?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kvm: x86: optimize dr6 restore
[linux/fpc-iii.git] / kernel / trace / trace_probe.c
blobe99c3ce7aa6541144da74e50a011e230bd25e0b0
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
16 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) \
29 int PRINT_TYPE_FUNC_NAME(tname)(struct trace_seq *s, const char *name, \
30 void *data, void *ent) \
31 { \
32 trace_seq_printf(s, " %s=" fmt, name, *(type *)data); \
33 return !trace_seq_has_overflowed(s); \
34 } \
35 const char PRINT_TYPE_FMT_NAME(tname)[] = fmt; \
36 NOKPROBE_SYMBOL(PRINT_TYPE_FUNC_NAME(tname));
37
38 DEFINE_BASIC_PRINT_TYPE_FUNC(u8, u8, "%u")
39 DEFINE_BASIC_PRINT_TYPE_FUNC(u16, u16, "%u")
40 DEFINE_BASIC_PRINT_TYPE_FUNC(u32, u32, "%u")
41 DEFINE_BASIC_PRINT_TYPE_FUNC(u64, u64, "%Lu")
42 DEFINE_BASIC_PRINT_TYPE_FUNC(s8, s8, "%d")
43 DEFINE_BASIC_PRINT_TYPE_FUNC(s16, s16, "%d")
44 DEFINE_BASIC_PRINT_TYPE_FUNC(s32, s32, "%d")
45 DEFINE_BASIC_PRINT_TYPE_FUNC(s64, s64, "%Ld")
46 DEFINE_BASIC_PRINT_TYPE_FUNC(x8, u8, "0x%x")
47 DEFINE_BASIC_PRINT_TYPE_FUNC(x16, u16, "0x%x")
48 DEFINE_BASIC_PRINT_TYPE_FUNC(x32, u32, "0x%x")
49 DEFINE_BASIC_PRINT_TYPE_FUNC(x64, u64, "0x%Lx")
50
51 /* Print type function for string type */
52 int PRINT_TYPE_FUNC_NAME(string)(struct trace_seq *s, const char *name,
53 void *data, void *ent)
54 {
55 int len = *(u32 *)data >> 16;
56
57 if (!len)
58 trace_seq_printf(s, " %s=(fault)", name);
59 else
60 trace_seq_printf(s, " %s=\"%s\"", name,
61 (const char *)get_loc_data(data, ent));
62 return !trace_seq_has_overflowed(s);
63 }
64 NOKPROBE_SYMBOL(PRINT_TYPE_FUNC_NAME(string));
65
66 const char PRINT_TYPE_FMT_NAME(string)[] = "\\\"%s\\\"";
67
68 #define CHECK_FETCH_FUNCS(method, fn) \
69 (((FETCH_FUNC_NAME(method, u8) == fn) || \
70 (FETCH_FUNC_NAME(method, u16) == fn) || \
71 (FETCH_FUNC_NAME(method, u32) == fn) || \
72 (FETCH_FUNC_NAME(method, u64) == fn) || \
73 (FETCH_FUNC_NAME(method, string) == fn) || \
74 (FETCH_FUNC_NAME(method, string_size) == fn)) \
75 && (fn != NULL))
76
77 /* Data fetch function templates */
78 #define DEFINE_FETCH_reg(type) \
79 void FETCH_FUNC_NAME(reg, type)(struct pt_regs *regs, void *offset, void *dest) \
80 { \
81 *(type *)dest = (type)regs_get_register(regs, \
82 (unsigned int)((unsigned long)offset)); \
83 } \
84 NOKPROBE_SYMBOL(FETCH_FUNC_NAME(reg, type));
85 DEFINE_BASIC_FETCH_FUNCS(reg)
86 /* No string on the register */
87 #define fetch_reg_string NULL
88 #define fetch_reg_string_size NULL
89
90 #define DEFINE_FETCH_retval(type) \
91 void FETCH_FUNC_NAME(retval, type)(struct pt_regs *regs, \
92 void *dummy, void *dest) \
93 { \
94 *(type *)dest = (type)regs_return_value(regs); \
95 } \
96 NOKPROBE_SYMBOL(FETCH_FUNC_NAME(retval, type));
97 DEFINE_BASIC_FETCH_FUNCS(retval)
98 /* No string on the retval */
99 #define fetch_retval_string NULL
100 #define fetch_retval_string_size NULL
101
102 /* Dereference memory access function */
103 struct deref_fetch_param {
104 struct fetch_param orig;
105 long offset;
106 fetch_func_t fetch;
107 fetch_func_t fetch_size;
108 };
109
110 #define DEFINE_FETCH_deref(type) \
111 void FETCH_FUNC_NAME(deref, type)(struct pt_regs *regs, \
112 void *data, void *dest) \
113 { \
114 struct deref_fetch_param *dprm = data; \
115 unsigned long addr; \
116 call_fetch(&dprm->orig, regs, &addr); \
117 if (addr) { \
118 addr += dprm->offset; \
119 dprm->fetch(regs, (void *)addr, dest); \
120 } else \
121 *(type *)dest = 0; \
122 } \
123 NOKPROBE_SYMBOL(FETCH_FUNC_NAME(deref, type));
124 DEFINE_BASIC_FETCH_FUNCS(deref)
125 DEFINE_FETCH_deref(string)
126
127 void FETCH_FUNC_NAME(deref, string_size)(struct pt_regs *regs,
128 void *data, void *dest)
129 {
130 struct deref_fetch_param *dprm = data;
131 unsigned long addr;
132
133 call_fetch(&dprm->orig, regs, &addr);
134 if (addr && dprm->fetch_size) {
135 addr += dprm->offset;
136 dprm->fetch_size(regs, (void *)addr, dest);
137 } else
138 *(string_size *)dest = 0;
139 }
140 NOKPROBE_SYMBOL(FETCH_FUNC_NAME(deref, string_size));
141
142 static void update_deref_fetch_param(struct deref_fetch_param *data)
143 {
144 if (CHECK_FETCH_FUNCS(deref, data->orig.fn))
145 update_deref_fetch_param(data->orig.data);
146 else if (CHECK_FETCH_FUNCS(symbol, data->orig.fn))
147 update_symbol_cache(data->orig.data);
148 }
149 NOKPROBE_SYMBOL(update_deref_fetch_param);
150
151 static void free_deref_fetch_param(struct deref_fetch_param *data)
152 {
153 if (CHECK_FETCH_FUNCS(deref, data->orig.fn))
154 free_deref_fetch_param(data->orig.data);
155 else if (CHECK_FETCH_FUNCS(symbol, data->orig.fn))
156 free_symbol_cache(data->orig.data);
157 kfree(data);
158 }
159 NOKPROBE_SYMBOL(free_deref_fetch_param);
160
161 /* Bitfield fetch function */
162 struct bitfield_fetch_param {
163 struct fetch_param orig;
164 unsigned char hi_shift;
165 unsigned char low_shift;
166 };
167
168 #define DEFINE_FETCH_bitfield(type) \
169 void FETCH_FUNC_NAME(bitfield, type)(struct pt_regs *regs, \
170 void *data, void *dest) \
171 { \
172 struct bitfield_fetch_param *bprm = data; \
173 type buf = 0; \
174 call_fetch(&bprm->orig, regs, &buf); \
175 if (buf) { \
176 buf <<= bprm->hi_shift; \
177 buf >>= bprm->low_shift; \
178 } \
179 *(type *)dest = buf; \
180 } \
181 NOKPROBE_SYMBOL(FETCH_FUNC_NAME(bitfield, type));
182 DEFINE_BASIC_FETCH_FUNCS(bitfield)
183 #define fetch_bitfield_string NULL
184 #define fetch_bitfield_string_size NULL
185
186 static void
187 update_bitfield_fetch_param(struct bitfield_fetch_param *data)
188 {
189 /*
190 * Don't check the bitfield itself, because this must be the
191 * last fetch function.
192 */
193 if (CHECK_FETCH_FUNCS(deref, data->orig.fn))
194 update_deref_fetch_param(data->orig.data);
195 else if (CHECK_FETCH_FUNCS(symbol, data->orig.fn))
196 update_symbol_cache(data->orig.data);
197 }
198
199 static void
200 free_bitfield_fetch_param(struct bitfield_fetch_param *data)
201 {
202 /*
203 * Don't check the bitfield itself, because this must be the
204 * last fetch function.
205 */
206 if (CHECK_FETCH_FUNCS(deref, data->orig.fn))
207 free_deref_fetch_param(data->orig.data);
208 else if (CHECK_FETCH_FUNCS(symbol, data->orig.fn))
209 free_symbol_cache(data->orig.data);
210
211 kfree(data);
212 }
213
214 void FETCH_FUNC_NAME(comm, string)(struct pt_regs *regs,
215 void *data, void *dest)
216 {
217 int maxlen = get_rloc_len(*(u32 *)dest);
218 u8 *dst = get_rloc_data(dest);
219 long ret;
220
221 if (!maxlen)
222 return;
223
224 ret = strlcpy(dst, current->comm, maxlen);
225 *(u32 *)dest = make_data_rloc(ret, get_rloc_offs(*(u32 *)dest));
226 }
227 NOKPROBE_SYMBOL(FETCH_FUNC_NAME(comm, string));
228
229 void FETCH_FUNC_NAME(comm, string_size)(struct pt_regs *regs,
230 void *data, void *dest)
231 {
232 *(u32 *)dest = strlen(current->comm) + 1;
233 }
234 NOKPROBE_SYMBOL(FETCH_FUNC_NAME(comm, string_size));
235
236 static const struct fetch_type *find_fetch_type(const char *type,
237 const struct fetch_type *ftbl)
238 {
239 int i;
240
241 if (!type)
242 type = DEFAULT_FETCH_TYPE_STR;
243
244 /* Special case: bitfield */
245 if (*type == 'b') {
246 unsigned long bs;
247
248 type = strchr(type, '/');
249 if (!type)
250 goto fail;
251
252 type++;
253 if (kstrtoul(type, 0, &bs))
254 goto fail;
255
256 switch (bs) {
257 case 8:
258 return find_fetch_type("u8", ftbl);
259 case 16:
260 return find_fetch_type("u16", ftbl);
261 case 32:
262 return find_fetch_type("u32", ftbl);
263 case 64:
264 return find_fetch_type("u64", ftbl);
265 default:
266 goto fail;
267 }
268 }
269
270 for (i = 0; ftbl[i].name; i++) {
271 if (strcmp(type, ftbl[i].name) == 0)
272 return &ftbl[i];
273 }
274
275 fail:
276 return NULL;
277 }
278
279 /* Special function : only accept unsigned long */
280 static void fetch_kernel_stack_address(struct pt_regs *regs, void *dummy, void *dest)
281 {
282 *(unsigned long *)dest = kernel_stack_pointer(regs);
283 }
284 NOKPROBE_SYMBOL(fetch_kernel_stack_address);
285
286 static void fetch_user_stack_address(struct pt_regs *regs, void *dummy, void *dest)
287 {
288 *(unsigned long *)dest = user_stack_pointer(regs);
289 }
290 NOKPROBE_SYMBOL(fetch_user_stack_address);
291
292 static fetch_func_t get_fetch_size_function(const struct fetch_type *type,
293 fetch_func_t orig_fn,
294 const struct fetch_type *ftbl)
295 {
296 int i;
297
298 if (type != &ftbl[FETCH_TYPE_STRING])
299 return NULL; /* Only string type needs size function */
300
301 for (i = 0; i < FETCH_MTD_END; i++)
302 if (type->fetch[i] == orig_fn)
303 return ftbl[FETCH_TYPE_STRSIZE].fetch[i];
304
305 WARN_ON(1); /* This should not happen */
306
307 return NULL;
308 }
309
310 /* Split symbol and offset. */
311 int traceprobe_split_symbol_offset(char *symbol, long *offset)
312 {
313 char *tmp;
314 int ret;
315
316 if (!offset)
317 return -EINVAL;
318
319 tmp = strpbrk(symbol, "+-");
320 if (tmp) {
321 ret = kstrtol(tmp, 0, offset);
322 if (ret)
323 return ret;
324 *tmp = '\0';
325 } else
326 *offset = 0;
327
328 return 0;
329 }
330
331 #define PARAM_MAX_STACK (THREAD_SIZE / sizeof(unsigned long))
332
333 static int parse_probe_vars(char *arg, const struct fetch_type *t,
334 struct fetch_param *f, bool is_return,
335 bool is_kprobe)
336 {
337 int ret = 0;
338 unsigned long param;
339
340 if (strcmp(arg, "retval") == 0) {
341 if (is_return)
342 f->fn = t->fetch[FETCH_MTD_retval];
343 else
344 ret = -EINVAL;
345 } else if (strncmp(arg, "stack", 5) == 0) {
346 if (arg[5] == '\0') {
347 if (strcmp(t->name, DEFAULT_FETCH_TYPE_STR))
348 return -EINVAL;
349
350 if (is_kprobe)
351 f->fn = fetch_kernel_stack_address;
352 else
353 f->fn = fetch_user_stack_address;
354 } else if (isdigit(arg[5])) {
355 ret = kstrtoul(arg + 5, 10, &param);
356 if (ret || (is_kprobe && param > PARAM_MAX_STACK))
357 ret = -EINVAL;
358 else {
359 f->fn = t->fetch[FETCH_MTD_stack];
360 f->data = (void *)param;
361 }
362 } else
363 ret = -EINVAL;
364 } else if (strcmp(arg, "comm") == 0) {
365 if (strcmp(t->name, "string") != 0 &&
366 strcmp(t->name, "string_size") != 0)
367 return -EINVAL;
368 f->fn = t->fetch[FETCH_MTD_comm];
369 } else
370 ret = -EINVAL;
371
372 return ret;
373 }
374
375 /* Recursive argument parser */
376 static int parse_probe_arg(char *arg, const struct fetch_type *t,
377 struct fetch_param *f, bool is_return, bool is_kprobe,
378 const struct fetch_type *ftbl)
379 {
380 unsigned long param;
381 long offset;
382 char *tmp;
383 int ret = 0;
384
385 switch (arg[0]) {
386 case '$':
387 ret = parse_probe_vars(arg + 1, t, f, is_return, is_kprobe);
388 break;
389
390 case '%': /* named register */
391 ret = regs_query_register_offset(arg + 1);
392 if (ret >= 0) {
393 f->fn = t->fetch[FETCH_MTD_reg];
394 f->data = (void *)(unsigned long)ret;
395 ret = 0;
396 }
397 break;
398
399 case '@': /* memory, file-offset or symbol */
400 if (isdigit(arg[1])) {
401 ret = kstrtoul(arg + 1, 0, &param);
402 if (ret)
403 break;
404
405 f->fn = t->fetch[FETCH_MTD_memory];
406 f->data = (void *)param;
407 } else if (arg[1] == '+') {
408 /* kprobes don't support file offsets */
409 if (is_kprobe)
410 return -EINVAL;
411
412 ret = kstrtol(arg + 2, 0, &offset);
413 if (ret)
414 break;
415
416 f->fn = t->fetch[FETCH_MTD_file_offset];
417 f->data = (void *)offset;
418 } else {
419 /* uprobes don't support symbols */
420 if (!is_kprobe)
421 return -EINVAL;
422
423 ret = traceprobe_split_symbol_offset(arg + 1, &offset);
424 if (ret)
425 break;
426
427 f->data = alloc_symbol_cache(arg + 1, offset);
428 if (f->data)
429 f->fn = t->fetch[FETCH_MTD_symbol];
430 }
431 break;
432
433 case '+': /* deref memory */
434 arg++; /* Skip '+', because kstrtol() rejects it. */
435 case '-':
436 tmp = strchr(arg, '(');
437 if (!tmp)
438 break;
439
440 *tmp = '\0';
441 ret = kstrtol(arg, 0, &offset);
442
443 if (ret)
444 break;
445
446 arg = tmp + 1;
447 tmp = strrchr(arg, ')');
448
449 if (tmp) {
450 struct deref_fetch_param *dprm;
451 const struct fetch_type *t2;
452
453 t2 = find_fetch_type(NULL, ftbl);
454 *tmp = '\0';
455 dprm = kzalloc(sizeof(struct deref_fetch_param), GFP_KERNEL);
456
457 if (!dprm)
458 return -ENOMEM;
459
460 dprm->offset = offset;
461 dprm->fetch = t->fetch[FETCH_MTD_memory];
462 dprm->fetch_size = get_fetch_size_function(t,
463 dprm->fetch, ftbl);
464 ret = parse_probe_arg(arg, t2, &dprm->orig, is_return,
465 is_kprobe, ftbl);
466 if (ret)
467 kfree(dprm);
468 else {
469 f->fn = t->fetch[FETCH_MTD_deref];
470 f->data = (void *)dprm;
471 }
472 }
473 break;
474 }
475 if (!ret && !f->fn) { /* Parsed, but do not find fetch method */
476 pr_info("%s type has no corresponding fetch method.\n", t->name);
477 ret = -EINVAL;
478 }
479
480 return ret;
481 }
482
483 #define BYTES_TO_BITS(nb) ((BITS_PER_LONG * (nb)) / sizeof(long))
484
485 /* Bitfield type needs to be parsed into a fetch function */
486 static int __parse_bitfield_probe_arg(const char *bf,
487 const struct fetch_type *t,
488 struct fetch_param *f)
489 {
490 struct bitfield_fetch_param *bprm;
491 unsigned long bw, bo;
492 char *tail;
493
494 if (*bf != 'b')
495 return 0;
496
497 bprm = kzalloc(sizeof(*bprm), GFP_KERNEL);
498 if (!bprm)
499 return -ENOMEM;
500
501 bprm->orig = *f;
502 f->fn = t->fetch[FETCH_MTD_bitfield];
503 f->data = (void *)bprm;
504 bw = simple_strtoul(bf + 1, &tail, 0); /* Use simple one */
505
506 if (bw == 0 || *tail != '@')
507 return -EINVAL;
508
509 bf = tail + 1;
510 bo = simple_strtoul(bf, &tail, 0);
511
512 if (tail == bf || *tail != '/')
513 return -EINVAL;
514
515 bprm->hi_shift = BYTES_TO_BITS(t->size) - (bw + bo);
516 bprm->low_shift = bprm->hi_shift + bo;
517
518 return (BYTES_TO_BITS(t->size) < (bw + bo)) ? -EINVAL : 0;
519 }
520
521 /* String length checking wrapper */
522 int traceprobe_parse_probe_arg(char *arg, ssize_t *size,
523 struct probe_arg *parg, bool is_return, bool is_kprobe,
524 const struct fetch_type *ftbl)
525 {
526 const char *t;
527 int ret;
528
529 if (strlen(arg) > MAX_ARGSTR_LEN) {
530 pr_info("Argument is too long.: %s\n", arg);
531 return -ENOSPC;
532 }
533 parg->comm = kstrdup(arg, GFP_KERNEL);
534 if (!parg->comm) {
535 pr_info("Failed to allocate memory for command '%s'.\n", arg);
536 return -ENOMEM;
537 }
538 t = strchr(parg->comm, ':');
539 if (t) {
540 arg[t - parg->comm] = '\0';
541 t++;
542 }
543 /*
544 * The default type of $comm should be "string", and it can't be
545 * dereferenced.
546 */
547 if (!t && strcmp(arg, "$comm") == 0)
548 t = "string";
549 parg->type = find_fetch_type(t, ftbl);
550 if (!parg->type) {
551 pr_info("Unsupported type: %s\n", t);
552 return -EINVAL;
553 }
554 parg->offset = *size;
555 *size += parg->type->size;
556 ret = parse_probe_arg(arg, parg->type, &parg->fetch, is_return,
557 is_kprobe, ftbl);
558
559 if (ret >= 0 && t != NULL)
560 ret = __parse_bitfield_probe_arg(t, parg->type, &parg->fetch);
561
562 if (ret >= 0) {
563 parg->fetch_size.fn = get_fetch_size_function(parg->type,
564 parg->fetch.fn,
565 ftbl);
566 parg->fetch_size.data = parg->fetch.data;
567 }
568
569 return ret;
570 }
571
572 /* Return 1 if name is reserved or already used by another argument */
573 int traceprobe_conflict_field_name(const char *name,
574 struct probe_arg *args, int narg)
575 {
576 int i;
577
578 for (i = 0; i < ARRAY_SIZE(reserved_field_names); i++)
579 if (strcmp(reserved_field_names[i], name) == 0)
580 return 1;
581
582 for (i = 0; i < narg; i++)
583 if (strcmp(args[i].name, name) == 0)
584 return 1;
585
586 return 0;
587 }
588
589 void traceprobe_update_arg(struct probe_arg *arg)
590 {
591 if (CHECK_FETCH_FUNCS(bitfield, arg->fetch.fn))
592 update_bitfield_fetch_param(arg->fetch.data);
593 else if (CHECK_FETCH_FUNCS(deref, arg->fetch.fn))
594 update_deref_fetch_param(arg->fetch.data);
595 else if (CHECK_FETCH_FUNCS(symbol, arg->fetch.fn))
596 update_symbol_cache(arg->fetch.data);
597 }
598
599 void traceprobe_free_probe_arg(struct probe_arg *arg)
600 {
601 if (CHECK_FETCH_FUNCS(bitfield, arg->fetch.fn))
602 free_bitfield_fetch_param(arg->fetch.data);
603 else if (CHECK_FETCH_FUNCS(deref, arg->fetch.fn))
604 free_deref_fetch_param(arg->fetch.data);
605 else if (CHECK_FETCH_FUNCS(symbol, arg->fetch.fn))
606 free_symbol_cache(arg->fetch.data);
607
608 kfree(arg->name);
609 kfree(arg->comm);
610 }
611
612 static int __set_print_fmt(struct trace_probe *tp, char *buf, int len,
613 bool is_return)
614 {
615 int i;
616 int pos = 0;
617
618 const char *fmt, *arg;
619
620 if (!is_return) {
621 fmt = "(%lx)";
622 arg = "REC->" FIELD_STRING_IP;
623 } else {
624 fmt = "(%lx <- %lx)";
625 arg = "REC->" FIELD_STRING_FUNC ", REC->" FIELD_STRING_RETIP;
626 }
627
628 /* When len=0, we just calculate the needed length */
629 #define LEN_OR_ZERO (len ? len - pos : 0)
630
631 pos += snprintf(buf + pos, LEN_OR_ZERO, "\"%s", fmt);
632
633 for (i = 0; i < tp->nr_args; i++) {
634 pos += snprintf(buf + pos, LEN_OR_ZERO, " %s=%s",
635 tp->args[i].name, tp->args[i].type->fmt);
636 }
637
638 pos += snprintf(buf + pos, LEN_OR_ZERO, "\", %s", arg);
639
640 for (i = 0; i < tp->nr_args; i++) {
641 if (strcmp(tp->args[i].type->name, "string") == 0)
642 pos += snprintf(buf + pos, LEN_OR_ZERO,
643 ", __get_str(%s)",
644 tp->args[i].name);
645 else
646 pos += snprintf(buf + pos, LEN_OR_ZERO, ", REC->%s",
647 tp->args[i].name);
648 }
649
650 #undef LEN_OR_ZERO
651
652 /* return the length of print_fmt */
653 return pos;
654 }
655
656 int set_print_fmt(struct trace_probe *tp, bool is_return)
657 {
658 int len;
659 char *print_fmt;
660
661 /* First: called with 0 length to calculate the needed length */
662 len = __set_print_fmt(tp, NULL, 0, is_return);
663 print_fmt = kmalloc(len + 1, GFP_KERNEL);
664 if (!print_fmt)
665 return -ENOMEM;
666
667 /* Second: actually write the @print_fmt */
668 __set_print_fmt(tp, print_fmt, len + 1, is_return);
669 tp->call.print_fmt = print_fmt;
670
671 return 0;
672 }
Linux with added FPC-III support