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