[deliverable/linux.git] / drivers / s390 / cio / qdio_debug.c

/*
 *  drivers/s390/cio/qdio_debug.c
 *
 *  Copyright IBM Corp. 2008,2009
 *
 *  Author: Jan Glauber (jang@linux.vnet.ibm.com)
 */
#include <linux/seq_file.h>
#include <linux/debugfs.h>
#include <asm/debug.h>
#include "qdio_debug.h"
#include "qdio.h"

debug_info_t *qdio_dbf_setup;
debug_info_t *qdio_dbf_error;

static struct dentry *debugfs_root;
#define QDIO_DEBUGFS_NAME_LEN	10

void qdio_allocate_dbf(struct qdio_initialize *init_data,
		       struct qdio_irq *irq_ptr)
{
	char text[20];

	DBF_EVENT("qfmt:%1d", init_data->q_format);
	DBF_HEX(init_data->adapter_name, 8);
	DBF_EVENT("qpff%4x", init_data->qib_param_field_format);
	DBF_HEX(&init_data->qib_param_field, sizeof(void *));
	DBF_HEX(&init_data->input_slib_elements, sizeof(void *));
	DBF_HEX(&init_data->output_slib_elements, sizeof(void *));
	DBF_EVENT("niq:%1d noq:%1d", init_data->no_input_qs,
		  init_data->no_output_qs);
	DBF_HEX(&init_data->input_handler, sizeof(void *));
	DBF_HEX(&init_data->output_handler, sizeof(void *));
	DBF_HEX(&init_data->int_parm, sizeof(long));
	DBF_HEX(&init_data->input_sbal_addr_array, sizeof(void *));
	DBF_HEX(&init_data->output_sbal_addr_array, sizeof(void *));
	DBF_EVENT("irq:%8lx", (unsigned long)irq_ptr);

	/* allocate trace view for the interface */
	snprintf(text, 20, "qdio_%s", dev_name(&init_data->cdev->dev));
	irq_ptr->debug_area = debug_register(text, 2, 1, 16);
	debug_register_view(irq_ptr->debug_area, &debug_hex_ascii_view);
	debug_set_level(irq_ptr->debug_area, DBF_WARN);
	DBF_DEV_EVENT(DBF_ERR, irq_ptr, "dbf created");
}

static int qstat_show(struct seq_file *m, void *v)
{
	unsigned char state;
	struct qdio_q *q = m->private;
	int i;

	if (!q)
		return 0;

	seq_printf(m, "DSCI: %d   nr_used: %d\n",
		   *(u32 *)q->irq_ptr->dsci, atomic_read(&q->nr_buf_used));
	seq_printf(m, "ftc: %d  last_move: %d\n",
		   q->first_to_check, q->last_move);
	if (q->is_input_q) {
		seq_printf(m, "polling: %d  ack start: %d  ack count: %d\n",
			   q->u.in.polling, q->u.in.ack_start,
			   q->u.in.ack_count);
		seq_printf(m, "IRQs disabled: %u\n",
			   test_bit(QDIO_QUEUE_IRQS_DISABLED,
			   &q->u.in.queue_irq_state));
	}
	seq_printf(m, "SBAL states:\n");
	seq_printf(m, "|0      |8      |16     |24     |32     |40     |48     |56  63|\n");

	for (i = 0; i < QDIO_MAX_BUFFERS_PER_Q; i++) {
		debug_get_buf_state(q, i, &state);
		switch (state) {
		case SLSB_P_INPUT_NOT_INIT:
		case SLSB_P_OUTPUT_NOT_INIT:
			seq_printf(m, "N");
			break;
		case SLSB_P_INPUT_PRIMED:
		case SLSB_CU_OUTPUT_PRIMED:
			seq_printf(m, "+");
			break;
		case SLSB_P_INPUT_ACK:
			seq_printf(m, "A");
			break;
		case SLSB_P_INPUT_ERROR:
		case SLSB_P_OUTPUT_ERROR:
			seq_printf(m, "x");
			break;
		case SLSB_CU_INPUT_EMPTY:
		case SLSB_P_OUTPUT_EMPTY:
			seq_printf(m, "-");
			break;
		case SLSB_P_INPUT_HALTED:
		case SLSB_P_OUTPUT_HALTED:
			seq_printf(m, ".");
			break;
		default:
			seq_printf(m, "?");
		}
		if (i == 63)
			seq_printf(m, "\n");
	}
	seq_printf(m, "\n");
	seq_printf(m, "|64     |72     |80     |88     |96     |104    |112    |   127|\n");

	seq_printf(m, "\nSBAL statistics:");
	if (!q->irq_ptr->perf_stat_enabled) {
		seq_printf(m, " disabled\n");
		return 0;
	}

	seq_printf(m, "\n1          2..        4..        8..        "
		   "16..       32..       64..       127\n");
	for (i = 0; i < ARRAY_SIZE(q->q_stats.nr_sbals); i++)
		seq_printf(m, "%-10u ", q->q_stats.nr_sbals[i]);
	seq_printf(m, "\nError      NOP        Total\n%-10u %-10u %-10u\n\n",
		   q->q_stats.nr_sbal_error, q->q_stats.nr_sbal_nop,
		   q->q_stats.nr_sbal_total);
	return 0;
}

