sysfs.c

Go to the documentation of this file.

/*
 *  (C) 2004-2009  Dominik Brodowski <[email protected]>
 *
 *  Licensed under the terms of the GNU GPL License version 2.
 */

#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

#include "cpufreq.h"

#define PATH_TO_CPU "/sys/devices/system/cpu/"
#define MAX_LINE_LEN 4096
#define SYSFS_PATH_MAX 255


static unsigned int sysfs_read_file(const char *path, char *buf, size_t buflen)
{
    int fd;
    ssize_t numread;

    fd = open(path, O_RDONLY);
    if (fd == -1)
        return 0;

    numread = read(fd, buf, buflen - 1);
    if (numread < 1) {
        close(fd);
        return 0;
    }

    buf[numread] = '\0';
    close(fd);

    return (unsigned int) numread;
}


/* CPUFREQ sysfs access **************************************************/

/* helper function to read file from /sys into given buffer */
/* fname is a relative path under "cpuX/cpufreq" dir */
static unsigned int sysfs_cpufreq_read_file(unsigned int cpu, const char *fname,
                        char *buf, size_t buflen)
{
    char path[SYSFS_PATH_MAX];

    snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u/cpufreq/%s",
             cpu, fname);
    return sysfs_read_file(path, buf, buflen);
}

/* helper function to write a new value to a /sys file */
/* fname is a relative path under "cpuX/cpufreq" dir */
static unsigned int sysfs_cpufreq_write_file(unsigned int cpu,
                         const char *fname,
                         const char *value, size_t len)
{
    char path[SYSFS_PATH_MAX];
    int fd;
    ssize_t numwrite;

    snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u/cpufreq/%s",
             cpu, fname);

    fd = open(path, O_WRONLY);
    if (fd == -1)
        return 0;

    numwrite = write(fd, value, len);
    if (numwrite < 1) {
        close(fd);
        return 0;
    }

    close(fd);

    return (unsigned int) numwrite;
}

/* read access to files which contain one numeric value */

enum cpufreq_value {
    CPUINFO_CUR_FREQ,
    CPUINFO_MIN_FREQ,
    CPUINFO_MAX_FREQ,
    CPUINFO_LATENCY,
    SCALING_CUR_FREQ,
    SCALING_MIN_FREQ,
    SCALING_MAX_FREQ,
    STATS_NUM_TRANSITIONS,
    MAX_CPUFREQ_VALUE_READ_FILES
};

static const char *cpufreq_value_files[MAX_CPUFREQ_VALUE_READ_FILES] = {
    [CPUINFO_CUR_FREQ] = "cpuinfo_cur_freq",
    [CPUINFO_MIN_FREQ] = "cpuinfo_min_freq",
    [CPUINFO_MAX_FREQ] = "cpuinfo_max_freq",
    [CPUINFO_LATENCY]  = "cpuinfo_transition_latency",
    [SCALING_CUR_FREQ] = "scaling_cur_freq",
    [SCALING_MIN_FREQ] = "scaling_min_freq",
    [SCALING_MAX_FREQ] = "scaling_max_freq",
    [STATS_NUM_TRANSITIONS] = "stats/total_trans"
};


static unsigned long sysfs_cpufreq_get_one_value(unsigned int cpu,
                         enum cpufreq_value which)
{
    unsigned long value;
    unsigned int len;
    char linebuf[MAX_LINE_LEN];
    char *endp;

    if (which >= MAX_CPUFREQ_VALUE_READ_FILES)
        return 0;

    len = sysfs_cpufreq_read_file(cpu, cpufreq_value_files[which],
                linebuf, sizeof(linebuf));

    if (len == 0)
        return 0;

    value = strtoul(linebuf, &endp, 0);

    if (endp == linebuf || errno == ERANGE)
        return 0;

    return value;
}

/* read access to files which contain one string */

enum cpufreq_string {
    SCALING_DRIVER,
    SCALING_GOVERNOR,
    MAX_CPUFREQ_STRING_FILES
};

static const char *cpufreq_string_files[MAX_CPUFREQ_STRING_FILES] = {
    [SCALING_DRIVER] = "scaling_driver",
    [SCALING_GOVERNOR] = "scaling_governor",
};


static char *sysfs_cpufreq_get_one_string(unsigned int cpu,
                       enum cpufreq_string which)
{
    char linebuf[MAX_LINE_LEN];
    char *result;
    unsigned int len;

    if (which >= MAX_CPUFREQ_STRING_FILES)
        return NULL;

    len = sysfs_cpufreq_read_file(cpu, cpufreq_string_files[which],
                linebuf, sizeof(linebuf));
    if (len == 0)
        return NULL;

