drm: GPU process manages VGEM fd.

ui/ozone/platform/drm/host/drm_display_host_manager.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/ozone/platform/drm/host/drm_display_host_manager.h"
 
 #include <fcntl.h>
 #include <stdio.h>
 #include <xf86drm.h>
 
+#include "base/files/file_enumerator.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/worker_pool.h"
 #include "ui/events/ozone/device/device_event.h"
 #include "ui/events/ozone/device/device_manager.h"
 #include "ui/ozone/common/display_snapshot_proxy.h"
 #include "ui/ozone/common/display_util.h"
 #include "ui/ozone/common/gpu/ozone_gpu_messages.h"
 #include "ui/ozone/platform/drm/common/drm_util.h"
 #include "ui/ozone/platform/drm/host/drm_device_handle.h"
 #include "ui/ozone/platform/drm/host/drm_gpu_platform_support_host.h"
 #include "ui/ozone/platform/drm/host/drm_native_display_delegate.h"
 
 namespace ui {
 
 namespace {
 
 typedef base::Callback<void(const base::FilePath&, scoped_ptr<DrmDeviceHandle>)>
     OnOpenDeviceReplyCallback;
 
 const char kDefaultGraphicsCardPattern[] = "/dev/dri/card%d";
+const char kVgemDevDriCardPath[] = "/dev/dri/";
+const char kVgemSysCardPath[] = "/sys/bus/platform/devices/vgem/drm/";
 
 const char* kDisplayActionString[] = {
     "ADD",
     "REMOVE",
     "CHANGE",
 };
 
 void OpenDeviceOnWorkerThread(
     const base::FilePath& path,
+    bool is_vgem,
     const scoped_refptr<base::TaskRunner>& reply_runner,
     const OnOpenDeviceReplyCallback& callback) {
   scoped_ptr<DrmDeviceHandle> handle(new DrmDeviceHandle());
-  handle->Initialize(path);
+  handle->Initialize(path, is_vgem);
   reply_runner->PostTask(
       FROM_HERE, base::Bind(callback, path, base::Passed(handle.Pass())));
 }
 
 base::FilePath GetPrimaryDisplayCardPath() {
   struct drm_mode_card_res res;
   for (int i = 0; /* end on first card# that does not exist */; i++) {
     std::string card_path = base::StringPrintf(kDefaultGraphicsCardPattern, i);
 
     if (access(card_path.c_str(), F_OK) != 0)
@@ skipping 11 matching lines @@
     if (ret == 0 && res.count_crtcs > 0) {
       return base::FilePath(card_path);
     }
 
     VPLOG_IF(1, ret) << "Failed to get DRM resources for '" << card_path << "'";
   }
 
   return base::FilePath();
 }
 
+base::FilePath GetVgemCardPath() {
+  base::FileEnumerator file_iter(
+      base::FilePath::FromUTF8Unsafe(kVgemSysCardPath), false,
+      base::FileEnumerator::DIRECTORIES, FILE_PATH_LITERAL("card*"));
+
+  while (!file_iter.Next().empty()) {
+    // Inspect the card%d directories in the directory and extract the filename.
+    std::string vgem_card_path =
+        kVgemDevDriCardPath +
+        file_iter.GetInfo().GetName().BaseName().MaybeAsASCII();
+    DVLOG(1) << "VGEM card path is " << vgem_card_path;
+    return base::FilePath(vgem_card_path);
+  }
+  DVLOG(1) << "Don't support VGEM";
+  return base::FilePath();
+}
+
 class FindDisplaySnapshotById {
  public:
   FindDisplaySnapshotById(int64_t display_id) : display_id_(display_id) {}
 
   bool operator()(const DisplaySnapshot* display) {
     return display->display_id() == display_id_;
   }
 
  private:
   int64_t display_id_;
 };
 
 }  // namespace
 
 DrmDisplayHostManager::DrmDisplayHostManager(DrmGpuPlatformSupportHost* proxy,
                                              DeviceManager* device_manager)
     : proxy_(proxy),
       device_manager_(device_manager),
       delegate_(nullptr),
       primary_graphics_card_path_(GetPrimaryDisplayCardPath()),
       has_dummy_display_(false),
       task_pending_(false),
       weak_ptr_factory_(this) {
   {
     // First device needs to be treated specially. We need to open this
     // synchronously since the GPU process will need it to initialize the
     // graphics state.
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     primary_drm_device_handle_.reset(new DrmDeviceHandle());
-    if (!primary_drm_device_handle_->Initialize(primary_graphics_card_path_)) {
+    if (!primary_drm_device_handle_->Initialize(primary_graphics_card_path_,
+                                                false)) {
       LOG(FATAL) << "Failed to open primary graphics card";
       return;
     }
     drm_devices_.insert(primary_graphics_card_path_);
+
+    vgem_card_path_ = GetVgemCardPath();
   }
 
   device_manager_->AddObserver(this);
   proxy_->RegisterHandler(this);
 
   ScopedVector<HardwareDisplayControllerInfo> display_infos =
       GetAvailableDisplayControllerInfos(primary_drm_device_handle_->fd());
   has_dummy_display_ = !display_infos.empty();
   for (size_t i = 0; i < display_infos.size(); ++i) {
     displays_.push_back(new DisplaySnapshotProxy(CreateDisplaySnapshotParams(
@@ skipping 104 matching lines @@
     DisplayEvent event = event_queue_.front();
     event_queue_.pop();
     VLOG(1) << "Got display event " << kDisplayActionString[event.action_type]
             << " for " << event.path.value();
     switch (event.action_type) {
       case DeviceEvent::ADD:
         if (drm_devices_.find(event.path) == drm_devices_.end()) {
           task_pending_ = base::WorkerPool::PostTask(
               FROM_HERE,
               base::Bind(&OpenDeviceOnWorkerThread, event.path,
+                         event.path == vgem_card_path_,
                          base::ThreadTaskRunnerHandle::Get(),
                          base::Bind(&DrmDisplayHostManager::OnAddGraphicsDevice,
                                     weak_ptr_factory_.GetWeakPtr())),
               false /* task_is_slow */);
         }
         break;
       case DeviceEvent::CHANGE:
         task_pending_ = base::ThreadTaskRunnerHandle::Get()->PostTask(
             FROM_HERE,
             base::Bind(&DrmDisplayHostManager::OnUpdateGraphicsDevice,
                        weak_ptr_factory_.GetWeakPtr()));
         break;
       case DeviceEvent::REMOVE:
         DCHECK(event.path != primary_graphics_card_path_)
             << "Removing primary graphics card";
+        DCHECK(event.path != vgem_card_path_) << "Removing VGEM device";
         auto it = drm_devices_.find(event.path);
         if (it != drm_devices_.end()) {
           task_pending_ = base::ThreadTaskRunnerHandle::Get()->PostTask(
               FROM_HERE,
               base::Bind(&DrmDisplayHostManager::OnRemoveGraphicsDevice,
                          weak_ptr_factory_.GetWeakPtr(), event.path));
           drm_devices_.erase(it);
         }
         break;
     }
   }
 }
 
 void DrmDisplayHostManager::OnAddGraphicsDevice(
     const base::FilePath& path,
     scoped_ptr<DrmDeviceHandle> handle) {
   if (handle->IsValid()) {
     drm_devices_.insert(path);
-    proxy_->Send(new OzoneGpuMsg_AddGraphicsDevice(
-        path, base::FileDescriptor(handle->PassFD())));
+    if (handle->IsVgem()) {
+      proxy_->Send(new OzoneGpuMsg_AddVgemDevice(
+          path, base::FileDescriptor(handle->PassFD())));
+    } else {
+      proxy_->Send(new OzoneGpuMsg_AddGraphicsDevice(
+          path, base::FileDescriptor(handle->PassFD())));
+    }
     NotifyDisplayDelegate();
   }
 
   task_pending_ = false;
   ProcessEvent();
 }
 
 void DrmDisplayHostManager::OnUpdateGraphicsDevice() {
   NotifyDisplayDelegate();
   task_pending_ = false;
@@ skipping 10 matching lines @@
 void DrmDisplayHostManager::OnChannelEstablished(
     int host_id,
     scoped_refptr<base::SingleThreadTaskRunner> send_runner,
     const base::Callback<void(IPC::Message*)>& send_callback) {
   drm_devices_.clear();
   drm_devices_.insert(primary_graphics_card_path_);
   scoped_ptr<DrmDeviceHandle> handle = primary_drm_device_handle_.Pass();
   if (!handle) {
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     handle.reset(new DrmDeviceHandle());
-    if (!handle->Initialize(primary_graphics_card_path_))
+    if (!handle->Initialize(primary_graphics_card_path_, false))
       LOG(FATAL) << "Failed to open primary graphics card";
   }
 
   // Send the primary device first since this is used to initialize graphics
   // state.
   proxy_->Send(new OzoneGpuMsg_AddGraphicsDevice(
       primary_graphics_card_path_, base::FileDescriptor(handle->PassFD())));
 
   device_manager_->ScanDevices(this);
   NotifyDisplayDelegate();
@@ skipping 82 matching lines @@
     const GetDisplaysCallback& callback) const {
   callback.Run(displays_.get());
 }
 
 void DrmDisplayHostManager::NotifyDisplayDelegate() const {
   if (delegate_)
     delegate_->OnConfigurationChanged();
 }
 
 }  // namespace ui