Needed to propagate it down to the ip_route_output_flow.
Signed-off-by: Denis V. Lunev <den@openvz.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
 
        memset(&fl, 0, sizeof fl);
        fl.nl_u.ip4_u.daddr = dst_ip;
-       if (ip_route_output_key(&rt, &fl))
+       if (ip_route_output_key(&init_net, &rt, &fl))
                return;
 
        neigh_event_send(rt->u.dst.neighbour, NULL);
        memset(&fl, 0, sizeof fl);
        fl.nl_u.ip4_u.daddr = dst_ip;
        fl.nl_u.ip4_u.saddr = src_ip;
-       ret = ip_route_output_key(&rt, &fl);
+       ret = ip_route_output_key(&init_net, &rt, &fl);
        if (ret)
                goto out;
 
 
                fl.fl4_dst = targets[i];
                fl.fl4_tos = RTO_ONLINK;
 
-               rv = ip_route_output_key(&rt, &fl);
+               rv = ip_route_output_key(&init_net, &rt, &fl);
                if (rv) {
                        if (net_ratelimit()) {
                                printk(KERN_WARNING DRV_NAME
 
                                       __be32 src, struct net_device *dev);
 extern void            rt_cache_flush(int how);
 extern int             __ip_route_output_key(struct net *, struct rtable **, const struct flowi *flp);
-extern int             ip_route_output_key(struct rtable **, struct flowi *flp);
+extern int             ip_route_output_key(struct net *, struct rtable **, struct flowi *flp);
 extern int             ip_route_output_flow(struct net *, struct rtable **rp, struct flowi *flp, struct sock *sk, int flags);
 extern int             ip_route_input(struct sk_buff*, __be32 dst, __be32 src, u8 tos, struct net_device *devin);
 extern unsigned short  ip_rt_frag_needed(struct iphdr *iph, unsigned short new_mtu);
 
                unlink_clip_vcc(clip_vcc);
                return 0;
        }
-       error = ip_route_output_key(&rt, &fl);
+       error = ip_route_output_key(&init_net, &rt, &fl);
        if (error)
                return error;
        neigh = __neigh_lookup(&clip_tbl, &ip, rt->u.dst.dev, 1);
 
                        if (err != -EHOSTUNREACH || !in_dev || IN_DEV_FORWARD(in_dev))
                                goto free_skb;
 
-                       if (!ip_route_output_key(&rt, &fl)) {
+                       if (!ip_route_output_key(&init_net, &rt, &fl)) {
                                /* - Bridged-and-DNAT'ed traffic doesn't
                                 *   require ip_forwarding. */
                                if (((struct dst_entry *)rt)->dev == dev) {
 
        int flag = 0;
        /*unsigned long now; */
 
-       if (ip_route_output_key(&rt, &fl) < 0)
+       if (ip_route_output_key(&init_net, &rt, &fl) < 0)
                return 1;
        if (rt->u.dst.dev != dev) {
                NET_INC_STATS_BH(LINUX_MIB_ARPFILTER);
                struct flowi fl = { .nl_u = { .ip4_u = { .daddr = ip,
                                                         .tos = RTO_ONLINK } } };
                struct rtable * rt;
-               if ((err = ip_route_output_key(&rt, &fl)) != 0)
+               if ((err = ip_route_output_key(net, &rt, &fl)) != 0)
                        return err;
                dev = rt->u.dst.dev;
                ip_rt_put(rt);
                struct flowi fl = { .nl_u = { .ip4_u = { .daddr = ip,
                                                         .tos = RTO_ONLINK } } };
                struct rtable * rt;
-               if ((err = ip_route_output_key(&rt, &fl)) != 0)
+               if ((err = ip_route_output_key(net, &rt, &fl)) != 0)
                        return err;
                dev = rt->u.dst.dev;
                ip_rt_put(rt);
 
                                                .tos = RT_TOS(ip_hdr(skb)->tos) } },
                                    .proto = IPPROTO_ICMP };
                security_skb_classify_flow(skb, &fl);
-               if (ip_route_output_key(&rt, &fl))
+               if (ip_route_output_key(&init_net, &rt, &fl))
                        goto out_unlock;
        }
        if (icmpv4_xrlim_allow(rt, icmp_param->data.icmph.type,
                        struct dst_entry *odst;
 
                        fl2.fl4_dst = fl.fl4_src;
-                       if (ip_route_output_key(&rt2, &fl2))
+                       if (ip_route_output_key(&init_net, &rt2, &fl2))
                                goto out_unlock;
 
                        /* Ugh! */
 
                                    .nl_u = { .ip4_u = {
                                    .daddr = IGMPV3_ALL_MCR } },
                                    .proto = IPPROTO_IGMP };
-               if (ip_route_output_key(&rt, &fl)) {
+               if (ip_route_output_key(&init_net, &rt, &fl)) {
                        kfree_skb(skb);
                        return NULL;
                }
                struct flowi fl = { .oif = dev->ifindex,
                                    .nl_u = { .ip4_u = { .daddr = dst } },
                                    .proto = IPPROTO_IGMP };
-               if (ip_route_output_key(&rt, &fl))
+               if (ip_route_output_key(&init_net, &rt, &fl))
                        return -1;
        }
        if (rt->rt_src == 0) {
                dev_put(dev);
        }
 
-       if (!dev && !ip_route_output_key(&rt, &fl)) {
+       if (!dev && !ip_route_output_key(&init_net, &rt, &fl)) {
                dev = rt->u.dst.dev;
                ip_rt_put(rt);
        }
 
        fl.fl4_dst = eiph->saddr;
        fl.fl4_tos = RT_TOS(eiph->tos);
        fl.proto = IPPROTO_GRE;
-       if (ip_route_output_key(&rt, &fl)) {
+       if (ip_route_output_key(&init_net, &rt, &fl)) {
                kfree_skb(skb2);
                return;
        }
                fl.fl4_dst = eiph->daddr;
                fl.fl4_src = eiph->saddr;
                fl.fl4_tos = eiph->tos;
-               if (ip_route_output_key(&rt, &fl) ||
+               if (ip_route_output_key(&init_net, &rt, &fl) ||
                    rt->u.dst.dev->type != ARPHRD_IPGRE) {
                        ip_rt_put(rt);
                        kfree_skb(skb2);
                                                .saddr = tiph->saddr,
                                                .tos = RT_TOS(tos) } },
                                    .proto = IPPROTO_GRE };
-               if (ip_route_output_key(&rt, &fl)) {
+               if (ip_route_output_key(&init_net, &rt, &fl)) {
                        tunnel->stat.tx_carrier_errors++;
                        goto tx_error;
                }
                                                .tos = RT_TOS(iph->tos) } },
                                    .proto = IPPROTO_GRE };
                struct rtable *rt;
-               if (!ip_route_output_key(&rt, &fl)) {
+               if (!ip_route_output_key(&init_net, &rt, &fl)) {
                        tdev = rt->u.dst.dev;
                        ip_rt_put(rt);
                }
                                                .tos = RT_TOS(t->parms.iph.tos) } },
                                    .proto = IPPROTO_GRE };
                struct rtable *rt;
