drivers/net/netdevsim/fib.c

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