Merge lp:~raof/mir/mesa-hybrid-cursor into lp:mir

[Chris Halse Rogers]

mesa-kms: Support hardware cursors in hybrid setups.

=== modified file 'src/common/CMakeLists.txt'
--- src/common/CMakeLists.txt	2017-02-15 14:45:41 +0000
+++ src/common/CMakeLists.txt	2017-03-22 06:55:00 +0000
@@ -20,7 +20,8 @@
   $<TARGET_OBJECTS:mirtime>
   ${CMAKE_CURRENT_SOURCE_DIR}/output_type_names.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/log.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/libname.cpp ${PROJECT_SOURCE_DIR}/include/common/mir/libname.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/libname.cpp
+  ${PROJECT_SOURCE_DIR}/include/common/mir/libname.h
   ${PROJECT_SOURCE_DIR}/include/common/mir/posix_rw_mutex.h
   posix_rw_mutex.cpp
   edid.cpp

=== modified file 'src/platforms/mesa/server/display_helpers.cpp'
--- src/platforms/mesa/server/display_helpers.cpp	2017-03-16 07:37:11 +0000
+++ src/platforms/mesa/server/display_helpers.cpp	2017-03-22 06:55:00 +0000
@@ -20,9 +20,14 @@
 #include "drm_close_threadsafe.h"
 
 #include "kms-utils/drm_mode_resources.h"
+#include "mir/graphics/gl_config.h"
+#include "mir/graphics/egl_error.h"
 
 #include "mir/udev/wrapper.h"
 
+#define MIR_LOG_COMPONENT "mesa-kms"
+#include "mir/log.h"
+
 #include <boost/exception/errinfo_errno.hpp>
 #include <boost/throw_exception.hpp>
 
@@ -31,6 +36,7 @@
 #include <stdexcept>
 #include <xf86drm.h>
 #include <fcntl.h>
+#include <vector>
 
 namespace mg = mir::graphics;
 namespace mgm = mir::graphics::mesa;
@@ -40,6 +46,69 @@
  * DRMHelper *
  *************/
 
+std::vector<std::shared_ptr<mgmh::DRMHelper>>
+mgmh::DRMHelper::open_all_devices(std::shared_ptr<mir::udev::Context> const& udev)
+{
+    int tmp_fd = -1;
+    int error = ENODEV; //Default error is "there are no DRM devices"
+
+    mir::udev::Enumerator devices(udev);
+    devices.match_subsystem("drm");
+    devices.match_sysname("card[0-9]");
+
+    devices.scan_devices();
+
+    std::vector<std::shared_ptr<DRMHelper>> opened_devices;
+
+    for(auto& device : devices)
+    {
+        // If directly opening the DRM device is good enough for X it's good enough for us!
+        tmp_fd = open(device.devnode(), O_RDWR | O_CLOEXEC);
+        if (tmp_fd < 0)
+        {
+            error = errno;
+            mir::log_warning(
+                "Failed to open DRM device node %s: %i (%s)",
+                device.devnode(),
+                error,
+                strerror(error));
+            continue;
+        }
+
+        // Check that the drm device is usable by setting the interface version we use (1.4)
+        drmSetVersion sv;
+        sv.drm_di_major = 1;
+        sv.drm_di_minor = 4;
+        sv.drm_dd_major = -1;     /* Don't care */
+        sv.drm_dd_minor = -1;     /* Don't care */
+
+        if ((error = -drmSetInterfaceVersion(tmp_fd, &sv)))
+        {
+            close(tmp_fd);
+            mir::log_warning(
+                "Failed to set DRM interface version on device %s: %i (%s)",
+                device.devnode(),
+                error,
+                strerror(error));
+            tmp_fd = -1;
+            continue;
+        }
+
+        // Can't use make_shared with the private constructor.
+        opened_devices.push_back(std::shared_ptr<DRMHelper>{new DRMHelper{tmp_fd}});
+        mir::log_info("Using DRM device %s", device.devnode());
+        tmp_fd = -1;
+    }
+
+    if (opened_devices.size() == 0)
+    {
+        BOOST_THROW_EXCEPTION((
+            std::system_error{error, std::system_category(), "Error opening DRM device"}));
+    }
+
+    return opened_devices;
+}
+
 void mgmh::DRMHelper::setup(std::shared_ptr<mir::udev::Context> const& udev)
 {
     fd = open_drm_device(udev);
@@ -160,6 +229,12 @@
     }
 }
 
+mgmh::DRMHelper::DRMHelper(int fd)
+    : fd{fd},
+      node_to_use{DRMNodeToUse::card}
+{
+}
+
 int mgmh::DRMHelper::is_appropriate_device(std::shared_ptr<mir::udev::Context> const& udev, mir::udev::Device const& drm_device)
 {
     mir::udev::Enumerator children(udev);
@@ -285,11 +360,29 @@
             std::runtime_error("Failed to create GBM device"));
 }
 
-mgm::GBMSurfaceUPtr mgmh::GBMHelper::create_scanout_surface(uint32_t width, uint32_t height)
+mgm::GBMSurfaceUPtr mgmh::GBMHelper::create_scanout_surface(
+    uint32_t width,
+    uint32_t height,
+    bool sharable)
 {
+    auto format_flags = GBM_BO_USE_RENDERING | GBM_BO_USE_SCANOUT;
+
+    if (sharable)
+    {
+#ifdef MIR_NO_HYBRID_SUPPORT
+        BOOST_THROW_EXCEPTION((
+            std::runtime_error{
+                "Mir built without hybrid support, but configuration requries hybrid outputs.\n"
+                "This will not work unless Mir is rebuilt against Mesa >= 11.0"}
+            ));
+#else
+        format_flags |= GBM_BO_USE_LINEAR;
+#endif
+    }
+
     auto surface_raw = gbm_surface_create(device, width, height,
                                           GBM_BO_FORMAT_XRGB8888,
-                                          GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING);
+                                          format_flags);
 
     auto gbm_surface_deleter = [](gbm_surface *p) { if (p) gbm_surface_destroy(p); };
     GBMSurfaceUPtr surface{surface_raw, gbm_surface_deleter};

=== modified file 'src/platforms/mesa/server/display_helpers.h'
--- src/platforms/mesa/server/display_helpers.h	2017-03-16 07:37:11 +0000
+++ src/platforms/mesa/server/display_helpers.h	2017-03-22 06:55:00 +0000
@@ -24,6 +24,7 @@
 
 #include <cstddef>
 #include <memory>
+#include <vector>
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic warning "-Wall"
@@ -59,6 +60,9 @@
     DRMHelper(const DRMHelper &) = delete;
     DRMHelper& operator=(const DRMHelper&) = delete;
 
+    static std::vector<std::shared_ptr<DRMHelper>> open_all_devices(
+        std::shared_ptr<mir::udev::Context> const& udev);
+
     void setup(std::shared_ptr<mir::udev::Context> const& udev);
     mir::Fd authenticated_fd();
     void auth_magic(drm_magic_t magic);
@@ -70,6 +74,8 @@
     DRMNodeToUse const node_to_use;
 
 private:
+    DRMHelper(int fd);
+
     // TODO: This herustic is temporary; should be replaced with
     // handling >1 DRM device.
     int is_appropriate_device(std::shared_ptr<mir::udev::Context> const& udev, mir::udev::Device const& dev);
@@ -90,7 +96,7 @@
 
     void setup(const DRMHelper& drm);
     void setup(int drm_fd);
-    GBMSurfaceUPtr create_scanout_surface(uint32_t width, uint32_t height);
+    GBMSurfaceUPtr create_scanout_surface(uint32_t width, uint32_t height, bool sharable);
 
     gbm_device* device;
 };

=== modified file 'src/platforms/mesa/server/kms/CMakeLists.txt'
--- src/platforms/mesa/server/kms/CMakeLists.txt	2017-03-16 07:37:11 +0000
+++ src/platforms/mesa/server/kms/CMakeLists.txt	2017-03-22 06:55:00 +0000
@@ -13,6 +13,11 @@
     ${PROJECT_SOURCE_DIR}/include/client
 )
 
+if (GBM_VERSION VERSION_LESS 11)
+  message(WARNING "Hybrid support requires libgbm from Mesa 11.0 or greater. Hybrid setups will not work")
+  add_definitions(-DMIR_NO_HYBRID_SUPPORT)
+endif()
+
 # gbm.h and drm.h have trailing commas at the end of enum definitions
 # This is valid C99, but g++ 4.4 flags it as an error with -pedantic
 string(REPLACE "-pedantic" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
@@ -38,11 +43,13 @@
   kms_display_configuration.h
   real_kms_display_configuration.cpp
   kms_output.h
+  real_kms_output.h
   real_kms_output.cpp
   kms_output_container.h
   real_kms_output_container.cpp
   egl_helper.h
   egl_helper.cpp
+  mutex.h
 )
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/symbols.map.in

=== modified file 'src/platforms/mesa/server/kms/cursor.cpp'
--- src/platforms/mesa/server/kms/cursor.cpp	2017-02-15 07:38:33 +0000
+++ src/platforms/mesa/server/kms/cursor.cpp	2017-03-22 06:55:00 +0000
@@ -88,34 +88,73 @@
        drmGetCap(fd, DRM_CAP_CURSOR_WIDTH, &width);
     return int(width);
 }
-}
-
-mgm::Cursor::GBMBOWrapper::GBMBOWrapper(gbm_device* gbm) :
-    buffer(gbm_bo_create(
-                gbm,
-                get_drm_cursor_width(gbm_device_get_fd(gbm)),
-                get_drm_cursor_height(gbm_device_get_fd(gbm)),
-                GBM_FORMAT_ARGB8888,
-                GBM_BO_USE_CURSOR | GBM_BO_USE_WRITE))
+
+gbm_device* gbm_create_device_checked(int fd)
+{
+    auto device = gbm_create_device(fd);
+    if (!device)
+    {
+        BOOST_THROW_EXCEPTION(std::runtime_error("Failed to create gbm device"));
+    }
+    return device;
+}
+}
+
+mgm::Cursor::GBMBOWrapper::GBMBOWrapper(int fd) :
+    device{gbm_create_device_checked(fd)},
+    buffer{
+        gbm_bo_create(
+            device,
+            get_drm_cursor_width(fd),
+            get_drm_cursor_height(fd),
+            GBM_FORMAT_ARGB8888,
+            GBM_BO_USE_CURSOR | GBM_BO_USE_WRITE)}
 {
     if (!buffer) BOOST_THROW_EXCEPTION(std::runtime_error("failed to create gbm buffer"));
 }
 
-inline mgm::Cursor::GBMBOWrapper::operator gbm_bo*() { return buffer; }
-inline mgm::Cursor::GBMBOWrapper::~GBMBOWrapper()    { gbm_bo_destroy(buffer); }
+inline mgm::Cursor::GBMBOWrapper::operator gbm_bo*()
+{
+    return buffer;
+}
+
+inline mgm::Cursor::GBMBOWrapper::~GBMBOWrapper()
+{
+    if (device)
+        gbm_device_destroy(device);
+    if (buffer)
+        gbm_bo_destroy(buffer);
+}
+
+mgm::Cursor::GBMBOWrapper::GBMBOWrapper(GBMBOWrapper&& from)
+    : device{from.device},
+      buffer{from.buffer}
+{
+    const_cast<gbm_bo*&>(from.buffer) = nullptr;
+    const_cast<gbm_device*&>(from.device) = nullptr;
+}
 
 mgm::Cursor::Cursor(
-    gbm_device* gbm,
     KMSOutputContainer& output_container,
     std::shared_ptr<CurrentConfiguration> const& current_configuration) :
         output_container(output_container),
         current_position(),
         last_set_failed(false),
-        buffer(gbm),
-        buffer_width(gbm_bo_get_width(buffer)),
-        buffer_height(gbm_bo_get_height(buffer)),
+        min_buffer_width{std::numeric_limits<uint32_t>::max()},
+        min_buffer_height{std::numeric_limits<uint32_t>::max()},
         current_configuration(current_configuration)
 {
+    // Generate the buffers for the initial configuration.
+    current_configuration->with_current_configuration_do(
+        [this](KMSDisplayConfiguration const& kms_conf)
+        {
+            kms_conf.for_each_output(
+                [this, &kms_conf](auto const& output)
+                {
+                    buffer_for_output(*kms_conf.get_output_for(output.id));
+                });
+        });
+
     hide();
     if (last_set_failed)
         throw std::runtime_error("Initial KMS cursor set failed");
@@ -126,7 +165,11 @@
     hide();
 }
 
-void mgm::Cursor::write_buffer_data_locked(std::lock_guard<std::mutex> const&, void const* data, size_t count)
+void mgm::Cursor::write_buffer_data_locked(
+    std::lock_guard<std::mutex> const&,
+    gbm_bo* buffer,
+    void const* data,
+    size_t count)
 {
     if (auto result = gbm_bo_write(buffer, data, count))
     {
@@ -136,20 +179,23 @@
     }
 }
 
-void mgm::Cursor::pad_and_write_image_data_locked(std::lock_guard<std::mutex> const& lg, CursorImage const& image)
+void mgm::Cursor::pad_and_write_image_data_locked(
+    std::lock_guard<std::mutex> const& lg,
+    gbm_bo* buffer,
+    CursorImage const& image)
 {
     auto image_argb = static_cast<uint8_t const*>(image.as_argb_8888());
     auto image_width = image.size().width.as_uint32_t();
     auto image_height = image.size().height.as_uint32_t();
     auto image_stride = image_width * 4;
 
-    if (image_width > buffer_width || image_height > buffer_height)
+    if (image_width > min_buffer_width || image_height > min_buffer_height)
     {
         BOOST_THROW_EXCEPTION(std::logic_error("Image is too big for GBM cursor buffer"));
     }
     
     size_t buffer_stride = gbm_bo_get_stride(buffer);  // in bytes
-    size_t padded_size = buffer_stride * buffer_height;
+    size_t padded_size = buffer_stride * gbm_bo_get_height(buffer);
     auto padded = std::unique_ptr<uint8_t[]>(new uint8_t[padded_size]);
     size_t rhs_padding = buffer_stride - image_stride;
 
@@ -164,9 +210,9 @@
         src += image_stride;
     }
 
-    memset(dest, 0, buffer_stride * (buffer_height - image_height));
+    memset(dest, 0, buffer_stride * (gbm_bo_get_height(buffer) - image_height));
 
-    write_buffer_data_locked(lg, &padded[0], padded_size);
+    write_buffer_data_locked(lg, buffer, &padded[0], padded_size);
 }
 
 void mgm::Cursor::show()
@@ -186,14 +232,20 @@
 
     auto const& size = cursor_image.size();
 
