lael-labs/linux

Documentation/admin-guide/bootconfig.rst+28−3

@@ -158,9 +158,15 @@ Each key-value pair is shown in each line with following style:: · 157 unmodified lines
158	Boot Kernel With a Boot Config	158	Boot Kernel With a Boot Config
159	==============================	159	==============================
160		160
161	Since the boot configuration file is loaded with initrd, it will be added	161	There are two options to boot the kernel with bootconfig: attaching the
162	to the end of the initrd (initramfs) image file with padding, size,	162	bootconfig to the initrd image or embedding it in the kernel itself.
163	checksum and 12-byte magic word as below.	163
		164	Attaching a Boot Config to Initrd
		165	---------------------------------
		166
		167	Since the boot configuration file is loaded with initrd by default,
		168	it will be added to the end of the initrd (initramfs) image file with
		169	padding, size, checksum and 12-byte magic word as below.
164		170
165	[initrd][bootconfig][padding][size(le32)][checksum(le32)][#BOOTCONFIG\n]	171	[initrd][bootconfig][padding][size(le32)][checksum(le32)][#BOOTCONFIG\n]
166		172
@@ -196,6 +202,25 @@ To remove the config from the image, you can use -d option as below:: · 29 unmodified lines
196	Then add "bootconfig" on the normal kernel command line to tell the	202	Then add "bootconfig" on the normal kernel command line to tell the
197	kernel to look for the bootconfig at the end of the initrd file.	203	kernel to look for the bootconfig at the end of the initrd file.
198		204
		205	Embedding a Boot Config into Kernel
		206	-----------------------------------
		207
		208	If you can not use initrd, you can also embed the bootconfig file in the
		209	kernel by Kconfig options. In this case, you need to recompile the kernel
		210	with the following configs::
		211
		212	CONFIG_BOOT_CONFIG_EMBED=y
		213	CONFIG_BOOT_CONFIG_EMBED_FILE="/PATH/TO/BOOTCONFIG/FILE"
		214
		215	``CONFIG_BOOT_CONFIG_EMBED_FILE`` requires an absolute path or a relative
		216	path to the bootconfig file from source tree or object tree.
		217	The kernel will embed it as the default bootconfig.
		218
		219	Just as when attaching the bootconfig to the initrd, you need ``bootconfig``
		220	option on the kernel command line to enable the embedded bootconfig.
		221
		222	Note that even if you set this option, you can override the embedded
		223	bootconfig by another bootconfig which attached to the initrd.
199		224
200	Kernel parameters via Boot Config	225	Kernel parameters via Boot Config
201	=================================	226	=================================

Documentation/trace/ftrace.rst+12−0

@@ -517,6 +517,18 @@ of ftrace. Here is a list of some of the key files: · 516 unmodified lines
517	processing should be able to handle them. See comments in the	517	processing should be able to handle them. See comments in the
518	ktime_get_boot_fast_ns() function for more information.	518	ktime_get_boot_fast_ns() function for more information.
519		519
		520	tai:
		521	This is the tai clock (CLOCK_TAI) and is derived from the wall-
		522	clock time. However, this clock does not experience
		523	discontinuities and backwards jumps caused by NTP inserting leap
		524	seconds. Since the clock access is designed for use in tracing,
		525	side effects are possible. The clock access may yield wrong
		526	readouts in case the internal TAI offset is updated e.g., caused
		527	by setting the system time or using adjtimex() with an offset.
		528	These effects are rare and post processing should be able to
		529	handle them. See comments in the ktime_get_tai_fast_ns()
		530	function for more information.
		531
520	To set a clock, simply echo the clock name into this file::	532	To set a clock, simply echo the clock name into this file::
521		533
522	# echo global > trace_clock	534	# echo global > trace_clock

Documentation/trace/timerlat-tracer.rst+3−2

  - stop_tracing_total_us: stop the system tracing if a
    timer latency at the *thread* context is higher than the configured
    value happens. Writing 0 disables this option.
- - print_stack: save the stack of the IRQ occurrence, and print
+ - print_stack: save the stack of the IRQ occurrence. The stack is printed
-   it after the *thread context* event".
+   after the *thread context* event, or at the IRQ handler if *stop_tracing_us*
+   is hit.
 timerlat and osnoise
 ----------------------------

MAINTAINERS+3−2

@@ -7517,6 +7517,7 @@ S: Maintained · 7516 unmodified lines
7517	F: Documentation/admin-guide/bootconfig.rst	7517	F: Documentation/admin-guide/bootconfig.rst
7518	F: fs/proc/bootconfig.c	7518	F: fs/proc/bootconfig.c
7519	F: include/linux/bootconfig.h	7519	F: include/linux/bootconfig.h
		7520	F: lib/bootconfig-data.S
7520	F: lib/bootconfig.c	7521	F: lib/bootconfig.c
7521	F: tools/bootconfig/*	7522	F: tools/bootconfig/*
7522	F: tools/bootconfig/scripts/*	7523	F: tools/bootconfig/scripts/*
@@ -20119,8 +20120,8 @@ M: Ingo Molnar <mingo@redhat.com> · 12596 unmodified lines
20119	S: Maintained	20120	S: Maintained
20120	T: git git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace.git	20121	T: git git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace.git
20121	F: Documentation/trace/ftrace.rst	20122	F: Documentation/trace/ftrace.rst
20122	F: arch///*/ftrace.h	20123	F: arch////ftrace*
20123	F: arch/*/kernel/ftrace.c	20124	F: arch///ftrace
20124	F: fs/tracefs/	20125	F: fs/tracefs/
20125	F: include/*/ftrace.h	20126	F: include/*/ftrace.h
20126	F: include/linux/trace*.h	20127	F: include/linux/trace*.h

arch/arm/kernel/ftrace.c+2−4

 	return (unsigned long)&ftrace_regs_caller_from_init;
 }
-int ftrace_arch_code_modify_prepare(void)
+void ftrace_arch_code_modify_prepare(void)
 {
-	return 0;
 }
-int ftrace_arch_code_modify_post_process(void)
+void ftrace_arch_code_modify_post_process(void)
 {
 	/* Make sure any TLB misses during machine stop are cleared. */
 	flush_tlb_all();
-	return 0;
 }
 static unsigned long ftrace_call_replace(unsigned long pc, unsigned long addr,

arch/riscv/kernel/ftrace.c+2−4

 #include <asm/patch.h>
 #ifdef CONFIG_DYNAMIC_FTRACE
-int ftrace_arch_code_modify_prepare(void) __acquires(&text_mutex)
+void ftrace_arch_code_modify_prepare(void) __acquires(&text_mutex)
 {
 	mutex_lock(&text_mutex);
-	return 0;
 }
-int ftrace_arch_code_modify_post_process(void) __releases(&text_mutex)
+void ftrace_arch_code_modify_post_process(void) __releases(&text_mutex)
 {
 	mutex_unlock(&text_mutex);
-	return 0;
 }
 static int ftrace_check_current_call(unsigned long hook_pos,

arch/s390/kernel/ftrace.c+1−2

 	ftrace_modify_all_code(command);
 }
-int ftrace_arch_code_modify_post_process(void)
+void ftrace_arch_code_modify_post_process(void)
 {
 	/*
 	 * Flush any pre-fetched instructions on all
 	 * CPUs to make the new code visible.
 	 */
 	text_poke_sync_lock();
-	return 0;
 }
 #ifdef CONFIG_MODULES

arch/x86/include/asm/ftrace.h+7−0

@@ -9,6 +9,13 @@ · 8 unmodified lines
9	# define MCOUNT_ADDR ((unsigned long)(__fentry__))	9	# define MCOUNT_ADDR ((unsigned long)(__fentry__))
10	#define MCOUNT_INSN_SIZE 5 /* sizeof mcount call */	10	#define MCOUNT_INSN_SIZE 5 /* sizeof mcount call */
11		11
		12	/* Ignore unused weak functions which will have non zero offsets */
		13	#ifdef CONFIG_HAVE_FENTRY
		14	# include <asm/ibt.h>
		15	/* Add offset for endbr64 if IBT enabled */
		16	# define FTRACE_MCOUNT_MAX_OFFSET ENDBR_INSN_SIZE
		17	#endif
		18
12	#ifdef CONFIG_DYNAMIC_FTRACE	19	#ifdef CONFIG_DYNAMIC_FTRACE
13	#define ARCH_SUPPORTS_FTRACE_OPS 1	20	#define ARCH_SUPPORTS_FTRACE_OPS 1
14	#endif	21	#endif

arch/x86/kernel/ftrace.c+2−4

 static int ftrace_poke_late = 0;
-int ftrace_arch_code_modify_prepare(void)
+void ftrace_arch_code_modify_prepare(void)
     __acquires(&text_mutex)
 {
 	/*
 	 */
 	mutex_lock(&text_mutex);
 	ftrace_poke_late = 1;
-	return 0;
 }
-int ftrace_arch_code_modify_post_process(void)
+void ftrace_arch_code_modify_post_process(void)
     __releases(&text_mutex)
 {
 	/*
 	text_poke_finish();
 	ftrace_poke_late = 0;
 	mutex_unlock(&text_mutex);
-	return 0;
 }
 static const char *ftrace_nop_replace(void)

arch/x86/kernel/tracepoint.c+0−6

 // SPDX-License-Identifier: GPL-2.0
 /*
- * Code for supporting irq vector tracepoints.
- *
  * Copyright (C) 2013 Seiji Aguchi <seiji.aguchi@hds.com>
- *
  */
 #include <linux/jump_label.h>
 #include <linux/atomic.h>
-#include <asm/hw_irq.h>
-#include <asm/desc.h>
 #include <asm/trace/exceptions.h>
-#include <asm/trace/irq_vectors.h>
 DEFINE_STATIC_KEY_FALSE(trace_pagefault_key);

include/linux/bootconfig.h+10−0

@@ -289,4 +289,14 @@ int __init xbc_get_info(int node_size, size_t data_size); · 288 unmodified lines
289	/* XBC cleanup data structures */	289	/* XBC cleanup data structures */
290	void __init xbc_exit(void);	290	void __init xbc_exit(void);
291		291
		292	/* XBC embedded bootconfig data in kernel */
		293	#ifdef CONFIG_BOOT_CONFIG_EMBED
		294	const char * __init xbc_get_embedded_bootconfig(size_t *size);
		295	#else
		296	static inline const char xbc_get_embedded_bootconfig(size_t size)
		297	{
		298	return NULL;
		299	}
		300	#endif
		301
292	#endif	302	#endif

include/linux/ftrace.h+2−2

@@ -452,8 +452,8 @@ static inline void stack_tracer_enable(void) { } · 451 unmodified lines
452		452
453	#ifdef CONFIG_DYNAMIC_FTRACE	453	#ifdef CONFIG_DYNAMIC_FTRACE
454		454
455	int ftrace_arch_code_modify_prepare(void);	455	void ftrace_arch_code_modify_prepare(void);
456	int ftrace_arch_code_modify_post_process(void);	456	void ftrace_arch_code_modify_post_process(void);
457		457
458	enum ftrace_bug_type {	458	enum ftrace_bug_type {
459	FTRACE_BUG_UNKNOWN,	459	FTRACE_BUG_UNKNOWN,

include/linux/kprobes.h+1−1

@@ -424,7 +424,7 @@ void unregister_kretprobe(struct kretprobe *rp); · 423 unmodified lines
424	int register_kretprobes(struct kretprobe **rps, int num);	424	int register_kretprobes(struct kretprobe **rps, int num);
425	void unregister_kretprobes(struct kretprobe **rps, int num);	425	void unregister_kretprobes(struct kretprobe **rps, int num);
426		426
427	#ifdef CONFIG_KRETPROBE_ON_RETHOOK	427	#if defined(CONFIG_KRETPROBE_ON_RETHOOK) \|\| !defined(CONFIG_KRETPROBES)
428	#define kprobe_flush_task(tk) do {} while (0)	428	#define kprobe_flush_task(tk) do {} while (0)
429	#else	429	#else
430	void kprobe_flush_task(struct task_struct *tk);	430	void kprobe_flush_task(struct task_struct *tk);

init/Kconfig+20−1

@@ -1338,7 +1338,7 @@ endif · 1337 unmodified lines
1338		1338
1339	config BOOT_CONFIG	1339	config BOOT_CONFIG
1340	bool "Boot config support"	1340	bool "Boot config support"
1341	select BLK_DEV_INITRD	1341	select BLK_DEV_INITRD if !BOOT_CONFIG_EMBED
1342	help	1342	help
1343	Extra boot config allows system admin to pass a config file as	1343	Extra boot config allows system admin to pass a config file as
1344	complemental extension of kernel cmdline when booting.	1344	complemental extension of kernel cmdline when booting.
@@ -1348,6 +1348,25 @@ config BOOT_CONFIG · 3 unmodified lines
1348		1348
1349	If unsure, say Y.	1349	If unsure, say Y.
1350		1350
		1351	config BOOT_CONFIG_EMBED
		1352	bool "Embed bootconfig file in the kernel"
		1353	depends on BOOT_CONFIG
		1354	help
		1355	Embed a bootconfig file given by BOOT_CONFIG_EMBED_FILE in the
		1356	kernel. Usually, the bootconfig file is loaded with the initrd
		1357	image. But if the system doesn't support initrd, this option will
		1358	help you by embedding a bootconfig file while building the kernel.
		1359
		1360	If unsure, say N.
		1361
		1362	config BOOT_CONFIG_EMBED_FILE
		1363	string "Embedded bootconfig file path"
		1364	depends on BOOT_CONFIG_EMBED
		1365	help
		1366	Specify a bootconfig file which will be embedded to the kernel.
		1367	This bootconfig will be used if there is no initrd or no other
		1368	bootconfig in the initrd.
		1369
1351	config INITRAMFS_PRESERVE_MTIME	1370	config INITRAMFS_PRESERVE_MTIME
1352	bool "Preserve cpio archive mtimes in initramfs"	1371	bool "Preserve cpio archive mtimes in initramfs"
1353	default y	1372	default y

init/main.c+19−19

 early_param("loglevel", loglevel);
 #ifdef CONFIG_BLK_DEV_INITRD
-static void * __init get_boot_config_from_initrd(u32 *_size, u32 *_csum)
+static void * __init get_boot_config_from_initrd(size_t *_size)
 {
 	u32 size, csum;
 	char *data;
 		return NULL;
 	}
+	if (xbc_calc_checksum(data, size) != csum) {
+		pr_err("bootconfig checksum failed\n");
+		return NULL;
+	}
 	/* Remove bootconfig from initramfs/initrd */
 	initrd_end = (unsigned long)data;
 	if (_size)
 		*_size = size;
-	if (_csum)
-		*_csum = csum;
 	return data;
 }
 #else
-static void * __init get_boot_config_from_initrd(u32 *_size, u32 *_csum)
+static void * __init get_boot_config_from_initrd(size_t *_size)
 {
 	return NULL;
 }
 static void __init setup_boot_config(void)
 {
 	static char tmp_cmdline[COMMAND_LINE_SIZE] __initdata;
-	const char *msg;
+	const char *msg, *data;
-	int pos;
+	int pos, ret;
-	u32 size, csum;
+	size_t size;
-	char *data, *err;
+	char *err;
-	int ret;
 	/* Cut out the bootconfig data even if we have no bootconfig option */
-	data = get_boot_config_from_initrd(&size, &csum);
+	data = get_boot_config_from_initrd(&size);
+	/* If there is no bootconfig in initrd, try embedded one. */
+	if (!data)
+		data = xbc_get_embedded_bootconfig(&size);
 	strlcpy(tmp_cmdline, boot_command_line, COMMAND_LINE_SIZE);
 	err = parse_args("bootconfig", tmp_cmdline, NULL, 0, 0, 0, NULL,
 	}
 	if (size >= XBC_DATA_MAX) {
-		pr_err("bootconfig size %d greater than max size %d\n",
+		pr_err("bootconfig size %ld greater than max size %d\n",
-			size, XBC_DATA_MAX);
+			(long)size, XBC_DATA_MAX);
-		return;
-	}
-	if (xbc_calc_checksum(data, size) != csum) {
-		pr_err("bootconfig checksum failed\n");
 		return;
 	}
 				msg, pos);
 	} else {
 		xbc_get_info(&ret, NULL);
-		pr_info("Load bootconfig: %d bytes %d nodes\n", size, ret);
+		pr_info("Load bootconfig: %ld bytes %d nodes\n", (long)size, ret);
 		/* keys starting with "kernel." are passed via cmdline */
 		extra_command_line = xbc_make_cmdline("kernel");
 		/* Also, "init." keys are init arguments */
 static void __init setup_boot_config(void)
 {
 	/* Remove bootconfig data from initrd */
-	get_boot_config_from_initrd(NULL, NULL);
+	get_boot_config_from_initrd(NULL);
 }
 static int __init warn_bootconfig(char *str)

kernel/kprobes.c+71−73

 	preempt_enable();
 }
-#if !defined(CONFIG_KRETPROBE_ON_RETHOOK)
-static void free_rp_inst_rcu(struct rcu_head *head)
-{
-	struct kretprobe_instance *ri = container_of(head, struct kretprobe_instance, rcu);
-	if (refcount_dec_and_test(&ri->rph->ref))
-		kfree(ri->rph);
-	kfree(ri);
-}
-NOKPROBE_SYMBOL(free_rp_inst_rcu);
-static void recycle_rp_inst(struct kretprobe_instance *ri)
-{
-	struct kretprobe *rp = get_kretprobe(ri);
-	if (likely(rp))
-		freelist_add(&ri->freelist, &rp->freelist);
-	else
-		call_rcu(&ri->rcu, free_rp_inst_rcu);
-}
-NOKPROBE_SYMBOL(recycle_rp_inst);
-/*
- * This function is called from delayed_put_task_struct() when a task is
- * dead and cleaned up to recycle any kretprobe instances associated with
- * this task. These left over instances represent probed functions that
- * have been called but will never return.
- */
-void kprobe_flush_task(struct task_struct *tk)
-{
-	struct kretprobe_instance *ri;
-	struct llist_node *node;
-	/* Early boot, not yet initialized. */
-	if (unlikely(!kprobes_initialized))
-		return;
-	kprobe_busy_begin();
-	node = __llist_del_all(&tk->kretprobe_instances);
-	while (node) {
-		ri = container_of(node, struct kretprobe_instance, llist);
-		node = node->next;
-		recycle_rp_inst(ri);
-	}
-	kprobe_busy_end();
-}
-NOKPROBE_SYMBOL(kprobe_flush_task);
-static inline void free_rp_inst(struct kretprobe *rp)
-{
-	struct kretprobe_instance *ri;
-	struct freelist_node *node;
-	int count = 0;
-	node = rp->freelist.head;
-	while (node) {
-		ri = container_of(node, struct kretprobe_instance, freelist);
-		node = node->next;
-		kfree(ri);
-		count++;
-	}
-	if (refcount_sub_and_test(count, &rp->rph->ref)) {
-		kfree(rp->rph);
-		rp->rph = NULL;
-	}
-}
-#endif	/* !CONFIG_KRETPROBE_ON_RETHOOK */
 /* Add the new probe to 'ap->list'. */
 static int add_new_kprobe(struct kprobe *ap, struct kprobe *p)
 {
 #ifdef CONFIG_KRETPROBES
 #if !defined(CONFIG_KRETPROBE_ON_RETHOOK)
+static void free_rp_inst_rcu(struct rcu_head *head)
+{
+	struct kretprobe_instance *ri = container_of(head, struct kretprobe_instance, rcu);
+	if (refcount_dec_and_test(&ri->rph->ref))
+		kfree(ri->rph);
+	kfree(ri);
+}
+NOKPROBE_SYMBOL(free_rp_inst_rcu);
+static void recycle_rp_inst(struct kretprobe_instance *ri)
+{
+	struct kretprobe *rp = get_kretprobe(ri);
+	if (likely(rp))
+		freelist_add(&ri->freelist, &rp->freelist);
+	else
+		call_rcu(&ri->rcu, free_rp_inst_rcu);
+}
+NOKPROBE_SYMBOL(recycle_rp_inst);
+/*
+ * This function is called from delayed_put_task_struct() when a task is
+ * dead and cleaned up to recycle any kretprobe instances associated with
+ * this task. These left over instances represent probed functions that
+ * have been called but will never return.
+ */
+void kprobe_flush_task(struct task_struct *tk)
+{
+	struct kretprobe_instance *ri;
+	struct llist_node *node;
+	/* Early boot, not yet initialized. */
+	if (unlikely(!kprobes_initialized))
+		return;
+	kprobe_busy_begin();
+	node = __llist_del_all(&tk->kretprobe_instances);
+	while (node) {
+		ri = container_of(node, struct kretprobe_instance, llist);
+		node = node->next;
+		recycle_rp_inst(ri);
+	}
+	kprobe_busy_end();
+}
+NOKPROBE_SYMBOL(kprobe_flush_task);
+static inline void free_rp_inst(struct kretprobe *rp)
+{
+	struct kretprobe_instance *ri;
+	struct freelist_node *node;
+	int count = 0;
+	node = rp->freelist.head;
+	while (node) {
+		ri = container_of(node, struct kretprobe_instance, freelist);
+		node = node->next;
+		kfree(ri);
+		count++;
+	}
+	if (refcount_sub_and_test(count, &rp->rph->ref)) {
+		kfree(rp->rph);
+		rp->rph = NULL;
+	}
+}
 /* This assumes the 'tsk' is the current task or the is not running. */
 static kprobe_opcode_t *__kretprobe_find_ret_addr(struct task_struct *tsk,
 						  struct llist_node **cur)

kernel/trace/Makefile+4−0

@@ -31,6 +31,10 @@ ifdef CONFIG_GCOV_PROFILE_FTRACE · 30 unmodified lines
31	GCOV_PROFILE := y	31	GCOV_PROFILE := y
32	endif	32	endif
33		33
		34	# Functions in this file could be invoked from early interrupt
		35	# code and produce random code coverage.
		36	KCOV_INSTRUMENT_trace_preemptirq.o := n
		37
34	CFLAGS_bpf_trace.o := -I$(src)	38	CFLAGS_bpf_trace.o := -I$(src)
35		39
36	CFLAGS_trace_benchmark.o := -I$(src)	40	CFLAGS_trace_benchmark.o := -I$(src)

kernel/trace/ftrace.c+174−36

 #include "trace_output.h"
 #include "trace_stat.h"
+#define FTRACE_INVALID_FUNCTION		"__ftrace_invalid_address__"
 #define FTRACE_WARN_ON(cond)			\
 	({					\
 		int ___r = cond;		\
 ftrace_func_t ftrace_trace_function __read_mostly = ftrace_stub;
 struct ftrace_ops global_ops;
-/* Defined by vmlinux.lds.h see the commment above arch_ftrace_ops_list_func for details */
+/* Defined by vmlinux.lds.h see the comment above arch_ftrace_ops_list_func for details */
 void ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip,
 			  struct ftrace_ops *op, struct ftrace_regs *fregs);
 static __init void ftrace_profile_tracefs(struct dentry *d_tracer)
 {
 	struct ftrace_profile_stat *stat;
-	struct dentry *entry;
 	char *name;
 	int ret;
 	int cpu;
 		}
 	}
-	entry = tracefs_create_file("function_profile_enabled",
+	trace_create_file("function_profile_enabled",
-				    TRACE_MODE_WRITE, d_tracer, NULL,
+			  TRACE_MODE_WRITE, d_tracer, NULL,
-				    &ftrace_profile_fops);
+			  &ftrace_profile_fops);
-	if (!entry)
-		pr_warn("Could not create tracefs 'function_profile_enabled' entry\n");
 }
 #else /* CONFIG_FUNCTION_PROFILER */
  * archs can override this function if they must do something
  * before the modifying code is performed.
  */
-int __weak ftrace_arch_code_modify_prepare(void)
+void __weak ftrace_arch_code_modify_prepare(void)
 {
-	return 0;
 }
 /*
  * archs can override this function if they must do something
  * after the modifying code is performed.
  */
-int __weak ftrace_arch_code_modify_post_process(void)
+void __weak ftrace_arch_code_modify_post_process(void)
 {
-	return 0;
 }
 void ftrace_modify_all_code(int command)
 static void ftrace_run_update_code(int command)
 {
-	int ret;
+	ftrace_arch_code_modify_prepare();
-	ret = ftrace_arch_code_modify_prepare();
-	FTRACE_WARN_ON(ret);
-	if (ret)
-		return;
 	/*
 	 * By default we use stop_machine() to modify the code.
 	 */
 	arch_ftrace_update_code(command);
-	ret = ftrace_arch_code_modify_post_process();
+	ftrace_arch_code_modify_post_process();
-	FTRACE_WARN_ON(ret);
 }
 static void ftrace_run_modify_code(struct ftrace_ops *ops, int command,
 		seq_printf(m, " ->%pS", ptr);
 }
+#ifdef FTRACE_MCOUNT_MAX_OFFSET
+/*
+ * Weak functions can still have an mcount/fentry that is saved in
+ * the __mcount_loc section. These can be detected by having a
+ * symbol offset of greater than FTRACE_MCOUNT_MAX_OFFSET, as the
+ * symbol found by kallsyms is not the function that the mcount/fentry
+ * is part of. The offset is much greater in these cases.
+ *
+ * Test the record to make sure that the ip points to a valid kallsyms
+ * and if not, mark it disabled.
+ */
+static int test_for_valid_rec(struct dyn_ftrace *rec)
+{
+	char str[KSYM_SYMBOL_LEN];
+	unsigned long offset;
+	const char *ret;
+	ret = kallsyms_lookup(rec->ip, NULL, &offset, NULL, str);
+	/* Weak functions can cause invalid addresses */
+	if (!ret || offset > FTRACE_MCOUNT_MAX_OFFSET) {
+		rec->flags |= FTRACE_FL_DISABLED;
+		return 0;
+	}
+	return 1;
+}
+static struct workqueue_struct *ftrace_check_wq __initdata;
+static struct work_struct ftrace_check_work __initdata;
+/*
+ * Scan all the mcount/fentry entries to make sure they are valid.
+ */
+static __init void ftrace_check_work_func(struct work_struct *work)
+{
+	struct ftrace_page *pg;
+	struct dyn_ftrace *rec;
+	mutex_lock(&ftrace_lock);
+	do_for_each_ftrace_rec(pg, rec) {
+		test_for_valid_rec(rec);
+	} while_for_each_ftrace_rec();
+	mutex_unlock(&ftrace_lock);
+}
+static int __init ftrace_check_for_weak_functions(void)
+{
+	INIT_WORK(&ftrace_check_work, ftrace_check_work_func);
+	ftrace_check_wq = alloc_workqueue("ftrace_check_wq", WQ_UNBOUND, 0);
+	queue_work(ftrace_check_wq, &ftrace_check_work);
+	return 0;
+}
+static int __init ftrace_check_sync(void)
+{
+	/* Make sure the ftrace_check updates are finished */
+	if (ftrace_check_wq)
+		destroy_workqueue(ftrace_check_wq);
+	return 0;
+}
+late_initcall_sync(ftrace_check_sync);
+subsys_initcall(ftrace_check_for_weak_functions);
+static int print_rec(struct seq_file *m, unsigned long ip)
+{
+	unsigned long offset;
+	char str[KSYM_SYMBOL_LEN];
+	char *modname;
+	const char *ret;
+	ret = kallsyms_lookup(ip, NULL, &offset, &modname, str);
+	/* Weak functions can cause invalid addresses */
+	if (!ret || offset > FTRACE_MCOUNT_MAX_OFFSET) {
+		snprintf(str, KSYM_SYMBOL_LEN, "%s_%ld",
+			 FTRACE_INVALID_FUNCTION, offset);
+		ret = NULL;
+	}
+	seq_puts(m, str);
+	if (modname)
+		seq_printf(m, " [%s]", modname);
+	return ret == NULL ? -1 : 0;
+}
+#else
+static inline int test_for_valid_rec(struct dyn_ftrace *rec)
+{
+	return 1;
+}
+static inline int print_rec(struct seq_file *m, unsigned long ip)
+{
+	seq_printf(m, "%ps", (void *)ip);
+	return 0;
+}
+#endif
 static int t_show(struct seq_file *m, void *v)
 {
 	struct ftrace_iterator *iter = m->private;
 	if (!rec)
 		return 0;
-	seq_printf(m, "%ps", (void *)rec->ip);
+	if (print_rec(m, rec->ip)) {
+		/* This should only happen when a rec is disabled */
+		WARN_ON_ONCE(!(rec->flags & FTRACE_FL_DISABLED));
+		seq_putc(m, '\n');
+		return 0;
+	}
 	if (iter->flags & FTRACE_ITER_ENABLED) {
 		struct ftrace_ops *ops;
 	return 0;
 }
+#ifdef FTRACE_MCOUNT_MAX_OFFSET
+static int lookup_ip(unsigned long ip, char **modname, char *str)
+{
+	unsigned long offset;
+	kallsyms_lookup(ip, NULL, &offset, modname, str);
+	if (offset > FTRACE_MCOUNT_MAX_OFFSET)
+		return -1;
+	return 0;
+}
+#else
+static int lookup_ip(unsigned long ip, char **modname, char *str)
+{
+	kallsyms_lookup(ip, NULL, NULL, modname, str);
+	return 0;
+}
+#endif
 static int
 ftrace_match_record(struct dyn_ftrace *rec, struct ftrace_glob *func_g,
 		struct ftrace_glob *mod_g, int exclude_mod)
 	char str[KSYM_SYMBOL_LEN];
 	char *modname;
-	kallsyms_lookup(rec->ip, NULL, NULL, &modname, str);
+	if (lookup_ip(rec->ip, &modname, str)) {
+		/* This should only happen when a rec is disabled */
+		WARN_ON_ONCE(system_state == SYSTEM_RUNNING &&
+			     !(rec->flags & FTRACE_FL_DISABLED));
+		return 0;
+	}
 	if (mod_g) {
 		int mod_matches = (modname) ? ftrace_match(modname, mod_g) : 0;
  * @ip: The instruction pointer address to remove the data from
  *
  * Returns the data if it is found, otherwise NULL.
  * Note, if the data pointer is used as the data itself, (see
  * ftrace_func_mapper_find_ip(), then the return value may be meaningless,
  * if the data pointer was set to zero.
  */
 			       struct ftrace_probe_ops *probe_ops,
 			       void *data)
 {
+	struct ftrace_func_probe *probe = NULL, *iter;
 	struct ftrace_func_entry *entry;
-	struct ftrace_func_probe *probe;
 	struct ftrace_hash **orig_hash;
 	struct ftrace_hash *old_hash;
 	struct ftrace_hash *hash;
 	mutex_lock(&ftrace_lock);
 	/* Check if the probe_ops is already registered */
-	list_for_each_entry(probe, &tr->func_probes, list) {
+	list_for_each_entry(iter, &tr->func_probes, list) {
-		if (probe->probe_ops == probe_ops)
+		if (iter->probe_ops == probe_ops) {
+			probe = iter;
 			break;
+		}
 	}
-	if (&probe->list == &tr->func_probes) {
+	if (!probe) {
 		probe = kzalloc(sizeof(*probe), GFP_KERNEL);
 		if (!probe) {
 			mutex_unlock(&ftrace_lock);
 unregister_ftrace_function_probe_func(char *glob, struct trace_array *tr,
 				      struct ftrace_probe_ops *probe_ops)
 {
+	struct ftrace_func_probe *probe = NULL, *iter;
 	struct ftrace_ops_hash old_hash_ops;
 	struct ftrace_func_entry *entry;
-	struct ftrace_func_probe *probe;
 	struct ftrace_glob func_g;
 	struct ftrace_hash **orig_hash;
 	struct ftrace_hash *old_hash;
 	mutex_lock(&ftrace_lock);
 	/* Check if the probe_ops is already registered */
-	list_for_each_entry(probe, &tr->func_probes, list) {
+	list_for_each_entry(iter, &tr->func_probes, list) {
-		if (probe->probe_ops == probe_ops)
+		if (iter->probe_ops == probe_ops) {
+			probe = iter;
 			break;
+		}
 	}
-	if (&probe->list == &tr->func_probes)
+	if (!probe)
 		goto err_unlock_ftrace;
 	ret = -EINVAL;
 		goto out_unlock;
 	ret = ftrace_set_filter_ip(&direct_ops, ip, 0, 0);
-	if (ret)
-		remove_hash_entry(direct_functions, entry);
 	if (!ret && !(direct_ops.flags & FTRACE_OPS_FL_ENABLED)) {
 		ret = register_ftrace_function(&direct_ops);
 	}
 	if (ret) {
+		remove_hash_entry(direct_functions, entry);
 		kfree(entry);
 		if (!direct->count) {
 			list_del_rcu(&direct->next);
 		    !within_module_init(rec->ip, mod))
 			break;
+		/* Weak functions should still be ignored */
+		if (!test_for_valid_rec(rec)) {
+			/* Clear all other flags. Should not be enabled anyway */
+			rec->flags = FTRACE_FL_DISABLED;
+			continue;
+		}
 		cnt = 0;
 		/*
 void ftrace_module_init(struct module *mod)
 {
+	int ret;
 	if (ftrace_disabled || !mod->num_ftrace_callsites)
 		return;
-	ftrace_process_locs(mod, mod->ftrace_callsites,
+	ret = ftrace_process_locs(mod, mod->ftrace_callsites,
-			    mod->ftrace_callsites + mod->num_ftrace_callsites);
+				  mod->ftrace_callsites + mod->num_ftrace_callsites);
+	if (ret)
+		pr_warn("ftrace: failed to allocate entries for module '%s' functions\n",
+			mod->name);
 }
 static void save_ftrace_mod_rec(struct ftrace_mod_map *mod_map,
 	pr_info("ftrace: allocating %ld entries in %ld pages\n",
 		count, count / ENTRIES_PER_PAGE + 1);
-	last_ftrace_enabled = ftrace_enabled = 1;
 	ret = ftrace_process_locs(NULL,
 				  __start_mcount_loc,
 				  __stop_mcount_loc);
+	if (ret) {
+		pr_warn("ftrace: failed to allocate entries for functions\n");
+		goto failed;
+	}
 	pr_info("ftrace: allocated %ld pages with %ld groups\n",
 		ftrace_number_of_pages, ftrace_number_of_groups);
+	last_ftrace_enabled = ftrace_enabled = 1;
 	set_ftrace_early_filters();
 	return;

kernel/trace/pid_list.c+2−2

@@ -118,9 +118,9 @@ static inline unsigned int pid_join(unsigned int upper1, · 117 unmodified lines
118	/**	118	/**
119	* trace_pid_list_is_set - test if the pid is set in the list	119	* trace_pid_list_is_set - test if the pid is set in the list
120	* @pid_list: The pid list to test	120	* @pid_list: The pid list to test
121	* @pid: The pid to to see if set in the list.	121	* @pid: The pid to see if set in the list.
122	*	122	*
123	* Tests if @pid is is set in the @pid_list. This is usually called	123	* Tests if @pid is set in the @pid_list. This is usually called
124	* from the scheduler when a task is scheduled. Its pid is checked	124	* from the scheduler when a task is scheduled. Its pid is checked
125	* if it should be traced or not.	125	* if it should be traced or not.
126	*	126	*

kernel/trace/ring_buffer.c+64−17

 #include <asm/local.h>
+/*
+ * The "absolute" timestamp in the buffer is only 59 bits.
+ * If a clock has the 5 MSBs set, it needs to be saved and
+ * reinserted.
+ */
+#define TS_MSB		(0xf8ULL << 56)
+#define ABS_TS_MASK	(~TS_MSB)
 static void update_pages_handler(struct work_struct *work);
 /*
 	local_t		cnt;
 	local_t		top;
 	local_t		bottom;
+	local_t		msb;
 };
 #else
 #include <asm/local64.h>
  * For the ring buffer, 64 bit required operations for the time is
  * the following:
  *
- *  - Only need 59 bits (uses 60 to make it even).
  *  - Reads may fail if it interrupted a modification of the time stamp.
  *      It will succeed if it did not interrupt another write even if
  *      the read itself is interrupted by a write.
  */
 #define RB_TIME_SHIFT	30
 #define RB_TIME_VAL_MASK ((1 << RB_TIME_SHIFT) - 1)
+#define RB_TIME_MSB_SHIFT	 60
 static inline int rb_time_cnt(unsigned long val)
 {
 static inline bool __rb_time_read(rb_time_t *t, u64 *ret, unsigned long *cnt)
 {
-	unsigned long top, bottom;
+	unsigned long top, bottom, msb;
 	unsigned long c;
 	/*
 		c = local_read(&t->cnt);
 		top = local_read(&t->top);
 		bottom = local_read(&t->bottom);
+		msb = local_read(&t->msb);
 	} while (c != local_read(&t->cnt));
 	*cnt = rb_time_cnt(top);
 	if (*cnt != rb_time_cnt(bottom))
 		return false;
-	*ret = rb_time_val(top, bottom);
+	/* The shift to msb will lose its cnt bits */
+	*ret = rb_time_val(top, bottom) | ((u64)msb << RB_TIME_MSB_SHIFT);
 	return true;
 }
 	return (val & RB_TIME_VAL_MASK) | ((cnt & 3) << RB_TIME_SHIFT);
 }
-static inline void rb_time_split(u64 val, unsigned long *top, unsigned long *bottom)
+static inline void rb_time_split(u64 val, unsigned long *top, unsigned long *bottom,
+				 unsigned long *msb)
 {
 	*top = (unsigned long)((val >> RB_TIME_SHIFT) & RB_TIME_VAL_MASK);
 	*bottom = (unsigned long)(val & RB_TIME_VAL_MASK);
+	*msb = (unsigned long)(val >> RB_TIME_MSB_SHIFT);
 }
 static inline void rb_time_val_set(local_t *t, unsigned long val, unsigned long cnt)
 static void rb_time_set(rb_time_t *t, u64 val)
 {
-	unsigned long cnt, top, bottom;
+	unsigned long cnt, top, bottom, msb;
-	rb_time_split(val, &top, &bottom);
+	rb_time_split(val, &top, &bottom, &msb);
 	/* Writes always succeed with a valid number even if it gets interrupted. */
 	do {
 		cnt = local_inc_return(&t->cnt);
 		rb_time_val_set(&t->top, top, cnt);
 		rb_time_val_set(&t->bottom, bottom, cnt);
+		rb_time_val_set(&t->msb, val >> RB_TIME_MSB_SHIFT, cnt);
 	} while (cnt != local_read(&t->cnt));
 }
 static int rb_time_cmpxchg(rb_time_t *t, u64 expect, u64 set)
 {
-	unsigned long cnt, top, bottom;
+	unsigned long cnt, top, bottom, msb;
-	unsigned long cnt2, top2, bottom2;
+	unsigned long cnt2, top2, bottom2, msb2;
 	u64 val;
 	/* The cmpxchg always fails if it interrupted an update */
 	 cnt2 = cnt + 1;
-	 rb_time_split(val, &top, &bottom);
+	 rb_time_split(val, &top, &bottom, &msb);
 	 top = rb_time_val_cnt(top, cnt);
 	 bottom = rb_time_val_cnt(bottom, cnt);
-	 rb_time_split(set, &top2, &bottom2);
+	 rb_time_split(set, &top2, &bottom2, &msb2);
 	 top2 = rb_time_val_cnt(top2, cnt2);
 	 bottom2 = rb_time_val_cnt(bottom2, cnt2);
 	if (!rb_time_read_cmpxchg(&t->cnt, cnt, cnt2))
 		return false;
+	if (!rb_time_read_cmpxchg(&t->msb, msb, msb2))
+		return false;
 	if (!rb_time_read_cmpxchg(&t->top, top, top2))
 		return false;
 	if (!rb_time_read_cmpxchg(&t->bottom, bottom, bottom2))
 }
 #endif
+/*
+ * The absolute time stamp drops the 5 MSBs and some clocks may
+ * require them. The rb_fix_abs_ts() will take a previous full
+ * time stamp, and add the 5 MSB of that time stamp on to the
+ * saved absolute time stamp. Then they are compared in case of
+ * the unlikely event that the latest time stamp incremented
+ * the 5 MSB.
+ */
+static inline u64 rb_fix_abs_ts(u64 abs, u64 save_ts)
+{
+	if (save_ts & TS_MSB) {
+		abs |= save_ts & TS_MSB;
+		/* Check for overflow */
+		if (unlikely(abs < save_ts))
+			abs += 1ULL << 59;
+	}
+	return abs;
+}
 static inline u64 rb_time_stamp(struct trace_buffer *buffer);
 	u64 ts;
 	/* If the event includes an absolute time, then just use that */
-	if (event->type_len == RINGBUF_TYPE_TIME_STAMP)
+	if (event->type_len == RINGBUF_TYPE_TIME_STAMP) {
-		return rb_event_time_stamp(event);
+		ts = rb_event_time_stamp(event);
+		return rb_fix_abs_ts(ts, cpu_buffer->tail_page->page->time_stamp);
+	}
 	nest = local_read(&cpu_buffer->committing);
 	verify_event(cpu_buffer, event);
 		(RB_ADD_STAMP_FORCE | RB_ADD_STAMP_ABSOLUTE);
 	if (unlikely(info->delta > (1ULL << 59))) {
+		/*
+		 * Some timers can use more than 59 bits, and when a timestamp
+		 * is added to the buffer, it will lose those bits.
+		 */
+		if (abs && (info->ts & TS_MSB)) {
+			info->delta &= ABS_TS_MASK;
 		/* did the clock go backwards */
-		if (info->before == info->after && info->before > info->ts) {
+		} else if (info->before == info->after && info->before > info->ts) {
 			/* not interrupted */
 			static int once;
 		case RINGBUF_TYPE_TIME_STAMP:
 			delta = rb_event_time_stamp(event);
-			ts = delta;
+			ts = rb_fix_abs_ts(delta, ts);
 			pr_warn("  [%lld] absolute:%lld TIME STAMP\n", ts, delta);
 			break;
 		case RINGBUF_TYPE_TIME_STAMP:
 			delta = rb_event_time_stamp(event);
-			ts = delta;
+			ts = rb_fix_abs_ts(delta, ts);
 			break;
 		case RINGBUF_TYPE_PADDING:
 	case RINGBUF_TYPE_TIME_STAMP:
 		delta = rb_event_time_stamp(event);
+		delta = rb_fix_abs_ts(delta, cpu_buffer->read_stamp);
 		cpu_buffer->read_stamp = delta;
 		return;
 	case RINGBUF_TYPE_TIME_STAMP:
 		delta = rb_event_time_stamp(event);
+		delta = rb_fix_abs_ts(delta, iter->read_stamp);
 		iter->read_stamp = delta;
 		return;
 	case RINGBUF_TYPE_TIME_STAMP:
 		if (ts) {
 			*ts = rb_event_time_stamp(event);
+			*ts = rb_fix_abs_ts(*ts, reader->page->time_stamp);
 			ring_buffer_normalize_time_stamp(cpu_buffer->buffer,
 							 cpu_buffer->cpu, ts);
 		}
 	case RINGBUF_TYPE_TIME_STAMP:
 		if (ts) {
 			*ts = rb_event_time_stamp(event);
+			*ts = rb_fix_abs_ts(*ts, iter->head_page->page->time_stamp);
 			ring_buffer_normalize_time_stamp(cpu_buffer->buffer,
 							 cpu_buffer->cpu, ts);
 		}
 		pr_info("        total events:   %ld\n", total_lost + total_read);
 		pr_info("  recorded len bytes:   %ld\n", total_len);
 		pr_info(" recorded size bytes:   %ld\n", total_size);
-		if (total_lost)
+		if (total_lost) {
 			pr_info(" With dropped events, record len and size may not match\n"
 				" alloced and written from above\n");
-		if (!total_lost) {
+		} else {
 			if (RB_WARN_ON(buffer, total_len != total_alloc ||
 				       total_size != total_written))
 				break;

kernel/trace/trace.c+45−27

 		pos = 0;
 		ret = trace_get_user(&parser, ubuf, cnt, &pos);
-		if (ret < 0 || !trace_parser_loaded(&parser))
+		if (ret < 0)
 			break;
 		read += ret;
 		ubuf += ret;
 		cnt -= ret;
+		if (!trace_parser_loaded(&parser))
+			break;
 		ret = -EINVAL;
 		if (kstrtoul(parser.buffer, 0, &val))
 			break;
 	if (!nr_pids) {
 		/* Cleared the list of pids */
 		trace_pid_list_free(pid_list);
-		read = ret;
 		pid_list = NULL;
 	}
 EXPORT_SYMBOL_GPL(tracing_snapshot_cond);
 /**
- * tracing_snapshot_cond_data - get the user data associated with a snapshot
+ * tracing_cond_snapshot_data - get the user data associated with a snapshot
  * @tr:		The tracing instance
  *
  * When the user enables a conditional snapshot using
 	{ ktime_get_mono_fast_ns,	"mono",		1 },
 	{ ktime_get_raw_fast_ns,	"mono_raw",	1 },
 	{ ktime_get_boot_fast_ns,	"boot",		1 },
+	{ ktime_get_tai_fast_ns,	"tai",		1 },
 	ARCH_TRACE_CLOCKS
 };
 }
 EXPORT_SYMBOL_GPL(trace_event_buffer_lock_reserve);
-static DEFINE_SPINLOCK(tracepoint_iter_lock);
+static DEFINE_RAW_SPINLOCK(tracepoint_iter_lock);
 static DEFINE_MUTEX(tracepoint_printk_mutex);
 static void output_printk(struct trace_event_buffer *fbuffer)
 	event = &fbuffer->trace_file->event_call->event;
-	spin_lock_irqsave(&tracepoint_iter_lock, flags);
+	raw_spin_lock_irqsave(&tracepoint_iter_lock, flags);
 	trace_seq_init(&iter->seq);
 	iter->ent = fbuffer->entry;
 	event_call->event.funcs->trace(iter, 0, event);
 	trace_seq_putc(&iter->seq, 0);
 	printk("%s", iter->seq.buffer);
-	spin_unlock_irqrestore(&tracepoint_iter_lock, flags);
+	raw_spin_unlock_irqrestore(&tracepoint_iter_lock, flags);
 }
 int tracepoint_printk_sysctl(struct ctl_table *table, int write,
 				       unsigned int flags)
 {
 	bool tgid = flags & TRACE_ITER_RECORD_TGID;
-	const char *space = "            ";
+	static const char space[] = "            ";
 	int prec = tgid ? 12 : 2;
 	print_event_info(buf, m);
 	struct tracer *type = iter->trace;
 	unsigned long entries;
 	unsigned long total;
-	const char *name = "preemption";
+	const char *name = type->name;
-	name = type->name;
 	get_total_entries(buf, &total, &entries);
 	"  error_log\t- error log for failed commands (that support it)\n"
 	"  buffer_size_kb\t- view and modify size of per cpu buffer\n"
 	"  buffer_total_size_kb  - view total size of all cpu buffers\n\n"
-	"  trace_clock\t\t-change the clock used to order events\n"
+	"  trace_clock\t\t- change the clock used to order events\n"
 	"       local:   Per cpu clock but may not be synced across CPUs\n"
 	"      global:   Synced across CPUs but slows tracing down.\n"
 	"     counter:   Not a clock, but just an increment\n"
 #ifdef CONFIG_X86_64
 	"     x86-tsc:   TSC cycle counter\n"
 #endif
-	"\n  timestamp_mode\t-view the mode used to timestamp events\n"
+	"\n  timestamp_mode\t- view the mode used to timestamp events\n"
 	"       delta:   Delta difference against a buffer-wide timestamp\n"
 	"    absolute:   Absolute (standalone) timestamp\n"
 	"\n  trace_marker\t\t- Writes into this file writes into the kernel buffer\n"
 	tr->current_trace = &nop_trace;
 }
+static bool tracer_options_updated;
 static void add_tracer_options(struct trace_array *tr, struct tracer *t)
 {
 	/* Only enable if the directory has been created already. */
 	if (!tr->dir)
 		return;
+	/* Only create trace option files after update_tracer_options finish */
+	if (!tracer_options_updated)
+		return;
 	create_trace_option_files(tr, t);
 }
 {
 	struct trace_array *tr = filp->private_data;
 	char buf[MAX_TRACER_SIZE+1];
-	int i;
+	char *name;
 	size_t ret;
 	int err;
 	buf[cnt] = 0;
-	/* strip ending whitespace. */
+	name = strim(buf);
-	for (i = cnt - 1; i > 0 && isspace(buf[i]); i--)
-		buf[i] = 0;
-	err = tracing_set_tracer(tr, buf);
+	err = tracing_set_tracer(tr, name);
 	if (err)
 		return err;
 static void update_tracer_options(struct trace_array *tr)
 {
 	mutex_lock(&trace_types_lock);
+	tracer_options_updated = true;
 	__update_tracer_options(tr);
 	mutex_unlock(&trace_types_lock);
 }
 static struct workqueue_struct *eval_map_wq __initdata;
 static struct work_struct eval_map_work __initdata;
+static struct work_struct tracerfs_init_work __initdata;
 static void __init eval_map_work_func(struct work_struct *work)
 {
 	return 0;
 }
+subsys_initcall(trace_eval_init);
 static int __init trace_eval_sync(void)
 {
 	/* Make sure the eval map updates are finished */
 };
 #endif /* CONFIG_MODULES */
-static __init int tracer_init_tracefs(void)
+static __init void tracer_init_tracefs_work_func(struct work_struct *work)
 {
-	int ret;
-	trace_access_lock_init();
-	ret = tracing_init_dentry();
-	if (ret)
-		return 0;
 	event_trace_init();
 	trace_create_file("saved_tgids", TRACE_MODE_READ, NULL,
 			NULL, &tracing_saved_tgids_fops);
-	trace_eval_init();
 	trace_create_eval_file(NULL);
 #ifdef CONFIG_MODULES
 	create_trace_instances(NULL);
 	update_tracer_options(&global_trace);
+}
+static __init int tracer_init_tracefs(void)
+{
+	int ret;
+	trace_access_lock_init();
+	ret = tracing_init_dentry();
+	if (ret)
+		return 0;
+	if (eval_map_wq) {
+		INIT_WORK(&tracerfs_init_work, tracer_init_tracefs_work_func);
+		queue_work(eval_map_wq, &tracerfs_init_work);
+	} else {
+		tracer_init_tracefs_work_func(NULL);
+	}
 	return 0;
 }

kernel/trace/trace.h+11−15

 };
 extern int event_enable_trigger_print(struct seq_file *m,
-				      struct event_trigger_ops *ops,
-				      struct event_trigger_data *data);
-extern void event_enable_trigger_free(struct event_trigger_ops *ops,
 				      struct event_trigger_data *data);
+extern void event_enable_trigger_free(struct event_trigger_data *data);
 extern int event_enable_trigger_parse(struct event_command *cmd_ops,
 				      struct trace_event_file *file,
-				      char *glob, char *cmd, char *param);
+				      char *glob, char *cmd,
+				      char *param_and_filter);
 extern int event_enable_register_trigger(char *glob,
 					 struct event_trigger_data *data,
 					 struct trace_event_file *file);
 					    struct event_trigger_data *test,
 					    struct trace_event_file *file);
 extern void trigger_data_free(struct event_trigger_data *data);
-extern int event_trigger_init(struct event_trigger_ops *ops,
+extern int event_trigger_init(struct event_trigger_data *data);
-			      struct event_trigger_data *data);
 extern int trace_event_trigger_enable_disable(struct trace_event_file *file,
 					      int trigger_enable);
 extern void update_cond_flag(struct trace_event_file *file);
 extern int event_trigger_register(struct event_command *cmd_ops,
 				  struct trace_event_file *file,
 				  char *glob,
-				  char *cmd,
+				  struct event_trigger_data *trigger_data);
-				  char *trigger,
+extern void event_trigger_unregister(struct event_command *cmd_ops,
-				  struct event_trigger_data *trigger_data,
+				     struct trace_event_file *file,
-				  int *n_registered);
+				     char *glob,
+				     struct event_trigger_data *trigger_data);
 /**
  * struct event_trigger_ops - callbacks for trace event triggers
 					   struct trace_buffer *buffer,
 					   void *rec,
 					   struct ring_buffer_event *rbe);
-	int			(*init)(struct event_trigger_ops *ops,
+	int			(*init)(struct event_trigger_data *data);
-					struct event_trigger_data *data);
+	void			(*free)(struct event_trigger_data *data);
-	void			(*free)(struct event_trigger_ops *ops,
-					struct event_trigger_data *data);
 	int			(*print)(struct seq_file *m,
-					 struct event_trigger_ops *ops,
 					 struct event_trigger_data *data);
 };

kernel/trace/trace_boot.c+1−1

@@ -300,7 +300,7 @@ trace_boot_hist_add_handlers(struct xbc_node hnode, char *bufp, · 299 unmodified lines
300	{	300	{
301	struct xbc_node *node;	301	struct xbc_node *node;
302	const char p, handler;	302	const char p, handler;
303	int ret;	303	int ret = 0;
304		304
305	handler = xbc_node_get_data(hnode);	305	handler = xbc_node_get_data(hnode);
306		306

kernel/trace/trace_dynevent.c+2−7

 /* Make a tracefs interface for controlling dynamic events */
 static __init int init_dynamic_event(void)
 {
-	struct dentry *entry;
 	int ret;
 	ret = tracing_init_dentry();
 	if (ret)
 		return 0;
-	entry = tracefs_create_file("dynamic_events", TRACE_MODE_WRITE, NULL,
+	trace_create_file("dynamic_events", TRACE_MODE_WRITE, NULL,
-				    NULL, &dynamic_events_ops);
+			  NULL, &dynamic_events_ops);
-	/* Event list interface */
-	if (!entry)
-		pr_warn("Could not create tracefs 'dynamic_events' entry\n");
 	return 0;
 }

kernel/trace/trace_eprobe.c+12−12

  * functions are just stubs to fulfill what is needed to use the trigger
  * infrastructure.
  */
-static int eprobe_trigger_init(struct event_trigger_ops *ops,
+static int eprobe_trigger_init(struct event_trigger_data *data)
-			       struct event_trigger_data *data)
 {
 	return 0;
 }
-static void eprobe_trigger_free(struct event_trigger_ops *ops,
+static void eprobe_trigger_free(struct event_trigger_data *data)
-				struct event_trigger_data *data)
 {
 }
 static int eprobe_trigger_print(struct seq_file *m,
-				struct event_trigger_ops *ops,
 				struct event_trigger_data *data)
 {
 	/* Do not print eprobe event triggers */
 static int eprobe_trigger_cmd_parse(struct event_command *cmd_ops,
 				    struct trace_event_file *file,
-				    char *glob, char *cmd, char *param)
+				    char *glob, char *cmd,
+				    char *param_and_filter)
 {
 	return -1;
 }
 static int disable_eprobe(struct trace_eprobe *ep,
 			  struct trace_array *tr)
 {
-	struct event_trigger_data *trigger;
+	struct event_trigger_data *trigger = NULL, *iter;
 	struct trace_event_file *file;
 	struct eprobe_data *edata;
 	if (!file)
 		return -ENOENT;
-	list_for_each_entry(trigger, &file->triggers, list) {
+	list_for_each_entry(iter, &file->triggers, list) {
-		if (!(trigger->flags & EVENT_TRIGGER_FL_PROBE))
+		if (!(iter->flags & EVENT_TRIGGER_FL_PROBE))
 			continue;
-		edata = trigger->private_data;
+		edata = iter->private_data;
-		if (edata->ep == ep)
+		if (edata->ep == ep) {
+			trigger = iter;
 			break;
+		}
 	}
-	if (list_entry_is_head(trigger, &file->triggers, list))
+	if (!trigger)
 		return -ENODEV;
 	list_del_rcu(&trigger->list);

kernel/trace/trace_events.c+30−39

 			if (!(dereference_flags & (1ULL << arg)))
 				goto next_arg;
-			/* Check for __get_sockaddr */;
-			if (str_has_prefix(fmt + i, "__get_sockaddr(")) {
-				dereference_flags &= ~(1ULL << arg);
-				goto next_arg;
-			}
 			/* Find the REC-> in the argument */
 			c = strchr(fmt + i, ',');
 			r = strstr(fmt + i, "REC->");
 				a = strchr(fmt + i, '&');
 				if ((a && (a < r)) || test_field(r, call))
 					dereference_flags &= ~(1ULL << arg);
+			} else if ((r = strstr(fmt + i, "__get_dynamic_array(")) &&
+				   (!c || r < c)) {
+				dereference_flags &= ~(1ULL << arg);
+			} else if ((r = strstr(fmt + i, "__get_sockaddr(")) &&
+				   (!c || r < c)) {
+				dereference_flags &= ~(1ULL << arg);
 			}
 		next_arg:
 			i--;
 			arg++;
 static int subsystem_open(struct inode *inode, struct file *filp)
 {
+	struct trace_subsystem_dir *dir = NULL, *iter_dir;
+	struct trace_array *tr = NULL, *iter_tr;
 	struct event_subsystem *system = NULL;
-	struct trace_subsystem_dir *dir = NULL; /* Initialize for gcc */
-	struct trace_array *tr;
 	int ret;
 	if (tracing_is_disabled())
 	/* Make sure the system still exists */
 	mutex_lock(&event_mutex);
 	mutex_lock(&trace_types_lock);
-	list_for_each_entry(tr, &ftrace_trace_arrays, list) {
+	list_for_each_entry(iter_tr, &ftrace_trace_arrays, list) {
-		list_for_each_entry(dir, &tr->systems, list) {
+		list_for_each_entry(iter_dir, &iter_tr->systems, list) {
-			if (dir == inode->i_private) {
+			if (iter_dir == inode->i_private) {
 				/* Don't open systems with no events */
+				tr = iter_tr;
+				dir = iter_dir;
 				if (dir->nr_events) {
 					__get_system_dir(dir);
 					system = dir->subsystem;
 	if (!system)
 		return -ENODEV;
-	/* Some versions of gcc think dir can be uninitialized here */
-	WARN_ON(!dir);
 	/* Still need to increment the ref count of the system */
 	if (trace_array_get(tr) < 0) {
 		put_system(dir);
 event_subsystem_dir(struct trace_array *tr, const char *name,
 		    struct trace_event_file *file, struct dentry *parent)
 {
+	struct event_subsystem *system, *iter;
 	struct trace_subsystem_dir *dir;
-	struct event_subsystem *system;
 	struct dentry *entry;
 	/* First see if we did not already create this dir */
 	}
 	/* Now see if the system itself exists. */
-	list_for_each_entry(system, &event_subsystems, list) {
+	system = NULL;
-		if (strcmp(system->name, name) == 0)
+	list_for_each_entry(iter, &event_subsystems, list) {
+		if (strcmp(iter->name, name) == 0) {
+			system = iter;
 			break;
+		}
 	}
-	/* Reset system variable when not found */
-	if (&system->list == &event_subsystems)
-		system = NULL;
 	dir = kmalloc(sizeof(*dir), GFP_KERNEL);
 	if (!dir)
 	struct dentry *d_events;
 	struct dentry *entry;
-	entry = tracefs_create_file("set_event", TRACE_MODE_WRITE, parent,
+	entry = trace_create_file("set_event", TRACE_MODE_WRITE, parent,
-				    tr, &ftrace_set_event_fops);
+				  tr, &ftrace_set_event_fops);
-	if (!entry) {
+	if (!entry)
-		pr_warn("Could not create tracefs 'set_event' entry\n");
 		return -ENOMEM;
-	}
 	d_events = tracefs_create_dir("events", parent);
 	if (!d_events) {
 	/* There are not as crucial, just warn if they are not created */
-	entry = tracefs_create_file("set_event_pid", TRACE_MODE_WRITE, parent,
+	trace_create_file("set_event_pid", TRACE_MODE_WRITE, parent,
-				    tr, &ftrace_set_event_pid_fops);
+			  tr, &ftrace_set_event_pid_fops);
-	if (!entry)
-		pr_warn("Could not create tracefs 'set_event_pid' entry\n");
-	entry = tracefs_create_file("set_event_notrace_pid",
+	trace_create_file("set_event_notrace_pid",
-				    TRACE_MODE_WRITE, parent, tr,
+			  TRACE_MODE_WRITE, parent, tr,
-				    &ftrace_set_event_notrace_pid_fops);
+			  &ftrace_set_event_notrace_pid_fops);
-	if (!entry)
-		pr_warn("Could not create tracefs 'set_event_notrace_pid' entry\n");
 	/* ring buffer internal formats */
 	trace_create_file("header_page", TRACE_MODE_READ, d_events,
 __init int event_trace_init(void)
 {
 	struct trace_array *tr;
-	struct dentry *entry;
 	int ret;
 	tr = top_trace_array();
 	if (!tr)
 		return -ENODEV;
-	entry = tracefs_create_file("available_events", TRACE_MODE_READ,
+	trace_create_file("available_events", TRACE_MODE_READ,
-				    NULL, tr, &ftrace_avail_fops);
+			  NULL, tr, &ftrace_avail_fops);
-	if (!entry)
-		pr_warn("Could not create tracefs 'available_events' entry\n");
 	ret = early_event_add_tracer(NULL, tr);
 	if (ret)

kernel/trace/trace_events_filter.c+1−1

@@ -1816,7 +1816,7 @@ static void create_filter_finish(struct filter_parse_error *pe) · 1815 unmodified lines
1816	* create_filter - create a filter for a trace_event_call	1816	* create_filter - create a filter for a trace_event_call
1817	* @tr: the trace array associated with these events	1817	* @tr: the trace array associated with these events
1818	* @call: trace_event_call to create a filter for	1818	* @call: trace_event_call to create a filter for
1819	* @filter_str: filter string	1819	* @filter_string: filter string
1820	* @set_str: remember @filter_str and enable detailed error in filter	1820	* @set_str: remember @filter_str and enable detailed error in filter
1821	* @filterp: out param for created filter (always updated on return)	1821	* @filterp: out param for created filter (always updated on return)
1822	* Must be a pointer that references a NULL pointer.	1822	* Must be a pointer that references a NULL pointer.

kernel/trace/trace_events_hist.c+99−92

@@ -2093,8 +2093,11 @@ static int init_var_ref(struct hist_field *ref_field, · 2092 unmodified lines
2093	return err;	2093	return err;
2094	free:	2094	free:
2095	kfree(ref_field->system);	2095	kfree(ref_field->system);
		2096	ref_field->system = NULL;
2096	kfree(ref_field->event_name);	2097	kfree(ref_field->event_name);
		2098	ref_field->event_name = NULL;
2097	kfree(ref_field->name);	2099	kfree(ref_field->name);
		2100	ref_field->name = NULL;
2098		2101
2099	goto out;	2102	goto out;
2100	}	2103	}
@@ -2785,7 +2788,8 @@ static char find_trigger_filter(struct hist_trigger_data hist_data, · 684 unmodified lines
2785	static struct event_command trigger_hist_cmd;	2788	static struct event_command trigger_hist_cmd;
2786	static int event_hist_trigger_parse(struct event_command *cmd_ops,	2789	static int event_hist_trigger_parse(struct event_command *cmd_ops,
2787	struct trace_event_file *file,	2790	struct trace_event_file *file,
2788	char glob, char cmd, char *param);	2791	char glob, char cmd,
		2792	char *param_and_filter);
2789		2793
2790	static bool compatible_keys(struct hist_trigger_data *target_hist_data,	2794	static bool compatible_keys(struct hist_trigger_data *target_hist_data,
2791	struct hist_trigger_data *hist_data,	2795	struct hist_trigger_data *hist_data,
@@ -4161,7 +4165,7 @@ static int create_val_field(struct hist_trigger_data *hist_data, · 1369 unmodified lines
4161	return __create_val_field(hist_data, val_idx, file, NULL, field_str, 0);	4165	return __create_val_field(hist_data, val_idx, file, NULL, field_str, 0);
4162	}	4166	}
4163		4167
4164	static const char *no_comm = "(no comm)";	4168	static const char no_comm[] = "(no comm)";
4165		4169
4166	static u64 hist_field_execname(struct hist_field *hist_field,	4170	static u64 hist_field_execname(struct hist_field *hist_field,
4167	struct tracing_map_elt *elt,	4171	struct tracing_map_elt *elt,
@@ -5252,7 +5256,7 @@ static void hist_trigger_show(struct seq_file *m, · 1084 unmodified lines
5252	seq_puts(m, "\n\n");	5256	seq_puts(m, "\n\n");
5253		5257
5254	seq_puts(m, "# event histogram\n#\n# trigger info: ");	5258	seq_puts(m, "# event histogram\n#\n# trigger info: ");
5255	data->ops->print(m, data->ops, data);	5259	data->ops->print(m, data);
5256	seq_puts(m, "#\n\n");	5260	seq_puts(m, "#\n\n");
5257		5261
5258	hist_data = data->private_data;	5262	hist_data = data->private_data;
@@ -5484,7 +5488,7 @@ static void hist_trigger_debug_show(struct seq_file *m, · 225 unmodified lines
5484	seq_puts(m, "\n\n");	5488	seq_puts(m, "\n\n");
5485		5489
5486	seq_puts(m, "# event histogram\n#\n# trigger info: ");	5490	seq_puts(m, "# event histogram\n#\n# trigger info: ");
5487	data->ops->print(m, data->ops, data);	5491	data->ops->print(m, data);
5488	seq_puts(m, "#\n\n");	5492	seq_puts(m, "#\n\n");
5489		5493
5490	hist_data = data->private_data;	5494	hist_data = data->private_data;
@@ -5621,7 +5625,6 @@ static void hist_field_print(struct seq_file m, struct hist_field hist_field) · 130 unmodified lines
5621	}	5625	}
5622		5626
5623	static int event_hist_trigger_print(struct seq_file *m,	5627	static int event_hist_trigger_print(struct seq_file *m,
5624	struct event_trigger_ops *ops,
5625	struct event_trigger_data *data)	5628	struct event_trigger_data *data)
5626	{	5629	{
5627	struct hist_trigger_data *hist_data = data->private_data;	5630	struct hist_trigger_data *hist_data = data->private_data;
@@ -5729,8 +5732,7 @@ static int event_hist_trigger_print(struct seq_file *m, · 101 unmodified lines
5729	return 0;	5732	return 0;
5730	}	5733	}
5731		5734
5732	static int event_hist_trigger_init(struct event_trigger_ops *ops,	5735	static int event_hist_trigger_init(struct event_trigger_data *data)
5733	struct event_trigger_data *data)
5734	{	5736	{
5735	struct hist_trigger_data *hist_data = data->private_data;	5737	struct hist_trigger_data *hist_data = data->private_data;
5736		5738
@@ -5758,8 +5760,7 @@ static void unregister_field_var_hists(struct hist_trigger_data *hist_data) · 21 unmodified lines
5758	}	5760	}
5759	}	5761	}
5760		5762
5761	static void event_hist_trigger_free(struct event_trigger_ops *ops,	5763	static void event_hist_trigger_free(struct event_trigger_data *data)
5762	struct event_trigger_data *data)
5763	{	5764	{
5764	struct hist_trigger_data *hist_data = data->private_data;	5765	struct hist_trigger_data *hist_data = data->private_data;
5765		5766
@@ -5788,25 +5789,23 @@ static struct event_trigger_ops event_hist_trigger_ops = { · 22 unmodified lines
5788	.free = event_hist_trigger_free,	5789	.free = event_hist_trigger_free,
5789	};	5790	};
5790		5791
5791	static int event_hist_trigger_named_init(struct event_trigger_ops *ops,	5792	static int event_hist_trigger_named_init(struct event_trigger_data *data)
5792	struct event_trigger_data *data)
5793	{	5793	{
5794	data->ref++;	5794	data->ref++;
5795		5795
5796	save_named_trigger(data->named_data->name, data);	5796	save_named_trigger(data->named_data->name, data);
5797		5797
5798	event_hist_trigger_init(ops, data->named_data);	5798	event_hist_trigger_init(data->named_data);
5799		5799
5800	return 0;	5800	return 0;
5801	}	5801	}
5802		5802
5803	static void event_hist_trigger_named_free(struct event_trigger_ops *ops,	5803	static void event_hist_trigger_named_free(struct event_trigger_data *data)
5804	struct event_trigger_data *data)
5805	{	5804	{
5806	if (WARN_ON_ONCE(data->ref <= 0))	5805	if (WARN_ON_ONCE(data->ref <= 0))
5807	return;	5806	return;
5808		5807
5809	event_hist_trigger_free(ops, data->named_data);	5808	event_hist_trigger_free(data->named_data);
5810		5809
5811	data->ref--;	5810	data->ref--;
5812	if (!data->ref) {	5811	if (!data->ref) {
@@ -5933,6 +5932,48 @@ static bool hist_trigger_match(struct event_trigger_data *data, · 120 unmodified lines
5933	return true;	5932	return true;
5934	}	5933	}
5935		5934
		5935	static bool existing_hist_update_only(char *glob,
		5936	struct event_trigger_data *data,
		5937	struct trace_event_file *file)
		5938	{
		5939	struct hist_trigger_data *hist_data = data->private_data;
		5940	struct event_trigger_data test, named_data = NULL;
		5941	bool updated = false;
		5942
		5943	if (!hist_data->attrs->pause && !hist_data->attrs->cont &&
		5944	!hist_data->attrs->clear)
		5945	goto out;
		5946
		5947	if (hist_data->attrs->name) {
		5948	named_data = find_named_trigger(hist_data->attrs->name);
		5949	if (named_data) {
		5950	if (!hist_trigger_match(data, named_data, named_data,
		5951	true))
		5952	goto out;
		5953	}
		5954	}
		5955
		5956	if (hist_data->attrs->name && !named_data)
		5957	goto out;
		5958
		5959	list_for_each_entry(test, &file->triggers, list) {
		5960	if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) {
		5961	if (!hist_trigger_match(data, test, named_data, false))
		5962	continue;
		5963	if (hist_data->attrs->pause)
		5964	test->paused = true;
		5965	else if (hist_data->attrs->cont)
		5966	test->paused = false;
		5967	else if (hist_data->attrs->clear)
		5968	hist_clear(test);
		5969	updated = true;
		5970	goto out;
		5971	}
		5972	}
		5973	out:
		5974	return updated;
		5975	}
		5976
5936	static int hist_register_trigger(char *glob,	5977	static int hist_register_trigger(char *glob,
5937	struct event_trigger_data *data,	5978	struct event_trigger_data *data,
5938	struct trace_event_file *file)	5979	struct trace_event_file *file)
@@ -5961,19 +6002,11 @@ static int hist_register_trigger(char *glob, · 22 unmodified lines
5961		6002
5962	list_for_each_entry(test, &file->triggers, list) {	6003	list_for_each_entry(test, &file->triggers, list) {
5963	if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) {	6004	if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) {
5964	if (!hist_trigger_match(data, test, named_data, false))	6005	if (hist_trigger_match(data, test, named_data, false)) {
5965	continue;
5966	if (hist_data->attrs->pause)
5967	test->paused = true;
5968	else if (hist_data->attrs->cont)
5969	test->paused = false;
5970	else if (hist_data->attrs->clear)
5971	hist_clear(test);
5972	else {
5973	hist_err(tr, HIST_ERR_TRIGGER_EEXIST, 0);	6006	hist_err(tr, HIST_ERR_TRIGGER_EEXIST, 0);
5974	ret = -EEXIST;	6007	ret = -EEXIST;
		6008	goto out;
5975	}	6009	}
5976	goto out;
5977	}	6010	}
5978	}	6011	}
5979	new:	6012	new:
@@ -5993,7 +6026,7 @@ static int hist_register_trigger(char *glob, · 13 unmodified lines
5993	}	6026	}
5994		6027
5995	if (data->ops->init) {	6028	if (data->ops->init) {
5996	ret = data->ops->init(data->ops, data);	6029	ret = data->ops->init(data);
5997	if (ret < 0)	6030	if (ret < 0)
5998	goto out;	6031	goto out;
5999	}	6032	}
@@ -6012,8 +6045,6 @@ static int hist_register_trigger(char *glob, · 12 unmodified lines
6012		6045
6013	if (named_data)	6046	if (named_data)
6014	destroy_hist_data(hist_data);	6047	destroy_hist_data(hist_data);
6015
6016	ret++;
6017	out:	6048	out:
6018	return ret;	6049	return ret;
6019	}	6050	}
@@ -6089,20 +6120,19 @@ static void hist_unregister_trigger(char *glob, · 69 unmodified lines
6089	struct event_trigger_data *data,	6120	struct event_trigger_data *data,
6090	struct trace_event_file *file)	6121	struct trace_event_file *file)
6091	{	6122	{
		6123	struct event_trigger_data test = NULL, iter, *named_data = NULL;
6092	struct hist_trigger_data *hist_data = data->private_data;	6124	struct hist_trigger_data *hist_data = data->private_data;
6093	struct event_trigger_data test, named_data = NULL;
6094	bool unregistered = false;
6095		6125
6096	lockdep_assert_held(&event_mutex);	6126	lockdep_assert_held(&event_mutex);
6097		6127
6098	if (hist_data->attrs->name)	6128	if (hist_data->attrs->name)
6099	named_data = find_named_trigger(hist_data->attrs->name);	6129	named_data = find_named_trigger(hist_data->attrs->name);
6100		6130
6101	list_for_each_entry(test, &file->triggers, list) {	6131	list_for_each_entry(iter, &file->triggers, list) {
6102	if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) {	6132	if (iter->cmd_ops->trigger_type == ETT_EVENT_HIST) {
6103	if (!hist_trigger_match(data, test, named_data, false))	6133	if (!hist_trigger_match(data, iter, named_data, false))
6104	continue;	6134	continue;
6105	unregistered = true;	6135	test = iter;
6106	list_del_rcu(&test->list);	6136	list_del_rcu(&test->list);
6107	trace_event_trigger_enable_disable(file, 0);	6137	trace_event_trigger_enable_disable(file, 0);
6108	update_cond_flag(file);	6138	update_cond_flag(file);
@@ -6110,11 +6140,11 @@ static void hist_unregister_trigger(char *glob, · 1 unmodified line
6110	}	6140	}
6111	}	6141	}
6112		6142
6113	if (unregistered && test->ops->free)	6143	if (test && test->ops->free)
6114	test->ops->free(test->ops, test);	6144	test->ops->free(test);
6115		6145
6116	if (hist_data->enable_timestamps) {	6146	if (hist_data->enable_timestamps) {
6117	if (!hist_data->remove \|\| unregistered)	6147	if (!hist_data->remove \|\| test)
6118	tracing_set_filter_buffering(file->tr, false);	6148	tracing_set_filter_buffering(file->tr, false);
6119	}	6149	}
6120	}	6150	}
@@ -6164,57 +6194,57 @@ static void hist_unreg_all(struct trace_event_file *file) · 43 unmodified lines
6164	if (hist_data->enable_timestamps)	6194	if (hist_data->enable_timestamps)
6165	tracing_set_filter_buffering(file->tr, false);	6195	tracing_set_filter_buffering(file->tr, false);
6166	if (test->ops->free)	6196	if (test->ops->free)
6167	test->ops->free(test->ops, test);	6197	test->ops->free(test);
6168	}	6198	}
6169	}	6199	}
6170	}	6200	}
6171		6201
6172	static int event_hist_trigger_parse(struct event_command *cmd_ops,	6202	static int event_hist_trigger_parse(struct event_command *cmd_ops,
6173	struct trace_event_file *file,	6203	struct trace_event_file *file,
6174	char glob, char cmd, char *param)	6204	char glob, char cmd,
		6205	char *param_and_filter)
6175	{	6206	{
6176	unsigned int hist_trigger_bits = TRACING_MAP_BITS_DEFAULT;	6207	unsigned int hist_trigger_bits = TRACING_MAP_BITS_DEFAULT;
6177	struct event_trigger_data *trigger_data;	6208	struct event_trigger_data *trigger_data;
6178	struct hist_trigger_attrs *attrs;	6209	struct hist_trigger_attrs *attrs;
6179	struct event_trigger_ops *trigger_ops;
6180	struct hist_trigger_data *hist_data;	6210	struct hist_trigger_data *hist_data;
		6211	char param, filter, p, start;
6181	struct synth_event *se;	6212	struct synth_event *se;
6182	const char *se_name;	6213	const char *se_name;
6183	bool remove = false;	6214	bool remove;
6184	char trigger, p, *start;
6185	int ret = 0;	6215	int ret = 0;
6186		6216
6187	lockdep_assert_held(&event_mutex);	6217	lockdep_assert_held(&event_mutex);
6188		6218
6189	WARN_ON(!glob);	6219	if (WARN_ON(!glob))
		6220	return -EINVAL;
6190		6221
6191	if (strlen(glob)) {	6222	if (glob[0]) {
6192	hist_err_clear();	6223	hist_err_clear();
6193	last_cmd_set(file, param);	6224	last_cmd_set(file, param_and_filter);
6194	}	6225	}
6195		6226
6196	if (!param)	6227	remove = event_trigger_check_remove(glob);
6197	return -EINVAL;
6198		6228
6199	if (glob[0] == '!')	6229	if (event_trigger_empty_param(param_and_filter))
6200	remove = true;	6230	return -EINVAL;
6201		6231
6202	/*	6232	/*
6203	* separate the trigger from the filter (k:v [if filter])	6233	* separate the trigger from the filter (k:v [if filter])
6204	* allowing for whitespace in the trigger	6234	* allowing for whitespace in the trigger
6205	*/	6235	*/
6206	p = trigger = param;	6236	p = param = param_and_filter;
6207	do {	6237	do {
6208	p = strstr(p, "if");	6238	p = strstr(p, "if");
6209	if (!p)	6239	if (!p)
6210	break;	6240	break;
6211	if (p == param)	6241	if (p == param_and_filter)
6212	return -EINVAL;	6242	return -EINVAL;
6213	if ((p - 1) != ' ' && (p - 1) != '\t') {	6243	if ((p - 1) != ' ' && (p - 1) != '\t') {
6214	p++;	6244	p++;
6215	continue;	6245	continue;
6216	}	6246	}
6217	if (p >= param + strlen(param) - (sizeof("if") - 1) - 1)	6247	if (p >= param_and_filter + strlen(param_and_filter) - (sizeof("if") - 1) - 1)
6218	return -EINVAL;	6248	return -EINVAL;
6219	if ((p + sizeof("if") - 1) != ' ' && (p + sizeof("if") - 1) != '\t') {	6249	if ((p + sizeof("if") - 1) != ' ' && (p + sizeof("if") - 1) != '\t') {
6220	p++;	6250	p++;
@@ -6224,24 +6254,24 @@ static int event_hist_trigger_parse(struct event_command *cmd_ops, · 3 unmodified lines
6224	} while (1);	6254	} while (1);
6225		6255
6226	if (!p)	6256	if (!p)
6227	param = NULL;	6257	filter = NULL;
6228	else {	6258	else {
6229	*(p - 1) = '\0';	6259	*(p - 1) = '\0';
6230	param = strstrip(p);	6260	filter = strstrip(p);
6231	trigger = strstrip(trigger);	6261	param = strstrip(param);
6232	}	6262	}
6233		6263
6234	/*	6264	/*
6235	* To simplify arithmetic expression parsing, replace occurrences of	6265	* To simplify arithmetic expression parsing, replace occurrences of
6236	* '.sym-offset' modifier with '.symXoffset'	6266	* '.sym-offset' modifier with '.symXoffset'
6237	*/	6267	*/
6238	start = strstr(trigger, ".sym-offset");	6268	start = strstr(param, ".sym-offset");
6239	while (start) {	6269	while (start) {
6240	*(start + 4) = 'X';	6270	*(start + 4) = 'X';
6241	start = strstr(start + 11, ".sym-offset");	6271	start = strstr(start + 11, ".sym-offset");
6242	}	6272	}
6243		6273
6244	attrs = parse_hist_trigger_attrs(file->tr, trigger);	6274	attrs = parse_hist_trigger_attrs(file->tr, param);
6245	if (IS_ERR(attrs))	6275	if (IS_ERR(attrs))
6246	return PTR_ERR(attrs);	6276	return PTR_ERR(attrs);
6247		6277
@@ -6254,29 +6284,15 @@ static int event_hist_trigger_parse(struct event_command *cmd_ops, · 6 unmodified lines
6254	return PTR_ERR(hist_data);	6284	return PTR_ERR(hist_data);
6255	}	6285	}
6256		6286
6257	trigger_ops = cmd_ops->get_trigger_ops(cmd, trigger);	6287	trigger_data = event_trigger_alloc(cmd_ops, cmd, param, hist_data);
6258
6259	trigger_data = kzalloc(sizeof(*trigger_data), GFP_KERNEL);
6260	if (!trigger_data) {	6288	if (!trigger_data) {
6261	ret = -ENOMEM;	6289	ret = -ENOMEM;
6262	goto out_free;	6290	goto out_free;
6263	}	6291	}
6264		6292
6265	trigger_data->count = -1;	6293	ret = event_trigger_set_filter(cmd_ops, file, filter, trigger_data);
6266	trigger_data->ops = trigger_ops;	6294	if (ret < 0)
6267	trigger_data->cmd_ops = cmd_ops;	6295	goto out_free;
6268
6269	INIT_LIST_HEAD(&trigger_data->list);
6270	RCU_INIT_POINTER(trigger_data->filter, NULL);
6271
6272	trigger_data->private_data = hist_data;
6273
6274	/* if param is non-empty, it's supposed to be a filter */
6275	if (param && cmd_ops->set_filter) {
6276	ret = cmd_ops->set_filter(param, trigger_data, file);
6277	if (ret < 0)
6278	goto out_free;
6279	}
6280		6296
6281	if (remove) {	6297	if (remove) {
6282	if (!have_hist_trigger_match(trigger_data, file))	6298	if (!have_hist_trigger_match(trigger_data, file))
@@ -6287,7 +6303,7 @@ static int event_hist_trigger_parse(struct event_command *cmd_ops, · 4 unmodified lines
6287	goto out_free;	6303	goto out_free;
6288	}	6304	}
6289		6305
6290	cmd_ops->unreg(glob+1, trigger_data, file);	6306	event_trigger_unregister(cmd_ops, file, glob+1, trigger_data);
6291	se_name = trace_event_name(file->event_call);	6307	se_name = trace_event_name(file->event_call);
6292	se = find_synth_event(se_name);	6308	se = find_synth_event(se_name);
6293	if (se)	6309	if (se)
@@ -6296,17 +6312,11 @@ static int event_hist_trigger_parse(struct event_command *cmd_ops, · 2 unmodified lines
6296	goto out_free;	6312	goto out_free;
6297	}	6313	}
6298		6314
6299	ret = cmd_ops->reg(glob, trigger_data, file);	6315	if (existing_hist_update_only(glob, trigger_data, file))
6300	/*
6301	* The above returns on success the # of triggers registered,
6302	* but if it didn't register any it returns zero. Consider no
6303	* triggers registered a failure too.
6304	*/
6305	if (!ret) {
6306	if (!(attrs->pause \|\| attrs->cont \|\| attrs->clear))
6307	ret = -ENOENT;
6308	goto out_free;	6316	goto out_free;
6309	} else if (ret < 0)	6317
		6318	ret = event_trigger_register(cmd_ops, file, glob, trigger_data);
		6319	if (ret < 0)
6310	goto out_free;	6320	goto out_free;
6311		6321
6312	if (get_named_trigger_data(trigger_data))	6322	if (get_named_trigger_data(trigger_data))
@@ -6331,18 +6341,15 @@ enable: · 18 unmodified lines
6331	se = find_synth_event(se_name);	6341	se = find_synth_event(se_name);
6332	if (se)	6342	if (se)
6333	se->ref++;	6343	se->ref++;
6334	/* Just return zero, not the number of registered triggers */
6335	ret = 0;
6336	out:	6344	out:
6337	if (ret == 0)	6345	if (ret == 0)
6338	hist_err_clear();	6346	hist_err_clear();
6339		6347
6340	return ret;	6348	return ret;
6341	out_unreg:	6349	out_unreg:
6342	cmd_ops->unreg(glob+1, trigger_data, file);	6350	event_trigger_unregister(cmd_ops, file, glob+1, trigger_data);
6343	out_free:	6351	out_free:
6344	if (cmd_ops->set_filter)	6352	event_trigger_reset_filter(cmd_ops, trigger_data);
6345	cmd_ops->set_filter(NULL, trigger_data, NULL);
6346		6353
6347	remove_hist_vars(hist_data);	6354	remove_hist_vars(hist_data);
6348		6355
@@ -6463,7 +6470,7 @@ static void hist_enable_unreg_all(struct trace_event_file *file) · 114 unmodified lines
6463	update_cond_flag(file);	6470	update_cond_flag(file);
6464	trace_event_trigger_enable_disable(file, 0);	6471	trace_event_trigger_enable_disable(file, 0);
6465	if (test->ops->free)	6472	if (test->ops->free)
6466	test->ops->free(test->ops, test);	6473	test->ops->free(test);
6467	}	6474	}
6468	}	6475	}
6469	}	6476	}

kernel/trace/trace_events_trigger.c+108−216

@@ -188,7 +188,7 @@ static int trigger_show(struct seq_file m, void v) · 187 unmodified lines
188	}	188	}
189		189
190	data = list_entry(v, struct event_trigger_data, list);	190	data = list_entry(v, struct event_trigger_data, list);
191	data->ops->print(m, data->ops, data);	191	data->ops->print(m, data);
192		192
193	return 0;	193	return 0;
194	}	194	}
@@ -432,7 +432,6 @@ event_trigger_print(const char name, struct seq_file m, · 237 unmodified lines
432		432
433	/**	433	/**
434	* event_trigger_init - Generic event_trigger_ops @init implementation	434	* event_trigger_init - Generic event_trigger_ops @init implementation
435	* @ops: The trigger ops associated with the trigger
436	* @data: Trigger-specific data	435	* @data: Trigger-specific data
437	*	436	*
438	* Common implementation of event trigger initialization.	437	* Common implementation of event trigger initialization.
@@ -442,8 +441,7 @@ event_trigger_print(const char name, struct seq_file m, · 3 unmodified lines
442	*	441	*
443	* Return: 0 on success, errno otherwise	442	* Return: 0 on success, errno otherwise
444	*/	443	*/
445	int event_trigger_init(struct event_trigger_ops *ops,	444	int event_trigger_init(struct event_trigger_data *data)
446	struct event_trigger_data *data)
447	{	445	{
448	data->ref++;	446	data->ref++;
449	return 0;	447	return 0;
@@ -451,7 +449,6 @@ int event_trigger_init(struct event_trigger_ops *ops, · 1 unmodified line
451		449
452	/**	450	/**
453	* event_trigger_free - Generic event_trigger_ops @free implementation	451	* event_trigger_free - Generic event_trigger_ops @free implementation
454	* @ops: The trigger ops associated with the trigger
455	* @data: Trigger-specific data	452	* @data: Trigger-specific data
456	*	453	*
457	* Common implementation of event trigger de-initialization.	454	* Common implementation of event trigger de-initialization.
@@ -460,8 +457,7 @@ int event_trigger_init(struct event_trigger_ops *ops, · 2 unmodified lines
460	* implementations.	457	* implementations.
461	*/	458	*/
462	static void	459	static void
463	event_trigger_free(struct event_trigger_ops *ops,	460	event_trigger_free(struct event_trigger_data *data)
464	struct event_trigger_data *data)
465	{	461	{
466	if (WARN_ON_ONCE(data->ref <= 0))	462	if (WARN_ON_ONCE(data->ref <= 0))
467	return;	463	return;
@@ -515,7 +511,7 @@ clear_event_triggers(struct trace_array *tr) · 47 unmodified lines
515	trace_event_trigger_enable_disable(file, 0);	511	trace_event_trigger_enable_disable(file, 0);
516	list_del_rcu(&data->list);	512	list_del_rcu(&data->list);
517	if (data->ops->free)	513	if (data->ops->free)
518	data->ops->free(data->ops, data);	514	data->ops->free(data);
519	}	515	}
520	}	516	}
521	}	517	}
@@ -581,19 +577,18 @@ static int register_trigger(char *glob, · 59 unmodified lines
581	}	577	}
582		578
583	if (data->ops->init) {	579	if (data->ops->init) {
584	ret = data->ops->init(data->ops, data);	580	ret = data->ops->init(data);
585	if (ret < 0)	581	if (ret < 0)
586	goto out;	582	goto out;
587	}	583	}
588		584
589	list_add_rcu(&data->list, &file->triggers);	585	list_add_rcu(&data->list, &file->triggers);
590	ret++;
591		586
592	update_cond_flag(file);	587	update_cond_flag(file);
593	if (trace_event_trigger_enable_disable(file, 1) < 0) {	588	ret = trace_event_trigger_enable_disable(file, 1);
		589	if (ret < 0) {
594	list_del_rcu(&data->list);	590	list_del_rcu(&data->list);
595	update_cond_flag(file);	591	update_cond_flag(file);
596	ret--;
597	}	592	}
598	out:	593	out:
599	return ret;	594	return ret;
@@ -614,14 +609,13 @@ static void unregister_trigger(char *glob, · 14 unmodified lines
614	struct event_trigger_data *test,	609	struct event_trigger_data *test,
615	struct trace_event_file *file)	610	struct trace_event_file *file)
616	{	611	{
617	struct event_trigger_data *data;	612	struct event_trigger_data data = NULL, iter;
618	bool unregistered = false;
619		613
620	lockdep_assert_held(&event_mutex);	614	lockdep_assert_held(&event_mutex);
621		615
622	list_for_each_entry(data, &file->triggers, list) {	616	list_for_each_entry(iter, &file->triggers, list) {
623	if (data->cmd_ops->trigger_type == test->cmd_ops->trigger_type) {	617	if (iter->cmd_ops->trigger_type == test->cmd_ops->trigger_type) {
624	unregistered = true;	618	data = iter;
625	list_del_rcu(&data->list);	619	list_del_rcu(&data->list);
626	trace_event_trigger_enable_disable(file, 0);	620	trace_event_trigger_enable_disable(file, 0);
627	update_cond_flag(file);	621	update_cond_flag(file);
@@ -629,8 +623,8 @@ static void unregister_trigger(char *glob, · 1 unmodified line
629	}	623	}
630	}	624	}
631		625
632	if (unregistered && data->ops->free)	626	if (data && data->ops->free)
633	data->ops->free(data->ops, data);	627	data->ops->free(data);
634	}	628	}
635		629
636	/*	630	/*
@@ -744,15 +738,15 @@ bool event_trigger_empty_param(const char *param) · 107 unmodified lines
744		738
745	/**	739	/**
746	* event_trigger_separate_filter - separate an event trigger from a filter	740	* event_trigger_separate_filter - separate an event trigger from a filter
747	* @param: The param string containing trigger and possibly filter	741	* @param_and_filter: String containing trigger and possibly filter
748	* @trigger: outparam, will be filled with a pointer to the trigger	742	* @param: outparam, will be filled with a pointer to the trigger
749	* @filter: outparam, will be filled with a pointer to the filter	743	* @filter: outparam, will be filled with a pointer to the filter
750	* @param_required: Specifies whether or not the param string is required	744	* @param_required: Specifies whether or not the param string is required
751	*	745	*
752	* Given a param string of the form '[trigger] [if filter]', this	746	* Given a param string of the form '[trigger] [if filter]', this
753	* function separates the filter from the trigger and returns the	747	* function separates the filter from the trigger and returns the
754	* trigger in trigger and the filter in filter. Either the *trigger	748	* trigger in @param and the filter in @filter. Either the @param
755	* or the *filter may be set to NULL by this function - if not set to	749	* or the @filter may be set to NULL by this function - if not set to
756	* NULL, they will contain strings corresponding to the trigger and	750	* NULL, they will contain strings corresponding to the trigger and
757	* filter.	751	* filter.
758	*	752	*
@@ -927,48 +921,37 @@ void event_trigger_reset_filter(struct event_command *cmd_ops, · 168 unmodified lines
927	* @cmd_ops: The event_command operations for the trigger	921	* @cmd_ops: The event_command operations for the trigger
928	* @file: The event file for the trigger's event	922	* @file: The event file for the trigger's event
929	* @glob: The trigger command string, with optional remove(!) operator	923	* @glob: The trigger command string, with optional remove(!) operator
930	* @cmd: The cmd string
931	* @param: The param string
932	* @trigger_data: The trigger_data for the trigger	924	* @trigger_data: The trigger_data for the trigger
933	* @n_registered: optional outparam, the number of triggers registered
934	*	925	*
935	* Register an event trigger. The @cmd_ops are used to call the	926	* Register an event trigger. The @cmd_ops are used to call the
936	* cmd_ops->reg() function which actually does the registration. The	927	* cmd_ops->reg() function which actually does the registration.
937	* cmd_ops->reg() function returns the number of triggers registered,
938	* which is assigned to n_registered, if n_registered is non-NULL.
939	*	928	*
940	* Return: 0 on success, errno otherwise	929	* Return: 0 on success, errno otherwise
941	*/	930	*/
942	int event_trigger_register(struct event_command *cmd_ops,	931	int event_trigger_register(struct event_command *cmd_ops,
943	struct trace_event_file *file,	932	struct trace_event_file *file,
944	char *glob,	933	char *glob,
945	char *cmd,	934	struct event_trigger_data *trigger_data)
946	char *param,
947	struct event_trigger_data *trigger_data,
948	int *n_registered)
949	{	935	{
950	int ret;	936	return cmd_ops->reg(glob, trigger_data, file);
951		937	}
952	if (n_registered)
953	*n_registered = 0;
954
955	ret = cmd_ops->reg(glob, trigger_data, file);
956	/*
957	* The above returns on success the # of functions enabled,
958	* but if it didn't find any functions it returns zero.
959	* Consider no functions a failure too.
960	*/
961	if (!ret) {
962	cmd_ops->unreg(glob, trigger_data, file);
963	ret = -ENOENT;
964	} else if (ret > 0) {
965	if (n_registered)
966	*n_registered = ret;
967	/* Just return zero, not the number of enabled functions */
968	ret = 0;
969	}
970		938
971	return ret;	939	/**
		940	* event_trigger_unregister - unregister an event trigger
		941	* @cmd_ops: The event_command operations for the trigger
		942	* @file: The event file for the trigger's event
		943	* @glob: The trigger command string, with optional remove(!) operator
		944	* @trigger_data: The trigger_data for the trigger
		945	*
		946	* Unregister an event trigger. The @cmd_ops are used to call the
		947	* cmd_ops->unreg() function which actually does the unregistration.
		948	*/
		949	void event_trigger_unregister(struct event_command *cmd_ops,
		950	struct trace_event_file *file,
		951	char *glob,
		952	struct event_trigger_data *trigger_data)
		953	{
		954	cmd_ops->unreg(glob, trigger_data, file);
972	}	955	}
973		956
974	/*	957	/*
@@ -981,7 +964,7 @@ int event_trigger_register(struct event_command *cmd_ops, · 6 unmodified lines
981	* @file: The trace_event_file associated with the event	964	* @file: The trace_event_file associated with the event
982	* @glob: The raw string used to register the trigger	965	* @glob: The raw string used to register the trigger
983	* @cmd: The cmd portion of the string used to register the trigger	966	* @cmd: The cmd portion of the string used to register the trigger
984	* @param: The params portion of the string used to register the trigger	967	* @param_and_filter: The param and filter portion of the string used to register the trigger
985	*	968	*
986	* Common implementation for event command parsing and trigger	969	* Common implementation for event command parsing and trigger
987	* instantiation.	970	* instantiation.
@@ -994,94 +977,53 @@ int event_trigger_register(struct event_command *cmd_ops, · 6 unmodified lines
994	static int	977	static int
995	event_trigger_parse(struct event_command *cmd_ops,	978	event_trigger_parse(struct event_command *cmd_ops,
996	struct trace_event_file *file,	979	struct trace_event_file *file,
997	char glob, char cmd, char *param)	980	char glob, char cmd, char *param_and_filter)
998	{	981	{
999	struct event_trigger_data *trigger_data;	982	struct event_trigger_data *trigger_data;
1000	struct event_trigger_ops *trigger_ops;	983	char param, filter;
1001	char *trigger = NULL;	984	bool remove;
1002	char *number;
1003	int ret;	985	int ret;
1004		986
1005	/* separate the trigger from the filter (t:n [if filter]) */	987	remove = event_trigger_check_remove(glob);
1006	if (param && isdigit(param[0])) {
1007	trigger = strsep(&param, " \t");
1008	if (param) {
1009	param = skip_spaces(param);
1010	if (!*param)
1011	param = NULL;
1012	}
1013	}
1014		988
1015	trigger_ops = cmd_ops->get_trigger_ops(cmd, trigger);	989	ret = event_trigger_separate_filter(param_and_filter, &param, &filter, false);
		990	if (ret)
		991	return ret;
1016		992
1017	ret = -ENOMEM;	993	ret = -ENOMEM;
1018	trigger_data = kzalloc(sizeof(*trigger_data), GFP_KERNEL);	994	trigger_data = event_trigger_alloc(cmd_ops, cmd, param, file);
1019	if (!trigger_data)	995	if (!trigger_data)
1020	goto out;	996	goto out;
1021		997
1022	trigger_data->count = -1;	998	if (remove) {
1023	trigger_data->ops = trigger_ops;	999	event_trigger_unregister(cmd_ops, file, glob+1, trigger_data);
1024	trigger_data->cmd_ops = cmd_ops;
1025	trigger_data->private_data = file;
1026	INIT_LIST_HEAD(&trigger_data->list);
1027	INIT_LIST_HEAD(&trigger_data->named_list);
1028
1029	if (glob[0] == '!') {
1030	cmd_ops->unreg(glob+1, trigger_data, file);
1031	kfree(trigger_data);	1000	kfree(trigger_data);
1032	ret = 0;	1001	ret = 0;
1033	goto out;	1002	goto out;
1034	}	1003	}
1035		1004
1036	if (trigger) {	1005	ret = event_trigger_parse_num(param, trigger_data);
1037	number = strsep(&trigger, ":");	1006	if (ret)
1038		1007	goto out_free;
1039	ret = -EINVAL;
1040	if (!strlen(number))
1041	goto out_free;
1042
1043	/*
1044	* We use the callback data field (which is a pointer)
1045	* as our counter.
1046	*/
1047	ret = kstrtoul(number, 0, &trigger_data->count);
1048	if (ret)
1049	goto out_free;
1050	}
1051
1052	if (!param) /* if param is non-empty, it's supposed to be a filter */
1053	goto out_reg;
1054
1055	if (!cmd_ops->set_filter)
1056	goto out_reg;
1057		1008
1058	ret = cmd_ops->set_filter(param, trigger_data, file);	1009	ret = event_trigger_set_filter(cmd_ops, file, filter, trigger_data);
1059	if (ret < 0)	1010	if (ret < 0)
1060	goto out_free;	1011	goto out_free;
1061		1012
1062	out_reg:
1063	/* Up the trigger_data count to make sure reg doesn't free it on failure */	1013	/* Up the trigger_data count to make sure reg doesn't free it on failure */
1064	event_trigger_init(trigger_ops, trigger_data);	1014	event_trigger_init(trigger_data);
1065	ret = cmd_ops->reg(glob, trigger_data, file);	1015
1066	/*	1016	ret = event_trigger_register(cmd_ops, file, glob, trigger_data);
1067	* The above returns on success the # of functions enabled,	1017	if (ret)
1068	* but if it didn't find any functions it returns zero.	1018	goto out_free;
1069	* Consider no functions a failure too.
1070	*/
1071	if (!ret) {
1072	cmd_ops->unreg(glob, trigger_data, file);
1073	ret = -ENOENT;
1074	} else if (ret > 0)
1075	ret = 0;
1076		1019
1077	/* Down the counter of trigger_data or free it if not used anymore */	1020	/* Down the counter of trigger_data or free it if not used anymore */
1078	event_trigger_free(trigger_ops, trigger_data);	1021	event_trigger_free(trigger_data);
1079	out:	1022	out:
1080	return ret;	1023	return ret;
1081		1024
1082	out_free:	1025	out_free:
1083	if (cmd_ops->set_filter)	1026	event_trigger_reset_filter(cmd_ops, trigger_data);
1084	cmd_ops->set_filter(NULL, trigger_data, NULL);
1085	kfree(trigger_data);	1027	kfree(trigger_data);
1086	goto out;	1028	goto out;
1087	}	1029	}
@@ -1401,16 +1343,14 @@ traceoff_count_trigger(struct event_trigger_data *data, · 313 unmodified lines
1401	}	1343	}
1402		1344
1403	static int	1345	static int
1404	traceon_trigger_print(struct seq_file m, struct event_trigger_ops ops,	1346	traceon_trigger_print(struct seq_file m, struct event_trigger_data data)
1405	struct event_trigger_data *data)
1406	{	1347	{
1407	return event_trigger_print("traceon", m, (void *)data->count,	1348	return event_trigger_print("traceon", m, (void *)data->count,
1408	data->filter_str);	1349	data->filter_str);
1409	}	1350	}
1410		1351
1411	static int	1352	static int
1412	traceoff_trigger_print(struct seq_file m, struct event_trigger_ops ops,	1353	traceoff_trigger_print(struct seq_file m, struct event_trigger_data data)
1413	struct event_trigger_data *data)
1414	{	1354	{
1415	return event_trigger_print("traceoff", m, (void *)data->count,	1355	return event_trigger_print("traceoff", m, (void *)data->count,
1416	data->filter_str);	1356	data->filter_str);
@@ -1521,8 +1461,7 @@ register_snapshot_trigger(char *glob, · 104 unmodified lines
1521	}	1461	}
1522		1462
1523	static int	1463	static int
1524	snapshot_trigger_print(struct seq_file m, struct event_trigger_ops ops,	1464	snapshot_trigger_print(struct seq_file m, struct event_trigger_data data)
1525	struct event_trigger_data *data)
1526	{	1465	{
1527	return event_trigger_print("snapshot", m, (void *)data->count,	1466	return event_trigger_print("snapshot", m, (void *)data->count,
1528	data->filter_str);	1467	data->filter_str);
@@ -1617,8 +1556,7 @@ stacktrace_count_trigger(struct event_trigger_data *data, · 88 unmodified lines
1617	}	1556	}
1618		1557
1619	static int	1558	static int
1620	stacktrace_trigger_print(struct seq_file m, struct event_trigger_ops ops,	1559	stacktrace_trigger_print(struct seq_file m, struct event_trigger_data data)
1621	struct event_trigger_data *data)
1622	{	1560	{
1623	return event_trigger_print("stacktrace", m, (void *)data->count,	1561	return event_trigger_print("stacktrace", m, (void *)data->count,
1624	data->filter_str);	1562	data->filter_str);
@@ -1708,7 +1646,6 @@ event_enable_count_trigger(struct event_trigger_data *data, · 83 unmodified lines
1708	}	1646	}
1709		1647
1710	int event_enable_trigger_print(struct seq_file *m,	1648	int event_enable_trigger_print(struct seq_file *m,
1711	struct event_trigger_ops *ops,
1712	struct event_trigger_data *data)	1649	struct event_trigger_data *data)
1713	{	1650	{
1714	struct enable_trigger_data *enable_data = data->private_data;	1651	struct enable_trigger_data *enable_data = data->private_data;
@@ -1733,8 +1670,7 @@ int event_enable_trigger_print(struct seq_file *m, · 18 unmodified lines
1733	return 0;	1670	return 0;
1734	}	1671	}
1735		1672
1736	void event_enable_trigger_free(struct event_trigger_ops *ops,	1673	void event_enable_trigger_free(struct event_trigger_data *data)
1737	struct event_trigger_data *data)
1738	{	1674	{
1739	struct enable_trigger_data *enable_data = data->private_data;	1675	struct enable_trigger_data *enable_data = data->private_data;
1740		1676
@@ -1781,39 +1717,33 @@ static struct event_trigger_ops event_disable_count_trigger_ops = { · 40 unmodified lines
1781		1717
1782	int event_enable_trigger_parse(struct event_command *cmd_ops,	1718	int event_enable_trigger_parse(struct event_command *cmd_ops,
1783	struct trace_event_file *file,	1719	struct trace_event_file *file,
1784	char glob, char cmd, char *param)	1720	char glob, char cmd, char *param_and_filter)
1785	{	1721	{
1786	struct trace_event_file *event_enable_file;	1722	struct trace_event_file *event_enable_file;
1787	struct enable_trigger_data *enable_data;	1723	struct enable_trigger_data *enable_data;
1788	struct event_trigger_data *trigger_data;	1724	struct event_trigger_data *trigger_data;
1789	struct event_trigger_ops *trigger_ops;
1790	struct trace_array *tr = file->tr;	1725	struct trace_array *tr = file->tr;
		1726	char param, filter;
		1727	bool enable, remove;
1791	const char *system;	1728	const char *system;
1792	const char *event;	1729	const char *event;
1793	bool hist = false;	1730	bool hist = false;
1794	char *trigger;
1795	char *number;
1796	bool enable;
1797	int ret;	1731	int ret;
1798		1732
1799	if (!param)	1733	remove = event_trigger_check_remove(glob);
1800	return -EINVAL;
1801		1734
1802	/* separate the trigger from the filter (s:e:n [if filter]) */	1735	if (event_trigger_empty_param(param_and_filter))
1803	trigger = strsep(&param, " \t");
1804	if (!trigger)
1805	return -EINVAL;	1736	return -EINVAL;
1806	if (param) {
1807	param = skip_spaces(param);
1808	if (!*param)
1809	param = NULL;
1810	}
1811		1737
1812	system = strsep(&trigger, ":");	1738	ret = event_trigger_separate_filter(param_and_filter, &param, &filter, true);
1813	if (!trigger)	1739	if (ret)
		1740	return ret;
		1741
		1742	system = strsep(&param, ":");
		1743	if (!param)
1814	return -EINVAL;	1744	return -EINVAL;
1815		1745
1816	event = strsep(&trigger, ":");	1746	event = strsep(&param, ":");
1817		1747
1818	ret = -EINVAL;	1748	ret = -EINVAL;
1819	event_enable_file = find_event_file(tr, system, event);	1749	event_enable_file = find_event_file(tr, system, event);
@@ -1829,32 +1759,24 @@ int event_enable_trigger_parse(struct event_command *cmd_ops, · 9 unmodified lines
1829	#else	1759	#else
1830	enable = strcmp(cmd, ENABLE_EVENT_STR) == 0;	1760	enable = strcmp(cmd, ENABLE_EVENT_STR) == 0;
1831	#endif	1761	#endif
1832	trigger_ops = cmd_ops->get_trigger_ops(cmd, trigger);
1833
1834	ret = -ENOMEM;	1762	ret = -ENOMEM;
1835	trigger_data = kzalloc(sizeof(*trigger_data), GFP_KERNEL);
1836	if (!trigger_data)
1837	goto out;
1838		1763
1839	enable_data = kzalloc(sizeof(*enable_data), GFP_KERNEL);	1764	enable_data = kzalloc(sizeof(*enable_data), GFP_KERNEL);
1840	if (!enable_data) {	1765	if (!enable_data)
1841	kfree(trigger_data);
1842	goto out;	1766	goto out;
1843	}
1844
1845	trigger_data->count = -1;
1846	trigger_data->ops = trigger_ops;
1847	trigger_data->cmd_ops = cmd_ops;
1848	INIT_LIST_HEAD(&trigger_data->list);
1849	RCU_INIT_POINTER(trigger_data->filter, NULL);
1850		1767
1851	enable_data->hist = hist;	1768	enable_data->hist = hist;
1852	enable_data->enable = enable;	1769	enable_data->enable = enable;
1853	enable_data->file = event_enable_file;	1770	enable_data->file = event_enable_file;
1854	trigger_data->private_data = enable_data;
1855		1771
1856	if (glob[0] == '!') {	1772	trigger_data = event_trigger_alloc(cmd_ops, cmd, param, enable_data);
1857	cmd_ops->unreg(glob+1, trigger_data, file);	1773	if (!trigger_data) {
		1774	kfree(enable_data);
		1775	goto out;
		1776	}
		1777
		1778	if (remove) {
		1779	event_trigger_unregister(cmd_ops, file, glob+1, trigger_data);
1858	kfree(trigger_data);	1780	kfree(trigger_data);
1859	kfree(enable_data);	1781	kfree(enable_data);
1860	ret = 0;	1782	ret = 0;
@@ -1862,35 +1784,16 @@ int event_enable_trigger_parse(struct event_command *cmd_ops, · 1 unmodified line
1862	}	1784	}
1863		1785
1864	/* Up the trigger_data count to make sure nothing frees it on failure */	1786	/* Up the trigger_data count to make sure nothing frees it on failure */
1865	event_trigger_init(trigger_ops, trigger_data);	1787	event_trigger_init(trigger_data);
1866
1867	if (trigger) {
1868	number = strsep(&trigger, ":");
1869
1870	ret = -EINVAL;
1871	if (!strlen(number))
1872	goto out_free;
1873
1874	/*
1875	* We use the callback data field (which is a pointer)
1876	* as our counter.
1877	*/
1878	ret = kstrtoul(number, 0, &trigger_data->count);
1879	if (ret)
1880	goto out_free;
1881	}
1882		1788
1883	if (!param) /* if param is non-empty, it's supposed to be a filter */	1789	ret = event_trigger_parse_num(param, trigger_data);
1884	goto out_reg;	1790	if (ret)
1885		1791	goto out_free;
1886	if (!cmd_ops->set_filter)
1887	goto out_reg;
1888		1792
1889	ret = cmd_ops->set_filter(param, trigger_data, file);	1793	ret = event_trigger_set_filter(cmd_ops, file, filter, trigger_data);
1890	if (ret < 0)	1794	if (ret < 0)
1891	goto out_free;	1795	goto out_free;
1892		1796
1893	out_reg:
1894	/* Don't let event modules unload while probe registered */	1797	/* Don't let event modules unload while probe registered */
1895	ret = trace_event_try_get_ref(event_enable_file->event_call);	1798	ret = trace_event_try_get_ref(event_enable_file->event_call);
1896	if (!ret) {	1799	if (!ret) {
@@ -1901,32 +1804,23 @@ int event_enable_trigger_parse(struct event_command *cmd_ops, · 4 unmodified lines
1901	ret = trace_event_enable_disable(event_enable_file, 1, 1);	1804	ret = trace_event_enable_disable(event_enable_file, 1, 1);
1902	if (ret < 0)	1805	if (ret < 0)
1903	goto out_put;	1806	goto out_put;
1904	ret = cmd_ops->reg(glob, trigger_data, file);	1807
1905	/*	1808	ret = event_trigger_register(cmd_ops, file, glob, trigger_data);
1906	* The above returns on success the # of functions enabled,	1809	if (ret)
1907	* but if it didn't find any functions it returns zero.
1908	* Consider no functions a failure too.
1909	*/
1910	if (!ret) {
1911	ret = -ENOENT;
1912	goto out_disable;
1913	} else if (ret < 0)
1914	goto out_disable;	1810	goto out_disable;
1915	/* Just return zero, not the number of enabled functions */	1811
1916	ret = 0;	1812	event_trigger_free(trigger_data);
1917	event_trigger_free(trigger_ops, trigger_data);
1918	out:	1813	out:
1919	return ret;	1814	return ret;
1920
1921	out_disable:	1815	out_disable:
1922	trace_event_enable_disable(event_enable_file, 0, 1);	1816	trace_event_enable_disable(event_enable_file, 0, 1);
1923	out_put:	1817	out_put:
1924	trace_event_put_ref(event_enable_file->event_call);	1818	trace_event_put_ref(event_enable_file->event_call);
1925	out_free:	1819	out_free:
1926	if (cmd_ops->set_filter)	1820	event_trigger_reset_filter(cmd_ops, trigger_data);
1927	cmd_ops->set_filter(NULL, trigger_data, NULL);	1821	event_trigger_free(trigger_data);
1928	event_trigger_free(trigger_ops, trigger_data);
1929	kfree(enable_data);	1822	kfree(enable_data);
		1823
1930	goto out;	1824	goto out;
1931	}	1825	}
1932		1826
@@ -1953,19 +1847,18 @@ int event_enable_register_trigger(char *glob, · 20 unmodified lines
1953	}	1847	}
1954		1848
1955	if (data->ops->init) {	1849	if (data->ops->init) {
1956	ret = data->ops->init(data->ops, data);	1850	ret = data->ops->init(data);
1957	if (ret < 0)	1851	if (ret < 0)
1958	goto out;	1852	goto out;
1959	}	1853	}
1960		1854
1961	list_add_rcu(&data->list, &file->triggers);	1855	list_add_rcu(&data->list, &file->triggers);
1962	ret++;
1963		1856
1964	update_cond_flag(file);	1857	update_cond_flag(file);
1965	if (trace_event_trigger_enable_disable(file, 1) < 0) {	1858	ret = trace_event_trigger_enable_disable(file, 1);
		1859	if (ret < 0) {
1966	list_del_rcu(&data->list);	1860	list_del_rcu(&data->list);
1967	update_cond_flag(file);	1861	update_cond_flag(file);
1968	ret--;
1969	}	1862	}
1970	out:	1863	out:
1971	return ret;	1864	return ret;
@@ -1976,19 +1869,18 @@ void event_enable_unregister_trigger(char *glob, · 4 unmodified lines
1976	struct trace_event_file *file)	1869	struct trace_event_file *file)
1977	{	1870	{
1978	struct enable_trigger_data *test_enable_data = test->private_data;	1871	struct enable_trigger_data *test_enable_data = test->private_data;
		1872	struct event_trigger_data data = NULL, iter;
1979	struct enable_trigger_data *enable_data;	1873	struct enable_trigger_data *enable_data;
1980	struct event_trigger_data *data;
1981	bool unregistered = false;
1982		1874
1983	lockdep_assert_held(&event_mutex);	1875	lockdep_assert_held(&event_mutex);
1984		1876
1985	list_for_each_entry(data, &file->triggers, list) {	1877	list_for_each_entry(iter, &file->triggers, list) {
1986	enable_data = data->private_data;	1878	enable_data = iter->private_data;
1987	if (enable_data &&	1879	if (enable_data &&
1988	(data->cmd_ops->trigger_type ==	1880	(iter->cmd_ops->trigger_type ==
1989	test->cmd_ops->trigger_type) &&	1881	test->cmd_ops->trigger_type) &&
1990	(enable_data->file == test_enable_data->file)) {	1882	(enable_data->file == test_enable_data->file)) {
1991	unregistered = true;	1883	data = iter;
1992	list_del_rcu(&data->list);	1884	list_del_rcu(&data->list);
1993	trace_event_trigger_enable_disable(file, 0);	1885	trace_event_trigger_enable_disable(file, 0);
1994	update_cond_flag(file);	1886	update_cond_flag(file);
@@ -1996,8 +1888,8 @@ void event_enable_unregister_trigger(char *glob, · 1 unmodified line
1996	}	1888	}
1997	}	1889	}
1998		1890
1999	if (unregistered && data->ops->free)	1891	if (data && data->ops->free)
2000	data->ops->free(data->ops, data);	1892	data->ops->free(data);
2001	}	1893	}
2002		1894
2003	static struct event_trigger_ops *	1895	static struct event_trigger_ops *

kernel/trace/trace_kprobe.c+4−11

 static __init int init_kprobe_trace(void)
 {
 	int ret;
-	struct dentry *entry;
 	ret = tracing_init_dentry();
 	if (ret)
 		return 0;
-	entry = tracefs_create_file("kprobe_events", TRACE_MODE_WRITE,
-				    NULL, NULL, &kprobe_events_ops);
 	/* Event list interface */
-	if (!entry)
+	trace_create_file("kprobe_events", TRACE_MODE_WRITE,
-		pr_warn("Could not create tracefs 'kprobe_events' entry\n");
+			  NULL, NULL, &kprobe_events_ops);
 	/* Profile interface */
-	entry = tracefs_create_file("kprobe_profile", TRACE_MODE_READ,
+	trace_create_file("kprobe_profile", TRACE_MODE_READ,
-				    NULL, NULL, &kprobe_profile_ops);
+			  NULL, NULL, &kprobe_profile_ops);
-	if (!entry)
-		pr_warn("Could not create tracefs 'kprobe_profile' entry\n");
 	setup_boot_kprobe_events();

kernel/trace/trace_osnoise.c+19−3

@@ -1578,11 +1578,27 @@ static enum hrtimer_restart timerlat_irq(struct hrtimer *timer) · 1577 unmodified lines
1578		1578
1579	trace_timerlat_sample(&s);	1579	trace_timerlat_sample(&s);
1580		1580
1581	notify_new_max_latency(diff);	1581	if (osnoise_data.stop_tracing) {
		1582	if (time_to_us(diff) >= osnoise_data.stop_tracing) {
		1583
		1584	/*
		1585	* At this point, if stop_tracing is set and <= print_stack,
		1586	* print_stack is set and would be printed in the thread handler.
		1587	*
		1588	* Thus, print the stack trace as it is helpful to define the
		1589	* root cause of an IRQ latency.
		1590	*/
		1591	if (osnoise_data.stop_tracing <= osnoise_data.print_stack) {
		1592	timerlat_save_stack(0);
		1593	timerlat_dump_stack(time_to_us(diff));
		1594	}
1582		1595
1583	if (osnoise_data.stop_tracing)
1584	if (time_to_us(diff) >= osnoise_data.stop_tracing)
1585	osnoise_stop_tracing();	1596	osnoise_stop_tracing();
		1597	notify_new_max_latency(diff);
		1598
		1599	return HRTIMER_NORESTART;
		1600	}
		1601	}
1586		1602
1587	wake_up_process(tlat->kthread);	1603	wake_up_process(tlat->kthread);
1588		1604

kernel/trace/trace_output.c+12−13

 static int trace_search_list(struct list_head **list)
 {
-	struct trace_event *e;
+	struct trace_event *e = NULL, *iter;
 	int next = __TRACE_LAST_TYPE;
 	if (list_empty(&ftrace_event_list)) {
 	 * We used up all possible max events,
 	 * lets see if somebody freed one.
 	 */
-	list_for_each_entry(e, &ftrace_event_list, list) {
+	list_for_each_entry(iter, &ftrace_event_list, list) {
-		if (e->type != next)
+		if (iter->type != next) {
+			e = iter;
 			break;
+		}
 		next++;
 	}
 	if (next > TRACE_EVENT_TYPE_MAX)
 		return 0;
-	*list = &e->list;
+	if (e)
+		*list = &e->list;
+	else
+		*list = &ftrace_event_list;
 	return next;
 }
 		list_add_tail(&event->list, list);
-	} else if (event->type > __TRACE_LAST_TYPE) {
+	} else if (WARN(event->type > __TRACE_LAST_TYPE,
-		printk(KERN_WARNING "Need to add type to trace.h\n");
+			"Need to add type to trace.h")) {
-		WARN_ON(1);
 		goto out;
 	} else {
 		/* Is this event already used */
 	for (i = 0; events[i]; i++) {
 		event = events[i];
 		ret = register_trace_event(event);
-		if (!ret) {
+		WARN_ONCE(!ret, "event %d failed to register", event->type);
-			printk(KERN_WARNING "event %d failed to register\n",
-			       event->type);
-			WARN_ON_ONCE(1);
-		}
 	}
 	return 0;

kernel/trace/trace_recursion_record.c+2−5

 __init static int create_recursed_functions(void)
 {
-	struct dentry *dentry;
-	dentry = trace_create_file("recursed_functions", TRACE_MODE_WRITE,
+	trace_create_file("recursed_functions", TRACE_MODE_WRITE,
-				   NULL, NULL, &recursed_functions_fops);
+			  NULL, NULL, &recursed_functions_fops);
-	if (!dentry)
-		pr_warn("WARNING: Failed to create recursed_functions\n");
 	return 0;
 }

kernel/trace/trace_selftest.c+3−0

@@ -895,6 +895,9 @@ trace_selftest_startup_function_graph(struct tracer *trace, · 894 unmodified lines
895	ret = -1;	895	ret = -1;
896	goto out;	896	goto out;
897	}	897	}
		898
		899	/* Enable tracing on all functions again */
		900	ftrace_set_global_filter(NULL, 0, 1);
898	#endif	901	#endif
899		902
900	/* Don't test dynamic tracing, the function tracer already did */	903	/* Don't test dynamic tracing, the function tracer already did */

kernel/trace/trace_syscalls.c+11−24

@@ -154,7 +154,7 @@ print_syscall_enter(struct trace_iterator *iter, int flags, · 153 unmodified lines
154	goto end;	154	goto end;
155		155
156	/* parameter types */	156	/* parameter types */
157	if (tr->trace_flags & TRACE_ITER_VERBOSE)	157	if (tr && tr->trace_flags & TRACE_ITER_VERBOSE)
158	trace_seq_printf(s, "%s ", entry->types[i]);	158	trace_seq_printf(s, "%s ", entry->types[i]);
159		159
160	/* parameter values */	160	/* parameter values */
@@ -296,9 +296,7 @@ static void ftrace_syscall_enter(void data, struct pt_regs regs, long id) · 135 unmodified lines
296	struct trace_event_file *trace_file;	296	struct trace_event_file *trace_file;
297	struct syscall_trace_enter *entry;	297	struct syscall_trace_enter *entry;
298	struct syscall_metadata *sys_data;	298	struct syscall_metadata *sys_data;
299	struct ring_buffer_event *event;	299	struct trace_event_buffer fbuffer;
300	struct trace_buffer *buffer;
301	unsigned int trace_ctx;
302	unsigned long args[6];	300	unsigned long args[6];
303	int syscall_nr;	301	int syscall_nr;
304	int size;	302	int size;
@@ -321,20 +319,16 @@ static void ftrace_syscall_enter(void data, struct pt_regs regs, long id) · 16 unmodified lines
321		319
322	size = sizeof(entry) + sizeof(unsigned long) sys_data->nb_args;	320	size = sizeof(entry) + sizeof(unsigned long) sys_data->nb_args;
323		321
324	trace_ctx = tracing_gen_ctx();	322	entry = trace_event_buffer_reserve(&fbuffer, trace_file, size);
325		323	if (!entry)
326	event = trace_event_buffer_lock_reserve(&buffer, trace_file,
327	sys_data->enter_event->event.type, size, trace_ctx);
328	if (!event)
329	return;	324	return;
330		325
331	entry = ring_buffer_event_data(event);	326	entry = ring_buffer_event_data(fbuffer.event);
332	entry->nr = syscall_nr;	327	entry->nr = syscall_nr;
333	syscall_get_arguments(current, regs, args);	328	syscall_get_arguments(current, regs, args);
334	memcpy(entry->args, args, sizeof(unsigned long) * sys_data->nb_args);	329	memcpy(entry->args, args, sizeof(unsigned long) * sys_data->nb_args);
335		330
336	event_trigger_unlock_commit(trace_file, buffer, event, entry,	331	trace_event_buffer_commit(&fbuffer);
337	trace_ctx);
338	}	332	}
339		333
340	static void ftrace_syscall_exit(void data, struct pt_regs regs, long ret)	334	static void ftrace_syscall_exit(void data, struct pt_regs regs, long ret)
@@ -343,9 +337,7 @@ static void ftrace_syscall_exit(void data, struct pt_regs regs, long ret) · 2 unmodified lines
343	struct trace_event_file *trace_file;	337	struct trace_event_file *trace_file;
344	struct syscall_trace_exit *entry;	338	struct syscall_trace_exit *entry;
345	struct syscall_metadata *sys_data;	339	struct syscall_metadata *sys_data;
346	struct ring_buffer_event *event;	340	struct trace_event_buffer fbuffer;
347	struct trace_buffer *buffer;
348	unsigned int trace_ctx;
349	int syscall_nr;	341	int syscall_nr;
350		342
351	syscall_nr = trace_get_syscall_nr(current, regs);	343	syscall_nr = trace_get_syscall_nr(current, regs);
@@ -364,20 +356,15 @@ static void ftrace_syscall_exit(void data, struct pt_regs regs, long ret) · 12 unmodified lines
364	if (!sys_data)	356	if (!sys_data)
365	return;	357	return;
366		358
367	trace_ctx = tracing_gen_ctx();	359	entry = trace_event_buffer_reserve(&fbuffer, trace_file, sizeof(*entry));
368		360	if (!entry)
369	event = trace_event_buffer_lock_reserve(&buffer, trace_file,
370	sys_data->exit_event->event.type, sizeof(*entry),
371	trace_ctx);
372	if (!event)
373	return;	361	return;
374		362
375	entry = ring_buffer_event_data(event);	363	entry = ring_buffer_event_data(fbuffer.event);
376	entry->nr = syscall_nr;	364	entry->nr = syscall_nr;
377	entry->ret = syscall_get_return_value(current, regs);	365	entry->ret = syscall_get_return_value(current, regs);
378		366
379	event_trigger_unlock_commit(trace_file, buffer, event, entry,	367	trace_event_buffer_commit(&fbuffer);
380	trace_ctx);
381	}	368	}
382		369
383	static int reg_event_syscall_enter(struct trace_event_file *file,	370	static int reg_event_syscall_enter(struct trace_event_file *file,

kernel/trace/tracing_map.c+2−1

 /**
  * tracing_map_sort_entries - Sort the current set of tracing_map_elts in a map
  * @map: The tracing_map
- * @sort_key: The sort key to use for sorting
+ * @sort_keys: The sort key to use for sorting
+ * @n_sort_keys: hitcount, always have at least one
  * @sort_entries: outval: pointer to allocated and sorted array of entries
  *
  * tracing_map_sort_entries() sorts the current set of entries in the

lib/.gitignore+1−0

@@ -1,6 +1,7 @@
1	# SPDX-License-Identifier: GPL-2.0-only	1	# SPDX-License-Identifier: GPL-2.0-only
2	/crc32table.h	2	/crc32table.h
3	/crc64table.h	3	/crc64table.h
		4	/default.bconf
4	/gen_crc32table	5	/gen_crc32table
5	/gen_crc64table	6	/gen_crc64table
6	/oid_registry_data.c	7	/oid_registry_data.c

lib/Makefile+9−1

@@ -281,7 +281,15 @@ $(foreach file, $(libfdt_files), \ · 280 unmodified lines
281	$(eval CFLAGS_$(file) = -I $(srctree)/scripts/dtc/libfdt))	281	$(eval CFLAGS_$(file) = -I $(srctree)/scripts/dtc/libfdt))
282	lib-$(CONFIG_LIBFDT) += $(libfdt_files)	282	lib-$(CONFIG_LIBFDT) += $(libfdt_files)
283		283
284	lib-$(CONFIG_BOOT_CONFIG) += bootconfig.o	284	obj-$(CONFIG_BOOT_CONFIG) += bootconfig.o
		285	obj-$(CONFIG_BOOT_CONFIG_EMBED) += bootconfig-data.o
		286
		287	$(obj)/bootconfig-data.o: $(obj)/default.bconf
		288
		289	targets += default.bconf
		290	filechk_defbconf = cat $(or $(real-prereqs), /dev/null)
		291	$(obj)/default.bconf: $(CONFIG_BOOT_CONFIG_EMBED_FILE) FORCE
		292	$(call filechk,defbconf)
285		293
286	obj-$(CONFIG_RBTREE_TEST) += rbtree_test.o	294	obj-$(CONFIG_RBTREE_TEST) += rbtree_test.o
287	obj-$(CONFIG_INTERVAL_TREE_TEST) += interval_tree_test.o	295	obj-$(CONFIG_INTERVAL_TREE_TEST) += interval_tree_test.o

lib/bootconfig-data.S+10−0

@@ -0,0 +1,10 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	/*
	3	* Embed default bootconfig in the kernel.
	4	*/
	5	.section .init.rodata, "aw"
	6	.global embedded_bootconfig_data
	7	embedded_bootconfig_data:
	8	.incbin "lib/default.bconf"
	9	.global embedded_bootconfig_data_end
	10	embedded_bootconfig_data_end:

lib/bootconfig.c+13−0

@@ -12,6 +12,19 @@ · 11 unmodified lines
12	#include <linux/kernel.h>	12	#include <linux/kernel.h>
13	#include <linux/memblock.h>	13	#include <linux/memblock.h>
14	#include <linux/string.h>	14	#include <linux/string.h>
		15
		16	#ifdef CONFIG_BOOT_CONFIG_EMBED
		17	/* embedded_bootconfig_data is defined in bootconfig-data.S */
		18	extern __visible const char embedded_bootconfig_data[];
		19	extern __visible const char embedded_bootconfig_data_end[];
		20
		21	const char * __init xbc_get_embedded_bootconfig(size_t *size)
		22	{
		23	*size = embedded_bootconfig_data_end - embedded_bootconfig_data;
		24	return (*size) ? embedded_bootconfig_data : NULL;
		25	}
		26	#endif
		27
15	#else /* !__KERNEL__ */	28	#else /* !__KERNEL__ */
16	/*	29	/*
17	* NOTE: This is only for tools/bootconfig, because tools/bootconfig will	30	* NOTE: This is only for tools/bootconfig, because tools/bootconfig will