Index: content/common/gpu/client/gpu_memory_buffer_impl_ozone_gbm.cc |
diff --git a/content/common/gpu/client/gpu_memory_buffer_impl_ozone_gbm.cc b/content/common/gpu/client/gpu_memory_buffer_impl_ozone_gbm.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..b5d53b424e8179d3124f16d66b0555a46e4ebc92 |
--- /dev/null |
+++ b/content/common/gpu/client/gpu_memory_buffer_impl_ozone_gbm.cc |
@@ -0,0 +1,186 @@ |
+// 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
|
+ 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 |