[linux-2.6-block.git] / net / batman-adv / debugfs.c

// SPDX-License-Identifier: GPL-2.0
/* Copyright (C) 2010-2018  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/dcache.h>
#include <linux/debugfs.h>
#include <linux/err.h>
#include <linux/errno.h>
#include <linux/export.h>
#include <linux/fs.h>
#include <linux/netdevice.h>
#include <linux/printk.h>
#include <linux/seq_file.h>
#include <linux/stat.h>
#include <linux/stddef.h>
#include <linux/stringify.h>
#include <linux/sysfs.h>
#include <net/net_namespace.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_cache
 * @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, 0444, 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, 0444, neighbors_open);
static BATADV_DEBUGINFO(originators, 0444, batadv_originators_open);
static BATADV_DEBUGINFO(gateways, 0444, batadv_gateways_open);
static BATADV_DEBUGINFO(transtable_global, 0444, batadv_transtable_global_open);
#ifdef CONFIG_BATMAN_ADV_BLA
static BATADV_DEBUGINFO(bla_claim_table, 0444, batadv_bla_claim_table_open);
static BATADV_DEBUGINFO(bla_backbone_table, 0444,
			batadv_bla_backbone_table_open);
#endif
#ifdef CONFIG_BATMAN_ADV_DAT
static BATADV_DEBUGINFO(dat_cache, 0444, batadv_dat_cache_open);
#endif
static BATADV_DEBUGINFO(transtable_local, 0444, batadv_transtable_local_open);
#ifdef CONFIG_BATMAN_ADV_NC
static BATADV_DEBUGINFO(nc_nodes, 0444, batadv_nc_nodes_open);
#endif
#ifdef CONFIG_BATMAN_ADV_MCAST
static BATADV_DEBUGINFO(mcast_flags, 0444, 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, 0444,
			       batadv_originators_hardif_open);

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

/**
 * batadv_debugfs_init() - Initialize soft interface independent debugfs entries
 */
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;
}

/**
 * batadv_debugfs_destroy() - Remove all debugfs entries
 */
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 net *net = dev_net(hard_iface->net_dev);
	struct batadv_debuginfo **bat_debug;
	struct dentry *file;

	if (!batadv_debugfs)
		goto out;

	if (net != &init_net)
		return 0;

	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_rename_hardif() - Fix debugfs path for renamed hardif
 * @hard_iface: hard interface which was renamed
 */
void batadv_debugfs_rename_hardif(struct batadv_hard_iface *hard_iface)
{
	const char *name = hard_iface->net_dev->name;
	struct dentry *dir;
	struct dentry *d;

	dir = hard_iface->debug_dir;
	if (!dir)
		return;

	d = debugfs_rename(dir->d_parent, dir, dir->d_parent, name);
	if (!d)
		pr_err("Can't rename debugfs dir to %s\n", name);
}

/**
 * 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)
{
	struct net *net = dev_net(hard_iface->net_dev);

	if (net != &init_net)
		return;

	if (batadv_debugfs) {
		debugfs_remove_recursive(hard_iface->debug_dir);
		hard_iface->debug_dir = NULL;
	}
}

/**
 * batadv_debugfs_add_meshif() - Initialize interface dependent debugfs entries
 * @dev: netdev struct of the soft interface
 *
 * Return: 0 on success or negative error number in case of failure
 */
int batadv_debugfs_add_meshif(struct net_device *dev)
{
	struct batadv_priv *bat_priv = netdev_priv(dev);
	struct batadv_debuginfo **bat_debug;
	struct net *net = dev_net(dev);
	struct dentry *file;

	if (!batadv_debugfs)
		goto out;

	if (net != &init_net)
		return 0;

	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;
}

/**
 * batadv_debugfs_rename_meshif() - Fix debugfs path for renamed softif
 * @dev: net_device which was renamed
 */
void batadv_debugfs_rename_meshif(struct net_device *dev)
{
	struct batadv_priv *bat_priv = netdev_priv(dev);
	const char *name = dev->name;
	struct dentry *dir;
	struct dentry *d;

	dir = bat_priv->debug_dir;
	if (!dir)
		return;

	d = debugfs_rename(dir->d_parent, dir, dir->d_parent, name);
	if (!d)
		pr_err("Can't rename debugfs dir to %s\n", name);
}