    result = strdup(linebuf);
    if (result == NULL)
        return NULL;

    if (result[strlen(result) - 1] == '\n')
        result[strlen(result) - 1] = '\0';

    return result;
}

/* write access */

enum cpufreq_write {
    WRITE_SCALING_MIN_FREQ,
    WRITE_SCALING_MAX_FREQ,
    WRITE_SCALING_GOVERNOR,
    WRITE_SCALING_SET_SPEED,
    MAX_CPUFREQ_WRITE_FILES
};

static const char *cpufreq_write_files[MAX_CPUFREQ_WRITE_FILES] = {
    [WRITE_SCALING_MIN_FREQ] = "scaling_min_freq",
    [WRITE_SCALING_MAX_FREQ] = "scaling_max_freq",
    [WRITE_SCALING_GOVERNOR] = "scaling_governor",
    [WRITE_SCALING_SET_SPEED] = "scaling_setspeed",
};

static int sysfs_cpufreq_write_one_value(unsigned int cpu,
                     enum cpufreq_write which,
                     const char *new_value, size_t len)
{
    if (which >= MAX_CPUFREQ_WRITE_FILES)
        return 0;

    if (sysfs_cpufreq_write_file(cpu, cpufreq_write_files[which],
                    new_value, len) != len)
        return -ENODEV;

    return 0;
};

unsigned long sysfs_get_freq_kernel(unsigned int cpu)
{
    return sysfs_cpufreq_get_one_value(cpu, SCALING_CUR_FREQ);
}

unsigned long sysfs_get_freq_hardware(unsigned int cpu)
{
    return sysfs_cpufreq_get_one_value(cpu, CPUINFO_CUR_FREQ);
}

unsigned long sysfs_get_freq_transition_latency(unsigned int cpu)
{
    return sysfs_cpufreq_get_one_value(cpu, CPUINFO_LATENCY);
}

int sysfs_get_freq_hardware_limits(unsigned int cpu,
                  unsigned long *min,
                  unsigned long *max)
{
    if ((!min) || (!max))
        return -EINVAL;

    *min = sysfs_cpufreq_get_one_value(cpu, CPUINFO_MIN_FREQ);
    if (!*min)
        return -ENODEV;

    *max = sysfs_cpufreq_get_one_value(cpu, CPUINFO_MAX_FREQ);
    if (!*max)
        return -ENODEV;

    return 0;
}

char *sysfs_get_freq_driver(unsigned int cpu)
{
    return sysfs_cpufreq_get_one_string(cpu, SCALING_DRIVER);
}

struct cpufreq_policy *sysfs_get_freq_policy(unsigned int cpu)
{
    struct cpufreq_policy *policy;

    policy = malloc(sizeof(struct cpufreq_policy));
    if (!policy)
        return NULL;

    policy->governor = sysfs_cpufreq_get_one_string(cpu, SCALING_GOVERNOR);
    if (!policy->governor) {
        free(policy);
        return NULL;
    }
    policy->min = sysfs_cpufreq_get_one_value(cpu, SCALING_MIN_FREQ);
    policy->max = sysfs_cpufreq_get_one_value(cpu, SCALING_MAX_FREQ);
    if ((!policy->min) || (!policy->max)) {
        free(policy->governor);
        free(policy);
        return NULL;
    }

    return policy;
}

struct cpufreq_available_governors *
sysfs_get_freq_available_governors(unsigned int cpu) {
    struct cpufreq_available_governors *first = NULL;
    struct cpufreq_available_governors *current = NULL;
    char linebuf[MAX_LINE_LEN];
    unsigned int pos, i;
    unsigned int len;

    len = sysfs_cpufreq_read_file(cpu, "scaling_available_governors",
                linebuf, sizeof(linebuf));
    if (len == 0)
        return NULL;

    pos = 0;
    for (i = 0; i < len; i++) {
        if (linebuf[i] == ' ' || linebuf[i] == '\n') {
            if (i - pos < 2)
                continue;
            if (current) {
                current->next = malloc(sizeof(*current));
                if (!current->next)
                    goto error_out;
                current = current->next;
            } else {
                first = malloc(sizeof(*first));
                if (!first)
                    goto error_out;
                current = first;
            }
            current->first = first;
            current->next = NULL;

            current->governor = malloc(i - pos + 1);
            if (!current->governor)
                goto error_out;

            memcpy(current->governor, linebuf + pos, i - pos);
            current->governor[i - pos] = '\0';
            pos = i + 1;
        }
    }

    return first;

 error_out:
    while (first) {
        current = first->next;
        if (first->governor)
            free(first->governor);
        free(first);
        first = current;
    }
    return NULL;
}


