}
 }
 
+static void ipvlan_skb_crossing_ns(struct sk_buff *skb, struct net_device *dev)
+{
+       bool xnet = true;
+
+       if (dev)
+               xnet = !net_eq(dev_net(skb->dev), dev_net(dev));
+
+       skb_scrub_packet(skb, xnet);
+       if (dev)
+               skb->dev = dev;
+}
+
 static int ipvlan_rcv_frame(struct ipvl_addr *addr, struct sk_buff **pskb,
                            bool local)
 {
 
                *pskb = skb;
        }
-       skb->dev = dev;
+       ipvlan_skb_crossing_ns(skb, dev);
 
        if (local) {
                skb->pkt_type = PACKET_HOST;
        return addr;
 }
 
-static int ipvlan_process_v4_outbound(struct sk_buff *skb, bool xnet)
+static int ipvlan_process_v4_outbound(struct sk_buff *skb)
 {
        const struct iphdr *ip4h = ip_hdr(skb);
        struct net_device *dev = skb->dev;
                ip_rt_put(rt);
                goto err;
        }
-       skb_scrub_packet(skb, xnet);
        skb_dst_set(skb, &rt->dst);
        err = ip_local_out(net, skb->sk, skb);
        if (unlikely(net_xmit_eval(err)))
        return ret;
 }
 
-static int ipvlan_process_v6_outbound(struct sk_buff *skb, bool xnet)
+static int ipvlan_process_v6_outbound(struct sk_buff *skb)
 {
        const struct ipv6hdr *ip6h = ipv6_hdr(skb);
        struct net_device *dev = skb->dev;
                dst_release(dst);
                goto err;
        }
-       skb_scrub_packet(skb, xnet);
        skb_dst_set(skb, dst);
        err = ip6_local_out(net, skb->sk, skb);
        if (unlikely(net_xmit_eval(err)))
        return ret;
 }
 
-static int ipvlan_process_outbound(struct sk_buff *skb, bool xnet)
+static int ipvlan_process_outbound(struct sk_buff *skb)
 {
        struct ethhdr *ethh = eth_hdr(skb);
        int ret = NET_XMIT_DROP;
        }
 
        if (skb->protocol == htons(ETH_P_IPV6))
-               ret = ipvlan_process_v6_outbound(skb, xnet);
+               ret = ipvlan_process_v6_outbound(skb);
        else if (skb->protocol == htons(ETH_P_IP))
-               ret = ipvlan_process_v4_outbound(skb, xnet);
+               ret = ipvlan_process_v4_outbound(skb);
        else {
                pr_warn_ratelimited("Dropped outbound packet type=%x\n",
                                    ntohs(skb->protocol));
        void *lyr3h;
        struct ipvl_addr *addr;
        int addr_type;
-       bool xnet;
 
        lyr3h = ipvlan_get_L3_hdr(skb, &addr_type);
        if (!lyr3h)
                return ipvlan_rcv_frame(addr, &skb, true);
 
 out:
-       xnet = !net_eq(dev_net(skb->dev), dev_net(ipvlan->phy_dev));
-       skb->dev = ipvlan->phy_dev;
-       return ipvlan_process_outbound(skb, xnet);
+       ipvlan_skb_crossing_ns(skb, ipvlan->phy_dev);
+       return ipvlan_process_outbound(skb);
 }
 
 static int ipvlan_xmit_mode_l2(struct sk_buff *skb, struct net_device *dev)
                return dev_forward_skb(ipvlan->phy_dev, skb);
 
        } else if (is_multicast_ether_addr(eth->h_dest)) {
+               ipvlan_skb_crossing_ns(skb, NULL);
                ipvlan_multicast_enqueue(ipvlan->port, skb);
                return NET_XMIT_SUCCESS;
        }
 
-       skb->dev = ipvlan->phy_dev;
+       ipvlan_skb_crossing_ns(skb, ipvlan->phy_dev);
        return dev_queue_xmit(skb);
 }
 
                         * when work-queue processes this frame. This is
                         * achieved by returning RX_HANDLER_PASS.
                         */
-                       if (nskb)
+                       if (nskb) {
+                               ipvlan_skb_crossing_ns(nskb, NULL);
                                ipvlan_multicast_enqueue(port, nskb);
+                       }
                }
        } else {
                struct ipvl_addr *addr;