debug.c 5.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259
  1. // SPDX-License-Identifier: GPL-2.0
  2. /* For general debugging purposes */
  3. #include <inttypes.h>
  4. #include <string.h>
  5. #include <stdarg.h>
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <sys/wait.h>
  9. #include <api/debug.h>
  10. #include <linux/kernel.h>
  11. #include <linux/time64.h>
  12. #ifdef HAVE_BACKTRACE_SUPPORT
  13. #include <execinfo.h>
  14. #endif
  15. #include "color.h"
  16. #include "event.h"
  17. #include "debug.h"
  18. #include "print_binary.h"
  19. #include "target.h"
  20. #include "ui/helpline.h"
  21. #include "ui/ui.h"
  22. #include "util/parse-sublevel-options.h"
  23. #include <linux/ctype.h>
  24. int verbose;
  25. int debug_peo_args;
  26. bool dump_trace = false, quiet = false;
  27. int debug_ordered_events;
  28. static int redirect_to_stderr;
  29. int debug_data_convert;
  30. int veprintf(int level, int var, const char *fmt, va_list args)
  31. {
  32. int ret = 0;
  33. if (var >= level) {
  34. if (use_browser >= 1 && !redirect_to_stderr)
  35. ui_helpline__vshow(fmt, args);
  36. else
  37. ret = vfprintf(stderr, fmt, args);
  38. }
  39. return ret;
  40. }
  41. int eprintf(int level, int var, const char *fmt, ...)
  42. {
  43. va_list args;
  44. int ret;
  45. va_start(args, fmt);
  46. ret = veprintf(level, var, fmt, args);
  47. va_end(args);
  48. return ret;
  49. }
  50. static int veprintf_time(u64 t, const char *fmt, va_list args)
  51. {
  52. int ret = 0;
  53. u64 secs, usecs, nsecs = t;
  54. secs = nsecs / NSEC_PER_SEC;
  55. nsecs -= secs * NSEC_PER_SEC;
  56. usecs = nsecs / NSEC_PER_USEC;
  57. ret = fprintf(stderr, "[%13" PRIu64 ".%06" PRIu64 "] ",
  58. secs, usecs);
  59. ret += vfprintf(stderr, fmt, args);
  60. return ret;
  61. }
  62. int eprintf_time(int level, int var, u64 t, const char *fmt, ...)
  63. {
  64. int ret = 0;
  65. va_list args;
  66. if (var >= level) {
  67. va_start(args, fmt);
  68. ret = veprintf_time(t, fmt, args);
  69. va_end(args);
  70. }
  71. return ret;
  72. }
  73. /*
  74. * Overloading libtraceevent standard info print
  75. * function, display with -v in perf.
  76. */
  77. void pr_stat(const char *fmt, ...)
  78. {
  79. va_list args;
  80. va_start(args, fmt);
  81. veprintf(1, verbose, fmt, args);
  82. va_end(args);
  83. eprintf(1, verbose, "\n");
  84. }
  85. int dump_printf(const char *fmt, ...)
  86. {
  87. va_list args;
  88. int ret = 0;
  89. if (dump_trace) {
  90. va_start(args, fmt);
  91. ret = vprintf(fmt, args);
  92. va_end(args);
  93. }
  94. return ret;
  95. }
  96. static int trace_event_printer(enum binary_printer_ops op,
  97. unsigned int val, void *extra, FILE *fp)
  98. {
  99. const char *color = PERF_COLOR_BLUE;
  100. union perf_event *event = (union perf_event *)extra;
  101. unsigned char ch = (unsigned char)val;
  102. int printed = 0;
  103. switch (op) {
  104. case BINARY_PRINT_DATA_BEGIN:
  105. printed += fprintf(fp, ".");
  106. printed += color_fprintf(fp, color, "\n. ... raw event: size %d bytes\n",
  107. event->header.size);
  108. break;
  109. case BINARY_PRINT_LINE_BEGIN:
  110. printed += fprintf(fp, ".");
  111. break;
  112. case BINARY_PRINT_ADDR:
  113. printed += color_fprintf(fp, color, " %04x: ", val);
  114. break;
  115. case BINARY_PRINT_NUM_DATA:
  116. printed += color_fprintf(fp, color, " %02x", val);
  117. break;
  118. case BINARY_PRINT_NUM_PAD:
  119. printed += color_fprintf(fp, color, " ");
  120. break;
  121. case BINARY_PRINT_SEP:
  122. printed += color_fprintf(fp, color, " ");
  123. break;
  124. case BINARY_PRINT_CHAR_DATA:
  125. printed += color_fprintf(fp, color, "%c",
  126. isprint(ch) && isascii(ch) ? ch : '.');
  127. break;
  128. case BINARY_PRINT_CHAR_PAD:
  129. printed += color_fprintf(fp, color, " ");
  130. break;
  131. case BINARY_PRINT_LINE_END:
  132. printed += color_fprintf(fp, color, "\n");
  133. break;
  134. case BINARY_PRINT_DATA_END:
  135. printed += fprintf(fp, "\n");
  136. break;
  137. default:
  138. break;
  139. }
  140. return printed;
  141. }
  142. void trace_event(union perf_event *event)
  143. {
  144. unsigned char *raw_event = (void *)event;
  145. if (!dump_trace)
  146. return;
  147. print_binary(raw_event, event->header.size, 16,
  148. trace_event_printer, event);
  149. }
  150. static struct sublevel_option debug_opts[] = {
  151. { .name = "verbose", .value_ptr = &verbose },
  152. { .name = "ordered-events", .value_ptr = &debug_ordered_events},
  153. { .name = "stderr", .value_ptr = &redirect_to_stderr},
  154. { .name = "data-convert", .value_ptr = &debug_data_convert },
  155. { .name = "perf-event-open", .value_ptr = &debug_peo_args },
  156. { .name = NULL, }
  157. };
  158. int perf_debug_option(const char *str)
  159. {
  160. int ret;
  161. ret = perf_parse_sublevel_options(str, debug_opts);
  162. if (ret)
  163. return ret;
  164. /* Allow only verbose value in range (0, 10), otherwise set 0. */
  165. verbose = (verbose < 0) || (verbose > 10) ? 0 : verbose;
  166. return 0;
  167. }
  168. int perf_quiet_option(void)
  169. {
  170. struct sublevel_option *opt = &debug_opts[0];
  171. /* disable all debug messages */
  172. while (opt->name) {
  173. *opt->value_ptr = -1;
  174. opt++;
  175. }
  176. return 0;
  177. }
  178. #define DEBUG_WRAPPER(__n, __l) \
  179. static int pr_ ## __n ## _wrapper(const char *fmt, ...) \
  180. { \
  181. va_list args; \
  182. int ret; \
  183. \
  184. va_start(args, fmt); \
  185. ret = veprintf(__l, verbose, fmt, args); \
  186. va_end(args); \
  187. return ret; \
  188. }
  189. DEBUG_WRAPPER(warning, 0);
  190. DEBUG_WRAPPER(debug, 1);
  191. void perf_debug_setup(void)
  192. {
  193. libapi_set_print(pr_warning_wrapper, pr_warning_wrapper, pr_debug_wrapper);
  194. }
  195. /* Obtain a backtrace and print it to stdout. */
  196. #ifdef HAVE_BACKTRACE_SUPPORT
  197. void dump_stack(void)
  198. {
  199. void *array[16];
  200. size_t size = backtrace(array, ARRAY_SIZE(array));
  201. char **strings = backtrace_symbols(array, size);
  202. size_t i;
  203. printf("Obtained %zd stack frames.\n", size);
  204. for (i = 0; i < size; i++)
  205. printf("%s\n", strings[i]);
  206. free(strings);
  207. }
  208. #else
  209. void dump_stack(void) {}
  210. #endif
  211. void sighandler_dump_stack(int sig)
  212. {
  213. psignal(sig, "perf");
  214. dump_stack();
  215. signal(sig, SIG_DFL);
  216. raise(sig);
  217. }