Mir

Merge lp:~raof/mir/eglstream-platform into lp:mir

eglstream-platform
Merge into development-branch

Proposed by Chris Halse Rogers on 2016-06-03

Status:

Merged

Merged at revision:

3537

Proposed branch:

lp:~raof/mir/eglstream-platform

Merge into:

lp:mir

Diff against target:

2843 lines (+2556/-12)

32 files modified

.bzrignore (+3/-0)
CMakeLists.txt (+9/-2)
include/client/mir_toolkit/client_types.h (+2/-1)
src/platforms/CMakeLists.txt (+5/-1)
src/platforms/eglstream-kms/CMakeLists.txt (+2/-0)
src/platforms/eglstream-kms/client/CMakeLists.txt (+39/-0)
src/platforms/eglstream-kms/client/client_buffer.cpp (+159/-0)
src/platforms/eglstream-kms/client/client_buffer.h (+67/-0)
src/platforms/eglstream-kms/client/client_buffer_factory.cpp (+36/-0)
src/platforms/eglstream-kms/client/client_buffer_factory.h (+45/-0)
src/platforms/eglstream-kms/client/client_platform.cpp (+77/-0)
src/platforms/eglstream-kms/client/client_platform.h (+52/-0)
src/platforms/eglstream-kms/client/client_platform_factory.cpp (+59/-0)
src/platforms/eglstream-kms/client/symbols.map (+7/-0)
src/platforms/eglstream-kms/server/CMakeLists.txt (+55/-0)
src/platforms/eglstream-kms/server/buffer_allocator.cpp (+69/-0)
src/platforms/eglstream-kms/server/buffer_allocator.h (+48/-0)
src/platforms/eglstream-kms/server/display.cpp (+363/-0)
src/platforms/eglstream-kms/server/display.h (+82/-0)
src/platforms/eglstream-kms/server/egl_output.cpp (+359/-0)
src/platforms/eglstream-kms/server/egl_output.h (+79/-0)
src/platforms/eglstream-kms/server/kms_display_configuration.cpp (+331/-0)
src/platforms/eglstream-kms/server/kms_display_configuration.h (+70/-0)
src/platforms/eglstream-kms/server/platform.cpp (+162/-0)
src/platforms/eglstream-kms/server/platform.h (+66/-0)
src/platforms/eglstream-kms/server/platform_symbols.cpp (+189/-0)
src/platforms/eglstream-kms/server/symbols.map.in (+10/-0)
src/platforms/mesa/server/kms/platform_symbols.cpp (+14/-0)
tests/unit-tests/CMakeLists.txt (+4/-0)
tests/unit-tests/client/test_probing_client_platform_factory.cpp (+32/-0)
tests/unit-tests/graphics/mesa/kms/test_platform.cpp (+47/-2)
tests/unit-tests/graphics/test_platform_prober.cpp (+14/-6)

To merge this branch:

bzr merge lp:~raof/mir/eglstream-platform

Medium

Triaged

Link a bug report

Reviewer	Review Type	Date Requested	Status
Mir CI Bot	continuous-integration	2016-06-03	Needs Fixing on 2016-06-09
Alan Griffiths			Abstain on 2016-06-09
Cemil Azizoglu (community)			Needs Fixing on 2016-06-07
Daniel van Vugt		2016-06-03	Pending
Review via email: mp+296389@code.launchpad.net

Commit Message

Add an EGLStream client platform and KMS-backed EGLStream server platform.

Currently supports only software clients, as hooking into nvidia's EGL is not (yet?) possible.

Description of the Change

The actual EGLStream platform

Mir CI Bot (mir-ci-bot) wrote on 2016-06-03:

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

review: Needs Fixing (continuous-integration)

Mir CI Bot (mir-ci-bot) wrote on 2016-06-03:

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

review: Approve (continuous-integration)

Alan Griffiths (alan-griffiths) wrote on 2016-06-03:

No tests needed?

review: Needs Information

Cemil Azizoglu (cemil-azizoglu) wrote on 2016-06-07:

Are there eglstream implementations that don't use kms? Instead of eglstream-kms, can't we call it eglstream?

------------------------
Couldn't mesa-kms and/or mesa-x11 return mg::PlatformPriority::best when eglstream-kms returns that? (unless render nodes and/or dri nodes are unavailable when using eglstream).

2489 +mg::PlatformPriority probe_graphics_platform(mo::ProgramOption const& /*options*/)

------------------------

Are guest platforms a TODO or will they be unsupported forever? A comment would be good either way?

2587 +mir::UniqueModulePtr<mg::Platform> create_guest_platform(
2588 + std::shared_ptr<mg::DisplayReport> const&,
2589 + std::shared_ptr<mg::NestedContext> const& /*nested_context*/)
2590 +{
2591 + mir::assert_entry_point_signature<mg::CreateGuestPlatform>(&create_guest_platform);
2592 + return nullptr;
2593 +}

------------------------
Isn't this going to require root? Can drm render nodes not be used instead?
2238 + if (drmSetMaster(drm_node))

------------------------
Any reason why we don't request alpha? I changed mir-on-X on Gerry's request that he needed alpha. May want to do the same here.
907 + EGL_ALPHA_SIZE, 0,

------------------------
This only supports software rendering but we should still check for
if (buffer_properties.usage == BufferUsage::software)
and throw if hardware is requested.

