drivers/net/netdevsim/dev.c

   1 /*
   2  * Copyright (c) 2018 Cumulus Networks. All rights reserved.
   3  * Copyright (c) 2018 David Ahern <[email protected]>
   4  * Copyright (c) 2019 Mellanox Technologies. All rights reserved.
   5  *
   6  * This software is licensed under the GNU General License Version 2,
   7  * June 1991 as shown in the file COPYING in the top-level directory of this
   8  * source tree.
   9  *
  10  * THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS"
  11  * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
  12  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  13  * FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE
  14  * OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME
  15  * THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
  16  */
  17
  18 #include <linux/debugfs.h>
  19 #include <linux/device.h>
  20 #include <linux/etherdevice.h>
  21 #include <linux/inet.h>
  22 #include <linux/jiffies.h>
  23 #include <linux/kernel.h>
  24 #include <linux/list.h>
  25 #include <linux/mutex.h>
  26 #include <linux/random.h>
  27 #include <linux/rtnetlink.h>
  28 #include <linux/workqueue.h>
  29 #include <net/devlink.h>
  30 #include <net/ip.h>
  31 #include <net/flow_offload.h>
  32 #include <uapi/linux/devlink.h>
  33 #include <uapi/linux/ip.h>
  34 #include <uapi/linux/udp.h>
  35
  36 #include "netdevsim.h"
  37
  38 static unsigned int
  39 nsim_dev_port_index(enum nsim_dev_port_type type, unsigned int port_index)
  40 {
  41         switch (type) {
  42         case NSIM_DEV_PORT_TYPE_VF:
  43                 port_index = NSIM_DEV_VF_PORT_INDEX_BASE + port_index;
  44                 break;
  45         case NSIM_DEV_PORT_TYPE_PF:
  46                 break;
  47         }
  48
  49         return port_index;
  50 }
  51
  52 static inline unsigned int nsim_dev_port_index_to_vf_index(unsigned int port_index)
  53 {
  54         return port_index - NSIM_DEV_VF_PORT_INDEX_BASE;
  55 }
  56
  57 static struct dentry *nsim_dev_ddir;
  58
  59 #define NSIM_DEV_DUMMY_REGION_SIZE (1024 * 32)
  60
  61 static int
  62 nsim_dev_take_snapshot(struct devlink *devlink,
  63                        const struct devlink_region_ops *ops,
  64                        struct netlink_ext_ack *extack,
  65                        u8 **data)
  66 {
  67         void *dummy_data;
  68
  69         dummy_data = kmalloc(NSIM_DEV_DUMMY_REGION_SIZE, GFP_KERNEL);
  70         if (!dummy_data)
  71                 return -ENOMEM;
  72
  73         get_random_bytes(dummy_data, NSIM_DEV_DUMMY_REGION_SIZE);
  74
  75         *data = dummy_data;
  76
  77         return 0;
  78 }
  79
  80 static ssize_t nsim_dev_take_snapshot_write(struct file *file,
  81                                             const char __user *data,
  82                                             size_t count, loff_t *ppos)
  83 {
  84         struct nsim_dev *nsim_dev = file->private_data;
  85         struct devlink *devlink;
  86         u8 *dummy_data;
  87         int err;
  88         u32 id;
  89
  90         devlink = priv_to_devlink(nsim_dev);
  91
  92         err = nsim_dev_take_snapshot(devlink, NULL, NULL, &dummy_data);
  93         if (err)
  94                 return err;
  95
  96         err = devlink_region_snapshot_id_get(devlink, &id);
  97         if (err) {
  98                 pr_err("Failed to get snapshot id\n");
  99                 kfree(dummy_data);
 100                 return err;
 101         }
 102         err = devlink_region_snapshot_create(nsim_dev->dummy_region,
 103                                              dummy_data, id);
 104         devlink_region_snapshot_id_put(devlink, id);
 105         if (err) {
 106                 pr_err("Failed to create region snapshot\n");
 107                 kfree(dummy_data);
 108                 return err;
 109         }
 110
 111         return count;
 112 }
 113
 114 static const struct file_operations nsim_dev_take_snapshot_fops = {
 115         .open = simple_open,
 116         .write = nsim_dev_take_snapshot_write,
 117         .llseek = generic_file_llseek,
 118         .owner = THIS_MODULE,
 119 };
 120
 121 static ssize_t nsim_dev_trap_fa_cookie_read(struct file *file,
 122                                             char __user *data,
 123                                             size_t count, loff_t *ppos)
 124 {
 125         struct nsim_dev *nsim_dev = file->private_data;
 126         struct flow_action_cookie *fa_cookie;
 127         unsigned int buf_len;
 128         ssize_t ret;
 129         char *buf;
 130
 131         spin_lock(&nsim_dev->fa_cookie_lock);
 132         fa_cookie = nsim_dev->fa_cookie;
 133         if (!fa_cookie) {
 134                 ret = -EINVAL;
 135                 goto errout;
 136         }
 137         buf_len = fa_cookie->cookie_len * 2;
 138         buf = kmalloc(buf_len, GFP_ATOMIC);
 139         if (!buf) {
 140                 ret = -ENOMEM;
 141                 goto errout;
 142         }
 143         bin2hex(buf, fa_cookie->cookie, fa_cookie->cookie_len);
 144         spin_unlock(&nsim_dev->fa_cookie_lock);
 145
 146         ret = simple_read_from_buffer(data, count, ppos, buf, buf_len);
 147
 148         kfree(buf);
 149         return ret;
 150
 151 errout:
 152         spin_unlock(&nsim_dev->fa_cookie_lock);
 153         return ret;
 154 }
 155
 156 static ssize_t nsim_dev_trap_fa_cookie_write(struct file *file,
 157                                              const char __user *data,
 158                                              size_t count, loff_t *ppos)
 159 {
 160         struct nsim_dev *nsim_dev = file->private_data;
 161         struct flow_action_cookie *fa_cookie;
 162         size_t cookie_len;
 163         ssize_t ret;
 164         char *buf;
 165
 166         if (*ppos != 0)
 167                 return -EINVAL;
 168         cookie_len = (count - 1) / 2;
 169         if ((count - 1) % 2)
 170                 return -EINVAL;
 171         buf = kmalloc(count, GFP_KERNEL | __GFP_NOWARN);
 172         if (!buf)
 173                 return -ENOMEM;
 174
 175         ret = simple_write_to_buffer(buf, count, ppos, data, count);
 176         if (ret < 0)
 177                 goto free_buf;
 178
 179         fa_cookie = kmalloc(sizeof(*fa_cookie) + cookie_len,
 180                             GFP_KERNEL | __GFP_NOWARN);
 181         if (!fa_cookie) {
 182                 ret = -ENOMEM;
 183                 goto free_buf;
 184         }
 185
 186         fa_cookie->cookie_len = cookie_len;
 187         ret = hex2bin(fa_cookie->cookie, buf, cookie_len);
 188         if (ret)
 189                 goto free_fa_cookie;
 190         kfree(buf);
 191
 192         spin_lock(&nsim_dev->fa_cookie_lock);
 193         kfree(nsim_dev->fa_cookie);
 194         nsim_dev->fa_cookie = fa_cookie;
 195         spin_unlock(&nsim_dev->fa_cookie_lock);
 196
 197         return count;
 198
 199 free_fa_cookie:
 200         kfree(fa_cookie);
 201 free_buf:
 202         kfree(buf);
 203         return ret;
 204 }
 205
 206 static const struct file_operations nsim_dev_trap_fa_cookie_fops = {
 207         .open = simple_open,
 208         .read = nsim_dev_trap_fa_cookie_read,
 209         .write = nsim_dev_trap_fa_cookie_write,
 210         .llseek = generic_file_llseek,
 211         .owner = THIS_MODULE,
 212 };
 213
 214 static const struct file_operations nsim_dev_max_vfs_fops = {
 215         .open = simple_open,
 216         .read = nsim_bus_dev_max_vfs_read,
 217         .write = nsim_bus_dev_max_vfs_write,
 218         .llseek = generic_file_llseek,
 219         .owner = THIS_MODULE,
 220 };
 221
 222 static int nsim_dev_debugfs_init(struct nsim_dev *nsim_dev)
 223 {
 224         char dev_ddir_name[sizeof(DRV_NAME) + 10];
 225         int err;
 226
 227         sprintf(dev_ddir_name, DRV_NAME "%u", nsim_dev->nsim_bus_dev->dev.id);
 228         nsim_dev->ddir = debugfs_create_dir(dev_ddir_name, nsim_dev_ddir);
 229         if (IS_ERR(nsim_dev->ddir))
 230                 return PTR_ERR(nsim_dev->ddir);
 231         nsim_dev->ports_ddir = debugfs_create_dir("ports", nsim_dev->ddir);
 232         if (IS_ERR(nsim_dev->ports_ddir))
 233                 return PTR_ERR(nsim_dev->ports_ddir);
 234         debugfs_create_bool("fw_update_status", 0600, nsim_dev->ddir,
 235                             &nsim_dev->fw_update_status);
 236         debugfs_create_u32("fw_update_overwrite_mask", 0600, nsim_dev->ddir,
 237                             &nsim_dev->fw_update_overwrite_mask);
 238         debugfs_create_u32("max_macs", 0600, nsim_dev->ddir,
 239                            &nsim_dev->max_macs);
 240         debugfs_create_bool("test1", 0600, nsim_dev->ddir,
 241                             &nsim_dev->test1);
 242         nsim_dev->take_snapshot = debugfs_create_file("take_snapshot",
 243                                                       0200,
 244                                                       nsim_dev->ddir,
 245                                                       nsim_dev,
 246                                                 &nsim_dev_take_snapshot_fops);
 247         debugfs_create_bool("dont_allow_reload", 0600, nsim_dev->ddir,
 248                             &nsim_dev->dont_allow_reload);
 249         debugfs_create_bool("fail_reload", 0600, nsim_dev->ddir,
 250                             &nsim_dev->fail_reload);
 251         debugfs_create_file("trap_flow_action_cookie", 0600, nsim_dev->ddir,
 252                             nsim_dev, &nsim_dev_trap_fa_cookie_fops);
 253         debugfs_create_bool("fail_trap_group_set", 0600,
 254                             nsim_dev->ddir,
 255                             &nsim_dev->fail_trap_group_set);
 256         debugfs_create_bool("fail_trap_policer_set", 0600,
 257                             nsim_dev->ddir,
 258                             &nsim_dev->fail_trap_policer_set);
 259         debugfs_create_bool("fail_trap_policer_counter_get", 0600,
 260                             nsim_dev->ddir,
 261                             &nsim_dev->fail_trap_policer_counter_get);
 262         nsim_dev->max_vfs = debugfs_create_file("max_vfs",
 263                                                 0600,
 264                                                 nsim_dev->ddir,
 265                                                 nsim_dev->nsim_bus_dev,
 266                                                 &nsim_dev_max_vfs_fops);
 267         nsim_dev->nodes_ddir = debugfs_create_dir("rate_nodes", nsim_dev->ddir);
 268         if (IS_ERR(nsim_dev->nodes_ddir)) {
 269                 err = PTR_ERR(nsim_dev->nodes_ddir);
 270                 goto err_out;
 271         }
 272         debugfs_create_bool("fail_trap_drop_counter_get", 0600,
 273                             nsim_dev->ddir,
 274                             &nsim_dev->fail_trap_drop_counter_get);
 275         nsim_udp_tunnels_debugfs_create(nsim_dev);
 276         return 0;
 277
 278 err_out:
 279         debugfs_remove_recursive(nsim_dev->ports_ddir);
 280         debugfs_remove_recursive(nsim_dev->ddir);
 281         return err;
 282 }
 283
 284 static void nsim_dev_debugfs_exit(struct nsim_dev *nsim_dev)
 285 {
 286         debugfs_remove_recursive(nsim_dev->nodes_ddir);
 287         debugfs_remove_recursive(nsim_dev->ports_ddir);
 288         debugfs_remove_recursive(nsim_dev->ddir);
 289 }
 290
 291 static ssize_t nsim_dev_rate_parent_read(struct file *file,
 292                                          char __user *data,
 293                                          size_t count, loff_t *ppos)
 294 {
 295         char **name_ptr = file->private_data;
 296         size_t len;
 297
 298         if (!*name_ptr)
 299                 return 0;
 300
 301         len = strlen(*name_ptr);
 302         return simple_read_from_buffer(data, count, ppos, *name_ptr, len);
 303 }
 304
 305 static const struct file_operations nsim_dev_rate_parent_fops = {
 306         .open = simple_open,
 307         .read = nsim_dev_rate_parent_read,
 308         .llseek = generic_file_llseek,
 309         .owner = THIS_MODULE,
 310 };
 311
 312 static int nsim_dev_port_debugfs_init(struct nsim_dev *nsim_dev,
 313                                       struct nsim_dev_port *nsim_dev_port)
 314 {
 315         struct nsim_bus_dev *nsim_bus_dev = nsim_dev->nsim_bus_dev;
 316         unsigned int port_index = nsim_dev_port->port_index;
 317         char port_ddir_name[16];
 318         char dev_link_name[32];
 319
 320         sprintf(port_ddir_name, "%u", port_index);
 321         nsim_dev_port->ddir = debugfs_create_dir(port_ddir_name,
 322                                                  nsim_dev->ports_ddir);
 323         if (IS_ERR(nsim_dev_port->ddir))
 324                 return PTR_ERR(nsim_dev_port->ddir);
 325
 326         sprintf(dev_link_name, "../../../" DRV_NAME "%u", nsim_bus_dev->dev.id);
 327         if (nsim_dev_port_is_vf(nsim_dev_port)) {
 328                 unsigned int vf_id = nsim_dev_port_index_to_vf_index(port_index);
 329
 330                 debugfs_create_u16("tx_share", 0400, nsim_dev_port->ddir,
 331                                    &nsim_bus_dev->vfconfigs[vf_id].min_tx_rate);
 332                 debugfs_create_u16("tx_max", 0400, nsim_dev_port->ddir,
 333                                    &nsim_bus_dev->vfconfigs[vf_id].max_tx_rate);
 334                 nsim_dev_port->rate_parent = debugfs_create_file("rate_parent",
 335                                                                  0400,
 336                                                                  nsim_dev_port->ddir,
 337                                                                  &nsim_dev_port->parent_name,
 338                                                                  &nsim_dev_rate_parent_fops);
 339         }
 340         debugfs_create_symlink("dev", nsim_dev_port->ddir, dev_link_name);
 341
 342         return 0;
 343 }
 344
 345 static void nsim_dev_port_debugfs_exit(struct nsim_dev_port *nsim_dev_port)
 346 {
 347         debugfs_remove_recursive(nsim_dev_port->ddir);
 348 }
 349
 350 static int nsim_dev_resources_register(struct devlink *devlink)
 351 {
 352         struct devlink_resource_size_params params = {
 353                 .size_max = (u64)-1,
 354                 .size_granularity = 1,
 355                 .unit = DEVLINK_RESOURCE_UNIT_ENTRY
 356         };
 357         int err;
 358
 359         /* Resources for IPv4 */
 360         err = devlink_resource_register(devlink, "IPv4", (u64)-1,
 361                                         NSIM_RESOURCE_IPV4,
 362                                         DEVLINK_RESOURCE_ID_PARENT_TOP,
 363                                         &params);
 364         if (err) {
 365                 pr_err("Failed to register IPv4 top resource\n");
 366                 goto out;
 367         }
 368
 369         err = devlink_resource_register(devlink, "fib", (u64)-1,
 370                                         NSIM_RESOURCE_IPV4_FIB,
 371                                         NSIM_RESOURCE_IPV4, &params);
 372         if (err) {
 373                 pr_err("Failed to register IPv4 FIB resource\n");
 374                 return err;
 375         }
 376
 377         err = devlink_resource_register(devlink, "fib-rules", (u64)-1,
 378                                         NSIM_RESOURCE_IPV4_FIB_RULES,
 379                                         NSIM_RESOURCE_IPV4, &params);
 380         if (err) {
 381                 pr_err("Failed to register IPv4 FIB rules resource\n");
 382                 return err;
 383         }
 384
 385         /* Resources for IPv6 */
 386         err = devlink_resource_register(devlink, "IPv6", (u64)-1,
 387                                         NSIM_RESOURCE_IPV6,
 388                                         DEVLINK_RESOURCE_ID_PARENT_TOP,
 389                                         &params);
 390         if (err) {
 391                 pr_err("Failed to register IPv6 top resource\n");
 392                 goto out;
 393         }
 394
 395         err = devlink_resource_register(devlink, "fib", (u64)-1,
 396                                         NSIM_RESOURCE_IPV6_FIB,
 397                                         NSIM_RESOURCE_IPV6, &params);
 398         if (err) {
 399                 pr_err("Failed to register IPv6 FIB resource\n");
 400                 return err;
 401         }
 402
 403         err = devlink_resource_register(devlink, "fib-rules", (u64)-1,
 404                                         NSIM_RESOURCE_IPV6_FIB_RULES,
 405                                         NSIM_RESOURCE_IPV6, &params);
 406         if (err) {
 407                 pr_err("Failed to register IPv6 FIB rules resource\n");
 408                 return err;
 409         }
 410
 411         /* Resources for nexthops */
 412         err = devlink_resource_register(devlink, "nexthops", (u64)-1,
 413                                         NSIM_RESOURCE_NEXTHOPS,
 414                                         DEVLINK_RESOURCE_ID_PARENT_TOP,
 415                                         &params);
 416
 417 out:
 418         return err;
 419 }
 420
 421 enum nsim_devlink_param_id {
 422         NSIM_DEVLINK_PARAM_ID_BASE = DEVLINK_PARAM_GENERIC_ID_MAX,
 423         NSIM_DEVLINK_PARAM_ID_TEST1,
 424 };
 425
 426 static const struct devlink_param nsim_devlink_params[] = {
 427         DEVLINK_PARAM_GENERIC(MAX_MACS,
 428                               BIT(DEVLINK_PARAM_CMODE_DRIVERINIT),
 429                               NULL, NULL, NULL),
 430         DEVLINK_PARAM_DRIVER(NSIM_DEVLINK_PARAM_ID_TEST1,
 431                              "test1", DEVLINK_PARAM_TYPE_BOOL,
 432                              BIT(DEVLINK_PARAM_CMODE_DRIVERINIT),
 433                              NULL, NULL, NULL),
 434 };
 435
 436 static void nsim_devlink_set_params_init_values(struct nsim_dev *nsim_dev,
 437                                                 struct devlink *devlink)
 438 {
 439         union devlink_param_value value;
 440
 441         value.vu32 = nsim_dev->max_macs;
 442         devlink_param_driverinit_value_set(devlink,
 443                                            DEVLINK_PARAM_GENERIC_ID_MAX_MACS,
 444                                            value);
 445         value.vbool = nsim_dev->test1;
 446         devlink_param_driverinit_value_set(devlink,
 447                                            NSIM_DEVLINK_PARAM_ID_TEST1,
 448                                            value);
 449 }
 450
 451 static void nsim_devlink_param_load_driverinit_values(struct devlink *devlink)
 452 {
 453         struct nsim_dev *nsim_dev = devlink_priv(devlink);
 454         union devlink_param_value saved_value;
 455         int err;
 456
 457         err = devlink_param_driverinit_value_get(devlink,
 458                                                  DEVLINK_PARAM_GENERIC_ID_MAX_MACS,
 459                                                  &saved_value);
 460         if (!err)
 461                 nsim_dev->max_macs = saved_value.vu32;
 462         err = devlink_param_driverinit_value_get(devlink,
 463                                                  NSIM_DEVLINK_PARAM_ID_TEST1,
 464                                                  &saved_value);
 465         if (!err)
 466                 nsim_dev->test1 = saved_value.vbool;
 467 }
 468
 469 #define NSIM_DEV_DUMMY_REGION_SNAPSHOT_MAX 16
 470
 471 static const struct devlink_region_ops dummy_region_ops = {
 472         .name = "dummy",
 473         .destructor = &kfree,
 474         .snapshot = nsim_dev_take_snapshot,
 475 };
 476
 477 static int nsim_dev_dummy_region_init(struct nsim_dev *nsim_dev,
 478                                       struct devlink *devlink)
 479 {
 480         nsim_dev->dummy_region =
 481                 devlink_region_create(devlink, &dummy_region_ops,
 482                                       NSIM_DEV_DUMMY_REGION_SNAPSHOT_MAX,
 483                                       NSIM_DEV_DUMMY_REGION_SIZE);
 484         return PTR_ERR_OR_ZERO(nsim_dev->dummy_region);
 485 }
 486
 487 static void nsim_dev_dummy_region_exit(struct nsim_dev *nsim_dev)
 488 {
 489         devlink_region_destroy(nsim_dev->dummy_region);
 490 }
 491
 492 static void __nsim_dev_port_del(struct nsim_dev_port *nsim_dev_port);
 493 int nsim_esw_legacy_enable(struct nsim_dev *nsim_dev, struct netlink_ext_ack *extack)
 494 {
 495         struct devlink *devlink = priv_to_devlink(nsim_dev);
 496         struct nsim_dev_port *nsim_dev_port, *tmp;
 497
 498         devlink_rate_nodes_destroy(devlink);
 499         mutex_lock(&nsim_dev->port_list_lock);
 500         list_for_each_entry_safe(nsim_dev_port, tmp, &nsim_dev->port_list, list)
 501                 if (nsim_dev_port_is_vf(nsim_dev_port))
 502                         __nsim_dev_port_del(nsim_dev_port);
 503         mutex_unlock(&nsim_dev->port_list_lock);
 504         nsim_dev->esw_mode = DEVLINK_ESWITCH_MODE_LEGACY;
 505         return 0;
 506 }
 507
 508 int nsim_esw_switchdev_enable(struct nsim_dev *nsim_dev, struct netlink_ext_ack *extack)
 509 {
 510         struct nsim_bus_dev *nsim_bus_dev = nsim_dev->nsim_bus_dev;
 511         int i, err;
 512
 513         for (i = 0; i < nsim_bus_dev->num_vfs; i++) {
 514                 err = nsim_dev_port_add(nsim_bus_dev, NSIM_DEV_PORT_TYPE_VF, i);
 515                 if (err) {
 516                         NL_SET_ERR_MSG_MOD(extack, "Failed to initialize VFs' netdevsim ports");
 517                         pr_err("Failed to initialize VF id=%d. %d.\n", i, err);
 518                         goto err_port_add_vfs;
 519                 }
 520         }
 521         nsim_dev->esw_mode = DEVLINK_ESWITCH_MODE_SWITCHDEV;
 522         return 0;
 523
 524 err_port_add_vfs:
 525         for (i--; i >= 0; i--)
 526                 nsim_dev_port_del(nsim_bus_dev, NSIM_DEV_PORT_TYPE_VF, i);
 527         return err;
 528 }
 529
 530 static int nsim_devlink_eswitch_mode_set(struct devlink *devlink, u16 mode,
 531                                          struct netlink_ext_ack *extack)
 532 {
 533         struct nsim_dev *nsim_dev = devlink_priv(devlink);
 534         int err = 0;
 535
 536         mutex_lock(&nsim_dev->nsim_bus_dev->vfs_lock);
 537         if (mode == nsim_dev->esw_mode)
 538                 goto unlock;
 539
 540         if (mode == DEVLINK_ESWITCH_MODE_LEGACY)
 541                 err = nsim_esw_legacy_enable(nsim_dev, extack);
 542         else if (mode == DEVLINK_ESWITCH_MODE_SWITCHDEV)
 543                 err = nsim_esw_switchdev_enable(nsim_dev, extack);
 544         else
 545                 err = -EINVAL;
 546
 547 unlock:
 548         mutex_unlock(&nsim_dev->nsim_bus_dev->vfs_lock);
 549         return err;
 550 }
 551
 552 static int nsim_devlink_eswitch_mode_get(struct devlink *devlink, u16 *mode)
 553 {
 554         struct nsim_dev *nsim_dev = devlink_priv(devlink);
 555
 556         *mode = nsim_dev->esw_mode;
 557         return 0;
 558 }
 559
 560 struct nsim_trap_item {
 561         void *trap_ctx;
 562         enum devlink_trap_action action;
 563 };
 564
 565 struct nsim_trap_data {
 566         struct delayed_work trap_report_dw;
 567         struct nsim_trap_item *trap_items_arr;
 568         u64 *trap_policers_cnt_arr;
 569         u64 trap_pkt_cnt;
 570         struct nsim_dev *nsim_dev;
 571         spinlock_t trap_lock;   /* Protects trap_items_arr */
 572 };
 573
 574 /* All driver-specific traps must be documented in
 575  * Documentation/networking/devlink/netdevsim.rst
 576  */
 577 enum {
 578         NSIM_TRAP_ID_BASE = DEVLINK_TRAP_GENERIC_ID_MAX,
 579         NSIM_TRAP_ID_FID_MISS,
 580 };
 581
 582 #define NSIM_TRAP_NAME_FID_MISS "fid_miss"
 583
 584 #define NSIM_TRAP_METADATA DEVLINK_TRAP_METADATA_TYPE_F_IN_PORT
 585
 586 #define NSIM_TRAP_DROP(_id, _group_id)                                        \
 587         DEVLINK_TRAP_GENERIC(DROP, DROP, _id,                                 \
 588                              DEVLINK_TRAP_GROUP_GENERIC_ID_##_group_id,       \
 589                              NSIM_TRAP_METADATA)
 590 #define NSIM_TRAP_DROP_EXT(_id, _group_id, _metadata)                         \
 591         DEVLINK_TRAP_GENERIC(DROP, DROP, _id,                                 \
 592                              DEVLINK_TRAP_GROUP_GENERIC_ID_##_group_id,       \
 593                              NSIM_TRAP_METADATA | (_metadata))
 594 #define NSIM_TRAP_EXCEPTION(_id, _group_id)                                   \
 595         DEVLINK_TRAP_GENERIC(EXCEPTION, TRAP, _id,                            \
 596                              DEVLINK_TRAP_GROUP_GENERIC_ID_##_group_id,       \
 597                              NSIM_TRAP_METADATA)
 598 #define NSIM_TRAP_CONTROL(_id, _group_id, _action)                            \
 599         DEVLINK_TRAP_GENERIC(CONTROL, _action, _id,                           \
 600                              DEVLINK_TRAP_GROUP_GENERIC_ID_##_group_id,       \
 601                              NSIM_TRAP_METADATA)
 602 #define NSIM_TRAP_DRIVER_EXCEPTION(_id, _group_id)                            \
 603         DEVLINK_TRAP_DRIVER(EXCEPTION, TRAP, NSIM_TRAP_ID_##_id,              \
 604                             NSIM_TRAP_NAME_##_id,                             \
 605                             DEVLINK_TRAP_GROUP_GENERIC_ID_##_group_id,        \
 606                             NSIM_TRAP_METADATA)
 607
 608 #define NSIM_DEV_TRAP_POLICER_MIN_RATE  1
 609 #define NSIM_DEV_TRAP_POLICER_MAX_RATE  8000
 610 #define NSIM_DEV_TRAP_POLICER_MIN_BURST 8
 611 #define NSIM_DEV_TRAP_POLICER_MAX_BURST 65536
 612
 613 #define NSIM_TRAP_POLICER(_id, _rate, _burst)                                 \
 614         DEVLINK_TRAP_POLICER(_id, _rate, _burst,                              \
 615                              NSIM_DEV_TRAP_POLICER_MAX_RATE,                  \
 616                              NSIM_DEV_TRAP_POLICER_MIN_RATE,                  \
 617                              NSIM_DEV_TRAP_POLICER_MAX_BURST,                 \
 618                              NSIM_DEV_TRAP_POLICER_MIN_BURST)
 619
 620 static const struct devlink_trap_policer nsim_trap_policers_arr[] = {
 621         NSIM_TRAP_POLICER(1, 1000, 128),
 622         NSIM_TRAP_POLICER(2, 2000, 256),
 623         NSIM_TRAP_POLICER(3, 3000, 512),
 624 };
 625
 626 static const struct devlink_trap_group nsim_trap_groups_arr[] = {
 627         DEVLINK_TRAP_GROUP_GENERIC(L2_DROPS, 0),
 628         DEVLINK_TRAP_GROUP_GENERIC(L3_DROPS, 1),
 629         DEVLINK_TRAP_GROUP_GENERIC(L3_EXCEPTIONS, 1),
 630         DEVLINK_TRAP_GROUP_GENERIC(BUFFER_DROPS, 2),
 631         DEVLINK_TRAP_GROUP_GENERIC(ACL_DROPS, 3),
 632         DEVLINK_TRAP_GROUP_GENERIC(MC_SNOOPING, 3),
 633 };
 634
 635 static const struct devlink_trap nsim_traps_arr[] = {
 636         NSIM_TRAP_DROP(SMAC_MC, L2_DROPS),
 637         NSIM_TRAP_DROP(VLAN_TAG_MISMATCH, L2_DROPS),
 638         NSIM_TRAP_DROP(INGRESS_VLAN_FILTER, L2_DROPS),
 639         NSIM_TRAP_DROP(INGRESS_STP_FILTER, L2_DROPS),
 640         NSIM_TRAP_DROP(EMPTY_TX_LIST, L2_DROPS),
 641         NSIM_TRAP_DROP(PORT_LOOPBACK_FILTER, L2_DROPS),
 642         NSIM_TRAP_DRIVER_EXCEPTION(FID_MISS, L2_DROPS),
 643         NSIM_TRAP_DROP(BLACKHOLE_ROUTE, L3_DROPS),
 644         NSIM_TRAP_EXCEPTION(TTL_ERROR, L3_EXCEPTIONS),
 645         NSIM_TRAP_DROP(TAIL_DROP, BUFFER_DROPS),
 646         NSIM_TRAP_DROP_EXT(INGRESS_FLOW_ACTION_DROP, ACL_DROPS,
 647                            DEVLINK_TRAP_METADATA_TYPE_F_FA_COOKIE),
 648         NSIM_TRAP_DROP_EXT(EGRESS_FLOW_ACTION_DROP, ACL_DROPS,
 649                            DEVLINK_TRAP_METADATA_TYPE_F_FA_COOKIE),
 650         NSIM_TRAP_CONTROL(IGMP_QUERY, MC_SNOOPING, MIRROR),
 651         NSIM_TRAP_CONTROL(IGMP_V1_REPORT, MC_SNOOPING, TRAP),
 652 };
 653
 654 #define NSIM_TRAP_L4_DATA_LEN 100
 655
 656 static struct sk_buff *nsim_dev_trap_skb_build(void)
 657 {
 658         int tot_len, data_len = NSIM_TRAP_L4_DATA_LEN;
 659         struct sk_buff *skb;
 660         struct udphdr *udph;
 661         struct ethhdr *eth;
 662         struct iphdr *iph;
 663
 664         skb = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);
 665         if (!skb)
 666                 return NULL;
 667         tot_len = sizeof(struct iphdr) + sizeof(struct udphdr) + data_len;
 668
 669         skb_reset_mac_header(skb);
 670         eth = skb_put(skb, sizeof(struct ethhdr));
 671         eth_random_addr(eth->h_dest);
 672         eth_random_addr(eth->h_source);
 673         eth->h_proto = htons(ETH_P_IP);
 674         skb->protocol = htons(ETH_P_IP);
 675
 676         skb_set_network_header(skb, skb->len);
 677         iph = skb_put(skb, sizeof(struct iphdr));
 678         iph->protocol = IPPROTO_UDP;
 679         iph->saddr = in_aton("192.0.2.1");
 680         iph->daddr = in_aton("198.51.100.1");
 681         iph->version = 0x4;
 682         iph->frag_off = 0;
 683         iph->ihl = 0x5;
 684         iph->tot_len = htons(tot_len);
 685         iph->ttl = 100;
 686         iph->check = 0;
 687         iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
 688
 689         skb_set_transport_header(skb, skb->len);
 690         udph = skb_put_zero(skb, sizeof(struct udphdr) + data_len);
 691         get_random_bytes(&udph->source, sizeof(u16));
 692         get_random_bytes(&udph->dest, sizeof(u16));
 693         udph->len = htons(sizeof(struct udphdr) + data_len);
 694
 695         return skb;
 696 }
 697
 698 static void nsim_dev_trap_report(struct nsim_dev_port *nsim_dev_port)
 699 {
 700         struct nsim_dev *nsim_dev = nsim_dev_port->ns->nsim_dev;
 701         struct devlink *devlink = priv_to_devlink(nsim_dev);
 702         struct nsim_trap_data *nsim_trap_data;
 703         int i;
 704
 705         nsim_trap_data = nsim_dev->trap_data;
 706
 707         spin_lock(&nsim_trap_data->trap_lock);
 708         for (i = 0; i < ARRAY_SIZE(nsim_traps_arr); i++) {
 709                 struct flow_action_cookie *fa_cookie = NULL;
 710                 struct nsim_trap_item *nsim_trap_item;
 711                 struct sk_buff *skb;
 712                 bool has_fa_cookie;
 713
 714                 has_fa_cookie = nsim_traps_arr[i].metadata_cap &
 715                                 DEVLINK_TRAP_METADATA_TYPE_F_FA_COOKIE;
 716
 717                 nsim_trap_item = &nsim_trap_data->trap_items_arr[i];
 718                 if (nsim_trap_item->action == DEVLINK_TRAP_ACTION_DROP)
 719                         continue;
 720
 721                 skb = nsim_dev_trap_skb_build();
 722                 if (!skb)
 723                         continue;
 724                 skb->dev = nsim_dev_port->ns->netdev;
 725
 726                 /* Trapped packets are usually passed to devlink in softIRQ,
 727                  * but in this case they are generated in a workqueue. Disable
 728                  * softIRQs to prevent lockdep from complaining about
 729                  * "incosistent lock state".
 730                  */
 731
 732                 spin_lock_bh(&nsim_dev->fa_cookie_lock);
 733                 fa_cookie = has_fa_cookie ? nsim_dev->fa_cookie : NULL;
 734                 devlink_trap_report(devlink, skb, nsim_trap_item->trap_ctx,
 735                                     &nsim_dev_port->devlink_port, fa_cookie);
 736                 spin_unlock_bh(&nsim_dev->fa_cookie_lock);
 737                 consume_skb(skb);
 738         }
 739         spin_unlock(&nsim_trap_data->trap_lock);
 740 }
 741
 742 #define NSIM_TRAP_REPORT_INTERVAL_MS    100
 743
 744 static void nsim_dev_trap_report_work(struct work_struct *work)
 745 {
 746         struct nsim_trap_data *nsim_trap_data;
 747         struct nsim_dev_port *nsim_dev_port;
 748         struct nsim_dev *nsim_dev;
 749
 750         nsim_trap_data = container_of(work, struct nsim_trap_data,
 751                                       trap_report_dw.work);
 752         nsim_dev = nsim_trap_data->nsim_dev;
 753
 754         /* For each running port and enabled packet trap, generate a UDP
 755          * packet with a random 5-tuple and report it.
 756          */
 757         mutex_lock(&nsim_dev->port_list_lock);
 758         list_for_each_entry(nsim_dev_port, &nsim_dev->port_list, list) {
 759                 if (!netif_running(nsim_dev_port->ns->netdev))
 760                         continue;
 761
 762                 nsim_dev_trap_report(nsim_dev_port);
 763         }
 764         mutex_unlock(&nsim_dev->port_list_lock);
 765
 766         schedule_delayed_work(&nsim_dev->trap_data->trap_report_dw,
 767                               msecs_to_jiffies(NSIM_TRAP_REPORT_INTERVAL_MS));
 768 }
 769
 770 static int nsim_dev_traps_init(struct devlink *devlink)
 771 {
 772         size_t policers_count = ARRAY_SIZE(nsim_trap_policers_arr);
 773         struct nsim_dev *nsim_dev = devlink_priv(devlink);
 774         struct nsim_trap_data *nsim_trap_data;
 775         int err;
 776
 777         nsim_trap_data = kzalloc(sizeof(*nsim_trap_data), GFP_KERNEL);
 778         if (!nsim_trap_data)
 779                 return -ENOMEM;
 780
 781         nsim_trap_data->trap_items_arr = kcalloc(ARRAY_SIZE(nsim_traps_arr),
 782                                                  sizeof(struct nsim_trap_item),
 783                                                  GFP_KERNEL);
 784         if (!nsim_trap_data->trap_items_arr) {
 785                 err = -ENOMEM;
 786                 goto err_trap_data_free;
 787         }
 788
 789         nsim_trap_data->trap_policers_cnt_arr = kcalloc(policers_count,
 790                                                         sizeof(u64),
 791                                                         GFP_KERNEL);
 792         if (!nsim_trap_data->trap_policers_cnt_arr) {
 793                 err = -ENOMEM;
 794                 goto err_trap_items_free;
 795         }
 796
 797         /* The lock is used to protect the action state of the registered
 798          * traps. The value is written by user and read in delayed work when
 799          * iterating over all the traps.
 800          */
 801         spin_lock_init(&nsim_trap_data->trap_lock);
 802         nsim_trap_data->nsim_dev = nsim_dev;
 803         nsim_dev->trap_data = nsim_trap_data;
 804
 805         err = devlink_trap_policers_register(devlink, nsim_trap_policers_arr,
 806                                              policers_count);
 807         if (err)
 808                 goto err_trap_policers_cnt_free;
 809
 810         err = devlink_trap_groups_register(devlink, nsim_trap_groups_arr,
 811                                            ARRAY_SIZE(nsim_trap_groups_arr));
 812         if (err)
 813                 goto err_trap_policers_unregister;
 814
 815         err = devlink_traps_register(devlink, nsim_traps_arr,
 816                                      ARRAY_SIZE(nsim_traps_arr), NULL);
 817         if (err)
 818                 goto err_trap_groups_unregister;
 819
 820         INIT_DELAYED_WORK(&nsim_dev->trap_data->trap_report_dw,
 821                           nsim_dev_trap_report_work);
 822         schedule_delayed_work(&nsim_dev->trap_data->trap_report_dw,
 823                               msecs_to_jiffies(NSIM_TRAP_REPORT_INTERVAL_MS));
 824
 825         return 0;
 826
 827 err_trap_groups_unregister:
 828         devlink_trap_groups_unregister(devlink, nsim_trap_groups_arr,
 829                                        ARRAY_SIZE(nsim_trap_groups_arr));
 830 err_trap_policers_unregister:
 831         devlink_trap_policers_unregister(devlink, nsim_trap_policers_arr,
 832                                          ARRAY_SIZE(nsim_trap_policers_arr));
 833 err_trap_policers_cnt_free:
 834         kfree(nsim_trap_data->trap_policers_cnt_arr);
 835 err_trap_items_free:
 836         kfree(nsim_trap_data->trap_items_arr);
 837 err_trap_data_free:
 838         kfree(nsim_trap_data);
 839         return err;
 840 }
 841
 842 static void nsim_dev_traps_exit(struct devlink *devlink)
 843 {
 844         struct nsim_dev *nsim_dev = devlink_priv(devlink);
 845
 846         cancel_delayed_work_sync(&nsim_dev->trap_data->trap_report_dw);
 847         devlink_traps_unregister(devlink, nsim_traps_arr,
 848                                  ARRAY_SIZE(nsim_traps_arr));
 849         devlink_trap_groups_unregister(devlink, nsim_trap_groups_arr,
 850                                        ARRAY_SIZE(nsim_trap_groups_arr));
 851         devlink_trap_policers_unregister(devlink, nsim_trap_policers_arr,
 852                                          ARRAY_SIZE(nsim_trap_policers_arr));
 853         kfree(nsim_dev->trap_data->trap_policers_cnt_arr);
 854         kfree(nsim_dev->trap_data->trap_items_arr);
 855         kfree(nsim_dev->trap_data);
 856 }
 857
 858 static int nsim_dev_reload_create(struct nsim_dev *nsim_dev,
 859                                   struct netlink_ext_ack *extack);
 860 static void nsim_dev_reload_destroy(struct nsim_dev *nsim_dev);
 861
 862 static int nsim_dev_reload_down(struct devlink *devlink, bool netns_change,
 863                                 enum devlink_reload_action action, enum devlink_reload_limit limit,
 864                                 struct netlink_ext_ack *extack)
 865 {
 866         struct nsim_dev *nsim_dev = devlink_priv(devlink);
 867
 868         if (nsim_dev->dont_allow_reload) {
 869                 /* For testing purposes, user set debugfs dont_allow_reload
 870                  * value to true. So forbid it.
 871                  */
 872                 NL_SET_ERR_MSG_MOD(extack, "User forbid the reload for testing purposes");
 873                 return -EOPNOTSUPP;
 874         }
 875
 876         nsim_dev_reload_destroy(nsim_dev);
 877         return 0;
 878 }
 879
 880 static int nsim_dev_reload_up(struct devlink *devlink, enum devlink_reload_action action,
 881                               enum devlink_reload_limit limit, u32 *actions_performed,
 882                               struct netlink_ext_ack *extack)
 883 {
 884         struct nsim_dev *nsim_dev = devlink_priv(devlink);
 885
 886         if (nsim_dev->fail_reload) {
 887                 /* For testing purposes, user set debugfs fail_reload
 888                  * value to true. Fail right away.
 889                  */
 890                 NL_SET_ERR_MSG_MOD(extack, "User setup the reload to fail for testing purposes");
 891                 return -EINVAL;
 892         }
 893
 894         *actions_performed = BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT);
 895         return nsim_dev_reload_create(nsim_dev, extack);
 896 }
 897
 898 static int nsim_dev_info_get(struct devlink *devlink,
 899                              struct devlink_info_req *req,
 900                              struct netlink_ext_ack *extack)
 901 {
 902         return devlink_info_driver_name_put(req, DRV_NAME);
 903 }
 904
 905 #define NSIM_DEV_FLASH_SIZE 500000
 906 #define NSIM_DEV_FLASH_CHUNK_SIZE 1000
 907 #define NSIM_DEV_FLASH_CHUNK_TIME_MS 10
 908
 909 static int nsim_dev_flash_update(struct devlink *devlink,
 910                                  struct devlink_flash_update_params *params,
 911                                  struct netlink_ext_ack *extack)
 912 {
 913         struct nsim_dev *nsim_dev = devlink_priv(devlink);
 914         int i;
 915
 916         if ((params->overwrite_mask & ~nsim_dev->fw_update_overwrite_mask) != 0)
 917                 return -EOPNOTSUPP;
 918
 919         if (nsim_dev->fw_update_status) {
 920                 devlink_flash_update_status_notify(devlink,
 921                                                    "Preparing to flash",
 922                                                    params->component, 0, 0);
 923         }
 924
 925         for (i = 0; i < NSIM_DEV_FLASH_SIZE / NSIM_DEV_FLASH_CHUNK_SIZE; i++) {
 926                 if (nsim_dev->fw_update_status)
 927                         devlink_flash_update_status_notify(devlink, "Flashing",
 928                                                            params->component,
 929                                                            i * NSIM_DEV_FLASH_CHUNK_SIZE,
 930                                                            NSIM_DEV_FLASH_SIZE);
 931                 msleep(NSIM_DEV_FLASH_CHUNK_TIME_MS);
 932         }
 933
 934         if (nsim_dev->fw_update_status) {
 935                 devlink_flash_update_status_notify(devlink, "Flashing",
 936                                                    params->component,
 937                                                    NSIM_DEV_FLASH_SIZE,
 938                                                    NSIM_DEV_FLASH_SIZE);
 939                 devlink_flash_update_timeout_notify(devlink, "Flash select",
 940                                                     params->component, 81);
 941                 devlink_flash_update_status_notify(devlink, "Flashing done",
 942                                                    params->component, 0, 0);
 943         }
 944
 945         return 0;
 946 }
 947
 948 static struct nsim_trap_item *
 949 nsim_dev_trap_item_lookup(struct nsim_dev *nsim_dev, u16 trap_id)
 950 {
 951         struct nsim_trap_data *nsim_trap_data = nsim_dev->trap_data;
 952         int i;
 953
 954         for (i = 0; i < ARRAY_SIZE(nsim_traps_arr); i++) {
 955                 if (nsim_traps_arr[i].id == trap_id)
 956                         return &nsim_trap_data->trap_items_arr[i];
 957         }
 958
 959         return NULL;
 960 }
 961
 962 static int nsim_dev_devlink_trap_init(struct devlink *devlink,
 963                                       const struct devlink_trap *trap,
 964                                       void *trap_ctx)
 965 {
 966         struct nsim_dev *nsim_dev = devlink_priv(devlink);
 967         struct nsim_trap_item *nsim_trap_item;
 968
 969         nsim_trap_item = nsim_dev_trap_item_lookup(nsim_dev, trap->id);
 970         if (WARN_ON(!nsim_trap_item))
 971                 return -ENOENT;
 972
 973         nsim_trap_item->trap_ctx = trap_ctx;
 974         nsim_trap_item->action = trap->init_action;
 975
 976         return 0;
 977 }
 978
 979 static int
 980 nsim_dev_devlink_trap_action_set(struct devlink *devlink,
 981                                  const struct devlink_trap *trap,
 982                                  enum devlink_trap_action action,
 983                                  struct netlink_ext_ack *extack)
 984 {
 985         struct nsim_dev *nsim_dev = devlink_priv(devlink);
 986         struct nsim_trap_item *nsim_trap_item;
 987
 988         nsim_trap_item = nsim_dev_trap_item_lookup(nsim_dev, trap->id);
 989         if (WARN_ON(!nsim_trap_item))
 990                 return -ENOENT;
 991
 992         spin_lock(&nsim_dev->trap_data->trap_lock);
 993         nsim_trap_item->action = action;
 994         spin_unlock(&nsim_dev->trap_data->trap_lock);
 995
 996         return 0;
 997 }
 998
 999 static int
