[linux-2.6-block.git] / kernel / rcu / tiny_plugin.h

/*
 * Read-Copy Update mechanism for mutual exclusion, the Bloatwatch edition
 * Internal non-public definitions that provide either classic
 * or preemptible semantics.
 *
 * 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 will 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you can access it online at
 * http://www.gnu.org/licenses/gpl-2.0.html.
 *
 * Copyright (c) 2010 Linaro
 *
 * Author: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
 */

#include <linux/kthread.h>
#include <linux/init.h>
#include <linux/debugfs.h>
#include <linux/seq_file.h>

/* Global control variables for rcupdate callback mechanism. */
struct rcu_ctrlblk {
	struct rcu_head *rcucblist;	/* List of pending callbacks (CBs). */
	struct rcu_head **donetail;	/* ->next pointer of last "done" CB. */
	struct rcu_head **curtail;	/* ->next pointer of last CB. */
	RCU_TRACE(long qlen);		/* Number of pending CBs. */
	RCU_TRACE(unsigned long gp_start); /* Start time for stalls. */
	RCU_TRACE(unsigned long ticks_this_gp); /* Statistic for stalls. */
	RCU_TRACE(unsigned long jiffies_stall); /* Jiffies at next stall. */
	RCU_TRACE(const char *name);	/* Name of RCU type. */
};

/* Definition for rcupdate control block. */
static struct rcu_ctrlblk rcu_sched_ctrlblk = {
	.donetail	= &rcu_sched_ctrlblk.rcucblist,
	.curtail	= &rcu_sched_ctrlblk.rcucblist,
	RCU_TRACE(.name = "rcu_sched")
};

static struct rcu_ctrlblk rcu_bh_ctrlblk = {
	.donetail	= &rcu_bh_ctrlblk.rcucblist,
	.curtail	= &rcu_bh_ctrlblk.rcucblist,
	RCU_TRACE(.name = "rcu_bh")
};

#ifdef CONFIG_DEBUG_LOCK_ALLOC
#include <linux/kernel_stat.h>

int rcu_scheduler_active __read_mostly;
EXPORT_SYMBOL_GPL(rcu_scheduler_active);

/*
 * During boot, we forgive RCU lockdep issues.  After this function is
 * invoked, we start taking RCU lockdep issues seriously.
 */
void __init rcu_scheduler_starting(void)
{
	WARN_ON(nr_context_switches() > 0);
	rcu_scheduler_active = 1;
}

#endif /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */

#ifdef CONFIG_RCU_TRACE

static void rcu_trace_sub_qlen(struct rcu_ctrlblk *rcp, int n)
{
	unsigned long flags;

	local_irq_save(flags);
	rcp->qlen -= n;
	local_irq_restore(flags);
}

/*
 * Dump statistics for TINY_RCU, such as they are.
 */
static int show_tiny_stats(struct seq_file *m, void *unused)
{
	seq_printf(m, "rcu_sched: qlen: %ld\n", rcu_sched_ctrlblk.qlen);
	seq_printf(m, "rcu_bh: qlen: %ld\n", rcu_bh_ctrlblk.qlen);
	return 0;
}

static int show_tiny_stats_open(struct inode *inode, struct file *file)
{
	return single_open(file, show_tiny_stats, NULL);
}

static const struct file_operations show_tiny_stats_fops = {
	.owner = THIS_MODULE,
	.open = show_tiny_stats_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
};

static struct dentry *rcudir;

static int __init rcutiny_trace_init(void)
{
	struct dentry *retval;

	rcudir = debugfs_create_dir("rcu", NULL);
	if (!rcudir)
		goto free_out;
	retval = debugfs_create_file("rcudata", 0444, rcudir,
				     NULL, &show_tiny_stats_fops);
	if (!retval)
		goto free_out;
	return 0;
free_out:
	debugfs_remove_recursive(rcudir);
	return 1;
}
device_initcall(rcutiny_trace_init);