static int qstat_seq_open(struct inode *inode, struct file *filp)
{
	return single_open(filp, qstat_show,
			   filp->f_path.dentry->d_inode->i_private);
}

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

static char *qperf_names[] = {
	"Assumed adapter interrupts",
	"QDIO interrupts",
	"Requested PCIs",
	"Inbound tasklet runs",
	"Inbound tasklet resched",
	"Inbound tasklet resched2",
	"Outbound tasklet runs",
	"SIGA read",
	"SIGA write",
	"SIGA sync",
	"Inbound calls",
	"Inbound handler",
	"Inbound stop_polling",
	"Inbound queue full",
	"Outbound calls",
	"Outbound handler",
	"Outbound queue full",
	"Outbound fast_requeue",
	"Outbound target_full",
	"QEBSM eqbs",
	"QEBSM eqbs partial",
	"QEBSM sqbs",
	"QEBSM sqbs partial",
	"Discarded interrupts"
};

static int qperf_show(struct seq_file *m, void *v)
{
	struct qdio_irq *irq_ptr = m->private;
	unsigned int *stat;
	int i;

	if (!irq_ptr)
		return 0;
	if (!irq_ptr->perf_stat_enabled) {
		seq_printf(m, "disabled\n");
		return 0;
	}
	stat = (unsigned int *)&irq_ptr->perf_stat;

	for (i = 0; i < ARRAY_SIZE(qperf_names); i++)
		seq_printf(m, "%26s:\t%u\n",
			   qperf_names[i], *(stat + i));
	return 0;
}

static ssize_t qperf_seq_write(struct file *file, const char __user *ubuf,
			       size_t count, loff_t *off)
{
	struct seq_file *seq = file->private_data;
	struct qdio_irq *irq_ptr = seq->private;
	struct qdio_q *q;
	unsigned long val;
	char buf[8];
	int ret, i;

	if (!irq_ptr)
		return 0;
	if (count >= sizeof(buf))
		return -EINVAL;
	if (copy_from_user(&buf, ubuf, count))
		return -EFAULT;
	buf[count] = 0;

	ret = strict_strtoul(buf, 10, &val);
	if (ret < 0)
		return ret;

	switch (val) {
	case 0:
		irq_ptr->perf_stat_enabled = 0;
		memset(&irq_ptr->perf_stat, 0, sizeof(irq_ptr->perf_stat));
		for_each_input_queue(irq_ptr, q, i)
			memset(&q->q_stats, 0, sizeof(q->q_stats));
		for_each_output_queue(irq_ptr, q, i)
			memset(&q->q_stats, 0, sizeof(q->q_stats));
		break;
	case 1:
		irq_ptr->perf_stat_enabled = 1;
		break;
	}
	return count;
}

static int qperf_seq_open(struct inode *inode, struct file *filp)
{
	return single_open(filp, qperf_show,
			   filp->f_path.dentry->d_inode->i_private);
}

static struct file_operations debugfs_perf_fops = {
	.owner	 = THIS_MODULE,
	.open	 = qperf_seq_open,
	.read	 = seq_read,
	.write	 = qperf_seq_write,
	.llseek  = seq_lseek,
	.release = single_release,
};
static void setup_debugfs_entry(struct qdio_q *q, struct ccw_device *cdev)
{
	char name[QDIO_DEBUGFS_NAME_LEN];

	snprintf(name, QDIO_DEBUGFS_NAME_LEN, "%s_%d",
		 q->is_input_q ? "input" : "output",
		 q->nr);
	q->debugfs_q = debugfs_create_file(name, S_IFREG | S_IRUGO | S_IWUSR,
				q->irq_ptr->debugfs_dev, q, &debugfs_fops);
	if (IS_ERR(q->debugfs_q))
		q->debugfs_q = NULL;
}

