@@ -34,6 +34,7 @@ TESTS_progs_M = \
gem_exec_bad_domains \
gem_exec_faulting_reloc \
gem_exec_nop \
+ gem_exec_pad_to_size \
gem_exec_params \
gem_exec_parse \
gem_fenced_exec_thrash \
new file mode 100644
@@ -0,0 +1,236 @@
+/*
+ * Copyright © 2015 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:
+ * Tvrtko Ursulin <tvrtko.ursulin@intel.com>
+ *
+ */
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include "drm.h"
+#include "ioctl_wrappers.h"
+#include "igt_core.h"
+#include "drmtest.h"
+#include "intel_reg.h"
+#include "igt_debugfs.h"
+
+#ifndef PAGE_SIZE
+#define PAGE_SIZE 4096
+#endif
+
+struct local_drm_i915_gem_exec_object2 {
+ /**
+ * User's handle for a buffer to be bound into the GTT for this
+ * operation.
+ */
+ __u32 handle;
+
+ /** Number of relocations to be performed on this buffer */
+ __u32 relocation_count;
+ /**
+ * Pointer to array of struct drm_i915_gem_relocation_entry containing
+ * the relocations to be performed in this buffer.
+ */
+ __u64 relocs_ptr;
+
+ /** Required alignment in graphics aperture */
+ __u64 alignment;
+
+ /**
+ * Returned value of the updated offset of the object, for future
+ * presumed_offset writes.
+ */
+ __u64 offset;
+
+#define LOCAL_EXEC_OBJECT_NEEDS_FENCE (1<<0)
+#define LOCAL_EXEC_OBJECT_NEEDS_GTT (1<<1)
+#define LOCAL_EXEC_OBJECT_WRITE (1<<2)
+#define LOCAL_EXEC_OBJECT_PAD_TO_SIZE (1<<3)
+#define __LOCAL_EXEC_OBJECT_UNKNOWN_FLAGS -(LOCAL_EXEC_OBJECT_PAD_TO_SIZE<<1)
+ __u64 flags;
+
+ __u64 pad_to_size;
+ __u64 rsvd2;
+};
+
+static int
+exec(int fd, uint32_t handles[3], uint32_t pad_to_size[2], uint64_t *offsets)
+{
+ struct drm_i915_gem_execbuffer2 execbuf;
+ struct local_drm_i915_gem_exec_object2 gem_exec[3];
+ int ret = 0;
+
+ memset(gem_exec, 0, sizeof(gem_exec));
+
+ gem_exec[0].handle = handles[1];
+ gem_exec[0].flags = pad_to_size[0] ?
+ LOCAL_EXEC_OBJECT_PAD_TO_SIZE : 0;
+ gem_exec[0].pad_to_size = pad_to_size[0];
+
+ gem_exec[1].handle = handles[2];
+ gem_exec[1].flags = pad_to_size[1] ?
+ LOCAL_EXEC_OBJECT_PAD_TO_SIZE : 0;
+ gem_exec[1].pad_to_size = pad_to_size[1];
+
+ gem_exec[2].handle = handles[0];
+
+ memset(&execbuf, 0, sizeof(execbuf));
+
+ execbuf.buffers_ptr = (uintptr_t)gem_exec;
+ execbuf.buffer_count = 3;
+ execbuf.batch_len = 8;
+
+ if (drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &execbuf))
+ ret = -errno;
+
+ if (ret == 0 && offsets) {
+ offsets[0] = gem_exec[0].offset;
+ offsets[1] = gem_exec[1].offset;
+ }
+
+ return ret;
+}
+
+static void
+require_pad_to_size(int fd, uint32_t handles[3])
+{
+ igt_require(exec(fd, handles, (uint32_t[2]){ PAGE_SIZE, PAGE_SIZE },
+ NULL) == 0);
+}
+
+static void
+not_aligned(int fd, uint32_t handles[3])
+{
+ require_pad_to_size(fd, handles);
+
+ igt_require(exec(fd, handles, (uint32_t[2]){1 ,1},
+ NULL) == -EINVAL);
+}
+
+static void
+padding(int fd, uint32_t handles[3])
+{
+ uint32_t pad_to_size[2] = {0, 0};
+ uint64_t offsets[2];
+ bool neighbours = false;
+ unsigned int try, i;
+ const unsigned int max_tries = 4096; /* Finger in the air. */
+ uint32_t *loc_handles;
+ uint32_t eb_handles[3];
+
+ require_pad_to_size(fd, handles);
+
+ igt_drop_caches_set(DROP_ALL);
+
+ loc_handles = calloc(max_tries * 2, sizeof(uint32_t));
+ igt_assert(loc_handles);
+
+ /* Try with passed in handles first. */
+ loc_handles[0] = handles[1];
+ loc_handles[1] = handles[2];
+
+ /* Try to get two buffer object next to each other in GTT space.
+ * We presume that sequential reservations are likely to be aligned and
+ * try until we find a pair that is.
+ */
+ for (try = 0; try < max_tries;) {
+ eb_handles[0] = handles[0];
+ eb_handles[1] = loc_handles[try];
+ eb_handles[2] = loc_handles[try + 1];
+
+ igt_assert(exec(fd, eb_handles, (uint32_t[2]){0, 0},
+ offsets) == 0);
+
+ if ((offsets[1] - offsets[0]) == PAGE_SIZE) {
+ neighbours = true;
+ pad_to_size[0] = 2 * PAGE_SIZE;
+ break;
+ }
+
+ try++;
+
+ loc_handles[try + 1] = gem_create(fd, PAGE_SIZE);
+ igt_assert(loc_handles[try + 1]);
+ }
+
+ /* Otherwise test can't confidently run. */
+ if (neighbours) {
+ /* Re-exec with padding set. */
+ igt_assert(exec(fd, eb_handles, pad_to_size, offsets) == 0);
+
+ /* Check that objects with padding do not overlap. */
+ igt_assert(offsets[0] >= offsets[1] + PAGE_SIZE ||
+ offsets[0] + 2 * PAGE_SIZE <= offsets[1]);
+ }
+
+ /* Cleanup our bos. */
+ for (i = 0; i < try; i++)
+ gem_close(fd, loc_handles[2 + i]);
+
+ free(loc_handles);
+
+ igt_require(neighbours);
+}
+
+uint32_t batch[2] = {MI_BATCH_BUFFER_END};
+uint32_t handles[3];
+int fd;
+
+igt_main
+{
+ igt_fixture {
+ fd = drm_open_any();
+
+ handles[0] = gem_create(fd, PAGE_SIZE);
+ gem_write(fd, handles[0], 0, batch, sizeof(batch));
+
+ handles[1] = gem_create(fd, PAGE_SIZE);
+ handles[2] = gem_create(fd, PAGE_SIZE);
+ }
+
+ igt_subtest("pad_to_size")
+ require_pad_to_size(fd, handles);
+
+ igt_subtest("not_aligned")
+ not_aligned(fd, handles);
+
+ igt_subtest("padding")
+ padding(fd, handles);
+
+ igt_fixture {
+ gem_close(fd, handles[0]);
+ gem_close(fd, handles[1]);
+ gem_close(fd, handles[2]);
+
+ close(fd);
+ }
+}