2013-01-04 02:05:31 +00:00
|
|
|
/* Copyright (C) 2007-2013 B.A.T.M.A.N. contributors:
|
2010-12-13 11:19:28 +00:00
|
|
|
*
|
|
|
|
* Marek Lindner, Simon Wunderlich
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of version 2 of the GNU General Public
|
|
|
|
* License as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
|
|
* 02110-1301, USA
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "main.h"
|
2011-06-26 01:37:18 +00:00
|
|
|
#include "distributed-arp-table.h"
|
2010-12-13 11:19:28 +00:00
|
|
|
#include "send.h"
|
|
|
|
#include "routing.h"
|
|
|
|
#include "translation-table.h"
|
|
|
|
#include "soft-interface.h"
|
|
|
|
#include "hard-interface.h"
|
|
|
|
#include "gateway_common.h"
|
2013-05-23 14:53:01 +00:00
|
|
|
#include "gateway_client.h"
|
2010-12-13 11:19:28 +00:00
|
|
|
#include "originator.h"
|
2013-01-25 10:12:42 +00:00
|
|
|
#include "network-coding.h"
|
2013-05-23 14:53:03 +00:00
|
|
|
#include "fragmentation.h"
|
2012-11-25 23:38:50 +00:00
|
|
|
|
2012-05-16 18:23:14 +00:00
|
|
|
static void batadv_send_outstanding_bcast_packet(struct work_struct *work);
|
2010-12-13 11:19:28 +00:00
|
|
|
|
|
|
|
/* send out an already prepared packet to the given address via the
|
2012-05-12 00:09:43 +00:00
|
|
|
* specified batman interface
|
|
|
|
*/
|
2012-06-05 20:31:31 +00:00
|
|
|
int batadv_send_skb_packet(struct sk_buff *skb,
|
|
|
|
struct batadv_hard_iface *hard_iface,
|
2012-05-12 00:09:37 +00:00
|
|
|
const uint8_t *dst_addr)
|
2010-12-13 11:19:28 +00:00
|
|
|
{
|
2013-01-25 10:12:42 +00:00
|
|
|
struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
|
2010-12-13 11:19:28 +00:00
|
|
|
struct ethhdr *ethhdr;
|
|
|
|
|
2012-06-03 20:19:19 +00:00
|
|
|
if (hard_iface->if_status != BATADV_IF_ACTIVE)
|
2010-12-13 11:19:28 +00:00
|
|
|
goto send_skb_err;
|
|
|
|
|
2011-02-18 12:33:20 +00:00
|
|
|
if (unlikely(!hard_iface->net_dev))
|
2010-12-13 11:19:28 +00:00
|
|
|
goto send_skb_err;
|
|
|
|
|
2011-02-18 12:33:20 +00:00
|
|
|
if (!(hard_iface->net_dev->flags & IFF_UP)) {
|
2012-03-26 14:22:45 +00:00
|
|
|
pr_warn("Interface %s is not up - can't send packet via that interface!\n",
|
|
|
|
hard_iface->net_dev->name);
|
2010-12-13 11:19:28 +00:00
|
|
|
goto send_skb_err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* push to the ethernet header. */
|
2012-05-12 00:09:38 +00:00
|
|
|
if (batadv_skb_head_push(skb, ETH_HLEN) < 0)
|
2010-12-13 11:19:28 +00:00
|
|
|
goto send_skb_err;
|
|
|
|
|
|
|
|
skb_reset_mac_header(skb);
|
|
|
|
|
2013-04-08 13:08:18 +00:00
|
|
|
ethhdr = eth_hdr(skb);
|
2011-02-18 12:33:20 +00:00
|
|
|
memcpy(ethhdr->h_source, hard_iface->net_dev->dev_addr, ETH_ALEN);
|
2010-12-13 11:19:28 +00:00
|
|
|
memcpy(ethhdr->h_dest, dst_addr, ETH_ALEN);
|
2013-05-19 10:55:16 +00:00
|
|
|
ethhdr->h_proto = htons(ETH_P_BATMAN);
|
2010-12-13 11:19:28 +00:00
|
|
|
|
|
|
|
skb_set_network_header(skb, ETH_HLEN);
|
2013-05-19 10:55:16 +00:00
|
|
|
skb->protocol = htons(ETH_P_BATMAN);
|
2010-12-13 11:19:28 +00:00
|
|
|
|
2011-02-18 12:33:20 +00:00
|
|
|
skb->dev = hard_iface->net_dev;
|
2010-12-13 11:19:28 +00:00
|
|
|
|
2013-01-25 10:12:42 +00:00
|
|
|
/* Save a clone of the skb to use when decoding coded packets */
|
|
|
|
batadv_nc_skb_store_for_decoding(bat_priv, skb);
|
|
|
|
|
2010-12-13 11:19:28 +00:00
|
|
|
/* dev_queue_xmit() returns a negative result on error. However on
|
|
|
|
* congestion and traffic shaping, it drops and returns NET_XMIT_DROP
|
2012-05-12 00:09:43 +00:00
|
|
|
* (which is > 0). This will not be treated as an error.
|
|
|
|
*/
|
2010-12-13 11:19:28 +00:00
|
|
|
return dev_queue_xmit(skb);
|
|
|
|
send_skb_err:
|
|
|
|
kfree_skb(skb);
|
|
|
|
return NET_XMIT_DROP;
|
|
|
|
}
|
|
|
|
|
2012-10-16 14:13:48 +00:00
|
|
|
/**
|
|
|
|
* batadv_send_skb_to_orig - Lookup next-hop and transmit skb.
|
|
|
|
* @skb: Packet to be transmitted.
|
|
|
|
* @orig_node: Final destination of the packet.
|
|
|
|
* @recv_if: Interface used when receiving the packet (can be NULL).
|
|
|
|
*
|
|
|
|
* Looks up the best next-hop towards the passed originator and passes the
|
|
|
|
* skb on for preparation of MAC header. If the packet originated from this
|
|
|
|
* host, NULL can be passed as recv_if and no interface alternating is
|
|
|
|
* attempted.
|
|
|
|
*
|
2013-04-20 11:54:39 +00:00
|
|
|
* Returns NET_XMIT_SUCCESS on success, NET_XMIT_DROP on failure, or
|
|
|
|
* NET_XMIT_POLICED if the skb is buffered for later transmit.
|
2012-10-16 14:13:48 +00:00
|
|
|
*/
|
2013-04-20 11:54:39 +00:00
|
|
|
int batadv_send_skb_to_orig(struct sk_buff *skb,
|
|
|
|
struct batadv_orig_node *orig_node,
|
|
|
|
struct batadv_hard_iface *recv_if)
|
2012-10-16 14:13:48 +00:00
|
|
|
{
|
|
|
|
struct batadv_priv *bat_priv = orig_node->bat_priv;
|
|
|
|
struct batadv_neigh_node *neigh_node;
|
2013-04-20 11:54:39 +00:00
|
|
|
int ret = NET_XMIT_DROP;
|
2012-10-16 14:13:48 +00:00
|
|
|
|
|
|
|
/* batadv_find_router() increases neigh_nodes refcount if found. */
|
|
|
|
neigh_node = batadv_find_router(bat_priv, orig_node, recv_if);
|
|
|
|
if (!neigh_node)
|
2013-05-23 14:53:03 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* Check if the skb is too large to send in one piece and fragment
|
|
|
|
* it if needed.
|
|
|
|
*/
|
|
|
|
if (atomic_read(&bat_priv->fragmentation) &&
|
|
|
|
skb->len > neigh_node->if_incoming->net_dev->mtu) {
|
|
|
|
/* Fragment and send packet. */
|
|
|
|
if (batadv_frag_send_packet(skb, orig_node, neigh_node))
|
|
|
|
ret = NET_XMIT_SUCCESS;
|
|
|
|
|
|
|
|
goto out;
|
|
|
|
}
|
2012-10-16 14:13:48 +00:00
|
|
|
|
2013-04-20 11:54:39 +00:00
|
|
|
/* try to network code the packet, if it is received on an interface
|
|
|
|
* (i.e. being forwarded). If the packet originates from this node or if
|
|
|
|
* network coding fails, then send the packet as usual.
|
|
|
|
*/
|
|
|
|
if (recv_if && batadv_nc_skb_forward(skb, neigh_node)) {
|
|
|
|
ret = NET_XMIT_POLICED;
|
|
|
|
} else {
|
|
|
|
batadv_send_skb_packet(skb, neigh_node->if_incoming,
|
|
|
|
neigh_node->addr);
|
|
|
|
ret = NET_XMIT_SUCCESS;
|
|
|
|
}
|
2012-10-16 14:13:48 +00:00
|
|
|
|
2013-05-23 14:53:03 +00:00
|
|
|
out:
|
|
|
|
if (neigh_node)
|
|
|
|
batadv_neigh_node_free_ref(neigh_node);
|
2012-10-16 14:13:48 +00:00
|
|
|
|
2013-04-20 11:54:39 +00:00
|
|
|
return ret;
|
2012-10-16 14:13:48 +00:00
|
|
|
}
|
|
|
|
|
2013-05-23 14:53:01 +00:00
|
|
|
/**
|
|
|
|
* batadv_send_skb_push_fill_unicast - extend the buffer and initialize the
|
|
|
|
* common fields for unicast packets
|
|
|
|
* @skb: the skb carrying the unicast header to initialize
|
|
|
|
* @hdr_size: amount of bytes to push at the beginning of the skb
|
|
|
|
* @orig_node: the destination node
|
|
|
|
*
|
|
|
|
* Returns false if the buffer extension was not possible or true otherwise.
|
|
|
|
*/
|
|
|
|
static bool
|
|
|
|
batadv_send_skb_push_fill_unicast(struct sk_buff *skb, int hdr_size,
|
|
|
|
struct batadv_orig_node *orig_node)
|
|
|
|
{
|
|
|
|
struct batadv_unicast_packet *unicast_packet;
|
|
|
|
uint8_t ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);
|
|
|
|
|
|
|
|
if (batadv_skb_head_push(skb, hdr_size) < 0)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
unicast_packet = (struct batadv_unicast_packet *)skb->data;
|
|
|
|
unicast_packet->header.version = BATADV_COMPAT_VERSION;
|
|
|
|
/* batman packet type: unicast */
|
|
|
|
unicast_packet->header.packet_type = BATADV_UNICAST;
|
|
|
|
/* set unicast ttl */
|
|
|
|
unicast_packet->header.ttl = BATADV_TTL;
|
|
|
|
/* copy the destination for faster routing */
|
|
|
|
memcpy(unicast_packet->dest, orig_node->orig, ETH_ALEN);
|
|
|
|
/* set the destination tt version number */
|
|
|
|
unicast_packet->ttvn = ttvn;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* batadv_send_skb_prepare_unicast - encapsulate an skb with a unicast header
|
|
|
|
* @skb: the skb containing the payload to encapsulate
|
|
|
|
* @orig_node: the destination node
|
|
|
|
*
|
|
|
|
* Returns false if the payload could not be encapsulated or true otherwise.
|
|
|
|
*/
|
|
|
|
static bool batadv_send_skb_prepare_unicast(struct sk_buff *skb,
|
|
|
|
struct batadv_orig_node *orig_node)
|
|
|
|
{
|
|
|
|
size_t uni_size = sizeof(struct batadv_unicast_packet);
|
|
|
|
|
|
|
|
return batadv_send_skb_push_fill_unicast(skb, uni_size, orig_node);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* batadv_send_skb_prepare_unicast_4addr - encapsulate an skb with a
|
|
|
|
* unicast 4addr header
|
|
|
|
* @bat_priv: the bat priv with all the soft interface information
|
|
|
|
* @skb: the skb containing the payload to encapsulate
|
|
|
|
* @orig_node: the destination node
|
|
|
|
* @packet_subtype: the unicast 4addr packet subtype to use
|
|
|
|
*
|
|
|
|
* Returns false if the payload could not be encapsulated or true otherwise.
|
|
|
|
*/
|
|
|
|
bool batadv_send_skb_prepare_unicast_4addr(struct batadv_priv *bat_priv,
|
|
|
|
struct sk_buff *skb,
|
|
|
|
struct batadv_orig_node *orig,
|
|
|
|
int packet_subtype)
|
|
|
|
{
|
|
|
|
struct batadv_hard_iface *primary_if;
|
|
|
|
struct batadv_unicast_4addr_packet *uc_4addr_packet;
|
|
|
|
bool ret = false;
|
|
|
|
|
|
|
|
primary_if = batadv_primary_if_get_selected(bat_priv);
|
|
|
|
if (!primary_if)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* Pull the header space and fill the unicast_packet substructure.
|
|
|
|
* We can do that because the first member of the uc_4addr_packet
|
|
|
|
* is of type struct unicast_packet
|
|
|
|
*/
|
|
|
|
if (!batadv_send_skb_push_fill_unicast(skb, sizeof(*uc_4addr_packet),
|
|
|
|
orig))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
uc_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data;
|
|
|
|
uc_4addr_packet->u.header.packet_type = BATADV_UNICAST_4ADDR;
|
|
|
|
memcpy(uc_4addr_packet->src, primary_if->net_dev->dev_addr, ETH_ALEN);
|
|
|
|
uc_4addr_packet->subtype = packet_subtype;
|
|
|
|
uc_4addr_packet->reserved = 0;
|
|
|
|
|
|
|
|
ret = true;
|
|
|
|
out:
|
|
|
|
if (primary_if)
|
|
|
|
batadv_hardif_free_ref(primary_if);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2013-07-03 08:40:00 +00:00
|
|
|
* batadv_send_skb_unicast - encapsulate and send an skb via unicast
|
2013-05-23 14:53:01 +00:00
|
|
|
* @bat_priv: the bat priv with all the soft interface information
|
|
|
|
* @skb: payload to send
|
|
|
|
* @packet_type: the batman unicast packet type to use
|
|
|
|
* @packet_subtype: the unicast 4addr packet subtype (only relevant for unicast
|
|
|
|
* 4addr packets)
|
2013-07-03 08:40:00 +00:00
|
|
|
* @orig_node: the originator to send the packet to
|
2013-06-04 10:11:39 +00:00
|
|
|
* @vid: the vid to be used to search the translation table
|
2013-05-23 14:53:01 +00:00
|
|
|
*
|
2013-07-03 08:40:00 +00:00
|
|
|
* Wrap the given skb into a batman-adv unicast or unicast-4addr header
|
|
|
|
* depending on whether BATADV_UNICAST or BATADV_UNICAST_4ADDR was supplied
|
|
|
|
* as packet_type. Then send this frame to the given orig_node and release a
|
|
|
|
* reference to this orig_node.
|
|
|
|
*
|
|
|
|
* Returns NET_XMIT_DROP in case of error or NET_XMIT_SUCCESS otherwise.
|
2013-05-23 14:53:01 +00:00
|
|
|
*/
|
2013-07-03 08:40:00 +00:00
|
|
|
static int batadv_send_skb_unicast(struct batadv_priv *bat_priv,
|
|
|
|
struct sk_buff *skb, int packet_type,
|
|
|
|
int packet_subtype,
|
|
|
|
struct batadv_orig_node *orig_node,
|
|
|
|
unsigned short vid)
|
2013-05-23 14:53:01 +00:00
|
|
|
{
|
|
|
|
struct ethhdr *ethhdr = (struct ethhdr *)skb->data;
|
|
|
|
struct batadv_unicast_packet *unicast_packet;
|
2013-07-03 08:40:00 +00:00
|
|
|
int ret = NET_XMIT_DROP;
|
2013-05-23 14:53:01 +00:00
|
|
|
|
2013-05-28 09:49:47 +00:00
|
|
|
if (!orig_node)
|
2013-05-23 14:53:01 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
switch (packet_type) {
|
|
|
|
case BATADV_UNICAST:
|
2013-10-19 12:06:05 +00:00
|
|
|
if (!batadv_send_skb_prepare_unicast(skb, orig_node))
|
|
|
|
goto out;
|
2013-05-23 14:53:01 +00:00
|
|
|
break;
|
|
|
|
case BATADV_UNICAST_4ADDR:
|
2013-10-19 12:06:05 +00:00
|
|
|
if (!batadv_send_skb_prepare_unicast_4addr(bat_priv, skb,
|
|
|
|
orig_node,
|
|
|
|
packet_subtype))
|
|
|
|
goto out;
|
2013-05-23 14:53:01 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* this function supports UNICAST and UNICAST_4ADDR only. It
|
|
|
|
* should never be invoked with any other packet type
|
|
|
|
*/
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
unicast_packet = (struct batadv_unicast_packet *)skb->data;
|
|
|
|
|
|
|
|
/* inform the destination node that we are still missing a correct route
|
|
|
|
* for this client. The destination will receive this packet and will
|
|
|
|
* try to reroute it because the ttvn contained in the header is less
|
|
|
|
* than the current one
|
|
|
|
*/
|
2013-06-04 10:11:39 +00:00
|
|
|
if (batadv_tt_global_client_is_roaming(bat_priv, ethhdr->h_dest, vid))
|
2013-05-23 14:53:01 +00:00
|
|
|
unicast_packet->ttvn = unicast_packet->ttvn - 1;
|
|
|
|
|
|
|
|
if (batadv_send_skb_to_orig(skb, orig_node, NULL) != NET_XMIT_DROP)
|
2013-07-03 08:40:00 +00:00
|
|
|
ret = NET_XMIT_SUCCESS;
|
2013-05-23 14:53:01 +00:00
|
|
|
|
|
|
|
out:
|
|
|
|
if (orig_node)
|
|
|
|
batadv_orig_node_free_ref(orig_node);
|
2013-07-03 08:40:00 +00:00
|
|
|
if (ret == NET_XMIT_DROP)
|
2013-05-23 14:53:01 +00:00
|
|
|
kfree_skb(skb);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-07-03 08:40:00 +00:00
|
|
|
/**
|
|
|
|
* batadv_send_skb_via_tt_generic - send an skb via TT lookup
|
|
|
|
* @bat_priv: the bat priv with all the soft interface information
|
|
|
|
* @skb: payload to send
|
|
|
|
* @packet_type: the batman unicast packet type to use
|
|
|
|
* @packet_subtype: the unicast 4addr packet subtype (only relevant for unicast
|
|
|
|
* 4addr packets)
|
|
|
|
* @vid: the vid to be used to search the translation table
|
|
|
|
*
|
|
|
|
* Look up the recipient node for the destination address in the ethernet
|
|
|
|
* header via the translation table. Wrap the given skb into a batman-adv
|
|
|
|
* unicast or unicast-4addr header depending on whether BATADV_UNICAST or
|
|
|
|
* BATADV_UNICAST_4ADDR was supplied as packet_type. Then send this frame
|
|
|
|
* to the according destination node.
|
|
|
|
*
|
|
|
|
* Returns NET_XMIT_DROP in case of error or NET_XMIT_SUCCESS otherwise.
|
|
|
|
*/
|
|
|
|
int batadv_send_skb_via_tt_generic(struct batadv_priv *bat_priv,
|
|
|
|
struct sk_buff *skb, int packet_type,
|
|
|
|
int packet_subtype, unsigned short vid)
|
|
|
|
{
|
|
|
|
struct ethhdr *ethhdr = (struct ethhdr *)skb->data;
|
|
|
|
struct batadv_orig_node *orig_node;
|
|
|
|
|
|
|
|
orig_node = batadv_transtable_search(bat_priv, ethhdr->h_source,
|
|
|
|
ethhdr->h_dest, vid);
|
|
|
|
return batadv_send_skb_unicast(bat_priv, skb, packet_type,
|
|
|
|
packet_subtype, orig_node, vid);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* batadv_send_skb_via_gw - send an skb via gateway lookup
|
|
|
|
* @bat_priv: the bat priv with all the soft interface information
|
|
|
|
* @skb: payload to send
|
|
|
|
* @vid: the vid to be used to search the translation table
|
|
|
|
*
|
|
|
|
* Look up the currently selected gateway. Wrap the given skb into a batman-adv
|
|
|
|
* unicast header and send this frame to this gateway node.
|
|
|
|
*
|
|
|
|
* Returns NET_XMIT_DROP in case of error or NET_XMIT_SUCCESS otherwise.
|
|
|
|
*/
|
|
|
|
int batadv_send_skb_via_gw(struct batadv_priv *bat_priv, struct sk_buff *skb,
|
|
|
|
unsigned short vid)
|
|
|
|
{
|
|
|
|
struct batadv_orig_node *orig_node;
|
|
|
|
|
|
|
|
orig_node = batadv_gw_get_selected_orig(bat_priv);
|
|
|
|
return batadv_send_skb_unicast(bat_priv, skb, BATADV_UNICAST, 0,
|
|
|
|
orig_node, vid);
|
|
|
|
}
|
|
|
|
|
2012-06-05 20:31:31 +00:00
|
|
|
void batadv_schedule_bat_ogm(struct batadv_hard_iface *hard_iface)
|
2010-12-13 11:19:28 +00:00
|
|
|
{
|
2012-06-05 20:31:31 +00:00
|
|
|
struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
|
2010-12-13 11:19:28 +00:00
|
|
|
|
2012-06-03 20:19:19 +00:00
|
|
|
if ((hard_iface->if_status == BATADV_IF_NOT_IN_USE) ||
|
|
|
|
(hard_iface->if_status == BATADV_IF_TO_BE_REMOVED))
|
2010-12-13 11:19:28 +00:00
|
|
|
return;
|
|
|
|
|
2012-05-12 00:09:43 +00:00
|
|
|
/* the interface gets activated here to avoid race conditions between
|
2010-12-13 11:19:28 +00:00
|
|
|
* the moment of activating the interface in
|
|
|
|
* hardif_activate_interface() where the originator mac is set and
|
|
|
|
* outdated packets (especially uninitialized mac addresses) in the
|
|
|
|
* packet queue
|
|
|
|
*/
|
2012-06-03 20:19:19 +00:00
|
|
|
if (hard_iface->if_status == BATADV_IF_TO_BE_ACTIVATED)
|
|
|
|
hard_iface->if_status = BATADV_IF_ACTIVE;
|
2010-12-13 11:19:28 +00:00
|
|
|
|
2012-05-06 20:22:05 +00:00
|
|
|
bat_priv->bat_algo_ops->bat_ogm_schedule(hard_iface);
|
2010-12-13 11:19:28 +00:00
|
|
|
}
|
|
|
|
|
2012-06-05 20:31:31 +00:00
|
|
|
static void batadv_forw_packet_free(struct batadv_forw_packet *forw_packet)
|
2010-12-13 11:19:28 +00:00
|
|
|
{
|
|
|
|
if (forw_packet->skb)
|
|
|
|
kfree_skb(forw_packet->skb);
|
2011-05-11 18:59:06 +00:00
|
|
|
if (forw_packet->if_incoming)
|
2012-05-12 11:48:54 +00:00
|
|
|
batadv_hardif_free_ref(forw_packet->if_incoming);
|
2010-12-13 11:19:28 +00:00
|
|
|
kfree(forw_packet);
|
|
|
|
}
|
|
|
|
|
2012-06-05 20:31:31 +00:00
|
|
|
static void
|
|
|
|
_batadv_add_bcast_packet_to_list(struct batadv_priv *bat_priv,
|
|
|
|
struct batadv_forw_packet *forw_packet,
|
|
|
|
unsigned long send_time)
|
2010-12-13 11:19:28 +00:00
|
|
|
{
|
|
|
|
/* add new packet to packet list */
|
|
|
|
spin_lock_bh(&bat_priv->forw_bcast_list_lock);
|
|
|
|
hlist_add_head(&forw_packet->list, &bat_priv->forw_bcast_list);
|
|
|
|
spin_unlock_bh(&bat_priv->forw_bcast_list_lock);
|
|
|
|
|
|
|
|
/* start timer for this packet */
|
2012-05-12 00:09:42 +00:00
|
|
|
queue_delayed_work(batadv_event_workqueue, &forw_packet->delayed_work,
|
2010-12-13 11:19:28 +00:00
|
|
|
send_time);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* add a broadcast packet to the queue and setup timers. broadcast packets
|
2011-07-09 15:52:13 +00:00
|
|
|
* are sent multiple times to increase probability for being received.
|
2010-12-13 11:19:28 +00:00
|
|
|
*
|
|
|
|
* This function returns NETDEV_TX_OK on success and NETDEV_TX_BUSY on
|
|
|
|
* errors.
|
|
|
|
*
|
|
|
|
* The skb is not consumed, so the caller should make sure that the
|
2012-05-12 00:09:43 +00:00
|
|
|
* skb is freed.
|
|
|
|
*/
|
2012-06-05 20:31:31 +00:00
|
|
|
int batadv_add_bcast_packet_to_list(struct batadv_priv *bat_priv,
|
2012-05-12 00:09:37 +00:00
|
|
|
const struct sk_buff *skb,
|
|
|
|
unsigned long delay)
|
2010-12-13 11:19:28 +00:00
|
|
|
{
|
2012-06-05 20:31:31 +00:00
|
|
|
struct batadv_hard_iface *primary_if = NULL;
|
|
|
|
struct batadv_forw_packet *forw_packet;
|
2012-06-05 20:31:30 +00:00
|
|
|
struct batadv_bcast_packet *bcast_packet;
|
2011-05-14 21:14:50 +00:00
|
|
|
struct sk_buff *newskb;
|
2010-12-13 11:19:28 +00:00
|
|
|
|
2012-05-16 18:23:22 +00:00
|
|
|
if (!batadv_atomic_dec_not_zero(&bat_priv->bcast_queue_left)) {
|
2012-06-03 20:19:22 +00:00
|
|
|
batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
|
|
|
|
"bcast packet queue full\n");
|
2010-12-13 11:19:28 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2012-05-12 11:48:54 +00:00
|
|
|
primary_if = batadv_primary_if_get_selected(bat_priv);
|
2011-04-20 13:40:58 +00:00
|
|
|
if (!primary_if)
|
2011-05-14 18:01:22 +00:00
|
|
|
goto out_and_inc;
|
2010-12-13 11:19:28 +00:00
|
|
|
|
2011-05-14 21:14:54 +00:00
|
|
|
forw_packet = kmalloc(sizeof(*forw_packet), GFP_ATOMIC);
|
2010-12-13 11:19:28 +00:00
|
|
|
|
|
|
|
if (!forw_packet)
|
|
|
|
goto out_and_inc;
|
|
|
|
|
2011-05-14 21:14:50 +00:00
|
|
|
newskb = skb_copy(skb, GFP_ATOMIC);
|
|
|
|
if (!newskb)
|
2010-12-13 11:19:28 +00:00
|
|
|
goto packet_free;
|
|
|
|
|
|
|
|
/* as we have a copy now, it is safe to decrease the TTL */
|
2012-06-05 20:31:30 +00:00
|
|
|
bcast_packet = (struct batadv_bcast_packet *)newskb->data;
|
2011-11-20 14:47:38 +00:00
|
|
|
bcast_packet->header.ttl--;
|
2010-12-13 11:19:28 +00:00
|
|
|
|
2011-05-14 21:14:50 +00:00
|
|
|
skb_reset_mac_header(newskb);
|
2010-12-13 11:19:28 +00:00
|
|
|
|
2011-05-14 21:14:50 +00:00
|
|
|
forw_packet->skb = newskb;
|
2011-04-20 13:40:58 +00:00
|
|
|
forw_packet->if_incoming = primary_if;
|
2010-12-13 11:19:28 +00:00
|
|
|
|
|
|
|
/* how often did we send the bcast packet ? */
|
|
|
|
forw_packet->num_packets = 0;
|
|
|
|
|
2012-12-25 12:14:37 +00:00
|
|
|
INIT_DELAYED_WORK(&forw_packet->delayed_work,
|
|
|
|
batadv_send_outstanding_bcast_packet);
|
|
|
|
|
2012-05-16 18:23:14 +00:00
|
|
|
_batadv_add_bcast_packet_to_list(bat_priv, forw_packet, delay);
|
2010-12-13 11:19:28 +00:00
|
|
|
return NETDEV_TX_OK;
|
|
|
|
|
|
|
|
packet_free:
|
|
|
|
kfree(forw_packet);
|
|
|
|
out_and_inc:
|
|
|
|
atomic_inc(&bat_priv->bcast_queue_left);
|
|
|
|
out:
|
2011-04-20 13:40:58 +00:00
|
|
|
if (primary_if)
|
2012-05-12 11:48:54 +00:00
|
|
|
batadv_hardif_free_ref(primary_if);
|
2010-12-13 11:19:28 +00:00
|
|
|
return NETDEV_TX_BUSY;
|
|
|
|
}
|
|
|
|
|
2012-05-16 18:23:14 +00:00
|
|
|
static void batadv_send_outstanding_bcast_packet(struct work_struct *work)
|
2010-12-13 11:19:28 +00:00
|
|
|
{
|
2012-06-05 20:31:31 +00:00
|
|
|
struct batadv_hard_iface *hard_iface;
|
2012-07-08 15:13:15 +00:00
|
|
|
struct delayed_work *delayed_work;
|
2012-06-05 20:31:31 +00:00
|
|
|
struct batadv_forw_packet *forw_packet;
|
2010-12-13 11:19:28 +00:00
|
|
|
struct sk_buff *skb1;
|
2012-06-05 20:31:31 +00:00
|
|
|
struct net_device *soft_iface;
|
|
|
|
struct batadv_priv *bat_priv;
|
|
|
|
|
2012-07-08 15:13:15 +00:00
|
|
|
delayed_work = container_of(work, struct delayed_work, work);
|
2012-06-05 20:31:31 +00:00
|
|
|
forw_packet = container_of(delayed_work, struct batadv_forw_packet,
|
|
|
|
delayed_work);
|
|
|
|
soft_iface = forw_packet->if_incoming->soft_iface;
|
|
|
|
bat_priv = netdev_priv(soft_iface);
|
2010-12-13 11:19:28 +00:00
|
|
|
|
|
|
|
spin_lock_bh(&bat_priv->forw_bcast_list_lock);
|
|
|
|
hlist_del(&forw_packet->list);
|
|
|
|
spin_unlock_bh(&bat_priv->forw_bcast_list_lock);
|
|
|
|
|
2012-06-03 20:19:22 +00:00
|
|
|
if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_DEACTIVATING)
|
2010-12-13 11:19:28 +00:00
|
|
|
goto out;
|
|
|
|
|
2011-06-26 01:37:18 +00:00
|
|
|
if (batadv_dat_drop_broadcast_packet(bat_priv, forw_packet))
|
|
|
|
goto out;
|
|
|
|
|
2010-12-13 11:19:28 +00:00
|
|
|
/* rebroadcast packet */
|
|
|
|
rcu_read_lock();
|
2012-05-12 00:09:42 +00:00
|
|
|
list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
|
2011-02-18 12:33:20 +00:00
|
|
|
if (hard_iface->soft_iface != soft_iface)
|
2010-12-13 11:19:28 +00:00
|
|
|
continue;
|
|
|
|
|
2013-03-09 22:14:23 +00:00
|
|
|
if (forw_packet->num_packets >= hard_iface->num_bcasts)
|
|
|
|
continue;
|
|
|
|
|
2010-12-13 11:19:28 +00:00
|
|
|
/* send a copy of the saved skb */
|
|
|
|
skb1 = skb_clone(forw_packet->skb, GFP_ATOMIC);
|
|
|
|
if (skb1)
|
2012-05-12 00:09:37 +00:00
|
|
|
batadv_send_skb_packet(skb1, hard_iface,
|
2012-05-12 00:09:42 +00:00
|
|
|
batadv_broadcast_addr);
|
2010-12-13 11:19:28 +00:00
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
forw_packet->num_packets++;
|
|
|
|
|
|
|
|
/* if we still have some more bcasts to send */
|
2013-03-09 22:14:23 +00:00
|
|
|
if (forw_packet->num_packets < BATADV_NUM_BCASTS_MAX) {
|
2012-05-16 18:23:14 +00:00
|
|
|
_batadv_add_bcast_packet_to_list(bat_priv, forw_packet,
|
|
|
|
msecs_to_jiffies(5));
|
2010-12-13 11:19:28 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
2012-05-16 18:23:14 +00:00
|
|
|
batadv_forw_packet_free(forw_packet);
|
2010-12-13 11:19:28 +00:00
|
|
|
atomic_inc(&bat_priv->bcast_queue_left);
|
|
|
|
}
|
|
|
|
|
2012-05-12 00:09:37 +00:00
|
|
|
void batadv_send_outstanding_bat_ogm_packet(struct work_struct *work)
|
2010-12-13 11:19:28 +00:00
|
|
|
{
|
2012-07-08 15:13:15 +00:00
|
|
|
struct delayed_work *delayed_work;
|
2012-06-05 20:31:31 +00:00
|
|
|
struct batadv_forw_packet *forw_packet;
|
|
|
|
struct batadv_priv *bat_priv;
|
2010-12-13 11:19:28 +00:00
|
|
|
|
2012-07-08 15:13:15 +00:00
|
|
|
delayed_work = container_of(work, struct delayed_work, work);
|
2012-06-05 20:31:31 +00:00
|
|
|
forw_packet = container_of(delayed_work, struct batadv_forw_packet,
|
|
|
|
delayed_work);
|
2010-12-13 11:19:28 +00:00
|
|
|
bat_priv = netdev_priv(forw_packet->if_incoming->soft_iface);
|
|
|
|
spin_lock_bh(&bat_priv->forw_bat_list_lock);
|
|
|
|
hlist_del(&forw_packet->list);
|
|
|
|
spin_unlock_bh(&bat_priv->forw_bat_list_lock);
|
|
|
|
|
2012-06-03 20:19:22 +00:00
|
|
|
if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_DEACTIVATING)
|
2010-12-13 11:19:28 +00:00
|
|
|
goto out;
|
|
|
|
|
2011-11-28 13:31:55 +00:00
|
|
|
bat_priv->bat_algo_ops->bat_ogm_emit(forw_packet);
|
2010-12-13 11:19:28 +00:00
|
|
|
|
2012-05-12 00:09:43 +00:00
|
|
|
/* we have to have at least one packet in the queue
|
2010-12-13 11:19:28 +00:00
|
|
|
* to determine the queues wake up time unless we are
|
|
|
|
* shutting down
|
|
|
|
*/
|
|
|
|
if (forw_packet->own)
|
2012-05-12 00:09:37 +00:00
|
|
|
batadv_schedule_bat_ogm(forw_packet->if_incoming);
|
2010-12-13 11:19:28 +00:00
|
|
|
|
|
|
|
out:
|
|
|
|
/* don't count own packet */
|
|
|
|
if (!forw_packet->own)
|
|
|
|
atomic_inc(&bat_priv->batman_queue_left);
|
|
|
|
|
2012-05-16 18:23:14 +00:00
|
|
|
batadv_forw_packet_free(forw_packet);
|
2010-12-13 11:19:28 +00:00
|
|
|
}
|
|
|
|
|
2012-06-05 20:31:31 +00:00
|
|
|
void
|
|
|
|
batadv_purge_outstanding_packets(struct batadv_priv *bat_priv,
|
|
|
|
const struct batadv_hard_iface *hard_iface)
|
2010-12-13 11:19:28 +00:00
|
|
|
{
|
2012-06-05 20:31:31 +00:00
|
|
|
struct batadv_forw_packet *forw_packet;
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 01:06:00 +00:00
|
|
|
struct hlist_node *safe_tmp_node;
|
2011-05-11 18:59:06 +00:00
|
|
|
bool pending;
|
2010-12-13 11:19:28 +00:00
|
|
|
|
2011-02-18 12:33:20 +00:00
|
|
|
if (hard_iface)
|
2012-06-03 20:19:22 +00:00
|
|
|
batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
|
2012-05-12 11:48:58 +00:00
|
|
|
"purge_outstanding_packets(): %s\n",
|
|
|
|
hard_iface->net_dev->name);
|
2010-12-13 11:19:28 +00:00
|
|
|
else
|
2012-06-03 20:19:22 +00:00
|
|
|
batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
|
2012-05-12 11:48:58 +00:00
|
|
|
"purge_outstanding_packets()\n");
|
2010-12-13 11:19:28 +00:00
|
|
|
|
|
|
|
/* free bcast list */
|
|
|
|
spin_lock_bh(&bat_priv->forw_bcast_list_lock);
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 01:06:00 +00:00
|
|
|
hlist_for_each_entry_safe(forw_packet, safe_tmp_node,
|
2010-12-13 11:19:28 +00:00
|
|
|
&bat_priv->forw_bcast_list, list) {
|
2012-05-12 00:09:43 +00:00
|
|
|
/* if purge_outstanding_packets() was called with an argument
|
2010-12-13 11:19:28 +00:00
|
|
|
* we delete only packets belonging to the given interface
|
|
|
|
*/
|
2011-02-18 12:33:20 +00:00
|
|
|
if ((hard_iface) &&
|
|
|
|
(forw_packet->if_incoming != hard_iface))
|
2010-12-13 11:19:28 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
spin_unlock_bh(&bat_priv->forw_bcast_list_lock);
|
|
|
|
|
2012-05-16 18:23:14 +00:00
|
|
|
/* batadv_send_outstanding_bcast_packet() will lock the list to
|
2010-12-13 11:19:28 +00:00
|
|
|
* delete the item from the list
|
|
|
|
*/
|
2011-05-11 18:59:06 +00:00
|
|
|
pending = cancel_delayed_work_sync(&forw_packet->delayed_work);
|
2010-12-13 11:19:28 +00:00
|
|
|
spin_lock_bh(&bat_priv->forw_bcast_list_lock);
|
2011-05-11 18:59:06 +00:00
|
|
|
|
|
|
|
if (pending) {
|
|
|
|
hlist_del(&forw_packet->list);
|
2012-05-16 18:23:14 +00:00
|
|
|
batadv_forw_packet_free(forw_packet);
|
2011-05-11 18:59:06 +00:00
|
|
|
}
|
2010-12-13 11:19:28 +00:00
|
|
|
}
|
|
|
|
spin_unlock_bh(&bat_priv->forw_bcast_list_lock);
|
|
|
|
|
|
|
|
/* free batman packet list */
|
|
|
|
spin_lock_bh(&bat_priv->forw_bat_list_lock);
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 01:06:00 +00:00
|
|
|
hlist_for_each_entry_safe(forw_packet, safe_tmp_node,
|
2010-12-13 11:19:28 +00:00
|
|
|
&bat_priv->forw_bat_list, list) {
|
2012-05-12 00:09:43 +00:00
|
|
|
/* if purge_outstanding_packets() was called with an argument
|
2010-12-13 11:19:28 +00:00
|
|
|
* we delete only packets belonging to the given interface
|
|
|
|
*/
|
2011-02-18 12:33:20 +00:00
|
|
|
if ((hard_iface) &&
|
|
|
|
(forw_packet->if_incoming != hard_iface))
|
2010-12-13 11:19:28 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
spin_unlock_bh(&bat_priv->forw_bat_list_lock);
|
|
|
|
|
2012-05-12 00:09:43 +00:00
|
|
|
/* send_outstanding_bat_packet() will lock the list to
|
2010-12-13 11:19:28 +00:00
|
|
|
* delete the item from the list
|
|
|
|
*/
|
2011-05-11 18:59:06 +00:00
|
|
|
pending = cancel_delayed_work_sync(&forw_packet->delayed_work);
|
2010-12-13 11:19:28 +00:00
|
|
|
spin_lock_bh(&bat_priv->forw_bat_list_lock);
|
2011-05-11 18:59:06 +00:00
|
|
|
|
|
|
|
if (pending) {
|
|
|
|
hlist_del(&forw_packet->list);
|
2012-05-16 18:23:14 +00:00
|
|
|
batadv_forw_packet_free(forw_packet);
|
2011-05-11 18:59:06 +00:00
|
|
|
}
|
2010-12-13 11:19:28 +00:00
|
|
|
}
|
|
|
|
spin_unlock_bh(&bat_priv->forw_bat_list_lock);
|
|
|
|
}
|