void qdio_setup_debug_entries(struct qdio_irq *irq_ptr, struct ccw_device *cdev)
{
	struct qdio_q *q;
	int i;

	irq_ptr->debugfs_dev = debugfs_create_dir(dev_name(&cdev->dev),
						  debugfs_root);
	if (IS_ERR(irq_ptr->debugfs_dev))
		irq_ptr->debugfs_dev = NULL;

	irq_ptr->debugfs_perf = debugfs_create_file("statistics",
				S_IFREG | S_IRUGO | S_IWUSR,
				irq_ptr->debugfs_dev, irq_ptr,
				&debugfs_perf_fops);
	if (IS_ERR(irq_ptr->debugfs_perf))
		irq_ptr->debugfs_perf = NULL;

	for_each_input_queue(irq_ptr, q, i)
		setup_debugfs_entry(q, cdev);
	for_each_output_queue(irq_ptr, q, i)
		setup_debugfs_entry(q, cdev);
}

void qdio_shutdown_debug_entries(struct qdio_irq *irq_ptr, struct ccw_device *cdev)
{
	struct qdio_q *q;
	int i;

	for_each_input_queue(irq_ptr, q, i)
		debugfs_remove(q->debugfs_q);
	for_each_output_queue(irq_ptr, q, i)
		debugfs_remove(q->debugfs_q);
	debugfs_remove(irq_ptr->debugfs_perf);
	debugfs_remove(irq_ptr->debugfs_dev);
}

int __init qdio_debug_init(void)
{
	debugfs_root = debugfs_create_dir("qdio", NULL);

	qdio_dbf_setup = debug_register("qdio_setup", 16, 1, 16);
	debug_register_view(qdio_dbf_setup, &debug_hex_ascii_view);
	debug_set_level(qdio_dbf_setup, DBF_INFO);
	DBF_EVENT("dbf created\n");

	qdio_dbf_error = debug_register("qdio_error", 4, 1, 16);
	debug_register_view(qdio_dbf_error, &debug_hex_ascii_view);
	debug_set_level(qdio_dbf_error, DBF_INFO);
	DBF_ERROR("dbf created\n");
	return 0;
}

void qdio_debug_exit(void)
{
	debugfs_remove(debugfs_root);
	if (qdio_dbf_setup)
		debug_unregister(qdio_dbf_setup);
	if (qdio_dbf_error)
		debug_unregister(qdio_dbf_error);
}
Commit	Line	Data
779e6e1c JG	1	/*
	2	* drivers/s390/cio/qdio_debug.c
	3	*
3f09bb89	4	* Copyright IBM Corp. 2008,2009
779e6e1c JG	5	*
	6	* Author: Jan Glauber (jang@linux.vnet.ibm.com)
	7	*/
779e6e1c JG	8	#include <linux/seq_file.h>
779e6e1c JG	9	#include <linux/debugfs.h>
779e6e1c JG	10	#include <asm/debug.h>
	11	#include "qdio_debug.h"
	12	#include "qdio.h"
	13
	14	debug_info_t *qdio_dbf_setup;
