Mir

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

mesa-hybrid-output
Merge into development-branch

Proposed by Chris Halse Rogers on 2017-03-17

Status:	Merged
Approved by:	Daniel van Vugt on 2017-04-04
Approved revision:	no longer in the source branch.
Merged at revision:	4137
Proposed branch:	lp:~raof/mir/mesa-hybrid-output
Merge into:	lp:mir
Prerequisite:	lp:~raof/mir/rearrange-drm-configuration
Diff against target:	4141 lines (+1816/-509) 38 files modified CMakeLists.txt (+4/-0) src/platforms/mesa/server/display_helpers.cpp (+95/-2) src/platforms/mesa/server/display_helpers.h (+7/-1) src/platforms/mesa/server/kms/CMakeLists.txt (+1/-0) src/platforms/mesa/server/kms/display.cpp (+188/-32) src/platforms/mesa/server/kms/display.h (+2/-2) src/platforms/mesa/server/kms/display_buffer.cpp (+414/-19) src/platforms/mesa/server/kms/display_buffer.h (+6/-5) src/platforms/mesa/server/kms/kms_output.h (+20/-1) src/platforms/mesa/server/kms/platform.cpp (+36/-9) src/platforms/mesa/server/kms/platform.h (+1/-1) src/platforms/mesa/server/kms/real_kms_output.cpp (+41/-19) src/platforms/mesa/server/kms/real_kms_output.h (+6/-1) src/platforms/mesa/server/kms/real_kms_output_container.cpp (+42/-21) src/platforms/mesa/server/kms/real_kms_output_container.h (+7/-5) src/server/input/default_input_device_hub.cpp (+1/-1) tests/include/mir/test/doubles/mock_drm.h (+35/-1) tests/include/mir/test/doubles/mock_gbm.h (+1/-0) tests/include/mir/test/doubles/mock_gl.h (+1/-0) tests/mir_test_doubles/mock_drm.cpp (+180/-7) tests/mir_test_doubles/mock_egl.cpp (+1/-1) tests/mir_test_doubles/mock_gbm.cpp (+5/-0) tests/mir_test_doubles/mock_gl.cpp (+8/-0) tests/unit-tests/platforms/mesa/CMakeLists.txt (+2/-1) tests/unit-tests/platforms/mesa/kms-utils/test_connector_utils.cpp (+74/-43) tests/unit-tests/platforms/mesa/kms/mock_kms_output.h (+3/-0) tests/unit-tests/platforms/mesa/kms/test_display.cpp (+55/-54) tests/unit-tests/platforms/mesa/kms/test_display_buffer.cpp (+17/-0) tests/unit-tests/platforms/mesa/kms/test_display_configuration.cpp (+308/-136) tests/unit-tests/platforms/mesa/kms/test_display_generic.cpp (+13/-0) tests/unit-tests/platforms/mesa/kms/test_display_multi_monitor.cpp (+49/-28) tests/unit-tests/platforms/mesa/kms/test_drm_helper.cpp (+20/-2) tests/unit-tests/platforms/mesa/kms/test_guest_platform.cpp (+5/-1) tests/unit-tests/platforms/mesa/kms/test_kms_page_flipper.cpp (+42/-31) tests/unit-tests/platforms/mesa/kms/test_platform.cpp (+13/-23) tests/unit-tests/platforms/mesa/kms/test_real_kms_output.cpp (+111/-60) tests/unit-tests/platforms/mesa/x11/test_guest_platform.cpp (+1/-1) tests/unit-tests/platforms/mesa/x11/test_platform.cpp (+1/-1)
To merge this branch:	bzr merge lp:~raof/mir/mesa-hybrid-output
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
Kevin DuBois (community)			Approve on 2017-04-03
Mir CI Bot	continuous-integration		Approve on 2017-03-31
Michael Zanetti (community)			Needs Information on 2017-03-29
Alan Griffiths			Approve on 2017-03-29
Cemil Azizoglu (community)		2017-03-17	Approve on 2017-03-28
Review via email: mp+320140@code.launchpad.net

Commit message

Initial hybrid-output support for mesa-kms platform.

This is (mostly) what is known in the X world as reverse-prime - rendering on the integrated card, displaying on the external GPU.

This selects whatever card is first to initialise in DRM (which is [usually?] the boot VGA device) to do all shell rendering on, but exposes all outputs across all GPUs for display.

As a first cut, it misses out on hardware cursor support for hybrid systems, and performance on hybrid systems will be non-optimal, but this should not significantly change the code flow for non-hybrid systems.

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2017-03-17:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/3181/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2017-03-20:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/3189/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2017-03-20:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/3192/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2017-03-20:

I guess you have to predefine GBM_BO_LINEAR ..

I will try this mp later today.. it used to work fine with the two cards here.

Revision history for this message

Chris Halse Rogers (raof) wrote on 2017-03-20:

vivid+overlay builds no longer try building mesa-kms, so that should work :)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2017-03-20:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/3200/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2017-03-21:

FAILED: Continuous integration, rev:4083
https://mir-jenkins.ubuntu.com/job/mir-ci/3202/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/4306/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/4393
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/4383
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/4383
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=zesty/4383

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/3202/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2017-03-22:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/3209/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2017-03-22:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/3217/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2017-03-23:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/3219/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2017-03-23:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/3221/rebuild

review: Approve (continuous-integration)

Revision history for this message

Cemil Azizoglu (cemil-azizoglu) wrote on 2017-03-23:

How do I test this branch? I have two GPUs, what do I expect to see happen differently? I usually have to do

echo OFF > /sys/kernel/debug/vgaswitcheroo/switch

to turn off the discrete GPU (nouveau, this case) to get non-garbage output (in Mir-on-X, though).

What should happen with this branch if I have two GPUs but one of them is disabled?

review: Needs Information

Revision history for this message

Chris Halse Rogers (raof) wrote on 2017-03-27:

Hm. I was sure I'd written a response to that. Anyway...

If you've got two GPUs you should *at least* expect to see Mir to say “using /dev/dri/card0” and “/dev/dri/card1” on startup. The rest depends on your setup...

If you've got two GPUs *and* you've got outputs plugged in to both, mir_demo_server should, by default, mirror across all plugged in outputs across all GPUs (I've not tried it with > 2 GPUs, but the code doesn't discriminate between 2 and > 2).

Revision history for this message

Cemil Azizoglu (cemil-azizoglu) wrote on 2017-03-27:

Conflicts...

Also it won't build at the moment:

...
[ 45%] Linking CXX executable ../../../../bin/mir_demo_standalone_render_overlays.bin
//usr/lib/x86_64-linux-gnu/libmirclient.so.9: undefined reference to `MirInputDeviceStateEvent::device_pressed_keys_for_index(unsigned long, unsigned long) const@MIR_COMMON_0.25_PRIVATE'
//usr/lib/x86_64-linux-gnu/libmirclient.so.9: undefined reference to `MirPointerEvent::set_x(float)@MIR_COMMON_0.25_PRIVATE'
//usr/lib/x86_64-linux-gnu/libmirclient.so.9: undefined reference to `MirTouchEvent::pressure(unsigned long) const@MIR_COMMON_0.25_PRIVATE'
...

review: Needs Fixing

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2017-03-27:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/3258/rebuild

review: Approve (continuous-integration)

Revision history for this message

Cemil Azizoglu (cemil-azizoglu) wrote on 2017-03-28:

I tested the branch on a laptop with integrated Intel and discrete NVidia GPU (with only one monitor) and it seems to work fine. When I have both GPUs powered, it's able to open both cards. When I have the discrete GPU turned off, it complains that it cannot open card1, which is expected.

I did observe that if I do

sudo bin/mir_demo_server --vt 1

and then close the server with ctl-alt-bkspace //without running any clients on it first// it seems to hang my machine (black screen, vt switches no working). Not sure if it's due to this branch.

I'm not sure if it's prudent to mirror the output on all displays. It's not clear to me if it's the default policy or if it's something this branch does. I think it's a 'to-do' per this comment :

1041 + // TODO: expose multiple rendering GPUs to the shell.

I did spot the following nit :

142 + ".... configuration requries hybrid ..."

review: Approve

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2017-03-29:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/3269/rebuild

