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