@@ -379,6 +379,53 @@ void gem_sync(int fd, uint32_t handle)
gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
}
+bool gem_create__has_stolen_support(int fd)
+{
+ static has_stolen_support = -1;
+ struct drm_i915_getparam gp;
+ int val = -1;
+
+ memset(&gp, 0, sizeof(gp));
+ gp.param = 35; /* CREATE_VERSION */
+ gp.value = &val;
+
+ /* Do we have the extended gem_create_ioctl? */
+ ioctl(fd, DRM_IOCTL_I915_GETPARAM, &gp);
+
+ return val >= 1;
+}
+
+/**
+ * gem_create stolen:
+ * @fd: open i915 drm file descriptor
+ * @size: desired size of the buffer
+ * @flags: desired placement i.e. stolen or shmem
+ *
+ * This wraps the new GEM_CREATE ioctl, which allocates a
+ * new gem buffer object of @size and placement based on @flags.
+ *
+ * Returns: The file-private handle of the created buffer object
+ */
+
+uint32_t gem_create_stolen(int fd, int size, uint32_t flags)
+{
+ struct drm_i915_gem_create create;
+ int ret;
+
+ memset(&create, 0, sizeof(create));
+ create.handle = 0;
+ create.size = size;
+ create.flags = flags;
+ ret = drmIoctl(fd, DRM_IOCTL_I915_GEM_CREATE, &create);
+
+ if (ret < 0)
+ return 0;
+
+ errno = 0;
+ return create.handle;
+}
+
+
uint32_t __gem_create(int fd, int size)
{
struct drm_i915_gem_create create;
@@ -56,6 +56,8 @@ void gem_read(int fd, uint32_t handle, uint32_t offset, void *buf, uint32_t leng
void gem_set_domain(int fd, uint32_t handle,
uint32_t read_domains, uint32_t write_domain);
void gem_sync(int fd, uint32_t handle);
+bool gem_create__has_stolen_support(int fd);
+uint32_t gem_create_stolen(int fd, int size, uint32_t flags);
uint32_t __gem_create(int fd, int size);
uint32_t gem_create(int fd, int size);
void gem_execbuf(int fd, struct drm_i915_gem_execbuffer2 *execbuf);
@@ -67,6 +69,15 @@ bool gem_mmap__has_wc(int fd);
void *gem_mmap__wc(int fd, uint32_t handle, int offset, int size, int prot);
/**
+ * gem_require_stolen_support:
+ * @fd: open i915 drm file descriptor
+ *
+ * Test macro to query whether support for allocating objects from stolen
+ * memory is available. Automatically skips through igt_require() if not.
+ */
+#define gem_require_stolen_support(fd) \
+ igt_require(gem_create__has_stolen_support(fd))
+/**
* gem_require_mmap_wc:
* @fd: open i915 drm file descriptor
*
@@ -23,6 +23,7 @@ TESTS_progs_M = \
gem_caching \
gem_close_race \
gem_concurrent_blit \
+ gem_create_stolen \
gem_cs_tlb \
gem_ctx_param_basic \
gem_ctx_bad_exec \
new file mode 100644
@@ -0,0 +1,333 @@
+/*
+ * Copyright © 2011 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:
+ * Ankitprasad Sharma <ankitprasad.r.sharma@intel.com>
+ *
+ */
+
+/** @file gem_create_stolen.c
+ *
+ * This is a test for the extended gem_create ioctl, that includes allocation
+ * of object from stolen memory
+ *
+ * The goal is to simply ensure the basics work, and invalid input combinations
+ * are rejected.
+ */
+
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <getopt.h>
+
+#include <drm.h>
+
+#include "ioctl_wrappers.h"
+#include "intel_bufmgr.h"
+#include "intel_batchbuffer.h"
+#include "intel_io.h"
+#include "intel_chipset.h"
+#include "igt_aux.h"
+#include "drmtest.h"
+#include "drm.h"
+#include "i915_drm.h"
+
+#define CLEAR(s) memset(&s, 0, sizeof(s))
+#define SIZE 1024*1024
+
+static struct drm_intel_bufmgr *bufmgr;
+static struct intel_batchbuffer *batch;
+
+static void verify_copy_op(drm_intel_bo *src, drm_intel_bo *dest)
+{
+ uint32_t *virt, i, ret;
+ /* Fill the src BO with dwords */
+ ret = drm_intel_gem_bo_map_gtt(src);
+ igt_assert(!ret);
+
+ virt = src->virtual;
+ for (i = 0; i < SIZE/4; i++)
+ virt[i] = i;
+
+ intel_copy_bo(batch, dest, src, SIZE);
+
+ ret = drm_intel_gem_bo_map_gtt(dest);
+ igt_assert(!ret);
+
+ virt = dest->virtual;
+ /* verify */
+ for (i = 0; i < SIZE/4; i++) {
+ if (virt[i] != i) {
+ fprintf(stderr, "Expected 0x%08x, found 0x%08x "
+ "at offset 0x%08x\n",
+ i, virt[i], i * 4);
+ igt_assert(virt[i] == i);
+ }
+ }
+
+ drm_intel_bo_unmap(src);
+ drm_intel_bo_unmap(dest);
+}
+
+static void copy_test(int fd)
+{
+ drm_intel_bo *src, *dest;
+ uint32_t src_handle = 0, dest_handle = 0;
+ int ret = 0;
+
+ gem_require_stolen_support(fd);
+
+ src_handle = gem_create_stolen(fd, SIZE, I915_CREATE_PLACEMENT_STOLEN);
+ igt_assert(src_handle != 0);
+
+ dest_handle = gem_create_stolen(fd, SIZE, I915_CREATE_PLACEMENT_STOLEN);
+ igt_assert(dest_handle != 0);
+
+ src = gem_handle_to_libdrm_bo(bufmgr, fd, "src_bo", src_handle);
+ dest = gem_handle_to_libdrm_bo(bufmgr, fd, "dst_bo", dest_handle);
+
+ igt_assert(src != NULL);
+ igt_assert(dest != NULL);
+
+ verify_copy_op(src, dest);
+
+ drm_intel_bo_unreference(src);
+ drm_intel_bo_unreference(dest);
+ gem_close(fd, src_handle);
+ gem_close(fd, dest_handle);
+}
+
+static void verify_object_clear(int fd)
+{
+ drm_intel_bo *bo;
+ uint32_t handle = 0;
+ uint32_t *virt;
+ int i, ret = 0;
+
+ gem_require_stolen_support(fd);
+
+ handle = gem_create_stolen(fd, SIZE, I915_CREATE_PLACEMENT_STOLEN);
+ igt_assert(handle != 0);
+
+ bo = gem_handle_to_libdrm_bo(bufmgr, fd, "verify_bo", handle);
+ igt_assert(bo != NULL);
+
+ ret = drm_intel_gem_bo_map_gtt(bo);
+ igt_assert(ret == 0);
+
+ /* Verify if the BO is zeroed */
+ virt = bo->virtual;
+ for (i = 0; i < SIZE / 4; i++)
+ igt_assert(virt[i] == 0);
+
+ drm_intel_bo_unmap(bo);
+ drm_intel_bo_unreference(bo);
+ gem_close(fd, handle);
+}
+
+static void stolen_fill_purge_test(int fd)
+{
+ drm_intel_bo *bo;
+ int mret = 0, ret = 0, obj_count = 0, i = 0;
+ int _ret = 0, j = 0;
+ uint32_t handle[100] = {0};
+ uint32_t new_handle = 0;
+ uint32_t *virt;
+ int retained = 0;
+
+ gem_require_stolen_support(fd);
+
+ /* Exhaust Stolen space */
+ while(ret == 0) {
+ ret = -1;
+ handle[i] = gem_create_stolen(fd, SIZE,
+ I915_CREATE_PLACEMENT_STOLEN);
+ if (handle[i] != 0) {
+ ret = 0;
+ bo = gem_handle_to_libdrm_bo(bufmgr, fd,
+ "verify_bo", handle[i]);
+ igt_assert(bo != NULL);
+
+ _ret = drm_intel_gem_bo_map_gtt(bo);
+ igt_assert(_ret == 0);
+
+ virt = bo->virtual;
+ for (j = 0; j < SIZE / 4; j++)
+ virt[j] = 0xab;
+
+ drm_intel_bo_unmap(bo);
+ drm_intel_bo_unreference(bo);
+
+ obj_count++;
+ }
+
+ i++;
+ }
+
+ igt_assert(obj_count > 0);
+
+ /* Mark all stolen objects purgeable */
+ for (i = 0; i < obj_count; i++)
+ retained = gem_madvise(fd, handle[i], I915_MADV_DONTNEED);
+
+ /* Try to allocate one more object */
+ new_handle = gem_create_stolen(fd, SIZE,
+ I915_CREATE_PLACEMENT_STOLEN);
+ igt_assert(new_handle != 0);
+
+ /* Check if the retained object's memory contents are intact */
+ for (i = 0; i < obj_count; i++) {
+ retained = gem_madvise(fd, handle[i], I915_MADV_WILLNEED);
+ if (retained) {
+ bo = gem_handle_to_libdrm_bo(bufmgr, fd,
+ "verify_bo", handle[i]);
+ igt_assert(bo != NULL);
+
+ _ret = drm_intel_gem_bo_map_gtt(bo);
+ igt_assert(_ret == 0);
+
+ virt = bo->virtual;
+ for (j = 0; j < SIZE / 4; j++)
+ igt_assert(virt[j] == 0xab);
+
+ drm_intel_bo_unmap(bo);
+ drm_intel_bo_unreference(bo);
+ }
+ }
+
+ gem_close(fd, new_handle);
+ for (i = 0; i < obj_count; i++)
+ gem_close(fd, handle[i]);
+}
+
+static void
+stolen_mmap(int fd)
+{
+ drm_intel_bo *bo;
+ int ret = 0;
+ uint32_t handle = 0;
+
+ gem_require_stolen_support(fd);
+
+ handle = gem_create_stolen(fd, SIZE, I915_CREATE_PLACEMENT_STOLEN);
+ igt_assert(handle != 0);
+
+ bo = gem_handle_to_libdrm_bo(bufmgr, fd, "mmap_bo", handle);
+ igt_assert(bo != NULL);
+
+ ret = drm_intel_bo_map(bo, 1);
+ igt_assert(ret != 0);
+
+ drm_intel_bo_unreference(bo);
+ gem_close(fd, handle);
+}
+
+static void
+stolen_pwrite(int fd)
+{
+ drm_intel_bo *bo;
+ char data[32] = {0};
+ int ret = 0;
+ uint32_t handle = 0;
+
+ gem_require_stolen_support(fd);
+
+ handle = gem_create_stolen(fd, SIZE, I915_CREATE_PLACEMENT_STOLEN);
+ igt_assert(handle != 0);
+
+ bo = gem_handle_to_libdrm_bo(bufmgr, fd, "mmap_bo", handle);
+ igt_assert(bo != NULL);
+
+ ret = drm_intel_bo_subdata(bo, 0, 32, data);
+ igt_assert(ret != 0);
+
+ drm_intel_bo_unreference(bo);
+ gem_close(fd, handle);
+}
+
+static void invalid_flag_test(int fd)
+{
+ uint32_t handle = 0;
+
+ gem_require_stolen_support(fd);
+
+ handle = gem_create_stolen(fd, SIZE, ~I915_CREATE_PLACEMENT_STOLEN);
+
+ igt_assert(handle == 0);
+}
+
+igt_main
+{
+ int i, fd, gtt_size_total, gtt_size_mappable;
+ uint32_t devid;
+
+ igt_skip_on_simulation();
+
+ igt_fixture {
+ fd = drm_open_any();
+ devid = intel_get_drm_devid(fd);
+
+ drm_intel_get_aperture_sizes(fd, (size_t*)>t_size_total,
+ (size_t*)>t_size_mappable);
+ bufmgr = drm_intel_bufmgr_gem_init(fd, 4096);
+ batch = intel_batchbuffer_alloc(bufmgr, devid);
+ }
+
+ igt_subtest("stolen-invalid-flag")
+ invalid_flag_test(fd);
+
+ igt_subtest("stolen-clear")
+ verify_object_clear(fd);
+
+ /*
+ * stolen mem special cases - checking for non cpu mappable
+ */
+ igt_subtest("stolen-mmap")
+ stolen_mmap(fd);
+
+ igt_subtest("stolen-pwrite")
+ stolen_pwrite(fd);
+
+ /* Functional Test - blt copy */
+ igt_subtest("stolen-copy")
+ copy_test(fd);
+
+ /* Filling stolen completely and marking all the objects
+ * purgeable. Then trying to add one more object, to verify
+ * the purging logic.
+ * Again marking all objects WILLNEED and verifying the
+ * contents of the retained objects.
+ */
+ igt_subtest("stolen-fill-purge")
+ stolen_fill_purge_test(fd);
+
+ igt_fixture {
+ intel_batchbuffer_free(batch);
+ drm_intel_bufmgr_destroy(bufmgr);
+ }
+}