[deliverable/linux.git] / drivers / scsi / qla2xxx / qla_dfs.c

/*
 * QLogic Fibre Channel HBA Driver
 * Copyright (c)  2003-2014 QLogic Corporation
 *
 * See LICENSE.qla2xxx for copyright and licensing details.
 */
#include "qla_def.h"

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

static struct dentry *qla2x00_dfs_root;
static atomic_t qla2x00_dfs_root_count;

static int
qla2x00_dfs_tgt_sess_show(struct seq_file *s, void *unused)
{
	scsi_qla_host_t *vha = s->private;
	struct qla_hw_data *ha = vha->hw;
	unsigned long flags;
	struct qla_tgt_sess *sess = NULL;
	struct qla_tgt *tgt= vha->vha_tgt.qla_tgt;

	seq_printf(s, "%s\n",vha->host_str);
	if (tgt) {
		seq_printf(s, "Port ID   Port Name                Handle\n");

		spin_lock_irqsave(&ha->tgt.sess_lock, flags);
		list_for_each_entry(sess, &tgt->sess_list, sess_list_entry) {
			seq_printf(s, "%02x:%02x:%02x  %8phC  %d\n",
					   sess->s_id.b.domain,sess->s_id.b.area,
					   sess->s_id.b.al_pa,	sess->port_name,
					   sess->loop_id);
		}
		spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
	}

	return 0;
}

static int
qla2x00_dfs_tgt_sess_open(struct inode *inode, struct file *file)
{
	scsi_qla_host_t *vha = inode->i_private;
	return single_open(file, qla2x00_dfs_tgt_sess_show, vha);
}


static const struct file_operations dfs_tgt_sess_ops = {
	.open		= qla2x00_dfs_tgt_sess_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};

static int
qla_dfs_fw_resource_cnt_show(struct seq_file *s, void *unused)
{
	struct scsi_qla_host *vha = s->private;
	struct qla_hw_data *ha = vha->hw;

	seq_puts(s, "FW Resource count\n\n");
	seq_printf(s, "Original TGT exchg count[%d]\n",
	    ha->orig_fw_tgt_xcb_count);
	seq_printf(s, "current TGT exchg count[%d]\n",
	    ha->cur_fw_tgt_xcb_count);
	seq_printf(s, "original Initiator Exchange count[%d]\n",
	    ha->orig_fw_xcb_count);
	seq_printf(s, "Current Initiator Exchange count[%d]\n",
	    ha->cur_fw_xcb_count);
	seq_printf(s, "Original IOCB count[%d]\n", ha->orig_fw_iocb_count);
	seq_printf(s, "Current IOCB count[%d]\n", ha->cur_fw_iocb_count);
	seq_printf(s, "MAX VP count[%d]\n", ha->max_npiv_vports);
	seq_printf(s, "MAX FCF count[%d]\n", ha->fw_max_fcf_count);

	return 0;
}

static int
qla_dfs_fw_resource_cnt_open(struct inode *inode, struct file *file)
{
	struct scsi_qla_host *vha = inode->i_private;
	return single_open(file, qla_dfs_fw_resource_cnt_show, vha);
}

static const struct file_operations dfs_fw_resource_cnt_ops = {
	.open           = qla_dfs_fw_resource_cnt_open,
	.read           = seq_read,
	.llseek         = seq_lseek,
	.release        = single_release,
};

static int
qla_dfs_tgt_counters_show(struct seq_file *s, void *unused)
{
	struct scsi_qla_host *vha = s->private;

	seq_puts(s, "Target Counters\n");
	seq_printf(s, "qla_core_sbt_cmd = %lld\n",
		vha->tgt_counters.qla_core_sbt_cmd);
	seq_printf(s, "qla_core_ret_sta_ctio = %lld\n",
		vha->tgt_counters.qla_core_ret_sta_ctio);
	seq_printf(s, "qla_core_ret_ctio = %lld\n",
		vha->tgt_counters.qla_core_ret_ctio);
	seq_printf(s, "core_qla_que_buf = %lld\n",
		vha->tgt_counters.core_qla_que_buf);
	seq_printf(s, "core_qla_snd_status = %lld\n",
		vha->tgt_counters.core_qla_snd_status);
	seq_printf(s, "core_qla_free_cmd = %lld\n",
		vha->tgt_counters.core_qla_free_cmd);
	seq_printf(s, "num alloc iocb failed = %lld\n",
		vha->tgt_counters.num_alloc_iocb_failed);
	seq_printf(s, "num term exchange sent = %lld\n",
		vha->tgt_counters.num_term_xchg_sent);
	seq_printf(s, "num Q full sent = %lld\n",
		vha->tgt_counters.num_q_full_sent);

	return 0;
}

