Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7502d79f authored by Ruchi Kandoi's avatar Ruchi Kandoi
Browse files

cpufreq: Persist cpufreq time in state data across hotplug 



Cpufreq time_in_state data for all CPUs is made persistent across
hotplug and exposed to userspace via sysfs file
/sys/devices/system/cpu/cpufreq/all_time_in_state

Change-Id: I97cb5de24b6de16189bf8b5df9592d0a6e6ddf32
Signed-off-by: default avatarRuchi Kandoi <kandoiruchi@google.com>
parent c5ecbca4

drivers/cpufreq/cpufreq_stats.c

+218 −1
Original line number Diff line number Diff line
@@ -13,6 +13,7 @@ 
#include <linux/cpufreq.h>

#include <linux/module.h>

#include <linux/slab.h>

#include <linux/sort.h>

#include <linux/cputime.h>



static spinlock_t cpufreq_stats_lock;
@@ -31,6 +32,20 @@ struct cpufreq_stats { 
#endif

};



struct all_cpufreq_stats {

	unsigned int state_num;

	cputime64_t *time_in_state;

	unsigned int *freq_table;

};



struct all_freq_table {

	unsigned int *freq_table;

	unsigned int table_size;

};



static struct all_freq_table *all_freq_table;



static DEFINE_PER_CPU(struct all_cpufreq_stats *, all_cpufreq_stats);

static DEFINE_PER_CPU(struct cpufreq_stats *, cpufreq_stats_table);