765 +std::shared_ptr<mg::Buffer> mge::BufferAllocator::alloc_buffer(
766
------------------------
s/falied/failed
+ "Platform claims to support EGL_EXT_device_base, but eglQueryDevicesEXT falied: %s",

------------------------
Probably be better handled by returning unsupported as was done to get the device_count.
2533 + if (eglQueryDevicesEXT(device_count, devices.get(), &device_count) != EGL_TRUE)
2534 + {
2535 + BOOST_THROW_EXCEPTION(mg::egl_error("Failed to get device list with eglQueryDevicesEXT"));
2536 + }

review: Needs Fixing

Mir CI Bot (mir-ci-bot) wrote on 2016-06-07:

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

review: Approve (continuous-integration)

Mir CI Bot (mir-ci-bot) wrote on 2016-06-07:

FAILED: Continuous integration, rev:3542
https://mir-jenkins.ubuntu.com/job/mir-ci/1107/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/1226/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/1276
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/1267
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial/1267
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=vivid+overlay/1236/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial/1236/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/1236/console
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/1236/artifact/output/*zip*/output.zip
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/1236/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial/1236/console

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

review: Needs Fixing (continuous-integration)

Mir CI Bot (mir-ci-bot) wrote on 2016-06-08:

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

review: Needs Fixing (continuous-integration)

Mir CI Bot (mir-ci-bot) wrote on 2016-06-08:

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

review: Approve (continuous-integration)

Alan Griffiths (alan-griffiths) wrote on 2016-06-09:

This seems like a lot of code with only the most trivial of tests. But I guess there's a limit to what we can test when it is supplying our abstraction over the drivers.

review: Abstain

Chris Halse Rogers (raof) wrote on 2016-06-09:

There are some more tests that I could usefully write; I'll write some tests that the platform-probe succeeds in appropriate environments and fails in inappropriate ones.

I'll also investigate writing a dummy KMS driver; that would let us usefully test a whole lot more.

Alan Griffiths (alan-griffiths) wrote on 2016-06-09:

We can land wit ha promise of tests later

Mir CI Bot (mir-ci-bot) on 2016-06-09:

review: Approve (continuous-integration)

Mir CI Bot (mir-ci-bot) on 2016-06-09:

review: Approve (continuous-integration)

Mir CI Bot (mir-ci-bot) wrote on 2016-06-09:

review: Needs Fixing (continuous-integration)

Chris Halse Rogers (raof) wrote on 2016-06-10:

Ahem. Post-merge response to Cemil.

> Are there eglstream implementations that don't use kms? Instead of eglstream-kms, can't we call > it eglstream?

nvidia currently have non-KMS platforms that use EGLStream (they've talked about OpenWF things). We don't currently have non-KMS EGLStream platforms, but they're plausible.

> Couldn't mesa-kms and/or mesa-x11 return mg::PlatformPriority::best when eglstream-kms returns > that? (unless render nodes and/or dri nodes are unavailable when using eglstream).

This was resolved by commits (and tests!) subsequent to this question; mesa-kms now checks for the EGL_MESA_platform_gbm extension (which provides the gbm-import features that we use).

> Are guest platforms a TODO or will they be unsupported forever? A comment would be good either > way?

Guest platforms are a TODO, albeit a TODO that I hope to delay until it no longer needs to be done (splitting output from buffer-allocation will remove guest platforms entirely)

> Isn't this going to require root? Can drm render nodes not be used instead?
> 2238 + if (drmSetMaster(drm_node))

Yes, this requires root (or to already be master, IIRC). You need to be master to do modesetting, so the platform can't work unless it's master.

Render nodes (as their name suggests) can't do modesetting ☺

> Any reason why we don't request alpha? I changed mir-on-X on Gerry's request that he needed
> alpha. May want to do the same here.
> 907 + EGL_ALPHA_SIZE, 0,

Hm, probably. I'll look into this when I get home and can test it.

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

 === added file '.bzrignore'
 --- .bzrignore	1970-01-01 00:00:00 +0000
 +++ .bzrignore	2016-06-08 13:28:19 +0000
@@ -0,0 +1,3 @@
++.idea
++build
++include/server/mir/version.h
 === modified file 'CMakeLists.txt'
 --- CMakeLists.txt	2016-06-02 05:33:50 +0000
 +++ CMakeLists.txt	2016-06-08 13:28:19 +0000
@@ -163,10 +163,10 @@
  # Default to KMS backend, but build all of them
  set(
    MIR_PLATFORM
--  mesa-kms;android;mesa-x11
++  mesa-kms;android;mesa-x11;eglstream-kms
    CACHE
    STRING
--  "a list of graphics backends to build (options are 'mesa-kms', 'android' or 'mesa-x11')"
++  "a list of graphics backends to build (options are 'mesa-kms', 'android', 'mesa-x11', or 'eglstream-kms')"
+ )
  list(GET MIR_PLATFORM 0 MIR_TEST_PLATFORM)
@@ -183,6 +183,9 @@
    if (platform STREQUAL "mesa-x11")
       set(MIR_BUILD_PLATFORM_MESA_X11 TRUE)
    endif()
++  if (platform STREQUAL "eglstream-kms")
++     set(MIR_BUILD_PLATFORM_EGLSTREAM_KMS TRUE)
++  endif()
  endforeach(platform)
  find_package(EGL REQUIRED)
@@ -245,6 +248,10 @@
    pkg_check_modules( DRM REQUIRED libdrm )
  endif()
++if (MIR_BUILD_PLATFORM_EGLSTREAM_KMS)
++  pkg_check_modules(EPOXY REQUIRED epoxy)
++endif()
++
  set(MIR_ANDROID_INCLUDE_DIRECTORIES) # to be filled by android-input
  set(MIR_ANDROID_INPUT_COMPILE_FLAGS) # to be filled by android-input
  set(MIR_3RD_PARTY_INCLUDE_DIRECTORIES)
 === modified file 'include/client/mir_toolkit/client_types.h'
 --- include/client/mir_toolkit/client_types.h	2016-05-03 06:55:25 +0000
 +++ include/client/mir_toolkit/client_types.h	2016-06-08 13:28:19 +0000
@@ -200,7 +200,8 @@
  typedef enum MirPlatformType
+ {
      mir_platform_type_gbm,
--    mir_platform_type_android
++    mir_platform_type_android,
++    mir_platform_type_eglstream,
  } MirPlatformType;
  typedef struct MirPlatformPackage
 === modified file 'src/platforms/CMakeLists.txt'
 --- src/platforms/CMakeLists.txt	2016-05-03 06:55:25 +0000
 +++ src/platforms/CMakeLists.txt	2016-06-08 13:28:19 +0000
@@ -71,4 +71,8 @@
    add_subdirectory(android/)
  endif()
--  add_subdirectory(evdev/)
++if (MIR_BUILD_PLATFORM_EGLSTREAM_KMS)
++  add_subdirectory(eglstream-kms)
++endif()
++
++add_subdirectory(evdev/)
 === added directory 'src/platforms/eglstream-kms'
 === added file 'src/platforms/eglstream-kms/CMakeLists.txt'
 --- src/platforms/eglstream-kms/CMakeLists.txt	1970-01-01 00:00:00 +0000
 +++ src/platforms/eglstream-kms/CMakeLists.txt	2016-06-08 13:28:19 +0000
@@ -0,0 +1,2 @@
++add_subdirectory(client/)
++add_subdirectory(server/)
 === added directory 'src/platforms/eglstream-kms/client'
 === added file 'src/platforms/eglstream-kms/client/CMakeLists.txt'
 --- src/platforms/eglstream-kms/client/CMakeLists.txt	1970-01-01 00:00:00 +0000
 +++ src/platforms/eglstream-kms/client/CMakeLists.txt	2016-06-08 13:28:19 +0000
@@ -0,0 +1,39 @@
++include_directories(${client_common_include_dirs})
++
++include_directories(
++    ${DRM_INCLUDE_DIRS}
++    ${EGL_INCLUDE_DIRS}
++)
++
++set(symbol_map ${CMAKE_CURRENT_SOURCE_DIR}/symbols.map)
++
++add_library(mirclientplatformeglstreamobjects OBJECT
++  client_platform_factory.cpp
++  client_platform.cpp
++  client_buffer_factory.cpp
++  client_buffer.cpp
++)
++
++mir_add_library_with_symbols(
++  mirclientplatformeglstream MODULE
++
++  ${symbol_map}
++  $<TARGET_OBJECTS:mirclientplatformeglstreamobjects>
++)
++
++set_target_properties(
++  mirclientplatformeglstream PROPERTIES
++  OUTPUT_NAME eglstream
++  LIBRARY_OUTPUT_DIRECTORY ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/client-modules
++  PREFIX ""
++  SUFFIX ".so.${MIR_CLIENT_PLATFORM_ABI}"
++  LINK_FLAGS "-Wl,--version-script,${symbol_map}"
++)
++
++target_link_libraries(mirclientplatformeglstream
++  mirclient
++  client_platform_common
++  ${DRM_LDFLAGS} ${DRM_LIBRARIES}
++)
++
++install(TARGETS mirclientplatformeglstream LIBRARY DESTINATION ${MIR_CLIENT_PLATFORM_PATH})
 === added file 'src/platforms/eglstream-kms/client/client_buffer.cpp'
 --- src/platforms/eglstream-kms/client/client_buffer.cpp	1970-01-01 00:00:00 +0000
 +++ src/platforms/eglstream-kms/client/client_buffer.cpp	2016-06-08 13:28:19 +0000
@@ -0,0 +1,159 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#include "mir_toolkit/mir_client_library.h"
++#include "client_buffer.h"
++
++#include <boost/throw_exception.hpp>
++
++#include <stdexcept>
++#include <system_error>
++
++#include <errno.h>
++#include <sys/mman.h>
++
++namespace mcl=mir::client;
++namespace mcle=mir::client::eglstream;
++namespace geom=mir::geometry;
++
++namespace
++{
++
++struct ShmMemoryRegion : mcl::MemoryRegion
++{
++    ShmMemoryRegion(
++        int buffer_fd,
++        geom::Size const& size_param,
++        geom::Stride stride_param,
++        MirPixelFormat format_param)
++        : size_in_bytes{size_param.height.as_uint32_t() * stride_param.as_uint32_t()}
++    {
++        static off_t const map_offset = 0;
++        width = size_param.width;
++        height = size_param.height;
++        stride = stride_param;
++        format = format_param;
++
++        void* map = mmap(
++            nullptr,
++            size_in_bytes,
++            PROT_READ | PROT_WRITE,
++            MAP_SHARED,
++            buffer_fd,
++            map_offset);
++        if (map == MAP_FAILED)
++        {
++            BOOST_THROW_EXCEPTION((
++                std::system_error{errno, std::system_category(), "Failed to mmap buffer"}));
++        }
++
++        vaddr = std::shared_ptr<char>(static_cast<char*>(map), [](auto*) noexcept {});
++    }
++
++    ~ShmMemoryRegion()
++    {
++        munmap(vaddr.get(), size_in_bytes);
++    }
++
++    size_t const size_in_bytes;
++};
++
++}
++
++mcle::ClientBuffer::ClientBuffer(
++    std::shared_ptr<MirBufferPackage> const& package,
++    geom::Size size, MirPixelFormat pf)
++    : creation_package{package},
++      rect({geom::Point{0, 0}, size}),
++      buffer_pf{pf}
++{
++    if (package->fd_items != 1)
++    {
++        BOOST_THROW_EXCEPTION(std::runtime_error(
++            "Buffer package does not contain the expected number of fd items"));
++    }
++}
++
++mcle::ClientBuffer::~ClientBuffer() noexcept
++{
++    // TODO (@raof): Error reporting? It should not be possible for this to fail; if it does,
++    //               something's seriously wrong.
++    close(creation_package->fd[0]);
++}
++
++std::shared_ptr<mcl::MemoryRegion> mcle::ClientBuffer::secure_for_cpu_write()
++{
++    int const buffer_fd = creation_package->fd[0];
++
++    return std::make_shared<ShmMemoryRegion>(
++        buffer_fd,
++        size(),
++        stride(),
++        pixel_format());
++}
++
++geom::Size mcle::ClientBuffer::size() const
++{
++    return rect.size;
++}
++
++geom::Stride mcle::ClientBuffer::stride() const
++{
++    return geom::Stride{creation_package->stride};
++}
++
++MirPixelFormat mcle::ClientBuffer::pixel_format() const
++{
++    return buffer_pf;
++}
++
++std::shared_ptr<MirNativeBuffer> mcle::ClientBuffer::native_buffer_handle() const
++{
++    creation_package->age = age();
++    return creation_package;
++}
++
++void mcle::ClientBuffer::update_from(MirBufferPackage const&)
++{
++}
++
++void mcle::ClientBuffer::fill_update_msg(MirBufferPackage& package)
++{
++    package.data_items = 0;
++    package.fd_items = 0;
++}
++
++MirNativeBuffer* mcle::ClientBuffer::as_mir_native_buffer() const
++{
++    //mesa has a POD native type for now. can return it directly to client API.
++    return native_buffer_handle().get();
++}
++
++void mcle::ClientBuffer::set_fence(MirNativeFence*, MirBufferAccess)
++{
++}
++
++MirNativeFence* mcle::ClientBuffer::get_fence() const
++{
++    return nullptr;
++}
++
++bool mcle::ClientBuffer::wait_fence(MirBufferAccess, std::chrono::nanoseconds)
++{
++    return true;
++}
 === added file 'src/platforms/eglstream-kms/client/client_buffer.h'
 --- src/platforms/eglstream-kms/client/client_buffer.h	1970-01-01 00:00:00 +0000
 +++ src/platforms/eglstream-kms/client/client_buffer.h	2016-06-08 13:28:19 +0000
@@ -0,0 +1,67 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by:
++ *   Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#ifndef MIR_CLIENT_EGLSTREAM_CLIENT_BUFFER_H_
++#define MIR_CLIENT_EGLSTREAM_CLIENT_BUFFER_H_
++
++#include "mir/aging_buffer.h"
++#include "mir_toolkit/mir_client_library.h"
++#include "mir/geometry/rectangle.h"
++
++#include <memory>
++
++namespace mir
++{
++namespace client
++{
++namespace eglstream
++{
++
++class ClientBuffer : public AgingBuffer
++{
++public:
++    ClientBuffer(
++        std::shared_ptr<MirBufferPackage> const& buffer_package,
++        geometry::Size size,
++        MirPixelFormat pf);
++
++    ~ClientBuffer() noexcept;
++
++    std::shared_ptr<MemoryRegion> secure_for_cpu_write();
++    geometry::Size size() const;
++    geometry::Stride stride() const;
++    MirPixelFormat pixel_format() const;
++    std::shared_ptr<MirNativeBuffer> native_buffer_handle() const;
++    void update_from(MirBufferPackage const&);
++    void fill_update_msg(MirBufferPackage&);
++    MirNativeBuffer* as_mir_native_buffer() const;
++    void set_fence(MirNativeFence*, MirBufferAccess);
++    MirNativeFence* get_fence() const;
++    bool wait_fence(MirBufferAccess, std::chrono::nanoseconds timeout);
++
++private:
++    std::shared_ptr<MirBufferPackage> const creation_package;
++    geometry::Rectangle const rect;
++    MirPixelFormat const buffer_pf;
++};
++
++}
++}
++}
++#endif /* MIR_CLIENT_EGLSTREAM_CLIENT_BUFFER_H_ */
 === added file 'src/platforms/eglstream-kms/client/client_buffer_factory.cpp'
 --- src/platforms/eglstream-kms/client/client_buffer_factory.cpp	1970-01-01 00:00:00 +0000
 +++ src/platforms/eglstream-kms/client/client_buffer_factory.cpp	2016-06-08 13:28:19 +0000
@@ -0,0 +1,36 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify
++ * it under the terms of the GNU Lesser General Public License version 3 as
++ * published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by:
++ *   Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#include "client_buffer_factory.h"
++#include "client_buffer.h"
++
++namespace mcl=mir::client;
++namespace mcle=mir::client::eglstream;
++
++std::shared_ptr<mcl::ClientBuffer>
++mcle::ClientBufferFactory::create_buffer(
++    std::shared_ptr<MirBufferPackage> const& package,
++    geometry::Size /*size*/,
++    MirPixelFormat pf)
++{
++    return std::make_shared<mcle::ClientBuffer>(
++        package,
++        geometry::Size{package->width, package->height},
++        pf);
++}
 === added file 'src/platforms/eglstream-kms/client/client_buffer_factory.h'
 --- src/platforms/eglstream-kms/client/client_buffer_factory.h	1970-01-01 00:00:00 +0000
 +++ src/platforms/eglstream-kms/client/client_buffer_factory.h	2016-06-08 13:28:19 +0000
@@ -0,0 +1,45 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify
++ * it under the terms of the GNU Lesser General Public License version 3 as
++ * published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by:
++ *   Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#ifndef MIR_CLIENT_EGLSTREAM_CLIENT_BUFFER_FACTORY_H_
++#define MIR_CLIENT_EGLSTREAM_CLIENT_BUFFER_FACTORY_H_
++
++#include "mir/client_buffer_factory.h"
++
++namespace mir
++{
++namespace client
++{
++namespace eglstream
++{
++
++class ClientBufferFactory : public client::ClientBufferFactory
++{
++public:
++    ClientBufferFactory() = default;
++
++    std::shared_ptr<client::ClientBuffer> create_buffer(
++        std::shared_ptr<MirBufferPackage> const& package,
++        geometry::Size size, MirPixelFormat pf);
++};
++
++}
++}
++}
++#endif /* MIR_CLIENT_EGLSTREAM_CLIENT_BUFFER_FACTORY_H_ */
 === added file 'src/platforms/eglstream-kms/client/client_platform.cpp'
 --- src/platforms/eglstream-kms/client/client_platform.cpp	1970-01-01 00:00:00 +0000
 +++ src/platforms/eglstream-kms/client/client_platform.cpp	2016-06-08 13:28:19 +0000
@@ -0,0 +1,77 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#include "mir_toolkit/mir_client_library.h"
++#include "client_platform.h"
++#include "client_buffer_factory.h"
++#include "mir/client_buffer_factory.h"
++#include "mir/client_context.h"
++
++#include <cstring>
++#include <boost/throw_exception.hpp>
++
++namespace mcl=mir::client;
++namespace mcle=mir::client::eglstream;
++namespace geom=mir::geometry;
++
++mcle::ClientPlatform::ClientPlatform(ClientContext* const context)
++    : context{context}
++{
++}
++
++std::shared_ptr<mcl::ClientBufferFactory> mcle::ClientPlatform::create_buffer_factory()
++{
++    return std::make_shared<mcle::ClientBufferFactory>();
++}
++
++std::shared_ptr<void> mcle::ClientPlatform::create_egl_native_window(EGLNativeSurface* /*client_surface*/)
++{
++    return nullptr;
++}
++
++std::shared_ptr<EGLNativeDisplayType> mcle::ClientPlatform::create_egl_native_display()
++{
++    return nullptr;
++}
++
++MirPlatformType mcle::ClientPlatform::platform_type() const
++{
++    return mir_platform_type_eglstream;
++}
++
++void mcle::ClientPlatform::populate(MirPlatformPackage& /*package*/) const
++{
++}
++
++MirPlatformMessage* mcle::ClientPlatform::platform_operation(MirPlatformMessage const* /*msg*/)
++{
++    return nullptr;
++}
++
++MirNativeBuffer* mcle::ClientPlatform::convert_native_buffer(graphics::NativeBuffer* buf) const
++{
++    // Only buffers we currently support are ShmBuffers, which are type-compatible
++    return buf;
++}
++
++
++MirPixelFormat mcle::ClientPlatform::get_egl_pixel_format(
++    EGLDisplay /*disp*/, EGLConfig /*conf*/) const
++{
++    BOOST_THROW_EXCEPTION(std::runtime_error{"EGL support unimplemented"});
++}
 === added file 'src/platforms/eglstream-kms/client/client_platform.h'
 --- src/platforms/eglstream-kms/client/client_platform.h	1970-01-01 00:00:00 +0000
 +++ src/platforms/eglstream-kms/client/client_platform.h	2016-06-08 13:28:19 +0000
@@ -0,0 +1,52 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++#ifndef MIR_CLIENT_EGLSTREAM_CLIENT_PLATFORM_H_
++#define MIR_CLIENT_EGLSTREAM_CLIENT_PLATFORM_H_
++
++#include "mir/client_platform.h"
++
++namespace mir
++{
++namespace client
++{
++namespace eglstream
++{
++
++class ClientPlatform : public client::ClientPlatform
++{
++public:
++    ClientPlatform(ClientContext* const context);
++
++    MirPlatformType platform_type() const override;
++    void populate(MirPlatformPackage& package) const override;
++    MirPlatformMessage* platform_operation(MirPlatformMessage const* request) override;
++    std::shared_ptr<ClientBufferFactory> create_buffer_factory() override;
++    std::shared_ptr<void> create_egl_native_window(EGLNativeSurface *surface) override;
++    std::shared_ptr<EGLNativeDisplayType> create_egl_native_display() override;
++    MirNativeBuffer* convert_native_buffer(graphics::NativeBuffer*) const override;
++    MirPixelFormat get_egl_pixel_format(EGLDisplay, EGLConfig) const override;
++
++private:
++    ClientContext* const context;
++};
++
++}
++}
++}
++
++#endif /* MIR_CLIENT_EGLSTREAM_CLIENT_PLATFORM_H_ */
 === added file 'src/platforms/eglstream-kms/client/client_platform_factory.cpp'
 --- src/platforms/eglstream-kms/client/client_platform_factory.cpp	1970-01-01 00:00:00 +0000
 +++ src/platforms/eglstream-kms/client/client_platform_factory.cpp	2016-06-08 13:28:19 +0000
@@ -0,0 +1,59 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#include "mir/client_platform_factory.h"
++#include "client_platform.h"
++#include "mir_toolkit/client_types.h"
++#include "mir/client_context.h"
++#include "mir/egl_native_display_container.h"
++#include "mir/assert_module_entry_point.h"
++#include "mir/module_deleter.h"
++
++#include "mir_toolkit/mir_client_library.h"
++
++#include <cstring>
++
++namespace mcl = mir::client;
++namespace mcle = mcl::eglstream;
++
++namespace
++{
++bool is_eglstream_server(mcl::ClientContext* context)
++{
++    MirModuleProperties module_properties;
++
++    context->populate_graphics_module(module_properties);
++
++    return strncmp(module_properties.name, "mir:eglstream", strlen("mir:eglstream")) == 0;
++}
++}
++
++mir::UniqueModulePtr<mcl::ClientPlatform> create_client_platform(mcl::ClientContext* context)
++{
++    mir::assert_entry_point_signature<mcl::CreateClientPlatform>(&create_client_platform);
++
++    return mir::make_module_ptr<mcle::ClientPlatform>(context);
++}
++
++bool
++is_appropriate_module(mcl::ClientContext* context)
++{
++    mir::assert_entry_point_signature<mcl::ClientPlatformProbe>(&is_appropriate_module);
++
++    return is_eglstream_server(context);
++}
 === added file 'src/platforms/eglstream-kms/client/symbols.map'
 --- src/platforms/eglstream-kms/client/symbols.map	1970-01-01 00:00:00 +0000
 +++ src/platforms/eglstream-kms/client/symbols.map	2016-06-08 13:28:19 +0000
@@ -0,0 +1,7 @@
++MIR_CLIENT_PLATFORM_5 {
++  global:
++    create_client_platform;
++    is_appropriate_module;
++  local:
++    *;
++};
 === added directory 'src/platforms/eglstream-kms/server'
 === added file 'src/platforms/eglstream-kms/server/CMakeLists.txt'
 --- src/platforms/eglstream-kms/server/CMakeLists.txt	1970-01-01 00:00:00 +0000
 +++ src/platforms/eglstream-kms/server/CMakeLists.txt	2016-06-08 13:28:19 +0000
@@ -0,0 +1,55 @@
++include_directories(
++  ${server_common_include_dirs}
++  ${DRM_INCLUDE_DIRS}
++  ${GBM_INCLUDE_DIRS}
++  ${EGL_INCLUDE_DIRS}
++  ${GLESv2_INCLUDE_DIRS}
++  ${EPOXY_INCLUDE_DIRS}
++)
++
++configure_file(
++  ${CMAKE_CURRENT_SOURCE_DIR}/symbols.map.in
++  ${CMAKE_CURRENT_BINARY_DIR}/symbols.map
++)
++set(symbol_map ${CMAKE_CURRENT_BINARY_DIR}/symbols.map)
++
++mir_add_library_with_symbols(
++  mirplatformgraphicseglstreamkms MODULE
++
++  ${symbol_map}
++  platform_symbols.cpp
++  platform.cpp
++  buffer_allocator.cpp
++  buffer_allocator.h
++  display.cpp
++  display.h
++  kms_display_configuration.h
++  kms_display_configuration.cpp
++  egl_output.h
++  egl_output.cpp
++)
++
++target_link_libraries(
++  mirplatformgraphicseglstreamkms
++
++  PRIVATE
++  mirplatform
++  server_platform_common
++  kms_utils
++  ${Boost_PROGRAM_OPTIONS_LIBRARY}
++  ${DRM_LDFLAGS} ${DRM_LIBRARIES}
++  ${EGL_LDFLAGS} ${EGL_LIBRARIES}
++  ${GLESv2_LDFLAGS} ${GLESv2_LIBRARIES}
++  ${EPOXY_LDFLAGS} ${EPOXY_LIBRARIES}
++)
++
++set_target_properties(
++  mirplatformgraphicseglstreamkms PROPERTIES
++  OUTPUT_NAME graphics-eglstream-kms
++  LIBRARY_OUTPUT_DIRECTORY ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/server-modules
++  PREFIX ""
++  SUFFIX ".so.${MIR_SERVER_GRAPHICS_PLATFORM_ABI}"
++  LINK_FLAGS "-Wl,--exclude-libs=ALL -Wl,--version-script,${symbol_map}"
++)
++
++install(TARGETS mirplatformgraphicseglstreamkms LIBRARY DESTINATION ${MIR_SERVER_PLATFORM_PATH})
 === added file 'src/platforms/eglstream-kms/server/buffer_allocator.cpp'
 --- src/platforms/eglstream-kms/server/buffer_allocator.cpp	1970-01-01 00:00:00 +0000
 +++ src/platforms/eglstream-kms/server/buffer_allocator.cpp	2016-06-08 13:28:19 +0000
@@ -0,0 +1,69 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by:
++ *   Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#include "buffer_allocator.h"
++#include "buffer_texture_binder.h"
++#include "anonymous_shm_file.h"
++#include "shm_buffer.h"
++#include "mir/graphics/buffer_properties.h"
++#include <boost/throw_exception.hpp>
++#include <boost/exception/errinfo_errno.hpp>
++
++#include <system_error>
++#include <cassert>
++
++namespace mg  = mir::graphics;
++namespace mge = mg::eglstream;
++namespace mgc = mg::common;
++namespace geom = mir::geometry;
++
++mge::BufferAllocator::BufferAllocator()
++{
++}
++
++std::shared_ptr<mg::Buffer> mge::BufferAllocator::alloc_buffer(
++    BufferProperties const& buffer_properties)
++{
++    if (!mgc::ShmBuffer::supports(buffer_properties.format))
++    {
++        BOOST_THROW_EXCEPTION(
++            std::runtime_error(
++                "Trying to create SHM buffer with unsupported pixel format"));
++    }
++
++    auto const stride = geom::Stride{
++        MIR_BYTES_PER_PIXEL(buffer_properties.format) *
++        buffer_properties.size.width.as_uint32_t()};
++    size_t const size_in_bytes =
++        stride.as_int() * buffer_properties.size.height.as_int();
++    auto shm_file =
++        std::make_unique<mgc::AnonymousShmFile>(size_in_bytes);
++
++    auto const buffer =
++        std::make_shared<mgc::ShmBuffer>(std::move(shm_file), buffer_properties.size,
++                                         buffer_properties.format);
++
++    return buffer;
++}
++
++std::vector<MirPixelFormat> mge::BufferAllocator::supported_pixel_formats()
++{
++    // Lazy
++    return {mir_pixel_format_argb_8888, mir_pixel_format_xrgb_8888};
++}
 === added file 'src/platforms/eglstream-kms/server/buffer_allocator.h'
 --- src/platforms/eglstream-kms/server/buffer_allocator.h	1970-01-01 00:00:00 +0000
 +++ src/platforms/eglstream-kms/server/buffer_allocator.h	2016-06-08 13:28:19 +0000
@@ -0,0 +1,48 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#ifndef MIR_PLATFORMS_EGLSTREAM_BUFFER_ALLOCATOR_
++#define MIR_PLATFORMS_EGLSTREAM_BUFFER_ALLOCATOR_
++
++#include "mir/graphics/graphic_buffer_allocator.h"
++#include "mir/graphics/buffer_id.h"
++
++#include <memory>
++
++namespace mir
++{
++namespace graphics
++{
++
++namespace eglstream
++{
++
++class BufferAllocator: public graphics::GraphicBufferAllocator
++{
++public:
++    BufferAllocator();
++
++    std::shared_ptr<Buffer> alloc_buffer(graphics::BufferProperties const& buffer_properties) override;
++    std::vector<MirPixelFormat> supported_pixel_formats() override;
++};
++
++}
++}
++}
++
++#endif // MIR_PLATFORMS_EGLSTREAM_BUFFER_ALLOCATOR_
 === added file 'src/platforms/eglstream-kms/server/display.cpp'
 --- src/platforms/eglstream-kms/server/display.cpp	1970-01-01 00:00:00 +0000
 +++ src/platforms/eglstream-kms/server/display.cpp	2016-06-08 13:28:19 +0000
@@ -0,0 +1,363 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#include <epoxy/egl.h>
++
++#include "display.h"
++#include "egl_output.h"
++
++#include "kms-utils/drm_mode_resources.h"
++
++#include "mir/graphics/display_configuration.h"
++#include "mir/graphics/display_configuration_policy.h"
++#include "mir/graphics/overlapping_output_grouping.h"
++#include "mir/graphics/gl_context.h"
++#include "mir/graphics/gl_config.h"
++#include "mir/graphics/virtual_output.h"
++#include "mir/graphics/egl_error.h"
++#include "mir/graphics/display_buffer.h"
++#include "mir/renderer/gl/render_target.h"
++
++#include <drm/drm.h>
++#include <xf86drmMode.h>
++#include <sys/ioctl.h>
++#include <system_error>
++#include <boost/throw_exception.hpp>
++
++namespace mg = mir::graphics;
++namespace mge = mir::graphics::eglstream;
++namespace mgk = mir::graphics::kms;
++
++namespace
++{
++EGLConfig choose_config(EGLDisplay display, mg::GLConfig const& requested_config)
++{
++    EGLint const config_attr[] = {
++        EGL_SURFACE_TYPE, EGL_STREAM_BIT_KHR,
++        EGL_RED_SIZE, 8,
++        EGL_GREEN_SIZE, 8,
++        EGL_BLUE_SIZE, 8,
++        EGL_ALPHA_SIZE, 0,
++        EGL_DEPTH_SIZE, requested_config.depth_buffer_bits(),
++        EGL_STENCIL_SIZE, requested_config.stencil_buffer_bits(),
++        EGL_RENDERABLE_TYPE, MIR_SERVER_EGL_OPENGL_BIT,
++        EGL_NONE
++    };
++
++    EGLint num_egl_configs;
++    EGLConfig egl_config;
++    if (eglChooseConfig(display, config_attr, &egl_config, 1, &num_egl_configs) != EGL_TRUE)
++    {
++        BOOST_THROW_EXCEPTION(mg::egl_error("Failed to chose EGL config"));
++    }
++    else if (num_egl_configs != 1)
++    {
++        BOOST_THROW_EXCEPTION(std::runtime_error{"Failed to find compatible EGL config"});
++    }
++
++    return egl_config;
++}
++
++EGLContext create_context(EGLDisplay display, EGLConfig config)
++{
++    eglBindAPI(MIR_SERVER_EGL_OPENGL_API);
++
++    EGLint const context_attr[] = {
++#if MIR_SERVER_EGL_OPENGL_BIT == EGL_OPENGL_ES2_BIT
++        EGL_CONTEXT_CLIENT_VERSION, 2,
++#endif
++        EGL_NONE
++    };
++
++    EGLContext context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attr);
++    if (context == EGL_NO_CONTEXT)
++    {
++        BOOST_THROW_EXCEPTION(mg::egl_error("Failed to create EGL context"));
++    }
++
++    return context;
++}
++
++EGLContext create_context(EGLDisplay display, EGLConfig config, EGLContext shared_context)
++{
++    eglBindAPI(MIR_SERVER_EGL_OPENGL_API);
++
++    EGLint const context_attr[] = {
++#if MIR_SERVER_EGL_OPENGL_BIT == EGL_OPENGL_ES2_BIT
++        EGL_CONTEXT_CLIENT_VERSION, 2,
++#endif
++        EGL_NONE
++    };
++
++    EGLContext context = eglCreateContext(display, config, shared_context, context_attr);
++    if (context == EGL_NO_CONTEXT)
++    {
++        BOOST_THROW_EXCEPTION(mg::egl_error("Failed to create EGL context"));
++    }
++
++    return context;
++}
++
++class DisplayBuffer
++    : public mg::DisplaySyncGroup,
++      public mg::DisplayBuffer,
++      public mg::NativeDisplayBuffer,
++      public mir::renderer::gl::RenderTarget
++{
++public:
++    DisplayBuffer(EGLDisplay dpy, EGLContext ctx, EGLConfig config, mge::kms::EGLOutput const& output)
++        : dpy{dpy},
++          ctx{create_context(dpy, config, ctx)},
++          layer{output.output_layer()},
++          view_area_{output.top_left, output.size()}
++    {
++        EGLint const stream_attribs[] = {
++            EGL_STREAM_FIFO_LENGTH_KHR, 1,
++            EGL_NONE
++        };
++        output_stream = eglCreateStreamKHR(dpy, stream_attribs);
++        if (output_stream == EGL_NO_STREAM_KHR)
++        {
++            BOOST_THROW_EXCEPTION(mg::egl_error("Failed to create EGLStream"));
++        }
++
++        EGLAttrib swap_interval;
++        if (eglQueryOutputLayerAttribEXT(dpy, layer, EGL_SWAP_INTERVAL_EXT, &swap_interval) != EGL_TRUE)
++        {
++            BOOST_THROW_EXCEPTION(mg::egl_error("Failed to query swap interval"));
++        }
++
++        if (eglOutputLayerAttribEXT(dpy, layer, EGL_SWAP_INTERVAL_EXT, 1) != EGL_TRUE)
++        {
++            BOOST_THROW_EXCEPTION(mg::egl_error("Failed to set swap interval"));
++        }
++
++        if (eglStreamConsumerOutputEXT(dpy, output_stream, output.output_layer()) == EGL_FALSE)
++        {
++            BOOST_THROW_EXCEPTION(mg::egl_error("Failed to attach EGLStream to output"));
++        };
++
++        EGLint const surface_attribs[] = {
++            EGL_WIDTH, output.size().width.as_int(),
++            EGL_HEIGHT, output.size().height.as_int(),
++            EGL_NONE,
++        };
++        surface = eglCreateStreamProducerSurfaceKHR(dpy, config, output_stream, surface_attribs);
++        if (surface == EGL_NO_SURFACE)
++        {
++            BOOST_THROW_EXCEPTION(mg::egl_error("Failed to create StreamProducerSurface"));
++        }
++
++    }
++
++    /* gl::RenderTarget */
++    void make_current() override
++    {
++        if (eglMakeCurrent(dpy, surface, surface, ctx) != EGL_TRUE)
++        {
++            BOOST_THROW_EXCEPTION(mg::egl_error("Failed to make context current"));
++        }
++    }
++
++    void release_current() override
++    {
++        if (eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT) != EGL_TRUE)
++        {
++            BOOST_THROW_EXCEPTION(mg::egl_error("Failed to release context"));
++        }
++    }
++
++    void swap_buffers() override
++    {
++        if (eglSwapBuffers(dpy, surface) != EGL_TRUE)
++        {
++            BOOST_THROW_EXCEPTION(mg::egl_error("eglSwapBuffers failed"));
++        }
++    }
++
++    mir::geometry::Rectangle view_area() const override
++    {
++        return view_area_;
++    }
++
++    bool post_renderables_if_optimizable(const mir::graphics::RenderableList& /*renderlist*/) override
++    {
++        return false;
++    }
++
++    MirOrientation orientation() const override
++    {
++        return mir_orientation_normal;
++    }
++
++    MirMirrorMode mirror_mode() const override
++    {
++        return mir_mirror_mode_none;
++    }
++
++    mir::graphics::NativeDisplayBuffer* native_display_buffer() override
++    {
++        return this;
++    }
++
++    void for_each_display_buffer(const std::function<void(mir::graphics::DisplayBuffer&)>& f) override
++    {
++        f(*this);
++    }
++
++    void post() override
++    {
++
++    }
++
++    void bind() override
++    {
++    }
++
++    std::chrono::milliseconds recommended_sleep() const override
++    {
++        return std::chrono::milliseconds{0};
++    }
++
++private:
++    EGLDisplay dpy;
++    EGLContext ctx;
++    EGLOutputLayerEXT layer;
++    mir::geometry::Rectangle const view_area_;
++    EGLStreamKHR output_stream;
++    EGLSurface surface;
++};
++}
++
++mge::Display::Display(
++    mir::Fd drm_node,
++    EGLDisplay display,
++    std::shared_ptr<DisplayConfigurationPolicy> const& configuration_policy,
++    GLConfig const& gl_conf)
++    : drm_node{drm_node},
++      display{display},
++      config{choose_config(display, gl_conf)},
++      context{create_context(display, config)},
++      display_configuration{this->drm_node, display}
++{
++    auto ret = drmSetClientCap(drm_node, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
++    if (ret != 0)
++    {
++        BOOST_THROW_EXCEPTION(std::system_error(-ret, std::system_category(), "Request for Universal Planes support failed"));
++    }
++
++    ret = drmSetClientCap(drm_node, DRM_CLIENT_CAP_ATOMIC, 1);
++    if (ret != 0)
++    {
++        BOOST_THROW_EXCEPTION(std::system_error(-ret, std::system_category(), "Request for Atomic Modesetting support failed"));
++    }
++
++    configuration_policy->apply_to(display_configuration);
++
++    configure(display_configuration);
++}
++
++void mge::Display::for_each_display_sync_group(const std::function<void(DisplaySyncGroup&)>& f)
++{
++    for (auto& group : active_sync_groups)
++    {
++        f(*group);
++    }
++}
++
++std::unique_ptr<mg::DisplayConfiguration> mge::Display::configuration() const
++{
++    return display_configuration.clone();
++}
++
++void mge::Display::configure(DisplayConfiguration const& conf)
++{
++    auto kms_conf = dynamic_cast<KMSDisplayConfiguration const&>(conf);
++    active_sync_groups.clear();
++    kms_conf.for_each_output([this, &conf](kms::EGLOutput const& output)
++         {
++             if (output.used)
++             {
++                 const_cast<kms::EGLOutput&>(output).configure(output.current_mode_index);
++                 active_sync_groups.emplace_back(std::make_unique<::DisplayBuffer>(display, context, config, output));
++             }
++         });
++}
++
++void mge::Display::register_configuration_change_handler(
++    EventHandlerRegister& /*handlers*/,
++    DisplayConfigurationChangeHandler const& /*conf_change_handler*/)
++{
++}
++
++void mge::Display::register_pause_resume_handlers(
++    EventHandlerRegister& /*handlers*/,
++    DisplayPauseHandler const& /*pause_handler*/,
++    DisplayResumeHandler const& /*resume_handler*/)
++{
++}
++
++void mge::Display::pause()
++{
++
++}
++
++void mge::Display::resume()
++{
++
++}
++
++std::shared_ptr<mg::Cursor> mge::Display::create_hardware_cursor(
++    std::shared_ptr<CursorImage> const& /*initial_image*/)
++{
++    // TODO: Find the cursor plane, and use it.
++    return nullptr;
++}
++
++std::unique_ptr<mg::GLContext> mge::Display::create_gl_context()
++{
++    class GLContext : public mg::GLContext
++    {
++    public:
++        GLContext(EGLDisplay display, EGLContext context)
++            : display{display},
++              context{context}
++        {
++        }
++
++        void make_current() const override
++        {
++            eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, context);
++        }
++
++        void release_current() const override
++        {
++            eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
++        }
++
++    private:
++        EGLDisplay display;
++        EGLContext context;
++    };
++    return std::make_unique<GLContext>(display, context);
++}
++
++std::unique_ptr<mg::VirtualOutput> mge::Display::create_virtual_output(int /*width*/, int /*height*/)
++{
++    return nullptr;
++}
 === added file 'src/platforms/eglstream-kms/server/display.h'
 --- src/platforms/eglstream-kms/server/display.h	1970-01-01 00:00:00 +0000
 +++ src/platforms/eglstream-kms/server/display.h	2016-06-08 13:28:19 +0000
