Merge branch 'batman-adv/next' of git://git.open-mesh.org/ecsv/linux-merge
This commit is contained in:
David S. Miller
commit
5bf74c91d7
|
|
@ -26,18 +26,18 @@
|
|||
#include "hard-interface.h"
|
||||
|
||||
/* calculate the size of the tt information for a given packet */
|
||||
static int tt_len(struct batman_packet *batman_packet)
|
||||
static int tt_len(const struct batman_packet *batman_packet)
|
||||
{
|
||||
return batman_packet->num_tt * ETH_ALEN;
|
||||
}
|
||||
|
||||
/* return true if new_packet can be aggregated with forw_packet */
|
||||
static bool can_aggregate_with(struct batman_packet *new_batman_packet,
|
||||
static bool can_aggregate_with(const struct batman_packet *new_batman_packet,
|
||||
int packet_len,
|
||||
unsigned long send_time,
|
||||
bool directlink,
|
||||
struct hard_iface *if_incoming,
|
||||
struct forw_packet *forw_packet)
|
||||
const struct hard_iface *if_incoming,
|
||||
const struct forw_packet *forw_packet)
|
||||
{
|
||||
struct batman_packet *batman_packet =
|
||||
(struct batman_packet *)forw_packet->skb->data;
|
||||
|
|
@ -97,8 +97,9 @@ static bool can_aggregate_with(struct batman_packet *new_batman_packet,
|
|||
}
|
||||
|
||||
/* create a new aggregated packet and add this packet to it */
|
||||
static void new_aggregated_packet(unsigned char *packet_buff, int packet_len,
|
||||
unsigned long send_time, bool direct_link,
|
||||
static void new_aggregated_packet(const unsigned char *packet_buff,
|
||||
int packet_len, unsigned long send_time,
|
||||
bool direct_link,
|
||||
struct hard_iface *if_incoming,
|
||||
int own_packet)
|
||||
{
|
||||
|
|
@ -118,7 +119,7 @@ static void new_aggregated_packet(unsigned char *packet_buff, int packet_len,
|
|||
}
|
||||
}
|
||||
|
||||
forw_packet_aggr = kmalloc(sizeof(struct forw_packet), GFP_ATOMIC);
|
||||
forw_packet_aggr = kmalloc(sizeof(*forw_packet_aggr), GFP_ATOMIC);
|
||||
if (!forw_packet_aggr) {
|
||||
if (!own_packet)
|
||||
atomic_inc(&bat_priv->batman_queue_left);
|
||||
|
|
@ -176,8 +177,7 @@ out:
|
|||
|
||||
/* aggregate a new packet into the existing aggregation */
|
||||
static void aggregate(struct forw_packet *forw_packet_aggr,
|
||||
unsigned char *packet_buff,
|
||||
int packet_len,
|
||||
const unsigned char *packet_buff, int packet_len,
|
||||
bool direct_link)
|
||||
{
|
||||
unsigned char *skb_buff;
|
||||
|
|
@ -253,8 +253,9 @@ void add_bat_packet_to_list(struct bat_priv *bat_priv,
|
|||
}
|
||||
|
||||
/* unpack the aggregated packets and process them one by one */
|
||||
void receive_aggr_bat_packet(struct ethhdr *ethhdr, unsigned char *packet_buff,
|
||||
int packet_len, struct hard_iface *if_incoming)
|
||||
void receive_aggr_bat_packet(const struct ethhdr *ethhdr,
|
||||
unsigned char *packet_buff, int packet_len,
|
||||
struct hard_iface *if_incoming)
|
||||
{
|
||||
struct batman_packet *batman_packet;
|
||||
int buff_pos = 0;
|
||||
|
|
|
|||
|
|
@ -37,7 +37,8 @@ void add_bat_packet_to_list(struct bat_priv *bat_priv,
|
|||
unsigned char *packet_buff, int packet_len,
|
||||
struct hard_iface *if_incoming, char own_packet,
|
||||
unsigned long send_time);
|
||||
void receive_aggr_bat_packet(struct ethhdr *ethhdr, unsigned char *packet_buff,
|
||||
int packet_len, struct hard_iface *if_incoming);
|
||||
void receive_aggr_bat_packet(const struct ethhdr *ethhdr,
|
||||
unsigned char *packet_buff, int packet_len,
|
||||
struct hard_iface *if_incoming);
|
||||
|
||||
#endif /* _NET_BATMAN_ADV_AGGREGATION_H_ */
|
||||
|
|
|
|||
|
|
@ -50,7 +50,8 @@ static void emit_log_char(struct debug_log *debug_log, char c)
|
|||
debug_log->log_start = debug_log->log_end - log_buff_len;
|
||||
}
|
||||
|
||||
static int fdebug_log(struct debug_log *debug_log, char *fmt, ...)
|
||||
__printf(2, 3)
|
||||
static int fdebug_log(struct debug_log *debug_log, const char *fmt, ...)
|
||||
{
|
||||
va_list args;
|
||||
static char debug_log_buf[256];
|
||||
|
|
@ -74,14 +75,14 @@ static int fdebug_log(struct debug_log *debug_log, char *fmt, ...)
|
|||
return 0;
|
||||
}
|
||||
|
||||
int debug_log(struct bat_priv *bat_priv, char *fmt, ...)
|
||||
int debug_log(struct bat_priv *bat_priv, const char *fmt, ...)
|
||||
{
|
||||
va_list args;
|
||||
char tmp_log_buf[256];
|
||||
|
||||
va_start(args, fmt);
|
||||
vscnprintf(tmp_log_buf, sizeof(tmp_log_buf), fmt, args);
|
||||
fdebug_log(bat_priv->debug_log, "[%10u] %s",
|
||||
fdebug_log(bat_priv->debug_log, "[%10lu] %s",
|
||||
(jiffies / HZ), tmp_log_buf);
|
||||
va_end(args);
|
||||
|
||||
|
|
@ -114,7 +115,7 @@ static ssize_t log_read(struct file *file, char __user *buf,
|
|||
!(debug_log->log_end - debug_log->log_start))
|
||||
return -EAGAIN;
|
||||
|
||||
if ((!buf) || (count < 0))
|
||||
if (!buf)
|
||||
return -EINVAL;
|
||||
|
||||
if (count == 0)
|
||||
|
|
@ -184,7 +185,7 @@ static int debug_log_setup(struct bat_priv *bat_priv)
|
|||
if (!bat_priv->debug_dir)
|
||||
goto err;
|
||||
|
||||
bat_priv->debug_log = kzalloc(sizeof(struct debug_log), GFP_ATOMIC);
|
||||
bat_priv->debug_log = kzalloc(sizeof(*bat_priv->debug_log), GFP_ATOMIC);
|
||||
if (!bat_priv->debug_log)
|
||||
goto err;
|
||||
|
||||
|
|
|
|||
|
|
@ -96,7 +96,7 @@ ssize_t show_##_name(struct kobject *kobj, struct attribute *attr, \
|
|||
|
||||
static int store_bool_attr(char *buff, size_t count,
|
||||
struct net_device *net_dev,
|
||||
char *attr_name, atomic_t *attr)
|
||||
const char *attr_name, atomic_t *attr)
|
||||
{
|
||||
int enabled = -1;
|
||||
|
||||
|
|
@ -138,16 +138,15 @@ static inline ssize_t __store_bool_attr(char *buff, size_t count,
|
|||
{
|
||||
int ret;
|
||||
|
||||
ret = store_bool_attr(buff, count, net_dev, (char *)attr->name,
|
||||
attr_store);
|
||||
ret = store_bool_attr(buff, count, net_dev, attr->name, attr_store);
|
||||
if (post_func && ret)
|
||||
post_func(net_dev);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int store_uint_attr(char *buff, size_t count,
|
||||
struct net_device *net_dev, char *attr_name,
|
||||
static int store_uint_attr(const char *buff, size_t count,
|
||||
struct net_device *net_dev, const char *attr_name,
|
||||
unsigned int min, unsigned int max, atomic_t *attr)
|
||||
{
|
||||
unsigned long uint_val;
|
||||
|
|
@ -183,15 +182,15 @@ static int store_uint_attr(char *buff, size_t count,
|
|||
return count;
|
||||
}
|
||||
|
||||
static inline ssize_t __store_uint_attr(char *buff, size_t count,
|
||||
static inline ssize_t __store_uint_attr(const char *buff, size_t count,
|
||||
int min, int max,
|
||||
void (*post_func)(struct net_device *),
|
||||
struct attribute *attr,
|
||||
const struct attribute *attr,
|
||||
atomic_t *attr_store, struct net_device *net_dev)
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = store_uint_attr(buff, count, net_dev, (char *)attr->name,
|
||||
ret = store_uint_attr(buff, count, net_dev, attr->name,
|
||||
min, max, attr_store);
|
||||
if (post_func && ret)
|
||||
post_func(net_dev);
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@
|
|||
|
||||
/* returns true if the corresponding bit in the given seq_bits indicates true
|
||||
* and curr_seqno is within range of last_seqno */
|
||||
uint8_t get_bit_status(unsigned long *seq_bits, uint32_t last_seqno,
|
||||
uint8_t get_bit_status(const unsigned long *seq_bits, uint32_t last_seqno,
|
||||
uint32_t curr_seqno)
|
||||
{
|
||||
int32_t diff, word_offset, word_num;
|
||||
|
|
@ -130,7 +130,7 @@ static void bit_reset_window(unsigned long *seq_bits)
|
|||
char bit_get_packet(void *priv, unsigned long *seq_bits,
|
||||
int32_t seq_num_diff, int8_t set_mark)
|
||||
{
|
||||
struct bat_priv *bat_priv = (struct bat_priv *)priv;
|
||||
struct bat_priv *bat_priv = priv;
|
||||
|
||||
/* sequence number is slightly older. We already got a sequence number
|
||||
* higher than this one, so we just mark it. */
|
||||
|
|
@ -190,7 +190,7 @@ char bit_get_packet(void *priv, unsigned long *seq_bits,
|
|||
/* count the hamming weight, how many good packets did we receive? just count
|
||||
* the 1's.
|
||||
*/
|
||||
int bit_packet_count(unsigned long *seq_bits)
|
||||
int bit_packet_count(const unsigned long *seq_bits)
|
||||
{
|
||||
int i, hamming = 0;
|
||||
|
||||
|
|
|
|||
|
|
@ -26,8 +26,8 @@
|
|||
|
||||
/* returns true if the corresponding bit in the given seq_bits indicates true
|
||||
* and curr_seqno is within range of last_seqno */
|
||||
uint8_t get_bit_status(unsigned long *seq_bits, uint32_t last_seqno,
|
||||
uint32_t curr_seqno);
|
||||
uint8_t get_bit_status(const unsigned long *seq_bits, uint32_t last_seqno,
|
||||
uint32_t curr_seqno);
|
||||
|
||||
/* turn corresponding bit on, so we can remember that we got the packet */
|
||||
void bit_mark(unsigned long *seq_bits, int32_t n);
|
||||
|
|
@ -39,6 +39,6 @@ char bit_get_packet(void *priv, unsigned long *seq_bits,
|
|||
int32_t seq_num_diff, int8_t set_mark);
|
||||
|
||||
/* count the hamming weight, how many good packets did we receive? */
|
||||
int bit_packet_count(unsigned long *seq_bits);
|
||||
int bit_packet_count(const unsigned long *seq_bits);
|
||||
|
||||
#endif /* _NET_BATMAN_ADV_BITARRAY_H_ */
|
||||
|
|
|
|||
|
|
@ -86,7 +86,7 @@ static void gw_select(struct bat_priv *bat_priv, struct gw_node *new_gw_node)
|
|||
if (new_gw_node && !atomic_inc_not_zero(&new_gw_node->refcount))
|
||||
new_gw_node = NULL;
|
||||
|
||||
curr_gw_node = bat_priv->curr_gw;
|
||||
curr_gw_node = rcu_dereference_protected(bat_priv->curr_gw, 1);
|
||||
rcu_assign_pointer(bat_priv->curr_gw, new_gw_node);
|
||||
|
||||
if (curr_gw_node)
|
||||
|
|
@ -273,11 +273,10 @@ static void gw_node_add(struct bat_priv *bat_priv,
|
|||
struct gw_node *gw_node;
|
||||
int down, up;
|
||||
|
||||
gw_node = kmalloc(sizeof(struct gw_node), GFP_ATOMIC);
|
||||
gw_node = kzalloc(sizeof(*gw_node), GFP_ATOMIC);
|
||||
if (!gw_node)
|
||||
return;
|
||||
|
||||
memset(gw_node, 0, sizeof(struct gw_node));
|
||||
INIT_HLIST_NODE(&gw_node->list);
|
||||
gw_node->orig_node = orig_node;
|
||||
atomic_set(&gw_node->refcount, 1);
|
||||
|
|
@ -394,8 +393,8 @@ void gw_node_purge(struct bat_priv *bat_priv)
|
|||
/**
|
||||
* fails if orig_node has no router
|
||||
*/
|
||||
static int _write_buffer_text(struct bat_priv *bat_priv,
|
||||
struct seq_file *seq, struct gw_node *gw_node)
|
||||
static int _write_buffer_text(struct bat_priv *bat_priv, struct seq_file *seq,
|
||||
const struct gw_node *gw_node)
|
||||
{
|
||||
struct gw_node *curr_gw;
|
||||
struct neigh_node *router;
|
||||
|
|
@ -509,7 +508,7 @@ int gw_is_target(struct bat_priv *bat_priv, struct sk_buff *skb)
|
|||
/* check for ip header */
|
||||
switch (ntohs(ethhdr->h_proto)) {
|
||||
case ETH_P_IP:
|
||||
if (!pskb_may_pull(skb, header_len + sizeof(struct iphdr)))
|
||||
if (!pskb_may_pull(skb, header_len + sizeof(*iphdr)))
|
||||
return 0;
|
||||
iphdr = (struct iphdr *)(skb->data + header_len);
|
||||
header_len += iphdr->ihl * 4;
|
||||
|
|
@ -520,10 +519,10 @@ int gw_is_target(struct bat_priv *bat_priv, struct sk_buff *skb)
|
|||
|
||||
break;
|
||||
case ETH_P_IPV6:
|
||||
if (!pskb_may_pull(skb, header_len + sizeof(struct ipv6hdr)))
|
||||
if (!pskb_may_pull(skb, header_len + sizeof(*ipv6hdr)))
|
||||
return 0;
|
||||
ipv6hdr = (struct ipv6hdr *)(skb->data + header_len);
|
||||
header_len += sizeof(struct ipv6hdr);
|
||||
header_len += sizeof(*ipv6hdr);
|
||||
|
||||
/* check for udp header */
|
||||
if (ipv6hdr->nexthdr != IPPROTO_UDP)
|
||||
|
|
@ -534,10 +533,10 @@ int gw_is_target(struct bat_priv *bat_priv, struct sk_buff *skb)
|
|||
return 0;
|
||||
}
|
||||
|
||||
if (!pskb_may_pull(skb, header_len + sizeof(struct udphdr)))
|
||||
if (!pskb_may_pull(skb, header_len + sizeof(*udphdr)))
|
||||
return 0;
|
||||
udphdr = (struct udphdr *)(skb->data + header_len);
|
||||
header_len += sizeof(struct udphdr);
|
||||
header_len += sizeof(*udphdr);
|
||||
|
||||
/* check for bootp port */
|
||||
if ((ntohs(ethhdr->h_proto) == ETH_P_IP) &&
|
||||
|
|
|
|||
|
|
@ -76,10 +76,11 @@ void gw_bandwidth_to_kbit(uint8_t gw_srv_class, int *down, int *up)
|
|||
}
|
||||
|
||||
static bool parse_gw_bandwidth(struct net_device *net_dev, char *buff,
|
||||
long *up, long *down)
|
||||
int *up, int *down)
|
||||
{
|
||||
int ret, multi = 1;
|
||||
char *slash_ptr, *tmp_ptr;
|
||||
long ldown, lup;
|
||||
|
||||
slash_ptr = strchr(buff, '/');
|
||||
if (slash_ptr)
|
||||
|
|
@ -96,7 +97,7 @@ static bool parse_gw_bandwidth(struct net_device *net_dev, char *buff,
|
|||
*tmp_ptr = '\0';
|
||||
}
|
||||
|
||||
ret = strict_strtoul(buff, 10, down);
|
||||
ret = strict_strtoul(buff, 10, &ldown);
|
||||
if (ret) {
|
||||
bat_err(net_dev,
|
||||
"Download speed of gateway mode invalid: %s\n",
|
||||
|
|
@ -104,7 +105,7 @@ static bool parse_gw_bandwidth(struct net_device *net_dev, char *buff,
|
|||
return false;
|
||||
}
|
||||
|
||||
*down *= multi;
|
||||
*down = ldown * multi;
|
||||
|
||||
/* we also got some upload info */
|
||||
if (slash_ptr) {
|
||||
|
|
@ -121,7 +122,7 @@ static bool parse_gw_bandwidth(struct net_device *net_dev, char *buff,
|
|||
*tmp_ptr = '\0';
|
||||
}
|
||||
|
||||
ret = strict_strtoul(slash_ptr + 1, 10, up);
|
||||
ret = strict_strtoul(slash_ptr + 1, 10, &lup);
|
||||
if (ret) {
|
||||
bat_err(net_dev,
|
||||
"Upload speed of gateway mode invalid: "
|
||||
|
|
@ -129,7 +130,7 @@ static bool parse_gw_bandwidth(struct net_device *net_dev, char *buff,
|
|||
return false;
|
||||
}
|
||||
|
||||
*up *= multi;
|
||||
*up = lup * multi;
|
||||
}
|
||||
|
||||
return true;
|
||||
|
|
@ -138,7 +139,8 @@ static bool parse_gw_bandwidth(struct net_device *net_dev, char *buff,
|
|||
ssize_t gw_bandwidth_set(struct net_device *net_dev, char *buff, size_t count)
|
||||
{
|
||||
struct bat_priv *bat_priv = netdev_priv(net_dev);
|
||||
long gw_bandwidth_tmp = 0, up = 0, down = 0;
|
||||
long gw_bandwidth_tmp = 0;
|
||||
int up = 0, down = 0;
|
||||
bool ret;
|
||||
|
||||
ret = parse_gw_bandwidth(net_dev, buff, &up, &down);
|
||||
|
|
@ -158,12 +160,11 @@ ssize_t gw_bandwidth_set(struct net_device *net_dev, char *buff, size_t count)
|
|||
* speeds, hence we need to calculate it back to show the number
|
||||
* that is going to be propagated
|
||||
**/
|
||||
gw_bandwidth_to_kbit((uint8_t)gw_bandwidth_tmp,
|
||||
(int *)&down, (int *)&up);
|
||||
gw_bandwidth_to_kbit((uint8_t)gw_bandwidth_tmp, &down, &up);
|
||||
|
||||
gw_deselect(bat_priv);
|
||||
bat_info(net_dev, "Changing gateway bandwidth from: '%i' to: '%ld' "
|
||||
"(propagating: %ld%s/%ld%s)\n",
|
||||
"(propagating: %d%s/%d%s)\n",
|
||||
atomic_read(&bat_priv->gw_bandwidth), gw_bandwidth_tmp,
|
||||
(down > 2048 ? down / 1024 : down),
|
||||
(down > 2048 ? "MBit" : "KBit"),
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ void hardif_free_rcu(struct rcu_head *rcu)
|
|||
kfree(hard_iface);
|
||||
}
|
||||
|
||||
struct hard_iface *hardif_get_by_netdev(struct net_device *net_dev)
|
||||
struct hard_iface *hardif_get_by_netdev(const struct net_device *net_dev)
|
||||
{
|
||||
struct hard_iface *hard_iface;
|
||||
|
||||
|
|
@ -64,7 +64,7 @@ out:
|
|||
return hard_iface;
|
||||
}
|
||||
|
||||
static int is_valid_iface(struct net_device *net_dev)
|
||||
static int is_valid_iface(const struct net_device *net_dev)
|
||||
{
|
||||
if (net_dev->flags & IFF_LOOPBACK)
|
||||
return 0;
|
||||
|
|
@ -86,7 +86,7 @@ static int is_valid_iface(struct net_device *net_dev)
|
|||
return 1;
|
||||
}
|
||||
|
||||
static struct hard_iface *hardif_get_active(struct net_device *soft_iface)
|
||||
static struct hard_iface *hardif_get_active(const struct net_device *soft_iface)
|
||||
{
|
||||
struct hard_iface *hard_iface;
|
||||
|
||||
|
|
@ -138,7 +138,7 @@ static void primary_if_select(struct bat_priv *bat_priv,
|
|||
if (new_hard_iface && !atomic_inc_not_zero(&new_hard_iface->refcount))
|
||||
new_hard_iface = NULL;
|
||||
|
||||
curr_hard_iface = bat_priv->primary_if;
|
||||
curr_hard_iface = rcu_dereference_protected(bat_priv->primary_if, 1);
|
||||
rcu_assign_pointer(bat_priv->primary_if, new_hard_iface);
|
||||
|
||||
if (curr_hard_iface)
|
||||
|
|
@ -160,7 +160,7 @@ static void primary_if_select(struct bat_priv *bat_priv,
|
|||
atomic_set(&bat_priv->tt_local_changed, 1);
|
||||
}
|
||||
|
||||
static bool hardif_is_iface_up(struct hard_iface *hard_iface)
|
||||
static bool hardif_is_iface_up(const struct hard_iface *hard_iface)
|
||||
{
|
||||
if (hard_iface->net_dev->flags & IFF_UP)
|
||||
return true;
|
||||
|
|
@ -176,9 +176,9 @@ static void update_mac_addresses(struct hard_iface *hard_iface)
|
|||
hard_iface->net_dev->dev_addr, ETH_ALEN);
|
||||
}
|
||||
|
||||
static void check_known_mac_addr(struct net_device *net_dev)
|
||||
static void check_known_mac_addr(const struct net_device *net_dev)
|
||||
{
|
||||
struct hard_iface *hard_iface;
|
||||
const struct hard_iface *hard_iface;
|
||||
|
||||
rcu_read_lock();
|
||||
list_for_each_entry_rcu(hard_iface, &hardif_list, list) {
|
||||
|
|
@ -204,8 +204,8 @@ static void check_known_mac_addr(struct net_device *net_dev)
|
|||
|
||||
int hardif_min_mtu(struct net_device *soft_iface)
|
||||
{
|
||||
struct bat_priv *bat_priv = netdev_priv(soft_iface);
|
||||
struct hard_iface *hard_iface;
|
||||
const struct bat_priv *bat_priv = netdev_priv(soft_iface);
|
||||
const struct hard_iface *hard_iface;
|
||||
/* allow big frames if all devices are capable to do so
|
||||
* (have MTU > 1500 + BAT_HEADER_LEN) */
|
||||
int min_mtu = ETH_DATA_LEN;
|
||||
|
|
@ -285,7 +285,8 @@ static void hardif_deactivate_interface(struct hard_iface *hard_iface)
|
|||
update_min_mtu(hard_iface->soft_iface);
|
||||
}
|
||||
|
||||
int hardif_enable_interface(struct hard_iface *hard_iface, char *iface_name)
|
||||
int hardif_enable_interface(struct hard_iface *hard_iface,
|
||||
const char *iface_name)
|
||||
{
|
||||
struct bat_priv *bat_priv;
|
||||
struct batman_packet *batman_packet;
|
||||
|
|
@ -458,7 +459,7 @@ static struct hard_iface *hardif_add_interface(struct net_device *net_dev)
|
|||
|
||||
dev_hold(net_dev);
|
||||
|
||||
hard_iface = kmalloc(sizeof(struct hard_iface), GFP_ATOMIC);
|
||||
hard_iface = kmalloc(sizeof(*hard_iface), GFP_ATOMIC);
|
||||
if (!hard_iface) {
|
||||
pr_err("Can't add interface (%s): out of memory\n",
|
||||
net_dev->name);
|
||||
|
|
@ -522,7 +523,7 @@ void hardif_remove_interfaces(void)
|
|||
static int hard_if_event(struct notifier_block *this,
|
||||
unsigned long event, void *ptr)
|
||||
{
|
||||
struct net_device *net_dev = (struct net_device *)ptr;
|
||||
struct net_device *net_dev = ptr;
|
||||
struct hard_iface *hard_iface = hardif_get_by_netdev(net_dev);
|
||||
struct hard_iface *primary_if = NULL;
|
||||
struct bat_priv *bat_priv;
|
||||
|
|
|
|||
|
|
@ -31,8 +31,10 @@
|
|||
|
||||
extern struct notifier_block hard_if_notifier;
|
||||
|
||||
struct hard_iface *hardif_get_by_netdev(struct net_device *net_dev);
|
||||
int hardif_enable_interface(struct hard_iface *hard_iface, char *iface_name);
|
||||
struct hard_iface*
|
||||
hardif_get_by_netdev(const struct net_device *net_dev);
|
||||
int hardif_enable_interface(struct hard_iface *hard_iface,
|
||||
const char *iface_name);
|
||||
void hardif_disable_interface(struct hard_iface *hard_iface);
|
||||
void hardif_remove_interfaces(void);
|
||||
int hardif_min_mtu(struct net_device *soft_iface);
|
||||
|
|
|
|||
|
|
@ -46,15 +46,16 @@ struct hashtable_t *hash_new(int size)
|
|||
{
|
||||
struct hashtable_t *hash;
|
||||
|
||||
hash = kmalloc(sizeof(struct hashtable_t), GFP_ATOMIC);
|
||||
hash = kmalloc(sizeof(*hash), GFP_ATOMIC);
|
||||
if (!hash)
|
||||
return NULL;
|
||||
|
||||
hash->table = kmalloc(sizeof(struct element_t *) * size, GFP_ATOMIC);
|
||||
hash->table = kmalloc(sizeof(*hash->table) * size, GFP_ATOMIC);
|
||||
if (!hash->table)
|
||||
goto free_hash;
|
||||
|
||||
hash->list_locks = kmalloc(sizeof(spinlock_t) * size, GFP_ATOMIC);
|
||||
hash->list_locks = kmalloc(sizeof(*hash->list_locks) * size,
|
||||
GFP_ATOMIC);
|
||||
if (!hash->list_locks)
|
||||
goto free_table;
|
||||
|
||||
|
|
|
|||
|
|
@ -28,12 +28,12 @@
|
|||
* compare 2 element datas for their keys,
|
||||
* return 0 if same and not 0 if not
|
||||
* same */
|
||||
typedef int (*hashdata_compare_cb)(struct hlist_node *, void *);
|
||||
typedef int (*hashdata_compare_cb)(const struct hlist_node *, const void *);
|
||||
|
||||
/* the hashfunction, should return an index
|
||||
* based on the key in the data of the first
|
||||
* argument and the size the second */
|
||||
typedef int (*hashdata_choose_cb)(void *, int);
|
||||
typedef int (*hashdata_choose_cb)(const void *, int);
|
||||
typedef void (*hashdata_free_cb)(struct hlist_node *, void *);
|
||||
|
||||
struct hashtable_t {
|
||||
|
|
@ -80,7 +80,7 @@ static inline void hash_delete(struct hashtable_t *hash,
|
|||
static inline int hash_add(struct hashtable_t *hash,
|
||||
hashdata_compare_cb compare,
|
||||
hashdata_choose_cb choose,
|
||||
void *data, struct hlist_node *data_node)
|
||||
const void *data, struct hlist_node *data_node)
|
||||
{
|
||||
int index;
|
||||
struct hlist_head *head;
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ static int bat_socket_open(struct inode *inode, struct file *file)
|
|||
|
||||
nonseekable_open(inode, file);
|
||||
|
||||
socket_client = kmalloc(sizeof(struct socket_client), GFP_KERNEL);
|
||||
socket_client = kmalloc(sizeof(*socket_client), GFP_KERNEL);
|
||||
|
||||
if (!socket_client)
|
||||
return -ENOMEM;
|
||||
|
|
@ -310,7 +310,7 @@ static void bat_socket_add_packet(struct socket_client *socket_client,
|
|||
{
|
||||
struct socket_packet *socket_packet;
|
||||
|
||||
socket_packet = kmalloc(sizeof(struct socket_packet), GFP_ATOMIC);
|
||||
socket_packet = kmalloc(sizeof(*socket_packet), GFP_ATOMIC);
|
||||
|
||||
if (!socket_packet)
|
||||
return;
|
||||
|
|
|
|||
|
|
@ -155,9 +155,9 @@ void dec_module_count(void)
|
|||
module_put(THIS_MODULE);
|
||||
}
|
||||
|
||||
int is_my_mac(uint8_t *addr)
|
||||
int is_my_mac(const uint8_t *addr)
|
||||
{
|
||||
struct hard_iface *hard_iface;
|
||||
const struct hard_iface *hard_iface;
|
||||
|
||||
rcu_read_lock();
|
||||
list_for_each_entry_rcu(hard_iface, &hardif_list, list) {
|
||||
|
|
|
|||
|
|
@ -133,10 +133,10 @@ int mesh_init(struct net_device *soft_iface);
|
|||
void mesh_free(struct net_device *soft_iface);
|
||||
void inc_module_count(void);
|
||||
void dec_module_count(void);
|
||||
int is_my_mac(uint8_t *addr);
|
||||
int is_my_mac(const uint8_t *addr);
|
||||
|
||||
#ifdef CONFIG_BATMAN_ADV_DEBUG
|
||||
int debug_log(struct bat_priv *bat_priv, char *fmt, ...);
|
||||
int debug_log(struct bat_priv *bat_priv, const char *fmt, ...) __printf(2, 3);
|
||||
|
||||
#define bat_dbg(type, bat_priv, fmt, arg...) \
|
||||
do { \
|
||||
|
|
@ -145,9 +145,10 @@ int debug_log(struct bat_priv *bat_priv, char *fmt, ...);
|
|||
} \
|
||||
while (0)
|
||||
#else /* !CONFIG_BATMAN_ADV_DEBUG */
|
||||
__printf(3, 4)
|
||||
static inline void bat_dbg(char type __always_unused,
|
||||
struct bat_priv *bat_priv __always_unused,
|
||||
char *fmt __always_unused, ...)
|
||||
const char *fmt __always_unused, ...)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
|
|
@ -172,11 +173,32 @@ static inline void bat_dbg(char type __always_unused,
|
|||
*
|
||||
* note: can't use compare_ether_addr() as it requires aligned memory
|
||||
*/
|
||||
static inline int compare_eth(void *data1, void *data2)
|
||||
|
||||
static inline int compare_eth(const void *data1, const void *data2)
|
||||
{
|
||||
return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0);
|
||||
}
|
||||
|
||||
|
||||
#define atomic_dec_not_zero(v) atomic_add_unless((v), -1, 0)
|
||||
|
||||
/* 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 */
|
||||
#define seq_before(x, y) ({typeof(x) _d1 = (x); \
|
||||
typeof(y) _d2 = (y); \
|
||||
typeof(x) _dummy = (_d1 - _d2); \
|
||||
(void) (&_d1 == &_d2); \
|
||||
_dummy > smallest_signed_int(_dummy); })
|
||||
#define seq_after(x, y) seq_before(y, x)
|
||||
|
||||
#endif /* _NET_BATMAN_ADV_MAIN_H_ */
|
||||
|
|
|
|||
|
|
@ -77,7 +77,7 @@ struct neigh_node *orig_node_get_router(struct orig_node *orig_node)
|
|||
|
||||
struct neigh_node *create_neighbor(struct orig_node *orig_node,
|
||||
struct orig_node *orig_neigh_node,
|
||||
uint8_t *neigh,
|
||||
const uint8_t *neigh,
|
||||
struct hard_iface *if_incoming)
|
||||
{
|
||||
struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
|
||||
|
|
@ -86,7 +86,7 @@ struct neigh_node *create_neighbor(struct orig_node *orig_node,
|
|||
bat_dbg(DBG_BATMAN, bat_priv,
|
||||
"Creating new last-hop neighbor of originator\n");
|
||||
|
||||
neigh_node = kzalloc(sizeof(struct neigh_node), GFP_ATOMIC);
|
||||
neigh_node = kzalloc(sizeof(*neigh_node), GFP_ATOMIC);
|
||||
if (!neigh_node)
|
||||
return NULL;
|
||||
|
||||
|
|
@ -183,7 +183,7 @@ void originator_free(struct bat_priv *bat_priv)
|
|||
|
||||
/* 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 *get_orig_node(struct bat_priv *bat_priv, const uint8_t *addr)
|
||||
{
|
||||
struct orig_node *orig_node;
|
||||
int size;
|
||||
|
|
@ -196,7 +196,7 @@ struct orig_node *get_orig_node(struct bat_priv *bat_priv, uint8_t *addr)
|
|||
bat_dbg(DBG_BATMAN, bat_priv,
|
||||
"Creating new originator: %pM\n", addr);
|
||||
|
||||
orig_node = kzalloc(sizeof(struct orig_node), GFP_ATOMIC);
|
||||
orig_node = kzalloc(sizeof(*orig_node), GFP_ATOMIC);
|
||||
if (!orig_node)
|
||||
return NULL;
|
||||
|
||||
|
|
@ -559,7 +559,7 @@ static int orig_node_del_if(struct orig_node *orig_node,
|
|||
memcpy(data_ptr, orig_node->bcast_own, del_if_num * chunk_size);
|
||||
|
||||
/* copy second part */
|
||||
memcpy(data_ptr + del_if_num * chunk_size,
|
||||
memcpy((char *)data_ptr + del_if_num * chunk_size,
|
||||
orig_node->bcast_own + ((del_if_num + 1) * chunk_size),
|
||||
(max_if_num - del_if_num) * chunk_size);
|
||||
|
||||
|
|
@ -579,7 +579,7 @@ free_bcast_own:
|
|||
memcpy(data_ptr, orig_node->bcast_own_sum,
|
||||
del_if_num * sizeof(uint8_t));
|
||||
|
||||
memcpy(data_ptr + del_if_num * sizeof(uint8_t),
|
||||
memcpy((char *)data_ptr + del_if_num * sizeof(uint8_t),
|
||||
orig_node->bcast_own_sum + ((del_if_num + 1) * sizeof(uint8_t)),
|
||||
(max_if_num - del_if_num) * sizeof(uint8_t));
|
||||
|
||||
|
|
|
|||
|
|
@ -28,10 +28,10 @@ int originator_init(struct bat_priv *bat_priv);
|
|||
void originator_free(struct bat_priv *bat_priv);
|
||||
void purge_orig_ref(struct bat_priv *bat_priv);
|
||||
void orig_node_free_ref(struct orig_node *orig_node);
|
||||
struct orig_node *get_orig_node(struct bat_priv *bat_priv, uint8_t *addr);
|
||||
struct orig_node *get_orig_node(struct bat_priv *bat_priv, const uint8_t *addr);
|
||||
struct neigh_node *create_neighbor(struct orig_node *orig_node,
|
||||
struct orig_node *orig_neigh_node,
|
||||
uint8_t *neigh,
|
||||
const uint8_t *neigh,
|
||||
struct hard_iface *if_incoming);
|
||||
void neigh_node_free_ref(struct neigh_node *neigh_node);
|
||||
struct neigh_node *orig_node_get_router(struct orig_node *orig_node);
|
||||
|
|
@ -41,18 +41,18 @@ int orig_hash_del_if(struct hard_iface *hard_iface, int max_if_num);
|
|||
|
||||
|
||||
/* returns 1 if they are the same originator */
|
||||
static inline int compare_orig(struct hlist_node *node, void *data2)
|
||||
static inline int compare_orig(const struct hlist_node *node, const void *data2)
|
||||
{
|
||||
void *data1 = container_of(node, struct orig_node, hash_entry);
|
||||
const void *data1 = container_of(node, struct orig_node, hash_entry);
|
||||
|
||||
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 */
|
||||
static inline int choose_orig(void *data, int32_t size)
|
||||
static inline int choose_orig(const void *data, int32_t size)
|
||||
{
|
||||
unsigned char *key = data;
|
||||
const unsigned char *key = data;
|
||||
uint32_t hash = 0;
|
||||
size_t i;
|
||||
|
||||
|
|
@ -70,7 +70,7 @@ static inline int choose_orig(void *data, int32_t size)
|
|||
}
|
||||
|
||||
static inline struct orig_node *orig_hash_find(struct bat_priv *bat_priv,
|
||||
void *data)
|
||||
const void *data)
|
||||
{
|
||||
struct hashtable_t *hash = bat_priv->orig_hash;
|
||||
struct hlist_head *head;
|
||||
|
|
|
|||
|
|
@ -28,9 +28,9 @@ void ring_buffer_set(uint8_t lq_recv[], uint8_t *lq_index, uint8_t value)
|
|||
*lq_index = (*lq_index + 1) % TQ_GLOBAL_WINDOW_SIZE;
|
||||
}
|
||||
|
||||
uint8_t ring_buffer_avg(uint8_t lq_recv[])
|
||||
uint8_t ring_buffer_avg(const uint8_t lq_recv[])
|
||||
{
|
||||
uint8_t *ptr;
|
||||
const uint8_t *ptr;
|
||||
uint16_t count = 0, i = 0, sum = 0;
|
||||
|
||||
ptr = lq_recv;
|
||||
|
|
|
|||
|
|
@ -23,6 +23,6 @@
|
|||
#define _NET_BATMAN_ADV_RING_BUFFER_H_
|
||||
|
||||
void ring_buffer_set(uint8_t lq_recv[], uint8_t *lq_index, uint8_t value);
|
||||
uint8_t ring_buffer_avg(uint8_t lq_recv[]);
|
||||
uint8_t ring_buffer_avg(const uint8_t lq_recv[]);
|
||||
|
||||
#endif /* _NET_BATMAN_ADV_RING_BUFFER_H_ */
|
||||
|
|
|
|||
|
|
@ -65,7 +65,7 @@ void slide_own_bcast_window(struct hard_iface *hard_iface)
|
|||
}
|
||||
|
||||
static void update_TT(struct bat_priv *bat_priv, struct orig_node *orig_node,
|
||||
unsigned char *tt_buff, int tt_buff_len)
|
||||
const unsigned char *tt_buff, int tt_buff_len)
|
||||
{
|
||||
if ((tt_buff_len != orig_node->tt_buff_len) ||
|
||||
((tt_buff_len > 0) &&
|
||||
|
|
@ -82,10 +82,9 @@ static void update_TT(struct bat_priv *bat_priv, struct orig_node *orig_node,
|
|||
}
|
||||
}
|
||||
|
||||
static void update_route(struct bat_priv *bat_priv,
|
||||
struct orig_node *orig_node,
|
||||
static void update_route(struct bat_priv *bat_priv, struct orig_node *orig_node,
|
||||
struct neigh_node *neigh_node,
|
||||
unsigned char *tt_buff, int tt_buff_len)
|
||||
const unsigned char *tt_buff, int tt_buff_len)
|
||||
{
|
||||
struct neigh_node *curr_router;
|
||||
|
||||
|
|
@ -109,7 +108,7 @@ static void update_route(struct bat_priv *bat_priv,
|
|||
tt_buff, tt_buff_len);
|
||||
|
||||
/* route changed */
|
||||
} else {
|
||||
} else if (neigh_node && curr_router) {
|
||||
bat_dbg(DBG_ROUTES, bat_priv,
|
||||
"Changing route towards: %pM "
|
||||
"(now via %pM - was via %pM)\n",
|
||||
|
|
@ -133,9 +132,8 @@ static void update_route(struct bat_priv *bat_priv,
|
|||
neigh_node_free_ref(curr_router);
|
||||
}
|
||||
|
||||
|
||||
void update_routes(struct bat_priv *bat_priv, struct orig_node *orig_node,
|
||||
struct neigh_node *neigh_node, unsigned char *tt_buff,
|
||||
struct neigh_node *neigh_node, const unsigned char *tt_buff,
|
||||
int tt_buff_len)
|
||||
{
|
||||
struct neigh_node *router = NULL;
|
||||
|
|
@ -348,9 +346,9 @@ out:
|
|||
}
|
||||
|
||||
/* copy primary address for bonding */
|
||||
static void bonding_save_primary(struct orig_node *orig_node,
|
||||
static void bonding_save_primary(const struct orig_node *orig_node,
|
||||
struct orig_node *orig_neigh_node,
|
||||
struct batman_packet *batman_packet)
|
||||
const struct batman_packet *batman_packet)
|
||||
{
|
||||
if (!(batman_packet->flags & PRIMARIES_FIRST_HOP))
|
||||
return;
|
||||
|
|
@ -358,12 +356,11 @@ static void bonding_save_primary(struct orig_node *orig_node,
|
|||
memcpy(orig_neigh_node->primary_addr, orig_node->orig, ETH_ALEN);
|
||||
}
|
||||
|
||||
static void update_orig(struct bat_priv *bat_priv,
|
||||
struct orig_node *orig_node,
|
||||
struct ethhdr *ethhdr,
|
||||
struct batman_packet *batman_packet,
|
||||
static void update_orig(struct bat_priv *bat_priv, struct orig_node *orig_node,
|
||||
const struct ethhdr *ethhdr,
|
||||
const struct batman_packet *batman_packet,
|
||||
struct hard_iface *if_incoming,
|
||||
unsigned char *tt_buff, int tt_buff_len,
|
||||
const unsigned char *tt_buff, int tt_buff_len,
|
||||
char is_duplicate)
|
||||
{
|
||||
struct neigh_node *neigh_node = NULL, *tmp_neigh_node = NULL;
|
||||
|
|
@ -531,9 +528,9 @@ static int window_protected(struct bat_priv *bat_priv,
|
|||
* -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 hard_iface *if_incoming)
|
||||
static char count_real_packets(const struct ethhdr *ethhdr,
|
||||
const struct batman_packet *batman_packet,
|
||||
const struct hard_iface *if_incoming)
|
||||
{
|
||||
struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
|
||||
struct orig_node *orig_node;
|
||||
|
|
@ -595,9 +592,9 @@ out:
|
|||
return ret;
|
||||
}
|
||||
|
||||
void receive_bat_packet(struct ethhdr *ethhdr,
|
||||
void receive_bat_packet(const struct ethhdr *ethhdr,
|
||||
struct batman_packet *batman_packet,
|
||||
unsigned char *tt_buff, int tt_buff_len,
|
||||
const unsigned char *tt_buff, int tt_buff_len,
|
||||
struct hard_iface *if_incoming)
|
||||
{
|
||||
struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
|
||||
|
|
@ -664,7 +661,7 @@ void receive_bat_packet(struct ethhdr *ethhdr,
|
|||
hard_iface->net_dev->dev_addr))
|
||||
is_my_oldorig = 1;
|
||||
|
||||
if (compare_eth(ethhdr->h_source, broadcast_addr))
|
||||
if (is_broadcast_ether_addr(ethhdr->h_source))
|
||||
is_broadcast = 1;
|
||||
}
|
||||
rcu_read_unlock();
|
||||
|
|
@ -1077,7 +1074,7 @@ out:
|
|||
* This method rotates the bonding list and increases the
|
||||
* returned router's refcount. */
|
||||
static struct neigh_node *find_bond_router(struct orig_node *primary_orig,
|
||||
struct hard_iface *recv_if)
|
||||
const struct hard_iface *recv_if)
|
||||
{
|
||||
struct neigh_node *tmp_neigh_node;
|
||||
struct neigh_node *router = NULL, *first_candidate = NULL;
|
||||
|
|
@ -1128,7 +1125,7 @@ out:
|
|||
*
|
||||
* Increases the returned router's refcount */
|
||||
static struct neigh_node *find_ifalter_router(struct orig_node *primary_orig,
|
||||
struct hard_iface *recv_if)
|
||||
const struct hard_iface *recv_if)
|
||||
{
|
||||
struct neigh_node *tmp_neigh_node;
|
||||
struct neigh_node *router = NULL, *first_candidate = NULL;
|
||||
|
|
@ -1176,7 +1173,7 @@ static struct neigh_node *find_ifalter_router(struct orig_node *primary_orig,
|
|||
* refcount.*/
|
||||
struct neigh_node *find_router(struct bat_priv *bat_priv,
|
||||
struct orig_node *orig_node,
|
||||
struct hard_iface *recv_if)
|
||||
const struct hard_iface *recv_if)
|
||||
{
|
||||
struct orig_node *primary_orig_node;
|
||||
struct orig_node *router_orig;
|
||||
|
|
@ -1240,6 +1237,9 @@ struct neigh_node *find_router(struct bat_priv *bat_priv,
|
|||
router = find_ifalter_router(primary_orig_node, recv_if);
|
||||
|
||||
return_router:
|
||||
if (router && router->if_incoming->if_status != IF_ACTIVE)
|
||||
goto err_unlock;
|
||||
|
||||
rcu_read_unlock();
|
||||
return router;
|
||||
err_unlock:
|
||||
|
|
@ -1357,7 +1357,7 @@ out:
|
|||
int recv_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if)
|
||||
{
|
||||
struct unicast_packet *unicast_packet;
|
||||
int hdr_size = sizeof(struct unicast_packet);
|
||||
int hdr_size = sizeof(*unicast_packet);
|
||||
|
||||
if (check_unicast_packet(skb, hdr_size) < 0)
|
||||
return NET_RX_DROP;
|
||||
|
|
@ -1377,7 +1377,7 @@ int recv_ucast_frag_packet(struct sk_buff *skb, struct hard_iface *recv_if)
|
|||
{
|
||||
struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
|
||||
struct unicast_frag_packet *unicast_packet;
|
||||
int hdr_size = sizeof(struct unicast_frag_packet);
|
||||
int hdr_size = sizeof(*unicast_packet);
|
||||
struct sk_buff *new_skb = NULL;
|
||||
int ret;
|
||||
|
||||
|
|
@ -1413,7 +1413,7 @@ int recv_bcast_packet(struct sk_buff *skb, struct hard_iface *recv_if)
|
|||
struct orig_node *orig_node = NULL;
|
||||
struct bcast_packet *bcast_packet;
|
||||
struct ethhdr *ethhdr;
|
||||
int hdr_size = sizeof(struct bcast_packet);
|
||||
int hdr_size = sizeof(*bcast_packet);
|
||||
int ret = NET_RX_DROP;
|
||||
int32_t seq_diff;
|
||||
|
||||
|
|
@ -1491,7 +1491,7 @@ int recv_vis_packet(struct sk_buff *skb, struct hard_iface *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);
|
||||
int hdr_size = sizeof(*vis_packet);
|
||||
|
||||
/* keep skb linear */
|
||||
if (skb_linearize(skb) < 0)
|
||||
|
|
|
|||
|
|
@ -23,12 +23,12 @@
|
|||
#define _NET_BATMAN_ADV_ROUTING_H_
|
||||
|
||||
void slide_own_bcast_window(struct hard_iface *hard_iface);
|
||||
void receive_bat_packet(struct ethhdr *ethhdr,
|
||||
struct batman_packet *batman_packet,
|
||||
unsigned char *tt_buff, int tt_buff_len,
|
||||
struct hard_iface *if_incoming);
|
||||
void receive_bat_packet(const struct ethhdr *ethhdr,
|
||||
struct batman_packet *batman_packet,
|
||||
const unsigned char *tt_buff, int tt_buff_len,
|
||||
struct hard_iface *if_incoming);
|
||||
void update_routes(struct bat_priv *bat_priv, struct orig_node *orig_node,
|
||||
struct neigh_node *neigh_node, unsigned char *tt_buff,
|
||||
struct neigh_node *neigh_node, const unsigned char *tt_buff,
|
||||
int tt_buff_len);
|
||||
int route_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if);
|
||||
int recv_icmp_packet(struct sk_buff *skb, struct hard_iface *recv_if);
|
||||
|
|
@ -39,7 +39,7 @@ int recv_vis_packet(struct sk_buff *skb, struct hard_iface *recv_if);
|
|||
int recv_bat_packet(struct sk_buff *skb, struct hard_iface *recv_if);
|
||||
struct neigh_node *find_router(struct bat_priv *bat_priv,
|
||||
struct orig_node *orig_node,
|
||||
struct hard_iface *recv_if);
|
||||
const struct hard_iface *recv_if);
|
||||
void bonding_candidate_del(struct orig_node *orig_node,
|
||||
struct neigh_node *neigh_node);
|
||||
|
||||
|
|
|
|||
|
|
@ -33,14 +33,14 @@
|
|||
static void send_outstanding_bcast_packet(struct work_struct *work);
|
||||
|
||||
/* apply hop penalty for a normal link */
|
||||
static uint8_t hop_penalty(const uint8_t tq, struct bat_priv *bat_priv)
|
||||
static uint8_t hop_penalty(uint8_t tq, const struct bat_priv *bat_priv)
|
||||
{
|
||||
int hop_penalty = atomic_read(&bat_priv->hop_penalty);
|
||||
return (tq * (TQ_MAX_VALUE - hop_penalty)) / (TQ_MAX_VALUE);
|
||||
}
|
||||
|
||||
/* when do we schedule our own packet to be sent */
|
||||
static unsigned long own_send_time(struct bat_priv *bat_priv)
|
||||
static unsigned long own_send_time(const struct bat_priv *bat_priv)
|
||||
{
|
||||
return jiffies + msecs_to_jiffies(
|
||||
atomic_read(&bat_priv->orig_interval) -
|
||||
|
|
@ -55,9 +55,8 @@ static unsigned long forward_send_time(void)
|
|||
|
||||
/* send out an already prepared packet to the given address via the
|
||||
* specified batman interface */
|
||||
int send_skb_packet(struct sk_buff *skb,
|
||||
struct hard_iface *hard_iface,
|
||||
uint8_t *dst_addr)
|
||||
int send_skb_packet(struct sk_buff *skb, struct hard_iface *hard_iface,
|
||||
const uint8_t *dst_addr)
|
||||
{
|
||||
struct ethhdr *ethhdr;
|
||||
|
||||
|
|
@ -74,7 +73,7 @@ int send_skb_packet(struct sk_buff *skb,
|
|||
}
|
||||
|
||||
/* push to the ethernet header. */
|
||||
if (my_skb_head_push(skb, sizeof(struct ethhdr)) < 0)
|
||||
if (my_skb_head_push(skb, sizeof(*ethhdr)) < 0)
|
||||
goto send_skb_err;
|
||||
|
||||
skb_reset_mac_header(skb);
|
||||
|
|
@ -145,7 +144,7 @@ static void send_packet_to_if(struct forw_packet *forw_packet,
|
|||
hard_iface->net_dev->name,
|
||||
hard_iface->net_dev->dev_addr);
|
||||
|
||||
buff_pos += sizeof(struct batman_packet) +
|
||||
buff_pos += sizeof(*batman_packet) +
|
||||
(batman_packet->num_tt * ETH_ALEN);
|
||||
packet_num++;
|
||||
batman_packet = (struct batman_packet *)
|
||||
|
|
@ -221,19 +220,18 @@ static void rebuild_batman_packet(struct bat_priv *bat_priv,
|
|||
unsigned char *new_buff;
|
||||
struct batman_packet *batman_packet;
|
||||
|
||||
new_len = sizeof(struct batman_packet) +
|
||||
(bat_priv->num_local_tt * ETH_ALEN);
|
||||
new_len = sizeof(*batman_packet) + (bat_priv->num_local_tt * ETH_ALEN);
|
||||
new_buff = kmalloc(new_len, GFP_ATOMIC);
|
||||
|
||||
/* keep old buffer if kmalloc should fail */
|
||||
if (new_buff) {
|
||||
memcpy(new_buff, hard_iface->packet_buff,
|
||||
sizeof(struct batman_packet));
|
||||
sizeof(*batman_packet));
|
||||
batman_packet = (struct batman_packet *)new_buff;
|
||||
|
||||
batman_packet->num_tt = tt_local_fill_buffer(bat_priv,
|
||||
new_buff + sizeof(struct batman_packet),
|
||||
new_len - sizeof(struct batman_packet));
|
||||
new_buff + sizeof(*batman_packet),
|
||||
new_len - sizeof(*batman_packet));
|
||||
|
||||
kfree(hard_iface->packet_buff);
|
||||
hard_iface->packet_buff = new_buff;
|
||||
|
|
@ -307,7 +305,7 @@ void schedule_own_packet(struct hard_iface *hard_iface)
|
|||
}
|
||||
|
||||
void schedule_forward_packet(struct orig_node *orig_node,
|
||||
struct ethhdr *ethhdr,
|
||||
const struct ethhdr *ethhdr,
|
||||
struct batman_packet *batman_packet,
|
||||
uint8_t directlink, int tt_buff_len,
|
||||
struct hard_iface *if_incoming)
|
||||
|
|
@ -369,7 +367,7 @@ void schedule_forward_packet(struct orig_node *orig_node,
|
|||
send_time = forward_send_time();
|
||||
add_bat_packet_to_list(bat_priv,
|
||||
(unsigned char *)batman_packet,
|
||||
sizeof(struct batman_packet) + tt_buff_len,
|
||||
sizeof(*batman_packet) + tt_buff_len,
|
||||
if_incoming, 0, send_time);
|
||||
}
|
||||
|
||||
|
|
@ -408,11 +406,13 @@ static void _add_bcast_packet_to_list(struct bat_priv *bat_priv,
|
|||
*
|
||||
* The skb is not consumed, so the caller should make sure that the
|
||||
* skb is freed. */
|
||||
int add_bcast_packet_to_list(struct bat_priv *bat_priv, struct sk_buff *skb)
|
||||
int add_bcast_packet_to_list(struct bat_priv *bat_priv,
|
||||
const struct sk_buff *skb)
|
||||
{
|
||||
struct hard_iface *primary_if = NULL;
|
||||
struct forw_packet *forw_packet;
|
||||
struct bcast_packet *bcast_packet;
|
||||
struct sk_buff *newskb;
|
||||
|
||||
if (!atomic_dec_not_zero(&bat_priv->bcast_queue_left)) {
|
||||
bat_dbg(DBG_BATMAN, bat_priv, "bcast packet queue full\n");
|
||||
|
|
@ -423,22 +423,22 @@ int add_bcast_packet_to_list(struct bat_priv *bat_priv, struct sk_buff *skb)
|
|||
if (!primary_if)
|
||||
goto out_and_inc;
|
||||
|
||||
forw_packet = kmalloc(sizeof(struct forw_packet), GFP_ATOMIC);
|
||||
forw_packet = kmalloc(sizeof(*forw_packet), GFP_ATOMIC);
|
||||
|
||||
if (!forw_packet)
|
||||
goto out_and_inc;
|
||||
|
||||
skb = skb_copy(skb, GFP_ATOMIC);
|
||||
if (!skb)
|
||||
newskb = skb_copy(skb, GFP_ATOMIC);
|
||||
if (!newskb)
|
||||
goto packet_free;
|
||||
|
||||
/* as we have a copy now, it is safe to decrease the TTL */
|
||||
bcast_packet = (struct bcast_packet *)skb->data;
|
||||
bcast_packet = (struct bcast_packet *)newskb->data;
|
||||
bcast_packet->ttl--;
|
||||
|
||||
skb_reset_mac_header(skb);
|
||||
skb_reset_mac_header(newskb);
|
||||
|
||||
forw_packet->skb = skb;
|
||||
forw_packet->skb = newskb;
|
||||
forw_packet->if_incoming = primary_if;
|
||||
|
||||
/* how often did we send the bcast packet ? */
|
||||
|
|
@ -537,7 +537,7 @@ out:
|
|||
}
|
||||
|
||||
void purge_outstanding_packets(struct bat_priv *bat_priv,
|
||||
struct hard_iface *hard_iface)
|
||||
const struct hard_iface *hard_iface)
|
||||
{
|
||||
struct forw_packet *forw_packet;
|
||||
struct hlist_node *tmp_node, *safe_tmp_node;
|
||||
|
|
|
|||
|
|
@ -22,18 +22,18 @@
|
|||
#ifndef _NET_BATMAN_ADV_SEND_H_
|
||||
#define _NET_BATMAN_ADV_SEND_H_
|
||||
|
||||
int send_skb_packet(struct sk_buff *skb,
|
||||
struct hard_iface *hard_iface,
|
||||
uint8_t *dst_addr);
|
||||
int send_skb_packet(struct sk_buff *skb, struct hard_iface *hard_iface,
|
||||
const uint8_t *dst_addr);
|
||||
void schedule_own_packet(struct hard_iface *hard_iface);
|
||||
void schedule_forward_packet(struct orig_node *orig_node,
|
||||
struct ethhdr *ethhdr,
|
||||
const struct ethhdr *ethhdr,
|
||||
struct batman_packet *batman_packet,
|
||||
uint8_t directlink, int tt_buff_len,
|
||||
struct hard_iface *if_outgoing);
|
||||
int add_bcast_packet_to_list(struct bat_priv *bat_priv, struct sk_buff *skb);
|
||||
int add_bcast_packet_to_list(struct bat_priv *bat_priv,
|
||||
const struct sk_buff *skb);
|
||||
void send_outstanding_bat_packet(struct work_struct *work);
|
||||
void purge_outstanding_packets(struct bat_priv *bat_priv,
|
||||
struct hard_iface *hard_iface);
|
||||
const struct hard_iface *hard_iface);
|
||||
|
||||
#endif /* _NET_BATMAN_ADV_SEND_H_ */
|
||||
|
|
|
|||
|
|
@ -123,8 +123,7 @@ static struct softif_neigh_vid *softif_neigh_vid_get(struct bat_priv *bat_priv,
|
|||
goto out;
|
||||
}
|
||||
|
||||
softif_neigh_vid = kzalloc(sizeof(struct softif_neigh_vid),
|
||||
GFP_ATOMIC);
|
||||
softif_neigh_vid = kzalloc(sizeof(*softif_neigh_vid), GFP_ATOMIC);
|
||||
if (!softif_neigh_vid)
|
||||
goto out;
|
||||
|
||||
|
|
@ -146,7 +145,7 @@ out:
|
|||
}
|
||||
|
||||
static struct softif_neigh *softif_neigh_get(struct bat_priv *bat_priv,
|
||||
uint8_t *addr, short vid)
|
||||
const uint8_t *addr, short vid)
|
||||
{
|
||||
struct softif_neigh_vid *softif_neigh_vid;
|
||||
struct softif_neigh *softif_neigh = NULL;
|
||||
|
|
@ -170,7 +169,7 @@ static struct softif_neigh *softif_neigh_get(struct bat_priv *bat_priv,
|
|||
goto unlock;
|
||||
}
|
||||
|
||||
softif_neigh = kzalloc(sizeof(struct softif_neigh), GFP_ATOMIC);
|
||||
softif_neigh = kzalloc(sizeof(*softif_neigh), GFP_ATOMIC);
|
||||
if (!softif_neigh)
|
||||
goto unlock;
|
||||
|
||||
|
|
@ -242,7 +241,8 @@ static void softif_neigh_vid_select(struct bat_priv *bat_priv,
|
|||
if (new_neigh && !atomic_inc_not_zero(&new_neigh->refcount))
|
||||
new_neigh = NULL;
|
||||
|
||||
curr_neigh = softif_neigh_vid->softif_neigh;
|
||||
curr_neigh = rcu_dereference_protected(softif_neigh_vid->softif_neigh,
|
||||
1);
|
||||
rcu_assign_pointer(softif_neigh_vid->softif_neigh, new_neigh);
|
||||
|
||||
if ((curr_neigh) && (!new_neigh))
|
||||
|
|
@ -611,7 +611,7 @@ int interface_tx(struct sk_buff *skb, struct net_device *soft_iface)
|
|||
if (!primary_if)
|
||||
goto dropped;
|
||||
|
||||
if (my_skb_head_push(skb, sizeof(struct bcast_packet)) < 0)
|
||||
if (my_skb_head_push(skb, sizeof(*bcast_packet)) < 0)
|
||||
goto dropped;
|
||||
|
||||
bcast_packet = (struct bcast_packet *)skb->data;
|
||||
|
|
@ -790,17 +790,16 @@ static void interface_setup(struct net_device *dev)
|
|||
|
||||
SET_ETHTOOL_OPS(dev, &bat_ethtool_ops);
|
||||
|
||||
memset(priv, 0, sizeof(struct bat_priv));
|
||||
memset(priv, 0, sizeof(*priv));
|
||||
}
|
||||
|
||||
struct net_device *softif_create(char *name)
|
||||
struct net_device *softif_create(const char *name)
|
||||
{
|
||||
struct net_device *soft_iface;
|
||||
struct bat_priv *bat_priv;
|
||||
int ret;
|
||||
|
||||
soft_iface = alloc_netdev(sizeof(struct bat_priv) , name,
|
||||
interface_setup);
|
||||
soft_iface = alloc_netdev(sizeof(*bat_priv), name, interface_setup);
|
||||
|
||||
if (!soft_iface) {
|
||||
pr_err("Unable to allocate the batman interface: %s\n", name);
|
||||
|
|
@ -872,7 +871,7 @@ void softif_destroy(struct net_device *soft_iface)
|
|||
unregister_netdevice(soft_iface);
|
||||
}
|
||||
|
||||
int softif_is_valid(struct net_device *net_dev)
|
||||
int softif_is_valid(const struct net_device *net_dev)
|
||||
{
|
||||
#ifdef HAVE_NET_DEVICE_OPS
|
||||
if (net_dev->netdev_ops->ndo_start_xmit == interface_tx)
|
||||
|
|
@ -924,4 +923,3 @@ static u32 bat_get_link(struct net_device *dev)
|
|||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -29,8 +29,8 @@ int interface_tx(struct sk_buff *skb, struct net_device *soft_iface);
|
|||
void interface_rx(struct net_device *soft_iface,
|
||||
struct sk_buff *skb, struct hard_iface *recv_if,
|
||||
int hdr_size);
|
||||
struct net_device *softif_create(char *name);
|
||||
struct net_device *softif_create(const char *name);
|
||||
void softif_destroy(struct net_device *soft_iface);
|
||||
int softif_is_valid(struct net_device *net_dev);
|
||||
int softif_is_valid(const struct net_device *net_dev);
|
||||
|
||||
#endif /* _NET_BATMAN_ADV_SOFT_INTERFACE_H_ */
|
||||
|
|
|
|||
|
|
@ -29,20 +29,22 @@
|
|||
static void tt_local_purge(struct work_struct *work);
|
||||
static void _tt_global_del_orig(struct bat_priv *bat_priv,
|
||||
struct tt_global_entry *tt_global_entry,
|
||||
char *message);
|
||||
const char *message);
|
||||
|
||||
/* returns 1 if they are the same mac addr */
|
||||
static int compare_ltt(struct hlist_node *node, void *data2)
|
||||
static int compare_ltt(const struct hlist_node *node, const void *data2)
|
||||
{
|
||||
void *data1 = container_of(node, struct tt_local_entry, hash_entry);
|
||||
const void *data1 = container_of(node, struct tt_local_entry,
|
||||
hash_entry);
|
||||
|
||||
return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0);
|
||||
}
|
||||
|
||||
/* returns 1 if they are the same mac addr */
|
||||
static int compare_gtt(struct hlist_node *node, void *data2)
|
||||
static int compare_gtt(const struct hlist_node *node, const void *data2)
|
||||
{
|
||||
void *data1 = container_of(node, struct tt_global_entry, hash_entry);
|
||||
const void *data1 = container_of(node, struct tt_global_entry,
|
||||
hash_entry);
|
||||
|
||||
return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0);
|
||||
}
|
||||
|
|
@ -54,7 +56,7 @@ static void tt_local_start_timer(struct bat_priv *bat_priv)
|
|||
}
|
||||
|
||||
static struct tt_local_entry *tt_local_hash_find(struct bat_priv *bat_priv,
|
||||
void *data)
|
||||
const void *data)
|
||||
{
|
||||
struct hashtable_t *hash = bat_priv->tt_local_hash;
|
||||
struct hlist_head *head;
|
||||
|
|
@ -82,7 +84,7 @@ static struct tt_local_entry *tt_local_hash_find(struct bat_priv *bat_priv,
|
|||
}
|
||||
|
||||
static struct tt_global_entry *tt_global_hash_find(struct bat_priv *bat_priv,
|
||||
void *data)
|
||||
const void *data)
|
||||
{
|
||||
struct hashtable_t *hash = bat_priv->tt_global_hash;
|
||||
struct hlist_head *head;
|
||||
|
|
@ -126,7 +128,7 @@ int tt_local_init(struct bat_priv *bat_priv)
|
|||
return 1;
|
||||
}
|
||||
|
||||
void tt_local_add(struct net_device *soft_iface, uint8_t *addr)
|
||||
void tt_local_add(struct net_device *soft_iface, const uint8_t *addr)
|
||||
{
|
||||
struct bat_priv *bat_priv = netdev_priv(soft_iface);
|
||||
struct tt_local_entry *tt_local_entry;
|
||||
|
|
@ -162,7 +164,7 @@ void tt_local_add(struct net_device *soft_iface, uint8_t *addr)
|
|||
bat_dbg(DBG_ROUTES, bat_priv,
|
||||
"Creating new local tt entry: %pM\n", addr);
|
||||
|
||||
tt_local_entry = kmalloc(sizeof(struct tt_local_entry), GFP_ATOMIC);
|
||||
tt_local_entry = kmalloc(sizeof(*tt_local_entry), GFP_ATOMIC);
|
||||
if (!tt_local_entry)
|
||||
return;
|
||||
|
||||
|
|
@ -311,7 +313,7 @@ out:
|
|||
|
||||
static void _tt_local_del(struct hlist_node *node, void *arg)
|
||||
{
|
||||
struct bat_priv *bat_priv = (struct bat_priv *)arg;
|
||||
struct bat_priv *bat_priv = arg;
|
||||
void *data = container_of(node, struct tt_local_entry, hash_entry);
|
||||
|
||||
kfree(data);
|
||||
|
|
@ -320,8 +322,8 @@ static void _tt_local_del(struct hlist_node *node, void *arg)
|
|||
}
|
||||
|
||||
static void tt_local_del(struct bat_priv *bat_priv,
|
||||
struct tt_local_entry *tt_local_entry,
|
||||
char *message)
|
||||
struct tt_local_entry *tt_local_entry,
|
||||
const char *message)
|
||||
{
|
||||
bat_dbg(DBG_ROUTES, bat_priv, "Deleting local tt entry (%pM): %s\n",
|
||||
tt_local_entry->addr, message);
|
||||
|
|
@ -332,7 +334,7 @@ static void tt_local_del(struct bat_priv *bat_priv,
|
|||
}
|
||||
|
||||
void tt_local_remove(struct bat_priv *bat_priv,
|
||||
uint8_t *addr, char *message)
|
||||
const uint8_t *addr, const char *message)
|
||||
{
|
||||
struct tt_local_entry *tt_local_entry;
|
||||
|
||||
|
|
@ -409,12 +411,12 @@ int tt_global_init(struct bat_priv *bat_priv)
|
|||
|
||||
void tt_global_add_orig(struct bat_priv *bat_priv,
|
||||
struct orig_node *orig_node,
|
||||
unsigned char *tt_buff, int tt_buff_len)
|
||||
const unsigned char *tt_buff, int tt_buff_len)
|
||||
{
|
||||
struct tt_global_entry *tt_global_entry;
|
||||
struct tt_local_entry *tt_local_entry;
|
||||
int tt_buff_count = 0;
|
||||
unsigned char *tt_ptr;
|
||||
const unsigned char *tt_ptr;
|
||||
|
||||
while ((tt_buff_count + 1) * ETH_ALEN <= tt_buff_len) {
|
||||
spin_lock_bh(&bat_priv->tt_ghash_lock);
|
||||
|
|
@ -425,9 +427,8 @@ void tt_global_add_orig(struct bat_priv *bat_priv,
|
|||
if (!tt_global_entry) {
|
||||
spin_unlock_bh(&bat_priv->tt_ghash_lock);
|
||||
|
||||
tt_global_entry =
|
||||
kmalloc(sizeof(struct tt_global_entry),
|
||||
GFP_ATOMIC);
|
||||
tt_global_entry = kmalloc(sizeof(*tt_global_entry),
|
||||
GFP_ATOMIC);
|
||||
|
||||
if (!tt_global_entry)
|
||||
break;
|
||||
|
|
@ -557,7 +558,7 @@ out:
|
|||
|
||||
static void _tt_global_del_orig(struct bat_priv *bat_priv,
|
||||
struct tt_global_entry *tt_global_entry,
|
||||
char *message)
|
||||
const char *message)
|
||||
{
|
||||
bat_dbg(DBG_ROUTES, bat_priv,
|
||||
"Deleting global tt entry %pM (via %pM): %s\n",
|
||||
|
|
@ -570,7 +571,7 @@ static void _tt_global_del_orig(struct bat_priv *bat_priv,
|
|||
}
|
||||
|
||||
void tt_global_del_orig(struct bat_priv *bat_priv,
|
||||
struct orig_node *orig_node, char *message)
|
||||
struct orig_node *orig_node, const char *message)
|
||||
{
|
||||
struct tt_global_entry *tt_global_entry;
|
||||
int tt_buff_count = 0;
|
||||
|
|
@ -616,7 +617,8 @@ void tt_global_free(struct bat_priv *bat_priv)
|
|||
bat_priv->tt_global_hash = NULL;
|
||||
}
|
||||
|
||||
struct orig_node *transtable_search(struct bat_priv *bat_priv, uint8_t *addr)
|
||||
struct orig_node *transtable_search(struct bat_priv *bat_priv,
|
||||
const uint8_t *addr)
|
||||
{
|
||||
struct tt_global_entry *tt_global_entry;
|
||||
struct orig_node *orig_node = NULL;
|
||||
|
|
|
|||
|
|
@ -23,21 +23,22 @@
|
|||
#define _NET_BATMAN_ADV_TRANSLATION_TABLE_H_
|
||||
|
||||
int tt_local_init(struct bat_priv *bat_priv);
|
||||
void tt_local_add(struct net_device *soft_iface, uint8_t *addr);
|
||||
void tt_local_add(struct net_device *soft_iface, const uint8_t *addr);
|
||||
void tt_local_remove(struct bat_priv *bat_priv,
|
||||
uint8_t *addr, char *message);
|
||||
const uint8_t *addr, const char *message);
|
||||
int tt_local_fill_buffer(struct bat_priv *bat_priv,
|
||||
unsigned char *buff, int buff_len);
|
||||
int tt_local_seq_print_text(struct seq_file *seq, void *offset);
|
||||
void tt_local_free(struct bat_priv *bat_priv);
|
||||
int tt_global_init(struct bat_priv *bat_priv);
|
||||
void tt_global_add_orig(struct bat_priv *bat_priv,
|
||||
struct orig_node *orig_node,
|
||||
unsigned char *tt_buff, int tt_buff_len);
|
||||
struct orig_node *orig_node,
|
||||
const unsigned char *tt_buff, int tt_buff_len);
|
||||
int tt_global_seq_print_text(struct seq_file *seq, void *offset);
|
||||
void tt_global_del_orig(struct bat_priv *bat_priv,
|
||||
struct orig_node *orig_node, char *message);
|
||||
struct orig_node *orig_node, const char *message);
|
||||
void tt_global_free(struct bat_priv *bat_priv);
|
||||
struct orig_node *transtable_search(struct bat_priv *bat_priv, uint8_t *addr);
|
||||
struct orig_node *transtable_search(struct bat_priv *bat_priv,
|
||||
const uint8_t *addr);
|
||||
|
||||
#endif /* _NET_BATMAN_ADV_TRANSLATION_TABLE_H_ */
|
||||
|
|
|
|||
|
|
@ -246,10 +246,10 @@ struct frag_packet_list_entry {
|
|||
};
|
||||
|
||||
struct vis_info {
|
||||
unsigned long first_seen;
|
||||
struct list_head recv_list;
|
||||
/* list of server-neighbors we received a vis-packet
|
||||
* from. we should not reply to them. */
|
||||
unsigned long first_seen;
|
||||
/* list of server-neighbors we received a vis-packet
|
||||
* from. we should not reply to them. */
|
||||
struct list_head recv_list;
|
||||
struct list_head send_list;
|
||||
struct kref refcount;
|
||||
struct hlist_node hash_entry;
|
||||
|
|
|
|||
|
|
@ -39,8 +39,8 @@ static struct sk_buff *frag_merge_packet(struct list_head *head,
|
|||
(struct unicast_frag_packet *)skb->data;
|
||||
struct sk_buff *tmp_skb;
|
||||
struct unicast_packet *unicast_packet;
|
||||
int hdr_len = sizeof(struct unicast_packet);
|
||||
int uni_diff = sizeof(struct unicast_frag_packet) - hdr_len;
|
||||
int hdr_len = sizeof(*unicast_packet);
|
||||
int uni_diff = sizeof(*up) - hdr_len;
|
||||
|
||||
/* set skb to the first part and tmp_skb to the second part */
|
||||
if (up->flags & UNI_FRAG_HEAD) {
|
||||
|
|
@ -53,7 +53,7 @@ static struct sk_buff *frag_merge_packet(struct list_head *head,
|
|||
if (skb_linearize(skb) < 0 || skb_linearize(tmp_skb) < 0)
|
||||
goto err;
|
||||
|
||||
skb_pull(tmp_skb, sizeof(struct unicast_frag_packet));
|
||||
skb_pull(tmp_skb, sizeof(*up));
|
||||
if (pskb_expand_head(skb, 0, tmp_skb->len, GFP_ATOMIC) < 0)
|
||||
goto err;
|
||||
|
||||
|
|
@ -99,8 +99,7 @@ static int frag_create_buffer(struct list_head *head)
|
|||
struct frag_packet_list_entry *tfp;
|
||||
|
||||
for (i = 0; i < FRAG_BUFFER_SIZE; i++) {
|
||||
tfp = kmalloc(sizeof(struct frag_packet_list_entry),
|
||||
GFP_ATOMIC);
|
||||
tfp = kmalloc(sizeof(*tfp), GFP_ATOMIC);
|
||||
if (!tfp) {
|
||||
frag_list_free(head);
|
||||
return -ENOMEM;
|
||||
|
|
@ -115,7 +114,7 @@ static int frag_create_buffer(struct list_head *head)
|
|||
}
|
||||
|
||||
static struct frag_packet_list_entry *frag_search_packet(struct list_head *head,
|
||||
struct unicast_frag_packet *up)
|
||||
const struct unicast_frag_packet *up)
|
||||
{
|
||||
struct frag_packet_list_entry *tfp;
|
||||
struct unicast_frag_packet *tmp_up = NULL;
|
||||
|
|
@ -218,14 +217,14 @@ out:
|
|||
}
|
||||
|
||||
int frag_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv,
|
||||
struct hard_iface *hard_iface, uint8_t dstaddr[])
|
||||
struct hard_iface *hard_iface, const uint8_t dstaddr[])
|
||||
{
|
||||
struct unicast_packet tmp_uc, *unicast_packet;
|
||||
struct hard_iface *primary_if;
|
||||
struct sk_buff *frag_skb;
|
||||
struct unicast_frag_packet *frag1, *frag2;
|
||||
int uc_hdr_len = sizeof(struct unicast_packet);
|
||||
int ucf_hdr_len = sizeof(struct unicast_frag_packet);
|
||||
int uc_hdr_len = sizeof(*unicast_packet);
|
||||
int ucf_hdr_len = sizeof(*frag1);
|
||||
int data_len = skb->len - uc_hdr_len;
|
||||
int large_tail = 0, ret = NET_RX_DROP;
|
||||
uint16_t seqno;
|
||||
|
|
@ -250,14 +249,14 @@ int frag_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv,
|
|||
frag1 = (struct unicast_frag_packet *)skb->data;
|
||||
frag2 = (struct unicast_frag_packet *)frag_skb->data;
|
||||
|
||||
memcpy(frag1, &tmp_uc, sizeof(struct unicast_packet));
|
||||
memcpy(frag1, &tmp_uc, sizeof(tmp_uc));
|
||||
|
||||
frag1->ttl--;
|
||||
frag1->version = COMPAT_VERSION;
|
||||
frag1->packet_type = BAT_UNICAST_FRAG;
|
||||
|
||||
memcpy(frag1->orig, primary_if->net_dev->dev_addr, ETH_ALEN);
|
||||
memcpy(frag2, frag1, sizeof(struct unicast_frag_packet));
|
||||
memcpy(frag2, frag1, sizeof(*frag2));
|
||||
|
||||
if (data_len & 1)
|
||||
large_tail = UNI_FRAG_LARGETAIL;
|
||||
|
|
@ -295,7 +294,7 @@ int unicast_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv)
|
|||
|
||||
/* get routing information */
|
||||
if (is_multicast_ether_addr(ethhdr->h_dest)) {
|
||||
orig_node = (struct orig_node *)gw_get_selected_orig(bat_priv);
|
||||
orig_node = gw_get_selected_orig(bat_priv);
|
||||
if (orig_node)
|
||||
goto find_router;
|
||||
}
|
||||
|
|
@ -314,10 +313,7 @@ find_router:
|
|||
if (!neigh_node)
|
||||
goto out;
|
||||
|
||||
if (neigh_node->if_incoming->if_status != IF_ACTIVE)
|
||||
goto out;
|
||||
|
||||
if (my_skb_head_push(skb, sizeof(struct unicast_packet)) < 0)
|
||||
if (my_skb_head_push(skb, sizeof(*unicast_packet)) < 0)
|
||||
goto out;
|
||||
|
||||
unicast_packet = (struct unicast_packet *)skb->data;
|
||||
|
|
@ -331,7 +327,7 @@ find_router:
|
|||
memcpy(unicast_packet->dest, orig_node->orig, ETH_ALEN);
|
||||
|
||||
if (atomic_read(&bat_priv->fragmentation) &&
|
||||
data_len + sizeof(struct unicast_packet) >
|
||||
data_len + sizeof(*unicast_packet) >
|
||||
neigh_node->if_incoming->net_dev->mtu) {
|
||||
/* send frag skb decreases ttl */
|
||||
unicast_packet->ttl++;
|
||||
|
|
|
|||
|
|
@ -32,11 +32,11 @@ int frag_reassemble_skb(struct sk_buff *skb, struct bat_priv *bat_priv,
|
|||
void frag_list_free(struct list_head *head);
|
||||
int unicast_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv);
|
||||
int frag_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv,
|
||||
struct hard_iface *hard_iface, uint8_t dstaddr[]);
|
||||
struct hard_iface *hard_iface, const uint8_t dstaddr[]);
|
||||
|
||||
static inline int frag_can_reassemble(struct sk_buff *skb, int mtu)
|
||||
static inline int frag_can_reassemble(const struct sk_buff *skb, int mtu)
|
||||
{
|
||||
struct unicast_frag_packet *unicast_packet;
|
||||
const struct unicast_frag_packet *unicast_packet;
|
||||
int uneven_correction = 0;
|
||||
unsigned int merged_size;
|
||||
|
||||
|
|
@ -49,7 +49,7 @@ static inline int frag_can_reassemble(struct sk_buff *skb, int mtu)
|
|||
uneven_correction = -1;
|
||||
}
|
||||
|
||||
merged_size = (skb->len - sizeof(struct unicast_frag_packet)) * 2;
|
||||
merged_size = (skb->len - sizeof(*unicast_packet)) * 2;
|
||||
merged_size += sizeof(struct unicast_packet) + uneven_correction;
|
||||
|
||||
return merged_size <= mtu;
|
||||
|
|
|
|||
|
|
@ -30,22 +30,6 @@
|
|||
|
||||
#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 */
|
||||
#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 */
|
||||
|
|
@ -68,10 +52,10 @@ static void free_info(struct kref *ref)
|
|||
}
|
||||
|
||||
/* Compare two vis packets, used by the hashing algorithm */
|
||||
static int vis_info_cmp(struct hlist_node *node, void *data2)
|
||||
static int vis_info_cmp(const struct hlist_node *node, const void *data2)
|
||||
{
|
||||
struct vis_info *d1, *d2;
|
||||
struct vis_packet *p1, *p2;
|
||||
const struct vis_info *d1, *d2;
|
||||
const struct vis_packet *p1, *p2;
|
||||
|
||||
d1 = container_of(node, struct vis_info, hash_entry);
|
||||
d2 = data2;
|
||||
|
|
@ -82,11 +66,11 @@ static int vis_info_cmp(struct hlist_node *node, void *data2)
|
|||
|
||||
/* 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)
|
||||
static int vis_info_choose(const void *data, int size)
|
||||
{
|
||||
struct vis_info *vis_info = data;
|
||||
struct vis_packet *packet;
|
||||
unsigned char *key;
|
||||
const struct vis_info *vis_info = data;
|
||||
const struct vis_packet *packet;
|
||||
const unsigned char *key;
|
||||
uint32_t hash = 0;
|
||||
size_t i;
|
||||
|
||||
|
|
@ -106,7 +90,7 @@ static int vis_info_choose(void *data, int size)
|
|||
}
|
||||
|
||||
static struct vis_info *vis_hash_find(struct bat_priv *bat_priv,
|
||||
void *data)
|
||||
const void *data)
|
||||
{
|
||||
struct hashtable_t *hash = bat_priv->vis_hash;
|
||||
struct hlist_head *head;
|
||||
|
|
@ -143,7 +127,7 @@ static void vis_data_insert_interface(const uint8_t *interface,
|
|||
struct hlist_node *pos;
|
||||
|
||||
hlist_for_each_entry(entry, pos, if_list, list) {
|
||||
if (compare_eth(entry->addr, (void *)interface))
|
||||
if (compare_eth(entry->addr, interface))
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -156,7 +140,8 @@ static void vis_data_insert_interface(const uint8_t *interface,
|
|||
hlist_add_head(&entry->list, if_list);
|
||||
}
|
||||
|
||||
static ssize_t vis_data_read_prim_sec(char *buff, struct hlist_head *if_list)
|
||||
static ssize_t vis_data_read_prim_sec(char *buff,
|
||||
const struct hlist_head *if_list)
|
||||
{
|
||||
struct if_list_entry *entry;
|
||||
struct hlist_node *pos;
|
||||
|
|
@ -189,8 +174,9 @@ static size_t vis_data_count_prim_sec(struct hlist_head *if_list)
|
|||
}
|
||||
|
||||
/* read an entry */
|
||||
static ssize_t vis_data_read_entry(char *buff, struct vis_info_entry *entry,
|
||||
uint8_t *src, bool primary)
|
||||
static ssize_t vis_data_read_entry(char *buff,
|
||||
const struct vis_info_entry *entry,
|
||||
const uint8_t *src, bool primary)
|
||||
{
|
||||
/* maximal length: max(4+17+2, 3+17+1+3+2) == 26 */
|
||||
if (primary && entry->quality == 0)
|
||||
|
|
@ -239,7 +225,7 @@ int vis_seq_print_text(struct seq_file *seq, void *offset)
|
|||
hlist_for_each_entry_rcu(info, node, head, hash_entry) {
|
||||
packet = (struct vis_packet *)info->skb_packet->data;
|
||||
entries = (struct vis_info_entry *)
|
||||
((char *)packet + sizeof(struct vis_packet));
|
||||
((char *)packet + sizeof(*packet));
|
||||
|
||||
for (j = 0; j < packet->entries; j++) {
|
||||
if (entries[j].quality == 0)
|
||||
|
|
@ -287,7 +273,7 @@ int vis_seq_print_text(struct seq_file *seq, void *offset)
|
|||
hlist_for_each_entry_rcu(info, node, head, hash_entry) {
|
||||
packet = (struct vis_packet *)info->skb_packet->data;
|
||||
entries = (struct vis_info_entry *)
|
||||
((char *)packet + sizeof(struct vis_packet));
|
||||
((char *)packet + sizeof(*packet));
|
||||
|
||||
for (j = 0; j < packet->entries; j++) {
|
||||
if (entries[j].quality == 0)
|
||||
|
|
@ -361,11 +347,11 @@ static void send_list_del(struct vis_info *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 list_head *recv_list, const char *mac)
|
||||
{
|
||||
struct recvlist_node *entry;
|
||||
|
||||
entry = kmalloc(sizeof(struct recvlist_node), GFP_ATOMIC);
|
||||
entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
|
||||
if (!entry)
|
||||
return;
|
||||
|
||||
|
|
@ -377,9 +363,9 @@ static void recv_list_add(struct bat_priv *bat_priv,
|
|||
|
||||
/* 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)
|
||||
const struct list_head *recv_list, const char *mac)
|
||||
{
|
||||
struct recvlist_node *entry;
|
||||
const struct recvlist_node *entry;
|
||||
|
||||
spin_lock_bh(&bat_priv->vis_list_lock);
|
||||
list_for_each_entry(entry, recv_list, list) {
|
||||
|
|
@ -412,11 +398,11 @@ static struct vis_info *add_packet(struct bat_priv *bat_priv,
|
|||
return NULL;
|
||||
|
||||
/* see if the packet is already in vis_hash */
|
||||
search_elem.skb_packet = dev_alloc_skb(sizeof(struct vis_packet));
|
||||
search_elem.skb_packet = dev_alloc_skb(sizeof(*search_packet));
|
||||
if (!search_elem.skb_packet)
|
||||
return NULL;
|
||||
search_packet = (struct vis_packet *)skb_put(search_elem.skb_packet,
|
||||
sizeof(struct vis_packet));
|
||||
sizeof(*search_packet));
|
||||
|
||||
memcpy(search_packet->vis_orig, vis_packet->vis_orig, ETH_ALEN);
|
||||
old_info = vis_hash_find(bat_priv, &search_elem);
|
||||
|
|
@ -442,27 +428,26 @@ static struct vis_info *add_packet(struct bat_priv *bat_priv,
|
|||
kref_put(&old_info->refcount, free_info);
|
||||
}
|
||||
|
||||
info = kmalloc(sizeof(struct vis_info), GFP_ATOMIC);
|
||||
info = kmalloc(sizeof(*info), GFP_ATOMIC);
|
||||
if (!info)
|
||||
return NULL;
|
||||
|
||||
info->skb_packet = dev_alloc_skb(sizeof(struct vis_packet) +
|
||||
vis_info_len + sizeof(struct ethhdr));
|
||||
info->skb_packet = dev_alloc_skb(sizeof(*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);
|
||||
packet = (struct vis_packet *)skb_put(info->skb_packet, sizeof(*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);
|
||||
memcpy(packet, vis_packet, sizeof(*packet) + vis_info_len);
|
||||
|
||||
/* initialize and add new packet. */
|
||||
*is_new = 1;
|
||||
|
|
@ -599,9 +584,9 @@ static int find_best_vis_server(struct bat_priv *bat_priv,
|
|||
}
|
||||
|
||||
/* Return true if the vis packet is full. */
|
||||
static bool vis_packet_full(struct vis_info *info)
|
||||
static bool vis_packet_full(const struct vis_info *info)
|
||||
{
|
||||
struct vis_packet *packet;
|
||||
const struct vis_packet *packet;
|
||||
packet = (struct vis_packet *)info->skb_packet->data;
|
||||
|
||||
if (MAX_VIS_PACKET_SIZE / sizeof(struct vis_info_entry)
|
||||
|
|
@ -619,7 +604,7 @@ static int generate_vis_packet(struct bat_priv *bat_priv)
|
|||
struct hlist_head *head;
|
||||
struct orig_node *orig_node;
|
||||
struct neigh_node *router;
|
||||
struct vis_info *info = (struct vis_info *)bat_priv->my_vis_info;
|
||||
struct vis_info *info = bat_priv->my_vis_info;
|
||||
struct vis_packet *packet = (struct vis_packet *)info->skb_packet->data;
|
||||
struct vis_info_entry *entry;
|
||||
struct tt_local_entry *tt_local_entry;
|
||||
|
|
@ -632,7 +617,7 @@ static int generate_vis_packet(struct bat_priv *bat_priv)
|
|||
packet->ttl = TTL;
|
||||
packet->seqno = htonl(ntohl(packet->seqno) + 1);
|
||||
packet->entries = 0;
|
||||
skb_trim(info->skb_packet, sizeof(struct vis_packet));
|
||||
skb_trim(info->skb_packet, sizeof(*packet));
|
||||
|
||||
if (packet->vis_type == VIS_TYPE_CLIENT_UPDATE) {
|
||||
best_tq = find_best_vis_server(bat_priv, info);
|
||||
|
|
@ -908,17 +893,15 @@ int vis_init(struct bat_priv *bat_priv)
|
|||
goto err;
|
||||
}
|
||||
|
||||
bat_priv->my_vis_info->skb_packet = dev_alloc_skb(
|
||||
sizeof(struct vis_packet) +
|
||||
MAX_VIS_PACKET_SIZE +
|
||||
sizeof(struct ethhdr));
|
||||
bat_priv->my_vis_info->skb_packet = dev_alloc_skb(sizeof(*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));
|
||||
packet = (struct vis_packet *)skb_put(bat_priv->my_vis_info->skb_packet,
|
||||
sizeof(*packet));
|
||||
|
||||
/* prefill the vis info */
|
||||
bat_priv->my_vis_info->first_seen = jiffies -
|
||||
|
|
|
|||
Loading…
Reference in a new issue