struct cpufreq_available_frequencies *
sysfs_get_available_frequencies(unsigned int cpu) {
    struct cpufreq_available_frequencies *first = NULL;
    struct cpufreq_available_frequencies *current = NULL;
    char one_value[SYSFS_PATH_MAX];
    char linebuf[MAX_LINE_LEN];
    unsigned int pos, i;
    unsigned int len;

    len = sysfs_cpufreq_read_file(cpu, "scaling_available_frequencies",
                linebuf, sizeof(linebuf));
    if (len == 0)
        return NULL;

    pos = 0;
    for (i = 0; i < len; i++) {
        if (linebuf[i] == ' ' || linebuf[i] == '\n') {
            if (i - pos < 2)
                continue;
            if (i - pos >= SYSFS_PATH_MAX)
                goto error_out;
            if (current) {
                current->next = malloc(sizeof(*current));
                if (!current->next)
                    goto error_out;
                current = current->next;
            } else {
                first = malloc(sizeof(*first));
                if (!first)
                    goto error_out;
                current = first;
            }
            current->first = first;
            current->next = NULL;

            memcpy(one_value, linebuf + pos, i - pos);
            one_value[i - pos] = '\0';
            if (sscanf(one_value, "%lu", &current->frequency) != 1)
                goto error_out;

            pos = i + 1;
        }
    }

    return first;

 error_out:
    while (first) {
        current = first->next;
        free(first);
        first = current;
    }
    return NULL;
}

static struct cpufreq_affected_cpus *sysfs_get_cpu_list(unsigned int cpu,
                            const char *file)
{
    struct cpufreq_affected_cpus *first = NULL;
    struct cpufreq_affected_cpus *current = NULL;
    char one_value[SYSFS_PATH_MAX];
    char linebuf[MAX_LINE_LEN];
    unsigned int pos, i;
    unsigned int len;

    len = sysfs_cpufreq_read_file(cpu, file, linebuf, sizeof(linebuf));
    if (len == 0)
        return NULL;

    pos = 0;
    for (i = 0; i < len; i++) {
        if (i == len || linebuf[i] == ' ' || linebuf[i] == '\n') {
            if (i - pos  < 1)
                continue;
            if (i - pos >= SYSFS_PATH_MAX)
                goto error_out;
            if (current) {
                current->next = malloc(sizeof(*current));
                if (!current->next)
                    goto error_out;
                current = current->next;
            } else {
                first = malloc(sizeof(*first));
                if (!first)
                    goto error_out;
                current = first;
            }
            current->first = first;
            current->next = NULL;

            memcpy(one_value, linebuf + pos, i - pos);
            one_value[i - pos] = '\0';

            if (sscanf(one_value, "%u", &current->cpu) != 1)
                goto error_out;

            pos = i + 1;
        }
    }

    return first;

 error_out:
    while (first) {
        current = first->next;
        free(first);
        first = current;
    }
    return NULL;
}

struct cpufreq_affected_cpus *sysfs_get_freq_affected_cpus(unsigned int cpu)
{
    return sysfs_get_cpu_list(cpu, "affected_cpus");
}

struct cpufreq_affected_cpus *sysfs_get_freq_related_cpus(unsigned int cpu)
{
    return sysfs_get_cpu_list(cpu, "related_cpus");
}

struct cpufreq_stats *sysfs_get_freq_stats(unsigned int cpu,
                    unsigned long long *total_time) {
    struct cpufreq_stats *first = NULL;
    struct cpufreq_stats *current = NULL;
    char one_value[SYSFS_PATH_MAX];
    char linebuf[MAX_LINE_LEN];
    unsigned int pos, i;
    unsigned int len;

    len = sysfs_cpufreq_read_file(cpu, "stats/time_in_state",
                linebuf, sizeof(linebuf));
    if (len == 0)
        return NULL;

    *total_time = 0;
    pos = 0;
    for (i = 0; i < len; i++) {
        if (i == strlen(linebuf) || linebuf[i] == '\n') {
            if (i - pos < 2)
                continue;
            if ((i - pos) >= SYSFS_PATH_MAX)
                goto error_out;
            if (current) {
                current->next = malloc(sizeof(*current));
                if (!current->next)
                    goto error_out;
                current = current->next;
            } else {
                first = malloc(sizeof(*first));
                if (!first)
                    goto error_out;
                current = first;
            }
            current->first = first;
            current->next = NULL;

            memcpy(one_value, linebuf + pos, i - pos);
            one_value[i - pos] = '\0';
            if (sscanf(one_value, "%lu %llu",
                    &current->frequency,
                    &current->time_in_state) != 2)
                goto error_out;

            *total_time = *total_time + current->time_in_state;
            pos = i + 1;
        }
    }

    return first;

 error_out:
    while (first) {
        current = first->next;
        free(first);
        first = current;
    }
    return NULL;
}

