tools/perf/util/debug.c

   1 /* For general debugging purposes */
   2
   3 #include "../perf.h"
   4
   5 #include <inttypes.h>
   6 #include <string.h>
   7 #include <stdarg.h>
   8 #include <stdio.h>
   9 #include <api/debug.h>
  10 #include <linux/time64.h>
  11
  12 #include "cache.h"
  13 #include "color.h"
  14 #include "event.h"
  15 #include "debug.h"
  16 #include "print_binary.h"
  17 #include "util.h"
  18 #include "target.h"
  19
  20 #include "sane_ctype.h"
  21
  22 int verbose;
  23 bool dump_trace = false, quiet = false;
  24 int debug_ordered_events;
  25 static int redirect_to_stderr;
  26 int debug_data_convert;
  27
  28 int veprintf(int level, int var, const char *fmt, va_list args)
  29 {
  30         int ret = 0;
  31
  32         if (var >= level) {
  33                 if (use_browser >= 1 && !redirect_to_stderr)
  34                         ui_helpline__vshow(fmt, args);
  35                 else
  36                         ret = vfprintf(stderr, fmt, args);
  37         }
  38
  39         return ret;
  40 }
  41
  42 int eprintf(int level, int var, const char *fmt, ...)
  43 {
  44         va_list args;
  45         int ret;
  46
  47         va_start(args, fmt);
  48         ret = veprintf(level, var, fmt, args);
  49         va_end(args);
  50
  51         return ret;
  52 }
  53
  54 static int veprintf_time(u64 t, const char *fmt, va_list args)
  55 {
  56         int ret = 0;
  57         u64 secs, usecs, nsecs = t;
  58
  59         secs   = nsecs / NSEC_PER_SEC;
  60         nsecs -= secs  * NSEC_PER_SEC;
  61         usecs  = nsecs / NSEC_PER_USEC;
  62
  63         ret = fprintf(stderr, "[%13" PRIu64 ".%06" PRIu64 "] ",
  64                       secs, usecs);
  65         ret += vfprintf(stderr, fmt, args);
  66         return ret;
  67 }
  68
  69 int eprintf_time(int level, int var, u64 t, const char *fmt, ...)
  70 {
  71         int ret = 0;
  72         va_list args;
  73
  74         if (var >= level) {
  75                 va_start(args, fmt);
  76                 ret = veprintf_time(t, fmt, args);
  77                 va_end(args);
  78         }
  79
  80         return ret;
  81 }
  82
  83 /*
  84  * Overloading libtraceevent standard info print
  85  * function, display with -v in perf.
  86  */
  87 void pr_stat(const char *fmt, ...)
  88 {
  89         va_list args;
  90
  91         va_start(args, fmt);
  92         veprintf(1, verbose, fmt, args);
  93         va_end(args);
  94         eprintf(1, verbose, "\n");
  95 }
  96
  97 int dump_printf(const char *fmt, ...)
  98 {
  99         va_list args;
 100         int ret = 0;
 101
 102         if (dump_trace) {
 103                 va_start(args, fmt);
 104                 ret = vprintf(fmt, args);
 105                 va_end(args);
 106         }
 107
 108         return ret;
 109 }
 110
 111 static void trace_event_printer(enum binary_printer_ops op,
 112                                 unsigned int val, void *extra)
 113 {
 114         const char *color = PERF_COLOR_BLUE;
 115         union perf_event *event = (union perf_event *)extra;
 116         unsigned char ch = (unsigned char)val;
 117
 118         switch (op) {
 119         case BINARY_PRINT_DATA_BEGIN:
 120                 printf(".");
 121                 color_fprintf(stdout, color, "\n. ... raw event: size %d bytes\n",
 122                                 event->header.size);
 123                 break;
 124         case BINARY_PRINT_LINE_BEGIN:
 125                 printf(".");
 126                 break;
 127         case BINARY_PRINT_ADDR:
 128                 color_fprintf(stdout, color, "  %04x: ", val);
 129                 break;
 130         case BINARY_PRINT_NUM_DATA:
 131                 color_fprintf(stdout, color, " %02x", val);
 132                 break;
 133         case BINARY_PRINT_NUM_PAD:
 134                 color_fprintf(stdout, color, "   ");
 135                 break;
 136         case BINARY_PRINT_SEP:
 137                 color_fprintf(stdout, color, "  ");
 138                 break;
 139         case BINARY_PRINT_CHAR_DATA:
 140                 color_fprintf(stdout, color, "%c",
 141                               isprint(ch) ? ch : '.');
 142                 break;
 143         case BINARY_PRINT_CHAR_PAD:
 144                 color_fprintf(stdout, color, " ");
 145                 break;
 146         case BINARY_PRINT_LINE_END:
 147                 color_fprintf(stdout, color, "\n");
 148                 break;
 149         case BINARY_PRINT_DATA_END:
 150                 printf("\n");
 151                 break;
 152         default:
 153                 break;
 154         }
 155 }
 156
 157 void trace_event(union perf_event *event)
 158 {
 159         unsigned char *raw_event = (void *)event;
 160
 161         if (!dump_trace)
 162                 return;
 163
 164         print_binary(raw_event, event->header.size, 16,
 165                      trace_event_printer, event);
 166 }
 167
 168 static struct debug_variable {
 169         const char *name;
 170         int *ptr;
 171 } debug_variables[] = {
 172         { .name = "verbose",            .ptr = &verbose },
 173         { .name = "ordered-events",     .ptr = &debug_ordered_events},
 174         { .name = "stderr",             .ptr = &redirect_to_stderr},
 175         { .name = "data-convert",       .ptr = &debug_data_convert },
 176         { .name = NULL, }
 177 };
 178
 179 int perf_debug_option(const char *str)
 180 {
 181         struct debug_variable *var = &debug_variables[0];
 182         char *vstr, *s = strdup(str);
 183         int v = 1;
 184
 185         vstr = strchr(s, '=');
 186         if (vstr)
 187                 *vstr++ = 0;
 188
 189         while (var->name) {
 190                 if (!strcmp(s, var->name))
 191                         break;
 192                 var++;
 193         }
 194
 195         if (!var->name) {
 196                 pr_err("Unknown debug variable name '%s'\n", s);
 197                 free(s);
 198                 return -1;
 199         }
 200
 201         if (vstr) {
 202                 v = atoi(vstr);
 203                 /*
 204                  * Allow only values in range (0, 10),
 205                  * otherwise set 0.
 206                  */
 207                 v = (v < 0) || (v > 10) ? 0 : v;
 208         }
 209
 210         if (quiet)
 211                 v = -1;
 212
 213         *var->ptr = v;
 214         free(s);
 215         return 0;
 216 }
 217
 218 int perf_quiet_option(void)
 219 {
 220         struct debug_variable *var = &debug_variables[0];
 221
 222         /* disable all debug messages */
 223         while (var->name) {
 224                 *var->ptr = -1;
 225                 var++;
 226         }
 227
 228         quiet = true;
 229         return 0;
 230 }
 231
 232 #define DEBUG_WRAPPER(__n, __l)                         \
 233 static int pr_ ## __n ## _wrapper(const char *fmt, ...) \
 234 {                                                       \
 235         va_list args;                                   \
 236         int ret;                                        \
 237                                                         \
 238         va_start(args, fmt);                            \
 239         ret = veprintf(__l, verbose, fmt, args);        \
 240         va_end(args);                                   \
 241         return ret;                                     \
 242 }
 243
 244 DEBUG_WRAPPER(warning, 0);
 245 DEBUG_WRAPPER(debug, 1);
 246
 247 void perf_debug_setup(void)
 248 {
 249         libapi_set_print(pr_warning_wrapper, pr_warning_wrapper, pr_debug_wrapper);
 250 }