bonding: move processing of recv handlers into handle_frame() (3aba891d) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/net/bonding/bond_3ad.c

+5 −24

Original line number	Original line	Diff line number	Diff line
	@@ -2465,35 +2465,16 @@ out:
	return NETDEV_TX_OK;		return NETDEV_TX_OK;
	}		}

	int bond_3ad_lacpdu_recv(struct sk_buff skb, struct net_device dev, struct packet_type* ptype, struct net_device *orig_dev)		void bond_3ad_lacpdu_recv(struct sk_buff skb, struct bonding bond,
			struct slave *slave)
	{		{
	struct bonding *bond = netdev_priv(dev);		if (skb->protocol != PKT_TYPE_LACPDU)
	struct slave *slave = NULL;		return;
	int ret = NET_RX_DROP;

	if (!(dev->flags & IFF_MASTER))
	goto out;

	skb = skb_share_check(skb, GFP_ATOMIC);
	if (!skb)
	goto out;

	if (!pskb_may_pull(skb, sizeof(struct lacpdu)))		if (!pskb_may_pull(skb, sizeof(struct lacpdu)))
	goto out;		return;

	read_lock(&bond->lock);		read_lock(&bond->lock);
	slave = bond_get_slave_by_dev(netdev_priv(dev), orig_dev);
	if (!slave)
	goto out_unlock;

	bond_3ad_rx_indication((struct lacpdu *) skb->data, slave, skb->len);		bond_3ad_rx_indication((struct lacpdu *) skb->data, slave, skb->len);

	ret = NET_RX_SUCCESS;

	out_unlock:
	read_unlock(&bond->lock);		read_unlock(&bond->lock);
	out:
	dev_kfree_skb(skb);

	return ret;
	}		}

drivers/net/bonding/bond_3ad.h

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -258,7 +258,6 @@ struct ad_bond_info {
	* requested		* requested
	*/		*/
	struct timer_list ad_timer;		struct timer_list ad_timer;
	struct packet_type ad_pkt_type;
	};		};

	struct ad_slave_info {		struct ad_slave_info {
	@@ -280,7 +279,8 @@ void bond_3ad_adapter_duplex_changed(struct slave *slave);
	void bond_3ad_handle_link_change(struct slave *slave, char link);		void bond_3ad_handle_link_change(struct slave *slave, char link);
	int bond_3ad_get_active_agg_info(struct bonding bond, struct ad_info ad_info);		int bond_3ad_get_active_agg_info(struct bonding bond, struct ad_info ad_info);
	int bond_3ad_xmit_xor(struct sk_buff skb, struct net_device dev);		int bond_3ad_xmit_xor(struct sk_buff skb, struct net_device dev);
	int bond_3ad_lacpdu_recv(struct sk_buff skb, struct net_device dev, struct packet_type* ptype, struct net_device *orig_dev);		void bond_3ad_lacpdu_recv(struct sk_buff skb, struct bonding bond,
			struct slave *slave);
	int bond_3ad_set_carrier(struct bonding *bond);		int bond_3ad_set_carrier(struct bonding *bond);
	#endif //__BOND_3AD_H__		#endif //__BOND_3AD_H__

drivers/net/bonding/bond_alb.c

+11 −35

Original line number	Original line	Diff line number	Diff line
	@@ -308,49 +308,33 @@ static void rlb_update_entry_from_arp(struct bonding bond, struct arp_pkt arp)
	_unlock_rx_hashtbl(bond);		_unlock_rx_hashtbl(bond);
	}		}

	static int rlb_arp_recv(struct sk_buff skb, struct net_device bond_dev, struct packet_type ptype, struct net_device orig_dev)		static void rlb_arp_recv(struct sk_buff skb, struct bonding bond,
			struct slave *slave)
	{		{
	struct bonding *bond;		struct arp_pkt *arp;
	struct arp_pkt arp = (struct arp_pkt )skb->data;
	int res = NET_RX_DROP;

	while (bond_dev->priv_flags & IFF_802_1Q_VLAN)		if (skb->protocol != cpu_to_be16(ETH_P_ARP))
	bond_dev = vlan_dev_real_dev(bond_dev);		return;

	if (!(bond_dev->priv_flags & IFF_BONDING) \|\|
	!(bond_dev->flags & IFF_MASTER))
	goto out;

			arp = (struct arp_pkt *) skb->data;
	if (!arp) {		if (!arp) {
	pr_debug("Packet has no ARP data\n");		pr_debug("Packet has no ARP data\n");
	goto out;		return;
	}		}

	skb = skb_share_check(skb, GFP_ATOMIC);		if (!pskb_may_pull(skb, arp_hdr_len(bond->dev)))
	if (!skb)		return;
	goto out;

	if (!pskb_may_pull(skb, arp_hdr_len(bond_dev)))
	goto out;

	if (skb->len < sizeof(struct arp_pkt)) {		if (skb->len < sizeof(struct arp_pkt)) {
	pr_debug("Packet is too small to be an ARP\n");		pr_debug("Packet is too small to be an ARP\n");
	goto out;		return;
	}		}

	if (arp->op_code == htons(ARPOP_REPLY)) {		if (arp->op_code == htons(ARPOP_REPLY)) {
	/* update rx hash table for this ARP */		/* update rx hash table for this ARP */
	bond = netdev_priv(bond_dev);
	rlb_update_entry_from_arp(bond, arp);		rlb_update_entry_from_arp(bond, arp);
	pr_debug("Server received an ARP Reply from client\n");		pr_debug("Server received an ARP Reply from client\n");
	}		}

	res = NET_RX_SUCCESS;

	out:
	dev_kfree_skb(skb);

	return res;
	}		}

	/* Caller must hold bond lock for read */		/* Caller must hold bond lock for read */
	@@ -759,7 +743,6 @@ static void rlb_init_table_entry(struct rlb_client_info *entry)
	static int rlb_initialize(struct bonding *bond)		static int rlb_initialize(struct bonding *bond)
	{		{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));		struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
	struct packet_type *pk_type = &(BOND_ALB_INFO(bond).rlb_pkt_type);
	struct rlb_client_info *new_hashtbl;		struct rlb_client_info *new_hashtbl;
	int size = RLB_HASH_TABLE_SIZE * sizeof(struct rlb_client_info);		int size = RLB_HASH_TABLE_SIZE * sizeof(struct rlb_client_info);
	int i;		int i;
	@@ -784,13 +767,8 @@ static int rlb_initialize(struct bonding *bond)

	_unlock_rx_hashtbl(bond);		_unlock_rx_hashtbl(bond);

	/initialize packet type/
	pk_type->type = cpu_to_be16(ETH_P_ARP);
	pk_type->dev = bond->dev;
	pk_type->func = rlb_arp_recv;

	/* register to receive ARPs */		/* register to receive ARPs */
	dev_add_pack(pk_type);		bond->recv_probe = rlb_arp_recv;

	return 0;		return 0;
	}		}
	@@ -799,8 +777,6 @@ static void rlb_deinitialize(struct bonding *bond)
	{		{
	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));		struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));

	dev_remove_pack(&(bond_info->rlb_pkt_type));

	_lock_rx_hashtbl(bond);		_lock_rx_hashtbl(bond);

	kfree(bond_info->rx_hashtbl);		kfree(bond_info->rx_hashtbl);

