mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-22 08:49:45 +00:00
![Sven Eckelmann](/assets/img/avatar_default.png)
The header files could not be build indepdent from each other. This is happened because headers didn't include the files for things they've used. This was problematic because the success of a build depended on the knowledge about the right order of local includes. Also source files were not including everything they've used explicitly. Instead they required that transitive includes are always stable. This is problematic because some transitive includes are not obvious, depend on config settings and may not be stable in the future. The order for include blocks are: * primary headers (main.h and the *.h file of a *.c file) * global linux headers * required local headers * extra forward declarations for pointers in function/struct declarations The only exceptions are linux/bitops.h and linux/if_ether.h in packet.h. This header file is shared with userspace applications like batctl and must therefore build together with userspace applications. The header linux/bitops.h is not part of the uapi headers and linux/if_ether.h conflicts with the musl implementation of netinet/if_ether.h. The maintainers rejected the use of __KERNEL__ preprocessor checks and thus these two headers are only in main.h. All files using packet.h first have to include main.h to work correctly. Reported-by: Markus Pargmann <mpa@pengutronix.de> Signed-off-by: Sven Eckelmann <sven@narfation.org> Signed-off-by: Marek Lindner <mareklindner@neomailbox.ch>
574 lines
14 KiB
C
574 lines
14 KiB
C
/* Copyright (C) 2010-2015 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/compiler.h>
|
|
#include <linux/debugfs.h>
|
|
#include <linux/device.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/export.h>
|
|
#include <linux/fcntl.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/jiffies.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/poll.h>
|
|
#include <linux/printk.h>
|
|
#include <linux/sched.h> /* for linux/wait.h */
|
|
#include <linux/seq_file.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/stat.h>
|
|
#include <linux/stddef.h>
|
|
#include <linux/stringify.h>
|
|
#include <linux/sysfs.h>
|
|
#include <linux/types.h>
|
|
#include <linux/uaccess.h>
|
|
#include <linux/wait.h>
|
|
#include <stdarg.h>
|
|
|
|
#include "bridge_loop_avoidance.h"
|
|
#include "distributed-arp-table.h"
|
|
#include "gateway_client.h"
|
|
#include "icmp_socket.h"
|
|
#include "network-coding.h"
|
|
#include "originator.h"
|
|
#include "translation-table.h"
|
|
|
|
static struct dentry *batadv_debugfs;
|
|
|
|
#ifdef CONFIG_BATMAN_ADV_DEBUG
|
|
#define BATADV_LOG_BUFF_MASK (batadv_log_buff_len - 1)
|
|
|
|
static const int batadv_log_buff_len = BATADV_LOG_BUF_LEN;
|
|
|
|
static char *batadv_log_char_addr(struct batadv_priv_debug_log *debug_log,
|
|
size_t idx)
|
|
{
|
|
return &debug_log->log_buff[idx & BATADV_LOG_BUFF_MASK];
|
|
}
|
|
|
|
static void batadv_emit_log_char(struct batadv_priv_debug_log *debug_log,
|
|
char c)
|
|
{
|
|
char *char_addr;
|
|
|
|
char_addr = batadv_log_char_addr(debug_log, debug_log->log_end);
|
|
*char_addr = c;
|
|
debug_log->log_end++;
|
|
|
|
if (debug_log->log_end - debug_log->log_start > batadv_log_buff_len)
|
|
debug_log->log_start = debug_log->log_end - batadv_log_buff_len;
|
|
}
|
|
|
|
__printf(2, 3)
|
|
static int batadv_fdebug_log(struct batadv_priv_debug_log *debug_log,
|
|
const char *fmt, ...)
|
|
{
|
|
va_list args;
|
|
static char debug_log_buf[256];
|
|
char *p;
|
|
|
|
if (!debug_log)
|
|
return 0;
|
|
|
|
spin_lock_bh(&debug_log->lock);
|
|
va_start(args, fmt);
|
|
vscnprintf(debug_log_buf, sizeof(debug_log_buf), fmt, args);
|
|
va_end(args);
|
|
|
|
for (p = debug_log_buf; *p != 0; p++)
|
|
batadv_emit_log_char(debug_log, *p);
|
|
|
|
spin_unlock_bh(&debug_log->lock);
|
|
|
|
wake_up(&debug_log->queue_wait);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int batadv_debug_log(struct batadv_priv *bat_priv, const char *fmt, ...)
|
|
{
|
|
va_list args;
|
|
char tmp_log_buf[256];
|
|
|
|
va_start(args, fmt);
|
|
vscnprintf(tmp_log_buf, sizeof(tmp_log_buf), fmt, args);
|
|
batadv_fdebug_log(bat_priv->debug_log, "[%10u] %s",
|
|
jiffies_to_msecs(jiffies), tmp_log_buf);
|
|
va_end(args);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int batadv_log_open(struct inode *inode, struct file *file)
|
|
{
|
|
if (!try_module_get(THIS_MODULE))
|
|
return -EBUSY;
|
|
|
|
nonseekable_open(inode, file);
|
|
file->private_data = inode->i_private;
|
|
return 0;
|
|
}
|
|
|
|
static int batadv_log_release(struct inode *inode, struct file *file)
|
|
{
|
|
module_put(THIS_MODULE);
|
|
return 0;
|
|
}
|
|
|
|
static int batadv_log_empty(struct batadv_priv_debug_log *debug_log)
|
|
{
|
|
return !(debug_log->log_start - debug_log->log_end);
|
|
}
|
|
|
|
static ssize_t batadv_log_read(struct file *file, char __user *buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct batadv_priv *bat_priv = file->private_data;
|
|
struct batadv_priv_debug_log *debug_log = bat_priv->debug_log;
|
|
int error, i = 0;
|
|
char *char_addr;
|
|
char c;
|
|
|
|
if ((file->f_flags & O_NONBLOCK) && batadv_log_empty(debug_log))
|
|
return -EAGAIN;
|
|
|
|
if (!buf)
|
|
return -EINVAL;
|
|
|
|
if (count == 0)
|
|
return 0;
|
|
|
|
if (!access_ok(VERIFY_WRITE, buf, count))
|
|
return -EFAULT;
|
|
|
|
error = wait_event_interruptible(debug_log->queue_wait,
|
|
(!batadv_log_empty(debug_log)));
|
|
|
|
if (error)
|
|
return error;
|
|
|
|
spin_lock_bh(&debug_log->lock);
|
|
|
|
while ((!error) && (i < count) &&
|
|
(debug_log->log_start != debug_log->log_end)) {
|
|
char_addr = batadv_log_char_addr(debug_log,
|
|
debug_log->log_start);
|
|
c = *char_addr;
|
|
|
|
debug_log->log_start++;
|
|
|
|
spin_unlock_bh(&debug_log->lock);
|
|
|
|
error = __put_user(c, buf);
|
|
|
|
spin_lock_bh(&debug_log->lock);
|
|
|
|
buf++;
|
|
i++;
|
|
}
|
|
|
|
spin_unlock_bh(&debug_log->lock);
|
|
|
|
if (!error)
|
|
return i;
|
|
|
|
return error;
|
|
}
|
|
|
|
static unsigned int batadv_log_poll(struct file *file, poll_table *wait)
|
|
{
|
|
struct batadv_priv *bat_priv = file->private_data;
|
|
struct batadv_priv_debug_log *debug_log = bat_priv->debug_log;
|
|
|
|
poll_wait(file, &debug_log->queue_wait, wait);
|
|
|
|
if (!batadv_log_empty(debug_log))
|
|
return POLLIN | POLLRDNORM;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct file_operations batadv_log_fops = {
|
|
.open = batadv_log_open,
|
|
.release = batadv_log_release,
|
|
.read = batadv_log_read,
|
|
.poll = batadv_log_poll,
|
|
.llseek = no_llseek,
|
|
};
|
|
|
|
static int batadv_debug_log_setup(struct batadv_priv *bat_priv)
|
|
{
|
|
struct dentry *d;
|
|
|
|
if (!bat_priv->debug_dir)
|
|
goto err;
|
|
|
|
bat_priv->debug_log = kzalloc(sizeof(*bat_priv->debug_log), GFP_ATOMIC);
|
|
if (!bat_priv->debug_log)
|
|
goto err;
|
|
|
|
spin_lock_init(&bat_priv->debug_log->lock);
|
|
init_waitqueue_head(&bat_priv->debug_log->queue_wait);
|
|
|
|
d = debugfs_create_file("log", S_IFREG | S_IRUSR,
|
|
bat_priv->debug_dir, bat_priv,
|
|
&batadv_log_fops);
|
|
if (!d)
|
|
goto err;
|
|
|
|
return 0;
|
|
|
|
err:
|
|
return -ENOMEM;
|
|
}
|
|
|
|
static void batadv_debug_log_cleanup(struct batadv_priv *bat_priv)
|
|
{
|
|
kfree(bat_priv->debug_log);
|
|
bat_priv->debug_log = NULL;
|
|
}
|
|
#else /* CONFIG_BATMAN_ADV_DEBUG */
|
|
static int batadv_debug_log_setup(struct batadv_priv *bat_priv)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static void batadv_debug_log_cleanup(struct batadv_priv *bat_priv)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
static int batadv_algorithms_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, batadv_algo_seq_print_text, NULL);
|
|
}
|
|
|
|
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
|
|
*/
|
|
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
|
|
*/
|
|
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
|
|
|
|
#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(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
|
|
|
|
static struct batadv_debuginfo *batadv_mesh_debuginfos[] = {
|
|
&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
|
|
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.
|
|
*/
|
|
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;
|
|
}
|
|
}
|