diff --git a/Android.bp b/Android.bp
index 9fed081..a9ee724 100644
--- a/Android.bp
+++ b/Android.bp
@@ -110,3 +110,132 @@
     host_supported: true,
     defaults: ["cuttlefish_base"],
 }
+
+cc_library_shared {
+    name: "vsoc_lib",
+    srcs: [
+        "common/vsoc/lib/compat.cpp",
+        "common/vsoc/lib/audio_data_layout.cpp",
+        "common/vsoc/lib/e2e_test_region_layout.cpp",
+        "common/vsoc/lib/gralloc_layout.cpp",
+        "common/vsoc/lib/input_events_layout.cpp",
+        "common/vsoc/lib/input_events_region_view.cpp",
+        "common/vsoc/lib/lock_common.cpp",
+        "common/vsoc/lib/managed_e2e_test_region_layout.cpp",
+        "common/vsoc/lib/region_view.cpp",
+        "common/vsoc/lib/screen_layout.cpp",
+        "common/vsoc/lib/screen_region_view.cpp",
+        "common/vsoc/lib/socket_forward_layout.cpp",
+        "common/vsoc/lib/socket_forward_region_view.cpp",
+        "common/vsoc/lib/vsoc_memory.cpp",
+    ],
+    header_libs: ["cuttlefish_glog"],
+    shared_libs: [
+        "libcuttlefish_fs",
+        "cuttlefish_auto_resources",
+        "libbase",
+        "liblog",
+    ],
+    target: {
+        host: {
+            srcs: [
+                "host/vsoc/lib/gralloc_buffer_region_view.cpp",
+                "host/vsoc/lib/host_lock.cpp",
+                "host/vsoc/lib/region_control.cpp",
+                "host/vsoc/lib/region_view.cpp",
+            ],
+        },
+        android: {
+            srcs: [
+                "guest/vsoc/lib/gralloc_region_view.cpp",
+                "guest/vsoc/lib/guest_lock.cpp",
+                "guest/vsoc/lib/region_control.cpp",
+                "guest/vsoc/lib/region_view.cpp",
+            ],
+        },
+    },
+    defaults: ["cuttlefish_host_and_guest"],
+}
+
+cc_test_host {
+    name: "circqueue_test",
+    srcs: [
+        "common/vsoc/lib/circqueue_test.cpp",
+    ],
+    shared_libs: [
+        "vsoc_lib",
+        "libbase",
+    ],
+    defaults: ["cuttlefish_host_only"],
+    test_suites: ["general-tests"],
+}
+
+cc_binary_host {
+    name: "vsoc_screen_region_view_test",
+    srcs: [
+        "common/vsoc/lib/screen_region_view_test.cpp",
+    ],
+    static_libs: [
+        "libcuttlefish_host_config",
+        "libjsoncpp",
+        "libgflags",
+    ],
+    shared_libs: [
+        "vsoc_lib",
+        "libbase",
+        "libcuttlefish_utils",
+    ],
+    defaults: ["cuttlefish_host_only"],
+}
+
+cc_test_host {
+    name: "lock_test",
+    srcs: [
+        "common/vsoc/lib/lock_test.cpp",
+    ],
+    shared_libs: [
+        "vsoc_lib",
+        "libcuttlefish_fs",
+        "cuttlefish_auto_resources",
+        "libbase",
+    ],
+    static_libs: [
+        "libgtest_host",
+    ],
+    defaults: ["cuttlefish_host_only"],
+    test_suites: ["general-tests"],
+}
+
+cc_test_host {
+    name: "vsoc_graphics_test",
+    srcs: [
+        "common/vsoc/lib/graphics_test.cpp",
+    ],
+    shared_libs: [
+        "vsoc_lib",
+        "libbase",
+    ],
+    defaults: ["cuttlefish_host_only"],
+    test_suites: ["general-tests"],
+}
+
+cc_binary_host {
+    name: "host_region_e2e_test",
+    srcs: [
+        "host/vsoc/lib/host_region_e2e_test.cpp",
+    ],
+    shared_libs: [
+        "vsoc_lib",
+        "libcuttlefish_fs",
+        "libcuttlefish_utils",
+        "cuttlefish_auto_resources",
+        "libbase",
+    ],
+    static_libs: [
+        "libcuttlefish_host_config",
+        "libjsoncpp",
+        "libgtest_host",
+        "libgflags",
+    ],
+    defaults: ["cuttlefish_host_only"],
+}
diff --git a/common/frontend/Android.bp b/common/frontend/Android.bp
index 39a4dbb..a7a4de5 100644
--- a/common/frontend/Android.bp
+++ b/common/frontend/Android.bp
@@ -14,5 +14,6 @@
 // limitations under the License.
 
 subdirs = [
+    "socket_forward_proxy",
     "socket_vsock_proxy",
 ]
diff --git a/common/frontend/socket_forward_proxy/Android.bp b/common/frontend/socket_forward_proxy/Android.bp
new file mode 100644
index 0000000..74ef53a
--- /dev/null
+++ b/common/frontend/socket_forward_proxy/Android.bp
@@ -0,0 +1,45 @@
+//
+// Copyright (C) 2018 The Android Open Source Project
+//
+// 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.
+
+cc_binary {
+    name: "socket_forward_proxy",
+    srcs: [
+        "main.cpp",
+    ],
+    shared_libs: [
+        "libbase",
+        "libcuttlefish_fs",
+        "libcuttlefish_utils",
+        "libcuttlefish_strings",
+        "cuttlefish_auto_resources",
+        "vsoc_lib",
+        "liblog",
+    ],
+    static_libs: [
+        "libgflags",
+    ],
+    header_libs: [
+        "cuttlefish_glog",
+    ],
+    target: {
+        host: {
+            static_libs: [
+                "libcuttlefish_host_config",
+                "libjsoncpp",
+            ],
+        },
+    },
+    defaults: ["cuttlefish_host_and_guest"]
+}
diff --git a/common/frontend/socket_forward_proxy/main.cpp b/common/frontend/socket_forward_proxy/main.cpp
new file mode 100644
index 0000000..4c21459
--- /dev/null
+++ b/common/frontend/socket_forward_proxy/main.cpp
@@ -0,0 +1,374 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <array>
+#include <cstdint>
+#include <cstdlib>
+#include <iostream>
+#include <limits>
+#include <memory>
+#include <mutex>
+#include <sstream>
+#include <string>
+#include <thread>
+#include <vector>
+#include <glog/logging.h>
+#include <gflags/gflags.h>
+
+#include <unistd.h>
+
+#include "common/libs/fs/shared_fd.h"
+#include "common/libs/strings/str_split.h"
+#include "common/vsoc/lib/socket_forward_region_view.h"
+
+#ifdef CUTTLEFISH_HOST
+#include "host/libs/config/cuttlefish_config.h"
+#endif
+
+using vsoc::socket_forward::Packet;
+using vsoc::socket_forward::SocketForwardRegionView;
+
+#ifdef CUTTLEFISH_HOST
+DEFINE_string(guest_ports, "",
+              "Comma-separated list of ports on which to forward TCP "
+              "connections to the guest.");
+DEFINE_string(host_ports, "",
+              "Comma-separated list of ports on which to run TCP servers on "
+              "the host.");
+#endif
+
+namespace {
+// Sends packets, Shutdown(SHUT_WR) on destruction
+class SocketSender {
+ public:
+  explicit SocketSender(cvd::SharedFD socket) : socket_{std::move(socket)} {}
+
+  SocketSender(SocketSender&&) = default;
+  SocketSender& operator=(SocketSender&&) = default;
+
+  SocketSender(const SocketSender&&) = delete;
+  SocketSender& operator=(const SocketSender&) = delete;
+
+  ~SocketSender() {
+    if (socket_.operator->()) {  // check that socket_ was not moved-from
+      socket_->Shutdown(SHUT_WR);
+    }
+  }
+
+  ssize_t SendAll(const Packet& packet) {
+    ssize_t written{};
+    while (written < static_cast<ssize_t>(packet.payload_length())) {
+      if (!socket_->IsOpen()) {
+        return -1;
+      }
+      auto just_written =
+          socket_->Send(packet.payload() + written,
+                        packet.payload_length() - written, MSG_NOSIGNAL);
+      if (just_written <= 0) {
+        LOG(INFO) << "Couldn't write to client: "
+                  << strerror(socket_->GetErrno());
+        return just_written;
+      }
+      written += just_written;
+    }
+    return written;
+  }
+
+ private:
+  cvd::SharedFD socket_;
+};
+
+class SocketReceiver {
+ public:
+  explicit SocketReceiver(cvd::SharedFD socket) : socket_{std::move(socket)} {}
+
+  SocketReceiver(SocketReceiver&&) = default;
+  SocketReceiver& operator=(SocketReceiver&&) = default;
+
+  SocketReceiver(const SocketReceiver&&) = delete;
+  SocketReceiver& operator=(const SocketReceiver&) = delete;
+
+  // *packet will be empty if Read returns 0 or error
+  void Recv(Packet* packet) {
+    auto size = socket_->Read(packet->payload(), sizeof packet->payload());
+    if (size < 0) {
+      size = 0;
+    }
+    packet->set_payload_length(size);
+  }
+
+ private:
+  cvd::SharedFD socket_;
+};
+
+void SocketToShm(SocketReceiver socket_receiver,
+                 SocketForwardRegionView::ShmSender shm_sender) {
+  while (true) {
+    auto packet = Packet::MakeData();
+    socket_receiver.Recv(&packet);
+    if (packet.empty() || !shm_sender.Send(packet)) {
+      break;
+    }
+  }
+  LOG(INFO) << "Socket to shm exiting";
+}
+
+void ShmToSocket(SocketSender socket_sender,
+                 SocketForwardRegionView::ShmReceiver shm_receiver) {
+  auto packet = Packet{};
+  while (true) {
+    shm_receiver.Recv(&packet);
+    CHECK(packet.IsData());
+    if (packet.empty()) {
+      break;
+    }
+    if (socket_sender.SendAll(packet) < 0) {
+      break;
+    }
+  }
+  LOG(INFO) << "Shm to socket exiting";
+}
+
+// One thread for reading from shm and writing into a socket.
+// One thread for reading from a socket and writing into shm.
+void HandleConnection(SocketForwardRegionView::ShmSenderReceiverPair shm_sender_and_receiver,
+                      cvd::SharedFD socket) {
+  auto socket_to_shm =
+      std::thread(SocketToShm, SocketReceiver{socket}, std::move(shm_sender_and_receiver.first));
+  ShmToSocket(SocketSender{socket}, std::move(shm_sender_and_receiver.second));
+  socket_to_shm.join();
+}
+
+#ifdef CUTTLEFISH_HOST
+struct PortPair {
+  int guest_port;
+  int host_port;
+};
+
+enum class QueueState {
+  kFree,
+  kUsed,
+};
+
+struct SocketConnectionInfo {
+  std::mutex lock{};
+  std::condition_variable cv{};
+  cvd::SharedFD socket{};
+  int guest_port{};
+  QueueState state = QueueState::kFree;
+};
+
+static constexpr auto kNumHostThreads =
+    vsoc::layout::socket_forward::kNumQueues;
+
+using SocketConnectionInfoCollection =
+    std::array<SocketConnectionInfo, kNumHostThreads>;
+
+void MarkAsFree(SocketConnectionInfo* conn) {
+  std::lock_guard<std::mutex> guard{conn->lock};
+  conn->socket = cvd::SharedFD{};
+  conn->guest_port = 0;
+  conn->state = QueueState::kFree;
+}
+
+std::pair<int, cvd::SharedFD> WaitForConnection(SocketConnectionInfo* conn) {
+  std::unique_lock<std::mutex> guard{conn->lock};
+  while (conn->state != QueueState::kUsed) {
+    conn->cv.wait(guard);
+  }
+  return {conn->guest_port, conn->socket};
+}
+
+[[noreturn]] void host_thread(SocketForwardRegionView::ShmConnectionView view,
+                              SocketConnectionInfo* conn) {
+  while (true) {
+    int guest_port{};
+    cvd::SharedFD socket{};
+    // TODO structured binding in C++17
+    std::tie(guest_port, socket) = WaitForConnection(conn);
+
+    LOG(INFO) << "Establishing connection to guest port " << guest_port
+              << " with connection_id: " << view.connection_id();
+    HandleConnection(view.EstablishConnection(guest_port), std::move(socket));
+    LOG(INFO) << "Connection to guest port " << guest_port
+              << " closed. Marking queue " << view.connection_id()
+              << " as free.";
+    MarkAsFree(conn);
+  }
+}
+
+bool TryAllocateConnection(SocketConnectionInfo* conn, int guest_port,
+                           cvd::SharedFD socket) {
+  bool success = false;
+  {
+    std::lock_guard<std::mutex> guard{conn->lock};
+    if (conn->state == QueueState::kFree) {
+      conn->socket = std::move(socket);
+      conn->guest_port = guest_port;
+      conn->state = QueueState::kUsed;
+      success = true;
+    }
+  }
+  if (success) {
+    conn->cv.notify_one();
+  }
+  return success;
+}
+
+void AllocateWorkers(cvd::SharedFD socket,
+                     SocketConnectionInfoCollection* socket_connection_info,
+                     int guest_port) {
+  while (true) {
+    for (auto& conn : *socket_connection_info) {
+      if (TryAllocateConnection(&conn, guest_port, socket)) {
+        return;
+      }
+    }
+    LOG(INFO) << "no queues available. sleeping and retrying";
+    sleep(5);
+  }
+}
+
+[[noreturn]] void host_impl(
+    SocketForwardRegionView* shm,
+    SocketConnectionInfoCollection* socket_connection_info,
+    std::vector<PortPair> ports, std::size_t index) {
+  // launch a worker for the following port before handling the current port.
+  // recursion (instead of a loop) removes the need fore any join() or having
+  // the main thread do no work.
+  if (index + 1 < ports.size()) {
+    std::thread(host_impl, shm, socket_connection_info, ports, index + 1)
+        .detach();
+  }
+  auto guest_port = ports[index].guest_port;
+  auto host_port = ports[index].host_port;
+  LOG(INFO) << "starting server on " << host_port << " for guest port "
+            << guest_port;
+  auto server = cvd::SharedFD::SocketLocalServer(host_port, SOCK_STREAM);
+  CHECK(server->IsOpen()) << "Could not start server on port " << host_port;
+  while (true) {
+    LOG(INFO) << "waiting for client connection";
+    auto client_socket = cvd::SharedFD::Accept(*server);
+    CHECK(client_socket->IsOpen()) << "error creating client socket";
+    LOG(INFO) << "client socket accepted";
+    AllocateWorkers(std::move(client_socket), socket_connection_info,
+                    guest_port);
+  }
+}
+
+[[noreturn]] void host(SocketForwardRegionView* shm,
+                       std::vector<PortPair> ports) {
+  CHECK(!ports.empty());
+
+  SocketConnectionInfoCollection socket_connection_info{};
+
+  auto conn_info_iter = std::begin(socket_connection_info);
+  for (auto& shm_connection_view : shm->AllConnections()) {
+    CHECK_NE(conn_info_iter, std::end(socket_connection_info));
+    std::thread(host_thread, std::move(shm_connection_view), &*conn_info_iter)
+        .detach();
+    ++conn_info_iter;
+  }
+  CHECK_EQ(conn_info_iter, std::end(socket_connection_info));
+  host_impl(shm, &socket_connection_info, ports, 0);
+}
+
+std::vector<PortPair> ParsePortsList(const std::string& guest_ports_str,
+                                     const std::string& host_ports_str) {
+  std::vector<PortPair> ports{};
+  auto guest_ports = cvd::StrSplit(guest_ports_str, ',');
+  auto host_ports = cvd::StrSplit(host_ports_str, ',');
+  CHECK(guest_ports.size() == host_ports.size());
+  for (std::size_t i = 0; i < guest_ports.size(); ++i) {
+    ports.push_back({std::stoi(guest_ports[i]), std::stoi(host_ports[i])});
+  }
+  return ports;
+}
+
+#else
+cvd::SharedFD OpenSocketConnection(int port) {
+  while (true) {
+    auto sock = cvd::SharedFD::SocketLocalClient(port, SOCK_STREAM);
+    if (sock->IsOpen()) {
+      return sock;
+    }
+    LOG(WARNING) << "could not connect on port " << port
+                 << ". sleeping for 1 second";
+    sleep(1);
+  }
+}
+
+[[noreturn]] void guest_thread(
+    SocketForwardRegionView::ShmConnectionView view) {
+  while (true) {
+    LOG(INFO) << "waiting for new connection";
+    auto shm_sender_and_receiver = view.WaitForNewConnection();
+    LOG(INFO) << "new connection for port " << view.port();
+    HandleConnection(std::move(shm_sender_and_receiver), OpenSocketConnection(view.port()));
+    LOG(INFO) << "connection closed on port " << view.port();
+  }
+}
+
+[[noreturn]] void guest(SocketForwardRegionView* shm) {
+  LOG(INFO) << "Starting guest mainloop";
+  auto connection_views = shm->AllConnections();
+  for (auto&& shm_connection_view : connection_views) {
+    std::thread(guest_thread, std::move(shm_connection_view)).detach();
+  }
+  while (true) {
+    sleep(std::numeric_limits<unsigned int>::max());
+  }
+}
+
+#endif
+
+SocketForwardRegionView* GetShm() {
+  auto shm = SocketForwardRegionView::GetInstance(
+#ifdef CUTTLEFISH_HOST
+      vsoc::GetDomain().c_str()
+#endif
+  );
+  if (!shm) {
+    LOG(FATAL) << "Could not open SHM. Aborting.";
+  }
+  shm->CleanUpPreviousConnections();
+  return shm;
+}
+
+// makes sure we're running as root on the guest, no-op on the host
+void assert_correct_user() {
+#ifndef CUTTLEFISH_HOST
+  CHECK_EQ(getuid(), 0u) << "must run as root!";
+#endif
+}
+
+}  // namespace
+
+int main(int argc, char* argv[]) {
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+  assert_correct_user();
+
+  auto shm = GetShm();
+  auto worker = shm->StartWorker();
+
+#ifdef CUTTLEFISH_HOST
+  CHECK(!FLAGS_guest_ports.empty()) << "Must specify --guest_ports flag";
+  CHECK(!FLAGS_host_ports.empty()) << "Must specify --host_ports flag";
+  host(shm, ParsePortsList(FLAGS_guest_ports, FLAGS_host_ports));
+#else
+  guest(shm);
+#endif
+}
diff --git a/common/frontend/socket_vsock_proxy/main.cpp b/common/frontend/socket_vsock_proxy/main.cpp
index 31cff0b..ac421a3 100644
--- a/common/frontend/socket_vsock_proxy/main.cpp
+++ b/common/frontend/socket_vsock_proxy/main.cpp
@@ -20,103 +20,13 @@
 #include <gflags/gflags.h>
 
 #include "common/libs/fs/shared_fd.h"
+#include "common/vsoc/lib/socket_forward_region_view.h"
 
 #ifdef CUTTLEFISH_HOST
 #include "host/libs/config/cuttlefish_config.h"
 #endif
 
-struct Header {
-  std::uint32_t payload_length;
-  enum MessageType : std::uint32_t {
-    DATA = 0,
-    BEGIN,
-    END,
-    RECV_CLOSED,  // indicate that this side's receive end is closed
-    RESTART,
-  };
-  MessageType message_type;
-};
-
-constexpr std::size_t kMaxPacketSize = 8192;
-constexpr std::size_t kMaxPayloadSize = kMaxPacketSize - sizeof(Header);
-
-struct Packet {
- private:
-  Header header_;
-  using Payload = char[kMaxPayloadSize];
-  Payload payload_data_;
-
-  static constexpr Packet MakePacket(Header::MessageType type) {
-    Packet packet{};
-    packet.header_.message_type = type;
-    return packet;
-  }
-
- public:
-  // port is only revelant on the host-side.
-  static Packet MakeBegin(std::uint16_t port);
-
-  static constexpr Packet MakeEnd() { return MakePacket(Header::END); }
-
-  static constexpr Packet MakeRecvClosed() {
-    return MakePacket(Header::RECV_CLOSED);
-  }
-
-  static constexpr Packet MakeRestart() { return MakePacket(Header::RESTART); }
-
-  // NOTE payload and payload_length must still be set.
-  static constexpr Packet MakeData() { return MakePacket(Header::DATA); }
-
-  bool empty() const { return IsData() && header_.payload_length == 0; }
-
-  void set_payload_length(std::uint32_t length) {
-    CHECK_LE(length, sizeof payload_data_);
-    header_.payload_length = length;
-  }
-
-  Payload& payload() { return payload_data_; }
-
-  const Payload& payload() const { return payload_data_; }
-
-  constexpr std::uint32_t payload_length() const {
-    return header_.payload_length;
-  }
-
-  constexpr bool IsBegin() const {
-    return header_.message_type == Header::BEGIN;
-  }
-
-  constexpr bool IsEnd() const { return header_.message_type == Header::END; }
-
-  constexpr bool IsData() const { return header_.message_type == Header::DATA; }
-
-  constexpr bool IsRecvClosed() const {
-    return header_.message_type == Header::RECV_CLOSED;
-  }
-
-  constexpr bool IsRestart() const {
-    return header_.message_type == Header::RESTART;
-  }
-
-  constexpr std::uint16_t port() const {
-    CHECK(IsBegin());
-    std::uint16_t port_number{};
-    CHECK_EQ(payload_length(), sizeof port_number);
-    std::memcpy(&port_number, payload(), sizeof port_number);
-    return port_number;
-  }
-
-  char* raw_data() { return reinterpret_cast<char*>(this); }
-
-  const char* raw_data() const { return reinterpret_cast<const char*>(this); }
-
-  constexpr size_t raw_data_length() const {
-    return payload_length() + sizeof header_;
-  }
-};
-
-static_assert(sizeof(Packet) == kMaxPacketSize, "");
-static_assert(std::is_pod<Packet>{}, "");
+using vsoc::socket_forward::Packet;
 
 DEFINE_uint32(tcp_port, 0, "TCP port (server on host, client on guest)");
 DEFINE_uint32(vsock_port, 0, "vsock port (client on host, server on guest");
diff --git a/common/vsoc/lib/audio_data_layout.cpp b/common/vsoc/lib/audio_data_layout.cpp
new file mode 100644
index 0000000..4b5172c
--- /dev/null
+++ b/common/vsoc/lib/audio_data_layout.cpp
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * 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.
+ */
+
+// Define some of the string constants associated with the region layout.
+#include "common/vsoc/shm/audio_data_layout.h"
+
+namespace vsoc {
+namespace layout {
+namespace audio_data {
+
+// static
+const char *const AudioDataLayout::region_name = "audio_data";
+
+}  // namespace audio_data
+}  // namespace layout
+}  // namespace vsoc
+
diff --git a/common/vsoc/lib/audio_data_region_view.h b/common/vsoc/lib/audio_data_region_view.h
new file mode 100644
index 0000000..42d05df
--- /dev/null
+++ b/common/vsoc/lib/audio_data_region_view.h
@@ -0,0 +1,39 @@
+#pragma once
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <memory>
+
+#include <android-base/macros.h>
+
+#include "common/vsoc/lib/typed_region_view.h"
+#include "common/vsoc/shm/audio_data_layout.h"
+
+namespace vsoc {
+namespace audio_data {
+
+class AudioDataRegionView
+    : public vsoc::TypedRegionView<
+        AudioDataRegionView,
+        vsoc::layout::audio_data::AudioDataLayout> {
+public:
+    AudioDataRegionView() = default;
+    AudioDataRegionView(const AudioDataRegionView &) = delete;
+    AudioDataRegionView &operator=(const AudioDataRegionView &) = delete;
+};
+
+}  // namespace audio_data
+}  // namespace vsoc
diff --git a/common/vsoc/lib/circqueue_impl.h b/common/vsoc/lib/circqueue_impl.h
new file mode 100644
index 0000000..8b0fa90
--- /dev/null
+++ b/common/vsoc/lib/circqueue_impl.h
@@ -0,0 +1,234 @@
+#pragma once
+
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <cerrno>
+#include <cstring>
+
+#include <sys/uio.h>
+
+#include "common/vsoc/lib/region_signaling_interface.h"
+#include "common/vsoc/shm/circqueue.h"
+
+// Increases the given index until it is naturally aligned for T.
+template <typename T>
+uintptr_t align(uintptr_t index) {
+  return (index + sizeof(T) - 1) & ~(sizeof(T) - 1);
+}
+
+namespace vsoc {
+class RegionSignalingInterface;
+namespace layout {
+
+template <uint32_t SizeLog2>
+void CircularQueueBase<SizeLog2>::CopyInRange(const char* buffer_in,
+                                              const Range& t) {
+  size_t bytes = t.end_idx - t.start_idx;
+  uint32_t index = t.start_idx & (BufferSize - 1);
+  if (index + bytes <= BufferSize) {
+    std::memcpy(buffer_ + index, buffer_in, bytes);
+  } else {
+    size_t part1_size = BufferSize - index;
+    size_t part2_size = bytes - part1_size;
+    std::memcpy(buffer_ + index, buffer_in, part1_size);
+    std::memcpy(buffer_, buffer_in + part1_size, part2_size);
+  }
+}
+
+template <uint32_t SizeLog2>
+void CircularQueueBase<SizeLog2>::CopyOutRange(const Range& t,
+                                               char* buffer_out) {
+  uint32_t index = t.start_idx & (BufferSize - 1);
+  size_t total_size = t.end_idx - t.start_idx;
+  if (index + total_size <= BufferSize) {
+    std::memcpy(buffer_out, buffer_ + index, total_size);
+  } else {
+    uint32_t part1_size = BufferSize - index;
+    uint32_t part2_size = total_size - part1_size;
+    std::memcpy(buffer_out, buffer_ + index, part1_size);
+    std::memcpy(buffer_out + part1_size, buffer_, part2_size);
+  }
+}
+
+template <uint32_t SizeLog2>
+void CircularQueueBase<SizeLog2>::WaitForDataLocked(
+    RegionSignalingInterface* r) {
+  while (1) {
+    uint32_t o_w_pub = w_pub_;
+    // We don't have data. Wait until some appears and try again
+    if (r_released_ != o_w_pub) {
+      return;
+    }
+    lock_.Unlock();
+    r->WaitForSignal(&w_pub_, o_w_pub);
+    lock_.Lock();
+  }
+}
+
+template <uint32_t SizeLog2>
+intptr_t CircularQueueBase<SizeLog2>::WriteReserveLocked(
+    RegionSignalingInterface* r, size_t bytes, Range* t, bool non_blocking) {
+  // Can't write more than the buffer will hold
+  if (bytes > BufferSize) {
+    return -ENOSPC;
+  }
+  while (true) {
+    uint32_t o_w_pub = w_pub_;
+    uint32_t o_r_release = r_released_;
+    uint32_t bytes_in_use = o_w_pub - o_r_release;
+    size_t available = BufferSize - bytes_in_use;
+    if (available >= bytes) {
+      t->start_idx = o_w_pub;
+      t->end_idx = o_w_pub + bytes;
+      break;
+    }
+    if (non_blocking) {
+      return -EWOULDBLOCK;
+    }
+    // If we can't write at the moment wait for a reader to release
+    // some bytes.
+    lock_.Unlock();
+    r->WaitForSignal(&r_released_, o_r_release);
+    lock_.Lock();
+  }
+  return t->end_idx - t->start_idx;
+}
+
+template <uint32_t SizeLog2>
+intptr_t CircularByteQueue<SizeLog2>::Read(RegionSignalingInterface* r,
+                                           char* buffer_out, size_t max_size) {
+  this->lock_.Lock();
+  this->WaitForDataLocked(r);
+  Range t;
+  t.start_idx = this->r_released_;
+  t.end_idx = this->w_pub_;
+  // The lock is still held here...
+  // Trim the range if we got more than the reader wanted
+  if ((t.end_idx - t.start_idx) > max_size) {
+    t.end_idx = t.start_idx + max_size;
+  }
+  this->CopyOutRange(t, buffer_out);
+  this->r_released_ = t.end_idx;
+  this->lock_.Unlock();
+  r->SendSignal(layout::Sides::Both, &this->r_released_);
+  return t.end_idx - t.start_idx;
+}
+
+template <uint32_t SizeLog2>
+intptr_t CircularByteQueue<SizeLog2>::Write(RegionSignalingInterface* r,
+                                            const char* buffer_in, size_t bytes,
+                                            bool non_blocking) {
+  Range range;
+  this->lock_.Lock();
+  intptr_t rval = this->WriteReserveLocked(r, bytes, &range, non_blocking);
+  if (rval < 0) {
+    this->lock_.Unlock();
+    return rval;
+  }
+  this->CopyInRange(buffer_in, range);
+  // We can't publish until all of the previous write allocations where
+  // published.
+  this->w_pub_ = range.end_idx;
+  this->lock_.Unlock();
+  r->SendSignal(layout::Sides::Both, &this->w_pub_);
+  return bytes;
+}
+
+template <uint32_t SizeLog2, uint32_t MaxPacketSize>
+intptr_t CircularPacketQueue<SizeLog2, MaxPacketSize>::CalculateBufferedSize(
+    size_t payload) {
+  return align<uint32_t>(sizeof(uint32_t) + payload);
+}
+
+template <uint32_t SizeLog2, uint32_t MaxPacketSize>
+intptr_t CircularPacketQueue<SizeLog2, MaxPacketSize>::Read(
+    RegionSignalingInterface* r, char* buffer_out, size_t max_size) {
+  this->lock_.Lock();
+  this->WaitForDataLocked(r);
+  uint32_t packet_size = *reinterpret_cast<uint32_t*>(
+      this->buffer_ + (this->r_released_ & (this->BufferSize - 1)));
+  if (packet_size > max_size) {
+    this->lock_.Unlock();
+    return -ENOSPC;
+  }
+  Range t;
+  t.start_idx = this->r_released_ + sizeof(uint32_t);
+  t.end_idx = t.start_idx + packet_size;
+  this->CopyOutRange(t, buffer_out);
+  this->r_released_ += this->CalculateBufferedSize(packet_size);
+  this->lock_.Unlock();
+  r->SendSignal(layout::Sides::Both, &this->r_released_);
+  return packet_size;
+}
+
+template <uint32_t SizeLog2, uint32_t MaxPacketSize>
+intptr_t CircularPacketQueue<SizeLog2, MaxPacketSize>::Write(
+    RegionSignalingInterface* r, const char* buffer_in, uint32_t bytes,
+    bool non_blocking) {
+  iovec iov;
+  iov.iov_base = const_cast<char *>(buffer_in);
+  iov.iov_len = bytes;
+  return Writev(r, &iov, 1 /* iov_count */, non_blocking);
+}
+
+template <uint32_t SizeLog2, uint32_t MaxPacketSize>
+intptr_t CircularPacketQueue<SizeLog2, MaxPacketSize>::Writev(
+      RegionSignalingInterface *r,
+      const iovec *iov,
+      size_t iov_count,
+      bool non_blocking) {
+  size_t bytes = 0;
+  for (size_t i = 0; i < iov_count; ++i) {
+    bytes += iov[i].iov_len;
+  }
+
+  if (bytes > MaxPacketSize) {
+    return -ENOSPC;
+  }
+
+  Range range;
+  size_t buffered_size = this->CalculateBufferedSize(bytes);
+  this->lock_.Lock();
+  intptr_t rval =
+      this->WriteReserveLocked(r, buffered_size, &range, non_blocking);
+  if (rval < 0) {
+    this->lock_.Unlock();
+    return rval;
+  }
+  Range header = range;
+  header.end_idx = header.start_idx + sizeof(uint32_t);
+  Range payload{
+      static_cast<uint32_t>(range.start_idx + sizeof(uint32_t)),
+      static_cast<uint32_t>(range.start_idx + sizeof(uint32_t) + bytes)};
+  this->CopyInRange(reinterpret_cast<const char*>(&bytes), header);
+
+  Range subRange = payload;
+  for (size_t i = 0; i < iov_count; ++i) {
+    subRange.end_idx = subRange.start_idx + iov[i].iov_len;
+    this->CopyInRange(static_cast<const char *>(iov[i].iov_base), subRange);
+
+    subRange.start_idx = subRange.end_idx;
+  }
+
+  this->w_pub_ = range.end_idx;
+  this->lock_.Unlock();
+  r->SendSignal(layout::Sides::Both, &this->w_pub_);
+  return bytes;
+}
+
+}  // namespace layout
+}  // namespace vsoc
diff --git a/common/vsoc/lib/circqueue_test.cpp b/common/vsoc/lib/circqueue_test.cpp
new file mode 100644
index 0000000..34aca33
--- /dev/null
+++ b/common/vsoc/lib/circqueue_test.cpp
@@ -0,0 +1,327 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+#include <thread>
+#include <unistd.h>
+
+#include <gtest/gtest.h>
+
+#include "common/vsoc/lib/circqueue_impl.h"
+#include "common/vsoc/lib/mock_region_view.h"
+
+#define EXPECT_BLOCK(region, tid) \
+    EXPECT_TRUE(region.IsBlocking(tid))
+
+namespace {
+
+constexpr int kQueueSizeLog2 = 16;
+constexpr int kQueueCapacity = 1 << kQueueSizeLog2;
+constexpr int kMaxPacketSize = 1024;
+
+constexpr int kNumReadingThread = 5;
+constexpr int kNumWritingThread = 5;
+
+struct CircQueueTestRegionLayout : public vsoc::layout::RegionLayout {
+  vsoc::layout::CircularByteQueue<kQueueSizeLog2> byte_queue;
+  vsoc::layout::CircularPacketQueue<kQueueSizeLog2, kMaxPacketSize> packet_queue;
+};
+
+typedef vsoc::test::MockRegionView<CircQueueTestRegionLayout> CircQueueRegionView;
+
+class CircQueueTest : public ::testing::Test {
+ protected:
+  virtual void SetUp() {
+    region_.Open();
+  }
+
+  CircQueueRegionView region_;
+};
+
+intptr_t ReadBytes(CircQueueRegionView* region, int bytes) {
+  char buffer_out[bytes];
+  CircQueueTestRegionLayout* layout = region->data();
+  return layout->byte_queue.Read(region, buffer_out, bytes);
+}
+
+intptr_t WriteBytes(CircQueueRegionView* region, int bytes) {
+  char buffer_in[bytes];
+  CircQueueTestRegionLayout* layout = region->data();
+  return layout->byte_queue.Write(region, buffer_in, bytes);
+}
+
+intptr_t ReadPacket(CircQueueRegionView* region, int max_size) {
+  char buffer_out[max_size];
+  CircQueueTestRegionLayout* layout = region->data();
+  return layout->packet_queue.Read(region, buffer_out, max_size);
+}
+
+intptr_t WritePacket(CircQueueRegionView* region, int packet_size) {
+  char buffer_in[packet_size];
+  CircQueueTestRegionLayout* layout = region->data();
+  return layout->packet_queue.Write(region, buffer_in, packet_size);
+}
+
+void ReadBytesInChunk(CircQueueRegionView* region, int total_size, int chuck_size) {
+  char buffer_out[chuck_size];
+  CircQueueTestRegionLayout* layout = region->data();
+  int total_read = 0;
+  int remaining = total_size;
+  while (remaining >= chuck_size) {
+    int ret = layout->byte_queue.Read(region, buffer_out, chuck_size);
+    total_read += ret;
+    remaining -= ret;
+  }
+  if (remaining > 0) {
+    total_read += layout->byte_queue.Write(region, buffer_out, remaining);
+  }
+  EXPECT_EQ(total_read, total_size);
+}
+
+void WriteBytesInChunk(CircQueueRegionView* region, int total_size, int chuck_size) {
+  char buffer_in[chuck_size];
+  CircQueueTestRegionLayout* layout = region->data();
+  int total_write = 0;
+  int remaining = total_size;
+  while (remaining >= chuck_size) {
+    int ret = layout->byte_queue.Write(region, buffer_in, chuck_size);
+    total_write += ret;
+    remaining -= ret;
+  }
+  if (remaining > 0) {
+    total_write += layout->byte_queue.Write(region, buffer_in, remaining);
+  }
+  EXPECT_EQ(total_write, total_size);
+}
+
+void ReadManyPackets(CircQueueRegionView* region, int num_packets, int packet_size) {
+  char buffer_out[packet_size];
+  CircQueueTestRegionLayout* layout = region->data();
+  int total_read = 0;
+  int remaining = num_packets;
+  while (remaining > 0) {
+    int ret = layout->packet_queue.Read(region, buffer_out, packet_size);
+    total_read += ret;
+    remaining--;
+  }
+  EXPECT_EQ(total_read, num_packets * packet_size);
+}
+
+void WriteManyPackets(CircQueueRegionView* region, int num_packets, int packet_size) {
+  char buffer_in[packet_size];
+  CircQueueTestRegionLayout* layout = region->data();
+  int total_write = 0;
+  int remaining = num_packets;
+  while (remaining > 0) {
+    int ret = layout->packet_queue.Write(region, buffer_in, packet_size);
+    total_write += ret;
+    remaining--;
+  }
+  EXPECT_EQ(total_write, num_packets * packet_size);
+}
+
+// ByteQueue Tests
+
+// Test writing bytes
+TEST_F(CircQueueTest, ByteQueueSimpleWrite) {
+  const int num_bytes = 8;
+  EXPECT_EQ(num_bytes, WriteBytes(&this->region_, num_bytes));
+}
+
+// Test reading bytes
+TEST_F(CircQueueTest, ByteQueueSimpleRead) {
+  const int num_bytes = 8;
+  EXPECT_EQ(num_bytes, WriteBytes(&this->region_, num_bytes));
+  EXPECT_EQ(num_bytes, ReadBytes(&this->region_, num_bytes));
+}
+
+// Test reading on an empty queue. Expect blocking.
+TEST_F(CircQueueTest, ByteQueueReadOnEmpty) {
+  const int num_bytes = 8;
+
+  // Spawn a thread to read from queue. Expect it to block.
+  std::thread reading_thread(ReadBytes, &this->region_, num_bytes);
+  EXPECT_BLOCK(region_, reading_thread.get_id());
+
+  // Write expected bytes in so that we can clean up properly.
+  std::thread writing_thread(WriteBytes, &this->region_, num_bytes);
+  writing_thread.join();
+
+  reading_thread.join();
+}
+
+// Test writing on a full queue. Expect blocking.
+TEST_F(CircQueueTest, ByteQueueWriteOnFull) {
+  // Fill the queue.
+  const int capacity_bytes = kQueueCapacity;
+  EXPECT_EQ(capacity_bytes, WriteBytes(&this->region_, capacity_bytes));
+
+  // Now the queue is full, any further write would block.
+  const int num_bytes = 8;
+  std::thread writing_thread(WriteBytes, &this->region_, num_bytes);
+  EXPECT_BLOCK(region_, writing_thread.get_id());
+
+  // Read the extra bytes out so that we can clean up properly.
+  std::thread reading_thread(ReadBytes, &this->region_, num_bytes);
+  reading_thread.join();
+
+  writing_thread.join();
+}
+
+// Test if bytes being read out are the same as ones being written in.
+TEST_F(CircQueueTest, ByteQueueContentIntegrity) {
+  const int num_bytes = 8;
+  CircQueueTestRegionLayout* layout = this->region_.data();
+
+  char buffer_in[num_bytes] = {'a'};
+  layout->byte_queue.Write(&this->region_, buffer_in, num_bytes);
+
+  char buffer_out[num_bytes] = {'b'};
+  layout->byte_queue.Read(&this->region_, buffer_out, num_bytes);
+
+  for (int i=0; i<num_bytes; i++) {
+    EXPECT_EQ(buffer_in[i], buffer_out[i]);
+  }
+}
+
+// Test writing more bytes than capacity
+TEST_F(CircQueueTest, ByteQueueWriteTooManyBytes) {
+  const int extra_bytes = 8;
+  const int num_bytes = kQueueCapacity + extra_bytes;
+  EXPECT_EQ(-ENOSPC, WriteBytes(&this->region_, num_bytes));
+}
+
+// Test multiple bytes read/write
+TEST_F(CircQueueTest, ByteQueueMultipleReadWrite) {
+  const int chunk_size = 7;
+  const int total_size = 3.3 * kQueueCapacity;
+  std::vector<std::thread> reading_threads;
+  std::vector<std::thread> writing_threads;
+  for (int i=0; i<kNumReadingThread; i++) {
+    reading_threads.emplace_back(
+        std::thread(ReadBytesInChunk, &this->region_, total_size, chunk_size));
+  }
+  for (int i=0; i<kNumWritingThread; i++) {
+    writing_threads.emplace_back(
+        std::thread(WriteBytesInChunk, &this->region_, total_size, chunk_size));
+  }
+  std::for_each(reading_threads.begin(), reading_threads.end(), [](std::thread& t) { t.join(); });
+  std::for_each(writing_threads.begin(), writing_threads.end(), [](std::thread& t) { t.join(); });
+}
+
+// PacketQueue Tests
+
+// Test writing packet
+TEST_F(CircQueueTest, PacketQueueSimpleWrite) {
+  const int packet_size = 8;
+  EXPECT_EQ(packet_size, WritePacket(&this->region_, packet_size));
+}
+
+// Test reading packet
+TEST_F(CircQueueTest, PacketQueueSimpleRead) {
+  const int packet_size = 8;
+  EXPECT_EQ(packet_size, WritePacket(&this->region_, packet_size));
+  EXPECT_EQ(packet_size, ReadPacket(&this->region_, packet_size));
+}
+
+// Test reading on an empty queue. Expect blocking.
+TEST_F(CircQueueTest, PacketQueueReadOnEmpty) {
+  const int packet_size = 8;
+
+  // Spawn a thread to read from queue. Expect it to block.
+  std::thread reading_thread(ReadPacket, &this->region_, packet_size);
+  EXPECT_BLOCK(region_, reading_thread.get_id());
+
+  // Write expected bytes in so that we can clean up properly.
+  std::thread writing_thread(WritePacket, &this->region_, packet_size);
+  writing_thread.join();
+
+  reading_thread.join();
+}
+
+// Test writing on a full queue. Expect blocking.
+TEST_F(CircQueueTest, PacketQueueWriteOnFull) {
+  // Fill the queue.
+  const int packet_size = kMaxPacketSize;
+  int capacity_bytes = kQueueCapacity;
+  while (capacity_bytes >= packet_size) {
+    EXPECT_EQ(packet_size, WritePacket(&this->region_, packet_size));
+    capacity_bytes -= (packet_size + sizeof(uint32_t));
+  }
+
+  // Now the queue is full, any further write would block.
+  std::thread writing_thread(WritePacket, &this->region_, packet_size);
+  EXPECT_BLOCK(region_, writing_thread.get_id());
+
+  // Read the extra bytes out so that we can clean up properly.
+  std::thread reading_thread(ReadPacket, &this->region_, packet_size);
+  reading_thread.join();
+
+  writing_thread.join();
+}
+
+// Test if packet being read out are the same as one being written in.
+TEST_F(CircQueueTest, PacketQueueContentIntegrity) {
+  const int packet_size = 8;
+  CircQueueTestRegionLayout* layout = this->region_.data();
+
+  char buffer_in[packet_size] = {'a'};
+  layout->packet_queue.Write(&this->region_, buffer_in, packet_size);
+
+  char buffer_out[packet_size] = {'b'};
+  layout->packet_queue.Read(&this->region_, buffer_out, packet_size);
+
+  for (int i=0; i<packet_size; i++) {
+    EXPECT_EQ(buffer_in[i], buffer_out[i]);
+  }
+}
+
+// Test writing packet larger than capacity
+TEST_F(CircQueueTest, PacketQueueWriteTooLargePacket) {
+  const int extra_bytes = 8;
+  const int packet_size = kQueueCapacity + extra_bytes;
+  EXPECT_EQ(-ENOSPC, WritePacket(&this->region_, packet_size));
+}
+
+// Test reading packet larger than can handle
+TEST_F(CircQueueTest, PacketQueueReadTooLargePacket) {
+  const int extra_bytes = 8;
+  const int small_packet = 8;
+  const int large_packet = small_packet + extra_bytes;
+
+  WritePacket(&this->region_, large_packet);
+  char buffer_out[small_packet];
+  CircQueueTestRegionLayout* layout = this->region_.data();
+  EXPECT_EQ(-ENOSPC, layout->packet_queue.Read(&this->region_, buffer_out, small_packet));
+}
+
+// Test multiple packets read/write
+TEST_F(CircQueueTest, PacketQueueMultipleReadWrite) {
+  const int packet_size = kMaxPacketSize;
+  const int num_packets = 1.5 * (kQueueCapacity / packet_size);
+  std::vector<std::thread> reading_threads;
+  std::vector<std::thread> writing_threads;
+  for (int i=0; i<kNumReadingThread; i++) {
+    reading_threads.emplace_back(
+        std::thread(ReadManyPackets, &this->region_, num_packets, packet_size));
+  }
+  for (int i=0; i<kNumWritingThread; i++) {
+    writing_threads.emplace_back(
+        std::thread(WriteManyPackets, &this->region_, num_packets, packet_size));
+  }
+  std::for_each(reading_threads.begin(), reading_threads.end(), [](std::thread& t) { t.join(); });
+  std::for_each(writing_threads.begin(), writing_threads.end(), [](std::thread& t) { t.join(); });
+}
+
+}  // namespace
diff --git a/common/vsoc/lib/compat.cpp b/common/vsoc/lib/compat.cpp
new file mode 100644
index 0000000..3b8deb2
--- /dev/null
+++ b/common/vsoc/lib/compat.cpp
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include "common/vsoc/lib/compat.h"
+
+#include <sys/syscall.h>
+#include <unistd.h>
+
+namespace vsoc {
+
+#ifdef CUTTLEFISH_HOST
+uint32_t gettid() {
+  thread_local uint32_t tid = syscall(SYS_gettid);
+  return tid;
+}
+#endif
+}
diff --git a/common/vsoc/lib/compat.h b/common/vsoc/lib/compat.h
new file mode 100644
index 0000000..8f3355c
--- /dev/null
+++ b/common/vsoc/lib/compat.h
@@ -0,0 +1,28 @@
+#pragma once
+
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+// Utilities to make the host and the guest a bit more compatible
+
+#include <stdint.h>
+
+namespace vsoc {
+#ifdef CUTTLEFISH_HOST
+// Things that are missing on the host
+uint32_t gettid();
+#endif
+}
diff --git a/common/vsoc/lib/e2e_test_region_layout.cpp b/common/vsoc/lib/e2e_test_region_layout.cpp
new file mode 100644
index 0000000..9a787bd
--- /dev/null
+++ b/common/vsoc/lib/e2e_test_region_layout.cpp
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+// Define some of the string constants associated with the region layout.
+#include "common/vsoc/shm/e2e_test_region_layout.h"
+
+namespace vsoc {
+namespace layout {
+namespace e2e_test {
+
+const char* E2EPrimaryTestRegionLayout::region_name = "e2e_primary";
+const char
+    E2EPrimaryTestRegionLayout::guest_pattern[E2EMemoryFill::kOwnedFieldSize] =
+        "primary guest e2e string";
+const char
+    E2EPrimaryTestRegionLayout::host_pattern[E2EMemoryFill::kOwnedFieldSize] =
+        "primary host e2e string";
+
+const char* E2ESecondaryTestRegionLayout::region_name = "e2e_secondary";
+const char E2ESecondaryTestRegionLayout::guest_pattern
+    [E2EMemoryFill::kOwnedFieldSize] = "secondary guest e2e string";
+const char
+    E2ESecondaryTestRegionLayout::host_pattern[E2EMemoryFill::kOwnedFieldSize] =
+        "secondary host e2e string";
+
+const char* E2EUnfindableRegionLayout::region_name = "e2e_must_not_exist";
+
+}  // namespace e2e_test
+}  // namespace layout
+}  // namespace vsoc
diff --git a/common/vsoc/lib/e2e_test_region_view.h b/common/vsoc/lib/e2e_test_region_view.h
new file mode 100644
index 0000000..70a3db6
--- /dev/null
+++ b/common/vsoc/lib/e2e_test_region_view.h
@@ -0,0 +1,104 @@
+#pragma once
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <memory>
+#include <functional>
+
+#include "common/vsoc/lib/typed_region_view.h"
+#include "common/vsoc/shm/e2e_test_region_layout.h"
+
+namespace vsoc {
+template <typename Layout>
+class E2ERegionView : public vsoc::TypedRegionView<
+                      E2ERegionView<Layout>,
+                      Layout> {
+ public:
+
+  uint32_t read_guest_self_register() const {
+    return this->data().guest_self_register;
+  }
+
+  void write_guest_self_register(uint32_t val) {
+    this->data()->guest_self_register = val;
+  }
+
+  void signal_guest_self_register() {
+    this->SendSignal(layout::Sides::OurSide,
+                     &this->data()->guest_self_register);
+  }
+
+  int wait_guest_self_register(uint32_t expected_value) {
+    return this->WaitForSignal(
+        &this->data()->guest_self_register, expected_value);
+  }
+
+  void signal_guest_to_host_register() {
+    this->SendSignal(layout::Sides::OurSide,
+                     &this->data()->guest_to_host_signal);
+  }
+
+  uint32_t guest_to_host_signal_offset() const {
+    return this->pointer_to_region_offset(&this->data().guest_to_host_signal);
+  }
+
+  uint32_t host_to_guest_signal_offset() const {
+    return this->pointer_to_region_offset(&this->data().host_to_guest_signal);
+  }
+
+  const char* guest_string(size_t index) const {
+    return const_cast<const char*>(this->data().data[index].guest_writable);
+  }
+
+  const char* host_string(size_t index) const {
+    return const_cast<const char*>(this->data().data[index].host_writable);
+  }
+
+  bool set_guest_string(size_t index, const char* value) {
+    strcpy(const_cast<char*>(this->data()->data[index].guest_writable),
+           value);
+    return true;
+  }
+
+  bool set_host_string(size_t index, const char* value) {
+    strcpy(const_cast<char*>(this->data()->data[index].host_writable),
+           value);
+    return true;
+  }
+
+  size_t string_size() const {
+    return Layout::NumFillRecords(this->control_->region_data_size());
+  }
+
+  void guest_status(vsoc::layout::e2e_test::E2ETestStage stage) {
+    this->data()->guest_status.set_value(stage);
+  }
+
+  void host_status(vsoc::layout::e2e_test::E2ETestStage stage) {
+    this->data()->host_status.set_value(stage);
+  }
+};
+
+using E2EPrimaryRegionView =
+  vsoc::E2ERegionView<layout::e2e_test::E2EPrimaryTestRegionLayout>;
+
+using E2ESecondaryRegionView =
+  vsoc::E2ERegionView<layout::e2e_test::E2ESecondaryTestRegionLayout>;
+
+using E2EUnfindableRegionView =
+  vsoc::E2ERegionView<layout::e2e_test::E2EUnfindableRegionLayout>;
+
+}  // namespace vsoc
diff --git a/common/vsoc/lib/gralloc_layout.cpp b/common/vsoc/lib/gralloc_layout.cpp
new file mode 100644
index 0000000..9be790a
--- /dev/null
+++ b/common/vsoc/lib/gralloc_layout.cpp
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+// Define some of the string constants associated with the region layout.
+#include "common/vsoc/shm/gralloc_layout.h"
+
+namespace vsoc {
+namespace layout {
+
+namespace gralloc {
+
+const char* GrallocManagerLayout::region_name = "gralloc_manager";
+const char* GrallocBufferLayout::region_name = "gralloc_memory";
+
+}  // gralloc
+}  // layout
+}  // vsoc
diff --git a/common/vsoc/lib/graphics_common.h b/common/vsoc/lib/graphics_common.h
new file mode 100644
index 0000000..d2db6c4
--- /dev/null
+++ b/common/vsoc/lib/graphics_common.h
@@ -0,0 +1,28 @@
+#pragma once
+
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+#include "common/vsoc/shm/graphics.h"
+
+namespace vsoc {
+
+// Returns BytesPerPixel given a PixelFormat. Code should rely on this rather
+// than accessing the mask directly.
+static inline std::size_t BytesPerPixel(PixelFormat in) {
+    return 1 + (in >> PixelFormatBase::SubformatSize) &
+        (PixelFormatBase::MaxBytesPerPixel - 1);
+}
+}  // vsoc
diff --git a/common/vsoc/lib/graphics_test.cpp b/common/vsoc/lib/graphics_test.cpp
new file mode 100644
index 0000000..b43e56e
--- /dev/null
+++ b/common/vsoc/lib/graphics_test.cpp
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+#include "common/vsoc/shm/graphics.h"
+
+#include <gtest/gtest.h>
+
+TEST(GraphicsTest, Basic) {
+  // This is a shared memory layout and is mostly tested via static asserts.
+  // If this can compile then the test has passed.
+}
diff --git a/common/vsoc/lib/input_events_layout.cpp b/common/vsoc/lib/input_events_layout.cpp
new file mode 100644
index 0000000..3f1da61
--- /dev/null
+++ b/common/vsoc/lib/input_events_layout.cpp
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+// Define some of the string constants associated with the region layout.
+#include "common/vsoc/shm/input_events_layout.h"
+
+namespace vsoc {
+namespace layout {
+
+namespace input_events {
+
+const char* InputEventsLayout::region_name = "input_events";
+
+}  // namespace input_events
+}  // namespace layout
+}  // namespace vsoc
diff --git a/common/vsoc/lib/input_events_region_view.cpp b/common/vsoc/lib/input_events_region_view.cpp
new file mode 100644
index 0000000..66bc697
--- /dev/null
+++ b/common/vsoc/lib/input_events_region_view.cpp
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+#include "common/vsoc/lib/input_events_region_view.h"
+
+#include <linux/input.h>
+#include <linux/uinput.h>
+
+#include "common/vsoc/lib/circqueue_impl.h"
+
+using vsoc::layout::input_events::InputEventsLayout;
+
+namespace vsoc {
+namespace input_events {
+
+namespace {
+void InitInputEvent(InputEvent* evt, uint16_t type, uint16_t code, uint32_t value) {
+  evt->type = type;
+  evt->code = code;
+  evt->value = value;
+}
+}  // namespace
+
+const int InputEventsRegionView::kMaxEventsPerPacket = 4;
+
+bool InputEventsRegionView::HandleSingleTouchEvent(bool down, int x, int y) {
+  // TODO(jemoreira): Use multitouch when available
+  InputEvent events[4];
+  // Make sure to modify kMaxEventPerPacket if more events are sent.
+  InitInputEvent(&events[0], EV_ABS, ABS_X, x);
+  InitInputEvent(&events[1], EV_ABS, ABS_Y, y);
+  InitInputEvent(&events[2], EV_KEY, BTN_TOUCH, down);
+  InitInputEvent(&events[3], EV_SYN, 0, 0);
+  return 0 <
+         data()->touch_screen_queue.Write(
+             this, reinterpret_cast<char*>(&events[0]), sizeof(events), true);
+}
+
+bool InputEventsRegionView::HandlePowerButtonEvent(bool down) {
+  InputEvent events[2];
+  InitInputEvent(&events[0], EV_KEY, KEY_POWER, down);
+  InitInputEvent(&events[1], EV_SYN, 0, 0);
+  return 0 < data()->power_button_queue.Write(
+                 this, reinterpret_cast<char*>(&events[0]),
+                 sizeof(events), true);
+}
+
+bool InputEventsRegionView::HandleKeyboardEvent(bool down, uint16_t key_code) {
+  InputEvent events[2];
+  InitInputEvent(&events[0], EV_KEY, key_code, down);
+  InitInputEvent(&events[1], EV_SYN, 0, 0);
+  return 0 <
+         data()->keyboard_queue.Write(this, reinterpret_cast<char*>(&events[0]),
+                                      sizeof(events), true);
+}
+
+intptr_t InputEventsRegionView::GetScreenEventsOrWait(InputEvent* evt,
+                                                      int max_event_count) {
+  intptr_t ret = this->data()->touch_screen_queue.Read(
+      this, reinterpret_cast<char*>(evt), sizeof(InputEvent) * max_event_count);
+  if (ret < 0) {
+    return ret;
+  }
+  return ret / sizeof(InputEvent);
+}
+
+intptr_t InputEventsRegionView::GetKeyboardEventsOrWait(InputEvent* evt,
+                                                        int max_event_count) {
+  intptr_t ret = this->data()->keyboard_queue.Read(
+      this, reinterpret_cast<char*>(evt), sizeof(InputEvent) * max_event_count);
+  if (ret < 0) {
+    return ret;
+  }
+  return ret / sizeof(InputEvent);
+}
+
+intptr_t InputEventsRegionView::GetPowerButtonEventsOrWait(
+    InputEvent* evt, int max_event_count) {
+  intptr_t ret = this->data()->power_button_queue.Read(
+      this, reinterpret_cast<char*>(evt), sizeof(InputEvent) * max_event_count);
+  if (ret < 0) {
+    return ret;
+  }
+  return ret / sizeof(InputEvent);
+}
+
+}  // namespace input_events
+}  // namespace vsoc
diff --git a/common/vsoc/lib/input_events_region_view.h b/common/vsoc/lib/input_events_region_view.h
new file mode 100644
index 0000000..3355631
--- /dev/null
+++ b/common/vsoc/lib/input_events_region_view.h
@@ -0,0 +1,57 @@
+#pragma once
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <memory>
+
+#include "common/vsoc/lib/typed_region_view.h"
+#include "common/vsoc/shm/input_events_layout.h"
+#include "uapi/vsoc_shm.h"
+
+namespace vsoc {
+namespace input_events {
+
+struct InputEvent {
+  uint16_t type;
+  uint16_t code;
+  uint32_t value;
+};
+
+class InputEventsRegionView
+    : public vsoc::TypedRegionView<
+          InputEventsRegionView,
+          vsoc::layout::input_events::InputEventsLayout> {
+ public:
+  static const int kMaxEventsPerPacket;
+  // Generates a touch event, may returns true if successful, false if there was
+  // an error, most likely that the queue is full.
+  bool HandleSingleTouchEvent(bool down, int x, int y);
+  bool HandlePowerButtonEvent(bool down);
+  bool HandleKeyboardEvent(bool down, uint16_t key_code);
+
+  // TODO(jemoreira): HandleMultiTouchEvent()...
+
+  // Read input events from the queue, waits if there are none available.
+  // Returns the number of events read or a negative value in case of an error
+  // (most likely the next packet in the queue is larger than the buffer
+  // provided).
+  intptr_t GetScreenEventsOrWait(InputEvent* buffer, int max_event_count);
+  intptr_t GetKeyboardEventsOrWait(InputEvent* buffer, int max_event_count);
+  intptr_t GetPowerButtonEventsOrWait(InputEvent* buffer, int max_event_count);
+
+};
+}  // namespace input_events
+}  // namespace vsoc
diff --git a/common/vsoc/lib/lock_common.cpp b/common/vsoc/lib/lock_common.cpp
new file mode 100644
index 0000000..c100574
--- /dev/null
+++ b/common/vsoc/lib/lock_common.cpp
@@ -0,0 +1,180 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+#include "common/vsoc/shm/lock.h"
+
+#include "common/libs/glog/logging.h"
+#include "common/vsoc/lib/compat.h"
+#include "common/vsoc/lib/region_view.h"
+
+#include <stdlib.h>
+
+using vsoc::layout::Sides;
+
+namespace {
+
+const uint32_t LockFree = 0U;
+const uint32_t GuestWaitingFlag = (Sides::Guest << 30);
+const uint32_t HostWaitingFlag = (Sides::Host << 30);
+const uint32_t OurWaitingFlag = (Sides::OurSide << 30);
+static_assert(GuestWaitingFlag, "GuestWaitingFlag is 0");
+static_assert(HostWaitingFlag, "HostWaitingFlag is 0");
+static_assert((GuestWaitingFlag & HostWaitingFlag) == 0,
+              "Waiting flags should not share bits");
+
+// Set if the current owner is the host
+const uint32_t HostIsOwner = 0x20000000U;
+
+// PID_MAX_LIMIT appears to be 0x00400000U, so we're probably ok here
+const uint32_t OwnerMask = 0x3FFFFFFFU;
+
+uint32_t MakeOwnerTid(uint32_t raw_tid) {
+  if (Sides::OurSide == Sides::Host) {
+    return (raw_tid | HostIsOwner) & OwnerMask;
+  } else {
+    return raw_tid & (OwnerMask & ~HostIsOwner);
+  }
+}
+
+};  // namespace
+
+namespace vsoc {
+/**
+ * This is a generic synchronization primitive that provides space for the
+ * owner of the lock to write platform-specific information.
+ */
+bool vsoc::layout::WaitingLockBase::TryLock(uint32_t tid,
+                                            uint32_t* expected_out) {
+  uint32_t masked_tid = MakeOwnerTid(tid);
+  uint32_t expected = LockFree;
+  while (1) {
+    // First try to lock assuming that the mutex is free
+    if (lock_uint32_.compare_exchange_strong(expected, masked_tid)) {
+      // We got the lock.
+      return true;
+    }
+    // We didn't get the lock and our wait flag is already set. It's safe to
+    // try to sleep
+    if (expected & OurWaitingFlag) {
+      *expected_out = expected;
+      return false;
+    }
+    // Attempt to set the wait flag. This will fail if the lock owner changes.
+    while (1) {
+      uint32_t add_wait_flag = expected | OurWaitingFlag;
+      if (lock_uint32_.compare_exchange_strong(expected, add_wait_flag)) {
+        // We set the waiting flag. Try to sleep.
+        *expected_out = expected;
+        return false;
+      }
+      // The owner changed, but we at least we got the wait flag.
+      // Try sleeping
+      if (expected & OurWaitingFlag) {
+        *expected_out = expected;
+        return false;
+      }
+      // Special case: the lock was just freed. Stop trying to set the
+      // waiting flag and try to grab the lock.
+      if (expected == LockFree) {
+        break;
+      }
+      // The owner changed and we have no wait flag
+      // Try to set the wait flag again
+    }
+    // This only happens if the lock was freed while we attempt the set the
+    // wait flag. Try to grab the lock again
+  }
+  // Never reached.
+}
+
+layout::Sides vsoc::layout::WaitingLockBase::UnlockCommon(uint32_t tid) {
+  uint32_t expected_state = lock_uint32_;
+
+  // We didn't hold the lock. This process is insane and must die before it
+  // does damage.
+  uint32_t marked_tid = MakeOwnerTid(tid);
+  if ((marked_tid ^ expected_state) & OwnerMask) {
+    LOG(FATAL) << tid << " unlocking " << this << " owned by "
+               << expected_state;
+  }
+  // If contention is just starting this may fail twice (once for each bit)
+  // expected_state updates on each failure. When this finishes we have
+  // one bit for each waiter
+  while (1) {
+    if (lock_uint32_.compare_exchange_strong(expected_state, LockFree)) {
+      break;
+    }
+  }
+  if ((expected_state ^ marked_tid) & OwnerMask) {
+    LOG(FATAL) << "Lock owner of " << this << " changed from " << tid << " to "
+               << expected_state << " during unlock";
+  }
+  switch (expected_state & (GuestWaitingFlag | HostWaitingFlag)) {
+    case 0:
+      return Sides::NoSides;
+    case GuestWaitingFlag:
+      return Sides::Guest;
+    case HostWaitingFlag:
+      return Sides::Host;
+    default:
+      return Sides::Both;
+  }
+}
+
+bool vsoc::layout::WaitingLockBase::RecoverSingleSided() {
+  // No need to signal because the caller ensured that there were no other
+  // threads...
+  return lock_uint32_.exchange(LockFree) != LockFree;
+}
+
+void layout::GuestAndHostLock::Lock(RegionView* region) {
+  uint32_t expected;
+  uint32_t tid = gettid();
+  while (1) {
+    if (TryLock(tid, &expected)) {
+      return;
+    }
+    region->WaitForSignal(&lock_uint32_, expected);
+  }
+}
+
+void layout::GuestAndHostLock::Unlock(RegionView* region) {
+  region->SendSignal(UnlockCommon(gettid()), &lock_uint32_);
+}
+
+bool layout::GuestAndHostLock::Recover(RegionView* region) {
+  uint32_t expected_state = lock_uint32_;
+  uint32_t expected_owner_bit = (Sides::OurSide == Sides::Host) ? HostIsOwner : 0;
+  // This avoids check then act by reading exactly once and then
+  // eliminating the states where Recover should be a noop.
+  if (expected_state == LockFree) {
+    return false;
+  }
+  // Owned by the other side, do nothing.
+  if ((expected_state & HostIsOwner) != expected_owner_bit) {
+    return false;
+  }
+  // At this point we know two things:
+  //   * The lock was held by our side
+  //   * There are no other threads running on our side (precondition
+  //     for calling Recover())
+  // Therefore, we know that the current expected value should still
+  // be in the lock structure. Use the normal unlock logic, providing
+  // the tid that we observed in the lock.
+  region->SendSignal(UnlockCommon(expected_state), &lock_uint32_);
+  return true;
+}
+
+}  // namespace vsoc
diff --git a/common/vsoc/lib/lock_guard.h b/common/vsoc/lib/lock_guard.h
new file mode 100644
index 0000000..8fbcc7d
--- /dev/null
+++ b/common/vsoc/lib/lock_guard.h
@@ -0,0 +1,84 @@
+#pragma once
+
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include "common/vsoc/shm/lock.h"
+
+namespace vsoc {
+
+class RegionView;
+
+/*
+ * Implements std::lock_guard like functionality for the vsoc locks.
+ */
+
+template <typename Lock>
+class LockGuard {
+ public:
+  explicit LockGuard(Lock* lock) : lock_(lock) {
+    lock_->Lock();
+  }
+
+  LockGuard(LockGuard&& o) noexcept {
+    lock_ = o.lock_;
+    o.lock_ = nullptr;
+  }
+
+  LockGuard(const LockGuard&) = delete;
+  LockGuard& operator=(const LockGuard&) = delete;
+
+  ~LockGuard() {
+    if (lock_) {
+      lock_->Unlock();
+    }
+  }
+
+ private:
+  Lock* lock_;
+};
+
+template <>
+class LockGuard<::vsoc::layout::GuestAndHostLock> {
+  using Lock = ::vsoc::layout::GuestAndHostLock;
+
+ public:
+  LockGuard(Lock* lock, RegionView* region) : lock_(lock), region_(region) {
+    lock_->Lock(region_);
+  }
+
+  LockGuard(LockGuard&& o) noexcept {
+    lock_ = o.lock_;
+    o.lock_ = nullptr;
+    region_ = o.region_;
+    o.region_ = nullptr;
+  }
+
+  LockGuard(const LockGuard&) = delete;
+  LockGuard& operator=(const LockGuard&) = delete;
+
+  ~LockGuard() {
+    if (lock_) {
+      lock_->Unlock(region_);
+    }
+  }
+
+ private:
+  Lock* lock_;
+  RegionView* region_;
+};
+
+}  // namespace vsoc
diff --git a/common/vsoc/lib/lock_test.cpp b/common/vsoc/lib/lock_test.cpp
new file mode 100644
index 0000000..d09b5a4
--- /dev/null
+++ b/common/vsoc/lib/lock_test.cpp
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+#include "common/vsoc/shm/lock.h"
+
+#include <thread>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+#include "common/vsoc/lib/region_view.h"
+
+#ifdef CUTTLEFISH_HOST
+using MyLock = vsoc::layout::HostLock;
+#else
+using MyLock = vsoc::layout::GuestLock;
+#endif
+
+class SimpleLocker {
+ public:
+  enum State {
+    BEFORE_EXECUTION,
+    BEFORE_LOCK,
+    IN_CRITICAL_SECTION,
+    DONE,
+    JOINED
+  };
+
+  explicit SimpleLocker(MyLock* lock)
+      : lock_(lock), thread_(&SimpleLocker::Work, this) {}
+
+  void Work() {
+    state_ = BEFORE_LOCK;
+    lock_->Lock();
+    state_ = IN_CRITICAL_SECTION;
+    InCriticalSection();
+    lock_->Unlock();
+    state_ = DONE;
+  }
+
+  void InCriticalSection() {}
+
+  void Join() {
+    thread_.join();
+    state_ = JOINED;
+  }
+
+ protected:
+  MyLock* lock_;
+  volatile State state_{BEFORE_EXECUTION};
+  std::thread thread_;
+};
+
+TEST(LockTest, Basic) {
+  // In production regions are always 0 filled on allocation. That's not
+  // true on the stack, so initialize the lock when we declare it.
+  MyLock lock{};
+  SimpleLocker a(&lock);
+  SimpleLocker b(&lock);
+  a.Join();
+  b.Join();
+}
diff --git a/common/vsoc/lib/managed_e2e_test_region_layout.cpp b/common/vsoc/lib/managed_e2e_test_region_layout.cpp
new file mode 100644
index 0000000..1cc794b
--- /dev/null
+++ b/common/vsoc/lib/managed_e2e_test_region_layout.cpp
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include "common/vsoc/shm/managed_e2e_test_region_layout.h"
+
+namespace vsoc {
+namespace layout {
+namespace e2e_test {
+
+const char* E2EManagedTestRegionLayout::region_name = "e2e_managed";
+
+const char* E2EManagerTestRegionLayout::region_name = "e2e_manager";
+
+}  // namespace e2e_test
+}  // namespace layout
+}  // namespace vsoc
diff --git a/common/vsoc/lib/mock_region_view.h b/common/vsoc/lib/mock_region_view.h
new file mode 100644
index 0000000..f9c3006
--- /dev/null
+++ b/common/vsoc/lib/mock_region_view.h
@@ -0,0 +1,119 @@
+#pragma once
+
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+#include <linux/futex.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <chrono>
+#include <condition_variable>
+#include <mutex>
+#include <thread>
+#include <unordered_map>
+
+#include "common/vsoc/lib/region_signaling_interface.h"
+
+namespace vsoc {
+namespace test {
+
+/**
+ * MockRegionView mocks a region in the shared memory window by calloc and
+ * futex. It supports only one-sided signal as in it doesn't do anything on
+ * sending or waiting interrupt. This is to test if a particular layout
+ * behaves correctly when there are multiple threads accessing it.
+ */
+template <typename Layout>
+class MockRegionView : public vsoc::RegionSignalingInterface {
+ public:
+  explicit MockRegionView(){};
+  virtual ~MockRegionView() {
+    if (region_base_) {
+      free(region_base_);
+      region_base_ = nullptr;
+    }
+  };
+
+  bool Open() {
+    region_base_ = calloc(sizeof(Layout), 1);
+    return !region_base_;
+  };
+
+  virtual void SendSignal(vsoc::layout::Sides /* sides_to_signal */,
+                          std::atomic<uint32_t>* uaddr) {
+    syscall(SYS_futex, reinterpret_cast<int32_t*>(uaddr), FUTEX_WAKE, -1,
+            nullptr, nullptr, 0);
+  }
+
+  virtual int WaitForSignal(std::atomic<uint32_t>* uaddr,
+                             uint32_t expected_value) {
+    {
+      std::lock_guard<std::mutex> guard(mutex_);
+      if (tid_to_addr_.find(std::this_thread::get_id()) != tid_to_addr_.end()) {
+        // Same thread tries to wait
+        return 0;
+      }
+      tid_to_addr_.emplace(std::this_thread::get_id(), uaddr);
+      map_changed_.notify_one();
+    }
+
+    syscall(SYS_futex, uaddr, FUTEX_WAIT, expected_value, nullptr, nullptr, 0);
+
+    {
+      std::lock_guard<std::mutex> guard(mutex_);
+      tid_to_addr_.erase(std::this_thread::get_id());
+    }
+    return 0;
+  }
+
+  // Mock methods from TypedRegionView
+  Layout* data() { return reinterpret_cast<Layout*>(region_base_); };
+
+  // Check wait status on a specificy thread
+  bool IsBlocking(std::thread::id tid) {
+    while (1) {
+      std::unique_lock<std::mutex> lock(mutex_);
+      if (tid_to_addr_.find(tid) != tid_to_addr_.end()) {
+        return true;
+      }
+      // Allow some time as tid map might not be updated yet
+      while (tid_to_addr_.find(tid) == tid_to_addr_.end()) {
+        if (map_changed_.wait_for(lock,
+                                  std::chrono::seconds(kWaitTimeoutInSec)) ==
+            std::cv_status::timeout) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+
+ private:
+  // Timeout to avoid a race on checking if a thread is blocked
+  static constexpr int kWaitTimeoutInSec = 5;
+
+  void* region_base_{};
+  std::mutex mutex_;
+  std::condition_variable map_changed_;
+  std::unordered_map<std::thread::id, std::atomic<uint32_t>*> tid_to_addr_;
+};
+
+template <typename Layout>
+constexpr int MockRegionView<Layout>::kWaitTimeoutInSec;
+
+}  // namespace test
+}  // namespace vsoc
diff --git a/common/vsoc/lib/region_control.h b/common/vsoc/lib/region_control.h
new file mode 100644
index 0000000..7762603
--- /dev/null
+++ b/common/vsoc/lib/region_control.h
@@ -0,0 +1,111 @@
+#pragma once
+
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <sys/mman.h>
+#include <stdint.h>
+#include <memory>
+#include "uapi/vsoc_shm.h"
+
+namespace vsoc {
+
+/**
+ * Base class for side-specific utility functions that work on regions.
+ * The methods in this class do not assume that the region is mapped in memory.
+ * This makes is appropriate for ManagedRegions and certain low-level tests
+ * of VSoC shared memory. Most other users will want to use TypedRegions with
+ * a defined RegionLayout.
+ *
+ * This class is not directly instantiable because it must be specialized with
+ * additional fields for the host and guest.
+ */
+class RegionControl {
+ public:
+  virtual ~RegionControl() {
+    if (region_base_) {
+      munmap(region_base_, region_size());
+    }
+    region_base_ = nullptr;
+  }
+
+#if defined(CUTTLEFISH_HOST)
+  static std::shared_ptr<RegionControl> Open(const char* region_name,
+                                             const char* domain);
+#else
+  static std::shared_ptr<RegionControl> Open(const char* region_name);
+#endif
+
+  const vsoc_device_region& region_desc() const { return region_desc_; }
+
+  // Returns the size of the entire region, including the signal tables.
+  uint32_t region_size() const {
+    return region_desc_.region_end_offset - region_desc_.region_begin_offset;
+  }
+
+  // Returns the size of the region that is usable for region-specific data.
+  uint32_t region_data_size() const {
+    return region_size() - region_desc_.offset_of_region_data;
+  }
+
+  // Creates a FdScopedPermission. Returns the file descriptor or -1 on
+  // failure. FdScopedPermission is not supported on the host, so -1 is
+  // always returned there.
+  virtual int CreateFdScopedPermission(const char* managed_region_name,
+                                       uint32_t owner_offset,
+                                       uint32_t owned_value,
+                                       uint32_t begin_offset,
+                                       uint32_t end_offset) = 0;
+
+  // Interrupt our peer, causing it to scan the outgoing_signal_table
+  virtual bool InterruptPeer() = 0;
+
+  // Wake the local signal table scanner. Primarily used during shutdown
+  virtual void InterruptSelf() = 0;
+
+  // Maps the entire region at an address, returning a pointer to the mapping
+  virtual void* Map() = 0;
+
+  // Wait for an interrupt from our peer
+  virtual void WaitForInterrupt() = 0;
+
+  // Signals local waiters at the given region offset.
+  // Defined only on the guest.
+  // Return value is negative on error.
+  virtual int SignalSelf(uint32_t offset) = 0;
+
+  // Waits for a signal at the given region offset.
+  // Defined only on the guest.
+  // Return value is negative on error. The number of false wakes is returned
+  // on success.
+  virtual int WaitForSignal(uint32_t offset, uint32_t expected_value) = 0;
+
+  template <typename T>
+  T* region_offset_to_pointer(uint32_t offset) {
+    if (offset > region_size()) {
+      LOG(FATAL) << __FUNCTION__ << ": " << offset << " not in region @"
+                 << region_base_;
+    }
+    return reinterpret_cast<T*>(reinterpret_cast<uintptr_t>(region_base_) +
+                                offset);
+  }
+
+ protected:
+  RegionControl() {}
+  void* region_base_{};
+  vsoc_device_region region_desc_{};
+};
+}  // namespace vsoc
diff --git a/common/vsoc/lib/region_signaling_interface.h b/common/vsoc/lib/region_signaling_interface.h
new file mode 100644
index 0000000..c1399e1
--- /dev/null
+++ b/common/vsoc/lib/region_signaling_interface.h
@@ -0,0 +1,64 @@
+#pragma once
+
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <stdlib.h>
+#include <atomic>
+
+#include "common/vsoc/shm/base.h"
+
+namespace vsoc {
+
+/**
+ * Interface that defines signaling and waiting for signal.
+ */
+class RegionSignalingInterface {
+ public:
+  virtual ~RegionSignalingInterface(){};
+
+  // Post a signal to the guest, the host, or both.
+  // See futex(2) FUTEX_WAKE for details.
+  //
+  //   sides_to_signal: controls where the signal is sent
+  //
+  //   signal_addr: the memory location to signal. Must be within the region.
+  virtual void SendSignal(layout::Sides sides_to_signal,
+                          std::atomic<uint32_t>* signal_addr) = 0;
+
+  // This implements the following:
+  // if (*signal_addr == last_observed_value)
+  //   wait_for_signal_at(signal_addr);
+  //
+  // Note: the caller still needs to check the value at signal_addr because
+  // this function may return early for reasons that are implementation-defined.
+  // See futex(2) FUTEX_WAIT for details.
+  //
+  //   signal_addr: the memory that will be signaled. Must be within the region.
+  //
+  //   last_observed_value: the value that motivated the calling code to wait.
+  //
+  // The return values are:
+  //   -1 on failure
+  //    0 indicates success with no tuning information
+  //    >0 indicates success. The number indicates how many times the thread
+  //       woke before it could return.
+  //       Large values indicate that the regions should be tuned.
+  virtual int WaitForSignal(std::atomic<uint32_t>* signal_addr,
+                             uint32_t last_observed_value) = 0;
+};
+
+}  // namespace vsoc
diff --git a/common/vsoc/lib/region_view.cpp b/common/vsoc/lib/region_view.cpp
new file mode 100644
index 0000000..dc1088c
--- /dev/null
+++ b/common/vsoc/lib/region_view.cpp
@@ -0,0 +1,201 @@
+#include "common/vsoc/lib/region_view.h"
+
+#include <sys/mman.h>
+
+#include "common/libs/glog/logging.h"
+
+namespace {
+const uint32_t UADDR_OFFSET_MASK = 0xFFFFFFFC;
+const uint32_t UADDR_OFFSET_ROUND_TRIP_FLAG = 1;
+}  // namespace
+
+using vsoc::layout::Sides;
+
+vsoc::RegionWorker::RegionWorker(RegionView* region,
+                                 std::shared_ptr<RegionControl> control)
+    : control_(control),
+      region_(region),
+      stopping_(false) {}
+
+void vsoc::RegionWorker::start() {
+  CHECK(!thread_.joinable());
+  thread_ = std::thread(&vsoc::RegionWorker::Work, this);
+}
+
+void vsoc::RegionWorker::Work() {
+  while (!stopping_) {
+    region_->WaitForInterrupt();
+    if (stopping_) {
+      return;
+    }
+    region_->ProcessSignalsFromPeer([this](uint32_t offset) {
+        control_->SignalSelf(offset);
+    });
+  }
+}
+
+vsoc::RegionWorker::~RegionWorker() {
+  stopping_ = true;
+
+  if (thread_.joinable()) {
+    region_->InterruptSelf();
+    thread_.join();
+  }
+}
+
+vsoc::RegionView::~RegionView() {
+  // region_base_ is borrowed here. It's owned by control_, which is
+  // responsible for unmapping the memory
+  region_base_ = nullptr;
+}
+
+#if defined(CUTTLEFISH_HOST)
+bool vsoc::RegionView::Open(const char* name, const char* domain) {
+  control_ = vsoc::RegionControl::Open(name, domain);
+  if (!control_) {
+    return false;
+  }
+  region_base_ = control_->Map();
+  return region_base_ != nullptr;
+}
+#else
+bool vsoc::RegionView::Open(const char* name) {
+  control_ = vsoc::RegionControl::Open(name);
+  if (!control_) {
+    return false;
+  }
+  region_base_ = control_->Map();
+  return region_base_ != nullptr;
+}
+#endif
+
+// Interrupt our peer, causing it to scan the outgoing_signal_table
+bool vsoc::RegionView::MaybeInterruptPeer() {
+  if (region_offset_to_pointer<std::atomic<uint32_t>>(
+          outgoing_signal_table().interrupt_signalled_offset)
+          ->exchange(1)) {
+    return false;
+  }
+  return control_->InterruptPeer();
+}
+
+// Wait for an interrupt from our peer
+void vsoc::RegionView::WaitForInterrupt() {
+  while (1) {
+    if (region_offset_to_pointer<std::atomic<uint32_t>>(
+            incoming_signal_table().interrupt_signalled_offset)
+            ->exchange(0)) {
+      return;
+    }
+    control_->WaitForInterrupt();
+  }
+}
+
+void vsoc::RegionView::ProcessSignalsFromPeer(
+    std::function<void(uint32_t)> signal_handler) {
+  const vsoc_signal_table_layout& table = incoming_signal_table();
+  const size_t num_offsets = (1 << table.num_nodes_lg2);
+  std::atomic<uint32_t>* offsets =
+      region_offset_to_pointer<std::atomic<uint32_t>>(
+          table.futex_uaddr_table_offset);
+  for (size_t i = 0; i < num_offsets; ++i) {
+    uint32_t raw_offset = offsets[i].exchange(0);
+    if (raw_offset) {
+      bool round_trip = raw_offset & UADDR_OFFSET_ROUND_TRIP_FLAG;
+      uint32_t offset = raw_offset & UADDR_OFFSET_MASK;
+      signal_handler(offset);
+      if (round_trip) {
+        SendSignalToPeer(
+            region_offset_to_pointer<std::atomic<uint32_t>>(offset), false);
+      }
+    }
+  }
+}
+
+void vsoc::RegionView::SendSignal(Sides sides_to_signal,
+                                  std::atomic<uint32_t>* uaddr) {
+  if (sides_to_signal & Sides::Peer) {
+    // If we should also be signalling our side set the round trip flag on
+    // the futex signal.
+    bool round_trip = sides_to_signal & Sides::OurSide;
+    SendSignalToPeer(uaddr, round_trip);
+    // Return without signaling our waiters to give the other side a chance
+    // to run.
+    return;
+  }
+  if (sides_to_signal & Sides::OurSide) {
+    control_->SignalSelf(pointer_to_region_offset(uaddr));
+  }
+}
+
+void vsoc::RegionView::SendSignalToPeer(std::atomic<uint32_t>* uaddr,
+                                        bool round_trip) {
+  const vsoc_signal_table_layout& table = outgoing_signal_table();
+  std::atomic<uint32_t>* offsets =
+      region_offset_to_pointer<std::atomic<uint32_t>>(
+          table.futex_uaddr_table_offset);
+  // maximum index in the node that can hold an offset;
+  const size_t max_index = (1 << table.num_nodes_lg2) - 1;
+  uint32_t offset = pointer_to_region_offset(uaddr);
+  if (offset & ~UADDR_OFFSET_MASK) {
+    LOG(FATAL) << "uaddr offset is not naturally aligned " << uaddr;
+  }
+  // Guess at where this offset should go in the table.
+  // Do this before we set the round-trip flag.
+  size_t hash = (offset >> 2) & max_index;
+  if (round_trip) {
+    offset |= UADDR_OFFSET_ROUND_TRIP_FLAG;
+  }
+  while (1) {
+    uint32_t expected = 0;
+    if (offsets[hash].compare_exchange_strong(expected, offset)) {
+      // We stored the offset. Send the interrupt.
+      this->MaybeInterruptPeer();
+      break;
+    }
+    // We didn't store, but the value was already in the table with our flag.
+    // Return without interrupting.
+    if (expected == offset) {
+      return;
+    }
+    // Hash collision. Try again in a different node
+    if ((expected & UADDR_OFFSET_MASK) != (offset & UADDR_OFFSET_MASK)) {
+      hash = (hash + 1) & max_index;
+      continue;
+    }
+    // Our offset was in the bucket, but the flags didn't match.
+    // We're done if the value in the node had the round trip flag set.
+    if (expected & UADDR_OFFSET_ROUND_TRIP_FLAG) {
+      return;
+    }
+    // We wanted the round trip flag, but the value in the bucket didn't set it.
+    // Do a second swap to try to set it.
+    if (offsets[hash].compare_exchange_strong(expected, offset)) {
+      // It worked. We're done.
+      return;
+    }
+    if (expected == offset) {
+      // expected was the offset without the flag. After the swap it has the
+      // the flag. This means that some other thread set the flag, so
+      // we're done.
+      return;
+    }
+    // Something about the offset changed. We need to go around again, because:
+    //   our peer processed the old entry
+    //   another thread may have stolen the node while we were distracted
+  }
+}
+
+std::unique_ptr<vsoc::RegionWorker> vsoc::RegionView::StartWorker() {
+    std::unique_ptr<vsoc::RegionWorker> worker(
+            new vsoc::RegionWorker(this /* region */, control_));
+
+    worker->start();
+    return worker;
+}
+
+int vsoc::RegionView::WaitForSignal(std::atomic<uint32_t>* uaddr,
+                                     uint32_t expected_value) {
+  return control_->WaitForSignal(pointer_to_region_offset(uaddr),
+                                 expected_value);
+}
diff --git a/common/vsoc/lib/region_view.h b/common/vsoc/lib/region_view.h
new file mode 100644
index 0000000..055f721
--- /dev/null
+++ b/common/vsoc/lib/region_view.h
@@ -0,0 +1,214 @@
+#pragma once
+
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+// Object that represents a region on the Host
+
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <atomic>
+#include <cstdint>
+
+#include <functional>
+#include <map>
+#include <thread>
+
+#include "common/libs/fs/shared_fd.h"
+#include "common/libs/glog/logging.h"
+#include "common/vsoc/lib/lock_guard.h"
+#include "common/vsoc/lib/region_control.h"
+#include "common/vsoc/lib/region_signaling_interface.h"
+#include "common/vsoc/shm/base.h"
+#include "uapi/vsoc_shm.h"
+
+namespace vsoc {
+
+class RegionControl;
+class RegionView;
+
+/**
+ * Represents a task that is tied to a RegionView.
+ *
+ * This is currently used for the task that forwards futexes across the
+ * shared memory window.
+ */
+class RegionWorker {
+ public:
+  RegionWorker(RegionView* region, std::shared_ptr<RegionControl> control);
+  ~RegionWorker();
+
+  void start();
+
+  void Work();
+
+ protected:
+  std::shared_ptr<RegionControl> control_;
+  RegionView* region_;
+  std::thread thread_;
+  volatile bool stopping_;
+};
+
+/**
+ * Base class to access a mapped region in VSoC shared memory.
+ * This class holds the methods that depends on the region's memory having an
+ * address. The RegionControl class holds the methods that can be invoked
+ * without mapping the region.
+ */
+class RegionView : public RegionSignalingInterface {
+ public:
+  virtual ~RegionView();
+
+#if defined(CUTTLEFISH_HOST)
+  bool Open(const char* region_name, const char* domain);
+#else
+  bool Open(const char* region_name);
+#endif
+
+  // Returns a pointer to the table that will be scanned for signals
+  const vsoc_signal_table_layout& incoming_signal_table();
+
+  // Returns a pointer to the table that will be used to post signals
+  const vsoc_signal_table_layout& outgoing_signal_table();
+
+  // Returns true iff an interrupt is queued in the signal table
+  bool HasIncomingInterrupt() {
+    return *region_offset_to_pointer<std::atomic<uint32_t>>(
+        incoming_signal_table().interrupt_signalled_offset);
+  }
+
+  // Wake any threads waiting for an interrupt. This is generally used during
+  // shutdown.
+  void InterruptSelf() { control_->InterruptSelf(); }
+
+  // Interrupt our peer if an interrupt is not already on the way.
+  // Returns true if the interrupt was sent, false if an interrupt was already
+  // pending.
+  bool MaybeInterruptPeer();
+
+  // Scan in the incoming signal table, issuing futex calls for any posted
+  // signals and then reposting them to the peer if they were round-trip
+  // signals.
+  //
+  //   signal_handler: An action to perform on every offset signalled by our
+  //   peer, usually a FUTEX_WAKE call, but can be customized for other
+  //   purposes.
+  void ProcessSignalsFromPeer(
+      std::function<void(uint32_t)> signal_handler);
+
+  // Post a signal to the guest, the host, or both.
+  // See futex(2) FUTEX_WAKE for details.
+  //
+  //   sides_to_signal: controls where the signal is sent
+  //
+  //   signal_addr: the memory location to signal. Must be within the region.
+  void SendSignal(layout::Sides sides_to_signal,
+                  std::atomic<uint32_t>* signal_addr);
+
+  // Post a signal to our peer for a specific memeory location.
+  // See futex(2) FUTEX_WAKE for details.
+  //
+  //   signal_addr: the memory location to signal. Must be within the region.
+  //
+  //   round_trip: true if there may be waiters on both sides of the shared
+  //               memory.
+  void SendSignalToPeer(std::atomic<uint32_t>* signal_addr, bool round_trip);
+
+  // Waits until an interrupt appears on this region, then clears the
+  // interrupted flag and returns.
+  void WaitForInterrupt();
+
+  // This implements the following:
+  // if (*signal_addr == last_observed_value)
+  //   wait_for_signal_at(signal_addr);
+  //
+  // Note: the caller still needs to check the value at signal_addr because
+  // this function may return early for reasons that are implementation-defined.
+  // See futex(2) FUTEX_WAIT for details.
+  //
+  //   signal_addr: the memory that will be signaled. Must be within the region.
+  //
+  //   last_observed_value: the value that motivated the calling code to wait.
+  //
+  // The return value is -1 on error. On the guest positive values give the
+  // number of false wakes.
+  int WaitForSignal(std::atomic<uint32_t>* signal_addr,
+                     uint32_t last_observed_value) override;
+
+  // Starts the signal table scanner. This must be invoked by subclasses, which
+  // MUST store the returned unique_ptr as a class member.
+  __attribute__((warn_unused_result))
+  std::unique_ptr<RegionWorker> StartWorker();
+
+  // Returns a pointer to the start of region data that is cast to the given
+  // type.  Initializers that run in the launcher use this to get a typed view
+  // of the region. Most other cases should be handled via TypedRegionView.
+  template <typename LayoutType>
+  LayoutType* GetLayoutPointer() {
+    return this->region_offset_to_pointer<LayoutType>(
+        control_->region_desc().offset_of_region_data);
+  }
+
+  // Helper functions for lock guards. This approach has two advantages:
+  //
+  //   o Callers don't have to be refactored when lock types change
+  //   o The region pointer can be provided automatically
+  template <typename T>
+  LockGuard<T> make_lock_guard(T* lock) {
+    return LockGuard<T>(lock);
+  }
+
+  LockGuard<::vsoc::layout::GuestAndHostLock> make_lock_guard(
+      ::vsoc::layout::GuestAndHostLock* l) {
+    return LockGuard<::vsoc::layout::GuestAndHostLock>(l, this);
+  }
+
+ protected:
+  template <typename T>
+  T* region_offset_to_pointer(uint32_t offset) {
+    return control_->region_offset_to_pointer<T>(offset);
+  }
+
+  template <typename T>
+  const T& region_offset_to_reference(uint32_t offset) const {
+    if (offset > control_->region_size()) {
+      LOG(FATAL) << __FUNCTION__ << ": " << offset << " not in region @"
+                 << region_base_;
+    }
+    return *reinterpret_cast<const T*>(
+        reinterpret_cast<uintptr_t>(region_base_) + offset);
+  }
+
+  // Calculates an offset based on a pointer in the region. Crashes if the
+  // pointer isn't in the region.
+  // This is mostly for the RegionView's internal plumbing. Use TypedRegionView
+  // and RegionLayout to avoid this in most cases.
+  template <typename T>
+  uint32_t pointer_to_region_offset(T* ptr) const {
+    uint32_t rval = reinterpret_cast<uintptr_t>(ptr) -
+                          reinterpret_cast<uintptr_t>(region_base_);
+    if (rval > control_->region_size()) {
+      LOG(FATAL) << __FUNCTION__ << ": " << ptr << " not in region @"
+                 << region_base_;
+    }
+    return rval;
+  }
+
+  std::shared_ptr<RegionControl> control_;
+  void* region_base_{};
+};
+
+}  // namespace vsoc
diff --git a/common/vsoc/lib/screen_layout.cpp b/common/vsoc/lib/screen_layout.cpp
new file mode 100644
index 0000000..d302030
--- /dev/null
+++ b/common/vsoc/lib/screen_layout.cpp
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+#include "common/vsoc/shm/screen_layout.h"
+
+namespace vsoc {
+namespace layout {
+
+namespace screen {
+
+const char* ScreenLayout::region_name = "screen";
+
+}  // namespace screen
+}  // namespace layout
+}  // namespace vsoc
diff --git a/common/vsoc/lib/screen_region_view.cpp b/common/vsoc/lib/screen_region_view.cpp
new file mode 100644
index 0000000..2a22335
--- /dev/null
+++ b/common/vsoc/lib/screen_region_view.cpp
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include "common/vsoc/lib/screen_region_view.h"
+
+#include <memory>
+
+#include "common/libs/glog/logging.h"
+#include "common/vsoc/lib/lock_guard.h"
+
+using vsoc::layout::screen::CompositionStats;
+using vsoc::screen::ScreenRegionView;
+
+const uint8_t* ScreenRegionView::first_buffer() const {
+  // TODO(jemoreira): Add alignments?
+  return &(this->data().buffer[0]);
+}
+
+int ScreenRegionView::number_of_buffers() const {
+  auto offset_of_first_buffer =
+      const_cast<ScreenRegionView*>(this)->pointer_to_region_offset(
+          this->first_buffer());
+  size_t total_buffer_size = control_->region_size() - offset_of_first_buffer;
+  return total_buffer_size / buffer_size();
+}
+
+void* ScreenRegionView::GetBuffer(int buffer_idx) {
+  uint8_t* buffer = const_cast<uint8_t*>(this->first_buffer());
+  return buffer + buffer_idx * this->buffer_size();
+}
+
+// We can use a locking protocol because we decided that the streamer should
+// have more priority than the hwcomposer, so it's OK to block the hwcomposer
+// waiting for the streamer to complete, while the streamer will only block on
+// the hwcomposer when it has ran out of work to do and needs to get more from
+// the hwcomposer.
+void ScreenRegionView::BroadcastNewFrame(int buffer_idx,
+                                         const CompositionStats* stats) {
+  {
+    if (buffer_idx < 0 || buffer_idx >= number_of_buffers()) {
+      LOG(ERROR) << "Attempting to broadcast an invalid buffer index: "
+                 << buffer_idx;
+      return;
+    }
+    auto lock_guard(make_lock_guard(&data()->bcast_lock));
+    data()->seq_num++;
+    data()->buffer_index = static_cast<int32_t>(buffer_idx);
+    if (stats) {
+      data()->stats = *stats;
+    }
+  }
+  // Signaling after releasing the lock may cause spurious wake ups.
+  // Signaling while holding the lock may cause the just-awaken listener to
+  // block immediately trying to acquire the lock.
+  // The former is less costly and slightly less likely to happen.
+  SendSignal(layout::Sides::Both, &data()->seq_num);
+}
+
+int ScreenRegionView::WaitForNewFrameSince(uint32_t* last_seq_num,
+                                           CompositionStats* stats) {
+  static std::unique_ptr<RegionWorker> worker = StartWorker();
+  // It's ok to read seq_num here without holding the lock because the lock will
+  // be acquired immediately after so we'll block if necessary to wait for the
+  // critical section in BroadcastNewFrame to complete.
+  // Also, the call to WaitForSignal receives a pointer to seq_num (so the
+  // compiler should not optimize it out) and includes a memory barrier
+  // (FUTEX_WAIT).
+  while (data()->seq_num == *last_seq_num) {
+    // Don't hold the lock when waiting for a signal, will deadlock.
+    WaitForSignal(&data()->seq_num, *last_seq_num);
+  }
+
+  {
+    auto lock_guard(make_lock_guard(&data()->bcast_lock));
+    *last_seq_num = data()->seq_num;
+    if (stats) {
+      *stats = data()->stats;
+    }
+    return static_cast<int>(data()->buffer_index);
+  }
+}
diff --git a/common/vsoc/lib/screen_region_view.h b/common/vsoc/lib/screen_region_view.h
new file mode 100644
index 0000000..aef4359
--- /dev/null
+++ b/common/vsoc/lib/screen_region_view.h
@@ -0,0 +1,104 @@
+#pragma once
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <memory>
+
+#include "common/vsoc/lib/typed_region_view.h"
+#include "common/vsoc/shm/graphics.h"
+#include "common/vsoc/shm/screen_layout.h"
+#include "uapi/vsoc_shm.h"
+
+namespace vsoc {
+namespace screen {
+
+// Provides information related to the device's screen. Allows to query screen
+// properties such as resolution and dpi, as well as subscribe/notify to/of
+// changes on the screen contents. It also holds the contents of the display.
+class ScreenRegionView
+    : public vsoc::TypedRegionView<ScreenRegionView,
+                                   vsoc::layout::screen::ScreenLayout> {
+ public:
+  static int align(int input) {
+    auto constexpr alignment = 16;
+    return (input + alignment - 1) & -alignment;
+  }
+
+  // Screen width in pixels
+  int x_res() const { return data().x_res; }
+
+  // Screen height in pixels
+  int y_res() const { return data().y_res; }
+
+  // Dots per inch
+  int dpi() const { return data().dpi; }
+
+  // Refresh rate in Hertz
+  int refresh_rate_hz() const { return data().refresh_rate_hz; }
+
+  uint32_t pixel_format() const { return kFbPixelFormat; }
+
+  uint32_t bytes_per_pixel() const {
+    return vsoc::PixelFormatProperties<kFbPixelFormat>::bytes_per_pixel;
+  }
+
+  int line_length() const { return align(x_res() * bytes_per_pixel()); }
+
+  size_t buffer_size() const {
+    return (align(x_res() * bytes_per_pixel()) * y_res()) + kSwiftShaderPadding;
+  }
+
+  int number_of_buffers() const;
+
+  // Gets a pointer to the beginning of a buffer. Does not perform any bound
+  // checks on the index.
+  void* GetBuffer(int buffer_idx);
+
+  // Broadcasts a new frame.
+  // buffer_idx is the index of the buffer containing the composed screen, it's
+  // a number in the range [0, number_of_buffers() - 1].
+  // Stats holds performance information of the last composition, can be null.
+  void BroadcastNewFrame(
+      int buffer_idx,
+      const vsoc::layout::screen::CompositionStats* stats = nullptr);
+
+  // Waits for a new frame (one with a different seq_num than last one we saw).
+  // Returns the index of the buffer containing the new frame or a negative
+  // number if there was an error, stores the new sequential number in
+  // *last_seq_num. The frame sequential numbers will be provided by the
+  // hwcomposer and expected to increase monotonically over time (though it's
+  // not a hard requirement), this numbers are guaranteed to be non-zero when a
+  // valid frame is available. Performance statistics are returned through the
+  // stats parameter when it's not null.
+  int WaitForNewFrameSince(
+      uint32_t* last_seq_num,
+      vsoc::layout::screen::CompositionStats* stats = nullptr);
+
+  using Pixel = uint32_t;
+  static constexpr int kSwiftShaderPadding = 4;
+  static constexpr int kRedShift = 0;
+  static constexpr int kGreenShift = 8;
+  static constexpr int kBlueShift = 16;
+  static constexpr int kRedBits = 8;
+  static constexpr int kGreenBits = 8;
+  static constexpr int kBlueBits = 8;
+  static constexpr uint32_t kFbPixelFormat = vsoc::VSOC_PIXEL_FORMAT_RGBA_8888;
+
+ protected:
+  const uint8_t* first_buffer() const;
+};
+}  // namespace screen
+}  // namespace vsoc
diff --git a/common/vsoc/lib/screen_region_view_test.cpp b/common/vsoc/lib/screen_region_view_test.cpp
new file mode 100644
index 0000000..cc02baa
--- /dev/null
+++ b/common/vsoc/lib/screen_region_view_test.cpp
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+#include "screen_region_view.h"
+#include "host/libs/config/cuttlefish_config.h"
+#include <stdio.h>
+
+using vsoc::screen::ScreenRegionView;
+
+int main() {
+  uint32_t frame_num = 0;
+  int buffer_id = 0;
+
+#if defined(CUTTLEFISH_HOST)
+  auto region = ScreenRegionView::GetInstance(vsoc::GetDomain().c_str());
+#else
+  auto region = ScreenRegionView::GetInstance();
+#endif
+  if (!region) {
+    fprintf(stderr, "Error opening region\n");
+    return 1;
+  }
+
+  while (1) {
+    buffer_id = region->WaitForNewFrameSince(&frame_num);
+    printf("Signaled frame_num = %d, buffer_id = %d\n", frame_num, buffer_id);
+  }
+
+  return 0;
+}
diff --git a/common/vsoc/lib/single_sided_signal.h b/common/vsoc/lib/single_sided_signal.h
new file mode 100644
index 0000000..a40c792
--- /dev/null
+++ b/common/vsoc/lib/single_sided_signal.h
@@ -0,0 +1,50 @@
+#pragma once
+
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <unistd.h>
+#include <linux/futex.h>
+#include <sys/syscall.h>
+
+
+// Signaling mechanism that allows threads to signal changes to shared
+// memory and to wait for signals.
+
+namespace vsoc {
+/**
+ * Defines the strategy for signaling among threads on a single kernel.
+ */
+namespace SingleSidedSignal {
+/**
+ * Waits for a signal, assuming the the word at addr matches expected_state.
+ * Will return immediately if the value does not match.
+ * Callers must be equipped to cope with spurious returns.
+ */
+static void AwaitSignal(uint32_t expected_state, uint32_t* uaddr) {
+  syscall(SYS_futex, uaddr, FUTEX_WAIT, expected_state, nullptr, nullptr, 0);
+}
+
+/**
+ * Sends a signal to every thread in AwaitSignal() using the address in
+ * uaddr.
+ */
+static void Signal(std::atomic<uint32_t>* uaddr) {
+  syscall(SYS_futex, reinterpret_cast<int32_t*>(uaddr), FUTEX_WAKE, -1, nullptr,
+          nullptr, 0);
+}
+}  // namespace SingleSidedSignal
+}  // namespace vsoc
diff --git a/common/vsoc/lib/socket_forward_layout.cpp b/common/vsoc/lib/socket_forward_layout.cpp
new file mode 100644
index 0000000..299ef70
--- /dev/null
+++ b/common/vsoc/lib/socket_forward_layout.cpp
@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include "common/vsoc/shm/socket_forward_layout.h"
+
+const char* vsoc::layout::socket_forward::SocketForwardLayout::region_name =
+  "socket_forward";
diff --git a/common/vsoc/lib/socket_forward_region_view.cpp b/common/vsoc/lib/socket_forward_region_view.cpp
new file mode 100644
index 0000000..2dbd2e8
--- /dev/null
+++ b/common/vsoc/lib/socket_forward_region_view.cpp
@@ -0,0 +1,250 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <cassert>
+
+#include "common/vsoc/lib/circqueue_impl.h"
+#include "common/vsoc/lib/lock_guard.h"
+#include "common/vsoc/lib/socket_forward_region_view.h"
+#include "common/vsoc/shm/lock.h"
+#include "common/vsoc/shm/socket_forward_layout.h"
+
+using vsoc::layout::socket_forward::Queue;
+using vsoc::layout::socket_forward::QueuePair;
+// store the read and write direction as variables to keep the ifdefs and macros
+// in later code to a minimum
+constexpr auto ReadDirection = &QueuePair::
+#ifdef CUTTLEFISH_HOST
+                                   guest_to_host;
+#else
+                                   host_to_guest;
+#endif
+
+constexpr auto WriteDirection = &QueuePair::
+#ifdef CUTTLEFISH_HOST
+                                    host_to_guest;
+#else
+                                    guest_to_host;
+#endif
+
+using vsoc::socket_forward::SocketForwardRegionView;
+
+vsoc::socket_forward::Packet vsoc::socket_forward::Packet::MakeBegin(
+    std::uint16_t port) {
+  auto packet = MakePacket(Header::BEGIN);
+  std::memcpy(packet.payload(), &port, sizeof port);
+  packet.set_payload_length(sizeof port);
+  return packet;
+}
+
+void SocketForwardRegionView::Recv(int connection_id, Packet* packet) {
+  CHECK(packet != nullptr);
+  do {
+    (data()->queues_[connection_id].*ReadDirection)
+        .queue.Read(this, reinterpret_cast<char*>(packet), sizeof *packet);
+  } while (packet->IsBegin());
+  CHECK(!packet->empty()) << "zero-size data message received";
+  CHECK_LE(packet->payload_length(), kMaxPayloadSize) << "invalid size";
+}
+
+bool SocketForwardRegionView::Send(int connection_id, const Packet& packet) {
+  CHECK(!packet.empty());
+  CHECK_LE(packet.payload_length(), kMaxPayloadSize);
+
+  (data()->queues_[connection_id].*WriteDirection)
+      .queue.Write(this, packet.raw_data(), packet.raw_data_length());
+  return true;
+}
+
+int SocketForwardRegionView::IgnoreUntilBegin(int connection_id) {
+  Packet packet{};
+  do {
+    (data()->queues_[connection_id].*ReadDirection)
+        .queue.Read(this, reinterpret_cast<char*>(&packet), sizeof packet);
+  } while (!packet.IsBegin());
+  return packet.port();
+}
+
+constexpr int kNumQueues =
+    static_cast<int>(vsoc::layout::socket_forward::kNumQueues);
+
+void SocketForwardRegionView::CleanUpPreviousConnections() {
+  data()->Recover();
+
+  static constexpr auto kRestartPacket = Packet::MakeRestart();
+  for (int connection_id = 0; connection_id < kNumQueues; ++connection_id) {
+    Send(connection_id, kRestartPacket);
+  }
+}
+
+SocketForwardRegionView::ConnectionViewCollection
+SocketForwardRegionView::AllConnections() {
+  SocketForwardRegionView::ConnectionViewCollection all_queues;
+  for (int connection_id = 0; connection_id < kNumQueues; ++connection_id) {
+    all_queues.emplace_back(this, connection_id);
+  }
+  return all_queues;
+}
+
+// --- Connection ---- //
+
+void SocketForwardRegionView::ShmConnectionView::Receiver::Recv(Packet* packet) {
+  std::unique_lock<std::mutex> guard(receive_thread_data_lock_);
+  while (received_packet_free_) {
+    receive_thread_data_cv_.wait(guard);
+  }
+  CHECK(received_packet_.IsData());
+  *packet = received_packet_;
+  received_packet_free_ = true;
+  receive_thread_data_cv_.notify_one();
+}
+
+bool SocketForwardRegionView::ShmConnectionView::Receiver::GotRecvClosed() const {
+      return received_packet_.IsRecvClosed() || (received_packet_.IsRestart()
+#ifdef CUTTLEFISH_HOST
+                                              && saw_data_
+#endif
+                                              );
+}
+
+bool SocketForwardRegionView::ShmConnectionView::Receiver::ShouldReceiveAnotherPacket() const {
+        return (received_packet_.IsRecvClosed() && !saw_end_) ||
+             (saw_end_ && received_packet_.IsEnd())
+#ifdef CUTTLEFISH_HOST
+             || (received_packet_.IsRestart() && !saw_data_) ||
+             (received_packet_.IsBegin())
+#endif
+             ;
+}
+
+void SocketForwardRegionView::ShmConnectionView::Receiver::ReceivePacket() {
+  view_->region_view()->Recv(view_->connection_id(), &received_packet_);
+}
+
+void SocketForwardRegionView::ShmConnectionView::Receiver::CheckPacketForRecvClosed() {
+      if (GotRecvClosed()) {
+        saw_recv_closed_ = true;
+        view_->MarkOtherSideRecvClosed();
+      }
+#ifdef CUTTLEFISH_HOST
+      if (received_packet_.IsData()) {
+        saw_data_ = true;
+      }
+#endif
+}
+
+void SocketForwardRegionView::ShmConnectionView::Receiver::CheckPacketForEnd() {
+  if (received_packet_.IsEnd() || received_packet_.IsRestart()) {
+    CHECK(!saw_end_ || received_packet_.IsRestart());
+    saw_end_ = true;
+  }
+}
+
+
+bool SocketForwardRegionView::ShmConnectionView::Receiver::ExpectMorePackets() const {
+  return !saw_recv_closed_ || !saw_end_;
+}
+
+void SocketForwardRegionView::ShmConnectionView::Receiver::UpdatePacketAndSignalAvailable() {
+  if (!received_packet_.IsData()) {
+    static constexpr auto kEmptyPacket = Packet::MakeData();
+    received_packet_ = kEmptyPacket;
+  }
+  received_packet_free_ = false;
+  receive_thread_data_cv_.notify_one();
+}
+
+void SocketForwardRegionView::ShmConnectionView::Receiver::Start() {
+  while (ExpectMorePackets()) {
+    std::unique_lock<std::mutex> guard(receive_thread_data_lock_);
+    while (!received_packet_free_) {
+      receive_thread_data_cv_.wait(guard);
+    }
+
+    do {
+      ReceivePacket();
+      CheckPacketForRecvClosed();
+    } while (ShouldReceiveAnotherPacket());
+
+    if (received_packet_.empty()) {
+      LOG(ERROR) << "Received empty packet.";
+    }
+
+    CheckPacketForEnd();
+
+    UpdatePacketAndSignalAvailable();
+  }
+}
+
+auto SocketForwardRegionView::ShmConnectionView::ResetAndConnect()
+    -> ShmSenderReceiverPair {
+  if (receiver_) {
+    receiver_->Join();
+  }
+
+  {
+    std::lock_guard<std::mutex> guard(*other_side_receive_closed_lock_);
+    other_side_receive_closed_ = false;
+  }
+
+#ifdef CUTTLEFISH_HOST
+  region_view()->IgnoreUntilBegin(connection_id());
+  region_view()->Send(connection_id(), Packet::MakeBegin(port_));
+#else
+  region_view()->Send(connection_id(), Packet::MakeBegin(port_));
+  port_ =
+      region_view()->IgnoreUntilBegin(connection_id());
+#endif
+
+  receiver_.reset(new Receiver{this});
+  return {ShmSender{this}, ShmReceiver{this}};
+}
+
+#ifdef CUTTLEFISH_HOST
+auto SocketForwardRegionView::ShmConnectionView::EstablishConnection(int port)
+    -> ShmSenderReceiverPair {
+  port_ = port;
+  return ResetAndConnect();
+}
+#else
+auto SocketForwardRegionView::ShmConnectionView::WaitForNewConnection()
+    -> ShmSenderReceiverPair {
+  port_ = 0;
+  return ResetAndConnect();
+}
+#endif
+
+bool SocketForwardRegionView::ShmConnectionView::Send(const Packet& packet) {
+  if (packet.empty()) {
+    LOG(ERROR) << "Sending empty packet";
+  }
+  if (packet.IsData() && IsOtherSideRecvClosed()) {
+    return false;
+  }
+  return region_view()->Send(connection_id(), packet);
+}
+
+void SocketForwardRegionView::ShmConnectionView::Recv(Packet* packet) {
+  receiver_->Recv(packet);
+}
+
+void SocketForwardRegionView::ShmReceiver::Recv(Packet* packet) {
+  view_->Recv(packet);
+}
+
+bool SocketForwardRegionView::ShmSender::Send(const Packet& packet) {
+  return view_->Send(packet);
+}
diff --git a/common/vsoc/lib/socket_forward_region_view.h b/common/vsoc/lib/socket_forward_region_view.h
new file mode 100644
index 0000000..c41517b
--- /dev/null
+++ b/common/vsoc/lib/socket_forward_region_view.h
@@ -0,0 +1,316 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * 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.
+ */
+#pragma once
+
+#include <cstdlib>
+#include <utility>
+#include <vector>
+#include <memory>
+
+#include "common/vsoc/lib/typed_region_view.h"
+#include "common/vsoc/shm/socket_forward_layout.h"
+
+namespace vsoc {
+namespace socket_forward {
+
+struct Header {
+  std::uint32_t payload_length;
+  enum MessageType : std::uint32_t {
+    DATA = 0,
+    BEGIN,
+    END,
+    RECV_CLOSED,  // indicate that this side's receive end is closed
+    RESTART,
+  };
+  MessageType message_type;
+};
+
+constexpr std::size_t kMaxPayloadSize =
+    layout::socket_forward::kMaxPacketSize - sizeof(Header);
+
+struct Packet {
+ private:
+  Header header_;
+  using Payload = char[kMaxPayloadSize];
+  Payload payload_data_;
+
+  static constexpr Packet MakePacket(Header::MessageType type) {
+    Packet packet{};
+    packet.header_.message_type = type;
+    return packet;
+  }
+
+ public:
+  // port is only revelant on the host-side.
+  static Packet MakeBegin(std::uint16_t port);
+
+  static constexpr Packet MakeEnd() { return MakePacket(Header::END); }
+
+  static constexpr Packet MakeRecvClosed() {
+    return MakePacket(Header::RECV_CLOSED);
+  }
+
+  static constexpr Packet MakeRestart() { return MakePacket(Header::RESTART); }
+
+  // NOTE payload and payload_length must still be set.
+  static constexpr Packet MakeData() { return MakePacket(Header::DATA); }
+
+  bool empty() const { return IsData() && header_.payload_length == 0; }
+
+  void set_payload_length(std::uint32_t length) {
+    CHECK_LE(length, sizeof payload_data_);
+    header_.payload_length = length;
+  }
+
+  Payload& payload() { return payload_data_; }
+
+  const Payload& payload() const { return payload_data_; }
+
+  constexpr std::uint32_t payload_length() const {
+    return header_.payload_length;
+  }
+
+  constexpr bool IsBegin() const {
+    return header_.message_type == Header::BEGIN;
+  }
+
+  constexpr bool IsEnd() const { return header_.message_type == Header::END; }
+
+  constexpr bool IsData() const { return header_.message_type == Header::DATA; }
+
+  constexpr bool IsRecvClosed() const {
+    return header_.message_type == Header::RECV_CLOSED;
+  }
+
+  constexpr bool IsRestart() const {
+    return header_.message_type == Header::RESTART;
+  }
+
+  constexpr std::uint16_t port() const {
+    CHECK(IsBegin());
+    std::uint16_t port_number{};
+    CHECK_EQ(payload_length(), sizeof port_number);
+    std::memcpy(&port_number, payload(), sizeof port_number);
+    return port_number;
+  }
+
+  char* raw_data() { return reinterpret_cast<char*>(this); }
+
+  const char* raw_data() const { return reinterpret_cast<const char*>(this); }
+
+  constexpr size_t raw_data_length() const {
+    return payload_length() + sizeof header_;
+  }
+};
+
+static_assert(sizeof(Packet) == layout::socket_forward::kMaxPacketSize, "");
+static_assert(std::is_pod<Packet>{}, "");
+
+// Data sent will start with a uint32_t indicating the number of bytes being
+// sent, followed be the data itself
+class SocketForwardRegionView
+    : public TypedRegionView<SocketForwardRegionView,
+                             layout::socket_forward::SocketForwardLayout> {
+ private:
+  // Returns an empty data packet if the other side is closed.
+  void Recv(int connection_id, Packet* packet);
+  // Returns true on success
+  bool Send(int connection_id, const Packet& packet);
+
+  // skip everything in the connection queue until seeing a BEGIN packet.
+  // returns port from begin packet.
+  int IgnoreUntilBegin(int connection_id);
+
+ public:
+  class ShmSender;
+  class ShmReceiver;
+
+  using ShmSenderReceiverPair = std::pair<ShmSender, ShmReceiver>;
+
+  class ShmConnectionView {
+   public:
+    ShmConnectionView(SocketForwardRegionView* region_view, int connection_id)
+        : region_view_{region_view}, connection_id_{connection_id} {}
+
+#ifdef CUTTLEFISH_HOST
+    ShmSenderReceiverPair EstablishConnection(int port);
+#else
+    // Should not be called while there is an active ShmSender or ShmReceiver
+    // for this connection.
+    ShmSenderReceiverPair WaitForNewConnection();
+#endif
+
+    int port() const { return port_; }
+
+    bool Send(const Packet& packet);
+    void Recv(Packet* packet);
+
+    ShmConnectionView(const ShmConnectionView&) = delete;
+    ShmConnectionView& operator=(const ShmConnectionView&) = delete;
+
+    // Moving invalidates all existing ShmSenders and ShmReceiver
+    ShmConnectionView(ShmConnectionView&&) = default;
+    ShmConnectionView& operator=(ShmConnectionView&&) = default;
+    ~ShmConnectionView() = default;
+
+    // NOTE should only be used for debugging/logging purposes.
+    // connection_ids are an implementation detail that are currently useful for
+    // debugging, but may go away in the future.
+    int connection_id() const { return connection_id_; }
+
+   private:
+    SocketForwardRegionView* region_view() const { return region_view_; }
+
+    bool IsOtherSideRecvClosed() {
+      std::lock_guard<std::mutex> guard(*other_side_receive_closed_lock_);
+      return other_side_receive_closed_;
+    }
+
+    void MarkOtherSideRecvClosed() {
+      std::lock_guard<std::mutex> guard(*other_side_receive_closed_lock_);
+      other_side_receive_closed_ = true;
+    }
+
+    void ReceiverThread();
+    ShmSenderReceiverPair ResetAndConnect();
+
+    class Receiver {
+     public:
+      Receiver(ShmConnectionView* view)
+          : view_{view}
+      {
+        receiver_thread_ = std::thread([this] { Start(); });
+      }
+
+      void Recv(Packet* packet);
+
+      void Join() { receiver_thread_.join(); }
+
+      Receiver(const Receiver&) = delete;
+      Receiver& operator=(const Receiver&) = delete;
+
+      ~Receiver() = default;
+     private:
+      void Start();
+      bool GotRecvClosed() const;
+      void ReceivePacket();
+      void CheckPacketForRecvClosed();
+      void CheckPacketForEnd();
+      void UpdatePacketAndSignalAvailable();
+      bool ShouldReceiveAnotherPacket() const;
+      bool ExpectMorePackets() const;
+
+      std::mutex receive_thread_data_lock_;
+      std::condition_variable receive_thread_data_cv_;
+      bool received_packet_free_ = true;
+      Packet received_packet_{};
+
+      ShmConnectionView* view_{};
+      bool saw_recv_closed_ = false;
+      bool saw_end_ = false;
+#ifdef CUTTLEFISH_HOST
+      bool saw_data_ = false;
+#endif
+
+      std::thread receiver_thread_;
+    };
+
+    SocketForwardRegionView* region_view_{};
+    int connection_id_ = -1;
+    int port_ = -1;
+
+    std::unique_ptr<std::mutex> other_side_receive_closed_lock_ =
+        std::unique_ptr<std::mutex>{new std::mutex{}};
+    bool other_side_receive_closed_ = false;
+
+    std::unique_ptr<Receiver> receiver_;
+  };
+
+  class ShmSender {
+   public:
+    explicit ShmSender(ShmConnectionView* view) : view_{view} {}
+
+    ShmSender(const ShmSender&) = delete;
+    ShmSender& operator=(const ShmSender&) = delete;
+
+    ShmSender(ShmSender&&) = default;
+    ShmSender& operator=(ShmSender&&) = default;
+    ~ShmSender() = default;
+
+    // Returns true on success
+    bool Send(const Packet& packet);
+
+   private:
+    struct EndSender {
+      void operator()(ShmConnectionView* view) const {
+        if (view) {
+          view->Send(Packet::MakeEnd());
+        }
+      }
+    };
+
+    // Doesn't actually own the View, responsible for sending the End
+    // indicator and marking the sending side as disconnected.
+    std::unique_ptr<ShmConnectionView, EndSender> view_;
+  };
+
+  class ShmReceiver {
+   public:
+    explicit ShmReceiver(ShmConnectionView* view) : view_{view} {}
+    ShmReceiver(const ShmReceiver&) = delete;
+    ShmReceiver& operator=(const ShmReceiver&) = delete;
+
+    ShmReceiver(ShmReceiver&&) = default;
+    ShmReceiver& operator=(ShmReceiver&&) = default;
+    ~ShmReceiver() = default;
+
+    void Recv(Packet* packet);
+
+   private:
+    struct RecvClosedSender {
+      void operator()(ShmConnectionView* view) const {
+        if (view) {
+          view->Send(Packet::MakeRecvClosed());
+        }
+      }
+    };
+
+    // Doesn't actually own the view, responsible for sending the RecvClosed
+    // indicator
+    std::unique_ptr<ShmConnectionView, RecvClosedSender> view_{};
+  };
+
+  friend ShmConnectionView;
+
+  SocketForwardRegionView() = default;
+  ~SocketForwardRegionView() = default;
+  SocketForwardRegionView(const SocketForwardRegionView&) = delete;
+  SocketForwardRegionView& operator=(const SocketForwardRegionView&) = delete;
+
+  using ConnectionViewCollection = std::vector<ShmConnectionView>;
+  ConnectionViewCollection AllConnections();
+
+  int port(int connection_id);
+  void CleanUpPreviousConnections();
+
+ private:
+#ifndef CUTTLEFISH_HOST
+  std::uint32_t last_seq_number_{};
+#endif
+};
+
+}  // namespace socket_forward
+}  // namespace vsoc
diff --git a/common/vsoc/lib/typed_region_view.h b/common/vsoc/lib/typed_region_view.h
new file mode 100644
index 0000000..ead7412
--- /dev/null
+++ b/common/vsoc/lib/typed_region_view.h
@@ -0,0 +1,104 @@
+#pragma once
+
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+// Object that represents a region on the Host
+
+#include "common/vsoc/lib/region_view.h"
+
+#include <map>
+#include <mutex>
+#include <string>
+
+namespace vsoc {
+
+/**
+ * This class adds methods that depend on the Region's type.
+ * This may be directly constructed. However, it may be more effective to
+ * subclass it, adding region-specific methods.
+ *
+ * Layout should be VSoC shared memory compatible, defined in common/vsoc/shm,
+ * and should have a constant string region name.
+ */
+template <typename ViewType, typename LayoutType>
+class TypedRegionView : public RegionView {
+ public:
+  using Layout = LayoutType;
+
+  /* Returns a pointer to the region with a type that matches the layout */
+  LayoutType* data() {
+    return this->GetLayoutPointer<LayoutType>();
+  }
+
+  const LayoutType& data() const {
+    return this->region_offset_to_reference<LayoutType>(
+        control_->region_desc().offset_of_region_data);
+  }
+
+ protected:
+#if defined(CUTTLEFISH_HOST)
+  bool Open(const char* domain) {
+    return RegionView::Open(LayoutType::region_name, domain);
+  }
+#else
+  bool Open() {
+    return RegionView::Open(LayoutType::region_name);
+  }
+#endif
+
+ public:
+  // Implementation of the region singletons.
+#if defined(CUTTLEFISH_HOST)
+  static ViewType* GetInstance(const char* domain) {
+    static std::mutex mtx;
+    static std::map<std::string, std::unique_ptr<ViewType>> instances;
+    if (!domain) {
+      return nullptr;
+    }
+    std::lock_guard<std::mutex> lock(mtx);
+    // Get a reference to the actual unique_ptr that's stored in the map, if
+    // there wasn't one it will be default constructed pointing to nullptr.
+    auto& instance = instances[domain];
+    if (!instance) {
+      // Update the referenced pointer with the address of the newly created
+      // region view.
+      instance.reset(new ViewType{});
+      if (!instance->Open(domain)) {
+        instance.reset();
+      }
+    }
+    return instance.get();
+  }
+#else
+  static ViewType* GetInstance() {
+    static std::mutex mtx;
+    static std::unique_ptr<ViewType> instance;
+    std::lock_guard<std::mutex> lock(mtx);
+    if (!instance) {
+      instance.reset(new ViewType{});
+      if (!instance->Open()) {
+        instance.reset();
+      }
+    }
+    return instance.get();
+  }
+#endif
+
+
+};
+
+}  // namespace vsoc
diff --git a/common/vsoc/lib/vsoc_audio_message.h b/common/vsoc/lib/vsoc_audio_message.h
new file mode 100644
index 0000000..230c4de
--- /dev/null
+++ b/common/vsoc/lib/vsoc_audio_message.h
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+#pragma once
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <time.h>
+
+#include <system/audio.h>
+
+typedef uint32_t size32_t;
+
+struct timespec32 {
+  uint32_t tv_sec;
+  uint32_t tv_nsec;
+
+  timespec32() = default;
+
+  timespec32(const timespec &from)
+      : tv_sec(from.tv_sec),
+        tv_nsec(from.tv_nsec) {
+  }
+};
+
+struct gce_audio_message {
+  static const size32_t kMaxAudioFrameLen = 65536;
+  enum message_t {
+    UNKNOWN = 0,
+    DATA_SAMPLES = 1,
+    OPEN_INPUT_STREAM = 2,
+    OPEN_OUTPUT_STREAM = 3,
+    CLOSE_INPUT_STREAM = 4,
+    CLOSE_OUTPUT_STREAM = 5,
+    CONTROL_PAUSE = 100
+  };
+  // Size of the header + data. Used to frame when we're on TCP.
+  size32_t total_size;
+  // Size of the audio header
+  size32_t header_size;
+  message_t message_type;
+  // Identifier for the stream.
+  uint32_t stream_number;
+  // HAL assigned frame number, starts from 0.
+  int64_t frame_num;
+  // MONOTONIC_TIME when these frames were presented to the HAL.
+  timespec32 time_presented;
+  // Sample rate from the audio configuration.
+  uint32_t frame_rate;
+  // Channel mask from the audio configuration.
+  audio_channel_mask_t channel_mask;
+  // Format from the audio configuration.
+  audio_format_t format;
+  // Size of each frame in bytes.
+  size32_t frame_size;
+  // Number of frames that were presented to the HAL.
+  size32_t num_frames_presented;
+  // Number of frames that the HAL accepted.
+  //   For blocking audio this will be the same as num_frames.
+  //   For non-blocking audio this may be less.
+  size32_t num_frames_accepted;
+  // Count of the number of packets that were dropped because they would
+  // have blocked the HAL or exceeded the maximum message size.
+  size32_t num_packets_dropped;
+  // Count of the number of packets that were shortened to fit within
+  // kMaxAudioFrameLen.
+  size32_t num_packets_shortened;
+  // num_frames_presented (not num_frames_accepted) will follow here.
+
+  gce_audio_message() :
+      total_size(sizeof(gce_audio_message)),
+      header_size(sizeof(gce_audio_message)),
+      message_type(UNKNOWN),
+      stream_number(0),
+      frame_num(0),
+      frame_rate(0),
+      channel_mask(0),
+      format(AUDIO_FORMAT_DEFAULT),
+      frame_size(0),
+      num_frames_presented(0),
+      num_frames_accepted(0),
+      num_packets_dropped(0),
+      num_packets_shortened(0) {
+    time_presented.tv_sec = 0;
+    time_presented.tv_nsec = 0;
+  }
+};
diff --git a/common/vsoc/lib/vsoc_memory.cpp b/common/vsoc/lib/vsoc_memory.cpp
new file mode 100644
index 0000000..017ab13
--- /dev/null
+++ b/common/vsoc/lib/vsoc_memory.cpp
@@ -0,0 +1,194 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include "common/vsoc/lib/vsoc_memory.h"
+
+#include <string.h>
+#include <unistd.h>
+
+#include <map>
+#include <string>
+#include <type_traits>
+
+#include "common/libs/glog/logging.h"
+#include "common/vsoc/shm/audio_data_layout.h"
+#include "common/vsoc/shm/base.h"
+#include "common/vsoc/shm/e2e_test_region_layout.h"
+#include "common/vsoc/shm/gralloc_layout.h"
+#include "common/vsoc/shm/input_events_layout.h"
+#include "common/vsoc/shm/managed_e2e_test_region_layout.h"
+#include "common/vsoc/shm/screen_layout.h"
+#include "common/vsoc/shm/socket_forward_layout.h"
+
+#include "uapi/vsoc_shm.h"
+
+namespace {
+
+// Takes a vector of objects and returns a vector of pointers to those objects.
+template <typename T, typename R>
+std::vector<R*> GetConstPointers(const std::vector<T>& v) {
+  std::vector<R*> result;
+  result.reserve(v.size());
+  for (auto& element : v) {
+    result.push_back(&element);
+  }
+  return result;
+}
+}  // namespace
+
+namespace vsoc {
+
+namespace {
+
+class VSoCRegionLayoutImpl : public VSoCRegionLayout {
+ public:
+  VSoCRegionLayoutImpl(const char* region_name, size_t layout_size,
+                       int guest_to_host_signal_table_log_size,
+                       int host_to_guest_signal_table_log_size,
+                       const char* managed_by)
+      : region_name_(region_name),
+        layout_size_(layout_size),
+        guest_to_host_signal_table_log_size_(
+            guest_to_host_signal_table_log_size),
+        host_to_guest_signal_table_log_size_(
+            host_to_guest_signal_table_log_size),
+        managed_by_(managed_by) {
+  }
+  VSoCRegionLayoutImpl(const VSoCRegionLayoutImpl&) = default;
+
+  const char* region_name() const override { return region_name_; }
+  const char* managed_by() const override { return managed_by_; }
+
+  size_t layout_size() const override { return layout_size_; }
+  int guest_to_host_signal_table_log_size() const override {
+    return guest_to_host_signal_table_log_size_;
+  }
+  int host_to_guest_signal_table_log_size() const override {
+    return host_to_guest_signal_table_log_size_;
+  }
+
+ private:
+  const char* region_name_{};
+  const size_t layout_size_{};
+  const int guest_to_host_signal_table_log_size_{};
+  const int host_to_guest_signal_table_log_size_{};
+  const char* managed_by_{};
+};
+
+class VSoCMemoryLayoutImpl : public VSoCMemoryLayout {
+ public:
+  explicit VSoCMemoryLayoutImpl(std::vector<VSoCRegionLayoutImpl>&& regions)
+      : regions_(regions), region_idx_by_name_(GetNameToIndexMap(regions)) {
+    for (size_t i = 0; i < regions_.size(); ++i) {
+      // This link could be resolved later, but doing it here disables
+      // managed_by cycles among the regions.
+      if (regions[i].managed_by() &&
+          !region_idx_by_name_.count(regions[i].managed_by())) {
+        LOG(FATAL) << regions[i].region_name()
+                   << " managed by unknown region: " << regions[i].managed_by()
+                   << ". Manager Regions must be declared before the regions "
+                      "they manage";
+      }
+    }
+  }
+
+  ~VSoCMemoryLayoutImpl() = default;
+
+  std::vector<const VSoCRegionLayout*> GetRegions() const {
+    static std::vector<const VSoCRegionLayout*> ret =
+        GetConstPointers<VSoCRegionLayoutImpl, const VSoCRegionLayout>(
+            regions_);
+    return ret;
+  }
+
+  const VSoCRegionLayout* GetRegionByName(
+      const char* region_name) const override {
+    if (!region_idx_by_name_.count(region_name)) {
+      return nullptr;
+    }
+    return &regions_[region_idx_by_name_.at(region_name)];
+  }
+
+ protected:
+  VSoCMemoryLayoutImpl() = delete;
+  VSoCMemoryLayoutImpl(const VSoCMemoryLayoutImpl&) = delete;
+
+  // Helper function to allow the creation of the name to index map in the
+  // constructor and allow the field to be const
+  static std::map<const char*, size_t> GetNameToIndexMap(
+      const std::vector<VSoCRegionLayoutImpl>& regions) {
+    std::map<const char*, size_t> result;
+    for (size_t index = 0; index < regions.size(); ++index) {
+      auto region_name = regions[index].region_name();
+      if (result.count(region_name)) {
+        LOG(FATAL) << region_name << " used for more than one region";
+      }
+      result[region_name] = index;
+    }
+    return result;
+  }
+
+  std::vector<VSoCRegionLayoutImpl> regions_;
+  const std::map<const char*, size_t> region_idx_by_name_;
+};
+
+template <class R>
+VSoCRegionLayoutImpl ValidateAndBuildLayout(int g_to_h_signal_table_log_size,
+                                            int h_to_g_signal_table_log_size,
+                                            const char* managed_by = nullptr) {
+  // Double check that the Layout is a valid shm type.
+  ASSERT_SHM_COMPATIBLE(R);
+  return VSoCRegionLayoutImpl(R::region_name, sizeof(R),
+                              g_to_h_signal_table_log_size,
+                              h_to_g_signal_table_log_size, managed_by);
+}
+
+}  // namespace
+
+VSoCMemoryLayout* VSoCMemoryLayout::Get() {
+  /*******************************************************************
+   * Make sure the first region is not the manager of other regions. *
+   *       This error will only be caught on runtime!!!!!            *
+   *******************************************************************/
+  static VSoCMemoryLayoutImpl layout(
+      {ValidateAndBuildLayout<layout::input_events::InputEventsLayout>(2, 2),
+       ValidateAndBuildLayout<layout::screen::ScreenLayout>(2, 2),
+       ValidateAndBuildLayout<layout::gralloc::GrallocManagerLayout>(2, 2),
+       ValidateAndBuildLayout<layout::gralloc::GrallocBufferLayout>(
+           0, 0,
+           /* managed_by */ layout::gralloc::GrallocManagerLayout::region_name),
+       ValidateAndBuildLayout<layout::socket_forward::SocketForwardLayout>(7,
+                                                                           7),
+       ValidateAndBuildLayout<layout::e2e_test::E2EPrimaryTestRegionLayout>(1,
+                                                                            1),
+       ValidateAndBuildLayout<layout::e2e_test::E2ESecondaryTestRegionLayout>(
+           1, 1),
+       ValidateAndBuildLayout<layout::e2e_test::E2EManagerTestRegionLayout>(1,
+                                                                            1),
+       ValidateAndBuildLayout<layout::e2e_test::E2EManagedTestRegionLayout>(1,
+                                                                            1),
+       ValidateAndBuildLayout<layout::audio_data::AudioDataLayout>(2, 2)});
+
+  // We need this code to compile on both sides to enforce the static checks,
+  // but should only be used host side.
+#if !defined(CUTTLEFISH_HOST)
+  LOG(FATAL) << "Memory layout should not be used guest side, use region "
+                "classes or the vsoc driver directly instead.";
+#endif
+  return &layout;
+}
+
+}  // namespace vsoc
diff --git a/common/vsoc/lib/vsoc_memory.h b/common/vsoc/lib/vsoc_memory.h
new file mode 100644
index 0000000..49853f9
--- /dev/null
+++ b/common/vsoc/lib/vsoc_memory.h
@@ -0,0 +1,53 @@
+#pragma once
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <stdint.h>
+
+#include <vector>
+
+namespace vsoc {
+
+class VSoCRegionLayout {
+ public:
+  virtual const char* region_name() const = 0;
+  virtual const char* managed_by() const = 0;
+
+  virtual size_t layout_size() const = 0;
+  virtual int guest_to_host_signal_table_log_size() const = 0;
+  virtual int host_to_guest_signal_table_log_size() const = 0;
+ protected:
+  VSoCRegionLayout() = default;
+  virtual ~VSoCRegionLayout() = default;
+};
+
+class VSoCMemoryLayout {
+ public:
+  // Returns a pointer to the memory layout singleton.
+  static VSoCMemoryLayout* Get();
+
+  VSoCMemoryLayout(const VSoCMemoryLayout&) = delete;
+  VSoCMemoryLayout(VSoCMemoryLayout&&) = delete;
+
+  virtual std::vector<const VSoCRegionLayout *> GetRegions() const = 0;
+  virtual const VSoCRegionLayout* GetRegionByName(
+      const char* region_name) const = 0;
+ protected:
+  VSoCMemoryLayout() = default;
+  virtual ~VSoCMemoryLayout() = default;
+};
+
+}  // namespace vsoc
diff --git a/common/vsoc/shm/audio_data_layout.h b/common/vsoc/shm/audio_data_layout.h
new file mode 100644
index 0000000..3991ea0
--- /dev/null
+++ b/common/vsoc/shm/audio_data_layout.h
@@ -0,0 +1,38 @@
+#pragma once
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include "common/vsoc/shm/base.h"
+#include "common/vsoc/shm/circqueue.h"
+
+// Memory layout for region carrying audio data from audio HAL to client.
+
+namespace vsoc {
+namespace layout {
+namespace audio_data {
+
+struct AudioDataLayout : public RegionLayout {
+    static const char *const region_name;
+    static constexpr size_t layout_size = 16396;
+
+    // size = 2^14 = 16384, packets are up to 4KB bytes each.
+    CircularPacketQueue<14, 4096> audio_queue;
+};
+ASSERT_SHM_COMPATIBLE(AudioDataLayout);
+
+}  // namespace audio_data
+}  // namespace layout
+}  // namespace vsoc
diff --git a/common/vsoc/shm/base.h b/common/vsoc/shm/base.h
new file mode 100644
index 0000000..f5abec8
--- /dev/null
+++ b/common/vsoc/shm/base.h
@@ -0,0 +1,82 @@
+#pragma once
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <stdint.h>
+#include <type_traits>
+
+// Base macros for all layout structures.
+// ShmTypeValidator provides meaningful information about the type size
+// mismatch in compilation error messages, eg.
+//
+// error:
+//    static_assert failed "Class size changed, update the layout_size field"
+//    static_assert(Current == Expected,
+// note: in instantiation of template class
+//    'ShmTypeValidator<vsoc::layout::myclass::ClassName>'
+//    requested here ASSERT_SHM_COMPATIBLE(ClassName);
+//
+template <typename Type, size_t expected_size = Type::layout_size>
+struct ShmTypeValidator {
+  static_assert(sizeof(Type) == expected_size,
+                "Class size changed, update the layout_size field");
+  static_assert(std::is_trivial<Type>(), "Class uses features that are unsafe");
+  static constexpr bool valid =
+      sizeof(Type) == expected_size && std::is_trivial<Type>();
+};
+
+#define ASSERT_SHM_COMPATIBLE(T)            \
+  static_assert(ShmTypeValidator<T>::valid, \
+                "Compilation error. Please fix above errors and retry.")
+
+namespace vsoc {
+namespace layout {
+
+/**
+ * Memory is shared between Guest and Host kernels. In some cases we need
+ * flag to indicate which side we're on. In those cases we'll use this
+ * simple structure.
+ *
+ * These are carefully formatted to make Guest and Host a bitfield.
+ */
+enum Sides : uint32_t {
+  NoSides = 0,
+  Guest = 1,
+  Host = 2,
+  Both = 3,
+#ifdef CUTTLEFISH_HOST
+  OurSide = Host,
+  Peer = Guest
+#else
+  OurSide = Guest,
+  Peer = Host
+#endif
+};
+// Enums can't have static members, so can't use the macro here.
+  static_assert(ShmTypeValidator<Sides, 4>::valid,
+              "Compilation error. Please fix above errors and retry.");
+
+/**
+ * Base class for all region layout structures.
+ */
+class RegionLayout {
+public:
+  static constexpr size_t layout_size = 1;
+};
+ASSERT_SHM_COMPATIBLE(RegionLayout);
+
+}  // namespace layout
+}  // namespace vsoc
diff --git a/common/vsoc/shm/circqueue.h b/common/vsoc/shm/circqueue.h
new file mode 100644
index 0000000..05893bf
--- /dev/null
+++ b/common/vsoc/shm/circqueue.h
@@ -0,0 +1,203 @@
+#pragma once
+
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+// Memory layout for byte-oriented circular queues
+
+#include <atomic>
+#include <cstdint>
+#include "common/vsoc/shm/base.h"
+#include "common/vsoc/shm/lock.h"
+
+struct iovec;
+
+namespace vsoc {
+class RegionSignalingInterface;
+namespace layout {
+
+/**
+ * Base classes for all spinlock protected circular queues.
+ * This class should be embedded in the per-region data structure that is used
+ * as the parameter to TypedRegion.
+ */
+template <uint32_t SizeLog2>
+class CircularQueueBase {
+ public:
+  static constexpr size_t layout_size = (1 << SizeLog2) + 12;
+
+ private:
+  CircularQueueBase() = delete;
+  CircularQueueBase(const CircularQueueBase&) = delete;
+  CircularQueueBase& operator=(const CircularQueueBase&) = delete;
+
+ protected:
+  /**
+   * Specifies a part of the queue. Note, the given indexes must be masked
+   * before they can be used against buffer_
+   */
+  struct Range {
+    // Points to the first bytes that is part of the range
+    uint32_t start_idx;
+    // Points to the first byte that is not in the range. This is similar to
+    // the STL end iterator.
+    uint32_t end_idx;
+  };
+  static const uintptr_t BufferSize = (1 << SizeLog2);
+
+  /**
+   * Copy bytes from buffer_in into the part of the queue specified by Range.
+   */
+  void CopyInRange(const char* buffer_in, const Range& t);
+
+  /**
+   * Copy the bytes specified by range to the given buffer. They caller must
+   * ensure that the buffer is large enough to hold the content of the range.
+   */
+  void CopyOutRange(const Range& t, char* buffer_out);
+
+  /**
+   * Wait until data becomes available in the queue. The caller must have
+   * called Lock() before invoking this. The caller must call Unlock()
+   * after this returns.
+   */
+  void WaitForDataLocked(RegionSignalingInterface* r);
+
+  /**
+   * Reserve space in the queue for writing. The caller must have called Lock()
+   * before invoking this. The caller must call Unlock() after this returns.
+   * Indexes pointing to the reserved space will be placed in range.
+   * On success this returns bytes.
+   * On failure a negative errno indicates the problem. -ENOSPC indicates that
+   * bytes > the queue size, -EWOULDBLOCK indicates that the call would block
+   * waiting for space but was requested non bloking.
+   */
+  intptr_t WriteReserveLocked(RegionSignalingInterface* r, size_t bytes,
+                              Range* t, bool non_blocking);
+
+  bool RecoverBase() {
+    return lock_.Recover();
+  }
+
+  // Note: Both of these fields may hold values larger than the buffer size,
+  // they should be interpreted modulo the buffer size. This fact along with the
+  // buffer size being a power of two greatly simplyfies the index calculations.
+  // Advances when a reader has finished with buffer space
+  std::atomic<uint32_t> r_released_;
+  // Advances when buffer space is filled and ready for a reader
+  std::atomic<uint32_t> w_pub_;
+  // Spinlock that protects the region. 0 means unlocked
+  SpinLock lock_;
+  // The actual memory in the buffer
+  char buffer_[BufferSize];
+};
+using CircularQueueBase64k = CircularQueueBase<16>;
+ASSERT_SHM_COMPATIBLE(CircularQueueBase64k);
+
+/**
+ * Byte oriented circular queue. Reads will always return some data, but
+ * may return less data than requested. Writes will always write all of the
+ * data or return an error.
+ */
+template <uint32_t SizeLog2>
+class CircularByteQueue : public CircularQueueBase<SizeLog2> {
+ public:
+  static constexpr size_t layout_size =
+      CircularQueueBase<SizeLog2>::layout_size;
+  /**
+   * Read at most max_size bytes from the qeueue, placing them in buffer_out
+   */
+  intptr_t Read(RegionSignalingInterface* r, char* buffer_out,
+                std::size_t max_size);
+  /**
+   * Write all of the given bytes into the queue. If non_blocking isn't set the
+   * call may block until there is enough available space in the queue. On
+   * success the return value will match bytes. On failure a negative errno is
+   * returned. -ENOSPC: If the queue size is smaller than the number of bytes to
+   * write. -EWOULDBLOCK: If non_blocking is true and there is not enough free
+   * space.
+   */
+  intptr_t Write(RegionSignalingInterface* r, const char* buffer_in,
+                 std::size_t bytes, bool non_blocking = false);
+
+  bool Recover() {
+    return this->RecoverBase();
+  }
+
+ protected:
+  using Range = typename CircularQueueBase<SizeLog2>::Range;
+};
+using CircularByteQueue64k = CircularByteQueue<16>;
+ASSERT_SHM_COMPATIBLE(CircularByteQueue64k);
+
+/**
+ * Packet oriented circular queue. Reads will either return data or an error.
+ * Each return from read corresponds to a call to write and returns all of the
+ * data from that corresponding Write().
+ */
+template <uint32_t SizeLog2, uint32_t MaxPacketSize>
+class CircularPacketQueue : public CircularQueueBase<SizeLog2> {
+ public:
+  static constexpr size_t layout_size =
+      CircularQueueBase<SizeLog2>::layout_size;
+
+  /**
+   * Read a single packet from the queue, placing its data into buffer_out.
+   * If max_size indicates that buffer_out cannot hold the entire packet
+   * this function will return -ENOSPC.
+   */
+  intptr_t Read(RegionSignalingInterface* r, char* buffer_out,
+                std::size_t max_size);
+
+  /**
+   * Writes [buffer_in, buffer_in + bytes) to the queue.
+   * If the number of bytes to be written exceeds the size of the queue
+   * -ENOSPC will be returned.
+   * If non_blocking is true and there is not enough free space on the queue to
+   * write all the data -EWOULDBLOCK will be returned.
+   */
+  intptr_t Write(RegionSignalingInterface* r, const char* buffer_in,
+                 uint32_t bytes, bool non_blocking = false);
+
+  /**
+   * Writes the data referenced by the given iov scatter/gather array to the
+   * queue.
+   * If the number of bytes to be written exceeds the size of the queue
+   * -ENOSPC will be returned.
+   * If non_blocking is true and there is not enough free space on the queue to
+   * write all the data -EWOULDBLOCK will be returned.
+   */
+  intptr_t Writev(
+          RegionSignalingInterface *r,
+          const iovec *iov,
+          size_t iov_count,
+          bool non_blocking = false);
+
+  bool Recover() {
+    return this->RecoverBase();
+  }
+
+ protected:
+  static_assert(CircularQueueBase<SizeLog2>::BufferSize >= MaxPacketSize,
+                "Buffer is too small to hold the maximum sized packet");
+  using Range = typename CircularQueueBase<SizeLog2>::Range;
+  intptr_t CalculateBufferedSize(size_t payload);
+};
+using CircularPacketQueue64k = CircularPacketQueue<16, 1024>;
+ASSERT_SHM_COMPATIBLE(CircularPacketQueue64k);
+
+}  // namespace layout
+}  // namespace vsoc
diff --git a/common/vsoc/shm/e2e_test_region_layout.h b/common/vsoc/shm/e2e_test_region_layout.h
new file mode 100644
index 0000000..f3ae615
--- /dev/null
+++ b/common/vsoc/shm/e2e_test_region_layout.h
@@ -0,0 +1,168 @@
+#pragma once
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <atomic>
+#include <cstdint>
+#include "common/vsoc/shm/base.h"
+
+// Memory layout for a region that supports end-to-end (E2E) testing of
+// shared memory regions. This verifies that all sorts of things work along the
+// the path:
+//
+//   host libraries <-> ivshmem server <-> kernel <-> guest libraries
+//
+// This is intentionally not a unit test. The primary source of errors along
+// this path is a misunderstanding and/or inconsistency in one of the
+// interfaces. Introducing mocks would allow these errors to go undetected.
+// Another way of looking at it is that the mocks would end up being a
+// a copy-and-paste job, making a series of change-detector tests.
+//
+// These tests are actually run on every device boot to verify that things are
+// ok.
+
+namespace vsoc {
+namespace layout {
+
+namespace e2e_test {
+
+/**
+ * Flags that are used to indicate test status. Some of the latter testing
+ * stages rely on initializion that must be done on the peer.
+ */
+enum E2ETestStage : uint32_t {
+  // No tests have passed
+  E2E_STAGE_NONE = 0,
+  // This side has finished writing its pattern to the region
+  E2E_MEMORY_FILLED = 1,
+  // This side has confirmed that it can see its peer's writes to the region
+  E2E_PEER_MEMORY_READ = 2,
+};
+static_assert(ShmTypeValidator<E2ETestStage, 4>::valid,
+              "Compilation error. Please fix above errors and retry.");
+
+/**
+ * Structure that grants permission to write in the region to either the guest
+ * or the host. This size of these fields is arbitrary.
+ */
+struct E2EMemoryFill {
+  static constexpr size_t layout_size = 64;
+
+  static const std::size_t kOwnedFieldSize = 32;
+
+  // The compiler must not attempt to optimize away reads and writes to the
+  // shared memory window. This is pretty typical when dealing with devices
+  // doing memory mapped I/O.
+  char host_writable[kOwnedFieldSize];
+  char guest_writable[kOwnedFieldSize];
+};
+ASSERT_SHM_COMPATIBLE(E2EMemoryFill);
+
+/**
+ * Structure that grants permission to write in the region to either the guest
+ * or the host. This size of these fields is arbitrary.
+ */
+class E2ETestStageRegister {
+ public:
+  static constexpr size_t layout_size = 4;
+
+  E2ETestStage value() const {
+    return value_;
+  }
+
+  void set_value(E2ETestStage new_value) { value_ = new_value; }
+
+ protected:
+  // The compiler must not attempt to optimize away reads and writes to the
+  // shared memory window. This is pretty typical when dealing with devices
+  // doing memory mapped I/O.
+  E2ETestStage value_;
+};
+ASSERT_SHM_COMPATIBLE(E2ETestStageRegister);
+
+/**
+ * Describes the layout of the regions used for the end-to-end test. There
+ * are multiple regions: primary and secondary, so some details like the region
+ * name must wait until later.
+ */
+class E2ETestRegionLayout : public ::vsoc::layout::RegionLayout {
+ public:
+  static constexpr size_t layout_size = 2 * E2ETestStageRegister::layout_size +
+                                        3 * 4 + E2EMemoryFill::layout_size;
+
+  /**
+   * Computes how many E2EMemoryFill records we need to cover the region.
+   * Covering the entire region during the test ensures that everything is
+   * mapped and coherent between guest and host.
+   */
+  static std::size_t NumFillRecords(std::size_t region_size) {
+    if (region_size < sizeof(E2ETestRegionLayout)) {
+      return 0;
+    }
+    // 1 + ... An array of size 1 is allocated in the E2ETestRegion.
+    // TODO(ghartman): AddressSanitizer may find this sort of thing to be
+    // alarming.
+    return 1 +
+           (region_size - sizeof(E2ETestRegionLayout)) / sizeof(E2EMemoryFill);
+  }
+  // The number of test stages that have completed on the guest
+  // Later host tests will wait on this
+  E2ETestStageRegister guest_status;
+  // The number of test stages that have completed on the host
+  // Later guest tests will wait on this
+  E2ETestStageRegister host_status;
+  // These fields are used to test the signaling mechanism.
+  std::atomic<uint32_t> host_to_guest_signal;
+  std::atomic<uint32_t> guest_to_host_signal;
+  std::atomic<uint32_t> guest_self_register;
+  // There rest of the region will be filled by guest_host_strings.
+  // We actually use more than one of these, but we can't know how many
+  // until we examine the region.
+  E2EMemoryFill data[1];
+};
+ASSERT_SHM_COMPATIBLE(E2ETestRegionLayout);
+
+struct E2EPrimaryTestRegionLayout : public E2ETestRegionLayout {
+  static constexpr size_t layout_size = E2ETestRegionLayout::layout_size;
+
+  static const char* region_name;
+  static const char guest_pattern[E2EMemoryFill::kOwnedFieldSize];
+  static const char host_pattern[E2EMemoryFill::kOwnedFieldSize];
+};
+ASSERT_SHM_COMPATIBLE(E2EPrimaryTestRegionLayout);
+
+struct E2ESecondaryTestRegionLayout : public E2ETestRegionLayout {
+  static constexpr size_t layout_size = E2ETestRegionLayout::layout_size;
+
+  static const char* region_name;
+  static const char guest_pattern[E2EMemoryFill::kOwnedFieldSize];
+  static const char host_pattern[E2EMemoryFill::kOwnedFieldSize];
+};
+ASSERT_SHM_COMPATIBLE(E2ESecondaryTestRegionLayout);
+
+/**
+ * Defines an end-to-end region with a name that should never be configured.
+ */
+struct E2EUnfindableRegionLayout : public E2ETestRegionLayout {
+  static constexpr size_t layout_size = E2ETestRegionLayout::layout_size;
+
+  static const char* region_name;
+};
+ASSERT_SHM_COMPATIBLE(E2EUnfindableRegionLayout);
+
+}  // namespace e2e_test
+}  // namespace layout
+}  // namespace vsoc
diff --git a/common/vsoc/shm/gralloc_layout.h b/common/vsoc/shm/gralloc_layout.h
new file mode 100644
index 0000000..4da740f
--- /dev/null
+++ b/common/vsoc/shm/gralloc_layout.h
@@ -0,0 +1,75 @@
+#pragma once
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include "common/vsoc/shm/base.h"
+#include "common/vsoc/shm/graphics.h"
+#include "common/vsoc/shm/lock.h"
+
+// Memory layout for the gralloc manager region.
+
+namespace vsoc {
+namespace layout {
+
+namespace gralloc {
+
+struct BufferEntry {
+  static constexpr size_t layout_size =
+      7 * 4 + PixelFormatRegister::layout_size;
+
+  uint32_t owned_by;
+  uint32_t buffer_begin;
+  uint32_t buffer_end;
+
+  PixelFormatRegister pixel_format;
+  uint32_t stride;
+  uint32_t width;
+  uint32_t height;
+
+  // A size of 28 is causing different layouts when GrallocManagerLayout is
+  // compiled in host and guest sides
+  uint32_t padding;
+
+  uint32_t buffer_size() {
+    return buffer_end - buffer_begin;
+  }
+};
+ASSERT_SHM_COMPATIBLE(BufferEntry);
+
+struct GrallocBufferLayout : public RegionLayout {
+  static constexpr size_t layout_size = 1;
+  static const char* region_name;
+};
+ASSERT_SHM_COMPATIBLE(GrallocBufferLayout);
+
+struct GrallocManagerLayout : public RegionLayout {
+  static constexpr size_t layout_size =
+      8 + GuestLock::layout_size + BufferEntry::layout_size;
+  static const char* region_name;
+  typedef GrallocBufferLayout ManagedRegion;
+
+  uint32_t allocated_buffer_memory;
+  uint32_t buffer_count;
+  // Make sure this isn't the first field
+  GuestLock new_buffer_lock;
+  // Needs to be last field
+  BufferEntry buffers_table[1];
+};
+ASSERT_SHM_COMPATIBLE(GrallocManagerLayout);
+
+} // namespace gralloc
+} // namespace layout
+} // namespace vsoc
diff --git a/common/vsoc/shm/graphics.h b/common/vsoc/shm/graphics.h
new file mode 100644
index 0000000..0aa7875
--- /dev/null
+++ b/common/vsoc/shm/graphics.h
@@ -0,0 +1,169 @@
+#pragma once
+
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+// Memory layout for primitive graphics types.
+
+// The vsoc::layout namespace indicates that these are shared memory structure
+// definitions. The #include's given above are strictly limited, as are the
+// types that can be referenced below.
+
+#include <cstdint>
+
+#include "common/vsoc/shm/base.h"
+
+namespace vsoc {
+
+// The enumerations for VSoC pixel formats are laid out so that hardware to
+// parse bytes per pixel without relying an a exhaustive list of pixel formats.
+// These constants define the fields involved.
+namespace PixelFormatConst {
+  static const uint32_t BytesPerPixelSize = 3;
+  static const uint32_t SubformatSize = 3;
+  static const uint32_t MaxBytesPerPixel = (1 << BytesPerPixelSize);
+  static const uint32_t MaxSubformat = (1 << SubformatSize) - 1;
+};
+
+
+// Builds (statically) a new pixel format enumeration value given constant
+// bytes per pixel.
+template <uint32_t BYTES, uint32_t SUB_FORMAT>
+struct PixelFormatBuilder {
+  static_assert(BYTES > 0, "Too few bytes");
+  static_assert(BYTES <= PixelFormatConst::MaxBytesPerPixel, "Too many bytes");
+  static_assert(SUB_FORMAT <= PixelFormatConst::MaxSubformat,
+                "Too many subformats");
+  static const uint32_t value = ((BYTES - 1) << PixelFormatConst::SubformatSize) | SUB_FORMAT;
+};
+
+template <uint32_t FORMAT>
+struct PixelFormatProperties {
+  // No static asserts since all int32_t values are (technically) valid pixel formats?
+  static const uint32_t bytes_per_pixel = (FORMAT >> PixelFormatConst::SubformatSize) + 1;
+};
+
+// Contains all of the pixel formats currently supported by this VSoC. The
+// enumeration serves multiple purposes:
+//
+//   * The compile will warn (or error) if we switch on PixelFormat and don't
+//     handly all of the cases.
+//
+//   * Code can use PixelFormat to describe paramaters, making APIs a bit more
+//     self-documenting.
+//
+//   * Observant reviewers can verify that the same pixel value is not assigned
+//     to multiple formats. Keep the enums in numerical order below to
+//     make this easier.
+enum PixelFormat : uint32_t {
+  VSOC_PIXEL_FORMAT_UNINITIALIZED = PixelFormatBuilder<1,0>::value,
+  VSOC_PIXEL_FORMAT_BLOB =          PixelFormatBuilder<1,1>::value,
+
+  VSOC_PIXEL_FORMAT_RGB_565 =       PixelFormatBuilder<2,0>::value,
+  VSOC_PIXEL_FORMAT_YV12 =          PixelFormatBuilder<2,1>::value,
+  VSOC_PIXEL_FORMAT_YCbCr_420_888 = PixelFormatBuilder<2,2>::value,
+
+  VSOC_PIXEL_FORMAT_RGB_888 =       PixelFormatBuilder<3,0>::value,
+
+  VSOC_PIXEL_FORMAT_RGBA_8888 =     PixelFormatBuilder<4,0>::value,
+  VSOC_PIXEL_FORMAT_RGBX_8888 =     PixelFormatBuilder<4,1>::value,
+  VSOC_PIXEL_FORMAT_BGRA_8888 =     PixelFormatBuilder<4,2>::value,
+
+  VSOC_PIXEL_FORMAT_RGBA_FP16 =     PixelFormatBuilder<8,0>::value,
+
+  // VSOC_PIXEL_FORMAT_IMPLEMENTATION_DEFINED intentionally left out. The HALs
+  // should choose one of the defined contrete types.
+  //
+  // The following formats are defined in various platform versions, but don't
+  // seem to be used. If we encounter them it's ok to add them to the table.
+  // This does not necessitate a version change.
+  //
+  // The following have been in the framework for a long time:
+  //
+  //   VSOC_PIXEL_FORMAT_YCrCb_420_SP
+  //   VSOC_PIXEL_FORMAT_YCbCr_422_SP
+  //
+  // The following were added in JB_MR2:
+  //
+  //   VSOC_PIXEL_FORMAT_YCbCr_420_888
+  //   VSOC_PIXEL_FORMAT_Y8
+  //   VSOC_PIXEL_FORMAT_Y16
+  //
+  // The following were added in L:
+  //
+  //    VSOC_PIXEL_FORMAT_RAW_OPAQUE
+  //    VSOC_PIXEL_FORMAT_RAW16 (also known as RAW_SENSOR. Define only RAW16)
+  //    VSOC_PIXEL_FORMAT_RAW10
+  //
+  // The following were added in L MR1:
+  //
+  //   VSOC_PIXEL_FORMAT_YCbCr_444_888
+  //   VSOC_PIXEL_FORMAT_YCbCr_422_888
+  //   VSOC_PIXEL_FORMAT_RAW12
+  //   VSOC_PIXEL_FORMAT_FLEX_RGBA_8888
+  //   VSOC_PIXEL_FORMAT_FLEX_RGB_888
+  //
+  // These pixel formats were removed in later framework versions. Implement
+  // only if absolutely necessary.
+  //
+  // Support was dropped in K for:
+  //
+  //   VSOC_PIXEL_FORMAT_RGBA_5551
+  //   VSOC_PIXEL_FORMAT_RGBA_4444
+  //
+  // Supported only in K, L, and LMR1:
+  //
+  //   VSOC_PIXEL_FORMAT_sRGB_X_8888
+  //   VSOC_PIXEL_FORMAT_sRGB_A_8888
+};
+// Enums can't have static members, so can't use the macro here.
+static_assert(ShmTypeValidator<PixelFormat, 4>::valid,
+              "Compilation error. Please fix above errors and retry.");
+
+namespace layout {
+
+// VSoC memory layout for a register that accepts a single pixel format.
+// The value is volatile to ensure that the compiler does not eliminate stores.
+struct PixelFormatRegister {
+  static constexpr size_t layout_size = 4;
+
+  volatile PixelFormat value_;
+};
+ASSERT_SHM_COMPATIBLE(PixelFormatRegister);
+
+// Register layout for a mask giving different PixelFormats. Reserve enough
+// space to allow for future expansion. For example, we may well end with
+// a 12 bit per channel format in the future.
+struct PixelFormatMaskRegister {
+  static constexpr size_t layout_size = 8;
+
+  volatile uint64_t value_;
+
+  bool HasValue(PixelFormat in) {
+    return !!(value_ & (uint64_t(1) << in));
+  }
+};
+ASSERT_SHM_COMPATIBLE(PixelFormatMaskRegister);
+
+// Ensure that the mask is large enough to hold the highest encodable
+// pixel format.
+static_assert(PixelFormatBuilder<
+              PixelFormatConst::MaxBytesPerPixel,
+              PixelFormatConst::MaxSubformat>::value <
+              8 * sizeof(PixelFormatMaskRegister),
+              "Largest pixel format does not fit in mask");
+}  // layout
+}  // vsoc
diff --git a/common/vsoc/shm/input_events_layout.h b/common/vsoc/shm/input_events_layout.h
new file mode 100644
index 0000000..737c903
--- /dev/null
+++ b/common/vsoc/shm/input_events_layout.h
@@ -0,0 +1,46 @@
+#pragma once
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include "common/vsoc/shm/base.h"
+#include "common/vsoc/shm/circqueue.h"
+
+// Memory layout for region carrying input events from host to guest
+
+namespace vsoc {
+namespace layout {
+
+namespace input_events {
+
+struct InputEventsLayout : public RegionLayout {
+  static constexpr size_t layout_size =
+      CircularPacketQueue<10, 256>::layout_size +
+      2 * CircularPacketQueue<10, 16>::layout_size;
+
+  static const char* region_name;
+  // Event queues for the different input devices supported. Both the power
+  // button and the keyboard need only generate 2 input events for every
+  // 'hardware' event, so 16 bytes are enough, however when the touchscreen has
+  // multitouch enabled the number of generated events is significantly higher.
+  CircularPacketQueue<10, 256> touch_screen_queue;
+  CircularPacketQueue<10, 16> keyboard_queue;
+  CircularPacketQueue<10, 16> power_button_queue;
+};
+ASSERT_SHM_COMPATIBLE(InputEventsLayout);
+
+}  // namespace input_events
+}  // namespace layout
+}  // namespace vsoc
diff --git a/common/vsoc/shm/lock.h b/common/vsoc/shm/lock.h
new file mode 100644
index 0000000..2049ba8
--- /dev/null
+++ b/common/vsoc/shm/lock.h
@@ -0,0 +1,252 @@
+#pragma once
+
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+// Memory layout for locks of all types.
+
+// The vsoc::layout namespace indicates that these are shared memory structure
+// definitions. The #include's given above are strictly limited, as are the
+// types that can be referenced below.
+
+// For _mm_pause()
+#if defined(__SSE2__)
+#include <x86intrin.h>
+#define _pause() _mm_pause()
+#elif defined(__arm__) || defined(__aarch64__)
+#include <arm_acle.h>
+#define _pause() __yield()
+#endif
+
+#include <atomic>
+#include <cstdint>
+
+#include "common/vsoc/shm/base.h"
+
+// Host userspace, guest userspace, and the guest kernel must all agree on
+// the relationship between std::atomic and atomic_t. That's hard to do without
+// examining assembly, and we can't really examing atomic_t outside of the
+// kernel tree, but we can at least assert that the host and the guest
+// agree on a size.
+static_assert(sizeof(std::atomic<uint32_t>) == 4, "std::atomic size mismatch");
+
+namespace vsoc {
+
+class RegionView;
+
+namespace layout {
+
+/**
+ * Lock that causes threads to busy loop rather than sleeping.
+ * This lock should never be used when the amount of work in the critical
+ * section cannot be bounded.
+ */
+class SpinLock {
+ public:
+  static constexpr size_t layout_size = 4;
+
+  /**
+   * Acquire the spinlock on the queue. This will effectively block all
+   * readers and writers.
+   */
+  void Lock() {
+    while (1) {
+      uint32_t expected = 0;
+      if (lock_.compare_exchange_strong(expected, Sides::OurSide)) {
+        return;
+      }
+      _pause();
+    }
+  }
+
+  /**
+   * Drop the lock iff it is currently held by this side. Used by
+   * recovery code that cleans up regions in the event of a reboot
+   * (guest side) or a service restart (host side).
+   *
+   * The caller must ensure that there are no other threads on its
+   * side (e.g. guest/host) are using the window.
+   */
+  bool Recover() {
+    uint32_t expected = Sides::OurSide;
+    return lock_.compare_exchange_strong(expected, 0);
+  }
+
+  /**
+   * Release the spinlock.
+   */
+  void Unlock() {
+    lock_ = 0;
+  }
+
+ protected:
+  std::atomic<uint32_t> lock_;
+};
+ASSERT_SHM_COMPATIBLE(SpinLock);
+
+/**
+ * This is a generic synchronization primitive that provides space for the
+ * owner of the lock to write platform-specific information.
+ */
+class WaitingLockBase {
+ public:
+  static constexpr size_t layout_size = 40;
+
+ protected:
+  // Common code to handle locking
+  // Must be called with the kernel's thread id
+  // Returns true if the lock was acquired. In this case the value in
+  // expected_vlaue is undefined.
+  // Returns false if locking failed. The value discovered in the lock word
+  // is returned in expected_value, and should probably be used in a conditional
+  // sleep.
+  bool TryLock(uint32_t tid, uint32_t* expected_value);
+
+  // Common code to handle unlocking.
+  // Must be called with the kernel's thread id
+  // Returns sides that should be signalled or 0
+  Sides UnlockCommon(uint32_t tid);
+
+  // Common code to recover single-sided locks.
+  bool RecoverSingleSided();
+
+  // Non-zero values in this word indicate that the lock is in use.
+  // This is 32 bits for compatibility with futex()
+  std::atomic<uint32_t> lock_uint32_;
+
+  // Pad so we line up with glib's pthread_mutex_t and can share the same queue.
+  // These fields may be redefined at any point in the future. They should not
+  // be used.
+ private:
+// These fields are known to be unused and are provided for compatibility
+// with glibc's locks.
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-private-field"
+  uint32_t reserved_1_;
+  char reserved_2_[16];
+  // Provide scratch space for the owner of the lock. The content of this space
+  // is undefined when the lock is acquired. The owner may write to and read
+  // from it while it holds the lock, but must relinquish control before
+  // releasing the lock.
+  //
+  // This is intended to support Linux robust futexes. See the documentation
+  // in the kernel tree:
+  //   Documentation/robust-futex-ABI.txt
+ public:
+  int64_t owner_scratch_[2];
+#pragma clang diagnostic pop
+};
+ASSERT_SHM_COMPATIBLE(WaitingLockBase);
+
+/**
+ * GuestLocks can be acquired and released only on the guest. They reside
+ * in the shared memory window because mutiple guest processes may need
+ * to coordinate activities in certain shared memory regions.
+ *
+ * Representing this as a concrete type allows for some optimizations when
+ * signalling on the lock.
+ */
+class GuestLock : public WaitingLockBase {
+ public:
+  static constexpr size_t layout_size = WaitingLockBase::layout_size;
+
+#ifndef CUTTLEFISH_HOST
+  void Lock();
+  void Unlock();
+  /**
+   * Drop the lock iff it is currently held. Used by
+   * recovery code that cleans up regions in the event of a reboot.
+   *
+   * The caller must ensure that there are no other threads on its
+   * side (e.g. guest/host) are using the window.
+   */
+  bool Recover();
+#endif
+};
+ASSERT_SHM_COMPATIBLE(GuestLock);
+
+/**
+ * HostLocks can be acquired and released only on the host. They reside
+ * in the shared memory window because mutiple host processes may need
+ * to coordinate activities in certain shared memory regions.
+ *
+ * Representing this as a concrete type allows for some optimizations when
+ * signalling on the lock.
+ */
+class HostLock : public WaitingLockBase {
+ public:
+  static constexpr size_t layout_size = WaitingLockBase::layout_size;
+
+#ifdef CUTTLEFISH_HOST
+  void Lock();
+  void Unlock();
+  /**
+   * Drop the lock iff it is currently held. Used by
+   * recovery code that cleans up regions in the event of a daemon
+   * restart.
+   *
+   * The caller must ensure that there are no other threads on its
+   * side (e.g. guest/host) are using the window.
+   */
+  bool Recover();
+#endif
+};
+ASSERT_SHM_COMPATIBLE(HostLock);
+
+/**
+ * GuestAndHostLocks can be acquired and released on either side of the
+ * shared memory window. The locks attempt to enforce fairness by using
+ * a round-trip signal:
+ *
+ *   When a guest releases a lock this code sends a signal to wake the host,
+ *   but not other guest waiters.
+ *
+ *   The wake handler on the host wakes up and local waiters and then reposts
+ *   the signal to the guest.
+ *
+ *   When the guest receives the signal from the host it then wakes ups
+ *   any waiters.
+ *
+ * A similar scenario applies when the host releases a lock with guest waiters.
+ *
+ * Signalling across the shared memory window twice has non-trivial cost.
+ * There are some optimizations in the code to prevent the full round-trip
+ * if the process releasing the lock can confirm that there are no waiters on
+ * the other side.
+ *
+ * Representing this as a concrete type allows for some optimizations when
+ * signalling on the lock.
+ */
+class GuestAndHostLock : public WaitingLockBase {
+ public:
+  static constexpr size_t layout_size = WaitingLockBase::layout_size;
+
+  void Lock(RegionView*);
+  void Unlock(RegionView*);
+  /**
+   * Drop the lock iff it is currently held by this side. Used by
+   * recovery code that cleans up regions in the event of a reboot
+   * (guest side) or a service restart (host side).
+   *
+   * The caller must ensure that there are no other threads on its
+   * side (e.g. guest/host) are using the window.
+   */
+  bool Recover(RegionView*);
+};
+ASSERT_SHM_COMPATIBLE(GuestAndHostLock);
+
+}  // namespace layout
+}  // namespace vsoc
diff --git a/common/vsoc/shm/managed_e2e_test_region_layout.h b/common/vsoc/shm/managed_e2e_test_region_layout.h
new file mode 100644
index 0000000..dc23f66
--- /dev/null
+++ b/common/vsoc/shm/managed_e2e_test_region_layout.h
@@ -0,0 +1,46 @@
+#pragma once
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <cstdint>
+
+#include "common/vsoc/shm/base.h"
+
+namespace vsoc {
+namespace layout {
+
+namespace e2e_test {
+
+struct E2EManagedTestRegionLayout : public RegionLayout {
+  static constexpr size_t layout_size = 4;
+
+  static const char* region_name;
+  uint32_t val;  // Not needed, here only to avoid an empty struct.
+};
+ASSERT_SHM_COMPATIBLE(E2EManagedTestRegionLayout);
+
+struct E2EManagerTestRegionLayout : public RegionLayout {
+  static constexpr size_t layout_size = 4 * 4;
+
+  static const char* region_name;
+  typedef E2EManagedTestRegionLayout ManagedRegion;
+  uint32_t data[4];  // We don't need more than 4 for the tests
+};
+ASSERT_SHM_COMPATIBLE(E2EManagerTestRegionLayout);
+
+}  // namespace e2e_test
+}  // namespace layout
+}  // namespace vsoc
diff --git a/common/vsoc/shm/screen_layout.h b/common/vsoc/shm/screen_layout.h
new file mode 100644
index 0000000..7ad0ca3
--- /dev/null
+++ b/common/vsoc/shm/screen_layout.h
@@ -0,0 +1,76 @@
+#pragma once
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include "common/vsoc/shm/base.h"
+#include "common/vsoc/shm/lock.h"
+
+// Memory layout for screen region
+
+namespace vsoc {
+namespace layout {
+
+namespace screen {
+struct TimeSpec {
+  static constexpr size_t layout_size = 16;
+
+  int64_t ts_sec;
+  uint32_t ts_nsec;
+  // Host and guest compilers are giving the structure different sizes without
+  // this field.
+  uint32_t reserved;
+};
+ASSERT_SHM_COMPATIBLE(TimeSpec);
+
+struct CompositionStats {
+  static constexpr size_t layout_size = 4 + 2 * 2 + 5 * TimeSpec::layout_size;
+
+  uint32_t num_prepare_calls;
+  uint16_t num_layers;
+  uint16_t num_hwcomposited_layers;
+  TimeSpec last_vsync;
+  TimeSpec prepare_start;
+  TimeSpec prepare_end;
+  TimeSpec set_start;
+  TimeSpec set_end;
+};
+ASSERT_SHM_COMPATIBLE(CompositionStats);
+
+struct ScreenLayout : public RegionLayout {
+  static constexpr size_t layout_size = 24 + CompositionStats::layout_size;
+  static const char* region_name;
+  // Display properties
+  uint32_t x_res;
+  uint32_t y_res;
+  uint16_t dpi;
+  uint16_t refresh_rate_hz;
+
+  // Protects access to the frame offset, sequential number and stats.
+  // See the region implementation for more details.
+  SpinLock bcast_lock;
+  // The frame sequential number
+  std::atomic<uint32_t> seq_num;
+  // The index of the buffer containing the current frame.
+  int32_t buffer_index;
+  CompositionStats stats;
+  uint8_t buffer[0];
+};
+ASSERT_SHM_COMPATIBLE(ScreenLayout);
+
+}  // namespace screen
+
+}  // namespace layout
+}  // namespace vsoc
diff --git a/common/vsoc/shm/socket_forward_layout.h b/common/vsoc/shm/socket_forward_layout.h
new file mode 100644
index 0000000..4a9beda
--- /dev/null
+++ b/common/vsoc/shm/socket_forward_layout.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * 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.
+ */
+#pragma once
+
+#include "common/vsoc/shm/base.h"
+#include "common/vsoc/shm/circqueue.h"
+#include "common/vsoc/shm/lock.h"
+
+// Memory layout for wifi packet exchange region.
+namespace vsoc {
+namespace layout {
+namespace socket_forward {
+
+constexpr std::size_t kMaxPacketSize = 8192;
+constexpr std::size_t kNumQueues = 16;
+
+struct Queue {
+  static constexpr size_t layout_size =
+      CircularPacketQueue<16, kMaxPacketSize>::layout_size;
+
+  CircularPacketQueue<16, kMaxPacketSize> queue;
+
+  bool Recover() { return queue.Recover(); }
+};
+ASSERT_SHM_COMPATIBLE(Queue);
+
+struct QueuePair {
+  static constexpr size_t layout_size = 2 * Queue::layout_size;
+
+  // Traffic originating from host that proceeds towards guest.
+  Queue host_to_guest;
+  // Traffic originating from guest that proceeds towards host.
+  Queue guest_to_host;
+
+  bool Recover() {
+    bool recovered = false;
+    recovered = recovered || host_to_guest.Recover();
+    recovered = recovered || guest_to_host.Recover();
+    return recovered;
+  }
+};
+ASSERT_SHM_COMPATIBLE(QueuePair);
+
+struct SocketForwardLayout : public RegionLayout {
+  static constexpr size_t layout_size = QueuePair::layout_size * kNumQueues;
+
+  bool Recover() {
+    bool recovered = false;
+    for (auto& i : queues_) {
+      bool rval = i.Recover();
+      recovered = recovered || rval;
+    }
+    return recovered;
+  }
+
+  QueuePair queues_[kNumQueues];
+  static const char* region_name;
+};
+
+ASSERT_SHM_COMPATIBLE(SocketForwardLayout);
+
+}  // namespace socket_forward
+}  // namespace layout
+}  // namespace vsoc
diff --git a/guest/commands/vsoc_input_service/Android.bp b/guest/commands/vsoc_input_service/Android.bp
index f2e197f..73ca067 100644
--- a/guest/commands/vsoc_input_service/Android.bp
+++ b/guest/commands/vsoc_input_service/Android.bp
@@ -33,6 +33,7 @@
         "libcuttlefish_fs",
         "libbase",
         "liblog",
+        "vsoc_lib",
     ],
     header_libs: [
         "cuttlefish_glog",
diff --git a/guest/commands/vsoc_input_service/vsoc_input_service.cpp b/guest/commands/vsoc_input_service/vsoc_input_service.cpp
index 8b75b45..8753735 100644
--- a/guest/commands/vsoc_input_service/vsoc_input_service.cpp
+++ b/guest/commands/vsoc_input_service/vsoc_input_service.cpp
@@ -28,6 +28,7 @@
 
 #include "common/libs/fs/shared_fd.h"
 #include "common/libs/device_config/device_config.h"
+#include "common/vsoc/lib/input_events_region_view.h"
 
 using vsoc::input_events::InputEvent;
 using vsoc_input_service::VirtualDeviceBase;
diff --git a/guest/commands/vsoc_input_service/vsoc_input_service.h b/guest/commands/vsoc_input_service/vsoc_input_service.h
index edf196d..2282b40 100644
--- a/guest/commands/vsoc_input_service/vsoc_input_service.h
+++ b/guest/commands/vsoc_input_service/vsoc_input_service.h
@@ -21,18 +21,6 @@
 #include "virtual_power_button.h"
 #include "virtual_touchscreen.h"
 
-namespace vsoc {
-namespace input_events {
-
-struct InputEvent {
-  uint16_t type;
-  uint16_t code;
-  uint32_t value;
-};
-
-} // namespace input_events
-} // namespace vsoc
-
 namespace vsoc_input_service {
 
 class VSoCInputService {
diff --git a/guest/hals/audio/legacy/Android.mk b/guest/hals/audio/legacy/Android.mk
new file mode 100644
index 0000000..8d4ef0a
--- /dev/null
+++ b/guest/hals/audio/legacy/Android.mk
@@ -0,0 +1,65 @@
+# Copyright (C) 2016 The Android Open Source Project
+#
+# 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.
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+ifeq (0, $(shell test $(PLATFORM_SDK_VERSION) -ge 21; echo $$?))
+LOCAL_MODULE_RELATIVE_PATH := hw
+else
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
+endif
+LOCAL_MODULE_TAGS := optional
+LOCAL_MULTILIB := first
+
+LOCAL_SHARED_LIBRARIES := \
+    libbase \
+    liblog \
+    libcutils \
+    cuttlefish_auto_resources \
+    libcuttlefish_fs \
+    cuttlefish_time \
+    vsoc_lib
+
+LOCAL_HEADER_LIBRARIES := \
+    libhardware_headers
+
+LOCAL_SRC_FILES := \
+    audio_hal.cpp \
+    vsoc_audio.cpp \
+    vsoc_audio_input_stream.cpp \
+    vsoc_audio_output_stream.cpp
+
+LOCAL_C_INCLUDES := \
+    device/google/cuttlefish_common \
+    device/google/cuttlefish_kernel \
+    $(VSOC_STLPORT_INCLUDES) \
+    frameworks/native/include/media/hardware \
+    $(call include-path-for, audio)
+
+LOCAL_STATIC_LIBRARIES := \
+    libcutils \
+    libcuttlefish_remoter_framework \
+    $(VSOC_STLPORT_STATIC_LIBS)
+
+LOCAL_CFLAGS := \
+    -Wall -Werror -std=c++17 \
+    $(VSOC_VERSION_CFLAGS)
+
+
+LOCAL_MODULE := audio.primary.cutf_ivsh
+LOCAL_VENDOR_MODULE := true
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/guest/hals/audio/legacy/audio_hal.cpp b/guest/hals/audio/legacy/audio_hal.cpp
new file mode 100644
index 0000000..a865d46
--- /dev/null
+++ b/guest/hals/audio/legacy/audio_hal.cpp
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+#include "guest/hals/audio/legacy/vsoc_audio.h"
+
+#include "guest/hals/audio/legacy/audio_hal.h"
+
+static hw_module_methods_t hal_module_methods = {
+  .open = cvd::GceAudio::Open,
+};
+
+
+audio_module HAL_MODULE_INFO_SYM = {
+  .common = {
+    .tag = HARDWARE_MODULE_TAG,
+    .module_api_version = AUDIO_MODULE_API_VERSION_0_1,
+    .hal_api_version = HARDWARE_HAL_API_VERSION,
+    .id = AUDIO_HARDWARE_MODULE_ID,
+    .name = "GCE Audio HW HAL",
+    .author = "The Android Open Source Project",
+    .methods = &hal_module_methods,
+  },
+};
diff --git a/guest/hals/audio/legacy/audio_hal.h b/guest/hals/audio/legacy/audio_hal.h
new file mode 100644
index 0000000..db547ff
--- /dev/null
+++ b/guest/hals/audio/legacy/audio_hal.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+#pragma once
+
+#define AUDIO_DEBUG 0
+
+#if AUDIO_DEBUG
+#  define D(...) ALOGD(__VA_ARGS__)
+#else
+#  define D(...) ((void)0)
+#endif
+
+#include <errno.h>
+#include <string.h>
+#include <log/log.h>
+
+#include <hardware/hardware.h>
+
+#pragma GCC diagnostic push
+#pragma  GCC diagnostic ignored "-Wparentheses"
+#pragma  GCC diagnostic ignored "-Wgnu-designator"
+#include <system/audio.h>
+#pragma GCC diagnostic pop
+
+#include <hardware/audio.h>
diff --git a/guest/hals/audio/legacy/policy/Android.mk b/guest/hals/audio/legacy/policy/Android.mk
new file mode 100644
index 0000000..0b2ef8c
--- /dev/null
+++ b/guest/hals/audio/legacy/policy/Android.mk
@@ -0,0 +1,45 @@
+# Copyright (C) 2016 The Android Open Source Project
+#
+# 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.
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+ifeq (0, $(shell test $(PLATFORM_SDK_VERSION) -ge 21; echo $$?))
+LOCAL_MODULE_RELATIVE_PATH := hw
+else
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
+endif
+LOCAL_MODULE_TAGS := optional
+LOCAL_MULTILIB := first
+
+LOCAL_SHARED_LIBRARIES := \
+    liblog \
+    libcutils
+
+LOCAL_SRC_FILES := \
+    vsoc_audio_policy_hal.cpp
+
+LOCAL_C_INCLUDES := \
+    device/google/cuttlefish_common \
+    $(VSOC_STLPORT_INCLUDES) \
+    frameworks/native/include/media/hardware \
+    $(call include-path-for, audio)
+
+LOCAL_CFLAGS := -Wall -Werror
+
+LOCAL_MODULE := audio_policy.vsoc
+LOCAL_VENDOR_MODULE := true
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/guest/hals/audio/legacy/policy/vsoc_audio_policy_hal.cpp b/guest/hals/audio/legacy/policy/vsoc_audio_policy_hal.cpp
new file mode 100644
index 0000000..53c3127
--- /dev/null
+++ b/guest/hals/audio/legacy/policy/vsoc_audio_policy_hal.cpp
@@ -0,0 +1,156 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+#include <errno.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <hardware/hardware.h>
+#include <system/audio.h>
+#include <system/audio_policy.h>
+#include <hardware/audio_policy.h>
+
+#include "guest/hals/audio/legacy/policy/vsoc_audio_policy_hal.h"
+
+namespace cvd {
+
+int GceAudioPolicy::Create(
+    const audio_policy_device* device,
+    audio_policy_service_ops* aps_ops,
+    void* service, audio_policy** ap) {
+  D("%s", __FUNCTION__);
+  audio_policy_device* dev;
+  gce_audio_policy* dap;
+  int ret;
+
+  *ap = NULL;
+
+  if (!service || !aps_ops) {
+    return -EINVAL;
+  }
+
+  dap = (gce_audio_policy*) calloc(1, sizeof(*dap));
+  if (!dap) {
+    return -ENOMEM;
+  }
+
+  dap->policy.set_device_connection_state =
+      &GceAudioPolicy::SetDeviceConnectionState;
+  dap->policy.get_device_connection_state =
+      &GceAudioPolicy::GetDeviceConnectionState;
+  dap->policy.set_phone_state = &GceAudioPolicy::SetPhoneState;
+  dap->policy.set_ringer_mode = &GceAudioPolicy::SetRingerMode;
+  dap->policy.set_force_use = &GceAudioPolicy::SetForceUse;
+  dap->policy.get_force_use = &GceAudioPolicy::GetForceUse;
+  dap->policy.set_can_mute_enforced_audible =
+      &GceAudioPolicy::SetCanMuteEnforcedAudible;
+  dap->policy.init_check = &GceAudioPolicy::InitCheck;
+  dap->policy.get_output = &GceAudioPolicy::GetOutput;
+  dap->policy.start_output = &GceAudioPolicy::StartOutput;
+  dap->policy.stop_output = &GceAudioPolicy::StopOutput;
+  dap->policy.release_output = &GceAudioPolicy::ReleaseOutput;
+  dap->policy.get_input = &GceAudioPolicy::GetInput;
+  dap->policy.start_input = &GceAudioPolicy::StartInput;
+  dap->policy.stop_input = &GceAudioPolicy::StopInput;
+  dap->policy.release_input = &GceAudioPolicy::ReleaseInput;
+  dap->policy.init_stream_volume = &GceAudioPolicy::InitStreamVolume;
+  dap->policy.set_stream_volume_index = &GceAudioPolicy::SetStreamVolumeIndex;
+  dap->policy.get_stream_volume_index = &GceAudioPolicy::GetStreamVolumeIndex;
+  dap->policy.set_stream_volume_index_for_device =
+      &GceAudioPolicy::SetStreamVolumeIndexForDevice;
+  dap->policy.get_stream_volume_index_for_device =
+      &GceAudioPolicy::GetStreamVolumeIndexForDevice;
+  dap->policy.get_strategy_for_stream = &GceAudioPolicy::GetStrategyForStream;
+  dap->policy.get_devices_for_stream = &GceAudioPolicy::GetDevicesForStream;
+  dap->policy.get_output_for_effect = &GceAudioPolicy::GetOutputForEffect;
+  dap->policy.register_effect = &GceAudioPolicy::RegisterEffect;
+  dap->policy.unregister_effect = &GceAudioPolicy::UnregisterEffect;
+  dap->policy.set_effect_enabled = &GceAudioPolicy::SetEffectEnabled;
+  dap->policy.is_stream_active = &GceAudioPolicy::IsStreamActive;
+  dap->policy.dump = &GceAudioPolicy::Dump;
+#ifdef ENABLE_OFFLOAD
+  dap->policy.is_offload_supported = &GceAudioPolicy::IsOffloadSupported;
+#endif
+
+  dap->service = service;
+  dap->aps_ops = aps_ops;
+
+  *ap = &dap->policy;
+  return 0;
+}
+
+
+int GceAudioPolicy::Destroy(const audio_policy_device* ap_dev,
+                            audio_policy* ap) {
+  D("%s", __FUNCTION__);
+  free(ap);
+  return 0;
+}
+
+
+int GceAudioPolicy::Close(hw_device_t* device) {
+  D("%s", __FUNCTION__);
+  free(device);
+  return 0;
+}
+
+
+int GceAudioPolicy::Open(
+    const hw_module_t* module, const char* name, hw_device_t** device) {
+  D("%s", __FUNCTION__);
+  audio_policy_device* dev;
+
+  *device = NULL;
+
+  if (strcmp(name, AUDIO_POLICY_INTERFACE) != 0) {
+    return -EINVAL;
+  }
+
+  dev = (audio_policy_device*) calloc(1, sizeof(*dev));
+  if (!dev) {
+    return -ENOMEM;
+  }
+
+  dev->common.tag = HARDWARE_DEVICE_TAG;
+  dev->common.version = 0;
+  dev->common.module = (hw_module_t*) module;
+  dev->common.close = &GceAudioPolicy::Close;
+  dev->create_audio_policy = &GceAudioPolicy::Create;
+  dev->destroy_audio_policy = &GceAudioPolicy::Destroy;
+
+  *device = &dev->common;
+
+  return 0;
+}
+
+}
+
+static hw_module_methods_t gce_audio_policy_module_methods = {
+  .open = &cvd::GceAudioPolicy::Open,
+};
+
+
+audio_policy_module HAL_MODULE_INFO_SYM = {
+  .common = {
+    .tag           = HARDWARE_MODULE_TAG,
+    .version_major = 1,
+    .version_minor = 0,
+    .id            = AUDIO_POLICY_HARDWARE_MODULE_ID,
+    .name          = "GCE Audio Policy HAL",
+    .author        = "The Android Open Source Project",
+    .methods       = &gce_audio_policy_module_methods,
+  },
+};
diff --git a/guest/hals/audio/legacy/policy/vsoc_audio_policy_hal.h b/guest/hals/audio/legacy/policy/vsoc_audio_policy_hal.h
new file mode 100644
index 0000000..00ea3d1
--- /dev/null
+++ b/guest/hals/audio/legacy/policy/vsoc_audio_policy_hal.h
@@ -0,0 +1,245 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+#pragma once
+
+#include <errno.h>
+#include <string.h>
+#include <log/log.h>
+
+#include <hardware/hardware.h>
+#include <system/audio.h>
+#include <hardware/audio.h>
+
+#define AUDIO_DEBUG 1
+
+#if AUDIO_DEBUG
+#  define D(...) ALOGD(__VA_ARGS__)
+#else
+#  define D(...) ((void)0)
+#endif
+
+#define LOG_TAG "GceAudioPolicy"
+
+namespace avd {
+
+struct gce_audio_policy {
+  audio_policy policy;
+
+  audio_policy_service_ops* aps_ops;
+  void* service;
+};
+
+
+class GceAudioPolicy {
+ public:
+  GceAudioPolicy() {}
+  ~GceAudioPolicy() {}
+
+  static int Open(
+      const hw_module_t* module, const char* name, hw_device_t** device);
+  static int Create(const audio_policy_device* device,
+      audio_policy_service_ops* aps_ops, void* service,
+      audio_policy** ap);
+  static int Destroy(const audio_policy_device* ap_dev,
+                     audio_policy* ap);
+  static int Close(hw_device_t* device);
+
+  static int SetDeviceConnectionState(
+      audio_policy* pol, audio_devices_t device,
+      audio_policy_dev_state_t state, const char* device_address) {
+    ALOGE("%s: not supported", __FUNCTION__);
+    return -ENOSYS;
+  }
+
+  static audio_policy_dev_state_t GetDeviceConnectionState(
+      const audio_policy* pol, audio_devices_t device,
+      const char* device_address) {
+    ALOGE("%s: not supported", __FUNCTION__);
+    return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
+  }
+
+  static void SetPhoneState(audio_policy* pol, audio_mode_t state) {
+    ALOGE("%s: not supported", __FUNCTION__);
+  }
+
+  static void SetRingerMode(audio_policy* pol, uint32_t mode,
+                            uint32_t mask) {
+    ALOGW("%s: deprecated", __FUNCTION__);
+  }
+
+  static void SetForceUse(
+      audio_policy* pol, audio_policy_force_use_t usage,
+    audio_policy_forced_cfg_t config) {
+    ALOGE("%s: not supported", __FUNCTION__);
+  }
+
+  static audio_policy_forced_cfg_t GetForceUse(
+      const audio_policy* pol, audio_policy_force_use_t usage) {
+    ALOGE("%s: not supported", __FUNCTION__);
+    return AUDIO_POLICY_FORCE_NONE;
+  }
+
+  static void SetCanMuteEnforcedAudible(
+      audio_policy* pol, bool can_mute) {
+    ALOGE("%s: not supported", __FUNCTION__);
+  }
+
+  static int InitCheck(const audio_policy* pol) {
+    ALOGE("%s: not supported", __FUNCTION__);
+    return 0;
+  }
+
+  static audio_io_handle_t GetOutput(
+      audio_policy* pol, audio_stream_type_t stream,
+      uint32_t sampling_rate, audio_format_t format,
+      audio_channel_mask_t channelMask, audio_output_flags_t flags
+#ifdef ENABLE_OFFLOAD
+      , const audio_offload_info_t* info
+#endif
+      ) {
+    ALOGE("%s: not supported", __FUNCTION__);
+    return 0;
+  }
+
+  static int StartOutput(audio_policy* pol, audio_io_handle_t output,
+                         audio_stream_type_t stream, int session) {
+    ALOGE("%s: not supported", __FUNCTION__);
+    return -ENOSYS;
+  }
+
+  static int StopOutput(audio_policy* pol, audio_io_handle_t output,
+                        audio_stream_type_t stream, int session) {
+    ALOGE("%s: not supported", __FUNCTION__);
+    return -ENOSYS;
+  }
+
+  static void ReleaseOutput(
+      audio_policy* pol, audio_io_handle_t output) {
+    ALOGE("%s: not supported", __FUNCTION__);
+  }
+
+  static audio_io_handle_t GetInput(
+      audio_policy* pol, audio_source_t inputSource,
+      uint32_t sampling_rate, audio_format_t format,
+      audio_channel_mask_t channelMask, audio_in_acoustics_t acoustics) {
+    ALOGE("%s: not supported", __FUNCTION__);
+    return 0;
+  }
+
+  static int StartInput(audio_policy* pol, audio_io_handle_t input) {
+    ALOGE("%s: not supported", __FUNCTION__);
+    return -ENOSYS;
+  }
+
+  static int StopInput(audio_policy* pol, audio_io_handle_t input) {
+    ALOGE("%s: not supported", __FUNCTION__);
+    return -ENOSYS;
+  }
+
+  static void ReleaseInput(
+      audio_policy* pol, audio_io_handle_t input) {
+    ALOGE("%s: not supported", __FUNCTION__);
+  }
+
+  static void InitStreamVolume(audio_policy* pol,
+                               audio_stream_type_t stream, int index_min,
+                               int index_max) {
+    ALOGE("%s: not supported", __FUNCTION__);
+  }
+
+  static int SetStreamVolumeIndex(audio_policy* pol,
+                                  audio_stream_type_t stream, int index) {
+    ALOGE("%s: not supported", __FUNCTION__);
+    return -ENOSYS;
+  }
+
+  static int GetStreamVolumeIndex(const audio_policy* pol,
+                                  audio_stream_type_t stream, int* index) {
+    ALOGE("%s: not supported", __FUNCTION__);
+    return -ENOSYS;
+  }
+
+  static int SetStreamVolumeIndexForDevice(
+      audio_policy* pol, audio_stream_type_t stream,
+      int index, audio_devices_t device) {
+    ALOGE("%s: not supported", __FUNCTION__);
+    return -ENOSYS;
+  }
+
+  static int GetStreamVolumeIndexForDevice(
+      const audio_policy* pol, audio_stream_type_t stream,
+      int* index, audio_devices_t device) {
+    ALOGE("%s: not supported", __FUNCTION__);
+    return -ENOSYS;
+  }
+
+  static uint32_t GetStrategyForStream(const audio_policy* pol,
+                                       audio_stream_type_t stream) {
+    ALOGE("%s: not supported", __FUNCTION__);
+    return 0;
+  }
+
+  static audio_devices_t GetDevicesForStream(const audio_policy* pol,
+                                             audio_stream_type_t stream) {
+    ALOGE("%s: not supported", __FUNCTION__);
+    return 0;
+  }
+
+  static audio_io_handle_t GetOutputForEffect(
+      audio_policy* pol, const effect_descriptor_s* desc) {
+    ALOGE("%s: not supported", __FUNCTION__);
+    return 0;
+  }
+
+  static int RegisterEffect(
+      audio_policy* pol, const effect_descriptor_s* desc,
+      audio_io_handle_t output, uint32_t strategy, int session, int id) {
+    ALOGE("%s: not supported", __FUNCTION__);
+    return -ENOSYS;
+  }
+
+  static int UnregisterEffect(audio_policy* pol, int id) {
+    ALOGE("%s: not supported", __FUNCTION__);
+    return -ENOSYS;
+  }
+
+  static int SetEffectEnabled(audio_policy* pol, int id, bool enabled) {
+    ALOGE("%s: not supported", __FUNCTION__);
+    return -ENOSYS;
+  }
+
+  static bool IsStreamActive(
+      const audio_policy* pol, audio_stream_type_t stream,
+      uint32_t in_past_ms) {
+    ALOGE("%s: not supported", __FUNCTION__);
+    return false;
+  }
+
+  static int Dump(const audio_policy* pol, int fd) {
+    ALOGE("%s: not supported", __FUNCTION__);
+    return -ENOSYS;
+  }
+
+#ifdef ENABLE_OFFLOAD
+  static bool IsOffloadSupported(const audio_policy* pol,
+                                 const audio_offload_info_t* info) {
+    ALOGE("%s: not supported", __FUNCTION__);
+    return false;
+  }
+#endif
+};
+
+}
diff --git a/guest/hals/audio/legacy/vsoc_audio.cpp b/guest/hals/audio/legacy/vsoc_audio.cpp
new file mode 100644
index 0000000..040e1e7
--- /dev/null
+++ b/guest/hals/audio/legacy/vsoc_audio.cpp
@@ -0,0 +1,387 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+#include "guest/hals/audio/legacy/audio_hal.h"
+
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <fcntl.h>
+
+extern "C" {
+#include <cutils/str_parms.h>
+}
+
+#include "common/libs/auto_resources/auto_resources.h"
+#include "common/libs/fs/shared_select.h"
+#include "common/libs/threads/cuttlefish_thread.h"
+#include "common/libs/threads/thunkers.h"
+#include "common/vsoc/lib/circqueue_impl.h"
+#include "guest/hals/audio/legacy/vsoc_audio.h"
+#include "guest/hals/audio/legacy/vsoc_audio_input_stream.h"
+#include "guest/hals/audio/legacy/vsoc_audio_output_stream.h"
+#include "guest/libs/remoter/remoter_framework_pkt.h"
+
+using cvd::LockGuard;
+using cvd::Mutex;
+
+namespace cvd {
+
+GceAudio::~GceAudio() { }
+
+int GceAudio::Close() {
+  D("GceAudio::%s", __FUNCTION__);
+  {
+    LockGuard<Mutex> guard(lock_);
+    for (std::list<GceAudioOutputStream*>::iterator it = output_list_.begin();
+         it != output_list_.end(); ++it) {
+      delete *it;
+    }
+    for (input_map_t::iterator it = input_map_.begin();
+         it != input_map_.end(); ++it) {
+      delete it->second;
+    }
+  }
+  delete this;
+  return 0;
+}
+
+size_t GceAudio::GetInputBufferSize(const audio_config*) const {
+  return IN_BUFFER_BYTES;
+}
+
+uint32_t GceAudio::GetSupportedDevices() const {
+  return AUDIO_DEVICE_OUT_EARPIECE |
+      AUDIO_DEVICE_OUT_SPEAKER |
+      AUDIO_DEVICE_OUT_DEFAULT |
+      AUDIO_DEVICE_IN_COMMUNICATION |
+      AUDIO_DEVICE_IN_BUILTIN_MIC |
+      AUDIO_DEVICE_IN_WIRED_HEADSET |
+      AUDIO_DEVICE_IN_VOICE_CALL |
+      AUDIO_DEVICE_IN_DEFAULT;
+}
+
+int GceAudio::InitCheck() const {
+  D("GceAudio::%s", __FUNCTION__);
+  return 0;
+}
+
+int GceAudio::SetMicMute(bool state) {
+  D("GceAudio::%s", __FUNCTION__);
+  LockGuard<Mutex> guard(lock_);
+  mic_muted_ = state;
+  return 0;
+}
+
+int GceAudio::GetMicMute(bool *state) const {
+  D("GceAudio::%s", __FUNCTION__);
+  LockGuard<Mutex> guard(lock_);
+  *state = mic_muted_;
+  return 0;
+}
+
+int GceAudio::OpenInputStream(audio_io_handle_t handle,
+                              audio_devices_t devices,
+                              audio_config *config,
+                              audio_stream_in **stream_in,
+                              audio_input_flags_t /*flags*/,
+                              const char * /*address*/,
+                              audio_source_t /*source*/) {
+  GceAudioInputStream* new_stream;
+  int rval = GceAudioInputStream::Open(
+      this, handle, devices, *config, &new_stream);
+  uint32_t stream_number;
+  if (new_stream) {
+    LockGuard<Mutex> guard(lock_);
+    stream_number = next_stream_number_++;
+    input_map_[stream_number] = new_stream;
+  }
+  // This should happen after the lock is released, hence the double check
+  if (new_stream) {
+    SendStreamUpdate(new_stream->GetStreamDescriptor(
+        stream_number, gce_audio_message::OPEN_INPUT_STREAM), MSG_DONTWAIT);
+  }
+  *stream_in = new_stream;
+  return rval;
+}
+
+
+void GceAudio::CloseInputStream(audio_stream_in *stream) {
+  GceAudioInputStream* astream = static_cast<GceAudioInputStream*>(stream);
+  gce_audio_message descriptor;
+  {
+    LockGuard<Mutex> guard(lock_);
+    // TODO(ghartman): This could be optimized if stream knew it's number.
+    for (input_map_t::iterator it = input_map_.begin();
+         it != input_map_.end(); ++it) {
+      if (it->second == stream) {
+        descriptor = it->second->GetStreamDescriptor(
+            it->first, gce_audio_message::CLOSE_INPUT_STREAM);
+        input_map_.erase(it);
+        break;
+      }
+    }
+  }
+  SendStreamUpdate(descriptor, MSG_DONTWAIT);
+  delete astream;
+}
+
+
+int GceAudio::OpenOutputStream(audio_io_handle_t handle,
+                               audio_devices_t devices,
+                               audio_output_flags_t flags,
+                               audio_config *config,
+                               audio_stream_out **stream_out,
+                               const char * /*address*/) {
+  GceAudioOutputStream* new_stream;
+  int rval;
+  {
+    LockGuard<Mutex> guard(lock_);
+    rval = GceAudioOutputStream::Open(
+        this, handle, devices, flags, config, next_stream_number_++,
+        &new_stream);
+    if (new_stream) {
+      output_list_.push_back(new_stream);
+    }
+  }
+  if (new_stream) {
+    SendStreamUpdate(new_stream->GetStreamDescriptor(
+        gce_audio_message::OPEN_OUTPUT_STREAM), MSG_DONTWAIT);
+  }
+  *stream_out = new_stream;
+  return rval;
+}
+
+void GceAudio::CloseOutputStream(audio_stream_out *stream) {
+  GceAudioOutputStream* astream = static_cast<GceAudioOutputStream*>(stream);
+  gce_audio_message close;
+  {
+    LockGuard<Mutex> guard(lock_);
+    output_list_.remove(astream);
+    close = astream->GetStreamDescriptor(
+        gce_audio_message::CLOSE_OUTPUT_STREAM);
+  }
+  SendStreamUpdate(close, MSG_DONTWAIT);
+  delete astream;
+}
+
+int GceAudio::Dump(int fd) const {
+  LockGuard<Mutex> guard(lock_);
+  dprintf(
+      fd,
+      "\nadev_dump:\n"
+      "\tmic_mute: %s\n"
+      "\tnum_outputs: %zu\n"
+      "\tnum_inputs: %zu\n\n",
+      mic_muted_ ? "true": "false",
+      output_list_.size(), input_map_.size());
+
+  for (std::list<GceAudioOutputStream*>::const_iterator it =
+           output_list_.begin();
+       it != output_list_.end(); ++it) {
+    (*it)->common.dump(&(*it)->common, fd);
+  }
+
+  for (input_map_t::const_iterator it = input_map_.begin();
+       it != input_map_.end(); ++it) {
+    (*it).second->common.dump(&(*it).second->common, fd);
+  }
+
+  return 0;
+}
+
+ssize_t GceAudio::SendMsg(const msghdr& msg, int /* flags */) {
+    intptr_t res = audio_data_rv_->data()->audio_queue.Writev(
+            audio_data_rv_,
+            msg.msg_iov,
+            msg.msg_iovlen,
+            true /* non_blocking */);
+
+    if (res < 0) {
+        ALOGV("GceAudio::%s: CircularPacketQueue::Write returned %" PRIiPTR,
+              __FUNCTION__,
+              res);
+    }
+
+    return static_cast<ssize_t>(res);
+}
+
+ssize_t GceAudio::SendStreamUpdate(
+    const gce_audio_message& stream_info, int flags) {
+  msghdr msg;
+  iovec msg_iov[1];
+  msg_iov[0].iov_base = const_cast<gce_audio_message*>(&stream_info);
+  msg_iov[0].iov_len = sizeof(gce_audio_message);
+  msg.msg_name = NULL;
+  msg.msg_namelen = 0;
+  msg.msg_iov = msg_iov;
+  msg.msg_iovlen = arraysize(msg_iov);
+  msg.msg_control = NULL;
+  msg.msg_controllen = 0;
+  msg.msg_flags = 0;
+  return SendMsg(msg, flags);
+}
+
+int GceAudio::SetVoiceVolume(float volume) {
+  D("GceAudio::%s: set voice volume %f", __FUNCTION__, volume);
+  voice_volume_ = volume;
+  return 0;
+}
+
+int GceAudio::SetMasterVolume(float volume) {
+  D("GceAudio::%s: set master volume %f", __FUNCTION__, volume);
+  master_volume_ = volume;
+  return 0;
+}
+
+int GceAudio::GetMasterVolume(float* volume) {
+  D("GceAudio::%s: get master volume %f", __FUNCTION__, master_volume_);
+  *volume = master_volume_;
+  return 0;
+}
+
+int GceAudio::SetMasterMute(bool muted) {
+  D("GceAudio::%s: set master muted %d", __FUNCTION__, muted);
+  master_muted_ = muted;
+  return 0;
+}
+
+int GceAudio::GetMasterMute(bool* muted) {
+  D("GceAudio::%s: get master muted %d", __FUNCTION__, master_muted_);
+  *muted = master_muted_;
+  return 0;
+}
+
+int GceAudio::SetMode(audio_mode_t mode) {
+  D("GceAudio::%s: new mode %d", __FUNCTION__, mode);
+  mode_ = mode;
+  return 0;
+}
+
+int GceAudio::Open(const hw_module_t* module, const char* name,
+                   hw_device_t** device) {
+  D("GceAudio::%s", __FUNCTION__);
+
+  if (strcmp(name, AUDIO_HARDWARE_INTERFACE)) {
+    ALOGE("GceAudio::%s: invalid module name %s (expected %s)",
+          __FUNCTION__, name, AUDIO_HARDWARE_INTERFACE);
+    return -EINVAL;
+  }
+
+  GceAudio* rval = new GceAudio;
+
+  rval->audio_data_rv_ = AudioDataRegionView::GetInstance();
+  rval->audio_worker_ = rval->audio_data_rv_->StartWorker();
+
+  rval->common.tag = HARDWARE_DEVICE_TAG;
+  rval->common.version = version_;
+  rval->common.module = const_cast<hw_module_t *>(module);
+  rval->common.close = cvd::thunk<hw_device_t, &GceAudio::Close>;
+
+#if !defined(AUDIO_DEVICE_API_VERSION_2_0)
+  // This HAL entry is supported only on AUDIO_DEVICE_API_VERSION_1_0.
+  // In fact, with version 2.0 the device numbers were orgainized in a
+  // way that makes the return value nonsense.
+  // Skipping the assignment is ok: the memset in the constructor already
+  // put a NULL here.
+  rval->get_supported_devices =
+      cvd::thunk<audio_hw_device, &GceAudio::GetSupportedDevices>;
+#endif
+  rval->init_check = cvd::thunk<audio_hw_device, &GceAudio::InitCheck>;
+
+  rval->set_voice_volume =
+      cvd::thunk<audio_hw_device, &GceAudio::SetVoiceVolume>;
+  rval->set_master_volume =
+      cvd::thunk<audio_hw_device, &GceAudio::SetMasterVolume>;
+  rval->get_master_volume =
+      cvd::thunk<audio_hw_device, &GceAudio::GetMasterVolume>;
+
+#if defined(AUDIO_DEVICE_API_VERSION_2_0)
+  rval->set_master_mute =
+      cvd::thunk<audio_hw_device, &GceAudio::SetMasterMute>;
+  rval->get_master_mute =
+      cvd::thunk<audio_hw_device, &GceAudio::GetMasterMute>;
+#endif
+
+  rval->set_mode = cvd::thunk<audio_hw_device, &GceAudio::SetMode>;
+  rval->set_mic_mute = cvd::thunk<audio_hw_device, &GceAudio::SetMicMute>;
+  rval->get_mic_mute = cvd::thunk<audio_hw_device, &GceAudio::GetMicMute>;
+
+  rval->set_parameters = cvd::thunk<audio_hw_device, &GceAudio::SetParameters>;
+  rval->get_parameters = cvd::thunk<audio_hw_device, &GceAudio::GetParameters>;
+
+  rval->get_input_buffer_size =
+      cvd::thunk<audio_hw_device, &GceAudio::GetInputBufferSize>;
+
+  rval->open_input_stream =
+      cvd::thunk<audio_hw_device, &GceAudio::OpenInputStreamCurrentHAL>;
+  rval->close_input_stream =
+      cvd::thunk<audio_hw_device, &GceAudio::CloseInputStream>;
+
+  rval->open_output_stream =
+      cvd::thunk<audio_hw_device, &GceAudio::OpenOutputStreamCurrentHAL>;
+  rval->close_output_stream =
+      cvd::thunk<audio_hw_device, &GceAudio::CloseOutputStream>;
+
+  rval->dump = cvd::thunk<audio_hw_device, &GceAudio::Dump>;
+
+  *device = &rval->common;
+  return 0;
+}
+
+int GceAudio::SetParameters(const char *kvpairs) {
+  ALOGE("GceAudio::%s: not implemented", __FUNCTION__);
+  if (kvpairs) D("GceAudio::%s: kvpairs %s", __FUNCTION__, kvpairs);
+  return 0;
+}
+
+
+char* GceAudio::GetParameters(const char *keys) const {
+  ALOGE("GceAudio::%s: not implemented", __FUNCTION__);
+  if (keys) D("GceAudio::%s: kvpairs %s", __FUNCTION__, keys);
+  return strdup("");
+}
+
+int GceAudio::SetStreamParameters(
+    struct audio_stream *stream, const char *kv_pairs) {
+  struct str_parms *parms = str_parms_create_str(kv_pairs);
+  if (!parms) {
+    return 0;
+  }
+  int sample_rate;
+  if (str_parms_get_int(parms, AUDIO_PARAMETER_STREAM_SAMPLING_RATE,
+                        &sample_rate) >= 0) {
+    stream->set_sample_rate(stream, sample_rate);
+  }
+  int format;
+  if (str_parms_get_int(parms, AUDIO_PARAMETER_STREAM_FORMAT,
+                        &format) >= 0) {
+    stream->set_format(stream, static_cast<audio_format_t>(format));
+  }
+  int routing;
+  if (str_parms_get_int(parms, AUDIO_PARAMETER_STREAM_ROUTING,
+                        &routing) >= 0) {
+    stream->set_device(stream, static_cast<audio_devices_t>(routing));
+  }
+  if (str_parms_get_int(parms, AUDIO_PARAMETER_STREAM_INPUT_SOURCE,
+                        &routing) >= 0) {
+    stream->set_device(stream, static_cast<audio_devices_t>(routing));
+  }
+  str_parms_destroy(parms);
+  return 0;
+}
+
+}
diff --git a/guest/hals/audio/legacy/vsoc_audio.h b/guest/hals/audio/legacy/vsoc_audio.h
new file mode 100644
index 0000000..7b96878
--- /dev/null
+++ b/guest/hals/audio/legacy/vsoc_audio.h
@@ -0,0 +1,306 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+#pragma once
+
+#include <list>
+#include <map>
+#include <memory>
+
+#include "common/libs/fs/shared_fd.h"
+#include "common/libs/threads/cuttlefish_thread.h"
+#include "common/vsoc/lib/audio_data_region_view.h"
+#include "common/vsoc/lib/vsoc_audio_message.h"
+#include "guest/hals/audio/legacy/audio_hal.h"
+#include "guest/hals/audio/legacy/vsoc_audio_input_stream.h"
+
+namespace cvd {
+
+class GceAudioInputStream;
+class GceAudioOutputStream;
+
+class GceAudio : public audio_hw_device {
+ public:
+  // This common code manipulates the parameters of input and output streams.
+  static int SetStreamParameters(struct audio_stream *, const char *);
+
+  ~GceAudio();
+
+  // Non-HAL methods that are part of the GCE implementation.
+  // Most of these are used by the input and output streams.
+
+  // Returns true if the microphone is muted. Used by input streams.
+  bool IsMicrophoneMuted() {
+    cvd::LockGuard<cvd::Mutex> guard(lock_);
+    return mic_muted_;
+  }
+
+  // Send a message to the connected streamer.
+  // Returns:
+  //   0 if there is no streamer.
+  //   >0 if the message was sent.
+  //   -1 if there was an error.
+  ssize_t SendMsg(const msghdr&, int flags);
+
+  // Sends a stream update to the connected streamer.
+  // Stream updates have no frames. Use SendMsg if the message has frames.
+  //   0 if there is no streamer.
+  //   >0 if the message was sent.
+  //   -1 if there was an error.
+  ssize_t SendStreamUpdate(
+      const gce_audio_message& stream_info, int flags);
+
+  // Callbacks for the Android audio_module HAL interface.
+  // Most of the comments below are copied from
+  // libhardware/include/hardware/audio.h
+  //
+  // Where the is a conflict the comments there apply.
+  // By default these methods return 0 on success -<errno> for failure.
+
+  // Opens the device.
+  static int Open(const hw_module_t* module, const char* name,
+                  hw_device_t** device);
+
+  // Closes the device, closing any open input streams and output streams.
+  int Close();
+
+  // Closes the input stream, throwing away any data in the buffer.
+  void CloseInputStream(audio_stream_in* stream);
+
+  // Closes the output stream without waiting for the buffer to clear.
+  void CloseOutputStream(audio_stream_out* stream);
+
+  // Creates an audio patch between several source and sink ports.
+  // The handle is allocated by the HAL and should be unique for this
+  // audio HAL module.
+  // TODO(ghartman): Implement this as part of HAL 3.0
+  //int CreateAudioPatch(unsigned int num_sources,
+  //                     const struct audio_port_config *sources,
+  //                     unsigned int num_sinks,
+  //                     const struct audio_port_config *sinks,
+  //                     audio_patch_handle_t *handle);
+
+  // dumps the state of the audio hardware to the given fd.
+  // This information can be retrieved using the dumpsys utility.
+  int Dump(int fd) const;
+
+  // Fills the list of supported attributes for a given audio port.
+  // As input, "port" contains the information (type, role, address etc...)
+  // needed by the HAL to identify the port.
+  // As output, "port" contains possible attributes (sampling rates, formats,
+  // channel masks, gain controllers...) for this port.
+  // TODO(ghartman): Implement this as part of HAL 3.0
+  // int GetAudioPort(struct audio_port *port);
+
+  // Sets audio port configuration
+  // TODO(ghartman): Implement this as part of HAL 3.0
+  // int SetAudioPortConfig(const struct audio_port_config *config);
+
+  size_t GetInputBufferSize(const audio_config*) const;
+
+  // Gets the current master volume value for the HAL, if the HAL supports
+  // master volume control.  AudioFlinger will query this value from the
+  // primary audio HAL when the service starts and use the value for setting
+  // the initial master volume across all HALs.  HALs which do not support
+  // this method may leave it set to NULL.
+  int GetMasterVolume(float* /*volume*/);
+
+  // Get the current master mute status for the HAL, if the HAL supports
+  // master mute control.  AudioFlinger will query this value from the primary
+  // audio HAL when the service starts and use the value for setting the
+  // initial master mute across all HALs.  HALs which do not support this
+  // method may leave it set to NULL.
+  int GetMasterMute(bool* muted);
+
+  // Gets the audio mute status for the microphone.
+  int GetMicMute(bool* state) const;
+
+  // Retrieves the global audio parameters.
+  // TODO(ghartman): Implement this.
+  char* GetParameters(const char* keys) const;
+
+  // Enumerates what devices are supported by each audio_hw_device
+  // implementation.
+  // Return value is a bitmask of 1 or more values of audio_devices_t
+  // used by audio flinger.
+  // NOTE: audio HAL implementations starting with
+  // AUDIO_DEVICE_API_VERSION_2_0 do not implement this function.
+  // AUDIO_DEVICE_API_VERSION_2_0 was the current version as of JB-MR1
+  // All supported devices should be listed in audio_policy.conf
+  // file and the audio policy manager must choose the appropriate
+  // audio module based on information in this file.
+  uint32_t GetSupportedDevices() const;
+
+  // Checks to see if the audio hardware interface has been initialized.
+  // Always returns 0 to indicate success, but -ENODEV is also allowed to
+  // indicate failure.
+  int InitCheck() const;
+
+  // Creates an additional hardware input stream.
+  // Additional parameters were added in the 3.0 version of the HAL.
+  // These defaults make it easier to implement a cross-branch device.
+  int OpenInputStream(
+      audio_io_handle_t handle,
+      audio_devices_t devices, audio_config *config,
+      audio_stream_in **stream_in,
+      audio_input_flags_t flags = AUDIO_INPUT_FLAG_NONE,
+      const char* address = 0,
+      audio_source_t source = AUDIO_SOURCE_DEFAULT);
+
+  // Creates an additional output stream.
+  // The "address" parameter qualifies the "devices" audio device type if
+  // needed. On GCE we ignore it for now because we simulate a single SoC
+  // hw devices.
+  //
+  // The format format depends on the device type:
+  //   Bluetooth devices use the MAC address of the device in the form
+  //     "00:11:22:AA:BB:CC"
+  // USB devices use the ALSA card and device numbers in the form
+  //     "card=X;device=Y"
+  // Other devices may use a number or any other string.
+  int OpenOutputStream(
+      audio_io_handle_t handle,
+      audio_devices_t devices, audio_output_flags_t flags,
+      audio_config* config, audio_stream_out** stream_out,
+      const char* address = 0);
+
+  // Releases an audio patch.
+  // TODO(ghartman): Implement this as part of HAL 3.0
+  //int ReleaseAudioPatch(audio_patch_handle_t handle);
+
+  // Sets the audio mute status for all audio activities.  If any value other
+  // than 0 is returned, the software mixer will emulate this capability.
+  // The GCE implementation always returns 0.
+  int SetMasterMute(bool muted);
+
+  // Sets the audio volume for all audio activities other than voice call.
+  // Range between 0.0 and 1.0. If any value other than 0 is returned,
+  // the software mixer will emulate this capability.
+  // The GCE implementation always returns 0.
+  int SetMasterVolume(float volume);
+
+  // Sets the audio mute status for the microphone.
+  int SetMicMute(bool state);
+
+  // set_mode is called when the audio mode changes. AUDIO_MODE_NORMAL mode
+  // is for standard audio playback, AUDIO_MODE_RINGTONE when a ringtone is
+  // playing, and AUDIO_MODE_IN_CALL when a call is in progress.
+  int SetMode(audio_mode_t mode);
+
+  // Sets the global audio parameters.
+  // TODO(ghartman): Create a sensible implementation.
+  int SetParameters(const char* kvpairs);
+
+  // Sets the audio volume of a voice call. Range is between 0.0 and 1.0
+  int SetVoiceVolume(float volume);
+
+
+ private:
+  // HAL 3.0 modifies the signatures of OpenInputStream and OpenOutputStream.
+  // We don't want to fork the implementation, and we don't want #ifdefs all
+  // over the code. The current implementation defines OpenInputStream and
+  // OpenOutputStream with default values for the paramteres that were added,
+  // and then generates a HAL-specific wrapper to be used in the function
+  // table.
+#if defined(AUDIO_DEVICE_API_VERSION_3_0)
+  typedef int OpenInputStreamHAL_t(
+      audio_io_handle_t, audio_devices_t, audio_config*, audio_stream_in**,
+      audio_input_flags_t, const char*, audio_source_t);
+
+  int OpenInputStreamCurrentHAL(
+      audio_io_handle_t a, audio_devices_t b, audio_config* c,
+      audio_stream_in** d, audio_input_flags_t e, const char* f,
+      audio_source_t g) {
+    return OpenInputStream(a, b, c, d, e, f, g);
+  }
+
+  typedef int OpenOutputStreamHAL_t(
+      audio_io_handle_t, audio_devices_t, audio_output_flags_t,
+      audio_config*, audio_stream_out**,
+      const char*);
+
+  int OpenOutputStreamCurrentHAL(
+      audio_io_handle_t a, audio_devices_t b, audio_output_flags_t c,
+      audio_config* d, audio_stream_out** e,
+      const char* f) {
+    return OpenOutputStream(a, b, c, d, e, f);
+  }
+#else
+  typedef int OpenInputStreamHAL_t(
+      audio_io_handle_t, audio_devices_t, audio_config*, audio_stream_in**);
+
+  int OpenInputStreamCurrentHAL(
+      audio_io_handle_t a, audio_devices_t b, audio_config* c,
+      audio_stream_in** d) {
+    return OpenInputStream(a, b, c, d);
+  }
+
+  typedef int OpenOutputStreamHAL_t(
+      audio_io_handle_t, audio_devices_t, audio_output_flags_t,
+      audio_config*, audio_stream_out**);
+
+  int OpenOutputStreamCurrentHAL(
+      audio_io_handle_t a, audio_devices_t b, audio_output_flags_t c,
+      audio_config* d, audio_stream_out** e) {
+    return OpenOutputStream(a, b, c, d, e);
+  }
+#endif
+
+  //TODO(ghartman): Update this when we support 3.0.
+#if defined(AUDIO_DEVICE_API_VERSION_2_0)
+  static const unsigned int version_ = AUDIO_DEVICE_API_VERSION_2_0;
+#else
+  static const unsigned int version_ = AUDIO_DEVICE_API_VERSION_1_0;
+#endif
+
+  using AudioDataRegionView = vsoc::audio_data::AudioDataRegionView;
+  AudioDataRegionView* audio_data_rv_{};
+  std::unique_ptr<vsoc::RegionWorker> audio_worker_;
+
+  // Lock to protect the data below.
+  mutable cvd::Mutex lock_;
+  // State that is managed at the device level.
+  float voice_volume_;
+  float master_volume_;
+  bool master_muted_;
+  bool mic_muted_;
+  audio_mode_t mode_;
+  // There can be multiple input and output streams. This field is used
+  // to assign each one a unique identifier.
+  // TODO(ghartman): This can wrap after 2^32 streams. Ideally we should check
+  // the output_list_ to ensure that the stream number hasn't been assigned.
+  // However, streams don't really appear and disapper that often.
+  // We use the same counter for both input and output streams to make things
+  // a little easier on the client.
+  uint32_t next_stream_number_;
+  // List of the currently active output streams.
+  // Used to clean things up Close()
+  std::list<GceAudioOutputStream *> output_list_;
+  // List of the currently active input streams.
+  // Used to clean things up Close()
+  typedef std::map<uint32_t, GceAudioInputStream *> input_map_t;
+  input_map_t input_map_;
+
+  GceAudio() :
+      audio_hw_device(),
+      voice_volume_(0.0),
+      master_volume_(0.0),
+      master_muted_(false),
+      mic_muted_(false),
+      mode_(AUDIO_MODE_NORMAL),
+      next_stream_number_(1) { }
+};
+
+}
diff --git a/guest/hals/audio/legacy/vsoc_audio_input_stream.cpp b/guest/hals/audio/legacy/vsoc_audio_input_stream.cpp
new file mode 100644
index 0000000..bb9e196
--- /dev/null
+++ b/guest/hals/audio/legacy/vsoc_audio_input_stream.cpp
@@ -0,0 +1,184 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <cstdint>
+#include <cinttypes>
+
+extern "C"{
+#include <cutils/str_parms.h>
+}
+
+#include "common/libs/auto_resources/auto_resources.h"
+#include "common/libs/threads/thunkers.h"
+#include "guest/hals/audio/legacy/audio_hal.h"
+#include "guest/hals/audio/legacy/vsoc_audio.h"
+#include "guest/hals/audio/legacy/vsoc_audio_input_stream.h"
+
+namespace cvd {
+
+#if defined(AUDIO_DEVICE_API_VERSION_3_0)
+static inline size_t GceAudioFrameSize(const audio_stream_in* s) {
+  return audio_stream_in_frame_size(s);
+}
+#elif defined(AUDIO_DEVICE_API_VERSION_2_0)
+static inline size_t GceAudioFrameSize(const audio_stream_in* s) {
+
+  return audio_stream_frame_size(&s->common);
+}
+#else
+static inline size_t GceAudioFrameSize(audio_stream_in* s) {
+
+  return audio_stream_frame_size(&s->common);
+}
+#endif
+
+GceAudioInputStream::GceAudioInputStream(
+    cvd::GceAudio* dev, audio_devices_t devices, const audio_config& config)
+    : audio_stream_in(),
+      dev_(dev),
+      config_(config),
+      gain_(0.0),
+      device_(devices) {
+  common.get_sample_rate =
+      cvd::thunk<audio_stream, &GceAudioInputStream::GetSampleRate>;
+  common.set_sample_rate =
+      cvd::thunk<audio_stream, &GceAudioInputStream::SetSampleRate>;
+  common.get_buffer_size =
+      cvd::thunk<audio_stream, &GceAudioInputStream::GetBufferSize>;
+  common.get_channels =
+      cvd::thunk<audio_stream, &GceAudioInputStream::GetChannels>;
+  common.get_device = cvd::thunk<audio_stream, &GceAudioInputStream::GetDevice>;
+  common.set_device = cvd::thunk<audio_stream, &GceAudioInputStream::SetDevice>;
+  common.get_format = cvd::thunk<audio_stream, &GceAudioInputStream::GetFormat>;
+  common.set_format = cvd::thunk<audio_stream, &GceAudioInputStream::SetFormat>;
+  common.standby = cvd::thunk<audio_stream, &GceAudioInputStream::Standby>;
+  common.dump = cvd::thunk<audio_stream, &GceAudioInputStream::Dump>;
+  common.set_parameters = GceAudio::SetStreamParameters;
+  common.get_parameters =
+      cvd::thunk<audio_stream, &GceAudioInputStream::GetParameters>;
+  common.add_audio_effect =
+      cvd::thunk<audio_stream, &GceAudioInputStream::AddAudioEffect>;
+  common.remove_audio_effect = cvd::thunk<audio_stream,
+    &GceAudioInputStream::RemoveAudioEffect>;
+  set_gain = cvd::thunk<audio_stream_in, &GceAudioInputStream::SetGain>;
+  read = cvd::thunk<audio_stream_in,
+    &GceAudioInputStream::Read>;
+  get_input_frames_lost = cvd::thunk<audio_stream_in,
+    &GceAudioInputStream::GetInputFramesLost>;
+  frame_size_ = GceAudioFrameSize(this);
+  buffer_model_.reset(
+      new SimulatedInputBuffer(config_.sample_rate, GetBufferSize() /
+                               frame_size_));
+  reported_lost_frames_ = 0;
+}
+
+gce_audio_message GceAudioInputStream::GetStreamDescriptor(
+    uint32_t stream_number, gce_audio_message::message_t event) {
+  gce_audio_message rval;
+  rval.message_type = event;
+  rval.stream_number = stream_number;
+  rval.frame_num = buffer_model_->GetCurrentItemNum();
+  rval.time_presented =
+      buffer_model_->GetLastUpdatedTime().SinceEpoch().GetTS();
+  rval.frame_rate = config_.sample_rate;
+  rval.channel_mask = config_.channel_mask;
+  rval.format = config_.format;
+  rval.frame_size = frame_size_;
+  return rval;
+}
+
+int GceAudioInputStream::Open(GceAudio* dev,
+                              audio_io_handle_t /*handle*/,
+                              audio_devices_t devices,
+                              const audio_config& config,
+                              GceAudioInputStream** stream_in) {
+  D("GceAudioInputStream::%s", __FUNCTION__);
+  *stream_in = new GceAudioInputStream(dev, devices, config);
+  return 0;
+}
+
+int GceAudioInputStream::SetFormat(audio_format_t format) {
+  config_.format = format;
+  frame_size_ = GceAudioFrameSize(this);
+  return 0;
+}
+
+int GceAudioInputStream::Dump(int fd) const {
+  D("GceAudioInputStream::%s", __FUNCTION__);
+  dprintf(
+      fd,
+      "\tInputSteam Dump:\n"
+      "\t\tsample rate: %u\n"
+      "\t\tbuffer size: %zu\n"
+      "\t\tchannel mask: %08x\n"
+      "\t\tformat: %d\n"
+      "\t\tdevice: %08x\n"
+      "\t\taudio dev: %p\n\n",
+      GetSampleRate(), GetBufferSize(),
+      GetChannels(), GetFormat(), device_, dev_);
+  return 0;
+}
+
+int GceAudioInputStream::SetSampleRate(uint32_t sample_rate) {
+  if (sample_rate != config_.sample_rate) {
+    config_.sample_rate = sample_rate;
+    buffer_model_.reset(
+        new SimulatedInputBuffer(sample_rate, GetBufferSize() / frame_size_));
+    reported_lost_frames_ = 0;
+  }
+  return 0;
+}
+
+char* GceAudioInputStream::GetParameters(const char* keys) const {
+  D("GceAudioInputStream::%s", __FUNCTION__);
+  if (keys) D("GceAudioInputStream::%s keys %s", __FUNCTION__, keys);
+
+  str_parms* query = str_parms_create_str(keys);
+  str_parms* reply = str_parms_create();
+
+  char value[256];
+  int ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_ROUTING,
+                              value, sizeof(value));
+  char* str;
+  if (ret >= 0) {
+    str_parms_add_int(reply, AUDIO_PARAMETER_STREAM_ROUTING, device_);
+    str = strdup(str_parms_to_str(reply));
+  } else {
+    str = strdup(keys);
+  }
+  str_parms_destroy(query);
+  str_parms_destroy(reply);
+  return str;
+}
+
+
+ssize_t GceAudioInputStream::Read(void* buffer, size_t bytes) {
+  int64_t available = buffer_model_->RemoveFromInputBuffer(
+      bytes / frame_size_, false) * frame_size_;
+  ssize_t rval = available;
+  if ((rval != available) || (rval < 0)) {
+    ALOGE("GceAudioInputStream:%s got bad value from "
+          "RemoveFromInputBuffer %" PRId64, __FUNCTION__, available);
+    return -1;
+  }
+  memset(buffer, 0, rval);
+  return rval;
+}
+
+}
diff --git a/guest/hals/audio/legacy/vsoc_audio_input_stream.h b/guest/hals/audio/legacy/vsoc_audio_input_stream.h
new file mode 100644
index 0000000..222194c
--- /dev/null
+++ b/guest/hals/audio/legacy/vsoc_audio_input_stream.h
@@ -0,0 +1,169 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+#pragma once
+
+#include <memory>
+
+#include "common/libs/utils/simulated_buffer.h"
+#include "common/vsoc/lib/vsoc_audio_message.h"
+#include "guest/hals/audio/legacy/audio_hal.h"
+
+namespace cvd {
+
+namespace {
+static const int IN_BUFFER_BYTES = 4096;
+}
+
+class GceAudio;
+
+// Defines static callback functions for generic_stream_in HAL interface.
+class GceAudioInputStream : public audio_stream_in {
+ public:
+  // These methods are internal to the GCE audio implementation.
+  // Factory for new input streams.
+  static int Open(
+      GceAudio* dev, audio_io_handle_t handle,
+      audio_devices_t devices, const audio_config& config,
+      GceAudioInputStream** stream_in);
+
+  // Gets a description of this stream
+  gce_audio_message GetStreamDescriptor(
+      uint32_t stream_number, gce_audio_message::message_t event);
+
+  // audio_stream_in implementation. These definitions follow the ones
+  // in hardware/libhardware/include/hardware/audio.h
+
+  // Returns the sampling rate in Hz - eg. 44100.
+  uint32_t GetSampleRate() const { return config_.sample_rate; }
+
+  // Sets the sample rate
+  // no direct calls from JB and later, but called indirectly from
+  // GceAudio::SetStreamParamters when it finds
+  // AUDIO_PARAMETER_STREAM_SAMPLING_RATE
+  int SetSampleRate(uint32_t rate);
+
+  // Returns the size of input/output buffer in bytes for this stream - eg.
+  // 4800.
+  // It should be a multiple of the frame size.  See also get_input_buffer_size
+  size_t GetBufferSize() const {
+    return IN_BUFFER_BYTES;
+  }
+
+  // Returns the channel mask -
+  //   e.g. AUDIO_CHANNEL_OUT_STEREO or AUDIO_CHANNEL_IN_STEREO
+  audio_channel_mask_t GetChannels() const {
+    return config_.channel_mask;
+  }
+
+  // Returns the audio format - e.g. AUDIO_FORMAT_PCM_16_BIT
+  audio_format_t GetFormat() const {
+    return config_.format;
+  }
+
+  // Sets the audio format
+  // no direct calls from JB and later, but called indirectly from
+  // GceAudio::SetStreamParamters when it finds
+  //   AUDIO_PARAMETER_STREAM_FORMAT
+  int SetFormat(audio_format_t format);
+
+  // Puts the audio hardware input/output into standby mode.
+  // Driver should exit from standby mode at the next I/O operation.
+  // Returns 0 on success and <0 on failure.
+  int Standby() { return 0; }
+
+  // Dumps the state of the audio input/output device
+  int Dump(int fd) const;
+
+  // Returns the set of device(s) which this stream is connected to
+  audio_devices_t GetDevice() const {
+    return device_;
+  }
+
+  // Sets the device this stream is connected to.
+  // no direct calls from JB and later, but called indirectly from
+  // GceAudio::SetStreamParamters when it finds
+  //   AUDIO_PARAMETER_STREAM_ROUTING for both input and output.
+  //   AUDIO_PARAMETER_STREAM_INPUT_SOURCE is an additional information used by
+  //                                       input streams only.
+  int SetDevice(audio_devices_t device) { device_ = device; return 0; }
+
+  // sets audio stream parameters. The function accepts a list of
+  // parameter key value pairs in the form: key1=value1;key2=value2;...
+  //
+  // Some keys are reserved for standard parameters (See AudioParameter class)
+  //
+  // If the implementation does not accept a parameter change while
+  // the output is active but the parameter is acceptable otherwise, it must
+  // return -ENOSYS.
+  // The audio flinger will put the stream in standby and then change the
+  // parameter value.
+  // Uses GceAudio::SetStreamParameters
+
+  // Returns a pointer to a heap allocated string. The caller is responsible
+  // for freeing the memory for it using free().
+  char* GetParameters(const char* keys) const;
+
+  int AddAudioEffect(effect_handle_t /*effect*/) const {
+    return 0;
+  }
+
+  int RemoveAudioEffect(effect_handle_t /*effect*/) const {
+    return 0;
+  }
+
+  // Input stream specific methods
+
+  // Sets the input gain for the audio driver. This method is for
+  // for future use as of M.
+  int SetGain(float gain) {
+    gain_ = gain;
+    return 0;
+  }
+
+  // Reads audio buffer in from audio driver. Returns number of bytes read, or
+  // a negative android::status_t. If at least one frame was read prior to the error,
+  //  read should return that byte count and then return an error in the
+  // subsequent call.
+  ssize_t Read(void* buffer, size_t bytes);
+
+  // Return the amount of input frames lost in the audio driver since the
+  // last call of this function.
+  // Audio driver is expected to reset the value to 0 and restart counting
+  // upon returning the current value by this function call.
+  // Such loss typically occurs when the user space process is blocked
+  // longer than the capacity of audio driver buffers.
+  //
+  // Unit: the number of input audio frames
+  uint32_t GetInputFramesLost() {
+    int64_t cur_lost_frames = buffer_model_->GetLostInputItems();
+    uint32_t rval = cur_lost_frames - reported_lost_frames_;
+    reported_lost_frames_ = cur_lost_frames;
+    return rval;
+  }
+
+ private:
+  GceAudioInputStream(cvd::GceAudio* dev, audio_devices_t devices,
+                      const audio_config& config);
+  std::unique_ptr<SimulatedInputBuffer> buffer_model_;
+  cvd::GceAudio *dev_;
+  audio_config config_;
+  float gain_;
+  audio_devices_t device_;
+  size_t frame_size_;
+  int64_t reported_lost_frames_;
+};
+
+}
diff --git a/guest/hals/audio/legacy/vsoc_audio_output_stream.cpp b/guest/hals/audio/legacy/vsoc_audio_output_stream.cpp
new file mode 100644
index 0000000..571f95e
--- /dev/null
+++ b/guest/hals/audio/legacy/vsoc_audio_output_stream.cpp
@@ -0,0 +1,322 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <memory>
+
+#include <cutils/sockets.h>
+extern "C"{
+#include <cutils/str_parms.h>
+}
+
+#include "common/libs/auto_resources/auto_resources.h"
+#include "common/libs/threads/thunkers.h"
+#include "common/libs/time/monotonic_time.h"
+#include "guest/hals/audio/legacy/audio_hal.h"
+#include "guest/hals/audio/legacy/vsoc_audio.h"
+#include "guest/hals/audio/legacy/vsoc_audio_output_stream.h"
+#include "guest/libs/remoter/remoter_framework_pkt.h"
+
+#if defined(AUDIO_DEVICE_API_VERSION_3_0)
+static inline size_t GceAudioFrameSize(const audio_stream_out* s) {
+  return audio_stream_out_frame_size(s);
+}
+#elif defined(AUDIO_DEVICE_API_VERSION_2_0)
+static inline size_t GceAudioFrameSize(const audio_stream_out* s) {
+
+  return audio_stream_frame_size(&s->common);
+}
+#else
+static inline size_t GceAudioFrameSize(audio_stream_out* s) {
+
+  return audio_stream_frame_size(&s->common);
+}
+#endif
+
+namespace cvd {
+
+const size_t GceAudioOutputStream::kOutBufferSize;
+const size_t GceAudioOutputStream::kOutLatency;
+
+GceAudioOutputStream::GceAudioOutputStream(GceAudio* dev) :
+    audio_stream_out(),
+    dev_(dev),
+    device_(AUDIO_DEVICE_OUT_DEFAULT),
+    frame_count_(0),
+    left_volume_(0.0),
+    right_volume_(0.0) { }
+
+int GceAudioOutputStream::Dump(int fd) const {
+  D("GceAudioOutputStream::%s", __FUNCTION__);
+  dprintf(
+      fd,
+      "\tout_dump:\n"
+      "\t\tsample rate: %u\n"
+      "\t\tbuffer size: %zu\n"
+      "\t\tchannel mask: %08x\n"
+      "\t\tformat: %d\n"
+      "\t\tdevice: %08x\n"
+      "\t\taudio dev: %p\n\n",
+      GetSampleRate(),
+      GetBufferSize(),
+      GetChannels(),
+      GetFormat(),
+      device_,
+      dev_);
+  return 0;
+}
+
+int GceAudioOutputStream::GetNextWriteTimestamp(int64_t* nstime) const {
+  *nstime = cvd::time::Nanoseconds(
+      buffer_->GetNextOutputBufferItemTime().SinceEpoch()).count();
+  return 0;
+}
+
+namespace {
+struct StrParmsDestroyer {
+  void operator()(str_parms* parms) const {
+    if (parms) {
+      str_parms_destroy(parms);
+    }
+  }
+};
+
+typedef std::unique_ptr<str_parms, StrParmsDestroyer> StrParmsPtr;
+}
+
+int GceAudioOutputStream::SetParameters(const char* kv_pairs) {
+  int err = 0;
+  StrParmsPtr parms(str_parms_create_str(kv_pairs));
+  {
+    int fmt = 0;
+    if (str_parms_get_int(parms.get(), AUDIO_PARAMETER_STREAM_FORMAT, &fmt)
+        == 0) {
+      SetFormat(static_cast<audio_format_t>(fmt));
+    }
+  }
+  {
+    int sample_rate = 0;
+    if (str_parms_get_int(parms.get(), AUDIO_PARAMETER_STREAM_SAMPLING_RATE,
+                          &sample_rate) == 0) {
+      SetSampleRate(static_cast<uint32_t>(sample_rate));
+    }
+  }
+  {
+    int routing = 0;
+    if (str_parms_get_int(parms.get(), AUDIO_PARAMETER_STREAM_ROUTING,
+                          &routing) == 0) {
+      device_ = static_cast<uint32_t>(routing);
+    }
+  }
+  {
+    int channels = 0;
+    if (str_parms_get_int(parms.get(), AUDIO_PARAMETER_STREAM_CHANNELS,
+                          &channels) == 0) {
+      message_header_.channel_mask = static_cast<audio_channel_mask_t>(channels);
+    }
+  }
+  {
+    int frame_count = 0;
+    if (str_parms_get_int(parms.get(), AUDIO_PARAMETER_STREAM_FRAME_COUNT,
+                          &frame_count) == 0) {
+      frame_count_ = static_cast<size_t>(frame_count);
+    }
+  }
+  {
+    int input_source = 0;
+    if (str_parms_get_int(parms.get(), AUDIO_PARAMETER_STREAM_INPUT_SOURCE,
+                          &input_source) == 0){
+      ALOGE("GceAudioOutputStream::%s AUDIO_PARAMETER_STREAM_INPUT_SOURCE"
+            " passed to an output stream", __FUNCTION__);
+      err = -EINVAL;
+    }
+  }
+  return err;
+}
+
+void GceAudioOutputStream::AddIntIfKeyPresent(
+    /*const */ str_parms* query, str_parms* reply, const char* key, int value) {
+  if (str_parms_get_str(query, key, NULL, 0) >= 0) {
+    str_parms_add_int(reply, key, value);
+  }
+}
+
+
+char* GceAudioOutputStream::GetParameters(const char* keys) const {
+  D("GceAudioOutputStream::%s", __FUNCTION__);
+  if (keys) D("%s keys %s", __FUNCTION__, keys);
+
+  StrParmsPtr query(str_parms_create_str(keys));
+  StrParmsPtr reply(str_parms_create());
+
+  AddIntIfKeyPresent(query.get(), reply.get(),
+                     AUDIO_PARAMETER_STREAM_FORMAT,
+                     static_cast<int>(GetFormat()));
+  AddIntIfKeyPresent(query.get(), reply.get(),
+                     AUDIO_PARAMETER_STREAM_SAMPLING_RATE,
+                     static_cast<int>(GetSampleRate()));
+  AddIntIfKeyPresent(query.get(), reply.get(),
+                     AUDIO_PARAMETER_STREAM_ROUTING,
+                     static_cast<int>(device_));
+  AddIntIfKeyPresent(query.get(), reply.get(),
+                     AUDIO_PARAMETER_STREAM_CHANNELS,
+                     static_cast<int>(message_header_.channel_mask));
+  AddIntIfKeyPresent(query.get(), reply.get(),
+                     AUDIO_PARAMETER_STREAM_FRAME_COUNT,
+                     static_cast<int>(frame_count_));
+
+  char *str = str_parms_to_str(reply.get());
+  return str;
+}
+
+int GceAudioOutputStream::GetRenderPosition(uint32_t* dsp_frames) const {
+  *dsp_frames = buffer_->GetCurrentItemNum();
+  return 0;
+}
+
+ssize_t GceAudioOutputStream::Write(const void* buffer, size_t length) {
+  // We're always the blocking case for now.
+  static const bool blocking = true;
+  message_header_.frame_size = frame_size_;
+  frame_count_ += message_header_.num_frames_presented = length / frame_size_;
+  message_header_.message_type = gce_audio_message::DATA_SAMPLES;
+  // First do a nonblocking add
+  int64_t frames_accepted_without_blocking = buffer_->AddToOutputBuffer(
+      message_header_.num_frames_presented, false);
+  // This seems backward, but adding the items to the buffer first
+  // allows us to calculate the right frame number in the case of underflow.
+  message_header_.frame_num =
+      buffer_->GetNextOutputBufferItemNum() - frames_accepted_without_blocking;
+  message_header_.time_presented =
+      buffer_->GetLastUpdatedTime().SinceEpoch().GetTS();
+  // We want to send the message before blocking. If we're in blocking mode
+  // we will accept all of the frames.
+  if (blocking) {
+    message_header_.num_frames_accepted =
+        message_header_.num_frames_presented;
+  } else {
+    message_header_.num_frames_accepted = frames_accepted_without_blocking;
+  }
+  // Never exceed the maximum packet size, as defined by the interface.
+  // Clip off any frames that we can't transmit and increment the clipped
+  // count.
+  size_t transmitted_frame_size = length;
+  if (length > gce_audio_message::kMaxAudioFrameLen) {
+    transmitted_frame_size = gce_audio_message::kMaxAudioFrameLen;
+    message_header_.num_packets_shortened++;
+  }
+  message_header_.total_size =
+      sizeof(message_header_) + transmitted_frame_size;
+  // Now send the message. Do not block if the receiver isn't ready
+  // If this is a blocking write we will block after we have attempted to
+  // send the data to the receiver.
+  msghdr msg;
+  iovec msg_iov[2];
+  // We need a cast here because iov_base is defined non-const to support
+  // recvmsg et.al.
+  // There is no danger here:sendmsg does not write to the buffer.
+  msg_iov[0].iov_base = &message_header_;
+  msg_iov[0].iov_len = sizeof(message_header_);
+  msg_iov[1].iov_base = const_cast<void*>(buffer);
+  msg_iov[1].iov_len = transmitted_frame_size;
+  msg.msg_name = NULL;
+  msg.msg_namelen = 0;
+  msg.msg_iov = msg_iov;
+  msg.msg_iovlen = arraysize(msg_iov);
+  msg.msg_control = NULL;
+  msg.msg_controllen = 0;
+  msg.msg_flags = 0;
+  if (dev_->SendMsg(msg, MSG_DONTWAIT) < 0) {
+    message_header_.num_packets_dropped++;
+  }
+  if (!blocking) {
+    return frames_accepted_without_blocking * frame_size_;
+  }
+  if ((message_header_.num_frames_presented) >
+      static_cast<size_t>(frames_accepted_without_blocking)) {
+    buffer_->AddToOutputBuffer(
+        message_header_.num_frames_presented -
+        frames_accepted_without_blocking, true);
+  }
+  return message_header_.num_frames_presented * frame_size_;
+}
+
+int GceAudioOutputStream::Open(
+    GceAudio* dev, audio_io_handle_t /*handle*/,
+    audio_devices_t devices, audio_output_flags_t /*flags*/,
+    audio_config* config, uint32_t stream_number,
+    GceAudioOutputStream** stream_out) {
+  D("GceAudioOutputStream::%s", __FUNCTION__);
+  *stream_out = NULL;
+  // Deleted by Close(); UniquePtr holds until end of Open().
+  std::unique_ptr<GceAudioOutputStream> out(
+      new GceAudioOutputStream(dev));
+  out->message_header_.stream_number = stream_number;
+  out->message_header_.format = config->format;
+  out->message_header_.channel_mask = config->channel_mask;
+  out->message_header_.frame_rate = config->sample_rate;
+  out->frame_count_ = config->frame_count;
+  out->common.get_sample_rate =
+      cvd::thunk<audio_stream, &GceAudioOutputStream::GetSampleRate>;
+  out->common.set_sample_rate =
+      cvd::thunk<audio_stream, &GceAudioOutputStream::SetSampleRate>;
+  out->common.get_buffer_size =
+      cvd::thunk<audio_stream, &GceAudioOutputStream::GetBufferSize>;
+  out->common.get_channels =
+      cvd::thunk<audio_stream, &GceAudioOutputStream::GetChannels>;
+  out->common.get_format = cvd::thunk<audio_stream, &GceAudioOutputStream::GetFormat>;
+  out->common.set_format = cvd::thunk<audio_stream, &GceAudioOutputStream::SetFormat>;
+  out->common.standby = cvd::thunk<audio_stream, &GceAudioOutputStream::Standby>;
+  out->common.dump = cvd::thunk<audio_stream, &GceAudioOutputStream::Dump>;
+  out->common.get_device = cvd::thunk<audio_stream, &GceAudioOutputStream::GetDevice>;
+  out->common.set_device = cvd::thunk<audio_stream, &GceAudioOutputStream::SetDevice>;
+  out->common.set_parameters =
+      cvd::thunk<audio_stream, &GceAudioOutputStream::SetParameters>;
+  out->common.get_parameters =
+      cvd::thunk<audio_stream, &GceAudioOutputStream::GetParameters>;
+  out->common.add_audio_effect =
+      cvd::thunk<audio_stream, &GceAudioOutputStream::AddAudioEffect>;
+  out->common.remove_audio_effect =
+      cvd::thunk<audio_stream, &GceAudioOutputStream::RemoveAudioEffect>;
+
+  out->get_latency =
+      cvd::thunk<audio_stream_out, &GceAudioOutputStream::GetLatency>;
+  out->set_volume =
+      cvd::thunk<audio_stream_out, &GceAudioOutputStream::SetVolume>;
+  out->write =
+      cvd::thunk<audio_stream_out, &GceAudioOutputStream::Write>;
+  out->get_render_position =
+      cvd::thunk<audio_stream_out, &GceAudioOutputStream::GetRenderPosition>;
+  out->get_next_write_timestamp =
+      cvd::thunk<audio_stream_out, &GceAudioOutputStream::GetNextWriteTimestamp>;
+  out->device_ = devices;
+  out->frame_size_ = GceAudioFrameSize(out.get());
+
+  int64_t item_capacity =
+      out->frame_size_  == 0 ? 0 : out->GetBufferSize() / out->frame_size_;
+  if (item_capacity == 0) {
+    ALOGE("Attempt to create GceAudioOutputStream with frame_size_ of 0.");
+    return -EINVAL;
+  }
+  out->buffer_.reset(
+      new SimulatedOutputBuffer(
+          config->sample_rate, item_capacity));
+  *stream_out = out.release();
+  return 0;
+}
+
+}  // namespace cvd
diff --git a/guest/hals/audio/legacy/vsoc_audio_output_stream.h b/guest/hals/audio/legacy/vsoc_audio_output_stream.h
new file mode 100644
index 0000000..70ced6e
--- /dev/null
+++ b/guest/hals/audio/legacy/vsoc_audio_output_stream.h
@@ -0,0 +1,313 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+#pragma once
+
+#include <memory>
+
+#include "common/libs/utils/simulated_buffer.h"
+#include "common/vsoc/lib/vsoc_audio_message.h"
+#include "guest/hals/audio/legacy/audio_hal.h"
+
+namespace cvd {
+
+// Defines static callback functions for the audio_stream and audio_stream_out
+// interfaces in  libhardware/include/hardware/audio.h
+//
+// Where the is a conflict the comments there apply.
+// By default these methods return 0 on success -<errno> for failure.
+class GceAudioOutputStream : public audio_stream_out {
+ public:
+  // Factory method for a new output stream.
+  static int Open(GceAudio* dev, audio_io_handle_t handle,
+                  audio_devices_t devices, audio_output_flags_t flags,
+                  audio_config* config, uint32_t stream_number,
+                  GceAudioOutputStream** stream_out);
+
+  gce_audio_message GetStreamDescriptor(
+      gce_audio_message::message_t message_type) const {
+    gce_audio_message rval = message_header_;
+    rval.total_size = sizeof(rval);
+    rval.header_size = sizeof(rval);
+    rval.message_type = message_type;
+    rval.num_frames_presented = 0;
+    rval.num_frames_accepted = 0;
+    return rval;
+  }
+
+  // Method from audio_stream, listed in order of appearance.
+  // TODO(ghartman): Consider moving these if they could be shared with
+  // gce_audio_input_stream.
+
+
+  // Returns the sampling rate in Hz - eg. 44100.
+  uint32_t GetSampleRate() const {
+    return message_header_.frame_rate;
+  }
+
+  // Sets the sample rate
+  //   AUDIO_PARAMETER_STREAM_SAMPLING_RATE
+  int SetSampleRate(uint32_t sample_rate) {
+    if (sample_rate != message_header_.frame_rate) {
+      message_header_.frame_rate = sample_rate;
+      // TODO(ghartman): The output buffer should be quantized at about 192
+      // bytes for better fidelity. Do this by passing
+      // frame_rate * frame_size / 192 and then rescaling the outputs.
+      // Or we could always create a quantized wrapper of the buffer...
+      buffer_.reset(
+          new SimulatedOutputBuffer(
+              sample_rate, GetBufferSize() / frame_size_));
+    }
+    return 0;
+  }
+
+  // Returns the size of input/output buffer in bytes for this stream.
+  // eg. 4800.
+  // It should be a multiple of the frame size.  See also GetInputBufferSize.
+  size_t GetBufferSize() const {
+    return kOutBufferSize;
+  }
+
+  // Returns the channel mask -
+  //  e.g. AUDIO_CHANNEL_OUT_STEREO or AUDIO_CHANNEL_IN_STEREO
+  audio_channel_mask_t GetChannels() const {
+    return message_header_.channel_mask;
+  }
+
+  // Returns the audio format - e.g. AUDIO_FORMAT_PCM_16_BIT
+  audio_format_t GetFormat() const {
+    return message_header_.format;
+  }
+
+  // Sets the audio format.
+  // Unused as of JB - use set_parameters with key
+  //   AUDIO_PARAMETER_STREAM_FORMAT
+  int SetFormat(audio_format_t format) {
+    message_header_.format = format;
+    return 0;
+  }
+
+  // Puts the audio hardware input/output into standby mode.
+  // Driver should exit from standby mode at the next I/O operation.
+  // Returns 0 on success and <0 on failure.
+  // TODO(ghartman): This should reset some of the frame counts.
+  int Standby() {
+    return 0;
+  }
+
+  // dumps the state of the audio hardware to the given fd.
+  // This information can be retrieved using the dumpsys utility.
+  int Dump(int fd) const;
+
+  // Returns the set of device(s) which this stream is connected to.
+  // TODO(ghartman): Implement this.
+  audio_devices_t GetDevice() const { return device_; }
+
+  // Not directly called from JB forward.
+  // Called indirectly from SetParameters with the key
+  //   AUDIO_PARAMETER_STREAM_ROUTING
+  int SetDevice(audio_devices_t device) { device_ = device; return 0; }
+
+  // Sets audio stream parameters. The function accepts a list of
+  // parameter key value pairs in the form: key1=value1;key2=value2;...
+  //
+  // Some keys are reserved for standard parameters (See AudioParameter class)
+  //
+  // If the implementation does not accept a parameter change while
+  // the output is active but the parameter is acceptable otherwise, it must
+  // return -ENOSYS.
+  //
+  // The audio flinger will put the stream in standby and then change the
+  // parameter value.
+  int SetParameters(const char* kv_pairs);
+
+  // Gets audio stream parameters. The function accepts a list of
+  // keys in the form: key1=value1;key2=value2;...
+  //
+  // Returns a pointer to a heap allocated string. The caller is responsible
+  // for freeing the memory for it using free().
+  // TODO(ghartman): Implement this.
+  char* GetParameters(const char* keys) const;
+
+  // TODO(ghartman): Implement this.
+  int AddAudioEffect(effect_handle_t /*effect*/) const {
+    static unsigned int printed = 0;  // printed every 2^32-th call.
+    ALOGE_IF(!printed++, "%s: not implemented", __FUNCTION__);
+    return 0;
+  }
+
+  // TODO(ghartman): Implement this.
+  int RemoveAudioEffect(effect_handle_t /*effect*/) const {
+    static unsigned int printed = 0;  // printed every 2^32-th call.
+    ALOGE_IF(!printed++, "%s: not implemented", __FUNCTION__);
+    return 0;
+  }
+
+  // Methods defined in audio_stream_out
+
+  // Returns the audio hardware driver estimated latency in milliseconds.
+  // TODO(ghartman): Calculate this based on the format and the quantum.
+  uint32_t GetLatency() const {
+    return kOutLatency;
+  }
+
+  // Use this method in situations where audio mixing is done in the
+  // hardware. This method serves as a direct interface with hardware,
+  // allowing you to directly set the volume as apposed to via the framework.
+  // This method might produce multiple PCM outputs or hardware accelerated
+  // codecs, such as MP3 or AAC.
+  //
+  // Note that GCE simulates hardware mixing.
+  int SetVolume(float left_volume, float right_volume) {
+    left_volume_ = left_volume;
+    right_volume_ = right_volume;
+    return 0;
+  }
+
+  // Write audio buffer to driver. Returns number of bytes written, or a
+  // negative android::status_t. If at least one frame was written successfully prior
+  // to the error the driver will return that successful (short) byte count
+  // and then return an error in the subsequent call.
+  //
+  // If SetCallback() has previously been called to enable non-blocking mode
+  // the Write() is not allowed to block. It must write only the number of
+  // bytes that currently fit in the driver/hardware buffer and then return
+  // this byte count. If this is less than the requested write size the
+  // callback function must be called when more space is available in the
+  // driver/hardware buffer.
+  ssize_t Write(const void* buffer, size_t bytes);
+
+  // Returns the number of audio frames written by the audio dsp to DAC since
+  // the output has exited standby
+  // TODO(ghartman): Implement zeroing this in Standby().
+  int GetRenderPosition(uint32_t* dsp_frames) const;
+
+  // Gets the local time at which the next write to the audio driver will be
+  // presented. The units are microseconds, where the epoch is decided by the
+  // local audio HAL.
+  //
+  // The GCE implementation uses CLOCK_MONOTONIC, which also happens to line
+  // up with LocalTime.
+  int GetNextWriteTimestamp(int64_t*) const;
+
+  // Turns on non-blocking mode and sets the callback function for notifying
+  // completion of non-blocking write and drain.
+  // Calling this function implies that all future Write() and Drain()
+  // must be non-blocking and use the callback to signal completion.
+  //
+  // TODO(ghartman): Implement this URGENTLY.
+  //
+  // int SetCallback(stream_callback_t callback, void *cookie);
+
+  // Notifies to the audio driver to stop playback however the queued buffers
+  // are retained by the hardware. Useful for implementing pause/resume. Empty
+  // implementation if not supported however should be implemented for hardware
+  // with non-trivial latency. In the pause state audio hardware could still be
+  // using power. User may consider calling suspend after a timeout.
+  //
+  // Implementation of this function is mandatory for offloaded playback.
+  //
+  // TODO(ghartman): Implement this URGENTLY. There is already support in
+  // SimulatedBuffer.
+  // int Pause();
+
+  // Notifies to the audio driver to resume playback following a pause.
+  // Returns error if called without matching pause.
+  //
+  // Implementation of this function is mandatory for offloaded playback.
+  //
+  // TODO(ghartman): Implement this URGENTLY.
+  //
+  // int Resume();
+
+  // Requests notification when data buffered by the driver/hardware has
+  // been played. If set_callback() has previously been called to enable
+  // non-blocking mode, the drain() must not block, instead it should return
+  // quickly and completion of the drain is notified through the callback.
+  // If set_callback() has not been called, the drain() must block until
+  // completion.
+  //
+  // If type==AUDIO_DRAIN_ALL, the drain completes when all previously written
+  // data has been played.
+  //
+  // If type==AUDIO_DRAIN_EARLY_NOTIFY, the drain completes shortly before all
+  // data for the current track has played to allow time for the framework
+  // to perform a gapless track switch.
+  //
+  // Drain must return immediately on stop() and flush() call
+  //
+  // Implementation of this function is mandatory for offloaded playback.
+  //
+  // TODO(ghartman): Implement this URGENTLY.
+  //
+  // int Drain(audio_drain_type_t type);
+
+  // Notifies to the audio driver to flush the queued data. Stream must already
+  // be paused before calling Flush().
+  //
+  // Implementation of this function is mandatory for offloaded playback.
+  //
+  // TODO(ghartman): Implement this URGENTLY.
+  //
+  // int Flush();
+
+  // Returns a recent count of the number of audio frames presented to an
+  // external observer.  This excludes frames which have been written but are
+  // still in the pipeline.
+  //
+  // The count is not reset to zero when output enters standby.
+  // Also returns the value of CLOCK_MONOTONIC as of this presentation count.
+  // The returned count is expected to be 'recent',
+  // but does not need to be the most recent possible value.
+  // However, the associated time should correspond to whatever count is
+  // returned.
+  //
+  // Example:  assume that N+M frames have been presented, where M is a
+  // 'small' number.
+  // Then it is permissible to return N instead of N+M,
+  // and the timestamp should correspond to N rather than N+M.
+  // The terms 'recent' and 'small' are not defined.
+  // They reflect the quality of the implementation.
+  //
+  // 3.0 and higher only.
+  //
+  // TODO(ghartman): Implement this URGENTLY.
+  //
+  // int GetPresentationPosition(uint64_t *frames, struct timespec *timestamp);
+
+ private:
+  // If key is present in query, add key=value; to reply.
+  // query should be pointer to const, but the str_parms functions aren't
+  // const-correct, so neither is this.
+  static void AddIntIfKeyPresent(
+      /*const*/ str_parms* query, str_parms* reply, const char* key, int value);
+
+
+  explicit GceAudioOutputStream(cvd::GceAudio*);
+
+  static const size_t kOutBufferSize = 3840;
+  static const size_t kOutLatency = 2;
+
+  gce_audio_message message_header_;
+  std::unique_ptr<SimulatedOutputBuffer> buffer_;
+  cvd::GceAudio *dev_;
+  audio_devices_t device_;
+  size_t frame_size_;
+  size_t frame_count_;
+  float left_volume_;
+  float right_volume_;
+};
+
+}
diff --git a/guest/hals/gralloc/Android.mk b/guest/hals/gralloc/Android.mk
new file mode 100644
index 0000000..68ffffa
--- /dev/null
+++ b/guest/hals/gralloc/Android.mk
@@ -0,0 +1,63 @@
+# Copyright (C) 2017 The Android Open Source Project
+#
+# 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.
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := gralloc.cutf_ivsh-future
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := \
+    gralloc.cpp \
+    mapper.cpp
+
+LOCAL_C_INCLUDES += \
+    device/google/cuttlefish_common \
+    device/google/cuttlefish_kernel \
+    hardware/libhardware/include \
+    system/core/base/include
+
+LOCAL_CFLAGS := \
+    -DLOG_TAG=\"gralloc_vsoc\" \
+    -Wno-missing-field-initializers \
+    -Wall -Werror \
+    $(VSOC_VERSION_CFLAGS)
+
+LOCAL_SHARED_LIBRARIES := \
+    libbase \
+    libcutils \
+    cuttlefish_auto_resources \
+    libcuttlefish_fs \
+    liblog \
+    vsoc_lib
+
+LOCAL_HEADER_LIBRARIES := \
+    libhardware_headers
+
+ifeq (0, $(shell test $(PLATFORM_SDK_VERSION) -ge 21; echo $$?))
+LOCAL_MODULE_RELATIVE_PATH := hw
+else
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
+endif
+
+LOCAL_VENDOR_MODULE := true
+
+# See b/67109557
+ifeq (true, $(TARGET_TRANSLATE_2ND_ARCH))
+LOCAL_MULTILIB := first
+endif
+include $(BUILD_SHARED_LIBRARY)
+
+include $(call first-makefiles-under,$(LOCAL_PATH))
diff --git a/guest/hals/gralloc/gralloc.cpp b/guest/hals/gralloc/gralloc.cpp
new file mode 100644
index 0000000..d21d918
--- /dev/null
+++ b/guest/hals/gralloc/gralloc.cpp
@@ -0,0 +1,320 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <hardware/gralloc.h>
+#include <hardware/hardware.h>
+#include <log/log.h>
+#include <stdlib.h>
+
+#include "guest/hals/gralloc/gralloc_vsoc_priv.h"
+#include "guest/vsoc/lib/gralloc_region_view.h"
+
+using vsoc::gralloc::GrallocRegionView;
+
+namespace {
+
+static const int kSwiftShaderPadding = 4;
+
+inline void formatToYcbcr(
+    int format, int width, int height, void* base_v, android_ycbcr* ycbcr) {
+  uintptr_t it = reinterpret_cast<uintptr_t>(base_v);
+  // Clear reserved fields;
+  memset(ycbcr, 0, sizeof(*ycbcr));
+  switch (format) {
+    case HAL_PIXEL_FORMAT_YV12:
+    case HAL_PIXEL_FORMAT_YCbCr_420_888:
+      ycbcr->ystride = align(width, 16);
+      ycbcr->cstride = align(ycbcr->ystride / 2, 16);
+      ycbcr->chroma_step = 1;
+      ycbcr->y = reinterpret_cast<void*>(it);
+      it += ycbcr->ystride * height;
+      ycbcr->cr = reinterpret_cast<void*>(it);
+      it += ycbcr->cstride * height / 2;
+      ycbcr->cb = reinterpret_cast<void*>(it);
+      break;
+    default:
+      ALOGE("%s: can't deal with format=0x%x", __FUNCTION__, format);
+  }
+}
+
+inline int formatToBytesPerPixel(int format) {
+  switch (format) {
+    case HAL_PIXEL_FORMAT_RGBA_FP16:
+      return 8;
+    case HAL_PIXEL_FORMAT_RGBA_8888:
+    case HAL_PIXEL_FORMAT_RGBX_8888:
+    case HAL_PIXEL_FORMAT_BGRA_8888:
+    // The camera 3.0 implementation assumes that IMPLEMENTATION_DEFINED
+    // means HAL_PIXEL_FORMAT_RGBA_8888
+    case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
+      return 4;
+    case HAL_PIXEL_FORMAT_RGB_888:
+      return 3;
+    case HAL_PIXEL_FORMAT_RGB_565:
+    case HAL_PIXEL_FORMAT_YV12:
+    case HAL_PIXEL_FORMAT_YCbCr_420_888:
+      return 2;
+    case HAL_PIXEL_FORMAT_BLOB:
+      return 1;
+    default:
+      ALOGE("%s: unknown format=%d", __FUNCTION__, format);
+      return 8;
+  }
+}
+
+inline int formatToBytesPerFrame(int format, int w, int h) {
+  int bytes_per_pixel = formatToBytesPerPixel(format);
+  int w16, h16;
+  int y_size, c_size;
+
+  switch (format) {
+    // BLOB is used to allocate buffers for JPEG formatted data. Bytes per pixel
+    // is 1, the desired buffer size is in w, and h should be 1. We refrain from
+    // adding additional padding, although the caller is likely to round
+    // up to a page size.
+    case HAL_PIXEL_FORMAT_BLOB:
+      return bytes_per_pixel * w * h;
+    case HAL_PIXEL_FORMAT_YV12:
+    case HAL_PIXEL_FORMAT_YCbCr_420_888:
+      android_ycbcr strides;
+      formatToYcbcr(format, w, h, NULL, &strides);
+      y_size = strides.ystride * h;
+      c_size = strides.cstride * h / 2;
+      return (y_size + 2 * c_size + kSwiftShaderPadding);
+    /*case HAL_PIXEL_FORMAT_RGBA_8888:
+    case HAL_PIXEL_FORMAT_RGBX_8888:
+    case HAL_PIXEL_FORMAT_BGRA_8888:
+    case HAL_PIXEL_FORMAT_RGB_888:
+    case HAL_PIXEL_FORMAT_RGB_565:*/
+    default:
+      w16 = align(w, 16);
+      h16 = align(h, 16);
+      return bytes_per_pixel * w16 * h16 + kSwiftShaderPadding;
+  }
+}
+
+}
+
+/******************************************************************************/
+
+void dump(struct alloc_device_t */*dev*/, char */*buff*/, int /*buff_len*/) {}
+
+/******************************************************************************/
+
+int lock(struct gralloc_module_t const* /*module*/,
+         buffer_handle_t handle,
+         int /*usage*/,
+         int /*l*/,
+         int /*t*/,
+         int /*w*/,
+         int /*h*/,
+         void** vaddr) {
+  if (!vaddr || vsoc_buffer_handle_t::validate(handle)) {
+    return -EINVAL;
+  }
+  // TODO(jemoreira): Check allocation usage flags against requested usage.
+  const vsoc_buffer_handle_t* hnd =
+      reinterpret_cast<const vsoc_buffer_handle_t*>(handle);
+  void* mapped = reference_buffer(hnd);
+  if (mapped == NULL) {
+    ALOGE("Unable to reference buffer, %s", __FUNCTION__);
+    return -1;
+  }
+  *vaddr = mapped;
+  return 0;
+}
+
+int unlock(struct gralloc_module_t const* /*module*/, buffer_handle_t handle) {
+  if (vsoc_buffer_handle_t::validate(handle)) {
+    return -EINVAL;
+  }
+  return unreference_buffer(
+      reinterpret_cast<const vsoc_buffer_handle_t*>(handle));
+}
+
+int lock_ycbcr(struct gralloc_module_t const* module,
+               buffer_handle_t handle,
+               int usage,
+               int l,
+               int t,
+               int w,
+               int h,
+               struct android_ycbcr* ycbcr) {
+  void* mapped;
+  int retval = lock(module, handle, usage, l, t, w, h, &mapped);
+  if (retval) {
+    return retval;
+  }
+  const vsoc_buffer_handle_t* hnd =
+      reinterpret_cast<const vsoc_buffer_handle_t*>(handle);
+  formatToYcbcr(hnd->format, w, h, mapped, ycbcr);
+  return 0;
+}
+
+/******************************************************************************/
+
+static int gralloc_alloc(alloc_device_t* /*dev*/,
+                         int w,
+                         int h,
+                         int format,
+                         int /*usage*/,
+                         buffer_handle_t* pHandle,
+                         int* pStrideInPixels) {
+  int fd = -1;
+
+  int bytes_per_pixel = formatToBytesPerPixel(format);
+  int bytes_per_line;
+  int stride_in_pixels;
+  int size = 0;
+  uint32_t offset = 0;
+  // SwiftShader can't handle RGB_888, so fail fast and hard if we try to create
+  // a gralloc buffer in this format.
+  ALOG_ASSERT(format != HAL_PIXEL_FORMAT_RGB_888);
+  if (format == HAL_PIXEL_FORMAT_YV12) {
+    bytes_per_line = align(bytes_per_pixel * w, 16);
+  } else {
+    bytes_per_line = align(bytes_per_pixel * w, 8);
+  }
+  size = align(size + formatToBytesPerFrame(format, w, h), PAGE_SIZE);
+  size += PAGE_SIZE;
+  fd = GrallocRegionView::GetInstance()->AllocateBuffer(size, &offset);
+  if (fd < 0) {
+    ALOGE("Unable to allocate buffer (%s)", strerror(-fd));
+    return fd;
+  }
+
+  stride_in_pixels = bytes_per_line / bytes_per_pixel;
+  vsoc_buffer_handle_t* hnd = new vsoc_buffer_handle_t(fd,
+                                                       offset,
+                                                       size,
+                                                       format,
+                                                       w, h,
+                                                       stride_in_pixels);
+  void* addr =
+      reference_buffer(reinterpret_cast<const vsoc_buffer_handle_t*>(hnd));
+  if (!addr) {
+    ALOGE("Unable to reference buffer, %s", __FUNCTION__);
+    return -EIO;
+  }
+
+  *pHandle = hnd;
+  *pStrideInPixels = stride_in_pixels;
+
+  return 0;
+}
+
+static int gralloc_free(alloc_device_t* /*dev*/, buffer_handle_t handle) {
+  // No need to do anything else, the buffer will be atomatically deallocated
+  // when the handle is closed.
+  return unreference_buffer(
+      reinterpret_cast<const vsoc_buffer_handle_t*>(handle));
+}
+
+static int register_buffer(struct gralloc_module_t const* /*module*/,
+                          buffer_handle_t handle) {
+  if (vsoc_buffer_handle_t::validate(handle)) {
+    return -EINVAL;
+  }
+  void* addr =
+      reference_buffer(reinterpret_cast<const vsoc_buffer_handle_t*>(handle));
+  if (!addr) {
+    ALOGE("Unable to reference buffer, %s", __FUNCTION__);
+    return -EIO;
+  }
+  return 0;
+}
+
+int unregister_buffer(struct gralloc_module_t const* /*module*/,
+                     buffer_handle_t handle) {
+  if (vsoc_buffer_handle_t::validate(handle)) {
+    return -EINVAL;
+  }
+  return unreference_buffer(
+      reinterpret_cast<const vsoc_buffer_handle_t*>(handle));
+}
+
+/******************************************************************************/
+
+static int gralloc_device_close(struct hw_device_t *dev) {
+  vsoc_alloc_device_t* pdev = reinterpret_cast<vsoc_alloc_device_t*>(dev);
+  if (pdev) {
+    free(pdev);
+  }
+  return 0;
+}
+
+static int gralloc_device_open(
+    const hw_module_t* module, const char* name, hw_device_t** device) {
+    int status = -EINVAL;
+  if (!strcmp(name, GRALLOC_HARDWARE_GPU0)) {
+    vsoc_alloc_device_t *dev;
+    dev = (vsoc_alloc_device_t*) malloc(sizeof(*dev));
+    LOG_FATAL_IF(!dev, "%s: malloc returned NULL.", __FUNCTION__);
+
+    /* initialize our state here */
+    memset(dev, 0, sizeof(*dev));
+
+    /* initialize the procs */
+    dev->device.common.tag = HARDWARE_DEVICE_TAG;
+    dev->device.common.version = 0; // TODO(jemoreira): Bump to 0_2 when stable
+    dev->device.common.module = const_cast<hw_module_t*>(module);
+    dev->device.common.close = gralloc_device_close;
+
+    dev->device.alloc   = gralloc_alloc;
+    dev->device.free    = gralloc_free;
+
+    if (!GrallocRegionView::GetInstance()) {
+      LOG_FATAL("Unable to instantiate the gralloc region");
+      free(dev);
+      return -EIO;
+    }
+
+    *device = &dev->device.common;
+    status = 0;
+  }
+  // TODO(jemoreira): Consider opening other type of devices (framebuffer)
+  return status;
+}
+
+/******************************************************************************/
+
+static struct hw_module_methods_t gralloc_module_methods = {
+  .open = gralloc_device_open
+};
+
+struct vsoc_gralloc_module_t HAL_MODULE_INFO_SYM = {
+  .base = {
+    .common = {
+      .tag = HARDWARE_MODULE_TAG,
+      .version_major = GRALLOC_MODULE_API_VERSION_0_2,
+      .version_minor = 0,
+      .id = GRALLOC_HARDWARE_MODULE_ID,
+      .name = "VSoC X86 Graphics Memory Allocator Module",
+      .author = "The Android Open Source Project",
+      .methods = &gralloc_module_methods,
+      .dso = NULL,
+      .reserved = {0},
+    },
+    .registerBuffer = register_buffer,
+    .unregisterBuffer = unregister_buffer,
+    .lock = lock,
+    .unlock = unlock,
+    .perform = NULL,
+    .lock_ycbcr = lock_ycbcr,
+    .getTransportSize = NULL,
+    .validateBufferSize = NULL,
+  },
+};
diff --git a/guest/hals/gralloc/gralloc_vsoc_priv.h b/guest/hals/gralloc/gralloc_vsoc_priv.h
new file mode 100644
index 0000000..1ec5659
--- /dev/null
+++ b/guest/hals/gralloc/gralloc_vsoc_priv.h
@@ -0,0 +1,100 @@
+#pragma once
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <errno.h>
+#include <cutils/native_handle.h>
+#include <hardware/gralloc.h>
+#include <log/log.h>
+
+struct vsoc_alloc_device_t {
+  alloc_device_t device;
+};
+
+struct vsoc_gralloc_module_t {
+  gralloc_module_t base;
+};
+
+static_assert(sizeof(int) >= 4, "At least 4 bytes are needed for offsets");
+
+struct vsoc_buffer_handle_t : public native_handle {
+  // File descriptors
+  int fd;
+  // ints
+  int magic;
+  int format;
+  int x_res;
+  int y_res;
+  int stride_in_pixels;
+  int size;
+  // buffer offset in bytes divided by PAGE_SIZE
+  int offset;
+
+  static inline int sNumInts() {
+    return ((sizeof(vsoc_buffer_handle_t) - sizeof(native_handle_t)) /
+                sizeof(int) -
+            sNumFds);
+  }
+  static const int sNumFds = 1;
+  static const int sMagic = 0xc63752f4;
+
+  vsoc_buffer_handle_t(int fd,
+                       int offset,
+                       int size,
+                       int format,
+                       int x_res,
+                       int y_res,
+                       int stride_in_pixels)
+      : fd(fd),
+        magic(sMagic),
+        format(format),
+        x_res(x_res),
+        y_res(y_res),
+        stride_in_pixels(stride_in_pixels),
+        size(size),
+        offset(offset) {
+    version = sizeof(native_handle);
+    numInts = sNumInts();
+    numFds = sNumFds;
+  }
+
+  ~vsoc_buffer_handle_t() {
+    magic = 0;
+  }
+
+  static int validate(const native_handle* handle) {
+    const vsoc_buffer_handle_t* hnd =
+        reinterpret_cast<const vsoc_buffer_handle_t*>(handle);
+    if (!hnd || hnd->version != sizeof(native_handle) ||
+        hnd->numInts != sNumInts() || hnd->numFds != sNumFds ||
+        hnd->magic != sMagic) {
+      ALOGE("Invalid gralloc handle (at %p)", handle);
+      return -EINVAL;
+    }
+    return 0;
+  }
+};
+
+// These functions are to be used to map/unmap gralloc buffers. They are thread
+// safe and ensure that the same buffer never gets mapped twice.
+void* reference_buffer(const vsoc_buffer_handle_t* hnd);
+int unreference_buffer(const vsoc_buffer_handle_t* hnd);
+
+// TODO(jemoreira): Move this to a place where it can be used by the gralloc
+// region as well.
+inline int align(int input, int alignment) {
+  return (input + alignment - 1) & -alignment;
+}
diff --git a/guest/hals/gralloc/legacy/Android.mk b/guest/hals/gralloc/legacy/Android.mk
index ac789fb..4bbc9c0 100644
--- a/guest/hals/gralloc/legacy/Android.mk
+++ b/guest/hals/gralloc/legacy/Android.mk
@@ -18,6 +18,7 @@
 
 VSOC_GRALLOC_COMMON_SRC_FILES := \
     gralloc.cpp \
+    framebuffer.cpp \
     mapper.cpp \
     region_registry.cpp
 
@@ -46,7 +47,8 @@
     libbase \
     liblog \
     libutils \
-    libcutils
+    libcutils \
+    vsoc_lib
 
 LOCAL_VENDOR_MODULE := true
 
diff --git a/guest/hals/gralloc/legacy/framebuffer.cpp b/guest/hals/gralloc/legacy/framebuffer.cpp
new file mode 100644
index 0000000..5a2b7f0
--- /dev/null
+++ b/guest/hals/gralloc/legacy/framebuffer.cpp
@@ -0,0 +1,155 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+#include <sys/mman.h>
+
+#include <dlfcn.h>
+
+#include <cutils/ashmem.h>
+#include <log/log.h>
+#include <cutils/properties.h>
+
+#include <sys/system_properties.h>
+
+#include <hardware/hardware.h>
+#include <hardware/gralloc.h>
+
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <cutils/atomic.h>
+
+#if defined(__ANDROID__)
+#include <linux/fb.h>
+#endif
+
+#include "gralloc_vsoc_priv.h"
+#include "region_registry.h"
+
+#include "common/libs/auto_resources/auto_resources.h"
+#include "common/libs/threads/cuttlefish_thread.h"
+#include "common/vsoc/lib/screen_region_view.h"
+
+using vsoc::screen::ScreenRegionView;
+
+/*****************************************************************************/
+
+struct fb_context_t {
+  framebuffer_device_t  device;
+};
+
+/*****************************************************************************/
+
+static int fb_setSwapInterval(struct framebuffer_device_t* dev, int interval) {
+  if (interval < dev->minSwapInterval || interval > dev->maxSwapInterval) {
+    return -EINVAL;
+  }
+  // FIXME: implement fb_setSwapInterval
+  return 0;
+}
+
+/*
+ * These functions (and probably the entire framebuffer device) are most likely
+ * not used when the hardware composer device is present, however is hard to be
+ * 100% sure.
+ */
+static int fb_setUpdateRect(
+    struct framebuffer_device_t* dev __unused, int l, int t, int w, int h) {
+  if (((w|h) <= 0) || ((l|t)<0)) {
+    return -EINVAL;
+  }
+  // TODO(jemoreira): Find a way to broadcast this with the framebuffer control.
+  return 0;
+}
+
+static int fb_post(struct framebuffer_device_t* dev __unused,
+                   buffer_handle_t buffer_handle) {
+  static int frame_buffer_idx = 0;
+
+  auto screen_view = ScreenRegionView::GetInstance();
+
+  void* frame_buffer = screen_view->GetBuffer(frame_buffer_idx);
+  const private_handle_t* p_handle =
+      reinterpret_cast<const private_handle_t*>(buffer_handle);
+  void* buffer;
+  int retval =
+      reinterpret_cast<gralloc_module_t*>(dev->common.module)
+          ->lock(reinterpret_cast<const gralloc_module_t*>(dev->common.module),
+                 buffer_handle, GRALLOC_USAGE_SW_READ_OFTEN, 0, 0,
+                 p_handle->x_res, p_handle->y_res, &buffer);
+  if (retval != 0) {
+    ALOGE("Got error code %d from lock function", retval);
+    return -1;
+  }
+  memcpy(frame_buffer, buffer, screen_view->buffer_size());
+  screen_view->BroadcastNewFrame(frame_buffer_idx);
+
+  frame_buffer_idx = (frame_buffer_idx + 1) % screen_view->number_of_buffers();
+
+  return 0;
+}
+
+/*****************************************************************************/
+
+static int fb_close(struct hw_device_t *dev) {
+  fb_context_t* ctx = (fb_context_t*)dev;
+  if (ctx) {
+    free(ctx);
+  }
+  return 0;
+}
+
+int fb_device_open(
+    hw_module_t const* module, const char* name, hw_device_t** device) {
+  if (strcmp(name, GRALLOC_HARDWARE_FB0) != 0) {
+    return -EINVAL;
+  }
+  /* initialize our state here */
+  fb_context_t* dev = (fb_context_t*) malloc(sizeof(*dev));
+  LOG_FATAL_IF(!dev, "%s: malloc returned NULL.", __FUNCTION__);
+  memset(dev, 0, sizeof(*dev));
+
+  /* initialize the procs */
+  dev->device.common.tag = HARDWARE_DEVICE_TAG;
+  dev->device.common.version = 0;
+  dev->device.common.module = const_cast<hw_module_t*>(module);
+  dev->device.common.close = fb_close;
+  dev->device.setSwapInterval = fb_setSwapInterval;
+  dev->device.post            = fb_post;
+  dev->device.setUpdateRect   = fb_setUpdateRect;
+
+  auto screen_view = ScreenRegionView::GetInstance();
+
+  int stride =
+    screen_view->line_length() / screen_view->bytes_per_pixel();
+  int format = HAL_PIXEL_FORMAT_RGBX_8888;
+  const_cast<uint32_t&>(dev->device.flags) = 0;
+  const_cast<uint32_t&>(dev->device.width) = screen_view->x_res();
+  const_cast<uint32_t&>(dev->device.height) = screen_view->y_res();
+  const_cast<int&>(dev->device.stride) = stride;
+  const_cast<int&>(dev->device.format) = format;
+  const_cast<float&>(dev->device.xdpi) = screen_view->dpi();
+  const_cast<float&>(dev->device.ydpi) = screen_view->dpi();
+  const_cast<float&>(dev->device.fps) =
+    (screen_view->refresh_rate_hz() * 1000) / 1000.0f;
+  const_cast<int&>(dev->device.minSwapInterval) = 1;
+  const_cast<int&>(dev->device.maxSwapInterval) = 1;
+  *device = &dev->device.common;
+
+  return 0;
+}
diff --git a/guest/hals/gralloc/legacy/gralloc.cpp b/guest/hals/gralloc/legacy/gralloc.cpp
index dbe2838..8a0cbd2 100644
--- a/guest/hals/gralloc/legacy/gralloc.cpp
+++ b/guest/hals/gralloc/legacy/gralloc.cpp
@@ -36,6 +36,7 @@
 #include <hardware/gralloc.h>
 
 #include "common/libs/auto_resources/auto_resources.h"
+#include "common/vsoc/lib/screen_region_view.h"
 #include "gralloc_vsoc_priv.h"
 #include "region_registry.h"
 
@@ -161,7 +162,7 @@
     *device = &dev->device.common;
     status = 0;
   } else {
-    ALOGE("Need to create framebuffer, but it is unsupported");
+    status = fb_device_open(module, name, device);
   }
   return status;
 }
diff --git a/guest/hals/gralloc/legacy/gralloc_vsoc_priv.h b/guest/hals/gralloc/legacy/gralloc_vsoc_priv.h
index 390c654..2544b5a 100644
--- a/guest/hals/gralloc/legacy/gralloc_vsoc_priv.h
+++ b/guest/hals/gralloc/legacy/gralloc_vsoc_priv.h
@@ -29,6 +29,8 @@
 
 #include <linux/fb.h>
 
+#include "common/vsoc/lib/screen_region_view.h"
+
 #ifndef GRALLOC_MODULE_API_VERSION_0_2
 // This structure will be defined in later releases of Android. Declare it
 // here to allow us to structure the code well.
@@ -43,20 +45,6 @@
 };
 #endif
 
-namespace vsoc {
-namespace screen {
-
-struct ScreenRegionView {
-  static int align(int input) {
-    auto constexpr alignment = 16;
-    return (input + alignment - 1) & -alignment;
-  }
-  static constexpr int kSwiftShaderPadding = 4;
-};
-
-}
-}
-
 /*****************************************************************************/
 
 struct private_handle_t;
@@ -309,6 +297,9 @@
   }
 }
 
+int fb_device_open(
+    const hw_module_t* module, const char* name, hw_device_t** device);
+
 int gralloc_lock(
     gralloc_module_t const* module,
     buffer_handle_t handle, int usage,
diff --git a/guest/hals/gralloc/mapper.cpp b/guest/hals/gralloc/mapper.cpp
new file mode 100644
index 0000000..e9ba2eb
--- /dev/null
+++ b/guest/hals/gralloc/mapper.cpp
@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include "gralloc_vsoc_priv.h"
+
+#include <unistd.h>
+#include <string.h>
+#include <sys/mman.h>
+
+#include <cutils/hashmap.h>
+#include <hardware/gralloc.h>
+#include <hardware/hardware.h>
+#include <log/log.h>
+
+namespace {
+
+const size_t g_page_size = sysconf(_SC_PAGESIZE);
+
+struct HmLockGuard {
+  HmLockGuard(Hashmap* map) : map_(map) {
+    hashmapLock(map_);
+  }
+  ~HmLockGuard() {
+    hashmapUnlock(map_);
+  }
+ private:
+  Hashmap* map_;
+};
+
+int offset_hash(void* key) {
+  return *reinterpret_cast<int*>(key);
+}
+
+bool offset_equals(void* key1, void* key2) {
+  return *reinterpret_cast<int*>(key1) ==
+         *reinterpret_cast<int*>(key2);
+}
+
+// Keeps track of how many times a buffer is locked in the current process.
+struct GrallocBuffer {
+  void* vaddr;
+  int ref_count;
+  GrallocBuffer() : vaddr(NULL), ref_count(0) {}
+
+  static Hashmap* mapped_buffers() {
+    static Hashmap* mapped_buffers =
+        hashmapCreate(19, offset_hash, offset_equals);
+    return mapped_buffers;
+  }
+};
+
+}
+
+void* reference_buffer(const vsoc_buffer_handle_t* hnd) {
+  Hashmap* map = GrallocBuffer::mapped_buffers();
+  HmLockGuard lock_guard(map);
+  GrallocBuffer* buffer = reinterpret_cast<GrallocBuffer*>(
+      hashmapGet(map, const_cast<int*>(&hnd->offset)));
+  if (!buffer) {
+    buffer = new GrallocBuffer();
+    hashmapPut(map, const_cast<int*>(&hnd->offset), buffer);
+  }
+
+  if (!buffer->vaddr) {
+    void* mapped =
+      mmap(NULL, hnd->size, PROT_READ | PROT_WRITE, MAP_SHARED, hnd->fd, 0);
+    if (mapped == MAP_FAILED) {
+      ALOGE("Unable to map buffer (offset: %d, size: %d): %s",
+            hnd->offset,
+            hnd->size,
+            strerror(errno));
+      return NULL;
+    }
+    // Set up the guard pages. The last page is always a guard
+    uintptr_t base = uintptr_t(mapped);
+    uintptr_t addr = base + hnd->size - g_page_size;
+    if (mprotect((void*)addr, g_page_size, PROT_NONE) == -1) {
+      ALOGW("Unable to protect last page of buffer (offset: %d, size: %d): %s",
+            hnd->offset,
+            hnd->size,
+            strerror(errno));
+    }
+    buffer->vaddr = mapped;
+  }
+  buffer->ref_count++;
+  return buffer->vaddr;
+}
+
+int unreference_buffer(const vsoc_buffer_handle_t* hnd) {
+  int result = 0;
+  Hashmap* map = GrallocBuffer::mapped_buffers();
+  HmLockGuard lock_guard(map);
+  GrallocBuffer* buffer = reinterpret_cast<GrallocBuffer*>(
+      hashmapGet(map, const_cast<int*>(&hnd->offset)));
+  if (!buffer) {
+    ALOGE("Unreferencing an unknown buffer (offset: %d, size: %d)",
+          hnd->offset,
+          hnd->size);
+    return -EINVAL;
+  }
+  if (buffer->ref_count == 0) {
+    ALOGE("Unbalanced reference/unreference on buffer (offset: %d, size: %d)",
+          hnd->offset,
+          hnd->size);
+    return -EINVAL;
+  }
+  buffer->ref_count--;
+  if (buffer->ref_count == 0) {
+    result = munmap(buffer->vaddr, hnd->size);
+    if (result) {
+      ALOGE("Unable to unmap buffer (offset: %d, size: %d): %s",
+            hnd->offset,
+            hnd->size,
+            strerror(errno));
+    }
+    buffer->vaddr = NULL;
+  }
+  return result;
+}
diff --git a/guest/hals/hwcomposer/vsoc-future/Android.mk b/guest/hals/hwcomposer/vsoc-future/Android.mk
new file mode 100644
index 0000000..bcc104e
--- /dev/null
+++ b/guest/hals/hwcomposer/vsoc-future/Android.mk
@@ -0,0 +1,58 @@
+# Copyright (C) 2017 The Android Open Source Project
+#
+# 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.
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := hwcomposer.cutf_ivsh-future
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := \
+    hwcomposer.cpp
+
+LOCAL_C_INCLUDES += \
+    device/google/cuttlefish_kernel \
+    device/google/cuttlefish_common \
+    device/google/cuttlefish_common/guest/hals/hwcomposer \
+    hardware/libhardware/include \
+    system/core/base/include
+
+LOCAL_CFLAGS := \
+    -DLOG_TAG=\"hwcomposer_vsoc\" \
+    -Wall -Werror
+
+LOCAL_SHARED_LIBRARIES := \
+    libbase \
+    liblog \
+    vsoc_lib
+
+ifeq (0, $(shell test $(PLATFORM_SDK_VERSION) -ge 21; echo $$?))
+LOCAL_MODULE_RELATIVE_PATH := hw
+else
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
+endif
+
+LOCAL_VENDOR_MODULE := true
+# See b/67109557
+ifeq (true, $(TARGET_TRANSLATE_2ND_ARCH))
+LOCAL_MULTILIB := first
+endif
+
+LOCAL_HEADER_LIBRARIES := \
+    libhardware_headers
+
+include $(BUILD_SHARED_LIBRARY)
+
+include $(call first-makefiles-under,$(LOCAL_PATH))
diff --git a/guest/hals/hwcomposer/vsoc-future/hwcomposer.cpp b/guest/hals/hwcomposer/vsoc-future/hwcomposer.cpp
new file mode 100644
index 0000000..f18712c
--- /dev/null
+++ b/guest/hals/hwcomposer/vsoc-future/hwcomposer.cpp
@@ -0,0 +1,363 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <pthread.h>
+#include <sys/resource.h>
+#include <sys/time.h>
+
+#include <hardware/hwcomposer.h>
+#include <hardware/hwcomposer_defs.h>
+#include <log/log.h>
+
+#include "common/vsoc/lib/screen_region_view.h"
+#include "guest/hals/gralloc/gralloc_vsoc_priv.h"
+
+// This file contains just a skeleton hwcomposer, the first step in the
+// multisided vsoc hwcomposer for cuttlefish.
+
+using vsoc::screen::ScreenRegionView;
+
+// TODO(jemoreira): ScreenRegionView may become the HWC region
+namespace {
+
+// Ensures that the layer does not include any inconsistencies
+int SanityCheckLayer(const hwc_layer_1& layer) {
+  // Check displayFrame
+  if (layer.displayFrame.left > layer.displayFrame.right ||
+      layer.displayFrame.top > layer.displayFrame.bottom) {
+    ALOGE(
+        "%s: Malformed rectangle (displayFrame): [left = %d, right = %d, top = "
+        "%d, bottom = %d]",
+        __FUNCTION__, layer.displayFrame.left, layer.displayFrame.right,
+        layer.displayFrame.top, layer.displayFrame.bottom);
+    return -EINVAL;
+  }
+  // Check sourceCrop
+  if (layer.sourceCrop.left > layer.sourceCrop.right ||
+      layer.sourceCrop.top > layer.sourceCrop.bottom) {
+    ALOGE(
+        "%s: Malformed rectangle (sourceCrop): [left = %d, right = %d, top = "
+        "%d, bottom = %d]",
+        __FUNCTION__, layer.sourceCrop.left, layer.sourceCrop.right,
+        layer.sourceCrop.top, layer.sourceCrop.bottom);
+    return -EINVAL;
+  }
+  const vsoc_buffer_handle_t* p_handle =
+      reinterpret_cast<const vsoc_buffer_handle_t*>(layer.handle);
+  if (!p_handle) {
+    ALOGE("Layer has a NULL buffer handle");
+    return -EINVAL;
+  }
+  if (layer.sourceCrop.left < 0 || layer.sourceCrop.top < 0 ||
+      layer.sourceCrop.right > p_handle->x_res ||
+      layer.sourceCrop.bottom > p_handle->y_res) {
+    ALOGE(
+        "%s: Invalid sourceCrop for buffer handle: sourceCrop = [left = %d, "
+        "right = %d, top = %d, bottom = %d], handle = [width = %d, height = "
+        "%d]",
+        __FUNCTION__, layer.sourceCrop.left, layer.sourceCrop.right,
+        layer.sourceCrop.top, layer.sourceCrop.bottom, p_handle->x_res,
+        p_handle->y_res);
+    return -EINVAL;
+  }
+  return 0;
+}
+
+struct vsoc_hwc_device {
+  hwc_composer_device_1_t base;
+  const hwc_procs_t* procs;
+  pthread_t vsync_thread;
+  int64_t vsync_base_timestamp;
+  int32_t vsync_period_ns;
+  uint32_t frame_num;
+};
+
+void* vsync_thread(void* arg) {
+  vsoc_hwc_device* pdev = reinterpret_cast<vsoc_hwc_device*>(arg);
+  setpriority(PRIO_PROCESS, 0, HAL_PRIORITY_URGENT_DISPLAY);
+
+  int64_t base_timestamp = pdev->vsync_base_timestamp;
+  int64_t last_logged = base_timestamp / 1e9;
+  int sent = 0;
+  int last_sent = 0;
+  static const int log_interval = 60;
+  void (*vsync_proc)(const struct hwc_procs*, int, int64_t) = nullptr;
+  bool log_no_procs = true, log_no_vsync = true;
+  while (true) {
+    struct timespec rt;
+    if (clock_gettime(CLOCK_MONOTONIC, &rt) == -1) {
+      ALOGE("%s:%d error in vsync thread clock_gettime: %s", __FILE__, __LINE__,
+            strerror(errno));
+    }
+    int64_t timestamp = int64_t(rt.tv_sec) * 1e9 + rt.tv_nsec;
+    // Given now's timestamp calculate the time of the next vsync.
+    timestamp += pdev->vsync_period_ns -
+                 (timestamp - base_timestamp) % pdev->vsync_period_ns;
+
+    rt.tv_sec = timestamp / 1e9;
+    rt.tv_nsec = timestamp % static_cast<int32_t>(1e9);
+    int err = clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &rt, NULL);
+    if (err == -1) {
+      ALOGE("error in vsync thread: %s", strerror(errno));
+      if (errno == EINTR) {
+        continue;
+      }
+    }
+
+    // The vsync thread is started on device open, it may run before the
+    // registerProcs callback has a chance to be called, so we need to make sure
+    // procs is not NULL before dereferencing it.
+    if (pdev && pdev->procs) {
+      vsync_proc = pdev->procs->vsync;
+    } else if (log_no_procs) {
+      log_no_procs = false;
+      ALOGI("procs is not set yet, unable to deliver vsync event");
+    }
+    if (vsync_proc) {
+      vsync_proc(const_cast<hwc_procs_t*>(pdev->procs), 0, timestamp);
+      ++sent;
+    } else if (log_no_vsync) {
+      log_no_vsync = false;
+      ALOGE("vsync callback is null (but procs was already set)");
+    }
+    if (rt.tv_sec - last_logged > log_interval) {
+      ALOGI("Sent %d syncs in %ds", sent - last_sent, log_interval);
+      last_logged = rt.tv_sec;
+      last_sent = sent;
+    }
+  }
+
+  return NULL;
+}
+
+int hwc_prepare(struct hwc_composer_device_1* /*dev*/, size_t numDisplays,
+                hwc_display_contents_1_t** displays) {
+  if (!numDisplays || !displays) return 0;
+  hwc_display_contents_1_t* list = displays[HWC_DISPLAY_PRIMARY];
+  if (!list) return 0;
+
+  for (size_t i = 0; i < list->numHwLayers; i++) {
+    if (list->hwLayers[i].compositionType == HWC_FRAMEBUFFER_TARGET) {
+      continue;
+    }
+    list->hwLayers[i].compositionType = HWC_FRAMEBUFFER;
+  }
+
+  return 0;
+}
+
+int hwc_set(struct hwc_composer_device_1* dev, size_t numDisplays,
+            hwc_display_contents_1_t** displays) {
+  if (!numDisplays || !displays) return 0;
+  hwc_display_contents_1_t* list = displays[HWC_DISPLAY_PRIMARY];
+  if (!list) return 0;
+  if (!dev) {
+    ALOGE("%s: dev is NULL", __FUNCTION__);
+    return -EINVAL;
+  }
+
+  for (size_t i = 0; i < list->numHwLayers; i++) {
+    if (vsoc_buffer_handle_t::validate(list->hwLayers[i].handle)) {
+      return -EINVAL;
+    }
+    if (list->hwLayers[i].compositionType == HWC_FRAMEBUFFER_TARGET) {
+      if (SanityCheckLayer(list->hwLayers[i])) {
+        ALOGW("Skipping layer %zu due to failed sanity check", i);
+        continue;
+      }
+      const vsoc_buffer_handle_t* fb_handle =
+          reinterpret_cast<const vsoc_buffer_handle_t*>(
+              list->hwLayers[i].handle);
+      ScreenRegionView::GetInstance()->BroadcastNewFrame(fb_handle->offset);
+      break;
+    }
+  }
+
+  return 0;
+}
+
+int hwc_eventControl(struct hwc_composer_device_1* /*dev*/, int disp, int event,
+                     int /*enabled*/) {
+  if (event == HWC_EVENT_VSYNC || disp != HWC_DISPLAY_PRIMARY) {
+    return 0;
+  }
+  return -EINVAL;
+}
+
+int hwc_blank(struct hwc_composer_device_1* /*dev*/, int disp, int /*blank*/) {
+  if (disp != HWC_DISPLAY_PRIMARY) {
+    return -EINVAL;
+  }
+  return 0;
+}
+
+int hwc_query(struct hwc_composer_device_1* dev, int what, int* value) {
+  vsoc_hwc_device* pdev = reinterpret_cast<vsoc_hwc_device*>(dev);
+  switch (what) {
+    case HWC_BACKGROUND_LAYER_SUPPORTED:
+      // we don't support the background layer
+      *value = 0;
+      break;
+    case HWC_VSYNC_PERIOD:
+      *value = pdev->vsync_period_ns;
+      break;
+    case HWC_DISPLAY_TYPES_SUPPORTED:
+      // We only support the primary display
+      *value = HWC_DISPLAY_PRIMARY_BIT;
+      break;
+    default:
+      // unsupported query
+      ALOGE("%s badness unsupported query what=%d", __FUNCTION__, what);
+      return -EINVAL;
+  }
+  return 0;
+}
+
+void hwc_registerProcs(struct hwc_composer_device_1* dev,
+                       hwc_procs_t const* procs) {
+  reinterpret_cast<vsoc_hwc_device*>(dev)->procs = procs;
+}
+
+void hwc_dump(struct hwc_composer_device_1* /*dev*/, char* /*buff*/,
+              int /*buff_len*/) {}
+
+int hwc_getDisplayConfigs(struct hwc_composer_device_1* /*dev*/, int disp,
+                          uint32_t* configs, size_t* numConfigs) {
+  if (*numConfigs == 0) return 0;
+
+  if (disp == HWC_DISPLAY_PRIMARY) {
+    configs[0] = 0;
+    *numConfigs = 1;
+    return 0;
+  }
+
+  return -EINVAL;
+}
+
+int32_t vsoc_hwc_attribute(uint32_t attribute) {
+  auto screen_view = ScreenRegionView::GetInstance();
+  switch (attribute) {
+    case HWC_DISPLAY_VSYNC_PERIOD:
+      return 1000000000 / screen_view->refresh_rate_hz();
+    case HWC_DISPLAY_WIDTH:
+      return screen_view->x_res();
+    case HWC_DISPLAY_HEIGHT:
+      return screen_view->y_res();
+    case HWC_DISPLAY_DPI_X:
+    case HWC_DISPLAY_DPI_Y:
+      // The number of pixels per thousand inches
+      return screen_view->dpi() * 1000;
+    case HWC_DISPLAY_COLOR_TRANSFORM:
+      // TODO(jemoreira): Add the other color transformations
+      return HAL_COLOR_TRANSFORM_IDENTITY;
+    default:
+      ALOGE("unknown display attribute %u", attribute);
+      return -EINVAL;
+  }
+}
+
+int hwc_getDisplayAttributes(struct hwc_composer_device_1* /*dev*/, int disp,
+                             uint32_t /*config*/, const uint32_t* attributes,
+                             int32_t* values) {
+  if (disp != HWC_DISPLAY_PRIMARY) {
+    ALOGE("Unknown display type %u", disp);
+    return -EINVAL;
+  }
+
+  for (int i = 0; attributes[i] != HWC_DISPLAY_NO_ATTRIBUTE; i++) {
+    values[i] = vsoc_hwc_attribute(attributes[i]);
+  }
+
+  return 0;
+}
+
+int hwc_close(hw_device_t* device) {
+  vsoc_hwc_device* dev = reinterpret_cast<vsoc_hwc_device*>(device);
+  pthread_kill(dev->vsync_thread, SIGTERM);
+  pthread_join(dev->vsync_thread, NULL);
+  delete dev;
+  return 0;
+}
+
+int hwc_open(const struct hw_module_t* module, const char* name,
+             struct hw_device_t** device) {
+  ALOGI("Opening vsoc hwcomposer device: %s", __FUNCTION__);
+  if (strcmp(name, HWC_HARDWARE_COMPOSER)) {
+    ALOGE("%s called with bad name %s", __FUNCTION__, name);
+    return -EINVAL;
+  }
+
+  vsoc_hwc_device* dev = new vsoc_hwc_device();
+  if (!dev) {
+    ALOGE("%s failed to allocate dev", __FUNCTION__);
+    return -ENOMEM;
+  }
+  memset(dev, 0, sizeof(*dev));
+
+  int refreshRate = 60;
+  dev->vsync_period_ns = 1000000000 / refreshRate;
+  struct timespec rt;
+  if (clock_gettime(CLOCK_MONOTONIC, &rt) == -1) {
+    ALOGE("%s:%d error in clock_gettime: %s", __FILE__, __LINE__,
+          strerror(errno));
+  }
+  dev->vsync_base_timestamp = int64_t(rt.tv_sec) * 1e9 + rt.tv_nsec;
+
+  dev->base.common.tag = HARDWARE_DEVICE_TAG;
+  dev->base.common.version = HWC_DEVICE_API_VERSION_1_1;
+  dev->base.common.module = const_cast<hw_module_t*>(module);
+  dev->base.common.close = hwc_close;
+
+  dev->base.prepare = hwc_prepare;
+  dev->base.set = hwc_set;
+  dev->base.query = hwc_query;
+  dev->base.registerProcs = hwc_registerProcs;
+  dev->base.dump = hwc_dump;
+  dev->base.blank = hwc_blank;
+  dev->base.eventControl = hwc_eventControl;
+  dev->base.getDisplayConfigs = hwc_getDisplayConfigs;
+  dev->base.getDisplayAttributes = hwc_getDisplayAttributes;
+
+  if (!ScreenRegionView::GetInstance()) {
+    ALOGE("Unable to open screen region (%s)", __FUNCTION__);
+    delete dev;
+    return -1;
+  }
+
+  int ret = pthread_create(&dev->vsync_thread, NULL, vsync_thread, dev);
+  if (ret) {
+    ALOGE("failed to start vsync thread: %s", strerror(ret));
+    delete dev;
+  } else {
+    *device = &dev->base.common;
+  }
+
+  return -ret;
+}
+
+struct hw_module_methods_t hwc_module_methods = {hwc_open};
+
+}  // namespace
+
+hwc_module_t HAL_MODULE_INFO_SYM = {{HARDWARE_MODULE_TAG,
+                                     HWC_MODULE_API_VERSION_0_1,
+                                     HARDWARE_HAL_API_VERSION,
+                                     HWC_HARDWARE_MODULE_ID,
+                                     "Cuttlefish hwcomposer module",
+                                     "Google",
+                                     &hwc_module_methods,
+                                     NULL,
+                                     {0}}};
diff --git a/guest/hals/hwcomposer/vsoc/Android.bp b/guest/hals/hwcomposer/vsoc/Android.bp
new file mode 100644
index 0000000..559a1c1
--- /dev/null
+++ b/guest/hals/hwcomposer/vsoc/Android.bp
@@ -0,0 +1,47 @@
+// Copyright (C) 2019 The Android Open Source Project
+//
+// 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.
+
+
+cc_library_shared {
+    name: "hwcomposer.cutf_ivsh_ashmem",
+    relative_install_path: "hw",
+    defaults: ["cuttlefish_guest_only"],
+    cflags: [
+        "-DGATHER_STATS",
+        // Uncomment the following line to revert to GL compositions
+        // "-DUSE_OLD_HWCOMPOSER",
+    ],
+    srcs: [
+        "vsoc_screen_view.cpp",
+        "hwcomposer.cpp",
+    ],
+    export_include_dirs: ["."],
+    static_libs: [
+        "libyuv_static", 
+        "hwcomposer_common"
+    ],
+    shared_libs: [
+        "cuttlefish_auto_resources",
+        "liblog",
+        "libhardware",
+        "libbase",
+        "libcutils",
+        "libutils",
+        "libsync",
+        "libjpeg",
+        "libcuttlefish_utils",
+        "libcuttlefish_fs",
+        "vsoc_lib",
+    ],
+}
diff --git a/guest/hals/hwcomposer/vsoc/hwcomposer.cpp b/guest/hals/hwcomposer/vsoc/hwcomposer.cpp
new file mode 100644
index 0000000..67713f2
--- /dev/null
+++ b/guest/hals/hwcomposer/vsoc/hwcomposer.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#define LOG_TAG "hwc.cutf_cvm"
+
+#include <cutils/properties.h>
+#include <hardware/hardware.h>
+#include <hardware/hwcomposer.h>
+#include <hardware/hwcomposer_defs.h>
+#include <log/log.h>
+
+#include "guest/hals/hwcomposer/common/hwcomposer.h"
+
+#include "guest/hals/hwcomposer/vsoc/vsoc_screen_view.h"
+
+static int hwc_open(const struct hw_module_t* module, const char* name,
+                    struct hw_device_t** device) {
+  std::unique_ptr<cvd::ScreenView> screen_view(new cvd::VSoCScreenView());
+  if (!screen_view) {
+    ALOGE("Failed to instantiate screen view");
+    return -1;
+  }
+
+  return cvd::cvd_hwc_open(std::move(screen_view), module, name, device);
+}
+
+static struct hw_module_methods_t hwc_module_methods = {
+    hwc_open,
+};
+
+hwc_module_t HAL_MODULE_INFO_SYM = {{HARDWARE_MODULE_TAG,
+                                     HWC_MODULE_API_VERSION_0_1,
+                                     HARDWARE_HAL_API_VERSION,
+                                     HWC_HARDWARE_MODULE_ID,
+                                     "VSoC hwcomposer module",
+                                     "Google",
+                                     &hwc_module_methods,
+                                     NULL,
+                                     {0}}};
diff --git a/guest/hals/hwcomposer/vsoc/vsoc_screen_view.cpp b/guest/hals/hwcomposer/vsoc/vsoc_screen_view.cpp
new file mode 100644
index 0000000..6ca9ac2
--- /dev/null
+++ b/guest/hals/hwcomposer/vsoc/vsoc_screen_view.cpp
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include "guest/hals/hwcomposer/vsoc/vsoc_screen_view.h"
+
+#include <sys/time.h>
+
+#include "common/vsoc/lib/screen_region_view.h"
+
+using vsoc::layout::screen::TimeSpec;
+using vsoc::screen::ScreenRegionView;
+
+namespace cvd {
+namespace {
+
+TimeSpec TimeSpecFromSystemStruct(const timespec* spec) {
+  return {static_cast<uint32_t>(spec->tv_sec),
+          static_cast<uint32_t>(spec->tv_nsec), 0};
+}
+
+void VSoCStatsFromCvdStats(vsoc::layout::screen::CompositionStats* vsoc_stats,
+                           const cvd::CompositionStats* stats) {
+  vsoc_stats->num_prepare_calls = stats->num_prepare_calls;
+  vsoc_stats->num_layers = stats->num_layers;
+  vsoc_stats->num_hwcomposited_layers = stats->num_hwcomposited_layers;
+  vsoc_stats->last_vsync = TimeSpecFromSystemStruct(&stats->last_vsync);
+  vsoc_stats->prepare_start = TimeSpecFromSystemStruct(&stats->prepare_start);
+  vsoc_stats->prepare_end = TimeSpecFromSystemStruct(&stats->prepare_end);
+  vsoc_stats->set_start = TimeSpecFromSystemStruct(&stats->set_start);
+  vsoc_stats->set_end = TimeSpecFromSystemStruct(&stats->set_end);
+}
+
+}  // namespace
+
+VSoCScreenView::VSoCScreenView()
+    : region_view_(ScreenRegionView::GetInstance()) {}
+
+VSoCScreenView::~VSoCScreenView() {}
+
+void VSoCScreenView::Broadcast(int buffer_id,
+                               const cvd::CompositionStats* stats) {
+  if (stats) {
+    vsoc::layout::screen::CompositionStats vsoc_stats;
+    VSoCStatsFromCvdStats(&vsoc_stats, stats);
+    region_view_->BroadcastNewFrame(buffer_id, &vsoc_stats);
+  } else {
+    region_view_->BroadcastNewFrame(buffer_id);
+  }
+}
+
+void* VSoCScreenView::GetBuffer(int fb_index) {
+  return region_view_->GetBuffer(fb_index);
+}
+
+int32_t VSoCScreenView::x_res() const { return region_view_->x_res(); }
+
+int32_t VSoCScreenView::y_res() const { return region_view_->y_res(); }
+
+int32_t VSoCScreenView::dpi() const { return region_view_->dpi(); }
+
+int32_t VSoCScreenView::refresh_rate() const {
+  return region_view_->refresh_rate_hz();
+}
+
+int VSoCScreenView::num_buffers() const {
+  return region_view_->number_of_buffers();
+}
+}  // namespace cvd
diff --git a/guest/hals/hwcomposer/vsoc/vsoc_screen_view.h b/guest/hals/hwcomposer/vsoc/vsoc_screen_view.h
new file mode 100644
index 0000000..1ecace6
--- /dev/null
+++ b/guest/hals/hwcomposer/vsoc/vsoc_screen_view.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+#pragma once
+
+#include <condition_variable>
+#include <functional>
+#include <mutex>
+#include <thread>
+#include <vector>
+
+#include "common/libs/fs/shared_fd.h"
+#include "common/vsoc/lib/screen_region_view.h"
+#include "guest/hals/hwcomposer/common/screen_view.h"
+
+namespace cvd {
+
+class VSoCScreenView : public ScreenView {
+ public:
+  VSoCScreenView();
+  virtual ~VSoCScreenView();
+
+  void Broadcast(int buffer_id,
+                 const CompositionStats* stats = nullptr) override;
+  void* GetBuffer(int fb_index) override;
+
+  int32_t x_res() const override;
+  int32_t y_res() const override;
+  int32_t dpi() const override;
+  int32_t refresh_rate() const override;
+
+  int num_buffers() const override;
+
+ private:
+  vsoc::screen::ScreenRegionView* region_view_;
+};
+
+}  // namespace cvd
diff --git a/guest/vsoc/lib/Android.bp b/guest/vsoc/lib/Android.bp
new file mode 100644
index 0000000..d534a5d
--- /dev/null
+++ b/guest/vsoc/lib/Android.bp
@@ -0,0 +1,77 @@
+//
+// Copyright (C) 2019 The Android Open Source Project
+//
+// 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.
+
+cc_binary {
+    name: "vsoc_driver_test",
+    srcs: [
+        "vsoc_driver_test.cpp",
+    ],
+    shared_libs: [
+        "vsoc_lib",
+        "cuttlefish_auto_resources",
+        "libcuttlefish_fs",
+        "libbase",
+    ],
+    static_libs: [
+        "libgtest",
+    ],
+    cflags: [
+        "-DGTEST_OS_LINUX_ANDROID",
+        "-DGTEST_HAS_STD_STRING",
+    ],
+    defaults: ["cuttlefish_guest_only"]
+}
+
+cc_binary {
+    name: "vsoc_guest_region_e2e_test",
+    srcs: [
+        "guest_region_e2e_test.cpp",
+    ],
+    shared_libs: [
+        "vsoc_lib",
+        "cuttlefish_auto_resources",
+        "libcuttlefish_fs",
+        "libbase",
+    ],
+    static_libs: [
+        "libgtest",
+    ],
+    cflags: [
+        "-DGTEST_OS_LINUX_ANDROID",
+        "-DGTEST_HAS_STD_STRING",
+    ],
+    defaults: ["cuttlefish_guest_only"]
+}
+
+cc_binary {
+    name: "vsoc_managed_region_e2e_test",
+    srcs: [
+        "managed_region_e2e_test.cpp",
+    ],
+    shared_libs: [
+        "vsoc_lib",
+        "cuttlefish_auto_resources",
+        "libcuttlefish_fs",
+        "libbase",
+    ],
+    static_libs: [
+        "libgtest",
+    ],
+    cflags: [
+        "-DGTEST_OS_LINUX_ANDROID",
+        "-DGTEST_HAS_STD_STRING",
+    ],
+    defaults: ["cuttlefish_guest_only"]
+}
diff --git a/guest/vsoc/lib/e2e_test_common.h b/guest/vsoc/lib/e2e_test_common.h
new file mode 100644
index 0000000..521f4c6
--- /dev/null
+++ b/guest/vsoc/lib/e2e_test_common.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <android-base/logging.h>
+
+#define DEATH_TEST_MESSAGE "abort converted to exit of 2 during death test"
+
+static inline void disable_tombstones() {
+  // We don't want a tombstone, and we're already in the child, so we modify the
+  // behavior of LOG(ABORT) to print the well known message and do an
+  // error-based exit.
+  android::base::SetAborter([](const char*) {
+    fputs(DEATH_TEST_MESSAGE, stderr);
+    fflush(stderr);
+    exit(2);
+  });
+}
diff --git a/guest/vsoc/lib/gralloc_region_view.cpp b/guest/vsoc/lib/gralloc_region_view.cpp
new file mode 100644
index 0000000..2c42f57
--- /dev/null
+++ b/guest/vsoc/lib/gralloc_region_view.cpp
@@ -0,0 +1,142 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include "guest/vsoc/lib/gralloc_region_view.h"
+
+#include <common/vsoc/lib/lock_guard.h>
+#include <log/log.h>
+#include <sys/types.h>
+#include <uapi/vsoc_shm.h>
+#include <atomic>
+
+using vsoc::gralloc::GrallocRegionView;
+using vsoc::layout::gralloc::BufferEntry;
+using vsoc::layout::gralloc::GrallocBufferLayout;
+using vsoc::layout::gralloc::GrallocManagerLayout;
+
+namespace {
+template <typename T>
+inline T gralloc_align(T val) {
+  return (val + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1);
+}
+
+// Use the thread id to identify the original creator of a buffer.
+inline uint32_t gralloc_owned_value() {
+  return gettid();
+}
+
+}  // namespace
+
+bool GrallocRegionView::Open() {
+  if (!vsoc::ManagerRegionView<GrallocRegionView, GrallocManagerLayout>::Open()) {
+    return false;
+  }
+  std::shared_ptr<vsoc::RegionControl> managed_region =
+      vsoc::RegionControl::Open(
+          GrallocManagerLayout::ManagedRegion::region_name);
+  if (!managed_region) {
+    LOG_FATAL("Unable to open managed region");
+    return false;
+  }
+  offset_of_buffer_memory_ = gralloc_align<uint32_t>(
+      managed_region->region_desc().offset_of_region_data);
+  total_buffer_memory_ =
+      managed_region->region_size() - offset_of_buffer_memory_;
+
+  // TODO(jemoreira): Handle the case of unexpected values in the region.
+  return true;
+}
+
+int GrallocRegionView::AllocateBuffer(size_t size, uint32_t* begin_offset) {
+  size = gralloc_align<size_t>(size);
+  // Cache the value of buffer_count in shared memory.
+  uint32_t buffer_count_local = 0;
+  {
+    vsoc::LockGuard<vsoc::layout::GuestLock>(&data()->new_buffer_lock);
+    buffer_count_local = data()->buffer_count;
+  }
+  // Find a free buffer entry of the appropriate size.
+  for (uint32_t idx = 0; idx < buffer_count_local; ++idx) {
+    BufferEntry& entry = data()->buffers_table[idx];
+    if (entry.owned_by == VSOC_REGION_FREE && entry.buffer_size() == size) {
+      int fd = control_->CreateFdScopedPermission(
+          GrallocManagerLayout::ManagedRegion::region_name,
+          pointer_to_region_offset(&entry.owned_by),
+          gralloc_owned_value(),
+          entry.buffer_begin,
+          entry.buffer_end);
+      if (fd >= 0) {
+        if (begin_offset) {
+          *begin_offset = entry.buffer_begin;
+        }
+        return fd;
+      }
+    }
+  }
+
+  // We couldn't find any suitable buffer, create one
+  {
+    vsoc::LockGuard<vsoc::layout::GuestLock>(&data()->new_buffer_lock);
+    // don't use the cached value here!!!
+    uint32_t idx = data()->buffer_count;
+    if (pointer_to_region_offset(&data()->buffers_table[idx + 1]) >
+        control_->region_size()) {
+      ALOGE(
+          "Out of memory in gralloc_manager (total: %d, used: %d, "
+          "requested: %d)",
+          static_cast<int>(control_->region_size()),
+          static_cast<int>(
+              pointer_to_region_offset(&data()->buffers_table[idx])),
+          static_cast<int>(sizeof(data()->buffers_table[idx])));
+      return -ENOMEM;
+    }
+    if (total_buffer_memory_ - data()->allocated_buffer_memory < size) {
+      ALOGE(
+          "Out of memory in gralloc_memory (total: %d, used: %d, requested: %d)",
+          static_cast<int>(total_buffer_memory_),
+          static_cast<int>(data()->allocated_buffer_memory),
+          static_cast<int>(size));
+      return -ENOMEM;
+    }
+    // Initialize the buffer entry and acquire ownership
+    // Do it before increasing buffer_count so that another thread looking for
+    // free entries doesn't find this one
+    BufferEntry& new_entry = data()->buffers_table[idx];
+    new_entry.buffer_begin =
+        offset_of_buffer_memory_ + data()->allocated_buffer_memory;
+    data()->allocated_buffer_memory += size;
+    new_entry.buffer_end = new_entry.buffer_begin + size;
+    int fd = control_->CreateFdScopedPermission(
+        GrallocManagerLayout::ManagedRegion::region_name,
+        pointer_to_region_offset(&new_entry.owned_by),
+        gralloc_owned_value(),
+        new_entry.buffer_begin,
+        new_entry.buffer_end);
+    if (fd < 0) {
+      LOG_FATAL(
+          "Unexpected error while creating fd scoped permission over "
+          "uncontested memory: %s",
+          strerror(-fd));
+      return fd;
+    }
+    // Increment buffer_count now that the entry can't be taken from us
+    data()->buffer_count++;
+    if (begin_offset) {
+      *begin_offset = new_entry.buffer_begin;
+    }
+    return fd;
+  }
+}
diff --git a/guest/vsoc/lib/gralloc_region_view.h b/guest/vsoc/lib/gralloc_region_view.h
new file mode 100644
index 0000000..ef5553f
--- /dev/null
+++ b/guest/vsoc/lib/gralloc_region_view.h
@@ -0,0 +1,52 @@
+#pragma once
+
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <common/vsoc/shm/gralloc_layout.h>
+#include <guest/vsoc/lib/manager_region_view.h>
+#include <memory>
+#include <stdlib.h>
+
+namespace vsoc {
+namespace gralloc {
+
+class GrallocRegionView : public vsoc::ManagerRegionView<
+                          GrallocRegionView,
+                          vsoc::layout::gralloc::GrallocManagerLayout> {
+ public:
+  friend TypedRegionView<
+      GrallocRegionView, vsoc::layout::gralloc::GrallocManagerLayout>;
+  GrallocRegionView() = default;
+  // Allocates a gralloc buffer of (at least) the specified size. Returns a file
+  // descriptor that exposes the buffer when mmapped from 0 to (the page
+  // aligned) size (and fails to mmap anything outside of that range) or a
+  // negative number in case of error (e.g not enough free memory left).
+  // TODO(jemoreira): Include debug info like stride, width, height, etc
+  int AllocateBuffer(size_t size, uint32_t* begin_offset = nullptr);
+
+ protected:
+  GrallocRegionView(const GrallocRegionView&) = delete;
+  GrallocRegionView & operator=(const GrallocRegionView&) = delete;
+
+  bool Open();
+
+  uint32_t offset_of_buffer_memory_{};
+  uint32_t total_buffer_memory_{};
+};
+
+} // namespace gralloc
+} // namespace vsoc
diff --git a/guest/vsoc/lib/guest_lock.cpp b/guest/vsoc/lib/guest_lock.cpp
new file mode 100644
index 0000000..247b48b
--- /dev/null
+++ b/guest/vsoc/lib/guest_lock.cpp
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+#include "common/vsoc/shm/lock.h"
+
+#include "common/vsoc/lib/compat.h"
+#include "common/vsoc/lib/single_sided_signal.h"
+
+namespace vsoc {
+namespace layout {
+
+void GuestLock::Lock() {
+  uint32_t tid = gettid();
+  uint32_t expected_value;
+  uint32_t* uaddr = reinterpret_cast<uint32_t*>(&lock_uint32_);
+
+  while (1) {
+    if (TryLock(tid, &expected_value)) {
+      return;
+    }
+    SingleSidedSignal::AwaitSignal(expected_value, uaddr);
+  }
+}
+
+void GuestLock::Unlock() {
+  Sides sides_to_signal = UnlockCommon(gettid());
+  if (sides_to_signal != Sides::NoSides) {
+    SingleSidedSignal::Signal(&lock_uint32_);
+  }
+}
+
+bool GuestLock::Recover() {
+  return RecoverSingleSided();
+}
+
+}  // namespace layout
+}  // namespace vsoc
diff --git a/guest/vsoc/lib/guest_region_e2e_test.cpp b/guest/vsoc/lib/guest_region_e2e_test.cpp
new file mode 100644
index 0000000..5fd644a
--- /dev/null
+++ b/guest/vsoc/lib/guest_region_e2e_test.cpp
@@ -0,0 +1,156 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+/*
+ * End-to-end test to ensure that mapping of vsoc regions works on the guest.
+ */
+
+#include "guest/vsoc/lib/e2e_test_common.h"
+#include "common/vsoc/lib/e2e_test_region_view.h"
+
+#include <android-base/logging.h>
+#include <gtest/gtest.h>
+
+template <typename View>
+void DeathTestView() {
+  disable_tombstones();
+  // View::GetInstance should never return.
+  EXPECT_FALSE(!!View::GetInstance());
+}
+
+// Here is a summary of the two regions interrupt and write test:
+// 1. Write our strings to the first region
+// 2. Ensure that our peer hasn't signalled the second region. That would
+//    indicate that it didn't wait for our interrupt.
+// 3. Send the interrupt on the first region
+// 4. Wait for our peer's interrupt on the first region
+// 5. Confirm that we can see our peer's writes in the first region
+// 6. Initialize our strings in the second region
+// 7. Send an interrupt on the second region to our peer
+// 8. Wait for our peer's interrupt on the second region
+// 9. Confirm that we can see our peer's writes in the second region
+// 10. Repeat the process for signaling.
+// 11. Confirm that no interrupt is pending in the first region
+// 12. Confirm that no interrupt is pending in the second region
+
+template <typename View>
+void SetGuestStrings(View* in) {
+  size_t num_data = in->string_size();
+  EXPECT_LE(2U, num_data);
+  for (size_t i = 0; i < num_data; ++i) {
+    EXPECT_TRUE(!in->guest_string(i)[0] ||
+                !strcmp(in->guest_string(i), View::Layout::guest_pattern));
+    in->set_guest_string(i, View::Layout::guest_pattern);
+    EXPECT_STREQ(in->guest_string(i), View::Layout::guest_pattern);
+  }
+}
+
+template <typename View>
+void CheckPeerStrings(View* in) {
+  size_t num_data = in->string_size();
+  EXPECT_LE(2U, num_data);
+  for (size_t i = 0; i < num_data; ++i) {
+    EXPECT_STREQ(View::Layout::host_pattern, in->host_string(i));
+  }
+}
+
+TEST(RegionTest, BasicPeerTests) {
+  auto primary = vsoc::E2EPrimaryRegionView::GetInstance();
+  auto secondary = vsoc::E2ESecondaryRegionView::GetInstance();
+  ASSERT_TRUE(!!primary);
+  ASSERT_TRUE(!!secondary);
+  LOG(INFO) << "Regions are open";
+  SetGuestStrings(primary);
+  LOG(INFO) << "Primary guest strings are set";
+  EXPECT_FALSE(secondary->HasIncomingInterrupt());
+  LOG(INFO) << "Verified no early second interrupt";
+  EXPECT_TRUE(primary->MaybeInterruptPeer());
+  LOG(INFO) << "Interrupt sent. Waiting for first interrupt from peer";
+  primary->WaitForInterrupt();
+  LOG(INFO) << "First interrupt received";
+  CheckPeerStrings(primary);
+  LOG(INFO) << "Verified peer's primary strings";
+  SetGuestStrings(secondary);
+  LOG(INFO) << "Secondary guest strings are set";
+  EXPECT_TRUE(secondary->MaybeInterruptPeer());
+  LOG(INFO) << "Second interrupt sent";
+  secondary->WaitForInterrupt();
+  LOG(INFO) << "Second interrupt received";
+  CheckPeerStrings(secondary);
+  LOG(INFO) << "Verified peer's secondary strings";
+
+  // Test signals
+  EXPECT_FALSE(secondary->HasIncomingInterrupt());
+  LOG(INFO) << "Verified no early second signal";
+  primary->SendSignal(vsoc::layout::Sides::Peer,
+                      &primary->data()->guest_to_host_signal);
+  LOG(INFO) << "Signal sent. Waiting for first signal from peer";
+  primary->WaitForInterrupt();
+  int count = 0;  // counts the number of signals received.
+  primary->ProcessSignalsFromPeer(
+      [&primary, &count](uint32_t offset) {
+        ++count;
+        EXPECT_TRUE(offset == primary->host_to_guest_signal_offset());
+      });
+  EXPECT_TRUE(count == 1);
+  LOG(INFO) << "Signal received on primary region";
+  secondary->SendSignal(vsoc::layout::Sides::Peer,
+                        &secondary->data()->guest_to_host_signal);
+  LOG(INFO) << "Signal sent. Waiting for second signal from peer";
+  secondary->WaitForInterrupt();
+  count = 0;
+  secondary->ProcessSignalsFromPeer(
+      [&secondary, &count](uint32_t offset) {
+        ++count;
+        EXPECT_TRUE(offset == secondary->host_to_guest_signal_offset());
+      });
+  EXPECT_TRUE(count == 1);
+  LOG(INFO) << "Signal received on secondary region";
+
+  EXPECT_FALSE(primary->HasIncomingInterrupt());
+  EXPECT_FALSE(secondary->HasIncomingInterrupt());
+  LOG(INFO) << "PASS: BasicPeerTests";
+}
+
+TEST(RegionTest, MissingRegionDeathTest) {
+  // EXPECT_DEATH creates a child for the test, so we do it out here.
+  // DeathTestGuestRegion will actually do the deadly call after ensuring
+  // that we don't create an unwanted tombstone.
+  EXPECT_EXIT(DeathTestView<vsoc::E2EUnfindableRegionView>(),
+              testing::ExitedWithCode(2),
+              ".*" DEATH_TEST_MESSAGE ".*");
+}
+
+int main(int argc, char** argv) {
+  if (argc == 2) {
+    // gtest tries to leave temporary files in the current directory, so make the
+    // current directory something that we control.
+    if (chdir(argv[1]) != 0) {
+      abort();
+    }
+  }
+  android::base::InitLogging(argv);
+  testing::InitGoogleTest(&argc, argv);
+  int rval = RUN_ALL_TESTS();
+  if (!rval) {
+    auto region = vsoc::E2EPrimaryRegionView::GetInstance();
+    region->guest_status(vsoc::layout::e2e_test::E2E_MEMORY_FILLED);
+    LOG(INFO) << "stage_1_guest_region_e2e_tests PASSED";
+  } else {
+    LOG(ERROR) << "stage_1_guest_region_e2e_tests FAILED";
+  }
+  return rval;
+}
diff --git a/guest/vsoc/lib/managed_region_e2e_test.cpp b/guest/vsoc/lib/managed_region_e2e_test.cpp
new file mode 100644
index 0000000..390a6b7
--- /dev/null
+++ b/guest/vsoc/lib/managed_region_e2e_test.cpp
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include "common/vsoc/shm/managed_e2e_test_region_layout.h"
+#include "guest/vsoc/lib/e2e_test_common.h"
+#include "guest/vsoc/lib/manager_region_view.h"
+
+#include <android-base/logging.h>
+#include <gtest/gtest.h>
+
+using vsoc::layout::e2e_test::E2EManagedTestRegionLayout;
+using vsoc::layout::e2e_test::E2EManagerTestRegionLayout;
+
+// Region view classes to allow calling the Open() function from the test.
+class E2EManagedTestRegionView
+    : public vsoc::TypedRegionView<
+        E2EManagedTestRegionView,
+        E2EManagedTestRegionLayout> {
+ public:
+  using vsoc::TypedRegionView<
+      E2EManagedTestRegionView, E2EManagedTestRegionLayout>::Open;
+};
+class E2EManagerTestRegionView
+    : public vsoc::ManagerRegionView<
+        E2EManagerTestRegionView,
+        E2EManagerTestRegionLayout> {
+ public:
+  using vsoc::ManagerRegionView<
+      E2EManagerTestRegionView, E2EManagerTestRegionLayout>::Open;
+};
+
+class ManagedRegionTest {
+ public:
+  void testManagedRegionFailMap() {
+    E2EManagedTestRegionView managed_region;
+    disable_tombstones();
+    // managed_region.Open should never return.
+    EXPECT_FALSE(managed_region.Open());
+  }
+
+  void testManagedRegionMap() {
+    EXPECT_TRUE(manager_region_.Open());
+
+    // Maps correctly with permission
+    const uint32_t owned_value = 65, begin_offset = 4096, end_offset = 8192;
+    int perm_fd = manager_region_.CreateFdScopedPermission(
+        &manager_region_.data()->data[0], owned_value, begin_offset,
+        end_offset);
+    EXPECT_TRUE(perm_fd >= 0);
+    fd_scoped_permission perm;
+    ASSERT_TRUE(ioctl(perm_fd, VSOC_GET_FD_SCOPED_PERMISSION, &perm) == 0);
+    void* mapped_ptr = mmap(NULL, perm.end_offset - perm.begin_offset,
+                            PROT_WRITE | PROT_READ, MAP_SHARED, perm_fd, 0);
+    EXPECT_FALSE(mapped_ptr == MAP_FAILED);
+
+    // Owned value gets written
+    EXPECT_TRUE(manager_region_.data()->data[0] == owned_value);
+
+    // Data written to the mapped memory stays there after unmap
+    std::string str = "managed by e2e_manager";
+    strcpy(reinterpret_cast<char*>(mapped_ptr), str.c_str());
+    EXPECT_TRUE(munmap(mapped_ptr, end_offset - begin_offset) == 0);
+    mapped_ptr = mmap(NULL, end_offset - begin_offset, PROT_WRITE | PROT_READ,
+                      MAP_SHARED, perm_fd, 0);
+    EXPECT_FALSE(mapped_ptr == MAP_FAILED);
+    EXPECT_TRUE(strcmp(reinterpret_cast<char*>(mapped_ptr), str.c_str()) == 0);
+
+    // Create permission elsewhere in the region, map same offset and length,
+    // ensure data isn't there
+    EXPECT_TRUE(munmap(mapped_ptr, end_offset - begin_offset) == 0);
+    close(perm_fd);
+    EXPECT_TRUE(manager_region_.data()->data[0] == 0);
+    perm_fd = manager_region_.CreateFdScopedPermission(
+        &manager_region_.data()->data[1], owned_value, begin_offset + 4096,
+        end_offset + 4096);
+    EXPECT_TRUE(perm_fd >= 0);
+    mapped_ptr = mmap(NULL, end_offset - begin_offset, PROT_WRITE | PROT_READ,
+                      MAP_SHARED, perm_fd, 0);
+    EXPECT_FALSE(mapped_ptr == MAP_FAILED);
+    EXPECT_FALSE(strcmp(reinterpret_cast<char*>(mapped_ptr), str.c_str()) == 0);
+  }
+  ManagedRegionTest() {}
+
+ private:
+  E2EManagerTestRegionView manager_region_;
+};
+
+TEST(ManagedRegionTest, ManagedRegionFailMap) {
+  ManagedRegionTest test;
+  EXPECT_EXIT(test.testManagedRegionFailMap(), testing::ExitedWithCode(2),
+              ".*" DEATH_TEST_MESSAGE ".*");
+}
+
+TEST(ManagedRegionTest, ManagedRegionMap) {
+  ManagedRegionTest test;
+  test.testManagedRegionMap();
+}
+
+int main(int argc, char** argv) {
+  if (argc == 2) {
+    // gtest tries to leave temporary files in the current directory, so make the
+    // current directory something that we control.
+    if (chdir(argv[1]) != 0) {
+      abort();
+    }
+  }
+  android::base::InitLogging(argv);
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/guest/vsoc/lib/manager_region_view.h b/guest/vsoc/lib/manager_region_view.h
new file mode 100644
index 0000000..c2a873d
--- /dev/null
+++ b/guest/vsoc/lib/manager_region_view.h
@@ -0,0 +1,58 @@
+#pragma once
+
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include "common/vsoc/lib/typed_region_view.h"
+
+namespace vsoc {
+
+/**
+ * Adds methods to create file descriptor scoped permissions. Just like
+ * TypedRegionView it can be directly constructed or subclassed.
+ *
+ * The Layout type must (in addition to requirements for TypedRegionView) also
+ * provide a nested type for the layout of the managed region.
+ */
+template <typename View, typename Layout>
+class ManagerRegionView : public TypedRegionView<View, Layout> {
+ public:
+  ManagerRegionView() = default;
+  /**
+   * Creates a fd scoped permission on the managed region.
+   *
+   * The managed_region_fd is in/out parameter that can be a not yet open file
+   * descriptor. If the fd is not open yet it will open the managed region
+   * device and then create the permission. If the function returns EBUSY
+   * (meaning that we lost the race to acquire the memory) the same fd can (and
+   * is expected to) be used in a subsequent call to create a permission on
+   * another memory location.
+   *
+   * On success returns an open fd with the requested permission asociated to
+   * it. If another thread/process acquired ownership of *owner_ptr before this
+   * one returns -EBUSY, returns a different negative number otherwise.
+   */
+  int CreateFdScopedPermission(uint32_t* owner_ptr, uint32_t owned_val,
+                               uint32_t begin_offset,
+                               uint32_t end_offset) {
+    return this->control_->CreateFdScopedPermission(
+        Layout::ManagedRegion::region_name,
+        this->pointer_to_region_offset(owner_ptr), owned_val, begin_offset,
+        end_offset);
+  }
+};
+
+}  // namespace vsoc
diff --git a/guest/vsoc/lib/region_control.cpp b/guest/vsoc/lib/region_control.cpp
new file mode 100644
index 0000000..1fcbd13
--- /dev/null
+++ b/guest/vsoc/lib/region_control.cpp
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+#include "common/vsoc/lib/region_view.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <string>
+#include <thread>
+
+#include <android-base/logging.h>
+#include <uapi/vsoc_shm.h>
+
+using cvd::SharedFD;
+
+namespace {
+class GuestRegionControl : public vsoc::RegionControl {
+ public:
+  explicit GuestRegionControl(const SharedFD& region_fd,
+                              const vsoc_device_region& desc)
+      : region_fd_{region_fd} {
+    region_desc_ = desc;
+  }
+  virtual bool InterruptPeer() override;
+  virtual void InterruptSelf() override;
+  virtual void WaitForInterrupt() override;
+  virtual void* Map() override;
+  virtual int SignalSelf(uint32_t offset) override;
+  virtual int WaitForSignal(uint32_t offset, uint32_t expected_value) override;
+
+ protected:
+  int CreateFdScopedPermission(const char* managed_region_name,
+                               uint32_t owner_offset, uint32_t owned_val,
+                               uint32_t begin_offset,
+                               uint32_t end_offset) override;
+  cvd::SharedFD region_fd_;
+};
+
+std::string device_path_from_name(const char* region_name) {
+  return std::string("/dev/") + region_name;
+}
+
+bool GuestRegionControl::InterruptPeer() {
+  int rval = region_fd_->Ioctl(VSOC_SEND_INTERRUPT_TO_HOST, 0);
+  if ((rval == -1) && (errno != EBUSY)) {
+    LOG(INFO) << __FUNCTION__ << ": ioctl failed (" << strerror(errno) << ")";
+  }
+  return !rval;
+}
+
+void GuestRegionControl::InterruptSelf() {
+  region_fd_->Ioctl(VSOC_SELF_INTERRUPT, 0);
+}
+
+void GuestRegionControl::WaitForInterrupt() {
+  region_fd_->Ioctl(VSOC_WAIT_FOR_INCOMING_INTERRUPT, 0);
+}
+
+int GuestRegionControl::SignalSelf(uint32_t offset) {
+  return region_fd_->Ioctl(VSOC_COND_WAKE, reinterpret_cast<void*>(offset));
+}
+
+int GuestRegionControl::WaitForSignal(uint32_t offset,
+                                      uint32_t expected_value) {
+  struct vsoc_cond_wait wait;
+  wait.offset = offset;
+  wait.value = expected_value;
+  wait.wake_time_sec = 0;
+  wait.wake_time_nsec = 0;
+  wait.wait_type = VSOC_WAIT_IF_EQUAL;
+  wait.wakes = 1000;
+  wait.reserved_1 = 0;
+  int rval = region_fd_->Ioctl(VSOC_COND_WAIT, &wait);
+  if (rval == -1) {
+    return rval;
+  }
+  // Clamp the number of wakes if it overflows an integer.
+  rval = wait.wakes;
+  if (rval >= 0) {
+    return rval;
+  }
+  return INT_MAX;
+}
+
+int GuestRegionControl::CreateFdScopedPermission(
+    const char* managed_region_name, uint32_t owner_offset,
+    uint32_t owned_value, uint32_t begin_offset,
+    uint32_t end_offset) {
+  if (!region_fd_->IsOpen()) {
+    LOG(FATAL) << "Can't create permission before opening controller region";
+    return -EINVAL;
+  }
+  int managed_region_fd =
+      open(device_path_from_name(managed_region_name).c_str(), O_RDWR);
+  if (managed_region_fd < 0) {
+    int errno_ = errno;
+    LOG(FATAL) << "Can't open managed region: " << managed_region_name;
+    return -errno_;
+  }
+
+  fd_scoped_permission_arg perm;
+  perm.perm.begin_offset = begin_offset;
+  perm.perm.end_offset = end_offset;
+  perm.perm.owned_value = owned_value;
+  perm.perm.owner_offset = owner_offset;
+  perm.managed_region_fd = managed_region_fd;
+  LOG(INFO) << "owner offset: " << perm.perm.owner_offset;
+  int retval = region_fd_->Ioctl(VSOC_CREATE_FD_SCOPED_PERMISSION, &perm);
+  if (retval) {
+    int errno_ = errno;
+    close(managed_region_fd);
+    if (errno_ != EBUSY) {
+      LOG(FATAL) << "Unable to create fd scoped permission ("
+                 << strerror(errno_) << ")";
+    }
+    return -errno_;
+  }
+  return managed_region_fd;
+}
+
+void* GuestRegionControl::Map() {
+  region_base_ =
+      region_fd_->Mmap(0, region_size(), PROT_READ | PROT_WRITE, MAP_SHARED, 0);
+  if (region_base_ == MAP_FAILED) {
+    LOG(FATAL) << "mmap failed (" << region_fd_->StrError() << ")";
+    region_base_ = nullptr;
+  }
+  return region_base_;
+}
+}  // namespace
+
+// domain is here to ensure that this method has the same signature as the
+// method on host regions.
+std::shared_ptr<vsoc::RegionControl> vsoc::RegionControl::Open(
+    const char* region_name) {
+  std::string path = device_path_from_name(region_name);
+  SharedFD fd = SharedFD::Open(path.c_str(), O_RDWR);
+  if (!fd->IsOpen()) {
+    LOG(FATAL) << "Unable to open region " << region_name << " ("
+               << fd->StrError() << ")";
+    return nullptr;
+  }
+  vsoc_device_region desc;
+  if (fd->Ioctl(VSOC_DESCRIBE_REGION, &desc)) {
+    LOG(FATAL) << "Unable to obtain region descriptor (" << fd->StrError()
+               << ")";
+    return nullptr;
+  }
+  return std::shared_ptr<vsoc::RegionControl>(new GuestRegionControl(fd, desc));
+}
diff --git a/guest/vsoc/lib/region_view.cpp b/guest/vsoc/lib/region_view.cpp
new file mode 100644
index 0000000..db1bec0
--- /dev/null
+++ b/guest/vsoc/lib/region_view.cpp
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+#include "common/vsoc/lib/region_view.h"
+#include "common/vsoc/lib/region_control.h"
+
+const vsoc_signal_table_layout& vsoc::RegionView::incoming_signal_table() {
+  return control_->region_desc().host_to_guest_signal_table;
+}
+
+// Returns a pointer to the table that will be used to post signals
+const vsoc_signal_table_layout& vsoc::RegionView::outgoing_signal_table() {
+  return control_->region_desc().guest_to_host_signal_table;
+}
diff --git a/guest/vsoc/lib/vsoc_driver_test.cpp b/guest/vsoc/lib/vsoc_driver_test.cpp
new file mode 100644
index 0000000..ff20ecb
--- /dev/null
+++ b/guest/vsoc/lib/vsoc_driver_test.cpp
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * 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.
+ */
+
+/*
+ * Stand-alone tests for the ioctls in the vsoc driver.
+ */
+
+#include "uapi/vsoc_shm.h"
+#include <atomic>
+#include <stdint.h>
+#include "common/vsoc/lib/e2e_test_region_view.h"
+#include "guest/vsoc/lib/manager_region_view.h"
+
+#include <android-base/logging.h>
+#include <gtest/gtest.h>
+
+void BasicWaitForSignal(vsoc::E2EPrimaryRegionView* region,
+                        uint32_t expected_start,
+                        uint32_t expected_finish) {
+  ASSERT_EQ(expected_start, region->read_guest_self_register());
+  int rval = region->wait_guest_self_register(expected_start);
+  EXPECT_LE(0, rval);
+  EXPECT_GT(5, rval);
+  EXPECT_EQ(expected_finish, region->read_guest_self_register());
+}
+
+TEST(FutexTest, BasicFutexTests) {
+  constexpr uint32_t INITIAL_SIGNAL = 0;
+  constexpr uint32_t SILENT_UPDATE_SIGNAL = 1;
+  constexpr uint32_t WAKE_SIGNAL = 2;
+  auto region = vsoc::E2EPrimaryRegionView::GetInstance();
+  ASSERT_TRUE(region != NULL);
+  LOG(INFO) << "Regions are open";
+  region->write_guest_self_register(INITIAL_SIGNAL);
+  std::thread waiter(BasicWaitForSignal, region, INITIAL_SIGNAL, WAKE_SIGNAL);
+  sleep(1);
+  LOG(INFO) << "Still waiting. Trying to wake wrong address";
+  region->signal_guest_to_host_register();
+  sleep(1);
+  LOG(INFO) << "Still waiting. Trying to wake without update";
+  region->signal_guest_self_register();
+  sleep(1);
+  LOG(INFO) << "Still waiting. Trying to wake without signal";
+  region->write_guest_self_register(SILENT_UPDATE_SIGNAL);
+  sleep(1);
+  LOG(INFO) << "Still waiting. Trying to wake with signal";
+  region->write_guest_self_register(WAKE_SIGNAL);
+  region->signal_guest_self_register();
+  waiter.join();
+  LOG(INFO) << "Wake worked";
+  LOG(INFO) << "PASS: BasicPeerTests";
+}
+
+int main(int argc, char* argv[]) {
+  android::base::InitLogging(argv);
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/host/commands/Android.bp b/host/commands/Android.bp
index c200611..a6f059d 100644
--- a/host/commands/Android.bp
+++ b/host/commands/Android.bp
@@ -19,6 +19,7 @@
     "launch",
     "stop_cvd",
     "ivserver",
+    "record_audio",
     "virtual_usb_manager",
     "kernel_log_monitor",
     "config_server",
diff --git a/host/commands/assemble_cvd/Android.bp b/host/commands/assemble_cvd/Android.bp
index 75d85d0..c5ac4c9 100644
--- a/host/commands/assemble_cvd/Android.bp
+++ b/host/commands/assemble_cvd/Android.bp
@@ -44,6 +44,7 @@
     ],
     shared_libs: [
         "cdisk_spec",
+        "vsoc_lib",
         "libcuttlefish_fs",
         "libcuttlefish_utils",
         "cuttlefish_auto_resources",
@@ -56,6 +57,7 @@
     static_libs: [
         "libcuttlefish_host_config",
         "libcuttlefish_vm_manager",
+        "libivserver",
         "libgflags",
         "libxml2",
         "libjsoncpp",
diff --git a/host/commands/assemble_cvd/flags.cc b/host/commands/assemble_cvd/flags.cc
index 09e76e6..5ae5a91 100644
--- a/host/commands/assemble_cvd/flags.cc
+++ b/host/commands/assemble_cvd/flags.cc
@@ -9,6 +9,7 @@
 
 #include "common/libs/utils/environment.h"
 #include "common/libs/utils/files.h"
+#include "common/vsoc/lib/vsoc_memory.h"
 #include "host/commands/assemble_cvd/boot_image_unpacker.h"
 #include "host/commands/assemble_cvd/data_image.h"
 #include "host/commands/assemble_cvd/image_aggregator.h"
@@ -112,6 +113,11 @@
 DEFINE_string(vnc_server_binary,
               vsoc::DefaultHostArtifactsPath("bin/vnc_server"),
               "Location of the vnc server binary.");
+DEFINE_bool(start_stream_audio, false,
+            "Whether to start the stream audio process.");
+DEFINE_string(stream_audio_binary,
+              vsoc::DefaultHostArtifactsPath("bin/stream_audio"),
+              "Location of the stream_audio binary.");
 DEFINE_string(virtual_usb_manager_binary,
               vsoc::DefaultHostArtifactsPath("bin/virtual_usb_manager"),
               "Location of the virtual usb manager binary.");
@@ -123,6 +129,8 @@
               "Location of the ivshmem server binary.");
 DEFINE_int32(vnc_server_port, GetPerInstanceDefault(6444),
              "The port on which the vnc server should listen");
+DEFINE_int32(stream_audio_port, GetPerInstanceDefault(7444),
+             "The port on which stream_audio should listen.");
 DEFINE_string(socket_forward_proxy_binary,
               vsoc::DefaultHostArtifactsPath("bin/socket_forward_proxy"),
               "Location of the socket_forward_proxy binary.");
@@ -273,6 +281,7 @@
     const cvd::BootImageUnpacker& boot_image_unpacker,
     const cvd::FetcherConfig& fetcher_config) {
   vsoc::CuttlefishConfig tmp_config_obj;
+  auto& memory_layout = *vsoc::VSoCMemoryLayout::Get();
   // Set this first so that calls to PerInstancePath below are correct
   tmp_config_obj.set_instance_dir(FLAGS_instance_dir);
   if (!vm_manager::VmManager::IsValidName(FLAGS_vm_manager)) {
@@ -435,7 +444,7 @@
       tmp_config_obj.PerInstanceInternalPath("ivshmem_socket_qemu"));
   tmp_config_obj.set_ivshmem_client_socket_path(
       tmp_config_obj.PerInstanceInternalPath("ivshmem_socket_client"));
-  tmp_config_obj.set_ivshmem_vector_count(0);
+  tmp_config_obj.set_ivshmem_vector_count(memory_layout.GetRegions().size());
 
   if (tmp_config_obj.adb_mode().count(vsoc::AdbMode::Usb) > 0) {
     tmp_config_obj.set_usb_v1_socket_name(
@@ -478,6 +487,10 @@
   tmp_config_obj.set_vnc_server_binary(FLAGS_vnc_server_binary);
   tmp_config_obj.set_vnc_server_port(FLAGS_vnc_server_port);
 
+  tmp_config_obj.set_enable_stream_audio(FLAGS_start_stream_audio);
+  tmp_config_obj.set_stream_audio_binary(FLAGS_stream_audio_binary);
+  tmp_config_obj.set_stream_audio_port(FLAGS_stream_audio_port);
+
   tmp_config_obj.set_restart_subprocesses(FLAGS_restart_subprocesses);
   tmp_config_obj.set_run_adb_connector(FLAGS_run_adb_connector);
   tmp_config_obj.set_adb_connector_binary(FLAGS_adb_connector_binary);
diff --git a/host/commands/ivserver/Android.bp b/host/commands/ivserver/Android.bp
new file mode 100644
index 0000000..4fc47a9
--- /dev/null
+++ b/host/commands/ivserver/Android.bp
@@ -0,0 +1,83 @@
+//
+// Copyright (C) 2017 The Android Open Source Project
+//
+// 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.
+
+cc_library_host_static {
+    name: "libivserver",
+    srcs: [
+        "hald_client.cc",
+        "ivserver.cc",
+        "options.cc",
+        "qemu_client.cc",
+        "vsocsharedmem.cc",
+    ],
+    header_libs: [
+        "cuttlefish_glog",
+    ],
+    shared_libs: [
+        "libbase",
+        "vsoc_lib",
+    ],
+    static_libs: [
+        "libjsoncpp",
+    ],
+    defaults: ["cuttlefish_host_only"],
+}
+
+cc_test_host {
+    name: "hald_client_test",
+    srcs: [
+        "hald_client_test.cc",
+    ],
+    header_libs: [
+        "cuttlefish_glog",
+    ],
+    shared_libs: [
+        "libcuttlefish_fs",
+        "cuttlefish_auto_resources",
+        "libbase",
+        "vsoc_lib",
+    ],
+    static_libs: [
+        "libivserver",
+        "libjsoncpp",
+        "libgmock",
+    ],
+    defaults: ["cuttlefish_host_only"],
+}
+
+cc_binary_host {
+    name: "ivserver",
+    srcs: [
+        "main.cpp",
+    ],
+    header_libs: [
+        "cuttlefish_glog",
+    ],
+    shared_libs: [
+        "vsoc_lib",
+        "libbase",
+        "libcuttlefish_fs",
+        "libcuttlefish_utils",
+        "cuttlefish_auto_resources",
+        "liblog",
+    ],
+    static_libs: [
+        "libcuttlefish_host_config",
+        "libivserver",
+        "libgflags",
+        "libjsoncpp",
+    ],
+    defaults: ["cuttlefish_host_only"],
+}
diff --git a/host/commands/ivserver/hald_client.cc b/host/commands/ivserver/hald_client.cc
new file mode 100644
index 0000000..98a83f6
--- /dev/null
+++ b/host/commands/ivserver/hald_client.cc
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+#include "host/commands/ivserver/hald_client.h"
+
+#include <string>
+
+#include <glog/logging.h>
+
+namespace ivserver {
+namespace {
+// The protocol between host-clients and the ivserver could change.
+// Clients should verify what version they are talking to during the handshake.
+const uint32_t kHaldClientProtocolVersion = 0;
+}  // anonymous namespace
+
+std::unique_ptr<HaldClient> HaldClient::New(const VSoCSharedMemory& shmem,
+                                            const cvd::SharedFD& clientfd) {
+  std::unique_ptr<HaldClient> res;
+
+  if (!clientfd->IsOpen()) {
+    LOG(WARNING) << "Invalid socket passed to HaldClient: "
+                 << clientfd->StrError();
+    return res;
+  }
+
+  res.reset(new HaldClient(clientfd));
+  if (!res->PerformHandshake(shmem)) {
+    LOG(ERROR) << "HalD handshake failed. Dropping connection.";
+    res.reset();
+  }
+
+  return res;
+}
+
+HaldClient::HaldClient(const cvd::SharedFD& client_socket)
+    : client_socket_(client_socket) {}
+
+bool HaldClient::PerformHandshake(const VSoCSharedMemory& shared_mem) {
+  int rval =
+      client_socket_->Send(&kHaldClientProtocolVersion,
+                           sizeof(kHaldClientProtocolVersion), MSG_NOSIGNAL);
+  if (rval != sizeof(kHaldClientProtocolVersion)) {
+    LOG(ERROR) << "failed to send protocol version: "
+               << client_socket_->StrError();
+    return false;
+  }
+
+  int16_t region_name_len;
+  if (client_socket_->Recv(&region_name_len, sizeof(region_name_len),
+                           MSG_NOSIGNAL) != sizeof(region_name_len)) {
+    LOG(ERROR) << "Error receiving region name length: "
+               << client_socket_->StrError();
+    return false;
+  }
+
+  if (region_name_len <= 0 ||
+      region_name_len > VSOC_DEVICE_NAME_SZ) {
+    LOG(ERROR) << "Invalid region length received: " << region_name_len;
+    return false;
+  }
+
+  std::vector<char> region_name_data(region_name_len);
+  rval = client_socket_->Recv(region_name_data.data(), region_name_len,
+                              MSG_NOSIGNAL);
+  if (rval != region_name_len) {
+    LOG(ERROR) << "Incomplete region name length received. Want: "
+               << region_name_len << ", got: " << rval;
+    return false;
+  }
+
+  std::string region_name(region_name_data.begin(), region_name_data.end());
+  LOG(INFO) << "New HALD requesting region: " << region_name;
+
+  // Send Host, Guest and SharedMemory FDs associated with this region.
+  cvd::SharedFD guest_to_host_efd;
+  cvd::SharedFD host_to_guest_efd;
+
+  if (!shared_mem.GetEventFdPairForRegion(region_name, &guest_to_host_efd,
+                                          &host_to_guest_efd)) {
+    LOG(ERROR) << "Region " << region_name << " was not found.";
+    return false;
+  }
+
+  if (!guest_to_host_efd->IsOpen()) {
+    LOG(ERROR) << "Host channel is not open; last known error: "
+               << guest_to_host_efd->StrError();
+    return false;
+  }
+
+  if (!host_to_guest_efd->IsOpen()) {
+    LOG(ERROR) << "Guest channel is not open; last known error: "
+               << host_to_guest_efd->StrError();
+    return false;
+  }
+
+  // TODO(ender): delete this once no longer necessary. Currently, absence of
+  // payload makes RecvMsgAndFDs hang forever.
+  uint64_t control_data = 0;
+  struct iovec vec {
+    &control_data, sizeof(control_data)
+  };
+  cvd::InbandMessageHeader hdr{nullptr, 0, &vec, 1, 0};
+  cvd::SharedFD fds[3] = {guest_to_host_efd, host_to_guest_efd,
+                          shared_mem.SharedMemFD()};
+  rval = client_socket_->SendMsgAndFDs<3>(hdr, MSG_NOSIGNAL, fds);
+  if (rval == -1) {
+    LOG(ERROR) << "failed to send Host FD: " << client_socket_->StrError();
+    return false;
+  }
+
+  LOG(INFO) << "HALD managing region: " << region_name << " connected.";
+  return true;
+}
+
+}  // namespace ivserver
diff --git a/host/commands/ivserver/hald_client.h b/host/commands/ivserver/hald_client.h
new file mode 100644
index 0000000..3b0fe2b
--- /dev/null
+++ b/host/commands/ivserver/hald_client.h
@@ -0,0 +1,49 @@
+#pragma once
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <inttypes.h>
+#include <unistd.h>
+#include <memory>
+
+#include "common/libs/fs/shared_fd.h"
+#include "host/commands/ivserver/vsocsharedmem.h"
+
+namespace ivserver {
+
+// Handles a HAL deamon client connection & handshake.
+class HaldClient final {
+ public:
+  static std::unique_ptr<HaldClient> New(const VSoCSharedMemory &shared_mem,
+                                         const cvd::SharedFD &client_fd);
+
+ private:
+  cvd::SharedFD client_socket_;
+
+  // Initialize new instance of HAL Client.
+  HaldClient(const cvd::SharedFD &client_fd);
+
+  // Perform handshake with HAL Client.
+  // If the region is not found approprate status (-1) is sent.
+  // Note that for every new client connected a unique ClientConnection object
+  // will be created and after the handshake it will be destroyed.
+  bool PerformHandshake(const VSoCSharedMemory &shared_mem);
+
+  HaldClient(const HaldClient &) = delete;
+  HaldClient &operator=(const HaldClient &) = delete;
+};
+
+}  // namespace ivserver
diff --git a/host/commands/ivserver/hald_client_test.cc b/host/commands/ivserver/hald_client_test.cc
new file mode 100644
index 0000000..ee65530
--- /dev/null
+++ b/host/commands/ivserver/hald_client_test.cc
@@ -0,0 +1,179 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+#include <stdlib.h>
+#include <memory>
+#include <string>
+#include <thread>
+
+#include <glog/logging.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "common/libs/fs/shared_fd.h"
+#include "host/commands/ivserver/hald_client.h"
+#include "host/commands/ivserver/vsocsharedmem_mock.h"
+
+using ::testing::_;
+using ::testing::DoAll;
+using ::testing::Return;
+using ::testing::ReturnRef;
+using ::testing::SetArgPointee;
+
+namespace ivserver {
+namespace test {
+
+class HaldClientTest : public ::testing::Test {
+ public:
+  void SetUp() override {
+    std::string socket_location;
+    ASSERT_TRUE(GetTempLocation(&socket_location))
+        << "Could not create temp file";
+    LOG(INFO) << "Temp file location: " << socket_location;
+
+    hald_server_socket_ = cvd::SharedFD::SocketLocalServer(
+        socket_location.c_str(), false, SOCK_STREAM, 0666);
+    test_socket_ = cvd::SharedFD::SocketLocalClient(socket_location.c_str(),
+                                                    false, SOCK_STREAM);
+    hald_socket_ =
+        cvd::SharedFD::Accept(*hald_server_socket_, nullptr, nullptr);
+
+    EXPECT_TRUE(hald_server_socket_->IsOpen());
+    EXPECT_TRUE(test_socket_->IsOpen());
+    EXPECT_TRUE(hald_socket_->IsOpen());
+  }
+
+  bool GetTempLocation(std::string* target) {
+    char temp_location[] = "/tmp/hald-client-test-XXXXXX";
+    mktemp(temp_location);
+    *target = temp_location;
+    if (target->size()) {
+      cleanup_files_.emplace_back(*target);
+      return true;
+    }
+    return false;
+  }
+
+  void TearDown() override {
+    hald_socket_->Close();
+    test_socket_->Close();
+    hald_server_socket_->Close();
+
+    for (const std::string& file : cleanup_files_) {
+      unlink(file.c_str());
+    }
+  }
+
+ protected:
+  ::testing::NiceMock<VSoCSharedMemoryMock> vsoc_;
+
+  cvd::SharedFD hald_server_socket_;
+  cvd::SharedFD hald_socket_;
+  cvd::SharedFD test_socket_;
+
+ private:
+  std::vector<std::string> cleanup_files_;
+};
+
+TEST_F(HaldClientTest, HandshakeTerminatedByHald) {
+  std::thread thread(
+      [this]() {
+        auto client(HaldClient::New(vsoc_, hald_socket_));
+        EXPECT_FALSE(client)
+            << "Handshake should not complete when client terminates early.";
+      });
+
+  test_socket_->Close();
+  thread.join();
+}
+
+TEST_F(HaldClientTest, HandshakeTerminatedByInvalidRegionSize) {
+  uint16_t sizes[] = {0, VSOC_DEVICE_NAME_SZ + 1, 0xffff};
+
+  for (uint16_t size : sizes) {
+    std::thread thread([this, size]() {
+      auto client(HaldClient::New(vsoc_, hald_socket_));
+      EXPECT_FALSE(client) << "Handle should not be created when size is "
+                           << size;
+    });
+
+    int32_t proto_version;
+    EXPECT_EQ(sizeof(proto_version),
+              static_cast<size_t>(test_socket_->Recv(
+                  &proto_version, sizeof(proto_version), MSG_NOSIGNAL)));
+
+    test_socket_->Send(&size, sizeof(size), MSG_NOSIGNAL);
+    thread.join();
+  }
+}
+
+TEST_F(HaldClientTest, FullSaneHandshake) {
+  std::string temp;
+  ASSERT_TRUE(GetTempLocation(&temp));
+  cvd::SharedFD host_fd(
+      cvd::SharedFD::Open(temp.c_str(), O_CREAT | O_RDWR, 0666));
+  EXPECT_TRUE(host_fd->IsOpen());
+
+  ASSERT_TRUE(GetTempLocation(&temp));
+  cvd::SharedFD guest_fd(
+      cvd::SharedFD::Open(temp.c_str(), O_CREAT | O_RDWR, 0666));
+  EXPECT_TRUE(guest_fd->IsOpen());
+
+  ASSERT_TRUE(GetTempLocation(&temp));
+  cvd::SharedFD shmem_fd(
+      cvd::SharedFD::Open(temp.c_str(), O_CREAT | O_RDWR, 0666));
+  EXPECT_TRUE(shmem_fd->IsOpen());
+
+  const std::string test_location("testing");
+  EXPECT_CALL(vsoc_, GetEventFdPairForRegion(test_location, _, _))
+      .WillOnce(DoAll(SetArgPointee<1>(host_fd), SetArgPointee<2>(guest_fd),
+                      Return(true)));
+  EXPECT_CALL(vsoc_, SharedMemFD()).WillOnce(ReturnRef(shmem_fd));
+
+  std::thread thread([this]() {
+    auto client(HaldClient::New(vsoc_, hald_socket_));
+    EXPECT_TRUE(client);
+  });
+
+  int32_t proto_version;
+  EXPECT_EQ(sizeof(proto_version),
+            static_cast<size_t>(test_socket_->Recv(
+                &proto_version, sizeof(proto_version), MSG_NOSIGNAL)));
+
+  uint16_t size = test_location.size();
+  EXPECT_EQ(sizeof(size), static_cast<size_t>(test_socket_->Send(
+                              &size, sizeof(size), MSG_NOSIGNAL)));
+  EXPECT_EQ(size, static_cast<size_t>(test_socket_->Send(test_location.data(),
+                                                         size, MSG_NOSIGNAL)));
+
+  // TODO(ender): delete this once no longer necessary. Currently, absence of
+  // payload makes RecvMsgAndFDs hang forever.
+  uint64_t control_data;
+  struct iovec vec {
+    &control_data, sizeof(control_data)
+  };
+  cvd::InbandMessageHeader hdr{nullptr, 0, &vec, 1, 0};
+  cvd::SharedFD fds[3];
+
+  EXPECT_GT(test_socket_->RecvMsgAndFDs<3>(hdr, MSG_NOSIGNAL, &fds), 0);
+  EXPECT_TRUE(fds[0]->IsOpen());
+  EXPECT_TRUE(fds[1]->IsOpen());
+  EXPECT_TRUE(fds[2]->IsOpen());
+
+  thread.join();
+}
+
+}  // namespace test
+}  // namespace ivserver
diff --git a/host/commands/ivserver/ivserver.cc b/host/commands/ivserver/ivserver.cc
new file mode 100644
index 0000000..ca274cc
--- /dev/null
+++ b/host/commands/ivserver/ivserver.cc
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+#include "host/commands/ivserver/ivserver.h"
+
+#include <sys/select.h>
+#include <algorithm>
+
+#include <glog/logging.h>
+
+#include "common/libs/fs/shared_select.h"
+#include "host/commands/ivserver/hald_client.h"
+#include "host/commands/ivserver/qemu_client.h"
+
+namespace ivserver {
+
+IVServer::IVServer(const IVServerOptions &options, int qemu_channel_fd,
+                   int client_channel_fd)
+    : vsoc_shmem_(VSoCSharedMemory::New(options.shm_file_path)) {
+  if (qemu_channel_fd > 0) {
+    qemu_channel_ = cvd::SharedFD::Dup(qemu_channel_fd);
+  } else {
+    LOG_IF(WARNING, unlink(options.qemu_socket_path.c_str()) == 0)
+        << "Removed existing unix socket: " << options.qemu_socket_path
+        << ". We can't confirm yet whether another instance is running.";
+    qemu_channel_ = cvd::SharedFD::SocketLocalServer(
+        options.qemu_socket_path.c_str(), false, SOCK_STREAM, 0666);
+  }
+  LOG_IF(FATAL, !qemu_channel_->IsOpen())
+      << "Could not create QEmu channel: " << qemu_channel_->StrError();
+
+  if (client_channel_fd > 0) {
+    client_channel_ = cvd::SharedFD::Dup(client_channel_fd);
+  } else {
+    LOG_IF(WARNING, unlink(options.client_socket_path.c_str()) == 0)
+        << "Removed existing unix socket: " << options.client_socket_path
+        << ". We can't confirm yet whether another instance is running.";
+    client_channel_ = cvd::SharedFD::SocketLocalServer(
+        options.client_socket_path.c_str(), false, SOCK_STREAM, 0666);
+  }
+  LOG_IF(FATAL, !client_channel_->IsOpen())
+      << "Could not create Client channel: " << client_channel_->StrError();
+}
+
+void IVServer::Serve() {
+  while (true) {
+    cvd::SharedFDSet rset;
+    rset.Set(qemu_channel_);
+    rset.Set(client_channel_);
+    cvd::Select(&rset, nullptr, nullptr, nullptr);
+
+    if (rset.IsSet(qemu_channel_)) {
+      HandleNewQemuConnection();
+    }
+
+    if (rset.IsSet(client_channel_)) {
+      HandleNewClientConnection();
+    }
+  }
+
+  LOG(FATAL) << "Control reached out of event loop";
+}
+
+void IVServer::HandleNewClientConnection() {
+  std::unique_ptr<HaldClient> res = HaldClient::New(
+      *vsoc_shmem_, cvd::SharedFD::Accept(*client_channel_, nullptr, nullptr));
+  if (!res) {
+    LOG(WARNING) << "Rejecting unsuccessful HALD connection.";
+  }
+}
+
+void IVServer::HandleNewQemuConnection() {
+  std::unique_ptr<QemuClient> res = QemuClient::New(
+      *vsoc_shmem_, cvd::SharedFD::Accept(*qemu_channel_, nullptr, nullptr));
+
+  if (!res) {
+    LOG(WARNING) << "Could not accept new QEmu client.";
+  }
+}
+
+}  // namespace ivserver
diff --git a/host/commands/ivserver/ivserver.h b/host/commands/ivserver/ivserver.h
new file mode 100644
index 0000000..d28d14b
--- /dev/null
+++ b/host/commands/ivserver/ivserver.h
@@ -0,0 +1,51 @@
+#pragma once
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <memory>
+
+#include "common/libs/fs/shared_fd.h"
+#include "host/commands/ivserver/options.h"
+#include "host/commands/ivserver/vsocsharedmem.h"
+
+namespace ivserver {
+
+// This class is responsible for orchestrating the setup and then serving
+// new connections.
+class IVServer final {
+ public:
+  // The qemu_channel_fd and client_channel_fd are the server sockets. If
+  // non-positive values are provided the server will create those sockets
+  // itself.
+  IVServer(const IVServerOptions &options, int qemu_channel_fd,
+           int client_channel_fd);
+  IVServer(const IVServer &) = delete;
+  IVServer& operator=(const IVServer&) = delete;
+
+  // Serves incoming client and qemu connection.
+  // This method should never return.
+  void Serve();
+
+ private:
+  void HandleNewClientConnection();
+  void HandleNewQemuConnection();
+
+  std::unique_ptr<VSoCSharedMemory> vsoc_shmem_;
+  cvd::SharedFD qemu_channel_;
+  cvd::SharedFD client_channel_;
+};
+
+}  // namespace ivserver
diff --git a/host/commands/ivserver/main.cpp b/host/commands/ivserver/main.cpp
new file mode 100644
index 0000000..16aa747
--- /dev/null
+++ b/host/commands/ivserver/main.cpp
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <unistd.h>
+
+#include <thread>
+
+#include <gflags/gflags.h>
+#include <glog/logging.h>
+
+#include "host/libs/config/cuttlefish_config.h"
+#include "host/commands/ivserver/ivserver.h"
+#include "host/commands/ivserver/options.h"
+
+DEFINE_int32(
+    qemu_socket_fd, -1,
+    "A file descriptor to use as the server Qemu connects to. If not specified "
+    "a unix socket will be created in the default location.");
+DEFINE_int32(
+    client_socket_fd, -1,
+    "A file descriptor to use as the server clients connects to. If not "
+    "specified a unix socket will be created in the default location.");
+
+int main(int argc, char* argv[]) {
+  ::android::base::InitLogging(argv, android::base::StderrLogger);
+  google::ParseCommandLineFlags(&argc, &argv, true);
+
+  auto config = vsoc::CuttlefishConfig::Get();
+  if (!config) {
+    LOG(ERROR) << "Unable to get cuttlefish config";
+    return 1;
+  }
+
+  ivserver::IVServer server(
+      ivserver::IVServerOptions(config->mempath(),
+                                config->ivshmem_qemu_socket_path(),
+                                vsoc::GetDomain()),
+      FLAGS_qemu_socket_fd, FLAGS_client_socket_fd);
+
+  // Close the file descriptors as they have been dupped by now.
+  if (FLAGS_qemu_socket_fd > 0) {
+    close(FLAGS_qemu_socket_fd);
+  }
+  if (FLAGS_client_socket_fd > 0) {
+    close(FLAGS_client_socket_fd);
+  }
+
+  server.Serve();
+
+  return 0;
+}
diff --git a/host/commands/ivserver/options.cc b/host/commands/ivserver/options.cc
new file mode 100644
index 0000000..0f19397
--- /dev/null
+++ b/host/commands/ivserver/options.cc
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+#include "host/commands/ivserver/options.h"
+
+namespace ivserver {
+
+IVServerOptions::IVServerOptions(const std::string &shm_file_path,
+                                 const std::string &qemu_socket_path,
+                                 const std::string &client_socket_path)
+    : shm_file_path(shm_file_path),
+      qemu_socket_path(qemu_socket_path),
+      client_socket_path(client_socket_path) {}
+
+std::ostream &operator<<(std::ostream &out, const IVServerOptions &options) {
+  out << "\nshm_file: " << options.shm_file_path
+      << "\nqemu_socket_path: " << options.qemu_socket_path
+      << "\nclient_socket_path: " << options.client_socket_path << std::endl;
+
+  return out;
+}
+
+}  // namespace ivserver
diff --git a/host/commands/ivserver/options.h b/host/commands/ivserver/options.h
new file mode 100644
index 0000000..40b3246
--- /dev/null
+++ b/host/commands/ivserver/options.h
@@ -0,0 +1,47 @@
+#pragma once
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <inttypes.h>
+#include <iostream>
+#include <string>
+
+namespace ivserver {
+
+const uint16_t kIVServerMajorVersion = 1;
+const uint16_t kIVServerMinorVersion = 0;
+const uint32_t kIVServerDefaultShmSizeInMiB = 4;
+
+//
+// structure that contains the various options to start the server.
+//
+struct IVServerOptions final {
+  IVServerOptions(const std::string &shm_file_path,
+                  const std::string &qemu_socket_path,
+                  const std::string &client_socket_path);
+
+  //
+  // We still need a friend here
+  //
+  friend std::ostream &operator<<(std::ostream &out,
+                                  const IVServerOptions &opts);
+
+  const std::string shm_file_path;
+  const std::string qemu_socket_path;
+  const std::string client_socket_path;
+};
+
+}  // namespace ivserver
diff --git a/host/commands/ivserver/qemu_client.cc b/host/commands/ivserver/qemu_client.cc
new file mode 100644
index 0000000..660c915
--- /dev/null
+++ b/host/commands/ivserver/qemu_client.cc
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+#include "host/commands/ivserver/qemu_client.h"
+
+#include <glog/logging.h>
+
+namespace ivserver {
+
+std::unique_ptr<QemuClient> QemuClient::New(const VSoCSharedMemory& shmem,
+                                            const cvd::SharedFD& socket) {
+  std::unique_ptr<QemuClient> res;
+  if (!socket->IsOpen()) {
+    LOG(WARNING) << "Invalid socket passed to QemuClient: "
+                 << socket->StrError();
+    return res;
+  }
+
+  res.reset(new QemuClient(std::move(socket)));
+  if (!res->PerformHandshake(shmem)) {
+    LOG(ERROR) << "Qemu handshake failed. Dropping connection.";
+    res.reset();
+  }
+
+  return res;
+}
+
+QemuClient::QemuClient(cvd::SharedFD socket) : client_socket_(socket) {}
+
+// Once the QemuClient object is constructed, invoking the following
+// method will perform the actual handshake with a QEMU instance.
+bool QemuClient::PerformHandshake(const VSoCSharedMemory& shmem) {
+  LOG(INFO) << "New QEmu client connected.";
+  // 1. The protocol version number, currently zero.  The client should
+  //    close the connection on receipt of versions it can't handle.
+  int64_t msg = QemuConstants::kIvshMemProtocolVersion;
+  int rval = client_socket_->Send(&msg, sizeof(msg), MSG_NOSIGNAL);
+  if (rval != sizeof(msg)) {
+    LOG(ERROR) << "Failed to send protocol version: "
+               << client_socket_->StrError();
+    return false;
+  }
+
+  // 2. The client's ID.  This is unique among all clients of this server.
+  //    IDs must be between 0 and 65535, because the Doorbell register
+  //    provides only 16 bits for them.
+  msg = QemuConstants::kGuestID;
+  rval = client_socket_->Send(&msg, sizeof(msg), MSG_NOSIGNAL);
+  if (rval != sizeof(msg)) {
+    LOG(ERROR) << "Failed to send VM Id: " << client_socket_->StrError();
+    return false;
+  }
+
+  // 3. Connect notifications for existing other clients, if any.  This is
+  //    a peer ID (number between 0 and 65535 other than the client's ID),
+  //    repeated N times.  Each repetition is accompanied by one file
+  //    descriptor.  These are for interrupting the peer with that ID using
+  //    vector 0,..,N-1, in order.  If the client is configured for fewer
+  //    vectors, it closes the extra file descriptors.  If it is configured
+  //    for more, the extra vectors remain unconnected.
+  for (const auto& region_data : shmem.Regions()) {
+    if (!SendSocketInfo(kHostID, region_data.host_fd)) {
+      LOG(ERROR) << "Failed to send Host Side FD for region "
+                 << region_data.device_name << ": " << client_socket_->StrError();
+      return false;
+    }
+  }
+
+  // 4. Interrupt setup.  This is the client's own ID, repeated N times.
+  //    Each repetition is accompanied by one file descriptor.  These are
+  //    for receiving interrupts from peers using vector 0,..,N-1, in
+  //    order.  If the client is configured for fewer vectors, it closes
+  //    the extra file descriptors.  If it is configured for more, the
+  //    extra vectors remain unconnected.
+  for (const auto& region_data : shmem.Regions()) {
+    if (!SendSocketInfo(kGuestID, region_data.guest_fd)) {
+      LOG(ERROR) << "Failed to send Guest Side FD for region "
+                 << region_data.device_name << ": " << client_socket_->StrError();
+      return false;
+    }
+  }
+
+  // 5. The number -1, accompanied by the file descriptor for the shared
+  //    memory.
+  if (!SendSocketInfo(kSharedMem, shmem.SharedMemFD())) {
+    LOG(ERROR) << "Failed to send Shared Memory socket: "
+               << client_socket_->StrError();
+    return false;
+  }
+
+
+  LOG(INFO) << "QEmu handshake completed.";
+  return true;
+}
+
+bool QemuClient::SendSocketInfo(QemuConstants message,
+                                const cvd::SharedFD& socket) {
+  struct iovec vec {
+    &message, sizeof(message)
+  };
+  cvd::InbandMessageHeader hdr{nullptr, 0, &vec, 1, 0};
+  cvd::SharedFD fds[] = {socket};
+  int rval = client_socket_->SendMsgAndFDs(hdr, 0, fds);
+  if (rval == -1) {
+    LOG(ERROR) << "failed to send shared_mem_fd: "
+               << client_socket_->StrError();
+    return false;
+  }
+  return true;
+}
+
+}  // namespace ivserver
diff --git a/host/commands/ivserver/qemu_client.h b/host/commands/ivserver/qemu_client.h
new file mode 100644
index 0000000..31cd211
--- /dev/null
+++ b/host/commands/ivserver/qemu_client.h
@@ -0,0 +1,69 @@
+#pragma once
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <memory>
+
+#include "common/libs/fs/shared_fd.h"
+#include "host/commands/ivserver/vsocsharedmem.h"
+
+namespace ivserver {
+
+// QemuClient manages individual QEmu connections using protocol specified
+// in documentation file distributed as part of QEmu 2.8 package under:
+// docs/specs/ivshmem-spec.txt
+// Alternatively, please point your browser to the following URL:
+// https://github.com/qemu/qemu/blob/stable-2.8/docs/specs/ivshmem-spec.txt
+class QemuClient final {
+ public:
+  static std::unique_ptr<QemuClient> New(const VSoCSharedMemory &shmem,
+                                         const cvd::SharedFD &connection);
+
+  cvd::SharedFD client_socket() const { return client_socket_; }
+
+ private:
+  enum QemuConstants : int64_t {
+    kIvshMemProtocolVersion = 0,
+    // Marker for the shared memory file
+    kSharedMem = -1,
+    // HostID is in fact a Peer ID and can take multiple values, depending on
+    // how many subsystems we would like Guest to talk to.
+    kHostID = 0,
+    // GuestID is a unique form of Peer ID (see above), that identifies newly
+    // created quest in IvSharedMem world.
+    kGuestID = 1
+  };
+
+  static_assert(QemuConstants::kHostID != QemuConstants::kGuestID,
+                "Guest and host should have different IDs");
+
+  cvd::SharedFD client_socket_;
+
+  // Initialize new instance of QemuClient.
+  QemuClient(cvd::SharedFD qemu_listener_socket);
+
+  // Once the QemuClient object is constructed, invoking the following
+  // method will perform the actual handshake with a QEMU instance.
+  bool PerformHandshake(const VSoCSharedMemory &shmem_fd);
+
+  // Send socket data to Qemu.
+  bool SendSocketInfo(QemuConstants message, const cvd::SharedFD &socket);
+
+  QemuClient(const QemuClient &) = delete;
+  QemuClient &operator=(const QemuClient &) = delete;
+};
+
+}  // namespace ivserver
diff --git a/host/commands/ivserver/shm_layout.txt b/host/commands/ivserver/shm_layout.txt
new file mode 100644
index 0000000..39d66a7
--- /dev/null
+++ b/host/commands/ivserver/shm_layout.txt
@@ -0,0 +1,88 @@
+(Please      use      a      smaller        font        and/or       appropriate     terminal   width  to      see    this     line without wrapping)
+
+
+                                              REGION DESCRIPTORS
+                                              (starts at page 0)
+                                       +------------------------------+
+                                       |     major_version: u16       |
+                                       +------------------------------+
+                                       |     minor_version: u16       |
+                                       +------------------------------+
+        (size of shared memory)        |         size: u32            |
+                                       +------------------------------+
+          (number of regions)          |     region_count: u32        |
+                                       +------------------------------+
+  (offset of region descriptor data)   | vsoc_region_desc_offset: u32 |o-----+
+                                       +------------------------------+      |
+                                       |                              |      |
+                                       | ..          ..            .. |      |
+                                       |                              |      |
+      (region 0 descriptor start)      +------------------------------+ <----+
+                                       |    current_version: u16      |
+                                       +------------------------------+
+                                       |  min_compatible_version: u16 |
+                                       +------------------------------+
+       (start offset of region 0)      |  region_begin_offset: u32    |o--------------------+
+                                       +------------------------------+                     |
+       (end offset   of region 0)      |  region_end_offset: u32      |o----------------------------------------------------------------------+
+                                       +------------------------------+                     |                                                 |
+                                       |  offset_of_region_data: u32  |o-----+              |                                                 |
+                                       +------------------------------+      |              |                                                 |
+                                       | guest_to_host_signal_table   |      |              |                                                 |
+                                       |______________________________|      |              |                                                 |
+                                        +----------------------------+       |              |                                                 |
+                                        |    num_nodes_lg2: u32      |       |              |                                                 |
+                                        +----------------------------+       |              |                                                 |
+                                        |futex_uaddr_table_offset:u32|o------------------+  |                                                 |
+                                        +----------------------------+       |           |  |                                                 |
+                                        | intr_signaled_offset: u32  |o----------------+ |  |                                                 |
+                                        +----------------------------+       |         | |  |                                                 |
+                                       +------------------------------+      |         | |  |                                                 |
+                                       | host_to_guest_signal_table   |      |         | |  |                                                 |
+                                       |______________________________|      |         | |  |                                                 |
+                                        +----------------------------+       |         | |  |                                                 |
+                                        |    num_nodes_lg2: u32      |       |         | |  |                                                 |
+                                        +----------------------------+       |         | |  |                                                 |
+                                        |futex_uaddr_table_offset:u32|o--------------+ | |  |                                                 |
+                                        +----------------------------+       |       | | |  \/      REGION AREA (page aligned)                |
+                                        | intr_signaled_offset: u32  |o------|-----+ | | |  +---------------------------------------+         |
+                                        +----------------------------+       |     | | | |  |  region area before start of guest to |         |
+                                       +------------------------------+      |     | | | |  |  host signal table.                   |         |
+                                       |    device_name: char[16]     |      |     | | | |  |     (currently does not exist)        |         |
+         (region 0 descriptor end)     +------------------------------+      |     | | | +->+---------------------------------------+         |
+       (region 1 descriptor start)     |                              |      |     | | |    |        uaddr_offset_0 : u32           |         |
+                                       |  current_version: u16        |      |     | | |    +---------------------------------------+         |
+                                       +------------------------------+      |     | | |    |        uaddr_offset_1 : u32           |         |
+                                       |  min_compatible_version: u16 |      |     | | |    +---------------------------------------+         |
+                                       +------------------------------+      |     | | |    |     ...      ..       ...             |         |
+                                       |  region_begin_offset: u32    |      |     | | |    +---------------------------------------+         |
+                                       +------------------------------+      |     | | |    | uaddr_offset_(2^num_nodes_lg2 - 1):u32|         |
+                                       |  region_end_offset: u32      |      |     | | +--->+---------------------------------------+         |
+                                       +------------------------------+      |     | |      |     (interrupt_signaled_area) : u32   |         |
+                                       |  offset_of_region_data: u32  |      |     | +----->+---------------------------------------+         |
+                                       +------------------------------+      |     |        |        uaddr_offset_0 : u32           |         |
+                                       | guest_to_host_signal_table   |      |     |        +---------------------------------------+         |
+                                       +------------------------------+      |     |        |     ...      ..       ...             |         |
+                                       | host_to_guest_signal_table   |      |     |        +---------------------------------------+         |
+                                       +------------------------------+      |     |        | uaddr_offset_(2^num_nodes_lg2 - 1):u32|         |
+                                       |    device_name: char[16]     |      |     +------->+---------------------------------------+         |
+          (region 1 descriptor end)    +------------------------------+      |              |     (interrupt_signaled_area) : u32   |         |
+                                       ...           ...            ...      +------------->+---------------------------------------+         |
+                                       +------------------------------+                     |                                       |         |
+                                       |    current_version: u16      |                     |                                       |         |
+                                       +------------------------------+                     |                                       |         |
+                                       |  min_compatible_version: u16 |                     |         region specific data          |         |
+                                       +------------------------------+                     | (defined by region specific agreement |         |
+                                       |  region_begin_offset: u32    |                     |  between HAL and host-side process)   |         |
+                                       +------------------------------+                     |                                       |         |
+                                       |  region_end_offset: u32      |                     |                                       |         |
+                                       +------------------------------+                     |                                       |         |
+                                       |  offset_of_region_data: u32  |                     +---------------------------------------+ <-------+
+                                       +------------------------------+
+                                       | guest_to_host_signal_table   |
+                                       +------------------------------+
+                                       | host_to_guest_signal_table   |
+                                       +------------------------------+
+                                       |    device_name: char[16]     |
+                                       +------------------------------+
+                                          END OF REGION DESCRIPTORS
diff --git a/host/commands/ivserver/vsocsharedmem.cc b/host/commands/ivserver/vsocsharedmem.cc
new file mode 100644
index 0000000..eb448d8
--- /dev/null
+++ b/host/commands/ivserver/vsocsharedmem.cc
@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+#include "host/commands/ivserver/vsocsharedmem.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/eventfd.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <algorithm>
+#include <tuple>
+
+#include <glog/logging.h>
+
+#include "common/vsoc/lib/vsoc_memory.h"
+#include "uapi/vsoc_shm.h"
+
+namespace ivserver {
+namespace {
+
+class VSoCSharedMemoryImpl : public VSoCSharedMemory {
+ public:
+  VSoCSharedMemoryImpl(const std::map<std::string, size_t> &name_to_region_idx,
+                       const std::vector<Region> &regions,
+                       const std::string &path);
+
+  bool GetEventFdPairForRegion(const std::string &region_name,
+                               cvd::SharedFD *guest_to_host,
+                               cvd::SharedFD *host_to_guest) const override;
+
+  const cvd::SharedFD &SharedMemFD() const override;
+
+  const std::vector<Region> &Regions() const override;
+
+ private:
+  void CreateLayout();
+
+  cvd::SharedFD shared_mem_fd_;
+  const std::map<std::string, size_t> region_name_to_index_;
+  const std::vector<Region> region_data_;
+
+  VSoCSharedMemoryImpl(const VSoCSharedMemoryImpl &) = delete;
+  VSoCSharedMemoryImpl &operator=(const VSoCSharedMemoryImpl &other) = delete;
+};
+
+VSoCSharedMemoryImpl::VSoCSharedMemoryImpl(
+    const std::map<std::string, size_t> &name_to_region_idx,
+    const std::vector<Region> &regions, const std::string &path)
+    : shared_mem_fd_(cvd::SharedFD::Open(path.c_str(), O_RDWR)),
+      region_name_to_index_{name_to_region_idx},
+      region_data_{regions} {
+  LOG_IF(FATAL, !shared_mem_fd_->IsOpen())
+      << "Error in creating shared_memory file: " << shared_mem_fd_->StrError();
+}
+
+const cvd::SharedFD &VSoCSharedMemoryImpl::SharedMemFD() const {
+  return shared_mem_fd_;
+}
+
+const std::vector<VSoCSharedMemory::Region> &VSoCSharedMemoryImpl::Regions()
+    const {
+  return region_data_;
+}
+
+bool VSoCSharedMemoryImpl::GetEventFdPairForRegion(
+    const std::string &region_name, cvd::SharedFD *guest_to_host,
+    cvd::SharedFD *host_to_guest) const {
+  auto it = region_name_to_index_.find(region_name);
+  if (it == region_name_to_index_.end()) return false;
+
+  *guest_to_host = region_data_[it->second].host_fd;
+  *host_to_guest = region_data_[it->second].guest_fd;
+  return true;
+}
+
+}  // anonymous namespace
+
+std::unique_ptr<VSoCSharedMemory> VSoCSharedMemory::New(
+    const std::string &path) {
+  auto device_layout = vsoc::VSoCMemoryLayout::Get();
+
+  std::map<std::string, size_t> name_to_region_idx;
+  std::vector<Region> regions;
+  regions.reserve(device_layout->GetRegions().size());
+
+  for (auto region_spec : device_layout->GetRegions()) {
+    auto device_name = region_spec->region_name();
+
+    // Create one pair of eventfds for this region. Note that the guest to host
+    // eventfd is non-blocking, whereas the host to guest eventfd is blocking.
+    // This is in anticipation of blocking semantics for the host side locks.
+    auto host_fd = cvd::SharedFD::Event(0, EFD_NONBLOCK);
+    if (!host_fd->IsOpen()) {
+      LOG(ERROR) << "Failed to create host eventfd for " << device_name << ": "
+                 << host_fd->StrError();
+      return nullptr;
+    }
+    auto guest_fd = cvd::SharedFD::Event(0, EFD_NONBLOCK);
+    if (!guest_fd->IsOpen()) {
+      LOG(ERROR) << "Failed to create guest eventfd for " << device_name << ": "
+                 << guest_fd->StrError();
+      return nullptr;
+    }
+
+    auto region_idx = regions.size();
+    name_to_region_idx[device_name] = region_idx;
+    regions.emplace_back(device_name, host_fd, guest_fd);
+  }
+
+  return std::unique_ptr<VSoCSharedMemory>(
+      new VSoCSharedMemoryImpl(name_to_region_idx, regions, path));
+}
+
+}  // namespace ivserver
diff --git a/host/commands/ivserver/vsocsharedmem.h b/host/commands/ivserver/vsocsharedmem.h
new file mode 100644
index 0000000..613c6a0
--- /dev/null
+++ b/host/commands/ivserver/vsocsharedmem.h
@@ -0,0 +1,59 @@
+#pragma once
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <inttypes.h>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "common/libs/fs/shared_fd.h"
+#include "uapi/vsoc_shm.h"
+
+namespace ivserver {
+
+class VSoCSharedMemory {
+ public:
+  // Region describes a VSoCSharedMem region.
+  struct Region {
+    Region() = default;
+    explicit Region(const char *device_name, const cvd::SharedFD &host_fd,
+                    const cvd::SharedFD &guest_fd)
+        : device_name(device_name), host_fd(host_fd), guest_fd(guest_fd) {}
+    const char *device_name;
+    cvd::SharedFD host_fd;
+    cvd::SharedFD guest_fd;
+  };
+
+  VSoCSharedMemory() = default;
+  virtual ~VSoCSharedMemory() = default;
+
+  static std::unique_ptr<VSoCSharedMemory> New(const std::string &name);
+
+  virtual bool GetEventFdPairForRegion(const std::string &region_name,
+                                       cvd::SharedFD *guest_to_host,
+                                       cvd::SharedFD *host_to_guest) const = 0;
+
+  virtual const cvd::SharedFD &SharedMemFD() const = 0;
+  virtual const std::vector<Region> &Regions() const = 0;
+
+ private:
+  VSoCSharedMemory(const VSoCSharedMemory &) = delete;
+  VSoCSharedMemory &operator=(const VSoCSharedMemory &other) = delete;
+};
+
+}  // namespace ivserver
diff --git a/host/commands/ivserver/vsocsharedmem_mock.h b/host/commands/ivserver/vsocsharedmem_mock.h
new file mode 100644
index 0000000..4ed1f16
--- /dev/null
+++ b/host/commands/ivserver/vsocsharedmem_mock.h
@@ -0,0 +1,33 @@
+#pragma once
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <gmock/gmock.h>
+
+#include "host/commands/ivserver/vsocsharedmem.h"
+
+namespace ivserver {
+namespace test {
+class VSoCSharedMemoryMock : public VSoCSharedMemory {
+ public:
+  MOCK_CONST_METHOD3(GetEventFdPairForRegion,
+                     bool(const std::string&, cvd::SharedFD*, cvd::SharedFD*));
+  MOCK_CONST_METHOD0(SharedMemFD, const cvd::SharedFD&());
+  MOCK_CONST_METHOD0(Regions,
+                     const std::vector<VSoCSharedMemory::Region>&());
+};
+}  // namespace test
+}  // namespace ivserver
diff --git a/host/commands/launch/Android.bp b/host/commands/launch/Android.bp
index 6dd6426..e2db615 100644
--- a/host/commands/launch/Android.bp
+++ b/host/commands/launch/Android.bp
@@ -24,6 +24,7 @@
         "cuttlefish_glog",
     ],
     shared_libs: [
+        "vsoc_lib",
         "libcuttlefish_fs",
         "libcuttlefish_utils",
         "cuttlefish_auto_resources",
@@ -33,6 +34,7 @@
     static_libs: [
         "libcuttlefish_host_config",
         "libcuttlefish_vm_manager",
+        "libivserver",
         "libgflags",
         "libxml2",
         "libjsoncpp",
diff --git a/host/commands/record_audio/Android.bp b/host/commands/record_audio/Android.bp
new file mode 100644
index 0000000..13f47ef
--- /dev/null
+++ b/host/commands/record_audio/Android.bp
@@ -0,0 +1,35 @@
+//
+// Copyright (C) 2018 The Android Open Source Project
+//
+// 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.
+
+cc_binary_host {
+    name: "record_audio",
+    srcs: [
+        "main.cc",
+    ],
+    include_dirs: [
+        "frameworks/av/cmds/stagefright",
+    ],
+    shared_libs: [
+        "libbase",
+        "libcuttlefish_utils",
+        "vsoc_lib",
+    ],
+    static_libs: [
+        "libcuttlefish_host_config",
+        "libjsoncpp",
+        "libgflags",
+    ],
+    defaults: ["cuttlefish_host_only"],
+}
diff --git a/host/commands/record_audio/main.cc b/host/commands/record_audio/main.cc
new file mode 100644
index 0000000..3c024b8
--- /dev/null
+++ b/host/commands/record_audio/main.cc
@@ -0,0 +1,138 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include "common/vsoc/lib/audio_data_region_view.h"
+#include "common/vsoc/lib/circqueue_impl.h"
+#include "common/vsoc/lib/vsoc_audio_message.h"
+#include "host/libs/config/cuttlefish_config.h"
+
+#include "WaveWriter.h"
+
+#include <android-base/logging.h>
+#include <gflags/gflags.h>
+#include <iostream>
+#include <signal.h>
+
+using AudioDataRegionView = vsoc::audio_data::AudioDataRegionView;
+using WaveWriter = android::WaveWriter;
+
+DEFINE_string(output_file, "", "Location of the output audio file.");
+DEFINE_bool(verbose, false, "Enable verbose logging.");
+
+volatile bool gDone = false;
+static void SigIntHandler(int /* sig */) {
+  gDone = true;
+}
+
+int main(int argc, char **argv) {
+  ::android::base::InitLogging(argv, android::base::StderrLogger);
+  google::ParseCommandLineFlags(&argc, &argv, true);
+
+  LOG_IF(FATAL, FLAGS_output_file.empty())
+      << "--output_file must be specified.";
+
+  AudioDataRegionView *audio_data_rv =
+      AudioDataRegionView::GetInstance(vsoc::GetDomain().c_str());
+
+  auto worker = audio_data_rv->StartWorker();
+
+  std::unique_ptr<WaveWriter> writer;
+  int64_t frameCount = 0LL;
+
+  // The configuration the writer is setup for.
+  gce_audio_message writer_hdr;
+
+  uint8_t buffer[4096];
+
+  gDone = false;
+
+  struct sigaction act;
+  sigemptyset(&act.sa_mask);
+  act.sa_flags = 0;
+  act.sa_handler = SigIntHandler;
+
+  struct sigaction oact;
+  sigaction(SIGINT, &act, &oact);
+
+  while (!gDone) {
+    intptr_t res = audio_data_rv->data()->audio_queue.Read(
+            audio_data_rv,
+            reinterpret_cast<char *>(buffer),
+            sizeof(buffer));
+
+    if (res < 0) {
+      std::cerr << "CircularPacketQueue::Read returned " << res << std::endl;
+        continue;
+    }
+
+    CHECK_GE(static_cast<size_t>(res), sizeof(gce_audio_message));
+
+    gce_audio_message hdr;
+    std::memcpy(&hdr, buffer, sizeof(gce_audio_message));
+
+    if (hdr.message_type != gce_audio_message::DATA_SAMPLES) {
+        continue;
+    }
+
+    const size_t payloadSize = res - sizeof(gce_audio_message);
+
+    if (FLAGS_verbose) {
+      std::cerr
+          << "stream "
+          << hdr.stream_number
+          << ", frame "
+          << hdr.frame_num
+          << ", rate "
+          << hdr.frame_rate
+          << ", channel_mask "
+          << hdr.channel_mask
+          << ", format "
+          << hdr.format
+          << ", payload_size "
+          << payloadSize
+          << std::endl;
+    }
+
+    if (!writer) {
+      const size_t numChannels = hdr.frame_size / sizeof(int16_t);
+
+      writer.reset(
+          new WaveWriter(FLAGS_output_file.c_str(), numChannels, hdr.frame_rate));
+
+      frameCount = hdr.frame_num;
+      writer_hdr = hdr;
+    } else if (writer_hdr.frame_size != hdr.frame_size
+        || writer_hdr.frame_rate != hdr.frame_rate
+        || writer_hdr.stream_number != hdr.stream_number) {
+      std::cerr << "Audio configuration changed. Aborting." << std::endl;
+      break;
+    }
+
+    int64_t framesMissing = hdr.frame_num - frameCount;
+    if (framesMissing > 0) {
+      // TODO(andih): Insert silence here, if necessary.
+    }
+
+    frameCount = hdr.frame_num;
+
+    writer->Append(&buffer[sizeof(gce_audio_message)], payloadSize);
+  }
+
+  std::cout << "DONE" << std::endl;
+
+  return 0;
+}
+
diff --git a/host/commands/run_cvd/Android.bp b/host/commands/run_cvd/Android.bp
index a8621e9..29238c9 100644
--- a/host/commands/run_cvd/Android.bp
+++ b/host/commands/run_cvd/Android.bp
@@ -19,11 +19,14 @@
         "launch.cc",
         "process_monitor.cc",
         "main.cc",
+        "screen_region_handler.cc",
+        "vsoc_shared_memory.cc",
     ],
     header_libs: [
         "cuttlefish_glog",
     ],
     shared_libs: [
+        "vsoc_lib",
         "libcuttlefish_fs",
         "libcuttlefish_utils",
         "cuttlefish_auto_resources",
@@ -33,6 +36,7 @@
     static_libs: [
         "libcuttlefish_host_config",
         "libcuttlefish_vm_manager",
+        "libivserver",
         "libgflags",
         "libxml2",
         "libjsoncpp",
diff --git a/host/commands/run_cvd/launch.cc b/host/commands/run_cvd/launch.cc
index e4eb858..5c42e59 100644
--- a/host/commands/run_cvd/launch.cc
+++ b/host/commands/run_cvd/launch.cc
@@ -8,8 +8,10 @@
 #include "common/libs/fs/shared_fd.h"
 #include "common/libs/utils/files.h"
 #include "common/libs/utils/size_utils.h"
+#include "common/vsoc/shm/screen_layout.h"
 #include "host/commands/run_cvd/runner_defs.h"
 #include "host/commands/run_cvd/pre_launch_initializers.h"
+#include "host/commands/run_cvd/vsoc_shared_memory.h"
 #include "host/libs/vm_manager/crosvm_manager.h"
 #include "host/libs/vm_manager/qemu_manager.h"
 
@@ -18,6 +20,20 @@
 
 namespace {
 
+cvd::SharedFD CreateIvServerUnixSocket(const std::string& path) {
+  return cvd::SharedFD::SocketLocalServer(path.c_str(), false, SOCK_STREAM,
+                                          0666);
+}
+
+std::string GetGuestPortArg() {
+  constexpr int kEmulatorPort = 5555;
+  return std::string{"--guest_ports="} + std::to_string(kEmulatorPort);
+}
+
+std::string GetHostPortArg(const vsoc::CuttlefishConfig& config) {
+  return std::string{"--host_ports="} + std::to_string(config.host_port());
+}
+
 std::string GetAdbConnectorTcpArg(const vsoc::CuttlefishConfig& config) {
   return std::string{"127.0.0.1:"} + std::to_string(config.host_port());
 }
@@ -32,6 +48,10 @@
   return config.adb_mode().count(mode) > 0;
 }
 
+bool AdbTunnelEnabled(const vsoc::CuttlefishConfig& config) {
+  return AdbModeEnabled(config, vsoc::AdbMode::Tunnel);
+}
+
 bool AdbVsockTunnelEnabled(const vsoc::CuttlefishConfig& config) {
   return config.vsock_guest_cid() > 2
       && AdbModeEnabled(config, vsoc::AdbMode::VsockTunnel);
@@ -43,9 +63,11 @@
 }
 
 bool AdbTcpConnectorEnabled(const vsoc::CuttlefishConfig& config) {
+  bool tunnel = AdbTunnelEnabled(config);
   bool vsock_tunnel = AdbVsockTunnelEnabled(config);
   bool vsock_half_tunnel = AdbVsockHalfTunnelEnabled(config);
-  return config.run_adb_connector() && (vsock_tunnel || vsock_half_tunnel);
+  return config.run_adb_connector()
+      && (tunnel || vsock_tunnel || vsock_half_tunnel);
 }
 
 bool AdbVsockConnectorEnabled(const vsoc::CuttlefishConfig& config) {
@@ -71,6 +93,32 @@
   return config.logcat_mode() == cvd::kLogcatVsockMode;
 }
 
+cvd::Command GetIvServerCommand(const vsoc::CuttlefishConfig& config) {
+  // Resize screen region
+  auto actual_width = cvd::AlignToPowerOf2(config.x_res() * 4, 4);// align to 16
+  uint32_t screen_buffers_size =
+      config.num_screen_buffers() *
+      cvd::AlignToPageSize(actual_width * config.y_res() + 16 /* padding */);
+  screen_buffers_size +=
+      (config.num_screen_buffers() - 1) * 4096; /* Guard pages */
+
+  // TODO(b/79170615) Resize gralloc region too.
+
+  vsoc::CreateSharedMemoryFile(
+      config.mempath(),
+      {{vsoc::layout::screen::ScreenLayout::region_name, screen_buffers_size}});
+
+
+  cvd::Command ivserver(config.ivserver_binary());
+  ivserver.AddParameter(
+      "-qemu_socket_fd=",
+      CreateIvServerUnixSocket(config.ivshmem_qemu_socket_path()));
+  ivserver.AddParameter(
+      "-client_socket_fd=",
+      CreateIvServerUnixSocket(config.ivshmem_client_socket_path()));
+  return ivserver;
+}
+
 std::vector<cvd::SharedFD> LaunchKernelLogMonitor(
     const vsoc::CuttlefishConfig& config,
     cvd::ProcessMonitor* process_monitor,
@@ -266,6 +314,17 @@
   return false;
 }
 
+void LaunchStreamAudioIfEnabled(const vsoc::CuttlefishConfig& config,
+                                cvd::ProcessMonitor* process_monitor,
+                                std::function<bool(MonitorEntry*)> callback) {
+  if (config.enable_stream_audio()) {
+    auto port_options = "-port=" + std::to_string(config.stream_audio_port());
+    cvd::Command stream_audio(config.stream_audio_binary());
+    stream_audio.AddParameter(port_options);
+    process_monitor->StartSubprocess(std::move(stream_audio), callback);
+  }
+}
+
 void LaunchAdbConnectorIfEnabled(cvd::ProcessMonitor* process_monitor,
                                  const vsoc::CuttlefishConfig& config,
                                  cvd::SharedFD adbd_events_pipe) {
@@ -292,6 +351,17 @@
   }
 }
 
+void LaunchSocketForwardProxyIfEnabled(cvd::ProcessMonitor* process_monitor,
+                                 const vsoc::CuttlefishConfig& config) {
+  if (AdbTunnelEnabled(config)) {
+    cvd::Command adb_tunnel(config.socket_forward_proxy_binary());
+    adb_tunnel.AddParameter(GetGuestPortArg());
+    adb_tunnel.AddParameter(GetHostPortArg(config));
+    process_monitor->StartSubprocess(std::move(adb_tunnel),
+                                     GetOnSubprocessExitCallback(config));
+  }
+}
+
 void LaunchSocketVsockProxyIfEnabled(cvd::ProcessMonitor* process_monitor,
                                  const vsoc::CuttlefishConfig& config) {
   if (AdbVsockTunnelEnabled(config)) {
@@ -315,3 +385,14 @@
                                      GetOnSubprocessExitCallback(config));
   }
 }
+
+void LaunchIvServerIfEnabled(cvd::ProcessMonitor* process_monitor,
+                             const vsoc::CuttlefishConfig& config) {
+  if (config.enable_ivserver()) {
+    process_monitor->StartSubprocess(GetIvServerCommand(config),
+                                     GetOnSubprocessExitCallback(config));
+
+    // Initialize the regions that require so before the VM starts.
+    PreLaunchInitializers::Initialize(config);
+  }
+}
diff --git a/host/commands/run_cvd/launch.h b/host/commands/run_cvd/launch.h
index 4db6e12..714b5bd 100644
--- a/host/commands/run_cvd/launch.h
+++ b/host/commands/run_cvd/launch.h
@@ -6,6 +6,7 @@
 #include "host/commands/run_cvd/process_monitor.h"
 #include "host/libs/config/cuttlefish_config.h"
 
+cvd::Command GetIvServerCommand(const vsoc::CuttlefishConfig& config);
 std::vector <cvd::SharedFD> LaunchKernelLogMonitor(
     const vsoc::CuttlefishConfig& config,
     cvd::ProcessMonitor* process_monitor,
@@ -19,10 +20,17 @@
 bool LaunchVNCServerIfEnabled(const vsoc::CuttlefishConfig& config,
                               cvd::ProcessMonitor* process_monitor,
                               std::function<bool(cvd::MonitorEntry*)> callback);
+void LaunchStreamAudioIfEnabled(const vsoc::CuttlefishConfig& config,
+                                cvd::ProcessMonitor* process_monitor,
+                                std::function<bool(cvd::MonitorEntry*)> callback);
 void LaunchAdbConnectorIfEnabled(cvd::ProcessMonitor* process_monitor,
                                  const vsoc::CuttlefishConfig& config,
                                  cvd::SharedFD adbd_events_pipe);
+void LaunchSocketForwardProxyIfEnabled(cvd::ProcessMonitor* process_monitor,
+                                 const vsoc::CuttlefishConfig& config);
 void LaunchSocketVsockProxyIfEnabled(cvd::ProcessMonitor* process_monitor,
                                  const vsoc::CuttlefishConfig& config);
+void LaunchIvServerIfEnabled(cvd::ProcessMonitor* process_monitor,
+                             const vsoc::CuttlefishConfig& config);
 void LaunchTombstoneReceiverIfEnabled(const vsoc::CuttlefishConfig& config,
                                       cvd::ProcessMonitor* process_monitor);
diff --git a/host/commands/run_cvd/main.cc b/host/commands/run_cvd/main.cc
index a4ed8cc..dd5ed4d 100644
--- a/host/commands/run_cvd/main.cc
+++ b/host/commands/run_cvd/main.cc
@@ -46,9 +46,12 @@
 #include "common/libs/utils/files.h"
 #include "common/libs/utils/subprocess.h"
 #include "common/libs/utils/size_utils.h"
+#include "common/vsoc/lib/vsoc_memory.h"
+#include "common/vsoc/shm/screen_layout.h"
 #include "host/commands/run_cvd/launch.h"
 #include "host/commands/run_cvd/runner_defs.h"
 #include "host/commands/run_cvd/process_monitor.h"
+#include "host/commands/run_cvd/vsoc_shared_memory.h"
 #include "host/libs/config/cuttlefish_config.h"
 #include "host/commands/kernel_log_monitor/kernel_log_server.h"
 #include <host/libs/vm_manager/crosvm_manager.h>
@@ -452,6 +455,8 @@
   LaunchTombstoneReceiverIfEnabled(*config, &process_monitor);
 
   LaunchUsbServerIfEnabled(*config, &process_monitor);
+
+  LaunchIvServerIfEnabled(&process_monitor, *config);
   // Launch the e2e tests after the ivserver is ready
   LaunchE2eTestIfEnabled(&process_monitor, boot_state_machine, *config);
 
@@ -469,7 +474,10 @@
   }
 
   // Start other host processes
+  LaunchSocketForwardProxyIfEnabled(&process_monitor, *config);
   LaunchSocketVsockProxyIfEnabled(&process_monitor, *config);
+  LaunchStreamAudioIfEnabled(*config, &process_monitor,
+                             GetOnSubprocessExitCallback(*config));
   LaunchAdbConnectorIfEnabled(&process_monitor, *config, adbd_events_pipe);
 
   ServerLoop(launcher_monitor_socket, &process_monitor); // Should not return
diff --git a/host/commands/run_cvd/screen_region_handler.cc b/host/commands/run_cvd/screen_region_handler.cc
new file mode 100644
index 0000000..9be969e
--- /dev/null
+++ b/host/commands/run_cvd/screen_region_handler.cc
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include <glog/logging.h>
+
+#include "common/vsoc/lib/screen_region_view.h"
+#include "host/commands/run_cvd/pre_launch_initializers.h"
+#include "host/libs/config/cuttlefish_config.h"
+
+void InitializeScreenRegion(const vsoc::CuttlefishConfig& config) {
+  auto region =
+      vsoc::screen::ScreenRegionView::GetInstance(vsoc::GetDomain().c_str());
+  if (!region) {
+    LOG(FATAL) << "Screen region was not found";
+    return;
+  }
+  auto dest = region->data();
+  dest->x_res = config.x_res();
+  dest->y_res = config.y_res();
+  dest->dpi = config.dpi();
+  dest->refresh_rate_hz = config.refresh_rate_hz();
+}
diff --git a/host/commands/run_cvd/vsoc_shared_memory.cc b/host/commands/run_cvd/vsoc_shared_memory.cc
new file mode 100644
index 0000000..0278cad
--- /dev/null
+++ b/host/commands/run_cvd/vsoc_shared_memory.cc
@@ -0,0 +1,192 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include "host/commands/run_cvd/vsoc_shared_memory.h"
+
+#include <unistd.h>
+
+#include <map>
+#include <vector>
+
+#include "common/libs/fs/shared_fd.h"
+#include "common/libs/utils/size_utils.h"
+#include "common/vsoc/lib/vsoc_memory.h"
+#include "glog/logging.h"
+
+#include "uapi/vsoc_shm.h"
+
+namespace vsoc {
+
+namespace {
+
+uint32_t OffsetOfRegionData(const VSoCRegionLayout& layout) {
+  uint32_t offset = 0;
+  // Signal tables
+  offset +=
+      (1 << layout.guest_to_host_signal_table_log_size()) * sizeof(uint32_t);
+  offset +=
+      (1 << layout.host_to_guest_signal_table_log_size()) * sizeof(uint32_t);
+  // Interrup signals
+  offset += 2 * sizeof(uint32_t);
+  return offset;
+}
+
+struct VSoCRegionAllocator {
+  const VSoCRegionLayout* region_layout;
+  uint32_t begin_offset;
+  uint32_t region_size;
+
+  VSoCRegionAllocator(const VSoCRegionLayout& layout, uint32_t offset,
+                      uint32_t requested_layout_increase = 0)
+      : region_layout(&layout),
+        begin_offset(offset),
+        region_size(cvd::AlignToPageSize(OffsetOfRegionData(layout) +
+                                         layout.layout_size() +
+                                         requested_layout_increase)) {}
+};
+
+// Writes a region's signal table layout to shared memory. Returns the region
+// offset of free memory after the table and interrupt signaled word.
+uint32_t WriteSignalTableDescription(vsoc_signal_table_layout* layout,
+                                     uint32_t offset, int log_size) {
+  layout->num_nodes_lg2 = log_size;
+  // First the signal table
+  layout->futex_uaddr_table_offset = offset;
+  offset += (1 << log_size) * sizeof(uint32_t);
+  // Then the interrupt signaled word
+  layout->interrupt_signalled_offset = offset;
+  offset += sizeof(uint32_t);
+  return offset;
+}
+
+// Writes a region's layout description to shared memory
+void WriteRegionDescription(vsoc_device_region* shmem_region_desc,
+                            const VSoCRegionAllocator& allocator) {
+  // Region versions are deprecated, write some sensible value
+  shmem_region_desc->current_version = 0;
+  shmem_region_desc->min_compatible_version = 0;
+
+  shmem_region_desc->region_begin_offset = allocator.begin_offset;
+  shmem_region_desc->region_end_offset =
+      allocator.begin_offset + allocator.region_size;
+  shmem_region_desc->offset_of_region_data =
+      OffsetOfRegionData(*allocator.region_layout);
+  strncpy(shmem_region_desc->device_name,
+          allocator.region_layout->region_name(), VSOC_DEVICE_NAME_SZ - 1);
+  shmem_region_desc->device_name[VSOC_DEVICE_NAME_SZ - 1] = '\0';
+  // Guest to host signal table at the beginning of the region
+  uint32_t offset = 0;
+  offset = WriteSignalTableDescription(
+      &shmem_region_desc->guest_to_host_signal_table, offset,
+      allocator.region_layout->guest_to_host_signal_table_log_size());
+  // Host to guest signal table right after
+  offset = WriteSignalTableDescription(
+      &shmem_region_desc->host_to_guest_signal_table, offset,
+      allocator.region_layout->host_to_guest_signal_table_log_size());
+  // Double check that the region metadata does not collide with the data
+  if (offset > shmem_region_desc->offset_of_region_data) {
+    LOG(FATAL) << "Error: Offset of region data too small (is "
+               << shmem_region_desc->offset_of_region_data << " should be "
+               << offset << " ) for region "
+               << allocator.region_layout->region_name() << ". This is a bug";
+  }
+}
+
+void WriteLayout(void* shared_memory,
+                 const std::vector<VSoCRegionAllocator>& allocators,
+                 uint32_t file_size) {
+  // Device header
+  static_assert(CURRENT_VSOC_LAYOUT_MAJOR_VERSION == 2,
+                "Region layout code must be updated");
+  auto header = reinterpret_cast<vsoc_shm_layout_descriptor*>(shared_memory);
+  header->major_version = CURRENT_VSOC_LAYOUT_MAJOR_VERSION;
+  header->minor_version = CURRENT_VSOC_LAYOUT_MINOR_VERSION;
+  header->size = file_size;
+  header->region_count = allocators.size();
+
+  std::map<std::string, size_t> region_idx_by_name;
+  for (size_t idx = 0; idx < allocators.size(); ++idx) {
+    region_idx_by_name[allocators[idx].region_layout->region_name()] = idx;
+  }
+
+  // Region descriptions go right after the layout descriptor
+  header->vsoc_region_desc_offset = sizeof(vsoc_shm_layout_descriptor);
+  auto region_descriptions = reinterpret_cast<vsoc_device_region*>(header + 1);
+  for (size_t idx = 0; idx < allocators.size(); ++idx) {
+    auto shmem_region_desc = &region_descriptions[idx];
+    const auto& region = *allocators[idx].region_layout;
+    WriteRegionDescription(shmem_region_desc, allocators[idx]);
+    // Handle managed_by links
+    if (region.managed_by()) {
+      auto manager_idx = region_idx_by_name.at(region.managed_by());
+      if (manager_idx == VSOC_REGION_WHOLE) {
+        LOG(FATAL) << "Region '" << region.region_name() << "' has owner "
+                   << region.managed_by() << " with index " << manager_idx
+                   << " which is the default value for regions without an "
+                      "owner. Choose a different region to be at index "
+                   << manager_idx
+                   << ", make sure the chosen region is NOT the owner of any "
+                      "other region";
+      }
+      shmem_region_desc->managed_by = manager_idx;
+    } else {
+      shmem_region_desc->managed_by = VSOC_REGION_WHOLE;
+    }
+  }
+}
+}  // namespace
+
+void CreateSharedMemoryFile(
+    const std::string& path,
+    const std::map<std::string, uint32_t>& layout_increases) {
+  // TODO(ender): Lock the file after creation and check lock status upon second
+  // execution attempt instead of throwing an error.
+  LOG_IF(WARNING, unlink(path.c_str()) == 0)
+      << "Removed existing instance of " << path
+      << ". We currently don't know if another instance of daemon is running";
+  auto shared_mem_fd = cvd::SharedFD::Open(
+      path.c_str(), O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
+  LOG_IF(FATAL, !shared_mem_fd->IsOpen())
+      << "Error in creating shared_memory file: " << shared_mem_fd->StrError();
+
+  auto region_layouts = VSoCMemoryLayout::Get()->GetRegions();
+  std::vector<VSoCRegionAllocator> allocators;
+  uint32_t file_size =
+      cvd::AlignToPageSize(sizeof(vsoc_shm_layout_descriptor) +
+                           region_layouts.size() * sizeof(vsoc_device_region));
+  for (auto layout : region_layouts) {
+    allocators.emplace_back(*layout, file_size /* offset */,
+                            layout_increases.count(layout->region_name())
+                                ? layout_increases.at(layout->region_name())
+                                : 0);
+    file_size += allocators.back().region_size;
+  }
+  file_size = cvd::RoundUpToNextPowerOf2(file_size);
+
+  int truncate_res = shared_mem_fd->Truncate(file_size);
+  LOG_IF(FATAL, truncate_res == -1)
+      << "Error in sizing up the shared memory file: "
+      << shared_mem_fd->StrError();
+
+  void* mmap_addr =
+      shared_mem_fd->Mmap(0, file_size, PROT_READ | PROT_WRITE, MAP_SHARED, 0);
+  LOG_IF(FATAL, mmap_addr == MAP_FAILED)
+      << "Error mmaping file: " << strerror(errno);
+  WriteLayout(mmap_addr, allocators, file_size);
+  munmap(mmap_addr, file_size);
+}
+
+}  // namespace vsoc
diff --git a/host/commands/run_cvd/vsoc_shared_memory.h b/host/commands/run_cvd/vsoc_shared_memory.h
new file mode 100644
index 0000000..94c03a1
--- /dev/null
+++ b/host/commands/run_cvd/vsoc_shared_memory.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * 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.
+ */
+#pragma once
+
+#include <map>
+#include <string>
+
+namespace vsoc {
+
+// Creates the shared memory file and initializes it with with the region
+// information. The size of each region is determined to be the smallest
+// multiple of page size that can accommodate the header and the layout. The
+// size of the layout can be increased by specifyng it on the
+// layout_increases_by_region_name parameter.
+void CreateSharedMemoryFile(
+    const std::string& path,
+    const std::map<std::string, uint32_t>& layout_increases_by_region_name = {});
+
+}  // namespace vsoc
diff --git a/host/commands/virtual_usb_manager/Android.bp b/host/commands/virtual_usb_manager/Android.bp
index 40c8c74..9c86b70 100644
--- a/host/commands/virtual_usb_manager/Android.bp
+++ b/host/commands/virtual_usb_manager/Android.bp
@@ -34,6 +34,7 @@
         "cuttlefish_glog",
     ],
     shared_libs: [
+        "vsoc_lib",
         "libcuttlefish_fs",
         "libcuttlefish_utils",
         "cuttlefish_auto_resources",
diff --git a/host/frontend/Android.bp b/host/frontend/Android.bp
index 8d78a9f..5a053e7 100644
--- a/host/frontend/Android.bp
+++ b/host/frontend/Android.bp
@@ -14,6 +14,7 @@
 // limitations under the License.
 
 subdirs = [
+    "stream_audio",
     "vnc_server",
     "adb_connector",
 ]
diff --git a/host/frontend/stream_audio/Android.bp b/host/frontend/stream_audio/Android.bp
new file mode 100644
index 0000000..8f07536
--- /dev/null
+++ b/host/frontend/stream_audio/Android.bp
@@ -0,0 +1,38 @@
+//
+// Copyright (C) 2018 The Android Open Source Project
+//
+// 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.
+
+cc_binary_host {
+    name: "stream_audio",
+    srcs: [
+        "main.cpp",
+    ],
+    shared_libs: [
+        "cuttlefish_tcp_socket",
+        "libbase",
+        "libcuttlefish_utils",
+        "libcuttlefish_fs",
+        "libopus",
+        "vsoc_lib",
+    ],
+    static_libs: [
+        "libcuttlefish_host_config",
+        "libjsoncpp",
+        "libgflags",
+        "libopuscpp",
+    ],
+    cpp_std: "c++17",
+    enabled: false,
+    defaults: ["cuttlefish_host_only"],
+}
diff --git a/host/frontend/stream_audio/main.cpp b/host/frontend/stream_audio/main.cpp
new file mode 100644
index 0000000..f63e315
--- /dev/null
+++ b/host/frontend/stream_audio/main.cpp
@@ -0,0 +1,270 @@
+/*
+ *
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * 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.
+ */
+
+// For each client that connects initially a header is sent with the following,
+// in this order, all as uint16_t in network-byte-order:
+//  number of channels, frame rate
+//
+// Following, audio packets are sent as a uint32_t length (network byte order)
+// indicating the number of bytes
+// followed by the (opus) frame_size as a uint32_t
+// followed by <length> bytes.
+
+#include "common/libs/tcp_socket/tcp_socket.h"
+#include "common/vsoc/lib/audio_data_region_view.h"
+#include "common/vsoc/lib/circqueue_impl.h"
+#include "common/vsoc/lib/vsoc_audio_message.h"
+#include "host/frontend/stream_audio/opuscpp/opus_wrapper.h"
+#include "host/libs/config/cuttlefish_config.h"
+
+#include <android-base/logging.h>
+#include <gflags/gflags.h>
+
+#include <arpa/inet.h>
+
+#include <cstdint>
+#include <cstring>
+#include <iostream>
+#include <memory>
+#include <mutex>
+#include <thread>
+#include <tuple>
+#include <vector>
+
+using vsoc::audio_data::AudioDataRegionView;
+
+DEFINE_int32(port, 0, "port on which to serve audio.");
+
+namespace {
+
+// Read audio frames from the AudioDataRegionView
+class AudioStreamer {
+ public:
+  cvd::Message MakeAudioDescriptionHeader() const {
+    std::unique_lock guard(buffer_lock_);
+    while (!audio_buffer_) {
+      buffer_cv_.wait(guard);
+    }
+
+    const size_t num_channels = header_.frame_size / sizeof(opus_int16);
+    return cvd::CreateMessage(static_cast<std::uint16_t>(num_channels),
+                              static_cast<std::uint16_t>(header_.frame_rate));
+  }
+
+  std::uint32_t frame_rate() const {
+    std::unique_lock guard(buffer_lock_);
+    while (!audio_buffer_) {
+      buffer_cv_.wait(guard);
+    }
+    return header_.frame_rate;
+  }
+
+  std::uint32_t num_channels() const {
+    std::unique_lock guard(buffer_lock_);
+    while (!audio_buffer_) {
+      buffer_cv_.wait(guard);
+    }
+    return header_.frame_size / sizeof(opus_int16);
+  }
+
+  // Returns the frame id and audio frame
+  std::tuple<std::int64_t, std::shared_ptr<const cvd::Message>> audio_buffer(
+      std::int64_t previous_frame_num) const {
+    std::unique_lock guard(buffer_lock_);
+    while (header_.frame_num <= previous_frame_num) {
+      buffer_cv_.wait(guard);
+    }
+
+    return {header_.frame_num, audio_buffer_};
+  }
+
+  void Update() {
+    auto audio_data_rv =
+        AudioDataRegionView::GetInstance(vsoc::GetDomain().c_str());
+    auto worker = audio_data_rv->StartWorker();
+    std::vector<char> new_buffer;
+
+    while (true) {
+      new_buffer.resize(new_buffer.capacity());
+
+      auto [new_header, payload_size, audio_data] =
+          NextAudioMessage(audio_data_rv, &new_buffer);
+
+      LOG(DEBUG) << "stream " << new_header.stream_number << ", frame "
+                 << new_header.frame_num << ", rate " << new_header.frame_rate
+                 << ", channel_mask " << new_header.channel_mask << ", format "
+                 << new_header.format << ", payload_size " << payload_size
+                 << '\n';
+
+      {
+        std::lock_guard guard(buffer_lock_);
+        CheckAudioConfigurationIsSame(new_header);
+        header_ = new_header;
+        audio_buffer_ = std::make_shared<const cvd::Message>(
+            audio_data, audio_data + payload_size);
+      }
+      buffer_cv_.notify_all();
+    }
+  }
+
+ private:
+  struct AudioMessage {
+    gce_audio_message header;
+    std::size_t payload_size;
+    const std::uint8_t* payload_data;
+  };
+
+  void ReadAudioMessage(AudioDataRegionView* audio_data_rv,
+                        std::vector<char>* buffer) const {
+    while (true) {
+      auto read_size = audio_data_rv->data()->audio_queue.Read(
+          audio_data_rv, buffer->data(), buffer->size());
+      if (read_size == -ENOSPC) {
+        DoubleSize(buffer);
+      } else if (read_size < 0) {
+        LOG(ERROR) << "CircularPacketQueue::Read returned " << read_size;
+      } else {
+        buffer->resize(read_size);
+        return;
+      }
+    }
+  }
+
+  void DoubleSize(std::vector<char>* buffer) const {
+    if (buffer->empty()) {
+      buffer->resize(1);
+    } else {
+      buffer->resize(buffer->size() * 2);
+    }
+  }
+
+  gce_audio_message GetHeaderFromBuffer(const std::vector<char>& buffer) const {
+    gce_audio_message new_header{};
+    CHECK_GE(buffer.size(), sizeof new_header);
+
+    std::memcpy(&new_header, buffer.data(), sizeof new_header);
+    CHECK_GT(new_header.stream_number, 0u);
+    return new_header;
+  }
+
+  std::tuple<std::size_t, const std::uint8_t*> GetPayloadFromBuffer(
+      const std::vector<char>& buffer) const {
+    const auto payload_size = buffer.size() - sizeof(gce_audio_message);
+    const auto* audio_data =
+        reinterpret_cast<const std::uint8_t*>(buffer.data()) +
+        sizeof(gce_audio_message);
+    return {payload_size, audio_data};
+  }
+
+  AudioMessage NextAudioMessage(AudioDataRegionView* audio_data_rv,
+                                std::vector<char>* buffer) const {
+    while (true) {
+      ReadAudioMessage(audio_data_rv, buffer);
+      auto header = GetHeaderFromBuffer(*buffer);
+      if (header.message_type == gce_audio_message::DATA_SAMPLES) {
+        auto [payload_size, payload_data] = GetPayloadFromBuffer(*buffer);
+        return {header, payload_size, payload_data};
+      }
+    }
+  }
+
+  void CheckAudioConfigurationIsSame(
+      const gce_audio_message& new_header) const {
+    if (audio_buffer_) {
+      CHECK_EQ(header_.frame_size, new_header.frame_size)
+          << "audio frame_size changed";
+      CHECK_EQ(header_.frame_rate, new_header.frame_rate)
+          << "audio frame_rate changed";
+      CHECK_EQ(header_.stream_number, new_header.stream_number)
+          << "audio stream_number changed";
+    }
+  }
+
+  std::shared_ptr<const cvd::Message> audio_buffer_{};
+  gce_audio_message header_{};
+  mutable std::mutex buffer_lock_;
+  mutable std::condition_variable buffer_cv_;
+};
+
+void HandleClient(AudioStreamer* audio_streamer,
+                  cvd::ClientSocket client_socket) {
+  auto num_channels = audio_streamer->num_channels();
+  opus::Encoder enc(audio_streamer->frame_rate(),
+                    audio_streamer->num_channels(), OPUS_APPLICATION_AUDIO);
+  CHECK(enc.valid()) << "Could not construct Encoder. Maybe bad frame_rate ("
+                     << audio_streamer->frame_rate() <<") or num_channels ("
+                     << audio_streamer->num_channels() << ")?";
+
+  auto header = audio_streamer->MakeAudioDescriptionHeader();
+  client_socket.SendNoSignal(header);
+  std::int64_t previous_frame_num = 0;
+
+  while (!client_socket.closed()) {
+    CHECK(enc.valid()) << "encoder in invalid state";
+    auto [frame_num, audio_data] =
+        audio_streamer->audio_buffer(previous_frame_num);
+    previous_frame_num = frame_num;
+
+    std::vector<opus_int16> pcm(audio_data->size() / sizeof(opus_int16));
+    std::memcpy(pcm.data(), audio_data->data(), audio_data->size());
+    // in opus terms "frame_size" is the number of unencoded samples per frame
+    const std::uint32_t frame_size = pcm.size() / num_channels;
+    auto encoded = enc.Encode(pcm, frame_size);
+    for (auto&& p : encoded) {
+      auto length_message =
+          cvd::CreateMessage(static_cast<std::uint32_t>(p.size()));
+      client_socket.SendNoSignal(length_message);
+      client_socket.SendNoSignal(cvd::CreateMessage(frame_size));
+      client_socket.SendNoSignal(p);
+    }
+  }
+}
+
+[[noreturn]] void AudioStreamerUpdateLoop(AudioStreamer* audio_streamer) {
+  while (true) {
+    audio_streamer->Update();
+  }
+}
+
+[[noreturn]] void MainLoop() {
+  AudioStreamer audio_streamer;
+  std::thread audio_streamer_update_thread;
+  auto server = cvd::ServerSocket(FLAGS_port);
+  while (true) {
+    LOG(INFO) << "waiting for client connection";
+    auto client = server.Accept();
+    LOG(INFO) << "client socket accepted";
+    if (!audio_streamer_update_thread.joinable()) {
+      audio_streamer_update_thread =
+          std::thread{AudioStreamerUpdateLoop, &audio_streamer};
+    }
+    std::thread(HandleClient, &audio_streamer, std::move(client)).detach();
+  }
+}
+
+}  // namespace
+
+int main(int argc, char* argv[]) {
+  ::android::base::InitLogging(argv, android::base::StderrLogger);
+  gflags::SetUsageMessage(" ");
+  google::ParseCommandLineFlags(&argc, &argv, true);
+  if (FLAGS_port <= 0) {
+    std::cerr << "--port must be specified.\n";
+    return 1;
+  }
+  MainLoop();
+}
diff --git a/host/frontend/stream_audio/opuscpp/Android.bp b/host/frontend/stream_audio/opuscpp/Android.bp
new file mode 100644
index 0000000..9ad7a52
--- /dev/null
+++ b/host/frontend/stream_audio/opuscpp/Android.bp
@@ -0,0 +1,28 @@
+//
+// Copyright (C) 2019 The Android Open Source Project
+//
+// 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.
+
+cc_library_host_static {
+    name: "libopuscpp",
+    srcs: [
+        "opus_wrapper.cc",
+    ],
+    shared_libs: [
+        "libbase",
+        "libopus",
+    ],
+    cpp_std: "c++17",
+    enabled: false,
+    defaults: ["cuttlefish_host_only"],
+}
diff --git a/host/frontend/stream_audio/opuscpp/opus_wrapper.cc b/host/frontend/stream_audio/opuscpp/opus_wrapper.cc
new file mode 100644
index 0000000..538bee8
--- /dev/null
+++ b/host/frontend/stream_audio/opuscpp/opus_wrapper.cc
@@ -0,0 +1,177 @@
+// Copyright 2018 Google LLC
+//
+// 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
+//
+//     https://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.
+
+// https://github.com/google/opuscpp
+
+#include <iterator>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <android-base/logging.h>
+#include "host/frontend/stream_audio/opuscpp/opus_wrapper.h"
+
+std::string opus::ErrorToString(int error) {
+  switch (error) {
+    case OPUS_OK:
+      return "OK";
+    case OPUS_BAD_ARG:
+      return "One or more invalid/out of range arguments.";
+    case OPUS_BUFFER_TOO_SMALL:
+      return "The mode struct passed is invalid.";
+    case OPUS_INTERNAL_ERROR:
+      return "An internal error was detected.";
+    case OPUS_INVALID_PACKET:
+      return "The compressed data passed is corrupted.";
+    case OPUS_UNIMPLEMENTED:
+      return "Invalid/unsupported request number.";
+    case OPUS_INVALID_STATE:
+      return "An encoder or decoder structure is invalid or already freed.";
+    default:
+      return "Unknown error code: " + std::to_string(error);
+  }
+}
+
+void opus::internal::OpusDestroyer::operator()(OpusEncoder* encoder) const
+    noexcept {
+  opus_encoder_destroy(encoder);
+}
+
+void opus::internal::OpusDestroyer::operator()(OpusDecoder* decoder) const
+    noexcept {
+  opus_decoder_destroy(decoder);
+}
+
+opus::Encoder::Encoder(opus_int32 sample_rate, int num_channels,
+                       int application, int expected_loss_percent)
+    : num_channels_{num_channels} {
+  int error{};
+  encoder_.reset(
+      opus_encoder_create(sample_rate, num_channels, application, &error));
+  valid_ = error == OPUS_OK;
+  if (!valid()) {
+    LOG(INFO) << "Could not construct encoder. Error: " << ErrorToString(error);
+    return;
+  }
+  if (expected_loss_percent > 0) {
+    LOG(INFO) << "Enabling FEC in the encoder.";
+    Ctl(OPUS_SET_INBAND_FEC(1));
+    Ctl(OPUS_SET_PACKET_LOSS_PERC(expected_loss_percent));
+  }
+}
+
+bool opus::Encoder::ResetState() {
+  valid_ = Ctl(OPUS_RESET_STATE) == OPUS_OK;
+  return valid_;
+}
+
+bool opus::Encoder::SetBitrate(int bitrate) {
+  valid_ = Ctl(OPUS_SET_BITRATE(bitrate)) == OPUS_OK;
+  return valid_;
+}
+
+bool opus::Encoder::SetVariableBitrate(int vbr) {
+  valid_ = Ctl(OPUS_SET_VBR(vbr)) == OPUS_OK;
+  return valid_;
+}
+
+bool opus::Encoder::SetComplexity(int complexity) {
+  valid_ = Ctl(OPUS_SET_COMPLEXITY(complexity)) == OPUS_OK;
+  return valid_;
+}
+
+int opus::Encoder::GetLookahead() {
+  opus_int32 skip{};
+  valid_ = Ctl(OPUS_GET_LOOKAHEAD(&skip)) == OPUS_OK;
+  return skip;
+}
+
+std::vector<std::vector<unsigned char>> opus::Encoder::Encode(
+    const std::vector<opus_int16>& pcm, int frame_size) {
+  constexpr auto sample_size = sizeof(pcm[0]);
+  const auto frame_length = frame_size * num_channels_ * sample_size;
+  auto data_length = pcm.size() * sample_size;
+  if (data_length % frame_length != 0u) {
+    LOG(WARNING) << "PCM samples contain an incomplete frame. Ignoring the "
+                    "incomplete frame.";
+    data_length -= (data_length % frame_length);
+  }
+
+  std::vector<std::vector<unsigned char>> encoded;
+  for (std::size_t i{}; i < data_length; i += frame_length) {
+    encoded.push_back(EncodeFrame(pcm.begin() + (i / sample_size), frame_size));
+  }
+  return encoded;
+}
+
+std::vector<unsigned char> opus::Encoder::EncodeFrame(
+    const std::vector<opus_int16>::const_iterator& frame_start,
+    int frame_size) {
+  const auto frame_length = (frame_size * num_channels_ * sizeof(*frame_start));
+  std::vector<unsigned char> encoded(frame_length);
+  auto num_bytes = opus_encode(encoder_.get(), &*frame_start, frame_size,
+                               encoded.data(), encoded.size());
+  if (num_bytes < 0) {
+    LOG(ERROR) << "Encode error: " << opus::ErrorToString(num_bytes);
+    return {};
+  }
+  encoded.resize(num_bytes);
+  return encoded;
+}
+
+opus::Decoder::Decoder(opus_uint32 sample_rate, int num_channels)
+    : num_channels_(num_channels) {
+  int error{};
+  decoder_.reset(opus_decoder_create(sample_rate, num_channels, &error));
+  valid_ = error == OPUS_OK;
+}
+
+std::vector<opus_int16> opus::Decoder::Decode(
+    const std::vector<std::vector<unsigned char>>& packets, int frame_size,
+    bool decode_fec) {
+  std::vector<opus_int16> decoded;
+  for (const auto& enc : packets) {
+    auto just_decoded = Decode(enc, frame_size, decode_fec);
+    decoded.insert(std::end(decoded), std::begin(just_decoded),
+                   std::end(just_decoded));
+  }
+  return decoded;
+}
+
+std::vector<opus_int16> opus::Decoder::Decode(
+    const std::vector<unsigned char>& packet, int frame_size, bool decode_fec) {
+  const auto frame_length = (frame_size * num_channels_ * sizeof(opus_int16));
+  std::vector<opus_int16> decoded(frame_length);
+  auto num_samples = opus_decode(decoder_.get(), packet.data(), packet.size(),
+                                 decoded.data(), frame_size, decode_fec);
+  if (num_samples < 0) {
+    LOG(ERROR) << "Decode error: " << opus::ErrorToString(num_samples);
+    return {};
+  }
+  decoded.resize(num_samples * num_channels_);
+  return decoded;
+}
+
+std::vector<opus_int16> opus::Decoder::DecodeDummy(int frame_size) {
+  const auto frame_length = (frame_size * num_channels_ * sizeof(opus_int16));
+  std::vector<opus_int16> decoded(frame_length);
+  auto num_samples =
+      opus_decode(decoder_.get(), nullptr, 0, decoded.data(), frame_size, true);
+  if (num_samples < 0) {
+    LOG(ERROR) << "Decode error: " << opus::ErrorToString(num_samples);
+    return {};
+  }
+  decoded.resize(num_samples * num_channels_);
+  return decoded;
+}
diff --git a/host/frontend/stream_audio/opuscpp/opus_wrapper.h b/host/frontend/stream_audio/opuscpp/opus_wrapper.h
new file mode 100644
index 0000000..07e932e
--- /dev/null
+++ b/host/frontend/stream_audio/opuscpp/opus_wrapper.h
@@ -0,0 +1,133 @@
+// Copyright 2018 Google LLC
+//
+// 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
+//
+//     https://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.
+
+// https://github.com/google/opuscpp
+
+#ifndef OPUSCPP_OPUS_WRAPPER_H_
+#define OPUSCPP_OPUS_WRAPPER_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "opus.h"
+
+namespace opus {
+
+std::string ErrorToString(int error);
+
+namespace internal {
+// Deleter for OpusEncoders and OpusDecoders
+struct OpusDestroyer {
+  void operator()(OpusEncoder* encoder) const noexcept;
+  void operator()(OpusDecoder* decoder) const noexcept;
+};
+template <typename T>
+using opus_uptr = std::unique_ptr<T, OpusDestroyer>;
+}  // namespace internal
+
+class Encoder {
+ public:
+  // see documentation at:
+  // https://mf4.xiph.org/jenkins/view/opus/job/opus/ws/doc/html/group__opus__encoder.html#gaa89264fd93c9da70362a0c9b96b9ca88
+  // Fs corresponds to sample_rate
+  //
+  // If expected_loss_percent is positive, FEC will be enabled
+  Encoder(opus_int32 sample_rate, int num_channels, int application,
+          int expected_loss_percent = 0);
+
+  // Resets internal state of encoder. This should be called between encoding
+  // different streams so that back-to-back decoding and one-at-a-time decoding
+  // give the same result. Returns true on success.
+  bool ResetState();
+
+  // Sets the desired bitrate. Rates from 500 to 512000 are meaningful as well
+  // as the special values OPUS_AUTO and OPUS_BITRATE_MAX. If this method
+  // is not called, the default value of OPUS_AUTO is used.
+  // Returns true on success.
+  bool SetBitrate(int bitrate);
+
+  // Enables or disables variable bitrate in the encoder. By default, variable
+  // bitrate is enabled. Returns true on success.
+  bool SetVariableBitrate(int vbr);
+
+  // Sets the computational complexity of the encoder, in the range of 0 to 10,
+  // inclusive, with 10 being the highest complexity. Returns true on success.
+  bool SetComplexity(int complexity);
+
+  // Gets the total samples of delay added by the entire codec. This value
+  // is the minimum amount of 'preskip' that has to be specified in an
+  // ogg-stream that encapsulates the encoded audio.
+  int GetLookahead();
+
+  // Takes audio data and encodes it. Returns a sequence of encoded packets.
+  // pcm.size() must be divisible by frame_size * (number of channels);
+  // pcm must not contain any incomplete packets.
+  // see documentation for pcm and frame_size at:
+  // https://mf4.xiph.org/jenkins/view/opus/job/opus/ws/doc/html/group__opus__encoder.html#gad2d6bf6a9ffb6674879d7605ed073e25
+  std::vector<std::vector<unsigned char>> Encode(
+      const std::vector<opus_int16>& pcm, int frame_size);
+
+  int valid() const { return valid_; }
+
+ private:
+  std::vector<unsigned char> EncodeFrame(
+      const std::vector<opus_int16>::const_iterator& frame_start,
+      int frame_size);
+
+  template <typename... Ts>
+  int Ctl(int request, Ts... args) const {
+    return opus_encoder_ctl(encoder_.get(), request, args...);
+  }
+
+  int num_channels_{};
+  bool valid_{};
+  internal::opus_uptr<OpusEncoder> encoder_;
+};
+
+class Decoder {
+ public:
+  // see documentation at:
+  // https://mf4.xiph.org/jenkins/view/opus/job/opus/ws/doc/html/group__opus__decoder.html#ga753f6fe0b699c81cfd47d70c8e15a0bd
+  // Fs corresponds to sample_rate
+  Decoder(opus_uint32 sample_rate, int num_channels);
+
+  // Takes a sequence of encoded packets and decodes them. Returns the decoded
+  // audio.
+  // see documentation at:
+  // https://mf4.xiph.org/jenkins/view/opus/job/opus/ws/doc/html/group__opus__decoder.html#ga7d1111f64c36027ddcb81799df9b3fc9
+  std::vector<opus_int16> Decode(
+      const std::vector<std::vector<unsigned char>>& packets, int frame_size,
+      bool decode_fec);
+
+  int valid() const { return valid_; }
+
+  // Takes an encoded packet and decodes it. Returns the decoded audio
+  // see documentation at:
+  // https://mf4.xiph.org/jenkins/view/opus/job/opus/ws/doc/html/group__opus__decoder.html#ga7d1111f64c36027ddcb81799df9b3fc9
+  std::vector<opus_int16> Decode(const std::vector<unsigned char>& packet,
+                                 int frame_size, bool decode_fec);
+
+  // Generates a dummy frame by passing nullptr to the underlying opus decode.
+  std::vector<opus_int16> DecodeDummy(int frame_size);
+
+ private:
+  int num_channels_{};
+  bool valid_{};
+  internal::opus_uptr<OpusDecoder> decoder_;
+};
+
+}  // namespace opus
+
+#endif
diff --git a/host/frontend/vnc_server/Android.bp b/host/frontend/vnc_server/Android.bp
index 210f21d..fae5a17 100644
--- a/host/frontend/vnc_server/Android.bp
+++ b/host/frontend/vnc_server/Android.bp
@@ -30,6 +30,7 @@
         "cuttlefish_glog",
     ],
     shared_libs: [
+        "vsoc_lib",
         "libcuttlefish_fs",
         "libcuttlefish_utils",
         "cuttlefish_tcp_socket",
diff --git a/host/frontend/vnc_server/screen_connector.cpp b/host/frontend/vnc_server/screen_connector.cpp
index 35cf22f..53cb389 100644
--- a/host/frontend/vnc_server/screen_connector.cpp
+++ b/host/frontend/vnc_server/screen_connector.cpp
@@ -18,11 +18,11 @@
 
 #include <atomic>
 #include <condition_variable>
-#include <thread>
 
-#include <glog/logging.h>
 #include <gflags/gflags.h>
 
+#include <common/vsoc/lib/screen_region_view.h>
+#include <host/libs/config/cuttlefish_config.h>
 #include "host/frontend/vnc_server/vnc_utils.h"
 
 DEFINE_int32(frame_server_fd, -1, "");
@@ -31,6 +31,23 @@
 namespace vnc {
 
 namespace {
+class VSoCScreenConnector : public ScreenConnector {
+ public:
+  int WaitForNewFrameSince(std::uint32_t* seq_num) override {
+    if (!screen_view_) return -1;
+    return screen_view_->WaitForNewFrameSince(seq_num);
+  }
+
+  void* GetBuffer(int buffer_idx) override {
+    if (!screen_view_) return nullptr;
+    return screen_view_->GetBuffer(buffer_idx);
+  }
+
+ private:
+  vsoc::screen::ScreenRegionView* screen_view_ =
+      vsoc::screen::ScreenRegionView::GetInstance(vsoc::GetDomain().c_str());
+};
+
 // TODO(b/128852363): Substitute with one based on memory shared with the
 //  wayland mock
 class SocketBasedScreenConnector : public ScreenConnector {
@@ -123,7 +140,12 @@
 }  // namespace
 
 ScreenConnector* ScreenConnector::Get() {
-  return new SocketBasedScreenConnector();
+  auto config = vsoc::CuttlefishConfig::Get();
+  if (config->enable_ivserver()) {
+    return new VSoCScreenConnector();
+  } else {
+    return new SocketBasedScreenConnector();
+  }
 }
 
 }  // namespace vnc
diff --git a/host/frontend/vnc_server/simulated_hw_composer.cpp b/host/frontend/vnc_server/simulated_hw_composer.cpp
index 96702e8..7a94454 100644
--- a/host/frontend/vnc_server/simulated_hw_composer.cpp
+++ b/host/frontend/vnc_server/simulated_hw_composer.cpp
@@ -20,6 +20,7 @@
 #include "host/libs/config/cuttlefish_config.h"
 
 using cvd::vnc::SimulatedHWComposer;
+using vsoc::screen::ScreenRegionView;
 
 SimulatedHWComposer::SimulatedHWComposer(BlackBoard* bb)
     :
diff --git a/host/frontend/vnc_server/virtual_inputs.cpp b/host/frontend/vnc_server/virtual_inputs.cpp
index fb91409..31c0328 100644
--- a/host/frontend/vnc_server/virtual_inputs.cpp
+++ b/host/frontend/vnc_server/virtual_inputs.cpp
@@ -16,19 +16,18 @@
 
 #include "host/frontend/vnc_server/virtual_inputs.h"
 #include <gflags/gflags.h>
-#include <glog/logging.h>
 #include <linux/input.h>
 #include <linux/uinput.h>
 
 #include <cstdint>
 #include <mutex>
-#include <thread>
 #include "keysyms.h"
 
 #include <common/libs/fs/shared_select.h>
 #include <host/libs/config/cuttlefish_config.h>
 
 using cvd::vnc::VirtualInputs;
+using vsoc::input_events::InputEventsRegionView;
 
 DEFINE_int32(touch_fd, -1,
              "A fd for a socket where to accept touch connections");
@@ -246,6 +245,37 @@
 
 }  // namespace
 
+class VSoCVirtualInputs : public VirtualInputs {
+ public:
+  VSoCVirtualInputs()
+      : input_events_region_view_{
+            vsoc::input_events::InputEventsRegionView::GetInstance(
+                vsoc::GetDomain().c_str())} {
+    if (!input_events_region_view_) {
+      LOG(FATAL) << "Failed to open Input events region view";
+    }
+  }
+
+  void GenerateKeyPressEvent(int code, bool down) override {
+    if (keymapping_.count(code)) {
+      input_events_region_view_->HandleKeyboardEvent(down, keymapping_[code]);
+    } else {
+      LOG(ERROR) << "Unknown keycode" << code;
+    }
+  }
+
+  void PressPowerButton(bool down) override {
+    input_events_region_view_->HandlePowerButtonEvent(down);
+  }
+
+  void HandlePointerEvent(bool touch_down, int x, int y) override {
+    input_events_region_view_->HandleSingleTouchEvent(touch_down, x, y);
+  }
+
+ private:
+  vsoc::input_events::InputEventsRegionView* input_events_region_view_{};
+};
+
 class SocketVirtualInputs : public VirtualInputs {
  public:
   SocketVirtualInputs()
diff --git a/host/frontend/vnc_server/virtual_inputs.h b/host/frontend/vnc_server/virtual_inputs.h
index 7aca3eb..f92693b 100644
--- a/host/frontend/vnc_server/virtual_inputs.h
+++ b/host/frontend/vnc_server/virtual_inputs.h
@@ -21,6 +21,8 @@
 #include <map>
 #include <mutex>
 
+#include "common/vsoc/lib/input_events_region_view.h"
+
 namespace cvd {
 namespace vnc {
 
diff --git a/host/frontend/vnc_server/vnc_client_connection.cpp b/host/frontend/vnc_server/vnc_client_connection.cpp
index b81bb88..a8faf47 100644
--- a/host/frontend/vnc_server/vnc_client_connection.cpp
+++ b/host/frontend/vnc_server/vnc_client_connection.cpp
@@ -42,17 +42,7 @@
 using cvd::vnc::Stripe;
 using cvd::vnc::StripePtrVec;
 using cvd::vnc::VncClientConnection;
-
-struct ScreenRegionView {
-  using Pixel = uint32_t;
-  static constexpr int kSwiftShaderPadding = 4;
-  static constexpr int kRedShift = 0;
-  static constexpr int kGreenShift = 8;
-  static constexpr int kBlueShift = 16;
-  static constexpr int kRedBits = 8;
-  static constexpr int kGreenBits = 8;
-  static constexpr int kBlueBits = 8;
-};
+using vsoc::screen::ScreenRegionView;
 
 DEFINE_bool(debug_client, false, "Turn on detailed logging for the client");
 
diff --git a/host/frontend/vnc_server/vnc_utils.h b/host/frontend/vnc_server/vnc_utils.h
index db88131..0953c4e 100644
--- a/host/frontend/vnc_server/vnc_utils.h
+++ b/host/frontend/vnc_server/vnc_utils.h
@@ -23,6 +23,7 @@
 
 #include "common/libs/utils/size_utils.h"
 #include "common/libs/tcp_socket/tcp_socket.h"
+#include "common/vsoc/lib/screen_region_view.h"
 #include "host/libs/config/cuttlefish_config.h"
 
 namespace cvd {
@@ -64,7 +65,7 @@
 };
 
 inline constexpr int BytesPerPixel() {
-  return sizeof(uint32_t);
+  return sizeof(vsoc::screen::ScreenRegionView::Pixel);
 }
 
 // The width of the screen regardless of orientation. Does not change.
diff --git a/host/libs/config/cuttlefish_config.cpp b/host/libs/config/cuttlefish_config.cpp
index 6f66fb3..17dcb6e 100644
--- a/host/libs/config/cuttlefish_config.cpp
+++ b/host/libs/config/cuttlefish_config.cpp
@@ -134,6 +134,10 @@
 const char* kVncServerBinary = "vnc_server_binary";
 const char* kVncServerPort = "vnc_server_port";
 
+const char* kEnableStreamAudio = "enable_stream_audio";
+const char* kStreamAudioBinary = "stream_audio_binary";
+const char* kStreamAudioPort = "stream_audio_port";
+
 const char* kRestartSubprocesses = "restart_subprocesses";
 const char* kRunAdbConnector = "run_adb_connector";
 const char* kAdbConnectorBinary = "adb_connector_binary";
@@ -559,7 +563,9 @@
 
 static AdbMode stringToAdbMode(std::string mode) {
   std::transform(mode.begin(), mode.end(), mode.begin(), ::tolower);
-  if (mode == "vsock_tunnel") {
+  if (mode == "tunnel") {
+    return AdbMode::Tunnel;
+  } else if (mode == "vsock_tunnel") {
     return AdbMode::VsockTunnel;
   } else if (mode == "vsock_half_tunnel") {
     return AdbMode::VsockHalfTunnel;
@@ -606,10 +612,11 @@
 
 std::string CuttlefishConfig::adb_device_name() const {
   // TODO(schuffelen): Deal with duplication between here and launch.cc
+  bool tunnelMode = adb_mode().count(AdbMode::Tunnel) > 0;
   bool vsockTunnel = adb_mode().count(AdbMode::VsockTunnel) > 0;
   bool vsockHalfProxy = adb_mode().count(AdbMode::VsockHalfTunnel) > 0;
   bool nativeVsock = adb_mode().count(AdbMode::NativeVsock) > 0;
-  if (vsockTunnel || vsockHalfProxy || nativeVsock) {
+  if (tunnelMode || vsockTunnel || vsockHalfProxy || nativeVsock) {
     return adb_ip_and_port();
   } else if (adb_mode().count(AdbMode::Usb) > 0) {
     return serial_number();
@@ -701,6 +708,31 @@
   (*dictionary_)[kVncServerPort] = vnc_server_port;
 }
 
+bool CuttlefishConfig::enable_stream_audio() const {
+  return (*dictionary_)[kEnableStreamAudio].asBool();
+}
+
+void CuttlefishConfig::set_enable_stream_audio(bool enable_stream_audio) {
+  (*dictionary_)[kEnableStreamAudio] = enable_stream_audio;
+}
+
+std::string CuttlefishConfig::stream_audio_binary() const {
+  return (*dictionary_)[kStreamAudioBinary].asString();
+}
+
+void CuttlefishConfig::set_stream_audio_binary(
+    const std::string& stream_audio_binary) {
+  (*dictionary_)[kStreamAudioBinary] = stream_audio_binary;
+}
+
+int CuttlefishConfig::stream_audio_port() const {
+  return (*dictionary_)[kStreamAudioPort].asInt();
+}
+
+void CuttlefishConfig::set_stream_audio_port(int stream_audio_port) {
+  (*dictionary_)[kStreamAudioPort] = stream_audio_port;
+}
+
 bool CuttlefishConfig::restart_subprocesses() const {
   return (*dictionary_)[kRestartSubprocesses].asBool();
 }
diff --git a/host/libs/config/cuttlefish_config.h b/host/libs/config/cuttlefish_config.h
index 4ec49e7..fc479ec 100644
--- a/host/libs/config/cuttlefish_config.h
+++ b/host/libs/config/cuttlefish_config.h
@@ -39,6 +39,7 @@
 
 
 enum class AdbMode {
+  Tunnel,
   VsockTunnel,
   VsockHalfTunnel,
   NativeVsock,
@@ -275,6 +276,15 @@
   void set_vnc_server_binary(const std::string& vnc_server_binary);
   std::string vnc_server_binary() const;
 
+  void set_enable_stream_audio(bool enable_stream_audio);
+  bool enable_stream_audio() const;
+
+  void set_stream_audio_port(int stream_audio_port);
+  int stream_audio_port() const;
+
+  void set_stream_audio_binary(const std::string& stream_audio_binary);
+  std::string stream_audio_binary() const;
+
   void set_restart_subprocesses(bool restart_subprocesses);
   bool restart_subprocesses() const;
 
diff --git a/host/vsoc/lib/gralloc_buffer_region_view.cpp b/host/vsoc/lib/gralloc_buffer_region_view.cpp
new file mode 100644
index 0000000..db302cb
--- /dev/null
+++ b/host/vsoc/lib/gralloc_buffer_region_view.cpp
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include "host/vsoc/lib/gralloc_buffer_region_view.h"
+
+#include <memory>
+#include <mutex>
+#include "glog/logging.h"
+
+using vsoc::gralloc::GrallocBufferRegionView;
+
+uint8_t* GrallocBufferRegionView::OffsetToBufferPtr(uint32_t offset) {
+  if (offset <= control_->region_desc().offset_of_region_data ||
+      offset >= control_->region_size()) {
+    LOG(FATAL)
+        << "Attempted to access a gralloc buffer outside region data, offset: "
+        << offset;
+    return nullptr;
+  }
+  return region_offset_to_pointer<uint8_t>(offset);
+}
diff --git a/host/vsoc/lib/gralloc_buffer_region_view.h b/host/vsoc/lib/gralloc_buffer_region_view.h
new file mode 100644
index 0000000..b132a0e
--- /dev/null
+++ b/host/vsoc/lib/gralloc_buffer_region_view.h
@@ -0,0 +1,47 @@
+#pragma once
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include "common/vsoc/lib/typed_region_view.h"
+#include "common/vsoc/shm/gralloc_layout.h"
+
+#include <string>
+
+namespace vsoc {
+namespace gralloc {
+
+// Allows access to the gralloc buffer region from host side. It needs to be a
+// different class than the one on guest side because of the required
+// interactions with the kernel on the guest.
+// Initially this class only returns a pointer to a buffer in memory given a
+// region offset, which is enough for now since it's only used by the hwcomposer
+// (which gets all other information from the guest side hwcomposer) and by the
+// VNC server (which uses only the frame buffer and gets the information it
+// needs from the framebuffer region).
+class GrallocBufferRegionView
+    : vsoc::TypedRegionView<
+        GrallocBufferRegionView,
+        vsoc::layout::gralloc::GrallocBufferLayout> {
+   public:
+  GrallocBufferRegionView() = default;
+  GrallocBufferRegionView(const GrallocBufferRegionView&) = delete;
+  GrallocBufferRegionView& operator=(const GrallocBufferRegionView&) = delete;
+
+  uint8_t* OffsetToBufferPtr(uint32_t offset);
+};
+
+}  // namespace gralloc
+}  // namespace vsoc
diff --git a/host/vsoc/lib/host_lock.cpp b/host/vsoc/lib/host_lock.cpp
new file mode 100644
index 0000000..895a429
--- /dev/null
+++ b/host/vsoc/lib/host_lock.cpp
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+#include "common/vsoc/shm/lock.h"
+
+#include "sys/types.h"
+
+#include "common/vsoc/lib/compat.h"
+#include "common/vsoc/lib/single_sided_signal.h"
+
+namespace vsoc {
+namespace layout {
+
+void HostLock::Lock() {
+  uint32_t tid = gettid();
+  uint32_t expected_value;
+  uint32_t* uaddr = reinterpret_cast<uint32_t*>(&lock_uint32_);
+
+  while (1) {
+    if (TryLock(tid, &expected_value)) {
+      return;
+    }
+    SingleSidedSignal::AwaitSignal(expected_value, uaddr);
+  }
+}
+
+void HostLock::Unlock() {
+  Sides sides_to_signal = UnlockCommon(gettid());
+  if (sides_to_signal != Sides::NoSides) {
+    SingleSidedSignal::Signal(&lock_uint32_);
+  }
+}
+
+bool HostLock::Recover() {
+  return RecoverSingleSided();
+}
+
+}  // namespace layout
+}  // namespace vsoc
diff --git a/host/vsoc/lib/host_region_e2e_test.cpp b/host/vsoc/lib/host_region_e2e_test.cpp
new file mode 100644
index 0000000..1366838
--- /dev/null
+++ b/host/vsoc/lib/host_region_e2e_test.cpp
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+
+/*
+ * End-to-end test to ensure that mapping of vsoc regions works on the host.
+ */
+
+#include <gtest/gtest.h>
+#include "common/vsoc/lib/e2e_test_region_view.h"
+#include "host/libs/config/cuttlefish_config.h"
+
+// Here is a summary of the two regions interrupt and write test:
+// 1. Write our strings to the first region
+// 2. Ensure that our peer hasn't signalled the second region. That would
+//    indicate that it didn't wait for our interrupt.
+// 3. Send the interrupt on the first region
+// 4. Wait for our peer's interrupt on the first region
+// 5. Confirm that we can see our peer's writes in the first region
+// 6. Initialize our strings in the second region
+// 7. Send an interrupt on the second region to our peer
+// 8. Wait for our peer's interrupt on the second region
+// 9. Confirm that we can see our peer's writes in the second region
+// 10. Repeat the process for signaling.
+// 11. Confirm that no interrupt is pending in the first region
+// 12. Confirm that no interrupt is pending in the second region
+
+template <typename View>
+void SetHostStrings(View* in) {
+  size_t num_data = in->string_size();
+  EXPECT_LE(static_cast<size_t>(2), num_data);
+  for (size_t i = 0; i < num_data; ++i) {
+    EXPECT_TRUE(!in->host_string(i)[0] ||
+                !strcmp(in->host_string(i), View::Layout::host_pattern));
+    in->set_host_string(i, View::Layout::host_pattern);
+    EXPECT_STREQ(in->host_string(i), View::Layout::host_pattern);
+  }
+}
+
+template <typename View>
+void CheckPeerStrings(View* in) {
+  size_t num_data = in->string_size();
+  EXPECT_LE(static_cast<size_t>(2), num_data);
+  for (size_t i = 0; i < num_data; ++i) {
+    EXPECT_STREQ(View::Layout::guest_pattern, in->guest_string(i));
+  }
+}
+
+TEST(RegionTest, PeerTests) {
+  auto primary =
+      vsoc::E2EPrimaryRegionView::GetInstance(vsoc::GetDomain().c_str());
+  ASSERT_TRUE(!!primary);
+  auto secondary =
+      vsoc::E2ESecondaryRegionView::GetInstance(vsoc::GetDomain().c_str());
+  ASSERT_TRUE(!!secondary);
+  LOG(INFO) << "Regions are open";
+  SetHostStrings(primary);
+  EXPECT_FALSE(secondary->HasIncomingInterrupt());
+  EXPECT_TRUE(primary->MaybeInterruptPeer());
+  LOG(INFO) << "Waiting for first interrupt from peer";
+  primary->WaitForInterrupt();
+  LOG(INFO) << "First interrupt received";
+  CheckPeerStrings(primary);
+  SetHostStrings(secondary);
+  EXPECT_TRUE(secondary->MaybeInterruptPeer());
+  LOG(INFO) << "Waiting for second interrupt from peer";
+  secondary->WaitForInterrupt();
+  LOG(INFO) << "Second interrupt received";
+  CheckPeerStrings(secondary);
+
+  // Test signals
+  EXPECT_FALSE(secondary->HasIncomingInterrupt());
+  LOG(INFO) << "Verified no early second signal";
+  primary->SendSignal(vsoc::layout::Sides::Peer,
+                      &primary->data()->host_to_guest_signal);
+  LOG(INFO) << "Signal sent. Waiting for first signal from peer";
+  primary->WaitForInterrupt();
+  int count = 0;  // counts the number of signals received.
+  primary->ProcessSignalsFromPeer(
+      [&primary, &count](uint32_t offset) {
+        ++count;
+        EXPECT_EQ(primary->guest_to_host_signal_offset(), offset);
+      });
+  EXPECT_EQ(1, count);
+  LOG(INFO) << "Signal received on primary region";
+  secondary->SendSignal(vsoc::layout::Sides::Peer,
+                        &secondary->data()->host_to_guest_signal);
+  LOG(INFO) << "Signal sent. Waiting for second signal from peer";
+  secondary->WaitForInterrupt();
+  count = 0;
+  secondary->ProcessSignalsFromPeer(
+      [secondary, &count](uint32_t offset) {
+        ++count;
+        EXPECT_EQ(secondary->guest_to_host_signal_offset(), offset);
+      });
+  EXPECT_EQ(1, count);
+  LOG(INFO) << "Signal received on secondary region";
+
+  EXPECT_FALSE(primary->HasIncomingInterrupt());
+  EXPECT_FALSE(secondary->HasIncomingInterrupt());
+}
+
+TEST(RegionTest, MissingRegionCausesDeath) {
+  EXPECT_DEATH(
+      vsoc::E2EUnfindableRegionView::GetInstance(vsoc::GetDomain().c_str()),
+      ".*");
+}
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  int rval = RUN_ALL_TESTS();
+  if (!rval) {
+    auto region =
+        vsoc::E2EPrimaryRegionView::GetInstance(vsoc::GetDomain().c_str());
+    region->host_status(vsoc::layout::e2e_test::E2E_MEMORY_FILLED);
+  }
+  return rval;
+}
diff --git a/host/vsoc/lib/region_control.cpp b/host/vsoc/lib/region_control.cpp
new file mode 100644
index 0000000..491f600
--- /dev/null
+++ b/host/vsoc/lib/region_control.cpp
@@ -0,0 +1,260 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+#include "common/vsoc/lib/region_view.h"
+
+#define LOG_TAG "vsoc: region_host"
+
+#include <stdio.h>
+#include <string.h>
+#include <linux/futex.h>
+#include <sys/mman.h>
+#include <sys/socket.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <iomanip>
+#include <sstream>
+#include <thread>
+#include <vector>
+
+#include <glog/logging.h>
+
+#include "common/libs/fs/shared_fd.h"
+#include "common/libs/fs/shared_select.h"
+
+using cvd::SharedFD;
+
+namespace {
+
+class HostRegionControl : public vsoc::RegionControl {
+ public:
+  HostRegionControl(const char* region_name,
+                    const SharedFD& incoming_interrupt_fd,
+                    const SharedFD& outgoing_interrupt_fd,
+                    const SharedFD& shared_memory_fd)
+      : region_name_{region_name},
+        incoming_interrupt_fd_{incoming_interrupt_fd},
+        outgoing_interrupt_fd_{outgoing_interrupt_fd},
+        shared_memory_fd_{shared_memory_fd} {}
+
+  int CreateFdScopedPermission(const char* /*managed_region_name*/,
+                               uint32_t /*owner_offset*/,
+                               uint32_t /*owned_val*/,
+                               uint32_t /*begin_offset*/,
+                               uint32_t /*end_offset*/) override {
+    return -1;
+  }
+
+  bool InitializeRegion();
+
+  virtual bool InterruptPeer() override {
+    uint64_t one = 1;
+    ssize_t rval = outgoing_interrupt_fd_->Write(&one, sizeof(one));
+    if (rval != sizeof(one)) {
+      LOG(FATAL) << __FUNCTION__ << ": rval (" << rval << ") != sizeof(one))";
+      return false;
+    }
+    return true;
+  }
+
+  // Wake the local signal table scanner. Primarily used during shutdown
+  virtual void InterruptSelf() override {
+    uint64_t one = 1;
+    ssize_t rval = incoming_interrupt_fd_->Write(&one, sizeof(one));
+    if (rval != sizeof(one)) {
+      LOG(FATAL) << __FUNCTION__ << ": rval (" << rval << ") != sizeof(one))";
+    }
+  }
+
+  virtual void WaitForInterrupt() override {
+    // Check then act isn't a problem here: the other side does
+    // the following things in exactly this order:
+    //   1. exchanges 1 with interrupt_signalled
+    //   2. if interrupt_signalled was 0 it increments the eventfd
+    // eventfd increments are persistent, so if interrupt_signalled was set
+    // back to 1 while we are going to sleep the sleep will return
+    // immediately.
+    uint64_t missed{};
+    cvd::SharedFDSet readset;
+    readset.Set(incoming_interrupt_fd_);
+    cvd::Select(&readset, NULL, NULL, NULL);
+    ssize_t rval = incoming_interrupt_fd_->Read(&missed, sizeof(missed));
+    if (rval != sizeof(missed)) {
+      LOG(FATAL) << __FUNCTION__ << ": rval (" << rval
+                 << ") != sizeof(missed)), are there more than one threads "
+                    "waiting for interrupts?";
+    }
+    if (!missed) {
+      LOG(FATAL) << __FUNCTION__ << ": woke with 0 interrupts";
+    }
+  }
+
+  virtual void* Map() override {
+    if (region_base_) {
+      return region_base_;
+    }
+    // Now actually map the region
+    region_base_ =
+        shared_memory_fd_->Mmap(0, region_size(), PROT_READ | PROT_WRITE,
+                                MAP_SHARED, region_desc_.region_begin_offset);
+    if (region_base_ == MAP_FAILED) {
+      LOG(FATAL) << "mmap failed for offset "
+                 << region_desc_.region_begin_offset << " ("
+                 << shared_memory_fd_->StrError() << ")";
+      region_base_ = nullptr;
+    }
+    return region_base_;
+  }
+
+
+  virtual int SignalSelf(uint32_t offset) override {
+    return syscall(SYS_futex, region_offset_to_pointer<int32_t*>(offset),
+                   FUTEX_WAKE, -1, nullptr, nullptr, 0);
+  }
+
+  virtual int WaitForSignal(uint32_t offset, uint32_t expected_value) override {
+    return syscall(SYS_futex, region_offset_to_pointer<int32_t*>(offset),
+                   FUTEX_WAIT, expected_value, nullptr, nullptr, 0);
+  }
+
+ protected:
+  const char* region_name_{};
+  cvd::SharedFD incoming_interrupt_fd_;
+  cvd::SharedFD outgoing_interrupt_fd_;
+  cvd::SharedFD shared_memory_fd_;
+};
+
+// Default path to the ivshmem_server socket. This can vary when we're
+// launching multiple CVDs.
+constexpr int kMaxSupportedProtocolVersion = 0;
+
+bool HostRegionControl::InitializeRegion() {
+  size_t region_name_len = strlen(region_name_);
+  if (region_name_len >= VSOC_DEVICE_NAME_SZ) {
+    LOG(FATAL) << "Region name length (" << region_name_len << ") not < "
+               << VSOC_DEVICE_NAME_SZ;
+    return false;
+  }
+  vsoc_shm_layout_descriptor layout;
+  ssize_t rval = shared_memory_fd_->Pread(&layout, sizeof(layout), 0);
+  if (rval != sizeof(layout)) {
+    LOG(FATAL) << "Unable to read layout, rval=" << rval << " ("
+               << shared_memory_fd_->StrError() << ")";
+    return false;
+  }
+  if (layout.major_version != CURRENT_VSOC_LAYOUT_MAJOR_VERSION) {
+    LOG(FATAL) << "Incompatible major version: saw " << layout.major_version
+               << " wanted " << CURRENT_VSOC_LAYOUT_MAJOR_VERSION;
+  }
+  std::vector<vsoc_device_region> descriptors;
+  descriptors.resize(layout.region_count);
+  ssize_t wanted = sizeof(vsoc_device_region) * layout.region_count;
+  rval = shared_memory_fd_->Pread(descriptors.data(), wanted,
+                                  layout.vsoc_region_desc_offset);
+  if (rval != wanted) {
+    LOG(FATAL) << "Unable to read region descriptors, rval=" << rval << " ("
+               << shared_memory_fd_->StrError() << ")";
+    return false;
+  }
+  for (const auto& desc : descriptors) {
+    if (!strcmp(region_name_, desc.device_name)) {
+      region_desc_ = desc;
+      return true;
+    }
+  }
+
+  std::ostringstream buf;
+  for (const auto& desc : descriptors) {
+    buf << " " << desc.device_name;
+  }
+  LOG(FATAL) << "Region name of " << region_name_
+             << " not found among:" << buf.str();
+  return false;
+}
+}  // namespace
+
+std::shared_ptr<vsoc::RegionControl> vsoc::RegionControl::Open(
+    const char* region_name, const char* domain) {
+  AutoFreeBuffer msg;
+
+  SharedFD region_server =
+      SharedFD::SocketLocalClient(domain, false, SOCK_STREAM);
+  if (!region_server->IsOpen()) {
+    LOG(FATAL) << "Could not contact ivshmem_server ("
+               << region_server->StrError() << ")";
+    return nullptr;
+  }
+
+  // Check server protocol version.
+  uint32_t protocol_version;
+  ssize_t bytes = region_server->Recv(&protocol_version,
+                                      sizeof(protocol_version), MSG_NOSIGNAL);
+  if (bytes != sizeof(protocol_version)) {
+    LOG(FATAL) << "Failed to recv protocol version; res=" << bytes << " ("
+               << region_server->StrError() << ")";
+    return nullptr;
+  }
+
+  if (protocol_version > kMaxSupportedProtocolVersion) {
+    LOG(FATAL) << "Unsupported protocol version " << protocol_version
+               << "; max supported version is " << kMaxSupportedProtocolVersion;
+    return nullptr;
+  }
+
+  // Send requested region.
+  int16_t size = strlen(region_name);
+  bytes = region_server->Send(&size, sizeof(size), MSG_NOSIGNAL);
+  if (bytes != sizeof(size)) {
+    LOG(FATAL) << "Failed to send region name length; res=" << bytes << " ("
+               << region_server->StrError() << ")";
+    return nullptr;
+  }
+
+  bytes = region_server->Send(region_name, size, MSG_NOSIGNAL);
+  if (bytes != size) {
+    LOG(FATAL) << "Failed to send region name; res=" << bytes << " ("
+               << region_server->StrError() << ")";
+    return nullptr;
+  }
+
+  // Receive control sockets.
+  uint64_t control_data;
+  struct iovec iov {
+    &control_data, sizeof(control_data)
+  };
+  cvd::InbandMessageHeader hdr{};
+  hdr.msg_iov = &iov;
+  hdr.msg_iovlen = 1;
+  SharedFD fds[3];
+  bytes = region_server->RecvMsgAndFDs(hdr, 0, &fds);
+  if (bytes != sizeof(control_data)) {
+    LOG(FATAL) << "Failed to complete handshake; res=" << bytes << " ("
+               << region_server->StrError() << ")";
+    return nullptr;
+  }
+  HostRegionControl* rval =
+      new HostRegionControl(region_name, fds[0], fds[1], fds[2]);
+  if (!rval) {
+    return nullptr;
+  }
+  // Search for the region header
+  if (!rval->InitializeRegion()) {
+    // We already logged, so we can just bail out.
+    return nullptr;
+  }
+  return std::shared_ptr<RegionControl>(rval);
+}
diff --git a/host/vsoc/lib/region_view.cpp b/host/vsoc/lib/region_view.cpp
new file mode 100644
index 0000000..975b7cd
--- /dev/null
+++ b/host/vsoc/lib/region_view.cpp
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * 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.
+ */
+#include "common/vsoc/lib/region_view.h"
+#include "common/vsoc/lib/region_control.h"
+
+const vsoc_signal_table_layout& vsoc::RegionView::incoming_signal_table() {
+  return control_->region_desc().guest_to_host_signal_table;
+}
+
+// Returns a pointer to the table that will be used to post signals
+const vsoc_signal_table_layout& vsoc::RegionView::outgoing_signal_table() {
+  return control_->region_desc().host_to_guest_signal_table;
+}