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