/**
 * batadv_debugfs_del_meshif() - Remove interface dependent debugfs entries
 * @dev: netdev struct of the soft interface
 */
void batadv_debugfs_del_meshif(struct net_device *dev)
{
	struct batadv_priv *bat_priv = netdev_priv(dev);
	struct net *net = dev_net(dev);

	if (net != &init_net)
		return;

	batadv_debug_log_cleanup(bat_priv);

	if (batadv_debugfs) {
		debugfs_remove_recursive(bat_priv->debug_dir);
		bat_priv->debug_dir = NULL;
	}
}
Commit	Line	Data
7db7d9f3	1	// SPDX-License-Identifier: GPL-2.0
6b1aea8c	2	/* Copyright (C) 2010-2018 B.A.T.M.A.N. contributors:
c6c8fea2 SE	3	*
	4	* Marek Lindner
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of version 2 of the GNU General Public
	8	* License as published by the Free Software Foundation.
	9	*
	10	* This program is distributed in the hope that it will be useful, but
	11	* WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	* General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
ebf38fb7	16	* along with this program; if not, see <http://www.gnu.org/licenses/>.
c6c8fea2 SE	17	*/
c6c8fea2 SE	18
1e2c2a4f	19	#include "debugfs.h"
c6c8fea2 SE	20	#include "main.h"
c6c8fea2 SE	21
36dc621c	22	#include <linux/dcache.h>
c6c8fea2	23	#include <linux/debugfs.h>
3e7514af	24	#include <linux/err.h>
1e2c2a4f SE	25	#include <linux/errno.h>
1e2c2a4f SE	26	#include <linux/export.h>
1e2c2a4f	27	#include <linux/fs.h>
1e2c2a4f	28	#include <linux/netdevice.h>
1e2c2a4f	29	#include <linux/printk.h>
1e2c2a4f	30	#include <linux/seq_file.h>
1e2c2a4f SE	31	#include <linux/stat.h>
	32	#include <linux/stddef.h>
	33	#include <linux/stringify.h>
	34	#include <linux/sysfs.h>
94969208	35	#include <net/net_namespace.h>
c6c8fea2	36
01d350d1	37	#include "bat_algo.h"
9bf8e4d4	38	#include "bridge_loop_avoidance.h"
2f1dfbe1	39	#include "distributed-arp-table.h"
1e2c2a4f SE	40	#include "gateway_client.h"
1e2c2a4f SE	41	#include "icmp_socket.h"
ba412080	42	#include "log.h"
4e3e823b	43	#include "multicast.h"
d56b1705	44	#include "network-coding.h"
1e2c2a4f SE	45	#include "originator.h"
1e2c2a4f SE	46	#include "translation-table.h"
c6c8fea2	47
9e466250	48	static struct dentry *batadv_debugfs;
c6c8fea2	49
9e466250	50	static int batadv_algorithms_open(struct inode inode, struct file file)
1c280471	51	{
3193e8fd	52	return single_open(file, batadv_algo_seq_print_text, NULL);
1c280471 ML	53	}
1c280471 ML	54
7587405a ML	55	static int neighbors_open(struct inode inode, struct file file)
	56	{
	57	struct net_device net_dev = (struct net_device )inode->i_private;
	58
	59	return single_open(file, batadv_hardif_neigh_seq_print_text, net_dev);
	60	}
	61
9e466250	62	static int batadv_originators_open(struct inode inode, struct file file)
c6c8fea2 SE	63	{
c6c8fea2 SE	64	struct net_device net_dev = (struct net_device )inode->i_private;
f138694b	65
7d211efc	66	return single_open(file, batadv_orig_seq_print_text, net_dev);
c6c8fea2 SE	67	}
c6c8fea2 SE	68
cb1c92ec	69	/**
7e9a8c2c SE	70	* batadv_originators_hardif_open() - handles debugfs output for the originator
7e9a8c2c SE	71	* table of an hard interface
cb1c92ec SW	72	* @inode: inode pointer to debugfs file
cb1c92ec SW	73	* @file: pointer to the seq_file
7afcbbef SE	74	*
7afcbbef SE	75	* Return: 0 on success or negative error number in case of failure
cb1c92ec SW	76	*/
	77	static int batadv_originators_hardif_open(struct inode *inode,
	78	struct file *file)
	79	{
	80	struct net_device net_dev = (struct net_device )inode->i_private;
f138694b	81
cb1c92ec SW	82	return single_open(file, batadv_orig_hardif_seq_print_text, net_dev);
	83	}
	84
