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 * Find the first device with a given source address.
154 struct net_device * ip_dev_find(struct net *net, __be32 addr)
156 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
157 struct fib_result res;
158 struct net_device *dev = NULL;
159 struct fib_table *local_table;
161 #ifdef CONFIG_IP_MULTIPLE_TABLES
165 local_table = fib_get_table(net, RT_TABLE_LOCAL);
166 if (!local_table || fib_table_lookup(local_table, &fl, &res))
168 if (res.type != RTN_LOCAL)
170 dev = FIB_RES_DEV(res);
180 * Find address type as if only "dev" was present in the system. If
181 * on_dev is NULL then all interfaces are taken into consideration.
183 static inline unsigned __inet_dev_addr_type(struct net *net,
184 const struct net_device *dev,
187 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
188 struct fib_result res;
189 unsigned ret = RTN_BROADCAST;
190 struct fib_table *local_table;
192 if (ipv4_is_zeronet(addr) || ipv4_is_lbcast(addr))
193 return RTN_BROADCAST;
194 if (ipv4_is_multicast(addr))
195 return RTN_MULTICAST;
197 #ifdef CONFIG_IP_MULTIPLE_TABLES
201 local_table = fib_get_table(net, RT_TABLE_LOCAL);
204 if (!fib_table_lookup(local_table, &fl, &res)) {
205 if (!dev || dev == res.fi->fib_dev)
213 unsigned int inet_addr_type(struct net *net, __be32 addr)
215 return __inet_dev_addr_type(net, NULL, addr);
218 unsigned int inet_dev_addr_type(struct net *net, const struct net_device *dev,
221 return __inet_dev_addr_type(net, dev, addr);
224 /* Given (packet source, input interface) and optional (dst, oif, tos):
225 - (main) check, that source is valid i.e. not broadcast or our local
227 - figure out what "logical" interface this packet arrived
228 and calculate "specific destination" address.
229 - check, that packet arrived from expected physical interface.
232 int fib_validate_source(__be32 src, __be32 dst, u8 tos, int oif,
233 struct net_device *dev, __be32 *spec_dst,
236 struct in_device *in_dev;
237 struct flowi fl = { .nl_u = { .ip4_u =
244 struct fib_result res;
245 int no_addr, rpf, accept_local;
249 no_addr = rpf = accept_local = 0;
251 in_dev = __in_dev_get_rcu(dev);
253 no_addr = in_dev->ifa_list == NULL;
254 rpf = IN_DEV_RPFILTER(in_dev);
255 accept_local = IN_DEV_ACCEPT_LOCAL(in_dev);
256 if (mark && !IN_DEV_SRC_VMARK(in_dev))
265 if (fib_lookup(net, &fl, &res))
267 if (res.type != RTN_UNICAST) {
268 if (res.type != RTN_LOCAL || !accept_local)
271 *spec_dst = FIB_RES_PREFSRC(res);
272 fib_combine_itag(itag, &res);
273 #ifdef CONFIG_IP_ROUTE_MULTIPATH
274 if (FIB_RES_DEV(res) == dev || res.fi->fib_nhs > 1)
276 if (FIB_RES_DEV(res) == dev)
279 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
288 fl.oif = dev->ifindex;
291 if (fib_lookup(net, &fl, &res) == 0) {
292 if (res.type == RTN_UNICAST) {
293 *spec_dst = FIB_RES_PREFSRC(res);
294 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
303 *spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
315 static inline __be32 sk_extract_addr(struct sockaddr *addr)
317 return ((struct sockaddr_in *) addr)->sin_addr.s_addr;
320 static int put_rtax(struct nlattr *mx, int len, int type, u32 value)
324 nla = (struct nlattr *) ((char *) mx + len);
325 nla->nla_type = type;
326 nla->nla_len = nla_attr_size(4);
327 *(u32 *) nla_data(nla) = value;
329 return len + nla_total_size(4);
332 static int rtentry_to_fib_config(struct net *net, int cmd, struct rtentry *rt,
333 struct fib_config *cfg)
338 memset(cfg, 0, sizeof(*cfg));
339 cfg->fc_nlinfo.nl_net = net;
341 if (rt->rt_dst.sa_family != AF_INET)
342 return -EAFNOSUPPORT;
345 * Check mask for validity:
346 * a) it must be contiguous.
347 * b) destination must have all host bits clear.
348 * c) if application forgot to set correct family (AF_INET),
349 * reject request unless it is absolutely clear i.e.
350 * both family and mask are zero.
353 addr = sk_extract_addr(&rt->rt_dst);
354 if (!(rt->rt_flags & RTF_HOST)) {
355 __be32 mask = sk_extract_addr(&rt->rt_genmask);
357 if (rt->rt_genmask.sa_family != AF_INET) {
358 if (mask || rt->rt_genmask.sa_family)
359 return -EAFNOSUPPORT;
362 if (bad_mask(mask, addr))
365 plen = inet_mask_len(mask);
368 cfg->fc_dst_len = plen;
371 if (cmd != SIOCDELRT) {
372 cfg->fc_nlflags = NLM_F_CREATE;
373 cfg->fc_protocol = RTPROT_BOOT;
377 cfg->fc_priority = rt->rt_metric - 1;
379 if (rt->rt_flags & RTF_REJECT) {
380 cfg->fc_scope = RT_SCOPE_HOST;
381 cfg->fc_type = RTN_UNREACHABLE;
385 cfg->fc_scope = RT_SCOPE_NOWHERE;
386 cfg->fc_type = RTN_UNICAST;
390 struct net_device *dev;
391 char devname[IFNAMSIZ];
393 if (copy_from_user(devname, rt->rt_dev, IFNAMSIZ-1))
396 devname[IFNAMSIZ-1] = 0;
397 colon = strchr(devname, ':');
400 dev = __dev_get_by_name(net, devname);
403 cfg->fc_oif = dev->ifindex;
405 struct in_ifaddr *ifa;
406 struct in_device *in_dev = __in_dev_get_rtnl(dev);
410 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next)
411 if (strcmp(ifa->ifa_label, devname) == 0)
415 cfg->fc_prefsrc = ifa->ifa_local;
419 addr = sk_extract_addr(&rt->rt_gateway);
420 if (rt->rt_gateway.sa_family == AF_INET && addr) {
422 if (rt->rt_flags & RTF_GATEWAY &&
423 inet_addr_type(net, addr) == RTN_UNICAST)
424 cfg->fc_scope = RT_SCOPE_UNIVERSE;
427 if (cmd == SIOCDELRT)
430 if (rt->rt_flags & RTF_GATEWAY && !cfg->fc_gw)
433 if (cfg->fc_scope == RT_SCOPE_NOWHERE)
434 cfg->fc_scope = RT_SCOPE_LINK;
436 if (rt->rt_flags & (RTF_MTU | RTF_WINDOW | RTF_IRTT)) {
440 mx = kzalloc(3 * nla_total_size(4), GFP_KERNEL);
444 if (rt->rt_flags & RTF_MTU)
445 len = put_rtax(mx, len, RTAX_ADVMSS, rt->rt_mtu - 40);
447 if (rt->rt_flags & RTF_WINDOW)
448 len = put_rtax(mx, len, RTAX_WINDOW, rt->rt_window);
450 if (rt->rt_flags & RTF_IRTT)
451 len = put_rtax(mx, len, RTAX_RTT, rt->rt_irtt << 3);
454 cfg->fc_mx_len = len;
461 * Handle IP routing ioctl calls. These are used to manipulate the routing tables
464 int ip_rt_ioctl(struct net *net, unsigned int cmd, void __user *arg)
466 struct fib_config cfg;
471 case SIOCADDRT: /* Add a route */
472 case SIOCDELRT: /* Delete a route */
473 if (!capable(CAP_NET_ADMIN))
476 if (copy_from_user(&rt, arg, sizeof(rt)))
480 err = rtentry_to_fib_config(net, cmd, &rt, &cfg);
482 struct fib_table *tb;
484 if (cmd == SIOCDELRT) {
485 tb = fib_get_table(net, cfg.fc_table);
487 err = fib_table_delete(tb, &cfg);
491 tb = fib_new_table(net, cfg.fc_table);
493 err = fib_table_insert(tb, &cfg);
498 /* allocated by rtentry_to_fib_config() */
507 const struct nla_policy rtm_ipv4_policy[RTA_MAX+1] = {
508 [RTA_DST] = { .type = NLA_U32 },
509 [RTA_SRC] = { .type = NLA_U32 },
510 [RTA_IIF] = { .type = NLA_U32 },
511 [RTA_OIF] = { .type = NLA_U32 },
512 [RTA_GATEWAY] = { .type = NLA_U32 },
513 [RTA_PRIORITY] = { .type = NLA_U32 },
514 [RTA_PREFSRC] = { .type = NLA_U32 },
515 [RTA_METRICS] = { .type = NLA_NESTED },
516 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
517 [RTA_FLOW] = { .type = NLA_U32 },
520 static int rtm_to_fib_config(struct net *net, struct sk_buff *skb,
521 struct nlmsghdr *nlh, struct fib_config *cfg)
527 err = nlmsg_validate(nlh, sizeof(*rtm), RTA_MAX, rtm_ipv4_policy);
531 memset(cfg, 0, sizeof(*cfg));
533 rtm = nlmsg_data(nlh);
534 cfg->fc_dst_len = rtm->rtm_dst_len;
535 cfg->fc_tos = rtm->rtm_tos;
536 cfg->fc_table = rtm->rtm_table;
537 cfg->fc_protocol = rtm->rtm_protocol;
538 cfg->fc_scope = rtm->rtm_scope;
539 cfg->fc_type = rtm->rtm_type;
540 cfg->fc_flags = rtm->rtm_flags;
541 cfg->fc_nlflags = nlh->nlmsg_flags;
543 cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
544 cfg->fc_nlinfo.nlh = nlh;
545 cfg->fc_nlinfo.nl_net = net;
547 if (cfg->fc_type > RTN_MAX) {
552 nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), remaining) {
553 switch (nla_type(attr)) {
555 cfg->fc_dst = nla_get_be32(attr);
558 cfg->fc_oif = nla_get_u32(attr);
561 cfg->fc_gw = nla_get_be32(attr);
564 cfg->fc_priority = nla_get_u32(attr);
567 cfg->fc_prefsrc = nla_get_be32(attr);
570 cfg->fc_mx = nla_data(attr);
571 cfg->fc_mx_len = nla_len(attr);
574 cfg->fc_mp = nla_data(attr);
575 cfg->fc_mp_len = nla_len(attr);
578 cfg->fc_flow = nla_get_u32(attr);
581 cfg->fc_table = nla_get_u32(attr);
591 static int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
593 struct net *net = sock_net(skb->sk);
594 struct fib_config cfg;
595 struct fib_table *tb;
598 err = rtm_to_fib_config(net, skb, nlh, &cfg);
602 tb = fib_get_table(net, cfg.fc_table);
608 err = fib_table_delete(tb, &cfg);
613 static int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
615 struct net *net = sock_net(skb->sk);
616 struct fib_config cfg;
617 struct fib_table *tb;
620 err = rtm_to_fib_config(net, skb, nlh, &cfg);
624 tb = fib_new_table(net, cfg.fc_table);
630 err = fib_table_insert(tb, &cfg);
635 static int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
637 struct net *net = sock_net(skb->sk);
639 unsigned int e = 0, s_e;
640 struct fib_table *tb;
641 struct hlist_node *node;
642 struct hlist_head *head;
645 if (nlmsg_len(cb->nlh) >= sizeof(struct rtmsg) &&
646 ((struct rtmsg *) nlmsg_data(cb->nlh))->rtm_flags & RTM_F_CLONED)
647 return ip_rt_dump(skb, cb);
652 for (h = s_h; h < FIB_TABLE_HASHSZ; h++, s_e = 0) {
654 head = &net->ipv4.fib_table_hash[h];
655 hlist_for_each_entry(tb, node, head, tb_hlist) {
659 memset(&cb->args[2], 0, sizeof(cb->args) -
660 2 * sizeof(cb->args[0]));
661 if (fib_table_dump(tb, skb, cb) < 0)
675 /* Prepare and feed intra-kernel routing request.
676 Really, it should be netlink message, but :-( netlink
677 can be not configured, so that we feed it directly
678 to fib engine. It is legal, because all events occur
679 only when netlink is already locked.
682 static void fib_magic(int cmd, int type, __be32 dst, int dst_len, struct in_ifaddr *ifa)
684 struct net *net = dev_net(ifa->ifa_dev->dev);
685 struct fib_table *tb;
686 struct fib_config cfg = {
687 .fc_protocol = RTPROT_KERNEL,
690 .fc_dst_len = dst_len,
691 .fc_prefsrc = ifa->ifa_local,
692 .fc_oif = ifa->ifa_dev->dev->ifindex,
693 .fc_nlflags = NLM_F_CREATE | NLM_F_APPEND,
699 if (type == RTN_UNICAST)
700 tb = fib_new_table(net, RT_TABLE_MAIN);
702 tb = fib_new_table(net, RT_TABLE_LOCAL);
707 cfg.fc_table = tb->tb_id;
709 if (type != RTN_LOCAL)
710 cfg.fc_scope = RT_SCOPE_LINK;
712 cfg.fc_scope = RT_SCOPE_HOST;
714 if (cmd == RTM_NEWROUTE)
715 fib_table_insert(tb, &cfg);
717 fib_table_delete(tb, &cfg);
720 void fib_add_ifaddr(struct in_ifaddr *ifa)
722 struct in_device *in_dev = ifa->ifa_dev;
723 struct net_device *dev = in_dev->dev;
724 struct in_ifaddr *prim = ifa;
725 __be32 mask = ifa->ifa_mask;
726 __be32 addr = ifa->ifa_local;
727 __be32 prefix = ifa->ifa_address&mask;
729 if (ifa->ifa_flags&IFA_F_SECONDARY) {
730 prim = inet_ifa_byprefix(in_dev, prefix, mask);
732 printk(KERN_WARNING "fib_add_ifaddr: bug: prim == NULL\n");
737 fib_magic(RTM_NEWROUTE, RTN_LOCAL, addr, 32, prim);
739 if (!(dev->flags&IFF_UP))
742 /* Add broadcast address, if it is explicitly assigned. */
743 if (ifa->ifa_broadcast && ifa->ifa_broadcast != htonl(0xFFFFFFFF))
744 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
746 if (!ipv4_is_zeronet(prefix) && !(ifa->ifa_flags&IFA_F_SECONDARY) &&
747 (prefix != addr || ifa->ifa_prefixlen < 32)) {
748 fib_magic(RTM_NEWROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
749 RTN_UNICAST, prefix, ifa->ifa_prefixlen, prim);
751 /* Add network specific broadcasts, when it takes a sense */
752 if (ifa->ifa_prefixlen < 31) {
753 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix, 32, prim);
754 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix|~mask, 32, prim);
759 static void fib_del_ifaddr(struct in_ifaddr *ifa)
761 struct in_device *in_dev = ifa->ifa_dev;
762 struct net_device *dev = in_dev->dev;
763 struct in_ifaddr *ifa1;
764 struct in_ifaddr *prim = ifa;
765 __be32 brd = ifa->ifa_address|~ifa->ifa_mask;
766 __be32 any = ifa->ifa_address&ifa->ifa_mask;
773 if (!(ifa->ifa_flags&IFA_F_SECONDARY))
774 fib_magic(RTM_DELROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
775 RTN_UNICAST, any, ifa->ifa_prefixlen, prim);
777 prim = inet_ifa_byprefix(in_dev, any, ifa->ifa_mask);
779 printk(KERN_WARNING "fib_del_ifaddr: bug: prim == NULL\n");
784 /* Deletion is more complicated than add.
785 We should take care of not to delete too much :-)
787 Scan address list to be sure that addresses are really gone.
790 for (ifa1 = in_dev->ifa_list; ifa1; ifa1 = ifa1->ifa_next) {
791 if (ifa->ifa_local == ifa1->ifa_local)
793 if (ifa->ifa_broadcast == ifa1->ifa_broadcast)
795 if (brd == ifa1->ifa_broadcast)
797 if (any == ifa1->ifa_broadcast)
802 fib_magic(RTM_DELROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
804 fib_magic(RTM_DELROUTE, RTN_BROADCAST, brd, 32, prim);
806 fib_magic(RTM_DELROUTE, RTN_BROADCAST, any, 32, prim);
807 if (!(ok&LOCAL_OK)) {
808 fib_magic(RTM_DELROUTE, RTN_LOCAL, ifa->ifa_local, 32, prim);
810 /* Check, that this local address finally disappeared. */
811 if (inet_addr_type(dev_net(dev), ifa->ifa_local) != RTN_LOCAL) {
812 /* And the last, but not the least thing.
813 We must flush stray FIB entries.
815 First of all, we scan fib_info list searching
816 for stray nexthop entries, then ignite fib_flush.
818 if (fib_sync_down_addr(dev_net(dev), ifa->ifa_local))
819 fib_flush(dev_net(dev));
828 static void nl_fib_lookup(struct fib_result_nl *frn, struct fib_table *tb )
831 struct fib_result res;
832 struct flowi fl = { .mark = frn->fl_mark,
833 .nl_u = { .ip4_u = { .daddr = frn->fl_addr,
835 .scope = frn->fl_scope } } };
837 #ifdef CONFIG_IP_MULTIPLE_TABLES
845 frn->tb_id = tb->tb_id;
846 frn->err = fib_table_lookup(tb, &fl, &res);
849 frn->prefixlen = res.prefixlen;
850 frn->nh_sel = res.nh_sel;
851 frn->type = res.type;
852 frn->scope = res.scope;
859 static void nl_fib_input(struct sk_buff *skb)
862 struct fib_result_nl *frn;
863 struct nlmsghdr *nlh;
864 struct fib_table *tb;
867 net = sock_net(skb->sk);
868 nlh = nlmsg_hdr(skb);
869 if (skb->len < NLMSG_SPACE(0) || skb->len < nlh->nlmsg_len ||
870 nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*frn)))
873 skb = skb_clone(skb, GFP_KERNEL);
876 nlh = nlmsg_hdr(skb);
878 frn = (struct fib_result_nl *) NLMSG_DATA(nlh);
879 tb = fib_get_table(net, frn->tb_id_in);
881 nl_fib_lookup(frn, tb);
883 pid = NETLINK_CB(skb).pid; /* pid of sending process */
884 NETLINK_CB(skb).pid = 0; /* from kernel */
885 NETLINK_CB(skb).dst_group = 0; /* unicast */
886 netlink_unicast(net->ipv4.fibnl, skb, pid, MSG_DONTWAIT);
889 static int __net_init nl_fib_lookup_init(struct net *net)
892 sk = netlink_kernel_create(net, NETLINK_FIB_LOOKUP, 0,
893 nl_fib_input, NULL, THIS_MODULE);
895 return -EAFNOSUPPORT;
896 net->ipv4.fibnl = sk;
900 static void nl_fib_lookup_exit(struct net *net)
902 netlink_kernel_release(net->ipv4.fibnl);
903 net->ipv4.fibnl = NULL;
906 static void fib_disable_ip(struct net_device *dev, int force, int delay)
908 if (fib_sync_down_dev(dev, force))
909 fib_flush(dev_net(dev));
910 rt_cache_flush(dev_net(dev), delay);
914 static int fib_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
916 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
917 struct net_device *dev = ifa->ifa_dev->dev;
922 #ifdef CONFIG_IP_ROUTE_MULTIPATH
925 rt_cache_flush(dev_net(dev), -1);
929 if (ifa->ifa_dev->ifa_list == NULL) {
930 /* Last address was deleted from this interface.
933 fib_disable_ip(dev, 1, 0);
935 rt_cache_flush(dev_net(dev), -1);
942 static int fib_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
944 struct net_device *dev = ptr;
945 struct in_device *in_dev = __in_dev_get_rtnl(dev);
947 if (event == NETDEV_UNREGISTER) {
948 fib_disable_ip(dev, 2, -1);
959 } endfor_ifa(in_dev);
960 #ifdef CONFIG_IP_ROUTE_MULTIPATH
963 rt_cache_flush(dev_net(dev), -1);
966 fib_disable_ip(dev, 0, 0);
968 case NETDEV_CHANGEMTU:
970 rt_cache_flush(dev_net(dev), 0);
972 case NETDEV_UNREGISTER_BATCH:
973 rt_cache_flush_batch();
979 static struct notifier_block fib_inetaddr_notifier = {
980 .notifier_call = fib_inetaddr_event,
983 static struct notifier_block fib_netdev_notifier = {
984 .notifier_call = fib_netdev_event,
987 static int __net_init ip_fib_net_init(struct net *net)
992 net->ipv4.fib_table_hash = kzalloc(
993 sizeof(struct hlist_head)*FIB_TABLE_HASHSZ, GFP_KERNEL);
994 if (net->ipv4.fib_table_hash == NULL)
997 for (i = 0; i < FIB_TABLE_HASHSZ; i++)
998 INIT_HLIST_HEAD(&net->ipv4.fib_table_hash[i]);
1000 err = fib4_rules_init(net);
1006 kfree(net->ipv4.fib_table_hash);
1010 static void ip_fib_net_exit(struct net *net)
1014 #ifdef CONFIG_IP_MULTIPLE_TABLES
1015 fib4_rules_exit(net);
1018 for (i = 0; i < FIB_TABLE_HASHSZ; i++) {
1019 struct fib_table *tb;
1020 struct hlist_head *head;
1021 struct hlist_node *node, *tmp;
1023 head = &net->ipv4.fib_table_hash[i];
1024 hlist_for_each_entry_safe(tb, node, tmp, head, tb_hlist) {
1026 fib_table_flush(tb);
1030 kfree(net->ipv4.fib_table_hash);
1033 static int __net_init fib_net_init(struct net *net)
1037 error = ip_fib_net_init(net);
1040 error = nl_fib_lookup_init(net);
1043 error = fib_proc_init(net);
1050 nl_fib_lookup_exit(net);
1052 ip_fib_net_exit(net);
1056 static void __net_exit fib_net_exit(struct net *net)
1059 nl_fib_lookup_exit(net);
1060 ip_fib_net_exit(net);
1063 static struct pernet_operations fib_net_ops = {
1064 .init = fib_net_init,
1065 .exit = fib_net_exit,
1068 void __init ip_fib_init(void)
1070 rtnl_register(PF_INET, RTM_NEWROUTE, inet_rtm_newroute, NULL);
1071 rtnl_register(PF_INET, RTM_DELROUTE, inet_rtm_delroute, NULL);
1072 rtnl_register(PF_INET, RTM_GETROUTE, NULL, inet_dump_fib);
1074 register_pernet_subsys(&fib_net_ops);
1075 register_netdevice_notifier(&fib_netdev_notifier);
1076 register_inetaddr_notifier(&fib_inetaddr_notifier);
1081 EXPORT_SYMBOL(inet_addr_type);
1082 EXPORT_SYMBOL(inet_dev_addr_type);
1083 EXPORT_SYMBOL(ip_dev_find);