forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
376 lines
8.2 KiB
376 lines
8.2 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* CPU accounting code for task groups. |
|
* |
|
* Based on the work by Paul Menage ([email protected]) and Balbir Singh |
|
* ([email protected]). |
|
*/ |
|
#include <asm/irq_regs.h> |
|
#include "sched.h" |
|
|
|
/* Time spent by the tasks of the CPU accounting group executing in ... */ |
|
enum cpuacct_stat_index { |
|
CPUACCT_STAT_USER, /* ... user mode */ |
|
CPUACCT_STAT_SYSTEM, /* ... kernel mode */ |
|
|
|
CPUACCT_STAT_NSTATS, |
|
}; |
|
|
|
static const char * const cpuacct_stat_desc[] = { |
|
[CPUACCT_STAT_USER] = "user", |
|
[CPUACCT_STAT_SYSTEM] = "system", |
|
}; |
|
|
|
struct cpuacct_usage { |
|
u64 usages[CPUACCT_STAT_NSTATS]; |
|
}; |
|
|
|
/* track CPU usage of a group of tasks and its child groups */ |
|
struct cpuacct { |
|
struct cgroup_subsys_state css; |
|
/* cpuusage holds pointer to a u64-type object on every CPU */ |
|
struct cpuacct_usage __percpu *cpuusage; |
|
struct kernel_cpustat __percpu *cpustat; |
|
}; |
|
|
|
static inline struct cpuacct *css_ca(struct cgroup_subsys_state *css) |
|
{ |
|
return css ? container_of(css, struct cpuacct, css) : NULL; |
|
} |
|
|
|
/* Return CPU accounting group to which this task belongs */ |
|
static inline struct cpuacct *task_ca(struct task_struct *tsk) |
|
{ |
|
return css_ca(task_css(tsk, cpuacct_cgrp_id)); |
|
} |
|
|
|
static inline struct cpuacct *parent_ca(struct cpuacct *ca) |
|
{ |
|
return css_ca(ca->css.parent); |
|
} |
|
|
|
static DEFINE_PER_CPU(struct cpuacct_usage, root_cpuacct_cpuusage); |
|
static struct cpuacct root_cpuacct = { |
|
.cpustat = &kernel_cpustat, |
|
.cpuusage = &root_cpuacct_cpuusage, |
|
}; |
|
|
|
/* Create a new CPU accounting group */ |
|
static struct cgroup_subsys_state * |
|
cpuacct_css_alloc(struct cgroup_subsys_state *parent_css) |
|
{ |
|
struct cpuacct *ca; |
|
|
|
if (!parent_css) |
|
return &root_cpuacct.css; |
|
|
|
ca = kzalloc(sizeof(*ca), GFP_KERNEL); |
|
if (!ca) |
|
goto out; |
|
|
|
ca->cpuusage = alloc_percpu(struct cpuacct_usage); |
|
if (!ca->cpuusage) |
|
goto out_free_ca; |
|
|
|
ca->cpustat = alloc_percpu(struct kernel_cpustat); |
|
if (!ca->cpustat) |
|
goto out_free_cpuusage; |
|
|
|
return &ca->css; |
|
|
|
out_free_cpuusage: |
|
free_percpu(ca->cpuusage); |
|
out_free_ca: |
|
kfree(ca); |
|
out: |
|
return ERR_PTR(-ENOMEM); |
|
} |
|
|
|
/* Destroy an existing CPU accounting group */ |
|
static void cpuacct_css_free(struct cgroup_subsys_state *css) |
|
{ |
|
struct cpuacct *ca = css_ca(css); |
|
|
|
free_percpu(ca->cpustat); |
|
free_percpu(ca->cpuusage); |
|
kfree(ca); |
|
} |
|
|
|
static u64 cpuacct_cpuusage_read(struct cpuacct *ca, int cpu, |
|
enum cpuacct_stat_index index) |
|
{ |
|
struct cpuacct_usage *cpuusage = per_cpu_ptr(ca->cpuusage, cpu); |
|
u64 data; |
|
|
|
/* |
|
* We allow index == CPUACCT_STAT_NSTATS here to read |
|
* the sum of usages. |
|
*/ |
|
BUG_ON(index > CPUACCT_STAT_NSTATS); |
|
|
|
#ifndef CONFIG_64BIT |
|
/* |
|
* Take rq->lock to make 64-bit read safe on 32-bit platforms. |
|
*/ |
|
raw_spin_rq_lock_irq(cpu_rq(cpu)); |
|
#endif |
|
|
|
if (index == CPUACCT_STAT_NSTATS) { |
|
int i = 0; |
|
|
|
data = 0; |
|
for (i = 0; i < CPUACCT_STAT_NSTATS; i++) |
|
data += cpuusage->usages[i]; |
|
} else { |
|
data = cpuusage->usages[index]; |
|
} |
|
|
|
#ifndef CONFIG_64BIT |
|
raw_spin_rq_unlock_irq(cpu_rq(cpu)); |
|
#endif |
|
|
|
return data; |
|
} |
|
|
|
static void cpuacct_cpuusage_write(struct cpuacct *ca, int cpu, u64 val) |
|
{ |
|
struct cpuacct_usage *cpuusage = per_cpu_ptr(ca->cpuusage, cpu); |
|
int i; |
|
|
|
#ifndef CONFIG_64BIT |
|
/* |
|
* Take rq->lock to make 64-bit write safe on 32-bit platforms. |
|
*/ |
|
raw_spin_rq_lock_irq(cpu_rq(cpu)); |
|
#endif |
|
|
|
for (i = 0; i < CPUACCT_STAT_NSTATS; i++) |
|
cpuusage->usages[i] = val; |
|
|
|
#ifndef CONFIG_64BIT |
|
raw_spin_rq_unlock_irq(cpu_rq(cpu)); |
|
#endif |
|
} |
|
|
|
/* Return total CPU usage (in nanoseconds) of a group */ |
|
static u64 __cpuusage_read(struct cgroup_subsys_state *css, |
|
enum cpuacct_stat_index index) |
|
{ |
|
struct cpuacct *ca = css_ca(css); |
|
u64 totalcpuusage = 0; |
|
int i; |
|
|
|
for_each_possible_cpu(i) |
|
totalcpuusage += cpuacct_cpuusage_read(ca, i, index); |
|
|
|
return totalcpuusage; |
|
} |
|
|
|
static u64 cpuusage_user_read(struct cgroup_subsys_state *css, |
|
struct cftype *cft) |
|
{ |
|
return __cpuusage_read(css, CPUACCT_STAT_USER); |
|
} |
|
|
|
static u64 cpuusage_sys_read(struct cgroup_subsys_state *css, |
|
struct cftype *cft) |
|
{ |
|
return __cpuusage_read(css, CPUACCT_STAT_SYSTEM); |
|
} |
|
|
|
static u64 cpuusage_read(struct cgroup_subsys_state *css, struct cftype *cft) |
|
{ |
|
return __cpuusage_read(css, CPUACCT_STAT_NSTATS); |
|
} |
|
|
|
static int cpuusage_write(struct cgroup_subsys_state *css, struct cftype *cft, |
|
u64 val) |
|
{ |
|
struct cpuacct *ca = css_ca(css); |
|
int cpu; |
|
|
|
/* |
|
* Only allow '0' here to do a reset. |
|
*/ |
|
if (val) |
|
return -EINVAL; |
|
|
|
for_each_possible_cpu(cpu) |
|
cpuacct_cpuusage_write(ca, cpu, 0); |
|
|
|
return 0; |
|
} |
|
|
|
static int __cpuacct_percpu_seq_show(struct seq_file *m, |
|
enum cpuacct_stat_index index) |
|
{ |
|
struct cpuacct *ca = css_ca(seq_css(m)); |
|
u64 percpu; |
|
int i; |
|
|
|
for_each_possible_cpu(i) { |
|
percpu = cpuacct_cpuusage_read(ca, i, index); |
|
seq_printf(m, "%llu ", (unsigned long long) percpu); |
|
} |
|
seq_printf(m, "\n"); |
|
return 0; |
|
} |
|
|
|
static int cpuacct_percpu_user_seq_show(struct seq_file *m, void *V) |
|
{ |
|
return __cpuacct_percpu_seq_show(m, CPUACCT_STAT_USER); |
|
} |
|
|
|
static int cpuacct_percpu_sys_seq_show(struct seq_file *m, void *V) |
|
{ |
|
return __cpuacct_percpu_seq_show(m, CPUACCT_STAT_SYSTEM); |
|
} |
|
|
|
static int cpuacct_percpu_seq_show(struct seq_file *m, void *V) |
|
{ |
|
return __cpuacct_percpu_seq_show(m, CPUACCT_STAT_NSTATS); |
|
} |
|
|
|
static int cpuacct_all_seq_show(struct seq_file *m, void *V) |
|
{ |
|
struct cpuacct *ca = css_ca(seq_css(m)); |
|
int index; |
|
int cpu; |
|
|
|
seq_puts(m, "cpu"); |
|
for (index = 0; index < CPUACCT_STAT_NSTATS; index++) |
|
seq_printf(m, " %s", cpuacct_stat_desc[index]); |
|
seq_puts(m, "\n"); |
|
|
|
for_each_possible_cpu(cpu) { |
|
struct cpuacct_usage *cpuusage = per_cpu_ptr(ca->cpuusage, cpu); |
|
|
|
seq_printf(m, "%d", cpu); |
|
|
|
for (index = 0; index < CPUACCT_STAT_NSTATS; index++) { |
|
#ifndef CONFIG_64BIT |
|
/* |
|
* Take rq->lock to make 64-bit read safe on 32-bit |
|
* platforms. |
|
*/ |
|
raw_spin_rq_lock_irq(cpu_rq(cpu)); |
|
#endif |
|
|
|
seq_printf(m, " %llu", cpuusage->usages[index]); |
|
|
|
#ifndef CONFIG_64BIT |
|
raw_spin_rq_unlock_irq(cpu_rq(cpu)); |
|
#endif |
|
} |
|
seq_puts(m, "\n"); |
|
} |
|
return 0; |
|
} |
|
|
|
static int cpuacct_stats_show(struct seq_file *sf, void *v) |
|
{ |
|
struct cpuacct *ca = css_ca(seq_css(sf)); |
|
s64 val[CPUACCT_STAT_NSTATS]; |
|
int cpu; |
|
int stat; |
|
|
|
memset(val, 0, sizeof(val)); |
|
for_each_possible_cpu(cpu) { |
|
u64 *cpustat = per_cpu_ptr(ca->cpustat, cpu)->cpustat; |
|
|
|
val[CPUACCT_STAT_USER] += cpustat[CPUTIME_USER]; |
|
val[CPUACCT_STAT_USER] += cpustat[CPUTIME_NICE]; |
|
val[CPUACCT_STAT_SYSTEM] += cpustat[CPUTIME_SYSTEM]; |
|
val[CPUACCT_STAT_SYSTEM] += cpustat[CPUTIME_IRQ]; |
|
val[CPUACCT_STAT_SYSTEM] += cpustat[CPUTIME_SOFTIRQ]; |
|
} |
|
|
|
for (stat = 0; stat < CPUACCT_STAT_NSTATS; stat++) { |
|
seq_printf(sf, "%s %lld\n", |
|
cpuacct_stat_desc[stat], |
|
(long long)nsec_to_clock_t(val[stat])); |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static struct cftype files[] = { |
|
{ |
|
.name = "usage", |
|
.read_u64 = cpuusage_read, |
|
.write_u64 = cpuusage_write, |
|
}, |
|
{ |
|
.name = "usage_user", |
|
.read_u64 = cpuusage_user_read, |
|
}, |
|
{ |
|
.name = "usage_sys", |
|
.read_u64 = cpuusage_sys_read, |
|
}, |
|
{ |
|
.name = "usage_percpu", |
|
.seq_show = cpuacct_percpu_seq_show, |
|
}, |
|
{ |
|
.name = "usage_percpu_user", |
|
.seq_show = cpuacct_percpu_user_seq_show, |
|
}, |
|
{ |
|
.name = "usage_percpu_sys", |
|
.seq_show = cpuacct_percpu_sys_seq_show, |
|
}, |
|
{ |
|
.name = "usage_all", |
|
.seq_show = cpuacct_all_seq_show, |
|
}, |
|
{ |
|
.name = "stat", |
|
.seq_show = cpuacct_stats_show, |
|
}, |
|
{ } /* terminate */ |
|
}; |
|
|
|
/* |
|
* charge this task's execution time to its accounting group. |
|
* |
|
* called with rq->lock held. |
|
*/ |
|
void cpuacct_charge(struct task_struct *tsk, u64 cputime) |
|
{ |
|
struct cpuacct *ca; |
|
int index = CPUACCT_STAT_SYSTEM; |
|
struct pt_regs *regs = get_irq_regs() ? : task_pt_regs(tsk); |
|
|
|
if (regs && user_mode(regs)) |
|
index = CPUACCT_STAT_USER; |
|
|
|
rcu_read_lock(); |
|
|
|
for (ca = task_ca(tsk); ca; ca = parent_ca(ca)) |
|
__this_cpu_add(ca->cpuusage->usages[index], cputime); |
|
|
|
rcu_read_unlock(); |
|
} |
|
|
|
/* |
|
* Add user/system time to cpuacct. |
|
* |
|
* Note: it's the caller that updates the account of the root cgroup. |
|
*/ |
|
void cpuacct_account_field(struct task_struct *tsk, int index, u64 val) |
|
{ |
|
struct cpuacct *ca; |
|
|
|
rcu_read_lock(); |
|
for (ca = task_ca(tsk); ca != &root_cpuacct; ca = parent_ca(ca)) |
|
__this_cpu_add(ca->cpustat->cpustat[index], val); |
|
rcu_read_unlock(); |
|
} |
|
|
|
struct cgroup_subsys cpuacct_cgrp_subsys = { |
|
.css_alloc = cpuacct_css_alloc, |
|
.css_free = cpuacct_css_free, |
|
.legacy_cftypes = files, |
|
.early_init = true, |
|
};
|
|
|