From patchwork Wed Aug 9 18:49:34 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Jason Ekstrand X-Patchwork-Id: 9891657 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork.web.codeaurora.org (Postfix) with ESMTP id D4D5360363 for ; Wed, 9 Aug 2017 18:49:43 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id C44962899E for ; Wed, 9 Aug 2017 18:49:43 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id B8B05289B6; Wed, 9 Aug 2017 18:49:43 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-4.1 required=2.0 tests=BAYES_00,DKIM_SIGNED, RCVD_IN_DNSWL_MED,T_DKIM_INVALID autolearn=ham version=3.3.1 Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher DHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id ADB732899E for ; Wed, 9 Aug 2017 18:49:42 +0000 (UTC) Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 7929D6E3B8; Wed, 9 Aug 2017 18:49:41 +0000 (UTC) X-Original-To: intel-gfx@lists.freedesktop.org Delivered-To: intel-gfx@lists.freedesktop.org Received: from mail-pf0-x242.google.com (mail-pf0-x242.google.com [IPv6:2607:f8b0:400e:c00::242]) by gabe.freedesktop.org (Postfix) with ESMTPS id AE5E26E3B8 for ; Wed, 9 Aug 2017 18:49:40 +0000 (UTC) Received: by mail-pf0-x242.google.com with SMTP id c65so6905792pfl.0 for ; Wed, 09 Aug 2017 11:49:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=jlekstrand-net.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=f3YFx+Pjxyg3K2957IyNTsjBbPVFbojsUpH66b5VC5M=; b=P+5t87MQjoMMAEM/Qb/6NYjlETCa5yRJt9su3dFNx4foN5s2B68vUPvjntPTnnwE+9 Kb46xq17suEXrJEnUzhk1+w3t7OLO7UkHN1b7LS0YAcAyUNxcsOab2j2lu0s++YmowlW 2gVrFmUSoOIfX6D1KcC8TkrCY0t1zlKhE0zKSLBqZkJ4NManOzEMd03i1fPCgPwe20Wx QQP66RoZ4goopac+jCSYxKCOCMHNgZ1KDTapA5UWI5ZEeryjf24PlYK/8hMDLBT4hsnf qgO4WFW1yMIgYbrwp+5gYmE4akpEpDRCbbF7w4zU0Y5DIIBwNBjXDn0myOmLErdUhbYU 9PHw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=f3YFx+Pjxyg3K2957IyNTsjBbPVFbojsUpH66b5VC5M=; b=GYO+kWiBfEuxPzzG96nI3rgiUv0C+QyFD83L+7Fc/fgYX2h9cLbyDcwpiRPpyweDOi tGPglGWxOhTUuKZFYn9i1t3DOXEUrF6bZ0PofI2HH4JLexT9uMGwPIS3hkTjaDW76ObM MZBdpPoIwTZrK9VJEjH1YjAYQVWb0b9ZkBp6i7vrVnEd8TYCQ+WMxPSnlwLqhx1X/av7 00mEi0KSncfxy6cAr68pgtstEllcDxj0zUlaMH19GDari75ls9mTV/JrHppZbRCV0g+/ 641U+//sN54lRORNHhEvXUmFcBfbznmQrwJ81EGEobnzpYh1UOzvoiolAINCOtsbFn22 fhiQ== X-Gm-Message-State: AHYfb5hkWNZHvE1KwVFAccWh36VkIIJYy/KTd8lBgJA7rZKrLPX6gDAO JGjSgIXY/VmP208USEyo7g== X-Received: by 10.99.103.129 with SMTP id b123mr8681264pgc.14.1502304578938; Wed, 09 Aug 2017 11:49:38 -0700 (PDT) Received: from omlet.jlekstrand.net (static-50-43-41-117.bvtn.or.frontiernet.net. [50.43.41.117]) by smtp.gmail.com with ESMTPSA id g25sm9112767pfg.91.2017.08.09.11.49.37 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Wed, 09 Aug 2017 11:49:37 -0700 (PDT) From: Jason Ekstrand X-Google-Original-From: Jason Ekstrand To: intel-gfx@lists.freedesktop.org Date: Wed, 9 Aug 2017 11:49:34 -0700 Message-Id: <1502304574-12189-1-git-send-email-jason.ekstrand@intel.com> X-Mailer: git-send-email 2.5.0.400.gff86faf In-Reply-To: <1502299508-24111-1-git-send-email-jason.ekstrand@intel.com> References: <1502299508-24111-1-git-send-email-jason.ekstrand@intel.com> MIME-Version: 1.0 Cc: Jason Ekstrand Subject: [Intel-gfx] [PATCH i-g-t] syncobj: Add some wait and reset tests (v3) 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-Virus-Scanned: ClamAV using ClamSMTP This adds both trivial error-checking tests as well as more complex tests which actually test whether or not waits do what they're supposed to do. They only currently work on i915 but it should be simple to hook them up for other drivers by simply implementing the little function pointer hook provided at the top for triggering a syncobj. v2: - Actually add the reset tests. v3: - Only do one execbuf for trigger - Use do_ioctl and do_ioctl_err - Better check for syncobj support - Add local_/LOCAL_ defines of things - Use a timer instead of a pthread Signed-off-by: Jason Ekstrand --- tests/Makefile.sources | 1 + tests/syncobj_wait.c | 691 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 692 insertions(+) create mode 100644 tests/syncobj_wait.c diff --git a/tests/Makefile.sources b/tests/Makefile.sources index bb013c7..430b637 100644 --- a/tests/Makefile.sources +++ b/tests/Makefile.sources @@ -230,6 +230,7 @@ TESTS_progs = \ prime_vgem \ sw_sync \ syncobj_basic \ + syncobj_wait \ template \ tools_test \ vgem_basic \ diff --git a/tests/syncobj_wait.c b/tests/syncobj_wait.c new file mode 100644 index 0000000..d584b96 --- /dev/null +++ b/tests/syncobj_wait.c @@ -0,0 +1,691 @@ +/* + * Copyright © 2017 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. + */ + +#include "igt.h" +#include +#include +#include +#include "drm.h" + +IGT_TEST_DESCRIPTION("Tests for the drm sync object wait API"); + +/* One tenth of a second */ +#define SHORT_TIME_NSEC 100000000ull + +/** A per-platform function which triggers a set of sync objects + * + * If wait is set, the function should wait for the work to complete so + * that an immediate call to SYNCOBJ_WAIT will return success. If wait is + * not set, then the function should try to submit enough work that an + * immediate call to SYNCOBJ_WAIT with a timeout of 0 will time out. + */ +void (*trigger_syncobj)(int fd, uint32_t *syncobjs, int count, bool wait); + +#define LOCAL_SYNCOBJ_WAIT_FLAGS_WAIT_ALL (1 << 0) +#define LOCAL_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT (1 << 1) +struct local_syncobj_wait { + __u64 handles; + /* absolute timeout */ + __s64 timeout_nsec; + __u32 count_handles; + __u32 flags; + __u32 first_signaled; /* only valid when not waiting all */ + __u32 pad; +}; + +struct local_syncobj_reset { + __u32 handle; + __u32 flags; +}; + +#define LOCAL_IOCTL_SYNCOBJ_WAIT DRM_IOWR(0xC3, struct local_syncobj_wait) +#define LOCAL_IOCTL_SYNCOBJ_RESET DRM_IOWR(0xC4, struct local_syncobj_reset) + +#define NSECS_PER_SEC 1000000000ull + +static uint64_t +gettime_ns(void) +{ + struct timespec current; + clock_gettime(CLOCK_MONOTONIC, ¤t); + return (uint64_t)current.tv_sec * NSECS_PER_SEC + current.tv_nsec; +} + +static uint64_t +short_timeout(void) +{ + return gettime_ns() + SHORT_TIME_NSEC; +} + +static uint32_t +syncobj_create(int fd) +{ + struct drm_syncobj_create create = { 0 }; + int ret; + + ret = ioctl(fd, DRM_IOCTL_SYNCOBJ_CREATE, &create); + igt_assert(ret == 0); + igt_assert(create.handle > 0); + + return create.handle; +} + +static void +syncobj_destroy(int fd, uint32_t handle) +{ + struct drm_syncobj_destroy destroy = { 0 }; + int ret; + + destroy.handle = handle; + ret = ioctl(fd, DRM_IOCTL_SYNCOBJ_DESTROY, &destroy); + igt_assert(ret == 0); +} + +struct delayed_trigger { + int fd; + uint32_t *syncobjs; + int count; + uint64_t nsec; +}; + +static void +trigger_syncobj_delayed_func(union sigval sigval) +{ + struct delayed_trigger *trigger = sigval.sival_ptr; + struct timespec time; + + trigger_syncobj(trigger->fd, trigger->syncobjs, trigger->count, true); + free(trigger); +} + +static timer_t +trigger_syncobj_delayed(int fd, uint32_t *syncobjs, int count, uint64_t nsec) +{ + struct delayed_trigger *trigger; + timer_t timer; + struct sigevent sev; + struct itimerspec its; + + trigger = malloc(sizeof(*trigger)); + trigger->fd = fd; + trigger->syncobjs = syncobjs; + trigger->count = count; + trigger->nsec = nsec; + + memset(&sev, 0, sizeof(sev)); + sev.sigev_notify = SIGEV_THREAD; + sev.sigev_value.sival_ptr = trigger; + sev.sigev_notify_function = trigger_syncobj_delayed_func; + igt_assert(timer_create(CLOCK_MONOTONIC, &sev, &timer) == 0); + + memset(&its, 0, sizeof(its)); + its.it_value.tv_sec = nsec / NSEC_PER_SEC; + its.it_value.tv_nsec = nsec % NSEC_PER_SEC; + igt_assert(timer_settime(timer, 0, &its, NULL) == 0); + + return timer; +} + +static void +test_wait_bad_flags(int fd) +{ + struct local_syncobj_wait wait = { 0 }; + wait.flags = 0xdeadbeef; + do_ioctl_err(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait, EINVAL); +} + +static void +test_wait_zero_handles(int fd) +{ + struct local_syncobj_wait wait = { 0 }; + do_ioctl_err(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait, EINVAL); +} + +static void +test_wait_illegal_handle(int fd) +{ + struct local_syncobj_wait wait = { 0 }; + uint32_t handle = 0; + + wait.count_handles = 1; + wait.handles = to_user_pointer(&handle); + do_ioctl_err(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait, ENOENT); +} + +static void +test_reset_bad_flags(int fd) +{ + struct local_syncobj_reset reset = { 0 }; + reset.flags = 0xdeadbeef; + do_ioctl_err(fd, LOCAL_IOCTL_SYNCOBJ_RESET, &reset, EINVAL); +} + +static void +test_reset_illegal_handle(int fd) +{ + struct local_syncobj_reset reset = { 0 }; + reset.handle = 0; + do_ioctl_err(fd, LOCAL_IOCTL_SYNCOBJ_RESET, &reset, ENOENT); +} + +static void +test_wait_unsignaled(int fd) +{ + uint32_t syncobj = syncobj_create(fd); + struct local_syncobj_wait wait = { 0 }; + + wait.handles = to_user_pointer(&syncobj); + wait.count_handles = 1; + wait.timeout_nsec = short_timeout(); + + do_ioctl_err(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait, EINVAL); + + syncobj_destroy(fd, syncobj); +} + +static void +test_wait_for_submit_unsignaled(int fd) +{ + uint32_t syncobj = syncobj_create(fd); + struct local_syncobj_wait wait = { 0 }; + + wait.handles = to_user_pointer(&syncobj); + wait.count_handles = 1; + wait.flags = LOCAL_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT; + wait.timeout_nsec = short_timeout(); + + do_ioctl_err(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait, ETIME); + + syncobj_destroy(fd, syncobj); +} + +static void +test_wait_signaled(int fd) +{ + uint32_t syncobj = syncobj_create(fd); + struct local_syncobj_wait wait = { 0 }; + int ret; + + wait.handles = to_user_pointer(&syncobj); + wait.count_handles = 1; + + trigger_syncobj(fd, &syncobj, 1, false); + + wait.timeout_nsec = 0; + ret = drmIoctl(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait); + igt_warn_on(ret != -1 || errno != ETIME); + + wait.timeout_nsec = short_timeout(); + do_ioctl(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait); + + syncobj_destroy(fd, syncobj); +} + +static void +test_wait_for_submit_signaled(int fd) +{ + uint32_t syncobj = syncobj_create(fd); + struct local_syncobj_wait wait = { 0 }; + int ret; + + wait.handles = to_user_pointer(&syncobj); + wait.count_handles = 1; + wait.flags = LOCAL_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT; + + trigger_syncobj(fd, &syncobj, 1, false); + + wait.timeout_nsec = 0; + ret = drmIoctl(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait); + igt_warn_on(ret != -1 || errno != ETIME); + + wait.timeout_nsec = short_timeout(); + do_ioctl(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait); + + syncobj_destroy(fd, syncobj); +} + +static void +test_wait_for_submit_delayed_signal(int fd) +{ + uint32_t syncobj = syncobj_create(fd); + struct local_syncobj_wait wait = { 0 }; + timer_t timer; + + wait.handles = to_user_pointer(&syncobj); + wait.count_handles = 1; + wait.flags = LOCAL_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT; + + timer = trigger_syncobj_delayed(fd, &syncobj, 1, SHORT_TIME_NSEC); + + wait.timeout_nsec = 0; + do_ioctl_err(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait, ETIME); + + wait.timeout_nsec = gettime_ns() + SHORT_TIME_NSEC * 2; + do_ioctl(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait); + + timer_delete(timer); + + syncobj_destroy(fd, syncobj); +} + +static void +test_reset_unsignaled(int fd) +{ + uint32_t syncobj = syncobj_create(fd); + struct local_syncobj_reset reset = { 0 }; + struct local_syncobj_wait wait = { 0 }; + + wait.handles = to_user_pointer(&syncobj); + wait.count_handles = 1; + wait.flags = LOCAL_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT; + wait.timeout_nsec = 0; + + do_ioctl_err(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait, ETIME); + + reset.handle = syncobj; + + do_ioctl(fd, LOCAL_IOCTL_SYNCOBJ_RESET, &reset); + + do_ioctl_err(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait, ETIME); + + syncobj_destroy(fd, syncobj); +} + +static void +test_reset_signaled(int fd) +{ + uint32_t syncobj = syncobj_create(fd); + struct local_syncobj_reset reset = { 0 }; + struct local_syncobj_wait wait = { 0 }; + + trigger_syncobj(fd, &syncobj, 1, true); + + wait.handles = to_user_pointer(&syncobj); + wait.count_handles = 1; + wait.flags = LOCAL_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT; + wait.timeout_nsec = 0; + + do_ioctl(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait); + + reset.handle = syncobj; + + do_ioctl(fd, LOCAL_IOCTL_SYNCOBJ_RESET, &reset); + + do_ioctl_err(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait, ETIME); + + syncobj_destroy(fd, syncobj); +} + +static void +test_wait_all_signaled(int fd) +{ + struct local_syncobj_wait wait = { 0 }; + uint32_t syncobjs[2]; + + syncobjs[0] = syncobj_create(fd); + syncobjs[1] = syncobj_create(fd); + + trigger_syncobj(fd, syncobjs, 2, true); + + wait.handles = to_user_pointer(&syncobjs); + wait.count_handles = 2; + wait.timeout_nsec = short_timeout(); + wait.flags = LOCAL_SYNCOBJ_WAIT_FLAGS_WAIT_ALL; + + do_ioctl(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait); + + syncobj_destroy(fd, syncobjs[0]); + syncobj_destroy(fd, syncobjs[1]); +} + +static void +test_wait_all_some_signaled(int fd) +{ + struct local_syncobj_wait wait = { 0 }; + uint32_t syncobjs[2]; + + syncobjs[0] = syncobj_create(fd); + syncobjs[1] = syncobj_create(fd); + + trigger_syncobj(fd, syncobjs, 1, true); + + wait.handles = to_user_pointer(&syncobjs); + wait.count_handles = 2; + wait.timeout_nsec = short_timeout(); + wait.flags = LOCAL_SYNCOBJ_WAIT_FLAGS_WAIT_ALL; + + do_ioctl_err(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait, EINVAL); + + syncobj_destroy(fd, syncobjs[0]); + syncobj_destroy(fd, syncobjs[1]); +} + +static void +test_wait_any_signaled(int fd) +{ + struct local_syncobj_wait wait = { 0 }; + uint32_t syncobjs[2]; + + syncobjs[0] = syncobj_create(fd); + syncobjs[1] = syncobj_create(fd); + + trigger_syncobj(fd, syncobjs, 2, true); + + wait.handles = to_user_pointer(&syncobjs); + wait.count_handles = 2; + wait.timeout_nsec = short_timeout(); + + do_ioctl(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait); + + syncobj_destroy(fd, syncobjs[0]); + syncobj_destroy(fd, syncobjs[1]); +} + +static void +test_wait_any_some_signaled(int fd) +{ + struct local_syncobj_wait wait = { 0 }; + uint32_t syncobjs[2]; + + syncobjs[0] = syncobj_create(fd); + syncobjs[1] = syncobj_create(fd); + + trigger_syncobj(fd, syncobjs, 1, true); + + wait.handles = to_user_pointer(&syncobjs); + wait.count_handles = 2; + wait.timeout_nsec = short_timeout(); + + /* Even though we're waiting for anything, the kernel should still + * reject the unsignaled syncobj. + */ + do_ioctl_err(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait, EINVAL); + + syncobj_destroy(fd, syncobjs[0]); + syncobj_destroy(fd, syncobjs[1]); +} + +static void +test_wait_for_submit_all_some_signaled(int fd) +{ + struct local_syncobj_wait wait = { 0 }; + uint32_t syncobjs[2]; + + syncobjs[0] = syncobj_create(fd); + syncobjs[1] = syncobj_create(fd); + + trigger_syncobj(fd, syncobjs, 1, true); + + wait.handles = to_user_pointer(&syncobjs); + wait.count_handles = 2; + wait.timeout_nsec = short_timeout(); + wait.flags = LOCAL_SYNCOBJ_WAIT_FLAGS_WAIT_ALL | + LOCAL_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT; + + do_ioctl_err(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait, ETIME); + + syncobj_destroy(fd, syncobjs[0]); + syncobj_destroy(fd, syncobjs[1]); +} + +static void +test_wait_for_submit_any_some_signaled(int fd) +{ + struct local_syncobj_wait wait = { 0 }; + uint32_t tmp, syncobjs[2]; + + syncobjs[0] = syncobj_create(fd); + syncobjs[1] = syncobj_create(fd); + + trigger_syncobj(fd, syncobjs, 1, true); + + wait.handles = to_user_pointer(&syncobjs); + wait.count_handles = 2; + wait.timeout_nsec = short_timeout(); + wait.flags = LOCAL_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT; + + do_ioctl(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait); + igt_assert(wait.first_signaled == 0); + + /* Swap and try again */ + tmp = syncobjs[0]; + syncobjs[0] = syncobjs[1]; + syncobjs[1] = tmp; + + do_ioctl(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait); + igt_assert(wait.first_signaled == 1); + + syncobj_destroy(fd, syncobjs[0]); + syncobj_destroy(fd, syncobjs[1]); +} + +static void +test_wait_all_for_submit_some_delayed_signal(int fd) +{ + struct local_syncobj_wait wait = { 0 }; + uint32_t syncobjs[2]; + timer_t timer; + + syncobjs[0] = syncobj_create(fd); + syncobjs[1] = syncobj_create(fd); + + trigger_syncobj(fd, syncobjs, 1, true); + + wait.handles = to_user_pointer(&syncobjs); + wait.count_handles = 2; + wait.flags = LOCAL_SYNCOBJ_WAIT_FLAGS_WAIT_ALL | + LOCAL_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT; + + timer = trigger_syncobj_delayed(fd, &syncobjs[1], 1, SHORT_TIME_NSEC); + + wait.timeout_nsec = 0; + do_ioctl_err(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait, ETIME); + + wait.timeout_nsec = gettime_ns() + 2 * SHORT_TIME_NSEC; + do_ioctl(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait); + + timer_delete(timer); + + syncobj_destroy(fd, syncobjs[0]); + syncobj_destroy(fd, syncobjs[1]); +} + +static void +test_wait_any_for_submit_some_delayed_signal(int fd) +{ + struct local_syncobj_wait wait = { 0 }; + uint32_t syncobjs[2]; + timer_t timer; + + syncobjs[0] = syncobj_create(fd); + syncobjs[1] = syncobj_create(fd); + + wait.handles = to_user_pointer(&syncobjs); + wait.count_handles = 2; + wait.timeout_nsec = short_timeout(); + wait.flags = LOCAL_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT; + + timer = trigger_syncobj_delayed(fd, &syncobjs[1], 1, SHORT_TIME_NSEC); + + do_ioctl_err(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait, ETIME); + + wait.timeout_nsec = gettime_ns() + 2 * SHORT_TIME_NSEC; + do_ioctl(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait); + igt_assert(wait.first_signaled == 1); + + timer_delete(timer); + + syncobj_destroy(fd, syncobjs[0]); + syncobj_destroy(fd, syncobjs[1]); +} + +/******** i915 specific bits ******/ +struct local_i915_gem_exec_fence { + /** + * User's handle for a dma-fence to wait on or signal. + */ + __u32 handle; + +#define LOCAL_EXEC_FENCE_WAIT (1<<0) +#define LOCAL_EXEC_FENCE_SIGNAL (1<<1) + __u32 flags; +}; + +#define LOCAL_EXEC_FENCE_ARRAY (1<<19) + +static void +i915_trigger_syncobj(int fd, uint32_t *syncobjs, int count, bool wait) +{ + uint32_t batch_data[2] = {0, MI_BATCH_BUFFER_END}; + struct drm_i915_gem_exec_object2 exec_obj = { 0 }; + struct local_i915_gem_exec_fence *fence_array; + struct drm_i915_gem_execbuffer2 execbuf = { 0 }; + int i; + + fence_array = calloc(count, sizeof(*fence_array)); + for (i = 0; i < count; i++) { + fence_array[i].handle = syncobjs[i]; + fence_array[i].flags = LOCAL_EXEC_FENCE_SIGNAL; + } + + exec_obj.handle = gem_create(fd, 4096); + gem_write(fd, exec_obj.handle, 0, batch_data, sizeof(batch_data)); + + execbuf.buffers_ptr = to_user_pointer(&exec_obj); + execbuf.buffer_count = 1; + execbuf.batch_start_offset = 0; + execbuf.batch_len = 8; + execbuf.cliprects_ptr = to_user_pointer(fence_array); + execbuf.num_cliprects = count; + execbuf.flags = I915_EXEC_RENDER | LOCAL_EXEC_FENCE_ARRAY; + + gem_execbuf(fd, &execbuf); + + free(fence_array); + + if (wait) + gem_sync(fd, exec_obj.handle); + + gem_close(fd, exec_obj.handle); +} + +static void +i915_init(int fd) +{ + trigger_syncobj = i915_trigger_syncobj; +} +/******** end of i915 bits ******/ + +static bool +has_syncobj_wait(int fd) +{ + struct local_syncobj_wait wait = { 0 }; + uint32_t handle = 0; + uint64_t value; + int ret; + + if (drmGetCap(fd, DRM_CAP_SYNCOBJ, &value)) + return false; + if (!value) + return false; + + /* Try waiting for zero sync objects should fail with EINVAL */ + wait.count_handles = 1; + wait.handles = to_user_pointer(&handle); + ret = drmIoctl(fd, LOCAL_IOCTL_SYNCOBJ_WAIT, &wait); + return ret == -1 && errno == ENOENT; +} + +igt_main +{ + int fd; + + igt_fixture { + fd = drm_open_driver_render(DRIVER_INTEL); + igt_require_gem(fd); + igt_require(has_syncobj_wait(fd)); + + if (is_i915_device(fd)) + i915_init(fd); + } + + igt_subtest("wait-bad-flags") + test_wait_bad_flags(fd); + + igt_subtest("wait-zero-handles") + test_wait_zero_handles(fd); + + igt_subtest("wait-illegal-handle") + test_wait_illegal_handle(fd); + + igt_subtest("reset-bad-flags") + test_reset_bad_flags(fd); + + igt_subtest("reset-illegal-handle") + test_reset_illegal_handle(fd); + + igt_subtest("wait-unsignaled") + test_wait_unsignaled(fd); + + igt_subtest("wait-for-submit-unsignaled") + test_wait_for_submit_unsignaled(fd); + + igt_subtest("wait-signaled") + test_wait_signaled(fd); + + igt_subtest("wait-for-submit-signaled") + test_wait_for_submit_signaled(fd); + + igt_subtest("wait-for-submit-delayed-signal") + test_wait_for_submit_delayed_signal(fd); + + igt_subtest("reset-unsignaled") + test_reset_unsignaled(fd); + + igt_subtest("reset-signaled") + test_reset_signaled(fd); + + igt_subtest("wait-all-signaled") + test_wait_all_signaled(fd); + + igt_subtest("wait-all-some-signaled") + test_wait_all_some_signaled(fd); + + igt_subtest("wait-any-signaled") + test_wait_any_signaled(fd); + + igt_subtest("wait-any-some-signaled") + test_wait_any_some_signaled(fd); + + igt_subtest("wait-for-submit-all-some-signaled") + test_wait_for_submit_all_some_signaled(fd); + + igt_subtest("wait-for-submit-any-some-signaled") + test_wait_for_submit_any_some_signaled(fd); + + igt_subtest("wait-all-for-submit-some-delayed-signal") + test_wait_all_for_submit_some_delayed_signal(fd); + + igt_subtest("wait-any-for-submit-some-delayed-signal") + test_wait_any_for_submit_some_delayed_signal(fd); +}