~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/sched/cpuacct.c

Version: ~ [ linux-6.2-rc3 ] ~ [ linux-6.1.5 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.87 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.162 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.228 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.269 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.302 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp