[commits] linux integration; branch, linux, updated. v2.6.36-rc3-514-gb1c4725

18 Sep 2010

The following commit has been merged in the linux branch:
commit 8b7974828d37798ef3f4c1bf5ca3c034d003e8d6
Merge: 47cb2ff5a5051d436b2c5a6a420b481c1067faa7 078eb6abad4d6166c7bf6e9b87eaa84d0ad94457
Author: Sven Eckelmann sven.eckelmann@gmx.de
Date:   Sat Sep 18 18:52:59 2010 +0200
Merge remote branch 'origin/next' into linux
diff --combined drivers/staging/batman-adv/bat_debugfs.c
index 507da68,0000000..57f84a9
mode 100644,000000..100644

--- a/drivers/staging/batman-adv/bat_debugfs.c
+++ b/drivers/staging/batman-adv/bat_debugfs.c
@@@ -1,341 -1,0 +1,343 @@@
 +/*
 + * Copyright (C) 2010 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, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 + * 02110-1301, USA
 + *
 + */
 +
 +#include "main.h"
 +
 +#include <linux/debugfs.h>
 +
 +#include "bat_debugfs.h"
 +#include "translation-table.h"
 +#include "originator.h"
 +#include "hard-interface.h"
 +#include "vis.h"
 +#include "icmp_socket.h"
 +
 +static struct dentry *bat_debugfs;
 +
 +#ifdef CONFIG_BATMAN_ADV_DEBUG
 +#define LOG_BUFF_MASK (log_buff_len-1)
 +#define LOG_BUFF(idx) (debug_log->log_buff[(idx) & LOG_BUFF_MASK])
 +
 +static int log_buff_len = LOG_BUF_LEN;
 +
 +static void emit_log_char(struct debug_log *debug_log, char c)
 +{
 +	LOG_BUFF(debug_log->log_end) = c;
 +	debug_log->log_end++;
 +
 +	if (debug_log->log_end - debug_log->log_start > log_buff_len)
 +		debug_log->log_start = debug_log->log_end - log_buff_len;
 +}
 +
 +static int fdebug_log(struct debug_log *debug_log, char *fmt, ...)
 +{
 +	int printed_len;
 +	va_list args;
 +	static char debug_log_buf[256];
 +	char *p;
 +	unsigned long flags;
 +
 +	if (!debug_log)
 +		return 0;
 +
 +	spin_lock_irqsave(&debug_log->lock, flags);
 +	va_start(args, fmt);
 +	printed_len = vscnprintf(debug_log_buf, sizeof(debug_log_buf),
 +				 fmt, args);
 +	va_end(args);
 +
 +	for (p = debug_log_buf; *p != 0; p++)
 +		emit_log_char(debug_log, *p);
 +
 +	spin_unlock_irqrestore(&debug_log->lock, flags);
 +
 +	wake_up(&debug_log->queue_wait);
 +
 +	return 0;
 +}
 +
 +int debug_log(struct bat_priv *bat_priv, char *fmt, ...)
 +{
 +	va_list args;
 +	char tmp_log_buf[256];
 +
 +	va_start(args, fmt);
 +	vscnprintf(tmp_log_buf, sizeof(tmp_log_buf), fmt, args);
 +	fdebug_log(bat_priv->debug_log, "[%10u] %s",
 +		   (jiffies / HZ), tmp_log_buf);
 +	va_end(args);
 +
 +	return 0;
 +}
 +
 +static int log_open(struct inode *inode, struct file *file)
 +{
++	nonseekable_open(inode, file);
 +	file->private_data = inode->i_private;
 +	inc_module_count();
 +	return 0;
 +}
 +
 +static int log_release(struct inode *inode, struct file *file)
 +{
 +	dec_module_count();
 +	return 0;
 +}
 +
 +static ssize_t log_read(struct file *file, char __user *buf,
 +			size_t count, loff_t *ppos)
 +{
 +	struct bat_priv *bat_priv = file->private_data;
 +	struct debug_log *debug_log = bat_priv->debug_log;
 +	int error, i = 0;
 +	char c;
 +	unsigned long flags;
 +
 +	if ((file->f_flags & O_NONBLOCK) &&
 +	    !(debug_log->log_end - debug_log->log_start))
 +		return -EAGAIN;
 +
 +	if ((!buf) || (count < 0))
 +		return -EINVAL;
 +
 +	if (count == 0)
 +		return 0;
 +
 +	if (!access_ok(VERIFY_WRITE, buf, count))
 +		return -EFAULT;
 +
 +	error = wait_event_interruptible(debug_log->queue_wait,
 +				(debug_log->log_start - debug_log->log_end));
 +
 +	if (error)
 +		return error;
 +
 +	spin_lock_irqsave(&debug_log->lock, flags);
 +
 +	while ((!error) && (i < count) &&
 +	       (debug_log->log_start != debug_log->log_end)) {
 +		c = LOG_BUFF(debug_log->log_start);
 +
 +		debug_log->log_start++;
 +
 +		spin_unlock_irqrestore(&debug_log->lock, flags);
 +
 +		error = __put_user(c, buf);
 +
 +		spin_lock_irqsave(&debug_log->lock, flags);
 +
 +		buf++;
 +		i++;
 +
 +	}
 +
 +	spin_unlock_irqrestore(&debug_log->lock, flags);
 +
 +	if (!error)
 +		return i;
 +
 +	return error;
 +}
 +
 +static unsigned int log_poll(struct file *file, poll_table *wait)
 +{
 +	struct bat_priv *bat_priv = file->private_data;
 +	struct debug_log *debug_log = bat_priv->debug_log;
 +
 +	poll_wait(file, &debug_log->queue_wait, wait);
 +
 +	if (debug_log->log_end - debug_log->log_start)
 +		return POLLIN | POLLRDNORM;
 +
 +	return 0;
 +}
 +
 +static const struct file_operations log_fops = {
 +	.open           = log_open,
 +	.release        = log_release,
 +	.read           = log_read,
 +	.poll           = log_poll,
++	.llseek         = no_llseek,
 +};
 +
 +static int debug_log_setup(struct bat_priv *bat_priv)
 +{
 +	struct dentry *d;
 +
 +	if (!bat_priv->debug_dir)
 +		goto err;
 +
 +	bat_priv->debug_log = kzalloc(sizeof(struct 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, &log_fops);
 +	if (d)
 +		goto err;
 +
 +	return 0;
 +
 +err:
 +	return 1;
 +}
 +
 +static void debug_log_cleanup(struct bat_priv *bat_priv)
 +{
 +	kfree(bat_priv->debug_log);
 +	bat_priv->debug_log = NULL;
 +}
 +#else /* CONFIG_BATMAN_ADV_DEBUG */
 +static int debug_log_setup(struct bat_priv *bat_priv)
 +{
 +	bat_priv->debug_log = NULL;
 +	return 0;
 +}
 +
 +static void debug_log_cleanup(struct bat_priv *bat_priv)
 +{
 +	return;
 +}
 +#endif
 +
 +static int originators_open(struct inode *inode, struct file *file)
 +{
 +	struct net_device *net_dev = (struct net_device *)inode->i_private;
 +	return single_open(file, orig_seq_print_text, net_dev);
 +}
 +
 +static int transtable_global_open(struct inode *inode, struct file *file)
 +{
 +	struct net_device *net_dev = (struct net_device *)inode->i_private;
 +	return single_open(file, hna_global_seq_print_text, net_dev);
 +}
 +
 +static int transtable_local_open(struct inode *inode, struct file *file)
 +{
 +	struct net_device *net_dev = (struct net_device *)inode->i_private;
 +	return single_open(file, hna_local_seq_print_text, net_dev);
 +}
 +
 +static int vis_data_open(struct inode *inode, struct file *file)
 +{
 +	struct net_device *net_dev = (struct net_device *)inode->i_private;
 +	return single_open(file, vis_seq_print_text, net_dev);
 +}
 +
 +struct bat_debuginfo {
 +	struct attribute attr;
 +	const struct file_operations fops;
 +};
 +
 +#define BAT_DEBUGINFO(_name, _mode, _open)	\
 +struct bat_debuginfo bat_debuginfo_##_name = {	\
 +	.attr = { .name = __stringify(_name),	\
 +		  .mode = _mode, },		\
 +	.fops = { .owner = THIS_MODULE,		\
 +		  .open = _open,		\
 +		  .read	= seq_read,		\
 +		  .llseek = seq_lseek,		\
 +		  .release = single_release,	\
 +		}				\
 +};
 +
 +static BAT_DEBUGINFO(originators, S_IRUGO, originators_open);
 +static BAT_DEBUGINFO(transtable_global, S_IRUGO, transtable_global_open);
 +static BAT_DEBUGINFO(transtable_local, S_IRUGO, transtable_local_open);
 +static BAT_DEBUGINFO(vis_data, S_IRUGO, vis_data_open);
 +
 +static struct bat_debuginfo *mesh_debuginfos[] = {
 +	&bat_debuginfo_originators,
 +	&bat_debuginfo_transtable_global,
 +	&bat_debuginfo_transtable_local,
 +	&bat_debuginfo_vis_data,
 +	NULL,
 +};
 +
 +void debugfs_init(void)
 +{
 +	bat_debugfs = debugfs_create_dir(DEBUGFS_BAT_SUBDIR, NULL);
 +	if (bat_debugfs == ERR_PTR(-ENODEV))
 +		bat_debugfs = NULL;
 +}
 +
 +void debugfs_destroy(void)
 +{
 +	if (bat_debugfs) {
 +		debugfs_remove_recursive(bat_debugfs);
 +		bat_debugfs = NULL;
 +	}
 +}
 +
 +int debugfs_add_meshif(struct net_device *dev)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(dev);
 +	struct bat_debuginfo **bat_debug;
 +	struct dentry *file;
 +
 +	if (!bat_debugfs)
 +		goto out;
 +
 +	bat_priv->debug_dir = debugfs_create_dir(dev->name, bat_debugfs);
 +	if (!bat_priv->debug_dir)
 +		goto out;
 +
 +	bat_socket_setup(bat_priv);
 +	debug_log_setup(bat_priv);
 +
 +	for (bat_debug = 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) {
 +			bat_err(dev, "Can't add debugfs file: %s/%s\n",
 +				dev->name, ((*bat_debug)->attr).name);
 +			goto rem_attr;
 +		}
 +	}
 +
 +	return 0;
 +rem_attr:
 +	debugfs_remove_recursive(bat_priv->debug_dir);
 +	bat_priv->debug_dir = NULL;
 +out:
 +#ifdef CONFIG_DEBUG_FS
 +	return -ENOMEM;
 +#else
 +	return 0;
 +#endif /* CONFIG_DEBUG_FS */
 +}
 +
 +void debugfs_del_meshif(struct net_device *dev)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(dev);
 +
 +	debug_log_cleanup(bat_priv);
 +
 +	if (bat_debugfs) {
 +		debugfs_remove_recursive(bat_priv->debug_dir);
 +		bat_priv->debug_dir = NULL;
 +	}
 +}
diff --combined drivers/staging/batman-adv/bat_sysfs.c
index 0610169,0000000..bc17fb8
mode 100644,000000..100644
--- a/drivers/staging/batman-adv/bat_sysfs.c
+++ b/drivers/staging/batman-adv/bat_sysfs.c
@@@ -1,536 -1,0 +1,558 @@@
 +/*
 + * Copyright (C) 2010 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, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 + * 02110-1301, USA
 + *
 + */
 +
 +#include "main.h"
 +#include "bat_sysfs.h"
 +#include "translation-table.h"
 +#include "originator.h"
 +#include "hard-interface.h"
 +#include "vis.h"
 +
 +#define to_dev(obj)     container_of(obj, struct device, kobj)
 +
 +#define BAT_ATTR(_name, _mode, _show, _store)	\
 +struct bat_attribute bat_attr_##_name = {	\
 +	.attr = {.name = __stringify(_name),	\
 +		 .mode = _mode },		\
 +	.show   = _show,			\
 +	.store  = _store,			\
 +};
 +
 +static ssize_t show_aggr_ogms(struct kobject *kobj, struct attribute *attr,
 +			     char *buff)
 +{
 +	struct device *dev = to_dev(kobj->parent);
 +	struct bat_priv *bat_priv = netdev_priv(to_net_dev(dev));
 +	int aggr_status = atomic_read(&bat_priv->aggregation_enabled);
 +
 +	return sprintf(buff, "%s\n",
 +		       aggr_status == 0 ? "disabled" : "enabled");
 +}
 +
 +static ssize_t store_aggr_ogms(struct kobject *kobj, struct attribute *attr,
 +			      char *buff, size_t count)
 +{
 +	struct device *dev = to_dev(kobj->parent);
 +	struct net_device *net_dev = to_net_dev(dev);
 +	struct bat_priv *bat_priv = netdev_priv(net_dev);
 +	int aggr_tmp = -1;
 +
 +	if (((count == 2) && (buff[0] == '1')) ||
 +	    (strncmp(buff, "enable", 6) == 0))
 +		aggr_tmp = 1;
 +
 +	if (((count == 2) && (buff[0] == '0')) ||
 +	    (strncmp(buff, "disable", 7) == 0))
 +		aggr_tmp = 0;
 +
 +	if (aggr_tmp < 0) {
 +		if (buff[count - 1] == '\n')
 +			buff[count - 1] = '\0';
 +
 +		bat_info(net_dev,
 +			 "Invalid parameter for 'aggregate OGM' setting"
 +			 "received: %s\n", buff);
 +		return -EINVAL;
 +	}
 +
 +	if (atomic_read(&bat_priv->aggregation_enabled) == aggr_tmp)
 +		return count;
 +
 +	bat_info(net_dev, "Changing aggregation from: %s to: %s\n",
 +		 atomic_read(&bat_priv->aggregation_enabled) == 1 ?
 +		 "enabled" : "disabled", aggr_tmp == 1 ? "enabled" :
 +		 "disabled");
 +
 +	atomic_set(&bat_priv->aggregation_enabled, (unsigned)aggr_tmp);
 +	return count;
 +}
 +
 +static ssize_t show_bond(struct kobject *kobj, struct attribute *attr,
 +			     char *buff)
 +{
 +	struct device *dev = to_dev(kobj->parent);
 +	struct bat_priv *bat_priv = netdev_priv(to_net_dev(dev));
 +	int bond_status = atomic_read(&bat_priv->bonding_enabled);
 +
 +	return sprintf(buff, "%s\n",
 +		       bond_status == 0 ? "disabled" : "enabled");
 +}
 +
 +static ssize_t store_bond(struct kobject *kobj, struct attribute *attr,
 +			  char *buff, size_t count)
 +{
 +	struct device *dev = to_dev(kobj->parent);
 +	struct net_device *net_dev = to_net_dev(dev);
 +	struct bat_priv *bat_priv = netdev_priv(net_dev);
 +	int bonding_enabled_tmp = -1;
 +
 +	if (((count == 2) && (buff[0] == '1')) ||
 +	    (strncmp(buff, "enable", 6) == 0))
 +		bonding_enabled_tmp = 1;
 +
 +	if (((count == 2) && (buff[0] == '0')) ||
 +	    (strncmp(buff, "disable", 7) == 0))
 +		bonding_enabled_tmp = 0;
 +
 +	if (bonding_enabled_tmp < 0) {
 +		if (buff[count - 1] == '\n')
 +			buff[count - 1] = '\0';
 +
 +		bat_err(net_dev,
 +			"Invalid parameter for 'bonding' setting received: "
 +			"%s\n", buff);
 +		return -EINVAL;
 +	}
 +
 +	if (atomic_read(&bat_priv->bonding_enabled) == bonding_enabled_tmp)
 +		return count;
 +
 +	bat_info(net_dev, "Changing bonding from: %s to: %s\n",
 +		 atomic_read(&bat_priv->bonding_enabled) == 1 ?
 +		 "enabled" : "disabled",
 +		 bonding_enabled_tmp == 1 ? "enabled" : "disabled");
 +
 +	atomic_set(&bat_priv->bonding_enabled, (unsigned)bonding_enabled_tmp);
 +	return count;
 +}
 +
 +static ssize_t show_frag(struct kobject *kobj, struct attribute *attr,
 +			     char *buff)
 +{
 +	struct device *dev = to_dev(kobj->parent);
 +	struct bat_priv *bat_priv = netdev_priv(to_net_dev(dev));
 +	int frag_status = atomic_read(&bat_priv->frag_enabled);
 +
 +	return sprintf(buff, "%s\n",
 +		       frag_status == 0 ? "disabled" : "enabled");
 +}
 +
 +static ssize_t store_frag(struct kobject *kobj, struct attribute *attr,
 +			  char *buff, size_t count)
 +{
 +	struct device *dev = to_dev(kobj->parent);
 +	struct net_device *net_dev = to_net_dev(dev);
 +	struct bat_priv *bat_priv = netdev_priv(net_dev);
 +	int frag_enabled_tmp = -1;
 +
 +	if (((count == 2) && (buff[0] == '1')) ||
 +	    (strncmp(buff, "enable", 6) == 0))
 +		frag_enabled_tmp = 1;
 +
 +	if (((count == 2) && (buff[0] == '0')) ||
 +	    (strncmp(buff, "disable", 7) == 0))
 +		frag_enabled_tmp = 0;
 +
 +	if (frag_enabled_tmp < 0) {
 +		if (buff[count - 1] == '\n')
 +			buff[count - 1] = '\0';
 +
 +		bat_err(net_dev,
 +			"Invalid parameter for 'fragmentation' setting on mesh"
 +			"received: %s\n", buff);
 +		return -EINVAL;
 +	}
 +
 +	if (atomic_read(&bat_priv->frag_enabled) == frag_enabled_tmp)
 +		return count;
 +
 +	bat_info(net_dev, "Changing fragmentation from: %s to: %s\n",
 +		 atomic_read(&bat_priv->frag_enabled) == 1 ?
 +		 "enabled" : "disabled",
 +		 frag_enabled_tmp == 1 ? "enabled" : "disabled");
 +
 +	atomic_set(&bat_priv->frag_enabled, (unsigned)frag_enabled_tmp);
 +	update_min_mtu(net_dev);
 +	return count;
 +}
 +
 +static ssize_t show_vis_mode(struct kobject *kobj, struct attribute *attr,
 +			     char *buff)
 +{
 +	struct device *dev = to_dev(kobj->parent);
 +	struct bat_priv *bat_priv = netdev_priv(to_net_dev(dev));
 +	int vis_mode = atomic_read(&bat_priv->vis_mode);
 +
 +	return sprintf(buff, "%s\n",
 +		       vis_mode == VIS_TYPE_CLIENT_UPDATE ?
 +							"client" : "server");
 +}
 +
 +static ssize_t store_vis_mode(struct kobject *kobj, struct attribute *attr,
 +			      char *buff, size_t count)
 +{
 +	struct device *dev = to_dev(kobj->parent);
 +	struct net_device *net_dev = to_net_dev(dev);
 +	struct bat_priv *bat_priv = netdev_priv(net_dev);
 +	unsigned long val;
 +	int ret, vis_mode_tmp = -1;
 +
 +	ret = strict_strtoul(buff, 10, &val);
 +
 +	if (((count == 2) && (!ret) && (val == VIS_TYPE_CLIENT_UPDATE)) ||
 +	    (strncmp(buff, "client", 6) == 0) ||
 +	    (strncmp(buff, "off", 3) == 0))
 +		vis_mode_tmp = VIS_TYPE_CLIENT_UPDATE;
 +
 +	if (((count == 2) && (!ret) && (val == VIS_TYPE_SERVER_SYNC)) ||
 +	    (strncmp(buff, "server", 6) == 0))
 +		vis_mode_tmp = VIS_TYPE_SERVER_SYNC;
 +
 +	if (vis_mode_tmp < 0) {
 +		if (buff[count - 1] == '\n')
 +			buff[count - 1] = '\0';
 +
 +		bat_info(net_dev,
 +			 "Invalid parameter for 'vis mode' setting received: "
 +			 "%s\n", buff);
 +		return -EINVAL;
 +	}
 +
 +	if (atomic_read(&bat_priv->vis_mode) == vis_mode_tmp)
 +		return count;
 +
 +	bat_info(net_dev, "Changing vis mode from: %s to: %s\n",
 +		 atomic_read(&bat_priv->vis_mode) == VIS_TYPE_CLIENT_UPDATE ?
 +		 "client" : "server", vis_mode_tmp == VIS_TYPE_CLIENT_UPDATE ?
 +		 "client" : "server");
 +
 +	atomic_set(&bat_priv->vis_mode, (unsigned)vis_mode_tmp);
 +	return count;
 +}
 +
 +static ssize_t show_orig_interval(struct kobject *kobj, struct attribute *attr,
 +				 char *buff)
 +{
 +	struct device *dev = to_dev(kobj->parent);
 +	struct bat_priv *bat_priv = netdev_priv(to_net_dev(dev));
 +
 +	return sprintf(buff, "%i\n",
 +		       atomic_read(&bat_priv->orig_interval));
 +}
 +
 +static ssize_t store_orig_interval(struct kobject *kobj, struct attribute *attr,
 +				  char *buff, size_t count)
 +{
 +	struct device *dev = to_dev(kobj->parent);
 +	struct net_device *net_dev = to_net_dev(dev);
 +	struct bat_priv *bat_priv = netdev_priv(net_dev);
 +	unsigned long orig_interval_tmp;
 +	int ret;
 +
 +	ret = strict_strtoul(buff, 10, &orig_interval_tmp);
 +	if (ret) {
 +		bat_info(net_dev, "Invalid parameter for 'orig_interval' "
 +			 "setting received: %s\n", buff);
 +		return -EINVAL;
 +	}
 +
 +	if (orig_interval_tmp < JITTER * 2) {
 +		bat_info(net_dev, "New originator interval too small: %li "
 +			 "(min: %i)\n", orig_interval_tmp, JITTER * 2);
 +		return -EINVAL;
 +	}
 +
 +	if (atomic_read(&bat_priv->orig_interval) == orig_interval_tmp)
 +		return count;
 +
 +	bat_info(net_dev, "Changing originator interval from: %i to: %li\n",
 +		 atomic_read(&bat_priv->orig_interval),
 +		 orig_interval_tmp);
 +
 +	atomic_set(&bat_priv->orig_interval, orig_interval_tmp);
 +	return count;
 +}
 +
 +#ifdef CONFIG_BATMAN_ADV_DEBUG
 +static ssize_t show_log_level(struct kobject *kobj, struct attribute *attr,
 +			     char *buff)
 +{
 +	struct device *dev = to_dev(kobj->parent);
 +	struct bat_priv *bat_priv = netdev_priv(to_net_dev(dev));
 +	int log_level = atomic_read(&bat_priv->log_level);
 +
 +	return sprintf(buff, "%d\n", log_level);
 +}
 +
 +static ssize_t store_log_level(struct kobject *kobj, struct attribute *attr,
 +			      char *buff, size_t count)
 +{
 +	struct device *dev = to_dev(kobj->parent);
 +	struct net_device *net_dev = to_net_dev(dev);
 +	struct bat_priv *bat_priv = netdev_priv(net_dev);
 +	unsigned long log_level_tmp;
 +	int ret;
 +
 +	ret = strict_strtoul(buff, 10, &log_level_tmp);
 +	if (ret) {
 +		bat_info(net_dev, "Invalid parameter for 'log_level' "
 +			 "setting received: %s\n", buff);
 +		return -EINVAL;
 +	}
 +
 +	if (log_level_tmp > 3) {
 +		bat_info(net_dev, "New log level too big: %li "
 +			 "(max: %i)\n", log_level_tmp, 3);
 +		return -EINVAL;
 +	}
 +
 +	if (atomic_read(&bat_priv->log_level) == log_level_tmp)
 +		return count;
 +
 +	bat_info(net_dev, "Changing log level from: %i to: %li\n",
 +		 atomic_read(&bat_priv->log_level),
 +		 log_level_tmp);
 +
 +	atomic_set(&bat_priv->log_level, (unsigned)log_level_tmp);
 +	return count;
 +}
 +#endif
 +
 +static BAT_ATTR(aggregated_ogms, S_IRUGO | S_IWUSR,
 +		show_aggr_ogms, store_aggr_ogms);
 +static BAT_ATTR(bonding, S_IRUGO | S_IWUSR, show_bond, store_bond);
 +static BAT_ATTR(fragmentation, S_IRUGO | S_IWUSR, show_frag, store_frag);
 +static BAT_ATTR(vis_mode, S_IRUGO | S_IWUSR, show_vis_mode, store_vis_mode);
 +static BAT_ATTR(orig_interval, S_IRUGO | S_IWUSR,
 +		show_orig_interval, store_orig_interval);
 +#ifdef CONFIG_BATMAN_ADV_DEBUG
 +static BAT_ATTR(log_level, S_IRUGO | S_IWUSR, show_log_level, store_log_level);
 +#endif
 +
 +static struct bat_attribute *mesh_attrs[] = {
 +	&bat_attr_aggregated_ogms,
 +	&bat_attr_bonding,
 +	&bat_attr_fragmentation,
 +	&bat_attr_vis_mode,
 +	&bat_attr_orig_interval,
 +#ifdef CONFIG_BATMAN_ADV_DEBUG
 +	&bat_attr_log_level,
 +#endif
 +	NULL,
 +};
 +
 +int sysfs_add_meshif(struct net_device *dev)
 +{
 +	struct kobject *batif_kobject = &dev->dev.kobj;
 +	struct bat_priv *bat_priv = netdev_priv(dev);
 +	struct bat_attribute **bat_attr;
 +	int err;
 +
 +	bat_priv->mesh_obj = kobject_create_and_add(SYSFS_IF_MESH_SUBDIR,
 +						    batif_kobject);
 +	if (!bat_priv->mesh_obj) {
 +		bat_err(dev, "Can't add sysfs directory: %s/%s\n", dev->name,
 +			SYSFS_IF_MESH_SUBDIR);
 +		goto out;
 +	}
 +
 +	for (bat_attr = mesh_attrs; *bat_attr; ++bat_attr) {
 +		err = sysfs_create_file(bat_priv->mesh_obj,
 +					&((*bat_attr)->attr));
 +		if (err) {
 +			bat_err(dev, "Can't add sysfs file: %s/%s/%s\n",
 +				dev->name, SYSFS_IF_MESH_SUBDIR,
 +				((*bat_attr)->attr).name);
 +			goto rem_attr;
 +		}
 +	}
 +
 +	return 0;
 +
 +rem_attr:
 +	for (bat_attr = mesh_attrs; *bat_attr; ++bat_attr)
 +		sysfs_remove_file(bat_priv->mesh_obj, &((*bat_attr)->attr));
 +
 +	kobject_put(bat_priv->mesh_obj);
 +	bat_priv->mesh_obj = NULL;
 +out:
 +	return -ENOMEM;
 +}
 +
 +void sysfs_del_meshif(struct net_device *dev)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(dev);
 +	struct bat_attribute **bat_attr;
 +
 +	for (bat_attr = mesh_attrs; *bat_attr; ++bat_attr)
 +		sysfs_remove_file(bat_priv->mesh_obj, &((*bat_attr)->attr));
 +
 +	kobject_put(bat_priv->mesh_obj);
 +	bat_priv->mesh_obj = NULL;
 +}
 +
 +static ssize_t show_mesh_iface(struct kobject *kobj, struct attribute *attr,
 +			       char *buff)
 +{
 +	struct device *dev = to_dev(kobj->parent);
 +	struct net_device *net_dev = to_net_dev(dev);
 +	struct batman_if *batman_if = get_batman_if_by_netdev(net_dev);
++	ssize_t length;
 +
 +	if (!batman_if)
 +		return 0;
 +
- 	return sprintf(buff, "%s\n",
- 		       batman_if->if_status == IF_NOT_IN_USE ?
- 					"none" : batman_if->soft_iface->name);
++	length = sprintf(buff, "%s\n", batman_if->if_status == IF_NOT_IN_USE ?
++			 "none" : batman_if->soft_iface->name);
++
++	hardif_put(batman_if);
++
++	return length;
 +}
 +
 +static ssize_t store_mesh_iface(struct kobject *kobj, struct attribute *attr,
 +				char *buff, size_t count)
 +{
 +	struct device *dev = to_dev(kobj->parent);
 +	struct net_device *net_dev = to_net_dev(dev);
 +	struct batman_if *batman_if = get_batman_if_by_netdev(net_dev);
 +	int status_tmp = -1;
++	int ret;
 +
 +	if (!batman_if)
 +		return count;
 +
 +	if (buff[count - 1] == '\n')
 +		buff[count - 1] = '\0';
 +
 +	if (strlen(buff) >= IFNAMSIZ) {
 +		pr_err("Invalid parameter for 'mesh_iface' setting received: "
 +		       "interface name too long '%s'\n", buff);
++		hardif_put(batman_if);
 +		return -EINVAL;
 +	}
 +
 +	if (strncmp(buff, "none", 4) == 0)
 +		status_tmp = IF_NOT_IN_USE;
 +	else
 +		status_tmp = IF_I_WANT_YOU;
 +
 +	if ((batman_if->if_status == status_tmp) || ((batman_if->soft_iface) &&
- 	    (strncmp(batman_if->soft_iface->name, buff, IFNAMSIZ) == 0)))
++	    (strncmp(batman_if->soft_iface->name, buff, IFNAMSIZ) == 0))) {
++		hardif_put(batman_if);
 +		return count;
++	}
 +
 +	if (status_tmp == IF_NOT_IN_USE) {
 +		rtnl_lock();
 +		hardif_disable_interface(batman_if);
 +		rtnl_unlock();
++		hardif_put(batman_if);
 +		return count;
 +	}
 +
 +	/* if the interface already is in use */
 +	if (batman_if->if_status != IF_NOT_IN_USE) {
 +		rtnl_lock();
 +		hardif_disable_interface(batman_if);
 +		rtnl_unlock();
 +	}
 +
- 	return hardif_enable_interface(batman_if, buff);
++	ret = hardif_enable_interface(batman_if, buff);
++	hardif_put(batman_if);
++
++	return ret;
 +}
 +
 +static ssize_t show_iface_status(struct kobject *kobj, struct attribute *attr,
 +				 char *buff)
 +{
 +	struct device *dev = to_dev(kobj->parent);
 +	struct net_device *net_dev = to_net_dev(dev);
 +	struct batman_if *batman_if = get_batman_if_by_netdev(net_dev);
++	ssize_t length;
 +
 +	if (!batman_if)
 +		return 0;
 +
 +	switch (batman_if->if_status) {
 +	case IF_TO_BE_REMOVED:
- 		return sprintf(buff, "disabling\n");
++		length = sprintf(buff, "disabling\n");
++		break;
 +	case IF_INACTIVE:
- 		return sprintf(buff, "inactive\n");
++		length = sprintf(buff, "inactive\n");
++		break;
 +	case IF_ACTIVE:
- 		return sprintf(buff, "active\n");
++		length = sprintf(buff, "active\n");
++		break;
 +	case IF_TO_BE_ACTIVATED:
- 		return sprintf(buff, "enabling\n");
++		length = sprintf(buff, "enabling\n");
++		break;
 +	case IF_NOT_IN_USE:
 +	default:
- 		return sprintf(buff, "not in use\n");
++		length = sprintf(buff, "not in use\n");
++		break;
 +	}
++
++	hardif_put(batman_if);
++
++	return length;
 +}
 +
 +static BAT_ATTR(mesh_iface, S_IRUGO | S_IWUSR,
 +		show_mesh_iface, store_mesh_iface);
 +static BAT_ATTR(iface_status, S_IRUGO, show_iface_status, NULL);
 +
 +static struct bat_attribute *batman_attrs[] = {
 +	&bat_attr_mesh_iface,
 +	&bat_attr_iface_status,
 +	NULL,
 +};
 +
 +int sysfs_add_hardif(struct kobject **hardif_obj, struct net_device *dev)
 +{
 +	struct kobject *hardif_kobject = &dev->dev.kobj;
 +	struct bat_attribute **bat_attr;
 +	int err;
 +
 +	*hardif_obj = kobject_create_and_add(SYSFS_IF_BAT_SUBDIR,
 +						    hardif_kobject);
 +
 +	if (!*hardif_obj) {
 +		bat_err(dev, "Can't add sysfs directory: %s/%s\n", dev->name,
 +			SYSFS_IF_BAT_SUBDIR);
 +		goto out;
 +	}
 +
 +	for (bat_attr = batman_attrs; *bat_attr; ++bat_attr) {
 +		err = sysfs_create_file(*hardif_obj, &((*bat_attr)->attr));
 +		if (err) {
 +			bat_err(dev, "Can't add sysfs file: %s/%s/%s\n",
 +				dev->name, SYSFS_IF_BAT_SUBDIR,
 +				((*bat_attr)->attr).name);
 +			goto rem_attr;
 +		}
 +	}
 +
 +	return 0;
 +
 +rem_attr:
 +	for (bat_attr = batman_attrs; *bat_attr; ++bat_attr)
 +		sysfs_remove_file(*hardif_obj, &((*bat_attr)->attr));
 +out:
 +	return -ENOMEM;
 +}
 +
 +void sysfs_del_hardif(struct kobject **hardif_obj)
 +{
 +	kobject_put(*hardif_obj);
 +	*hardif_obj = NULL;
 +}
diff --combined drivers/staging/batman-adv/hard-interface.c
index a587da9,0000000..7b77cf2
mode 100644,000000..100644
--- a/drivers/staging/batman-adv/hard-interface.c
+++ b/drivers/staging/batman-adv/hard-interface.c
@@@ -1,596 -1,0 +1,637 @@@
 +/*
 + * Copyright (C) 2007-2010 B.A.T.M.A.N. contributors:
 + *
 + * Marek Lindner, Simon Wunderlich
 + *
 + * 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, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 + * 02110-1301, USA
 + *
 + */
 +
 +#include "main.h"
 +#include "hard-interface.h"
 +#include "soft-interface.h"
 +#include "send.h"
 +#include "translation-table.h"
 +#include "routing.h"
 +#include "bat_sysfs.h"
 +#include "originator.h"
 +#include "hash.h"
 +
 +#include <linux/if_arp.h>
 +
 +#define MIN(x, y) ((x) < (y) ? (x) : (y))
 +
++/* protect update critical side of if_list - but not the content */
++static DEFINE_SPINLOCK(if_list_lock);
++
 +struct batman_if *get_batman_if_by_netdev(struct net_device *net_dev)
 +{
 +	struct batman_if *batman_if;
 +
 +	rcu_read_lock();
 +	list_for_each_entry_rcu(batman_if, &if_list, list) {
 +		if (batman_if->net_dev == net_dev)
 +			goto out;
 +	}
 +
 +	batman_if = NULL;
 +
 +out:
++	if (batman_if)
++		hardif_hold(batman_if);
++
 +	rcu_read_unlock();
 +	return batman_if;
 +}
 +
 +static int is_valid_iface(struct net_device *net_dev)
 +{
 +	if (net_dev->flags & IFF_LOOPBACK)
 +		return 0;
 +
 +	if (net_dev->type != ARPHRD_ETHER)
 +		return 0;
 +
 +	if (net_dev->addr_len != ETH_ALEN)
 +		return 0;
 +
 +	/* no batman over batman */
 +#ifdef HAVE_NET_DEVICE_OPS
 +	if (net_dev->netdev_ops->ndo_start_xmit == interface_tx)
 +		return 0;
 +#else
 +	if (net_dev->hard_start_xmit == interface_tx)
 +		return 0;
 +#endif
 +
 +	/* Device is being bridged */
 +	/* if (net_dev->priv_flags & IFF_BRIDGE_PORT)
 +		return 0; */
 +
 +	return 1;
 +}
 +
 +static struct batman_if *get_active_batman_if(struct net_device *soft_iface)
 +{
 +	struct batman_if *batman_if;
 +
 +	rcu_read_lock();
 +	list_for_each_entry_rcu(batman_if, &if_list, list) {
 +		if (batman_if->soft_iface != soft_iface)
 +			continue;
 +
 +		if (batman_if->if_status == IF_ACTIVE)
 +			goto out;
 +	}
 +
 +	batman_if = NULL;
 +
 +out:
++	if (batman_if)
++		hardif_hold(batman_if);
++
 +	rcu_read_unlock();
 +	return batman_if;
 +}
 +
++static void update_primary_addr(struct bat_priv *bat_priv)
++{
++	struct vis_packet *vis_packet;
++
++	vis_packet = (struct vis_packet *)
++				bat_priv->my_vis_info->skb_packet->data;
++	memcpy(vis_packet->vis_orig,
++	       bat_priv->primary_if->net_dev->dev_addr, ETH_ALEN);
++	memcpy(vis_packet->sender_orig,
++	       bat_priv->primary_if->net_dev->dev_addr, ETH_ALEN);
++}
++
 +static void set_primary_if(struct bat_priv *bat_priv,
 +			   struct batman_if *batman_if)
 +{
 +	struct batman_packet *batman_packet;
- 	struct vis_packet *vis_packet;
++	struct batman_if *old_if;
 +
++	if (batman_if)
++		hardif_hold(batman_if);
++
++	old_if = bat_priv->primary_if;
 +	bat_priv->primary_if = batman_if;
 +
++	if (old_if)
++		hardif_put(old_if);
++
 +	if (!bat_priv->primary_if)
 +		return;
 +
 +	batman_packet = (struct batman_packet *)(batman_if->packet_buff);
 +	batman_packet->flags = PRIMARIES_FIRST_HOP;
 +	batman_packet->ttl = TTL;
 +
- 	vis_packet = (struct vis_packet *)
- 				bat_priv->my_vis_info->skb_packet->data;
- 	memcpy(vis_packet->vis_orig,
- 	       bat_priv->primary_if->net_dev->dev_addr, ETH_ALEN);
- 	memcpy(vis_packet->sender_orig,
- 	       bat_priv->primary_if->net_dev->dev_addr, ETH_ALEN);
++	update_primary_addr(bat_priv);
 +
 +	/***
 +	 * hacky trick to make sure that we send the HNA information via
 +	 * our new primary interface
 +	 */
 +	atomic_set(&bat_priv->hna_local_changed, 1);
 +}
 +
 +static bool hardif_is_iface_up(struct batman_if *batman_if)
 +{
 +	if (batman_if->net_dev->flags & IFF_UP)
 +		return true;
 +
 +	return false;
 +}
 +
 +static void update_mac_addresses(struct batman_if *batman_if)
 +{
 +	addr_to_string(batman_if->addr_str, batman_if->net_dev->dev_addr);
 +
 +	memcpy(((struct batman_packet *)(batman_if->packet_buff))->orig,
 +	       batman_if->net_dev->dev_addr, ETH_ALEN);
 +	memcpy(((struct batman_packet *)(batman_if->packet_buff))->prev_sender,
 +	       batman_if->net_dev->dev_addr, ETH_ALEN);
 +}
 +
 +static void check_known_mac_addr(uint8_t *addr)
 +{
 +	struct batman_if *batman_if;
 +
 +	rcu_read_lock();
 +	list_for_each_entry_rcu(batman_if, &if_list, list) {
 +		if ((batman_if->if_status != IF_ACTIVE) &&
 +		    (batman_if->if_status != IF_TO_BE_ACTIVATED))
 +			continue;
 +
 +		if (!compare_orig(batman_if->net_dev->dev_addr, addr))
 +			continue;
 +
 +		pr_warning("The newly added mac address (%pM) already exists "
 +			   "on: %s\n", addr, batman_if->net_dev->name);
 +		pr_warning("It is strongly recommended to keep mac addresses "
 +			   "unique to avoid problems!\n");
 +	}
 +	rcu_read_unlock();
 +}
 +
 +int hardif_min_mtu(struct net_device *soft_iface)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(soft_iface);
 +	struct batman_if *batman_if;
 +	/* allow big frames if all devices are capable to do so
 +	 * (have MTU > 1500 + BAT_HEADER_LEN) */
 +	int min_mtu = ETH_DATA_LEN;
 +
 +	if (atomic_read(&bat_priv->frag_enabled))
 +		goto out;
 +
 +	rcu_read_lock();
 +	list_for_each_entry_rcu(batman_if, &if_list, list) {
 +		if ((batman_if->if_status != IF_ACTIVE) &&
 +		    (batman_if->if_status != IF_TO_BE_ACTIVATED))
 +			continue;
 +
 +		if (batman_if->soft_iface != soft_iface)
 +			continue;
 +
 +		min_mtu = MIN(batman_if->net_dev->mtu - BAT_HEADER_LEN,
 +			      min_mtu);
 +	}
 +	rcu_read_unlock();
 +out:
 +	return min_mtu;
 +}
 +
 +/* adjusts the MTU if a new interface with a smaller MTU appeared. */
 +void update_min_mtu(struct net_device *soft_iface)
 +{
 +	int min_mtu;
 +
 +	min_mtu = hardif_min_mtu(soft_iface);
 +	if (soft_iface->mtu != min_mtu)
 +		soft_iface->mtu = min_mtu;
 +}
 +
 +static void hardif_activate_interface(struct batman_if *batman_if)
 +{
 +	struct bat_priv *bat_priv;
 +
 +	if (batman_if->if_status != IF_INACTIVE)
 +		return;
 +
 +	bat_priv = netdev_priv(batman_if->soft_iface);
 +
 +	update_mac_addresses(batman_if);
 +	batman_if->if_status = IF_TO_BE_ACTIVATED;
 +
 +	/**
 +	 * the first active interface becomes our primary interface or
 +	 * the next active interface after the old primay interface was removed
 +	 */
 +	if (!bat_priv->primary_if)
 +		set_primary_if(bat_priv, batman_if);
 +
 +	bat_info(batman_if->soft_iface, "Interface activated: %s\n",
 +		 batman_if->net_dev->name);
 +
 +	update_min_mtu(batman_if->soft_iface);
 +	return;
 +}
 +
 +static void hardif_deactivate_interface(struct batman_if *batman_if)
 +{
 +	if ((batman_if->if_status != IF_ACTIVE) &&
 +	   (batman_if->if_status != IF_TO_BE_ACTIVATED))
 +		return;
 +
 +	batman_if->if_status = IF_INACTIVE;
 +
 +	bat_info(batman_if->soft_iface, "Interface deactivated: %s\n",
 +		 batman_if->net_dev->name);
 +
 +	update_min_mtu(batman_if->soft_iface);
 +}
 +
 +int hardif_enable_interface(struct batman_if *batman_if, char *iface_name)
 +{
 +	struct bat_priv *bat_priv;
 +	struct batman_packet *batman_packet;
 +
 +	if (batman_if->if_status != IF_NOT_IN_USE)
 +		goto out;
 +
 +	batman_if->soft_iface = dev_get_by_name(&init_net, iface_name);
 +
 +	if (!batman_if->soft_iface) {
 +		batman_if->soft_iface = softif_create(iface_name);
 +
 +		if (!batman_if->soft_iface)
 +			goto err;
 +
 +		/* dev_get_by_name() increases the reference counter for us */
 +		dev_hold(batman_if->soft_iface);
 +	}
 +
 +	bat_priv = netdev_priv(batman_if->soft_iface);
 +	batman_if->packet_len = BAT_PACKET_LEN;
 +	batman_if->packet_buff = kmalloc(batman_if->packet_len, GFP_ATOMIC);
 +
 +	if (!batman_if->packet_buff) {
 +		bat_err(batman_if->soft_iface, "Can't add interface packet "
 +			"(%s): out of memory\n", batman_if->net_dev->name);
 +		goto err;
 +	}
 +
 +	batman_packet = (struct batman_packet *)(batman_if->packet_buff);
 +	batman_packet->packet_type = BAT_PACKET;
 +	batman_packet->version = COMPAT_VERSION;
 +	batman_packet->flags = 0;
 +	batman_packet->ttl = 2;
 +	batman_packet->tq = TQ_MAX_VALUE;
 +	batman_packet->num_hna = 0;
 +
 +	batman_if->if_num = bat_priv->num_ifaces;
 +	bat_priv->num_ifaces++;
 +	batman_if->if_status = IF_INACTIVE;
 +	orig_hash_add_if(batman_if, bat_priv->num_ifaces);
 +
 +	batman_if->batman_adv_ptype.type = __constant_htons(ETH_P_BATMAN);
 +	batman_if->batman_adv_ptype.func = batman_skb_recv;
 +	batman_if->batman_adv_ptype.dev = batman_if->net_dev;
++	hardif_hold(batman_if);
 +	dev_add_pack(&batman_if->batman_adv_ptype);
 +
 +	atomic_set(&batman_if->seqno, 1);
 +	atomic_set(&batman_if->frag_seqno, 1);
 +	bat_info(batman_if->soft_iface, "Adding interface: %s\n",
 +		 batman_if->net_dev->name);
 +
 +	if (atomic_read(&bat_priv->frag_enabled) && batman_if->net_dev->mtu <
 +		ETH_DATA_LEN + BAT_HEADER_LEN)
 +		bat_info(batman_if->soft_iface,
 +			"The MTU of interface %s is too small (%i) to handle "
 +			"the transport of batman-adv packets. Packets going "
 +			"over this interface will be fragmented on layer2 "
 +			"which could impact the performance. Setting the MTU "
 +			"to %zi would solve the problem.\n",
 +			batman_if->net_dev->name, batman_if->net_dev->mtu,
 +			ETH_DATA_LEN + BAT_HEADER_LEN);
 +
 +	if (!atomic_read(&bat_priv->frag_enabled) && batman_if->net_dev->mtu <
 +		ETH_DATA_LEN + BAT_HEADER_LEN)
 +		bat_info(batman_if->soft_iface,
 +			"The MTU of interface %s is too small (%i) to handle "
 +			"the transport of batman-adv packets. If you experience"
 +			" problems getting traffic through try increasing the "
 +			"MTU to %zi.\n",
 +			batman_if->net_dev->name, batman_if->net_dev->mtu,
 +			ETH_DATA_LEN + BAT_HEADER_LEN);
 +
 +	if (hardif_is_iface_up(batman_if))
 +		hardif_activate_interface(batman_if);
 +	else
 +		bat_err(batman_if->soft_iface, "Not using interface %s "
 +			"(retrying later): interface not active\n",
 +			batman_if->net_dev->name);
 +
 +	/* begin scheduling originator messages on that interface */
 +	schedule_own_packet(batman_if);
 +
 +out:
 +	return 0;
 +
 +err:
 +	return -ENOMEM;
 +}
 +
 +void hardif_disable_interface(struct batman_if *batman_if)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(batman_if->soft_iface);
 +
 +	if (batman_if->if_status == IF_ACTIVE)
 +		hardif_deactivate_interface(batman_if);
 +
 +	if (batman_if->if_status != IF_INACTIVE)
 +		return;
 +
 +	bat_info(batman_if->soft_iface, "Removing interface: %s\n",
 +		 batman_if->net_dev->name);
 +	dev_remove_pack(&batman_if->batman_adv_ptype);