drivers/net/bonding/bond_alb.h

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -129,7 +129,6 @@ struct alb_bond_info {
	int lp_counter;		int lp_counter;
	/* -------- rlb parameters -------- */		/* -------- rlb parameters -------- */
	int rlb_enabled;		int rlb_enabled;
	struct packet_type rlb_pkt_type;
	struct rlb_client_info rx_hashtbl; / Receive hash table */		struct rlb_client_info rx_hashtbl; / Receive hash table */
	spinlock_t rx_hashtbl_lock;		spinlock_t rx_hashtbl_lock;
	u32 rx_hashtbl_head;		u32 rx_hashtbl_head;

drivers/net/bonding/bond_main.c

+23 −98

Original line number	Original line	Diff line number	Diff line
	@@ -1439,27 +1439,17 @@ static void bond_setup_by_slave(struct net_device *bond_dev,
	}		}

	/* On bonding slaves other than the currently active slave, suppress		/* On bonding slaves other than the currently active slave, suppress
	* duplicates except for 802.3ad ETH_P_SLOW, alb non-mcast/bcast, and		* duplicates except for alb non-mcast/bcast.
	* ARP on active-backup slaves with arp_validate enabled.
	*/		*/
	static bool bond_should_deliver_exact_match(struct sk_buff *skb,		static bool bond_should_deliver_exact_match(struct sk_buff *skb,
	struct slave *slave,		struct slave *slave,
	struct bonding *bond)		struct bonding *bond)
	{		{
	if (bond_is_slave_inactive(slave)) {		if (bond_is_slave_inactive(slave)) {
	if (slave_do_arp_validate(bond, slave) &&
	skb->protocol == __cpu_to_be16(ETH_P_ARP))
	return false;

	if (bond->params.mode == BOND_MODE_ALB &&		if (bond->params.mode == BOND_MODE_ALB &&
	skb->pkt_type != PACKET_BROADCAST &&		skb->pkt_type != PACKET_BROADCAST &&
	skb->pkt_type != PACKET_MULTICAST)		skb->pkt_type != PACKET_MULTICAST)
	return false;		return false;

	if (bond->params.mode == BOND_MODE_8023AD &&
	skb->protocol == __cpu_to_be16(ETH_P_SLOW))
	return false;

	return true;		return true;
	}		}
	return false;		return false;
	@@ -1483,6 +1473,15 @@ static rx_handler_result_t bond_handle_frame(struct sk_buff **pskb)
	if (bond->params.arp_interval)		if (bond->params.arp_interval)
	slave->dev->last_rx = jiffies;		slave->dev->last_rx = jiffies;

			if (bond->recv_probe) {
			struct sk_buff *nskb = skb_clone(skb, GFP_ATOMIC);

			if (likely(nskb)) {
			bond->recv_probe(nskb, bond, slave);
			dev_kfree_skb(nskb);
			}
			}

	if (bond_should_deliver_exact_match(skb, slave, bond)) {		if (bond_should_deliver_exact_match(skb, slave, bond)) {
	return RX_HANDLER_EXACT;		return RX_HANDLER_EXACT;
	}		}
	@@ -2743,48 +2742,26 @@ static void bond_validate_arp(struct bonding bond, struct slave slave, __be32
	}		}
	}		}

	static int bond_arp_rcv(struct sk_buff skb, struct net_device dev, struct packet_type pt, struct net_device orig_dev)		static void bond_arp_rcv(struct sk_buff skb, struct bonding bond,
			struct slave *slave)
	{		{
	struct arphdr *arp;		struct arphdr *arp;
	struct slave *slave;
	struct bonding *bond;
	unsigned char *arp_ptr;		unsigned char *arp_ptr;
	__be32 sip, tip;		__be32 sip, tip;

	if (dev->priv_flags & IFF_802_1Q_VLAN) {		if (skb->protocol != __cpu_to_be16(ETH_P_ARP))
	/*		return;
	* When using VLANS and bonding, dev and oriv_dev may be
	* incorrect if the physical interface supports VLAN
	* acceleration. With this change ARP validation now
	* works for hosts only reachable on the VLAN interface.
	*/
	dev = vlan_dev_real_dev(dev);
	orig_dev = dev_get_by_index_rcu(dev_net(skb->dev),skb->skb_iif);
	}

	if (!(dev->priv_flags & IFF_BONDING) \|\| !(dev->flags & IFF_MASTER))
	goto out;

	bond = netdev_priv(dev);
	read_lock(&bond->lock);		read_lock(&bond->lock);

	pr_debug("bond_arp_rcv: bond %s skb->dev %s orig_dev %s\n",		pr_debug("bond_arp_rcv: bond %s skb->dev %s\n",
	bond->dev->name, skb->dev ? skb->dev->name : "NULL",		bond->dev->name, skb->dev->name);
	orig_dev ? orig_dev->name : "NULL");

	slave = bond_get_slave_by_dev(bond, orig_dev);
	if (!slave \|\| !slave_do_arp_validate(bond, slave))
	goto out_unlock;

	skb = skb_share_check(skb, GFP_ATOMIC);
	if (!skb)
	goto out_unlock;

	if (!pskb_may_pull(skb, arp_hdr_len(dev)))		if (!pskb_may_pull(skb, arp_hdr_len(bond->dev)))
	goto out_unlock;		goto out_unlock;

	arp = arp_hdr(skb);		arp = arp_hdr(skb);
	if (arp->ar_hln != dev->addr_len \|\|		if (arp->ar_hln != bond->dev->addr_len \|\|
	skb->pkt_type == PACKET_OTHERHOST \|\|		skb->pkt_type == PACKET_OTHERHOST \|\|
	skb->pkt_type == PACKET_LOOPBACK \|\|		skb->pkt_type == PACKET_LOOPBACK \|\|
	arp->ar_hrd != htons(ARPHRD_ETHER) \|\|		arp->ar_hrd != htons(ARPHRD_ETHER) \|\|
	@@ -2793,9 +2770,9 @@ static int bond_arp_rcv(struct sk_buff skb, struct net_device dev, struct pack
	goto out_unlock;		goto out_unlock;

	arp_ptr = (unsigned char *)(arp + 1);		arp_ptr = (unsigned char *)(arp + 1);
	arp_ptr += dev->addr_len;		arp_ptr += bond->dev->addr_len;
	memcpy(&sip, arp_ptr, 4);		memcpy(&sip, arp_ptr, 4);
	arp_ptr += 4 + dev->addr_len;		arp_ptr += 4 + bond->dev->addr_len;
	memcpy(&tip, arp_ptr, 4);		memcpy(&tip, arp_ptr, 4);

	pr_debug("bond_arp_rcv: %s %s/%d av %d sv %d sip %pI4 tip %pI4\n",		pr_debug("bond_arp_rcv: %s %s/%d av %d sv %d sip %pI4 tip %pI4\n",
	@@ -2818,9 +2795,6 @@ static int bond_arp_rcv(struct sk_buff skb, struct net_device dev, struct pack

	out_unlock:		out_unlock:
	read_unlock(&bond->lock);		read_unlock(&bond->lock);
	out:
	dev_kfree_skb(skb);
	return NET_RX_SUCCESS;
	}		}

	/*		/*
	@@ -3407,48 +3381,6 @@ static struct notifier_block bond_inetaddr_notifier = {
	.notifier_call = bond_inetaddr_event,		.notifier_call = bond_inetaddr_event,
	};		};

	/-------------------------- Packet type handling ---------------------------/

	/* register to receive lacpdus on a bond */
	static void bond_register_lacpdu(struct bonding *bond)
	{
	struct packet_type *pk_type = &(BOND_AD_INFO(bond).ad_pkt_type);

	/* initialize packet type */
	pk_type->type = PKT_TYPE_LACPDU;
	pk_type->dev = bond->dev;
	pk_type->func = bond_3ad_lacpdu_recv;

	dev_add_pack(pk_type);
	}

	/* unregister to receive lacpdus on a bond */
	static void bond_unregister_lacpdu(struct bonding *bond)
	{
	dev_remove_pack(&(BOND_AD_INFO(bond).ad_pkt_type));
	}

	void bond_register_arp(struct bonding *bond)
	{
	struct packet_type *pt = &bond->arp_mon_pt;

	if (pt->type)
	return;

	pt->type = htons(ETH_P_ARP);
	pt->dev = bond->dev;
	pt->func = bond_arp_rcv;
	dev_add_pack(pt);
	}

	void bond_unregister_arp(struct bonding *bond)
	{
	struct packet_type *pt = &bond->arp_mon_pt;

	dev_remove_pack(pt);
	pt->type = 0;
	}

	/---------------------------- Hashing Policies -----------------------------/		/---------------------------- Hashing Policies -----------------------------/

	/*		/*
	@@ -3542,14 +3474,14 @@ static int bond_open(struct net_device *bond_dev)

	queue_delayed_work(bond->wq, &bond->arp_work, 0);		queue_delayed_work(bond->wq, &bond->arp_work, 0);
	if (bond->params.arp_validate)		if (bond->params.arp_validate)
	bond_register_arp(bond);		bond->recv_probe = bond_arp_rcv;
	}		}

	if (bond->params.mode == BOND_MODE_8023AD) {		if (bond->params.mode == BOND_MODE_8023AD) {
	INIT_DELAYED_WORK(&bond->ad_work, bond_3ad_state_machine_handler);		INIT_DELAYED_WORK(&bond->ad_work, bond_3ad_state_machine_handler);
	queue_delayed_work(bond->wq, &bond->ad_work, 0);		queue_delayed_work(bond->wq, &bond->ad_work, 0);
	/* register to receive LACPDUs */		/* register to receive LACPDUs */
	bond_register_lacpdu(bond);		bond->recv_probe = bond_3ad_lacpdu_recv;
	bond_3ad_initiate_agg_selection(bond, 1);		bond_3ad_initiate_agg_selection(bond, 1);
	}		}

	@@ -3560,14 +3492,6 @@ static int bond_close(struct net_device *bond_dev)
	{		{
	struct bonding *bond = netdev_priv(bond_dev);		struct bonding *bond = netdev_priv(bond_dev);

	if (bond->params.mode == BOND_MODE_8023AD) {
	/* Unregister the receive of LACPDUs */
	bond_unregister_lacpdu(bond);
	}

	if (bond->params.arp_validate)
	bond_unregister_arp(bond);

	write_lock_bh(&bond->lock);		write_lock_bh(&bond->lock);

	/* signal timers not to re-arm */		/* signal timers not to re-arm */
	@@ -3604,6 +3528,7 @@ static int bond_close(struct net_device *bond_dev)
	*/		*/
	bond_alb_deinitialize(bond);		bond_alb_deinitialize(bond);
	}		}
			bond->recv_probe = NULL;

	return 0;		return 0;
	}		}