delayacct.c 4.95 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
/* 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>
18
#include <linux/taskstats.h>
19 20 21 22
#include <linux/time.h>
#include <linux/sysctl.h>
#include <linux/delayacct.h>

23
int delayacct_on __read_mostly = 1;	/* Delay accounting turned on/off */
24
struct kmem_cache *delayacct_cache;
25

26
static int __init delayacct_setup_disable(char *str)
27
{
28
	delayacct_on = 0;
29 30
	return 1;
}
31
__setup("nodelayacct", delayacct_setup_disable);
32 33 34

void delayacct_init(void)
{
35
	delayacct_cache = KMEM_CACHE(task_delay_info, SLAB_PANIC);
36 37 38 39 40
	delayacct_tsk_init(&init_task);
}

void __delayacct_tsk_init(struct task_struct *tsk)
{
41
	tsk->delays = kmem_cache_zalloc(delayacct_cache, GFP_KERNEL);
42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65
	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;
66
	unsigned long flags;
67 68 69 70 71 72 73

	do_posix_clock_monotonic_gettime(end);
	ts = timespec_sub(*end, *start);
	ns = timespec_to_ns(&ts);
	if (ns < 0)
		return;

74
	spin_lock_irqsave(&current->delays->lock, flags);
75 76
	*total += ns;
	(*count)++;
77
	spin_unlock_irqrestore(&current->delays->lock, flags);
78 79
}

80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
void __delayacct_blkio_start(void)
{
	delayacct_start(&current->delays->blkio_start);
}

void __delayacct_blkio_end(void)
{
	if (current->delays->flags & DELAYACCT_PF_SWAPIN)
		/* Swapin block I/O */
		delayacct_end(&current->delays->blkio_start,
			&current->delays->blkio_end,
			&current->delays->swapin_delay,
			&current->delays->swapin_count);
	else	/* Other block I/O */
		delayacct_end(&current->delays->blkio_start,
			&current->delays->blkio_end,
			&current->delays->blkio_delay,
			&current->delays->blkio_count);
}
99 100 101 102

int __delayacct_add_tsk(struct taskstats *d, struct task_struct *tsk)
{
	s64 tmp;
103 104
	unsigned long t1;
	unsigned long long t2, t3;
105
	unsigned long flags;
106
	struct timespec ts;
107 108 109 110 111 112 113 114 115 116 117 118

	/* 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;

119 120 121 122 123 124
	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;

125 126 127 128
	/*
	 * No locking available for sched_info (and too expensive to add one)
	 * Mitigate by taking snapshot of values
	 */
129
	t1 = tsk->sched_info.pcount;
130
	t2 = tsk->sched_info.run_delay;
131
	t3 = tsk->se.sum_exec_runtime;
132 133 134

	d->cpu_count += t1;

135
	tmp = (s64)d->cpu_delay_total + t2;
136 137
	d->cpu_delay_total = (tmp < (s64)d->cpu_delay_total) ? 0 : tmp;

138
	tmp = (s64)d->cpu_run_virtual_total + t3;
139 140 141 142 143
	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 */

144
	spin_lock_irqsave(&tsk->delays->lock, flags);
145 146 147 148
	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;
149 150
	tmp = d->freepages_delay_total + tsk->delays->freepages_delay;
	d->freepages_delay_total = (tmp < d->freepages_delay_total) ? 0 : tmp;
151 152
	d->blkio_count += tsk->delays->blkio_count;
	d->swapin_count += tsk->delays->swapin_count;
153
	d->freepages_count += tsk->delays->freepages_count;
154
	spin_unlock_irqrestore(&tsk->delays->lock, flags);
155 156 157 158

done:
	return 0;
}
159 160 161 162

__u64 __delayacct_blkio_ticks(struct task_struct *tsk)
{
	__u64 ret;
163
	unsigned long flags;
164

165
	spin_lock_irqsave(&tsk->delays->lock, flags);
166 167
	ret = nsec_to_clock_t(tsk->delays->blkio_delay +
				tsk->delays->swapin_delay);
168
	spin_unlock_irqrestore(&tsk->delays->lock, flags);
169 170 171
	return ret;
}

172 173 174 175 176 177 178 179 180 181 182 183 184
void __delayacct_freepages_start(void)
{
	delayacct_start(&current->delays->freepages_start);
}

void __delayacct_freepages_end(void)
{
	delayacct_end(&current->delays->freepages_start,
			&current->delays->freepages_end,
			&current->delays->freepages_delay,
			&current->delays->freepages_count);
}