From c28691ab77d432a3351539dd6eca81b53620d4d4 Mon Sep 17 00:00:00 2001 From: Kenneth Graunke Date: Wed, 22 Mar 2017 00:50:21 -0700 Subject: [PATCH] i965/drm: Combine drm_bacon_bufmgr_gem and drm_bacon_bufmgr classes. The distinction was required when the bufmgr was virtualised, now there is only one class, we no longer need the distraction of pretending it is a subclass. Reviewed-by: Chris Wilson Acked-by: Jason Ekstrand --- src/mesa/drivers/dri/i965/Makefile.sources | 1 - src/mesa/drivers/dri/i965/intel_bufmgr_gem.c | 687 +++++++++--------- src/mesa/drivers/dri/i965/intel_bufmgr_priv.h | 45 -- 3 files changed, 328 insertions(+), 405 deletions(-) delete mode 100644 src/mesa/drivers/dri/i965/intel_bufmgr_priv.h diff --git a/src/mesa/drivers/dri/i965/Makefile.sources b/src/mesa/drivers/dri/i965/Makefile.sources index 3e73d0f9e2a..9068bcdde7a 100644 --- a/src/mesa/drivers/dri/i965/Makefile.sources +++ b/src/mesa/drivers/dri/i965/Makefile.sources @@ -132,7 +132,6 @@ i965_FILES = \ intel_buffers.c \ intel_buffers.h \ intel_bufmgr_gem.c \ - intel_bufmgr_priv.h \ intel_chipset.h \ intel_copy_image.c \ intel_extensions.c \ diff --git a/src/mesa/drivers/dri/i965/intel_bufmgr_gem.c b/src/mesa/drivers/dri/i965/intel_bufmgr_gem.c index d0395e78307..440ec16de38 100644 --- a/src/mesa/drivers/dri/i965/intel_bufmgr_gem.c +++ b/src/mesa/drivers/dri/i965/intel_bufmgr_gem.c @@ -62,7 +62,6 @@ #include "util/macros.h" #include "util/list.h" #include "brw_bufmgr.h" -#include "intel_bufmgr_priv.h" #include "intel_chipset.h" #include "string.h" @@ -119,9 +118,7 @@ struct drm_bacon_gem_bo_bucket { unsigned long size; }; -typedef struct _drm_bacon_bufmgr_gem { - drm_bacon_bufmgr bufmgr; - +typedef struct _drm_bacon_bufmgr { int refcount; int fd; @@ -165,7 +162,7 @@ typedef struct _drm_bacon_bufmgr_gem { uint32_t handle; } userptr_active; -} drm_bacon_bufmgr_gem; +} drm_bacon_bufmgr; typedef struct _drm_bacon_reloc_target_info { drm_bacon_bo *bo; @@ -308,7 +305,7 @@ static inline drm_bacon_bo_gem *to_bo_gem(drm_bacon_bo *bo) } static unsigned long -drm_bacon_gem_bo_tile_size(drm_bacon_bufmgr_gem *bufmgr_gem, unsigned long size, +drm_bacon_gem_bo_tile_size(drm_bacon_bufmgr *bufmgr, unsigned long size, uint32_t *tiling_mode) { if (*tiling_mode == I915_TILING_NONE) @@ -324,7 +321,7 @@ drm_bacon_gem_bo_tile_size(drm_bacon_bufmgr_gem *bufmgr_gem, unsigned long size, * change. */ static unsigned long -drm_bacon_gem_bo_tile_pitch(drm_bacon_bufmgr_gem *bufmgr_gem, +drm_bacon_gem_bo_tile_pitch(drm_bacon_bufmgr *bufmgr, unsigned long pitch, uint32_t *tiling_mode) { unsigned long tile_width; @@ -345,14 +342,14 @@ drm_bacon_gem_bo_tile_pitch(drm_bacon_bufmgr_gem *bufmgr_gem, } static struct drm_bacon_gem_bo_bucket * -drm_bacon_gem_bo_bucket_for_size(drm_bacon_bufmgr_gem *bufmgr_gem, +drm_bacon_gem_bo_bucket_for_size(drm_bacon_bufmgr *bufmgr, unsigned long size) { int i; - for (i = 0; i < bufmgr_gem->num_buckets; i++) { + for (i = 0; i < bufmgr->num_buckets; i++) { struct drm_bacon_gem_bo_bucket *bucket = - &bufmgr_gem->cache_bucket[i]; + &bufmgr->cache_bucket[i]; if (bucket->size >= size) { return bucket; } @@ -362,12 +359,12 @@ drm_bacon_gem_bo_bucket_for_size(drm_bacon_bufmgr_gem *bufmgr_gem, } static void -drm_bacon_gem_dump_validation_list(drm_bacon_bufmgr_gem *bufmgr_gem) +drm_bacon_gem_dump_validation_list(drm_bacon_bufmgr *bufmgr) { int i, j; - for (i = 0; i < bufmgr_gem->exec_count; i++) { - drm_bacon_bo *bo = bufmgr_gem->exec_bos[i]; + for (i = 0; i < bufmgr->exec_count; i++) { + drm_bacon_bo *bo = bufmgr->exec_bos[i]; drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *) bo; if (bo_gem->relocs == NULL && bo_gem->softpin_target == NULL) { @@ -426,7 +423,7 @@ drm_bacon_bo_reference(drm_bacon_bo *bo) static void drm_bacon_add_validate_buffer2(drm_bacon_bo *bo) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *)bo->bufmgr; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *)bo; int index; @@ -434,38 +431,38 @@ drm_bacon_add_validate_buffer2(drm_bacon_bo *bo) return; /* Extend the array of validation entries as necessary. */ - if (bufmgr_gem->exec_count == bufmgr_gem->exec_size) { - int new_size = bufmgr_gem->exec_size * 2; + if (bufmgr->exec_count == bufmgr->exec_size) { + int new_size = bufmgr->exec_size * 2; if (new_size == 0) new_size = 5; - bufmgr_gem->exec2_objects = - realloc(bufmgr_gem->exec2_objects, - sizeof(*bufmgr_gem->exec2_objects) * new_size); - bufmgr_gem->exec_bos = - realloc(bufmgr_gem->exec_bos, - sizeof(*bufmgr_gem->exec_bos) * new_size); - bufmgr_gem->exec_size = new_size; + bufmgr->exec2_objects = + realloc(bufmgr->exec2_objects, + sizeof(*bufmgr->exec2_objects) * new_size); + bufmgr->exec_bos = + realloc(bufmgr->exec_bos, + sizeof(*bufmgr->exec_bos) * new_size); + bufmgr->exec_size = new_size; } - index = bufmgr_gem->exec_count; + index = bufmgr->exec_count; bo_gem->validate_index = index; /* Fill in array entry */ - bufmgr_gem->exec2_objects[index].handle = bo_gem->gem_handle; - bufmgr_gem->exec2_objects[index].relocation_count = bo_gem->reloc_count; - bufmgr_gem->exec2_objects[index].relocs_ptr = (uintptr_t)bo_gem->relocs; - bufmgr_gem->exec2_objects[index].alignment = bo->align; - bufmgr_gem->exec2_objects[index].offset = bo->offset64; - bufmgr_gem->exec2_objects[index].flags = bo_gem->kflags; - bufmgr_gem->exec2_objects[index].rsvd1 = 0; - bufmgr_gem->exec2_objects[index].rsvd2 = 0; - bufmgr_gem->exec_bos[index] = bo; - bufmgr_gem->exec_count++; + bufmgr->exec2_objects[index].handle = bo_gem->gem_handle; + bufmgr->exec2_objects[index].relocation_count = bo_gem->reloc_count; + bufmgr->exec2_objects[index].relocs_ptr = (uintptr_t)bo_gem->relocs; + bufmgr->exec2_objects[index].alignment = bo->align; + bufmgr->exec2_objects[index].offset = bo->offset64; + bufmgr->exec2_objects[index].flags = bo_gem->kflags; + bufmgr->exec2_objects[index].rsvd1 = 0; + bufmgr->exec2_objects[index].rsvd2 = 0; + bufmgr->exec_bos[index] = bo; + bufmgr->exec_count++; } static void -drm_bacon_bo_gem_set_in_aperture_size(drm_bacon_bufmgr_gem *bufmgr_gem, +drm_bacon_bo_gem_set_in_aperture_size(drm_bacon_bufmgr *bufmgr, drm_bacon_bo_gem *bo_gem, unsigned int alignment) { @@ -488,8 +485,8 @@ static int drm_bacon_setup_reloc_list(drm_bacon_bo *bo) { drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *) bo; - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bo->bufmgr; - unsigned int max_relocs = bufmgr_gem->max_relocs; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; + unsigned int max_relocs = bufmgr->max_relocs; if (bo->size / 4 < max_relocs) max_relocs = bo->size / 4; @@ -516,7 +513,7 @@ drm_bacon_setup_reloc_list(drm_bacon_bo *bo) int drm_bacon_bo_busy(drm_bacon_bo *bo) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bo->bufmgr; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *) bo; struct drm_i915_gem_busy busy; int ret; @@ -527,7 +524,7 @@ drm_bacon_bo_busy(drm_bacon_bo *bo) memclear(busy); busy.handle = bo_gem->gem_handle; - ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_BUSY, &busy); + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GEM_BUSY, &busy); if (ret == 0) { bo_gem->idle = !busy.busy; return busy.busy; @@ -538,7 +535,7 @@ drm_bacon_bo_busy(drm_bacon_bo *bo) } static int -drm_bacon_gem_bo_madvise_internal(drm_bacon_bufmgr_gem *bufmgr_gem, +drm_bacon_gem_bo_madvise_internal(drm_bacon_bufmgr *bufmgr, drm_bacon_bo_gem *bo_gem, int state) { struct drm_i915_gem_madvise madv; @@ -547,7 +544,7 @@ drm_bacon_gem_bo_madvise_internal(drm_bacon_bufmgr_gem *bufmgr_gem, madv.handle = bo_gem->gem_handle; madv.madv = state; madv.retained = 1; - drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_MADVISE, &madv); + drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GEM_MADVISE, &madv); return madv.retained; } @@ -555,15 +552,14 @@ drm_bacon_gem_bo_madvise_internal(drm_bacon_bufmgr_gem *bufmgr_gem, int drm_bacon_bo_madvise(drm_bacon_bo *bo, int madv) { - return drm_bacon_gem_bo_madvise_internal - ((drm_bacon_bufmgr_gem *) bo->bufmgr, - (drm_bacon_bo_gem *) bo, - madv); + return drm_bacon_gem_bo_madvise_internal(bo->bufmgr, + (drm_bacon_bo_gem *) bo, + madv); } /* drop the oldest entries that have been purged by the kernel */ static void -drm_bacon_gem_bo_cache_purge_bucket(drm_bacon_bufmgr_gem *bufmgr_gem, +drm_bacon_gem_bo_cache_purge_bucket(drm_bacon_bufmgr *bufmgr, struct drm_bacon_gem_bo_bucket *bucket) { while (!list_empty(&bucket->head)) { @@ -572,7 +568,7 @@ drm_bacon_gem_bo_cache_purge_bucket(drm_bacon_bufmgr_gem *bufmgr_gem, bo_gem = LIST_ENTRY(drm_bacon_bo_gem, bucket->head.next, head); if (drm_bacon_gem_bo_madvise_internal - (bufmgr_gem, bo_gem, I915_MADV_DONTNEED)) + (bufmgr, bo_gem, I915_MADV_DONTNEED)) break; list_del(&bo_gem->head); @@ -589,7 +585,6 @@ drm_bacon_gem_bo_alloc_internal(drm_bacon_bufmgr *bufmgr, unsigned long stride, unsigned int alignment) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bufmgr; drm_bacon_bo_gem *bo_gem; unsigned int page_size = getpagesize(); int ret; @@ -602,7 +597,7 @@ drm_bacon_gem_bo_alloc_internal(drm_bacon_bufmgr *bufmgr, for_render = true; /* Round the allocated size up to a power of two number of pages. */ - bucket = drm_bacon_gem_bo_bucket_for_size(bufmgr_gem, size); + bucket = drm_bacon_gem_bo_bucket_for_size(bufmgr, size); /* If we don't have caching at this size, don't actually round the * allocation up. @@ -615,7 +610,7 @@ drm_bacon_gem_bo_alloc_internal(drm_bacon_bufmgr *bufmgr, bo_size = bucket->size; } - pthread_mutex_lock(&bufmgr_gem->lock); + pthread_mutex_lock(&bufmgr->lock); /* Get a buffer out of the cache if available */ retry: alloc_from_cache = false; @@ -649,9 +644,9 @@ retry: if (alloc_from_cache) { if (!drm_bacon_gem_bo_madvise_internal - (bufmgr_gem, bo_gem, I915_MADV_WILLNEED)) { + (bufmgr, bo_gem, I915_MADV_WILLNEED)) { drm_bacon_gem_bo_free(&bo_gem->bo); - drm_bacon_gem_bo_cache_purge_bucket(bufmgr_gem, + drm_bacon_gem_bo_cache_purge_bucket(bufmgr, bucket); goto retry; } @@ -681,7 +676,7 @@ retry: memclear(create); create.size = bo_size; - ret = drmIoctl(bufmgr_gem->fd, + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GEM_CREATE, &create); if (ret != 0) { @@ -690,7 +685,7 @@ retry: } bo_gem->gem_handle = create.handle; - HASH_ADD(handle_hh, bufmgr_gem->handle_table, + HASH_ADD(handle_hh, bufmgr->handle_table, gem_handle, sizeof(bo_gem->gem_handle), bo_gem); @@ -715,8 +710,8 @@ retry: bo_gem->has_error = false; bo_gem->reusable = true; - drm_bacon_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem, alignment); - pthread_mutex_unlock(&bufmgr_gem->lock); + drm_bacon_bo_gem_set_in_aperture_size(bufmgr, bo_gem, alignment); + pthread_mutex_unlock(&bufmgr->lock); DBG("bo_create: buf %d (%s) %ldb\n", bo_gem->gem_handle, bo_gem->name, size); @@ -726,7 +721,7 @@ retry: err_free: drm_bacon_gem_bo_free(&bo_gem->bo); err: - pthread_mutex_unlock(&bufmgr_gem->lock); + pthread_mutex_unlock(&bufmgr->lock); return NULL; } @@ -757,7 +752,6 @@ drm_bacon_bo_alloc_tiled(drm_bacon_bufmgr *bufmgr, const char *name, int x, int y, int cpp, uint32_t *tiling_mode, unsigned long *pitch, unsigned long flags) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *)bufmgr; unsigned long size, stride; uint32_t tiling; @@ -787,9 +781,9 @@ drm_bacon_bo_alloc_tiled(drm_bacon_bufmgr *bufmgr, const char *name, aligned_y = ALIGN(y, height_alignment); stride = x * cpp; - stride = drm_bacon_gem_bo_tile_pitch(bufmgr_gem, stride, tiling_mode); + stride = drm_bacon_gem_bo_tile_pitch(bufmgr, stride, tiling_mode); size = stride * aligned_y; - size = drm_bacon_gem_bo_tile_size(bufmgr_gem, size, tiling_mode); + size = drm_bacon_gem_bo_tile_size(bufmgr, size, tiling_mode); } while (*tiling_mode != tiling); *pitch = stride; @@ -809,7 +803,6 @@ drm_bacon_bo_alloc_userptr(drm_bacon_bufmgr *bufmgr, unsigned long size, unsigned long flags) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bufmgr; drm_bacon_bo_gem *bo_gem; int ret; struct drm_i915_gem_userptr userptr; @@ -834,7 +827,7 @@ drm_bacon_bo_alloc_userptr(drm_bacon_bufmgr *bufmgr, userptr.user_size = size; userptr.flags = flags; - ret = drmIoctl(bufmgr_gem->fd, + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GEM_USERPTR, &userptr); if (ret != 0) { @@ -845,7 +838,7 @@ drm_bacon_bo_alloc_userptr(drm_bacon_bufmgr *bufmgr, return NULL; } - pthread_mutex_lock(&bufmgr_gem->lock); + pthread_mutex_lock(&bufmgr->lock); bo_gem->gem_handle = userptr.handle; bo_gem->bo.handle = bo_gem->gem_handle; @@ -858,7 +851,7 @@ drm_bacon_bo_alloc_userptr(drm_bacon_bufmgr *bufmgr, bo_gem->swizzle_mode = I915_BIT_6_SWIZZLE_NONE; bo_gem->stride = 0; - HASH_ADD(handle_hh, bufmgr_gem->handle_table, + HASH_ADD(handle_hh, bufmgr->handle_table, gem_handle, sizeof(bo_gem->gem_handle), bo_gem); @@ -868,8 +861,8 @@ drm_bacon_bo_alloc_userptr(drm_bacon_bufmgr *bufmgr, bo_gem->has_error = false; bo_gem->reusable = false; - drm_bacon_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem, 0); - pthread_mutex_unlock(&bufmgr_gem->lock); + drm_bacon_bo_gem_set_in_aperture_size(bufmgr, bo_gem, 0); + pthread_mutex_unlock(&bufmgr->lock); DBG("bo_create_userptr: " "ptr %p buf %d (%s) size %ldb, stride 0x%x, tile mode %d\n", @@ -882,7 +875,6 @@ drm_bacon_bo_alloc_userptr(drm_bacon_bufmgr *bufmgr, bool drm_bacon_has_userptr(drm_bacon_bufmgr *bufmgr) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bufmgr; int ret; void *ptr; long pgsz; @@ -903,7 +895,7 @@ drm_bacon_has_userptr(drm_bacon_bufmgr *bufmgr) userptr.user_size = pgsz; retry: - ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_USERPTR, &userptr); + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GEM_USERPTR, &userptr); if (ret) { if (errno == ENODEV && userptr.flags == 0) { userptr.flags = I915_USERPTR_UNSYNCHRONIZED; @@ -920,8 +912,8 @@ retry: * mm_locks and stop_machine()). */ - bufmgr_gem->userptr_active.ptr = ptr; - bufmgr_gem->userptr_active.handle = userptr.handle; + bufmgr->userptr_active.ptr = ptr; + bufmgr->userptr_active.handle = userptr.handle; return true; } @@ -937,7 +929,6 @@ drm_bacon_bo_gem_create_from_name(drm_bacon_bufmgr *bufmgr, const char *name, unsigned int handle) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bufmgr; drm_bacon_bo_gem *bo_gem; int ret; struct drm_gem_open open_arg; @@ -949,8 +940,8 @@ drm_bacon_bo_gem_create_from_name(drm_bacon_bufmgr *bufmgr, * alternating names for the front/back buffer a linear search * provides a sufficiently fast match. */ - pthread_mutex_lock(&bufmgr_gem->lock); - HASH_FIND(name_hh, bufmgr_gem->name_table, + pthread_mutex_lock(&bufmgr->lock); + HASH_FIND(name_hh, bufmgr->name_table, &handle, sizeof(handle), bo_gem); if (bo_gem) { drm_bacon_bo_reference(&bo_gem->bo); @@ -959,7 +950,7 @@ drm_bacon_bo_gem_create_from_name(drm_bacon_bufmgr *bufmgr, memclear(open_arg); open_arg.name = handle; - ret = drmIoctl(bufmgr_gem->fd, + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_GEM_OPEN, &open_arg); if (ret != 0) { @@ -972,7 +963,7 @@ drm_bacon_bo_gem_create_from_name(drm_bacon_bufmgr *bufmgr, * object from the kernel before by looking through the list * again for a matching gem_handle */ - HASH_FIND(handle_hh, bufmgr_gem->handle_table, + HASH_FIND(handle_hh, bufmgr->handle_table, &open_arg.handle, sizeof(open_arg.handle), bo_gem); if (bo_gem) { drm_bacon_bo_reference(&bo_gem->bo); @@ -998,14 +989,14 @@ drm_bacon_bo_gem_create_from_name(drm_bacon_bufmgr *bufmgr, bo_gem->global_name = handle; bo_gem->reusable = false; - HASH_ADD(handle_hh, bufmgr_gem->handle_table, + HASH_ADD(handle_hh, bufmgr->handle_table, gem_handle, sizeof(bo_gem->gem_handle), bo_gem); - HASH_ADD(name_hh, bufmgr_gem->name_table, + HASH_ADD(name_hh, bufmgr->name_table, global_name, sizeof(bo_gem->global_name), bo_gem); memclear(get_tiling); get_tiling.handle = bo_gem->gem_handle; - ret = drmIoctl(bufmgr_gem->fd, + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GEM_GET_TILING, &get_tiling); if (ret != 0) @@ -1014,23 +1005,23 @@ drm_bacon_bo_gem_create_from_name(drm_bacon_bufmgr *bufmgr, bo_gem->tiling_mode = get_tiling.tiling_mode; bo_gem->swizzle_mode = get_tiling.swizzle_mode; /* XXX stride is unknown */ - drm_bacon_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem, 0); + drm_bacon_bo_gem_set_in_aperture_size(bufmgr, bo_gem, 0); DBG("bo_create_from_handle: %d (%s)\n", handle, bo_gem->name); out: - pthread_mutex_unlock(&bufmgr_gem->lock); + pthread_mutex_unlock(&bufmgr->lock); return &bo_gem->bo; err_unref: drm_bacon_gem_bo_free(&bo_gem->bo); - pthread_mutex_unlock(&bufmgr_gem->lock); + pthread_mutex_unlock(&bufmgr->lock); return NULL; } static void drm_bacon_gem_bo_free(drm_bacon_bo *bo) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bo->bufmgr; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *) bo; struct drm_gem_close close; int ret; @@ -1039,26 +1030,26 @@ drm_bacon_gem_bo_free(drm_bacon_bo *bo) if (bo_gem->mem_virtual) { VG(VALGRIND_FREELIKE_BLOCK(bo_gem->mem_virtual, 0)); drm_munmap(bo_gem->mem_virtual, bo_gem->bo.size); - bufmgr_gem->vma_count--; + bufmgr->vma_count--; } if (bo_gem->wc_virtual) { VG(VALGRIND_FREELIKE_BLOCK(bo_gem->wc_virtual, 0)); drm_munmap(bo_gem->wc_virtual, bo_gem->bo.size); - bufmgr_gem->vma_count--; + bufmgr->vma_count--; } if (bo_gem->gtt_virtual) { drm_munmap(bo_gem->gtt_virtual, bo_gem->bo.size); - bufmgr_gem->vma_count--; + bufmgr->vma_count--; } if (bo_gem->global_name) - HASH_DELETE(name_hh, bufmgr_gem->name_table, bo_gem); - HASH_DELETE(handle_hh, bufmgr_gem->handle_table, bo_gem); + HASH_DELETE(name_hh, bufmgr->name_table, bo_gem); + HASH_DELETE(handle_hh, bufmgr->handle_table, bo_gem); /* Close this object */ memclear(close); close.handle = bo_gem->gem_handle; - ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_GEM_CLOSE, &close); + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_GEM_CLOSE, &close); if (ret != 0) { DBG("DRM_IOCTL_GEM_CLOSE %d failed (%s): %s\n", bo_gem->gem_handle, bo_gem->name, strerror(errno)); @@ -1085,16 +1076,16 @@ drm_bacon_gem_bo_mark_mmaps_incoherent(drm_bacon_bo *bo) /** Frees all cached buffers significantly older than @time. */ static void -drm_bacon_gem_cleanup_bo_cache(drm_bacon_bufmgr_gem *bufmgr_gem, time_t time) +drm_bacon_gem_cleanup_bo_cache(drm_bacon_bufmgr *bufmgr, time_t time) { int i; - if (bufmgr_gem->time == time) + if (bufmgr->time == time) return; - for (i = 0; i < bufmgr_gem->num_buckets; i++) { + for (i = 0; i < bufmgr->num_buckets; i++) { struct drm_bacon_gem_bo_bucket *bucket = - &bufmgr_gem->cache_bucket[i]; + &bufmgr->cache_bucket[i]; while (!list_empty(&bucket->head)) { drm_bacon_bo_gem *bo_gem; @@ -1110,29 +1101,29 @@ drm_bacon_gem_cleanup_bo_cache(drm_bacon_bufmgr_gem *bufmgr_gem, time_t time) } } - bufmgr_gem->time = time; + bufmgr->time = time; } -static void drm_bacon_gem_bo_purge_vma_cache(drm_bacon_bufmgr_gem *bufmgr_gem) +static void drm_bacon_gem_bo_purge_vma_cache(drm_bacon_bufmgr *bufmgr) { int limit; DBG("%s: cached=%d, open=%d, limit=%d\n", __FUNCTION__, - bufmgr_gem->vma_count, bufmgr_gem->vma_open, bufmgr_gem->vma_max); + bufmgr->vma_count, bufmgr->vma_open, bufmgr->vma_max); - if (bufmgr_gem->vma_max < 0) + if (bufmgr->vma_max < 0) return; /* We may need to evict a few entries in order to create new mmaps */ - limit = bufmgr_gem->vma_max - 2*bufmgr_gem->vma_open; + limit = bufmgr->vma_max - 2*bufmgr->vma_open; if (limit < 0) limit = 0; - while (bufmgr_gem->vma_count > limit) { + while (bufmgr->vma_count > limit) { drm_bacon_bo_gem *bo_gem; bo_gem = LIST_ENTRY(drm_bacon_bo_gem, - bufmgr_gem->vma_cache.next, + bufmgr->vma_cache.next, vma_list); assert(bo_gem->map_count == 0); list_delinit(&bo_gem->vma_list); @@ -1140,53 +1131,53 @@ static void drm_bacon_gem_bo_purge_vma_cache(drm_bacon_bufmgr_gem *bufmgr_gem) if (bo_gem->mem_virtual) { drm_munmap(bo_gem->mem_virtual, bo_gem->bo.size); bo_gem->mem_virtual = NULL; - bufmgr_gem->vma_count--; + bufmgr->vma_count--; } if (bo_gem->wc_virtual) { drm_munmap(bo_gem->wc_virtual, bo_gem->bo.size); bo_gem->wc_virtual = NULL; - bufmgr_gem->vma_count--; + bufmgr->vma_count--; } if (bo_gem->gtt_virtual) { drm_munmap(bo_gem->gtt_virtual, bo_gem->bo.size); bo_gem->gtt_virtual = NULL; - bufmgr_gem->vma_count--; + bufmgr->vma_count--; } } } -static void drm_bacon_gem_bo_close_vma(drm_bacon_bufmgr_gem *bufmgr_gem, +static void drm_bacon_gem_bo_close_vma(drm_bacon_bufmgr *bufmgr, drm_bacon_bo_gem *bo_gem) { - bufmgr_gem->vma_open--; - list_addtail(&bo_gem->vma_list, &bufmgr_gem->vma_cache); + bufmgr->vma_open--; + list_addtail(&bo_gem->vma_list, &bufmgr->vma_cache); if (bo_gem->mem_virtual) - bufmgr_gem->vma_count++; + bufmgr->vma_count++; if (bo_gem->wc_virtual) - bufmgr_gem->vma_count++; + bufmgr->vma_count++; if (bo_gem->gtt_virtual) - bufmgr_gem->vma_count++; - drm_bacon_gem_bo_purge_vma_cache(bufmgr_gem); + bufmgr->vma_count++; + drm_bacon_gem_bo_purge_vma_cache(bufmgr); } -static void drm_bacon_gem_bo_open_vma(drm_bacon_bufmgr_gem *bufmgr_gem, +static void drm_bacon_gem_bo_open_vma(drm_bacon_bufmgr *bufmgr, drm_bacon_bo_gem *bo_gem) { - bufmgr_gem->vma_open++; + bufmgr->vma_open++; list_del(&bo_gem->vma_list); if (bo_gem->mem_virtual) - bufmgr_gem->vma_count--; + bufmgr->vma_count--; if (bo_gem->wc_virtual) - bufmgr_gem->vma_count--; + bufmgr->vma_count--; if (bo_gem->gtt_virtual) - bufmgr_gem->vma_count--; - drm_bacon_gem_bo_purge_vma_cache(bufmgr_gem); + bufmgr->vma_count--; + drm_bacon_gem_bo_purge_vma_cache(bufmgr); } static void drm_bacon_gem_bo_unreference_final(drm_bacon_bo *bo, time_t time) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bo->bufmgr; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *) bo; struct drm_bacon_gem_bo_bucket *bucket; int i; @@ -1229,14 +1220,14 @@ drm_bacon_gem_bo_unreference_final(drm_bacon_bo *bo, time_t time) if (bo_gem->map_count) { DBG("bo freed with non-zero map-count %d\n", bo_gem->map_count); bo_gem->map_count = 0; - drm_bacon_gem_bo_close_vma(bufmgr_gem, bo_gem); + drm_bacon_gem_bo_close_vma(bufmgr, bo_gem); drm_bacon_gem_bo_mark_mmaps_incoherent(bo); } - bucket = drm_bacon_gem_bo_bucket_for_size(bufmgr_gem, bo->size); + bucket = drm_bacon_gem_bo_bucket_for_size(bufmgr, bo->size); /* Put the buffer into our internal cache for reuse if we can. */ - if (bufmgr_gem->bo_reuse && bo_gem->reusable && bucket != NULL && - drm_bacon_gem_bo_madvise_internal(bufmgr_gem, bo_gem, + if (bufmgr->bo_reuse && bo_gem->reusable && bucket != NULL && + drm_bacon_gem_bo_madvise_internal(bufmgr, bo_gem, I915_MADV_DONTNEED)) { bo_gem->free_time = time; @@ -1270,27 +1261,26 @@ drm_bacon_bo_unreference(drm_bacon_bo *bo) assert(p_atomic_read(&bo_gem->refcount) > 0); if (atomic_add_unless(&bo_gem->refcount, -1, 1)) { - drm_bacon_bufmgr_gem *bufmgr_gem = - (drm_bacon_bufmgr_gem *) bo->bufmgr; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; struct timespec time; clock_gettime(CLOCK_MONOTONIC, &time); - pthread_mutex_lock(&bufmgr_gem->lock); + pthread_mutex_lock(&bufmgr->lock); if (p_atomic_dec_zero(&bo_gem->refcount)) { drm_bacon_gem_bo_unreference_final(bo, time.tv_sec); - drm_bacon_gem_cleanup_bo_cache(bufmgr_gem, time.tv_sec); + drm_bacon_gem_cleanup_bo_cache(bufmgr, time.tv_sec); } - pthread_mutex_unlock(&bufmgr_gem->lock); + pthread_mutex_unlock(&bufmgr->lock); } } int drm_bacon_bo_map(drm_bacon_bo *bo, int write_enable) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bo->bufmgr; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *) bo; struct drm_i915_gem_set_domain set_domain; int ret; @@ -1301,10 +1291,10 @@ drm_bacon_bo_map(drm_bacon_bo *bo, int write_enable) return 0; } - pthread_mutex_lock(&bufmgr_gem->lock); + pthread_mutex_lock(&bufmgr->lock); if (bo_gem->map_count++ == 0) - drm_bacon_gem_bo_open_vma(bufmgr_gem, bo_gem); + drm_bacon_gem_bo_open_vma(bufmgr, bo_gem); if (!bo_gem->mem_virtual) { struct drm_i915_gem_mmap mmap_arg; @@ -1315,7 +1305,7 @@ drm_bacon_bo_map(drm_bacon_bo *bo, int write_enable) memclear(mmap_arg); mmap_arg.handle = bo_gem->gem_handle; mmap_arg.size = bo->size; - ret = drmIoctl(bufmgr_gem->fd, + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GEM_MMAP, &mmap_arg); if (ret != 0) { @@ -1324,8 +1314,8 @@ drm_bacon_bo_map(drm_bacon_bo *bo, int write_enable) __FILE__, __LINE__, bo_gem->gem_handle, bo_gem->name, strerror(errno)); if (--bo_gem->map_count == 0) - drm_bacon_gem_bo_close_vma(bufmgr_gem, bo_gem); - pthread_mutex_unlock(&bufmgr_gem->lock); + drm_bacon_gem_bo_close_vma(bufmgr, bo_gem); + pthread_mutex_unlock(&bufmgr->lock); return ret; } VG(VALGRIND_MALLOCLIKE_BLOCK(mmap_arg.addr_ptr, mmap_arg.size, 0, 1)); @@ -1342,7 +1332,7 @@ drm_bacon_bo_map(drm_bacon_bo *bo, int write_enable) set_domain.write_domain = I915_GEM_DOMAIN_CPU; else set_domain.write_domain = 0; - ret = drmIoctl(bufmgr_gem->fd, + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GEM_SET_DOMAIN, &set_domain); if (ret != 0) { @@ -1356,7 +1346,7 @@ drm_bacon_bo_map(drm_bacon_bo *bo, int write_enable) drm_bacon_gem_bo_mark_mmaps_incoherent(bo); VG(VALGRIND_MAKE_MEM_DEFINED(bo_gem->mem_virtual, bo->size)); - pthread_mutex_unlock(&bufmgr_gem->lock); + pthread_mutex_unlock(&bufmgr->lock); return 0; } @@ -1364,7 +1354,7 @@ drm_bacon_bo_map(drm_bacon_bo *bo, int write_enable) static int map_gtt(drm_bacon_bo *bo) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bo->bufmgr; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *) bo; int ret; @@ -1372,7 +1362,7 @@ map_gtt(drm_bacon_bo *bo) return -EINVAL; if (bo_gem->map_count++ == 0) - drm_bacon_gem_bo_open_vma(bufmgr_gem, bo_gem); + drm_bacon_gem_bo_open_vma(bufmgr, bo_gem); /* Get a mapping of the buffer if we haven't before. */ if (bo_gem->gtt_virtual == NULL) { @@ -1385,7 +1375,7 @@ map_gtt(drm_bacon_bo *bo) mmap_arg.handle = bo_gem->gem_handle; /* Get the fake offset back... */ - ret = drmIoctl(bufmgr_gem->fd, + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GEM_MMAP_GTT, &mmap_arg); if (ret != 0) { @@ -1395,13 +1385,13 @@ map_gtt(drm_bacon_bo *bo) bo_gem->gem_handle, bo_gem->name, strerror(errno)); if (--bo_gem->map_count == 0) - drm_bacon_gem_bo_close_vma(bufmgr_gem, bo_gem); + drm_bacon_gem_bo_close_vma(bufmgr, bo_gem); return ret; } /* and mmap it */ bo_gem->gtt_virtual = drm_mmap(0, bo->size, PROT_READ | PROT_WRITE, - MAP_SHARED, bufmgr_gem->fd, + MAP_SHARED, bufmgr->fd, mmap_arg.offset); if (bo_gem->gtt_virtual == MAP_FAILED) { bo_gem->gtt_virtual = NULL; @@ -1411,7 +1401,7 @@ map_gtt(drm_bacon_bo *bo) bo_gem->gem_handle, bo_gem->name, strerror(errno)); if (--bo_gem->map_count == 0) - drm_bacon_gem_bo_close_vma(bufmgr_gem, bo_gem); + drm_bacon_gem_bo_close_vma(bufmgr, bo_gem); return ret; } } @@ -1427,16 +1417,16 @@ map_gtt(drm_bacon_bo *bo) int drm_bacon_gem_bo_map_gtt(drm_bacon_bo *bo) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bo->bufmgr; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *) bo; struct drm_i915_gem_set_domain set_domain; int ret; - pthread_mutex_lock(&bufmgr_gem->lock); + pthread_mutex_lock(&bufmgr->lock); ret = map_gtt(bo); if (ret) { - pthread_mutex_unlock(&bufmgr_gem->lock); + pthread_mutex_unlock(&bufmgr->lock); return ret; } @@ -1453,7 +1443,7 @@ drm_bacon_gem_bo_map_gtt(drm_bacon_bo *bo) set_domain.handle = bo_gem->gem_handle; set_domain.read_domains = I915_GEM_DOMAIN_GTT; set_domain.write_domain = I915_GEM_DOMAIN_GTT; - ret = drmIoctl(bufmgr_gem->fd, + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GEM_SET_DOMAIN, &set_domain); if (ret != 0) { @@ -1464,7 +1454,7 @@ drm_bacon_gem_bo_map_gtt(drm_bacon_bo *bo) drm_bacon_gem_bo_mark_mmaps_incoherent(bo); VG(VALGRIND_MAKE_MEM_DEFINED(bo_gem->gtt_virtual, bo->size)); - pthread_mutex_unlock(&bufmgr_gem->lock); + pthread_mutex_unlock(&bufmgr->lock); return 0; } @@ -1486,7 +1476,7 @@ drm_bacon_gem_bo_map_gtt(drm_bacon_bo *bo) int drm_bacon_gem_bo_map_unsynchronized(drm_bacon_bo *bo) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bo->bufmgr; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; #ifdef HAVE_VALGRIND drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *) bo; #endif @@ -1499,10 +1489,10 @@ drm_bacon_gem_bo_map_unsynchronized(drm_bacon_bo *bo) * we would potentially corrupt the buffer even when the user * does reasonable things. */ - if (!bufmgr_gem->has_llc) + if (!bufmgr->has_llc) return drm_bacon_gem_bo_map_gtt(bo); - pthread_mutex_lock(&bufmgr_gem->lock); + pthread_mutex_lock(&bufmgr->lock); ret = map_gtt(bo); if (ret == 0) { @@ -1510,7 +1500,7 @@ drm_bacon_gem_bo_map_unsynchronized(drm_bacon_bo *bo) VG(VALGRIND_MAKE_MEM_DEFINED(bo_gem->gtt_virtual, bo->size)); } - pthread_mutex_unlock(&bufmgr_gem->lock); + pthread_mutex_unlock(&bufmgr->lock); return ret; } @@ -1518,7 +1508,7 @@ drm_bacon_gem_bo_map_unsynchronized(drm_bacon_bo *bo) int drm_bacon_bo_unmap(drm_bacon_bo *bo) { - drm_bacon_bufmgr_gem *bufmgr_gem; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *) bo; int ret = 0; @@ -1528,13 +1518,11 @@ drm_bacon_bo_unmap(drm_bacon_bo *bo) if (bo_gem->is_userptr) return 0; - bufmgr_gem = (drm_bacon_bufmgr_gem *) bo->bufmgr; - - pthread_mutex_lock(&bufmgr_gem->lock); + pthread_mutex_lock(&bufmgr->lock); if (bo_gem->map_count <= 0) { DBG("attempted to unmap an unmapped bo\n"); - pthread_mutex_unlock(&bufmgr_gem->lock); + pthread_mutex_unlock(&bufmgr->lock); /* Preserve the old behaviour of just treating this as a * no-op rather than reporting the error. */ @@ -1551,7 +1539,7 @@ drm_bacon_bo_unmap(drm_bacon_bo *bo) */ memclear(sw_finish); sw_finish.handle = bo_gem->gem_handle; - ret = drmIoctl(bufmgr_gem->fd, + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GEM_SW_FINISH, &sw_finish); ret = ret == -1 ? -errno : 0; @@ -1564,11 +1552,11 @@ drm_bacon_bo_unmap(drm_bacon_bo *bo) * limits and cause later failures. */ if (--bo_gem->map_count == 0) { - drm_bacon_gem_bo_close_vma(bufmgr_gem, bo_gem); + drm_bacon_gem_bo_close_vma(bufmgr, bo_gem); drm_bacon_gem_bo_mark_mmaps_incoherent(bo); bo->virtual = NULL; } - pthread_mutex_unlock(&bufmgr_gem->lock); + pthread_mutex_unlock(&bufmgr->lock); return ret; } @@ -1577,7 +1565,7 @@ int drm_bacon_bo_subdata(drm_bacon_bo *bo, unsigned long offset, unsigned long size, const void *data) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bo->bufmgr; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *) bo; struct drm_i915_gem_pwrite pwrite; int ret; @@ -1590,7 +1578,7 @@ drm_bacon_bo_subdata(drm_bacon_bo *bo, unsigned long offset, pwrite.offset = offset; pwrite.size = size; pwrite.data_ptr = (uint64_t) (uintptr_t) data; - ret = drmIoctl(bufmgr_gem->fd, + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GEM_PWRITE, &pwrite); if (ret != 0) { @@ -1607,7 +1595,7 @@ int drm_bacon_bo_get_subdata(drm_bacon_bo *bo, unsigned long offset, unsigned long size, void *data) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bo->bufmgr; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *) bo; struct drm_i915_gem_pread pread; int ret; @@ -1620,7 +1608,7 @@ drm_bacon_bo_get_subdata(drm_bacon_bo *bo, unsigned long offset, pread.offset = offset; pread.size = size; pread.data_ptr = (uint64_t) (uintptr_t) data; - ret = drmIoctl(bufmgr_gem->fd, + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GEM_PREAD, &pread); if (ret != 0) { @@ -1670,12 +1658,12 @@ drm_bacon_bo_wait_rendering(drm_bacon_bo *bo) int drm_bacon_gem_bo_wait(drm_bacon_bo *bo, int64_t timeout_ns) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bo->bufmgr; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *) bo; struct drm_i915_gem_wait wait; int ret; - if (!bufmgr_gem->has_wait_timeout) { + if (!bufmgr->has_wait_timeout) { DBG("%s:%d: Timed wait is not supported. Falling back to " "infinite wait\n", __FILE__, __LINE__); if (timeout_ns) { @@ -1689,7 +1677,7 @@ drm_bacon_gem_bo_wait(drm_bacon_bo *bo, int64_t timeout_ns) memclear(wait); wait.bo_handle = bo_gem->gem_handle; wait.timeout_ns = timeout_ns; - ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_WAIT, &wait); + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GEM_WAIT, &wait); if (ret == -1) return -errno; @@ -1706,7 +1694,7 @@ drm_bacon_gem_bo_wait(drm_bacon_bo *bo, int64_t timeout_ns) void drm_bacon_gem_bo_start_gtt_access(drm_bacon_bo *bo, int write_enable) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bo->bufmgr; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *) bo; struct drm_i915_gem_set_domain set_domain; int ret; @@ -1715,7 +1703,7 @@ drm_bacon_gem_bo_start_gtt_access(drm_bacon_bo *bo, int write_enable) set_domain.handle = bo_gem->gem_handle; set_domain.read_domains = I915_GEM_DOMAIN_GTT; set_domain.write_domain = write_enable ? I915_GEM_DOMAIN_GTT : 0; - ret = drmIoctl(bufmgr_gem->fd, + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GEM_SET_DOMAIN, &set_domain); if (ret != 0) { @@ -1729,19 +1717,18 @@ drm_bacon_gem_bo_start_gtt_access(drm_bacon_bo *bo, int write_enable) static void drm_bacon_bufmgr_gem_destroy(drm_bacon_bufmgr *bufmgr) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bufmgr; struct drm_gem_close close_bo; int i, ret; - free(bufmgr_gem->exec2_objects); - free(bufmgr_gem->exec_bos); + free(bufmgr->exec2_objects); + free(bufmgr->exec_bos); - pthread_mutex_destroy(&bufmgr_gem->lock); + pthread_mutex_destroy(&bufmgr->lock); /* Free any cached buffer objects we were going to reuse */ - for (i = 0; i < bufmgr_gem->num_buckets; i++) { + for (i = 0; i < bufmgr->num_buckets; i++) { struct drm_bacon_gem_bo_bucket *bucket = - &bufmgr_gem->cache_bucket[i]; + &bufmgr->cache_bucket[i]; drm_bacon_bo_gem *bo_gem; while (!list_empty(&bucket->head)) { @@ -1754,11 +1741,11 @@ drm_bacon_bufmgr_gem_destroy(drm_bacon_bufmgr *bufmgr) } /* Release userptr bo kept hanging around for optimisation. */ - if (bufmgr_gem->userptr_active.ptr) { + if (bufmgr->userptr_active.ptr) { memclear(close_bo); - close_bo.handle = bufmgr_gem->userptr_active.handle; - ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_GEM_CLOSE, &close_bo); - free(bufmgr_gem->userptr_active.ptr); + close_bo.handle = bufmgr->userptr_active.handle; + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_GEM_CLOSE, &close_bo); + free(bufmgr->userptr_active.ptr); if (ret) fprintf(stderr, "Failed to release test userptr object! (%d) " @@ -1782,7 +1769,7 @@ do_bo_emit_reloc(drm_bacon_bo *bo, uint32_t offset, drm_bacon_bo *target_bo, uint32_t target_offset, uint32_t read_domains, uint32_t write_domain) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bo->bufmgr; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *) bo; drm_bacon_bo_gem *target_bo_gem = (drm_bacon_bo_gem *) target_bo; @@ -1799,7 +1786,7 @@ do_bo_emit_reloc(drm_bacon_bo *bo, uint32_t offset, return -ENOMEM; /* Check overflow */ - assert(bo_gem->reloc_count < bufmgr_gem->max_relocs); + assert(bo_gem->reloc_count < bufmgr->max_relocs); /* Check args */ assert(offset <= bo->size - 4); @@ -1833,7 +1820,7 @@ do_bo_emit_reloc(drm_bacon_bo *bo, uint32_t offset, static int drm_bacon_gem_bo_add_softpin_target(drm_bacon_bo *bo, drm_bacon_bo *target_bo) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bo->bufmgr; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *) bo; drm_bacon_bo_gem *target_bo_gem = (drm_bacon_bo_gem *) target_bo; @@ -1853,7 +1840,7 @@ drm_bacon_gem_bo_add_softpin_target(drm_bacon_bo *bo, drm_bacon_bo *target_bo) if (bo_gem->softpin_target_count == bo_gem->softpin_target_size) { int new_size = bo_gem->softpin_target_size * 2; if (new_size == 0) - new_size = bufmgr_gem->max_relocs; + new_size = bufmgr->max_relocs; bo_gem->softpin_target = realloc(bo_gem->softpin_target, new_size * sizeof(drm_bacon_bo *)); @@ -1909,7 +1896,7 @@ drm_bacon_gem_bo_get_reloc_count(drm_bacon_bo *bo) void drm_bacon_gem_bo_clear_relocs(drm_bacon_bo *bo, int start) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bo->bufmgr; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *) bo; int i; struct timespec time; @@ -1919,7 +1906,7 @@ drm_bacon_gem_bo_clear_relocs(drm_bacon_bo *bo, int start) assert(bo_gem->reloc_count >= start); /* Unreference the cleared target buffers */ - pthread_mutex_lock(&bufmgr_gem->lock); + pthread_mutex_lock(&bufmgr->lock); for (i = start; i < bo_gem->reloc_count; i++) { drm_bacon_bo_gem *target_bo_gem = (drm_bacon_bo_gem *) bo_gem->reloc_target_info[i].bo; @@ -1936,7 +1923,7 @@ drm_bacon_gem_bo_clear_relocs(drm_bacon_bo *bo, int start) } bo_gem->softpin_target_count = 0; - pthread_mutex_unlock(&bufmgr_gem->lock); + pthread_mutex_unlock(&bufmgr->lock); } @@ -1977,16 +1964,16 @@ drm_bacon_gem_bo_process_reloc2(drm_bacon_bo *bo) } static void -drm_bacon_update_buffer_offsets2 (drm_bacon_bufmgr_gem *bufmgr_gem) +drm_bacon_update_buffer_offsets2 (drm_bacon_bufmgr *bufmgr) { int i; - for (i = 0; i < bufmgr_gem->exec_count; i++) { - drm_bacon_bo *bo = bufmgr_gem->exec_bos[i]; + for (i = 0; i < bufmgr->exec_count; i++) { + drm_bacon_bo *bo = bufmgr->exec_bos[i]; drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *)bo; /* Update the buffer offset */ - if (bufmgr_gem->exec2_objects[i].offset != bo->offset64) { + if (bufmgr->exec2_objects[i].offset != bo->offset64) { /* If we're seeing softpinned object here it means that the kernel * has relocated our object... Indicating a programming error */ @@ -1995,10 +1982,10 @@ drm_bacon_update_buffer_offsets2 (drm_bacon_bufmgr_gem *bufmgr_gem) bo_gem->gem_handle, bo_gem->name, upper_32_bits(bo->offset64), lower_32_bits(bo->offset64), - upper_32_bits(bufmgr_gem->exec2_objects[i].offset), - lower_32_bits(bufmgr_gem->exec2_objects[i].offset)); - bo->offset64 = bufmgr_gem->exec2_objects[i].offset; - bo->offset = bufmgr_gem->exec2_objects[i].offset; + upper_32_bits(bufmgr->exec2_objects[i].offset), + lower_32_bits(bufmgr->exec2_objects[i].offset)); + bo->offset64 = bufmgr->exec2_objects[i].offset; + bo->offset = bufmgr->exec2_objects[i].offset; } } } @@ -2008,7 +1995,7 @@ do_exec2(drm_bacon_bo *bo, int used, drm_bacon_context *ctx, int in_fence, int *out_fence, unsigned int flags) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *)bo->bufmgr; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; struct drm_i915_gem_execbuffer2 execbuf; int ret = 0; int i; @@ -2020,15 +2007,15 @@ do_exec2(drm_bacon_bo *bo, int used, drm_bacon_context *ctx, default: return -EINVAL; case I915_EXEC_BLT: - if (!bufmgr_gem->has_blt) + if (!bufmgr->has_blt) return -EINVAL; break; case I915_EXEC_BSD: - if (!bufmgr_gem->has_bsd) + if (!bufmgr->has_bsd) return -EINVAL; break; case I915_EXEC_VEBOX: - if (!bufmgr_gem->has_vebox) + if (!bufmgr->has_vebox) return -EINVAL; break; case I915_EXEC_RENDER: @@ -2036,7 +2023,7 @@ do_exec2(drm_bacon_bo *bo, int used, drm_bacon_context *ctx, break; } - pthread_mutex_lock(&bufmgr_gem->lock); + pthread_mutex_lock(&bufmgr->lock); /* Update indices and set up the validate list. */ drm_bacon_gem_bo_process_reloc2(bo); @@ -2046,8 +2033,8 @@ do_exec2(drm_bacon_bo *bo, int used, drm_bacon_context *ctx, drm_bacon_add_validate_buffer2(bo); memclear(execbuf); - execbuf.buffers_ptr = (uintptr_t)bufmgr_gem->exec2_objects; - execbuf.buffer_count = bufmgr_gem->exec_count; + execbuf.buffers_ptr = (uintptr_t)bufmgr->exec2_objects; + execbuf.buffer_count = bufmgr->exec_count; execbuf.batch_start_offset = 0; execbuf.batch_len = used; execbuf.cliprects_ptr = 0; @@ -2069,10 +2056,10 @@ do_exec2(drm_bacon_bo *bo, int used, drm_bacon_context *ctx, execbuf.flags |= I915_EXEC_FENCE_OUT; } - if (bufmgr_gem->no_exec) + if (bufmgr->no_exec) goto skip_execution; - ret = drmIoctl(bufmgr_gem->fd, + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GEM_EXECBUFFER2_WR, &execbuf); if (ret != 0) { @@ -2080,33 +2067,33 @@ do_exec2(drm_bacon_bo *bo, int used, drm_bacon_context *ctx, if (ret == -ENOSPC) { DBG("Execbuffer fails to pin. " "Estimate: %u. Actual: %u. Available: %u\n", - drm_bacon_gem_estimate_batch_space(bufmgr_gem->exec_bos, - bufmgr_gem->exec_count), - drm_bacon_gem_compute_batch_space(bufmgr_gem->exec_bos, - bufmgr_gem->exec_count), - (unsigned int) bufmgr_gem->gtt_size); + drm_bacon_gem_estimate_batch_space(bufmgr->exec_bos, + bufmgr->exec_count), + drm_bacon_gem_compute_batch_space(bufmgr->exec_bos, + bufmgr->exec_count), + (unsigned int) bufmgr->gtt_size); } } - drm_bacon_update_buffer_offsets2(bufmgr_gem); + drm_bacon_update_buffer_offsets2(bufmgr); if (ret == 0 && out_fence != NULL) *out_fence = execbuf.rsvd2 >> 32; skip_execution: if (INTEL_DEBUG & DEBUG_BUFMGR) - drm_bacon_gem_dump_validation_list(bufmgr_gem); + drm_bacon_gem_dump_validation_list(bufmgr); - for (i = 0; i < bufmgr_gem->exec_count; i++) { - drm_bacon_bo_gem *bo_gem = to_bo_gem(bufmgr_gem->exec_bos[i]); + for (i = 0; i < bufmgr->exec_count; i++) { + drm_bacon_bo_gem *bo_gem = to_bo_gem(bufmgr->exec_bos[i]); bo_gem->idle = false; /* Disconnect the buffer from the validate list */ bo_gem->validate_index = -1; - bufmgr_gem->exec_bos[i] = NULL; + bufmgr->exec_bos[i] = NULL; } - bufmgr_gem->exec_count = 0; - pthread_mutex_unlock(&bufmgr_gem->lock); + bufmgr->exec_count = 0; + pthread_mutex_unlock(&bufmgr->lock); return ret; } @@ -2146,7 +2133,7 @@ drm_bacon_gem_bo_set_tiling_internal(drm_bacon_bo *bo, uint32_t tiling_mode, uint32_t stride) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bo->bufmgr; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *) bo; struct drm_i915_gem_set_tiling set_tiling; int ret; @@ -2166,7 +2153,7 @@ drm_bacon_gem_bo_set_tiling_internal(drm_bacon_bo *bo, set_tiling.tiling_mode = tiling_mode; set_tiling.stride = stride; - ret = ioctl(bufmgr_gem->fd, + ret = ioctl(bufmgr->fd, DRM_IOCTL_I915_GEM_SET_TILING, &set_tiling); } while (ret == -1 && (errno == EINTR || errno == EAGAIN)); @@ -2183,7 +2170,7 @@ int drm_bacon_bo_set_tiling(drm_bacon_bo *bo, uint32_t * tiling_mode, uint32_t stride) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bo->bufmgr; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *) bo; int ret; @@ -2201,7 +2188,7 @@ drm_bacon_bo_set_tiling(drm_bacon_bo *bo, uint32_t * tiling_mode, ret = drm_bacon_gem_bo_set_tiling_internal(bo, *tiling_mode, stride); if (ret == 0) - drm_bacon_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem, 0); + drm_bacon_bo_gem_set_in_aperture_size(bufmgr, bo_gem, 0); *tiling_mode = bo_gem->tiling_mode; return ret; @@ -2233,17 +2220,16 @@ drm_bacon_bo_set_softpin_offset(drm_bacon_bo *bo, uint64_t offset) drm_bacon_bo * drm_bacon_bo_gem_create_from_prime(drm_bacon_bufmgr *bufmgr, int prime_fd, int size) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bufmgr; int ret; uint32_t handle; drm_bacon_bo_gem *bo_gem; struct drm_i915_gem_get_tiling get_tiling; - pthread_mutex_lock(&bufmgr_gem->lock); - ret = drmPrimeFDToHandle(bufmgr_gem->fd, prime_fd, &handle); + pthread_mutex_lock(&bufmgr->lock); + ret = drmPrimeFDToHandle(bufmgr->fd, prime_fd, &handle); if (ret) { DBG("create_from_prime: failed to obtain handle from fd: %s\n", strerror(errno)); - pthread_mutex_unlock(&bufmgr_gem->lock); + pthread_mutex_unlock(&bufmgr->lock); return NULL; } @@ -2252,7 +2238,7 @@ drm_bacon_bo_gem_create_from_prime(drm_bacon_bufmgr *bufmgr, int prime_fd, int s * for named buffers, we must not create two bo's pointing at the same * kernel object */ - HASH_FIND(handle_hh, bufmgr_gem->handle_table, + HASH_FIND(handle_hh, bufmgr->handle_table, &handle, sizeof(handle), bo_gem); if (bo_gem) { drm_bacon_bo_reference(&bo_gem->bo); @@ -2281,7 +2267,7 @@ drm_bacon_bo_gem_create_from_prime(drm_bacon_bufmgr *bufmgr, int prime_fd, int s bo_gem->bo.bufmgr = bufmgr; bo_gem->gem_handle = handle; - HASH_ADD(handle_hh, bufmgr_gem->handle_table, + HASH_ADD(handle_hh, bufmgr->handle_table, gem_handle, sizeof(bo_gem->gem_handle), bo_gem); bo_gem->name = "prime"; @@ -2292,7 +2278,7 @@ drm_bacon_bo_gem_create_from_prime(drm_bacon_bufmgr *bufmgr, int prime_fd, int s memclear(get_tiling); get_tiling.handle = bo_gem->gem_handle; - if (drmIoctl(bufmgr_gem->fd, + if (drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GEM_GET_TILING, &get_tiling)) goto err; @@ -2300,25 +2286,25 @@ drm_bacon_bo_gem_create_from_prime(drm_bacon_bufmgr *bufmgr, int prime_fd, int s bo_gem->tiling_mode = get_tiling.tiling_mode; bo_gem->swizzle_mode = get_tiling.swizzle_mode; /* XXX stride is unknown */ - drm_bacon_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem, 0); + drm_bacon_bo_gem_set_in_aperture_size(bufmgr, bo_gem, 0); out: - pthread_mutex_unlock(&bufmgr_gem->lock); + pthread_mutex_unlock(&bufmgr->lock); return &bo_gem->bo; err: drm_bacon_gem_bo_free(&bo_gem->bo); - pthread_mutex_unlock(&bufmgr_gem->lock); + pthread_mutex_unlock(&bufmgr->lock); return NULL; } int drm_bacon_bo_gem_export_to_prime(drm_bacon_bo *bo, int *prime_fd) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bo->bufmgr; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *) bo; - if (drmPrimeHandleToFD(bufmgr_gem->fd, bo_gem->gem_handle, + if (drmPrimeHandleToFD(bufmgr->fd, bo_gem->gem_handle, DRM_CLOEXEC, prime_fd) != 0) return -errno; @@ -2330,7 +2316,7 @@ drm_bacon_bo_gem_export_to_prime(drm_bacon_bo *bo, int *prime_fd) int drm_bacon_bo_flink(drm_bacon_bo *bo, uint32_t *name) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bo->bufmgr; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *) bo; if (!bo_gem->global_name) { @@ -2338,19 +2324,19 @@ drm_bacon_bo_flink(drm_bacon_bo *bo, uint32_t *name) memclear(flink); flink.handle = bo_gem->gem_handle; - if (drmIoctl(bufmgr_gem->fd, DRM_IOCTL_GEM_FLINK, &flink)) + if (drmIoctl(bufmgr->fd, DRM_IOCTL_GEM_FLINK, &flink)) return -errno; - pthread_mutex_lock(&bufmgr_gem->lock); + pthread_mutex_lock(&bufmgr->lock); if (!bo_gem->global_name) { bo_gem->global_name = flink.name; bo_gem->reusable = false; - HASH_ADD(name_hh, bufmgr_gem->name_table, + HASH_ADD(name_hh, bufmgr->name_table, global_name, sizeof(bo_gem->global_name), bo_gem); } - pthread_mutex_unlock(&bufmgr_gem->lock); + pthread_mutex_unlock(&bufmgr->lock); } *name = bo_gem->global_name; @@ -2367,9 +2353,7 @@ drm_bacon_bo_flink(drm_bacon_bo *bo, uint32_t *name) void drm_bacon_bufmgr_gem_enable_reuse(drm_bacon_bufmgr *bufmgr) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bufmgr; - - bufmgr_gem->bo_reuse = true; + bufmgr->bo_reuse = true; } /** @@ -2420,9 +2404,7 @@ drm_bacon_gem_bo_enable_implicit_sync(drm_bacon_bo *bo) int drm_bacon_bufmgr_gem_can_disable_implicit_sync(drm_bacon_bufmgr *bufmgr) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bufmgr; - - return bufmgr_gem->has_exec_async; + return bufmgr->has_exec_async; } /** @@ -2541,10 +2523,9 @@ drm_bacon_gem_compute_batch_space(drm_bacon_bo **bo_array, int count) int drm_bacon_bufmgr_check_aperture_space(drm_bacon_bo **bo_array, int count) { - drm_bacon_bufmgr_gem *bufmgr_gem = - (drm_bacon_bufmgr_gem *) bo_array[0]->bufmgr; + drm_bacon_bufmgr *bufmgr = bo_array[0]->bufmgr; unsigned int total = 0; - unsigned int threshold = bufmgr_gem->gtt_size * 3 / 4; + unsigned int threshold = bufmgr->gtt_size * 3 / 4; total = drm_bacon_gem_estimate_batch_space(bo_array, count); @@ -2554,11 +2535,11 @@ drm_bacon_bufmgr_check_aperture_space(drm_bacon_bo **bo_array, int count) if (total > threshold) { DBG("check_space: overflowed available aperture, " "%dkb vs %dkb\n", - total / 1024, (int)bufmgr_gem->gtt_size / 1024); + total / 1024, (int)bufmgr->gtt_size / 1024); return -ENOSPC; } else { DBG("drm_check_space: total %dkb vs bufgr %dkb\n", total / 1024, - (int)bufmgr_gem->gtt_size / 1024); + (int)bufmgr->gtt_size / 1024); return 0; } } @@ -2624,19 +2605,19 @@ drm_bacon_bo_references(drm_bacon_bo *bo, drm_bacon_bo *target_bo) } static void -add_bucket(drm_bacon_bufmgr_gem *bufmgr_gem, int size) +add_bucket(drm_bacon_bufmgr *bufmgr, int size) { - unsigned int i = bufmgr_gem->num_buckets; + unsigned int i = bufmgr->num_buckets; - assert(i < ARRAY_SIZE(bufmgr_gem->cache_bucket)); + assert(i < ARRAY_SIZE(bufmgr->cache_bucket)); - list_inithead(&bufmgr_gem->cache_bucket[i].head); - bufmgr_gem->cache_bucket[i].size = size; - bufmgr_gem->num_buckets++; + list_inithead(&bufmgr->cache_bucket[i].head); + bufmgr->cache_bucket[i].size = size; + bufmgr->num_buckets++; } static void -init_cache_buckets(drm_bacon_bufmgr_gem *bufmgr_gem) +init_cache_buckets(drm_bacon_bufmgr *bufmgr) { unsigned long size, cache_max_size = 64 * 1024 * 1024; @@ -2648,28 +2629,26 @@ init_cache_buckets(drm_bacon_bufmgr_gem *bufmgr_gem) * width/height alignment and rounding of sizes to pages will * get us useful cache hit rates anyway) */ - add_bucket(bufmgr_gem, 4096); - add_bucket(bufmgr_gem, 4096 * 2); - add_bucket(bufmgr_gem, 4096 * 3); + add_bucket(bufmgr, 4096); + add_bucket(bufmgr, 4096 * 2); + add_bucket(bufmgr, 4096 * 3); /* Initialize the linked lists for BO reuse cache. */ for (size = 4 * 4096; size <= cache_max_size; size *= 2) { - add_bucket(bufmgr_gem, size); + add_bucket(bufmgr, size); - add_bucket(bufmgr_gem, size + size * 1 / 4); - add_bucket(bufmgr_gem, size + size * 2 / 4); - add_bucket(bufmgr_gem, size + size * 3 / 4); + add_bucket(bufmgr, size + size * 1 / 4); + add_bucket(bufmgr, size + size * 2 / 4); + add_bucket(bufmgr, size + size * 3 / 4); } } void drm_bacon_bufmgr_gem_set_vma_cache_size(drm_bacon_bufmgr *bufmgr, int limit) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *)bufmgr; + bufmgr->vma_max = limit; - bufmgr_gem->vma_max = limit; - - drm_bacon_gem_bo_purge_vma_cache(bufmgr_gem); + drm_bacon_gem_bo_purge_vma_cache(bufmgr); } static int @@ -2705,7 +2684,7 @@ parse_devid_override(const char *devid_override) * INTEL_DEVID_OVERRIDE environment variable to the desired ID. */ static int -get_pci_device_id(drm_bacon_bufmgr_gem *bufmgr_gem) +get_pci_device_id(drm_bacon_bufmgr *bufmgr) { char *devid_override; int devid = 0; @@ -2715,7 +2694,7 @@ get_pci_device_id(drm_bacon_bufmgr_gem *bufmgr_gem) if (geteuid() == getuid()) { devid_override = getenv("INTEL_DEVID_OVERRIDE"); if (devid_override) { - bufmgr_gem->no_exec = true; + bufmgr->no_exec = true; return parse_devid_override(devid_override); } } @@ -2723,7 +2702,7 @@ get_pci_device_id(drm_bacon_bufmgr_gem *bufmgr_gem) memclear(gp); gp.param = I915_PARAM_CHIPSET_ID; gp.value = &devid; - ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp); + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GETPARAM, &gp); if (ret) { fprintf(stderr, "get chip id failed: %d [%d]\n", ret, errno); fprintf(stderr, "param: %d, val: %d\n", gp.param, *gp.value); @@ -2734,15 +2713,12 @@ get_pci_device_id(drm_bacon_bufmgr_gem *bufmgr_gem) int drm_bacon_bufmgr_gem_get_devid(drm_bacon_bufmgr *bufmgr) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *)bufmgr; - - return bufmgr_gem->pci_device; + return bufmgr->pci_device; } drm_bacon_context * drm_bacon_gem_context_create(drm_bacon_bufmgr *bufmgr) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *)bufmgr; struct drm_i915_gem_context_create create; drm_bacon_context *context = NULL; int ret; @@ -2752,7 +2728,7 @@ drm_bacon_gem_context_create(drm_bacon_bufmgr *bufmgr) return NULL; memclear(create); - ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_CONTEXT_CREATE, &create); + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GEM_CONTEXT_CREATE, &create); if (ret != 0) { DBG("DRM_IOCTL_I915_GEM_CONTEXT_CREATE failed: %s\n", strerror(errno)); @@ -2780,7 +2756,6 @@ drm_bacon_gem_context_get_id(drm_bacon_context *ctx, uint32_t *ctx_id) void drm_bacon_gem_context_destroy(drm_bacon_context *ctx) { - drm_bacon_bufmgr_gem *bufmgr_gem; struct drm_i915_gem_context_destroy destroy; int ret; @@ -2789,9 +2764,8 @@ drm_bacon_gem_context_destroy(drm_bacon_context *ctx) memclear(destroy); - bufmgr_gem = (drm_bacon_bufmgr_gem *)ctx->bufmgr; destroy.ctx_id = ctx->ctx_id; - ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_CONTEXT_DESTROY, + ret = drmIoctl(ctx->bufmgr->fd, DRM_IOCTL_I915_GEM_CONTEXT_DESTROY, &destroy); if (ret != 0) fprintf(stderr, "DRM_IOCTL_I915_GEM_CONTEXT_DESTROY failed: %s\n", @@ -2806,7 +2780,6 @@ drm_bacon_get_reset_stats(drm_bacon_context *ctx, uint32_t *active, uint32_t *pending) { - drm_bacon_bufmgr_gem *bufmgr_gem; struct drm_i915_reset_stats stats; int ret; @@ -2815,9 +2788,8 @@ drm_bacon_get_reset_stats(drm_bacon_context *ctx, memclear(stats); - bufmgr_gem = (drm_bacon_bufmgr_gem *)ctx->bufmgr; stats.ctx_id = ctx->ctx_id; - ret = drmIoctl(bufmgr_gem->fd, + ret = drmIoctl(ctx->bufmgr->fd, DRM_IOCTL_I915_GET_RESET_STATS, &stats); if (ret == 0) { @@ -2839,14 +2811,13 @@ drm_bacon_reg_read(drm_bacon_bufmgr *bufmgr, uint32_t offset, uint64_t *result) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *)bufmgr; struct drm_i915_reg_read reg_read; int ret; memclear(reg_read); reg_read.offset = offset; - ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_REG_READ, ®_read); + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_REG_READ, ®_read); *result = reg_read.val; return ret; @@ -2855,14 +2826,14 @@ drm_bacon_reg_read(drm_bacon_bufmgr *bufmgr, static pthread_mutex_t bufmgr_list_mutex = PTHREAD_MUTEX_INITIALIZER; static struct list_head bufmgr_list = { &bufmgr_list, &bufmgr_list }; -static drm_bacon_bufmgr_gem * +static drm_bacon_bufmgr * drm_bacon_bufmgr_gem_find(int fd) { - list_for_each_entry(drm_bacon_bufmgr_gem, - bufmgr_gem, &bufmgr_list, managers) { - if (bufmgr_gem->fd == fd) { - p_atomic_inc(&bufmgr_gem->refcount); - return bufmgr_gem; + list_for_each_entry(drm_bacon_bufmgr, + bufmgr, &bufmgr_list, managers) { + if (bufmgr->fd == fd) { + p_atomic_inc(&bufmgr->refcount); + return bufmgr; } } @@ -2872,13 +2843,11 @@ drm_bacon_bufmgr_gem_find(int fd) void drm_bacon_bufmgr_destroy(drm_bacon_bufmgr *bufmgr) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *)bufmgr; - - if (atomic_add_unless(&bufmgr_gem->refcount, -1, 1)) { + if (atomic_add_unless(&bufmgr->refcount, -1, 1)) { pthread_mutex_lock(&bufmgr_list_mutex); - if (p_atomic_dec_zero(&bufmgr_gem->refcount)) { - list_del(&bufmgr_gem->managers); + if (p_atomic_dec_zero(&bufmgr->refcount)) { + list_del(&bufmgr->managers); drm_bacon_bufmgr_gem_destroy(bufmgr); } @@ -2888,7 +2857,7 @@ drm_bacon_bufmgr_destroy(drm_bacon_bufmgr *bufmgr) void *drm_bacon_gem_bo_map__gtt(drm_bacon_bo *bo) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bo->bufmgr; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *) bo; if (bo_gem->gtt_virtual) @@ -2897,7 +2866,7 @@ void *drm_bacon_gem_bo_map__gtt(drm_bacon_bo *bo) if (bo_gem->is_userptr) return NULL; - pthread_mutex_lock(&bufmgr_gem->lock); + pthread_mutex_lock(&bufmgr->lock); if (bo_gem->gtt_virtual == NULL) { struct drm_i915_gem_mmap_gtt mmap_arg; void *ptr; @@ -2906,37 +2875,37 @@ void *drm_bacon_gem_bo_map__gtt(drm_bacon_bo *bo) bo_gem->gem_handle, bo_gem->name, bo_gem->map_count); if (bo_gem->map_count++ == 0) - drm_bacon_gem_bo_open_vma(bufmgr_gem, bo_gem); + drm_bacon_gem_bo_open_vma(bufmgr, bo_gem); memclear(mmap_arg); mmap_arg.handle = bo_gem->gem_handle; /* Get the fake offset back... */ ptr = MAP_FAILED; - if (drmIoctl(bufmgr_gem->fd, + if (drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GEM_MMAP_GTT, &mmap_arg) == 0) { /* and mmap it */ ptr = drm_mmap(0, bo->size, PROT_READ | PROT_WRITE, - MAP_SHARED, bufmgr_gem->fd, + MAP_SHARED, bufmgr->fd, mmap_arg.offset); } if (ptr == MAP_FAILED) { if (--bo_gem->map_count == 0) - drm_bacon_gem_bo_close_vma(bufmgr_gem, bo_gem); + drm_bacon_gem_bo_close_vma(bufmgr, bo_gem); ptr = NULL; } bo_gem->gtt_virtual = ptr; } - pthread_mutex_unlock(&bufmgr_gem->lock); + pthread_mutex_unlock(&bufmgr->lock); return bo_gem->gtt_virtual; } void *drm_bacon_gem_bo_map__cpu(drm_bacon_bo *bo) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bo->bufmgr; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *) bo; if (bo_gem->mem_virtual) @@ -2947,12 +2916,12 @@ void *drm_bacon_gem_bo_map__cpu(drm_bacon_bo *bo) return bo_gem->user_virtual; } - pthread_mutex_lock(&bufmgr_gem->lock); + pthread_mutex_lock(&bufmgr->lock); if (!bo_gem->mem_virtual) { struct drm_i915_gem_mmap mmap_arg; if (bo_gem->map_count++ == 0) - drm_bacon_gem_bo_open_vma(bufmgr_gem, bo_gem); + drm_bacon_gem_bo_open_vma(bufmgr, bo_gem); DBG("bo_map: %d (%s), map_count=%d\n", bo_gem->gem_handle, bo_gem->name, bo_gem->map_count); @@ -2960,27 +2929,27 @@ void *drm_bacon_gem_bo_map__cpu(drm_bacon_bo *bo) memclear(mmap_arg); mmap_arg.handle = bo_gem->gem_handle; mmap_arg.size = bo->size; - if (drmIoctl(bufmgr_gem->fd, + if (drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GEM_MMAP, &mmap_arg)) { DBG("%s:%d: Error mapping buffer %d (%s): %s .\n", __FILE__, __LINE__, bo_gem->gem_handle, bo_gem->name, strerror(errno)); if (--bo_gem->map_count == 0) - drm_bacon_gem_bo_close_vma(bufmgr_gem, bo_gem); + drm_bacon_gem_bo_close_vma(bufmgr, bo_gem); } else { VG(VALGRIND_MALLOCLIKE_BLOCK(mmap_arg.addr_ptr, mmap_arg.size, 0, 1)); bo_gem->mem_virtual = (void *)(uintptr_t) mmap_arg.addr_ptr; } } - pthread_mutex_unlock(&bufmgr_gem->lock); + pthread_mutex_unlock(&bufmgr->lock); return bo_gem->mem_virtual; } void *drm_bacon_gem_bo_map__wc(drm_bacon_bo *bo) { - drm_bacon_bufmgr_gem *bufmgr_gem = (drm_bacon_bufmgr_gem *) bo->bufmgr; + drm_bacon_bufmgr *bufmgr = bo->bufmgr; drm_bacon_bo_gem *bo_gem = (drm_bacon_bo_gem *) bo; if (bo_gem->wc_virtual) @@ -2989,12 +2958,12 @@ void *drm_bacon_gem_bo_map__wc(drm_bacon_bo *bo) if (bo_gem->is_userptr) return NULL; - pthread_mutex_lock(&bufmgr_gem->lock); + pthread_mutex_lock(&bufmgr->lock); if (!bo_gem->wc_virtual) { struct drm_i915_gem_mmap mmap_arg; if (bo_gem->map_count++ == 0) - drm_bacon_gem_bo_open_vma(bufmgr_gem, bo_gem); + drm_bacon_gem_bo_open_vma(bufmgr, bo_gem); DBG("bo_map: %d (%s), map_count=%d\n", bo_gem->gem_handle, bo_gem->name, bo_gem->map_count); @@ -3003,20 +2972,20 @@ void *drm_bacon_gem_bo_map__wc(drm_bacon_bo *bo) mmap_arg.handle = bo_gem->gem_handle; mmap_arg.size = bo->size; mmap_arg.flags = I915_MMAP_WC; - if (drmIoctl(bufmgr_gem->fd, + if (drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GEM_MMAP, &mmap_arg)) { DBG("%s:%d: Error mapping buffer %d (%s): %s .\n", __FILE__, __LINE__, bo_gem->gem_handle, bo_gem->name, strerror(errno)); if (--bo_gem->map_count == 0) - drm_bacon_gem_bo_close_vma(bufmgr_gem, bo_gem); + drm_bacon_gem_bo_close_vma(bufmgr, bo_gem); } else { VG(VALGRIND_MALLOCLIKE_BLOCK(mmap_arg.addr_ptr, mmap_arg.size, 0, 1)); bo_gem->wc_virtual = (void *)(uintptr_t) mmap_arg.addr_ptr; } } - pthread_mutex_unlock(&bufmgr_gem->lock); + pthread_mutex_unlock(&bufmgr->lock); return bo_gem->wc_virtual; } @@ -3030,64 +2999,64 @@ void *drm_bacon_gem_bo_map__wc(drm_bacon_bo *bo) drm_bacon_bufmgr * drm_bacon_bufmgr_gem_init(int fd, int batch_size) { - drm_bacon_bufmgr_gem *bufmgr_gem; + drm_bacon_bufmgr *bufmgr; struct drm_i915_gem_get_aperture aperture; drm_i915_getparam_t gp; int ret, tmp; pthread_mutex_lock(&bufmgr_list_mutex); - bufmgr_gem = drm_bacon_bufmgr_gem_find(fd); - if (bufmgr_gem) + bufmgr = drm_bacon_bufmgr_gem_find(fd); + if (bufmgr) goto exit; - bufmgr_gem = calloc(1, sizeof(*bufmgr_gem)); - if (bufmgr_gem == NULL) + bufmgr = calloc(1, sizeof(*bufmgr)); + if (bufmgr == NULL) goto exit; - bufmgr_gem->fd = fd; - p_atomic_set(&bufmgr_gem->refcount, 1); + bufmgr->fd = fd; + p_atomic_set(&bufmgr->refcount, 1); - if (pthread_mutex_init(&bufmgr_gem->lock, NULL) != 0) { - free(bufmgr_gem); - bufmgr_gem = NULL; + if (pthread_mutex_init(&bufmgr->lock, NULL) != 0) { + free(bufmgr); + bufmgr = NULL; goto exit; } memclear(aperture); - ret = drmIoctl(bufmgr_gem->fd, + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GEM_GET_APERTURE, &aperture); if (ret == 0) - bufmgr_gem->gtt_size = aperture.aper_available_size; + bufmgr->gtt_size = aperture.aper_available_size; else { fprintf(stderr, "DRM_IOCTL_I915_GEM_APERTURE failed: %s\n", strerror(errno)); - bufmgr_gem->gtt_size = 128 * 1024 * 1024; + bufmgr->gtt_size = 128 * 1024 * 1024; fprintf(stderr, "Assuming %dkB available aperture size.\n" "May lead to reduced performance or incorrect " "rendering.\n", - (int)bufmgr_gem->gtt_size / 1024); - } - - bufmgr_gem->pci_device = get_pci_device_id(bufmgr_gem); - - if (IS_GEN4(bufmgr_gem->pci_device)) - bufmgr_gem->gen = 4; - else if (IS_GEN5(bufmgr_gem->pci_device)) - bufmgr_gem->gen = 5; - else if (IS_GEN6(bufmgr_gem->pci_device)) - bufmgr_gem->gen = 6; - else if (IS_GEN7(bufmgr_gem->pci_device)) - bufmgr_gem->gen = 7; - else if (IS_GEN8(bufmgr_gem->pci_device)) - bufmgr_gem->gen = 8; - else if (IS_GEN9(bufmgr_gem->pci_device)) - bufmgr_gem->gen = 9; + (int)bufmgr->gtt_size / 1024); + } + + bufmgr->pci_device = get_pci_device_id(bufmgr); + + if (IS_GEN4(bufmgr->pci_device)) + bufmgr->gen = 4; + else if (IS_GEN5(bufmgr->pci_device)) + bufmgr->gen = 5; + else if (IS_GEN6(bufmgr->pci_device)) + bufmgr->gen = 6; + else if (IS_GEN7(bufmgr->pci_device)) + bufmgr->gen = 7; + else if (IS_GEN8(bufmgr->pci_device)) + bufmgr->gen = 8; + else if (IS_GEN9(bufmgr->pci_device)) + bufmgr->gen = 9; else { - free(bufmgr_gem); - bufmgr_gem = NULL; + free(bufmgr); + bufmgr = NULL; goto exit; } @@ -3095,35 +3064,35 @@ drm_bacon_bufmgr_gem_init(int fd, int batch_size) gp.value = &tmp; gp.param = I915_PARAM_HAS_BSD; - ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp); - bufmgr_gem->has_bsd = ret == 0; + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GETPARAM, &gp); + bufmgr->has_bsd = ret == 0; gp.param = I915_PARAM_HAS_BLT; - ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp); - bufmgr_gem->has_blt = ret == 0; + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GETPARAM, &gp); + bufmgr->has_blt = ret == 0; gp.param = I915_PARAM_HAS_EXEC_ASYNC; - ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp); - bufmgr_gem->has_exec_async = ret == 0; + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GETPARAM, &gp); + bufmgr->has_exec_async = ret == 0; gp.param = I915_PARAM_HAS_WAIT_TIMEOUT; - ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp); - bufmgr_gem->has_wait_timeout = ret == 0; + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GETPARAM, &gp); + bufmgr->has_wait_timeout = ret == 0; gp.param = I915_PARAM_HAS_LLC; - ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp); + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GETPARAM, &gp); if (ret != 0) { /* Kernel does not supports HAS_LLC query, fallback to GPU * generation detection and assume that we have LLC on GEN6/7 */ - bufmgr_gem->has_llc = (IS_GEN6(bufmgr_gem->pci_device) | - IS_GEN7(bufmgr_gem->pci_device)); + bufmgr->has_llc = (IS_GEN6(bufmgr->pci_device) | + IS_GEN7(bufmgr->pci_device)); } else - bufmgr_gem->has_llc = *gp.value; + bufmgr->has_llc = *gp.value; gp.param = I915_PARAM_HAS_VEBOX; - ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp); - bufmgr_gem->has_vebox = (ret == 0) & (*gp.value > 0); + ret = drmIoctl(bufmgr->fd, DRM_IOCTL_I915_GETPARAM, &gp); + bufmgr->has_vebox = (ret == 0) & (*gp.value > 0); /* Let's go with one relocation per every 2 dwords (but round down a bit * since a power of two will mean an extra page allocation for the reloc @@ -3131,17 +3100,17 @@ drm_bacon_bufmgr_gem_init(int fd, int batch_size) * * Every 4 was too few for the blender benchmark. */ - bufmgr_gem->max_relocs = batch_size / sizeof(uint32_t) / 2 - 2; + bufmgr->max_relocs = batch_size / sizeof(uint32_t) / 2 - 2; - init_cache_buckets(bufmgr_gem); + init_cache_buckets(bufmgr); - list_inithead(&bufmgr_gem->vma_cache); - bufmgr_gem->vma_max = -1; /* unlimited by default */ + list_inithead(&bufmgr->vma_cache); + bufmgr->vma_max = -1; /* unlimited by default */ - list_add(&bufmgr_gem->managers, &bufmgr_list); + list_add(&bufmgr->managers, &bufmgr_list); exit: pthread_mutex_unlock(&bufmgr_list_mutex); - return bufmgr_gem != NULL ? &bufmgr_gem->bufmgr : NULL; + return bufmgr; } diff --git a/src/mesa/drivers/dri/i965/intel_bufmgr_priv.h b/src/mesa/drivers/dri/i965/intel_bufmgr_priv.h deleted file mode 100644 index cccb9e4a972..00000000000 --- a/src/mesa/drivers/dri/i965/intel_bufmgr_priv.h +++ /dev/null @@ -1,45 +0,0 @@ -/* - * Copyright © 2008 Intel Corporation - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice (including the next - * paragraph) shall be included in all copies or substantial portions of the - * Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS - * IN THE SOFTWARE. - * - * Authors: - * Eric Anholt - * - */ - -/** - * @file intel_bufmgr_priv.h - * - * Private definitions of Intel-specific bufmgr functions and structures. - */ - -#ifndef INTEL_BUFMGR_PRIV_H -#define INTEL_BUFMGR_PRIV_H - -/** - * Context for a buffer manager instance. - * - * Contains public methods followed by private storage for the buffer manager. - */ -struct _drm_bacon_bufmgr { -}; - -#endif /* INTEL_BUFMGR_PRIV_H */ -- 2.30.2