diff --git a/Android.bp b/Android.bp
index ea670fa..5fe6ad5 100644
--- a/Android.bp
+++ b/Android.bp
@@ -13,8 +13,9 @@
 // limitations under the License.
 
 subdirs = [
-    "base",         // libhidlbase
-    "transport",    // libhidl
+    "base",           // libhidlbase
+    "libhidlmemory",  // libhidlmemory
+    "transport",      // libhidltransport
 ]
 
 cc_test {
diff --git a/base/HidlSupport.cpp b/base/HidlSupport.cpp
index 35e1672..0103d14 100644
--- a/base/HidlSupport.cpp
+++ b/base/HidlSupport.cpp
@@ -13,10 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#define LOG_TAG "HidlSupport"
 
 #include <hidl/HidlSupport.h>
 
 #include <android-base/logging.h>
+
 #ifdef LIBHIDL_TARGET_DEBUGGABLE
 #include <cutils/properties.h>
 #include <regex>
diff --git a/base/include/hidl/HidlSupport.h b/base/include/hidl/HidlSupport.h
index 6a1f4e5..f9f7f32 100644
--- a/base/include/hidl/HidlSupport.h
+++ b/base/include/hidl/HidlSupport.h
@@ -34,6 +34,16 @@
 #include <vector>
 
 namespace android {
+
+// this file is included by all hidl interface, so we must forward declare the IMemory type.
+namespace hidl {
+namespace memory {
+namespace V1_0 {
+    struct IMemory;
+}; // namespace V1_0
+}; // namespace manager
+}; // namespace hidl
+
 namespace hardware {
 
 // hidl_handle wraps a pointer to a native_handle_t in a hidl_pointer,
@@ -169,6 +179,75 @@
     return !(s == hs);
 }
 
+// hidl_memory is a structure that can be used to transfer
+// pieces of shared memory between processes. The assumption
+// of this object is that the memory remains accessible as
+// long as the file descriptors in the enclosed mHandle
+// - as well as all of its cross-process dups() - remain opened.
+struct hidl_memory {
+
+    hidl_memory() : mOwnsHandle(false), mHandle(nullptr), mSize(0), mName("") {
+    }
+
+    /**
+     * Creates a hidl_memory object and takes ownership of the handle.
+     */
+    hidl_memory(const hidl_string &name, const hidl_handle &handle, size_t size)
+       : mOwnsHandle(true),
+         mHandle(handle),
+         mSize(size),
+         mName(name)
+    {}
+
+    // copy constructor
+    hidl_memory(const hidl_memory& other) {
+        *this = other;
+    }
+
+    // copy assignment
+    hidl_memory &operator=(const hidl_memory &other) {
+        if (this != &other) {
+            mOwnsHandle = true;
+            mHandle = native_handle_clone(other.mHandle);
+            mSize = other.mSize;
+            mName = other.mName;
+        }
+
+        return *this;
+    }
+
+    // TODO move constructor/move assignment
+
+    ~hidl_memory() {
+        // TODO if we had previously mapped from this object, unmap
+        if (mOwnsHandle) {
+            native_handle_close(mHandle);
+        }
+    }
+
+    const native_handle_t* handle() const {
+        return mHandle;
+    }
+
+    const hidl_string &name() const {
+        return mName;
+    }
+
+    size_t size() const {
+        return mSize;
+    }
+
+    // offsetof(hidl_memory, mHandle) exposed since mHandle is private.
+    static const size_t kOffsetOfHandle;
+    // offsetof(hidl_memory, mName) exposed since mHandle is private.
+    static const size_t kOffsetOfName;
+private:
+    bool mOwnsHandle;
+    hidl_handle mHandle;
+    size_t mSize;
+    hidl_string mName;
+};
+
 ////////////////////////////////////////////////////////////////////////////////
 
 template<typename T>
diff --git a/libhidlmemory/Android.bp b/libhidlmemory/Android.bp
new file mode 100644
index 0000000..8f27065
--- /dev/null
+++ b/libhidlmemory/Android.bp
@@ -0,0 +1,43 @@
+// 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.
+
+cc_library_shared {
+    name: "libhidlmemory",
+    shared_libs: [
+        "libbase",
+        "liblog",
+        "libutils",
+        "libcutils",
+        "libhidlbase",
+        "libhidltransport",
+        "android.hidl.memory@1.0"
+    ],
+    local_include_dirs: ["include"],
+    export_include_dirs: ["include"],
+
+    export_shared_lib_headers: [
+        "android.hidl.memory@1.0",
+        "libhidlbase"
+    ],
+
+    srcs: [
+        "mapping.cpp"
+    ],
+
+    product_variables: {
+        debuggable: {
+            cflags: ["-DLIBHIDL_TARGET_DEBUGGABLE"],
+        },
+    },
+}
diff --git a/libhidlmemory/include/hidlmemory/mapping.h b/libhidlmemory/include/hidlmemory/mapping.h
new file mode 100644
index 0000000..8ed0d54
--- /dev/null
+++ b/libhidlmemory/include/hidlmemory/mapping.h
@@ -0,0 +1,25 @@
+/*
+ * 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 <android/hidl/memory/1.0/IMemory.h>
+#include <hidl/HidlSupport.h>
+
+namespace android {
+namespace hardware {
+
+sp<android::hidl::memory::V1_0::IMemory> mapMemory(const hidl_memory &memory);
+
+}  // namespace hardware
+}  // namespace android
\ No newline at end of file
diff --git a/libhidlmemory/mapping.cpp b/libhidlmemory/mapping.cpp
new file mode 100644
index 0000000..b4fa123
--- /dev/null
+++ b/libhidlmemory/mapping.cpp
@@ -0,0 +1,58 @@
+/*
+ * 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 "libhidlmemory"
+
+#include <hidlmemory/mapping.h>
+
+#include <android-base/logging.h>
+#include <android/hidl/memory/1.0/IMapper.h>
+#include <hidl/HidlSupport.h>
+
+using android::sp;
+using android::hidl::memory::V1_0::IMemory;
+
+namespace android {
+namespace hardware {
+
+sp<IMemory> mapMemory(const hidl_memory &memory) {
+    using android::hidl::memory::V1_0::IMapper;
+
+    sp<IMapper> mapper = IMapper::getService(memory.name(), true /* getStub */);
+
+    if (mapper == nullptr) {
+        LOG(FATAL) << "Could not fetch mapper for " << memory.name() << " shared memory";
+    }
+
+    if (mapper->isRemote()) {
+        LOG(FATAL) << "IMapper must be a passthrough service.";
+    }
+
+    sp<IMemory> retMemory = nullptr;
+
+    Return<void> ret = mapper->mapMemory(memory,
+        [&retMemory](const auto &mapped) {
+            retMemory = mapped;
+        });
+
+    if (!ret.isOk()) {
+        LOG(FATAL) << "hidl_memory map returned transport error.";
+    }
+
+    return retMemory;
+}
+
+}  // namespace hardware
+}  // namespace android
\ No newline at end of file
diff --git a/transport/Android.bp b/transport/Android.bp
index 032381a..ac4cb12 100644
--- a/transport/Android.bp
+++ b/transport/Android.bp
@@ -13,7 +13,9 @@
 // limitations under the License.
 
 subdirs = [
-    "manager/1.0"
+    "manager/1.0",
+    "memory/1.0",
+    "memory/1.0/default",
 ]
 
 cc_library_shared {
diff --git a/transport/HidlBinderSupport.cpp b/transport/HidlBinderSupport.cpp
index c206018..f3e99e1 100644
--- a/transport/HidlBinderSupport.cpp
+++ b/transport/HidlBinderSupport.cpp
@@ -27,6 +27,47 @@
 
 std::map<std::string, std::function<sp<IBinder>(void*)>> gBnConstructorMap{};
 
+const size_t hidl_memory::kOffsetOfHandle = offsetof(hidl_memory, mHandle);
+const size_t hidl_memory::kOffsetOfName = offsetof(hidl_memory, mName);
+
+status_t readEmbeddedFromParcel(hidl_memory * /* memory */,
+        const Parcel &parcel, size_t parentHandle, size_t parentOffset) {
+    ::android::status_t _hidl_err = ::android::OK;
+    const native_handle_t *_hidl_memory_handle = parcel.readEmbeddedNativeHandle(
+            parentHandle,
+            parentOffset + hidl_memory::kOffsetOfHandle);
+
+    if (_hidl_memory_handle == nullptr) {
+        _hidl_err = ::android::UNKNOWN_ERROR;
+        return _hidl_err;
+    }
+
+    _hidl_err = readEmbeddedFromParcel(
+            (hidl_string*) nullptr,
+            parcel,
+            parentHandle,
+            parentOffset + hidl_memory::kOffsetOfName);
+
+    return _hidl_err;
+}
+
+status_t writeEmbeddedToParcel(const hidl_memory &memory,
+        Parcel *parcel, size_t parentHandle, size_t parentOffset) {
+    status_t _hidl_err = parcel->writeEmbeddedNativeHandle(
+            memory.handle(),
+            parentHandle,
+            parentOffset + hidl_memory::kOffsetOfHandle);
+
+    if (_hidl_err == ::android::OK) {
+        _hidl_err = writeEmbeddedToParcel(
+            memory.name(),
+            parcel,
+            parentHandle,
+            parentOffset + hidl_memory::kOffsetOfName);
+    }
+
+    return _hidl_err;
+}
 // static
 const size_t hidl_string::kOffsetOfBuffer = offsetof(hidl_string, mBuffer);
 
diff --git a/transport/include/hidl/HidlBinderSupport.h b/transport/include/hidl/HidlBinderSupport.h
index 84ba966..d6a308b 100644
--- a/transport/include/hidl/HidlBinderSupport.h
+++ b/transport/include/hidl/HidlBinderSupport.h
@@ -28,6 +28,14 @@
 namespace android {
 namespace hardware {
 
+// ---------------------- hidl_memory
+
+status_t readEmbeddedFromParcel(hidl_memory *memory,
+        const Parcel &parcel, size_t parentHandle, size_t parentOffset);
+
+status_t writeEmbeddedToParcel(const hidl_memory &memory,
+        Parcel *parcel, size_t parentHandle, size_t parentOffset);
+
 // ---------------------- hidl_string
 
 status_t readEmbeddedFromParcel(hidl_string *string,
diff --git a/transport/manager/1.0/update-makefiles.sh b/transport/manager/1.0/update-makefiles.sh
deleted file mode 100755
index 850ca7b..0000000
--- a/transport/manager/1.0/update-makefiles.sh
+++ /dev/null
@@ -1,9 +0,0 @@
-#!/bin/bash
-
-if [ ! -d system/libhidl ] ; then
-  echo "Where is system/libhidl?";
-  exit 1;
-fi
-
-hidl-gen -Lmakefile -r android.hidl:system/libhidl/transport android.hidl.manager@1.0
-hidl-gen -Landroidbp -r android.hidl:system/libhidl/transport android.hidl.manager@1.0
diff --git a/transport/memory/1.0/Android.bp b/transport/memory/1.0/Android.bp
new file mode 100644
index 0000000..5839197
--- /dev/null
+++ b/transport/memory/1.0/Android.bp
@@ -0,0 +1,66 @@
+// This file is autogenerated by hidl-gen. Do not edit manually.
+
+genrule {
+    name: "android.hidl.memory@1.0_genc++",
+    tools: ["hidl-gen"],
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hidl:system/libhidl/transport android.hidl.memory@1.0",
+    srcs: [
+        "IAllocator.hal",
+        "IMapper.hal",
+        "IMemory.hal",
+    ],
+    out: [
+        "android/hidl/memory/1.0/AllocatorAll.cpp",
+        "android/hidl/memory/1.0/MapperAll.cpp",
+        "android/hidl/memory/1.0/MemoryAll.cpp",
+    ],
+}
+
+genrule {
+    name: "android.hidl.memory@1.0_genc++_headers",
+    tools: ["hidl-gen"],
+    cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hidl:system/libhidl/transport android.hidl.memory@1.0",
+    srcs: [
+        "IAllocator.hal",
+        "IMapper.hal",
+        "IMemory.hal",
+    ],
+    out: [
+        "android/hidl/memory/1.0/IAllocator.h",
+        "android/hidl/memory/1.0/IHwAllocator.h",
+        "android/hidl/memory/1.0/BnAllocator.h",
+        "android/hidl/memory/1.0/BpAllocator.h",
+        "android/hidl/memory/1.0/BsAllocator.h",
+        "android/hidl/memory/1.0/IMapper.h",
+        "android/hidl/memory/1.0/IHwMapper.h",
+        "android/hidl/memory/1.0/BnMapper.h",
+        "android/hidl/memory/1.0/BpMapper.h",
+        "android/hidl/memory/1.0/BsMapper.h",
+        "android/hidl/memory/1.0/IMemory.h",
+        "android/hidl/memory/1.0/IHwMemory.h",
+        "android/hidl/memory/1.0/BnMemory.h",
+        "android/hidl/memory/1.0/BpMemory.h",
+        "android/hidl/memory/1.0/BsMemory.h",
+    ],
+}
+
+cc_library_shared {
+    name: "android.hidl.memory@1.0",
+    generated_sources: ["android.hidl.memory@1.0_genc++"],
+    generated_headers: ["android.hidl.memory@1.0_genc++_headers"],
+    export_generated_headers: ["android.hidl.memory@1.0_genc++_headers"],
+    shared_libs: [
+        "libhidlbase",
+        "libhidltransport",
+        "libhwbinder",
+        "liblog",
+        "libutils",
+        "libcutils",
+    ],
+    export_shared_lib_headers: [
+        "libhidlbase",
+        "libhidltransport",
+        "libhwbinder",
+        "libutils",
+    ],
+}
diff --git a/transport/memory/1.0/IAllocator.hal b/transport/memory/1.0/IAllocator.hal
new file mode 100644
index 0000000..7f540aa
--- /dev/null
+++ b/transport/memory/1.0/IAllocator.hal
@@ -0,0 +1,32 @@
+/*
+ * 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.
+ */
+
+package android.hidl.memory@1.0;
+
+/**
+ * Interface which allocates the required memory.
+ */
+interface IAllocator {
+
+    /**
+     * Return memory must have instance name corresponding to this type of memory.
+     *
+     * @param size Size of memory to allocate in bytes.
+     * @return success Whether allocation succeeded.
+     * @return memory Unmapped memory object.
+     */
+    allocate(uint64_t size) generates (bool success, memory mem);
+};
\ No newline at end of file
diff --git a/transport/memory/1.0/IMapper.hal b/transport/memory/1.0/IMapper.hal
new file mode 100644
index 0000000..6f730a0
--- /dev/null
+++ b/transport/memory/1.0/IMapper.hal
@@ -0,0 +1,29 @@
+/*
+ * 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.
+ */
+
+package android.hidl.memory@1.0;
+
+import IMemory;
+
+interface IMapper {
+
+    /**
+     * @param mem Reference to shared memory.
+     * @return mappedMemory Object representing memory mapped in this process.
+     *                      This will be null if mapping fails.
+     */
+    mapMemory(memory mem) generates (IMemory mappedMemory);
+};
diff --git a/transport/memory/1.0/IMemory.hal b/transport/memory/1.0/IMemory.hal
new file mode 100644
index 0000000..1b38336
--- /dev/null
+++ b/transport/memory/1.0/IMemory.hal
@@ -0,0 +1,41 @@
+/*
+ * 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.
+ */
+
+package android.hidl.memory@1.0;
+
+interface IMemory {
+
+    /**
+     * Notify that you are about to use this memory.
+     */
+    update();
+
+    /**
+     * Notify that you are done modifying this memory.
+     */
+    commit();
+
+    /**
+     * @return ptr Actual pointer to underlying memory.
+     */
+    getPointer() generates (pointer ptr);
+
+    /**
+     * @return size Size in bytes of underlying memory.
+     */
+    getSize() generates (uint64_t size);
+
+};
\ No newline at end of file
diff --git a/transport/memory/1.0/default/Android.bp b/transport/memory/1.0/default/Android.bp
new file mode 100644
index 0000000..b5079e8
--- /dev/null
+++ b/transport/memory/1.0/default/Android.bp
@@ -0,0 +1,57 @@
+// 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.
+
+cc_library_shared {
+    name: "android.hidl.memory@1.0-impl",
+    relative_install_path: "hw",
+    srcs: [
+        "AshmemAllocator.cpp",
+        "AshmemMapper.cpp",
+        "AshmemMemory.cpp",
+        "HidlFetch.cpp"
+    ],
+    shared_libs: [
+        "liblog",
+        "libcutils",
+        "libhardware",
+        "libhwbinder",
+        "libbase",
+        "libcutils",
+        "libutils",
+        "libhidlbase",
+        "libhidltransport",
+        "android.hidl.memory@1.0",
+    ],
+}
+
+cc_binary {
+    name: "android.hidl.memory@1.0-service",
+    relative_install_path: "hw",
+    srcs: ["service.cpp"],
+    init_rc: ["android.hidl.memory@1.0-service.rc"],
+
+    shared_libs: [
+        "android.hidl.memory@1.0",
+        "libhidlbase",
+        "libhidltransport",
+        "libhwbinder",
+        "liblog",
+        "libutils",
+    ],
+
+    required: [
+        // only one implementation is allowed
+        "android.hidl.memory@1.0-impl"
+    ]
+}
diff --git a/transport/memory/1.0/default/AshmemAllocator.cpp b/transport/memory/1.0/default/AshmemAllocator.cpp
new file mode 100644
index 0000000..59ae3e1
--- /dev/null
+++ b/transport/memory/1.0/default/AshmemAllocator.cpp
@@ -0,0 +1,47 @@
+/*
+ * 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 "AshmemAllocator.h"
+
+#include <cutils/ashmem.h>
+
+namespace android {
+namespace hidl {
+namespace memory {
+namespace V1_0 {
+namespace implementation {
+
+// Methods from ::android::hidl::memory::V1_0::IAllocator follow.
+Return<void> AshmemAllocator::allocate(uint64_t size, allocate_cb _hidl_cb) {
+    int fd = ashmem_create_region("AshmemAllocator_hidl", size);
+    if (fd < 0) {
+        _hidl_cb(false /* success */, hidl_memory());
+        return Void();
+    }
+
+    native_handle_t* handle = native_handle_create(1, 0);
+    handle->data[0] = fd;
+    hidl_memory memory("ashmem", handle, size);
+
+    _hidl_cb(true /* success */, memory);
+    return Void();
+}
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace memory
+}  // namespace hidl
+}  // namespace android
diff --git a/transport/memory/1.0/default/AshmemAllocator.h b/transport/memory/1.0/default/AshmemAllocator.h
new file mode 100644
index 0000000..35ad420
--- /dev/null
+++ b/transport/memory/1.0/default/AshmemAllocator.h
@@ -0,0 +1,51 @@
+/*
+ * 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.
+ */
+
+#ifndef ANDROID_HIDL_ASHMEM_MEMORY_V1_0_ALLOCATOR_H
+#define ANDROID_HIDL_ASHMEM_MEMORY_V1_0_ALLOCATOR_H
+
+#include <android/hidl/memory/1.0/IAllocator.h>
+#include <hidl/MQDescriptor.h>
+#include <hidl/Status.h>
+
+namespace android {
+namespace hidl {
+namespace memory {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hidl::memory::V1_0::IAllocator;
+using ::android::hardware::hidl_array;
+using ::android::hardware::hidl_memory;
+using ::android::hardware::hidl_string;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::sp;
+
+struct AshmemAllocator : public IAllocator {
+    // Methods from ::android::hidl::memory::V1_0::IAllocator follow.
+    Return<void> allocate(uint64_t size, allocate_cb _hidl_cb) override;
+
+};
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace memory
+}  // namespace hidl
+}  // namespace android
+
+#endif  // ANDROID_HIDL_ASHMEM_MEMORY_V1_0_ALLOCATOR_H
diff --git a/transport/memory/1.0/default/AshmemMapper.cpp b/transport/memory/1.0/default/AshmemMapper.cpp
new file mode 100644
index 0000000..37eb8af
--- /dev/null
+++ b/transport/memory/1.0/default/AshmemMapper.cpp
@@ -0,0 +1,55 @@
+/*
+ * 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 "AshmemMapper.h"
+
+#include <sys/mman.h>
+
+#include "AshmemMemory.h"
+
+namespace android {
+namespace hidl {
+namespace memory {
+namespace V1_0 {
+namespace implementation {
+
+// Methods from ::android::hidl::memory::V1_0::IMapper follow.
+Return<void> AshmemMapper::mapMemory(const hidl_memory& mem, mapMemory_cb _hidl_cb) {
+    if (mem.handle()->numFds == 0) {
+        _hidl_cb(nullptr);
+        return Void();
+    }
+
+    int fd = mem.handle()->data[0];
+    void* data = mmap(0, mem.size(), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
+    if (data == MAP_FAILED) {
+        // mmap never maps at address zero without MAP_FIXED, so we can avoid
+        // exposing clients to MAP_FAILED.
+        _hidl_cb(nullptr);
+        return Void();
+    }
+
+    sp<IMemory> memory = new AshmemMemory(mem, data);
+
+    _hidl_cb(memory);
+    return Void();
+}
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace memory
+}  // namespace hidl
+}  // namespace android
diff --git a/transport/memory/1.0/default/AshmemMapper.h b/transport/memory/1.0/default/AshmemMapper.h
new file mode 100644
index 0000000..c6cfc37
--- /dev/null
+++ b/transport/memory/1.0/default/AshmemMapper.h
@@ -0,0 +1,51 @@
+/*
+ * 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.
+ */
+
+#ifndef ANDROID_HIDL_ASHMEM_MEMORY_V1_0_MAPPER_H
+#define ANDROID_HIDL_ASHMEM_MEMORY_V1_0_MAPPER_H
+
+#include <android/hidl/memory/1.0/IMapper.h>
+#include <hidl/MQDescriptor.h>
+#include <hidl/Status.h>
+
+namespace android {
+namespace hidl {
+namespace memory {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hidl::memory::V1_0::IMapper;
+using ::android::hardware::hidl_array;
+using ::android::hardware::hidl_memory;
+using ::android::hardware::hidl_string;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::sp;
+
+struct AshmemMapper : public IMapper {
+    // Methods from ::android::hidl::memory::V1_0::IMapper follow.
+    Return<void> mapMemory(const hidl_memory& mem, mapMemory_cb _hidl_cb) override;
+
+};
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace memory
+}  // namespace hidl
+}  // namespace android
+
+#endif  // ANDROID_HIDL_ASHMEM_MEMORY_V1_0_MAPPER_H
diff --git a/transport/memory/1.0/default/AshmemMemory.cpp b/transport/memory/1.0/default/AshmemMemory.cpp
new file mode 100644
index 0000000..31626ea
--- /dev/null
+++ b/transport/memory/1.0/default/AshmemMemory.cpp
@@ -0,0 +1,61 @@
+/*
+ * 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 "AshmemMemory.h"
+
+namespace android {
+namespace hidl {
+namespace memory {
+namespace V1_0 {
+namespace implementation {
+
+AshmemMemory::AshmemMemory(const hidl_memory& memory, void* data)
+  : mMemory(memory),
+    mData(data)
+{}
+
+AshmemMemory::~AshmemMemory()
+{
+    // TODO: Move implementation to mapper class
+    munmap(mData, mMemory.size());
+}
+
+// Methods from ::android::hidl::memory::V1_0::IMemory follow.
+Return<void> AshmemMemory::update() {
+    // NOOP
+    return Void();
+}
+
+Return<void> AshmemMemory::commit() {
+    // NOOP
+    return Void();
+}
+
+Return<void*> AshmemMemory::getPointer() {
+    return mData;
+}
+
+Return<uint64_t> AshmemMemory::getSize() {
+    return mMemory.size();
+}
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace memory
+}  // namespace hidl
+}  // namespace android
diff --git a/transport/memory/1.0/default/AshmemMemory.h b/transport/memory/1.0/default/AshmemMemory.h
new file mode 100644
index 0000000..9dbe1fe
--- /dev/null
+++ b/transport/memory/1.0/default/AshmemMemory.h
@@ -0,0 +1,66 @@
+/*
+ * 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.
+ */
+
+#ifndef ANDROID_HIDL_ASHMEM_MEMORY_V1_0_MEMORY_H
+#define ANDROID_HIDL_ASHMEM_MEMORY_V1_0_MEMORY_H
+
+#include <android/hidl/memory/1.0/IMemory.h>
+#include <hidl/MQDescriptor.h>
+#include <hidl/Status.h>
+
+namespace android {
+namespace hidl {
+namespace memory {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hidl::memory::V1_0::IMemory;
+using ::android::hardware::hidl_array;
+using ::android::hardware::hidl_memory;
+using ::android::hardware::hidl_string;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::sp;
+
+struct AshmemMemory : public IMemory {
+
+    AshmemMemory(const hidl_memory& memory, void* mappedMemory);
+    ~AshmemMemory();
+
+    // Methods from ::android::hidl::memory::V1_0::IMemory follow.
+    Return<void> update() override;
+    Return<void> commit() override;
+    Return<void*> getPointer() override;
+    Return<uint64_t> getSize() override;
+
+private:
+    // Holding onto hidl_memory reference because it contains
+    // handle and size, and handle will also be required for
+    // the remoted case.
+    hidl_memory mMemory;
+
+    // Mapped memory in process.
+    void* mData;
+};
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace memory
+}  // namespace hidl
+}  // namespace android
+
+#endif  // ANDROID_HIDL_ASHMEM_MEMORY_V1_0_MEMORY_H
diff --git a/transport/memory/1.0/default/HidlFetch.cpp b/transport/memory/1.0/default/HidlFetch.cpp
new file mode 100644
index 0000000..8236055
--- /dev/null
+++ b/transport/memory/1.0/default/HidlFetch.cpp
@@ -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.
+ */
+
+#include "HidlFetch.h"
+
+#include "AshmemAllocator.h"
+#include "AshmemMapper.h"
+
+static std::string kAshmemMemoryName = "ashmem";
+
+namespace android {
+namespace hidl {
+namespace memory {
+namespace V1_0 {
+namespace implementation {
+
+IAllocator* HIDL_FETCH_IAllocator(const char* name) {
+    if (name == kAshmemMemoryName) {
+        return new AshmemAllocator;
+    }
+
+    return nullptr;
+}
+
+IMapper* HIDL_FETCH_IMapper(const char* name) {
+    if (name == kAshmemMemoryName) {
+        return new AshmemMapper;
+    }
+
+    return nullptr;
+}
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace memory
+}  // namespace hidl
+}  // namespace android
diff --git a/transport/memory/1.0/default/HidlFetch.h b/transport/memory/1.0/default/HidlFetch.h
new file mode 100644
index 0000000..a9d366f
--- /dev/null
+++ b/transport/memory/1.0/default/HidlFetch.h
@@ -0,0 +1,40 @@
+/*
+ * 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.
+ */
+
+#ifndef HIDL_FETCH_H
+#define HIDL_FETCH_H
+
+#include <android/hidl/memory/1.0/IAllocator.h>
+#include <android/hidl/memory/1.0/IMapper.h>
+
+namespace android {
+namespace hidl {
+namespace memory {
+namespace V1_0 {
+namespace implementation {
+
+// TODO: disable passthrough allocator. It's much better if it's in a centralized location
+extern "C" IAllocator* HIDL_FETCH_IAllocator(const char* name);
+
+extern "C" IMapper* HIDL_FETCH_IMapper(const char* name);
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace memory
+}  // namespace hidl
+}  // namespace android
+
+#endif  // HIDL_FETCH_H
\ No newline at end of file
diff --git a/transport/memory/1.0/default/android.hidl.memory@1.0-service.rc b/transport/memory/1.0/default/android.hidl.memory@1.0-service.rc
new file mode 100644
index 0000000..1caaae9
--- /dev/null
+++ b/transport/memory/1.0/default/android.hidl.memory@1.0-service.rc
@@ -0,0 +1,4 @@
+service hidl_memory /system/bin/hw/android.hidl.memory@1.0-service
+    class hal
+    user system
+    group system
diff --git a/transport/memory/1.0/default/service.cpp b/transport/memory/1.0/default/service.cpp
new file mode 100644
index 0000000..ff3a8e8
--- /dev/null
+++ b/transport/memory/1.0/default/service.cpp
@@ -0,0 +1,12 @@
+#define LOG_TAG "android.hidl.memory@1.0-service"
+
+#include <android/hidl/memory/1.0/IAllocator.h>
+
+#include <hidl/LegacySupport.h>
+
+using android::hidl::memory::V1_0::IAllocator;
+using android::hardware::defaultPassthroughServiceImplementation;
+
+int main() {
+    return defaultPassthroughServiceImplementation<IAllocator>("ashmem");
+}
diff --git a/update-makefiles.sh b/update-makefiles.sh
new file mode 100755
index 0000000..4e17f64
--- /dev/null
+++ b/update-makefiles.sh
@@ -0,0 +1,16 @@
+#!/bin/bash
+
+# TODO(b/33276472)
+
+if [ ! -d system/libhidl ] ; then
+  echo "Where is system/libhidl?";
+  exit 1;
+fi
+
+#manager
+hidl-gen -Lmakefile -r android.hidl:system/libhidl/transport android.hidl.manager@1.0
+hidl-gen -Landroidbp -r android.hidl:system/libhidl/transport android.hidl.manager@1.0
+
+#memory
+hidl-gen -Lmakefile -r android.hidl:system/libhidl/transport android.hidl.memory@1.0
+hidl-gen -Landroidbp -r android.hidl:system/libhidl/transport android.hidl.memory@1.0