[linux-2.6-block.git] / kernel / slow-work-debugfs.c

/* Slow work debugging
 *
 * Copyright (C) 2009 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public Licence
 * as published by the Free Software Foundation; either version
 * 2 of the Licence, or (at your option) any later version.
 */

#include <linux/module.h>
#include <linux/slow-work.h>
#include <linux/fs.h>
#include <linux/time.h>
#include <linux/seq_file.h>
#include "slow-work.h"

#define ITERATOR_SHIFT		(BITS_PER_LONG - 4)
#define ITERATOR_SELECTOR	(0xfUL << ITERATOR_SHIFT)
#define ITERATOR_COUNTER	(~ITERATOR_SELECTOR)

void slow_work_new_thread_desc(struct slow_work *work, struct seq_file *m)
{
	seq_puts(m, "Slow-work: New thread");
}

/*
 * Render the time mark field on a work item into a 5-char time with units plus
 * a space
 */
static void slow_work_print_mark(struct seq_file *m, struct slow_work *work)
{
	struct timespec now, diff;

	now = CURRENT_TIME;
	diff = timespec_sub(now, work->mark);

	if (diff.tv_sec < 0)
		seq_puts(m, "  -ve ");
	else if (diff.tv_sec == 0 && diff.tv_nsec < 1000)
		seq_printf(m, "%3luns ", diff.tv_nsec);
	else if (diff.tv_sec == 0 && diff.tv_nsec < 1000000)
		seq_printf(m, "%3luus ", diff.tv_nsec / 1000);
	else if (diff.tv_sec == 0 && diff.tv_nsec < 1000000000)
		seq_printf(m, "%3lums ", diff.tv_nsec / 1000000);
	else if (diff.tv_sec <= 1)
		seq_puts(m, "   1s ");
	else if (diff.tv_sec < 60)
		seq_printf(m, "%4lus ", diff.tv_sec);
	else if (diff.tv_sec < 60 * 60)
		seq_printf(m, "%4lum ", diff.tv_sec / 60);
	else if (diff.tv_sec < 60 * 60 * 24)
		seq_printf(m, "%4luh ", diff.tv_sec / 3600);
	else
		seq_puts(m, "exces ");
}

/*
 * Describe a slow work item for debugfs
 */
static int slow_work_runqueue_show(struct seq_file *m, void *v)
{
	struct slow_work *work;
	struct list_head *p = v;
	unsigned long id;

	switch ((unsigned long) v) {
	case 1:
		seq_puts(m, "THR PID   ITEM ADDR        FL MARK  DESC\n");
		return 0;
	case 2:
		seq_puts(m, "=== ===== ================ == ===== ==========\n");
		return 0;

	case 3 ... 3 + SLOW_WORK_THREAD_LIMIT - 1:
		id = (unsigned long) v - 3;

		read_lock(&slow_work_execs_lock);
		work = slow_work_execs[id];
		if (work) {
			smp_read_barrier_depends();

			seq_printf(m, "%3lu %5d %16p %2lx ",
				   id, slow_work_pids[id], work, work->flags);
			slow_work_print_mark(m, work);

			if (work->ops->desc)
				work->ops->desc(work, m);
			seq_putc(m, '\n');
		}
		read_unlock(&slow_work_execs_lock);
		return 0;

	default:
		work = list_entry(p, struct slow_work, link);
		seq_printf(m, "%3s     - %16p %2lx ",
			   work->flags & SLOW_WORK_VERY_SLOW ? "vsq" : "sq",
			   work, work->flags);
		slow_work_print_mark(m, work);

		if (work->ops->desc)
			work->ops->desc(work, m);
		seq_putc(m, '\n');
		return 0;
	}
}

/*
 * map the iterator to a work item
 */
static void *slow_work_runqueue_index(struct seq_file *m, loff_t *_pos)
{
	struct list_head *p;
	unsigned long count, id;

	switch (*_pos >> ITERATOR_SHIFT) {
	case 0x0:
		if (*_pos == 0)
			*_pos = 1;
		if (*_pos < 3)
			return (void *)(unsigned long) *_pos;
		if (*_pos < 3 + SLOW_WORK_THREAD_LIMIT)
			for (id = *_pos - 3;
			     id < SLOW_WORK_THREAD_LIMIT;
			     id++, (*_pos)++)
				if (slow_work_execs[id])
					return (void *)(unsigned long) *_pos;
		*_pos = 0x1UL << ITERATOR_SHIFT;

	case 0x1:
		count = *_pos & ITERATOR_COUNTER;
		list_for_each(p, &slow_work_queue) {
			if (count == 0)
				return p;
			count--;
		}
		*_pos = 0x2UL << ITERATOR_SHIFT;

	case 0x2:
		count = *_pos & ITERATOR_COUNTER;
		list_for_each(p, &vslow_work_queue) {
			if (count == 0)
				return p;
			count--;
		}
		*_pos = 0x3UL << ITERATOR_SHIFT;

	default:
		return NULL;
	}
}

/*
 * set up the iterator to start reading from the first line
 */
