diff --git a/libc/system_properties/Android.bp b/libc/system_properties/Android.bp
new file mode 100644
index 0000000..f94cda9
--- /dev/null
+++ b/libc/system_properties/Android.bp
@@ -0,0 +1,24 @@
+cc_library_static {
+    name: "libsystemproperties",
+    defaults: ["libc_defaults"],
+    srcs: [
+        "context_node.cpp",
+        "contexts_split.cpp",
+        "contexts_serialized.cpp",
+        "prop_area.cpp",
+        "prop_info.cpp",
+        "system_properties.cpp",
+    ],
+    whole_static_libs: [
+        "libpropertyinfoparser",
+    ],
+    static_libs: [
+        "libasync_safe",
+    ],
+
+    include_dirs: [
+        "bionic/libc",
+        "bionic/libstdc++/include",
+    ],
+    export_include_dirs: ["include"],
+}
diff --git a/libc/system_properties/context_node.cpp b/libc/system_properties/context_node.cpp
index 13cef75..5496b5a 100644
--- a/libc/system_properties/context_node.cpp
+++ b/libc/system_properties/context_node.cpp
@@ -26,13 +26,14 @@
  * SUCH DAMAGE.
  */
 
-#include "context_node.h"
+#include "system_properties/context_node.h"
 
+#include <limits.h>
 #include <unistd.h>
 
 #include <async_safe/log.h>
 
-#include "property_filename.h"
+#include "system_properties/system_properties.h"
 
 // pthread_mutex_lock() calls into system_properties in the case of contention.
 // This creates a risk of dead lock if any system_properties functions
@@ -49,8 +50,7 @@
   }
 
   char filename[PROP_FILENAME_MAX];