review: Approve (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2017-03-29:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/3272/rebuild

review: Approve (continuous-integration)

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2017-03-29:

+ private:
+ static mgm::GBMSurfaceUPtr create_scanout_surface(

Don't we usually indent like this:

private:
static mgm::GBMSurfaceUPtr create_scanout_surface(

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2017-03-29:

There's spurious whitespace at the end of at least one line.

But it all looks plausible and doesn't break anything obvious on my (non-hybrid) system.

review: Approve

Revision history for this message

Michael Zanetti (mzanetti) wrote on 2017-03-29:

I've tried this with silo 2373. The good news is, I do get the shell on the external screen now, the bad news is, the internal one claims to be disconnected now. This is on a MacBook Pro 10.1 (1st gen Retina) with an integrated Intel HD440 and an NVidia GeForce GT 650M Mac Edition as discrete graphics.

Here's the relevant log I get from Mir:

[2017-03-29 18:54:38.940700] mirserver: Initial display configuration:
[2017-03-29 18:54:38.941421] mirserver: Output 47: eDP disconnected
[2017-03-29 18:54:38.941781] mirserver: Output 50: DisplayPort disconnected
[2017-03-29 18:54:38.942547] mirserver: Output 54: DisplayPort disconnected
[2017-03-29 18:54:38.942908] mirserver: Output 58: HDMI-A connected, used
[2017-03-29 18:54:38.943267] mirserver: EDID monitor name: Panasonic-TV
[2017-03-29 18:54:38.946217] mirserver: EDID manufacturer: MEI
[2017-03-29 18:54:38.946267] mirserver: EDID product code: 41127
[2017-03-29 18:54:38.946288] mirserver: Physical size 0,0" 0x0mm
[2017-03-29 18:54:38.946303] mirserver: Power is on
[2017-03-29 18:54:38.946322] mirserver: Current mode 1920x1080 50,00Hz
[2017-03-29 18:54:38.946337] mirserver: Preferred mode 1920x1080 50,00Hz
[2017-03-29 18:54:38.946352] mirserver: Orientation normal
[2017-03-29 18:54:38.946365] mirserver: Logical size 1920x1080
[2017-03-29 18:54:38.946388] mirserver: Logical position +0+0

Not sure if I need to fiddle something with the drivers but it looks to me like Output 47 claims to be disconnected while it is not (as it is the internal display).

review: Needs Information

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2017-03-30:

If you're using the latest Mir code that this branch depends on, your outputs would be numbered 1-N. I'm not sure if that indicates your silo is incomplete...

Revision history for this message

Chris Halse Rogers (raof) wrote on 2017-03-30:

Additionally, next time please post the full Mir log; you've cut out some relevant information (particularly: has it actually picked up both your GPUs!)

Revision history for this message

Michael Zanetti (mzanetti) wrote on 2017-03-30:

Here's the complete log: http://paste.ubuntu.com/24279666/

And here's the silo with this branch: https://bileto.ubuntu.com/#/ticket/2373

Revision history for this message

Chris Halse Rogers (raof) wrote on 2017-03-30:

Hmm, that's the (nested) Unity 8 log. Could you attach the USC log? USC is the one that actually interfaces with the hardware.

Revision history for this message

Michael Zanetti (mzanetti) wrote on 2017-03-30:

Sorry, here's unity-system-compositor's log: http://paste.ubuntu.com/24280507/

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2017-03-31:

Just a warning: nouveau is highly unstable and will crash if used from multiple threads (or multiple heads) -> bug 1553328

I strongly recommend not using nouveau (which also means not using Nvidia at all) for now. At least until we have adequate workarounds for bug 1553328 in place, or complete Nvidia proprietary driver support.

Revision history for this message

Chris Halse Rogers (raof) wrote on 2017-03-31:

I've just added some extra startup logging that will make it clear
a) What cards are being driven, and by what driver,
b) What outputs are attached, to what card, and
c) What outputs are *connected*, and the modes drm gives us (if any)

Please pull that into your silo, and try again :)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2017-03-31:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/3286/rebuild

review: Approve (continuous-integration)

Revision history for this message

Mir CI Bot (mir-ci-bot) wrote on 2017-03-31:

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/3288/rebuild

review: Approve (continuous-integration)

Revision history for this message

Kevin DuBois (kdub) wrote on 2017-04-03:

lgtm overall.

low-hanging fix:
EGLBufferCopier should check more of the RC codes coming from egl, and throw or at least log if there are failures in setup.
eg,
758+ eglMakeCurrent(display, egl_surface, egl_surface, context);

future improvements/opinions that don't need fixing / are non-blocking.
+ EGLBufferCopier::EGLBufferCopier()
some of the egl/gl initialization stuff could use RAII to clean up better if an exception is thrown. (additionally, maybe some of the stuff in src/include/platform/mir/graphics could be reused? a specific example would be that mg::EGLExtensions would load the 3 buffer import functions )

+ static std::vector<std::shared_ptr<DRMHelper>> open_all_devices(
why static?

+ double hz = (mode.clock * 100000LL /
253 + ((long)mode.htotal * (long)mode.vtotal)
254 + ) / 100.0;
could use std::chrono conversions (even if they're long, they make for quicker visual checks imo)

492 + auto const raw_surface = surface.get();
could just call surface.get() when making the db a few lines later

review: Approve

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Chris Halse Rogers

Emanuele Antonio Faraone

Gerry Boland

Mir development team

 === modified file 'CMakeLists.txt'
 --- CMakeLists.txt	2017-03-24 15:20:01 +0000
 +++ CMakeLists.txt	2017-03-31 06:57:08 +0000
@@ -264,6 +264,10 @@
    find_package( PkgConfig )
    pkg_check_modules( GBM REQUIRED gbm>=9.0.0)
    pkg_check_modules( DRM REQUIRED libdrm )
++  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()
  endif()
  if (MIR_BUILD_PLATFORM_EGLSTREAM_KMS)
 === 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-31 06:57:08 +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 requires 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-31 06:57:08 +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-31 06:57:08 +0000
@@ -38,6 +38,7 @@
    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
 === modified file 'src/platforms/mesa/server/kms/display.cpp'
 --- src/platforms/mesa/server/kms/display.cpp	2017-03-22 07:01:56 +0000
 +++ src/platforms/mesa/server/kms/display.cpp	2017-03-31 06:57:08 +0000
@@ -37,8 +37,14 @@
  #include <boost/exception/get_error_info.hpp>
  #include <boost/exception/errinfo_errno.hpp>
++#define MIR_LOG_COMPONENT "mesa-kms"
++#include "mir/log.h"
++#include "kms-utils/drm_mode_resources.h"
++#include "kms-utils/kms_connector.h"
++
  #include <stdexcept>
  #include <algorithm>
++#include <unordered_map>
  namespace mgm = mir::graphics::mesa;
  namespace mg = mir::graphics;
@@ -78,23 +84,118 @@
      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;
++}
++
++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;
++
++    return hz;
++}
++
++char const* describe_connection_status(drmModeConnector const& connection)
++{
++    switch (connection.connection)
++    {
++    case DRM_MODE_CONNECTED:
++        return "connected";
++    case DRM_MODE_DISCONNECTED:
++        return "disconnected";
++    case DRM_MODE_UNKNOWNCONNECTION:
++        return "UNKNOWN";
++    default:
++        return "<Unexpected connection value>";
++    }
++}
++
++void log_drm_details(std::vector<std::shared_ptr<mgm::helpers::DRMHelper>> const& drm)
++{
++    mir::log_info("DRM device details:");
++    for (auto const& device : drm)
++    {
++        auto version = std::unique_ptr<drmVersion, decltype(&drmFreeVersion)>{
++            drmGetVersion(device->fd),
++            &drmFreeVersion};
++
++        auto device_name = std::unique_ptr<char, decltype(&free)>{
++            drmGetDeviceNameFromFd(device->fd),
++            &free
++        };
++
++        mir::log_info(
++            "%s: using driver %s [%s] (version: %i.%i.%i driver date: %s)",
++            device_name.get(),
++            version->name,
++            version->desc,
++            version->version_major,
++            version->version_minor,
++            version->version_patchlevel,
++            version->date);
++
++        mg::kms::DRMModeResources resources{device->fd};
++        for (auto const& connector : resources.connectors())
++        {
++            mir::log_info(
++                "\tOutput: %s (%s)",
++                mg::kms::connector_name(connector).c_str(),
++                describe_connection_status(*connector));
++            for (auto i = 0; i < connector->count_modes; ++i)
++            {
++                mir::log_info(
++                    "\t\tMode: %i×%i@%.2f",
++                    connector->modes[i].hdisplay,
++                    connector->modes[i].vdisplay,
++                    calculate_vrefresh_hz(connector->modes[i]));
++            }
++        }
++    }
++}
++
++}
++
++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{std::make_shared<RealKMSOutputContainer>(drm->fd,
--                       std::make_shared<KMSPageFlipper>(drm->fd, listener))},
++      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),
@@ -107,6 +208,8 @@
      monitor.filter_by_subsystem_and_type("drm", "drm_minor");
      monitor.enable();
++    log_drm_details(drm);
++
      initial_conf_policy->apply_to(current_display_configuration);
      configure(current_display_configuration);