static int
qla_dfs_tgt_counters_open(struct inode *inode, struct file *file)
{
	struct scsi_qla_host *vha = inode->i_private;
	return single_open(file, qla_dfs_tgt_counters_show, vha);
}

static const struct file_operations dfs_tgt_counters_ops = {
	.open           = qla_dfs_tgt_counters_open,
	.read           = seq_read,
	.llseek         = seq_lseek,
	.release        = single_release,
};

static int
qla2x00_dfs_fce_show(struct seq_file *s, void *unused)
{
	scsi_qla_host_t *vha = s->private;
	uint32_t cnt;
	uint32_t *fce;
	uint64_t fce_start;
	struct qla_hw_data *ha = vha->hw;

	mutex_lock(&ha->fce_mutex);

	seq_puts(s, "FCE Trace Buffer\n");
	seq_printf(s, "In Pointer = %llx\n\n", (unsigned long long)ha->fce_wr);
	seq_printf(s, "Base = %llx\n\n", (unsigned long long) ha->fce_dma);
	seq_puts(s, "FCE Enable Registers\n");
	seq_printf(s, "%08x %08x %08x %08x %08x %08x\n",
	    ha->fce_mb[0], ha->fce_mb[2], ha->fce_mb[3], ha->fce_mb[4],
	    ha->fce_mb[5], ha->fce_mb[6]);

	fce = (uint32_t *) ha->fce;
	fce_start = (unsigned long long) ha->fce_dma;
	for (cnt = 0; cnt < fce_calc_size(ha->fce_bufs) / 4; cnt++) {
		if (cnt % 8 == 0)
			seq_printf(s, "\n%llx: ",
			    (unsigned long long)((cnt * 4) + fce_start));
		else
			seq_putc(s, ' ');
		seq_printf(s, "%08x", *fce++);
	}

	seq_puts(s, "\nEnd\n");

	mutex_unlock(&ha->fce_mutex);

	return 0;
}

static int
qla2x00_dfs_fce_open(struct inode *inode, struct file *file)
{
	scsi_qla_host_t *vha = inode->i_private;
	struct qla_hw_data *ha = vha->hw;
	int rval;

	if (!ha->flags.fce_enabled)
		goto out;

	mutex_lock(&ha->fce_mutex);

	/* Pause tracing to flush FCE buffers. */
	rval = qla2x00_disable_fce_trace(vha, &ha->fce_wr, &ha->fce_rd);
	if (rval)
		ql_dbg(ql_dbg_user, vha, 0x705c,
		    "DebugFS: Unable to disable FCE (%d).\n", rval);

	ha->flags.fce_enabled = 0;

	mutex_unlock(&ha->fce_mutex);
out:
	return single_open(file, qla2x00_dfs_fce_show, vha);
}

static int
qla2x00_dfs_fce_release(struct inode *inode, struct file *file)
{
	scsi_qla_host_t *vha = inode->i_private;
	struct qla_hw_data *ha = vha->hw;
	int rval;

	if (ha->flags.fce_enabled)
		goto out;

	mutex_lock(&ha->fce_mutex);

	/* Re-enable FCE tracing. */
	ha->flags.fce_enabled = 1;
	memset(ha->fce, 0, fce_calc_size(ha->fce_bufs));
	rval = qla2x00_enable_fce_trace(vha, ha->fce_dma, ha->fce_bufs,
	    ha->fce_mb, &ha->fce_bufs);
	if (rval) {
		ql_dbg(ql_dbg_user, vha, 0x700d,
		    "DebugFS: Unable to reinitialize FCE (%d).\n", rval);
		ha->flags.fce_enabled = 0;
	}

	mutex_unlock(&ha->fce_mutex);
out:
	return single_release(inode, file);
}

