Initial Atomic KMS platform

CMakeLists.txt

@@ -161,18 +161,18 @@ pkg_check_modules(WAYLAND_EGLSTREAM wayland-eglstream IMPORTED_TARGET)
 if (WAYLAND_EGLSTREAM_FOUND)
   set(
     MIR_PLATFORM
-    gbm-kms;x11;eglstream-kms;wayland
+    gbm-kms;atomic-kms;x11;eglstream-kms;wayland
     CACHE
     STRING
-    "a list of graphics backends to build (options are 'gbm-kms', 'x11', 'eglstream-kms', or 'wayland')"
+    "a list of graphics backends to build (options are 'gbm-kms', 'atomic-kms', 'x11', 'eglstream-kms', or 'wayland')"
   )
 else()
   set(
     MIR_PLATFORM
-    gbm-kms;x11;wayland
+    gbm-kms;atomic-kms;x11;wayland
     CACHE
     STRING
-    "a list of graphics backends to build (options are 'gbm-kms', 'x11', 'eglstream-kms', or 'wayland')"
+    "a list of graphics backends to build (options are 'gbm-kms', 'atomic-kms', 'x11', 'eglstream-kms', or 'wayland')"
   )
 endif()
 
@@ -209,6 +209,9 @@ foreach(platform IN LISTS MIR_PLATFORM)
   if (platform STREQUAL "gbm-kms")
     set(MIR_BUILD_PLATFORM_GBM_KMS TRUE)
   endif()
+  if (platform STREQUAL "atomic-kms")
+    set(MIR_BUILD_PLATFORM_ATOMIC_KMS TRUE)
+  endif()
   if (platform STREQUAL "x11")
      set(MIR_BUILD_PLATFORM_X11 TRUE)
   endif()
@@ -263,7 +266,7 @@ if (HAVE_SYS_SDT_H)
   add_compile_definitions(LTTNG_UST_HAVE_SDT_INTEGRATION)
 endif()
 
-if (MIR_BUILD_PLATFORM_GBM_KMS)
+if (MIR_BUILD_PLATFORM_GBM_KMS OR MIR_BUILD_PLATFORM_ATOMIC_KMS)
   pkg_check_modules(GBM REQUIRED IMPORTED_TARGET gbm>=11.0.0)
 endif()
 

debian/control

@@ -297,6 +297,21 @@ Description: Display server for Ubuntu - platform library for X11
  Contains the shared libraries required for the Mir server to interact with
  the X11 platform.
 
+Package: mir-platform-graphics-atomic-kms22
+Section: libs
+Architecture: linux-any
+Multi-Arch: same
+Pre-Depends: ${misc:Pre-Depends}
+Depends: mir-platform-graphics-gbm-kms22,
+         ${misc:Depends},
+         ${shlibs:Depends},
+Description: Display server for Ubuntu - platform library for Atomic KMS
+ Mir is a display server running on linux systems, with a focus on efficiency,
+ robust operation and a well-defined driver model.
+ .
+ Contains the shared libraries required for the Mir server to interact with
+ the hardware platform using the Mesa drivers and Atomic KMS API.
+
 Package: mir-platform-graphics-gbm-kms22
 Section: libs
 Architecture: linux-any
@@ -404,6 +419,7 @@ Architecture: linux-any
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends}
 Depends: ${misc:Depends},
+         mir-platform-graphics-atomic-kms,
          mir-platform-graphics-gbm-kms,
          mir-platform-graphics-x,
          mir-platform-graphics-wayland,
@@ -416,6 +432,22 @@ Description: Display server for Ubuntu - desktop driver metapackage
  This package depends on a full set of graphics and input drivers for traditional desktop
  systems.
 
+Package: mir-platform-graphics-atomic-kms
+Section: libs
+Architecture: linux-any
+Multi-Arch: same
+Pre-Depends: ${misc:Pre-Depends}
+Depends: ${misc:Depends},
+         mir-platform-graphics-atomic-kms22,
+         mir-platform-input-evdev10,
+         mir-platform-rendering-egl-generic,
+Description: Display server for Ubuntu - gbm-kms driver metapackage
+ Mir is a display server running on linux systems, with a focus on efficiency,
+ robust operation and a well-defined driver model.
+ .
+ This package depends on a full set of graphics and input drivers for atomic-kms
+ systems.
+
 Package: mir-platform-graphics-gbm-kms
 Section: libs
 Architecture: linux-any

debian/mir-platform-graphics-atomic-kms22.install

