1181e1daac
The batman-adv vis server has to a stack which stores all information about packets which should be send later. This stack is protected with a spinlock that is used to prevent concurrent write access to it. The send_vis_packets function has to take all elements from the stack and send them to other hosts over the primary interface. The send will be initiated without the lock which protects the stack. The implementation using list_for_each_entry_safe has the problem that it stores the next element as "safe ptr" to allow the deletion of the current element in the list. The list may be modified during the unlock/lock pair in the loop body which may make the safe pointer not pointing to correct next element. It is safer to remove and use the first element from the stack until no elements are available. This does not need reduntant information which would have to be validated each time the lock was removed. Reported-by: Russell Senior <russell@personaltelco.net> Signed-off-by: Sven Eckelmann <sven@narfation.org>
951 lines
25 KiB
C
951 lines
25 KiB
C
/*
|
|
* 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"
|
|
#include "originator.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 */
|
|
#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;
|
|
|
|
list_del_init(&info->send_list);
|
|
spin_lock_bh(&bat_priv->vis_list_lock);
|
|
list_for_each_entry_safe(entry, tmp, &info->recv_list, list) {
|
|
list_del(&entry->list);
|
|
kfree(entry);
|
|
}
|
|
|
|
spin_unlock_bh(&bat_priv->vis_list_lock);
|
|
kfree_skb(info->skb_packet);
|
|
kfree(info);
|
|
}
|
|
|
|
/* 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;
|
|
size_t len = 0;
|
|
|
|
hlist_for_each_entry(entry, pos, if_list, list) {
|
|
if (entry->primary)
|
|
len += sprintf(buff + len, "PRIMARY, ");
|
|
else
|
|
len += sprintf(buff + len, "SEC %pM, ", entry->addr);
|
|
}
|
|
|
|
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)
|
|
{
|
|
/* maximal length: max(4+17+2, 3+17+1+3+2) == 26 */
|
|
if (primary && entry->quality == 0)
|
|
return sprintf(buff, "HNA %pM, ", entry->dest);
|
|
else if (compare_orig(entry->src, src))
|
|
return sprintf(buff, "TQ %pM %d, ", entry->dest,
|
|
entry->quality);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int vis_seq_print_text(struct seq_file *seq, void *offset)
|
|
{
|
|
struct hlist_node *walk;
|
|
struct hlist_head *head;
|
|
struct element_t *bucket;
|
|
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);
|
|
struct hashtable_t *hash = bat_priv->vis_hash;
|
|
HLIST_HEAD(vis_if_list);
|
|
struct if_list_entry *entry;
|
|
struct hlist_node *pos, *n;
|
|
int i, j;
|
|
int vis_server = atomic_read(&bat_priv->vis_mode);
|
|
size_t buff_pos, buf_size;
|
|
char *buff;
|
|
int compare;
|
|
|
|
if ((!bat_priv->primary_if) ||
|
|
(vis_server == VIS_TYPE_CLIENT_UPDATE))
|
|
return 0;
|
|
|
|
buf_size = 1;
|
|
/* Estimate length */
|
|
spin_lock_bh(&bat_priv->vis_hash_lock);
|
|
for (i = 0; i < hash->size; i++) {
|
|
head = &hash->table[i];
|
|
|
|
hlist_for_each_entry(bucket, walk, head, hlist) {
|
|
info = bucket->data;
|
|
packet = (struct vis_packet *)info->skb_packet->data;
|
|
entries = (struct vis_info_entry *)
|
|
((char *)packet + sizeof(struct vis_packet));
|
|
|
|
for (j = 0; j < packet->entries; j++) {
|
|
if (entries[j].quality == 0)
|
|
continue;
|
|
compare =
|
|
compare_orig(entries[j].src, packet->vis_orig);
|
|
vis_data_insert_interface(entries[j].src,
|
|
&vis_if_list,
|
|
compare);
|
|
}
|
|
|
|
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_bh(&bat_priv->vis_hash_lock);
|
|
return -ENOMEM;
|
|
}
|
|
buff[0] = '\0';
|
|
buff_pos = 0;
|
|
|
|
for (i = 0; i < hash->size; i++) {
|
|
head = &hash->table[i];
|
|
|
|
hlist_for_each_entry(bucket, walk, head, hlist) {
|
|
info = bucket->data;
|
|
packet = (struct vis_packet *)info->skb_packet->data;
|
|
entries = (struct vis_info_entry *)
|
|
((char *)packet + sizeof(struct vis_packet));
|
|
|
|
for (j = 0; j < packet->entries; j++) {
|
|
if (entries[j].quality == 0)
|
|
continue;
|
|
compare =
|
|
compare_orig(entries[j].src, packet->vis_orig);
|
|
vis_data_insert_interface(entries[j].src,
|
|
&vis_if_list,
|
|
compare);
|
|
}
|
|
|
|
hlist_for_each_entry(entry, pos, &vis_if_list, list) {
|
|
buff_pos += sprintf(buff + buff_pos, "%pM,",
|
|
entry->addr);
|
|
|
|
for (j = 0; j < packet->entries; j++)
|
|
buff_pos += vis_data_read_entry(
|
|
buff + buff_pos,
|
|
&entries[j],
|
|
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_bh(&bat_priv->vis_hash_lock);
|
|
|
|
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;
|
|
|
|
entry = kmalloc(sizeof(struct recvlist_node), GFP_ATOMIC);
|
|
if (!entry)
|
|
return;
|
|
|
|
memcpy(entry->mac, mac, ETH_ALEN);
|
|
spin_lock_bh(&bat_priv->vis_list_lock);
|
|
list_add_tail(&entry->list, recv_list);
|
|
spin_unlock_bh(&bat_priv->vis_list_lock);
|
|
}
|
|
|
|
/* 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;
|
|
|
|
spin_lock_bh(&bat_priv->vis_list_lock);
|
|
list_for_each_entry(entry, recv_list, list) {
|
|
if (memcmp(entry->mac, mac, ETH_ALEN) == 0) {
|
|
spin_unlock_bh(&bat_priv->vis_list_lock);
|
|
return 1;
|
|
}
|
|
}
|
|
spin_unlock_bh(&bat_priv->vis_list_lock);
|
|
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;
|
|
int hash_added;
|
|
|
|
*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, vis_info_cmp, vis_info_choose,
|
|
&search_elem);
|
|
kfree_skb(search_elem.skb_packet);
|
|
|
|
if (old_info) {
|
|
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, vis_info_cmp, vis_info_choose,
|
|
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 */
|
|
hash_added = hash_add(bat_priv->vis_hash, vis_info_cmp, vis_info_choose,
|
|
info);
|
|
if (hash_added < 0) {
|
|
/* did not work (for some reason) */
|
|
kref_put(&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;
|
|
int vis_server = atomic_read(&bat_priv->vis_mode);
|
|
|
|
make_broadcast = (vis_server == VIS_TYPE_SERVER_SYNC);
|
|
|
|
spin_lock_bh(&bat_priv->vis_hash_lock);
|
|
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_bh(&bat_priv->vis_hash_lock);
|
|
}
|
|
|
|
/* 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;
|
|
int vis_server = atomic_read(&bat_priv->vis_mode);
|
|
int are_target = 0;
|
|
|
|
/* clients shall not broadcast. */
|
|
if (is_broadcast_ether_addr(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_bh(&bat_priv->vis_hash_lock);
|
|
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_bh(&bat_priv->vis_hash_lock);
|
|
}
|
|
|
|
/* 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)
|
|
{
|
|
struct hashtable_t *hash = bat_priv->orig_hash;
|
|
struct hlist_node *walk;
|
|
struct hlist_head *head;
|
|
struct element_t *bucket;
|
|
struct orig_node *orig_node;
|
|
struct vis_packet *packet;
|
|
int best_tq = -1, i;
|
|
|
|
packet = (struct vis_packet *)info->skb_packet->data;
|
|
|
|
for (i = 0; i < hash->size; i++) {
|
|
head = &hash->table[i];
|
|
|
|
hlist_for_each_entry(bucket, walk, head, hlist) {
|
|
orig_node = 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)
|
|
{
|
|
struct hashtable_t *hash = bat_priv->orig_hash;
|
|
struct hlist_node *walk;
|
|
struct hlist_head *head;
|
|
struct element_t *bucket;
|
|
struct orig_node *orig_node;
|
|
struct neigh_node *neigh_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, i;
|
|
|
|
info->first_seen = jiffies;
|
|
packet->vis_type = atomic_read(&bat_priv->vis_mode);
|
|
|
|
spin_lock_bh(&bat_priv->orig_hash_lock);
|
|
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_bh(&bat_priv->orig_hash_lock);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < hash->size; i++) {
|
|
head = &hash->table[i];
|
|
|
|
hlist_for_each_entry(bucket, walk, head, hlist) {
|
|
orig_node = bucket->data;
|
|
neigh_node = orig_node->router;
|
|
|
|
if (!neigh_node)
|
|
continue;
|
|
|
|
if (!compare_orig(neigh_node->addr, orig_node->orig))
|
|
continue;
|
|
|
|
if (neigh_node->if_incoming->if_status != IF_ACTIVE)
|
|
continue;
|
|
|
|
if (neigh_node->tq_avg < 1)
|
|
continue;
|
|
|
|
/* fill one entry into buffer. */
|
|
entry = (struct vis_info_entry *)
|
|
skb_put(info->skb_packet, sizeof(*entry));
|
|
memcpy(entry->src,
|
|
neigh_node->if_incoming->net_dev->dev_addr,
|
|
ETH_ALEN);
|
|
memcpy(entry->dest, orig_node->orig, ETH_ALEN);
|
|
entry->quality = neigh_node->tq_avg;
|
|
packet->entries++;
|
|
|
|
if (vis_packet_full(info)) {
|
|
spin_unlock_bh(&bat_priv->orig_hash_lock);
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
spin_unlock_bh(&bat_priv->orig_hash_lock);
|
|
|
|
hash = bat_priv->hna_local_hash;
|
|
|
|
spin_lock_bh(&bat_priv->hna_lhash_lock);
|
|
for (i = 0; i < hash->size; i++) {
|
|
head = &hash->table[i];
|
|
|
|
hlist_for_each_entry(bucket, walk, head, hlist) {
|
|
hna_local_entry = 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_bh(&bat_priv->hna_lhash_lock);
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
spin_unlock_bh(&bat_priv->hna_lhash_lock);
|
|
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)
|
|
{
|
|
int i;
|
|
struct hashtable_t *hash = bat_priv->vis_hash;
|
|
struct hlist_node *walk, *safe;
|
|
struct hlist_head *head;
|
|
struct element_t *bucket;
|
|
struct vis_info *info;
|
|
|
|
for (i = 0; i < hash->size; i++) {
|
|
head = &hash->table[i];
|
|
|
|
hlist_for_each_entry_safe(bucket, walk, safe, head, hlist) {
|
|
info = bucket->data;
|
|
|
|
/* never purge own data. */
|
|
if (info == bat_priv->my_vis_info)
|
|
continue;
|
|
|
|
if (time_after(jiffies,
|
|
info->first_seen + VIS_TIMEOUT * HZ)) {
|
|
hlist_del(walk);
|
|
kfree(bucket);
|
|
send_list_del(info);
|
|
kref_put(&info->refcount, free_info);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void broadcast_vis_packet(struct bat_priv *bat_priv,
|
|
struct vis_info *info)
|
|
{
|
|
struct hashtable_t *hash = bat_priv->orig_hash;
|
|
struct hlist_node *walk;
|
|
struct hlist_head *head;
|
|
struct element_t *bucket;
|
|
struct orig_node *orig_node;
|
|
struct vis_packet *packet;
|
|
struct sk_buff *skb;
|
|
struct batman_if *batman_if;
|
|
uint8_t dstaddr[ETH_ALEN];
|
|
int i;
|
|
|
|
|
|
spin_lock_bh(&bat_priv->orig_hash_lock);
|
|
packet = (struct vis_packet *)info->skb_packet->data;
|
|
|
|
/* send to all routers in range. */
|
|
for (i = 0; i < hash->size; i++) {
|
|
head = &hash->table[i];
|
|
|
|
hlist_for_each_entry(bucket, walk, head, hlist) {
|
|
orig_node = 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_bh(&bat_priv->orig_hash_lock);
|
|
|
|
skb = skb_clone(info->skb_packet, GFP_ATOMIC);
|
|
if (skb)
|
|
send_skb_packet(skb, batman_if, dstaddr);
|
|
|
|
spin_lock_bh(&bat_priv->orig_hash_lock);
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock_bh(&bat_priv->orig_hash_lock);
|
|
}
|
|
|
|
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;
|
|
struct batman_if *batman_if;
|
|
uint8_t dstaddr[ETH_ALEN];
|
|
|
|
spin_lock_bh(&bat_priv->orig_hash_lock);
|
|
packet = (struct vis_packet *)info->skb_packet->data;
|
|
orig_node = ((struct orig_node *)hash_find(bat_priv->orig_hash,
|
|
compare_orig, choose_orig,
|
|
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_bh(&bat_priv->orig_hash_lock);
|
|
|
|
skb = skb_clone(info->skb_packet, GFP_ATOMIC);
|
|
if (skb)
|
|
send_skb_packet(skb, batman_if, dstaddr);
|
|
|
|
return;
|
|
|
|
out:
|
|
spin_unlock_bh(&bat_priv->orig_hash_lock);
|
|
}
|
|
|
|
/* 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_broadcast_ether_addr(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;
|
|
|
|
spin_lock_bh(&bat_priv->vis_hash_lock);
|
|
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);
|
|
}
|
|
|
|
while (!list_empty(&bat_priv->vis_send_list)) {
|
|
info = list_first_entry(&bat_priv->vis_send_list,
|
|
typeof(*info), send_list);
|
|
|
|
kref_get(&info->refcount);
|
|
spin_unlock_bh(&bat_priv->vis_hash_lock);
|
|
|
|
if (bat_priv->primary_if)
|
|
send_vis_packet(bat_priv, info);
|
|
|
|
spin_lock_bh(&bat_priv->vis_hash_lock);
|
|
send_list_del(info);
|
|
kref_put(&info->refcount, free_info);
|
|
}
|
|
spin_unlock_bh(&bat_priv->vis_hash_lock);
|
|
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;
|
|
int hash_added;
|
|
|
|
if (bat_priv->vis_hash)
|
|
return 1;
|
|
|
|
spin_lock_bh(&bat_priv->vis_hash_lock);
|
|
|
|
bat_priv->vis_hash = hash_new(256);
|
|
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);
|
|
|
|
hash_added = hash_add(bat_priv->vis_hash, vis_info_cmp, vis_info_choose,
|
|
bat_priv->my_vis_info);
|
|
if (hash_added < 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_bh(&bat_priv->vis_hash_lock);
|
|
start_vis_timer(bat_priv);
|
|
return 1;
|
|
|
|
free_info:
|
|
kfree(bat_priv->my_vis_info);
|
|
bat_priv->my_vis_info = NULL;
|
|
err:
|
|
spin_unlock_bh(&bat_priv->vis_hash_lock);
|
|
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)
|
|
{
|
|
if (!bat_priv->vis_hash)
|
|
return;
|
|
|
|
cancel_delayed_work_sync(&bat_priv->vis_work);
|
|
|
|
spin_lock_bh(&bat_priv->vis_hash_lock);
|
|
/* 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_bh(&bat_priv->vis_hash_lock);
|
|
}
|
|
|
|
/* 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));
|
|
}
|