9e466250	85	static int batadv_gateways_open(struct inode inode, struct file file)
c6c8fea2 SE	86	{
c6c8fea2 SE	87	struct net_device net_dev = (struct net_device )inode->i_private;
f138694b	88
7cf06bc6	89	return single_open(file, batadv_gw_client_seq_print_text, net_dev);
c6c8fea2 SE	90	}
c6c8fea2 SE	91
9e466250	92	static int batadv_transtable_global_open(struct inode inode, struct file file)
c6c8fea2 SE	93	{
c6c8fea2 SE	94	struct net_device net_dev = (struct net_device )inode->i_private;
f138694b	95
08c36d3e	96	return single_open(file, batadv_tt_global_seq_print_text, net_dev);
c6c8fea2 SE	97	}
c6c8fea2 SE	98
7a5cc242	99	#ifdef CONFIG_BATMAN_ADV_BLA
9e466250	100	static int batadv_bla_claim_table_open(struct inode inode, struct file file)
9bf8e4d4 SW	101	{
9bf8e4d4 SW	102	struct net_device net_dev = (struct net_device )inode->i_private;
f138694b	103
08adf151 SE	104	return single_open(file, batadv_bla_claim_table_seq_print_text,
08adf151 SE	105	net_dev);
9bf8e4d4	106	}
536a23f1 SW	107
	108	static int batadv_bla_backbone_table_open(struct inode *inode,
	109	struct file *file)
	110	{
	111	struct net_device net_dev = (struct net_device )inode->i_private;
f138694b	112
536a23f1 SW	113	return single_open(file, batadv_bla_backbone_table_seq_print_text,
	114	net_dev);
	115	}
	116
7a5cc242	117	#endif
9bf8e4d4	118
17224474	119	#ifdef CONFIG_BATMAN_ADV_DAT
2f1dfbe1	120	/**
be01dc33	121	* batadv_dat_cache_open() - Prepare file handler for reads from dat_cache
2f1dfbe1 AQ	122	* @inode: inode which was opened
2f1dfbe1 AQ	123	* @file: file handle to be initialized
7afcbbef SE	124	*
7afcbbef SE	125	* Return: 0 on success or negative error number in case of failure
2f1dfbe1 AQ	126	*/
	127	static int batadv_dat_cache_open(struct inode inode, struct file file)
	128	{
	129	struct net_device net_dev = (struct net_device )inode->i_private;
f138694b	130
2f1dfbe1 AQ	131	return single_open(file, batadv_dat_cache_seq_print_text, net_dev);
2f1dfbe1 AQ	132	}
17224474	133	#endif
2f1dfbe1	134
9e466250	135	static int batadv_transtable_local_open(struct inode inode, struct file file)
c6c8fea2 SE	136	{
c6c8fea2 SE	137	struct net_device net_dev = (struct net_device )inode->i_private;
f138694b	138
08c36d3e	139	return single_open(file, batadv_tt_local_seq_print_text, net_dev);
c6c8fea2 SE	140	}
c6c8fea2 SE	141
7f223c0c	142	struct batadv_debuginfo {
c6c8fea2 SE	143	struct attribute attr;
	144	const struct file_operations fops;
	145	};
	146
d56b1705 MH	147	#ifdef CONFIG_BATMAN_ADV_NC
	148	static int batadv_nc_nodes_open(struct inode inode, struct file file)
	149	{
	150	struct net_device net_dev = (struct net_device )inode->i_private;
f138694b	151
d56b1705 MH	152	return single_open(file, batadv_nc_nodes_seq_print_text, net_dev);
	153	}
	154	#endif
	155
