[mirror_ubuntu-artful-kernel.git] / net / batman-adv / debugfs.c

/* Copyright (C) 2010-2016  B.A.T.M.A.N. contributors:
 *
 * Marek Lindner
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of version 2 of the GNU General Public
 * License as published by the Free Software Foundation.
 *
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include "debugfs.h"
#include "main.h"

#include <linux/debugfs.h>
#include <linux/device.h>
#include <linux/errno.h>
#include <linux/export.h>
#include <linux/fs.h>
#include <linux/netdevice.h>
#include <linux/printk.h>
#include <linux/sched.h> /* for linux/wait.h */
#include <linux/seq_file.h>
#include <linux/stat.h>
#include <linux/stddef.h>
#include <linux/stringify.h>
#include <linux/sysfs.h>

#include "bat_algo.h"
#include "bridge_loop_avoidance.h"
#include "distributed-arp-table.h"
#include "gateway_client.h"
#include "icmp_socket.h"
#include "log.h"
#include "multicast.h"
#include "network-coding.h"
#include "originator.h"
#include "translation-table.h"

static struct dentry *batadv_debugfs;

static int batadv_algorithms_open(struct inode *inode, struct file *file)
{
	return single_open(file, batadv_algo_seq_print_text, NULL);
}

static int neighbors_open(struct inode *inode, struct file *file)
{
	struct net_device *net_dev = (struct net_device *)inode->i_private;

	return single_open(file, batadv_hardif_neigh_seq_print_text, net_dev);
}

static int batadv_originators_open(struct inode *inode, struct file *file)
{
	struct net_device *net_dev = (struct net_device *)inode->i_private;

	return single_open(file, batadv_orig_seq_print_text, net_dev);
}

/**
 * batadv_originators_hardif_open - handles debugfs output for the
 *  originator table of an hard interface
 * @inode: inode pointer to debugfs file
 * @file: pointer to the seq_file
 *
 * Return: 0 on success or negative error number in case of failure
 */
static int batadv_originators_hardif_open(struct inode *inode,
					  struct file *file)
{
	struct net_device *net_dev = (struct net_device *)inode->i_private;

	return single_open(file, batadv_orig_hardif_seq_print_text, net_dev);
}

static int batadv_gateways_open(struct inode *inode, struct file *file)
{
	struct net_device *net_dev = (struct net_device *)inode->i_private;

	return single_open(file, batadv_gw_client_seq_print_text, net_dev);
}

static int batadv_transtable_global_open(struct inode *inode, struct file *file)
{
	struct net_device *net_dev = (struct net_device *)inode->i_private;

	return single_open(file, batadv_tt_global_seq_print_text, net_dev);
}

#ifdef CONFIG_BATMAN_ADV_BLA
static int batadv_bla_claim_table_open(struct inode *inode, struct file *file)
{
	struct net_device *net_dev = (struct net_device *)inode->i_private;

	return single_open(file, batadv_bla_claim_table_seq_print_text,
			   net_dev);
}

static int batadv_bla_backbone_table_open(struct inode *inode,
					  struct file *file)
{
	struct net_device *net_dev = (struct net_device *)inode->i_private;

	return single_open(file, batadv_bla_backbone_table_seq_print_text,
			   net_dev);
}

#endif

#ifdef CONFIG_BATMAN_ADV_DAT
/**
 * batadv_dat_cache_open - Prepare file handler for reads from dat_chache
 * @inode: inode which was opened
 * @file: file handle to be initialized
 *
 * Return: 0 on success or negative error number in case of failure
 */
static int batadv_dat_cache_open(struct inode *inode, struct file *file)
{
	struct net_device *net_dev = (struct net_device *)inode->i_private;

	return single_open(file, batadv_dat_cache_seq_print_text, net_dev);
}
#endif

static int batadv_transtable_local_open(struct inode *inode, struct file *file)
{
	struct net_device *net_dev = (struct net_device *)inode->i_private;

	return single_open(file, batadv_tt_local_seq_print_text, net_dev);
}

struct batadv_debuginfo {
	struct attribute attr;
	const struct file_operations fops;
};

