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 * Version: $Id: fib_frontend.c,v 1.26 2001/10/31 21:55:54 davem Exp $
10 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
18 #include <linux/module.h>
19 #include <asm/uaccess.h>
20 #include <asm/system.h>
21 #include <linux/bitops.h>
22 #include <linux/capability.h>
23 #include <linux/types.h>
24 #include <linux/kernel.h>
26 #include <linux/string.h>
27 #include <linux/socket.h>
28 #include <linux/sockios.h>
29 #include <linux/errno.h>
31 #include <linux/inet.h>
32 #include <linux/inetdevice.h>
33 #include <linux/netdevice.h>
34 #include <linux/if_addr.h>
35 #include <linux/if_arp.h>
36 #include <linux/skbuff.h>
37 #include <linux/init.h>
38 #include <linux/list.h>
41 #include <net/protocol.h>
42 #include <net/route.h>
47 #include <net/ip_fib.h>
48 #include <net/rtnetlink.h>
50 #ifndef CONFIG_IP_MULTIPLE_TABLES
52 static int __net_init fib4_rules_init(struct net *net)
54 struct fib_table *local_table, *main_table;
56 local_table = fib_hash_table(RT_TABLE_LOCAL);
57 if (local_table == NULL)
60 main_table = fib_hash_table(RT_TABLE_MAIN);
61 if (main_table == NULL)
64 hlist_add_head_rcu(&local_table->tb_hlist,
65 &net->ipv4.fib_table_hash[TABLE_LOCAL_INDEX]);
66 hlist_add_head_rcu(&main_table->tb_hlist,
67 &net->ipv4.fib_table_hash[TABLE_MAIN_INDEX]);
76 struct fib_table *fib_new_table(struct net *net, u32 id)
83 tb = fib_get_table(net, id);
87 tb = fib_hash_table(id);
90 h = id & (FIB_TABLE_HASHSZ - 1);
91 hlist_add_head_rcu(&tb->tb_hlist, &net->ipv4.fib_table_hash[h]);
95 struct fib_table *fib_get_table(struct net *net, u32 id)
98 struct hlist_node *node;
99 struct hlist_head *head;
104 h = id & (FIB_TABLE_HASHSZ - 1);
107 head = &net->ipv4.fib_table_hash[h];
108 hlist_for_each_entry_rcu(tb, node, head, tb_hlist) {
109 if (tb->tb_id == id) {
117 #endif /* CONFIG_IP_MULTIPLE_TABLES */
119 void fib_select_default(const struct flowi *flp, struct fib_result *res)
121 struct fib_table *tb;
122 int table = RT_TABLE_MAIN;
123 #ifdef CONFIG_IP_MULTIPLE_TABLES
124 if (res->r == NULL || res->r->action != FR_ACT_TO_TBL)
126 table = res->r->table;
128 tb = fib_get_table(&init_net, table);
129 if (FIB_RES_GW(*res) && FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK)
130 tb->tb_select_default(tb, flp, res);
133 static void fib_flush(struct net *net)
136 struct fib_table *tb;
137 struct hlist_node *node;
138 struct hlist_head *head;
141 for (h = 0; h < FIB_TABLE_HASHSZ; h++) {
142 head = &net->ipv4.fib_table_hash[h];
143 hlist_for_each_entry(tb, node, head, tb_hlist)
144 flushed += tb->tb_flush(tb);
152 * Find the first device with a given source address.
155 struct net_device * ip_dev_find(__be32 addr)
157 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
158 struct fib_result res;
159 struct net_device *dev = NULL;
160 struct fib_table *local_table;
162 #ifdef CONFIG_IP_MULTIPLE_TABLES
166 local_table = fib_get_table(&init_net, RT_TABLE_LOCAL);
167 if (!local_table || local_table->tb_lookup(local_table, &fl, &res))
169 if (res.type != RTN_LOCAL)
171 dev = FIB_RES_DEV(res);
181 * Find address type as if only "dev" was present in the system. If
182 * on_dev is NULL then all interfaces are taken into consideration.
184 static inline unsigned __inet_dev_addr_type(struct net *net,
185 const struct net_device *dev,
188 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
189 struct fib_result res;
190 unsigned ret = RTN_BROADCAST;
191 struct fib_table *local_table;
193 if (ipv4_is_zeronet(addr) || ipv4_is_lbcast(addr))
194 return RTN_BROADCAST;
195 if (ipv4_is_multicast(addr))
196 return RTN_MULTICAST;
198 #ifdef CONFIG_IP_MULTIPLE_TABLES
202 local_table = fib_get_table(net, RT_TABLE_LOCAL);
205 if (!local_table->tb_lookup(local_table, &fl, &res)) {
206 if (!dev || dev == res.fi->fib_dev)
214 unsigned int inet_addr_type(struct net *net, __be32 addr)
216 return __inet_dev_addr_type(net, NULL, addr);
219 unsigned int inet_dev_addr_type(struct net *net, const struct net_device *dev,
222 return __inet_dev_addr_type(net, dev, addr);
225 /* Given (packet source, input interface) and optional (dst, oif, tos):
226 - (main) check, that source is valid i.e. not broadcast or our local
228 - figure out what "logical" interface this packet arrived
229 and calculate "specific destination" address.
230 - check, that packet arrived from expected physical interface.
233 int fib_validate_source(__be32 src, __be32 dst, u8 tos, int oif,
234 struct net_device *dev, __be32 *spec_dst, u32 *itag)
236 struct in_device *in_dev;
237 struct flowi fl = { .nl_u = { .ip4_u =
242 struct fib_result res;
249 in_dev = __in_dev_get_rcu(dev);
251 no_addr = in_dev->ifa_list == NULL;
252 rpf = IN_DEV_RPFILTER(in_dev);
260 if (fib_lookup(net, &fl, &res))
262 if (res.type != RTN_UNICAST)
264 *spec_dst = FIB_RES_PREFSRC(res);
265 fib_combine_itag(itag, &res);
266 #ifdef CONFIG_IP_ROUTE_MULTIPATH
267 if (FIB_RES_DEV(res) == dev || res.fi->fib_nhs > 1)
269 if (FIB_RES_DEV(res) == dev)
272 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
281 fl.oif = dev->ifindex;
284 if (fib_lookup(net, &fl, &res) == 0) {
285 if (res.type == RTN_UNICAST) {
286 *spec_dst = FIB_RES_PREFSRC(res);
287 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
296 *spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
306 static inline __be32 sk_extract_addr(struct sockaddr *addr)
308 return ((struct sockaddr_in *) addr)->sin_addr.s_addr;
311 static int put_rtax(struct nlattr *mx, int len, int type, u32 value)
315 nla = (struct nlattr *) ((char *) mx + len);
316 nla->nla_type = type;
317 nla->nla_len = nla_attr_size(4);
318 *(u32 *) nla_data(nla) = value;
320 return len + nla_total_size(4);
323 static int rtentry_to_fib_config(struct net *net, int cmd, struct rtentry *rt,
324 struct fib_config *cfg)
329 memset(cfg, 0, sizeof(*cfg));
330 cfg->fc_nlinfo.nl_net = net;
332 if (rt->rt_dst.sa_family != AF_INET)
333 return -EAFNOSUPPORT;
336 * Check mask for validity:
337 * a) it must be contiguous.
338 * b) destination must have all host bits clear.
339 * c) if application forgot to set correct family (AF_INET),
340 * reject request unless it is absolutely clear i.e.
341 * both family and mask are zero.
344 addr = sk_extract_addr(&rt->rt_dst);
345 if (!(rt->rt_flags & RTF_HOST)) {
346 __be32 mask = sk_extract_addr(&rt->rt_genmask);
348 if (rt->rt_genmask.sa_family != AF_INET) {
349 if (mask || rt->rt_genmask.sa_family)
350 return -EAFNOSUPPORT;
353 if (bad_mask(mask, addr))
356 plen = inet_mask_len(mask);
359 cfg->fc_dst_len = plen;
362 if (cmd != SIOCDELRT) {
363 cfg->fc_nlflags = NLM_F_CREATE;
364 cfg->fc_protocol = RTPROT_BOOT;
368 cfg->fc_priority = rt->rt_metric - 1;
370 if (rt->rt_flags & RTF_REJECT) {
371 cfg->fc_scope = RT_SCOPE_HOST;
372 cfg->fc_type = RTN_UNREACHABLE;
376 cfg->fc_scope = RT_SCOPE_NOWHERE;
377 cfg->fc_type = RTN_UNICAST;
381 struct net_device *dev;
382 char devname[IFNAMSIZ];
384 if (copy_from_user(devname, rt->rt_dev, IFNAMSIZ-1))
387 devname[IFNAMSIZ-1] = 0;
388 colon = strchr(devname, ':');
391 dev = __dev_get_by_name(net, devname);
394 cfg->fc_oif = dev->ifindex;
396 struct in_ifaddr *ifa;
397 struct in_device *in_dev = __in_dev_get_rtnl(dev);
401 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next)
402 if (strcmp(ifa->ifa_label, devname) == 0)
406 cfg->fc_prefsrc = ifa->ifa_local;
410 addr = sk_extract_addr(&rt->rt_gateway);
411 if (rt->rt_gateway.sa_family == AF_INET && addr) {
413 if (rt->rt_flags & RTF_GATEWAY &&
414 inet_addr_type(net, addr) == RTN_UNICAST)
415 cfg->fc_scope = RT_SCOPE_UNIVERSE;
418 if (cmd == SIOCDELRT)
421 if (rt->rt_flags & RTF_GATEWAY && !cfg->fc_gw)
424 if (cfg->fc_scope == RT_SCOPE_NOWHERE)
425 cfg->fc_scope = RT_SCOPE_LINK;
427 if (rt->rt_flags & (RTF_MTU | RTF_WINDOW | RTF_IRTT)) {
431 mx = kzalloc(3 * nla_total_size(4), GFP_KERNEL);
435 if (rt->rt_flags & RTF_MTU)
436 len = put_rtax(mx, len, RTAX_ADVMSS, rt->rt_mtu - 40);
438 if (rt->rt_flags & RTF_WINDOW)
439 len = put_rtax(mx, len, RTAX_WINDOW, rt->rt_window);
441 if (rt->rt_flags & RTF_IRTT)
442 len = put_rtax(mx, len, RTAX_RTT, rt->rt_irtt << 3);
445 cfg->fc_mx_len = len;
452 * Handle IP routing ioctl calls. These are used to manipulate the routing tables
455 int ip_rt_ioctl(struct net *net, unsigned int cmd, void __user *arg)
457 struct fib_config cfg;
462 case SIOCADDRT: /* Add a route */
463 case SIOCDELRT: /* Delete a route */
464 if (!capable(CAP_NET_ADMIN))
467 if (copy_from_user(&rt, arg, sizeof(rt)))
471 err = rtentry_to_fib_config(net, cmd, &rt, &cfg);
473 struct fib_table *tb;
475 if (cmd == SIOCDELRT) {
476 tb = fib_get_table(net, cfg.fc_table);
478 err = tb->tb_delete(tb, &cfg);
482 tb = fib_new_table(net, cfg.fc_table);
484 err = tb->tb_insert(tb, &cfg);
489 /* allocated by rtentry_to_fib_config() */
498 const struct nla_policy rtm_ipv4_policy[RTA_MAX+1] = {
499 [RTA_DST] = { .type = NLA_U32 },
500 [RTA_SRC] = { .type = NLA_U32 },
501 [RTA_IIF] = { .type = NLA_U32 },
502 [RTA_OIF] = { .type = NLA_U32 },
503 [RTA_GATEWAY] = { .type = NLA_U32 },
504 [RTA_PRIORITY] = { .type = NLA_U32 },
505 [RTA_PREFSRC] = { .type = NLA_U32 },
506 [RTA_METRICS] = { .type = NLA_NESTED },
507 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
508 [RTA_PROTOINFO] = { .type = NLA_U32 },
509 [RTA_FLOW] = { .type = NLA_U32 },
512 static int rtm_to_fib_config(struct net *net, struct sk_buff *skb,
513 struct nlmsghdr *nlh, struct fib_config *cfg)
519 err = nlmsg_validate(nlh, sizeof(*rtm), RTA_MAX, rtm_ipv4_policy);
523 memset(cfg, 0, sizeof(*cfg));
525 rtm = nlmsg_data(nlh);
526 cfg->fc_dst_len = rtm->rtm_dst_len;
527 cfg->fc_tos = rtm->rtm_tos;
528 cfg->fc_table = rtm->rtm_table;
529 cfg->fc_protocol = rtm->rtm_protocol;
530 cfg->fc_scope = rtm->rtm_scope;
531 cfg->fc_type = rtm->rtm_type;
532 cfg->fc_flags = rtm->rtm_flags;
533 cfg->fc_nlflags = nlh->nlmsg_flags;
535 cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
536 cfg->fc_nlinfo.nlh = nlh;
537 cfg->fc_nlinfo.nl_net = net;
539 if (cfg->fc_type > RTN_MAX) {
544 nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), remaining) {
545 switch (nla_type(attr)) {
547 cfg->fc_dst = nla_get_be32(attr);
550 cfg->fc_oif = nla_get_u32(attr);
553 cfg->fc_gw = nla_get_be32(attr);
556 cfg->fc_priority = nla_get_u32(attr);
559 cfg->fc_prefsrc = nla_get_be32(attr);
562 cfg->fc_mx = nla_data(attr);
563 cfg->fc_mx_len = nla_len(attr);
566 cfg->fc_mp = nla_data(attr);
567 cfg->fc_mp_len = nla_len(attr);
570 cfg->fc_flow = nla_get_u32(attr);
573 cfg->fc_table = nla_get_u32(attr);
583 static int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
585 struct net *net = skb->sk->sk_net;
586 struct fib_config cfg;
587 struct fib_table *tb;
590 err = rtm_to_fib_config(net, skb, nlh, &cfg);
594 tb = fib_get_table(net, cfg.fc_table);
600 err = tb->tb_delete(tb, &cfg);
605 static int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
607 struct net *net = skb->sk->sk_net;
608 struct fib_config cfg;
609 struct fib_table *tb;
612 err = rtm_to_fib_config(net, skb, nlh, &cfg);
616 tb = fib_new_table(net, cfg.fc_table);
622 err = tb->tb_insert(tb, &cfg);
627 static int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
629 struct net *net = skb->sk->sk_net;
631 unsigned int e = 0, s_e;
632 struct fib_table *tb;
633 struct hlist_node *node;
634 struct hlist_head *head;
637 if (nlmsg_len(cb->nlh) >= sizeof(struct rtmsg) &&
638 ((struct rtmsg *) nlmsg_data(cb->nlh))->rtm_flags & RTM_F_CLONED)
639 return ip_rt_dump(skb, cb);
644 for (h = s_h; h < FIB_TABLE_HASHSZ; h++, s_e = 0) {
646 head = &net->ipv4.fib_table_hash[h];
647 hlist_for_each_entry(tb, node, head, tb_hlist) {
651 memset(&cb->args[2], 0, sizeof(cb->args) -
652 2 * sizeof(cb->args[0]));
653 if (tb->tb_dump(tb, skb, cb) < 0)
667 /* Prepare and feed intra-kernel routing request.
668 Really, it should be netlink message, but :-( netlink
669 can be not configured, so that we feed it directly
670 to fib engine. It is legal, because all events occur
671 only when netlink is already locked.
674 static void fib_magic(int cmd, int type, __be32 dst, int dst_len, struct in_ifaddr *ifa)
676 struct net *net = ifa->ifa_dev->dev->nd_net;
677 struct fib_table *tb;
678 struct fib_config cfg = {
679 .fc_protocol = RTPROT_KERNEL,
682 .fc_dst_len = dst_len,
683 .fc_prefsrc = ifa->ifa_local,
684 .fc_oif = ifa->ifa_dev->dev->ifindex,
685 .fc_nlflags = NLM_F_CREATE | NLM_F_APPEND,
691 if (type == RTN_UNICAST)
692 tb = fib_new_table(net, RT_TABLE_MAIN);
694 tb = fib_new_table(net, RT_TABLE_LOCAL);
699 cfg.fc_table = tb->tb_id;
701 if (type != RTN_LOCAL)
702 cfg.fc_scope = RT_SCOPE_LINK;
704 cfg.fc_scope = RT_SCOPE_HOST;
706 if (cmd == RTM_NEWROUTE)
707 tb->tb_insert(tb, &cfg);
709 tb->tb_delete(tb, &cfg);
712 void fib_add_ifaddr(struct in_ifaddr *ifa)
714 struct in_device *in_dev = ifa->ifa_dev;
715 struct net_device *dev = in_dev->dev;
716 struct in_ifaddr *prim = ifa;
717 __be32 mask = ifa->ifa_mask;
718 __be32 addr = ifa->ifa_local;
719 __be32 prefix = ifa->ifa_address&mask;
721 if (ifa->ifa_flags&IFA_F_SECONDARY) {
722 prim = inet_ifa_byprefix(in_dev, prefix, mask);
724 printk(KERN_WARNING "fib_add_ifaddr: bug: prim == NULL\n");
729 fib_magic(RTM_NEWROUTE, RTN_LOCAL, addr, 32, prim);
731 if (!(dev->flags&IFF_UP))
734 /* Add broadcast address, if it is explicitly assigned. */
735 if (ifa->ifa_broadcast && ifa->ifa_broadcast != htonl(0xFFFFFFFF))
736 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
738 if (!ipv4_is_zeronet(prefix) && !(ifa->ifa_flags&IFA_F_SECONDARY) &&
739 (prefix != addr || ifa->ifa_prefixlen < 32)) {
740 fib_magic(RTM_NEWROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
741 RTN_UNICAST, prefix, ifa->ifa_prefixlen, prim);
743 /* Add network specific broadcasts, when it takes a sense */
744 if (ifa->ifa_prefixlen < 31) {
745 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix, 32, prim);
746 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix|~mask, 32, prim);
751 static void fib_del_ifaddr(struct in_ifaddr *ifa)
753 struct in_device *in_dev = ifa->ifa_dev;
754 struct net_device *dev = in_dev->dev;
755 struct in_ifaddr *ifa1;
756 struct in_ifaddr *prim = ifa;
757 __be32 brd = ifa->ifa_address|~ifa->ifa_mask;
758 __be32 any = ifa->ifa_address&ifa->ifa_mask;
765 if (!(ifa->ifa_flags&IFA_F_SECONDARY))
766 fib_magic(RTM_DELROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
767 RTN_UNICAST, any, ifa->ifa_prefixlen, prim);
769 prim = inet_ifa_byprefix(in_dev, any, ifa->ifa_mask);
771 printk(KERN_WARNING "fib_del_ifaddr: bug: prim == NULL\n");
776 /* Deletion is more complicated than add.
777 We should take care of not to delete too much :-)
779 Scan address list to be sure that addresses are really gone.
782 for (ifa1 = in_dev->ifa_list; ifa1; ifa1 = ifa1->ifa_next) {
783 if (ifa->ifa_local == ifa1->ifa_local)
785 if (ifa->ifa_broadcast == ifa1->ifa_broadcast)
787 if (brd == ifa1->ifa_broadcast)
789 if (any == ifa1->ifa_broadcast)
794 fib_magic(RTM_DELROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
796 fib_magic(RTM_DELROUTE, RTN_BROADCAST, brd, 32, prim);
798 fib_magic(RTM_DELROUTE, RTN_BROADCAST, any, 32, prim);
799 if (!(ok&LOCAL_OK)) {
800 fib_magic(RTM_DELROUTE, RTN_LOCAL, ifa->ifa_local, 32, prim);
802 /* Check, that this local address finally disappeared. */
803 if (inet_addr_type(dev->nd_net, ifa->ifa_local) != RTN_LOCAL) {
804 /* And the last, but not the least thing.
805 We must flush stray FIB entries.
807 First of all, we scan fib_info list searching
808 for stray nexthop entries, then ignite fib_flush.
810 if (fib_sync_down(ifa->ifa_local, NULL, 0))
811 fib_flush(dev->nd_net);
820 static void nl_fib_lookup(struct fib_result_nl *frn, struct fib_table *tb )
823 struct fib_result res;
824 struct flowi fl = { .mark = frn->fl_mark,
825 .nl_u = { .ip4_u = { .daddr = frn->fl_addr,
827 .scope = frn->fl_scope } } };
829 #ifdef CONFIG_IP_MULTIPLE_TABLES
837 frn->tb_id = tb->tb_id;
838 frn->err = tb->tb_lookup(tb, &fl, &res);
841 frn->prefixlen = res.prefixlen;
842 frn->nh_sel = res.nh_sel;
843 frn->type = res.type;
844 frn->scope = res.scope;
851 static void nl_fib_input(struct sk_buff *skb)
854 struct fib_result_nl *frn;
855 struct nlmsghdr *nlh;
856 struct fib_table *tb;
859 net = skb->sk->sk_net;
860 nlh = nlmsg_hdr(skb);
861 if (skb->len < NLMSG_SPACE(0) || skb->len < nlh->nlmsg_len ||
862 nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*frn)))
865 skb = skb_clone(skb, GFP_KERNEL);
868 nlh = nlmsg_hdr(skb);
870 frn = (struct fib_result_nl *) NLMSG_DATA(nlh);
871 tb = fib_get_table(net, frn->tb_id_in);
873 nl_fib_lookup(frn, tb);
875 pid = NETLINK_CB(skb).pid; /* pid of sending process */
876 NETLINK_CB(skb).pid = 0; /* from kernel */
877 NETLINK_CB(skb).dst_group = 0; /* unicast */
878 netlink_unicast(net->ipv4.fibnl, skb, pid, MSG_DONTWAIT);
881 static int nl_fib_lookup_init(struct net *net)
884 sk = netlink_kernel_create(net, NETLINK_FIB_LOOKUP, 0,
885 nl_fib_input, NULL, THIS_MODULE);
887 return -EAFNOSUPPORT;
888 net->ipv4.fibnl = sk;
892 static void nl_fib_lookup_exit(struct net *net)
894 netlink_kernel_release(net->ipv4.fibnl);
895 net->ipv4.fibnl = NULL;
898 static void fib_disable_ip(struct net_device *dev, int force)
900 if (fib_sync_down(0, dev, force))
901 fib_flush(dev->nd_net);
906 static int fib_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
908 struct in_ifaddr *ifa = (struct in_ifaddr*)ptr;
913 #ifdef CONFIG_IP_ROUTE_MULTIPATH
914 fib_sync_up(ifa->ifa_dev->dev);
920 if (ifa->ifa_dev->ifa_list == NULL) {
921 /* Last address was deleted from this interface.
924 fib_disable_ip(ifa->ifa_dev->dev, 1);
933 static int fib_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
935 struct net_device *dev = ptr;
936 struct in_device *in_dev = __in_dev_get_rtnl(dev);
938 if (event == NETDEV_UNREGISTER) {
939 fib_disable_ip(dev, 2);
950 } endfor_ifa(in_dev);
951 #ifdef CONFIG_IP_ROUTE_MULTIPATH
957 fib_disable_ip(dev, 0);
959 case NETDEV_CHANGEMTU:
967 static struct notifier_block fib_inetaddr_notifier = {
968 .notifier_call =fib_inetaddr_event,
971 static struct notifier_block fib_netdev_notifier = {
972 .notifier_call =fib_netdev_event,
975 static int __net_init ip_fib_net_init(struct net *net)
979 net->ipv4.fib_table_hash = kzalloc(
980 sizeof(struct hlist_head)*FIB_TABLE_HASHSZ, GFP_KERNEL);
981 if (net->ipv4.fib_table_hash == NULL)
984 for (i = 0; i < FIB_TABLE_HASHSZ; i++)
985 INIT_HLIST_HEAD(&net->ipv4.fib_table_hash[i]);
987 return fib4_rules_init(net);
990 static void __net_exit ip_fib_net_exit(struct net *net)
994 #ifdef CONFIG_IP_MULTIPLE_TABLES
995 fib4_rules_exit(net);
998 for (i = 0; i < FIB_TABLE_HASHSZ; i++) {
999 struct fib_table *tb;
1000 struct hlist_head *head;
1001 struct hlist_node *node, *tmp;
1003 head = &net->ipv4.fib_table_hash[i];
1004 hlist_for_each_entry_safe(tb, node, tmp, head, tb_hlist) {
1010 kfree(net->ipv4.fib_table_hash);
1013 static int __net_init fib_net_init(struct net *net)
1017 error = ip_fib_net_init(net);
1020 error = nl_fib_lookup_init(net);
1023 error = fib_proc_init(net);
1030 nl_fib_lookup_exit(net);
1032 ip_fib_net_exit(net);
1036 static void __net_exit fib_net_exit(struct net *net)
1039 nl_fib_lookup_exit(net);
1040 ip_fib_net_exit(net);
1043 static struct pernet_operations fib_net_ops = {
1044 .init = fib_net_init,
1045 .exit = fib_net_exit,
1048 void __init ip_fib_init(void)
1050 rtnl_register(PF_INET, RTM_NEWROUTE, inet_rtm_newroute, NULL);
1051 rtnl_register(PF_INET, RTM_DELROUTE, inet_rtm_delroute, NULL);
1052 rtnl_register(PF_INET, RTM_GETROUTE, NULL, inet_dump_fib);
1054 register_pernet_subsys(&fib_net_ops);
1055 register_netdevice_notifier(&fib_netdev_notifier);
1056 register_inetaddr_notifier(&fib_inetaddr_notifier);
1061 EXPORT_SYMBOL(inet_addr_type);
1062 EXPORT_SYMBOL(inet_dev_addr_type);
1063 EXPORT_SYMBOL(ip_dev_find);