diff --git a/ojluni/src/main/native/LinuxWatchService.c b/ojluni/src/main/native/LinuxWatchService.c
index 375aaa4..1f531d0 100644
--- a/ojluni/src/main/native/LinuxWatchService.c
+++ b/ojluni/src/main/native/LinuxWatchService.c
@@ -32,8 +32,14 @@
 #include <dlfcn.h>
 #include <sys/types.h>
 #include <sys/socket.h>
+// Android-changed: Fuchsia: Point to correct location of header. http://b/119426171
+// #include <sys/poll.h>
+#if defined(__Fuchsia__)
+#include <poll.h>
+#else
 #include <sys/poll.h>
 #include <sys/inotify.h>
+#endif
 
 #include "sun_nio_fs_LinuxWatchService.h"
 
diff --git a/ojluni/src/main/native/NativeThread.c b/ojluni/src/main/native/NativeThread.c
index 3a1c5c1..dc21e5d 100644
--- a/ojluni/src/main/native/NativeThread.c
+++ b/ojluni/src/main/native/NativeThread.c
@@ -48,6 +48,13 @@
   #include <signal.h>
   /* Also defined in net/bsd_close.c */
   #define INTERRUPT_SIGNAL SIGIO
+// BEGIN Android-added: Fuchsia: Support for Fuchsia platform.
+#elif __Fuchsia__
+  #include <pthread.h>
+  #include <signal.h>
+  /* Also defined in net/bsd_close.c */
+  #define INTERRUPT_SIGNAL SIGIO
+// END Android-added: Fuchsia: Support for Fuchsia platform.
 #else
   #error "missing platform-specific definition here"
 #endif
diff --git a/ojluni/src/main/native/Net.c b/ojluni/src/main/native/Net.c
index 462830d..bcf984e 100644
--- a/ojluni/src/main/native/Net.c
+++ b/ojluni/src/main/native/Net.c
@@ -23,7 +23,13 @@
  * questions.
  */
 
+// Android-changed: Fuchsia: Point to correct location of header. http://b/119426171
+// #include <sys/poll.h>
+#if defined(__Fuchsia__)
+#include <poll.h>
+#else
 #include <sys/poll.h>
+#endif
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <string.h>
@@ -374,7 +380,13 @@
             struct sockaddr_in *sin;
             sin = (struct sockaddr_in *) &sa;
             bzero(sin, sizeof(*sin));
+            // BEGIN Android-changed: Fuchsia: sin_len is not a sockaddr_in member on Fuchsia.
+            // http://b/119497331
+            // sin->sin_len = sizeof(struct sockaddr_in);
+#if !defined(__Fuchsia__)
             sin->sin_len  = sizeof(struct sockaddr_in);
+#endif
+            // END Android-changed: Fuchsia: sin_len is not a sockaddr_in member on Fuchsia.
             sin->sin_family = AF_INET;
             sin->sin_port = htonl(0);
             sin->sin_addr.s_addr = INADDR_ANY;
@@ -409,7 +421,13 @@
             struct sockaddr_in *sin;
             sin = (struct sockaddr_in *) &sa;
             bzero(sin, sizeof(*sin));
+            // BEGIN Android-changed: Fuchsia: sin_len is not a sockaddr_in member on Fuchsia.
+            // http://b/119497331
+            // sin->sin_len = sizeof(struct sockaddr_in);
+#if !defined(__Fuchsia__)
             sin->sin_len  = sizeof(struct sockaddr_in);
+#endif
+            // END Android-changed: Fuchsia: sin_len is not a sockaddr_in member on Fuchsia.
             sin->sin_family = AF_INET;
             sin->sin_port = htonl(0);
             sin->sin_addr.s_addr = INADDR_ANY;
diff --git a/ojluni/src/main/native/UNIXProcess_md.c b/ojluni/src/main/native/UNIXProcess_md.c
index 9d869b9..807a915 100644
--- a/ojluni/src/main/native/UNIXProcess_md.c
+++ b/ojluni/src/main/native/UNIXProcess_md.c
@@ -44,7 +44,9 @@
 #include <stdlib.h>
 #include <sys/types.h>
 #include <ctype.h>
-#ifdef _ALLBSD_SOURCE
+// Android-changed: Fuchsia: Point to correct location of header. http://b/119426171
+// #ifdef _ALLBSD_SOURCE
+#if defined(_ALLBSD_SOURCE) && !defined(__Fuchsia__)
 #include <wait.h>
 #else
 #include <sys/wait.h>
