tools/perf/util/time-utils.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <sys/time.h>
   5 #include <linux/time64.h>
   6 #include <time.h>
   7 #include <errno.h>
   8 #include <inttypes.h>
   9 #include <math.h>
  10
  11 #include "perf.h"
  12 #include "debug.h"
  13 #include "time-utils.h"
  14
  15 int parse_nsec_time(const char *str, u64 *ptime)
  16 {
  17         u64 time_sec, time_nsec;
  18         char *end;
  19
  20         time_sec = strtoul(str, &end, 10);
  21         if (*end != '.' && *end != '\0')
  22                 return -1;
  23
  24         if (*end == '.') {
  25                 int i;
  26                 char nsec_buf[10];
  27
  28                 if (strlen(++end) > 9)
  29                         return -1;
  30
  31                 strncpy(nsec_buf, end, 9);
  32                 nsec_buf[9] = '\0';
  33
  34                 /* make it nsec precision */
  35                 for (i = strlen(nsec_buf); i < 9; i++)
  36                         nsec_buf[i] = '0';
  37
  38                 time_nsec = strtoul(nsec_buf, &end, 10);
  39                 if (*end != '\0')
  40                         return -1;
  41         } else
  42                 time_nsec = 0;
  43
  44         *ptime = time_sec * NSEC_PER_SEC + time_nsec;
  45         return 0;
  46 }
  47
  48 static int parse_timestr_sec_nsec(struct perf_time_interval *ptime,
  49                                   char *start_str, char *end_str)
  50 {
  51         if (start_str && (*start_str != '\0') &&
  52             (parse_nsec_time(start_str, &ptime->start) != 0)) {
  53                 return -1;
  54         }
  55
  56         if (end_str && (*end_str != '\0') &&
  57             (parse_nsec_time(end_str, &ptime->end) != 0)) {
  58                 return -1;
  59         }
  60
  61         return 0;
  62 }
  63
  64 static int split_start_end(char **start, char **end, const char *ostr, char ch)
  65 {
  66         char *start_str, *end_str;
  67         char *d, *str;
  68
  69         if (ostr == NULL || *ostr == '\0')
  70                 return 0;
  71
  72         /* copy original string because we need to modify it */
  73         str = strdup(ostr);
  74         if (str == NULL)
  75                 return -ENOMEM;
  76
  77         start_str = str;
  78         d = strchr(start_str, ch);
  79         if (d) {
  80                 *d = '\0';
  81                 ++d;
  82         }
  83         end_str = d;
  84
  85         *start = start_str;
  86         *end = end_str;
  87
  88         return 0;
  89 }
  90
  91 int perf_time__parse_str(struct perf_time_interval *ptime, const char *ostr)
  92 {
  93         char *start_str = NULL, *end_str;
  94         int rc;
  95
  96         rc = split_start_end(&start_str, &end_str, ostr, ',');
  97         if (rc || !start_str)
  98                 return rc;
  99
 100         ptime->start = 0;
 101         ptime->end = 0;
 102
 103         rc = parse_timestr_sec_nsec(ptime, start_str, end_str);
 104
 105         free(start_str);
 106
 107         /* make sure end time is after start time if it was given */
 108         if (rc == 0 && ptime->end && ptime->end < ptime->start)
 109                 return -EINVAL;
 110
 111         pr_debug("start time %" PRIu64 ", ", ptime->start);
 112         pr_debug("end time %" PRIu64 "\n", ptime->end);
 113
 114         return rc;
 115 }
 116
 117 static int parse_percent(double *pcnt, char *str)
 118 {
 119         char *c, *endptr;
 120         double d;
 121
 122         c = strchr(str, '%');
 123         if (c)
 124                 *c = '\0';
 125         else
 126                 return -1;
 127
 128         d = strtod(str, &endptr);
 129         if (endptr != str + strlen(str))
 130                 return -1;
 131
 132         *pcnt = d / 100.0;
 133         return 0;
 134 }
 135
 136 static int percent_slash_split(char *str, struct perf_time_interval *ptime,
 137                                u64 start, u64 end)
 138 {
 139         char *p, *end_str;
 140         double pcnt, start_pcnt, end_pcnt;
 141         u64 total = end - start;
 142         int i;
 143
 144         /*
 145          * Example:
 146          * 10%/2: select the second 10% slice and the third 10% slice
 147          */
 148
 149         /* We can modify this string since the original one is copied */
 150         p = strchr(str, '/');
 151         if (!p)
 152                 return -1;
 153
 154         *p = '\0';
 155         if (parse_percent(&pcnt, str) < 0)
 156                 return -1;
 157
 158         p++;
 159         i = (int)strtol(p, &end_str, 10);
 160         if (*end_str)
 161                 return -1;
 162
 163         if (pcnt <= 0.0)
 164                 return -1;
 165
 166         start_pcnt = pcnt * (i - 1);
 167         end_pcnt = pcnt * i;
 168
 169         if (start_pcnt < 0.0 || start_pcnt > 1.0 ||
 170             end_pcnt < 0.0 || end_pcnt > 1.0) {
 171                 return -1;
 172         }
 173
 174         ptime->start = start + round(start_pcnt * total);
 175         ptime->end = start + round(end_pcnt * total);
 176
 177         return 0;
 178 }
 179
 180 static int percent_dash_split(char *str, struct perf_time_interval *ptime,
 181                               u64 start, u64 end)
 182 {
 183         char *start_str = NULL, *end_str;
 184         double start_pcnt, end_pcnt;
 185         u64 total = end - start;
 186         int ret;
 187
 188         /*
 189          * Example: 0%-10%
 190          */
 191
 192         ret = split_start_end(&start_str, &end_str, str, '-');
 193         if (ret || !start_str)
 194                 return ret;
 195
 196         if ((parse_percent(&start_pcnt, start_str) != 0) ||
 197             (parse_percent(&end_pcnt, end_str) != 0)) {
 198                 free(start_str);
 199                 return -1;
 200         }
 201
 202         free(start_str);
 203
 204         if (start_pcnt < 0.0 || start_pcnt > 1.0 ||
 205             end_pcnt < 0.0 || end_pcnt > 1.0 ||
 206             start_pcnt > end_pcnt) {
 207                 return -1;
 208         }
 209
 210         ptime->start = start + round(start_pcnt * total);
 211         ptime->end = start + round(end_pcnt * total);
 212
 213         return 0;
 214 }
 215
 216 typedef int (*time_pecent_split)(char *, struct perf_time_interval *,
 217                                  u64 start, u64 end);
 218
 219 static int percent_comma_split(struct perf_time_interval *ptime_buf, int num,
 220                                const char *ostr, u64 start, u64 end,
 221                                time_pecent_split func)
 222 {
 223         char *str, *p1, *p2;
 224         int len, ret, i = 0;
 225
 226         str = strdup(ostr);
 227         if (str == NULL)
 228                 return -ENOMEM;
 229
 230         len = strlen(str);
 231         p1 = str;
 232
 233         while (p1 < str + len) {
 234                 if (i >= num) {
 235                         free(str);
 236                         return -1;
 237                 }
 238
 239                 p2 = strchr(p1, ',');
 240                 if (p2)
 241                         *p2 = '\0';
 242
 243                 ret = (func)(p1, &ptime_buf[i], start, end);
 244                 if (ret < 0) {
 245                         free(str);
 246                         return -1;
 247                 }
 248
 249                 pr_debug("start time %d: %" PRIu64 ", ", i, ptime_buf[i].start);
 250                 pr_debug("end time %d: %" PRIu64 "\n", i, ptime_buf[i].end);
 251
 252                 i++;
 253
 254                 if (p2)
 255                         p1 = p2 + 1;
 256                 else
 257                         break;
 258         }
 259
 260         free(str);
 261         return i;
 262 }
 263
 264 static int one_percent_convert(struct perf_time_interval *ptime_buf,
 265                                const char *ostr, u64 start, u64 end, char *c)
 266 {
 267         char *str;
 268         int len = strlen(ostr), ret;
 269
 270         /*
 271          * c points to '%'.
 272          * '%' should be the last character
 273          */
 274         if (ostr + len - 1 != c)
 275                 return -1;
 276
 277         /*
 278          * Construct a string like "xx%/1"
 279          */
 280         str = malloc(len + 3);
 281         if (str == NULL)
 282                 return -ENOMEM;
 283
 284         memcpy(str, ostr, len);
 285         strcpy(str + len, "/1");
 286
 287         ret = percent_slash_split(str, ptime_buf, start, end);
 288         if (ret == 0)
 289                 ret = 1;
 290
 291         free(str);
 292         return ret;
 293 }
 294
 295 int perf_time__percent_parse_str(struct perf_time_interval *ptime_buf, int num,
 296                                  const char *ostr, u64 start, u64 end)
 297 {
 298         char *c;
 299
 300         /*
 301          * ostr example:
 302          * 10%/2,10%/3: select the second 10% slice and the third 10% slice
 303          * 0%-10%,30%-40%: multiple time range
 304          * 50%: just one percent
 305          */
 306
 307         memset(ptime_buf, 0, sizeof(*ptime_buf) * num);
 308
 309         c = strchr(ostr, '/');
 310         if (c) {
 311                 return percent_comma_split(ptime_buf, num, ostr, start,
 312                                            end, percent_slash_split);
 313         }
 314
 315         c = strchr(ostr, '-');
 316         if (c) {
 317                 return percent_comma_split(ptime_buf, num, ostr, start,
 318                                            end, percent_dash_split);
 319         }
 320
 321         c = strchr(ostr, '%');
 322         if (c)
 323                 return one_percent_convert(ptime_buf, ostr, start, end, c);
 324
 325         return -1;
 326 }
 327
 328 struct perf_time_interval *perf_time__range_alloc(const char *ostr, int *size)
 329 {
 330         const char *p1, *p2;
 331         int i = 1;
 332         struct perf_time_interval *ptime;
 333
 334         /*
 335          * At least allocate one time range.
 336          */
 337         if (!ostr)
 338                 goto alloc;
 339
 340         p1 = ostr;
 341         while (p1 < ostr + strlen(ostr)) {
 342                 p2 = strchr(p1, ',');
 343                 if (!p2)
 344                         break;
 345
 346                 p1 = p2 + 1;
 347                 i++;
 348         }
 349
 350 alloc:
 351         *size = i;
 352         ptime = calloc(i, sizeof(*ptime));
 353         return ptime;
 354 }
 355
 356 bool perf_time__skip_sample(struct perf_time_interval *ptime, u64 timestamp)
 357 {
 358         /* if time is not set don't drop sample */
 359         if (timestamp == 0)
 360                 return false;
 361
 362         /* otherwise compare sample time to time window */
 363         if ((ptime->start && timestamp < ptime->start) ||
 364             (ptime->end && timestamp > ptime->end)) {
 365                 return true;
 366         }
 367
 368         return false;
 369 }
 370
 371 bool perf_time__ranges_skip_sample(struct perf_time_interval *ptime_buf,
 372                                    int num, u64 timestamp)
 373 {
 374         struct perf_time_interval *ptime;
 375         int i;
 376
 377         if ((timestamp == 0) || (num == 0))
 378                 return false;
 379
 380         if (num == 1)
 381                 return perf_time__skip_sample(&ptime_buf[0], timestamp);
 382
 383         /*
 384          * start/end of multiple time ranges must be valid.
 385          */
 386         for (i = 0; i < num; i++) {
 387                 ptime = &ptime_buf[i];
 388
 389                 if (timestamp >= ptime->start &&
 390                     ((timestamp < ptime->end && i < num - 1) ||
 391                      (timestamp <= ptime->end && i == num - 1))) {
 392                         break;
 393                 }
 394         }
 395
 396         return (i == num) ? true : false;
 397 }
 398
 399 int timestamp__scnprintf_usec(u64 timestamp, char *buf, size_t sz)
 400 {
 401         u64  sec = timestamp / NSEC_PER_SEC;
 402         u64 usec = (timestamp % NSEC_PER_SEC) / NSEC_PER_USEC;
 403
 404         return scnprintf(buf, sz, "%"PRIu64".%06"PRIu64, sec, usec);
 405 }
 406
 407 int fetch_current_timestamp(char *buf, size_t sz)
 408 {
 409         struct timeval tv;
 410         struct tm tm;
 411         char dt[32];
 412
 413         if (gettimeofday(&tv, NULL) || !localtime_r(&tv.tv_sec, &tm))
 414                 return -1;
 415
 416         if (!strftime(dt, sizeof(dt), "%Y%m%d%H%M%S", &tm))
 417                 return -1;
 418
 419         scnprintf(buf, sz, "%s%02u", dt, (unsigned)tv.tv_usec / 10000);
 420
 421         return 0;
 422 }