#ifdef CONFIG_BATMAN_ADV_NC
static int batadv_nc_nodes_open(struct inode *inode, struct file *file)
{
	struct net_device *net_dev = (struct net_device *)inode->i_private;

	return single_open(file, batadv_nc_nodes_seq_print_text, net_dev);
}
#endif

#ifdef CONFIG_BATMAN_ADV_MCAST
/**
 * batadv_mcast_flags_open - prepare file handler for reads from mcast_flags
 * @inode: inode which was opened
 * @file: file handle to be initialized
 *
 * Return: 0 on success or negative error number in case of failure
 */
static int batadv_mcast_flags_open(struct inode *inode, struct file *file)
{
	struct net_device *net_dev = (struct net_device *)inode->i_private;

	return single_open(file, batadv_mcast_flags_seq_print_text, net_dev);
}
#endif

#define BATADV_DEBUGINFO(_name, _mode, _open)		\
struct batadv_debuginfo batadv_debuginfo_##_name = {	\
	.attr = {					\
		.name = __stringify(_name),		\
		.mode = _mode,				\
	},						\
	.fops = {					\
		.owner = THIS_MODULE,			\
		.open = _open,				\
		.read	= seq_read,			\
		.llseek = seq_lseek,			\
		.release = single_release,		\
	},						\
}

/* the following attributes are general and therefore they will be directly
 * placed in the BATADV_DEBUGFS_SUBDIR subdirectory of debugfs
 */
static BATADV_DEBUGINFO(routing_algos, S_IRUGO, batadv_algorithms_open);

static struct batadv_debuginfo *batadv_general_debuginfos[] = {
	&batadv_debuginfo_routing_algos,
	NULL,
};

/* The following attributes are per soft interface */
static BATADV_DEBUGINFO(neighbors, S_IRUGO, neighbors_open);
static BATADV_DEBUGINFO(originators, S_IRUGO, batadv_originators_open);
static BATADV_DEBUGINFO(gateways, S_IRUGO, batadv_gateways_open);
static BATADV_DEBUGINFO(transtable_global, S_IRUGO,
			batadv_transtable_global_open);
#ifdef CONFIG_BATMAN_ADV_BLA
static BATADV_DEBUGINFO(bla_claim_table, S_IRUGO, batadv_bla_claim_table_open);
static BATADV_DEBUGINFO(bla_backbone_table, S_IRUGO,
			batadv_bla_backbone_table_open);
#endif
#ifdef CONFIG_BATMAN_ADV_DAT
static BATADV_DEBUGINFO(dat_cache, S_IRUGO, batadv_dat_cache_open);
#endif
static BATADV_DEBUGINFO(transtable_local, S_IRUGO,
			batadv_transtable_local_open);
#ifdef CONFIG_BATMAN_ADV_NC
static BATADV_DEBUGINFO(nc_nodes, S_IRUGO, batadv_nc_nodes_open);
#endif
#ifdef CONFIG_BATMAN_ADV_MCAST
static BATADV_DEBUGINFO(mcast_flags, S_IRUGO, batadv_mcast_flags_open);
#endif

static struct batadv_debuginfo *batadv_mesh_debuginfos[] = {
	&batadv_debuginfo_neighbors,
	&batadv_debuginfo_originators,
	&batadv_debuginfo_gateways,
	&batadv_debuginfo_transtable_global,
#ifdef CONFIG_BATMAN_ADV_BLA
	&batadv_debuginfo_bla_claim_table,
	&batadv_debuginfo_bla_backbone_table,
#endif
#ifdef CONFIG_BATMAN_ADV_DAT
	&batadv_debuginfo_dat_cache,
#endif
	&batadv_debuginfo_transtable_local,
#ifdef CONFIG_BATMAN_ADV_NC
	&batadv_debuginfo_nc_nodes,
#endif
#ifdef CONFIG_BATMAN_ADV_MCAST
	&batadv_debuginfo_mcast_flags,
#endif
	NULL,
};

