From patchwork Tue Dec 11 10:37:35 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Chunming Zhou X-Patchwork-Id: 10723503 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 14B6B1751 for ; Tue, 11 Dec 2018 10:37:51 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 00476299A3 for ; Tue, 11 Dec 2018 10:37:51 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id E824E2A0DC; Tue, 11 Dec 2018 10:37:50 +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=-5.2 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_MED autolearn=unavailable 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 BDEDD2A0D7 for ; Tue, 11 Dec 2018 10:37:48 +0000 (UTC) Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 19FE66E096; Tue, 11 Dec 2018 10:37:47 +0000 (UTC) X-Original-To: intel-gfx@lists.freedesktop.org Delivered-To: intel-gfx@lists.freedesktop.org Received: from NAM04-CO1-obe.outbound.protection.outlook.com (mail-eopbgr690055.outbound.protection.outlook.com [40.107.69.55]) by gabe.freedesktop.org (Postfix) with ESMTPS id AB1A389F45; Tue, 11 Dec 2018 10:37:45 +0000 (UTC) Received: from BN4PR12CA0009.namprd12.prod.outlook.com (2603:10b6:403:2::19) by BY2PR12MB0054.namprd12.prod.outlook.com (2a01:111:e400:2c80::23) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1425.18; Tue, 11 Dec 2018 10:37:42 +0000 Received: from BY2NAM03FT041.eop-NAM03.prod.protection.outlook.com (2a01:111:f400:7e4a::205) by BN4PR12CA0009.outlook.office365.com (2603:10b6:403:2::19) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384) id 15.20.1404.18 via Frontend Transport; Tue, 11 Dec 2018 10:37:41 +0000 Received-SPF: None (protection.outlook.com: amd.com does not designate permitted sender hosts) Received: from SATLEXCHOV01.amd.com (165.204.84.17) by BY2NAM03FT041.mail.protection.outlook.com (10.152.85.246) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384) id 15.20.1425.16 via Frontend Transport; Tue, 11 Dec 2018 10:37:41 +0000 Received: from zhoucm1.amd.com (10.34.1.3) by SATLEXCHOV01.amd.com (10.181.40.71) with Microsoft SMTP Server id 14.3.389.1; Tue, 11 Dec 2018 04:37:38 -0600 From: Chunming Zhou To: , , , Date: Tue, 11 Dec 2018 18:37:35 +0800 Message-ID: <20181211103735.26058-1-david1.zhou@amd.com> X-Mailer: git-send-email 2.17.1 MIME-Version: 1.0 X-EOPAttributedMessage: 0 X-MS-Office365-Filtering-HT: Tenant X-Forefront-Antispam-Report: CIP:165.204.84.17; IPV:NLI; CTRY:US; EFV:NLI; SFV:NSPM; SFS:(10009020)(136003)(396003)(39860400002)(376002)(346002)(2980300002)(428003)(199004)(189003)(97736004)(104016004)(486006)(5820100001)(336012)(68736007)(53946003)(81166006)(5024004)(8676002)(316002)(4326008)(53936002)(14444005)(81156014)(110136005)(50226002)(8936002)(126002)(7696005)(23676004)(5660300001)(47776003)(36756003)(476003)(53416004)(106466001)(186003)(105586002)(1076002)(77096007)(2616005)(426003)(72206003)(478600001)(26005)(50466002)(4744004)(450100002)(356004)(6666004)(2870700001)(2201001)(86362001)(2906002)(305945005); DIR:OUT; SFP:1101; SCL:1; SRVR:BY2PR12MB0054; H:SATLEXCHOV01.amd.com; FPR:; SPF:None; LANG:en; PTR:InfoDomainNonexistent; A:1; MX:1; X-Microsoft-Exchange-Diagnostics: 1; BY2NAM03FT041; 1:dwFafiriVS6pAeuc2p/FMjpC08Lh/VL02RUz/lhGfjEOWul5JOKIWiuzT2kq+Wx4ysS7u3BXO6AVwF4cfbyVjPOramSxMcxd2vQOt3J4nf5E8Grw3k/lhfohckPeukcK X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 2ad5e659-c499-47d8-e072-08d65f54ada0 X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(2390098)(7020095)(4652040)(8989299)(5600074)(711020)(4534185)(4627221)(201703031133081)(201702281549075)(8990200)(2017052603328)(7153060); SRVR:BY2PR12MB0054; X-Microsoft-Exchange-Diagnostics: 1; BY2PR12MB0054; 3:Xsarjs7fkiWUd9sQrYj98IiejCJU7kDgsbUyj3UTHSt2fI4F8WkVluYt/zhwyn4cOiOKcpTb1FDjufeThEi+zb+eVySEeKjcARXkuGZcE2doN+Myk0s5UvpE5TeSrvS368oT1W06S+OeA9LYRvuH0YiVWUlW1troS5uhkP0+7varWCrK7JWCSSlHHEYG5uWCFtUUrJ67zRgYPpw46L6rkPnc6XUsSyBTE9hfq6XSN79EK8RqBhvfzP6Y1wa7YHdHk9+VrQPjq/oGQb1h0l1DMYv+VGOE4gufMsHkutXhnbRQZJaip0nUPWLzFCi0yM4F5eoJZFbxjhPohF8ljlJllMlWBGTLLpW+6JexHnY1dpo=; 25:vrcI4+hT0rfTXWZLZdCrZXoFXPl5GoQppwXFN+TXr80mGLMqFS17K2Ns7hYyGXSrLYV7TzVSXP8OJPnhM5NnakDKYN/Q2yRN/TBMbmCAaEehwsfmt0i/IYMYE8cAKYLo6eyQxe/OsUp6SdeDq+0spSRS7daA2sg+pzCzQeOSsSMzsXb6sdL878h1DIYbWqNg7/MzJ8LB0/wfIvu4de7ajIyShtf7pAiROPAPEL/51/y5vBRMBwo53TOLWgScCjX+N0mt62xVDlRxxX25/nO5WeOH/vuodZ6ewelmVjMNjwAPg/MOpiLThY4WRtNqQQhDooF2KHX+Ygd2wm5VXcLXFMjJh/DVrCivYQ1bHCSHNj8= X-MS-TrafficTypeDiagnostic: BY2PR12MB0054: X-Microsoft-Exchange-Diagnostics: 1; BY2PR12MB0054; 31:RUhX3Fdr1tpRRX+YxuWDyH0GvuqcqbqdLqDMTniteLABxxyw6Jx7hclcY0WIFw16d8LyHY8dU1O4fWlf3K689slNc3X/1UFYaBxbsPXnXYKAvPRGWWzRz+FS43YTsjqNIuGF58KGYYsFuaOOAE3KSfOAcaAKygb3tBc1FJYYry+2vYaJr9Xh9ZIM3TsClzQ8ywkxzcYLrcTQLw+o7QCbKEomKOKPP4QzNJLl3RCDr5Y=; 20:QT3vPaiwIEjYGtoGx1xV+MNpXWrTJecZwZQTsLVRPVsLo36PlHTi8zAJpvQDnFENLn1mzlLCffpi4ZimdF+FKXjgyqlgJTd20CoJwYDyPJ7UL0P6tBkXwV6dj/UYQYH31DrNFM4/kAdAkrDOiXBH8n/zn7fkwyB7ALH0edZHY7rKcWgBDKWWSQVkh+eoK+Fyb4mKF4bz7KXtjlcBmXMjAs7BLsRsuX2d4mNIu1RPfPNIrzjJyeOBC1D+5+l7lfutZL9stlG87BFFJDXl/t+H+szAvZKf/G4b5iRZm2YtwaGJtfxPufSYGRrQQuOVP0XX6ZsXe3ElpVm85t9vfvEln3FaHzV687rLl6dPR0axj7aTmdaTXDsE5Swb2jI4TVfxY+onOXdVZ5+54w61Ug/ZVkYYuuVzoqOmkfZNYnJ6PFMjLRl9hzkCopTwrboSynig6GBqrFL9gO//f95zHG8mdfNRXiPf4/Ucqa/Q7ntM9pEcN7cqFnFONRpesWQluORj X-Microsoft-Antispam-PRVS: X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(3230017)(999002)(6040522)(2401047)(8121501046)(5005006)(3231472)(944501520)(52105112)(93006095)(93003095)(10201501046)(3002001)(6055026)(148016)(149066)(150057)(6041310)(20161123558120)(20161123560045)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123564045)(20161123562045)(201708071742011)(7699051)(76991095); SRVR:BY2PR12MB0054; BCL:0; PCL:0; RULEID:; SRVR:BY2PR12MB0054; X-Microsoft-Exchange-Diagnostics: 1; BY2PR12MB0054; 4:iRQMeBhqNPaj/9n2GH5SWX5V8/71H9Ud9fCgyVo5BlQeO+UhHXhJWu/qA4DdS1X52+A9VV0QYikkSCwerKmOk+YPA7AKzObID4V8Jhq1oaoCrRTXQY6UNkVKIvhWW+0U5ATkwyiJun27JEmg+IhpiZ4+06a8wYBA+OYF/YWgpuqWIt4ZRR0fKWz59Ne2RoanZhi3IU8bG33s/k83AuID73GjdvYy2or2JE+o602L978wXff1ZnNbDgd6eaOWs0oy2Lni+JiMjFn5zaCH/W7t3A== X-Forefront-PRVS: 08831F51DC X-Microsoft-Exchange-Diagnostics: =?utf-8?q?1=3BBY2PR12MB0054=3B23=3A9/D+ARP?= =?utf-8?q?lHSISDpuf3dx3bE5CZLIHkTUKZkhyxkOaMhgh1zlge+a1F4Kf+p1JeijunUQUQSfV?= =?utf-8?q?5P8oc2x7iOEHF/kFWgaoKtjjUK731/APAW0IAzrvZ02x/6Se5QMbJxjQZybgUX4Ey?= =?utf-8?q?dYkDIy+XX8wbntE3D7QvFZnATOJAg/e6KGEmw+5RxbotNHO+6FZmc2cI2ZEVbmV69?= =?utf-8?q?JhvO+UY1gK7cGSm5WA567jXDzFmbuDpagawLrjMDkDHTnwYmoKF4cpeEjFVG7VkKT?= =?utf-8?q?qTSbQx/LSbc72342lpsJ9Il6GHtnghhFBH77TWLPhCxMT/w4y2nKz8G/SGbRtdoMQ?= =?utf-8?q?uYnDqp2veiGVyJJ7jpGiur2fD6Z4teRX0exyPrMt55fgKljU8ylTBl+Y6XLwJGR9T?= =?utf-8?q?H12/dpmNzBuUSyOI0x5HxAa264gN6PeiGiBcYv2osVhzXST/wOgAC64425pBwcUug?= =?utf-8?q?8aFjgWg8qOyu7t0Vq64n9Gd7Rjf17JqGXANsMl++QaPsls3o6IatvA8IEN6A4PGBy?= =?utf-8?q?cxiOuKCVqCzAvbpxGjeOgcbK177m9XjVS+IHDINxhLBTDccKjpnj/2S/0PAkcIrEU?= =?utf-8?q?Ovw4pM8556Hq9dXF2RpB8E/l9wq8nPeQr1rEihmP2tS6J6cxYbmV7RIc6RMHHeOgr?= =?utf-8?q?ZmBuO857/S9AGrFAwrmjnwSmqVoAW1q050Xyxwg4ykHTwwbjIdQgOYeYP81xxhnp1?= =?utf-8?q?iqYYjdNqwsK9V1Ga2IwPpVQz8B8HzKOvR/yy15qvC1A3HmoOiAkMuTql6m2s14Z2T?= =?utf-8?q?C74TzTTnzwIrSEy4yojjUcBpVfP02d9LLMn1m+KVlFrCNTm/QjBR96Es1EgTs87yF?= =?utf-8?q?6UGl3xrhZb80IHc+IkcTkBUvRH0lFkTtxJKNiXVV4ZkL4izpI4QD4SH2oQoFvS4IB?= =?utf-8?q?+a/c6CgJgSa33u6GqlW6VJ8od1uOOL+e2TXZ5A3tupRuNmJi/Yb/2sKniEOquyOSH?= =?utf-8?q?xNgh6m/Zb2pXFhhOHzmKODSkelruZBbViW8/BUQSJGt6B7OLwelj+fVQ1Xg0ZJ1JO?= =?utf-8?q?T3csUJNnHxu/sPUJ4HgLyrJsyS4a1fA1ckITnnxwAQRStNveE4xXZ5R4Yi5BATJt2?= =?utf-8?q?Fu5LhFaoiKhtdZ9NpprwGrdxUDHL38nGHLwKrzspVnecvRH0FlLKHkDebnYnBIWb1?= =?utf-8?q?iZTvL1o5bDnq7X6bBWglvgaW0aNRj1+OJpRvUMpA2MR65985egwgaWEIPc/gg=3D?= =?utf-8?q?=3D?= X-Microsoft-Antispam-Message-Info: ktY3B6nGQnhrmqXuR2/NiWrEMeI/F+vFxc5heEMJrLTiwNHUZkGXD9SKMubTS0CJ1cHvWcuD3y5xYXhYjJxyUGMQdObHpYLqIWpSG6PBJwBQRRWmIEELPqrlSHJjDSxC118f5NzVgEZzKZW4kW1qaZWLxarAbKiv1xA4xZi8jF1VcZYzLqNhz1QdjMeRO4hZgg+QnmaL/LSNKYpf+Q1DA9VI74lrr8/k7MQR27/1XkMIdzAgEJ7fphEHhACy90Vi+fjcjtkTiQgbcUxE4Zycb4fqNG1y7OxMgrdK47iqlyUbNHpJIHvmOmZnopC2ENTl X-Microsoft-Exchange-Diagnostics: 1; BY2PR12MB0054; 6:FqJHU1OFdNfue0KfjLVQAr2jasgrxvRkdGSoJ+bxjp3wphZ/PIiy0STW6KEQBI5nWQLCIskdY2AxAhhW/rCgzXuutY6xt5Wmep6Fk1ZoN0cvX8EMuvpMGhUlrNEc21iYSTV7GA2qZPdquQz3fvphr8MV3A6RkOGKKicZ6Md14qy5hbAz/eyEuvcAgbx4Sw1f79PV9Yj1DjEPs/GrltJq4E564FKbx7JedMHSgJ15ff3bNmhdFMX3wZiHdYNJhIXr34hPjp2Bm3kP0AfdRsSA6x61hhANrq4u+Pg0gRdr8nYB5Two4NB+D8h04TSlLPBura3vY8DolGWHQjvSiZvv+tftkefLUnm2o/9f1QtyQJzdsCpRAAs92PFetqzYSiyHbC4xv/khf/0pQ+D2YnwAsk+qA2vPJC2endZKipXcz0lhjy7M4d0SifDmtm+q6alEIhajNzHolsrStGtmO/CF4w==; 5:LU1fXOq+lgdkmN2iuYRWrFa+Pk3nQSA0nnXrt6SZazaQZPm7d5j+MAdL9t9rpXbu3UijFcgLnSRJBljI45IJp2a4ZcKES4QSrtFZqp8cBv9vuMxXHBYmLDYu6l1FrjDfvnvHoUSzPKeJ5K/s3mvwS38BUtyDsKYHgp1KOHRZvbU=; 7:OGarUKw9b4AsLk6hSEUCYCF2AbNf9mpbwbeGp5T9gCDFpkYa3GKaknmidZNIBxqEStPdwtkrny3yrZjGns+iTyVgkT5JoN1mAK7KxPBqCRr5M75A2vc+6fonTsZMDvaxq0bt0Klr8fM82o/PMhn0Zw== SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; BY2PR12MB0054; 20:Z7jrNBSvMeaqleoz6g/8i2Yz48u/RZZfqyS+5oQVtCGLNaQfUf3npGF0GKfrhtuPPz03MlDm96nB5mmbQFoBWpBBZMF58t1c+3SDTK6FeZE6j8lxnSB3JBobjSB87el+fitVMTboFKCWxlDXLlKWPrU662uhUaWqjJmwcBI4S4bUA5zEeMxccBLCtT1yVP8/9iMq9gcg+bNC7Zp2YqhGCI9XTmRcJmcYDO1JiPngwd9WrZ8Ckq32MQrHjNPgyZRu X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 11 Dec 2018 10:37:41.1896 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 2ad5e659-c499-47d8-e072-08d65f54ada0 X-MS-Exchange-CrossTenant-Id: 3dd8961f-e488-4e60-8e11-a82d994e183d X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=3dd8961f-e488-4e60-8e11-a82d994e183d; Ip=[165.204.84.17]; Helo=[SATLEXCHOV01.amd.com] X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: BY2PR12MB0054 Subject: [Intel-gfx] [PATCH i-g-t] igt: add timeline test cases v2 X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Chunming Zhou Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" X-Virus-Scanned: ClamAV using ClamSMTP v2: adapt to new transfer ioctl Signed-off-by: Chunming Zhou --- include/drm-uapi/drm.h | 33 ++ lib/igt_syncobj.c | 206 ++++++++ lib/igt_syncobj.h | 19 + tests/meson.build | 1 + tests/syncobj_timeline.c | 1032 ++++++++++++++++++++++++++++++++++++++ 5 files changed, 1291 insertions(+) create mode 100644 tests/syncobj_timeline.c diff --git a/include/drm-uapi/drm.h b/include/drm-uapi/drm.h index 85c685a2..dcd245d9 100644 --- a/include/drm-uapi/drm.h +++ b/include/drm-uapi/drm.h @@ -731,6 +731,8 @@ struct drm_syncobj_handle { #define DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL (1 << 0) #define DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT (1 << 1) +/* wait for time point to become available */ +#define DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE (1 << 2) struct drm_syncobj_wait { __u64 handles; /* absolute timeout */ @@ -741,11 +743,38 @@ struct drm_syncobj_wait { __u32 pad; }; +struct drm_syncobj_timeline_wait { + __u64 handles; + /* wait on specific timeline point for every handles*/ + __u64 points; + /* absolute timeout */ + __s64 timeout_nsec; + __u32 count_handles; + __u32 flags; + __u32 first_signaled; /* only valid when not waiting all */ + __u32 pad; +}; + struct drm_syncobj_array { __u64 handles; __u32 count_handles; __u32 pad; }; +struct drm_syncobj_timeline_array { + __u64 handles; + __u64 points; + __u32 count_handles; + __u32 pad; +}; + +struct drm_syncobj_transfer { + __u32 src_handle; + __u32 dst_handle; + __u64 src_point; + __u64 dst_point; + __u32 flags; + __u32 pad; +}; /* Query current scanout sequence number */ struct drm_crtc_get_sequence { @@ -902,6 +931,10 @@ extern "C" { #define DRM_IOCTL_MODE_LIST_LESSEES DRM_IOWR(0xC7, struct drm_mode_list_lessees) #define DRM_IOCTL_MODE_GET_LEASE DRM_IOWR(0xC8, struct drm_mode_get_lease) #define DRM_IOCTL_MODE_REVOKE_LEASE DRM_IOWR(0xC9, struct drm_mode_revoke_lease) +#define DRM_IOCTL_SYNCOBJ_TIMELINE_WAIT DRM_IOWR(0xCA, struct drm_syncobj_timeline_wait) +#define DRM_IOCTL_SYNCOBJ_QUERY DRM_IOWR(0xCB, struct drm_syncobj_timeline_array) +#define DRM_IOCTL_SYNCOBJ_TRANSFER DRM_IOWR(0xCC, struct drm_syncobj_transfer) +#define DRM_IOCTL_SYNCOBJ_TIMELINE_SIGNAL DRM_IOWR(0xCD, struct drm_syncobj_timeline_array) /** * Device specific ioctls should only be in their respective headers diff --git a/lib/igt_syncobj.c b/lib/igt_syncobj.c index d9114ca8..efa2adc4 100644 --- a/lib/igt_syncobj.c +++ b/lib/igt_syncobj.c @@ -286,3 +286,209 @@ syncobj_signal(int fd, uint32_t *handles, uint32_t count) { igt_assert_eq(__syncobj_signal(fd, handles, count), 0); } + +static int +__syncobj_timeline_signal(int fd, uint32_t *handles, uint64_t *points, uint32_t count) +{ + struct drm_syncobj_timeline_array array = { 0 }; + int err = 0; + + array.handles = to_user_pointer(handles); + array.points = to_user_pointer(points); + array.count_handles = count; + if (drmIoctl(fd, DRM_IOCTL_SYNCOBJ_TIMELINE_SIGNAL, &array)) + err = -errno; + return err; +} + +/** + * syncobj_signal: + * @fd: The DRM file descriptor. + * @handles: Array of syncobj handles to signal + * @points: List of point of handles to signal. + * @count: Count of syncobj handles. + * + * Signal a set of syncobjs. + */ +void +syncobj_timeline_signal(int fd, uint32_t *handles, uint64_t *points, uint32_t count) +{ + igt_assert_eq(__syncobj_timeline_signal(fd, handles, points, count), 0); +} +int +__syncobj_timeline_wait_ioctl(int fd, struct drm_syncobj_timeline_wait *args) +{ + int err = 0; + if (drmIoctl(fd, DRM_IOCTL_SYNCOBJ_TIMELINE_WAIT, args)) + err = -errno; + return err; +} +static int +__syncobj_timeline_wait(int fd, uint32_t *handles, uint64_t *points, + unsigned num_handles, + int64_t timeout_nsec, unsigned flags, + uint32_t *first_signaled) +{ + struct drm_syncobj_timeline_wait args; + int ret; + + args.handles = to_user_pointer(handles); + args.points = (uint64_t)to_user_pointer(points); + args.timeout_nsec = timeout_nsec; + args.count_handles = num_handles; + args.flags = flags; + args.first_signaled = 0; + args.pad = 0; + + ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_TIMELINE_WAIT, &args); + if (ret < 0) + return -errno; + + if (first_signaled) + *first_signaled = args.first_signaled; + + return ret; +} +int +syncobj_timeline_wait_err(int fd, uint32_t *handles, uint64_t *points, + unsigned num_handles, + int64_t timeout_nsec, unsigned flags) +{ + return __syncobj_timeline_wait(fd, handles, points, num_handles, + timeout_nsec, flags, NULL); +} + +/** + * syncobj_timeline_wait: + * @fd: The DRM file descriptor + * @handles: List of syncobj handles to wait for. + * @points: List of point of handles to wait for. + * @num_handles: Count of handles + * @timeout_nsec: Absolute wait timeout in nanoseconds. + * @flags: Wait ioctl flags. + * @first_signaled: Returned handle for first signaled syncobj. + * + * Waits in the kernel for any/all the requested syncobjs timeline point + * using the timeout and flags. + * Returns: bool value - false = timedout, true = signaled + */ +bool +syncobj_timeline_wait(int fd, uint32_t *handles, uint64_t *points, + unsigned num_handles, + int64_t timeout_nsec, unsigned flags, + uint32_t *first_signaled) +{ + int ret; + + ret = __syncobj_timeline_wait(fd, handles, points, num_handles, + timeout_nsec, flags, first_signaled); + if (ret == -ETIME) + return false; + igt_assert_eq(ret, 0); + + return true; + +} + +static int +__syncobj_timeline_query(int fd, uint32_t *handles, uint64_t **points, + uint32_t handle_count) +{ + struct drm_syncobj_timeline_array args; + int ret; + + args.handles = to_user_pointer(handles); + args.points = (uint64_t)to_user_pointer(points); + args.count_handles = handle_count; + args.pad = 0; + + ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_QUERY, &args); + if (ret) + return ret; + return 0; +} + +/** + * syncobj_timeline_query: + * @fd: The DRM file descriptor. + * @handles: Array of syncobj handles. + * @points: Array of syncobj points queried. + * @count: Count of syncobj handles. + * + * query a set of syncobjs. + */ +void +syncobj_timeline_query(int fd, uint32_t *handles, uint64_t **points, + uint32_t count) +{ + igt_assert_eq(__syncobj_timeline_query(fd, handles, points, count), 0); +} + +static int +__syncobj_binary_to_timeline(int fd, uint32_t timeline_handle, + uint64_t point, uint32_t binary_handle) +{ + struct drm_syncobj_transfer args; + + args.src_handle = binary_handle; + args.dst_handle = timeline_handle; + args.src_point = 0; + args.dst_point = point; + args.flags = 0; + args.pad = 0; + return drmIoctl(fd, DRM_IOCTL_SYNCOBJ_TRANSFER, &args); +} + +/** + * syncobj_binary_to_timeline: + * @fd: The DRM file descriptor. + * @timeline_handles: Array of timeline syncobj handles. + * @point: syncobj point. + * @binary_handle: Array of binary syncobj handles. + * + * query a set of syncobjs. + */ +void +syncobj_binary_to_timeline(int fd, uint32_t timeline_handle, + uint64_t point, uint32_t binary_handle) +{ + igt_assert_eq(__syncobj_binary_to_timeline(fd, timeline_handle, point, + binary_handle), 0); +} + +static int +__syncobj_timeline_to_binary(int fd, uint32_t binary_handle, + uint32_t timeline_handle, + uint64_t point, + uint32_t flags) +{ + struct drm_syncobj_transfer args; + + args.dst_handle = binary_handle; + args.src_handle = timeline_handle; + args.dst_point = 0; + args.src_point = point; + args.flags = flags; + args.pad = 0; + return drmIoctl(fd, DRM_IOCTL_SYNCOBJ_TRANSFER, &args); +} + +/** + * syncobj_binary_to_timeline: + * @fd: The DRM file descriptor. + * @timeline_handles: Array of timeline syncobj handles. + * @point: syncobj point. + * @binary_handle: Array of binary syncobj handles. + * + * query a set of syncobjs. + */ +void +syncobj_timeline_to_binary(int fd, uint32_t binary_handle, + uint32_t timeline_handle, + uint64_t point, + uint32_t flags) +{ + igt_assert_eq(__syncobj_timeline_to_binary(fd, binary_handle, + timeline_handle, point, + flags), 0); +} diff --git a/lib/igt_syncobj.h b/lib/igt_syncobj.h index 44d1378d..175e5027 100644 --- a/lib/igt_syncobj.h +++ b/lib/igt_syncobj.h @@ -65,7 +65,26 @@ int syncobj_wait_err(int fd, uint32_t *handles, uint32_t count, bool syncobj_wait(int fd, uint32_t *handles, uint32_t count, uint64_t abs_timeout_nsec, uint32_t flags, uint32_t *first_signaled); +int __syncobj_timeline_wait_ioctl(int fd, + struct drm_syncobj_timeline_wait *args); +bool syncobj_timeline_wait(int fd, uint32_t *handles, uint64_t *points, + unsigned num_handles, + int64_t timeout_nsec, unsigned flags, + uint32_t *first_signaled); +int syncobj_timeline_wait_err(int fd, uint32_t *handles, uint64_t *points, + unsigned num_handles, + int64_t timeout_nsec, unsigned flags); void syncobj_reset(int fd, uint32_t *handles, uint32_t count); void syncobj_signal(int fd, uint32_t *handles, uint32_t count); +void syncobj_timeline_query(int fd, uint32_t *handles, uint64_t **points, + uint32_t count); +void syncobj_binary_to_timeline(int fd, uint32_t timeline_handle, + uint64_t point, uint32_t binary_handle); +void syncobj_timeline_to_binary(int fd, uint32_t binary_handle, + uint32_t timeline_handle, + uint64_t point, + uint32_t flags); +void syncobj_timeline_signal(int fd, uint32_t *handles, uint64_t *points, + uint32_t count); #endif /* IGT_SYNCOBJ_H */ diff --git a/tests/meson.build b/tests/meson.build index b8a6e61b..bddc223c 100644 --- a/tests/meson.build +++ b/tests/meson.build @@ -77,6 +77,7 @@ test_progs = [ 'sw_sync', 'syncobj_basic', 'syncobj_wait', + 'syncobj_timeline', 'template', 'tools_test', 'v3d_get_bo_offset', diff --git a/tests/syncobj_timeline.c b/tests/syncobj_timeline.c new file mode 100644 index 00000000..505fd9ed --- /dev/null +++ b/tests/syncobj_timeline.c @@ -0,0 +1,1032 @@ +/* + * Copyright © 2018 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 "sw_sync.h" +#include "igt_syncobj.h" +#include +#include +#include +#include +#include +#include "drm.h" + +IGT_TEST_DESCRIPTION("Tests for the drm timeline sync object API"); + +/* One tenth of a second */ +#define SHORT_TIME_NSEC 100000000ull + +#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 void +sleep_nsec(uint64_t time_nsec) +{ + struct timespec t; + t.tv_sec = time_nsec / NSECS_PER_SEC; + t.tv_nsec = time_nsec % NSECS_PER_SEC; + igt_assert_eq(nanosleep(&t, NULL), 0); +} + +static uint64_t +short_timeout(void) +{ + return gettime_ns() + SHORT_TIME_NSEC; +} + +static int +syncobj_attach_sw_sync(int fd, uint32_t handle, uint64_t point) +{ + struct drm_syncobj_handle; + uint32_t syncobj = syncobj_create(fd, 0); + int timeline, fence; + + timeline = sw_sync_timeline_create(); + fence = sw_sync_timeline_create_fence(timeline, 1); + syncobj_import_sync_file(fd, syncobj, fence); + syncobj_binary_to_timeline(fd, handle, point, syncobj); + close(fence); + + syncobj_destroy(fd, syncobj); + return timeline; +} + +static void +syncobj_trigger(int fd, uint32_t handle, uint64_t point) +{ + int timeline = syncobj_attach_sw_sync(fd, handle, point); + sw_sync_timeline_inc(timeline, 1); + close(timeline); +} + +static timer_t +set_timer(void (*cb)(union sigval), void *ptr, int i, uint64_t nsec) +{ + timer_t timer; + struct sigevent sev; + struct itimerspec its; + + memset(&sev, 0, sizeof(sev)); + sev.sigev_notify = SIGEV_THREAD; + if (ptr) + sev.sigev_value.sival_ptr = ptr; + else + sev.sigev_value.sival_int = i; + sev.sigev_notify_function = cb; + 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; +} + +struct fd_handle_pair { + int fd; + uint32_t handle; + uint64_t point; +}; + +static void +timeline_inc_func(union sigval sigval) +{ + sw_sync_timeline_inc(sigval.sival_int, 1); +} + +static void +syncobj_trigger_free_pair_func(union sigval sigval) +{ + struct fd_handle_pair *pair = sigval.sival_ptr; + syncobj_trigger(pair->fd, pair->handle, pair->point); + free(pair); +} + +static timer_t +syncobj_trigger_delayed(int fd, uint32_t syncobj, uint64_t point, uint64_t nsec) +{ + struct fd_handle_pair *pair = malloc(sizeof(*pair)); + + pair->fd = fd; + pair->handle = syncobj; + pair->point = syncobj; + + return set_timer(syncobj_trigger_free_pair_func, pair, 0, nsec); +} + +static void +test_wait_bad_flags(int fd) +{ + struct drm_syncobj_timeline_wait wait = { 0 }; + wait.flags = 0xdeadbeef; + igt_assert_eq(__syncobj_timeline_wait_ioctl(fd, &wait), -EINVAL); +} + +static void +test_wait_zero_handles(int fd) +{ + struct drm_syncobj_timeline_wait wait = { 0 }; + igt_assert_eq(__syncobj_timeline_wait_ioctl(fd, &wait), -EINVAL); +} + +static void +test_wait_illegal_handle(int fd) +{ + struct drm_syncobj_timeline_wait wait = { 0 }; + uint32_t handle = 0; + + wait.count_handles = 1; + wait.handles = to_user_pointer(&handle); + igt_assert_eq(__syncobj_timeline_wait_ioctl(fd, &wait), -ENOENT); +} + +static void +test_query_zero_handles(int fd) +{ + struct drm_syncobj_timeline_array args = { 0 }; + int ret; + + ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_QUERY, &args); + igt_assert(ret == -1 && errno == EINVAL); +} + +static void +test_query_illegal_handle(int fd) +{ + struct drm_syncobj_timeline_array args = { 0 }; + uint32_t handle = 0; + int ret; + + args.count_handles = 1; + args.handles = to_user_pointer(&handle); + ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_QUERY, &args); + igt_assert(ret == -1 && errno == ENOENT); +} + +static void +test_query_one_illegal_handle(int fd) +{ + struct drm_syncobj_timeline_array array = { 0 }; + uint32_t syncobjs[3]; + uint64_t initial_point = 1; + int ret; + + syncobjs[0] = syncobj_create(fd, 0); + syncobjs[1] = 0; + syncobjs[2] = syncobj_create(fd, 0); + + syncobj_timeline_signal(fd, &syncobjs[0], &initial_point, 1); + syncobj_timeline_signal(fd, &syncobjs[2], &initial_point, 1); + igt_assert_eq(syncobj_timeline_wait_err(fd, &syncobjs[0], + &initial_point, 1, 0, 0), 0); + igt_assert_eq(syncobj_timeline_wait_err(fd, &syncobjs[2], + &initial_point, 1, 0, 0), 0); + + array.count_handles = 3; + array.handles = to_user_pointer(syncobjs); + ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_QUERY, &array); + igt_assert(ret == -1 && errno == ENOENT); + + syncobj_destroy(fd, syncobjs[0]); + syncobj_destroy(fd, syncobjs[2]); +} + +static void +test_query_bad_pad(int fd) +{ + struct drm_syncobj_timeline_array array = { 0 }; + uint32_t handle = 0; + int ret; + + array.pad = 0xdeadbeef; + array.count_handles = 1; + array.handles = to_user_pointer(&handle); + ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_QUERY, &array); + igt_assert(ret == -1 && errno == EINVAL); +} + +static void +test_signal_zero_handles(int fd) +{ + struct drm_syncobj_timeline_array args = { 0 }; + int ret; + + ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_TIMELINE_SIGNAL, &args); + igt_assert(ret == -1 && errno == EINVAL); +} + +static void +test_signal_illegal_handle(int fd) +{ + struct drm_syncobj_timeline_array args = { 0 }; + uint32_t handle = 0; + int ret; + + args.count_handles = 1; + args.handles = to_user_pointer(&handle); + ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_TIMELINE_SIGNAL, &args); + igt_assert(ret == -1 && errno == ENOENT); +} + +static void +test_signal_illegal_point(int fd) +{ + struct drm_syncobj_timeline_array args = { 0 }; + uint32_t handle = 1; + uint64_t point = 0; + int ret; + + args.count_handles = 1; + args.handles = to_user_pointer(&handle); + args.points = to_user_pointer(&point); + ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_TIMELINE_SIGNAL, &args); + igt_assert(ret == -1 && errno == ENOENT); +} +static void +test_signal_one_illegal_handle(int fd) +{ + struct drm_syncobj_timeline_array array = { 0 }; + uint32_t syncobjs[3]; + uint64_t initial_point = 1; + int ret; + + syncobjs[0] = syncobj_create(fd, 0); + syncobjs[1] = 0; + syncobjs[2] = syncobj_create(fd, 0); + + syncobj_timeline_signal(fd, &syncobjs[0], &initial_point, 1); + syncobj_timeline_signal(fd, &syncobjs[2], &initial_point, 1); + igt_assert_eq(syncobj_timeline_wait_err(fd, &syncobjs[0], + &initial_point, 1, 0, 0), 0); + igt_assert_eq(syncobj_timeline_wait_err(fd, &syncobjs[2], + &initial_point, 1, 0, 0), 0); + + array.count_handles = 3; + array.handles = to_user_pointer(syncobjs); + ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_TIMELINE_SIGNAL, &array); + igt_assert(ret == -1 && errno == ENOENT); + + syncobj_destroy(fd, syncobjs[0]); + syncobj_destroy(fd, syncobjs[2]); +} + +static void +test_signal_bad_pad(int fd) +{ + struct drm_syncobj_timeline_array array = { 0 }; + uint32_t handle = 0; + int ret; + + array.pad = 0xdeadbeef; + array.count_handles = 1; + array.handles = to_user_pointer(&handle); + ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_TIMELINE_SIGNAL, &array); + igt_assert(ret == -1 && errno == EINVAL); +} + +static void +test_signal_array(int fd) +{ + uint32_t syncobjs[4]; + uint64_t points[4] = {1, 1, 1, 0}; + + syncobjs[0] = syncobj_create(fd, 0); + syncobjs[1] = syncobj_create(fd, 0); + syncobjs[2] = syncobj_create(fd, 0); + syncobjs[3] = syncobj_create(fd, 0); + + syncobj_timeline_signal(fd, syncobjs, points, 4); + igt_assert_eq(syncobj_timeline_wait_err(fd, syncobjs, + points, 3, 0, 0), 0); + igt_assert_eq(syncobj_wait_err(fd, &syncobjs[3], 1, 0, 0), 0); + + syncobj_destroy(fd, syncobjs[0]); + syncobj_destroy(fd, syncobjs[1]); + syncobj_destroy(fd, syncobjs[2]); + syncobj_destroy(fd, syncobjs[3]); +} + +static void +test_transfer_illegal_handle(int fd) +{ + struct drm_syncobj_transfer args = { 0 }; + uint32_t handle = 0; + int ret; + + args.src_handle = to_user_pointer(&handle); + args.dst_handle = to_user_pointer(&handle); + args.src_point = 1; + args.dst_point = 0; + ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_TRANSFER, &args); + igt_assert(ret == -1 && errno == ENOENT); +} + +static void +test_transfer_bad_pad(int fd) +{ + struct drm_syncobj_transfer arg = { 0 }; + uint32_t handle = 0; + int ret; + + arg.pad = 0xdeadbeef; + arg.src_handle = to_user_pointer(&handle); + arg.dst_handle = to_user_pointer(&handle); + ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_TRANSFER, &arg); + igt_assert(ret == -1 && errno == EINVAL); +} + +#define WAIT_FOR_SUBMIT (1 << 0) +#define WAIT_ALL (1 << 1) +#define WAIT_AVAILABLE (1 << 2) +#define WAIT_UNSUBMITTED (1 << 3) +#define WAIT_SUBMITTED (1 << 4) +#define WAIT_SIGNALED (1 << 5) +#define WAIT_FLAGS_MAX (1 << 6) - 1 + +static uint32_t +flags_for_test_flags(uint32_t test_flags) +{ + uint32_t flags = 0; + + if (test_flags & WAIT_FOR_SUBMIT) + flags |= DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT; + + if (test_flags & WAIT_AVAILABLE) + flags |= DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE; + + if (test_flags & WAIT_ALL) + flags |= DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL; + + return flags; +} + +static void +test_single_wait(int fd, uint32_t test_flags, int expect) +{ + uint32_t syncobj = syncobj_create(fd, 0); + uint32_t flags = flags_for_test_flags(test_flags); + uint64_t point = 1; + int timeline = -1; + + if (test_flags & (WAIT_SUBMITTED | WAIT_SIGNALED)) + timeline = syncobj_attach_sw_sync(fd, syncobj, point); + + if (test_flags & WAIT_SIGNALED) + sw_sync_timeline_inc(timeline, 1); + + igt_assert_eq(syncobj_timeline_wait_err(fd, &syncobj, &point, 1, + 0, flags), expect); + + igt_assert_eq(syncobj_timeline_wait_err(fd, &syncobj, &point, 1, + short_timeout(), flags), expect); + + if (expect != -ETIME) { + igt_assert_eq(syncobj_timeline_wait_err(fd, &syncobj, &point, 1, + UINT64_MAX, flags), expect); + } + + syncobj_destroy(fd, syncobj); + if (timeline != -1) + close(timeline); +} + +static void +test_wait_delayed_signal(int fd, uint32_t test_flags) +{ + uint32_t syncobj = syncobj_create(fd, 0); + uint32_t flags = flags_for_test_flags(test_flags); + uint64_t point = 1; + int timeline = -1; + timer_t timer; + + if (test_flags & WAIT_FOR_SUBMIT) { + timer = syncobj_trigger_delayed(fd, syncobj, point, SHORT_TIME_NSEC); + } else { + timeline = syncobj_attach_sw_sync(fd, syncobj, point); + timer = set_timer(timeline_inc_func, NULL, + timeline, SHORT_TIME_NSEC); + } + + igt_assert(syncobj_timeline_wait(fd, &syncobj, &point, 1, + gettime_ns() + SHORT_TIME_NSEC * 2, + flags, NULL)); + + timer_delete(timer); + + if (timeline != -1) + close(timeline); + + syncobj_destroy(fd, syncobj); +} + +static void +test_reset_unsignaled(int fd) +{ + uint32_t syncobj = syncobj_create(fd, 0); + uint64_t point = 1; + + igt_assert_eq(syncobj_timeline_wait_err(fd, &syncobj, &point, + 1, 0, 0), -EINVAL); + + syncobj_reset(fd, &syncobj, 1); + + igt_assert_eq(syncobj_timeline_wait_err(fd, &syncobj, &point, + 1, 0, 0), -EINVAL); + + syncobj_destroy(fd, syncobj); +} + +static void +test_reset_signaled(int fd) +{ + uint32_t syncobj = syncobj_create(fd, 0); + uint64_t point = 1; + + syncobj_trigger(fd, syncobj, point); + + igt_assert_eq(syncobj_timeline_wait_err(fd, &syncobj, &point, + 1, 0, 0), 0); + + syncobj_reset(fd, &syncobj, 1); + + igt_assert_eq(syncobj_timeline_wait_err(fd, &syncobj, &point, + 1, 0, 0), -EINVAL); + + syncobj_destroy(fd, syncobj); +} + +static void +test_reset_multiple_signaled(int fd) +{ + uint64_t points[3] = {1, 1, 1}; + uint32_t syncobjs[3]; + int i; + + for (i = 0; i < 3; i++) { + syncobjs[i] = syncobj_create(fd, 0); + syncobj_trigger(fd, syncobjs[i], points[i]); + } + + igt_assert_eq(syncobj_timeline_wait_err(fd, syncobjs, points, 3, 0, 0), 0); + + syncobj_reset(fd, syncobjs, 3); + + for (i = 0; i < 3; i++) { + igt_assert_eq(syncobj_timeline_wait_err(fd, &syncobjs[i], + &points[i], 1, + 0, 0), -EINVAL); + syncobj_destroy(fd, syncobjs[i]); + } +} + +static void +reset_and_trigger_func(union sigval sigval) +{ + struct fd_handle_pair *pair = sigval.sival_ptr; + syncobj_reset(pair->fd, &pair->handle, 1); + syncobj_trigger(pair->fd, pair->handle, pair->point); +} + +static void +test_reset_during_wait_for_submit(int fd) +{ + uint32_t syncobj = syncobj_create(fd, 0); + uint32_t flags = LOCAL_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT; + struct fd_handle_pair pair; + uint64_t point = 1; + timer_t timer; + + pair.fd = fd; + pair.handle = syncobj; + timer = set_timer(reset_and_trigger_func, &pair, 0, SHORT_TIME_NSEC); + + /* A reset should be a no-op even if we're in the middle of a wait */ + igt_assert(syncobj_timeline_wait(fd, &syncobj, &point, 1, + gettime_ns() + SHORT_TIME_NSEC * 2, + flags, NULL)); + + timer_delete(timer); + + syncobj_destroy(fd, syncobj); +} + +static void +test_signal(int fd) +{ + uint32_t syncobj = syncobj_create(fd, 0); + uint32_t flags = LOCAL_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT; + uint64_t point = 1; + + igt_assert_eq(syncobj_timeline_wait_err(fd, &syncobj, &point, + 1, 0, 0), -EINVAL); + igt_assert_eq(syncobj_timeline_wait_err(fd, &syncobj, &point, + 1, 0, flags), -ETIME); + + syncobj_timeline_signal(fd, &syncobj, &point, 1); + + igt_assert(syncobj_timeline_wait(fd, &syncobj, &point, 1, 0, 0, NULL)); + igt_assert(syncobj_timeline_wait(fd, &syncobj, &point, 1, 0, flags, NULL)); + + syncobj_destroy(fd, syncobj); +} + +static void +test_multi_wait(int fd, uint32_t test_flags, int expect) +{ + uint32_t syncobjs[3]; + uint32_t tflag, flags; + int i, fidx, timeline; + uint64_t points[3] = {1, 1, 1}; + + syncobjs[0] = syncobj_create(fd, 0); + syncobjs[1] = syncobj_create(fd, 0); + syncobjs[2] = syncobj_create(fd, 0); + + flags = flags_for_test_flags(test_flags); + test_flags &= ~(WAIT_ALL | WAIT_FOR_SUBMIT | WAIT_AVAILABLE); + + for (i = 0; i < 3; i++) { + fidx = ffs(test_flags) - 1; + tflag = (1 << fidx); + + if (test_flags & ~tflag) + test_flags &= ~tflag; + + if (tflag & (WAIT_SUBMITTED | WAIT_SIGNALED)) + timeline = syncobj_attach_sw_sync(fd, syncobjs[i], + points[i]); + if (tflag & WAIT_SIGNALED) + sw_sync_timeline_inc(timeline, 1); + } + + igt_assert_eq(syncobj_timeline_wait_err(fd, syncobjs, points, 3, 0, flags), expect); + + igt_assert_eq(syncobj_timeline_wait_err(fd, syncobjs, points, 3, short_timeout(), + flags), expect); + + if (expect != -ETIME) { + igt_assert_eq(syncobj_timeline_wait_err(fd, syncobjs, points, 3, UINT64_MAX, + flags), expect); + } + + syncobj_destroy(fd, syncobjs[0]); + syncobj_destroy(fd, syncobjs[1]); + syncobj_destroy(fd, syncobjs[2]); +} + +struct wait_thread_data { + int fd; + struct drm_syncobj_timeline_wait wait; +}; + +static void * +wait_thread_func(void *data) +{ + struct wait_thread_data *wait = data; + igt_assert_eq(__syncobj_timeline_wait_ioctl(wait->fd, &wait->wait), 0); + return NULL; +} + +static void +test_wait_snapshot(int fd, uint32_t test_flags) +{ + struct wait_thread_data wait = { 0 }; + uint32_t syncobjs[2]; + uint64_t points[2] = {1, 1}; + int timelines[3] = { -1, -1, -1 }; + pthread_t thread; + + syncobjs[0] = syncobj_create(fd, 0); + syncobjs[1] = syncobj_create(fd, 0); + + if (!(test_flags & WAIT_FOR_SUBMIT)) { + timelines[0] = syncobj_attach_sw_sync(fd, syncobjs[0], points[0]); + timelines[1] = syncobj_attach_sw_sync(fd, syncobjs[1], points[1]); + } + + wait.fd = fd; + wait.wait.handles = to_user_pointer(syncobjs); + wait.wait.count_handles = 2; + wait.wait.points = to_user_pointer(points); + wait.wait.timeout_nsec = short_timeout(); + wait.wait.flags = flags_for_test_flags(test_flags); + + igt_assert_eq(pthread_create(&thread, NULL, wait_thread_func, &wait), 0); + + sleep_nsec(SHORT_TIME_NSEC / 5); + + /* Try to fake the kernel out by triggering or partially triggering + * the first fence. + */ + if (test_flags & WAIT_ALL) { + /* If it's WAIT_ALL, actually trigger it */ + if (timelines[0] == -1) + syncobj_trigger(fd, syncobjs[0], points[0]); + else + sw_sync_timeline_inc(timelines[0], 1); + } else if (test_flags & WAIT_FOR_SUBMIT) { + timelines[0] = syncobj_attach_sw_sync(fd, syncobjs[0], points[0]); + } + + sleep_nsec(SHORT_TIME_NSEC / 5); + + /* Then reset it */ + syncobj_reset(fd, &syncobjs[0], 1); + + sleep_nsec(SHORT_TIME_NSEC / 5); + + /* Then "submit" it in a way that will never trigger. This way, if + * the kernel picks up on the new fence (it shouldn't), we'll get a + * timeout. + */ + timelines[2] = syncobj_attach_sw_sync(fd, syncobjs[0], points[0]); + + sleep_nsec(SHORT_TIME_NSEC / 5); + + /* Now trigger the second fence to complete the wait */ + + if (timelines[1] == -1) + syncobj_trigger(fd, syncobjs[1], points[1]); + else + sw_sync_timeline_inc(timelines[1], 1); + + pthread_join(thread, NULL); + + if (!(test_flags & WAIT_ALL)) + igt_assert_eq(wait.wait.first_signaled, 1); + + close(timelines[0]); + close(timelines[1]); + close(timelines[2]); + syncobj_destroy(fd, syncobjs[0]); + syncobj_destroy(fd, syncobjs[1]); +} + +/* The numbers 0-7, each repeated 5x and shuffled. */ +static const unsigned shuffled_0_7_x4[] = { + 2, 0, 6, 1, 1, 4, 5, 2, 0, 7, 1, 7, 6, 3, 4, 5, + 0, 2, 7, 3, 5, 4, 0, 6, 7, 3, 2, 5, 6, 1, 4, 3, +}; + +enum syncobj_stage { + STAGE_UNSUBMITTED, + STAGE_SUBMITTED, + STAGE_SIGNALED, + STAGE_RESET, + STAGE_RESUBMITTED, +}; + +static void +test_wait_complex(int fd, uint32_t test_flags) +{ + struct wait_thread_data wait = { 0 }; + uint32_t syncobjs[8]; + uint64_t points[8] = {1, 1, 1, 1, 1, 1, 1, 1}; + enum syncobj_stage stage[8]; + int i, j, timelines[8]; + uint32_t first_signaled = -1, num_signaled = 0; + pthread_t thread; + + for (i = 0; i < 8; i++) { + stage[i] = STAGE_UNSUBMITTED; + syncobjs[i] = syncobj_create(fd, 0); + } + + if (test_flags & WAIT_FOR_SUBMIT) { + for (i = 0; i < 8; i++) + timelines[i] = -1; + } else { + for (i = 0; i < 8; i++) + timelines[i] = syncobj_attach_sw_sync(fd, syncobjs[i], + points[i]); + } + + wait.fd = fd; + wait.wait.handles = to_user_pointer(syncobjs); + wait.wait.count_handles = 2; + wait.wait.points = to_user_pointer(points); + wait.wait.timeout_nsec = gettime_ns() + NSECS_PER_SEC; + wait.wait.flags = flags_for_test_flags(test_flags); + + igt_assert_eq(pthread_create(&thread, NULL, wait_thread_func, &wait), 0); + + sleep_nsec(NSECS_PER_SEC / 50); + + num_signaled = 0; + for (j = 0; j < ARRAY_SIZE(shuffled_0_7_x4); j++) { + i = shuffled_0_7_x4[j]; + igt_assert_lt(i, ARRAY_SIZE(syncobjs)); + + switch (stage[i]++) { + case STAGE_UNSUBMITTED: + /* We need to submit attach a fence */ + if (!(test_flags & WAIT_FOR_SUBMIT)) { + /* We had to attach one up-front */ + igt_assert_neq(timelines[i], -1); + break; + } + timelines[i] = syncobj_attach_sw_sync(fd, syncobjs[i], + points[i]); + break; + + case STAGE_SUBMITTED: + /* We have a fence, trigger it */ + igt_assert_neq(timelines[i], -1); + sw_sync_timeline_inc(timelines[i], 1); + close(timelines[i]); + timelines[i] = -1; + if (num_signaled == 0) + first_signaled = i; + num_signaled++; + break; + + case STAGE_SIGNALED: + /* We're already signaled, reset */ + syncobj_reset(fd, &syncobjs[i], 1); + break; + + case STAGE_RESET: + /* We're reset, submit and don't signal */ + timelines[i] = syncobj_attach_sw_sync(fd, syncobjs[i], + points[i]); + break; + + case STAGE_RESUBMITTED: + igt_assert(!"Should not reach this stage"); + break; + } + + if (test_flags & WAIT_ALL) { + if (num_signaled == ARRAY_SIZE(syncobjs)) + break; + } else { + if (num_signaled > 0) + break; + } + + sleep_nsec(NSECS_PER_SEC / 100); + } + + pthread_join(thread, NULL); + + if (test_flags & WAIT_ALL) { + igt_assert_eq(num_signaled, ARRAY_SIZE(syncobjs)); + } else { + igt_assert_eq(num_signaled, 1); + igt_assert_eq(wait.wait.first_signaled, first_signaled); + } + + for (i = 0; i < 8; i++) { + close(timelines[i]); + syncobj_destroy(fd, syncobjs[i]); + } +} + +static void +test_wait_interrupted(int fd, uint32_t test_flags) +{ + struct drm_syncobj_timeline_wait wait = { 0 }; + uint32_t syncobj = syncobj_create(fd, 0); + uint64_t point = 1; + int timeline; + + wait.handles = to_user_pointer(&syncobj); + wait.points = to_user_pointer(&point); + wait.count_handles = 1; + wait.flags = flags_for_test_flags(test_flags); + + if (test_flags & WAIT_FOR_SUBMIT) { + wait.timeout_nsec = short_timeout(); + igt_while_interruptible(true) + igt_assert_eq(__syncobj_timeline_wait_ioctl(fd, &wait), -ETIME); + } + + timeline = syncobj_attach_sw_sync(fd, syncobj, point); + + wait.timeout_nsec = short_timeout(); + igt_while_interruptible(true) + igt_assert_eq(__syncobj_timeline_wait_ioctl(fd, &wait), -ETIME); + + syncobj_destroy(fd, syncobj); + close(timeline); +} + +static bool +has_syncobj_timeline_wait(int fd) +{ + struct drm_syncobj_timeline_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, DRM_IOCTL_SYNCOBJ_TIMELINE_WAIT, &wait); + return ret == -1 && errno == ENOENT; +} + +igt_main +{ + int fd = -1; + + igt_fixture { + fd = drm_open_driver(DRIVER_ANY); + igt_require(has_syncobj_timeline_wait(fd)); + igt_require_sw_sync(); + } + + igt_subtest("invalid-wait-bad-flags") + test_wait_bad_flags(fd); + + igt_subtest("invalid-wait-zero-handles") + test_wait_zero_handles(fd); + + igt_subtest("invalid-wait-illegal-handle") + test_wait_illegal_handle(fd); + + igt_subtest("invalid-query-zero-handles") + test_query_zero_handles(fd); + + igt_subtest("invalid-query-illegal-handle") + test_query_illegal_handle(fd); + + igt_subtest("invalid-query-one-illegal-handle") + test_query_one_illegal_handle(fd); + + igt_subtest("invalid-query-bad-pad") + test_query_bad_pad(fd); + + igt_subtest("invalid-signal-zero-handles") + test_signal_zero_handles(fd); + + igt_subtest("invalid-signal-illegal-handle") + test_signal_illegal_handle(fd); + + igt_subtest("invalid-signal-illegal-point") + test_signal_illegal_point(fd); + + igt_subtest("invalid-signal-one-illegal-handle") + test_signal_one_illegal_handle(fd); + + igt_subtest("invalid-signal-bad-pad") + test_signal_bad_pad(fd); + + igt_subtest("invalid-signal-array") + test_signal_array(fd); + + igt_subtest("invalid-transfer-illegal-handle") + test_transfer_illegal_handle(fd); + + igt_subtest("invalid-transfer-bad-pad") + test_transfer_bad_pad(fd); + + for (unsigned flags = 0; flags < WAIT_FLAGS_MAX; flags++) { + int err; + + /* Only one wait mode for single-wait tests */ + if (__builtin_popcount(flags & (WAIT_UNSUBMITTED | + WAIT_SUBMITTED | + WAIT_SIGNALED)) != 1) + continue; + + if ((flags & WAIT_UNSUBMITTED) && !(flags & WAIT_FOR_SUBMIT)) + err = -EINVAL; + else if (!(flags & WAIT_SIGNALED) && !((flags & WAIT_SUBMITTED) && (flags & WAIT_AVAILABLE))) + err = -ETIME; + else + err = 0; + + igt_subtest_f("%ssingle-wait%s%s%s%s%s%s", + err == -EINVAL ? "invalid-" : err == -ETIME ? "etime-" : "", + (flags & WAIT_ALL) ? "-all" : "", + (flags & WAIT_FOR_SUBMIT) ? "-for-submit" : "", + (flags & WAIT_AVAILABLE) ? "-available" : "", + (flags & WAIT_UNSUBMITTED) ? "-unsubmitted" : "", + (flags & WAIT_SUBMITTED) ? "-submitted" : "", + (flags & WAIT_SIGNALED) ? "-signaled" : "") + test_single_wait(fd, flags, err); + } + + igt_subtest("wait-delayed-signal") + test_wait_delayed_signal(fd, 0); + + igt_subtest("wait-for-submit-delayed-submit") + test_wait_delayed_signal(fd, WAIT_FOR_SUBMIT); + + igt_subtest("wait-all-delayed-signal") + test_wait_delayed_signal(fd, WAIT_ALL); + + igt_subtest("wait-all-for-submit-delayed-submit") + test_wait_delayed_signal(fd, WAIT_ALL | WAIT_FOR_SUBMIT); + + igt_subtest("reset-unsignaled") + test_reset_unsignaled(fd); + + igt_subtest("reset-signaled") + test_reset_signaled(fd); + + igt_subtest("reset-multiple-signaled") + test_reset_multiple_signaled(fd); + + igt_subtest("reset-during-wait-for-submit") + test_reset_during_wait_for_submit(fd); + + igt_subtest("signal") + test_signal(fd); + + for (unsigned flags = 0; flags < WAIT_FLAGS_MAX; flags++) { + int err; + + /* At least one wait mode for multi-wait tests */ + if (!(flags & (WAIT_UNSUBMITTED | + WAIT_SUBMITTED | + WAIT_SIGNALED))) + continue; + + err = 0; + if ((flags & WAIT_UNSUBMITTED) && !(flags & WAIT_FOR_SUBMIT)) { + err = -EINVAL; + } else if (flags & WAIT_ALL) { + if (flags & (WAIT_UNSUBMITTED | WAIT_SUBMITTED)) + err = -ETIME; + if (!(flags & WAIT_UNSUBMITTED) && (flags & WAIT_SUBMITTED) && (flags & WAIT_AVAILABLE)) + err = 0; + } else { + if (!(flags & WAIT_SIGNALED) && !((flags & WAIT_SUBMITTED) && (flags & WAIT_AVAILABLE))) + err = -ETIME; + } + + igt_subtest_f("%smulti-wait%s%s%s%s%s%s", + err == -EINVAL ? "invalid-" : err == -ETIME ? "etime-" : "", + (flags & WAIT_ALL) ? "-all" : "", + (flags & WAIT_FOR_SUBMIT) ? "-for-submit" : "", + (flags & WAIT_AVAILABLE) ? "-available" : "", + (flags & WAIT_UNSUBMITTED) ? "-unsubmitted" : "", + (flags & WAIT_SUBMITTED) ? "-submitted" : "", + (flags & WAIT_SIGNALED) ? "-signaled" : "") + test_multi_wait(fd, flags, err); + } + igt_subtest("wait-any-snapshot") + test_wait_snapshot(fd, 0); + + igt_subtest("wait-all-snapshot") + test_wait_snapshot(fd, WAIT_ALL); + + igt_subtest("wait-for-submit-snapshot") + test_wait_snapshot(fd, WAIT_FOR_SUBMIT); + + igt_subtest("wait-all-for-submit-snapshot") + test_wait_snapshot(fd, WAIT_ALL | WAIT_FOR_SUBMIT); + + igt_subtest("wait-any-complex") + test_wait_complex(fd, 0); + + igt_subtest("wait-all-complex") + test_wait_complex(fd, WAIT_ALL); + + igt_subtest("wait-for-submit-complex") + test_wait_complex(fd, WAIT_FOR_SUBMIT); + + igt_subtest("wait-all-for-submit-complex") + test_wait_complex(fd, WAIT_ALL | WAIT_FOR_SUBMIT); + + igt_subtest("wait-any-interrupted") + test_wait_interrupted(fd, 0); + + igt_subtest("wait-all-interrupted") + test_wait_interrupted(fd, WAIT_ALL); +}