From patchwork Tue Nov 22 17:45:08 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Thomas Gleixner X-Patchwork-Id: 24489 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:adf:f944:0:0:0:0:0 with SMTP id q4csp2353724wrr; Tue, 22 Nov 2022 09:48:14 -0800 (PST) X-Google-Smtp-Source: AA0mqf70x9h3c+IsSqNP6buPBcifQdAEEqzBnd6iP7jFfqTyp0XAfjYXEU2miaEz9+GighwRGn4d X-Received: by 2002:a17:902:e0ca:b0:187:1a3f:d552 with SMTP id e10-20020a170902e0ca00b001871a3fd552mr7122808pla.5.1669139294155; Tue, 22 Nov 2022 09:48:14 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1669139294; cv=none; d=google.com; s=arc-20160816; b=TErmAVvHV57Z/CvEVqPxJr7IKQ8YAUH5PBQSDe/qtK4Mb7x/iFlR0IAT/DHr0G6IIs Yv6smp9Lxxue1nmgWHXTUOeqjMreOQFjLhXeXCGFWGV7BZm1nclSlZo6YKd9WiIOrkgb EHv5YkPNgQFDkEgVP6G7J2BcZ4Ro09li+bMUJo27mhZnDxLCFUE2qXtAswN92pWbq0OO bu5AQVoV8KLoeGJ/SQt9/ki7CAVfsZi40xbos8uoWyaYjBZtOQLWgtblHlB8Fn1enVB4 6cRQl1yOCCMXA4wjBQ9VxTnozjnLPJaC7E6xfpKwrERoWI3m24EEBRlL+gNcDEnU3Mk/ fYww== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:date:mime-version:references:subject:cc:to:from :dkim-signature:dkim-signature:message-id; bh=WsaxXCiIFZLvl2a+KHGq5BIIa2ad2oCSb0Kkrc+3rTI=; b=FwGnIjAJ6fhbKRyCuOUtmx6FMRJpj/+IaSpqGxhNnt5KXhPWLni0r1Kw6+h4UeT/U8 js35SfwRM+6KrB496P5DsFmEVniR/QznSJe5JdRSSX7GBTLb7HdqGh8wkf770famr4DQ k8NL+tVZucddR5O9wcUaQGHyaEj1hLqMnFVeOEUf8oWRpSnCyMKCdv0SCldInxuA4MMY tubw/GtIQiN1RhAWQXUgpZdq0RzWqIcZ8EBG9uNjiypci1kT3nLAs+wQltfCPWDCwjEZ MW4h0ZxWo84yJhAFkR6EiP/NSHAltV6pKh/P+MKaTOAEXixZaSHb3ITmIzYxkk2Mki/g yhyA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linutronix.de header.s=2020 header.b=QZk3ePmc; dkim=neutral (no key) header.i=@linutronix.de header.s=2020e header.b=UpHhSaR7; 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=QUARANTINE dis=NONE) header.from=linutronix.de Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id r28-20020a63fc5c000000b00476fddead0csi15069195pgk.181.2022.11.22.09.48.00; Tue, 22 Nov 2022 09:48:14 -0800 (PST) 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=@linutronix.de header.s=2020 header.b=QZk3ePmc; dkim=neutral (no key) header.i=@linutronix.de header.s=2020e header.b=UpHhSaR7; 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=QUARANTINE dis=NONE) header.from=linutronix.de Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234558AbiKVRrI (ORCPT + 99 others); Tue, 22 Nov 2022 12:47:08 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60092 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233845AbiKVRqE (ORCPT ); Tue, 22 Nov 2022 12:46:04 -0500 Received: from galois.linutronix.de (Galois.linutronix.de [193.142.43.55]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 08ABA84314; Tue, 22 Nov 2022 09:45:12 -0800 (PST) Message-ID: <20221122173648.962476045@linutronix.de> DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linutronix.de; s=2020; t=1669139109; 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: references:references; bh=WsaxXCiIFZLvl2a+KHGq5BIIa2ad2oCSb0Kkrc+3rTI=; b=QZk3ePmcX54lYpuvD1la8aLDDNqbzt6ROoaV+JUErElnam4yZVY7Gx80SJQzUMOCXIz2Ht sTUqSOD9RkmSIvbEMhh8mA5IYB5hGkCk6PjLUL6H0fGyPYdl/ZfZJXTSXHawgDiMEPVZ1j ie/zZBLnqS7PjUC6hJ78XWcK9Zm67qla9eOD6aBhrBpUAijqU/F9iKSV3wPdSTsAigwbcu rvNOujtqnK+2NiNZRlNwB+cLlDK3AB2SWEoBhTb39UDW0jtd7hMrFDINLhByaWBOIEfBbF 4EIz1Vlu5JztZJ2Ux52LEK0oenA9lzlyzBl5opymWRLLuTZOLBZRR1H8xmAMdw== DKIM-Signature: v=1; a=ed25519-sha256; c=relaxed/relaxed; d=linutronix.de; s=2020e; t=1669139109; 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: references:references; bh=WsaxXCiIFZLvl2a+KHGq5BIIa2ad2oCSb0Kkrc+3rTI=; b=UpHhSaR7cw/qvjS025tDoaAw171dk6c6hrHbhMpv01LkMLvO0plj4En4dkHCviNYoGoAui KZXUTLpMfnOGZ+BA== From: Thomas Gleixner To: LKML Cc: Linus Torvalds , Steven Rostedt , Anna-Maria Behnsen , Peter Zijlstra , Stephen Boyd , Guenter Roeck , Andrew Morton , Julia Lawall , Arnd Bergmann , Viresh Kumar , Marc Zyngier , Marcel Holtmann , Johan Hedberg , Luiz Augusto von Dentz , linux-bluetooth@vger.kernel.org, "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , netdev@vger.kernel.org Subject: [patch V2 15/17] timers: Provide timer_shutdown[_sync]() References: <20221122171312.191765396@linutronix.de> MIME-Version: 1.0 Date: Tue, 22 Nov 2022 18:45:08 +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-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1750219305144532877?= X-GMAIL-MSGID: =?utf-8?q?1750219404150076809?= Tearing down timers which have circular dependencies to other functionality, e.g. workqueues, where the timer can schedule work and work can arm timers is not trivial. In those cases it is desired to shutdown the timer in a way which prevents rearming of the timer. The mechanism to do so it to set timer->function to NULL and use this as an indicator for the timer arming functions to ignore the (re)arm request. Expose new interfaces for this: timer_shutdown_sync() and timer_shutdown(). timer_shutdown_sync() has the same functionality as timer_delete_sync() plus the NULL-ification of the timer function. timer_shutdown() has the same functionality as timer_delete() plus the NULL-ification of the timer function. In both cases the rearming of the timer is prevented by silently discarding rearm attempts due to timer->function being NULL. Co-developed-by: Steven Rostedt Signed-off-by: Steven Rostedt Signed-off-by: Thomas Gleixner Tested-by: Guenter Roeck Link: https://lore.kernel.org/all/20220407161745.7d6754b3@gandalf.local.home Link: https://lore.kernel.org/all/20221110064101.429013735@goodmis.org --- include/linux/timer.h | 2 + kernel/time/timer.c | 66 ++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 68 insertions(+) --- a/include/linux/timer.h +++ b/include/linux/timer.h @@ -184,6 +184,8 @@ extern void add_timer(struct timer_list extern int try_to_del_timer_sync(struct timer_list *timer); extern int timer_delete_sync(struct timer_list *timer); extern int timer_delete(struct timer_list *timer); +extern int timer_shutdown_sync(struct timer_list *timer); +extern int timer_shutdown(struct timer_list *timer); /** * del_timer_sync - Delete a pending timer and wait for a running callback --- a/kernel/time/timer.c +++ b/kernel/time/timer.c @@ -1363,6 +1363,27 @@ int timer_delete(struct timer_list *time EXPORT_SYMBOL(timer_delete); /** + * timer_shutdown - Deactivate a timer and prevent rearming + * @timer: The timer to be deactivated + * + * The function does not wait for an eventually running timer callback on a + * different CPU but it prevents rearming of the timer. Any attempt to arm + * @timer after this function returns will be silently ignored. + * + * This function is useful for teardown code and should only be used when + * timer_shutdown_sync() cannot be invoked due to locking or context constraints. + * + * Return: + * * %0 - The timer was not pending + * * %1 - The timer was pending + */ +int timer_shutdown(struct timer_list *timer) +{ + return __timer_delete(timer, true); +} +EXPORT_SYMBOL_GPL(timer_shutdown); + +/** * __try_to_del_timer_sync - Internal function: Try to deactivate a timer * @timer: Timer to deactivate * @shutdown: If true, this indicates that the timer is about to be @@ -1595,6 +1616,9 @@ static int __timer_delete_sync(struct ti * lock. If there is the possibility of a concurrent rearm then the return * value of the function is meaningless. * + * If such a guarantee is needed, e.g. for teardown situations then use + * timer_shutdown_sync() instead. + * * Return: * * %0 - The timer was not pending * * %1 - The timer was pending and deactivated @@ -1605,6 +1629,48 @@ int timer_delete_sync(struct timer_list } EXPORT_SYMBOL(timer_delete_sync); +/** + * timer_shutdown_sync - Shutdown a timer and prevent rearming + * @timer: The timer to be shutdown + * + * When the function returns it is guaranteed that: + * - @timer is not queued + * - The callback function of @timer is not running + * - @timer cannot be enqueued again. Any attempt to rearm + * @timer is silently ignored. + * + * See timer_delete_sync() for synchronization rules. + * + * This function is useful for final teardown of an infrastructure where + * the timer is subject to a circular dependency problem. + * + * A common pattern for this is a timer and a workqueue where the timer can + * schedule work and work can arm the timer. On shutdown the workqueue must + * be destroyed and the timer must be prevented from rearming. Unless the + * code has conditionals like 'if (mything->in_shutdown)' to prevent that + * there is no way to get this correct with timer_delete_sync(). + * + * timer_shutdown_sync() is solving the problem. The correct ordering of + * calls in this case is: + * + * timer_shutdown_sync(&mything->timer); + * workqueue_destroy(&mything->workqueue); + * + * After this 'mything' can be safely freed. + * + * This obviously requires that the timer is not required to be functional + * for the rest of the shutdown operation. + * + * Return: + * * %0 - The timer was not pending + * * %1 - The timer was pending + */ +int timer_shutdown_sync(struct timer_list *timer) +{ + return __timer_delete_sync(timer, true); +} +EXPORT_SYMBOL_GPL(timer_shutdown_sync); + static void call_timer_fn(struct timer_list *timer, void (*fn)(struct timer_list *), unsigned long baseclk)