@@ -193,7 +296,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 +310,8 @@
+ {
      try
+     {
--        drm->set_master();
++        for (auto& helper : drm)
++            helper->set_master();
+     }
      catch(std::runtime_error const& e)
+     {
@@ -233,6 +338,17 @@
  auto mgm::Display::create_hardware_cursor() -> std::shared_ptr<graphics::Cursor>
+ {
++    /*
++     * TODO: Using the hardware cursor in a hybrid-output situation requires making
++     * mgm::Cursor hybrid-aware so it can create a cursor bo on each GPU.
++     *
++     * For a first cut, just disable the hardware cursor on hybrid systems.
++     */
++    if (drm.size() > 1)
++    {
++        return nullptr;
++    }
++
      // There is only one hardware cursor. We do not keep a strong reference to it in the display though,
      // if no other component of Mir is interested (i.e. the input stack does not keep a reference to send
      // position updates) we must be configured not to use a cursor and thusly let it deallocate.
@@ -331,6 +447,35 @@
      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&)
@@ -373,7 +518,8 @@
          [&](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(
@@ -388,7 +534,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));
+                     }
                      /*
@@ -411,28 +557,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-22 07:01:56 +0000
 +++ src/platforms/mesa/server/kms/display.h	2017-03-31 06:57:08 +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,7 +106,7 @@
      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;
 === modified file 'src/platforms/mesa/server/kms/display_buffer.cpp'
 --- src/platforms/mesa/server/kms/display_buffer.cpp	2017-03-24 07:06:18 +0000
 +++ src/platforms/mesa/server/kms/display_buffer.cpp	2017-03-31 06:57:08 +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));
      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))
+                 {
@@ -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);
          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-31 06:57:08 +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_output.h'
 --- src/platforms/mesa/server/kms/kms_output.h	2017-03-24 07:06:18 +0000
 +++ src/platforms/mesa/server/kms/kms_output.h	2017-03-31 06:57:08 +0000
@@ -26,6 +26,8 @@
  #include "mir/graphics/frame.h"
  #include "mir_toolkit/common.h"
++#include "kms-utils/drm_mode_resources.h"
++
  #include <gbm.h>
  namespace mir
@@ -44,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;
@@ -86,12 +94,23 @@
      virtual void update_from_hardware_state(DisplayConfigurationOutput& to_update) const = 0;
      virtual FBHandle* fb_for(gbm_bo* bo) 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/platform.cpp'
 --- src/platforms/mesa/server/kms/platform.cpp	2017-03-23 17:18:29 +0000
 +++ src/platforms/mesa/server/kms/platform.cpp	2017-03-31 06:57:08 +0000
@@ -41,17 +41,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]
@@ -59,10 +67,22 @@
                  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 (...)
++                        {
++                        }
++                    }
++                }
              }));
--    native_platform = std::make_unique<mgm::DRMNativePlatform>(*drm);
++
++    native_platform = std::make_unique<mgm::DRMNativePlatform>(*drm.front());
+ }
  mir::UniqueModulePtr<mg::GraphicBufferAllocator> mgm::Platform::create_buffer_allocator()
@@ -73,7 +93,14 @@
  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);
+ }
  mg::NativeDisplayPlatform* mgm::Platform::native_display_platform()
@@ -83,7 +110,7 @@
  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::NativeRenderingPlatform* mgm::Platform::native_rendering_platform()
 === modified file 'src/platforms/mesa/server/kms/platform.h'
 --- src/platforms/mesa/server/kms/platform.h	2017-03-23 17:18:29 +0000
 +++ src/platforms/mesa/server/kms/platform.h	2017-03-31 06:57:08 +0000
@@ -58,7 +58,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_output.cpp'
 --- src/platforms/mesa/server/kms/real_kms_output.cpp	2017-03-24 07:06:18 +0000
 +++ src/platforms/mesa/server/kms/real_kms_output.cpp	2017-03-31 06:57:08 +0000
@@ -73,7 +73,7 @@
      int drm_fd,
      kms::DRMModeConnectorUPtr&& connector,
      std::shared_ptr<PageFlipper> const& page_flipper)
--    : drm_fd{drm_fd},
++    : drm_fd_{drm_fd},
        page_flipper{page_flipper},
        connector{std::move(connector)},
        mode_index{0},
@@ -85,7 +85,7 @@
+ {
      reset();
--    kms::DRMModeResources resources{drm_fd};
++    kms::DRMModeResources resources{drm_fd_};
      if (this->connector->encoder_id)
+     {
@@ -102,9 +102,14 @@
      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
@@ -119,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"))
+             {
@@ -162,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]);
@@ -193,7 +198,7 @@
          return;
+     }
--    auto result = drmModeSetCrtc(drm_fd, current_crtc->crtc_id,
++    auto result = drmModeSetCrtc(drm_fd_, current_crtc->crtc_id,
 , 0, 0, nullptr, 0, nullptr);
      if (result)
+     {
@@ -247,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),
@@ -266,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()))
+         {
@@ -281,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)",
@@ -307,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);
@@ -317,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);
@@ -333,7 +338,7 @@
+     {
          power_mode = mode;
          drmModeConnectorSetProperty(
--            drm_fd,
++            drm_fd_,
              connector->connector_id,
              dpms_enum_id,
              mode);
@@ -357,7 +362,7 @@
+     }
      int ret = drmModeCrtcSetGamma(
--        drm_fd,
++        drm_fd_,
          current_crtc->crtc_id,
          gamma.red.size(),
          const_cast<uint16_t*>(gamma.red.data()),
@@ -373,21 +378,21 @@
  void mgm::RealKMSOutput::refresh_hardware_state()
+ {
--    connector = kms::get_connector(drm_fd, connector->connector_id);
++    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);
++        auto encoder = kms::get_encoder(drm_fd_, connector->encoder_id);
          if (encoder->crtc_id)
+         {
--            current_crtc = kms::get_crtc(drm_fd, encoder->crtc_id);
++            current_crtc = kms::get_crtc(drm_fd_, encoder->crtc_id);
+         }
+     }
+ }
--    namespace
++namespace
+ {
  bool kms_modes_are_equal(drmModeModeInfo const& info1, drmModeModeInfo const& info2)
@@ -540,7 +545,7 @@
          /* 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);
++        edid = edid_for_connector(drm_fd_, connector->connector_id);
+     }
      drmModeModeInfo current_mode_info = drmModeModeInfo();
@@ -615,7 +620,7 @@
      auto const height = gbm_bo_get_height(bo);
      /* 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;
@@ -626,3 +631,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-24 07:06:18 +0000
 +++ src/platforms/mesa/server/kms/real_kms_output.h	2017-03-31 06:57:08 +0000
@@ -44,6 +44,8 @@
          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;
@@ -68,11 +70,14 @@
      void update_from_hardware_state(DisplayConfigurationOutput& output) const override;
      FBHandle* fb_for(gbm_bo* bo) 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;
++    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	2017-03-10 10:20:24 +0000
 +++ src/platforms/mesa/server/kms/real_kms_output_container.cpp	2017-03-31 06:57:08 +0000
@@ -16,6 +16,7 @@
   * Authored by: Alexandros Frantzis <alexandros.frantzis@canonical.com>
   */
++#include <algorithm>
  #include "real_kms_output_container.h"
  #include "real_kms_output.h"
  #include "kms-utils/drm_mode_resources.h"
@@ -23,40 +24,60 @@
  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::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.second);
++        functor(output);
+ }
  void mgm::RealKMSOutputContainer::update_from_hardware_state()
+ {
--    kms::DRMModeResources resources{drm_fd};
--
      decltype(outputs) new_outputs;
--    for (auto&& connector : resources.connectors())
++    for (auto drm_fd : drm_fds)
+     {
--        if (outputs.count(connector->connector_id))
--        {
--            new_outputs[connector->connector_id] = std::move(outputs[connector->connector_id]);
--            new_outputs[connector->connector_id]->refresh_hardware_state();
--        }
--        else
--        {
--            auto const id = connector->connector_id;
--            new_outputs[id] = std::make_shared<RealKMSOutput>(
--                drm_fd,
--                std::move(connector),
--                page_flipper);
--        }
++        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	2017-03-10 10:20:24 +0000
 +++ src/platforms/mesa/server/kms/real_kms_output_container.h	2017-03-31 06:57:08 +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);
++    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 'src/server/input/default_input_device_hub.cpp'
 --- src/server/input/default_input_device_hub.cpp	2017-03-28 12:21:33 +0000
 +++ src/server/input/default_input_device_hub.cpp	2017-03-31 06:57:08 +0000
@@ -377,7 +377,7 @@
          handles.push_back(handle);
+     }
--    observers.for_each([&handle, this](std::shared_ptr<InputDeviceObserver> const& observer)
++    observers.for_each([&handle](std::shared_ptr<InputDeviceObserver> const& observer)
+         {
              observer->device_added(handle);
              observer->changes_complete();
 === 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-31 06:57:08 +0000
@@ -23,6 +23,7 @@
  #include <xf86drm.h>
  #include <xf86drmMode.h>
++#include <unordered_map>
  namespace mir
+ {
@@ -154,12 +155,45 @@
      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;
++    MOCK_METHOD1(drmGetVersion, drmVersionPtr(int));
++    MOCK_METHOD1(drmFreeVersion, void(drmVersionPtr));
++
++
++    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-31 06:57:08 +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-31 06:57:08 +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-31 06:57:08 +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));
@@ -270,6 +307,20 @@
      ON_CALL(*this, drmFreeBusid(_))
      .WillByDefault(WithArg<0>(Invoke([&](const char* busid){ free(const_cast<char*>(busid)); })));
++
++    static drmVersion const version{
++        1,
++        2,
++        3,
++        static_cast<int>(strlen("mock_driver")),
++        const_cast<char*>("mock_driver"),
++        static_cast<int>(strlen("1 Jan 1970")),
++        const_cast<char*>("1 Jan 1970"),
++        static_cast<int>(strlen("Not really a driver")),
++        const_cast<char*>("Not really a driver")
++    };
++    ON_CALL(*this, drmGetVersion(_))
++        .WillByDefault(Return(const_cast<drmVersionPtr>(&version)));
+ }
  mtd::MockDRM::~MockDRM() noexcept
@@ -277,6 +328,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);
@@ -362,6 +525,16 @@
      return global_mock->drmGetCap(fd, capability, value);
+ }
++drmVersionPtr drmGetVersion(int fd)
++{
++    return global_mock->drmGetVersion(fd);
++}
++
++void drmFreeVersion(drmVersionPtr version)
++{
++    return global_mock->drmFreeVersion(version);
++}
++
  int drmSetClientCap(int fd, uint64_t capability, uint64_t value)
+ {
      return global_mock->drmSetClientCap(fd, capability, value);
 === 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-31 06:57:08 +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-31 06:57:08 +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-31 06:57:08 +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/CMakeLists.txt'
 --- tests/unit-tests/platforms/mesa/CMakeLists.txt	2017-01-18 02:29:37 +0000
 +++ tests/unit-tests/platforms/mesa/CMakeLists.txt	2017-03-31 06:57:08 +0000
@@ -5,7 +5,8 @@
  add_subdirectory(kms-utils/)
--if (MIR_BUILD_PLATFORM_MESA_KMS)
++if (MIR_BUILD_PLATFORM_MESA_KMS AND
++    (GBM_VERSION VERSION_GREATER 11.0.0))
    add_subdirectory(kms/)
  endif()
 === 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-31 06:57:08 +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-24 07:15:51 +0000
 +++ tests/unit-tests/platforms/mesa/kms/mock_kms_output.h	2017-03-31 06:57:08 +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());
@@ -72,6 +73,8 @@
      MOCK_CONST_METHOD1(update_from_hardware_state, void(graphics::DisplayConfigurationOutput&));
      MOCK_CONST_METHOD1(fb_for, graphics::mesa::FBHandle*(gbm_bo*));
