tools/perf/util/time-utils.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <linux/string.h>
   5 #include <sys/time.h>
   6 #include <linux/time64.h>
   7 #include <time.h>
   8 #include <errno.h>
   9 #include <inttypes.h>
  10 #include <math.h>
  11 #include <linux/ctype.h>
  12
  13 #include "debug.h"
  14 #include "time-utils.h"
  15 #include "session.h"
  16 #include "evlist.h"
  17
  18 int parse_nsec_time(const char *str, u64 *ptime)
  19 {
  20         u64 time_sec, time_nsec;
  21         char *end;
  22
  23         time_sec = strtoul(str, &end, 10);
  24         if (*end != '.' && *end != '\0')
  25                 return -1;
  26
  27         if (*end == '.') {
  28                 int i;
  29                 char nsec_buf[10];
  30
  31                 if (strlen(++end) > 9)
  32                         return -1;
  33
  34                 strncpy(nsec_buf, end, 9);
  35                 nsec_buf[9] = '\0';
  36
  37                 /* make it nsec precision */
  38                 for (i = strlen(nsec_buf); i < 9; i++)
  39                         nsec_buf[i] = '0';
  40
  41                 time_nsec = strtoul(nsec_buf, &end, 10);
  42                 if (*end != '\0')
  43                         return -1;
  44         } else
  45                 time_nsec = 0;
  46
  47         *ptime = time_sec * NSEC_PER_SEC + time_nsec;
  48         return 0;
  49 }
  50
  51 static int parse_timestr_sec_nsec(struct perf_time_interval *ptime,
  52                                   char *start_str, char *end_str)
  53 {
  54         if (start_str && (*start_str != '\0') &&
  55             (parse_nsec_time(start_str, &ptime->start) != 0)) {
  56                 return -1;
  57         }
  58
  59         if (end_str && (*end_str != '\0') &&
  60             (parse_nsec_time(end_str, &ptime->end) != 0)) {
  61                 return -1;
  62         }
  63
  64         return 0;
  65 }
  66
  67 static int split_start_end(char **start, char **end, const char *ostr, char ch)
  68 {
  69         char *start_str, *end_str;
  70         char *d, *str;
  71
  72         if (ostr == NULL || *ostr == '\0')
  73                 return 0;
  74
  75         /* copy original string because we need to modify it */
  76         str = strdup(ostr);
  77         if (str == NULL)
  78                 return -ENOMEM;
  79
  80         start_str = str;
  81         d = strchr(start_str, ch);
  82         if (d) {
  83                 *d = '\0';
  84                 ++d;
  85         }
  86         end_str = d;
  87
  88         *start = start_str;
  89         *end = end_str;
  90
  91         return 0;
  92 }
  93
  94 int perf_time__parse_str(struct perf_time_interval *ptime, const char *ostr)
  95 {
  96         char *start_str = NULL, *end_str;
  97         int rc;
  98
  99         rc = split_start_end(&start_str, &end_str, ostr, ',');
 100         if (rc || !start_str)
 101                 return rc;
 102
 103         ptime->start = 0;
 104         ptime->end = 0;
 105
 106         rc = parse_timestr_sec_nsec(ptime, start_str, end_str);
 107
 108         free(start_str);
 109
 110         /* make sure end time is after start time if it was given */
 111         if (rc == 0 && ptime->end && ptime->end < ptime->start)
 112                 return -EINVAL;
 113
 114         pr_debug("start time %" PRIu64 ", ", ptime->start);
 115         pr_debug("end time %" PRIu64 "\n", ptime->end);
 116
 117         return rc;
 118 }
 119
 120 static int perf_time__parse_strs(struct perf_time_interval *ptime,
 121                                  const char *ostr, int size)
 122 {
 123         const char *cp;
 124         char *str, *arg, *p;
 125         int i, num = 0, rc = 0;
 126
 127         /* Count the commas */
 128         for (cp = ostr; *cp; cp++)
 129                 num += !!(*cp == ',');
 130
 131         if (!num)
 132                 return -EINVAL;
 133
 134         BUG_ON(num > size);
 135
 136         str = strdup(ostr);
 137         if (!str)
 138                 return -ENOMEM;
 139
 140         /* Split the string and parse each piece, except the last */
 141         for (i = 0, p = str; i < num - 1; i++) {
 142                 arg = p;
 143                 /* Find next comma, there must be one */
 144                 p = skip_spaces(strchr(p, ',') + 1);
 145                 /* Skip the value, must not contain space or comma */
 146                 while (*p && !isspace(*p)) {
 147                         if (*p++ == ',') {
 148                                 rc = -EINVAL;
 149                                 goto out;
 150                         }
 151                 }
 152                 /* Split and parse */
 153                 if (*p)
 154                         *p++ = 0;
 155                 rc = perf_time__parse_str(ptime + i, arg);
 156                 if (rc < 0)
 157                         goto out;
 158         }
 159
 160         /* Parse the last piece */
 161         rc = perf_time__parse_str(ptime + i, p);
 162         if (rc < 0)
 163                 goto out;
 164
 165         /* Check there is no overlap */
 166         for (i = 0; i < num - 1; i++) {
 167                 if (ptime[i].end >= ptime[i + 1].start) {
 168                         rc = -EINVAL;
 169                         goto out;
 170                 }
 171         }
 172
 173         rc = num;
 174 out:
 175         free(str);
 176
 177         return rc;
 178 }
 179
 180 static int parse_percent(double *pcnt, char *str)
 181 {
 182         char *c, *endptr;
 183         double d;
 184
 185         c = strchr(str, '%');
 186         if (c)
 187                 *c = '\0';
 188         else
 189                 return -1;
 190
 191         d = strtod(str, &endptr);
 192         if (endptr != str + strlen(str))
 193                 return -1;
 194
 195         *pcnt = d / 100.0;
 196         return 0;
 197 }
 198
 199 static int set_percent_time(struct perf_time_interval *ptime, double start_pcnt,
 200                             double end_pcnt, u64 start, u64 end)
 201 {
 202         u64 total = end - start;
 203
 204         if (start_pcnt < 0.0 || start_pcnt > 1.0 ||
 205             end_pcnt < 0.0 || end_pcnt > 1.0) {
 206                 return -1;
 207         }
 208
 209         ptime->start = start + round(start_pcnt * total);
 210         ptime->end = start + round(end_pcnt * total);
 211
 212         if (ptime->end > ptime->start && ptime->end != end)
 213                 ptime->end -= 1;
 214
 215         return 0;
 216 }
 217
 218 static int percent_slash_split(char *str, struct perf_time_interval *ptime,
 219                                u64 start, u64 end)
 220 {
 221         char *p, *end_str;
 222         double pcnt, start_pcnt, end_pcnt;
 223         int i;
 224
 225         /*
 226          * Example:
 227          * 10%/2: select the second 10% slice and the third 10% slice
 228          */
 229
 230         /* We can modify this string since the original one is copied */
 231         p = strchr(str, '/');
 232         if (!p)
 233                 return -1;
 234
 235         *p = '\0';
 236         if (parse_percent(&pcnt, str) < 0)
 237                 return -1;
 238
 239         p++;
 240         i = (int)strtol(p, &end_str, 10);
 241         if (*end_str)
 242                 return -1;
 243
 244         if (pcnt <= 0.0)
 245                 return -1;
 246
 247         start_pcnt = pcnt * (i - 1);
 248         end_pcnt = pcnt * i;
 249
 250         return set_percent_time(ptime, start_pcnt, end_pcnt, start, end);
 251 }
 252
 253 static int percent_dash_split(char *str, struct perf_time_interval *ptime,
 254                               u64 start, u64 end)
 255 {
 256         char *start_str = NULL, *end_str;
 257         double start_pcnt, end_pcnt;
 258         int ret;
 259
 260         /*
 261          * Example: 0%-10%
 262          */
 263
 264         ret = split_start_end(&start_str, &end_str, str, '-');
 265         if (ret || !start_str)
 266                 return ret;
 267
 268         if ((parse_percent(&start_pcnt, start_str) != 0) ||
 269             (parse_percent(&end_pcnt, end_str) != 0)) {
 270                 free(start_str);
 271                 return -1;
 272         }
 273
 274         free(start_str);
 275
 276         return set_percent_time(ptime, start_pcnt, end_pcnt, start, end);
 277 }
 278
 279 typedef int (*time_pecent_split)(char *, struct perf_time_interval *,
 280                                  u64 start, u64 end);
 281
 282 static int percent_comma_split(struct perf_time_interval *ptime_buf, int num,
 283                                const char *ostr, u64 start, u64 end,
 284                                time_pecent_split func)
 285 {
 286         char *str, *p1, *p2;
 287         int len, ret, i = 0;
 288
 289         str = strdup(ostr);
 290         if (str == NULL)
 291                 return -ENOMEM;
 292
 293         len = strlen(str);
 294         p1 = str;
 295
 296         while (p1 < str + len) {
 297                 if (i >= num) {
 298                         free(str);
 299                         return -1;
 300                 }
 301
 302                 p2 = strchr(p1, ',');
 303                 if (p2)
 304                         *p2 = '\0';
 305
 306                 ret = (func)(p1, &ptime_buf[i], start, end);
 307                 if (ret < 0) {
 308                         free(str);
 309                         return -1;
 310                 }
 311
 312                 pr_debug("start time %d: %" PRIu64 ", ", i, ptime_buf[i].start);
 313                 pr_debug("end time %d: %" PRIu64 "\n", i, ptime_buf[i].end);
 314
 315                 i++;
 316
 317                 if (p2)
 318                         p1 = p2 + 1;
 319                 else
 320                         break;
 321         }
 322
 323         free(str);
 324         return i;
 325 }
 326
 327 static int one_percent_convert(struct perf_time_interval *ptime_buf,
 328                                const char *ostr, u64 start, u64 end, char *c)
 329 {
 330         char *str;
 331         int len = strlen(ostr), ret;
 332
 333         /*
 334          * c points to '%'.
 335          * '%' should be the last character
 336          */
 337         if (ostr + len - 1 != c)
 338                 return -1;
 339
 340         /*
 341          * Construct a string like "xx%/1"
 342          */
 343         str = malloc(len + 3);
 344         if (str == NULL)
 345                 return -ENOMEM;
 346
 347         memcpy(str, ostr, len);
 348         strcpy(str + len, "/1");
 349
 350         ret = percent_slash_split(str, ptime_buf, start, end);
 351         if (ret == 0)
 352                 ret = 1;
 353
 354         free(str);
 355         return ret;
 356 }
 357
 358 int perf_time__percent_parse_str(struct perf_time_interval *ptime_buf, int num,
 359                                  const char *ostr, u64 start, u64 end)
 360 {
 361         char *c;
 362
 363         /*
 364          * ostr example:
 365          * 10%/2,10%/3: select the second 10% slice and the third 10% slice
 366          * 0%-10%,30%-40%: multiple time range
 367          * 50%: just one percent
 368          */
 369
 370         memset(ptime_buf, 0, sizeof(*ptime_buf) * num);
 371
 372         c = strchr(ostr, '/');
 373         if (c) {
 374                 return percent_comma_split(ptime_buf, num, ostr, start,
 375                                            end, percent_slash_split);
 376         }
 377
 378         c = strchr(ostr, '-');
 379         if (c) {
 380                 return percent_comma_split(ptime_buf, num, ostr, start,
 381                                            end, percent_dash_split);
 382         }
 383
 384         c = strchr(ostr, '%');
 385         if (c)
 386                 return one_percent_convert(ptime_buf, ostr, start, end, c);
 387
 388         return -1;
 389 }
 390
 391 struct perf_time_interval *perf_time__range_alloc(const char *ostr, int *size)
 392 {
 393         const char *p1, *p2;
 394         int i = 1;
 395         struct perf_time_interval *ptime;
 396
 397         /*
 398          * At least allocate one time range.
 399          */
 400         if (!ostr)
 401                 goto alloc;
 402
 403         p1 = ostr;
 404         while (p1 < ostr + strlen(ostr)) {
 405                 p2 = strchr(p1, ',');
 406                 if (!p2)
 407                         break;
 408
 409                 p1 = p2 + 1;
 410                 i++;
 411         }
 412
 413 alloc:
 414         *size = i;
 415         ptime = calloc(i, sizeof(*ptime));
 416         return ptime;
 417 }
 418
 419 bool perf_time__skip_sample(struct perf_time_interval *ptime, u64 timestamp)
 420 {
 421         /* if time is not set don't drop sample */
 422         if (timestamp == 0)
 423                 return false;
 424
 425         /* otherwise compare sample time to time window */
 426         if ((ptime->start && timestamp < ptime->start) ||
 427             (ptime->end && timestamp > ptime->end)) {
 428                 return true;
 429         }
 430
 431         return false;
 432 }
 433
 434 bool perf_time__ranges_skip_sample(struct perf_time_interval *ptime_buf,
 435                                    int num, u64 timestamp)
 436 {
 437         struct perf_time_interval *ptime;
 438         int i;
 439
 440         if ((!ptime_buf) || (timestamp == 0) || (num == 0))
 441                 return false;
 442
 443         if (num == 1)
 444                 return perf_time__skip_sample(&ptime_buf[0], timestamp);
 445
 446         /*
 447          * start/end of multiple time ranges must be valid.
 448          */
 449         for (i = 0; i < num; i++) {
 450                 ptime = &ptime_buf[i];
 451
 452                 if (timestamp >= ptime->start &&
 453                     (timestamp <= ptime->end || !ptime->end)) {
 454                         return false;
 455                 }
 456         }
 457
 458         return true;
 459 }
 460
 461 int perf_time__parse_for_ranges_reltime(const char *time_str,
 462                                 struct perf_session *session,
 463                                 struct perf_time_interval **ranges,
 464                                 int *range_size, int *range_num,
 465                                 bool reltime)
 466 {
 467         bool has_percent = strchr(time_str, '%');
 468         struct perf_time_interval *ptime_range;
 469         int size, num, ret = -EINVAL;
 470
 471         ptime_range = perf_time__range_alloc(time_str, &size);
 472         if (!ptime_range)
 473                 return -ENOMEM;
 474
 475         if (has_percent || reltime) {
 476                 if (session->evlist->first_sample_time == 0 &&
 477                     session->evlist->last_sample_time == 0) {
 478                         pr_err("HINT: no first/last sample time found in perf data.\n"
 479                                "Please use latest perf binary to execute 'perf record'\n"
 480                                "(if '--buildid-all' is enabled, please set '--timestamp-boundary').\n");
 481                         goto error;
 482                 }
 483         }
 484
 485         if (has_percent) {
 486                 num = perf_time__percent_parse_str(
 487                                 ptime_range, size,
 488                                 time_str,
 489                                 session->evlist->first_sample_time,
 490                                 session->evlist->last_sample_time);
 491         } else {
 492                 num = perf_time__parse_strs(ptime_range, time_str, size);
 493         }
 494
 495         if (num < 0)
 496                 goto error_invalid;
 497
 498         if (reltime) {
 499                 int i;
 500
 501                 for (i = 0; i < num; i++) {
 502                         ptime_range[i].start += session->evlist->first_sample_time;
 503                         ptime_range[i].end += session->evlist->first_sample_time;
 504                 }
 505         }
 506
 507         *range_size = size;
 508         *range_num = num;
 509         *ranges = ptime_range;
 510         return 0;
 511
 512 error_invalid:
 513         pr_err("Invalid time string\n");
 514 error:
 515         free(ptime_range);
 516         return ret;
 517 }
 518
 519 int perf_time__parse_for_ranges(const char *time_str,
 520                                 struct perf_session *session,
 521                                 struct perf_time_interval **ranges,
 522                                 int *range_size, int *range_num)
 523 {
 524         return perf_time__parse_for_ranges_reltime(time_str, session, ranges,
 525                                         range_size, range_num, false);
 526 }
 527
 528 int timestamp__scnprintf_usec(u64 timestamp, char *buf, size_t sz)
 529 {
 530         u64  sec = timestamp / NSEC_PER_SEC;
 531         u64 usec = (timestamp % NSEC_PER_SEC) / NSEC_PER_USEC;
 532
 533         return scnprintf(buf, sz, "%"PRIu64".%06"PRIu64, sec, usec);
 534 }
 535
 536 int timestamp__scnprintf_nsec(u64 timestamp, char *buf, size_t sz)
 537 {
 538         u64 sec  = timestamp / NSEC_PER_SEC,
 539             nsec = timestamp % NSEC_PER_SEC;
 540
 541         return scnprintf(buf, sz, "%" PRIu64 ".%09" PRIu64, sec, nsec);
 542 }
 543
 544 int fetch_current_timestamp(char *buf, size_t sz)
 545 {
 546         struct timeval tv;
 547         struct tm tm;
 548         char dt[32];
 549
 550         if (gettimeofday(&tv, NULL) || !localtime_r(&tv.tv_sec, &tm))
 551                 return -1;
 552
 553         if (!strftime(dt, sizeof(dt), "%Y%m%d%H%M%S", &tm))
 554                 return -1;
 555
 556         scnprintf(buf, sz, "%s%02u", dt, (unsigned)tv.tv_usec / 10000);
 557
 558         return 0;
 559 }