From patchwork Sun Oct 29 21:33:24 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Thomas Gleixner X-Patchwork-Id: 159424 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:d641:0:b0:403:3b70:6f57 with SMTP id cy1csp1863551vqb; Sun, 29 Oct 2023 14:33:42 -0700 (PDT) X-Google-Smtp-Source: AGHT+IEhhipm5IcodJtWNF+Ql5ZTq6/pFMaHbyHoNipsBJuibH+0IsGGXvyS1iipH1Y6GYT7xaOg X-Received: by 2002:a05:6e02:1e08:b0:34f:6dbb:6a2a with SMTP id g8-20020a056e021e0800b0034f6dbb6a2amr11736833ila.7.1698615222608; Sun, 29 Oct 2023 14:33:42 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1698615222; cv=none; d=google.com; s=arc-20160816; b=Nw5ggz/GPCmwgVe7KUDg852zpOPtpcXidzV8VjfulkBNX1yFK6lc0fGJ2PWJU05nTb /rN6WtAgl/RsnMN0ivKiTV96K0FWM8px10RK1B4ApD1RyyiPfCA9JE66Gn/YukSeSDBx HQWhh5Sun9rBg6hGaHcASTUGfg1KRGX2bPvirCCp/fzgJrbAN/P2XUCJYvBFFuAmzeBt QwiNCebMKzsixcixAUYlN8NLZh/UwQ2w/UUIUAKYZKHPZNq7ad+0hv7LwVMe/bTCosBW L+FzzjT5M48w/km8P+GxCJQ85a9sK9xvJJcJo2UE9T7Et5+emg+MY+bbg+2KBEx+Ajbv XsrQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:date:mime-version:content-transfer-encoding :message-id:subject:cc:to:dkim-signature:dkim-signature:from; bh=03b+M3ovvoAn9/IVDghYwfyRcYqQRt2WvXYoyE2rXIQ=; fh=6LkEhNBL2mo5Mo+t6yemqdayPsF8SyUW68IBAGIUZAo=; b=MSqUFH7QPtFkEQiBf9/KqV2v8hm27Vraylyzn/lDD0tnR3M1iI9DonSqurgRKKbYZK i8vXtf04aiuRHGvpAqyMjSBKrx+plrDDkmMlfG3lMwzfTsP2llszu27QKnRaDo2kW+xj cVyBX/xu8xIvJ57Phpj2PPDaNN7r0LSMawpekmc7AvF97A6laC5w547L0hai+7HgBB9i ZZ+VD9Z7jbooq0dkLQq8Vk1h6b61p7T5Ish5S4ruHuIIFa7vM1EMDvBYSAZQqYqrqUi0 Nj5DtvU6BNOhcl7EFoRZsmlcEUcX03hXW3VSy1bYLSKKt39fTPz1vqyc7m0LNq6dA2ru HcrQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linutronix.de header.s=2020 header.b=N9qxvrQf; dkim=neutral (no key) header.i=@linutronix.de header.s=2020e header.b=NlanTSqc; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:7 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=QUARANTINE dis=NONE) header.from=linutronix.de Received: from snail.vger.email (snail.vger.email. [2620:137:e000::3:7]) by mx.google.com with ESMTPS id 201-20020a6301d2000000b005b8ebaa2935si4212247pgb.164.2023.10.29.14.33.42 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 29 Oct 2023 14:33:42 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:7 as permitted sender) client-ip=2620:137:e000::3:7; Authentication-Results: mx.google.com; dkim=pass header.i=@linutronix.de header.s=2020 header.b=N9qxvrQf; dkim=neutral (no key) header.i=@linutronix.de header.s=2020e header.b=NlanTSqc; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:7 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=QUARANTINE dis=NONE) header.from=linutronix.de Received: from out1.vger.email (depot.vger.email [IPv6:2620:137:e000::3:0]) by snail.vger.email (Postfix) with ESMTP id A82A18074790; Sun, 29 Oct 2023 14:33:41 -0700 (PDT) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.103.10 at snail.vger.email Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230333AbjJ2Vda (ORCPT + 31 others); Sun, 29 Oct 2023 17:33:30 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37106 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229533AbjJ2Vd3 (ORCPT ); Sun, 29 Oct 2023 17:33:29 -0400 Received: from galois.linutronix.de (Galois.linutronix.de [IPv6:2a0a:51c0:0:12e:550::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 316FDBC for ; Sun, 29 Oct 2023 14:33:27 -0700 (PDT) From: Thomas Gleixner DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linutronix.de; s=2020; t=1698615204; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=03b+M3ovvoAn9/IVDghYwfyRcYqQRt2WvXYoyE2rXIQ=; b=N9qxvrQfUflXt41gKJHHciPiitsitxiJiGvrMCHLX6GOgRiu/LBeMaHNPSnpbCpAafxt3/ +fCevGoMwZe3Rc+GAfORRouHG+Tlyr5GDGpM51pLphg87EkRSy4lreXMaeYwxg8Sh2ndV+ 1MLyp3rYmMNTH2aodLIIf9uIUOsA+CAU+dn8m3pc6Snzuqf6U3xH13iGBYPSkYNvflxwnm ZdoPNXN3Fs2XcU4Rl1GfGkjHGMnGnBwMkmXycPt5kCKX5JCp8Qrqc2JPeMQyJbnayQLQab zFp786ptOpjorgJk0of5uO+0a1Dw8rJntDz1wfGrHFOvMBxju/pAgu4Syr76NA== DKIM-Signature: v=1; a=ed25519-sha256; c=relaxed/relaxed; d=linutronix.de; s=2020e; t=1698615204; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=03b+M3ovvoAn9/IVDghYwfyRcYqQRt2WvXYoyE2rXIQ=; b=NlanTSqcxIYUgdDgKgreKMkIq/0efAYuFyGyBLS83n4Tfi+3Y8hx84WhUEIkofp2Nc6guJ 0kZG2k9UEET216Dg== To: Linus Torvalds Cc: linux-kernel@vger.kernel.org, x86@kernel.org Subject: [GIT pull] core/core for v6.7-rc1 Message-ID: <169861500709.181063.7816209662289132093.tglx@xen13> MIME-Version: 1.0 Date: Sun, 29 Oct 2023 22:33:24 +0100 (CET) X-Spam-Status: No, score=-4.4 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_MED,SPF_HELO_NONE, SPF_PASS 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-Greylist: Sender passed SPF test, not delayed by milter-greylist-4.6.4 (snail.vger.email [0.0.0.0]); Sun, 29 Oct 2023 14:33:41 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1781127155579340757 X-GMAIL-MSGID: 1781127155579340757 Linus, please pull the latest core/core branch from: git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git core-core-2023-10-29-v2 up to: 1aabbc532413: signal: Don't disable preemption in ptrace_stop() on PREEMPT_RT Two small updates to ptrace_stop(): - Add a comment to explain that the preempt_disable() before unlocking tasklist lock is not a correctness problem and just avoids the tracer to preempt the tracee before the tracee schedules out. - Make that preempt_disable() conditional on PREEMPT_RT=n. RT enabled kernels cannot disable preemption at this point because cgroup_enter_frozen() and sched_submit_work() acquire spinlocks or rwlocks which are substituted by sleeping locks on RT. Acquiring a sleeping lock in a preemption disable region is obviously not possible. This obviously brings back the potential slowdown of ptrace() for RT enabled kernels, but that's a price to be payed for latency guarantees. Thanks, tglx ------------------> Sebastian Andrzej Siewior (2): signal: Add a proper comment about preempt_disable() in ptrace_stop() signal: Don't disable preemption in ptrace_stop() on PREEMPT_RT kernel/signal.c | 33 ++++++++++++++++++++++++++++----- 1 file changed, 28 insertions(+), 5 deletions(-) diff --git a/kernel/signal.c b/kernel/signal.c index 09019017d669..f2a5578326ad 100644 --- a/kernel/signal.c +++ b/kernel/signal.c @@ -2329,15 +2329,38 @@ static int ptrace_stop(int exit_code, int why, unsigned long message, do_notify_parent_cldstop(current, false, why); /* - * Don't want to allow preemption here, because - * sys_ptrace() needs this task to be inactive. + * The previous do_notify_parent_cldstop() invocation woke ptracer. + * One a PREEMPTION kernel this can result in preemption requirement + * which will be fulfilled after read_unlock() and the ptracer will be + * put on the CPU. + * The ptracer is in wait_task_inactive(, __TASK_TRACED) waiting for + * this task wait in schedule(). If this task gets preempted then it + * remains enqueued on the runqueue. The ptracer will observe this and + * then sleep for a delay of one HZ tick. In the meantime this task + * gets scheduled, enters schedule() and will wait for the ptracer. * - * XXX: implement read_unlock_no_resched(). + * This preemption point is not bad from a correctness point of + * view but extends the runtime by one HZ tick time due to the + * ptracer's sleep. The preempt-disable section ensures that there + * will be no preemption between unlock and schedule() and so + * improving the performance since the ptracer will observe that + * the tracee is scheduled out once it gets on the CPU. + * + * On PREEMPT_RT locking tasklist_lock does not disable preemption. + * Therefore the task can be preempted after do_notify_parent_cldstop() + * before unlocking tasklist_lock so there is no benefit in doing this. + * + * In fact disabling preemption is harmful on PREEMPT_RT because + * the spinlock_t in cgroup_enter_frozen() must not be acquired + * with preemption disabled due to the 'sleeping' spinlock + * substitution of RT. */ - preempt_disable(); + if (!IS_ENABLED(CONFIG_PREEMPT_RT)) + preempt_disable(); read_unlock(&tasklist_lock); cgroup_enter_frozen(); - preempt_enable_no_resched(); + if (!IS_ENABLED(CONFIG_PREEMPT_RT)) + preempt_enable_no_resched(); schedule(); cgroup_leave_frozen(true);