2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
6 * IPv4 Forwarding Information Base: FIB frontend.
8 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version
13 * 2 of the License, or (at your option) any later version.
16 #include <linux/module.h>
17 #include <asm/uaccess.h>
18 #include <asm/system.h>
19 #include <linux/bitops.h>
20 #include <linux/capability.h>
21 #include <linux/types.h>
22 #include <linux/kernel.h>
24 #include <linux/string.h>
25 #include <linux/socket.h>
26 #include <linux/sockios.h>
27 #include <linux/errno.h>
29 #include <linux/inet.h>
30 #include <linux/inetdevice.h>
31 #include <linux/netdevice.h>
32 #include <linux/if_addr.h>
33 #include <linux/if_arp.h>
34 #include <linux/skbuff.h>
35 #include <linux/init.h>
36 #include <linux/list.h>
37 #include <linux/slab.h>
40 #include <net/protocol.h>
41 #include <net/route.h>
45 #include <net/ip_fib.h>
46 #include <net/rtnetlink.h>
48 #ifndef CONFIG_IP_MULTIPLE_TABLES
50 static int __net_init fib4_rules_init(struct net *net)
52 struct fib_table *local_table, *main_table;
54 local_table = fib_hash_table(RT_TABLE_LOCAL);
55 if (local_table == NULL)
58 main_table = fib_hash_table(RT_TABLE_MAIN);
59 if (main_table == NULL)
62 hlist_add_head_rcu(&local_table->tb_hlist,
63 &net->ipv4.fib_table_hash[TABLE_LOCAL_INDEX]);
64 hlist_add_head_rcu(&main_table->tb_hlist,
65 &net->ipv4.fib_table_hash[TABLE_MAIN_INDEX]);
74 struct fib_table *fib_new_table(struct net *net, u32 id)
81 tb = fib_get_table(net, id);
85 tb = fib_hash_table(id);
88 h = id & (FIB_TABLE_HASHSZ - 1);
89 hlist_add_head_rcu(&tb->tb_hlist, &net->ipv4.fib_table_hash[h]);
93 struct fib_table *fib_get_table(struct net *net, u32 id)
96 struct hlist_node *node;
97 struct hlist_head *head;
102 h = id & (FIB_TABLE_HASHSZ - 1);
105 head = &net->ipv4.fib_table_hash[h];
106 hlist_for_each_entry_rcu(tb, node, head, tb_hlist) {
107 if (tb->tb_id == id) {
115 #endif /* CONFIG_IP_MULTIPLE_TABLES */
117 void fib_select_default(struct net *net,
118 const struct flowi *flp, struct fib_result *res)
120 struct fib_table *tb;
121 int table = RT_TABLE_MAIN;
122 #ifdef CONFIG_IP_MULTIPLE_TABLES
123 if (res->r == NULL || res->r->action != FR_ACT_TO_TBL)
125 table = res->r->table;
127 tb = fib_get_table(net, table);
128 if (FIB_RES_GW(*res) && FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK)
129 fib_table_select_default(tb, flp, res);
132 static void fib_flush(struct net *net)
135 struct fib_table *tb;
136 struct hlist_node *node;
137 struct hlist_head *head;
140 for (h = 0; h < FIB_TABLE_HASHSZ; h++) {
141 head = &net->ipv4.fib_table_hash[h];
142 hlist_for_each_entry(tb, node, head, tb_hlist)
143 flushed += fib_table_flush(tb);
147 rt_cache_flush(net, -1);
151 * __ip_dev_find - find the first device with a given source address.
152 * @net: the net namespace
153 * @addr: the source address
154 * @devref: if true, take a reference on the found device
156 * If a caller uses devref=false, it should be protected by RCU
158 struct net_device *__ip_dev_find(struct net *net, __be32 addr, bool devref)
166 .flags = FLOWI_FLAG_MATCH_ANY_IIF
168 struct fib_result res = { 0 };
169 struct net_device *dev = NULL;
171 if (fib_lookup(net, &fl, &res))
173 if (res.type != RTN_LOCAL)
175 dev = FIB_RES_DEV(res);
183 EXPORT_SYMBOL(__ip_dev_find);
186 * Find address type as if only "dev" was present in the system. If
187 * on_dev is NULL then all interfaces are taken into consideration.
189 static inline unsigned __inet_dev_addr_type(struct net *net,
190 const struct net_device *dev,
193 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
194 struct fib_result res;
195 unsigned ret = RTN_BROADCAST;
196 struct fib_table *local_table;
198 if (ipv4_is_zeronet(addr) || ipv4_is_lbcast(addr))
199 return RTN_BROADCAST;
200 if (ipv4_is_multicast(addr))
201 return RTN_MULTICAST;
203 #ifdef CONFIG_IP_MULTIPLE_TABLES
207 local_table = fib_get_table(net, RT_TABLE_LOCAL);
210 if (!fib_table_lookup(local_table, &fl, &res)) {
211 if (!dev || dev == res.fi->fib_dev)
219 unsigned int inet_addr_type(struct net *net, __be32 addr)
221 return __inet_dev_addr_type(net, NULL, addr);
223 EXPORT_SYMBOL(inet_addr_type);
225 unsigned int inet_dev_addr_type(struct net *net, const struct net_device *dev,
228 return __inet_dev_addr_type(net, dev, addr);
230 EXPORT_SYMBOL(inet_dev_addr_type);
232 /* Given (packet source, input interface) and optional (dst, oif, tos):
233 - (main) check, that source is valid i.e. not broadcast or our local
235 - figure out what "logical" interface this packet arrived
236 and calculate "specific destination" address.
237 - check, that packet arrived from expected physical interface.
240 int fib_validate_source(__be32 src, __be32 dst, u8 tos, int oif,
241 struct net_device *dev, __be32 *spec_dst,
244 struct in_device *in_dev;
245 struct flowi fl = { .nl_u = { .ip4_u =
252 struct fib_result res;
253 int no_addr, rpf, accept_local;
258 no_addr = rpf = accept_local = 0;
260 in_dev = __in_dev_get_rcu(dev);
262 no_addr = in_dev->ifa_list == NULL;
263 rpf = IN_DEV_RPFILTER(in_dev);
264 accept_local = IN_DEV_ACCEPT_LOCAL(in_dev);
265 if (mark && !IN_DEV_SRC_VMARK(in_dev))
274 if (fib_lookup(net, &fl, &res))
276 if (res.type != RTN_UNICAST) {
277 if (res.type != RTN_LOCAL || !accept_local)
280 *spec_dst = FIB_RES_PREFSRC(res);
281 fib_combine_itag(itag, &res);
284 #ifdef CONFIG_IP_ROUTE_MULTIPATH
285 for (ret = 0; ret < res.fi->fib_nhs; ret++) {
286 struct fib_nh *nh = &res.fi->fib_nh[ret];
288 if (nh->nh_dev == dev) {
294 if (FIB_RES_DEV(res) == dev)
298 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
307 fl.oif = dev->ifindex;
310 if (fib_lookup(net, &fl, &res) == 0) {
311 if (res.type == RTN_UNICAST) {
312 *spec_dst = FIB_RES_PREFSRC(res);
313 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
322 *spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
334 static inline __be32 sk_extract_addr(struct sockaddr *addr)
336 return ((struct sockaddr_in *) addr)->sin_addr.s_addr;
339 static int put_rtax(struct nlattr *mx, int len, int type, u32 value)
343 nla = (struct nlattr *) ((char *) mx + len);
344 nla->nla_type = type;
345 nla->nla_len = nla_attr_size(4);
346 *(u32 *) nla_data(nla) = value;
348 return len + nla_total_size(4);
351 static int rtentry_to_fib_config(struct net *net, int cmd, struct rtentry *rt,
352 struct fib_config *cfg)
357 memset(cfg, 0, sizeof(*cfg));
358 cfg->fc_nlinfo.nl_net = net;
360 if (rt->rt_dst.sa_family != AF_INET)
361 return -EAFNOSUPPORT;
364 * Check mask for validity:
365 * a) it must be contiguous.
366 * b) destination must have all host bits clear.
367 * c) if application forgot to set correct family (AF_INET),
368 * reject request unless it is absolutely clear i.e.
369 * both family and mask are zero.
372 addr = sk_extract_addr(&rt->rt_dst);
373 if (!(rt->rt_flags & RTF_HOST)) {
374 __be32 mask = sk_extract_addr(&rt->rt_genmask);
376 if (rt->rt_genmask.sa_family != AF_INET) {
377 if (mask || rt->rt_genmask.sa_family)
378 return -EAFNOSUPPORT;
381 if (bad_mask(mask, addr))
384 plen = inet_mask_len(mask);
387 cfg->fc_dst_len = plen;
390 if (cmd != SIOCDELRT) {
391 cfg->fc_nlflags = NLM_F_CREATE;
392 cfg->fc_protocol = RTPROT_BOOT;
396 cfg->fc_priority = rt->rt_metric - 1;
398 if (rt->rt_flags & RTF_REJECT) {
399 cfg->fc_scope = RT_SCOPE_HOST;
400 cfg->fc_type = RTN_UNREACHABLE;
404 cfg->fc_scope = RT_SCOPE_NOWHERE;
405 cfg->fc_type = RTN_UNICAST;
409 struct net_device *dev;
410 char devname[IFNAMSIZ];
412 if (copy_from_user(devname, rt->rt_dev, IFNAMSIZ-1))
415 devname[IFNAMSIZ-1] = 0;
416 colon = strchr(devname, ':');
419 dev = __dev_get_by_name(net, devname);
422 cfg->fc_oif = dev->ifindex;
424 struct in_ifaddr *ifa;
425 struct in_device *in_dev = __in_dev_get_rtnl(dev);
429 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next)
430 if (strcmp(ifa->ifa_label, devname) == 0)
434 cfg->fc_prefsrc = ifa->ifa_local;
438 addr = sk_extract_addr(&rt->rt_gateway);
439 if (rt->rt_gateway.sa_family == AF_INET && addr) {
441 if (rt->rt_flags & RTF_GATEWAY &&
442 inet_addr_type(net, addr) == RTN_UNICAST)
443 cfg->fc_scope = RT_SCOPE_UNIVERSE;
446 if (cmd == SIOCDELRT)
449 if (rt->rt_flags & RTF_GATEWAY && !cfg->fc_gw)
452 if (cfg->fc_scope == RT_SCOPE_NOWHERE)
453 cfg->fc_scope = RT_SCOPE_LINK;
455 if (rt->rt_flags & (RTF_MTU | RTF_WINDOW | RTF_IRTT)) {
459 mx = kzalloc(3 * nla_total_size(4), GFP_KERNEL);
463 if (rt->rt_flags & RTF_MTU)
464 len = put_rtax(mx, len, RTAX_ADVMSS, rt->rt_mtu - 40);
466 if (rt->rt_flags & RTF_WINDOW)
467 len = put_rtax(mx, len, RTAX_WINDOW, rt->rt_window);
469 if (rt->rt_flags & RTF_IRTT)
470 len = put_rtax(mx, len, RTAX_RTT, rt->rt_irtt << 3);
473 cfg->fc_mx_len = len;
480 * Handle IP routing ioctl calls. These are used to manipulate the routing tables
483 int ip_rt_ioctl(struct net *net, unsigned int cmd, void __user *arg)
485 struct fib_config cfg;
490 case SIOCADDRT: /* Add a route */
491 case SIOCDELRT: /* Delete a route */
492 if (!capable(CAP_NET_ADMIN))
495 if (copy_from_user(&rt, arg, sizeof(rt)))
499 err = rtentry_to_fib_config(net, cmd, &rt, &cfg);
501 struct fib_table *tb;
503 if (cmd == SIOCDELRT) {
504 tb = fib_get_table(net, cfg.fc_table);
506 err = fib_table_delete(tb, &cfg);
510 tb = fib_new_table(net, cfg.fc_table);
512 err = fib_table_insert(tb, &cfg);
517 /* allocated by rtentry_to_fib_config() */
526 const struct nla_policy rtm_ipv4_policy[RTA_MAX+1] = {
527 [RTA_DST] = { .type = NLA_U32 },
528 [RTA_SRC] = { .type = NLA_U32 },
529 [RTA_IIF] = { .type = NLA_U32 },
530 [RTA_OIF] = { .type = NLA_U32 },
531 [RTA_GATEWAY] = { .type = NLA_U32 },
532 [RTA_PRIORITY] = { .type = NLA_U32 },
533 [RTA_PREFSRC] = { .type = NLA_U32 },
534 [RTA_METRICS] = { .type = NLA_NESTED },
535 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
536 [RTA_FLOW] = { .type = NLA_U32 },
539 static int rtm_to_fib_config(struct net *net, struct sk_buff *skb,
540 struct nlmsghdr *nlh, struct fib_config *cfg)
546 err = nlmsg_validate(nlh, sizeof(*rtm), RTA_MAX, rtm_ipv4_policy);
550 memset(cfg, 0, sizeof(*cfg));
552 rtm = nlmsg_data(nlh);
553 cfg->fc_dst_len = rtm->rtm_dst_len;
554 cfg->fc_tos = rtm->rtm_tos;
555 cfg->fc_table = rtm->rtm_table;
556 cfg->fc_protocol = rtm->rtm_protocol;
557 cfg->fc_scope = rtm->rtm_scope;
558 cfg->fc_type = rtm->rtm_type;
559 cfg->fc_flags = rtm->rtm_flags;
560 cfg->fc_nlflags = nlh->nlmsg_flags;
562 cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
563 cfg->fc_nlinfo.nlh = nlh;
564 cfg->fc_nlinfo.nl_net = net;
566 if (cfg->fc_type > RTN_MAX) {
571 nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), remaining) {
572 switch (nla_type(attr)) {
574 cfg->fc_dst = nla_get_be32(attr);
577 cfg->fc_oif = nla_get_u32(attr);
580 cfg->fc_gw = nla_get_be32(attr);
583 cfg->fc_priority = nla_get_u32(attr);
586 cfg->fc_prefsrc = nla_get_be32(attr);
589 cfg->fc_mx = nla_data(attr);
590 cfg->fc_mx_len = nla_len(attr);
593 cfg->fc_mp = nla_data(attr);
594 cfg->fc_mp_len = nla_len(attr);
597 cfg->fc_flow = nla_get_u32(attr);
600 cfg->fc_table = nla_get_u32(attr);
610 static int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
612 struct net *net = sock_net(skb->sk);
613 struct fib_config cfg;
614 struct fib_table *tb;
617 err = rtm_to_fib_config(net, skb, nlh, &cfg);
621 tb = fib_get_table(net, cfg.fc_table);
627 err = fib_table_delete(tb, &cfg);
632 static int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
634 struct net *net = sock_net(skb->sk);
635 struct fib_config cfg;
636 struct fib_table *tb;
639 err = rtm_to_fib_config(net, skb, nlh, &cfg);
643 tb = fib_new_table(net, cfg.fc_table);
649 err = fib_table_insert(tb, &cfg);
654 static int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
656 struct net *net = sock_net(skb->sk);
658 unsigned int e = 0, s_e;
659 struct fib_table *tb;
660 struct hlist_node *node;
661 struct hlist_head *head;
664 if (nlmsg_len(cb->nlh) >= sizeof(struct rtmsg) &&
665 ((struct rtmsg *) nlmsg_data(cb->nlh))->rtm_flags & RTM_F_CLONED)
666 return ip_rt_dump(skb, cb);
671 for (h = s_h; h < FIB_TABLE_HASHSZ; h++, s_e = 0) {
673 head = &net->ipv4.fib_table_hash[h];
674 hlist_for_each_entry(tb, node, head, tb_hlist) {
678 memset(&cb->args[2], 0, sizeof(cb->args) -
679 2 * sizeof(cb->args[0]));
680 if (fib_table_dump(tb, skb, cb) < 0)
694 /* Prepare and feed intra-kernel routing request.
695 Really, it should be netlink message, but :-( netlink
696 can be not configured, so that we feed it directly
697 to fib engine. It is legal, because all events occur
698 only when netlink is already locked.
701 static void fib_magic(int cmd, int type, __be32 dst, int dst_len, struct in_ifaddr *ifa)
703 struct net *net = dev_net(ifa->ifa_dev->dev);
704 struct fib_table *tb;
705 struct fib_config cfg = {
706 .fc_protocol = RTPROT_KERNEL,
709 .fc_dst_len = dst_len,
710 .fc_prefsrc = ifa->ifa_local,
711 .fc_oif = ifa->ifa_dev->dev->ifindex,
712 .fc_nlflags = NLM_F_CREATE | NLM_F_APPEND,
718 if (type == RTN_UNICAST)
719 tb = fib_new_table(net, RT_TABLE_MAIN);
721 tb = fib_new_table(net, RT_TABLE_LOCAL);
726 cfg.fc_table = tb->tb_id;
728 if (type != RTN_LOCAL)
729 cfg.fc_scope = RT_SCOPE_LINK;
731 cfg.fc_scope = RT_SCOPE_HOST;
733 if (cmd == RTM_NEWROUTE)
734 fib_table_insert(tb, &cfg);
736 fib_table_delete(tb, &cfg);
739 void fib_add_ifaddr(struct in_ifaddr *ifa)
741 struct in_device *in_dev = ifa->ifa_dev;
742 struct net_device *dev = in_dev->dev;
743 struct in_ifaddr *prim = ifa;
744 __be32 mask = ifa->ifa_mask;
745 __be32 addr = ifa->ifa_local;
746 __be32 prefix = ifa->ifa_address&mask;
748 if (ifa->ifa_flags&IFA_F_SECONDARY) {
749 prim = inet_ifa_byprefix(in_dev, prefix, mask);
751 printk(KERN_WARNING "fib_add_ifaddr: bug: prim == NULL\n");
756 fib_magic(RTM_NEWROUTE, RTN_LOCAL, addr, 32, prim);
758 if (!(dev->flags&IFF_UP))
761 /* Add broadcast address, if it is explicitly assigned. */
762 if (ifa->ifa_broadcast && ifa->ifa_broadcast != htonl(0xFFFFFFFF))
763 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
765 if (!ipv4_is_zeronet(prefix) && !(ifa->ifa_flags&IFA_F_SECONDARY) &&
766 (prefix != addr || ifa->ifa_prefixlen < 32)) {
767 fib_magic(RTM_NEWROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
768 RTN_UNICAST, prefix, ifa->ifa_prefixlen, prim);
770 /* Add network specific broadcasts, when it takes a sense */
771 if (ifa->ifa_prefixlen < 31) {
772 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix, 32, prim);
773 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix|~mask, 32, prim);
778 static void fib_del_ifaddr(struct in_ifaddr *ifa)
780 struct in_device *in_dev = ifa->ifa_dev;
781 struct net_device *dev = in_dev->dev;
782 struct in_ifaddr *ifa1;
783 struct in_ifaddr *prim = ifa;
784 __be32 brd = ifa->ifa_address|~ifa->ifa_mask;
785 __be32 any = ifa->ifa_address&ifa->ifa_mask;
792 if (!(ifa->ifa_flags&IFA_F_SECONDARY))
793 fib_magic(RTM_DELROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
794 RTN_UNICAST, any, ifa->ifa_prefixlen, prim);
796 prim = inet_ifa_byprefix(in_dev, any, ifa->ifa_mask);
798 printk(KERN_WARNING "fib_del_ifaddr: bug: prim == NULL\n");
803 /* Deletion is more complicated than add.
804 We should take care of not to delete too much :-)
806 Scan address list to be sure that addresses are really gone.
809 for (ifa1 = in_dev->ifa_list; ifa1; ifa1 = ifa1->ifa_next) {
810 if (ifa->ifa_local == ifa1->ifa_local)
812 if (ifa->ifa_broadcast == ifa1->ifa_broadcast)
814 if (brd == ifa1->ifa_broadcast)
816 if (any == ifa1->ifa_broadcast)
821 fib_magic(RTM_DELROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
823 fib_magic(RTM_DELROUTE, RTN_BROADCAST, brd, 32, prim);
825 fib_magic(RTM_DELROUTE, RTN_BROADCAST, any, 32, prim);
826 if (!(ok&LOCAL_OK)) {
827 fib_magic(RTM_DELROUTE, RTN_LOCAL, ifa->ifa_local, 32, prim);
829 /* Check, that this local address finally disappeared. */
830 if (inet_addr_type(dev_net(dev), ifa->ifa_local) != RTN_LOCAL) {
831 /* And the last, but not the least thing.
832 We must flush stray FIB entries.
834 First of all, we scan fib_info list searching
835 for stray nexthop entries, then ignite fib_flush.
837 if (fib_sync_down_addr(dev_net(dev), ifa->ifa_local))
838 fib_flush(dev_net(dev));
847 static void nl_fib_lookup(struct fib_result_nl *frn, struct fib_table *tb )
850 struct fib_result res;
851 struct flowi fl = { .mark = frn->fl_mark,
852 .nl_u = { .ip4_u = { .daddr = frn->fl_addr,
854 .scope = frn->fl_scope } } };
856 #ifdef CONFIG_IP_MULTIPLE_TABLES
864 frn->tb_id = tb->tb_id;
865 frn->err = fib_table_lookup(tb, &fl, &res);
868 frn->prefixlen = res.prefixlen;
869 frn->nh_sel = res.nh_sel;
870 frn->type = res.type;
871 frn->scope = res.scope;
878 static void nl_fib_input(struct sk_buff *skb)
881 struct fib_result_nl *frn;
882 struct nlmsghdr *nlh;
883 struct fib_table *tb;
886 net = sock_net(skb->sk);
887 nlh = nlmsg_hdr(skb);
888 if (skb->len < NLMSG_SPACE(0) || skb->len < nlh->nlmsg_len ||
889 nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*frn)))
892 skb = skb_clone(skb, GFP_KERNEL);
895 nlh = nlmsg_hdr(skb);
897 frn = (struct fib_result_nl *) NLMSG_DATA(nlh);
898 tb = fib_get_table(net, frn->tb_id_in);
900 nl_fib_lookup(frn, tb);
902 pid = NETLINK_CB(skb).pid; /* pid of sending process */
903 NETLINK_CB(skb).pid = 0; /* from kernel */
904 NETLINK_CB(skb).dst_group = 0; /* unicast */
905 netlink_unicast(net->ipv4.fibnl, skb, pid, MSG_DONTWAIT);
908 static int __net_init nl_fib_lookup_init(struct net *net)
911 sk = netlink_kernel_create(net, NETLINK_FIB_LOOKUP, 0,
912 nl_fib_input, NULL, THIS_MODULE);
914 return -EAFNOSUPPORT;
915 net->ipv4.fibnl = sk;
919 static void nl_fib_lookup_exit(struct net *net)
921 netlink_kernel_release(net->ipv4.fibnl);
922 net->ipv4.fibnl = NULL;
925 static void fib_disable_ip(struct net_device *dev, int force, int delay)
927 if (fib_sync_down_dev(dev, force))
928 fib_flush(dev_net(dev));
929 rt_cache_flush(dev_net(dev), delay);
933 static int fib_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
935 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
936 struct net_device *dev = ifa->ifa_dev->dev;
941 #ifdef CONFIG_IP_ROUTE_MULTIPATH
944 rt_cache_flush(dev_net(dev), -1);
948 if (ifa->ifa_dev->ifa_list == NULL) {
949 /* Last address was deleted from this interface.
952 fib_disable_ip(dev, 1, 0);
954 rt_cache_flush(dev_net(dev), -1);
961 static int fib_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
963 struct net_device *dev = ptr;
964 struct in_device *in_dev = __in_dev_get_rtnl(dev);
966 if (event == NETDEV_UNREGISTER) {
967 fib_disable_ip(dev, 2, -1);
978 } endfor_ifa(in_dev);
979 #ifdef CONFIG_IP_ROUTE_MULTIPATH
982 rt_cache_flush(dev_net(dev), -1);
985 fib_disable_ip(dev, 0, 0);
987 case NETDEV_CHANGEMTU:
989 rt_cache_flush(dev_net(dev), 0);
991 case NETDEV_UNREGISTER_BATCH:
992 rt_cache_flush_batch();
998 static struct notifier_block fib_inetaddr_notifier = {
999 .notifier_call = fib_inetaddr_event,
1002 static struct notifier_block fib_netdev_notifier = {
1003 .notifier_call = fib_netdev_event,
1006 static int __net_init ip_fib_net_init(struct net *net)
1011 net->ipv4.fib_table_hash = kzalloc(
1012 sizeof(struct hlist_head)*FIB_TABLE_HASHSZ, GFP_KERNEL);
1013 if (net->ipv4.fib_table_hash == NULL)
1016 for (i = 0; i < FIB_TABLE_HASHSZ; i++)
1017 INIT_HLIST_HEAD(&net->ipv4.fib_table_hash[i]);
1019 err = fib4_rules_init(net);
1025 kfree(net->ipv4.fib_table_hash);
1029 static void ip_fib_net_exit(struct net *net)
1033 #ifdef CONFIG_IP_MULTIPLE_TABLES
1034 fib4_rules_exit(net);
1037 for (i = 0; i < FIB_TABLE_HASHSZ; i++) {
1038 struct fib_table *tb;
1039 struct hlist_head *head;
1040 struct hlist_node *node, *tmp;
1042 head = &net->ipv4.fib_table_hash[i];
1043 hlist_for_each_entry_safe(tb, node, tmp, head, tb_hlist) {
1045 fib_table_flush(tb);
1049 kfree(net->ipv4.fib_table_hash);
1052 static int __net_init fib_net_init(struct net *net)
1056 error = ip_fib_net_init(net);
1059 error = nl_fib_lookup_init(net);
1062 error = fib_proc_init(net);
1069 nl_fib_lookup_exit(net);
1071 ip_fib_net_exit(net);
1075 static void __net_exit fib_net_exit(struct net *net)
1078 nl_fib_lookup_exit(net);
1079 ip_fib_net_exit(net);
1082 static struct pernet_operations fib_net_ops = {
1083 .init = fib_net_init,
1084 .exit = fib_net_exit,
1087 void __init ip_fib_init(void)
1089 rtnl_register(PF_INET, RTM_NEWROUTE, inet_rtm_newroute, NULL);
1090 rtnl_register(PF_INET, RTM_DELROUTE, inet_rtm_delroute, NULL);
1091 rtnl_register(PF_INET, RTM_GETROUTE, NULL, inet_dump_fib);
1093 register_pernet_subsys(&fib_net_ops);
1094 register_netdevice_notifier(&fib_netdev_notifier);
1095 register_inetaddr_notifier(&fib_inetaddr_notifier);