static const struct file_operations dfs_fce_ops = {
	.open		= qla2x00_dfs_fce_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= qla2x00_dfs_fce_release,
};

int
qla2x00_dfs_setup(scsi_qla_host_t *vha)
{
	struct qla_hw_data *ha = vha->hw;

	if (!IS_QLA25XX(ha) && !IS_QLA81XX(ha) && !IS_QLA83XX(ha) &&
	    !IS_QLA27XX(ha))
		goto out;
	if (!ha->fce)
		goto out;

	if (qla2x00_dfs_root)
		goto create_dir;

	atomic_set(&qla2x00_dfs_root_count, 0);
	qla2x00_dfs_root = debugfs_create_dir(QLA2XXX_DRIVER_NAME, NULL);
	if (!qla2x00_dfs_root) {
		ql_log(ql_log_warn, vha, 0x00f7,
		    "Unable to create debugfs root directory.\n");
		goto out;
	}

create_dir:
	if (ha->dfs_dir)
		goto create_nodes;

	mutex_init(&ha->fce_mutex);
	ha->dfs_dir = debugfs_create_dir(vha->host_str, qla2x00_dfs_root);
	if (!ha->dfs_dir) {
		ql_log(ql_log_warn, vha, 0x00f8,
		    "Unable to create debugfs ha directory.\n");
		goto out;
	}

	atomic_inc(&qla2x00_dfs_root_count);

create_nodes:
	ha->dfs_fw_resource_cnt = debugfs_create_file("fw_resource_count",
	    S_IRUSR, ha->dfs_dir, vha, &dfs_fw_resource_cnt_ops);
	if (!ha->dfs_fw_resource_cnt) {
		ql_log(ql_log_warn, vha, 0x00fd,
		    "Unable to create debugFS fw_resource_count node.\n");
		goto out;
	}

	ha->dfs_tgt_counters = debugfs_create_file("tgt_counters", S_IRUSR,
	    ha->dfs_dir, vha, &dfs_tgt_counters_ops);
	if (!ha->dfs_tgt_counters) {
		ql_log(ql_log_warn, vha, 0xd301,
		    "Unable to create debugFS tgt_counters node.\n");
		goto out;
	}

	ha->dfs_fce = debugfs_create_file("fce", S_IRUSR, ha->dfs_dir, vha,
	    &dfs_fce_ops);
	if (!ha->dfs_fce) {
		ql_log(ql_log_warn, vha, 0x00f9,
		    "Unable to create debugfs fce node.\n");
		goto out;
	}

	ha->tgt.dfs_tgt_sess = debugfs_create_file("tgt_sess",
		S_IRUSR, ha->dfs_dir, vha, &dfs_tgt_sess_ops);
	if (!ha->tgt.dfs_tgt_sess) {
		ql_log(ql_log_warn, vha, 0xffff,
			"Unable to create debugFS tgt_sess node.\n");
		goto out;
	}

out:
	return 0;
}