static void *slow_work_runqueue_start(struct seq_file *m, loff_t *_pos)
{
	spin_lock_irq(&slow_work_queue_lock);
	return slow_work_runqueue_index(m, _pos);
}

/*
 * move to the next line
 */
static void *slow_work_runqueue_next(struct seq_file *m, void *v, loff_t *_pos)
{
	struct list_head *p = v;
	unsigned long selector = *_pos >> ITERATOR_SHIFT;

	(*_pos)++;
	switch (selector) {
	case 0x0:
		return slow_work_runqueue_index(m, _pos);

	case 0x1:
		if (*_pos >> ITERATOR_SHIFT == 0x1) {
			p = p->next;
			if (p != &slow_work_queue)
				return p;
		}
		*_pos = 0x2UL << ITERATOR_SHIFT;
		p = &vslow_work_queue;

	case 0x2:
		if (*_pos >> ITERATOR_SHIFT == 0x2) {
			p = p->next;
			if (p != &vslow_work_queue)
				return p;
		}
		*_pos = 0x3UL << ITERATOR_SHIFT;

	default:
		return NULL;
	}
}

/*
 * clean up after reading
 */
static void slow_work_runqueue_stop(struct seq_file *m, void *v)
{
	spin_unlock_irq(&slow_work_queue_lock);
}

static const struct seq_operations slow_work_runqueue_ops = {
	.start		= slow_work_runqueue_start,
	.stop		= slow_work_runqueue_stop,
	.next		= slow_work_runqueue_next,
	.show		= slow_work_runqueue_show,
};

/*
 * open "/sys/kernel/debug/slow_work/runqueue" to list queue contents
 */
static int slow_work_runqueue_open(struct inode *inode, struct file *file)
{
	return seq_open(file, &slow_work_runqueue_ops);
}