static void check_cpu_stall(struct rcu_ctrlblk *rcp)
{
	unsigned long j;
	unsigned long js;

	if (rcu_cpu_stall_suppress)
		return;
	rcp->ticks_this_gp++;
	j = jiffies;
	js = READ_ONCE(rcp->jiffies_stall);
	if (rcp->rcucblist && ULONG_CMP_GE(j, js)) {
		pr_err("INFO: %s stall on CPU (%lu ticks this GP) idle=%llx (t=%lu jiffies q=%ld)\n",
		       rcp->name, rcp->ticks_this_gp, DYNTICK_TASK_EXIT_IDLE,
		       jiffies - rcp->gp_start, rcp->qlen);
		dump_stack();
		WRITE_ONCE(rcp->jiffies_stall,
			   jiffies + 3 * rcu_jiffies_till_stall_check() + 3);
	} else if (ULONG_CMP_GE(j, js)) {
		WRITE_ONCE(rcp->jiffies_stall,
			   jiffies + rcu_jiffies_till_stall_check());
	}
}

static void reset_cpu_stall_ticks(struct rcu_ctrlblk *rcp)
{
	rcp->ticks_this_gp = 0;
	rcp->gp_start = jiffies;
	WRITE_ONCE(rcp->jiffies_stall,
		   jiffies + rcu_jiffies_till_stall_check());
}

static void check_cpu_stalls(void)
{
	RCU_TRACE(check_cpu_stall(&rcu_bh_ctrlblk));
	RCU_TRACE(check_cpu_stall(&rcu_sched_ctrlblk));
}

#endif /* #ifdef CONFIG_RCU_TRACE */
Commit	Line	Data
bbad9379	1	/*
a57eb940	2	* Read-Copy Update mechanism for mutual exclusion, the Bloatwatch edition
bbad9379	3	* Internal non-public definitions that provide either classic
a57eb940	4	* or preemptible semantics.
bbad9379 PM	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
87de1cfd PM	17	* along with this program; if not, you can access it online at
87de1cfd PM	18	* http://www.gnu.org/licenses/gpl-2.0.html.
bbad9379	19	*
a57eb940	20	* Copyright (c) 2010 Linaro
bbad9379 PM	21	*
	22	* Author: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
	23	*/
	24
b2c0710c	25	#include <linux/kthread.h>
9fc9204e	26	#include <linux/init.h>
9e571a82 PM	27	#include <linux/debugfs.h>
	28	#include <linux/seq_file.h>
	29
24278d14 PM	30	/* Global control variables for rcupdate callback mechanism. */
	31	struct rcu_ctrlblk {
	32	struct rcu_head rcucblist; / List of pending callbacks (CBs). */
	33	struct rcu_head *donetail; / ->next pointer of last "done" CB. */
	34	struct rcu_head *curtail; / ->next pointer of last CB. */
9e571a82	35	RCU_TRACE(long qlen); /* Number of pending CBs. */
6bfc09e2 PM	36	RCU_TRACE(unsigned long gp_start); /* Start time for stalls. */
	37	RCU_TRACE(unsigned long ticks_this_gp); /* Statistic for stalls. */
	38	RCU_TRACE(unsigned long jiffies_stall); /* Jiffies at next stall. */
e66c33d5	39	RCU_TRACE(const char name); / Name of RCU type. */
24278d14 PM	40	};
	41
	42	/* Definition for rcupdate control block. */
	43	static struct rcu_ctrlblk rcu_sched_ctrlblk = {
	44	.donetail = &rcu_sched_ctrlblk.rcucblist,
	45	.curtail = &rcu_sched_ctrlblk.rcucblist,
e99033c5	46	RCU_TRACE(.name = "rcu_sched")
24278d14 PM	47	};
	48
	49	static struct rcu_ctrlblk rcu_bh_ctrlblk = {
	50	.donetail = &rcu_bh_ctrlblk.rcucblist,
	51	.curtail = &rcu_bh_ctrlblk.rcucblist,
e99033c5	52	RCU_TRACE(.name = "rcu_bh")
24278d14 PM	53	};
	54
	55	#ifdef CONFIG_DEBUG_LOCK_ALLOC
318bdcd9 PM	56	#include <linux/kernel_stat.h>
318bdcd9 PM	57
24278d14 PM	58	int rcu_scheduler_active __read_mostly;
24278d14 PM	59	EXPORT_SYMBOL_GPL(rcu_scheduler_active);
bbad9379 PM	60
	61	/*
	62	* During boot, we forgive RCU lockdep issues. After this function is
	63	* invoked, we start taking RCU lockdep issues seriously.
	64	*/
b2c0710c	65	void __init rcu_scheduler_starting(void)
bbad9379 PM	66	{
	67	WARN_ON(nr_context_switches() > 0);
	68	rcu_scheduler_active = 1;
	69	}
	70
	71	#endif /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
