diff --git a/media_driver/linux/common/os/magma/inflight_list.cpp b/media_driver/linux/common/os/magma/inflight_list.cpp
new file mode 100644
index 0000000..4af26e3
--- /dev/null
+++ b/media_driver/linux/common/os/magma/inflight_list.cpp
@@ -0,0 +1,170 @@
+/*
+ * Copyright © 2019 Google, LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include "inflight_list.h"
+#include <time.h>
+
+static uint64_t gettime_ns(void)
+{
+   struct timespec current;
+   clock_gettime(CLOCK_MONOTONIC, &current);
+   constexpr uint64_t kNsecPerSec =  1000000000;
+   return static_cast<uint64_t>(current.tv_sec * kNsecPerSec + current.tv_nsec);
+}
+
+static uint64_t get_relative_timeout(uint64_t abs_timeout)
+{
+   uint64_t now = gettime_ns();
+
+   if (abs_timeout < now)
+      return 0;
+   return abs_timeout - now;
+}
+
+static magma_status_t wait_notification_channel(magma_handle_t channel, int64_t timeout_ns)
+{
+   magma_poll_item_t item = {
+       .handle = channel,
+       .type = MAGMA_POLL_TYPE_HANDLE,
+       .condition = MAGMA_POLL_CONDITION_READABLE,
+   };
+   return magma_poll(&item, 1, timeout_ns);
+}
+
+InflightList::InflightList()
+{
+   wait_ = wait_notification_channel;
+   read_ = magma_read_notification_channel2;
+}
+
+InflightList::~InflightList()
+{
+}
+
+void InflightList::add( uint64_t buffer_id)
+{
+   assert(buffer_id != 0);
+   buffers_.push_back(buffer_id);
+}
+
+bool InflightList::remove(uint64_t buffer_id)
+{
+   auto it = std::find(buffers_.begin(), buffers_.end(), buffer_id);
+   if (it == buffers_.end()) {
+      return false;
+   }
+   buffers_.erase(it);
+   return true;
+}
+
+bool InflightList::is_inflight(uint64_t buffer_id)
+{
+   return std::find(buffers_.begin(), buffers_.end(), buffer_id) != buffers_.end();
+}
+
+bool InflightList::TryUpdate(magma_connection_t connection)
+{
+   if (!mutex_.try_lock()) {
+      return false;
+   }
+
+   update(connection);
+
+   mutex_.unlock();
+
+   return true;
+}
+
+magma_status_t InflightList::WaitForBuffer(magma_connection_t connection,
+                                           magma_handle_t notification_channel, uint64_t buffer_id,
+                                           uint64_t timeout_ns)
+{
+   // Calculate deadline before potentially blocking on the mutex
+   uint64_t start = gettime_ns();
+   uint64_t deadline = start + timeout_ns;
+
+   std::lock_guard<std::mutex> lock(mutex_);
+
+   magma_status_t status = MAGMA_STATUS_OK;
+
+   if (is_inflight(buffer_id)) {
+
+      while (true) {
+         // First pass optimization: optimistically try reading the notification channel;
+         // may avoid an unnecessary wait.
+         update(connection);
+
+         if (!is_inflight(buffer_id))
+            break;
+
+         if (timeout_ns == 0) {
+            // Optimization: don't bother making the wait system call since the notification
+            // channel was just drained.
+            status = MAGMA_STATUS_TIMED_OUT;
+            break;
+         }
+
+         status = wait_(notification_channel, get_relative_timeout(deadline));
+         if (status != MAGMA_STATUS_OK) {
+            break;
+         }
+      }
+   }
+
+   return status;
+}
+
+void InflightList::AddAndUpdate(magma_connection_t connection,
+                               struct magma_exec_resource* resources, uint32_t count)
+{
+   std::lock_guard<std::mutex> lock(mutex_);
+
+   for (uint32_t i = 0; i < count; i++) {
+      add(resources[i].buffer_id);
+   }
+
+   update(connection);
+}
+
+void InflightList::update(magma_connection_t connection)
+{
+   uint64_t bytes_available = 0;
+   magma_bool_t more_data = false;
+   while (true) {
+      magma_status_t status =
+          read_(connection, notification_buffer, sizeof(notification_buffer),
+                      &bytes_available, &more_data);
+      if (status != MAGMA_STATUS_OK) {
+         return;
+      }
+      if (bytes_available == 0)
+         return;
+      assert(bytes_available % sizeof(uint64_t) == 0);
+      for (uint32_t i = 0; i < bytes_available / sizeof(uint64_t); i++) {
+         assert(is_inflight(notification_buffer[i]));
+         remove(notification_buffer[i]);
+      }
+      if (!more_data)
+         return;
+   }
+}
diff --git a/media_driver/linux/common/os/magma/inflight_list.h b/media_driver/linux/common/os/magma/inflight_list.h
new file mode 100644
index 0000000..f652462
--- /dev/null
+++ b/media_driver/linux/common/os/magma/inflight_list.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright © 2019 Google, LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef INFLIGHT_LIST_H
+#define INFLIGHT_LIST_H
+
+#include <assert.h>
+#include <magma.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+#include <deque>
+#include <mutex>
+
+// A convenience utility for maintaining a list of inflight command buffers,
+// by reading completed buffer ids from the magma notification channel.
+
+typedef magma_status_t (*wait_notification_channel_t)(magma_handle_t channel, int64_t timeout_ns);
+
+typedef magma_status_t (*read_notification_channel_t)(magma_connection_t connection, void* buffer,
+                                                      uint64_t buffer_size,
+                                                      uint64_t* buffer_size_out,
+                                                      magma_bool_t* more_data_out);
+
+class InflightList {
+  public:
+   InflightList();
+   ~InflightList();
+
+   void add(uint64_t buffer_id);
+   bool remove(uint64_t buffer_id);
+
+   bool is_inflight(uint64_t buffer_id);
+
+   void update(magma_connection_t connection);
+
+   // Returns true if the list lock was obtained. Threadsafe.
+   bool TryUpdate(magma_connection_t connection);
+
+   // Wait for the given |buffer_id| to be removed from the inflight list. Threadsafe.
+   magma_status_t WaitForBuffer(magma_connection_t connection,
+                                magma_handle_t notification_channel, uint64_t buffer_id,
+                                uint64_t timeout_ns);
+
+   // Adds the given buffers to the inflight list and services the notification channel. Threadsafe.
+   void AddAndUpdate(magma_connection_t connection,
+                     struct magma_exec_resource* resources, uint32_t count);
+
+ private:
+   wait_notification_channel_t wait_;
+   read_notification_channel_t read_;
+
+   std::deque<uint64_t> buffers_;
+   std::mutex mutex_;
+   uint64_t notification_buffer[4096 / sizeof(uint64_t)];
+};
+
+#endif // INFLIGHT_LIST_H
diff --git a/media_driver/linux/common/os/magma/media_srcs.cmake b/media_driver/linux/common/os/magma/media_srcs.cmake
index 73f9e46..01d3296 100644
--- a/media_driver/linux/common/os/magma/media_srcs.cmake
+++ b/media_driver/linux/common/os/magma/media_srcs.cmake
@@ -24,6 +24,7 @@
     ${CMAKE_CURRENT_LIST_DIR}/mos_bufmgr_magma.cpp
     ${CMAKE_CURRENT_LIST_DIR}/mos_bufmgr_stub.c
     ${CMAKE_CURRENT_LIST_DIR}/simple_allocator.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/inflight_list.cpp
     ${CMAKE_CURRENT_LIST_DIR}/../i915/mos_bufmgr_api.c
 )
 
diff --git a/media_driver/linux/common/os/magma/mos_bufmgr_magma.cpp b/media_driver/linux/common/os/magma/mos_bufmgr_magma.cpp
index af79ea6..0a2cd4e 100644
--- a/media_driver/linux/common/os/magma/mos_bufmgr_magma.cpp
+++ b/media_driver/linux/common/os/magma/mos_bufmgr_magma.cpp
@@ -25,6 +25,7 @@
 #include <zircon/process.h>
 #include <zircon/syscalls.h>
 
+#include "inflight_list.h"
 #include "mos_bufmgr.h"
 #include "mos_bufmgr_priv.h"
 #include "simple_allocator.h"
@@ -53,6 +54,7 @@
     ~MagmaBufMgr();
 
     magma_connection_t connection() const { return connection_; }
+    magma_handle_t notification_handle() const { return notification_handle_; }
 
     uint32_t device_id() const { return device_id_; }
 
@@ -68,11 +70,15 @@
 
     MagmaBo* CreateBo(const char *name, unsigned long size);
 
+    InflightList* inflight_list() { return &inflight_list_;}
+
 private:
     magma_connection_t connection_ {};
+    magma_handle_t notification_handle_{};
     uint32_t device_id_;
     std::mutex allocator_mutex_;
     std::unique_ptr<SimpleAllocator> allocator_ __attribute__((__guarded_by__(allocator_mutex_)));
+    InflightList inflight_list_;
 };
 
 
@@ -413,6 +419,8 @@
 MagmaBufMgr::MagmaBufMgr(magma_connection_t connection, uint32_t device_id) :
     connection_(connection), device_id_(device_id) {
 
+    notification_handle_ = magma_get_notification_channel_handle(connection_);
+
     mos_bufmgr::bo_alloc = bufmgr_bo_alloc;
     mos_bufmgr::bo_alloc_for_render = bufmgr_bo_alloc_for_render;
     mos_bufmgr::bo_alloc_tiled = bufmgr_bo_alloc_tiled;
@@ -569,6 +577,7 @@
     constexpr uint32_t kExpectedFlags = I915_EXEC_BSD|I915_EXEC_BSD_RING1;
 
     auto bo = static_cast<MagmaBo*>(mos_linux_bo);
+    auto bufmgr = static_cast<MagmaBufMgr*>(ctx->bufmgr);
 
     LOG_VERBOSE("mos_gem_bo_context_exec2 bo %lu used %d context_id %u num_cliprects %d DR4 %d flags 0x%x kExpectedFlags 0x%x",
         bo->id(), used, ctx->ctx_id, num_cliprects, DR4, flags, kExpectedFlags);
@@ -589,6 +598,14 @@
         .flags = kMagmaIntelGenCommandBufferForVideo,
     };
 
+   // Add to inflight list first to avoid race with any other thread reading completions from the
+   // notification channel, in case this thread is preempted just after sending the command buffer
+   // and the completion happens quickly.
+   bufmgr->inflight_list()->AddAndUpdate(
+                             bufmgr->connection(), resources.data(),
+                             resources.size());
+
+
     magma_status_t status = magma_execute_command_buffer_with_resources2(bo->magma_bufmgr()->connection(),
         ctx->ctx_id,
         &command_buffer,
@@ -622,3 +639,19 @@
     *prime_fd = handle;
     return 0;
 }
+
+int mos_gem_bo_wait(struct mos_linux_bo *mos_linux_bo, int64_t timeout_ns)
+{
+    auto bo = static_cast<MagmaBo*>(mos_linux_bo);
+    auto bufmgr = bo->magma_bufmgr();
+    magma_status_t status = bufmgr->inflight_list()->WaitForBuffer(
+        bufmgr->connection(),
+        bufmgr->notification_handle(),
+        bo->id(),
+        timeout_ns);
+    if (status != MAGMA_STATUS_OK) {
+        LOG_VERBOSE("WaitForbuffer failed: %d", status);
+        return -1;
+    }
+    return 0;
+}
diff --git a/media_driver/linux/common/os/magma/mos_bufmgr_stub.c b/media_driver/linux/common/os/magma/mos_bufmgr_stub.c
index b0aeb9c..ff88479 100644
--- a/media_driver/linux/common/os/magma/mos_bufmgr_stub.c
+++ b/media_driver/linux/common/os/magma/mos_bufmgr_stub.c
@@ -33,12 +33,6 @@
         fflush(stderr); \
 } while (0)
 
-int mos_gem_bo_wait(struct mos_linux_bo *bo, int64_t timeout_ns)
-{
-    LOG_VERBOSE("mos_gem_bo_wait unimplemented");
-    return 0;
-}
-
 void mos_bufmgr_gem_enable_reuse(struct mos_bufmgr *bufmgr)
 {
     LOG_VERBOSE("mos_bufmgr_gem_enable_reuse unimplemented");