4e3e823b LL	156	#ifdef CONFIG_BATMAN_ADV_MCAST
4e3e823b LL	157	/**
7e9a8c2c	158	* batadv_mcast_flags_open() - prepare file handler for reads from mcast_flags
4e3e823b LL	159	* @inode: inode which was opened
	160	* @file: file handle to be initialized
	161	*
	162	* Return: 0 on success or negative error number in case of failure
	163	*/
	164	static int batadv_mcast_flags_open(struct inode inode, struct file file)
	165	{
	166	struct net_device net_dev = (struct net_device )inode->i_private;
	167
	168	return single_open(file, batadv_mcast_flags_seq_print_text, net_dev);
	169	}
	170	#endif
	171
347c80f0	172	#define BATADV_DEBUGINFO(_name, _mode, _open) \
7f223c0c	173	struct batadv_debuginfo batadv_debuginfo_##_name = { \
121bdca0 SW	174	.attr = { \
	175	.name = __stringify(_name), \
	176	.mode = _mode, \
	177	}, \
	178	.fops = { \
	179	.owner = THIS_MODULE, \
	180	.open = _open, \
	181	.read = seq_read, \
	182	.llseek = seq_lseek, \
	183	.release = single_release, \
	184	}, \
2b64df20	185	}
c6c8fea2	186
637fbd12 AQ	187	/* the following attributes are general and therefore they will be directly
	188	* placed in the BATADV_DEBUGFS_SUBDIR subdirectory of debugfs
	189	*/
507b37cf	190	static BATADV_DEBUGINFO(routing_algos, 0444, batadv_algorithms_open);
637fbd12 AQ	191
	192	static struct batadv_debuginfo *batadv_general_debuginfos[] = {
	193	&batadv_debuginfo_routing_algos,
	194	NULL,
	195	};
	196
	197	/* The following attributes are per soft interface */
507b37cf SE	198	static BATADV_DEBUGINFO(neighbors, 0444, neighbors_open);
	199	static BATADV_DEBUGINFO(originators, 0444, batadv_originators_open);
	200	static BATADV_DEBUGINFO(gateways, 0444, batadv_gateways_open);
	201	static BATADV_DEBUGINFO(transtable_global, 0444, batadv_transtable_global_open);
