1 /* 2 * Copyright (c) 2018 Cumulus Networks. All rights reserved. 3 * Copyright (c) 2018 David Ahern <dsa@cumulusnetworks.com> 4 * 5 * This software is licensed under the GNU General License Version 2, 6 * June 1991 as shown in the file COPYING in the top-level directory of this 7 * source tree. 8 * 9 * THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" 10 * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, 11 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 12 * FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE 13 * OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME 14 * THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 15 */ 16 17 #include <linux/bitmap.h> 18 #include <linux/in6.h> 19 #include <linux/kernel.h> 20 #include <linux/list.h> 21 #include <linux/rhashtable.h> 22 #include <linux/spinlock_types.h> 23 #include <linux/types.h> 24 #include <net/fib_notifier.h> 25 #include <net/inet_dscp.h> 26 #include <net/ip_fib.h> 27 #include <net/ip6_fib.h> 28 #include <net/fib_rules.h> 29 #include <net/net_namespace.h> 30 #include <net/nexthop.h> 31 #include <linux/debugfs.h> 32 33 #include "netdevsim.h" 34 35 struct nsim_fib_entry { 36 u64 max; 37 atomic64_t num; 38 }; 39 40 struct nsim_per_fib_data { 41 struct nsim_fib_entry fib; 42 struct nsim_fib_entry rules; 43 }; 44 45 struct nsim_fib_data { 46 struct notifier_block fib_nb; 47 struct nsim_per_fib_data ipv4; 48 struct nsim_per_fib_data ipv6; 49 struct nsim_fib_entry nexthops; 50 struct rhashtable fib_rt_ht; 51 struct list_head fib_rt_list; 52 struct mutex fib_lock; /* Protects FIB HT and list */ 53 struct notifier_block nexthop_nb; 54 struct rhashtable nexthop_ht; 55 struct devlink *devlink; 56 struct work_struct fib_event_work; 57 struct list_head fib_event_queue; 58 spinlock_t fib_event_queue_lock; /* Protects fib event queue list */ 59 struct mutex nh_lock; /* Protects NH HT */ 60 struct dentry *ddir; 61 bool fail_route_offload; 62 bool fail_res_nexthop_group_replace; 63 bool fail_nexthop_bucket_replace; 64 }; 65 66 struct nsim_fib_rt_key { 67 unsigned char addr[sizeof(struct in6_addr)]; 68 unsigned char prefix_len; 69 int family; 70 u32 tb_id; 71 }; 72 73 struct nsim_fib_rt { 74 struct nsim_fib_rt_key key; 75 struct rhash_head ht_node; 76 struct list_head list; /* Member of fib_rt_list */ 77 }; 78 79 struct nsim_fib4_rt { 80 struct nsim_fib_rt common; 81 struct fib_info *fi; 82 dscp_t dscp; 83 u8 type; 84 }; 85 86 struct nsim_fib6_rt { 87 struct nsim_fib_rt common; 88 struct list_head nh_list; 89 unsigned int nhs; 90 }; 91 92 struct nsim_fib6_rt_nh { 93 struct list_head list; /* Member of nh_list */ 94 struct fib6_info *rt; 95 }; 96 97 struct nsim_fib6_event { 98 struct fib6_info **rt_arr; 99 unsigned int nrt6; 100 }; 101 102 struct nsim_fib_event { 103 struct list_head list; /* node in fib queue */ 104 union { 105 struct fib_entry_notifier_info fen_info; 106 struct nsim_fib6_event fib6_event; 107 }; 108 struct nsim_fib_data *data; 109 unsigned long event; 110 int family; 111 }; 112 113 static const struct rhashtable_params nsim_fib_rt_ht_params = { 114 .key_offset = offsetof(struct nsim_fib_rt, key), 115 .head_offset = offsetof(struct nsim_fib_rt, ht_node), 116 .key_len = sizeof(struct nsim_fib_rt_key), 117 .automatic_shrinking = true, 118 }; 119 120 struct nsim_nexthop { 121 struct rhash_head ht_node; 122 u64 occ; 123 u32 id; 124 bool is_resilient; 125 }; 126 127 static const struct rhashtable_params nsim_nexthop_ht_params = { 128 .key_offset = offsetof(struct nsim_nexthop, id), 129 .head_offset = offsetof(struct nsim_nexthop, ht_node), 130 .key_len = sizeof(u32), 131 .automatic_shrinking = true, 132 }; 133 134 u64 nsim_fib_get_val(struct nsim_fib_data *fib_data, 135 enum nsim_resource_id res_id, bool max) 136 { 137 struct nsim_fib_entry *entry; 138 139 switch (res_id) { 140 case NSIM_RESOURCE_IPV4_FIB: 141 entry = &fib_data->ipv4.fib; 142 break; 143 case NSIM_RESOURCE_IPV4_FIB_RULES: 144 entry = &fib_data->ipv4.rules; 145 break; 146 case NSIM_RESOURCE_IPV6_FIB: 147 entry = &fib_data->ipv6.fib; 148 break; 149 case NSIM_RESOURCE_IPV6_FIB_RULES: 150 entry = &fib_data->ipv6.rules; 151 break; 152 case NSIM_RESOURCE_NEXTHOPS: 153 entry = &fib_data->nexthops; 154 break; 155 default: 156 return 0; 157 } 158 159 return max ? entry->max : atomic64_read(&entry->num); 160 } 161 162 static void nsim_fib_set_max(struct nsim_fib_data *fib_data, 163 enum nsim_resource_id res_id, u64 val) 164 { 165 struct nsim_fib_entry *entry; 166 167 switch (res_id) { 168 case NSIM_RESOURCE_IPV4_FIB: 169 entry = &fib_data->ipv4.fib; 170 break; 171 case NSIM_RESOURCE_IPV4_FIB_RULES: 172 entry = &fib_data->ipv4.rules; 173 break; 174 case NSIM_RESOURCE_IPV6_FIB: 175 entry = &fib_data->ipv6.fib; 176 break; 177 case NSIM_RESOURCE_IPV6_FIB_RULES: 178 entry = &fib_data->ipv6.rules; 179 break; 180 case NSIM_RESOURCE_NEXTHOPS: 181 entry = &fib_data->nexthops; 182 break; 183 default: 184 WARN_ON(1); 185 return; 186 } 187 entry->max = val; 188 } 189 190 static int nsim_fib_rule_account(struct nsim_fib_entry *entry, bool add, 191 struct netlink_ext_ack *extack) 192 { 193 int err = 0; 194 195 if (add) { 196 if (!atomic64_add_unless(&entry->num, 1, entry->max)) { 197 err = -ENOSPC; 198 NL_SET_ERR_MSG_MOD(extack, "Exceeded number of supported fib rule entries"); 199 } 200 } else { 201 atomic64_dec_if_positive(&entry->num); 202 } 203 204 return err; 205 } 206 207 static int nsim_fib_rule_event(struct nsim_fib_data *data, 208 struct fib_notifier_info *info, bool add) 209 { 210 struct netlink_ext_ack *extack = info->extack; 211 int err = 0; 212 213 switch (info->family) { 214 case AF_INET: 215 err = nsim_fib_rule_account(&data->ipv4.rules, add, extack); 216 break; 217 case AF_INET6: 218 err = nsim_fib_rule_account(&data->ipv6.rules, add, extack); 219 break; 220 } 221 222 return err; 223 } 224 225 static int nsim_fib_account(struct nsim_fib_entry *entry, bool add) 226 { 227 int err = 0; 228 229 if (add) { 230 if (!atomic64_add_unless(&entry->num, 1, entry->max)) 231 err = -ENOSPC; 232 } else { 233 atomic64_dec_if_positive(&entry->num); 234 } 235 236 return err; 237 } 238 239 static void nsim_fib_rt_init(struct nsim_fib_data *data, 240 struct nsim_fib_rt *fib_rt, const void *addr, 241 size_t addr_len, unsigned int prefix_len, 242 int family, u32 tb_id) 243 { 244 memcpy(fib_rt->key.addr, addr, addr_len); 245 fib_rt->key.prefix_len = prefix_len; 246 fib_rt->key.family = family; 247 fib_rt->key.tb_id = tb_id; 248 list_add(&fib_rt->list, &data->fib_rt_list); 249 } 250 251 static void nsim_fib_rt_fini(struct nsim_fib_rt *fib_rt) 252 { 253 list_del(&fib_rt->list); 254 } 255 256 static struct nsim_fib_rt *nsim_fib_rt_lookup(struct rhashtable *fib_rt_ht, 257 const void *addr, size_t addr_len, 258 unsigned int prefix_len, 259 int family, u32 tb_id) 260 { 261 struct nsim_fib_rt_key key; 262 263 memset(&key, 0, sizeof(key)); 264 memcpy(key.addr, addr, addr_len); 265 key.prefix_len = prefix_len; 266 key.family = family; 267 key.tb_id = tb_id; 268 269 return rhashtable_lookup_fast(fib_rt_ht, &key, nsim_fib_rt_ht_params); 270 } 271 272 static struct nsim_fib4_rt * 273 nsim_fib4_rt_create(struct nsim_fib_data *data, 274 struct fib_entry_notifier_info *fen_info) 275 { 276 struct nsim_fib4_rt *fib4_rt; 277 278 fib4_rt = kzalloc(sizeof(*fib4_rt), GFP_KERNEL); 279 if (!fib4_rt) 280 return NULL; 281 282 nsim_fib_rt_init(data, &fib4_rt->common, &fen_info->dst, sizeof(u32), 283 fen_info->dst_len, AF_INET, fen_info->tb_id); 284 285 fib4_rt->fi = fen_info->fi; 286 fib_info_hold(fib4_rt->fi); 287 fib4_rt->dscp = fen_info->dscp; 288 fib4_rt->type = fen_info->type; 289 290 return fib4_rt; 291 } 292 293 static void nsim_fib4_rt_destroy(struct nsim_fib4_rt *fib4_rt) 294 { 295 fib_info_put(fib4_rt->fi); 296 nsim_fib_rt_fini(&fib4_rt->common); 297 kfree(fib4_rt); 298 } 299 300 static struct nsim_fib4_rt * 301 nsim_fib4_rt_lookup(struct rhashtable *fib_rt_ht, 302 const struct fib_entry_notifier_info *fen_info) 303 { 304 struct nsim_fib_rt *fib_rt; 305 306 fib_rt = nsim_fib_rt_lookup(fib_rt_ht, &fen_info->dst, sizeof(u32), 307 fen_info->dst_len, AF_INET, 308 fen_info->tb_id); 309 if (!fib_rt) 310 return NULL; 311 312 return container_of(fib_rt, struct nsim_fib4_rt, common); 313 } 314 315 static void 316 nsim_fib4_rt_offload_failed_flag_set(struct net *net, 317 struct fib_entry_notifier_info *fen_info) 318 { 319 u32 *p_dst = (u32 *)&fen_info->dst; 320 struct fib_rt_info fri; 321 322 fri.fi = fen_info->fi; 323 fri.tb_id = fen_info->tb_id; 324 fri.dst = cpu_to_be32(*p_dst); 325 fri.dst_len = fen_info->dst_len; 326 fri.dscp = fen_info->dscp; 327 fri.type = fen_info->type; 328 fri.offload = false; 329 fri.trap = false; 330 fri.offload_failed = true; 331 fib_alias_hw_flags_set(net, &fri); 332 } 333 334 static void nsim_fib4_rt_hw_flags_set(struct net *net, 335 const struct nsim_fib4_rt *fib4_rt, 336 bool trap) 337 { 338 u32 *p_dst = (u32 *) fib4_rt->common.key.addr; 339 int dst_len = fib4_rt->common.key.prefix_len; 340 struct fib_rt_info fri; 341 342 fri.fi = fib4_rt->fi; 343 fri.tb_id = fib4_rt->common.key.tb_id; 344 fri.dst = cpu_to_be32(*p_dst); 345 fri.dst_len = dst_len; 346 fri.dscp = fib4_rt->dscp; 347 fri.type = fib4_rt->type; 348 fri.offload = false; 349 fri.trap = trap; 350 fri.offload_failed = false; 351 fib_alias_hw_flags_set(net, &fri); 352 } 353 354 static int nsim_fib4_rt_add(struct nsim_fib_data *data, 355 struct nsim_fib4_rt *fib4_rt) 356 { 357 struct net *net = devlink_net(data->devlink); 358 int err; 359 360 err = rhashtable_insert_fast(&data->fib_rt_ht, 361 &fib4_rt->common.ht_node, 362 nsim_fib_rt_ht_params); 363 if (err) 364 goto err_fib_dismiss; 365 366 /* Simulate hardware programming latency. */ 367 msleep(1); 368 nsim_fib4_rt_hw_flags_set(net, fib4_rt, true); 369 370 return 0; 371 372 err_fib_dismiss: 373 /* Drop the accounting that was increased from the notification 374 * context when FIB_EVENT_ENTRY_REPLACE was triggered. 375 */ 376 nsim_fib_account(&data->ipv4.fib, false); 377 return err; 378 } 379 380 static int nsim_fib4_rt_replace(struct nsim_fib_data *data, 381 struct nsim_fib4_rt *fib4_rt, 382 struct nsim_fib4_rt *fib4_rt_old) 383 { 384 struct net *net = devlink_net(data->devlink); 385 int err; 386 387 /* We are replacing a route, so need to remove the accounting which 388 * was increased when FIB_EVENT_ENTRY_REPLACE was triggered. 389 */ 390 err = nsim_fib_account(&data->ipv4.fib, false); 391 if (err) 392 return err; 393 err = rhashtable_replace_fast(&data->fib_rt_ht, 394 &fib4_rt_old->common.ht_node, 395 &fib4_rt->common.ht_node, 396 nsim_fib_rt_ht_params); 397 if (err) 398 return err; 399 400 msleep(1); 401 nsim_fib4_rt_hw_flags_set(net, fib4_rt, true); 402 403 nsim_fib4_rt_hw_flags_set(net, fib4_rt_old, false); 404 nsim_fib4_rt_destroy(fib4_rt_old); 405 406 return 0; 407 } 408 409 static int nsim_fib4_rt_insert(struct nsim_fib_data *data, 410 struct fib_entry_notifier_info *fen_info) 411 { 412 struct nsim_fib4_rt *fib4_rt, *fib4_rt_old; 413 int err; 414 415 if (data->fail_route_offload) { 416 /* For testing purposes, user set debugfs fail_route_offload 417 * value to true. Simulate hardware programming latency and then 418 * fail. 419 */ 420 msleep(1); 421 return -EINVAL; 422 } 423 424 fib4_rt = nsim_fib4_rt_create(data, fen_info); 425 if (!fib4_rt) 426 return -ENOMEM; 427 428 fib4_rt_old = nsim_fib4_rt_lookup(&data->fib_rt_ht, fen_info); 429 if (!fib4_rt_old) 430 err = nsim_fib4_rt_add(data, fib4_rt); 431 else 432 err = nsim_fib4_rt_replace(data, fib4_rt, fib4_rt_old); 433 434 if (err) 435 nsim_fib4_rt_destroy(fib4_rt); 436 437 return err; 438 } 439 440 static void nsim_fib4_rt_remove(struct nsim_fib_data *data, 441 const struct fib_entry_notifier_info *fen_info) 442 { 443 struct nsim_fib4_rt *fib4_rt; 444 445 fib4_rt = nsim_fib4_rt_lookup(&data->fib_rt_ht, fen_info); 446 if (!fib4_rt) 447 return; 448 449 rhashtable_remove_fast(&data->fib_rt_ht, &fib4_rt->common.ht_node, 450 nsim_fib_rt_ht_params); 451 nsim_fib4_rt_destroy(fib4_rt); 452 } 453 454 static int nsim_fib4_event(struct nsim_fib_data *data, 455 struct fib_entry_notifier_info *fen_info, 456 unsigned long event) 457 { 458 int err = 0; 459 460 switch (event) { 461 case FIB_EVENT_ENTRY_REPLACE: 462 err = nsim_fib4_rt_insert(data, fen_info); 463 if (err) { 464 struct net *net = devlink_net(data->devlink); 465 466 nsim_fib4_rt_offload_failed_flag_set(net, fen_info); 467 } 468 break; 469 case FIB_EVENT_ENTRY_DEL: 470 nsim_fib4_rt_remove(data, fen_info); 471 break; 472 default: 473 break; 474 } 475 476 return err; 477 } 478 479 static struct nsim_fib6_rt_nh * 480 nsim_fib6_rt_nh_find(const struct nsim_fib6_rt *fib6_rt, 481 const struct fib6_info *rt) 482 { 483 struct nsim_fib6_rt_nh *fib6_rt_nh; 484 485 list_for_each_entry(fib6_rt_nh, &fib6_rt->nh_list, list) { 486 if (fib6_rt_nh->rt == rt) 487 return fib6_rt_nh; 488 } 489 490 return NULL; 491 } 492 493 static int nsim_fib6_rt_nh_add(struct nsim_fib6_rt *fib6_rt, 494 struct fib6_info *rt) 495 { 496 struct nsim_fib6_rt_nh *fib6_rt_nh; 497 498 fib6_rt_nh = kzalloc(sizeof(*fib6_rt_nh), GFP_KERNEL); 499 if (!fib6_rt_nh) 500 return -ENOMEM; 501 502 fib6_info_hold(rt); 503 fib6_rt_nh->rt = rt; 504 list_add_tail(&fib6_rt_nh->list, &fib6_rt->nh_list); 505 fib6_rt->nhs++; 506 507 return 0; 508 } 509 510 #if IS_ENABLED(CONFIG_IPV6) 511 static void nsim_rt6_release(struct fib6_info *rt) 512 { 513 fib6_info_release(rt); 514 } 515 #else 516 static void nsim_rt6_release(struct fib6_info *rt) 517 { 518 } 519 #endif 520 521 static void nsim_fib6_rt_nh_del(struct nsim_fib6_rt *fib6_rt, 522 const struct fib6_info *rt) 523 { 524 struct nsim_fib6_rt_nh *fib6_rt_nh; 525 526 fib6_rt_nh = nsim_fib6_rt_nh_find(fib6_rt, rt); 527 if (!fib6_rt_nh) 528 return; 529 530 fib6_rt->nhs--; 531 list_del(&fib6_rt_nh->list); 532 nsim_rt6_release(fib6_rt_nh->rt); 533 kfree(fib6_rt_nh); 534 } 535 536 static struct nsim_fib6_rt * 537 nsim_fib6_rt_create(struct nsim_fib_data *data, 538 struct fib6_info **rt_arr, unsigned int nrt6) 539 { 540 struct fib6_info *rt = rt_arr[0]; 541 struct nsim_fib6_rt *fib6_rt; 542 int i = 0; 543 int err; 544 545 fib6_rt = kzalloc(sizeof(*fib6_rt), GFP_KERNEL); 546 if (!fib6_rt) 547 return ERR_PTR(-ENOMEM); 548 549 nsim_fib_rt_init(data, &fib6_rt->common, &rt->fib6_dst.addr, 550 sizeof(rt->fib6_dst.addr), rt->fib6_dst.plen, AF_INET6, 551 rt->fib6_table->tb6_id); 552 553 /* We consider a multipath IPv6 route as one entry, but it can be made 554 * up from several fib6_info structs (one for each nexthop), so we 555 * add them all to the same list under the entry. 556 */ 557 INIT_LIST_HEAD(&fib6_rt->nh_list); 558 559 for (i = 0; i < nrt6; i++) { 560 err = nsim_fib6_rt_nh_add(fib6_rt, rt_arr[i]); 561 if (err) 562 goto err_fib6_rt_nh_del; 563 } 564 565 return fib6_rt; 566 567 err_fib6_rt_nh_del: 568 for (i--; i >= 0; i--) { 569 nsim_fib6_rt_nh_del(fib6_rt, rt_arr[i]); 570 } 571 nsim_fib_rt_fini(&fib6_rt->common); 572 kfree(fib6_rt); 573 return ERR_PTR(err); 574 } 575 576 static void nsim_fib6_rt_destroy(struct nsim_fib6_rt *fib6_rt) 577 { 578 struct nsim_fib6_rt_nh *iter, *tmp; 579 580 list_for_each_entry_safe(iter, tmp, &fib6_rt->nh_list, list) 581 nsim_fib6_rt_nh_del(fib6_rt, iter->rt); 582 WARN_ON_ONCE(!list_empty(&fib6_rt->nh_list)); 583 nsim_fib_rt_fini(&fib6_rt->common); 584 kfree(fib6_rt); 585 } 586 587 static struct nsim_fib6_rt * 588 nsim_fib6_rt_lookup(struct rhashtable *fib_rt_ht, const struct fib6_info *rt) 589 { 590 struct nsim_fib_rt *fib_rt; 591 592 fib_rt = nsim_fib_rt_lookup(fib_rt_ht, &rt->fib6_dst.addr, 593 sizeof(rt->fib6_dst.addr), 594 rt->fib6_dst.plen, AF_INET6, 595 rt->fib6_table->tb6_id); 596 if (!fib_rt) 597 return NULL; 598 599 return container_of(fib_rt, struct nsim_fib6_rt, common); 600 } 601 602 static int nsim_fib6_rt_append(struct nsim_fib_data *data, 603 struct nsim_fib6_event *fib6_event) 604 { 605 struct fib6_info *rt = fib6_event->rt_arr[0]; 606 struct nsim_fib6_rt *fib6_rt; 607 int i, err; 608 609 if (data->fail_route_offload) { 610 /* For testing purposes, user set debugfs fail_route_offload 611 * value to true. Simulate hardware programming latency and then 612 * fail. 613 */ 614 msleep(1); 615 return -EINVAL; 616 } 617 618 fib6_rt = nsim_fib6_rt_lookup(&data->fib_rt_ht, rt); 619 if (!fib6_rt) 620 return -EINVAL; 621 622 for (i = 0; i < fib6_event->nrt6; i++) { 623 err = nsim_fib6_rt_nh_add(fib6_rt, fib6_event->rt_arr[i]); 624 if (err) 625 goto err_fib6_rt_nh_del; 626 627 WRITE_ONCE(fib6_event->rt_arr[i]->trap, true); 628 } 629 630 return 0; 631 632 err_fib6_rt_nh_del: 633 for (i--; i >= 0; i--) { 634 WRITE_ONCE(fib6_event->rt_arr[i]->trap, false); 635 nsim_fib6_rt_nh_del(fib6_rt, fib6_event->rt_arr[i]); 636 } 637 return err; 638 } 639 640 #if IS_ENABLED(CONFIG_IPV6) 641 static void nsim_fib6_rt_offload_failed_flag_set(struct nsim_fib_data *data, 642 struct fib6_info **rt_arr, 643 unsigned int nrt6) 644 645 { 646 struct net *net = devlink_net(data->devlink); 647 int i; 648 649 for (i = 0; i < nrt6; i++) 650 fib6_info_hw_flags_set(net, rt_arr[i], false, false, true); 651 } 652 #else 653 static void nsim_fib6_rt_offload_failed_flag_set(struct nsim_fib_data *data, 654 struct fib6_info **rt_arr, 655 unsigned int nrt6) 656 { 657 } 658 #endif 659 660 #if IS_ENABLED(CONFIG_IPV6) 661 static void nsim_fib6_rt_hw_flags_set(struct nsim_fib_data *data, 662 const struct nsim_fib6_rt *fib6_rt, 663 bool trap) 664 { 665 struct net *net = devlink_net(data->devlink); 666 struct nsim_fib6_rt_nh *fib6_rt_nh; 667 668 list_for_each_entry(fib6_rt_nh, &fib6_rt->nh_list, list) 669 fib6_info_hw_flags_set(net, fib6_rt_nh->rt, false, trap, false); 670 } 671 #else 672 static void nsim_fib6_rt_hw_flags_set(struct nsim_fib_data *data, 673 const struct nsim_fib6_rt *fib6_rt, 674 bool trap) 675 { 676 } 677 #endif 678 679 static int nsim_fib6_rt_add(struct nsim_fib_data *data, 680 struct nsim_fib6_rt *fib6_rt) 681 { 682 int err; 683 684 err = rhashtable_insert_fast(&data->fib_rt_ht, 685 &fib6_rt->common.ht_node, 686 nsim_fib_rt_ht_params); 687 688 if (err) 689 goto err_fib_dismiss; 690 691 msleep(1); 692 nsim_fib6_rt_hw_flags_set(data, fib6_rt, true); 693 694 return 0; 695 696 err_fib_dismiss: 697 /* Drop the accounting that was increased from the notification 698 * context when FIB_EVENT_ENTRY_REPLACE was triggered. 699 */ 700 nsim_fib_account(&data->ipv6.fib, false); 701 return err; 702 } 703 704 static int nsim_fib6_rt_replace(struct nsim_fib_data *data, 705 struct nsim_fib6_rt *fib6_rt, 706 struct nsim_fib6_rt *fib6_rt_old) 707 { 708 int err; 709 710 /* We are replacing a route, so need to remove the accounting which 711 * was increased when FIB_EVENT_ENTRY_REPLACE was triggered. 712 */ 713 err = nsim_fib_account(&data->ipv6.fib, false); 714 if (err) 715 return err; 716 717 err = rhashtable_replace_fast(&data->fib_rt_ht, 718 &fib6_rt_old->common.ht_node, 719 &fib6_rt->common.ht_node, 720 nsim_fib_rt_ht_params); 721 722 if (err) 723 return err; 724 725 msleep(1); 726 nsim_fib6_rt_hw_flags_set(data, fib6_rt, true); 727 728 nsim_fib6_rt_hw_flags_set(data, fib6_rt_old, false); 729 nsim_fib6_rt_destroy(fib6_rt_old); 730 731 return 0; 732 } 733 734 static int nsim_fib6_rt_insert(struct nsim_fib_data *data, 735 struct nsim_fib6_event *fib6_event) 736 { 737 struct fib6_info *rt = fib6_event->rt_arr[0]; 738 struct nsim_fib6_rt *fib6_rt, *fib6_rt_old; 739 int err; 740 741 if (data->fail_route_offload) { 742 /* For testing purposes, user set debugfs fail_route_offload 743 * value to true. Simulate hardware programming latency and then 744 * fail. 745 */ 746 msleep(1); 747 return -EINVAL; 748 } 749 750 fib6_rt = nsim_fib6_rt_create(data, fib6_event->rt_arr, 751 fib6_event->nrt6); 752 if (IS_ERR(fib6_rt)) 753 return PTR_ERR(fib6_rt); 754 755 fib6_rt_old = nsim_fib6_rt_lookup(&data->fib_rt_ht, rt); 756 if (!fib6_rt_old) 757 err = nsim_fib6_rt_add(data, fib6_rt); 758 else 759 err = nsim_fib6_rt_replace(data, fib6_rt, fib6_rt_old); 760 761 if (err) 762 nsim_fib6_rt_destroy(fib6_rt); 763 764 return err; 765 } 766 767 static void nsim_fib6_rt_remove(struct nsim_fib_data *data, 768 struct nsim_fib6_event *fib6_event) 769 { 770 struct fib6_info *rt = fib6_event->rt_arr[0]; 771 struct nsim_fib6_rt *fib6_rt; 772 int i; 773 774 /* Multipath routes are first added to the FIB trie and only then 775 * notified. If we vetoed the addition, we will get a delete 776 * notification for a route we do not have. Therefore, do not warn if 777 * route was not found. 778 */ 779 fib6_rt = nsim_fib6_rt_lookup(&data->fib_rt_ht, rt); 780 if (!fib6_rt) 781 return; 782 783 /* If not all the nexthops are deleted, then only reduce the nexthop 784 * group. 785 */ 786 if (fib6_event->nrt6 != fib6_rt->nhs) { 787 for (i = 0; i < fib6_event->nrt6; i++) 788 nsim_fib6_rt_nh_del(fib6_rt, fib6_event->rt_arr[i]); 789 return; 790 } 791 792 rhashtable_remove_fast(&data->fib_rt_ht, &fib6_rt->common.ht_node, 793 nsim_fib_rt_ht_params); 794 nsim_fib6_rt_destroy(fib6_rt); 795 } 796 797 static int nsim_fib6_event_init(struct nsim_fib6_event *fib6_event, 798 struct fib6_entry_notifier_info *fen6_info) 799 { 800 struct fib6_info *rt = fen6_info->rt; 801 struct fib6_info **rt_arr; 802 struct fib6_info *iter; 803 unsigned int nrt6; 804 int i = 0; 805 806 nrt6 = fen6_info->nsiblings + 1; 807 808 rt_arr = kcalloc(nrt6, sizeof(struct fib6_info *), GFP_ATOMIC); 809 if (!rt_arr) 810 return -ENOMEM; 811 812 fib6_event->rt_arr = rt_arr; 813 fib6_event->nrt6 = nrt6; 814 815 rt_arr[0] = rt; 816 fib6_info_hold(rt); 817 818 if (!fen6_info->nsiblings) 819 return 0; 820 821 list_for_each_entry(iter, &rt->fib6_siblings, fib6_siblings) { 822 if (i == fen6_info->nsiblings) 823 break; 824 825 rt_arr[i + 1] = iter; 826 fib6_info_hold(iter); 827 i++; 828 } 829 WARN_ON_ONCE(i != fen6_info->nsiblings); 830 831 return 0; 832 } 833 834 static void nsim_fib6_event_fini(struct nsim_fib6_event *fib6_event) 835 { 836 int i; 837 838 for (i = 0; i < fib6_event->nrt6; i++) 839 nsim_rt6_release(fib6_event->rt_arr[i]); 840 kfree(fib6_event->rt_arr); 841 } 842 843 static int nsim_fib6_event(struct nsim_fib_data *data, 844 struct nsim_fib6_event *fib6_event, 845 unsigned long event) 846 { 847 int err; 848 849 if (fib6_event->rt_arr[0]->fib6_src.plen) 850 return 0; 851 852 switch (event) { 853 case FIB_EVENT_ENTRY_REPLACE: 854 err = nsim_fib6_rt_insert(data, fib6_event); 855 if (err) 856 goto err_rt_offload_failed_flag_set; 857 break; 858 case FIB_EVENT_ENTRY_APPEND: 859 err = nsim_fib6_rt_append(data, fib6_event); 860 if (err) 861 goto err_rt_offload_failed_flag_set; 862 break; 863 case FIB_EVENT_ENTRY_DEL: 864 nsim_fib6_rt_remove(data, fib6_event); 865 break; 866 default: 867 break; 868 } 869 870 return 0; 871 872 err_rt_offload_failed_flag_set: 873 nsim_fib6_rt_offload_failed_flag_set(data, fib6_event->rt_arr, 874 fib6_event->nrt6); 875 return err; 876 } 877 878 static void nsim_fib_event(struct nsim_fib_event *fib_event) 879 { 880 switch (fib_event->family) { 881 case AF_INET: 882 nsim_fib4_event(fib_event->data, &fib_event->fen_info, 883 fib_event->event); 884 fib_info_put(fib_event->fen_info.fi); 885 break; 886 case AF_INET6: 887 nsim_fib6_event(fib_event->data, &fib_event->fib6_event, 888 fib_event->event); 889 nsim_fib6_event_fini(&fib_event->fib6_event); 890 break; 891 } 892 } 893 894 static int nsim_fib4_prepare_event(struct fib_notifier_info *info, 895 struct nsim_fib_event *fib_event, 896 unsigned long event) 897 { 898 struct nsim_fib_data *data = fib_event->data; 899 struct fib_entry_notifier_info *fen_info; 900 struct netlink_ext_ack *extack; 901 int err = 0; 902 903 fen_info = container_of(info, struct fib_entry_notifier_info, 904 info); 905 fib_event->fen_info = *fen_info; 906 extack = info->extack; 907 908 switch (event) { 909 case FIB_EVENT_ENTRY_REPLACE: 910 err = nsim_fib_account(&data->ipv4.fib, true); 911 if (err) { 912 NL_SET_ERR_MSG_MOD(extack, "Exceeded number of supported fib entries"); 913 return err; 914 } 915 break; 916 case FIB_EVENT_ENTRY_DEL: 917 nsim_fib_account(&data->ipv4.fib, false); 918 break; 919 } 920 921 /* Take reference on fib_info to prevent it from being 922 * freed while event is queued. Release it afterwards. 923 */ 924 fib_info_hold(fib_event->fen_info.fi); 925 926 return 0; 927 } 928 929 static int nsim_fib6_prepare_event(struct fib_notifier_info *info, 930 struct nsim_fib_event *fib_event, 931 unsigned long event) 932 { 933 struct nsim_fib_data *data = fib_event->data; 934 struct fib6_entry_notifier_info *fen6_info; 935 struct netlink_ext_ack *extack; 936 int err = 0; 937 938 fen6_info = container_of(info, struct fib6_entry_notifier_info, 939 info); 940 941 err = nsim_fib6_event_init(&fib_event->fib6_event, fen6_info); 942 if (err) 943 return err; 944 945 extack = info->extack; 946 switch (event) { 947 case FIB_EVENT_ENTRY_REPLACE: 948 err = nsim_fib_account(&data->ipv6.fib, true); 949 if (err) { 950 NL_SET_ERR_MSG_MOD(extack, "Exceeded number of supported fib entries"); 951 goto err_fib6_event_fini; 952 } 953 break; 954 case FIB_EVENT_ENTRY_DEL: 955 nsim_fib_account(&data->ipv6.fib, false); 956 break; 957 } 958 959 return 0; 960 961 err_fib6_event_fini: 962 nsim_fib6_event_fini(&fib_event->fib6_event); 963 return err; 964 } 965 966 static int nsim_fib_event_schedule_work(struct nsim_fib_data *data, 967 struct fib_notifier_info *info, 968 unsigned long event) 969 { 970 struct nsim_fib_event *fib_event; 971 int err; 972 973 if (info->family != AF_INET && info->family != AF_INET6) 974 /* netdevsim does not support 'RTNL_FAMILY_IP6MR' and 975 * 'RTNL_FAMILY_IPMR' and should ignore them. 976 */ 977 return NOTIFY_DONE; 978 979 fib_event = kzalloc(sizeof(*fib_event), GFP_ATOMIC); 980 if (!fib_event) 981 return NOTIFY_BAD; 982 983 fib_event->data = data; 984 fib_event->event = event; 985 fib_event->family = info->family; 986 987 switch (info->family) { 988 case AF_INET: 989 err = nsim_fib4_prepare_event(info, fib_event, event); 990 break; 991 case AF_INET6: 992 err = nsim_fib6_prepare_event(info, fib_event, event); 993 break; 994 } 995 996 if (err) 997 goto err_fib_prepare_event; 998 999 /* Enqueue the event and trigger the work */ 1000 spin_lock_bh(&data->fib_event_queue_lock); 1001 list_add_tail(&fib_event->list, &data->fib_event_queue); 1002 spin_unlock_bh(&data->fib_event_queue_lock); 1003 schedule_work(&data->fib_event_work); 1004 1005 return NOTIFY_DONE; 1006 1007 err_fib_prepare_event: 1008 kfree(fib_event); 1009 return NOTIFY_BAD; 1010 } 1011 1012 static int nsim_fib_event_nb(struct notifier_block *nb, unsigned long event, 1013 void *ptr) 1014 { 1015 struct nsim_fib_data *data = container_of(nb, struct nsim_fib_data, 1016 fib_nb); 1017 struct fib_notifier_info *info = ptr; 1018 int err; 1019 1020 switch (event) { 1021 case FIB_EVENT_RULE_ADD: 1022 case FIB_EVENT_RULE_DEL: 1023 err = nsim_fib_rule_event(data, info, 1024 event == FIB_EVENT_RULE_ADD); 1025 return notifier_from_errno(err); 1026 case FIB_EVENT_ENTRY_REPLACE: 1027 case FIB_EVENT_ENTRY_APPEND: 1028 case FIB_EVENT_ENTRY_DEL: 1029 return nsim_fib_event_schedule_work(data, info, event); 1030 } 1031 1032 return NOTIFY_DONE; 1033 } 1034 1035 static void nsim_fib4_rt_free(struct nsim_fib_rt *fib_rt, 1036 struct nsim_fib_data *data) 1037 { 1038 struct devlink *devlink = data->devlink; 1039 struct nsim_fib4_rt *fib4_rt; 1040 1041 fib4_rt = container_of(fib_rt, struct nsim_fib4_rt, common); 1042 nsim_fib4_rt_hw_flags_set(devlink_net(devlink), fib4_rt, false); 1043 nsim_fib_account(&data->ipv4.fib, false); 1044 nsim_fib4_rt_destroy(fib4_rt); 1045 } 1046 1047 static void nsim_fib6_rt_free(struct nsim_fib_rt *fib_rt, 1048 struct nsim_fib_data *data) 1049 { 1050 struct nsim_fib6_rt *fib6_rt; 1051 1052 fib6_rt = container_of(fib_rt, struct nsim_fib6_rt, common); 1053 nsim_fib6_rt_hw_flags_set(data, fib6_rt, false); 1054 nsim_fib_account(&data->ipv6.fib, false); 1055 nsim_fib6_rt_destroy(fib6_rt); 1056 } 1057 1058 static void nsim_fib_rt_free(void *ptr, void *arg) 1059 { 1060 struct nsim_fib_rt *fib_rt = ptr; 1061 struct nsim_fib_data *data = arg; 1062 1063 switch (fib_rt->key.family) { 1064 case AF_INET: 1065 nsim_fib4_rt_free(fib_rt, data); 1066 break; 1067 case AF_INET6: 1068 nsim_fib6_rt_free(fib_rt, data); 1069 break; 1070 default: 1071 WARN_ON_ONCE(1); 1072 } 1073 } 1074 1075 /* inconsistent dump, trying again */ 1076 static void nsim_fib_dump_inconsistent(struct notifier_block *nb) 1077 { 1078 struct nsim_fib_data *data = container_of(nb, struct nsim_fib_data, 1079 fib_nb); 1080 struct nsim_fib_rt *fib_rt, *fib_rt_tmp; 1081 1082 /* Flush the work to make sure there is no race with notifications. */ 1083 flush_work(&data->fib_event_work); 1084 1085 /* The notifier block is still not registered, so we do not need to 1086 * take any locks here. 1087 */ 1088 list_for_each_entry_safe(fib_rt, fib_rt_tmp, &data->fib_rt_list, list) { 1089 rhashtable_remove_fast(&data->fib_rt_ht, &fib_rt->ht_node, 1090 nsim_fib_rt_ht_params); 1091 nsim_fib_rt_free(fib_rt, data); 1092 } 1093 1094 atomic64_set(&data->ipv4.rules.num, 0ULL); 1095 atomic64_set(&data->ipv6.rules.num, 0ULL); 1096 } 1097 1098 static struct nsim_nexthop *nsim_nexthop_create(struct nsim_fib_data *data, 1099 struct nh_notifier_info *info) 1100 { 1101 struct nsim_nexthop *nexthop; 1102 u64 occ = 0; 1103 int i; 1104 1105 nexthop = kzalloc(sizeof(*nexthop), GFP_KERNEL); 1106 if (!nexthop) 1107 return ERR_PTR(-ENOMEM); 1108 1109 nexthop->id = info->id; 1110 1111 /* Determine the number of nexthop entries the new nexthop will 1112 * occupy. 1113 */ 1114 1115 switch (info->type) { 1116 case NH_NOTIFIER_INFO_TYPE_SINGLE: 1117 occ = 1; 1118 break; 1119 case NH_NOTIFIER_INFO_TYPE_GRP: 1120 for (i = 0; i < info->nh_grp->num_nh; i++) 1121 occ += info->nh_grp->nh_entries[i].weight; 1122 break; 1123 case NH_NOTIFIER_INFO_TYPE_RES_TABLE: 1124 occ = info->nh_res_table->num_nh_buckets; 1125 nexthop->is_resilient = true; 1126 break; 1127 default: 1128 NL_SET_ERR_MSG_MOD(info->extack, "Unsupported nexthop type"); 1129 kfree(nexthop); 1130 return ERR_PTR(-EOPNOTSUPP); 1131 } 1132 1133 nexthop->occ = occ; 1134 return nexthop; 1135 } 1136 1137 static void nsim_nexthop_destroy(struct nsim_nexthop *nexthop) 1138 { 1139 kfree(nexthop); 1140 } 1141 1142 static int nsim_nexthop_account(struct nsim_fib_data *data, u64 occ, 1143 bool add, struct netlink_ext_ack *extack) 1144 { 1145 int i, err = 0; 1146 1147 if (add) { 1148 for (i = 0; i < occ; i++) 1149 if (!atomic64_add_unless(&data->nexthops.num, 1, 1150 data->nexthops.max)) { 1151 err = -ENOSPC; 1152 NL_SET_ERR_MSG_MOD(extack, "Exceeded number of supported nexthops"); 1153 goto err_num_decrease; 1154 } 1155 } else { 1156 if (WARN_ON(occ > atomic64_read(&data->nexthops.num))) 1157 return -EINVAL; 1158 atomic64_sub(occ, &data->nexthops.num); 1159 } 1160 1161 return err; 1162 1163 err_num_decrease: 1164 atomic64_sub(i, &data->nexthops.num); 1165 return err; 1166 1167 } 1168 1169 static void nsim_nexthop_hw_flags_set(struct net *net, 1170 const struct nsim_nexthop *nexthop, 1171 bool trap) 1172 { 1173 int i; 1174 1175 nexthop_set_hw_flags(net, nexthop->id, false, trap); 1176 1177 if (!nexthop->is_resilient) 1178 return; 1179 1180 for (i = 0; i < nexthop->occ; i++) 1181 nexthop_bucket_set_hw_flags(net, nexthop->id, i, false, trap); 1182 } 1183 1184 static int nsim_nexthop_add(struct nsim_fib_data *data, 1185 struct nsim_nexthop *nexthop, 1186 struct netlink_ext_ack *extack) 1187 { 1188 struct net *net = devlink_net(data->devlink); 1189 int err; 1190 1191 err = nsim_nexthop_account(data, nexthop->occ, true, extack); 1192 if (err) 1193 return err; 1194 1195 err = rhashtable_insert_fast(&data->nexthop_ht, &nexthop->ht_node, 1196 nsim_nexthop_ht_params); 1197 if (err) { 1198 NL_SET_ERR_MSG_MOD(extack, "Failed to insert nexthop"); 1199 goto err_nexthop_dismiss; 1200 } 1201 1202 nsim_nexthop_hw_flags_set(net, nexthop, true); 1203 1204 return 0; 1205 1206 err_nexthop_dismiss: 1207 nsim_nexthop_account(data, nexthop->occ, false, extack); 1208 return err; 1209 } 1210 1211 static int nsim_nexthop_replace(struct nsim_fib_data *data, 1212 struct nsim_nexthop *nexthop, 1213 struct nsim_nexthop *nexthop_old, 1214 struct netlink_ext_ack *extack) 1215 { 1216 struct net *net = devlink_net(data->devlink); 1217 int err; 1218 1219 err = nsim_nexthop_account(data, nexthop->occ, true, extack); 1220 if (err) 1221 return err; 1222 1223 err = rhashtable_replace_fast(&data->nexthop_ht, 1224 &nexthop_old->ht_node, &nexthop->ht_node, 1225 nsim_nexthop_ht_params); 1226 if (err) { 1227 NL_SET_ERR_MSG_MOD(extack, "Failed to replace nexthop"); 1228 goto err_nexthop_dismiss; 1229 } 1230 1231 nsim_nexthop_hw_flags_set(net, nexthop, true); 1232 nsim_nexthop_account(data, nexthop_old->occ, false, extack); 1233 nsim_nexthop_destroy(nexthop_old); 1234 1235 return 0; 1236 1237 err_nexthop_dismiss: 1238 nsim_nexthop_account(data, nexthop->occ, false, extack); 1239 return err; 1240 } 1241 1242 static int nsim_nexthop_insert(struct nsim_fib_data *data, 1243 struct nh_notifier_info *info) 1244 { 1245 struct nsim_nexthop *nexthop, *nexthop_old; 1246 int err; 1247 1248 nexthop = nsim_nexthop_create(data, info); 1249 if (IS_ERR(nexthop)) 1250 return PTR_ERR(nexthop); 1251 1252 nexthop_old = rhashtable_lookup_fast(&data->nexthop_ht, &info->id, 1253 nsim_nexthop_ht_params); 1254 if (!nexthop_old) 1255 err = nsim_nexthop_add(data, nexthop, info->extack); 1256 else 1257 err = nsim_nexthop_replace(data, nexthop, nexthop_old, 1258 info->extack); 1259 1260 if (err) 1261 nsim_nexthop_destroy(nexthop); 1262 1263 return err; 1264 } 1265 1266 static void nsim_nexthop_remove(struct nsim_fib_data *data, 1267 struct nh_notifier_info *info) 1268 { 1269 struct nsim_nexthop *nexthop; 1270 1271 nexthop = rhashtable_lookup_fast(&data->nexthop_ht, &info->id, 1272 nsim_nexthop_ht_params); 1273 if (!nexthop) 1274 return; 1275 1276 rhashtable_remove_fast(&data->nexthop_ht, &nexthop->ht_node, 1277 nsim_nexthop_ht_params); 1278 nsim_nexthop_account(data, nexthop->occ, false, info->extack); 1279 nsim_nexthop_destroy(nexthop); 1280 } 1281 1282 static int nsim_nexthop_res_table_pre_replace(struct nsim_fib_data *data, 1283 struct nh_notifier_info *info) 1284 { 1285 if (data->fail_res_nexthop_group_replace) { 1286 NL_SET_ERR_MSG_MOD(info->extack, "Failed to replace a resilient nexthop group"); 1287 return -EINVAL; 1288 } 1289 1290 return 0; 1291 } 1292 1293 static int nsim_nexthop_bucket_replace(struct nsim_fib_data *data, 1294 struct nh_notifier_info *info) 1295 { 1296 if (data->fail_nexthop_bucket_replace) { 1297 NL_SET_ERR_MSG_MOD(info->extack, "Failed to replace nexthop bucket"); 1298 return -EINVAL; 1299 } 1300 1301 nexthop_bucket_set_hw_flags(info->net, info->id, 1302 info->nh_res_bucket->bucket_index, 1303 false, true); 1304 1305 return 0; 1306 } 1307 1308 static int nsim_nexthop_event_nb(struct notifier_block *nb, unsigned long event, 1309 void *ptr) 1310 { 1311 struct nsim_fib_data *data = container_of(nb, struct nsim_fib_data, 1312 nexthop_nb); 1313 struct nh_notifier_info *info = ptr; 1314 int err = 0; 1315 1316 mutex_lock(&data->nh_lock); 1317 switch (event) { 1318 case NEXTHOP_EVENT_REPLACE: 1319 err = nsim_nexthop_insert(data, info); 1320 break; 1321 case NEXTHOP_EVENT_DEL: 1322 nsim_nexthop_remove(data, info); 1323 break; 1324 case NEXTHOP_EVENT_RES_TABLE_PRE_REPLACE: 1325 err = nsim_nexthop_res_table_pre_replace(data, info); 1326 break; 1327 case NEXTHOP_EVENT_BUCKET_REPLACE: 1328 err = nsim_nexthop_bucket_replace(data, info); 1329 break; 1330 default: 1331 break; 1332 } 1333 1334 mutex_unlock(&data->nh_lock); 1335 return notifier_from_errno(err); 1336 } 1337 1338 static void nsim_nexthop_free(void *ptr, void *arg) 1339 { 1340 struct nsim_nexthop *nexthop = ptr; 1341 struct nsim_fib_data *data = arg; 1342 struct net *net; 1343 1344 net = devlink_net(data->devlink); 1345 nsim_nexthop_hw_flags_set(net, nexthop, false); 1346 nsim_nexthop_account(data, nexthop->occ, false, NULL); 1347 nsim_nexthop_destroy(nexthop); 1348 } 1349 1350 static ssize_t nsim_nexthop_bucket_activity_write(struct file *file, 1351 const char __user *user_buf, 1352 size_t size, loff_t *ppos) 1353 { 1354 struct nsim_fib_data *data = file->private_data; 1355 struct net *net = devlink_net(data->devlink); 1356 struct nsim_nexthop *nexthop; 1357 unsigned long *activity; 1358 loff_t pos = *ppos; 1359 u16 bucket_index; 1360 char buf[128]; 1361 int err = 0; 1362 u32 nhid; 1363 1364 if (pos != 0) 1365 return -EINVAL; 1366 if (size > sizeof(buf)) 1367 return -EINVAL; 1368 if (copy_from_user(buf, user_buf, size)) 1369 return -EFAULT; 1370 if (sscanf(buf, "%u %hu", &nhid, &bucket_index) != 2) 1371 return -EINVAL; 1372 1373 rtnl_lock(); 1374 1375 nexthop = rhashtable_lookup_fast(&data->nexthop_ht, &nhid, 1376 nsim_nexthop_ht_params); 1377 if (!nexthop || !nexthop->is_resilient || 1378 bucket_index >= nexthop->occ) { 1379 err = -EINVAL; 1380 goto out; 1381 } 1382 1383 activity = bitmap_zalloc(nexthop->occ, GFP_KERNEL); 1384 if (!activity) { 1385 err = -ENOMEM; 1386 goto out; 1387 } 1388 1389 bitmap_set(activity, bucket_index, 1); 1390 nexthop_res_grp_activity_update(net, nhid, nexthop->occ, activity); 1391 bitmap_free(activity); 1392 1393 out: 1394 rtnl_unlock(); 1395 1396 *ppos = size; 1397 return err ?: size; 1398 } 1399 1400 static const struct file_operations nsim_nexthop_bucket_activity_fops = { 1401 .open = simple_open, 1402 .write = nsim_nexthop_bucket_activity_write, 1403 .llseek = no_llseek, 1404 .owner = THIS_MODULE, 1405 }; 1406 1407 static u64 nsim_fib_ipv4_resource_occ_get(void *priv) 1408 { 1409 struct nsim_fib_data *data = priv; 1410 1411 return nsim_fib_get_val(data, NSIM_RESOURCE_IPV4_FIB, false); 1412 } 1413 1414 static u64 nsim_fib_ipv4_rules_res_occ_get(void *priv) 1415 { 1416 struct nsim_fib_data *data = priv; 1417 1418 return nsim_fib_get_val(data, NSIM_RESOURCE_IPV4_FIB_RULES, false); 1419 } 1420 1421 static u64 nsim_fib_ipv6_resource_occ_get(void *priv) 1422 { 1423 struct nsim_fib_data *data = priv; 1424 1425 return nsim_fib_get_val(data, NSIM_RESOURCE_IPV6_FIB, false); 1426 } 1427 1428 static u64 nsim_fib_ipv6_rules_res_occ_get(void *priv) 1429 { 1430 struct nsim_fib_data *data = priv; 1431 1432 return nsim_fib_get_val(data, NSIM_RESOURCE_IPV6_FIB_RULES, false); 1433 } 1434 1435 static u64 nsim_fib_nexthops_res_occ_get(void *priv) 1436 { 1437 struct nsim_fib_data *data = priv; 1438 1439 return nsim_fib_get_val(data, NSIM_RESOURCE_NEXTHOPS, false); 1440 } 1441 1442 static void nsim_fib_set_max_all(struct nsim_fib_data *data, 1443 struct devlink *devlink) 1444 { 1445 static const enum nsim_resource_id res_ids[] = { 1446 NSIM_RESOURCE_IPV4_FIB, NSIM_RESOURCE_IPV4_FIB_RULES, 1447 NSIM_RESOURCE_IPV6_FIB, NSIM_RESOURCE_IPV6_FIB_RULES, 1448 NSIM_RESOURCE_NEXTHOPS, 1449 }; 1450 int i; 1451 1452 for (i = 0; i < ARRAY_SIZE(res_ids); i++) { 1453 int err; 1454 u64 val; 1455 1456 err = devlink_resource_size_get(devlink, res_ids[i], &val); 1457 if (err) 1458 val = (u64) -1; 1459 nsim_fib_set_max(data, res_ids[i], val); 1460 } 1461 } 1462 1463 static void nsim_fib_event_work(struct work_struct *work) 1464 { 1465 struct nsim_fib_data *data = container_of(work, struct nsim_fib_data, 1466 fib_event_work); 1467 struct nsim_fib_event *fib_event, *next_fib_event; 1468 1469 LIST_HEAD(fib_event_queue); 1470 1471 spin_lock_bh(&data->fib_event_queue_lock); 1472 list_splice_init(&data->fib_event_queue, &fib_event_queue); 1473 spin_unlock_bh(&data->fib_event_queue_lock); 1474 1475 mutex_lock(&data->fib_lock); 1476 list_for_each_entry_safe(fib_event, next_fib_event, &fib_event_queue, 1477 list) { 1478 nsim_fib_event(fib_event); 1479 list_del(&fib_event->list); 1480 kfree(fib_event); 1481 cond_resched(); 1482 } 1483 mutex_unlock(&data->fib_lock); 1484 } 1485 1486 static int 1487 nsim_fib_debugfs_init(struct nsim_fib_data *data, struct nsim_dev *nsim_dev) 1488 { 1489 data->ddir = debugfs_create_dir("fib", nsim_dev->ddir); 1490 if (IS_ERR(data->ddir)) 1491 return PTR_ERR(data->ddir); 1492 1493 data->fail_route_offload = false; 1494 debugfs_create_bool("fail_route_offload", 0600, data->ddir, 1495 &data->fail_route_offload); 1496 1497 data->fail_res_nexthop_group_replace = false; 1498 debugfs_create_bool("fail_res_nexthop_group_replace", 0600, data->ddir, 1499 &data->fail_res_nexthop_group_replace); 1500 1501 data->fail_nexthop_bucket_replace = false; 1502 debugfs_create_bool("fail_nexthop_bucket_replace", 0600, data->ddir, 1503 &data->fail_nexthop_bucket_replace); 1504 1505 debugfs_create_file("nexthop_bucket_activity", 0200, data->ddir, 1506 data, &nsim_nexthop_bucket_activity_fops); 1507 return 0; 1508 } 1509 1510 static void nsim_fib_debugfs_exit(struct nsim_fib_data *data) 1511 { 1512 debugfs_remove_recursive(data->ddir); 1513 } 1514 1515 struct nsim_fib_data *nsim_fib_create(struct devlink *devlink, 1516 struct netlink_ext_ack *extack) 1517 { 1518 struct nsim_fib_data *data; 1519 struct nsim_dev *nsim_dev; 1520 int err; 1521 1522 data = kzalloc(sizeof(*data), GFP_KERNEL); 1523 if (!data) 1524 return ERR_PTR(-ENOMEM); 1525 data->devlink = devlink; 1526 1527 nsim_dev = devlink_priv(devlink); 1528 err = nsim_fib_debugfs_init(data, nsim_dev); 1529 if (err) 1530 goto err_data_free; 1531 1532 mutex_init(&data->nh_lock); 1533 err = rhashtable_init(&data->nexthop_ht, &nsim_nexthop_ht_params); 1534 if (err) 1535 goto err_debugfs_exit; 1536 1537 mutex_init(&data->fib_lock); 1538 INIT_LIST_HEAD(&data->fib_rt_list); 1539 err = rhashtable_init(&data->fib_rt_ht, &nsim_fib_rt_ht_params); 1540 if (err) 1541 goto err_rhashtable_nexthop_destroy; 1542 1543 INIT_WORK(&data->fib_event_work, nsim_fib_event_work); 1544 INIT_LIST_HEAD(&data->fib_event_queue); 1545 spin_lock_init(&data->fib_event_queue_lock); 1546 1547 nsim_fib_set_max_all(data, devlink); 1548 1549 data->nexthop_nb.notifier_call = nsim_nexthop_event_nb; 1550 err = register_nexthop_notifier(devlink_net(devlink), &data->nexthop_nb, 1551 extack); 1552 if (err) { 1553 pr_err("Failed to register nexthop notifier\n"); 1554 goto err_rhashtable_fib_destroy; 1555 } 1556 1557 data->fib_nb.notifier_call = nsim_fib_event_nb; 1558 err = register_fib_notifier(devlink_net(devlink), &data->fib_nb, 1559 nsim_fib_dump_inconsistent, extack); 1560 if (err) { 1561 pr_err("Failed to register fib notifier\n"); 1562 goto err_nexthop_nb_unregister; 1563 } 1564 1565 devlink_resource_occ_get_register(devlink, 1566 NSIM_RESOURCE_IPV4_FIB, 1567 nsim_fib_ipv4_resource_occ_get, 1568 data); 1569 devlink_resource_occ_get_register(devlink, 1570 NSIM_RESOURCE_IPV4_FIB_RULES, 1571 nsim_fib_ipv4_rules_res_occ_get, 1572 data); 1573 devlink_resource_occ_get_register(devlink, 1574 NSIM_RESOURCE_IPV6_FIB, 1575 nsim_fib_ipv6_resource_occ_get, 1576 data); 1577 devlink_resource_occ_get_register(devlink, 1578 NSIM_RESOURCE_IPV6_FIB_RULES, 1579 nsim_fib_ipv6_rules_res_occ_get, 1580 data); 1581 devlink_resource_occ_get_register(devlink, 1582 NSIM_RESOURCE_NEXTHOPS, 1583 nsim_fib_nexthops_res_occ_get, 1584 data); 1585 return data; 1586 1587 err_nexthop_nb_unregister: 1588 unregister_nexthop_notifier(devlink_net(devlink), &data->nexthop_nb); 1589 err_rhashtable_fib_destroy: 1590 flush_work(&data->fib_event_work); 1591 rhashtable_free_and_destroy(&data->fib_rt_ht, nsim_fib_rt_free, 1592 data); 1593 err_rhashtable_nexthop_destroy: 1594 rhashtable_free_and_destroy(&data->nexthop_ht, nsim_nexthop_free, 1595 data); 1596 mutex_destroy(&data->fib_lock); 1597 err_debugfs_exit: 1598 mutex_destroy(&data->nh_lock); 1599 nsim_fib_debugfs_exit(data); 1600 err_data_free: 1601 kfree(data); 1602 return ERR_PTR(err); 1603 } 1604 1605 void nsim_fib_destroy(struct devlink *devlink, struct nsim_fib_data *data) 1606 { 1607 devlink_resource_occ_get_unregister(devlink, 1608 NSIM_RESOURCE_NEXTHOPS); 1609 devlink_resource_occ_get_unregister(devlink, 1610 NSIM_RESOURCE_IPV6_FIB_RULES); 1611 devlink_resource_occ_get_unregister(devlink, 1612 NSIM_RESOURCE_IPV6_FIB); 1613 devlink_resource_occ_get_unregister(devlink, 1614 NSIM_RESOURCE_IPV4_FIB_RULES); 1615 devlink_resource_occ_get_unregister(devlink, 1616 NSIM_RESOURCE_IPV4_FIB); 1617 unregister_fib_notifier(devlink_net(devlink), &data->fib_nb); 1618 unregister_nexthop_notifier(devlink_net(devlink), &data->nexthop_nb); 1619 flush_work(&data->fib_event_work); 1620 rhashtable_free_and_destroy(&data->fib_rt_ht, nsim_fib_rt_free, 1621 data); 1622 rhashtable_free_and_destroy(&data->nexthop_ht, nsim_nexthop_free, 1623 data); 1624 WARN_ON_ONCE(!list_empty(&data->fib_event_queue)); 1625 WARN_ON_ONCE(!list_empty(&data->fib_rt_list)); 1626 mutex_destroy(&data->fib_lock); 1627 mutex_destroy(&data->nh_lock); 1628 nsim_fib_debugfs_exit(data); 1629 kfree(data); 1630 } 1631