#define BATADV_HARDIF_DEBUGINFO(_name, _mode, _open)		\
struct batadv_debuginfo batadv_hardif_debuginfo_##_name = {	\
	.attr = {						\
		.name = __stringify(_name),			\
		.mode = _mode,					\
	},							\
	.fops = {						\
		.owner = THIS_MODULE,				\
		.open = _open,					\
		.read	= seq_read,				\
		.llseek = seq_lseek,				\
		.release = single_release,			\
	},							\
}

static BATADV_HARDIF_DEBUGINFO(originators, S_IRUGO,
			       batadv_originators_hardif_open);

static struct batadv_debuginfo *batadv_hardif_debuginfos[] = {
	&batadv_hardif_debuginfo_originators,
	NULL,
};

void batadv_debugfs_init(void)
{
	struct batadv_debuginfo **bat_debug;
	struct dentry *file;

	batadv_debugfs = debugfs_create_dir(BATADV_DEBUGFS_SUBDIR, NULL);
	if (batadv_debugfs == ERR_PTR(-ENODEV))
		batadv_debugfs = NULL;

	if (!batadv_debugfs)
		goto err;

	for (bat_debug = batadv_general_debuginfos; *bat_debug; ++bat_debug) {
		file = debugfs_create_file(((*bat_debug)->attr).name,
					   S_IFREG | ((*bat_debug)->attr).mode,
					   batadv_debugfs, NULL,
					   &(*bat_debug)->fops);
		if (!file) {
			pr_err("Can't add general debugfs file: %s\n",
			       ((*bat_debug)->attr).name);
			goto err;
		}
	}

	return;
err:
	debugfs_remove_recursive(batadv_debugfs);
	batadv_debugfs = NULL;
}

void batadv_debugfs_destroy(void)
{
	debugfs_remove_recursive(batadv_debugfs);
	batadv_debugfs = NULL;
}

/**
 * batadv_debugfs_add_hardif - creates the base directory for a hard interface
 *  in debugfs.
 * @hard_iface: hard interface which should be added.
 *
 * Return: 0 on success or negative error number in case of failure
 */
int batadv_debugfs_add_hardif(struct batadv_hard_iface *hard_iface)
{
	struct batadv_debuginfo **bat_debug;
	struct dentry *file;

	if (!batadv_debugfs)
		goto out;

	hard_iface->debug_dir = debugfs_create_dir(hard_iface->net_dev->name,
						   batadv_debugfs);
	if (!hard_iface->debug_dir)
		goto out;

	for (bat_debug = batadv_hardif_debuginfos; *bat_debug; ++bat_debug) {
		file = debugfs_create_file(((*bat_debug)->attr).name,
					   S_IFREG | ((*bat_debug)->attr).mode,
					   hard_iface->debug_dir,
					   hard_iface->net_dev,
					   &(*bat_debug)->fops);
		if (!file)
			goto rem_attr;
	}

	return 0;
rem_attr:
	debugfs_remove_recursive(hard_iface->debug_dir);
	hard_iface->debug_dir = NULL;
out:
	return -ENOMEM;
}

/**
 * batadv_debugfs_del_hardif - delete the base directory for a hard interface
 *  in debugfs.
 * @hard_iface: hard interface which is deleted.
 */
void batadv_debugfs_del_hardif(struct batadv_hard_iface *hard_iface)
{
	if (batadv_debugfs) {
		debugfs_remove_recursive(hard_iface->debug_dir);
		hard_iface->debug_dir = NULL;
	}
}

int batadv_debugfs_add_meshif(struct net_device *dev)
{
	struct batadv_priv *bat_priv = netdev_priv(dev);
	struct batadv_debuginfo **bat_debug;
	struct dentry *file;

	if (!batadv_debugfs)
		goto out;

	bat_priv->debug_dir = debugfs_create_dir(dev->name, batadv_debugfs);
	if (!bat_priv->debug_dir)
		goto out;

	if (batadv_socket_setup(bat_priv) < 0)
		goto rem_attr;

	if (batadv_debug_log_setup(bat_priv) < 0)
		goto rem_attr;

	for (bat_debug = batadv_mesh_debuginfos; *bat_debug; ++bat_debug) {
		file = debugfs_create_file(((*bat_debug)->attr).name,
					   S_IFREG | ((*bat_debug)->attr).mode,
					   bat_priv->debug_dir,
					   dev, &(*bat_debug)->fops);
		if (!file) {
			batadv_err(dev, "Can't add debugfs file: %s/%s\n",
				   dev->name, ((*bat_debug)->attr).name);
			goto rem_attr;
		}
	}

	if (batadv_nc_init_debugfs(bat_priv) < 0)
		goto rem_attr;

	return 0;
rem_attr:
	debugfs_remove_recursive(bat_priv->debug_dir);
	bat_priv->debug_dir = NULL;
out:
	return -ENOMEM;
}