int
qla2x00_dfs_remove(scsi_qla_host_t *vha)
{
	struct qla_hw_data *ha = vha->hw;

	if (ha->tgt.dfs_tgt_sess) {
		debugfs_remove(ha->tgt.dfs_tgt_sess);
		ha->tgt.dfs_tgt_sess = NULL;
	}

	if (ha->dfs_fw_resource_cnt) {
		debugfs_remove(ha->dfs_fw_resource_cnt);
		ha->dfs_fw_resource_cnt = NULL;
	}

	if (ha->dfs_tgt_counters) {
		debugfs_remove(ha->dfs_tgt_counters);
		ha->dfs_tgt_counters = NULL;
	}

	if (ha->dfs_fce) {
		debugfs_remove(ha->dfs_fce);
		ha->dfs_fce = NULL;
	}

	if (ha->dfs_dir) {
		debugfs_remove(ha->dfs_dir);
		ha->dfs_dir = NULL;
		atomic_dec(&qla2x00_dfs_root_count);
	}

	if (atomic_read(&qla2x00_dfs_root_count) == 0 &&
	    qla2x00_dfs_root) {
		debugfs_remove(qla2x00_dfs_root);
		qla2x00_dfs_root = NULL;
	}

	return 0;
}
Commit	Line	Data
df613b96 AV	1	/*
df613b96 AV	2	* QLogic Fibre Channel HBA Driver
bd21eaf9	3	* Copyright (c) 2003-2014 QLogic Corporation
df613b96 AV	4	*
	5	* See LICENSE.qla2xxx for copyright and licensing details.
	6	*/
	7	#include "qla_def.h"
	8
	9	#include <linux/debugfs.h>
	10	#include <linux/seq_file.h>
	11
	12	static struct dentry *qla2x00_dfs_root;
	13	static atomic_t qla2x00_dfs_root_count;
	14
36c78452 QT	15	static int
	16	qla2x00_dfs_tgt_sess_show(struct seq_file s, void unused)
	17	{
	18	scsi_qla_host_t *vha = s->private;
	19	struct qla_hw_data *ha = vha->hw;
	20	unsigned long flags;
	21	struct qla_tgt_sess *sess = NULL;
	22	struct qla_tgt *tgt= vha->vha_tgt.qla_tgt;
	23
	24	seq_printf(s, "%s\n",vha->host_str);
	25	if (tgt) {
	26	seq_printf(s, "Port ID Port Name Handle\n");
	27
	28	spin_lock_irqsave(&ha->tgt.sess_lock, flags);
	29	list_for_each_entry(sess, &tgt->sess_list, sess_list_entry) {
	30	seq_printf(s, "%02x:%02x:%02x %8phC %d\n",
	31	sess->s_id.b.domain,sess->s_id.b.area,
	32	sess->s_id.b.al_pa, sess->port_name,
	33	sess->loop_id);
	34	}
	35	spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
	36	}
	37
	38	return 0;
	39	}
	40
	41	static int
	42	qla2x00_dfs_tgt_sess_open(struct inode inode, struct file file)
	43	{
	44	scsi_qla_host_t *vha = inode->i_private;
	45	return single_open(file, qla2x00_dfs_tgt_sess_show, vha);
	46	}
	47
	48
	49	static const struct file_operations dfs_tgt_sess_ops = {
	50	.open = qla2x00_dfs_tgt_sess_open,
	51	.read = seq_read,
	52	.llseek = seq_lseek,
	53	.release = single_release,
	54	};
	55
03e8c680 QT	56	static int
	57	qla_dfs_fw_resource_cnt_show(struct seq_file s, void unused)
	58	{
	59	struct scsi_qla_host *vha = s->private;
	60	struct qla_hw_data *ha = vha->hw;
	61
	62	seq_puts(s, "FW Resource count\n\n");
	63	seq_printf(s, "Original TGT exchg count[%d]\n",
	64	ha->orig_fw_tgt_xcb_count);
	65	seq_printf(s, "current TGT exchg count[%d]\n",
	66	ha->cur_fw_tgt_xcb_count);
	67	seq_printf(s, "original Initiator Exchange count[%d]\n",
	68	ha->orig_fw_xcb_count);
	69	seq_printf(s, "Current Initiator Exchange count[%d]\n",
	70	ha->cur_fw_xcb_count);
	71	seq_printf(s, "Original IOCB count[%d]\n", ha->orig_fw_iocb_count);
	72	seq_printf(s, "Current IOCB count[%d]\n", ha->cur_fw_iocb_count);
	73	seq_printf(s, "MAX VP count[%d]\n", ha->max_npiv_vports);
	74	seq_printf(s, "MAX FCF count[%d]\n", ha->fw_max_fcf_count);
	75
	76	return 0;
	77	}
	78
	79	static int
	80	qla_dfs_fw_resource_cnt_open(struct inode inode, struct file file)
	81	{
	82	struct scsi_qla_host *vha = inode->i_private;
	83	return single_open(file, qla_dfs_fw_resource_cnt_show, vha);
	84	}
	85
	86	static const struct file_operations dfs_fw_resource_cnt_ops = {
	87	.open = qla_dfs_fw_resource_cnt_open,
	88	.read = seq_read,
	89	.llseek = seq_lseek,
	90	.release = single_release,
	91	};
	92