++	hardif_put(batman_if);
 +
 +	bat_priv->num_ifaces--;
 +	orig_hash_del_if(batman_if, bat_priv->num_ifaces);
 +
- 	if (batman_if == bat_priv->primary_if)
- 		set_primary_if(bat_priv,
- 			       get_active_batman_if(batman_if->soft_iface));
++	if (batman_if == bat_priv->primary_if) {
++		struct batman_if *new_if;
++
++		new_if = get_active_batman_if(batman_if->soft_iface);
++		set_primary_if(bat_priv, new_if);
++
++		if (new_if)
++			hardif_put(new_if);
++	}
 +
 +	kfree(batman_if->packet_buff);
 +	batman_if->packet_buff = NULL;
 +	batman_if->if_status = IF_NOT_IN_USE;
 +
 +	/* delete all references to this batman_if */
 +	purge_orig_ref(bat_priv);
 +	purge_outstanding_packets(bat_priv, batman_if);
 +	dev_put(batman_if->soft_iface);
 +
 +	/* nobody uses this interface anymore */
 +	if (!bat_priv->num_ifaces)
 +		softif_destroy(batman_if->soft_iface);
 +
 +	batman_if->soft_iface = NULL;
 +}
 +
 +static struct batman_if *hardif_add_interface(struct net_device *net_dev)
 +{
 +	struct batman_if *batman_if;
 +	int ret;
 +
 +	ret = is_valid_iface(net_dev);
 +	if (ret != 1)
 +		goto out;
 +
 +	dev_hold(net_dev);
 +
 +	batman_if = kmalloc(sizeof(struct batman_if), GFP_ATOMIC);
 +	if (!batman_if) {
 +		pr_err("Can't add interface (%s): out of memory\n",
 +		       net_dev->name);
 +		goto release_dev;
 +	}
 +
 +	ret = sysfs_add_hardif(&batman_if->hardif_obj, net_dev);
 +	if (ret)
 +		goto free_if;
 +
 +	batman_if->if_num = -1;
 +	batman_if->net_dev = net_dev;
 +	batman_if->soft_iface = NULL;
 +	batman_if->if_status = IF_NOT_IN_USE;
 +	INIT_LIST_HEAD(&batman_if->list);
++	atomic_set(&batman_if->refcnt, 0);
++	hardif_hold(batman_if);
 +
 +	check_known_mac_addr(batman_if->net_dev->dev_addr);
++
++	spin_lock(&if_list_lock);
 +	list_add_tail_rcu(&batman_if->list, &if_list);
++	spin_unlock(&if_list_lock);
++
++	/* extra reference for return */
++	hardif_hold(batman_if);
 +	return batman_if;
 +
 +free_if:
 +	kfree(batman_if);
 +release_dev:
 +	dev_put(net_dev);
 +out:
 +	return NULL;
 +}
 +
- static void hardif_free_interface(struct rcu_head *rcu)
- {
- 	struct batman_if *batman_if = container_of(rcu, struct batman_if, rcu);
- 
- 	kfree(batman_if);
- }
- 
 +static void hardif_remove_interface(struct batman_if *batman_if)
 +{
 +	/* first deactivate interface */
 +	if (batman_if->if_status != IF_NOT_IN_USE)
 +		hardif_disable_interface(batman_if);
 +
 +	if (batman_if->if_status != IF_NOT_IN_USE)
 +		return;
 +
 +	batman_if->if_status = IF_TO_BE_REMOVED;
++
++	/* caller must take if_list_lock */
 +	list_del_rcu(&batman_if->list);
++	synchronize_rcu();
 +	sysfs_del_hardif(&batman_if->hardif_obj);
- 	dev_put(batman_if->net_dev);
- 	call_rcu(&batman_if->rcu, hardif_free_interface);
++	hardif_put(batman_if);
 +}
 +
 +void hardif_remove_interfaces(void)
 +{
 +	struct batman_if *batman_if, *batman_if_tmp;
 +
++	rtnl_lock();
++	spin_lock(&if_list_lock);
 +	list_for_each_entry_safe(batman_if, batman_if_tmp, &if_list, list) {
- 		rtnl_lock();
 +		hardif_remove_interface(batman_if);
- 		rtnl_unlock();
 +	}
++	spin_unlock(&if_list_lock);
++	rtnl_unlock();
 +}
 +
 +static int hard_if_event(struct notifier_block *this,
 +			 unsigned long event, void *ptr)
 +{
 +	struct net_device *net_dev = (struct net_device *)ptr;
 +	struct batman_if *batman_if = get_batman_if_by_netdev(net_dev);
 +	struct bat_priv *bat_priv;
 +
 +	if (!batman_if && event == NETDEV_REGISTER)
- 			batman_if = hardif_add_interface(net_dev);
++		batman_if = hardif_add_interface(net_dev);
 +
 +	if (!batman_if)
 +		goto out;
 +
 +	switch (event) {
 +	case NETDEV_UP:
 +		hardif_activate_interface(batman_if);
 +		break;
 +	case NETDEV_GOING_DOWN:
 +	case NETDEV_DOWN:
 +		hardif_deactivate_interface(batman_if);
 +		break;
 +	case NETDEV_UNREGISTER:
++		spin_lock(&if_list_lock);
 +		hardif_remove_interface(batman_if);
++		spin_unlock(&if_list_lock);
 +		break;
 +	case NETDEV_CHANGEMTU:
 +		if (batman_if->soft_iface)
 +			update_min_mtu(batman_if->soft_iface);
 +		break;
 +	case NETDEV_CHANGEADDR:
- 		if (batman_if->if_status == IF_NOT_IN_USE)
++		if (batman_if->if_status == IF_NOT_IN_USE) {
++			hardif_put(batman_if);
 +			goto out;
++		}
 +
 +		check_known_mac_addr(batman_if->net_dev->dev_addr);
 +		update_mac_addresses(batman_if);
 +
 +		bat_priv = netdev_priv(batman_if->soft_iface);
 +		if (batman_if == bat_priv->primary_if)
- 			set_primary_if(bat_priv, batman_if);
++			update_primary_addr(bat_priv);
 +		break;
 +	default:
 +		break;
 +	};
++	hardif_put(batman_if);
 +
 +out:
 +	return NOTIFY_DONE;
 +}
 +
 +/* receive a packet with the batman ethertype coming on a hard
 + * interface */
 +int batman_skb_recv(struct sk_buff *skb, struct net_device *dev,
 +	struct packet_type *ptype, struct net_device *orig_dev)
 +{
 +	struct bat_priv *bat_priv;
 +	struct batman_packet *batman_packet;
 +	struct batman_if *batman_if;
 +	int ret;
 +
 +	batman_if = container_of(ptype, struct batman_if, batman_adv_ptype);
 +	skb = skb_share_check(skb, GFP_ATOMIC);
 +
 +	/* skb was released by skb_share_check() */
 +	if (!skb)
 +		goto err_out;
 +
 +	/* packet should hold at least type and version */
 +	if (unlikely(!pskb_may_pull(skb, 2)))
 +		goto err_free;
 +
 +	/* expect a valid ethernet header here. */
 +	if (unlikely(skb->mac_len != sizeof(struct ethhdr)
 +				|| !skb_mac_header(skb)))
 +		goto err_free;
 +
 +	if (!batman_if->soft_iface)
 +		goto err_free;
 +
 +	bat_priv = netdev_priv(batman_if->soft_iface);
 +
 +	if (atomic_read(&bat_priv->mesh_state) != MESH_ACTIVE)
 +		goto err_free;
 +
 +	/* discard frames on not active interfaces */
 +	if (batman_if->if_status != IF_ACTIVE)
 +		goto err_free;
 +
 +	batman_packet = (struct batman_packet *)skb->data;
 +
 +	if (batman_packet->version != COMPAT_VERSION) {
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"Drop packet: incompatible batman version (%i)\n",
 +			batman_packet->version);
 +		goto err_free;
 +	}
 +
 +	/* all receive handlers return whether they received or reused
 +	 * the supplied skb. if not, we have to free the skb. */
 +
 +	switch (batman_packet->packet_type) {
 +		/* batman originator packet */
 +	case BAT_PACKET:
 +		ret = recv_bat_packet(skb, batman_if);
 +		break;
 +
 +		/* batman icmp packet */
 +	case BAT_ICMP:
 +		ret = recv_icmp_packet(skb, batman_if);
 +		break;
 +
 +		/* unicast packet */
 +	case BAT_UNICAST:
 +		ret = recv_unicast_packet(skb, batman_if);
 +		break;
 +
 +		/* fragmented unicast packet */
 +	case BAT_UNICAST_FRAG:
 +		ret = recv_ucast_frag_packet(skb, batman_if);
 +		break;
 +
 +		/* broadcast packet */
 +	case BAT_BCAST:
 +		ret = recv_bcast_packet(skb, batman_if);
 +		break;
 +
 +		/* vis packet */
 +	case BAT_VIS:
 +		ret = recv_vis_packet(skb, batman_if);
 +		break;
 +	default:
 +		ret = NET_RX_DROP;
 +	}
 +
 +	if (ret == NET_RX_DROP)
 +		kfree_skb(skb);
 +
 +	/* return NET_RX_SUCCESS in any case as we
 +	 * most probably dropped the packet for
 +	 * routing-logical reasons. */
 +
 +	return NET_RX_SUCCESS;
 +
 +err_free:
 +	kfree_skb(skb);
 +err_out:
 +	return NET_RX_DROP;
 +}
 +
 +struct notifier_block hard_if_notifier = {
 +	.notifier_call = hard_if_event,
 +};
diff --combined drivers/staging/batman-adv/hard-interface.h
index 4b49527,d550889..d550889
--- a/drivers/staging/batman-adv/hard-interface.h
+++ b/drivers/staging/batman-adv/hard-interface.h
@@@ -42,4 -42,17 +42,17 @@@ int batman_skb_recv(struct sk_buff *skb
  int hardif_min_mtu(struct net_device *soft_iface);
  void update_min_mtu(struct net_device *soft_iface);
+ static inline void hardif_hold(struct batman_if *batman_if)
+ {
+ 	atomic_inc(&batman_if->refcnt);
+ }
+ 
+ static inline void hardif_put(struct batman_if *batman_if)
+ {
+ 	if (atomic_dec_and_test(&batman_if->refcnt)) {
+ 		dev_put(batman_if->net_dev);
+ 		kfree(batman_if);
+ 	}
+ }
+ 
  #endif /* _NET_BATMAN_ADV_HARD_INTERFACE_H_ */
diff --combined drivers/staging/batman-adv/icmp_socket.c
index 24627be,0000000..48856ca
mode 100644,000000..100644
--- a/drivers/staging/batman-adv/icmp_socket.c
+++ b/drivers/staging/batman-adv/icmp_socket.c
@@@ -1,356 -1,0 +1,359 @@@
 +/*
 + * Copyright (C) 2007-2010 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, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 + * 02110-1301, USA
 + *
 + */
 +
 +#include "main.h"
 +#include <linux/debugfs.h>
 +#include <linux/slab.h>
 +#include "icmp_socket.h"
 +#include "send.h"
 +#include "types.h"
 +#include "hash.h"
 +#include "hard-interface.h"
 +
 +
 +static struct socket_client *socket_client_hash[256];
 +
 +static void bat_socket_add_packet(struct socket_client *socket_client,
 +				  struct icmp_packet_rr *icmp_packet,
 +				  size_t icmp_len);
 +
 +void bat_socket_init(void)
 +{
 +	memset(socket_client_hash, 0, sizeof(socket_client_hash));
 +}
 +
 +static int bat_socket_open(struct inode *inode, struct file *file)
 +{
 +	unsigned int i;
 +	struct socket_client *socket_client;
 +
++	nonseekable_open(inode, file);
++
 +	socket_client = kmalloc(sizeof(struct socket_client), GFP_KERNEL);
 +
 +	if (!socket_client)
 +		return -ENOMEM;
 +
 +	for (i = 0; i < ARRAY_SIZE(socket_client_hash); i++) {
 +		if (!socket_client_hash[i]) {
 +			socket_client_hash[i] = socket_client;
 +			break;
 +		}
 +	}
 +
 +	if (i == ARRAY_SIZE(socket_client_hash)) {
 +		pr_err("Error - can't add another packet client: "
 +		       "maximum number of clients reached\n");
 +		kfree(socket_client);
 +		return -EXFULL;
 +	}
 +
 +	INIT_LIST_HEAD(&socket_client->queue_list);
 +	socket_client->queue_len = 0;
 +	socket_client->index = i;
 +	socket_client->bat_priv = inode->i_private;
 +	spin_lock_init(&socket_client->lock);
 +	init_waitqueue_head(&socket_client->queue_wait);
 +
 +	file->private_data = socket_client;
 +
 +	inc_module_count();
 +	return 0;
 +}
 +
 +static int bat_socket_release(struct inode *inode, struct file *file)
 +{
 +	struct socket_client *socket_client = file->private_data;
 +	struct socket_packet *socket_packet;
 +	struct list_head *list_pos, *list_pos_tmp;
 +	unsigned long flags;
 +
 +	spin_lock_irqsave(&socket_client->lock, flags);
 +
 +	/* for all packets in the queue ... */
 +	list_for_each_safe(list_pos, list_pos_tmp, &socket_client->queue_list) {
 +		socket_packet = list_entry(list_pos,
 +					   struct socket_packet, list);
 +
 +		list_del(list_pos);
 +		kfree(socket_packet);
 +	}
 +
 +	socket_client_hash[socket_client->index] = NULL;
 +	spin_unlock_irqrestore(&socket_client->lock, flags);
 +
 +	kfree(socket_client);
 +	dec_module_count();
 +
 +	return 0;
 +}
 +
 +static ssize_t bat_socket_read(struct file *file, char __user *buf,
 +			       size_t count, loff_t *ppos)
 +{
 +	struct socket_client *socket_client = file->private_data;
 +	struct socket_packet *socket_packet;
 +	size_t packet_len;
 +	int error;
 +	unsigned long flags;
 +
 +	if ((file->f_flags & O_NONBLOCK) && (socket_client->queue_len == 0))
 +		return -EAGAIN;
 +
 +	if ((!buf) || (count < sizeof(struct icmp_packet)))
 +		return -EINVAL;
 +
 +	if (!access_ok(VERIFY_WRITE, buf, count))
 +		return -EFAULT;
 +
 +	error = wait_event_interruptible(socket_client->queue_wait,
 +					 socket_client->queue_len);
 +
 +	if (error)
 +		return error;
 +
 +	spin_lock_irqsave(&socket_client->lock, flags);
 +
 +	socket_packet = list_first_entry(&socket_client->queue_list,
 +					 struct socket_packet, list);
 +	list_del(&socket_packet->list);
 +	socket_client->queue_len--;
 +
 +	spin_unlock_irqrestore(&socket_client->lock, flags);
 +
 +	error = __copy_to_user(buf, &socket_packet->icmp_packet,
 +			       socket_packet->icmp_len);
 +
 +	packet_len = socket_packet->icmp_len;
 +	kfree(socket_packet);
 +
 +	if (error)
 +		return -EFAULT;
 +
 +	return packet_len;
 +}
 +
 +static ssize_t bat_socket_write(struct file *file, const char __user *buff,
 +				size_t len, loff_t *off)
 +{
 +	struct socket_client *socket_client = file->private_data;
 +	struct bat_priv *bat_priv = socket_client->bat_priv;
 +	struct sk_buff *skb;
 +	struct icmp_packet_rr *icmp_packet;
 +
 +	struct orig_node *orig_node;
 +	struct batman_if *batman_if;
 +	size_t packet_len = sizeof(struct icmp_packet);
 +	uint8_t dstaddr[ETH_ALEN];
 +	unsigned long flags;
 +
 +	if (len < sizeof(struct icmp_packet)) {
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"Error - can't send packet from char device: "
 +			"invalid packet size\n");
 +		return -EINVAL;
 +	}
 +
 +	if (!bat_priv->primary_if)
 +		return -EFAULT;
 +
 +	if (len >= sizeof(struct icmp_packet_rr))
 +		packet_len = sizeof(struct icmp_packet_rr);
 +
 +	skb = dev_alloc_skb(packet_len + sizeof(struct ethhdr));
 +	if (!skb)
 +		return -ENOMEM;
 +
 +	skb_reserve(skb, sizeof(struct ethhdr));
 +	icmp_packet = (struct icmp_packet_rr *)skb_put(skb, packet_len);
 +
 +	if (!access_ok(VERIFY_READ, buff, packet_len)) {
 +		len = -EFAULT;
 +		goto free_skb;
 +	}
 +
 +	if (__copy_from_user(icmp_packet, buff, packet_len)) {
 +		len = -EFAULT;
 +		goto free_skb;
 +	}
 +
 +	if (icmp_packet->packet_type != BAT_ICMP) {
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"Error - can't send packet from char device: "
 +			"got bogus packet type (expected: BAT_ICMP)\n");
 +		len = -EINVAL;
 +		goto free_skb;
 +	}
 +
 +	if (icmp_packet->msg_type != ECHO_REQUEST) {
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"Error - can't send packet from char device: "
 +			"got bogus message type (expected: ECHO_REQUEST)\n");
 +		len = -EINVAL;
 +		goto free_skb;
 +	}
 +
 +	icmp_packet->uid = socket_client->index;
 +
 +	if (icmp_packet->version != COMPAT_VERSION) {
 +		icmp_packet->msg_type = PARAMETER_PROBLEM;
 +		icmp_packet->ttl = COMPAT_VERSION;
 +		bat_socket_add_packet(socket_client, icmp_packet, packet_len);
 +		goto free_skb;
 +	}
 +
 +	if (atomic_read(&bat_priv->mesh_state) != MESH_ACTIVE)
 +		goto dst_unreach;
 +
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +	orig_node = ((struct orig_node *)hash_find(bat_priv->orig_hash,
 +						   icmp_packet->dst));
 +
 +	if (!orig_node)
 +		goto unlock;
 +
 +	if (!orig_node->router)
 +		goto unlock;
 +
 +	batman_if = orig_node->router->if_incoming;
 +	memcpy(dstaddr, orig_node->router->addr, ETH_ALEN);
 +
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +	if (!batman_if)
 +		goto dst_unreach;
 +
 +	if (batman_if->if_status != IF_ACTIVE)
 +		goto dst_unreach;
 +
 +	memcpy(icmp_packet->orig,
 +	       bat_priv->primary_if->net_dev->dev_addr, ETH_ALEN);
 +
 +	if (packet_len == sizeof(struct icmp_packet_rr))
 +		memcpy(icmp_packet->rr, batman_if->net_dev->dev_addr, ETH_ALEN);
 +
 +
 +	send_skb_packet(skb, batman_if, dstaddr);
 +
 +	goto out;
 +
 +unlock:
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +dst_unreach:
 +	icmp_packet->msg_type = DESTINATION_UNREACHABLE;
 +	bat_socket_add_packet(socket_client, icmp_packet, packet_len);
 +free_skb:
 +	kfree_skb(skb);
 +out:
 +	return len;
 +}
 +
 +static unsigned int bat_socket_poll(struct file *file, poll_table *wait)
 +{
 +	struct socket_client *socket_client = file->private_data;
 +
 +	poll_wait(file, &socket_client->queue_wait, wait);
 +
 +	if (socket_client->queue_len > 0)
 +		return POLLIN | POLLRDNORM;
 +
 +	return 0;
 +}
 +
 +static const struct file_operations fops = {
 +	.owner = THIS_MODULE,
 +	.open = bat_socket_open,
 +	.release = bat_socket_release,
 +	.read = bat_socket_read,
 +	.write = bat_socket_write,
 +	.poll = bat_socket_poll,
++	.llseek = no_llseek,
 +};
 +
 +int bat_socket_setup(struct bat_priv *bat_priv)
 +{
 +	struct dentry *d;
 +
 +	if (!bat_priv->debug_dir)
 +		goto err;
 +
 +	d = debugfs_create_file(ICMP_SOCKET, S_IFREG | S_IWUSR | S_IRUSR,
 +				bat_priv->debug_dir, bat_priv, &fops);
 +	if (d)
 +		goto err;
 +
 +	return 0;
 +
 +err:
 +	return 1;
 +}
 +
 +static void bat_socket_add_packet(struct socket_client *socket_client,
 +				  struct icmp_packet_rr *icmp_packet,
 +				  size_t icmp_len)
 +{
 +	struct socket_packet *socket_packet;
 +	unsigned long flags;
 +
 +	socket_packet = kmalloc(sizeof(struct socket_packet), GFP_ATOMIC);
 +
 +	if (!socket_packet)
 +		return;
 +
 +	INIT_LIST_HEAD(&socket_packet->list);
 +	memcpy(&socket_packet->icmp_packet, icmp_packet, icmp_len);
 +	socket_packet->icmp_len = icmp_len;
 +
 +	spin_lock_irqsave(&socket_client->lock, flags);
 +
 +	/* while waiting for the lock the socket_client could have been
 +	 * deleted */
 +	if (!socket_client_hash[icmp_packet->uid]) {
 +		spin_unlock_irqrestore(&socket_client->lock, flags);
 +		kfree(socket_packet);
 +		return;
 +	}
 +
 +	list_add_tail(&socket_packet->list, &socket_client->queue_list);
 +	socket_client->queue_len++;
 +
 +	if (socket_client->queue_len > 100) {
 +		socket_packet = list_first_entry(&socket_client->queue_list,
 +						 struct socket_packet, list);
 +
 +		list_del(&socket_packet->list);
 +		kfree(socket_packet);
 +		socket_client->queue_len--;
 +	}
 +
 +	spin_unlock_irqrestore(&socket_client->lock, flags);
 +
 +	wake_up(&socket_client->queue_wait);
 +}
 +
 +void bat_socket_receive_packet(struct icmp_packet_rr *icmp_packet,
 +			       size_t icmp_len)
 +{
 +	struct socket_client *hash = socket_client_hash[icmp_packet->uid];
 +
 +	if (hash)
 +		bat_socket_add_packet(hash, icmp_packet, icmp_len);
 +}