void batadv_debugfs_del_meshif(struct net_device *dev)
{
	struct batadv_priv *bat_priv = netdev_priv(dev);

	batadv_debug_log_cleanup(bat_priv);

	if (batadv_debugfs) {
		debugfs_remove_recursive(bat_priv->debug_dir);
		bat_priv->debug_dir = NULL;
	}
}
Commit	Line	Data
0046b040	1	/* Copyright (C) 2010-2016 B.A.T.M.A.N. contributors:
c6c8fea2 SE	2	*
	3	* Marek Lindner
	4	*
	5	* This program is free software; you can redistribute it and/or
	6	* modify it under the terms of version 2 of the GNU General Public
	7	* License as published by the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope that it will be useful, but
	10	* WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	12	* General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
ebf38fb7	15	* along with this program; if not, see <http://www.gnu.org/licenses/>.
c6c8fea2 SE	16	*/
c6c8fea2 SE	17
1e2c2a4f	18	#include "debugfs.h"
c6c8fea2 SE	19	#include "main.h"
	20
	21	#include <linux/debugfs.h>
1e2c2a4f SE	22	#include <linux/device.h>
	23	#include <linux/errno.h>
	24	#include <linux/export.h>
1e2c2a4f	25	#include <linux/fs.h>
1e2c2a4f	26	#include <linux/netdevice.h>
1e2c2a4f SE	27	#include <linux/printk.h>
	28	#include <linux/sched.h> /* for linux/wait.h */
	29	#include <linux/seq_file.h>
1e2c2a4f SE	30	#include <linux/stat.h>
	31	#include <linux/stddef.h>
	32	#include <linux/stringify.h>
	33	#include <linux/sysfs.h>
c6c8fea2	34
01d350d1	35	#include "bat_algo.h"
9bf8e4d4	36	#include "bridge_loop_avoidance.h"
2f1dfbe1	37	#include "distributed-arp-table.h"
1e2c2a4f SE	38	#include "gateway_client.h"
1e2c2a4f SE	39	#include "icmp_socket.h"
ba412080	40	#include "log.h"
4e3e823b	41	#include "multicast.h"
d56b1705	42	#include "network-coding.h"
1e2c2a4f SE	43	#include "originator.h"
1e2c2a4f SE	44	#include "translation-table.h"
c6c8fea2	45
9e466250	46	static struct dentry *batadv_debugfs;
c6c8fea2	47
9e466250	48	static int batadv_algorithms_open(struct inode inode, struct file file)
1c280471	49	{
3193e8fd	50	return single_open(file, batadv_algo_seq_print_text, NULL);
1c280471 ML	51	}
1c280471 ML	52
7587405a ML	53	static int neighbors_open(struct inode inode, struct file file)
	54	{
	55	struct net_device net_dev = (struct net_device )inode->i_private;
	56
	57	return single_open(file, batadv_hardif_neigh_seq_print_text, net_dev);
	58	}
	59
9e466250	60	static int batadv_originators_open(struct inode inode, struct file file)
c6c8fea2 SE	61	{
c6c8fea2 SE	62	struct net_device net_dev = (struct net_device )inode->i_private;
f138694b	63
7d211efc	64	return single_open(file, batadv_orig_seq_print_text, net_dev);
c6c8fea2 SE	65	}
c6c8fea2 SE	66
cb1c92ec SW	67	/**
	68	* batadv_originators_hardif_open - handles debugfs output for the
	69	* originator table of an hard interface
	70	* @inode: inode pointer to debugfs file
	71	* @file: pointer to the seq_file
7afcbbef SE	72	*
7afcbbef SE	73	* Return: 0 on success or negative error number in case of failure
cb1c92ec SW	74	*/
	75	static int batadv_originators_hardif_open(struct inode *inode,
	76	struct file *file)
	77	{
	78	struct net_device net_dev = (struct net_device )inode->i_private;
f138694b	79
cb1c92ec SW	80	return single_open(file, batadv_orig_hardif_seq_print_text, net_dev);
	81	}
	82
