dscp_t dscp, struct net_device *dev,
                      const struct sk_buff *hint);
 
-static inline int ip_route_input(struct sk_buff *skb, __be32 dst, __be32 src,
-                                dscp_t dscp, struct net_device *devin)
+static inline enum skb_drop_reason
+ip_route_input(struct sk_buff *skb, __be32 dst, __be32 src, dscp_t dscp,
+              struct net_device *devin)
 {
        enum skb_drop_reason reason;
 
        }
        rcu_read_unlock();
 
-       return reason ? -EINVAL : 0;
+       return reason;
 }
 
 void ipv4_update_pmtu(struct sk_buff *skb, struct net *net, u32 mtu, int oif,
 
        struct nf_bridge_info *nf_bridge = nf_bridge_info_get(skb);
        struct net_device *dev = skb->dev, *br_indev;
        const struct iphdr *iph = ip_hdr(skb);
+       enum skb_drop_reason reason;
        struct rtable *rt;
-       int err;
 
        br_indev = nf_bridge_get_physindev(skb, net);
        if (!br_indev) {
        }
        nf_bridge->in_prerouting = 0;
        if (br_nf_ipv4_daddr_was_changed(skb, nf_bridge)) {
-               err = ip_route_input(skb, iph->daddr, iph->saddr,
-                                    ip4h_dscp(iph), dev);
-               if (err) {
+               reason = ip_route_input(skb, iph->daddr, iph->saddr,
+                                       ip4h_dscp(iph), dev);
+               if (reason) {
                        struct in_device *in_dev = __in_dev_get_rcu(dev);
 
                        /* If err equals -EHOSTUNREACH the error is due to a
                         * martian destinations: loopback destinations and destination
                         * 0.0.0.0. In both cases the packet will be dropped because the
                         * destination is the loopback device and not the bridge. */
-                       if (err != -EHOSTUNREACH || !in_dev || IN_DEV_FORWARD(in_dev))
+                       if (reason != SKB_DROP_REASON_IP_INADDRERRORS || !in_dev ||
+                           IN_DEV_FORWARD(in_dev))
                                goto free_skb;
 
                        rt = ip_route_output(net, iph->daddr, 0,
 
                orefdst = skb_in->_skb_refdst; /* save old refdst */
                skb_dst_set(skb_in, NULL);
                err = ip_route_input(skb_in, fl4_dec.daddr, fl4_dec.saddr,
-                                    dscp, rt2->dst.dev);
+                                    dscp, rt2->dst.dev) ? -EINVAL : 0;
 
                dst_release(&rt2->dst);
                rt2 = skb_rtable(skb_in);
 
                orefdst = skb->_skb_refdst;
                skb_dst_set(skb, NULL);
                err = ip_route_input(skb, nexthop, iph->saddr, ip4h_dscp(iph),
-                                    dev);
+                                    dev) ? -EINVAL : 0;
                rt2 = skb_rtable(skb);
                if (err || (rt2->rt_type != RTN_UNICAST && rt2->rt_type != RTN_LOCAL)) {
                        skb_dst_drop(skb);
 
                                       struct sk_buff *skb)
 {
        struct dst_entry *orig_dst = skb_dst(skb);
+       enum skb_drop_reason reason;
        struct seg6_local_lwt *slwt;
        struct iphdr *iph;
        __be32 nhaddr;
-       int err;
 
        slwt = seg6_local_lwtunnel(orig_dst->lwtstate);
 
 
        skb_dst_drop(skb);
 
-       err = ip_route_input(skb, nhaddr, iph->saddr, 0, skb->dev);
-       if (err) {
-               kfree_skb(skb);
+       reason = ip_route_input(skb, nhaddr, iph->saddr, 0, skb->dev);
+       if (reason) {
+               kfree_skb_reason(skb, reason);
                return -EINVAL;
        }
 
 static int input_action_end_dt4(struct sk_buff *skb,
                                struct seg6_local_lwt *slwt)
 {
+       enum skb_drop_reason reason;
        struct iphdr *iph;
-       int err;
 
        if (!decap_and_validate(skb, IPPROTO_IPIP))
                goto drop;
 
        iph = ip_hdr(skb);
 
-       err = ip_route_input(skb, iph->daddr, iph->saddr, 0, skb->dev);
-       if (unlikely(err))
+       reason = ip_route_input(skb, iph->daddr, iph->saddr, 0, skb->dev);
+       if (unlikely(reason))
                goto drop;
 
        return dst_input(skb);