From patchwork Sun Apr 7 10:37:01 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?q?Linus_L=C3=BCssing?= X-Patchwork-Id: 17881 X-Patchwork-Delegate: sw@simonwunderlich.de Return-Path: X-Original-To: patchwork@open-mesh.org Delivered-To: patchwork@open-mesh.org Received: from open-mesh.org (localhost [IPv6:::1]) by open-mesh.org (Postfix) with ESMTP id EDE558266B; Sun, 7 Apr 2019 12:37:20 +0200 (CEST) Authentication-Results: open-mesh.org; dkim=fail reason="key not found in DNS" (0-bit key; unprotected) header.d=c0d3.blue header.i=@c0d3.blue header.b="ID16xdlR"; dkim-atps=neutral Received-SPF: None (mailfrom) identity=mailfrom; client-ip=138.201.29.205; helo=mail.aperture-lab.de; envelope-from=linus.luessing@c0d3.blue; receiver= Received: from mail.aperture-lab.de (mail.aperture-lab.de [138.201.29.205]) by open-mesh.org (Postfix) with ESMTPS id 1889082585 for ; Sun, 7 Apr 2019 12:37:18 +0200 (CEST) From: =?utf-8?q?Linus_L=C3=BCssing?= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=c0d3.blue; s=2018; t=1554633438; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=kBB/sxuo1/TGhH8ZSqksGv/4d3RrPUKxSCXdEdC0Afg=; b=ID16xdlRyltiowqAK5CnZaTSOqvp7GN7zTlDe0HoS2K8taXj03OZYpWE613hZnQz+BJMhw iiwnJOJWI4A9RdNYO3Zfu0Kau68GOGC2Wk3hdB94UkCOSAMs+Xy6ez+SX02bXgjQIwQmQg tDue7CH6/fhhORvswKcBNokv90JrlbUR8pNb+UyJ029LnU0tq5L+c312XCRDYlevnfuV3j e36gwpZ1zohHv36mQQgb9B3Y15dSgXoAIF2/2ckQGDDzUWBBEMoZWdn/SXZZ6YjZ2pl0gy D1Cp63cmeKfkzdwwsb8x2MYgLRb/+4jC8GwEzYEZWRZdkJK+pwQTjWeAS3sHjw== To: b.a.t.m.a.n@lists.open-mesh.org Date: Sun, 7 Apr 2019 12:37:01 +0200 Message-Id: <20190407103702.30435-2-linus.luessing@c0d3.blue> In-Reply-To: <20190407103702.30435-1-linus.luessing@c0d3.blue> References: <20190407103702.30435-1-linus.luessing@c0d3.blue> MIME-Version: 1.0 ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=c0d3.blue; s=2018; t=1554633438; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=kBB/sxuo1/TGhH8ZSqksGv/4d3RrPUKxSCXdEdC0Afg=; b=fXoWrQAoMN6k+mrpi6ekNI+X0tL2WOlBmM9dx5wVyhQYM2PUydOOk8Ez/ID0GAxYqnkFfe gE8xL3T7fYY0UhcR0rDHtrkBlSC10PXVWZVwjb1r5KNFgRti+Jq3sLzZrkGTpsBe6iggGg M3EmpW5GUhUj4GtbusXZzsF0KRVAq07pNnPPTsEoZOqI7MHHHu1KZ2ha/RMvheE+dJWSIN UF5WD7ZFohNy319QczI3rz7dhpdsd1GjTReI26lwqrEkwtvn+l0VGXoE8znFlBsgsWAhWH 4qQbtKTVuL/p2UdZqLSbod/PUMwbk3lYmAwSY98LPCO6apok8OSbJGbDGrSlVg== ARC-Seal: i=1; s=2018; d=c0d3.blue; t=1554633438; a=rsa-sha256; cv=none; b=RU9WtrkPTp9ICzTUsbnFeHlM+u86uLrbyytt6NEZg6AbqDz8ILLiBJP9lkA3fCiEnF82pS isK7xMyqNgyjnLed94KnrUpdIkcgc55t2ygDbi8QxAnwBHQ7ncJN3oTYvzlIfBQ7Pgq56y Op3nNsC2iYSfi4GK1ea4qPhu6r7N2yqZrV7dqFmOu3Ji9dRYEebwRCJ2+Gltta0/P6cXMd 7nD77GkxWpSGZS/LoafzcRmfAc4O6awxGj7nJoaUe9wbZHP3LZj18Ny+rSdCdcg/lfKM6T wF2v2BdaVrMmuVrNhkBMIeU7CbjvgJ7BTvosSVI+2chsLQfurOCk+Kf/V4UhMQ== ARC-Authentication-Results: i=1; ORIGINATING; auth=pass smtp.auth=linus.luessing@c0d3.blue smtp.mailfrom=linus.luessing@c0d3.blue Authentication-Results: ORIGINATING; auth=pass smtp.auth=linus.luessing@c0d3.blue smtp.mailfrom=linus.luessing@c0d3.blue Subject: [B.A.T.M.A.N.] [PATCH v3 1/2] batman-adv: split DAT cache into DAT cache and DAT DHT X-BeenThere: b.a.t.m.a.n@lists.open-mesh.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: The list for a Better Approach To Mobile Ad-hoc Networking List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: The list for a Better Approach To Mobile Ad-hoc Networking Errors-To: b.a.t.m.a.n-bounces@lists.open-mesh.org Sender: "B.A.T.M.A.N" Similar to the translation table split the (mostly) locally maintained DAT cache and foreignly maintained DAT DHT concepts into two separate tables. This eases the monitoring and debugging regarding the origin of DAT entries. And allows to apply differing properties to entries in the DAT cache and DAT DHT in the future. Signed-off-by: Linus Lüssing --- include/uapi/linux/batadv_packet.h | 4 +- include/uapi/linux/batman_adv.h | 5 + net/batman-adv/distributed-arp-table.c | 367 ++++++++++++++++++------- net/batman-adv/distributed-arp-table.h | 13 +- net/batman-adv/netlink.c | 6 + net/batman-adv/routing.c | 8 +- net/batman-adv/types.h | 7 +- 7 files changed, 309 insertions(+), 101 deletions(-) diff --git a/include/uapi/linux/batadv_packet.h b/include/uapi/linux/batadv_packet.h index 4ebc2135..b997c295 100644 --- a/include/uapi/linux/batadv_packet.h +++ b/include/uapi/linux/batadv_packet.h @@ -58,13 +58,15 @@ enum batadv_packettype { * @BATADV_P_DATA: user payload * @BATADV_P_DAT_DHT_GET: DHT request message * @BATADV_P_DAT_DHT_PUT: DHT store message - * @BATADV_P_DAT_CACHE_REPLY: ARP reply generated by DAT + * @BATADV_P_DAT_CACHE_REPLY: deprecated: use BATADV_P_DAT_DHT_REPLY instead + * @BATADV_P_DAT_DHT_REPLY: ARP reply generated by DAT */ enum batadv_subtype { BATADV_P_DATA = 0x01, BATADV_P_DAT_DHT_GET = 0x02, BATADV_P_DAT_DHT_PUT = 0x03, BATADV_P_DAT_CACHE_REPLY = 0x04, + BATADV_P_DAT_DHT_REPLY = 0x04, }; /* this file is included by batctl which needs these defines */ diff --git a/include/uapi/linux/batman_adv.h b/include/uapi/linux/batman_adv.h index 67f46367..e4bcc234 100644 --- a/include/uapi/linux/batman_adv.h +++ b/include/uapi/linux/batman_adv.h @@ -612,6 +612,11 @@ enum batadv_nl_commands { */ BATADV_CMD_SET_VLAN, + /** + * @BATADV_CMD_GET_DAT_DHT: Query list of DAT DHT entries + */ + BATADV_CMD_GET_DAT_DHT, + /* add new commands above here */ /** diff --git a/net/batman-adv/distributed-arp-table.c b/net/batman-adv/distributed-arp-table.c index b0af3a11..97444342 100644 --- a/net/batman-adv/distributed-arp-table.c +++ b/net/batman-adv/distributed-arp-table.c @@ -144,17 +144,17 @@ static bool batadv_dat_to_purge(struct batadv_dat_entry *dat_entry) } /** - * __batadv_dat_purge() - delete entries from the DAT local storage - * @bat_priv: the bat priv with all the soft interface information + * __batadv_dat_purge() - delete entries from a DAT hash table + * @hash: the hash table to delete from * @to_purge: function in charge to decide whether an entry has to be purged or * not. This function takes the dat_entry as argument and has to * returns a boolean value: true is the entry has to be deleted, * false otherwise * - * Loops over each entry in the DAT local storage and deletes it if and only if + * Loops over each entry in a DAT hash table and deletes it if and only if * the to_purge function passed as argument returns true. */ -static void __batadv_dat_purge(struct batadv_priv *bat_priv, +static void __batadv_dat_purge(struct batadv_hashtable *hash, bool (*to_purge)(struct batadv_dat_entry *)) { spinlock_t *list_lock; /* protects write access to the hash lists */ @@ -163,12 +163,12 @@ static void __batadv_dat_purge(struct batadv_priv *bat_priv, struct hlist_head *head; u32 i; - if (!bat_priv->dat.hash) + if (!hash) return; - for (i = 0; i < bat_priv->dat.hash->size; i++) { - head = &bat_priv->dat.hash->table[i]; - list_lock = &bat_priv->dat.hash->list_locks[i]; + for (i = 0; i < hash->size; i++) { + head = &hash->table[i]; + list_lock = &hash->list_locks[i]; spin_lock_bh(list_lock); hlist_for_each_entry_safe(dat_entry, node_tmp, head, @@ -201,7 +201,8 @@ static void batadv_dat_purge(struct work_struct *work) priv_dat = container_of(delayed_work, struct batadv_priv_dat, work); bat_priv = container_of(priv_dat, struct batadv_priv, dat); - __batadv_dat_purge(bat_priv, batadv_dat_to_purge); + __batadv_dat_purge(bat_priv->dat.cache_hash, batadv_dat_to_purge); + __batadv_dat_purge(bat_priv->dat.dht_hash, batadv_dat_to_purge); batadv_dat_start_timer(bat_priv); } @@ -309,21 +310,19 @@ static u32 batadv_hash_dat(const void *data, u32 size) } /** - * batadv_dat_entry_hash_find() - look for a given dat_entry in the local hash - * table - * @bat_priv: the bat priv with all the soft interface information + * batadv_dat_entry_hash_find() - look for a given dat_entry in a hash table + * @hash: the hash table to search in * @ip: search key * @vid: VLAN identifier * * Return: the dat_entry if found, NULL otherwise. */ static struct batadv_dat_entry * -batadv_dat_entry_hash_find(struct batadv_priv *bat_priv, __be32 ip, +batadv_dat_entry_hash_find(struct batadv_hashtable *hash, __be32 ip, unsigned short vid) { struct hlist_head *head; struct batadv_dat_entry to_find, *dat_entry, *dat_entry_tmp = NULL; - struct batadv_hashtable *hash = bat_priv->dat.hash; u32 index; if (!hash) @@ -351,28 +350,63 @@ batadv_dat_entry_hash_find(struct batadv_priv *bat_priv, __be32 ip, return dat_entry_tmp; } +/** + * batadv_dat_cache_entry_find() - look for a given dat_entry in the DAT cache + * @bat_priv: the bat priv with all the soft interface information + * @ip: search key + * @vid: VLAN identifier + * + * Return: the dat_entry if found, NULL otherwise. + */ +static inline struct batadv_dat_entry * +batadv_dat_cache_entry_find(struct batadv_priv *bat_priv, __be32 ip, + unsigned short vid) +{ + return batadv_dat_entry_hash_find(bat_priv->dat.cache_hash, ip, vid); +} + +/** + * batadv_dat_dht_entry_find() - look for a given dat_entry in the DAT DHT + * @bat_priv: the bat priv with all the soft interface information + * @ip: search key + * @vid: VLAN identifier + * + * Return: the dat_entry if found, NULL otherwise. + */ +static inline struct batadv_dat_entry * +batadv_dat_dht_entry_find(struct batadv_priv *bat_priv, __be32 ip, + unsigned short vid) +{ + return batadv_dat_entry_hash_find(bat_priv->dat.dht_hash, ip, vid); +} + /** * batadv_dat_entry_add() - add a new dat entry or update it if already exists * @bat_priv: the bat priv with all the soft interface information + * @hash: the hash table to add to * @ip: ipv4 to add/edit * @mac_addr: mac address to assign to the given ipv4 * @vid: VLAN identifier + * @tablename: the name of the hash table to add to */ -static void batadv_dat_entry_add(struct batadv_priv *bat_priv, __be32 ip, - u8 *mac_addr, unsigned short vid) +static void +batadv_dat_entry_add(struct batadv_priv *bat_priv, + struct batadv_hashtable *hash, __be32 ip, + u8 *mac_addr, unsigned short vid, + const char *tablename) { struct batadv_dat_entry *dat_entry; int hash_added; - dat_entry = batadv_dat_entry_hash_find(bat_priv, ip, vid); + dat_entry = batadv_dat_entry_hash_find(hash, ip, vid); /* if this entry is already known, just update it */ if (dat_entry) { if (!batadv_compare_eth(dat_entry->mac_addr, mac_addr)) ether_addr_copy(dat_entry->mac_addr, mac_addr); dat_entry->last_update = jiffies; batadv_dbg(BATADV_DBG_DAT, bat_priv, - "Entry updated: %pI4 %pM (vid: %d)\n", - &dat_entry->ip, dat_entry->mac_addr, + "Entry updated in %s: %pI4 %pM (vid: %d)\n", + tablename, &dat_entry->ip, dat_entry->mac_addr, batadv_print_vid(vid)); goto out; } @@ -388,7 +422,7 @@ static void batadv_dat_entry_add(struct batadv_priv *bat_priv, __be32 ip, kref_init(&dat_entry->refcount); kref_get(&dat_entry->refcount); - hash_added = batadv_hash_add(bat_priv->dat.hash, batadv_compare_dat, + hash_added = batadv_hash_add(hash, batadv_compare_dat, batadv_hash_dat, dat_entry, &dat_entry->hash_entry); @@ -398,14 +432,46 @@ static void batadv_dat_entry_add(struct batadv_priv *bat_priv, __be32 ip, goto out; } - batadv_dbg(BATADV_DBG_DAT, bat_priv, "New entry added: %pI4 %pM (vid: %d)\n", - &dat_entry->ip, dat_entry->mac_addr, batadv_print_vid(vid)); + batadv_dbg(BATADV_DBG_DAT, bat_priv, + "New entry added in %s: %pI4 %pM (vid: %d)\n", + tablename, &dat_entry->ip, dat_entry->mac_addr, + batadv_print_vid(vid)); out: if (dat_entry) batadv_dat_entry_put(dat_entry); } +/** + * batadv_dat_cache_entry_add() - add or update dat_entry in the DAT cache + * @bat_priv: the bat priv with all the soft interface information + * @ip: ipv4 to add/edit + * @mac_addr: mac address to assign to the given ipv4 + * @vid: VLAN identifier + */ +static inline void +batadv_dat_cache_entry_add(struct batadv_priv *bat_priv, __be32 ip, + u8 *mac_addr, unsigned short vid) +{ + batadv_dat_entry_add(bat_priv, bat_priv->dat.cache_hash, ip, mac_addr, + vid, "cache"); +} + +/** + * batadv_dat_dht_entry_add() - add or update dat_entry in the DAT DHT + * @bat_priv: the bat priv with all the soft interface information + * @ip: ipv4 to add/edit + * @mac_addr: mac address to assign to the given ipv4 + * @vid: VLAN identifier + */ +static inline void +batadv_dat_dht_entry_add(struct batadv_priv *bat_priv, __be32 ip, + u8 *mac_addr, unsigned short vid) +{ + batadv_dat_entry_add(bat_priv, bat_priv->dat.dht_hash, ip, mac_addr, + vid, "dht"); +} + #ifdef CONFIG_BATMAN_ADV_DEBUG /** @@ -455,9 +521,9 @@ static void batadv_dbg_arp(struct batadv_priv *bat_priv, struct sk_buff *skb, case BATADV_P_DAT_DHT_GET: batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DAT_DHT_GET\n"); break; - case BATADV_P_DAT_CACHE_REPLY: + case BATADV_P_DAT_DHT_REPLY: batadv_dbg(BATADV_DBG_DAT, bat_priv, - "* type: DAT_CACHE_REPLY\n"); + "* type: DAT_DHT_REPLY\n"); break; case BATADV_P_DATA: batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DATA\n"); @@ -784,37 +850,77 @@ static void batadv_dat_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv, } /** - * batadv_dat_hash_free() - free the local DAT hash table + * batadv_dat_hash_free() - free a DAT hash table * @bat_priv: the bat priv with all the soft interface information */ -static void batadv_dat_hash_free(struct batadv_priv *bat_priv) +static void batadv_dat_hash_free(struct batadv_hashtable **hash) { - if (!bat_priv->dat.hash) + if (!(*hash)) return; - __batadv_dat_purge(bat_priv, NULL); + __batadv_dat_purge(*hash, NULL); - batadv_hash_destroy(bat_priv->dat.hash); + batadv_hash_destroy(*hash); - bat_priv->dat.hash = NULL; + *hash = NULL; } /** - * batadv_dat_init() - initialise the DAT internals + * batadv_dat_cache_hash_init() - initialise the DAT cache hash table * @bat_priv: the bat priv with all the soft interface information * * Return: 0 in case of success, a negative error code otherwise */ -int batadv_dat_init(struct batadv_priv *bat_priv) +static int batadv_dat_cache_hash_init(struct batadv_priv *bat_priv) { - if (bat_priv->dat.hash) + if (bat_priv->dat.cache_hash) return 0; - bat_priv->dat.hash = batadv_hash_new(1024); + bat_priv->dat.cache_hash = batadv_hash_new(1024); - if (!bat_priv->dat.hash) + if (!bat_priv->dat.cache_hash) return -ENOMEM; + return 0; +} + +/** + * batadv_dat_dht_hash_init() - initialise the DAT DHT hash table + * @bat_priv: the bat priv with all the soft interface information + * + * Return: 0 in case of success, a negative error code otherwise + */ +static int batadv_dat_dht_hash_init(struct batadv_priv *bat_priv) +{ + if (bat_priv->dat.dht_hash) + return 0; + + bat_priv->dat.dht_hash = batadv_hash_new(1024); + + if (!bat_priv->dat.dht_hash) + return -ENOMEM; + + return 0; +} + +/** + * batadv_dat_init() - initialise the DAT internals + * @bat_priv: the bat priv with all the soft interface information + * + * Return: 0 in case of success, a negative error code otherwise + */ +int batadv_dat_init(struct batadv_priv *bat_priv) +{ + int ret; + + ret = batadv_dat_cache_hash_init(bat_priv); + if (ret < 0) + return ret; + + ret = batadv_dat_dht_hash_init(bat_priv); + if (ret < 0) + return ret; + batadv_dat_start_timer(bat_priv); batadv_tvlv_handler_register(bat_priv, batadv_dat_tvlv_ogm_handler_v1, @@ -835,7 +941,8 @@ void batadv_dat_free(struct batadv_priv *bat_priv) cancel_delayed_work_sync(&bat_priv->dat.work); - batadv_dat_hash_free(bat_priv); + batadv_dat_hash_free(&bat_priv->dat.cache_hash); + batadv_dat_hash_free(&bat_priv->dat.dht_hash); } #ifdef CONFIG_BATMAN_ADV_DEBUGFS @@ -850,9 +957,9 @@ int batadv_dat_cache_seq_print_text(struct seq_file *seq, void *offset) { struct net_device *net_dev = (struct net_device *)seq->private; struct batadv_priv *bat_priv = netdev_priv(net_dev); - struct batadv_hashtable *hash = bat_priv->dat.hash; struct batadv_dat_entry *dat_entry; struct batadv_hard_iface *primary_if; + struct batadv_hashtable *hash; struct hlist_head *head; unsigned long last_seen_jiffies; int last_seen_msecs, last_seen_secs, last_seen_mins; @@ -862,10 +969,12 @@ int batadv_dat_cache_seq_print_text(struct seq_file *seq, void *offset) if (!primary_if) goto out; - seq_printf(seq, "Distributed ARP Table (%s):\n", net_dev->name); + seq_printf(seq, "Distributed ARP Table Cache (%s):\n", net_dev->name); seq_puts(seq, " IPv4 MAC VID last-seen\n"); + hash = bat_priv->dat.cache_hash; + for (i = 0; i < hash->size; i++) { head = &hash->table[i]; @@ -893,26 +1002,26 @@ int batadv_dat_cache_seq_print_text(struct seq_file *seq, void *offset) #endif /** - * batadv_dat_cache_dump_entry() - dump one entry of the DAT cache table to a - * netlink socket + * batadv_dat_dump_entry() - dump one entry of a DAT hash table to a netlink + * socket * @msg: buffer for the message * @portid: netlink port * @cb: Control block containing additional options * @dat_entry: entry to dump + * @cmd: generic netlink command * * Return: 0 or error code. */ static int -batadv_dat_cache_dump_entry(struct sk_buff *msg, u32 portid, - struct netlink_callback *cb, - struct batadv_dat_entry *dat_entry) +batadv_dat_dump_entry(struct sk_buff *msg, u32 portid, + struct netlink_callback *cb, + struct batadv_dat_entry *dat_entry, u8 cmd) { int msecs; void *hdr; hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq, - &batadv_netlink_family, NLM_F_MULTI, - BATADV_CMD_GET_DAT_CACHE); + &batadv_netlink_family, NLM_F_MULTI, cmd); if (!hdr) return -ENOBUFS; @@ -935,22 +1044,23 @@ batadv_dat_cache_dump_entry(struct sk_buff *msg, u32 portid, } /** - * batadv_dat_cache_dump_bucket() - dump one bucket of the DAT cache table to - * a netlink socket + * batadv_dat_dump_bucket() - dump one bucket of a DAT hash table to a netlink + * socket * @msg: buffer for the message * @portid: netlink port * @cb: Control block containing additional options * @hash: hash to dump * @bucket: bucket index to dump * @idx_skip: How many entries to skip + * @cmd: generic netlink command * * Return: 0 or error code. */ static int -batadv_dat_cache_dump_bucket(struct sk_buff *msg, u32 portid, - struct netlink_callback *cb, - struct batadv_hashtable *hash, unsigned int bucket, - int *idx_skip) +batadv_dat_dump_bucket(struct sk_buff *msg, u32 portid, + struct netlink_callback *cb, + struct batadv_hashtable *hash, unsigned int bucket, + int *idx_skip, u8 cmd) { struct batadv_dat_entry *dat_entry; int idx = 0; @@ -962,7 +1072,7 @@ batadv_dat_cache_dump_bucket(struct sk_buff *msg, u32 portid, if (idx < *idx_skip) goto skip; - if (batadv_dat_cache_dump_entry(msg, portid, cb, dat_entry)) { + if (batadv_dat_dump_entry(msg, portid, cb, dat_entry, cmd)) { spin_unlock_bh(&hash->list_locks[bucket]); *idx_skip = idx; @@ -978,39 +1088,26 @@ batadv_dat_cache_dump_bucket(struct sk_buff *msg, u32 portid, } /** - * batadv_dat_cache_dump() - dump DAT cache table to a netlink socket + * batadv_dat_dump() - dump a DAT hash table to a netlink socket + * @bat_priv: the bat priv with all the soft interface information * @msg: buffer for the message * @cb: callback structure containing arguments + * @hash: the hash table to dump from + * @cmd: generic netlink command * * Return: message length. */ -int batadv_dat_cache_dump(struct sk_buff *msg, struct netlink_callback *cb) +static int +batadv_dat_dump(struct batadv_priv *bat_priv, struct sk_buff *msg, + struct netlink_callback *cb, struct batadv_hashtable *hash, + u8 cmd) { - struct batadv_hard_iface *primary_if = NULL; int portid = NETLINK_CB(cb->skb).portid; - struct net *net = sock_net(cb->skb->sk); - struct net_device *soft_iface; - struct batadv_hashtable *hash; - struct batadv_priv *bat_priv; + struct batadv_hard_iface *primary_if; int bucket = cb->args[0]; int idx = cb->args[1]; - int ifindex; int ret = 0; - ifindex = batadv_netlink_get_ifindex(cb->nlh, - BATADV_ATTR_MESH_IFINDEX); - if (!ifindex) - return -EINVAL; - - soft_iface = dev_get_by_index(net, ifindex); - if (!soft_iface || !batadv_softif_is_valid(soft_iface)) { - ret = -ENODEV; - goto out; - } - - bat_priv = netdev_priv(soft_iface); - hash = bat_priv->dat.hash; - primary_if = batadv_primary_if_get_selected(bat_priv); if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) { ret = -ENOENT; @@ -1018,8 +1115,8 @@ int batadv_dat_cache_dump(struct sk_buff *msg, struct netlink_callback *cb) } while (bucket < hash->size) { - if (batadv_dat_cache_dump_bucket(msg, portid, cb, hash, bucket, - &idx)) + if (batadv_dat_dump_bucket(msg, portid, cb, hash, bucket, &idx, + cmd)) break; bucket++; @@ -1035,9 +1132,87 @@ int batadv_dat_cache_dump(struct sk_buff *msg, struct netlink_callback *cb) if (primary_if) batadv_hardif_put(primary_if); - if (soft_iface) + return ret; +} + +/** + * batadv_dat_get_softif() - get the soft interface from a netlink callback + * @cb: callback structure containing arguments + * + * Return: The soft interface on success or an error pointer otherwise. + */ +static struct net_device *batadv_dat_get_softif(struct netlink_callback *cb) +{ + struct net *net = sock_net(cb->skb->sk); + struct net_device *soft_iface; + int ifindex; + + ifindex = batadv_netlink_get_ifindex(cb->nlh, + BATADV_ATTR_MESH_IFINDEX); + if (!ifindex) + return ERR_PTR(-EINVAL); + + soft_iface = dev_get_by_index(net, ifindex); + if (!soft_iface) + return ERR_PTR(-ENODEV); + + if (!batadv_softif_is_valid(soft_iface)) { dev_put(soft_iface); + return ERR_PTR(-ENODEV); + } + + return soft_iface; +} + +/** + * batadv_dat_cache_dump() - dump the DAT cache table to a netlink socket + * @msg: buffer for the message + * @cb: callback structure containing arguments + * + * Return: Message length on success or a negative error number otherwise. + */ +int batadv_dat_cache_dump(struct sk_buff *msg, struct netlink_callback *cb) +{ + struct net_device *soft_iface; + struct batadv_priv *bat_priv; + int ret; + + soft_iface = batadv_dat_get_softif(cb); + if (IS_ERR(soft_iface)) + return PTR_ERR(soft_iface); + + bat_priv = netdev_priv(soft_iface); + + ret = batadv_dat_dump(bat_priv, msg, cb, bat_priv->dat.cache_hash, + BATADV_CMD_GET_DAT_CACHE); + dev_put(soft_iface); + return ret; +} + +/** + * batadv_dat_dht_dump() - dump the DAT DHT table to a netlink socket + * @msg: buffer for the message + * @cb: callback structure containing arguments + * + * Return: Message length on success or a negative error number otherwise. + */ +int batadv_dat_dht_dump(struct sk_buff *msg, struct netlink_callback *cb) +{ + struct net_device *soft_iface; + struct batadv_priv *bat_priv; + int ret; + + soft_iface = batadv_dat_get_softif(cb); + if (IS_ERR(soft_iface)) + return PTR_ERR(soft_iface); + + bat_priv = netdev_priv(soft_iface); + + ret = batadv_dat_dump(bat_priv, msg, cb, bat_priv->dat.dht_hash, + BATADV_CMD_GET_DAT_DHT); + + dev_put(soft_iface); return ret; } @@ -1217,9 +1392,9 @@ bool batadv_dat_snoop_outgoing_arp_request(struct batadv_priv *bat_priv, hw_src = batadv_arp_hw_src(skb, hdr_size); ip_dst = batadv_arp_ip_dst(skb, hdr_size); - batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid); + batadv_dat_cache_entry_add(bat_priv, ip_src, hw_src, vid); - dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid); + dat_entry = batadv_dat_cache_entry_find(bat_priv, ip_dst, vid); if (dat_entry) { /* If the ARP request is destined for a local client the local * client will answer itself. DAT would only generate a @@ -1310,9 +1485,9 @@ bool batadv_dat_snoop_incoming_arp_request(struct batadv_priv *bat_priv, batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing incoming ARP REQUEST"); - batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid); + batadv_dat_cache_entry_add(bat_priv, ip_src, hw_src, vid); - dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid); + dat_entry = batadv_dat_dht_entry_find(bat_priv, ip_dst, vid); if (!dat_entry) goto out; @@ -1327,7 +1502,7 @@ bool batadv_dat_snoop_incoming_arp_request(struct batadv_priv *bat_priv, */ if (hdr_size == sizeof(struct batadv_unicast_4addr_packet)) err = batadv_send_skb_via_tt_4addr(bat_priv, skb_new, - BATADV_P_DAT_CACHE_REPLY, + BATADV_P_DAT_DHT_REPLY, NULL, vid); else err = batadv_send_skb_via_tt(bat_priv, skb_new, NULL, vid); @@ -1374,8 +1549,8 @@ void batadv_dat_snoop_outgoing_arp_reply(struct batadv_priv *bat_priv, hw_dst = batadv_arp_hw_dst(skb, hdr_size); ip_dst = batadv_arp_ip_dst(skb, hdr_size); - batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid); - batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid); + batadv_dat_cache_entry_add(bat_priv, ip_src, hw_src, vid); + batadv_dat_cache_entry_add(bat_priv, ip_dst, hw_dst, vid); /* Send the ARP reply to the candidates for both the IP addresses that * the node obtained from the ARP reply @@ -1397,7 +1572,8 @@ void batadv_dat_snoop_outgoing_arp_reply(struct batadv_priv *bat_priv, * packet has to be delivered to the interface */ bool batadv_dat_snoop_incoming_arp_reply(struct batadv_priv *bat_priv, - struct sk_buff *skb, int hdr_size) + struct sk_buff *skb, int hdr_size, + bool is_dht_put) { struct batadv_dat_entry *dat_entry = NULL; u16 type; @@ -1422,13 +1598,18 @@ bool batadv_dat_snoop_incoming_arp_reply(struct batadv_priv *bat_priv, hw_dst = batadv_arp_hw_dst(skb, hdr_size); ip_dst = batadv_arp_ip_dst(skb, hdr_size); + if (is_dht_put) { + batadv_dat_dht_entry_add(bat_priv, ip_src, hw_src, vid); + batadv_dat_dht_entry_add(bat_priv, ip_dst, hw_dst, vid); + } + /* If ip_dst is already in cache and has the right mac address, * drop this frame if this ARP reply is destined for us because it's * most probably an ARP reply generated by another node of the DHT. * We have most probably received already a reply earlier. Delivering * this frame would lead to doubled receive of an ARP reply. */ - dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_src, vid); + dat_entry = batadv_dat_cache_entry_find(bat_priv, ip_src, vid); if (dat_entry && batadv_compare_eth(hw_src, dat_entry->mac_addr)) { batadv_dbg(BATADV_DBG_DAT, bat_priv, "Doubled ARP reply removed: ARP MSG = [src: %pM-%pI4 dst: %pM-%pI4]; dat_entry: %pM-%pI4\n", hw_src, &ip_src, hw_dst, &ip_dst, @@ -1439,8 +1620,8 @@ bool batadv_dat_snoop_incoming_arp_reply(struct batadv_priv *bat_priv, /* Update our internal cache with both the IP addresses the node got * within the ARP reply */ - batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid); - batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid); + batadv_dat_cache_entry_add(bat_priv, ip_src, hw_src, vid); + batadv_dat_cache_entry_add(bat_priv, ip_dst, hw_dst, vid); if (dropped) goto out; @@ -1697,8 +1878,8 @@ static void batadv_dat_put_dhcp(struct batadv_priv *bat_priv, u8 *chaddr, skb_set_network_header(skb, ETH_HLEN); - batadv_dat_entry_add(bat_priv, yiaddr, chaddr, vid); - batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid); + batadv_dat_cache_entry_add(bat_priv, yiaddr, chaddr, vid); + batadv_dat_cache_entry_add(bat_priv, ip_dst, hw_dst, vid); batadv_dat_forward_data(bat_priv, skb, yiaddr, vid, BATADV_P_DAT_DHT_PUT); @@ -1823,8 +2004,8 @@ void batadv_dat_snoop_incoming_dhcp_ack(struct batadv_priv *bat_priv, hw_src = ethhdr->h_source; vid = batadv_dat_get_vid(skb, &hdr_size); - batadv_dat_entry_add(bat_priv, yiaddr, chaddr, vid); - batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid); + batadv_dat_cache_entry_add(bat_priv, yiaddr, chaddr, vid); + batadv_dat_cache_entry_add(bat_priv, ip_src, hw_src, vid); batadv_dbg(BATADV_DBG_DAT, bat_priv, "Snooped from incoming DHCPACK (server address): %pI4, %pM (vid: %i)\n", @@ -1868,7 +2049,7 @@ bool batadv_dat_drop_broadcast_packet(struct batadv_priv *bat_priv, goto out; ip_dst = batadv_arp_ip_dst(forw_packet->skb, hdr_size); - dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid); + dat_entry = batadv_dat_cache_entry_find(bat_priv, ip_dst, vid); /* check if the node already got this entry */ if (!dat_entry) { batadv_dbg(BATADV_DBG_DAT, bat_priv, diff --git a/net/batman-adv/distributed-arp-table.h b/net/batman-adv/distributed-arp-table.h index 110c2744..efb32c67 100644 --- a/net/batman-adv/distributed-arp-table.h +++ b/net/batman-adv/distributed-arp-table.h @@ -33,7 +33,8 @@ bool batadv_dat_snoop_incoming_arp_request(struct batadv_priv *bat_priv, void batadv_dat_snoop_outgoing_arp_reply(struct batadv_priv *bat_priv, struct sk_buff *skb); bool batadv_dat_snoop_incoming_arp_reply(struct batadv_priv *bat_priv, - struct sk_buff *skb, int hdr_size); + struct sk_buff *skb, int hdr_size, + bool is_dht_put); void batadv_dat_snoop_outgoing_dhcp_ack(struct batadv_priv *bat_priv, struct sk_buff *skb, __be16 proto, @@ -77,6 +78,7 @@ int batadv_dat_init(struct batadv_priv *bat_priv); void batadv_dat_free(struct batadv_priv *bat_priv); int batadv_dat_cache_seq_print_text(struct seq_file *seq, void *offset); int batadv_dat_cache_dump(struct sk_buff *msg, struct netlink_callback *cb); +int batadv_dat_dht_dump(struct sk_buff *msg, struct netlink_callback *cb); /** * batadv_dat_inc_counter() - increment the correct DAT packet counter @@ -129,7 +131,8 @@ batadv_dat_snoop_outgoing_arp_reply(struct batadv_priv *bat_priv, static inline bool batadv_dat_snoop_incoming_arp_reply(struct batadv_priv *bat_priv, - struct sk_buff *skb, int hdr_size) + struct sk_buff *skb, int hdr_size, + bool is_dht_put) { return false; } @@ -184,6 +187,12 @@ batadv_dat_cache_dump(struct sk_buff *msg, struct netlink_callback *cb) return -EOPNOTSUPP; } +static inline int +batadv_dat_dht_dump(struct sk_buff *msg, struct netlink_callback *cb) +{ + return -EOPNOTSUPP; +} + static inline void batadv_dat_inc_counter(struct batadv_priv *bat_priv, u8 subtype) { diff --git a/net/batman-adv/netlink.c b/net/batman-adv/netlink.c index daf56933..59c114f3 100644 --- a/net/batman-adv/netlink.c +++ b/net/batman-adv/netlink.c @@ -1425,6 +1425,12 @@ static const struct genl_ops batadv_netlink_ops[] = { .policy = batadv_netlink_policy, .dumpit = batadv_dat_cache_dump, }, + { + .cmd = BATADV_CMD_GET_DAT_DHT, + .flags = GENL_ADMIN_PERM, + .policy = batadv_netlink_policy, + .dumpit = batadv_dat_dht_dump, + }, { .cmd = BATADV_CMD_GET_MCAST_FLAGS, .flags = GENL_ADMIN_PERM, diff --git a/net/batman-adv/routing.c b/net/batman-adv/routing.c index f0f86482..9008b2cb 100644 --- a/net/batman-adv/routing.c +++ b/net/batman-adv/routing.c @@ -959,10 +959,10 @@ int batadv_recv_unicast_packet(struct sk_buff *skb, struct batadv_unicast_4addr_packet *unicast_4addr_packet; u8 *orig_addr, *orig_addr_gw; struct batadv_orig_node *orig_node = NULL, *orig_node_gw = NULL; + bool is4addr, is_gw, is_dht_put = false; int check, hdr_size = sizeof(*unicast_packet); enum batadv_subtype subtype; int ret = NET_RX_DROP; - bool is4addr, is_gw; unicast_packet = (struct batadv_unicast_packet *)skb->data; is4addr = unicast_packet->packet_type == BATADV_UNICAST_4ADDR; @@ -1021,6 +1021,8 @@ int batadv_recv_unicast_packet(struct sk_buff *skb, orig_addr = unicast_4addr_packet->src; orig_node = batadv_orig_hash_find(bat_priv, orig_addr); + } else if (subtype == BATADV_P_DAT_DHT_PUT) { + is_dht_put = true; } } @@ -1028,7 +1030,7 @@ int batadv_recv_unicast_packet(struct sk_buff *skb, hdr_size)) goto rx_success; if (batadv_dat_snoop_incoming_arp_reply(bat_priv, skb, - hdr_size)) + hdr_size, is_dht_put)) goto rx_success; batadv_dat_snoop_incoming_dhcp_ack(bat_priv, skb, hdr_size); @@ -1265,7 +1267,7 @@ int batadv_recv_bcast_packet(struct sk_buff *skb, if (batadv_dat_snoop_incoming_arp_request(bat_priv, skb, hdr_size)) goto rx_success; - if (batadv_dat_snoop_incoming_arp_reply(bat_priv, skb, hdr_size)) + if (batadv_dat_snoop_incoming_arp_reply(bat_priv, skb, hdr_size, false)) goto rx_success; batadv_dat_snoop_incoming_dhcp_ack(bat_priv, skb, hdr_size); diff --git a/net/batman-adv/types.h b/net/batman-adv/types.h index 357ca119..c036ad50 100644 --- a/net/batman-adv/types.h +++ b/net/batman-adv/types.h @@ -1145,8 +1145,11 @@ struct batadv_priv_dat { /** @addr: node DAT address */ batadv_dat_addr_t addr; - /** @hash: hashtable representing the local ARP cache */ - struct batadv_hashtable *hash; + /** @cache_hash: hashtable representing the local ARP cache */ + struct batadv_hashtable *cache_hash; + + /** @dht_hash: hashtable representing the local DAT DHT */ + struct batadv_hashtable *dht_hash; /** @work: work queue callback item for cache purging */ struct delayed_work work; From patchwork Sun Apr 7 10:37:02 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?q?Linus_L=C3=BCssing?= X-Patchwork-Id: 17882 X-Patchwork-Delegate: sw@simonwunderlich.de Return-Path: X-Original-To: patchwork@open-mesh.org Delivered-To: patchwork@open-mesh.org Received: from open-mesh.org (localhost [IPv6:::1]) by open-mesh.org (Postfix) with ESMTP id A6F5882687; Sun, 7 Apr 2019 12:37:23 +0200 (CEST) Authentication-Results: open-mesh.org; dkim=fail reason="key not found in DNS" (0-bit key; unprotected) header.d=c0d3.blue header.i=@c0d3.blue header.b="pl0/0CHi"; dkim-atps=neutral Received-SPF: None (mailfrom) identity=mailfrom; client-ip=138.201.29.205; helo=mail.aperture-lab.de; envelope-from=linus.luessing@c0d3.blue; receiver= Received: from mail.aperture-lab.de (mail.aperture-lab.de [138.201.29.205]) by open-mesh.org (Postfix) with ESMTPS id 010D482669 for ; Sun, 7 Apr 2019 12:37:19 +0200 (CEST) From: =?utf-8?q?Linus_L=C3=BCssing?= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=c0d3.blue; s=2018; t=1554633439; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=6b6kig4OgIl9omswmGN8rewe5DzIs3B7MS6/Fyhqu60=; b=pl0/0CHiWlk59g/Mx9xWDX0c4Cz9+mnF2ilJCP7rA2w0nOlM3PxPLa+/4hBYpndbWxcR4q ds633EkpE5SA7zKw+9fetNYoZd5E2FefY8i+iDdJkNzexwAbo4XzNFLguX9pk9tFL38Vec LAFqW7CZmr1ja59XYtno0PnMKtj559g+VfnscQ5pOnGAHXs4oApPRAb+V5GbgjudzBud0d bXxOpU5CbeDUJe48kquGpl9LR179EA7dLeXdt698q8qMqOnei7FubgUL4gooaq+dvdhmSL /GKJEw98QpRvkExgmJlB03iD7/DV63sfQ0bLC/qIp+xDZQvmryABTpooiKyA5w== To: b.a.t.m.a.n@lists.open-mesh.org Date: Sun, 7 Apr 2019 12:37:02 +0200 Message-Id: <20190407103702.30435-3-linus.luessing@c0d3.blue> In-Reply-To: <20190407103702.30435-1-linus.luessing@c0d3.blue> References: <20190407103702.30435-1-linus.luessing@c0d3.blue> MIME-Version: 1.0 ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=c0d3.blue; s=2018; t=1554633439; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=6b6kig4OgIl9omswmGN8rewe5DzIs3B7MS6/Fyhqu60=; b=bbxZPRVT75m83wF2ipFXVcUTPa4cJUB5y92Po6H4h9j9syaK33yj0NJX5DG87HBlZIm6dU 9GUtHIqXTyrVTO0W7UFnVfvr2fiMlNMMhg22ffch2+ezFHoXIJ+pg1hRQ5ODnC2n5k17q/ 8PjxxfHDnsE/IB965bEqsTTknYYEvHNMwhVudwkB7bnxprNzLOQP8N9nLT7xWdVxbWRXvm YDu+ZyPzl/Cfg7x58bf74JvlWTqvInNG8Txxaw82uQhLEgi+gjzAoYXM05PJEK85vtdOHQ kR8L5mIuKz2qaiwOGmNbfS6WbUtajdlUHaT9D4fQK9kgHa+lWOIfQ+g/iWDJsA== ARC-Seal: i=1; s=2018; d=c0d3.blue; t=1554633439; a=rsa-sha256; cv=none; b=MWI0WtA+X/QFGAmy4j8aZ4asRX1YLiddRA+t0/IOsJjrZlldMJYkYdXtLLa5BvF9vhn0Bq kf2y/MiZqgrdcgjiitYwpuoTk7hO6HuiErO1TXN+E1Xi8utkHqdbPEYVw8JtIwYg53q6Si PNgNXUmYWdbB4X96eVyxPNlJ0S8FwgdB9xhv7X1WE/WMVLroTAqsG1pqdTLQgM2/hsEK06 R9tAGrYy6iL6XEnn9sinKUJKdozwOVJ9XzNkuwsiHCCYXIVe1Gw7WaDNp4W0EohnPE/5LJ AnAXNpNMUPBi15JBNOK6i1RaG6tj0XMidrJ9REq3tukmqrKledhJ2ilq1Ad6Hw== ARC-Authentication-Results: i=1; ORIGINATING; auth=pass smtp.auth=linus.luessing@c0d3.blue smtp.mailfrom=linus.luessing@c0d3.blue Authentication-Results: ORIGINATING; auth=pass smtp.auth=linus.luessing@c0d3.blue smtp.mailfrom=linus.luessing@c0d3.blue Subject: [B.A.T.M.A.N.] [PATCH v3 2/2] batman-adv: increase DAT DHT timeout X-BeenThere: b.a.t.m.a.n@lists.open-mesh.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: The list for a Better Approach To Mobile Ad-hoc Networking List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: The list for a Better Approach To Mobile Ad-hoc Networking Errors-To: b.a.t.m.a.n-bounces@lists.open-mesh.org Sender: "B.A.T.M.A.N" Currently, the DHT_GET messages of the DAT will likely be left unanswered due to the following issues: When a node has a matching DAT Cache entry for a local ARP Request then this node will answer it directly with the information provided by the cache. This however, will likely lead to missing ARP Replies from the original host. Which in turn leads to the DAT DHT not being updated. Then the local DAT cache entry will time out, triggering a unicasted DHT_GET. However, as the 5min. timeout has passed, the DAT DHT candidates will likely have purged their entry, too. So basically this results in an ARP Request broadcast fallback every five minutes. A second issue is that it is quite common that a host which has long gone offline will be tried to be contacted by another one at some remote period larger than the current 5min. timeout. This too leads to flooded ARP Requests. With this patch the purge timeout for DAT DHT entries is increased to 30min to reduce the number of DAT ARP broadcast fallbacks. Signed-off-by: Linus Lüssing --- net/batman-adv/distributed-arp-table.c | 22 +++++++++++++++++----- net/batman-adv/main.h | 3 ++- 2 files changed, 19 insertions(+), 6 deletions(-) diff --git a/net/batman-adv/distributed-arp-table.c b/net/batman-adv/distributed-arp-table.c index 97444342..b2173c5f 100644 --- a/net/batman-adv/distributed-arp-table.c +++ b/net/batman-adv/distributed-arp-table.c @@ -132,15 +132,27 @@ static void batadv_dat_entry_put(struct batadv_dat_entry *dat_entry) } /** - * batadv_dat_to_purge() - check whether a dat_entry has to be purged or not + * batadv_dat_cache_to_purge() - check if a cache entry has to be purged or not * @dat_entry: the entry to check * * Return: true if the entry has to be purged now, false otherwise. */ -static bool batadv_dat_to_purge(struct batadv_dat_entry *dat_entry) +static bool batadv_dat_cache_to_purge(struct batadv_dat_entry *dat_entry) { return batadv_has_timed_out(dat_entry->last_update, - BATADV_DAT_ENTRY_TIMEOUT); + BATADV_DAT_CACHE_ENTRY_TIMEOUT); +} + +/** + * batadv_dat_dht_to_purge() - check if a DHT entry has to be purged or not + * @dat_entry: the entry to check + * + * Return: true if the entry has to be purged now, false otherwise. + */ +static bool batadv_dat_dht_to_purge(struct batadv_dat_entry *dat_entry) +{ + return batadv_has_timed_out(dat_entry->last_update, + BATADV_DAT_DHT_ENTRY_TIMEOUT); } /** @@ -201,8 +213,8 @@ static void batadv_dat_purge(struct work_struct *work) priv_dat = container_of(delayed_work, struct batadv_priv_dat, work); bat_priv = container_of(priv_dat, struct batadv_priv, dat); - __batadv_dat_purge(bat_priv->dat.cache_hash, batadv_dat_to_purge); - __batadv_dat_purge(bat_priv->dat.dht_hash, batadv_dat_to_purge); + __batadv_dat_purge(bat_priv->dat.cache_hash, batadv_dat_cache_to_purge); + __batadv_dat_purge(bat_priv->dat.dht_hash, batadv_dat_dht_to_purge); batadv_dat_start_timer(bat_priv); } diff --git a/net/batman-adv/main.h b/net/batman-adv/main.h index c59afcba..cb30c042 100644 --- a/net/batman-adv/main.h +++ b/net/batman-adv/main.h @@ -38,7 +38,8 @@ #define BATADV_TT_WORK_PERIOD 5000 /* 5 seconds */ #define BATADV_ORIG_WORK_PERIOD 1000 /* 1 second */ #define BATADV_MCAST_WORK_PERIOD 500 /* 0.5 seconds */ -#define BATADV_DAT_ENTRY_TIMEOUT (5 * 60000) /* 5 mins in milliseconds */ +#define BATADV_DAT_CACHE_ENTRY_TIMEOUT (5 * 60000) /* 5 mins in milliseconds */ +#define BATADV_DAT_DHT_ENTRY_TIMEOUT (30 * 60000) /* 30 mins in milliseconds */ /* sliding packet range of received originator messages in sequence numbers * (should be a multiple of our word size) */