1000 nsim_dev_devlink_trap_group_set(struct devlink *devlink,
1001                                 const struct devlink_trap_group *group,
1002                                 const struct devlink_trap_policer *policer,
1003                                 struct netlink_ext_ack *extack)
1004 {
1005         struct nsim_dev *nsim_dev = devlink_priv(devlink);
1006
1007         if (nsim_dev->fail_trap_group_set)
1008                 return -EINVAL;
1009
1010         return 0;
1011 }
1012
1013 static int
1014 nsim_dev_devlink_trap_policer_set(struct devlink *devlink,
1015                                   const struct devlink_trap_policer *policer,
1016                                   u64 rate, u64 burst,
1017                                   struct netlink_ext_ack *extack)
1018 {
1019         struct nsim_dev *nsim_dev = devlink_priv(devlink);
1020
1021         if (nsim_dev->fail_trap_policer_set) {
1022                 NL_SET_ERR_MSG_MOD(extack, "User setup the operation to fail for testing purposes");
1023                 return -EINVAL;
1024         }
1025
1026         return 0;
1027 }
1028
1029 static int
1030 nsim_dev_devlink_trap_policer_counter_get(struct devlink *devlink,
1031                                           const struct devlink_trap_policer *policer,
1032                                           u64 *p_drops)
1033 {
1034         struct nsim_dev *nsim_dev = devlink_priv(devlink);
1035         u64 *cnt;
1036
1037         if (nsim_dev->fail_trap_policer_counter_get)
1038                 return -EINVAL;
1039
1040         cnt = &nsim_dev->trap_data->trap_policers_cnt_arr[policer->id - 1];
1041         *p_drops = (*cnt)++;
1042
1043         return 0;
1044 }
1045
1046 #define NSIM_LINK_SPEED_MAX     5000 /* Mbps */
1047 #define NSIM_LINK_SPEED_UNIT    125000 /* 1 Mbps given in bytes/sec to avoid
1048                                         * u64 overflow during conversion from
1049                                         * bytes to bits.
1050                                         */
1051
1052 static int nsim_rate_bytes_to_units(char *name, u64 *rate, struct netlink_ext_ack *extack)
1053 {
1054         u64 val;
1055         u32 rem;
1056
1057         val = div_u64_rem(*rate, NSIM_LINK_SPEED_UNIT, &rem);
1058         if (rem) {
1059                 pr_err("%s rate value %lluBps not in link speed units of 1Mbps.\n",
1060                        name, *rate);
1061                 NL_SET_ERR_MSG_MOD(extack, "TX rate value not in link speed units of 1Mbps.");
1062                 return -EINVAL;
1063         }
1064
1065         if (val > NSIM_LINK_SPEED_MAX) {
1066                 pr_err("%s rate value %lluMbps exceed link maximum speed 5000Mbps.\n",
1067                        name, val);
1068                 NL_SET_ERR_MSG_MOD(extack, "TX rate value exceed link maximum speed 5000Mbps.");
1069                 return -EINVAL;
1070         }
1071         *rate = val;
1072         return 0;
1073 }
1074
1075 static int nsim_leaf_tx_share_set(struct devlink_rate *devlink_rate, void *priv,
1076                                   u64 tx_share, struct netlink_ext_ack *extack)
1077 {
1078         struct nsim_dev_port *nsim_dev_port = priv;
1079         struct nsim_bus_dev *nsim_bus_dev = nsim_dev_port->ns->nsim_bus_dev;
1080         int vf_id = nsim_dev_port_index_to_vf_index(nsim_dev_port->port_index);
1081         int err;
1082
1083         err = nsim_rate_bytes_to_units("tx_share", &tx_share, extack);
1084         if (err)
1085                 return err;
1086
1087         nsim_bus_dev->vfconfigs[vf_id].min_tx_rate = tx_share;
1088         return 0;
1089 }
1090
1091 static int nsim_leaf_tx_max_set(struct devlink_rate *devlink_rate, void *priv,
1092                                 u64 tx_max, struct netlink_ext_ack *extack)
1093 {
1094         struct nsim_dev_port *nsim_dev_port = priv;
1095         struct nsim_bus_dev *nsim_bus_dev = nsim_dev_port->ns->nsim_bus_dev;
1096         int vf_id = nsim_dev_port_index_to_vf_index(nsim_dev_port->port_index);
1097         int err;
1098
1099         err = nsim_rate_bytes_to_units("tx_max", &tx_max, extack);
1100         if (err)
1101                 return err;
1102
1103         nsim_bus_dev->vfconfigs[vf_id].max_tx_rate = tx_max;
1104         return 0;
1105 }
1106
1107 struct nsim_rate_node {
1108         struct dentry *ddir;
1109         struct dentry *rate_parent;
1110         char *parent_name;
1111         u16 tx_share;
1112         u16 tx_max;
1113 };
1114
1115 static int nsim_node_tx_share_set(struct devlink_rate *devlink_rate, void *priv,
1116                                   u64 tx_share, struct netlink_ext_ack *extack)
1117 {
1118         struct nsim_rate_node *nsim_node = priv;
1119         int err;
1120
1121         err = nsim_rate_bytes_to_units("tx_share", &tx_share, extack);
1122         if (err)
1123                 return err;
1124
1125         nsim_node->tx_share = tx_share;
1126         return 0;
1127 }
1128
1129 static int nsim_node_tx_max_set(struct devlink_rate *devlink_rate, void *priv,
1130                                 u64 tx_max, struct netlink_ext_ack *extack)
1131 {
1132         struct nsim_rate_node *nsim_node = priv;
1133         int err;
1134
1135         err = nsim_rate_bytes_to_units("tx_max", &tx_max, extack);
1136         if (err)
1137                 return err;
1138
1139         nsim_node->tx_max = tx_max;
1140         return 0;
1141 }
1142
1143 static int nsim_rate_node_new(struct devlink_rate *node, void **priv,
1144                               struct netlink_ext_ack *extack)
1145 {
1146         struct nsim_dev *nsim_dev = devlink_priv(node->devlink);
1147         struct nsim_rate_node *nsim_node;
1148
1149         if (!nsim_esw_mode_is_switchdev(nsim_dev)) {
1150                 NL_SET_ERR_MSG_MOD(extack, "Node creation allowed only in switchdev mode.");
1151                 return -EOPNOTSUPP;
1152         }
1153
1154         nsim_node = kzalloc(sizeof(*nsim_node), GFP_KERNEL);
1155         if (!nsim_node)
1156                 return -ENOMEM;
1157
1158         nsim_node->ddir = debugfs_create_dir(node->name, nsim_dev->nodes_ddir);
1159
1160         debugfs_create_u16("tx_share", 0400, nsim_node->ddir, &nsim_node->tx_share);
1161         debugfs_create_u16("tx_max", 0400, nsim_node->ddir, &nsim_node->tx_max);
1162         nsim_node->rate_parent = debugfs_create_file("rate_parent", 0400,
1163                                                      nsim_node->ddir,
1164                                                      &nsim_node->parent_name,
1165                                                      &nsim_dev_rate_parent_fops);
1166
1167         *priv = nsim_node;
1168         return 0;
1169 }
1170
1171 static int nsim_rate_node_del(struct devlink_rate *node, void *priv,
1172                               struct netlink_ext_ack *extack)
1173 {
1174         struct nsim_rate_node *nsim_node = priv;
1175
1176         debugfs_remove(nsim_node->rate_parent);
1177         debugfs_remove_recursive(nsim_node->ddir);
1178         kfree(nsim_node);
1179         return 0;
1180 }
1181
1182 static int nsim_rate_leaf_parent_set(struct devlink_rate *child,
1183                                      struct devlink_rate *parent,
1184                                      void *priv_child, void *priv_parent,
1185                                      struct netlink_ext_ack *extack)
1186 {
1187         struct nsim_dev_port *nsim_dev_port = priv_child;
1188
1189         if (parent)
1190                 nsim_dev_port->parent_name = parent->name;
1191         else
1192                 nsim_dev_port->parent_name = NULL;
1193         return 0;
1194 }
1195
1196 static int nsim_rate_node_parent_set(struct devlink_rate *child,
1197                                      struct devlink_rate *parent,
1198                                      void *priv_child, void *priv_parent,
1199                                      struct netlink_ext_ack *extack)
1200 {
1201         struct nsim_rate_node *nsim_node = priv_child;
1202
1203         if (parent)
1204                 nsim_node->parent_name = parent->name;
1205         else
1206                 nsim_node->parent_name = NULL;
1207         return 0;
1208 }
1209
1210 static int
1211 nsim_dev_devlink_trap_drop_counter_get(struct devlink *devlink,
1212                                        const struct devlink_trap *trap,
1213                                        u64 *p_drops)
1214 {
1215         struct nsim_dev *nsim_dev = devlink_priv(devlink);
1216         u64 *cnt;
1217
1218         if (nsim_dev->fail_trap_drop_counter_get)
1219                 return -EINVAL;
1220
1221         cnt = &nsim_dev->trap_data->trap_pkt_cnt;
1222         *p_drops = (*cnt)++;
1223
1224         return 0;
1225 }
1226
1227 static const struct devlink_ops nsim_dev_devlink_ops = {
1228         .eswitch_mode_set = nsim_devlink_eswitch_mode_set,
1229         .eswitch_mode_get = nsim_devlink_eswitch_mode_get,
1230         .supported_flash_update_params = DEVLINK_SUPPORT_FLASH_UPDATE_COMPONENT |
1231                                          DEVLINK_SUPPORT_FLASH_UPDATE_OVERWRITE_MASK,
1232         .reload_actions = BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT),
1233         .reload_down = nsim_dev_reload_down,
1234         .reload_up = nsim_dev_reload_up,
1235         .info_get = nsim_dev_info_get,
1236         .flash_update = nsim_dev_flash_update,
1237         .trap_init = nsim_dev_devlink_trap_init,
1238         .trap_action_set = nsim_dev_devlink_trap_action_set,
1239         .trap_group_set = nsim_dev_devlink_trap_group_set,
1240         .trap_policer_set = nsim_dev_devlink_trap_policer_set,
1241         .trap_policer_counter_get = nsim_dev_devlink_trap_policer_counter_get,
1242         .rate_leaf_tx_share_set = nsim_leaf_tx_share_set,
1243         .rate_leaf_tx_max_set = nsim_leaf_tx_max_set,
1244         .rate_node_tx_share_set = nsim_node_tx_share_set,
1245         .rate_node_tx_max_set = nsim_node_tx_max_set,
1246         .rate_node_new = nsim_rate_node_new,
1247         .rate_node_del = nsim_rate_node_del,
1248         .rate_leaf_parent_set = nsim_rate_leaf_parent_set,
1249         .rate_node_parent_set = nsim_rate_node_parent_set,
1250         .trap_drop_counter_get = nsim_dev_devlink_trap_drop_counter_get,
1251 };
1252
1253 #define NSIM_DEV_MAX_MACS_DEFAULT 32
1254 #define NSIM_DEV_TEST1_DEFAULT true
1255
1256 static int __nsim_dev_port_add(struct nsim_dev *nsim_dev, enum nsim_dev_port_type type,
1257                                unsigned int port_index)
1258 {
1259         struct nsim_bus_dev *nsim_bus_dev = nsim_dev->nsim_bus_dev;
1260         struct devlink_port_attrs attrs = {};
1261         struct nsim_dev_port *nsim_dev_port;
1262         struct devlink_port *devlink_port;
1263         int err;
1264
1265         if (type == NSIM_DEV_PORT_TYPE_VF && !nsim_bus_dev->num_vfs)
1266                 return -EINVAL;
1267
1268         nsim_dev_port = kzalloc(sizeof(*nsim_dev_port), GFP_KERNEL);
1269         if (!nsim_dev_port)
1270                 return -ENOMEM;
1271         nsim_dev_port->port_index = nsim_dev_port_index(type, port_index);
1272         nsim_dev_port->port_type = type;
1273
1274         devlink_port = &nsim_dev_port->devlink_port;
1275         if (nsim_dev_port_is_pf(nsim_dev_port)) {
1276                 attrs.flavour = DEVLINK_PORT_FLAVOUR_PHYSICAL;
1277                 attrs.phys.port_number = port_index + 1;
1278         } else {
1279                 attrs.flavour = DEVLINK_PORT_FLAVOUR_PCI_VF;
1280                 attrs.pci_vf.pf = 0;
1281                 attrs.pci_vf.vf = port_index;
1282         }
1283         memcpy(attrs.switch_id.id, nsim_dev->switch_id.id, nsim_dev->switch_id.id_len);
1284         attrs.switch_id.id_len = nsim_dev->switch_id.id_len;
1285         devlink_port_attrs_set(devlink_port, &attrs);
1286         err = devlink_port_register(priv_to_devlink(nsim_dev), devlink_port,
1287                                     nsim_dev_port->port_index);
1288         if (err)
1289                 goto err_port_free;
1290
1291         err = nsim_dev_port_debugfs_init(nsim_dev, nsim_dev_port);
1292         if (err)
1293                 goto err_dl_port_unregister;
1294
1295         nsim_dev_port->ns = nsim_create(nsim_dev, nsim_dev_port);
1296         if (IS_ERR(nsim_dev_port->ns)) {
1297                 err = PTR_ERR(nsim_dev_port->ns);
1298                 goto err_port_debugfs_exit;
1299         }
1300
1301         if (nsim_dev_port_is_vf(nsim_dev_port)) {
1302                 err = devlink_rate_leaf_create(&nsim_dev_port->devlink_port,
1303                                                nsim_dev_port);
1304                 if (err)
1305                         goto err_nsim_destroy;
1306         }
1307
1308         devlink_port_type_eth_set(devlink_port, nsim_dev_port->ns->netdev);
1309         list_add(&nsim_dev_port->list, &nsim_dev->port_list);
1310
1311         return 0;
1312
1313 err_nsim_destroy:
1314         nsim_destroy(nsim_dev_port->ns);
1315 err_port_debugfs_exit:
1316         nsim_dev_port_debugfs_exit(nsim_dev_port);
1317 err_dl_port_unregister:
1318         devlink_port_unregister(devlink_port);
1319 err_port_free:
1320         kfree(nsim_dev_port);
1321         return err;
1322 }
1323
1324 static void __nsim_dev_port_del(struct nsim_dev_port *nsim_dev_port)
1325 {
1326         struct devlink_port *devlink_port = &nsim_dev_port->devlink_port;
1327
1328         list_del(&nsim_dev_port->list);
1329         if (nsim_dev_port_is_vf(nsim_dev_port))
1330                 devlink_rate_leaf_destroy(&nsim_dev_port->devlink_port);
1331         devlink_port_type_clear(devlink_port);
1332         nsim_destroy(nsim_dev_port->ns);
1333         nsim_dev_port_debugfs_exit(nsim_dev_port);
1334         devlink_port_unregister(devlink_port);
1335         kfree(nsim_dev_port);
1336 }
1337
1338 static void nsim_dev_port_del_all(struct nsim_dev *nsim_dev)
1339 {
1340         struct nsim_dev_port *nsim_dev_port, *tmp;
1341
1342         mutex_lock(&nsim_dev->port_list_lock);
1343         list_for_each_entry_safe(nsim_dev_port, tmp,
1344                                  &nsim_dev->port_list, list)
1345                 __nsim_dev_port_del(nsim_dev_port);
1346         mutex_unlock(&nsim_dev->port_list_lock);
1347 }
1348
1349 static int nsim_dev_port_add_all(struct nsim_dev *nsim_dev,
1350                                  unsigned int port_count)
1351 {
1352         int i, err;
1353
1354         for (i = 0; i < port_count; i++) {
1355                 err = __nsim_dev_port_add(nsim_dev, NSIM_DEV_PORT_TYPE_PF, i);
1356                 if (err)
1357                         goto err_port_del_all;
1358         }
1359         return 0;
1360
1361 err_port_del_all:
1362         nsim_dev_port_del_all(nsim_dev);
1363         return err;
1364 }
1365
1366 static int nsim_dev_reload_create(struct nsim_dev *nsim_dev,
1367                                   struct netlink_ext_ack *extack)
1368 {
1369         struct nsim_bus_dev *nsim_bus_dev = nsim_dev->nsim_bus_dev;
1370         struct devlink *devlink;
1371         int err;
1372
1373         devlink = priv_to_devlink(nsim_dev);
1374         nsim_dev = devlink_priv(devlink);
1375         INIT_LIST_HEAD(&nsim_dev->port_list);
1376         mutex_init(&nsim_dev->port_list_lock);
1377         nsim_dev->fw_update_status = true;
1378         nsim_dev->fw_update_overwrite_mask = 0;
1379
1380         nsim_devlink_param_load_driverinit_values(devlink);
1381
1382         err = nsim_dev_dummy_region_init(nsim_dev, devlink);
1383         if (err)
1384                 return err;
1385
1386         err = nsim_dev_traps_init(devlink);
1387         if (err)
1388                 goto err_dummy_region_exit;
1389
1390         nsim_dev->fib_data = nsim_fib_create(devlink, extack);
1391         if (IS_ERR(nsim_dev->fib_data)) {
1392                 err = PTR_ERR(nsim_dev->fib_data);
1393                 goto err_traps_exit;
1394         }
1395
1396         err = nsim_dev_health_init(nsim_dev, devlink);
1397         if (err)
1398                 goto err_fib_destroy;
1399
1400         err = nsim_dev_psample_init(nsim_dev);
1401         if (err)
1402                 goto err_health_exit;
1403
1404         err = nsim_dev_port_add_all(nsim_dev, nsim_bus_dev->port_count);
1405         if (err)
1406                 goto err_psample_exit;
1407
1408         nsim_dev->take_snapshot = debugfs_create_file("take_snapshot",
1409                                                       0200,
1410                                                       nsim_dev->ddir,
1411                                                       nsim_dev,
1412                                                 &nsim_dev_take_snapshot_fops);
1413         return 0;
1414
1415 err_psample_exit:
1416         nsim_dev_psample_exit(nsim_dev);
1417 err_health_exit:
1418         nsim_dev_health_exit(nsim_dev);
1419 err_fib_destroy:
1420         nsim_fib_destroy(devlink, nsim_dev->fib_data);
1421 err_traps_exit:
1422         nsim_dev_traps_exit(devlink);
1423 err_dummy_region_exit:
1424         nsim_dev_dummy_region_exit(nsim_dev);
1425         return err;
1426 }
1427
1428 int nsim_dev_probe(struct nsim_bus_dev *nsim_bus_dev)
1429 {
1430         struct nsim_dev *nsim_dev;
1431         struct devlink *devlink;
1432         int err;
1433
1434         devlink = devlink_alloc(&nsim_dev_devlink_ops, sizeof(*nsim_dev));
1435         if (!devlink)
1436                 return -ENOMEM;
1437         devlink_net_set(devlink, nsim_bus_dev->initial_net);
1438         nsim_dev = devlink_priv(devlink);
1439         nsim_dev->nsim_bus_dev = nsim_bus_dev;
1440         nsim_dev->switch_id.id_len = sizeof(nsim_dev->switch_id.id);
1441         get_random_bytes(nsim_dev->switch_id.id, nsim_dev->switch_id.id_len);
1442         INIT_LIST_HEAD(&nsim_dev->port_list);
1443         mutex_init(&nsim_dev->port_list_lock);
1444         nsim_dev->fw_update_status = true;
1445         nsim_dev->fw_update_overwrite_mask = 0;
1446         nsim_dev->max_macs = NSIM_DEV_MAX_MACS_DEFAULT;
1447         nsim_dev->test1 = NSIM_DEV_TEST1_DEFAULT;
1448         spin_lock_init(&nsim_dev->fa_cookie_lock);
1449
1450         dev_set_drvdata(&nsim_bus_dev->dev, nsim_dev);
1451
1452         err = nsim_dev_resources_register(devlink);
1453         if (err)
1454                 goto err_devlink_free;
1455
1456         err = devlink_register(devlink, &nsim_bus_dev->dev);
1457         if (err)
1458                 goto err_resources_unregister;
1459
1460         err = devlink_params_register(devlink, nsim_devlink_params,
1461                                       ARRAY_SIZE(nsim_devlink_params));
1462         if (err)
1463                 goto err_dl_unregister;
1464         nsim_devlink_set_params_init_values(nsim_dev, devlink);
1465
1466         err = nsim_dev_dummy_region_init(nsim_dev, devlink);
1467         if (err)
1468                 goto err_params_unregister;
1469
1470         err = nsim_dev_traps_init(devlink);
1471         if (err)
1472                 goto err_dummy_region_exit;
1473
1474         err = nsim_dev_debugfs_init(nsim_dev);
1475         if (err)
1476                 goto err_traps_exit;
1477
1478         nsim_dev->fib_data = nsim_fib_create(devlink, NULL);
1479         if (IS_ERR(nsim_dev->fib_data)) {
1480                 err = PTR_ERR(nsim_dev->fib_data);
1481                 goto err_debugfs_exit;
1482         }
1483
1484         err = nsim_dev_health_init(nsim_dev, devlink);
1485         if (err)
1486                 goto err_fib_destroy;
1487
1488         err = nsim_bpf_dev_init(nsim_dev);
1489         if (err)
1490                 goto err_health_exit;
1491
1492         err = nsim_dev_psample_init(nsim_dev);
1493         if (err)
1494                 goto err_bpf_dev_exit;
1495
1496         err = nsim_dev_port_add_all(nsim_dev, nsim_bus_dev->port_count);
1497         if (err)
1498                 goto err_psample_exit;
1499
1500         devlink_params_publish(devlink);
1501         devlink_reload_enable(devlink);
1502         nsim_dev->esw_mode = DEVLINK_ESWITCH_MODE_LEGACY;
1503         return 0;
1504
1505 err_psample_exit:
1506         nsim_dev_psample_exit(nsim_dev);
1507 err_bpf_dev_exit:
1508         nsim_bpf_dev_exit(nsim_dev);
1509 err_health_exit:
1510         nsim_dev_health_exit(nsim_dev);
1511 err_fib_destroy:
1512         nsim_fib_destroy(devlink, nsim_dev->fib_data);
1513 err_debugfs_exit:
1514         nsim_dev_debugfs_exit(nsim_dev);
1515 err_traps_exit:
1516         nsim_dev_traps_exit(devlink);
1517 err_dummy_region_exit:
1518         nsim_dev_dummy_region_exit(nsim_dev);
1519 err_params_unregister:
1520         devlink_params_unregister(devlink, nsim_devlink_params,
1521                                   ARRAY_SIZE(nsim_devlink_params));
1522 err_dl_unregister:
1523         devlink_unregister(devlink);
1524 err_resources_unregister:
1525         devlink_resources_unregister(devlink, NULL);
1526 err_devlink_free:
1527         devlink_free(devlink);
1528         return err;
1529 }
1530
1531 static void nsim_dev_reload_destroy(struct nsim_dev *nsim_dev)
1532 {
1533         struct devlink *devlink = priv_to_devlink(nsim_dev);
1534
1535         if (devlink_is_reload_failed(devlink))
1536                 return;
1537         debugfs_remove(nsim_dev->take_snapshot);
1538
1539         mutex_lock(&nsim_dev->nsim_bus_dev->vfs_lock);
1540         if (nsim_dev->nsim_bus_dev->num_vfs)
1541                 nsim_bus_dev_vfs_disable(nsim_dev->nsim_bus_dev);
1542         mutex_unlock(&nsim_dev->nsim_bus_dev->vfs_lock);
1543
1544         nsim_dev_port_del_all(nsim_dev);
1545         nsim_dev_psample_exit(nsim_dev);
1546         nsim_dev_health_exit(nsim_dev);
1547         nsim_fib_destroy(devlink, nsim_dev->fib_data);
1548         nsim_dev_traps_exit(devlink);
1549         nsim_dev_dummy_region_exit(nsim_dev);
1550         mutex_destroy(&nsim_dev->port_list_lock);
1551 }
1552
1553 void nsim_dev_remove(struct nsim_bus_dev *nsim_bus_dev)
1554 {
1555         struct nsim_dev *nsim_dev = dev_get_drvdata(&nsim_bus_dev->dev);
1556         struct devlink *devlink = priv_to_devlink(nsim_dev);
1557
1558         devlink_reload_disable(devlink);
1559
1560         nsim_dev_reload_destroy(nsim_dev);
1561
1562         nsim_bpf_dev_exit(nsim_dev);
1563         nsim_dev_debugfs_exit(nsim_dev);
1564         devlink_params_unregister(devlink, nsim_devlink_params,
1565                                   ARRAY_SIZE(nsim_devlink_params));
1566         devlink_unregister(devlink);
1567         devlink_resources_unregister(devlink, NULL);
1568         devlink_free(devlink);
1569 }
1570
1571 static struct nsim_dev_port *
1572 __nsim_dev_port_lookup(struct nsim_dev *nsim_dev, enum nsim_dev_port_type type,
1573                        unsigned int port_index)
1574 {
1575         struct nsim_dev_port *nsim_dev_port;
1576
1577         port_index = nsim_dev_port_index(type, port_index);
1578         list_for_each_entry(nsim_dev_port, &nsim_dev->port_list, list)
1579                 if (nsim_dev_port->port_index == port_index)
1580                         return nsim_dev_port;
1581         return NULL;
1582 }
1583
1584 int nsim_dev_port_add(struct nsim_bus_dev *nsim_bus_dev, enum nsim_dev_port_type type,
1585                       unsigned int port_index)
1586 {
1587         struct nsim_dev *nsim_dev = dev_get_drvdata(&nsim_bus_dev->dev);
1588         int err;
1589
1590         mutex_lock(&nsim_dev->port_list_lock);
1591         if (__nsim_dev_port_lookup(nsim_dev, type, port_index))
1592                 err = -EEXIST;
1593         else
1594                 err = __nsim_dev_port_add(nsim_dev, type, port_index);
1595         mutex_unlock(&nsim_dev->port_list_lock);
1596         return err;
1597 }
1598
1599 int nsim_dev_port_del(struct nsim_bus_dev *nsim_bus_dev, enum nsim_dev_port_type type,
1600                       unsigned int port_index)
1601 {
1602         struct nsim_dev *nsim_dev = dev_get_drvdata(&nsim_bus_dev->dev);
1603         struct nsim_dev_port *nsim_dev_port;
1604         int err = 0;
1605
1606         mutex_lock(&nsim_dev->port_list_lock);
1607         nsim_dev_port = __nsim_dev_port_lookup(nsim_dev, type, port_index);
1608         if (!nsim_dev_port)
1609                 err = -ENOENT;
1610         else
1611                 __nsim_dev_port_del(nsim_dev_port);
1612         mutex_unlock(&nsim_dev->port_list_lock);
1613         return err;
1614 }
1615
1616 int nsim_dev_init(void)
1617 {
1618         nsim_dev_ddir = debugfs_create_dir(DRV_NAME, NULL);
1619         return PTR_ERR_OR_ZERO(nsim_dev_ddir);
1620 }
1621
1622 void nsim_dev_exit(void)
1623 {
1624         debugfs_remove_recursive(nsim_dev_ddir);
1625 }