diff --combined drivers/staging/batman-adv/main.c
index 78ceebf,0000000..580ca02
mode 100644,000000..100644
--- a/drivers/staging/batman-adv/main.c
+++ b/drivers/staging/batman-adv/main.c
@@@ -1,222 -1,0 +1,222 @@@
 +/*
 + * Copyright (C) 2007-2010 B.A.T.M.A.N. contributors:
 + *
 + * Marek Lindner, Simon Wunderlich
 + *
 + * 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, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 + * 02110-1301, USA
 + *
 + */
 +
 +#include "main.h"
 +#include "bat_sysfs.h"
 +#include "bat_debugfs.h"
 +#include "routing.h"
 +#include "send.h"
 +#include "originator.h"
 +#include "soft-interface.h"
 +#include "icmp_socket.h"
 +#include "translation-table.h"
 +#include "hard-interface.h"
 +#include "types.h"
 +#include "vis.h"
 +#include "hash.h"
 +
 +struct list_head if_list;
 +
 +unsigned char broadcast_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 +
 +struct workqueue_struct *bat_event_workqueue;
 +
 +static int __init batman_init(void)
 +{
 +	INIT_LIST_HEAD(&if_list);
 +
 +	/* the name should not be longer than 10 chars - see
 +	 * http://lwn.net/Articles/23634/ */
 +	bat_event_workqueue = create_singlethread_workqueue("bat_events");
 +
 +	if (!bat_event_workqueue)
 +		return -ENOMEM;
 +
 +	bat_socket_init();
 +	debugfs_init();
 +
 +	register_netdevice_notifier(&hard_if_notifier);
 +
 +	pr_info("B.A.T.M.A.N. advanced %s%s (compatibility version %i) "
 +		"loaded\n", SOURCE_VERSION, REVISION_VERSION_STR,
 +		COMPAT_VERSION);
 +
 +	return 0;
 +}
 +
 +static void __exit batman_exit(void)
 +{
 +	debugfs_destroy();
 +	unregister_netdevice_notifier(&hard_if_notifier);
 +	hardif_remove_interfaces();
 +
 +	flush_workqueue(bat_event_workqueue);
 +	destroy_workqueue(bat_event_workqueue);
 +	bat_event_workqueue = NULL;
 +
- 	synchronize_net();
++	rcu_barrier();
 +}
 +
 +int mesh_init(struct net_device *soft_iface)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(soft_iface);
 +
 +	spin_lock_init(&bat_priv->orig_hash_lock);
 +	spin_lock_init(&bat_priv->forw_bat_list_lock);
 +	spin_lock_init(&bat_priv->forw_bcast_list_lock);
 +	spin_lock_init(&bat_priv->hna_lhash_lock);
 +	spin_lock_init(&bat_priv->hna_ghash_lock);
 +	spin_lock_init(&bat_priv->vis_hash_lock);
 +	spin_lock_init(&bat_priv->vis_list_lock);
 +
 +	INIT_HLIST_HEAD(&bat_priv->forw_bat_list);
 +	INIT_HLIST_HEAD(&bat_priv->forw_bcast_list);
 +
 +	if (originator_init(bat_priv) < 1)
 +		goto err;
 +
 +	if (hna_local_init(bat_priv) < 1)
 +		goto err;
 +
 +	if (hna_global_init(bat_priv) < 1)
 +		goto err;
 +
 +	hna_local_add(soft_iface, soft_iface->dev_addr);
 +
 +	if (vis_init(bat_priv) < 1)
 +		goto err;
 +
 +	atomic_set(&bat_priv->mesh_state, MESH_ACTIVE);
 +	goto end;
 +
 +err:
 +	pr_err("Unable to allocate memory for mesh information structures: "
 +	       "out of mem ?\n");
 +	mesh_free(soft_iface);
 +	return -1;
 +
 +end:
 +	return 0;
 +}
 +
 +void mesh_free(struct net_device *soft_iface)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(soft_iface);
 +
 +	atomic_set(&bat_priv->mesh_state, MESH_DEACTIVATING);
 +
 +	purge_outstanding_packets(bat_priv, NULL);
 +
 +	vis_quit(bat_priv);
 +
 +	originator_free(bat_priv);
 +
 +	hna_local_free(bat_priv);
 +	hna_global_free(bat_priv);
 +
 +	atomic_set(&bat_priv->mesh_state, MESH_INACTIVE);
 +}
 +
 +void inc_module_count(void)
 +{
 +	try_module_get(THIS_MODULE);
 +}
 +
 +void dec_module_count(void)
 +{
 +	module_put(THIS_MODULE);
 +}
 +
 +int addr_to_string(char *buff, uint8_t *addr)
 +{
 +	return sprintf(buff, "%pM", addr);
 +}
 +
 +/* returns 1 if they are the same originator */
 +
 +int compare_orig(void *data1, void *data2)
 +{
 +	return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0);
 +}
 +
 +/* hashfunction to choose an entry in a hash table of given size */
 +/* hash algorithm from http://en.wikipedia.org/wiki/Hash_table */
 +int choose_orig(void *data, int32_t size)
 +{
 +	unsigned char *key = data;
 +	uint32_t hash = 0;
 +	size_t i;
 +
 +	for (i = 0; i < 6; i++) {
 +		hash += key[i];
 +		hash += (hash << 10);
 +		hash ^= (hash >> 6);
 +	}
 +
 +	hash += (hash << 3);
 +	hash ^= (hash >> 11);
 +	hash += (hash << 15);
 +
 +	return hash % size;
 +}
 +
 +int is_my_mac(uint8_t *addr)
 +{
 +	struct batman_if *batman_if;
 +
 +	rcu_read_lock();
 +	list_for_each_entry_rcu(batman_if, &if_list, list) {
 +		if (batman_if->if_status != IF_ACTIVE)
 +			continue;
 +
 +		if (compare_orig(batman_if->net_dev->dev_addr, addr)) {
 +			rcu_read_unlock();
 +			return 1;
 +		}
 +	}
 +	rcu_read_unlock();
 +	return 0;
 +
 +}
 +
 +int is_bcast(uint8_t *addr)
 +{
 +	return (addr[0] == (uint8_t)0xff) && (addr[1] == (uint8_t)0xff);
 +}
 +
 +int is_mcast(uint8_t *addr)
 +{
 +	return *addr & 0x01;
 +}
 +
 +module_init(batman_init);
 +module_exit(batman_exit);
 +
 +MODULE_LICENSE("GPL");
 +
 +MODULE_AUTHOR(DRIVER_AUTHOR);
 +MODULE_DESCRIPTION(DRIVER_DESC);
 +MODULE_SUPPORTED_DEVICE(DRIVER_DEVICE);
 +#ifdef REVISION_VERSION
 +MODULE_VERSION(SOURCE_VERSION "-" REVISION_VERSION);
 +#else
 +MODULE_VERSION(SOURCE_VERSION);
 +#endif
diff --combined drivers/staging/batman-adv/originator.c
index f25d7fd,0000000..c530df1
mode 100644,000000..100644
--- a/drivers/staging/batman-adv/originator.c
+++ b/drivers/staging/batman-adv/originator.c
@@@ -1,539 -1,0 +1,537 @@@
 +/*
 + * Copyright (C) 2009-2010 B.A.T.M.A.N. contributors:
 + *
 + * Marek Lindner, Simon Wunderlich
 + *
 + * 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, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 + * 02110-1301, USA
 + *
 + */
 +
 +/* increase the reference counter for this originator */
 +
 +#include "main.h"
 +#include "originator.h"
 +#include "hash.h"
 +#include "translation-table.h"
 +#include "routing.h"
 +#include "hard-interface.h"
 +#include "unicast.h"
 +
 +static void purge_orig(struct work_struct *work);
 +
 +static void start_purge_timer(struct bat_priv *bat_priv)
 +{
 +	INIT_DELAYED_WORK(&bat_priv->orig_work, purge_orig);
 +	queue_delayed_work(bat_event_workqueue, &bat_priv->orig_work, 1 * HZ);
 +}
 +
 +int originator_init(struct bat_priv *bat_priv)
 +{
 +	unsigned long flags;
 +	if (bat_priv->orig_hash)
 +		return 1;
 +
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +	bat_priv->orig_hash = hash_new(128, compare_orig, choose_orig);
 +
 +	if (!bat_priv->orig_hash)
 +		goto err;
 +
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +	start_purge_timer(bat_priv);
 +	return 1;
 +
 +err:
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +	return 0;
 +}
 +
 +struct neigh_node *
 +create_neighbor(struct orig_node *orig_node, struct orig_node *orig_neigh_node,
 +		uint8_t *neigh, struct batman_if *if_incoming)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
 +	struct neigh_node *neigh_node;
 +
 +	bat_dbg(DBG_BATMAN, bat_priv,
 +		"Creating new last-hop neighbor of originator\n");
 +
 +	neigh_node = kzalloc(sizeof(struct neigh_node), GFP_ATOMIC);
 +	if (!neigh_node)
 +		return NULL;
 +
 +	INIT_LIST_HEAD(&neigh_node->list);
 +
 +	memcpy(neigh_node->addr, neigh, ETH_ALEN);
 +	neigh_node->orig_node = orig_neigh_node;
 +	neigh_node->if_incoming = if_incoming;
 +
 +	list_add_tail(&neigh_node->list, &orig_node->neigh_list);
 +	return neigh_node;
 +}
 +
 +static void free_orig_node(void *data, void *arg)
 +{
 +	struct list_head *list_pos, *list_pos_tmp;
 +	struct neigh_node *neigh_node;
 +	struct orig_node *orig_node = (struct orig_node *)data;
 +	struct bat_priv *bat_priv = (struct bat_priv *)arg;
 +
 +	/* for all neighbors towards this originator ... */
 +	list_for_each_safe(list_pos, list_pos_tmp, &orig_node->neigh_list) {
 +		neigh_node = list_entry(list_pos, struct neigh_node, list);
 +
 +		list_del(list_pos);
 +		kfree(neigh_node);
 +	}
 +
 +	frag_list_free(&orig_node->frag_list);
 +	hna_global_del_orig(bat_priv, orig_node, "originator timed out");
 +
 +	kfree(orig_node->bcast_own);
 +	kfree(orig_node->bcast_own_sum);
 +	kfree(orig_node);
 +}
 +
 +void originator_free(struct bat_priv *bat_priv)
 +{
 +	unsigned long flags;
 +
 +	if (!bat_priv->orig_hash)
 +		return;
 +
 +	cancel_delayed_work_sync(&bat_priv->orig_work);
 +
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +	hash_delete(bat_priv->orig_hash, free_orig_node, bat_priv);
 +	bat_priv->orig_hash = NULL;
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +}
 +
 +/* this function finds or creates an originator entry for the given
 + * address if it does not exits */
 +struct orig_node *get_orig_node(struct bat_priv *bat_priv, uint8_t *addr)
 +{
 +	struct orig_node *orig_node;
 +	struct hashtable_t *swaphash;
 +	int size;
 +
 +	orig_node = ((struct orig_node *)hash_find(bat_priv->orig_hash, addr));
 +
 +	if (orig_node)
 +		return orig_node;
 +
 +	bat_dbg(DBG_BATMAN, bat_priv,
 +		"Creating new originator: %pM\n", addr);
 +
 +	orig_node = kzalloc(sizeof(struct orig_node), GFP_ATOMIC);
 +	if (!orig_node)
 +		return NULL;
 +
 +	INIT_LIST_HEAD(&orig_node->neigh_list);
 +
 +	memcpy(orig_node->orig, addr, ETH_ALEN);
 +	orig_node->router = NULL;
 +	orig_node->hna_buff = NULL;
 +	orig_node->bcast_seqno_reset = jiffies - 1
 +					- msecs_to_jiffies(RESET_PROTECTION_MS);
 +	orig_node->batman_seqno_reset = jiffies - 1
 +					- msecs_to_jiffies(RESET_PROTECTION_MS);
 +
 +	size = bat_priv->num_ifaces * sizeof(TYPE_OF_WORD) * NUM_WORDS;
 +
 +	orig_node->bcast_own = kzalloc(size, GFP_ATOMIC);
 +	if (!orig_node->bcast_own)
 +		goto free_orig_node;
 +
 +	size = bat_priv->num_ifaces * sizeof(uint8_t);
 +	orig_node->bcast_own_sum = kzalloc(size, GFP_ATOMIC);
 +
 +	INIT_LIST_HEAD(&orig_node->frag_list);
 +	orig_node->last_frag_packet = 0;
 +
 +	if (!orig_node->bcast_own_sum)
 +		goto free_bcast_own;
 +
 +	if (hash_add(bat_priv->orig_hash, orig_node) < 0)
 +		goto free_bcast_own_sum;
 +
 +	if (bat_priv->orig_hash->elements * 4 > bat_priv->orig_hash->size) {
 +		swaphash = hash_resize(bat_priv->orig_hash,
 +				       bat_priv->orig_hash->size * 2);
 +
 +		if (!swaphash)
 +			bat_dbg(DBG_BATMAN, bat_priv,
 +				"Couldn't resize orig hash table\n");
 +		else
 +			bat_priv->orig_hash = swaphash;
 +	}
 +
 +	return orig_node;
 +free_bcast_own_sum:
 +	kfree(orig_node->bcast_own_sum);
 +free_bcast_own:
 +	kfree(orig_node->bcast_own);
 +free_orig_node:
 +	kfree(orig_node);
 +	return NULL;
 +}
 +
 +static bool purge_orig_neighbors(struct bat_priv *bat_priv,
 +				 struct orig_node *orig_node,
 +				 struct neigh_node **best_neigh_node)
 +{
 +	struct list_head *list_pos, *list_pos_tmp;
 +	struct neigh_node *neigh_node;
 +	bool neigh_purged = false;
 +
 +	*best_neigh_node = NULL;
 +
 +	/* for all neighbors towards this originator ... */
 +	list_for_each_safe(list_pos, list_pos_tmp, &orig_node->neigh_list) {
 +		neigh_node = list_entry(list_pos, struct neigh_node, list);
 +
 +		if ((time_after(jiffies,
 +			neigh_node->last_valid + PURGE_TIMEOUT * HZ)) ||
 +		    (neigh_node->if_incoming->if_status == IF_INACTIVE) ||
 +		    (neigh_node->if_incoming->if_status == IF_TO_BE_REMOVED)) {
 +
 +			if (neigh_node->if_incoming->if_status ==
 +							IF_TO_BE_REMOVED)
 +				bat_dbg(DBG_BATMAN, bat_priv,
 +					"neighbor purge: originator %pM, "
 +					"neighbor: %pM, iface: %s\n",
 +					orig_node->orig, neigh_node->addr,
 +					neigh_node->if_incoming->net_dev->name);
 +			else
 +				bat_dbg(DBG_BATMAN, bat_priv,
 +					"neighbor timeout: originator %pM, "
 +					"neighbor: %pM, last_valid: %lu\n",
 +					orig_node->orig, neigh_node->addr,
 +					(neigh_node->last_valid / HZ));
 +
 +			neigh_purged = true;
 +			list_del(list_pos);
 +			kfree(neigh_node);
 +		} else {
 +			if ((*best_neigh_node == NULL) ||
 +			    (neigh_node->tq_avg > (*best_neigh_node)->tq_avg))
 +				*best_neigh_node = neigh_node;
 +		}
 +	}
 +	return neigh_purged;
 +}
 +
 +static bool purge_orig_node(struct bat_priv *bat_priv,
 +			    struct orig_node *orig_node)
 +{
 +	struct neigh_node *best_neigh_node;
 +
 +	if (time_after(jiffies,
 +		orig_node->last_valid + 2 * PURGE_TIMEOUT * HZ)) {
 +
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"Originator timeout: originator %pM, last_valid %lu\n",
 +			orig_node->orig, (orig_node->last_valid / HZ));
 +		return true;
 +	} else {
 +		if (purge_orig_neighbors(bat_priv, orig_node,
 +							&best_neigh_node)) {
 +			update_routes(bat_priv, orig_node,
 +				      best_neigh_node,
 +				      orig_node->hna_buff,
 +				      orig_node->hna_buff_len);
 +			/* update bonding candidates, we could have lost
 +			 * some candidates. */
 +			update_bonding_candidates(bat_priv, orig_node);
 +		}
 +	}
 +
 +	return false;
 +}
 +
 +static void _purge_orig(struct bat_priv *bat_priv)
 +{
 +	HASHIT(hashit);
 +	struct orig_node *orig_node;
 +	unsigned long flags;
 +
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +
 +	/* for all origins... */
 +	while (hash_iterate(bat_priv->orig_hash, &hashit)) {
 +		orig_node = hashit.bucket->data;
 +
 +		if (purge_orig_node(bat_priv, orig_node)) {
 +			hash_remove_bucket(bat_priv->orig_hash, &hashit);
 +			free_orig_node(orig_node, bat_priv);
 +		}
 +
 +		if (time_after(jiffies, (orig_node->last_frag_packet +
 +					msecs_to_jiffies(FRAG_TIMEOUT))))
 +			frag_list_free(&orig_node->frag_list);
 +	}
 +
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +}
 +
 +static void purge_orig(struct work_struct *work)
 +{
 +	struct delayed_work *delayed_work =
 +		container_of(work, struct delayed_work, work);
 +	struct bat_priv *bat_priv =
 +		container_of(delayed_work, struct bat_priv, orig_work);
 +
 +	_purge_orig(bat_priv);
 +	start_purge_timer(bat_priv);
 +}
 +
 +void purge_orig_ref(struct bat_priv *bat_priv)
 +{
 +	_purge_orig(bat_priv);
 +}
 +
 +int orig_seq_print_text(struct seq_file *seq, void *offset)
 +{
 +	HASHIT(hashit);
 +	struct net_device *net_dev = (struct net_device *)seq->private;
 +	struct bat_priv *bat_priv = netdev_priv(net_dev);
 +	struct orig_node *orig_node;
 +	struct neigh_node *neigh_node;
 +	int batman_count = 0;
 +	int last_seen_secs;
 +	int last_seen_msecs;
 +	unsigned long flags;
 +	char orig_str[ETH_STR_LEN], router_str[ETH_STR_LEN];
 +
 +	if ((!bat_priv->primary_if) ||
 +	    (bat_priv->primary_if->if_status != IF_ACTIVE)) {
 +		if (!bat_priv->primary_if)
 +			return seq_printf(seq, "BATMAN mesh %s disabled - "
 +				     "please specify interfaces to enable it\n",
 +				     net_dev->name);
 +
 +		return seq_printf(seq, "BATMAN mesh %s "
 +				  "disabled - primary interface not active\n",
 +				  net_dev->name);
 +	}
 +
- 	rcu_read_lock();
 +	seq_printf(seq, "[B.A.T.M.A.N. adv %s%s, MainIF/MAC: %s/%s (%s)]\n",
 +		   SOURCE_VERSION, REVISION_VERSION_STR,
 +		   bat_priv->primary_if->net_dev->name,
 +		   bat_priv->primary_if->addr_str, net_dev->name);
 +	seq_printf(seq, "  %-15s %s (%s/%i) %17s [%10s]: %20s ...\n",
 +		   "Originator", "last-seen", "#", TQ_MAX_VALUE, "Nexthop",
 +		   "outgoingIF", "Potential nexthops");
- 	rcu_read_unlock();
 +
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +
 +	while (hash_iterate(bat_priv->orig_hash, &hashit)) {
 +
 +		orig_node = hashit.bucket->data;
 +
 +		if (!orig_node->router)
 +			continue;
 +
 +		if (orig_node->router->tq_avg == 0)
 +			continue;
 +
 +		addr_to_string(orig_str, orig_node->orig);
 +		addr_to_string(router_str, orig_node->router->addr);
 +		last_seen_secs = jiffies_to_msecs(jiffies -
 +						orig_node->last_valid) / 1000;
 +		last_seen_msecs = jiffies_to_msecs(jiffies -
 +						orig_node->last_valid) % 1000;
 +
 +		seq_printf(seq, "%-17s %4i.%03is   (%3i) %17s [%10s]:",
 +			   orig_str, last_seen_secs, last_seen_msecs,
 +			   orig_node->router->tq_avg, router_str,
 +			   orig_node->router->if_incoming->net_dev->name);
 +
 +		list_for_each_entry(neigh_node, &orig_node->neigh_list, list) {
 +			addr_to_string(orig_str, neigh_node->addr);
 +			seq_printf(seq, " %17s (%3i)", orig_str,
 +					   neigh_node->tq_avg);
 +		}
 +
 +		seq_printf(seq, "\n");
 +		batman_count++;
 +	}
 +
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +	if ((batman_count == 0))
 +		seq_printf(seq, "No batman nodes in range ...\n");
 +
 +	return 0;
 +}
 +
 +static int orig_node_add_if(struct orig_node *orig_node, int max_if_num)
 +{
 +	void *data_ptr;
 +
 +	data_ptr = kmalloc(max_if_num * sizeof(TYPE_OF_WORD) * NUM_WORDS,
 +			   GFP_ATOMIC);
 +	if (!data_ptr) {
 +		pr_err("Can't resize orig: out of memory\n");
 +		return -1;
 +	}
 +
 +	memcpy(data_ptr, orig_node->bcast_own,
 +	       (max_if_num - 1) * sizeof(TYPE_OF_WORD) * NUM_WORDS);
 +	kfree(orig_node->bcast_own);
 +	orig_node->bcast_own = data_ptr;
 +
 +	data_ptr = kmalloc(max_if_num * sizeof(uint8_t), GFP_ATOMIC);
 +	if (!data_ptr) {
 +		pr_err("Can't resize orig: out of memory\n");
 +		return -1;
 +	}
 +
 +	memcpy(data_ptr, orig_node->bcast_own_sum,
 +	       (max_if_num - 1) * sizeof(uint8_t));
 +	kfree(orig_node->bcast_own_sum);
 +	orig_node->bcast_own_sum = data_ptr;
 +
 +	return 0;
 +}
 +
 +int orig_hash_add_if(struct batman_if *batman_if, int max_if_num)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(batman_if->soft_iface);
 +	struct orig_node *orig_node;
 +	unsigned long flags;
 +	HASHIT(hashit);
 +
 +	/* resize all orig nodes because orig_node->bcast_own(_sum) depend on
 +	 * if_num */
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +
 +	while (hash_iterate(bat_priv->orig_hash, &hashit)) {
 +		orig_node = hashit.bucket->data;
 +
 +		if (orig_node_add_if(orig_node, max_if_num) == -1)
 +			goto err;
 +	}
 +
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +	return 0;
 +
 +err:
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +	return -ENOMEM;
 +}
 +
 +static int orig_node_del_if(struct orig_node *orig_node,
 +		     int max_if_num, int del_if_num)
 +{
 +	void *data_ptr = NULL;
 +	int chunk_size;
 +
 +	/* last interface was removed */
 +	if (max_if_num == 0)
 +		goto free_bcast_own;
 +
 +	chunk_size = sizeof(TYPE_OF_WORD) * NUM_WORDS;
 +	data_ptr = kmalloc(max_if_num * chunk_size, GFP_ATOMIC);
 +	if (!data_ptr) {
 +		pr_err("Can't resize orig: out of memory\n");
 +		return -1;
 +	}
 +
 +	/* copy first part */
 +	memcpy(data_ptr, orig_node->bcast_own, del_if_num * chunk_size);
 +
 +	/* copy second part */
 +	memcpy(data_ptr,
 +	       orig_node->bcast_own + ((del_if_num + 1) * chunk_size),
 +	       (max_if_num - del_if_num) * chunk_size);
 +
 +free_bcast_own:
 +	kfree(orig_node->bcast_own);
 +	orig_node->bcast_own = data_ptr;
 +
 +	if (max_if_num == 0)
 +		goto free_own_sum;
 +
 +	data_ptr = kmalloc(max_if_num * sizeof(uint8_t), GFP_ATOMIC);
 +	if (!data_ptr) {
 +		pr_err("Can't resize orig: out of memory\n");
 +		return -1;
 +	}
 +
 +	memcpy(data_ptr, orig_node->bcast_own_sum,
 +	       del_if_num * sizeof(uint8_t));
 +
 +	memcpy(data_ptr,
 +	       orig_node->bcast_own_sum + ((del_if_num + 1) * sizeof(uint8_t)),
 +	       (max_if_num - del_if_num) * sizeof(uint8_t));
 +
 +free_own_sum:
 +	kfree(orig_node->bcast_own_sum);
 +	orig_node->bcast_own_sum = data_ptr;
 +
 +	return 0;
 +}
 +
 +int orig_hash_del_if(struct batman_if *batman_if, int max_if_num)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(batman_if->soft_iface);
 +	struct batman_if *batman_if_tmp;
 +	struct orig_node *orig_node;
 +	unsigned long flags;
 +	HASHIT(hashit);
 +	int ret;
 +
 +	/* resize all orig nodes because orig_node->bcast_own(_sum) depend on
 +	 * if_num */
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +
 +	while (hash_iterate(bat_priv->orig_hash, &hashit)) {
 +		orig_node = hashit.bucket->data;
 +
 +		ret = orig_node_del_if(orig_node, max_if_num,
 +				       batman_if->if_num);
 +
 +		if (ret == -1)
 +			goto err;
 +	}
 +
 +	/* renumber remaining batman interfaces _inside_ of orig_hash_lock */
 +	rcu_read_lock();
 +	list_for_each_entry_rcu(batman_if_tmp, &if_list, list) {
 +		if (batman_if_tmp->if_status == IF_NOT_IN_USE)
 +			continue;
 +
 +		if (batman_if == batman_if_tmp)
 +			continue;
 +
 +		if (batman_if->soft_iface != batman_if_tmp->soft_iface)
 +			continue;
 +
 +		if (batman_if_tmp->if_num > batman_if->if_num)
 +			batman_if_tmp->if_num--;
 +	}
 +	rcu_read_unlock();
 +
 +	batman_if->if_num = -1;
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +	return 0;
 +
 +err:
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +	return -ENOMEM;
 +}
