Merge tag 'linux-kselftest-next-6.6-rc2' of git://git.kernel.org/pub/scm/linux/kernel...
[platform/kernel/linux-starfive.git] / 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 }