-    if (size != geometry::Size{buffer_width, buffer_height})
-    {
-        pad_and_write_image_data_locked(lg, cursor_image);
-    }
-    else
-    {
-        auto const count = size.width.as_uint32_t() * size.height.as_uint32_t() * sizeof(uint32_t);
-        write_buffer_data_locked(lg, cursor_image.as_argb_8888(), count);
+    {
+        auto locked_buffers = buffers.lock();
+        for (auto& pair : *locked_buffers)
+        {
+            auto& buffer = pair.second;
+            if (size != geometry::Size{gbm_bo_get_width(buffer), gbm_bo_get_height(buffer)})
+            {
+                pad_and_write_image_data_locked(lg, buffer, cursor_image);
+            } else
+            {
+                auto const count = size.width.as_uint32_t() * size.height.as_uint32_t() * sizeof(uint32_t);
+                write_buffer_data_locked(lg, buffer, cursor_image.as_argb_8888(), count);
+            }
+        }
     }
     hotspot = cursor_image.hotspot();
     
@@ -217,9 +269,9 @@
 void mir::graphics::mesa::Cursor::clear(std::lock_guard<std::mutex> const&)
 {
     last_set_failed = false;
-    output_container.for_each_output([&](KMSOutput& output)
+    output_container.for_each_output([&](std::shared_ptr<KMSOutput> const& output)
         {
-            if (!output.clear_cursor())
+            if (!output->clear_cursor())
                 last_set_failed = true;
         });
 }
@@ -240,14 +292,13 @@
     std::function<void(KMSOutput&, geom::Rectangle const&, MirOrientation orientation)> const& f)
 {
     current_configuration->with_current_configuration_do(
-        [this,&f](KMSDisplayConfiguration const& kms_conf)
+        [&f](KMSDisplayConfiguration const& kms_conf)
         {
             kms_conf.for_each_output([&](DisplayConfigurationOutput const& conf_output)
             {
                 if (conf_output.used)
                 {
-                    uint32_t const connector_id = kms_conf.get_kms_connector_id(conf_output.id);
-                    auto output = output_container.get_kms_output_for(connector_id);
+                    auto output = kms_conf.get_output_for(conf_output.id);
 
                     f(*output, conf_output.extents(), conf_output.orientation);
                 }
@@ -289,7 +340,7 @@
             output.move_cursor(geom::Point{} + dp - hotspot);
             if (force_state || !output.has_cursor()) // TODO - or if orientation had changed - then set buffer..
             {
-                if (!output.set_cursor(buffer) || !output.has_cursor())
+                if (!output.set_cursor(buffer_for_output(output)) || !output.has_cursor())
                     set_on_all_outputs = false;
             }
         }
@@ -304,3 +355,35 @@
 
     last_set_failed = !set_on_all_outputs;
 }
+
+gbm_bo* mgm::Cursor::buffer_for_output(KMSOutput const& output)
+{
+    auto locked_buffers = buffers.lock();
+
+    auto buffer_it = std::find_if(
+        locked_buffers->begin(),
+        locked_buffers->end(),
+        [&output](auto const& candidate)
+        {
+            return candidate.first == output.drm_fd();
+        });
+
+    if (buffer_it != locked_buffers->end())
+    {
+        return buffer_it->second;
+    }
+
+    locked_buffers->push_back(std::make_pair(output.drm_fd(), GBMBOWrapper(output.drm_fd())));
+
+    gbm_bo* bo = locked_buffers->back().second;
+    if (gbm_bo_get_width(bo) < min_buffer_width)
+    {
+        min_buffer_width = gbm_bo_get_width(bo);
+    }
+    if (gbm_bo_get_height(bo) < min_buffer_height)
+    {
+        min_buffer_height = gbm_bo_get_height(bo);
+    }
+
+    return bo;
+}

=== modified file 'src/platforms/mesa/server/kms/cursor.h'
--- src/platforms/mesa/server/kms/cursor.h	2017-02-15 07:38:33 +0000
+++ src/platforms/mesa/server/kms/cursor.h	2017-03-22 06:55:00 +0000
@@ -25,11 +25,13 @@
 #include "mir/geometry/displacement.h"
 
 #include "mir_toolkit/common.h"
+#include "mutex.h"
 
 #include <gbm.h>
 
 #include <memory>
 #include <mutex>
+#include <vector>
 
 namespace mir
 {
@@ -66,7 +68,6 @@
 {
 public:
     Cursor(
-        gbm_device* device,
         KMSOutputContainer& output_container,
         std::shared_ptr<CurrentConfiguration> const& current_configuration);
 
@@ -86,9 +87,18 @@
     void for_each_used_output(std::function<void(KMSOutput&, geometry::Rectangle const&, MirOrientation orientation)> const& f);
     void place_cursor_at(geometry::Point position, ForceCursorState force_state);
     void place_cursor_at_locked(std::lock_guard<std::mutex> const&, geometry::Point position, ForceCursorState force_state);
-    void write_buffer_data_locked(std::lock_guard<std::mutex> const&, void const* data, size_t count);
-    void pad_and_write_image_data_locked(std::lock_guard<std::mutex> const&, CursorImage const& image);
+    void write_buffer_data_locked(
+        std::lock_guard<std::mutex> const&,
+        gbm_bo* buffer,
+        void const* data,
+        size_t count);
+    void pad_and_write_image_data_locked(
+        std::lock_guard<std::mutex> const&,
+        gbm_bo* buffer,
+        CursorImage const& image);
     void clear(std::lock_guard<std::mutex> const&);
+
+    gbm_bo* buffer_for_output(KMSOutput const& output);
     
     std::mutex guard;
 
@@ -101,17 +111,21 @@
 
     struct GBMBOWrapper
     {
-        GBMBOWrapper(gbm_device* gbm);
+        GBMBOWrapper(int fd);
         operator gbm_bo*();
         ~GBMBOWrapper();
+
+        GBMBOWrapper(GBMBOWrapper&& from);
     private:
-        gbm_bo* buffer;
+        gbm_device* const device;
+        gbm_bo* const buffer;
         GBMBOWrapper(GBMBOWrapper const&) = delete;
         GBMBOWrapper& operator=(GBMBOWrapper const&) = delete;
-    } buffer;
+    };
+    Mutex<std::vector<std::pair<int, GBMBOWrapper>>> buffers;
 
-    uint32_t buffer_width;
-    uint32_t buffer_height;
+    uint32_t min_buffer_width;
+    uint32_t min_buffer_height;
 
     std::shared_ptr<CurrentConfiguration> const current_configuration;
 };

=== modified file 'src/platforms/mesa/server/kms/display.cpp'
--- src/platforms/mesa/server/kms/display.cpp	2017-03-13 08:12:52 +0000
+++ src/platforms/mesa/server/kms/display.cpp	2017-03-22 06:55:00 +0000
@@ -39,6 +39,7 @@
 
 #include <stdexcept>
 #include <algorithm>
+#include <unordered_map>
 
 namespace mgm = mir::graphics::mesa;
 namespace mg = mir::graphics;
@@ -78,24 +79,48 @@
     mgm::helpers::EGLHelper egl;
 };
 
-}
-
-mgm::Display::Display(std::shared_ptr<helpers::DRMHelper> const& drm,
+std::vector<int> drm_fds_from_drm_helpers(
+    std::vector<std::shared_ptr<mgm::helpers::DRMHelper>> const& helpers)
+{
+    std::vector<int> fds;
+    for (auto const& helper: helpers)
+    {
+        fds.push_back(helper->fd);
+    }
+    return fds;
+}
+
+}
+
+mgm::Display::Display(std::vector<std::shared_ptr<helpers::DRMHelper>> const& drm,
                       std::shared_ptr<helpers::GBMHelper> const& gbm,
                       std::shared_ptr<VirtualTerminal> const& vt,
                       mgm::BypassOption bypass_option,
                       std::shared_ptr<DisplayConfigurationPolicy> const& initial_conf_policy,
                       std::shared_ptr<GLConfig> const& gl_config,
                       std::shared_ptr<DisplayReport> const& listener)
-    : drm(drm),
+    : drm{drm},
       gbm(gbm),
       vt(vt),
       listener(listener),
       monitor(mir::udev::Context()),
       shared_egl{*gl_config},
-      output_container{drm->fd,
-                       std::make_shared<KMSPageFlipper>(drm->fd, listener)},
-      current_display_configuration{drm->fd},
+      output_container{
+          std::make_shared<RealKMSOutputContainer>(
+              drm_fds_from_drm_helpers(drm),
+              [
+                  listener,
+                  flippers = std::unordered_map<int, std::shared_ptr<KMSPageFlipper>>{}
+              ](int drm_fd) mutable
+              {
+                  auto& flipper = flippers[drm_fd];
+                  if (!flipper)
+                  {
+                      flipper = std::make_shared<KMSPageFlipper>(drm_fd, listener);
+                  }
+                  return flipper;
+              })},
+      current_display_configuration{output_container},
       dirty_configuration{false},
       bypass_option(bypass_option),
       gl_config{gl_config}
@@ -193,7 +218,8 @@
     try
     {
         if (auto c = cursor.lock()) c->suspend();
-        drm->drop_master();
+        for (auto& helper : drm)
+            helper->drop_master();
     }
     catch(std::runtime_error const& e)
     {
@@ -206,7 +232,8 @@
 {
     try
     {
-        drm->set_master();
+        for (auto& helper : drm)
+            helper->set_master();
     }
     catch(std::runtime_error const& e)
     {
@@ -260,9 +287,9 @@
 
         try
         {
-            locked_cursor = std::make_shared<Cursor>(gbm->device,
-                              output_container,
-                              std::make_shared<KMSCurrentConfiguration>(*this));
+            locked_cursor = std::make_shared<Cursor>(
+                *output_container,
+                std::make_shared<KMSCurrentConfiguration>(*this));
         }
         catch (std::runtime_error const&)
         {
@@ -287,8 +314,7 @@
         if (conf_output.connected &&
             (!conf_output.used || (conf_output.power_mode != mir_power_mode_on)))
         {
-            uint32_t const connector_id = current_display_configuration.get_kms_connector_id(conf_output.id);
-            auto kms_output = output_container.get_kms_output_for(connector_id);
+            auto kms_output = current_display_configuration.get_output_for(conf_output.id);
 
             kms_output->clear_crtc();
             kms_output->set_power_mode(conf_output.power_mode);
@@ -327,10 +353,40 @@
 
 mg::Frame mgm::Display::last_frame_on(unsigned output_id) const
 {
-    auto output = output_container.get_kms_output_for(output_id);
+    auto output = current_display_configuration.get_output_for(
+        DisplayConfigurationOutputId{static_cast<int>(output_id)});
     return output->last_frame();
 }
 
+namespace
+{
+/*
+ * Add output to the grouping, maintaining the invariant that each vector of outputs
+ * is a single GPU memory domain.
+ */
+void add_to_drm_device_group(
+    std::vector<std::vector<std::shared_ptr<mgm::KMSOutput>>>& grouping,
+    std::shared_ptr<mgm::KMSOutput>&& output)
+{
+    for (auto &group : grouping)
+    {
+        /*
+         * We could be smarter about this, but being on the same DRM device is guaranteed
+         * to be in the same GPU memory domain :).
+         */
+        if (group.front()->drm_fd() == output->drm_fd())
+        {
+            group.push_back(std::move(output));
+            break;
+        }
+    }
+    if (output)
+    {
+        grouping.push_back(std::vector<std::shared_ptr<mgm::KMSOutput>>{std::move(output)});
+    }
+}
+}
+
 void mgm::Display::configure_locked(
     mgm::RealKMSDisplayConfiguration const& kms_conf,
     std::lock_guard<std::mutex> const&)
@@ -359,8 +415,7 @@
         kms_conf.for_each_output(
             [&](DisplayConfigurationOutput const& conf_output)
             {
-                uint32_t const connector_id = current_display_configuration.get_kms_connector_id(conf_output.id);
-                auto kms_output = output_container.get_kms_output_for(connector_id);
+                auto kms_output = current_display_configuration.get_output_for(conf_output.id);
                 kms_output->clear_cursor();
                 kms_output->reset();
             });
@@ -374,14 +429,14 @@
         [&](OverlappingOutputGroup const& group)
         {
             auto bounding_rect = group.bounding_rectangle();
-            std::vector<std::shared_ptr<KMSOutput>> kms_outputs;
+            // Each vector<KMSOutput> is a single GPU memory domain
+            std::vector<std::vector<std::shared_ptr<KMSOutput>>> kms_output_groups;
             MirOrientation orientation = mir_orientation_normal;
 
             group.for_each_output(
                 [&](DisplayConfigurationOutput const& conf_output)
                 {
-                    uint32_t const connector_id = kms_conf.get_kms_connector_id(conf_output.id);
-                    auto kms_output = output_container.get_kms_output_for(connector_id);
+                    auto kms_output = current_display_configuration.get_output_for(conf_output.id);
 
                     auto const mode_index = kms_conf.get_kms_mode_index(conf_output.id,
                                                                   conf_output.current_mode_index);
@@ -390,7 +445,7 @@
                     {
                         kms_output->set_power_mode(conf_output.power_mode);
                         kms_output->set_gamma(conf_output.gamma);
-                        kms_outputs.push_back(kms_output);
+                        add_to_drm_device_group(kms_output_groups, std::move(kms_output));
                     }
 
                     /*
@@ -413,28 +468,38 @@
                     std::swap(width, height);
                 }
 
-                auto surface = gbm->create_scanout_surface(width, height);
-                auto const raw_surface = surface.get();
-
-                std::unique_ptr<DisplayBuffer> db{
-                    new DisplayBuffer{bypass_option,
-                    listener,
-                    kms_outputs,
-                    GBMOutputSurface{
-                        drm->fd,
-                        std::move(surface),
-                        width, height,
-                        helpers::EGLHelper{
-                            *gl_config,
-                            *gbm,
-                            raw_surface,
-                            shared_egl.context()
-                        }
-                    },
-                    bounding_rect,
-                    orientation}};
-
-                display_buffers_new.push_back(std::move(db));
+                for (auto const& group : kms_output_groups)
+                {
+                    /*
+                     * In a hybrid setup a scanout surface needs to be allocated differently if it
+                     * needs to be able to be shared across GPUs. This likely reduces performance.
+                     *
+                     * As a first cut, assume every scanout buffer in a hybrid setup might need
+                     * to be shared.
+                     */
+                    auto surface = gbm->create_scanout_surface(width, height, drm.size() != 1);
+                    auto const raw_surface = surface.get();
+
+                    auto db = std::make_unique<DisplayBuffer>(
+                        bypass_option,
+                        listener,
+                        group,
+                        GBMOutputSurface{
+                            group.front()->drm_fd(),
+                            std::move(surface),
+                            width, height,
+                            helpers::EGLHelper{
+                                *gl_config,
+                                *gbm,
+                                raw_surface,
+                                shared_egl.context()
+                            }
+                        },
+                        bounding_rect,
+                        orientation);
+
+                    display_buffers_new.push_back(std::move(db));
+                }
             }
         });
 

=== modified file 'src/platforms/mesa/server/kms/display.h'
--- src/platforms/mesa/server/kms/display.h	2017-03-16 07:37:11 +0000
+++ src/platforms/mesa/server/kms/display.h	2017-03-22 06:55:00 +0000
@@ -65,7 +65,7 @@
                 public renderer::gl::ContextSource
 {
 public:
-    Display(std::shared_ptr<helpers::DRMHelper> const& drm,
+    Display(std::vector<std::shared_ptr<helpers::DRMHelper>> const& drm,
             std::shared_ptr<helpers::GBMHelper> const& gbm,
             std::shared_ptr<VirtualTerminal> const& vt,
             BypassOption bypass_option,
@@ -106,14 +106,14 @@
     void clear_connected_unused_outputs();
 
     mutable std::mutex configuration_mutex;
-    std::shared_ptr<helpers::DRMHelper> const drm;
+    std::vector<std::shared_ptr<helpers::DRMHelper>> const drm;
     std::shared_ptr<helpers::GBMHelper> const gbm;
     std::shared_ptr<VirtualTerminal> const vt;
     std::shared_ptr<DisplayReport> const listener;
     mir::udev::Monitor monitor;
     helpers::EGLHelper shared_egl;
     std::vector<std::unique_ptr<DisplayBuffer>> display_buffers;
-    mutable RealKMSOutputContainer output_container;
+    std::shared_ptr<KMSOutputContainer> const output_container;
     mutable RealKMSDisplayConfiguration current_display_configuration;
     mutable std::atomic<bool> dirty_configuration;
 

=== modified file 'src/platforms/mesa/server/kms/display_buffer.cpp'
--- src/platforms/mesa/server/kms/display_buffer.cpp	2017-03-13 08:12:52 +0000
+++ src/platforms/mesa/server/kms/display_buffer.cpp	2017-03-22 06:55:00 +0000
@@ -28,8 +28,13 @@
 #include "mir/graphics/egl_error.h"
 
 #include <boost/throw_exception.hpp>
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
 #include MIR_SERVER_GL_H
+#include <GLES2/gl2ext.h>
+#include <drm/drm_fourcc.h>
 
+#include <sstream>
 #include <stdexcept>
 #include <chrono>
 #include <thread>
@@ -104,18 +109,378 @@
 
 namespace
 {
-
-void ensure_egl_image_extensions()
-{
-    std::string ext_string;
-    const char* exts = reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));
-    if (exts)
-        ext_string = exts;
-
-    if (ext_string.find("GL_OES_EGL_image") == std::string::npos)
-        BOOST_THROW_EXCEPTION(std::runtime_error("GLES2 implementation doesn't support GL_OES_EGL_image extension"));
-}
-
+void require_extensions(
+    std::initializer_list<char const*> extensions,
+    std::function<std::string()> const& extension_getter)
+{
+    std::stringstream missing_extensions;
+
+    std::string const ext_string = extension_getter();
+
+    for (auto extension : extensions)
+    {
+        if (ext_string.find(extension) == std::string::npos)
+        {
+            missing_extensions << "Missing " << extension << std::endl;
+        }
+    }
+
+    if (!missing_extensions.str().empty())
+    {
+        BOOST_THROW_EXCEPTION(std::runtime_error(
+            std::string("Missing required extensions:\n") + missing_extensions.str()));
+    }
+}
+
+void require_egl_extensions(EGLDisplay dpy, std::initializer_list<char const*> extensions)
+{
+    require_extensions(
+        extensions,
+        [dpy]() -> std::string
+        {
+            char const* maybe_exts = eglQueryString(dpy, EGL_EXTENSIONS);
+            if (maybe_exts)
+                return maybe_exts;
+            return {};
+        });
+}
+
+void require_gl_extensions(std::initializer_list<char const*> extensions)
+{
+    require_extensions(
+        extensions,
+        []() -> std::string
+        {
+            char const *maybe_exts =
+                reinterpret_cast<char const*>(glGetString(GL_EXTENSIONS));
+            if (maybe_exts)
+                return maybe_exts;
+            return {};
+        });
+}
+
+bool needs_bounce_buffer(mgm::KMSOutput const& destination, gbm_bo* source)
+{
+    return destination.buffer_requires_migration(source);
+}
+
+const GLchar* const vshader =
+    {
+        "attribute vec4 position;\n"
+        "attribute vec2 texcoord;\n"
+        "varying vec2 v_texcoord;\n"
+        "void main() {\n"
+        "   gl_Position = position;\n"
+        "   v_texcoord = texcoord;\n"
+        "}\n"
+    };
+
+const GLchar* const fshader =
+    {
+        "#ifdef GL_ES\n"
+        "precision mediump float;\n"
+        "#endif\n"
+        "uniform sampler2D tex;"
+        "varying vec2 v_texcoord;\n"
+        "void main() {\n"
+        "   gl_FragColor = texture2D(tex, v_texcoord);\n"
+        "}\n"
+    };
+
+class VBO
+{
+public:
+    VBO(void const* data, size_t size)
+    {
+        glGenBuffers(1, &buf_id);
+        glBindBuffer(GL_ARRAY_BUFFER, buf_id);
+        glBufferData(GL_ARRAY_BUFFER, size, data, GL_STATIC_DRAW);
+        glBindBuffer(GL_ARRAY_BUFFER, 0);
+    }
+
+    ~VBO()
+    {
+        glDeleteBuffers(1, &buf_id);
+    }
+
+    void bind()
+    {
+        glBindBuffer(GL_ARRAY_BUFFER, buf_id);
+    }
+
+private:
+    GLuint buf_id;
+};
+
+class EGLBufferCopier
+{
+public:
+    EGLBufferCopier(
+        int drm_fd,
+        uint32_t width,
+        uint32_t height,
+        uint32_t format)
+        : eglCreateImageKHR{
+              reinterpret_cast<PFNEGLCREATEIMAGEKHRPROC>(eglGetProcAddress("eglCreateImageKHR"))},
+          eglDestroyImageKHR{
+              reinterpret_cast<PFNEGLDESTROYIMAGEKHRPROC>(eglGetProcAddress("eglDestroyImageKHR"))},
+          glEGLImageTargetTexture2DOES{
+              reinterpret_cast<PFNGLEGLIMAGETARGETTEXTURE2DOESPROC>(eglGetProcAddress("glEGLImageTargetTexture2DOES"))},
+          device{gbm_create_device(drm_fd), &gbm_device_destroy},
+          width{width},
+          height{height},
+          surface{create_scanout_surface(*device, width, height, format)}
+    {
+        require_gl_extensions({
+            "GL_OES_EGL_image"
+        });
+
+        EGLint const config_attr[] = {
+            EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
+            EGL_RED_SIZE, 5,
+            EGL_GREEN_SIZE, 5,
+            EGL_BLUE_SIZE, 5,
+            EGL_ALPHA_SIZE, 0,
+            EGL_DEPTH_SIZE, 0,
+            EGL_STENCIL_SIZE, 0,
+            EGL_RENDERABLE_TYPE, MIR_SERVER_EGL_OPENGL_BIT,
+            EGL_NONE
+        };
+
+        static const EGLint required_egl_version_major = 1;
+        static const EGLint required_egl_version_minor = 4;
+
+        EGLint num_egl_configs;
+        EGLConfig egl_config;
+
+        display = eglGetDisplay(static_cast<EGLNativeDisplayType>(device.get()));
+        if (display == EGL_NO_DISPLAY)
+            BOOST_THROW_EXCEPTION(mg::egl_error("Failed to get EGL display"));
+
+        EGLint major, minor;
+
+        if (eglInitialize(display, &major, &minor) == EGL_FALSE)
+            BOOST_THROW_EXCEPTION(mg::egl_error("Failed to initialize EGL display"));
+
+        if ((major < required_egl_version_major) ||
+            (major == required_egl_version_major && minor < required_egl_version_minor))
+        {
+            BOOST_THROW_EXCEPTION(std::runtime_error("Incompatible EGL version"));
+        }
+
+        require_egl_extensions(
+            display,
+            {
+                "EGL_KHR_image_base",
+                "EGL_EXT_image_dma_buf_import"
+            });
+
+        if (eglChooseConfig(display, config_attr, &egl_config, 1, &num_egl_configs) == EGL_FALSE ||
+            num_egl_configs != 1)
+        {
+            BOOST_THROW_EXCEPTION(mg::egl_error("Failed to choose ARGB EGL config"));
+        }
+
+        eglBindAPI(MIR_SERVER_EGL_OPENGL_API);
+        static const EGLint context_attr[] = {
+#if MIR_SERVER_EGL_OPENGL_BIT == EGL_OPENGL_ES2_BIT
+            EGL_CONTEXT_CLIENT_VERSION, 2,
+#endif
+            EGL_NONE
+        };
+
+        context = eglCreateContext(display, egl_config, EGL_NO_CONTEXT, context_attr);
+        if (context == EGL_NO_CONTEXT)
+            BOOST_THROW_EXCEPTION(mg::egl_error("Failed to create EGL context"));
+
+        egl_surface = eglCreateWindowSurface(display, egl_config, surface.get(), nullptr);
+        eglMakeCurrent(display, egl_surface, egl_surface, context);
+
+        auto vertex = glCreateShader(GL_VERTEX_SHADER);
+        glShaderSource(vertex, 1, &vshader, nullptr);
+        glCompileShader(vertex);
+
+        int compiled;
+        glGetShaderiv (vertex, GL_COMPILE_STATUS, &compiled);
+
+        if (!compiled) {
+            GLchar log[1024];
+
+            glGetShaderInfoLog (vertex, sizeof log - 1, NULL, log);
+            log[sizeof log - 1] = '\0';
+            glDeleteShader (vertex);
+
+            BOOST_THROW_EXCEPTION(
+                std::runtime_error(std::string{"Failed to compile vertex shader:\n"} + log));
+        }
+
+
+        auto fragment = glCreateShader(GL_FRAGMENT_SHADER);
+        glShaderSource(fragment, 1, &fshader, nullptr);
+        glCompileShader(fragment);
+
+        glGetShaderiv (fragment, GL_COMPILE_STATUS, &compiled);
+        if (!compiled) {
+            GLchar log[1024];
+
+            glGetShaderInfoLog (fragment, sizeof log - 1, NULL, log);
+            log[sizeof log - 1] = '\0';
+            glDeleteShader (fragment);
+
+            BOOST_THROW_EXCEPTION(
+                std::runtime_error(std::string{"Failed to compile fragment shader:\n"} + log));
+        }
+
+        prog = glCreateProgram();
+        glAttachShader(prog, vertex);
+        glAttachShader(prog, fragment);
+        glLinkProgram(prog);
+        glGetProgramiv (prog, GL_LINK_STATUS, &compiled);
+        if (!compiled) {
+            GLchar log[1024];
+
+            glGetProgramInfoLog (prog, sizeof log - 1, NULL, log);
+            log[sizeof log - 1] = '\0';
+
+            BOOST_THROW_EXCEPTION(
+                std::runtime_error(std::string{"Failed to link shader prog:\n"} + log));
+        }
+
+        glUseProgram(prog);
+
+        attrpos = glGetAttribLocation(prog, "position");
+        attrtex = glGetAttribLocation(prog, "texcoord");
+        auto unitex = glGetUniformLocation(prog, "tex");
+
+        glGenTextures(1, &tex);
+        glActiveTexture(GL_TEXTURE0);
+        glBindTexture(GL_TEXTURE_2D, tex);
+
+        glUniform1i(unitex, 0);
+
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+        static GLfloat const dest_vert[4][2] =
+            { { -1.f, 1.f }, { 1.f, 1.f }, { 1.f, -1.f }, { -1.f, -1.f } };
+        vert_data = std::make_unique<VBO>(dest_vert, sizeof(dest_vert));
+
+        static GLfloat const tex_vert[4][2] =
+            {
+                { 0.f, 0.f }, { 1.f, 0.f }, { 1.f, 1.f }, { 0.f, 1.f },
+            };
+        tex_data = std::make_unique<VBO>(tex_vert, sizeof(tex_vert));
+    }
+
+    EGLBufferCopier(EGLBufferCopier const&) = delete;
+    EGLBufferCopier& operator==(EGLBufferCopier const&) = delete;
+
+    ~EGLBufferCopier()
+    {
+        eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, context);
+        vert_data = nullptr;
+        tex_data = nullptr;
+        eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+        eglDestroySurface(display, egl_surface);
+        eglDestroyContext(display, context);
+        eglTerminate(display);
+    }
+
+    mgm::GBMOutputSurface::FrontBuffer copy_front_buffer_from(mgm::GBMOutputSurface::FrontBuffer&& from)
+    {
+        eglMakeCurrent(display, egl_surface, egl_surface, context);
+        mir::Fd const dma_buf{gbm_bo_get_fd(from)};
+
+        glUseProgram(prog);
+
+        EGLint const image_attrs[] = {
+            EGL_WIDTH, static_cast<EGLint>(width),
+            EGL_HEIGHT, static_cast<EGLint>(height),
+            EGL_LINUX_DRM_FOURCC_EXT, DRM_FORMAT_XRGB8888,
+            EGL_DMA_BUF_PLANE0_FD_EXT, static_cast<int>(dma_buf),
+            EGL_DMA_BUF_PLANE0_OFFSET_EXT, 0,
+            EGL_DMA_BUF_PLANE0_PITCH_EXT, static_cast<EGLint>(gbm_bo_get_stride(from)),
+            EGL_NONE
+        };
+
+        auto image = eglCreateImageKHR(
+            display,
+            EGL_NO_CONTEXT,
+            EGL_LINUX_DMA_BUF_EXT,
+            nullptr,
+            image_attrs);
+
+        if (image == EGL_NO_IMAGE_KHR)
+        {
+            BOOST_THROW_EXCEPTION(mg::egl_error("Failed to create EGLImage from dma_buf"));
+        }
+
+        glActiveTexture(GL_TEXTURE0);
+        glBindTexture(GL_TEXTURE_2D, tex);
+        glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image);
+
+        vert_data->bind();
+        glVertexAttribPointer (attrpos, 2, GL_FLOAT, GL_FALSE, 0, 0);
+
+        tex_data->bind();
+        glVertexAttribPointer (attrtex, 2, GL_FLOAT, GL_FALSE, 0, 0);
+
+        glEnableVertexAttribArray(attrpos);
+        glEnableVertexAttribArray(attrtex);
+
+        GLubyte const idx[] = { 0, 1, 3, 2 };
+        glDrawElements (GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_BYTE, idx);
+
+        if (eglSwapBuffers(display, egl_surface) != EGL_TRUE)
+        {
+            BOOST_THROW_EXCEPTION(mg::egl_error("Failed to swap bounce buffers"));
+        }
+
+        eglDestroyImageKHR(display, image);
+
+        eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+        return mgm::GBMOutputSurface::FrontBuffer(surface.get());
+    }
+
+    private:
+    static mgm::GBMSurfaceUPtr create_scanout_surface(
+        gbm_device& on,
+        uint32_t width,
+        uint32_t height,
+        uint32_t format)
+    {
+        auto* const device = &on;
+
+        return {
+            gbm_surface_create(
+                device,
+                width,
+                height,
+                format,
+                GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING),
+            &gbm_surface_destroy};
+    }
+
+    PFNEGLCREATEIMAGEKHRPROC const eglCreateImageKHR;
+    PFNEGLDESTROYIMAGEKHRPROC const eglDestroyImageKHR;
+    PFNGLEGLIMAGETARGETTEXTURE2DOESPROC const glEGLImageTargetTexture2DOES;
+
+    std::unique_ptr<gbm_device, decltype(&gbm_device_destroy)> const device;
+    uint32_t const width;
+    uint32_t const height;
+    mgm::GBMSurfaceUPtr const surface;
+    EGLDisplay display;
+    EGLContext context;
+    EGLSurface egl_surface;
+    GLuint prog;
+    GLuint tex;
+    GLint attrtex;
+    GLint attrpos;
+    std::unique_ptr<VBO> vert_data;
+    std::unique_ptr<VBO> tex_data;
+};
 }
 
 mgm::DisplayBuffer::DisplayBuffer(
@@ -152,19 +517,48 @@
     make_current();
 
     listener->report_successful_egl_make_current_on_construction();
-
-    ensure_egl_image_extensions();
-
+    
     glClear(GL_COLOR_BUFFER_BIT);
 
     surface.swap_buffers();
 
     listener->report_successful_egl_buffer_swap_on_construction();
 
-    visible_composite_frame = surface.lock_front();
-    if (!visible_composite_frame)
+    auto temporary_front = surface.lock_front();
+    if (!temporary_front)
         fatal_error("Failed to get frontbuffer");
 
+    if (needs_bounce_buffer(*outputs.front(), temporary_front))
+    {
+        get_front_buffer = std::bind(
+            std::mem_fn(&EGLBufferCopier::copy_front_buffer_from),
+            std::make_shared<EGLBufferCopier>(
+                outputs.front()->drm_fd(),
+                fb_width,
+                fb_height,
+                GBM_BO_FORMAT_XRGB8888),
+            std::placeholders::_1);
+    }
+    else
+    {
+        get_front_buffer = [](auto&& fb) { return std::move(fb); };
+    }
+
+    visible_composite_frame = get_front_buffer(std::move(temporary_front));
+
+    /*
+     * Check that our (possibly bounced) front buffer is usable on *all* the
+     * outputs we've been asked to output on.
+     */
+    for (auto const& output : outputs)
+    {
+        if (output->buffer_requires_migration(visible_composite_frame))
+        {
+            BOOST_THROW_EXCEPTION(std::invalid_argument(
+                "Attempted to create a DisplayBuffer spanning multiple GPU memory domains"));
+        }
+    }
+
     set_crtc(*outputs.front()->fb_for(visible_composite_frame, fb_width, fb_height));
 
     release_current();
@@ -213,7 +607,8 @@
             if (!native)
                 BOOST_THROW_EXCEPTION(std::invalid_argument("could not convert NativeBuffer"));
             if (native->flags & mir_buffer_flag_can_scanout &&
-                bypass_buffer->size() == geom::Size{fb_width,fb_height})
+                bypass_buffer->size() == geom::Size{fb_width,fb_height} &&
+                !needs_bounce_buffer(*outputs.front(), native->bo))
             {
                 if (auto bufobj = outputs.front()->fb_for(native->bo, fb_width, fb_height))
                 {
@@ -278,7 +673,7 @@
     }
     else
     {
-        scheduled_composite_frame = surface.lock_front();
+        scheduled_composite_frame = get_front_buffer(surface.lock_front());
         bufobj = outputs.front()->fb_for(scheduled_composite_frame, fb_width, fb_height);
         if (!bufobj)
             fatal_error("Failed to get front buffer object");

=== modified file 'src/platforms/mesa/server/kms/display_buffer.h'
--- src/platforms/mesa/server/kms/display_buffer.h	2017-03-16 07:37:11 +0000
+++ src/platforms/mesa/server/kms/display_buffer.h	2017-03-22 06:55:00 +0000
@@ -53,19 +53,18 @@
     {
     public:
         FrontBuffer();
+        FrontBuffer(gbm_surface* surface);
+        FrontBuffer(FrontBuffer&& from);
+
         ~FrontBuffer();
 
-        FrontBuffer(FrontBuffer&& from);
-
         FrontBuffer& operator=(FrontBuffer&& from);
         FrontBuffer& operator=(std::nullptr_t);
 
         operator gbm_bo*();
         operator bool() const;
+
     private:
-        friend class GBMOutputSurface;
-        FrontBuffer(gbm_surface* surface);
-
         gbm_surface* const surf;
         gbm_bo* const bo;
     };
@@ -146,6 +145,8 @@
     GBMOutputSurface::FrontBuffer visible_composite_frame;
     GBMOutputSurface::FrontBuffer scheduled_composite_frame;
 
+    std::function<GBMOutputSurface::FrontBuffer(GBMOutputSurface::FrontBuffer&&)> get_front_buffer;
+
     geometry::Rectangle area;
     uint32_t fb_width, fb_height;
     glm::mat2 transform;

=== modified file 'src/platforms/mesa/server/kms/kms_display_configuration.h'
--- src/platforms/mesa/server/kms/kms_display_configuration.h	2016-01-29 08:18:22 +0000
+++ src/platforms/mesa/server/kms/kms_display_configuration.h	2017-03-22 06:55:00 +0000
@@ -20,6 +20,7 @@
 #define MIR_GRAPHICS_MESA_KMS_DISPLAY_CONFIGURATION_H_
 
 #include "mir/graphics/display_configuration.h"
+#include <memory>
 
 namespace mir
 {
@@ -27,15 +28,17 @@
 {
 namespace mesa
 {
+class KMSOutput;
 
 class DRMModeResources;
 
 class KMSDisplayConfiguration : public DisplayConfiguration
 {
 public:
-    virtual uint32_t get_kms_connector_id(DisplayConfigurationOutputId id) const = 0;
-    virtual size_t get_kms_mode_index(DisplayConfigurationOutputId id,
-                                      size_t conf_mode_index) const = 0;
+    virtual std::shared_ptr<KMSOutput> get_output_for(DisplayConfigurationOutputId id) const = 0;
+    virtual size_t get_kms_mode_index(
+        DisplayConfigurationOutputId id,
+        size_t conf_mode_index) const = 0;
     virtual void update() = 0;
 };
 

=== modified file 'src/platforms/mesa/server/kms/kms_output.h'
--- src/platforms/mesa/server/kms/kms_output.h	2017-03-13 08:12:52 +0000
+++ src/platforms/mesa/server/kms/kms_output.h	2017-03-22 06:55:00 +0000
@@ -26,12 +26,16 @@
 #include "mir/graphics/frame.h"
 #include "mir_toolkit/common.h"
 
+#include "kms-utils/drm_mode_resources.h"
+
 #include <gbm.h>
 
 namespace mir
 {
 namespace graphics
 {
+class DisplayConfigurationOutput;
+
 namespace mesa
 {
 
@@ -42,6 +46,12 @@
 public:
     virtual ~KMSOutput() = default;
 
+    /*
+     * I'm not sure that DRM guarantees ID uniqueness in the presence of hotplug/unplug;
+     * this may want to be an opaque class Id + operator== in future.
+     */
+    virtual uint32_t id() const = 0;
+    
     virtual void reset() = 0;
     virtual void configure(geometry::Displacement fb_offset, size_t kms_mode_index) = 0;
     virtual geometry::Size size() const = 0;
@@ -68,14 +78,39 @@
     virtual void set_gamma(GammaCurves const& gamma) = 0;
     virtual Frame last_frame() const = 0;
 
+    /**
+     * Re-probe the hardware state of this connector.
+     *
+     * \throws std::system_error if the underlying DRM connector has disappeared.
+     */
+    virtual void refresh_hardware_state() = 0;
+    /**
+     * Translate and copy the cached hardware state into a Mir display configuration object.
+     *
+     * \param [out] to_update   The Mir display configuration object to update with new
+     *                                  hardware state. Only hardware state (modes, dimensions, etc)
+     *                                  is touched.
+     */
+    virtual void update_from_hardware_state(DisplayConfigurationOutput& to_update) const = 0;
     virtual FBHandle* fb_for(gbm_bo* bo, uint32_t width, uint32_t height) const = 0;
 
+    /**
+     * Check whether buffer need to be migrated to GPU-private memory for display.
+     *
+     * \param [in] bo   GBM buffer to test
+     * \return  True if buffer must be migrated to display-private memory in order to be displayed.
+     *          If this method returns true the caller should probably copy it to a new buffer before
+     *          calling fb_for(buffer), as acquiring a FBHandle to the buffer will likely make it
+     *          unusable for rendering on the original GPU.
+     */
+    virtual bool buffer_requires_migration(gbm_bo* bo) const = 0;
+
+    virtual int drm_fd() const = 0;
 protected:
     KMSOutput() = default;
     KMSOutput(const KMSOutput&) = delete;
     KMSOutput& operator=(const KMSOutput&) = delete;
 };
-
 }
 }
 }

=== modified file 'src/platforms/mesa/server/kms/kms_output_container.h'
--- src/platforms/mesa/server/kms/kms_output_container.h	2016-01-29 08:18:22 +0000
+++ src/platforms/mesa/server/kms/kms_output_container.h	2017-03-22 06:55:00 +0000
@@ -36,9 +36,12 @@
 public:
     virtual ~KMSOutputContainer() = default;
 
-    virtual std::shared_ptr<KMSOutput> get_kms_output_for(uint32_t connector_id) = 0;
-    virtual void for_each_output(std::function<void(KMSOutput&)> functor) const = 0;
+    virtual void for_each_output(std::function<void(std::shared_ptr<KMSOutput> const&)> functor) const = 0;
 
+    /**
+     * Re-probe hardware state and update output list.
+     */
+    virtual void update_from_hardware_state() = 0;
 protected:
     KMSOutputContainer() = default;
     KMSOutputContainer(KMSOutputContainer const&) = delete;

=== added file 'src/platforms/mesa/server/kms/mutex.h'
--- src/platforms/mesa/server/kms/mutex.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mesa/server/kms/mutex.h	2017-03-22 06:55:00 +0000
@@ -0,0 +1,104 @@
+/*
+ * Copyright © 2017 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Christopher James Halse Rogers <[e-mail]>
+ */
+
+#ifndef MIR_MUTEX_H_
+#define MIR_MUTEX_H_
+
+#include <mutex>
+
+namespace mir
+{
+/**
+ * Smart-pointer-esque accessor for Mutex<> protected data.
+ *
+ * Ensures exclusive access to the referenced data.
+ *
+ * \tparam Guarded Type of data guarded by the mutex.
+ */
+template<typename Guarded>
+class MutexGuard
+{
+public:
+    MutexGuard(std::unique_lock<std::mutex>&& lock, Guarded& value)
+        : value{value},
+          lock{std::move(lock)}
+    {
+    }
+    MutexGuard(MutexGuard&& from) = default;
+    ~MutexGuard() noexcept(false)
+    {
+        if (lock.owns_lock())
+        {
+            lock.unlock();
+        }
+    }
+
+    Guarded& operator*()
+    {
+        return value;
+    }
+    Guarded* operator->()
+    {
+        return &value;
+    }
+private:
+    Guarded& value;
+    std::unique_lock<std::mutex> lock;
+};
+
+/**
+ * A data-locking mutex
+ *
+ * This is a mutex which owns the data it guards, and can give out a
+ * smart-pointer-esque lock to lock and access it.
+ *
+ * \tparam Guarded  The type of data guarded by the mutex
+ */
+template<typename Guarded>
+class Mutex
+{
+public:
+    Mutex() = default;
+    Mutex(Guarded&& initial_value)
+        : value{std::move(initial_value)}
+    {
+    }
+
+    Mutex(Mutex const&) = delete;
+    Mutex& operator=(Mutex const&) = delete;
+
+    /**
+     * Lock the mutex and return an accessor for the protected data.
+     *
+     * \return A smart-pointer-esque accessor for the contained data.
+     *          While code has access to the MutexGuard it is guaranteed to have exclusive
+     *          access to the contained data.
+     */
+    MutexGuard<Guarded> lock()
+    {
+        return MutexGuard<Guarded>{std::unique_lock<std::mutex>{mutex}, value};
+    }
+
+private:
+    std::mutex mutex;
+    Guarded value;
+};
+
+}
+
+#endif //MIR_MUTEX_H_

=== modified file 'src/platforms/mesa/server/kms/platform.cpp'
--- src/platforms/mesa/server/kms/platform.cpp	2017-03-16 07:37:11 +0000
+++ src/platforms/mesa/server/kms/platform.cpp	2017-03-22 06:55:00 +0000
@@ -39,17 +39,25 @@
                         EmergencyCleanupRegistry& emergency_cleanup_registry,
                         BypassOption bypass_option)
     : udev{std::make_shared<mir::udev::Context>()},
-      drm{std::make_shared<mgmh::DRMHelper>(mgmh::DRMNodeToUse::card)},
+      drm{helpers::DRMHelper::open_all_devices(udev)},
       gbm{std::make_shared<mgmh::GBMHelper>()},
       listener{listener},
       vt{vt},
       bypass_option_{bypass_option}
 {
-    drm->setup(udev);
-    gbm->setup(*drm);
+    // We assume the first DRM device is the boot GPU, and arbitrarily pick it as our
+    // shell renderer.
+    //
+    // TODO: expose multiple rendering GPUs to the shell.
+    gbm->setup(*drm.front());
 
     std::weak_ptr<VirtualTerminal> weak_vt = vt;
-    std::weak_ptr<mgmh::DRMHelper> weak_drm = drm;
+    std::vector<std::weak_ptr<mgmh::DRMHelper>> weak_drm;
+
+    for (auto const &helper : drm)
+    {
+        weak_drm.push_back(helper);
+    }
     emergency_cleanup_registry.add(
         make_module_ptr<EmergencyCleanupHandler>(
             [weak_vt,weak_drm]
@@ -57,8 +65,19 @@
                 if (auto const vt = weak_vt.lock())
                     try { vt->restore(); } catch (...) {}
 
-                if (auto const drm = weak_drm.lock())
-                    try { drm->drop_master(); } catch (...) {}
+                for (auto helper : weak_drm)
+                {
+                    if (auto const drm = helper.lock())
+                    {
+                        try
+                        {
+                            drm->drop_master();
+                        }
+                        catch (...)
+                        {
+                        }
+                    }
+                }
             }));
 
 }
@@ -71,12 +90,19 @@
 mir::UniqueModulePtr<mg::Display> mgm::Platform::create_display(
     std::shared_ptr<DisplayConfigurationPolicy> const& initial_conf_policy, std::shared_ptr<GLConfig> const& gl_config)
 {
-    return make_module_ptr<mgm::Display>(drm, gbm, vt, bypass_option_, initial_conf_policy, gl_config, listener);
+    return make_module_ptr<mgm::Display>(
+        drm,
+        gbm,
+        vt,
+        bypass_option_,
+        initial_conf_policy,
+        gl_config,
+        listener);
 }
 
 mir::UniqueModulePtr<mg::PlatformIpcOperations> mgm::Platform::make_ipc_operations() const
 {
-    return make_module_ptr<mgm::IpcOperations>(drm);
+    return make_module_ptr<mgm::IpcOperations>(drm.front());
 }
 
 mg::NativePlatform* mgm::Platform::native_platform()

=== modified file 'src/platforms/mesa/server/kms/platform.h'
--- src/platforms/mesa/server/kms/platform.h	2017-03-16 07:37:11 +0000
+++ src/platforms/mesa/server/kms/platform.h	2017-03-22 06:55:00 +0000
@@ -56,7 +56,7 @@
     EGLNativeDisplayType egl_native_display() const override;
 
     std::shared_ptr<mir::udev::Context> udev;
-    std::shared_ptr<helpers::DRMHelper> const drm;
+    std::vector<std::shared_ptr<helpers::DRMHelper>> const drm;
     std::shared_ptr<helpers::GBMHelper> const gbm;
 
     std::shared_ptr<DisplayReport> const listener;

=== modified file 'src/platforms/mesa/server/kms/real_kms_display_configuration.cpp'
--- src/platforms/mesa/server/kms/real_kms_display_configuration.cpp	2017-03-14 02:26:28 +0000
+++ src/platforms/mesa/server/kms/real_kms_display_configuration.cpp	2017-03-22 06:55:00 +0000
@@ -17,9 +17,10 @@
  */
 
 #include "real_kms_display_configuration.h"
-#include "kms-utils/drm_mode_resources.h"
 #include "mir/graphics/pixel_format_utils.h"
 #include "mir/log.h"
+#include "kms_output_container.h"
+#include "kms_output.h"
 
 #include <cmath>
 #include <limits>
@@ -35,77 +36,21 @@
 namespace mgk = mir::graphics::kms;
 namespace geom = mir::geometry;
 
-namespace
-{
-
-bool kms_modes_are_equal(drmModeModeInfo const& info1, drmModeModeInfo const& info2)
-{
-    return (info1.clock == info2.clock &&
-            info1.hdisplay == info2.hdisplay &&
-            info1.hsync_start == info2.hsync_start &&
-            info1.hsync_end == info2.hsync_end &&
-            info1.htotal == info2.htotal &&
-            info1.hskew == info2.hskew &&
-            info1.vdisplay == info2.vdisplay &&
-            info1.vsync_start == info2.vsync_start &&
-            info1.vsync_end == info2.vsync_end &&
-            info1.vtotal == info2.vtotal);
-}
-
-double calculate_vrefresh_hz(drmModeModeInfo const& mode)
-{
-    if (mode.htotal == 0 || mode.vtotal == 0)
-        return 0.0;
-
-    /* mode.clock is in KHz */
-    double hz = (mode.clock * 100000LL /
-                 ((long)mode.htotal * (long)mode.vtotal)
-                ) / 100.0;
-
-    // Actually we don't need floating point at all for this...
-    // TODO: Consider converting our structs to fixed-point ints
-    return hz;
-}
-
-mg::DisplayConfigurationOutputType
-kms_connector_type_to_output_type(uint32_t connector_type)
-{
-    return static_cast<mg::DisplayConfigurationOutputType>(connector_type);
-}
-
-MirSubpixelArrangement kms_subpixel_to_mir_subpixel(uint32_t subpixel)
-{
-    switch (subpixel)
-    {
-    case DRM_MODE_SUBPIXEL_UNKNOWN:
-        return mir_subpixel_arrangement_unknown;
-    case DRM_MODE_SUBPIXEL_HORIZONTAL_RGB:
-        return mir_subpixel_arrangement_horizontal_rgb;
-    case DRM_MODE_SUBPIXEL_HORIZONTAL_BGR:
-        return mir_subpixel_arrangement_horizontal_bgr;
-    case DRM_MODE_SUBPIXEL_VERTICAL_RGB:
-        return mir_subpixel_arrangement_vertical_rgb;
-    case DRM_MODE_SUBPIXEL_VERTICAL_BGR:
-        return mir_subpixel_arrangement_vertical_bgr;
-    case DRM_MODE_SUBPIXEL_NONE:
-        return mir_subpixel_arrangement_none;
-    default:
-        return mir_subpixel_arrangement_unknown;
-    }
-}
-
-}
-
-mgm::RealKMSDisplayConfiguration::RealKMSDisplayConfiguration(int drm_fd)
-    : drm_fd{drm_fd}
+mgm::RealKMSDisplayConfiguration::RealKMSDisplayConfiguration(
+    std::shared_ptr<KMSOutputContainer> const& displays)
+    : displays{displays},
+      card{mg::DisplayConfigurationCardId{0}, 0}
 {
     update();
 }
 
 mgm::RealKMSDisplayConfiguration::RealKMSDisplayConfiguration(
     RealKMSDisplayConfiguration const& conf)
-    : KMSDisplayConfiguration(), drm_fd{conf.drm_fd},
-      card(conf.card), outputs{conf.outputs}
+    : KMSDisplayConfiguration(),
+      displays{conf.displays},
+    // Vivid GCC is apparently confused by trying to copy-construct card from conf.card?
+      card{conf.card.id, conf.card.max_simultaneous_outputs},
+      outputs{conf.outputs}
 {
 }
 
@@ -114,7 +59,7 @@
 {
     if (&conf != this)
     {
-        drm_fd = conf.drm_fd;
+        displays = conf.displays;
         card = conf.card;
         outputs = conf.outputs;
     }
@@ -131,16 +76,16 @@
 void mgm::RealKMSDisplayConfiguration::for_each_output(
     std::function<void(DisplayConfigurationOutput const&)> f) const
 {
-    for (auto const& output : outputs)
-        f(output);
+    for (auto const& output_pair : outputs)
+        f(output_pair.first);
 }
 
 void mgm::RealKMSDisplayConfiguration::for_each_output(
     std::function<void(UserDisplayConfigurationOutput&)> f)
 {
-    for (auto& output : outputs)
+    for (auto& output_pair : outputs)
     {
-        UserDisplayConfigurationOutput user(output);
+        UserDisplayConfigurationOutput user(output_pair.first);
         f(user);
     }
 }
@@ -150,233 +95,87 @@
     return std::make_unique<RealKMSDisplayConfiguration>(*this);
 }
 
-uint32_t mgm::RealKMSDisplayConfiguration::get_kms_connector_id(
+std::shared_ptr<mgm::KMSOutput> mgm::RealKMSDisplayConfiguration::get_output_for(
     DisplayConfigurationOutputId id) const
 {
-    auto iter = find_output_with_id(id);
-
-    if (iter == outputs.end())
-    {
-        BOOST_THROW_EXCEPTION(
-            std::runtime_error("Failed to find DisplayConfigurationOutput with provided id"));
-    }
-
-    return id.as_value();
+    return outputs.at(id.as_value()).second;
 }
 
 size_t mgm::RealKMSDisplayConfiguration::get_kms_mode_index(
     DisplayConfigurationOutputId id,
     size_t conf_mode_index) const
 {
-    auto iter = find_output_with_id(id);
-
-    if (iter == outputs.end() || conf_mode_index >= iter->modes.size())
-    {
-        BOOST_THROW_EXCEPTION(
-            std::runtime_error("Failed to find valid mode index for DisplayConfigurationOutput with provided id/mode_index"));
+    if (static_cast<size_t>(id.as_value()) > outputs.size())
+    {
+        BOOST_THROW_EXCEPTION(std::invalid_argument("Request for KMS mode index of invalid output ID"));
+    }
+    if (conf_mode_index > outputs[id.as_value()].first.modes.size())
+    {
+        BOOST_THROW_EXCEPTION(std::invalid_argument("Request for out-of-bounds KMS mode index"));
     }
 
     return conf_mode_index;
 }
 
+namespace
+{
+void populate_default_mir_config(mg::DisplayConfigurationOutput& to_populate)
+{
+    to_populate.card_id = mg::DisplayConfigurationCardId{0};
+    to_populate.gamma_supported = mir_output_gamma_supported;
+    to_populate.orientation = mir_orientation_normal;
+    to_populate.form_factor = mir_form_factor_monitor;
+    to_populate.scale = 1.0f;
+    to_populate.top_left = geom::Point{};
+    to_populate.used = false;
+    to_populate.pixel_formats = {mir_pixel_format_xrgb_8888, mir_pixel_format_argb_8888};
+    to_populate.current_format = mir_pixel_format_xrgb_8888;
+    to_populate.current_mode_index = std::numeric_limits<uint32_t>::max();
+}
+}
+
 void mgm::RealKMSDisplayConfiguration::update()
 {
-    kms::DRMModeResources resources{drm_fd};
-
-    size_t max_outputs = std::min(resources.num_crtcs(), resources.num_connectors());
-    card = {DisplayConfigurationCardId{0}, max_outputs};
-
-    resources.for_each_connector([&](kms::DRMModeConnectorUPtr connector)
-    {
-        add_or_update_output(resources, *connector);
-    });
-}
-
-namespace
-{
-std::vector<uint8_t> edid_for_connector(int drm_fd, uint32_t connector_id)
-{
-    std::vector<uint8_t> edid;
-
-    mgk::ObjectProperties connector_props{
-        drm_fd, connector_id, DRM_MODE_OBJECT_CONNECTOR};
-
-    if (connector_props.has_property("EDID"))
-    {
-        /*
-         * We don't technically need the property information here, but query it
-         * anyway so we can detect if our assumptions about DRM behaviour
-         * become invalid.
-         */
-        auto property = mgk::DRMModePropertyUPtr{
-            drmModeGetProperty(drm_fd, connector_props.id_for("EDID")),
-            &drmModeFreeProperty};
-
-        if (!property)
-        {
-            mir::log_warning(
-                "Failed to get EDID property for connector %u: %i (%s)",
-                connector_id,
-                errno,
-                ::strerror(errno));
-            return edid;
-        }
-
-        if (!drm_property_type_is(property.get(), DRM_MODE_PROP_BLOB))
-        {
-            mir::log_warning(
-                "EDID property on connector %u has unexpected type %u",
-                connector_id,
-                property->flags);
-            return edid;
-        }
-
-        // A property ID of 0 means invalid.
-        if (connector_props["EDID"] == 0)
-        {
-            /*
-             * Log a debug message only. This will trigger for broken monitors which
-             * don't provide an EDID, which is not as unusual as you might think...
-             */
-            mir::log_debug("No EDID data available on connector %u", connector_id);
-            return edid;
-        }
-
-        auto blob = drmModeGetPropertyBlob(drm_fd, connector_props["EDID"]);
-
-        if (!blob)
-        {
-            mir::log_warning(
-                "Failed to get EDID property blob for connector %u: %i (%s)",
-                connector_id,
-                errno,
-                ::strerror(errno));
-
-            return edid;
-        }
-
-        edid.reserve(blob->length);
-        edid.insert(edid.begin(),
-            reinterpret_cast<uint8_t*>(blob->data),
-            reinterpret_cast<uint8_t*>(blob->data) + blob->length);
-
-        drmModeFreePropertyBlob(blob);
-
-        edid.shrink_to_fit();
-    }
-
-    return edid;
-}
-}
-
-void mgm::RealKMSDisplayConfiguration::add_or_update_output(
-    kms::DRMModeResources const& resources,
-    drmModeConnector const& connector)
-{
-    DisplayConfigurationOutputId id{static_cast<int>(connector.connector_id)};
-    DisplayConfigurationCardId card_id{0};
-    DisplayConfigurationOutputType const type{
-        kms_connector_type_to_output_type(connector.connector_type)};
-    geom::Size physical_size{connector.mmWidth, connector.mmHeight};
-    bool connected{connector.connection == DRM_MODE_CONNECTED};
-    uint32_t const invalid_mode_index = std::numeric_limits<uint32_t>::max();
-    uint32_t current_mode_index{invalid_mode_index};
-    uint32_t preferred_mode_index{invalid_mode_index};
-    std::vector<DisplayConfigurationMode> modes;
-    std::vector<MirPixelFormat> formats {mir_pixel_format_argb_8888,
-                                         mir_pixel_format_xrgb_8888};
-
-    std::vector<uint8_t> edid;
-    if (connected)
-    {
-        /* Only ask for the EDID on connected outputs. There's obviously no monitor EDID
-         * when there is no monitor connected!
-         */
-        edid = edid_for_connector(drm_fd, connector.connector_id);
-    }
-
-    drmModeModeInfo current_mode_info = drmModeModeInfo();
-    GammaCurves gamma;
-
-    /* Get information about the current mode */
-    if (connector.encoder_id)
-    {
-        auto encoder = resources.encoder(connector.encoder_id);
-        if (encoder->crtc_id)
-        {
-            auto crtc = resources.crtc(encoder->crtc_id);
-            current_mode_info = crtc->mode;
-
-            if (crtc->gamma_size > 0)
-                gamma = mg::LinearGammaLUTs(crtc->gamma_size);
-        }
-    }
-
-    /* Add all the available modes and find the current and preferred one */
-    for (int m = 0; m < connector.count_modes; m++)
-    {
-        drmModeModeInfo& mode_info = connector.modes[m];
-
-        geom::Size size{mode_info.hdisplay, mode_info.vdisplay};
-
-        double vrefresh_hz = calculate_vrefresh_hz(mode_info);
-
-        modes.push_back({size, vrefresh_hz});
-
-        if (kms_modes_are_equal(mode_info, current_mode_info))
-            current_mode_index = m;
-
-        if ((mode_info.type & DRM_MODE_TYPE_PREFERRED) == DRM_MODE_TYPE_PREFERRED)
-            preferred_mode_index = m;
-    }
-
-    /* Add or update the output */
-    auto iter = find_output_with_id(id);
-
-    if (iter == outputs.end())
-    {
-        outputs.push_back({id, card_id, type, formats, modes, preferred_mode_index,
-                           physical_size, connected, false, geom::Point(),
-                           current_mode_index, mir_pixel_format_xrgb_8888,
-                           mir_power_mode_on, mir_orientation_normal,
-                           1.0f, mir_form_factor_monitor,
-                           kms_subpixel_to_mir_subpixel(connector.subpixel),
-                           gamma, mir_output_gamma_supported, std::move(edid)});
-    }
-    else
-    {
-        auto& output = *iter;
-
-        output.current_mode_index = current_mode_index;
-        output.modes = modes;
-        output.preferred_mode_index = preferred_mode_index;
-        output.physical_size_mm = physical_size;
-        output.connected = connected;
-        output.current_format = mir_pixel_format_xrgb_8888;
-        output.subpixel_arrangement = kms_subpixel_to_mir_subpixel(connector.subpixel);
-        output.gamma = gamma;
-        output.edid = edid;
-    }
-}
-
-std::vector<mg::DisplayConfigurationOutput>::iterator
-mgm::RealKMSDisplayConfiguration::find_output_with_id(mg::DisplayConfigurationOutputId id)
-{
-    return std::find_if(outputs.begin(), outputs.end(),
-                        [id](DisplayConfigurationOutput const& output)
-                        {
-                            return output.id == id;
-                        });
-}
-
-std::vector<mg::DisplayConfigurationOutput>::const_iterator
-mgm::RealKMSDisplayConfiguration::find_output_with_id(mg::DisplayConfigurationOutputId id) const
-{
-    return std::find_if(outputs.begin(), outputs.end(),
-                        [id](DisplayConfigurationOutput const& output)
-                        {
-                            return output.id == id;
-                        });
+    decltype(outputs) new_outputs;
+
+    int counter = 0;
+    displays->update_from_hardware_state();
+    displays->for_each_output(
+        [this, &new_outputs, &counter](auto const& output) mutable
+        {
+            DisplayConfigurationOutput mir_config;
+
+            auto const existing_output = std::find_if(
+                outputs.begin(),
+                outputs.end(),
+                [&output](auto const& candidate)
+                {
+                    // Pointer comparison; is this KMSOutput object already present?
+                    return candidate.second == output;
+                });
+            if (existing_output == outputs.end())
+            {
+                populate_default_mir_config(mir_config);
+            }
+            else
+            {
+                mir_config = existing_output->first;
+            }
+
+            output->update_from_hardware_state(mir_config);
+            mir_config.id = DisplayConfigurationOutputId{counter};
+            counter++;
+
+            new_outputs.push_back(std::make_pair(mir_config, output));
+        });
+
+    outputs = new_outputs;
+
+    /*
+     * This is not the true max simultaneous outputs, but it's unclear whether it's possible
+     * to provide a max_simultaneous_outputs value that is useful to clients.
+     */
+    card.max_simultaneous_outputs = outputs.size();
 }
 
 // Compatibility means conf1 can be attained from conf2 (and vice versa)
@@ -386,9 +185,9 @@
 // to be allocated/destroyed, and hence should not be considered compatible.
 bool mgm::compatible(mgm::RealKMSDisplayConfiguration const& conf1, mgm::RealKMSDisplayConfiguration const& conf2)
 {
-    bool compatible{(conf1.drm_fd         == conf2.drm_fd) &&
-                    (conf1.card           == conf2.card)   &&
-                    (conf1.outputs.size() == conf2.outputs.size())};
+    bool compatible{
+        (conf1.card           == conf2.card)   &&
+        (conf1.outputs.size() == conf2.outputs.size())};
 
     if (compatible)
     {
@@ -396,17 +195,17 @@
 
         for (unsigned int i = 0; i < count; ++i)
         {
-            compatible &= (conf1.outputs[i].power_mode == conf2.outputs[i].power_mode);
+            compatible &= (conf1.outputs[i].first.power_mode == conf2.outputs[i].first.power_mode);
             if (compatible)
             {
-                auto clone = conf2.outputs[i];
+                auto clone = conf2.outputs[i].first;
 
                 // ignore difference in orientation, scale factor, form factor, subpixel arrangement
-                clone.orientation = conf1.outputs[i].orientation;
-                clone.subpixel_arrangement = conf1.outputs[i].subpixel_arrangement;
-                clone.scale = conf1.outputs[i].scale;
-                clone.form_factor = conf1.outputs[i].form_factor;
-                compatible &= (conf1.outputs[i] == clone);
+                clone.orientation = conf1.outputs[i].first.orientation;
+                clone.subpixel_arrangement = conf1.outputs[i].first.subpixel_arrangement;
+                clone.scale = conf1.outputs[i].first.scale;
+                clone.form_factor = conf1.outputs[i].first.form_factor;
+                compatible &= (conf1.outputs[i].first == clone);
             }
             else
             	break;

=== modified file 'src/platforms/mesa/server/kms/real_kms_display_configuration.h'
--- src/platforms/mesa/server/kms/real_kms_display_configuration.h	2017-01-18 02:29:37 +0000
+++ src/platforms/mesa/server/kms/real_kms_display_configuration.h	2017-03-22 06:55:00 +0000
@@ -30,13 +30,15 @@
 {
 namespace mesa
 {
+class KMSOutput;
+class KMSOutputContainer;
 
 class RealKMSDisplayConfiguration : public KMSDisplayConfiguration
 {
 friend bool compatible(RealKMSDisplayConfiguration const& conf1, RealKMSDisplayConfiguration const& conf2);
 
 public:
-    RealKMSDisplayConfiguration(int drm_fd);
+    RealKMSDisplayConfiguration(std::shared_ptr<KMSOutputContainer> const& displays);
     RealKMSDisplayConfiguration(RealKMSDisplayConfiguration const& conf);
     RealKMSDisplayConfiguration& operator=(RealKMSDisplayConfiguration const& conf);
 
@@ -45,18 +47,15 @@
     void for_each_output(std::function<void(UserDisplayConfigurationOutput&)> f) override;
     std::unique_ptr<DisplayConfiguration> clone() const override;
 
-    uint32_t get_kms_connector_id(DisplayConfigurationOutputId id) const override;
+    std::shared_ptr<KMSOutput> get_output_for(DisplayConfigurationOutputId id) const override;
     size_t get_kms_mode_index(DisplayConfigurationOutputId id, size_t conf_mode_index) const override;
     void update() override;
 
 private:
-    void add_or_update_output(kms::DRMModeResources const& resources, drmModeConnector const& connector);
-    std::vector<DisplayConfigurationOutput>::iterator find_output_with_id(DisplayConfigurationOutputId id);
-    std::vector<DisplayConfigurationOutput>::const_iterator find_output_with_id(DisplayConfigurationOutputId id) const;
 
-    int drm_fd;
+    std::shared_ptr<KMSOutputContainer> displays;
     DisplayConfigurationCard card;
-    std::vector<DisplayConfigurationOutput> outputs;
+    std::vector<std::pair< DisplayConfigurationOutput, std::shared_ptr<KMSOutput>>> outputs;
 };
 
 bool compatible(RealKMSDisplayConfiguration const& conf1, RealKMSDisplayConfiguration const& conf2);

=== modified file 'src/platforms/mesa/server/kms/real_kms_output.cpp'
--- src/platforms/mesa/server/kms/real_kms_output.cpp	2017-03-13 08:12:52 +0000
+++ src/platforms/mesa/server/kms/real_kms_output.cpp	2017-03-22 06:55:00 +0000
@@ -17,6 +17,7 @@
  */
 
 #include "real_kms_output.h"
+#include "mir/graphics/display_configuration.h"
 #include "page_flipper.h"
 #include "kms-utils/kms_connector.h"
 #include "mir/fatal.h"
@@ -68,20 +69,27 @@
 
 }
 
-mgm::RealKMSOutput::RealKMSOutput(int drm_fd, uint32_t connector_id,
-                                  std::shared_ptr<PageFlipper> const& page_flipper)
-    : drm_fd{drm_fd}, connector_id{connector_id}, page_flipper{page_flipper},
-      connector(), mode_index{0}, current_crtc(), saved_crtc(),
-      using_saved_crtc{true}, has_cursor_{false},
+mgm::RealKMSOutput::RealKMSOutput(
+    int drm_fd,
+    kms::DRMModeConnectorUPtr&& connector,
+    std::shared_ptr<PageFlipper> const& page_flipper)
+    : drm_fd_{drm_fd},
+      page_flipper{page_flipper},
+      connector{std::move(connector)},
+      mode_index{0},
+      current_crtc(),
+      saved_crtc(),
+      using_saved_crtc{true},
+      has_cursor_{false},
       power_mode(mir_power_mode_on)
 {
     reset();
 
-    kms::DRMModeResources resources{drm_fd};
+    kms::DRMModeResources resources{drm_fd_};
 
-    if (connector->encoder_id)
+    if (this->connector->encoder_id)
     {
-        auto encoder = resources.encoder(connector->encoder_id);
+        auto encoder = resources.encoder(this->connector->encoder_id);
         if (encoder->crtc_id)
         {
             saved_crtc = *resources.crtc(encoder->crtc_id);
@@ -94,14 +102,19 @@
     restore_saved_crtc();
 }
 
+uint32_t mgm::RealKMSOutput::id() const
+{
+    return connector->connector_id;
+}
+
 void mgm::RealKMSOutput::reset()
 {
-    kms::DRMModeResources resources{drm_fd};
+    kms::DRMModeResources resources{drm_fd_};
 
     /* Update the connector to ensure we have the latest information */
     try
     {
-        connector = resources.connector(connector_id);
+        connector = resources.connector(connector->connector_id);
     }
     catch (std::exception const& e)
     {
@@ -111,7 +124,7 @@
     // TODO: What if we can't locate the DPMS property?
     for (int i = 0; i < connector->count_props; i++)
     {
-        auto prop = drmModeGetProperty(drm_fd, connector->props[i]);
+        auto prop = drmModeGetProperty(drm_fd_, connector->props[i]);
         if (prop && (prop->flags & DRM_MODE_PROP_ENUM)) {
             if (!strcmp(prop->name, "DPMS"))
             {
@@ -154,7 +167,7 @@
         return false;
     }
 
-    auto ret = drmModeSetCrtc(drm_fd, current_crtc->crtc_id,
+    auto ret = drmModeSetCrtc(drm_fd_, current_crtc->crtc_id,
                               fb.get_drm_fb_id(), fb_offset.dx.as_int(), fb_offset.dy.as_int(),
                               &connector->connector_id, 1,
                               &connector->modes[mode_index]);
@@ -185,7 +198,7 @@
         return;
     }
 
-    auto result = drmModeSetCrtc(drm_fd, current_crtc->crtc_id,
+    auto result = drmModeSetCrtc(drm_fd_, current_crtc->crtc_id,
                                  0, 0, 0, nullptr, 0, nullptr);
     if (result)
     {
@@ -207,7 +220,10 @@
                        mgk::connector_name(connector).c_str());
         return false;
     }
-    return page_flipper->schedule_flip(current_crtc->crtc_id, fb.get_drm_fb_id(), connector_id);
+    return page_flipper->schedule_flip(
+        current_crtc->crtc_id,
+        fb.get_drm_fb_id(),
+        connector->connector_id);
 }
 
 void mgm::RealKMSOutput::wait_for_page_flip()
@@ -236,7 +252,7 @@
     {
         has_cursor_ = true;
         result = drmModeSetCursor(
-                drm_fd,
+                drm_fd_,
                 current_crtc->crtc_id,
                 gbm_bo_get_handle(buffer).u32,
                 gbm_bo_get_width(buffer),
@@ -255,7 +271,7 @@
 {
     if (current_crtc)
     {
-        if (auto result = drmModeMoveCursor(drm_fd, current_crtc->crtc_id,
+        if (auto result = drmModeMoveCursor(drm_fd_, current_crtc->crtc_id,
                                             destination.x.as_uint32_t(),
                                             destination.y.as_uint32_t()))
         {
@@ -270,7 +286,7 @@
     int result = 0;
     if (current_crtc)
     {
-        result = drmModeSetCursor(drm_fd, current_crtc->crtc_id, 0, 0, 0);
+        result = drmModeSetCursor(drm_fd_, current_crtc->crtc_id, 0, 0, 0);
 
         if (result)
             mir::log_warning("clear_cursor: drmModeSetCursor failed (%s)",
@@ -296,7 +312,7 @@
     if (connector->connection != DRM_MODE_CONNECTED)
         return false;
 
-    current_crtc = mgk::find_crtc_for_connector(drm_fd, connector);
+    current_crtc = mgk::find_crtc_for_connector(drm_fd_, connector);
 
 
     return (current_crtc != nullptr);
@@ -306,7 +322,7 @@
 {
     if (!using_saved_crtc)
     {
-        drmModeSetCrtc(drm_fd, saved_crtc.crtc_id, saved_crtc.buffer_id,
+        drmModeSetCrtc(drm_fd_, saved_crtc.crtc_id, saved_crtc.buffer_id,
                        saved_crtc.x, saved_crtc.y,
                        &connector->connector_id, 1, &saved_crtc.mode);
 
@@ -321,8 +337,11 @@
     if (power_mode != mode)
     {
         power_mode = mode;
-        drmModeConnectorSetProperty(drm_fd, connector_id,
-                                   dpms_enum_id, mode);
+        drmModeConnectorSetProperty(
+            drm_fd_,
+            connector->connector_id,
+            dpms_enum_id,
+            mode);
     }
 }
 
@@ -343,7 +362,7 @@
     }
 
     int ret = drmModeCrtcSetGamma(
-        drm_fd,
+        drm_fd_,
         current_crtc->crtc_id,
         gamma.red.size(),
         const_cast<uint16_t*>(gamma.red.data()),
@@ -357,6 +376,218 @@
     // TODO: return bool in future? Then do what with it?
 }
 
+void mgm::RealKMSOutput::refresh_hardware_state()
+{
+    connector = kms::get_connector(drm_fd_, connector->connector_id);
+    current_crtc = nullptr;
+
+    if (connector->encoder_id)
+    {
+        auto encoder = kms::get_encoder(drm_fd_, connector->encoder_id);
+
+        if (encoder->crtc_id)
+        {
+            current_crtc = kms::get_crtc(drm_fd_, encoder->crtc_id);
+        }
+    }
+}
+
+    namespace
+{
+
+bool kms_modes_are_equal(drmModeModeInfo const& info1, drmModeModeInfo const& info2)
+{
+    return (info1.clock == info2.clock &&
+            info1.hdisplay == info2.hdisplay &&
+            info1.hsync_start == info2.hsync_start &&
+            info1.hsync_end == info2.hsync_end &&
+            info1.htotal == info2.htotal &&
+            info1.hskew == info2.hskew &&
+            info1.vdisplay == info2.vdisplay &&
+            info1.vsync_start == info2.vsync_start &&
+            info1.vsync_end == info2.vsync_end &&
+            info1.vtotal == info2.vtotal);
+}
+
+double calculate_vrefresh_hz(drmModeModeInfo const& mode)
+{
+    if (mode.htotal == 0 || mode.vtotal == 0)
+        return 0.0;
+
+    /* mode.clock is in KHz */
+    double hz = (mode.clock * 100000LL /
+                 ((long)mode.htotal * (long)mode.vtotal)
+                ) / 100.0;
+
+    // Actually we don't need floating point at all for this...
+    // TODO: Consider converting our structs to fixed-point ints
+    return hz;
+}
+
+mg::DisplayConfigurationOutputType
+kms_connector_type_to_output_type(uint32_t connector_type)
+{
+    return static_cast<mg::DisplayConfigurationOutputType>(connector_type);
+}
+
+MirSubpixelArrangement kms_subpixel_to_mir_subpixel(uint32_t subpixel)
+{
+    switch (subpixel)
+    {
+        case DRM_MODE_SUBPIXEL_UNKNOWN:
+            return mir_subpixel_arrangement_unknown;
+        case DRM_MODE_SUBPIXEL_HORIZONTAL_RGB:
+            return mir_subpixel_arrangement_horizontal_rgb;
+        case DRM_MODE_SUBPIXEL_HORIZONTAL_BGR:
+            return mir_subpixel_arrangement_horizontal_bgr;
+        case DRM_MODE_SUBPIXEL_VERTICAL_RGB:
+            return mir_subpixel_arrangement_vertical_rgb;
+        case DRM_MODE_SUBPIXEL_VERTICAL_BGR:
+            return mir_subpixel_arrangement_vertical_bgr;
+        case DRM_MODE_SUBPIXEL_NONE:
+            return mir_subpixel_arrangement_none;
+        default:
+            return mir_subpixel_arrangement_unknown;
+    }
+}
+
+std::vector<uint8_t> edid_for_connector(int drm_fd, uint32_t connector_id)
+{
+    std::vector<uint8_t> edid;
+
+    mgk::ObjectProperties connector_props{
+        drm_fd, connector_id, DRM_MODE_OBJECT_CONNECTOR};
+
+    if (connector_props.has_property("EDID"))
+    {
+        /*
+         * We don't technically need the property information here, but query it
+         * anyway so we can detect if our assumptions about DRM behaviour
+         * become invalid.
+         */
+        auto property = mgk::DRMModePropertyUPtr{
+            drmModeGetProperty(drm_fd, connector_props.id_for("EDID")),
+            &drmModeFreeProperty};
+
+        if (!property)
+        {
+            mir::log_warning(
+                "Failed to get EDID property for connector %u: %i (%s)",
+                connector_id,
+                errno,
+                ::strerror(errno));
+            return edid;
+        }
+
+        if (!drm_property_type_is(property.get(), DRM_MODE_PROP_BLOB))
+        {
+            mir::log_warning(
+                "EDID property on connector %u has unexpected type %u",
+                connector_id,
+                property->flags);
+            return edid;
+        }
+
+        // A property ID of 0 means invalid.
+        if (connector_props["EDID"] == 0)
+        {
+            /*
+             * Log a debug message only. This will trigger for broken monitors which
+             * don't provide an EDID, which is not as unusual as you might think...
+             */
+            mir::log_debug("No EDID data available on connector %u", connector_id);
+            return edid;
+        }
+
+        auto blob = drmModeGetPropertyBlob(drm_fd, connector_props["EDID"]);
+
+        if (!blob)
+        {
+            mir::log_warning(
+                "Failed to get EDID property blob for connector %u: %i (%s)",
+                connector_id,
+                errno,
+                ::strerror(errno));
+
+            return edid;
+        }
+
+        edid.reserve(blob->length);
+        edid.insert(edid.begin(),
+                    reinterpret_cast<uint8_t*>(blob->data),
+                    reinterpret_cast<uint8_t*>(blob->data) + blob->length);
+
+        drmModeFreePropertyBlob(blob);
+
+        edid.shrink_to_fit();
+    }
+
+    return edid;
+}
+}
+
+void mgm::RealKMSOutput::update_from_hardware_state(
+    DisplayConfigurationOutput& output) const
+{
+    DisplayConfigurationOutputType const type{
+        kms_connector_type_to_output_type(connector->connector_type)};
+    geom::Size physical_size{connector->mmWidth, connector->mmHeight};
+    bool connected{connector->connection == DRM_MODE_CONNECTED};
+    uint32_t const invalid_mode_index = std::numeric_limits<uint32_t>::max();
+    uint32_t current_mode_index{invalid_mode_index};
+    uint32_t preferred_mode_index{invalid_mode_index};
+    std::vector<DisplayConfigurationMode> modes;
+    std::vector<MirPixelFormat> formats{mir_pixel_format_argb_8888,
+                                        mir_pixel_format_xrgb_8888};
+
+    std::vector<uint8_t> edid;
+    if (connected) {
+        /* Only ask for the EDID on connected outputs. There's obviously no monitor EDID
+         * when there is no monitor connected!
+         */
+        edid = edid_for_connector(drm_fd_, connector->connector_id);
+    }
+
+    drmModeModeInfo current_mode_info = drmModeModeInfo();
+    GammaCurves gamma;
+
+    /* Get information about the current mode */
+    if (current_crtc) {
+        current_mode_info = current_crtc->mode;
+
+        if (current_crtc->gamma_size > 0)
+            gamma = mg::LinearGammaLUTs(current_crtc->gamma_size);
+    }
+
+    /* Add all the available modes and find the current and preferred one */
+    for (int m = 0; m < connector->count_modes; m++) {
+        drmModeModeInfo &mode_info = connector->modes[m];
+
+        geom::Size size{mode_info.hdisplay, mode_info.vdisplay};
+
+        double vrefresh_hz = calculate_vrefresh_hz(mode_info);
+
+        modes.push_back({size, vrefresh_hz});
+
+        if (kms_modes_are_equal(mode_info, current_mode_info))
+            current_mode_index = m;
+
+        if ((mode_info.type & DRM_MODE_TYPE_PREFERRED) == DRM_MODE_TYPE_PREFERRED)
+            preferred_mode_index = m;
+    }
+
+    output.type = type;
+    output.modes = modes;
+    output.preferred_mode_index = preferred_mode_index;
+    output.physical_size_mm = physical_size;
+    output.connected = connected;
+    output.current_format = mir_pixel_format_xrgb_8888;
+    output.current_mode_index = current_mode_index;
+    output.subpixel_arrangement = kms_subpixel_to_mir_subpixel(connector->subpixel);
+    output.gamma = gamma;
+    output.edid = edid;
+}
+
 mgm::FBHandle* mgm::RealKMSOutput::fb_for(gbm_bo* bo, uint32_t width, uint32_t height) const
 {
     if (!bo)
@@ -386,7 +617,7 @@
         format = GBM_FORMAT_ARGB8888;
 
     /* Create a KMS FB object with the gbm_bo attached to it. */
-    auto ret = drmModeAddFB2(drm_fd, width, height, format,
+    auto ret = drmModeAddFB2(drm_fd_, width, height, format,
                              handles, strides, offsets, &fb_id, 0);
     if (ret)
         return nullptr;
@@ -397,3 +628,20 @@
 
     return bufobj;
 }
+
+bool mgm::RealKMSOutput::buffer_requires_migration(gbm_bo* bo) const
+{
+    /*
+     * It's possible that some devices will not require migration -
+     * Intel GPUs can obviously scanout from main memory, as can USB outputs such as
+     * DisplayLink.
+     *
+     * For a first go, just say that *every* device scans out of GPU-private memory.
+     */
+    return gbm_device_get_fd(gbm_bo_get_device(bo)) != drm_fd_;
+}
+
+int mgm::RealKMSOutput::drm_fd() const
+{
+    return drm_fd_;
+}

=== modified file 'src/platforms/mesa/server/kms/real_kms_output.h'
--- src/platforms/mesa/server/kms/real_kms_output.h	2017-03-13 08:12:52 +0000
+++ src/platforms/mesa/server/kms/real_kms_output.h	2017-03-22 06:55:00 +0000
@@ -38,10 +38,14 @@
 class RealKMSOutput : public KMSOutput
 {
 public:
-    RealKMSOutput(int drm_fd, uint32_t connector_id,
-                  std::shared_ptr<PageFlipper> const& page_flipper);
+    RealKMSOutput(
+        int drm_fd,
+        kms::DRMModeConnectorUPtr&& connector,
+        std::shared_ptr<PageFlipper> const& page_flipper);
     ~RealKMSOutput();
 
+    uint32_t id() const override;
+
     void reset() override;
     void configure(geometry::Displacement fb_offset, size_t kms_mode_index) override;
     geometry::Size size() const override;
@@ -62,14 +66,18 @@
 
     Frame last_frame() const override;
 
+    void refresh_hardware_state() override;
+    void update_from_hardware_state(DisplayConfigurationOutput& output) const override;
+
     FBHandle* fb_for(gbm_bo* bo, uint32_t width, uint32_t height) const override;
 
+    bool buffer_requires_migration(gbm_bo* bo) const override;
+    int drm_fd() const override;
 private:
     bool ensure_crtc();
     void restore_saved_crtc();
 
-    int const drm_fd;
-    uint32_t const connector_id;
+    int const drm_fd_;
     std::shared_ptr<PageFlipper> const page_flipper;
 
     kms::DRMModeConnectorUPtr connector;

=== modified file 'src/platforms/mesa/server/kms/real_kms_output_container.cpp'
--- src/platforms/mesa/server/kms/real_kms_output_container.cpp	2016-01-29 08:18:22 +0000
+++ src/platforms/mesa/server/kms/real_kms_output_container.cpp	2017-03-22 06:55:00 +0000
@@ -16,39 +16,68 @@
  * Authored by: Alexandros Frantzis <[e-mail]>
  */
 
+#include <algorithm>
 #include "real_kms_output_container.h"
 #include "real_kms_output.h"
+#include "kms-utils/drm_mode_resources.h"
 
 namespace mgm = mir::graphics::mesa;
 
 mgm::RealKMSOutputContainer::RealKMSOutputContainer(
-    int drm_fd, std::shared_ptr<PageFlipper> const& page_flipper)
-    : drm_fd{drm_fd},
-      page_flipper{page_flipper}
-{
-}
-
-std::shared_ptr<mgm::KMSOutput>
-mgm::RealKMSOutputContainer::get_kms_output_for(uint32_t connector_id)
-{
-    std::shared_ptr<KMSOutput> output;
-
-    auto output_iter = outputs.find(connector_id);
-    if (output_iter == outputs.end())
-    {
-        output = std::make_shared<RealKMSOutput>(drm_fd, connector_id, page_flipper);
-        outputs[connector_id] = output;
-    }
-    else
-    {
-        output = output_iter->second;
-    }
-
-    return output;
-}
-
-void mgm::RealKMSOutputContainer::for_each_output(std::function<void(KMSOutput&)> functor) const
-{
-    for(auto& pair: outputs)
-        functor(*pair.second);
+    std::vector<int> const& drm_fds,
+    std::function<std::shared_ptr<PageFlipper>(int)> const& construct_page_flipper)
+    : drm_fds{drm_fds},
+      construct_page_flipper{construct_page_flipper}
+{
+}
+
+void mgm::RealKMSOutputContainer::for_each_output(std::function<void(std::shared_ptr<KMSOutput> const&)> functor) const
+{
+    for(auto& output: outputs)
+        functor(output);
+}
+
+void mgm::RealKMSOutputContainer::update_from_hardware_state()
+{
+    decltype(outputs) new_outputs;
+
+    for (auto drm_fd : drm_fds)
+    {
+        kms::DRMModeResources resources{drm_fd};
+
+
+        for (auto &&connector : resources.connectors())
+        {
+            // Caution: O(n²) here, but n is the number of outputs, so should
+            // conservatively be << 100.
+            auto existing_output = std::find_if(
+                outputs.begin(),
+                outputs.end(),
+                [&connector, drm_fd](auto const &candidate)
+                {
+                    return
+                        connector->connector_id == candidate->id() &&
+                        drm_fd == candidate->drm_fd();
+                });
+
+            if (existing_output != outputs.end())
+            {
+                // We could drop this down to O(n) by being smarter about moving out
+                // of the outputs vector.
+                //
+                // That's a bit of a faff, so just do the simple thing for now.
+                new_outputs.push_back(*existing_output);
+                new_outputs.back()->refresh_hardware_state();
+            }
+            else
+            {
+                new_outputs.push_back(std::make_shared<RealKMSOutput>(
+                    drm_fd,
+                    std::move(connector),
+                    construct_page_flipper(drm_fd)));
+            }
+        }
+
+    }
+    outputs = new_outputs;
 }

=== modified file 'src/platforms/mesa/server/kms/real_kms_output_container.h'
--- src/platforms/mesa/server/kms/real_kms_output_container.h	2016-01-29 08:18:22 +0000
+++ src/platforms/mesa/server/kms/real_kms_output_container.h	2017-03-22 06:55:00 +0000
@@ -20,7 +20,7 @@
 #define MIR_GRAPHICS_MESA_REAL_KMS_OUTPUT_CONTAINER_H_
 
 #include "kms_output_container.h"
-#include <unordered_map>
+#include <vector>
 
 namespace mir
 {
@@ -34,15 +34,17 @@
 class RealKMSOutputContainer : public KMSOutputContainer
 {
 public:
-    RealKMSOutputContainer(int drm_fd, std::shared_ptr<PageFlipper> const& page_flipper);
-
-    std::shared_ptr<KMSOutput> get_kms_output_for(uint32_t connector_id);
-    void for_each_output(std::function<void(KMSOutput&)> functor) const;
-
+    RealKMSOutputContainer(
+        std::vector<int> const& drm_fds,
+        std::function<std::shared_ptr<PageFlipper>(int drm_fd)> const& construct_page_flipper);
+
+    void for_each_output(std::function<void(std::shared_ptr<KMSOutput> const&)> functor) const override;
+
+    void update_from_hardware_state() override;
 private:
-    int const drm_fd;
-    std::unordered_map<uint32_t,std::shared_ptr<KMSOutput>> outputs;
-    std::shared_ptr<PageFlipper> const page_flipper;
+    std::vector<int> const drm_fds;
+    std::vector<std::shared_ptr<KMSOutput>> outputs;
+    std::function<std::shared_ptr<PageFlipper>(int drm_fd)> const construct_page_flipper;
 };
 
 }

=== modified file 'tests/acceptance-tests/test_client_input.cpp'
--- tests/acceptance-tests/test_client_input.cpp	2017-03-14 02:26:28 +0000
+++ tests/acceptance-tests/test_client_input.cpp	2017-03-22 06:55:00 +0000
@@ -1578,7 +1578,7 @@
 
     mt::Signal touchscreen_ready;
     fake_touch_screen->on_new_configuration_do(
-        [&touchscreen_ready, second_output](mi::InputDevice const& dev)
+        [&touchscreen_ready](mi::InputDevice const& dev)
         {
             auto ts = dev.get_touchscreen_settings();
             if (ts.is_set() && ts.value().output_id == second_output)
@@ -1650,7 +1650,7 @@
 
     mt::Signal touchscreen_ready;
     fake_touch_screen->on_new_configuration_do(
-        [&touchscreen_ready, second_output](mi::InputDevice const& dev)
+        [&touchscreen_ready](mi::InputDevice const& dev)
         {
             auto ts = dev.get_touchscreen_settings();
             if (ts.is_set()

=== modified file 'tests/include/mir/test/doubles/mock_drm.h'
--- tests/include/mir/test/doubles/mock_drm.h	2017-01-18 02:29:37 +0000
+++ tests/include/mir/test/doubles/mock_drm.h	2017-03-22 06:55:00 +0000
@@ -23,6 +23,7 @@
 
 #include <xf86drm.h>
 #include <xf86drmMode.h>
+#include <unordered_map>
 
 namespace mir
 {
@@ -154,12 +155,42 @@
     MOCK_METHOD6(drmModeCrtcSetGamma, int(int fd, uint32_t crtc_id, uint32_t size,
                                           uint16_t* red, uint16_t* green, uint16_t* blue));
 
-    FakeDRMResources fake_drm;
+
+    void add_crtc(
+        char const* device,
+        uint32_t id,
+        drmModeModeInfo mode);
+    void add_encoder(
+        char const* device,
+        uint32_t encoder_id,
+        uint32_t crtc_id,
+        uint32_t possible_crtcs_mask);
+    void add_connector(
+        char const* device,
+        uint32_t connector_id,
+        uint32_t type,
+        drmModeConnection connection,
+        uint32_t encoder_id,
+        std::vector<drmModeModeInfo>& modes,
+        std::vector<uint32_t>& possible_encoder_ids,
+        geometry::Size const& physical_size,
+        drmModeSubPixel subpixel_arrangement = DRM_MODE_SUBPIXEL_UNKNOWN);
+
+    void prepare(char const* device);
+    void reset(char const* device);
+
+    void generate_event_on(char const* device);
+
+    class IsFdOfDeviceMatcher;
+    friend class IsFdOfDeviceMatcher;
 
 private:
+    std::unordered_map<std::string, FakeDRMResources> fake_drms;
+    std::unordered_map<int, FakeDRMResources&> fd_to_drm;
     drmModeObjectProperties empty_object_props;
 };
 
+testing::Matcher<int> IsFdOfDevice(char const* device);
 }
 }
 }

=== modified file 'tests/include/mir/test/doubles/mock_gbm.h'
--- tests/include/mir/test/doubles/mock_gbm.h	2015-07-16 07:03:19 +0000
+++ tests/include/mir/test/doubles/mock_gbm.h	2017-03-22 06:55:00 +0000
@@ -80,6 +80,7 @@
     MOCK_METHOD3(gbm_bo_write, bool(struct gbm_bo *bo, const void *buf, size_t count));
     MOCK_METHOD1(gbm_bo_destroy, void(struct gbm_bo *bo));
     MOCK_METHOD4(gbm_bo_import, struct gbm_bo*(struct gbm_device*, uint32_t, void*, uint32_t));
+    MOCK_METHOD1(gbm_bo_get_fd, int(gbm_bo*));
 
     FakeGBMResources fake_gbm;
 

=== modified file 'tests/include/mir/test/doubles/mock_gl.h'
--- tests/include/mir/test/doubles/mock_gl.h	2016-06-30 13:41:11 +0000
+++ tests/include/mir/test/doubles/mock_gl.h	2017-03-22 06:55:00 +0000
@@ -110,6 +110,7 @@
                       const GLvoid *));
     MOCK_METHOD4(glViewport, void(GLint, GLint, GLsizei, GLsizei));
     MOCK_METHOD1(glGenerateMipmap, void(GLenum target));
+    MOCK_METHOD4(glDrawElements, void(GLenum, GLsizei, GLenum, const GLvoid*));
 };
 
 }

=== modified file 'tests/mir_test_doubles/mock_drm.cpp'
--- tests/mir_test_doubles/mock_drm.cpp	2017-01-18 02:29:37 +0000
+++ tests/mir_test_doubles/mock_drm.cpp	2017-03-22 06:55:00 +0000
@@ -24,6 +24,8 @@
 #include <stdexcept>
 #include <unistd.h>
 #include <dlfcn.h>
+#include <system_error>
+#include <boost/throw_exception.hpp>
 
 namespace mtd=mir::test::doubles;
 namespace geom = mir::geometry;
@@ -239,25 +241,60 @@
     memset(&empty_object_props, 0, sizeof(empty_object_props));
 
     ON_CALL(*this, open(_,_,_))
-    .WillByDefault(Return(fake_drm.fd()));
+        .WillByDefault(
+            WithArg<0>(
+                Invoke(
+                    [this](char const* device_path)
+                    {
+                        auto fd = fake_drms[device_path].fd();
+                        fd_to_drm.insert({fd, fake_drms[device_path]});
+                        return fd;
+                    })));
 
     ON_CALL(*this, drmOpen(_,_))
-    .WillByDefault(Return(fake_drm.fd()));
+        .WillByDefault(
+            InvokeWithoutArgs(
+                [this]()
+                {
+                    auto fd = fake_drms["/dev/dri/card0"].fd();
+                    fd_to_drm.insert({fd, fake_drms["/dev/dri/card0"]});
+                    return fd;
+                }));
 
     ON_CALL(*this, drmClose(_))
-    .WillByDefault(WithArg<0>(Invoke([&](int fd){ return close(fd); })));
+        .WillByDefault(Invoke([](int fd){ return close(fd); }));
 
     ON_CALL(*this, drmModeGetResources(_))
-    .WillByDefault(Return(fake_drm.resources_ptr()));
+        .WillByDefault(
+            Invoke(
+                [this](int fd)
+                {
+                    return fd_to_drm.at(fd).resources_ptr();
+                }));
 
     ON_CALL(*this, drmModeGetCrtc(_, _))
-    .WillByDefault(WithArgs<1>(Invoke(&fake_drm, &FakeDRMResources::find_crtc)));
+        .WillByDefault(
+            Invoke(
+                [this](int fd, uint32_t crtc_id)
+                {
+                    return fd_to_drm.at(fd).find_crtc(crtc_id);
+                }));
 
     ON_CALL(*this, drmModeGetEncoder(_, _))
-    .WillByDefault(WithArgs<1>(Invoke(&fake_drm, &FakeDRMResources::find_encoder)));
+        .WillByDefault(
+            Invoke(
+                [this](int fd, uint32_t encoder_id)
+                {
+                    return fd_to_drm.at(fd).find_encoder(encoder_id);
+                }));
 
     ON_CALL(*this, drmModeGetConnector(_, _))
-    .WillByDefault(WithArgs<1>(Invoke(&fake_drm, &FakeDRMResources::find_connector)));
+        .WillByDefault(
+            Invoke(
+                [this](int fd, uint32_t connector_id)
+                {
+                    return fd_to_drm.at(fd).find_connector(connector_id);
+                }));
 
     ON_CALL(*this, drmModeObjectGetProperties(_, _, _))
         .WillByDefault(Return(&empty_object_props));
@@ -277,6 +314,118 @@
     global_mock = nullptr;
 }
 
+void mtd::MockDRM::add_crtc(char const *device, uint32_t id, drmModeModeInfo mode)
+{
+    fake_drms[device].add_crtc(id, mode);
+}
+
+void mtd::MockDRM::add_encoder(
+    char const *device,
+    uint32_t encoder_id,
+    uint32_t crtc_id,
+    uint32_t possible_crtcs_mask)
+{
+    fake_drms[device].add_encoder(encoder_id, crtc_id, possible_crtcs_mask);
+}
+
+void mtd::MockDRM::prepare(char const *device)
+{
+    fake_drms[device].prepare();
+}
+
+void mtd::MockDRM::reset(char const *device)
+{
+    fake_drms[device].reset();
+}
+
+void mtd::MockDRM::generate_event_on(char const *device)
+{
+    auto const fd = fake_drms[device].write_fd();
+
+    if (write(fd, "a", 1) != 1)
+    {
+        BOOST_THROW_EXCEPTION(
+            std::system_error(errno, std::system_category(), "Failed to make fake DRM event"));
+    }
+}
+
+void mtd::MockDRM::add_connector(
+    char const *device,
+    uint32_t connector_id,
+    uint32_t type,
+    drmModeConnection connection,
+    uint32_t encoder_id,
+    std::vector<drmModeModeInfo> &modes,
+    std::vector<uint32_t> &possible_encoder_ids,
+    geometry::Size const &physical_size,
+    drmModeSubPixel subpixel_arrangement)
+{
+    fake_drms[device].add_connector(
+        connector_id,
+        type,
+        connection,
+        encoder_id,
+        modes,
+        possible_encoder_ids,
+        physical_size,
+        subpixel_arrangement);
+}
+
+MATCHER_P2(IsFdOfDevice, devname, fds, "")
+{
+    return std::find(
+        fds.begin(),
+        fds.end(),
+        arg) != fds.end();
+}
+
+class mtd::MockDRM::IsFdOfDeviceMatcher : public ::testing::MatcherInterface<int>
+{
+public:
+    IsFdOfDeviceMatcher(char const* device)
+        : device{device}
+    {
+    }
+
+    void DescribeTo(::std::ostream *os) const override
+    {
+
+        *os
+            << "Is an fd of DRM device "
+            << device
+            << " (one of: "
+            << ::testing::PrintToString(fds_for_device(device.c_str()))
+            << ")";
+    }
+
+    bool MatchAndExplain(int x, testing::MatchResultListener *listener) const override
+    {
+        testing::Matcher<std::vector<int>> matcher = testing::Contains(x);
+        return matcher.MatchAndExplain(fds_for_device(device.c_str()), listener);
+    }
+
+private:
+    std::vector<int> fds_for_device(char const* device) const
+    {
+        std::vector<int> device_fds;
+        for (auto const& pair : global_mock->fd_to_drm)
+        {
+            if (&global_mock->fake_drms[device] == &pair.second)
+            {
+                device_fds.push_back(pair.first);
+            }
+        }
+        return device_fds;
+    }
+
+    std::string const device;
+};
+
+testing::Matcher<int> mtd::IsFdOfDevice(char const* device)
+{
+    return ::testing::MakeMatcher(new mtd::MockDRM::IsFdOfDeviceMatcher(device));
+}
+
 int drmOpen(const char *name, const char *busid)
 {
     return global_mock->drmOpen(name, busid);

=== modified file 'tests/mir_test_doubles/mock_egl.cpp'
--- tests/mir_test_doubles/mock_egl.cpp	2017-01-18 02:29:37 +0000
+++ tests/mir_test_doubles/mock_egl.cpp	2017-03-22 06:55:00 +0000
@@ -156,7 +156,7 @@
 {
     using namespace testing;
 
-    const char* egl_exts = "EGL_KHR_image EGL_KHR_image_base EGL_KHR_image_pixmap";
+    const char* egl_exts = "EGL_KHR_image EGL_KHR_image_base EGL_KHR_image_pixmap EGL_EXT_image_dma_buf_import";
     ON_CALL(*this, eglQueryString(_,EGL_EXTENSIONS))
         .WillByDefault(Return(egl_exts));
 }

=== modified file 'tests/mir_test_doubles/mock_gbm.cpp'
--- tests/mir_test_doubles/mock_gbm.cpp	2015-07-16 07:03:19 +0000
+++ tests/mir_test_doubles/mock_gbm.cpp	2017-03-22 06:55:00 +0000
@@ -182,3 +182,8 @@
 {
     return global_mock->gbm_bo_import(device, type, data, flags);
 }
+
+int gbm_bo_get_fd(gbm_bo* bo)
+{
+    return global_mock->gbm_bo_get_fd(bo);
+}

=== modified file 'tests/mir_test_doubles/mock_gl.cpp'
--- tests/mir_test_doubles/mock_gl.cpp	2016-06-30 13:41:11 +0000
+++ tests/mir_test_doubles/mock_gl.cpp	2017-03-22 06:55:00 +0000
@@ -20,6 +20,8 @@
 #include "mir/test/doubles/mock_gl.h"
 #include <gtest/gtest.h>
 
+#include <GLES2/gl2.h>
+
 #include <cstring>
 
 namespace mtd = mir::test::doubles;
@@ -462,3 +464,9 @@
     CHECK_GLOBAL_VOID_MOCK();
     global_mock_gl->glPixelStorei(pname, param);
 }
+
+void glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indicies)
+{
+    CHECK_GLOBAL_VOID_MOCK();
+    global_mock_gl->glDrawElements(mode, count, type, indicies);
+}

=== modified file 'tests/unit-tests/platforms/mesa/kms-utils/test_connector_utils.cpp'
--- tests/unit-tests/platforms/mesa/kms-utils/test_connector_utils.cpp	2016-05-20 02:15:41 +0000
+++ tests/unit-tests/platforms/mesa/kms-utils/test_connector_utils.cpp	2017-03-22 06:55:00 +0000
@@ -25,6 +25,7 @@
 
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
+#include <fcntl.h>
 
 namespace mtd = mir::test::doubles;
 namespace mgk = mir::graphics::kms;
@@ -35,30 +36,37 @@
 {
     using namespace testing;
     NiceMock<mtd::MockDRM> drm;
-
-    auto& resources = drm.fake_drm;
+    char const* const drm_device = "/dev/dri/card0";
 
     std::array<uint32_t, 3> const crtc_ids = {{21, 25, 30}};
     std::array<uint32_t, 3> const encoder_ids = {{3, 5, 7}};
     std::array<uint32_t, 3> const connector_id = {{9, 10, 11}};
 
-    resources.reset();
+    drm.reset(drm_device);
     // Add a bunch of CRTCs
     for (auto id : crtc_ids)
     {
-        resources.add_crtc(id, drmModeModeInfo());
+        drm.add_crtc(drm_device, id, drmModeModeInfo());
     }
     // Add an encoder that can only drive any CRTC...
-    resources.add_encoder(encoder_ids[0], 0, 1 << 0 | 1 << 1 | 1 << 2);
+    drm.add_encoder(drm_device, encoder_ids[0], 0, 1 << 0 | 1 << 1 | 1 << 2);
     // ...and one that can only drive the third...
-    resources.add_encoder(encoder_ids[1], 0, 1 << 2);
+    drm.add_encoder(drm_device, encoder_ids[1], 0, 1 << 2);
     // ...and one that can only drive the second two...
-    resources.add_encoder(encoder_ids[2], 0, 1 << 1 | 1 << 2);
+    drm.add_encoder(drm_device, encoder_ids[2], 0, 1 << 1 | 1 << 2);
 
-    std::vector<drmModeModeInfo> modes{resources.create_mode(1200, 1600, 138500, 1400, 1800, mtd::FakeDRMResources::ModePreference::PreferredMode)};
+    std::vector<drmModeModeInfo> modes{
+        mtd::FakeDRMResources::create_mode(
+            1200,
+            1600,
+            138500,
+            1400,
+            1800,
+            mtd::FakeDRMResources::ModePreference::PreferredMode)};
     // Finally, add a connector that can only be driven by any encoder...
     std::vector<uint32_t> any_encoder{encoder_ids.begin(), encoder_ids.end()};
-    resources.add_connector(
+    drm.add_connector(
+        drm_device,
         connector_id[0],
         DRM_MODE_CONNECTOR_VGA,
         DRM_MODE_CONNECTED,
@@ -69,7 +77,8 @@
 
     // ...then one that can only be driven by the third...
     std::vector<uint32_t> third_encoder{encoder_ids[2]};
-    resources.add_connector(
+    drm.add_connector(
+        drm_device,
         connector_id[1],
         DRM_MODE_CONNECTOR_VGA,
         DRM_MODE_CONNECTED,
@@ -80,7 +89,8 @@
 
     // ...and finally one that can only be driven by the second...
     std::vector<uint32_t> second_encoder{encoder_ids[1]};
-    resources.add_connector(
+    drm.add_connector(
+        drm_device,
         connector_id[2],
         DRM_MODE_CONNECTOR_VGA,
         DRM_MODE_CONNECTED,
@@ -89,21 +99,23 @@
         second_encoder,
         mir::geometry::Size{300, 200});
 
-    resources.prepare();
+    drm.prepare(drm_device);
+
+    auto const drm_fd = open(drm_device, 0, 0);
 
     auto crtc = mgk::find_crtc_for_connector(
-        resources.fd(),
-        mgk::get_connector(resources.fd(), connector_id[0]));
+        drm_fd,
+        mgk::get_connector(drm_fd, connector_id[0]));
     EXPECT_THAT(crtc->crtc_id, AnyOf(crtc_ids[0], crtc_ids[1], crtc_ids[2]));
 
     crtc = mgk::find_crtc_for_connector(
-        resources.fd(),
-        mgk::get_connector(resources.fd(), connector_id[1]));
+        drm_fd,
+        mgk::get_connector(drm_fd, connector_id[1]));
     EXPECT_THAT(crtc->crtc_id, AnyOf(crtc_ids[1], crtc_ids[2]));
 
     crtc = mgk::find_crtc_for_connector(
-        resources.fd(),
-        mgk::get_connector(resources.fd(), connector_id[2]));
+        drm_fd,
+        mgk::get_connector(drm_fd, connector_id[2]));
     EXPECT_THAT(crtc->crtc_id, Eq(crtc_ids[2]));
 }
 
@@ -111,30 +123,38 @@
 {
     using namespace testing;
     NiceMock<mtd::MockDRM> drm;
-
-    auto& resources = drm.fake_drm;
+    char const* const drm_device = "/dev/dri/card0";
+    int const drm_fd = open(drm_device, 0, 0);
 
     std::array<uint32_t, 2> const crtc_ids = {{21, 25}};
     std::array<uint32_t, 2> const encoder_ids = {{3, 5}};
     std::array<uint32_t, 2> const connector_id = {{9, 10}};
 
-    resources.reset();
-    auto boring_mode = resources.create_mode(1200, 1600, 138500, 1400, 1800, mtd::FakeDRMResources::ModePreference::PreferredMode);
+    drm.reset(drm_device);
+    auto boring_mode =
+        mtd::FakeDRMResources::create_mode(
+            1200,
+            1600,
+            138500,
+            1400,
+            1800,
+            mtd::FakeDRMResources::ModePreference::PreferredMode);
     // Add an active CRTC...
-    resources.add_crtc(crtc_ids[0], boring_mode);
+    drm.add_crtc(drm_device, crtc_ids[0], boring_mode);
     // ...and an inactive one.
-    resources.add_crtc(crtc_ids[1], drmModeModeInfo());
+    drm.add_crtc(drm_device, crtc_ids[1], drmModeModeInfo());
 
     // Add an encoder hooked up to the active CRTC
-    resources.add_encoder(encoder_ids[0], crtc_ids[0], 1 << 0 | 1 << 1);
+    drm.add_encoder(drm_device, encoder_ids[0], crtc_ids[0], 1 << 0 | 1 << 1);
     // ...and one not connected to anything
-    resources.add_encoder(encoder_ids[1], 0, 1 << 0 | 1 << 1);
+    drm.add_encoder(drm_device, encoder_ids[1], 0, 1 << 0 | 1 << 1);
 
     std::vector<drmModeModeInfo> modes{boring_mode};
     std::vector<uint32_t> any_encoder{encoder_ids.begin(), encoder_ids.end()};
 
     // Finally, a connector hooked up to a CRTC-encoder
-    resources.add_connector(
+    drm.add_connector(
+        drm_device,
         connector_id[0],
         DRM_MODE_CONNECTOR_VGA,
         DRM_MODE_CONNECTED,
@@ -144,7 +164,8 @@
         mir::geometry::Size{300, 200});
 
     // ... and one not hooked up to anything
-    resources.add_connector(
+    drm.add_connector(
+        drm_device,
         connector_id[1],
         DRM_MODE_CONNECTOR_VGA,
         DRM_MODE_CONNECTED,
@@ -153,11 +174,11 @@
         any_encoder,
         mir::geometry::Size{300, 200});
 
-    resources.prepare();
+    drm.prepare(drm_device);
 
     auto crtc = mgk::find_crtc_for_connector(
-        resources.fd(),
-        mgk::get_connector(resources.fd(), connector_id[1]));
+        drm_fd,
+        mgk::get_connector(drm_fd, connector_id[1]));
     EXPECT_THAT(crtc->crtc_id, Eq(crtc_ids[1]));
 }
 
@@ -165,30 +186,39 @@
 {
     using namespace testing;
     NiceMock<mtd::MockDRM> drm;
+    char const* const drm_device = "/dev/dri/card0";
+    int const drm_fd = open(drm_device, 0, 0);
 
-    auto& resources = drm.fake_drm;
 
     std::array<uint32_t, 2> const crtc_ids = {{21, 25}};
     std::array<uint32_t, 2> const encoder_ids = {{3, 5}};
     std::array<uint32_t, 2> const connector_id = {{9, 10}};
 
-    resources.reset();
-    auto boring_mode = resources.create_mode(1200, 1600, 138500, 1400, 1800, mtd::FakeDRMResources::ModePreference::PreferredMode);
+    drm.reset(drm_device);
+    auto boring_mode =
+        mtd::FakeDRMResources::create_mode(
+            1200,
+            1600,
+            138500,
+            1400,
+            1800,
+            mtd::FakeDRMResources::ModePreference::PreferredMode);
     // Add an active CRTC...
-    resources.add_crtc(crtc_ids[0], boring_mode);
+    drm.add_crtc(drm_device, crtc_ids[0], boring_mode);
     // ...and an inactive one.
-    resources.add_crtc(crtc_ids[1], drmModeModeInfo());
+    drm.add_crtc(drm_device, crtc_ids[1], drmModeModeInfo());
 
     // Add an encoder hooked up to the active CRTC
-    resources.add_encoder(encoder_ids[0], crtc_ids[0], 1 << 0 | 1 << 1);
+    drm.add_encoder(drm_device, encoder_ids[0], crtc_ids[0], 1 << 0 | 1 << 1);
     // ...and one not connected to anything
-    resources.add_encoder(encoder_ids[1], 0, 1 << 0 | 1 << 1);
+    drm.add_encoder(drm_device, encoder_ids[1], 0, 1 << 0 | 1 << 1);
 
     std::vector<drmModeModeInfo> modes{boring_mode};
     std::vector<uint32_t> any_encoder{encoder_ids.begin(), encoder_ids.end()};
 
     // Finally, a connector hooked up to a CRTC-encoder
-    resources.add_connector(
+    drm.add_connector(
+        drm_device,
         connector_id[0],
         DRM_MODE_CONNECTOR_VGA,
         DRM_MODE_CONNECTED,
@@ -198,7 +228,8 @@
         mir::geometry::Size{300, 200});
 
     // ... and one not hooked up to anything
-    resources.add_connector(
+    drm.add_connector(
+        drm_device,
         connector_id[1],
         DRM_MODE_CONNECTOR_VGA,
         DRM_MODE_CONNECTED,
@@ -207,10 +238,10 @@
         any_encoder,
         mir::geometry::Size{300, 200});
 
-    resources.prepare();
+    drm.prepare(drm_device);
 
     auto crtc = mgk::find_crtc_for_connector(
-        resources.fd(),
-        mgk::get_connector(resources.fd(), connector_id[0]));
+        drm_fd,
+        mgk::get_connector(drm_fd, connector_id[0]));
     EXPECT_THAT(crtc->crtc_id, Eq(crtc_ids[0]));
 }

=== modified file 'tests/unit-tests/platforms/mesa/kms/mock_kms_output.h'
--- tests/unit-tests/platforms/mesa/kms/mock_kms_output.h	2017-03-13 08:12:52 +0000
+++ tests/unit-tests/platforms/mesa/kms/mock_kms_output.h	2017-03-22 06:55:00 +0000
@@ -38,6 +38,7 @@
 
 struct MockKMSOutput : public graphics::mesa::KMSOutput
 {
+    MOCK_CONST_METHOD0(id, uint32_t());
     MOCK_METHOD0(reset, void());
     MOCK_METHOD2(configure, void(geometry::Displacement, size_t));
     MOCK_CONST_METHOD0(size, geometry::Size());
@@ -68,7 +69,12 @@
     MOCK_METHOD1(set_power_mode, void(MirPowerMode));
     MOCK_METHOD1(set_gamma, void(mir::graphics::GammaCurves const&));
 
+    MOCK_METHOD0(refresh_hardware_state, void());
+    MOCK_CONST_METHOD1(update_from_hardware_state, void(graphics::DisplayConfigurationOutput&));
+
     MOCK_CONST_METHOD3(fb_for, graphics::mesa::FBHandle*(gbm_bo*, uint32_t, uint32_t));
+    MOCK_CONST_METHOD1(buffer_requires_migration, bool(gbm_bo*));
+    MOCK_CONST_METHOD0(drm_fd, int());
 };
 
 } // namespace test

=== modified file 'tests/unit-tests/platforms/mesa/kms/test_cursor.cpp'
--- tests/unit-tests/platforms/mesa/kms/test_cursor.cpp	2017-02-15 07:38:33 +0000
+++ tests/unit-tests/platforms/mesa/kms/test_cursor.cpp	2017-03-22 06:55:00 +0000
@@ -56,14 +56,14 @@
 {
     StubKMSOutputContainer()
         : outputs{
-            {10, std::make_shared<testing::NiceMock<MockKMSOutput>>()},
-            {11, std::make_shared<testing::NiceMock<MockKMSOutput>>()},
-            {12, std::make_shared<testing::NiceMock<MockKMSOutput>>()}}
+            std::make_shared<testing::NiceMock<MockKMSOutput>>(),
+            std::make_shared<testing::NiceMock<MockKMSOutput>>(),
+            std::make_shared<testing::NiceMock<MockKMSOutput>>()}
     {
         // These need to be established before Cursor construction:
-        for (auto& entry : outputs)
+        for (auto& output : outputs)
         {
-            auto& out = *entry.second;
+            auto& out = *output;
             ON_CALL(out, has_cursor())
                 .WillByDefault(Return(true));
             ON_CALL(out, set_cursor(_))
@@ -73,33 +73,33 @@
         }
     }
 
-    std::shared_ptr<mgm::KMSOutput> get_kms_output_for(uint32_t connector_id)
-    {
-        return outputs[connector_id];
-    }
-
-    void for_each_output(std::function<void(mgm::KMSOutput&)> functor) const
-    {
-        for (auto const& pair : outputs)
-            functor(*pair.second);
+    void for_each_output(std::function<void(std::shared_ptr<mgm::KMSOutput> const&)> functor) const
+    {
+        for (auto const& output : outputs)
+            functor(output);
     }
 
     void verify_and_clear_expectations()
     {
-        for (auto const& pair : outputs)
-            ::testing::Mock::VerifyAndClearExpectations(pair.second.get());
-    }
-
-    std::unordered_map<uint32_t,std::shared_ptr<testing::NiceMock<MockKMSOutput>>> outputs;
+        for (auto const& output : outputs)
+            ::testing::Mock::VerifyAndClearExpectations(output.get());
+    }
+
+    void update_from_hardware_state()
+    {
+    }
+
+    std::vector<std::shared_ptr<testing::NiceMock<MockKMSOutput>>> outputs;
 };
 
 struct StubKMSDisplayConfiguration : public mgm::KMSDisplayConfiguration
 {
-    StubKMSDisplayConfiguration()
+    StubKMSDisplayConfiguration(mgm::KMSOutputContainer& container)
         : mgm::KMSDisplayConfiguration(),
+          container{container},
           stub_config{
             {{
-                mg::DisplayConfigurationOutputId{10},
+                mg::DisplayConfigurationOutputId{0},
                 mg::DisplayConfigurationCardId{},
                 mg::DisplayConfigurationOutputType::vga,
                 {},
@@ -124,7 +124,7 @@
                 {}
             },
             {
-                mg::DisplayConfigurationOutputId{11},
+                mg::DisplayConfigurationOutputId{1},
                 mg::DisplayConfigurationCardId{},
                 mg::DisplayConfigurationOutputType::vga,
                 {},
@@ -149,7 +149,7 @@
                 {}
             },
             {
-                mg::DisplayConfigurationOutputId{12},
+                mg::DisplayConfigurationOutputId{2},
                 mg::DisplayConfigurationCardId{},
                 mg::DisplayConfigurationOutputType::vga,
                 {},
@@ -174,6 +174,7 @@
                 {}
             }}}
     {
+        update();
     }
 
     void for_each_card(std::function<void(mg::DisplayConfigurationCard const&)> f) const override
@@ -201,9 +202,9 @@
         return stub_config.valid();
     }
 
-    uint32_t get_kms_connector_id(mg::DisplayConfigurationOutputId id) const override
+    std::shared_ptr<mgm::KMSOutput> get_output_for(mg::DisplayConfigurationOutputId id) const override
     {
-        return id.as_value();
+        return outputs[id.as_value()];
     }
 
     size_t get_kms_mode_index(mg::DisplayConfigurationOutputId, size_t conf_mode_index) const override
@@ -213,6 +214,11 @@
 
     void update() override
     {
+        container.for_each_output(
+            [this](auto const& output)
+            {
+                outputs.push_back(output);
+            });
     }
 
     void set_orentation_of_output(mg::DisplayConfigurationOutputId id, MirOrientation orientation)
@@ -225,11 +231,18 @@
             });
     }
 
+    mgm::KMSOutputContainer& container;
     mtd::StubDisplayConfig stub_config;
+    std::vector<std::shared_ptr<mgm::KMSOutput>> outputs;
 };
 
 struct StubCurrentConfiguration : public mgm::CurrentConfiguration
 {
+    StubCurrentConfiguration(mgm::KMSOutputContainer& container)
+        : conf(container)
+    {
+    }
+
     void with_current_configuration_do(
         std::function<void(mgm::KMSDisplayConfiguration const&)> const& exec)
     {
@@ -284,7 +297,7 @@
 
     size_t const cursor_side{64};
     MesaCursorTest()
-        : cursor{mock_gbm.fake_gbm.device, output_container,
+        : cursor{output_container,
             mt::fake_shared(current_configuration)}
     {
         using namespace ::testing;
@@ -304,9 +317,9 @@
     }
 
     testing::NiceMock<mtd::MockDRM> mock_drm;
-    StubCurrentConfiguration current_configuration;
     StubCursorImage stub_image;
     StubKMSOutputContainer output_container;
+    StubCurrentConfiguration current_configuration{output_container};
     mgm::Cursor cursor;
 };
 
@@ -335,19 +348,20 @@
                                         GBM_FORMAT_ARGB8888,
                                         GBM_BO_USE_CURSOR | GBM_BO_USE_WRITE));
 
-    mgm::Cursor cursor_tmp{mock_gbm.fake_gbm.device, output_container,
-        std::make_shared<StubCurrentConfiguration>()};
+    mgm::Cursor cursor_tmp{output_container,
+        std::make_shared<StubCurrentConfiguration>(output_container)};
 }
 
 TEST_F(MesaCursorTest, queries_received_cursor_size)
 {
     using namespace ::testing;
 
-    EXPECT_CALL(mock_gbm, gbm_bo_get_width(_));
-    EXPECT_CALL(mock_gbm, gbm_bo_get_height(_));
+    // Our standard mock DRM has 2 GPU devices, and we should construct a cursor on both.
+    EXPECT_CALL(mock_gbm, gbm_bo_get_width(_)).Times(2);
+    EXPECT_CALL(mock_gbm, gbm_bo_get_height(_)).Times(2);
 
-    mgm::Cursor cursor_tmp{mock_gbm.fake_gbm.device, output_container,
-        std::make_shared<StubCurrentConfiguration>()};
+    mgm::Cursor cursor_tmp{output_container,
+        std::make_shared<StubCurrentConfiguration>(output_container)};
 }
 
 TEST_F(MesaCursorTest, respects_drm_cap_cursor)
@@ -361,8 +375,8 @@
 
     EXPECT_CALL(mock_gbm, gbm_bo_create(_, drm_buffer_size, drm_buffer_size, _, _));
 
-    mgm::Cursor cursor_tmp{mock_gbm.fake_gbm.device, output_container,
-                           std::make_shared<StubCurrentConfiguration>()};
+    mgm::Cursor cursor_tmp{output_container,
+                           std::make_shared<StubCurrentConfiguration>(output_container)};
 }
 
 TEST_F(MesaCursorTest, can_force_64x64_cursor)
@@ -378,8 +392,8 @@
 
     EXPECT_CALL(mock_gbm, gbm_bo_create(_, 64, 64, _, _));
 
-    mgm::Cursor cursor_tmp{mock_gbm.fake_gbm.device, output_container,
-                           std::make_shared<StubCurrentConfiguration>()};
+    mgm::Cursor cursor_tmp{output_container,
+                           std::make_shared<StubCurrentConfiguration>(output_container)};
 }
 
 TEST_F(MesaCursorTest, show_cursor_writes_to_bo)
@@ -442,8 +456,8 @@
 
     EXPECT_CALL(mock_gbm, gbm_bo_write(mock_gbm.fake_gbm.bo, ContainsASingleWhitePixel(width*height), buffer_size_bytes));
 
-    mgm::Cursor cursor_tmp{mock_gbm.fake_gbm.device, output_container,
-        std::make_shared<StubCurrentConfiguration>()};
+    mgm::Cursor cursor_tmp{output_container,
+        std::make_shared<StubCurrentConfiguration>(output_container)};
     cursor_tmp.show(SinglePixelCursorImage());
 }
 
@@ -470,17 +484,17 @@
 {
     using namespace testing;
 
-    EXPECT_CALL(*output_container.outputs[10], clear_cursor());
-    EXPECT_CALL(*output_container.outputs[11], clear_cursor());
-    EXPECT_CALL(*output_container.outputs[12], clear_cursor());
+    EXPECT_CALL(*output_container.outputs[0], clear_cursor());
+    EXPECT_CALL(*output_container.outputs[1], clear_cursor());
+    EXPECT_CALL(*output_container.outputs[2], clear_cursor());
 
     /* No checking of existing cursor state */
-    EXPECT_CALL(*output_container.outputs[10], has_cursor()).Times(0);
-    EXPECT_CALL(*output_container.outputs[11], has_cursor()).Times(0);
-    EXPECT_CALL(*output_container.outputs[12], has_cursor()).Times(0);
+    EXPECT_CALL(*output_container.outputs[0], has_cursor()).Times(0);
+    EXPECT_CALL(*output_container.outputs[1], has_cursor()).Times(0);
+    EXPECT_CALL(*output_container.outputs[2], has_cursor()).Times(0);
 
-    mgm::Cursor cursor_tmp{mock_gbm.fake_gbm.device, output_container,
-       std::make_shared<StubCurrentConfiguration>()};
+    mgm::Cursor cursor_tmp{output_container,
+       std::make_shared<StubCurrentConfiguration>(output_container)};
 
     output_container.verify_and_clear_expectations();
 }
@@ -489,16 +503,16 @@
 {
     using namespace testing;
 
-    ON_CALL(*output_container.outputs[10], clear_cursor())
-        .WillByDefault(Return(false));
-    ON_CALL(*output_container.outputs[10], set_cursor(_))
-        .WillByDefault(Return(false));
-    ON_CALL(*output_container.outputs[10], has_cursor())
+    ON_CALL(*output_container.outputs[0], clear_cursor())
+        .WillByDefault(Return(false));
+    ON_CALL(*output_container.outputs[0], set_cursor(_))
+        .WillByDefault(Return(false));
+    ON_CALL(*output_container.outputs[0], has_cursor())
         .WillByDefault(Return(false));
 
     EXPECT_THROW(
-        mgm::Cursor cursor_tmp(mock_gbm.fake_gbm.device, output_container,
-           std::make_shared<StubCurrentConfiguration>());
+        mgm::Cursor cursor_tmp(output_container,
+           std::make_shared<StubCurrentConfiguration>(output_container));
     , std::runtime_error);
 }
 
@@ -508,14 +522,14 @@
 
     cursor.show(stub_image);
 
-    EXPECT_CALL(*output_container.outputs[10], has_cursor())
+    EXPECT_CALL(*output_container.outputs[0], has_cursor())
         .WillOnce(Return(false))
         .WillOnce(Return(true));
-    EXPECT_CALL(*output_container.outputs[10], set_cursor(_));
+    EXPECT_CALL(*output_container.outputs[0], set_cursor(_));
 
-    EXPECT_CALL(*output_container.outputs[11], has_cursor())
+    EXPECT_CALL(*output_container.outputs[1], has_cursor())
         .WillOnce(Return(true));
-    EXPECT_CALL(*output_container.outputs[11], clear_cursor());
+    EXPECT_CALL(*output_container.outputs[1], clear_cursor());
 
     cursor.move_to({10, 10});
 
@@ -528,14 +542,14 @@
 
     cursor.show(stub_image);
 
-    EXPECT_CALL(*output_container.outputs[10], has_cursor())
+    EXPECT_CALL(*output_container.outputs[0], has_cursor())
         .WillOnce(Return(true));
-    EXPECT_CALL(*output_container.outputs[10], set_cursor(_))
+    EXPECT_CALL(*output_container.outputs[0], set_cursor(_))
         .Times(0);
 
-    EXPECT_CALL(*output_container.outputs[11], has_cursor())
+    EXPECT_CALL(*output_container.outputs[1], has_cursor())
         .WillOnce(Return(false));
-    EXPECT_CALL(*output_container.outputs[11], clear_cursor())
+    EXPECT_CALL(*output_container.outputs[1], clear_cursor())
         .Times(0);
 
     cursor.move_to({10, 10});
@@ -549,32 +563,32 @@
 
     cursor.show(stub_image);
 
-    EXPECT_CALL(*output_container.outputs[10], move_cursor(geom::Point{10,10}));
-    EXPECT_CALL(*output_container.outputs[11], move_cursor(_))
+    EXPECT_CALL(*output_container.outputs[0], move_cursor(geom::Point{10,10}));
+    EXPECT_CALL(*output_container.outputs[1], move_cursor(_))
         .Times(0);
 
     cursor.move_to({10, 10});
 
     output_container.verify_and_clear_expectations();
 
-    EXPECT_CALL(*output_container.outputs[10], move_cursor(_))
+    EXPECT_CALL(*output_container.outputs[0], move_cursor(_))
         .Times(0);
-    EXPECT_CALL(*output_container.outputs[11], move_cursor(geom::Point{50,100}));
+    EXPECT_CALL(*output_container.outputs[1], move_cursor(geom::Point{50,100}));
 
     cursor.move_to({150, 150});
 
     output_container.verify_and_clear_expectations();
 
-    EXPECT_CALL(*output_container.outputs[10], move_cursor(geom::Point{150,75}));
-    EXPECT_CALL(*output_container.outputs[11], move_cursor(geom::Point{50,25}));
+    EXPECT_CALL(*output_container.outputs[0], move_cursor(geom::Point{150,75}));
+    EXPECT_CALL(*output_container.outputs[1], move_cursor(geom::Point{50,25}));
 
     cursor.move_to({150, 75});
 
     output_container.verify_and_clear_expectations();
 
-    EXPECT_CALL(*output_container.outputs[10], move_cursor(_))
+    EXPECT_CALL(*output_container.outputs[0], move_cursor(_))
         .Times(0);
-    EXPECT_CALL(*output_container.outputs[11], move_cursor(_))
+    EXPECT_CALL(*output_container.outputs[1], move_cursor(_))
         .Times(0);
 
     cursor.move_to({-1, -1});
@@ -588,10 +602,10 @@
 
     cursor.show(stub_image);
 
-    current_configuration.conf.set_orentation_of_output(mg::DisplayConfigurationOutputId{12}, mir_orientation_left);
+    current_configuration.conf.set_orentation_of_output(mg::DisplayConfigurationOutputId{2}, mir_orientation_left);
 
-    EXPECT_CALL(*output_container.outputs[12], move_cursor(geom::Point{112,100}));
-    EXPECT_CALL(*output_container.outputs[12], move_cursor(geom::Point{150,96}));
+    EXPECT_CALL(*output_container.outputs[2], move_cursor(geom::Point{112,100}));
+    EXPECT_CALL(*output_container.outputs[2], move_cursor(geom::Point{150,96}));
 
     cursor.move_to({766, 112});
     cursor.move_to({770, 150});
@@ -606,11 +620,11 @@
 
     cursor.show(stub_image);
 
-    current_configuration.conf.set_orentation_of_output(mg::DisplayConfigurationOutputId{12}, mir_orientation_right);
-
-
-    EXPECT_CALL(*output_container.outputs[12], move_cursor(geom::Point{688,100}));
-    EXPECT_CALL(*output_container.outputs[12], move_cursor(geom::Point{650,104}));
+    current_configuration.conf.set_orentation_of_output(mg::DisplayConfigurationOutputId{2}, mir_orientation_right);
+
+
+    EXPECT_CALL(*output_container.outputs[2], move_cursor(geom::Point{688,100}));
+    EXPECT_CALL(*output_container.outputs[2], move_cursor(geom::Point{650,104}));
 
     cursor.move_to({766, 112});
     cursor.move_to({770, 150});
@@ -624,10 +638,10 @@
 
     cursor.show(stub_image);
 
-    current_configuration.conf.set_orentation_of_output(mg::DisplayConfigurationOutputId{12}, mir_orientation_inverted);
+    current_configuration.conf.set_orentation_of_output(mg::DisplayConfigurationOutputId{2}, mir_orientation_inverted);
 
-    EXPECT_CALL(*output_container.outputs[12], move_cursor(geom::Point{700,88}));
-    EXPECT_CALL(*output_container.outputs[12], move_cursor(geom::Point{696,50}));
+    EXPECT_CALL(*output_container.outputs[2], move_cursor(geom::Point{700,88}));
+    EXPECT_CALL(*output_container.outputs[2], move_cursor(geom::Point{696,50}));
 
     cursor.move_to({766, 112});
     cursor.move_to({770, 150});
@@ -639,9 +653,9 @@
 {
     using namespace testing;
 
-    EXPECT_CALL(*output_container.outputs[10], clear_cursor());
-    EXPECT_CALL(*output_container.outputs[11], clear_cursor());
-    EXPECT_CALL(*output_container.outputs[12], clear_cursor());
+    EXPECT_CALL(*output_container.outputs[0], clear_cursor());
+    EXPECT_CALL(*output_container.outputs[1], clear_cursor());
+    EXPECT_CALL(*output_container.outputs[2], clear_cursor());
 
     cursor.hide();
 
@@ -652,12 +666,12 @@
 {
     using namespace testing;
 
-    EXPECT_CALL(*output_container.outputs[10], clear_cursor());
-    EXPECT_CALL(*output_container.outputs[11], clear_cursor());
-    EXPECT_CALL(*output_container.outputs[12], clear_cursor());
-    EXPECT_CALL(*output_container.outputs[10], move_cursor(_)).Times(0);
-    EXPECT_CALL(*output_container.outputs[11], move_cursor(_)).Times(0);
-    EXPECT_CALL(*output_container.outputs[12], move_cursor(_)).Times(0);
+    EXPECT_CALL(*output_container.outputs[0], clear_cursor());
+    EXPECT_CALL(*output_container.outputs[1], clear_cursor());
+    EXPECT_CALL(*output_container.outputs[2], clear_cursor());
+    EXPECT_CALL(*output_container.outputs[0], move_cursor(_)).Times(0);
+    EXPECT_CALL(*output_container.outputs[1], move_cursor(_)).Times(0);
+    EXPECT_CALL(*output_container.outputs[2], move_cursor(_)).Times(0);
 
     cursor.hide();
     cursor.move_to({17, 29});
@@ -669,9 +683,9 @@
 {
     using namespace testing;
 
-    EXPECT_CALL(*output_container.outputs[10], clear_cursor());
-    EXPECT_CALL(*output_container.outputs[11], clear_cursor());
-    EXPECT_CALL(*output_container.outputs[12], clear_cursor());
+    EXPECT_CALL(*output_container.outputs[0], clear_cursor());
+    EXPECT_CALL(*output_container.outputs[1], clear_cursor());
+    EXPECT_CALL(*output_container.outputs[2], clear_cursor());
 }
 
 TEST_F(MesaCursorTest, cursor_is_shown_at_correct_location_after_suspend_resume)
@@ -680,23 +694,23 @@
 
     cursor.show(stub_image);
 
-    EXPECT_CALL(*output_container.outputs[10], move_cursor(geom::Point{150,75}));
-    EXPECT_CALL(*output_container.outputs[11], move_cursor(geom::Point{50,25}));
-    EXPECT_CALL(*output_container.outputs[10], clear_cursor());
-    EXPECT_CALL(*output_container.outputs[11], clear_cursor());
-    EXPECT_CALL(*output_container.outputs[12], has_cursor())
+    EXPECT_CALL(*output_container.outputs[0], move_cursor(geom::Point{150,75}));
+    EXPECT_CALL(*output_container.outputs[1], move_cursor(geom::Point{50,25}));
+    EXPECT_CALL(*output_container.outputs[0], clear_cursor());
+    EXPECT_CALL(*output_container.outputs[1], clear_cursor());
+    EXPECT_CALL(*output_container.outputs[2], has_cursor())
         .WillRepeatedly(Return(false));
-    EXPECT_CALL(*output_container.outputs[12], clear_cursor());
+    EXPECT_CALL(*output_container.outputs[2], clear_cursor());
 
     cursor.move_to({150, 75});
     cursor.suspend();
 
     output_container.verify_and_clear_expectations();
 
-    EXPECT_CALL(*output_container.outputs[10], set_cursor(_));
-    EXPECT_CALL(*output_container.outputs[11], set_cursor(_));
-    EXPECT_CALL(*output_container.outputs[10], move_cursor(geom::Point{150,75}));
-    EXPECT_CALL(*output_container.outputs[11], move_cursor(geom::Point{50,25}));
+    EXPECT_CALL(*output_container.outputs[0], set_cursor(_));
+    EXPECT_CALL(*output_container.outputs[1], set_cursor(_));
+    EXPECT_CALL(*output_container.outputs[0], move_cursor(geom::Point{150,75}));
+    EXPECT_CALL(*output_container.outputs[1], move_cursor(geom::Point{50,25}));
 
     cursor.resume();
     output_container.verify_and_clear_expectations();
@@ -706,18 +720,18 @@
 {
     using namespace testing;
 
-    EXPECT_CALL(*output_container.outputs[10], clear_cursor()).Times(AnyNumber());
-    EXPECT_CALL(*output_container.outputs[11], clear_cursor()).Times(AnyNumber());
-    EXPECT_CALL(*output_container.outputs[12], clear_cursor()).Times(AnyNumber());
+    EXPECT_CALL(*output_container.outputs[0], clear_cursor()).Times(AnyNumber());
+    EXPECT_CALL(*output_container.outputs[1], clear_cursor()).Times(AnyNumber());
+    EXPECT_CALL(*output_container.outputs[2], clear_cursor()).Times(AnyNumber());
 
     cursor.hide();
     cursor.suspend();
 
     output_container.verify_and_clear_expectations();
 
-    EXPECT_CALL(*output_container.outputs[10], set_cursor(_)).Times(0);
-    EXPECT_CALL(*output_container.outputs[11], set_cursor(_)).Times(0);
-    EXPECT_CALL(*output_container.outputs[12], set_cursor(_)).Times(0);
+    EXPECT_CALL(*output_container.outputs[0], set_cursor(_)).Times(0);
+    EXPECT_CALL(*output_container.outputs[1], set_cursor(_)).Times(0);
+    EXPECT_CALL(*output_container.outputs[2], set_cursor(_)).Times(0);
 
     cursor.resume();
     output_container.verify_and_clear_expectations();
@@ -725,24 +739,24 @@
 
 TEST_F(MesaCursorTest, show_with_param_places_cursor_on_output)
 {
-    EXPECT_CALL(*output_container.outputs[10], clear_cursor());
+    EXPECT_CALL(*output_container.outputs[0], clear_cursor());
     cursor.hide();
 
     output_container.verify_and_clear_expectations();
 
-    EXPECT_CALL(*output_container.outputs[10], set_cursor(_));
+    EXPECT_CALL(*output_container.outputs[0], set_cursor(_));
     cursor.show(stub_image);
 }
 
 TEST_F(MesaCursorTest, show_without_param_places_cursor_on_output_output)
 {
     using namespace testing;
-    EXPECT_CALL(*output_container.outputs[10], clear_cursor());
+    EXPECT_CALL(*output_container.outputs[0], clear_cursor());
 
     cursor.hide();
     output_container.verify_and_clear_expectations();
 
-    EXPECT_CALL(*output_container.outputs[10], set_cursor(_));
+    EXPECT_CALL(*output_container.outputs[0], set_cursor(_));
     cursor.show();
 }
 
@@ -772,15 +786,15 @@
     
     
     EXPECT_CALL(mock_gbm, gbm_bo_write(_, _, _)).Times(AnyNumber());
-    EXPECT_CALL(*output_container.outputs[10], set_cursor(_)).Times(AnyNumber());
+    EXPECT_CALL(*output_container.outputs[0], set_cursor(_)).Times(AnyNumber());
 
     // When we set the image with the hotspot, first we should see the cursor move from its initial
     // location, to account for the displacement. Further movement should be offset by the hotspot.
     {
         InSequence seq;
-        EXPECT_CALL(*output_container.outputs[10], move_cursor(initial_buffer_location));
-        EXPECT_CALL(*output_container.outputs[10], move_cursor(expected_buffer_location_1));
-        EXPECT_CALL(*output_container.outputs[10], move_cursor(expected_buffer_location_2));
+        EXPECT_CALL(*output_container.outputs[0], move_cursor(initial_buffer_location));
+        EXPECT_CALL(*output_container.outputs[0], move_cursor(expected_buffer_location_1));
+        EXPECT_CALL(*output_container.outputs[0], move_cursor(expected_buffer_location_2));
     }
 
     cursor.show(HotspotCursor());

=== modified file 'tests/unit-tests/platforms/mesa/kms/test_display.cpp'
--- tests/unit-tests/platforms/mesa/kms/test_display.cpp	2017-02-28 08:53:57 +0000
+++ tests/unit-tests/platforms/mesa/kms/test_display.cpp	2017-03-22 06:55:00 +0000
@@ -27,6 +27,7 @@
 #include "mir/time/steady_clock.h"
 #include "mir/glib_main_loop.h"
 #include "mir/fatal.h"
+#include "src/platforms/common/server/kms-utils/drm_mode_resources.h"
 
 #include "mir/test/doubles/mock_egl.h"
 #include "mir/test/doubles/mock_gl.h"
@@ -55,6 +56,7 @@
 #include <atomic>
 #include <mutex>
 #include <condition_variable>
+#include <fcntl.h>
 
 namespace mg=mir::graphics;
 namespace mgm=mir::graphics::mesa;
@@ -80,7 +82,8 @@
 public:
     MesaDisplayTest() :
         mock_report{std::make_shared<testing::NiceMock<mtd::MockDisplayReport>>()},
-        null_report{mr::null_display_report()}
+        null_report{mr::null_display_report()},
+        drm_fd{open(drm_device, 0, 0)}
     {
         using namespace testing;
         ON_CALL(mock_egl, eglChooseConfig(_,_,_,1,_))
@@ -95,11 +98,16 @@
          * the MockGBM destructor, and which are not handled by NiceMock<>.
          */
         EXPECT_CALL(mock_gbm, gbm_bo_get_device(_))
-        .Times(AtLeast(0));
+            .Times(AtLeast(0));
         EXPECT_CALL(mock_gbm, gbm_device_get_fd(_))
-        .Times(AtLeast(0));
+            .Times(AtLeast(0))
+            .WillRepeatedly(Return(drm_fd));
 
         fake_devices.add_standard_device("standard-drm-devices");
+
+        // Our standard mock devices have 2 DRM devices; kill all the outputs on
+        // the second one, so we don't try to test hybrid (for now)
+        mock_drm.reset("/dev/dri/card1");
     }
 
     std::shared_ptr<mgm::Platform> create_platform()
@@ -145,14 +153,14 @@
             .Times(Exactly(1))
             .WillOnce(Return(fake.bo_handle2));
 
-        EXPECT_CALL(mock_drm, drmModeAddFB2(mock_drm.fake_drm.fd(),
+        EXPECT_CALL(mock_drm, drmModeAddFB2(drm_fd,
                                             _, _, _,
                                             Pointee(fake.bo_handle1.u32),
                                             _, _, _, _))
             .Times(Exactly(1))
             .WillOnce(DoAll(SetArgPointee<7>(fake.fb_id1), Return(0)));
 
-        EXPECT_CALL(mock_drm, drmModeAddFB2(mock_drm.fake_drm.fd(),
+        EXPECT_CALL(mock_drm, drmModeAddFB2(drm_fd,
                                             _, _, _,
                                             Pointee(fake.bo_handle2.u32),
                                             _, _, _, _))
@@ -162,26 +170,27 @@
 
     uint32_t get_connected_connector_id()
     {
-        auto drm_res = mock_drm.fake_drm.resources_ptr();
-
-        for (int i = 0; i < drm_res->count_connectors; i++)
-        {
-            auto connector = mock_drm.fake_drm.find_connector(drm_res->connectors[i]);
-            if (connector->connection == DRM_MODE_CONNECTED)
-                return connector->connector_id;
-        }
-
-        return 0;
+        mg::kms::DRMModeResources resources{drm_fd};
+
+        int connected_id = 0;
+        resources.for_each_connector(
+            [&connected_id](auto const& connector)
+            {
+                if (connector->connection == DRM_MODE_CONNECTED)
+                    connected_id = connector->connector_id;
+            });
+
+        return connected_id;
     }
 
     uint32_t get_connected_crtc_id()
     {
         auto connector_id = get_connected_connector_id();
-        auto connector = mock_drm.fake_drm.find_connector(connector_id);
+        auto connector = mg::kms::get_connector(drm_fd, connector_id);
 
         if (connector)
         {
-            auto encoder = mock_drm.fake_drm.find_encoder(connector->encoder_id);
+            auto encoder = mg::kms::get_encoder(drm_fd, connector->encoder_id);
             if (encoder)
                 return encoder->crtc_id;
         }
@@ -217,6 +226,9 @@
     std::shared_ptr<testing::NiceMock<mtd::MockDisplayReport>> const mock_report;
     std::shared_ptr<mg::DisplayReport> const null_report;
     mtf::UdevEnvironment fake_devices;
+
+    char const* const drm_device = "/dev/dri/card0";
+    int const drm_fd;
 };
 
 }
@@ -256,7 +268,7 @@
         .WillOnce(Return(fake.bo_handle1));
 
     /* Create a a DRM FB with the DRM buffer attached */
-    EXPECT_CALL(mock_drm, drmModeAddFB2(mock_drm.fake_drm.fd(),
+    EXPECT_CALL(mock_drm, drmModeAddFB2(drm_fd,
                                        _, _, _,
                                        Pointee(fake.bo_handle1.u32),
                                        _, _, _, _))
@@ -264,14 +276,14 @@
         .WillOnce(DoAll(SetArgPointee<7>(fake.fb_id1), Return(0)));
 
     /* Display the DRM FB (first expectation is for cleanup) */
-    EXPECT_CALL(mock_drm, drmModeSetCrtc(mock_drm.fake_drm.fd(),
+    EXPECT_CALL(mock_drm, drmModeSetCrtc(drm_fd,
                                          crtc_id, Ne(fake.fb_id1),
                                          _, _,
                                          Pointee(connector_id),
                                          _, _))
         .Times(AtLeast(0));
 
-    EXPECT_CALL(mock_drm, drmModeSetCrtc(mock_drm.fake_drm.fd(),
+    EXPECT_CALL(mock_drm, drmModeSetCrtc(drm_fd,
                                          crtc_id, fake.fb_id1,
                                          _, _,
                                          Pointee(connector_id),
@@ -291,7 +303,7 @@
     uint32_t const fb_id{66};
 
     /* Create DRM FBs */
-    EXPECT_CALL(mock_drm, drmModeAddFB2(mock_drm.fake_drm.fd(),
+    EXPECT_CALL(mock_drm, drmModeAddFB2(drm_fd,
                                         _, _, _, _, _, _, _, _))
         .WillRepeatedly(DoAll(SetArgPointee<7>(fb_id), Return(0)));
 
@@ -300,7 +312,7 @@
         InSequence s;
 
         /* crtc is set */
-        EXPECT_CALL(mock_drm, drmModeSetCrtc(mock_drm.fake_drm.fd(),
+        EXPECT_CALL(mock_drm, drmModeSetCrtc(drm_fd,
                                              crtc_id, fb_id,
                                              _, _,
                                              Pointee(connector_id),
@@ -308,7 +320,7 @@
             .Times(AtLeast(1));
 
         /* crtc is reset */
-        EXPECT_CALL(mock_drm, drmModeSetCrtc(mock_drm.fake_drm.fd(),
+        EXPECT_CALL(mock_drm, drmModeSetCrtc(drm_fd,
                                              crtc_id, Ne(fb_id),
                                              _, _,
                                              Pointee(connector_id),
@@ -325,7 +337,10 @@
 
     EXPECT_CALL(mock_drm, open(_,_,_))
         .Times(AtLeast(1))
-        .WillRepeatedly(Return(-1));
+        .WillRepeatedly(
+            DoAll(
+                InvokeWithoutArgs([]() { errno = ENODEV; }),
+                Return(-1)));
 
     EXPECT_CALL(mock_drm, drmClose(_))
         .Times(Exactly(0));
@@ -351,8 +366,9 @@
     EXPECT_CALL(mock_drm, drmModeFreeResources(_))
         .Times(Exactly(0));
 
+    // There are 2 DRM device nodes in our mock environment.
     EXPECT_CALL(mock_drm, drmClose(_))
-        .Times(Exactly(1));
+        .Times(Exactly(2));
 
     EXPECT_THROW({
         auto display = create_display(platform);
@@ -371,7 +387,7 @@
         .Times(Exactly(0));
 
     EXPECT_CALL(mock_drm, drmClose(_))
-        .Times(Exactly(1));
+        .Times(Exactly(2));
 
     EXPECT_THROW({
         auto platform = create_platform();
@@ -381,9 +397,9 @@
 namespace
 {
 
-ACTION_P(QueuePageFlipEvent, write_drm_fd)
+ACTION_P(QueuePageFlipEvent, mock_drm)
 {
-    EXPECT_EQ(1, write(write_drm_fd, "a", 1));
+    static_cast<mtd::MockDRM&>(mock_drm).generate_event_on("/dev/dri/card0");
 }
 
 ACTION_P(InvokePageFlipHandler, param)
@@ -410,17 +426,17 @@
         InSequence s;
 
         /* Flip the new FB */
-        EXPECT_CALL(mock_drm, drmModePageFlip(mock_drm.fake_drm.fd(),
+        EXPECT_CALL(mock_drm, drmModePageFlip(drm_fd,
                                               crtc_id,
                                               fake.fb_id2,
                                               _, _))
             .Times(Exactly(1))
-            .WillOnce(DoAll(QueuePageFlipEvent(mock_drm.fake_drm.write_fd()),
+            .WillOnce(DoAll(QueuePageFlipEvent(std::ref(mock_drm)),
                             SaveArg<4>(&user_data),
                             Return(0)));
 
         /* Handle the flip event */
-        EXPECT_CALL(mock_drm, drmHandleEvent(mock_drm.fake_drm.fd(), _))
+        EXPECT_CALL(mock_drm, drmHandleEvent(drm_fd, _))
             .Times(1)
             .WillOnce(DoAll(InvokePageFlipHandler(&user_data), Return(0)));
 
@@ -455,7 +471,7 @@
     setup_post_update_expectations();
 
     // clear_crtc happens at some stage. Not interesting.
-    EXPECT_CALL(mock_drm, drmModeSetCrtc(mock_drm.fake_drm.fd(),
+    EXPECT_CALL(mock_drm, drmModeSetCrtc(drm_fd,
                                          crtc_id, 0,
                                          _, _, _, _, _))
         .WillOnce(Return(0));
@@ -465,13 +481,13 @@
 
         // DisplayBuffer construction paints an empty screen.
         // That's probably less than ideal but we've always had it that way.
-        EXPECT_CALL(mock_drm, drmModeSetCrtc(mock_drm.fake_drm.fd(),
+        EXPECT_CALL(mock_drm, drmModeSetCrtc(drm_fd,
                                              crtc_id, fake.fb_id1,
                                              _, _, _, _, _))
             .WillOnce(Return(0));
 
         // New FB flip failure
-        EXPECT_CALL(mock_drm, drmModePageFlip(mock_drm.fake_drm.fd(),
+        EXPECT_CALL(mock_drm, drmModePageFlip(drm_fd,
                                               crtc_id,
                                               fake.fb_id2,
                                               _, _))
@@ -479,7 +495,7 @@
             .WillOnce(Return(-1));
 
         // Expect fallback to blitting
-        EXPECT_CALL(mock_drm, drmModeSetCrtc(mock_drm.fake_drm.fd(),
+        EXPECT_CALL(mock_drm, drmModeSetCrtc(drm_fd,
                                              crtc_id, fake.fb_id2,
                                              _, _, _, _, _))
             .WillOnce(Return(0));
@@ -623,21 +639,6 @@
     }, std::runtime_error);
 }
 
-TEST_F(MesaDisplayTest, constructor_throws_if_gl_oes_image_not_supported)
-{
-    using namespace ::testing;
-
-    const char* gl_exts = "GL_OES_texture_npot GL_OES_blend_func_separate";
-
-    EXPECT_CALL(mock_gl, glGetString(GL_EXTENSIONS))
-    .WillOnce(Return(reinterpret_cast<const GLubyte*>(gl_exts)));
-
-    EXPECT_THROW(
-    {
-        auto display = create_display(create_platform());
-    }, std::runtime_error);
-}
-
 TEST_F(MesaDisplayTest, for_each_display_buffer_calls_callback)
 {
     using namespace ::testing;
@@ -677,8 +678,8 @@
 {
     using namespace testing;
 
-    EXPECT_CALL(mock_drm, drmDropMaster(mock_drm.fake_drm.fd()))
-        .Times(1);
+    EXPECT_CALL(mock_drm, drmDropMaster(_))
+        .Times(2);
 
     auto display = create_display(create_platform());
 
@@ -689,8 +690,8 @@
 {
     using namespace testing;
 
-    EXPECT_CALL(mock_drm, drmSetMaster(mock_drm.fake_drm.fd()))
-        .Times(1);
+    EXPECT_CALL(mock_drm, drmSetMaster(_))
+        .Times(2);
 
     auto display = create_display(create_platform());
 

=== modified file 'tests/unit-tests/platforms/mesa/kms/test_display_buffer.cpp'
--- tests/unit-tests/platforms/mesa/kms/test_display_buffer.cpp	2017-03-13 08:12:52 +0000
+++ tests/unit-tests/platforms/mesa/kms/test_display_buffer.cpp	2017-03-22 06:55:00 +0000
@@ -93,6 +93,8 @@
             .WillByDefault(Return(mock_refresh_rate));
         ON_CALL(*mock_kms_output, fb_for(_,_,_))
             .WillByDefault(Return(reinterpret_cast<FBHandle*>(0x12ad)));
+        ON_CALL(*mock_kms_output, buffer_requires_migration(_))
+            .WillByDefault(Return(false));
 
         ON_CALL(*mock_bypassable_buffer, size())
             .WillByDefault(Return(display_area.size));
@@ -486,3 +488,18 @@
     EXPECT_FALSE(db.overlay(list));
 }
 
+TEST_F(MesaDisplayBufferTest, buffer_requiring_migration_is_ineligable_for_bypass)
+{
+    ON_CALL(*mock_kms_output, buffer_requires_migration(Eq(stub_gbm_native_buffer->bo)))
+        .WillByDefault(Return(true));
+
+    graphics::mesa::DisplayBuffer db(
+        graphics::mesa::BypassOption::allowed,
+        null_display_report(),
+        {mock_kms_output},
+        make_output_surface(),
+        display_area,
+        mir_orientation_normal);
+
+    EXPECT_FALSE(db.overlay(bypassable_list));
+}

=== modified file 'tests/unit-tests/platforms/mesa/kms/test_display_configuration.cpp'
--- tests/unit-tests/platforms/mesa/kms/test_display_configuration.cpp	2017-03-14 02:26:28 +0000
+++ tests/unit-tests/platforms/mesa/kms/test_display_configuration.cpp	2017-03-22 06:55:00 +0000
@@ -44,6 +44,7 @@
 #include <gtest/gtest.h>
 
 #include <stdexcept>
+#include <fcntl.h>
 
 namespace mg = mir::graphics;
 namespace mgm = mir::graphics::mesa;
@@ -92,21 +93,30 @@
 {
 public:
     MesaDisplayConfigurationTest()
+        : drm_fd{open(drm_device, 0, 0)}
     {
         using namespace testing;
 
         /* Needed for display start-up */
-        ON_CALL(mock_egl, eglChooseConfig(_,_,_,1,_))
-        .WillByDefault(DoAll(SetArgPointee<2>(mock_egl.fake_configs[0]),
-                             SetArgPointee<4>(1),
-                             Return(EGL_TRUE)));
+        ON_CALL(mock_egl, eglChooseConfig(_, _, _, 1, _))
+            .WillByDefault(DoAll(SetArgPointee<2>(mock_egl.fake_configs[0]),
+                                 SetArgPointee<4>(1),
+                                 Return(EGL_TRUE)));
 
         mock_egl.provide_egl_extensions();
         mock_gl.provide_gles_extensions();
 
+        ON_CALL(mock_gbm, gbm_device_get_fd(_))
+            .WillByDefault(Return(drm_fd));
+
         setup_sample_modes();
 
         fake_devices.add_standard_device("standard-drm-devices");
+
+        // Remove all outputs from all but one of the DRM devices we access;
+        // these tests are not set up to test hybrid.
+        mock_drm.reset("/dev/dri/card1");
+        mock_drm.reset("/dev/dri/card2");
     }
 
     std::shared_ptr<mg::Platform> create_platform()
@@ -160,8 +170,46 @@
     std::vector<drmModeModeInfo> modes_empty;
 
     mtf::UdevEnvironment fake_devices;
+
+    char const* const drm_device = "/dev/dri/card0";
+    int const drm_fd;
 };
 
+MATCHER_P(Unique, scratch_vector, "")
+{
+    if (std::any_of(
+        scratch_vector.begin(),
+        scratch_vector.end(),
+        [&arg](auto const& candidate) { return arg == candidate; }))
+    {
+        return false;
+    }
+    const_cast<typename std::remove_const<scratch_vector_type>::type&>(scratch_vector).push_back(arg);
+    return true;
+}
+
+MATCHER_P(DisplayConfigsAreEquivalent, expected_configs, "")
+{
+    using namespace testing;
+
+    std::vector<mg::DisplayConfigurationOutput> outputs;
+    std::vector<mg::DisplayConfigurationOutputId> output_ids;
+    arg->for_each_output([&](mg::DisplayConfigurationOutput const& output)
+                          {
+                              outputs.push_back(output);
+                              output_ids.push_back(output.id);
+                              outputs.back().id = mg::DisplayConfigurationOutputId{0};
+                          });
+
+
+    Matcher<decltype(outputs)> config_matcher = UnorderedElementsAreArray(expected_configs);
+    std::vector<mg::DisplayConfigurationOutputId> scratch_space;
+    Matcher<decltype(output_ids)> ids_are_unique = Each(Unique(scratch_space));
+
+    return
+        config_matcher.MatchAndExplain(outputs, result_listener) &&
+        ids_are_unique.MatchAndExplain(output_ids, result_listener);
+}
 }
 
 TEST_F(MesaDisplayConfigurationTest, configuration_is_read_correctly)
@@ -182,34 +230,58 @@
     std::vector<uint32_t> possible_encoder_ids_empty;
     uint32_t const possible_crtcs_mask_empty{0};
 
-    mtd::FakeDRMResources& resources(mock_drm.fake_drm);
-
-    resources.reset();
-
-    resources.add_crtc(crtc0_id, modes0[1]);
-
-    resources.add_encoder(encoder0_id, crtc0_id, possible_crtcs_mask_empty);
-    resources.add_encoder(encoder1_id, invalid_id, possible_crtcs_mask_empty);
-
-    resources.add_connector(connector0_id, DRM_MODE_CONNECTOR_HDMIA,
-                            DRM_MODE_CONNECTED, encoder0_id,
-                            modes0, possible_encoder_ids_empty,
-                            connector0_physical_size_mm);
-    resources.add_connector(connector1_id, DRM_MODE_CONNECTOR_Unknown,
-                            DRM_MODE_DISCONNECTED, invalid_id,
-                            modes_empty, possible_encoder_ids_empty,
-                            connector1_physical_size_mm);
-    resources.add_connector(connector2_id, DRM_MODE_CONNECTOR_eDP,
-                            DRM_MODE_DISCONNECTED, encoder1_id,
-                            modes_empty, possible_encoder_ids_empty,
-                            connector2_physical_size_mm);
-
-    resources.prepare();
+    mock_drm.reset(drm_device);
+
+    mock_drm.add_crtc(
+        drm_device,
+        crtc0_id,
+        modes0[1]);
+
+    mock_drm.add_encoder(
+        drm_device,
+        encoder0_id,
+        crtc0_id,
+        possible_crtcs_mask_empty);
+    mock_drm.add_encoder(
+        drm_device,
+        encoder1_id,
+        invalid_id,
+        possible_crtcs_mask_empty);
+
+    mock_drm.add_connector(
+        drm_device,
+        connector0_id,
+        DRM_MODE_CONNECTOR_HDMIA,
+        DRM_MODE_CONNECTED,
+        encoder0_id,
+        modes0,
+        possible_encoder_ids_empty,
+        connector0_physical_size_mm);
+    mock_drm.add_connector(
+        drm_device,
+        connector1_id,
+        DRM_MODE_CONNECTOR_Unknown,
+        DRM_MODE_DISCONNECTED,
+        invalid_id,
+        modes_empty,
+        possible_encoder_ids_empty,
+        connector1_physical_size_mm);
+    mock_drm.add_connector(
+        drm_device,
+        connector2_id,
+        DRM_MODE_CONNECTOR_eDP,
+        DRM_MODE_DISCONNECTED,
+        encoder1_id,
+        modes_empty,
+        possible_encoder_ids_empty,
+        connector2_physical_size_mm);
+
+    mock_drm.prepare(drm_device);
 
     std::vector<mg::DisplayConfigurationOutput> const expected_outputs =
     {
         {
-            mg::DisplayConfigurationOutputId{connector0_id},
+            mg::DisplayConfigurationOutputId{0},
             mg::DisplayConfigurationCardId{0},
             mg::DisplayConfigurationOutputType::hdmia,
             {},
@@ -231,7 +303,7 @@
             {}
         },
         {
-            mg::DisplayConfigurationOutputId{connector1_id},
+            mg::DisplayConfigurationOutputId{0},
             mg::DisplayConfigurationCardId{0},
             mg::DisplayConfigurationOutputType::unknown,
             {},
@@ -253,7 +325,7 @@
             {}
         },
         {
-            mg::DisplayConfigurationOutputId{connector2_id},
+            mg::DisplayConfigurationOutputId{0},
             mg::DisplayConfigurationCardId{0},
             mg::DisplayConfigurationOutputType::edp,
             {},
@@ -281,16 +353,7 @@
 
     auto conf = display->configuration();
 
-    size_t output_count{0};
-
-    conf->for_each_output([&](mg::DisplayConfigurationOutput const& output)
-    {
-        ASSERT_LT(output_count, expected_outputs.size());
-        EXPECT_EQ(expected_outputs[output_count], output) << "output_count: " << output_count;
-        ++output_count;
-    });
-
-    EXPECT_EQ(expected_outputs.size(), output_count);
+    EXPECT_THAT(conf, DisplayConfigsAreEquivalent(expected_outputs));
 }
 
 TEST_F(MesaDisplayConfigurationTest, reads_subpixel_information_correctly)
@@ -305,8 +368,6 @@
     std::vector<uint32_t> possible_encoder_ids_empty;
     uint32_t const possible_crtcs_mask_empty{0};
 
-    mtd::FakeDRMResources& resources(mock_drm.fake_drm);
-
     struct TestData
     {
         drmModeSubPixel drm_subpixel;
@@ -324,19 +385,31 @@
     for (auto& data : test_data)
     {
 
-        resources.reset();
-
-        resources.add_crtc(crtc0_id, modes0[1]);
-
-        resources.add_encoder(encoder0_id, crtc0_id, possible_crtcs_mask_empty);
-
-        resources.add_connector(connector0_id, DRM_MODE_CONNECTOR_HDMIA,
-                                DRM_MODE_CONNECTED, encoder0_id,
-                                modes0, possible_encoder_ids_empty,
-                                connector0_physical_size_mm,
-                                data.drm_subpixel);
-
-        resources.prepare();
+        mock_drm.reset(drm_device);
+
+        mock_drm.add_crtc(
+            drm_device,
+            crtc0_id,
+            modes0[1]);
+
+        mock_drm.add_encoder(
+            drm_device,
+            encoder0_id,
+            crtc0_id,
+            possible_crtcs_mask_empty);
+
+        mock_drm.add_connector(
+            drm_device,
+            connector0_id,
+            DRM_MODE_CONNECTOR_HDMIA,
+            DRM_MODE_CONNECTED,
+            encoder0_id,
+            modes0,
+            possible_encoder_ids_empty,
+            connector0_physical_size_mm,
+            data.drm_subpixel);
+
+        mock_drm.prepare(drm_device);
 
         /* Test body */
         auto display = create_display(create_platform());
@@ -369,21 +442,31 @@
     std::vector<uint32_t> possible_encoder_ids_empty;
     uint32_t const possible_crtcs_mask_empty{0};
 
-    mtd::FakeDRMResources& resources(mock_drm.fake_drm);
-
-    resources.reset();
-
-    resources.add_crtc(crtc0_id, modes0[1]);
-
-    resources.add_encoder(encoder0_id, crtc0_id, possible_crtcs_mask_empty);
-
-    resources.add_connector(connector0_id, DRM_MODE_CONNECTOR_HDMIA,
-                            DRM_MODE_CONNECTED, encoder0_id,
-                            modes0, possible_encoder_ids_empty,
-                            connector0_physical_size_mm,
-                            DRM_MODE_SUBPIXEL_NONE);
-
-    resources.prepare();
+    mock_drm.reset(drm_device);
+
+    mock_drm.add_crtc(
+        drm_device,
+        crtc0_id,
+        modes0[1]);
+
+    mock_drm.add_encoder(
+        drm_device,
+        encoder0_id,
+        crtc0_id,
+        possible_crtcs_mask_empty);
+
+    mock_drm.add_connector(
+        drm_device,
+        connector0_id,
+        DRM_MODE_CONNECTOR_HDMIA,
+        DRM_MODE_CONNECTED,
+        encoder0_id,
+        modes0,
+        possible_encoder_ids_empty,
+        connector0_physical_size_mm,
+        DRM_MODE_SUBPIXEL_NONE);
+
+    mock_drm.prepare(drm_device);
 
     struct TestData
     {
@@ -405,19 +488,31 @@
     for (auto& data : test_data)
     {
 
-        resources.reset();
-
-        resources.add_crtc(crtc0_id, modes0[1]);
-
-        resources.add_encoder(encoder0_id, crtc0_id, possible_crtcs_mask_empty);
-
-        resources.add_connector(connector0_id, DRM_MODE_CONNECTOR_HDMIA,
-                                DRM_MODE_CONNECTED, encoder0_id,
-                                modes0, possible_encoder_ids_empty,
-                                connector0_physical_size_mm,
-                                data.drm_subpixel);
-
-        resources.prepare();
+        mock_drm.reset(drm_device);
+
+        mock_drm.add_crtc(
+            drm_device,
+            crtc0_id,
+            modes0[1]);
+
+        mock_drm.add_encoder(
+            drm_device,
+            encoder0_id,
+            crtc0_id,
+            possible_crtcs_mask_empty);
+
+        mock_drm.add_connector(
+            drm_device,
+            connector0_id,
+            DRM_MODE_CONNECTOR_HDMIA,
+            DRM_MODE_CONNECTED,
+            encoder0_id,
+            modes0,
+            possible_encoder_ids_empty,
+            connector0_physical_size_mm,
+            data.drm_subpixel);
+
+        mock_drm.prepare(drm_device);
 
         mt::Signal handler_signal;
         MainLoop ml;
@@ -442,88 +537,6 @@
     }
 }
 
-TEST_F(MesaDisplayConfigurationTest, get_kms_connector_id_returns_correct_id)
-{
-    uint32_t const crtc0_id{10};
-    uint32_t const encoder0_id{20};
-    uint32_t const possible_crtcs_mask_empty{0};
-    std::vector<uint32_t> const connector_ids{30, 31};
-    std::vector<uint32_t> encoder_ids{20};
-
-    /* Set up DRM resources */
-    mtd::FakeDRMResources& resources(mock_drm.fake_drm);
-
-    resources.reset();
-
-    resources.add_crtc(crtc0_id, modes0[1]);
-    resources.add_encoder(encoder0_id, crtc0_id, possible_crtcs_mask_empty);
-    for (auto id : connector_ids)
-    {
-        resources.add_connector(id, DRM_MODE_CONNECTOR_DVID,
-                                DRM_MODE_CONNECTED, encoder0_id,
-                                modes0, encoder_ids,
-                                geom::Size());
-    }
-
-    resources.prepare();
-
-    /* Test body */
-    auto display = create_display(create_platform());
-
-    std::shared_ptr<mg::DisplayConfiguration> conf = display->configuration();
-    auto const& kms_conf = std::static_pointer_cast<mgm::KMSDisplayConfiguration>(conf);
-
-    size_t output_count{0};
-
-    conf->for_each_output([&](mg::DisplayConfigurationOutput const& output)
-    {
-        ASSERT_LT(output_count, connector_ids.size());
-
-        EXPECT_EQ(connector_ids[output_count],
-                  kms_conf->get_kms_connector_id(output.id));
-        ++output_count;
-    });
-}
-
-TEST_F(MesaDisplayConfigurationTest, get_kms_connector_id_throws_on_invalid_id)
-{
-    uint32_t const crtc0_id{10};
-    uint32_t const encoder0_id{20};
-    uint32_t const possible_crtcs_mask_empty{0};
-    std::vector<uint32_t> const connector_ids{30, 31};
-    std::vector<uint32_t> encoder_ids{20};
-
-    /* Set up DRM resources */
-    mtd::FakeDRMResources& resources(mock_drm.fake_drm);
-
-    resources.reset();
-
-    resources.add_crtc(crtc0_id, modes0[1]);
-    resources.add_encoder(encoder0_id, crtc0_id, possible_crtcs_mask_empty);
-    for (auto id : connector_ids)
-    {
-        resources.add_connector(id, DRM_MODE_CONNECTOR_VGA,
-                                DRM_MODE_CONNECTED, encoder0_id,
-                                modes0, encoder_ids,
-                                geom::Size());
-    }
-
-    resources.prepare();
-
-    /* Test body */
-    auto display = create_display(create_platform());
-
-    std::shared_ptr<mg::DisplayConfiguration> conf = display->configuration();
-    auto const& kms_conf = std::static_pointer_cast<mgm::KMSDisplayConfiguration>(conf);
-
-    EXPECT_THROW({
-        kms_conf->get_kms_connector_id(mg::DisplayConfigurationOutputId{29});
-    }, std::runtime_error);
-    EXPECT_THROW({
-        kms_conf->get_kms_connector_id(mg::DisplayConfigurationOutputId{32});
-    }, std::runtime_error);
-}
-
 TEST_F(MesaDisplayConfigurationTest, returns_updated_configuration)
 {
     using namespace ::testing;
@@ -545,7 +558,7 @@
     std::vector<mg::DisplayConfigurationOutput> const expected_outputs_before =
     {
         {
-            mg::DisplayConfigurationOutputId(connector_ids[0]),
+            mg::DisplayConfigurationOutputId{0},
             mg::DisplayConfigurationCardId{0},
             mg::DisplayConfigurationOutputType::composite,
             {},
@@ -567,7 +580,7 @@
             {}
         },
         {
-            mg::DisplayConfigurationOutputId(connector_ids[1]),
+            mg::DisplayConfigurationOutputId{0},
             mg::DisplayConfigurationCardId{0},
             mg::DisplayConfigurationOutputType::vga,
             {},
@@ -593,7 +606,7 @@
     std::vector<mg::DisplayConfigurationOutput> const expected_outputs_after =
     {
         {
-            mg::DisplayConfigurationOutputId(connector_ids[0]),
+            mg::DisplayConfigurationOutputId{0},
             mg::DisplayConfigurationCardId{0},
             mg::DisplayConfigurationOutputType::composite,
             {},
@@ -615,7 +628,7 @@
             {}
         },
         {
-            mg::DisplayConfigurationOutputId(connector_ids[1]),
+            mg::DisplayConfigurationOutputId{0},
             mg::DisplayConfigurationCardId{0},
             mg::DisplayConfigurationOutputType::vga,
             {},
@@ -639,60 +652,100 @@
     };
 
     /* Set up DRM resources and check */
-    mtd::FakeDRMResources& resources(mock_drm.fake_drm);
-    auto const syspath = fake_devices.add_device("drm", "card2", NULL, {}, {"DEVTYPE", "drm_minor"});
-
-    resources.reset();
-
-    resources.add_crtc(crtc_ids[0], modes0[1]);
-
-    resources.add_encoder(encoder_ids[0], crtc_ids[0], possible_crtcs_mask_empty);
-    resources.add_encoder(encoder_ids[1], invalid_id, possible_crtcs_mask_empty);
-
-    resources.add_connector(connector_ids[0], DRM_MODE_CONNECTOR_Composite,
-                            DRM_MODE_CONNECTED, encoder_ids[0],
-                            modes0, possible_encoder_ids_empty,
-                            connector_physical_sizes_mm_before[0]);
-    resources.add_connector(connector_ids[1], DRM_MODE_CONNECTOR_VGA,
-                            DRM_MODE_DISCONNECTED, invalid_id,
-                            modes_empty, possible_encoder_ids_empty,
-                            connector_physical_sizes_mm_before[1]);
-
-    resources.prepare();
+    auto const syspath = fake_devices.add_device(
+        "drm",
+        "card2",
+        NULL,
+        {},
+        {
+            "DEVTYPE", "drm_minor",
+            "DEVNAME", "/dev/dri/card2"
+        });
+
+    mock_drm.reset(drm_device);
+
+    mock_drm.add_crtc(
+        drm_device,
+        crtc_ids[0],
+        modes0[1]);
+
+    mock_drm.add_encoder(
+        drm_device,
+        encoder_ids[0],
+        crtc_ids[0],
+        possible_crtcs_mask_empty);
+    mock_drm.add_encoder(
+        drm_device,
+        encoder_ids[1],
+        invalid_id,
+        possible_crtcs_mask_empty);
+
+    mock_drm.add_connector(
+        drm_device,
+        connector_ids[0],
+        DRM_MODE_CONNECTOR_Composite,
+        DRM_MODE_CONNECTED,
+        encoder_ids[0],
+        modes0,
+        possible_encoder_ids_empty,
+        connector_physical_sizes_mm_before[0]);
+    mock_drm.add_connector(
+        drm_device,
+        connector_ids[1],
+        DRM_MODE_CONNECTOR_VGA,
+        DRM_MODE_DISCONNECTED,
+        invalid_id,
+        modes_empty,
+        possible_encoder_ids_empty,
+        connector_physical_sizes_mm_before[1]);
+
+    mock_drm.prepare(drm_device);
 
     auto display = create_display(create_platform());
 
     auto conf = display->configuration();
 
-    size_t output_count{0};
-
-    conf->for_each_output([&](mg::DisplayConfigurationOutput const& output)
-    {
-        ASSERT_LT(output_count, expected_outputs_before.size());
-        EXPECT_EQ(expected_outputs_before[output_count], output) << "output_count: " << output_count;
-        ++output_count;
-    });
-
-    EXPECT_EQ(expected_outputs_before.size(), output_count);
+    EXPECT_THAT(conf, DisplayConfigsAreEquivalent(expected_outputs_before));
 
     /* Reset DRM resources and check again */
-    resources.reset();
-
-    resources.add_crtc(crtc_ids[1], modes0[1]);
-
-    resources.add_encoder(encoder_ids[0], invalid_id, possible_crtcs_mask_empty);
-    resources.add_encoder(encoder_ids[1], crtc_ids[1], possible_crtcs_mask_empty);
-
-    resources.add_connector(connector_ids[0], DRM_MODE_CONNECTOR_Composite,
-                            DRM_MODE_DISCONNECTED, invalid_id,
-                            modes_empty, possible_encoder_ids_empty,
-                            connector_physical_sizes_mm_after[0]);
-    resources.add_connector(connector_ids[1], DRM_MODE_CONNECTOR_VGA,
-                            DRM_MODE_CONNECTED, encoder_ids[1],
-                            modes0, possible_encoder_ids_empty,
-                            connector_physical_sizes_mm_after[1]);
-
-    resources.prepare();
+    mock_drm.reset(drm_device);
+
+    mock_drm.add_crtc(
+        drm_device,
+        crtc_ids[1],
+        modes0[1]);
+
+    mock_drm.add_encoder(
+        drm_device,
+        encoder_ids[0],
+        invalid_id,
+        possible_crtcs_mask_empty);
+    mock_drm.add_encoder(
+        drm_device,
+        encoder_ids[1],
+        crtc_ids[1],
+        possible_crtcs_mask_empty);
+
+    mock_drm.add_connector(
+        drm_device,
+        connector_ids[0],
+        DRM_MODE_CONNECTOR_Composite,
+        DRM_MODE_DISCONNECTED,
+        invalid_id,
+        modes_empty,
+        possible_encoder_ids_empty,
+        connector_physical_sizes_mm_after[0]);
+    mock_drm.add_connector(
+        drm_device,
+        connector_ids[1],
+        DRM_MODE_CONNECTOR_VGA,
+        DRM_MODE_CONNECTED,
+        encoder_ids[1],
+        modes0,
+        possible_encoder_ids_empty,
+        connector_physical_sizes_mm_after[1]);
+
+    mock_drm.prepare(drm_device);
 
     /* Fake a device change so display can fetch updated configuration*/
     MainLoop ml;
@@ -703,16 +756,7 @@
 
     conf = display->configuration();
 
-    output_count = 0;
-
-    conf->for_each_output([&](mg::DisplayConfigurationOutput const& output)
-    {
-        ASSERT_LT(output_count, expected_outputs_after.size());
-        EXPECT_EQ(expected_outputs_after[output_count], output) << "output_count: " << output_count;
-        ++output_count;
-    });
-
-    EXPECT_EQ(expected_outputs_after.size(), output_count);
+    EXPECT_THAT(conf, DisplayConfigsAreEquivalent(expected_outputs_after));
 }
 
 TEST_F(MesaDisplayConfigurationTest, new_monitor_matches_hardware_state)
@@ -727,12 +771,11 @@
     geom::Size const connector_physical_sizes_mm_after{512, 642};
     std::vector<uint32_t> possible_encoder_ids_empty;
     uint32_t const possible_crtcs_mask_empty{0};
-    int const noutputs = 1;
 
-    mg::DisplayConfigurationOutput const expected_outputs_before[noutputs] =
+    std::vector<mg::DisplayConfigurationOutput> const expected_outputs_before =
     {
         {
-            mg::DisplayConfigurationOutputId(connector_ids[0]),
+            mg::DisplayConfigurationOutputId{0},
             mg::DisplayConfigurationCardId{0},
             mg::DisplayConfigurationOutputType::composite,
             {},
@@ -755,10 +798,10 @@
         },
     };
 
-    mg::DisplayConfigurationOutput const expected_outputs_after[noutputs] =
+    std::vector<mg::DisplayConfigurationOutput> const expected_outputs_after =
     {
         {
-            mg::DisplayConfigurationOutputId(connector_ids[0]),
+            mg::DisplayConfigurationOutputId{0},
             mg::DisplayConfigurationCardId{0},
             mg::DisplayConfigurationOutputType::composite,
             {},