@@ -0,0 +1,82 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#ifndef MIR_PLATFORMS_EGLSTREAM_KMS_DISPLAY_H_
++#define MIR_PLATFORMS_EGLSTREAM_KMS_DISPLAY_H_
++
++#include "mir/graphics/display.h"
++#include "kms_display_configuration.h"
++#include "mir/fd.h"
++
++namespace mir
++{
++namespace graphics
++{
++class DisplayConfigurationPolicy;
++class GLConfig;
++
++namespace eglstream
++{
++
++class Display : public mir::graphics::Display
++{
++public:
++    Display(
++        mir::Fd drm_node,
++        EGLDisplay display,
++        std::shared_ptr<DisplayConfigurationPolicy> const& configuration_policy,
++        GLConfig const& gl_conf);
++
++    void for_each_display_sync_group(const std::function<void(DisplaySyncGroup&)>& f) override;
++
++    std::unique_ptr<DisplayConfiguration> configuration() const override;
++
++    void configure(DisplayConfiguration const& conf) override;
++
++    void register_configuration_change_handler(EventHandlerRegister& handlers,
++        DisplayConfigurationChangeHandler const& conf_change_handler) override;
++
++    void register_pause_resume_handlers(EventHandlerRegister& handlers,
++        DisplayPauseHandler const& pause_handler, DisplayResumeHandler const& resume_handler) override;
++
++    void pause() override;
++
++    void resume() override;
++
++    std::shared_ptr<Cursor> create_hardware_cursor(std::shared_ptr<CursorImage> const& initial_image) override;
++
++    std::unique_ptr<GLContext> create_gl_context() override;
++
++    std::unique_ptr<VirtualOutput> create_virtual_output(int width, int height) override;
++
++private:
++    mir::Fd const drm_node;
++    EGLDisplay display;
++    EGLConfig config;
++    EGLContext context;
++    KMSDisplayConfiguration display_configuration;
++    std::vector<std::unique_ptr<DisplaySyncGroup>> active_sync_groups;
++    std::shared_ptr<DisplayConfigurationPolicy> const configuration_policy;
++};
++
++}
++}
++
++}
++
++#endif  // MIR_PLATFORMS_EGLSTREAM_KMS_DISPLAY_H_
 === added file 'src/platforms/eglstream-kms/server/egl_output.cpp'
 --- src/platforms/eglstream-kms/server/egl_output.cpp	1970-01-01 00:00:00 +0000
 +++ src/platforms/eglstream-kms/server/egl_output.cpp	2016-06-08 13:28:19 +0000
