Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * Simple CPU accounting cgroup controller
4 : : */
5 : : #include "sched.h"
6 : :
7 : : #ifdef CONFIG_IRQ_TIME_ACCOUNTING
8 : :
9 : : /*
10 : : * There are no locks covering percpu hardirq/softirq time.
11 : : * They are only modified in vtime_account, on corresponding CPU
12 : : * with interrupts disabled. So, writes are safe.
13 : : * They are read and saved off onto struct rq in update_rq_clock().
14 : : * This may result in other CPU reading this CPU's irq time and can
15 : : * race with irq/vtime_account on this CPU. We would either get old
16 : : * or new value with a side effect of accounting a slice of irq time to wrong
17 : : * task when irq is in progress while we read rq->clock. That is a worthy
18 : : * compromise in place of having locks on each irq in account_system_time.
19 : : */
20 : : DEFINE_PER_CPU(struct irqtime, cpu_irqtime);
21 : :
22 : : static int sched_clock_irqtime;
23 : :
24 : : void enable_sched_clock_irqtime(void)
25 : : {
26 : : sched_clock_irqtime = 1;
27 : : }
28 : :
29 : : void disable_sched_clock_irqtime(void)
30 : : {
31 : : sched_clock_irqtime = 0;
32 : : }
33 : :
34 : : static void irqtime_account_delta(struct irqtime *irqtime, u64 delta,
35 : : enum cpu_usage_stat idx)
36 : : {
37 : : u64 *cpustat = kcpustat_this_cpu->cpustat;
38 : :
39 : : u64_stats_update_begin(&irqtime->sync);
40 : : cpustat[idx] += delta;
41 : : irqtime->total += delta;
42 : : irqtime->tick_delta += delta;
43 : : u64_stats_update_end(&irqtime->sync);
44 : : }
45 : :
46 : : /*
47 : : * Called before incrementing preempt_count on {soft,}irq_enter
48 : : * and before decrementing preempt_count on {soft,}irq_exit.
49 : : */
50 : : void irqtime_account_irq(struct task_struct *curr)
51 : : {
52 : : struct irqtime *irqtime = this_cpu_ptr(&cpu_irqtime);
53 : : s64 delta;
54 : : int cpu;
55 : :
56 : : if (!sched_clock_irqtime)
57 : : return;
58 : :
59 : : cpu = smp_processor_id();
60 : : delta = sched_clock_cpu(cpu) - irqtime->irq_start_time;
61 : : irqtime->irq_start_time += delta;
62 : :
63 : : /*
64 : : * We do not account for softirq time from ksoftirqd here.
65 : : * We want to continue accounting softirq time to ksoftirqd thread
66 : : * in that case, so as not to confuse scheduler with a special task
67 : : * that do not consume any time, but still wants to run.
68 : : */
69 : : if (hardirq_count())
70 : : irqtime_account_delta(irqtime, delta, CPUTIME_IRQ);
71 : : else if (in_serving_softirq() && curr != this_cpu_ksoftirqd())
72 : : irqtime_account_delta(irqtime, delta, CPUTIME_SOFTIRQ);
73 : : }
74 : : EXPORT_SYMBOL_GPL(irqtime_account_irq);
75 : :
76 : : static u64 irqtime_tick_accounted(u64 maxtime)
77 : : {
78 : : struct irqtime *irqtime = this_cpu_ptr(&cpu_irqtime);
79 : : u64 delta;
80 : :
81 : : delta = min(irqtime->tick_delta, maxtime);
82 : : irqtime->tick_delta -= delta;
83 : :
84 : : return delta;
85 : : }
86 : :
87 : : #else /* CONFIG_IRQ_TIME_ACCOUNTING */
88 : :
89 : : #define sched_clock_irqtime (0)
90 : :
91 : : static u64 irqtime_tick_accounted(u64 dummy)
92 : : {
93 : : return 0;
94 : : }
95 : :
96 : : #endif /* !CONFIG_IRQ_TIME_ACCOUNTING */
97 : :
98 : 45850 : static inline void task_group_account_field(struct task_struct *p, int index,
99 : : u64 tmp)
100 : : {
101 : : /*
102 : : * Since all updates are sure to touch the root cgroup, we
103 : : * get ourselves ahead and touch it first. If the root cgroup
104 : : * is the only cgroup, then nothing else should be necessary.
105 : : *
106 : : */
107 [ - + - - : 45850 : __this_cpu_add(kernel_cpustat.cpustat[index], tmp);
- - - + ]
108 : :
109 : 45850 : cgroup_account_cputime_field(p, index, tmp);
110 : 45850 : }
111 : :
112 : : /*
113 : : * Account user CPU time to a process.
114 : : * @p: the process that the CPU time gets accounted to
115 : : * @cputime: the CPU time spent in user space since the last update
116 : : */
117 : 5447 : void account_user_time(struct task_struct *p, u64 cputime)
118 : : {
119 : 5447 : int index;
120 : :
121 : : /* Add user time to process. */
122 : 5447 : p->utime += cputime;
123 : 5447 : account_group_user_time(p, cputime);
124 : :
125 : 5447 : index = (task_nice(p) > 0) ? CPUTIME_NICE : CPUTIME_USER;
126 : :
127 : : /* Add user time to cpustat. */
128 : 5447 : task_group_account_field(p, index, cputime);
129 : :
130 : : /* Account for user time used */
131 : 5447 : acct_account_cputime(p);
132 : 5447 : }
133 : :
134 : : /*
135 : : * Account guest CPU time to a process.
136 : : * @p: the process that the CPU time gets accounted to
137 : : * @cputime: the CPU time spent in virtual machine since the last update
138 : : */
139 : 0 : void account_guest_time(struct task_struct *p, u64 cputime)
140 : : {
141 : 0 : u64 *cpustat = kcpustat_this_cpu->cpustat;
142 : :
143 : : /* Add guest time to process. */
144 : 0 : p->utime += cputime;
145 : 0 : account_group_user_time(p, cputime);
146 : 0 : p->gtime += cputime;
147 : :
148 : : /* Add guest time to cpustat. */
149 [ # # ]: 0 : if (task_nice(p) > 0) {
150 : 0 : cpustat[CPUTIME_NICE] += cputime;
151 : 0 : cpustat[CPUTIME_GUEST_NICE] += cputime;
152 : : } else {
153 : 0 : cpustat[CPUTIME_USER] += cputime;
154 : 0 : cpustat[CPUTIME_GUEST] += cputime;
155 : : }
156 : 0 : }
157 : :
158 : : /*
159 : : * Account system CPU time to a process and desired cpustat field
160 : : * @p: the process that the CPU time gets accounted to
161 : : * @cputime: the CPU time spent in kernel space since the last update
162 : : * @index: pointer to cpustat field that has to be updated
163 : : */
164 : 40403 : void account_system_index_time(struct task_struct *p,
165 : : u64 cputime, enum cpu_usage_stat index)
166 : : {
167 : : /* Add system time to process. */
168 : 40403 : p->stime += cputime;
169 : 40403 : account_group_system_time(p, cputime);
170 : :
171 : : /* Add system time to cpustat. */
172 : 40403 : task_group_account_field(p, index, cputime);
173 : :
174 : : /* Account for system time used */
175 : 40403 : acct_account_cputime(p);
176 : 40403 : }
177 : :
178 : : /*
179 : : * Account system CPU time to a process.
180 : : * @p: the process that the CPU time gets accounted to
181 : : * @hardirq_offset: the offset to subtract from hardirq_count()
182 : : * @cputime: the CPU time spent in kernel space since the last update
183 : : */
184 : 40403 : void account_system_time(struct task_struct *p, int hardirq_offset, u64 cputime)
185 : : {
186 : 40403 : int index;
187 : :
188 [ - + - - ]: 40403 : if ((p->flags & PF_VCPU) && (irq_count() - hardirq_offset == 0)) {
189 : 0 : account_guest_time(p, cputime);
190 : 0 : return;
191 : : }
192 : :
193 [ + - ]: 40403 : if (hardirq_count() - hardirq_offset)
194 : : index = CPUTIME_IRQ;
195 [ + + ]: 40403 : else if (in_serving_softirq())
196 : : index = CPUTIME_SOFTIRQ;
197 : : else
198 : 39763 : index = CPUTIME_SYSTEM;
199 : :
200 : 40403 : account_system_index_time(p, cputime, index);
201 : : }
202 : :
203 : : /*
204 : : * Account for involuntary wait time.
205 : : * @cputime: the CPU time spent in involuntary wait
206 : : */
207 : 45468 : void account_steal_time(u64 cputime)
208 : : {
209 : 0 : u64 *cpustat = kcpustat_this_cpu->cpustat;
210 : :
211 : 45468 : cpustat[CPUTIME_STEAL] += cputime;
212 : 0 : }
213 : :
214 : : /*
215 : : * Account for idle time.
216 : : * @cputime: the CPU time spent in idle wait
217 : : */
218 : 2309 : void account_idle_time(u64 cputime)
219 : : {
220 : 2309 : u64 *cpustat = kcpustat_this_cpu->cpustat;
221 : 2309 : struct rq *rq = this_rq();
222 : :
223 [ + + ]: 2309 : if (atomic_read(&rq->nr_iowait) > 0)
224 : 810 : cpustat[CPUTIME_IOWAIT] += cputime;
225 : : else
226 : 1499 : cpustat[CPUTIME_IDLE] += cputime;
227 : 2309 : }
228 : :
229 : : /*
230 : : * When a guest is interrupted for a longer amount of time, missed clock
231 : : * ticks are not redelivered later. Due to that, this function may on
232 : : * occasion account more time than the calling functions think elapsed.
233 : : */
234 : 48182 : static __always_inline u64 steal_account_process_time(u64 maxtime)
235 : : {
236 : : #ifdef CONFIG_PARAVIRT
237 : 48182 : if (static_key_false(¶virt_steal_enabled)) {
238 : 45468 : u64 steal;
239 : :
240 : 45468 : steal = paravirt_steal_clock(smp_processor_id());
241 : 45468 : steal -= this_rq()->prev_steal_time;
242 : 45468 : steal = min(steal, maxtime);
243 : 45468 : account_steal_time(steal);
244 : 45468 : this_rq()->prev_steal_time += steal;
245 : :
246 : 354 : return steal;
247 : : }
248 : : #endif
249 : : return 0;
250 : : }
251 : :
252 : : /*
253 : : * Account how much elapsed time was spent in steal, irq, or softirq time.
254 : : */
255 : : static inline u64 account_other_time(u64 max)
256 : : {
257 : : u64 accounted;
258 : :
259 : : lockdep_assert_irqs_disabled();
260 : :
261 : : accounted = steal_account_process_time(max);
262 : :
263 : : if (accounted < max)
264 : : accounted += irqtime_tick_accounted(max - accounted);
265 : :
266 : : return accounted;
267 : : }
268 : :
269 : : #ifdef CONFIG_64BIT
270 : 12138 : static inline u64 read_sum_exec_runtime(struct task_struct *t)
271 : : {
272 : 12138 : return t->se.sum_exec_runtime;
273 : : }
274 : : #else
275 : : static u64 read_sum_exec_runtime(struct task_struct *t)
276 : : {
277 : : u64 ns;
278 : : struct rq_flags rf;
279 : : struct rq *rq;
280 : :
281 : : rq = task_rq_lock(t, &rf);
282 : : ns = t->se.sum_exec_runtime;
283 : : task_rq_unlock(rq, t, &rf);
284 : :
285 : : return ns;
286 : : }
287 : : #endif
288 : :
289 : : /*
290 : : * Accumulate raw cputime values of dead tasks (sig->[us]time) and live
291 : : * tasks (sum on group iteration) belonging to @tsk's group.
292 : : */
293 : 12138 : void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times)
294 : : {
295 : 12138 : struct signal_struct *sig = tsk->signal;
296 : 12138 : u64 utime, stime;
297 : 12138 : struct task_struct *t;
298 : 12138 : unsigned int seq, nextseq;
299 : 12138 : unsigned long flags;
300 : :
301 : : /*
302 : : * Update current task runtime to account pending time since last
303 : : * scheduler action or thread_group_cputime() call. This thread group
304 : : * might have other running tasks on different CPUs, but updating
305 : : * their runtime can affect syscall performance, so we skip account
306 : : * those pending times and rely only on values updated on tick or
307 : : * other scheduler action.
308 : : */
309 [ + + ]: 12138 : if (same_thread_group(current, tsk))
310 : 735 : (void) task_sched_runtime(current);
311 : :
312 : 12138 : rcu_read_lock();
313 : : /* Attempt a lockless read on the first round. */
314 : 12138 : nextseq = 0;
315 : 12138 : do {
316 : 12138 : seq = nextseq;
317 : 12138 : flags = read_seqbegin_or_lock_irqsave(&sig->stats_lock, &seq);
318 : 12138 : times->utime = sig->utime;
319 : 12138 : times->stime = sig->stime;
320 : 12138 : times->sum_exec_runtime = sig->sum_sched_runtime;
321 : :
322 [ + + ]: 24276 : for_each_thread(tsk, t) {
323 : 12138 : task_cputime(t, &utime, &stime);
324 : 12138 : times->utime += utime;
325 : 12138 : times->stime += stime;
326 : 12138 : times->sum_exec_runtime += read_sum_exec_runtime(t);
327 : : }
328 : : /* If lockless access failed, take the lock. */
329 : 12138 : nextseq = 1;
330 [ + - ]: 12138 : } while (need_seqretry(&sig->stats_lock, seq));
331 [ - + ]: 12138 : done_seqretry_irqrestore(&sig->stats_lock, seq, flags);
332 : 12138 : rcu_read_unlock();
333 : 12138 : }
334 : :
335 : : #ifdef CONFIG_IRQ_TIME_ACCOUNTING
336 : : /*
337 : : * Account a tick to a process and cpustat
338 : : * @p: the process that the CPU time gets accounted to
339 : : * @user_tick: is the tick from userspace
340 : : * @rq: the pointer to rq
341 : : *
342 : : * Tick demultiplexing follows the order
343 : : * - pending hardirq update
344 : : * - pending softirq update
345 : : * - user_time
346 : : * - idle_time
347 : : * - system time
348 : : * - check for guest_time
349 : : * - else account as system_time
350 : : *
351 : : * Check for hardirq is done both for system and user time as there is
352 : : * no timer going off while we are on hardirq and hence we may never get an
353 : : * opportunity to update it solely in system time.
354 : : * p->stime and friends are only updated on system time and not on irq
355 : : * softirq as those do not count in task exec_runtime any more.
356 : : */
357 : : static void irqtime_account_process_tick(struct task_struct *p, int user_tick,
358 : : int ticks)
359 : : {
360 : : u64 other, cputime = TICK_NSEC * ticks;
361 : :
362 : : /*
363 : : * When returning from idle, many ticks can get accounted at
364 : : * once, including some ticks of steal, irq, and softirq time.
365 : : * Subtract those ticks from the amount of time accounted to
366 : : * idle, or potentially user or system time. Due to rounding,
367 : : * other time can exceed ticks occasionally.
368 : : */
369 : : other = account_other_time(ULONG_MAX);
370 : : if (other >= cputime)
371 : : return;
372 : :
373 : : cputime -= other;
374 : :
375 : : if (this_cpu_ksoftirqd() == p) {
376 : : /*
377 : : * ksoftirqd time do not get accounted in cpu_softirq_time.
378 : : * So, we have to handle it separately here.
379 : : * Also, p->stime needs to be updated for ksoftirqd.
380 : : */
381 : : account_system_index_time(p, cputime, CPUTIME_SOFTIRQ);
382 : : } else if (user_tick) {
383 : : account_user_time(p, cputime);
384 : : } else if (p == this_rq()->idle) {
385 : : account_idle_time(cputime);
386 : : } else if (p->flags & PF_VCPU) { /* System time or guest time */
387 : : account_guest_time(p, cputime);
388 : : } else {
389 : : account_system_index_time(p, cputime, CPUTIME_SYSTEM);
390 : : }
391 : : }
392 : :
393 : : static void irqtime_account_idle_ticks(int ticks)
394 : : {
395 : : irqtime_account_process_tick(current, 0, ticks);
396 : : }
397 : : #else /* CONFIG_IRQ_TIME_ACCOUNTING */
398 : : static inline void irqtime_account_idle_ticks(int ticks) { }
399 : : static inline void irqtime_account_process_tick(struct task_struct *p, int user_tick,
400 : : int nr_ticks) { }
401 : : #endif /* CONFIG_IRQ_TIME_ACCOUNTING */
402 : :
403 : : /*
404 : : * Use precise platform statistics if available:
405 : : */
406 : : #ifdef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
407 : :
408 : : # ifndef __ARCH_HAS_VTIME_TASK_SWITCH
409 : : void vtime_task_switch(struct task_struct *prev)
410 : : {
411 : : if (is_idle_task(prev))
412 : : vtime_account_idle(prev);
413 : : else
414 : : vtime_account_kernel(prev);
415 : :
416 : : vtime_flush(prev);
417 : : arch_vtime_task_switch(prev);
418 : : }
419 : : # endif
420 : :
421 : : /*
422 : : * Archs that account the whole time spent in the idle task
423 : : * (outside irq) as idle time can rely on this and just implement
424 : : * vtime_account_kernel() and vtime_account_idle(). Archs that
425 : : * have other meaning of the idle time (s390 only includes the
426 : : * time spent by the CPU when it's in low power mode) must override
427 : : * vtime_account().
428 : : */
429 : : #ifndef __ARCH_HAS_VTIME_ACCOUNT
430 : : void vtime_account_irq_enter(struct task_struct *tsk)
431 : : {
432 : : if (!in_interrupt() && is_idle_task(tsk))
433 : : vtime_account_idle(tsk);
434 : : else
435 : : vtime_account_kernel(tsk);
436 : : }
437 : : EXPORT_SYMBOL_GPL(vtime_account_irq_enter);
438 : : #endif /* __ARCH_HAS_VTIME_ACCOUNT */
439 : :
440 : : void cputime_adjust(struct task_cputime *curr, struct prev_cputime *prev,
441 : : u64 *ut, u64 *st)
442 : : {
443 : : *ut = curr->utime;
444 : : *st = curr->stime;
445 : : }
446 : :
447 : : void task_cputime_adjusted(struct task_struct *p, u64 *ut, u64 *st)
448 : : {
449 : : *ut = p->utime;
450 : : *st = p->stime;
451 : : }
452 : : EXPORT_SYMBOL_GPL(task_cputime_adjusted);
453 : :
454 : : void thread_group_cputime_adjusted(struct task_struct *p, u64 *ut, u64 *st)
455 : : {
456 : : struct task_cputime cputime;
457 : :
458 : : thread_group_cputime(p, &cputime);
459 : :
460 : : *ut = cputime.utime;
461 : : *st = cputime.stime;
462 : : }
463 : :
464 : : #else /* !CONFIG_VIRT_CPU_ACCOUNTING_NATIVE: */
465 : :
466 : : /*
467 : : * Account a single tick of CPU time.
468 : : * @p: the process that the CPU time gets accounted to
469 : : * @user_tick: indicates if the tick is a user or a system tick
470 : : */
471 : 47828 : void account_process_tick(struct task_struct *p, int user_tick)
472 : : {
473 : 47828 : u64 cputime, steal;
474 : :
475 [ + + ]: 47828 : if (vtime_accounting_enabled_this_cpu())
476 : : return;
477 : :
478 : 47828 : if (sched_clock_irqtime) {
479 : : irqtime_account_process_tick(p, user_tick, 1);
480 : : return;
481 : : }
482 : :
483 : 47828 : cputime = TICK_NSEC;
484 [ + + ]: 47828 : steal = steal_account_process_time(ULONG_MAX);
485 : :
486 [ + + ]: 47828 : if (steal >= cputime)
487 : : return;
488 : :
489 : 47805 : cputime -= steal;
490 : :
491 [ + + ]: 47805 : if (user_tick)
492 : 5447 : account_user_time(p, cputime);
493 [ + + + + ]: 42358 : else if ((p != this_rq()->idle) || (irq_count() != HARDIRQ_OFFSET))
494 : 40403 : account_system_time(p, HARDIRQ_OFFSET, cputime);
495 : : else
496 : 1955 : account_idle_time(cputime);
497 : : }
498 : :
499 : : /*
500 : : * Account multiple ticks of idle time.
501 : : * @ticks: number of stolen ticks
502 : : */
503 : 354 : void account_idle_ticks(unsigned long ticks)
504 : : {
505 : 354 : u64 cputime, steal;
506 : :
507 : 354 : if (sched_clock_irqtime) {
508 : : irqtime_account_idle_ticks(ticks);
509 : : return;
510 : : }
511 : :
512 : 354 : cputime = ticks * TICK_NSEC;
513 [ + - ]: 354 : steal = steal_account_process_time(ULONG_MAX);
514 : :
515 [ + - ]: 354 : if (steal >= cputime)
516 : : return;
517 : :
518 : 354 : cputime -= steal;
519 : 354 : account_idle_time(cputime);
520 : : }
521 : :
522 : : /*
523 : : * Perform (stime * rtime) / total, but avoid multiplication overflow by
524 : : * losing precision when the numbers are big.
525 : : */
526 : 1313 : static u64 scale_stime(u64 stime, u64 rtime, u64 total)
527 : : {
528 : 1313 : u64 scaled;
529 : :
530 : 1313 : for (;;) {
531 : : /* Make sure "rtime" is the bigger of stime/rtime */
532 [ + + ]: 1313 : if (stime > rtime)
533 : 162 : swap(rtime, stime);
534 : :
535 : : /* Make sure 'total' fits in 32 bits */
536 [ - + ]: 1313 : if (total >> 32)
537 : 0 : goto drop_precision;
538 : :
539 : : /* Does rtime (and thus stime) fit in 32 bits? */
540 [ - + ]: 1313 : if (!(rtime >> 32))
541 : : break;
542 : :
543 : : /* Can we just balance rtime/stime rather than dropping bits? */
544 [ # # ]: 0 : if (stime >> 31)
545 : 0 : goto drop_precision;
546 : :
547 : : /* We can grow stime and shrink rtime and try to make them both fit */
548 : 0 : stime <<= 1;
549 : 0 : rtime >>= 1;
550 : 0 : continue;
551 : :
552 : 0 : drop_precision:
553 : : /* We drop from rtime, it has more bits than stime */
554 : 0 : rtime >>= 1;
555 : 0 : total >>= 1;
556 : : }
557 : :
558 : : /*
559 : : * Make sure gcc understands that this is a 32x32->64 multiply,
560 : : * followed by a 64/32->64 divide.
561 : : */
562 : 1313 : scaled = div_u64((u64) (u32) stime * (u64) (u32) rtime, (u32)total);
563 : 1313 : return scaled;
564 : : }
565 : :
566 : : /*
567 : : * Adjust tick based cputime random precision against scheduler runtime
568 : : * accounting.
569 : : *
570 : : * Tick based cputime accounting depend on random scheduling timeslices of a
571 : : * task to be interrupted or not by the timer. Depending on these
572 : : * circumstances, the number of these interrupts may be over or
573 : : * under-optimistic, matching the real user and system cputime with a variable
574 : : * precision.
575 : : *
576 : : * Fix this by scaling these tick based values against the total runtime
577 : : * accounted by the CFS scheduler.
578 : : *
579 : : * This code provides the following guarantees:
580 : : *
581 : : * stime + utime == rtime
582 : : * stime_i+1 >= stime_i, utime_i+1 >= utime_i
583 : : *
584 : : * Assuming that rtime_i+1 >= rtime_i.
585 : : */
586 : 12138 : void cputime_adjust(struct task_cputime *curr, struct prev_cputime *prev,
587 : : u64 *ut, u64 *st)
588 : : {
589 : 12138 : u64 rtime, stime, utime;
590 : 12138 : unsigned long flags;
591 : :
592 : : /* Serialize concurrent callers such that we can honour our guarantees */
593 : 12138 : raw_spin_lock_irqsave(&prev->lock, flags);
594 : 12138 : rtime = curr->sum_exec_runtime;
595 : :
596 : : /*
597 : : * This is possible under two circumstances:
598 : : * - rtime isn't monotonic after all (a bug);
599 : : * - we got reordered by the lock.
600 : : *
601 : : * In both cases this acts as a filter such that the rest of the code
602 : : * can assume it is monotonic regardless of anything else.
603 : : */
604 [ + + ]: 12138 : if (prev->stime + prev->utime >= rtime)
605 : 467 : goto out;
606 : :
607 : 11671 : stime = curr->stime;
608 : 11671 : utime = curr->utime;
609 : :
610 : : /*
611 : : * If either stime or utime are 0, assume all runtime is userspace.
612 : : * Once a task gets some ticks, the monotonicy code at 'update:'
613 : : * will ensure things converge to the observed ratio.
614 : : */
615 [ + + ]: 11671 : if (stime == 0) {
616 : 4281 : utime = rtime;
617 : 4281 : goto update;
618 : : }
619 : :
620 [ + + ]: 7390 : if (utime == 0) {
621 : 6077 : stime = rtime;
622 : 6077 : goto update;
623 : : }
624 : :
625 : 1313 : stime = scale_stime(stime, rtime, stime + utime);
626 : :
627 : 11671 : update:
628 : : /*
629 : : * Make sure stime doesn't go backwards; this preserves monotonicity
630 : : * for utime because rtime is monotonic.
631 : : *
632 : : * utime_i+1 = rtime_i+1 - stime_i
633 : : * = rtime_i+1 - (rtime_i - utime_i)
634 : : * = (rtime_i+1 - rtime_i) + utime_i
635 : : * >= utime_i
636 : : */
637 : 11671 : if (stime < prev->stime)
638 : : stime = prev->stime;
639 : 11671 : utime = rtime - stime;
640 : :
641 : : /*
642 : : * Make sure utime doesn't go backwards; this still preserves
643 : : * monotonicity for stime, analogous argument to above.
644 : : */
645 [ + + ]: 11671 : if (utime < prev->utime) {
646 : 212 : utime = prev->utime;
647 : 212 : stime = rtime - utime;
648 : : }
649 : :
650 : 11671 : prev->stime = stime;
651 : 11671 : prev->utime = utime;
652 : 12138 : out:
653 : 12138 : *ut = prev->utime;
654 : 12138 : *st = prev->stime;
655 : 12138 : raw_spin_unlock_irqrestore(&prev->lock, flags);
656 : 12138 : }
657 : :
658 : 0 : void task_cputime_adjusted(struct task_struct *p, u64 *ut, u64 *st)
659 : : {
660 : 0 : struct task_cputime cputime = {
661 : 0 : .sum_exec_runtime = p->se.sum_exec_runtime,
662 : : };
663 : :
664 : 0 : task_cputime(p, &cputime.utime, &cputime.stime);
665 : 0 : cputime_adjust(&cputime, &p->prev_cputime, ut, st);
666 : 0 : }
667 : : EXPORT_SYMBOL_GPL(task_cputime_adjusted);
668 : :
669 : 12138 : void thread_group_cputime_adjusted(struct task_struct *p, u64 *ut, u64 *st)
670 : : {
671 : 12138 : struct task_cputime cputime;
672 : :
673 : 12138 : thread_group_cputime(p, &cputime);
674 : 12138 : cputime_adjust(&cputime, &p->signal->prev_cputime, ut, st);
675 : 12138 : }
676 : : #endif /* !CONFIG_VIRT_CPU_ACCOUNTING_NATIVE */
677 : :
678 : : #ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
679 : : static u64 vtime_delta(struct vtime *vtime)
680 : : {
681 : : unsigned long long clock;
682 : :
683 : : clock = sched_clock();
684 : : if (clock < vtime->starttime)
685 : : return 0;
686 : :
687 : : return clock - vtime->starttime;
688 : : }
689 : :
690 : : static u64 get_vtime_delta(struct vtime *vtime)
691 : : {
692 : : u64 delta = vtime_delta(vtime);
693 : : u64 other;
694 : :
695 : : /*
696 : : * Unlike tick based timing, vtime based timing never has lost
697 : : * ticks, and no need for steal time accounting to make up for
698 : : * lost ticks. Vtime accounts a rounded version of actual
699 : : * elapsed time. Limit account_other_time to prevent rounding
700 : : * errors from causing elapsed vtime to go negative.
701 : : */
702 : : other = account_other_time(delta);
703 : : WARN_ON_ONCE(vtime->state == VTIME_INACTIVE);
704 : : vtime->starttime += delta;
705 : :
706 : : return delta - other;
707 : : }
708 : :
709 : : static void vtime_account_system(struct task_struct *tsk,
710 : : struct vtime *vtime)
711 : : {
712 : : vtime->stime += get_vtime_delta(vtime);
713 : : if (vtime->stime >= TICK_NSEC) {
714 : : account_system_time(tsk, irq_count(), vtime->stime);
715 : : vtime->stime = 0;
716 : : }
717 : : }
718 : :
719 : : static void vtime_account_guest(struct task_struct *tsk,
720 : : struct vtime *vtime)
721 : : {
722 : : vtime->gtime += get_vtime_delta(vtime);
723 : : if (vtime->gtime >= TICK_NSEC) {
724 : : account_guest_time(tsk, vtime->gtime);
725 : : vtime->gtime = 0;
726 : : }
727 : : }
728 : :
729 : : static void __vtime_account_kernel(struct task_struct *tsk,
730 : : struct vtime *vtime)
731 : : {
732 : : /* We might have scheduled out from guest path */
733 : : if (vtime->state == VTIME_GUEST)
734 : : vtime_account_guest(tsk, vtime);
735 : : else
736 : : vtime_account_system(tsk, vtime);
737 : : }
738 : :
739 : : void vtime_account_kernel(struct task_struct *tsk)
740 : : {
741 : : struct vtime *vtime = &tsk->vtime;
742 : :
743 : : if (!vtime_delta(vtime))
744 : : return;
745 : :
746 : : write_seqcount_begin(&vtime->seqcount);
747 : : __vtime_account_kernel(tsk, vtime);
748 : : write_seqcount_end(&vtime->seqcount);
749 : : }
750 : :
751 : : void vtime_user_enter(struct task_struct *tsk)
752 : : {
753 : : struct vtime *vtime = &tsk->vtime;
754 : :
755 : : write_seqcount_begin(&vtime->seqcount);
756 : : vtime_account_system(tsk, vtime);
757 : : vtime->state = VTIME_USER;
758 : : write_seqcount_end(&vtime->seqcount);
759 : : }
760 : :
761 : : void vtime_user_exit(struct task_struct *tsk)
762 : : {
763 : : struct vtime *vtime = &tsk->vtime;
764 : :
765 : : write_seqcount_begin(&vtime->seqcount);
766 : : vtime->utime += get_vtime_delta(vtime);
767 : : if (vtime->utime >= TICK_NSEC) {
768 : : account_user_time(tsk, vtime->utime);
769 : : vtime->utime = 0;
770 : : }
771 : : vtime->state = VTIME_SYS;
772 : : write_seqcount_end(&vtime->seqcount);
773 : : }
774 : :
775 : : void vtime_guest_enter(struct task_struct *tsk)
776 : : {
777 : : struct vtime *vtime = &tsk->vtime;
778 : : /*
779 : : * The flags must be updated under the lock with
780 : : * the vtime_starttime flush and update.
781 : : * That enforces a right ordering and update sequence
782 : : * synchronization against the reader (task_gtime())
783 : : * that can thus safely catch up with a tickless delta.
784 : : */
785 : : write_seqcount_begin(&vtime->seqcount);
786 : : vtime_account_system(tsk, vtime);
787 : : tsk->flags |= PF_VCPU;
788 : : vtime->state = VTIME_GUEST;
789 : : write_seqcount_end(&vtime->seqcount);
790 : : }
791 : : EXPORT_SYMBOL_GPL(vtime_guest_enter);
792 : :
793 : : void vtime_guest_exit(struct task_struct *tsk)
794 : : {
795 : : struct vtime *vtime = &tsk->vtime;
796 : :
797 : : write_seqcount_begin(&vtime->seqcount);
798 : : vtime_account_guest(tsk, vtime);
799 : : tsk->flags &= ~PF_VCPU;
800 : : vtime->state = VTIME_SYS;
801 : : write_seqcount_end(&vtime->seqcount);
802 : : }
803 : : EXPORT_SYMBOL_GPL(vtime_guest_exit);
804 : :
805 : : void vtime_account_idle(struct task_struct *tsk)
806 : : {
807 : : account_idle_time(get_vtime_delta(&tsk->vtime));
808 : : }
809 : :
810 : : void vtime_task_switch_generic(struct task_struct *prev)
811 : : {
812 : : struct vtime *vtime = &prev->vtime;
813 : :
814 : : write_seqcount_begin(&vtime->seqcount);
815 : : if (vtime->state == VTIME_IDLE)
816 : : vtime_account_idle(prev);
817 : : else
818 : : __vtime_account_kernel(prev, vtime);
819 : : vtime->state = VTIME_INACTIVE;
820 : : vtime->cpu = -1;
821 : : write_seqcount_end(&vtime->seqcount);
822 : :
823 : : vtime = ¤t->vtime;
824 : :
825 : : write_seqcount_begin(&vtime->seqcount);
826 : : if (is_idle_task(current))
827 : : vtime->state = VTIME_IDLE;
828 : : else if (current->flags & PF_VCPU)
829 : : vtime->state = VTIME_GUEST;
830 : : else
831 : : vtime->state = VTIME_SYS;
832 : : vtime->starttime = sched_clock();
833 : : vtime->cpu = smp_processor_id();
834 : : write_seqcount_end(&vtime->seqcount);
835 : : }
836 : :
837 : : void vtime_init_idle(struct task_struct *t, int cpu)
838 : : {
839 : : struct vtime *vtime = &t->vtime;
840 : : unsigned long flags;
841 : :
842 : : local_irq_save(flags);
843 : : write_seqcount_begin(&vtime->seqcount);
844 : : vtime->state = VTIME_IDLE;
845 : : vtime->starttime = sched_clock();
846 : : vtime->cpu = cpu;
847 : : write_seqcount_end(&vtime->seqcount);
848 : : local_irq_restore(flags);
849 : : }
850 : :
851 : : u64 task_gtime(struct task_struct *t)
852 : : {
853 : : struct vtime *vtime = &t->vtime;
854 : : unsigned int seq;
855 : : u64 gtime;
856 : :
857 : : if (!vtime_accounting_enabled())
858 : : return t->gtime;
859 : :
860 : : do {
861 : : seq = read_seqcount_begin(&vtime->seqcount);
862 : :
863 : : gtime = t->gtime;
864 : : if (vtime->state == VTIME_GUEST)
865 : : gtime += vtime->gtime + vtime_delta(vtime);
866 : :
867 : : } while (read_seqcount_retry(&vtime->seqcount, seq));
868 : :
869 : : return gtime;
870 : : }
871 : :
872 : : /*
873 : : * Fetch cputime raw values from fields of task_struct and
874 : : * add up the pending nohz execution time since the last
875 : : * cputime snapshot.
876 : : */
877 : : void task_cputime(struct task_struct *t, u64 *utime, u64 *stime)
878 : : {
879 : : struct vtime *vtime = &t->vtime;
880 : : unsigned int seq;
881 : : u64 delta;
882 : :
883 : : if (!vtime_accounting_enabled()) {
884 : : *utime = t->utime;
885 : : *stime = t->stime;
886 : : return;
887 : : }
888 : :
889 : : do {
890 : : seq = read_seqcount_begin(&vtime->seqcount);
891 : :
892 : : *utime = t->utime;
893 : : *stime = t->stime;
894 : :
895 : : /* Task is sleeping or idle, nothing to add */
896 : : if (vtime->state < VTIME_SYS)
897 : : continue;
898 : :
899 : : delta = vtime_delta(vtime);
900 : :
901 : : /*
902 : : * Task runs either in user (including guest) or kernel space,
903 : : * add pending nohz time to the right place.
904 : : */
905 : : if (vtime->state == VTIME_SYS)
906 : : *stime += vtime->stime + delta;
907 : : else
908 : : *utime += vtime->utime + delta;
909 : : } while (read_seqcount_retry(&vtime->seqcount, seq));
910 : : }
911 : :
912 : : static int vtime_state_check(struct vtime *vtime, int cpu)
913 : : {
914 : : /*
915 : : * We raced against a context switch, fetch the
916 : : * kcpustat task again.
917 : : */
918 : : if (vtime->cpu != cpu && vtime->cpu != -1)
919 : : return -EAGAIN;
920 : :
921 : : /*
922 : : * Two possible things here:
923 : : * 1) We are seeing the scheduling out task (prev) or any past one.
924 : : * 2) We are seeing the scheduling in task (next) but it hasn't
925 : : * passed though vtime_task_switch() yet so the pending
926 : : * cputime of the prev task may not be flushed yet.
927 : : *
928 : : * Case 1) is ok but 2) is not. So wait for a safe VTIME state.
929 : : */
930 : : if (vtime->state == VTIME_INACTIVE)
931 : : return -EAGAIN;
932 : :
933 : : return 0;
934 : : }
935 : :
936 : : static u64 kcpustat_user_vtime(struct vtime *vtime)
937 : : {
938 : : if (vtime->state == VTIME_USER)
939 : : return vtime->utime + vtime_delta(vtime);
940 : : else if (vtime->state == VTIME_GUEST)
941 : : return vtime->gtime + vtime_delta(vtime);
942 : : return 0;
943 : : }
944 : :
945 : : static int kcpustat_field_vtime(u64 *cpustat,
946 : : struct task_struct *tsk,
947 : : enum cpu_usage_stat usage,
948 : : int cpu, u64 *val)
949 : : {
950 : : struct vtime *vtime = &tsk->vtime;
951 : : unsigned int seq;
952 : : int err;
953 : :
954 : : do {
955 : : seq = read_seqcount_begin(&vtime->seqcount);
956 : :
957 : : err = vtime_state_check(vtime, cpu);
958 : : if (err < 0)
959 : : return err;
960 : :
961 : : *val = cpustat[usage];
962 : :
963 : : /*
964 : : * Nice VS unnice cputime accounting may be inaccurate if
965 : : * the nice value has changed since the last vtime update.
966 : : * But proper fix would involve interrupting target on nice
967 : : * updates which is a no go on nohz_full (although the scheduler
968 : : * may still interrupt the target if rescheduling is needed...)
969 : : */
970 : : switch (usage) {
971 : : case CPUTIME_SYSTEM:
972 : : if (vtime->state == VTIME_SYS)
973 : : *val += vtime->stime + vtime_delta(vtime);
974 : : break;
975 : : case CPUTIME_USER:
976 : : if (task_nice(tsk) <= 0)
977 : : *val += kcpustat_user_vtime(vtime);
978 : : break;
979 : : case CPUTIME_NICE:
980 : : if (task_nice(tsk) > 0)
981 : : *val += kcpustat_user_vtime(vtime);
982 : : break;
983 : : case CPUTIME_GUEST:
984 : : if (vtime->state == VTIME_GUEST && task_nice(tsk) <= 0)
985 : : *val += vtime->gtime + vtime_delta(vtime);
986 : : break;
987 : : case CPUTIME_GUEST_NICE:
988 : : if (vtime->state == VTIME_GUEST && task_nice(tsk) > 0)
989 : : *val += vtime->gtime + vtime_delta(vtime);
990 : : break;
991 : : default:
992 : : break;
993 : : }
994 : : } while (read_seqcount_retry(&vtime->seqcount, seq));
995 : :
996 : : return 0;
997 : : }
998 : :
999 : : u64 kcpustat_field(struct kernel_cpustat *kcpustat,
1000 : : enum cpu_usage_stat usage, int cpu)
1001 : : {
1002 : : u64 *cpustat = kcpustat->cpustat;
1003 : : struct rq *rq;
1004 : : u64 val;
1005 : : int err;
1006 : :
1007 : : if (!vtime_accounting_enabled_cpu(cpu))
1008 : : return cpustat[usage];
1009 : :
1010 : : rq = cpu_rq(cpu);
1011 : :
1012 : : for (;;) {
1013 : : struct task_struct *curr;
1014 : :
1015 : : rcu_read_lock();
1016 : : curr = rcu_dereference(rq->curr);
1017 : : if (WARN_ON_ONCE(!curr)) {
1018 : : rcu_read_unlock();
1019 : : return cpustat[usage];
1020 : : }
1021 : :
1022 : : err = kcpustat_field_vtime(cpustat, curr, usage, cpu, &val);
1023 : : rcu_read_unlock();
1024 : :
1025 : : if (!err)
1026 : : return val;
1027 : :
1028 : : cpu_relax();
1029 : : }
1030 : : }
1031 : : EXPORT_SYMBOL_GPL(kcpustat_field);
1032 : :
1033 : : static int kcpustat_cpu_fetch_vtime(struct kernel_cpustat *dst,
1034 : : const struct kernel_cpustat *src,
1035 : : struct task_struct *tsk, int cpu)
1036 : : {
1037 : : struct vtime *vtime = &tsk->vtime;
1038 : : unsigned int seq;
1039 : : int err;
1040 : :
1041 : : do {
1042 : : u64 *cpustat;
1043 : : u64 delta;
1044 : :
1045 : : seq = read_seqcount_begin(&vtime->seqcount);
1046 : :
1047 : : err = vtime_state_check(vtime, cpu);
1048 : : if (err < 0)
1049 : : return err;
1050 : :
1051 : : *dst = *src;
1052 : : cpustat = dst->cpustat;
1053 : :
1054 : : /* Task is sleeping, dead or idle, nothing to add */
1055 : : if (vtime->state < VTIME_SYS)
1056 : : continue;
1057 : :
1058 : : delta = vtime_delta(vtime);
1059 : :
1060 : : /*
1061 : : * Task runs either in user (including guest) or kernel space,
1062 : : * add pending nohz time to the right place.
1063 : : */
1064 : : if (vtime->state == VTIME_SYS) {
1065 : : cpustat[CPUTIME_SYSTEM] += vtime->stime + delta;
1066 : : } else if (vtime->state == VTIME_USER) {
1067 : : if (task_nice(tsk) > 0)
1068 : : cpustat[CPUTIME_NICE] += vtime->utime + delta;
1069 : : else
1070 : : cpustat[CPUTIME_USER] += vtime->utime + delta;
1071 : : } else {
1072 : : WARN_ON_ONCE(vtime->state != VTIME_GUEST);
1073 : : if (task_nice(tsk) > 0) {
1074 : : cpustat[CPUTIME_GUEST_NICE] += vtime->gtime + delta;
1075 : : cpustat[CPUTIME_NICE] += vtime->gtime + delta;
1076 : : } else {
1077 : : cpustat[CPUTIME_GUEST] += vtime->gtime + delta;
1078 : : cpustat[CPUTIME_USER] += vtime->gtime + delta;
1079 : : }
1080 : : }
1081 : : } while (read_seqcount_retry(&vtime->seqcount, seq));
1082 : :
1083 : : return err;
1084 : : }
1085 : :
1086 : : void kcpustat_cpu_fetch(struct kernel_cpustat *dst, int cpu)
1087 : : {
1088 : : const struct kernel_cpustat *src = &kcpustat_cpu(cpu);
1089 : : struct rq *rq;
1090 : : int err;
1091 : :
1092 : : if (!vtime_accounting_enabled_cpu(cpu)) {
1093 : : *dst = *src;
1094 : : return;
1095 : : }
1096 : :
1097 : : rq = cpu_rq(cpu);
1098 : :
1099 : : for (;;) {
1100 : : struct task_struct *curr;
1101 : :
1102 : : rcu_read_lock();
1103 : : curr = rcu_dereference(rq->curr);
1104 : : if (WARN_ON_ONCE(!curr)) {
1105 : : rcu_read_unlock();
1106 : : *dst = *src;
1107 : : return;
1108 : : }
1109 : :
1110 : : err = kcpustat_cpu_fetch_vtime(dst, src, curr, cpu);
1111 : : rcu_read_unlock();
1112 : :
1113 : : if (!err)
1114 : : return;
1115 : :
1116 : : cpu_relax();
1117 : : }
1118 : : }
1119 : : EXPORT_SYMBOL_GPL(kcpustat_cpu_fetch);
1120 : :
1121 : : #endif /* CONFIG_VIRT_CPU_ACCOUNTING_GEN */
|