ce1025cd HM	93	static int
	94	qla_dfs_tgt_counters_show(struct seq_file s, void unused)
	95	{
	96	struct scsi_qla_host *vha = s->private;
	97
	98	seq_puts(s, "Target Counters\n");
	99	seq_printf(s, "qla_core_sbt_cmd = %lld\n",
	100	vha->tgt_counters.qla_core_sbt_cmd);
	101	seq_printf(s, "qla_core_ret_sta_ctio = %lld\n",
	102	vha->tgt_counters.qla_core_ret_sta_ctio);
	103	seq_printf(s, "qla_core_ret_ctio = %lld\n",
	104	vha->tgt_counters.qla_core_ret_ctio);
	105	seq_printf(s, "core_qla_que_buf = %lld\n",
	106	vha->tgt_counters.core_qla_que_buf);
	107	seq_printf(s, "core_qla_snd_status = %lld\n",
	108	vha->tgt_counters.core_qla_snd_status);
	109	seq_printf(s, "core_qla_free_cmd = %lld\n",
	110	vha->tgt_counters.core_qla_free_cmd);
	111	seq_printf(s, "num alloc iocb failed = %lld\n",
	112	vha->tgt_counters.num_alloc_iocb_failed);
	113	seq_printf(s, "num term exchange sent = %lld\n",
	114	vha->tgt_counters.num_term_xchg_sent);
	115	seq_printf(s, "num Q full sent = %lld\n",
	116	vha->tgt_counters.num_q_full_sent);
	117
	118	return 0;
	119	}
	120
	121	static int
	122	qla_dfs_tgt_counters_open(struct inode inode, struct file file)
	123	{
	124	struct scsi_qla_host *vha = inode->i_private;
	125	return single_open(file, qla_dfs_tgt_counters_show, vha);
	126	}
	127
	128	static const struct file_operations dfs_tgt_counters_ops = {
	129	.open = qla_dfs_tgt_counters_open,
	130	.read = seq_read,
	131	.llseek = seq_lseek,
	132	.release = single_release,
	133	};
	134