7a5cc242	202	#ifdef CONFIG_BATMAN_ADV_BLA
507b37cf SE	203	static BATADV_DEBUGINFO(bla_claim_table, 0444, batadv_bla_claim_table_open);
507b37cf SE	204	static BATADV_DEBUGINFO(bla_backbone_table, 0444,
536a23f1	205	batadv_bla_backbone_table_open);
7a5cc242	206	#endif
17224474	207	#ifdef CONFIG_BATMAN_ADV_DAT
507b37cf	208	static BATADV_DEBUGINFO(dat_cache, 0444, batadv_dat_cache_open);
17224474	209	#endif
507b37cf	210	static BATADV_DEBUGINFO(transtable_local, 0444, batadv_transtable_local_open);
d56b1705	211	#ifdef CONFIG_BATMAN_ADV_NC
507b37cf	212	static BATADV_DEBUGINFO(nc_nodes, 0444, batadv_nc_nodes_open);
d56b1705	213	#endif
4e3e823b	214	#ifdef CONFIG_BATMAN_ADV_MCAST
507b37cf	215	static BATADV_DEBUGINFO(mcast_flags, 0444, batadv_mcast_flags_open);
4e3e823b	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
507b37cf	255	static BATADV_HARDIF_DEBUGINFO(originators, 0444,
cb1c92ec	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
ff15c27c SE	263	/**
	264	* batadv_debugfs_init() - Initialize soft interface independent debugfs entries
	265	*/
40a072d7	266	void batadv_debugfs_init(void)
c6c8fea2	267	{
637fbd12	268	struct batadv_debuginfo **bat_debug;
1c280471 ML	269	struct dentry *file;
1c280471 ML	270
54590e4d	271	batadv_debugfs = debugfs_create_dir(BATADV_DEBUGFS_SUBDIR, NULL);
9e466250 SE	272	if (batadv_debugfs == ERR_PTR(-ENODEV))
9e466250 SE	273	batadv_debugfs = NULL;
1c280471	274
9e466250	275	if (!batadv_debugfs)
637fbd12	276	goto err;
1c280471	277
637fbd12 AQ	278	for (bat_debug = batadv_general_debuginfos; *bat_debug; ++bat_debug) {
	279	file = debugfs_create_file(((*bat_debug)->attr).name,
	280	S_IFREG \| ((*bat_debug)->attr).mode,
	281	batadv_debugfs, NULL,
	282	&(*bat_debug)->fops);
	283	if (!file) {
	284	pr_err("Can't add general debugfs file: %s\n",
	285	((*bat_debug)->attr).name);
	286	goto err;
	287	}
	288	}
1c280471	289
1c280471	290	return;
637fbd12 AQ	291	err:
637fbd12 AQ	292	debugfs_remove_recursive(batadv_debugfs);
5bc7c1eb	293	batadv_debugfs = NULL;
c6c8fea2 SE	294	}
c6c8fea2 SE	295
ff15c27c SE	296	/**
	297	* batadv_debugfs_destroy() - Remove all debugfs entries
	298	*/
40a072d7	299	void batadv_debugfs_destroy(void)
c6c8fea2	300	{
3f87c423 AQ	301	debugfs_remove_recursive(batadv_debugfs);
3f87c423 AQ	302	batadv_debugfs = NULL;
c6c8fea2 SE	303	}
c6c8fea2 SE	304
5bc7c1eb	305	/**
7e9a8c2c	306	* batadv_debugfs_add_hardif() - creates the base directory for a hard interface
5bc7c1eb SW	307	* in debugfs.
5bc7c1eb SW	308	* @hard_iface: hard interface which should be added.
7afcbbef SE	309	*
7afcbbef SE	310	* Return: 0 on success or negative error number in case of failure
5bc7c1eb SW	311	*/
	312	int batadv_debugfs_add_hardif(struct batadv_hard_iface *hard_iface)
	313	{
94969208	314	struct net *net = dev_net(hard_iface->net_dev);
5bc7c1eb SW	315	struct batadv_debuginfo **bat_debug;
	316	struct dentry *file;
	317
	318	if (!batadv_debugfs)
	319	goto out;
	320
94969208 AL	321	if (net != &init_net)
	322	return 0;
	323
5bc7c1eb SW	324	hard_iface->debug_dir = debugfs_create_dir(hard_iface->net_dev->name,
	325	batadv_debugfs);
	326	if (!hard_iface->debug_dir)
	327	goto out;
	328
	329	for (bat_debug = batadv_hardif_debuginfos; *bat_debug; ++bat_debug) {
	330	file = debugfs_create_file(((*bat_debug)->attr).name,
	331	S_IFREG \| ((*bat_debug)->attr).mode,
	332	hard_iface->debug_dir,
	333	hard_iface->net_dev,
	334	&(*bat_debug)->fops);
	335	if (!file)
	336	goto rem_attr;
	337	}
	338
	339	return 0;
	340	rem_attr:
	341	debugfs_remove_recursive(hard_iface->debug_dir);
	342	hard_iface->debug_dir = NULL;
	343	out:
5bc7c1eb	344	return -ENOMEM;
5bc7c1eb SW	345	}
5bc7c1eb SW	346
36dc621c SE	347	/**
	348	* batadv_debugfs_rename_hardif() - Fix debugfs path for renamed hardif
	349	* @hard_iface: hard interface which was renamed
	350	*/
	351	void batadv_debugfs_rename_hardif(struct batadv_hard_iface *hard_iface)
	352	{
	353	const char *name = hard_iface->net_dev->name;
	354	struct dentry *dir;
	355	struct dentry *d;
	356
	357	dir = hard_iface->debug_dir;
	358	if (!dir)
	359	return;
	360
	361	d = debugfs_rename(dir->d_parent, dir, dir->d_parent, name);
	362	if (!d)
	363	pr_err("Can't rename debugfs dir to %s\n", name);
	364	}
	365
5bc7c1eb	366	/**
7e9a8c2c	367	* batadv_debugfs_del_hardif() - delete the base directory for a hard interface
5bc7c1eb SW	368	* in debugfs.
	369	* @hard_iface: hard interface which is deleted.
	370	*/
	371	void batadv_debugfs_del_hardif(struct batadv_hard_iface *hard_iface)
	372	{
94969208 AL	373	struct net *net = dev_net(hard_iface->net_dev);
	374
	375	if (net != &init_net)
	376	return;
	377
5bc7c1eb SW	378	if (batadv_debugfs) {
	379	debugfs_remove_recursive(hard_iface->debug_dir);
	380	hard_iface->debug_dir = NULL;
	381	}
	382	}
	383
ff15c27c SE	384	/**
	385	* batadv_debugfs_add_meshif() - Initialize interface dependent debugfs entries
	386	* @dev: netdev struct of the soft interface
	387	*
	388	* Return: 0 on success or negative error number in case of failure
	389	*/
40a072d7	390	int batadv_debugfs_add_meshif(struct net_device *dev)
c6c8fea2	391	{
56303d34	392	struct batadv_priv *bat_priv = netdev_priv(dev);
7f223c0c	393	struct batadv_debuginfo **bat_debug;
94969208	394	struct net *net = dev_net(dev);
c6c8fea2 SE	395	struct dentry *file;
c6c8fea2 SE	396
9e466250	397	if (!batadv_debugfs)
c6c8fea2 SE	398	goto out;
c6c8fea2 SE	399
94969208 AL	400	if (net != &init_net)
	401	return 0;
	402
9e466250	403	bat_priv->debug_dir = debugfs_create_dir(dev->name, batadv_debugfs);
c6c8fea2 SE	404	if (!bat_priv->debug_dir)
	405	goto out;
	406
9039dc7e	407	if (batadv_socket_setup(bat_priv) < 0)
5346c35e SE	408	goto rem_attr;
5346c35e SE	409
9e466250	410	if (batadv_debug_log_setup(bat_priv) < 0)
5346c35e	411	goto rem_attr;
c6c8fea2	412
9e466250	413	for (bat_debug = batadv_mesh_debuginfos; *bat_debug; ++bat_debug) {
c6c8fea2	414	file = debugfs_create_file(((*bat_debug)->attr).name,
0aca2369 SE	415	S_IFREG \| ((*bat_debug)->attr).mode,
	416	bat_priv->debug_dir,
	417	dev, &(*bat_debug)->fops);
c6c8fea2	418	if (!file) {
3e34819e SE	419	batadv_err(dev, "Can't add debugfs file: %s/%s\n",
3e34819e SE	420	dev->name, ((*bat_debug)->attr).name);
c6c8fea2 SE	421	goto rem_attr;
	422	}
	423	}
	424
d56b1705 MH	425	if (batadv_nc_init_debugfs(bat_priv) < 0)
	426	goto rem_attr;
	427
c6c8fea2 SE	428	return 0;
	429	rem_attr:
	430	debugfs_remove_recursive(bat_priv->debug_dir);
	431	bat_priv->debug_dir = NULL;
	432	out:
c6c8fea2	433	return -ENOMEM;
c6c8fea2 SE	434	}
c6c8fea2 SE	435
6da7be7d SE	436	/**
	437	* batadv_debugfs_rename_meshif() - Fix debugfs path for renamed softif
	438	* @dev: net_device which was renamed
	439	*/
	440	void batadv_debugfs_rename_meshif(struct net_device *dev)
	441	{
	442	struct batadv_priv *bat_priv = netdev_priv(dev);
	443	const char *name = dev->name;
	444	struct dentry *dir;
	445	struct dentry *d;
	446
	447	dir = bat_priv->debug_dir;
	448	if (!dir)
	449	return;
	450
	451	d = debugfs_rename(dir->d_parent, dir, dir->d_parent, name);
	452	if (!d)
	453	pr_err("Can't rename debugfs dir to %s\n", name);
	454	}
	455
ff15c27c SE	456	/**
	457	* batadv_debugfs_del_meshif() - Remove interface dependent debugfs entries
	458	* @dev: netdev struct of the soft interface
	459	*/
40a072d7	460	void batadv_debugfs_del_meshif(struct net_device *dev)
c6c8fea2	461	{
56303d34	462	struct batadv_priv *bat_priv = netdev_priv(dev);
94969208 AL	463	struct net *net = dev_net(dev);
	464
	465	if (net != &init_net)
	466	return;
c6c8fea2	467
9e466250	468	batadv_debug_log_cleanup(bat_priv);
c6c8fea2	469
9e466250	470	if (batadv_debugfs) {
c6c8fea2 SE	471	debugfs_remove_recursive(bat_priv->debug_dir);
	472	bat_priv->debug_dir = NULL;
	473	}
	474	}