9e466250	83	static int batadv_gateways_open(struct inode inode, struct file file)
c6c8fea2 SE	84	{
c6c8fea2 SE	85	struct net_device net_dev = (struct net_device )inode->i_private;
f138694b	86
7cf06bc6	87	return single_open(file, batadv_gw_client_seq_print_text, net_dev);
c6c8fea2 SE	88	}
c6c8fea2 SE	89
9e466250	90	static int batadv_transtable_global_open(struct inode inode, struct file file)
c6c8fea2 SE	91	{
c6c8fea2 SE	92	struct net_device net_dev = (struct net_device )inode->i_private;
f138694b	93
08c36d3e	94	return single_open(file, batadv_tt_global_seq_print_text, net_dev);
c6c8fea2 SE	95	}
c6c8fea2 SE	96
7a5cc242	97	#ifdef CONFIG_BATMAN_ADV_BLA
9e466250	98	static int batadv_bla_claim_table_open(struct inode inode, struct file file)
9bf8e4d4 SW	99	{
9bf8e4d4 SW	100	struct net_device net_dev = (struct net_device )inode->i_private;
f138694b	101
08adf151 SE	102	return single_open(file, batadv_bla_claim_table_seq_print_text,
08adf151 SE	103	net_dev);
9bf8e4d4	104	}
536a23f1 SW	105
	106	static int batadv_bla_backbone_table_open(struct inode *inode,
	107	struct file *file)
	108	{
	109	struct net_device net_dev = (struct net_device )inode->i_private;
f138694b	110
536a23f1 SW	111	return single_open(file, batadv_bla_backbone_table_seq_print_text,
	112	net_dev);
	113	}
	114
7a5cc242	115	#endif
9bf8e4d4	116
17224474	117	#ifdef CONFIG_BATMAN_ADV_DAT
2f1dfbe1 AQ	118	/**
	119	* batadv_dat_cache_open - Prepare file handler for reads from dat_chache
	120	* @inode: inode which was opened
	121	* @file: file handle to be initialized
7afcbbef SE	122	*
7afcbbef SE	123	* Return: 0 on success or negative error number in case of failure
2f1dfbe1 AQ	124	*/
	125	static int batadv_dat_cache_open(struct inode inode, struct file file)
	126	{
	127	struct net_device net_dev = (struct net_device )inode->i_private;
f138694b	128
2f1dfbe1 AQ	129	return single_open(file, batadv_dat_cache_seq_print_text, net_dev);
2f1dfbe1 AQ	130	}
17224474	131	#endif
2f1dfbe1	132
9e466250	133	static int batadv_transtable_local_open(struct inode inode, struct file file)
c6c8fea2 SE	134	{
c6c8fea2 SE	135	struct net_device net_dev = (struct net_device )inode->i_private;
f138694b	136
08c36d3e	137	return single_open(file, batadv_tt_local_seq_print_text, net_dev);
c6c8fea2 SE	138	}
c6c8fea2 SE	139
7f223c0c	140	struct batadv_debuginfo {
c6c8fea2 SE	141	struct attribute attr;
	142	const struct file_operations fops;
	143	};
	144
d56b1705 MH	145	#ifdef CONFIG_BATMAN_ADV_NC
	146	static int batadv_nc_nodes_open(struct inode inode, struct file file)
	147	{
	148	struct net_device net_dev = (struct net_device )inode->i_private;
f138694b	149
d56b1705 MH	150	return single_open(file, batadv_nc_nodes_seq_print_text, net_dev);
	151	}
	152	#endif
	153
