trace_probe.c 27 KB

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