22f99347	15	debug_info_t *qdio_dbf_error;
779e6e1c JG	16
779e6e1c JG	17	static struct dentry *debugfs_root;
3f09bb89	18	#define QDIO_DEBUGFS_NAME_LEN 10
779e6e1c	19
22f99347 JG	20	void qdio_allocate_dbf(struct qdio_initialize *init_data,
22f99347 JG	21	struct qdio_irq *irq_ptr)
779e6e1c	22	{
22f99347 JG	23	char text[20];
	24
	25	DBF_EVENT("qfmt:%1d", init_data->q_format);
	26	DBF_HEX(init_data->adapter_name, 8);
	27	DBF_EVENT("qpff%4x", init_data->qib_param_field_format);
	28	DBF_HEX(&init_data->qib_param_field, sizeof(void *));
	29	DBF_HEX(&init_data->input_slib_elements, sizeof(void *));
	30	DBF_HEX(&init_data->output_slib_elements, sizeof(void *));
	31	DBF_EVENT("niq:%1d noq:%1d", init_data->no_input_qs,
	32	init_data->no_output_qs);
	33	DBF_HEX(&init_data->input_handler, sizeof(void *));
	34	DBF_HEX(&init_data->output_handler, sizeof(void *));
	35	DBF_HEX(&init_data->int_parm, sizeof(long));
22f99347 JG	36	DBF_HEX(&init_data->input_sbal_addr_array, sizeof(void *));
	37	DBF_HEX(&init_data->output_sbal_addr_array, sizeof(void *));
	38	DBF_EVENT("irq:%8lx", (unsigned long)irq_ptr);
	39
	40	/* allocate trace view for the interface */
	41	snprintf(text, 20, "qdio_%s", dev_name(&init_data->cdev->dev));
	42	irq_ptr->debug_area = debug_register(text, 2, 1, 16);
	43	debug_register_view(irq_ptr->debug_area, &debug_hex_ascii_view);
	44	debug_set_level(irq_ptr->debug_area, DBF_WARN);
	45	DBF_DEV_EVENT(DBF_ERR, irq_ptr, "dbf created");
779e6e1c JG	46	}
	47
	48	static int qstat_show(struct seq_file m, void v)
	49	{
	50	unsigned char state;
	51	struct qdio_q *q = m->private;
	52	int i;
	53
	54	if (!q)
	55	return 0;
	56
6486cda6 JG	57	seq_printf(m, "DSCI: %d nr_used: %d\n",
6486cda6 JG	58	(u32 )q->irq_ptr->dsci, atomic_read(&q->nr_buf_used));
d36deae7 JG	59	seq_printf(m, "ftc: %d last_move: %d\n",
	60	q->first_to_check, q->last_move);
	61	if (q->is_input_q) {
	62	seq_printf(m, "polling: %d ack start: %d ack count: %d\n",
	63	q->u.in.polling, q->u.in.ack_start,
	64	q->u.in.ack_count);
	65	seq_printf(m, "IRQs disabled: %u\n",
	66	test_bit(QDIO_QUEUE_IRQS_DISABLED,
	67	&q->u.in.queue_irq_state));
	68	}
d307297f	69	seq_printf(m, "SBAL states:\n");
50f769df	70	seq_printf(m, "\|0 \|8 \|16 \|24 \|32 \|40 \|48 \|56 63\|\n");
779e6e1c	71
779e6e1c	72	for (i = 0; i < QDIO_MAX_BUFFERS_PER_Q; i++) {
60b5df2f	73	debug_get_buf_state(q, i, &state);
779e6e1c JG	74	switch (state) {
	75	case SLSB_P_INPUT_NOT_INIT:
	76	case SLSB_P_OUTPUT_NOT_INIT:
	77	seq_printf(m, "N");
	78	break;
	79	case SLSB_P_INPUT_PRIMED:
	80	case SLSB_CU_OUTPUT_PRIMED:
	81	seq_printf(m, "+");
	82	break;
	83	case SLSB_P_INPUT_ACK:
	84	seq_printf(m, "A");
	85	break;
	86	case SLSB_P_INPUT_ERROR:
	87	case SLSB_P_OUTPUT_ERROR:
	88	seq_printf(m, "x");
	89	break;
	90	case SLSB_CU_INPUT_EMPTY:
	91	case SLSB_P_OUTPUT_EMPTY:
	92	seq_printf(m, "-");
	93	break;
	94	case SLSB_P_INPUT_HALTED:
	95	case SLSB_P_OUTPUT_HALTED:
	96	seq_printf(m, ".");
	97	break;
	98	default:
	99	seq_printf(m, "?");
	100	}
	101	if (i == 63)
	102	seq_printf(m, "\n");
	103	}
	104	seq_printf(m, "\n");
50f769df	105	seq_printf(m, "\|64 \|72 \|80 \|88 \|96 \|104 \|112 \| 127\|\n");
d307297f JG	106
	107	seq_printf(m, "\nSBAL statistics:");
	108	if (!q->irq_ptr->perf_stat_enabled) {
	109	seq_printf(m, " disabled\n");
	110	return 0;
	111	}
	112
	113	seq_printf(m, "\n1 2.. 4.. 8.. "
	114	"16.. 32.. 64.. 127\n");
	115	for (i = 0; i < ARRAY_SIZE(q->q_stats.nr_sbals); i++)
	116	seq_printf(m, "%-10u ", q->q_stats.nr_sbals[i]);
	117	seq_printf(m, "\nError NOP Total\n%-10u %-10u %-10u\n\n",
	118	q->q_stats.nr_sbal_error, q->q_stats.nr_sbal_nop,
	119	q->q_stats.nr_sbal_total);
779e6e1c JG	120	return 0;
	121	}
	122