const struct file_operations slow_work_runqueue_fops = {
	.owner		= THIS_MODULE,
	.open		= slow_work_runqueue_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= seq_release,
};
Commit	Line	Data
8fba10a4 DH	1	/* Slow work debugging
	2	*
	3	* Copyright (C) 2009 Red Hat, Inc. All Rights Reserved.
	4	* Written by David Howells (dhowells@redhat.com)
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public Licence
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the Licence, or (at your option) any later version.
	10	*/
	11
	12	#include <linux/module.h>
	13	#include <linux/slow-work.h>
	14	#include <linux/fs.h>
	15	#include <linux/time.h>
	16	#include <linux/seq_file.h>
	17	#include "slow-work.h"
	18
	19	#define ITERATOR_SHIFT (BITS_PER_LONG - 4)
	20	#define ITERATOR_SELECTOR (0xfUL << ITERATOR_SHIFT)
	21	#define ITERATOR_COUNTER (~ITERATOR_SELECTOR)
	22
	23	void slow_work_new_thread_desc(struct slow_work work, struct seq_file m)
	24	{
	25	seq_puts(m, "Slow-work: New thread");
	26	}
	27
	28	/*
	29	* Render the time mark field on a work item into a 5-char time with units plus
	30	* a space
	31	*/
	32	static void slow_work_print_mark(struct seq_file m, struct slow_work work)
	33	{
	34	struct timespec now, diff;
	35
	36	now = CURRENT_TIME;
	37	diff = timespec_sub(now, work->mark);
	38
	39	if (diff.tv_sec < 0)
	40	seq_puts(m, " -ve ");
	41	else if (diff.tv_sec == 0 && diff.tv_nsec < 1000)
	42	seq_printf(m, "%3luns ", diff.tv_nsec);
	43	else if (diff.tv_sec == 0 && diff.tv_nsec < 1000000)
	44	seq_printf(m, "%3luus ", diff.tv_nsec / 1000);
	45	else if (diff.tv_sec == 0 && diff.tv_nsec < 1000000000)
	46	seq_printf(m, "%3lums ", diff.tv_nsec / 1000000);
	47	else if (diff.tv_sec <= 1)
	48	seq_puts(m, " 1s ");
	49	else if (diff.tv_sec < 60)
	50	seq_printf(m, "%4lus ", diff.tv_sec);
	51	else if (diff.tv_sec < 60 * 60)
	52	seq_printf(m, "%4lum ", diff.tv_sec / 60);
	53	else if (diff.tv_sec < 60 * 60 * 24)
	54	seq_printf(m, "%4luh ", diff.tv_sec / 3600);
	55	else
	56	seq_puts(m, "exces ");
	57	}
	58
	59	/*
f13a48bd	60	* Describe a slow work item for debugfs
8fba10a4 DH	61	*/
	62	static int slow_work_runqueue_show(struct seq_file m, void v)
	63	{
	64	struct slow_work *work;
	65	struct list_head *p = v;
	66	unsigned long id;
	67
	68	switch ((unsigned long) v) {
	69	case 1:
	70	seq_puts(m, "THR PID ITEM ADDR FL MARK DESC\n");
	71	return 0;
	72	case 2:
	73	seq_puts(m, "=== ===== ================ == ===== ==========\n");
	74	return 0;
	75
	76	case 3 ... 3 + SLOW_WORK_THREAD_LIMIT - 1:
	77	id = (unsigned long) v - 3;
	78
	79	read_lock(&slow_work_execs_lock);
	80	work = slow_work_execs[id];
	81	if (work) {
	82	smp_read_barrier_depends();
	83
	84	seq_printf(m, "%3lu %5d %16p %2lx ",
	85	id, slow_work_pids[id], work, work->flags);
	86	slow_work_print_mark(m, work);
	87
	88	if (work->ops->desc)
	89	work->ops->desc(work, m);
	90	seq_putc(m, '\n');
	91	}
	92	read_unlock(&slow_work_execs_lock);
	93	return 0;
	94
	95	default:
	96	work = list_entry(p, struct slow_work, link);
	97	seq_printf(m, "%3s - %16p %2lx ",
	98	work->flags & SLOW_WORK_VERY_SLOW ? "vsq" : "sq",
	99	work, work->flags);
	100	slow_work_print_mark(m, work);
	101
	102	if (work->ops->desc)
	103	work->ops->desc(work, m);
	104	seq_putc(m, '\n');
	105	return 0;
	106	}
	107	}
	108
	109	/*
	110	* map the iterator to a work item
	111	*/
	112	static void slow_work_runqueue_index(struct seq_file m, loff_t *_pos)
	113	{
	114	struct list_head *p;
	115	unsigned long count, id;
	116
	117	switch (*_pos >> ITERATOR_SHIFT) {
	118	case 0x0:
	119	if (*_pos == 0)
	120	*_pos = 1;
	121	if (*_pos < 3)
	122	return (void )(unsigned long) _pos;
	123	if (*_pos < 3 + SLOW_WORK_THREAD_LIMIT)
	124	for (id = *_pos - 3;
125	id < SLOW_WORK_THREAD_LIMIT;
126	id++, (*_pos)++)
127	if (slow_work_execs[id])
128	return (void )(unsigned long) _pos;
129	*_pos = 0x1UL << ITERATOR_SHIFT;
130
131	case 0x1:
132	count = *_pos & ITERATOR_COUNTER;
133	list_for_each(p, &slow_work_queue) {
134	if (count == 0)
135	return p;
136	count--;
137	}
138	*_pos = 0x2UL << ITERATOR_SHIFT;
139
140	case 0x2:
141	count = *_pos & ITERATOR_COUNTER;
142	list_for_each(p, &vslow_work_queue) {
143	if (count == 0)
144	return p;
145	count--;
146	}
147	*_pos = 0x3UL << ITERATOR_SHIFT;
148
149	default:
150	return NULL;
151	}
152	}
153
154	/*
155	* set up the iterator to start reading from the first line
156	*/
157	static void slow_work_runqueue_start(struct seq_file m, loff_t *_pos)
158	{
159	spin_lock_irq(&slow_work_queue_lock);
160	return slow_work_runqueue_index(m, _pos);
161	}
162
163	/*
164	* move to the next line
165	*/
166	static void slow_work_runqueue_next(struct seq_file m, void v, loff_t _pos)
167	{
168	struct list_head *p = v;
169	unsigned long selector = *_pos >> ITERATOR_SHIFT;
170
171	(*_pos)++;
172	switch (selector) {
173	case 0x0:
174	return slow_work_runqueue_index(m, _pos);
175
176	case 0x1:
177	if (*_pos >> ITERATOR_SHIFT == 0x1) {
178	p = p->next;
179	if (p != &slow_work_queue)
180	return p;
181	}
182	*_pos = 0x2UL << ITERATOR_SHIFT;
183	p = &vslow_work_queue;
184
185	case 0x2:
186	if (*_pos >> ITERATOR_SHIFT == 0x2) {
187	p = p->next;
188	if (p != &vslow_work_queue)
189	return p;
190	}
191	*_pos = 0x3UL << ITERATOR_SHIFT;
192
193	default:
194	return NULL;
195	}
196	}
197
198	/*
199	* clean up after reading
200	*/
201	static void slow_work_runqueue_stop(struct seq_file m, void v)
202	{
203	spin_unlock_irq(&slow_work_queue_lock);
204	}
205
206	static const struct seq_operations slow_work_runqueue_ops = {
207	.start = slow_work_runqueue_start,
208	.stop = slow_work_runqueue_stop,
209	.next = slow_work_runqueue_next,
210	.show = slow_work_runqueue_show,
211	};
212
213	/*
f13a48bd	214	* open "/sys/kernel/debug/slow_work/runqueue" to list queue contents
8fba10a4 DH	215	*/
	216	static int slow_work_runqueue_open(struct inode inode, struct file file)
	217	{
	218	return seq_open(file, &slow_work_runqueue_ops);
	219	}
	220
	221	const struct file_operations slow_work_runqueue_fops = {
	222	.owner = THIS_MODULE,
	223	.open = slow_work_runqueue_open,
	224	.read = seq_read,
	225	.llseek = seq_lseek,
	226	.release = seq_release,
	227	};