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>
39 #include <net/protocol.h>
40 #include <net/route.h>
44 #include <net/ip_fib.h>
45 #include <net/rtnetlink.h>
47 #ifndef CONFIG_IP_MULTIPLE_TABLES
49 static int __net_init fib4_rules_init(struct net *net)
51 struct fib_table *local_table, *main_table;
53 local_table = fib_hash_table(RT_TABLE_LOCAL);
54 if (local_table == NULL)
57 main_table = fib_hash_table(RT_TABLE_MAIN);
58 if (main_table == NULL)
61 hlist_add_head_rcu(&local_table->tb_hlist,
62 &net->ipv4.fib_table_hash[TABLE_LOCAL_INDEX]);
63 hlist_add_head_rcu(&main_table->tb_hlist,
64 &net->ipv4.fib_table_hash[TABLE_MAIN_INDEX]);
73 struct fib_table *fib_new_table(struct net *net, u32 id)
80 tb = fib_get_table(net, id);
84 tb = fib_hash_table(id);
87 h = id & (FIB_TABLE_HASHSZ - 1);
88 hlist_add_head_rcu(&tb->tb_hlist, &net->ipv4.fib_table_hash[h]);
92 struct fib_table *fib_get_table(struct net *net, u32 id)
95 struct hlist_node *node;
96 struct hlist_head *head;
101 h = id & (FIB_TABLE_HASHSZ - 1);
104 head = &net->ipv4.fib_table_hash[h];
105 hlist_for_each_entry_rcu(tb, node, head, tb_hlist) {
106 if (tb->tb_id == id) {
114 #endif /* CONFIG_IP_MULTIPLE_TABLES */
116 void fib_select_default(struct net *net,
117 const struct flowi *flp, struct fib_result *res)
119 struct fib_table *tb;
120 int table = RT_TABLE_MAIN;
121 #ifdef CONFIG_IP_MULTIPLE_TABLES
122 if (res->r == NULL || res->r->action != FR_ACT_TO_TBL)
124 table = res->r->table;
126 tb = fib_get_table(net, table);
127 if (FIB_RES_GW(*res) && FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK)
128 fib_table_select_default(tb, flp, res);
131 static void fib_flush(struct net *net)
134 struct fib_table *tb;
135 struct hlist_node *node;
136 struct hlist_head *head;
139 for (h = 0; h < FIB_TABLE_HASHSZ; h++) {
140 head = &net->ipv4.fib_table_hash[h];
141 hlist_for_each_entry(tb, node, head, tb_hlist)
142 flushed += fib_table_flush(tb);
146 rt_cache_flush(net, -1);
150 * Find the first device with a given source address.
153 struct net_device * ip_dev_find(struct net *net, __be32 addr)
155 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
156 struct fib_result res;
157 struct net_device *dev = NULL;
158 struct fib_table *local_table;
160 #ifdef CONFIG_IP_MULTIPLE_TABLES
164 local_table = fib_get_table(net, RT_TABLE_LOCAL);
165 if (!local_table || fib_table_lookup(local_table, &fl, &res))
167 if (res.type != RTN_LOCAL)
169 dev = FIB_RES_DEV(res);
179 * Find address type as if only "dev" was present in the system. If
180 * on_dev is NULL then all interfaces are taken into consideration.
182 static inline unsigned __inet_dev_addr_type(struct net *net,
183 const struct net_device *dev,
186 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
187 struct fib_result res;
188 unsigned ret = RTN_BROADCAST;
189 struct fib_table *local_table;
191 if (ipv4_is_zeronet(addr) || ipv4_is_lbcast(addr))
192 return RTN_BROADCAST;
193 if (ipv4_is_multicast(addr))
194 return RTN_MULTICAST;
196 #ifdef CONFIG_IP_MULTIPLE_TABLES
200 local_table = fib_get_table(net, RT_TABLE_LOCAL);
203 if (!fib_table_lookup(local_table, &fl, &res)) {
204 if (!dev || dev == res.fi->fib_dev)
212 unsigned int inet_addr_type(struct net *net, __be32 addr)
214 return __inet_dev_addr_type(net, NULL, addr);
217 unsigned int inet_dev_addr_type(struct net *net, const struct net_device *dev,
220 return __inet_dev_addr_type(net, dev, addr);
223 /* Given (packet source, input interface) and optional (dst, oif, tos):
224 - (main) check, that source is valid i.e. not broadcast or our local
226 - figure out what "logical" interface this packet arrived
227 and calculate "specific destination" address.
228 - check, that packet arrived from expected physical interface.
231 int fib_validate_source(__be32 src, __be32 dst, u8 tos, int oif,
232 struct net_device *dev, __be32 *spec_dst,
235 struct in_device *in_dev;
236 struct flowi fl = { .nl_u = { .ip4_u =
243 struct fib_result res;
244 int no_addr, rpf, accept_local;
248 no_addr = rpf = accept_local = 0;
250 in_dev = __in_dev_get_rcu(dev);
252 no_addr = in_dev->ifa_list == NULL;
253 rpf = IN_DEV_RPFILTER(in_dev);
254 accept_local = IN_DEV_ACCEPT_LOCAL(in_dev);
262 if (fib_lookup(net, &fl, &res))
264 if (res.type != RTN_UNICAST) {
265 if (res.type != RTN_LOCAL || !accept_local)
268 *spec_dst = FIB_RES_PREFSRC(res);
269 fib_combine_itag(itag, &res);
270 #ifdef CONFIG_IP_ROUTE_MULTIPATH
271 if (FIB_RES_DEV(res) == dev || res.fi->fib_nhs > 1)
273 if (FIB_RES_DEV(res) == dev)
276 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
285 fl.oif = dev->ifindex;
288 if (fib_lookup(net, &fl, &res) == 0) {
289 if (res.type == RTN_UNICAST) {
290 *spec_dst = FIB_RES_PREFSRC(res);
291 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
300 *spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
310 static inline __be32 sk_extract_addr(struct sockaddr *addr)
312 return ((struct sockaddr_in *) addr)->sin_addr.s_addr;
315 static int put_rtax(struct nlattr *mx, int len, int type, u32 value)
319 nla = (struct nlattr *) ((char *) mx + len);
320 nla->nla_type = type;
321 nla->nla_len = nla_attr_size(4);
322 *(u32 *) nla_data(nla) = value;
324 return len + nla_total_size(4);
327 static int rtentry_to_fib_config(struct net *net, int cmd, struct rtentry *rt,
328 struct fib_config *cfg)
333 memset(cfg, 0, sizeof(*cfg));
334 cfg->fc_nlinfo.nl_net = net;
336 if (rt->rt_dst.sa_family != AF_INET)
337 return -EAFNOSUPPORT;
340 * Check mask for validity:
341 * a) it must be contiguous.
342 * b) destination must have all host bits clear.
343 * c) if application forgot to set correct family (AF_INET),
344 * reject request unless it is absolutely clear i.e.
345 * both family and mask are zero.
348 addr = sk_extract_addr(&rt->rt_dst);
349 if (!(rt->rt_flags & RTF_HOST)) {
350 __be32 mask = sk_extract_addr(&rt->rt_genmask);
352 if (rt->rt_genmask.sa_family != AF_INET) {
353 if (mask || rt->rt_genmask.sa_family)
354 return -EAFNOSUPPORT;
357 if (bad_mask(mask, addr))
360 plen = inet_mask_len(mask);
363 cfg->fc_dst_len = plen;
366 if (cmd != SIOCDELRT) {
367 cfg->fc_nlflags = NLM_F_CREATE;
368 cfg->fc_protocol = RTPROT_BOOT;
372 cfg->fc_priority = rt->rt_metric - 1;
374 if (rt->rt_flags & RTF_REJECT) {
375 cfg->fc_scope = RT_SCOPE_HOST;
376 cfg->fc_type = RTN_UNREACHABLE;
380 cfg->fc_scope = RT_SCOPE_NOWHERE;
381 cfg->fc_type = RTN_UNICAST;
385 struct net_device *dev;
386 char devname[IFNAMSIZ];
388 if (copy_from_user(devname, rt->rt_dev, IFNAMSIZ-1))
391 devname[IFNAMSIZ-1] = 0;
392 colon = strchr(devname, ':');
395 dev = __dev_get_by_name(net, devname);
398 cfg->fc_oif = dev->ifindex;
400 struct in_ifaddr *ifa;
401 struct in_device *in_dev = __in_dev_get_rtnl(dev);
405 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next)
406 if (strcmp(ifa->ifa_label, devname) == 0)
410 cfg->fc_prefsrc = ifa->ifa_local;
414 addr = sk_extract_addr(&rt->rt_gateway);
415 if (rt->rt_gateway.sa_family == AF_INET && addr) {
417 if (rt->rt_flags & RTF_GATEWAY &&
418 inet_addr_type(net, addr) == RTN_UNICAST)
419 cfg->fc_scope = RT_SCOPE_UNIVERSE;
422 if (cmd == SIOCDELRT)
425 if (rt->rt_flags & RTF_GATEWAY && !cfg->fc_gw)
428 if (cfg->fc_scope == RT_SCOPE_NOWHERE)
429 cfg->fc_scope = RT_SCOPE_LINK;
431 if (rt->rt_flags & (RTF_MTU | RTF_WINDOW | RTF_IRTT)) {
435 mx = kzalloc(3 * nla_total_size(4), GFP_KERNEL);
439 if (rt->rt_flags & RTF_MTU)
440 len = put_rtax(mx, len, RTAX_ADVMSS, rt->rt_mtu - 40);
442 if (rt->rt_flags & RTF_WINDOW)
443 len = put_rtax(mx, len, RTAX_WINDOW, rt->rt_window);
445 if (rt->rt_flags & RTF_IRTT)
446 len = put_rtax(mx, len, RTAX_RTT, rt->rt_irtt << 3);
449 cfg->fc_mx_len = len;
456 * Handle IP routing ioctl calls. These are used to manipulate the routing tables
459 int ip_rt_ioctl(struct net *net, unsigned int cmd, void __user *arg)
461 struct fib_config cfg;
466 case SIOCADDRT: /* Add a route */
467 case SIOCDELRT: /* Delete a route */
468 if (!capable(CAP_NET_ADMIN))
471 if (copy_from_user(&rt, arg, sizeof(rt)))
475 err = rtentry_to_fib_config(net, cmd, &rt, &cfg);
477 struct fib_table *tb;
479 if (cmd == SIOCDELRT) {
480 tb = fib_get_table(net, cfg.fc_table);
482 err = fib_table_delete(tb, &cfg);
486 tb = fib_new_table(net, cfg.fc_table);
488 err = fib_table_insert(tb, &cfg);
493 /* allocated by rtentry_to_fib_config() */
502 const struct nla_policy rtm_ipv4_policy[RTA_MAX+1] = {
503 [RTA_DST] = { .type = NLA_U32 },
504 [RTA_SRC] = { .type = NLA_U32 },
505 [RTA_IIF] = { .type = NLA_U32 },
506 [RTA_OIF] = { .type = NLA_U32 },
507 [RTA_GATEWAY] = { .type = NLA_U32 },
508 [RTA_PRIORITY] = { .type = NLA_U32 },
509 [RTA_PREFSRC] = { .type = NLA_U32 },
510 [RTA_METRICS] = { .type = NLA_NESTED },
511 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
512 [RTA_FLOW] = { .type = NLA_U32 },
515 static int rtm_to_fib_config(struct net *net, struct sk_buff *skb,
516 struct nlmsghdr *nlh, struct fib_config *cfg)
522 err = nlmsg_validate(nlh, sizeof(*rtm), RTA_MAX, rtm_ipv4_policy);
526 memset(cfg, 0, sizeof(*cfg));
528 rtm = nlmsg_data(nlh);
529 cfg->fc_dst_len = rtm->rtm_dst_len;
530 cfg->fc_tos = rtm->rtm_tos;
531 cfg->fc_table = rtm->rtm_table;
532 cfg->fc_protocol = rtm->rtm_protocol;
533 cfg->fc_scope = rtm->rtm_scope;
534 cfg->fc_type = rtm->rtm_type;
535 cfg->fc_flags = rtm->rtm_flags;
536 cfg->fc_nlflags = nlh->nlmsg_flags;
538 cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
539 cfg->fc_nlinfo.nlh = nlh;
540 cfg->fc_nlinfo.nl_net = net;
542 if (cfg->fc_type > RTN_MAX) {
547 nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), remaining) {
548 switch (nla_type(attr)) {
550 cfg->fc_dst = nla_get_be32(attr);
553 cfg->fc_oif = nla_get_u32(attr);
556 cfg->fc_gw = nla_get_be32(attr);
559 cfg->fc_priority = nla_get_u32(attr);
562 cfg->fc_prefsrc = nla_get_be32(attr);
565 cfg->fc_mx = nla_data(attr);
566 cfg->fc_mx_len = nla_len(attr);
569 cfg->fc_mp = nla_data(attr);
570 cfg->fc_mp_len = nla_len(attr);
573 cfg->fc_flow = nla_get_u32(attr);
576 cfg->fc_table = nla_get_u32(attr);
586 static int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
588 struct net *net = sock_net(skb->sk);
589 struct fib_config cfg;
590 struct fib_table *tb;
593 err = rtm_to_fib_config(net, skb, nlh, &cfg);
597 tb = fib_get_table(net, cfg.fc_table);
603 err = fib_table_delete(tb, &cfg);
608 static int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
610 struct net *net = sock_net(skb->sk);
611 struct fib_config cfg;
612 struct fib_table *tb;
615 err = rtm_to_fib_config(net, skb, nlh, &cfg);
619 tb = fib_new_table(net, cfg.fc_table);
625 err = fib_table_insert(tb, &cfg);
630 static int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
632 struct net *net = sock_net(skb->sk);
634 unsigned int e = 0, s_e;
635 struct fib_table *tb;
636 struct hlist_node *node;
637 struct hlist_head *head;
640 if (nlmsg_len(cb->nlh) >= sizeof(struct rtmsg) &&
641 ((struct rtmsg *) nlmsg_data(cb->nlh))->rtm_flags & RTM_F_CLONED)
642 return ip_rt_dump(skb, cb);
647 for (h = s_h; h < FIB_TABLE_HASHSZ; h++, s_e = 0) {
649 head = &net->ipv4.fib_table_hash[h];
650 hlist_for_each_entry(tb, node, head, tb_hlist) {
654 memset(&cb->args[2], 0, sizeof(cb->args) -
655 2 * sizeof(cb->args[0]));
656 if (fib_table_dump(tb, skb, cb) < 0)
670 /* Prepare and feed intra-kernel routing request.
671 Really, it should be netlink message, but :-( netlink
672 can be not configured, so that we feed it directly
673 to fib engine. It is legal, because all events occur
674 only when netlink is already locked.
677 static void fib_magic(int cmd, int type, __be32 dst, int dst_len, struct in_ifaddr *ifa)
679 struct net *net = dev_net(ifa->ifa_dev->dev);
680 struct fib_table *tb;
681 struct fib_config cfg = {
682 .fc_protocol = RTPROT_KERNEL,
685 .fc_dst_len = dst_len,
686 .fc_prefsrc = ifa->ifa_local,
687 .fc_oif = ifa->ifa_dev->dev->ifindex,
688 .fc_nlflags = NLM_F_CREATE | NLM_F_APPEND,
694 if (type == RTN_UNICAST)
695 tb = fib_new_table(net, RT_TABLE_MAIN);
697 tb = fib_new_table(net, RT_TABLE_LOCAL);
702 cfg.fc_table = tb->tb_id;
704 if (type != RTN_LOCAL)
705 cfg.fc_scope = RT_SCOPE_LINK;
707 cfg.fc_scope = RT_SCOPE_HOST;
709 if (cmd == RTM_NEWROUTE)
710 fib_table_insert(tb, &cfg);
712 fib_table_delete(tb, &cfg);
715 void fib_add_ifaddr(struct in_ifaddr *ifa)
717 struct in_device *in_dev = ifa->ifa_dev;
718 struct net_device *dev = in_dev->dev;
719 struct in_ifaddr *prim = ifa;
720 __be32 mask = ifa->ifa_mask;
721 __be32 addr = ifa->ifa_local;
722 __be32 prefix = ifa->ifa_address&mask;
724 if (ifa->ifa_flags&IFA_F_SECONDARY) {
725 prim = inet_ifa_byprefix(in_dev, prefix, mask);
727 printk(KERN_WARNING "fib_add_ifaddr: bug: prim == NULL\n");
732 fib_magic(RTM_NEWROUTE, RTN_LOCAL, addr, 32, prim);
734 if (!(dev->flags&IFF_UP))
737 /* Add broadcast address, if it is explicitly assigned. */
738 if (ifa->ifa_broadcast && ifa->ifa_broadcast != htonl(0xFFFFFFFF))
739 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
741 if (!ipv4_is_zeronet(prefix) && !(ifa->ifa_flags&IFA_F_SECONDARY) &&
742 (prefix != addr || ifa->ifa_prefixlen < 32)) {
743 fib_magic(RTM_NEWROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
744 RTN_UNICAST, prefix, ifa->ifa_prefixlen, prim);
746 /* Add network specific broadcasts, when it takes a sense */
747 if (ifa->ifa_prefixlen < 31) {
748 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix, 32, prim);
749 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix|~mask, 32, prim);
754 static void fib_del_ifaddr(struct in_ifaddr *ifa)
756 struct in_device *in_dev = ifa->ifa_dev;
757 struct net_device *dev = in_dev->dev;
758 struct in_ifaddr *ifa1;
759 struct in_ifaddr *prim = ifa;
760 __be32 brd = ifa->ifa_address|~ifa->ifa_mask;
761 __be32 any = ifa->ifa_address&ifa->ifa_mask;
768 if (!(ifa->ifa_flags&IFA_F_SECONDARY))
769 fib_magic(RTM_DELROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
770 RTN_UNICAST, any, ifa->ifa_prefixlen, prim);
772 prim = inet_ifa_byprefix(in_dev, any, ifa->ifa_mask);
774 printk(KERN_WARNING "fib_del_ifaddr: bug: prim == NULL\n");
779 /* Deletion is more complicated than add.
780 We should take care of not to delete too much :-)
782 Scan address list to be sure that addresses are really gone.
785 for (ifa1 = in_dev->ifa_list; ifa1; ifa1 = ifa1->ifa_next) {
786 if (ifa->ifa_local == ifa1->ifa_local)
788 if (ifa->ifa_broadcast == ifa1->ifa_broadcast)
790 if (brd == ifa1->ifa_broadcast)
792 if (any == ifa1->ifa_broadcast)
797 fib_magic(RTM_DELROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
799 fib_magic(RTM_DELROUTE, RTN_BROADCAST, brd, 32, prim);
801 fib_magic(RTM_DELROUTE, RTN_BROADCAST, any, 32, prim);
802 if (!(ok&LOCAL_OK)) {
803 fib_magic(RTM_DELROUTE, RTN_LOCAL, ifa->ifa_local, 32, prim);
805 /* Check, that this local address finally disappeared. */
806 if (inet_addr_type(dev_net(dev), ifa->ifa_local) != RTN_LOCAL) {
807 /* And the last, but not the least thing.
808 We must flush stray FIB entries.
810 First of all, we scan fib_info list searching
811 for stray nexthop entries, then ignite fib_flush.
813 if (fib_sync_down_addr(dev_net(dev), ifa->ifa_local))
814 fib_flush(dev_net(dev));
823 static void nl_fib_lookup(struct fib_result_nl *frn, struct fib_table *tb )
826 struct fib_result res;
827 struct flowi fl = { .mark = frn->fl_mark,
828 .nl_u = { .ip4_u = { .daddr = frn->fl_addr,
830 .scope = frn->fl_scope } } };
832 #ifdef CONFIG_IP_MULTIPLE_TABLES
840 frn->tb_id = tb->tb_id;
841 frn->err = fib_table_lookup(tb, &fl, &res);
844 frn->prefixlen = res.prefixlen;
845 frn->nh_sel = res.nh_sel;
846 frn->type = res.type;
847 frn->scope = res.scope;
854 static void nl_fib_input(struct sk_buff *skb)
857 struct fib_result_nl *frn;
858 struct nlmsghdr *nlh;
859 struct fib_table *tb;
862 net = sock_net(skb->sk);
863 nlh = nlmsg_hdr(skb);
864 if (skb->len < NLMSG_SPACE(0) || skb->len < nlh->nlmsg_len ||
865 nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*frn)))
868 skb = skb_clone(skb, GFP_KERNEL);
871 nlh = nlmsg_hdr(skb);
873 frn = (struct fib_result_nl *) NLMSG_DATA(nlh);
874 tb = fib_get_table(net, frn->tb_id_in);
876 nl_fib_lookup(frn, tb);
878 pid = NETLINK_CB(skb).pid; /* pid of sending process */
879 NETLINK_CB(skb).pid = 0; /* from kernel */
880 NETLINK_CB(skb).dst_group = 0; /* unicast */
881 netlink_unicast(net->ipv4.fibnl, skb, pid, MSG_DONTWAIT);
884 static int nl_fib_lookup_init(struct net *net)
887 sk = netlink_kernel_create(net, NETLINK_FIB_LOOKUP, 0,
888 nl_fib_input, NULL, THIS_MODULE);
890 return -EAFNOSUPPORT;
891 net->ipv4.fibnl = sk;
895 static void nl_fib_lookup_exit(struct net *net)
897 netlink_kernel_release(net->ipv4.fibnl);
898 net->ipv4.fibnl = NULL;
901 static void fib_disable_ip(struct net_device *dev, int force, int delay)
903 if (fib_sync_down_dev(dev, force))
904 fib_flush(dev_net(dev));
905 rt_cache_flush(dev_net(dev), delay);
909 static int fib_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
911 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
912 struct net_device *dev = ifa->ifa_dev->dev;
917 #ifdef CONFIG_IP_ROUTE_MULTIPATH
920 rt_cache_flush(dev_net(dev), -1);
924 if (ifa->ifa_dev->ifa_list == NULL) {
925 /* Last address was deleted from this interface.
928 fib_disable_ip(dev, 1, 0);
930 rt_cache_flush(dev_net(dev), -1);
937 static int fib_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
939 struct net_device *dev = ptr;
940 struct in_device *in_dev = __in_dev_get_rtnl(dev);
942 if (event == NETDEV_UNREGISTER) {
943 fib_disable_ip(dev, 2, -1);
954 } endfor_ifa(in_dev);
955 #ifdef CONFIG_IP_ROUTE_MULTIPATH
958 rt_cache_flush(dev_net(dev), -1);
961 fib_disable_ip(dev, 0, 0);
963 case NETDEV_CHANGEMTU:
965 rt_cache_flush(dev_net(dev), 0);
967 case NETDEV_UNREGISTER_BATCH:
968 rt_cache_flush_batch();
974 static struct notifier_block fib_inetaddr_notifier = {
975 .notifier_call = fib_inetaddr_event,
978 static struct notifier_block fib_netdev_notifier = {
979 .notifier_call = fib_netdev_event,
982 static int __net_init ip_fib_net_init(struct net *net)
987 net->ipv4.fib_table_hash = kzalloc(
988 sizeof(struct hlist_head)*FIB_TABLE_HASHSZ, GFP_KERNEL);
989 if (net->ipv4.fib_table_hash == NULL)
992 for (i = 0; i < FIB_TABLE_HASHSZ; i++)
993 INIT_HLIST_HEAD(&net->ipv4.fib_table_hash[i]);
995 err = fib4_rules_init(net);
1001 kfree(net->ipv4.fib_table_hash);
1005 static void __net_exit ip_fib_net_exit(struct net *net)
1009 #ifdef CONFIG_IP_MULTIPLE_TABLES
1010 fib4_rules_exit(net);
1013 for (i = 0; i < FIB_TABLE_HASHSZ; i++) {
1014 struct fib_table *tb;
1015 struct hlist_head *head;
1016 struct hlist_node *node, *tmp;
1018 head = &net->ipv4.fib_table_hash[i];
1019 hlist_for_each_entry_safe(tb, node, tmp, head, tb_hlist) {
1021 fib_table_flush(tb);
1025 kfree(net->ipv4.fib_table_hash);
1028 static int __net_init fib_net_init(struct net *net)
1032 error = ip_fib_net_init(net);
1035 error = nl_fib_lookup_init(net);
1038 error = fib_proc_init(net);
1045 nl_fib_lookup_exit(net);
1047 ip_fib_net_exit(net);
1051 static void __net_exit fib_net_exit(struct net *net)
1054 nl_fib_lookup_exit(net);
1055 ip_fib_net_exit(net);
1058 static struct pernet_operations fib_net_ops = {
1059 .init = fib_net_init,
1060 .exit = fib_net_exit,
1063 void __init ip_fib_init(void)
1065 rtnl_register(PF_INET, RTM_NEWROUTE, inet_rtm_newroute, NULL);
1066 rtnl_register(PF_INET, RTM_DELROUTE, inet_rtm_delroute, NULL);
1067 rtnl_register(PF_INET, RTM_GETROUTE, NULL, inet_dump_fib);
1069 register_pernet_subsys(&fib_net_ops);
1070 register_netdevice_notifier(&fib_netdev_notifier);
1071 register_inetaddr_notifier(&fib_inetaddr_notifier);
1076 EXPORT_SYMBOL(inet_addr_type);
1077 EXPORT_SYMBOL(inet_dev_addr_type);
1078 EXPORT_SYMBOL(ip_dev_find);