lael-labs/linux

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