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