df613b96 AV	135	static int
	136	qla2x00_dfs_fce_show(struct seq_file s, void unused)
	137	{
7b867cf7	138	scsi_qla_host_t *vha = s->private;
df613b96 AV	139	uint32_t cnt;
	140	uint32_t *fce;
	141	uint64_t fce_start;
7b867cf7	142	struct qla_hw_data *ha = vha->hw;
df613b96 AV	143
	144	mutex_lock(&ha->fce_mutex);
	145
91c40f24	146	seq_puts(s, "FCE Trace Buffer\n");
279e7f54	147	seq_printf(s, "In Pointer = %llx\n\n", (unsigned long long)ha->fce_wr);
df613b96	148	seq_printf(s, "Base = %llx\n\n", (unsigned long long) ha->fce_dma);
91c40f24	149	seq_puts(s, "FCE Enable Registers\n");
df613b96 AV	150	seq_printf(s, "%08x %08x %08x %08x %08x %08x\n",
	151	ha->fce_mb[0], ha->fce_mb[2], ha->fce_mb[3], ha->fce_mb[4],
	152	ha->fce_mb[5], ha->fce_mb[6]);
	153
	154	fce = (uint32_t *) ha->fce;
	155	fce_start = (unsigned long long) ha->fce_dma;
	156	for (cnt = 0; cnt < fce_calc_size(ha->fce_bufs) / 4; cnt++) {
	157	if (cnt % 8 == 0)
	158	seq_printf(s, "\n%llx: ",
	159	(unsigned long long)((cnt * 4) + fce_start));
	160	else
f50332ff	161	seq_putc(s, ' ');
df613b96 AV	162	seq_printf(s, "%08x", *fce++);
	163	}
	164
91c40f24	165	seq_puts(s, "\nEnd\n");
df613b96 AV	166
	167	mutex_unlock(&ha->fce_mutex);
	168
	169	return 0;
	170	}
	171
	172	static int
	173	qla2x00_dfs_fce_open(struct inode inode, struct file file)
	174	{
7b867cf7 AC	175	scsi_qla_host_t *vha = inode->i_private;
7b867cf7 AC	176	struct qla_hw_data *ha = vha->hw;
df613b96 AV	177	int rval;
	178
	179	if (!ha->flags.fce_enabled)
	180	goto out;
	181
	182	mutex_lock(&ha->fce_mutex);
	183
	184	/* Pause tracing to flush FCE buffers. */
7b867cf7	185	rval = qla2x00_disable_fce_trace(vha, &ha->fce_wr, &ha->fce_rd);
df613b96	186	if (rval)
7c3df132	187	ql_dbg(ql_dbg_user, vha, 0x705c,
df613b96 AV	188	"DebugFS: Unable to disable FCE (%d).\n", rval);
	189
	190	ha->flags.fce_enabled = 0;
	191
	192	mutex_unlock(&ha->fce_mutex);
	193	out:
94279ede	194	return single_open(file, qla2x00_dfs_fce_show, vha);
df613b96 AV	195	}
	196
	197	static int
	198	qla2x00_dfs_fce_release(struct inode inode, struct file file)
	199	{
7b867cf7 AC	200	scsi_qla_host_t *vha = inode->i_private;
7b867cf7 AC	201	struct qla_hw_data *ha = vha->hw;
df613b96 AV	202	int rval;
	203
	204	if (ha->flags.fce_enabled)
	205	goto out;
	206
	207	mutex_lock(&ha->fce_mutex);
	208
	209	/* Re-enable FCE tracing. */
	210	ha->flags.fce_enabled = 1;
	211	memset(ha->fce, 0, fce_calc_size(ha->fce_bufs));
7b867cf7	212	rval = qla2x00_enable_fce_trace(vha, ha->fce_dma, ha->fce_bufs,
df613b96 AV	213	ha->fce_mb, &ha->fce_bufs);
df613b96 AV	214	if (rval) {
7c3df132	215	ql_dbg(ql_dbg_user, vha, 0x700d,
df613b96 AV	216	"DebugFS: Unable to reinitialize FCE (%d).\n", rval);
	217	ha->flags.fce_enabled = 0;
	218	}
	219
	220	mutex_unlock(&ha->fce_mutex);
	221	out:
	222	return single_release(inode, file);
	223	}
	224
	225	static const struct file_operations dfs_fce_ops = {
	226	.open = qla2x00_dfs_fce_open,
	227	.read = seq_read,
	228	.llseek = seq_lseek,
	229	.release = qla2x00_dfs_fce_release,
	230	};
	231
	232	int
