1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Common code for probe-based Dynamic events.
4 *
5 * This code was copied from kernel/trace/trace_kprobe.c written by
6 * Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
7 *
8 * Updates to make this generic:
9 * Copyright (C) IBM Corporation, 2010-2011
10 * Author: Srikar Dronamraju
11 */
12#define pr_fmt(fmt) "trace_probe: " fmt
13
14#include "trace_probe.h"
15
16static const char *reserved_field_names[] = {
17 "common_type",
18 "common_flags",
19 "common_preempt_count",
20 "common_pid",
21 "common_tgid",
22 FIELD_STRING_IP,
23 FIELD_STRING_RETIP,
24 FIELD_STRING_FUNC,
25};
26
27/* Printing in basic type function template */
28#define DEFINE_BASIC_PRINT_TYPE_FUNC(tname, type, fmt) \
29int PRINT_TYPE_FUNC_NAME(tname)(struct trace_seq *s, void *data, void *ent)\
30{ \
31 trace_seq_printf(s, fmt, *(type *)data); \
32 return !trace_seq_has_overflowed(s); \
33} \
34const char PRINT_TYPE_FMT_NAME(tname)[] = fmt;
35
36DEFINE_BASIC_PRINT_TYPE_FUNC(u8, u8, "%u")
37DEFINE_BASIC_PRINT_TYPE_FUNC(u16, u16, "%u")
38DEFINE_BASIC_PRINT_TYPE_FUNC(u32, u32, "%u")
39DEFINE_BASIC_PRINT_TYPE_FUNC(u64, u64, "%Lu")
40DEFINE_BASIC_PRINT_TYPE_FUNC(s8, s8, "%d")
41DEFINE_BASIC_PRINT_TYPE_FUNC(s16, s16, "%d")
42DEFINE_BASIC_PRINT_TYPE_FUNC(s32, s32, "%d")
43DEFINE_BASIC_PRINT_TYPE_FUNC(s64, s64, "%Ld")
44DEFINE_BASIC_PRINT_TYPE_FUNC(x8, u8, "0x%x")
45DEFINE_BASIC_PRINT_TYPE_FUNC(x16, u16, "0x%x")
46DEFINE_BASIC_PRINT_TYPE_FUNC(x32, u32, "0x%x")
47DEFINE_BASIC_PRINT_TYPE_FUNC(x64, u64, "0x%Lx")
48
49int PRINT_TYPE_FUNC_NAME(symbol)(struct trace_seq *s, void *data, void *ent)
50{
51 trace_seq_printf(s, "%pS", (void *)*(unsigned long *)data);
52 return !trace_seq_has_overflowed(s);
53}
54const char PRINT_TYPE_FMT_NAME(symbol)[] = "%pS";
55
56/* Print type function for string type */
57int PRINT_TYPE_FUNC_NAME(string)(struct trace_seq *s, void *data, void *ent)
58{
59 int len = *(u32 *)data >> 16;
60
61 if (!len)
62 trace_seq_puts(s, "(fault)");
63 else
64 trace_seq_printf(s, "\"%s\"",
65 (const char *)get_loc_data(data, ent));
66 return !trace_seq_has_overflowed(s);
67}
68
69const char PRINT_TYPE_FMT_NAME(string)[] = "\\\"%s\\\"";
70
71/* Fetch type information table */
72static const struct fetch_type probe_fetch_types[] = {
73 /* Special types */
74 __ASSIGN_FETCH_TYPE("string", string, string, sizeof(u32), 1,
75 "__data_loc char[]"),
76 /* Basic types */
77 ASSIGN_FETCH_TYPE(u8, u8, 0),
78 ASSIGN_FETCH_TYPE(u16, u16, 0),
79 ASSIGN_FETCH_TYPE(u32, u32, 0),
80 ASSIGN_FETCH_TYPE(u64, u64, 0),
81 ASSIGN_FETCH_TYPE(s8, u8, 1),
82 ASSIGN_FETCH_TYPE(s16, u16, 1),
83 ASSIGN_FETCH_TYPE(s32, u32, 1),
84 ASSIGN_FETCH_TYPE(s64, u64, 1),
85 ASSIGN_FETCH_TYPE_ALIAS(x8, u8, u8, 0),
86 ASSIGN_FETCH_TYPE_ALIAS(x16, u16, u16, 0),
87 ASSIGN_FETCH_TYPE_ALIAS(x32, u32, u32, 0),
88 ASSIGN_FETCH_TYPE_ALIAS(x64, u64, u64, 0),
89 ASSIGN_FETCH_TYPE_ALIAS(symbol, ADDR_FETCH_TYPE, ADDR_FETCH_TYPE, 0),
90
91 ASSIGN_FETCH_TYPE_END
92};
93
94static const struct fetch_type *find_fetch_type(const char *type)
95{
96 int i;
97
98 if (!type)
99 type = DEFAULT_FETCH_TYPE_STR;
100
101 /* Special case: bitfield */
102 if (*type == 'b') {
103 unsigned long bs;
104
105 type = strchr(type, '/');
106 if (!type)
107 goto fail;
108
109 type++;
110 if (kstrtoul(type, 0, &bs))
111 goto fail;
112
113 switch (bs) {
114 case 8:
115 return find_fetch_type("u8");
116 case 16:
117 return find_fetch_type("u16");
118 case 32:
119 return find_fetch_type("u32");
120 case 64:
121 return find_fetch_type("u64");
122 default:
123 goto fail;
124 }
125 }
126
127 for (i = 0; probe_fetch_types[i].name; i++) {
128 if (strcmp(type, probe_fetch_types[i].name) == 0)
129 return &probe_fetch_types[i];
130 }
131
132fail:
133 return NULL;
134}
135
136/* Split symbol and offset. */
137int traceprobe_split_symbol_offset(char *symbol, long *offset)
138{
139 char *tmp;
140 int ret;
141
142 if (!offset)
143 return -EINVAL;
144
145 tmp = strpbrk(symbol, "+-");
146 if (tmp) {
147 ret = kstrtol(tmp, 0, offset);
148 if (ret)
149 return ret;
150 *tmp = '\0';
151 } else
152 *offset = 0;
153
154 return 0;
155}
156
157/* @buf must has MAX_EVENT_NAME_LEN size */
158int traceprobe_parse_event_name(const char **pevent, const char **pgroup,
159 char *buf)
160{
161 const char *slash, *event = *pevent;
162 int len;
163
164 slash = strchr(event, '/');
165 if (slash) {
166 if (slash == event) {
167 pr_info("Group name is not specified\n");
168 return -EINVAL;
169 }
170 if (slash - event + 1 > MAX_EVENT_NAME_LEN) {
171 pr_info("Group name is too long\n");
172 return -E2BIG;
173 }
174 strlcpy(buf, event, slash - event + 1);
175 if (!is_good_name(buf)) {
176 pr_info("Group name must follow the same rules as C identifiers\n");
177 return -EINVAL;
178 }
179 *pgroup = buf;
180 *pevent = slash + 1;
181 event = *pevent;
182 }
183 len = strlen(event);
184 if (len == 0) {
185 pr_info("Event name is not specified\n");
186 return -EINVAL;
187 } else if (len > MAX_EVENT_NAME_LEN) {
188 pr_info("Event name is too long\n");
189 return -E2BIG;
190 }
191 if (!is_good_name(event)) {
192 pr_info("Event name must follow the same rules as C identifiers\n");
193 return -EINVAL;
194 }
195 return 0;
196}
197
198#define PARAM_MAX_STACK (THREAD_SIZE / sizeof(unsigned long))
199
200static int parse_probe_vars(char *arg, const struct fetch_type *t,
201 struct fetch_insn *code, unsigned int flags)
202{
203 unsigned long param;
204 int ret = 0;
205 int len;
206
207 if (strcmp(arg, "retval") == 0) {
208 if (flags & TPARG_FL_RETURN)
209 code->op = FETCH_OP_RETVAL;
210 else
211 ret = -EINVAL;
212 } else if ((len = str_has_prefix(arg, "stack"))) {
213 if (arg[len] == '\0') {
214 code->op = FETCH_OP_STACKP;
215 } else if (isdigit(arg[len])) {
216 ret = kstrtoul(arg + len, 10, &param);
217 if (ret || ((flags & TPARG_FL_KERNEL) &&
218 param > PARAM_MAX_STACK))
219 ret = -EINVAL;
220 else {
221 code->op = FETCH_OP_STACK;
222 code->param = (unsigned int)param;
223 }
224 } else
225 ret = -EINVAL;
226 } else if (strcmp(arg, "comm") == 0) {
227 code->op = FETCH_OP_COMM;
228#ifdef CONFIG_HAVE_FUNCTION_ARG_ACCESS_API
229 } else if (((flags & TPARG_FL_MASK) ==
230 (TPARG_FL_KERNEL | TPARG_FL_FENTRY)) &&
231 (len = str_has_prefix(arg, "arg"))) {
232 if (!isdigit(arg[len]))
233 return -EINVAL;
234 ret = kstrtoul(arg + len, 10, &param);
235 if (ret || !param || param > PARAM_MAX_STACK)
236 return -EINVAL;
237 code->op = FETCH_OP_ARG;
238 code->param = (unsigned int)param - 1;
239#endif
240 } else
241 ret = -EINVAL;
242
243 return ret;
244}
245
246/* Recursive argument parser */
247static int
248parse_probe_arg(char *arg, const struct fetch_type *type,
249 struct fetch_insn **pcode, struct fetch_insn *end,
250 unsigned int flags)
251{
252 struct fetch_insn *code = *pcode;
253 unsigned long param;
254 long offset = 0;
255 char *tmp;
256 int ret = 0;
257
258 switch (arg[0]) {
259 case '$':
260 ret = parse_probe_vars(arg + 1, type, code, flags);
261 break;
262
263 case '%': /* named register */
264 ret = regs_query_register_offset(arg + 1);
265 if (ret >= 0) {
266 code->op = FETCH_OP_REG;
267 code->param = (unsigned int)ret;
268 ret = 0;
269 }
270 break;
271
272 case '@': /* memory, file-offset or symbol */
273 if (isdigit(arg[1])) {
274 ret = kstrtoul(arg + 1, 0, &param);
275 if (ret)
276 break;
277 /* load address */
278 code->op = FETCH_OP_IMM;
279 code->immediate = param;
280 } else if (arg[1] == '+') {
281 /* kprobes don't support file offsets */
282 if (flags & TPARG_FL_KERNEL)
283 return -EINVAL;
284
285 ret = kstrtol(arg + 2, 0, &offset);
286 if (ret)
287 break;
288
289 code->op = FETCH_OP_FOFFS;
290 code->immediate = (unsigned long)offset; // imm64?
291 } else {
292 /* uprobes don't support symbols */
293 if (!(flags & TPARG_FL_KERNEL))
294 return -EINVAL;
295
296 /* Preserve symbol for updating */
297 code->op = FETCH_NOP_SYMBOL;
298 code->data = kstrdup(arg + 1, GFP_KERNEL);
299 if (!code->data)
300 return -ENOMEM;
301 if (++code == end)
302 return -E2BIG;
303
304 code->op = FETCH_OP_IMM;
305 code->immediate = 0;
306 }
307 /* These are fetching from memory */
308 if (++code == end)
309 return -E2BIG;
310 *pcode = code;
311 code->op = FETCH_OP_DEREF;
312 code->offset = offset;
313 break;
314
315 case '+': /* deref memory */
316 arg++; /* Skip '+', because kstrtol() rejects it. */
317 /* fall through */
318 case '-':
319 tmp = strchr(arg, '(');
320 if (!tmp)
321 return -EINVAL;
322
323 *tmp = '\0';
324 ret = kstrtol(arg, 0, &offset);
325 if (ret)
326 break;
327
328 arg = tmp + 1;
329 tmp = strrchr(arg, ')');
330
331 if (tmp) {
332 const struct fetch_type *t2 = find_fetch_type(NULL);
333
334 *tmp = '\0';
335 ret = parse_probe_arg(arg, t2, &code, end, flags);
336 if (ret)
337 break;
338 if (code->op == FETCH_OP_COMM)
339 return -EINVAL;
340 if (++code == end)
341 return -E2BIG;
342 *pcode = code;
343
344 code->op = FETCH_OP_DEREF;
345 code->offset = offset;
346 }
347 break;
348 }
349 if (!ret && code->op == FETCH_OP_NOP) {
350 /* Parsed, but do not find fetch method */
351 ret = -EINVAL;
352 }
353 return ret;
354}
355
356#define BYTES_TO_BITS(nb) ((BITS_PER_LONG * (nb)) / sizeof(long))
357
358/* Bitfield type needs to be parsed into a fetch function */
359static int __parse_bitfield_probe_arg(const char *bf,
360 const struct fetch_type *t,
361 struct fetch_insn **pcode)
362{
363 struct fetch_insn *code = *pcode;
364 unsigned long bw, bo;
365 char *tail;
366
367 if (*bf != 'b')
368 return 0;
369
370 bw = simple_strtoul(bf + 1, &tail, 0); /* Use simple one */
371
372 if (bw == 0 || *tail != '@')
373 return -EINVAL;
374
375 bf = tail + 1;
376 bo = simple_strtoul(bf, &tail, 0);
377
378 if (tail == bf || *tail != '/')
379 return -EINVAL;
380 code++;
381 if (code->op != FETCH_OP_NOP)
382 return -E2BIG;
383 *pcode = code;
384
385 code->op = FETCH_OP_MOD_BF;
386 code->lshift = BYTES_TO_BITS(t->size) - (bw + bo);
387 code->rshift = BYTES_TO_BITS(t->size) - bw;
388 code->basesize = t->size;
389
390 return (BYTES_TO_BITS(t->size) < (bw + bo)) ? -EINVAL : 0;
391}
392
393/* String length checking wrapper */
394static int traceprobe_parse_probe_arg_body(char *arg, ssize_t *size,
395 struct probe_arg *parg, unsigned int flags)
396{
397 struct fetch_insn *code, *scode, *tmp = NULL;
398 char *t, *t2;
399 int ret, len;
400
401 if (strlen(arg) > MAX_ARGSTR_LEN) {
402 pr_info("Argument is too long.: %s\n", arg);
403 return -ENOSPC;
404 }
405 parg->comm = kstrdup(arg, GFP_KERNEL);
406 if (!parg->comm) {
407 pr_info("Failed to allocate memory for command '%s'.\n", arg);
408 return -ENOMEM;
409 }
410 t = strchr(arg, ':');
411 if (t) {
412 *t = '\0';
413 t2 = strchr(++t, '[');
414 if (t2) {
415 *t2 = '\0';
416 parg->count = simple_strtoul(t2 + 1, &t2, 0);
417 if (strcmp(t2, "]") || parg->count == 0)
418 return -EINVAL;
419 if (parg->count > MAX_ARRAY_LEN)
420 return -E2BIG;
421 }
422 }
423 /*
424 * The default type of $comm should be "string", and it can't be
425 * dereferenced.
426 */
427 if (!t && strcmp(arg, "$comm") == 0)
428 parg->type = find_fetch_type("string");
429 else
430 parg->type = find_fetch_type(t);
431 if (!parg->type) {
432 pr_info("Unsupported type: %s\n", t);
433 return -EINVAL;
434 }
435 parg->offset = *size;
436 *size += parg->type->size * (parg->count ?: 1);
437
438 if (parg->count) {
439 len = strlen(parg->type->fmttype) + 6;
440 parg->fmt = kmalloc(len, GFP_KERNEL);
441 if (!parg->fmt)
442 return -ENOMEM;
443 snprintf(parg->fmt, len, "%s[%d]", parg->type->fmttype,
444 parg->count);
445 }
446
447 code = tmp = kzalloc(sizeof(*code) * FETCH_INSN_MAX, GFP_KERNEL);
448 if (!code)
449 return -ENOMEM;
450 code[FETCH_INSN_MAX - 1].op = FETCH_OP_END;
451
452 ret = parse_probe_arg(arg, parg->type, &code, &code[FETCH_INSN_MAX - 1],
453 flags);
454 if (ret)
455 goto fail;
456
457 /* Store operation */
458 if (!strcmp(parg->type->name, "string")) {
459 if (code->op != FETCH_OP_DEREF && code->op != FETCH_OP_IMM &&
460 code->op != FETCH_OP_COMM) {
461 pr_info("string only accepts memory or address.\n");
462 ret = -EINVAL;
463 goto fail;
464 }
465 if (code->op != FETCH_OP_DEREF || parg->count) {
466 /*
467 * IMM and COMM is pointing actual address, those must
468 * be kept, and if parg->count != 0, this is an array
469 * of string pointers instead of string address itself.
470 */
471 code++;
472 if (code->op != FETCH_OP_NOP) {
473 ret = -E2BIG;
474 goto fail;
475 }
476 }
477 code->op = FETCH_OP_ST_STRING; /* In DEREF case, replace it */
478 code->size = parg->type->size;
479 parg->dynamic = true;
480 } else if (code->op == FETCH_OP_DEREF) {
481 code->op = FETCH_OP_ST_MEM;
482 code->size = parg->type->size;
483 } else {
484 code++;
485 if (code->op != FETCH_OP_NOP) {
486 ret = -E2BIG;
487 goto fail;
488 }
489 code->op = FETCH_OP_ST_RAW;
490 code->size = parg->type->size;
491 }
492 scode = code;
493 /* Modify operation */
494 if (t != NULL) {
495 ret = __parse_bitfield_probe_arg(t, parg->type, &code);
496 if (ret)
497 goto fail;
498 }
499 /* Loop(Array) operation */
500 if (parg->count) {
501 if (scode->op != FETCH_OP_ST_MEM &&
502 scode->op != FETCH_OP_ST_STRING) {
503 pr_info("array only accepts memory or address\n");
504 ret = -EINVAL;
505 goto fail;
506 }
507 code++;
508 if (code->op != FETCH_OP_NOP) {
509 ret = -E2BIG;
510 goto fail;
511 }
512 code->op = FETCH_OP_LP_ARRAY;
513 code->param = parg->count;
514 }
515 code++;
516 code->op = FETCH_OP_END;
517
518 /* Shrink down the code buffer */
519 parg->code = kzalloc(sizeof(*code) * (code - tmp + 1), GFP_KERNEL);
520 if (!parg->code)
521 ret = -ENOMEM;
522 else
523 memcpy(parg->code, tmp, sizeof(*code) * (code - tmp + 1));
524
525fail:
526 if (ret) {
527 for (code = tmp; code < tmp + FETCH_INSN_MAX; code++)
528 if (code->op == FETCH_NOP_SYMBOL)
529 kfree(code->data);
530 }
531 kfree(tmp);
532
533 return ret;
534}
535
536/* Return 1 if name is reserved or already used by another argument */
537static int traceprobe_conflict_field_name(const char *name,
538 struct probe_arg *args, int narg)
539{
540 int i;
541
542 for (i = 0; i < ARRAY_SIZE(reserved_field_names); i++)
543 if (strcmp(reserved_field_names[i], name) == 0)
544 return 1;
545
546 for (i = 0; i < narg; i++)
547 if (strcmp(args[i].name, name) == 0)
548 return 1;
549
550 return 0;
551}
552
553int traceprobe_parse_probe_arg(struct trace_probe *tp, int i, char *arg,
554 unsigned int flags)
555{
556 struct probe_arg *parg = &tp->args[i];
557 char *body;
558 int ret;
559
560 /* Increment count for freeing args in error case */
561 tp->nr_args++;
562
563 body = strchr(arg, '=');
564 if (body) {
565 if (body - arg > MAX_ARG_NAME_LEN || body == arg)
566 return -EINVAL;
567 parg->name = kmemdup_nul(arg, body - arg, GFP_KERNEL);
568 body++;
569 } else {
570 /* If argument name is omitted, set "argN" */
571 parg->name = kasprintf(GFP_KERNEL, "arg%d", i + 1);
572 body = arg;
573 }
574 if (!parg->name)
575 return -ENOMEM;
576
577 if (!is_good_name(parg->name)) {
578 pr_info("Invalid argument[%d] name: %s\n",
579 i, parg->name);
580 return -EINVAL;
581 }
582
583 if (traceprobe_conflict_field_name(parg->name, tp->args, i)) {
584 pr_info("Argument[%d]: '%s' conflicts with another field.\n",
585 i, parg->name);
586 return -EINVAL;
587 }
588
589 /* Parse fetch argument */
590 ret = traceprobe_parse_probe_arg_body(body, &tp->size, parg, flags);
591 if (ret)
592 pr_info("Parse error at argument[%d]. (%d)\n", i, ret);
593 return ret;
594}
595
596void traceprobe_free_probe_arg(struct probe_arg *arg)
597{
598 struct fetch_insn *code = arg->code;
599
600 while (code && code->op != FETCH_OP_END) {
601 if (code->op == FETCH_NOP_SYMBOL)
602 kfree(code->data);
603 code++;
604 }
605 kfree(arg->code);
606 kfree(arg->name);
607 kfree(arg->comm);
608 kfree(arg->fmt);
609}
610
611int traceprobe_update_arg(struct probe_arg *arg)
612{
613 struct fetch_insn *code = arg->code;
614 long offset;
615 char *tmp;
616 char c;
617 int ret = 0;
618
619 while (code && code->op != FETCH_OP_END) {
620 if (code->op == FETCH_NOP_SYMBOL) {
621 if (code[1].op != FETCH_OP_IMM)
622 return -EINVAL;
623
624 tmp = strpbrk(code->data, "+-");
625 if (tmp)
626 c = *tmp;
627 ret = traceprobe_split_symbol_offset(code->data,
628 &offset);
629 if (ret)
630 return ret;
631
632 code[1].immediate =
633 (unsigned long)kallsyms_lookup_name(code->data);
634 if (tmp)
635 *tmp = c;
636 if (!code[1].immediate)
637 return -ENOENT;
638 code[1].immediate += offset;
639 }
640 code++;
641 }
642 return 0;
643}
644
645/* When len=0, we just calculate the needed length */
646#define LEN_OR_ZERO (len ? len - pos : 0)
647static int __set_print_fmt(struct trace_probe *tp, char *buf, int len,
648 bool is_return)
649{
650 struct probe_arg *parg;
651 int i, j;
652 int pos = 0;
653 const char *fmt, *arg;
654
655 if (!is_return) {
656 fmt = "(%lx)";
657 arg = "REC->" FIELD_STRING_IP;
658 } else {
659 fmt = "(%lx <- %lx)";
660 arg = "REC->" FIELD_STRING_FUNC ", REC->" FIELD_STRING_RETIP;
661 }
662
663 pos += snprintf(buf + pos, LEN_OR_ZERO, "\"%s", fmt);
664
665 for (i = 0; i < tp->nr_args; i++) {
666 parg = tp->args + i;
667 pos += snprintf(buf + pos, LEN_OR_ZERO, " %s=", parg->name);
668 if (parg->count) {
669 pos += snprintf(buf + pos, LEN_OR_ZERO, "{%s",
670 parg->type->fmt);
671 for (j = 1; j < parg->count; j++)
672 pos += snprintf(buf + pos, LEN_OR_ZERO, ",%s",
673 parg->type->fmt);
674 pos += snprintf(buf + pos, LEN_OR_ZERO, "}");
675 } else
676 pos += snprintf(buf + pos, LEN_OR_ZERO, "%s",
677 parg->type->fmt);
678 }
679
680 pos += snprintf(buf + pos, LEN_OR_ZERO, "\", %s", arg);
681
682 for (i = 0; i < tp->nr_args; i++) {
683 parg = tp->args + i;
684 if (parg->count) {
685 if (strcmp(parg->type->name, "string") == 0)
686 fmt = ", __get_str(%s[%d])";
687 else
688 fmt = ", REC->%s[%d]";
689 for (j = 0; j < parg->count; j++)
690 pos += snprintf(buf + pos, LEN_OR_ZERO,
691 fmt, parg->name, j);
692 } else {
693 if (strcmp(parg->type->name, "string") == 0)
694 fmt = ", __get_str(%s)";
695 else
696 fmt = ", REC->%s";
697 pos += snprintf(buf + pos, LEN_OR_ZERO,
698 fmt, parg->name);
699 }
700 }
701
702 /* return the length of print_fmt */
703 return pos;
704}
705#undef LEN_OR_ZERO
706
707int traceprobe_set_print_fmt(struct trace_probe *tp, bool is_return)
708{
709 int len;
710 char *print_fmt;
711
712 /* First: called with 0 length to calculate the needed length */
713 len = __set_print_fmt(tp, NULL, 0, is_return);
714 print_fmt = kmalloc(len + 1, GFP_KERNEL);
715 if (!print_fmt)
716 return -ENOMEM;
717
718 /* Second: actually write the @print_fmt */
719 __set_print_fmt(tp, print_fmt, len + 1, is_return);
720 tp->call.print_fmt = print_fmt;
721
722 return 0;
723}
724
725int traceprobe_define_arg_fields(struct trace_event_call *event_call,
726 size_t offset, struct trace_probe *tp)
727{
728 int ret, i;
729
730 /* Set argument names as fields */
731 for (i = 0; i < tp->nr_args; i++) {
732 struct probe_arg *parg = &tp->args[i];
733 const char *fmt = parg->type->fmttype;
734 int size = parg->type->size;
735
736 if (parg->fmt)
737 fmt = parg->fmt;
738 if (parg->count)
739 size *= parg->count;
740 ret = trace_define_field(event_call, fmt, parg->name,
741 offset + parg->offset, size,
742 parg->type->is_signed,
743 FILTER_OTHER);
744 if (ret)
745 return ret;
746 }
747 return 0;
748}
749