++    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_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-31 06:57:08 +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-24 07:15:51 +0000
 +++ tests/unit-tests/platforms/mesa/kms/test_display_buffer.cpp	2017-03-31 06:57:08 +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-22 07:01:56 +0000
 +++ tests/unit-tests/platforms/mesa/kms/test_display_configuration.cpp	2017-03-31 06:57:08 +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,6 +170,9 @@
      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, "")
@@ -217,29 +230,53 @@
      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 =
+     {
@@ -331,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;
@@ -350,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());
@@ -395,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
+     {
@@ -431,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;
@@ -583,26 +652,54 @@
      };
      /* 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());
@@ -611,23 +708,44 @@
      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;
@@ -708,17 +826,36 @@
          },
      };
--    mtd::FakeDRMResources& resources(mock_drm.fake_drm);
--    auto const syspath = fake_devices.add_device("drm", "card2", NULL, {}, {"DEVTYPE", "drm_minor"});
++    auto const syspath = fake_devices.add_device(
++        "drm",
++        "card2",
++        NULL,
++        {},
++        {
++            "DEVTYPE", "drm_minor",
++            "DEVNAME", "/dev/dri/card2"
++        });
--    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_connector(connector_ids[0], DRM_MODE_CONNECTOR_Composite,
--                            DRM_MODE_CONNECTED, encoder_ids[0],
--                            modes0, possible_encoder_ids_empty,
--                            connector_physical_sizes_mm_before);
--    resources.prepare();
++    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_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);
++    mock_drm.prepare(drm_device);
      auto display = create_display(create_platform());
      auto conf = display->configuration();
@@ -726,15 +863,31 @@
      // Now simulate a change of monitor, with no CRTC attached (and hence no current mode).
      // The configuration should mirror this state.
--    resources.reset();
--    resources.add_crtc(crtc_ids[0], modes1[1]);
--    resources.add_encoder(encoder_ids[0], crtc_ids[0], possible_crtcs_mask_empty);
--    resources.add_encoder(encoder_ids[1], 0, possible_crtcs_mask_empty);
--    resources.add_connector(connector_ids[0], DRM_MODE_CONNECTOR_Composite,
--                            DRM_MODE_CONNECTED, encoder_ids[1],
--                            modes1, possible_encoder_ids_empty,
--                            connector_physical_sizes_mm_after);
--    resources.prepare();
++    mock_drm.reset(drm_device);
++    mock_drm.add_crtc(
++        drm_device,
++        crtc_ids[0],
++        modes1[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],
++        0,
++        possible_crtcs_mask_empty);
++    mock_drm.add_connector(
++        drm_device,
++        connector_ids[0],
++        DRM_MODE_CONNECTOR_Composite,
++        DRM_MODE_CONNECTED,
++        encoder_ids[1],
++        modes1,
++        possible_encoder_ids_empty,
++        connector_physical_sizes_mm_after);
++    mock_drm.prepare(drm_device);
      MainLoop ml;
      mt::Signal handler_signal;
@@ -758,17 +911,36 @@
      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(crtc_id, modes0[1]);
--    resources.add_encoder(encoder_id, crtc_id, possible_crtcs_mask_empty);
--    resources.add_connector(connector_id, DRM_MODE_CONNECTOR_Composite,
--                            DRM_MODE_CONNECTED, encoder_id,
--                            modes0, possible_encoder_ids_empty,
--                            connector_physical_sizes_mm);
--    resources.prepare();
++    mock_drm.reset(drm_device);
++    mock_drm.add_crtc(
++        drm_device,
++        crtc_id,
++        modes0[1]);
++    mock_drm.add_encoder(
++        drm_device,
++        encoder_id,
++        crtc_id,
++        possible_crtcs_mask_empty);
++    mock_drm.add_connector(
++        drm_device,
++        connector_id,
++        DRM_MODE_CONNECTOR_Composite,
++        DRM_MODE_CONNECTED,
++        encoder_id,
++        modes0,
++        possible_encoder_ids_empty,
++        connector_physical_sizes_mm);
++    mock_drm.prepare(drm_device);
--    auto const syspath = fake_devices.add_device("drm", "card2", NULL, {}, {"DEVTYPE", "drm_minor"});
++    auto const syspath = fake_devices.add_device(
++        "drm",
++        "card2",
++        NULL,
++        {},
++        {
++            "DEVTYPE", "drm_minor",
++            "DEVNAME", "/dev/dri/card2"
++        });
      auto display = create_display(create_platform());
 === modified file 'tests/unit-tests/platforms/mesa/kms/test_display_generic.cpp'
 --- tests/unit-tests/platforms/mesa/kms/test_display_generic.cpp	2016-08-24 02:09:08 +0000
 +++ tests/unit-tests/platforms/mesa/kms/test_display_generic.cpp	2017-03-31 06:57:08 +0000
@@ -35,6 +35,7 @@
  #include <gtest/gtest.h>
  #include <gmock/gmock.h>
++#include <fcntl.h>
  namespace mg = mir::graphics;
  namespace mgm = mg::mesa;
@@ -45,6 +46,7 @@
+ {
  public:
      DisplayTestGeneric()
++        : drm_fd{open(drm_device, 0, 0)}
+     {
          using namespace testing;
@@ -56,7 +58,15 @@
          mock_egl.provide_egl_extensions();
          mock_gl.provide_gles_extensions();
++        ON_CALL(mock_gbm, gbm_device_get_fd(_))
++            .WillByDefault(Return(drm_fd));
++
          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::Display> create_display()
@@ -76,6 +86,9 @@
      ::testing::NiceMock<mtd::MockDRM> mock_drm;
      ::testing::NiceMock<mtd::MockGBM> mock_gbm;
      mtf::UdevEnvironment fake_devices;
++
++    char const* const drm_device = "/dev/dri/card0";
++    int const drm_fd;
  };
  #include "../../test_display.h"
 === modified file 'tests/unit-tests/platforms/mesa/kms/test_display_multi_monitor.cpp'
 --- tests/unit-tests/platforms/mesa/kms/test_display_multi_monitor.cpp	2016-01-29 08:18:22 +0000
 +++ tests/unit-tests/platforms/mesa/kms/test_display_multi_monitor.cpp	2017-03-31 06:57:08 +0000
@@ -41,6 +41,7 @@
  #include <gmock/gmock.h>
  #include <unordered_set>
++#include <fcntl.h>
  namespace mg = mir::graphics;
  namespace mgm = mg::mesa;
@@ -109,6 +110,7 @@
+ {
  public:
      MesaDisplayMultiMonitorTest()
++        : drm_fd{open(drm_device, 0, 0)}
+     {
          using namespace testing;
@@ -128,9 +130,15 @@
          EXPECT_CALL(mock_gbm, gbm_bo_get_device(_))
              .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");
++
++        // 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<mgm::Platform> create_platform()
@@ -162,8 +170,6 @@
+     {
          using fake = mtd::FakeDRMResources;
--        mtd::FakeDRMResources& resources(mock_drm.fake_drm);
--
          modes0.clear();
          modes0.push_back(fake::create_mode(1920, 1080, 138500, 2080, 1111, fake::NormalMode));
          modes0.push_back(fake::create_mode(1920, 1080, 148500, 2200, 1125, fake::PreferredMode));
@@ -172,7 +178,7 @@
          geom::Size const connector_physical_size_mm{1597, 987};
--        resources.reset();
++        mock_drm.reset(drm_device);
          uint32_t const crtc_base_id{10};
          uint32_t const encoder_base_id{20};
@@ -185,10 +191,10 @@
              uint32_t const all_crtcs_mask{0xff};
              crtc_ids.push_back(crtc_id);
--            resources.add_crtc(crtc_id, drmModeModeInfo());
++            mock_drm.add_crtc(drm_device, crtc_id, drmModeModeInfo());
              encoder_ids.push_back(encoder_id);
--            resources.add_encoder(encoder_id, crtc_id, all_crtcs_mask);
++            mock_drm.add_encoder(drm_device, encoder_id, crtc_id, all_crtcs_mask);
+         }
          for (int i = 0; i < connected; i++)
@@ -196,9 +202,15 @@
              uint32_t const connector_id{connector_base_id + i};
              connector_ids.push_back(connector_id);
--            resources.add_connector(connector_id, DRM_MODE_CONNECTOR_VGA,
--                                    DRM_MODE_CONNECTED, encoder_ids[i],
--                                    modes0, encoder_ids, connector_physical_size_mm);
++            mock_drm.add_connector(
++                drm_device,
++                connector_id,
++                DRM_MODE_CONNECTOR_VGA,
++                DRM_MODE_CONNECTED,
++                encoder_ids[i],
++                modes0,
++                encoder_ids,
++                connector_physical_size_mm);
+         }
          for (int i = 0; i < disconnected; i++)
@@ -206,12 +218,18 @@
              uint32_t const connector_id{connector_base_id + connected + i};
              connector_ids.push_back(connector_id);
--            resources.add_connector(connector_id, DRM_MODE_CONNECTOR_VGA,
--                                    DRM_MODE_DISCONNECTED, 0,
--                                    modes_empty, encoder_ids, geom::Size{});
++            mock_drm.add_connector(
++                drm_device,
++                connector_id,
++                DRM_MODE_CONNECTOR_VGA,
++                DRM_MODE_DISCONNECTED,
++                0,
++                modes_empty,
++                encoder_ids,
++                geom::Size{});
+         }
--        resources.prepare();
++        mock_drm.prepare(drm_device);
+     }
@@ -227,6 +245,9 @@
      std::vector<uint32_t> connector_ids;
      mtf::UdevEnvironment fake_devices;
++
++    char const* const drm_device = "/dev/dri/card0";
++    int const drm_fd;
  };
+ }
@@ -242,7 +263,7 @@
      setup_outputs(num_connected_outputs, num_disconnected_outputs);
      /* Create DRM FBs */