@@ -0,0 +1 @@
+usr/lib/*/mir/server-platform/graphics-atomic-kms.so.22

debian/rules

@@ -65,7 +65,7 @@ export DEB_BUILD_MAINT_OPTIONS
 $(info COMMON_CONFIGURE_OPTIONS: ${COMMON_CONFIGURE_OPTIONS})
 $(info DEB_BUILD_MAINT_OPTIONS: ${DEB_BUILD_MAINT_OPTIONS})
 
-AVAILABLE_PLATFORMS=gbm-kms\;x11\;wayland\;eglstream-kms
+AVAILABLE_PLATFORMS=atomic-kms\;gbm-kms\;x11\;wayland\;eglstream-kms
 
 override_dh_auto_configure:
 ifneq ($(filter armhf,$(DEB_HOST_ARCH)),)

snap/snapcraft.yaml

@@ -18,7 +18,7 @@ parts:
     cmake-parameters:
     - -DCMAKE_INSTALL_PREFIX=/usr
     - -DMIR_ENABLE_WLCS_TESTS=OFF
-    - -DMIR_PLATFORM='gbm-kms;eglstream-kms;x11;wayland'
+    - -DMIR_PLATFORM='atomic-kms;gbm-kms;eglstream-kms;x11;wayland'
     build-packages:
     - build-essential
     - eglexternalplatform-dev

src/platforms/CMakeLists.txt

@@ -49,6 +49,10 @@ if (MIR_BUILD_PLATFORM_GBM_KMS)
     add_subdirectory(gbm-kms/)
 endif()
 
+if (MIR_BUILD_PLATFORM_ATOMIC_KMS)
+    add_subdirectory(atomic-kms/)
+endif()
+
 if (MIR_BUILD_PLATFORM_X11)
     add_subdirectory(x11/)
 endif()

src/platforms/atomic-kms/CMakeLists.txt

@@ -0,0 +1,2 @@
+add_definitions(-DMIR_LOG_COMPONENT_FALLBACK="atomic-kms")
+add_subdirectory(server/)

src/platforms/atomic-kms/server/CMakeLists.txt

@@ -0,0 +1,24 @@
+add_subdirectory(kms/)
+
+add_library(
+  mirsharedatomickmscommon-static STATIC
+
+  display_helpers.cpp
+  gbm_display_allocator.h
+  gbm_display_allocator.cpp
+)
+
+target_include_directories(
+  mirsharedatomickmscommon-static
+  PUBLIC
+    ${server_common_include_dirs}
+    ${CMAKE_CURRENT_BINARY_DIR}
+)
+
+target_link_libraries(
+  mirsharedatomickmscommon-static
+
+  server_platform_common
+  kms_utils
+  mirplatform
+)

src/platforms/atomic-kms/server/display_helpers.cpp

@@ -0,0 +1,240 @@
+/*
+ * Copyright © 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 2 or 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/>.
+ */
+
+#include "display_helpers.h"
+#include "one_shot_device_observer.h"
+
+#include "kms-utils/drm_mode_resources.h"
+#include "mir/graphics/egl_error.h"
+#include "kms/quirks.h"
+
+#include "mir/udev/wrapper.h"
+#include "mir/console_services.h"
+
+#include <sys/sysmacros.h>
+
+#include "mir/log.h"
+
+#include <boost/exception/errinfo_errno.hpp>
+#include <boost/throw_exception.hpp>
+
+#include <cstring>
+#include <stdexcept>
+#include <xf86drm.h>
+#include <fcntl.h>
+#include <vector>
+#include <boost/exception/diagnostic_information.hpp>
+
+namespace mg = mir::graphics;
+namespace mga = mir::graphics::atomic;
+namespace mgc = mir::graphics::common;
+namespace mgmh = mir::graphics::atomic::helpers;
+
+/*************
+ * DRMHelper *
+ *************/
+
+std::vector<std::shared_ptr<mgmh::DRMHelper>>
+mgmh::DRMHelper::open_all_devices(
+    std::shared_ptr<mir::udev::Context> const& udev,
+    mir::ConsoleServices& console,
+    mga::Quirks const& quirks)
+{
+    int error = ENODEV; //Default error is "there are no DRM devices"
+
+    mir::udev::Enumerator devices(udev);
+    devices.match_subsystem("drm");
+    devices.match_sysname("card[0-9]");
+
+    devices.scan_devices();
+
+    std::vector<std::shared_ptr<DRMHelper>> opened_devices;
+
+    for(auto& device : devices)
+    {
+        if (quirks.should_skip(device))
+        {
+            mir::log_info("Ignoring device %s due to specified quirk", device.devnode());
+            continue;
+        }
+
+        mir::Fd tmp_fd;
+        std::unique_ptr<mir::Device> device_handle;
+        try
+        {
+            device_handle = console.acquire_device(
+                major(device.devnum()), minor(device.devnum()),
+                std::make_unique<mgc::OneShotDeviceObserver>(tmp_fd))
+                    .get();
+        }
+        catch (std::exception const& error)
+        {
+            mir::log_warning(
+                "Failed to open DRM device node %s: %s",
+                device.devnode(),
+                boost::diagnostic_information(error).c_str());
+            continue;
+        }
+
+        // Paranoia is always justified when dealing with hardware interfaces…
+        if (tmp_fd == mir::Fd::invalid)
+        {
+            mir::log_critical(
+                "Opening the DRM device %s succeeded, but provided an invalid descriptor!",
+                device.devnode());
+            mir::log_critical(
+                "This is probably a logic error in Mir, please report to https://github.com/MirServer/mir/issues");
+            continue;
+        }
+
+        // Check that the drm device is usable by setting the interface version we use (1.4)
+        drmSetVersion sv;
+        sv.drm_di_major = 1;
+        sv.drm_di_minor = 4;
+        sv.drm_dd_major = -1;     /* Don't care */
+        sv.drm_dd_minor = -1;     /* Don't care */
+
+        if ((error = -drmSetInterfaceVersion(tmp_fd, &sv)))
+        {
+            mir::log_warning(
+                "Failed to set DRM interface version on device %s: %i (%s)",
+                device.devnode(),
+                error,
+                strerror(error));
+            continue;
+        }
+
+        auto busid = std::unique_ptr<char, decltype(&drmFreeBusid)>{
+            drmGetBusid(tmp_fd), &drmFreeBusid
+        };
+
+        if (!busid)
+        {
+            mir::log_warning(
+                "Failed to query BusID for device %s; cannot check if KMS is available",
+                device.devnode());
+        }
+        else
+        {
+            switch (auto err = -drmCheckModesettingSupported(busid.get()))
+            {
+            case 0: break;
+
+            case ENOSYS:
+                if (quirks.require_modesetting_support(device))
+                {
+                    mir::log_info("Ignoring non-KMS DRM device %s", device.devnode());
+                    error = ENOSYS;
+                    continue;
+                }
+
+                [[fallthrough]];
+            case EINVAL:
+                mir::log_warning(
+                    "Failed to detect whether device %s supports KMS, but continuing anyway",
+                    device.devnode());
+                break;
+
+            default:
+                mir::log_warning("Unexpected error from drmCheckModesettingSupported(): %s (%i), but continuing anyway",
+                    strerror(err), err);
+                mir::log_warning("Please file a bug at https://github.com/MirServer/mir/issues containing this message");
+            }
+        }
+
+        // Can't use make_shared with the private constructor.
+        opened_devices.push_back(
+            std::shared_ptr<DRMHelper>{
+                new DRMHelper{
+                    std::move(tmp_fd),
+                    std::move(device_handle)}});
+        mir::log_info("Using DRM device %s", device.devnode());
+    }
+
+    if (opened_devices.size() == 0)
+    {
+        BOOST_THROW_EXCEPTION((
+            std::system_error{error, std::system_category(), "Error opening DRM device"}));
+    }
+
+    return opened_devices;
+}
+
+std::unique_ptr<mgmh::DRMHelper> mgmh::DRMHelper::open_any_render_node(
+    std::shared_ptr<mir::udev::Context> const& udev)
+{
+    mir::Fd tmp_fd;
+    int error = ENODEV; //Default error is "there are no DRM devices"
+
+    mir::udev::Enumerator devices(udev);
+    devices.match_subsystem("drm");
+    devices.match_sysname("renderD[0-9]*");
+
+    devices.scan_devices();
+
+    for(auto& device : devices)
+    {
+        // If directly opening the DRM device is good enough for X it's good enough for us!
+        tmp_fd = mir::Fd{open(device.devnode(), O_RDWR | O_CLOEXEC)};
+        if (tmp_fd < 0)
+        {
+            error = errno;
+            continue;
+        }
+
+        break;
+    }
+
+    if (tmp_fd < 0)
+    {
+        BOOST_THROW_EXCEPTION((
+            std::system_error{
+                    error,
+                    std::system_category(),
+                    "Error opening DRM device"}));
+    }
+
+    return std::unique_ptr<mgmh::DRMHelper>{
+        new mgmh::DRMHelper{std::move(tmp_fd), nullptr}};
+}
+
+mgmh::DRMHelper::DRMHelper(mir::Fd&& fd, std::unique_ptr<mir::Device> device)
+    : fd{std::move(fd)},
+      device_handle{std::move(device)}
+{
+}
+
+mgmh::DRMHelper::~DRMHelper()
+{
+}
+
+/*************
+ * GBMHelper *
+ *************/
+
+mgmh::GBMHelper::GBMHelper(mir::Fd const& drm_fd)
+    : device{gbm_create_device(drm_fd)}
+{
+    if (!device)
+        BOOST_THROW_EXCEPTION(
+            std::runtime_error("Failed to create GBM device"));
+}
+
+mgmh::GBMHelper::~GBMHelper()
+{
+    if (device)
+        gbm_device_destroy(device);
+}