kselftests: dmabuf-heaps: Add extra checking that allocated buffers are zeroed

Add a check to validate that buffers allocated from the heaps
are properly zeroed before being given to userland.

It is done by allocating a number of buffers, and filling them
with a nonzero pattern, then closing and reallocating more
buffers and checking that they are all properly zeroed.

This is helpful to validate any cached buffers are zeroed
before being given back out.

Cc: Shuah Khan <shuah@kernel.org>
Cc: Brian Starkey <brian.starkey@arm.com>
Cc: Sumit Semwal <sumit.semwal@linaro.org>
Cc: Laura Abbott <labbott@kernel.org>
Cc: Hridya Valsaraju <hridya@google.com>
Cc: Suren Baghdasaryan <surenb@google.com>
Cc: Sandeep Patil <sspatil@google.com>
Cc: Daniel Mentz <danielmentz@google.com>
Cc: linux-media@vger.kernel.org
Cc: dri-devel@lists.freedesktop.org
Cc: linux-kselftest@vger.kernel.org
Signed-off-by: John Stultz <john.stultz@linaro.org>
Signed-off-by: Shuah Khan <skhan@linuxfoundation.org>

diff --git a/tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c b/tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c
index d179d81e23558c2df3b65305b4da2c32d8978dc9..29af27acd40ea08fdf787e63a52cd285980c5cfc 100644 (file)
--- a/tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c
+++ b/tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c
@@ -218,6 +218,84 @@ out:
        return ret;
 }
 
+static int test_alloc_zeroed(char *heap_name, size_t size)
+{
+       int heap_fd = -1, dmabuf_fd[32];
+       int i, j, ret;
+       void *p = NULL;
+       char *c;
+
+       printf("  Testing alloced %ldk buffers are zeroed:  ", size / 1024);
+       heap_fd = dmabuf_heap_open(heap_name);
+       if (heap_fd < 0)
+               return -1;
+
+       /* Allocate and fill a bunch of buffers */
+       for (i = 0; i < 32; i++) {
+               ret = dmabuf_heap_alloc(heap_fd, size, 0, &dmabuf_fd[i]);
+               if (ret < 0) {
+                       printf("FAIL (Allocation (%i) failed)\n", i);
+                       goto out;
+               }
+               /* mmap and fill with simple pattern */
+               p = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, dmabuf_fd[i], 0);
+               if (p == MAP_FAILED) {
+                       printf("FAIL (mmap() failed!)\n");
+                       ret = -1;
+                       goto out;
+               }
+               dmabuf_sync(dmabuf_fd[i], DMA_BUF_SYNC_START);
+               memset(p, 0xff, size);
+               dmabuf_sync(dmabuf_fd[i], DMA_BUF_SYNC_END);
+               munmap(p, size);
+       }
+       /* close them all */
+       for (i = 0; i < 32; i++)
+               close(dmabuf_fd[i]);
+
+       /* Allocate and validate all buffers are zeroed */
+       for (i = 0; i < 32; i++) {
+               ret = dmabuf_heap_alloc(heap_fd, size, 0, &dmabuf_fd[i]);
+               if (ret < 0) {
+                       printf("FAIL (Allocation (%i) failed)\n", i);
+                       goto out;
+               }
+
+               /* mmap and validate everything is zero */
+               p = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, dmabuf_fd[i], 0);
+               if (p == MAP_FAILED) {
+                       printf("FAIL (mmap() failed!)\n");
+                       ret = -1;
+                       goto out;
+               }
+               dmabuf_sync(dmabuf_fd[i], DMA_BUF_SYNC_START);
+               c = (char *)p;
+               for (j = 0; j < size; j++) {
+                       if (c[j] != 0) {
+                               printf("FAIL (Allocated buffer not zeroed @ %i)\n", j);
+                               break;
+                       }
+               }
+               dmabuf_sync(dmabuf_fd[i], DMA_BUF_SYNC_END);
+               munmap(p, size);
+       }
+       /* close them all */
+       for (i = 0; i < 32; i++)
+               close(dmabuf_fd[i]);
+
+       close(heap_fd);
+       printf("OK\n");
+       return 0;
+
+out:
+       while (i > 0) {
+               close(dmabuf_fd[i]);
+               i--;
+       }
+       close(heap_fd);
+       return ret;
+}
+
 /* Test the ioctl version compatibility w/ a smaller structure then expected */
 static int dmabuf_heap_alloc_older(int fd, size_t len, unsigned int flags,
                                   int *dmabuf_fd)
@@ -386,6 +464,14 @@ int main(void)
                if (ret)
                        break;
 
+               ret = test_alloc_zeroed(dir->d_name, 4 * 1024);
+               if (ret)
+                       break;
+
+               ret = test_alloc_zeroed(dir->d_name, ONE_MEG);
+               if (ret)
+                       break;
+
                ret = test_alloc_compat(dir->d_name);
                if (ret)
                        break;