@@ -0,0 +1,359 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#include <epoxy/egl.h>
++
++#include "egl_output.h"
++#include "mir/graphics/egl_error.h"
++#include "kms-utils/kms_connector.h"
++
++#include <cstring>
++#include <drm/drm.h>
++#include <sys/ioctl.h>
++#include <vector>
++#include <boost/throw_exception.hpp>
++#include <unordered_map>
++#include <tuple>
++#include <sys/mman.h>
++
++namespace mg = mir::graphics;
++namespace mge = mg::eglstream;
++namespace mgek = mge::kms;
++namespace mgk = mg::kms;
++namespace geom = mir::geometry;
++
++namespace
++{
++namespace
++{
++class DumbFb
++{
++public:
++    DumbFb(int drm_fd, uint32_t width, uint32_t height)
++        : drm_fd{drm_fd}
++    {
++        struct drm_mode_create_dumb params = {};
++
++        params.bpp = 32;
++        params.height = height;
++        params.width = width;
++
++        if (ioctl(drm_fd, DRM_IOCTL_MODE_CREATE_DUMB, &params) != 0)
++        {
++            BOOST_THROW_EXCEPTION((std::system_error{errno, std::system_category(), "Failed to create dumb buffer"}));
++        }
++
++        gem_handle = params.handle;
++        pitch_ = params.pitch;
++
++        auto ret = drmModeAddFB(drm_fd, width, height, 24, 32, params.pitch, params.handle, &fb_id);
++        if (ret)
++        {
++            BOOST_THROW_EXCEPTION((std::system_error{-ret, std::system_category(), "Failed to attach dumb buffer to FB"}));
++        }
++
++        struct drm_mode_map_dumb map_request = {};
++
++        map_request.handle = gem_handle;
++
++        ret = drmIoctl(drm_fd, DRM_IOCTL_MODE_MAP_DUMB, &map_request);
++        if (ret)
++        {
++            BOOST_THROW_EXCEPTION((std::system_error{-ret, std::system_category(), "Failed to map dumb buffer"}));
++        }
++
++        auto map = mmap(0, params.size, PROT_READ | PROT_WRITE, MAP_SHARED, drm_fd, map_request.offset);
++        if (map == MAP_FAILED)
++        {
++            BOOST_THROW_EXCEPTION((std::system_error{errno, std::system_category(), "Failed to mmap() buffer"}));
++        }
++    }
++    ~DumbFb() noexcept(false)
++    {
++        struct drm_mode_destroy_dumb params = { gem_handle };
++
++        if (ioctl(drm_fd, DRM_IOCTL_MODE_DESTROY_DUMB, &params) != 0)
++        {
++            if (!std::uncaught_exception())
++            {
++                BOOST_THROW_EXCEPTION((std::system_error{errno, std::system_category(), "Failed to destroy dumb buffer"}));
++            }
++        }
++    }
++
++    uint32_t handle() const
++    {
++        return gem_handle;
++    }
++
++    uint32_t pitch() const
++    {
++        return pitch_;
++    }
++
++    uint32_t id() const
++    {
++        return fb_id;
++    }
++
++private:
++    int const drm_fd;
++    uint32_t fb_id;
++    uint32_t gem_handle;
++    uint32_t pitch_;
++};
++
++}
++
++uint32_t kms_id_from_port(EGLDisplay dpy, EGLOutputPortEXT port)
++{
++    EGLAttrib kms_connector_id;
++    if (eglQueryOutputPortAttribEXT(dpy, port, EGL_DRM_CONNECTOR_EXT, &kms_connector_id) != EGL_TRUE)
++    {
++        BOOST_THROW_EXCEPTION(mg::egl_error("Failed to get EGLOutputPort → KMS connector ID mapping"));
++    }
++    return static_cast<uint32_t>(kms_connector_id);
++}
++
++void refresh_connector(int drm_fd, mgk::DRMModeConnectorUPtr& connector)
++{
++    connector = mgk::get_connector(drm_fd, connector->connector_id);
++}
++}
++
++mgek::EGLOutput::EGLOutput(
++    int drm_fd,
++    EGLDisplay dpy,
++    EGLOutputPortEXT connector)
++    : drm_fd{drm_fd},
++      display{dpy},
++      port{connector},
++      connector{mgk::get_connector(drm_fd, kms_id_from_port(dpy, port))}
++{
++
++}
++
++mgek::EGLOutput::~EGLOutput() noexcept(false)
++{
++    auto const uncaught_exception = std::uncaught_exception();
++    try
++    {
++        restore_saved_crtc();
++    }
++    catch(...)
++    {
++        if (!uncaught_exception)
++        {
++            throw;
++        }
++    }
++}
++
++void mgek::EGLOutput::reset()
++{
++    /* Update the connector to ensure we have the latest information */
++    refresh_connector(drm_fd, connector);
++
++    // TODO: What if we can't locate the DPMS property?
++    // TODO: Replace with mgk::ObjectProperties
++    for (int i = 0; i < connector->count_props; i++)
++    {
++        auto prop = drmModeGetProperty(drm_fd, connector->props[i]);
++        if (prop && (prop->flags & DRM_MODE_PROP_ENUM)) {
++            if (!strcmp(prop->name, "DPMS"))
++            {
++                dpms_enum_id = connector->props[i];
++                drmModeFreeProperty(prop);
++                break;
++            }
++            drmModeFreeProperty(prop);
++        }
++    }
++}
++
++geom::Size mgek::EGLOutput::size() const
++{
++    drmModeModeInfo const& mode = connector->modes[mode_index];
++    return {mode.hdisplay, mode.vdisplay};
++}
++
++int mgek::EGLOutput::max_refresh_rate() const
++{
++    // TODO: In future when DRM exposes FreeSync/Adaptive Sync/G-Sync info
++    //       this value may be calculated differently.
++    drmModeModeInfo const& current_mode = connector->modes[mode_index];
++    return current_mode.vrefresh;
++}
++
++void mgek::EGLOutput::configure(size_t kms_mode_index)
++{
++    mode_index = kms_mode_index;
++    auto const width = connector->modes[kms_mode_index].hdisplay;
++    auto const height = connector->modes[kms_mode_index].vdisplay;
++
++    std::unique_ptr<drmModeAtomicReq, void(*)(drmModeAtomicReqPtr)>
++        request{drmModeAtomicAlloc(), &drmModeAtomicFree};
++
++    mgk::DRMModeCrtcUPtr crtc;
++    mgk::DRMModePlaneUPtr plane;
++
++    std::tie(crtc, plane) = mgk::find_crtc_with_primary_plane(drm_fd, connector);
++    auto const crtc_id = crtc->crtc_id;
++
++    uint32_t mode_id{0};
++    auto ret = drmModeCreatePropertyBlob(
++        drm_fd,
++        &connector->modes[kms_mode_index],
++        sizeof(connector->modes[kms_mode_index]),
++        &mode_id);
++
++    if (ret != 0)
++    {
++        BOOST_THROW_EXCEPTION(
++            std::system_error(-ret, std::system_category(), "Failed to create DRM Mode property blob"));
++    }
++
++    DumbFb dummy{drm_fd, width, height};
++
++    mgk::ObjectProperties crtc_props{drm_fd, crtc_id, DRM_MODE_OBJECT_CRTC};
++
++    /* Activate the CRTC and set the mode */
++    drmModeAtomicAddProperty(request.get(), crtc_id, crtc_props.id_for("MODE_ID"), mode_id);
++    drmModeAtomicAddProperty(request.get(), crtc_id, crtc_props.id_for("ACTIVE"), 1);
++
++    /* Set CRTC for the output */
++    auto const connector_id = connector->connector_id;
++    mgk::ObjectProperties connector_props{drm_fd, connector_id, DRM_MODE_OBJECT_CONNECTOR};
++    drmModeAtomicAddProperty(request.get(), connector_id, connector_props.id_for("CRTC_ID"), crtc_id);
++
++    /* Set up the output plane... */
++    auto const plane_id = plane->plane_id;
++    mgk::ObjectProperties plane_props{drm_fd, plane_id, DRM_MODE_OBJECT_PLANE};
++
++    /* Source viewport. Coordinates are 16.16 fixed point format */
++    drmModeAtomicAddProperty(request.get(), plane_id, plane_props.id_for("SRC_X"), 0);
++    drmModeAtomicAddProperty(request.get(), plane_id, plane_props.id_for("SRC_Y"), 0);
++    drmModeAtomicAddProperty(request.get(), plane_id, plane_props.id_for("SRC_W"), width << 16);
++    drmModeAtomicAddProperty(request.get(), plane_id, plane_props.id_for("SRC_H"), height << 16);
++
++    /* Destination viewport. Coordinates are *not* 16.16 */
++    drmModeAtomicAddProperty(request.get(), plane_id, plane_props.id_for("CRTC_X"), 0);
++    drmModeAtomicAddProperty(request.get(), plane_id, plane_props.id_for("CRTC_Y"), 0);
++    drmModeAtomicAddProperty(request.get(), plane_id, plane_props.id_for("CRTC_W"), width);
++    drmModeAtomicAddProperty(request.get(), plane_id, plane_props.id_for("CRTC_H"), height);
++
++    /* Set a surface for the plane, and connect to the CRTC */
++    drmModeAtomicAddProperty(request.get(), plane_id, plane_props.id_for("FB_ID"), dummy.id());
++    drmModeAtomicAddProperty(request.get(), plane_id, plane_props.id_for("CRTC_ID"), crtc_id);
++
++    /* We don't monitor the DRM events (yet), so have no userdata */
++    ret = drmModeAtomicCommit(drm_fd, request.get(), DRM_MODE_ATOMIC_ALLOW_MODESET, nullptr);
++
++    if (ret != 0)
++    {
++        BOOST_THROW_EXCEPTION(
++            std::system_error(-ret, std::system_category(), "Failed to commit atomic KMS configuration change"));
++    }
++
++    EGLAttrib const crtc_filter[] = {
++        EGL_DRM_PLANE_EXT, plane_id,
++        EGL_NONE};
++    int found_layers{0};
++    if (eglGetOutputLayersEXT(display, crtc_filter, &layer, 1, &found_layers) != EGL_TRUE)
++    {
++        BOOST_THROW_EXCEPTION((mg::egl_error("Failed to find EGLOutputEXT corresponding to DRM CRTC")));
++    }
++    if (found_layers != 1)
++    {
++        BOOST_THROW_EXCEPTION(std::runtime_error{"Failed to find EGLOutputEXT corresponding to DRM CRTC"});
++    }
++
++    using_saved_crtc = false;
++}
++
++EGLOutputLayerEXT mgek::EGLOutput::output_layer() const
++{
++    return layer;
++}
++
++void mgek::EGLOutput::clear_crtc()
++{
++    using namespace std::string_literals;
++    mgk::DRMModeCrtcUPtr crtc;
++    try
++    {
++        crtc = mgk::find_crtc_for_connector(drm_fd, connector);
++    }
++    catch (std::runtime_error const&)
++    {
++        /*
++         * In order to actually clear the output, we need to have a crtc
++         * connected to the output/connector so that we can disconnect
++         * it. However, not being able to get a crtc is OK, since it means
++         * that the output cannot be displaying anything anyway.
++         */
++        return;
++    }
++    auto const crtc_id = crtc->crtc_id;
++
++    auto result = drmModeSetCrtc(drm_fd, crtc_id,
++                                 0, 0, 0, nullptr, 0, nullptr);
++    if (result)
++    {
++        BOOST_THROW_EXCEPTION((
++            std::system_error{
++                -result,
++                std::system_category(),
++                "Couldn't clear output "s + mgk::connector_name(connector)}));
++    }
++}
++
++void mgek::EGLOutput::restore_saved_crtc()
++{
++    if (!using_saved_crtc)
++    {
++        auto result = drmModeSetCrtc(
++            drm_fd,
++            saved_crtc.crtc_id,
++            saved_crtc.buffer_id,
++            saved_crtc.x, saved_crtc.y,
++            &connector->connector_id,
++            1,
++            &saved_crtc.mode);
++
++        if (result != 0)
++        {
++            BOOST_THROW_EXCEPTION((std::system_error{-result, std::system_category(), "Failed to set CRTC"}));
++        }
++
++        using_saved_crtc = true;
++    }
++}
++
++void mgek::EGLOutput::set_power_mode(MirPowerMode mode)
++{
++    auto ret = drmModeConnectorSetProperty(
++        drm_fd,
++        connector->connector_id,
++        dpms_enum_id,
++        mode);
++    if (ret)
++    {
++        BOOST_THROW_EXCEPTION((std::system_error{-ret, std::system_category(), "Failed to set output power mode"}));
++    }
++}
 === added file 'src/platforms/eglstream-kms/server/egl_output.h'
 --- src/platforms/eglstream-kms/server/egl_output.h	1970-01-01 00:00:00 +0000
 +++ src/platforms/eglstream-kms/server/egl_output.h	2016-06-08 13:28:19 +0000