-               if (ip_route_output_key(&rt, &fl))
+               if (ip_route_output_key(&init_net, &rt, &fl))
                        return -EADDRNOTAVAIL;
                dev = rt->u.dst.dev;
                ip_rt_put(rt);
 
                                                 .dport = tcp_hdr(skb)->source } },
                                    .proto = sk->sk_protocol };
                security_skb_classify_flow(skb, &fl);
-               if (ip_route_output_key(&rt, &fl))
+               if (ip_route_output_key(&init_net, &rt, &fl))
                        return;
        }
 
 
        fl.fl4_daddr = eiph->saddr;
        fl.fl4_tos = RT_TOS(eiph->tos);
        fl.proto = IPPROTO_IPIP;
-       if (ip_route_output_key(&rt, &key)) {
+       if (ip_route_output_key(&init_net, &rt, &key)) {
                kfree_skb(skb2);
                return 0;
        }
                fl.fl4_daddr = eiph->daddr;
                fl.fl4_src = eiph->saddr;
                fl.fl4_tos = eiph->tos;
-               if (ip_route_output_key(&rt, &fl) ||
+               if (ip_route_output_key(&init_net, &rt, &fl) ||
                    rt->u.dst.dev->type != ARPHRD_TUNNEL) {
                        ip_rt_put(rt);
                        kfree_skb(skb2);
                                                .saddr = tiph->saddr,
                                                .tos = RT_TOS(tos) } },
                                    .proto = IPPROTO_IPIP };
