tools/tracing/rtla/src/osnoise.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2021 Red Hat Inc, Daniel Bristot de Oliveira <bristot@kernel.org>
   4  */
   5
   6 #include <sys/types.h>
   7 #include <sys/stat.h>
   8 #include <pthread.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <unistd.h>
  12 #include <errno.h>
  13 #include <fcntl.h>
  14 #include <stdio.h>
  15
  16 #include "osnoise.h"
  17 #include "utils.h"
  18
  19 /*
  20  * osnoise_get_cpus - return the original "osnoise/cpus" content
  21  *
  22  * It also saves the value to be restored.
  23  */
  24 char *osnoise_get_cpus(struct osnoise_context *context)
  25 {
  26         if (context->curr_cpus)
  27                 return context->curr_cpus;
  28
  29         if (context->orig_cpus)
  30                 return context->orig_cpus;
  31
  32         context->orig_cpus = tracefs_instance_file_read(NULL, "osnoise/cpus", NULL);
  33
  34         /*
  35          * The error value (NULL) is the same for tracefs_instance_file_read()
  36          * and this functions, so:
  37          */
  38         return context->orig_cpus;
  39 }
  40
  41 /*
  42  * osnoise_set_cpus - configure osnoise to run on *cpus
  43  *
  44  * "osnoise/cpus" file is used to set the cpus in which osnoise/timerlat
  45  * will run. This function opens this file, saves the current value,
  46  * and set the cpus passed as argument.
  47  */
  48 int osnoise_set_cpus(struct osnoise_context *context, char *cpus)
  49 {
  50         char *orig_cpus = osnoise_get_cpus(context);
  51         char buffer[1024];
  52         int retval;
  53
  54         if (!orig_cpus)
  55                 return -1;
  56
  57         context->curr_cpus = strdup(cpus);
  58         if (!context->curr_cpus)
  59                 return -1;
  60
  61         snprintf(buffer, 1024, "%s\n", cpus);
  62
  63         debug_msg("setting cpus to %s from %s", cpus, context->orig_cpus);
  64
  65         retval = tracefs_instance_file_write(NULL, "osnoise/cpus", buffer);
  66         if (retval < 0) {
  67                 free(context->curr_cpus);
  68                 context->curr_cpus = NULL;
  69                 return -1;
  70         }
  71
  72         return 0;
  73 }
  74
  75 /*
  76  * osnoise_restore_cpus - restore the original "osnoise/cpus"
  77  *
  78  * osnoise_set_cpus() saves the original data for the "osnoise/cpus"
  79  * file. This function restore the original config it was previously
  80  * modified.
  81  */
  82 void osnoise_restore_cpus(struct osnoise_context *context)
  83 {
  84         int retval;
  85
  86         if (!context->orig_cpus)
  87                 return;
  88
  89         if (!context->curr_cpus)
  90                 return;
  91
  92         /* nothing to do? */
  93         if (!strcmp(context->orig_cpus, context->curr_cpus))
  94                 goto out_done;
  95
  96         debug_msg("restoring cpus to %s", context->orig_cpus);
  97
  98         retval = tracefs_instance_file_write(NULL, "osnoise/cpus", context->orig_cpus);
  99         if (retval < 0)
 100                 err_msg("could not restore original osnoise cpus\n");
 101
 102 out_done:
 103         free(context->curr_cpus);
 104         context->curr_cpus = NULL;
 105 }
 106
 107 /*
 108  * osnoise_put_cpus - restore cpus config and cleanup data
 109  */
 110 void osnoise_put_cpus(struct osnoise_context *context)
 111 {
 112         osnoise_restore_cpus(context);
 113
 114         if (!context->orig_cpus)
 115                 return;
 116
 117         free(context->orig_cpus);
 118         context->orig_cpus = NULL;
 119 }
 120
 121 /*
 122  * osnoise_read_ll_config - read a long long value from a config
 123  *
 124  * returns -1 on error.
 125  */
 126 static long long osnoise_read_ll_config(char *rel_path)
 127 {
 128         long long retval;
 129         char *buffer;
 130
 131         buffer = tracefs_instance_file_read(NULL, rel_path, NULL);
 132         if (!buffer)
 133                 return -1;
 134
 135         /* get_llong_from_str returns -1 on error */
 136         retval = get_llong_from_str(buffer);
 137
 138         debug_msg("reading %s returned %lld\n", rel_path, retval);
 139
 140         free(buffer);
 141
 142         return retval;
 143 }
 144
 145 /*
 146  * osnoise_write_ll_config - write a long long value to a config in rel_path
 147  *
 148  * returns -1 on error.
 149  */
 150 static long long osnoise_write_ll_config(char *rel_path, long long value)
 151 {
 152         char buffer[BUFF_U64_STR_SIZE];
 153         long long retval;
 154
 155         snprintf(buffer, sizeof(buffer), "%lld\n", value);
 156
 157         debug_msg("setting %s to %lld\n", rel_path, value);
 158
 159         retval = tracefs_instance_file_write(NULL, rel_path, buffer);
 160         return retval;
 161 }
 162
 163 /*
 164  * osnoise_get_runtime - return the original "osnoise/runtime_us" value
 165  *
 166  * It also saves the value to be restored.
 167  */
 168 unsigned long long osnoise_get_runtime(struct osnoise_context *context)
 169 {
 170         long long runtime_us;
 171
 172         if (context->runtime_us != OSNOISE_TIME_INIT_VAL)
 173                 return context->runtime_us;
 174
 175         if (context->orig_runtime_us != OSNOISE_TIME_INIT_VAL)
 176                 return context->orig_runtime_us;
 177
 178         runtime_us = osnoise_read_ll_config("osnoise/runtime_us");
 179         if (runtime_us < 0)
 180                 goto out_err;
 181
 182         context->orig_runtime_us = runtime_us;
 183         return runtime_us;
 184
 185 out_err:
 186         return OSNOISE_TIME_INIT_VAL;
 187 }
 188
 189 /*
 190  * osnoise_get_period - return the original "osnoise/period_us" value
 191  *
 192  * It also saves the value to be restored.
 193  */
 194 unsigned long long osnoise_get_period(struct osnoise_context *context)
 195 {
 196         long long period_us;
 197
 198         if (context->period_us != OSNOISE_TIME_INIT_VAL)
 199                 return context->period_us;
 200
 201         if (context->orig_period_us != OSNOISE_TIME_INIT_VAL)
 202                 return context->orig_period_us;
 203
 204         period_us = osnoise_read_ll_config("osnoise/period_us");
 205         if (period_us < 0)
 206                 goto out_err;
 207
 208         context->orig_period_us = period_us;
 209         return period_us;
 210
 211 out_err:
 212         return OSNOISE_TIME_INIT_VAL;
 213 }
 214
 215 static int __osnoise_write_runtime(struct osnoise_context *context,
 216                                    unsigned long long runtime)
 217 {
 218         int retval;
 219
 220         if (context->orig_runtime_us == OSNOISE_TIME_INIT_VAL)
 221                 return -1;
 222
 223         retval = osnoise_write_ll_config("osnoise/runtime_us", runtime);
 224         if (retval < 0)
 225                 return -1;
 226
 227         context->runtime_us = runtime;
 228         return 0;
 229 }
 230
 231 static int __osnoise_write_period(struct osnoise_context *context,
 232                                   unsigned long long period)
 233 {
 234         int retval;
 235
 236         if (context->orig_period_us == OSNOISE_TIME_INIT_VAL)
 237                 return -1;
 238
 239         retval = osnoise_write_ll_config("osnoise/period_us", period);
 240         if (retval < 0)
 241                 return -1;
 242
 243         context->period_us = period;
 244         return 0;
 245 }
 246
 247 /*
 248  * osnoise_set_runtime_period - set osnoise runtime and period
 249  *
 250  * Osnoise's runtime and period are related as runtime <= period.
 251  * Thus, this function saves the original values, and then tries
 252  * to set the runtime and period if they are != 0.
 253  */
 254 int osnoise_set_runtime_period(struct osnoise_context *context,
 255                                unsigned long long runtime,
 256                                unsigned long long period)
 257 {
 258         unsigned long long curr_runtime_us;
 259         unsigned long long curr_period_us;
 260         int retval;
 261
 262         if (!period && !runtime)
 263                 return 0;
 264
 265         curr_runtime_us = osnoise_get_runtime(context);
 266         curr_period_us = osnoise_get_period(context);
 267
 268         /* error getting any value? */
 269         if (curr_period_us == OSNOISE_TIME_INIT_VAL || curr_runtime_us == OSNOISE_TIME_INIT_VAL)
 270                 return -1;
 271
 272         if (!period) {
 273                 if (runtime > curr_period_us)
 274                         return -1;
 275                 return __osnoise_write_runtime(context, runtime);
 276         } else if (!runtime) {
 277                 if (period < curr_runtime_us)
 278                         return -1;
 279                 return __osnoise_write_period(context, period);
 280         }
 281
 282         if (runtime > curr_period_us) {
 283                 retval = __osnoise_write_period(context, period);
 284                 if (retval)
 285                         return -1;
 286                 retval = __osnoise_write_runtime(context, runtime);
 287                 if (retval)
 288                         return -1;
 289         } else {
 290                 retval = __osnoise_write_runtime(context, runtime);
 291                 if (retval)
 292                         return -1;
 293                 retval = __osnoise_write_period(context, period);
 294                 if (retval)
 295                         return -1;
 296         }
 297
 298         return 0;
 299 }
 300
 301 /*
 302  * osnoise_restore_runtime_period - restore the original runtime and period
 303  */
 304 void osnoise_restore_runtime_period(struct osnoise_context *context)
 305 {
 306         unsigned long long orig_runtime = context->orig_runtime_us;
 307         unsigned long long orig_period = context->orig_period_us;
 308         unsigned long long curr_runtime = context->runtime_us;
 309         unsigned long long curr_period = context->period_us;
 310         int retval;
 311
 312         if ((orig_runtime == OSNOISE_TIME_INIT_VAL) && (orig_period == OSNOISE_TIME_INIT_VAL))
 313                 return;
 314
 315         if ((orig_period == curr_period) && (orig_runtime == curr_runtime))
 316                 goto out_done;
 317
 318         retval = osnoise_set_runtime_period(context, orig_runtime, orig_period);
 319         if (retval)
 320                 err_msg("Could not restore original osnoise runtime/period\n");
 321
 322 out_done:
 323         context->runtime_us = OSNOISE_TIME_INIT_VAL;
 324         context->period_us = OSNOISE_TIME_INIT_VAL;
 325 }
 326
 327 /*
 328  * osnoise_put_runtime_period - restore original values and cleanup data
 329  */
 330 void osnoise_put_runtime_period(struct osnoise_context *context)
 331 {
 332         osnoise_restore_runtime_period(context);
 333
 334         if (context->orig_runtime_us != OSNOISE_TIME_INIT_VAL)
 335                 context->orig_runtime_us = OSNOISE_TIME_INIT_VAL;
 336
 337         if (context->orig_period_us != OSNOISE_TIME_INIT_VAL)
 338                 context->orig_period_us = OSNOISE_TIME_INIT_VAL;
 339 }
 340
 341 /*
 342  * osnoise_get_timerlat_period_us - read and save the original "timerlat_period_us"
 343  */
 344 static long long
 345 osnoise_get_timerlat_period_us(struct osnoise_context *context)
 346 {
 347         long long timerlat_period_us;
 348
 349         if (context->timerlat_period_us != OSNOISE_TIME_INIT_VAL)
 350                 return context->timerlat_period_us;
 351
 352         if (context->orig_timerlat_period_us != OSNOISE_TIME_INIT_VAL)
 353                 return context->orig_timerlat_period_us;
 354
 355         timerlat_period_us = osnoise_read_ll_config("osnoise/timerlat_period_us");
 356         if (timerlat_period_us < 0)
 357                 goto out_err;
 358
 359         context->orig_timerlat_period_us = timerlat_period_us;
 360         return timerlat_period_us;
 361
 362 out_err:
 363         return OSNOISE_TIME_INIT_VAL;
 364 }
 365
 366 /*
 367  * osnoise_set_timerlat_period_us - set "timerlat_period_us"
 368  */
 369 int osnoise_set_timerlat_period_us(struct osnoise_context *context, long long timerlat_period_us)
 370 {
 371         long long curr_timerlat_period_us = osnoise_get_timerlat_period_us(context);
 372         int retval;
 373
 374         if (curr_timerlat_period_us == OSNOISE_TIME_INIT_VAL)
 375                 return -1;
 376
 377         retval = osnoise_write_ll_config("osnoise/timerlat_period_us", timerlat_period_us);
 378         if (retval < 0)
 379                 return -1;
 380
 381         context->timerlat_period_us = timerlat_period_us;
 382
 383         return 0;
 384 }
 385
 386 /*
 387  * osnoise_restore_timerlat_period_us - restore "timerlat_period_us"
 388  */
 389 void osnoise_restore_timerlat_period_us(struct osnoise_context *context)
 390 {
 391         int retval;
 392
 393         if (context->orig_timerlat_period_us == OSNOISE_TIME_INIT_VAL)
 394                 return;
 395
 396         if (context->orig_timerlat_period_us == context->timerlat_period_us)
 397                 goto out_done;
 398
 399         retval = osnoise_write_ll_config("osnoise/timerlat_period_us", context->orig_timerlat_period_us);
 400         if (retval < 0)
 401                 err_msg("Could not restore original osnoise timerlat_period_us\n");
 402
 403 out_done:
 404         context->timerlat_period_us = OSNOISE_TIME_INIT_VAL;
 405 }
 406
 407 /*
 408  * osnoise_put_timerlat_period_us - restore original values and cleanup data
 409  */
 410 void osnoise_put_timerlat_period_us(struct osnoise_context *context)
 411 {
 412         osnoise_restore_timerlat_period_us(context);
 413
 414         if (context->orig_timerlat_period_us == OSNOISE_TIME_INIT_VAL)
 415                 return;
 416
 417         context->orig_timerlat_period_us = OSNOISE_TIME_INIT_VAL;
 418 }
 419
 420 /*
 421  * osnoise_get_stop_us - read and save the original "stop_tracing_us"
 422  */
 423 static long long
 424 osnoise_get_stop_us(struct osnoise_context *context)
 425 {
 426         long long stop_us;
 427
 428         if (context->stop_us != OSNOISE_OPTION_INIT_VAL)
 429                 return context->stop_us;
 430
 431         if (context->orig_stop_us != OSNOISE_OPTION_INIT_VAL)
 432                 return context->orig_stop_us;
 433
 434         stop_us = osnoise_read_ll_config("osnoise/stop_tracing_us");
 435         if (stop_us < 0)
 436                 goto out_err;
 437
 438         context->orig_stop_us = stop_us;
 439         return stop_us;
 440
 441 out_err:
 442         return OSNOISE_OPTION_INIT_VAL;
 443 }
 444
 445 /*
 446  * osnoise_set_stop_us - set "stop_tracing_us"
 447  */
 448 int osnoise_set_stop_us(struct osnoise_context *context, long long stop_us)
 449 {
 450         long long curr_stop_us = osnoise_get_stop_us(context);
 451         int retval;
 452
 453         if (curr_stop_us == OSNOISE_OPTION_INIT_VAL)
 454                 return -1;
 455
 456         retval = osnoise_write_ll_config("osnoise/stop_tracing_us", stop_us);
 457         if (retval < 0)
 458                 return -1;
 459
 460         context->stop_us = stop_us;
 461
 462         return 0;
 463 }
 464
 465 /*
 466  * osnoise_restore_stop_us - restore the original "stop_tracing_us"
 467  */
 468 void osnoise_restore_stop_us(struct osnoise_context *context)
 469 {
 470         int retval;
 471
 472         if (context->orig_stop_us == OSNOISE_OPTION_INIT_VAL)
 473                 return;
 474
 475         if (context->orig_stop_us == context->stop_us)
 476                 goto out_done;
 477
 478         retval = osnoise_write_ll_config("osnoise/stop_tracing_us", context->orig_stop_us);
 479         if (retval < 0)
 480                 err_msg("Could not restore original osnoise stop_us\n");
 481
 482 out_done:
 483         context->stop_us = OSNOISE_OPTION_INIT_VAL;
 484 }
 485
 486 /*
 487  * osnoise_put_stop_us - restore original values and cleanup data
 488  */
 489 void osnoise_put_stop_us(struct osnoise_context *context)
 490 {
 491         osnoise_restore_stop_us(context);
 492
 493         if (context->orig_stop_us == OSNOISE_OPTION_INIT_VAL)
 494                 return;
 495
 496         context->orig_stop_us = OSNOISE_OPTION_INIT_VAL;
 497 }
 498
 499 /*
 500  * osnoise_get_stop_total_us - read and save the original "stop_tracing_total_us"
 501  */
 502 static long long
 503 osnoise_get_stop_total_us(struct osnoise_context *context)
 504 {
 505         long long stop_total_us;
 506
 507         if (context->stop_total_us != OSNOISE_OPTION_INIT_VAL)
 508                 return context->stop_total_us;
 509
 510         if (context->orig_stop_total_us != OSNOISE_OPTION_INIT_VAL)
 511                 return context->orig_stop_total_us;
 512
 513         stop_total_us = osnoise_read_ll_config("osnoise/stop_tracing_total_us");
 514         if (stop_total_us < 0)
 515                 goto out_err;
 516
 517         context->orig_stop_total_us = stop_total_us;
 518         return stop_total_us;
 519
 520 out_err:
 521         return OSNOISE_OPTION_INIT_VAL;
 522 }
 523
 524 /*
 525  * osnoise_set_stop_total_us - set "stop_tracing_total_us"
 526  */
 527 int osnoise_set_stop_total_us(struct osnoise_context *context, long long stop_total_us)
 528 {
 529         long long curr_stop_total_us = osnoise_get_stop_total_us(context);
 530         int retval;
 531
 532         if (curr_stop_total_us == OSNOISE_OPTION_INIT_VAL)
 533                 return -1;
 534
 535         retval = osnoise_write_ll_config("osnoise/stop_tracing_total_us", stop_total_us);
 536         if (retval < 0)
 537                 return -1;
 538
 539         context->stop_total_us = stop_total_us;
 540
 541         return 0;
 542 }
 543
 544 /*
 545  * osnoise_restore_stop_total_us - restore the original "stop_tracing_total_us"
 546  */
 547 void osnoise_restore_stop_total_us(struct osnoise_context *context)
 548 {
 549         int retval;
 550
 551         if (context->orig_stop_total_us == OSNOISE_OPTION_INIT_VAL)
 552                 return;
 553
 554         if (context->orig_stop_total_us == context->stop_total_us)
 555                 goto out_done;
 556
 557         retval = osnoise_write_ll_config("osnoise/stop_tracing_total_us",
 558                         context->orig_stop_total_us);
 559         if (retval < 0)
 560                 err_msg("Could not restore original osnoise stop_total_us\n");
 561
 562 out_done:
 563         context->stop_total_us = OSNOISE_OPTION_INIT_VAL;
 564 }
 565
 566 /*
 567  * osnoise_put_stop_total_us - restore original values and cleanup data
 568  */
 569 void osnoise_put_stop_total_us(struct osnoise_context *context)
 570 {
 571         osnoise_restore_stop_total_us(context);
 572
 573         if (context->orig_stop_total_us == OSNOISE_OPTION_INIT_VAL)
 574                 return;
 575
 576         context->orig_stop_total_us = OSNOISE_OPTION_INIT_VAL;
 577 }
 578
 579 /*
 580  * osnoise_get_print_stack - read and save the original "print_stack"
 581  */
 582 static long long
 583 osnoise_get_print_stack(struct osnoise_context *context)
 584 {
 585         long long print_stack;
 586
 587         if (context->print_stack != OSNOISE_OPTION_INIT_VAL)
 588                 return context->print_stack;
 589
 590         if (context->orig_print_stack != OSNOISE_OPTION_INIT_VAL)
 591                 return context->orig_print_stack;
 592
 593         print_stack = osnoise_read_ll_config("osnoise/print_stack");
 594         if (print_stack < 0)
 595                 goto out_err;
 596
 597         context->orig_print_stack = print_stack;
 598         return print_stack;
 599
 600 out_err:
 601         return OSNOISE_OPTION_INIT_VAL;
 602 }
 603
 604 /*
 605  * osnoise_set_print_stack - set "print_stack"
 606  */
 607 int osnoise_set_print_stack(struct osnoise_context *context, long long print_stack)
 608 {
 609         long long curr_print_stack = osnoise_get_print_stack(context);
 610         int retval;
 611
 612         if (curr_print_stack == OSNOISE_OPTION_INIT_VAL)
 613                 return -1;
 614
 615         retval = osnoise_write_ll_config("osnoise/print_stack", print_stack);
 616         if (retval < 0)
 617                 return -1;
 618
 619         context->print_stack = print_stack;
 620
 621         return 0;
 622 }
 623
 624 /*
 625  * osnoise_restore_print_stack - restore the original "print_stack"
 626  */
 627 void osnoise_restore_print_stack(struct osnoise_context *context)
 628 {
 629         int retval;
 630
 631         if (context->orig_print_stack == OSNOISE_OPTION_INIT_VAL)
 632                 return;
 633
 634         if (context->orig_print_stack == context->print_stack)
 635                 goto out_done;
 636
 637         retval = osnoise_write_ll_config("osnoise/print_stack", context->orig_print_stack);
 638         if (retval < 0)
 639                 err_msg("Could not restore original osnoise print_stack\n");
 640
 641 out_done:
 642         context->print_stack = OSNOISE_OPTION_INIT_VAL;
 643 }
 644
 645 /*
 646  * osnoise_put_print_stack - restore original values and cleanup data
 647  */
 648 void osnoise_put_print_stack(struct osnoise_context *context)
 649 {
 650         osnoise_restore_print_stack(context);
 651
 652         if (context->orig_print_stack == OSNOISE_OPTION_INIT_VAL)
 653                 return;
 654
 655         context->orig_print_stack = OSNOISE_OPTION_INIT_VAL;
 656 }
 657
 658 /*
 659  * enable_osnoise - enable osnoise tracer in the trace_instance
 660  */
 661 int enable_osnoise(struct trace_instance *trace)
 662 {
 663         return enable_tracer_by_name(trace->inst, "osnoise");
 664 }
 665
 666 /*
 667  * enable_timerlat - enable timerlat tracer in the trace_instance
 668  */
 669 int enable_timerlat(struct trace_instance *trace)
 670 {
 671         return enable_tracer_by_name(trace->inst, "timerlat");
 672 }
 673
 674 enum {
 675         FLAG_CONTEXT_NEWLY_CREATED      = (1 << 0),
 676         FLAG_CONTEXT_DELETED            = (1 << 1),
 677 };
 678
 679 /*
 680  * osnoise_get_context - increase the usage of a context and return it
 681  */
 682 int osnoise_get_context(struct osnoise_context *context)
 683 {
 684         int ret;
 685
 686         if (context->flags & FLAG_CONTEXT_DELETED) {
 687                 ret = -1;
 688         } else {
 689                 context->ref++;
 690                 ret = 0;
 691         }
 692
 693         return ret;
 694 }
 695
 696 /*
 697  * osnoise_context_alloc - alloc an osnoise_context
 698  *
 699  * The osnoise context contains the information of the "osnoise/" configs.
 700  * It is used to set and restore the config.
 701  */
 702 struct osnoise_context *osnoise_context_alloc(void)
 703 {
 704         struct osnoise_context *context;
 705
 706         context = calloc(1, sizeof(*context));
 707         if (!context)
 708                 return NULL;
 709
 710         context->orig_stop_us           = OSNOISE_OPTION_INIT_VAL;
 711         context->stop_us                = OSNOISE_OPTION_INIT_VAL;
 712
 713         context->orig_stop_total_us     = OSNOISE_OPTION_INIT_VAL;
 714         context->stop_total_us          = OSNOISE_OPTION_INIT_VAL;
 715
 716         context->orig_print_stack       = OSNOISE_OPTION_INIT_VAL;
 717         context->print_stack            = OSNOISE_OPTION_INIT_VAL;
 718
 719         osnoise_get_context(context);
 720
 721         return context;
 722 }
 723
 724 /*
 725  * osnoise_put_context - put the osnoise_put_context
 726  *
 727  * If there is no other user for the context, the original data
 728  * is restored.
 729  */
 730 void osnoise_put_context(struct osnoise_context *context)
 731 {
 732         if (--context->ref < 1)
 733                 context->flags |= FLAG_CONTEXT_DELETED;
 734
 735         if (!(context->flags & FLAG_CONTEXT_DELETED))
 736                 return;
 737
 738         osnoise_put_cpus(context);
 739         osnoise_put_runtime_period(context);
 740         osnoise_put_stop_us(context);
 741         osnoise_put_stop_total_us(context);
 742         osnoise_put_timerlat_period_us(context);
 743         osnoise_put_print_stack(context);
 744
 745         free(context);
 746 }
 747
 748 /*
 749  * osnoise_destroy_tool - disable trace, restore configs and free data
 750  */
 751 void osnoise_destroy_tool(struct osnoise_tool *top)
 752 {
 753         trace_instance_destroy(&top->trace);
 754
 755         if (top->context)
 756                 osnoise_put_context(top->context);
 757
 758         free(top);
 759 }
 760
 761 /*
 762  * osnoise_init_tool - init an osnoise tool
 763  *
 764  * It allocs data, create a context to store data and
 765  * creates a new trace instance for the tool.
 766  */
 767 struct osnoise_tool *osnoise_init_tool(char *tool_name)
 768 {
 769         struct osnoise_tool *top;
 770         int retval;
 771
 772         top = calloc(1, sizeof(*top));
 773         if (!top)
 774                 return NULL;
 775
 776         top->context = osnoise_context_alloc();
 777         if (!top->context)
 778                 goto out_err;
 779
 780         retval = trace_instance_init(&top->trace, tool_name);
 781         if (retval)
 782                 goto out_err;
 783
 784         return top;
 785 out_err:
 786         osnoise_destroy_tool(top);
 787         return NULL;
 788 }
 789
 790 /*
 791  * osnoise_init_trace_tool - init a tracer instance to trace osnoise events
 792  */
 793 struct osnoise_tool *osnoise_init_trace_tool(char *tracer)
 794 {
 795         struct osnoise_tool *trace;
 796         int retval;
 797
 798         trace = osnoise_init_tool("osnoise_trace");
 799         if (!trace)
 800                 return NULL;
 801
 802         retval = tracefs_event_enable(trace->trace.inst, "osnoise", NULL);
 803         if (retval < 0 && !errno) {
 804                 err_msg("Could not find osnoise events\n");
 805                 goto out_err;
 806         }
 807
 808         retval = enable_tracer_by_name(trace->trace.inst, tracer);
 809         if (retval) {
 810                 err_msg("Could not enable osnoiser tracer for tracing\n");
 811                 goto out_err;
 812         }
 813
 814         return trace;
 815 out_err:
 816         osnoise_destroy_tool(trace);
 817         return NULL;
 818 }
 819
 820 static void osnoise_usage(void)
 821 {
 822         int i;
 823
 824         static const char *msg[] = {
 825                 "",
 826                 "osnoise version " VERSION,
 827                 "",
 828                 "  usage: [rtla] osnoise [MODE] ...",
 829                 "",
 830                 "  modes:",
 831                 "     top   - prints the summary from osnoise tracer",
 832                 "     hist  - prints a histogram of osnoise samples",
 833                 "",
 834                 "if no MODE is given, the top mode is called, passing the arguments",
 835                 NULL,
 836         };
 837
 838         for (i = 0; msg[i]; i++)
 839                 fprintf(stderr, "%s\n", msg[i]);
 840         exit(1);
 841 }
 842
 843 int osnoise_main(int argc, char *argv[])
 844 {
 845         if (argc == 0)
 846                 goto usage;
 847
 848         /*
 849          * if osnoise was called without any argument, run the
 850          * default cmdline.
 851          */
 852         if (argc == 1) {
 853                 osnoise_top_main(argc, argv);
 854                 exit(0);
 855         }
 856
 857         if ((strcmp(argv[1], "-h") == 0) || (strcmp(argv[1], "--help") == 0)) {
 858                 osnoise_usage();
 859                 exit(0);
 860         } else if (strncmp(argv[1], "-", 1) == 0) {
 861                 /* the user skipped the tool, call the default one */
 862                 osnoise_top_main(argc, argv);
 863                 exit(0);
 864         } else if (strcmp(argv[1], "top") == 0) {
 865                 osnoise_top_main(argc-1, &argv[1]);
 866                 exit(0);
 867         } else if (strcmp(argv[1], "hist") == 0) {
 868                 osnoise_hist_main(argc-1, &argv[1]);
 869                 exit(0);
 870         }
 871
 872 usage:
 873         osnoise_usage();
 874         exit(1);
 875 }