diff --combined drivers/staging/batman-adv/packet.h
index 44de1bf,2693383..2693383
--- a/drivers/staging/batman-adv/packet.h
+++ b/drivers/staging/batman-adv/packet.h
@@@ -79,7 -79,7 +79,7 @@@ struct icmp_packet 
  #define BAT_RR_LEN 16
/* icmp_packet_rr must start with all fields from imcp_packet
-    as this is assumed by code that handles ICMP packets */
+  * as this is assumed by code that handles ICMP packets */
  struct icmp_packet_rr {
    uint8_t  packet_type;
    uint8_t  version;  /* batman version field */
diff --combined drivers/staging/batman-adv/routing.c
index 2cf8cf9,0000000..58aa99e
mode 100644,000000..100644
--- a/drivers/staging/batman-adv/routing.c
+++ b/drivers/staging/batman-adv/routing.c
@@@ -1,1391 -1,0 +1,1393 @@@
 +/*
 + * Copyright (C) 2007-2010 B.A.T.M.A.N. contributors:
 + *
 + * Marek Lindner, Simon Wunderlich
 + *
 + * 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, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 + * 02110-1301, USA
 + *
 + */
 +
 +#include "main.h"
 +#include "routing.h"
 +#include "send.h"
 +#include "hash.h"
 +#include "soft-interface.h"
 +#include "hard-interface.h"
 +#include "icmp_socket.h"
 +#include "translation-table.h"
 +#include "originator.h"
 +#include "types.h"
 +#include "ring_buffer.h"
 +#include "vis.h"
 +#include "aggregation.h"
 +#include "unicast.h"
 +
 +void slide_own_bcast_window(struct batman_if *batman_if)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(batman_if->soft_iface);
 +	HASHIT(hashit);
 +	struct orig_node *orig_node;
 +	TYPE_OF_WORD *word;
 +	unsigned long flags;
 +
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +
 +	while (hash_iterate(bat_priv->orig_hash, &hashit)) {
 +		orig_node = hashit.bucket->data;
 +		word = &(orig_node->bcast_own[batman_if->if_num * NUM_WORDS]);
 +
 +		bit_get_packet(bat_priv, word, 1, 0);
 +		orig_node->bcast_own_sum[batman_if->if_num] =
 +			bit_packet_count(word);
 +	}
 +
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +}
 +
 +static void update_HNA(struct bat_priv *bat_priv, struct orig_node *orig_node,
 +		       unsigned char *hna_buff, int hna_buff_len)
 +{
 +	if ((hna_buff_len != orig_node->hna_buff_len) ||
 +	    ((hna_buff_len > 0) &&
 +	     (orig_node->hna_buff_len > 0) &&
 +	     (memcmp(orig_node->hna_buff, hna_buff, hna_buff_len) != 0))) {
 +
 +		if (orig_node->hna_buff_len > 0)
 +			hna_global_del_orig(bat_priv, orig_node,
 +					    "originator changed hna");
 +
 +		if ((hna_buff_len > 0) && (hna_buff != NULL))
 +			hna_global_add_orig(bat_priv, orig_node,
 +					    hna_buff, hna_buff_len);
 +	}
 +}
 +
 +static void update_route(struct bat_priv *bat_priv,
 +			 struct orig_node *orig_node,
 +			 struct neigh_node *neigh_node,
 +			 unsigned char *hna_buff, int hna_buff_len)
 +{
 +	/* route deleted */
 +	if ((orig_node->router != NULL) && (neigh_node == NULL)) {
 +
 +		bat_dbg(DBG_ROUTES, bat_priv, "Deleting route towards: %pM\n",
 +			orig_node->orig);
 +		hna_global_del_orig(bat_priv, orig_node,
 +				    "originator timed out");
 +
 +		/* route added */
 +	} else if ((orig_node->router == NULL) && (neigh_node != NULL)) {
 +
 +		bat_dbg(DBG_ROUTES, bat_priv,
 +			"Adding route towards: %pM (via %pM)\n",
 +			orig_node->orig, neigh_node->addr);
 +		hna_global_add_orig(bat_priv, orig_node,
 +				    hna_buff, hna_buff_len);
 +
 +		/* route changed */
 +	} else {
 +		bat_dbg(DBG_ROUTES, bat_priv,
 +			"Changing route towards: %pM "
 +			"(now via %pM - was via %pM)\n",
 +			orig_node->orig, neigh_node->addr,
 +			orig_node->router->addr);
 +	}
 +
 +	orig_node->router = neigh_node;
 +}
 +
 +
 +void update_routes(struct bat_priv *bat_priv, struct orig_node *orig_node,
 +		   struct neigh_node *neigh_node, unsigned char *hna_buff,
 +		   int hna_buff_len)
 +{
 +
 +	if (orig_node == NULL)
 +		return;
 +
 +	if (orig_node->router != neigh_node)
 +		update_route(bat_priv, orig_node, neigh_node,
 +			     hna_buff, hna_buff_len);
 +	/* may be just HNA changed */
 +	else
 +		update_HNA(bat_priv, orig_node, hna_buff, hna_buff_len);
 +}
 +
 +static int is_bidirectional_neigh(struct orig_node *orig_node,
 +				struct orig_node *orig_neigh_node,
 +				struct batman_packet *batman_packet,
 +				struct batman_if *if_incoming)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
 +	struct neigh_node *neigh_node = NULL, *tmp_neigh_node = NULL;
 +	unsigned char total_count;
 +
 +	if (orig_node == orig_neigh_node) {
 +		list_for_each_entry(tmp_neigh_node,
 +				    &orig_node->neigh_list,
 +				    list) {
 +
 +			if (compare_orig(tmp_neigh_node->addr,
 +					 orig_neigh_node->orig) &&
 +			    (tmp_neigh_node->if_incoming == if_incoming))
 +				neigh_node = tmp_neigh_node;
 +		}
 +
 +		if (!neigh_node)
 +			neigh_node = create_neighbor(orig_node,
 +						     orig_neigh_node,
 +						     orig_neigh_node->orig,
 +						     if_incoming);
 +		/* create_neighbor failed, return 0 */
 +		if (!neigh_node)
 +			return 0;
 +
 +		neigh_node->last_valid = jiffies;
 +	} else {
 +		/* find packet count of corresponding one hop neighbor */
 +		list_for_each_entry(tmp_neigh_node,
 +				    &orig_neigh_node->neigh_list, list) {
 +
 +			if (compare_orig(tmp_neigh_node->addr,
 +					 orig_neigh_node->orig) &&
 +			    (tmp_neigh_node->if_incoming == if_incoming))
 +				neigh_node = tmp_neigh_node;
 +		}
 +
 +		if (!neigh_node)
 +			neigh_node = create_neighbor(orig_neigh_node,
 +						     orig_neigh_node,
 +						     orig_neigh_node->orig,
 +						     if_incoming);
 +		/* create_neighbor failed, return 0 */
 +		if (!neigh_node)
 +			return 0;
 +	}
 +
 +	orig_node->last_valid = jiffies;
 +
 +	/* pay attention to not get a value bigger than 100 % */
 +	total_count = (orig_neigh_node->bcast_own_sum[if_incoming->if_num] >
 +		       neigh_node->real_packet_count ?
 +		       neigh_node->real_packet_count :
 +		       orig_neigh_node->bcast_own_sum[if_incoming->if_num]);
 +
 +	/* if we have too few packets (too less data) we set tq_own to zero */
 +	/* if we receive too few packets it is not considered bidirectional */
 +	if ((total_count < TQ_LOCAL_BIDRECT_SEND_MINIMUM) ||
 +	    (neigh_node->real_packet_count < TQ_LOCAL_BIDRECT_RECV_MINIMUM))
 +		orig_neigh_node->tq_own = 0;
 +	else
 +		/* neigh_node->real_packet_count is never zero as we
 +		 * only purge old information when getting new
 +		 * information */
 +		orig_neigh_node->tq_own = (TQ_MAX_VALUE * total_count) /
 +			neigh_node->real_packet_count;
 +
 +	/*
 +	 * 1 - ((1-x) ** 3), normalized to TQ_MAX_VALUE this does
 +	 * affect the nearly-symmetric links only a little, but
 +	 * punishes asymmetric links more.  This will give a value
 +	 * between 0 and TQ_MAX_VALUE
 +	 */
 +	orig_neigh_node->tq_asym_penalty =
 +		TQ_MAX_VALUE -
 +		(TQ_MAX_VALUE *
 +		 (TQ_LOCAL_WINDOW_SIZE - neigh_node->real_packet_count) *
 +		 (TQ_LOCAL_WINDOW_SIZE - neigh_node->real_packet_count) *
 +		 (TQ_LOCAL_WINDOW_SIZE - neigh_node->real_packet_count)) /
 +		(TQ_LOCAL_WINDOW_SIZE *
 +		 TQ_LOCAL_WINDOW_SIZE *
 +		 TQ_LOCAL_WINDOW_SIZE);
 +
 +	batman_packet->tq = ((batman_packet->tq *
 +			      orig_neigh_node->tq_own *
 +			      orig_neigh_node->tq_asym_penalty) /
 +			     (TQ_MAX_VALUE * TQ_MAX_VALUE));
 +
 +	bat_dbg(DBG_BATMAN, bat_priv,
 +		"bidirectional: "
 +		"orig = %-15pM neigh = %-15pM => own_bcast = %2i, "
 +		"real recv = %2i, local tq: %3i, asym_penalty: %3i, "
 +		"total tq: %3i\n",
 +		orig_node->orig, orig_neigh_node->orig, total_count,
 +		neigh_node->real_packet_count, orig_neigh_node->tq_own,
 +		orig_neigh_node->tq_asym_penalty, batman_packet->tq);
 +
 +	/* if link has the minimum required transmission quality
 +	 * consider it bidirectional */
 +	if (batman_packet->tq >= TQ_TOTAL_BIDRECT_LIMIT)
 +		return 1;
 +
 +	return 0;
 +}
 +
 +static void update_orig(struct bat_priv *bat_priv,
 +			struct orig_node *orig_node,
 +			struct ethhdr *ethhdr,
 +			struct batman_packet *batman_packet,
 +			struct batman_if *if_incoming,
 +			unsigned char *hna_buff, int hna_buff_len,
 +			char is_duplicate)
 +{
 +	struct neigh_node *neigh_node = NULL, *tmp_neigh_node = NULL;
 +	int tmp_hna_buff_len;
 +
 +	bat_dbg(DBG_BATMAN, bat_priv, "update_originator(): "
 +		"Searching and updating originator entry of received packet\n");
 +
 +	list_for_each_entry(tmp_neigh_node, &orig_node->neigh_list, list) {
 +		if (compare_orig(tmp_neigh_node->addr, ethhdr->h_source) &&
 +		    (tmp_neigh_node->if_incoming == if_incoming)) {
 +			neigh_node = tmp_neigh_node;
 +			continue;
 +		}
 +
 +		if (is_duplicate)
 +			continue;
 +
 +		ring_buffer_set(tmp_neigh_node->tq_recv,
 +				&tmp_neigh_node->tq_index, 0);
 +		tmp_neigh_node->tq_avg =
 +			ring_buffer_avg(tmp_neigh_node->tq_recv);
 +	}
 +
 +	if (!neigh_node) {
 +		struct orig_node *orig_tmp;
 +
 +		orig_tmp = get_orig_node(bat_priv, ethhdr->h_source);
 +		if (!orig_tmp)
 +			return;
 +
 +		neigh_node = create_neighbor(orig_node, orig_tmp,
 +					     ethhdr->h_source, if_incoming);
 +		if (!neigh_node)
 +			return;
 +	} else
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"Updating existing last-hop neighbor of originator\n");
 +
 +	orig_node->flags = batman_packet->flags;
 +	neigh_node->last_valid = jiffies;
 +
 +	ring_buffer_set(neigh_node->tq_recv,
 +			&neigh_node->tq_index,
 +			batman_packet->tq);
 +	neigh_node->tq_avg = ring_buffer_avg(neigh_node->tq_recv);
 +
 +	if (!is_duplicate) {
 +		orig_node->last_ttl = batman_packet->ttl;
 +		neigh_node->last_ttl = batman_packet->ttl;
 +	}
 +
 +	tmp_hna_buff_len = (hna_buff_len > batman_packet->num_hna * ETH_ALEN ?
 +			    batman_packet->num_hna * ETH_ALEN : hna_buff_len);
 +
 +	/* if this neighbor already is our next hop there is nothing
 +	 * to change */
 +	if (orig_node->router == neigh_node)
 +		goto update_hna;
 +
 +	/* if this neighbor does not offer a better TQ we won't consider it */
 +	if ((orig_node->router) &&
 +	    (orig_node->router->tq_avg > neigh_node->tq_avg))
 +		goto update_hna;
 +
 +	/* if the TQ is the same and the link not more symetric we
 +	 * won't consider it either */
 +	if ((orig_node->router) &&
 +	     ((neigh_node->tq_avg == orig_node->router->tq_avg) &&
 +	     (orig_node->router->orig_node->bcast_own_sum[if_incoming->if_num]
 +	      >= neigh_node->orig_node->bcast_own_sum[if_incoming->if_num])))
 +		goto update_hna;
 +
 +	update_routes(bat_priv, orig_node, neigh_node,
 +		      hna_buff, tmp_hna_buff_len);
 +	return;
 +
 +update_hna:
 +	update_routes(bat_priv, orig_node, orig_node->router,
 +		      hna_buff, tmp_hna_buff_len);
 +}
 +
 +/* checks whether the host restarted and is in the protection time.
 + * returns:
 + *  0 if the packet is to be accepted
 + *  1 if the packet is to be ignored.
 + */
 +static int window_protected(struct bat_priv *bat_priv,
 +			    int32_t seq_num_diff,
 +			    unsigned long *last_reset)
 +{
 +	if ((seq_num_diff <= -TQ_LOCAL_WINDOW_SIZE)
 +		|| (seq_num_diff >= EXPECTED_SEQNO_RANGE)) {
 +		if (time_after(jiffies, *last_reset +
 +			msecs_to_jiffies(RESET_PROTECTION_MS))) {
 +
 +			*last_reset = jiffies;
 +			bat_dbg(DBG_BATMAN, bat_priv,
 +				"old packet received, start protection\n");
 +
 +			return 0;
 +		} else
 +			return 1;
 +	}
 +	return 0;
 +}
 +
 +/* processes a batman packet for all interfaces, adjusts the sequence number and
 + * finds out whether it is a duplicate.
 + * returns:
 + *   1 the packet is a duplicate
 + *   0 the packet has not yet been received
 + *  -1 the packet is old and has been received while the seqno window
 + *     was protected. Caller should drop it.
 + */
 +static char count_real_packets(struct ethhdr *ethhdr,
 +			       struct batman_packet *batman_packet,
 +			       struct batman_if *if_incoming)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
 +	struct orig_node *orig_node;
 +	struct neigh_node *tmp_neigh_node;
 +	char is_duplicate = 0;
 +	int32_t seq_diff;
 +	int need_update = 0;
 +	int set_mark;
 +
 +	orig_node = get_orig_node(bat_priv, batman_packet->orig);
 +	if (orig_node == NULL)
 +		return 0;
 +
 +	seq_diff = batman_packet->seqno - orig_node->last_real_seqno;
 +
 +	/* signalize caller that the packet is to be dropped. */
 +	if (window_protected(bat_priv, seq_diff,
 +			     &orig_node->batman_seqno_reset))
 +		return -1;
 +
 +	list_for_each_entry(tmp_neigh_node, &orig_node->neigh_list, list) {
 +
 +		is_duplicate |= get_bit_status(tmp_neigh_node->real_bits,
 +					       orig_node->last_real_seqno,
 +					       batman_packet->seqno);
 +
 +		if (compare_orig(tmp_neigh_node->addr, ethhdr->h_source) &&
 +		    (tmp_neigh_node->if_incoming == if_incoming))
 +			set_mark = 1;
 +		else
 +			set_mark = 0;
 +
 +		/* if the window moved, set the update flag. */
 +		need_update |= bit_get_packet(bat_priv,
 +					      tmp_neigh_node->real_bits,
 +					      seq_diff, set_mark);
 +
 +		tmp_neigh_node->real_packet_count =
 +			bit_packet_count(tmp_neigh_node->real_bits);
 +	}
 +
 +	if (need_update) {
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"updating last_seqno: old %d, new %d\n",
 +			orig_node->last_real_seqno, batman_packet->seqno);
 +		orig_node->last_real_seqno = batman_packet->seqno;
 +	}
 +
 +	return is_duplicate;
 +}
 +
 +/* copy primary address for bonding */
 +static void mark_bonding_address(struct bat_priv *bat_priv,
 +				 struct orig_node *orig_node,
 +				 struct orig_node *orig_neigh_node,
 +				 struct batman_packet *batman_packet)
 +
 +{
 +	if (batman_packet->flags & PRIMARIES_FIRST_HOP)
 +		memcpy(orig_neigh_node->primary_addr,
 +		       orig_node->orig, ETH_ALEN);
 +
 +	return;
 +}
 +
 +/* mark possible bond.candidates in the neighbor list */
 +void update_bonding_candidates(struct bat_priv *bat_priv,
 +			       struct orig_node *orig_node)
 +{
 +	int candidates;
 +	int interference_candidate;
 +	int best_tq;
 +	struct neigh_node *tmp_neigh_node, *tmp_neigh_node2;
 +	struct neigh_node *first_candidate, *last_candidate;
 +
 +	/* update the candidates for this originator */
 +	if (!orig_node->router) {
 +		orig_node->bond.candidates = 0;
 +		return;
 +	}
 +
 +	best_tq = orig_node->router->tq_avg;
 +
 +	/* update bond.candidates */
 +
 +	candidates = 0;
 +
 +	/* mark other nodes which also received "PRIMARIES FIRST HOP" packets
 +	 * as "bonding partner" */
 +
 +	/* first, zero the list */
 +	list_for_each_entry(tmp_neigh_node, &orig_node->neigh_list, list) {
 +		tmp_neigh_node->next_bond_candidate = NULL;
 +	}
 +
 +	first_candidate = NULL;
 +	last_candidate = NULL;
 +	list_for_each_entry(tmp_neigh_node, &orig_node->neigh_list, list) {
 +
 +		/* only consider if it has the same primary address ...  */
 +		if (memcmp(orig_node->orig,
 +				tmp_neigh_node->orig_node->primary_addr,
 +				ETH_ALEN) != 0)
 +			continue;
 +
 +		/* ... and is good enough to be considered */
 +		if (tmp_neigh_node->tq_avg < best_tq - BONDING_TQ_THRESHOLD)
 +			continue;
 +
 +		/* check if we have another candidate with the same
 +		 * mac address or interface. If we do, we won't
 +		 * select this candidate because of possible interference. */
 +
 +		interference_candidate = 0;
 +		list_for_each_entry(tmp_neigh_node2,
 +				&orig_node->neigh_list, list) {
 +
 +			if (tmp_neigh_node2 == tmp_neigh_node)
 +				continue;
 +
 +			/* we only care if the other candidate is even
 +			 * considered as candidate. */
 +			if (tmp_neigh_node2->next_bond_candidate == NULL)
 +				continue;
 +
 +
 +			if ((tmp_neigh_node->if_incoming ==
 +				tmp_neigh_node2->if_incoming)
 +				|| (memcmp(tmp_neigh_node->addr,
 +				tmp_neigh_node2->addr, ETH_ALEN) == 0)) {
 +
 +				interference_candidate = 1;
 +				break;
 +			}
 +		}
 +		/* don't care further if it is an interference candidate */
 +		if (interference_candidate)
 +			continue;
 +
 +		if (first_candidate == NULL) {
 +			first_candidate = tmp_neigh_node;
 +			tmp_neigh_node->next_bond_candidate = first_candidate;
 +		} else
 +			tmp_neigh_node->next_bond_candidate = last_candidate;
 +
 +		last_candidate = tmp_neigh_node;
 +
 +		candidates++;
 +	}
 +
 +	if (candidates > 0) {
 +		first_candidate->next_bond_candidate = last_candidate;
 +		orig_node->bond.selected = first_candidate;
 +	}
 +
 +	orig_node->bond.candidates = candidates;
 +}
 +
 +void receive_bat_packet(struct ethhdr *ethhdr,
 +				struct batman_packet *batman_packet,
 +				unsigned char *hna_buff, int hna_buff_len,
 +				struct batman_if *if_incoming)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
 +	struct batman_if *batman_if;
 +	struct orig_node *orig_neigh_node, *orig_node;
 +	char has_directlink_flag;
 +	char is_my_addr = 0, is_my_orig = 0, is_my_oldorig = 0;
 +	char is_broadcast = 0, is_bidirectional, is_single_hop_neigh;
 +	char is_duplicate;
 +	uint32_t if_incoming_seqno;
 +
 +	/* Silently drop when the batman packet is actually not a
 +	 * correct packet.
 +	 *
 +	 * This might happen if a packet is padded (e.g. Ethernet has a
 +	 * minimum frame length of 64 byte) and the aggregation interprets
 +	 * it as an additional length.
 +	 *
 +	 * TODO: A more sane solution would be to have a bit in the
 +	 * batman_packet to detect whether the packet is the last
 +	 * packet in an aggregation.  Here we expect that the padding
 +	 * is always zero (or not 0x01)
 +	 */
 +	if (batman_packet->packet_type != BAT_PACKET)
 +		return;
 +
 +	/* could be changed by schedule_own_packet() */
 +	if_incoming_seqno = atomic_read(&if_incoming->seqno);
 +
 +	has_directlink_flag = (batman_packet->flags & DIRECTLINK ? 1 : 0);
 +
 +	is_single_hop_neigh = (compare_orig(ethhdr->h_source,
 +					    batman_packet->orig) ? 1 : 0);
 +
 +	bat_dbg(DBG_BATMAN, bat_priv,
 +		"Received BATMAN packet via NB: %pM, IF: %s [%s] "
 +		"(from OG: %pM, via prev OG: %pM, seqno %d, tq %d, "
 +		"TTL %d, V %d, IDF %d)\n",
 +		ethhdr->h_source, if_incoming->net_dev->name,
 +		if_incoming->addr_str, batman_packet->orig,
 +		batman_packet->prev_sender, batman_packet->seqno,
 +		batman_packet->tq, batman_packet->ttl, batman_packet->version,
 +		has_directlink_flag);
 +