@@ -0,0 +1,79 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#ifndef MIR_GRAPHICS_EGLSTREAM_KMS_OUTPUT_H_
++#define MIR_GRAPHICS_EGLSTREAM_KMS_OUTPUT_H_
++
++#include "kms-utils/drm_mode_resources.h"
++#include "mir/geometry/size.h"
++#include "mir/geometry/point.h"
++#include "mir/geometry/displacement.h"
++#include "mir/graphics/display_configuration.h"
++#include "mir_toolkit/common.h"
++
++#include <epoxy/egl.h>
++
++namespace mir
++{
++namespace graphics
++{
++namespace eglstream
++{
++
++namespace kms
++{
++class EGLOutput : public DisplayConfigurationOutput
++{
++public:
++    EGLOutput(int drm_fd, EGLDisplay dpy, EGLOutputPortEXT connector);
++    ~EGLOutput() noexcept(false);
++
++    void reset();
++    void configure(size_t kms_mode_index);
++    geometry::Size size() const;
++    int max_refresh_rate() const;
++
++    EGLOutputLayerEXT output_layer() const;
++    void clear_crtc();
++
++    void set_power_mode(MirPowerMode mode);
++
++private:
++    void restore_saved_crtc();
++
++    int const drm_fd;
++
++    EGLDisplay display;
++    EGLOutputPortEXT port;
++    EGLOutputLayerEXT layer;
++
++    graphics::kms::DRMModeConnectorUPtr connector;
++
++    size_t mode_index;
++    drmModeCrtc saved_crtc;
++    bool using_saved_crtc;
++
++    int dpms_enum_id;
++};
++
++}
++}
++}
++}
++
++#endif /* MIR_GRAPHICS_EGLSTREAM_KMS_KMS_OUTPUT_H_ */
 === added file 'src/platforms/eglstream-kms/server/kms_display_configuration.cpp'
 --- src/platforms/eglstream-kms/server/kms_display_configuration.cpp	1970-01-01 00:00:00 +0000
 +++ src/platforms/eglstream-kms/server/kms_display_configuration.cpp	2016-06-08 13:28:19 +0000
