Merge branch 'john/erts/putenv-thread-safety/OTP-14666'

27 files changed, 1361 insertions, 957 deletions

diff --git a/erts/doc/src/erl_driver.xml b/erts/doc/src/erl_driver.xml
index ca9d458e1e..c790872fe4 100644
--- a/erts/doc/src/erl_driver.xml
+++ b/erts/doc/src/erl_driver.xml
@@ -2304,8 +2304,13 @@ r = driver_async(myPort, &myKey, myData, myFunc);    ]]></code>
           buffer is too small, a value &gt; <c>0</c> is returned and
           <c>*value_size</c> has been set to the buffer size needed.</p>
         <warning>
-          <p>Do <em>not</em> use libc's <c>getenv</c> or similar C library
-            interfaces from a driver.</p>
+          <p>This function reads the emulated environment used by
+            <seealso marker="os:getenv/1"><c>os:getenv/1</c></seealso> and not
+            the environment used by libc's <c>getenv(3)</c> or similar. Drivers
+            that <em>require</em> that these are in sync will need to do so
+            themselves, but keep in mind that they are segregated for a reason;
+            <c>getenv(3)</c> and its friends are <em>not thread-safe</em> and
+            may cause unrelated code to misbehave or crash the emulator.</p>
         </warning>
         <p>This function is thread-safe.</p>
       </desc>
