1 /* 2 * Linux INET6 implementation 3 * Forwarding Information Database 4 * 5 * Authors: 6 * Pedro Roque <roque@di.fc.ul.pt> 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License 10 * as published by the Free Software Foundation; either version 11 * 2 of the License, or (at your option) any later version. 12 */ 13 14 /* 15 * Changes: 16 * Yuji SEKIYA @USAGI: Support default route on router node; 17 * remove ip6_null_entry from the top of 18 * routing table. 19 * Ville Nuorvala: Fixed routing subtrees. 20 */ 21 #include <linux/errno.h> 22 #include <linux/types.h> 23 #include <linux/net.h> 24 #include <linux/route.h> 25 #include <linux/netdevice.h> 26 #include <linux/in6.h> 27 #include <linux/init.h> 28 #include <linux/list.h> 29 30 #ifdef CONFIG_PROC_FS 31 #include <linux/proc_fs.h> 32 #endif 33 34 #include <net/ipv6.h> 35 #include <net/ndisc.h> 36 #include <net/addrconf.h> 37 38 #include <net/ip6_fib.h> 39 #include <net/ip6_route.h> 40 41 #define RT6_DEBUG 2 42 43 #if RT6_DEBUG >= 3 44 #define RT6_TRACE(x...) printk(KERN_DEBUG x) 45 #else 46 #define RT6_TRACE(x...) do { ; } while (0) 47 #endif 48 49 static struct kmem_cache * fib6_node_kmem __read_mostly; 50 51 enum fib_walk_state_t 52 { 53 #ifdef CONFIG_IPV6_SUBTREES 54 FWS_S, 55 #endif 56 FWS_L, 57 FWS_R, 58 FWS_C, 59 FWS_U 60 }; 61 62 struct fib6_cleaner_t 63 { 64 struct fib6_walker_t w; 65 struct net *net; 66 int (*func)(struct rt6_info *, void *arg); 67 void *arg; 68 }; 69 70 static DEFINE_RWLOCK(fib6_walker_lock); 71 72 #ifdef CONFIG_IPV6_SUBTREES 73 #define FWS_INIT FWS_S 74 #else 75 #define FWS_INIT FWS_L 76 #endif 77 78 static void fib6_prune_clones(struct net *net, struct fib6_node *fn, 79 struct rt6_info *rt); 80 static struct rt6_info *fib6_find_prefix(struct net *net, struct fib6_node *fn); 81 static struct fib6_node *fib6_repair_tree(struct net *net, struct fib6_node *fn); 82 static int fib6_walk(struct fib6_walker_t *w); 83 static int fib6_walk_continue(struct fib6_walker_t *w); 84 85 /* 86 * A routing update causes an increase of the serial number on the 87 * affected subtree. This allows for cached routes to be asynchronously 88 * tested when modifications are made to the destination cache as a 89 * result of redirects, path MTU changes, etc. 90 */ 91 92 static __u32 rt_sernum; 93 94 static void fib6_gc_timer_cb(unsigned long arg); 95 96 static struct fib6_walker_t fib6_walker_list = { 97 .prev = &fib6_walker_list, 98 .next = &fib6_walker_list, 99 }; 100 101 #define FOR_WALKERS(w) for ((w)=fib6_walker_list.next; (w) != &fib6_walker_list; (w)=(w)->next) 102 103 static inline void fib6_walker_link(struct fib6_walker_t *w) 104 { 105 write_lock_bh(&fib6_walker_lock); 106 w->next = fib6_walker_list.next; 107 w->prev = &fib6_walker_list; 108 w->next->prev = w; 109 w->prev->next = w; 110 write_unlock_bh(&fib6_walker_lock); 111 } 112 113 static inline void fib6_walker_unlink(struct fib6_walker_t *w) 114 { 115 write_lock_bh(&fib6_walker_lock); 116 w->next->prev = w->prev; 117 w->prev->next = w->next; 118 w->prev = w->next = w; 119 write_unlock_bh(&fib6_walker_lock); 120 } 121 static __inline__ u32 fib6_new_sernum(void) 122 { 123 u32 n = ++rt_sernum; 124 if ((__s32)n <= 0) 125 rt_sernum = n = 1; 126 return n; 127 } 128 129 /* 130 * Auxiliary address test functions for the radix tree. 131 * 132 * These assume a 32bit processor (although it will work on 133 * 64bit processors) 134 */ 135 136 /* 137 * test bit 138 */ 139 140 static __inline__ __be32 addr_bit_set(void *token, int fn_bit) 141 { 142 __be32 *addr = token; 143 144 return htonl(1 << ((~fn_bit)&0x1F)) & addr[fn_bit>>5]; 145 } 146 147 static __inline__ struct fib6_node * node_alloc(void) 148 { 149 struct fib6_node *fn; 150 151 fn = kmem_cache_zalloc(fib6_node_kmem, GFP_ATOMIC); 152 153 return fn; 154 } 155 156 static __inline__ void node_free(struct fib6_node * fn) 157 { 158 kmem_cache_free(fib6_node_kmem, fn); 159 } 160 161 static __inline__ void rt6_release(struct rt6_info *rt) 162 { 163 if (atomic_dec_and_test(&rt->rt6i_ref)) 164 dst_free(&rt->u.dst); 165 } 166 167 #ifdef CONFIG_IPV6_MULTIPLE_TABLES 168 #define FIB_TABLE_HASHSZ 256 169 #else 170 #define FIB_TABLE_HASHSZ 1 171 #endif 172 173 static void fib6_link_table(struct net *net, struct fib6_table *tb) 174 { 175 unsigned int h; 176 177 /* 178 * Initialize table lock at a single place to give lockdep a key, 179 * tables aren't visible prior to being linked to the list. 180 */ 181 rwlock_init(&tb->tb6_lock); 182 183 h = tb->tb6_id & (FIB_TABLE_HASHSZ - 1); 184 185 /* 186 * No protection necessary, this is the only list mutatation 187 * operation, tables never disappear once they exist. 188 */ 189 hlist_add_head_rcu(&tb->tb6_hlist, &net->ipv6.fib_table_hash[h]); 190 } 191 192 #ifdef CONFIG_IPV6_MULTIPLE_TABLES 193 194 static struct fib6_table *fib6_alloc_table(struct net *net, u32 id) 195 { 196 struct fib6_table *table; 197 198 table = kzalloc(sizeof(*table), GFP_ATOMIC); 199 if (table != NULL) { 200 table->tb6_id = id; 201 table->tb6_root.leaf = net->ipv6.ip6_null_entry; 202 table->tb6_root.fn_flags = RTN_ROOT | RTN_TL_ROOT | RTN_RTINFO; 203 } 204 205 return table; 206 } 207 208 struct fib6_table *fib6_new_table(struct net *net, u32 id) 209 { 210 struct fib6_table *tb; 211 212 if (id == 0) 213 id = RT6_TABLE_MAIN; 214 tb = fib6_get_table(net, id); 215 if (tb) 216 return tb; 217 218 tb = fib6_alloc_table(net, id); 219 if (tb != NULL) 220 fib6_link_table(net, tb); 221 222 return tb; 223 } 224 225 struct fib6_table *fib6_get_table(struct net *net, u32 id) 226 { 227 struct fib6_table *tb; 228 struct hlist_head *head; 229 struct hlist_node *node; 230 unsigned int h; 231 232 if (id == 0) 233 id = RT6_TABLE_MAIN; 234 h = id & (FIB_TABLE_HASHSZ - 1); 235 rcu_read_lock(); 236 head = &net->ipv6.fib_table_hash[h]; 237 hlist_for_each_entry_rcu(tb, node, head, tb6_hlist) { 238 if (tb->tb6_id == id) { 239 rcu_read_unlock(); 240 return tb; 241 } 242 } 243 rcu_read_unlock(); 244 245 return NULL; 246 } 247 248 static void fib6_tables_init(struct net *net) 249 { 250 fib6_link_table(net, net->ipv6.fib6_main_tbl); 251 fib6_link_table(net, net->ipv6.fib6_local_tbl); 252 } 253 #else 254 255 struct fib6_table *fib6_new_table(struct net *net, u32 id) 256 { 257 return fib6_get_table(net, id); 258 } 259 260 struct fib6_table *fib6_get_table(struct net *net, u32 id) 261 { 262 return net->ipv6.fib6_main_tbl; 263 } 264 265 struct dst_entry *fib6_rule_lookup(struct net *net, struct flowi *fl, 266 int flags, pol_lookup_t lookup) 267 { 268 return (struct dst_entry *) lookup(net, net->ipv6.fib6_main_tbl, fl, flags); 269 } 270 271 static void fib6_tables_init(struct net *net) 272 { 273 fib6_link_table(net, net->ipv6.fib6_main_tbl); 274 } 275 276 #endif 277 278 static int fib6_dump_node(struct fib6_walker_t *w) 279 { 280 int res; 281 struct rt6_info *rt; 282 283 for (rt = w->leaf; rt; rt = rt->u.dst.rt6_next) { 284 res = rt6_dump_route(rt, w->args); 285 if (res < 0) { 286 /* Frame is full, suspend walking */ 287 w->leaf = rt; 288 return 1; 289 } 290 WARN_ON(res == 0); 291 } 292 w->leaf = NULL; 293 return 0; 294 } 295 296 static void fib6_dump_end(struct netlink_callback *cb) 297 { 298 struct fib6_walker_t *w = (void*)cb->args[2]; 299 300 if (w) { 301 cb->args[2] = 0; 302 kfree(w); 303 } 304 cb->done = (void*)cb->args[3]; 305 cb->args[1] = 3; 306 } 307 308 static int fib6_dump_done(struct netlink_callback *cb) 309 { 310 fib6_dump_end(cb); 311 return cb->done ? cb->done(cb) : 0; 312 } 313 314 static int fib6_dump_table(struct fib6_table *table, struct sk_buff *skb, 315 struct netlink_callback *cb) 316 { 317 struct fib6_walker_t *w; 318 int res; 319 320 w = (void *)cb->args[2]; 321 w->root = &table->tb6_root; 322 323 if (cb->args[4] == 0) { 324 read_lock_bh(&table->tb6_lock); 325 res = fib6_walk(w); 326 read_unlock_bh(&table->tb6_lock); 327 if (res > 0) 328 cb->args[4] = 1; 329 } else { 330 read_lock_bh(&table->tb6_lock); 331 res = fib6_walk_continue(w); 332 read_unlock_bh(&table->tb6_lock); 333 if (res != 0) { 334 if (res < 0) 335 fib6_walker_unlink(w); 336 goto end; 337 } 338 fib6_walker_unlink(w); 339 cb->args[4] = 0; 340 } 341 end: 342 return res; 343 } 344 345 static int inet6_dump_fib(struct sk_buff *skb, struct netlink_callback *cb) 346 { 347 struct net *net = sock_net(skb->sk); 348 unsigned int h, s_h; 349 unsigned int e = 0, s_e; 350 struct rt6_rtnl_dump_arg arg; 351 struct fib6_walker_t *w; 352 struct fib6_table *tb; 353 struct hlist_node *node; 354 struct hlist_head *head; 355 int res = 0; 356 357 s_h = cb->args[0]; 358 s_e = cb->args[1]; 359 360 w = (void *)cb->args[2]; 361 if (w == NULL) { 362 /* New dump: 363 * 364 * 1. hook callback destructor. 365 */ 366 cb->args[3] = (long)cb->done; 367 cb->done = fib6_dump_done; 368 369 /* 370 * 2. allocate and initialize walker. 371 */ 372 w = kzalloc(sizeof(*w), GFP_ATOMIC); 373 if (w == NULL) 374 return -ENOMEM; 375 w->func = fib6_dump_node; 376 cb->args[2] = (long)w; 377 } 378 379 arg.skb = skb; 380 arg.cb = cb; 381 arg.net = net; 382 w->args = &arg; 383 384 for (h = s_h; h < FIB_TABLE_HASHSZ; h++, s_e = 0) { 385 e = 0; 386 head = &net->ipv6.fib_table_hash[h]; 387 hlist_for_each_entry(tb, node, head, tb6_hlist) { 388 if (e < s_e) 389 goto next; 390 res = fib6_dump_table(tb, skb, cb); 391 if (res != 0) 392 goto out; 393 next: 394 e++; 395 } 396 } 397 out: 398 cb->args[1] = e; 399 cb->args[0] = h; 400 401 res = res < 0 ? res : skb->len; 402 if (res <= 0) 403 fib6_dump_end(cb); 404 return res; 405 } 406 407 /* 408 * Routing Table 409 * 410 * return the appropriate node for a routing tree "add" operation 411 * by either creating and inserting or by returning an existing 412 * node. 413 */ 414 415 static struct fib6_node * fib6_add_1(struct fib6_node *root, void *addr, 416 int addrlen, int plen, 417 int offset) 418 { 419 struct fib6_node *fn, *in, *ln; 420 struct fib6_node *pn = NULL; 421 struct rt6key *key; 422 int bit; 423 __be32 dir = 0; 424 __u32 sernum = fib6_new_sernum(); 425 426 RT6_TRACE("fib6_add_1\n"); 427 428 /* insert node in tree */ 429 430 fn = root; 431 432 do { 433 key = (struct rt6key *)((u8 *)fn->leaf + offset); 434 435 /* 436 * Prefix match 437 */ 438 if (plen < fn->fn_bit || 439 !ipv6_prefix_equal(&key->addr, addr, fn->fn_bit)) 440 goto insert_above; 441 442 /* 443 * Exact match ? 444 */ 445 446 if (plen == fn->fn_bit) { 447 /* clean up an intermediate node */ 448 if ((fn->fn_flags & RTN_RTINFO) == 0) { 449 rt6_release(fn->leaf); 450 fn->leaf = NULL; 451 } 452 453 fn->fn_sernum = sernum; 454 455 return fn; 456 } 457 458 /* 459 * We have more bits to go 460 */ 461 462 /* Try to walk down on tree. */ 463 fn->fn_sernum = sernum; 464 dir = addr_bit_set(addr, fn->fn_bit); 465 pn = fn; 466 fn = dir ? fn->right: fn->left; 467 } while (fn); 468 469 /* 470 * We walked to the bottom of tree. 471 * Create new leaf node without children. 472 */ 473 474 ln = node_alloc(); 475 476 if (ln == NULL) 477 return NULL; 478 ln->fn_bit = plen; 479 480 ln->parent = pn; 481 ln->fn_sernum = sernum; 482 483 if (dir) 484 pn->right = ln; 485 else 486 pn->left = ln; 487 488 return ln; 489 490 491 insert_above: 492 /* 493 * split since we don't have a common prefix anymore or 494 * we have a less significant route. 495 * we've to insert an intermediate node on the list 496 * this new node will point to the one we need to create 497 * and the current 498 */ 499 500 pn = fn->parent; 501 502 /* find 1st bit in difference between the 2 addrs. 503 504 See comment in __ipv6_addr_diff: bit may be an invalid value, 505 but if it is >= plen, the value is ignored in any case. 506 */ 507 508 bit = __ipv6_addr_diff(addr, &key->addr, addrlen); 509 510 /* 511 * (intermediate)[in] 512 * / \ 513 * (new leaf node)[ln] (old node)[fn] 514 */ 515 if (plen > bit) { 516 in = node_alloc(); 517 ln = node_alloc(); 518 519 if (in == NULL || ln == NULL) { 520 if (in) 521 node_free(in); 522 if (ln) 523 node_free(ln); 524 return NULL; 525 } 526 527 /* 528 * new intermediate node. 529 * RTN_RTINFO will 530 * be off since that an address that chooses one of 531 * the branches would not match less specific routes 532 * in the other branch 533 */ 534 535 in->fn_bit = bit; 536 537 in->parent = pn; 538 in->leaf = fn->leaf; 539 atomic_inc(&in->leaf->rt6i_ref); 540 541 in->fn_sernum = sernum; 542 543 /* update parent pointer */ 544 if (dir) 545 pn->right = in; 546 else 547 pn->left = in; 548 549 ln->fn_bit = plen; 550 551 ln->parent = in; 552 fn->parent = in; 553 554 ln->fn_sernum = sernum; 555 556 if (addr_bit_set(addr, bit)) { 557 in->right = ln; 558 in->left = fn; 559 } else { 560 in->left = ln; 561 in->right = fn; 562 } 563 } else { /* plen <= bit */ 564 565 /* 566 * (new leaf node)[ln] 567 * / \ 568 * (old node)[fn] NULL 569 */ 570 571 ln = node_alloc(); 572 573 if (ln == NULL) 574 return NULL; 575 576 ln->fn_bit = plen; 577 578 ln->parent = pn; 579 580 ln->fn_sernum = sernum; 581 582 if (dir) 583 pn->right = ln; 584 else 585 pn->left = ln; 586 587 if (addr_bit_set(&key->addr, plen)) 588 ln->right = fn; 589 else 590 ln->left = fn; 591 592 fn->parent = ln; 593 } 594 return ln; 595 } 596 597 /* 598 * Insert routing information in a node. 599 */ 600 601 static int fib6_add_rt2node(struct fib6_node *fn, struct rt6_info *rt, 602 struct nl_info *info) 603 { 604 struct rt6_info *iter = NULL; 605 struct rt6_info **ins; 606 607 ins = &fn->leaf; 608 609 for (iter = fn->leaf; iter; iter=iter->u.dst.rt6_next) { 610 /* 611 * Search for duplicates 612 */ 613 614 if (iter->rt6i_metric == rt->rt6i_metric) { 615 /* 616 * Same priority level 617 */ 618 619 if (iter->rt6i_dev == rt->rt6i_dev && 620 iter->rt6i_idev == rt->rt6i_idev && 621 ipv6_addr_equal(&iter->rt6i_gateway, 622 &rt->rt6i_gateway)) { 623 if (!(iter->rt6i_flags&RTF_EXPIRES)) 624 return -EEXIST; 625 iter->rt6i_expires = rt->rt6i_expires; 626 if (!(rt->rt6i_flags&RTF_EXPIRES)) { 627 iter->rt6i_flags &= ~RTF_EXPIRES; 628 iter->rt6i_expires = 0; 629 } 630 return -EEXIST; 631 } 632 } 633 634 if (iter->rt6i_metric > rt->rt6i_metric) 635 break; 636 637 ins = &iter->u.dst.rt6_next; 638 } 639 640 /* Reset round-robin state, if necessary */ 641 if (ins == &fn->leaf) 642 fn->rr_ptr = NULL; 643 644 /* 645 * insert node 646 */ 647 648 rt->u.dst.rt6_next = iter; 649 *ins = rt; 650 rt->rt6i_node = fn; 651 atomic_inc(&rt->rt6i_ref); 652 inet6_rt_notify(RTM_NEWROUTE, rt, info); 653 info->nl_net->ipv6.rt6_stats->fib_rt_entries++; 654 655 if ((fn->fn_flags & RTN_RTINFO) == 0) { 656 info->nl_net->ipv6.rt6_stats->fib_route_nodes++; 657 fn->fn_flags |= RTN_RTINFO; 658 } 659 660 return 0; 661 } 662 663 static __inline__ void fib6_start_gc(struct net *net, struct rt6_info *rt) 664 { 665 if (!timer_pending(&net->ipv6.ip6_fib_timer) && 666 (rt->rt6i_flags & (RTF_EXPIRES|RTF_CACHE))) 667 mod_timer(&net->ipv6.ip6_fib_timer, 668 jiffies + net->ipv6.sysctl.ip6_rt_gc_interval); 669 } 670 671 void fib6_force_start_gc(struct net *net) 672 { 673 if (!timer_pending(&net->ipv6.ip6_fib_timer)) 674 mod_timer(&net->ipv6.ip6_fib_timer, 675 jiffies + net->ipv6.sysctl.ip6_rt_gc_interval); 676 } 677 678 /* 679 * Add routing information to the routing tree. 680 * <destination addr>/<source addr> 681 * with source addr info in sub-trees 682 */ 683 684 int fib6_add(struct fib6_node *root, struct rt6_info *rt, struct nl_info *info) 685 { 686 struct fib6_node *fn, *pn = NULL; 687 int err = -ENOMEM; 688 689 fn = fib6_add_1(root, &rt->rt6i_dst.addr, sizeof(struct in6_addr), 690 rt->rt6i_dst.plen, offsetof(struct rt6_info, rt6i_dst)); 691 692 if (fn == NULL) 693 goto out; 694 695 pn = fn; 696 697 #ifdef CONFIG_IPV6_SUBTREES 698 if (rt->rt6i_src.plen) { 699 struct fib6_node *sn; 700 701 if (fn->subtree == NULL) { 702 struct fib6_node *sfn; 703 704 /* 705 * Create subtree. 706 * 707 * fn[main tree] 708 * | 709 * sfn[subtree root] 710 * \ 711 * sn[new leaf node] 712 */ 713 714 /* Create subtree root node */ 715 sfn = node_alloc(); 716 if (sfn == NULL) 717 goto st_failure; 718 719 sfn->leaf = info->nl_net->ipv6.ip6_null_entry; 720 atomic_inc(&info->nl_net->ipv6.ip6_null_entry->rt6i_ref); 721 sfn->fn_flags = RTN_ROOT; 722 sfn->fn_sernum = fib6_new_sernum(); 723 724 /* Now add the first leaf node to new subtree */ 725 726 sn = fib6_add_1(sfn, &rt->rt6i_src.addr, 727 sizeof(struct in6_addr), rt->rt6i_src.plen, 728 offsetof(struct rt6_info, rt6i_src)); 729 730 if (sn == NULL) { 731 /* If it is failed, discard just allocated 732 root, and then (in st_failure) stale node 733 in main tree. 734 */ 735 node_free(sfn); 736 goto st_failure; 737 } 738 739 /* Now link new subtree to main tree */ 740 sfn->parent = fn; 741 fn->subtree = sfn; 742 } else { 743 sn = fib6_add_1(fn->subtree, &rt->rt6i_src.addr, 744 sizeof(struct in6_addr), rt->rt6i_src.plen, 745 offsetof(struct rt6_info, rt6i_src)); 746 747 if (sn == NULL) 748 goto st_failure; 749 } 750 751 if (fn->leaf == NULL) { 752 fn->leaf = rt; 753 atomic_inc(&rt->rt6i_ref); 754 } 755 fn = sn; 756 } 757 #endif 758 759 err = fib6_add_rt2node(fn, rt, info); 760 761 if (err == 0) { 762 fib6_start_gc(info->nl_net, rt); 763 if (!(rt->rt6i_flags&RTF_CACHE)) 764 fib6_prune_clones(info->nl_net, pn, rt); 765 } 766 767 out: 768 if (err) { 769 #ifdef CONFIG_IPV6_SUBTREES 770 /* 771 * If fib6_add_1 has cleared the old leaf pointer in the 772 * super-tree leaf node we have to find a new one for it. 773 */ 774 if (pn != fn && pn->leaf == rt) { 775 pn->leaf = NULL; 776 atomic_dec(&rt->rt6i_ref); 777 } 778 if (pn != fn && !pn->leaf && !(pn->fn_flags & RTN_RTINFO)) { 779 pn->leaf = fib6_find_prefix(info->nl_net, pn); 780 #if RT6_DEBUG >= 2 781 if (!pn->leaf) { 782 WARN_ON(pn->leaf == NULL); 783 pn->leaf = info->nl_net->ipv6.ip6_null_entry; 784 } 785 #endif 786 atomic_inc(&pn->leaf->rt6i_ref); 787 } 788 #endif 789 dst_free(&rt->u.dst); 790 } 791 return err; 792 793 #ifdef CONFIG_IPV6_SUBTREES 794 /* Subtree creation failed, probably main tree node 795 is orphan. If it is, shoot it. 796 */ 797 st_failure: 798 if (fn && !(fn->fn_flags & (RTN_RTINFO|RTN_ROOT))) 799 fib6_repair_tree(info->nl_net, fn); 800 dst_free(&rt->u.dst); 801 return err; 802 #endif 803 } 804 805 /* 806 * Routing tree lookup 807 * 808 */ 809 810 struct lookup_args { 811 int offset; /* key offset on rt6_info */ 812 struct in6_addr *addr; /* search key */ 813 }; 814 815 static struct fib6_node * fib6_lookup_1(struct fib6_node *root, 816 struct lookup_args *args) 817 { 818 struct fib6_node *fn; 819 __be32 dir; 820 821 if (unlikely(args->offset == 0)) 822 return NULL; 823 824 /* 825 * Descend on a tree 826 */ 827 828 fn = root; 829 830 for (;;) { 831 struct fib6_node *next; 832 833 dir = addr_bit_set(args->addr, fn->fn_bit); 834 835 next = dir ? fn->right : fn->left; 836 837 if (next) { 838 fn = next; 839 continue; 840 } 841 842 break; 843 } 844 845 while(fn) { 846 if (FIB6_SUBTREE(fn) || fn->fn_flags & RTN_RTINFO) { 847 struct rt6key *key; 848 849 key = (struct rt6key *) ((u8 *) fn->leaf + 850 args->offset); 851 852 if (ipv6_prefix_equal(&key->addr, args->addr, key->plen)) { 853 #ifdef CONFIG_IPV6_SUBTREES 854 if (fn->subtree) 855 fn = fib6_lookup_1(fn->subtree, args + 1); 856 #endif 857 if (!fn || fn->fn_flags & RTN_RTINFO) 858 return fn; 859 } 860 } 861 862 if (fn->fn_flags & RTN_ROOT) 863 break; 864 865 fn = fn->parent; 866 } 867 868 return NULL; 869 } 870 871 struct fib6_node * fib6_lookup(struct fib6_node *root, struct in6_addr *daddr, 872 struct in6_addr *saddr) 873 { 874 struct fib6_node *fn; 875 struct lookup_args args[] = { 876 { 877 .offset = offsetof(struct rt6_info, rt6i_dst), 878 .addr = daddr, 879 }, 880 #ifdef CONFIG_IPV6_SUBTREES 881 { 882 .offset = offsetof(struct rt6_info, rt6i_src), 883 .addr = saddr, 884 }, 885 #endif 886 { 887 .offset = 0, /* sentinel */ 888 } 889 }; 890 891 fn = fib6_lookup_1(root, daddr ? args : args + 1); 892 893 if (fn == NULL || fn->fn_flags & RTN_TL_ROOT) 894 fn = root; 895 896 return fn; 897 } 898 899 /* 900 * Get node with specified destination prefix (and source prefix, 901 * if subtrees are used) 902 */ 903 904 905 static struct fib6_node * fib6_locate_1(struct fib6_node *root, 906 struct in6_addr *addr, 907 int plen, int offset) 908 { 909 struct fib6_node *fn; 910 911 for (fn = root; fn ; ) { 912 struct rt6key *key = (struct rt6key *)((u8 *)fn->leaf + offset); 913 914 /* 915 * Prefix match 916 */ 917 if (plen < fn->fn_bit || 918 !ipv6_prefix_equal(&key->addr, addr, fn->fn_bit)) 919 return NULL; 920 921 if (plen == fn->fn_bit) 922 return fn; 923 924 /* 925 * We have more bits to go 926 */ 927 if (addr_bit_set(addr, fn->fn_bit)) 928 fn = fn->right; 929 else 930 fn = fn->left; 931 } 932 return NULL; 933 } 934 935 struct fib6_node * fib6_locate(struct fib6_node *root, 936 struct in6_addr *daddr, int dst_len, 937 struct in6_addr *saddr, int src_len) 938 { 939 struct fib6_node *fn; 940 941 fn = fib6_locate_1(root, daddr, dst_len, 942 offsetof(struct rt6_info, rt6i_dst)); 943 944 #ifdef CONFIG_IPV6_SUBTREES 945 if (src_len) { 946 WARN_ON(saddr == NULL); 947 if (fn && fn->subtree) 948 fn = fib6_locate_1(fn->subtree, saddr, src_len, 949 offsetof(struct rt6_info, rt6i_src)); 950 } 951 #endif 952 953 if (fn && fn->fn_flags&RTN_RTINFO) 954 return fn; 955 956 return NULL; 957 } 958 959 960 /* 961 * Deletion 962 * 963 */ 964 965 static struct rt6_info *fib6_find_prefix(struct net *net, struct fib6_node *fn) 966 { 967 if (fn->fn_flags&RTN_ROOT) 968 return net->ipv6.ip6_null_entry; 969 970 while(fn) { 971 if(fn->left) 972 return fn->left->leaf; 973 974 if(fn->right) 975 return fn->right->leaf; 976 977 fn = FIB6_SUBTREE(fn); 978 } 979 return NULL; 980 } 981 982 /* 983 * Called to trim the tree of intermediate nodes when possible. "fn" 984 * is the node we want to try and remove. 985 */ 986 987 static struct fib6_node *fib6_repair_tree(struct net *net, 988 struct fib6_node *fn) 989 { 990 int children; 991 int nstate; 992 struct fib6_node *child, *pn; 993 struct fib6_walker_t *w; 994 int iter = 0; 995 996 for (;;) { 997 RT6_TRACE("fixing tree: plen=%d iter=%d\n", fn->fn_bit, iter); 998 iter++; 999 1000 WARN_ON(fn->fn_flags & RTN_RTINFO); 1001 WARN_ON(fn->fn_flags & RTN_TL_ROOT); 1002 WARN_ON(fn->leaf != NULL); 1003 1004 children = 0; 1005 child = NULL; 1006 if (fn->right) child = fn->right, children |= 1; 1007 if (fn->left) child = fn->left, children |= 2; 1008 1009 if (children == 3 || FIB6_SUBTREE(fn) 1010 #ifdef CONFIG_IPV6_SUBTREES 1011 /* Subtree root (i.e. fn) may have one child */ 1012 || (children && fn->fn_flags&RTN_ROOT) 1013 #endif 1014 ) { 1015 fn->leaf = fib6_find_prefix(net, fn); 1016 #if RT6_DEBUG >= 2 1017 if (fn->leaf==NULL) { 1018 WARN_ON(!fn->leaf); 1019 fn->leaf = net->ipv6.ip6_null_entry; 1020 } 1021 #endif 1022 atomic_inc(&fn->leaf->rt6i_ref); 1023 return fn->parent; 1024 } 1025 1026 pn = fn->parent; 1027 #ifdef CONFIG_IPV6_SUBTREES 1028 if (FIB6_SUBTREE(pn) == fn) { 1029 WARN_ON(!(fn->fn_flags & RTN_ROOT)); 1030 FIB6_SUBTREE(pn) = NULL; 1031 nstate = FWS_L; 1032 } else { 1033 WARN_ON(fn->fn_flags & RTN_ROOT); 1034 #endif 1035 if (pn->right == fn) pn->right = child; 1036 else if (pn->left == fn) pn->left = child; 1037 #if RT6_DEBUG >= 2 1038 else 1039 WARN_ON(1); 1040 #endif 1041 if (child) 1042 child->parent = pn; 1043 nstate = FWS_R; 1044 #ifdef CONFIG_IPV6_SUBTREES 1045 } 1046 #endif 1047 1048 read_lock(&fib6_walker_lock); 1049 FOR_WALKERS(w) { 1050 if (child == NULL) { 1051 if (w->root == fn) { 1052 w->root = w->node = NULL; 1053 RT6_TRACE("W %p adjusted by delroot 1\n", w); 1054 } else if (w->node == fn) { 1055 RT6_TRACE("W %p adjusted by delnode 1, s=%d/%d\n", w, w->state, nstate); 1056 w->node = pn; 1057 w->state = nstate; 1058 } 1059 } else { 1060 if (w->root == fn) { 1061 w->root = child; 1062 RT6_TRACE("W %p adjusted by delroot 2\n", w); 1063 } 1064 if (w->node == fn) { 1065 w->node = child; 1066 if (children&2) { 1067 RT6_TRACE("W %p adjusted by delnode 2, s=%d\n", w, w->state); 1068 w->state = w->state>=FWS_R ? FWS_U : FWS_INIT; 1069 } else { 1070 RT6_TRACE("W %p adjusted by delnode 2, s=%d\n", w, w->state); 1071 w->state = w->state>=FWS_C ? FWS_U : FWS_INIT; 1072 } 1073 } 1074 } 1075 } 1076 read_unlock(&fib6_walker_lock); 1077 1078 node_free(fn); 1079 if (pn->fn_flags&RTN_RTINFO || FIB6_SUBTREE(pn)) 1080 return pn; 1081 1082 rt6_release(pn->leaf); 1083 pn->leaf = NULL; 1084 fn = pn; 1085 } 1086 } 1087 1088 static void fib6_del_route(struct fib6_node *fn, struct rt6_info **rtp, 1089 struct nl_info *info) 1090 { 1091 struct fib6_walker_t *w; 1092 struct rt6_info *rt = *rtp; 1093 struct net *net = info->nl_net; 1094 1095 RT6_TRACE("fib6_del_route\n"); 1096 1097 /* Unlink it */ 1098 *rtp = rt->u.dst.rt6_next; 1099 rt->rt6i_node = NULL; 1100 net->ipv6.rt6_stats->fib_rt_entries--; 1101 net->ipv6.rt6_stats->fib_discarded_routes++; 1102 1103 /* Reset round-robin state, if necessary */ 1104 if (fn->rr_ptr == rt) 1105 fn->rr_ptr = NULL; 1106 1107 /* Adjust walkers */ 1108 read_lock(&fib6_walker_lock); 1109 FOR_WALKERS(w) { 1110 if (w->state == FWS_C && w->leaf == rt) { 1111 RT6_TRACE("walker %p adjusted by delroute\n", w); 1112 w->leaf = rt->u.dst.rt6_next; 1113 if (w->leaf == NULL) 1114 w->state = FWS_U; 1115 } 1116 } 1117 read_unlock(&fib6_walker_lock); 1118 1119 rt->u.dst.rt6_next = NULL; 1120 1121 /* If it was last route, expunge its radix tree node */ 1122 if (fn->leaf == NULL) { 1123 fn->fn_flags &= ~RTN_RTINFO; 1124 net->ipv6.rt6_stats->fib_route_nodes--; 1125 fn = fib6_repair_tree(net, fn); 1126 } 1127 1128 if (atomic_read(&rt->rt6i_ref) != 1) { 1129 /* This route is used as dummy address holder in some split 1130 * nodes. It is not leaked, but it still holds other resources, 1131 * which must be released in time. So, scan ascendant nodes 1132 * and replace dummy references to this route with references 1133 * to still alive ones. 1134 */ 1135 while (fn) { 1136 if (!(fn->fn_flags&RTN_RTINFO) && fn->leaf == rt) { 1137 fn->leaf = fib6_find_prefix(net, fn); 1138 atomic_inc(&fn->leaf->rt6i_ref); 1139 rt6_release(rt); 1140 } 1141 fn = fn->parent; 1142 } 1143 /* No more references are possible at this point. */ 1144 BUG_ON(atomic_read(&rt->rt6i_ref) != 1); 1145 } 1146 1147 inet6_rt_notify(RTM_DELROUTE, rt, info); 1148 rt6_release(rt); 1149 } 1150 1151 int fib6_del(struct rt6_info *rt, struct nl_info *info) 1152 { 1153 struct net *net = info->nl_net; 1154 struct fib6_node *fn = rt->rt6i_node; 1155 struct rt6_info **rtp; 1156 1157 #if RT6_DEBUG >= 2 1158 if (rt->u.dst.obsolete>0) { 1159 WARN_ON(fn != NULL); 1160 return -ENOENT; 1161 } 1162 #endif 1163 if (fn == NULL || rt == net->ipv6.ip6_null_entry) 1164 return -ENOENT; 1165 1166 WARN_ON(!(fn->fn_flags & RTN_RTINFO)); 1167 1168 if (!(rt->rt6i_flags&RTF_CACHE)) { 1169 struct fib6_node *pn = fn; 1170 #ifdef CONFIG_IPV6_SUBTREES 1171 /* clones of this route might be in another subtree */ 1172 if (rt->rt6i_src.plen) { 1173 while (!(pn->fn_flags&RTN_ROOT)) 1174 pn = pn->parent; 1175 pn = pn->parent; 1176 } 1177 #endif 1178 fib6_prune_clones(info->nl_net, pn, rt); 1179 } 1180 1181 /* 1182 * Walk the leaf entries looking for ourself 1183 */ 1184 1185 for (rtp = &fn->leaf; *rtp; rtp = &(*rtp)->u.dst.rt6_next) { 1186 if (*rtp == rt) { 1187 fib6_del_route(fn, rtp, info); 1188 return 0; 1189 } 1190 } 1191 return -ENOENT; 1192 } 1193 1194 /* 1195 * Tree traversal function. 1196 * 1197 * Certainly, it is not interrupt safe. 1198 * However, it is internally reenterable wrt itself and fib6_add/fib6_del. 1199 * It means, that we can modify tree during walking 1200 * and use this function for garbage collection, clone pruning, 1201 * cleaning tree when a device goes down etc. etc. 1202 * 1203 * It guarantees that every node will be traversed, 1204 * and that it will be traversed only once. 1205 * 1206 * Callback function w->func may return: 1207 * 0 -> continue walking. 1208 * positive value -> walking is suspended (used by tree dumps, 1209 * and probably by gc, if it will be split to several slices) 1210 * negative value -> terminate walking. 1211 * 1212 * The function itself returns: 1213 * 0 -> walk is complete. 1214 * >0 -> walk is incomplete (i.e. suspended) 1215 * <0 -> walk is terminated by an error. 1216 */ 1217 1218 static int fib6_walk_continue(struct fib6_walker_t *w) 1219 { 1220 struct fib6_node *fn, *pn; 1221 1222 for (;;) { 1223 fn = w->node; 1224 if (fn == NULL) 1225 return 0; 1226 1227 if (w->prune && fn != w->root && 1228 fn->fn_flags&RTN_RTINFO && w->state < FWS_C) { 1229 w->state = FWS_C; 1230 w->leaf = fn->leaf; 1231 } 1232 switch (w->state) { 1233 #ifdef CONFIG_IPV6_SUBTREES 1234 case FWS_S: 1235 if (FIB6_SUBTREE(fn)) { 1236 w->node = FIB6_SUBTREE(fn); 1237 continue; 1238 } 1239 w->state = FWS_L; 1240 #endif 1241 case FWS_L: 1242 if (fn->left) { 1243 w->node = fn->left; 1244 w->state = FWS_INIT; 1245 continue; 1246 } 1247 w->state = FWS_R; 1248 case FWS_R: 1249 if (fn->right) { 1250 w->node = fn->right; 1251 w->state = FWS_INIT; 1252 continue; 1253 } 1254 w->state = FWS_C; 1255 w->leaf = fn->leaf; 1256 case FWS_C: 1257 if (w->leaf && fn->fn_flags&RTN_RTINFO) { 1258 int err = w->func(w); 1259 if (err) 1260 return err; 1261 continue; 1262 } 1263 w->state = FWS_U; 1264 case FWS_U: 1265 if (fn == w->root) 1266 return 0; 1267 pn = fn->parent; 1268 w->node = pn; 1269 #ifdef CONFIG_IPV6_SUBTREES 1270 if (FIB6_SUBTREE(pn) == fn) { 1271 WARN_ON(!(fn->fn_flags & RTN_ROOT)); 1272 w->state = FWS_L; 1273 continue; 1274 } 1275 #endif 1276 if (pn->left == fn) { 1277 w->state = FWS_R; 1278 continue; 1279 } 1280 if (pn->right == fn) { 1281 w->state = FWS_C; 1282 w->leaf = w->node->leaf; 1283 continue; 1284 } 1285 #if RT6_DEBUG >= 2 1286 WARN_ON(1); 1287 #endif 1288 } 1289 } 1290 } 1291 1292 static int fib6_walk(struct fib6_walker_t *w) 1293 { 1294 int res; 1295 1296 w->state = FWS_INIT; 1297 w->node = w->root; 1298 1299 fib6_walker_link(w); 1300 res = fib6_walk_continue(w); 1301 if (res <= 0) 1302 fib6_walker_unlink(w); 1303 return res; 1304 } 1305 1306 static int fib6_clean_node(struct fib6_walker_t *w) 1307 { 1308 int res; 1309 struct rt6_info *rt; 1310 struct fib6_cleaner_t *c = container_of(w, struct fib6_cleaner_t, w); 1311 struct nl_info info = { 1312 .nl_net = c->net, 1313 }; 1314 1315 for (rt = w->leaf; rt; rt = rt->u.dst.rt6_next) { 1316 res = c->func(rt, c->arg); 1317 if (res < 0) { 1318 w->leaf = rt; 1319 res = fib6_del(rt, &info); 1320 if (res) { 1321 #if RT6_DEBUG >= 2 1322 printk(KERN_DEBUG "fib6_clean_node: del failed: rt=%p@%p err=%d\n", rt, rt->rt6i_node, res); 1323 #endif 1324 continue; 1325 } 1326 return 0; 1327 } 1328 WARN_ON(res != 0); 1329 } 1330 w->leaf = rt; 1331 return 0; 1332 } 1333 1334 /* 1335 * Convenient frontend to tree walker. 1336 * 1337 * func is called on each route. 1338 * It may return -1 -> delete this route. 1339 * 0 -> continue walking 1340 * 1341 * prune==1 -> only immediate children of node (certainly, 1342 * ignoring pure split nodes) will be scanned. 1343 */ 1344 1345 static void fib6_clean_tree(struct net *net, struct fib6_node *root, 1346 int (*func)(struct rt6_info *, void *arg), 1347 int prune, void *arg) 1348 { 1349 struct fib6_cleaner_t c; 1350 1351 c.w.root = root; 1352 c.w.func = fib6_clean_node; 1353 c.w.prune = prune; 1354 c.func = func; 1355 c.arg = arg; 1356 c.net = net; 1357 1358 fib6_walk(&c.w); 1359 } 1360 1361 void fib6_clean_all(struct net *net, int (*func)(struct rt6_info *, void *arg), 1362 int prune, void *arg) 1363 { 1364 struct fib6_table *table; 1365 struct hlist_node *node; 1366 struct hlist_head *head; 1367 unsigned int h; 1368 1369 rcu_read_lock(); 1370 for (h = 0; h < FIB_TABLE_HASHSZ; h++) { 1371 head = &net->ipv6.fib_table_hash[h]; 1372 hlist_for_each_entry_rcu(table, node, head, tb6_hlist) { 1373 write_lock_bh(&table->tb6_lock); 1374 fib6_clean_tree(net, &table->tb6_root, 1375 func, prune, arg); 1376 write_unlock_bh(&table->tb6_lock); 1377 } 1378 } 1379 rcu_read_unlock(); 1380 } 1381 1382 static int fib6_prune_clone(struct rt6_info *rt, void *arg) 1383 { 1384 if (rt->rt6i_flags & RTF_CACHE) { 1385 RT6_TRACE("pruning clone %p\n", rt); 1386 return -1; 1387 } 1388 1389 return 0; 1390 } 1391 1392 static void fib6_prune_clones(struct net *net, struct fib6_node *fn, 1393 struct rt6_info *rt) 1394 { 1395 fib6_clean_tree(net, fn, fib6_prune_clone, 1, rt); 1396 } 1397 1398 /* 1399 * Garbage collection 1400 */ 1401 1402 static struct fib6_gc_args 1403 { 1404 int timeout; 1405 int more; 1406 } gc_args; 1407 1408 static int fib6_age(struct rt6_info *rt, void *arg) 1409 { 1410 unsigned long now = jiffies; 1411 1412 /* 1413 * check addrconf expiration here. 1414 * Routes are expired even if they are in use. 1415 * 1416 * Also age clones. Note, that clones are aged out 1417 * only if they are not in use now. 1418 */ 1419 1420 if (rt->rt6i_flags&RTF_EXPIRES && rt->rt6i_expires) { 1421 if (time_after(now, rt->rt6i_expires)) { 1422 RT6_TRACE("expiring %p\n", rt); 1423 return -1; 1424 } 1425 gc_args.more++; 1426 } else if (rt->rt6i_flags & RTF_CACHE) { 1427 if (atomic_read(&rt->u.dst.__refcnt) == 0 && 1428 time_after_eq(now, rt->u.dst.lastuse + gc_args.timeout)) { 1429 RT6_TRACE("aging clone %p\n", rt); 1430 return -1; 1431 } else if ((rt->rt6i_flags & RTF_GATEWAY) && 1432 (!(rt->rt6i_nexthop->flags & NTF_ROUTER))) { 1433 RT6_TRACE("purging route %p via non-router but gateway\n", 1434 rt); 1435 return -1; 1436 } 1437 gc_args.more++; 1438 } 1439 1440 return 0; 1441 } 1442 1443 static DEFINE_SPINLOCK(fib6_gc_lock); 1444 1445 void fib6_run_gc(unsigned long expires, struct net *net) 1446 { 1447 if (expires != ~0UL) { 1448 spin_lock_bh(&fib6_gc_lock); 1449 gc_args.timeout = expires ? (int)expires : 1450 net->ipv6.sysctl.ip6_rt_gc_interval; 1451 } else { 1452 if (!spin_trylock_bh(&fib6_gc_lock)) { 1453 mod_timer(&net->ipv6.ip6_fib_timer, jiffies + HZ); 1454 return; 1455 } 1456 gc_args.timeout = net->ipv6.sysctl.ip6_rt_gc_interval; 1457 } 1458 1459 gc_args.more = icmp6_dst_gc(); 1460 1461 fib6_clean_all(net, fib6_age, 0, NULL); 1462 1463 if (gc_args.more) 1464 mod_timer(&net->ipv6.ip6_fib_timer, 1465 round_jiffies(jiffies 1466 + net->ipv6.sysctl.ip6_rt_gc_interval)); 1467 else 1468 del_timer(&net->ipv6.ip6_fib_timer); 1469 spin_unlock_bh(&fib6_gc_lock); 1470 } 1471 1472 static void fib6_gc_timer_cb(unsigned long arg) 1473 { 1474 fib6_run_gc(0, (struct net *)arg); 1475 } 1476 1477 static int fib6_net_init(struct net *net) 1478 { 1479 setup_timer(&net->ipv6.ip6_fib_timer, fib6_gc_timer_cb, (unsigned long)net); 1480 1481 net->ipv6.rt6_stats = kzalloc(sizeof(*net->ipv6.rt6_stats), GFP_KERNEL); 1482 if (!net->ipv6.rt6_stats) 1483 goto out_timer; 1484 1485 net->ipv6.fib_table_hash = kcalloc(FIB_TABLE_HASHSZ, 1486 sizeof(*net->ipv6.fib_table_hash), 1487 GFP_KERNEL); 1488 if (!net->ipv6.fib_table_hash) 1489 goto out_rt6_stats; 1490 1491 net->ipv6.fib6_main_tbl = kzalloc(sizeof(*net->ipv6.fib6_main_tbl), 1492 GFP_KERNEL); 1493 if (!net->ipv6.fib6_main_tbl) 1494 goto out_fib_table_hash; 1495 1496 net->ipv6.fib6_main_tbl->tb6_id = RT6_TABLE_MAIN; 1497 net->ipv6.fib6_main_tbl->tb6_root.leaf = net->ipv6.ip6_null_entry; 1498 net->ipv6.fib6_main_tbl->tb6_root.fn_flags = 1499 RTN_ROOT | RTN_TL_ROOT | RTN_RTINFO; 1500 1501 #ifdef CONFIG_IPV6_MULTIPLE_TABLES 1502 net->ipv6.fib6_local_tbl = kzalloc(sizeof(*net->ipv6.fib6_local_tbl), 1503 GFP_KERNEL); 1504 if (!net->ipv6.fib6_local_tbl) 1505 goto out_fib6_main_tbl; 1506 net->ipv6.fib6_local_tbl->tb6_id = RT6_TABLE_LOCAL; 1507 net->ipv6.fib6_local_tbl->tb6_root.leaf = net->ipv6.ip6_null_entry; 1508 net->ipv6.fib6_local_tbl->tb6_root.fn_flags = 1509 RTN_ROOT | RTN_TL_ROOT | RTN_RTINFO; 1510 #endif 1511 fib6_tables_init(net); 1512 1513 return 0; 1514 1515 #ifdef CONFIG_IPV6_MULTIPLE_TABLES 1516 out_fib6_main_tbl: 1517 kfree(net->ipv6.fib6_main_tbl); 1518 #endif 1519 out_fib_table_hash: 1520 kfree(net->ipv6.fib_table_hash); 1521 out_rt6_stats: 1522 kfree(net->ipv6.rt6_stats); 1523 out_timer: 1524 return -ENOMEM; 1525 } 1526 1527 static void fib6_net_exit(struct net *net) 1528 { 1529 rt6_ifdown(net, NULL); 1530 del_timer_sync(&net->ipv6.ip6_fib_timer); 1531 1532 #ifdef CONFIG_IPV6_MULTIPLE_TABLES 1533 kfree(net->ipv6.fib6_local_tbl); 1534 #endif 1535 kfree(net->ipv6.fib6_main_tbl); 1536 kfree(net->ipv6.fib_table_hash); 1537 kfree(net->ipv6.rt6_stats); 1538 } 1539 1540 static struct pernet_operations fib6_net_ops = { 1541 .init = fib6_net_init, 1542 .exit = fib6_net_exit, 1543 }; 1544 1545 int __init fib6_init(void) 1546 { 1547 int ret = -ENOMEM; 1548 1549 fib6_node_kmem = kmem_cache_create("fib6_nodes", 1550 sizeof(struct fib6_node), 1551 0, SLAB_HWCACHE_ALIGN, 1552 NULL); 1553 if (!fib6_node_kmem) 1554 goto out; 1555 1556 ret = register_pernet_subsys(&fib6_net_ops); 1557 if (ret) 1558 goto out_kmem_cache_create; 1559 1560 ret = __rtnl_register(PF_INET6, RTM_GETROUTE, NULL, inet6_dump_fib); 1561 if (ret) 1562 goto out_unregister_subsys; 1563 out: 1564 return ret; 1565 1566 out_unregister_subsys: 1567 unregister_pernet_subsys(&fib6_net_ops); 1568 out_kmem_cache_create: 1569 kmem_cache_destroy(fib6_node_kmem); 1570 goto out; 1571 } 1572 1573 void fib6_gc_cleanup(void) 1574 { 1575 unregister_pernet_subsys(&fib6_net_ops); 1576 kmem_cache_destroy(fib6_node_kmem); 1577 } 1578