Merge branch 'john/erts/efile-nif'

OTP-14256
OTP-14797

5 files changed, 4373 insertions, 0 deletions

diff --git a/erts/emulator/nifs/common/prim_buffer_nif.c b/erts/emulator/nifs/common/prim_buffer_nif.c
new file mode 100644
index 0000000000..a8ef5fc355
--- /dev/null
+++ b/erts/emulator/nifs/common/prim_buffer_nif.c
@@ -0,0 +1,512 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson 2017. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * %CopyrightEnd%
+ */
+
+#define STATIC_ERLANG_NIF 1
+
+#include "erl_nif.h"
+#include "config.h"
+#include "sys.h"
+
+#ifdef VALGRIND
+#  include <valgrind/memcheck.h>
+#endif
+
+#define ACCUMULATOR_SIZE (2 << 10)
+
+#define FIND_NIF_RESCHEDULE_SIZE (1 << 20)
+
+/* NIF interface declarations */
+static int load(ErlNifEnv *env, void** priv_data, ERL_NIF_TERM load_info);
+static int upgrade(ErlNifEnv *env, void** priv_data, void** old_priv_data, ERL_NIF_TERM load_info);
+static void unload(ErlNifEnv *env, void* priv_data);
+
+static ErlNifResourceType *rtype_buffer;
+
+static ERL_NIF_TERM am_ok;
+static ERL_NIF_TERM am_error;
+
+static ERL_NIF_TERM am_lock_order_violation;
+
+static ERL_NIF_TERM am_acquired;
+static ERL_NIF_TERM am_busy;
+
+static ERL_NIF_TERM am_continue;
+
+static ERL_NIF_TERM am_out_of_memory;
+static ERL_NIF_TERM am_not_found;
+
+typedef struct {
+#ifdef DEBUG
+    erts_atomic32_t concurrent_users;
+#endif
+
+    ErlNifBinary accumulator;
+    size_t accumulated_bytes;
+    int accumulator_present;
+
+    ErlNifIOQueue *queue;
+
+    erts_atomic32_t external_lock;
+} buffer_data_t;
+
+static ERL_NIF_TERM new_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+
+static ERL_NIF_TERM peek_head_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM skip_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM size_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+
+static ERL_NIF_TERM write_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM copying_read_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+
+static ERL_NIF_TERM find_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+
+static ERL_NIF_TERM trylock_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM unlock_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+
+static ErlNifFunc nif_funcs[] = {
+    {"new", 0, new_nif},
+    {"size", 1, size_nif},
+    {"peek_head", 1, peek_head_nif},
+    {"copying_read", 2, copying_read_nif},
+    {"write", 2, write_nif},
+    {"skip", 2, skip_nif},
+    {"find_byte_index", 2, find_nif},
+    {"try_lock", 1, trylock_nif},
+    {"unlock", 1, unlock_nif},
+};
+
+ERL_NIF_INIT(prim_buffer, nif_funcs, load, NULL, upgrade, unload)
+
+static void gc_buffer(ErlNifEnv *env, void* data);
+
+static int load(ErlNifEnv *env, void** priv_data, ERL_NIF_TERM load_info)
+{
+    am_ok = enif_make_atom(env, "ok");
+    am_error = enif_make_atom(env, "error");
+
+    am_lock_order_violation = enif_make_atom(env, "lock_order_violation");
+    am_acquired = enif_make_atom(env, "acquired");
+    am_busy = enif_make_atom(env, "busy");
+
+    am_continue = enif_make_atom(env, "continue");
+
+    am_out_of_memory = enif_make_atom(env, "out_of_memory");
+    am_not_found = enif_make_atom(env, "not_found");
+
+    rtype_buffer = enif_open_resource_type(env, NULL, "gc_buffer", gc_buffer,
+        ERL_NIF_RT_CREATE, NULL);
+
+    *priv_data = NULL;
+
+    return 0;
+}
+
+static void unload(ErlNifEnv *env, void* priv_data)
+{
+
+}
+
+static int upgrade(ErlNifEnv *env, void** priv_data, void** old_priv_data, ERL_NIF_TERM load_info)
+{
+    if(*old_priv_data != NULL) {
+        return -1; /* Don't know how to do that */
+    }
+
+    if(*priv_data != NULL) {
+        return -1; /* Don't know how to do that */
+    }
+
+    if(load(env, priv_data, load_info)) {
+        return -1;
+    }
+
+    return 0;
+}
+
+static void gc_buffer(ErlNifEnv *env, void* data) {
+    buffer_data_t *buffer = (buffer_data_t*)data;
+
+    if(buffer->accumulator_present) {
+        enif_release_binary(&buffer->accumulator);
+    }
+
+    enif_ioq_destroy(buffer->queue);
+}
+
+static int get_buffer_data(ErlNifEnv *env, ERL_NIF_TERM opaque, buffer_data_t **buffer) {
+    return enif_get_resource(env, opaque, rtype_buffer, (void **)buffer);
+}
+
+/* Copies a number of bytes from the head of the iovec, skipping "vec_skip"
+ * vector elements followed by "byte_skip" bytes on the target vector. */
+static void copy_from_iovec(SysIOVec *iovec, int vec_len, int vec_skip,
+        size_t byte_skip, size_t size, char *data) {
+
+    size_t bytes_copied, skip_offset;
+    int vec_index;
+
+    skip_offset = byte_skip;
+    vec_index = vec_skip;
+    bytes_copied = 0;
+
+    while(bytes_copied < size) {
+        size_t block_size, copy_size;
+        char *block_start;
+
+        ASSERT(vec_index < vec_len);
+
+        block_start = (char*)iovec[vec_index].iov_base;
+        block_size = iovec[vec_index].iov_len;
+
+        copy_size = MIN(size - bytes_copied, block_size - skip_offset);
+        sys_memcpy(&data[bytes_copied], &block_start[skip_offset], copy_size);
+
+        bytes_copied += copy_size;
+        skip_offset = 0;
+
+        vec_index++;
+    }
+}
+
+/* Convenience function for copy_from_iovec over queues. */
+static void copy_from_queue(ErlNifIOQueue *queue, int queue_skip,
+    size_t byte_skip, size_t size, char *data) {
+
+    SysIOVec *queued_data;
+    int queue_length;
+
+    queued_data = enif_ioq_peek(queue, &queue_length);
+    ASSERT(queue_skip < queue_length);
+
+    copy_from_iovec(queued_data, queue_length, queue_skip, byte_skip, size, data);
+}
+
+static int enqueue_write_accumulator(buffer_data_t *buffer) {
+    ASSERT(!buffer->accumulator_present ^ (buffer->accumulated_bytes > 0));
+
+    if(buffer->accumulator_present && buffer->accumulated_bytes > 0) {
+        if(!enif_realloc_binary(&buffer->accumulator, buffer->accumulated_bytes)) {
+            return 0;
+        } else if(!enif_ioq_enq_binary(buffer->queue, &buffer->accumulator, 0)) {
+            return 0;
+        }
+
+        /* The queue owns the accumulator now. */
+        buffer->accumulator_present = 0;
+        buffer->accumulated_bytes = 0;
+    }
+
+    return 1;
+}
+
+static int combine_small_writes(buffer_data_t *buffer, ErlNifIOVec *iovec) {
+    ASSERT(!buffer->accumulator_present ^ (buffer->accumulated_bytes > 0));
+
+    if(buffer->accumulated_bytes + iovec->size >= ACCUMULATOR_SIZE) {
+        if(iovec->size >= (ACCUMULATOR_SIZE / 2)) {
+            return 0;
+        }
+
+        if(!enqueue_write_accumulator(buffer)) {
+            return 0;
+        }
+    }
+
+    if(!buffer->accumulator_present) {
+        if(!enif_alloc_binary(ACCUMULATOR_SIZE, &buffer->accumulator)) {
+            return 0;
+        }
+
+        buffer->accumulator_present = 1;
+    }
+
+    copy_from_iovec(iovec->iov, iovec->iovcnt, 0, 0, iovec->size,
+            (char*)&buffer->accumulator.data[buffer->accumulated_bytes]);
+    buffer->accumulated_bytes += iovec->size;
+
+    return 1;
+}
+
+/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
+
+static ERL_NIF_TERM new_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    buffer_data_t *buffer;
+    ERL_NIF_TERM result;
+
+    buffer = (buffer_data_t*)enif_alloc_resource(rtype_buffer, sizeof(buffer_data_t));
+    buffer->queue = enif_ioq_create(ERL_NIF_IOQ_NORMAL);
+
+    if(buffer->queue != NULL) {
+#ifdef DEBUG
+        erts_atomic32_init_nob(&buffer->concurrent_users, 0);
+#endif
+        erts_atomic32_init_nob(&buffer->external_lock, 0);
+
+        buffer->accumulator_present = 0;
+        buffer->accumulated_bytes = 0;
+
+        result = enif_make_resource(env, buffer);
+    } else {
+        result = enif_raise_exception(env, am_out_of_memory);
+    }
+
+    enif_release_resource(buffer);
+
+    return result;
+}
+
+static ERL_NIF_TERM size_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    buffer_data_t *buffer;
+
+    size_t total_size;
+
+    if(argc != 1 || !get_buffer_data(env, argv[0], &buffer)) {
+        return enif_make_badarg(env);
+    }
+
+    ASSERT(erts_atomic32_inc_read_acqb(&buffer->concurrent_users) == 1);
+
+    total_size = enif_ioq_size(buffer->queue);
+
+    if(buffer->accumulator_present) {
+        total_size += buffer->accumulated_bytes;
+    } else {
+        ASSERT(buffer->accumulated_bytes == 0);
+    }
+
+    ASSERT(erts_atomic32_dec_read_relb(&buffer->concurrent_users) == 0);
+
+    return enif_make_uint64(env, total_size);
+}
+
+static ERL_NIF_TERM copying_read_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    buffer_data_t *buffer;
+
+    ERL_NIF_TERM result;
+    unsigned char *data;
+    Uint64 block_size;
+
+    if(argc != 2 || !get_buffer_data(env, argv[0], &buffer)
+                 || !enif_get_uint64(env, argv[1], &block_size)) {
+        return enif_make_badarg(env);
+    }
+
+    ASSERT(erts_atomic32_inc_read_acqb(&buffer->concurrent_users) == 1);
+
+    if(!enqueue_write_accumulator(buffer)) {
+        return enif_raise_exception(env, am_out_of_memory);
+    }
+
+    if(enif_ioq_size(buffer->queue) < block_size) {
+        return enif_make_badarg(env);
+    }
+
+    data = enif_make_new_binary(env, block_size, &result);
+
+    if(block_size > 0) {
+        copy_from_queue(buffer->queue, 0, 0, block_size, (char*)data);
+        enif_ioq_deq(buffer->queue, block_size, NULL);
+    }
+
+    ASSERT(erts_atomic32_dec_read_relb(&buffer->concurrent_users) == 0);
+
+    return result;
+}
+
+static ERL_NIF_TERM write_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    buffer_data_t *buffer;
+
+    ErlNifIOVec vec, *iovec = &vec;
+    ERL_NIF_TERM tail;
+
+    if(argc != 2 || !get_buffer_data(env, argv[0], &buffer)
+                 || !enif_inspect_iovec(env, 64, argv[1], &tail, &iovec)) {
+        return enif_make_badarg(env);
+    }
+
+    ASSERT(erts_atomic32_inc_read_acqb(&buffer->concurrent_users) == 1);
+
+    if(!combine_small_writes(buffer, iovec)) {
+        if(!enqueue_write_accumulator(buffer) || !enif_ioq_enqv(buffer->queue, iovec, 0)) {
+            return enif_raise_exception(env, am_out_of_memory);
+        }
+    }
+
+    ASSERT(erts_atomic32_dec_read_relb(&buffer->concurrent_users) == 0);
+
+    if(!enif_is_empty_list(env, tail)) {
+        const ERL_NIF_TERM new_argv[2] = {argv[0], tail};
+
+        return enif_schedule_nif(env, "write", 0, &write_nif, argc, new_argv);
+    }
+
+    return am_ok;
+}
+
+static ERL_NIF_TERM peek_head_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    buffer_data_t *buffer;
+
+    ERL_NIF_TERM result;
+
+    if(argc != 1 || !get_buffer_data(env, argv[0], &buffer)) {
+        return enif_make_badarg(env);
+    }
+
+    ASSERT(erts_atomic32_inc_read_acqb(&buffer->concurrent_users) == 1);
+
+    if(!enqueue_write_accumulator(buffer)) {
+        return enif_raise_exception(env, am_out_of_memory);
+    }
+
+    if(!enif_ioq_peek_head(env, buffer->queue, NULL, &result)) {
+        return enif_make_badarg(env);
+    }
+
+    ASSERT(erts_atomic32_dec_read_relb(&buffer->concurrent_users) == 0);
+
+    return result;
+}
+
+static ERL_NIF_TERM skip_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    buffer_data_t *buffer;
+
+    Uint64 block_size;
+
+    if(argc != 2 || !get_buffer_data(env, argv[0], &buffer)
+                 || !enif_get_uint64(env, argv[1], &block_size)) {
+        return enif_make_badarg(env);
+    }
+
+    ASSERT(erts_atomic32_inc_read_acqb(&buffer->concurrent_users) == 1);
+
+    if(!enqueue_write_accumulator(buffer)) {
+        return enif_raise_exception(env, am_out_of_memory);
+    } else if(enif_ioq_size(buffer->queue) < block_size) {
+        return enif_make_badarg(env);
+    }
+
+    enif_ioq_deq(buffer->queue, block_size, NULL);
+
+    ASSERT(erts_atomic32_dec_read_relb(&buffer->concurrent_users) == 0);
+
+    return am_ok;
+}
+
+static ERL_NIF_TERM find_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    buffer_data_t *buffer;
+
+    int queue_length, queue_index;
+    SysIOVec *queued_data;
+    size_t queue_size;
+
+    size_t search_offset;
+    int needle;
+
+    if(argc != 2 || !get_buffer_data(env, argv[0], &buffer)
+                 || !enif_get_int(env, argv[1], &needle)) {
+        return enif_make_badarg(env);
+    }
+
+    ASSERT(erts_atomic32_inc_read_acqb(&buffer->concurrent_users) == 1);
+
+    if(!enqueue_write_accumulator(buffer)) {
+        return enif_raise_exception(env, am_out_of_memory);
+    } else if(needle < 0 || needle > 255) {
+        return enif_make_badarg(env);
+    }
+
+    queued_data = enif_ioq_peek(buffer->queue, &queue_length);
+    queue_size = enif_ioq_size(buffer->queue);
+    queue_index = 0;
+
+    search_offset = 0;
+
+    if(queue_size > (FIND_NIF_RESCHEDULE_SIZE / 100)) {
+        if(enif_thread_type() == ERL_NIF_THR_NORMAL_SCHEDULER) {
+            int timeslice_percent;
+
+            if(queue_size >= FIND_NIF_RESCHEDULE_SIZE) {
+                ASSERT(erts_atomic32_dec_read_relb(&buffer->concurrent_users) == 0);
+
+                return enif_schedule_nif(env, "find",
+                    ERL_NIF_DIRTY_JOB_CPU_BOUND, &find_nif, argc, argv);
+            }
+
+            timeslice_percent = (queue_size * 100) / FIND_NIF_RESCHEDULE_SIZE;
+            enif_consume_timeslice(env, timeslice_percent);
+        }
+    }
+
+    while(queue_index < queue_length) {
+        char *needle_address;
+        char *block_start;
+        size_t block_size;
+
+        block_start = queued_data[queue_index].iov_base;
+        block_size = queued_data[queue_index].iov_len;
+
+        needle_address = memchr(block_start, needle, block_size);
+
+        if(needle_address != NULL) {
+            size_t result = search_offset + (needle_address - block_start);
+
+            ASSERT(erts_atomic32_dec_read_relb(&buffer->concurrent_users) == 0);
+
+            return enif_make_tuple2(env, am_ok, enif_make_uint64(env, result));
+        }
+
+        search_offset += block_size;
+        queue_index++;
+    }
+
+    ASSERT(erts_atomic32_dec_read_relb(&buffer->concurrent_users) == 0);
+
+    return am_not_found;
+}
+
+/* */
+
+static ERL_NIF_TERM trylock_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    buffer_data_t *buffer;
+
+    if(argc != 1 || !get_buffer_data(env, argv[0], &buffer)) {
+        return enif_make_badarg(env);
+    }
+
+    if(erts_atomic32_cmpxchg_acqb(&buffer->external_lock, 1, 0) == 0) {
+        return am_acquired;
+    }
+
+    return am_busy;
+}
+
+static ERL_NIF_TERM unlock_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    buffer_data_t *buffer;
+
+    if(argc != 1 || !get_buffer_data(env, argv[0], &buffer)) {
+        return enif_make_badarg(env);
+    }
+
+    if(erts_atomic32_cmpxchg_relb(&buffer->external_lock, 0, 1) == 0) {
+        return enif_raise_exception(env, am_lock_order_violation);
+    }
+
+    return am_ok;
+}
diff --git a/erts/emulator/nifs/common/prim_file_nif.c b/erts/emulator/nifs/common/prim_file_nif.c
new file mode 100644
index 0000000000..6874f41d75
--- /dev/null
+++ b/erts/emulator/nifs/common/prim_file_nif.c
@@ -0,0 +1,1237 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson 2017. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * %CopyrightEnd%
+ */
+
+#define STATIC_ERLANG_NIF 1
+
+#include "erl_nif.h"
+#include "config.h"
+#include "sys.h"
+
+#ifdef VALGRIND
+#  include <valgrind/memcheck.h>
+#endif
+
+#include "erl_driver.h"
+#include "prim_file_nif.h"
+
+/* NIF interface declarations */
+static int load(ErlNifEnv *env, void** priv_data, ERL_NIF_TERM load_info);
+static int upgrade(ErlNifEnv *env, void** priv_data, void** old_priv_data, ERL_NIF_TERM load_info);
+static void unload(ErlNifEnv *env, void* priv_data);
+
+static ErlNifResourceType *efile_resource_type;
+
+static ERL_NIF_TERM am_ok;
+static ERL_NIF_TERM am_error;
+static ERL_NIF_TERM am_continue;
+
+static ERL_NIF_TERM am_file_info;
+
+/* File modes */
+static ERL_NIF_TERM am_read;
+static ERL_NIF_TERM am_write;
+static ERL_NIF_TERM am_exclusive;
+static ERL_NIF_TERM am_append;
+static ERL_NIF_TERM am_sync;
+static ERL_NIF_TERM am_skip_type_check;
+
+/* enum efile_access_t; read and write are defined above.*/
+static ERL_NIF_TERM am_read_write;
+static ERL_NIF_TERM am_none;
+
+/* enum efile_advise_t */
+static ERL_NIF_TERM am_normal;
+static ERL_NIF_TERM am_random;
+static ERL_NIF_TERM am_sequential;
+static ERL_NIF_TERM am_will_need;
+static ERL_NIF_TERM am_dont_need;
+static ERL_NIF_TERM am_no_reuse;
+
+/* enum efile_filetype_t */
+static ERL_NIF_TERM am_device;
+static ERL_NIF_TERM am_directory;
+static ERL_NIF_TERM am_regular;
+static ERL_NIF_TERM am_symlink;
+static ERL_NIF_TERM am_other;
+
+/* enum efile_seek_t, 'eof' marker. */
+static ERL_NIF_TERM am_bof;
+static ERL_NIF_TERM am_cur;
+static ERL_NIF_TERM am_eof;
+
+static ERL_NIF_TERM read_info_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM set_permissions_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM set_owner_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM set_time_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+
+static ERL_NIF_TERM read_link_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM list_dir_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+
+static ERL_NIF_TERM make_hard_link_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM make_soft_link_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM rename_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM make_dir_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM del_file_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM del_dir_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM get_device_cwd_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM get_cwd_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM set_cwd_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+
+static ERL_NIF_TERM read_file_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+
+static ERL_NIF_TERM get_handle_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM altname_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+
+static ERL_NIF_TERM open_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+
+/* All file handle operations are passed through a wrapper that handles state
+ * transitions, marking it as busy during the course of the operation, and
+ * closing on completion if the owner died in the middle of an operation.
+ *
+ * This is pretty ugly but required as there's no way to tell when it's safe to
+ * asynchronously close a file; the event could have fired just before landing
+ * in a system call which will fail with EBADF at best or alias a newly opened
+ * fd at worst.
+ *
+ * The old driver got away with enqueueing the close operation on the same
+ * async queue as all of its other operations, but since dirty schedulers use a
+ * single global queue there's no natural way to schedule an asynchronous close
+ * "behind" other operations.
+ *
+ * The states may transition as follows:
+ *
+ * IDLE ->
+ *      BUSY (file_handle_wrapper) |
+ *      CLOSED (owner_death_callback)
+ *
+ * BUSY ->
+ *      IDLE (file_handle_wrapper)
+ *      CLOSED (close_nif_impl)
+ *      CLOSE_PENDING (owner_death_callback)
+ *
+ * CLOSE_PENDING ->
+ *      CLOSED (file_handle_wrapper)
+ */
+
+typedef ERL_NIF_TERM (*file_op_impl_t)(efile_data_t *d, ErlNifEnv *env,
+    int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM file_handle_wrapper(file_op_impl_t operation, ErlNifEnv *env,
+    int argc, const ERL_NIF_TERM argv[]);
+
+#define WRAP_FILE_HANDLE_EXPORT(name) \
+    static ERL_NIF_TERM name ## _impl (efile_data_t *d, ErlNifEnv *env, \
+        int argc, const ERL_NIF_TERM argv[]);\
+    static ERL_NIF_TERM name(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { \
+        return file_handle_wrapper( name ## _impl , env, argc, argv); \
+    }
+
+WRAP_FILE_HANDLE_EXPORT(close_nif)
+WRAP_FILE_HANDLE_EXPORT(read_nif)
+WRAP_FILE_HANDLE_EXPORT(write_nif)
+WRAP_FILE_HANDLE_EXPORT(pread_nif)
+WRAP_FILE_HANDLE_EXPORT(pwrite_nif)
+WRAP_FILE_HANDLE_EXPORT(seek_nif)
+WRAP_FILE_HANDLE_EXPORT(sync_nif)
+WRAP_FILE_HANDLE_EXPORT(truncate_nif)
+WRAP_FILE_HANDLE_EXPORT(allocate_nif)
+WRAP_FILE_HANDLE_EXPORT(advise_nif)
+WRAP_FILE_HANDLE_EXPORT(get_handle_nif)
+WRAP_FILE_HANDLE_EXPORT(ipread_s32bu_p32bu_nif)
+
+static ErlNifFunc nif_funcs[] = {
+    /* File handle ops */
+    {"open_nif", 2, open_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"close_nif", 1, close_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"read_nif", 2, read_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"write_nif", 2, write_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"pread_nif", 3, pread_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"pwrite_nif", 3, pwrite_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"seek_nif", 3, seek_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"sync_nif", 2, sync_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"truncate_nif", 1, truncate_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"allocate_nif", 3, allocate_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"advise_nif", 4, advise_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+
+    /* Filesystem ops */
+    {"make_hard_link_nif", 2, make_hard_link_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"make_soft_link_nif", 2, make_soft_link_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"rename_nif", 2, rename_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"read_info_nif", 2, read_info_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"set_permissions_nif", 2, set_permissions_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"set_owner_nif", 3, set_owner_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"set_time_nif", 4, set_time_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"read_link_nif", 1, read_link_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"list_dir_nif", 1, list_dir_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"make_dir_nif", 1, make_dir_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"del_file_nif", 1, del_file_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"del_dir_nif", 1, del_dir_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"get_device_cwd_nif", 1, get_device_cwd_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"set_cwd_nif", 1, set_cwd_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"get_cwd_nif", 0, get_cwd_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+
+    /* These operations are equivalent to chained calls of other operations,
+     * but have been moved down to avoid excessive rescheduling. */
+    {"ipread_s32bu_p32bu_nif", 3, ipread_s32bu_p32bu_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"read_file_nif", 1, read_file_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+
+    /* Internal ops. */
+    {"get_handle_nif", 1, get_handle_nif},
+    {"altname_nif", 1, altname_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+};
+
+ERL_NIF_INIT(prim_file, nif_funcs, load, NULL, upgrade, unload)
+
+static void owner_death_callback(ErlNifEnv* env, void* obj, ErlNifPid* pid, ErlNifMonitor* mon);
+static void gc_callback(ErlNifEnv *env, void* data);
+
+static int load(ErlNifEnv *env, void** priv_data, ERL_NIF_TERM load_info)
+{
+    ErlNifResourceTypeInit callbacks;
+
+    am_ok = enif_make_atom(env, "ok");
+    am_error = enif_make_atom(env, "error");
+    am_continue = enif_make_atom(env, "continue");
+
+    am_read = enif_make_atom(env, "read");
+    am_write = enif_make_atom(env, "write");
+    am_exclusive = enif_make_atom(env, "exclusive");
+    am_append = enif_make_atom(env, "append");
+    am_sync = enif_make_atom(env, "sync");
+    am_skip_type_check = enif_make_atom(env, "skip_type_check");
+
+    am_read_write = enif_make_atom(env, "read_write");
+    am_none = enif_make_atom(env, "none");
+
+    am_normal = enif_make_atom(env, "normal");
+    am_random = enif_make_atom(env, "random");
+    am_sequential = enif_make_atom(env, "sequential");
+    am_will_need = enif_make_atom(env, "will_need");
+    am_dont_need = enif_make_atom(env, "dont_need");
+    am_no_reuse = enif_make_atom(env, "no_reuse");
+
+    am_device = enif_make_atom(env, "device");
+    am_directory = enif_make_atom(env, "directory");
+    am_regular = enif_make_atom(env, "regular");
+    am_symlink = enif_make_atom(env, "symlink");
+    am_other = enif_make_atom(env, "other");
+
+    am_file_info = enif_make_atom(env, "file_info");
+
+    am_bof = enif_make_atom(env, "bof");
+    am_cur = enif_make_atom(env, "cur");
+    am_eof = enif_make_atom(env, "eof");
+
+    callbacks.down = owner_death_callback;
+    callbacks.dtor = gc_callback;
+    callbacks.stop = NULL;
+
+    efile_resource_type = enif_open_resource_type_x(env, "efile", &callbacks,
+        ERL_NIF_RT_CREATE, NULL);
+
+    *priv_data = NULL;
+
+    return 0;
+}
+
+static void unload(ErlNifEnv *env, void* priv_data)
+{
+
+}
+
+static int upgrade(ErlNifEnv *env, void** priv_data, void** old_priv_data, ERL_NIF_TERM load_info)
+{
+    if(*old_priv_data != NULL) {
+        return -1; /* Don't know how to do that */
+    }
+    if(*priv_data != NULL) {
+        return -1; /* Don't know how to do that */
+    }
+    if(load(env, priv_data, load_info)) {
+        return -1;
+    }
+    return 0;
+}
+
+static ERL_NIF_TERM posix_error_to_tuple(ErlNifEnv *env, posix_errno_t posix_errno) {
+    ERL_NIF_TERM error = enif_make_atom(env, erl_errno_id(posix_errno));
+    return enif_make_tuple2(env, am_error, error);
+}
+
+static int get_file_data(ErlNifEnv *env, ERL_NIF_TERM opaque, efile_data_t **d) {
+    return enif_get_resource(env, opaque, efile_resource_type, (void **)d);
+}
+
+static ERL_NIF_TERM file_handle_wrapper(file_op_impl_t operation, ErlNifEnv *env,
+        int argc, const ERL_NIF_TERM argv[]) {
+
+    efile_data_t *d;
+
+    enum efile_state_t previous_state;
+    ERL_NIF_TERM result;
+
+    if(argc < 1 || !get_file_data(env, argv[0], &d)) {
+        return enif_make_badarg(env);
+    }
+
+    previous_state = erts_atomic32_cmpxchg_acqb(&d->state,
+        EFILE_STATE_BUSY, EFILE_STATE_IDLE);
+
+    if(previous_state == EFILE_STATE_IDLE) {
+        result = operation(d, env, argc - 1, &argv[1]);
+
+        previous_state = erts_atomic32_cmpxchg_relb(&d->state,
+            EFILE_STATE_IDLE, EFILE_STATE_BUSY);
+
+        ASSERT(previous_state != EFILE_STATE_IDLE);
+
+        if(previous_state == EFILE_STATE_CLOSE_PENDING) {
+            /* This is the only point where a change from CLOSE_PENDING is
+             * possible, and we're running synchronously, so we can't race with
+             * anything else here. */
+            erts_atomic32_set_acqb(&d->state, EFILE_STATE_CLOSED);
+            efile_close(d);
+        }
+    } else {
+        /* CLOSE_PENDING should be impossible at this point since it requires
+         * a transition from BUSY; the only valid state here is CLOSED. */
+        ASSERT(previous_state == EFILE_STATE_CLOSED);
+
+        result = posix_error_to_tuple(env, EINVAL);
+    }
+
+    return result;
+}
+
+static void owner_death_callback(ErlNifEnv* env, void* obj, ErlNifPid* pid, ErlNifMonitor* mon) {
+    efile_data_t *d = (efile_data_t*)obj;
+
+    (void)env;
+    (void)pid;
+    (void)mon;
+
+    for(;;) {
+        enum efile_state_t previous_state;
+
+        previous_state = erts_atomic32_cmpxchg_acqb(&d->state,
+            EFILE_STATE_CLOSED, EFILE_STATE_IDLE);
+
+        switch(previous_state) {
+        case EFILE_STATE_IDLE:
+            efile_close(d);
+            return;
+        case EFILE_STATE_CLOSE_PENDING:
+        case EFILE_STATE_CLOSED:
+            /* We're either already closed or managed to mark ourselves for
+             * closure in the previous iteration. */
+            return;
+        case EFILE_STATE_BUSY:
+            /* Schedule ourselves to be closed once the current operation
+             * finishes, retrying the [IDLE -> CLOSED] transition in case we
+             * narrowly passed the [BUSY -> IDLE] one. */
+            erts_atomic32_cmpxchg_nob(&d->state,
+                EFILE_STATE_CLOSE_PENDING, EFILE_STATE_BUSY);
+            break;
+        }
+    }
+}
+
+static void gc_callback(ErlNifEnv *env, void* data) {
+    efile_data_t *d = (efile_data_t*)data;
+
+    enum efile_state_t previous_state;
+
+    (void)env;
+
+    previous_state = erts_atomic32_cmpxchg_acqb(&d->state,
+        EFILE_STATE_CLOSED, EFILE_STATE_IDLE);
+
+    ASSERT(previous_state != EFILE_STATE_CLOSE_PENDING &&
+        previous_state != EFILE_STATE_BUSY);
+
+    if(previous_state == EFILE_STATE_IDLE) {
+        efile_close(d);
+    }
+}
+
+static ERL_NIF_TERM efile_filetype_to_atom(enum efile_filetype_t type) {
+    switch(type) {
+        case EFILE_FILETYPE_DEVICE: return am_device;
+        case EFILE_FILETYPE_DIRECTORY: return am_directory;
+        case EFILE_FILETYPE_REGULAR: return am_regular;
+        case EFILE_FILETYPE_SYMLINK: return am_symlink;
+        case EFILE_FILETYPE_OTHER: return am_other;
+    }
+
+    return am_other;
+}
+
+static ERL_NIF_TERM efile_access_to_atom(enum efile_access_t type) {
+    if(type & EFILE_ACCESS_READ && !(type & EFILE_ACCESS_WRITE)) {
+        return am_read;
+    } else if(type & EFILE_ACCESS_WRITE && !(type & EFILE_ACCESS_READ)) {
+        return am_write;
+    } else if(type & EFILE_ACCESS_READ_WRITE) {
+        return am_read_write;
+    }
+
+    return am_none;
+}
+
+static enum efile_modes_t efile_translate_modelist(ErlNifEnv *env, ERL_NIF_TERM list) {
+    enum efile_modes_t modes;
+    ERL_NIF_TERM head, tail;
+
+    modes = 0;
+
+    while(enif_get_list_cell(env, list, &head, &tail)) {
+        if(enif_is_identical(head, am_read)) {
+            modes |= EFILE_MODE_READ;
+        } else if(enif_is_identical(head, am_write)) {
+            modes |= EFILE_MODE_WRITE;
+        } else if(enif_is_identical(head, am_exclusive)) {
+            modes |= EFILE_MODE_EXCLUSIVE;
+        } else if(enif_is_identical(head, am_append)) {
+            modes |= EFILE_MODE_APPEND;
+        } else if(enif_is_identical(head, am_sync)) {
+            modes |= EFILE_MODE_SYNC;
+        } else if(enif_is_identical(head, am_skip_type_check)) {
+            modes |= EFILE_MODE_SKIP_TYPE_CHECK;
+        } else {
+            /* Modes like 'raw', 'ram', 'delayed_writes' etc are handled
+             * further up the chain. */
+        }
+
+        list = tail;
+    }
+
+    if(modes & (EFILE_MODE_APPEND | EFILE_MODE_EXCLUSIVE)) {
+        /* 'append' and 'exclusive' are documented as "open for writing." */
+        modes |= EFILE_MODE_WRITE;
+    } else if(!(modes & EFILE_MODE_READ_WRITE)) {
+        /* Defaulting to read if !(W|R) is undocumented, but specifically
+         * tested against in file_SUITE. */
+        modes |= EFILE_MODE_READ;
+    }
+
+    return modes;
+}
+
+static ERL_NIF_TERM open_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    posix_errno_t posix_errno;
+    efile_data_t *d;
+
+    ErlNifPid controlling_process;
+    enum efile_modes_t modes;
+    ERL_NIF_TERM result;
+    efile_path_t path;
+
+    if(argc != 2 || !enif_is_list(env, argv[1])) {
+        return enif_make_badarg(env);
+    }
+
+    modes = efile_translate_modelist(env, argv[1]);
+
+    if((posix_errno = efile_marshal_path(env, argv[0], &path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    } else if((posix_errno = efile_open(&path, modes, efile_resource_type, &d))) {
+        return posix_error_to_tuple(env, posix_errno);
+    }
+
+    result = enif_make_resource(env, d);
+    enif_release_resource(d);
+
+    enif_self(env, &controlling_process);
+
+    if(enif_monitor_process(env, d, &controlling_process, &d->monitor)) {
+        return posix_error_to_tuple(env, EINVAL);
+    }
+
+    return enif_make_tuple2(env, am_ok, result);
+}
+
+static ERL_NIF_TERM close_nif_impl(efile_data_t *d, ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    enum efile_state_t previous_state;
+
+    if(argc != 0) {
+        return enif_make_badarg(env);
+    }
+
+    previous_state = erts_atomic32_cmpxchg_acqb(&d->state,
+        EFILE_STATE_CLOSED, EFILE_STATE_BUSY);
+
+    ASSERT(previous_state == EFILE_STATE_CLOSE_PENDING ||
+        previous_state == EFILE_STATE_BUSY);
+
+    if(previous_state == EFILE_STATE_BUSY) {
+        enif_demonitor_process(env, d, &d->monitor);
+
+        if(!efile_close(d)) {
+            return posix_error_to_tuple(env, d->posix_errno);
+        }
+    }
+
+    return am_ok;
+}
+
+static ERL_NIF_TERM read_nif_impl(efile_data_t *d, ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    Sint64 bytes_read, block_size;
+    SysIOVec read_vec[1];
+    ErlNifBinary result;
+
+    if(argc != 1 || !enif_is_number(env, argv[0])) {
+        return enif_make_badarg(env);
+    }
+
+    if(!enif_get_int64(env, argv[0], &block_size) || block_size < 0) {
+        return posix_error_to_tuple(env, EINVAL);
+    }
+
+    if(!enif_alloc_binary(block_size, &result)) {
+        return posix_error_to_tuple(env, ENOMEM);
+    }
+
+    read_vec[0].iov_base = result.data;
+    read_vec[0].iov_len = result.size;
+
+    bytes_read = efile_readv(d, read_vec, 1);
+    ASSERT(bytes_read <= block_size);
+
+    if(bytes_read < 0) {
+        return posix_error_to_tuple(env, d->posix_errno);
+    } else if(bytes_read == 0) {
+        enif_release_binary(&result);
+        return am_eof;
+    }
+
+    if(bytes_read < block_size && !enif_realloc_binary(&result, bytes_read)) {
+        ERTS_INTERNAL_ERROR("Failed to shrink read result.");
+    }
+
+    return enif_make_tuple2(env, am_ok, enif_make_binary(env, &result));
+}
+
+static ERL_NIF_TERM write_nif_impl(efile_data_t *d, ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    ErlNifIOVec vec, *input = &vec;
+    Sint64 bytes_written;
+    ERL_NIF_TERM tail;
+
+    if(argc != 1 || !enif_inspect_iovec(env, 64, argv[0], &tail, &input)) {
+        return enif_make_badarg(env);
+    }
+
+    bytes_written = efile_writev(d, input->iov, input->iovcnt);
+
+    if(bytes_written < 0) {
+        return posix_error_to_tuple(env, d->posix_errno);
+    }
+
+    if(!enif_is_empty_list(env, tail)) {
+        ASSERT(bytes_written > 0);
+        return enif_make_tuple2(env, am_continue, tail);
+    }
+
+    return am_ok;
+}
+
+static ERL_NIF_TERM pread_nif_impl(efile_data_t *d, ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    Sint64 bytes_read, block_size, offset;
+    SysIOVec read_vec[1];
+    ErlNifBinary result;
+
+    if(argc != 2 || !enif_is_number(env, argv[0])
+                 || !enif_is_number(env, argv[1])) {
+        return enif_make_badarg(env);
+    }
+
+    if(!enif_get_int64(env, argv[0], &offset) ||
+       !enif_get_int64(env, argv[1], &block_size) ||
+       (offset < 0 || block_size < 0)) {
+        return posix_error_to_tuple(env, EINVAL);
+    }
+
+    if(!enif_alloc_binary(block_size, &result)) {
+        return posix_error_to_tuple(env, ENOMEM);
+    }
+
+    read_vec[0].iov_base = result.data;
+    read_vec[0].iov_len = result.size;
+
+    bytes_read = efile_preadv(d, offset, read_vec, 1);
+
+    if(bytes_read < 0) {
+        return posix_error_to_tuple(env, d->posix_errno);
+    } else if(bytes_read == 0) {
+        enif_release_binary(&result);
+        return am_eof;
+    }
+
+    if(bytes_read < block_size && !enif_realloc_binary(&result, bytes_read)) {
+        ERTS_INTERNAL_ERROR("Failed to shrink pread result.");
+    }
+
+    return enif_make_tuple2(env, am_ok, enif_make_binary(env, &result));
+}
+
+static ERL_NIF_TERM pwrite_nif_impl(efile_data_t *d, ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    ErlNifIOVec vec, *input = &vec;
+    Sint64 bytes_written, offset;
+    ERL_NIF_TERM tail;
+
+    if(argc != 2 || !enif_is_number(env, argv[0])
+                 || !enif_inspect_iovec(env, 64, argv[1], &tail, &input)) {
+        return enif_make_badarg(env);
+    }
+
+    if(!enif_get_int64(env, argv[0], &offset) || offset < 0) {
+        return posix_error_to_tuple(env, EINVAL);
+    }
+
+    bytes_written = efile_pwritev(d, offset, input->iov, input->iovcnt);
+
+    if(bytes_written < 0) {
+        return posix_error_to_tuple(env, d->posix_errno);
+    }
+
+    if(!enif_is_empty_list(env, tail)) {
+        ASSERT(bytes_written > 0);
+        return enif_make_tuple3(env, am_continue,
+            enif_make_int64(env, bytes_written), tail);
+    }
+
+    return am_ok;
+}
+
+static ERL_NIF_TERM seek_nif_impl(efile_data_t *d, ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    Sint64 new_position, offset;
+    enum efile_seek_t seek;
+
+    if(argc != 2 || !enif_get_int64(env, argv[1], &offset)) {
+        return enif_make_badarg(env);
+    }
+
+    if(enif_is_identical(argv[0], am_bof)) {
+        seek = EFILE_SEEK_BOF;
+    } else if(enif_is_identical(argv[0], am_cur)) {
+        seek = EFILE_SEEK_CUR;
+    } else if(enif_is_identical(argv[0], am_eof)) {
+        seek = EFILE_SEEK_EOF;
+    } else {
+        return enif_make_badarg(env);
+    }
+
+    if(!efile_seek(d, seek, offset, &new_position)) {
+        return posix_error_to_tuple(env, d->posix_errno);
+    }
+
+    return enif_make_tuple2(env, am_ok, enif_make_uint64(env, new_position));
+}
+
+static ERL_NIF_TERM sync_nif_impl(efile_data_t *d, ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    int data_only;
+
+    if(argc != 1 || !enif_get_int(env, argv[0], &data_only)) {
+        return enif_make_badarg(env);
+    }
+
+    if(!efile_sync(d, data_only)) {
+        return posix_error_to_tuple(env, d->posix_errno);
+    }
+
+    return am_ok;
+}
+
+static ERL_NIF_TERM truncate_nif_impl(efile_data_t *d, ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    if(argc != 0) {
+        return enif_make_badarg(env);
+    }
+
+    if(!efile_truncate(d)) {
+        return posix_error_to_tuple(env, d->posix_errno);
+    }
+
+    return am_ok;
+}
+
+static ERL_NIF_TERM allocate_nif_impl(efile_data_t *d, ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    Sint64 offset, length;
+
+    if(argc != 2 || !enif_is_number(env, argv[0])
+                 || !enif_is_number(env, argv[1])) {
+        return enif_make_badarg(env);
+    }
+
+    if(!enif_get_int64(env, argv[0], &offset) ||
+       !enif_get_int64(env, argv[1], &length) ||
+       (offset < 0 || length < 0)) {
+        return posix_error_to_tuple(env, EINVAL);
+    }
+
+    if(!efile_allocate(d, offset, length)) {
+        return posix_error_to_tuple(env, d->posix_errno);
+    }
+
+    return am_ok;
+}
+
+static ERL_NIF_TERM advise_nif_impl(efile_data_t *d, ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    enum efile_advise_t advise;
+    Sint64 offset, length;
+
+    if(argc != 3 || !enif_is_number(env, argv[0])
+                 || !enif_is_number(env, argv[1])) {
+        return enif_make_badarg(env);
+    }
+
+    if(!enif_get_int64(env, argv[0], &offset) ||
+       !enif_get_int64(env, argv[1], &length) ||
+       (offset < 0 || length < 0)) {
+        return posix_error_to_tuple(env, EINVAL);
+    }
+
+    if(enif_is_identical(argv[2], am_normal)) {
+        advise = EFILE_ADVISE_NORMAL;
+    } else if(enif_is_identical(argv[2], am_random)) {
+        advise = EFILE_ADVISE_RANDOM;
+    } else if(enif_is_identical(argv[2], am_sequential)) {
+        advise = EFILE_ADVISE_SEQUENTIAL;
+    } else if(enif_is_identical(argv[2], am_will_need)) {
+        advise = EFILE_ADVISE_WILL_NEED;
+    } else if(enif_is_identical(argv[2], am_dont_need)) {
+        advise = EFILE_ADVISE_DONT_NEED;
+    } else if(enif_is_identical(argv[2], am_no_reuse)) {
+        advise = EFILE_ADVISE_NO_REUSE;
+    } else {
+        /* The tests check for EINVAL instead of badarg. Sigh. */
+        return posix_error_to_tuple(env, EINVAL);
+    }
+
+    if(!efile_advise(d, offset, length, advise)) {
+        return posix_error_to_tuple(env, d->posix_errno);
+    }
+
+    return am_ok;
+}
+
+/* This undocumented function reads a pointer and then reads the data block
+ * described by said pointer. It was reverse-engineered from the old
+ * implementation so while all tests pass it may not be entirely correct. Our
+ * current understanding is as follows:
+ *
+ * Pointer layout:
+ *
+ *     <<Size:1/integer-unit:32, Offset:1/integer-unit:32>>
+ *
+ * Where Offset is the -absolute- address to the data block.
+ *
+ * *) If we fail to read the pointer block in its entirety, we return eof.
+ * *) If the provided max_payload_size is larger than Size, we return eof.
+ * *) If we fail to read any data whatsoever at Offset, we return
+ *    {ok, {Size, Offset, eof}}
+ * *) Otherwise, we return {ok, {Size, Offset, Data}}. Note that the size
+ *    of Data may be smaller than Size if we encounter EOF before we could
+ *    read the entire block.
+ *
+ * On errors we'll return {error, posix()} regardless of whether they
+ * happened before or after reading the pointer block. */
+static ERL_NIF_TERM ipread_s32bu_p32bu_nif_impl(efile_data_t *d, ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    Sint64 payload_offset, payload_size;
+
+    SysIOVec read_vec[1];
+    Sint64 bytes_read;
+
+    ErlNifBinary payload;
+
+    if(argc != 2 || !enif_is_number(env, argv[0])
+                 || !enif_is_number(env, argv[1])) {
+        return enif_make_badarg(env);
+    }
+
+    {
+        Sint64 max_payload_size, pointer_offset;
+        unsigned char pointer_block[8];
+
+        if(!enif_get_int64(env, argv[0], &pointer_offset) ||
+           !enif_get_int64(env, argv[1], &max_payload_size) ||
+           (pointer_offset < 0 || max_payload_size >= 1u << 31)) {
+            return posix_error_to_tuple(env, EINVAL);
+        }
+
+        read_vec[0].iov_base = pointer_block;
+        read_vec[0].iov_len = sizeof(pointer_block);
+
+        bytes_read = efile_preadv(d, pointer_offset, read_vec, 1);
+
+        if(bytes_read < 0) {
+            return posix_error_to_tuple(env, d->posix_errno);
+        } else if(bytes_read < sizeof(pointer_block)) {
+            return am_eof;
+        }
+
+        payload_size = (Uint32)get_int32(&pointer_block[0]);
+        payload_offset = (Uint32)get_int32(&pointer_block[4]);
+
+        if(payload_size > max_payload_size) {
+            return am_eof;
+        }
+    }
+
+    if(!enif_alloc_binary(payload_size, &payload)) {
+        return posix_error_to_tuple(env, ENOMEM);
+    }
+
+    read_vec[0].iov_base = payload.data;
+    read_vec[0].iov_len = payload.size;
+
+    bytes_read = efile_preadv(d, payload_offset, read_vec, 1);
+
+    if(bytes_read < 0) {
+        return posix_error_to_tuple(env, d->posix_errno);
+    } else if(bytes_read == 0) {
+        enif_release_binary(&payload);
+
+        return enif_make_tuple2(env, am_ok,
+                enif_make_tuple3(env,
+                    enif_make_uint(env, payload_size),
+                    enif_make_uint(env, payload_offset),
+                    am_eof));
+    }
+
+    if(bytes_read < payload.size && !enif_realloc_binary(&payload, bytes_read)) {
+        ERTS_INTERNAL_ERROR("Failed to shrink ipread payload.");
+    }
+
+    return enif_make_tuple2(env, am_ok,
+        enif_make_tuple3(env,
+            enif_make_uint(env, payload_size),
+            enif_make_uint(env, payload_offset),
+            enif_make_binary(env, &payload)));
+}
+
+static ERL_NIF_TERM get_handle_nif_impl(efile_data_t *d, ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    if(argc != 0) {
+        return enif_make_badarg(env);
+    }
+
+    return efile_get_handle(env, d);
+}
+
+static ERL_NIF_TERM read_info_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    posix_errno_t posix_errno;
+
+    efile_fileinfo_t info = {0};
+    efile_path_t path;
+    int follow_links;
+
+    if(argc != 2 || !enif_get_int(env, argv[1], &follow_links)) {
+        return enif_make_badarg(env);
+    }
+
+    if((posix_errno = efile_marshal_path(env, argv[0], &path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    } else if((posix_errno = efile_read_info(&path, follow_links, &info))) {
+        return posix_error_to_tuple(env, posix_errno);
+    }
+
+    /* #file_info as declared in file.hrl */
+    return enif_make_tuple(env, 14,
+        am_file_info,
+        enif_make_uint64(env, info.size),
+        efile_filetype_to_atom(info.type),
+        efile_access_to_atom(info.access),
+        enif_make_int64(env, MAX(EFILE_MIN_FILETIME, info.a_time)),
+        enif_make_int64(env, MAX(EFILE_MIN_FILETIME, info.m_time)),
+        enif_make_int64(env, MAX(EFILE_MIN_FILETIME, info.c_time)),
+        enif_make_uint(env, info.mode),
+        enif_make_uint(env, info.links),
+        enif_make_uint(env, info.major_device),
+        enif_make_uint(env, info.minor_device),
+        enif_make_uint(env, info.inode),
+        enif_make_uint(env, info.uid),
+        enif_make_uint(env, info.gid)
+    );
+}
+
+static ERL_NIF_TERM set_permissions_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    posix_errno_t posix_errno;
+
+    efile_path_t path;
+    Uint32 permissions;
+
+    if(argc != 2 || !enif_get_uint(env, argv[1], &permissions)) {
+        return enif_make_badarg(env);
+    }
+
+    if((posix_errno = efile_marshal_path(env, argv[0], &path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    } else if((posix_errno = efile_set_permissions(&path, permissions))) {
+        return posix_error_to_tuple(env, posix_errno);
+    }
+
+    return am_ok;
+}
+
+static ERL_NIF_TERM set_owner_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    posix_errno_t posix_errno;
+
+    efile_path_t path;
+    Uint32 uid, gid;
+
+    if(argc != 3 || !enif_get_uint(env, argv[1], &uid)
+                 || !enif_get_uint(env, argv[2], &gid)) {
+        return enif_make_badarg(env);
+    }
+
+    if((posix_errno = efile_marshal_path(env, argv[0], &path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    } else if((posix_errno = efile_set_owner(&path, uid, gid))) {
+        return posix_error_to_tuple(env, posix_errno);
+    }
+
+    return am_ok;
+}
+
+static ERL_NIF_TERM set_time_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    posix_errno_t posix_errno;
+
+    Sint64 accessed, modified, created;
+    efile_path_t path;
+
+    if(argc != 4 || !enif_get_int64(env, argv[1], &accessed)
+                 || !enif_get_int64(env, argv[2], &modified)
+                 || !enif_get_int64(env, argv[3], &created)) {
+        return enif_make_badarg(env);
+    }
+
+    if((posix_errno = efile_marshal_path(env, argv[0], &path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    } else if((posix_errno = efile_set_time(&path, accessed, modified, created))) {
+        return posix_error_to_tuple(env, posix_errno);
+    }
+
+    return am_ok;
+}
+
+static ERL_NIF_TERM read_link_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    posix_errno_t posix_errno;
+
+    efile_path_t path;
+    ERL_NIF_TERM result;
+
+    if(argc != 1) {
+        return enif_make_badarg(env);
+    }
+
+    if((posix_errno = efile_marshal_path(env, argv[0], &path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    } else if((posix_errno = efile_read_link(env, &path, &result))) {
+        return posix_error_to_tuple(env, posix_errno);
+    }
+
+    return enif_make_tuple2(env, am_ok, result);
+}
+
+static ERL_NIF_TERM list_dir_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    posix_errno_t posix_errno;
+
+    efile_path_t path;
+    ERL_NIF_TERM result;
+
+    if(argc != 1) {
+        return enif_make_badarg(env);
+    }
+
+    if((posix_errno = efile_marshal_path(env, argv[0], &path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    } else if((posix_errno = efile_list_dir(env, &path, &result))) {
+        return posix_error_to_tuple(env, posix_errno);
+    }
+
+    return enif_make_tuple2(env, am_ok, result);
+}
+
+static ERL_NIF_TERM rename_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    posix_errno_t posix_errno;
+
+    efile_path_t existing_path, new_path;
+
+    if(argc != 2) {
+        return enif_make_badarg(env);
+    }
+
+    if((posix_errno = efile_marshal_path(env, argv[0], &existing_path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    } else if((posix_errno = efile_marshal_path(env, argv[1], &new_path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    } else if((posix_errno = efile_rename(&existing_path, &new_path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    }
+
+    return am_ok;
+}
+
+static ERL_NIF_TERM make_hard_link_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    posix_errno_t posix_errno;
+
+    efile_path_t existing_path, new_path;
+
+    if(argc != 2) {
+        return enif_make_badarg(env);
+    }
+
+    if((posix_errno = efile_marshal_path(env, argv[0], &existing_path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    } else if((posix_errno = efile_marshal_path(env, argv[1], &new_path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    } else if((posix_errno = efile_make_hard_link(&existing_path, &new_path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    }
+
+    return am_ok;
+}
+
+static ERL_NIF_TERM make_soft_link_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    posix_errno_t posix_errno;
+
+    efile_path_t existing_path, new_path;
+
+    if(argc != 2) {
+        return enif_make_badarg(env);
+    }
+
+    if((posix_errno = efile_marshal_path(env, argv[0], &existing_path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    } else if((posix_errno = efile_marshal_path(env, argv[1], &new_path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    } else if((posix_errno = efile_make_soft_link(&existing_path, &new_path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    }
+
+    return am_ok;
+}
+
+static ERL_NIF_TERM make_dir_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    posix_errno_t posix_errno;
+
+    efile_path_t path;
+
+    if(argc != 1) {
+        return enif_make_badarg(env);
+    }
+
+    if((posix_errno = efile_marshal_path(env, argv[0], &path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    } else if((posix_errno = efile_make_dir(&path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    }
+
+    return am_ok;
+}
+
+static ERL_NIF_TERM del_file_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    posix_errno_t posix_errno;
+
+    efile_path_t path;
+
+    if(argc != 1) {
+        return enif_make_badarg(env);
+    }
+
+    if((posix_errno = efile_marshal_path(env, argv[0], &path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    } else if((posix_errno = efile_del_file(&path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    }
+
+    return am_ok;
+}
+
+static ERL_NIF_TERM del_dir_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    posix_errno_t posix_errno;
+
+    efile_path_t path;
+
+    if(argc != 1) {
+        return enif_make_badarg(env);
+    }
+
+    if((posix_errno = efile_marshal_path(env, argv[0], &path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    } else if((posix_errno = efile_del_dir(&path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    }
+
+    return am_ok;
+}
+
+static ERL_NIF_TERM get_device_cwd_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    posix_errno_t posix_errno;
+
+    ERL_NIF_TERM result;
+    int device_index;
+
+    if(argc != 1 || !enif_get_int(env, argv[0], &device_index)) {
+        return enif_make_badarg(env);
+    }
+
+    if((posix_errno = efile_get_device_cwd(env, device_index, &result))) {
+        return posix_error_to_tuple(env, posix_errno);
+    }
+
+    return enif_make_tuple2(env, am_ok, result);
+}
+
+static ERL_NIF_TERM get_cwd_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    posix_errno_t posix_errno;
+    ERL_NIF_TERM result;
+
+    if(argc != 0) {
+        return enif_make_badarg(env);
+    }
+
+    if((posix_errno = efile_get_cwd(env, &result))) {
+        return posix_error_to_tuple(env, posix_errno);
+    }
+
+    return enif_make_tuple2(env, am_ok, result);
+}
+
+static ERL_NIF_TERM set_cwd_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    posix_errno_t posix_errno;
+
+    efile_path_t path;
+
+    if(argc != 1) {
+        return enif_make_badarg(env);
+    }
+
+    if((posix_errno = efile_marshal_path(env, argv[0], &path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    } else if((posix_errno = efile_set_cwd(&path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    }
+
+    return am_ok;
+}
+
+/** @brief Reads an entire file into \c result, stopping after \c size bytes or
+ * EOF. It will read until EOF if size is 0. */
+static posix_errno_t read_file(efile_data_t *d, size_t size, ErlNifBinary *result) {
+    size_t initial_buffer_size;
+    ssize_t bytes_read;
+
+    if(size == 0) {
+        initial_buffer_size = 16 << 10;
+    } else {
+        initial_buffer_size = size;
+    }
+
+    if(!enif_alloc_binary(initial_buffer_size, result)) {
+        return ENOMEM;
+    }
+
+    bytes_read = 0;
+
+    for(;;) {
+        ssize_t block_bytes_read;
+        SysIOVec read_vec[1];
+
+        read_vec[0].iov_base = result->data + bytes_read;
+        read_vec[0].iov_len = result->size - bytes_read;
+
+        block_bytes_read = efile_readv(d, read_vec, 1);
+
+        if(block_bytes_read < 0) {
+            enif_release_binary(result);
+            return d->posix_errno;
+        }
+
+        bytes_read += block_bytes_read;
+
+        if(block_bytes_read < (result->size - bytes_read)) {
+            /* EOF */
+            break;
+        } else if(bytes_read == size) {
+            break;
+        }
+
+        if(!enif_realloc_binary(result, bytes_read * 2)) {
+            enif_release_binary(result);
+            return ENOMEM;
+        }
+    }
+
+    /* The file may have shrunk since we queried its size, so we have to do
+     * this even when the size is known. */
+    if(bytes_read < result->size && !enif_realloc_binary(result, bytes_read)) {
+        ERTS_INTERNAL_ERROR("Failed to shrink read_file result.");
+    }
+
+    return 0;
+}
+
+static ERL_NIF_TERM read_file_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    posix_errno_t posix_errno;
+
+    efile_fileinfo_t info = {0};
+    efile_path_t path;
+    efile_data_t *d;
+
+    ErlNifBinary result;
+
+    if(argc != 1) {
+        return enif_make_badarg(env);
+    }
+
+    if((posix_errno = efile_marshal_path(env, argv[0], &path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    } else if((posix_errno = efile_read_info(&path, 1, &info))) {
+        return posix_error_to_tuple(env, posix_errno);
+    } else if((posix_errno = efile_open(&path, EFILE_MODE_READ, efile_resource_type, &d))) {
+        return posix_error_to_tuple(env, posix_errno);
+    }
+
+    posix_errno = read_file(d, info.size, &result);
+    enif_release_resource(d);
+
+    if(posix_errno) {
+        return posix_error_to_tuple(env, posix_errno);
+    }
+
+    return enif_make_tuple2(env, am_ok, enif_make_binary(env, &result));
+}
+
+static ERL_NIF_TERM altname_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    posix_errno_t posix_errno;
+
+    efile_path_t path;
+    ERL_NIF_TERM result;
+
+    if(argc != 1) {
+        return enif_make_badarg(env);
+    }
+
+    if((posix_errno = efile_marshal_path(env, argv[0], &path))) {
+        return posix_error_to_tuple(env, posix_errno);
+    } else if((posix_errno = efile_altname(env, &path, &result))) {
+        return posix_error_to_tuple(env, posix_errno);
+    }
+
+    return enif_make_tuple2(env, am_ok, result);
+}
diff --git a/erts/emulator/nifs/common/prim_file_nif.h b/erts/emulator/nifs/common/prim_file_nif.h
new file mode 100644
index 0000000000..cc9bc8f5c3
--- /dev/null
+++ b/erts/emulator/nifs/common/prim_file_nif.h
@@ -0,0 +1,240 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson 2017. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * %CopyrightEnd%
+ */
+
+typedef int posix_errno_t;
+
+enum efile_modes_t {
+    EFILE_MODE_READ = (1 << 0),
+    EFILE_MODE_WRITE = (1 << 1), /* Implies truncating file when used alone. */
+    EFILE_MODE_APPEND = (1 << 2),
+    EFILE_MODE_EXCLUSIVE = (1 << 3),
+    EFILE_MODE_SYNC = (1 << 4),
+
+    EFILE_MODE_SKIP_TYPE_CHECK = (1 << 5), /* Special for device files on Unix. */
+    EFILE_MODE_NO_TRUNCATE = (1 << 6), /* Special for reopening on VxWorks. */
+
+    EFILE_MODE_READ_WRITE = EFILE_MODE_READ | EFILE_MODE_WRITE
+};
+
+enum efile_access_t {
+    EFILE_ACCESS_NONE = 0,
+    EFILE_ACCESS_READ = 1,
+    EFILE_ACCESS_WRITE = 2,
+    EFILE_ACCESS_READ_WRITE = EFILE_ACCESS_READ | EFILE_ACCESS_WRITE
+};
+
+enum efile_seek_t {
+    EFILE_SEEK_BOF,
+    EFILE_SEEK_CUR,
+    EFILE_SEEK_EOF
+};
+
+enum efile_filetype_t {
+    EFILE_FILETYPE_DEVICE,
+    EFILE_FILETYPE_DIRECTORY,
+    EFILE_FILETYPE_REGULAR,
+    EFILE_FILETYPE_SYMLINK,
+    EFILE_FILETYPE_OTHER
+};
+
+enum efile_advise_t {
+    EFILE_ADVISE_NORMAL,
+    EFILE_ADVISE_RANDOM,
+    EFILE_ADVISE_SEQUENTIAL,
+    EFILE_ADVISE_WILL_NEED,
+    EFILE_ADVISE_DONT_NEED,
+    EFILE_ADVISE_NO_REUSE
+};
+
+enum efile_state_t {
+    EFILE_STATE_IDLE = 0,
+    EFILE_STATE_BUSY = 1,
+    EFILE_STATE_CLOSE_PENDING = 2,
+    EFILE_STATE_CLOSED = 3
+};
+
+typedef struct {
+    Sint64 size;            /* Size of file */
+    Uint32 type;            /* Type of file -- one of EFILE_FILETYPE_*. */
+    Uint32 access;          /* Access to file -- one of EFILE_ACCESS_*. */
+    Uint32 mode;            /* Access permissions -- bit field. */
+    Uint32 links;           /* Number of links to file. */
+    Uint32 major_device;    /* Major device or file system. */
+    Uint32 minor_device;    /* Minor device (for devices). */
+    Uint32 inode;           /* Inode number. */
+    Uint32 uid;             /* User id of owner. */
+    Uint32 gid;             /* Group id of owner. */
+    Sint64 a_time;          /* Last time the file was accessed. */
+    Sint64 m_time;          /* Last time the file was modified. */
+    Sint64 c_time;          /* Windows: creation time, Unix: last inode
+                             * change. */
+} efile_fileinfo_t;
+
+/* The smallest value that can be converted freely between universal, local,
+ * and POSIX time, as required by read_file_info/2. Corresponds to
+ * {{1902,1,1},{0,0,0}} */
+#define EFILE_MIN_FILETIME -2145916800
+
+/* Initializes an efile_data_t; must be used in efile_open on success. */
+#define EFILE_INIT_RESOURCE(__d, __modes) do { \
+        erts_atomic32_init_acqb(&(__d)->state, EFILE_STATE_IDLE); \
+        (__d)->posix_errno = 0; \
+        (__d)->modes = __modes; \
+    } while(0)
+
+typedef struct {
+    erts_atomic32_t state;
+
+    posix_errno_t posix_errno;
+    enum efile_modes_t modes;
+
+    ErlNifMonitor monitor;
+} efile_data_t;
+
+typedef ErlNifBinary efile_path_t;
+
+/* @brief Translates the given "raw name" into the format expected by the APIs
+ * used by the underlying implementation. The result is transient and does not
+ * need to be released.
+ *
+ * This may change the structure of the path and its results should never be
+ * passed on to the user. Refer to the OS-specific implementation for details.
+ *
+ * @param path The term to translate; it must have been encoded with
+ * prim_file:internal_native2name for compatibility reasons. */
+posix_errno_t efile_marshal_path(ErlNifEnv *env, ERL_NIF_TERM path, efile_path_t *result);
+
+/* @brief Returns the underlying handle as an implementation-defined term.
+ *
+ * This is an internal function intended to support tests and tricky
+ * operations like sendfile(2). */
+ERL_NIF_TERM efile_get_handle(ErlNifEnv *env, efile_data_t *d);
+
+/* @brief Read until EOF or the given iovec has been filled.
+ *
+ * @return -1 on failure, or the number of bytes read on success. The return
+ * value will be 0 if no bytes could be read before EOF or the end of the
+ * iovec. */
+Sint64 efile_readv(efile_data_t *d, SysIOVec *iov, int iovlen);
+
+/* @brief Write the entirety of the given iovec.
+ *
+ * @return -1 on failure, or the number of bytes written on success. "Partial"
+ * failures will be reported with -1 and not the number of bytes we managed to
+ * write to disk before the failure. */
+Sint64 efile_writev(efile_data_t *d, SysIOVec *iov, int iovlen);
+
+/* @brief As \c efile_readv, but starting from a file offset. */
+Sint64 efile_preadv(efile_data_t *d, Sint64 offset, SysIOVec *iov, int iovlen);
+
+/* @brief As \c efile_writev, but starting from a file offset. */
+Sint64 efile_pwritev(efile_data_t *d, Sint64 offset, SysIOVec *iov, int iovlen);
+
+int efile_seek(efile_data_t *d, enum efile_seek_t seek, Sint64 offset, Sint64 *new_position);
+
+int efile_sync(efile_data_t *d, int data_only);
+
+int efile_advise(efile_data_t *d, Sint64 offset, Sint64 length, enum efile_advise_t advise);
+int efile_allocate(efile_data_t *d, Sint64 offset, Sint64 length);
+int efile_truncate(efile_data_t *d);
+
+posix_errno_t efile_open(const efile_path_t *path, enum efile_modes_t modes,
+        ErlNifResourceType *nif_type, efile_data_t **d);
+
+/** @brief Closes a file. The file must have entered the CLOSED state prior to
+ * calling this to prevent double close. */
+int efile_close(efile_data_t *d);
+
+/* **** **** **** **** **** **** **** **** **** **** **** **** **** **** **** */
+
+posix_errno_t efile_read_info(const efile_path_t *path, int follow_link, efile_fileinfo_t *result);
+
+/** @brief Sets the file times to the given values. Refer to efile_fileinfo_t
+ * for a description of each. */
+posix_errno_t efile_set_time(const efile_path_t *path, Sint64 a_time, Sint64 m_time, Sint64 c_time);
+
+/** @brief On Unix, this sets the file permissions according to the docs for
+ * file:write_file_info/2. On Windows it uses the "owner write permission" flag
+ * to toggle whether the file is read-only or not. */
+posix_errno_t efile_set_permissions(const efile_path_t *path, Uint32 permissions);
+
+/** @brief On Unix, this will set the owner/group to the given values. It will
+ * do nothing on other platforms. */
+posix_errno_t efile_set_owner(const efile_path_t *path, Uint32 owner, Uint32 group);
+
+/** @brief Resolves the final path of the given link. */
+posix_errno_t efile_read_link(ErlNifEnv *env, const efile_path_t *path, ERL_NIF_TERM *result);
+
+/** @brief Lists the contents of the given directory.
+ * @param result [out] A list of all the directory/file names contained in the
+ * given directory. */
+posix_errno_t efile_list_dir(ErlNifEnv *env, const efile_path_t *path, ERL_NIF_TERM *result);
+
+/** @brief Changes the name of an existing file or directory, from old_path
+ * to new_path.
+ *
+ * If old_path and new_path refer to the same file or directory, it does
+ * nothing and returns success. Otherwise if new_path already exists, it will
+ * be deleted and replaced by src subject to the following conditions:
+ *
+ *     If old_path is a directory, new_path may be an empty directory.
+ *     If old_path is a file, new_path may be a file.
+ *
+ * Neither of these are guaranteed to be atomic. In any other situation where
+ * new_path already exists, the rename will fail.
+ *
+ * Some possible error codes:
+ *
+ * - EACCES:     Either paths or one of their parent directories can't be read
+ *               and/or written.
+ * - EEXIST:     new_path is a non-empty directory.
+ * - EINVAL:     old_path is a root directory or new_path is a subdirectory
+ *               of new_path.
+ * - EISDIR:     new_path is a directory, but old_path is not.
+ * - ENOTDIR:    old_path is a directory, but new_path is not.
+ * - ENOENT:     old_path doesn't exist, or either path is "".
+ * - EXDEV:      The paths are on different filesystems.
+ *
+ * The implementation of rename may allow cross-filesystem renames,
+ * but the caller should be prepared to emulate it with copy and
+ * delete if errno is EXDEV. */
+posix_errno_t efile_rename(const efile_path_t *old_path, const efile_path_t *new_path);
+
+posix_errno_t efile_make_hard_link(const efile_path_t *existing_path, const efile_path_t *new_path);
+posix_errno_t efile_make_soft_link(const efile_path_t *existing_path, const efile_path_t *new_path);
+posix_errno_t efile_make_dir(const efile_path_t *path);
+
+posix_errno_t efile_del_file(const efile_path_t *path);
+posix_errno_t efile_del_dir(const efile_path_t *path);
+
+posix_errno_t efile_get_cwd(ErlNifEnv *env, ERL_NIF_TERM *result);
+posix_errno_t efile_set_cwd(const efile_path_t *path);
+
+/** @brief A Windows-specific function for returning the working directory of a
+ * given device.
+ *
+ * @param device_index The drive index; 1 for A, 2 for B, etc.
+ * @param result [out] The working directory of the given device
+ */
+posix_errno_t efile_get_device_cwd(ErlNifEnv *env, int device_index, ERL_NIF_TERM *result);
+
+/** @brief A Windows-specific function for returning the 8.3-name of a given
+ * file or directory. */
+posix_errno_t efile_altname(ErlNifEnv *env, const efile_path_t *path, ERL_NIF_TERM *result);
diff --git a/erts/emulator/nifs/unix/unix_prim_file.c b/erts/emulator/nifs/unix/unix_prim_file.c
new file mode 100644
index 0000000000..57c8ef62e1
--- /dev/null
+++ b/erts/emulator/nifs/unix/unix_prim_file.c
@@ -0,0 +1,957 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson 2017. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * %CopyrightEnd%
+ */
+
+#include "erl_nif.h"
+#include "config.h"
+#include "sys.h"
+
+#ifdef VALGRIND
+#  include <valgrind/memcheck.h>
+#endif
+
+#include "prim_file_nif.h"
+
+#if defined(__APPLE__) && defined(__MACH__) && !defined(__DARWIN__)
+#define __DARWIN__ 1
+#endif
+
+#if defined(__DARWIN__) || defined(HAVE_LINUX_FALLOC_H) || defined(HAVE_POSIX_FALLOCATE)
+#include <fcntl.h>
+#endif
+
+#ifdef HAVE_LINUX_FALLOC_H
+#include <linux/falloc.h>
+#endif
+
+#include <utime.h>
+
+/* Macros for testing file types. */
+#ifdef NO_UMASK
+#define FILE_MODE 0644
+#define DIR_MODE  0755
+#else
+#define FILE_MODE 0666
+#define DIR_MODE  0777
+#endif
+
+/* Old platforms might not have IOV_MAX defined. */
+#if !defined(IOV_MAX) && defined(UIO_MAXIOV)
+#define IOV_MAX UIO_MAXIOV
+#elif !defined(IOV_MAX)
+#define IOV_MAX 16
+#endif
+
+typedef struct {
+    efile_data_t common;
+    int fd;
+} efile_unix_t;
+
+static int has_invalid_null_termination(const ErlNifBinary *path) {
+    const char *null_pos, *end_pos;
+
+    null_pos = memchr(path->data, '\0', path->size);
+    end_pos = (const char*)&path->data[path->size] - 1;
+
+    if(null_pos == NULL) {
+        return 1;
+    }
+
+    /* prim_file:internal_name2native sometimes feeds us data that is "doubly"
+     * NUL-terminated, so we'll accept any number of trailing NULs so long as
+     * they aren't interrupted by anything else. */
+    while(null_pos < end_pos && (*null_pos) == '\0') {
+        null_pos++;
+    }
+
+    return null_pos != end_pos;
+}
+
+posix_errno_t efile_marshal_path(ErlNifEnv *env, ERL_NIF_TERM path, efile_path_t *result) {
+    if(!enif_inspect_binary(env, path, result)) {
+        return EINVAL;
+    }
+
+    if(has_invalid_null_termination(result)) {
+        return EINVAL;
+    }
+
+    return 0;
+}
+
+ERL_NIF_TERM efile_get_handle(ErlNifEnv *env, efile_data_t *d) {
+    efile_unix_t *u = (efile_unix_t*)d;
+
+    ERL_NIF_TERM result;
+    unsigned char *bits;
+
+    bits = enif_make_new_binary(env, sizeof(u->fd), &result);
+    memcpy(bits, &u->fd, sizeof(u->fd));
+
+    return result;
+}
+
+static int open_file_type_check(const efile_path_t *path, int fd) {
+    struct stat file_info;
+    int error;
+
+#ifndef HAVE_FSTAT
+    error = stat((const char*)path->data, &file_info);
+    (void)fd;
+#else
+    error = fstat(fd, &file_info);
+    (void)path;
+#endif
+
+    if(error < 0) {
+        /* If we failed to stat assume success and let the next call handle the
+         * error. The old driver checked whether the file was to be used
+         * immediately in a read within the call, but the new implementation
+         * never does that. */
+         return 1;
+    } else {
+        /* The old driver tolerated opening /dev/null despite the "no devices"
+         * limitation. It provided no explanation for this but we still need
+         * to match the behavior. We're checking through stat(2) instead of
+         * comparing the name to account for links. */
+        struct stat null_device_info;
+        int is_dev_null;
+
+        is_dev_null = (stat("/dev/null", &null_device_info) == 0);
+        is_dev_null &= (file_info.st_ino == null_device_info.st_ino);
+        is_dev_null &= (file_info.st_dev == null_device_info.st_dev);
+
+        if(is_dev_null) {
+            return 1;
+        }
+    }
+
+    if(!S_ISREG(file_info.st_mode)) {
+        return 0;
+    }
+
+    return 1;
+}
+
+posix_errno_t efile_open(const efile_path_t *path, enum efile_modes_t modes,
+        ErlNifResourceType *nif_type, efile_data_t **d) {
+
+    int flags, fd;
+
+    flags = 0;
+
+    if(modes & EFILE_MODE_READ && !(modes & EFILE_MODE_WRITE)) {
+        flags |= O_RDONLY;
+    } else if(modes & EFILE_MODE_WRITE && !(modes & EFILE_MODE_READ)) {
+        if(!(modes & EFILE_MODE_NO_TRUNCATE)) {
+            flags |= O_TRUNC;
+        }
+
+        flags |= O_WRONLY | O_CREAT;
+    } else if(modes & EFILE_MODE_READ_WRITE) {
+        flags |= O_RDWR | O_CREAT;
+    } else {
+        return EINVAL;
+    }
+
+    if(modes & EFILE_MODE_APPEND) {
+        flags &= ~O_TRUNC;
+        flags |= O_APPEND;
+    }
+
+    if(modes & EFILE_MODE_EXCLUSIVE) {
+        flags |= O_EXCL;
+    }
+
+    if(modes & EFILE_MODE_SYNC) {
+#ifndef O_SYNC
+        return ENOTSUP;
+#else
+        flags |= O_SYNC;
+#endif
+    }
+
+    do {
+        fd = open((const char*)path->data, flags, FILE_MODE);
+    } while(fd == -1 && errno == EINTR);
+
+    if(fd != -1) {
+        efile_unix_t *u;
+
+        if(!(modes & EFILE_MODE_SKIP_TYPE_CHECK) && !open_file_type_check(path, fd)) {
+            close(fd);
+
+            /* This is blatantly incorrect, but we're documented as returning
+             * this for everything that isn't a file. */
+            return EISDIR;
+        }
+
+        u = (efile_unix_t*)enif_alloc_resource(nif_type, sizeof(efile_unix_t));
+        u->fd = fd;
+
+        EFILE_INIT_RESOURCE(&u->common, modes);
+        (*d) = &u->common;
+
+        return 0;
+    }
+
+    (*d) = NULL;
+    return errno;
+}
+
+int efile_close(efile_data_t *d) {
+    efile_unix_t *u = (efile_unix_t*)d;
+    int fd;
+
+    ASSERT(erts_atomic32_read_nob(&d->state) == EFILE_STATE_CLOSED);
+    ASSERT(u->fd != -1);
+
+    fd = u->fd;
+    u->fd = -1;
+
+    /* close(2) either always closes (*BSD, Linux) or leaves the fd in an
+     * undefined state (POSIX 2008, Solaris), so we must not retry on EINTR. */
+
+    if(close(fd) < 0) {
+        u->common.posix_errno = errno;
+        return 0;
+    }
+
+    return 1;
+}
+
+static void shift_iov(SysIOVec **iov, int *iovlen, ssize_t shift) {
+    SysIOVec *head_vec = (*iov);
+
+    ASSERT(shift >= 0);
+
+    while(shift > 0) {
+        ASSERT(head_vec < &(*iov)[*iovlen]);
+
+        if(shift < head_vec->iov_len) {
+            head_vec->iov_base = (char*)head_vec->iov_base + shift;
+            head_vec->iov_len -= shift;
+            break;
+        } else {
+            shift -= head_vec->iov_len;
+            head_vec++;
+        }
+    }
+
+    (*iovlen) -= head_vec - (*iov);
+    (*iov) = head_vec;
+}
+
+Sint64 efile_readv(efile_data_t *d, SysIOVec *iov, int iovlen) {
+    efile_unix_t *u = (efile_unix_t*)d;
+
+    Sint64 bytes_read;
+    ssize_t result;
+
+    bytes_read = 0;
+
+    do {
+        int use_fallback = 0;
+
+        if(iovlen < 1) {
+            result = 0;
+            break;
+        }
+
+        /* writev(2) implies readv(2) */
+#ifdef HAVE_WRITEV
+        result = readv(u->fd, iov, MIN(IOV_MAX, iovlen));
+
+        /* Fall back to using read(2) if readv(2) reports that the combined
+         * size of iov is greater than SSIZE_T_MAX. */
+        use_fallback = (result < 0 && errno == EINVAL);
+#else
+        use_fallback = 1;
+#endif
+
+        if(use_fallback) {
+            result = read(u->fd, iov->iov_base, iov->iov_len);
+        }
+
+        if(result > 0) {
+            shift_iov(&iov, &iovlen, result);
+            bytes_read += result;
+        }
+    } while(result > 0 || (result < 0 && errno == EINTR));
+
+    u->common.posix_errno = errno;
+
+    if(result == 0 && bytes_read > 0) {
+        return bytes_read;
+    }
+
+    return result;
+}
+
+Sint64 efile_writev(efile_data_t *d, SysIOVec *iov, int iovlen) {
+    efile_unix_t *u = (efile_unix_t*)d;
+
+    Sint64 bytes_written;
+    ssize_t result;
+
+    bytes_written = 0;
+
+    do {
+        int use_fallback = 0;
+
+        if(iovlen < 1) {
+            result = 0;
+            break;
+        }
+
+#ifdef HAVE_WRITEV
+        result = writev(u->fd, iov, MIN(IOV_MAX, iovlen));
+
+        /* Fall back to using write(2) if writev(2) reports that the combined
+         * size of iov is greater than SSIZE_T_MAX. */
+        use_fallback = (result < 0 && errno == EINVAL);
+#else
+        use_fallback = 1;
+#endif
+
+        if(use_fallback) {
+            result = write(u->fd, iov->iov_base, iov->iov_len);
+        }
+
+        if(result > 0) {
+            shift_iov(&iov, &iovlen, result);
+            bytes_written += result;
+        }
+    } while(result > 0 || (result < 0 && errno == EINTR));
+
+    u->common.posix_errno = errno;
+
+    if(result == 0 && bytes_written > 0) {
+        return bytes_written;
+    }
+
+    return result;
+}
+
+Sint64 efile_preadv(efile_data_t *d, Sint64 offset, SysIOVec *iov, int iovlen) {
+    efile_unix_t *u = (efile_unix_t*)d;
+
+    Uint64 bytes_read;
+    Sint64 result;
+
+#if !defined(HAVE_PREADV) && !defined(HAVE_PREAD)
+    /* This function is documented as leaving the file position undefined, but
+     * the old driver always reset it so there's probably code in the wild that
+     * relies on this behavior. */
+    off_t original_position = lseek(u->fd, 0, SEEK_CUR);
+
+    if(original_position < 0 || lseek(u->fd, offset, SEEK_SET) < 0) {
+        u->common.posix_errno = errno;
+        return -1;
+    }
+#endif
+
+    bytes_read = 0;
+
+    do {
+        if(iovlen < 1) {
+            result = 0;
+            break;
+        }
+
+#if defined(HAVE_PREADV)
+        result = preadv(u->fd, iov, MIN(IOV_MAX, iovlen), offset);
+#elif defined(HAVE_PREAD)
+        result = pread(u->fd, iov->iov_base, iov->iov_len, offset);
+#else
+        result = read(u->fd, iov->iov_base, iov->iov_len);
+#endif
+
+        if(result > 0) {
+            shift_iov(&iov, &iovlen, result);
+            bytes_read += result;
+            offset += result;
+        }
+    } while(result > 0 || (result < 0 && errno == EINTR));
+
+    u->common.posix_errno = errno;
+
+#if !defined(HAVE_PREADV) && !defined(HAVE_PREAD)
+    if(result >= 0) {
+        if(lseek(u->fd, original_position, SEEK_SET) < 0) {
+            u->common.posix_errno = errno;
+            return -1;
+        }
+    }
+#endif
+
+    if(result == 0 && bytes_read > 0) {
+        return bytes_read;
+    }
+
+    return result;
+}
+
+Sint64 efile_pwritev(efile_data_t *d, Sint64 offset, SysIOVec *iov, int iovlen) {
+    efile_unix_t *u = (efile_unix_t*)d;
+
+    Sint64 bytes_written;
+    ssize_t result;
+
+#if !defined(HAVE_PWRITEV) && !defined(HAVE_PWRITE)
+    off_t original_position = lseek(u->fd, 0, SEEK_CUR);
+
+    if(original_position < 0 || lseek(u->fd, offset, SEEK_SET) < 0) {
+        u->common.posix_errno = errno;
+        return -1;
+    }
+#endif
+
+    bytes_written = 0;
+
+    do {
+        if(iovlen < 1) {
+            result = 0;
+            break;
+        }
+
+#if defined(HAVE_PWRITEV)
+        result = pwritev(u->fd, iov, MIN(IOV_MAX, iovlen), offset);
+#elif defined(HAVE_PWRITE)
+        result = pwrite(u->fd, iov->iov_base, iov->iov_len, offset);
+#else
+        result = write(u->fd, iov->iov_base, iov->iov_len);
+#endif
+
+        if(result > 0) {
+            shift_iov(&iov, &iovlen, result);
+            bytes_written += result;
+            offset += result;
+        }
+    } while(result > 0 || (result < 0 && errno == EINTR));
+
+    u->common.posix_errno = errno;
+
+#if !defined(HAVE_PWRITEV) && !defined(HAVE_PWRITE)
+    if(result >= 0) {
+        if(lseek(u->fd, original_position, SEEK_SET) < 0) {
+            u->common.posix_errno = errno;
+            return -1;
+        }
+    }
+#endif
+
+    if(result == 0 && bytes_written > 0) {
+        return bytes_written;
+    }
+
+    return result;
+}
+
+int efile_seek(efile_data_t *d, enum efile_seek_t seek, Sint64 offset, Sint64 *new_position) {
+    efile_unix_t *u = (efile_unix_t*)d;
+    off_t result;
+    int whence;
+
+    switch(seek) {
+        case EFILE_SEEK_BOF: whence = SEEK_SET; break;
+        case EFILE_SEEK_CUR: whence = SEEK_CUR; break;
+        case EFILE_SEEK_EOF: whence = SEEK_END; break;
+        default: ERTS_INTERNAL_ERROR("Invalid seek parameter");
+    }
+
+    result = lseek(u->fd, offset, whence);
+
+    /*
+     * The man page for lseek (on SunOs 5) says:
+     *
+     * "if fildes is a remote file descriptor and offset is negative, lseek()
+     * returns the file pointer even if it is negative."
+     */
+    if(result < 0 && errno == 0) {
+        errno = EINVAL;
+    }
+
+    if(result < 0) {
+        u->common.posix_errno = errno;
+        return 0;
+    }
+
+    (*new_position) = result;
+
+    return 1;
+}
+
+int efile_sync(efile_data_t *d, int data_only) {
+    efile_unix_t *u = (efile_unix_t*)d;
+
+#if defined(HAVE_FDATASYNC) && !defined(__DARWIN__)
+    if(data_only) {
+        if(fdatasync(u->fd) < 0) {
+            u->common.posix_errno = errno;
+            return 0;
+        }
+
+        return 1;
+    }
+#endif
+
+#if defined(__DARWIN__) && defined(F_FULLFSYNC)
+    if(fcntl(u->fd, F_FULLFSYNC) < 0) {
+#else
+    if(fsync(u->fd) < 0) {
+#endif
+        u->common.posix_errno = errno;
+        return 0;
+    }
+
+    return 1;
+}
+
+int efile_advise(efile_data_t *d, Sint64 offset, Sint64 length, enum efile_advise_t advise) {
+    efile_unix_t *u = (efile_unix_t*)d;
+#ifdef HAVE_POSIX_FADVISE
+    int p_advise;
+
+    switch(advise) {
+        case EFILE_ADVISE_NORMAL: p_advise = POSIX_FADV_NORMAL; break;
+        case EFILE_ADVISE_RANDOM: p_advise = POSIX_FADV_RANDOM; break;
+        case EFILE_ADVISE_SEQUENTIAL: p_advise = POSIX_FADV_SEQUENTIAL; break;
+        case EFILE_ADVISE_WILL_NEED: p_advise = POSIX_FADV_WILLNEED; break;
+        case EFILE_ADVISE_DONT_NEED: p_advise = POSIX_FADV_DONTNEED; break;
+        case EFILE_ADVISE_NO_REUSE: p_advise = POSIX_FADV_NOREUSE; break;
+        default:
+            u->common.posix_errno = EINVAL;
+            return 0;
+    }
+
+    if(posix_fadvise(u->fd, offset, length, p_advise) < 0) {
+        u->common.posix_errno = errno;
+        return 0;
+    }
+
+    return 1;
+#else
+    /* We'll pretend to support this syscall as it's only a recommendation even
+     * on systems that do support it. */
+    return 1;
+#endif
+}
+
+int efile_allocate(efile_data_t *d, Sint64 offset, Sint64 length) {
+    efile_unix_t *u = (efile_unix_t*)d;
+    int ret = -1;
+
+    /* We prefer OS-specific methods, but fall back to posix_fallocate on
+     * failure. It's unclear whether this has any practical benefit on
+     * modern systems, but the old driver did it. */
+
+#if defined(HAVE_FALLOCATE)
+    /* Linux-specific */
+    do {
+        ret = fallocate(u->fd, FALLOC_FL_KEEP_SIZE, offset, length);
+    } while(ret < 0 && errno == EINTR);
+#elif defined(F_PREALLOCATE)
+    /* Mac-specific */
+    fstore_t fs = {};
+
+    fs.fst_flags = F_ALLOCATECONTIG;
+    fs.fst_posmode = F_VOLPOSMODE;
+    fs.fst_offset = offset;
+    fs.fst_length = length;
+
+    ret = fcntl(u->fd, F_PREALLOCATE, &fs);
+    if(ret < 0) {
+        fs.fst_flags = F_ALLOCATEALL;
+        ret = fcntl(u->fd, F_PREALLOCATE, &fs);
+    }
+#elif !defined(HAVE_POSIX_FALLOCATE)
+    u->common.posix_errno = ENOTSUP;
+    return 0;
+#endif
+
+#ifdef HAVE_POSIX_FALLOCATE
+    if(ret < 0) {
+        do {
+            ret = posix_fallocate(u->fd, offset, length);
+
+            /* On Linux and Solaris for example, posix_fallocate() returns a
+             * positive error number on error and it does not set errno. On
+             * FreeBSD however (9.0 at least), it returns -1 on error and it
+             * sets errno. */
+            if (ret > 0) {
+                errno = ret;
+                ret = -1;
+            }
+        } while(ret < 0 && errno == EINTR);
+    }
+#endif
+
+    if(ret < 0) {
+        u->common.posix_errno = errno;
+        return 0;
+    }
+
+    return 1;
+}
+
+int efile_truncate(efile_data_t *d) {
+    efile_unix_t *u = (efile_unix_t*)d;
+    off_t offset;
+
+    offset = lseek(u->fd, 0, SEEK_CUR);
+
+    if(offset < 0) {
+        u->common.posix_errno = errno;
+        return 0;
+    }
+
+    if(ftruncate(u->fd, offset) < 0) {
+        u->common.posix_errno = errno;
+        return 0;
+    }
+
+    return 1;
+}
+
+posix_errno_t efile_read_info(const efile_path_t *path, int follow_links, efile_fileinfo_t *result) {
+    struct stat data;
+
+    if(follow_links) {
+        if(stat((const char*)path->data, &data) < 0) {
+            return errno;
+        }
+    } else {
+        if(lstat((const char*)path->data, &data) < 0) {
+            return errno;
+        }
+    }
+
+    if(S_ISCHR(data.st_mode) || S_ISBLK(data.st_mode)) {
+        result->type = EFILE_FILETYPE_DEVICE;
+    } else if(S_ISDIR(data.st_mode)) {
+        result->type = EFILE_FILETYPE_DIRECTORY;
+    } else if(S_ISREG(data.st_mode)) {
+        result->type = EFILE_FILETYPE_REGULAR;
+    } else if(S_ISLNK(data.st_mode)) {
+        result->type = EFILE_FILETYPE_SYMLINK;
+    } else {
+        result->type = EFILE_FILETYPE_OTHER;
+    }
+
+    result->a_time = (Sint64)data.st_atime;
+    result->m_time = (Sint64)data.st_mtime;
+    result->c_time = (Sint64)data.st_ctime;
+    result->size = data.st_size;
+
+    result->major_device = data.st_dev;
+    result->minor_device = data.st_rdev;
+    result->links = data.st_nlink;
+    result->inode = data.st_ino;
+    result->mode = data.st_mode;
+    result->uid = data.st_uid;
+    result->gid = data.st_gid;
+
+#ifndef NO_ACCESS
+    result->access = EFILE_ACCESS_NONE;
+
+    if(access((const char*)path->data, R_OK) == 0) {
+        result->access |= EFILE_ACCESS_READ;
+    }
+    if(access((const char*)path->data, W_OK) == 0) {
+        result->access |= EFILE_ACCESS_WRITE;
+    }
+#else
+    /* Just look at read/write access for owner. */
+    result->access = ((data.st_mode >> 6) & 07) >> 1;
+#endif
+
+    return 0;
+}
+
+posix_errno_t efile_set_permissions(const efile_path_t *path, Uint32 permissions) {
+    const mode_t MUTABLE_MODES = (S_ISUID | S_ISGID | S_IRWXU | S_IRWXG | S_IRWXO);
+    mode_t new_modes = permissions & MUTABLE_MODES;
+
+    if(chmod((const char*)path->data, new_modes) < 0) {
+        new_modes &= ~(S_ISUID | S_ISGID);
+
+        if (chmod((const char*)path->data, new_modes) < 0) {
+            return errno;
+        }
+    }
+
+    return 0;
+}
+
+posix_errno_t efile_set_owner(const efile_path_t *path, Uint32 owner, Uint32 group) {
+    if(chown((const char*)path->data, owner, group) < 0) {
+        return errno;
+    }
+
+    return 0;
+}
+
+posix_errno_t efile_set_time(const efile_path_t *path, Sint64 a_time, Sint64 m_time, Sint64 c_time) {
+    struct utimbuf tval;
+
+    tval.actime = (time_t)a_time;
+    tval.modtime = (time_t)m_time;
+
+    (void)c_time;
+
+    if(utime((const char*)path->data, &tval) < 0) {
+        return errno;
+    }
+
+    return 0;
+}
+
+posix_errno_t efile_read_link(ErlNifEnv *env, const efile_path_t *path, ERL_NIF_TERM *result) {
+    ErlNifBinary result_bin;
+
+    if(!enif_alloc_binary(256, &result_bin)) {
+        return ENOMEM;
+    }
+
+    for(;;) {
+        ssize_t bytes_copied;
+
+        bytes_copied = readlink((const char*)path->data, (char*)result_bin.data,
+            result_bin.size);
+
+        if(bytes_copied <= 0) {
+            posix_errno_t saved_errno = errno;
+            enif_release_binary(&result_bin);
+            return saved_errno;
+        } else if(bytes_copied < result_bin.size) {
+            if(!enif_realloc_binary(&result_bin, bytes_copied)) {
+                enif_release_binary(&result_bin);
+                return ENOMEM;
+            }
+
+            (*result) = enif_make_binary(env, &result_bin);
+
+            return 0;
+        }
+
+        /* The result didn't fit into the buffer, so we'll try again with a
+         * larger one. */
+
+        if(!enif_realloc_binary(&result_bin, result_bin.size * 2)) {
+            enif_release_binary(&result_bin);
+            return ENOMEM;
+        }
+    }
+}
+
+static int is_ignored_name(int name_length, const char *name) {
+    if(name_length == 1 && name[0] == '.') {
+        return 1;
+    } else if(name_length == 2 && memcmp(name, "..", 2) == 0) {
+        return 1;
+    }
+
+    return 0;
+}
+
+posix_errno_t efile_list_dir(ErlNifEnv *env, const efile_path_t *path, ERL_NIF_TERM *result) {
+    ERL_NIF_TERM list_head;
+
+    struct dirent *dir_entry;
+    DIR *dir_stream;
+
+    dir_stream = opendir((const char*)path->data);
+    if(dir_stream == NULL) {
+        posix_errno_t saved_errno = errno;
+        *result = enif_make_list(env, 0);
+        return saved_errno;
+    }
+
+    list_head = enif_make_list(env, 0);
+    dir_entry = readdir(dir_stream);
+
+    while(dir_entry != NULL) {
+        int name_length = strlen(dir_entry->d_name);
+
+        if(!is_ignored_name(name_length, dir_entry->d_name)) {
+            unsigned char *name_bytes;
+            ERL_NIF_TERM name_term;
+
+            name_bytes = enif_make_new_binary(env, name_length, &name_term);
+            sys_memcpy(name_bytes, dir_entry->d_name, name_length);
+
+            list_head = enif_make_list_cell(env, name_term, list_head);
+        }
+
+        dir_entry = readdir(dir_stream);
+    }
+
+    (*result) = list_head;
+    closedir(dir_stream);
+
+    return 0;
+}
+
+posix_errno_t efile_rename(const efile_path_t *old_path, const efile_path_t *new_path) {
+    if(rename((const char*)old_path->data, (const char*)new_path->data) < 0) {
+        if(errno == ENOTEMPTY) {
+            return EEXIST;
+        }
+
+        if(strcmp((const char*)old_path->data, "/") == 0) {
+            /* Alpha reports renaming / as EBUSY and Linux reports it as EACCES
+             * instead of EINVAL.*/
+             return EINVAL;
+        }
+
+        return errno;
+    }
+
+    return 0;
+}
+
+posix_errno_t efile_make_hard_link(const efile_path_t *existing_path, const efile_path_t *new_path) {
+    if(link((const char*)existing_path->data, (const char*)new_path->data) < 0) {
+        return errno;
+    }
+
+    return 0;
+}
+
+posix_errno_t efile_make_soft_link(const efile_path_t *existing_path, const efile_path_t *new_path) {
+    if(symlink((const char*)existing_path->data, (const char*)new_path->data) < 0) {
+        return errno;
+    }
+
+    return 0;
+}
+
+posix_errno_t efile_make_dir(const efile_path_t *path) {
+#ifdef NO_MKDIR_MODE
+    if(mkdir((const char*)path->data) < 0) {
+#else
+    if(mkdir((const char*)path->data, DIR_MODE) < 0) {
+#endif
+        return errno;
+    }
+
+    return 0;
+}
+
+posix_errno_t efile_del_file(const efile_path_t *path) {
+    if(unlink((const char*)path->data) < 0) {
+        /* Linux sets the wrong error code. */
+        if(errno == EISDIR) {
+            return EPERM;
+        }
+
+        return errno;
+    }
+
+    return 0;
+}
+
+posix_errno_t efile_del_dir(const efile_path_t *path) {
+    if(rmdir((const char*)path->data) < 0) {
+        posix_errno_t saved_errno = errno;
+
+        if(saved_errno == ENOTEMPTY) {
+            saved_errno = EEXIST;
+        }
+
+        /* The error code might be wrong if we're trying to delete the current
+         * directory. */
+        if(saved_errno == EEXIST) {
+            struct stat path_stat, cwd_stat;
+            int has_stat;
+
+            has_stat = (stat((const char*)path->data, &path_stat) == 0);
+            has_stat &= (stat(".", &cwd_stat) == 0);
+
+            if(has_stat && path_stat.st_ino == cwd_stat.st_ino) {
+                if(path_stat.st_dev == cwd_stat.st_dev) {
+                    return EINVAL;
+                }
+            }
+        }
+
+        return saved_errno;
+    }
+
+    return 0;
+}
+
+posix_errno_t efile_set_cwd(const efile_path_t *path) {
+    if(chdir((const char*)path->data) < 0) {
+        return errno;
+    }
+
+    return 0;
+}
+
+posix_errno_t efile_get_device_cwd(ErlNifEnv *env, int device_index, ERL_NIF_TERM *result) {
+    (void)device_index;
+    (void)result;
+    (void)env;
+
+    return ENOTSUP;
+}
+
+posix_errno_t efile_get_cwd(ErlNifEnv *env, ERL_NIF_TERM *result) {
+    ErlNifBinary result_bin;
+    size_t bytes_copied;
+
+    if(!enif_alloc_binary(256, &result_bin)) {
+        return ENOMEM;
+    }
+
+    while(getcwd((char*)result_bin.data, result_bin.size) == NULL) {
+        posix_errno_t saved_errno = errno;
+
+        if(saved_errno != ERANGE) {
+            enif_release_binary(&result_bin);
+            return saved_errno;
+        } else {
+            if(!enif_realloc_binary(&result_bin, result_bin.size * 2)) {
+                enif_release_binary(&result_bin);
+                return ENOMEM;
+            }
+        }
+    }
+
+    /* getcwd(2) guarantees null-termination. */
+    bytes_copied = strlen((const char*)result_bin.data);
+
+    if(!enif_realloc_binary(&result_bin, bytes_copied)) {
+        enif_release_binary(&result_bin);
+        return ENOMEM;
+    }
+
+    (*result) = enif_make_binary(env, &result_bin);
+
+    return 0;
+}
+
+posix_errno_t efile_altname(ErlNifEnv *env, const efile_path_t *path, ERL_NIF_TERM *result) {
+    (void)path;
+    (void)result;
+
+    return ENOTSUP;
+}
diff --git a/erts/emulator/nifs/win32/win_prim_file.c b/erts/emulator/nifs/win32/win_prim_file.c
new file mode 100644
index 0000000000..9f993f1d24
--- /dev/null
+++ b/erts/emulator/nifs/win32/win_prim_file.c
@@ -0,0 +1,1427 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson 2017. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * %CopyrightEnd%
+ */
+
+#include "erl_nif.h"
+#include "config.h"
+#include "sys.h"
+
+#include "prim_file_nif.h"
+
+#include <windows.h>
+#include <strsafe.h>
+#include <wchar.h>
+
+#define IS_SLASH(a)  ((a) == L'\\' || (a) == L'/')
+
+#define FILE_SHARE_FLAGS (FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE)
+
+#define LP_PREFIX L"\\\\?\\"
+#define LP_PREFIX_SIZE (sizeof(LP_PREFIX) - sizeof(WCHAR))
+#define LP_PREFIX_LENGTH (LP_PREFIX_SIZE / sizeof(WCHAR))
+
+#define PATH_LENGTH(path) (path->size / sizeof(WCHAR) - 1)
+
+#define ASSERT_PATH_FORMAT(path) \
+    do { \
+        ASSERT(PATH_LENGTH(path) >= 4 && \
+            !memcmp(path->data, LP_PREFIX, LP_PREFIX_SIZE)); \
+        ASSERT(PATH_LENGTH(path) == wcslen((WCHAR*)path->data)); \
+    } while(0)
+
+#define TICKS_PER_SECOND (10000000ULL)
+#define EPOCH_DIFFERENCE (11644473600LL)
+
+#define FILETIME_TO_EPOCH(epoch, ft) \
+    do { \
+        ULARGE_INTEGER ull; \
+        ull.LowPart  = (ft).dwLowDateTime; \
+        ull.HighPart = (ft).dwHighDateTime; \
+        (epoch) = ((ull.QuadPart / TICKS_PER_SECOND) - EPOCH_DIFFERENCE); \
+    } while(0)
+
+#define EPOCH_TO_FILETIME(ft, epoch) \
+    do { \
+        ULARGE_INTEGER ull; \
+        ull.QuadPart = (((epoch) + EPOCH_DIFFERENCE) * TICKS_PER_SECOND); \
+        (ft).dwLowDateTime = ull.LowPart; \
+        (ft).dwHighDateTime = ull.HighPart; \
+    } while(0)
+
+typedef struct {
+    efile_data_t common;
+    HANDLE handle;
+} efile_win_t;
+
+static int windows_to_posix_errno(DWORD last_error);
+
+static int has_invalid_null_termination(const ErlNifBinary *path) {
+    const WCHAR *null_pos, *end_pos;
+
+    null_pos = wmemchr((const WCHAR*)path->data, L'\0', path->size);
+    end_pos = (const WCHAR*)&path->data[path->size] - 1;
+
+    if(null_pos == NULL) {
+        return 1;
+    }
+
+    /* prim_file:internal_name2native sometimes feeds us data that is "doubly"
+     * NUL-terminated, so we'll accept any number of trailing NULs so long as
+     * they aren't interrupted by anything else. */
+    while(null_pos < end_pos && (*null_pos) == L'\0') {
+        null_pos++;
+    }
+
+    return null_pos != end_pos;
+}
+
+static posix_errno_t get_full_path(ErlNifEnv *env, WCHAR *input, efile_path_t *result) {
+    DWORD maximum_length, actual_length;
+    int add_long_prefix;
+
+    maximum_length = GetFullPathNameW(input, 0, NULL, NULL);
+    add_long_prefix = 0;
+
+    if(maximum_length == 0) {
+        /* POSIX doesn't have the concept of a "path error" in the same way
+         * Windows does, so we'll return ENOENT since that's what most POSIX
+         * APIs would return if they were fed such garbage. */
+        return ENOENT;
+    }
+
+    maximum_length += LP_PREFIX_LENGTH;
+
+    if(!enif_alloc_binary(maximum_length * sizeof(WCHAR), result)) {
+        return ENOMEM;
+    }
+
+    actual_length = GetFullPathNameW(input, maximum_length, (WCHAR*)result->data, NULL);
+
+    if(actual_length < maximum_length) {
+        int has_long_path_prefix;
+        WCHAR *path_start;
+
+        /* Make sure we have a long-path prefix; GetFullPathNameW only adds one
+         * if the path is relative. */
+        has_long_path_prefix = actual_length >= LP_PREFIX_LENGTH &&
+            !sys_memcmp(result->data, LP_PREFIX, LP_PREFIX_SIZE);
+
+        if(!has_long_path_prefix) {
+            sys_memmove(result->data + LP_PREFIX_SIZE, result->data,
+                (actual_length + 1) * sizeof(WCHAR));
+            sys_memcpy(result->data, LP_PREFIX, LP_PREFIX_SIZE);
+            actual_length += LP_PREFIX_LENGTH;
+        }
+
+        path_start = (WCHAR*)result->data;
+
+        /* We're removing trailing slashes since quite a few APIs refuse to
+         * work with them, and none require them. We only check the last
+         * character since GetFullPathNameW folds slashes together. */
+        if(IS_SLASH(path_start[actual_length - 1])) {
+            if(path_start[actual_length - 2] != L':') {
+                path_start[actual_length - 1] = L'\0';
+                actual_length--;
+            }
+        }
+
+        if(!enif_realloc_binary(result, (actual_length + 1) * sizeof(WCHAR))) {
+            enif_release_binary(result);
+            return ENOMEM;
+        }
+
+        enif_make_binary(env, result);
+        return 0;
+    }
+
+    /* We may end up here if the current directory changes to something longer
+     * between/during GetFullPathName. There's nothing sensible we can do about
+     * this. */
+
+    enif_release_binary(result);
+
+    return EINVAL;
+}
+
+posix_errno_t efile_marshal_path(ErlNifEnv *env, ERL_NIF_TERM path, efile_path_t *result) {
+    ErlNifBinary raw_path;
+
+    if(!enif_inspect_binary(env, path, &raw_path)) {
+        return EINVAL;
+    } else if(raw_path.size % sizeof(WCHAR)) {
+        return EINVAL;
+    }
+
+    if(has_invalid_null_termination(&raw_path)) {
+        return EINVAL;
+    }
+
+    return get_full_path(env, (WCHAR*)raw_path.data, result);
+}
+
+ERL_NIF_TERM efile_get_handle(ErlNifEnv *env, efile_data_t *d) {
+    efile_win_t *w = (efile_win_t*)d;
+
+    ERL_NIF_TERM result;
+    unsigned char *bits;
+
+    bits = enif_make_new_binary(env, sizeof(w->handle), &result);
+    memcpy(bits, &w->handle, sizeof(w->handle));
+
+    return result;
+}
+
+/** @brief Converts a native path to the preferred form in "erlang space,"
+ * without path-prefixes, forward-slashes, or NUL terminators. */
+static int normalize_path_result(ErlNifBinary *path) {
+    WCHAR *path_iterator, *path_start, *path_end;
+    int length;
+
+    path_start = (WCHAR*)path->data;
+    length = wcslen(path_start);
+
+    ASSERT(length < path->size / sizeof(WCHAR));
+
+    /* Get rid of the long-path prefix, if present. */
+    if(length >= LP_PREFIX_LENGTH) {
+        if(!sys_memcmp(path_start, LP_PREFIX, LP_PREFIX_SIZE)) {
+            length -= LP_PREFIX_LENGTH;
+
+            sys_memmove(path_start, &path_start[LP_PREFIX_LENGTH],
+                length * sizeof(WCHAR));
+        }
+    }
+
+    path_end = &path_start[length];
+    path_iterator = path_start;
+
+    /* Convert drive letters to lowercase, if present. */
+    if(length >= 2 && path_start[1] == L':') {
+        WCHAR drive_letter = path_start[0];
+
+        if(drive_letter >= L'A' && drive_letter <= L'Z') {
+            path_start[0] = drive_letter - L'A' + L'a';
+        }
+    }
+
+    while(path_iterator < path_end) {
+        if(*path_iterator == L'\\') {
+            *path_iterator = L'/';
+        }
+
+        path_iterator++;
+    }
+
+    /* Truncate the result to its actual length; we don't want to include the
+     * NUL terminator. */
+    return enif_realloc_binary(path, length * sizeof(WCHAR));
+}
+
+/* @brief Checks whether all the given attributes are set on the object at the
+ * given path. Note that it assumes false on errors. */
+static int has_file_attributes(const efile_path_t *path, DWORD mask) {
+    DWORD attributes = GetFileAttributesW((WCHAR*)path->data);
+
+    if(attributes == INVALID_FILE_ATTRIBUTES) {
+        return 0;
+    }
+
+    return !!((attributes & mask) == mask);
+}
+
+static int is_ignored_name(int name_length, const WCHAR *name) {
+    if(name_length == 1 && name[0] == L'.') {
+        return 1;
+    } else if(name_length == 2 && !sys_memcmp(name, L"..", 2 * sizeof(WCHAR))) {
+        return 1;
+    }
+
+    return 0;
+}
+
+static int get_drive_number(const efile_path_t *path) {
+    const WCHAR *path_start;
+    int length;
+
+    ASSERT_PATH_FORMAT(path);
+
+    path_start = (WCHAR*)path->data + LP_PREFIX_LENGTH;
+    length = PATH_LENGTH(path) - LP_PREFIX_LENGTH;
+
+    if(length >= 2 && path_start[1] == L':') {
+        WCHAR drive_letter = path_start[0];
+
+        if(drive_letter >= L'A' && drive_letter <= L'Z') {
+            return drive_letter - L'A' + 1;
+        } else if(drive_letter >= L'a' && drive_letter <= L'z') {
+            return drive_letter - L'a' + 1;
+        }
+    }
+
+    return -1;
+}
+
+/* @brief Checks whether two *paths* are on the same mount point; they don't
+ * have to refer to existing or accessible files/directories. */
+static int has_same_mount_point(const efile_path_t *path_a, const efile_path_t *path_b) {
+    WCHAR *mount_a, *mount_b;
+    int result = 0;
+
+    mount_a = enif_alloc(path_a->size);
+    mount_b = enif_alloc(path_b->size);
+
+    if(mount_a != NULL && mount_b != NULL) {
+        int length_a, length_b;
+
+        length_a = PATH_LENGTH(path_a);
+        length_b = PATH_LENGTH(path_b);
+
+        if(GetVolumePathNameW((WCHAR*)path_a->data, mount_a, length_a)) {
+            ASSERT(wcslen(mount_a) <= length_a);
+
+            if(GetVolumePathNameW((WCHAR*)path_b->data, mount_b, length_b)) {
+                ASSERT(wcslen(mount_b) <= length_b);
+
+                result = !_wcsicmp(mount_a, mount_b);
+            }
+        }
+    }
+
+    if(mount_b != NULL) {
+        enif_free(mount_b);
+    }
+
+    if(mount_a != NULL) {
+        enif_free(mount_a);
+    }
+
+    return result;
+}
+
+/* Mirrors the PathIsRootW function of the shell API, but doesn't choke on
+ * paths longer than MAX_PATH. */
+static int is_path_root(const efile_path_t *path) {
+    const WCHAR *path_start, *path_end;
+    int length;
+
+    ASSERT_PATH_FORMAT(path);
+
+    path_start = (WCHAR*)path->data + LP_PREFIX_LENGTH;
+    length = PATH_LENGTH(path) - LP_PREFIX_LENGTH;
+
+    path_end = &path_start[length];
+
+    if(length == 1) {
+        /* A single \ refers to the root of the current working directory. */
+        return IS_SLASH(path_start[0]);
+    } else if(length == 3 && iswalpha(path_start[0]) && path_start[1] == L':') {
+        /* Drive letter. */
+        return IS_SLASH(path_start[2]);
+    } else if(length >= 4) {
+        /* Check whether we're a UNC root, eg. \\server, \\server\share */
+        const WCHAR *path_iterator;
+
+        if(!IS_SLASH(path_start[0]) || !IS_SLASH(path_start[1])) {
+            return 0;
+        }
+
+        path_iterator = path_start + 2;
+
+        /* Slide to the slash between the server and share names, if present. */
+        while(path_iterator < path_end && !IS_SLASH(*path_iterator)) {
+            path_iterator++;
+        }
+
+        /* Slide past the end of the string, stopping at the first slash we
+         * encounter. */
+        do {
+            path_iterator++;
+        }  while(path_iterator < path_end && !IS_SLASH(*path_iterator));
+
+        /* If we're past the end of the string and it didnt't end with a slash,
+         * then we're a root path. */
+        return path_iterator >= path_end && !IS_SLASH(path_start[length - 1]);
+    }
+
+    return 0;
+}
+
+posix_errno_t efile_open(const efile_path_t *path, enum efile_modes_t modes,
+        ErlNifResourceType *nif_type, efile_data_t **d) {
+
+    DWORD attributes, access_flags, open_mode;
+    HANDLE handle;
+
+    ASSERT_PATH_FORMAT(path);
+
+    access_flags = 0;
+    open_mode = 0;
+
+    if(modes & EFILE_MODE_READ && !(modes & EFILE_MODE_WRITE)) {
+        access_flags = GENERIC_READ;
+        open_mode = OPEN_EXISTING;
+    } else if(modes & EFILE_MODE_WRITE && !(modes & EFILE_MODE_READ)) {
+        access_flags = GENERIC_WRITE;
+        open_mode = CREATE_ALWAYS;
+    } else if(modes & EFILE_MODE_READ_WRITE) {
+        access_flags = GENERIC_READ | GENERIC_WRITE;
+        open_mode = OPEN_ALWAYS;
+    } else {
+        return EINVAL;
+    }
+
+    if(modes & EFILE_MODE_APPEND) {
+        access_flags |= FILE_APPEND_DATA;
+        open_mode = OPEN_ALWAYS;
+    }
+
+    if(modes & EFILE_MODE_EXCLUSIVE) {
+        open_mode = CREATE_NEW;
+    }
+
+    if(modes & EFILE_MODE_SYNC) {
+        attributes = FILE_FLAG_WRITE_THROUGH;
+    } else {
+        attributes = FILE_ATTRIBUTE_NORMAL;
+    }
+
+    handle = CreateFileW((WCHAR*)path->data, access_flags,
+        FILE_SHARE_FLAGS, NULL, open_mode, attributes, NULL);
+
+    if(handle != INVALID_HANDLE_VALUE) {
+        efile_win_t *w;
+
+        w = (efile_win_t*)enif_alloc_resource(nif_type, sizeof(efile_win_t));
+        w->handle = handle;
+
+        EFILE_INIT_RESOURCE(&w->common, modes);
+        (*d) = &w->common;
+
+        return 0;
+    } else {
+        DWORD last_error = GetLastError();
+
+        /* Rewrite all failures on directories to EISDIR to match the old
+         * driver. */
+        if(has_file_attributes(path, FILE_ATTRIBUTE_DIRECTORY)) {
+            return EISDIR;
+        }
+
+        return windows_to_posix_errno(last_error);
+    }
+}
+
+int efile_close(efile_data_t *d) {
+    efile_win_t *w = (efile_win_t*)d;
+    HANDLE handle;
+
+    ASSERT(erts_atomic32_read_nob(&d->state) == EFILE_STATE_CLOSED);
+    ASSERT(w->handle != INVALID_HANDLE_VALUE);
+
+    handle = w->handle;
+    w->handle = INVALID_HANDLE_VALUE;
+
+    if(!CloseHandle(handle)) {
+        w->common.posix_errno = windows_to_posix_errno(GetLastError());
+        return 0;
+    }
+
+    return 1;
+}
+
+static void shift_overlapped(OVERLAPPED *overlapped, DWORD shift) {
+    LARGE_INTEGER offset;
+
+    ASSERT(shift >= 0);
+
+    offset.HighPart = overlapped->OffsetHigh;
+    offset.LowPart = overlapped->Offset;
+
+    /* ~(Uint64)0 is a magic value ("append to end of file") which needs to be
+     * preserved. Other positions resulting in overflow would have errored out
+     * just prior to this point. */
+    if(offset.QuadPart != ERTS_UINT64_MAX) {
+        offset.QuadPart += shift;
+    }
+
+    /* All unused fields must be zeroed for the next call. */
+    sys_memset(overlapped, 0, sizeof(*overlapped));
+    overlapped->OffsetHigh = offset.HighPart;
+    overlapped->Offset = offset.LowPart;
+}
+
+static void shift_iov(SysIOVec **iov, int *iovlen, DWORD shift) {
+    SysIOVec *head_vec = (*iov);
+
+    ASSERT(shift >= 0);
+
+    while(shift > 0) {
+        ASSERT(head_vec < &(*iov)[*iovlen]);
+
+        if(shift < head_vec->iov_len) {
+            head_vec->iov_base = (char*)head_vec->iov_base + shift;
+            head_vec->iov_len -= shift;
+            break;
+        } else {
+            shift -= head_vec->iov_len;
+            head_vec++;
+        }
+    }
+
+    (*iovlen) -= head_vec - (*iov);
+    (*iov) = head_vec;
+}
+
+typedef BOOL (WINAPI *io_op_t)(HANDLE, LPVOID, DWORD, LPDWORD, LPOVERLAPPED);
+
+static Sint64 internal_sync_io(efile_win_t *w, io_op_t operation,
+        SysIOVec *iov, int iovlen, OVERLAPPED *overlapped) {
+
+    Sint64 bytes_processed = 0;
+
+    for(;;) {
+        DWORD block_bytes_processed, last_error;
+        BOOL succeeded;
+
+        if(iovlen < 1) {
+            return bytes_processed;
+        }
+
+        succeeded = operation(w->handle, iov->iov_base, iov->iov_len,
+            &block_bytes_processed, overlapped);
+        last_error = GetLastError();
+
+        if(!succeeded && (last_error != ERROR_HANDLE_EOF)) {
+            w->common.posix_errno = windows_to_posix_errno(last_error);
+            return -1;
+        } else if(block_bytes_processed == 0) {
+            /* EOF */
+            return bytes_processed;
+        }
+
+        if(overlapped != NULL) {
+            shift_overlapped(overlapped, block_bytes_processed);
+        }
+
+        shift_iov(&iov, &iovlen, block_bytes_processed);
+
+        bytes_processed += block_bytes_processed;
+    }
+}
+
+Sint64 efile_readv(efile_data_t *d, SysIOVec *iov, int iovlen) {
+    efile_win_t *w = (efile_win_t*)d;
+
+    return internal_sync_io(w, ReadFile, iov, iovlen, NULL);
+}
+
+Sint64 efile_writev(efile_data_t *d, SysIOVec *iov, int iovlen) {
+    efile_win_t *w = (efile_win_t*)d;
+
+    OVERLAPPED __overlapped, *overlapped;
+    Uint64 bytes_written;
+
+    if(w->common.modes & EFILE_MODE_APPEND) {
+        overlapped = &__overlapped;
+
+        sys_memset(overlapped, 0, sizeof(*overlapped));
+        overlapped->OffsetHigh = 0xFFFFFFFF;
+        overlapped->Offset = 0xFFFFFFFF;
+    } else {
+        overlapped = NULL;
+    }
+
+    return internal_sync_io(w, WriteFile, iov, iovlen, overlapped);
+}
+
+Sint64 efile_preadv(efile_data_t *d, Sint64 offset, SysIOVec *iov, int iovlen) {
+    efile_win_t *w = (efile_win_t*)d;
+
+    OVERLAPPED overlapped;
+
+    sys_memset(&overlapped, 0, sizeof(overlapped));
+    overlapped.OffsetHigh = (offset >> 32) & 0xFFFFFFFF;
+    overlapped.Offset = offset & 0xFFFFFFFF;
+
+    return internal_sync_io(w, ReadFile, iov, iovlen, &overlapped);
+}
+
+Sint64 efile_pwritev(efile_data_t *d, Sint64 offset, SysIOVec *iov, int iovlen) {
+    efile_win_t *w = (efile_win_t*)d;
+
+    OVERLAPPED overlapped;
+
+    sys_memset(&overlapped, 0, sizeof(overlapped));
+    overlapped.OffsetHigh = (offset >> 32) & 0xFFFFFFFF;
+    overlapped.Offset = offset & 0xFFFFFFFF;
+
+    return internal_sync_io(w, WriteFile, iov, iovlen, &overlapped);
+}
+
+int efile_seek(efile_data_t *d, enum efile_seek_t seek, Sint64 offset, Sint64 *new_position) {
+    efile_win_t *w = (efile_win_t*)d;
+
+    LARGE_INTEGER large_offset, large_new_position;
+    DWORD whence;
+
+    switch(seek) {
+        case EFILE_SEEK_BOF: whence = FILE_BEGIN; break;
+        case EFILE_SEEK_CUR: whence = FILE_CURRENT; break;
+        case EFILE_SEEK_EOF: whence = FILE_END; break;
+        default: ERTS_INTERNAL_ERROR("Invalid seek parameter");
+    }
+
+    large_offset.QuadPart = offset;
+
+    if(!SetFilePointerEx(w->handle, large_offset, &large_new_position, whence)) {
+        w->common.posix_errno = windows_to_posix_errno(GetLastError());
+        return 0;
+    }
+
+    (*new_position) = large_new_position.QuadPart;
+
+    return 1;
+}
+
+int efile_sync(efile_data_t *d, int data_only) {
+    efile_win_t *w = (efile_win_t*)d;
+
+    /* Windows doesn't support data-only syncing. */
+    (void)data_only;
+
+    if(!FlushFileBuffers(w->handle)) {
+        w->common.posix_errno = windows_to_posix_errno(GetLastError());
+        return 0;
+    }
+
+    return 1;
+}
+
+int efile_advise(efile_data_t *d, Sint64 offset, Sint64 length, enum efile_advise_t advise) {
+    /* Windows doesn't support this, but we'll pretend it does since the call
+     * is only a recommendation even on systems that do support it. */
+
+    (void)d;
+    (void)offset;
+    (void)length;
+    (void)advise;
+
+    return 1;
+}
+
+int efile_allocate(efile_data_t *d, Sint64 offset, Sint64 length) {
+    efile_win_t *w = (efile_win_t*)d;
+
+    (void)d;
+    (void)offset;
+    (void)length;
+
+    w->common.posix_errno = ENOTSUP;
+
+    return 0;
+}
+
+int efile_truncate(efile_data_t *d) {
+    efile_win_t *w = (efile_win_t*)d;
+
+    if(!SetEndOfFile(w->handle)) {
+        w->common.posix_errno = windows_to_posix_errno(GetLastError());
+        return 0;
+    }
+
+    return 1;
+}
+
+static int is_executable_file(const efile_path_t *path) {
+    /* We're using the file extension in order to be quirks-compliant with the
+     * old driver, which never bothered to check the actual permissions. We
+     * could easily do so now (cf. GetNamedSecurityInfo) but the execute
+     * permission is only relevant for files that are started with the default
+     * loader, and batch files run just fine with read permission alone. */
+
+    int length = PATH_LENGTH(path);
+
+    if(length >= 4) {
+        const WCHAR *last_four = &((WCHAR*)path->data)[length - 4];
+
+        if (!_wcsicmp(last_four, L".exe") ||
+            !_wcsicmp(last_four, L".cmd") ||
+            !_wcsicmp(last_four, L".bat") ||
+            !_wcsicmp(last_four, L".com")) {
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+posix_errno_t efile_read_info(const efile_path_t *path, int follow_links, efile_fileinfo_t *result) {
+    BY_HANDLE_FILE_INFORMATION native_file_info;
+    DWORD attributes;
+
+    sys_memset(&native_file_info, 0, sizeof(native_file_info));
+
+    attributes = GetFileAttributesW((WCHAR*)path->data);
+
+    if(attributes == INVALID_FILE_ATTRIBUTES) {
+        DWORD last_error = GetLastError();
+
+        /* Querying a network share root fails with ERROR_BAD_NETPATH, so we'll
+         * fake it as a directory just like local roots. */
+        if(!is_path_root(path) || last_error != ERROR_BAD_NETPATH) {
+            return windows_to_posix_errno(last_error);
+        }
+
+        attributes = FILE_ATTRIBUTE_DIRECTORY;
+    } else if(is_path_root(path)) {
+        /* Local (or mounted) roots can be queried with GetFileAttributesW but
+         * lack support for GetFileInformationByHandle, so we'll skip that
+         * part. */
+    } else {
+        HANDLE handle;
+
+        if(follow_links && (attributes & FILE_ATTRIBUTE_REPARSE_POINT)) {
+            posix_errno_t posix_errno;
+            efile_path_t resolved_path;
+
+            posix_errno = internal_read_link(path, &resolved_path);
+
+            if(posix_errno != 0) {
+                return posix_errno;
+            }
+
+            return efile_read_info(&resolved_path, 0, result);
+        }
+
+        handle = CreateFileW((const WCHAR*)path->data, GENERIC_READ,
+            FILE_SHARE_FLAGS, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS,
+            NULL);
+
+        /* The old driver never cared whether this succeeded. */
+        if(handle != INVALID_HANDLE_VALUE) {
+            GetFileInformationByHandle(handle, &native_file_info);
+            CloseHandle(handle);
+        }
+
+        FILETIME_TO_EPOCH(result->m_time, native_file_info.ftLastWriteTime);
+        FILETIME_TO_EPOCH(result->a_time, native_file_info.ftLastAccessTime);
+        FILETIME_TO_EPOCH(result->c_time, native_file_info.ftCreationTime);
+
+        if(result->m_time == -EPOCH_DIFFERENCE) {
+            /* Default to 1970 just like the old driver. */
+            result->m_time = 0;
+        }
+
+        if(result->a_time == -EPOCH_DIFFERENCE) {
+            result->a_time = result->m_time;
+        }
+
+        if(result->c_time == -EPOCH_DIFFERENCE) {
+            result->c_time = result->m_time;
+        }
+    }
+
+    if(attributes & FILE_ATTRIBUTE_REPARSE_POINT) {
+        result->type = EFILE_FILETYPE_SYMLINK;
+        /* This should be _S_IFLNK, but the old driver always set
+         * non-directories to _S_IFREG. */
+        result->mode |= _S_IFREG;
+    } else if(attributes & FILE_ATTRIBUTE_DIRECTORY) {
+        result->type = EFILE_FILETYPE_DIRECTORY;
+        result->mode |= _S_IFDIR | _S_IEXEC;
+    } else {
+        if(is_executable_file(path)) {
+            result->mode |= _S_IEXEC;
+        }
+
+        result->type = EFILE_FILETYPE_REGULAR;
+        result->mode |= _S_IFREG;
+    }
+
+    if(!(attributes & FILE_ATTRIBUTE_READONLY)) {
+        result->access = EFILE_ACCESS_READ | EFILE_ACCESS_WRITE;
+        result->mode |= _S_IREAD | _S_IWRITE;
+    } else {
+        result->access = EFILE_ACCESS_READ;
+        result->mode |= _S_IREAD;
+    }
+
+    /* Propagate user mode-bits to group/other fields */
+    result->mode |= (result->mode & 0700) >> 3;
+    result->mode |= (result->mode & 0700) >> 6;
+
+    result->size =
+        ((Uint64)native_file_info.nFileSizeHigh << 32ull) |
+        (Uint64)native_file_info.nFileSizeLow;
+
+    result->links = MAX(1, native_file_info.nNumberOfLinks);
+
+    result->major_device = get_drive_number(path);
+    result->minor_device = 0;
+    result->inode = 0;
+    result->uid = 0;
+    result->gid = 0;
+
+    return 0;
+}
+
+posix_errno_t efile_set_permissions(const efile_path_t *path, Uint32 permissions) {
+    DWORD attributes = GetFileAttributesW((WCHAR*)path->data);
+
+    if(attributes == INVALID_FILE_ATTRIBUTES) {
+        return windows_to_posix_errno(GetLastError());
+    }
+
+    if(permissions & _S_IWRITE) {
+        attributes &= ~FILE_ATTRIBUTE_READONLY;
+    } else {
+        attributes |= FILE_ATTRIBUTE_READONLY;
+    }
+
+    if(SetFileAttributesW((WCHAR*)path->data, attributes)) {
+        return 0;
+    }
+
+    return windows_to_posix_errno(GetLastError());
+}
+
+posix_errno_t efile_set_owner(const efile_path_t *path, Uint32 owner, Uint32 group) {
+    (void)path;
+    (void)owner;
+    (void)group;
+
+    return 0;
+}
+
+posix_errno_t efile_set_time(const efile_path_t *path, Sint64 a_time, Sint64 m_time, Sint64 c_time) {
+    FILETIME accessed, modified, created;
+    DWORD last_error, attributes;
+    HANDLE handle;
+
+    attributes = GetFileAttributesW((WCHAR*)path->data);
+
+    if(attributes == INVALID_FILE_ATTRIBUTES) {
+        return windows_to_posix_errno(GetLastError());
+    }
+
+    /* If the file is read-only, we have to make it temporarily writable while
+     * setting new metadata. */
+    if(attributes & FILE_ATTRIBUTE_READONLY) {
+        DWORD without_readonly = attributes & ~FILE_ATTRIBUTE_READONLY;
+
+        if(!SetFileAttributesW((WCHAR*)path->data, without_readonly)) {
+            return windows_to_posix_errno(GetLastError());
+        }
+    }
+
+    EPOCH_TO_FILETIME(modified, m_time);
+    EPOCH_TO_FILETIME(accessed, a_time);
+    EPOCH_TO_FILETIME(created, c_time);
+
+    handle = CreateFileW((WCHAR*)path->data, GENERIC_READ | GENERIC_WRITE,
+        FILE_SHARE_FLAGS, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
+    last_error = GetLastError();
+
+    if(handle != INVALID_HANDLE_VALUE) {
+        if(SetFileTime(handle, &created, &accessed, &modified)) {
+            last_error = ERROR_SUCCESS;
+        } else {
+            last_error = GetLastError();
+        }
+
+        CloseHandle(handle);
+    }
+
+    if(attributes & FILE_ATTRIBUTE_READONLY) {
+        SetFileAttributesW((WCHAR*)path->data, attributes);
+    }
+
+    return windows_to_posix_errno(last_error);
+}
+
+static posix_errno_t internal_read_link(const efile_path_t *path, efile_path_t *result) {
+    DWORD required_length, actual_length;
+    HANDLE link_handle;
+    DWORD last_error;
+
+    link_handle = CreateFileW((WCHAR*)path->data, GENERIC_READ,
+        FILE_SHARE_FLAGS, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
+    last_error = GetLastError();
+
+    if(link_handle == INVALID_HANDLE_VALUE) {
+        return windows_to_posix_errno(last_error);
+    }
+
+    required_length = GetFinalPathNameByHandleW(link_handle, NULL, 0, 0);
+    last_error = GetLastError();
+
+    if(required_length <= 0) {
+        CloseHandle(link_handle);
+        return windows_to_posix_errno(last_error);
+    }
+
+    /* Unlike many other path functions (eg. GetFullPathNameW), this one
+     * includes the NUL terminator in its required length. */
+    if(!enif_alloc_binary(required_length * sizeof(WCHAR), result)) {
+        CloseHandle(link_handle);
+        return ENOMEM;
+    }
+
+    actual_length = GetFinalPathNameByHandleW(link_handle,
+        (WCHAR*)result->data, required_length, 0);
+    last_error = GetLastError();
+
+    CloseHandle(link_handle);
+
+    if(actual_length == 0 || actual_length >= required_length) {
+        enif_release_binary(result);
+        return windows_to_posix_errno(last_error);
+    }
+
+    /* GetFinalPathNameByHandle always prepends with "\\?\" and NUL-terminates,
+     * so we never have to touch-up the resulting path. */
+
+    ASSERT_PATH_FORMAT(result);
+
+    return 0;
+}
+
+posix_errno_t efile_read_link(ErlNifEnv *env, const efile_path_t *path, ERL_NIF_TERM *result) {
+    posix_errno_t posix_errno;
+    ErlNifBinary result_bin;
+    DWORD attributes;
+
+    ASSERT_PATH_FORMAT(path);
+
+    attributes = GetFileAttributesW((WCHAR*)path->data);
+
+    if(attributes == INVALID_FILE_ATTRIBUTES) {
+        return windows_to_posix_errno(GetLastError());
+    } else if(!(attributes & FILE_ATTRIBUTE_REPARSE_POINT)) {
+        return EINVAL;
+    }
+
+    posix_errno = internal_read_link(path, &result_bin);
+
+    if(posix_errno == 0) {
+        if(!normalize_path_result(&result_bin)) {
+            enif_release_binary(&result_bin);
+            return ENOMEM;
+        }
+
+        (*result) = enif_make_binary(env, &result_bin);
+    }
+
+    return posix_errno;
+}
+
+posix_errno_t efile_list_dir(ErlNifEnv *env, const efile_path_t *path, ERL_NIF_TERM *result) {
+    ERL_NIF_TERM list_head;
+    WIN32_FIND_DATAW data;
+    HANDLE search_handle;
+    WCHAR *search_path;
+    DWORD last_error;
+
+    ASSERT_PATH_FORMAT(path);
+
+    search_path = enif_alloc(path->size + 2 * sizeof(WCHAR));
+
+    if(search_path == NULL) {
+        return ENOMEM;
+    }
+
+    sys_memcpy(search_path, path->data, path->size);
+    search_path[PATH_LENGTH(path) + 0] = L'\\';
+    search_path[PATH_LENGTH(path) + 1] = L'*';
+    search_path[PATH_LENGTH(path) + 2] = L'\0';
+
+    search_handle = FindFirstFileW(search_path, &data);
+    last_error = GetLastError();
+
+    enif_free(search_path);
+
+    if(search_handle == INVALID_HANDLE_VALUE) {
+        return windows_to_posix_errno(last_error);
+    }
+
+    list_head = enif_make_list(env, 0);
+
+    do {
+        int name_length = wcslen(data.cFileName);
+
+        if(!is_ignored_name(name_length, data.cFileName)) {
+            unsigned char *name_bytes;
+            ERL_NIF_TERM name_term;
+            size_t name_size;
+
+            name_size = name_length * sizeof(WCHAR);
+
+            name_bytes = enif_make_new_binary(env, name_size, &name_term);
+            sys_memcpy(name_bytes, data.cFileName, name_size);
+
+            list_head = enif_make_list_cell(env, name_term, list_head);
+        }
+    } while(FindNextFileW(search_handle, &data));
+
+    FindClose(search_handle);
+    (*result) = list_head;
+
+    return 0;
+}
+
+posix_errno_t efile_rename(const efile_path_t *old_path, const efile_path_t *new_path) {
+    BOOL old_is_directory, new_is_directory;
+    DWORD move_flags, last_error;
+
+    ASSERT_PATH_FORMAT(old_path);
+    ASSERT_PATH_FORMAT(new_path);
+
+    move_flags = MOVEFILE_COPY_ALLOWED | MOVEFILE_WRITE_THROUGH;
+
+    if(MoveFileExW((WCHAR*)old_path->data, (WCHAR*)new_path->data, move_flags)) {
+        return 0;
+    }
+
+    last_error = GetLastError();
+
+    old_is_directory = has_file_attributes(old_path, FILE_ATTRIBUTE_DIRECTORY);
+    new_is_directory = has_file_attributes(new_path, FILE_ATTRIBUTE_DIRECTORY);
+
+    switch(last_error) {
+    case ERROR_SHARING_VIOLATION:
+    case ERROR_ACCESS_DENIED:
+        if(old_is_directory) {
+            BOOL moved_into_itself;
+
+            moved_into_itself = (old_path->size <= new_path->size) &&
+                !_wcsnicmp((WCHAR*)old_path->data, (WCHAR*)new_path->data,
+                    PATH_LENGTH(old_path));
+
+            if(moved_into_itself) {
+                return EINVAL;
+            } else if(is_path_root(old_path)) {
+                return EINVAL;
+            }
+
+            /* Renaming a directory across volumes needs to be rewritten as
+             * EXDEV so that the caller can respond by simulating it with
+             * copy/delete operations.
+             *
+             * Files are handled through MOVEFILE_COPY_ALLOWED. */
+            if(!has_same_mount_point(old_path, new_path)) {
+                return EXDEV;
+            }
+        }
+        break;
+    case ERROR_PATH_NOT_FOUND:
+    case ERROR_FILE_NOT_FOUND:
+        return ENOENT;
+    case ERROR_ALREADY_EXISTS:
+    case ERROR_FILE_EXISTS:
+        if(old_is_directory && !new_is_directory) {
+            return ENOTDIR;
+        } else if(!old_is_directory && new_is_directory) {
+            return EISDIR;
+        } else if(old_is_directory && new_is_directory) {
+            /* This will fail if the destination isn't empty. */
+            if(RemoveDirectoryW((WCHAR*)new_path->data)) {
+                return efile_rename(old_path, new_path);
+            }
+
+            return EEXIST;
+        } else if(!old_is_directory && !new_is_directory) {
+            /* This is pretty iffy; the public documentation says that the
+             * operation may EACCES on some systems when either file is open,
+             * which gives us room to use MOVEFILE_REPLACE_EXISTING and be done
+             * with it, but the old implementation simulated Unix semantics and
+             * there's a lot of code that relies on that.
+             *
+             * The simulation renames the destination to a scratch name to get
+             * around the fact that it's impossible to open (and by extension
+             * rename) a file that's been deleted while open. It has a few
+             * drawbacks though;
+             *
+             * 1) It's not atomic as there's a small window where there's no
+             *    file at all on the destination path.
+             * 2) It will confuse applications that subscribe to folder
+             *    changes.
+             * 3) It will fail if we lack general permission to write in the
+             *    same folder. */
+
+            WCHAR *swap_path = enif_alloc(new_path->size + sizeof(WCHAR) * 64);
+
+            if(swap_path == NULL) {
+                return ENOMEM;
+            } else {
+                static LONGLONG unique_counter = 0;
+                WCHAR *swap_path_end;
+
+                /* We swap in the same folder as the destination to be
+                 * reasonably sure that it's on the same volume. Note that
+                 * we're avoiding GetTempFileNameW as it will fail on long
+                 * paths. */
+
+                sys_memcpy(swap_path, (WCHAR*)new_path->data, new_path->size);
+                swap_path_end = swap_path + PATH_LENGTH(new_path);
+
+                while(!IS_SLASH(*swap_path_end)) {
+                    ASSERT(swap_path_end > swap_path);
+                    swap_path_end--;
+                }
+
+                StringCchPrintfW(&swap_path_end[1], 64, L"erl-%lx-%llx.tmp",
+                    GetCurrentProcessId(), unique_counter);
+                InterlockedIncrement64(&unique_counter);
+            }
+
+            if(MoveFileExW((WCHAR*)new_path->data, swap_path, MOVEFILE_REPLACE_EXISTING)) {
+                if(MoveFileExW((WCHAR*)old_path->data, (WCHAR*)new_path->data, move_flags)) {
+                    last_error = ERROR_SUCCESS;
+                    DeleteFileW(swap_path);
+                } else {
+                    last_error = GetLastError();
+                    MoveFileW(swap_path, (WCHAR*)new_path->data);
+                }
+            } else {
+                last_error = GetLastError();
+                DeleteFileW(swap_path);
+            }
+
+            enif_free(swap_path);
+
+            return windows_to_posix_errno(last_error);
+        }
+
+        return EEXIST;
+    }
+
+    return windows_to_posix_errno(last_error);
+}
+
+posix_errno_t efile_make_hard_link(const efile_path_t *existing_path, const efile_path_t *new_path) {
+    ASSERT_PATH_FORMAT(existing_path);
+    ASSERT_PATH_FORMAT(new_path);
+
+    if(!CreateHardLinkW((WCHAR*)new_path->data, (WCHAR*)existing_path->data, NULL)) {
+        return windows_to_posix_errno(GetLastError());
+    }
+
+    return 0;
+}
+
+posix_errno_t efile_make_soft_link(const efile_path_t *existing_path, const efile_path_t *new_path) {
+    DWORD link_flags;
+
+    ASSERT_PATH_FORMAT(existing_path);
+    ASSERT_PATH_FORMAT(new_path);
+
+    if(has_file_attributes(existing_path, FILE_ATTRIBUTE_DIRECTORY)) {
+        link_flags = SYMBOLIC_LINK_FLAG_DIRECTORY;
+    } else {
+        link_flags = 0;
+    }
+
+    if(!CreateSymbolicLinkW((WCHAR*)new_path->data, (WCHAR*)existing_path->data, link_flags)) {
+        return windows_to_posix_errno(GetLastError());
+    }
+
+    return 0;
+}
+
+posix_errno_t efile_make_dir(const efile_path_t *path) {
+    ASSERT_PATH_FORMAT(path);
+
+    if(!CreateDirectoryW((WCHAR*)path->data, NULL)) {
+        return windows_to_posix_errno(GetLastError());
+    }
+
+    return 0;
+}
+
+posix_errno_t efile_del_file(const efile_path_t *path) {
+    ASSERT_PATH_FORMAT(path);
+
+    if(!DeleteFileW((WCHAR*)path->data)) {
+        DWORD last_error = GetLastError();
+
+        switch(last_error) {
+        case ERROR_INVALID_NAME:
+            /* Attempted to delete a device or similar. */
+            return EACCES;
+        case ERROR_ACCESS_DENIED:
+            /* Windows NT reports removing a directory as EACCES instead of
+             * EPERM. */
+            if(has_file_attributes(path, FILE_ATTRIBUTE_DIRECTORY)) {
+                return EPERM;
+            }
+            break;
+        }
+
+        return windows_to_posix_errno(last_error);
+    }
+
+    return 0;
+}
+
+posix_errno_t efile_del_dir(const efile_path_t *path) {
+    ASSERT_PATH_FORMAT(path);
+
+    if(!RemoveDirectoryW((WCHAR*)path->data)) {
+        DWORD last_error = GetLastError();
+
+        if(last_error == ERROR_DIRECTORY) {
+            return ENOTDIR;
+        }
+
+        return windows_to_posix_errno(last_error);
+    }
+
+    return 0;
+}
+
+posix_errno_t efile_set_cwd(const efile_path_t *path) {
+    const WCHAR *path_start;
+
+    ASSERT_PATH_FORMAT(path);
+
+    /* We have to use _wchdir since that's the only function that updates the
+     * per-drive working directory, but it naively assumes that all paths
+     * starting with \\ are UNC paths, so we have to skip the \\?\-prefix. */
+    path_start = (WCHAR*)path->data + LP_PREFIX_LENGTH;
+
+    if(_wchdir(path_start)) {
+        return windows_to_posix_errno(GetLastError());
+    }
+
+    return 0;
+}
+
+static int is_valid_drive(int device_index) {
+    WCHAR drive_path[4] = {L'?', L':', L'\\', L'\0'};
+
+    if(device_index == 0) {
+        /* Default drive; always valid. */
+        return 1;
+    } else if(device_index > (L'Z' - L'A' + 1)) {
+        return 0;
+    }
+
+    drive_path[0] = device_index + L'A' - 1;
+
+    switch(GetDriveTypeW(drive_path)) {
+    case DRIVE_NO_ROOT_DIR:
+    case DRIVE_UNKNOWN:
+        return 0;
+    }
+
+    return 1;
+}
+
+posix_errno_t efile_get_device_cwd(ErlNifEnv *env, int device_index, ERL_NIF_TERM *result) {
+    ErlNifBinary result_bin;
+
+    /* _wgetdcwd might crash the entire emulator on debug builds since the CRT
+     * invalid parameter handler asserts if passed a non-existent drive (Or
+     * simply one that has been unmounted), so we check it ourselves to avoid
+     * that. */
+    if(!is_valid_drive(device_index)) {
+        return EACCES;
+    }
+
+    if(!enif_alloc_binary(MAX_PATH * sizeof(WCHAR), &result_bin)) {
+        return ENOMEM;
+    }
+
+    if(_wgetdcwd(device_index, (WCHAR*)result_bin.data, MAX_PATH) == NULL) {
+        enif_release_binary(&result_bin);
+        return EACCES;
+    }
+
+    if(!normalize_path_result(&result_bin)) {
+        enif_release_binary(&result_bin);
+        return ENOMEM;
+    }
+
+    (*result) = enif_make_binary(env, &result_bin);
+
+    return 0;
+}
+
+posix_errno_t efile_get_cwd(ErlNifEnv *env, ERL_NIF_TERM *result) {
+    return efile_get_device_cwd(env, 0, result);
+}
+
+posix_errno_t efile_altname(ErlNifEnv *env, const efile_path_t *path, ERL_NIF_TERM *result) {
+    ErlNifBinary result_bin;
+
+    ASSERT_PATH_FORMAT(path);
+
+    if(is_path_root(path)) {
+        /* Root paths can't be queried so we'll just return them as they are. */
+        if(!enif_alloc_binary(path->size, &result_bin)) {
+            return ENOMEM;
+        }
+
+        sys_memcpy(result_bin.data, path->data, path->size);
+    } else {
+        WIN32_FIND_DATAW data;
+        HANDLE handle;
+
+        WCHAR *name_buffer;
+        int name_length;
+
+        /* Reject path wildcards. */
+        if(wcspbrk(&((const WCHAR*)path->data)[4], L"?*")) {
+            return ENOENT;
+        }
+
+        handle = FindFirstFileW((const WCHAR*)path->data, &data);
+
+        if(handle == INVALID_HANDLE_VALUE) {
+            return windows_to_posix_errno(GetLastError());
+        }
+
+        FindClose(handle);
+
+        name_length = wcslen(data.cAlternateFileName);
+
+        if(name_length > 0) {
+            name_buffer = data.cAlternateFileName;
+        } else {
+            name_length = wcslen(data.cFileName);
+            name_buffer = data.cFileName;
+        }
+
+        /* Include NUL-terminator; it will be removed after normalization. */
+        name_length += 1;
+
+        if(!enif_alloc_binary(name_length * sizeof(WCHAR), &result_bin)) {
+            return ENOMEM;
+        }
+
+        sys_memcpy(result_bin.data, name_buffer, name_length * sizeof(WCHAR));
+    }
+
+    if(!normalize_path_result(&result_bin)) {
+        enif_release_binary(&result_bin);
+        return ENOMEM;
+    }
+
+    (*result) = enif_make_binary(env, &result_bin);
+
+    return 0;
+}
+
+static int windows_to_posix_errno(DWORD last_error) {
+    switch(last_error) {
+    case ERROR_SUCCESS:
+        return 0;
+    case ERROR_INVALID_FUNCTION:
+    case ERROR_INVALID_DATA:
+    case ERROR_INVALID_PARAMETER:
+    case ERROR_INVALID_TARGET_HANDLE:
+    case ERROR_INVALID_CATEGORY:
+    case ERROR_NEGATIVE_SEEK:
+        return EINVAL;
+    case ERROR_DIR_NOT_EMPTY:
+        return EEXIST;
+    case ERROR_BAD_FORMAT:
+        return ENOEXEC;
+    case ERROR_PATH_NOT_FOUND:
+    case ERROR_FILE_NOT_FOUND:
+    case ERROR_NO_MORE_FILES:
+        return ENOENT;
+    case ERROR_TOO_MANY_OPEN_FILES:
+        return EMFILE;
+    case ERROR_ACCESS_DENIED:
+    case ERROR_INVALID_ACCESS:
+    case ERROR_CURRENT_DIRECTORY:
+    case ERROR_SHARING_VIOLATION:
+    case ERROR_LOCK_VIOLATION:
+    case ERROR_INVALID_PASSWORD:
+    case ERROR_DRIVE_LOCKED:
+        return EACCES;
+    case ERROR_INVALID_HANDLE:
+        return EBADF;
+    case ERROR_NOT_ENOUGH_MEMORY:
+    case ERROR_OUTOFMEMORY:
+    case ERROR_OUT_OF_STRUCTURES:
+        return ENOMEM;
+    case ERROR_INVALID_DRIVE:
+    case ERROR_BAD_UNIT:
+    case ERROR_NOT_READY:
+    case ERROR_REM_NOT_LIST:
+    case ERROR_DUP_NAME:
+    case ERROR_BAD_NETPATH:
+    case ERROR_NETWORK_BUSY:
+    case ERROR_DEV_NOT_EXIST:
+    case ERROR_BAD_NET_NAME:
+        return ENXIO;
+    case ERROR_NOT_SAME_DEVICE:
+        return EXDEV;
+    case ERROR_WRITE_PROTECT:
+        return EROFS;
+    case ERROR_BAD_LENGTH:
+    case ERROR_BUFFER_OVERFLOW:
+        return E2BIG;
+    case ERROR_SEEK:
+    case ERROR_SECTOR_NOT_FOUND:
+        return ESPIPE;
+    case ERROR_NOT_DOS_DISK:
+        return ENODEV;
+    case ERROR_GEN_FAILURE:
+        return ENODEV;
+    case ERROR_SHARING_BUFFER_EXCEEDED:
+    case ERROR_NO_MORE_SEARCH_HANDLES:
+        return EMFILE;
+    case ERROR_HANDLE_EOF:
+    case ERROR_BROKEN_PIPE:
+        return EPIPE;
+    case ERROR_HANDLE_DISK_FULL:
+    case ERROR_DISK_FULL:
+        return ENOSPC;
+    case ERROR_NOT_SUPPORTED:
+        return ENOTSUP;
+    case ERROR_FILE_EXISTS:
+    case ERROR_ALREADY_EXISTS:
+    case ERROR_CANNOT_MAKE:
+        return EEXIST;
+    case ERROR_ALREADY_ASSIGNED:
+        return EBUSY;
+    case ERROR_NO_PROC_SLOTS:
+        return EAGAIN;
+    case ERROR_CANT_RESOLVE_FILENAME:
+        return EMLINK;
+    case ERROR_PRIVILEGE_NOT_HELD:
+        return EPERM;
+    case ERROR_ARENA_TRASHED:
+    case ERROR_INVALID_BLOCK:
+    case ERROR_BAD_ENVIRONMENT:
+    case ERROR_BAD_COMMAND:
+    case ERROR_CRC:
+    case ERROR_OUT_OF_PAPER:
+    case ERROR_READ_FAULT:
+    case ERROR_WRITE_FAULT:
+    case ERROR_WRONG_DISK:
+    case ERROR_NET_WRITE_FAULT:
+        return EIO;
+    default: /* not to do with files I expect. */
+        return EIO;
+    }
+}