libdrm/intel: add drm_intel_bo_disable_reuse api

Scanout buffers need to be freed through the kernel as it holds a reference
to them; exposing this API allows applications allocating scanout buffers to
flag them as not reusable.

Signed-off-by: Keith Packard <keithp@keithp.com>
Reviewed-by: Eric Anholt <eric@anholt.net>

diff --git a/libdrm/intel/intel_bufmgr.c b/libdrm/intel/intel_bufmgr.c
index 25a6828cae03c5c05c89e95f27a415b08d91944b..5057fe69ed4f8e8b83b90cc6625f97fc841fd393 100644 (file)
--- a/libdrm/intel/intel_bufmgr.c
+++ b/libdrm/intel/intel_bufmgr.c
@@ -212,3 +212,10 @@ int drm_intel_bo_get_tiling(drm_intel_bo *bo, uint32_t *tiling_mode,
     *swizzle_mode = I915_BIT_6_SWIZZLE_NONE;
     return 0;
 }
+
+int drm_intel_bo_disable_reuse(drm_intel_bo *bo)
+{
+       if (bo->bufmgr->bo_disable_reuse)
+               return bo->bufmgr->bo_disable_reuse(bo);
+       return 0;
+}

diff --git a/libdrm/intel/intel_bufmgr.h b/libdrm/intel/intel_bufmgr.h
index 542dc06fca98185fa08aa093808ea663f843d7fa..75d06cadd20f15216522813e62471d99739757d5 100644 (file)
--- a/libdrm/intel/intel_bufmgr.h
+++ b/libdrm/intel/intel_bufmgr.h
@@ -108,6 +108,8 @@ int drm_intel_bo_get_tiling(drm_intel_bo *bo, uint32_t *tiling_mode,
                        uint32_t *swizzle_mode);
 int drm_intel_bo_flink(drm_intel_bo *bo, uint32_t *name);
 
+int drm_intel_bo_disable_reuse(drm_intel_bo *bo);
+
 /* drm_intel_bufmgr_gem.c */
 drm_intel_bufmgr *drm_intel_bufmgr_gem_init(int fd, int batch_size);
 drm_intel_bo *drm_intel_bo_gem_create_from_name(drm_intel_bufmgr *bufmgr,

diff --git a/libdrm/intel/intel_bufmgr_gem.c b/libdrm/intel/intel_bufmgr_gem.c
index 89931d85629776d9ef6c64ec031792806c591b17..5ae4d668f144ac5e1db632de5616aa2913d9aeb1 100644 (file)
--- a/libdrm/intel/intel_bufmgr_gem.c
+++ b/libdrm/intel/intel_bufmgr_gem.c
@@ -165,6 +165,11 @@ struct _drm_intel_bo_gem {
      */
      char used_as_reloc_target;
 
+    /**
+     * Boolean of whether this buffer can be re-used
+     */
+    char reusable;
+
     /**
      * Size in bytes of this buffer and its relocation descendents.
      *
@@ -420,6 +425,7 @@ drm_intel_gem_bo_alloc_internal(drm_intel_bufmgr *bufmgr, const char *name,
     bo_gem->used_as_reloc_target = 0;
     bo_gem->tiling_mode = I915_TILING_NONE;
     bo_gem->swizzle_mode = I915_BIT_6_SWIZZLE_NONE;
+    bo_gem->reusable = 1;
 
     DBG("bo_create: buf %d (%s) %ldb\n",
        bo_gem->gem_handle, bo_gem->name, size);
@@ -479,6 +485,7 @@ drm_intel_bo_gem_create_from_name(drm_intel_bufmgr *bufmgr, const char *name,
     bo_gem->validate_index = -1;
     bo_gem->gem_handle = open_arg.handle;
     bo_gem->global_name = handle;
+    bo_gem->reusable = 0;
 
     memset(&get_tiling, 0, sizeof(get_tiling));
     get_tiling.handle = bo_gem->gem_handle;
@@ -572,7 +579,7 @@ drm_intel_gem_bo_unreference_locked(drm_intel_bo *bo)
        bucket = drm_intel_gem_bo_bucket_for_size(bufmgr_gem, bo->size);
        /* Put the buffer into our internal cache for reuse if we can. */
        tiling_mode = I915_TILING_NONE;
-       if (bo_gem->global_name == 0 &&
+       if (bo_gem->reusable &&
            bucket != NULL &&
            (bucket->max_entries == -1 ||
             (bucket->max_entries > 0 &&
@@ -1168,6 +1175,7 @@ drm_intel_gem_bo_flink(drm_intel_bo *bo, uint32_t *name)
        if (ret != 0)
            return -errno;
        bo_gem->global_name = flink.name;
+       bo_gem->reusable = 0;
     }
     
     *name = bo_gem->global_name;
@@ -1356,6 +1364,19 @@ drm_intel_gem_check_aperture_space(drm_intel_bo **bo_array, int count)
     }
 }
 
+/*
+ * Disable buffer reuse for objects which are shared with the kernel
+ * as scanout buffers
+ */
+static int
+drm_intel_gem_bo_disable_reuse(drm_intel_bo *bo)
+{
+    drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
+
+    bo_gem->reusable = 0;
+    return 0;
+}
+
 /**
  * Initializes the GEM buffer manager, which uses the kernel to allocate, map,
  * and manage map buffer objections.
@@ -1437,6 +1458,7 @@ drm_intel_bufmgr_gem_init(int fd, int batch_size)
     bufmgr_gem->bufmgr.destroy = drm_intel_bufmgr_gem_destroy;
     bufmgr_gem->bufmgr.debug = 0;
     bufmgr_gem->bufmgr.check_aperture_space = drm_intel_gem_check_aperture_space;
+    bufmgr_gem->bufmgr.bo_disable_reuse = drm_intel_gem_bo_disable_reuse;
     /* Initialize the linked lists for BO reuse cache. */
     for (i = 0; i < DRM_INTEL_GEM_BO_BUCKETS; i++)
        DRMINITLISTHEAD(&bufmgr_gem->cache_bucket[i].head);

diff --git a/libdrm/intel/intel_bufmgr_priv.h b/libdrm/intel/intel_bufmgr_priv.h
index 82d87b4cbda6ec803c94c779adba86c26addea2e..3484dee87dd1a1793050d86e97fe80b95fb54417 100644 (file)
--- a/libdrm/intel/intel_bufmgr_priv.h
+++ b/libdrm/intel/intel_bufmgr_priv.h
@@ -178,6 +178,16 @@ struct _drm_intel_bufmgr {
     int (*bo_flink)(drm_intel_bo *bo, uint32_t *name);
 
     int (*check_aperture_space)(drm_intel_bo **bo_array, int count);
+
+    /**
+     * Disable buffer reuse for buffers which will be shared in some way,
+     * as with scanout buffers. When the buffer reference count goes to zero,
+     * it will be freed and not placed in the reuse list.
+     *
+     * \param bo Buffer to disable reuse for
+     */
+    int (*bo_disable_reuse)(drm_intel_bo *bo);
+
     int debug; /**< Enables verbose debugging printouts */
 };