From patchwork Thu Sep 10 06:02:39 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Daniel Stone X-Patchwork-Id: 7150981 Return-Path: X-Original-To: patchwork-intel-gfx@patchwork.kernel.org Delivered-To: patchwork-parsemail@patchwork2.web.kernel.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.136]) by patchwork2.web.kernel.org (Postfix) with ESMTP id D8934BEEC1 for ; Thu, 10 Sep 2015 06:02:51 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id 844A92073F for ; Thu, 10 Sep 2015 06:02:46 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) by mail.kernel.org (Postfix) with ESMTP id 5A47020674 for ; Thu, 10 Sep 2015 06:02:45 +0000 (UTC) Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id D33016E3B2; Wed, 9 Sep 2015 23:02:44 -0700 (PDT) X-Original-To: intel-gfx@lists.freedesktop.org Delivered-To: intel-gfx@lists.freedesktop.org Received: from bhuna.collabora.co.uk (bhuna.collabora.co.uk [93.93.135.160]) by gabe.freedesktop.org (Postfix) with ESMTPS id DA1776E3B2 for ; Wed, 9 Sep 2015 23:02:43 -0700 (PDT) Received: from [127.0.0.1] (localhost [127.0.0.1]) (Authenticated sender: daniels) with ESMTPSA id B6D943C88711 From: Daniel Stone To: intel-gfx@lists.freedesktop.org Date: Thu, 10 Sep 2015 07:02:39 +0100 Message-Id: <1441864960-8847-1-git-send-email-daniels@collabora.com> X-Mailer: git-send-email 2.5.0 MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH i-g-t v3 1/2] tests: Add blob-property test X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" X-Spam-Status: No, score=-4.2 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_MED, T_RP_MATCHES_RCVD, UNPARSEABLE_RELAY autolearn=unavailable version=3.3.1 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on mail.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Exercises the new blob-creation ioctl, testing lifetimes and behaviour of user-created blobs, as well as exercising all the invariant conditions we guarantee from modes exposed as blob properties. v2: Renamed to core_prop_blob, skip test if blob not available. v3: No changes. Signed-off-by: Daniel Stone --- tests/.gitignore | 1 + tests/Makefile.sources | 1 + tests/core_prop_blob.c | 237 +++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 239 insertions(+) create mode 100644 tests/core_prop_blob.c diff --git a/tests/.gitignore b/tests/.gitignore index dc8bb53..beda511 100644 --- a/tests/.gitignore +++ b/tests/.gitignore @@ -3,6 +3,7 @@ core_get_client_auth core_getclient core_getstats core_getversion +core_prop_blob drm_auth drm_import_export drm_read diff --git a/tests/Makefile.sources b/tests/Makefile.sources index 2e2e088..0f0e481 100644 --- a/tests/Makefile.sources +++ b/tests/Makefile.sources @@ -76,6 +76,7 @@ TESTS_progs_M = \ kms_pipe_b_c_ivb \ kms_pipe_crc_basic \ kms_plane \ + kms_prop_blob \ kms_psr_sink_crc \ kms_render \ kms_rotation_crc \ diff --git a/tests/core_prop_blob.c b/tests/core_prop_blob.c new file mode 100644 index 0000000..1250c00 --- /dev/null +++ b/tests/core_prop_blob.c @@ -0,0 +1,237 @@ +/* + * Copyright © 2014-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: + * Damien Lespiau + * Daniel Stone + */ + +#include +#include +#include +#include + +#include "drmtest.h" +#include "igt_debugfs.h" +#include "igt_kms.h" +#include "igt_aux.h" + +IGT_TEST_DESCRIPTION("Tests behaviour of mass-data 'blob' properties."); + +static const struct drm_mode_modeinfo test_mode_valid = { + .clock = 1234, + .hdisplay = 640, + .hsync_start = 641, + .hsync_end = 642, + .htotal = 643, + .hskew = 0, + .vdisplay = 480, + .vsync_start = 481, + .vsync_end = 482, + .vtotal = 483, + .vscan = 0, + .vrefresh = 60000, + .flags = 0, + .type = 0, + .name = "FROMUSER", +}; + + +static int +validate_prop(int fd, uint32_t prop_id) +{ + struct drm_mode_get_blob get; + struct drm_mode_modeinfo ret_mode; + int err; + + get.blob_id = prop_id; + get.length = 0; + get.data = (uintptr_t) 0; + + err = drmIoctl(fd, DRM_IOCTL_MODE_GETPROPBLOB, &get); + if (err != 0) + return err; + + if (get.length != sizeof(test_mode_valid)) + return ENOMEM; + + get.data = (uintptr_t) &ret_mode; + + err = drmIoctl(fd, DRM_IOCTL_MODE_GETPROPBLOB, &get); + if (err != 0) + return err; + + if (memcmp(&ret_mode, &test_mode_valid, sizeof(test_mode_valid)) != 0) + return EINVAL; + + return 0; +} + +static uint32_t +create_prop(int fd) +{ + struct drm_mode_create_blob create; + + create.length = sizeof(test_mode_valid); + create.data = (uintptr_t) &test_mode_valid; + + do_ioctl(fd, DRM_IOCTL_MODE_CREATEPROPBLOB, &create); + + return create.blob_id; +} + +static int +destroy_prop(int fd, uint32_t prop_id) +{ + struct drm_mode_destroy_blob destroy; + int err; + + destroy.blob_id = prop_id; + err = drmIoctl(fd, DRM_IOCTL_MODE_DESTROYPROPBLOB, &destroy); + return err; +} + +static void +test_validate(int fd) +{ + struct drm_mode_create_blob create; + struct drm_mode_get_blob get; + char too_small[32]; + uint32_t prop_id; + int ret; + + memset(too_small, 0, sizeof(too_small)); + + /* Outlandish size. */ + create.length = 0x10000; + create.data = (uintptr_t) &too_small; + ret = drmIoctl(fd, DRM_IOCTL_MODE_CREATEPROPBLOB, &create); + igt_assert(ret != 0 && errno == EFAULT); + + /* Outlandish address. */ + create.length = sizeof(test_mode_valid); + create.data = (uintptr_t) 0xdeadbeee; + ret = drmIoctl(fd, DRM_IOCTL_MODE_CREATEPROPBLOB, &create); + igt_assert(ret != 0 && errno == EFAULT); + + /* When we pass an incorrect size, the kernel should correct us. */ + prop_id = create_prop(fd); + igt_assert(prop_id != 0); + get.blob_id = prop_id; + get.length = sizeof(too_small); + get.data = (uintptr_t) too_small; + ret = drmIoctl(fd, DRM_IOCTL_MODE_GETPROPBLOB, &get); + igt_assert(ret == 0); + igt_assert(get.length == sizeof(test_mode_valid)); + + get.blob_id = prop_id; + get.data = (uintptr_t) 0xdeadbeee; + ret = drmIoctl(fd, DRM_IOCTL_MODE_GETPROPBLOB, &get); + igt_assert(ret != 0 && errno == EFAULT); +} + +static void +test_lifetime(int fd) +{ + int fd2; + uint32_t prop_id, prop_id2; + + fd2 = drm_open_any(); + + /* Ensure clients can see properties created by other clients. */ + prop_id = create_prop(fd); + igt_assert(prop_id != 0); + igt_assert(validate_prop(fd, prop_id) == 0); + igt_assert(validate_prop(fd2, prop_id) == 0); + + /* ... but can't destroy them. */ + igt_assert(destroy_prop(fd2, prop_id) != 0); + + /* Make sure properties can't be accessed once explicitly destroyed. */ + prop_id2 = create_prop(fd2); + igt_assert(prop_id2 != 0); + igt_assert(validate_prop(fd2, prop_id2) == 0); + igt_assert(destroy_prop(fd2, prop_id2) == 0); + igt_assert(validate_prop(fd2, prop_id2) != 0); + igt_assert(validate_prop(fd, prop_id2) != 0); + + /* Make sure properties are cleaned up on client exit. */ + prop_id2 = create_prop(fd2); + igt_assert(prop_id != 0); + igt_assert(validate_prop(fd, prop_id2) == 0); + close(fd2); + igt_assert(validate_prop(fd, prop_id2) != 0); + + igt_assert(validate_prop(fd, prop_id) == 0); + igt_assert(destroy_prop(fd, prop_id) == 0); + igt_assert(validate_prop(fd, prop_id) != 0); +} + +static void +test_core(int fd) +{ + uint32_t prop_id; + + /* The first hurdle. */ + prop_id = create_prop(fd); + igt_require(prop_id != 0); + igt_assert(validate_prop(fd, prop_id) == 0); + igt_assert(destroy_prop(fd, prop_id) == 0); + + /* Look up some invalid property IDs. They should fail. */ + igt_assert(validate_prop(fd, 0xffffffff) != 0); + igt_assert(validate_prop(fd, 0) != 0); +} + +static void +test_basic(int fd) +{ + uint32_t prop_id; + + prop_id = create_prop(fd); + igt_require(prop_id != 0); + igt_assert(destroy_prop(fd, prop_id) == 0); +} + +igt_main +{ + int fd; + + igt_skip_on_simulation(); + + igt_fixture { + fd = drm_open_any(); + test_basic(); + } + + igt_subtest("blob-prop-core") + test_core(fd); + + igt_subtest("blob-prop-validate") + test_validate(fd); + + igt_subtest("blob-prop-lifetime") + test_lifetime(fd); + + igt_fixture + close(fd); +}