struct cpufreq_stats_attribute {
@@ -41,14 +56,24 @@ struct cpufreq_stats_attribute { 
static int cpufreq_stats_update(unsigned int cpu)

{

	struct cpufreq_stats *stat;

	struct all_cpufreq_stats *all_stat;

	unsigned long long cur_time;



	cur_time = get_jiffies_64();

	spin_lock(&cpufreq_stats_lock);

	stat = per_cpu(cpufreq_stats_table, cpu);

	if (stat->time_in_state)

	all_stat = per_cpu(all_cpufreq_stats, cpu);

	if (!stat) {

		spin_unlock(&cpufreq_stats_lock);

		return 0;

	}

	if (stat->time_in_state) {

		stat->time_in_state[stat->last_index] +=

			cur_time - stat->last_time;

		if (all_stat)

			all_stat->time_in_state[stat->last_index] +=

					cur_time - stat->last_time;

	}

	stat->last_time = cur_time;

	spin_unlock(&cpufreq_stats_lock);

	return 0;
@@ -79,6 +104,62 @@ static ssize_t show_time_in_state(struct cpufreq_policy *policy, char *buf) 
	return len;

}



static int get_index_all_cpufreq_stat(struct all_cpufreq_stats *all_stat,

		unsigned int freq)

{

	int i;

	if (!all_stat)

		return -1;

	for (i = 0; i < all_stat->state_num; i++) {

		if (all_stat->freq_table[i] == freq)

			return i;

	}

	return -1;

}



static ssize_t show_all_time_in_state(struct kobject *kobj,

		struct kobj_attribute *attr, char *buf)

{

	ssize_t len = 0;

	unsigned int i, cpu, freq, index;

	struct all_cpufreq_stats *all_stat;

	struct cpufreq_policy *policy;



	len += scnprintf(buf + len, PAGE_SIZE - len, "freq\t\t");

	for_each_possible_cpu(cpu) {

		len += scnprintf(buf + len, PAGE_SIZE - len, "cpu%d\t\t", cpu);

		if (cpu_online(cpu))

			cpufreq_stats_update(cpu);

	}



	if (!all_freq_table)

		goto out;

	for (i = 0; i < all_freq_table->table_size; i++) {

		freq = all_freq_table->freq_table[i];

		len += scnprintf(buf + len, PAGE_SIZE - len, "\n%u\t\t", freq);

		for_each_possible_cpu(cpu) {

			policy = cpufreq_cpu_get(cpu);

			if (policy == NULL)

				continue;

			all_stat = per_cpu(all_cpufreq_stats, policy->cpu);

			index = get_index_all_cpufreq_stat(all_stat, freq);

			if (index != -1) {

				len += scnprintf(buf + len, PAGE_SIZE - len,

					"%llu\t\t", (unsigned long long)

					cputime64_to_clock_t(all_stat->time_in_state[index]));

			} else {

				len += scnprintf(buf + len, PAGE_SIZE - len,

						"N/A\t\t");

			}

			cpufreq_cpu_put(policy);

		}

	}



out:

	len += scnprintf(buf + len, PAGE_SIZE - len, "\n");

	return len;

}



#ifdef CONFIG_CPU_FREQ_STAT_DETAILS

static ssize_t show_trans_table(struct cpufreq_policy *policy, char *buf)

{
@@ -142,6 +223,9 @@ static struct attribute_group stats_attr_group = { 
	.name = "stats"

};



static struct kobj_attribute _attr_all_time_in_state = __ATTR(all_time_in_state,

		0444, show_all_time_in_state, NULL);



static int freq_table_get_index(struct cpufreq_stats *stat, unsigned int freq)

{

	int index;
@@ -180,6 +264,29 @@ static void cpufreq_stats_free_table(unsigned int cpu) 
	cpufreq_cpu_put(policy);

}



static void cpufreq_allstats_free(void)

{

	int i;

	struct all_cpufreq_stats *all_stat;



	sysfs_remove_file(cpufreq_global_kobject,

						&_attr_all_time_in_state.attr);



	for (i = 0; i < total_cpus; i++) {

		all_stat = per_cpu(all_cpufreq_stats, i);

		if (!all_stat)

			continue;

		kfree(all_stat->time_in_state);

		kfree(all_stat);

		per_cpu(all_cpufreq_stats, i) = NULL;

	}

	if (all_freq_table) {

		kfree(all_freq_table->freq_table);

		kfree(all_freq_table);

		all_freq_table = NULL;

	}

}



static int __cpufreq_stats_create_table(struct cpufreq_policy *policy)

{

	unsigned int i, count = 0, ret = 0;
@@ -272,6 +379,106 @@ static void cpufreq_stats_update_policy_cpu(struct cpufreq_policy *policy) 
	stat->cpu = policy->cpu;

}



static int compare_for_sort(const void *lhs_ptr, const void *rhs_ptr)

{

	unsigned int lhs = *(const unsigned int *)(lhs_ptr);

	unsigned int rhs = *(const unsigned int *)(rhs_ptr);

	if (lhs < rhs)

		return -1;

	if (lhs > rhs)

		return 1;

	return 0;

}



static bool check_all_freq_table(unsigned int freq)

{

	int i;

	for (i = 0; i < all_freq_table->table_size; i++) {

		if (freq == all_freq_table->freq_table[i])

			return true;

	}

	return false;

}



static void create_all_freq_table(void)

{

	all_freq_table = kzalloc(sizeof(struct all_freq_table),

			GFP_KERNEL);

	if (!all_freq_table)

		pr_warn("could not allocate memory for all_freq_table\n");

	return;

}



static void add_all_freq_table(unsigned int freq)

{

	unsigned int size;

	size = sizeof(unsigned int) * (all_freq_table->table_size + 1);

	all_freq_table->freq_table = krealloc(all_freq_table->freq_table,

			size, GFP_KERNEL);

	if (IS_ERR(all_freq_table->freq_table)) {

		pr_warn("Could not reallocate memory for freq_table\n");

		all_freq_table->freq_table = NULL;

		return;

	}

	all_freq_table->freq_table[all_freq_table->table_size++] = freq;

}



static void cpufreq_allstats_create(unsigned int cpu)

{

	int i , j = 0;

	unsigned int alloc_size, count = 0;

	struct cpufreq_frequency_table *table = cpufreq_frequency_get_table(cpu);

	struct all_cpufreq_stats *all_stat;

	bool sort_needed = false;



	if (!table)

		return;



	for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {

		unsigned int freq = table[i].frequency;

		if (freq == CPUFREQ_ENTRY_INVALID)

			continue;

		count++;

	}



	all_stat = kzalloc(sizeof(struct all_cpufreq_stats),

			GFP_KERNEL);

	if (!all_stat) {

		pr_warn("Cannot allocate memory for cpufreq stats\n");

		return;

	}



	/*Allocate memory for freq table per cpu as well as clockticks per freq*/

	alloc_size = count * sizeof(int) + count * sizeof(cputime64_t);

	all_stat->time_in_state = kzalloc(alloc_size, GFP_KERNEL);

	if (!all_stat->time_in_state) {

		pr_warn("Cannot allocate memory for cpufreq time_in_state\n");

		kfree(all_stat);

		all_stat = NULL;

		return;

	}

	all_stat->freq_table = (unsigned int *)

		(all_stat->time_in_state + count);



	spin_lock(&cpufreq_stats_lock);

	for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {

		unsigned int freq = table[i].frequency;

		if (freq == CPUFREQ_ENTRY_INVALID)

			continue;

		all_stat->freq_table[j++] = freq;

		if (all_freq_table && !check_all_freq_table(freq)) {

			add_all_freq_table(freq);

			sort_needed = true;

		}

	}

	if (sort_needed)

		sort(all_freq_table->freq_table, all_freq_table->table_size,

				sizeof(unsigned int), &compare_for_sort, NULL);

	all_stat->state_num = j;

	per_cpu(all_cpufreq_stats, cpu) = all_stat;

	spin_unlock(&cpufreq_stats_lock);

}



static int cpufreq_stat_notifier_policy(struct notifier_block *nb,

		unsigned long val, void *data)

{
@@ -283,6 +490,9 @@ static int cpufreq_stat_notifier_policy(struct notifier_block *nb, 
		return 0;

	}



	if (!per_cpu(all_cpufreq_stats, cpu))

		cpufreq_allstats_create(cpu);



	if (val == CPUFREQ_CREATE_POLICY)

		ret = __cpufreq_stats_create_table(policy);

	else if (val == CPUFREQ_REMOVE_POLICY)
@@ -359,6 +569,12 @@ static int __init cpufreq_stats_init(void) 
		return ret;

	}



	create_all_freq_table();

	ret = sysfs_create_file(cpufreq_global_kobject,

			&_attr_all_time_in_state.attr);

	if (ret)

		pr_warn("Error creating sysfs file for cpufreq stats\n");



	return 0;

}

static void __exit cpufreq_stats_exit(void)
@@ -371,6 +587,7 @@ static void __exit cpufreq_stats_exit(void) 
			CPUFREQ_TRANSITION_NOTIFIER);

	for_each_online_cpu(cpu)

		cpufreq_stats_free_table(cpu);

	cpufreq_allstats_free();

}



MODULE_AUTHOR("Zou Nan hai <nanhai.zou@intel.com>");