mono/profiler/log-args.c

   1 #include <config.h>
   2 #include <mono/utils/mono-logger-internals.h>
   3 #include <mono/utils/mono-proclib.h>
   4 #include "log.h"
   5
   6 #ifdef HAVE_UNISTD_H
   7 #include <unistd.h>
   8 #endif
   9
  10 typedef struct {
  11         const char *event_name;
  12         const int mask;
  13 } NameAndMask;
  14
  15 static NameAndMask event_list[] = {
  16         { "exception", PROFLOG_EXCEPTION_EVENTS },
  17         { "monitor", PROFLOG_MONITOR_EVENTS },
  18         { "gc", PROFLOG_GC_EVENTS },
  19         { "gcalloc", PROFLOG_GC_ALLOCATION_EVENTS },
  20         { "gcmove", PROFLOG_GC_MOVE_EVENTS },
  21         { "gcroot", PROFLOG_GC_ROOT_EVENTS },
  22         { "gchandle", PROFLOG_GC_HANDLE_EVENTS },
  23         { "finalization", PROFLOG_GC_FINALIZATION_EVENTS },
  24         { "counter", PROFLOG_COUNTER_EVENTS },
  25         { "jit", PROFLOG_JIT_EVENTS },
  26
  27         { "alloc", PROFLOG_ALLOC_ALIAS },
  28         { "legacy", PROFLOG_LEGACY_ALIAS },
  29 };
  30
  31 static void usage (void);
  32 static void set_hsmode (ProfilerConfig *config, const char* val);
  33 static void set_sample_freq (ProfilerConfig *config, const char *val);
  34
  35 static gboolean
  36 match_option (const char *arg, const char *opt_name, const char **rval)
  37 {
  38         if (rval) {
  39                 const char *end = strchr (arg, '=');
  40
  41                 *rval = NULL;
  42                 if (!end)
  43                         return !strcmp (arg, opt_name);
  44
  45                 if (strncmp (arg, opt_name, strlen (opt_name)) || (end - arg) > strlen (opt_name) + 1)
  46                         return FALSE;
  47                 *rval = end + 1;
  48                 return TRUE;
  49         } else {
  50                 //FIXME how should we handle passing a value to an arg that doesn't expect it?
  51                 return !strcmp (arg, opt_name);
  52         }
  53 }
  54
  55 static void
  56 parse_arg (const char *arg, ProfilerConfig *config)
  57 {
  58         const char *val;
  59
  60         if (match_option (arg, "help", NULL)) {
  61                 usage ();
  62         } else if (match_option (arg, "report", NULL)) {
  63                 config->do_report = TRUE;
  64         } else if (match_option (arg, "debug", NULL)) {
  65                 config->do_debug = TRUE;
  66         } else if (match_option (arg, "heapshot", &val)) {
  67                 set_hsmode (config, val);
  68                 if (config->hs_mode != MONO_PROFILER_HEAPSHOT_NONE)
  69                         config->enable_mask |= PROFLOG_HEAPSHOT_ALIAS;
  70         } else if (match_option (arg, "heapshot-on-shutdown", NULL)) {
  71                 config->hs_on_shutdown = TRUE;
  72                 config->enable_mask |= PROFLOG_HEAPSHOT_ALIAS;
  73         } else if (match_option (arg, "sample", &val)) {
  74                 set_sample_freq (config, val);
  75                 config->sampling_mode = MONO_PROFILER_SAMPLE_MODE_PROCESS;
  76                 config->enable_mask |= PROFLOG_SAMPLE_EVENTS;
  77         } else if (match_option (arg, "sample-real", &val)) {
  78                 set_sample_freq (config, val);
  79                 config->sampling_mode = MONO_PROFILER_SAMPLE_MODE_REAL;
  80                 config->enable_mask |= PROFLOG_SAMPLE_EVENTS;
  81         } else if (match_option (arg, "calls", NULL)) {
  82                 config->enter_leave = TRUE;
  83         } else if (match_option (arg, "coverage", NULL)) {
  84                 g_warning ("the log profiler support for code coverage is obsolete, use the \"coverage\" profiler");
  85                 config->collect_coverage = TRUE;
  86         } else if (match_option (arg, "zip", NULL)) {
  87                 config->use_zip = TRUE;
  88         } else if (match_option (arg, "output", &val)) {
  89                 config->output_filename = g_strdup (val);
  90         } else if (match_option (arg, "port", &val)) {
  91                 char *end;
  92                 config->command_port = strtoul (val, &end, 10);
  93         } else if (match_option (arg, "maxframes", &val)) {
  94                 char *end;
  95                 int num_frames = strtoul (val, &end, 10);
  96                 if (num_frames > MAX_FRAMES)
  97                         num_frames = MAX_FRAMES;
  98                 config->num_frames = num_frames;
  99         } else if (match_option (arg, "maxsamples", &val)) {
 100                 char *end;
 101                 int max_samples = strtoul (val, &end, 10);
 102                 if (max_samples)
 103                         config->max_allocated_sample_hits = max_samples;
 104         } else if (match_option (arg, "calldepth", &val)) {
 105                 char *end;
 106                 config->max_call_depth = strtoul (val, &end, 10);
 107         } else if (match_option (arg, "covfilter-file", &val)) {
 108                 if (config->cov_filter_files == NULL)
 109                         config->cov_filter_files = g_ptr_array_new ();
 110                 g_ptr_array_add (config->cov_filter_files, g_strdup (val));
 111         } else {
 112                 int i;
 113
 114                 for (i = 0; i < G_N_ELEMENTS (event_list); ++i){
 115                         if (!strcmp (arg, event_list [i].event_name)) {
 116                                 config->enable_mask |= event_list [i].mask;
 117                                 break;
 118                         } else if (!strncmp (arg, "no", 2) && !strcmp (arg + 2, event_list [i].event_name)) {
 119                                 config->disable_mask |= event_list [i].mask;
 120                                 break;
 121                         }
 122                 }
 123
 124                 if (i == G_N_ELEMENTS (event_list))
 125                         mono_profiler_printf_err ("Could not parse argument: %s", arg);
 126         }
 127 }
 128
 129 static void
 130 load_args_from_env_or_default (ProfilerConfig *config)
 131 {
 132         //XXX change this to header constants
 133
 134         config->max_allocated_sample_hits = mono_cpu_count () * 1000;
 135         config->sampling_mode = MONO_PROFILER_SAMPLE_MODE_NONE;
 136         config->sample_freq = 100;
 137         config->max_call_depth = 100;
 138         config->num_frames = MAX_FRAMES;
 139 }
 140
 141
 142 void
 143 proflog_parse_args (ProfilerConfig *config, const char *desc)
 144 {
 145         const char *p;
 146         gboolean in_quotes = FALSE;
 147         char quote_char = '\0';
 148         char *buffer = malloc (strlen (desc));
 149         int buffer_pos = 0;
 150
 151         load_args_from_env_or_default (config);
 152
 153         for (p = desc; *p; p++){
 154                 switch (*p){
 155                 case ',':
 156                         if (!in_quotes) {
 157                                 if (buffer_pos != 0){
 158                                         buffer [buffer_pos] = 0;
 159                                         parse_arg (buffer, config);
 160                                         buffer_pos = 0;
 161                                 }
 162                         } else {
 163                                 buffer [buffer_pos++] = *p;
 164                         }
 165                         break;
 166
 167                 case '\\':
 168                         if (p [1]) {
 169                                 buffer [buffer_pos++] = p[1];
 170                                 p++;
 171                         }
 172                         break;
 173                 case '\'':
 174                 case '"':
 175                         if (in_quotes) {
 176                                 if (quote_char == *p)
 177                                         in_quotes = FALSE;
 178                                 else
 179                                         buffer [buffer_pos++] = *p;
 180                         } else {
 181                                 in_quotes = TRUE;
 182                                 quote_char = *p;
 183                         }
 184                         break;
 185                 default:
 186                         buffer [buffer_pos++] = *p;
 187                         break;
 188                 }
 189         }
 190
 191         if (buffer_pos != 0) {
 192                 buffer [buffer_pos] = 0;
 193                 parse_arg (buffer, config);
 194         }
 195
 196         g_free (buffer);
 197
 198         //Compure config effective mask
 199         config->effective_mask = config->enable_mask & ~config->disable_mask;
 200 }
 201
 202 static void
 203 set_hsmode (ProfilerConfig *config, const char* val)
 204 {
 205         if (!val) {
 206                 config->hs_mode = MONO_PROFILER_HEAPSHOT_MAJOR;
 207                 return;
 208         }
 209
 210         if (strcmp (val, "ondemand") == 0) {
 211                 config->hs_mode = MONO_PROFILER_HEAPSHOT_ON_DEMAND;
 212                 return;
 213         }
 214
 215         char *end;
 216
 217         unsigned int count = strtoul (val, &end, 10);
 218
 219         if (val == end) {
 220                 usage ();
 221                 return;
 222         }
 223
 224         if (strcmp (end, "ms") == 0) {
 225                 config->hs_mode = MONO_PROFILER_HEAPSHOT_X_MS;
 226                 config->hs_freq_ms = count;
 227         } else if (strcmp (end, "gc") == 0) {
 228                 config->hs_mode = MONO_PROFILER_HEAPSHOT_X_GC;
 229                 config->hs_freq_gc = count;
 230         } else
 231                 usage ();
 232 }
 233
 234 static void
 235 set_sample_freq (ProfilerConfig *config, const char *val)
 236 {
 237         if (!val)
 238                 return;
 239
 240         char *end;
 241
 242         int freq = strtoul (val, &end, 10);
 243
 244         if (val == end) {
 245                 usage ();
 246                 return;
 247         }
 248
 249         config->sample_freq = freq;
 250 }
 251
 252 static void
 253 usage (void)
 254 {
 255         mono_profiler_printf ("Mono log profiler version %d.%d (format: %d)", LOG_VERSION_MAJOR, LOG_VERSION_MINOR, LOG_DATA_VERSION);
 256         mono_profiler_printf ("Usage: mono --profile=log[:OPTION1[,OPTION2...]] program.exe\n");
 257         mono_profiler_printf ("Options:");
 258         mono_profiler_printf ("\thelp                 show this usage info");
 259         mono_profiler_printf ("\t[no]'EVENT'          enable/disable an individual profiling event");
 260         mono_profiler_printf ("\t                     valid EVENT values:");
 261
 262         for (int i = 0; i < G_N_ELEMENTS (event_list); i++)
 263                 mono_profiler_printf ("\t                         %s", event_list [i].event_name);
 264
 265         mono_profiler_printf ("\t[no]alloc            enable/disable recording allocation info");
 266         mono_profiler_printf ("\t[no]legacy           enable/disable pre Mono 5.6 default profiler events");
 267         mono_profiler_printf ("\tsample[-real][=FREQ] enable/disable statistical sampling of threads");
 268         mono_profiler_printf ("\t                     FREQ in Hz, 100 by default");
 269         mono_profiler_printf ("\t                     the -real variant uses wall clock time instead of process time");
 270         mono_profiler_printf ("\theapshot[=MODE]      record heapshot info (by default at each major collection)");
 271         mono_profiler_printf ("\t                     MODE: every XXms milliseconds, every YYgc collections, ondemand");
 272         mono_profiler_printf ("\theapshot-on-shutdown do a heapshot on runtime shutdown");
 273         mono_profiler_printf ("\t                     this option is independent of the above option");
 274         mono_profiler_printf ("\tcalls                enable recording enter/leave method events (very heavy)");
 275         mono_profiler_printf ("\tcoverage             enable collection of code coverage data");
 276         mono_profiler_printf ("\tcovfilter=ASSEMBLY   add ASSEMBLY to the code coverage filters");
 277         mono_profiler_printf ("\t                     prefix a + to include the assembly or a - to exclude it");
 278         mono_profiler_printf ("\t                     e.g. covfilter=-mscorlib");
 279         mono_profiler_printf ("\tcovfilter-file=FILE  use FILE to generate the list of assemblies to be filtered");
 280         mono_profiler_printf ("\tmaxframes=NUM        collect up to NUM stack frames");
 281         mono_profiler_printf ("\tcalldepth=NUM        ignore method events for call chain depth bigger than NUM");
 282         mono_profiler_printf ("\toutput=FILENAME      write the data to file FILENAME (the file is always overwritten)");
 283         mono_profiler_printf ("\toutput=+FILENAME     write the data to file FILENAME.pid (the file is always overwritten)");
 284         mono_profiler_printf ("\toutput=|PROGRAM      write the data to the stdin of PROGRAM");
 285         mono_profiler_printf ("\t                     %%t is substituted with date and time, %%p with the pid");
 286         mono_profiler_printf ("\treport               create a report instead of writing the raw data to a file");
 287         mono_profiler_printf ("\tzip                  compress the output data");
 288         mono_profiler_printf ("\tport=PORTNUM         use PORTNUM for the listening command server");
 289 }