projects/linux·blob master · refs

365 lines · 8.1 KiB

1// SPDX-License-Identifier: GPL-2.0
2
3/*
4 * CPU accounting code for task groups.
5 *
6 * Based on the work by Paul Menage ([email protected]) and Balbir Singh
7 * ([email protected]).
8 */
9#include <linux/sched/cputime.h>
10#include "sched.h"
11
12/* Time spent by the tasks of the CPU accounting group executing in ... */
13enum cpuacct_stat_index {
14 CPUACCT_STAT_USER, /* ... user mode */
15 CPUACCT_STAT_SYSTEM, /* ... kernel mode */
16
17 CPUACCT_STAT_NSTATS,
18};
19
20static const char * const cpuacct_stat_desc[] = {
21 [CPUACCT_STAT_USER] = "user",
22 [CPUACCT_STAT_SYSTEM] = "system",
23};
24
25/* track CPU usage of a group of tasks and its child groups */
26struct cpuacct {
27 struct cgroup_subsys_state css;
28 /* cpuusage holds pointer to a u64-type object on every CPU */
29 u64 __percpu *cpuusage;
30 struct kernel_cpustat __percpu *cpustat;
31};
32
33static inline struct cpuacct *css_ca(struct cgroup_subsys_state *css)
34{
35 return css ? container_of(css, struct cpuacct, css) : NULL;
36}
37
38/* Return CPU accounting group to which this task belongs */
39static inline struct cpuacct *task_ca(struct task_struct *tsk)
40{
41 return css_ca(task_css(tsk, cpuacct_cgrp_id));
42}
43
44static inline struct cpuacct *parent_ca(struct cpuacct *ca)
45{
46 return css_ca(ca->css.parent);
47}
48
49static DEFINE_PER_CPU(u64, root_cpuacct_cpuusage);
50static struct cpuacct root_cpuacct = {
51 .cpustat = &kernel_cpustat,
52 .cpuusage = &root_cpuacct_cpuusage,
53};
54
55/* Create a new CPU accounting group */
56static struct cgroup_subsys_state *
57cpuacct_css_alloc(struct cgroup_subsys_state *parent_css)
58{
59 struct cpuacct *ca;
60
61 if (!parent_css)
62 return &root_cpuacct.css;
63
64 ca = kzalloc_obj(*ca);
65 if (!ca)
66 goto out;
67
68 ca->cpuusage = alloc_percpu(u64);
69 if (!ca->cpuusage)
70 goto out_free_ca;
71
72 ca->cpustat = alloc_percpu(struct kernel_cpustat);
73 if (!ca->cpustat)
74 goto out_free_cpuusage;
75
76 return &ca->css;
77
78out_free_cpuusage:
79 free_percpu(ca->cpuusage);
80out_free_ca:
81 kfree(ca);
82out:
83 return ERR_PTR(-ENOMEM);
84}
85
86/* Destroy an existing CPU accounting group */
87static void cpuacct_css_free(struct cgroup_subsys_state *css)
88{
89 struct cpuacct *ca = css_ca(css);
90
91 free_percpu(ca->cpustat);
92 free_percpu(ca->cpuusage);
93 kfree(ca);
94}
95
96static u64 cpuacct_cpuusage_read(struct cpuacct *ca, int cpu,
97 enum cpuacct_stat_index index)
98{
99 u64 *cpuusage = per_cpu_ptr(ca->cpuusage, cpu);
100 u64 *cpustat = per_cpu_ptr(ca->cpustat, cpu)->cpustat;
101 u64 data;
102
103 /*
104 * We allow index == CPUACCT_STAT_NSTATS here to read
105 * the sum of usages.
106 */
107 if (WARN_ON_ONCE(index > CPUACCT_STAT_NSTATS))
108 return 0;
109
110#ifndef CONFIG_64BIT
111 /*
112 * Take rq->lock to make 64-bit read safe on 32-bit platforms.
113 */
114 raw_spin_rq_lock_irq(cpu_rq(cpu));
115#endif
116
117 switch (index) {
118 case CPUACCT_STAT_USER:
119 data = cpustat[CPUTIME_USER] + cpustat[CPUTIME_NICE];
120 break;
121 case CPUACCT_STAT_SYSTEM:
122 data = cpustat[CPUTIME_SYSTEM] + cpustat[CPUTIME_IRQ] +
123 cpustat[CPUTIME_SOFTIRQ];
124 break;
125 case CPUACCT_STAT_NSTATS:
126 data = *cpuusage;
127 break;
128 }
129
130#ifndef CONFIG_64BIT
131 raw_spin_rq_unlock_irq(cpu_rq(cpu));
132#endif
133
134 return data;
135}
136
137static void cpuacct_cpuusage_write(struct cpuacct *ca, int cpu)
138{
139 u64 *cpuusage = per_cpu_ptr(ca->cpuusage, cpu);
140 u64 *cpustat = per_cpu_ptr(ca->cpustat, cpu)->cpustat;
141
142 /* Don't allow to reset global kernel_cpustat */
143 if (ca == &root_cpuacct)
144 return;
145
146#ifndef CONFIG_64BIT
147 /*
148 * Take rq->lock to make 64-bit write safe on 32-bit platforms.
149 */
150 raw_spin_rq_lock_irq(cpu_rq(cpu));
151#endif
152 *cpuusage = 0;
153 cpustat[CPUTIME_USER] = cpustat[CPUTIME_NICE] = 0;
154 cpustat[CPUTIME_SYSTEM] = cpustat[CPUTIME_IRQ] = 0;
155 cpustat[CPUTIME_SOFTIRQ] = 0;
156
157#ifndef CONFIG_64BIT
158 raw_spin_rq_unlock_irq(cpu_rq(cpu));
159#endif
160}
161
162/* Return total CPU usage (in nanoseconds) of a group */
163static u64 __cpuusage_read(struct cgroup_subsys_state *css,
164 enum cpuacct_stat_index index)
165{
166 struct cpuacct *ca = css_ca(css);
167 u64 totalcpuusage = 0;
168 int i;
169
170 for_each_possible_cpu(i)
171 totalcpuusage += cpuacct_cpuusage_read(ca, i, index);
172
173 return totalcpuusage;
174}
175
176static u64 cpuusage_user_read(struct cgroup_subsys_state *css,
177 struct cftype *cft)
178{
179 return __cpuusage_read(css, CPUACCT_STAT_USER);
180}
181
182static u64 cpuusage_sys_read(struct cgroup_subsys_state *css,
183 struct cftype *cft)
184{
185 return __cpuusage_read(css, CPUACCT_STAT_SYSTEM);
186}
187
188static u64 cpuusage_read(struct cgroup_subsys_state *css, struct cftype *cft)
189{
190 return __cpuusage_read(css, CPUACCT_STAT_NSTATS);
191}
192
193static int cpuusage_write(struct cgroup_subsys_state *css, struct cftype *cft,
194 u64 val)
195{
196 struct cpuacct *ca = css_ca(css);
197 int cpu;
198
199 /*
200 * Only allow '0' here to do a reset.
201 */
202 if (val)
203 return -EINVAL;
204
205 for_each_possible_cpu(cpu)
206 cpuacct_cpuusage_write(ca, cpu);
207
208 return 0;
209}
210
211static int __cpuacct_percpu_seq_show(struct seq_file *m,
212 enum cpuacct_stat_index index)
213{
214 struct cpuacct *ca = css_ca(seq_css(m));
215 u64 percpu;
216 int i;
217
218 for_each_possible_cpu(i) {
219 percpu = cpuacct_cpuusage_read(ca, i, index);
220 seq_printf(m, "%llu ", (unsigned long long) percpu);
221 }
222 seq_printf(m, "\n");
223 return 0;
224}
225
226static int cpuacct_percpu_user_seq_show(struct seq_file *m, void *V)
227{
228 return __cpuacct_percpu_seq_show(m, CPUACCT_STAT_USER);
229}
230
231static int cpuacct_percpu_sys_seq_show(struct seq_file *m, void *V)
232{
233 return __cpuacct_percpu_seq_show(m, CPUACCT_STAT_SYSTEM);
234}
235
236static int cpuacct_percpu_seq_show(struct seq_file *m, void *V)
237{
238 return __cpuacct_percpu_seq_show(m, CPUACCT_STAT_NSTATS);
239}
240
241static int cpuacct_all_seq_show(struct seq_file *m, void *V)
242{
243 struct cpuacct *ca = css_ca(seq_css(m));
244 int index;
245 int cpu;
246
247 seq_puts(m, "cpu");
248 for (index = 0; index < CPUACCT_STAT_NSTATS; index++)
249 seq_printf(m, " %s", cpuacct_stat_desc[index]);
250 seq_puts(m, "\n");
251
252 for_each_possible_cpu(cpu) {
253 seq_printf(m, "%d", cpu);
254 for (index = 0; index < CPUACCT_STAT_NSTATS; index++)
255 seq_printf(m, " %llu",
256 cpuacct_cpuusage_read(ca, cpu, index));
257 seq_puts(m, "\n");
258 }
259 return 0;
260}
261
262static int cpuacct_stats_show(struct seq_file *sf, void *v)
263{
264 struct cpuacct *ca = css_ca(seq_css(sf));
265 struct task_cputime cputime;
266 u64 val[CPUACCT_STAT_NSTATS];
267 int cpu;
268 int stat;
269
270 memset(&cputime, 0, sizeof(cputime));
271 for_each_possible_cpu(cpu) {
272 u64 *cpustat = per_cpu_ptr(ca->cpustat, cpu)->cpustat;
273
274 cputime.utime += cpustat[CPUTIME_USER];
275 cputime.utime += cpustat[CPUTIME_NICE];
276 cputime.stime += cpustat[CPUTIME_SYSTEM];
277 cputime.stime += cpustat[CPUTIME_IRQ];
278 cputime.stime += cpustat[CPUTIME_SOFTIRQ];
279
280 cputime.sum_exec_runtime += *per_cpu_ptr(ca->cpuusage, cpu);
281 }
282
283 cputime_adjust(&cputime, &seq_css(sf)->cgroup->prev_cputime,
284 &val[CPUACCT_STAT_USER], &val[CPUACCT_STAT_SYSTEM]);
285
286 for (stat = 0; stat < CPUACCT_STAT_NSTATS; stat++) {
287 seq_printf(sf, "%s %llu\n", cpuacct_stat_desc[stat],
288 nsec_to_clock_t(val[stat]));
289 }
290
291 return 0;
292}
293
294static struct cftype files[] = {
295 {
296 .name = "usage",
297 .read_u64 = cpuusage_read,
298 .write_u64 = cpuusage_write,
299 },
300 {
301 .name = "usage_user",
302 .read_u64 = cpuusage_user_read,
303 },
304 {
305 .name = "usage_sys",
306 .read_u64 = cpuusage_sys_read,
307 },
308 {
309 .name = "usage_percpu",
310 .seq_show = cpuacct_percpu_seq_show,
311 },
312 {
313 .name = "usage_percpu_user",
314 .seq_show = cpuacct_percpu_user_seq_show,
315 },
316 {
317 .name = "usage_percpu_sys",
318 .seq_show = cpuacct_percpu_sys_seq_show,
319 },
320 {
321 .name = "usage_all",
322 .seq_show = cpuacct_all_seq_show,
323 },
324 {
325 .name = "stat",
326 .seq_show = cpuacct_stats_show,
327 },
328 { } /* terminate */
329};
330
331/*
332 * charge this task's execution time to its accounting group.
333 *
334 * called with rq->lock held.
335 */
336void cpuacct_charge(struct task_struct *tsk, u64 cputime)
337{
338 unsigned int cpu = task_cpu(tsk);
339 struct cpuacct *ca;
340
341 lockdep_assert_rq_held(cpu_rq(cpu));
342
343 for (ca = task_ca(tsk); ca; ca = parent_ca(ca))
344 *per_cpu_ptr(ca->cpuusage, cpu) += cputime;
345}
346
347/*
348 * Add user/system time to cpuacct.
349 *
350 * Note: it's the caller that updates the account of the root cgroup.
351 */
352void cpuacct_account_field(struct task_struct *tsk, int index, u64 val)
353{
354 struct cpuacct *ca;
355
356 for (ca = task_ca(tsk); ca != &root_cpuacct; ca = parent_ca(ca))
357 __this_cpu_add(ca->cpustat->cpustat[index], val);
358}
359
360struct cgroup_subsys cpuacct_cgrp_subsys = {
361 .css_alloc = cpuacct_css_alloc,
362 .css_free = cpuacct_css_free,
363 .legacy_cftypes = files,
364 .early_init = true,
365};