time-utils.c

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <linux/time64.h>
#include <time.h>
#include <errno.h>
#include <inttypes.h>
#include <math.h>

#include "perf.h"
#include "debug.h"
#include "time-utils.h"

int parse_nsec_time(const char *str, u64 *ptime)
{
    u64 time_sec, time_nsec;
    char *end;

    time_sec = strtoul(str, &end, 10);
    if (*end != '.' && *end != '\0')
        return -1;

    if (*end == '.') {
        int i;
        char nsec_buf[10];

        if (strlen(++end) > 9)
            return -1;

        strncpy(nsec_buf, end, 9);
        nsec_buf[9] = '\0';

        /* make it nsec precision */
        for (i = strlen(nsec_buf); i < 9; i++)
            nsec_buf[i] = '0';

        time_nsec = strtoul(nsec_buf, &end, 10);
        if (*end != '\0')
            return -1;
    } else
        time_nsec = 0;

    *ptime = time_sec * NSEC_PER_SEC + time_nsec;
    return 0;
}

static int parse_timestr_sec_nsec(struct perf_time_interval *ptime,
                  char *start_str, char *end_str)
{
    if (start_str && (*start_str != '\0') &&
        (parse_nsec_time(start_str, &ptime->start) != 0)) {
        return -1;
    }

    if (end_str && (*end_str != '\0') &&
        (parse_nsec_time(end_str, &ptime->end) != 0)) {
        return -1;
    }

    return 0;
}

static int split_start_end(char **start, char **end, const char *ostr, char ch)
{
    char *start_str, *end_str;
    char *d, *str;

    if (ostr == NULL || *ostr == '\0')
        return 0;

    /* copy original string because we need to modify it */
    str = strdup(ostr);
    if (str == NULL)
        return -ENOMEM;

    start_str = str;
    d = strchr(start_str, ch);
    if (d) {
        *d = '\0';
        ++d;
    }
    end_str = d;

    *start = start_str;
    *end = end_str;

    return 0;
}

int perf_time__parse_str(struct perf_time_interval *ptime, const char *ostr)
{
    char *start_str = NULL, *end_str;
    int rc;

    rc = split_start_end(&start_str, &end_str, ostr, ',');
    if (rc || !start_str)
        return rc;

    ptime->start = 0;
    ptime->end = 0;

    rc = parse_timestr_sec_nsec(ptime, start_str, end_str);

    free(start_str);

    /* make sure end time is after start time if it was given */
    if (rc == 0 && ptime->end && ptime->end < ptime->start)
        return -EINVAL;

    pr_debug("start time %" PRIu64 ", ", ptime->start);
    pr_debug("end time %" PRIu64 "\n", ptime->end);

    return rc;
}

static int parse_percent(double *pcnt, char *str)
{
    char *c, *endptr;
    double d;

    c = strchr(str, '%');
    if (c)
        *c = '\0';
    else
        return -1;

    d = strtod(str, &endptr);
    if (endptr != str + strlen(str))
        return -1;

    *pcnt = d / 100.0;
    return 0;
}

static int percent_slash_split(char *str, struct perf_time_interval *ptime,
                   u64 start, u64 end)
{
    char *p, *end_str;
    double pcnt, start_pcnt, end_pcnt;
    u64 total = end - start;
    int i;

    /*
     * Example:
     * 10%/2: select the second 10% slice and the third 10% slice
     */

    /* We can modify this string since the original one is copied */
    p = strchr(str, '/');
    if (!p)
        return -1;

    *p = '\0';
    if (parse_percent(&pcnt, str) < 0)
        return -1;

    p++;
    i = (int)strtol(p, &end_str, 10);
    if (*end_str)
        return -1;

    if (pcnt <= 0.0)
        return -1;

    start_pcnt = pcnt * (i - 1);
    end_pcnt = pcnt * i;

    if (start_pcnt < 0.0 || start_pcnt > 1.0 ||
        end_pcnt < 0.0 || end_pcnt > 1.0) {
        return -1;
    }

    ptime->start = start + round(start_pcnt * total);
    ptime->end = start + round(end_pcnt * total);

    return 0;
}

static int percent_dash_split(char *str, struct perf_time_interval *ptime,
                  u64 start, u64 end)
{
    char *start_str = NULL, *end_str;
    double start_pcnt, end_pcnt;
    u64 total = end - start;
    int ret;

    /*
     * Example: 0%-10%
     */

    ret = split_start_end(&start_str, &end_str, str, '-');
    if (ret || !start_str)
        return ret;

    if ((parse_percent(&start_pcnt, start_str) != 0) ||
        (parse_percent(&end_pcnt, end_str) != 0)) {
        free(start_str);
        return -1;
    }

    free(start_str);

    if (start_pcnt < 0.0 || start_pcnt > 1.0 ||
        end_pcnt < 0.0 || end_pcnt > 1.0 ||
        start_pcnt > end_pcnt) {
        return -1;
    }

    ptime->start = start + round(start_pcnt * total);
    ptime->end = start + round(end_pcnt * total);

    return 0;
}

typedef int (*time_pecent_split)(char *, struct perf_time_interval *,
                 u64 start, u64 end);