++	rcu_read_lock();
 +	list_for_each_entry_rcu(batman_if, &if_list, list) {
 +		if (batman_if->if_status != IF_ACTIVE)
 +			continue;
 +
 +		if (batman_if->soft_iface != if_incoming->soft_iface)
 +			continue;
 +
 +		if (compare_orig(ethhdr->h_source,
 +				 batman_if->net_dev->dev_addr))
 +			is_my_addr = 1;
 +
 +		if (compare_orig(batman_packet->orig,
 +				 batman_if->net_dev->dev_addr))
 +			is_my_orig = 1;
 +
 +		if (compare_orig(batman_packet->prev_sender,
 +				 batman_if->net_dev->dev_addr))
 +			is_my_oldorig = 1;
 +
 +		if (compare_orig(ethhdr->h_source, broadcast_addr))
 +			is_broadcast = 1;
 +	}
++	rcu_read_unlock();
 +
 +	if (batman_packet->version != COMPAT_VERSION) {
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"Drop packet: incompatible batman version (%i)\n",
 +			batman_packet->version);
 +		return;
 +	}
 +
 +	if (is_my_addr) {
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"Drop packet: received my own broadcast (sender: %pM"
 +			")\n",
 +			ethhdr->h_source);
 +		return;
 +	}
 +
 +	if (is_broadcast) {
 +		bat_dbg(DBG_BATMAN, bat_priv, "Drop packet: "
 +		"ignoring all packets with broadcast source addr (sender: %pM"
 +		")\n", ethhdr->h_source);
 +		return;
 +	}
 +
 +	if (is_my_orig) {
 +		TYPE_OF_WORD *word;
 +		int offset;
 +
 +		orig_neigh_node = get_orig_node(bat_priv, ethhdr->h_source);
 +
 +		if (!orig_neigh_node)
 +			return;
 +
 +		/* neighbor has to indicate direct link and it has to
 +		 * come via the corresponding interface */
 +		/* if received seqno equals last send seqno save new
 +		 * seqno for bidirectional check */
 +		if (has_directlink_flag &&
 +		    compare_orig(if_incoming->net_dev->dev_addr,
 +				 batman_packet->orig) &&
 +		    (batman_packet->seqno - if_incoming_seqno + 2 == 0)) {
 +			offset = if_incoming->if_num * NUM_WORDS;
 +			word = &(orig_neigh_node->bcast_own[offset]);
 +			bit_mark(word, 0);
 +			orig_neigh_node->bcast_own_sum[if_incoming->if_num] =
 +				bit_packet_count(word);
 +		}
 +
 +		bat_dbg(DBG_BATMAN, bat_priv, "Drop packet: "
 +			"originator packet from myself (via neighbor)\n");
 +		return;
 +	}
 +
 +	if (is_my_oldorig) {
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"Drop packet: ignoring all rebroadcast echos (sender: "
 +			"%pM)\n", ethhdr->h_source);
 +		return;
 +	}
 +
 +	orig_node = get_orig_node(bat_priv, batman_packet->orig);
 +	if (orig_node == NULL)
 +		return;
 +
 +	is_duplicate = count_real_packets(ethhdr, batman_packet, if_incoming);
 +
 +	if (is_duplicate == -1) {
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"Drop packet: packet within seqno protection time "
 +			"(sender: %pM)\n", ethhdr->h_source);
 +		return;
 +	}
 +
 +	if (batman_packet->tq == 0) {
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"Drop packet: originator packet with tq equal 0\n");
 +		return;
 +	}
 +
 +	/* avoid temporary routing loops */
 +	if ((orig_node->router) &&
 +	    (orig_node->router->orig_node->router) &&
 +	    (compare_orig(orig_node->router->addr,
 +			  batman_packet->prev_sender)) &&
 +	    !(compare_orig(batman_packet->orig, batman_packet->prev_sender)) &&
 +	    (compare_orig(orig_node->router->addr,
 +			  orig_node->router->orig_node->router->addr))) {
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"Drop packet: ignoring all rebroadcast packets that "
 +			"may make me loop (sender: %pM)\n", ethhdr->h_source);
 +		return;
 +	}
 +
 +	/* if sender is a direct neighbor the sender mac equals
 +	 * originator mac */
 +	orig_neigh_node = (is_single_hop_neigh ?
 +			   orig_node :
 +			   get_orig_node(bat_priv, ethhdr->h_source));
 +	if (orig_neigh_node == NULL)
 +		return;
 +
 +	/* drop packet if sender is not a direct neighbor and if we
 +	 * don't route towards it */
 +	if (!is_single_hop_neigh &&
 +	    (orig_neigh_node->router == NULL)) {
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"Drop packet: OGM via unknown neighbor!\n");
 +		return;
 +	}
 +
 +	is_bidirectional = is_bidirectional_neigh(orig_node, orig_neigh_node,
 +						batman_packet, if_incoming);
 +
 +	/* update ranking if it is not a duplicate or has the same
 +	 * seqno and similar ttl as the non-duplicate */
 +	if (is_bidirectional &&
 +	    (!is_duplicate ||
 +	     ((orig_node->last_real_seqno == batman_packet->seqno) &&
 +	      (orig_node->last_ttl - 3 <= batman_packet->ttl))))
 +		update_orig(bat_priv, orig_node, ethhdr, batman_packet,
 +			    if_incoming, hna_buff, hna_buff_len, is_duplicate);
 +
 +	mark_bonding_address(bat_priv, orig_node,
 +			     orig_neigh_node, batman_packet);
 +	update_bonding_candidates(bat_priv, orig_node);
 +
 +	/* is single hop (direct) neighbor */
 +	if (is_single_hop_neigh) {
 +
 +		/* mark direct link on incoming interface */
 +		schedule_forward_packet(orig_node, ethhdr, batman_packet,
 +					1, hna_buff_len, if_incoming);
 +
 +		bat_dbg(DBG_BATMAN, bat_priv, "Forwarding packet: "
 +			"rebroadcast neighbor packet with direct link flag\n");
 +		return;
 +	}
 +
 +	/* multihop originator */
 +	if (!is_bidirectional) {
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"Drop packet: not received via bidirectional link\n");
 +		return;
 +	}
 +
 +	if (is_duplicate) {
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"Drop packet: duplicate packet received\n");
 +		return;
 +	}
 +
 +	bat_dbg(DBG_BATMAN, bat_priv,
 +		"Forwarding packet: rebroadcast originator packet\n");
 +	schedule_forward_packet(orig_node, ethhdr, batman_packet,
 +				0, hna_buff_len, if_incoming);
 +}
 +
 +int recv_bat_packet(struct sk_buff *skb, struct batman_if *batman_if)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(batman_if->soft_iface);
 +	struct ethhdr *ethhdr;
 +	unsigned long flags;
 +
 +	/* drop packet if it has not necessary minimum size */
 +	if (unlikely(!pskb_may_pull(skb, sizeof(struct batman_packet))))
 +		return NET_RX_DROP;
 +
 +	ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +	/* packet with broadcast indication but unicast recipient */
 +	if (!is_bcast(ethhdr->h_dest))
 +		return NET_RX_DROP;
 +
 +	/* packet with broadcast sender address */
 +	if (is_bcast(ethhdr->h_source))
 +		return NET_RX_DROP;
 +
 +	/* create a copy of the skb, if needed, to modify it. */
 +	if (skb_cow(skb, 0) < 0)
 +		return NET_RX_DROP;
 +
 +	/* keep skb linear */
 +	if (skb_linearize(skb) < 0)
 +		return NET_RX_DROP;
 +
 +	ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +	receive_aggr_bat_packet(ethhdr,
 +				skb->data,
 +				skb_headlen(skb),
 +				batman_if);
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +	kfree_skb(skb);
 +	return NET_RX_SUCCESS;
 +}
 +
 +static int recv_my_icmp_packet(struct bat_priv *bat_priv,
 +			       struct sk_buff *skb, size_t icmp_len)
 +{
 +	struct orig_node *orig_node;
 +	struct icmp_packet_rr *icmp_packet;
 +	struct ethhdr *ethhdr;
 +	struct batman_if *batman_if;
 +	int ret;
 +	unsigned long flags;
 +	uint8_t dstaddr[ETH_ALEN];
 +
 +	icmp_packet = (struct icmp_packet_rr *)skb->data;
 +	ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +	/* add data to device queue */
 +	if (icmp_packet->msg_type != ECHO_REQUEST) {
 +		bat_socket_receive_packet(icmp_packet, icmp_len);
 +		return NET_RX_DROP;
 +	}
 +
 +	if (!bat_priv->primary_if)
 +		return NET_RX_DROP;
 +
 +	/* answer echo request (ping) */
 +	/* get routing information */
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +	orig_node = ((struct orig_node *)hash_find(bat_priv->orig_hash,
 +						   icmp_packet->orig));
 +	ret = NET_RX_DROP;
 +
 +	if ((orig_node != NULL) &&
 +	    (orig_node->router != NULL)) {
 +
 +		/* don't lock while sending the packets ... we therefore
 +		 * copy the required data before sending */
 +		batman_if = orig_node->router->if_incoming;
 +		memcpy(dstaddr, orig_node->router->addr, ETH_ALEN);
 +		spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +		/* create a copy of the skb, if needed, to modify it. */
 +		if (skb_cow(skb, sizeof(struct ethhdr)) < 0)
 +			return NET_RX_DROP;
 +
 +		icmp_packet = (struct icmp_packet_rr *)skb->data;
 +		ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +		memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN);
 +		memcpy(icmp_packet->orig,
 +		       bat_priv->primary_if->net_dev->dev_addr, ETH_ALEN);
 +		icmp_packet->msg_type = ECHO_REPLY;
 +		icmp_packet->ttl = TTL;
 +
 +		send_skb_packet(skb, batman_if, dstaddr);
 +		ret = NET_RX_SUCCESS;
 +
 +	} else
 +		spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +	return ret;
 +}
 +
 +static int recv_icmp_ttl_exceeded(struct bat_priv *bat_priv,
 +				  struct sk_buff *skb, size_t icmp_len)
 +{
 +	struct orig_node *orig_node;
 +	struct icmp_packet *icmp_packet;
 +	struct ethhdr *ethhdr;
 +	struct batman_if *batman_if;
 +	int ret;
 +	unsigned long flags;
 +	uint8_t dstaddr[ETH_ALEN];
 +
 +	icmp_packet = (struct icmp_packet *)skb->data;
 +	ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +	/* send TTL exceeded if packet is an echo request (traceroute) */
 +	if (icmp_packet->msg_type != ECHO_REQUEST) {
 +		pr_debug("Warning - can't forward icmp packet from %pM to "
 +			 "%pM: ttl exceeded\n", icmp_packet->orig,
 +			 icmp_packet->dst);
 +		return NET_RX_DROP;
 +	}
 +
 +	if (!bat_priv->primary_if)
 +		return NET_RX_DROP;
 +
 +	/* get routing information */
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +	orig_node = ((struct orig_node *)
 +		     hash_find(bat_priv->orig_hash, icmp_packet->orig));
 +	ret = NET_RX_DROP;
 +
 +	if ((orig_node != NULL) &&
 +	    (orig_node->router != NULL)) {
 +
 +		/* don't lock while sending the packets ... we therefore
 +		 * copy the required data before sending */
 +		batman_if = orig_node->router->if_incoming;
 +		memcpy(dstaddr, orig_node->router->addr, ETH_ALEN);
 +		spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +		/* create a copy of the skb, if needed, to modify it. */
 +		if (skb_cow(skb, sizeof(struct ethhdr)) < 0)
 +			return NET_RX_DROP;
 +
 +		icmp_packet = (struct icmp_packet *) skb->data;
 +		ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +		memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN);
 +		memcpy(icmp_packet->orig,
 +		       bat_priv->primary_if->net_dev->dev_addr, ETH_ALEN);
 +		icmp_packet->msg_type = TTL_EXCEEDED;
 +		icmp_packet->ttl = TTL;
 +
 +		send_skb_packet(skb, batman_if, dstaddr);
 +		ret = NET_RX_SUCCESS;
 +
 +	} else
 +		spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +	return ret;
 +}
 +
 +
 +int recv_icmp_packet(struct sk_buff *skb, struct batman_if *recv_if)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
 +	struct icmp_packet_rr *icmp_packet;
 +	struct ethhdr *ethhdr;
 +	struct orig_node *orig_node;
 +	struct batman_if *batman_if;
 +	int hdr_size = sizeof(struct icmp_packet);
 +	int ret;
 +	unsigned long flags;
 +	uint8_t dstaddr[ETH_ALEN];
 +
 +	/**
 +	 * we truncate all incoming icmp packets if they don't match our size
 +	 */
 +	if (skb->len >= sizeof(struct icmp_packet_rr))
 +		hdr_size = sizeof(struct icmp_packet_rr);
 +
 +	/* drop packet if it has not necessary minimum size */
 +	if (unlikely(!pskb_may_pull(skb, hdr_size)))
 +		return NET_RX_DROP;
 +
 +	ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +	/* packet with unicast indication but broadcast recipient */
 +	if (is_bcast(ethhdr->h_dest))
 +		return NET_RX_DROP;
 +
 +	/* packet with broadcast sender address */
 +	if (is_bcast(ethhdr->h_source))
 +		return NET_RX_DROP;
 +
 +	/* not for me */
 +	if (!is_my_mac(ethhdr->h_dest))
 +		return NET_RX_DROP;
 +
 +	icmp_packet = (struct icmp_packet_rr *)skb->data;
 +
 +	/* add record route information if not full */
 +	if ((hdr_size == sizeof(struct icmp_packet_rr)) &&
 +	    (icmp_packet->rr_cur < BAT_RR_LEN)) {
 +		memcpy(&(icmp_packet->rr[icmp_packet->rr_cur]),
 +			ethhdr->h_dest, ETH_ALEN);
 +		icmp_packet->rr_cur++;
 +	}
 +
 +	/* packet for me */
 +	if (is_my_mac(icmp_packet->dst))
 +		return recv_my_icmp_packet(bat_priv, skb, hdr_size);
 +
 +	/* TTL exceeded */
 +	if (icmp_packet->ttl < 2)
 +		return recv_icmp_ttl_exceeded(bat_priv, skb, hdr_size);
 +
 +	ret = NET_RX_DROP;
 +
 +	/* get routing information */
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +	orig_node = ((struct orig_node *)
 +		     hash_find(bat_priv->orig_hash, icmp_packet->dst));
 +
 +	if ((orig_node != NULL) &&
 +	    (orig_node->router != NULL)) {
 +
 +		/* don't lock while sending the packets ... we therefore
 +		 * copy the required data before sending */
 +		batman_if = orig_node->router->if_incoming;
 +		memcpy(dstaddr, orig_node->router->addr, ETH_ALEN);
 +		spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +		/* create a copy of the skb, if needed, to modify it. */
 +		if (skb_cow(skb, sizeof(struct ethhdr)) < 0)
 +			return NET_RX_DROP;
 +
 +		icmp_packet = (struct icmp_packet_rr *)skb->data;
 +		ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +		/* decrement ttl */
 +		icmp_packet->ttl--;
 +
 +		/* route it */
 +		send_skb_packet(skb, batman_if, dstaddr);
 +		ret = NET_RX_SUCCESS;
 +
 +	} else
 +		spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +	return ret;
 +}
 +
 +/* find a suitable router for this originator, and use
 + * bonding if possible. */
 +struct neigh_node *find_router(struct orig_node *orig_node,
 +			       struct batman_if *recv_if)
 +{
 +	struct bat_priv *bat_priv;
 +	struct orig_node *primary_orig_node;
 +	struct orig_node *router_orig;
 +	struct neigh_node *router, *first_candidate, *best_router;
 +	static uint8_t zero_mac[ETH_ALEN] = {0, 0, 0, 0, 0, 0};
 +	int bonding_enabled;
 +
 +	if (!orig_node)
 +		return NULL;
 +
 +	if (!orig_node->router)
 +		return NULL;
 +
 +	/* without bonding, the first node should
 +	 * always choose the default router. */
 +
 +	if (!recv_if)
 +		return orig_node->router;
 +
 +	bat_priv = netdev_priv(recv_if->soft_iface);
 +	bonding_enabled = atomic_read(&bat_priv->bonding_enabled);
 +
 +	if (!bonding_enabled)
 +		return orig_node->router;
 +
 +	router_orig = orig_node->router->orig_node;
 +
 +	/* if we have something in the primary_addr, we can search
 +	 * for a potential bonding candidate. */
 +	if (memcmp(router_orig->primary_addr, zero_mac, ETH_ALEN) == 0)
 +		return orig_node->router;
 +
 +	/* find the orig_node which has the primary interface. might
 +	 * even be the same as our router_orig in many cases */
 +
 +	if (memcmp(router_orig->primary_addr,
 +				router_orig->orig, ETH_ALEN) == 0) {
 +		primary_orig_node = router_orig;
 +	} else {
 +		primary_orig_node = hash_find(bat_priv->orig_hash,
 +						router_orig->primary_addr);
 +
 +		if (!primary_orig_node)
 +			return orig_node->router;
 +	}
 +
 +	/* with less than 2 candidates, we can't do any
 +	 * bonding and prefer the original router. */
 +
 +	if (primary_orig_node->bond.candidates < 2)
 +		return orig_node->router;
 +
 +
 +	/* all nodes between should choose a candidate which
 +	 * is is not on the interface where the packet came
 +	 * in. */
 +	first_candidate = primary_orig_node->bond.selected;
 +	router = first_candidate;
 +
 +	if (bonding_enabled) {
 +		/* in the bonding case, send the packets in a round
 +		 * robin fashion over the remaining interfaces. */
 +		do {
 +			/* recv_if == NULL on the first node. */
 +			if (router->if_incoming != recv_if)
 +				break;
 +
 +			router = router->next_bond_candidate;
 +		} while (router != first_candidate);
 +
 +		primary_orig_node->bond.selected = router->next_bond_candidate;
 +
 +	} else {
 +		/* if bonding is disabled, use the best of the
 +		 * remaining candidates which are not using
 +		 * this interface. */
 +		best_router = first_candidate;
 +
 +		do {
 +			/* recv_if == NULL on the first node. */
 +			if ((router->if_incoming != recv_if) &&
 +				(router->tq_avg > best_router->tq_avg))
 +					best_router = router;
 +
 +			router = router->next_bond_candidate;
 +		} while (router != first_candidate);
 +
 +		router = best_router;
 +	}
 +
 +	return router;
 +}
 +
 +static int check_unicast_packet(struct sk_buff *skb, int hdr_size)
 +{
 +	struct ethhdr *ethhdr;
 +
 +	/* drop packet if it has not necessary minimum size */
 +	if (unlikely(!pskb_may_pull(skb, hdr_size)))
 +		return -1;
 +
 +	ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +	/* packet with unicast indication but broadcast recipient */
 +	if (is_bcast(ethhdr->h_dest))
 +		return -1;
 +
 +	/* packet with broadcast sender address */
 +	if (is_bcast(ethhdr->h_source))
 +		return -1;
 +
 +	/* not for me */
 +	if (!is_my_mac(ethhdr->h_dest))
 +		return -1;
 +
 +	return 0;
 +}
 +
 +static int route_unicast_packet(struct sk_buff *skb,
 +				struct batman_if *recv_if, int hdr_size)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
 +	struct orig_node *orig_node;
 +	struct neigh_node *router;
 +	struct batman_if *batman_if;
 +	uint8_t dstaddr[ETH_ALEN];
 +	unsigned long flags;
 +	struct unicast_packet *unicast_packet;
 +	struct ethhdr *ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +	unicast_packet = (struct unicast_packet *)skb->data;
 +
 +	/* packet for me */
 +	if (is_my_mac(unicast_packet->dest)) {
 +		interface_rx(recv_if->soft_iface, skb, hdr_size);
 +		return NET_RX_SUCCESS;
 +	}
 +
 +	/* TTL exceeded */
 +	if (unicast_packet->ttl < 2) {
 +		pr_debug("Warning - can't forward unicast packet from %pM to "
 +			 "%pM: ttl exceeded\n", ethhdr->h_source,
 +			 unicast_packet->dest);
 +		return NET_RX_DROP;
 +	}
 +
 +	/* get routing information */
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +	orig_node = ((struct orig_node *)
 +		     hash_find(bat_priv->orig_hash, unicast_packet->dest));
 +
 +	router = find_router(orig_node, recv_if);
 +
 +	if (!router) {
 +		spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +		return NET_RX_DROP;
 +	}
 +
 +	/* don't lock while sending the packets ... we therefore
 +	 * copy the required data before sending */
 +
 +	batman_if = router->if_incoming;
 +	memcpy(dstaddr, router->addr, ETH_ALEN);
 +
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +	/* create a copy of the skb, if needed, to modify it. */
 +	if (skb_cow(skb, sizeof(struct ethhdr)) < 0)
 +		return NET_RX_DROP;
 +
 +	unicast_packet = (struct unicast_packet *)skb->data;
 +	ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +	/* decrement ttl */
 +	unicast_packet->ttl--;
 +
 +	/* route it */
 +	send_skb_packet(skb, batman_if, dstaddr);
 +
 +	return NET_RX_SUCCESS;
 +}
 +
 +int recv_unicast_packet(struct sk_buff *skb, struct batman_if *recv_if)
 +{
 +	struct unicast_packet *unicast_packet;
 +	int hdr_size = sizeof(struct unicast_packet);
 +
 +	if (check_unicast_packet(skb, hdr_size) < 0)
 +		return NET_RX_DROP;
 +
 +	unicast_packet = (struct unicast_packet *)skb->data;
 +
 +	/* packet for me */
 +	if (is_my_mac(unicast_packet->dest)) {
 +		interface_rx(recv_if->soft_iface, skb, hdr_size);
 +		return NET_RX_SUCCESS;
 +	}
 +
 +	return route_unicast_packet(skb, recv_if, hdr_size);
 +}
 +
 +int recv_ucast_frag_packet(struct sk_buff *skb, struct batman_if *recv_if)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
 +	struct unicast_frag_packet *unicast_packet;
 +	struct orig_node *orig_node;
 +	struct frag_packet_list_entry *tmp_frag_entry;
 +	int hdr_size = sizeof(struct unicast_frag_packet);
 +	unsigned long flags;
 +
 +	if (check_unicast_packet(skb, hdr_size) < 0)
 +		return NET_RX_DROP;
 +
 +	unicast_packet = (struct unicast_frag_packet *)skb->data;
 +
 +	/* packet for me */
 +	if (is_my_mac(unicast_packet->dest)) {
 +
 +		spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +		orig_node = ((struct orig_node *)
 +			hash_find(bat_priv->orig_hash, unicast_packet->orig));
 +
 +		if (!orig_node) {
 +			pr_debug("couldn't find orig node for fragmentation\n");
 +			spin_unlock_irqrestore(&bat_priv->orig_hash_lock,
 +					       flags);
 +			return NET_RX_DROP;
 +		}
 +
 +		orig_node->last_frag_packet = jiffies;
 +
 +		if (list_empty(&orig_node->frag_list) &&
 +			create_frag_buffer(&orig_node->frag_list)) {
 +			spin_unlock_irqrestore(&bat_priv->orig_hash_lock,
 +					       flags);
 +			return NET_RX_DROP;
 +		}
 +
 +		tmp_frag_entry =
 +			search_frag_packet(&orig_node->frag_list,
 +					   unicast_packet);
 +
 +		if (!tmp_frag_entry) {
 +			create_frag_entry(&orig_node->frag_list, skb);
 +			spin_unlock_irqrestore(&bat_priv->orig_hash_lock,
 +					       flags);
 +			return NET_RX_SUCCESS;
 +		}
 +
 +		skb = merge_frag_packet(&orig_node->frag_list,
 +					tmp_frag_entry, skb);
 +		spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +		if (!skb)
 +			return NET_RX_DROP;
 +
 +		interface_rx(recv_if->soft_iface, skb, hdr_size);
 +		return NET_RX_SUCCESS;
 +	}
 +
 +	return route_unicast_packet(skb, recv_if, hdr_size);
 +}
 +
 +
 +int recv_bcast_packet(struct sk_buff *skb, struct batman_if *recv_if)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
 +	struct orig_node *orig_node;
 +	struct bcast_packet *bcast_packet;
 +	struct ethhdr *ethhdr;
 +	int hdr_size = sizeof(struct bcast_packet);
 +	int32_t seq_diff;
 +	unsigned long flags;
 +
 +	/* drop packet if it has not necessary minimum size */
 +	if (unlikely(!pskb_may_pull(skb, hdr_size)))
 +		return NET_RX_DROP;
 +
 +	ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +	/* packet with broadcast indication but unicast recipient */
 +	if (!is_bcast(ethhdr->h_dest))
 +		return NET_RX_DROP;
 +
 +	/* packet with broadcast sender address */
 +	if (is_bcast(ethhdr->h_source))
 +		return NET_RX_DROP;
 +
 +	/* ignore broadcasts sent by myself */
 +	if (is_my_mac(ethhdr->h_source))
 +		return NET_RX_DROP;
 +
 +	bcast_packet = (struct bcast_packet *)skb->data;
 +
 +	/* ignore broadcasts originated by myself */
 +	if (is_my_mac(bcast_packet->orig))
 +		return NET_RX_DROP;
 +
 +	if (bcast_packet->ttl < 2)
 +		return NET_RX_DROP;
 +
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +	orig_node = ((struct orig_node *)
 +		     hash_find(bat_priv->orig_hash, bcast_packet->orig));
 +
 +	if (orig_node == NULL) {
 +		spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +		return NET_RX_DROP;
 +	}
 +
 +	/* check whether the packet is a duplicate */
 +	if (get_bit_status(orig_node->bcast_bits,
 +			   orig_node->last_bcast_seqno,
 +			   ntohl(bcast_packet->seqno))) {
 +		spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +		return NET_RX_DROP;
 +	}
 +
 +	seq_diff = ntohl(bcast_packet->seqno) - orig_node->last_bcast_seqno;
 +
 +	/* check whether the packet is old and the host just restarted. */
 +	if (window_protected(bat_priv, seq_diff,
 +			     &orig_node->bcast_seqno_reset)) {
 +		spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +		return NET_RX_DROP;
 +	}
 +
 +	/* mark broadcast in flood history, update window position
 +	 * if required. */
 +	if (bit_get_packet(bat_priv, orig_node->bcast_bits, seq_diff, 1))
 +		orig_node->last_bcast_seqno = ntohl(bcast_packet->seqno);
 +
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +	/* rebroadcast packet */
 +	add_bcast_packet_to_list(bat_priv, skb);
 +
 +	/* broadcast for me */
 +	interface_rx(recv_if->soft_iface, skb, hdr_size);
 +
 +	return NET_RX_SUCCESS;
 +}
 +
 +int recv_vis_packet(struct sk_buff *skb, struct batman_if *recv_if)
 +{
 +	struct vis_packet *vis_packet;
 +	struct ethhdr *ethhdr;
 +	struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
 +	int hdr_size = sizeof(struct vis_packet);
 +
 +	/* keep skb linear */
 +	if (skb_linearize(skb) < 0)
 +		return NET_RX_DROP;
 +
 +	if (unlikely(!pskb_may_pull(skb, hdr_size)))
 +		return NET_RX_DROP;
 +
 +	vis_packet = (struct vis_packet *)skb->data;
 +	ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +	/* not for me */
 +	if (!is_my_mac(ethhdr->h_dest))
 +		return NET_RX_DROP;
 +
 +	/* ignore own packets */
 +	if (is_my_mac(vis_packet->vis_orig))
 +		return NET_RX_DROP;
 +
 +	if (is_my_mac(vis_packet->sender_orig))
 +		return NET_RX_DROP;
 +
 +	switch (vis_packet->vis_type) {
 +	case VIS_TYPE_SERVER_SYNC:
 +		receive_server_sync_packet(bat_priv, vis_packet,
 +					   skb_headlen(skb));
 +		break;
 +
 +	case VIS_TYPE_CLIENT_UPDATE:
 +		receive_client_update_packet(bat_priv, vis_packet,
 +					     skb_headlen(skb));
 +		break;
 +
 +	default:	/* ignore unknown packet */
 +		break;
 +	}
 +
 +	/* We take a copy of the data in the packet, so we should
 +	   always free the skbuf. */
 +	return NET_RX_DROP;
 +}