-               if (ip_route_output_key(&rt, &fl)) {
+               if (ip_route_output_key(&init_net, &rt, &fl)) {
                        tunnel->stat.tx_carrier_errors++;
                        goto tx_error_icmp;
                }
                                                .tos = RT_TOS(iph->tos) } },
                                    .proto = IPPROTO_IPIP };
                struct rtable *rt;
-               if (!ip_route_output_key(&rt, &fl)) {
+               if (!ip_route_output_key(&init_net, &rt, &fl)) {
                        tdev = rt->u.dst.dev;
                        ip_rt_put(rt);
                }
 
                                                .saddr = vif->local,
                                                .tos = RT_TOS(iph->tos) } },
                                    .proto = IPPROTO_IPIP };
-               if (ip_route_output_key(&rt, &fl))
+               if (ip_route_output_key(&init_net, &rt, &fl))
                        goto out_free;
                encap = sizeof(struct iphdr);
        } else {
                                              { .daddr = iph->daddr,
                                                .tos = RT_TOS(iph->tos) } },
                                    .proto = IPPROTO_IPIP };
-               if (ip_route_output_key(&rt, &fl))
+               if (ip_route_output_key(&init_net, &rt, &fl))
                        goto out_free;
        }
 
 
                                                .tos = rtos, } },
                        };
 
-                       if (ip_route_output_key(&rt, &fl)) {
+                       if (ip_route_output_key(&init_net, &rt, &fl)) {
                                spin_unlock(&dest->dst_lock);
                                IP_VS_DBG_RL("ip_route_output error, "
                                             "dest: %u.%u.%u.%u\n",
                                        .tos = rtos, } },
                };
 
