mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
synced 2025-12-28 05:34:13 -05:00
658eb5ab91
Introduce the use cases of delay max, which can help quickly detect
potential abnormal delays in the system and record the types and specific
details of delay spikes.
Problem
========
Delay accounting can track the average delay of processes to show
system workload. However, when a process experiences a significant
delay, maybe a delay spike, which adversely affects performance,
getdelays can only display the average system delay over a period
of time. Yet, average delay is unhelpful for diagnosing delay peak.
It is not even possible to determine which type of delay has spiked,
as this information might be masked by the average delay.
Solution
=========
the 'delay max' can display delay peak since the system's startup,
which can record potential abnormal delays over time, including
the type of delay and the maximum delay. This is helpful for
quickly identifying crash caused by delay.
Use case
=========
bash# ./getdelays -d -p 244
print delayacct stats ON
PID 244
CPU count real total virtual total delay total delay average delay max
68 192000000 213676651 705643 0.010ms 0.306381ms
IO count delay total delay average delay max
0 0 0.000ms 0.000000ms
SWAP count delay total delay average delay max
0 0 0.000ms 0.000000ms
RECLAIM count delay total delay average delay max
0 0 0.000ms 0.000000ms
THRASHING count delay total delay average delay max
0 0 0.000ms 0.000000ms
COMPACT count delay total delay average delay max
0 0 0.000ms 0.000000ms
WPCOPY count delay total delay average delay max
235 15648284 0.067ms 0.263842ms
IRQ count delay total delay average delay max
0 0 0.000ms 0.000000ms
[wang.yaxin@zte.com.cn: update docs and fix some spelling errors]
Link: https://lkml.kernel.org/r/20241213192700771XKZ8H30OtHSeziGqRVMs0@zte.com.cn
Link: https://lkml.kernel.org/r/20241203164848805CS62CQPQWG9GLdQj2_BxS@zte.com.cn
Co-developed-by: Wang Yong <wang.yong12@zte.com.cn>
Signed-off-by: Wang Yong <wang.yong12@zte.com.cn>
Co-developed-by: xu xin <xu.xin16@zte.com.cn>
Signed-off-by: xu xin <xu.xin16@zte.com.cn>
Co-developed-by: Wang Yaxin <wang.yaxin@zte.com.cn>
Signed-off-by: Wang Yaxin <wang.yaxin@zte.com.cn>
Signed-off-by: Kun Jiang <jiang.kun2@zte.com.cn>
Cc: Balbir Singh <bsingharora@gmail.com>
Cc: David Hildenbrand <david@redhat.com>
Cc: Fan Yu <fan.yu9@zte.com.cn>
Cc: Peilin He <he.peilin@zte.com.cn>
Cc: tuqiang <tu.qiang35@zte.com.cn>
Cc: Yang Yang <yang.yang29@zte.com.cn>
Cc: ye xingchen <ye.xingchen@zte.com.cn>
Cc: Yunkai Zhang <zhang.yunkai@zte.com.cn>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
307 lines
8.2 KiB
C
307 lines
8.2 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/* delayacct.c - per-task delay accounting
|
|
*
|
|
* Copyright (C) Shailabh Nagar, IBM Corp. 2006
|
|
*/
|
|
|
|
#include <linux/sched.h>
|
|
#include <linux/sched/task.h>
|
|
#include <linux/sched/cputime.h>
|
|
#include <linux/sched/clock.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/taskstats.h>
|
|
#include <linux/sysctl.h>
|
|
#include <linux/delayacct.h>
|
|
#include <linux/module.h>
|
|
|
|
DEFINE_STATIC_KEY_FALSE(delayacct_key);
|
|
int delayacct_on __read_mostly; /* Delay accounting turned on/off */
|
|
struct kmem_cache *delayacct_cache;
|
|
|
|
static void set_delayacct(bool enabled)
|
|
{
|
|
if (enabled) {
|
|
static_branch_enable(&delayacct_key);
|
|
delayacct_on = 1;
|
|
} else {
|
|
delayacct_on = 0;
|
|
static_branch_disable(&delayacct_key);
|
|
}
|
|
}
|
|
|
|
static int __init delayacct_setup_enable(char *str)
|
|
{
|
|
delayacct_on = 1;
|
|
return 1;
|
|
}
|
|
__setup("delayacct", delayacct_setup_enable);
|
|
|
|
void delayacct_init(void)
|
|
{
|
|
delayacct_cache = KMEM_CACHE(task_delay_info, SLAB_PANIC|SLAB_ACCOUNT);
|
|
delayacct_tsk_init(&init_task);
|
|
set_delayacct(delayacct_on);
|
|
}
|
|
|
|
#ifdef CONFIG_PROC_SYSCTL
|
|
static int sysctl_delayacct(const struct ctl_table *table, int write, void *buffer,
|
|
size_t *lenp, loff_t *ppos)
|
|
{
|
|
int state = delayacct_on;
|
|
struct ctl_table t;
|
|
int err;
|
|
|
|
if (write && !capable(CAP_SYS_ADMIN))
|
|
return -EPERM;
|
|
|
|
t = *table;
|
|
t.data = &state;
|
|
err = proc_dointvec_minmax(&t, write, buffer, lenp, ppos);
|
|
if (err < 0)
|
|
return err;
|
|
if (write)
|
|
set_delayacct(state);
|
|
return err;
|
|
}
|
|
|
|
static struct ctl_table kern_delayacct_table[] = {
|
|
{
|
|
.procname = "task_delayacct",
|
|
.data = NULL,
|
|
.maxlen = sizeof(unsigned int),
|
|
.mode = 0644,
|
|
.proc_handler = sysctl_delayacct,
|
|
.extra1 = SYSCTL_ZERO,
|
|
.extra2 = SYSCTL_ONE,
|
|
},
|
|
};
|
|
|
|
static __init int kernel_delayacct_sysctls_init(void)
|
|
{
|
|
register_sysctl_init("kernel", kern_delayacct_table);
|
|
return 0;
|
|
}
|
|
late_initcall(kernel_delayacct_sysctls_init);
|
|
#endif
|
|
|
|
void __delayacct_tsk_init(struct task_struct *tsk)
|
|
{
|
|
tsk->delays = kmem_cache_zalloc(delayacct_cache, GFP_KERNEL);
|
|
if (tsk->delays)
|
|
raw_spin_lock_init(&tsk->delays->lock);
|
|
}
|
|
|
|
/*
|
|
* Finish delay accounting for a statistic using its timestamps (@start),
|
|
* accumulator (@total) and @count
|
|
*/
|
|
static void delayacct_end(raw_spinlock_t *lock, u64 *start, u64 *total, u32 *count, u64 *max)
|
|
{
|
|
s64 ns = local_clock() - *start;
|
|
unsigned long flags;
|
|
|
|
if (ns > 0) {
|
|
raw_spin_lock_irqsave(lock, flags);
|
|
*total += ns;
|
|
(*count)++;
|
|
if (ns > *max)
|
|
*max = ns;
|
|
raw_spin_unlock_irqrestore(lock, flags);
|
|
}
|
|
}
|
|
|
|
void __delayacct_blkio_start(void)
|
|
{
|
|
current->delays->blkio_start = local_clock();
|
|
}
|
|
|
|
/*
|
|
* We cannot rely on the `current` macro, as we haven't yet switched back to
|
|
* the process being woken.
|
|
*/
|
|
void __delayacct_blkio_end(struct task_struct *p)
|
|
{
|
|
delayacct_end(&p->delays->lock,
|
|
&p->delays->blkio_start,
|
|
&p->delays->blkio_delay,
|
|
&p->delays->blkio_count,
|
|
&p->delays->blkio_delay_max);
|
|
}
|
|
|
|
int delayacct_add_tsk(struct taskstats *d, struct task_struct *tsk)
|
|
{
|
|
u64 utime, stime, stimescaled, utimescaled;
|
|
unsigned long long t2, t3;
|
|
unsigned long flags, t1;
|
|
s64 tmp;
|
|
|
|
task_cputime(tsk, &utime, &stime);
|
|
tmp = (s64)d->cpu_run_real_total;
|
|
tmp += utime + stime;
|
|
d->cpu_run_real_total = (tmp < (s64)d->cpu_run_real_total) ? 0 : tmp;
|
|
|
|
task_cputime_scaled(tsk, &utimescaled, &stimescaled);
|
|
tmp = (s64)d->cpu_scaled_run_real_total;
|
|
tmp += utimescaled + stimescaled;
|
|
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;
|
|
|
|
d->cpu_delay_max = tsk->sched_info.max_run_delay;
|
|
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;
|
|
|
|
if (!tsk->delays)
|
|
return 0;
|
|
|
|
/* zero XXX_total, non-zero XXX_count implies XXX stat overflowed */
|
|
raw_spin_lock_irqsave(&tsk->delays->lock, flags);
|
|
d->blkio_delay_max = tsk->delays->blkio_delay_max;
|
|
tmp = d->blkio_delay_total + tsk->delays->blkio_delay;
|
|
d->blkio_delay_total = (tmp < d->blkio_delay_total) ? 0 : tmp;
|
|
d->swapin_delay_max = tsk->delays->swapin_delay_max;
|
|
tmp = d->swapin_delay_total + tsk->delays->swapin_delay;
|
|
d->swapin_delay_total = (tmp < d->swapin_delay_total) ? 0 : tmp;
|
|
d->freepages_delay_max = tsk->delays->freepages_delay_max;
|
|
tmp = d->freepages_delay_total + tsk->delays->freepages_delay;
|
|
d->freepages_delay_total = (tmp < d->freepages_delay_total) ? 0 : tmp;
|
|
d->thrashing_delay_max = tsk->delays->thrashing_delay_max;
|
|
tmp = d->thrashing_delay_total + tsk->delays->thrashing_delay;
|
|
d->thrashing_delay_total = (tmp < d->thrashing_delay_total) ? 0 : tmp;
|
|
d->compact_delay_max = tsk->delays->compact_delay_max;
|
|
tmp = d->compact_delay_total + tsk->delays->compact_delay;
|
|
d->compact_delay_total = (tmp < d->compact_delay_total) ? 0 : tmp;
|
|
d->wpcopy_delay_max = tsk->delays->wpcopy_delay_max;
|
|
tmp = d->wpcopy_delay_total + tsk->delays->wpcopy_delay;
|
|
d->wpcopy_delay_total = (tmp < d->wpcopy_delay_total) ? 0 : tmp;
|
|
d->irq_delay_max = tsk->delays->irq_delay_max;
|
|
tmp = d->irq_delay_total + tsk->delays->irq_delay;
|
|
d->irq_delay_total = (tmp < d->irq_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;
|
|
d->thrashing_count += tsk->delays->thrashing_count;
|
|
d->compact_count += tsk->delays->compact_count;
|
|
d->wpcopy_count += tsk->delays->wpcopy_count;
|
|
d->irq_count += tsk->delays->irq_count;
|
|
raw_spin_unlock_irqrestore(&tsk->delays->lock, flags);
|
|
|
|
return 0;
|
|
}
|
|
|
|
__u64 __delayacct_blkio_ticks(struct task_struct *tsk)
|
|
{
|
|
__u64 ret;
|
|
unsigned long flags;
|
|
|
|
raw_spin_lock_irqsave(&tsk->delays->lock, flags);
|
|
ret = nsec_to_clock_t(tsk->delays->blkio_delay);
|
|
raw_spin_unlock_irqrestore(&tsk->delays->lock, flags);
|
|
return ret;
|
|
}
|
|
|
|
void __delayacct_freepages_start(void)
|
|
{
|
|
current->delays->freepages_start = local_clock();
|
|
}
|
|
|
|
void __delayacct_freepages_end(void)
|
|
{
|
|
delayacct_end(¤t->delays->lock,
|
|
¤t->delays->freepages_start,
|
|
¤t->delays->freepages_delay,
|
|
¤t->delays->freepages_count,
|
|
¤t->delays->freepages_delay_max);
|
|
}
|
|
|
|
void __delayacct_thrashing_start(bool *in_thrashing)
|
|
{
|
|
*in_thrashing = !!current->in_thrashing;
|
|
if (*in_thrashing)
|
|
return;
|
|
|
|
current->in_thrashing = 1;
|
|
current->delays->thrashing_start = local_clock();
|
|
}
|
|
|
|
void __delayacct_thrashing_end(bool *in_thrashing)
|
|
{
|
|
if (*in_thrashing)
|
|
return;
|
|
|
|
current->in_thrashing = 0;
|
|
delayacct_end(¤t->delays->lock,
|
|
¤t->delays->thrashing_start,
|
|
¤t->delays->thrashing_delay,
|
|
¤t->delays->thrashing_count,
|
|
¤t->delays->thrashing_delay_max);
|
|
}
|
|
|
|
void __delayacct_swapin_start(void)
|
|
{
|
|
current->delays->swapin_start = local_clock();
|
|
}
|
|
|
|
void __delayacct_swapin_end(void)
|
|
{
|
|
delayacct_end(¤t->delays->lock,
|
|
¤t->delays->swapin_start,
|
|
¤t->delays->swapin_delay,
|
|
¤t->delays->swapin_count,
|
|
¤t->delays->swapin_delay_max);
|
|
}
|
|
|
|
void __delayacct_compact_start(void)
|
|
{
|
|
current->delays->compact_start = local_clock();
|
|
}
|
|
|
|
void __delayacct_compact_end(void)
|
|
{
|
|
delayacct_end(¤t->delays->lock,
|
|
¤t->delays->compact_start,
|
|
¤t->delays->compact_delay,
|
|
¤t->delays->compact_count,
|
|
¤t->delays->compact_delay_max);
|
|
}
|
|
|
|
void __delayacct_wpcopy_start(void)
|
|
{
|
|
current->delays->wpcopy_start = local_clock();
|
|
}
|
|
|
|
void __delayacct_wpcopy_end(void)
|
|
{
|
|
delayacct_end(¤t->delays->lock,
|
|
¤t->delays->wpcopy_start,
|
|
¤t->delays->wpcopy_delay,
|
|
¤t->delays->wpcopy_count,
|
|
¤t->delays->wpcopy_delay_max);
|
|
}
|
|
|
|
void __delayacct_irq(struct task_struct *task, u32 delta)
|
|
{
|
|
unsigned long flags;
|
|
|
|
raw_spin_lock_irqsave(&task->delays->lock, flags);
|
|
task->delays->irq_delay += delta;
|
|
task->delays->irq_count++;
|
|
if (delta > task->delays->irq_delay_max)
|
|
task->delays->irq_delay_max = delta;
|
|
raw_spin_unlock_irqrestore(&task->delays->lock, flags);
|
|
}
|
|
|