kernel/sched/cputime.c

   1 #include <linux/export.h>
   2 #include <linux/sched.h>
   3 #include <linux/tsacct_kern.h>
   4 #include <linux/kernel_stat.h>
   5 #include <linux/static_key.h>
   6 #include <linux/context_tracking.h>
   7 #include "sched.h"
   8 #ifdef CONFIG_PARAVIRT
   9 #include <asm/paravirt.h>
  10 #endif
  11
  12
  13 #ifdef CONFIG_IRQ_TIME_ACCOUNTING
  14
  15 /*
  16  * There are no locks covering percpu hardirq/softirq time.
  17  * They are only modified in vtime_account, on corresponding CPU
  18  * with interrupts disabled. So, writes are safe.
  19  * They are read and saved off onto struct rq in update_rq_clock().
  20  * This may result in other CPU reading this CPU's irq time and can
  21  * race with irq/vtime_account on this CPU. We would either get old
  22  * or new value with a side effect of accounting a slice of irq time to wrong
  23  * task when irq is in progress while we read rq->clock. That is a worthy
  24  * compromise in place of having locks on each irq in account_system_time.
  25  */
  26 DEFINE_PER_CPU(u64, cpu_hardirq_time);
  27 DEFINE_PER_CPU(u64, cpu_softirq_time);
  28
  29 static DEFINE_PER_CPU(u64, irq_start_time);
  30 static int sched_clock_irqtime;
  31
  32 void enable_sched_clock_irqtime(void)
  33 {
  34         sched_clock_irqtime = 1;
  35 }
  36
  37 void disable_sched_clock_irqtime(void)
  38 {
  39         sched_clock_irqtime = 0;
  40 }
  41
  42 #ifndef CONFIG_64BIT
  43 DEFINE_PER_CPU(seqcount_t, irq_time_seq);
  44 #endif /* CONFIG_64BIT */
  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         s64 delta;
  53         int cpu;
  54
  55         if (!sched_clock_irqtime)
  56                 return;
  57
  58         cpu = smp_processor_id();
  59         delta = sched_clock_cpu(cpu) - __this_cpu_read(irq_start_time);
  60         __this_cpu_add(irq_start_time, delta);
  61
  62         irq_time_write_begin();
  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                 __this_cpu_add(cpu_hardirq_time, delta);
  71         else if (in_serving_softirq() && curr != this_cpu_ksoftirqd())
  72                 __this_cpu_add(cpu_softirq_time, delta);
  73
  74         irq_time_write_end();
  75 }
  76 EXPORT_SYMBOL_GPL(irqtime_account_irq);
  77
  78 static cputime_t irqtime_account_hi_update(cputime_t maxtime)
  79 {
  80         u64 *cpustat = kcpustat_this_cpu->cpustat;
  81         cputime_t irq_cputime;
  82
  83         irq_cputime = nsecs_to_cputime64(__this_cpu_read(cpu_hardirq_time)) -
  84                       cpustat[CPUTIME_IRQ];
  85         irq_cputime = min(irq_cputime, maxtime);
  86         cpustat[CPUTIME_IRQ] += irq_cputime;
  87
  88         return irq_cputime;
  89 }
  90
  91 static cputime_t irqtime_account_si_update(cputime_t maxtime)
  92 {
  93         u64 *cpustat = kcpustat_this_cpu->cpustat;
  94         cputime_t softirq_cputime;
  95
  96         softirq_cputime = nsecs_to_cputime64(__this_cpu_read(cpu_softirq_time)) -
  97                           cpustat[CPUTIME_SOFTIRQ];
  98         softirq_cputime = min(softirq_cputime, maxtime);
  99         cpustat[CPUTIME_SOFTIRQ] += softirq_cputime;
 100
 101         return softirq_cputime;
 102 }
 103
 104 #else /* CONFIG_IRQ_TIME_ACCOUNTING */
 105
 106 #define sched_clock_irqtime     (0)
 107
 108 static cputime_t irqtime_account_hi_update(cputime_t dummy)
 109 {
 110         return 0;
 111 }
 112
 113 static cputime_t irqtime_account_si_update(cputime_t dummy)
 114 {
 115         return 0;
 116 }
 117
 118 #endif /* !CONFIG_IRQ_TIME_ACCOUNTING */
 119
 120 static inline void task_group_account_field(struct task_struct *p, int index,
 121                                             u64 tmp)
 122 {
 123         /*
 124          * Since all updates are sure to touch the root cgroup, we
 125          * get ourselves ahead and touch it first. If the root cgroup
 126          * is the only cgroup, then nothing else should be necessary.
 127          *
 128          */
 129         __this_cpu_add(kernel_cpustat.cpustat[index], tmp);
 130
 131         cpuacct_account_field(p, index, tmp);
 132 }
 133
 134 /*
 135  * Account user cpu time to a process.
 136  * @p: the process that the cpu time gets accounted to
 137  * @cputime: the cpu time spent in user space since the last update
 138  * @cputime_scaled: cputime scaled by cpu frequency
 139  */
 140 void account_user_time(struct task_struct *p, cputime_t cputime,
 141                        cputime_t cputime_scaled)
 142 {
 143         int index;
 144
 145         /* Add user time to process. */
 146         p->utime += cputime;
 147         p->utimescaled += cputime_scaled;
 148         account_group_user_time(p, cputime);
 149
 150         index = (task_nice(p) > 0) ? CPUTIME_NICE : CPUTIME_USER;
 151
 152         /* Add user time to cpustat. */
 153         task_group_account_field(p, index, (__force u64) cputime);
 154
 155         /* Account for user time used */
 156         acct_account_cputime(p);
 157 }
 158
 159 /*
 160  * Account guest cpu time to a process.
 161  * @p: the process that the cpu time gets accounted to
 162  * @cputime: the cpu time spent in virtual machine since the last update
 163  * @cputime_scaled: cputime scaled by cpu frequency
 164  */
 165 static void account_guest_time(struct task_struct *p, cputime_t cputime,
 166                                cputime_t cputime_scaled)
 167 {
 168         u64 *cpustat = kcpustat_this_cpu->cpustat;
 169
 170         /* Add guest time to process. */
 171         p->utime += cputime;
 172         p->utimescaled += cputime_scaled;
 173         account_group_user_time(p, cputime);
 174         p->gtime += cputime;
 175
 176         /* Add guest time to cpustat. */
 177         if (task_nice(p) > 0) {
 178                 cpustat[CPUTIME_NICE] += (__force u64) cputime;
 179                 cpustat[CPUTIME_GUEST_NICE] += (__force u64) cputime;
 180         } else {
 181                 cpustat[CPUTIME_USER] += (__force u64) cputime;
 182                 cpustat[CPUTIME_GUEST] += (__force u64) cputime;
 183         }
 184 }
 185
 186 /*
 187  * Account system cpu time to a process and desired cpustat field
 188  * @p: the process that the cpu time gets accounted to
 189  * @cputime: the cpu time spent in kernel space since the last update
 190  * @cputime_scaled: cputime scaled by cpu frequency
 191  * @target_cputime64: pointer to cpustat field that has to be updated
 192  */
 193 static inline
 194 void __account_system_time(struct task_struct *p, cputime_t cputime,
 195                         cputime_t cputime_scaled, int index)
 196 {
 197         /* Add system time to process. */
 198         p->stime += cputime;
 199         p->stimescaled += cputime_scaled;
 200         account_group_system_time(p, cputime);
 201
 202         /* Add system time to cpustat. */
 203         task_group_account_field(p, index, (__force u64) cputime);
 204
 205         /* Account for system time used */
 206         acct_account_cputime(p);
 207 }
 208
 209 /*
 210  * Account system cpu time to a process.
 211  * @p: the process that the cpu time gets accounted to
 212  * @hardirq_offset: the offset to subtract from hardirq_count()
 213  * @cputime: the cpu time spent in kernel space since the last update
 214  * @cputime_scaled: cputime scaled by cpu frequency
 215  */
 216 void account_system_time(struct task_struct *p, int hardirq_offset,
 217                          cputime_t cputime, cputime_t cputime_scaled)
 218 {
 219         int index;
 220
 221         if ((p->flags & PF_VCPU) && (irq_count() - hardirq_offset == 0)) {
 222                 account_guest_time(p, cputime, cputime_scaled);
 223                 return;
 224         }
 225
 226         if (hardirq_count() - hardirq_offset)
 227                 index = CPUTIME_IRQ;
 228         else if (in_serving_softirq())
 229                 index = CPUTIME_SOFTIRQ;
 230         else
 231                 index = CPUTIME_SYSTEM;
 232
 233         __account_system_time(p, cputime, cputime_scaled, index);
 234 }
 235
 236 /*
 237  * Account for involuntary wait time.
 238  * @cputime: the cpu time spent in involuntary wait
 239  */
 240 void account_steal_time(cputime_t cputime)
 241 {
 242         u64 *cpustat = kcpustat_this_cpu->cpustat;
 243
 244         cpustat[CPUTIME_STEAL] += (__force u64) cputime;
 245 }
 246
 247 /*
 248  * Account for idle time.
 249  * @cputime: the cpu time spent in idle wait
 250  */
 251 void account_idle_time(cputime_t cputime)
 252 {
 253         u64 *cpustat = kcpustat_this_cpu->cpustat;
 254         struct rq *rq = this_rq();
 255
 256         if (atomic_read(&rq->nr_iowait) > 0)
 257                 cpustat[CPUTIME_IOWAIT] += (__force u64) cputime;
 258         else
 259                 cpustat[CPUTIME_IDLE] += (__force u64) cputime;
 260 }
 261
 262 /*
 263  * When a guest is interrupted for a longer amount of time, missed clock
 264  * ticks are not redelivered later. Due to that, this function may on
 265  * occasion account more time than the calling functions think elapsed.
 266  */
 267 static __always_inline cputime_t steal_account_process_time(cputime_t maxtime)
 268 {
 269 #ifdef CONFIG_PARAVIRT
 270         if (static_key_false(&paravirt_steal_enabled)) {
 271                 cputime_t steal_cputime;
 272                 u64 steal;
 273
 274                 steal = paravirt_steal_clock(smp_processor_id());
 275                 steal -= this_rq()->prev_steal_time;
 276
 277                 steal_cputime = min(nsecs_to_cputime(steal), maxtime);
 278                 account_steal_time(steal_cputime);
 279                 this_rq()->prev_steal_time += cputime_to_nsecs(steal_cputime);
 280
 281                 return steal_cputime;
 282         }
 283 #endif
 284         return 0;
 285 }
 286
 287 /*
 288  * Account how much elapsed time was spent in steal, irq, or softirq time.
 289  */
 290 static inline cputime_t account_other_time(cputime_t max)
 291 {
 292         cputime_t accounted;
 293
 294         /* Shall be converted to a lockdep-enabled lightweight check */
 295         WARN_ON_ONCE(!irqs_disabled());
 296
 297         accounted = steal_account_process_time(max);
 298
 299         if (accounted < max)
 300                 accounted += irqtime_account_hi_update(max - accounted);
 301
 302         if (accounted < max)
 303                 accounted += irqtime_account_si_update(max - accounted);
 304
 305         return accounted;
 306 }
 307
 308 #ifdef CONFIG_64BIT
 309 static inline u64 read_sum_exec_runtime(struct task_struct *t)
 310 {
 311         return t->se.sum_exec_runtime;
 312 }
 313 #else
 314 static u64 read_sum_exec_runtime(struct task_struct *t)
 315 {
 316         u64 ns;
 317         struct rq_flags rf;
 318         struct rq *rq;
 319
 320         rq = task_rq_lock(t, &rf);
 321         ns = t->se.sum_exec_runtime;
 322         task_rq_unlock(rq, t, &rf);
 323
 324         return ns;
 325 }
 326 #endif
 327
 328 /*
 329  * Accumulate raw cputime values of dead tasks (sig->[us]time) and live
 330  * tasks (sum on group iteration) belonging to @tsk's group.
 331  */
 332 void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times)
 333 {
 334         struct signal_struct *sig = tsk->signal;
 335         cputime_t utime, stime;
 336         struct task_struct *t;
 337         unsigned int seq, nextseq;
 338         unsigned long flags;
 339
 340         /*
 341          * Update current task runtime to account pending time since last
 342          * scheduler action or thread_group_cputime() call. This thread group
 343          * might have other running tasks on different CPUs, but updating
 344          * their runtime can affect syscall performance, so we skip account
 345          * those pending times and rely only on values updated on tick or
 346          * other scheduler action.
 347          */
 348         if (same_thread_group(current, tsk))
 349                 (void) task_sched_runtime(current);
 350
 351         rcu_read_lock();
 352         /* Attempt a lockless read on the first round. */
 353         nextseq = 0;
 354         do {
 355                 seq = nextseq;
 356                 flags = read_seqbegin_or_lock_irqsave(&sig->stats_lock, &seq);
 357                 times->utime = sig->utime;
 358                 times->stime = sig->stime;
 359                 times->sum_exec_runtime = sig->sum_sched_runtime;
 360
 361                 for_each_thread(tsk, t) {
 362                         task_cputime(t, &utime, &stime);
 363                         times->utime += utime;
 364                         times->stime += stime;
 365                         times->sum_exec_runtime += read_sum_exec_runtime(t);
 366                 }
 367                 /* If lockless access failed, take the lock. */
 368                 nextseq = 1;
 369         } while (need_seqretry(&sig->stats_lock, seq));
 370         done_seqretry_irqrestore(&sig->stats_lock, seq, flags);
 371         rcu_read_unlock();
 372 }
 373
 374 #ifdef CONFIG_IRQ_TIME_ACCOUNTING
 375 /*
 376  * Account a tick to a process and cpustat
 377  * @p: the process that the cpu time gets accounted to
 378  * @user_tick: is the tick from userspace
 379  * @rq: the pointer to rq
 380  *
 381  * Tick demultiplexing follows the order
 382  * - pending hardirq update
 383  * - pending softirq update
 384  * - user_time
 385  * - idle_time
 386  * - system time
 387  *   - check for guest_time
 388  *   - else account as system_time
 389  *
 390  * Check for hardirq is done both for system and user time as there is
 391  * no timer going off while we are on hardirq and hence we may never get an
 392  * opportunity to update it solely in system time.
 393  * p->stime and friends are only updated on system time and not on irq
 394  * softirq as those do not count in task exec_runtime any more.
 395  */
 396 static void irqtime_account_process_tick(struct task_struct *p, int user_tick,
 397                                          struct rq *rq, int ticks)
 398 {
 399         u64 cputime = (__force u64) cputime_one_jiffy * ticks;
 400         cputime_t scaled, other;
 401
 402         /*
 403          * When returning from idle, many ticks can get accounted at
 404          * once, including some ticks of steal, irq, and softirq time.
 405          * Subtract those ticks from the amount of time accounted to
 406          * idle, or potentially user or system time. Due to rounding,
 407          * other time can exceed ticks occasionally.
 408          */
 409         other = account_other_time(ULONG_MAX);
 410         if (other >= cputime)
 411                 return;
 412         cputime -= other;
 413         scaled = cputime_to_scaled(cputime);
 414
 415         if (this_cpu_ksoftirqd() == p) {
 416                 /*
 417                  * ksoftirqd time do not get accounted in cpu_softirq_time.
 418                  * So, we have to handle it separately here.
 419                  * Also, p->stime needs to be updated for ksoftirqd.
 420                  */
 421                 __account_system_time(p, cputime, scaled, CPUTIME_SOFTIRQ);
 422         } else if (user_tick) {
 423                 account_user_time(p, cputime, scaled);
 424         } else if (p == rq->idle) {
 425                 account_idle_time(cputime);
 426         } else if (p->flags & PF_VCPU) { /* System time or guest time */
 427                 account_guest_time(p, cputime, scaled);
 428         } else {
 429                 __account_system_time(p, cputime, scaled,       CPUTIME_SYSTEM);
 430         }
 431 }
 432
 433 static void irqtime_account_idle_ticks(int ticks)
 434 {
 435         struct rq *rq = this_rq();
 436
 437         irqtime_account_process_tick(current, 0, rq, ticks);
 438 }
 439 #else /* CONFIG_IRQ_TIME_ACCOUNTING */
 440 static inline void irqtime_account_idle_ticks(int ticks) {}
 441 static inline void irqtime_account_process_tick(struct task_struct *p, int user_tick,
 442                                                 struct rq *rq, int nr_ticks) {}
 443 #endif /* CONFIG_IRQ_TIME_ACCOUNTING */
 444
 445 /*
 446  * Use precise platform statistics if available:
 447  */
 448 #ifdef CONFIG_VIRT_CPU_ACCOUNTING
 449
 450 #ifndef __ARCH_HAS_VTIME_TASK_SWITCH
 451 void vtime_common_task_switch(struct task_struct *prev)
 452 {
 453         if (is_idle_task(prev))
 454                 vtime_account_idle(prev);
 455         else
 456                 vtime_account_system(prev);
 457
 458 #ifdef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
 459         vtime_account_user(prev);
 460 #endif
 461         arch_vtime_task_switch(prev);
 462 }
 463 #endif
 464
 465 #endif /* CONFIG_VIRT_CPU_ACCOUNTING */
 466
 467
 468 #ifdef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
 469 /*
 470  * Archs that account the whole time spent in the idle task
 471  * (outside irq) as idle time can rely on this and just implement
 472  * vtime_account_system() and vtime_account_idle(). Archs that
 473  * have other meaning of the idle time (s390 only includes the
 474  * time spent by the CPU when it's in low power mode) must override
 475  * vtime_account().
 476  */
 477 #ifndef __ARCH_HAS_VTIME_ACCOUNT
 478 void vtime_account_irq_enter(struct task_struct *tsk)
 479 {
 480         if (!in_interrupt() && is_idle_task(tsk))
 481                 vtime_account_idle(tsk);
 482         else
 483                 vtime_account_system(tsk);
 484 }
 485 EXPORT_SYMBOL_GPL(vtime_account_irq_enter);
 486 #endif /* __ARCH_HAS_VTIME_ACCOUNT */
 487
 488 void task_cputime_adjusted(struct task_struct *p, cputime_t *ut, cputime_t *st)
 489 {
 490         *ut = p->utime;
 491         *st = p->stime;
 492 }
 493 EXPORT_SYMBOL_GPL(task_cputime_adjusted);
 494
 495 void thread_group_cputime_adjusted(struct task_struct *p, cputime_t *ut, cputime_t *st)
 496 {
 497         struct task_cputime cputime;
 498
 499         thread_group_cputime(p, &cputime);
 500
 501         *ut = cputime.utime;
 502         *st = cputime.stime;
 503 }
 504 #else /* !CONFIG_VIRT_CPU_ACCOUNTING_NATIVE */
 505 /*
 506  * Account a single tick of cpu time.
 507  * @p: the process that the cpu time gets accounted to
 508  * @user_tick: indicates if the tick is a user or a system tick
 509  */
 510 void account_process_tick(struct task_struct *p, int user_tick)
 511 {
 512         cputime_t cputime, scaled, steal;
 513         struct rq *rq = this_rq();
 514
 515         if (vtime_accounting_cpu_enabled())
 516                 return;
 517
 518         if (sched_clock_irqtime) {
 519                 irqtime_account_process_tick(p, user_tick, rq, 1);
 520                 return;
 521         }
 522
 523         cputime = cputime_one_jiffy;
 524         steal = steal_account_process_time(ULONG_MAX);
 525
 526         if (steal >= cputime)
 527                 return;
 528
 529         cputime -= steal;
 530         scaled = cputime_to_scaled(cputime);
 531
 532         if (user_tick)
 533                 account_user_time(p, cputime, scaled);
 534         else if ((p != rq->idle) || (irq_count() != HARDIRQ_OFFSET))
 535                 account_system_time(p, HARDIRQ_OFFSET, cputime, scaled);
 536         else
 537                 account_idle_time(cputime);
 538 }
 539
 540 /*
 541  * Account multiple ticks of idle time.
 542  * @ticks: number of stolen ticks
 543  */
 544 void account_idle_ticks(unsigned long ticks)
 545 {
 546         cputime_t cputime, steal;
 547
 548         if (sched_clock_irqtime) {
 549                 irqtime_account_idle_ticks(ticks);
 550                 return;
 551         }
 552
 553         cputime = jiffies_to_cputime(ticks);
 554         steal = steal_account_process_time(ULONG_MAX);
 555
 556         if (steal >= cputime)
 557                 return;
 558
 559         cputime -= steal;
 560         account_idle_time(cputime);
 561 }
 562
 563 /*
 564  * Perform (stime * rtime) / total, but avoid multiplication overflow by
 565  * loosing precision when the numbers are big.
 566  */
 567 static cputime_t scale_stime(u64 stime, u64 rtime, u64 total)
 568 {
 569         u64 scaled;
 570
 571         for (;;) {
 572                 /* Make sure "rtime" is the bigger of stime/rtime */
 573                 if (stime > rtime)
 574                         swap(rtime, stime);
 575
 576                 /* Make sure 'total' fits in 32 bits */
 577                 if (total >> 32)
 578                         goto drop_precision;
 579
 580                 /* Does rtime (and thus stime) fit in 32 bits? */
 581                 if (!(rtime >> 32))
 582                         break;
 583
 584                 /* Can we just balance rtime/stime rather than dropping bits? */
 585                 if (stime >> 31)
 586                         goto drop_precision;
 587
 588                 /* We can grow stime and shrink rtime and try to make them both fit */
 589                 stime <<= 1;
 590                 rtime >>= 1;
 591                 continue;
 592
 593 drop_precision:
 594                 /* We drop from rtime, it has more bits than stime */
 595                 rtime >>= 1;
 596                 total >>= 1;
 597         }
 598
 599         /*
 600          * Make sure gcc understands that this is a 32x32->64 multiply,
 601          * followed by a 64/32->64 divide.
 602          */
 603         scaled = div_u64((u64) (u32) stime * (u64) (u32) rtime, (u32)total);
 604         return (__force cputime_t) scaled;
 605 }
 606
 607 /*
 608  * Adjust tick based cputime random precision against scheduler runtime
 609  * accounting.
 610  *
 611  * Tick based cputime accounting depend on random scheduling timeslices of a
 612  * task to be interrupted or not by the timer.  Depending on these
 613  * circumstances, the number of these interrupts may be over or
 614  * under-optimistic, matching the real user and system cputime with a variable
 615  * precision.
 616  *
 617  * Fix this by scaling these tick based values against the total runtime
 618  * accounted by the CFS scheduler.
 619  *
 620  * This code provides the following guarantees:
 621  *
 622  *   stime + utime == rtime
 623  *   stime_i+1 >= stime_i, utime_i+1 >= utime_i
 624  *
 625  * Assuming that rtime_i+1 >= rtime_i.
 626  */
 627 static void cputime_adjust(struct task_cputime *curr,
 628                            struct prev_cputime *prev,
 629                            cputime_t *ut, cputime_t *st)
 630 {
 631         cputime_t rtime, stime, utime;
 632         unsigned long flags;
 633
 634         /* Serialize concurrent callers such that we can honour our guarantees */
 635         raw_spin_lock_irqsave(&prev->lock, flags);
 636         rtime = nsecs_to_cputime(curr->sum_exec_runtime);
 637
 638         /*
 639          * This is possible under two circumstances:
 640          *  - rtime isn't monotonic after all (a bug);
 641          *  - we got reordered by the lock.
 642          *
 643          * In both cases this acts as a filter such that the rest of the code
 644          * can assume it is monotonic regardless of anything else.
 645          */
 646         if (prev->stime + prev->utime >= rtime)
 647                 goto out;
 648
 649         stime = curr->stime;
 650         utime = curr->utime;
 651
 652         /*
 653          * If either stime or both stime and utime are 0, assume all runtime is
 654          * userspace. Once a task gets some ticks, the monotonicy code at
 655          * 'update' will ensure things converge to the observed ratio.
 656          */
 657         if (stime == 0) {
 658                 utime = rtime;
 659                 goto update;
 660         }
 661
 662         if (utime == 0) {
 663                 stime = rtime;
 664                 goto update;
 665         }
 666
 667         stime = scale_stime((__force u64)stime, (__force u64)rtime,
 668                             (__force u64)(stime + utime));
 669
 670 update:
 671         /*
 672          * Make sure stime doesn't go backwards; this preserves monotonicity
 673          * for utime because rtime is monotonic.
 674          *
 675          *  utime_i+1 = rtime_i+1 - stime_i
 676          *            = rtime_i+1 - (rtime_i - utime_i)
 677          *            = (rtime_i+1 - rtime_i) + utime_i
 678          *            >= utime_i
 679          */
 680         if (stime < prev->stime)
 681                 stime = prev->stime;
 682         utime = rtime - stime;
 683
 684         /*
 685          * Make sure utime doesn't go backwards; this still preserves
 686          * monotonicity for stime, analogous argument to above.
 687          */
 688         if (utime < prev->utime) {
 689                 utime = prev->utime;
 690                 stime = rtime - utime;
 691         }
 692
 693         prev->stime = stime;
 694         prev->utime = utime;
 695 out:
 696         *ut = prev->utime;
 697         *st = prev->stime;
 698         raw_spin_unlock_irqrestore(&prev->lock, flags);
 699 }
 700
 701 void task_cputime_adjusted(struct task_struct *p, cputime_t *ut, cputime_t *st)
 702 {
 703         struct task_cputime cputime = {
 704                 .sum_exec_runtime = p->se.sum_exec_runtime,
 705         };
 706
 707         task_cputime(p, &cputime.utime, &cputime.stime);
 708         cputime_adjust(&cputime, &p->prev_cputime, ut, st);
 709 }
 710 EXPORT_SYMBOL_GPL(task_cputime_adjusted);
 711
 712 void thread_group_cputime_adjusted(struct task_struct *p, cputime_t *ut, cputime_t *st)
 713 {
 714         struct task_cputime cputime;
 715
 716         thread_group_cputime(p, &cputime);
 717         cputime_adjust(&cputime, &p->signal->prev_cputime, ut, st);
 718 }
 719 #endif /* !CONFIG_VIRT_CPU_ACCOUNTING_NATIVE */
 720
 721 #ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
 722 static cputime_t vtime_delta(struct task_struct *tsk)
 723 {
 724         unsigned long now = READ_ONCE(jiffies);
 725
 726         if (time_before(now, (unsigned long)tsk->vtime_snap))
 727                 return 0;
 728
 729         return jiffies_to_cputime(now - tsk->vtime_snap);
 730 }
 731
 732 static cputime_t get_vtime_delta(struct task_struct *tsk)
 733 {
 734         unsigned long now = READ_ONCE(jiffies);
 735         cputime_t delta, other;
 736
 737         /*
 738          * Unlike tick based timing, vtime based timing never has lost
 739          * ticks, and no need for steal time accounting to make up for
 740          * lost ticks. Vtime accounts a rounded version of actual
 741          * elapsed time. Limit account_other_time to prevent rounding
 742          * errors from causing elapsed vtime to go negative.
 743          */
 744         delta = jiffies_to_cputime(now - tsk->vtime_snap);
 745         other = account_other_time(delta);
 746         WARN_ON_ONCE(tsk->vtime_snap_whence == VTIME_INACTIVE);
 747         tsk->vtime_snap = now;
 748
 749         return delta - other;
 750 }
 751
 752 static void __vtime_account_system(struct task_struct *tsk)
 753 {
 754         cputime_t delta_cpu = get_vtime_delta(tsk);
 755
 756         account_system_time(tsk, irq_count(), delta_cpu, cputime_to_scaled(delta_cpu));
 757 }
 758
 759 void vtime_account_system(struct task_struct *tsk)
 760 {
 761         if (!vtime_delta(tsk))
 762                 return;
 763
 764         write_seqcount_begin(&tsk->vtime_seqcount);
 765         __vtime_account_system(tsk);
 766         write_seqcount_end(&tsk->vtime_seqcount);
 767 }
 768
 769 void vtime_account_user(struct task_struct *tsk)
 770 {
 771         cputime_t delta_cpu;
 772
 773         write_seqcount_begin(&tsk->vtime_seqcount);
 774         tsk->vtime_snap_whence = VTIME_SYS;
 775         if (vtime_delta(tsk)) {
 776                 delta_cpu = get_vtime_delta(tsk);
 777                 account_user_time(tsk, delta_cpu, cputime_to_scaled(delta_cpu));
 778         }
 779         write_seqcount_end(&tsk->vtime_seqcount);
 780 }
 781
 782 void vtime_user_enter(struct task_struct *tsk)
 783 {
 784         write_seqcount_begin(&tsk->vtime_seqcount);
 785         if (vtime_delta(tsk))
 786                 __vtime_account_system(tsk);
 787         tsk->vtime_snap_whence = VTIME_USER;
 788         write_seqcount_end(&tsk->vtime_seqcount);
 789 }
 790
 791 void vtime_guest_enter(struct task_struct *tsk)
 792 {
 793         /*
 794          * The flags must be updated under the lock with
 795          * the vtime_snap flush and update.
 796          * That enforces a right ordering and update sequence
 797          * synchronization against the reader (task_gtime())
 798          * that can thus safely catch up with a tickless delta.
 799          */
 800         write_seqcount_begin(&tsk->vtime_seqcount);
 801         if (vtime_delta(tsk))
 802                 __vtime_account_system(tsk);
 803         current->flags |= PF_VCPU;
 804         write_seqcount_end(&tsk->vtime_seqcount);
 805 }
 806 EXPORT_SYMBOL_GPL(vtime_guest_enter);
 807
 808 void vtime_guest_exit(struct task_struct *tsk)
 809 {
 810         write_seqcount_begin(&tsk->vtime_seqcount);
 811         __vtime_account_system(tsk);
 812         current->flags &= ~PF_VCPU;
 813         write_seqcount_end(&tsk->vtime_seqcount);
 814 }
 815 EXPORT_SYMBOL_GPL(vtime_guest_exit);
 816
 817 void vtime_account_idle(struct task_struct *tsk)
 818 {
 819         cputime_t delta_cpu = get_vtime_delta(tsk);
 820
 821         account_idle_time(delta_cpu);
 822 }
 823
 824 void arch_vtime_task_switch(struct task_struct *prev)
 825 {
 826         write_seqcount_begin(&prev->vtime_seqcount);
 827         prev->vtime_snap_whence = VTIME_INACTIVE;
 828         write_seqcount_end(&prev->vtime_seqcount);
 829
 830         write_seqcount_begin(&current->vtime_seqcount);
 831         current->vtime_snap_whence = VTIME_SYS;
 832         current->vtime_snap = jiffies;
 833         write_seqcount_end(&current->vtime_seqcount);
 834 }
 835
 836 void vtime_init_idle(struct task_struct *t, int cpu)
 837 {
 838         unsigned long flags;
 839
 840         local_irq_save(flags);
 841         write_seqcount_begin(&t->vtime_seqcount);
 842         t->vtime_snap_whence = VTIME_SYS;
 843         t->vtime_snap = jiffies;
 844         write_seqcount_end(&t->vtime_seqcount);
 845         local_irq_restore(flags);
 846 }
 847
 848 cputime_t task_gtime(struct task_struct *t)
 849 {
 850         unsigned int seq;
 851         cputime_t gtime;
 852
 853         if (!vtime_accounting_enabled())
 854                 return t->gtime;
 855
 856         do {
 857                 seq = read_seqcount_begin(&t->vtime_seqcount);
 858
 859                 gtime = t->gtime;
 860                 if (t->vtime_snap_whence == VTIME_SYS && t->flags & PF_VCPU)
 861                         gtime += vtime_delta(t);
 862
 863         } while (read_seqcount_retry(&t->vtime_seqcount, seq));
 864
 865         return gtime;
 866 }
 867
 868 /*
 869  * Fetch cputime raw values from fields of task_struct and
 870  * add up the pending nohz execution time since the last
 871  * cputime snapshot.
 872  */
 873 static void
 874 fetch_task_cputime(struct task_struct *t,
 875                    cputime_t *u_dst, cputime_t *s_dst,
 876                    cputime_t *u_src, cputime_t *s_src,
 877                    cputime_t *udelta, cputime_t *sdelta)
 878 {
 879         unsigned int seq;
 880         unsigned long long delta;
 881
 882         do {
 883                 *udelta = 0;
 884                 *sdelta = 0;
 885
 886                 seq = read_seqcount_begin(&t->vtime_seqcount);
 887
 888                 if (u_dst)
 889                         *u_dst = *u_src;
 890                 if (s_dst)
 891                         *s_dst = *s_src;
 892
 893                 /* Task is sleeping, nothing to add */
 894                 if (t->vtime_snap_whence == VTIME_INACTIVE ||
 895                     is_idle_task(t))
 896                         continue;
 897
 898                 delta = vtime_delta(t);
 899
 900                 /*
 901                  * Task runs either in user or kernel space, add pending nohz time to
 902                  * the right place.
 903                  */
 904                 if (t->vtime_snap_whence == VTIME_USER || t->flags & PF_VCPU) {
 905                         *udelta = delta;
 906                 } else {
 907                         if (t->vtime_snap_whence == VTIME_SYS)
 908                                 *sdelta = delta;
 909                 }
 910         } while (read_seqcount_retry(&t->vtime_seqcount, seq));
 911 }
 912
 913
 914 void task_cputime(struct task_struct *t, cputime_t *utime, cputime_t *stime)
 915 {
 916         cputime_t udelta, sdelta;
 917
 918         if (!vtime_accounting_enabled()) {
 919                 if (utime)
 920                         *utime = t->utime;
 921                 if (stime)
 922                         *stime = t->stime;
 923                 return;
 924         }
 925
 926         fetch_task_cputime(t, utime, stime, &t->utime,
 927                            &t->stime, &udelta, &sdelta);
 928         if (utime)
 929                 *utime += udelta;
 930         if (stime)
 931                 *stime += sdelta;
 932 }
 933
 934 void task_cputime_scaled(struct task_struct *t,
 935                          cputime_t *utimescaled, cputime_t *stimescaled)
 936 {
 937         cputime_t udelta, sdelta;
 938
 939         if (!vtime_accounting_enabled()) {
 940                 if (utimescaled)
 941                         *utimescaled = t->utimescaled;
 942                 if (stimescaled)
 943                         *stimescaled = t->stimescaled;
 944                 return;
 945         }
 946
 947         fetch_task_cputime(t, utimescaled, stimescaled,
 948                            &t->utimescaled, &t->stimescaled, &udelta, &sdelta);
 949         if (utimescaled)
 950                 *utimescaled += cputime_to_scaled(udelta);
 951         if (stimescaled)
 952                 *stimescaled += cputime_to_scaled(sdelta);
 953 }
 954 #endif /* CONFIG_VIRT_CPU_ACCOUNTING_GEN */