@@ -0,0 +1,331 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program. If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#include <epoxy/egl.h>
++
++#include "kms_display_configuration.h"
++#include "kms-utils/drm_mode_resources.h"
++#include "mir/graphics/pixel_format_utils.h"
++#include "mir/graphics/egl_error.h"
++
++#include <cmath>
++#include <limits>
++
++#include <boost/throw_exception.hpp>
++#include <stdexcept>
++#include <algorithm>
++
++namespace mg = mir::graphics;
++namespace mge = mir::graphics::eglstream;
++namespace mgk = mir::graphics::kms;
++
++namespace geom = mir::geometry;
++
++namespace
++{
++
++bool kms_modes_are_equal(drmModeModeInfo const& info1, drmModeModeInfo const& info2)
++{
++    return (info1.clock == info2.clock &&
++            info1.hdisplay == info2.hdisplay &&
++            info1.hsync_start == info2.hsync_start &&
++            info1.hsync_end == info2.hsync_end &&
++            info1.htotal == info2.htotal &&
++            info1.hskew == info2.hskew &&
++            info1.vdisplay == info2.vdisplay &&
++            info1.vsync_start == info2.vsync_start &&
++            info1.vsync_end == info2.vsync_end &&
++            info1.vtotal == info2.vtotal);
++}
++
++double calculate_vrefresh_hz(drmModeModeInfo const& mode)
++{
++    if (mode.htotal == 0 || mode.vtotal == 0)
++        return 0.0;
++
++    /* mode.clock is in KHz */
++    double hz = (mode.clock * 100000LL /
++                 ((long)mode.htotal * (long)mode.vtotal)
++                ) / 100.0;
++
++    // Actually we don't need floating point at all for this...
++    // TODO: Consider converting our structs to fixed-point ints
++    return hz;
++}
++
++mg::DisplayConfigurationOutputType
++kms_connector_type_to_output_type(uint32_t connector_type)
++{
++    return static_cast<mg::DisplayConfigurationOutputType>(connector_type);
++}
++
++std::vector<std::shared_ptr<mge::kms::EGLOutput>> create_outputs(int drm_fd, EGLDisplay display)
++{
++    mgk::DRMModeResources resources{drm_fd};
++
++    std::vector<std::shared_ptr<mge::kms::EGLOutput>> outputs;
++
++    for (auto const& connector : resources.connectors())
++    {
++        EGLOutputPortEXT port;
++        int num_ports;
++        EGLAttrib const select_connector[] = {
++            EGL_DRM_CONNECTOR_EXT, connector->connector_id,
++            EGL_NONE
++        };
++        if (eglGetOutputPortsEXT(display, select_connector, &port, 1, &num_ports) != EGL_TRUE)
++        {
++            BOOST_THROW_EXCEPTION(mg::egl_error("Failed to find EGLOutputPort corresponding to DRM connector"));
++        }
++        if (num_ports != 1)
++        {
++            BOOST_THROW_EXCEPTION(std::runtime_error("Failed to find EGLOutputPort corresponding to DRM connector"));
++        }
++        outputs.push_back(std::make_shared<mge::kms::EGLOutput>(drm_fd, display, port));
++        auto& output = outputs.back();
++
++        // TODO: This should all be owned by mgek::EGLOutput
++
++        output->id = mg::DisplayConfigurationOutputId{static_cast<int>(connector->connector_id)};
++        output->card_id = mg::DisplayConfigurationCardId{0};
++        output->type = kms_connector_type_to_output_type(connector->connector_type);
++        output->physical_size_mm = geom::Size{connector->mmWidth, connector->mmHeight};
++        output->connected = connector->connection == DRM_MODE_CONNECTED;
++        output->pixel_formats = {
++            mir_pixel_format_argb_8888,
++            mir_pixel_format_xrgb_8888
++        };
++
++        uint32_t const invalid_mode_index = std::numeric_limits<uint32_t>::max();
++        output->current_mode_index = invalid_mode_index;
++        output->preferred_mode_index = invalid_mode_index;
++
++        /* Get information about the current mode */
++        mgk::DRMModeCrtcUPtr current_crtc;
++        if (connector->encoder_id)
++        {
++            auto encoder = mgk::get_encoder(drm_fd, connector->encoder_id);
++            if (encoder->crtc_id)
++            {
++                current_crtc = mgk::get_crtc(drm_fd, encoder->crtc_id);
++            }
++        }
++
++         /* Add all the available modes and find the current and preferred one */
++         for (int m = 0; m < connector->count_modes; m++)
++         {
++             drmModeModeInfo &mode_info = connector->modes[m];
++
++             geom::Size size{mode_info.hdisplay, mode_info.vdisplay};
++
++             double vrefresh_hz = calculate_vrefresh_hz(mode_info);
++
++             output->modes.push_back({size, vrefresh_hz});
++
++             if (current_crtc && kms_modes_are_equal(mode_info, current_crtc->mode))
++                 output->current_mode_index = m;
++
++             if ((mode_info.type & DRM_MODE_TYPE_PREFERRED) == DRM_MODE_TYPE_PREFERRED)
++                 output->preferred_mode_index = m;
++         }
++
++
++        output->current_format = mir_pixel_format_xrgb_8888;
++        output->power_mode = mir_power_mode_on;
++        output->orientation = mir_orientation_normal;
++        output->scale = 1.0f;
++        output->form_factor = mir_form_factor_monitor;
++        output->used = false;
++    }
++
++    return outputs;
++}
++
++mg::DisplayConfigurationCard create_card(int drm_fd)
++{
++    mgk::DRMModeResources resources{drm_fd};
++
++    size_t max_outputs = std::min(resources.num_crtcs(), resources.num_connectors());
++    return {mg::DisplayConfigurationCardId{0}, max_outputs};
++}
++
++}
++
++mge::KMSDisplayConfiguration::KMSDisplayConfiguration(int drm_fd, EGLDisplay dpy)
++    : drm_fd{drm_fd},
++      card{create_card(drm_fd)},
++      outputs{create_outputs(drm_fd, dpy)}
++{
++    update();
++}
++
++mge::KMSDisplayConfiguration::KMSDisplayConfiguration(
++    KMSDisplayConfiguration const& conf)
++    : mg::DisplayConfiguration(),
++      drm_fd{conf.drm_fd},
++      card(conf.card),
++      outputs{conf.outputs}
++{
++}
++
++void mge::KMSDisplayConfiguration::for_each_card(
++    std::function<void(DisplayConfigurationCard const&)> f) const
++{
++    f(card);
++}
++
++void mge::KMSDisplayConfiguration::for_each_output(
++    std::function<void(DisplayConfigurationOutput const&)> f) const
++{
++    for (auto const& output : outputs)
++        f(*output);
++}
++
++void mge::KMSDisplayConfiguration::for_each_output(
++    std::function<void(UserDisplayConfigurationOutput&)> f)
++{
++    for (auto& output : outputs)
++    {
++        UserDisplayConfigurationOutput user(*output);
++        f(user);
++    }
++}
++
++std::unique_ptr<mg::DisplayConfiguration> mge::KMSDisplayConfiguration::clone() const
++{
++    return std::make_unique<KMSDisplayConfiguration>(*this);
++}
++
++uint32_t mge::KMSDisplayConfiguration::get_kms_connector_id(
++    DisplayConfigurationOutputId id) const
++{
++    auto iter = find_output_with_id(id);
++
++    if (iter == outputs.end())
++    {
++        BOOST_THROW_EXCEPTION(
++            std::out_of_range("Failed to find DisplayConfigurationOutput with provided id"));
++    }
++
++    return id.as_value();
++}
++
++size_t mge::KMSDisplayConfiguration::get_kms_mode_index(
++    DisplayConfigurationOutputId id,
++    size_t conf_mode_index) const
++{
++    auto iter = find_output_with_id(id);
++
++    if (iter == outputs.end() || conf_mode_index >= (*iter)->modes.size())
++    {
++        BOOST_THROW_EXCEPTION(
++            std::out_of_range("Failed to find valid mode index for DisplayConfigurationOutput with provided id/mode_index"));
++    }
++
++    return conf_mode_index;
++}
++void mge::KMSDisplayConfiguration::update()
++{
++    mgk::DRMModeResources resources{drm_fd};
++
++    for (auto const& connector : resources.connectors())
++    {
++        update_output(resources, connector, **find_output_with_id(DisplayConfigurationOutputId(connector->connector_id)));
++    };
++}
++
++void mge::KMSDisplayConfiguration::for_each_output(
++    std::function<void(kms::EGLOutput const&)> const& f) const
++{
++    for (auto const& output : outputs)
++    {
++        f(*output);
++    }
++}
++
++void mge::KMSDisplayConfiguration::update_output(
++    mgk::DRMModeResources const& resources,
++    mgk::DRMModeConnectorUPtr const& connector,
++    kms::EGLOutput& output)
++{
++    output.physical_size_mm = geom::Size{connector->mmWidth, connector->mmHeight};
++    output.connected = connector->connection == DRM_MODE_CONNECTED;
++
++    uint32_t const invalid_mode_index = std::numeric_limits<uint32_t>::max();
++
++    output.modes.clear();
++    output.current_mode_index = invalid_mode_index;
++
++    drmModeModeInfo* current_mode_info{nullptr};
++    mgk::DRMModeCrtcUPtr current_crtc;
++    if (connector->encoder_id)
++    {
++        auto encoder = resources.encoder(connector->encoder_id);
++        if (encoder->crtc_id)
++        {
++            current_crtc = resources.crtc(encoder->crtc_id);
++            current_mode_info = &current_crtc->mode;
++        }
++    }
++
++    /* Add all the available modes and find the current and preferred one */
++    for (int m = 0; m < connector->count_modes; m++)
++    {
++        drmModeModeInfo& mode_info = connector->modes[m];
++
++        geom::Size size{mode_info.hdisplay, mode_info.vdisplay};
++
++        double vrefresh_hz = calculate_vrefresh_hz(mode_info);
++
++        output.modes.push_back({size, vrefresh_hz});
++
++        if (current_mode_info && kms_modes_are_equal(mode_info, *current_mode_info))
++            output.current_mode_index = m;
++
++        if ((mode_info.type & DRM_MODE_TYPE_PREFERRED) == DRM_MODE_TYPE_PREFERRED)
++            output.preferred_mode_index = m;
++    }
++
++    if (output.modes.empty())
++    {
++        output.preferred_mode_index = invalid_mode_index;
++    }
++    output.physical_size_mm = geom::Size{connector->mmWidth, connector->mmHeight};
++}
++
++std::vector<std::shared_ptr<mge::kms::EGLOutput>>::iterator
++mge::KMSDisplayConfiguration::find_output_with_id(mg::DisplayConfigurationOutputId id)
++{
++    return std::find_if(
++        outputs.begin(), outputs.end(),
++        [id](std::shared_ptr<DisplayConfigurationOutput> const& output)
++        {
++            return output->id == id;
++        });
++}
++
++std::vector<std::shared_ptr<mge::kms::EGLOutput>>::const_iterator
++mge::KMSDisplayConfiguration::find_output_with_id(mg::DisplayConfigurationOutputId id) const
++{
++    return std::find_if(
++        outputs.begin(), outputs.end(),
++        [id](std::shared_ptr<DisplayConfigurationOutput> const& output)
++        {
++            return output->id == id;
++        });
++}
 === added file 'src/platforms/eglstream-kms/server/kms_display_configuration.h'
 --- src/platforms/eglstream-kms/server/kms_display_configuration.h	1970-01-01 00:00:00 +0000
 +++ src/platforms/eglstream-kms/server/kms_display_configuration.h	2016-06-08 13:28:19 +0000
