[igt-dev] [PATCH i-g-t 09/16] Add test where both src and dest are protected
Alan Previn
alan.previn.teres.alexis at intel.com
Fri May 14 06:49:46 UTC 2021
When both the source and destination surfaces are
protected, the destination pixel result of the 3d
copy operation would be the same as the source. By
appending this test case to the end of the prior
test (raw-src to protected-dest) and reusing the
previous' test destination as the current source,
we can prove that new-source was decrypted properly
as we would see the difference in results: repeating
the same render operation but with a src buffer
that is protected in this case yields matching
(but still encrypted) output rendered pixels.
Signed-off-by: Alan Previn <alan.previn.teres.alexis at intel.com>
---
tests/i915/gem_pxp.c | 110 ++++++++++++++++++++++++++++++++++++++-----
1 file changed, 97 insertions(+), 13 deletions(-)
diff --git a/tests/i915/gem_pxp.c b/tests/i915/gem_pxp.c
index cd839527..22a2d09a 100644
--- a/tests/i915/gem_pxp.c
+++ b/tests/i915/gem_pxp.c
@@ -327,29 +327,51 @@ static void fill_bo_content(int i915, uint32_t bo, uint32_t size, uint32_t initc
#define COMPARE_COLOR_READIBLE 1
#define COMPARE_COLOR_UNREADIBLE 2
+#define COMPARE_BUFFER_READIBLE 3
+#define COMPARE_BUFFER_UNREADIBLE 4
+#define COPY_BUFFER 5
#define COMPARE_N_PIXELS_VERBOSELY 0
-static void assert_bo_content_check(int i915, uint32_t bo, int compare_op,
- uint32_t size, uint32_t color)
+static void assert_bo_content_check(int i915, uint32_t bo, int compare_op, uint32_t size,
+ uint32_t color, uint32_t *auxptr, int auxsize)
{
- uint32_t *ptr, *ptrtmp;
+ uint32_t *ptr, *ptrtmp, *auxtmp;
int loop = 0, num_matches = 0;
uint32_t value;
- bool op_readible = (compare_op == COMPARE_COLOR_READIBLE);
+ bool op_readible = ((compare_op == COMPARE_COLOR_READIBLE) ||
+ (compare_op == COMPARE_BUFFER_READIBLE));
+ bool chk_buff = ((compare_op == COMPARE_BUFFER_READIBLE) ||
+ (compare_op == COMPARE_BUFFER_UNREADIBLE));
+ bool copy_buff = (compare_op == COPY_BUFFER);
ptr = gem_mmap__device_coherent(i915, bo, 0, size, PROT_READ);
ptrtmp = ptr;
+ if (chk_buff || copy_buff) {
+ if (auxsize < size)
+ auxptr = NULL;
+ igt_assert(auxptr);
+ auxtmp = auxptr;
+ }
+
if (COMPARE_N_PIXELS_VERBOSELY) {
igt_info("--------->>>\n");
while (loop < COMPARE_N_PIXELS_VERBOSELY && loop < (size/4)) {
value = *ptrtmp;
- igt_info("Color read = 0x%08x ", value);
- igt_info("expected %c= 0x%08x)\n", op_readible?'=':'!', color);
+ if (chk_buff)
+ color = *auxtmp;
+ if (copy_buff)
+ igt_info("Color copy = 0x%08x\n", value);
+ else {
+ igt_info("Color read = 0x%08x ", value);
+ igt_info("expected %c= 0x%08x)\n", op_readible?'=':'!', color);
+ }
+ ++auxtmp;
++ptrtmp;
++loop;
}
igt_info("<<<---------\n");
+ auxtmp = auxptr;
ptrtmp = ptr;
loop = 0;
}
@@ -357,8 +379,25 @@ static void assert_bo_content_check(int i915, uint32_t bo, int compare_op,
/* count all pixels for matches */
while (loop++ < (size/4)) {
value = *ptrtmp;
- if (value == color)
- ++num_matches;
+ switch (compare_op) {
+ case COMPARE_COLOR_READIBLE:
+ case COMPARE_COLOR_UNREADIBLE:
+ if (value == color)
+ ++num_matches;
+ break;
+ case COMPARE_BUFFER_READIBLE:
+ case COMPARE_BUFFER_UNREADIBLE:
+ if (value == (*auxtmp))
+ ++num_matches;
+ ++auxtmp;
+ break;
+ case COPY_BUFFER:
+ *auxtmp = value;
+ ++auxtmp;
+ break;
+ default:
+ break;
+ }
++ptrtmp;
}
@@ -378,7 +417,8 @@ static uint32_t alloc_and_fill_dest_buff(int i915, bool protected, uint32_t size
bo = create_protected_bo(i915, size, protected, 0);
igt_assert(bo);
fill_bo_content(i915, bo, size, init_color);
- assert_bo_content_check(i915, bo, COMPARE_COLOR_READIBLE, size, init_color);
+ assert_bo_content_check(i915, bo, COMPARE_COLOR_READIBLE,
+ size, init_color, NULL, 0);
return bo;
}
@@ -396,14 +436,16 @@ static uint32_t alloc_and_fill_dest_buff(int i915, bool protected, uint32_t size
#define TSTSURF_FILLCOLOR2 0xdeaddead
#define TSTSURF_INITCOLOR1 0x12341234
#define TSTSURF_INITCOLOR2 0x56785678
+#define TSTSURF_INITCOLOR3 0xabcdabcd
static void test_render_protected_buffer(int i915, uint32_t test_cfg)
{
- uint32_t ctx, srcbo, dstbo;
- struct intel_buf *srcbuf, *dstbuf;
+ uint32_t ctx, srcbo, dstbo, dstbo2;
+ struct intel_buf *srcbuf, *dstbuf, *dstbuf2;
struct buf_ops *bops;
struct intel_bb *ibb;
uint32_t devid;
+ uint32_t encrypted[TSTSURF_SIZE/TSTSURF_BYTESPP];
devid = intel_get_drm_devid(i915);
igt_assert(devid);
@@ -432,7 +474,7 @@ static void test_render_protected_buffer(int i915, uint32_t test_cfg)
gem_sync(i915, dstbo);
assert_bo_content_check(i915, dstbo, COMPARE_COLOR_READIBLE,
- TSTSURF_SIZE, TSTSURF_FILLCOLOR1);
+ TSTSURF_SIZE, TSTSURF_FILLCOLOR1, NULL, 0);
intel_bb_destroy(ibb);
intel_buf_destroy(srcbuf);
@@ -443,6 +485,7 @@ static void test_render_protected_buffer(int i915, uint32_t test_cfg)
break;
case COPY3D_PROTECTED_SRC_TO_PROTDST:
+ case COPY3D_PROTECTED_PROTSRC_TO_PROTDST:
/* Perform a protected render operation but only label
* the dest as protected. After rendering, the content
* should be encrypted
@@ -468,13 +511,52 @@ static void test_render_protected_buffer(int i915, uint32_t test_cfg)
gem_sync(i915, dstbo);
assert_bo_content_check(i915, dstbo, COMPARE_COLOR_UNREADIBLE,
- TSTSURF_SIZE, TSTSURF_FILLCOLOR2);
+ TSTSURF_SIZE, TSTSURF_FILLCOLOR2, NULL, 0);
+
+ if (test_cfg == COPY3D_PROTECTED_SRC_TO_PROTDST) {
+ intel_bb_destroy(ibb);
+ intel_buf_destroy(srcbuf);
+ gem_close(i915, srcbo);
+ intel_buf_destroy(dstbuf);
+ gem_close(i915, dstbo);
+ gem_context_destroy(i915, ctx);
+ break;
+ }
+
+ /* For COPY3D_PROTECTED_PROTSRC_TO_PROTDST, reuse
+ * prior dst as the new-src and create a new dst2 as
+ * the new-dest. Take a copy of encrypted content
+ * from new-src for comparison after render operation.
+ * After the rendering, we should find no difference
+ * in content since both new-src and new-dest are
+ * labelled as encrypted. HW should read and decrypt
+ * new-src, perform the render and re-encrypt when
+ * going into new-dest
+ */
+ assert_bo_content_check(i915, dstbo, COPY_BUFFER,
+ TSTSURF_SIZE, 0, encrypted, TSTSURF_SIZE);
+
+ dstbo2 = alloc_and_fill_dest_buff(i915, false, TSTSURF_SIZE, TSTSURF_INITCOLOR3);
+ dstbuf2 = intel_buf_create_using_handle(bops, dstbo2, TSTSURF_WIDTH, TSTSURF_HEIGHT,
+ TSTSURF_BYTESPP*8, 0, I915_TILING_NONE, 0);
+ intel_buf_set_pxp(dstbuf2, true);
+
+ intel_buf_set_pxp(dstbuf, true);/*this time, src is protected*/
+
+ intel_bb_set_pxp(ibb, true, DISPLAY_APPTYPE, I915_PROTECTED_CONTENT_DEFAULT_SESSION);
+
+ gen12_render_copyfunc(ibb, dstbuf, 0, 0, TSTSURF_WIDTH, TSTSURF_HEIGHT, dstbuf2, 0, 0);
+ gem_sync(i915, dstbo2);
+
+ assert_bo_content_check(i915, dstbo2, COMPARE_BUFFER_READIBLE, TSTSURF_SIZE, 0, encrypted, TSTSURF_SIZE);
intel_bb_destroy(ibb);
intel_buf_destroy(srcbuf);
gem_close(i915, srcbo);
intel_buf_destroy(dstbuf);
gem_close(i915, dstbo);
+ intel_buf_destroy(dstbuf2);
+ gem_close(i915, dstbo2);
gem_context_destroy(i915, ctx);
break;
@@ -560,6 +642,8 @@ igt_main
test_render_protected_buffer(i915, COPY3D_BASELINE_SRC_TO_DST);
igt_subtest("protected-raw-src-copy-not-readible")
test_render_protected_buffer(i915, COPY3D_PROTECTED_SRC_TO_PROTDST);
+ igt_subtest("protected-encrypted-src-copy-not-readible")
+ test_render_protected_buffer(i915, COPY3D_PROTECTED_PROTSRC_TO_PROTDST);
}
igt_fixture {
--
2.25.1
More information about the igt-dev
mailing list