diff --git a/ojluni/src/main/native/UnixNativeDispatcher.c b/ojluni/src/main/native/UnixNativeDispatcher.c
index e8a1623..1853a2c 100644
--- a/ojluni/src/main/native/UnixNativeDispatcher.c
+++ b/ojluni/src/main/native/UnixNativeDispatcher.c
@@ -46,7 +46,9 @@
 #include <string.h>
 #endif
 
-#ifdef _ALLBSD_SOURCE
+// Android-changed: Fuchsia: Alias *64 on Fuchsia builds. http://b/119496969
+// #ifdef _ALLBSD_SOURCE
+#if defined(_ALLBSD_SOURCE) || defined(__Fuchsia__)
 #include <string.h>
 
 #define stat64 stat
diff --git a/ojluni/src/main/native/io_util_md.c b/ojluni/src/main/native/io_util_md.c
index 8b8a687..39ceb4a 100644
--- a/ojluni/src/main/native/io_util_md.c
+++ b/ojluni/src/main/native/io_util_md.c
@@ -30,6 +30,14 @@
 #include "io_util_md.h"
 #include <string.h>
 
+// BEGIN Android-added: Fuchsia: Alias *64 functions on Fuchsia. http://b/119496969
+#if defined(__Fuchsia__)
+#define stat64 stat
+#define fstat64 fstat
+#define open64 open
+#endif
+// END Android-added: Fuchsia: Alias *64 functions on Fuchsia. http://b/119496969
+
 #ifdef MACOSX
 
 #include <CoreFoundation/CoreFoundation.h>
diff --git a/ojluni/src/main/native/jvm_md.h b/ojluni/src/main/native/jvm_md.h
index a366445..54743c6 100644
--- a/ojluni/src/main/native/jvm_md.h
+++ b/ojluni/src/main/native/jvm_md.h
@@ -65,7 +65,13 @@
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <errno.h>
+// Android-changed: Fuchsia: Point to correct header location. http://b/119426171
+// #include <sys/signal.h>
+#if !defined(__Fuchsia__)
 #include <sys/signal.h>
+#else
+#include <signal.h>
+#endif
 
 /* O Flags */
 
diff --git a/ojluni/src/main/native/linux_close.cpp b/ojluni/src/main/native/linux_close.cpp
index e100035..5b48292 100644
--- a/ojluni/src/main/native/linux_close.cpp
+++ b/ojluni/src/main/native/linux_close.cpp
@@ -30,12 +30,22 @@
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <sys/time.h>
+// Android-changed: Fuchsia: Drop #include of resource.h absent on Fuchsia. http://b/119433484
+// #include <sys/resource.h>
+#if !defined(__Fuchsia__)
 #include <sys/resource.h>
+#endif
 #include <sys/uio.h>
 #include <unistd.h>
 #include <errno.h>
 
+// Android-changed: Fuchsia: Fix poll.h include location
+// #include <sys/poll.h>
+#if !defined(__Fuchsia__)
 #include <sys/poll.h>
+#else
+#include <poll.h>
+#endif
 
 
 #include <nativehelper/AsynchronousCloseMonitor.h>
diff --git a/ojluni/src/main/native/net_util_md.h b/ojluni/src/main/native/net_util_md.h
index 94a8877..0bef5b9 100644
--- a/ojluni/src/main/native/net_util_md.h
+++ b/ojluni/src/main/native/net_util_md.h
@@ -33,11 +33,18 @@
 #include <unistd.h>
 
 #ifndef USE_SELECT
+// Android-changed: Fuchsia: Point to correct location of header. http://b/119426171
+// #include <sys/poll.h>
+#if !defined(__Fuchsia__)
 #include <sys/poll.h>
+#else
+#include <poll.h>
+#endif
 #endif
 
-
-#if defined(__linux__) || defined(MACOSX)
+// Android-changed: Fuchsia: Use the non-JVM NET_* on Fuchsia also.
+// #if defined(__linux__) || defined(MACOSX)
+#if defined(__linux__) || defined(MACOSX) || defined(__Fuchsia__)
 extern int NET_Timeout(int s, long timeout);
 extern int NET_Read(int s, void* buf, size_t len);
 extern int NET_RecvFrom(int s, void *buf, int len, unsigned int flags,