4e3e823b LL	154	#ifdef CONFIG_BATMAN_ADV_MCAST
	155	/**
	156	* batadv_mcast_flags_open - prepare file handler for reads from mcast_flags
	157	* @inode: inode which was opened
	158	* @file: file handle to be initialized
	159	*
	160	* Return: 0 on success or negative error number in case of failure
	161	*/
	162	static int batadv_mcast_flags_open(struct inode inode, struct file file)
	163	{
	164	struct net_device net_dev = (struct net_device )inode->i_private;
	165
	166	return single_open(file, batadv_mcast_flags_seq_print_text, net_dev);
	167	}
	168	#endif
	169
347c80f0	170	#define BATADV_DEBUGINFO(_name, _mode, _open) \
7f223c0c	171	struct batadv_debuginfo batadv_debuginfo_##_name = { \
121bdca0 SW	172	.attr = { \
	173	.name = __stringify(_name), \
	174	.mode = _mode, \
	175	}, \
	176	.fops = { \
	177	.owner = THIS_MODULE, \
	178	.open = _open, \
	179	.read = seq_read, \
	180	.llseek = seq_lseek, \
	181	.release = single_release, \
	182	}, \
2b64df20	183	}
c6c8fea2	184
637fbd12 AQ	185	/* the following attributes are general and therefore they will be directly
	186	* placed in the BATADV_DEBUGFS_SUBDIR subdirectory of debugfs
	187	*/
347c80f0	188	static BATADV_DEBUGINFO(routing_algos, S_IRUGO, batadv_algorithms_open);
637fbd12 AQ	189
	190	static struct batadv_debuginfo *batadv_general_debuginfos[] = {
	191	&batadv_debuginfo_routing_algos,
	192	NULL,
	193	};
	194
	195	/* The following attributes are per soft interface */
7587405a	196	static BATADV_DEBUGINFO(neighbors, S_IRUGO, neighbors_open);
347c80f0 SE	197	static BATADV_DEBUGINFO(originators, S_IRUGO, batadv_originators_open);
	198	static BATADV_DEBUGINFO(gateways, S_IRUGO, batadv_gateways_open);
	199	static BATADV_DEBUGINFO(transtable_global, S_IRUGO,
	200	batadv_transtable_global_open);
7a5cc242	201	#ifdef CONFIG_BATMAN_ADV_BLA
347c80f0	202	static BATADV_DEBUGINFO(bla_claim_table, S_IRUGO, batadv_bla_claim_table_open);
536a23f1 SW	203	static BATADV_DEBUGINFO(bla_backbone_table, S_IRUGO,
536a23f1 SW	204	batadv_bla_backbone_table_open);
7a5cc242	205	#endif
17224474	206	#ifdef CONFIG_BATMAN_ADV_DAT
2f1dfbe1	207	static BATADV_DEBUGINFO(dat_cache, S_IRUGO, batadv_dat_cache_open);
17224474	208	#endif
347c80f0 SE	209	static BATADV_DEBUGINFO(transtable_local, S_IRUGO,
347c80f0 SE	210	batadv_transtable_local_open);
d56b1705 MH	211	#ifdef CONFIG_BATMAN_ADV_NC
	212	static BATADV_DEBUGINFO(nc_nodes, S_IRUGO, batadv_nc_nodes_open);
	213	#endif
4e3e823b LL	214	#ifdef CONFIG_BATMAN_ADV_MCAST
	215	static BATADV_DEBUGINFO(mcast_flags, S_IRUGO, batadv_mcast_flags_open);
	216	#endif
