testcases/kernel/sched/eas/util.c

/*
 * Copyright (c) 2018 Google, Inc.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */

#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <sched.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>

#include "tst_cpu.h"
#include "tst_safe_file_ops.h"

#include "util.h"

void affine(int cpu)
{
	cpu_set_t cpuset;
	CPU_ZERO(&cpuset);
	CPU_SET(cpu, &cpuset);
	ERROR_CHECK(sched_setaffinity(0, sizeof(cpu_set_t), &cpuset));
}

/*
 * Busywait for a certain amount of wallclock time.
 * If sleep is nonzero, sleep for 1ms between each check.
 */
void burn(unsigned int usec, int sleep)
{
	unsigned long long now_usec, end_usec;
	struct timespec ts;

	if (clock_gettime(CLOCK_MONOTONIC, &ts)) {
		printf("clock_gettime() reported an error\n");
		return;
	}
	end_usec = (ts.tv_sec) * USEC_PER_SEC + (ts.tv_nsec / 1000) + usec;
	while(1) {
		if (clock_gettime(CLOCK_MONOTONIC, &ts)) {
			printf("clock_gettime() reported an error\n");
			return;
		}
		now_usec = ts.tv_sec * USEC_PER_SEC + ts.tv_nsec / 1000;
		if (now_usec > end_usec)
			return;
		if (sleep)
			usleep(1000);
	}
}

#define CAP_STATE_FILE_SIZE 1024
static int read_capacity_sched_domains(int cpu, unsigned int *cap)
{
	char *filebuf, *tmp1, *tmp2;
	char cap_states_file[100];
	int cap_states_fd;
	int bytes, rv;

	sprintf(cap_states_file,
			"/proc/sys/kernel/sched_domain/cpu%d/domain0/group0/energy/cap_states",
			cpu);
	cap_states_fd = open(cap_states_file, O_RDONLY);
	if (cap_states_fd == -1)
		return -ENOENT;

	bytes = CAP_STATE_FILE_SIZE;
	filebuf = calloc(1, CAP_STATE_FILE_SIZE + 1);
	if (!filebuf) {
		printf("Failed to calloc buffer for cap_states\n");
		return -1;
	}
	tmp1 = filebuf;
	while (bytes) {
		rv = read(cap_states_fd, tmp1, bytes);
		if (rv == -1) {
			printf("Could not read cap_states\n");
			return -1;
		}
		if (rv == 0)
			break;
		tmp1 += rv;
		bytes -= rv;
	}
	if (tmp1 - filebuf == CAP_STATE_FILE_SIZE) {
		printf("CAP_STATE_FILE_SIZE exhausted, increase\n");
		return -1;
	}
	tmp1 = strrchr(filebuf, '\t');
	if (!tmp1 || tmp1 == filebuf ) {
		printf("Malformatted cap_states_file (1).\n%s\n", filebuf);
		return -1;
	}
	tmp1 = strrchr(tmp1 - 1, '\t');
	if (!tmp1 || tmp1 == filebuf) {
		printf("Malformatted cap_states_file (2).\n%s\n", filebuf);
		return -1;
	}
	tmp1 = strrchr(tmp1 - 1, '\t');
	if (!tmp1 || tmp1 == filebuf) {
		printf("Malformatted cap_states_file (3).\n%s\n", filebuf);
		return -1;
	}
	/* tmp1 now points to tab after the capacity we want. */
	*tmp1 = 0;
	tmp2 = strrchr(tmp1 - 1, '\t');
	if (!tmp2)
		tmp2 = filebuf;
	else
		tmp2++;
	if (sscanf(tmp2,"%d", cap) != 1) {
		printf("Failed to parse capacity from cap_states.\n");
		return -1;
	}
	free(filebuf);
	if (close(cap_states_fd)) {
		printf("Failed to close cap_states file.\n");
		return -1;
	}

	return 0;
}

static int read_capacity_sysfs(int cpu, unsigned int *cap)
{
	char path[100];

	sprintf(path, "/sys/devices/system/cpu/cpu%d/cpu_capacity", cpu);

	return SAFE_FILE_LINES_SCANF(path, "%u", cap);
}

static int read_cpu_capacity(int cpu, unsigned int *cap)
{
	int ret = read_capacity_sched_domains(cpu, cap);

	/*
	 * Capacities are exposed in sched debug for android 4.9 and older.
	 * Otherwise, upstream uses a sysfs interface.
	 */
	if (ret == -ENOENT)
		ret = read_capacity_sysfs(cpu, cap);

	if (ret)
		perror(NULL);

	return ret;
}

/*
 * get_bigs = 0, search for smallest CPUs
 * get_bigs = 1, search for CPUs other than the smallest CPUs
 */
int find_cpus_with_capacity(int get_bigs, cpu_set_t *cpuset)
{
	unsigned int cap, smallest = -1;
	int i;

	CPU_ZERO(cpuset);

	for (i = 0; i < tst_ncpus(); i++) {
		if (read_cpu_capacity(i, &cap))
			return -1;

		if (cap < smallest) {
			smallest = cap;
			CPU_ZERO(cpuset);
			CPU_SET(i, cpuset);
		} else if (cap == smallest) {
			CPU_SET(i, cpuset);
		}
	}

	if (!get_bigs)
		return 0;

	for (i = 0; i < tst_ncpus(); i++)
		if (CPU_ISSET(i, cpuset))
			CPU_CLR(i, cpuset);
		else
			CPU_SET(i, cpuset);

	return 0;
}