net: update netdev_rx_csum_fault() print dump only once
Subsystems (6)
v3 cover net: update netdev_rx_csum_fault() print dump only once
From: Tanner Love <[email protected]>
First patch implements DO_ONCE_LITE to abstract uses of the ".data.once" trick. It is defined in its own, new header file -- rather than alongside the existing DO_ONCE in include/linux/once.h -- because include/linux/once.h includes include/linux/jump_label.h, and this causes the build to break for some architectures if include/linux/once.h is included in include/linux/printk.h or include/asm-generic/bug.h.
Second patch uses DO_ONCE_LITE in netdev_rx_csum_fault to print dump only once.
Tanner Love (2):
once: implement DO_ONCE_LITE for non-fast-path "do once" functionality
net: update netdev_rx_csum_fault() print dump only once
fs/xfs/xfs_message.h | 13 +++---------- include/asm-generic/bug.h | 37 +++++++------------------------------ include/linux/once_lite.h | 24 ++++++++++++++++++++++++ include/linux/printk.h | 23 +++-------------------- kernel/trace/trace.h | 13 +++---------- net/core/dev.c | 14 +++++++++----- 6 files changed, 49 insertions(+), 75 deletions(-) create mode 100644 include/linux/once_lite.h
Signature · 1 line
2.32.0.93.g670b81a890-goog
PATCH v3 1/2 once: implement DO_ONCE_LITE for non-fast-path "do once" functionality
From: Tanner Love <[email protected]>
Certain uses of "do once" functionality reside outside of fast path, and so do not require jump label patching via static keys, making existing DO_ONCE undesirable in such cases.
Replace uses of __section(".data.once") with DO_ONCE_LITE(_IF)?
This patch changes the return values of xfs_printk_once, printk_once, and printk_deferred_once. Before, they returned whether the print was performed, but now, they always return true. This is okay because the return values of the following macros are entirely ignored throughout the kernel:
- xfs_printk_once
- xfs_warn_once
- xfs_notice_once
- xfs_info_once
- printk_once
- pr_emerg_once
- pr_alert_once
- pr_crit_once
- pr_err_once
- pr_warn_once
- pr_notice_once
- pr_info_once
- pr_devel_once
- pr_debug_once
- printk_deferred_once
- orc_warn
Changes
v3:
- Expand commit message to explain why changing return values of xfs_printk_once, printk_once, printk_deferred_once is benign
v2:
- Fix i386 build warnings
--- fs/xfs/xfs_message.h | 13 +++---------- include/asm-generic/bug.h | 37 +++++++------------------------------ include/linux/once_lite.h | 24 ++++++++++++++++++++++++ include/linux/printk.h | 23 +++-------------------- kernel/trace/trace.h | 13 +++---------- 5 files changed, 40 insertions(+), 70 deletions(-) create mode 100644 include/linux/once_lite.h
fs/xfs/xfs_message.h +3 -10
@@ -2,6 +2,8 @@#ifndef __XFS_MESSAGE_H#define __XFS_MESSAGE_H 1 +#include <linux/once_lite.h> +struct xfs_mount ; extern __printf(2, 3)
@@ -41,16 +43,7 @@ do { \ } while (0)#define xfs_printk_once (func, dev, fmt, ...) \ -({ \ - static bool __section(".data.once") __print_once; \ - bool __ret_print_once = !__print_once; \ - \ - if (!__print_once) { \ - __print_once = true; \ - func(dev, fmt, ##__VA_ARGS__); \ - } \ - unlikely(__ret_print_once); \ -}) + DO_ONCE_LITE(func, dev, fmt, ##__VA_ARGS__)#define xfs_emerg_ratelimited (dev, fmt, ...) \ xfs_printk_ratelimited(xfs_emerg, dev, fmt, ##__VA_ARGS__)
include/asm-generic/bug.h +7 -30
@@ -4,6 +4,7 @@#include <linux/compiler.h> #include <linux/instrumentation.h> +#include <linux/once_lite.h> #define CUT_HERE "------------[ cut here ]------------\n"
@@ -140,39 +141,15 @@ void __warn(const char *file, int line, void *caller, unsigned taint, })#ifndef WARN_ON_ONCE -#define WARN_ON_ONCE (condition) ({ \ - static bool __section(".data.once") __warned; \ - int __ret_warn_once = !!(condition); \ - \ - if (unlikely(__ret_warn_once && !__warned)) { \ - __warned = true; \ - WARN_ON(1); \ - } \ - unlikely(__ret_warn_once); \ -}) +#define WARN_ON_ONCE (condition) \ + DO_ONCE_LITE_IF(condition, WARN_ON, 1)#endif -#define WARN_ONCE(condition, format...) ({ \ - static bool __section(".data.once") __warned; \ - int __ret_warn_once = !!(condition); \ - \ - if (unlikely(__ret_warn_once && !__warned)) { \ - __warned = true; \ - WARN(1, format); \ - } \ - unlikely(__ret_warn_once); \ -}) +#define WARN_ONCE(condition, format...) \ + DO_ONCE_LITE_IF(condition, WARN, 1, format) -#define WARN_TAINT_ONCE(condition, taint, format...) ({ \ - static bool __section(".data.once") __warned; \ - int __ret_warn_once = !!(condition); \ - \ - if (unlikely(__ret_warn_once && !__warned)) { \ - __warned = true; \ - WARN_TAINT(1, taint, format); \ - } \ - unlikely(__ret_warn_once); \ -}) +#define WARN_TAINT_ONCE(condition, taint, format...) \ + DO_ONCE_LITE_IF(condition, WARN_TAINT, 1, taint, format)#else /* !CONFIG_BUG */ #ifndef HAVE_ARCH_BUG
include/linux/once_lite.h new file +24 -0
@@ -0,0 +1,24 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _LINUX_ONCE_LITE_H +#define _LINUX_ONCE_LITE_H + +#include <linux/types.h> + +/* Call a function once. Similar to DO_ONCE(), but does not use jump label +* patching via static keys. +*/ +#define DO_ONCE_LITE (func, ...) \ + DO_ONCE_LITE_IF(true, func, ##__VA_ARGS__) +#define DO_ONCE_LITE_IF (condition, func, ...) \ + ({ \ + static bool __section(".data.once") __already_done; \ + bool __ret_do_once = !!(condition); \ + \ + if (unlikely(__ret_do_once && !__already_done)) { \ + __already_done = true; \ + func(__VA_ARGS__); \ + } \ + unlikely(__ret_do_once); \ + }) + +#endif /* _LINUX_ONCE_LITE_H */
include/linux/printk.h +3 -20
@@ -8,6 +8,7 @@#include <linux/linkage.h> #include <linux/cache.h> #include <linux/ratelimit_types.h> +#include <linux/once_lite.h> extern const char linux_banner[];extern const char linux_proc_banner[];
@@ -436,27 +437,9 @@ extern int kptr_restrict;#ifdef CONFIG_PRINTK #define printk_once (fmt, ...) \ -({ \ - static bool __section(".data.once") __print_once; \ - bool __ret_print_once = !__print_once; \ - \ - if (!__print_once) { \ - __print_once = true; \ - printk(fmt, ##__VA_ARGS__); \ - } \ - unlikely(__ret_print_once); \ -}) + DO_ONCE_LITE(printk, fmt, ##__VA_ARGS__)#define printk_deferred_once (fmt, ...) \ -({ \ - static bool __section(".data.once") __print_once; \ - bool __ret_print_once = !__print_once; \ - \ - if (!__print_once) { \ - __print_once = true; \ - printk_deferred(fmt, ##__VA_ARGS__); \ - } \ - unlikely(__ret_print_once); \ -}) + DO_ONCE_LITE(printk_deferred, fmt, ##__VA_ARGS__)#else #define printk_once (fmt, ...) \ no_printk(fmt, ##__VA_ARGS__)
kernel/trace/trace.h +3 -10
@@ -20,6 +20,7 @@#include <linux/irq_work.h> #include <linux/workqueue.h> #include <linux/ctype.h> +#include <linux/once_lite.h> #ifdef CONFIG_FTRACE_SYSCALLS #include <asm/unistd.h> /* For NR_SYSCALLS */
@@ -99,16 +100,8 @@ enum trace_type {#include "trace_entries.h" /* Use this for memory failure errors */ -#define MEM_FAIL (condition, fmt, ...) ({ \ - static bool __section(".data.once") __warned; \ - int __ret_warn_once = !!(condition); \ - \ - if (unlikely(__ret_warn_once && !__warned)) { \ - __warned = true; \ - pr_err("ERROR: " fmt, ##__VA_ARGS__); \ - } \ - unlikely(__ret_warn_once); \ -}) +#define MEM_FAIL (condition, fmt, ...) \ + DO_ONCE_LITE_IF(condition, pr_err, "ERROR: " fmt, ##__VA_ARGS__)/* * syscalls are special, and need special handling, this is why
Signature · 1 line
2.32.0.93.g670b81a890-goog
Re: [PATCH net-next v3 1/2] once: implement DO_ONCE_LITE for non-fast-path "do once" functionality
Quoted 5 lines · On Mon, 28 Jun 2021 09:50:06 -0400 Tanner Love <[email protected]>…
Certain uses of "do once" functionality reside outside of fast path, and so do not require jump label patching via static keys, making existing
DO_ONCEundesirable in such cases.Replace uses of
__section(".data.once")withDO_ONCE_LITE(_IF)?
I hate the name "_LITE" but can't come up with something better.
Maybe: DO_ONCE_SLOW() ??
Anyway, besides my bike-shedding comment above...
-- Steve
Re: [PATCH net-next v3 1/2] once: implement DO_ONCE_LITE for non-fast-path "do once" functionality
Quoted 7 lines · Steven Rostedt
Quoted 4 lines · On Mon, 28 Jun 2021 09:50:06 -0400 Tanner Love <[email protected]>…
Certain uses of "do once" functionality reside outside of fast path, and so do not require jump label patching via static keys, making existing
DO_ONCEundesirable in such cases.
Quoted 5 lines
Quoted 1 line
Replace uses of
__section(".data.once")withDO_ONCE_LITE(_IF)?I hate the name "
_LITE" but can't come up with something better.Maybe:
DO_ONCE_SLOW()??
Or rename the original DO_ONCE() to DO_ONCE_FAST() because it is more tricky to be fast. And call the "normal" implementation DO_ONCE().
Quoted 1 line
Anyway, besides my bike-shedding comment above...
Same here :-)
Best Regards,
Petr
PATCH v3 2/2 net: update netdev_rx_csum_fault() print dump only once
In reply to Tanner LoveFrom: Tanner Love <[email protected]>
Printing this stack dump multiple times does not provide additional useful information, and consumes time in the data path. Printing once is sufficient.
Changes
v2: Format indentation properly
--- net/core/dev.c | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-)
net/core/dev.c +9 -5
@@ -148,6 +148,7 @@#include <net/devlink.h> #include <linux/pm_runtime.h> #include <linux/prandom.h> +#include <linux/once_lite.h> #include "net-sysfs.h"
@@ -3487,13 +3488,16 @@ EXPORT_SYMBOL(__skb_gso_segment);/* Take action when hardware reception checksum errors are detected. */ #ifdef CONFIG_BUG +static void do_netdev_rx_csum_fault (struct net_device *dev,struct sk_buff *skb) +{ +pr_err ("%s: hw csum failure\n" , dev ? dev->name :"<unknown>" ); +skb_dump (KERN_ERR , skb, true); +dump_stack (); +} +void netdev_rx_csum_fault (struct net_device *dev,struct sk_buff *skb) { -if (net_ratelimit ()) { -pr_err ("%s: hw csum failure\n" , dev ? dev->name :"<unknown>" ); -skb_dump (KERN_ERR , skb, true); -dump_stack (); - } +DO_ONCE_LITE (do_netdev_rx_csum_fault, dev, skb); }EXPORT_SYMBOL (netdev_rx_csum_fault);#endif
Signature · 1 line
2.32.0.93.g670b81a890-goog
This series was applied to netdev/net-next.git (refs/heads/master):
Hello:
This series was applied to netdev/net-next.git (refs/heads/master):
Quoted 11 lines · On Mon, 28 Jun 2021 09:50:05 -0400 you wrote:
From: Tanner Love <[email protected]>
First patch implements
DO_ONCE_LITEto abstract uses of the ".data.once" trick. It is defined in its own, new header file -- rather than alongside the existingDO_ONCEininclude/linux/once.h-- becauseinclude/linux/once.hincludesinclude/linux/jump_label.h, and this causes the build to break for some architectures ifinclude/linux/once.his included ininclude/linux/printk.horinclude/asm-generic/bug.h.[...]
Here is the summary with links:
- [net-next,v3,1/2] once: implement DO_ONCE_LITE for non-fast-path "do once" functionality
https://git.kernel.org/netdev/net-next/c/a358f40600b3 - [net-next,v3,2/2] net: update netdev_rx_csum_fault() print dump only once https://git.kernel.org/netdev/net-next/c/127d7355abb3
You are awesome, thank you!
--
Deet-doot-dot, I am a bot.
https://korg.docs.kernel.org/patchwork/pwbot.html