// SPDX-License-Identifier: GPL-2.0-only#include <linux/array_size.h>#include <linux/bitops.h>#include <linux/cleanup.h>#include <linux/console.h>#include <linux/log2.h>#include <linux/kernel.h>#include <linux/ftrace.h>#include <linux/nmi.h>#include <linux/sched/debug.h>#include <linux/string.h>#include <linux/sysctl.h> #include <linux/sys_info.h> static const char * const si_names[] = {	[ilog2(SYS_INFO_TASKS)]			= "tasks",	[ilog2(SYS_INFO_MEM)]			= "mem",	[ilog2(SYS_INFO_TIMERS)]		= "timers",	[ilog2(SYS_INFO_LOCKS)]			= "locks",	[ilog2(SYS_INFO_FTRACE)]		= "ftrace",	[ilog2(SYS_INFO_PANIC_CONSOLE_REPLAY)]	= "",	[ilog2(SYS_INFO_ALL_BT)]		= "all_bt",	[ilog2(SYS_INFO_BLOCKED_TASKS)]		= "blocked_tasks",}; /* * Default kernel sys_info mask. * If a kernel module calls sys_info() with "parameter == 0", then * this mask will be used. */static unsigned long kernel_si_mask; /* Expecting string like "xxx_sys_info=tasks,mem,timers,locks,ftrace,..." */unsigned long sys_info_parse_param(char *str){	unsigned long si_bits = 0;	char *s, *name;	int i; 	s = str;	while ((name = strsep(&s, ",")) && *name) {		i = match_string(si_names, ARRAY_SIZE(si_names), name);		if (i >= 0)			__set_bit(i, &si_bits);	} 	return si_bits;} #ifdef CONFIG_SYSCTL static int sys_info_write_handler(const struct ctl_table *table,				  void *buffer, size_t *lenp, loff_t *ppos,				  unsigned long *si_bits_global){	unsigned long si_bits;	int ret; 	ret = proc_dostring(table, 1, buffer, lenp, ppos);	if (ret)		return ret; 	si_bits = sys_info_parse_param(table->data); 	/* The access to the global value is not synchronized. */	WRITE_ONCE(*si_bits_global, si_bits); 	return 0;} static int sys_info_read_handler(const struct ctl_table *table,				 void *buffer, size_t *lenp, loff_t *ppos,				 unsigned long *si_bits_global){	unsigned long si_bits;	unsigned int len = 0;	char *delim = "";	unsigned int i; 	/* The access to the global value is not synchronized. */	si_bits = READ_ONCE(*si_bits_global); 	for_each_set_bit(i, &si_bits, ARRAY_SIZE(si_names)) {		if (*si_names[i]) {			len += scnprintf(table->data + len, table->maxlen - len,					 "%s%s", delim, si_names[i]);			delim = ",";		}	} 	return proc_dostring(table, 0, buffer, lenp, ppos);} int sysctl_sys_info_handler(const struct ctl_table *ro_table, int write,					  void *buffer, size_t *lenp,					  loff_t *ppos){	struct ctl_table table;	unsigned int i;	size_t maxlen; 	maxlen = 0;	for (i = 0; i < ARRAY_SIZE(si_names); i++)		maxlen += strlen(si_names[i]) + 1; 	char *names __free(kfree) = kzalloc(maxlen, GFP_KERNEL);	if (!names)		return -ENOMEM; 	table = *ro_table;	table.data = names;	table.maxlen = maxlen; 	if (write)		return sys_info_write_handler(&table, buffer, lenp, ppos, ro_table->data);	else		return sys_info_read_handler(&table, buffer, lenp, ppos, ro_table->data);} static const struct ctl_table sys_info_sysctls[] = {	{		.procname	= "kernel_sys_info",		.data		= &kernel_si_mask,		.maxlen         = sizeof(kernel_si_mask),		.mode		= 0644,		.proc_handler	= sysctl_sys_info_handler,	},}; static int __init sys_info_sysctl_init(void){	register_sysctl_init("kernel", sys_info_sysctls);	return 0;}subsys_initcall(sys_info_sysctl_init);#endif static void __sys_info(unsigned long si_mask){	if (si_mask & SYS_INFO_TASKS)		show_state(); 	if (si_mask & SYS_INFO_MEM)		show_mem(); 	if (si_mask & SYS_INFO_TIMERS)		sysrq_timer_list_show(); 	if (si_mask & SYS_INFO_LOCKS)		debug_show_all_locks(); 	if (si_mask & SYS_INFO_FTRACE)		ftrace_dump(DUMP_ALL); 	if (si_mask & SYS_INFO_ALL_BT)		trigger_all_cpu_backtrace(); 	if (si_mask & SYS_INFO_BLOCKED_TASKS)		show_state_filter(TASK_UNINTERRUPTIBLE);} void sys_info(unsigned long si_mask){	__sys_info(si_mask ? : kernel_si_mask);}