@@ -2650,8 +2655,13 @@ erl_drv_output_term(driver_mk_port(drvport), spec, sizeof(spec) / sizeof(spec[0]
             environment variable is removed.</p>
         </note>
         <warning>
-          <p>Do <em>not</em> use libc's <c>putenv</c> or similar C library
-            interfaces from a driver.</p>
+          <p>This function modifies the emulated environment used by
+            <seealso marker="os:putenv/2"><c>os:putenv/2</c></seealso> and not
+            the environment used by libc's <c>putenv(3)</c> or similar. Drivers
+            that <em>require</em> that these are in sync will need to do so
+            themselves, but keep in mind that they are segregated for a reason;
+            <c>putenv(3)</c> and its friends are <em>not thread-safe</em> and
+            may cause unrelated code to misbehave or crash the emulator.</p>
         </warning>
         <p>This function is thread-safe.</p>
       </desc>
diff --git a/erts/emulator/Makefile.in b/erts/emulator/Makefile.in
index 15b65f1c71..9c79bf3da0 100644
--- a/erts/emulator/Makefile.in
+++ b/erts/emulator/Makefile.in
@@ -903,6 +903,7 @@ else
 OS_OBJS = \
 	$(OBJDIR)/sys.o \
 	$(OBJDIR)/sys_drivers.o \
+	$(OBJDIR)/sys_env.o \
 	$(OBJDIR)/sys_uds.o \
 	$(OBJDIR)/driver_tab.o \
 	$(OBJDIR)/elib_memmove.o \
@@ -944,7 +945,8 @@ endif
 OS_OBJS +=	$(OBJDIR)/erl_poll.o \
 		$(OBJDIR)/erl_check_io.o \
 		$(OBJDIR)/erl_mseg.o \
-		$(OBJDIR)/erl_mmap.o \
+		$(OBJDIR)/erl_mmap.o  \
+		$(OBJDIR)/erl_osenv.o \
 		$(OBJDIR)/erl_$(ERLANG_OSTYPE)_sys_ddll.o \
 		$(OBJDIR)/erl_mtrace_sys_wrap.o \
 		$(OBJDIR)/erl_sys_common_misc.o \
diff --git a/erts/emulator/beam/bif.tab b/erts/emulator/beam/bif.tab
index 33f6eef652..c0d5e8ce74 100644
--- a/erts/emulator/beam/bif.tab
+++ b/erts/emulator/beam/bif.tab
@@ -376,9 +376,10 @@ bif ets:match_spec_run_r/3
 # Bifs in os module.
 #
 
-bif os:putenv/2
-bif os:getenv/0
-bif os:getenv/1
+bif os:get_env_var/1
+bif os:set_env_var/2
+bif os:unset_env_var/1
+bif os:list_env_vars/0
 bif os:getpid/0
 bif os:timestamp/0
 bif os:system_time/0
@@ -619,7 +620,6 @@ bif erlang:float_to_binary/2
 bif erlang:binary_to_float/1
 
 bif io:printable_range/0
-bif os:unsetenv/1
 
 #
 # New in 17.0
diff --git a/erts/emulator/beam/break.c b/erts/emulator/beam/break.c
index 2cff05c7f3..e7acea0c5f 100644
--- a/erts/emulator/beam/break.c
+++ b/erts/emulator/beam/break.c
@@ -775,16 +775,16 @@ erl_crash_dump_v(char *file, int line, char* fmt, va_list args)
      * - write dump until alarm or file is written completely
      */
 	
-    if (erts_sys_getenv__("ERL_CRASH_DUMP_SECONDS", env, &envsz) != 0) {
-	env_erl_crash_dump_seconds_set = 0;
-	secs = -1;
+    if (erts_sys_explicit_8bit_getenv("ERL_CRASH_DUMP_SECONDS", env, &envsz) == 1) {
+        env_erl_crash_dump_seconds_set = 1;
+        secs = atoi(env);
     } else {
-	env_erl_crash_dump_seconds_set = 1;
-	secs = atoi(env);
+        env_erl_crash_dump_seconds_set = 0;
+        secs = -1;
     }
 
     if (secs == 0) {
-	return;
+        return;
     }
 
     /* erts_sys_prepare_crash_dump returns 1 if heart port is found, otherwise 0
@@ -800,7 +800,7 @@ erl_crash_dump_v(char *file, int line, char* fmt, va_list args)
 
     crash_dump_limit = ERTS_SINT64_MAX;
     envsz = sizeof(env);
-    if (erts_sys_getenv__("ERL_CRASH_DUMP_BYTES", env, &envsz) == 0) {
+    if (erts_sys_explicit_8bit_getenv("ERL_CRASH_DUMP_BYTES", env, &envsz) == 1) {
         Sint64 limit;
         char* endptr;
         errno = 0;
@@ -813,7 +813,7 @@ erl_crash_dump_v(char *file, int line, char* fmt, va_list args)
         }
     }
 
-    if (erts_sys_getenv__("ERL_CRASH_DUMP",&dumpnamebuf[0],&dumpnamebufsize) != 0)
+    if (erts_sys_explicit_8bit_getenv("ERL_CRASH_DUMP",&dumpnamebuf[0],&dumpnamebufsize) != 1)
 	dumpname = "erl_crash.dump";
     else
 	dumpname = &dumpnamebuf[0];
diff --git a/erts/emulator/beam/dist.c b/erts/emulator/beam/dist.c
index 7ff7462bf6..30390cdb5e 100644
--- a/erts/emulator/beam/dist.c
+++ b/erts/emulator/beam/dist.c
@@ -1212,7 +1212,7 @@ erts_dsig_send_group_leader(ErtsDSigData *dsdp, Eterm leader, Eterm remote)
 #  define PURIFY_MSG(msg)                                                    \
     do {								     \
 	char buf__[1]; size_t bufsz__ = sizeof(buf__);			     \
-	if (erts_sys_getenv_raw("VALGRIND_LOG_XML", buf__, &bufsz__) >= 0) { \
+	if (erts_sys_explicit_8bit_getenv("VALGRIND_LOG_XML", buf__, &bufsz__) >= 0) { \
 	    VALGRIND_PRINTF_XML("<erlang_error_log>"			     \
 			    "%s, line %d: %s</erlang_error_log>\n",	     \
 			    __FILE__, __LINE__, msg);			     \
diff --git a/erts/emulator/beam/erl_alloc.types b/erts/emulator/beam/erl_alloc.types
index c6cc5c78b3..8107f133aa 100644
--- a/erts/emulator/beam/erl_alloc.types
+++ b/erts/emulator/beam/erl_alloc.types
@@ -283,6 +283,8 @@ type	THR_PRGR_DATA	LONG_LIVED	SYSTEM		thr_prgr_data
 type	T_THR_PRGR_DATA	SHORT_LIVED	SYSTEM		temp_thr_prgr_data
 type	RELEASE_LAREA	SHORT_LIVED	SYSTEM		release_literal_area
 
+type	ENVIRONMENT	SYSTEM		SYSTEM		environment
+
 #
 # Types used for special emulators
 #
@@ -370,8 +372,6 @@ type	SYS_READ_BUF	TEMPORARY	SYSTEM		sys_read_buf
 type	FD_TAB		LONG_LIVED	SYSTEM		fd_tab
 type	FD_ENTRY_BUF	STANDARD	SYSTEM		fd_entry_buf
 type	CS_PROG_PATH	LONG_LIVED	SYSTEM		cs_prog_path
-type	ENVIRONMENT	TEMPORARY	SYSTEM		environment
-type	PUTENV_STR	SYSTEM		SYSTEM		putenv_string
 type	PRT_REP_EXIT	STANDARD	SYSTEM		port_report_exit
 type	SYS_BLOCKING	STANDARD	SYSTEM		sys_blocking
 
@@ -383,9 +383,7 @@ type	SYS_WRITE_BUF	TEMPORARY	SYSTEM		sys_write_buf
 
 type	DRV_DATA_BUF	SYSTEM		SYSTEM		drv_data_buf
 type	PRELOADED	LONG_LIVED	SYSTEM		preloaded
-type	PUTENV_STR	SYSTEM		SYSTEM		putenv_string
 type	WAITER_OBJ	LONG_LIVED	SYSTEM		waiter_object
-type	ENVIRONMENT	SYSTEM		SYSTEM		environment
 type	CON_VPRINTF_BUF	TEMPORARY	SYSTEM		con_vprintf_buf
 
 +endif
diff --git a/erts/emulator/beam/erl_bif_info.c b/erts/emulator/beam/erl_bif_info.c
index 2f6f2c6e0a..52056023fd 100644
--- a/erts/emulator/beam/erl_bif_info.c
+++ b/erts/emulator/beam/erl_bif_info.c
@@ -1754,7 +1754,7 @@ static int check_if_xml(void)
 {
     char buf[1];
     size_t bufsz = sizeof(buf);
-    return erts_sys_getenv_raw("VALGRIND_LOG_XML", buf, &bufsz) >= 0;
+    return erts_sys_explicit_8bit_getenv("VALGRIND_LOG_XML", buf, &bufsz) >= 0;
 }
 #else
 #define check_if_xml() 0
diff --git a/erts/emulator/beam/erl_bif_os.c b/erts/emulator/beam/erl_bif_os.c
index 910325a2f4..ce2b27409b 100644
--- a/erts/emulator/beam/erl_bif_os.c
+++ b/erts/emulator/beam/erl_bif_os.c
@@ -36,8 +36,7 @@
 #include "big.h"
 #include "dist.h"
 #include "erl_version.h"
-
-static int check_env_name(char *name);
+#include "erl_osenv.h"
 
 /*
  * Return the pid for the Erlang process in the host OS.
@@ -67,148 +66,78 @@ BIF_RETTYPE os_getpid_0(BIF_ALIST_0)
      BIF_RET(buf_to_intlist(&hp, pid_string, n, NIL));
 }
 
-BIF_RETTYPE os_getenv_0(BIF_ALIST_0)
+static void os_getenv_foreach(Process *process, Eterm *result, Eterm key, Eterm value)
 {
-    GETENV_STATE state;
-    char *cp;
-    Eterm* hp;
-    Eterm ret;
-    Eterm str;
+    Eterm kvp_term, *hp;
 
-    init_getenv_state(&state);
+    hp = HAlloc(process, 5);
+    kvp_term = TUPLE2(hp, key, value);
+    hp += 3;
 
-    ret = NIL;
-    while ((cp = getenv_string(&state)) != NULL) {
-	str = erts_convert_native_to_filename(BIF_P,(byte *)cp);
-	hp = HAlloc(BIF_P, 2);
-	ret = CONS(hp, str, ret);
-    }
+    (*result) = CONS(hp, kvp_term, (*result));
+}
 
-    fini_getenv_state(&state);
+BIF_RETTYPE os_list_env_vars_0(BIF_ALIST_0)
+{
+    const erts_osenv_t *global_env;
+    Eterm result = NIL;
+
+    global_env = erts_sys_rlock_global_osenv();
+    erts_osenv_foreach_term(global_env, BIF_P, &result, (void*)&os_getenv_foreach);
+    erts_sys_runlock_global_osenv();
 
-    return ret;
+    return result;
 }
 
-#define STATIC_BUF_SIZE 1024
-BIF_RETTYPE os_getenv_1(BIF_ALIST_1)
+BIF_RETTYPE os_get_env_var_1(BIF_ALIST_1)
 {
-    Process* p = BIF_P;
-    Eterm str;
-    Sint len;
-    int res;
-    char *key_str, *val;
-    char buf[STATIC_BUF_SIZE];
-    size_t val_size = sizeof(buf);
-
-    key_str = erts_convert_filename_to_native(BIF_ARG_1,buf,STATIC_BUF_SIZE,
-					      ERTS_ALC_T_TMP,1,0,&len);
-
-    if (!check_env_name(key_str)) {
-        if (key_str && key_str != &buf[0])
-            erts_free(ERTS_ALC_T_TMP, key_str);
-        BIF_ERROR(p, BADARG);
-    }
+    const erts_osenv_t *global_env;
+    Eterm out_term;
+    int error;
 
-    if (key_str != &buf[0])
-	val = &buf[0];
-    else {
-	/* len includes zero byte */
-	val_size -= len;
-	val = &buf[len];
-    }
-    res = erts_sys_getenv(key_str, val, &val_size);
-
-    if (res < 0) {
-    no_var:
-	str = am_false;
-    } else {
-	if (res > 0) {
-	    val = erts_alloc(ERTS_ALC_T_TMP, val_size);
-	    while (1) {
-		res = erts_sys_getenv(key_str, val, &val_size);
-		if (res == 0)
-		    break;
-		else if (res < 0)
-		    goto no_var;
-		else
-		    val = erts_realloc(ERTS_ALC_T_TMP, val, val_size);
-	    }
-	}
-	str = erts_convert_native_to_filename(p,(byte *)val);
-    }
-    if (key_str != &buf[0])
-	erts_free(ERTS_ALC_T_TMP, key_str);
-    if (val < &buf[0] || &buf[sizeof(buf)-1] < val)
-	erts_free(ERTS_ALC_T_TMP, val);
-    BIF_RET(str);
+    global_env = erts_sys_rlock_global_osenv();
+    error = erts_osenv_get_term(global_env, BIF_P, BIF_ARG_1, &out_term);
+    erts_sys_runlock_global_osenv();
+
+    if (error == 0) {
+        return am_false;
+    } else if (error < 0) {
+        BIF_ERROR(BIF_P, BADARG);
+    } 
+
+    return out_term;
 }
 
-BIF_RETTYPE os_putenv_2(BIF_ALIST_2)
+BIF_RETTYPE os_set_env_var_2(BIF_ALIST_2)
 {
-    char def_buf_key[STATIC_BUF_SIZE];
-    char def_buf_value[STATIC_BUF_SIZE];
-    char *key_buf = NULL, *value_buf = NULL;
-
-    key_buf = erts_convert_filename_to_native(BIF_ARG_1,def_buf_key,
-					      STATIC_BUF_SIZE,
-					      ERTS_ALC_T_TMP,0,0,NULL);
-    if (!check_env_name(key_buf))
-        goto badarg;
-
-    value_buf = erts_convert_filename_to_native(BIF_ARG_2,def_buf_value,
-						STATIC_BUF_SIZE,
-						ERTS_ALC_T_TMP,1,0,
-						NULL);
-    if (!value_buf)
-        goto badarg;
-
-    if (erts_sys_putenv(key_buf, value_buf)) {
-	if (key_buf != def_buf_key) {
-	    erts_free(ERTS_ALC_T_TMP, key_buf);
-	}
-	if (value_buf != def_buf_value) {
-	    erts_free(ERTS_ALC_T_TMP, value_buf);
-	}
-	BIF_ERROR(BIF_P, BADARG);
-    }
-    if (key_buf != def_buf_key) {
-	erts_free(ERTS_ALC_T_TMP, key_buf);
-    }
-    if (value_buf != def_buf_value) {
-	erts_free(ERTS_ALC_T_TMP, value_buf);
+    erts_osenv_t *global_env;
+    int error;
+
+    global_env = erts_sys_rwlock_global_osenv();
+    error = erts_osenv_put_term(global_env, BIF_ARG_1, BIF_ARG_2);
+    erts_sys_rwunlock_global_osenv();
+
+    if (error < 0) {
+        BIF_ERROR(BIF_P, BADARG);
     }
-    BIF_RET(am_true);
 
-badarg:
-    if (key_buf && key_buf != def_buf_key)
-	erts_free(ERTS_ALC_T_TMP, key_buf);
-    if (value_buf && value_buf != def_buf_value)
-	erts_free(ERTS_ALC_T_TMP, value_buf);
-    BIF_ERROR(BIF_P, BADARG);
+    BIF_RET(am_true);
 }
 
-BIF_RETTYPE os_unsetenv_1(BIF_ALIST_1)
+BIF_RETTYPE os_unset_env_var_1(BIF_ALIST_1)
 {
-    char *key_buf;
-    char buf[STATIC_BUF_SIZE];
+    erts_osenv_t *global_env;
+    int error;
 
-    key_buf = erts_convert_filename_to_native(BIF_ARG_1,buf,STATIC_BUF_SIZE,
-					      ERTS_ALC_T_TMP,0,0,NULL);
-    if (!check_env_name(key_buf))
-        goto badarg;
+    global_env = erts_sys_rwlock_global_osenv();
+    error = erts_osenv_unset_term(global_env, BIF_ARG_1);
+    erts_sys_rwunlock_global_osenv();
 
-    if (erts_sys_unsetenv(key_buf))
-        goto badarg;
-
-    if (key_buf != buf) {
-	erts_free(ERTS_ALC_T_TMP, key_buf);
+    if (error < 0) {
+        BIF_ERROR(BIF_P, BADARG);
     }
-    BIF_RET(am_true);
 
-badarg:
-    if (key_buf && key_buf != buf)
-        erts_free(ERTS_ALC_T_TMP, key_buf);
-    BIF_ERROR(BIF_P, BADARG);    
+    BIF_RET(am_true);
 }
 
 BIF_RETTYPE os_set_signal_2(BIF_ALIST_2) {
@@ -224,27 +153,3 @@ BIF_RETTYPE os_set_signal_2(BIF_ALIST_2) {
 error:
     BIF_ERROR(BIF_P, BADARG);
 }
-
-static int
-check_env_name(char *raw_name)
-{
-    byte *c = (byte *) raw_name;
-    int encoding;
-
-    if (!c)
-        return 0;
-    
-    encoding = erts_get_native_filename_encoding();
-
-    if (erts_raw_env_char_is_7bit_ascii_char('\0', c, encoding))
-        return 0; /* Do not allow empty name... */
-
-    /* Verify no '=' characters in variable name... */
-    do {
-        if (erts_raw_env_char_is_7bit_ascii_char('=', c, encoding))
-            return 0;
-        c = erts_raw_env_next_char(c, encoding);
-    } while (!erts_raw_env_char_is_7bit_ascii_char('\0', c, encoding));
-
-    return 1; /* Seems ok... */
-}
diff --git a/erts/emulator/beam/erl_bif_port.c b/erts/emulator/beam/erl_bif_port.c
index c4a4dd5863..9f0c90ff7b 100644
--- a/erts/emulator/beam/erl_bif_port.c
+++ b/erts/emulator/beam/erl_bif_port.c
@@ -45,7 +45,7 @@
 #include "dtrace-wrapper.h"
 
 static Port *open_port(Process* p, Eterm name, Eterm settings, int *err_typep, int *err_nump);
-static char* convert_environment(Eterm env);
+static int merge_global_environment(erts_osenv_t *env, Eterm key_value_pairs);
 static char **convert_args(Eterm);
 static void free_args(char **);
 
@@ -651,6 +651,7 @@ BIF_RETTYPE port_get_data_1(BIF_ALIST_1)
 static Port *
 open_port(Process* p, Eterm name, Eterm settings, int *err_typep, int *err_nump)
 {
+    int merged_environment = 0;
     Sint i;
     Eterm option;
     Uint arity;
@@ -672,12 +673,13 @@ open_port(Process* p, Eterm name, Eterm settings, int *err_typep, int *err_nump)
     opts.read_write = 0;
     opts.hide_window = 0;
     opts.wd = NULL;
-    opts.envir = NULL;
     opts.exit_status = 0;
     opts.overlapped_io = 0; 
     opts.spawn_type = ERTS_SPAWN_ANY; 
     opts.argv = NULL;
     opts.parallelism = erts_port_parallelism;
+    erts_osenv_init(&opts.envir);
+
     linebuf = 0;
 
     *err_nump = 0;
@@ -718,11 +720,16 @@ open_port(Process* p, Eterm name, Eterm settings, int *err_typep, int *err_nump)
 			goto badarg;
 		    }
 		} else if (option == am_env) {
-                    if (opts.envir) /* ignore previous env option... */
-                        erts_free(ERTS_ALC_T_OPEN_PORT_ENV, opts.envir);
-                    opts.envir = convert_environment(*tp);
-                    if (!opts.envir)
-			goto badarg;
+		    if (merged_environment) {
+		        /* Ignore previous env option */
+		        erts_osenv_clear(&opts.envir);
+		    }
+
+		    merged_environment = 1;
+
+		    if (merge_global_environment(&opts.envir, *tp)) {
+		        goto badarg;
+		    }
 		} else if (option == am_args) {
 		    char **av;
 		    char **oav = opts.argv;
@@ -807,6 +814,12 @@ open_port(Process* p, Eterm name, Eterm settings, int *err_typep, int *err_nump)
     if((linebuf && opts.packet_bytes) || 
        (opts.redir_stderr && !opts.use_stdio)) {
 	goto badarg;
+}
+
+    /* If we lacked an env option, fill in the global environment without
+     * changes. */
+    if (!merged_environment) {
+        merge_global_environment(&opts.envir, NIL);
     }
 
     /*
@@ -956,8 +969,7 @@ open_port(Process* p, Eterm name, Eterm settings, int *err_typep, int *err_nump)
 	erts_atomic32_read_bor_relb(&port->state, sflgs);
  
  do_return:
-    if (opts.envir)
-        erts_free(ERTS_ALC_T_OPEN_PORT_ENV, opts.envir);
+    erts_osenv_clear(&opts.envir);
     if (name_buf)
 	erts_free(ERTS_ALC_T_TMP, (void *) name_buf);
     if (opts.argv) {
@@ -977,6 +989,45 @@ open_port(Process* p, Eterm name, Eterm settings, int *err_typep, int *err_nump)
     goto do_return;
 }
 
+/* Merges the the global environment and the given {Key, Value} list into env,
+ * unsetting all keys whose value is either 'false' or NIL. The behavior on
+ * NIL is undocumented and perhaps surprising, but the previous implementation
+ * worked in this manner. */
+static int merge_global_environment(erts_osenv_t *env, Eterm key_value_pairs) {
+    const erts_osenv_t *global_env = erts_sys_rlock_global_osenv();
+    erts_osenv_merge(env, global_env, 0);
+    erts_sys_runlock_global_osenv();
+
+    while (is_list(key_value_pairs)) {
+        Eterm *cell, *tuple;
+
+        cell = list_val(key_value_pairs);
+
+        if(!is_tuple_arity(CAR(cell), 2)) {
+            return -1;
+        }
+
+        tuple = tuple_val(CAR(cell));
+        key_value_pairs = CDR(cell);
+
+        if(is_nil(tuple[2]) || tuple[2] == am_false) {
+            if(erts_osenv_unset_term(env, tuple[1]) < 0) {
+                return -1;
+            }
+        } else {
+            if(erts_osenv_put_term(env, tuple[1], tuple[2]) < 0) {
+                return -1;
+            }
+        }
+    }
+
+    if(!is_nil(key_value_pairs)) {
+        return -1;
+    }
+
+    return 0;
+}
+
 /* Arguments can be given i unicode and as raw binaries, convert filename is used to convert */
 static char **convert_args(Eterm l)
 {
@@ -1024,130 +1075,6 @@ static void free_args(char **av)
     erts_free(ERTS_ALC_T_TMP, av);
 }
 
-#ifdef DEBUG
-#define ERTS_CONV_ENV_BUF_EXTRA 2
-#else
-#define ERTS_CONV_ENV_BUF_EXTRA 1024
-#endif
-
-static char* convert_environment(Eterm env)
-{
-    /*
-     * Returns environment buffer in memory allocated
-     * as ERTS_ALC_T_OPEN_PORT_ENV. Caller *needs*
-     * to deallocate...
-     */
-
-    Sint size, alloc_size;
-    byte* bytes;
-    int encoding = erts_get_native_filename_encoding();
-
-    alloc_size = ERTS_CONV_ENV_BUF_EXTRA;
-    bytes = erts_alloc(ERTS_ALC_T_OPEN_PORT_ENV,
-                       alloc_size);
-    size = 0;
-
-    /* ERTS_CONV_ENV_BUF_EXTRA >= for end delimiter... */
-    ERTS_CT_ASSERT(ERTS_CONV_ENV_BUF_EXTRA >= 2);
-
-    while (is_list(env)) {
-        Sint var_sz, val_sz, need;
-        byte *str, *limit;
-	Eterm tmp, *tp, *consp;
-
-        consp = list_val(env);
-	tmp = CAR(consp);
-	if (is_not_tuple_arity(tmp, 2))
-	    goto error;
-
-	tp = tuple_val(tmp);
-
-        /* Check encoding of env variable... */
-        if (is_not_list(tp[1]))
-            goto error;
-        var_sz = erts_native_filename_need(tp[1], encoding);
-        if (var_sz <= 0)
-            goto error;
-        /* Check encoding of value... */
-        if (tp[2] == am_false || is_nil(tp[2]))
-            val_sz = 0;
-        else if (is_not_list(tp[2]))
-            goto error;
-        else {
-            val_sz = erts_native_filename_need(tp[2], encoding);
-            if (val_sz < 0)
-                goto error;
-        }
-
-        /* Ensure enough memory... */
-        need = size;
-        need += var_sz + val_sz;
-        /* '=' and '\0' */
-        need += 2 * erts_raw_env_7bit_ascii_char_need(encoding);
-        if (need > alloc_size) {
-            alloc_size = (need - alloc_size) + alloc_size;
-            alloc_size += ERTS_CONV_ENV_BUF_EXTRA;
-            bytes = erts_realloc(ERTS_ALC_T_OPEN_PORT_ENV,
-                                 bytes, alloc_size);
-        }
-
-        /* Write environment variable name... */
-        str = bytes + size;
-        erts_native_filename_put(tp[1], encoding, str);
-        /* empty variable name is not allowed... */
-        if (erts_raw_env_char_is_7bit_ascii_char('\0', str, encoding))
-            goto error;
-
-        /*
-         * Drop null characters at the end and verify that we do
-         * not have any '=' characters in the name...
-         */
-        limit = str + var_sz;
-        while (str < limit) {
-            if (erts_raw_env_char_is_7bit_ascii_char('\0', str, encoding))
-                break;
-            if (erts_raw_env_char_is_7bit_ascii_char('=', str, encoding))
-                goto error;
-            str = erts_raw_env_next_char(str, encoding);
-        }
-
-        /* Write the equals sign... */
-        str = erts_raw_env_7bit_ascii_char_put('=', str, encoding);
-
-        /* Write the value... */
-        if (val_sz > 0) {
-            limit = str + val_sz;
-            erts_native_filename_put(tp[2], encoding, str);
-            while (str < limit) {
-                if (erts_raw_env_char_is_7bit_ascii_char('\0', str, encoding))
-                    break;
-                str = erts_raw_env_next_char(str, encoding);
-            }
-        }
-
-        /* Delimit... */
-        str = erts_raw_env_7bit_ascii_char_put('\0', str, encoding);
-
-        size = str - bytes;
-        ASSERT(size <= alloc_size);
-
-        env = CDR(consp);
-    }
-
-    /* End delimit... */
-    (void) erts_raw_env_7bit_ascii_char_put('\0', &bytes[size], encoding);
-
-    if (is_nil(env))
-        return (char *) bytes;
-
-error:
-
-    if (bytes)
-        erts_free(ERTS_ALC_T_OPEN_PORT_ENV, bytes);
-
-    return (char *) NULL; /* error... */
-}
-
 /* ------------ decode_packet() and friends: */
 
 struct packet_callback_args
diff --git a/erts/emulator/beam/erl_init.c b/erts/emulator/beam/erl_init.c
index 6cef9bd0e3..f52eed41d5 100644
--- a/erts/emulator/beam/erl_init.c
+++ b/erts/emulator/beam/erl_init.c
@@ -50,7 +50,7 @@
 #define ERTS_WANT_TIMER_WHEEL_API
 #include "erl_time.h"
 #include "erl_check_io.h"
-
+#include "erl_osenv.h"
 #ifdef HIPE
 #include "hipe_mode_switch.h"	/* for hipe_mode_switch_init() */
 #include "hipe_signal.h"	/* for hipe_signal_init() */
@@ -803,8 +803,9 @@ early_init(int *argc, char **argv) /*
 
     envbufsz = sizeof(envbuf);
 
-    /* erts_sys_getenv(_raw)() not initialized yet; need erts_sys_getenv__() */
-    if (erts_sys_getenv__("ERL_THREAD_POOL_SIZE", envbuf, &envbufsz) == 0)
+    /* erts_osenv hasn't been initialized yet, so we need to fall back to
+     * erts_sys_explicit_host_getenv() */
+    if (erts_sys_explicit_host_getenv("ERL_THREAD_POOL_SIZE", envbuf, &envbufsz) == 1)
 	erts_async_max_threads = atoi(envbuf);
     else
 	erts_async_max_threads = ERTS_DEFAULT_NO_ASYNC_THREADS;
@@ -1210,20 +1211,20 @@ erl_start(int argc, char **argv)
 			 &time_warp_mode);
 
     envbufsz = sizeof(envbuf);
-    if (erts_sys_getenv_raw(ERL_MAX_ETS_TABLES_ENV, envbuf, &envbufsz) == 0)
+    if (erts_sys_explicit_8bit_getenv(ERL_MAX_ETS_TABLES_ENV, envbuf, &envbufsz) == 1)
 	user_requested_db_max_tabs = atoi(envbuf);
     else
 	user_requested_db_max_tabs = 0;
 
     envbufsz = sizeof(envbuf);
-    if (erts_sys_getenv_raw("ERL_FULLSWEEP_AFTER", envbuf, &envbufsz) == 0) {
+    if (erts_sys_explicit_8bit_getenv("ERL_FULLSWEEP_AFTER", envbuf, &envbufsz) == 1) {
 	Uint16 max_gen_gcs = atoi(envbuf);
 	erts_atomic32_set_nob(&erts_max_gen_gcs,
 				  (erts_aint32_t) max_gen_gcs);
     }
 
     envbufsz = sizeof(envbuf);
-    if (erts_sys_getenv_raw("ERL_MAX_PORTS", envbuf, &envbufsz) == 0) {
+    if (erts_sys_explicit_8bit_getenv("ERL_MAX_PORTS", envbuf, &envbufsz) == 1) {
 	port_tab_sz = atoi(envbuf);
 	port_tab_sz_ignore_files = 1;
     }
diff --git a/erts/emulator/beam/erl_unicode.c b/erts/emulator/beam/erl_unicode.c
index b7a5c45fea..e5c7a9502b 100644
--- a/erts/emulator/beam/erl_unicode.c
+++ b/erts/emulator/beam/erl_unicode.c
@@ -2083,18 +2083,9 @@ char* erts_convert_filename_to_wchar(byte* bytes, Uint size,
     return name_buf;
 }
 
-
-static int filename_len_16bit(byte *str) 
-{
-    byte *p = str;
-    while(*p != '\0' || p[1] != '\0') {
-	p += 2;
-    }
-    return (p - str);
-}
-Eterm erts_convert_native_to_filename(Process *p, byte *bytes)
+Eterm erts_convert_native_to_filename(Process *p, size_t size, byte *bytes)
 {
-    Uint size,num_chars;
+    Uint num_chars;
     Eterm *hp;
     byte *err_pos;
     Uint num_built; /* characters */
@@ -2108,7 +2099,6 @@ Eterm erts_convert_native_to_filename(Process *p, byte *bytes)
     case ERL_FILENAME_UTF8_MAC:
 	mac = 1;
     case ERL_FILENAME_UTF8:
-	size = strlen((char *) bytes);
 	if (size == 0)
 	    return NIL;
 	if (erts_analyze_utf8(bytes,size,&err_pos,&num_chars,NULL) != ERTS_UTF8_OK) {
@@ -2123,7 +2113,6 @@ Eterm erts_convert_native_to_filename(Process *p, byte *bytes)
 	} 
 	return ret;
     case ERL_FILENAME_WIN_WCHAR:
-	size=filename_len_16bit(bytes);
 	if ((size % 2) != 0) { /* Panic fixup to avoid crashing the emulator */
 	    size--;
 	    hp = HAlloc(p, size+2);
@@ -2146,7 +2135,6 @@ Eterm erts_convert_native_to_filename(Process *p, byte *bytes)
 	goto noconvert;
     }
  noconvert:
-    size = strlen((char *) bytes);
     hp = HAlloc(p, 2 * size);
     return erts_bin_bytes_to_list(NIL, hp, bytes, size, 0);
 }
@@ -2158,7 +2146,6 @@ Sint erts_native_filename_need(Eterm ioterm, int encoding)
     Eterm obj;
     DECLARE_ESTACK(stack);
     Sint need = 0;
-    int seen_null = 0;
 
     if (is_atom(ioterm)) {
 	Atom* ap;
@@ -2203,9 +2190,7 @@ Sint erts_native_filename_need(Eterm ioterm, int encoding)
             byte *name = ap->name;
             int len = ap->len;
             for (i = 0; i < len; i++) {
-                if (name[i] == 0)
-                    seen_null = 1;
-                else if (seen_null) {
+                if (name[i] == 0) {
                     need = -1;
                     break;
                 }
@@ -2245,9 +2230,7 @@ L_Again:   /* Restart with sublist, old listend was pushed on stack */
                          * Do not allow null in
                          * the middle of filenames
                          */
-                        if (x == 0)
-                            seen_null = 1;
-                        else if (seen_null) {
+                        if (x == 0) {
                             DESTROY_ESTACK(stack);
                             return ((Sint) -1);
                         }
@@ -2580,7 +2563,6 @@ BIF_RETTYPE prim_file_internal_name2native_1(BIF_ALIST_1)
 	BIF_ERROR(BIF_P,BADARG);
     }
     if (is_binary(BIF_ARG_1)) {
-        int seen_null = 0;
 	byte *temp_alloc = NULL;
 	byte *bytes;
 	byte *err_pos;
@@ -2597,8 +2579,6 @@ BIF_RETTYPE prim_file_internal_name2native_1(BIF_ALIST_1)
             for (i = 0; i < size; i++) {
                 /* Don't allow null in the middle of filenames... */
                 if (bytes[i] == 0)
-                    seen_null = 1;
-                else if (seen_null)
                     goto bin_name_error;
                 bin_p[i] = bytes[i];
             }
@@ -2617,8 +2597,6 @@ BIF_RETTYPE prim_file_internal_name2native_1(BIF_ALIST_1)
 	    while (size--) {
                 /* Don't allow null in the middle of filenames... */
                 if (*bytes == 0)
-                    seen_null = 1;
-                else if (seen_null)
                     goto bin_name_error;
 		*bin_p++ = *bytes++;
 		*bin_p++ = 0;
diff --git a/erts/emulator/beam/global.h b/erts/emulator/beam/global.h
index 09207364eb..09500c5bc0 100644
--- a/erts/emulator/beam/global.h
+++ b/erts/emulator/beam/global.h
@@ -1264,7 +1264,7 @@ char* erts_convert_filename_to_wchar(byte* bytes, Uint size,
                                      char *statbuf, size_t statbuf_size,
                                      ErtsAlcType_t alloc_type, Sint* used,
                                      Uint extra_wchars);
-Eterm erts_convert_native_to_filename(Process *p, byte *bytes);
+Eterm erts_convert_native_to_filename(Process *p, size_t size, byte *bytes);
 Eterm erts_utf8_to_list(Process *p, Uint num, byte *bytes, Uint sz, Uint left,
 			Uint *num_built, Uint *num_eaten, Eterm tail);
 int erts_utf8_to_latin1(byte* dest, const byte* source, int slen);
diff --git a/erts/emulator/beam/io.c b/erts/emulator/beam/io.c
index 9933c8dda4..6158e9613a 100644
--- a/erts/emulator/beam/io.c
+++ b/erts/emulator/beam/io.c
@@ -7715,13 +7715,27 @@ int null_func(void)
 int
 erl_drv_putenv(const char *key, char *value)
 {
-    return erts_sys_putenv_raw((char*)key, value);
+    switch (erts_sys_explicit_8bit_putenv((char*)key, value)) {
+    case -1: /* Insufficient buffer space */
+        return 1;
+    case 1: /* Success */
+        return 0;
+    default: /* Not found */
+        return -1;
+    }
 }
 
 int
 erl_drv_getenv(const char *key, char *value, size_t *value_size)
 {
-    return erts_sys_getenv_raw((char*)key, value, value_size);
+    switch (erts_sys_explicit_8bit_getenv((char*)key, value, value_size)) {
+    case -1: /* Insufficient buffer space */
+        return 1;
+    case 1: /* Success */
+        return 0;
+    default: /* Not found */
+        return -1;
+    }
 }
 
 /* get heart_port
diff --git a/erts/emulator/beam/sys.h b/erts/emulator/beam/sys.h
index bf7d310568..290e0b209a 100644
--- a/erts/emulator/beam/sys.h
+++ b/erts/emulator/beam/sys.h
@@ -636,6 +636,8 @@ typedef struct preload {
  */
 typedef Eterm ErtsTracer;
 
+#include "erl_osenv.h"
+
 /*
  * This structure contains options to all built in drivers.
  * None of the drivers use all of the fields.
@@ -651,8 +653,7 @@ typedef struct _SysDriverOpts {
     int hide_window;		/* Hide this windows (Windows). */
     int exit_status;		/* Report exit status of subprocess. */
     int overlapped_io;          /* Only has effect on windows NT et al */
-    char *envir;		/* Environment of the port process, */
-				/* in Windows format. */
+    erts_osenv_t envir;		/* Environment of the port process */
     char **argv;                /* Argument vector in Unix'ish format. */
     char *wd;			/* Working directory. */
     unsigned spawn_type;        /* Bitfield of ERTS_SPAWN_DRIVER | 
@@ -782,9 +783,6 @@ void set_break_quit(void (*)(void), void (*)(void));
 
 void os_flavor(char*, unsigned);
 void os_version(int*, int*, int*);
-void init_getenv_state(GETENV_STATE *);
-char * getenv_string(GETENV_STATE *);
-void fini_getenv_state(GETENV_STATE *);
 
 #define HAVE_ERTS_CHECK_IO_DEBUG
 typedef struct {
@@ -805,20 +803,21 @@ int sys_double_to_chars_ext(double, char*, size_t, size_t);
 int sys_double_to_chars_fast(double, char*, int, int, int);
 void sys_get_pid(char *, size_t);
 
-/* erts_sys_putenv() returns, 0 on success and a value != 0 on failure. */
-int erts_sys_putenv(char *key, char *value);
-/* Simple variant used from drivers, raw eightbit interface */
-int erts_sys_putenv_raw(char *key, char *value);
-/* erts_sys_getenv() returns 0 on success (length of value string in
-   *size), a value > 0 if value buffer is too small (*size is set to needed
-   size), and a value < 0 on failure. */
-int erts_sys_getenv(char *key, char *value, size_t *size);
-/* Simple variant used from drivers, raw eightbit interface */
-int erts_sys_getenv_raw(char *key, char *value, size_t *size);
-/* erts_sys_getenv__() is only allowed to be used in early init phase */
-int erts_sys_getenv__(char *key, char *value, size_t *size);
-/* erst_sys_unsetenv() returns 0 on success and a value != 0 on failure. */
-int erts_sys_unsetenv(char *key);
+/* erl_drv_get/putenv have been implicitly 8-bit for so long that we can't
+ * change them without breaking things on Windows. Their return values are
+ * identical to erts_osenv_get/putenv */
+int erts_sys_explicit_8bit_getenv(char *key, char *value, size_t *size);
+int erts_sys_explicit_8bit_putenv(char *key, char *value);
+
+/* This is identical to erts_sys_explicit_8bit_getenv but falls down to the
+ * host OS implementation instead of erts_osenv. */
+int erts_sys_explicit_host_getenv(char *key, char *value, size_t *size);
+
+const erts_osenv_t *erts_sys_rlock_global_osenv(void);
+void erts_sys_runlock_global_osenv(void);
+
+erts_osenv_t *erts_sys_rwlock_global_osenv(void);
+void erts_sys_rwunlock_global_osenv(void);
 
 /* Easier to use, but not as efficient, environment functions */
 char *erts_read_env(char *key);
diff --git a/erts/emulator/beam/utils.c b/erts/emulator/beam/utils.c
index 993585be10..fe9f1c7606 100644
--- a/erts/emulator/beam/utils.c
+++ b/erts/emulator/beam/utils.c
@@ -4360,15 +4360,20 @@ erts_read_env(char *key)
     char *value = erts_alloc(ERTS_ALC_T_TMP, value_len);
     int res;
     while (1) {
-	res = erts_sys_getenv_raw(key, value, &value_len);
-	if (res <= 0)
-	    break;
-	value = erts_realloc(ERTS_ALC_T_TMP, value, value_len);
+        res = erts_sys_explicit_8bit_getenv(key, value, &value_len);
+
+        if (res >= 0) {
+            break;
+        }
+
+        value = erts_realloc(ERTS_ALC_T_TMP, value, value_len);
     }
-    if (res != 0) {
-	erts_free(ERTS_ALC_T_TMP, value);
-	return NULL;
+
+    if (res != 1) {
+        erts_free(ERTS_ALC_T_TMP, value);
+        return NULL;
     }
+
     return value;
 }
 
diff --git a/erts/emulator/sys/common/erl_osenv.c b/erts/emulator/sys/common/erl_osenv.c
new file mode 100644
index 0000000000..9f54d1dff0
--- /dev/null
+++ b/erts/emulator/sys/common/erl_osenv.c
@@ -0,0 +1,396 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson AB 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_osenv.h"
+
+#include "global.h"
+#include "erl_alloc.h"
+#include "erl_process.h"
+
+#define STACKBUF_SIZE (512)
+
+typedef struct __env_rbtnode_t {
+    struct __env_rbtnode_t *parent;
+    struct __env_rbtnode_t *left;
+    struct __env_rbtnode_t *right;
+
+    int is_red;
+
+    erts_osenv_data_t key;
+    erts_osenv_data_t value;
+} env_rbtnode_t;
+
+#define ERTS_RBT_PREFIX env
+#define ERTS_RBT_T env_rbtnode_t
+#define ERTS_RBT_KEY_T erts_osenv_data_t
+#define ERTS_RBT_FLAGS_T int
+#define ERTS_RBT_INIT_EMPTY_TNODE(T) \
+    do { \
+        (T)->parent = NULL; \
+        (T)->left = NULL; \
+        (T)->right = NULL; \
+        (T)->is_red = 0; \
+    } while(0)
+#define ERTS_RBT_IS_RED(T) ((T)->is_red)
+#define ERTS_RBT_SET_RED(T) ((T)->is_red = 1)
+#define ERTS_RBT_IS_BLACK(T) (!ERTS_RBT_IS_RED(T))
+#define ERTS_RBT_SET_BLACK(T) ((T)->is_red = 0)
+#define ERTS_RBT_GET_FLAGS(T) ((T)->is_red)
+#define ERTS_RBT_SET_FLAGS(T, F) ((T)->is_red = F)
+#define ERTS_RBT_GET_PARENT(T) ((T)->parent)
+#define ERTS_RBT_SET_PARENT(T, P) ((T)->parent = P)
+#define ERTS_RBT_GET_RIGHT(T) ((T)->right)
+#define ERTS_RBT_SET_RIGHT(T, R) ((T)->right = (R))
+#define ERTS_RBT_GET_LEFT(T) ((T)->left)
+#define ERTS_RBT_SET_LEFT(T, L) ((T)->left = (L))
+#define ERTS_RBT_GET_KEY(T) ((T)->key)
+#define ERTS_RBT_IS_LT(KX, KY) (compare_env_keys(KX, KY) < 0)
+#define ERTS_RBT_IS_EQ(KX, KY) (compare_env_keys(KX, KY) == 0)
+#define ERTS_RBT_WANT_FOREACH_DESTROY
+#define ERTS_RBT_WANT_FOREACH
+#define ERTS_RBT_WANT_REPLACE
+#define ERTS_RBT_WANT_DELETE
+#define ERTS_RBT_WANT_INSERT
+#define ERTS_RBT_WANT_LOOKUP
+
+static int compare_env_keys(const erts_osenv_data_t a, const erts_osenv_data_t b);
+
+#include "erl_rbtree.h"
+
+static int compare_env_keys(const erts_osenv_data_t a, const erts_osenv_data_t b) {
+    int relation = sys_memcmp(a.data, b.data, MIN(a.length, b.length));
+
+    if(relation != 0) {
+        return relation;
+    }
+
+    if(a.length < b.length) {
+        return -1;
+    } else if(a.length == b.length) {
+        return 0;
+    } else {
+        return 1;
+    }
+}
+
+static void *convert_value_to_native(Eterm term, char *stackbuf,
+        int stackbuf_size, Sint *length) {
+    int encoding;
+    void *result;
+
+    if(is_atom(term)) {
+        return NULL;
+    }
+
+    encoding = erts_get_native_filename_encoding();
+    *length = erts_native_filename_need(term, encoding);
+
+    if(*length < 0) {
+        return NULL;
+    } else if(*length >= stackbuf_size) {
+        result = erts_alloc(ERTS_ALC_T_TMP, *length);
+    } else {
+        result = stackbuf;
+    }
+
+    erts_native_filename_put(term, encoding, (byte*)result);
+
+    return result;
+}
+
+static void *convert_key_to_native(Eterm term, char *stackbuf,
+        int stackbuf_size, Sint *length) {
+    byte *name_iterator, *name_end;
+    void *result;
+    int encoding;
+
+    result = convert_value_to_native(term, stackbuf, stackbuf_size, length);
+
+    if(result == NULL || length == 0) {
+        return NULL;
+    }
+
+    encoding = erts_get_native_filename_encoding();
+
+    name_iterator = (byte*)result;
+    name_end = &name_iterator[*length];
+
+#ifdef __WIN32__
+    /* Windows stores per-drive working directories as variables starting with
+     * '=', so we skip the first character to tolerate that. */
+    name_iterator = erts_raw_env_next_char(name_iterator, encoding);
+#endif
+
+    while(name_iterator < name_end) {
+        if(erts_raw_env_char_is_7bit_ascii_char('=', name_iterator, encoding)) {
+            if(result != stackbuf) {
+                erts_free(ERTS_ALC_T_TMP, result);
+            }
+
+            return NULL;
+        }
+
+        name_iterator = erts_raw_env_next_char(name_iterator, encoding);
+    }
+
+    return result;
+}
+
+void erts_osenv_init(erts_osenv_t *env) {
+    env->variable_count = 0;
+    env->content_size = 0;
+    env->tree = NULL;
+}
+
+static void destroy_foreach(env_rbtnode_t *node, void *_state) {
+    erts_free(ERTS_ALC_T_ENVIRONMENT, node);
+    (void)_state;
+}
+
+void erts_osenv_clear(erts_osenv_t *env) {
+    env_rbt_foreach_destroy(&env->tree, &destroy_foreach, NULL);
+    erts_osenv_init(env);
+}
+
+struct __env_merge {
+    int overwrite_existing;
+    erts_osenv_t *env;
+};
+
+static void merge_foreach(env_rbtnode_t *node, void *_state) {
+    struct __env_merge *state = (struct __env_merge*)(_state);
+    env_rbtnode_t *existing_node;
+
+    existing_node = env_rbt_lookup(state->env->tree, node->key);
+
+    if(existing_node == NULL || state->overwrite_existing) {
+        erts_osenv_put_native(state->env, &node->key, &node->value);
+    }
+}
+
+void erts_osenv_merge(erts_osenv_t *env, const erts_osenv_t *with, int overwrite) {
+    struct __env_merge merge_state;
+
+    merge_state.overwrite_existing = overwrite;
+    merge_state.env = env;
+
+    env_rbt_foreach(with->tree, merge_foreach, &merge_state);
+}
+
+struct __env_foreach_term {
+    erts_osenv_foreach_term_cb_t user_callback;
+    struct process *process;
+    void *user_state;
+};
+
+static void foreach_term_wrapper(env_rbtnode_t *node, void *_state) {
+    struct __env_foreach_term *state = (struct __env_foreach_term*)_state;
+    Eterm key, value;
+
+    key = erts_convert_native_to_filename(state->process,
+        node->key.length, (byte*)node->key.data);
+    value = erts_convert_native_to_filename(state->process,
+        node->value.length, (byte*)node->value.data);
+
+    state->user_callback(state->process, state->user_state, key, value);
+}
+
+void erts_osenv_foreach_term(const erts_osenv_t *env, struct process *process,
+        void *state, erts_osenv_foreach_term_cb_t callback) {
+    struct __env_foreach_term wrapper_state;
+
+    wrapper_state.user_callback = callback;
+    wrapper_state.user_state = state;
+    wrapper_state.process = process;
+
+    env_rbt_foreach(env->tree, foreach_term_wrapper, &wrapper_state);
+}
+
+int erts_osenv_get_term(const erts_osenv_t *env, Process *process,
+        Eterm key_term, Eterm *out_term) {
+    char key_stackbuf[STACKBUF_SIZE];
+    erts_osenv_data_t key;
+    int result;
+
+    key.data = convert_key_to_native(key_term, key_stackbuf,
+        STACKBUF_SIZE, &key.length);
+    result = -1;
+
+    if(key.data != NULL) {
+        env_rbtnode_t *node;
+
+        node = env_rbt_lookup(env->tree, key);
+        result = 0;
+
+        if(node != NULL) {
+            (*out_term) = erts_convert_native_to_filename(process,
+                node->value.length, (byte*)node->value.data);
+            result = 1;
+        }
+
+        if(key.data != key_stackbuf) {
+            erts_free(ERTS_ALC_T_TMP, key.data);
+        }
+    }
+
+    return result;
+}
+
+int erts_osenv_put_term(erts_osenv_t *env, Eterm key_term, Eterm value_term) {
+    char key_stackbuf[STACKBUF_SIZE], value_stackbuf[STACKBUF_SIZE];
+    erts_osenv_data_t key, value;
+    int result;
+
+    key.data = convert_key_to_native(key_term, key_stackbuf,
+        STACKBUF_SIZE, &key.length);
+    value.data = convert_value_to_native(value_term, value_stackbuf,
+        STACKBUF_SIZE, &value.length);
+    result = -1;
+
+    if(value.data != NULL && key.data != NULL) {
+        result = erts_osenv_put_native(env, &key, &value);
+    }
+
+    if(value.data != NULL && value.data != value_stackbuf) {
+        erts_free(ERTS_ALC_T_TMP, value.data);
+    }
+
+    if(key.data != NULL && key.data != key_stackbuf) {
+        erts_free(ERTS_ALC_T_TMP, key.data);
+    }
+
+    return result;
+}
+
+int erts_osenv_unset_term(erts_osenv_t *env, Eterm key_term) {
+    char key_stackbuf[STACKBUF_SIZE];
+    erts_osenv_data_t key;
+    int result;
+
+    key.data = convert_key_to_native(key_term, key_stackbuf,
+        STACKBUF_SIZE, &key.length);
+    result = -1;
+
+    if(key.data != NULL) {
+        result = erts_osenv_unset_native(env, &key);
+
+        if(key.data != key_stackbuf) {
+            erts_free(ERTS_ALC_T_TMP, key.data);
+        }
+    }
+
+    return result;
+}
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+struct __env_foreach_native {
+    erts_osenv_foreach_native_cb_t user_callback;
+    void *user_state;
+};
+
+static void foreach_native_wrapper(env_rbtnode_t *node, void *_state) {
+    struct __env_foreach_native *state = (struct __env_foreach_native*)_state;
+
+    state->user_callback(state->user_state, &node->key, &node->value);
+}
+
+void erts_osenv_foreach_native(const erts_osenv_t *env, void *state,
+        erts_osenv_foreach_native_cb_t callback) {
+    struct __env_foreach_native wrapper_state;
+
+    wrapper_state.user_callback = callback;
+    wrapper_state.user_state = state;
+
+    env_rbt_foreach(env->tree, foreach_native_wrapper, &wrapper_state);
+}
+
+int erts_osenv_get_native(const erts_osenv_t *env,
+        const erts_osenv_data_t *key,
+        erts_osenv_data_t *value) {
+    env_rbtnode_t *node = env_rbt_lookup(env->tree, *key);
+
+    if(node != NULL) {
+        if(value != NULL) {
+            if(node->value.length > value->length) {
+                return -1;
+            }
+
+            sys_memcpy(value->data, node->value.data, node->value.length);
+            value->length = node->value.length;
+        }
+
+        return 1;
+    }
+
+    return 0;
+}
+
+int erts_osenv_put_native(erts_osenv_t *env, const erts_osenv_data_t *key,
+        const erts_osenv_data_t *value) {
+    env_rbtnode_t *old_node, *new_node;
+
+    new_node = erts_alloc(ERTS_ALC_T_ENVIRONMENT, sizeof(env_rbtnode_t) +
+        key->length + value->length);
+
+    new_node->key.data = (char*)(&new_node[1]);
+    new_node->key.length = key->length;
+    new_node->value.data = &((char*)new_node->key.data)[key->length];
+    new_node->value.length = value->length;
+
+    sys_memcpy(new_node->key.data, key->data, key->length);
+    sys_memcpy(new_node->value.data, value->data, value->length);
+
+    old_node = env_rbt_lookup(env->tree, *key);
+
+    if(old_node != NULL) {
+        env->content_size -= old_node->value.length;
+        env->content_size -= old_node->key.length;
+        env_rbt_replace(&env->tree, old_node, new_node);
+    } else {
+        env_rbt_insert(&env->tree, new_node);
+        env->variable_count++;
+    }
+
+    env->content_size += new_node->value.length;
+    env->content_size += new_node->key.length;
+
+    if(old_node != NULL) {
+        erts_free(ERTS_ALC_T_ENVIRONMENT, old_node);
+    }
+
+    return 1;
+}
+
+int erts_osenv_unset_native(erts_osenv_t *env, const erts_osenv_data_t *key) {
+    env_rbtnode_t *old_node = env_rbt_lookup(env->tree, *key);
+
+    if(old_node != NULL) {
+        env->content_size -= old_node->value.length;
+        env->content_size -= old_node->key.length;
+        env->variable_count -= 1;
+
+        env_rbt_delete(&env->tree, old_node);
+        erts_free(ERTS_ALC_T_ENVIRONMENT, old_node);
+        return 1;
+    }
+
+    return 0;
+}
diff --git a/erts/emulator/sys/common/erl_osenv.h b/erts/emulator/sys/common/erl_osenv.h
new file mode 100644
index 0000000000..4777f2148a
--- /dev/null
+++ b/erts/emulator/sys/common/erl_osenv.h
@@ -0,0 +1,121 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson AB 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%
+ */
+
+/* This is a replacement for getenv(3) and friends, operating on instances so
+ * we can keep a common implementation for both the global and local (per-port)
+ * environments.
+ *
+ * The instances are not thread-safe on their own but unlike getenv(3) we're
+ * guaranteed to be the only user, so placing locks around all our accesses
+ * will suffice.
+ *
+ * Use erts_sys_rwlock_global_osenv to access the global environment. */
+
+#ifndef __ERL_OSENV_H__
+#define __ERL_OSENV_H__
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+typedef struct __erts_osenv_data_t erts_osenv_data_t;
+
+typedef struct __erts_osenv_t {
+    struct __env_rbtnode_t *tree;
+    int variable_count;
+    int content_size;
+} erts_osenv_t;
+
+#include "sys.h"
+
+struct __erts_osenv_data_t {
+    Sint length;
+    void *data;
+};
+
+void erts_osenv_init(erts_osenv_t *env);
+void erts_osenv_clear(erts_osenv_t *env);
+
+/* @brief Merges \c with into \c env
+ *
+ * @param overwrite Whether to overwrite existing entries or keep them as they
+ * are. */
+void erts_osenv_merge(erts_osenv_t *env, const erts_osenv_t *with, int overwrite);
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/* @brief Copies env[key] into \c value
+ *
+ * @return 1 on success, 0 if the key couldn't be found, and -1 if the input
+ * was invalid. */
+int erts_osenv_get_term(const erts_osenv_t *env, struct process *process,
+    Eterm key, Eterm *value);
+
+/* @brief Copies \c value into \c env[key]
+ *
+ * @return 1 on success, -1 if the input was invalid. */
+int erts_osenv_put_term(erts_osenv_t *env, Eterm key, Eterm value);
+
+/* @brief Removes \c env[key]
+ *
+ * @return 1 on success, 0 if the key couldn't be found, and -1 if the input
+ * was invalid. */
+int erts_osenv_unset_term(erts_osenv_t *env, Eterm key);
+
+/* @brief Copies env[key] into \c value
+ *
+ * @param value [in,out] The buffer to copy the value into, may be NULL if you
+ * only wish to query presence.
+ *
+ * @return 1 on success, 0 if the key couldn't be found, and -1 if if the value
+ * didn't fit into the buffer. */
+int erts_osenv_get_native(const erts_osenv_t *env, const erts_osenv_data_t *key,
+    erts_osenv_data_t *value);
+
+/* @brief Copies \c value into \c env[key]
+ *
+ * @return 1 on success, -1 on failure. */
+int erts_osenv_put_native(erts_osenv_t *env, const erts_osenv_data_t *key,
+    const erts_osenv_data_t *value);
+
+/* @brief Removes \c key from the env.
+ *
+ * @return 1 on success, 0 if the key couldn't be found. */
+int erts_osenv_unset_native(erts_osenv_t *env, const erts_osenv_data_t *key);
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+typedef void (*erts_osenv_foreach_term_cb_t)(struct process *process,
+    void *state, Eterm key, Eterm value);
+
+typedef void (*erts_osenv_foreach_native_cb_t)(void *state,
+    const erts_osenv_data_t *key,
+    const erts_osenv_data_t *value);
+
+/* @brief Walks through all environment variables, calling \c callback for each
+ * one. It's unsafe to modify \c env within the callback. */
+void erts_osenv_foreach_term(const erts_osenv_t *env, struct process *process,
+    void *state, erts_osenv_foreach_term_cb_t callback);
+
+/* @copydoc erts_osenv_foreach_term */
+void erts_osenv_foreach_native(const erts_osenv_t *env, void *state,
+    erts_osenv_foreach_native_cb_t callback);
+
+#endif
diff --git a/erts/emulator/sys/unix/erl_unix_sys.h b/erts/emulator/sys/unix/erl_unix_sys.h
index b6f5b319ee..e367d565a7 100644
--- a/erts/emulator/sys/unix/erl_unix_sys.h
+++ b/erts/emulator/sys/unix/erl_unix_sys.h
@@ -133,7 +133,7 @@
 #define  ERTS_SYS_CONTINOUS_FD_NUMBERS
 
 
-typedef void *GETENV_STATE;
+void erts_sys_env_init(void);
 
 /*
 ** For the erl_timer_sup module.
diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index 6315135151..189ca083d7 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -62,9 +62,6 @@
 
 #include "erl_mseg.h"
 
-extern char **environ;
-erts_rwmtx_t environ_rwmtx;
-
 #define MAX_VSIZE 16		/* Max number of entries allowed in an I/O
 				 * vector sock_sendv().
 				 */
@@ -77,7 +74,7 @@ erts_rwmtx_t environ_rwmtx;
 
 #include "erl_check_io.h"
 #include "erl_cpu_topology.h"
-
+#include "erl_osenv.h"
 extern int  driver_interrupt(int, int);
 extern void do_break(void);
 
@@ -454,10 +451,10 @@ prepare_crash_dump(int secs)
     close(crashdump_companion_cube_fd);
 
     envsz = sizeof(env);
-    i = erts_sys_getenv__("ERL_CRASH_DUMP_NICE", env, &envsz);
+    i = erts_sys_explicit_8bit_getenv("ERL_CRASH_DUMP_NICE", env, &envsz);
     if (i >= 0) {
 	int nice_val;
-	nice_val = i != 0 ? 0 : atoi(env);
+	nice_val = i != 1 ? 0 : atoi(env);
 	if (nice_val > 39) {
 	    nice_val = 39;
 	}
@@ -749,34 +746,6 @@ void os_version(int *pMajor, int *pMinor, int *pBuild) {
     *pBuild = get_number(&release); /* Pointer to build number. */
 }
 
-void init_getenv_state(GETENV_STATE *state)
-{
-   erts_rwmtx_rlock(&environ_rwmtx);
-   *state = NULL;
-}
-
-char *getenv_string(GETENV_STATE *state0)
-{
-   char **state = (char **) *state0;
-   char *cp;
-
-   ERTS_LC_ASSERT(erts_lc_rwmtx_is_rlocked(&environ_rwmtx));
-
-   if (state == NULL)
-      state = environ;
-
-   cp = *state++;
-   *state0 = (GETENV_STATE) state;
-
-   return cp;
-}
-
-void fini_getenv_state(GETENV_STATE *state)
-{
-   *state = NULL;
-   erts_rwmtx_runlock(&environ_rwmtx);
-}
-
 void erts_do_break_handling(void)
 {
     struct termios temp_mode;
@@ -830,90 +799,6 @@ void sys_get_pid(char *buffer, size_t buffer_size){
     erts_snprintf(buffer, buffer_size, "%lu",(unsigned long) p);
 }
 
-int
-erts_sys_putenv_raw(char *key, char *value) {
-    return erts_sys_putenv(key, value);
-}
-int
-erts_sys_putenv(char *key, char *value)
-{
-    int res;
-    char *env;
-    Uint need = strlen(key) + strlen(value) + 2;
-
-#ifdef HAVE_COPYING_PUTENV
-    env = erts_alloc(ERTS_ALC_T_TMP, need);
-#else
-    env = erts_alloc(ERTS_ALC_T_PUTENV_STR, need);
-    erts_atomic_add_nob(&sys_misc_mem_sz, need);
-#endif
-    strcpy(env,key);
-    strcat(env,"=");
-    strcat(env,value);
-    erts_rwmtx_rwlock(&environ_rwmtx);
-    res = putenv(env);
-    erts_rwmtx_rwunlock(&environ_rwmtx);
-#ifdef HAVE_COPYING_PUTENV
-    erts_free(ERTS_ALC_T_TMP, env);
-#endif
-    return res;
-}
-
-int
-erts_sys_getenv__(char *key, char *value, size_t *size)
-{
-    int res;
-    char *orig_value = getenv(key);
-    if (!orig_value)
-	res = -1;
-    else {
-	size_t len = sys_strlen(orig_value);
-	if (len >= *size) {
-	    *size = len + 1;
-	    res = 1;
-	}
-	else {
-	    *size = len;
-	    sys_memcpy((void *) value, (void *) orig_value, len+1);
-	    res = 0;
-	}
-    }
-    return res;
-}
-
-int
-erts_sys_getenv_raw(char *key, char *value, size_t *size) {
-    return erts_sys_getenv(key, value, size);
-}
-
-/*
- * erts_sys_getenv
- * returns:
- *  -1, if environment key is not set with a value
- *   0, if environment key is set and value fits into buffer size
- *   1, if environment key is set but does not fit into buffer size
- *      size is set with the needed buffer size value
- */
-
-int
-erts_sys_getenv(char *key, char *value, size_t *size)
-{
-    int res;
-    erts_rwmtx_rlock(&environ_rwmtx);
-    res = erts_sys_getenv__(key, value, size);
-    erts_rwmtx_runlock(&environ_rwmtx);
-    return res;
-}
-
-int
-erts_sys_unsetenv(char *key)
-{
-    int res;
-    erts_rwmtx_rwlock(&environ_rwmtx);
-    res = unsetenv(key);
-    erts_rwmtx_rwunlock(&environ_rwmtx);
-    return res;
-}
 
 void sys_init_io(void) { }
 void erts_sys_alloc_init(void) { }
@@ -1260,14 +1145,9 @@ erts_sys_main_thread(void)
     }
 }
 
-
 void
 erl_sys_args(int* argc, char** argv)
 {
-
-    erts_rwmtx_init(&environ_rwmtx, "environ", NIL,
-        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
-
     ASSERT(argc && argv);
 
     max_files = erts_check_io_max_files();
@@ -1275,4 +1155,5 @@ erl_sys_args(int* argc, char** argv)
     init_smp_sig_notify();
     init_smp_sig_suspend();
 
+    erts_sys_env_init();
 }
diff --git a/erts/emulator/sys/unix/sys_drivers.c b/erts/emulator/sys/unix/sys_drivers.c
index 0228e1af54..b7ac89d89a 100644
--- a/erts/emulator/sys/unix/sys_drivers.c
+++ b/erts/emulator/sys/unix/sys_drivers.c
@@ -55,9 +55,6 @@
 
 #include "erl_threads.h"
 
-extern char **environ;
-extern erts_rwmtx_t environ_rwmtx;
-
 extern erts_atomic_t sys_misc_mem_sz;
 
 static Eterm forker_port;
@@ -180,7 +177,7 @@ erl_sys_late_init(void)
     opts.read_write = 0;
     opts.hide_window = 0;
     opts.wd = NULL;
-    opts.envir = NULL;
+    erts_osenv_init(&opts.envir);
     opts.exit_status = 0;
     opts.overlapped_io = 0;
     opts.spawn_type = ERTS_SPAWN_ANY;
@@ -443,85 +440,55 @@ static void close_pipes(int ifd[2], int ofd[2])
     close(ofd[1]);
 }
 
-static char **build_unix_environment(char *block)
+struct __add_spawn_env_state {
+    struct iovec *iov;
+    int *iov_index;
+
+    Sint32 *payload_size;
+    char *env_block;
+};
+
+static void add_spawn_env_block_foreach(void *_state,
+                                        const erts_osenv_data_t *key,
+                                        const erts_osenv_data_t *value)
 {
-    int i;
-    int j;
-    int len;
-    char *cp;
-    char **cpp;
-    char** old_env;
-    
-    ERTS_LC_ASSERT(erts_lc_rwmtx_is_rlocked(&environ_rwmtx));
-
-    cp = block;
-    len = 0;
-    while (*cp != '\0') {
-	cp += strlen(cp) + 1;
-	len++;
-    }
-    old_env = environ;
-    while (*old_env++ != NULL) {
-	len++;
-    }
-    
-    cpp = (char **) erts_alloc_fnf(ERTS_ALC_T_ENVIRONMENT,
-				   sizeof(char *) * (len+1));
-    if (cpp == NULL) {
-	return NULL;
-    }
+    struct __add_spawn_env_state *state;
+    struct iovec *iov;
 
-    cp = block;
-    len = 0;
-    while (*cp != '\0') {
-	cpp[len] = cp;
-	cp += strlen(cp) + 1;
-	len++;
-    }
-    
-    i = len;
-    for (old_env = environ; *old_env; old_env++) {
-	char* old = *old_env;
-
-	for (j = 0; j < len; j++) {
-	    char *s, *t;
-
-	    /* check if cpp[j] equals old
-	       before the = sign,
-	       i.e.
-	       "TMPDIR=/tmp/" */
-	    s = cpp[j];
-	    t = old;
-	    while (*s == *t && *s != '=') {
-		s++, t++;
-	    }
-	    if (*s == '=' && *t == '=') {
-		break;
-	    }
-	}
+    state = (struct __add_spawn_env_state*)(_state);
+    iov = &state->iov[*state->iov_index];
 
-	if (j == len) {		/* New version not found */
-	    cpp[len++] = old;
-	}
-    }
+    iov->iov_base = state->env_block;
 
-    for (j = 0; j < i; ) {
-        size_t last = strlen(cpp[j])-1;
-	if (cpp[j][last] == '=' && strchr(cpp[j], '=') == cpp[j]+last) {
-	    cpp[j] = cpp[--len];
-	    if (len < i) {
-		i--;
-	    } else {
-		j++;
-	    }
-	}
-	else {
-	    j++;
-	}
-    }
+    sys_memcpy(state->env_block, key->data, key->length);
+    state->env_block += key->length;
+    *state->env_block++ = '=';
+    sys_memcpy(state->env_block, value->data, value->length);
+    state->env_block += value->length;
+    *state->env_block++ = '\0';
 
-    cpp[len] = NULL;
-    return cpp;
+    iov->iov_len = state->env_block - (char*)iov->iov_base;
+
+    (*state->payload_size) += iov->iov_len;
+    (*state->iov_index)++;
+}
+
+static void *add_spawn_env_block(const erts_osenv_t *env, struct iovec *iov,
+                                  int *iov_index, Sint32 *payload_size) {
+    struct __add_spawn_env_state add_state;
+    char *env_block;
+
+    env_block = erts_alloc(ERTS_ALC_T_TMP, env->content_size +
+        env->variable_count * sizeof("=\0"));
+
+    add_state.iov = iov;
+    add_state.iov_index = iov_index;
+    add_state.env_block = env_block;
+    add_state.payload_size = payload_size;
+
+    erts_osenv_foreach_native(env, &add_state, add_spawn_env_block_foreach);
+
+    return env_block;
 }
 
 static ErlDrvData spawn_start(ErlDrvPort port_num, char* name,
@@ -531,7 +498,6 @@ static ErlDrvData spawn_start(ErlDrvPort port_num, char* name,
 #define CMD_LINE_PREFIX_STR_SZ (sizeof(CMD_LINE_PREFIX_STR) - 1)
 
     int len;
-    char **new_environ;
     ErtsSysDriverData *dd;
     char *cmd_line;
     char wd_buff[MAXPATHLEN+1];
@@ -598,19 +564,7 @@ static ErlDrvData spawn_start(ErlDrvPort port_num, char* name,
 	memcpy((void *) (cmd_line + CMD_LINE_PREFIX_STR_SZ), (void *) name, len);
 	cmd_line[CMD_LINE_PREFIX_STR_SZ + len] = '\0';
 	len = CMD_LINE_PREFIX_STR_SZ + len + 1;
-    }
-
-    erts_rwmtx_rlock(&environ_rwmtx);
-
-    if (opts->envir == NULL) {
-	new_environ = environ;
-    } else if ((new_environ = build_unix_environment(opts->envir)) == NULL) {
-	erts_rwmtx_runlock(&environ_rwmtx);
-        close_pipes(ifd, ofd);
-	erts_free(ERTS_ALC_T_TMP, (void *) cmd_line);
-	errno = ENOMEM;
-	return ERL_DRV_ERROR_ERRNO;
-    }
+}
 
     if ((cwd = getcwd(wd_buff, MAXPATHLEN+1)) == NULL) {
         /* on some OSs this call opens a fd in the
@@ -619,9 +573,6 @@ static ErlDrvData spawn_start(ErlDrvPort port_num, char* name,
         int err = errno;
         close_pipes(ifd, ofd);
         erts_free(ERTS_ALC_T_TMP, (void *) cmd_line);
-        if (new_environ != environ)
-            erts_free(ERTS_ALC_T_ENVIRONMENT, (void *) new_environ);
-        erts_rwmtx_runlock(&environ_rwmtx);
         errno = err;
         return ERL_DRV_ERROR_ERRNO;
     }
@@ -629,6 +580,7 @@ static ErlDrvData spawn_start(ErlDrvPort port_num, char* name,
     wd = opts->wd;
 
     {
+        void *environment_block;
         struct iovec *io_vector;
         int iov_len = 5;
         char nullbuff[] = "\0";
@@ -641,10 +593,8 @@ static ErlDrvData spawn_start(ErlDrvPort port_num, char* name,
 
         if (wd) iov_len++;
 
-        /* count number of elements in environment */
-        while(new_environ[env_len] != NULL)
-            env_len++;
-        iov_len += 1 + env_len; /* num envs including size int */
+        /* num envs including size int */
+        iov_len += 1 + opts->envir.variable_count;
 
         /* count number of element in argument list */
         if (opts->spawn_type == ERTS_SPAWN_EXECUTABLE) {
@@ -661,10 +611,7 @@ static ErlDrvData spawn_start(ErlDrvPort port_num, char* name,
 
         if (!io_vector) {
             close_pipes(ifd, ofd);
-            erts_rwmtx_runlock(&environ_rwmtx);
             erts_free(ERTS_ALC_T_TMP, (void *) cmd_line);
-            if (new_environ != environ)
-                erts_free(ERTS_ALC_T_ENVIRONMENT, (void *) new_environ);
             errno = ENOMEM;
             return ERL_DRV_ERROR_ERRNO;
         }
@@ -699,16 +646,13 @@ static ErlDrvData spawn_start(ErlDrvPort port_num, char* name,
         io_vector[i++].iov_len = 1;
         buffsz += io_vector[i-1].iov_len;
 
+        env_len = htonl(opts->envir.variable_count);
         io_vector[i].iov_base = (void*)&env_len;
-        env_len = htonl(env_len);
         io_vector[i++].iov_len = sizeof(env_len);
         buffsz += io_vector[i-1].iov_len;
 
-        for (j = 0; new_environ[j] != NULL; j++) {
-            io_vector[i].iov_base = new_environ[j];
-            io_vector[i++].iov_len = strlen(new_environ[j]) + 1;
-            buffsz += io_vector[i-1].iov_len;
-        }
+        environment_block = add_spawn_env_block(&opts->envir, io_vector, &i,
+            &buffsz);
 
         /* only append arguments if this was a spawn_executable */
         if (opts->spawn_type == ERTS_SPAWN_EXECUTABLE) {
@@ -744,9 +688,6 @@ static ErlDrvData spawn_start(ErlDrvPort port_num, char* name,
                 int err = errno;
                 close_pipes(ifd, ofd);
                 erts_free(ERTS_ALC_T_TMP, io_vector);
-                if (new_environ != environ)
-                    erts_free(ERTS_ALC_T_ENVIRONMENT, (void *) new_environ);
-                erts_rwmtx_runlock(&environ_rwmtx);
                 erts_free(ERTS_ALC_T_TMP, (void *) cmd_line);
                 errno = err;
                 return ERL_DRV_ERROR_ERRNO;
@@ -767,16 +708,12 @@ static ErlDrvData spawn_start(ErlDrvPort port_num, char* name,
             driver_select(port_num, ofd[1], ERL_DRV_WRITE|ERL_DRV_USE, 1);
         }
 
+        erts_free(ERTS_ALC_T_TMP, environment_block);
         erts_free(ERTS_ALC_T_TMP, io_vector);
     }
 
     erts_free(ERTS_ALC_T_TMP, (void *) cmd_line);
 
-    if (new_environ != environ)
-	erts_free(ERTS_ALC_T_ENVIRONMENT, (void *) new_environ);
-
-    erts_rwmtx_runlock(&environ_rwmtx);
-
     dd = create_driver_data(port_num, ifd[0], ofd[1], opts->packet_bytes,
                              DO_WRITE | DO_READ, opts->exit_status,
                              0, 0);
@@ -1652,15 +1589,13 @@ static ErlDrvData forker_start(ErlDrvPort port_num, char* name,
 
     forker_port = erts_drvport2id(port_num);
 
-    res = erts_sys_getenv_raw("BINDIR", bindir, &bindirsz);
-    if (res != 0) {
-        if (res < 0)
-            erts_exit(1,
-                     "Environment variable BINDIR is not set\n");
-        if (res > 0)
-            erts_exit(1,
-                     "Value of environment variable BINDIR is too large\n");
+    res = erts_sys_explicit_8bit_getenv("BINDIR", bindir, &bindirsz);
+    if (res == 0) {
+        erts_exit(1, "Environment variable BINDIR is not set\n");
+    } else if(res < 0) {
+        erts_exit(1, "Value of environment variable BINDIR is too large\n");
     }
+
     if (bindir[0] != DIR_SEPARATOR_CHAR)
         erts_exit(1,
                  "Environment variable BINDIR does not contain an"
diff --git a/erts/emulator/sys/unix/sys_env.c b/erts/emulator/sys/unix/sys_env.c
new file mode 100644
index 0000000000..4d8301f985
--- /dev/null
+++ b/erts/emulator/sys/unix/sys_env.c
@@ -0,0 +1,133 @@
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#include "sys.h"
+#include "erl_osenv.h"
+#include "erl_alloc.h"
+
+#include "erl_thr_progress.h"
+
+static erts_osenv_t sysenv_global_env;
+static erts_rwmtx_t sysenv_rwmtx;
+
+extern char **environ;
+
+static void import_initial_env(void);
+
+void erts_sys_env_init() {
+    erts_rwmtx_init(&sysenv_rwmtx, "environ", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
+
+    erts_osenv_init(&sysenv_global_env);
+    import_initial_env();
+}
+
+const erts_osenv_t *erts_sys_rlock_global_osenv() {
+    erts_rwmtx_rlock(&sysenv_rwmtx);
+    return &sysenv_global_env;
+}
+
+erts_osenv_t *erts_sys_rwlock_global_osenv() {
+    erts_rwmtx_rwlock(&sysenv_rwmtx);
+    return &sysenv_global_env;
+}
+
+void erts_sys_rwunlock_global_osenv() {
+    erts_rwmtx_rwunlock(&sysenv_rwmtx);
+}
+
+void erts_sys_runlock_global_osenv() {
+    erts_rwmtx_runlock(&sysenv_rwmtx);
+}
+
+int erts_sys_explicit_8bit_putenv(char *key, char *value) {
+    erts_osenv_data_t env_key, env_value;
+    int result;
+
+    env_key.length = sys_strlen(key);
+    env_key.data = key;
+
+    env_value.length = sys_strlen(value);
+    env_value.data = value;
+
+    {
+        erts_osenv_t *env = erts_sys_rwlock_global_osenv();
+        result = erts_osenv_put_native(env, &env_key, &env_value);
+        erts_sys_rwunlock_global_osenv();
+    }
+
+    return result;
+}
+
+int erts_sys_explicit_8bit_getenv(char *key, char *value, size_t *size) {
+    erts_osenv_data_t env_key, env_value;
+    int result;
+
+    env_key.length = sys_strlen(key);
+    env_key.data = key;
+
+    /* Reserve space for NUL termination. */
+    env_value.length = *size - 1;
+    env_value.data = value;
+
+    {
+        const erts_osenv_t *env = erts_sys_rlock_global_osenv();
+        result = erts_osenv_get_native(env, &env_key, &env_value);
+        erts_sys_runlock_global_osenv();
+    }
+
+    if(result == 1) {
+        value[env_value.length] = '\0';
+    }
+
+    *size = env_value.length;
+
+    return result;
+}
+
+int erts_sys_explicit_host_getenv(char *key, char *value, size_t *size) {
+    char *orig_value;
+    size_t length;
+    
+    orig_value = getenv(key);
+
+    if(orig_value == NULL) {
+        return 0;
+    }
+
+    length = sys_strlen(orig_value);
+
+    if (length >= *size) {
+        *size = length + 1;
+        return -1;
+    }
+
+    sys_memcpy((void*)value, (void*)orig_value, length + 1);
+    *size = length;
+
+    return 1;
+}
+
+static void import_initial_env(void) {
+    char **environ_iterator, *environ_variable;
+
+    environ_iterator = environ;
+
+    while ((environ_variable = *(environ_iterator++)) != NULL) {
+        char *separator_index = strchr(environ_variable, '=');
+
+        if (separator_index != NULL) {
+            erts_osenv_data_t env_key, env_value;
+
+            env_key.length = separator_index - environ_variable;
+            env_key.data = environ_variable;
+    
+            env_value.length = sys_strlen(separator_index) - 1;
+            env_value.data = separator_index + 1;
+
+            erts_osenv_put_native(&sysenv_global_env, &env_key, &env_value);
+        }
+    }
+}
diff --git a/erts/emulator/sys/win32/erl_win32_sys_ddll.c b/erts/emulator/sys/win32/erl_win32_sys_ddll.c
index 274133a346..fc2179328f 100644
--- a/erts/emulator/sys/win32/erl_win32_sys_ddll.c
+++ b/erts/emulator/sys/win32/erl_win32_sys_ddll.c
@@ -46,9 +46,17 @@ static TWinDynDriverCallbacks wddc;
 static TWinDynNifCallbacks nif_callbacks;
 
 void erl_sys_ddll_init(void) {
+    WCHAR cwd_buffer[MAX_PATH];
+
     tls_index = TlsAlloc();
     ERL_INIT_CALLBACK_STRUCTURE(wddc);
 
+    /* LOAD_WITH_ALTERED_SEARCH_PATH removes the startup directory from the
+     * search path, so we add it separately to be backwards compatible. */
+    if (GetCurrentDirectoryW(sizeof(cwd_buffer), cwd_buffer)) {
+        SetDllDirectoryW(cwd_buffer);
+    }
+
 #define ERL_NIF_API_FUNC_DECL(RET,NAME,ARGS) nif_callbacks.NAME = NAME
 #include "erl_nif_api_funcs.h"
 #undef ERL_NIF_API_FUNC_DECL
@@ -81,7 +89,10 @@ int erts_sys_ddll_open(const char *full_name, void **handle, ErtsSysDdllError* e
 						   ERTS_ALC_T_TMP, &used, EXT_LEN);
     wcscpy(&wcp[used/2 - 1], FILE_EXT_WCHAR);
 
-    if ((hinstance = LoadLibraryW(wcp)) == NULL) {
+    /* LOAD_WITH_ALTERED_SEARCH_PATH adds the specified DLL's directory to the
+     * dependency search path. This also removes the directory we started in,
+     * but we've explicitly added that in in erl_sys_ddll_init. */
+    if ((hinstance = LoadLibraryExW(wcp, NULL, LOAD_WITH_ALTERED_SEARCH_PATH)) == NULL) {
 	code = ERL_DE_DYNAMIC_ERROR_OFFSET - GetLastError();
 	if (err != NULL) {
 	    err->str = erts_sys_ddll_error(code);
diff --git a/erts/emulator/sys/win32/sys.c b/erts/emulator/sys/win32/sys.c
index 0598a12351..a1c630d68a 100644
--- a/erts/emulator/sys/win32/sys.c
+++ b/erts/emulator/sys/win32/sys.c
@@ -77,6 +77,7 @@ static int create_pipe(LPHANDLE, LPHANDLE, BOOL, BOOL);
 static int application_type(const wchar_t* originalName, wchar_t fullPath[MAX_PATH],
 			   BOOL search_in_path, BOOL handle_quotes,
 			   int *error_return);
+static void *build_env_block(const erts_osenv_t *env);
 
 HANDLE erts_service_event;
 
@@ -1190,7 +1191,6 @@ spawn_start(ErlDrvPort port_num, char* utf8_name, SysDriverOpts* opts)
     int ok;
     int neededSelects = 0;
     SECURITY_ATTRIBUTES sa = {sizeof(SECURITY_ATTRIBUTES), NULL, TRUE};
-    char* envir = opts->envir;
     int errno_return = -1;
     wchar_t *name;
     int len;
@@ -1265,29 +1265,33 @@ spawn_start(ErlDrvPort port_num, char* utf8_name, SysDriverOpts* opts)
 	name[i] = L'\0';
     }
     DEBUGF(("Spawning \"%S\"\n", name));
-    envir = win_build_environment(envir); /* Always a unicode environment */ 
-    ok = create_child_process(name,
-			      hChildStdin,
-			      hChildStdout,
-			      hChildStderr,
-			      &dp->port_pid,
-			      &pid,
-			      opts->hide_window,
-			      (LPVOID) envir,
-			      (wchar_t *) opts->wd,
-			      opts->spawn_type,
-			      (wchar_t **) opts->argv,
-			      &errno_return);
-    CloseHandle(hChildStdin);
-    CloseHandle(hChildStdout);
-    if (close_child_stderr && hChildStderr != INVALID_HANDLE_VALUE &&
-	hChildStderr != 0) {
-	CloseHandle(hChildStderr);
-    }
-    erts_free(ERTS_ALC_T_TMP, name);
-
-    if (envir != NULL) {
-	erts_free(ERTS_ALC_T_ENVIRONMENT, envir);
+
+    {
+        void *environment_block = build_env_block(&opts->envir);
+
+        ok = create_child_process(name,
+                                  hChildStdin,
+                                  hChildStdout,
+                                  hChildStderr,
+                                  &dp->port_pid,
+                                  &pid,
+                                  opts->hide_window,
+                                  environment_block,
+                                  (wchar_t *) opts->wd,
+                                  opts->spawn_type,
+                                  (wchar_t **) opts->argv,
+                                  &errno_return);
+
+        CloseHandle(hChildStdin);
+        CloseHandle(hChildStdout);
+
+        if (close_child_stderr && hChildStderr != INVALID_HANDLE_VALUE &&
+            hChildStderr != 0) {
+            CloseHandle(hChildStderr);
+        }
+
+        erts_free(ERTS_ALC_T_TMP, environment_block);
+        erts_free(ERTS_ALC_T_TMP, name);
     }
 
     if (!ok) {
@@ -1338,6 +1342,41 @@ spawn_start(ErlDrvPort port_num, char* utf8_name, SysDriverOpts* opts)
     return retval;
 }
 
+struct __build_env_state {
+    WCHAR *next_variable;
+};
+
+static void build_env_foreach(void *_state, const erts_osenv_data_t *key,
+                              const erts_osenv_data_t *value)
+{
+    struct __build_env_state *state = (struct __build_env_state*)(_state);
+
+    sys_memcpy(state->next_variable, key->data, key->length);
+    state->next_variable += (int)key->length / sizeof(WCHAR);
+    *state->next_variable++ = L'=';
+
+    sys_memcpy(state->next_variable, value->data, value->length);
+    state->next_variable += (int)value->length / sizeof(WCHAR);
+    *state->next_variable++ = L'\0';
+}
+
+/* Builds an environment block suitable for CreateProcessW. */
+static void *build_env_block(const erts_osenv_t *env) {
+    struct __build_env_state build_state;
+    WCHAR *env_block;
+
+    env_block = erts_alloc(ERTS_ALC_T_TMP, env->content_size +
+        (env->variable_count * sizeof(L"=\0") + sizeof(L'\0')));
+
+    build_state.next_variable = env_block;
+
+    erts_osenv_foreach_native(env, &build_state, build_env_foreach);
+
+    (*build_state.next_variable) = L'\0';
+
+    return env_block;
+}
+
 static int
 create_file_thread(AsyncIo* aio, int mode)
 {
diff --git a/erts/emulator/sys/win32/sys_env.c b/erts/emulator/sys/win32/sys_env.c
index 5792816267..c78161b344 100644
--- a/erts/emulator/sys/win32/sys_env.c
+++ b/erts/emulator/sys/win32/sys_env.c
@@ -1,319 +1,212 @@
-/*

- * %CopyrightBegin%

- *

- * Copyright Ericsson AB 2002-2016. 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%

- */

-

-#ifdef HAVE_CONFIG_H

-#  include "config.h"

-#endif

-

-#include "sys.h"

-#include "erl_sys_driver.h"

-#include "erl_alloc.h"

-

-static WCHAR *merge_environment(WCHAR *current, WCHAR *add);

-static WCHAR *arg_to_env(WCHAR **arg);

-static WCHAR **env_to_arg(WCHAR *env);

-static WCHAR **find_arg(WCHAR **arg, WCHAR *str);

-static int compare(const void *a, const void *b);

-

-static erts_rwmtx_t environ_rwmtx;
-

-void

-erts_sys_env_init(void)

-{

-    erts_rwmtx_init(&environ_rwmtx, "environ", NIL,
-        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);

-}

-

-int

-erts_sys_putenv_raw(char *key, char *value)

-{

-    int res;

-    erts_rwmtx_rwlock(&environ_rwmtx);
-    res = (SetEnvironmentVariable((LPCTSTR) key,

-				  (LPCTSTR) value) ? 0 : 1);

-    erts_rwmtx_rwunlock(&environ_rwmtx);
-    return res;

-}

-

-int

-erts_sys_putenv(char *key, char *value)

-{

-    int res;

-    WCHAR *wkey = (WCHAR *) key;

-    WCHAR *wvalue = (WCHAR *) value;

-    erts_rwmtx_rwlock(&environ_rwmtx);
-    res = (SetEnvironmentVariableW(wkey,

-				   wvalue) ? 0 : 1);

-    erts_rwmtx_rwunlock(&environ_rwmtx);
-    return res;

-}

-

-int

-erts_sys_getenv(char *key, char *value, size_t *size)

-{

-    size_t req_size = 0;

-    int res = 0;

-    DWORD new_size;

-    WCHAR *wkey = (WCHAR *) key;

-    WCHAR *wvalue = (WCHAR *) value;

-    DWORD wsize = *size / (sizeof(WCHAR) / sizeof(char));

-

-    SetLastError(0);

-    erts_rwmtx_rlock(&environ_rwmtx);
-    new_size = GetEnvironmentVariableW(wkey,

-				       wvalue,

-				      (DWORD) wsize);

-    res = !new_size && GetLastError() == ERROR_ENVVAR_NOT_FOUND ? -1 : 0;

-    erts_rwmtx_runlock(&environ_rwmtx);
-    if (res < 0)

-	return res;

-    res = new_size > wsize ? 1 : 0;

-    *size = new_size * (sizeof(WCHAR) / sizeof(char));

-    return res;

-}

-int

-erts_sys_getenv__(char *key, char *value, size_t *size)

-{

-    size_t req_size = 0;

-    int res = 0;

-    DWORD new_size;

-

-    SetLastError(0);

-    new_size = GetEnvironmentVariable((LPCTSTR) key,

-				      (LPTSTR) value,

-				      (DWORD) *size);

-    res = !new_size && GetLastError() == ERROR_ENVVAR_NOT_FOUND ? -1 : 0;

-    if (res < 0)

-	return res;

-    res = new_size > *size ? 1 : 0;

-    *size = new_size;

-    return res;

-}

-

-int

-erts_sys_getenv_raw(char *key, char *value, size_t *size)

-{

-    int res;

-    erts_rwmtx_rlock(&environ_rwmtx);
-    res = erts_sys_getenv__(key, value, size);

-    erts_rwmtx_runlock(&environ_rwmtx);
-    return res;

-}

-

-void init_getenv_state(GETENV_STATE *state)

-{

-    erts_rwmtx_rlock(&environ_rwmtx);
-    state->environment_strings = GetEnvironmentStringsW();

-    state->next_string = state->environment_strings;

-}

-

-char *getenv_string(GETENV_STATE *state)

-{

-    ERTS_LC_ASSERT(erts_lc_rwmtx_is_rlocked(&environ_rwmtx));
-    if (state->next_string[0] == L'\0') {

-	return NULL;

-    } else {

-	WCHAR *res = state->next_string;

-	state->next_string += wcslen(res) + 1;

-	return (char *) res;

-    }

-}

-

-void fini_getenv_state(GETENV_STATE *state)

-{

-    FreeEnvironmentStringsW(state->environment_strings);

-    state->environment_strings = state->next_string = NULL;

-    erts_rwmtx_runlock(&environ_rwmtx);
-}

-

-int erts_sys_unsetenv(char *key)

-{

-    int res = 0;

-    WCHAR *wkey = (WCHAR *) key;

-

-    SetLastError(0);

-    erts_rwmtx_rlock(&environ_rwmtx);
-    GetEnvironmentVariableW(wkey,

-                            NULL,

-                            0);

-    if (GetLastError() != ERROR_ENVVAR_NOT_FOUND) {

-        res = (SetEnvironmentVariableW(wkey,

-                                       NULL) ? 0 : 1);

-    }

-    erts_rwmtx_runlock(&environ_rwmtx);
-    return res;

-}

-

-char*

-win_build_environment(char* new_env)

-{

-    if (new_env == NULL) {

-	return NULL;

-    } else {

-	WCHAR *tmp, *merged, *tmp_new;

-

-	tmp_new = (WCHAR *) new_env;

-	

-	erts_rwmtx_rlock(&environ_rwmtx);
-	tmp = GetEnvironmentStringsW();

-	merged = merge_environment(tmp, tmp_new);

-

-	FreeEnvironmentStringsW(tmp);

-	erts_rwmtx_runlock(&environ_rwmtx);
-	return (char *) merged;

-    }

-}

-

-static WCHAR *

-merge_environment(WCHAR *old, WCHAR *add)

-{

-    WCHAR **a_arg = env_to_arg(add);

-    WCHAR **c_arg = env_to_arg(old);

-    WCHAR *ret;

-    int i, j;

-    

-    for(i = 0; c_arg[i] != NULL; ++i)

-	;

-

-    for(j = 0; a_arg[j] != NULL; ++j)

-	;

-

-    c_arg = erts_realloc(ERTS_ALC_T_TMP,

-			 c_arg, (i+j+1) * sizeof(WCHAR *));

-

-    for(j = 0; a_arg[j] != NULL; ++j){

-	WCHAR **tmp;

-	WCHAR *current = a_arg[j];

-	WCHAR *eq_p = wcschr(current,L'=');

-	int unset = (eq_p!=NULL && eq_p[1]==L'\0');

-

-	if ((tmp = find_arg(c_arg, current)) != NULL) {

-	    if (!unset) {

-		*tmp = current;

-	    } else {

-		*tmp = c_arg[--i];

-		c_arg[i] = NULL;

-	    }

-	} else if (!unset) {

-	    c_arg[i++] = current;

-	    c_arg[i] = NULL;

-	}

-    }

-    ret = arg_to_env(c_arg);

-    erts_free(ERTS_ALC_T_TMP, c_arg);

-    erts_free(ERTS_ALC_T_TMP, a_arg);

-    return ret;

-}

-

-static WCHAR**

-find_arg(WCHAR **arg, WCHAR *str)

-{

-    WCHAR *tmp;

-    int len;

-

-    if ((tmp = wcschr(str, L'=')) != NULL) {

-	tmp++;

-	len = tmp - str;

-	while (*arg != NULL){

-	    if (_wcsnicmp(*arg, str, len) == 0){

-		return arg;

-	    }

-	    ++arg;

-	}

-    }

-    return NULL;

-}

-

-static int

-compare(const void *a, const void *b)

-{

-    WCHAR *s1 = *((WCHAR **) a);

-    WCHAR *s2 = *((WCHAR **) b);

-    WCHAR *e1 = wcschr(s1,L'=');

-    WCHAR *e2 = wcschr(s2,L'=');

-    int ret;

-    int len;

-  

-    if(!e1)

-	e1 = s1 + wcslen(s1);

-    if(!e2)

-	e2 = s2 + wcslen(s2);

-  

-    if((e1 - s1) > (e2 - s2))

-	len = (e2 - s2);

-    else

-	len = (e1 - s1);

-  

-    ret = _wcsnicmp(s1,s2,len);

-    if (ret == 0)

-	return ((e1 - s1) - (e2 - s2));

-    else

-	return ret;

-}

-

-static WCHAR**

-env_to_arg(WCHAR *env)

-{

-    WCHAR **ret;

-    WCHAR *tmp;

-    int i;

-    int num_strings = 0;

-

-    for(tmp = env; *tmp != '\0'; tmp += wcslen(tmp)+1) {

-	++num_strings;

-    }

-    ret = erts_alloc(ERTS_ALC_T_TMP, sizeof(WCHAR *) * (num_strings + 1));

-    i = 0;

-    for(tmp = env; *tmp != '\0'; tmp += wcslen(tmp)+1){

-	ret[i++] = tmp;

-    }

-    ret[i] = NULL;

-    return ret;

-}

-

-static WCHAR *

-arg_to_env(WCHAR **arg)

-{

-    WCHAR *block;

-    WCHAR *ptr;

-    int i;

-    int totlen = 1;		/* extra '\0' */

-

-    for(i = 0; arg[i] != NULL; ++i) {

-	totlen += wcslen(arg[i])+1;

-    }

-

-    /* sort the environment vector */

-    qsort(arg, i, sizeof(WCHAR *), &compare);

-

-    if (totlen == 1){

-	block = erts_alloc(ERTS_ALC_T_ENVIRONMENT, 2 * sizeof(WCHAR));

-	block[0] = block[1] = '\0'; 

-    } else {

-	block = erts_alloc(ERTS_ALC_T_ENVIRONMENT, totlen * sizeof(WCHAR));

-	ptr = block;

-	for(i=0; arg[i] != NULL; ++i){

-	    wcscpy(ptr, arg[i]);

-	    ptr += wcslen(ptr)+1;

-	}

-	*ptr = '\0';

-    }

-    return block;

-}

+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson AB 2002-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%
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#include "sys.h"
+#include "erl_sys_driver.h"
+#include "erl_alloc.h"
+
+static erts_osenv_t sysenv_global_env;
+static erts_rwmtx_t sysenv_rwmtx;
+
+static void import_initial_env(void);
+
+void erts_sys_env_init() {
+    erts_rwmtx_init(&sysenv_rwmtx, "environ", NIL,
+        ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
+
+    erts_osenv_init(&sysenv_global_env);
+    import_initial_env();
+}
+
+const erts_osenv_t *erts_sys_rlock_global_osenv() {
+    erts_rwmtx_rlock(&sysenv_rwmtx);
+    return &sysenv_global_env;
+}
+
+erts_osenv_t *erts_sys_rwlock_global_osenv() {
+    erts_rwmtx_rwlock(&sysenv_rwmtx);
+    return &sysenv_global_env;
+}
+
+void erts_sys_runlock_global_osenv() {
+    erts_rwmtx_runlock(&sysenv_rwmtx);
+}
+
+void erts_sys_rwunlock_global_osenv() {
+    erts_rwmtx_rwunlock(&sysenv_rwmtx);
+}
+
+int erts_sys_explicit_host_getenv(char *key, char *value, size_t *size) {
+    size_t new_size = GetEnvironmentVariableA(key, value, (DWORD)*size);
+
+    if(new_size == 0 && GetLastError() == ERROR_ENVVAR_NOT_FOUND) {
+        return 0;
+    } else if(new_size > *size) {
+        return -1;
+    }
+
+    *size = new_size;
+    return 1;
+}
+
+int erts_sys_explicit_8bit_putenv(char *key, char *value) {
+    WCHAR *wide_key, *wide_value;
+    int key_length, value_length;
+    int result;
+
+    /* Note that we do *NOT* honor the filename encoding flags (+fnu/+fnl)
+     * here; the previous implementation used SetEnvironmentVariableA and
+     * things may break if we step away from that. */
+
+    key_length = MultiByteToWideChar(CP_ACP, 0, key, -1, NULL, 0);
+    value_length = MultiByteToWideChar(CP_ACP, 0, value, -1, NULL, 0);
+
+    /* Report "not found" if either string isn't convertible. */
+    if(key_length == 0 || value_length == 0) {
+        return 0;
+    }
+
+    wide_key = erts_alloc(ERTS_ALC_T_TMP, key_length * sizeof(WCHAR));
+    wide_value = erts_alloc(ERTS_ALC_T_TMP, value_length * sizeof(WCHAR));
+
+    MultiByteToWideChar(CP_ACP, 0, key, -1, wide_key, key_length);
+    MultiByteToWideChar(CP_ACP, 0, value, -1, wide_value, value_length);
+
+    {
+        erts_osenv_data_t env_key, env_value;
+        erts_osenv_t *env;
+
+        env = erts_sys_rwlock_global_osenv();
+
+        /* -1 to exclude the NUL terminator. */
+        env_key.length = (key_length - 1) * sizeof(WCHAR);
+        env_key.data = wide_key;
+
+        env_value.length = (value_length - 1) * sizeof(WCHAR);
+        env_value.data = wide_value;
+
+        result = erts_osenv_put_native(env, &env_key, &env_value);
+        erts_sys_rwunlock_global_osenv();
+    }
+
+    erts_free(ERTS_ALC_T_TMP, wide_key);
+    erts_free(ERTS_ALC_T_TMP, wide_value);
+
+    return result;
+}
+
+int erts_sys_explicit_8bit_getenv(char *key, char *value, size_t *size) {
+    erts_osenv_data_t env_key, env_value;
+    int key_length, value_length, result;
+    WCHAR *wide_key, *wide_value;
+
+    key_length = MultiByteToWideChar(CP_ACP, 0, key, -1, NULL, 0);
+
+    /* Report "not found" if the string isn't convertible. */
+    if(key_length == 0) {
+        return 0;
+    }
+
+    wide_key = erts_alloc(ERTS_ALC_T_TMP, key_length * sizeof(WCHAR));
+    MultiByteToWideChar(CP_ACP, 0, key, -1, wide_key, key_length);
+
+    /* We assume that the worst possible size is twice the output buffer width,
+     * as we could theoretically be on a code page that requires surrogates. */
+    value_length = (*size) * 2;
+    wide_value = erts_alloc(ERTS_ALC_T_TMP, value_length * sizeof(WCHAR));
+
+    {
+        const erts_osenv_t *env = erts_sys_rlock_global_osenv();
+
+        /* -1 to exclude the NUL terminator. */
+        env_key.length = (key_length - 1) * sizeof(WCHAR);
+        env_key.data = wide_key;
+
+        env_value.length = value_length * sizeof(WCHAR);
+        env_value.data = wide_value;
+
+        result = erts_osenv_get_native(env, &env_key, &env_value);
+        erts_sys_runlock_global_osenv();
+    }
+
+    if(result == 1 && env_value.length > 0) {
+        /* This function doesn't NUL-terminate if the provided size is >= 0,
+         * so we pass (*size - 1) to reserve space for it and then do it
+         * manually. */
+        *size = WideCharToMultiByte(CP_ACP, 0, env_value.data,
+            env_value.length / sizeof(WCHAR), value, *size - 1, NULL, NULL);
+
+        if(*size == 0) {
+            if(GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
+                result = -1;
+            } else {
+                result = 0;
+            }
+        }
+    } else {
+        *size = 0;
+    }
+
+    if(*size > 0) {
+        value[*size] = '\0';
+    }
+
+    erts_free(ERTS_ALC_T_TMP, wide_key);
+    erts_free(ERTS_ALC_T_TMP, wide_value);
+
+    return result;
+}
+
+static void import_initial_env(void) {
+    WCHAR *environment_block, *current_variable;
+
+    environment_block = GetEnvironmentStringsW();
+    current_variable = environment_block;
+
+    while(wcslen(current_variable) > 0) {
+        WCHAR *separator_index = wcschr(current_variable, L'=');
+
+        /* We tolerate environment variables starting with '=' as the per-drive
+         * working directories are stored this way. */
+        if(separator_index == current_variable) {
+            separator_index = wcschr(separator_index + 1, L'=');
+        }
+
+        if(separator_index != NULL && separator_index != current_variable) {
+            erts_osenv_data_t env_key, env_value;
+
+            env_key.length = (separator_index - current_variable) * sizeof(WCHAR);
+            env_key.data = current_variable;
+
+            env_value.length = (wcslen(separator_index) - 1) * sizeof(WCHAR);
+            env_value.data = separator_index + 1;
+
+            erts_osenv_put_native(&sysenv_global_env, &env_key, &env_value);
+        }
+
+        current_variable += wcslen(current_variable) + 1;
+    }
+
+    FreeEnvironmentStringsW(environment_block);
+}
diff --git a/erts/emulator/test/driver_SUITE.erl b/erts/emulator/test/driver_SUITE.erl
index e133349216..294c42780d 100644
--- a/erts/emulator/test/driver_SUITE.erl
+++ b/erts/emulator/test/driver_SUITE.erl
@@ -80,6 +80,7 @@
          async_blast/1,
          thr_msg_blast/1,
          consume_timeslice/1,
+         env/1,
          z_test/1]).
 
 -export([bin_prefix/2]).
@@ -166,6 +167,7 @@ all() -> %% Keep a_test first and z_test last...
      async_blast,
      thr_msg_blast,
      consume_timeslice,
+     env,
      z_test].
 
 groups() -> 
@@ -2363,6 +2365,51 @@ count_proc_sched(Ps, PNs) ->
               PNs
     end.
 
+%%
+%% Tests whether erl_drv_putenv reflects in os:getenv and vice versa.
+%%
+env(Config) when is_list(Config) ->
+    ok = load_driver(proplists:get_value(data_dir, Config), env_drv),
+    Port = open_port({spawn_driver, env_drv}, []),
+    true = is_port(Port),
+
+    Keys = ["env_drv_a_key", "env_drv_b_key", "env_drv_c_key"],
+    Values = ["a_value", "b_value", "c_value"],
+
+    [env_put_test(Port, Key, Value) || Key <- Keys, Value <- Values],
+    [env_get_test(Port, Key, Value) || Key <- Keys, Value <- Values],
+    [env_oversize_test(Port, Key) || Key <- Keys],
+    [env_notfound_test(Port, Key) || Key <- Keys],
+
+    true = port_close(Port),
+    erl_ddll:unload_driver(env_drv),
+    ok.
+
+env_control(Port, Command, Key, Value) ->
+    KeyBin = list_to_binary(Key),
+    ValueBin = list_to_binary(Value),
+    Header = <<(byte_size(KeyBin)), (byte_size(ValueBin))>>,
+    Payload = <<KeyBin/binary, ValueBin/binary>>,
+    port_control(Port, Command, <<Header/binary, Payload/binary>>).
+
+env_put_test(Port, Key, Value) ->
+    os:unsetenv(Key),
+    [0] = env_control(Port, 0, Key, Value),
+    Value = os:getenv(Key).
+
+env_get_test(Port, Key, ExpectedValue) ->
+    true = os:putenv(Key, ExpectedValue),
+    [0] = env_control(Port, 1, Key, ExpectedValue).
+
+env_oversize_test(Port, Key) ->
+    os:putenv(Key, [$A || _ <- lists:seq(1, 1024)]),
+    [127] = env_control(Port, 1, Key, "").
+
+env_notfound_test(Port, Key) ->
+    true = os:unsetenv(Key),
+    [255] = env_control(Port, 1, Key, "").
+
+
 a_test(Config) when is_list(Config) ->
     rpc(Config, fun check_io_debug/0).
 
diff --git a/erts/emulator/test/driver_SUITE_data/Makefile.src b/erts/emulator/test/driver_SUITE_data/Makefile.src
index 1fedd72200..bcabaa689d 100644
--- a/erts/emulator/test/driver_SUITE_data/Makefile.src
+++ b/erts/emulator/test/driver_SUITE_data/Makefile.src
@@ -16,7 +16,8 @@ MISC_DRVS =		outputv_drv@dll@ \
 			thr_free_drv@dll@ \
 			async_blast_drv@dll@ \
 			thr_msg_blast_drv@dll@ \
-			consume_timeslice_drv@dll@
+			consume_timeslice_drv@dll@ \
+			env_drv@dll@
 
 SYS_INFO_DRVS = 	sys_info_base_drv@dll@ \
 			sys_info_prev_drv@dll@ \
diff --git a/erts/emulator/test/driver_SUITE_data/env_drv.c b/erts/emulator/test/driver_SUITE_data/env_drv.c
new file mode 100644
index 0000000000..0e910eeb84
--- /dev/null
+++ b/erts/emulator/test/driver_SUITE_data/env_drv.c
@@ -0,0 +1,108 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson AB 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%
+ */
+
+/* Tests whether erl_drv_putenv/erl_drv_getenv work correctly and reflect
+ * changes to os:putenv/getenv. */
+
+#include <string.h>
+#include <stdio.h>
+
+#include "erl_driver.h"
+
+static ErlDrvSSizeT env_drv_ctl(ErlDrvData drv_data, unsigned int cmd,
+        char* buf, ErlDrvSizeT len, char** rbuf, ErlDrvSizeT rsize);
+
+static ErlDrvEntry env_drv_entry = { 
+    NULL /* init */,
+    NULL /* start */,
+    NULL /* stop */,
+    NULL /* output */,
+    NULL /* ready_input */,
+    NULL /* ready_output */,
+    "env_drv",
+    NULL /* finish */,
+    NULL /* handle */,
+    env_drv_ctl,
+    NULL /* timeout */,
+    NULL /* outputv*/,
+    NULL /* ready_async */,
+    NULL /* flush */,
+    NULL /* call*/,
+    NULL /* event */,
+    ERL_DRV_EXTENDED_MARKER,
+    ERL_DRV_EXTENDED_MAJOR_VERSION,
+    ERL_DRV_EXTENDED_MINOR_VERSION,
+    ERL_DRV_FLAG_USE_PORT_LOCKING,
+    NULL /* handle2 */,
+    NULL /* handle_monitor */
+};
+
+DRIVER_INIT(env_drv) {
+    return &env_drv_entry;
+}
+
+static int test_putenv(ErlDrvData drv_data, char *buf, ErlDrvSizeT len) {
+    char key[256], value[256];
+    int key_len, value_len;
+
+    key_len = buf[0];
+    value_len = buf[1];
+
+    sprintf(key, "%.*s", key_len, &buf[2]);
+    sprintf(value, "%.*s", value_len, &buf[2 + key_len]);
+
+    return erl_drv_putenv(key, value);
+}
+
+static int test_getenv(ErlDrvData drv_data, char *buf, ErlDrvSizeT len) {
+    char expected_value[256], stored_value[256], key[256];
+    int expected_value_len, key_len;
+    size_t stored_value_len;
+    int res;
+
+    key_len = buf[0];
+    sprintf(key, "%.*s", key_len, &buf[2]);
+
+    expected_value_len = buf[1];
+    sprintf(expected_value, "%.*s", expected_value_len, &buf[2 + key_len]);
+
+    stored_value_len = sizeof(stored_value);
+    res = erl_drv_getenv(key, stored_value, &stored_value_len);
+
+    if(res == 0) {
+        return strcmp(stored_value, expected_value) != 0;
+    } else if(res == 1) {
+        return 127;
+    }
+
+    return 255;
+}
+
+static ErlDrvSSizeT env_drv_ctl(ErlDrvData drv_data, unsigned int cmd,
+        char* buf, ErlDrvSizeT len, char** rbuf, ErlDrvSizeT rsize) {
+
+    if(cmd == 0) {
+        (**rbuf) = (char)test_putenv(drv_data, buf, len);
+    } else {
+        (**rbuf) = (char)test_getenv(drv_data, buf, len);
+    }
+
+    return 1;
+}