779e6e1c JG	123	static int qstat_seq_open(struct inode inode, struct file filp)
	124	{
	125	return single_open(filp, qstat_show,
	126	filp->f_path.dentry->d_inode->i_private);
	127	}
	128
828c0950	129	static const struct file_operations debugfs_fops = {
779e6e1c JG	130	.owner = THIS_MODULE,
	131	.open = qstat_seq_open,
	132	.read = seq_read,
779e6e1c JG	133	.llseek = seq_lseek,
	134	.release = single_release,
	135	};
	136
6486cda6 JG	137	static char *qperf_names[] = {
	138	"Assumed adapter interrupts",
	139	"QDIO interrupts",
	140	"Requested PCIs",
	141	"Inbound tasklet runs",
	142	"Inbound tasklet resched",
	143	"Inbound tasklet resched2",
	144	"Outbound tasklet runs",
	145	"SIGA read",
	146	"SIGA write",
	147	"SIGA sync",
	148	"Inbound calls",
	149	"Inbound handler",
	150	"Inbound stop_polling",
	151	"Inbound queue full",
	152	"Outbound calls",
	153	"Outbound handler",
0195843b	154	"Outbound queue full",
6486cda6 JG	155	"Outbound fast_requeue",
	156	"Outbound target_full",
	157	"QEBSM eqbs",
	158	"QEBSM eqbs partial",
	159	"QEBSM sqbs",
d36deae7 JG	160	"QEBSM sqbs partial",
d36deae7 JG	161	"Discarded interrupts"
6486cda6 JG	162	};
	163
	164	static int qperf_show(struct seq_file m, void v)
	165	{
	166	struct qdio_irq *irq_ptr = m->private;
	167	unsigned int *stat;
	168	int i;
	169
	170	if (!irq_ptr)
	171	return 0;
	172	if (!irq_ptr->perf_stat_enabled) {
	173	seq_printf(m, "disabled\n");
	174	return 0;
	175	}
	176	stat = (unsigned int *)&irq_ptr->perf_stat;
	177
	178	for (i = 0; i < ARRAY_SIZE(qperf_names); i++)
	179	seq_printf(m, "%26s:\t%u\n",
	180	qperf_names[i], *(stat + i));
	181	return 0;
	182	}
	183
	184	static ssize_t qperf_seq_write(struct file file, const char __user ubuf,
	185	size_t count, loff_t *off)
	186	{
	187	struct seq_file *seq = file->private_data;
	188	struct qdio_irq *irq_ptr = seq->private;
d307297f	189	struct qdio_q *q;
6486cda6 JG	190	unsigned long val;
6486cda6 JG	191	char buf[8];
d307297f	192	int ret, i;
6486cda6 JG	193
	194	if (!irq_ptr)
	195	return 0;
	196	if (count >= sizeof(buf))
	197	return -EINVAL;
	198	if (copy_from_user(&buf, ubuf, count))
	199	return -EFAULT;
	200	buf[count] = 0;
	201
	202	ret = strict_strtoul(buf, 10, &val);
	203	if (ret < 0)
	204	return ret;
	205
	206	switch (val) {
	207	case 0:
	208	irq_ptr->perf_stat_enabled = 0;
	209	memset(&irq_ptr->perf_stat, 0, sizeof(irq_ptr->perf_stat));
d307297f JG	210	for_each_input_queue(irq_ptr, q, i)
	211	memset(&q->q_stats, 0, sizeof(q->q_stats));
	212	for_each_output_queue(irq_ptr, q, i)
	213	memset(&q->q_stats, 0, sizeof(q->q_stats));
6486cda6 JG	214	break;
	215	case 1:
	216	irq_ptr->perf_stat_enabled = 1;
	217	break;
	218	}
	219	return count;
	220	}
	221
	222	static int qperf_seq_open(struct inode inode, struct file filp)
	223	{
	224	return single_open(filp, qperf_show,
	225	filp->f_path.dentry->d_inode->i_private);
	226	}
	227
	228	static struct file_operations debugfs_perf_fops = {
	229	.owner = THIS_MODULE,
	230	.open = qperf_seq_open,
	231	.read = seq_read,
	232	.write = qperf_seq_write,
	233	.llseek = seq_lseek,
	234	.release = single_release,
	235	};
