minigbm: Use dmabuf inode as unique buffer id instead of handle

Handle has some limits and can't be used as unique buffer ID on systems
where display controller can scanout from CMA but GPU can work with both
CMA and VRAM.

Such systems have DRM/KMS and DRM/GPU drivers separated.
GBM frontend is always expecting handle for DRM/KMS driver.
In such system any attempt of importing the buffer with more
than 1 contiguous chunk into DRM/KMS driver will fail.

Using dma-buf inode as unique buffer ID is a common practice for
a last several years starting from [this kernel patch][1].

[1]: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=ed63bb1d1f8469586006a9ca63c42344401aa2ab
Change-Id: Ic3a69010d5da2f866a2252fc7e9eb29d67f8e1ed
Signed-off-by: Roman Stratiienko <[email protected]>

For reviews, comments, suggestions and questions visit:
#10

Author: rsglobal

drv.c

@@ -253,7 +253,7 @@ static void drv_bo_mapping_destroy(struct bo *bo)
 		while (idx < drv_array_size(drv->mappings)) {
 			struct mapping *mapping =
 			    (struct mapping *)drv_array_at_idx(drv->mappings, idx);
-			if (mapping->vma->handle != bo->handle.u32) {
+			if (mapping->vma->inode != bo->inode) {
 				idx++;
 				continue;
 			}
@@ -287,11 +287,16 @@ static void drv_bo_acquire(struct bo *bo)
 	pthread_mutex_lock(&drv->buffer_table_lock);
 	for (size_t plane = 0; plane < bo->meta.num_planes; plane++) {
 		uintptr_t num = 0;
+		if (!bo->inode) {
+			int fd = drv_bo_get_plane_fd(bo, plane);
+			bo->inode = drv_get_inode(fd);
+			close(fd);
+		}
 
-		if (!drmHashLookup(drv->buffer_table, bo->handle.u32, (void **)&num))
-			drmHashDelete(drv->buffer_table, bo->handle.u32);
+		if (!drmHashLookup(drv->buffer_table, bo->inode, (void **)&num))
+			drmHashDelete(drv->buffer_table, bo->inode);
 
-		drmHashInsert(drv->buffer_table, bo->handle.u32, (void *)(num + 1));
+		drmHashInsert(drv->buffer_table, bo->inode, (void *)(num + 1));
 	}
 	pthread_mutex_unlock(&drv->buffer_table_lock);
 }
@@ -310,18 +315,18 @@ static bool drv_bo_release(struct bo *bo)
 
 	pthread_mutex_lock(&drv->buffer_table_lock);
 	for (size_t plane = 0; plane < bo->meta.num_planes; plane++) {
-		if (!drmHashLookup(drv->buffer_table, bo->handle.u32, (void **)&num)) {
-			drmHashDelete(drv->buffer_table, bo->handle.u32);
+		if (!drmHashLookup(drv->buffer_table, bo->inode, (void **)&num)) {
+			drmHashDelete(drv->buffer_table, bo->inode);
 
 			if (num > 1) {
-				drmHashInsert(drv->buffer_table, bo->handle.u32, (void *)(num - 1));
+				drmHashInsert(drv->buffer_table, bo->inode, (void *)(num - 1));
 			}
 		}
 	}
 
 	/* The same buffer can back multiple planes with different offsets. */
 	for (size_t plane = 0; plane < bo->meta.num_planes; plane++) {
-		if (!drmHashLookup(drv->buffer_table, bo->handle.u32, (void **)&num)) {
+		if (!drmHashLookup(drv->buffer_table, bo->inode, (void **)&num)) {
 			/* num is positive if found in the hashmap. */
 			pthread_mutex_unlock(&drv->buffer_table_lock);
 			return false;
@@ -433,6 +438,8 @@ struct bo *drv_bo_import(struct driver *drv, struct drv_import_fd_data *data)
 		return NULL;
 	}
 
+	bo->inode = drv_get_inode(data->fds[0]);
+
 	drv_bo_acquire(bo);
 
 	bo->meta.format_modifier = data->format_modifier;
@@ -493,7 +500,7 @@ void *drv_bo_map(struct bo *bo, const struct rectangle *rect, uint32_t map_flags
 
 	for (i = 0; i < drv_array_size(drv->mappings); i++) {
 		struct mapping *prior = (struct mapping *)drv_array_at_idx(drv->mappings, i);
-		if (prior->vma->handle != bo->handle.u32 || prior->vma->map_flags != map_flags)
+		if (prior->vma->inode != bo->inode || prior->vma->map_flags != map_flags)
 			continue;
 
 		if (rect->x != prior->rect.x || rect->y != prior->rect.y ||
@@ -507,7 +514,7 @@ void *drv_bo_map(struct bo *bo, const struct rectangle *rect, uint32_t map_flags
 
 	for (i = 0; i < drv_array_size(drv->mappings); i++) {
 		struct mapping *prior = (struct mapping *)drv_array_at_idx(drv->mappings, i);
-		if (prior->vma->handle != bo->handle.u32 || prior->vma->map_flags != map_flags)
+		if (prior->vma->inode != bo->inode || prior->vma->map_flags != map_flags)
 			continue;
 
 		prior->vma->refcount++;
@@ -533,7 +540,7 @@ void *drv_bo_map(struct bo *bo, const struct rectangle *rect, uint32_t map_flags
 
 	mapping.vma->refcount = 1;
 	mapping.vma->addr = addr;
-	mapping.vma->handle = bo->handle.u32;
+	mapping.vma->inode = bo->inode;
 	mapping.vma->map_flags = map_flags;
 
 success:

drv.h

@@ -126,7 +126,8 @@ struct drv_import_fd_data {
 struct vma {
 	void *addr;
 	size_t length;
-	uint32_t handle;
+
+	uint32_t inode;
 	uint32_t map_flags;
 	int32_t refcount;
 	uint32_t map_strides[DRV_MAX_PLANES];

drv_helpers.c

@@ -12,6 +12,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/mman.h>
+#include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <xf86drm.h>
@@ -616,6 +617,18 @@ void drv_resolve_format_and_use_flags_helper(struct driver *drv, uint32_t format
 	}
 }
 
+uint32_t drv_get_inode(int dmabuf_fd)
+{
+	struct stat sb = { 0 };
+	int ret = 0;
+
+	ret = fstat(dmabuf_fd, &sb);
+	if (ret)
+		drv_loge("Failed to fstat dmabuf %d: %s\n", dmabuf_fd, strerror(errno));
+
+	return sb.st_ino;
+}
+
 const char *drv_get_os_option(const char *name)
 {
 	const char *ret = getenv(name);

drv_helpers.h

@@ -51,6 +51,8 @@ void drv_resolve_format_and_use_flags_helper(struct driver *drv, uint32_t format
 					     uint64_t use_flags, uint32_t *out_format,
 					     uint64_t *out_use_flags);
 
+uint32_t drv_get_inode(int dmabuf_fd);
+
 /*
  * Get an option. Should return NULL if specified option is not set.
  */

drv_priv.h

@@ -44,7 +44,9 @@ struct bo {
 	struct driver *drv;
 	struct bo_metadata meta;
 	bool is_test_buffer;
+	/* handle are mandatory only for SCANOUT buffers */
 	union bo_handle handle;
+	uint32_t inode;
 	void *priv;
 };
 

virtgpu_virgl.c

@@ -1021,7 +1021,7 @@ static int virgl_bo_invalidate(struct bo *bo, struct mapping *mapping)
 	if (params[param_resource_blob].value && (bo->meta.tiling & VIRTGPU_BLOB_FLAG_USE_MAPPABLE))
 		return 0;
 
-	xfer.bo_handle = mapping->vma->handle;
+	xfer.bo_handle = bo->handle.u32;
 
 	if (mapping->rect.x || mapping->rect.y) {
 		/*
@@ -1075,7 +1075,7 @@ static int virgl_bo_invalidate(struct bo *bo, struct mapping *mapping)
 	// The transfer needs to complete before invalidate returns so that any host changes
 	// are visible and to ensure the host doesn't overwrite subsequent guest changes.
 	// TODO(b/136733358): Support returning fences from transfers
-	waitcmd.handle = mapping->vma->handle;
+	waitcmd.handle = bo->handle.u32;
 	ret = drmIoctl(bo->drv->fd, DRM_IOCTL_VIRTGPU_WAIT, &waitcmd);
 	if (ret) {
 		drv_loge("DRM_IOCTL_VIRTGPU_WAIT failed with %s\n", strerror(errno));
@@ -1103,7 +1103,7 @@ static int virgl_bo_flush(struct bo *bo, struct mapping *mapping)
 	if (params[param_resource_blob].value && (bo->meta.tiling & VIRTGPU_BLOB_FLAG_USE_MAPPABLE))
 		return 0;
 
-	xfer.bo_handle = mapping->vma->handle;
+	xfer.bo_handle = bo->handle.u32;
 
 	if (mapping->rect.x || mapping->rect.y) {
 		/*
@@ -1153,7 +1153,7 @@ static int virgl_bo_flush(struct bo *bo, struct mapping *mapping)
 	// buffer, we need to wait for the transfer to complete for consistency.
 	// TODO(b/136733358): Support returning fences from transfers
 	if (bo->meta.use_flags & BO_USE_NON_GPU_HW) {
-		waitcmd.handle = mapping->vma->handle;
+		waitcmd.handle = bo->handle.u32;
 
 		ret = drmIoctl(bo->drv->fd, DRM_IOCTL_VIRTGPU_WAIT, &waitcmd);
 		if (ret) {