unsigned long sysfs_get_freq_transitions(unsigned int cpu)
{
    return sysfs_cpufreq_get_one_value(cpu, STATS_NUM_TRANSITIONS);
}

static int verify_gov(char *new_gov, char *passed_gov)
{
    unsigned int i, j = 0;

    if (!passed_gov || (strlen(passed_gov) > 19))
        return -EINVAL;

    strncpy(new_gov, passed_gov, 20);
    for (i = 0; i < 20; i++) {
        if (j) {
            new_gov[i] = '\0';
            continue;
        }
        if ((new_gov[i] >= 'a') && (new_gov[i] <= 'z'))
            continue;

        if ((new_gov[i] >= 'A') && (new_gov[i] <= 'Z'))
            continue;

        if (new_gov[i] == '-')
            continue;

        if (new_gov[i] == '_')
            continue;

        if (new_gov[i] == '\0') {
            j = 1;
            continue;
        }
        return -EINVAL;
    }
    new_gov[19] = '\0';
    return 0;
}

int sysfs_modify_freq_policy_governor(unsigned int cpu, char *governor)
{
    char new_gov[SYSFS_PATH_MAX];

    if (!governor)
        return -EINVAL;

    if (verify_gov(new_gov, governor))
        return -EINVAL;

    return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_GOVERNOR,
                         new_gov, strlen(new_gov));
};

int sysfs_modify_freq_policy_max(unsigned int cpu, unsigned long max_freq)
{
    char value[SYSFS_PATH_MAX];

    snprintf(value, SYSFS_PATH_MAX, "%lu", max_freq);

    return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MAX_FREQ,
                         value, strlen(value));
};


int sysfs_modify_freq_policy_min(unsigned int cpu, unsigned long min_freq)
{
    char value[SYSFS_PATH_MAX];

    snprintf(value, SYSFS_PATH_MAX, "%lu", min_freq);

    return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MIN_FREQ,
                         value, strlen(value));
};


int sysfs_set_freq_policy(unsigned int cpu, struct cpufreq_policy *policy)
{
    char min[SYSFS_PATH_MAX];
    char max[SYSFS_PATH_MAX];
    char gov[SYSFS_PATH_MAX];
    int ret;
    unsigned long old_min;
    int write_max_first;

    if (!policy || !(policy->governor))
        return -EINVAL;

    if (policy->max < policy->min)
        return -EINVAL;

    if (verify_gov(gov, policy->governor))
        return -EINVAL;

    snprintf(min, SYSFS_PATH_MAX, "%lu", policy->min);
    snprintf(max, SYSFS_PATH_MAX, "%lu", policy->max);

    old_min = sysfs_cpufreq_get_one_value(cpu, SCALING_MIN_FREQ);
    write_max_first = (old_min && (policy->max < old_min) ? 0 : 1);

    if (write_max_first) {
        ret = sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MAX_FREQ,
                            max, strlen(max));
        if (ret)
            return ret;
    }

    ret = sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MIN_FREQ, min,
                        strlen(min));
    if (ret)
        return ret;

    if (!write_max_first) {
        ret = sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MAX_FREQ,
                            max, strlen(max));
        if (ret)
            return ret;
    }

    return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_GOVERNOR,
                         gov, strlen(gov));
}

int sysfs_set_frequency(unsigned int cpu, unsigned long target_frequency)
{
    struct cpufreq_policy *pol = sysfs_get_freq_policy(cpu);
    char userspace_gov[] = "userspace";
    char freq[SYSFS_PATH_MAX];
    int ret;

    if (!pol)
        return -ENODEV;

    if (strncmp(pol->governor, userspace_gov, 9) != 0) {
        ret = sysfs_modify_freq_policy_governor(cpu, userspace_gov);
        if (ret) {
            cpufreq_put_policy(pol);
            return ret;
        }
    }

    cpufreq_put_policy(pol);

    snprintf(freq, SYSFS_PATH_MAX, "%lu", target_frequency);

    return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_SET_SPEED,
                         freq, strlen(freq));
}

/* CPUFREQ sysfs access **************************************************/

/* General sysfs access **************************************************/
int sysfs_cpu_exists(unsigned int cpu)
{
    char file[SYSFS_PATH_MAX];
    struct stat statbuf;

    snprintf(file, SYSFS_PATH_MAX, PATH_TO_CPU "cpu%u/", cpu);

    if (stat(file, &statbuf) != 0)
        return -ENOSYS;

    return S_ISDIR(statbuf.st_mode) ? 0 : -ENOSYS;
}

/* General sysfs access **************************************************/