_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 *)skb->data;
-       int res = NET_RX_DROP;
+       struct arp_pkt *arp;
 
-       while (bond_dev->priv_flags & IFF_802_1Q_VLAN)
-               bond_dev = vlan_dev_real_dev(bond_dev);
-
-       if (!(bond_dev->priv_flags & IFF_BONDING) ||
-           !(bond_dev->flags & IFF_MASTER))
-               goto out;
+       if (skb->protocol != cpu_to_be16(ETH_P_ARP))
+               return;
 
+       arp = (struct arp_pkt *) skb->data;
        if (!arp) {
                pr_debug("Packet has no ARP data\n");
-               goto out;
+               return;
        }
 
-       skb = skb_share_check(skb, GFP_ATOMIC);
-       if (!skb)
-               goto out;
-
-       if (!pskb_may_pull(skb, arp_hdr_len(bond_dev)))
-               goto out;
+       if (!pskb_may_pull(skb, arp_hdr_len(bond->dev)))
+               return;
 
        if (skb->len < sizeof(struct arp_pkt)) {
                pr_debug("Packet is too small to be an ARP\n");
-               goto out;
+               return;
        }
 
        if (arp->op_code == htons(ARPOP_REPLY)) {
                /* update rx hash table for this ARP */
-               bond = netdev_priv(bond_dev);
                rlb_update_entry_from_arp(bond, arp);
                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 */
 static int rlb_initialize(struct bonding *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;
        int size = RLB_HASH_TABLE_SIZE * sizeof(struct rlb_client_info);
        int i;
 
        _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 */
-       dev_add_pack(pk_type);
+       bond->recv_probe = rlb_arp_recv;
 
        return 0;
 }
 {
        struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
 
-       dev_remove_pack(&(bond_info->rlb_pkt_type));
-
        _lock_rx_hashtbl(bond);
 
        kfree(bond_info->rx_hashtbl);
 
 }
 
 /* On bonding slaves other than the currently active slave, suppress
- * duplicates except for 802.3ad ETH_P_SLOW, alb non-mcast/bcast, and
- * ARP on active-backup slaves with arp_validate enabled.
+ * duplicates except for alb non-mcast/bcast.
  */
 static bool bond_should_deliver_exact_match(struct sk_buff *skb,
                                            struct slave *slave,
                                            struct bonding *bond)
 {
        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 &&
                    skb->pkt_type != PACKET_BROADCAST &&
                    skb->pkt_type != PACKET_MULTICAST)
-                               return false;
-
-               if (bond->params.mode == BOND_MODE_8023AD &&
-                   skb->protocol == __cpu_to_be16(ETH_P_SLOW))
                        return false;
-
                return true;
        }
        return false;
        if (bond->params.arp_interval)
                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)) {
                return RX_HANDLER_EXACT;
        }
        }
 }
 
-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 slave *slave;
-       struct bonding *bond;
        unsigned char *arp_ptr;
        __be32 sip, tip;
 
-       if (dev->priv_flags & IFF_802_1Q_VLAN) {
-               /*
-                * 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;
+       if (skb->protocol != __cpu_to_be16(ETH_P_ARP))
+               return;
 
-       bond = netdev_priv(dev);
        read_lock(&bond->lock);
 
-       pr_debug("bond_arp_rcv: bond %s skb->dev %s orig_dev %s\n",
-                bond->dev->name, skb->dev ? skb->dev->name : "NULL",
-                orig_dev ? orig_dev->name : "NULL");
+       pr_debug("bond_arp_rcv: bond %s skb->dev %s\n",
+                bond->dev->name, skb->dev->name);
 
-       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;
 
        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_LOOPBACK ||
            arp->ar_hrd != htons(ARPHRD_ETHER) ||
                goto out_unlock;
 
        arp_ptr = (unsigned char *)(arp + 1);
-       arp_ptr += dev->addr_len;
+       arp_ptr += bond->dev->addr_len;
        memcpy(&sip, arp_ptr, 4);
-       arp_ptr += 4 + dev->addr_len;
+       arp_ptr += 4 + bond->dev->addr_len;
        memcpy(&tip, arp_ptr, 4);
 
        pr_debug("bond_arp_rcv: %s %s/%d av %d sv %d sip %pI4 tip %pI4\n",
 
 out_unlock:
        read_unlock(&bond->lock);
-out:
-       dev_kfree_skb(skb);
-       return NET_RX_SUCCESS;
 }
 
 /*
        .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 -----------------------------*/
 
 /*
 
                queue_delayed_work(bond->wq, &bond->arp_work, 0);
                if (bond->params.arp_validate)
-                       bond_register_arp(bond);
+                       bond->recv_probe = bond_arp_rcv;
        }
 
        if (bond->params.mode == BOND_MODE_8023AD) {
                INIT_DELAYED_WORK(&bond->ad_work, bond_3ad_state_machine_handler);
                queue_delayed_work(bond->wq, &bond->ad_work, 0);
                /* register to receive LACPDUs */
-               bond_register_lacpdu(bond);
+               bond->recv_probe = bond_3ad_lacpdu_recv;
                bond_3ad_initiate_agg_selection(bond, 1);
        }
 
 {
        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);
 
        /* signal timers not to re-arm */
                 */
                bond_alb_deinitialize(bond);
        }
+       bond->recv_probe = NULL;
 
        return 0;
 }