-  int len =
-      async_safe_format_buffer(filename, sizeof(filename), "%s/%s", property_filename, context_);
+  int len = async_safe_format_buffer(filename, sizeof(filename), "%s/%s", filename_, context_);
   if (len < 0 || len > PROP_FILENAME_MAX) {
     lock_.unlock();
     return false;
@@ -85,8 +85,7 @@
 
 bool ContextNode::CheckAccess() {
   char filename[PROP_FILENAME_MAX];
-  int len =
-      async_safe_format_buffer(filename, sizeof(filename), "%s/%s", property_filename, context_);
+  int len = async_safe_format_buffer(filename, sizeof(filename), "%s/%s", filename_, context_);
   if (len < 0 || len > PROP_FILENAME_MAX) {
     return false;
   }
diff --git a/libc/system_properties/contexts_serialized.cpp b/libc/system_properties/contexts_serialized.cpp
index 117b5cf..062e8a5 100644
--- a/libc/system_properties/contexts_serialized.cpp
+++ b/libc/system_properties/contexts_serialized.cpp
@@ -26,9 +26,10 @@
  * SUCH DAMAGE.
  */
 
-#include "contexts_serialized.h"
+#include "system_properties/contexts_serialized.h"
 
 #include <fcntl.h>
+#include <limits.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/types.h>
@@ -38,7 +39,7 @@
 #include <async_safe/log.h>
 
 #include "private/bionic_prctl.h"
-#include "property_filename.h"
+#include "system_properties/system_properties.h"
 
 bool ContextsSerialized::InitializeContextNodes() {
   auto num_context_nodes = property_info_area_file_->num_contexts();
@@ -58,7 +59,7 @@
   context_nodes_mmap_size_ = context_nodes_mmap_size;
 
   for (size_t i = 0; i < num_context_nodes; ++i) {
-    new (&context_nodes_[i]) ContextNode(property_info_area_file_->context(i));
+    new (&context_nodes_[i]) ContextNode(property_info_area_file_->context(i), filename_);
   }
 
   return true;
@@ -66,8 +67,7 @@
 
 bool ContextsSerialized::MapSerialPropertyArea(bool access_rw, bool* fsetxattr_failed) {
   char filename[PROP_FILENAME_MAX];
-  int len = async_safe_format_buffer(filename, sizeof(filename), "%s/properties_serial",
-                                     property_filename);
+  int len = async_safe_format_buffer(filename, sizeof(filename), "%s/properties_serial", filename_);
   if (len < 0 || len > PROP_FILENAME_MAX) {
     serial_prop_area_ = nullptr;
     return false;
@@ -95,27 +95,28 @@
   return true;
 }
 
-bool ContextsSerialized::Initialize(bool writable) {
+bool ContextsSerialized::Initialize(bool writable, const char* filename, bool* fsetxattr_failed) {
+  filename_ = filename;
   if (!InitializeProperties()) {
     return false;
   }
 
   if (writable) {
-    mkdir(property_filename, S_IRWXU | S_IXGRP | S_IXOTH);
+    mkdir(filename_, S_IRWXU | S_IXGRP | S_IXOTH);
     bool open_failed = false;
-    bool fsetxattr_failed = false;
+    if (fsetxattr_failed) {
+      *fsetxattr_failed = false;
+    }
 
     for (size_t i = 0; i < num_context_nodes_; ++i) {
-      if (!context_nodes_[i].Open(true, &fsetxattr_failed)) {
+      if (!context_nodes_[i].Open(true, fsetxattr_failed)) {
         open_failed = true;
       }
     }
-    if (open_failed || !MapSerialPropertyArea(true, &fsetxattr_failed)) {
+    if (open_failed || !MapSerialPropertyArea(true, fsetxattr_failed)) {
       FreeAndUnmap();
       return false;
     }
-
-    return !fsetxattr_failed;
   } else {
     if (!MapSerialPropertyArea(false, nullptr)) {
       FreeAndUnmap();
diff --git a/libc/system_properties/contexts_split.cpp b/libc/system_properties/contexts_split.cpp
index 77f2069..b8afa29 100644
--- a/libc/system_properties/contexts_split.cpp
+++ b/libc/system_properties/contexts_split.cpp
@@ -26,22 +26,23 @@
  * SUCH DAMAGE.
  */
 
-#include "contexts_split.h"
+#include "system_properties/contexts_split.h"
 
 #include <ctype.h>
+#include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 
 #include <async_safe/log.h>
 
-#include "context_node.h"
-#include "property_filename.h"
+#include "system_properties/context_node.h"
+#include "system_properties/system_properties.h"
 
 class ContextListNode : public ContextNode {
  public:
-  ContextListNode(ContextListNode* next, const char* context)
-      : ContextNode(strdup(context)), next(next) {
+  ContextListNode(ContextListNode* next, const char* context, const char* filename)
+      : ContextNode(strdup(context), filename), next(next) {
   }
 
   ~ContextListNode() {
@@ -194,8 +195,7 @@
 
 bool ContextsSplit::MapSerialPropertyArea(bool access_rw, bool* fsetxattr_failed) {
   char filename[PROP_FILENAME_MAX];
-  int len = async_safe_format_buffer(filename, sizeof(filename), "%s/properties_serial",
-                                     property_filename);
+  int len = async_safe_format_buffer(filename, sizeof(filename), "%s/properties_serial", filename_);
   if (len < 0 || len > PROP_FILENAME_MAX) {
     serial_prop_area_ = nullptr;
     return false;
@@ -245,7 +245,7 @@
     if (old_context) {
       ListAddAfterLen(&prefixes_, prop_prefix, old_context);
     } else {
-      ListAdd(&contexts_, context);
+      ListAdd(&contexts_, context, filename_);
       ListAddAfterLen(&prefixes_, prop_prefix, contexts_);
     }
     free(prop_prefix);
@@ -285,26 +285,28 @@
   return true;
 }
 
-bool ContextsSplit::Initialize(bool writable) {
+bool ContextsSplit::Initialize(bool writable, const char* filename, bool* fsetxattr_failed) {
+  filename_ = filename;
   if (!InitializeProperties()) {
     return false;
   }
 
   if (writable) {
-    mkdir(property_filename, S_IRWXU | S_IXGRP | S_IXOTH);
+    mkdir(filename_, S_IRWXU | S_IXGRP | S_IXOTH);
     bool open_failed = false;
-    bool fsetxattr_failed = false;
+    if (fsetxattr_failed) {
+      *fsetxattr_failed = false;
+    }
+
     ListForEach(contexts_, [&fsetxattr_failed, &open_failed](ContextListNode* l) {
-      if (!l->Open(true, &fsetxattr_failed)) {
+      if (!l->Open(true, fsetxattr_failed)) {
         open_failed = true;
       }
     });
-    if (open_failed || !MapSerialPropertyArea(true, &fsetxattr_failed)) {
+    if (open_failed || !MapSerialPropertyArea(true, fsetxattr_failed)) {
       FreeAndUnmap();
       return false;
     }
-
-    return !fsetxattr_failed;
   } else {
     if (!MapSerialPropertyArea(false, nullptr)) {
       FreeAndUnmap();
diff --git a/libc/system_properties/context_node.h b/libc/system_properties/include/system_properties/context_node.h
similarity index 87%
rename from libc/system_properties/context_node.h
rename to libc/system_properties/include/system_properties/context_node.h
index 769b853..6a3bbcd 100644
--- a/libc/system_properties/context_node.h
+++ b/libc/system_properties/include/system_properties/context_node.h
@@ -35,17 +35,15 @@
 
 class ContextNode {
  public:
-  ContextNode(const char* context) : context_(context), pa_(nullptr), no_access_(false) {
+  ContextNode(const char* context, const char* filename)
+      : context_(context), pa_(nullptr), no_access_(false), filename_(filename) {
     lock_.init(false);
   }
   ~ContextNode() {
     Unmap();
   }
 
-  ContextNode(const ContextNode&) = delete;
-  ContextNode(ContextNode&&) = delete;
-  void operator=(const ContextNode&) = delete;
-  void operator=(const ContextNode&&) = delete;
+  DISALLOW_COPY_AND_ASSIGN(ContextNode);
 
   bool Open(bool access_rw, bool* fsetxattr_failed);
   bool CheckAccessAndOpen();
@@ -66,6 +64,7 @@
   const char* context_;
   prop_area* pa_;
   bool no_access_;
+  const char* filename_;
 };
 
 #endif
diff --git a/libc/system_properties/contexts.h b/libc/system_properties/include/system_properties/contexts.h
similarity index 95%
rename from libc/system_properties/contexts.h
rename to libc/system_properties/include/system_properties/contexts.h
index 5df9d96..8f154ed 100644
--- a/libc/system_properties/contexts.h
+++ b/libc/system_properties/include/system_properties/contexts.h
@@ -37,7 +37,7 @@
   virtual ~Contexts() {
   }
 
-  virtual bool Initialize(bool writable) = 0;
+  virtual bool Initialize(bool writable, const char* filename, bool* fsetxattr_failed) = 0;
   virtual prop_area* GetPropAreaForName(const char* name) = 0;
   virtual prop_area* GetSerialPropArea() = 0;
   virtual void ForEach(void (*propfn)(const prop_info* pi, void* cookie), void* cookie) = 0;
diff --git a/libc/system_properties/contexts_pre_split.h b/libc/system_properties/include/system_properties/contexts_pre_split.h
similarity index 94%
rename from libc/system_properties/contexts_pre_split.h
rename to libc/system_properties/include/system_properties/contexts_pre_split.h
index bbc8529..14b00f1 100644
--- a/libc/system_properties/contexts_pre_split.h
+++ b/libc/system_properties/include/system_properties/contexts_pre_split.h
@@ -32,7 +32,6 @@
 #include "contexts.h"
 #include "prop_area.h"
 #include "prop_info.h"
-#include "property_filename.h"
 
 class ContextsPreSplit : public Contexts {
  public:
@@ -40,8 +39,8 @@
   }
 
   // We'll never initialize this legacy option as writable, so don't even check the arg.
-  virtual bool Initialize(bool) override {
-    pre_split_prop_area_ = prop_area::map_prop_area(property_filename);
+  virtual bool Initialize(bool, const char* filename, bool*) override {
+    pre_split_prop_area_ = prop_area::map_prop_area(filename);
     return pre_split_prop_area_ != nullptr;
   }
 
diff --git a/libc/system_properties/contexts_serialized.h b/libc/system_properties/include/system_properties/contexts_serialized.h
similarity index 94%
rename from libc/system_properties/contexts_serialized.h
rename to libc/system_properties/include/system_properties/contexts_serialized.h
index 52474c3..010730a 100644
--- a/libc/system_properties/contexts_serialized.h
+++ b/libc/system_properties/include/system_properties/contexts_serialized.h
@@ -39,7 +39,7 @@
   virtual ~ContextsSerialized() override {
   }
 
-  virtual bool Initialize(bool writable) override;
+  virtual bool Initialize(bool writable, const char* filename, bool* fsetxattr_failed) override;
   virtual prop_area* GetPropAreaForName(const char* name) override;
   virtual prop_area* GetSerialPropArea() override {
     return serial_prop_area_;
@@ -53,6 +53,7 @@
   bool InitializeProperties();
   bool MapSerialPropertyArea(bool access_rw, bool* fsetxattr_failed);
 
+  const char* filename_;
   android::properties::PropertyInfoAreaFile property_info_area_file_;
   ContextNode* context_nodes_ = nullptr;
   size_t num_context_nodes_ = 0;
diff --git a/libc/system_properties/contexts_split.h b/libc/system_properties/include/system_properties/contexts_split.h
similarity index 94%
rename from libc/system_properties/contexts_split.h
rename to libc/system_properties/include/system_properties/contexts_split.h
index f98eb44..06c405a 100644
--- a/libc/system_properties/contexts_split.h
+++ b/libc/system_properties/include/system_properties/contexts_split.h
@@ -39,7 +39,7 @@
   virtual ~ContextsSplit() override {
   }
 
-  virtual bool Initialize(bool writable) override;
+  virtual bool Initialize(bool writable, const char* filename, bool* fsetxattr_failed) override;
   virtual prop_area* GetPropAreaForName(const char* name) override;
   virtual prop_area* GetSerialPropArea() override {
     return serial_prop_area_;
@@ -56,6 +56,7 @@
   PrefixNode* prefixes_ = nullptr;
   ContextListNode* contexts_ = nullptr;
   prop_area* serial_prop_area_ = nullptr;
+  const char* filename_ = nullptr;
 };
 
 #endif
diff --git a/libc/system_properties/prop_area.h b/libc/system_properties/include/system_properties/prop_area.h
similarity index 99%
rename from libc/system_properties/prop_area.h
rename to libc/system_properties/include/system_properties/prop_area.h
index 10c1adb..a7d5d22 100644
--- a/libc/system_properties/prop_area.h
+++ b/libc/system_properties/include/system_properties/prop_area.h
@@ -103,7 +103,7 @@
   }
 
   prop_area(const uint32_t magic, const uint32_t version) : magic_(magic), version_(version) {
-    atomic_init(&serial_, 0);
+    atomic_init(&serial_, 0u);
     memset(reserved_, 0, sizeof(reserved_));
     // Allocate enough space for the root node.
     bytes_used_ = sizeof(prop_bt);
diff --git a/libc/system_properties/prop_info.h b/libc/system_properties/include/system_properties/prop_info.h
similarity index 100%
rename from libc/system_properties/prop_info.h
rename to libc/system_properties/include/system_properties/prop_info.h
diff --git a/libc/system_properties/include/system_properties/system_properties.h b/libc/system_properties/include/system_properties/system_properties.h
new file mode 100644
index 0000000..c74f875
--- /dev/null
+++ b/libc/system_properties/include/system_properties/system_properties.h
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef SYSTEM_PROPERTIES_SYSTEM_PROPERTIES_H
+#define SYSTEM_PROPERTIES_SYSTEM_PROPERTIES_H
+
+#include <stdint.h>
+#include <sys/system_properties.h>
+
+#include "contexts.h"
+#include "contexts_pre_split.h"
+#include "contexts_serialized.h"
+#include "contexts_split.h"
+
+constexpr int PROP_FILENAME_MAX = 1024;
+
+class SystemProperties {
+ public:
+  // Note that system properties are initialized before libc calls static initializers, so
+  // doing any initialization in this constructor is an error.  Even a Constructor that zero
+  // initializes this class will clobber the previous property initialization.
+  // We rely on the static SystemProperties in libc to be placed in .bss and zero initialized.
+  SystemProperties() {
+  }
+  // Special constructor for testing that also zero initializes the important members.
+  SystemProperties(bool initialized) : initialized_(initialized) {
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(SystemProperties);
+
+  bool Init(const char* filename);
+  bool AreaInit(const char* filename, bool* fsetxattr_failed);
+  uint32_t AreaSerial();
+  const prop_info* Find(const char* name);
+  int Read(const prop_info* pi, char* name, char* value);
+  void ReadCallback(const prop_info* pi,
+                    void (*callback)(void* cookie, const char* name, const char* value,
+                                     uint32_t serial),
+                    void* cookie);
+  int Get(const char* name, char* value);
+  int Update(prop_info* pi, const char* value, unsigned int len);
+  int Add(const char* name, unsigned int namelen, const char* value, unsigned int valuelen);
+  uint32_t Serial(const prop_info* pi);
+  uint32_t WaitAny(uint32_t old_serial);
+  bool Wait(const prop_info* pi, uint32_t old_serial, uint32_t* new_serial_ptr,
+            const timespec* relative_timeout);
+  const prop_info* FindNth(unsigned n);
+  int Foreach(void (*propfn)(const prop_info* pi, void* cookie), void* cookie);
+
+  Contexts* contexts() {
+    return reinterpret_cast<Contexts*>(&contexts_union_);
+  }
+
+ private:
+  // We don't want to use new or malloc in properties (b/31659220), and since these classes
+  // are small enough and we place them in a union.  See the above note about Constructors
+  // for why there is a no-op constructor here.
+  union ContextsUnion {
+    ContextsUnion() {
+    }
+    ~ContextsUnion() {
+    }
+    ContextsSerialized contexts_serialized;
+    ContextsSplit contexts_split;
+    ContextsPreSplit contexts_pre_split;
+  } contexts_union_;
+  bool initialized_;
+  char property_filename_[PROP_FILENAME_MAX];
+};
+
+#endif
diff --git a/libc/system_properties/prop_area.cpp b/libc/system_properties/prop_area.cpp
index 032fa4e..42bee9f 100644
--- a/libc/system_properties/prop_area.cpp
+++ b/libc/system_properties/prop_area.cpp
@@ -26,6 +26,8 @@
  * SUCH DAMAGE.
  */
 
+#include "system_properties/prop_area.h"
+
 #include <errno.h>
 #include <fcntl.h>
 #include <stdlib.h>
@@ -39,8 +41,6 @@
 
 #include <async_safe/log.h>
 
-#include "prop_area.h"
-
 constexpr size_t PA_SIZE = 128 * 1024;
 constexpr uint32_t PROP_AREA_MAGIC = 0x504f5250;
 constexpr uint32_t PROP_AREA_VERSION = 0xfc6ed0ab;
diff --git a/libc/system_properties/prop_info.cpp b/libc/system_properties/prop_info.cpp
index 5123f92..890d1cf 100644
--- a/libc/system_properties/prop_info.cpp
+++ b/libc/system_properties/prop_info.cpp
@@ -26,7 +26,7 @@
  * SUCH DAMAGE.
  */
 
-#include "prop_info.h"
+#include "system_properties/prop_info.h"
 
 #include <string.h>
 
diff --git a/libc/system_properties/property_filename.h b/libc/system_properties/property_filename.h
deleted file mode 100644
index 0f7bcf7..0000000
--- a/libc/system_properties/property_filename.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (C) 2008 The Android Open Source Project
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *  * Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- *  * Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in
- *    the documentation and/or other materials provided with the
- *    distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
- * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
- * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
- * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#ifndef SYSTEM_PROPERTIES_PROPERTY_FILENAME_H
-#define SYSTEM_PROPERTIES_PROPERTY_FILENAME_H
-
-// These are globals set by __system_property_set_filename().
-// There isn't huge benefit in refactoring them, so they're alone in this header.
-constexpr int PROP_FILENAME_MAX = 1024;
-extern char property_filename[PROP_FILENAME_MAX];
-
-#endif
diff --git a/libc/system_properties/system_properties.cpp b/libc/system_properties/system_properties.cpp
index f67fc4d..c610df2 100644
--- a/libc/system_properties/system_properties.cpp
+++ b/libc/system_properties/system_properties.cpp
@@ -26,246 +26,30 @@
  * SUCH DAMAGE.
  */
 
+#include "system_properties/system_properties.h"
+
 #include <errno.h>
-#include <fcntl.h>
-#include <netinet/in.h>
-#include <poll.h>
 #include <stdatomic.h>
-#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sys/select.h>
-#include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/types.h>
-#include <sys/uio.h>
-#include <sys/un.h>
 #include <unistd.h>
 
-#define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_
-#include <sys/_system_properties.h>
-#include <sys/system_properties.h>
-
 #include <new>
 
 #include <async_safe/log.h>
 
 #include "private/ErrnoRestorer.h"
-#include "private/bionic_defs.h"
 #include "private/bionic_futex.h"
-#include "private/bionic_macros.h"
-#include "private/bionic_sdk_version.h"
 
-#include "context_node.h"
-#include "contexts.h"
-#include "contexts_pre_split.h"
-#include "contexts_serialized.h"
-#include "contexts_split.h"
-#include "prop_area.h"
-#include "prop_info.h"
-#include "property_filename.h"
-
-// We don't want to use new or malloc in properties (b/31659220), and since these classes are
-// small enough and we place them in a static union.  Note that system properties are initialized
-// before static initializers are called, so using a Constructor here is an error.  Even a
-// Constructor that zero initializes a class will clobber the previous property initialization.
-static union ContextsUnion {
-  ContextsUnion() {}
-  ~ContextsUnion() {}
-  ContextsSerialized contexts_serialized;
-  ContextsSplit contexts_split;
-  ContextsPreSplit contexts_pre_split;
-} contexts_union;
-static Contexts* contexts = nullptr;
+#include "system_properties/context_node.h"
+#include "system_properties/prop_area.h"
+#include "system_properties/prop_info.h"
 
 #define SERIAL_DIRTY(serial) ((serial)&1)
 #define SERIAL_VALUE_LEN(serial) ((serial) >> 24)
 
-static const char property_service_socket[] = "/dev/socket/" PROP_SERVICE_NAME;
-static const char* kServiceVersionPropertyName = "ro.property_service.version";
-
-// This is public because it was exposed in the NDK. As of 2017-01, ~60 apps reference this symbol.
-// It is set to nullptr and never modified.
-__BIONIC_WEAK_VARIABLE_FOR_NATIVE_BRIDGE
-prop_area* __system_property_area__ = nullptr;
-
-char property_filename[PROP_FILENAME_MAX] = PROP_FILENAME;
-
-class PropertyServiceConnection {
- public:
-  PropertyServiceConnection() : last_error_(0) {
-    socket_ = ::socket(AF_LOCAL, SOCK_STREAM | SOCK_CLOEXEC, 0);
-    if (socket_ == -1) {
-      last_error_ = errno;
-      return;
-    }
-
-    const size_t namelen = strlen(property_service_socket);
-    sockaddr_un addr;
-    memset(&addr, 0, sizeof(addr));
-    strlcpy(addr.sun_path, property_service_socket, sizeof(addr.sun_path));
-    addr.sun_family = AF_LOCAL;
-    socklen_t alen = namelen + offsetof(sockaddr_un, sun_path) + 1;
-
-    if (TEMP_FAILURE_RETRY(connect(socket_, reinterpret_cast<sockaddr*>(&addr), alen)) == -1) {
-      last_error_ = errno;
-      close(socket_);
-      socket_ = -1;
-    }
-  }
-
-  bool IsValid() {
-    return socket_ != -1;
-  }
-
-  int GetLastError() {
-    return last_error_;
-  }
-
-  bool RecvInt32(int32_t* value) {
-    int result = TEMP_FAILURE_RETRY(recv(socket_, value, sizeof(*value), MSG_WAITALL));
-    return CheckSendRecvResult(result, sizeof(*value));
-  }
-
-  int socket() {
-    return socket_;
-  }
-
-  ~PropertyServiceConnection() {
-    if (socket_ != -1) {
-      close(socket_);
-    }
-  }
-
- private:
-  bool CheckSendRecvResult(int result, int expected_len) {
-    if (result == -1) {
-      last_error_ = errno;
-    } else if (result != expected_len) {
-      last_error_ = -1;
-    } else {
-      last_error_ = 0;
-    }
-
-    return last_error_ == 0;
-  }
-
-  int socket_;
-  int last_error_;
-
-  friend class SocketWriter;
-};
-
-class SocketWriter {
- public:
-  explicit SocketWriter(PropertyServiceConnection* connection)
-      : connection_(connection), iov_index_(0), uint_buf_index_(0) {
-  }
-
-  SocketWriter& WriteUint32(uint32_t value) {
-    CHECK(uint_buf_index_ < kUintBufSize);
-    CHECK(iov_index_ < kIovSize);
-    uint32_t* ptr = uint_buf_ + uint_buf_index_;
-    uint_buf_[uint_buf_index_++] = value;
-    iov_[iov_index_].iov_base = ptr;
-    iov_[iov_index_].iov_len = sizeof(*ptr);
-    ++iov_index_;
-    return *this;
-  }
-
-  SocketWriter& WriteString(const char* value) {
-    uint32_t valuelen = strlen(value);
-    WriteUint32(valuelen);
-    if (valuelen == 0) {
-      return *this;
-    }
-
-    CHECK(iov_index_ < kIovSize);
-    iov_[iov_index_].iov_base = const_cast<char*>(value);
-    iov_[iov_index_].iov_len = valuelen;
-    ++iov_index_;
-
-    return *this;
-  }
-
-  bool Send() {
-    if (!connection_->IsValid()) {
-      return false;
-    }
-
-    if (writev(connection_->socket(), iov_, iov_index_) == -1) {
-      connection_->last_error_ = errno;
-      return false;
-    }
-
-    iov_index_ = uint_buf_index_ = 0;
-    return true;
-  }
-
- private:
-  static constexpr size_t kUintBufSize = 8;
-  static constexpr size_t kIovSize = 8;
-
-  PropertyServiceConnection* connection_;
-  iovec iov_[kIovSize];
-  size_t iov_index_;
-  uint32_t uint_buf_[kUintBufSize];
-  size_t uint_buf_index_;
-
-  DISALLOW_IMPLICIT_CONSTRUCTORS(SocketWriter);
-};
-
-struct prop_msg {
-  unsigned cmd;
-  char name[PROP_NAME_MAX];
-  char value[PROP_VALUE_MAX];
-};
-
-static int send_prop_msg(const prop_msg* msg) {
-  PropertyServiceConnection connection;
-  if (!connection.IsValid()) {
-    return connection.GetLastError();
-  }
-
-  int result = -1;
-  int s = connection.socket();
-
-  const int num_bytes = TEMP_FAILURE_RETRY(send(s, msg, sizeof(prop_msg), 0));
-  if (num_bytes == sizeof(prop_msg)) {
-    // We successfully wrote to the property server but now we
-    // wait for the property server to finish its work.  It
-    // acknowledges its completion by closing the socket so we
-    // poll here (on nothing), waiting for the socket to close.
-    // If you 'adb shell setprop foo bar' you'll see the POLLHUP
-    // once the socket closes.  Out of paranoia we cap our poll
-    // at 250 ms.
-    pollfd pollfds[1];
-    pollfds[0].fd = s;
-    pollfds[0].events = 0;
-    const int poll_result = TEMP_FAILURE_RETRY(poll(pollfds, 1, 250 /* ms */));
-    if (poll_result == 1 && (pollfds[0].revents & POLLHUP) != 0) {
-      result = 0;
-    } else {
-      // Ignore the timeout and treat it like a success anyway.
-      // The init process is single-threaded and its property
-      // service is sometimes slow to respond (perhaps it's off
-      // starting a child process or something) and thus this
-      // times out and the caller thinks it failed, even though
-      // it's still getting around to it.  So we fake it here,
-      // mostly for ctl.* properties, but we do try and wait 250
-      // ms so callers who do read-after-write can reliably see
-      // what they've written.  Most of the time.
-      // TODO: fix the system properties design.
-      async_safe_format_log(ANDROID_LOG_WARN, "libc",
-                            "Property service has timed out while trying to set \"%s\" to \"%s\"",
-                            msg->name, msg->value);
-      result = 0;
-    }
-  }
-
-  return result;
-}
-
 static bool is_dir(const char* pathname) {
   struct stat info;
   if (stat(pathname, &info) == -1) {
@@ -274,71 +58,62 @@
   return S_ISDIR(info.st_mode);
 }
 
-__BIONIC_WEAK_FOR_NATIVE_BRIDGE
-int __system_properties_init() {
+bool SystemProperties::Init(const char* filename) {
   // This is called from __libc_init_common, and should leave errno at 0 (http://b/37248982).
   ErrnoRestorer errno_restorer;
 
-  if (contexts != nullptr) {
-    contexts->ResetAccess();
-    return 0;
+  if (initialized_) {
+    contexts()->ResetAccess();
+    return true;
   }
-  contexts = nullptr;
-  if (is_dir(property_filename)) {
+
+  if (strlen(filename) > PROP_FILENAME_MAX) {
+    return false;
+  }
+  strcpy(property_filename_, filename);
+
+  if (is_dir(property_filename_)) {
     if (access("/dev/__properties__/property_info", R_OK) == 0) {
-      new (&contexts_union.contexts_serialized) ContextsSerialized();
-      if (!contexts_union.contexts_serialized.Initialize(false)) {
-        return -1;
+      new (&contexts_union_.contexts_serialized) ContextsSerialized();
+      if (!contexts_union_.contexts_serialized.Initialize(false, property_filename_, nullptr)) {
+        return false;
       }
-      contexts = &contexts_union.contexts_serialized;
     } else {
-      new (&contexts_union.contexts_split) ContextsSplit();
-      if (!contexts_union.contexts_split.Initialize(false)) {
-        return -1;
+      new (&contexts_union_.contexts_split) ContextsSplit();
+      if (!contexts_union_.contexts_split.Initialize(false, property_filename_, nullptr)) {
+        return false;
       }
-      contexts = &contexts_union.contexts_split;
     }
   } else {
-    new (&contexts_union.contexts_pre_split) ContextsPreSplit();
-    if (!contexts_union.contexts_pre_split.Initialize(false)) {
-      return -1;
+    new (&contexts_union_.contexts_pre_split) ContextsPreSplit();
+    if (!contexts_union_.contexts_pre_split.Initialize(false, property_filename_, nullptr)) {
+      return false;
     }
-    contexts = &contexts_union.contexts_pre_split;
   }
-  return 0;
+  initialized_ = true;
+  return true;
 }
 
-__BIONIC_WEAK_FOR_NATIVE_BRIDGE
-int __system_property_set_filename(const char* filename) {
-  size_t len = strlen(filename);
-  if (len >= sizeof(property_filename)) return -1;
+bool SystemProperties::AreaInit(const char* filename, bool* fsetxattr_failed) {
+  if (strlen(filename) > PROP_FILENAME_MAX) {
+    return false;
+  }
+  strcpy(property_filename_, filename);
 
-  strcpy(property_filename, filename);
-  return 0;
+  new (&contexts_union_.contexts_serialized) ContextsSerialized();
+  if (!contexts_union_.contexts_serialized.Initialize(true, property_filename_, fsetxattr_failed)) {
+    return false;
+  }
+  initialized_ = true;
+  return true;
 }
 
-__BIONIC_WEAK_FOR_NATIVE_BRIDGE
-int __system_property_area_init() {
-  if (contexts != nullptr) {
-    contexts->FreeAndUnmap();
-  }
-  // We set this unconditionally as we want tests to continue on regardless of if this failed
-  // and property_service will abort on an error condition, so no harm done.
-  new (&contexts_union.contexts_serialized) ContextsSerialized;
-  contexts = &contexts_union.contexts_serialized;
-  if (!contexts_union.contexts_serialized.Initialize(true)) {
-    return -1;
-  }
-  return 0;
-}
-
-__BIONIC_WEAK_FOR_NATIVE_BRIDGE
-uint32_t __system_property_area_serial() {
-  if (contexts == nullptr) {
+uint32_t SystemProperties::AreaSerial() {
+  if (!initialized_) {
     return -1;
   }
 
-  prop_area* pa = contexts->GetSerialPropArea();
+  prop_area* pa = contexts()->GetSerialPropArea();
   if (!pa) {
     return -1;
   }
@@ -347,13 +122,12 @@
   return atomic_load_explicit(pa->serial(), memory_order_acquire);
 }
 
-__BIONIC_WEAK_FOR_NATIVE_BRIDGE
-const prop_info* __system_property_find(const char* name) {
-  if (contexts == nullptr) {
+const prop_info* SystemProperties::Find(const char* name) {
+  if (!initialized_) {
     return nullptr;
   }
 
-  prop_area* pa = contexts->GetPropAreaForName(name);
+  prop_area* pa = contexts()->GetPropAreaForName(name);
   if (!pa) {
     async_safe_format_log(ANDROID_LOG_ERROR, "libc", "Access denied finding property \"%s\"", name);
     return nullptr;
@@ -366,10 +140,9 @@
   return strncmp(name, "ro.", 3) == 0;
 }
 
-__BIONIC_WEAK_FOR_NATIVE_BRIDGE
-int __system_property_read(const prop_info* pi, char* name, char* value) {
+int SystemProperties::Read(const prop_info* pi, char* name, char* value) {
   while (true) {
-    uint32_t serial = __system_property_serial(pi);  // acquire semantics
+    uint32_t serial = Serial(pi);  // acquire semantics
     size_t len = SERIAL_VALUE_LEN(serial);
     memcpy(value, pi->value, len + 1);
     // TODO: Fix the synchronization scheme here.
@@ -405,15 +178,14 @@
   }
 }
 
-__BIONIC_WEAK_FOR_NATIVE_BRIDGE
-void __system_property_read_callback(const prop_info* pi,
-                                     void (*callback)(void* cookie, const char* name,
-                                                      const char* value, uint32_t serial),
-                                     void* cookie) {
+void SystemProperties::ReadCallback(const prop_info* pi,
+                                    void (*callback)(void* cookie, const char* name,
+                                                     const char* value, uint32_t serial),
+                                    void* cookie) {
   // Read only properties don't need to copy the value to a temporary buffer, since it can never
   // change.
   if (is_read_only(pi->name)) {
-    uint32_t serial = __system_property_serial(pi);
+    uint32_t serial = Serial(pi);
     if (pi->is_long()) {
       callback(cookie, pi->name, pi->long_value(), serial);
     } else {
@@ -423,14 +195,14 @@
   }
 
   while (true) {
-    uint32_t serial = __system_property_serial(pi);  // acquire semantics
+    uint32_t serial = Serial(pi);  // acquire semantics
     size_t len = SERIAL_VALUE_LEN(serial);
     char value_buf[len + 1];
 
     memcpy(value_buf, pi->value, len);
     value_buf[len] = '\0';
 
-    // TODO: see todo in __system_property_read function
+    // TODO: see todo in Read function
     atomic_thread_fence(memory_order_acquire);
     if (serial == load_const_atomic(&(pi->serial), memory_order_relaxed)) {
       callback(cookie, pi->name, value_buf, serial);
@@ -439,118 +211,27 @@
   }
 }
 
-__BIONIC_WEAK_FOR_NATIVE_BRIDGE
-int __system_property_get(const char* name, char* value) {
-  const prop_info* pi = __system_property_find(name);
+int SystemProperties::Get(const char* name, char* value) {
+  const prop_info* pi = Find(name);
 
   if (pi != 0) {
-    return __system_property_read(pi, nullptr, value);
+    return Read(pi, nullptr, value);
   } else {
     value[0] = 0;
     return 0;
   }
 }
 
-static constexpr uint32_t kProtocolVersion1 = 1;
-static constexpr uint32_t kProtocolVersion2 = 2;  // current
-
-static atomic_uint_least32_t g_propservice_protocol_version = 0;
-
-static void detect_protocol_version() {
-  char value[PROP_VALUE_MAX];
-  if (__system_property_get(kServiceVersionPropertyName, value) == 0) {
-    g_propservice_protocol_version = kProtocolVersion1;
-    async_safe_format_log(ANDROID_LOG_WARN, "libc",
-                          "Using old property service protocol (\"%s\" is not set)",
-                          kServiceVersionPropertyName);
-  } else {
-    uint32_t version = static_cast<uint32_t>(atoll(value));
-    if (version >= kProtocolVersion2) {
-      g_propservice_protocol_version = kProtocolVersion2;
-    } else {
-      async_safe_format_log(ANDROID_LOG_WARN, "libc",
-                            "Using old property service protocol (\"%s\"=\"%s\")",
-                            kServiceVersionPropertyName, value);
-      g_propservice_protocol_version = kProtocolVersion1;
-    }
-  }
-}
-
-__BIONIC_WEAK_FOR_NATIVE_BRIDGE
-int __system_property_set(const char* key, const char* value) {
-  if (key == nullptr) return -1;
-  if (value == nullptr) value = "";
-
-  if (g_propservice_protocol_version == 0) {
-    detect_protocol_version();
-  }
-
-  if (g_propservice_protocol_version == kProtocolVersion1) {
-    // Old protocol does not support long names or values
-    if (strlen(key) >= PROP_NAME_MAX) return -1;
-    if (strlen(value) >= PROP_VALUE_MAX) return -1;
-
-    prop_msg msg;
-    memset(&msg, 0, sizeof msg);
-    msg.cmd = PROP_MSG_SETPROP;
-    strlcpy(msg.name, key, sizeof msg.name);
-    strlcpy(msg.value, value, sizeof msg.value);
-
-    return send_prop_msg(&msg);
-  } else {
-    // New protocol only allows long values for ro. properties only.
-    if (strlen(value) >= PROP_VALUE_MAX && !is_read_only(key)) return -1;
-    // Use proper protocol
-    PropertyServiceConnection connection;
-    if (!connection.IsValid()) {
-      errno = connection.GetLastError();
-      async_safe_format_log(
-          ANDROID_LOG_WARN, "libc",
-          "Unable to set property \"%s\" to \"%s\": connection failed; errno=%d (%s)", key, value,
-          errno, strerror(errno));
-      return -1;
-    }
-
-    SocketWriter writer(&connection);
-    if (!writer.WriteUint32(PROP_MSG_SETPROP2).WriteString(key).WriteString(value).Send()) {
-      errno = connection.GetLastError();
-      async_safe_format_log(ANDROID_LOG_WARN, "libc",
-                            "Unable to set property \"%s\" to \"%s\": write failed; errno=%d (%s)",
-                            key, value, errno, strerror(errno));
-      return -1;
-    }
-
-    int result = -1;
-    if (!connection.RecvInt32(&result)) {
-      errno = connection.GetLastError();
-      async_safe_format_log(ANDROID_LOG_WARN, "libc",
-                            "Unable to set property \"%s\" to \"%s\": recv failed; errno=%d (%s)",
-                            key, value, errno, strerror(errno));
-      return -1;
-    }
-
-    if (result != PROP_SUCCESS) {
-      async_safe_format_log(ANDROID_LOG_WARN, "libc",
-                            "Unable to set property \"%s\" to \"%s\": error code: 0x%x", key, value,
-                            result);
-      return -1;
-    }
-
-    return 0;
-  }
-}
-
-__BIONIC_WEAK_FOR_NATIVE_BRIDGE
-int __system_property_update(prop_info* pi, const char* value, unsigned int len) {
+int SystemProperties::Update(prop_info* pi, const char* value, unsigned int len) {
   if (len >= PROP_VALUE_MAX) {
     return -1;
   }
 
-  if (contexts == nullptr) {
+  if (!initialized_) {
     return -1;
   }
 
-  prop_area* pa = contexts->GetSerialPropArea();
+  prop_area* pa = contexts()->GetSerialPropArea();
   if (!pa) {
     return -1;
   }
@@ -574,8 +255,7 @@
   return 0;
 }
 
-__BIONIC_WEAK_FOR_NATIVE_BRIDGE
-int __system_property_add(const char* name, unsigned int namelen, const char* value,
+int SystemProperties::Add(const char* name, unsigned int namelen, const char* value,
                           unsigned int valuelen) {
   if (valuelen >= PROP_VALUE_MAX && !is_read_only(name)) {
     return -1;
@@ -585,16 +265,16 @@
     return -1;
   }
 
-  if (contexts == nullptr) {
+  if (!initialized_) {
     return -1;
   }
 
-  prop_area* serial_pa = contexts->GetSerialPropArea();
+  prop_area* serial_pa = contexts()->GetSerialPropArea();
   if (serial_pa == nullptr) {
     return -1;
   }
 
-  prop_area* pa = contexts->GetPropAreaForName(name);
+  prop_area* pa = contexts()->GetPropAreaForName(name);
   if (!pa) {
     async_safe_format_log(ANDROID_LOG_ERROR, "libc", "Access denied adding property \"%s\"", name);
     return -1;
@@ -615,8 +295,7 @@
 }
 
 // Wait for non-locked serial, and retrieve it with acquire semantics.
-__BIONIC_WEAK_FOR_NATIVE_BRIDGE
-uint32_t __system_property_serial(const prop_info* pi) {
+uint32_t SystemProperties::Serial(const prop_info* pi) {
   uint32_t serial = load_const_atomic(&pi->serial, memory_order_acquire);
   while (SERIAL_DIRTY(serial)) {
     __futex_wait(const_cast<_Atomic(uint_least32_t)*>(&pi->serial), serial, nullptr);
@@ -625,24 +304,22 @@
   return serial;
 }
 
-__BIONIC_WEAK_FOR_NATIVE_BRIDGE
-uint32_t __system_property_wait_any(uint32_t old_serial) {
+uint32_t SystemProperties::WaitAny(uint32_t old_serial) {
   uint32_t new_serial;
-  __system_property_wait(nullptr, old_serial, &new_serial, nullptr);
+  Wait(nullptr, old_serial, &new_serial, nullptr);
   return new_serial;
 }
 
-__BIONIC_WEAK_FOR_NATIVE_BRIDGE
-bool __system_property_wait(const prop_info* pi, uint32_t old_serial, uint32_t* new_serial_ptr,
+bool SystemProperties::Wait(const prop_info* pi, uint32_t old_serial, uint32_t* new_serial_ptr,
                             const timespec* relative_timeout) {
   // Are we waiting on the global serial or a specific serial?
   atomic_uint_least32_t* serial_ptr;
   if (pi == nullptr) {
-    if (contexts == nullptr) {
+    if (!initialized_) {
       return -1;
     }
 
-    prop_area* serial_pa = contexts->GetSerialPropArea();
+    prop_area* serial_pa = contexts()->GetSerialPropArea();
     if (serial_pa == nullptr) {
       return -1;
     }
@@ -665,8 +342,7 @@
   return true;
 }
 
-__BIONIC_WEAK_FOR_NATIVE_BRIDGE
-const prop_info* __system_property_find_nth(unsigned n) {
+const prop_info* SystemProperties::FindNth(unsigned n) {
   struct find_nth {
     const uint32_t sought;
     uint32_t current;
@@ -679,17 +355,16 @@
       if (self->current++ == self->sought) self->result = pi;
     }
   } state(n);
-  __system_property_foreach(find_nth::fn, &state);
+  Foreach(find_nth::fn, &state);
   return state.result;
 }
 
-__BIONIC_WEAK_FOR_NATIVE_BRIDGE
-int __system_property_foreach(void (*propfn)(const prop_info* pi, void* cookie), void* cookie) {
-  if (contexts == nullptr) {
+int SystemProperties::Foreach(void (*propfn)(const prop_info* pi, void* cookie), void* cookie) {
+  if (!initialized_) {
     return -1;
   }
 
-  contexts->ForEach(propfn, cookie);
+  contexts()->ForEach(propfn, cookie);
 
   return 0;
 }