diff --combined drivers/staging/batman-adv/types.h
index 9d744d8,bb5827f..bb5827f
--- a/drivers/staging/batman-adv/types.h
+++ b/drivers/staging/batman-adv/types.h
@@@ -44,7 -44,7 +44,7 @@@ struct batman_if 
    unsigned char *packet_buff;
    int packet_len;
    struct kobject *hardif_obj;
- 	struct rcu_head rcu;
+ 	atomic_t refcnt;
    struct packet_type batman_adv_ptype;
    struct net_device *soft_iface;
  };
@@@ -109,6 -109,7 +109,7 @@@ struct neigh_node 
    struct batman_if *if_incoming;
  };
+ 
  struct bat_priv {
    atomic_t mesh_state;
    struct net_device_stats stats;
@@@ -133,13 -134,13 +134,13 @@@
    struct hashtable_t *hna_local_hash;
    struct hashtable_t *hna_global_hash;
    struct hashtable_t *vis_hash;
- 	spinlock_t orig_hash_lock;
- 	spinlock_t forw_bat_list_lock;
- 	spinlock_t forw_bcast_list_lock;
- 	spinlock_t hna_lhash_lock;
- 	spinlock_t hna_ghash_lock;
- 	spinlock_t vis_hash_lock;
- 	spinlock_t vis_list_lock;
+ 	spinlock_t orig_hash_lock; /* protects orig_hash */
+ 	spinlock_t forw_bat_list_lock; /* protects forw_bat_list */
+ 	spinlock_t forw_bcast_list_lock; /* protects  */
+ 	spinlock_t hna_lhash_lock; /* protects hna_local_hash */
+ 	spinlock_t hna_ghash_lock; /* protects hna_global_hash */
+ 	spinlock_t vis_hash_lock; /* protects vis_hash */
+ 	spinlock_t vis_list_lock; /* protects vis_info::recv_list */
    int16_t num_local_hna;
    atomic_t hna_local_changed;
    struct delayed_work hna_work;
@@@ -152,7 -153,7 +153,7 @@@ struct socket_client 
    struct list_head queue_list;
    unsigned int queue_len;
    unsigned char index;
- 	spinlock_t lock;
+ 	spinlock_t lock; /* protects queue_list, queue_len, index */
    wait_queue_head_t queue_wait;
    struct bat_priv *bat_priv;
  };
@@@ -204,7 -205,7 +205,7 @@@ struct debug_log 
    char log_buff[LOG_BUF_LEN];
    unsigned long log_start;
    unsigned long log_end;
- 	spinlock_t lock;
+ 	spinlock_t lock; /* protects log_buff, log_start and log_end */
    wait_queue_head_t queue_wait;
  };