--    EXPECT_CALL(mock_drm, drmModeAddFB2(mock_drm.fake_drm.fd(),
++    EXPECT_CALL(mock_drm, drmModeAddFB2(mtd::IsFdOfDevice(drm_device),
                                          _, _, _, _, _, _, _, _))
          .WillRepeatedly(DoAll(SetArgPointee<7>(fb_id), Return(0)));
@@ -252,7 +273,7 @@
      for (int i = 0; i < num_connected_outputs; i++)
+     {
          crtc_setups += EXPECT_CALL(mock_drm,
--                                   drmModeSetCrtc(mock_drm.fake_drm.fd(),
++                                   drmModeSetCrtc(mtd::IsFdOfDevice(drm_device),
                                                    crtc_ids[i], fb_id,
                                                    _, _,
                                                    Pointee(connector_ids[i]),
@@ -263,7 +284,7 @@
      /* All crtcs are restored at teardown */
      for (int i = 0; i < num_connected_outputs; i++)
+     {
--        EXPECT_CALL(mock_drm, drmModeSetCrtc(mock_drm.fake_drm.fd(),
++        EXPECT_CALL(mock_drm, drmModeSetCrtc(mtd::IsFdOfDevice(drm_device),
                                               crtc_ids[i], Ne(fb_id),
                                               _, _,
                                               Pointee(connector_ids[i]),
@@ -338,25 +359,25 @@
      setup_outputs(num_connected_outputs, num_disconnected_outputs);
      /* Create DRM FBs */
--    EXPECT_CALL(mock_drm, drmModeAddFB2(mock_drm.fake_drm.fd(),
++    EXPECT_CALL(mock_drm, drmModeAddFB2(mtd::IsFdOfDevice(drm_device),
                                          _, _, _, _, _, _, _, _))
          .WillRepeatedly(DoAll(SetArgPointee<7>(fb_id), Return(0)));
      /* All crtcs are flipped */
      for (int i = 0; i < num_connected_outputs; i++)
+     {
--        EXPECT_CALL(mock_drm, drmModePageFlip(mock_drm.fake_drm.fd(),
++        EXPECT_CALL(mock_drm, drmModePageFlip(mtd::IsFdOfDevice(drm_device),
                                                crtc_ids[i], fb_id,
                                                _, _))
              .Times(2)
              .WillRepeatedly(DoAll(SaveArg<4>(&user_data[i]), Return(0)));
          /* Emit fake DRM page-flip events */
--        EXPECT_EQ(1, write(mock_drm.fake_drm.write_fd(), "a", 1));
++        mock_drm.generate_event_on(drm_device);
+     }
      /* Handle the events properly */
--    EXPECT_CALL(mock_drm, drmHandleEvent(mock_drm.fake_drm.fd(), _))
++    EXPECT_CALL(mock_drm, drmHandleEvent(mtd::IsFdOfDevice(drm_device), _))
          .Times(num_connected_outputs)
          .WillOnce(DoAll(InvokePageFlipHandler(&user_data[0]), Return(0)))
          .WillOnce(DoAll(InvokePageFlipHandler(&user_data[1]), Return(0)))
@@ -426,7 +447,7 @@
      setup_outputs(num_connected_outputs, num_disconnected_outputs);
      /* Create DRM FBs */
--    EXPECT_CALL(mock_drm, drmModeAddFB2(mock_drm.fake_drm.fd(),
++    EXPECT_CALL(mock_drm, drmModeAddFB2(mtd::IsFdOfDevice(drm_device),
                                          _, _, _, _, _, _, _, _))
          .Times(num_connected_outputs)
          .WillRepeatedly(Invoke(&fb_id_container, &FBIDContainer::add_fb2));
@@ -437,7 +458,7 @@
      for (int i = 0; i < num_connected_outputs; i++)
+     {
          crtc_setups += EXPECT_CALL(mock_drm,
--                                   drmModeSetCrtc(mock_drm.fake_drm.fd(),
++                                   drmModeSetCrtc(mtd::IsFdOfDevice(drm_device),
                                                    crtc_ids[i],
                                                    IsValidFB(&fb_id_container),
                                                    _, _,
@@ -449,7 +470,7 @@
      /* All crtcs are restored at teardown */
      for (int i = 0; i < num_connected_outputs; i++)
+     {
--        EXPECT_CALL(mock_drm, drmModeSetCrtc(mock_drm.fake_drm.fd(),
++        EXPECT_CALL(mock_drm, drmModeSetCrtc(mtd::IsFdOfDevice(drm_device),
                                               crtc_ids[i], 0,
                                               _, _,
                                               Pointee(connector_ids[i]),
@@ -478,11 +499,11 @@
      for (int i = 0; i < num_connected_outputs; i++)
+     {
          EXPECT_CALL(mock_drm,
--                    drmModeSetCursor(mock_drm.fake_drm.fd(),
++                    drmModeSetCursor(mtd::IsFdOfDevice(drm_device),
                                       crtc_ids[i], 0, 0, 0))
                          .Times(1);
          EXPECT_CALL(mock_drm,
--                    drmModeSetCrtc(mock_drm.fake_drm.fd(),
++                    drmModeSetCrtc(mtd::IsFdOfDevice(drm_device),
                                     crtc_ids[i], 0, 0, 0,
                                     nullptr, 0, nullptr))
                          .Times(1);
@@ -508,7 +529,7 @@
      for (int i = 0; i < num_connected_outputs; i++)
+     {
          EXPECT_CALL(mock_drm,
--                    drmModeSetCrtc(mock_drm.fake_drm.fd(), crtc_ids[i],
++                    drmModeSetCrtc(mtd::IsFdOfDevice(drm_device), crtc_ids[i],
 , _, _, Pointee(connector_ids[i]),
                                     _, _))
                          .Times(1);
@@ -548,7 +569,7 @@
      for (int i = 0; i < num_connected_outputs; i++)
+     {
          EXPECT_CALL(mock_drm,
--                    drmModeSetCrtc(mock_drm.fake_drm.fd(),
++                    drmModeSetCrtc(mtd::IsFdOfDevice(drm_device),
                                     crtc_ids[i], 0, 0, 0,
                                     nullptr, 0, nullptr))
                          .Times(1);
@@ -562,7 +583,7 @@
      for (int i = 0; i < num_connected_outputs; i++)
+     {
          EXPECT_CALL(mock_drm,
--                    drmModeSetCrtc(mock_drm.fake_drm.fd(), crtc_ids[i],
++                    drmModeSetCrtc(mtd::IsFdOfDevice(drm_device), crtc_ids[i],
 , _, _, Pointee(connector_ids[i]),
                                     _, _))
                          .Times(1);
 === modified file 'tests/unit-tests/platforms/mesa/kms/test_drm_helper.cpp'
 --- tests/unit-tests/platforms/mesa/kms/test_drm_helper.cpp	2017-01-18 02:29:37 +0000
 +++ tests/unit-tests/platforms/mesa/kms/test_drm_helper.cpp	2017-03-31 06:57:08 +0000
@@ -70,8 +70,14 @@
      drm_magic_t const magic{0x10111213};
--    EXPECT_CALL(mock_drm, drmAuthMagic(mock_drm.fake_drm.fd(), magic))
--        .WillOnce(Return(-1));
++    EXPECT_CALL(
++        mock_drm,
++        drmAuthMagic(
++            AnyOf(
++                mtd::IsFdOfDevice("/dev/dri/card0"),
++                mtd::IsFdOfDevice("/dev/dri/card1")),
++            magic))
++            .WillOnce(Return(-1));
      drm_helper.setup(std::make_shared<mir::udev::Context>());
@@ -79,3 +85,15 @@
          drm_helper.auth_magic(magic);
      }, std::runtime_error);
+ }
++
++TEST_F(DRMHelperTest, open_all_devices_opens_with_cloexec)
++{
++    using namespace testing;
++
++    EXPECT_CALL(mock_drm, open(StrEq("/dev/dri/card0"), FlagSet(O_CLOEXEC), _))
++        .Times(1);
++    EXPECT_CALL(mock_drm, open(StrEq("/dev/dri/card1"), FlagSet(O_CLOEXEC), _))
++        .Times(1);
++
++    mgm::helpers::DRMHelper::open_all_devices(std::make_shared<mir::udev::Context>());
++}
 \ No newline at end of file
 === modified file 'tests/unit-tests/platforms/mesa/kms/test_guest_platform.cpp'
 --- tests/unit-tests/platforms/mesa/kms/test_guest_platform.cpp	2017-03-20 19:06:00 +0000
 +++ tests/unit-tests/platforms/mesa/kms/test_guest_platform.cpp	2017-03-31 06:57:08 +0000
@@ -36,6 +36,7 @@
  #include <gmock/gmock.h>
  #include <cstring>
++#include <fcntl.h>
  namespace mg = mir::graphics;
  namespace mgm = mir::graphics::mesa;
@@ -56,10 +57,11 @@
+ {
  public:
      MesaGuestPlatformTest()
++        : drm_fd{open(drm_device, 0, 0)}
+     {
          int fake_fd = 4939;
          ON_CALL(mock_platform_authentication, platform_fd_items())
--            .WillByDefault(Return(std::vector<int>{mock_drm.fake_drm.fd()}));
++            .WillByDefault(Return(std::vector<int>{drm_fd}));
          ON_CALL(mock_platform_authentication, set_gbm_extension())
              .WillByDefault(Return(mir::optional_value<std::shared_ptr<mg::SetGbmExtension>>{mock_gbm_ext}));
          ON_CALL(mock_platform_authentication, auth_extension())
@@ -74,6 +76,8 @@
      ::testing::NiceMock<mtd::MockPlatformAuthentication> mock_platform_authentication;
      std::shared_ptr<mtd::MockMesaExt> mock_ext = std::make_shared<mtd::MockMesaExt>();
      std::shared_ptr<MockSetGbmExt> mock_gbm_ext = std::make_shared<MockSetGbmExt>();
++    char const* const drm_device = "/dev/dri/card0";
++    int const drm_fd;
  };
+ }
 === modified file 'tests/unit-tests/platforms/mesa/kms/test_kms_page_flipper.cpp'
 --- tests/unit-tests/platforms/mesa/kms/test_kms_page_flipper.cpp	2017-01-18 02:29:37 +0000
 +++ tests/unit-tests/platforms/mesa/kms/test_kms_page_flipper.cpp	2017-03-31 06:57:08 +0000
@@ -32,6 +32,7 @@
  #include <unordered_set>
  #include <sys/time.h>
++#include <fcntl.h>
  namespace mg  = mir::graphics;
  namespace mgm = mir::graphics::mesa;
@@ -45,12 +46,17 @@
+ {
  public:
      KMSPageFlipperTest()
--        : page_flipper{mock_drm.fake_drm.fd(), mt::fake_shared(report)}
++    : drm_fd{open(drm_device, 0, 0)},
++      page_flipper{drm_fd, mt::fake_shared(report)}
+     {
+     }
      testing::NiceMock<mtd::MockDisplayReport> report;
      testing::NiceMock<mtd::MockDRM> mock_drm;
++
++    char const* const drm_device = "/dev/dri/card0";
++    int const drm_fd;
++
      mgm::KMSPageFlipper page_flipper;
  };
@@ -73,8 +79,7 @@
      uint32_t const fb_id{101};
      uint32_t const connector_id{345};
--    EXPECT_CALL(mock_drm, drmModePageFlip(mock_drm.fake_drm.fd(),
--                                          crtc_id, fb_id, _, _))
++    EXPECT_CALL(mock_drm, drmModePageFlip(drm_fd, crtc_id, fb_id, _, _))
          .Times(1);
      page_flipper.schedule_flip(crtc_id, fb_id, connector_id);
@@ -88,8 +93,7 @@
      uint32_t const fb_id{101};
      uint32_t const connector_id{345};
--    EXPECT_CALL(mock_drm, drmModePageFlip(mock_drm.fake_drm.fd(),
--                                          crtc_id, fb_id, _, _))
++    EXPECT_CALL(mock_drm, drmModePageFlip(drm_fd, crtc_id, fb_id, _, _))
          .Times(1);
      page_flipper.schedule_flip(crtc_id, fb_id, connector_id);
@@ -108,19 +112,18 @@
      uint32_t const connector_id{345};
      void* user_data{nullptr};
--    EXPECT_CALL(mock_drm, drmModePageFlip(mock_drm.fake_drm.fd(),
--                                          crtc_id, fb_id, _, _))
++    EXPECT_CALL(mock_drm, drmModePageFlip(drm_fd, crtc_id, fb_id, _, _))
          .Times(1)
          .WillOnce(DoAll(SaveArg<4>(&user_data), Return(0)));
--    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)));
      page_flipper.schedule_flip(crtc_id, fb_id, connector_id);
      /* Fake a DRM event */
--    EXPECT_EQ(1, write(mock_drm.fake_drm.write_fd(), "a", 1));
++    mock_drm.generate_event_on(drm_device);
      page_flipper.wait_for_flip(crtc_id);
+ }
@@ -142,7 +145,7 @@
      EXPECT_CALL(report, report_vsync(connector_id, _));
      page_flipper.schedule_flip(crtc_id, fb_id, connector_id);
--    EXPECT_EQ(1, write(mock_drm.fake_drm.write_fd(), "a", 1));
++    mock_drm.generate_event_on(drm_device);
      page_flipper.wait_for_flip(crtc_id);
+ }
@@ -170,8 +173,7 @@
      uint32_t const connector_id{345};
      void* user_data{nullptr};
--    EXPECT_CALL(mock_drm, drmModePageFlip(mock_drm.fake_drm.fd(),
--                                          crtc_id, fb_id, _, _))
++    EXPECT_CALL(mock_drm, drmModePageFlip(drm_fd, crtc_id, fb_id, _, _))
          .Times(1)
          .WillOnce(DoAll(SaveArg<4>(&user_data), Return(0)));
@@ -181,7 +183,7 @@
      page_flipper.schedule_flip(crtc_id, fb_id, connector_id);
      /* Cause a failure in wait_for_flip */
--    close(mock_drm.fake_drm.fd());
++    close(drm_fd);
      EXPECT_THROW({
          page_flipper.wait_for_flip(crtc_id);
@@ -198,14 +200,13 @@
      uint32_t const connector_ids[flips] = {23, 45, 67};
      void* user_data[flips] = {nullptr, nullptr, nullptr};
--    EXPECT_CALL(mock_drm, drmModePageFlip(mock_drm.fake_drm.fd(),
--                                          _, fb_id, _, _))
++    EXPECT_CALL(mock_drm, drmModePageFlip(drm_fd, _, fb_id, _, _))
          .Times(3)
          .WillOnce(DoAll(SaveArg<4>(&user_data[0]), Return(0)))
          .WillOnce(DoAll(SaveArg<4>(&user_data[1]), Return(0)))
          .WillOnce(DoAll(SaveArg<4>(&user_data[2]), Return(0)));
--    EXPECT_CALL(mock_drm, drmHandleEvent(mock_drm.fake_drm.fd(), _))
++    EXPECT_CALL(mock_drm, drmHandleEvent(drm_fd, _))
          .Times(3)
          .WillOnce(DoAll(InvokePageFlipHandler(&user_data[1]), Return(0)))
          .WillOnce(DoAll(InvokePageFlipHandler(&user_data[2]), Return(0)))
@@ -215,7 +216,9 @@
          page_flipper.schedule_flip(crtc_ids[i], fb_id, connector_ids[i]);
      /* Fake 3 DRM events */
--    EXPECT_EQ(flips, write(mock_drm.fake_drm.write_fd(), "abc", 3));
++    mock_drm.generate_event_on(drm_device);
++    mock_drm.generate_event_on(drm_device);
++    mock_drm.generate_event_on(drm_device);
      for (auto crtc_id : crtc_ids)
          page_flipper.wait_for_flip(crtc_id);
@@ -283,7 +286,7 @@
      std::vector<std::thread> page_flipping_threads;
      std::thread::id tid;
--    EXPECT_CALL(mock_drm, drmModePageFlip(mock_drm.fake_drm.fd(), _, _, _, _))
++    EXPECT_CALL(mock_drm, drmModePageFlip(drm_fd, _, _, _, _))
          .Times(2)
          .WillOnce(DoAll(SaveArg<4>(&user_data[worker_index]), Return(0)))
          .WillOnce(DoAll(SaveArg<4>(&user_data[other_index]), Return(0)));
@@ -292,7 +295,7 @@
       * The first event releases the original worker, hence we expect that
       * then the other thread will become the worker.
       */
--    EXPECT_CALL(mock_drm, drmHandleEvent(mock_drm.fake_drm.fd(), _))
++    EXPECT_CALL(mock_drm, drmHandleEvent(drm_fd, _))
          .Times(2)
          .WillOnce(DoAll(InvokePageFlipHandler(&user_data[worker_index]), Return(0)))
          .WillOnce(DoAll(InvokePageFlipHandler(&user_data[other_index]), Return(0)));
@@ -320,7 +323,7 @@
      EXPECT_EQ(page_flipping_threads[worker_index].get_id(), tid);
      /* Fake a DRM event */
--    EXPECT_EQ(1, write(mock_drm.fake_drm.write_fd(), "a", 1));
++    mock_drm.generate_event_on(drm_device);
      page_flipping_threads[worker_index].join();
@@ -332,7 +335,7 @@
+     }
      /* Fake another DRM event to unblock the remaining thread */
--    EXPECT_EQ(1, write(mock_drm.fake_drm.write_fd(), "a", 1));
++    mock_drm.generate_event_on(drm_device);
      page_flipping_threads[other_index].join();
+ }
@@ -349,7 +352,7 @@
      std::vector<std::thread> page_flipping_threads;
      std::thread::id tid;
--    EXPECT_CALL(mock_drm, drmModePageFlip(mock_drm.fake_drm.fd(), _, _, _, _))
++    EXPECT_CALL(mock_drm, drmModePageFlip(drm_fd, _, _, _, _))
          .Times(2)
          .WillOnce(DoAll(SaveArg<4>(&user_data[worker_index]), Return(0)))
          .WillOnce(DoAll(SaveArg<4>(&user_data[other_index]), Return(0)));
@@ -358,7 +361,7 @@
       * The first event releases the non-worker thread, hence we expect that
       * original worker not change.
       */
--    EXPECT_CALL(mock_drm, drmHandleEvent(mock_drm.fake_drm.fd(), _))
++    EXPECT_CALL(mock_drm, drmHandleEvent(drm_fd, _))
          .Times(2)
          .WillOnce(DoAll(InvokePageFlipHandler(&user_data[other_index]), Return(0)))
          .WillOnce(DoAll(InvokePageFlipHandler(&user_data[worker_index]), Return(0)));
@@ -386,7 +389,7 @@
      EXPECT_EQ(page_flipping_threads[worker_index].get_id(), tid);
      /* Fake a DRM event */
--    EXPECT_EQ(1, write(mock_drm.fake_drm.write_fd(), "a", 1));
++    mock_drm.generate_event_on(drm_device);
      /* Wait for the non-worker thread to exit */
      page_flipping_threads[other_index].join();
@@ -396,7 +399,7 @@
                page_flipper.debug_get_worker_tid());
      /* Fake another DRM event to unblock the remaining thread */
--    EXPECT_EQ(1, write(mock_drm.fake_drm.write_fd(), "a", 1));
++    mock_drm.generate_event_on(drm_device);
      page_flipping_threads[worker_index].join();
+ }
@@ -515,7 +518,7 @@
      counter->add_handle_event(crtc_id);
+ }
--ACTION_P2(AddPageFlipEvent, counter, write_drm_fd)
++ACTION_P2(AddPageFlipEvent, counter, generate_event_functor)
+ {
      uint32_t const crtc_id{arg0};
      void* const user_data{arg1};
@@ -523,7 +526,7 @@
      /* Record this call */
      counter->add_flip(crtc_id, user_data);
      /* Add an event to the drm event queue */
--    EXPECT_EQ(1, write(write_drm_fd, "a", 1));
++    generate_event_functor();
+ }
+ }
@@ -537,11 +540,19 @@
      std::vector<std::thread> page_flipping_threads;
      PageFlipCounter counter;
--    EXPECT_CALL(mock_drm, drmModePageFlip(mock_drm.fake_drm.fd(), _, _, _, _))
--        .WillRepeatedly(DoAll(WithArgs<1,4>(AddPageFlipEvent(&counter, mock_drm.fake_drm.write_fd())),
--                              Return(0)));
++    EXPECT_CALL(mock_drm, drmModePageFlip(drm_fd, _, _, _, _))
++        .WillRepeatedly(
++            DoAll(
++                WithArgs<1,4>(
++                    AddPageFlipEvent(
++                        &counter,
++                        [this]()
++                        {
++                            mock_drm.generate_event_on(drm_device);
++                        })),
++                Return(0)));
--    EXPECT_CALL(mock_drm, drmHandleEvent(mock_drm.fake_drm.fd(), _))
++    EXPECT_CALL(mock_drm, drmHandleEvent(drm_fd, _))
          .WillRepeatedly(DoAll(InvokePageFlipHandlerWithPendingData(&counter),
                                Return(0)));
 === modified file 'tests/unit-tests/platforms/mesa/kms/test_platform.cpp'
 --- tests/unit-tests/platforms/mesa/kms/test_platform.cpp	2017-03-09 12:52:48 +0000
 +++ tests/unit-tests/platforms/mesa/kms/test_platform.cpp	2017-03-31 06:57:08 +0000
@@ -97,16 +97,18 @@
      int const auth_fd{auth_pipe.read_fd()};
      /* First time for master DRM fd, second for authenticated fd */
--    EXPECT_CALL(mock_drm, open(_,_,_))
--        .WillOnce(Return(mock_drm.fake_drm.fd()));
++    EXPECT_CALL(mock_drm, open(StrEq("/dev/dri/card0"),_,_));
++    EXPECT_CALL(mock_drm, open(StrEq("/dev/dri/card1"),_,_));
++
      EXPECT_CALL(mock_drm, drmOpen(_,_))
          .WillOnce(Return(auth_fd));
      /* Expect proper authorization */
      EXPECT_CALL(mock_drm, drmGetMagic(auth_fd,_));
--    EXPECT_CALL(mock_drm, drmAuthMagic(mock_drm.fake_drm.fd(),_));
++    EXPECT_CALL(mock_drm, drmAuthMagic(mtd::IsFdOfDevice("/dev/dri/card0"),_));
--    EXPECT_CALL(mock_drm, drmClose(mock_drm.fake_drm.fd()));
++    EXPECT_CALL(mock_drm, drmClose(mtd::IsFdOfDevice("/dev/dri/card0")));
++    EXPECT_CALL(mock_drm, drmClose(mtd::IsFdOfDevice("/dev/dri/card1")));
      /* Expect authenticated fd to be closed when package is destroyed */
      EXPECT_CALL(mock_drm, drmClose(auth_fd));
@@ -140,22 +142,6 @@
      FAIL() << "Expected an exception to be thrown.";
+ }
--TEST_F(MesaGraphicsPlatform, fails_if_no_resources)
--{
--    using namespace ::testing;
--
--    EXPECT_CALL(mock_drm, drmModeGetResources(_))
--        .Times(Exactly(1))
--        .WillOnce(Return(reinterpret_cast<drmModeRes*>(0)));
--
--    EXPECT_CALL(mock_drm, drmModeFreeResources(_))
--        .Times(Exactly(0));
--
--    EXPECT_THROW({
--        auto platform = create_platform();
--    }, std::runtime_error) << "Expected that c'tor of Platform throws";
--}
--
  TEST_F(MesaGraphicsPlatform, egl_native_display_is_gbm_device)
+ {
      auto platform = create_platform();
@@ -284,7 +270,9 @@
          mgm::BypassOption::allowed};
      int const success_code = 0;
--    EXPECT_CALL(mock_drm, drmDropMaster(mock_drm.fake_drm.fd()))
++    EXPECT_CALL(mock_drm, drmDropMaster(mtd::IsFdOfDevice("/dev/dri/card0")))
++        .WillOnce(Return(success_code));
++    EXPECT_CALL(mock_drm, drmDropMaster(mtd::IsFdOfDevice("/dev/dri/card1")))
          .WillOnce(Return(success_code));
      (*emergency_cleanup_registry.handler)();
@@ -296,6 +284,8 @@
+ {
      using namespace testing;
++
++
      auto const mock_vt = std::make_shared<mtd::MockVirtualTerminal>();
      StubEmergencyCleanupRegistry emergency_cleanup_registry;
      mgm::Platform platform{
@@ -306,8 +296,8 @@
      EXPECT_CALL(*mock_vt, restore())
          .WillOnce(Throw(std::runtime_error("vt restore exception")));
--    EXPECT_CALL(mock_drm, drmDropMaster(mock_drm.fake_drm.fd()))
--        .WillOnce(Throw(std::runtime_error("drm drop master exception")));
++    EXPECT_CALL(mock_drm, drmDropMaster(_))
++        .WillRepeatedly(Throw(std::runtime_error("drm drop master exception")));
      (*emergency_cleanup_registry.handler)();
 === modified file 'tests/unit-tests/platforms/mesa/kms/test_real_kms_output.cpp'
 --- tests/unit-tests/platforms/mesa/kms/test_real_kms_output.cpp	2017-03-24 07:15:51 +0000
 +++ tests/unit-tests/platforms/mesa/kms/test_real_kms_output.cpp	2017-03-31 06:57:08 +0000
@@ -29,6 +29,7 @@
  #include <gtest/gtest.h>
  #include <gmock/gmock.h>
++#include <fcntl.h>
  namespace mg = mir::graphics;
  namespace mgm = mir::graphics::mesa;
@@ -59,7 +60,8 @@
+ {
  public:
      RealKMSOutputTest()
--        : invalid_id{0}, crtc_ids{10, 11},
++        : drm_fd{open(drm_device, 0, 0)},
++          invalid_id{0}, crtc_ids{10, 11},
            encoder_ids{20, 21}, connector_ids{30, 21},
            possible_encoder_ids1{encoder_ids[0]},
            possible_encoder_ids2{encoder_ids[0], encoder_ids[1]}
@@ -73,40 +75,77 @@
      void setup_outputs_connected_crtc()
+     {
--        mtd::FakeDRMResources& resources(mock_drm.fake_drm);
          uint32_t const possible_crtcs_mask{0x1};
--        resources.reset();
--
--        resources.add_crtc(crtc_ids[0], drmModeModeInfo());
--        resources.add_encoder(encoder_ids[0], crtc_ids[0], possible_crtcs_mask);
--        resources.add_connector(connector_ids[0], DRM_MODE_CONNECTOR_VGA,
--                                DRM_MODE_CONNECTED, encoder_ids[0],
--                                modes_empty, possible_encoder_ids1, geom::Size());
--
--        resources.prepare();
++        mock_drm.reset(drm_device);
++
++        mock_drm.add_crtc(
++            drm_device,
++            crtc_ids[0],
++            drmModeModeInfo());
++        mock_drm.add_encoder(
++            drm_device,
++            encoder_ids[0],
++            crtc_ids[0],
++            possible_crtcs_mask);
++        mock_drm.add_connector(
++            drm_device,
++            connector_ids[0],
++            DRM_MODE_CONNECTOR_VGA,
++            DRM_MODE_CONNECTED,
++            encoder_ids[0],
++            modes_empty,
++            possible_encoder_ids1,
++            geom::Size());
++
++        mock_drm.prepare(drm_device);
+     }
      void setup_outputs_no_connected_crtc()
+     {
--        mtd::FakeDRMResources& resources(mock_drm.fake_drm);
          uint32_t const possible_crtcs_mask1{0x1};
          uint32_t const possible_crtcs_mask_all{0x3};
--        resources.reset();
--
--        resources.add_crtc(crtc_ids[0], drmModeModeInfo());
--        resources.add_crtc(crtc_ids[1], drmModeModeInfo());
--        resources.add_encoder(encoder_ids[0], crtc_ids[0], possible_crtcs_mask1);
--        resources.add_encoder(encoder_ids[1], invalid_id, possible_crtcs_mask_all);
--        resources.add_connector(connector_ids[0], DRM_MODE_CONNECTOR_Composite,
--                                DRM_MODE_CONNECTED, invalid_id,
--                                modes_empty, possible_encoder_ids2, geom::Size());
--        resources.add_connector(connector_ids[1], DRM_MODE_CONNECTOR_DVIA,
--                                DRM_MODE_CONNECTED, encoder_ids[0],
--                                modes_empty, possible_encoder_ids2, geom::Size());
--
--        resources.prepare();
++        mock_drm.reset(drm_device);
++
++        mock_drm.add_crtc(
++            drm_device,
++            crtc_ids[0],
++            drmModeModeInfo());
++        mock_drm.add_crtc(
++            drm_device,
++            crtc_ids[1],
++            drmModeModeInfo());
++        mock_drm.add_encoder(
++            drm_device,
++            encoder_ids[0],
++            crtc_ids[0],
++            possible_crtcs_mask1);
++        mock_drm.add_encoder(
++            drm_device,
++            encoder_ids[1],
++            invalid_id,
++            possible_crtcs_mask_all);
++        mock_drm.add_connector(
++            drm_device,
++            connector_ids[0],
++            DRM_MODE_CONNECTOR_Composite,
++            DRM_MODE_CONNECTED,
++            invalid_id,
++            modes_empty,
++            possible_encoder_ids2,
++            geom::Size());
++        mock_drm.add_connector(
++            drm_device,
++            connector_ids[1],
++            DRM_MODE_CONNECTOR_DVIA,
++            DRM_MODE_CONNECTED,
++            encoder_ids[0],
++            modes_empty,
++            possible_encoder_ids2,
++            geom::Size());
++
++        mock_drm.prepare(drm_device);
+     }
      void append_fb_id(uint32_t fb_id)
@@ -122,8 +161,11 @@
      testing::NiceMock<mtd::MockGBM> mock_gbm;
      MockPageFlipper mock_page_flipper;
      NullPageFlipper null_page_flipper;
--
      std::vector<drmModeModeInfo> modes_empty;
++
++    char const* const drm_device = "/dev/dri/card0";
++    int const drm_fd;
++
      gbm_bo* const fake_bo{reinterpret_cast<gbm_bo*>(0x123ba)};
      uint32_t const invalid_id;
      std::vector<uint32_t> const crtc_ids;
@@ -165,8 +207,8 @@
+     }
      mgm::RealKMSOutput output{
--        mock_drm.fake_drm.fd(),
--        mg::kms::get_connector(mock_drm.fake_drm.fd(), connector_ids[0]),
++        drm_fd,
++        mg::kms::get_connector(drm_fd, connector_ids[0]),
          mt::fake_shared(mock_page_flipper)};
      auto fb = output.fb_for(fake_bo);
@@ -207,8 +249,8 @@
      append_fb_id(fb_id);
      mgm::RealKMSOutput output{
--        mock_drm.fake_drm.fd(),
--        mg::kms::get_connector(mock_drm.fake_drm.fd(), connector_ids[0]),
++        drm_fd,
++        mg::kms::get_connector(drm_fd, connector_ids[0]),
          mt::fake_shared(mock_page_flipper)};
      auto fb = output.fb_for(fake_bo);
@@ -247,8 +289,8 @@
      append_fb_id(fb_id);
      mgm::RealKMSOutput output{
--        mock_drm.fake_drm.fd(),
--        mg::kms::get_connector(mock_drm.fake_drm.fd(), connector_ids[0]),
++        drm_fd,
++        mg::kms::get_connector(drm_fd, connector_ids[0]),
          mt::fake_shared(mock_page_flipper)};
      auto fb = output.fb_for(fake_bo);
@@ -270,8 +312,8 @@
      setup_outputs_connected_crtc();
      mgm::RealKMSOutput output{
--        mock_drm.fake_drm.fd(),
--        mg::kms::get_connector(mock_drm.fake_drm.fd(), connector_ids[0]),
++        drm_fd,
++        mg::kms::get_connector(drm_fd, connector_ids[0]),
          mt::fake_shared(mock_page_flipper)};
      EXPECT_CALL(mock_drm, drmModeSetCrtc(_, crtc_ids[0], 0, 0, 0, nullptr, 0, nullptr))
@@ -285,21 +327,30 @@
+ {
      using namespace testing;
--    mtd::FakeDRMResources& resources(mock_drm.fake_drm);
      uint32_t const possible_crtcs_mask_empty{0x0};
--    resources.reset();
--
--    resources.add_encoder(encoder_ids[0], invalid_id, possible_crtcs_mask_empty);
--    resources.add_connector(connector_ids[0], DRM_MODE_CONNECTOR_VGA,
--                            DRM_MODE_CONNECTED, encoder_ids[0],
--                            modes_empty, possible_encoder_ids1, geom::Size());
--
--    resources.prepare();
++    mock_drm.reset(drm_device);
++
++    mock_drm.add_encoder(
++        drm_device,
++        encoder_ids[0],
++        invalid_id,
++        possible_crtcs_mask_empty);
++    mock_drm.add_connector(
++        drm_device,
++        connector_ids[0],
++        DRM_MODE_CONNECTOR_VGA,
++        DRM_MODE_CONNECTED,
++        encoder_ids[0],
++        modes_empty,
++        possible_encoder_ids1,
++        geom::Size());
++
++    mock_drm.prepare(drm_device);
      mgm::RealKMSOutput output{
--        mock_drm.fake_drm.fd(),
--        mg::kms::get_connector(mock_drm.fake_drm.fd(), connector_ids[0]),
++        drm_fd,
++        mg::kms::get_connector(drm_fd, connector_ids[0]),
          mt::fake_shared(mock_page_flipper)};
      EXPECT_CALL(mock_drm, drmModeSetCrtc(_, _, 0, 0, 0, nullptr, 0, nullptr))
@@ -319,8 +370,8 @@
      setup_outputs_connected_crtc();
      mgm::RealKMSOutput output{
--        mock_drm.fake_drm.fd(),
--        mg::kms::get_connector(mock_drm.fake_drm.fd(), connector_ids[0]),
++        drm_fd,
++        mg::kms::get_connector(drm_fd, connector_ids[0]),
          mt::fake_shared(mock_page_flipper)};
      auto fb = output.fb_for(fake_bo);
@@ -347,8 +398,8 @@
      setup_outputs_connected_crtc();
      mgm::RealKMSOutput output{
--        mock_drm.fake_drm.fd(),
--        mg::kms::get_connector(mock_drm.fake_drm.fd(), connector_ids[0]),
++        drm_fd,
++        mg::kms::get_connector(drm_fd, connector_ids[0]),
          mt::fake_shared(mock_page_flipper)};
      auto fb = output.fb_for(fake_bo);
@@ -376,8 +427,8 @@
      setup_outputs_connected_crtc();
      mgm::RealKMSOutput output{
--        mock_drm.fake_drm.fd(),
--        mg::kms::get_connector(mock_drm.fake_drm.fd(), connector_ids[0]),
++        drm_fd,
++        mg::kms::get_connector(drm_fd, connector_ids[0]),
          mt::fake_shared(mock_page_flipper)};
      auto fb = output.fb_for(fake_bo);
@@ -397,8 +448,8 @@
      setup_outputs_connected_crtc();
      mgm::RealKMSOutput output{
--        mock_drm.fake_drm.fd(),
--        mg::kms::get_connector(mock_drm.fake_drm.fd(), connector_ids[0]),
++        drm_fd,
++        mg::kms::get_connector(drm_fd, connector_ids[0]),
          mt::fake_shared(mock_page_flipper)};
      EXPECT_CALL(mock_drm, drmModeSetCrtc(_, crtc_ids[0], 0, 0, 0, nullptr, 0, nullptr))
@@ -419,13 +470,13 @@
      setup_outputs_connected_crtc();
      mgm::RealKMSOutput output{
--        mock_drm.fake_drm.fd(),
--        mg::kms::get_connector(mock_drm.fake_drm.fd(), connector_ids[0]),
++        drm_fd,
++        mg::kms::get_connector(drm_fd, connector_ids[0]),
          mt::fake_shared(mock_page_flipper)};
      mg::GammaCurves gamma{{1}, {2}, {3}};
--    EXPECT_CALL(mock_drm, drmModeCrtcSetGamma(mock_drm.fake_drm.fd(), crtc_ids[0],
++    EXPECT_CALL(mock_drm, drmModeCrtcSetGamma(drm_fd, crtc_ids[0],
                                                gamma.red.size(),
                                                const_cast<uint16_t*>(gamma.red.data()),
                                                const_cast<uint16_t*>(gamma.green.data()),
@@ -450,13 +501,13 @@
      setup_outputs_connected_crtc();
      mgm::RealKMSOutput output{
--        mock_drm.fake_drm.fd(),
--        mg::kms::get_connector(mock_drm.fake_drm.fd(), connector_ids[0]),
++        drm_fd,
++        mg::kms::get_connector(drm_fd, connector_ids[0]),
          mt::fake_shared(mock_page_flipper)};
      mg::GammaCurves gamma{{1}, {2}, {3}};
--    EXPECT_CALL(mock_drm, drmModeCrtcSetGamma(mock_drm.fake_drm.fd(), crtc_ids[0],
++    EXPECT_CALL(mock_drm, drmModeCrtcSetGamma(drm_fd, crtc_ids[0],
                                                gamma.red.size(),
                                                const_cast<uint16_t*>(gamma.red.data()),
                                                const_cast<uint16_t*>(gamma.green.data()),
 === modified file 'tests/unit-tests/platforms/mesa/x11/test_guest_platform.cpp'
 --- tests/unit-tests/platforms/mesa/x11/test_guest_platform.cpp	2017-03-23 17:18:29 +0000
 +++ tests/unit-tests/platforms/mesa/x11/test_guest_platform.cpp	2017-03-31 06:57:08 +0000
@@ -63,7 +63,7 @@
+ {
      using namespace ::testing;
--    EXPECT_CALL(mock_gbm, gbm_create_device(mock_drm.fake_drm.fd()))
++    EXPECT_CALL(mock_gbm, gbm_create_device(_))
          .WillRepeatedly(Return(nullptr));
      EXPECT_THROW({ create_guest_platform(); }, std::exception);
 === modified file 'tests/unit-tests/platforms/mesa/x11/test_platform.cpp'
 --- tests/unit-tests/platforms/mesa/x11/test_platform.cpp	2017-01-18 02:29:37 +0000
 +++ tests/unit-tests/platforms/mesa/x11/test_platform.cpp	2017-03-31 06:57:08 +0000
@@ -88,7 +88,7 @@
+ {
      using namespace ::testing;
--    EXPECT_CALL(mock_gbm, gbm_create_device(mock_drm.fake_drm.fd()))
++    EXPECT_CALL(mock_gbm, gbm_create_device(_))
          .WillRepeatedly(Return(nullptr));
      EXPECT_THROW({ create_platform(); }, std::exception);

Mir

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

Commit message

Description of the change

Preview Diff

Subscribers