@@ -0,0 +1,70 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program. If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#ifndef MIR_PLATFORMS_EGLSTREAM_KMS_KMS_DISPLAY_CONFIGURATION_H_
++#define MIR_PLATFORMS_EGLSTREAM_KMS_KMS_DISPLAY_CONFIGURATION_H_
++
++#include "egl_output.h"
++
++#include "mir/graphics/display_configuration.h"
++
++
++#include <xf86drmMode.h>
++
++namespace mir
++{
++namespace graphics
++{
++namespace eglstream
++{
++
++class KMSDisplayConfiguration : public DisplayConfiguration
++{
++public:
++    KMSDisplayConfiguration(int drm_fd, EGLDisplay dpy);
++    KMSDisplayConfiguration(KMSDisplayConfiguration const& conf);
++
++    void for_each_card(std::function<void(DisplayConfigurationCard const&)> f) const override;
++    void for_each_output(std::function<void(DisplayConfigurationOutput const&)> f) const override;
++    void for_each_output(std::function<void(UserDisplayConfigurationOutput&)> f) override;
++    std::unique_ptr<DisplayConfiguration> clone() const override;
++
++    uint32_t get_kms_connector_id(DisplayConfigurationOutputId id) const;
++    size_t get_kms_mode_index(DisplayConfigurationOutputId id, size_t conf_mode_index) const;
++    void update();
++
++    void for_each_output(std::function<void(kms::EGLOutput const&)> const& f) const;
++
++private:
++    void update_output(
++        graphics::kms::DRMModeResources const& resources,
++        graphics::kms::DRMModeConnectorUPtr const& connector,
++        kms::EGLOutput& output);
++    std::vector<std::shared_ptr<kms::EGLOutput>>::iterator find_output_with_id(DisplayConfigurationOutputId id);
++    std::vector<std::shared_ptr<kms::EGLOutput>>::const_iterator find_output_with_id(DisplayConfigurationOutputId id) const;
++
++    int drm_fd;
++    DisplayConfigurationCard const card;
++    std::vector<std::shared_ptr<kms::EGLOutput>> outputs;
++};
++
++}
++}
++}
++
++#endif // MIR_PLATFORMS_EGLSTREAM_KMS_KMS_DISPLAY_CONFIGURATION_H_
 === added file 'src/platforms/eglstream-kms/server/platform.cpp'
 --- src/platforms/eglstream-kms/server/platform.cpp	1970-01-01 00:00:00 +0000
 +++ src/platforms/eglstream-kms/server/platform.cpp	2016-06-08 13:28:19 +0000
@@ -0,0 +1,162 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#include <epoxy/egl.h>
++
++#include "platform.h"
++#include "buffer_allocator.h"
++#include "display.h"
++#include "mir/graphics/platform_ipc_operations.h"
++#include "mir/graphics/platform_ipc_package.h"
++#include "mir/graphics/platform_operation_message.h"
++#include "mir/graphics/buffer_ipc_message.h"
++
++#include "mir/graphics/egl_error.h"
++
++#include <boost/throw_exception.hpp>
++#include <xf86drm.h>
++#include <fcntl.h>
++
++namespace mg = mir::graphics;
++namespace mge = mir::graphics::eglstream;
++
++namespace
++{
++// Our copy of eglext.h doesn't have this?
++int const EGL_DRM_MASTER_FD_EXT{0x333C};
++
++char const* drm_node_for_device(EGLDeviceEXT device)
++{
++    auto const device_path = eglQueryDeviceStringEXT(device, EGL_DRM_DEVICE_FILE_EXT);
++    if (!device_path)
++    {
++        BOOST_THROW_EXCEPTION(mg::egl_error("Failed to determine DRM device node path from EGLDevice"));
++    }
++    return device_path;
++}
++}
++
++mge::Platform::Platform(
++    EGLDeviceEXT device,
++    std::shared_ptr<EmergencyCleanupRegistry> const& /*emergency_cleanup_registry*/,
++    std::shared_ptr<DisplayReport> const& /*report*/)
++    : device{device},
++      display{EGL_NO_DISPLAY},
++      drm_node{open(drm_node_for_device(device), O_RDWR | O_CLOEXEC)}
++{
++    using namespace std::literals;
++
++    if (drm_node == mir::Fd::invalid)
++    {
++        BOOST_THROW_EXCEPTION(std::system_error(
++            errno,
++            std::system_category(),
++            "Failed to open DRM device "s + drm_node_for_device(device)));
++    }
++
++    if (drmSetMaster(drm_node))
++    {
++        BOOST_THROW_EXCEPTION((std::system_error{errno, std::system_category(), "Failed to acquire DRM master"}));
++    }
++
++    int const drm_node_attrib[] = {
++        EGL_DRM_MASTER_FD_EXT, static_cast<int>(drm_node), EGL_NONE
++    };
++    display = eglGetPlatformDisplayEXT(EGL_PLATFORM_DEVICE_EXT, device, drm_node_attrib);
++
++    if (display == EGL_NO_DISPLAY)
++    {
++        BOOST_THROW_EXCEPTION(mg::egl_error("Failed to create EGLDisplay on the EGLDeviceEXT"));
++    }
++
++    EGLint major{1};
++    EGLint minor{4};
++    if (eglInitialize(display, &major, &minor) != EGL_TRUE)
++    {
++        BOOST_THROW_EXCEPTION(mg::egl_error("Failed to initialise EGL"));
++    }
++    if (major != 1 || minor != 4)
++    {
++        BOOST_THROW_EXCEPTION((std::runtime_error{
++            "Incompatible EGL version"s +
++            "Wanted 1.4, got " + std::to_string(major) + "." + std::to_string(minor)}));
++    }
++}
++
++mir::UniqueModulePtr<mg::GraphicBufferAllocator> mge::Platform::create_buffer_allocator()
++{
++    return mir::make_module_ptr<mge::BufferAllocator>();
++}
++
++mir::UniqueModulePtr<mg::Display> mge::Platform::create_display(
++    std::shared_ptr<DisplayConfigurationPolicy> const& configuration_policy,
++    std::shared_ptr<GLConfig> const& gl_config)
++{
++    return mir::make_module_ptr<mge::Display>(drm_node, display, configuration_policy, *gl_config);
++}
++
++mir::UniqueModulePtr<mg::PlatformIpcOperations> mge::Platform::make_ipc_operations() const
++{
++    class NoIPCOperations : public mg::PlatformIpcOperations
++    {
++
++    public:
++        void pack_buffer(BufferIpcMessage& packer, Buffer const& buffer, BufferIpcMsgType msg_type) const override
++        {
++            if (msg_type == mg::BufferIpcMsgType::full_msg)
++            {
++                auto native_handle = buffer.native_buffer_handle();
++                for(auto i=0; i<native_handle->data_items; i++)
++                {
++                    packer.pack_data(native_handle->data[i]);
++                }
++                for(auto i=0; i<native_handle->fd_items; i++)
++                {
++                    packer.pack_fd(mir::Fd(IntOwnedFd{native_handle->fd[i]}));
++                }
++
++                packer.pack_stride(buffer.stride());
++                packer.pack_flags(native_handle->flags);
++                packer.pack_size(buffer.size());
++            }
++        }
++
++        void unpack_buffer(BufferIpcMessage& /*message*/, Buffer const& /*buffer*/) const override
++        {
++
++        }
++
++        std::shared_ptr<mg::PlatformIPCPackage> connection_ipc_package() override
++        {
++            return std::make_shared<mg::PlatformIPCPackage>(describe_graphics_module());
++        }
++
++        PlatformOperationMessage platform_operation(unsigned int const /*opcode*/,
++            PlatformOperationMessage const& /*message*/) override
++        {
++            BOOST_THROW_EXCEPTION(std::runtime_error{"No platform operations implemented"});
++        }
++    };
++
++    return mir::make_module_ptr<NoIPCOperations>();
++}
++
++EGLNativeDisplayType mge::Platform::egl_native_display() const
++{
++    return display;
++}
 === added file 'src/platforms/eglstream-kms/server/platform.h'
 --- src/platforms/eglstream-kms/server/platform.h	1970-01-01 00:00:00 +0000
 +++ src/platforms/eglstream-kms/server/platform.h	2016-06-08 13:28:19 +0000
@@ -0,0 +1,66 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#ifndef MIR_PLATFORMS_EGLSTREAM_KMS_PLATFORM_H_
++#define MIR_PLATFORMS_EGLSTREAM_KMS_PLATFORM_H_
++
++#include "mir/graphics/platform.h"
++#include "mir/options/option.h"
++#include "mir/graphics/graphic_buffer_allocator.h"
++#include "mir/graphics/display.h"
++#include "mir/graphics/platform_ipc_operations.h"
++#include "mir/fd.h"
++
++#include <EGL/egl.h>
++#include <EGL/eglext.h>
++
++namespace mir
++{
++namespace graphics
++{
++namespace eglstream
++{
++class Platform : public mir::graphics::Platform
++{
++public:
++    Platform(
++        EGLDeviceEXT device,
++        std::shared_ptr<EmergencyCleanupRegistry> const& /*emergency_cleanup_registry*/,
++        std::shared_ptr<DisplayReport> const& /*report*/);
++    ~Platform() = default;
++
++    UniqueModulePtr<GraphicBufferAllocator> create_buffer_allocator() override;
++
++    UniqueModulePtr<Display> create_display(
++        std::shared_ptr<DisplayConfigurationPolicy> const& /*initial_conf_policy*/,
++        std::shared_ptr<GLConfig> const& /*gl_config*/) override;
++
++    UniqueModulePtr<PlatformIpcOperations> make_ipc_operations() const override;
++
++    EGLNativeDisplayType egl_native_display() const override;
++
++private:
++    EGLDeviceEXT device;
++    EGLDisplay display;
++    mir::Fd const drm_node;
++};
++}
++}
++}
++
++#endif // MIR_PLATFORMS_EGLSTREAM_KMS_PLATFORM_H_
 === added file 'src/platforms/eglstream-kms/server/platform_symbols.cpp'
 --- src/platforms/eglstream-kms/server/platform_symbols.cpp	1970-01-01 00:00:00 +0000
 +++ src/platforms/eglstream-kms/server/platform_symbols.cpp	2016-06-08 13:28:19 +0000
@@ -0,0 +1,189 @@
++/*
++ * Copyright © 2016 Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License version 3,
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
++ */
++
++#include <epoxy/egl.h>
++
++#include "platform.h"
++#include "mir/graphics/platform.h"
++#include "mir/options/option.h"
++#include "mir/module_deleter.h"
++#include "mir/assert_module_entry_point.h"
++#include "mir/libname.h"
++#include "mir/log.h"
++#include "mir/graphics/egl_error.h"
++
++#include <boost/throw_exception.hpp>
++#include <boost/exception/diagnostic_information.hpp>
++#include <xf86drm.h>
++#include <sstream>
++
++#include <fcntl.h>
++
++namespace mg = mir::graphics;
++namespace mo = mir::options;
++namespace mge = mir::graphics::eglstream;
++
++mir::UniqueModulePtr<mg::Platform> create_host_platform(
++    std::shared_ptr<mo::Option> const& /*options*/,
++    std::shared_ptr<mir::EmergencyCleanupRegistry> const& emergency_cleanup_registry,
++    std::shared_ptr<mg::DisplayReport> const& report)
++{
++    mir::assert_entry_point_signature<mg::CreateHostPlatform>(&create_host_platform);
++
++    int device_count{0};
++    if (eglQueryDevicesEXT(0, nullptr, &device_count) != EGL_TRUE)
++    {
++        BOOST_THROW_EXCEPTION(mg::egl_error("Failed to query device count with eglQueryDevicesEXT"));
++    }
++
++    auto devices = std::make_unique<EGLDeviceEXT[]>(device_count);
++    if (eglQueryDevicesEXT(device_count, devices.get(), &device_count) != EGL_TRUE)
++    {
++        BOOST_THROW_EXCEPTION(mg::egl_error("Failed to get device list with eglQueryDevicesEXT"));
++    }
++
++    auto device = std::find_if(devices.get(), devices.get() + device_count,
++        [](EGLDeviceEXT device)
++        {
++            auto device_extensions = eglQueryDeviceStringEXT(device, EGL_EXTENSIONS);
++            if (device_extensions)
++            {
++                return strstr(device_extensions, "EGL_EXT_device_drm") != NULL;
++            }
++            return false;
++        });
++
++    if (device == (devices.get() + device_count))
++    {
++        BOOST_THROW_EXCEPTION(std::runtime_error("Couldn't find EGLDeviceEXT supporting EGL_EXT_device_drm?"));
++    }
++
++    return mir::make_module_ptr<mge::Platform>(*device, emergency_cleanup_registry, report);
++}
++
++void add_graphics_platform_options(boost::program_options::options_description& /*config*/)
++{
++    mir::assert_entry_point_signature<mg::AddPlatformOptions>(&add_graphics_platform_options);
++}
++
++mg::PlatformPriority probe_graphics_platform(mo::ProgramOption const& /*options*/)
++{
++    mir::assert_entry_point_signature<mg::PlatformProbe>(&probe_graphics_platform);
++
++    std::vector<char const*> missing_extensions;
++    for (char const* extension : {
++        "EGL_EXT_platform_base",
++        "EGL_EXT_platform_device",
++        "EGL_EXT_device_base",})
++    {
++        if (!epoxy_has_egl_extension(EGL_NO_DISPLAY, extension))
++        {
++            missing_extensions.push_back(extension);
++        }
++    }
++
++    if (!missing_extensions.empty())
++    {
++        std::stringstream message;
++        message << "Missing required extension" << (missing_extensions.size() > 1 ? "s:" : ":");
++        for (auto missing_extension : missing_extensions)
++        {
++            message << " " << missing_extension;
++        }
++
++        mir::log(
++            mir::logging::Severity::debug,
++            "platform-eglstream",
++            "EGLStream platform is unsupported: %s",
++            message.str().c_str());
++        return mg::PlatformPriority::unsupported;
++    }
++
++    int device_count{0};
++    if (eglQueryDevicesEXT(0, nullptr, &device_count) != EGL_TRUE)
++    {
++        mir::log(
++            mir::logging::Severity::informational,
++            "platform-eglstream",
++            "Platform claims to support EGL_EXT_device_base, but eglQueryDevicesEXT falied: %s",
++            mg::egl_category().message(eglGetError()).c_str());
++        return mg::PlatformPriority::unsupported;
++    }
++
++    auto devices = std::make_unique<EGLDeviceEXT[]>(device_count);
++    if (eglQueryDevicesEXT(device_count, devices.get(), &device_count) != EGL_TRUE)
++    {
++        BOOST_THROW_EXCEPTION(mg::egl_error("Failed to get device list with eglQueryDevicesEXT"));
++    }
++
++    if (std::none_of(devices.get(), devices.get() + device_count,
++        [](EGLDeviceEXT device)
++        {
++            auto device_extensions = eglQueryDeviceStringEXT(device, EGL_EXTENSIONS);
++            if (device_extensions)
++            {
++                mir::log(
++                    mir::logging::Severity::debug,
++                    "platform-eglstream",
++                    "Found EGLDeviceEXT with device extensions: %s", device_extensions);
++                return strstr(device_extensions, "EGL_EXT_device_drm") != NULL;
++            }
++            else
++            {
++                mir::log(
++                    mir::logging::Severity::debug,
++                    "platform-eglstream",
++                    "Found EGLDeviceEXT with no device extensions");
++                return false;
++            }
++        }))
++    {
++        mir::log(
++            mir::logging::Severity::debug,
++            "platform-eglstream",
++            "EGLDeviceEXTs found, but none support required EGL_EXT_device_drm extension");
++        return mg::PlatformPriority::unsupported;
++    }
++
++    return mg::PlatformPriority::best;
++}
++
++namespace
++{
++mir::ModuleProperties const description = {
++    "mir:eglstream-kms",
++    MIR_VERSION_MAJOR,
++    MIR_VERSION_MINOR,
++    MIR_VERSION_MICRO,
++    mir::libname()
++};
++}
++
++mir::ModuleProperties const* describe_graphics_module()
++{
++    mir::assert_entry_point_signature<mg::DescribeModule>(&describe_graphics_module);
++    return &description;
++}
++
++mir::UniqueModulePtr<mg::Platform> create_guest_platform(
++    std::shared_ptr<mg::DisplayReport> const&,
++    std::shared_ptr<mg::NestedContext> const& /*nested_context*/)
++{
++    mir::assert_entry_point_signature<mg::CreateGuestPlatform>(&create_guest_platform);
++    return nullptr;
++}
 === added file 'src/platforms/eglstream-kms/server/symbols.map.in'
 --- src/platforms/eglstream-kms/server/symbols.map.in	1970-01-01 00:00:00 +0000
 +++ src/platforms/eglstream-kms/server/symbols.map.in	2016-06-08 13:28:19 +0000