779e6e1c JG	236	static void setup_debugfs_entry(struct qdio_q q, struct ccw_device cdev)
779e6e1c JG	237	{
2c780914	238	char name[QDIO_DEBUGFS_NAME_LEN];
779e6e1c	239
3f09bb89	240	snprintf(name, QDIO_DEBUGFS_NAME_LEN, "%s_%d",
2c780914 JG	241	q->is_input_q ? "input" : "output",
2c780914 JG	242	q->nr);
3f09bb89 JG	243	q->debugfs_q = debugfs_create_file(name, S_IFREG \| S_IRUGO \| S_IWUSR,
	244	q->irq_ptr->debugfs_dev, q, &debugfs_fops);
	245	if (IS_ERR(q->debugfs_q))
	246	q->debugfs_q = NULL;
779e6e1c JG	247	}
	248
	249	void qdio_setup_debug_entries(struct qdio_irq irq_ptr, struct ccw_device cdev)
	250	{
	251	struct qdio_q *q;
	252	int i;
	253
3f09bb89 JG	254	irq_ptr->debugfs_dev = debugfs_create_dir(dev_name(&cdev->dev),
	255	debugfs_root);
	256	if (IS_ERR(irq_ptr->debugfs_dev))
	257	irq_ptr->debugfs_dev = NULL;
6486cda6 JG	258
	259	irq_ptr->debugfs_perf = debugfs_create_file("statistics",
	260	S_IFREG \| S_IRUGO \| S_IWUSR,
	261	irq_ptr->debugfs_dev, irq_ptr,
	262	&debugfs_perf_fops);
	263	if (IS_ERR(irq_ptr->debugfs_perf))
	264	irq_ptr->debugfs_perf = NULL;
	265
779e6e1c JG	266	for_each_input_queue(irq_ptr, q, i)
	267	setup_debugfs_entry(q, cdev);
	268	for_each_output_queue(irq_ptr, q, i)
	269	setup_debugfs_entry(q, cdev);
779e6e1c JG	270	}
	271
	272	void qdio_shutdown_debug_entries(struct qdio_irq irq_ptr, struct ccw_device cdev)
	273	{
	274	struct qdio_q *q;
	275	int i;
	276
779e6e1c	277	for_each_input_queue(irq_ptr, q, i)
3f09bb89	278	debugfs_remove(q->debugfs_q);
779e6e1c	279	for_each_output_queue(irq_ptr, q, i)
3f09bb89	280	debugfs_remove(q->debugfs_q);
6486cda6	281	debugfs_remove(irq_ptr->debugfs_perf);
3f09bb89	282	debugfs_remove(irq_ptr->debugfs_dev);
779e6e1c JG	283	}
	284
	285	int __init qdio_debug_init(void)
	286	{
3f09bb89	287	debugfs_root = debugfs_create_dir("qdio", NULL);
22f99347 JG	288
	289	qdio_dbf_setup = debug_register("qdio_setup", 16, 1, 16);
	290	debug_register_view(qdio_dbf_setup, &debug_hex_ascii_view);
	291	debug_set_level(qdio_dbf_setup, DBF_INFO);
	292	DBF_EVENT("dbf created\n");
	293
	294	qdio_dbf_error = debug_register("qdio_error", 4, 1, 16);
	295	debug_register_view(qdio_dbf_error, &debug_hex_ascii_view);
	296	debug_set_level(qdio_dbf_error, DBF_INFO);
	297	DBF_ERROR("dbf created\n");
	298	return 0;
779e6e1c JG	299	}
	300
	301	void qdio_debug_exit(void)
	302	{
	303	debugfs_remove(debugfs_root);
22f99347 JG	304	if (qdio_dbf_setup)
	305	debug_unregister(qdio_dbf_setup);
	306	if (qdio_dbf_error)
	307	debug_unregister(qdio_dbf_error);
779e6e1c	308	}