tools/verification/rv/src/in_kernel.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * in kernel monitor support: allows rv to control in-kernel monitors.
   4  *
   5  * Copyright (C) 2022 Red Hat Inc, Daniel Bristot de Oliveira <bristot@kernel.org>
   6  */
   7 #include <getopt.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <errno.h>
  11 #include <unistd.h>
  12
  13 #include <trace.h>
  14 #include <utils.h>
  15 #include <rv.h>
  16
  17 static int config_has_id;
  18 static int config_my_pid;
  19 static int config_trace;
  20
  21 static char *config_initial_reactor;
  22 static char *config_reactor;
  23
  24 /*
  25  * __ikm_read_enable - reads monitor's enable status
  26  *
  27  * __does not log errors.
  28  *
  29  * Returns the current status, or -1 if the monitor does not exist,
  30  * __hence not logging errors.
  31  */
  32 static int __ikm_read_enable(char *monitor_name)
  33 {
  34         char path[MAX_PATH];
  35         long long enabled;
  36         int retval;
  37
  38         snprintf(path, MAX_PATH, "rv/monitors/%s/enable", monitor_name);
  39
  40         retval = tracefs_instance_file_read_number(NULL, path, &enabled);
  41         if (retval < 0)
  42                 return -1;
  43
  44         return enabled;
  45 }
  46
  47 /*
  48  * ikm_read_enable - reads monitor's enable status
  49  *
  50  * Returns the current status, or -1 on error.
  51  */
  52 static int ikm_read_enable(char *monitor_name)
  53 {
  54         int enabled;
  55
  56         enabled = __ikm_read_enable(monitor_name);
  57         if (enabled < 0) {
  58                 err_msg("ikm: fail read enabled: %d\n", enabled);
  59                 return -1;
  60         }
  61
  62         debug_msg("ikm: read enabled: %d\n", enabled);
  63
  64         return enabled;
  65 }
  66
  67 /*
  68  * ikm_write_enable - write to the monitor's enable file
  69  *
  70  * Return the number of bytes written, -1 on error.
  71  */
  72 static int ikm_write_enable(char *monitor_name, char *enable_disable)
  73 {
  74         char path[MAX_PATH];
  75         int retval;
  76
  77         debug_msg("ikm: writing enabled: %s\n", enable_disable);
  78
  79         snprintf(path, MAX_PATH, "rv/monitors/%s/enable", monitor_name);
  80         retval = tracefs_instance_file_write(NULL, path, enable_disable);
  81         if (retval < strlen(enable_disable)) {
  82                 err_msg("ikm: writing enabled: %s\n", enable_disable);
  83                 return -1;
  84         }
  85
  86         return retval;
  87 }
  88
  89 /*
  90  * ikm_enable - enable a monitor
  91  *
  92  * Returns -1 on failure. Success otherwise.
  93  */
  94 static int ikm_enable(char *monitor_name)
  95 {
  96         return ikm_write_enable(monitor_name, "1");
  97 }
  98
  99 /*
 100  * ikm_disable - disable a monitor
 101  *
 102  * Returns -1 on failure. Success otherwise.
 103  */
 104 static int ikm_disable(char *monitor_name)
 105 {
 106         return ikm_write_enable(monitor_name, "0");
 107 }
 108
 109 /*
 110  * ikm_read_desc - read monitors' description
 111  *
 112  * Return a dynamically allocated string with the monitor's
 113  * description, NULL otherwise.
 114  */
 115 static char *ikm_read_desc(char *monitor_name)
 116 {
 117         char path[MAX_PATH];
 118         char *desc;
 119
 120         snprintf(path, MAX_PATH, "rv/monitors/%s/desc", monitor_name);
 121         desc = tracefs_instance_file_read(NULL, path, NULL);
 122         if (!desc) {
 123                 err_msg("ikm: error reading monitor %s desc\n", monitor_name);
 124                 return NULL;
 125         }
 126
 127         *strstr(desc, "\n") = '\0';
 128
 129         return desc;
 130 }
 131
 132 /*
 133  * ikm_fill_monitor_definition - fill monitor's definition
 134  *
 135  * Returns -1 on error, 0 otherwise.
 136  */
 137 static int ikm_fill_monitor_definition(char *name, struct monitor *ikm)
 138 {
 139         int enabled;
 140         char *desc;
 141
 142         enabled = ikm_read_enable(name);
 143         if (enabled < 0) {
 144                 err_msg("ikm: monitor %s fail to read enable file, bug?\n", name);
 145                 return -1;
 146         }
 147
 148         desc = ikm_read_desc(name);
 149         if (!desc) {
 150                 err_msg("ikm: monitor %s does not have desc file, bug?\n", name);
 151                 return -1;
 152         }
 153
 154         strncpy(ikm->name, name, MAX_DA_NAME_LEN);
 155         ikm->enabled = enabled;
 156         strncpy(ikm->desc, desc, MAX_DESCRIPTION);
 157
 158         free(desc);
 159
 160         return 0;
 161 }
 162
 163 /*
 164  * ikm_write_reactor - switch the reactor to *reactor
 165  *
 166  * Return the number or characters written, -1 on error.
 167  */
 168 static int ikm_write_reactor(char *monitor_name, char *reactor)
 169 {
 170         char path[MAX_PATH];
 171         int retval;
 172
 173         snprintf(path, MAX_PATH, "rv/monitors/%s/reactors", monitor_name);
 174         retval = tracefs_instance_file_write(NULL, path, reactor);
 175         debug_msg("ikm: write \"%s\" reactors: %d\n", reactor, retval);
 176
 177         return retval;
 178 }
 179
 180 /*
 181  * ikm_read_reactor - read the reactors file
 182  *
 183  * Returns a dynamically allocated string with monitor's
 184  * available reactors, or NULL on error.
 185  */
 186 static char *ikm_read_reactor(char *monitor_name)
 187 {
 188         char path[MAX_PATH];
 189         char *reactors;
 190
 191         snprintf(path, MAX_PATH, "rv/monitors/%s/reactors", monitor_name);
 192         reactors = tracefs_instance_file_read(NULL, path, NULL);
 193         if (!reactors) {
 194                 err_msg("ikm: fail reading monitor's %s reactors file\n", monitor_name);
 195                 return NULL;
 196         }
 197
 198         return reactors;
 199 }
 200
 201 /*
 202  * ikm_get_current_reactor - get the current enabled reactor
 203  *
 204  * Reads the reactors file and find the currently enabled
 205  * [reactor].
 206  *
 207  * Returns a dynamically allocated memory with the current
 208  * reactor. NULL otherwise.
 209  */
 210 static char *ikm_get_current_reactor(char *monitor_name)
 211 {
 212         char *reactors = ikm_read_reactor(monitor_name);
 213         char *curr_reactor = NULL;
 214         char *start;
 215         char *end;
 216
 217         if (!reactors)
 218                 return NULL;
 219
 220         start = strstr(reactors, "[");
 221         if (!start)
 222                 goto out_free;
 223
 224         start++;
 225
 226         end = strstr(start, "]");
 227         if (!end)
 228                 goto out_free;
 229
 230         *end = '\0';
 231
 232         curr_reactor = calloc(strlen(start) + 1, sizeof(char));
 233         if (!curr_reactor)
 234                 goto out_free;
 235
 236         strncpy(curr_reactor, start, strlen(start));
 237         debug_msg("ikm: read current reactor %s\n", curr_reactor);
 238
 239 out_free:
 240         free(reactors);
 241
 242         return curr_reactor;
 243 }
 244
 245 static int ikm_has_id(char *monitor_name)
 246 {
 247         char path[MAX_PATH];
 248         char *format;
 249         int has_id;
 250
 251         snprintf(path, MAX_PATH, "events/rv/event_%s/format", monitor_name);
 252         format = tracefs_instance_file_read(NULL, path, NULL);
 253         if (!format) {
 254                 err_msg("ikm: fail reading monitor's %s format event file\n", monitor_name);
 255                 return -1;
 256         }
 257
 258         /* print fmt: "%d: %s x %s -> %s %s", REC->id, ... */
 259         has_id = !!strstr(format, "REC->id");
 260
 261         debug_msg("ikm: monitor %s has id: %s\n", monitor_name, has_id ? "yes" : "no");
 262
 263         free(format);
 264
 265         return has_id;
 266 }
 267
 268 /**
 269  * ikm_list_monitors - list all available monitors
 270  *
 271  * Returns 0 on success, -1 otherwise.
 272  */
 273 int ikm_list_monitors(void)
 274 {
 275         char *available_monitors;
 276         struct monitor ikm;
 277         char *curr, *next;
 278         int retval;
 279
 280         available_monitors = tracefs_instance_file_read(NULL, "rv/available_monitors", NULL);
 281
 282         if (!available_monitors) {
 283                 err_msg("ikm: available monitors is not available, is CONFIG_RV enabled?\n");
 284                 return -1;
 285         }
 286
 287         curr = available_monitors;
 288         do {
 289                 next = strstr(curr, "\n");
 290                 *next = '\0';
 291
 292                 retval = ikm_fill_monitor_definition(curr, &ikm);
 293                 if (retval)
 294                         err_msg("ikm: error reading %d in kernel monitor, skipping\n", curr);
 295
 296                 printf("%-24s %s %s\n", ikm.name, ikm.desc, ikm.enabled ? "[ON]" : "[OFF]");
 297                 curr = ++next;
 298
 299         } while (strlen(curr));
 300
 301         free(available_monitors);
 302
 303         return 0;
 304 }
 305
 306 static void ikm_print_header(struct trace_seq *s)
 307 {
 308         trace_seq_printf(s, "%16s-%-8s %5s %5s ", "<TASK>", "PID", "[CPU]", "TYPE");
 309         if (config_has_id)
 310                 trace_seq_printf(s, "%8s ", "ID");
 311
 312         trace_seq_printf(s, "%24s x %-24s -> %-24s %s\n",
 313                          "STATE",
 314                          "EVENT",
 315                          "NEXT_STATE",
 316                          "FINAL");
 317
 318         trace_seq_printf(s, "%16s %-8s %5s %5s ", " | ", " | ", " | ", " | ");
 319
 320         if (config_has_id)
 321                 trace_seq_printf(s, "%8s ", " | ");
 322
 323         trace_seq_printf(s, "%24s   %-24s    %-24s %s\n",
 324                          " | ",
 325                          " | ",
 326                          " | ",
 327                          "|");
 328
 329 }
 330
 331 /*
 332  * ikm_event_handler - callback to handle event events
 333  *
 334  * Called any time a rv:"monitor"_event events is generated.
 335  * It parses and prints event.
 336  */
 337 static int
 338 ikm_event_handler(struct trace_seq *s, struct tep_record *record,
 339                   struct tep_event *trace_event, void *context)
 340 {
 341         /* if needed: struct trace_instance *inst = context; */
 342         char *state, *event, *next_state;
 343         unsigned long long final_state;
 344         unsigned long long pid;
 345         unsigned long long id;
 346         int cpu = record->cpu;
 347         int val;
 348
 349         if (config_has_id)
 350                 tep_get_field_val(s, trace_event, "id", record, &id, 1);
 351
 352         tep_get_common_field_val(s, trace_event, "common_pid", record, &pid, 1);
 353
 354         if (config_has_id && (config_my_pid == id))
 355                 return 0;
 356         else if (config_my_pid && (config_my_pid == pid))
 357                 return 0;
 358
 359         tep_print_event(trace_event->tep, s, record, "%16s-%-8d ", TEP_PRINT_COMM, TEP_PRINT_PID);
 360
 361         trace_seq_printf(s, "[%.3d] event ", cpu);
 362
 363         if (config_has_id)
 364                 trace_seq_printf(s, "%8llu ", id);
 365
 366         state = tep_get_field_raw(s, trace_event, "state", record, &val, 0);
 367         event = tep_get_field_raw(s, trace_event, "event", record, &val, 0);
 368         next_state = tep_get_field_raw(s, trace_event, "next_state", record, &val, 0);
 369         tep_get_field_val(s, trace_event, "final_state", record, &final_state, 1);
 370
 371         trace_seq_printf(s, "%24s x %-24s -> %-24s %s\n",
 372                          state,
 373                          event,
 374                          next_state,
 375                          final_state ? "Y" : "N");
 376
 377         trace_seq_do_printf(s);
 378         trace_seq_reset(s);
 379
 380         return 0;
 381 }
 382
 383 /*
 384  * ikm_error_handler - callback to handle error events
 385  *
 386  * Called any time a rv:"monitor"_errors events is generated.
 387  * It parses and prints event.
 388  */
 389 static int
 390 ikm_error_handler(struct trace_seq *s, struct tep_record *record,
 391                   struct tep_event *trace_event, void *context)
 392 {
 393         unsigned long long pid, id;
 394         int cpu = record->cpu;
 395         char *state, *event;
 396         int val;
 397
 398         if (config_has_id)
 399                 tep_get_field_val(s, trace_event, "id", record, &id, 1);
 400
 401         tep_get_common_field_val(s, trace_event, "common_pid", record, &pid, 1);
 402
 403         if (config_has_id && config_my_pid == id)
 404                 return 0;
 405         else if (config_my_pid == pid)
 406                 return 0;
 407
 408         trace_seq_printf(s, "%8lld [%03d] error ", pid, cpu);
 409
 410         if (config_has_id)
 411                 trace_seq_printf(s, "%8llu ", id);
 412
 413         state = tep_get_field_raw(s, trace_event, "state", record, &val, 0);
 414         event = tep_get_field_raw(s, trace_event, "event", record, &val, 0);
 415
 416         trace_seq_printf(s, "%24s x %s\n", state, event);
 417
 418         trace_seq_do_printf(s);
 419         trace_seq_reset(s);
 420
 421         return 0;
 422 }
 423
 424 /*
 425  * ikm_setup_trace_instance - set up a tracing instance to collect data
 426  *
 427  * Create a trace instance, enable rv: events and enable the trace.
 428  *
 429  * Returns the trace_instance * with all set, NULL otherwise.
 430  */
 431 static struct trace_instance *ikm_setup_trace_instance(char *monitor_name)
 432 {
 433         char event[MAX_DA_NAME_LEN + 7]; /* max(error_,event_) + '0' = 7 */
 434         struct trace_instance *inst;
 435         int retval;
 436
 437         if (!config_trace)
 438                 return NULL;
 439
 440         config_has_id = ikm_has_id(monitor_name);
 441         if (config_has_id < 0) {
 442                 err_msg("ikm: failed to read monitor %s event format\n", monitor_name);
 443                 goto out_err;
 444         }
 445
 446         /* alloc data */
 447         inst = calloc(1, sizeof(*inst));
 448         if (!inst) {
 449                 err_msg("ikm: failed to allocate trace instance");
 450                 goto out_err;
 451         }
 452
 453         retval = trace_instance_init(inst, monitor_name);
 454         if (retval)
 455                 goto out_free;
 456
 457         /* enable events */
 458         snprintf(event, sizeof(event), "event_%s", monitor_name);
 459         retval = tracefs_event_enable(inst->inst, "rv",  event);
 460         if (retval)
 461                 goto out_inst;
 462
 463         tep_register_event_handler(inst->tep, -1, "rv", event,
 464                                    ikm_event_handler, NULL);
 465
 466         snprintf(event, sizeof(event), "error_%s", monitor_name);
 467         retval = tracefs_event_enable(inst->inst, "rv", event);
 468         if (retval)
 469                 goto out_inst;
 470
 471         tep_register_event_handler(inst->tep, -1, "rv", event,
 472                                    ikm_error_handler, NULL);
 473
 474         /* ready to enable */
 475         tracefs_trace_on(inst->inst);
 476
 477         return inst;
 478
 479 out_inst:
 480         trace_instance_destroy(inst);
 481 out_free:
 482         free(inst);
 483 out_err:
 484         return NULL;
 485 }
 486
 487 /**
 488  * ikm_destroy_trace_instance - destroy a previously created instance
 489  */
 490 static void ikm_destroy_trace_instance(struct trace_instance *inst)
 491 {
 492         if (!inst)
 493                 return;
 494
 495         trace_instance_destroy(inst);
 496         free(inst);
 497 }
 498
 499 /*
 500  * ikm_usage_print_reactors - print all available reactors, one per line.
 501  */
 502 static void ikm_usage_print_reactors(void)
 503 {
 504         char *reactors = tracefs_instance_file_read(NULL, "rv/available_reactors", NULL);
 505         char *start, *end;
 506
 507         if (!reactors)
 508                 return;
 509
 510         fprintf(stderr, "  available reactors:");
 511
 512         start = reactors;
 513         end = strstr(start, "\n");
 514
 515         while (end) {
 516                 *end = '\0';
 517
 518                 fprintf(stderr, " %s", start);
 519
 520                 start = ++end;
 521                 end = strstr(start, "\n");
 522         }
 523
 524         fprintf(stderr, "\n");
 525 }
 526 /*
 527  * ikm_usage - print usage
 528  */
 529 static void ikm_usage(int exit_val, char *monitor_name, const char *fmt, ...)
 530 {
 531
 532         char message[1024];
 533         va_list ap;
 534         int i;
 535
 536         static const char *const usage[] = {
 537                 "",
 538                 "       -h/--help: print this menu and the reactor list",
 539                 "       -r/--reactor 'reactor': enables the 'reactor'",
 540                 "       -s/--self: when tracing (-t), also trace rv command",
 541                 "       -t/--trace: trace monitor's event",
 542                 "       -v/--verbose: print debug messages",
 543                 "",
 544                 NULL,
 545         };
 546
 547         va_start(ap, fmt);
 548         vsnprintf(message, sizeof(message), fmt, ap);
 549         va_end(ap);
 550
 551         fprintf(stderr, "  %s\n", message);
 552
 553         fprintf(stderr, "\n  usage: rv mon %s [-h] [-q] [-r reactor] [-s] [-v]", monitor_name);
 554
 555         for (i = 0; usage[i]; i++)
 556                 fprintf(stderr, "%s\n", usage[i]);
 557
 558         ikm_usage_print_reactors();
 559         exit(exit_val);
 560 }
 561
 562 /*
 563  * parse_arguments - parse arguments and set config
 564  */
 565 static int parse_arguments(char *monitor_name, int argc, char **argv)
 566 {
 567         int c, retval;
 568
 569         config_my_pid = getpid();
 570
 571         while (1) {
 572                 static struct option long_options[] = {
 573                         {"help",                no_argument,            0, 'h'},
 574                         {"reactor",             required_argument,      0, 'r'},
 575                         {"self",                no_argument,            0, 's'},
 576                         {"trace",               no_argument,            0, 't'},
 577                         {"verbose",             no_argument,            0, 'v'},
 578                         {0, 0, 0, 0}
 579                 };
 580
 581                 /* getopt_long stores the option index here. */
 582                 int option_index = 0;
 583
 584                 c = getopt_long(argc, argv, "hr:stv", long_options, &option_index);
 585
 586                 /* detect the end of the options. */
 587                 if (c == -1)
 588                         break;
 589
 590                 switch (c) {
 591                 case 'h':
 592                         ikm_usage(0, monitor_name, "help:");
 593                         break;
 594                 case 'r':
 595                         config_reactor = optarg;
 596                         break;
 597                 case 's':
 598                         config_my_pid = 0;
 599                         break;
 600                 case 't':
 601                         config_trace = 1;
 602                         break;
 603                 case 'v':
 604                         config_debug = 1;
 605                         break;
 606                 }
 607         }
 608
 609         if (config_reactor) {
 610                 config_initial_reactor = ikm_get_current_reactor(monitor_name);
 611                 if (!config_initial_reactor)
 612                         ikm_usage(1, monitor_name,
 613                                   "ikm: failed to read current reactor, are reactors enabled?");
 614
 615                 retval = ikm_write_reactor(monitor_name, config_reactor);
 616                 if (retval <= 0)
 617                         ikm_usage(1, monitor_name,
 618                                   "ikm: failed to set %s reactor, is it available?",
 619                                   config_reactor);
 620         }
 621
 622         debug_msg("ikm: my pid is %d\n", config_my_pid);
 623
 624         return 0;
 625 }
 626
 627 /**
 628  * ikm_run_monitor - apply configs and run the monitor
 629  *
 630  * Returns 1 if a monitor was found an executed, 0 if no
 631  * monitors were found, or -1 on error.
 632  */
 633 int ikm_run_monitor(char *monitor_name, int argc, char **argv)
 634 {
 635         struct trace_instance *inst = NULL;
 636         int retval;
 637
 638         /*
 639          * Check if monitor exists by seeing it is enabled.
 640          */
 641         retval = __ikm_read_enable(monitor_name);
 642         if (retval < 0)
 643                 return 0;
 644
 645         if (retval) {
 646                 err_msg("ikm: monitor %s (in-kernel) is already enabled\n", monitor_name);
 647                 return -1;
 648         }
 649
 650         /* we should be good to go */
 651         retval = parse_arguments(monitor_name, argc, argv);
 652         if (retval)
 653                 ikm_usage(1, monitor_name, "ikm: failed parsing arguments");
 654
 655         if (config_trace) {
 656                 inst = ikm_setup_trace_instance(monitor_name);
 657                 if (!inst)
 658                         return -1;
 659         }
 660
 661         retval = ikm_enable(monitor_name);
 662         if (retval < 0)
 663                 goto out_free_instance;
 664
 665         if (config_trace)
 666                 ikm_print_header(inst->seq);
 667
 668         while (!should_stop()) {
 669                 if (config_trace) {
 670                         retval = tracefs_iterate_raw_events(inst->tep,
 671                                                             inst->inst,
 672                                                             NULL,
 673                                                             0,
 674                                                             collect_registered_events,
 675                                                             inst);
 676                         if (retval) {
 677                                 err_msg("ikm: error reading trace buffer\n");
 678                                 break;
 679                         }
 680                 }
 681
 682                 sleep(1);
 683         }
 684
 685         ikm_disable(monitor_name);
 686         ikm_destroy_trace_instance(inst);
 687
 688         if (config_reactor && config_initial_reactor)
 689                 ikm_write_reactor(monitor_name, config_initial_reactor);
 690
 691         return 1;
 692
 693 out_free_instance:
 694         ikm_destroy_trace_instance(inst);
 695         if (config_reactor && config_initial_reactor)
 696                 ikm_write_reactor(monitor_name, config_initial_reactor);
 697         return -1;
 698 }