c6c8fea2	217
7f223c0c	218	static struct batadv_debuginfo *batadv_mesh_debuginfos[] = {
7587405a	219	&batadv_debuginfo_neighbors,
9e466250 SE	220	&batadv_debuginfo_originators,
	221	&batadv_debuginfo_gateways,
	222	&batadv_debuginfo_transtable_global,
7a5cc242	223	#ifdef CONFIG_BATMAN_ADV_BLA
9e466250	224	&batadv_debuginfo_bla_claim_table,
536a23f1	225	&batadv_debuginfo_bla_backbone_table,
7a5cc242	226	#endif
17224474	227	#ifdef CONFIG_BATMAN_ADV_DAT
2f1dfbe1	228	&batadv_debuginfo_dat_cache,
17224474	229	#endif
9e466250	230	&batadv_debuginfo_transtable_local,
d56b1705 MH	231	#ifdef CONFIG_BATMAN_ADV_NC
d56b1705 MH	232	&batadv_debuginfo_nc_nodes,
4e3e823b LL	233	#endif
	234	#ifdef CONFIG_BATMAN_ADV_MCAST
	235	&batadv_debuginfo_mcast_flags,
d56b1705	236	#endif
c6c8fea2 SE	237	NULL,
	238	};
	239
5bc7c1eb SW	240	#define BATADV_HARDIF_DEBUGINFO(_name, _mode, _open) \
	241	struct batadv_debuginfo batadv_hardif_debuginfo_##_name = { \
	242	.attr = { \
	243	.name = __stringify(_name), \
	244	.mode = _mode, \
	245	}, \
	246	.fops = { \
	247	.owner = THIS_MODULE, \
	248	.open = _open, \
	249	.read = seq_read, \
	250	.llseek = seq_lseek, \
	251	.release = single_release, \
	252	}, \
2b64df20	253	}
aa143d28	254
cb1c92ec SW	255	static BATADV_HARDIF_DEBUGINFO(originators, S_IRUGO,
cb1c92ec SW	256	batadv_originators_hardif_open);
5bc7c1eb SW	257
5bc7c1eb SW	258	static struct batadv_debuginfo *batadv_hardif_debuginfos[] = {
cb1c92ec	259	&batadv_hardif_debuginfo_originators,
5bc7c1eb SW	260	NULL,
	261	};
	262
40a072d7	263	void batadv_debugfs_init(void)
c6c8fea2	264	{
637fbd12	265	struct batadv_debuginfo **bat_debug;
1c280471 ML	266	struct dentry *file;
1c280471 ML	267
54590e4d	268	batadv_debugfs = debugfs_create_dir(BATADV_DEBUGFS_SUBDIR, NULL);
9e466250 SE	269	if (batadv_debugfs == ERR_PTR(-ENODEV))
9e466250 SE	270	batadv_debugfs = NULL;
1c280471	271
9e466250	272	if (!batadv_debugfs)
637fbd12	273	goto err;
1c280471	274
637fbd12 AQ	275	for (bat_debug = batadv_general_debuginfos; *bat_debug; ++bat_debug) {
	276	file = debugfs_create_file(((*bat_debug)->attr).name,
	277	S_IFREG \| ((*bat_debug)->attr).mode,
	278	batadv_debugfs, NULL,
	279	&(*bat_debug)->fops);
	280	if (!file) {
	281	pr_err("Can't add general debugfs file: %s\n",
	282	((*bat_debug)->attr).name);
	283	goto err;
	284	}
	285	}
1c280471	286
1c280471	287	return;
637fbd12 AQ	288	err:
637fbd12 AQ	289	debugfs_remove_recursive(batadv_debugfs);
5bc7c1eb	290	batadv_debugfs = NULL;
c6c8fea2 SE	291	}
c6c8fea2 SE	292
40a072d7	293	void batadv_debugfs_destroy(void)
c6c8fea2	294	{
3f87c423 AQ	295	debugfs_remove_recursive(batadv_debugfs);
3f87c423 AQ	296	batadv_debugfs = NULL;
c6c8fea2 SE	297	}
c6c8fea2 SE	298
5bc7c1eb SW	299	/**
	300	* batadv_debugfs_add_hardif - creates the base directory for a hard interface
	301	* in debugfs.
	302	* @hard_iface: hard interface which should be added.
7afcbbef SE	303	*
7afcbbef SE	304	* Return: 0 on success or negative error number in case of failure
5bc7c1eb SW	305	*/
	306	int batadv_debugfs_add_hardif(struct batadv_hard_iface *hard_iface)
	307	{
	308	struct batadv_debuginfo **bat_debug;
	309	struct dentry *file;
	310
	311	if (!batadv_debugfs)
	312	goto out;
	313
	314	hard_iface->debug_dir = debugfs_create_dir(hard_iface->net_dev->name,
	315	batadv_debugfs);
	316	if (!hard_iface->debug_dir)
	317	goto out;
	318
	319	for (bat_debug = batadv_hardif_debuginfos; *bat_debug; ++bat_debug) {
	320	file = debugfs_create_file(((*bat_debug)->attr).name,
	321	S_IFREG \| ((*bat_debug)->attr).mode,
	322	hard_iface->debug_dir,
	323	hard_iface->net_dev,
	324	&(*bat_debug)->fops);
	325	if (!file)
	326	goto rem_attr;
	327	}
	328
	329	return 0;
	330	rem_attr:
	331	debugfs_remove_recursive(hard_iface->debug_dir);
	332	hard_iface->debug_dir = NULL;
	333	out:
5bc7c1eb	334	return -ENOMEM;
5bc7c1eb SW	335	}
	336
	337	/**
	338	* batadv_debugfs_del_hardif - delete the base directory for a hard interface
	339	* in debugfs.
	340	* @hard_iface: hard interface which is deleted.
	341	*/
	342	void batadv_debugfs_del_hardif(struct batadv_hard_iface *hard_iface)
	343	{
	344	if (batadv_debugfs) {
	345	debugfs_remove_recursive(hard_iface->debug_dir);
	346	hard_iface->debug_dir = NULL;
	347	}
	348	}
	349