@@ -0,0 +1,10 @@
++@MIR_SERVER_GRAPHICS_PLATFORM_VERSION@ {
++  global:
++    add_graphics_platform_options;
++    create_host_platform;
++    create_guest_platform;
++    probe_graphics_platform;
++    describe_graphics_module;
++  local:
++    *;
++};
 === modified file 'src/platforms/mesa/server/kms/platform_symbols.cpp'
 --- src/platforms/mesa/server/kms/platform_symbols.cpp	2016-01-29 08:18:22 +0000
 +++ src/platforms/mesa/server/kms/platform_symbols.cpp	2016-06-08 13:28:19 +0000
@@ -26,6 +26,7 @@
  #include "mir/assert_module_entry_point.h"
  #include "mir/libname.h"
++#include <EGL/egl.h>
  #include <fcntl.h>
  #include <sys/ioctl.h>
@@ -162,6 +163,19 @@
      if (drm_devices.begin() == drm_devices.end())
          return mg::PlatformPriority::unsupported;
++    // We also require GBM EGL platform
++    auto const* client_extensions = eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
++    if (!client_extensions)
++    {
++        // Doesn't support EGL client extensions; Mesa does, so this is unlikely to be mesa.
++        return mg::PlatformPriority::unsupported;
++    }
++    if (strstr(client_extensions, "EGL_MESA_platform_gbm") == nullptr)
++    {
++        // No platform_gbm support, so we can't work.
++        return mg::PlatformPriority::unsupported;
++    }
++
      // Check for master
      int tmp_fd = -1;
      for (auto& device : drm_devices)
 === modified file 'tests/unit-tests/CMakeLists.txt'
 --- tests/unit-tests/CMakeLists.txt	2016-06-02 05:33:50 +0000
 +++ tests/unit-tests/CMakeLists.txt	2016-06-08 13:28:19 +0000
@@ -17,6 +17,10 @@
    add_definitions(-DMIR_BUILD_PLATFORM_MESA_X11)
  endif()
++if (MIR_BUILD_PLATFORM_EGLSTREAM_KMS)
++  add_definitions(-DMIR_BUILD_PLATFORM_EGLSTREAM_KMS)
++endif()
++
  include_directories(
    ${CMAKE_SOURCE_DIR}
 === modified file 'tests/unit-tests/client/test_probing_client_platform_factory.cpp'
 --- tests/unit-tests/client/test_probing_client_platform_factory.cpp	2016-05-27 00:47:04 +0000
 +++ tests/unit-tests/client/test_probing_client_platform_factory.cpp	2016-06-08 13:28:19 +0000
@@ -55,6 +55,13 @@
      memset(&pkg, 0, sizeof(pkg));
+ }
++#if defined(MIR_BUILD_PLATFORM_EGLSTREAM_KMS)
++void populate_valid_eglstream_platform_package(MirPlatformPackage& pkg)
++{
++    memset(&pkg, 0, sizeof(pkg));
++}
++#endif
++
  class ModuleContext
+ {
  public:
@@ -115,6 +122,11 @@
          std::make_pair<std::string, ModuleContext>(
              "android", { "android", "graphics-android", &populate_valid_android_platform_package }));
  #endif
++#if defined(MIR_BUILD_PLATFORM_EGLSTREAM_KMS)
++    modules.emplace(
++        std::make_pair<std::string, ModuleContext>(
++            "eglstream-kms", { "eglstream", "graphics-eglstream-kms", &populate_valid_eglstream_platform_package}));
++#endif
      return modules;
+ }
@@ -289,6 +301,26 @@
      EXPECT_EQ(mir_platform_type_gbm, platform->platform_type());
+ }
++#if defined(MIR_BUILD_PLATFORM_EGLSTREAM_KMS)
++TEST(ProbingClientPlatformFactory, CreatesEglstreamPlatformOnEglstreamKMS)
++#else
++TEST(ProbingClientPlatformFactory, DISABLED_CreatesEglstreamPlatformOnEglstreamKMS)
++#endif
++{
++    using namespace testing;
++
++    mir::client::ProbingClientPlatformFactory factory(
++        mir::report::null_shared_library_prober_report(),
++        all_available_modules(),
++        {});
++
++    NiceMock<mtd::MockClientContext> context;
++    all_available_fixtures().at("eglstream-kms").setup_context(context);
++
++    auto platform = factory.create_client_platform(&context);
++    EXPECT_EQ(mir_platform_type_eglstream, platform->platform_type());
++}
++
  #ifdef MIR_BUILD_PLATFORM_ANDROID
  TEST(ProbingClientPlatformFactory, CreatesAndroidPlatformWhenAppropriate)
  #else
 === modified file 'tests/unit-tests/graphics/mesa/kms/test_platform.cpp'
 --- tests/unit-tests/graphics/mesa/kms/test_platform.cpp	2016-01-29 08:18:22 +0000
 +++ tests/unit-tests/graphics/mesa/kms/test_platform.cpp	2016-06-08 13:28:19 +0000
@@ -40,6 +40,7 @@
  #include "mir/test/doubles/mock_drm.h"
  #include "mir/test/doubles/mock_gbm.h"
++#include "mir/test/doubles/mock_egl.h"
  #include "mir/test/doubles/fd_matcher.h"
  #include <gtest/gtest.h>
@@ -65,8 +66,11 @@
  public:
      void SetUp()
+     {
--        ::testing::Mock::VerifyAndClearExpectations(&mock_drm);
--        ::testing::Mock::VerifyAndClearExpectations(&mock_gbm);
++        using namespace testing;
++        Mock::VerifyAndClearExpectations(&mock_drm);
++        Mock::VerifyAndClearExpectations(&mock_gbm);
++        ON_CALL(mock_egl, eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS))
++            .WillByDefault(Return("EGL_AN_extension_string EGL_MESA_platform_gbm"));
          fake_devices.add_standard_device("standard-drm-devices");
+     }
@@ -81,6 +85,7 @@
      ::testing::NiceMock<mtd::MockDRM> mock_drm;
      ::testing::NiceMock<mtd::MockGBM> mock_gbm;
++    ::testing::NiceMock<mtd::MockEGL> mock_egl;
      mtf::UdevEnvironment fake_devices;
  };
+ }
@@ -366,3 +371,43 @@
      auto probe = platform_lib.load_function<mg::PlatformProbe>(probe_platform);
      EXPECT_EQ(mg::PlatformPriority::best, probe(options));
+ }
++
++TEST_F(MesaGraphicsPlatform, probe_returns_unsupported_when_egl_client_extensions_not_supported)
++{
++    using namespace testing;
++
++    mtf::UdevEnvironment udev_environment;
++    boost::program_options::options_description po;
++    mir::options::ProgramOption options;
++    const char *argv[] = {"dummy", "--vt"};
++    options.parse_arguments(po, 2, argv);
++
++    udev_environment.add_standard_device("standard-drm-devices");
++
++    ON_CALL(mock_egl, eglQueryString(EGL_NO_DISPLAY, _))
++        .WillByDefault(Return(nullptr));
++
++    mir::SharedLibrary platform_lib{mtf::server_platform("graphics-mesa-kms")};
++    auto probe = platform_lib.load_function<mg::PlatformProbe>(probe_platform);
++    EXPECT_EQ(mg::PlatformPriority::unsupported, probe(options));
++}
++
++TEST_F(MesaGraphicsPlatform, probe_returns_unsupported_when_gbm_platform_not_supported)
++{
++    using namespace testing;
++
++    mtf::UdevEnvironment udev_environment;
++    boost::program_options::options_description po;
++    mir::options::ProgramOption options;
++    const char *argv[] = {"dummy", "--vt"};
++    options.parse_arguments(po, 2, argv);
++
++    udev_environment.add_standard_device("standard-drm-devices");
++
++    ON_CALL(mock_egl, eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS))
++        .WillByDefault(Return("EGL_KHR_not_really_an_extension EGL_EXT_master_of_the_house"));
++
++    mir::SharedLibrary platform_lib{mtf::server_platform("graphics-mesa-kms")};
++    auto probe = platform_lib.load_function<mg::PlatformProbe>(probe_platform);
++    EXPECT_EQ(mg::PlatformPriority::unsupported, probe(options));
++}
 === modified file 'tests/unit-tests/graphics/test_platform_prober.cpp'
 --- tests/unit-tests/graphics/test_platform_prober.cpp	2016-05-27 03:32:07 +0000
 +++ tests/unit-tests/graphics/test_platform_prober.cpp	2016-06-08 13:28:19 +0000
@@ -27,6 +27,7 @@
  #ifdef MIR_BUILD_PLATFORM_MESA_KMS
  #include "mir/test/doubles/mock_drm.h"
  #include "mir/test/doubles/mock_gbm.h"
++#include "mir/test/doubles/mock_egl.h"
  #endif
  #ifdef MIR_BUILD_PLATFORM_ANDROID
@@ -81,11 +82,18 @@
  std::shared_ptr<void> ensure_mesa_probing_succeeds()
+ {
--    auto udev = std::make_shared<mtf::UdevEnvironment>();
--
--    udev->add_standard_device("standard-drm-devices");
--
--    return udev;
++    using namespace testing;
++    struct MockEnvironment {
++        mtf::UdevEnvironment udev;
++        mtd::MockEGL egl;
++    };
++    auto env = std::make_shared<MockEnvironment>();
++
++    env->udev.add_standard_device("standard-drm-devices");
++    ON_CALL(env->egl, eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS))
++        .WillByDefault(Return("EGL_MESA_platform_gbm"));
++
++    return env;
+ }
  std::shared_ptr<void> ensure_android_probing_succeeds()
@@ -236,7 +244,7 @@
      auto descriptor = module->load_function<mir::graphics::DescribeModule>(describe_module);
      auto description = descriptor();
--    EXPECT_THAT(description->name, Not(HasSubstr("dummy")));
++    EXPECT_THAT(description->name, Not(HasSubstr("mir:stub-graphics")));
+ }
  #endif