7b867cf7	233	qla2x00_dfs_setup(scsi_qla_host_t *vha)
df613b96	234	{
7b867cf7	235	struct qla_hw_data *ha = vha->hw;
3a03eb79	236
f73cb695 CD	237	if (!IS_QLA25XX(ha) && !IS_QLA81XX(ha) && !IS_QLA83XX(ha) &&
f73cb695 CD	238	!IS_QLA27XX(ha))
df613b96 AV	239	goto out;
	240	if (!ha->fce)
	241	goto out;
	242
	243	if (qla2x00_dfs_root)
	244	goto create_dir;
	245
	246	atomic_set(&qla2x00_dfs_root_count, 0);
	247	qla2x00_dfs_root = debugfs_create_dir(QLA2XXX_DRIVER_NAME, NULL);
	248	if (!qla2x00_dfs_root) {
7c3df132 SK	249	ql_log(ql_log_warn, vha, 0x00f7,
7c3df132 SK	250	"Unable to create debugfs root directory.\n");
df613b96 AV	251	goto out;
	252	}
	253
	254	create_dir:
	255	if (ha->dfs_dir)
	256	goto create_nodes;
	257
	258	mutex_init(&ha->fce_mutex);
7b867cf7	259	ha->dfs_dir = debugfs_create_dir(vha->host_str, qla2x00_dfs_root);
df613b96	260	if (!ha->dfs_dir) {
7c3df132 SK	261	ql_log(ql_log_warn, vha, 0x00f8,
7c3df132 SK	262	"Unable to create debugfs ha directory.\n");
df613b96 AV	263	goto out;
	264	}
	265
	266	atomic_inc(&qla2x00_dfs_root_count);
	267
	268	create_nodes:
03e8c680 QT	269	ha->dfs_fw_resource_cnt = debugfs_create_file("fw_resource_count",
	270	S_IRUSR, ha->dfs_dir, vha, &dfs_fw_resource_cnt_ops);
	271	if (!ha->dfs_fw_resource_cnt) {
	272	ql_log(ql_log_warn, vha, 0x00fd,
	273	"Unable to create debugFS fw_resource_count node.\n");
	274	goto out;
	275	}
	276
ce1025cd HM	277	ha->dfs_tgt_counters = debugfs_create_file("tgt_counters", S_IRUSR,
	278	ha->dfs_dir, vha, &dfs_tgt_counters_ops);
	279	if (!ha->dfs_tgt_counters) {
	280	ql_log(ql_log_warn, vha, 0xd301,
	281	"Unable to create debugFS tgt_counters node.\n");
	282	goto out;
	283	}
	284
94279ede	285	ha->dfs_fce = debugfs_create_file("fce", S_IRUSR, ha->dfs_dir, vha,
df613b96 AV	286	&dfs_fce_ops);
df613b96 AV	287	if (!ha->dfs_fce) {
7c3df132 SK	288	ql_log(ql_log_warn, vha, 0x00f9,
7c3df132 SK	289	"Unable to create debugfs fce node.\n");
df613b96 AV	290	goto out;
df613b96 AV	291	}
36c78452 QT	292
	293	ha->tgt.dfs_tgt_sess = debugfs_create_file("tgt_sess",
	294	S_IRUSR, ha->dfs_dir, vha, &dfs_tgt_sess_ops);
	295	if (!ha->tgt.dfs_tgt_sess) {
	296	ql_log(ql_log_warn, vha, 0xffff,
	297	"Unable to create debugFS tgt_sess node.\n");
	298	goto out;
	299	}
	300
df613b96 AV	301	out:
	302	return 0;
	303	}
	304
	305	int
7b867cf7	306	qla2x00_dfs_remove(scsi_qla_host_t *vha)
df613b96	307	{
7b867cf7	308	struct qla_hw_data *ha = vha->hw;
ce1025cd	309
36c78452 QT	310	if (ha->tgt.dfs_tgt_sess) {
	311	debugfs_remove(ha->tgt.dfs_tgt_sess);
	312	ha->tgt.dfs_tgt_sess = NULL;
	313	}
	314
03e8c680 QT	315	if (ha->dfs_fw_resource_cnt) {
	316	debugfs_remove(ha->dfs_fw_resource_cnt);
	317	ha->dfs_fw_resource_cnt = NULL;
	318	}
	319
ce1025cd HM	320	if (ha->dfs_tgt_counters) {
	321	debugfs_remove(ha->dfs_tgt_counters);
	322	ha->dfs_tgt_counters = NULL;
	323	}
	324
df613b96 AV	325	if (ha->dfs_fce) {
	326	debugfs_remove(ha->dfs_fce);
	327	ha->dfs_fce = NULL;
	328	}
	329
	330	if (ha->dfs_dir) {
	331	debugfs_remove(ha->dfs_dir);
	332	ha->dfs_dir = NULL;
	333	atomic_dec(&qla2x00_dfs_root_count);
	334	}
	335
	336	if (atomic_read(&qla2x00_dfs_root_count) == 0 &&
	337	qla2x00_dfs_root) {
	338	debugfs_remove(qla2x00_dfs_root);
	339	qla2x00_dfs_root = NULL;
	340	}
	341
	342	return 0;
	343	}