static int percent_comma_split(struct perf_time_interval *ptime_buf, int num,
                   const char *ostr, u64 start, u64 end,
                   time_pecent_split func)
{
    char *str, *p1, *p2;
    int len, ret, i = 0;

    str = strdup(ostr);
    if (str == NULL)
        return -ENOMEM;

    len = strlen(str);
    p1 = str;

    while (p1 < str + len) {
        if (i >= num) {
            free(str);
            return -1;
        }

        p2 = strchr(p1, ',');
        if (p2)
            *p2 = '\0';

        ret = (func)(p1, &ptime_buf[i], start, end);
        if (ret < 0) {
            free(str);
            return -1;
        }

        pr_debug("start time %d: %" PRIu64 ", ", i, ptime_buf[i].start);
        pr_debug("end time %d: %" PRIu64 "\n", i, ptime_buf[i].end);

        i++;

        if (p2)
            p1 = p2 + 1;
        else
            break;
    }

    free(str);
    return i;
}

static int one_percent_convert(struct perf_time_interval *ptime_buf,
                   const char *ostr, u64 start, u64 end, char *c)
{
    char *str;
    int len = strlen(ostr), ret;

    /*
     * c points to '%'.
     * '%' should be the last character
     */
    if (ostr + len - 1 != c)
        return -1;

    /*
     * Construct a string like "xx%/1"
     */
    str = malloc(len + 3);
    if (str == NULL)
        return -ENOMEM;

    memcpy(str, ostr, len);
    strcpy(str + len, "/1");

    ret = percent_slash_split(str, ptime_buf, start, end);
    if (ret == 0)
        ret = 1;

    free(str);
    return ret;
}

int perf_time__percent_parse_str(struct perf_time_interval *ptime_buf, int num,
                 const char *ostr, u64 start, u64 end)
{
    char *c;

    /*
     * ostr example:
     * 10%/2,10%/3: select the second 10% slice and the third 10% slice
     * 0%-10%,30%-40%: multiple time range
     * 50%: just one percent
     */

    memset(ptime_buf, 0, sizeof(*ptime_buf) * num);

    c = strchr(ostr, '/');
    if (c) {
        return percent_comma_split(ptime_buf, num, ostr, start,
                       end, percent_slash_split);
    }

    c = strchr(ostr, '-');
    if (c) {
        return percent_comma_split(ptime_buf, num, ostr, start,
                       end, percent_dash_split);
    }

    c = strchr(ostr, '%');
    if (c)
        return one_percent_convert(ptime_buf, ostr, start, end, c);

    return -1;
}

struct perf_time_interval *perf_time__range_alloc(const char *ostr, int *size)
{
    const char *p1, *p2;
    int i = 1;
    struct perf_time_interval *ptime;

    /*
     * At least allocate one time range.
     */
    if (!ostr)
        goto alloc;

    p1 = ostr;
    while (p1 < ostr + strlen(ostr)) {
        p2 = strchr(p1, ',');
        if (!p2)
            break;

        p1 = p2 + 1;
        i++;
    }

alloc:
    *size = i;
    ptime = calloc(i, sizeof(*ptime));
    return ptime;
}

bool perf_time__skip_sample(struct perf_time_interval *ptime, u64 timestamp)
{
    /* if time is not set don't drop sample */
    if (timestamp == 0)
        return false;

    /* otherwise compare sample time to time window */
    if ((ptime->start && timestamp < ptime->start) ||
        (ptime->end && timestamp > ptime->end)) {
        return true;
    }

    return false;
}

bool perf_time__ranges_skip_sample(struct perf_time_interval *ptime_buf,
                   int num, u64 timestamp)
{
    struct perf_time_interval *ptime;
    int i;

    if ((timestamp == 0) || (num == 0))
        return false;

    if (num == 1)
        return perf_time__skip_sample(&ptime_buf[0], timestamp);

    /*
     * start/end of multiple time ranges must be valid.
     */
    for (i = 0; i < num; i++) {
        ptime = &ptime_buf[i];

        if (timestamp >= ptime->start &&
            ((timestamp < ptime->end && i < num - 1) ||
             (timestamp <= ptime->end && i == num - 1))) {
            break;
        }
    }

    return (i == num) ? true : false;
}

int timestamp__scnprintf_usec(u64 timestamp, char *buf, size_t sz)
{
    u64  sec = timestamp / NSEC_PER_SEC;
    u64 usec = (timestamp % NSEC_PER_SEC) / NSEC_PER_USEC;

    return scnprintf(buf, sz, "%"PRIu64".%06"PRIu64, sec, usec);
}

int fetch_current_timestamp(char *buf, size_t sz)
{
    struct timeval tv;
    struct tm tm;
    char dt[32];

    if (gettimeofday(&tv, NULL) || !localtime_r(&tv.tv_sec, &tm))
        return -1;

    if (!strftime(dt, sizeof(dt), "%Y%m%d%H%M%S", &tm))
        return -1;

    scnprintf(buf, sz, "%s%02u", dt, (unsigned)tv.tv_usec / 10000);

    return 0;
}