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>
 
@@ skipping 13 matching lines @@
 #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 kVGEMCardPattern[] = "/sys/bus/platform/devices/vgem/drm/card%d";
 
 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())));
 }
 
 void CloseDeviceOnWorkerThread(
     scoped_ptr<DrmDeviceHandle> handle,
     const scoped_refptr<base::TaskRunner>& reply_runner,
     const base::Closure& callback) {
   handle.reset();
   reply_runner->PostTask(FROM_HERE, callback);
@@ skipping 48 matching lines @@
       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;
     scoped_ptr<DrmDeviceHandle> handle(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";
       return;
     }
     drm_devices_.add(primary_graphics_card_path_, handle.Pass());
   }
 
   device_manager_->AddObserver(this);
   proxy_->RegisterHandler(this);
 
   DisplaySnapshot_Params params;
@@ skipping 116 matching lines @@
     int64_t display_id,
     const std::vector<GammaRampRGBEntry>& lut) {
   proxy_->Send(new OzoneGpuMsg_SetGammaRamp(display_id, lut));
   return true;
 }
 
 void DrmDisplayHostManager::OnDeviceEvent(const DeviceEvent& event) {
   if (event.device_type() != DeviceEvent::DISPLAY)
     return;
 
-  event_queue_.push(DisplayEvent(event.action_type(), event.path()));
+  bool is_vgem = false;
+  for (int i = 0; i < 16; i++) {
+    struct stat vgem_stat;
+    std::string vgem_path = base::StringPrintf(kVGEMCardPattern, i);
+    if (stat(vgem_path.c_str(), &vgem_stat) == -1)
+      continue;
+
+    std::string card_path = base::StringPrintf(kDefaultGraphicsCardPattern, i);
+    if (card_path == event.path().value())
+      is_vgem = true;
+    break;
+  }
+
+  event_queue_.push(DisplayEvent(event.action_type(), event.path(), is_vgem));
   ProcessEvent();
 }
 
 void DrmDisplayHostManager::ProcessEvent() {
   while (!event_queue_.empty() && !task_pending_) {
     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,
+              base::Bind(&OpenDeviceOnWorkerThread, event.path, event.is_vgem,
                          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,
@@ skipping 20 matching lines @@
   }
 }
 
 void DrmDisplayHostManager::OnAddGraphicsDevice(
     const base::FilePath& path,
     scoped_ptr<DrmDeviceHandle> handle) {
   if (handle->IsValid()) {
     base::ScopedFD file = handle->Duplicate();
     drm_devices_.add(path, handle.Pass());
     proxy_->Send(new OzoneGpuMsg_AddGraphicsDevice(
-        path, base::FileDescriptor(file.Pass())));
+        path, base::FileDescriptor(file.Pass()), handle->IsVgem()));
     NotifyDisplayDelegate();
   }
 
   task_pending_ = false;
   ProcessEvent();
 }
 
 void DrmDisplayHostManager::OnUpdateGraphicsDevice() {
   NotifyDisplayDelegate();
   task_pending_ = false;
   ProcessEvent();
 }
 
 void DrmDisplayHostManager::OnRemoveGraphicsDevice(const base::FilePath& path) {
   proxy_->Send(new OzoneGpuMsg_RemoveGraphicsDevice(path));
   NotifyDisplayDelegate();
   task_pending_ = false;
   ProcessEvent();
 }
 
 void DrmDisplayHostManager::OnChannelEstablished(
     int host_id,
     scoped_refptr<base::SingleThreadTaskRunner> send_runner,
     const base::Callback<void(IPC::Message*)>& send_callback) {
   auto it = drm_devices_.find(primary_graphics_card_path_);
   DCHECK(it != drm_devices_.end());
   // Send the primary device first since this is used to initialize graphics
   // state.
   proxy_->Send(new OzoneGpuMsg_AddGraphicsDevice(
-      it->first, base::FileDescriptor(it->second->Duplicate())));
+      it->first, base::FileDescriptor(it->second->Duplicate()),
+      it->second->IsVgem()));
 
   for (auto pair : drm_devices_) {
     if (pair.second->IsValid() && pair.first != primary_graphics_card_path_) {
       proxy_->Send(new OzoneGpuMsg_AddGraphicsDevice(
-          pair.first, base::FileDescriptor(pair.second->Duplicate())));
+          pair.first, base::FileDescriptor(pair.second->Duplicate()),
+          it->second->IsVgem()));
     }
   }
 
   device_manager_->ScanDevices(this);
   NotifyDisplayDelegate();
 }
 
 void DrmDisplayHostManager::OnChannelDestroyed(int host_id) {
   // If the channel got destroyed in the middle of a configuration then just
   // respond with failure.
@@ skipping 77 matching lines @@
     const GetDisplaysCallback& callback) const {
   callback.Run(displays_.get());
 }
 
 void DrmDisplayHostManager::NotifyDisplayDelegate() const {
   if (delegate_)
     delegate_->OnConfigurationChanged();
 }
 
 }  // namespace ui