mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-29 20:30:35 +00:00
![Glauber Costa](/assets/img/avatar_default.png)
To implement steal time, we need the hypervisor to pass the guest information about how much time was spent running other processes outside the VM, while the vcpu had meaningful work to do - halt time does not count. This information is acquired through the run_delay field of delayacct/schedstats infrastructure, that counts time spent in a runqueue but not running. Steal time is a per-cpu information, so the traditional MSR-based infrastructure is used. A new msr, KVM_MSR_STEAL_TIME, holds the memory area address containing information about steal time This patch contains the hypervisor part of the steal time infrasructure, and can be backported independently of the guest portion. [avi, yongjie: export delayacct_on, to avoid build failures in some configs] Signed-off-by: Glauber Costa <glommer@redhat.com> Tested-by: Eric B Munson <emunson@mgebm.net> CC: Rik van Riel <riel@redhat.com> CC: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com> CC: Peter Zijlstra <peterz@infradead.org> CC: Anthony Liguori <aliguori@us.ibm.com> Signed-off-by: Yongjie Ren <yongjie.ren@intel.com> Signed-off-by: Avi Kivity <avi@redhat.com>
186 lines
5 KiB
C
186 lines
5 KiB
C
/* delayacct.c - per-task delay accounting
|
|
*
|
|
* Copyright (C) Shailabh Nagar, IBM Corp. 2006
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it would be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
|
|
* the GNU General Public License for more details.
|
|
*/
|
|
|
|
#include <linux/sched.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/taskstats.h>
|
|
#include <linux/time.h>
|
|
#include <linux/sysctl.h>
|
|
#include <linux/delayacct.h>
|
|
#include <linux/module.h>
|
|
|
|
int delayacct_on __read_mostly = 1; /* Delay accounting turned on/off */
|
|
EXPORT_SYMBOL_GPL(delayacct_on);
|
|
struct kmem_cache *delayacct_cache;
|
|
|
|
static int __init delayacct_setup_disable(char *str)
|
|
{
|
|
delayacct_on = 0;
|
|
return 1;
|
|
}
|
|
__setup("nodelayacct", delayacct_setup_disable);
|
|
|
|
void delayacct_init(void)
|
|
{
|
|
delayacct_cache = KMEM_CACHE(task_delay_info, SLAB_PANIC);
|
|
delayacct_tsk_init(&init_task);
|
|
}
|
|
|
|
void __delayacct_tsk_init(struct task_struct *tsk)
|
|
{
|
|
tsk->delays = kmem_cache_zalloc(delayacct_cache, GFP_KERNEL);
|
|
if (tsk->delays)
|
|
spin_lock_init(&tsk->delays->lock);
|
|
}
|
|
|
|
/*
|
|
* Start accounting for a delay statistic using
|
|
* its starting timestamp (@start)
|
|
*/
|
|
|
|
static inline void delayacct_start(struct timespec *start)
|
|
{
|
|
do_posix_clock_monotonic_gettime(start);
|
|
}
|
|
|
|
/*
|
|
* Finish delay accounting for a statistic using
|
|
* its timestamps (@start, @end), accumalator (@total) and @count
|
|
*/
|
|
|
|
static void delayacct_end(struct timespec *start, struct timespec *end,
|
|
u64 *total, u32 *count)
|
|
{
|
|
struct timespec ts;
|
|
s64 ns;
|
|
unsigned long flags;
|
|
|
|
do_posix_clock_monotonic_gettime(end);
|
|
ts = timespec_sub(*end, *start);
|
|
ns = timespec_to_ns(&ts);
|
|
if (ns < 0)
|
|
return;
|
|
|
|
spin_lock_irqsave(¤t->delays->lock, flags);
|
|
*total += ns;
|
|
(*count)++;
|
|
spin_unlock_irqrestore(¤t->delays->lock, flags);
|
|
}
|
|
|
|
void __delayacct_blkio_start(void)
|
|
{
|
|
delayacct_start(¤t->delays->blkio_start);
|
|
}
|
|
|
|
void __delayacct_blkio_end(void)
|
|
{
|
|
if (current->delays->flags & DELAYACCT_PF_SWAPIN)
|
|
/* Swapin block I/O */
|
|
delayacct_end(¤t->delays->blkio_start,
|
|
¤t->delays->blkio_end,
|
|
¤t->delays->swapin_delay,
|
|
¤t->delays->swapin_count);
|
|
else /* Other block I/O */
|
|
delayacct_end(¤t->delays->blkio_start,
|
|
¤t->delays->blkio_end,
|
|
¤t->delays->blkio_delay,
|
|
¤t->delays->blkio_count);
|
|
}
|
|
|
|
int __delayacct_add_tsk(struct taskstats *d, struct task_struct *tsk)
|
|
{
|
|
s64 tmp;
|
|
unsigned long t1;
|
|
unsigned long long t2, t3;
|
|
unsigned long flags;
|
|
struct timespec ts;
|
|
|
|
/* Though tsk->delays accessed later, early exit avoids
|
|
* unnecessary returning of other data
|
|
*/
|
|
if (!tsk->delays)
|
|
goto done;
|
|
|
|
tmp = (s64)d->cpu_run_real_total;
|
|
cputime_to_timespec(tsk->utime + tsk->stime, &ts);
|
|
tmp += timespec_to_ns(&ts);
|
|
d->cpu_run_real_total = (tmp < (s64)d->cpu_run_real_total) ? 0 : tmp;
|
|
|
|
tmp = (s64)d->cpu_scaled_run_real_total;
|
|
cputime_to_timespec(tsk->utimescaled + tsk->stimescaled, &ts);
|
|
tmp += timespec_to_ns(&ts);
|
|
d->cpu_scaled_run_real_total =
|
|
(tmp < (s64)d->cpu_scaled_run_real_total) ? 0 : tmp;
|
|
|
|
/*
|
|
* No locking available for sched_info (and too expensive to add one)
|
|
* Mitigate by taking snapshot of values
|
|
*/
|
|
t1 = tsk->sched_info.pcount;
|
|
t2 = tsk->sched_info.run_delay;
|
|
t3 = tsk->se.sum_exec_runtime;
|
|
|
|
d->cpu_count += t1;
|
|
|
|
tmp = (s64)d->cpu_delay_total + t2;
|
|
d->cpu_delay_total = (tmp < (s64)d->cpu_delay_total) ? 0 : tmp;
|
|
|
|
tmp = (s64)d->cpu_run_virtual_total + t3;
|
|
d->cpu_run_virtual_total =
|
|
(tmp < (s64)d->cpu_run_virtual_total) ? 0 : tmp;
|
|
|
|
/* zero XXX_total, non-zero XXX_count implies XXX stat overflowed */
|
|
|
|
spin_lock_irqsave(&tsk->delays->lock, flags);
|
|
tmp = d->blkio_delay_total + tsk->delays->blkio_delay;
|
|
d->blkio_delay_total = (tmp < d->blkio_delay_total) ? 0 : tmp;
|
|
tmp = d->swapin_delay_total + tsk->delays->swapin_delay;
|
|
d->swapin_delay_total = (tmp < d->swapin_delay_total) ? 0 : tmp;
|
|
tmp = d->freepages_delay_total + tsk->delays->freepages_delay;
|
|
d->freepages_delay_total = (tmp < d->freepages_delay_total) ? 0 : tmp;
|
|
d->blkio_count += tsk->delays->blkio_count;
|
|
d->swapin_count += tsk->delays->swapin_count;
|
|
d->freepages_count += tsk->delays->freepages_count;
|
|
spin_unlock_irqrestore(&tsk->delays->lock, flags);
|
|
|
|
done:
|
|
return 0;
|
|
}
|
|
|
|
__u64 __delayacct_blkio_ticks(struct task_struct *tsk)
|
|
{
|
|
__u64 ret;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&tsk->delays->lock, flags);
|
|
ret = nsec_to_clock_t(tsk->delays->blkio_delay +
|
|
tsk->delays->swapin_delay);
|
|
spin_unlock_irqrestore(&tsk->delays->lock, flags);
|
|
return ret;
|
|
}
|
|
|
|
void __delayacct_freepages_start(void)
|
|
{
|
|
delayacct_start(¤t->delays->freepages_start);
|
|
}
|
|
|
|
void __delayacct_freepages_end(void)
|
|
{
|
|
delayacct_end(¤t->delays->freepages_start,
|
|
¤t->delays->freepages_end,
|
|
¤t->delays->freepages_delay,
|
|
¤t->delays->freepages_count);
|
|
}
|
|
|