ozone: Implement zero/one-copy texture for Ozone GBM.

content/common/gpu/client/gpu_memory_buffer_impl_ozone_gbm.cc

+// Copyright 2015 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 "content/common/gpu/client/gpu_memory_buffer_impl_ozone_gbm.h"
+
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <xf86drm.h>
+
+#include "base/lazy_instance.h"
+#include "base/threading/thread_local.h"
+#include "base/trace_event/trace_event.h"
+
+namespace content {
+
+namespace {
+
+class VGemDevice {
+ public:
+  VGemDevice();
+  ~VGemDevice();
+  bool Initialize(const base::FileDescriptor& device_fd);
+  int device_fd() const;
+
+ private:
+  base::ScopedFD device_fd_;
+  base::ThreadChecker thread_checker_;
+
+  DISALLOW_COPY_AND_ASSIGN(VGemDevice);
+};
+
+VGemDevice::VGemDevice() {
+}
+
+VGemDevice::~VGemDevice() {
+}
+
+bool VGemDevice::Initialize(const base::FileDescriptor& device_fd) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (device_fd_.get() > 0)
+    return true;
+
+  DCHECK(device_fd.auto_close);
+  device_fd_.reset(device_fd.fd);
+  return true;
+}
+
+int VGemDevice::device_fd() const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return device_fd_.get();
+}
+
+// --single-process launches a render thread instead of a render process, so
+// use ThreadLocalPointer to keep vgem fd per renderer.
+base::LazyInstance<base::ThreadLocalPointer<VGemDevice>>::Leaky g_vgem_device =
+    LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
+GpuMemoryBufferImplOzoneGbm::GpuMemoryBufferImplOzoneGbm(
+    gfx::GpuMemoryBufferId id,
+    const gfx::Size& size,
+    Format format,
+    const DestructionCallback& callback)
+    : GpuMemoryBufferImplOzoneNativeBuffer(id, size, format, callback),
+      vgem_bo_handle_(0),
+      stride_(0),
+      mmap_ptr_(nullptr) {
+  RowSizeInBytes(size_.width(), format_, 0, &stride_);
+}
+
+GpuMemoryBufferImplOzoneGbm::~GpuMemoryBufferImplOzoneGbm() {
+  if (vgem_bo_handle_) {
+    // TODO(dshwang): Both causes CRASH. How to release a handle?
+    if (false) {
+      struct drm_mode_destroy_dumb destroy;
+      memset(&destroy, 0, sizeof(destroy));
+      destroy.handle = vgem_bo_handle_;
+      int ret = drmIoctl(g_vgem_device.Pointer()->Get()->device_fd(),
+                         DRM_IOCTL_MODE_DESTROY_DUMB, &destroy);
+      if (!ret)
+        LOG(ERROR) << "fail to free a vgem buffer. error:" << ret;
+    }
+    if (false) {
+      struct drm_gem_close close;
+      memset(&close, 0, sizeof(close));
+      close.handle = vgem_bo_handle_;
+      int ret = drmIoctl(g_vgem_device.Pointer()->Get()->device_fd(),
+                         DRM_IOCTL_GEM_CLOSE, &close);
+      if (!ret)
+        LOG(ERROR) << "fail to free a vgem buffer. error:" << ret;
+    }

[dshwang, 2015/05/11 13:38:05]

zachr, I could not release the handle because both
drmIoctl(DRM_IOCTL_MODE_DESTROY_DUMB) and drmIoctl(DRM_IOCTL_GEM_CLOSE) cause
renderer crash. I guess kernel has bug. could you advice?

+    vgem_bo_handle_ = 0;
+  }
+}
+
+// static
+scoped_ptr<GpuMemoryBufferImpl> GpuMemoryBufferImplOzoneGbm::CreateFromHandle(
+    const gfx::GpuMemoryBufferHandle& handle,
+    const gfx::Size& size,
+    Format format,
+    const DestructionCallback& callback) {
+  scoped_ptr<GpuMemoryBufferImplOzoneGbm> buffer = make_scoped_ptr(
+      new GpuMemoryBufferImplOzoneGbm(handle.id, size, format, callback));
+  if (!buffer->Initialize(handle))
+    return nullptr;
+  return buffer.Pass();
+}
+
+bool GpuMemoryBufferImplOzoneGbm::Initialize(
+    const gfx::GpuMemoryBufferHandle& handle) {
+  // Render process must close |device_handle|.
+  DCHECK(handle.device_handle.auto_close);
+  if (!g_vgem_device.Pointer()->Get()) {
+    g_vgem_device.Pointer()->Set(new VGemDevice);
+    g_vgem_device.Pointer()->Get()->Initialize(handle.device_handle);
+  } else {
+    // TODO(dshwang): pass this fd only one time for each render process.
+    base::ScopedFD closing_fd(handle.device_handle.fd);
+  }
+  DCHECK(g_vgem_device.Pointer()->Get()->device_fd());
+
+  DCHECK(handle.handle.auto_close);
+  dma_buf_.reset(handle.handle.fd);
+
+  int ret = drmPrimeFDToHandle(g_vgem_device.Pointer()->Get()->device_fd(),
+                               dma_buf_.get(), &vgem_bo_handle_);
+  if (ret) {
+    LOG(ERROR) << "drmPrimeFDToHandle failed, handle:" << vgem_bo_handle_;
+    return false;
+  }
+  return true;
+}
+
+bool GpuMemoryBufferImplOzoneGbm::Map(void** data) {
+  TRACE_EVENT0("gpu", "GpuMemoryBufferImplOzoneGbm::Map");
+  DCHECK(!mapped_);
+  DCHECK(!mmap_ptr_);
+  DCHECK(vgem_bo_handle_);
+
+  struct drm_mode_map_dumb mmap_arg;
+  memset(&mmap_arg, 0, sizeof(mmap_arg));
+  mmap_arg.handle = vgem_bo_handle_;
+
+  int ret = drmIoctl(g_vgem_device.Pointer()->Get()->device_fd(),
+                     DRM_IOCTL_MODE_MAP_DUMB, &mmap_arg);
+  if (ret) {
+    LOG(ERROR) << "fail to map a vgem buffer. error:" << ret;
+    return false;
+  }
+  DCHECK(mmap_arg.offset);
+
+  size_t size = stride_ * size_.height();
+  mmap_ptr_ =
+      mmap(nullptr, size, (PROT_READ | PROT_WRITE), MAP_SHARED,
+           g_vgem_device.Pointer()->Get()->device_fd(), mmap_arg.offset);
+  DCHECK(mmap_ptr_ != MAP_FAILED);
+  mapped_ = true;
+  *data = mmap_ptr_;
+  return true;
+}
+
+void GpuMemoryBufferImplOzoneGbm::Unmap() {
+  TRACE_EVENT0("gpu", "GpuMemoryBufferImplOzoneGbm::Unmap");
+  DCHECK(mapped_);
+  DCHECK(mmap_ptr_);
+  size_t size = stride_ * size_.height();
+  int ret = munmap(mmap_ptr_, size);
+  DCHECK(!ret);
+  mmap_ptr_ = nullptr;
+  mapped_ = false;
+}
+
+void GpuMemoryBufferImplOzoneGbm::GetStride(int* stride) const {
+  *stride = stride_;
+}
+
+gfx::GpuMemoryBufferHandle GpuMemoryBufferImplOzoneGbm::GetHandle() const {
+  // Don't need to set |handle.handle| and |handle.device_handle| because gpu
+  // process can look up the right pixmap only by id.
+  // See ui::GpuMemoryBufferFactoryOzoneNativeBuffer
+  return GpuMemoryBufferImplOzoneNativeBuffer::GetHandle();
+}
+
+}  // namespace content