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 #define FFprint(a...) printk(KERN_DEBUG a)
52 static struct sock *fibnl;
54 #ifndef CONFIG_IP_MULTIPLE_TABLES
56 struct fib_table *ip_fib_local_table;
57 struct fib_table *ip_fib_main_table;
59 #define FIB_TABLE_HASHSZ 1
60 static struct hlist_head fib_table_hash[FIB_TABLE_HASHSZ];
62 static int __net_init fib4_rules_init(struct net *net)
64 ip_fib_local_table = fib_hash_init(RT_TABLE_LOCAL);
65 if (ip_fib_local_table == NULL)
68 ip_fib_main_table = fib_hash_init(RT_TABLE_MAIN);
69 if (ip_fib_main_table == NULL)
72 hlist_add_head_rcu(&ip_fib_local_table->tb_hlist, &fib_table_hash[0]);
73 hlist_add_head_rcu(&ip_fib_main_table->tb_hlist, &fib_table_hash[0]);
77 kfree(ip_fib_local_table);
78 ip_fib_local_table = NULL;
83 #define FIB_TABLE_HASHSZ 256
84 static struct hlist_head fib_table_hash[FIB_TABLE_HASHSZ];
86 struct fib_table *fib_new_table(u32 id)
93 tb = fib_get_table(id);
96 tb = fib_hash_init(id);
99 h = id & (FIB_TABLE_HASHSZ - 1);
100 hlist_add_head_rcu(&tb->tb_hlist, &fib_table_hash[h]);
104 struct fib_table *fib_get_table(u32 id)
106 struct fib_table *tb;
107 struct hlist_node *node;
112 h = id & (FIB_TABLE_HASHSZ - 1);
114 hlist_for_each_entry_rcu(tb, node, &fib_table_hash[h], tb_hlist) {
115 if (tb->tb_id == id) {
123 #endif /* CONFIG_IP_MULTIPLE_TABLES */
125 static void fib_flush(void)
128 struct fib_table *tb;
129 struct hlist_node *node;
132 for (h = 0; h < FIB_TABLE_HASHSZ; h++) {
133 hlist_for_each_entry(tb, node, &fib_table_hash[h], tb_hlist)
134 flushed += tb->tb_flush(tb);
142 * Find the first device with a given source address.
145 struct net_device * ip_dev_find(__be32 addr)
147 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
148 struct fib_result res;
149 struct net_device *dev = NULL;
150 struct fib_table *local_table;
152 #ifdef CONFIG_IP_MULTIPLE_TABLES
156 local_table = fib_get_table(RT_TABLE_LOCAL);
157 if (!local_table || local_table->tb_lookup(local_table, &fl, &res))
159 if (res.type != RTN_LOCAL)
161 dev = FIB_RES_DEV(res);
171 * Find address type as if only "dev" was present in the system. If
172 * on_dev is NULL then all interfaces are taken into consideration.
174 static inline unsigned __inet_dev_addr_type(const struct net_device *dev,
177 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
178 struct fib_result res;
179 unsigned ret = RTN_BROADCAST;
180 struct fib_table *local_table;
182 if (ipv4_is_zeronet(addr) || ipv4_is_badclass(addr))
183 return RTN_BROADCAST;
184 if (ipv4_is_multicast(addr))
185 return RTN_MULTICAST;
187 #ifdef CONFIG_IP_MULTIPLE_TABLES
191 local_table = fib_get_table(RT_TABLE_LOCAL);
194 if (!local_table->tb_lookup(local_table, &fl, &res)) {
195 if (!dev || dev == res.fi->fib_dev)
203 unsigned int inet_addr_type(__be32 addr)
205 return __inet_dev_addr_type(NULL, addr);
208 unsigned int inet_dev_addr_type(const struct net_device *dev, __be32 addr)
210 return __inet_dev_addr_type(dev, addr);
213 /* Given (packet source, input interface) and optional (dst, oif, tos):
214 - (main) check, that source is valid i.e. not broadcast or our local
216 - figure out what "logical" interface this packet arrived
217 and calculate "specific destination" address.
218 - check, that packet arrived from expected physical interface.
221 int fib_validate_source(__be32 src, __be32 dst, u8 tos, int oif,
222 struct net_device *dev, __be32 *spec_dst, u32 *itag)
224 struct in_device *in_dev;
225 struct flowi fl = { .nl_u = { .ip4_u =
230 struct fib_result res;
236 in_dev = __in_dev_get_rcu(dev);
238 no_addr = in_dev->ifa_list == NULL;
239 rpf = IN_DEV_RPFILTER(in_dev);
246 if (fib_lookup(&fl, &res))
248 if (res.type != RTN_UNICAST)
250 *spec_dst = FIB_RES_PREFSRC(res);
251 fib_combine_itag(itag, &res);
252 #ifdef CONFIG_IP_ROUTE_MULTIPATH
253 if (FIB_RES_DEV(res) == dev || res.fi->fib_nhs > 1)
255 if (FIB_RES_DEV(res) == dev)
258 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
267 fl.oif = dev->ifindex;
270 if (fib_lookup(&fl, &res) == 0) {
271 if (res.type == RTN_UNICAST) {
272 *spec_dst = FIB_RES_PREFSRC(res);
273 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
282 *spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
292 static inline __be32 sk_extract_addr(struct sockaddr *addr)
294 return ((struct sockaddr_in *) addr)->sin_addr.s_addr;
297 static int put_rtax(struct nlattr *mx, int len, int type, u32 value)
301 nla = (struct nlattr *) ((char *) mx + len);
302 nla->nla_type = type;
303 nla->nla_len = nla_attr_size(4);
304 *(u32 *) nla_data(nla) = value;
306 return len + nla_total_size(4);
309 static int rtentry_to_fib_config(int cmd, struct rtentry *rt,
310 struct fib_config *cfg)
315 memset(cfg, 0, sizeof(*cfg));
317 if (rt->rt_dst.sa_family != AF_INET)
318 return -EAFNOSUPPORT;
321 * Check mask for validity:
322 * a) it must be contiguous.
323 * b) destination must have all host bits clear.
324 * c) if application forgot to set correct family (AF_INET),
325 * reject request unless it is absolutely clear i.e.
326 * both family and mask are zero.
329 addr = sk_extract_addr(&rt->rt_dst);
330 if (!(rt->rt_flags & RTF_HOST)) {
331 __be32 mask = sk_extract_addr(&rt->rt_genmask);
333 if (rt->rt_genmask.sa_family != AF_INET) {
334 if (mask || rt->rt_genmask.sa_family)
335 return -EAFNOSUPPORT;
338 if (bad_mask(mask, addr))
341 plen = inet_mask_len(mask);
344 cfg->fc_dst_len = plen;
347 if (cmd != SIOCDELRT) {
348 cfg->fc_nlflags = NLM_F_CREATE;
349 cfg->fc_protocol = RTPROT_BOOT;
353 cfg->fc_priority = rt->rt_metric - 1;
355 if (rt->rt_flags & RTF_REJECT) {
356 cfg->fc_scope = RT_SCOPE_HOST;
357 cfg->fc_type = RTN_UNREACHABLE;
361 cfg->fc_scope = RT_SCOPE_NOWHERE;
362 cfg->fc_type = RTN_UNICAST;
366 struct net_device *dev;
367 char devname[IFNAMSIZ];
369 if (copy_from_user(devname, rt->rt_dev, IFNAMSIZ-1))
372 devname[IFNAMSIZ-1] = 0;
373 colon = strchr(devname, ':');
376 dev = __dev_get_by_name(&init_net, devname);
379 cfg->fc_oif = dev->ifindex;
381 struct in_ifaddr *ifa;
382 struct in_device *in_dev = __in_dev_get_rtnl(dev);
386 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next)
387 if (strcmp(ifa->ifa_label, devname) == 0)
391 cfg->fc_prefsrc = ifa->ifa_local;
395 addr = sk_extract_addr(&rt->rt_gateway);
396 if (rt->rt_gateway.sa_family == AF_INET && addr) {
398 if (rt->rt_flags & RTF_GATEWAY &&
399 inet_addr_type(addr) == RTN_UNICAST)
400 cfg->fc_scope = RT_SCOPE_UNIVERSE;
403 if (cmd == SIOCDELRT)
406 if (rt->rt_flags & RTF_GATEWAY && !cfg->fc_gw)
409 if (cfg->fc_scope == RT_SCOPE_NOWHERE)
410 cfg->fc_scope = RT_SCOPE_LINK;
412 if (rt->rt_flags & (RTF_MTU | RTF_WINDOW | RTF_IRTT)) {
416 mx = kzalloc(3 * nla_total_size(4), GFP_KERNEL);
420 if (rt->rt_flags & RTF_MTU)
421 len = put_rtax(mx, len, RTAX_ADVMSS, rt->rt_mtu - 40);
423 if (rt->rt_flags & RTF_WINDOW)
424 len = put_rtax(mx, len, RTAX_WINDOW, rt->rt_window);
426 if (rt->rt_flags & RTF_IRTT)
427 len = put_rtax(mx, len, RTAX_RTT, rt->rt_irtt << 3);
430 cfg->fc_mx_len = len;
437 * Handle IP routing ioctl calls. These are used to manipulate the routing tables
440 int ip_rt_ioctl(unsigned int cmd, void __user *arg)
442 struct fib_config cfg;
447 case SIOCADDRT: /* Add a route */
448 case SIOCDELRT: /* Delete a route */
449 if (!capable(CAP_NET_ADMIN))
452 if (copy_from_user(&rt, arg, sizeof(rt)))
456 err = rtentry_to_fib_config(cmd, &rt, &cfg);
458 struct fib_table *tb;
460 if (cmd == SIOCDELRT) {
461 tb = fib_get_table(cfg.fc_table);
463 err = tb->tb_delete(tb, &cfg);
467 tb = fib_new_table(cfg.fc_table);
469 err = tb->tb_insert(tb, &cfg);
474 /* allocated by rtentry_to_fib_config() */
483 const struct nla_policy rtm_ipv4_policy[RTA_MAX+1] = {
484 [RTA_DST] = { .type = NLA_U32 },
485 [RTA_SRC] = { .type = NLA_U32 },
486 [RTA_IIF] = { .type = NLA_U32 },
487 [RTA_OIF] = { .type = NLA_U32 },
488 [RTA_GATEWAY] = { .type = NLA_U32 },
489 [RTA_PRIORITY] = { .type = NLA_U32 },
490 [RTA_PREFSRC] = { .type = NLA_U32 },
491 [RTA_METRICS] = { .type = NLA_NESTED },
492 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
493 [RTA_PROTOINFO] = { .type = NLA_U32 },
494 [RTA_FLOW] = { .type = NLA_U32 },
497 static int rtm_to_fib_config(struct sk_buff *skb, struct nlmsghdr *nlh,
498 struct fib_config *cfg)
504 err = nlmsg_validate(nlh, sizeof(*rtm), RTA_MAX, rtm_ipv4_policy);
508 memset(cfg, 0, sizeof(*cfg));
510 rtm = nlmsg_data(nlh);
511 cfg->fc_dst_len = rtm->rtm_dst_len;
512 cfg->fc_tos = rtm->rtm_tos;
513 cfg->fc_table = rtm->rtm_table;
514 cfg->fc_protocol = rtm->rtm_protocol;
515 cfg->fc_scope = rtm->rtm_scope;
516 cfg->fc_type = rtm->rtm_type;
517 cfg->fc_flags = rtm->rtm_flags;
518 cfg->fc_nlflags = nlh->nlmsg_flags;
520 cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
521 cfg->fc_nlinfo.nlh = nlh;
523 if (cfg->fc_type > RTN_MAX) {
528 nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), remaining) {
529 switch (nla_type(attr)) {
531 cfg->fc_dst = nla_get_be32(attr);
534 cfg->fc_oif = nla_get_u32(attr);
537 cfg->fc_gw = nla_get_be32(attr);
540 cfg->fc_priority = nla_get_u32(attr);
543 cfg->fc_prefsrc = nla_get_be32(attr);
546 cfg->fc_mx = nla_data(attr);
547 cfg->fc_mx_len = nla_len(attr);
550 cfg->fc_mp = nla_data(attr);
551 cfg->fc_mp_len = nla_len(attr);
554 cfg->fc_flow = nla_get_u32(attr);
557 cfg->fc_table = nla_get_u32(attr);
567 static int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
569 struct net *net = skb->sk->sk_net;
570 struct fib_config cfg;
571 struct fib_table *tb;
574 if (net != &init_net)
577 err = rtm_to_fib_config(skb, nlh, &cfg);
581 tb = fib_get_table(cfg.fc_table);
587 err = tb->tb_delete(tb, &cfg);
592 static int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
594 struct net *net = skb->sk->sk_net;
595 struct fib_config cfg;
596 struct fib_table *tb;
599 if (net != &init_net)
602 err = rtm_to_fib_config(skb, nlh, &cfg);
606 tb = fib_new_table(cfg.fc_table);
612 err = tb->tb_insert(tb, &cfg);
617 static int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
619 struct net *net = skb->sk->sk_net;
621 unsigned int e = 0, s_e;
622 struct fib_table *tb;
623 struct hlist_node *node;
626 if (net != &init_net)
629 if (nlmsg_len(cb->nlh) >= sizeof(struct rtmsg) &&
630 ((struct rtmsg *) nlmsg_data(cb->nlh))->rtm_flags & RTM_F_CLONED)
631 return ip_rt_dump(skb, cb);
636 for (h = s_h; h < FIB_TABLE_HASHSZ; h++, s_e = 0) {
638 hlist_for_each_entry(tb, node, &fib_table_hash[h], tb_hlist) {
642 memset(&cb->args[2], 0, sizeof(cb->args) -
643 2 * sizeof(cb->args[0]));
644 if (tb->tb_dump(tb, skb, cb) < 0)
658 /* Prepare and feed intra-kernel routing request.
659 Really, it should be netlink message, but :-( netlink
660 can be not configured, so that we feed it directly
661 to fib engine. It is legal, because all events occur
662 only when netlink is already locked.
665 static void fib_magic(int cmd, int type, __be32 dst, int dst_len, struct in_ifaddr *ifa)
667 struct fib_table *tb;
668 struct fib_config cfg = {
669 .fc_protocol = RTPROT_KERNEL,
672 .fc_dst_len = dst_len,
673 .fc_prefsrc = ifa->ifa_local,
674 .fc_oif = ifa->ifa_dev->dev->ifindex,
675 .fc_nlflags = NLM_F_CREATE | NLM_F_APPEND,
678 if (type == RTN_UNICAST)
679 tb = fib_new_table(RT_TABLE_MAIN);
681 tb = fib_new_table(RT_TABLE_LOCAL);
686 cfg.fc_table = tb->tb_id;
688 if (type != RTN_LOCAL)
689 cfg.fc_scope = RT_SCOPE_LINK;
691 cfg.fc_scope = RT_SCOPE_HOST;
693 if (cmd == RTM_NEWROUTE)
694 tb->tb_insert(tb, &cfg);
696 tb->tb_delete(tb, &cfg);
699 void fib_add_ifaddr(struct in_ifaddr *ifa)
701 struct in_device *in_dev = ifa->ifa_dev;
702 struct net_device *dev = in_dev->dev;
703 struct in_ifaddr *prim = ifa;
704 __be32 mask = ifa->ifa_mask;
705 __be32 addr = ifa->ifa_local;
706 __be32 prefix = ifa->ifa_address&mask;
708 if (ifa->ifa_flags&IFA_F_SECONDARY) {
709 prim = inet_ifa_byprefix(in_dev, prefix, mask);
711 printk(KERN_DEBUG "fib_add_ifaddr: bug: prim == NULL\n");
716 fib_magic(RTM_NEWROUTE, RTN_LOCAL, addr, 32, prim);
718 if (!(dev->flags&IFF_UP))
721 /* Add broadcast address, if it is explicitly assigned. */
722 if (ifa->ifa_broadcast && ifa->ifa_broadcast != htonl(0xFFFFFFFF))
723 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
725 if (!ipv4_is_zeronet(prefix) && !(ifa->ifa_flags&IFA_F_SECONDARY) &&
726 (prefix != addr || ifa->ifa_prefixlen < 32)) {
727 fib_magic(RTM_NEWROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
728 RTN_UNICAST, prefix, ifa->ifa_prefixlen, prim);
730 /* Add network specific broadcasts, when it takes a sense */
731 if (ifa->ifa_prefixlen < 31) {
732 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix, 32, prim);
733 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix|~mask, 32, prim);
738 static void fib_del_ifaddr(struct in_ifaddr *ifa)
740 struct in_device *in_dev = ifa->ifa_dev;
741 struct net_device *dev = in_dev->dev;
742 struct in_ifaddr *ifa1;
743 struct in_ifaddr *prim = ifa;
744 __be32 brd = ifa->ifa_address|~ifa->ifa_mask;
745 __be32 any = ifa->ifa_address&ifa->ifa_mask;
752 if (!(ifa->ifa_flags&IFA_F_SECONDARY))
753 fib_magic(RTM_DELROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
754 RTN_UNICAST, any, ifa->ifa_prefixlen, prim);
756 prim = inet_ifa_byprefix(in_dev, any, ifa->ifa_mask);
758 printk(KERN_DEBUG "fib_del_ifaddr: bug: prim == NULL\n");
763 /* Deletion is more complicated than add.
764 We should take care of not to delete too much :-)
766 Scan address list to be sure that addresses are really gone.
769 for (ifa1 = in_dev->ifa_list; ifa1; ifa1 = ifa1->ifa_next) {
770 if (ifa->ifa_local == ifa1->ifa_local)
772 if (ifa->ifa_broadcast == ifa1->ifa_broadcast)
774 if (brd == ifa1->ifa_broadcast)
776 if (any == ifa1->ifa_broadcast)
781 fib_magic(RTM_DELROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
783 fib_magic(RTM_DELROUTE, RTN_BROADCAST, brd, 32, prim);
785 fib_magic(RTM_DELROUTE, RTN_BROADCAST, any, 32, prim);
786 if (!(ok&LOCAL_OK)) {
787 fib_magic(RTM_DELROUTE, RTN_LOCAL, ifa->ifa_local, 32, prim);
789 /* Check, that this local address finally disappeared. */
790 if (inet_addr_type(ifa->ifa_local) != RTN_LOCAL) {
791 /* And the last, but not the least thing.
792 We must flush stray FIB entries.
794 First of all, we scan fib_info list searching
795 for stray nexthop entries, then ignite fib_flush.
797 if (fib_sync_down(ifa->ifa_local, NULL, 0))
807 static void nl_fib_lookup(struct fib_result_nl *frn, struct fib_table *tb )
810 struct fib_result res;
811 struct flowi fl = { .mark = frn->fl_mark,
812 .nl_u = { .ip4_u = { .daddr = frn->fl_addr,
814 .scope = frn->fl_scope } } };
816 #ifdef CONFIG_IP_MULTIPLE_TABLES
824 frn->tb_id = tb->tb_id;
825 frn->err = tb->tb_lookup(tb, &fl, &res);
828 frn->prefixlen = res.prefixlen;
829 frn->nh_sel = res.nh_sel;
830 frn->type = res.type;
831 frn->scope = res.scope;
838 static void nl_fib_input(struct sk_buff *skb)
840 struct fib_result_nl *frn;
841 struct nlmsghdr *nlh;
842 struct fib_table *tb;
845 nlh = nlmsg_hdr(skb);
846 if (skb->len < NLMSG_SPACE(0) || skb->len < nlh->nlmsg_len ||
847 nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*frn)))
850 skb = skb_clone(skb, GFP_KERNEL);
853 nlh = nlmsg_hdr(skb);
855 frn = (struct fib_result_nl *) NLMSG_DATA(nlh);
856 tb = fib_get_table(frn->tb_id_in);
858 nl_fib_lookup(frn, tb);
860 pid = NETLINK_CB(skb).pid; /* pid of sending process */
861 NETLINK_CB(skb).pid = 0; /* from kernel */
862 NETLINK_CB(skb).dst_group = 0; /* unicast */
863 netlink_unicast(fibnl, skb, pid, MSG_DONTWAIT);
866 static int nl_fib_lookup_init(struct net *net)
868 fibnl = netlink_kernel_create(net, NETLINK_FIB_LOOKUP, 0,
869 nl_fib_input, NULL, THIS_MODULE);
871 return -EAFNOSUPPORT;
875 static void nl_fib_lookup_exit(struct net *net)
880 static void fib_disable_ip(struct net_device *dev, int force)
882 if (fib_sync_down(0, dev, force))
888 static int fib_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
890 struct in_ifaddr *ifa = (struct in_ifaddr*)ptr;
895 #ifdef CONFIG_IP_ROUTE_MULTIPATH
896 fib_sync_up(ifa->ifa_dev->dev);
902 if (ifa->ifa_dev->ifa_list == NULL) {
903 /* Last address was deleted from this interface.
906 fib_disable_ip(ifa->ifa_dev->dev, 1);
915 static int fib_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
917 struct net_device *dev = ptr;
918 struct in_device *in_dev = __in_dev_get_rtnl(dev);
920 if (dev->nd_net != &init_net)
923 if (event == NETDEV_UNREGISTER) {
924 fib_disable_ip(dev, 2);
935 } endfor_ifa(in_dev);
936 #ifdef CONFIG_IP_ROUTE_MULTIPATH
942 fib_disable_ip(dev, 0);
944 case NETDEV_CHANGEMTU:
952 static struct notifier_block fib_inetaddr_notifier = {
953 .notifier_call =fib_inetaddr_event,
956 static struct notifier_block fib_netdev_notifier = {
957 .notifier_call =fib_netdev_event,
960 static int __net_init ip_fib_net_init(struct net *net)
964 for (i = 0; i < FIB_TABLE_HASHSZ; i++)
965 INIT_HLIST_HEAD(&fib_table_hash[i]);
967 return fib4_rules_init(net);
970 static void __net_exit ip_fib_net_exit(struct net *net)
974 #ifdef CONFIG_IP_MULTIPLE_TABLES
975 fib4_rules_exit(net);
978 for (i = 0; i < FIB_TABLE_HASHSZ; i++) {
979 struct fib_table *tb;
980 struct hlist_head *head;
981 struct hlist_node *node, *tmp;
983 head = &fib_table_hash[i];
984 hlist_for_each_entry_safe(tb, node, tmp, head, tb_hlist) {
992 static int __net_init fib_net_init(struct net *net)
997 if (net != &init_net)
1000 error = ip_fib_net_init(net);
1003 error = nl_fib_lookup_init(net);
1006 error = fib_proc_init(net);
1013 nl_fib_lookup_exit(net);
1015 ip_fib_net_exit(net);
1019 static void __net_exit fib_net_exit(struct net *net)
1022 nl_fib_lookup_exit(net);
1023 ip_fib_net_exit(net);
1026 static struct pernet_operations fib_net_ops = {
1027 .init = fib_net_init,
1028 .exit = fib_net_exit,
1031 void __init ip_fib_init(void)
1033 rtnl_register(PF_INET, RTM_NEWROUTE, inet_rtm_newroute, NULL);
1034 rtnl_register(PF_INET, RTM_DELROUTE, inet_rtm_delroute, NULL);
1035 rtnl_register(PF_INET, RTM_GETROUTE, NULL, inet_dump_fib);
1037 register_pernet_subsys(&fib_net_ops);
1038 register_netdevice_notifier(&fib_netdev_notifier);
1039 register_inetaddr_notifier(&fib_inetaddr_notifier);
1042 EXPORT_SYMBOL(inet_addr_type);
1043 EXPORT_SYMBOL(inet_dev_addr_type);
1044 EXPORT_SYMBOL(ip_dev_find);