This source file includes following definitions.
- parse_nsec_time
- parse_timestr_sec_nsec
- split_start_end
- perf_time__parse_str
- perf_time__parse_strs
- parse_percent
- set_percent_time
- percent_slash_split
- percent_dash_split
- percent_comma_split
- one_percent_convert
- perf_time__percent_parse_str
- perf_time__range_alloc
- perf_time__skip_sample
- perf_time__ranges_skip_sample
- perf_time__parse_for_ranges_reltime
- perf_time__parse_for_ranges
- timestamp__scnprintf_usec
- timestamp__scnprintf_nsec
- fetch_current_timestamp
1
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
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
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
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
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
141 for (i = 0, p = str; i < num - 1; i++) {
142 arg = p;
143
144 p = skip_spaces(strchr(p, ',') + 1);
145
146 while (*p && !isspace(*p)) {
147 if (*p++ == ',') {
148 rc = -EINVAL;
149 goto out;
150 }
151 }
152
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
161 rc = perf_time__parse_str(ptime + i, p);
162 if (rc < 0)
163 goto out;
164
165
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
227
228
229
230
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
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
335
336
337 if (ostr + len - 1 != c)
338 return -1;
339
340
341
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
365
366
367
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
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
422 if (timestamp == 0)
423 return false;
424
425
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
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 }