40a072d7	350	int batadv_debugfs_add_meshif(struct net_device *dev)
c6c8fea2	351	{
56303d34	352	struct batadv_priv *bat_priv = netdev_priv(dev);
7f223c0c	353	struct batadv_debuginfo **bat_debug;
c6c8fea2 SE	354	struct dentry *file;
c6c8fea2 SE	355
9e466250	356	if (!batadv_debugfs)
c6c8fea2 SE	357	goto out;
c6c8fea2 SE	358
9e466250	359	bat_priv->debug_dir = debugfs_create_dir(dev->name, batadv_debugfs);
c6c8fea2 SE	360	if (!bat_priv->debug_dir)
	361	goto out;
	362
9039dc7e	363	if (batadv_socket_setup(bat_priv) < 0)
5346c35e SE	364	goto rem_attr;
5346c35e SE	365
9e466250	366	if (batadv_debug_log_setup(bat_priv) < 0)
5346c35e	367	goto rem_attr;
c6c8fea2	368
9e466250	369	for (bat_debug = batadv_mesh_debuginfos; *bat_debug; ++bat_debug) {
c6c8fea2	370	file = debugfs_create_file(((*bat_debug)->attr).name,
0aca2369 SE	371	S_IFREG \| ((*bat_debug)->attr).mode,
	372	bat_priv->debug_dir,
	373	dev, &(*bat_debug)->fops);
c6c8fea2	374	if (!file) {
3e34819e SE	375	batadv_err(dev, "Can't add debugfs file: %s/%s\n",
3e34819e SE	376	dev->name, ((*bat_debug)->attr).name);
c6c8fea2 SE	377	goto rem_attr;
	378	}
	379	}
	380
d56b1705 MH	381	if (batadv_nc_init_debugfs(bat_priv) < 0)
	382	goto rem_attr;
	383
c6c8fea2 SE	384	return 0;
	385	rem_attr:
	386	debugfs_remove_recursive(bat_priv->debug_dir);
	387	bat_priv->debug_dir = NULL;
	388	out:
c6c8fea2	389	return -ENOMEM;
c6c8fea2 SE	390	}
c6c8fea2 SE	391
40a072d7	392	void batadv_debugfs_del_meshif(struct net_device *dev)
c6c8fea2	393	{
56303d34	394	struct batadv_priv *bat_priv = netdev_priv(dev);
c6c8fea2	395
9e466250	396	batadv_debug_log_cleanup(bat_priv);
c6c8fea2	397
9e466250	398	if (batadv_debugfs) {
c6c8fea2 SE	399	debugfs_remove_recursive(bat_priv->debug_dir);
	400	bat_priv->debug_dir = NULL;
	401	}
	402	}