24278d14	72
9e571a82 PM	73	#ifdef CONFIG_RCU_TRACE
9e571a82 PM	74
9e571a82 PM	75	static void rcu_trace_sub_qlen(struct rcu_ctrlblk *rcp, int n)
	76	{
	77	unsigned long flags;
	78
7a11e205	79	local_irq_save(flags);
9e571a82	80	rcp->qlen -= n;
7a11e205	81	local_irq_restore(flags);
9e571a82 PM	82	}
	83
	84	/*
	85	* Dump statistics for TINY_RCU, such as they are.
	86	*/
	87	static int show_tiny_stats(struct seq_file m, void unused)
	88	{
9e571a82 PM	89	seq_printf(m, "rcu_sched: qlen: %ld\n", rcu_sched_ctrlblk.qlen);
	90	seq_printf(m, "rcu_bh: qlen: %ld\n", rcu_bh_ctrlblk.qlen);
	91	return 0;
	92	}
	93
	94	static int show_tiny_stats_open(struct inode inode, struct file file)
	95	{
	96	return single_open(file, show_tiny_stats, NULL);
	97	}
	98
	99	static const struct file_operations show_tiny_stats_fops = {
	100	.owner = THIS_MODULE,
	101	.open = show_tiny_stats_open,
	102	.read = seq_read,
	103	.llseek = seq_lseek,
	104	.release = single_release,
	105	};
	106
	107	static struct dentry *rcudir;
	108
	109	static int __init rcutiny_trace_init(void)
	110	{
	111	struct dentry *retval;
	112
	113	rcudir = debugfs_create_dir("rcu", NULL);
	114	if (!rcudir)
	115	goto free_out;
	116	retval = debugfs_create_file("rcudata", 0444, rcudir,
	117	NULL, &show_tiny_stats_fops);
	118	if (!retval)
	119	goto free_out;
	120	return 0;
	121	free_out:
	122	debugfs_remove_recursive(rcudir);
	123	return 1;
	124	}
9fc9204e	125	device_initcall(rcutiny_trace_init);
9e571a82	126
318bdcd9 PM	127	static void check_cpu_stall(struct rcu_ctrlblk *rcp)
	128	{
	129	unsigned long j;
	130	unsigned long js;
	131
	132	if (rcu_cpu_stall_suppress)
	133	return;
	134	rcp->ticks_this_gp++;
	135	j = jiffies;
7d0ae808	136	js = READ_ONCE(rcp->jiffies_stall);
ec1fe396	137	if (rcp->rcucblist && ULONG_CMP_GE(j, js)) {
318bdcd9	138	pr_err("INFO: %s stall on CPU (%lu ticks this GP) idle=%llx (t=%lu jiffies q=%ld)\n",
5f6130fa	139	rcp->name, rcp->ticks_this_gp, DYNTICK_TASK_EXIT_IDLE,
318bdcd9 PM	140	jiffies - rcp->gp_start, rcp->qlen);
318bdcd9 PM	141	dump_stack();
7d0ae808 PM	142	WRITE_ONCE(rcp->jiffies_stall,
7d0ae808 PM	143	jiffies + 3 * rcu_jiffies_till_stall_check() + 3);
ec1fe396	144	} else if (ULONG_CMP_GE(j, js)) {
7d0ae808 PM	145	WRITE_ONCE(rcp->jiffies_stall,
7d0ae808 PM	146	jiffies + rcu_jiffies_till_stall_check());
ec1fe396	147	}
318bdcd9 PM	148	}
318bdcd9 PM	149
318bdcd9 PM	150	static void reset_cpu_stall_ticks(struct rcu_ctrlblk *rcp)
318bdcd9 PM	151	{
318bdcd9 PM	152	rcp->ticks_this_gp = 0;
318bdcd9 PM	153	rcp->gp_start = jiffies;
7d0ae808 PM	154	WRITE_ONCE(rcp->jiffies_stall,
7d0ae808 PM	155	jiffies + rcu_jiffies_till_stall_check());
318bdcd9 PM	156	}
	157
	158	static void check_cpu_stalls(void)
	159	{
	160	RCU_TRACE(check_cpu_stall(&rcu_bh_ctrlblk));
	161	RCU_TRACE(check_cpu_stall(&rcu_sched_ctrlblk));
	162	}
14961444 PM	163
14961444 PM	164	#endif /* #ifdef CONFIG_RCU_TRACE */