Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * INET     An implementation of the TCP/IP protocol suite for the LINUX
0004  *      operating system.  INET is implemented using the  BSD Socket
0005  *      interface as the means of communication with the user level.
0006  *
0007  *      IPv4 Forwarding Information Base: semantics.
0008  *
0009  * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
0010  */
0011 
0012 #include <linux/uaccess.h>
0013 #include <linux/bitops.h>
0014 #include <linux/types.h>
0015 #include <linux/kernel.h>
0016 #include <linux/jiffies.h>
0017 #include <linux/mm.h>
0018 #include <linux/string.h>
0019 #include <linux/socket.h>
0020 #include <linux/sockios.h>
0021 #include <linux/errno.h>
0022 #include <linux/in.h>
0023 #include <linux/inet.h>
0024 #include <linux/inetdevice.h>
0025 #include <linux/netdevice.h>
0026 #include <linux/if_arp.h>
0027 #include <linux/proc_fs.h>
0028 #include <linux/skbuff.h>
0029 #include <linux/init.h>
0030 #include <linux/slab.h>
0031 #include <linux/netlink.h>
0032 #include <linux/hash.h>
0033 
0034 #include <net/arp.h>
0035 #include <net/inet_dscp.h>
0036 #include <net/ip.h>
0037 #include <net/protocol.h>
0038 #include <net/route.h>
0039 #include <net/tcp.h>
0040 #include <net/sock.h>
0041 #include <net/ip_fib.h>
0042 #include <net/ip6_fib.h>
0043 #include <net/nexthop.h>
0044 #include <net/netlink.h>
0045 #include <net/rtnh.h>
0046 #include <net/lwtunnel.h>
0047 #include <net/fib_notifier.h>
0048 #include <net/addrconf.h>
0049 
0050 #include "fib_lookup.h"
0051 
0052 static DEFINE_SPINLOCK(fib_info_lock);
0053 static struct hlist_head *fib_info_hash;
0054 static struct hlist_head *fib_info_laddrhash;
0055 static unsigned int fib_info_hash_size;
0056 static unsigned int fib_info_hash_bits;
0057 static unsigned int fib_info_cnt;
0058 
0059 #define DEVINDEX_HASHBITS 8
0060 #define DEVINDEX_HASHSIZE (1U << DEVINDEX_HASHBITS)
0061 static struct hlist_head fib_info_devhash[DEVINDEX_HASHSIZE];
0062 
0063 /* for_nexthops and change_nexthops only used when nexthop object
0064  * is not set in a fib_info. The logic within can reference fib_nh.
0065  */
0066 #ifdef CONFIG_IP_ROUTE_MULTIPATH
0067 
0068 #define for_nexthops(fi) {                      \
0069     int nhsel; const struct fib_nh *nh;             \
0070     for (nhsel = 0, nh = (fi)->fib_nh;              \
0071          nhsel < fib_info_num_path((fi));               \
0072          nh++, nhsel++)
0073 
0074 #define change_nexthops(fi) {                       \
0075     int nhsel; struct fib_nh *nexthop_nh;               \
0076     for (nhsel = 0, nexthop_nh = (struct fib_nh *)((fi)->fib_nh);   \
0077          nhsel < fib_info_num_path((fi));               \
0078          nexthop_nh++, nhsel++)
0079 
0080 #else /* CONFIG_IP_ROUTE_MULTIPATH */
0081 
0082 /* Hope, that gcc will optimize it to get rid of dummy loop */
0083 
0084 #define for_nexthops(fi) {                      \
0085     int nhsel; const struct fib_nh *nh = (fi)->fib_nh;      \
0086     for (nhsel = 0; nhsel < 1; nhsel++)
0087 
0088 #define change_nexthops(fi) {                       \
0089     int nhsel;                          \
0090     struct fib_nh *nexthop_nh = (struct fib_nh *)((fi)->fib_nh);    \
0091     for (nhsel = 0; nhsel < 1; nhsel++)
0092 
0093 #endif /* CONFIG_IP_ROUTE_MULTIPATH */
0094 
0095 #define endfor_nexthops(fi) }
0096 
0097 
0098 const struct fib_prop fib_props[RTN_MAX + 1] = {
0099     [RTN_UNSPEC] = {
0100         .error  = 0,
0101         .scope  = RT_SCOPE_NOWHERE,
0102     },
0103     [RTN_UNICAST] = {
0104         .error  = 0,
0105         .scope  = RT_SCOPE_UNIVERSE,
0106     },
0107     [RTN_LOCAL] = {
0108         .error  = 0,
0109         .scope  = RT_SCOPE_HOST,
0110     },
0111     [RTN_BROADCAST] = {
0112         .error  = 0,
0113         .scope  = RT_SCOPE_LINK,
0114     },
0115     [RTN_ANYCAST] = {
0116         .error  = 0,
0117         .scope  = RT_SCOPE_LINK,
0118     },
0119     [RTN_MULTICAST] = {
0120         .error  = 0,
0121         .scope  = RT_SCOPE_UNIVERSE,
0122     },
0123     [RTN_BLACKHOLE] = {
0124         .error  = -EINVAL,
0125         .scope  = RT_SCOPE_UNIVERSE,
0126     },
0127     [RTN_UNREACHABLE] = {
0128         .error  = -EHOSTUNREACH,
0129         .scope  = RT_SCOPE_UNIVERSE,
0130     },
0131     [RTN_PROHIBIT] = {
0132         .error  = -EACCES,
0133         .scope  = RT_SCOPE_UNIVERSE,
0134     },
0135     [RTN_THROW] = {
0136         .error  = -EAGAIN,
0137         .scope  = RT_SCOPE_UNIVERSE,
0138     },
0139     [RTN_NAT] = {
0140         .error  = -EINVAL,
0141         .scope  = RT_SCOPE_NOWHERE,
0142     },
0143     [RTN_XRESOLVE] = {
0144         .error  = -EINVAL,
0145         .scope  = RT_SCOPE_NOWHERE,
0146     },
0147 };
0148 
0149 static void rt_fibinfo_free(struct rtable __rcu **rtp)
0150 {
0151     struct rtable *rt = rcu_dereference_protected(*rtp, 1);
0152 
0153     if (!rt)
0154         return;
0155 
0156     /* Not even needed : RCU_INIT_POINTER(*rtp, NULL);
0157      * because we waited an RCU grace period before calling
0158      * free_fib_info_rcu()
0159      */
0160 
0161     dst_dev_put(&rt->dst);
0162     dst_release_immediate(&rt->dst);
0163 }
0164 
0165 static void free_nh_exceptions(struct fib_nh_common *nhc)
0166 {
0167     struct fnhe_hash_bucket *hash;
0168     int i;
0169 
0170     hash = rcu_dereference_protected(nhc->nhc_exceptions, 1);
0171     if (!hash)
0172         return;
0173     for (i = 0; i < FNHE_HASH_SIZE; i++) {
0174         struct fib_nh_exception *fnhe;
0175 
0176         fnhe = rcu_dereference_protected(hash[i].chain, 1);
0177         while (fnhe) {
0178             struct fib_nh_exception *next;
0179 
0180             next = rcu_dereference_protected(fnhe->fnhe_next, 1);
0181 
0182             rt_fibinfo_free(&fnhe->fnhe_rth_input);
0183             rt_fibinfo_free(&fnhe->fnhe_rth_output);
0184 
0185             kfree(fnhe);
0186 
0187             fnhe = next;
0188         }
0189     }
0190     kfree(hash);
0191 }
0192 
0193 static void rt_fibinfo_free_cpus(struct rtable __rcu * __percpu *rtp)
0194 {
0195     int cpu;
0196 
0197     if (!rtp)
0198         return;
0199 
0200     for_each_possible_cpu(cpu) {
0201         struct rtable *rt;
0202 
0203         rt = rcu_dereference_protected(*per_cpu_ptr(rtp, cpu), 1);
0204         if (rt) {
0205             dst_dev_put(&rt->dst);
0206             dst_release_immediate(&rt->dst);
0207         }
0208     }
0209     free_percpu(rtp);
0210 }
0211 
0212 void fib_nh_common_release(struct fib_nh_common *nhc)
0213 {
0214     netdev_put(nhc->nhc_dev, &nhc->nhc_dev_tracker);
0215     lwtstate_put(nhc->nhc_lwtstate);
0216     rt_fibinfo_free_cpus(nhc->nhc_pcpu_rth_output);
0217     rt_fibinfo_free(&nhc->nhc_rth_input);
0218     free_nh_exceptions(nhc);
0219 }
0220 EXPORT_SYMBOL_GPL(fib_nh_common_release);
0221 
0222 void fib_nh_release(struct net *net, struct fib_nh *fib_nh)
0223 {
0224 #ifdef CONFIG_IP_ROUTE_CLASSID
0225     if (fib_nh->nh_tclassid)
0226         atomic_dec(&net->ipv4.fib_num_tclassid_users);
0227 #endif
0228     fib_nh_common_release(&fib_nh->nh_common);
0229 }
0230 
0231 /* Release a nexthop info record */
0232 static void free_fib_info_rcu(struct rcu_head *head)
0233 {
0234     struct fib_info *fi = container_of(head, struct fib_info, rcu);
0235 
0236     if (fi->nh) {
0237         nexthop_put(fi->nh);
0238     } else {
0239         change_nexthops(fi) {
0240             fib_nh_release(fi->fib_net, nexthop_nh);
0241         } endfor_nexthops(fi);
0242     }
0243 
0244     ip_fib_metrics_put(fi->fib_metrics);
0245 
0246     kfree(fi);
0247 }
0248 
0249 void free_fib_info(struct fib_info *fi)
0250 {
0251     if (fi->fib_dead == 0) {
0252         pr_warn("Freeing alive fib_info %p\n", fi);
0253         return;
0254     }
0255 
0256     call_rcu(&fi->rcu, free_fib_info_rcu);
0257 }
0258 EXPORT_SYMBOL_GPL(free_fib_info);
0259 
0260 void fib_release_info(struct fib_info *fi)
0261 {
0262     spin_lock_bh(&fib_info_lock);
0263     if (fi && refcount_dec_and_test(&fi->fib_treeref)) {
0264         hlist_del(&fi->fib_hash);
0265 
0266         /* Paired with READ_ONCE() in fib_create_info(). */
0267         WRITE_ONCE(fib_info_cnt, fib_info_cnt - 1);
0268 
0269         if (fi->fib_prefsrc)
0270             hlist_del(&fi->fib_lhash);
0271         if (fi->nh) {
0272             list_del(&fi->nh_list);
0273         } else {
0274             change_nexthops(fi) {
0275                 if (!nexthop_nh->fib_nh_dev)
0276                     continue;
0277                 hlist_del(&nexthop_nh->nh_hash);
0278             } endfor_nexthops(fi)
0279         }
0280         fi->fib_dead = 1;
0281         fib_info_put(fi);
0282     }
0283     spin_unlock_bh(&fib_info_lock);
0284 }
0285 
0286 static inline int nh_comp(struct fib_info *fi, struct fib_info *ofi)
0287 {
0288     const struct fib_nh *onh;
0289 
0290     if (fi->nh || ofi->nh)
0291         return nexthop_cmp(fi->nh, ofi->nh) ? 0 : -1;
0292 
0293     if (ofi->fib_nhs == 0)
0294         return 0;
0295 
0296     for_nexthops(fi) {
0297         onh = fib_info_nh(ofi, nhsel);
0298 
0299         if (nh->fib_nh_oif != onh->fib_nh_oif ||
0300             nh->fib_nh_gw_family != onh->fib_nh_gw_family ||
0301             nh->fib_nh_scope != onh->fib_nh_scope ||
0302 #ifdef CONFIG_IP_ROUTE_MULTIPATH
0303             nh->fib_nh_weight != onh->fib_nh_weight ||
0304 #endif
0305 #ifdef CONFIG_IP_ROUTE_CLASSID
0306             nh->nh_tclassid != onh->nh_tclassid ||
0307 #endif
0308             lwtunnel_cmp_encap(nh->fib_nh_lws, onh->fib_nh_lws) ||
0309             ((nh->fib_nh_flags ^ onh->fib_nh_flags) & ~RTNH_COMPARE_MASK))
0310             return -1;
0311 
0312         if (nh->fib_nh_gw_family == AF_INET &&
0313             nh->fib_nh_gw4 != onh->fib_nh_gw4)
0314             return -1;
0315 
0316         if (nh->fib_nh_gw_family == AF_INET6 &&
0317             ipv6_addr_cmp(&nh->fib_nh_gw6, &onh->fib_nh_gw6))
0318             return -1;
0319     } endfor_nexthops(fi);
0320     return 0;
0321 }
0322 
0323 static inline unsigned int fib_devindex_hashfn(unsigned int val)
0324 {
0325     return hash_32(val, DEVINDEX_HASHBITS);
0326 }
0327 
0328 static struct hlist_head *
0329 fib_info_devhash_bucket(const struct net_device *dev)
0330 {
0331     u32 val = net_hash_mix(dev_net(dev)) ^ dev->ifindex;
0332 
0333     return &fib_info_devhash[fib_devindex_hashfn(val)];
0334 }
0335 
0336 static unsigned int fib_info_hashfn_1(int init_val, u8 protocol, u8 scope,
0337                       u32 prefsrc, u32 priority)
0338 {
0339     unsigned int val = init_val;
0340 
0341     val ^= (protocol << 8) | scope;
0342     val ^= prefsrc;
0343     val ^= priority;
0344 
0345     return val;
0346 }
0347 
0348 static unsigned int fib_info_hashfn_result(unsigned int val)
0349 {
0350     unsigned int mask = (fib_info_hash_size - 1);
0351 
0352     return (val ^ (val >> 7) ^ (val >> 12)) & mask;
0353 }
0354 
0355 static inline unsigned int fib_info_hashfn(struct fib_info *fi)
0356 {
0357     unsigned int val;
0358 
0359     val = fib_info_hashfn_1(fi->fib_nhs, fi->fib_protocol,
0360                 fi->fib_scope, (__force u32)fi->fib_prefsrc,
0361                 fi->fib_priority);
0362 
0363     if (fi->nh) {
0364         val ^= fib_devindex_hashfn(fi->nh->id);
0365     } else {
0366         for_nexthops(fi) {
0367             val ^= fib_devindex_hashfn(nh->fib_nh_oif);
0368         } endfor_nexthops(fi)
0369     }
0370 
0371     return fib_info_hashfn_result(val);
0372 }
0373 
0374 /* no metrics, only nexthop id */
0375 static struct fib_info *fib_find_info_nh(struct net *net,
0376                      const struct fib_config *cfg)
0377 {
0378     struct hlist_head *head;
0379     struct fib_info *fi;
0380     unsigned int hash;
0381 
0382     hash = fib_info_hashfn_1(fib_devindex_hashfn(cfg->fc_nh_id),
0383                  cfg->fc_protocol, cfg->fc_scope,
0384                  (__force u32)cfg->fc_prefsrc,
0385                  cfg->fc_priority);
0386     hash = fib_info_hashfn_result(hash);
0387     head = &fib_info_hash[hash];
0388 
0389     hlist_for_each_entry(fi, head, fib_hash) {
0390         if (!net_eq(fi->fib_net, net))
0391             continue;
0392         if (!fi->nh || fi->nh->id != cfg->fc_nh_id)
0393             continue;
0394         if (cfg->fc_protocol == fi->fib_protocol &&
0395             cfg->fc_scope == fi->fib_scope &&
0396             cfg->fc_prefsrc == fi->fib_prefsrc &&
0397             cfg->fc_priority == fi->fib_priority &&
0398             cfg->fc_type == fi->fib_type &&
0399             cfg->fc_table == fi->fib_tb_id &&
0400             !((cfg->fc_flags ^ fi->fib_flags) & ~RTNH_COMPARE_MASK))
0401             return fi;
0402     }
0403 
0404     return NULL;
0405 }
0406 
0407 static struct fib_info *fib_find_info(struct fib_info *nfi)
0408 {
0409     struct hlist_head *head;
0410     struct fib_info *fi;
0411     unsigned int hash;
0412 
0413     hash = fib_info_hashfn(nfi);
0414     head = &fib_info_hash[hash];
0415 
0416     hlist_for_each_entry(fi, head, fib_hash) {
0417         if (!net_eq(fi->fib_net, nfi->fib_net))
0418             continue;
0419         if (fi->fib_nhs != nfi->fib_nhs)
0420             continue;
0421         if (nfi->fib_protocol == fi->fib_protocol &&
0422             nfi->fib_scope == fi->fib_scope &&
0423             nfi->fib_prefsrc == fi->fib_prefsrc &&
0424             nfi->fib_priority == fi->fib_priority &&
0425             nfi->fib_type == fi->fib_type &&
0426             memcmp(nfi->fib_metrics, fi->fib_metrics,
0427                sizeof(u32) * RTAX_MAX) == 0 &&
0428             !((nfi->fib_flags ^ fi->fib_flags) & ~RTNH_COMPARE_MASK) &&
0429             nh_comp(fi, nfi) == 0)
0430             return fi;
0431     }
0432 
0433     return NULL;
0434 }
0435 
0436 /* Check, that the gateway is already configured.
0437  * Used only by redirect accept routine.
0438  */
0439 int ip_fib_check_default(__be32 gw, struct net_device *dev)
0440 {
0441     struct hlist_head *head;
0442     struct fib_nh *nh;
0443 
0444     spin_lock(&fib_info_lock);
0445 
0446     head = fib_info_devhash_bucket(dev);
0447 
0448     hlist_for_each_entry(nh, head, nh_hash) {
0449         if (nh->fib_nh_dev == dev &&
0450             nh->fib_nh_gw4 == gw &&
0451             !(nh->fib_nh_flags & RTNH_F_DEAD)) {
0452             spin_unlock(&fib_info_lock);
0453             return 0;
0454         }
0455     }
0456 
0457     spin_unlock(&fib_info_lock);
0458 
0459     return -1;
0460 }
0461 
0462 size_t fib_nlmsg_size(struct fib_info *fi)
0463 {
0464     size_t payload = NLMSG_ALIGN(sizeof(struct rtmsg))
0465              + nla_total_size(4) /* RTA_TABLE */
0466              + nla_total_size(4) /* RTA_DST */
0467              + nla_total_size(4) /* RTA_PRIORITY */
0468              + nla_total_size(4) /* RTA_PREFSRC */
0469              + nla_total_size(TCP_CA_NAME_MAX); /* RTAX_CC_ALGO */
0470     unsigned int nhs = fib_info_num_path(fi);
0471 
0472     /* space for nested metrics */
0473     payload += nla_total_size((RTAX_MAX * nla_total_size(4)));
0474 
0475     if (fi->nh)
0476         payload += nla_total_size(4); /* RTA_NH_ID */
0477 
0478     if (nhs) {
0479         size_t nh_encapsize = 0;
0480         /* Also handles the special case nhs == 1 */
0481 
0482         /* each nexthop is packed in an attribute */
0483         size_t nhsize = nla_total_size(sizeof(struct rtnexthop));
0484         unsigned int i;
0485 
0486         /* may contain flow and gateway attribute */
0487         nhsize += 2 * nla_total_size(4);
0488 
0489         /* grab encap info */
0490         for (i = 0; i < fib_info_num_path(fi); i++) {
0491             struct fib_nh_common *nhc = fib_info_nhc(fi, i);
0492 
0493             if (nhc->nhc_lwtstate) {
0494                 /* RTA_ENCAP_TYPE */
0495                 nh_encapsize += lwtunnel_get_encap_size(
0496                         nhc->nhc_lwtstate);
0497                 /* RTA_ENCAP */
0498                 nh_encapsize +=  nla_total_size(2);
0499             }
0500         }
0501 
0502         /* all nexthops are packed in a nested attribute */
0503         payload += nla_total_size((nhs * nhsize) + nh_encapsize);
0504 
0505     }
0506 
0507     return payload;
0508 }
0509 
0510 void rtmsg_fib(int event, __be32 key, struct fib_alias *fa,
0511            int dst_len, u32 tb_id, const struct nl_info *info,
0512            unsigned int nlm_flags)
0513 {
0514     struct fib_rt_info fri;
0515     struct sk_buff *skb;
0516     u32 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
0517     int err = -ENOBUFS;
0518 
0519     skb = nlmsg_new(fib_nlmsg_size(fa->fa_info), GFP_KERNEL);
0520     if (!skb)
0521         goto errout;
0522 
0523     fri.fi = fa->fa_info;
0524     fri.tb_id = tb_id;
0525     fri.dst = key;
0526     fri.dst_len = dst_len;
0527     fri.dscp = fa->fa_dscp;
0528     fri.type = fa->fa_type;
0529     fri.offload = READ_ONCE(fa->offload);
0530     fri.trap = READ_ONCE(fa->trap);
0531     fri.offload_failed = READ_ONCE(fa->offload_failed);
0532     err = fib_dump_info(skb, info->portid, seq, event, &fri, nlm_flags);
0533     if (err < 0) {
0534         /* -EMSGSIZE implies BUG in fib_nlmsg_size() */
0535         WARN_ON(err == -EMSGSIZE);
0536         kfree_skb(skb);
0537         goto errout;
0538     }
0539     rtnl_notify(skb, info->nl_net, info->portid, RTNLGRP_IPV4_ROUTE,
0540             info->nlh, GFP_KERNEL);
0541     return;
0542 errout:
0543     if (err < 0)
0544         rtnl_set_sk_err(info->nl_net, RTNLGRP_IPV4_ROUTE, err);
0545 }
0546 
0547 static int fib_detect_death(struct fib_info *fi, int order,
0548                 struct fib_info **last_resort, int *last_idx,
0549                 int dflt)
0550 {
0551     const struct fib_nh_common *nhc = fib_info_nhc(fi, 0);
0552     struct neighbour *n;
0553     int state = NUD_NONE;
0554 
0555     if (likely(nhc->nhc_gw_family == AF_INET))
0556         n = neigh_lookup(&arp_tbl, &nhc->nhc_gw.ipv4, nhc->nhc_dev);
0557     else if (nhc->nhc_gw_family == AF_INET6)
0558         n = neigh_lookup(ipv6_stub->nd_tbl, &nhc->nhc_gw.ipv6,
0559                  nhc->nhc_dev);
0560     else
0561         n = NULL;
0562 
0563     if (n) {
0564         state = n->nud_state;
0565         neigh_release(n);
0566     } else {
0567         return 0;
0568     }
0569     if (state == NUD_REACHABLE)
0570         return 0;
0571     if ((state & NUD_VALID) && order != dflt)
0572         return 0;
0573     if ((state & NUD_VALID) ||
0574         (*last_idx < 0 && order > dflt && state != NUD_INCOMPLETE)) {
0575         *last_resort = fi;
0576         *last_idx = order;
0577     }
0578     return 1;
0579 }
0580 
0581 int fib_nh_common_init(struct net *net, struct fib_nh_common *nhc,
0582                struct nlattr *encap, u16 encap_type,
0583                void *cfg, gfp_t gfp_flags,
0584                struct netlink_ext_ack *extack)
0585 {
0586     int err;
0587 
0588     nhc->nhc_pcpu_rth_output = alloc_percpu_gfp(struct rtable __rcu *,
0589                             gfp_flags);
0590     if (!nhc->nhc_pcpu_rth_output)
0591         return -ENOMEM;
0592 
0593     if (encap) {
0594         struct lwtunnel_state *lwtstate;
0595 
0596         if (encap_type == LWTUNNEL_ENCAP_NONE) {
0597             NL_SET_ERR_MSG(extack, "LWT encap type not specified");
0598             err = -EINVAL;
0599             goto lwt_failure;
0600         }
0601         err = lwtunnel_build_state(net, encap_type, encap,
0602                        nhc->nhc_family, cfg, &lwtstate,
0603                        extack);
0604         if (err)
0605             goto lwt_failure;
0606 
0607         nhc->nhc_lwtstate = lwtstate_get(lwtstate);
0608     }
0609 
0610     return 0;
0611 
0612 lwt_failure:
0613     rt_fibinfo_free_cpus(nhc->nhc_pcpu_rth_output);
0614     nhc->nhc_pcpu_rth_output = NULL;
0615     return err;
0616 }
0617 EXPORT_SYMBOL_GPL(fib_nh_common_init);
0618 
0619 int fib_nh_init(struct net *net, struct fib_nh *nh,
0620         struct fib_config *cfg, int nh_weight,
0621         struct netlink_ext_ack *extack)
0622 {
0623     int err;
0624 
0625     nh->fib_nh_family = AF_INET;
0626 
0627     err = fib_nh_common_init(net, &nh->nh_common, cfg->fc_encap,
0628                  cfg->fc_encap_type, cfg, GFP_KERNEL, extack);
0629     if (err)
0630         return err;
0631 
0632     nh->fib_nh_oif = cfg->fc_oif;
0633     nh->fib_nh_gw_family = cfg->fc_gw_family;
0634     if (cfg->fc_gw_family == AF_INET)
0635         nh->fib_nh_gw4 = cfg->fc_gw4;
0636     else if (cfg->fc_gw_family == AF_INET6)
0637         nh->fib_nh_gw6 = cfg->fc_gw6;
0638 
0639     nh->fib_nh_flags = cfg->fc_flags;
0640 
0641 #ifdef CONFIG_IP_ROUTE_CLASSID
0642     nh->nh_tclassid = cfg->fc_flow;
0643     if (nh->nh_tclassid)
0644         atomic_inc(&net->ipv4.fib_num_tclassid_users);
0645 #endif
0646 #ifdef CONFIG_IP_ROUTE_MULTIPATH
0647     nh->fib_nh_weight = nh_weight;
0648 #endif
0649     return 0;
0650 }
0651 
0652 #ifdef CONFIG_IP_ROUTE_MULTIPATH
0653 
0654 static int fib_count_nexthops(struct rtnexthop *rtnh, int remaining,
0655                   struct netlink_ext_ack *extack)
0656 {
0657     int nhs = 0;
0658 
0659     while (rtnh_ok(rtnh, remaining)) {
0660         nhs++;
0661         rtnh = rtnh_next(rtnh, &remaining);
0662     }
0663 
0664     /* leftover implies invalid nexthop configuration, discard it */
0665     if (remaining > 0) {
0666         NL_SET_ERR_MSG(extack,
0667                    "Invalid nexthop configuration - extra data after nexthops");
0668         nhs = 0;
0669     }
0670 
0671     return nhs;
0672 }
0673 
0674 static int fib_gw_from_attr(__be32 *gw, struct nlattr *nla,
0675                 struct netlink_ext_ack *extack)
0676 {
0677     if (nla_len(nla) < sizeof(*gw)) {
0678         NL_SET_ERR_MSG(extack, "Invalid IPv4 address in RTA_GATEWAY");
0679         return -EINVAL;
0680     }
0681 
0682     *gw = nla_get_in_addr(nla);
0683 
0684     return 0;
0685 }
0686 
0687 /* only called when fib_nh is integrated into fib_info */
0688 static int fib_get_nhs(struct fib_info *fi, struct rtnexthop *rtnh,
0689                int remaining, struct fib_config *cfg,
0690                struct netlink_ext_ack *extack)
0691 {
0692     struct net *net = fi->fib_net;
0693     struct fib_config fib_cfg;
0694     struct fib_nh *nh;
0695     int ret;
0696 
0697     change_nexthops(fi) {
0698         int attrlen;
0699 
0700         memset(&fib_cfg, 0, sizeof(fib_cfg));
0701 
0702         if (!rtnh_ok(rtnh, remaining)) {
0703             NL_SET_ERR_MSG(extack,
0704                        "Invalid nexthop configuration - extra data after nexthop");
0705             return -EINVAL;
0706         }
0707 
0708         if (rtnh->rtnh_flags & (RTNH_F_DEAD | RTNH_F_LINKDOWN)) {
0709             NL_SET_ERR_MSG(extack,
0710                        "Invalid flags for nexthop - can not contain DEAD or LINKDOWN");
0711             return -EINVAL;
0712         }
0713 
0714         fib_cfg.fc_flags = (cfg->fc_flags & ~0xFF) | rtnh->rtnh_flags;
0715         fib_cfg.fc_oif = rtnh->rtnh_ifindex;
0716 
0717         attrlen = rtnh_attrlen(rtnh);
0718         if (attrlen > 0) {
0719             struct nlattr *nla, *nlav, *attrs = rtnh_attrs(rtnh);
0720 
0721             nla = nla_find(attrs, attrlen, RTA_GATEWAY);
0722             nlav = nla_find(attrs, attrlen, RTA_VIA);
0723             if (nla && nlav) {
0724                 NL_SET_ERR_MSG(extack,
0725                            "Nexthop configuration can not contain both GATEWAY and VIA");
0726                 return -EINVAL;
0727             }
0728             if (nla) {
0729                 ret = fib_gw_from_attr(&fib_cfg.fc_gw4, nla,
0730                                extack);
0731                 if (ret)
0732                     goto errout;
0733 
0734                 if (fib_cfg.fc_gw4)
0735                     fib_cfg.fc_gw_family = AF_INET;
0736             } else if (nlav) {
0737                 ret = fib_gw_from_via(&fib_cfg, nlav, extack);
0738                 if (ret)
0739                     goto errout;
0740             }
0741 
0742             nla = nla_find(attrs, attrlen, RTA_FLOW);
0743             if (nla) {
0744                 if (nla_len(nla) < sizeof(u32)) {
0745                     NL_SET_ERR_MSG(extack, "Invalid RTA_FLOW");
0746                     return -EINVAL;
0747                 }
0748                 fib_cfg.fc_flow = nla_get_u32(nla);
0749             }
0750 
0751             fib_cfg.fc_encap = nla_find(attrs, attrlen, RTA_ENCAP);
0752             /* RTA_ENCAP_TYPE length checked in
0753              * lwtunnel_valid_encap_type_attr
0754              */
0755             nla = nla_find(attrs, attrlen, RTA_ENCAP_TYPE);
0756             if (nla)
0757                 fib_cfg.fc_encap_type = nla_get_u16(nla);
0758         }
0759 
0760         ret = fib_nh_init(net, nexthop_nh, &fib_cfg,
0761                   rtnh->rtnh_hops + 1, extack);
0762         if (ret)
0763             goto errout;
0764 
0765         rtnh = rtnh_next(rtnh, &remaining);
0766     } endfor_nexthops(fi);
0767 
0768     ret = -EINVAL;
0769     nh = fib_info_nh(fi, 0);
0770     if (cfg->fc_oif && nh->fib_nh_oif != cfg->fc_oif) {
0771         NL_SET_ERR_MSG(extack,
0772                    "Nexthop device index does not match RTA_OIF");
0773         goto errout;
0774     }
0775     if (cfg->fc_gw_family) {
0776         if (cfg->fc_gw_family != nh->fib_nh_gw_family ||
0777             (cfg->fc_gw_family == AF_INET &&
0778              nh->fib_nh_gw4 != cfg->fc_gw4) ||
0779             (cfg->fc_gw_family == AF_INET6 &&
0780              ipv6_addr_cmp(&nh->fib_nh_gw6, &cfg->fc_gw6))) {
0781             NL_SET_ERR_MSG(extack,
0782                        "Nexthop gateway does not match RTA_GATEWAY or RTA_VIA");
0783             goto errout;
0784         }
0785     }
0786 #ifdef CONFIG_IP_ROUTE_CLASSID
0787     if (cfg->fc_flow && nh->nh_tclassid != cfg->fc_flow) {
0788         NL_SET_ERR_MSG(extack,
0789                    "Nexthop class id does not match RTA_FLOW");
0790         goto errout;
0791     }
0792 #endif
0793     ret = 0;
0794 errout:
0795     return ret;
0796 }
0797 
0798 /* only called when fib_nh is integrated into fib_info */
0799 static void fib_rebalance(struct fib_info *fi)
0800 {
0801     int total;
0802     int w;
0803 
0804     if (fib_info_num_path(fi) < 2)
0805         return;
0806 
0807     total = 0;
0808     for_nexthops(fi) {
0809         if (nh->fib_nh_flags & RTNH_F_DEAD)
0810             continue;
0811 
0812         if (ip_ignore_linkdown(nh->fib_nh_dev) &&
0813             nh->fib_nh_flags & RTNH_F_LINKDOWN)
0814             continue;
0815 
0816         total += nh->fib_nh_weight;
0817     } endfor_nexthops(fi);
0818 
0819     w = 0;
0820     change_nexthops(fi) {
0821         int upper_bound;
0822 
0823         if (nexthop_nh->fib_nh_flags & RTNH_F_DEAD) {
0824             upper_bound = -1;
0825         } else if (ip_ignore_linkdown(nexthop_nh->fib_nh_dev) &&
0826                nexthop_nh->fib_nh_flags & RTNH_F_LINKDOWN) {
0827             upper_bound = -1;
0828         } else {
0829             w += nexthop_nh->fib_nh_weight;
0830             upper_bound = DIV_ROUND_CLOSEST_ULL((u64)w << 31,
0831                                 total) - 1;
0832         }
0833 
0834         atomic_set(&nexthop_nh->fib_nh_upper_bound, upper_bound);
0835     } endfor_nexthops(fi);
0836 }
0837 #else /* CONFIG_IP_ROUTE_MULTIPATH */
0838 
0839 static int fib_get_nhs(struct fib_info *fi, struct rtnexthop *rtnh,
0840                int remaining, struct fib_config *cfg,
0841                struct netlink_ext_ack *extack)
0842 {
0843     NL_SET_ERR_MSG(extack, "Multipath support not enabled in kernel");
0844 
0845     return -EINVAL;
0846 }
0847 
0848 #define fib_rebalance(fi) do { } while (0)
0849 
0850 #endif /* CONFIG_IP_ROUTE_MULTIPATH */
0851 
0852 static int fib_encap_match(struct net *net, u16 encap_type,
0853                struct nlattr *encap,
0854                const struct fib_nh *nh,
0855                const struct fib_config *cfg,
0856                struct netlink_ext_ack *extack)
0857 {
0858     struct lwtunnel_state *lwtstate;
0859     int ret, result = 0;
0860 
0861     if (encap_type == LWTUNNEL_ENCAP_NONE)
0862         return 0;
0863 
0864     ret = lwtunnel_build_state(net, encap_type, encap, AF_INET,
0865                    cfg, &lwtstate, extack);
0866     if (!ret) {
0867         result = lwtunnel_cmp_encap(lwtstate, nh->fib_nh_lws);
0868         lwtstate_free(lwtstate);
0869     }
0870 
0871     return result;
0872 }
0873 
0874 int fib_nh_match(struct net *net, struct fib_config *cfg, struct fib_info *fi,
0875          struct netlink_ext_ack *extack)
0876 {
0877 #ifdef CONFIG_IP_ROUTE_MULTIPATH
0878     struct rtnexthop *rtnh;
0879     int remaining;
0880 #endif
0881 
0882     if (cfg->fc_priority && cfg->fc_priority != fi->fib_priority)
0883         return 1;
0884 
0885     if (cfg->fc_nh_id) {
0886         if (fi->nh && cfg->fc_nh_id == fi->nh->id)
0887             return 0;
0888         return 1;
0889     }
0890 
0891     if (cfg->fc_oif || cfg->fc_gw_family) {
0892         struct fib_nh *nh;
0893 
0894         /* cannot match on nexthop object attributes */
0895         if (fi->nh)
0896             return 1;
0897 
0898         nh = fib_info_nh(fi, 0);
0899         if (cfg->fc_encap) {
0900             if (fib_encap_match(net, cfg->fc_encap_type,
0901                         cfg->fc_encap, nh, cfg, extack))
0902                 return 1;
0903         }
0904 #ifdef CONFIG_IP_ROUTE_CLASSID
0905         if (cfg->fc_flow &&
0906             cfg->fc_flow != nh->nh_tclassid)
0907             return 1;
0908 #endif
0909         if ((cfg->fc_oif && cfg->fc_oif != nh->fib_nh_oif) ||
0910             (cfg->fc_gw_family &&
0911              cfg->fc_gw_family != nh->fib_nh_gw_family))
0912             return 1;
0913 
0914         if (cfg->fc_gw_family == AF_INET &&
0915             cfg->fc_gw4 != nh->fib_nh_gw4)
0916             return 1;
0917 
0918         if (cfg->fc_gw_family == AF_INET6 &&
0919             ipv6_addr_cmp(&cfg->fc_gw6, &nh->fib_nh_gw6))
0920             return 1;
0921 
0922         return 0;
0923     }
0924 
0925 #ifdef CONFIG_IP_ROUTE_MULTIPATH
0926     if (!cfg->fc_mp)
0927         return 0;
0928 
0929     rtnh = cfg->fc_mp;
0930     remaining = cfg->fc_mp_len;
0931 
0932     for_nexthops(fi) {
0933         int attrlen;
0934 
0935         if (!rtnh_ok(rtnh, remaining))
0936             return -EINVAL;
0937 
0938         if (rtnh->rtnh_ifindex && rtnh->rtnh_ifindex != nh->fib_nh_oif)
0939             return 1;
0940 
0941         attrlen = rtnh_attrlen(rtnh);
0942         if (attrlen > 0) {
0943             struct nlattr *nla, *nlav, *attrs = rtnh_attrs(rtnh);
0944             int err;
0945 
0946             nla = nla_find(attrs, attrlen, RTA_GATEWAY);
0947             nlav = nla_find(attrs, attrlen, RTA_VIA);
0948             if (nla && nlav) {
0949                 NL_SET_ERR_MSG(extack,
0950                            "Nexthop configuration can not contain both GATEWAY and VIA");
0951                 return -EINVAL;
0952             }
0953 
0954             if (nla) {
0955                 __be32 gw;
0956 
0957                 err = fib_gw_from_attr(&gw, nla, extack);
0958                 if (err)
0959                     return err;
0960 
0961                 if (nh->fib_nh_gw_family != AF_INET ||
0962                     gw != nh->fib_nh_gw4)
0963                     return 1;
0964             } else if (nlav) {
0965                 struct fib_config cfg2;
0966 
0967                 err = fib_gw_from_via(&cfg2, nlav, extack);
0968                 if (err)
0969                     return err;
0970 
0971                 switch (nh->fib_nh_gw_family) {
0972                 case AF_INET:
0973                     if (cfg2.fc_gw_family != AF_INET ||
0974                         cfg2.fc_gw4 != nh->fib_nh_gw4)
0975                         return 1;
0976                     break;
0977                 case AF_INET6:
0978                     if (cfg2.fc_gw_family != AF_INET6 ||
0979                         ipv6_addr_cmp(&cfg2.fc_gw6,
0980                               &nh->fib_nh_gw6))
0981                         return 1;
0982                     break;
0983                 }
0984             }
0985 
0986 #ifdef CONFIG_IP_ROUTE_CLASSID
0987             nla = nla_find(attrs, attrlen, RTA_FLOW);
0988             if (nla) {
0989                 if (nla_len(nla) < sizeof(u32)) {
0990                     NL_SET_ERR_MSG(extack, "Invalid RTA_FLOW");
0991                     return -EINVAL;
0992                 }
0993                 if (nla_get_u32(nla) != nh->nh_tclassid)
0994                     return 1;
0995             }
0996 #endif
0997         }
0998 
0999         rtnh = rtnh_next(rtnh, &remaining);
1000     } endfor_nexthops(fi);
1001 #endif
1002     return 0;
1003 }
1004 
1005 bool fib_metrics_match(struct fib_config *cfg, struct fib_info *fi)
1006 {
1007     struct nlattr *nla;
1008     int remaining;
1009 
1010     if (!cfg->fc_mx)
1011         return true;
1012 
1013     nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
1014         int type = nla_type(nla);
1015         u32 fi_val, val;
1016 
1017         if (!type)
1018             continue;
1019         if (type > RTAX_MAX)
1020             return false;
1021 
1022         if (type == RTAX_CC_ALGO) {
1023             char tmp[TCP_CA_NAME_MAX];
1024             bool ecn_ca = false;
1025 
1026             nla_strscpy(tmp, nla, sizeof(tmp));
1027             val = tcp_ca_get_key_by_name(fi->fib_net, tmp, &ecn_ca);
1028         } else {
1029             if (nla_len(nla) != sizeof(u32))
1030                 return false;
1031             val = nla_get_u32(nla);
1032         }
1033 
1034         fi_val = fi->fib_metrics->metrics[type - 1];
1035         if (type == RTAX_FEATURES)
1036             fi_val &= ~DST_FEATURE_ECN_CA;
1037 
1038         if (fi_val != val)
1039             return false;
1040     }
1041 
1042     return true;
1043 }
1044 
1045 static int fib_check_nh_v6_gw(struct net *net, struct fib_nh *nh,
1046                   u32 table, struct netlink_ext_ack *extack)
1047 {
1048     struct fib6_config cfg = {
1049         .fc_table = table,
1050         .fc_flags = nh->fib_nh_flags | RTF_GATEWAY,
1051         .fc_ifindex = nh->fib_nh_oif,
1052         .fc_gateway = nh->fib_nh_gw6,
1053     };
1054     struct fib6_nh fib6_nh = {};
1055     int err;
1056 
1057     err = ipv6_stub->fib6_nh_init(net, &fib6_nh, &cfg, GFP_KERNEL, extack);
1058     if (!err) {
1059         nh->fib_nh_dev = fib6_nh.fib_nh_dev;
1060         netdev_hold(nh->fib_nh_dev, &nh->fib_nh_dev_tracker,
1061                 GFP_KERNEL);
1062         nh->fib_nh_oif = nh->fib_nh_dev->ifindex;
1063         nh->fib_nh_scope = RT_SCOPE_LINK;
1064 
1065         ipv6_stub->fib6_nh_release(&fib6_nh);
1066     }
1067 
1068     return err;
1069 }
1070 
1071 /*
1072  * Picture
1073  * -------
1074  *
1075  * Semantics of nexthop is very messy by historical reasons.
1076  * We have to take into account, that:
1077  * a) gateway can be actually local interface address,
1078  *    so that gatewayed route is direct.
1079  * b) gateway must be on-link address, possibly
1080  *    described not by an ifaddr, but also by a direct route.
1081  * c) If both gateway and interface are specified, they should not
1082  *    contradict.
1083  * d) If we use tunnel routes, gateway could be not on-link.
1084  *
1085  * Attempt to reconcile all of these (alas, self-contradictory) conditions
1086  * results in pretty ugly and hairy code with obscure logic.
1087  *
1088  * I chose to generalized it instead, so that the size
1089  * of code does not increase practically, but it becomes
1090  * much more general.
1091  * Every prefix is assigned a "scope" value: "host" is local address,
1092  * "link" is direct route,
1093  * [ ... "site" ... "interior" ... ]
1094  * and "universe" is true gateway route with global meaning.
1095  *
1096  * Every prefix refers to a set of "nexthop"s (gw, oif),
1097  * where gw must have narrower scope. This recursion stops
1098  * when gw has LOCAL scope or if "nexthop" is declared ONLINK,
1099  * which means that gw is forced to be on link.
1100  *
1101  * Code is still hairy, but now it is apparently logically
1102  * consistent and very flexible. F.e. as by-product it allows
1103  * to co-exists in peace independent exterior and interior
1104  * routing processes.
1105  *
1106  * Normally it looks as following.
1107  *
1108  * {universe prefix}  -> (gw, oif) [scope link]
1109  *        |
1110  *        |-> {link prefix} -> (gw, oif) [scope local]
1111  *                  |
1112  *                  |-> {local prefix} (terminal node)
1113  */
1114 static int fib_check_nh_v4_gw(struct net *net, struct fib_nh *nh, u32 table,
1115                   u8 scope, struct netlink_ext_ack *extack)
1116 {
1117     struct net_device *dev;
1118     struct fib_result res;
1119     int err = 0;
1120 
1121     if (nh->fib_nh_flags & RTNH_F_ONLINK) {
1122         unsigned int addr_type;
1123 
1124         if (scope >= RT_SCOPE_LINK) {
1125             NL_SET_ERR_MSG(extack, "Nexthop has invalid scope");
1126             return -EINVAL;
1127         }
1128         dev = __dev_get_by_index(net, nh->fib_nh_oif);
1129         if (!dev) {
1130             NL_SET_ERR_MSG(extack, "Nexthop device required for onlink");
1131             return -ENODEV;
1132         }
1133         if (!(dev->flags & IFF_UP)) {
1134             NL_SET_ERR_MSG(extack, "Nexthop device is not up");
1135             return -ENETDOWN;
1136         }
1137         addr_type = inet_addr_type_dev_table(net, dev, nh->fib_nh_gw4);
1138         if (addr_type != RTN_UNICAST) {
1139             NL_SET_ERR_MSG(extack, "Nexthop has invalid gateway");
1140             return -EINVAL;
1141         }
1142         if (!netif_carrier_ok(dev))
1143             nh->fib_nh_flags |= RTNH_F_LINKDOWN;
1144         nh->fib_nh_dev = dev;
1145         netdev_hold(dev, &nh->fib_nh_dev_tracker, GFP_ATOMIC);
1146         nh->fib_nh_scope = RT_SCOPE_LINK;
1147         return 0;
1148     }
1149     rcu_read_lock();
1150     {
1151         struct fib_table *tbl = NULL;
1152         struct flowi4 fl4 = {
1153             .daddr = nh->fib_nh_gw4,
1154             .flowi4_scope = scope + 1,
1155             .flowi4_oif = nh->fib_nh_oif,
1156             .flowi4_iif = LOOPBACK_IFINDEX,
1157         };
1158 
1159         /* It is not necessary, but requires a bit of thinking */
1160         if (fl4.flowi4_scope < RT_SCOPE_LINK)
1161             fl4.flowi4_scope = RT_SCOPE_LINK;
1162 
1163         if (table && table != RT_TABLE_MAIN)
1164             tbl = fib_get_table(net, table);
1165 
1166         if (tbl)
1167             err = fib_table_lookup(tbl, &fl4, &res,
1168                            FIB_LOOKUP_IGNORE_LINKSTATE |
1169                            FIB_LOOKUP_NOREF);
1170 
1171         /* on error or if no table given do full lookup. This
1172          * is needed for example when nexthops are in the local
1173          * table rather than the given table
1174          */
1175         if (!tbl || err) {
1176             err = fib_lookup(net, &fl4, &res,
1177                      FIB_LOOKUP_IGNORE_LINKSTATE);
1178         }
1179 
1180         if (err) {
1181             NL_SET_ERR_MSG(extack, "Nexthop has invalid gateway");
1182             goto out;
1183         }
1184     }
1185 
1186     err = -EINVAL;
1187     if (res.type != RTN_UNICAST && res.type != RTN_LOCAL) {
1188         NL_SET_ERR_MSG(extack, "Nexthop has invalid gateway");
1189         goto out;
1190     }
1191     nh->fib_nh_scope = res.scope;
1192     nh->fib_nh_oif = FIB_RES_OIF(res);
1193     nh->fib_nh_dev = dev = FIB_RES_DEV(res);
1194     if (!dev) {
1195         NL_SET_ERR_MSG(extack,
1196                    "No egress device for nexthop gateway");
1197         goto out;
1198     }
1199     netdev_hold(dev, &nh->fib_nh_dev_tracker, GFP_ATOMIC);
1200     if (!netif_carrier_ok(dev))
1201         nh->fib_nh_flags |= RTNH_F_LINKDOWN;
1202     err = (dev->flags & IFF_UP) ? 0 : -ENETDOWN;
1203 out:
1204     rcu_read_unlock();
1205     return err;
1206 }
1207 
1208 static int fib_check_nh_nongw(struct net *net, struct fib_nh *nh,
1209                   struct netlink_ext_ack *extack)
1210 {
1211     struct in_device *in_dev;
1212     int err;
1213 
1214     if (nh->fib_nh_flags & (RTNH_F_PERVASIVE | RTNH_F_ONLINK)) {
1215         NL_SET_ERR_MSG(extack,
1216                    "Invalid flags for nexthop - PERVASIVE and ONLINK can not be set");
1217         return -EINVAL;
1218     }
1219 
1220     rcu_read_lock();
1221 
1222     err = -ENODEV;
1223     in_dev = inetdev_by_index(net, nh->fib_nh_oif);
1224     if (!in_dev)
1225         goto out;
1226     err = -ENETDOWN;
1227     if (!(in_dev->dev->flags & IFF_UP)) {
1228         NL_SET_ERR_MSG(extack, "Device for nexthop is not up");
1229         goto out;
1230     }
1231 
1232     nh->fib_nh_dev = in_dev->dev;
1233     netdev_hold(nh->fib_nh_dev, &nh->fib_nh_dev_tracker, GFP_ATOMIC);
1234     nh->fib_nh_scope = RT_SCOPE_LINK;
1235     if (!netif_carrier_ok(nh->fib_nh_dev))
1236         nh->fib_nh_flags |= RTNH_F_LINKDOWN;
1237     err = 0;
1238 out:
1239     rcu_read_unlock();
1240     return err;
1241 }
1242 
1243 int fib_check_nh(struct net *net, struct fib_nh *nh, u32 table, u8 scope,
1244          struct netlink_ext_ack *extack)
1245 {
1246     int err;
1247 
1248     if (nh->fib_nh_gw_family == AF_INET)
1249         err = fib_check_nh_v4_gw(net, nh, table, scope, extack);
1250     else if (nh->fib_nh_gw_family == AF_INET6)
1251         err = fib_check_nh_v6_gw(net, nh, table, extack);
1252     else
1253         err = fib_check_nh_nongw(net, nh, extack);
1254 
1255     return err;
1256 }
1257 
1258 static struct hlist_head *
1259 fib_info_laddrhash_bucket(const struct net *net, __be32 val)
1260 {
1261     u32 slot = hash_32(net_hash_mix(net) ^ (__force u32)val,
1262                fib_info_hash_bits);
1263 
1264     return &fib_info_laddrhash[slot];
1265 }
1266 
1267 static void fib_info_hash_move(struct hlist_head *new_info_hash,
1268                    struct hlist_head *new_laddrhash,
1269                    unsigned int new_size)
1270 {
1271     struct hlist_head *old_info_hash, *old_laddrhash;
1272     unsigned int old_size = fib_info_hash_size;
1273     unsigned int i;
1274 
1275     spin_lock_bh(&fib_info_lock);
1276     old_info_hash = fib_info_hash;
1277     old_laddrhash = fib_info_laddrhash;
1278     fib_info_hash_size = new_size;
1279     fib_info_hash_bits = ilog2(new_size);
1280 
1281     for (i = 0; i < old_size; i++) {
1282         struct hlist_head *head = &fib_info_hash[i];
1283         struct hlist_node *n;
1284         struct fib_info *fi;
1285 
1286         hlist_for_each_entry_safe(fi, n, head, fib_hash) {
1287             struct hlist_head *dest;
1288             unsigned int new_hash;
1289 
1290             new_hash = fib_info_hashfn(fi);
1291             dest = &new_info_hash[new_hash];
1292             hlist_add_head(&fi->fib_hash, dest);
1293         }
1294     }
1295     fib_info_hash = new_info_hash;
1296 
1297     fib_info_laddrhash = new_laddrhash;
1298     for (i = 0; i < old_size; i++) {
1299         struct hlist_head *lhead = &old_laddrhash[i];
1300         struct hlist_node *n;
1301         struct fib_info *fi;
1302 
1303         hlist_for_each_entry_safe(fi, n, lhead, fib_lhash) {
1304             struct hlist_head *ldest;
1305 
1306             ldest = fib_info_laddrhash_bucket(fi->fib_net,
1307                               fi->fib_prefsrc);
1308             hlist_add_head(&fi->fib_lhash, ldest);
1309         }
1310     }
1311 
1312     spin_unlock_bh(&fib_info_lock);
1313 
1314     kvfree(old_info_hash);
1315     kvfree(old_laddrhash);
1316 }
1317 
1318 __be32 fib_info_update_nhc_saddr(struct net *net, struct fib_nh_common *nhc,
1319                  unsigned char scope)
1320 {
1321     struct fib_nh *nh;
1322 
1323     if (nhc->nhc_family != AF_INET)
1324         return inet_select_addr(nhc->nhc_dev, 0, scope);
1325 
1326     nh = container_of(nhc, struct fib_nh, nh_common);
1327     nh->nh_saddr = inet_select_addr(nh->fib_nh_dev, nh->fib_nh_gw4, scope);
1328     nh->nh_saddr_genid = atomic_read(&net->ipv4.dev_addr_genid);
1329 
1330     return nh->nh_saddr;
1331 }
1332 
1333 __be32 fib_result_prefsrc(struct net *net, struct fib_result *res)
1334 {
1335     struct fib_nh_common *nhc = res->nhc;
1336 
1337     if (res->fi->fib_prefsrc)
1338         return res->fi->fib_prefsrc;
1339 
1340     if (nhc->nhc_family == AF_INET) {
1341         struct fib_nh *nh;
1342 
1343         nh = container_of(nhc, struct fib_nh, nh_common);
1344         if (nh->nh_saddr_genid == atomic_read(&net->ipv4.dev_addr_genid))
1345             return nh->nh_saddr;
1346     }
1347 
1348     return fib_info_update_nhc_saddr(net, nhc, res->fi->fib_scope);
1349 }
1350 
1351 static bool fib_valid_prefsrc(struct fib_config *cfg, __be32 fib_prefsrc)
1352 {
1353     if (cfg->fc_type != RTN_LOCAL || !cfg->fc_dst ||
1354         fib_prefsrc != cfg->fc_dst) {
1355         u32 tb_id = cfg->fc_table;
1356         int rc;
1357 
1358         if (tb_id == RT_TABLE_MAIN)
1359             tb_id = RT_TABLE_LOCAL;
1360 
1361         rc = inet_addr_type_table(cfg->fc_nlinfo.nl_net,
1362                       fib_prefsrc, tb_id);
1363 
1364         if (rc != RTN_LOCAL && tb_id != RT_TABLE_LOCAL) {
1365             rc = inet_addr_type_table(cfg->fc_nlinfo.nl_net,
1366                           fib_prefsrc, RT_TABLE_LOCAL);
1367         }
1368 
1369         if (rc != RTN_LOCAL)
1370             return false;
1371     }
1372     return true;
1373 }
1374 
1375 struct fib_info *fib_create_info(struct fib_config *cfg,
1376                  struct netlink_ext_ack *extack)
1377 {
1378     int err;
1379     struct fib_info *fi = NULL;
1380     struct nexthop *nh = NULL;
1381     struct fib_info *ofi;
1382     int nhs = 1;
1383     struct net *net = cfg->fc_nlinfo.nl_net;
1384 
1385     if (cfg->fc_type > RTN_MAX)
1386         goto err_inval;
1387 
1388     /* Fast check to catch the most weird cases */
1389     if (fib_props[cfg->fc_type].scope > cfg->fc_scope) {
1390         NL_SET_ERR_MSG(extack, "Invalid scope");
1391         goto err_inval;
1392     }
1393 
1394     if (cfg->fc_flags & (RTNH_F_DEAD | RTNH_F_LINKDOWN)) {
1395         NL_SET_ERR_MSG(extack,
1396                    "Invalid rtm_flags - can not contain DEAD or LINKDOWN");
1397         goto err_inval;
1398     }
1399 
1400     if (cfg->fc_nh_id) {
1401         if (!cfg->fc_mx) {
1402             fi = fib_find_info_nh(net, cfg);
1403             if (fi) {
1404                 refcount_inc(&fi->fib_treeref);
1405                 return fi;
1406             }
1407         }
1408 
1409         nh = nexthop_find_by_id(net, cfg->fc_nh_id);
1410         if (!nh) {
1411             NL_SET_ERR_MSG(extack, "Nexthop id does not exist");
1412             goto err_inval;
1413         }
1414         nhs = 0;
1415     }
1416 
1417 #ifdef CONFIG_IP_ROUTE_MULTIPATH
1418     if (cfg->fc_mp) {
1419         nhs = fib_count_nexthops(cfg->fc_mp, cfg->fc_mp_len, extack);
1420         if (nhs == 0)
1421             goto err_inval;
1422     }
1423 #endif
1424 
1425     err = -ENOBUFS;
1426 
1427     /* Paired with WRITE_ONCE() in fib_release_info() */
1428     if (READ_ONCE(fib_info_cnt) >= fib_info_hash_size) {
1429         unsigned int new_size = fib_info_hash_size << 1;
1430         struct hlist_head *new_info_hash;
1431         struct hlist_head *new_laddrhash;
1432         size_t bytes;
1433 
1434         if (!new_size)
1435             new_size = 16;
1436         bytes = (size_t)new_size * sizeof(struct hlist_head *);
1437         new_info_hash = kvzalloc(bytes, GFP_KERNEL);
1438         new_laddrhash = kvzalloc(bytes, GFP_KERNEL);
1439         if (!new_info_hash || !new_laddrhash) {
1440             kvfree(new_info_hash);
1441             kvfree(new_laddrhash);
1442         } else {
1443             fib_info_hash_move(new_info_hash, new_laddrhash, new_size);
1444         }
1445         if (!fib_info_hash_size)
1446             goto failure;
1447     }
1448 
1449     fi = kzalloc(struct_size(fi, fib_nh, nhs), GFP_KERNEL);
1450     if (!fi)
1451         goto failure;
1452     fi->fib_metrics = ip_fib_metrics_init(fi->fib_net, cfg->fc_mx,
1453                           cfg->fc_mx_len, extack);
1454     if (IS_ERR(fi->fib_metrics)) {
1455         err = PTR_ERR(fi->fib_metrics);
1456         kfree(fi);
1457         return ERR_PTR(err);
1458     }
1459 
1460     fi->fib_net = net;
1461     fi->fib_protocol = cfg->fc_protocol;
1462     fi->fib_scope = cfg->fc_scope;
1463     fi->fib_flags = cfg->fc_flags;
1464     fi->fib_priority = cfg->fc_priority;
1465     fi->fib_prefsrc = cfg->fc_prefsrc;
1466     fi->fib_type = cfg->fc_type;
1467     fi->fib_tb_id = cfg->fc_table;
1468 
1469     fi->fib_nhs = nhs;
1470     if (nh) {
1471         if (!nexthop_get(nh)) {
1472             NL_SET_ERR_MSG(extack, "Nexthop has been deleted");
1473             err = -EINVAL;
1474         } else {
1475             err = 0;
1476             fi->nh = nh;
1477         }
1478     } else {
1479         change_nexthops(fi) {
1480             nexthop_nh->nh_parent = fi;
1481         } endfor_nexthops(fi)
1482 
1483         if (cfg->fc_mp)
1484             err = fib_get_nhs(fi, cfg->fc_mp, cfg->fc_mp_len, cfg,
1485                       extack);
1486         else
1487             err = fib_nh_init(net, fi->fib_nh, cfg, 1, extack);
1488     }
1489 
1490     if (err != 0)
1491         goto failure;
1492 
1493     if (fib_props[cfg->fc_type].error) {
1494         if (cfg->fc_gw_family || cfg->fc_oif || cfg->fc_mp) {
1495             NL_SET_ERR_MSG(extack,
1496                        "Gateway, device and multipath can not be specified for this route type");
1497             goto err_inval;
1498         }
1499         goto link_it;
1500     } else {
1501         switch (cfg->fc_type) {
1502         case RTN_UNICAST:
1503         case RTN_LOCAL:
1504         case RTN_BROADCAST:
1505         case RTN_ANYCAST:
1506         case RTN_MULTICAST:
1507             break;
1508         default:
1509             NL_SET_ERR_MSG(extack, "Invalid route type");
1510             goto err_inval;
1511         }
1512     }
1513 
1514     if (cfg->fc_scope > RT_SCOPE_HOST) {
1515         NL_SET_ERR_MSG(extack, "Invalid scope");
1516         goto err_inval;
1517     }
1518 
1519     if (fi->nh) {
1520         err = fib_check_nexthop(fi->nh, cfg->fc_scope, extack);
1521         if (err)
1522             goto failure;
1523     } else if (cfg->fc_scope == RT_SCOPE_HOST) {
1524         struct fib_nh *nh = fi->fib_nh;
1525 
1526         /* Local address is added. */
1527         if (nhs != 1) {
1528             NL_SET_ERR_MSG(extack,
1529                        "Route with host scope can not have multiple nexthops");
1530             goto err_inval;
1531         }
1532         if (nh->fib_nh_gw_family) {
1533             NL_SET_ERR_MSG(extack,
1534                        "Route with host scope can not have a gateway");
1535             goto err_inval;
1536         }
1537         nh->fib_nh_scope = RT_SCOPE_NOWHERE;
1538         nh->fib_nh_dev = dev_get_by_index(net, nh->fib_nh_oif);
1539         err = -ENODEV;
1540         if (!nh->fib_nh_dev)
1541             goto failure;
1542         netdev_tracker_alloc(nh->fib_nh_dev, &nh->fib_nh_dev_tracker,
1543                      GFP_KERNEL);
1544     } else {
1545         int linkdown = 0;
1546 
1547         change_nexthops(fi) {
1548             err = fib_check_nh(cfg->fc_nlinfo.nl_net, nexthop_nh,
1549                        cfg->fc_table, cfg->fc_scope,
1550                        extack);
1551             if (err != 0)
1552                 goto failure;
1553             if (nexthop_nh->fib_nh_flags & RTNH_F_LINKDOWN)
1554                 linkdown++;
1555         } endfor_nexthops(fi)
1556         if (linkdown == fi->fib_nhs)
1557             fi->fib_flags |= RTNH_F_LINKDOWN;
1558     }
1559 
1560     if (fi->fib_prefsrc && !fib_valid_prefsrc(cfg, fi->fib_prefsrc)) {
1561         NL_SET_ERR_MSG(extack, "Invalid prefsrc address");
1562         goto err_inval;
1563     }
1564 
1565     if (!fi->nh) {
1566         change_nexthops(fi) {
1567             fib_info_update_nhc_saddr(net, &nexthop_nh->nh_common,
1568                           fi->fib_scope);
1569             if (nexthop_nh->fib_nh_gw_family == AF_INET6)
1570                 fi->fib_nh_is_v6 = true;
1571         } endfor_nexthops(fi)
1572 
1573         fib_rebalance(fi);
1574     }
1575 
1576 link_it:
1577     ofi = fib_find_info(fi);
1578     if (ofi) {
1579         fi->fib_dead = 1;
1580         free_fib_info(fi);
1581         refcount_inc(&ofi->fib_treeref);
1582         return ofi;
1583     }
1584 
1585     refcount_set(&fi->fib_treeref, 1);
1586     refcount_set(&fi->fib_clntref, 1);
1587     spin_lock_bh(&fib_info_lock);
1588     fib_info_cnt++;
1589     hlist_add_head(&fi->fib_hash,
1590                &fib_info_hash[fib_info_hashfn(fi)]);
1591     if (fi->fib_prefsrc) {
1592         struct hlist_head *head;
1593 
1594         head = fib_info_laddrhash_bucket(net, fi->fib_prefsrc);
1595         hlist_add_head(&fi->fib_lhash, head);
1596     }
1597     if (fi->nh) {
1598         list_add(&fi->nh_list, &nh->fi_list);
1599     } else {
1600         change_nexthops(fi) {
1601             struct hlist_head *head;
1602 
1603             if (!nexthop_nh->fib_nh_dev)
1604                 continue;
1605             head = fib_info_devhash_bucket(nexthop_nh->fib_nh_dev);
1606             hlist_add_head(&nexthop_nh->nh_hash, head);
1607         } endfor_nexthops(fi)
1608     }
1609     spin_unlock_bh(&fib_info_lock);
1610     return fi;
1611 
1612 err_inval:
1613     err = -EINVAL;
1614 
1615 failure:
1616     if (fi) {
1617         fi->fib_dead = 1;
1618         free_fib_info(fi);
1619     }
1620 
1621     return ERR_PTR(err);
1622 }
1623 
1624 int fib_nexthop_info(struct sk_buff *skb, const struct fib_nh_common *nhc,
1625              u8 rt_family, unsigned char *flags, bool skip_oif)
1626 {
1627     if (nhc->nhc_flags & RTNH_F_DEAD)
1628         *flags |= RTNH_F_DEAD;
1629 
1630     if (nhc->nhc_flags & RTNH_F_LINKDOWN) {
1631         *flags |= RTNH_F_LINKDOWN;
1632 
1633         rcu_read_lock();
1634         switch (nhc->nhc_family) {
1635         case AF_INET:
1636             if (ip_ignore_linkdown(nhc->nhc_dev))
1637                 *flags |= RTNH_F_DEAD;
1638             break;
1639         case AF_INET6:
1640             if (ip6_ignore_linkdown(nhc->nhc_dev))
1641                 *flags |= RTNH_F_DEAD;
1642             break;
1643         }
1644         rcu_read_unlock();
1645     }
1646 
1647     switch (nhc->nhc_gw_family) {
1648     case AF_INET:
1649         if (nla_put_in_addr(skb, RTA_GATEWAY, nhc->nhc_gw.ipv4))
1650             goto nla_put_failure;
1651         break;
1652     case AF_INET6:
1653         /* if gateway family does not match nexthop family
1654          * gateway is encoded as RTA_VIA
1655          */
1656         if (rt_family != nhc->nhc_gw_family) {
1657             int alen = sizeof(struct in6_addr);
1658             struct nlattr *nla;
1659             struct rtvia *via;
1660 
1661             nla = nla_reserve(skb, RTA_VIA, alen + 2);
1662             if (!nla)
1663                 goto nla_put_failure;
1664 
1665             via = nla_data(nla);
1666             via->rtvia_family = AF_INET6;
1667             memcpy(via->rtvia_addr, &nhc->nhc_gw.ipv6, alen);
1668         } else if (nla_put_in6_addr(skb, RTA_GATEWAY,
1669                         &nhc->nhc_gw.ipv6) < 0) {
1670             goto nla_put_failure;
1671         }
1672         break;
1673     }
1674 
1675     *flags |= (nhc->nhc_flags &
1676            (RTNH_F_ONLINK | RTNH_F_OFFLOAD | RTNH_F_TRAP));
1677 
1678     if (!skip_oif && nhc->nhc_dev &&
1679         nla_put_u32(skb, RTA_OIF, nhc->nhc_dev->ifindex))
1680         goto nla_put_failure;
1681 
1682     if (nhc->nhc_lwtstate &&
1683         lwtunnel_fill_encap(skb, nhc->nhc_lwtstate,
1684                 RTA_ENCAP, RTA_ENCAP_TYPE) < 0)
1685         goto nla_put_failure;
1686 
1687     return 0;
1688 
1689 nla_put_failure:
1690     return -EMSGSIZE;
1691 }
1692 EXPORT_SYMBOL_GPL(fib_nexthop_info);
1693 
1694 #if IS_ENABLED(CONFIG_IP_ROUTE_MULTIPATH) || IS_ENABLED(CONFIG_IPV6)
1695 int fib_add_nexthop(struct sk_buff *skb, const struct fib_nh_common *nhc,
1696             int nh_weight, u8 rt_family, u32 nh_tclassid)
1697 {
1698     const struct net_device *dev = nhc->nhc_dev;
1699     struct rtnexthop *rtnh;
1700     unsigned char flags = 0;
1701 
1702     rtnh = nla_reserve_nohdr(skb, sizeof(*rtnh));
1703     if (!rtnh)
1704         goto nla_put_failure;
1705 
1706     rtnh->rtnh_hops = nh_weight - 1;
1707     rtnh->rtnh_ifindex = dev ? dev->ifindex : 0;
1708 
1709     if (fib_nexthop_info(skb, nhc, rt_family, &flags, true) < 0)
1710         goto nla_put_failure;
1711 
1712     rtnh->rtnh_flags = flags;
1713 
1714     if (nh_tclassid && nla_put_u32(skb, RTA_FLOW, nh_tclassid))
1715         goto nla_put_failure;
1716 
1717     /* length of rtnetlink header + attributes */
1718     rtnh->rtnh_len = nlmsg_get_pos(skb) - (void *)rtnh;
1719 
1720     return 0;
1721 
1722 nla_put_failure:
1723     return -EMSGSIZE;
1724 }
1725 EXPORT_SYMBOL_GPL(fib_add_nexthop);
1726 #endif
1727 
1728 #ifdef CONFIG_IP_ROUTE_MULTIPATH
1729 static int fib_add_multipath(struct sk_buff *skb, struct fib_info *fi)
1730 {
1731     struct nlattr *mp;
1732 
1733     mp = nla_nest_start_noflag(skb, RTA_MULTIPATH);
1734     if (!mp)
1735         goto nla_put_failure;
1736 
1737     if (unlikely(fi->nh)) {
1738         if (nexthop_mpath_fill_node(skb, fi->nh, AF_INET) < 0)
1739             goto nla_put_failure;
1740         goto mp_end;
1741     }
1742 
1743     for_nexthops(fi) {
1744         u32 nh_tclassid = 0;
1745 #ifdef CONFIG_IP_ROUTE_CLASSID
1746         nh_tclassid = nh->nh_tclassid;
1747 #endif
1748         if (fib_add_nexthop(skb, &nh->nh_common, nh->fib_nh_weight,
1749                     AF_INET, nh_tclassid) < 0)
1750             goto nla_put_failure;
1751     } endfor_nexthops(fi);
1752 
1753 mp_end:
1754     nla_nest_end(skb, mp);
1755 
1756     return 0;
1757 
1758 nla_put_failure:
1759     return -EMSGSIZE;
1760 }
1761 #else
1762 static int fib_add_multipath(struct sk_buff *skb, struct fib_info *fi)
1763 {
1764     return 0;
1765 }
1766 #endif
1767 
1768 int fib_dump_info(struct sk_buff *skb, u32 portid, u32 seq, int event,
1769           const struct fib_rt_info *fri, unsigned int flags)
1770 {
1771     unsigned int nhs = fib_info_num_path(fri->fi);
1772     struct fib_info *fi = fri->fi;
1773     u32 tb_id = fri->tb_id;
1774     struct nlmsghdr *nlh;
1775     struct rtmsg *rtm;
1776 
1777     nlh = nlmsg_put(skb, portid, seq, event, sizeof(*rtm), flags);
1778     if (!nlh)
1779         return -EMSGSIZE;
1780 
1781     rtm = nlmsg_data(nlh);
1782     rtm->rtm_family = AF_INET;
1783     rtm->rtm_dst_len = fri->dst_len;
1784     rtm->rtm_src_len = 0;
1785     rtm->rtm_tos = inet_dscp_to_dsfield(fri->dscp);
1786     if (tb_id < 256)
1787         rtm->rtm_table = tb_id;
1788     else
1789         rtm->rtm_table = RT_TABLE_COMPAT;
1790     if (nla_put_u32(skb, RTA_TABLE, tb_id))
1791         goto nla_put_failure;
1792     rtm->rtm_type = fri->type;
1793     rtm->rtm_flags = fi->fib_flags;
1794     rtm->rtm_scope = fi->fib_scope;
1795     rtm->rtm_protocol = fi->fib_protocol;
1796 
1797     if (rtm->rtm_dst_len &&
1798         nla_put_in_addr(skb, RTA_DST, fri->dst))
1799         goto nla_put_failure;
1800     if (fi->fib_priority &&
1801         nla_put_u32(skb, RTA_PRIORITY, fi->fib_priority))
1802         goto nla_put_failure;
1803     if (rtnetlink_put_metrics(skb, fi->fib_metrics->metrics) < 0)
1804         goto nla_put_failure;
1805 
1806     if (fi->fib_prefsrc &&
1807         nla_put_in_addr(skb, RTA_PREFSRC, fi->fib_prefsrc))
1808         goto nla_put_failure;
1809 
1810     if (fi->nh) {
1811         if (nla_put_u32(skb, RTA_NH_ID, fi->nh->id))
1812             goto nla_put_failure;
1813         if (nexthop_is_blackhole(fi->nh))
1814             rtm->rtm_type = RTN_BLACKHOLE;
1815         if (!READ_ONCE(fi->fib_net->ipv4.sysctl_nexthop_compat_mode))
1816             goto offload;
1817     }
1818 
1819     if (nhs == 1) {
1820         const struct fib_nh_common *nhc = fib_info_nhc(fi, 0);
1821         unsigned char flags = 0;
1822 
1823         if (fib_nexthop_info(skb, nhc, AF_INET, &flags, false) < 0)
1824             goto nla_put_failure;
1825 
1826         rtm->rtm_flags = flags;
1827 #ifdef CONFIG_IP_ROUTE_CLASSID
1828         if (nhc->nhc_family == AF_INET) {
1829             struct fib_nh *nh;
1830 
1831             nh = container_of(nhc, struct fib_nh, nh_common);
1832             if (nh->nh_tclassid &&
1833                 nla_put_u32(skb, RTA_FLOW, nh->nh_tclassid))
1834                 goto nla_put_failure;
1835         }
1836 #endif
1837     } else {
1838         if (fib_add_multipath(skb, fi) < 0)
1839             goto nla_put_failure;
1840     }
1841 
1842 offload:
1843     if (fri->offload)
1844         rtm->rtm_flags |= RTM_F_OFFLOAD;
1845     if (fri->trap)
1846         rtm->rtm_flags |= RTM_F_TRAP;
1847     if (fri->offload_failed)
1848         rtm->rtm_flags |= RTM_F_OFFLOAD_FAILED;
1849 
1850     nlmsg_end(skb, nlh);
1851     return 0;
1852 
1853 nla_put_failure:
1854     nlmsg_cancel(skb, nlh);
1855     return -EMSGSIZE;
1856 }
1857 
1858 /*
1859  * Update FIB if:
1860  * - local address disappeared -> we must delete all the entries
1861  *   referring to it.
1862  * - device went down -> we must shutdown all nexthops going via it.
1863  */
1864 int fib_sync_down_addr(struct net_device *dev, __be32 local)
1865 {
1866     int tb_id = l3mdev_fib_table(dev) ? : RT_TABLE_MAIN;
1867     struct net *net = dev_net(dev);
1868     struct hlist_head *head;
1869     struct fib_info *fi;
1870     int ret = 0;
1871 
1872     if (!fib_info_laddrhash || local == 0)
1873         return 0;
1874 
1875     head = fib_info_laddrhash_bucket(net, local);
1876     hlist_for_each_entry(fi, head, fib_lhash) {
1877         if (!net_eq(fi->fib_net, net) ||
1878             fi->fib_tb_id != tb_id)
1879             continue;
1880         if (fi->fib_prefsrc == local) {
1881             fi->fib_flags |= RTNH_F_DEAD;
1882             ret++;
1883         }
1884     }
1885     return ret;
1886 }
1887 
1888 static int call_fib_nh_notifiers(struct fib_nh *nh,
1889                  enum fib_event_type event_type)
1890 {
1891     bool ignore_link_down = ip_ignore_linkdown(nh->fib_nh_dev);
1892     struct fib_nh_notifier_info info = {
1893         .fib_nh = nh,
1894     };
1895 
1896     switch (event_type) {
1897     case FIB_EVENT_NH_ADD:
1898         if (nh->fib_nh_flags & RTNH_F_DEAD)
1899             break;
1900         if (ignore_link_down && nh->fib_nh_flags & RTNH_F_LINKDOWN)
1901             break;
1902         return call_fib4_notifiers(dev_net(nh->fib_nh_dev), event_type,
1903                        &info.info);
1904     case FIB_EVENT_NH_DEL:
1905         if ((ignore_link_down && nh->fib_nh_flags & RTNH_F_LINKDOWN) ||
1906             (nh->fib_nh_flags & RTNH_F_DEAD))
1907             return call_fib4_notifiers(dev_net(nh->fib_nh_dev),
1908                            event_type, &info.info);
1909         break;
1910     default:
1911         break;
1912     }
1913 
1914     return NOTIFY_DONE;
1915 }
1916 
1917 /* Update the PMTU of exceptions when:
1918  * - the new MTU of the first hop becomes smaller than the PMTU
1919  * - the old MTU was the same as the PMTU, and it limited discovery of
1920  *   larger MTUs on the path. With that limit raised, we can now
1921  *   discover larger MTUs
1922  * A special case is locked exceptions, for which the PMTU is smaller
1923  * than the minimal accepted PMTU:
1924  * - if the new MTU is greater than the PMTU, don't make any change
1925  * - otherwise, unlock and set PMTU
1926  */
1927 void fib_nhc_update_mtu(struct fib_nh_common *nhc, u32 new, u32 orig)
1928 {
1929     struct fnhe_hash_bucket *bucket;
1930     int i;
1931 
1932     bucket = rcu_dereference_protected(nhc->nhc_exceptions, 1);
1933     if (!bucket)
1934         return;
1935 
1936     for (i = 0; i < FNHE_HASH_SIZE; i++) {
1937         struct fib_nh_exception *fnhe;
1938 
1939         for (fnhe = rcu_dereference_protected(bucket[i].chain, 1);
1940              fnhe;
1941              fnhe = rcu_dereference_protected(fnhe->fnhe_next, 1)) {
1942             if (fnhe->fnhe_mtu_locked) {
1943                 if (new <= fnhe->fnhe_pmtu) {
1944                     fnhe->fnhe_pmtu = new;
1945                     fnhe->fnhe_mtu_locked = false;
1946                 }
1947             } else if (new < fnhe->fnhe_pmtu ||
1948                    orig == fnhe->fnhe_pmtu) {
1949                 fnhe->fnhe_pmtu = new;
1950             }
1951         }
1952     }
1953 }
1954 
1955 void fib_sync_mtu(struct net_device *dev, u32 orig_mtu)
1956 {
1957     struct hlist_head *head = fib_info_devhash_bucket(dev);
1958     struct fib_nh *nh;
1959 
1960     hlist_for_each_entry(nh, head, nh_hash) {
1961         if (nh->fib_nh_dev == dev)
1962             fib_nhc_update_mtu(&nh->nh_common, dev->mtu, orig_mtu);
1963     }
1964 }
1965 
1966 /* Event              force Flags           Description
1967  * NETDEV_CHANGE      0     LINKDOWN        Carrier OFF, not for scope host
1968  * NETDEV_DOWN        0     LINKDOWN|DEAD   Link down, not for scope host
1969  * NETDEV_DOWN        1     LINKDOWN|DEAD   Last address removed
1970  * NETDEV_UNREGISTER  1     LINKDOWN|DEAD   Device removed
1971  *
1972  * only used when fib_nh is built into fib_info
1973  */
1974 int fib_sync_down_dev(struct net_device *dev, unsigned long event, bool force)
1975 {
1976     struct hlist_head *head = fib_info_devhash_bucket(dev);
1977     struct fib_info *prev_fi = NULL;
1978     int scope = RT_SCOPE_NOWHERE;
1979     struct fib_nh *nh;
1980     int ret = 0;
1981 
1982     if (force)
1983         scope = -1;
1984 
1985     hlist_for_each_entry(nh, head, nh_hash) {
1986         struct fib_info *fi = nh->nh_parent;
1987         int dead;
1988 
1989         BUG_ON(!fi->fib_nhs);
1990         if (nh->fib_nh_dev != dev || fi == prev_fi)
1991             continue;
1992         prev_fi = fi;
1993         dead = 0;
1994         change_nexthops(fi) {
1995             if (nexthop_nh->fib_nh_flags & RTNH_F_DEAD)
1996                 dead++;
1997             else if (nexthop_nh->fib_nh_dev == dev &&
1998                  nexthop_nh->fib_nh_scope != scope) {
1999                 switch (event) {
2000                 case NETDEV_DOWN:
2001                 case NETDEV_UNREGISTER:
2002                     nexthop_nh->fib_nh_flags |= RTNH_F_DEAD;
2003                     fallthrough;
2004                 case NETDEV_CHANGE:
2005                     nexthop_nh->fib_nh_flags |= RTNH_F_LINKDOWN;
2006                     break;
2007                 }
2008                 call_fib_nh_notifiers(nexthop_nh,
2009                               FIB_EVENT_NH_DEL);
2010                 dead++;
2011             }
2012 #ifdef CONFIG_IP_ROUTE_MULTIPATH
2013             if (event == NETDEV_UNREGISTER &&
2014                 nexthop_nh->fib_nh_dev == dev) {
2015                 dead = fi->fib_nhs;
2016                 break;
2017             }
2018 #endif
2019         } endfor_nexthops(fi)
2020         if (dead == fi->fib_nhs) {
2021             switch (event) {
2022             case NETDEV_DOWN:
2023             case NETDEV_UNREGISTER:
2024                 fi->fib_flags |= RTNH_F_DEAD;
2025                 fallthrough;
2026             case NETDEV_CHANGE:
2027                 fi->fib_flags |= RTNH_F_LINKDOWN;
2028                 break;
2029             }
2030             ret++;
2031         }
2032 
2033         fib_rebalance(fi);
2034     }
2035 
2036     return ret;
2037 }
2038 
2039 /* Must be invoked inside of an RCU protected region.  */
2040 static void fib_select_default(const struct flowi4 *flp, struct fib_result *res)
2041 {
2042     struct fib_info *fi = NULL, *last_resort = NULL;
2043     struct hlist_head *fa_head = res->fa_head;
2044     struct fib_table *tb = res->table;
2045     u8 slen = 32 - res->prefixlen;
2046     int order = -1, last_idx = -1;
2047     struct fib_alias *fa, *fa1 = NULL;
2048     u32 last_prio = res->fi->fib_priority;
2049     dscp_t last_dscp = 0;
2050 
2051     hlist_for_each_entry_rcu(fa, fa_head, fa_list) {
2052         struct fib_info *next_fi = fa->fa_info;
2053         struct fib_nh_common *nhc;
2054 
2055         if (fa->fa_slen != slen)
2056             continue;
2057         if (fa->fa_dscp &&
2058             fa->fa_dscp != inet_dsfield_to_dscp(flp->flowi4_tos))
2059             continue;
2060         if (fa->tb_id != tb->tb_id)
2061             continue;
2062         if (next_fi->fib_priority > last_prio &&
2063             fa->fa_dscp == last_dscp) {
2064             if (last_dscp)
2065                 continue;
2066             break;
2067         }
2068         if (next_fi->fib_flags & RTNH_F_DEAD)
2069             continue;
2070         last_dscp = fa->fa_dscp;
2071         last_prio = next_fi->fib_priority;
2072 
2073         if (next_fi->fib_scope != res->scope ||
2074             fa->fa_type != RTN_UNICAST)
2075             continue;
2076 
2077         nhc = fib_info_nhc(next_fi, 0);
2078         if (!nhc->nhc_gw_family || nhc->nhc_scope != RT_SCOPE_LINK)
2079             continue;
2080 
2081         fib_alias_accessed(fa);
2082 
2083         if (!fi) {
2084             if (next_fi != res->fi)
2085                 break;
2086             fa1 = fa;
2087         } else if (!fib_detect_death(fi, order, &last_resort,
2088                          &last_idx, fa1->fa_default)) {
2089             fib_result_assign(res, fi);
2090             fa1->fa_default = order;
2091             goto out;
2092         }
2093         fi = next_fi;
2094         order++;
2095     }
2096 
2097     if (order <= 0 || !fi) {
2098         if (fa1)
2099             fa1->fa_default = -1;
2100         goto out;
2101     }
2102 
2103     if (!fib_detect_death(fi, order, &last_resort, &last_idx,
2104                   fa1->fa_default)) {
2105         fib_result_assign(res, fi);
2106         fa1->fa_default = order;
2107         goto out;
2108     }
2109 
2110     if (last_idx >= 0)
2111         fib_result_assign(res, last_resort);
2112     fa1->fa_default = last_idx;
2113 out:
2114     return;
2115 }
2116 
2117 /*
2118  * Dead device goes up. We wake up dead nexthops.
2119  * It takes sense only on multipath routes.
2120  *
2121  * only used when fib_nh is built into fib_info
2122  */
2123 int fib_sync_up(struct net_device *dev, unsigned char nh_flags)
2124 {
2125     struct fib_info *prev_fi;
2126     struct hlist_head *head;
2127     struct fib_nh *nh;
2128     int ret;
2129 
2130     if (!(dev->flags & IFF_UP))
2131         return 0;
2132 
2133     if (nh_flags & RTNH_F_DEAD) {
2134         unsigned int flags = dev_get_flags(dev);
2135 
2136         if (flags & (IFF_RUNNING | IFF_LOWER_UP))
2137             nh_flags |= RTNH_F_LINKDOWN;
2138     }
2139 
2140     prev_fi = NULL;
2141     head = fib_info_devhash_bucket(dev);
2142     ret = 0;
2143 
2144     hlist_for_each_entry(nh, head, nh_hash) {
2145         struct fib_info *fi = nh->nh_parent;
2146         int alive;
2147 
2148         BUG_ON(!fi->fib_nhs);
2149         if (nh->fib_nh_dev != dev || fi == prev_fi)
2150             continue;
2151 
2152         prev_fi = fi;
2153         alive = 0;
2154         change_nexthops(fi) {
2155             if (!(nexthop_nh->fib_nh_flags & nh_flags)) {
2156                 alive++;
2157                 continue;
2158             }
2159             if (!nexthop_nh->fib_nh_dev ||
2160                 !(nexthop_nh->fib_nh_dev->flags & IFF_UP))
2161                 continue;
2162             if (nexthop_nh->fib_nh_dev != dev ||
2163                 !__in_dev_get_rtnl(dev))
2164                 continue;
2165             alive++;
2166             nexthop_nh->fib_nh_flags &= ~nh_flags;
2167             call_fib_nh_notifiers(nexthop_nh, FIB_EVENT_NH_ADD);
2168         } endfor_nexthops(fi)
2169 
2170         if (alive > 0) {
2171             fi->fib_flags &= ~nh_flags;
2172             ret++;
2173         }
2174 
2175         fib_rebalance(fi);
2176     }
2177 
2178     return ret;
2179 }
2180 
2181 #ifdef CONFIG_IP_ROUTE_MULTIPATH
2182 static bool fib_good_nh(const struct fib_nh *nh)
2183 {
2184     int state = NUD_REACHABLE;
2185 
2186     if (nh->fib_nh_scope == RT_SCOPE_LINK) {
2187         struct neighbour *n;
2188 
2189         rcu_read_lock_bh();
2190 
2191         if (likely(nh->fib_nh_gw_family == AF_INET))
2192             n = __ipv4_neigh_lookup_noref(nh->fib_nh_dev,
2193                            (__force u32)nh->fib_nh_gw4);
2194         else if (nh->fib_nh_gw_family == AF_INET6)
2195             n = __ipv6_neigh_lookup_noref_stub(nh->fib_nh_dev,
2196                                &nh->fib_nh_gw6);
2197         else
2198             n = NULL;
2199         if (n)
2200             state = n->nud_state;
2201 
2202         rcu_read_unlock_bh();
2203     }
2204 
2205     return !!(state & NUD_VALID);
2206 }
2207 
2208 void fib_select_multipath(struct fib_result *res, int hash)
2209 {
2210     struct fib_info *fi = res->fi;
2211     struct net *net = fi->fib_net;
2212     bool first = false;
2213 
2214     if (unlikely(res->fi->nh)) {
2215         nexthop_path_fib_result(res, hash);
2216         return;
2217     }
2218 
2219     change_nexthops(fi) {
2220         if (READ_ONCE(net->ipv4.sysctl_fib_multipath_use_neigh)) {
2221             if (!fib_good_nh(nexthop_nh))
2222                 continue;
2223             if (!first) {
2224                 res->nh_sel = nhsel;
2225                 res->nhc = &nexthop_nh->nh_common;
2226                 first = true;
2227             }
2228         }
2229 
2230         if (hash > atomic_read(&nexthop_nh->fib_nh_upper_bound))
2231             continue;
2232 
2233         res->nh_sel = nhsel;
2234         res->nhc = &nexthop_nh->nh_common;
2235         return;
2236     } endfor_nexthops(fi);
2237 }
2238 #endif
2239 
2240 void fib_select_path(struct net *net, struct fib_result *res,
2241              struct flowi4 *fl4, const struct sk_buff *skb)
2242 {
2243     if (fl4->flowi4_oif)
2244         goto check_saddr;
2245 
2246 #ifdef CONFIG_IP_ROUTE_MULTIPATH
2247     if (fib_info_num_path(res->fi) > 1) {
2248         int h = fib_multipath_hash(net, fl4, skb, NULL);
2249 
2250         fib_select_multipath(res, h);
2251     }
2252     else
2253 #endif
2254     if (!res->prefixlen &&
2255         res->table->tb_num_default > 1 &&
2256         res->type == RTN_UNICAST)
2257         fib_select_default(fl4, res);
2258 
2259 check_saddr:
2260     if (!fl4->saddr)
2261         fl4->saddr = fib_result_prefsrc(net, res);
2262 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!