diff --combined drivers/staging/batman-adv/vis.c
index b2cec8e,0000000..6b102a3
mode 100644,000000..100644
--- a/drivers/staging/batman-adv/vis.c
+++ b/drivers/staging/batman-adv/vis.c
@@@ -1,901 -1,0 +1,901 @@@
 +/*
 + * Copyright (C) 2008-2010 B.A.T.M.A.N. contributors:
 + *
 + * Simon Wunderlich
 + *
 + * 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, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 + * 02110-1301, USA
 + *
 + */
 +
 +#include "main.h"
 +#include "send.h"
 +#include "translation-table.h"
 +#include "vis.h"
 +#include "soft-interface.h"
 +#include "hard-interface.h"
 +#include "hash.h"
 +
 +#define MAX_VIS_PACKET_SIZE 1000
 +
 +/* Returns the smallest signed integer in two's complement with the sizeof x */
 +#define smallest_signed_int(x) (1u << (7u + 8u * (sizeof(x) - 1u)))
 +
 +/* Checks if a sequence number x is a predecessor/successor of y.
-    they handle overflows/underflows and can correctly check for a
-    predecessor/successor unless the variable sequence number has grown by
-    more then 2**(bitwidth(x)-1)-1.
-    This means that for a uint8_t with the maximum value 255, it would think:
-     * when adding nothing - it is neither a predecessor nor a successor
-     * before adding more than 127 to the starting value - it is a predecessor,
-     * when adding 128 - it is neither a predecessor nor a successor,
-     * after adding more than 127 to the starting value - it is a successor */
++ * they handle overflows/underflows and can correctly check for a
++ * predecessor/successor unless the variable sequence number has grown by
++ * more then 2**(bitwidth(x)-1)-1.
++ * This means that for a uint8_t with the maximum value 255, it would think:
++ *  - when adding nothing - it is neither a predecessor nor a successor
++ *  - before adding more than 127 to the starting value - it is a predecessor,
++ *  - when adding 128 - it is neither a predecessor nor a successor,
++ *  - after adding more than 127 to the starting value - it is a successor */
 +#define seq_before(x, y) ({typeof(x) _dummy = (x - y); \
 +			_dummy > smallest_signed_int(_dummy); })
 +#define seq_after(x, y) seq_before(y, x)
 +
 +static void start_vis_timer(struct bat_priv *bat_priv);
 +
 +/* free the info */
 +static void free_info(struct kref *ref)
 +{
 +	struct vis_info *info = container_of(ref, struct vis_info, refcount);
 +	struct bat_priv *bat_priv = info->bat_priv;
 +	struct recvlist_node *entry, *tmp;
 +	unsigned long flags;
 +
 +	list_del_init(&info->send_list);
 +	spin_lock_irqsave(&bat_priv->vis_list_lock, flags);
 +	list_for_each_entry_safe(entry, tmp, &info->recv_list, list) {
 +		list_del(&entry->list);
 +		kfree(entry);
 +	}
 +
 +	spin_unlock_irqrestore(&bat_priv->vis_list_lock, flags);
 +	kfree_skb(info->skb_packet);
 +}
 +
 +/* Compare two vis packets, used by the hashing algorithm */
 +static int vis_info_cmp(void *data1, void *data2)
 +{
 +	struct vis_info *d1, *d2;
 +	struct vis_packet *p1, *p2;
 +	d1 = data1;
 +	d2 = data2;
 +	p1 = (struct vis_packet *)d1->skb_packet->data;
 +	p2 = (struct vis_packet *)d2->skb_packet->data;
 +	return compare_orig(p1->vis_orig, p2->vis_orig);
 +}
 +
 +/* hash function to choose an entry in a hash table of given size */
 +/* hash algorithm from http://en.wikipedia.org/wiki/Hash_table */
 +static int vis_info_choose(void *data, int size)
 +{
 +	struct vis_info *vis_info = data;
 +	struct vis_packet *packet;
 +	unsigned char *key;
 +	uint32_t hash = 0;
 +	size_t i;
 +
 +	packet = (struct vis_packet *)vis_info->skb_packet->data;
 +	key = packet->vis_orig;
 +	for (i = 0; i < ETH_ALEN; i++) {
 +		hash += key[i];
 +		hash += (hash << 10);
 +		hash ^= (hash >> 6);
 +	}
 +
 +	hash += (hash << 3);
 +	hash ^= (hash >> 11);
 +	hash += (hash << 15);
 +
 +	return hash % size;
 +}
 +
 +/* insert interface to the list of interfaces of one originator, if it
 + * does not already exist in the list */
 +static void vis_data_insert_interface(const uint8_t *interface,
 +				      struct hlist_head *if_list,
 +				      bool primary)
 +{
 +	struct if_list_entry *entry;
 +	struct hlist_node *pos;
 +
 +	hlist_for_each_entry(entry, pos, if_list, list) {
 +		if (compare_orig(entry->addr, (void *)interface))
 +			return;
 +	}
 +
 +	/* its a new address, add it to the list */
 +	entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
 +	if (!entry)
 +		return;
 +	memcpy(entry->addr, interface, ETH_ALEN);
 +	entry->primary = primary;
 +	hlist_add_head(&entry->list, if_list);
 +}
 +
 +static ssize_t vis_data_read_prim_sec(char *buff, struct hlist_head *if_list)
 +{
 +	struct if_list_entry *entry;
 +	struct hlist_node *pos;
 +	char tmp_addr_str[ETH_STR_LEN];
 +	size_t len = 0;
 +
 +	hlist_for_each_entry(entry, pos, if_list, list) {
 +		if (entry->primary)
 +			len += sprintf(buff + len, "PRIMARY, ");
 +		else {
 +			addr_to_string(tmp_addr_str, entry->addr);
 +			len += sprintf(buff + len,  "SEC %s, ", tmp_addr_str);
 +		}
 +	}
 +
 +	return len;
 +}
 +
 +static size_t vis_data_count_prim_sec(struct hlist_head *if_list)
 +{
 +	struct if_list_entry *entry;
 +	struct hlist_node *pos;
 +	size_t count = 0;
 +
 +	hlist_for_each_entry(entry, pos, if_list, list) {
 +		if (entry->primary)
 +			count += 9;
 +		else
 +			count += 23;
 +	}
 +
 +	return count;
 +}
 +
 +/* read an entry  */
 +static ssize_t vis_data_read_entry(char *buff, struct vis_info_entry *entry,
 +				   uint8_t *src, bool primary)
 +{
 +	char to[18];
 +
 +	/* maximal length: max(4+17+2, 3+17+1+3+2) == 26 */
 +	addr_to_string(to, entry->dest);
 +	if (primary && entry->quality == 0)
 +		return sprintf(buff, "HNA %s, ", to);
 +	else if (compare_orig(entry->src, src))
 +		return sprintf(buff, "TQ %s %d, ", to, entry->quality);
 +
 +	return 0;
 +}
 +
 +int vis_seq_print_text(struct seq_file *seq, void *offset)
 +{
 +	HASHIT(hashit);
 +	HASHIT(hashit_count);
 +	struct vis_info *info;
 +	struct vis_packet *packet;
 +	struct vis_info_entry *entries;
 +	struct net_device *net_dev = (struct net_device *)seq->private;
 +	struct bat_priv *bat_priv = netdev_priv(net_dev);
 +	HLIST_HEAD(vis_if_list);
 +	struct if_list_entry *entry;
 +	struct hlist_node *pos, *n;
 +	int i;
 +	char tmp_addr_str[ETH_STR_LEN];
 +	unsigned long flags;
 +	int vis_server = atomic_read(&bat_priv->vis_mode);
 +	size_t buff_pos, buf_size;
 +	char *buff;
 +
 +	if ((!bat_priv->primary_if) ||
 +	    (vis_server == VIS_TYPE_CLIENT_UPDATE))
 +		return 0;
 +
 +	buf_size = 1;
 +	/* Estimate length */
 +	spin_lock_irqsave(&bat_priv->vis_hash_lock, flags);
 +	while (hash_iterate(bat_priv->vis_hash, &hashit_count)) {
 +		info = hashit_count.bucket->data;
 +		packet = (struct vis_packet *)info->skb_packet->data;
 +		entries = (struct vis_info_entry *)
 +			  ((char *)packet + sizeof(struct vis_packet));
 +
 +		for (i = 0; i < packet->entries; i++) {
 +			if (entries[i].quality == 0)
 +				continue;
 +			vis_data_insert_interface(entries[i].src, &vis_if_list,
 +				compare_orig(entries[i].src, packet->vis_orig));
 +		}
 +
 +		hlist_for_each_entry(entry, pos, &vis_if_list, list) {
 +			buf_size += 18 + 26 * packet->entries;
 +
 +			/* add primary/secondary records */
 +			if (compare_orig(entry->addr, packet->vis_orig))
 +				buf_size +=
 +					vis_data_count_prim_sec(&vis_if_list);
 +
 +			buf_size += 1;
 +		}
 +
 +		hlist_for_each_entry_safe(entry, pos, n, &vis_if_list, list) {
 +			hlist_del(&entry->list);
 +			kfree(entry);
 +		}
 +	}
 +
 +	buff = kmalloc(buf_size, GFP_ATOMIC);
 +	if (!buff) {
 +		spin_unlock_irqrestore(&bat_priv->vis_hash_lock, flags);
 +		return -ENOMEM;
 +	}
 +	buff[0] = '\0';
 +	buff_pos = 0;
 +
 +	while (hash_iterate(bat_priv->vis_hash, &hashit)) {
 +		info = hashit.bucket->data;
 +		packet = (struct vis_packet *)info->skb_packet->data;
 +		entries = (struct vis_info_entry *)
 +			  ((char *)packet + sizeof(struct vis_packet));
 +
 +		for (i = 0; i < packet->entries; i++) {
 +			if (entries[i].quality == 0)
 +				continue;
 +			vis_data_insert_interface(entries[i].src, &vis_if_list,
 +				compare_orig(entries[i].src, packet->vis_orig));
 +		}
 +
 +		hlist_for_each_entry(entry, pos, &vis_if_list, list) {
 +			addr_to_string(tmp_addr_str, entry->addr);
 +			buff_pos += sprintf(buff + buff_pos, "%s,",
 +					    tmp_addr_str);
 +
 +			for (i = 0; i < packet->entries; i++)
 +				buff_pos += vis_data_read_entry(buff + buff_pos,
 +								&entries[i],
 +								entry->addr,
 +								entry->primary);
 +
 +			/* add primary/secondary records */
 +			if (compare_orig(entry->addr, packet->vis_orig))
 +				buff_pos +=
 +					vis_data_read_prim_sec(buff + buff_pos,
 +							       &vis_if_list);
 +
 +			buff_pos += sprintf(buff + buff_pos, "\n");
 +		}
 +
 +		hlist_for_each_entry_safe(entry, pos, n, &vis_if_list, list) {
 +			hlist_del(&entry->list);
 +			kfree(entry);
 +		}
 +	}
 +
 +	spin_unlock_irqrestore(&bat_priv->vis_hash_lock, flags);
 +
 +	seq_printf(seq, "%s", buff);
 +	kfree(buff);
 +
 +	return 0;
 +}
 +
 +/* add the info packet to the send list, if it was not
 + * already linked in. */
 +static void send_list_add(struct bat_priv *bat_priv, struct vis_info *info)
 +{
 +	if (list_empty(&info->send_list)) {
 +		kref_get(&info->refcount);
 +		list_add_tail(&info->send_list, &bat_priv->vis_send_list);
 +	}
 +}
 +
 +/* delete the info packet from the send list, if it was
 + * linked in. */
 +static void send_list_del(struct vis_info *info)
 +{
 +	if (!list_empty(&info->send_list)) {
 +		list_del_init(&info->send_list);
 +		kref_put(&info->refcount, free_info);
 +	}
 +}
 +
 +/* tries to add one entry to the receive list. */
 +static void recv_list_add(struct bat_priv *bat_priv,
 +			  struct list_head *recv_list, char *mac)
 +{
 +	struct recvlist_node *entry;
 +	unsigned long flags;
 +
 +	entry = kmalloc(sizeof(struct recvlist_node), GFP_ATOMIC);
 +	if (!entry)
 +		return;
 +
 +	memcpy(entry->mac, mac, ETH_ALEN);
 +	spin_lock_irqsave(&bat_priv->vis_list_lock, flags);
 +	list_add_tail(&entry->list, recv_list);
 +	spin_unlock_irqrestore(&bat_priv->vis_list_lock, flags);
 +}
 +
 +/* returns 1 if this mac is in the recv_list */
 +static int recv_list_is_in(struct bat_priv *bat_priv,
 +			   struct list_head *recv_list, char *mac)
 +{
 +	struct recvlist_node *entry;
 +	unsigned long flags;
 +
 +	spin_lock_irqsave(&bat_priv->vis_list_lock, flags);
 +	list_for_each_entry(entry, recv_list, list) {
 +		if (memcmp(entry->mac, mac, ETH_ALEN) == 0) {
 +			spin_unlock_irqrestore(&bat_priv->vis_list_lock,
 +					       flags);
 +			return 1;
 +		}
 +	}
 +	spin_unlock_irqrestore(&bat_priv->vis_list_lock, flags);
 +	return 0;
 +}
 +
 +/* try to add the packet to the vis_hash. return NULL if invalid (e.g. too old,
 + * broken.. ).	vis hash must be locked outside.  is_new is set when the packet
 + * is newer than old entries in the hash. */
 +static struct vis_info *add_packet(struct bat_priv *bat_priv,
 +				   struct vis_packet *vis_packet,
 +				   int vis_info_len, int *is_new,
 +				   int make_broadcast)
 +{
 +	struct vis_info *info, *old_info;
 +	struct vis_packet *search_packet, *old_packet;
 +	struct vis_info search_elem;
 +	struct vis_packet *packet;
 +
 +	*is_new = 0;
 +	/* sanity check */
 +	if (!bat_priv->vis_hash)
 +		return NULL;
 +
 +	/* see if the packet is already in vis_hash */
 +	search_elem.skb_packet = dev_alloc_skb(sizeof(struct vis_packet));
 +	if (!search_elem.skb_packet)
 +		return NULL;
 +	search_packet = (struct vis_packet *)skb_put(search_elem.skb_packet,
 +						     sizeof(struct vis_packet));
 +
 +	memcpy(search_packet->vis_orig, vis_packet->vis_orig, ETH_ALEN);
 +	old_info = hash_find(bat_priv->vis_hash, &search_elem);
 +	kfree_skb(search_elem.skb_packet);
 +
 +	if (old_info != NULL) {
 +		old_packet = (struct vis_packet *)old_info->skb_packet->data;
 +		if (!seq_after(ntohl(vis_packet->seqno),
 +			       ntohl(old_packet->seqno))) {
 +			if (old_packet->seqno == vis_packet->seqno) {
 +				recv_list_add(bat_priv, &old_info->recv_list,
 +					      vis_packet->sender_orig);
 +				return old_info;
 +			} else {
 +				/* newer packet is already in hash. */
 +				return NULL;
 +			}
 +		}
 +		/* remove old entry */
 +		hash_remove(bat_priv->vis_hash, old_info);
 +		send_list_del(old_info);
 +		kref_put(&old_info->refcount, free_info);
 +	}
 +
 +	info = kmalloc(sizeof(struct vis_info), GFP_ATOMIC);
 +	if (!info)
 +		return NULL;
 +
 +	info->skb_packet = dev_alloc_skb(sizeof(struct vis_packet) +
 +					 vis_info_len + sizeof(struct ethhdr));
 +	if (!info->skb_packet) {
 +		kfree(info);
 +		return NULL;
 +	}
 +	skb_reserve(info->skb_packet, sizeof(struct ethhdr));
 +	packet = (struct vis_packet *)skb_put(info->skb_packet,
 +					      sizeof(struct vis_packet) +
 +					      vis_info_len);
 +
 +	kref_init(&info->refcount);
 +	INIT_LIST_HEAD(&info->send_list);
 +	INIT_LIST_HEAD(&info->recv_list);
 +	info->first_seen = jiffies;
 +	info->bat_priv = bat_priv;
 +	memcpy(packet, vis_packet, sizeof(struct vis_packet) + vis_info_len);
 +
 +	/* initialize and add new packet. */
 +	*is_new = 1;
 +
 +	/* Make it a broadcast packet, if required */
 +	if (make_broadcast)
 +		memcpy(packet->target_orig, broadcast_addr, ETH_ALEN);
 +
 +	/* repair if entries is longer than packet. */
 +	if (packet->entries * sizeof(struct vis_info_entry) > vis_info_len)
 +		packet->entries = vis_info_len / sizeof(struct vis_info_entry);
 +
 +	recv_list_add(bat_priv, &info->recv_list, packet->sender_orig);
 +
 +	/* try to add it */
 +	if (hash_add(bat_priv->vis_hash, info) < 0) {
 +		/* did not work (for some reason) */
 +		kref_put(&old_info->refcount, free_info);
 +		info = NULL;
 +	}
 +
 +	return info;
 +}
 +
 +/* handle the server sync packet, forward if needed. */
 +void receive_server_sync_packet(struct bat_priv *bat_priv,
 +				struct vis_packet *vis_packet,
 +				int vis_info_len)
 +{
 +	struct vis_info *info;
 +	int is_new, make_broadcast;
 +	unsigned long flags;
 +	int vis_server = atomic_read(&bat_priv->vis_mode);
 +
 +	make_broadcast = (vis_server == VIS_TYPE_SERVER_SYNC);
 +
 +	spin_lock_irqsave(&bat_priv->vis_hash_lock, flags);
 +	info = add_packet(bat_priv, vis_packet, vis_info_len,
 +			  &is_new, make_broadcast);
 +	if (!info)
 +		goto end;
 +
 +	/* only if we are server ourselves and packet is newer than the one in
 +	 * hash.*/
 +	if (vis_server == VIS_TYPE_SERVER_SYNC && is_new)
 +		send_list_add(bat_priv, info);
 +end:
 +	spin_unlock_irqrestore(&bat_priv->vis_hash_lock, flags);
 +}
 +
 +/* handle an incoming client update packet and schedule forward if needed. */
 +void receive_client_update_packet(struct bat_priv *bat_priv,
 +				  struct vis_packet *vis_packet,
 +				  int vis_info_len)
 +{
 +	struct vis_info *info;
 +	struct vis_packet *packet;
 +	int is_new;
 +	unsigned long flags;
 +	int vis_server = atomic_read(&bat_priv->vis_mode);
 +	int are_target = 0;
 +
 +	/* clients shall not broadcast. */
 +	if (is_bcast(vis_packet->target_orig))
 +		return;
 +
 +	/* Are we the target for this VIS packet? */
 +	if (vis_server == VIS_TYPE_SERVER_SYNC	&&
 +	    is_my_mac(vis_packet->target_orig))
 +		are_target = 1;
 +
 +	spin_lock_irqsave(&bat_priv->vis_hash_lock, flags);
 +	info = add_packet(bat_priv, vis_packet, vis_info_len,
 +			  &is_new, are_target);
 +
 +	if (!info)
 +		goto end;
 +	/* note that outdated packets will be dropped at this point. */
 +
 +	packet = (struct vis_packet *)info->skb_packet->data;
 +
 +	/* send only if we're the target server or ... */
 +	if (are_target && is_new) {
 +		packet->vis_type = VIS_TYPE_SERVER_SYNC;	/* upgrade! */
 +		send_list_add(bat_priv, info);
 +
 +		/* ... we're not the recipient (and thus need to forward). */
 +	} else if (!is_my_mac(packet->target_orig)) {
 +		send_list_add(bat_priv, info);
 +	}
 +
 +end:
 +	spin_unlock_irqrestore(&bat_priv->vis_hash_lock, flags);
 +}
 +
 +/* Walk the originators and find the VIS server with the best tq. Set the packet
 + * address to its address and return the best_tq.
 + *
 + * Must be called with the originator hash locked */
 +static int find_best_vis_server(struct bat_priv *bat_priv,
 +				struct vis_info *info)
 +{
 +	HASHIT(hashit);
 +	struct orig_node *orig_node;
 +	struct vis_packet *packet;
 +	int best_tq = -1;
 +
 +	packet = (struct vis_packet *)info->skb_packet->data;
 +
 +	while (hash_iterate(bat_priv->orig_hash, &hashit)) {
 +		orig_node = hashit.bucket->data;
 +		if ((orig_node) && (orig_node->router) &&
 +		    (orig_node->flags & VIS_SERVER) &&
 +		    (orig_node->router->tq_avg > best_tq)) {
 +			best_tq = orig_node->router->tq_avg;
 +			memcpy(packet->target_orig, orig_node->orig, ETH_ALEN);
 +		}
 +	}
 +	return best_tq;
 +}
 +
 +/* Return true if the vis packet is full. */
 +static bool vis_packet_full(struct vis_info *info)
 +{
 +	struct vis_packet *packet;
 +	packet = (struct vis_packet *)info->skb_packet->data;
 +
 +	if (MAX_VIS_PACKET_SIZE / sizeof(struct vis_info_entry)
 +		< packet->entries + 1)
 +		return true;
 +	return false;
 +}
 +
 +/* generates a packet of own vis data,
 + * returns 0 on success, -1 if no packet could be generated */
 +static int generate_vis_packet(struct bat_priv *bat_priv)
 +{
 +	HASHIT(hashit_local);
 +	HASHIT(hashit_global);
 +	struct orig_node *orig_node;
 +	struct vis_info *info = (struct vis_info *)bat_priv->my_vis_info;
 +	struct vis_packet *packet = (struct vis_packet *)info->skb_packet->data;
 +	struct vis_info_entry *entry;
 +	struct hna_local_entry *hna_local_entry;
 +	int best_tq = -1;
 +	unsigned long flags;
 +
 +	info->first_seen = jiffies;
 +	packet->vis_type = atomic_read(&bat_priv->vis_mode);
 +
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +	memcpy(packet->target_orig, broadcast_addr, ETH_ALEN);
 +	packet->ttl = TTL;
 +	packet->seqno = htonl(ntohl(packet->seqno) + 1);
 +	packet->entries = 0;
 +	skb_trim(info->skb_packet, sizeof(struct vis_packet));
 +
 +	if (packet->vis_type == VIS_TYPE_CLIENT_UPDATE) {
 +		best_tq = find_best_vis_server(bat_priv, info);
 +
 +		if (best_tq < 0) {
 +			spin_unlock_irqrestore(&bat_priv->orig_hash_lock,
 +					       flags);
 +			return -1;
 +		}
 +	}
 +
 +	while (hash_iterate(bat_priv->orig_hash, &hashit_global)) {
 +		orig_node = hashit_global.bucket->data;
 +
 +		if (!orig_node->router)
 +			continue;
 +
 +		if (!compare_orig(orig_node->router->addr, orig_node->orig))
 +			continue;
 +
 +		if (orig_node->router->if_incoming->if_status != IF_ACTIVE)
 +			continue;
 +
 +		if (orig_node->router->tq_avg < 1)
 +			continue;
 +
 +		/* fill one entry into buffer. */
 +		entry = (struct vis_info_entry *)
 +				skb_put(info->skb_packet, sizeof(*entry));
 +		memcpy(entry->src,
 +		       orig_node->router->if_incoming->net_dev->dev_addr,
 +		       ETH_ALEN);
 +		memcpy(entry->dest, orig_node->orig, ETH_ALEN);
 +		entry->quality = orig_node->router->tq_avg;
 +		packet->entries++;
 +
 +		if (vis_packet_full(info)) {
 +			spin_unlock_irqrestore(
 +					&bat_priv->orig_hash_lock, flags);
 +			return 0;
 +		}
 +	}
 +
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +	spin_lock_irqsave(&bat_priv->hna_lhash_lock, flags);
 +	while (hash_iterate(bat_priv->hna_local_hash, &hashit_local)) {
 +		hna_local_entry = hashit_local.bucket->data;
 +		entry = (struct vis_info_entry *)skb_put(info->skb_packet,
 +							 sizeof(*entry));
 +		memset(entry->src, 0, ETH_ALEN);
 +		memcpy(entry->dest, hna_local_entry->addr, ETH_ALEN);
 +		entry->quality = 0; /* 0 means HNA */
 +		packet->entries++;
 +
 +		if (vis_packet_full(info)) {
 +			spin_unlock_irqrestore(&bat_priv->hna_lhash_lock,
 +					       flags);
 +			return 0;
 +		}
 +	}
 +
 +	spin_unlock_irqrestore(&bat_priv->hna_lhash_lock, flags);
 +	return 0;
 +}
 +
 +/* free old vis packets. Must be called with this vis_hash_lock
 + * held */
 +static void purge_vis_packets(struct bat_priv *bat_priv)
 +{
 +	HASHIT(hashit);
 +	struct vis_info *info;
 +
 +	while (hash_iterate(bat_priv->vis_hash, &hashit)) {
 +		info = hashit.bucket->data;
 +
 +		/* never purge own data. */
 +		if (info == bat_priv->my_vis_info)
 +			continue;
 +
 +		if (time_after(jiffies,
 +			       info->first_seen + VIS_TIMEOUT * HZ)) {
 +			hash_remove_bucket(bat_priv->vis_hash, &hashit);
 +			send_list_del(info);
 +			kref_put(&info->refcount, free_info);
 +		}
 +	}
 +}
 +
 +static void broadcast_vis_packet(struct bat_priv *bat_priv,
 +				 struct vis_info *info)
 +{
 +	HASHIT(hashit);
 +	struct orig_node *orig_node;
 +	struct vis_packet *packet;
 +	struct sk_buff *skb;
 +	unsigned long flags;
 +	struct batman_if *batman_if;
 +	uint8_t dstaddr[ETH_ALEN];
 +
 +
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +	packet = (struct vis_packet *)info->skb_packet->data;
 +
 +	/* send to all routers in range. */
 +	while (hash_iterate(bat_priv->orig_hash, &hashit)) {
 +		orig_node = hashit.bucket->data;
 +
 +		/* if it's a vis server and reachable, send it. */
 +		if ((!orig_node) || (!orig_node->router))
 +			continue;
 +		if (!(orig_node->flags & VIS_SERVER))
 +			continue;
 +		/* don't send it if we already received the packet from
 +		 * this node. */
 +		if (recv_list_is_in(bat_priv, &info->recv_list,
 +							orig_node->orig))
 +			continue;
 +
 +		memcpy(packet->target_orig, orig_node->orig, ETH_ALEN);
 +		batman_if = orig_node->router->if_incoming;
 +		memcpy(dstaddr, orig_node->router->addr, ETH_ALEN);
 +		spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +		skb = skb_clone(info->skb_packet, GFP_ATOMIC);
 +		if (skb)
 +			send_skb_packet(skb, batman_if, dstaddr);
 +
 +		spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +
 +	}
 +
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +}
 +
 +static void unicast_vis_packet(struct bat_priv *bat_priv,
 +			       struct vis_info *info)
 +{
 +	struct orig_node *orig_node;
 +	struct sk_buff *skb;
 +	struct vis_packet *packet;
 +	unsigned long flags;
 +	struct batman_if *batman_if;
 +	uint8_t dstaddr[ETH_ALEN];
 +
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +	packet = (struct vis_packet *)info->skb_packet->data;
 +	orig_node = ((struct orig_node *)hash_find(bat_priv->orig_hash,
 +						   packet->target_orig));
 +
 +	if ((!orig_node) || (!orig_node->router))
 +		goto out;
 +
 +	/* don't lock while sending the packets ... we therefore
 +	 * copy the required data before sending */
 +	batman_if = orig_node->router->if_incoming;
 +	memcpy(dstaddr, orig_node->router->addr, ETH_ALEN);
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +	skb = skb_clone(info->skb_packet, GFP_ATOMIC);
 +	if (skb)
 +		send_skb_packet(skb, batman_if, dstaddr);
 +
 +	return;
 +
 +out:
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +}
 +
 +/* only send one vis packet. called from send_vis_packets() */
 +static void send_vis_packet(struct bat_priv *bat_priv, struct vis_info *info)
 +{
 +	struct vis_packet *packet;
 +
 +	packet = (struct vis_packet *)info->skb_packet->data;
 +	if (packet->ttl < 2) {
 +		pr_debug("Error - can't send vis packet: ttl exceeded\n");
 +		return;
 +	}
 +
 +	memcpy(packet->sender_orig, bat_priv->primary_if->net_dev->dev_addr,
 +	       ETH_ALEN);
 +	packet->ttl--;
 +
 +	if (is_bcast(packet->target_orig))
 +		broadcast_vis_packet(bat_priv, info);
 +	else
 +		unicast_vis_packet(bat_priv, info);
 +	packet->ttl++; /* restore TTL */
 +}
 +
 +/* called from timer; send (and maybe generate) vis packet. */
 +static void send_vis_packets(struct work_struct *work)
 +{
 +	struct delayed_work *delayed_work =
 +		container_of(work, struct delayed_work, work);
 +	struct bat_priv *bat_priv =
 +		container_of(delayed_work, struct bat_priv, vis_work);
 +	struct vis_info *info, *temp;
 +	unsigned long flags;
 +
 +	spin_lock_irqsave(&bat_priv->vis_hash_lock, flags);
 +	purge_vis_packets(bat_priv);
 +
 +	if (generate_vis_packet(bat_priv) == 0) {
 +		/* schedule if generation was successful */
 +		send_list_add(bat_priv, bat_priv->my_vis_info);
 +	}
 +
 +	list_for_each_entry_safe(info, temp, &bat_priv->vis_send_list,
 +				 send_list) {
 +
 +		kref_get(&info->refcount);
 +		spin_unlock_irqrestore(&bat_priv->vis_hash_lock, flags);
 +
 +		if (bat_priv->primary_if)
 +			send_vis_packet(bat_priv, info);
 +
 +		spin_lock_irqsave(&bat_priv->vis_hash_lock, flags);
 +		send_list_del(info);
 +		kref_put(&info->refcount, free_info);
 +	}
 +	spin_unlock_irqrestore(&bat_priv->vis_hash_lock, flags);
 +	start_vis_timer(bat_priv);
 +}
 +
 +/* init the vis server. this may only be called when if_list is already
 + * initialized (e.g. bat0 is initialized, interfaces have been added) */
 +int vis_init(struct bat_priv *bat_priv)
 +{
 +	struct vis_packet *packet;
 +	unsigned long flags;
 +
 +	if (bat_priv->vis_hash)
 +		return 1;
 +
 +	spin_lock_irqsave(&bat_priv->vis_hash_lock, flags);
 +
 +	bat_priv->vis_hash = hash_new(256, vis_info_cmp, vis_info_choose);
 +	if (!bat_priv->vis_hash) {
 +		pr_err("Can't initialize vis_hash\n");
 +		goto err;
 +	}
 +
 +	bat_priv->my_vis_info = kmalloc(MAX_VIS_PACKET_SIZE, GFP_ATOMIC);
 +	if (!bat_priv->my_vis_info) {
 +		pr_err("Can't initialize vis packet\n");
 +		goto err;
 +	}
 +
 +	bat_priv->my_vis_info->skb_packet = dev_alloc_skb(
 +						sizeof(struct vis_packet) +
 +						MAX_VIS_PACKET_SIZE +
 +						sizeof(struct ethhdr));
 +	if (!bat_priv->my_vis_info->skb_packet)
 +		goto free_info;
 +
 +	skb_reserve(bat_priv->my_vis_info->skb_packet, sizeof(struct ethhdr));
 +	packet = (struct vis_packet *)skb_put(
 +					bat_priv->my_vis_info->skb_packet,
 +					sizeof(struct vis_packet));
 +
 +	/* prefill the vis info */
 +	bat_priv->my_vis_info->first_seen = jiffies -
 +						msecs_to_jiffies(VIS_INTERVAL);
 +	INIT_LIST_HEAD(&bat_priv->my_vis_info->recv_list);
 +	INIT_LIST_HEAD(&bat_priv->my_vis_info->send_list);
 +	kref_init(&bat_priv->my_vis_info->refcount);
 +	bat_priv->my_vis_info->bat_priv = bat_priv;
 +	packet->version = COMPAT_VERSION;
 +	packet->packet_type = BAT_VIS;
 +	packet->ttl = TTL;
 +	packet->seqno = 0;
 +	packet->entries = 0;
 +
 +	INIT_LIST_HEAD(&bat_priv->vis_send_list);
 +
 +	if (hash_add(bat_priv->vis_hash, bat_priv->my_vis_info) < 0) {
 +		pr_err("Can't add own vis packet into hash\n");
 +		/* not in hash, need to remove it manually. */
 +		kref_put(&bat_priv->my_vis_info->refcount, free_info);
 +		goto err;
 +	}
 +
 +	spin_unlock_irqrestore(&bat_priv->vis_hash_lock, flags);
 +	start_vis_timer(bat_priv);
 +	return 1;
 +
 +free_info:
 +	kfree(bat_priv->my_vis_info);
 +	bat_priv->my_vis_info = NULL;
 +err:
 +	spin_unlock_irqrestore(&bat_priv->vis_hash_lock, flags);
 +	vis_quit(bat_priv);
 +	return 0;
 +}
 +
 +/* Decrease the reference count on a hash item info */
 +static void free_info_ref(void *data, void *arg)
 +{
 +	struct vis_info *info = data;
 +
 +	send_list_del(info);
 +	kref_put(&info->refcount, free_info);
 +}
 +
 +/* shutdown vis-server */
 +void vis_quit(struct bat_priv *bat_priv)
 +{
 +	unsigned long flags;
 +	if (!bat_priv->vis_hash)
 +		return;
 +
 +	cancel_delayed_work_sync(&bat_priv->vis_work);
 +
 +	spin_lock_irqsave(&bat_priv->vis_hash_lock, flags);
 +	/* properly remove, kill timers ... */
 +	hash_delete(bat_priv->vis_hash, free_info_ref, NULL);
 +	bat_priv->vis_hash = NULL;
 +	bat_priv->my_vis_info = NULL;
 +	spin_unlock_irqrestore(&bat_priv->vis_hash_lock, flags);
 +}
 +
 +/* schedule packets for (re)transmission */
 +static void start_vis_timer(struct bat_priv *bat_priv)
 +{
 +	INIT_DELAYED_WORK(&bat_priv->vis_work, send_vis_packets);
 +	queue_delayed_work(bat_event_workqueue, &bat_priv->vis_work,
 +			   msecs_to_jiffies(VIS_INTERVAL));
 +}
-- 
linux integration

    

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

[commits] linux integration; branch, linux, updated. v2.6.36-rc3-514-gb1c4725