blob: 1a2117043bb140d06b366d8d6e0798bb69fcad26 [file] [log] [blame]
Masami Hiramatsu413d37d2009-08-13 16:35:11 -04001/*
Masami Hiramatsu77b44d12009-11-03 19:12:47 -05002 * Kprobes-based tracing events
Masami Hiramatsu413d37d2009-08-13 16:35:11 -04003 *
4 * Created by Masami Hiramatsu <mhiramat@redhat.com>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 */
19
20#include <linux/module.h>
21#include <linux/uaccess.h>
Masami Hiramatsu413d37d2009-08-13 16:35:11 -040022
Srikar Dronamraju8ab83f52012-04-09 14:41:44 +053023#include "trace_probe.h"
Masami Hiramatsu413d37d2009-08-13 16:35:11 -040024
Masami Hiramatsuf52487e2009-09-10 19:53:53 -040025#define KPROBE_EVENT_SYSTEM "kprobes"
Masami Hiramatsu413d37d2009-08-13 16:35:11 -040026
Masami Hiramatsu413d37d2009-08-13 16:35:11 -040027/**
Masami Hiramatsu77b44d12009-11-03 19:12:47 -050028 * Kprobe event core functions
Masami Hiramatsu413d37d2009-08-13 16:35:11 -040029 */
30
31struct trace_probe {
32 struct list_head list;
Masami Hiramatsu4a846b42009-09-11 05:31:21 +020033 struct kretprobe rp; /* Use rp.kp for kprobe use */
Masami Hiramatsucd7e7bd2009-08-13 16:35:42 -040034 unsigned long nhit;
Masami Hiramatsu50d78052009-09-14 16:49:20 -040035 unsigned int flags; /* For TP_FLAG_* */
Masami Hiramatsu413d37d2009-08-13 16:35:11 -040036 const char *symbol; /* symbol name */
Steven Rostedt22392912010-04-21 12:27:06 -040037 struct ftrace_event_class class;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -040038 struct ftrace_event_call call;
Masami Hiramatsu93ccae72010-04-12 13:17:08 -040039 ssize_t size; /* trace entry size */
Masami Hiramatsua82378d2009-08-13 16:35:18 -040040 unsigned int nr_args;
Masami Hiramatsueca0d912009-09-10 19:53:38 -040041 struct probe_arg args[];
Masami Hiramatsu413d37d2009-08-13 16:35:11 -040042};
43
Masami Hiramatsua82378d2009-08-13 16:35:18 -040044#define SIZEOF_TRACE_PROBE(n) \
45 (offsetof(struct trace_probe, args) + \
Masami Hiramatsueca0d912009-09-10 19:53:38 -040046 (sizeof(struct probe_arg) * (n)))
Masami Hiramatsua82378d2009-08-13 16:35:18 -040047
Masami Hiramatsu93ccae72010-04-12 13:17:08 -040048
Masami Hiramatsu7143f162011-06-27 16:26:36 +090049static __kprobes int trace_probe_is_return(struct trace_probe *tp)
Masami Hiramatsu413d37d2009-08-13 16:35:11 -040050{
Masami Hiramatsu4a846b42009-09-11 05:31:21 +020051 return tp->rp.handler != NULL;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -040052}
53
Masami Hiramatsu7143f162011-06-27 16:26:36 +090054static __kprobes const char *trace_probe_symbol(struct trace_probe *tp)
Masami Hiramatsu413d37d2009-08-13 16:35:11 -040055{
56 return tp->symbol ? tp->symbol : "unknown";
57}
58
Masami Hiramatsu61424312011-06-27 16:26:56 +090059static __kprobes unsigned long trace_probe_offset(struct trace_probe *tp)
60{
61 return tp->rp.kp.offset;
62}
63
64static __kprobes bool trace_probe_is_enabled(struct trace_probe *tp)
65{
66 return !!(tp->flags & (TP_FLAG_TRACE | TP_FLAG_PROFILE));
67}
68
69static __kprobes bool trace_probe_is_registered(struct trace_probe *tp)
70{
71 return !!(tp->flags & TP_FLAG_REGISTERED);
72}
73
74static __kprobes bool trace_probe_has_gone(struct trace_probe *tp)
75{
76 return !!(kprobe_gone(&tp->rp.kp));
77}
78
79static __kprobes bool trace_probe_within_module(struct trace_probe *tp,
80 struct module *mod)
81{
82 int len = strlen(mod->name);
83 const char *name = trace_probe_symbol(tp);
84 return strncmp(mod->name, name, len) == 0 && name[len] == ':';
85}
86
87static __kprobes bool trace_probe_is_on_module(struct trace_probe *tp)
88{
89 return !!strchr(trace_probe_symbol(tp), ':');
90}
91
Masami Hiramatsu413d37d2009-08-13 16:35:11 -040092static int register_probe_event(struct trace_probe *tp);
93static void unregister_probe_event(struct trace_probe *tp);
94
95static DEFINE_MUTEX(probe_lock);
96static LIST_HEAD(probe_list);
97
Masami Hiramatsu50d78052009-09-14 16:49:20 -040098static int kprobe_dispatcher(struct kprobe *kp, struct pt_regs *regs);
99static int kretprobe_dispatcher(struct kretprobe_instance *ri,
100 struct pt_regs *regs);
101
Masami Hiramatsu4a846b42009-09-11 05:31:21 +0200102/*
103 * Allocate new trace_probe and initialize it (including kprobes).
104 */
Masami Hiramatsuf52487e2009-09-10 19:53:53 -0400105static struct trace_probe *alloc_trace_probe(const char *group,
106 const char *event,
Masami Hiramatsu4a846b42009-09-11 05:31:21 +0200107 void *addr,
108 const char *symbol,
109 unsigned long offs,
Srikar Dronamraju3a6b7662012-04-09 14:41:33 +0530110 int nargs, bool is_return)
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400111{
112 struct trace_probe *tp;
Masami Hiramatsu6f3cf442009-12-16 17:24:08 -0500113 int ret = -ENOMEM;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400114
Masami Hiramatsua82378d2009-08-13 16:35:18 -0400115 tp = kzalloc(SIZEOF_TRACE_PROBE(nargs), GFP_KERNEL);
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400116 if (!tp)
Masami Hiramatsu6f3cf442009-12-16 17:24:08 -0500117 return ERR_PTR(ret);
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400118
119 if (symbol) {
120 tp->symbol = kstrdup(symbol, GFP_KERNEL);
121 if (!tp->symbol)
122 goto error;
Masami Hiramatsu4a846b42009-09-11 05:31:21 +0200123 tp->rp.kp.symbol_name = tp->symbol;
124 tp->rp.kp.offset = offs;
125 } else
126 tp->rp.kp.addr = addr;
127
128 if (is_return)
Masami Hiramatsu50d78052009-09-14 16:49:20 -0400129 tp->rp.handler = kretprobe_dispatcher;
Masami Hiramatsu4a846b42009-09-11 05:31:21 +0200130 else
Masami Hiramatsu50d78052009-09-14 16:49:20 -0400131 tp->rp.kp.pre_handler = kprobe_dispatcher;
Masami Hiramatsu4a846b42009-09-11 05:31:21 +0200132
Masami Hiramatsuda346342010-08-27 20:39:12 +0900133 if (!event || !is_good_name(event)) {
Masami Hiramatsu6f3cf442009-12-16 17:24:08 -0500134 ret = -EINVAL;
Masami Hiramatsu42635652009-08-13 16:35:26 -0400135 goto error;
Masami Hiramatsu6f3cf442009-12-16 17:24:08 -0500136 }
137
Steven Rostedt22392912010-04-21 12:27:06 -0400138 tp->call.class = &tp->class;
Masami Hiramatsu42635652009-08-13 16:35:26 -0400139 tp->call.name = kstrdup(event, GFP_KERNEL);
140 if (!tp->call.name)
141 goto error;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400142
Masami Hiramatsuda346342010-08-27 20:39:12 +0900143 if (!group || !is_good_name(group)) {
Masami Hiramatsu6f3cf442009-12-16 17:24:08 -0500144 ret = -EINVAL;
Masami Hiramatsuf52487e2009-09-10 19:53:53 -0400145 goto error;
Masami Hiramatsu6f3cf442009-12-16 17:24:08 -0500146 }
147
Steven Rostedt22392912010-04-21 12:27:06 -0400148 tp->class.system = kstrdup(group, GFP_KERNEL);
149 if (!tp->class.system)
Masami Hiramatsuf52487e2009-09-10 19:53:53 -0400150 goto error;
151
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400152 INIT_LIST_HEAD(&tp->list);
153 return tp;
154error:
Masami Hiramatsuf52487e2009-09-10 19:53:53 -0400155 kfree(tp->call.name);
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400156 kfree(tp->symbol);
157 kfree(tp);
Masami Hiramatsu6f3cf442009-12-16 17:24:08 -0500158 return ERR_PTR(ret);
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400159}
160
161static void free_trace_probe(struct trace_probe *tp)
162{
163 int i;
164
165 for (i = 0; i < tp->nr_args; i++)
Srikar Dronamraju8ab83f52012-04-09 14:41:44 +0530166 traceprobe_free_probe_arg(&tp->args[i]);
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400167
Steven Rostedt8f082012010-04-20 10:47:33 -0400168 kfree(tp->call.class->system);
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400169 kfree(tp->call.name);
170 kfree(tp->symbol);
171 kfree(tp);
172}
173
Masami Hiramatsu7143f162011-06-27 16:26:36 +0900174static struct trace_probe *find_trace_probe(const char *event,
Masami Hiramatsudd004c42009-10-27 16:42:44 -0400175 const char *group)
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400176{
177 struct trace_probe *tp;
178
179 list_for_each_entry(tp, &probe_list, list)
Masami Hiramatsudd004c42009-10-27 16:42:44 -0400180 if (strcmp(tp->call.name, event) == 0 &&
Steven Rostedt8f082012010-04-20 10:47:33 -0400181 strcmp(tp->call.class->system, group) == 0)
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400182 return tp;
183 return NULL;
184}
185
Masami Hiramatsu1538f882011-06-27 16:26:44 +0900186/* Enable trace_probe - @flag must be TP_FLAG_TRACE or TP_FLAG_PROFILE */
187static int enable_trace_probe(struct trace_probe *tp, int flag)
188{
189 int ret = 0;
190
191 tp->flags |= flag;
Masami Hiramatsu61424312011-06-27 16:26:56 +0900192 if (trace_probe_is_enabled(tp) && trace_probe_is_registered(tp) &&
193 !trace_probe_has_gone(tp)) {
Masami Hiramatsu1538f882011-06-27 16:26:44 +0900194 if (trace_probe_is_return(tp))
195 ret = enable_kretprobe(&tp->rp);
196 else
197 ret = enable_kprobe(&tp->rp.kp);
198 }
199
200 return ret;
201}
202
203/* Disable trace_probe - @flag must be TP_FLAG_TRACE or TP_FLAG_PROFILE */
204static void disable_trace_probe(struct trace_probe *tp, int flag)
205{
206 tp->flags &= ~flag;
Masami Hiramatsu61424312011-06-27 16:26:56 +0900207 if (!trace_probe_is_enabled(tp) && trace_probe_is_registered(tp)) {
Masami Hiramatsu1538f882011-06-27 16:26:44 +0900208 if (trace_probe_is_return(tp))
209 disable_kretprobe(&tp->rp);
210 else
211 disable_kprobe(&tp->rp.kp);
212 }
213}
214
Masami Hiramatsu61424312011-06-27 16:26:56 +0900215/* Internal register function - just handle k*probes and flags */
216static int __register_trace_probe(struct trace_probe *tp)
217{
Masami Hiramatsu7f6878a2011-06-27 16:27:03 +0900218 int i, ret;
Masami Hiramatsu61424312011-06-27 16:26:56 +0900219
220 if (trace_probe_is_registered(tp))
221 return -EINVAL;
222
Masami Hiramatsu7f6878a2011-06-27 16:27:03 +0900223 for (i = 0; i < tp->nr_args; i++)
Srikar Dronamraju8ab83f52012-04-09 14:41:44 +0530224 traceprobe_update_arg(&tp->args[i]);
Masami Hiramatsu7f6878a2011-06-27 16:27:03 +0900225
Masami Hiramatsu61424312011-06-27 16:26:56 +0900226 /* Set/clear disabled flag according to tp->flag */
227 if (trace_probe_is_enabled(tp))
228 tp->rp.kp.flags &= ~KPROBE_FLAG_DISABLED;
229 else
230 tp->rp.kp.flags |= KPROBE_FLAG_DISABLED;
231
232 if (trace_probe_is_return(tp))
233 ret = register_kretprobe(&tp->rp);
234 else
235 ret = register_kprobe(&tp->rp.kp);
236
237 if (ret == 0)
238 tp->flags |= TP_FLAG_REGISTERED;
239 else {
240 pr_warning("Could not insert probe at %s+%lu: %d\n",
241 trace_probe_symbol(tp), trace_probe_offset(tp), ret);
242 if (ret == -ENOENT && trace_probe_is_on_module(tp)) {
243 pr_warning("This probe might be able to register after"
244 "target module is loaded. Continue.\n");
245 ret = 0;
246 } else if (ret == -EILSEQ) {
247 pr_warning("Probing address(0x%p) is not an "
248 "instruction boundary.\n",
249 tp->rp.kp.addr);
250 ret = -EINVAL;
251 }
252 }
253
254 return ret;
255}
256
257/* Internal unregister function - just handle k*probes and flags */
258static void __unregister_trace_probe(struct trace_probe *tp)
259{
260 if (trace_probe_is_registered(tp)) {
261 if (trace_probe_is_return(tp))
262 unregister_kretprobe(&tp->rp);
263 else
264 unregister_kprobe(&tp->rp.kp);
265 tp->flags &= ~TP_FLAG_REGISTERED;
266 /* Cleanup kprobe for reuse */
267 if (tp->rp.kp.symbol_name)
268 tp->rp.kp.addr = NULL;
269 }
270}
271
Masami Hiramatsu2d5e0672009-09-14 16:48:56 -0400272/* Unregister a trace_probe and probe_event: call with locking probe_lock */
Masami Hiramatsu02ca1522011-10-04 19:44:38 +0900273static int unregister_trace_probe(struct trace_probe *tp)
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400274{
Masami Hiramatsu02ca1522011-10-04 19:44:38 +0900275 /* Enabled event can not be unregistered */
276 if (trace_probe_is_enabled(tp))
277 return -EBUSY;
278
Masami Hiramatsu61424312011-06-27 16:26:56 +0900279 __unregister_trace_probe(tp);
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400280 list_del(&tp->list);
Masami Hiramatsu2d5e0672009-09-14 16:48:56 -0400281 unregister_probe_event(tp);
Masami Hiramatsu02ca1522011-10-04 19:44:38 +0900282
283 return 0;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400284}
285
286/* Register a trace_probe and probe_event */
287static int register_trace_probe(struct trace_probe *tp)
288{
289 struct trace_probe *old_tp;
290 int ret;
291
292 mutex_lock(&probe_lock);
293
Masami Hiramatsu61424312011-06-27 16:26:56 +0900294 /* Delete old (same name) event if exist */
Masami Hiramatsu7143f162011-06-27 16:26:36 +0900295 old_tp = find_trace_probe(tp->call.name, tp->call.class->system);
Masami Hiramatsu2d5e0672009-09-14 16:48:56 -0400296 if (old_tp) {
Masami Hiramatsu02ca1522011-10-04 19:44:38 +0900297 ret = unregister_trace_probe(old_tp);
298 if (ret < 0)
299 goto end;
Masami Hiramatsu2d5e0672009-09-14 16:48:56 -0400300 free_trace_probe(old_tp);
301 }
Masami Hiramatsu61424312011-06-27 16:26:56 +0900302
303 /* Register new event */
Masami Hiramatsu2d5e0672009-09-14 16:48:56 -0400304 ret = register_probe_event(tp);
305 if (ret) {
Paul Bolle426d3102010-08-07 12:30:03 +0200306 pr_warning("Failed to register probe event(%d)\n", ret);
Masami Hiramatsu2d5e0672009-09-14 16:48:56 -0400307 goto end;
308 }
309
Masami Hiramatsu61424312011-06-27 16:26:56 +0900310 /* Register k*probe */
311 ret = __register_trace_probe(tp);
312 if (ret < 0)
Masami Hiramatsu2d5e0672009-09-14 16:48:56 -0400313 unregister_probe_event(tp);
Masami Hiramatsu61424312011-06-27 16:26:56 +0900314 else
Masami Hiramatsu2d5e0672009-09-14 16:48:56 -0400315 list_add_tail(&tp->list, &probe_list);
Masami Hiramatsu61424312011-06-27 16:26:56 +0900316
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400317end:
318 mutex_unlock(&probe_lock);
319 return ret;
320}
321
Masami Hiramatsu61424312011-06-27 16:26:56 +0900322/* Module notifier call back, checking event on the module */
323static int trace_probe_module_callback(struct notifier_block *nb,
324 unsigned long val, void *data)
325{
326 struct module *mod = data;
327 struct trace_probe *tp;
328 int ret;
329
330 if (val != MODULE_STATE_COMING)
331 return NOTIFY_DONE;
332
333 /* Update probes on coming module */
334 mutex_lock(&probe_lock);
335 list_for_each_entry(tp, &probe_list, list) {
336 if (trace_probe_within_module(tp, mod)) {
Masami Hiramatsu02ca1522011-10-04 19:44:38 +0900337 /* Don't need to check busy - this should have gone. */
Masami Hiramatsu61424312011-06-27 16:26:56 +0900338 __unregister_trace_probe(tp);
339 ret = __register_trace_probe(tp);
340 if (ret)
341 pr_warning("Failed to re-register probe %s on"
342 "%s: %d\n",
343 tp->call.name, mod->name, ret);
344 }
345 }
346 mutex_unlock(&probe_lock);
347
348 return NOTIFY_DONE;
349}
350
351static struct notifier_block trace_probe_module_nb = {
352 .notifier_call = trace_probe_module_callback,
353 .priority = 1 /* Invoked after kprobe module callback */
354};
355
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400356static int create_trace_probe(int argc, char **argv)
357{
358 /*
359 * Argument syntax:
Masami Hiramatsu61424312011-06-27 16:26:56 +0900360 * - Add kprobe: p[:[GRP/]EVENT] [MOD:]KSYM[+OFFS]|KADDR [FETCHARGS]
361 * - Add kretprobe: r[:[GRP/]EVENT] [MOD:]KSYM[+0] [FETCHARGS]
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400362 * Fetch args:
Masami Hiramatsu2e06ff62009-10-07 18:27:59 -0400363 * $retval : fetch return value
364 * $stack : fetch stack address
365 * $stackN : fetch Nth of stack (N:0-)
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400366 * @ADDR : fetch memory at ADDR (ADDR should be in kernel)
367 * @SYM[+|-offs] : fetch memory at SYM +|- offs (SYM is a data symbol)
368 * %REG : fetch register REG
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400369 * Dereferencing memory fetch:
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400370 * +|-offs(ARG) : fetch memory at ARG +|- offs address.
Masami Hiramatsueca0d912009-09-10 19:53:38 -0400371 * Alias name of args:
372 * NAME=FETCHARG : set NAME as alias of FETCHARG.
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400373 * Type of args:
374 * FETCHARG:TYPE : use TYPE instead of unsigned long.
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400375 */
376 struct trace_probe *tp;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400377 int i, ret = 0;
Srikar Dronamraju3a6b7662012-04-09 14:41:33 +0530378 bool is_return = false, is_delete = false;
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400379 char *symbol = NULL, *event = NULL, *group = NULL;
Masami Hiramatsuda346342010-08-27 20:39:12 +0900380 char *arg;
Masami Hiramatsu2fba0c82009-09-10 19:53:14 -0400381 unsigned long offset = 0;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400382 void *addr = NULL;
Masami Hiramatsu4a846b42009-09-11 05:31:21 +0200383 char buf[MAX_EVENT_NAME_LEN];
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400384
Masami Hiramatsua7c312b2009-12-08 17:03:16 -0500385 /* argc must be >= 1 */
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400386 if (argv[0][0] == 'p')
Srikar Dronamraju3a6b7662012-04-09 14:41:33 +0530387 is_return = false;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400388 else if (argv[0][0] == 'r')
Srikar Dronamraju3a6b7662012-04-09 14:41:33 +0530389 is_return = true;
Masami Hiramatsua7c312b2009-12-08 17:03:16 -0500390 else if (argv[0][0] == '-')
Srikar Dronamraju3a6b7662012-04-09 14:41:33 +0530391 is_delete = true;
Masami Hiramatsue63cc232009-10-16 20:07:28 -0400392 else {
Masami Hiramatsua7c312b2009-12-08 17:03:16 -0500393 pr_info("Probe definition must be started with 'p', 'r' or"
394 " '-'.\n");
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400395 return -EINVAL;
Masami Hiramatsue63cc232009-10-16 20:07:28 -0400396 }
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400397
398 if (argv[0][1] == ':') {
399 event = &argv[0][2];
Masami Hiramatsuf52487e2009-09-10 19:53:53 -0400400 if (strchr(event, '/')) {
401 group = event;
402 event = strchr(group, '/') + 1;
403 event[-1] = '\0';
404 if (strlen(group) == 0) {
Wenji Huanga5efd922010-02-24 15:40:23 +0800405 pr_info("Group name is not specified\n");
Masami Hiramatsuf52487e2009-09-10 19:53:53 -0400406 return -EINVAL;
407 }
408 }
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400409 if (strlen(event) == 0) {
Wenji Huanga5efd922010-02-24 15:40:23 +0800410 pr_info("Event name is not specified\n");
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400411 return -EINVAL;
412 }
413 }
Masami Hiramatsua7c312b2009-12-08 17:03:16 -0500414 if (!group)
415 group = KPROBE_EVENT_SYSTEM;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400416
Masami Hiramatsua7c312b2009-12-08 17:03:16 -0500417 if (is_delete) {
418 if (!event) {
419 pr_info("Delete command needs an event name.\n");
420 return -EINVAL;
421 }
Srikar Dronamraju9da79ab2010-06-30 14:15:48 +0530422 mutex_lock(&probe_lock);
Masami Hiramatsu7143f162011-06-27 16:26:36 +0900423 tp = find_trace_probe(event, group);
Masami Hiramatsua7c312b2009-12-08 17:03:16 -0500424 if (!tp) {
Srikar Dronamraju9da79ab2010-06-30 14:15:48 +0530425 mutex_unlock(&probe_lock);
Masami Hiramatsua7c312b2009-12-08 17:03:16 -0500426 pr_info("Event %s/%s doesn't exist.\n", group, event);
427 return -ENOENT;
428 }
429 /* delete an event */
Masami Hiramatsu02ca1522011-10-04 19:44:38 +0900430 ret = unregister_trace_probe(tp);
431 if (ret == 0)
432 free_trace_probe(tp);
Srikar Dronamraju9da79ab2010-06-30 14:15:48 +0530433 mutex_unlock(&probe_lock);
Masami Hiramatsu02ca1522011-10-04 19:44:38 +0900434 return ret;
Masami Hiramatsua7c312b2009-12-08 17:03:16 -0500435 }
436
437 if (argc < 2) {
438 pr_info("Probe point is not specified.\n");
439 return -EINVAL;
440 }
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400441 if (isdigit(argv[1][0])) {
Masami Hiramatsue63cc232009-10-16 20:07:28 -0400442 if (is_return) {
443 pr_info("Return probe point must be a symbol.\n");
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400444 return -EINVAL;
Masami Hiramatsue63cc232009-10-16 20:07:28 -0400445 }
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400446 /* an address specified */
Heiko Carstensa9bb18f2010-02-10 17:23:47 +0100447 ret = strict_strtoul(&argv[1][0], 0, (unsigned long *)&addr);
Masami Hiramatsue63cc232009-10-16 20:07:28 -0400448 if (ret) {
449 pr_info("Failed to parse address.\n");
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400450 return ret;
Masami Hiramatsue63cc232009-10-16 20:07:28 -0400451 }
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400452 } else {
453 /* a symbol specified */
454 symbol = argv[1];
455 /* TODO: support .init module functions */
Srikar Dronamraju8ab83f52012-04-09 14:41:44 +0530456 ret = traceprobe_split_symbol_offset(symbol, &offset);
Masami Hiramatsue63cc232009-10-16 20:07:28 -0400457 if (ret) {
458 pr_info("Failed to parse symbol.\n");
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400459 return ret;
Masami Hiramatsue63cc232009-10-16 20:07:28 -0400460 }
461 if (offset && is_return) {
462 pr_info("Return probe must be used without offset.\n");
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400463 return -EINVAL;
Masami Hiramatsue63cc232009-10-16 20:07:28 -0400464 }
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400465 }
Masami Hiramatsua82378d2009-08-13 16:35:18 -0400466 argc -= 2; argv += 2;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400467
468 /* setup a probe */
Masami Hiramatsu42635652009-08-13 16:35:26 -0400469 if (!event) {
470 /* Make a new event name */
Masami Hiramatsu42635652009-08-13 16:35:26 -0400471 if (symbol)
Masami Hiramatsu6f3cf442009-12-16 17:24:08 -0500472 snprintf(buf, MAX_EVENT_NAME_LEN, "%c_%s_%ld",
Masami Hiramatsu42635652009-08-13 16:35:26 -0400473 is_return ? 'r' : 'p', symbol, offset);
474 else
Masami Hiramatsu6f3cf442009-12-16 17:24:08 -0500475 snprintf(buf, MAX_EVENT_NAME_LEN, "%c_0x%p",
Masami Hiramatsu42635652009-08-13 16:35:26 -0400476 is_return ? 'r' : 'p', addr);
Masami Hiramatsu4a846b42009-09-11 05:31:21 +0200477 event = buf;
478 }
Masami Hiramatsuf52487e2009-09-10 19:53:53 -0400479 tp = alloc_trace_probe(group, event, addr, symbol, offset, argc,
480 is_return);
Masami Hiramatsue63cc232009-10-16 20:07:28 -0400481 if (IS_ERR(tp)) {
482 pr_info("Failed to allocate trace_probe.(%d)\n",
483 (int)PTR_ERR(tp));
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400484 return PTR_ERR(tp);
Masami Hiramatsue63cc232009-10-16 20:07:28 -0400485 }
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400486
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400487 /* parse arguments */
Masami Hiramatsua82378d2009-08-13 16:35:18 -0400488 ret = 0;
489 for (i = 0; i < argc && i < MAX_TRACE_ARGS; i++) {
Masami Hiramatsu61a52732010-08-27 20:38:46 +0900490 /* Increment count for freeing args in error case */
491 tp->nr_args++;
492
Masami Hiramatsueca0d912009-09-10 19:53:38 -0400493 /* Parse argument name */
494 arg = strchr(argv[i], '=');
Masami Hiramatsuaba91592010-08-27 20:39:06 +0900495 if (arg) {
Masami Hiramatsueca0d912009-09-10 19:53:38 -0400496 *arg++ = '\0';
Masami Hiramatsuaba91592010-08-27 20:39:06 +0900497 tp->args[i].name = kstrdup(argv[i], GFP_KERNEL);
498 } else {
Masami Hiramatsueca0d912009-09-10 19:53:38 -0400499 arg = argv[i];
Masami Hiramatsuaba91592010-08-27 20:39:06 +0900500 /* If argument name is omitted, set "argN" */
501 snprintf(buf, MAX_EVENT_NAME_LEN, "arg%d", i + 1);
502 tp->args[i].name = kstrdup(buf, GFP_KERNEL);
503 }
Masami Hiramatsua703d942009-10-07 18:28:07 -0400504
Masami Hiramatsuba8665d2009-11-30 19:19:20 -0500505 if (!tp->args[i].name) {
Masami Hiramatsuaba91592010-08-27 20:39:06 +0900506 pr_info("Failed to allocate argument[%d] name.\n", i);
Masami Hiramatsuba8665d2009-11-30 19:19:20 -0500507 ret = -ENOMEM;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400508 goto error;
509 }
Masami Hiramatsuda346342010-08-27 20:39:12 +0900510
511 if (!is_good_name(tp->args[i].name)) {
512 pr_info("Invalid argument[%d] name: %s\n",
513 i, tp->args[i].name);
514 ret = -EINVAL;
515 goto error;
516 }
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400517
Srikar Dronamraju8ab83f52012-04-09 14:41:44 +0530518 if (traceprobe_conflict_field_name(tp->args[i].name,
519 tp->args, i)) {
Masami Hiramatsuaba91592010-08-27 20:39:06 +0900520 pr_info("Argument[%d] name '%s' conflicts with "
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400521 "another field.\n", i, argv[i]);
522 ret = -EINVAL;
523 goto error;
524 }
Masami Hiramatsuba8665d2009-11-30 19:19:20 -0500525
526 /* Parse fetch argument */
Srikar Dronamraju8ab83f52012-04-09 14:41:44 +0530527 ret = traceprobe_parse_probe_arg(arg, &tp->size, &tp->args[i],
Srikar Dronamrajuf3f096c2012-04-11 16:00:43 +0530528 is_return, true);
Masami Hiramatsue63cc232009-10-16 20:07:28 -0400529 if (ret) {
Masami Hiramatsuaba91592010-08-27 20:39:06 +0900530 pr_info("Parse error at argument[%d]. (%d)\n", i, ret);
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400531 goto error;
Masami Hiramatsue63cc232009-10-16 20:07:28 -0400532 }
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400533 }
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400534
535 ret = register_trace_probe(tp);
536 if (ret)
537 goto error;
538 return 0;
539
540error:
541 free_trace_probe(tp);
542 return ret;
543}
544
Masami Hiramatsu02ca1522011-10-04 19:44:38 +0900545static int release_all_trace_probes(void)
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400546{
547 struct trace_probe *tp;
Masami Hiramatsu02ca1522011-10-04 19:44:38 +0900548 int ret = 0;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400549
550 mutex_lock(&probe_lock);
Masami Hiramatsu02ca1522011-10-04 19:44:38 +0900551 /* Ensure no probe is in use. */
552 list_for_each_entry(tp, &probe_list, list)
553 if (trace_probe_is_enabled(tp)) {
554 ret = -EBUSY;
555 goto end;
556 }
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400557 /* TODO: Use batch unregistration */
558 while (!list_empty(&probe_list)) {
559 tp = list_entry(probe_list.next, struct trace_probe, list);
560 unregister_trace_probe(tp);
561 free_trace_probe(tp);
562 }
Masami Hiramatsu02ca1522011-10-04 19:44:38 +0900563
564end:
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400565 mutex_unlock(&probe_lock);
Masami Hiramatsu02ca1522011-10-04 19:44:38 +0900566
567 return ret;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400568}
569
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400570/* Probes listing interfaces */
571static void *probes_seq_start(struct seq_file *m, loff_t *pos)
572{
573 mutex_lock(&probe_lock);
574 return seq_list_start(&probe_list, *pos);
575}
576
577static void *probes_seq_next(struct seq_file *m, void *v, loff_t *pos)
578{
579 return seq_list_next(v, &probe_list, pos);
580}
581
582static void probes_seq_stop(struct seq_file *m, void *v)
583{
584 mutex_unlock(&probe_lock);
585}
586
587static int probes_seq_show(struct seq_file *m, void *v)
588{
589 struct trace_probe *tp = v;
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400590 int i;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400591
Masami Hiramatsu7143f162011-06-27 16:26:36 +0900592 seq_printf(m, "%c", trace_probe_is_return(tp) ? 'r' : 'p');
Steven Rostedt8f082012010-04-20 10:47:33 -0400593 seq_printf(m, ":%s/%s", tp->call.class->system, tp->call.name);
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400594
Lai Jiangshan52a11f32009-11-25 16:33:15 +0800595 if (!tp->symbol)
596 seq_printf(m, " 0x%p", tp->rp.kp.addr);
597 else if (tp->rp.kp.offset)
Masami Hiramatsu7143f162011-06-27 16:26:36 +0900598 seq_printf(m, " %s+%u", trace_probe_symbol(tp),
599 tp->rp.kp.offset);
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400600 else
Masami Hiramatsu7143f162011-06-27 16:26:36 +0900601 seq_printf(m, " %s", trace_probe_symbol(tp));
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400602
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400603 for (i = 0; i < tp->nr_args; i++)
604 seq_printf(m, " %s=%s", tp->args[i].name, tp->args[i].comm);
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400605 seq_printf(m, "\n");
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400606
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400607 return 0;
608}
609
610static const struct seq_operations probes_seq_op = {
611 .start = probes_seq_start,
612 .next = probes_seq_next,
613 .stop = probes_seq_stop,
614 .show = probes_seq_show
615};
616
617static int probes_open(struct inode *inode, struct file *file)
618{
Masami Hiramatsu02ca1522011-10-04 19:44:38 +0900619 int ret;
620
621 if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC)) {
622 ret = release_all_trace_probes();
623 if (ret < 0)
624 return ret;
625 }
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400626
627 return seq_open(file, &probes_seq_op);
628}
629
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400630static ssize_t probes_write(struct file *file, const char __user *buffer,
631 size_t count, loff_t *ppos)
632{
Srikar Dronamraju8ab83f52012-04-09 14:41:44 +0530633 return traceprobe_probes_write(file, buffer, count, ppos,
634 create_trace_probe);
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400635}
636
637static const struct file_operations kprobe_events_ops = {
638 .owner = THIS_MODULE,
639 .open = probes_open,
640 .read = seq_read,
641 .llseek = seq_lseek,
642 .release = seq_release,
643 .write = probes_write,
644};
645
Masami Hiramatsucd7e7bd2009-08-13 16:35:42 -0400646/* Probes profiling interfaces */
647static int probes_profile_seq_show(struct seq_file *m, void *v)
648{
649 struct trace_probe *tp = v;
650
651 seq_printf(m, " %-44s %15lu %15lu\n", tp->call.name, tp->nhit,
Masami Hiramatsu4a846b42009-09-11 05:31:21 +0200652 tp->rp.kp.nmissed);
Masami Hiramatsucd7e7bd2009-08-13 16:35:42 -0400653
654 return 0;
655}
656
657static const struct seq_operations profile_seq_op = {
658 .start = probes_seq_start,
659 .next = probes_seq_next,
660 .stop = probes_seq_stop,
661 .show = probes_profile_seq_show
662};
663
664static int profile_open(struct inode *inode, struct file *file)
665{
666 return seq_open(file, &profile_seq_op);
667}
668
669static const struct file_operations kprobe_profile_ops = {
670 .owner = THIS_MODULE,
671 .open = profile_open,
672 .read = seq_read,
673 .llseek = seq_lseek,
674 .release = seq_release,
675};
676
Masami Hiramatsue09c8612010-07-05 15:54:45 -0300677/* Sum up total data length for dynamic arraies (strings) */
678static __kprobes int __get_data_size(struct trace_probe *tp,
679 struct pt_regs *regs)
680{
681 int i, ret = 0;
682 u32 len;
683
684 for (i = 0; i < tp->nr_args; i++)
685 if (unlikely(tp->args[i].fetch_size.fn)) {
686 call_fetch(&tp->args[i].fetch_size, regs, &len);
687 ret += len;
688 }
689
690 return ret;
691}
692
693/* Store the value of each argument */
694static __kprobes void store_trace_args(int ent_size, struct trace_probe *tp,
695 struct pt_regs *regs,
696 u8 *data, int maxlen)
697{
698 int i;
699 u32 end = tp->size;
700 u32 *dl; /* Data (relative) location */
701
702 for (i = 0; i < tp->nr_args; i++) {
703 if (unlikely(tp->args[i].fetch_size.fn)) {
704 /*
705 * First, we set the relative location and
706 * maximum data length to *dl
707 */
708 dl = (u32 *)(data + tp->args[i].offset);
709 *dl = make_data_rloc(maxlen, end - tp->args[i].offset);
710 /* Then try to fetch string or dynamic array data */
711 call_fetch(&tp->args[i].fetch, regs, dl);
712 /* Reduce maximum length */
713 end += get_rloc_len(*dl);
714 maxlen -= get_rloc_len(*dl);
715 /* Trick here, convert data_rloc to data_loc */
716 *dl = convert_rloc_to_loc(*dl,
717 ent_size + tp->args[i].offset);
718 } else
719 /* Just fetching data normally */
720 call_fetch(&tp->args[i].fetch, regs,
721 data + tp->args[i].offset);
722 }
723}
724
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400725/* Kprobe handler */
Xiao Guangrong1e12a4a2010-01-28 09:34:27 +0800726static __kprobes void kprobe_trace_func(struct kprobe *kp, struct pt_regs *regs)
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400727{
Masami Hiramatsu4a846b42009-09-11 05:31:21 +0200728 struct trace_probe *tp = container_of(kp, struct trace_probe, rp.kp);
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400729 struct kprobe_trace_entry_head *entry;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400730 struct ring_buffer_event *event;
Frederic Weisbecker8f8ffe22009-09-11 01:09:23 +0200731 struct ring_buffer *buffer;
Masami Hiramatsue09c8612010-07-05 15:54:45 -0300732 int size, dsize, pc;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400733 unsigned long irq_flags;
Masami Hiramatsu42635652009-08-13 16:35:26 -0400734 struct ftrace_event_call *call = &tp->call;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400735
Masami Hiramatsucd7e7bd2009-08-13 16:35:42 -0400736 tp->nhit++;
737
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400738 local_save_flags(irq_flags);
739 pc = preempt_count();
740
Masami Hiramatsue09c8612010-07-05 15:54:45 -0300741 dsize = __get_data_size(tp, regs);
742 size = sizeof(*entry) + tp->size + dsize;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400743
Steven Rostedt32c0eda2010-04-23 10:38:03 -0400744 event = trace_current_buffer_lock_reserve(&buffer, call->event.type,
745 size, irq_flags, pc);
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400746 if (!event)
Xiao Guangrong1e12a4a2010-01-28 09:34:27 +0800747 return;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400748
749 entry = ring_buffer_event_data(event);
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400750 entry->ip = (unsigned long)kp->addr;
Masami Hiramatsue09c8612010-07-05 15:54:45 -0300751 store_trace_args(sizeof(*entry), tp, regs, (u8 *)&entry[1], dsize);
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400752
Frederic Weisbecker8f8ffe22009-09-11 01:09:23 +0200753 if (!filter_current_check_discard(buffer, call, entry, event))
Masami Hiramatsu1fd8df22011-06-08 16:09:34 +0900754 trace_nowake_buffer_unlock_commit_regs(buffer, event,
755 irq_flags, pc, regs);
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400756}
757
758/* Kretprobe handler */
Xiao Guangrong1e12a4a2010-01-28 09:34:27 +0800759static __kprobes void kretprobe_trace_func(struct kretprobe_instance *ri,
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400760 struct pt_regs *regs)
761{
762 struct trace_probe *tp = container_of(ri->rp, struct trace_probe, rp);
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400763 struct kretprobe_trace_entry_head *entry;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400764 struct ring_buffer_event *event;
Frederic Weisbecker8f8ffe22009-09-11 01:09:23 +0200765 struct ring_buffer *buffer;
Masami Hiramatsue09c8612010-07-05 15:54:45 -0300766 int size, pc, dsize;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400767 unsigned long irq_flags;
Masami Hiramatsu42635652009-08-13 16:35:26 -0400768 struct ftrace_event_call *call = &tp->call;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400769
770 local_save_flags(irq_flags);
771 pc = preempt_count();
772
Masami Hiramatsue09c8612010-07-05 15:54:45 -0300773 dsize = __get_data_size(tp, regs);
774 size = sizeof(*entry) + tp->size + dsize;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400775
Steven Rostedt32c0eda2010-04-23 10:38:03 -0400776 event = trace_current_buffer_lock_reserve(&buffer, call->event.type,
777 size, irq_flags, pc);
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400778 if (!event)
Xiao Guangrong1e12a4a2010-01-28 09:34:27 +0800779 return;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400780
781 entry = ring_buffer_event_data(event);
Masami Hiramatsu4a846b42009-09-11 05:31:21 +0200782 entry->func = (unsigned long)tp->rp.kp.addr;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400783 entry->ret_ip = (unsigned long)ri->ret_addr;
Masami Hiramatsue09c8612010-07-05 15:54:45 -0300784 store_trace_args(sizeof(*entry), tp, regs, (u8 *)&entry[1], dsize);
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400785
Frederic Weisbecker8f8ffe22009-09-11 01:09:23 +0200786 if (!filter_current_check_discard(buffer, call, entry, event))
Masami Hiramatsu1fd8df22011-06-08 16:09:34 +0900787 trace_nowake_buffer_unlock_commit_regs(buffer, event,
788 irq_flags, pc, regs);
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400789}
790
791/* Event entry printers */
792enum print_line_t
Steven Rostedta9a57762010-04-22 18:46:14 -0400793print_kprobe_event(struct trace_iterator *iter, int flags,
794 struct trace_event *event)
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400795{
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400796 struct kprobe_trace_entry_head *field;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400797 struct trace_seq *s = &iter->seq;
Masami Hiramatsueca0d912009-09-10 19:53:38 -0400798 struct trace_probe *tp;
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400799 u8 *data;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400800 int i;
801
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400802 field = (struct kprobe_trace_entry_head *)iter->ent;
Steven Rostedt80decc72010-04-23 10:00:22 -0400803 tp = container_of(event, struct trace_probe, call.event);
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400804
Masami Hiramatsu6e9f23d2009-09-10 19:53:45 -0400805 if (!trace_seq_printf(s, "%s: (", tp->call.name))
806 goto partial;
807
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400808 if (!seq_print_ip_sym(s, field->ip, flags | TRACE_ITER_SYM_OFFSET))
809 goto partial;
810
Masami Hiramatsu6e9f23d2009-09-10 19:53:45 -0400811 if (!trace_seq_puts(s, ")"))
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400812 goto partial;
813
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400814 data = (u8 *)&field[1];
815 for (i = 0; i < tp->nr_args; i++)
816 if (!tp->args[i].type->print(s, tp->args[i].name,
Masami Hiramatsue09c8612010-07-05 15:54:45 -0300817 data + tp->args[i].offset, field))
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400818 goto partial;
819
820 if (!trace_seq_puts(s, "\n"))
821 goto partial;
822
823 return TRACE_TYPE_HANDLED;
824partial:
825 return TRACE_TYPE_PARTIAL_LINE;
826}
827
828enum print_line_t
Steven Rostedta9a57762010-04-22 18:46:14 -0400829print_kretprobe_event(struct trace_iterator *iter, int flags,
830 struct trace_event *event)
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400831{
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400832 struct kretprobe_trace_entry_head *field;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400833 struct trace_seq *s = &iter->seq;
Masami Hiramatsueca0d912009-09-10 19:53:38 -0400834 struct trace_probe *tp;
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400835 u8 *data;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400836 int i;
837
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400838 field = (struct kretprobe_trace_entry_head *)iter->ent;
Steven Rostedt80decc72010-04-23 10:00:22 -0400839 tp = container_of(event, struct trace_probe, call.event);
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400840
Masami Hiramatsu6e9f23d2009-09-10 19:53:45 -0400841 if (!trace_seq_printf(s, "%s: (", tp->call.name))
842 goto partial;
843
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400844 if (!seq_print_ip_sym(s, field->ret_ip, flags | TRACE_ITER_SYM_OFFSET))
845 goto partial;
846
847 if (!trace_seq_puts(s, " <- "))
848 goto partial;
849
850 if (!seq_print_ip_sym(s, field->func, flags & ~TRACE_ITER_SYM_OFFSET))
851 goto partial;
852
Masami Hiramatsu6e9f23d2009-09-10 19:53:45 -0400853 if (!trace_seq_puts(s, ")"))
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400854 goto partial;
855
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400856 data = (u8 *)&field[1];
857 for (i = 0; i < tp->nr_args; i++)
858 if (!tp->args[i].type->print(s, tp->args[i].name,
Masami Hiramatsue09c8612010-07-05 15:54:45 -0300859 data + tp->args[i].offset, field))
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400860 goto partial;
861
862 if (!trace_seq_puts(s, "\n"))
863 goto partial;
864
865 return TRACE_TYPE_HANDLED;
866partial:
867 return TRACE_TYPE_PARTIAL_LINE;
868}
869
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400870
871static int kprobe_event_define_fields(struct ftrace_event_call *event_call)
872{
873 int ret, i;
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400874 struct kprobe_trace_entry_head field;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400875 struct trace_probe *tp = (struct trace_probe *)event_call->data;
876
Masami Hiramatsua703d942009-10-07 18:28:07 -0400877 DEFINE_FIELD(unsigned long, ip, FIELD_STRING_IP, 0);
Masami Hiramatsueca0d912009-09-10 19:53:38 -0400878 /* Set argument names as fields */
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400879 for (i = 0; i < tp->nr_args; i++) {
Masami Hiramatsue09c8612010-07-05 15:54:45 -0300880 ret = trace_define_field(event_call, tp->args[i].type->fmttype,
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400881 tp->args[i].name,
882 sizeof(field) + tp->args[i].offset,
883 tp->args[i].type->size,
884 tp->args[i].type->is_signed,
885 FILTER_OTHER);
886 if (ret)
887 return ret;
888 }
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400889 return 0;
890}
891
892static int kretprobe_event_define_fields(struct ftrace_event_call *event_call)
893{
894 int ret, i;
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400895 struct kretprobe_trace_entry_head field;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400896 struct trace_probe *tp = (struct trace_probe *)event_call->data;
897
Masami Hiramatsua703d942009-10-07 18:28:07 -0400898 DEFINE_FIELD(unsigned long, func, FIELD_STRING_FUNC, 0);
899 DEFINE_FIELD(unsigned long, ret_ip, FIELD_STRING_RETIP, 0);
Masami Hiramatsueca0d912009-09-10 19:53:38 -0400900 /* Set argument names as fields */
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400901 for (i = 0; i < tp->nr_args; i++) {
Masami Hiramatsue09c8612010-07-05 15:54:45 -0300902 ret = trace_define_field(event_call, tp->args[i].type->fmttype,
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400903 tp->args[i].name,
904 sizeof(field) + tp->args[i].offset,
905 tp->args[i].type->size,
906 tp->args[i].type->is_signed,
907 FILTER_OTHER);
908 if (ret)
909 return ret;
910 }
Masami Hiramatsu413d37d2009-08-13 16:35:11 -0400911 return 0;
912}
913
Lai Jiangshana342a0282009-12-15 15:39:49 +0800914static int __set_print_fmt(struct trace_probe *tp, char *buf, int len)
915{
916 int i;
917 int pos = 0;
918
919 const char *fmt, *arg;
920
Masami Hiramatsu7143f162011-06-27 16:26:36 +0900921 if (!trace_probe_is_return(tp)) {
Lai Jiangshana342a0282009-12-15 15:39:49 +0800922 fmt = "(%lx)";
923 arg = "REC->" FIELD_STRING_IP;
924 } else {
925 fmt = "(%lx <- %lx)";
926 arg = "REC->" FIELD_STRING_FUNC ", REC->" FIELD_STRING_RETIP;
927 }
928
929 /* When len=0, we just calculate the needed length */
930#define LEN_OR_ZERO (len ? len - pos : 0)
931
932 pos += snprintf(buf + pos, LEN_OR_ZERO, "\"%s", fmt);
933
934 for (i = 0; i < tp->nr_args; i++) {
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400935 pos += snprintf(buf + pos, LEN_OR_ZERO, " %s=%s",
936 tp->args[i].name, tp->args[i].type->fmt);
Lai Jiangshana342a0282009-12-15 15:39:49 +0800937 }
938
939 pos += snprintf(buf + pos, LEN_OR_ZERO, "\", %s", arg);
940
941 for (i = 0; i < tp->nr_args; i++) {
Masami Hiramatsue09c8612010-07-05 15:54:45 -0300942 if (strcmp(tp->args[i].type->name, "string") == 0)
943 pos += snprintf(buf + pos, LEN_OR_ZERO,
944 ", __get_str(%s)",
945 tp->args[i].name);
946 else
947 pos += snprintf(buf + pos, LEN_OR_ZERO, ", REC->%s",
948 tp->args[i].name);
Lai Jiangshana342a0282009-12-15 15:39:49 +0800949 }
950
951#undef LEN_OR_ZERO
952
953 /* return the length of print_fmt */
954 return pos;
955}
956
957static int set_print_fmt(struct trace_probe *tp)
958{
959 int len;
960 char *print_fmt;
961
962 /* First: called with 0 length to calculate the needed length */
963 len = __set_print_fmt(tp, NULL, 0);
964 print_fmt = kmalloc(len + 1, GFP_KERNEL);
965 if (!print_fmt)
966 return -ENOMEM;
967
968 /* Second: actually write the @print_fmt */
969 __set_print_fmt(tp, print_fmt, len + 1);
970 tp->call.print_fmt = print_fmt;
971
972 return 0;
973}
974
Li Zefan07b139c2009-12-21 14:27:35 +0800975#ifdef CONFIG_PERF_EVENTS
Masami Hiramatsue08d1c62009-09-10 19:53:30 -0400976
977/* Kprobe profile handler */
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100978static __kprobes void kprobe_perf_func(struct kprobe *kp,
Masami Hiramatsue08d1c62009-09-10 19:53:30 -0400979 struct pt_regs *regs)
980{
981 struct trace_probe *tp = container_of(kp, struct trace_probe, rp.kp);
982 struct ftrace_event_call *call = &tp->call;
Masami Hiramatsu93ccae72010-04-12 13:17:08 -0400983 struct kprobe_trace_entry_head *entry;
Peter Zijlstra1c024eca2010-05-19 14:02:22 +0200984 struct hlist_head *head;
Masami Hiramatsue09c8612010-07-05 15:54:45 -0300985 int size, __size, dsize;
Peter Zijlstra4ed7c922009-11-23 11:37:29 +0100986 int rctx;
Masami Hiramatsue08d1c62009-09-10 19:53:30 -0400987
Masami Hiramatsue09c8612010-07-05 15:54:45 -0300988 dsize = __get_data_size(tp, regs);
989 __size = sizeof(*entry) + tp->size + dsize;
Masami Hiramatsu74ebb632009-09-14 16:49:28 -0400990 size = ALIGN(__size + sizeof(u32), sizeof(u64));
991 size -= sizeof(u32);
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100992 if (WARN_ONCE(size > PERF_MAX_TRACE_SIZE,
Masami Hiramatsua1a138d2009-09-25 11:20:12 -0700993 "profile buffer not large enough"))
Xiao Guangrong1e12a4a2010-01-28 09:34:27 +0800994 return;
Masami Hiramatsue08d1c62009-09-10 19:53:30 -0400995
Steven Rostedtff5f1492010-05-21 11:49:57 -0400996 entry = perf_trace_buf_prepare(size, call->event.type, regs, &rctx);
Xiao Guangrong430ad5a2010-01-28 09:32:29 +0800997 if (!entry)
Xiao Guangrong1e12a4a2010-01-28 09:34:27 +0800998 return;
Frederic Weisbeckerce71b9d2009-11-22 05:26:55 +0100999
Masami Hiramatsua1a138d2009-09-25 11:20:12 -07001000 entry->ip = (unsigned long)kp->addr;
Masami Hiramatsue09c8612010-07-05 15:54:45 -03001001 memset(&entry[1], 0, dsize);
1002 store_trace_args(sizeof(*entry), tp, regs, (u8 *)&entry[1], dsize);
Frederic Weisbecker444a2a32009-11-06 04:13:05 +01001003
Peter Zijlstra3771f072010-05-21 12:31:09 +02001004 head = this_cpu_ptr(call->perf_events);
Andrew Vagine6dab5f2012-07-11 18:14:58 +04001005 perf_trace_buf_submit(entry, size, rctx,
1006 entry->ip, 1, regs, head, NULL);
Masami Hiramatsue08d1c62009-09-10 19:53:30 -04001007}
1008
1009/* Kretprobe profile handler */
Frederic Weisbecker97d5a222010-03-05 05:35:37 +01001010static __kprobes void kretprobe_perf_func(struct kretprobe_instance *ri,
Masami Hiramatsue08d1c62009-09-10 19:53:30 -04001011 struct pt_regs *regs)
1012{
1013 struct trace_probe *tp = container_of(ri->rp, struct trace_probe, rp);
1014 struct ftrace_event_call *call = &tp->call;
Masami Hiramatsu93ccae72010-04-12 13:17:08 -04001015 struct kretprobe_trace_entry_head *entry;
Peter Zijlstra1c024eca2010-05-19 14:02:22 +02001016 struct hlist_head *head;
Masami Hiramatsue09c8612010-07-05 15:54:45 -03001017 int size, __size, dsize;
Peter Zijlstra4ed7c922009-11-23 11:37:29 +01001018 int rctx;
Masami Hiramatsue08d1c62009-09-10 19:53:30 -04001019
Masami Hiramatsue09c8612010-07-05 15:54:45 -03001020 dsize = __get_data_size(tp, regs);
1021 __size = sizeof(*entry) + tp->size + dsize;
Masami Hiramatsu74ebb632009-09-14 16:49:28 -04001022 size = ALIGN(__size + sizeof(u32), sizeof(u64));
1023 size -= sizeof(u32);
Frederic Weisbecker97d5a222010-03-05 05:35:37 +01001024 if (WARN_ONCE(size > PERF_MAX_TRACE_SIZE,
Masami Hiramatsua1a138d2009-09-25 11:20:12 -07001025 "profile buffer not large enough"))
Xiao Guangrong1e12a4a2010-01-28 09:34:27 +08001026 return;
Masami Hiramatsue08d1c62009-09-10 19:53:30 -04001027
Steven Rostedtff5f1492010-05-21 11:49:57 -04001028 entry = perf_trace_buf_prepare(size, call->event.type, regs, &rctx);
Xiao Guangrong430ad5a2010-01-28 09:32:29 +08001029 if (!entry)
Xiao Guangrong1e12a4a2010-01-28 09:34:27 +08001030 return;
Frederic Weisbeckerce71b9d2009-11-22 05:26:55 +01001031
Masami Hiramatsua1a138d2009-09-25 11:20:12 -07001032 entry->func = (unsigned long)tp->rp.kp.addr;
1033 entry->ret_ip = (unsigned long)ri->ret_addr;
Masami Hiramatsue09c8612010-07-05 15:54:45 -03001034 store_trace_args(sizeof(*entry), tp, regs, (u8 *)&entry[1], dsize);
Frederic Weisbecker444a2a32009-11-06 04:13:05 +01001035
Peter Zijlstra3771f072010-05-21 12:31:09 +02001036 head = this_cpu_ptr(call->perf_events);
Andrew Vagine6dab5f2012-07-11 18:14:58 +04001037 perf_trace_buf_submit(entry, size, rctx,
1038 entry->ret_ip, 1, regs, head, NULL);
Masami Hiramatsue08d1c62009-09-10 19:53:30 -04001039}
Li Zefan07b139c2009-12-21 14:27:35 +08001040#endif /* CONFIG_PERF_EVENTS */
Masami Hiramatsu50d78052009-09-14 16:49:20 -04001041
Steven Rostedt22392912010-04-21 12:27:06 -04001042static __kprobes
Jiri Olsaceec0b62012-02-15 15:51:49 +01001043int kprobe_register(struct ftrace_event_call *event,
1044 enum trace_reg type, void *data)
Steven Rostedt22392912010-04-21 12:27:06 -04001045{
Masami Hiramatsu1538f882011-06-27 16:26:44 +09001046 struct trace_probe *tp = (struct trace_probe *)event->data;
1047
Steven Rostedt22392912010-04-21 12:27:06 -04001048 switch (type) {
1049 case TRACE_REG_REGISTER:
Masami Hiramatsu1538f882011-06-27 16:26:44 +09001050 return enable_trace_probe(tp, TP_FLAG_TRACE);
Steven Rostedt22392912010-04-21 12:27:06 -04001051 case TRACE_REG_UNREGISTER:
Masami Hiramatsu1538f882011-06-27 16:26:44 +09001052 disable_trace_probe(tp, TP_FLAG_TRACE);
Steven Rostedt22392912010-04-21 12:27:06 -04001053 return 0;
1054
1055#ifdef CONFIG_PERF_EVENTS
1056 case TRACE_REG_PERF_REGISTER:
Masami Hiramatsu1538f882011-06-27 16:26:44 +09001057 return enable_trace_probe(tp, TP_FLAG_PROFILE);
Steven Rostedt22392912010-04-21 12:27:06 -04001058 case TRACE_REG_PERF_UNREGISTER:
Masami Hiramatsu1538f882011-06-27 16:26:44 +09001059 disable_trace_probe(tp, TP_FLAG_PROFILE);
Steven Rostedt22392912010-04-21 12:27:06 -04001060 return 0;
Jiri Olsaceec0b62012-02-15 15:51:49 +01001061 case TRACE_REG_PERF_OPEN:
1062 case TRACE_REG_PERF_CLOSE:
Jiri Olsa489c75c2012-02-15 15:51:50 +01001063 case TRACE_REG_PERF_ADD:
1064 case TRACE_REG_PERF_DEL:
Jiri Olsaceec0b62012-02-15 15:51:49 +01001065 return 0;
Steven Rostedt22392912010-04-21 12:27:06 -04001066#endif
1067 }
1068 return 0;
1069}
Masami Hiramatsu50d78052009-09-14 16:49:20 -04001070
1071static __kprobes
1072int kprobe_dispatcher(struct kprobe *kp, struct pt_regs *regs)
1073{
1074 struct trace_probe *tp = container_of(kp, struct trace_probe, rp.kp);
1075
1076 if (tp->flags & TP_FLAG_TRACE)
1077 kprobe_trace_func(kp, regs);
Li Zefan07b139c2009-12-21 14:27:35 +08001078#ifdef CONFIG_PERF_EVENTS
Masami Hiramatsu50d78052009-09-14 16:49:20 -04001079 if (tp->flags & TP_FLAG_PROFILE)
Frederic Weisbecker97d5a222010-03-05 05:35:37 +01001080 kprobe_perf_func(kp, regs);
Li Zefan07b139c2009-12-21 14:27:35 +08001081#endif
Masami Hiramatsu50d78052009-09-14 16:49:20 -04001082 return 0; /* We don't tweek kernel, so just return 0 */
Masami Hiramatsue08d1c62009-09-10 19:53:30 -04001083}
1084
Masami Hiramatsu50d78052009-09-14 16:49:20 -04001085static __kprobes
1086int kretprobe_dispatcher(struct kretprobe_instance *ri, struct pt_regs *regs)
1087{
1088 struct trace_probe *tp = container_of(ri->rp, struct trace_probe, rp);
1089
1090 if (tp->flags & TP_FLAG_TRACE)
1091 kretprobe_trace_func(ri, regs);
Li Zefan07b139c2009-12-21 14:27:35 +08001092#ifdef CONFIG_PERF_EVENTS
Masami Hiramatsu50d78052009-09-14 16:49:20 -04001093 if (tp->flags & TP_FLAG_PROFILE)
Frederic Weisbecker97d5a222010-03-05 05:35:37 +01001094 kretprobe_perf_func(ri, regs);
Li Zefan07b139c2009-12-21 14:27:35 +08001095#endif
Masami Hiramatsu50d78052009-09-14 16:49:20 -04001096 return 0; /* We don't tweek kernel, so just return 0 */
1097}
Masami Hiramatsue08d1c62009-09-10 19:53:30 -04001098
Steven Rostedta9a57762010-04-22 18:46:14 -04001099static struct trace_event_functions kretprobe_funcs = {
1100 .trace = print_kretprobe_event
1101};
1102
1103static struct trace_event_functions kprobe_funcs = {
1104 .trace = print_kprobe_event
1105};
1106
Masami Hiramatsu413d37d2009-08-13 16:35:11 -04001107static int register_probe_event(struct trace_probe *tp)
1108{
1109 struct ftrace_event_call *call = &tp->call;
1110 int ret;
1111
1112 /* Initialize ftrace_event_call */
Li Zefanffb9f992010-05-24 16:24:52 +08001113 INIT_LIST_HEAD(&call->class->fields);
Masami Hiramatsu7143f162011-06-27 16:26:36 +09001114 if (trace_probe_is_return(tp)) {
Steven Rostedt80decc72010-04-23 10:00:22 -04001115 call->event.funcs = &kretprobe_funcs;
Steven Rostedt2e33af02010-04-22 10:35:55 -04001116 call->class->define_fields = kretprobe_event_define_fields;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -04001117 } else {
Steven Rostedt80decc72010-04-23 10:00:22 -04001118 call->event.funcs = &kprobe_funcs;
Steven Rostedt2e33af02010-04-22 10:35:55 -04001119 call->class->define_fields = kprobe_event_define_fields;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -04001120 }
Lai Jiangshana342a0282009-12-15 15:39:49 +08001121 if (set_print_fmt(tp) < 0)
1122 return -ENOMEM;
Steven Rostedt32c0eda2010-04-23 10:38:03 -04001123 ret = register_ftrace_event(&call->event);
1124 if (!ret) {
Lai Jiangshana342a0282009-12-15 15:39:49 +08001125 kfree(call->print_fmt);
Masami Hiramatsuff50d992009-08-13 16:35:34 -04001126 return -ENODEV;
Lai Jiangshana342a0282009-12-15 15:39:49 +08001127 }
Steven Rostedt553552c2010-04-23 11:12:36 -04001128 call->flags = 0;
Steven Rostedt22392912010-04-21 12:27:06 -04001129 call->class->reg = kprobe_register;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -04001130 call->data = tp;
1131 ret = trace_add_event_call(call);
Masami Hiramatsuff50d992009-08-13 16:35:34 -04001132 if (ret) {
Masami Hiramatsu413d37d2009-08-13 16:35:11 -04001133 pr_info("Failed to register kprobe event: %s\n", call->name);
Lai Jiangshana342a0282009-12-15 15:39:49 +08001134 kfree(call->print_fmt);
Steven Rostedt80decc72010-04-23 10:00:22 -04001135 unregister_ftrace_event(&call->event);
Masami Hiramatsuff50d992009-08-13 16:35:34 -04001136 }
Masami Hiramatsu413d37d2009-08-13 16:35:11 -04001137 return ret;
1138}
1139
1140static void unregister_probe_event(struct trace_probe *tp)
1141{
Masami Hiramatsuff50d992009-08-13 16:35:34 -04001142 /* tp->event is unregistered in trace_remove_event_call() */
Masami Hiramatsu413d37d2009-08-13 16:35:11 -04001143 trace_remove_event_call(&tp->call);
Lai Jiangshana342a0282009-12-15 15:39:49 +08001144 kfree(tp->call.print_fmt);
Masami Hiramatsu413d37d2009-08-13 16:35:11 -04001145}
1146
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001147/* Make a debugfs interface for controlling probe points */
Masami Hiramatsu413d37d2009-08-13 16:35:11 -04001148static __init int init_kprobe_trace(void)
1149{
1150 struct dentry *d_tracer;
1151 struct dentry *entry;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -04001152
Masami Hiramatsu61424312011-06-27 16:26:56 +09001153 if (register_module_notifier(&trace_probe_module_nb))
1154 return -EINVAL;
1155
Masami Hiramatsu413d37d2009-08-13 16:35:11 -04001156 d_tracer = tracing_init_dentry();
1157 if (!d_tracer)
1158 return 0;
1159
1160 entry = debugfs_create_file("kprobe_events", 0644, d_tracer,
1161 NULL, &kprobe_events_ops);
1162
Masami Hiramatsucd7e7bd2009-08-13 16:35:42 -04001163 /* Event list interface */
Masami Hiramatsu413d37d2009-08-13 16:35:11 -04001164 if (!entry)
1165 pr_warning("Could not create debugfs "
1166 "'kprobe_events' entry\n");
Masami Hiramatsucd7e7bd2009-08-13 16:35:42 -04001167
1168 /* Profile interface */
1169 entry = debugfs_create_file("kprobe_profile", 0444, d_tracer,
1170 NULL, &kprobe_profile_ops);
1171
1172 if (!entry)
1173 pr_warning("Could not create debugfs "
1174 "'kprobe_profile' entry\n");
Masami Hiramatsu413d37d2009-08-13 16:35:11 -04001175 return 0;
1176}
1177fs_initcall(init_kprobe_trace);
1178
1179
1180#ifdef CONFIG_FTRACE_STARTUP_TEST
1181
Steven Rostedt265a5b72011-06-06 22:35:13 -04001182/*
1183 * The "__used" keeps gcc from removing the function symbol
1184 * from the kallsyms table.
1185 */
1186static __used int kprobe_trace_selftest_target(int a1, int a2, int a3,
1187 int a4, int a5, int a6)
Masami Hiramatsu413d37d2009-08-13 16:35:11 -04001188{
1189 return a1 + a2 + a3 + a4 + a5 + a6;
1190}
1191
1192static __init int kprobe_trace_self_tests_init(void)
1193{
Masami Hiramatsu231e36f2010-01-14 00:12:12 -05001194 int ret, warn = 0;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -04001195 int (*target)(int, int, int, int, int, int);
Masami Hiramatsu231e36f2010-01-14 00:12:12 -05001196 struct trace_probe *tp;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -04001197
1198 target = kprobe_trace_selftest_target;
1199
1200 pr_info("Testing kprobe tracing: ");
1201
Srikar Dronamraju8ab83f52012-04-09 14:41:44 +05301202 ret = traceprobe_command("p:testprobe kprobe_trace_selftest_target "
1203 "$stack $stack0 +0($stack)",
1204 create_trace_probe);
Masami Hiramatsu231e36f2010-01-14 00:12:12 -05001205 if (WARN_ON_ONCE(ret)) {
1206 pr_warning("error on probing function entry.\n");
1207 warn++;
1208 } else {
1209 /* Enable trace point */
Masami Hiramatsu7143f162011-06-27 16:26:36 +09001210 tp = find_trace_probe("testprobe", KPROBE_EVENT_SYSTEM);
Masami Hiramatsu231e36f2010-01-14 00:12:12 -05001211 if (WARN_ON_ONCE(tp == NULL)) {
1212 pr_warning("error on getting new probe.\n");
1213 warn++;
1214 } else
Masami Hiramatsu1538f882011-06-27 16:26:44 +09001215 enable_trace_probe(tp, TP_FLAG_TRACE);
Masami Hiramatsu231e36f2010-01-14 00:12:12 -05001216 }
Masami Hiramatsu413d37d2009-08-13 16:35:11 -04001217
Srikar Dronamraju8ab83f52012-04-09 14:41:44 +05301218 ret = traceprobe_command("r:testprobe2 kprobe_trace_selftest_target "
1219 "$retval", create_trace_probe);
Masami Hiramatsu231e36f2010-01-14 00:12:12 -05001220 if (WARN_ON_ONCE(ret)) {
1221 pr_warning("error on probing function return.\n");
1222 warn++;
1223 } else {
1224 /* Enable trace point */
Masami Hiramatsu7143f162011-06-27 16:26:36 +09001225 tp = find_trace_probe("testprobe2", KPROBE_EVENT_SYSTEM);
Masami Hiramatsu231e36f2010-01-14 00:12:12 -05001226 if (WARN_ON_ONCE(tp == NULL)) {
1227 pr_warning("error on getting new probe.\n");
1228 warn++;
1229 } else
Masami Hiramatsu1538f882011-06-27 16:26:44 +09001230 enable_trace_probe(tp, TP_FLAG_TRACE);
Masami Hiramatsu231e36f2010-01-14 00:12:12 -05001231 }
1232
1233 if (warn)
1234 goto end;
Masami Hiramatsu413d37d2009-08-13 16:35:11 -04001235
1236 ret = target(1, 2, 3, 4, 5, 6);
1237
Masami Hiramatsu02ca1522011-10-04 19:44:38 +09001238 /* Disable trace points before removing it */
1239 tp = find_trace_probe("testprobe", KPROBE_EVENT_SYSTEM);
1240 if (WARN_ON_ONCE(tp == NULL)) {
1241 pr_warning("error on getting test probe.\n");
1242 warn++;
1243 } else
1244 disable_trace_probe(tp, TP_FLAG_TRACE);
1245
1246 tp = find_trace_probe("testprobe2", KPROBE_EVENT_SYSTEM);
1247 if (WARN_ON_ONCE(tp == NULL)) {
1248 pr_warning("error on getting 2nd test probe.\n");
1249 warn++;
1250 } else
1251 disable_trace_probe(tp, TP_FLAG_TRACE);
1252
Srikar Dronamraju8ab83f52012-04-09 14:41:44 +05301253 ret = traceprobe_command("-:testprobe", create_trace_probe);
Masami Hiramatsu231e36f2010-01-14 00:12:12 -05001254 if (WARN_ON_ONCE(ret)) {
1255 pr_warning("error on deleting a probe.\n");
1256 warn++;
1257 }
Masami Hiramatsu413d37d2009-08-13 16:35:11 -04001258
Srikar Dronamraju8ab83f52012-04-09 14:41:44 +05301259 ret = traceprobe_command("-:testprobe2", create_trace_probe);
Masami Hiramatsu231e36f2010-01-14 00:12:12 -05001260 if (WARN_ON_ONCE(ret)) {
1261 pr_warning("error on deleting a probe.\n");
1262 warn++;
1263 }
1264
1265end:
Masami Hiramatsu7143f162011-06-27 16:26:36 +09001266 release_all_trace_probes();
Masami Hiramatsu231e36f2010-01-14 00:12:12 -05001267 if (warn)
1268 pr_cont("NG: Some tests are failed. Please check them.\n");
1269 else
1270 pr_cont("OK\n");
Masami Hiramatsu413d37d2009-08-13 16:35:11 -04001271 return 0;
1272}
1273
1274late_initcall(kprobe_trace_self_tests_init);
1275
1276#endif