From patchwork Wed May 17 15:26:51 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Desnoyers X-Patchwork-Id: 95357 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:6358:3046:b0:115:7a1d:dabb with SMTP id p6csp1103602rwl; Wed, 17 May 2023 08:31:28 -0700 (PDT) X-Google-Smtp-Source: ACHHUZ6XQqEhI8UEzckzt0ufMThiegs/OI24dqVJNCidWDXuVujh83CY1FpIdQlumAfrjuQtizlL X-Received: by 2002:a05:6a00:c83:b0:646:b3f6:945c with SMTP id a3-20020a056a000c8300b00646b3f6945cmr194619pfv.4.1684337487905; Wed, 17 May 2023 08:31:27 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1684337487; cv=none; d=google.com; s=arc-20160816; b=wkXe2140sMdkYQ6TgJaFdt626H0DzYnP11C5CCOAXiHFGdkNKVO5OP0S04iMfG6nLS ymgeU5LXFzIw+UGhokdpoYh9OrH+8PlJMynprUG3UyzmZ7Uw8Yaqd1R4GFw5GBsr3KMH gtwRLuLXztd2EcsSC0khn7hVovXHa60/u1pOeEfwRMiKWsdZ/uDrrtv7eTweEtIIQEyg wNGQrVi3blErYBGUfTapmmWB4aRVkJ3UtcXWra6N2T55VHK/h8arLHyz0b/iKuAmyq7r UB+c1sVHlesfRewvmKKvbYdVlfVSG9ZB3HmwTBIwZPymE8wGgiVnHpepuPnx+xDtSs6/ f97Q== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=I+n62NOzeqoDJaIS0fVUVqcuLGX1IUfTknQBNq/CXhc=; b=kaKakaJRDaSg+1e65qCfvKfSyEdCxos05IDblQr7K2WRSbLkEnQnP480wKLou8WRCx FJGbiyrlyM9ZWA/U0QOYiP8elUqpQc1496NdtUiLaIVOcYzHH3oLcMWbOS/b3E9+5dkK oCGnn3QMC2bYrdAY+PUCuB5OZL99pX3PTErQSJmkbnAjcDoP612zfUKGfvJvu30jDUok zNbaB3Mf5HsPzObeIs5u0Wzkza+wmmcp/YGf19aC7hS224SE9gYJXD4UilsQo1qlXdYd a+/zEqGxSwul6yVXeScu3FoTo3Cf6cxnQWrDFUcCb9xXXvzGGErisJzsTw4qu5Mp2u0Q fNJg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@efficios.com header.s=smtpout1 header.b=EmcH9M9u; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=efficios.com Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id f67-20020a623846000000b0064105588e53si12070556pfa.359.2023.05.17.08.31.15; Wed, 17 May 2023 08:31:27 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@efficios.com header.s=smtpout1 header.b=EmcH9M9u; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=efficios.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231860AbjEQP1z (ORCPT + 99 others); Wed, 17 May 2023 11:27:55 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:56202 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232361AbjEQP1V (ORCPT ); Wed, 17 May 2023 11:27:21 -0400 Received: from smtpout.efficios.com (smtpout.efficios.com [167.114.26.122]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 3F41C9ECB; Wed, 17 May 2023 08:27:06 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=efficios.com; s=smtpout1; t=1684337224; bh=1RursNp9qkMTEe/+yMwWnmeNTzScNBsuw1A9Btx9VgI=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=EmcH9M9uGLTxz1YI6yx1ArarwBBRUSw2TPdgE8iVHAMD9UT7tr/3iiFq244PhEw8o +Gr9a+zVV/aRi+thfHp+rrk4OlidHlM/r6zMlInIZUBrTJkh2K2qsJKpPBI10cGrRk P7Z6U6DAmDnJdtq4tRBfv3dzZfMswU1QVRshqBB8E7eUCXAyUhgl54p8BGWpKcscaS 6kN2/UQguakV2xf384R2W3zsMUOP7vaXC9hSn41w7FJSNzFUYdm/EqCiY77zMfNheZ INdQlrRmyq1mF60w+pTO0boVcG1e8vbRqIZmnMc8jJrlAxfrM670yaz0JfbKGa+75/ 1+C6Qp62LE5IQ== Received: from localhost.localdomain (192-222-143-198.qc.cable.ebox.net [192.222.143.198]) by smtpout.efficios.com (Postfix) with ESMTPSA id 4QLxmR53HXz131r; Wed, 17 May 2023 11:27:03 -0400 (EDT) From: Mathieu Desnoyers To: Peter Zijlstra Cc: linux-kernel@vger.kernel.org, Thomas Gleixner , "Paul E . McKenney" , Boqun Feng , "H . Peter Anvin" , Paul Turner , linux-api@vger.kernel.org, Christian Brauner , Florian Weimer , David.Laight@ACULAB.COM, carlos@redhat.com, Peter Oskolkov , Alexander Mikhalitsyn , Chris Kennelly , Ingo Molnar , Darren Hart , Davidlohr Bueso , =?utf-8?q?Andr=C3=A9_Almeida?= , libc-alpha@sourceware.org, Steven Rostedt , Jonathan Corbet , Mathieu Desnoyers , Florian Weimer Subject: [RFC PATCH 1/4] rseq: Add sched_state field to struct rseq Date: Wed, 17 May 2023 11:26:51 -0400 Message-Id: <20230517152654.7193-2-mathieu.desnoyers@efficios.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20230517152654.7193-1-mathieu.desnoyers@efficios.com> References: <20230517152654.7193-1-mathieu.desnoyers@efficios.com> MIME-Version: 1.0 X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,SPF_HELO_NONE,SPF_PASS, T_SCC_BODY_TEXT_LINE,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1766155866138840401?= X-GMAIL-MSGID: =?utf-8?q?1766155866138840401?= Expose the "on-cpu" state for each thread through struct rseq to allow adaptative mutexes to decide more accurately between busy-waiting and calling sys_futex() to release the CPU, based on the on-cpu state of the mutex owner. It is only provided as an optimization hint, because there is no guarantee that the page containing this field is in the page cache, and therefore the scheduler may very well fail to clear the on-cpu state on preemption. This is expected to be rare though, and is resolved as soon as the task returns to user-space. The goal is to improve use-cases where the duration of the critical sections for a given lock follows a multi-modal distribution, preventing statistical guesses from doing a good job at choosing between busy-wait and futex wait behavior. Signed-off-by: Mathieu Desnoyers Cc: Peter Zijlstra (Intel) Cc: Jonathan Corbet Cc: Steven Rostedt (Google) Cc: Carlos O'Donell Cc: Florian Weimer Cc: libc-alpha@sourceware.org --- include/linux/sched.h | 12 ++++++++++++ include/uapi/linux/rseq.h | 17 +++++++++++++++++ kernel/rseq.c | 14 ++++++++++++++ 3 files changed, 43 insertions(+) diff --git a/include/linux/sched.h b/include/linux/sched.h index eed5d65b8d1f..c7e9248134c1 100644 --- a/include/linux/sched.h +++ b/include/linux/sched.h @@ -2351,11 +2351,20 @@ static inline void rseq_signal_deliver(struct ksignal *ksig, rseq_handle_notify_resume(ksig, regs); } +void __rseq_set_sched_state(struct task_struct *t, unsigned int state); + +static inline void rseq_set_sched_state(struct task_struct *t, unsigned int state) +{ + if (t->rseq) + __rseq_set_sched_state(t, state); +} + /* rseq_preempt() requires preemption to be disabled. */ static inline void rseq_preempt(struct task_struct *t) { __set_bit(RSEQ_EVENT_PREEMPT_BIT, &t->rseq_event_mask); rseq_set_notify_resume(t); + rseq_set_sched_state(t, 0); } /* rseq_migrate() requires preemption to be disabled. */ @@ -2405,6 +2414,9 @@ static inline void rseq_signal_deliver(struct ksignal *ksig, struct pt_regs *regs) { } +static inline void rseq_set_sched_state(struct task_struct *t, unsigned int state) +{ +} static inline void rseq_preempt(struct task_struct *t) { } diff --git a/include/uapi/linux/rseq.h b/include/uapi/linux/rseq.h index c233aae5eac9..c6d8537e23ca 100644 --- a/include/uapi/linux/rseq.h +++ b/include/uapi/linux/rseq.h @@ -37,6 +37,13 @@ enum rseq_cs_flags { (1U << RSEQ_CS_FLAG_NO_RESTART_ON_MIGRATE_BIT), }; +enum rseq_sched_state { + /* + * Task is currently running on a CPU if bit is set. + */ + RSEQ_SCHED_STATE_ON_CPU = (1U << 0), +}; + /* * struct rseq_cs is aligned on 4 * 8 bytes to ensure it is always * contained within a single cache-line. It is usually declared as @@ -148,6 +155,16 @@ struct rseq { */ __u32 mm_cid; + /* + * Restartable sequences sched_state field. Updated by the kernel. Read + * by user-space with single-copy atomicity semantics. This fields can + * be read by any userspace thread. Aligned on 32-bit. Contains a + * bitmask of enum rseq_sched_state. This field is provided as a hint + * by the scheduler, and requires that the page holding struct rseq is + * faulted-in for the state update to be performed by the scheduler. + */ + __u32 sched_state; + /* * Flexible array member at end of structure, after last feature field. */ diff --git a/kernel/rseq.c b/kernel/rseq.c index 9de6e35fe679..b2eb3bbaa9ef 100644 --- a/kernel/rseq.c +++ b/kernel/rseq.c @@ -91,6 +91,7 @@ static int rseq_update_cpu_node_id(struct task_struct *t) u32 cpu_id = raw_smp_processor_id(); u32 node_id = cpu_to_node(cpu_id); u32 mm_cid = task_mm_cid(t); + u32 sched_state = RSEQ_SCHED_STATE_ON_CPU; WARN_ON_ONCE((int) mm_cid < 0); if (!user_write_access_begin(rseq, t->rseq_len)) @@ -99,6 +100,7 @@ static int rseq_update_cpu_node_id(struct task_struct *t) unsafe_put_user(cpu_id, &rseq->cpu_id, efault_end); unsafe_put_user(node_id, &rseq->node_id, efault_end); unsafe_put_user(mm_cid, &rseq->mm_cid, efault_end); + unsafe_put_user(sched_state, &rseq->sched_state, efault_end); /* * Additional feature fields added after ORIG_RSEQ_SIZE * need to be conditionally updated only if @@ -339,6 +341,18 @@ void __rseq_handle_notify_resume(struct ksignal *ksig, struct pt_regs *regs) force_sigsegv(sig); } +/* + * Attempt to update rseq scheduler state. + */ +void __rseq_set_sched_state(struct task_struct *t, unsigned int state) +{ + if (unlikely(t->flags & PF_EXITING)) + return; + pagefault_disable(); + (void) put_user(state, &t->rseq->sched_state); + pagefault_enable(); +} + #ifdef CONFIG_DEBUG_RSEQ /* From patchwork Wed May 17 15:26:52 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Desnoyers X-Patchwork-Id: 95360 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:6358:3046:b0:115:7a1d:dabb with SMTP id p6csp1104259rwl; Wed, 17 May 2023 08:32:13 -0700 (PDT) X-Google-Smtp-Source: ACHHUZ5k7drjsyU+6KguG3ARsetoY6e9kMrNIRrNgdrzGvq+PTr5D8j5HaabyhFrktZZXEAUvpL4 X-Received: by 2002:a17:902:d2c7:b0:1a9:90bc:c3c6 with SMTP id n7-20020a170902d2c700b001a990bcc3c6mr53187420plc.16.1684337532810; Wed, 17 May 2023 08:32:12 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1684337532; cv=none; d=google.com; s=arc-20160816; b=i1ufv6LL/1udtljp9nNo9tqjImgxUiBlMhZKaeqahEXxU9EHWoN4NalZOmRNVNca9e qS0d/yx+HgHsPAqYmg47x3mfaupO8K9K1bK7dMG7fJBAoPKTsHIbzne/VrQdGS/EvcHc okYdzE41qc3iOsArK6AA3fsoXnYRkpotMAgL8HWN/SXkGF1LCwief07LPwk3XfonLDKG FK9fBaPRna4uNwNl/tnMFLMIVomgQKtnKHXbhW3W+wwpWu2hoCZOGVqdfWrDleSkQTb2 uv8f3WoTe3kK2SuFY1iz+FeehRQEjMlrnaZ3Q/ziJr5UVRRyVdsYGha5+pnX/2h77ZOb VnbQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=rFwpm2TeJ0c+EdYWU70YKVNWl31vEZpFl0AiI2tATUw=; b=aOZo41zLtLdaIkuluyUVnkThEsqKP/IzjvnVYeMgV6YTf0oMpayrj4l1vdsJIJIGpX CZZiQqHJbndT1bbFKjbM8V34lUmgQXcN8dv8J6Scu2wDDs6/Q0vcp4PP/KCvcbG1fwrx EceYwNiis4VDcvEP4tgQnvo7mP3MvknmRCoEeWQEc9e7yIOy/GQIuJNm9LFKkWjFb0dV jkdz7liMobqUsPUF7B+KmFj0JYVUAsCGunDYowEt6KvGszF9IYPYqMMuLEMvILk6+lKl P9N55LVZFlfc3kMfNdz86Uy9Tav0C9bOKaHWae/1I3xoYWcuDtzpLmvekKA27iLK1b9c It0A== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@efficios.com header.s=smtpout1 header.b=xJVyQm7G; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=efficios.com Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id h6-20020a170902eec600b001aaccc51d45si20194864plb.398.2023.05.17.08.31.59; Wed, 17 May 2023 08:32:12 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@efficios.com header.s=smtpout1 header.b=xJVyQm7G; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=efficios.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232432AbjEQP2F (ORCPT + 99 others); Wed, 17 May 2023 11:28:05 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:56172 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232356AbjEQP1U (ORCPT ); Wed, 17 May 2023 11:27:20 -0400 Received: from smtpout.efficios.com (unknown [IPv6:2607:5300:203:b2ee::31e5]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4FEE6E8; Wed, 17 May 2023 08:27:05 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=efficios.com; s=smtpout1; t=1684337224; bh=cGY+UUiS0WxsYW24i8f6zUJg+b2UGm/oIzYRyqAGABQ=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=xJVyQm7GdpTCkFgl5YFT51SZEn4RQShO5JKmoP4KqC6BkFLube50vwhpFwOY/n/s2 DO7VeKFwt9vnBWPd2OjzuULKWw0xMd3AdrBR1R4ts2sGCjsEYEnVgurvrvZvLHHHPZ gCaMCjEFGlI3+lLXub5gTl9TAqIEe4NIT3OAuWjzmXBMZV0t7tLiHW18Ai+jIwUV/i w5wbQqzRrKevyVI8TyZgcTq4vIXWS85zvCR7AEywByqoJ/OL9qe9ZaCkTJJWLO8hAi um0Nw0ZLy0DpWzOAZYKjBDH/vRGmO6eWQxAANn9/74b+NtfaGEadt5DYLjmg/OSdqx YR32xMs+jOIEw== Received: from localhost.localdomain (192-222-143-198.qc.cable.ebox.net [192.222.143.198]) by smtpout.efficios.com (Postfix) with ESMTPSA id 4QLxmS1S00z12Mc; Wed, 17 May 2023 11:27:04 -0400 (EDT) From: Mathieu Desnoyers To: Peter Zijlstra Cc: linux-kernel@vger.kernel.org, Thomas Gleixner , "Paul E . McKenney" , Boqun Feng , "H . Peter Anvin" , Paul Turner , linux-api@vger.kernel.org, Christian Brauner , Florian Weimer , David.Laight@ACULAB.COM, carlos@redhat.com, Peter Oskolkov , Alexander Mikhalitsyn , Chris Kennelly , Ingo Molnar , Darren Hart , Davidlohr Bueso , =?utf-8?q?Andr=C3=A9_Almeida?= , libc-alpha@sourceware.org, Steven Rostedt , Jonathan Corbet , Mathieu Desnoyers Subject: [RFC PATCH 2/4] selftests/rseq: Add sched_state rseq field and getter Date: Wed, 17 May 2023 11:26:52 -0400 Message-Id: <20230517152654.7193-3-mathieu.desnoyers@efficios.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20230517152654.7193-1-mathieu.desnoyers@efficios.com> References: <20230517152654.7193-1-mathieu.desnoyers@efficios.com> MIME-Version: 1.0 X-Spam-Status: No, score=-1.3 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RDNS_NONE,SPF_HELO_NONE, SPF_PASS,T_SCC_BODY_TEXT_LINE,URIBL_BLOCKED autolearn=no autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1766155912630561471?= X-GMAIL-MSGID: =?utf-8?q?1766155912630561471?= Extend struct rseq in the rseq selftests to include the sched_state field. Implement a getter function for this field. Signed-off-by: Mathieu Desnoyers --- tools/testing/selftests/rseq/rseq-abi.h | 17 +++++++++++++++++ tools/testing/selftests/rseq/rseq.h | 5 +++++ 2 files changed, 22 insertions(+) diff --git a/tools/testing/selftests/rseq/rseq-abi.h b/tools/testing/selftests/rseq/rseq-abi.h index fb4ec8a75dd4..15ec333e9eec 100644 --- a/tools/testing/selftests/rseq/rseq-abi.h +++ b/tools/testing/selftests/rseq/rseq-abi.h @@ -37,6 +37,13 @@ enum rseq_abi_cs_flags { (1U << RSEQ_ABI_CS_FLAG_NO_RESTART_ON_MIGRATE_BIT), }; +enum rseq_sched_state { + /* + * Task is currently running on a CPU if bit is set. + */ + RSEQ_SCHED_STATE_ON_CPU = (1U << 0), +}; + /* * struct rseq_abi_cs is aligned on 4 * 8 bytes to ensure it is always * contained within a single cache-line. It is usually declared as @@ -164,6 +171,16 @@ struct rseq_abi { */ __u32 mm_cid; + /* + * Restartable sequences sched_state field. Updated by the kernel. Read + * by user-space with single-copy atomicity semantics. This fields can + * be read by any userspace thread. Aligned on 32-bit. Contains a + * bitmask of enum rseq_sched_state. This field is provided as a hint + * by the scheduler, and requires that the page holding struct rseq is + * faulted-in for the state update to be performed by the scheduler. + */ + __u32 sched_state; + /* * Flexible array member at end of structure, after last feature field. */ diff --git a/tools/testing/selftests/rseq/rseq.h b/tools/testing/selftests/rseq/rseq.h index d7364ea4d201..348e9385cb2b 100644 --- a/tools/testing/selftests/rseq/rseq.h +++ b/tools/testing/selftests/rseq/rseq.h @@ -236,6 +236,11 @@ static inline void rseq_prepare_unload(void) rseq_clear_rseq_cs(); } +static inline uint32_t rseq_current_sched_state(void) +{ + return RSEQ_ACCESS_ONCE(rseq_get_abi()->sched_state); +} + static inline __attribute__((always_inline)) int rseq_cmpeqv_storev(enum rseq_mo rseq_mo, enum rseq_percpu_mode percpu_mode, intptr_t *v, intptr_t expect, From patchwork Wed May 17 15:26:53 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Desnoyers X-Patchwork-Id: 95358 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:6358:3046:b0:115:7a1d:dabb with SMTP id p6csp1103780rwl; Wed, 17 May 2023 08:31:40 -0700 (PDT) X-Google-Smtp-Source: ACHHUZ61nYK+Bqimzt9DupL3SYwOFsjTNOqpVF2txcKU7c03XyB57zON9qEiwEfQ9ZtPeog5TH04 X-Received: by 2002:a17:902:e882:b0:1aa:e30e:29d3 with SMTP id w2-20020a170902e88200b001aae30e29d3mr53243868plg.29.1684337499950; Wed, 17 May 2023 08:31:39 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1684337499; cv=none; d=google.com; s=arc-20160816; b=VQjday4Q/B7OoRlVnCPmb1KmKy5DUF2vEc8yGZeBQyM5iI6WMo/LOCSFtRBgioORJY prlIll1tUkf5IfDhYUf0otQ9LP+OVO9VJ1LrV7XAUHCCNRE3CX2Rq35/YUFwzj6Bdetw qZUy+K3d3fzySnBJsNitcn8E0R6ozlRABKv9l8U5Xw6N+eHiekVjXynZbh9cI9R+PnQj oKBxCrJ5UAds5J68ZVR/tw6tCJ3tSD6xJVMzE9PYg4Xdng93Yx/TiONz+82xcMein3zN bC+/5EESdJLricewYJX8+LYOTEQzwnP/oeVVeMNBNL5CzL+nYaIqkeSWxA2xdErUyDnS c95g== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=mqrSj2vd4XVIdxm9EDKqlQXsCArThMEl0iVqbFQ6GD0=; b=Gv49Gdjkg3+ACeCxdLvBpMU2pfrtcJk6r2TzyHhYqz5I9H6xKpyh0DEc7y+uGIyBiH KdKWu5z/Oe2Kog+tIGSMGh6L5yrckOby623fLJjrkSzjWZPgi6UMUgSz/rtirkOqkJ2Y Jk+THLU6+MIYvhaR5pkmZsR4DNzvE/x3D5PtRdcu3e41rFy8ZOevJE0C2ceqdY07pWip 6W3JzViisguwmdf1IsZ1QgGRHGH9whN1Sz2e+0cpHEFz6sy9cc+v2ylp4XFIx58Ioz7J u2SQcQaqKT++Xn2x+4Afb4w+pOjQWqJ/m29eIuDM2jC3urg2zkYsHiSnK21K2Aeni9sh jMEg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@efficios.com header.s=smtpout1 header.b=UjGsLJnT; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=efficios.com Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id co13-20020a17090afe8d00b00250252e39besi443863pjb.135.2023.05.17.08.31.27; Wed, 17 May 2023 08:31:39 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@efficios.com header.s=smtpout1 header.b=UjGsLJnT; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=efficios.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232361AbjEQP2A (ORCPT + 99 others); Wed, 17 May 2023 11:28:00 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:56210 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232363AbjEQP1V (ORCPT ); Wed, 17 May 2023 11:27:21 -0400 Received: from smtpout.efficios.com (unknown [IPv6:2607:5300:203:b2ee::31e5]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id D1192A261; Wed, 17 May 2023 08:27:05 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=efficios.com; s=smtpout1; t=1684337225; bh=hT9e3gv7K/FNrNBkQsoKYl28jg6kolO72kzwOKl/7ck=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=UjGsLJnTOSUJZOGX0pqCxp8UmKu2QdKVAklVv8sMFxW1hxxk++1JTMec8yzzJ6hGh zIIW4DzYCAbghenGdcrjT75Hcxqkqajd/mYKc66SW3Fhv2WJOOmtc+xebg2gfvgVj6 kA2uFSkq0/jqGRBAPYr8ZATbBYMUd0wrT6ze56z8pu9GZsL+O1sxiar99KFWT5OpvM dpEUejnQcO86WBJpOrezhhfLL/0CZRanKTuyAP3pIu+mtBmpEmDs1EdDuWlUUWAPXY B4GXxIzf2lu1/2I+roCswqmNGsSGDjTC42eeehii0YE/RAGjlE5GnJe3REOoujQZzZ pWYQq+ne1phFA== Received: from localhost.localdomain (192-222-143-198.qc.cable.ebox.net [192.222.143.198]) by smtpout.efficios.com (Postfix) with ESMTPSA id 4QLxmS504rz12wc; Wed, 17 May 2023 11:27:04 -0400 (EDT) From: Mathieu Desnoyers To: Peter Zijlstra Cc: linux-kernel@vger.kernel.org, Thomas Gleixner , "Paul E . McKenney" , Boqun Feng , "H . Peter Anvin" , Paul Turner , linux-api@vger.kernel.org, Christian Brauner , Florian Weimer , David.Laight@ACULAB.COM, carlos@redhat.com, Peter Oskolkov , Alexander Mikhalitsyn , Chris Kennelly , Ingo Molnar , Darren Hart , Davidlohr Bueso , =?utf-8?q?Andr=C3=A9_Almeida?= , libc-alpha@sourceware.org, Steven Rostedt , Jonathan Corbet , Mathieu Desnoyers Subject: [RFC PATCH 3/4] selftests/rseq: Implement sched state test program Date: Wed, 17 May 2023 11:26:53 -0400 Message-Id: <20230517152654.7193-4-mathieu.desnoyers@efficios.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20230517152654.7193-1-mathieu.desnoyers@efficios.com> References: <20230517152654.7193-1-mathieu.desnoyers@efficios.com> MIME-Version: 1.0 X-Spam-Status: No, score=-1.3 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RDNS_NONE,SPF_HELO_NONE, SPF_PASS,T_SCC_BODY_TEXT_LINE,URIBL_BLOCKED autolearn=no autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1766155878190836200?= X-GMAIL-MSGID: =?utf-8?q?1766155878190836200?= This is a small test program with can be altered to show whether the target thread is on-cpu or not, dependending on whether it loops on poll() or does a busy-loop. Signed-off-by: Mathieu Desnoyers --- tools/testing/selftests/rseq/.gitignore | 1 + tools/testing/selftests/rseq/Makefile | 2 +- .../testing/selftests/rseq/sched_state_test.c | 71 +++++++++++++++++++ 3 files changed, 73 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/rseq/sched_state_test.c diff --git a/tools/testing/selftests/rseq/.gitignore b/tools/testing/selftests/rseq/.gitignore index 16496de5f6ce..a8db9f7a7cec 100644 --- a/tools/testing/selftests/rseq/.gitignore +++ b/tools/testing/selftests/rseq/.gitignore @@ -9,3 +9,4 @@ param_test_compare_twice param_test_mm_cid param_test_mm_cid_benchmark param_test_mm_cid_compare_twice +sched_state_test diff --git a/tools/testing/selftests/rseq/Makefile b/tools/testing/selftests/rseq/Makefile index b357ba24af06..7c8f4f2be74c 100644 --- a/tools/testing/selftests/rseq/Makefile +++ b/tools/testing/selftests/rseq/Makefile @@ -14,7 +14,7 @@ OVERRIDE_TARGETS = 1 TEST_GEN_PROGS = basic_test basic_percpu_ops_test basic_percpu_ops_mm_cid_test param_test \ param_test_benchmark param_test_compare_twice param_test_mm_cid \ - param_test_mm_cid_benchmark param_test_mm_cid_compare_twice + param_test_mm_cid_benchmark param_test_mm_cid_compare_twice sched_state_test TEST_GEN_PROGS_EXTENDED = librseq.so diff --git a/tools/testing/selftests/rseq/sched_state_test.c b/tools/testing/selftests/rseq/sched_state_test.c new file mode 100644 index 000000000000..47aeee6d980f --- /dev/null +++ b/tools/testing/selftests/rseq/sched_state_test.c @@ -0,0 +1,71 @@ +// SPDX-License-Identifier: LGPL-2.1 + +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include + +#include "rseq.h" + +static struct rseq_abi *target_thread; + +//TODO: +//Use rseq c.s. and rseq fence to protect access to remote thread's rseq_abi. + +static +void show_sched_state(struct rseq_abi *rseq_thread) +{ + uint32_t state; + + state = rseq_thread->sched_state; + printf("Target thread: ON_CPU=%d\n", !!(state & RSEQ_SCHED_STATE_ON_CPU)); +} + + +static +void *test_thread(void *arg) +{ + int i; + + for (i = 0; i < 1000; i++) { + show_sched_state(target_thread); + (void) poll(NULL, 0, 100); + } + return NULL; +} + +int main(int argc, char **argv) +{ + pthread_t test_thread_id; + int i; + + if (rseq_register_current_thread()) { + fprintf(stderr, "Error: rseq_register_current_thread(...) failed(%d): %s\n", + errno, strerror(errno)); + goto init_thread_error; + } + target_thread = rseq_get_abi(); + + pthread_create(&test_thread_id, NULL, test_thread, NULL); + + for (i = 0; i < 1000000000; i++) + rseq_barrier(); + //for (i = 0; i < 10000; i++) + // (void) poll(NULL, 0, 75); + + pthread_join(test_thread_id, NULL); + + if (rseq_unregister_current_thread()) { + fprintf(stderr, "Error: rseq_unregister_current_thread(...) failed(%d): %s\n", + errno, strerror(errno)); + goto init_thread_error; + } + return 0; + +init_thread_error: + return -1; +} From patchwork Wed May 17 15:26:54 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Desnoyers X-Patchwork-Id: 95359 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:6358:3046:b0:115:7a1d:dabb with SMTP id p6csp1104118rwl; Wed, 17 May 2023 08:32:02 -0700 (PDT) X-Google-Smtp-Source: ACHHUZ4YAVrGShA94q2+0Lz8dC0CASVh7o7w7lhibo/XIW1lrnSoyFpQUwpsPUdXa5fdYdLBemJQ X-Received: by 2002:a17:903:2448:b0:1ab:1a6:34bc with SMTP id l8-20020a170903244800b001ab01a634bcmr52046472pls.9.1684337522559; Wed, 17 May 2023 08:32:02 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1684337522; cv=none; d=google.com; s=arc-20160816; b=fVMnMxOR6E/MctdIB8mNejtOpum/1FnVkXMQgmOp2CgTDNtGTy1rd5ZCPo87se2aod y37+o4QR876U0TJW3KI0mnaJpTw/1jLF6ZGPuv0YUYepKHLoaM+a+K+bL5i6s5N5S5nn k5Z98WcBflukHMaqrBe2yp4ylPdR+8CBLSaWTawosPYC5H/fj9vAxvIHAToWcMGpzTzo t7AK1Cd96w6FDD4rZLU++nUCgKK3hOOCciumH3xWKAQ81RjjJibQTfwjF7qsV9+LCwXA v4xvoPfgd/JX4re/0IQNd+2efJS7rGhhVVOFodAAb6qudGshsACx34DI9HL2HO93R7HX nGWQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=Qq1wVDIs+dVwNXnwpFr/UOrPE+dVUEsiQ9P+MK/TCNQ=; b=tuwfhxkjKYd4+fI5I+BVZ5KURRMp8isGoJru5j1rv3sZLinLGNmM2T1lzi2kfzy11g SvA9hRhGcf30vsRjTfDtJ9NPZ+EM15k+9I7xILCE6lI1FDLwDoNfEQl8HdDazgCGkZcp Jilp9nETQvzBv6vtp1Va8gTj8WpVAfkZpya0OnUvEaVN9+g6id1rGJpQNFMt/SFLKJx6 Qd4p5iUCQXx/iZ69xWpUNrBjzvWxh4siMAtg1ybqiSfj6Ezi3LiuaRxYHi5Ya/aA9OHc SAb8X9/wp2f1jlCi+aYXjH7h98nvm6eqIEuVhJcrj/o+Y0OSjoJWrjxIjoyBWwhoEHZD EXcQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@efficios.com header.s=smtpout1 header.b="Pf/uwYxx"; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=efficios.com Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id e9-20020a17090301c900b001a6d4eab490si22748497plh.63.2023.05.17.08.31.48; Wed, 17 May 2023 08:32:02 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@efficios.com header.s=smtpout1 header.b="Pf/uwYxx"; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=efficios.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232430AbjEQP2D (ORCPT + 99 others); Wed, 17 May 2023 11:28:03 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:56204 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232357AbjEQP1V (ORCPT ); Wed, 17 May 2023 11:27:21 -0400 Received: from smtpout.efficios.com (unknown [IPv6:2607:5300:203:b2ee::31e5]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 63E669ECC; Wed, 17 May 2023 08:27:06 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=efficios.com; s=smtpout1; t=1684337225; bh=oUBWD3uXfnEFaLFPKw63JibCtJN1wNcWvTTMTt7WX2U=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Pf/uwYxxbU/O++e8hVjspgx9b82crpxKgs6qVzKTYkrKAz+57jx+u5zvEZCnclksb 5x0sd3aETZoQFT6ZAHAhXzEagqOkpzW3Tl9WOA1VlptN2JOdiRS9Jqv9EvSlvc25hM y1TxBLPyYXGnAkMv9BPQVoDojU9oK83/x8NL+zzZQ1kfh6j8Le+h01F/4T3VrDkWkY UJXHx43mewfzDxxOTBQqMc1CuXoPbXiE2N7oCPQrOmz8clHWjaZpE6SHpqL1roOGQD RU2JyfoAYjoOFovgNap6MI/rdZL+DSo5q5Ic/ncCjQyfLM4XaKanXKYxN/zGXodtI2 QCwlzi20GPCWg== Received: from localhost.localdomain (192-222-143-198.qc.cable.ebox.net [192.222.143.198]) by smtpout.efficios.com (Postfix) with ESMTPSA id 4QLxmT1RBCz12rG; Wed, 17 May 2023 11:27:05 -0400 (EDT) From: Mathieu Desnoyers To: Peter Zijlstra Cc: linux-kernel@vger.kernel.org, Thomas Gleixner , "Paul E . McKenney" , Boqun Feng , "H . Peter Anvin" , Paul Turner , linux-api@vger.kernel.org, Christian Brauner , Florian Weimer , David.Laight@ACULAB.COM, carlos@redhat.com, Peter Oskolkov , Alexander Mikhalitsyn , Chris Kennelly , Ingo Molnar , Darren Hart , Davidlohr Bueso , =?utf-8?q?Andr=C3=A9_Almeida?= , libc-alpha@sourceware.org, Steven Rostedt , Jonathan Corbet , Mathieu Desnoyers Subject: [RFC PATCH 4/4] selftests/rseq: Implement rseq_mutex test program Date: Wed, 17 May 2023 11:26:54 -0400 Message-Id: <20230517152654.7193-5-mathieu.desnoyers@efficios.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20230517152654.7193-1-mathieu.desnoyers@efficios.com> References: <20230517152654.7193-1-mathieu.desnoyers@efficios.com> MIME-Version: 1.0 X-Spam-Status: No, score=-1.3 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RDNS_NONE,SPF_HELO_NONE, SPF_PASS,T_SCC_BODY_TEXT_LINE,URIBL_BLOCKED autolearn=no autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1766155902176174440?= X-GMAIL-MSGID: =?utf-8?q?1766155902176174440?= Example use of the rseq sched state. Signed-off-by: Mathieu Desnoyers --- tools/testing/selftests/rseq/.gitignore | 1 + tools/testing/selftests/rseq/Makefile | 3 +- tools/testing/selftests/rseq/rseq_mutex.c | 120 ++++++++++++++++++++++ 3 files changed, 123 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/rseq/rseq_mutex.c diff --git a/tools/testing/selftests/rseq/.gitignore b/tools/testing/selftests/rseq/.gitignore index a8db9f7a7cec..38d5b2fe5905 100644 --- a/tools/testing/selftests/rseq/.gitignore +++ b/tools/testing/selftests/rseq/.gitignore @@ -10,3 +10,4 @@ param_test_mm_cid param_test_mm_cid_benchmark param_test_mm_cid_compare_twice sched_state_test +rseq_mutex diff --git a/tools/testing/selftests/rseq/Makefile b/tools/testing/selftests/rseq/Makefile index 7c8f4f2be74c..a9d7ceb5b79b 100644 --- a/tools/testing/selftests/rseq/Makefile +++ b/tools/testing/selftests/rseq/Makefile @@ -14,7 +14,8 @@ OVERRIDE_TARGETS = 1 TEST_GEN_PROGS = basic_test basic_percpu_ops_test basic_percpu_ops_mm_cid_test param_test \ param_test_benchmark param_test_compare_twice param_test_mm_cid \ - param_test_mm_cid_benchmark param_test_mm_cid_compare_twice sched_state_test + param_test_mm_cid_benchmark param_test_mm_cid_compare_twice sched_state_test \ + rseq_mutex TEST_GEN_PROGS_EXTENDED = librseq.so diff --git a/tools/testing/selftests/rseq/rseq_mutex.c b/tools/testing/selftests/rseq/rseq_mutex.c new file mode 100644 index 000000000000..7e580fc6eebf --- /dev/null +++ b/tools/testing/selftests/rseq/rseq_mutex.c @@ -0,0 +1,120 @@ +// SPDX-License-Identifier: LGPL-2.1 + +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include + +#include "rseq.h" + +#define RSEQ_MUTEX_MAX_BUSY_LOOP 100 + +struct rseq_mutex { + /* + * NULL: unlocked. When non-NULL, owner points to per-thread rseq_abi + * of owner thread. + */ + struct rseq_abi *owner; +}; + +static struct rseq_mutex lock = { .owner = NULL }; + +static int testvar; + +static void rseq_lock_slowpath(struct rseq_mutex *lock) +{ + int i = 0; + + for (;;) { + struct rseq_abi *expected = NULL, *self = rseq_get_abi(); + + if (__atomic_compare_exchange_n(&lock->owner, &expected, self, false, + __ATOMIC_ACQUIRE, __ATOMIC_RELAXED)) + break; + //TODO: use rseq critical section to protect dereference of owner thread's + //rseq_abi, combined with rseq fence at thread reclaim. + if ((RSEQ_ACCESS_ONCE(expected->sched_state) & RSEQ_SCHED_STATE_ON_CPU) && + i < RSEQ_MUTEX_MAX_BUSY_LOOP) { + rseq_barrier(); /* busy-wait, e.g. cpu_relax(). */ + i++; + } else { + //TODO: Enqueue waiter in a wait-queue, and integrate + //with sys_futex rather than waiting for 10ms. + (void) poll(NULL, 0, 10); /* wait 10ms */ + } + } +} + +static void rseq_lock(struct rseq_mutex *lock) +{ + struct rseq_abi *expected = NULL, *self = rseq_get_abi(); + + if (rseq_likely(__atomic_compare_exchange_n(&lock->owner, &expected, self, false, + __ATOMIC_ACQUIRE, __ATOMIC_RELAXED))) + return; + rseq_lock_slowpath(lock); +} + +static void rseq_unlock(struct rseq_mutex *lock) +{ + __atomic_store_n(&lock->owner, NULL, __ATOMIC_RELEASE); + //TODO: integrate with sys_futex and wakeup oldest waiter. +} + +static +void *test_thread(void *arg) +{ + int i; + + if (rseq_register_current_thread()) { + fprintf(stderr, "Error: rseq_register_current_thread(...) failed(%d): %s\n", + errno, strerror(errno)); + abort(); + } + + for (i = 0; i < 1000; i++) { + int var; + + rseq_lock(&lock); + var = RSEQ_READ_ONCE(testvar); + if (var) { + fprintf(stderr, "Unexpected value %d\n", var); + abort(); + } + RSEQ_WRITE_ONCE(testvar, 1); + if (!(i % 10)) + (void) poll(NULL, 0, 10); + else + rseq_barrier(); + RSEQ_WRITE_ONCE(testvar, 0); + rseq_unlock(&lock); + } + + if (rseq_unregister_current_thread()) { + fprintf(stderr, "Error: rseq_unregister_current_thread(...) failed(%d): %s\n", + errno, strerror(errno)); + abort(); + } + return NULL; +} + +int main(int argc, char **argv) +{ + int nr_threads = 5; + pthread_t test_thread_id[nr_threads]; + int i; + + for (i = 0; i < nr_threads; i++) { + pthread_create(&test_thread_id[i], NULL, test_thread, NULL); + } + + for (i = 0; i < nr_threads; i++) { + pthread_join(test_thread_id[i], NULL); + } + + return 0; +}