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 static int __net_init fib4_rules_init(struct net *net)
58 struct fib_table *local_table, *main_table;
60 local_table = fib_hash_init(RT_TABLE_LOCAL);
61 if (local_table == NULL)
64 main_table = fib_hash_init(RT_TABLE_MAIN);
65 if (main_table == NULL)
68 hlist_add_head_rcu(&local_table->tb_hlist,
69 &net->ipv4.fib_table_hash[TABLE_LOCAL_INDEX]);
70 hlist_add_head_rcu(&main_table->tb_hlist,
71 &net->ipv4.fib_table_hash[TABLE_MAIN_INDEX]);
80 struct fib_table *fib_new_table(struct net *net, u32 id)
87 tb = fib_get_table(net, id);
90 tb = fib_hash_init(id);
93 h = id & (FIB_TABLE_HASHSZ - 1);
94 hlist_add_head_rcu(&tb->tb_hlist, &net->ipv4.fib_table_hash[h]);
98 struct fib_table *fib_get_table(struct net *net, u32 id)
100 struct fib_table *tb;
101 struct hlist_node *node;
102 struct hlist_head *head;
107 h = id & (FIB_TABLE_HASHSZ - 1);
110 head = &net->ipv4.fib_table_hash[h];
111 hlist_for_each_entry_rcu(tb, node, head, tb_hlist) {
112 if (tb->tb_id == id) {
120 #endif /* CONFIG_IP_MULTIPLE_TABLES */
122 static void fib_flush(struct net *net)
125 struct fib_table *tb;
126 struct hlist_node *node;
127 struct hlist_head *head;
130 for (h = 0; h < FIB_TABLE_HASHSZ; h++) {
131 head = &net->ipv4.fib_table_hash[h];
132 hlist_for_each_entry(tb, node, head, tb_hlist)
133 flushed += tb->tb_flush(tb);
141 * Find the first device with a given source address.
144 struct net_device * ip_dev_find(__be32 addr)
146 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
147 struct fib_result res;
148 struct net_device *dev = NULL;
149 struct fib_table *local_table;
151 #ifdef CONFIG_IP_MULTIPLE_TABLES
155 local_table = fib_get_table(&init_net, RT_TABLE_LOCAL);
156 if (!local_table || local_table->tb_lookup(local_table, &fl, &res))
158 if (res.type != RTN_LOCAL)
160 dev = FIB_RES_DEV(res);
170 * Find address type as if only "dev" was present in the system. If
171 * on_dev is NULL then all interfaces are taken into consideration.
173 static inline unsigned __inet_dev_addr_type(struct net *net,
174 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(net, 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(struct net *net, __be32 addr)
205 return __inet_dev_addr_type(net, NULL, addr);
208 unsigned int inet_dev_addr_type(struct net *net, const struct net_device *dev,
211 return __inet_dev_addr_type(net, dev, addr);
214 /* Given (packet source, input interface) and optional (dst, oif, tos):
215 - (main) check, that source is valid i.e. not broadcast or our local
217 - figure out what "logical" interface this packet arrived
218 and calculate "specific destination" address.
219 - check, that packet arrived from expected physical interface.
222 int fib_validate_source(__be32 src, __be32 dst, u8 tos, int oif,
223 struct net_device *dev, __be32 *spec_dst, u32 *itag)
225 struct in_device *in_dev;
226 struct flowi fl = { .nl_u = { .ip4_u =
231 struct fib_result res;
237 in_dev = __in_dev_get_rcu(dev);
239 no_addr = in_dev->ifa_list == NULL;
240 rpf = IN_DEV_RPFILTER(in_dev);
247 if (fib_lookup(&fl, &res))
249 if (res.type != RTN_UNICAST)
251 *spec_dst = FIB_RES_PREFSRC(res);
252 fib_combine_itag(itag, &res);
253 #ifdef CONFIG_IP_ROUTE_MULTIPATH
254 if (FIB_RES_DEV(res) == dev || res.fi->fib_nhs > 1)
256 if (FIB_RES_DEV(res) == dev)
259 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
268 fl.oif = dev->ifindex;
271 if (fib_lookup(&fl, &res) == 0) {
272 if (res.type == RTN_UNICAST) {
273 *spec_dst = FIB_RES_PREFSRC(res);
274 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
283 *spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
293 static inline __be32 sk_extract_addr(struct sockaddr *addr)
295 return ((struct sockaddr_in *) addr)->sin_addr.s_addr;
298 static int put_rtax(struct nlattr *mx, int len, int type, u32 value)
302 nla = (struct nlattr *) ((char *) mx + len);
303 nla->nla_type = type;
304 nla->nla_len = nla_attr_size(4);
305 *(u32 *) nla_data(nla) = value;
307 return len + nla_total_size(4);
310 static int rtentry_to_fib_config(int cmd, struct rtentry *rt,
311 struct fib_config *cfg)
316 memset(cfg, 0, sizeof(*cfg));
317 cfg->fc_nlinfo.nl_net = &init_net;
319 if (rt->rt_dst.sa_family != AF_INET)
320 return -EAFNOSUPPORT;
323 * Check mask for validity:
324 * a) it must be contiguous.
325 * b) destination must have all host bits clear.
326 * c) if application forgot to set correct family (AF_INET),
327 * reject request unless it is absolutely clear i.e.
328 * both family and mask are zero.
331 addr = sk_extract_addr(&rt->rt_dst);
332 if (!(rt->rt_flags & RTF_HOST)) {
333 __be32 mask = sk_extract_addr(&rt->rt_genmask);
335 if (rt->rt_genmask.sa_family != AF_INET) {
336 if (mask || rt->rt_genmask.sa_family)
337 return -EAFNOSUPPORT;
340 if (bad_mask(mask, addr))
343 plen = inet_mask_len(mask);
346 cfg->fc_dst_len = plen;
349 if (cmd != SIOCDELRT) {
350 cfg->fc_nlflags = NLM_F_CREATE;
351 cfg->fc_protocol = RTPROT_BOOT;
355 cfg->fc_priority = rt->rt_metric - 1;
357 if (rt->rt_flags & RTF_REJECT) {
358 cfg->fc_scope = RT_SCOPE_HOST;
359 cfg->fc_type = RTN_UNREACHABLE;
363 cfg->fc_scope = RT_SCOPE_NOWHERE;
364 cfg->fc_type = RTN_UNICAST;
368 struct net_device *dev;
369 char devname[IFNAMSIZ];
371 if (copy_from_user(devname, rt->rt_dev, IFNAMSIZ-1))
374 devname[IFNAMSIZ-1] = 0;
375 colon = strchr(devname, ':');
378 dev = __dev_get_by_name(&init_net, devname);
381 cfg->fc_oif = dev->ifindex;
383 struct in_ifaddr *ifa;
384 struct in_device *in_dev = __in_dev_get_rtnl(dev);
388 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next)
389 if (strcmp(ifa->ifa_label, devname) == 0)
393 cfg->fc_prefsrc = ifa->ifa_local;
397 addr = sk_extract_addr(&rt->rt_gateway);
398 if (rt->rt_gateway.sa_family == AF_INET && addr) {
400 if (rt->rt_flags & RTF_GATEWAY &&
401 inet_addr_type(&init_net, addr) == RTN_UNICAST)
402 cfg->fc_scope = RT_SCOPE_UNIVERSE;
405 if (cmd == SIOCDELRT)
408 if (rt->rt_flags & RTF_GATEWAY && !cfg->fc_gw)
411 if (cfg->fc_scope == RT_SCOPE_NOWHERE)
412 cfg->fc_scope = RT_SCOPE_LINK;
414 if (rt->rt_flags & (RTF_MTU | RTF_WINDOW | RTF_IRTT)) {
418 mx = kzalloc(3 * nla_total_size(4), GFP_KERNEL);
422 if (rt->rt_flags & RTF_MTU)
423 len = put_rtax(mx, len, RTAX_ADVMSS, rt->rt_mtu - 40);
425 if (rt->rt_flags & RTF_WINDOW)
426 len = put_rtax(mx, len, RTAX_WINDOW, rt->rt_window);
428 if (rt->rt_flags & RTF_IRTT)
429 len = put_rtax(mx, len, RTAX_RTT, rt->rt_irtt << 3);
432 cfg->fc_mx_len = len;
439 * Handle IP routing ioctl calls. These are used to manipulate the routing tables
442 int ip_rt_ioctl(unsigned int cmd, void __user *arg)
444 struct fib_config cfg;
449 case SIOCADDRT: /* Add a route */
450 case SIOCDELRT: /* Delete a route */
451 if (!capable(CAP_NET_ADMIN))
454 if (copy_from_user(&rt, arg, sizeof(rt)))
458 err = rtentry_to_fib_config(cmd, &rt, &cfg);
460 struct fib_table *tb;
462 if (cmd == SIOCDELRT) {
463 tb = fib_get_table(&init_net, cfg.fc_table);
465 err = tb->tb_delete(tb, &cfg);
469 tb = fib_new_table(&init_net, cfg.fc_table);
471 err = tb->tb_insert(tb, &cfg);
476 /* allocated by rtentry_to_fib_config() */
485 const struct nla_policy rtm_ipv4_policy[RTA_MAX+1] = {
486 [RTA_DST] = { .type = NLA_U32 },
487 [RTA_SRC] = { .type = NLA_U32 },
488 [RTA_IIF] = { .type = NLA_U32 },
489 [RTA_OIF] = { .type = NLA_U32 },
490 [RTA_GATEWAY] = { .type = NLA_U32 },
491 [RTA_PRIORITY] = { .type = NLA_U32 },
492 [RTA_PREFSRC] = { .type = NLA_U32 },
493 [RTA_METRICS] = { .type = NLA_NESTED },
494 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
495 [RTA_PROTOINFO] = { .type = NLA_U32 },
496 [RTA_FLOW] = { .type = NLA_U32 },
499 static int rtm_to_fib_config(struct sk_buff *skb, struct nlmsghdr *nlh,
500 struct fib_config *cfg)
506 err = nlmsg_validate(nlh, sizeof(*rtm), RTA_MAX, rtm_ipv4_policy);
510 memset(cfg, 0, sizeof(*cfg));
512 rtm = nlmsg_data(nlh);
513 cfg->fc_dst_len = rtm->rtm_dst_len;
514 cfg->fc_tos = rtm->rtm_tos;
515 cfg->fc_table = rtm->rtm_table;
516 cfg->fc_protocol = rtm->rtm_protocol;
517 cfg->fc_scope = rtm->rtm_scope;
518 cfg->fc_type = rtm->rtm_type;
519 cfg->fc_flags = rtm->rtm_flags;
520 cfg->fc_nlflags = nlh->nlmsg_flags;
522 cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
523 cfg->fc_nlinfo.nlh = nlh;
524 cfg->fc_nlinfo.nl_net = &init_net;
526 if (cfg->fc_type > RTN_MAX) {
531 nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), remaining) {
532 switch (nla_type(attr)) {
534 cfg->fc_dst = nla_get_be32(attr);
537 cfg->fc_oif = nla_get_u32(attr);
540 cfg->fc_gw = nla_get_be32(attr);
543 cfg->fc_priority = nla_get_u32(attr);
546 cfg->fc_prefsrc = nla_get_be32(attr);
549 cfg->fc_mx = nla_data(attr);
550 cfg->fc_mx_len = nla_len(attr);
553 cfg->fc_mp = nla_data(attr);
554 cfg->fc_mp_len = nla_len(attr);
557 cfg->fc_flow = nla_get_u32(attr);
560 cfg->fc_table = nla_get_u32(attr);
570 static int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
572 struct net *net = skb->sk->sk_net;
573 struct fib_config cfg;
574 struct fib_table *tb;
577 if (net != &init_net)
580 err = rtm_to_fib_config(skb, nlh, &cfg);
584 tb = fib_get_table(net, cfg.fc_table);
590 err = tb->tb_delete(tb, &cfg);
595 static int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
597 struct net *net = skb->sk->sk_net;
598 struct fib_config cfg;
599 struct fib_table *tb;
602 if (net != &init_net)
605 err = rtm_to_fib_config(skb, nlh, &cfg);
609 tb = fib_new_table(&init_net, cfg.fc_table);
615 err = tb->tb_insert(tb, &cfg);
620 static int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
622 struct net *net = skb->sk->sk_net;
624 unsigned int e = 0, s_e;
625 struct fib_table *tb;
626 struct hlist_node *node;
627 struct hlist_head *head;
630 if (net != &init_net)
633 if (nlmsg_len(cb->nlh) >= sizeof(struct rtmsg) &&
634 ((struct rtmsg *) nlmsg_data(cb->nlh))->rtm_flags & RTM_F_CLONED)
635 return ip_rt_dump(skb, cb);
640 for (h = s_h; h < FIB_TABLE_HASHSZ; h++, s_e = 0) {
642 head = &net->ipv4.fib_table_hash[h];
643 hlist_for_each_entry(tb, node, head, tb_hlist) {
647 memset(&cb->args[2], 0, sizeof(cb->args) -
648 2 * sizeof(cb->args[0]));
649 if (tb->tb_dump(tb, skb, cb) < 0)
663 /* Prepare and feed intra-kernel routing request.
664 Really, it should be netlink message, but :-( netlink
665 can be not configured, so that we feed it directly
666 to fib engine. It is legal, because all events occur
667 only when netlink is already locked.
670 static void fib_magic(int cmd, int type, __be32 dst, int dst_len, struct in_ifaddr *ifa)
672 struct fib_table *tb;
673 struct fib_config cfg = {
674 .fc_protocol = RTPROT_KERNEL,
677 .fc_dst_len = dst_len,
678 .fc_prefsrc = ifa->ifa_local,
679 .fc_oif = ifa->ifa_dev->dev->ifindex,
680 .fc_nlflags = NLM_F_CREATE | NLM_F_APPEND,
686 if (type == RTN_UNICAST)
687 tb = fib_new_table(&init_net, RT_TABLE_MAIN);
689 tb = fib_new_table(&init_net, RT_TABLE_LOCAL);
694 cfg.fc_table = tb->tb_id;
696 if (type != RTN_LOCAL)
697 cfg.fc_scope = RT_SCOPE_LINK;
699 cfg.fc_scope = RT_SCOPE_HOST;
701 if (cmd == RTM_NEWROUTE)
702 tb->tb_insert(tb, &cfg);
704 tb->tb_delete(tb, &cfg);
707 void fib_add_ifaddr(struct in_ifaddr *ifa)
709 struct in_device *in_dev = ifa->ifa_dev;
710 struct net_device *dev = in_dev->dev;
711 struct in_ifaddr *prim = ifa;
712 __be32 mask = ifa->ifa_mask;
713 __be32 addr = ifa->ifa_local;
714 __be32 prefix = ifa->ifa_address&mask;
716 if (ifa->ifa_flags&IFA_F_SECONDARY) {
717 prim = inet_ifa_byprefix(in_dev, prefix, mask);
719 printk(KERN_DEBUG "fib_add_ifaddr: bug: prim == NULL\n");
724 fib_magic(RTM_NEWROUTE, RTN_LOCAL, addr, 32, prim);
726 if (!(dev->flags&IFF_UP))
729 /* Add broadcast address, if it is explicitly assigned. */
730 if (ifa->ifa_broadcast && ifa->ifa_broadcast != htonl(0xFFFFFFFF))
731 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
733 if (!ipv4_is_zeronet(prefix) && !(ifa->ifa_flags&IFA_F_SECONDARY) &&
734 (prefix != addr || ifa->ifa_prefixlen < 32)) {
735 fib_magic(RTM_NEWROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
736 RTN_UNICAST, prefix, ifa->ifa_prefixlen, prim);
738 /* Add network specific broadcasts, when it takes a sense */
739 if (ifa->ifa_prefixlen < 31) {
740 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix, 32, prim);
741 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix|~mask, 32, prim);
746 static void fib_del_ifaddr(struct in_ifaddr *ifa)
748 struct in_device *in_dev = ifa->ifa_dev;
749 struct net_device *dev = in_dev->dev;
750 struct in_ifaddr *ifa1;
751 struct in_ifaddr *prim = ifa;
752 __be32 brd = ifa->ifa_address|~ifa->ifa_mask;
753 __be32 any = ifa->ifa_address&ifa->ifa_mask;
760 if (!(ifa->ifa_flags&IFA_F_SECONDARY))
761 fib_magic(RTM_DELROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
762 RTN_UNICAST, any, ifa->ifa_prefixlen, prim);
764 prim = inet_ifa_byprefix(in_dev, any, ifa->ifa_mask);
766 printk(KERN_DEBUG "fib_del_ifaddr: bug: prim == NULL\n");
771 /* Deletion is more complicated than add.
772 We should take care of not to delete too much :-)
774 Scan address list to be sure that addresses are really gone.
777 for (ifa1 = in_dev->ifa_list; ifa1; ifa1 = ifa1->ifa_next) {
778 if (ifa->ifa_local == ifa1->ifa_local)
780 if (ifa->ifa_broadcast == ifa1->ifa_broadcast)
782 if (brd == ifa1->ifa_broadcast)
784 if (any == ifa1->ifa_broadcast)
789 fib_magic(RTM_DELROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
791 fib_magic(RTM_DELROUTE, RTN_BROADCAST, brd, 32, prim);
793 fib_magic(RTM_DELROUTE, RTN_BROADCAST, any, 32, prim);
794 if (!(ok&LOCAL_OK)) {
795 fib_magic(RTM_DELROUTE, RTN_LOCAL, ifa->ifa_local, 32, prim);
797 /* Check, that this local address finally disappeared. */
798 if (inet_addr_type(&init_net, ifa->ifa_local) != RTN_LOCAL) {
799 /* And the last, but not the least thing.
800 We must flush stray FIB entries.
802 First of all, we scan fib_info list searching
803 for stray nexthop entries, then ignite fib_flush.
805 if (fib_sync_down(ifa->ifa_local, NULL, 0))
806 fib_flush(&init_net);
815 static void nl_fib_lookup(struct fib_result_nl *frn, struct fib_table *tb )
818 struct fib_result res;
819 struct flowi fl = { .mark = frn->fl_mark,
820 .nl_u = { .ip4_u = { .daddr = frn->fl_addr,
822 .scope = frn->fl_scope } } };
824 #ifdef CONFIG_IP_MULTIPLE_TABLES
832 frn->tb_id = tb->tb_id;
833 frn->err = tb->tb_lookup(tb, &fl, &res);
836 frn->prefixlen = res.prefixlen;
837 frn->nh_sel = res.nh_sel;
838 frn->type = res.type;
839 frn->scope = res.scope;
846 static void nl_fib_input(struct sk_buff *skb)
848 struct fib_result_nl *frn;
849 struct nlmsghdr *nlh;
850 struct fib_table *tb;
853 nlh = nlmsg_hdr(skb);
854 if (skb->len < NLMSG_SPACE(0) || skb->len < nlh->nlmsg_len ||
855 nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*frn)))
858 skb = skb_clone(skb, GFP_KERNEL);
861 nlh = nlmsg_hdr(skb);
863 frn = (struct fib_result_nl *) NLMSG_DATA(nlh);
864 tb = fib_get_table(&init_net, frn->tb_id_in);
866 nl_fib_lookup(frn, tb);
868 pid = NETLINK_CB(skb).pid; /* pid of sending process */
869 NETLINK_CB(skb).pid = 0; /* from kernel */
870 NETLINK_CB(skb).dst_group = 0; /* unicast */
871 netlink_unicast(fibnl, skb, pid, MSG_DONTWAIT);
874 static int nl_fib_lookup_init(struct net *net)
876 fibnl = netlink_kernel_create(net, NETLINK_FIB_LOOKUP, 0,
877 nl_fib_input, NULL, THIS_MODULE);
879 return -EAFNOSUPPORT;
883 static void nl_fib_lookup_exit(struct net *net)
888 static void fib_disable_ip(struct net_device *dev, int force)
890 if (fib_sync_down(0, dev, force))
891 fib_flush(&init_net);
896 static int fib_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
898 struct in_ifaddr *ifa = (struct in_ifaddr*)ptr;
903 #ifdef CONFIG_IP_ROUTE_MULTIPATH
904 fib_sync_up(ifa->ifa_dev->dev);
910 if (ifa->ifa_dev->ifa_list == NULL) {
911 /* Last address was deleted from this interface.
914 fib_disable_ip(ifa->ifa_dev->dev, 1);
923 static int fib_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
925 struct net_device *dev = ptr;
926 struct in_device *in_dev = __in_dev_get_rtnl(dev);
928 if (dev->nd_net != &init_net)
931 if (event == NETDEV_UNREGISTER) {
932 fib_disable_ip(dev, 2);
943 } endfor_ifa(in_dev);
944 #ifdef CONFIG_IP_ROUTE_MULTIPATH
950 fib_disable_ip(dev, 0);
952 case NETDEV_CHANGEMTU:
960 static struct notifier_block fib_inetaddr_notifier = {
961 .notifier_call =fib_inetaddr_event,
964 static struct notifier_block fib_netdev_notifier = {
965 .notifier_call =fib_netdev_event,
968 static int __net_init ip_fib_net_init(struct net *net)
972 net->ipv4.fib_table_hash = kzalloc(
973 sizeof(struct hlist_head)*FIB_TABLE_HASHSZ, GFP_KERNEL);
974 if (net->ipv4.fib_table_hash == NULL)
977 for (i = 0; i < FIB_TABLE_HASHSZ; i++)
978 INIT_HLIST_HEAD(&net->ipv4.fib_table_hash[i]);
980 return fib4_rules_init(net);
983 static void __net_exit ip_fib_net_exit(struct net *net)
987 #ifdef CONFIG_IP_MULTIPLE_TABLES
988 fib4_rules_exit(net);
991 for (i = 0; i < FIB_TABLE_HASHSZ; i++) {
992 struct fib_table *tb;
993 struct hlist_head *head;
994 struct hlist_node *node, *tmp;
996 head = &net->ipv4.fib_table_hash[i];
997 hlist_for_each_entry_safe(tb, node, tmp, head, tb_hlist) {
1003 kfree(net->ipv4.fib_table_hash);
1006 static int __net_init fib_net_init(struct net *net)
1011 if (net != &init_net)
1014 error = ip_fib_net_init(net);
1017 error = nl_fib_lookup_init(net);
1020 error = fib_proc_init(net);
1027 nl_fib_lookup_exit(net);
1029 ip_fib_net_exit(net);
1033 static void __net_exit fib_net_exit(struct net *net)
1036 nl_fib_lookup_exit(net);
1037 ip_fib_net_exit(net);
1040 static struct pernet_operations fib_net_ops = {
1041 .init = fib_net_init,
1042 .exit = fib_net_exit,
1045 void __init ip_fib_init(void)
1047 rtnl_register(PF_INET, RTM_NEWROUTE, inet_rtm_newroute, NULL);
1048 rtnl_register(PF_INET, RTM_DELROUTE, inet_rtm_delroute, NULL);
1049 rtnl_register(PF_INET, RTM_GETROUTE, NULL, inet_dump_fib);
1051 register_pernet_subsys(&fib_net_ops);
1052 register_netdevice_notifier(&fib_netdev_notifier);
1053 register_inetaddr_notifier(&fib_inetaddr_notifier);
1056 EXPORT_SYMBOL(inet_addr_type);
1057 EXPORT_SYMBOL(inet_dev_addr_type);
1058 EXPORT_SYMBOL(ip_dev_find);