-               if (ip_route_output_key(&rt, &fl)) {
+               if (ip_route_output_key(&init_net, &rt, &fl)) {
                        IP_VS_DBG_RL("ip_route_output error, dest: "
                                     "%u.%u.%u.%u\n", NIPQUAD(cp->daddr));
                        return NULL;
 
        EnterFunction(10);
 
-       if (ip_route_output_key(&rt, &fl)) {
+       if (ip_route_output_key(&init_net, &rt, &fl)) {
                IP_VS_DBG_RL("ip_vs_bypass_xmit(): ip_route_output error, "
                             "dest: %u.%u.%u.%u\n", NIPQUAD(iph->daddr));
                goto tx_error_icmp;
 
                fl.nl_u.ip4_u.tos = RT_TOS(iph->tos);
                fl.oif = skb->sk ? skb->sk->sk_bound_dev_if : 0;
                fl.mark = skb->mark;
-               if (ip_route_output_key(&rt, &fl) != 0)
+               if (ip_route_output_key(&init_net, &rt, &fl) != 0)
                        return -1;
 
                /* Drop old route. */
                /* non-local src, find valid iif to satisfy
                 * rp-filter when calling ip_route_input. */
                fl.nl_u.ip4_u.daddr = iph->saddr;
-               if (ip_route_output_key(&rt, &fl) != 0)
+               if (ip_route_output_key(&init_net, &rt, &fl) != 0)
                        return -1;
 
                odst = skb->dst;
 
 static int nf_ip_route(struct dst_entry **dst, struct flowi *fl)
 {
-       return ip_route_output_key((struct rtable **)dst, fl);
+       return ip_route_output_key(&init_net, (struct rtable **)dst, fl);
 }
 
 static const struct nf_afinfo nf_ip_afinfo = {
 
        struct flowi fl = { .nl_u = { .ip4_u = { .daddr = dstip } } };
        struct rtable *rt;
 
-       if (ip_route_output_key(&rt, &fl) != 0)
+       if (ip_route_output_key(&init_net, &rt, &fl) != 0)
                return;
 
        if (rt->rt_src != srcip && !warned) {
 
 
 EXPORT_SYMBOL_GPL(ip_route_output_flow);
 
-int ip_route_output_key(struct rtable **rp, struct flowi *flp)
+int ip_route_output_key(struct net *net, struct rtable **rp, struct flowi *flp)
 {
-       return ip_route_output_flow(&init_net, rp, flp, NULL, 0);
+       return ip_route_output_flow(net, rp, flp, NULL, 0);
 }
 
 static int rt_fill_info(struct sk_buff *skb, u32 pid, u32 seq, int event,
                        },
                        .oif = tb[RTA_OIF] ? nla_get_u32(tb[RTA_OIF]) : 0,
                };
-               err = ip_route_output_key(&rt, &fl);
+               err = ip_route_output_key(&init_net, &rt, &fl);
        }
 
        if (err)
 
                                               { .sport = th->dest,
                                                 .dport = th->source } } };
                security_req_classify_flow(req, &fl);
-               if (ip_route_output_key(&rt, &fl)) {
+               if (ip_route_output_key(&init_net, &rt, &fl)) {
                        reqsk_free(req);
                        goto out;
                }
 
        fl.fl4_dst = eiph->saddr;
        fl.fl4_tos = RT_TOS(eiph->tos);
        fl.proto = IPPROTO_IPIP;
-       if (ip_route_output_key(&rt, &fl))
+       if (ip_route_output_key(&init_net, &rt, &fl))
                goto out;
 
        skb2->dev = rt->u.dst.dev;
                fl.fl4_dst = eiph->daddr;
                fl.fl4_src = eiph->saddr;
                fl.fl4_tos = eiph->tos;
-               if (ip_route_output_key(&rt, &fl) ||
+               if (ip_route_output_key(&init_net, &rt, &fl) ||
                    rt->u.dst.dev->type != ARPHRD_TUNNEL) {
                        ip_rt_put(rt);
                        goto out;
 
                                                .tos = RT_TOS(tos) } },
                                    .oif = tunnel->parms.link,
                                    .proto = IPPROTO_IPV6 };
-               if (ip_route_output_key(&rt, &fl)) {
+               if (ip_route_output_key(&init_net, &rt, &fl)) {
                        tunnel->stat.tx_carrier_errors++;
                        goto tx_error_icmp;
                }
                                    .oif = tunnel->parms.link,
                                    .proto = IPPROTO_IPV6 };
                struct rtable *rt;
-               if (!ip_route_output_key(&rt, &fl)) {
+               if (!ip_route_output_key(&init_net, &rt, &fl)) {
                        tdev = rt->u.dst.dev;
                        ip_rt_put(rt);
                }
 
                BUG();
        }
 
-       ret = ip_route_output_key(&rt, &fl);
+       ret = ip_route_output_key(&init_net, &rt, &fl);
        if (ret < 0) {
                _leave(" [route err %d]", ret);
                return;
 
                          __FUNCTION__, NIPQUAD(fl.fl4_dst),
                          NIPQUAD(fl.fl4_src));
 
-       if (!ip_route_output_key(&rt, &fl)) {
+       if (!ip_route_output_key(&init_net, &rt, &fl)) {
                dst = &rt->u.dst;
        }
 
                if ((laddr->state == SCTP_ADDR_SRC) &&
                    (AF_INET == laddr->a.sa.sa_family)) {
                        fl.fl4_src = laddr->a.v4.sin_addr.s_addr;
-                       if (!ip_route_output_key(&rt, &fl)) {
+                       if (!ip_route_output_key(&init_net, &rt, &fl)) {
                                dst = &rt->u.dst;
                                goto out_unlock;
                        }