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         struct nsim_bus_dev *nsim_bus_dev;
 868
 869         nsim_bus_dev = nsim_dev->nsim_bus_dev;
 870         if (!mutex_trylock(&nsim_bus_dev->nsim_bus_reload_lock))
 871                 return -EOPNOTSUPP;
 872
 873         if (nsim_dev->dont_allow_reload) {
 874                 /* For testing purposes, user set debugfs dont_allow_reload
 875                  * value to true. So forbid it.
 876                  */
 877                 NL_SET_ERR_MSG_MOD(extack, "User forbid the reload for testing purposes");
 878                 mutex_unlock(&nsim_bus_dev->nsim_bus_reload_lock);
 879                 return -EOPNOTSUPP;
 880         }
 881         nsim_bus_dev->in_reload = true;
 882
 883         nsim_dev_reload_destroy(nsim_dev);
 884         mutex_unlock(&nsim_bus_dev->nsim_bus_reload_lock);
 885         return 0;
 886 }
 887
 888 static int nsim_dev_reload_up(struct devlink *devlink, enum devlink_reload_action action,
 889                               enum devlink_reload_limit limit, u32 *actions_performed,
 890                               struct netlink_ext_ack *extack)
 891 {
 892         struct nsim_dev *nsim_dev = devlink_priv(devlink);
 893         struct nsim_bus_dev *nsim_bus_dev;
 894         int ret;
 895
 896         nsim_bus_dev = nsim_dev->nsim_bus_dev;
 897         mutex_lock(&nsim_bus_dev->nsim_bus_reload_lock);
 898         nsim_bus_dev->in_reload = false;
 899
 900         if (nsim_dev->fail_reload) {
 901                 /* For testing purposes, user set debugfs fail_reload
 902                  * value to true. Fail right away.
 903                  */
 904                 NL_SET_ERR_MSG_MOD(extack, "User setup the reload to fail for testing purposes");
 905                 mutex_unlock(&nsim_bus_dev->nsim_bus_reload_lock);
 906                 return -EINVAL;
 907         }
 908
 909         *actions_performed = BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT);
 910         ret = nsim_dev_reload_create(nsim_dev, extack);
 911         mutex_unlock(&nsim_bus_dev->nsim_bus_reload_lock);
 912         return ret;
 913 }
 914
 915 static int nsim_dev_info_get(struct devlink *devlink,
 916                              struct devlink_info_req *req,
 917                              struct netlink_ext_ack *extack)
 918 {
 919         return devlink_info_driver_name_put(req, DRV_NAME);
 920 }
 921
 922 #define NSIM_DEV_FLASH_SIZE 500000
 923 #define NSIM_DEV_FLASH_CHUNK_SIZE 1000
 924 #define NSIM_DEV_FLASH_CHUNK_TIME_MS 10
 925
 926 static int nsim_dev_flash_update(struct devlink *devlink,
 927                                  struct devlink_flash_update_params *params,
 928                                  struct netlink_ext_ack *extack)
 929 {
 930         struct nsim_dev *nsim_dev = devlink_priv(devlink);
 931         int i;
 932
 933         if ((params->overwrite_mask & ~nsim_dev->fw_update_overwrite_mask) != 0)
 934                 return -EOPNOTSUPP;
 935
 936         if (nsim_dev->fw_update_status) {
 937                 devlink_flash_update_status_notify(devlink,
 938                                                    "Preparing to flash",
 939                                                    params->component, 0, 0);
 940         }
 941
 942         for (i = 0; i < NSIM_DEV_FLASH_SIZE / NSIM_DEV_FLASH_CHUNK_SIZE; i++) {
 943                 if (nsim_dev->fw_update_status)
 944                         devlink_flash_update_status_notify(devlink, "Flashing",
 945                                                            params->component,
 946                                                            i * NSIM_DEV_FLASH_CHUNK_SIZE,
 947                                                            NSIM_DEV_FLASH_SIZE);
 948                 msleep(NSIM_DEV_FLASH_CHUNK_TIME_MS);
 949         }
 950
 951         if (nsim_dev->fw_update_status) {
 952                 devlink_flash_update_status_notify(devlink, "Flashing",
 953                                                    params->component,
 954                                                    NSIM_DEV_FLASH_SIZE,
 955                                                    NSIM_DEV_FLASH_SIZE);
 956                 devlink_flash_update_timeout_notify(devlink, "Flash select",
 957                                                     params->component, 81);
 958                 devlink_flash_update_status_notify(devlink, "Flashing done",
 959                                                    params->component, 0, 0);
 960         }
 961
 962         return 0;
 963 }
 964
 965 static struct nsim_trap_item *
 966 nsim_dev_trap_item_lookup(struct nsim_dev *nsim_dev, u16 trap_id)
 967 {
 968         struct nsim_trap_data *nsim_trap_data = nsim_dev->trap_data;
 969         int i;
 970
 971         for (i = 0; i < ARRAY_SIZE(nsim_traps_arr); i++) {
 972                 if (nsim_traps_arr[i].id == trap_id)
 973                         return &nsim_trap_data->trap_items_arr[i];
 974         }
 975
 976         return NULL;
 977 }
 978
 979 static int nsim_dev_devlink_trap_init(struct devlink *devlink,
 980                                       const struct devlink_trap *trap,
 981                                       void *trap_ctx)
 982 {
 983         struct nsim_dev *nsim_dev = devlink_priv(devlink);
 984         struct nsim_trap_item *nsim_trap_item;
 985
 986         nsim_trap_item = nsim_dev_trap_item_lookup(nsim_dev, trap->id);
 987         if (WARN_ON(!nsim_trap_item))
 988                 return -ENOENT;
 989
 990         nsim_trap_item->trap_ctx = trap_ctx;
 991         nsim_trap_item->action = trap->init_action;
 992
 993         return 0;
 994 }
 995
 996 static int
 997 nsim_dev_devlink_trap_action_set(struct devlink *devlink,
 998                                  const struct devlink_trap *trap,
 999                                  enum devlink_trap_action action,
1000                                  struct netlink_ext_ack *extack)
1001 {
1002         struct nsim_dev *nsim_dev = devlink_priv(devlink);
1003         struct nsim_trap_item *nsim_trap_item;
1004
1005         nsim_trap_item = nsim_dev_trap_item_lookup(nsim_dev, trap->id);
1006         if (WARN_ON(!nsim_trap_item))
1007                 return -ENOENT;
1008
1009         spin_lock(&nsim_dev->trap_data->trap_lock);
1010         nsim_trap_item->action = action;
1011         spin_unlock(&nsim_dev->trap_data->trap_lock);
1012
1013         return 0;
1014 }
1015
1016 static int
1017 nsim_dev_devlink_trap_group_set(struct devlink *devlink,
1018                                 const struct devlink_trap_group *group,
1019                                 const struct devlink_trap_policer *policer,
1020                                 struct netlink_ext_ack *extack)
1021 {
1022         struct nsim_dev *nsim_dev = devlink_priv(devlink);
1023
1024         if (nsim_dev->fail_trap_group_set)
1025                 return -EINVAL;
1026
1027         return 0;
1028 }
1029
1030 static int
1031 nsim_dev_devlink_trap_policer_set(struct devlink *devlink,
1032                                   const struct devlink_trap_policer *policer,
1033                                   u64 rate, u64 burst,
1034                                   struct netlink_ext_ack *extack)
1035 {
1036         struct nsim_dev *nsim_dev = devlink_priv(devlink);
1037
1038         if (nsim_dev->fail_trap_policer_set) {
1039                 NL_SET_ERR_MSG_MOD(extack, "User setup the operation to fail for testing purposes");
1040                 return -EINVAL;
1041         }
1042
1043         return 0;
1044 }
1045
1046 static int
1047 nsim_dev_devlink_trap_policer_counter_get(struct devlink *devlink,
1048                                           const struct devlink_trap_policer *policer,
1049                                           u64 *p_drops)
1050 {
1051         struct nsim_dev *nsim_dev = devlink_priv(devlink);
1052         u64 *cnt;
1053
1054         if (nsim_dev->fail_trap_policer_counter_get)
1055                 return -EINVAL;
1056
1057         cnt = &nsim_dev->trap_data->trap_policers_cnt_arr[policer->id - 1];
1058         *p_drops = (*cnt)++;
1059
1060         return 0;
1061 }
1062
1063 #define NSIM_LINK_SPEED_MAX     5000 /* Mbps */
1064 #define NSIM_LINK_SPEED_UNIT    125000 /* 1 Mbps given in bytes/sec to avoid
1065                                         * u64 overflow during conversion from
1066                                         * bytes to bits.
1067                                         */
1068
1069 static int nsim_rate_bytes_to_units(char *name, u64 *rate, struct netlink_ext_ack *extack)
1070 {
1071         u64 val;
1072         u32 rem;
1073
1074         val = div_u64_rem(*rate, NSIM_LINK_SPEED_UNIT, &rem);
1075         if (rem) {
1076                 pr_err("%s rate value %lluBps not in link speed units of 1Mbps.\n",
1077                        name, *rate);
1078                 NL_SET_ERR_MSG_MOD(extack, "TX rate value not in link speed units of 1Mbps.");
1079                 return -EINVAL;
1080         }
1081
1082         if (val > NSIM_LINK_SPEED_MAX) {
1083                 pr_err("%s rate value %lluMbps exceed link maximum speed 5000Mbps.\n",
1084                        name, val);
1085                 NL_SET_ERR_MSG_MOD(extack, "TX rate value exceed link maximum speed 5000Mbps.");
1086                 return -EINVAL;
1087         }
1088         *rate = val;
1089         return 0;
1090 }
1091
1092 static int nsim_leaf_tx_share_set(struct devlink_rate *devlink_rate, void *priv,
1093                                   u64 tx_share, struct netlink_ext_ack *extack)
1094 {
1095         struct nsim_dev_port *nsim_dev_port = priv;
1096         struct nsim_bus_dev *nsim_bus_dev = nsim_dev_port->ns->nsim_bus_dev;
1097         int vf_id = nsim_dev_port_index_to_vf_index(nsim_dev_port->port_index);
1098         int err;
1099
1100         err = nsim_rate_bytes_to_units("tx_share", &tx_share, extack);
1101         if (err)
1102                 return err;
1103
1104         nsim_bus_dev->vfconfigs[vf_id].min_tx_rate = tx_share;
1105         return 0;
1106 }
1107
1108 static int nsim_leaf_tx_max_set(struct devlink_rate *devlink_rate, void *priv,
1109                                 u64 tx_max, struct netlink_ext_ack *extack)
1110 {
1111         struct nsim_dev_port *nsim_dev_port = priv;
1112         struct nsim_bus_dev *nsim_bus_dev = nsim_dev_port->ns->nsim_bus_dev;
1113         int vf_id = nsim_dev_port_index_to_vf_index(nsim_dev_port->port_index);
1114         int err;
1115
1116         err = nsim_rate_bytes_to_units("tx_max", &tx_max, extack);
1117         if (err)
1118                 return err;
1119
1120         nsim_bus_dev->vfconfigs[vf_id].max_tx_rate = tx_max;
1121         return 0;
1122 }
1123
1124 struct nsim_rate_node {
1125         struct dentry *ddir;
1126         struct dentry *rate_parent;
1127         char *parent_name;
1128         u16 tx_share;
1129         u16 tx_max;
1130 };
1131
1132 static int nsim_node_tx_share_set(struct devlink_rate *devlink_rate, void *priv,
1133                                   u64 tx_share, struct netlink_ext_ack *extack)
1134 {
1135         struct nsim_rate_node *nsim_node = priv;
1136         int err;
1137
1138         err = nsim_rate_bytes_to_units("tx_share", &tx_share, extack);
1139         if (err)
1140                 return err;
1141
1142         nsim_node->tx_share = tx_share;
1143         return 0;
1144 }
1145
1146 static int nsim_node_tx_max_set(struct devlink_rate *devlink_rate, void *priv,
1147                                 u64 tx_max, struct netlink_ext_ack *extack)
1148 {
1149         struct nsim_rate_node *nsim_node = priv;
1150         int err;
1151
1152         err = nsim_rate_bytes_to_units("tx_max", &tx_max, extack);
1153         if (err)
1154                 return err;
1155
1156         nsim_node->tx_max = tx_max;
1157         return 0;
1158 }
1159
1160 static int nsim_rate_node_new(struct devlink_rate *node, void **priv,
1161                               struct netlink_ext_ack *extack)
1162 {
1163         struct nsim_dev *nsim_dev = devlink_priv(node->devlink);
1164         struct nsim_rate_node *nsim_node;
1165
1166         if (!nsim_esw_mode_is_switchdev(nsim_dev)) {
1167                 NL_SET_ERR_MSG_MOD(extack, "Node creation allowed only in switchdev mode.");
1168                 return -EOPNOTSUPP;
1169         }
1170
1171         nsim_node = kzalloc(sizeof(*nsim_node), GFP_KERNEL);
1172         if (!nsim_node)
1173                 return -ENOMEM;
1174
1175         nsim_node->ddir = debugfs_create_dir(node->name, nsim_dev->nodes_ddir);
1176
1177         debugfs_create_u16("tx_share", 0400, nsim_node->ddir, &nsim_node->tx_share);
1178         debugfs_create_u16("tx_max", 0400, nsim_node->ddir, &nsim_node->tx_max);
1179         nsim_node->rate_parent = debugfs_create_file("rate_parent", 0400,
1180                                                      nsim_node->ddir,
1181                                                      &nsim_node->parent_name,
1182                                                      &nsim_dev_rate_parent_fops);
1183
1184         *priv = nsim_node;
1185         return 0;
1186 }
1187
1188 static int nsim_rate_node_del(struct devlink_rate *node, void *priv,
1189                               struct netlink_ext_ack *extack)
1190 {
1191         struct nsim_rate_node *nsim_node = priv;
1192
1193         debugfs_remove(nsim_node->rate_parent);
1194         debugfs_remove_recursive(nsim_node->ddir);
1195         kfree(nsim_node);
1196         return 0;
1197 }
1198
1199 static int nsim_rate_leaf_parent_set(struct devlink_rate *child,
1200                                      struct devlink_rate *parent,
1201                                      void *priv_child, void *priv_parent,
1202                                      struct netlink_ext_ack *extack)
1203 {
1204         struct nsim_dev_port *nsim_dev_port = priv_child;
1205
1206         if (parent)
1207                 nsim_dev_port->parent_name = parent->name;
1208         else
1209                 nsim_dev_port->parent_name = NULL;
1210         return 0;
1211 }
1212
1213 static int nsim_rate_node_parent_set(struct devlink_rate *child,
1214                                      struct devlink_rate *parent,
1215                                      void *priv_child, void *priv_parent,
1216                                      struct netlink_ext_ack *extack)
1217 {
1218         struct nsim_rate_node *nsim_node = priv_child;
1219
1220         if (parent)
1221                 nsim_node->parent_name = parent->name;
1222         else
1223                 nsim_node->parent_name = NULL;
1224         return 0;
1225 }
1226
1227 static int
1228 nsim_dev_devlink_trap_drop_counter_get(struct devlink *devlink,
1229                                        const struct devlink_trap *trap,
1230                                        u64 *p_drops)
1231 {
1232         struct nsim_dev *nsim_dev = devlink_priv(devlink);
1233         u64 *cnt;
1234
1235         if (nsim_dev->fail_trap_drop_counter_get)
1236                 return -EINVAL;
1237
1238         cnt = &nsim_dev->trap_data->trap_pkt_cnt;
1239         *p_drops = (*cnt)++;
1240
1241         return 0;
1242 }
1243
1244 static const struct devlink_ops nsim_dev_devlink_ops = {
1245         .eswitch_mode_set = nsim_devlink_eswitch_mode_set,
1246         .eswitch_mode_get = nsim_devlink_eswitch_mode_get,
1247         .supported_flash_update_params = DEVLINK_SUPPORT_FLASH_UPDATE_COMPONENT |
1248                                          DEVLINK_SUPPORT_FLASH_UPDATE_OVERWRITE_MASK,
1249         .reload_actions = BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT),
1250         .reload_down = nsim_dev_reload_down,
1251         .reload_up = nsim_dev_reload_up,
1252         .info_get = nsim_dev_info_get,
1253         .flash_update = nsim_dev_flash_update,
1254         .trap_init = nsim_dev_devlink_trap_init,
1255         .trap_action_set = nsim_dev_devlink_trap_action_set,
1256         .trap_group_set = nsim_dev_devlink_trap_group_set,
1257         .trap_policer_set = nsim_dev_devlink_trap_policer_set,
1258         .trap_policer_counter_get = nsim_dev_devlink_trap_policer_counter_get,
1259         .rate_leaf_tx_share_set = nsim_leaf_tx_share_set,
1260         .rate_leaf_tx_max_set = nsim_leaf_tx_max_set,
1261         .rate_node_tx_share_set = nsim_node_tx_share_set,
1262         .rate_node_tx_max_set = nsim_node_tx_max_set,
1263         .rate_node_new = nsim_rate_node_new,
1264         .rate_node_del = nsim_rate_node_del,
1265         .rate_leaf_parent_set = nsim_rate_leaf_parent_set,
1266         .rate_node_parent_set = nsim_rate_node_parent_set,
1267         .trap_drop_counter_get = nsim_dev_devlink_trap_drop_counter_get,
1268 };
1269
1270 #define NSIM_DEV_MAX_MACS_DEFAULT 32
1271 #define NSIM_DEV_TEST1_DEFAULT true
1272
1273 static int __nsim_dev_port_add(struct nsim_dev *nsim_dev, enum nsim_dev_port_type type,
1274                                unsigned int port_index)
1275 {
1276         struct nsim_bus_dev *nsim_bus_dev = nsim_dev->nsim_bus_dev;
1277         struct devlink_port_attrs attrs = {};
1278         struct nsim_dev_port *nsim_dev_port;
1279         struct devlink_port *devlink_port;
1280         int err;
1281
1282         if (type == NSIM_DEV_PORT_TYPE_VF && !nsim_bus_dev->num_vfs)
1283                 return -EINVAL;
1284
1285         nsim_dev_port = kzalloc(sizeof(*nsim_dev_port), GFP_KERNEL);
1286         if (!nsim_dev_port)
1287                 return -ENOMEM;
1288         nsim_dev_port->port_index = nsim_dev_port_index(type, port_index);
1289         nsim_dev_port->port_type = type;
1290
1291         devlink_port = &nsim_dev_port->devlink_port;
1292         if (nsim_dev_port_is_pf(nsim_dev_port)) {
1293                 attrs.flavour = DEVLINK_PORT_FLAVOUR_PHYSICAL;
1294                 attrs.phys.port_number = port_index + 1;
1295         } else {
1296                 attrs.flavour = DEVLINK_PORT_FLAVOUR_PCI_VF;
1297                 attrs.pci_vf.pf = 0;
1298                 attrs.pci_vf.vf = port_index;
1299         }
1300         memcpy(attrs.switch_id.id, nsim_dev->switch_id.id, nsim_dev->switch_id.id_len);
1301         attrs.switch_id.id_len = nsim_dev->switch_id.id_len;
1302         devlink_port_attrs_set(devlink_port, &attrs);
1303         err = devlink_port_register(priv_to_devlink(nsim_dev), devlink_port,
1304                                     nsim_dev_port->port_index);
1305         if (err)
1306                 goto err_port_free;
1307
1308         err = nsim_dev_port_debugfs_init(nsim_dev, nsim_dev_port);
1309         if (err)
1310                 goto err_dl_port_unregister;
1311
1312         nsim_dev_port->ns = nsim_create(nsim_dev, nsim_dev_port);
1313         if (IS_ERR(nsim_dev_port->ns)) {
1314                 err = PTR_ERR(nsim_dev_port->ns);
1315                 goto err_port_debugfs_exit;
1316         }
1317
1318         if (nsim_dev_port_is_vf(nsim_dev_port)) {
1319                 err = devlink_rate_leaf_create(&nsim_dev_port->devlink_port,
1320                                                nsim_dev_port);
1321                 if (err)
1322                         goto err_nsim_destroy;
1323         }
1324
1325         devlink_port_type_eth_set(devlink_port, nsim_dev_port->ns->netdev);
1326         list_add(&nsim_dev_port->list, &nsim_dev->port_list);
1327
1328         return 0;
1329
1330 err_nsim_destroy:
1331         nsim_destroy(nsim_dev_port->ns);
1332 err_port_debugfs_exit:
1333         nsim_dev_port_debugfs_exit(nsim_dev_port);
1334 err_dl_port_unregister:
1335         devlink_port_unregister(devlink_port);
1336 err_port_free:
1337         kfree(nsim_dev_port);
1338         return err;
1339 }
1340
1341 static void __nsim_dev_port_del(struct nsim_dev_port *nsim_dev_port)
1342 {
1343         struct devlink_port *devlink_port = &nsim_dev_port->devlink_port;
1344
1345         list_del(&nsim_dev_port->list);
1346         if (nsim_dev_port_is_vf(nsim_dev_port))
1347                 devlink_rate_leaf_destroy(&nsim_dev_port->devlink_port);
1348         devlink_port_type_clear(devlink_port);
1349         nsim_destroy(nsim_dev_port->ns);
1350         nsim_dev_port_debugfs_exit(nsim_dev_port);
1351         devlink_port_unregister(devlink_port);
1352         kfree(nsim_dev_port);
1353 }
1354
1355 static void nsim_dev_port_del_all(struct nsim_dev *nsim_dev)
1356 {
1357         struct nsim_dev_port *nsim_dev_port, *tmp;
1358
1359         mutex_lock(&nsim_dev->port_list_lock);
1360         list_for_each_entry_safe(nsim_dev_port, tmp,
1361                                  &nsim_dev->port_list, list)
1362                 __nsim_dev_port_del(nsim_dev_port);
1363         mutex_unlock(&nsim_dev->port_list_lock);
1364 }
1365
1366 static int nsim_dev_port_add_all(struct nsim_dev *nsim_dev,
1367                                  unsigned int port_count)
1368 {
1369         int i, err;
1370
1371         for (i = 0; i < port_count; i++) {
1372                 err = __nsim_dev_port_add(nsim_dev, NSIM_DEV_PORT_TYPE_PF, i);
1373                 if (err)
1374                         goto err_port_del_all;
1375         }
1376         return 0;
1377
1378 err_port_del_all:
1379         nsim_dev_port_del_all(nsim_dev);
1380         return err;
1381 }
1382
1383 static int nsim_dev_reload_create(struct nsim_dev *nsim_dev,
1384                                   struct netlink_ext_ack *extack)
1385 {
1386         struct nsim_bus_dev *nsim_bus_dev = nsim_dev->nsim_bus_dev;
1387         struct devlink *devlink;
1388         int err;
1389
1390         devlink = priv_to_devlink(nsim_dev);
1391         nsim_dev = devlink_priv(devlink);
1392         INIT_LIST_HEAD(&nsim_dev->port_list);
1393         mutex_init(&nsim_dev->port_list_lock);
1394         nsim_dev->fw_update_status = true;
1395         nsim_dev->fw_update_overwrite_mask = 0;
1396
1397         nsim_devlink_param_load_driverinit_values(devlink);
1398
1399         err = nsim_dev_dummy_region_init(nsim_dev, devlink);
1400         if (err)
1401                 return err;
1402
1403         err = nsim_dev_traps_init(devlink);
1404         if (err)
1405                 goto err_dummy_region_exit;
1406
1407         nsim_dev->fib_data = nsim_fib_create(devlink, extack);
1408         if (IS_ERR(nsim_dev->fib_data)) {
1409                 err = PTR_ERR(nsim_dev->fib_data);
1410                 goto err_traps_exit;
1411         }
1412
1413         err = nsim_dev_health_init(nsim_dev, devlink);
1414         if (err)
1415                 goto err_fib_destroy;
1416
1417         err = nsim_dev_psample_init(nsim_dev);
1418         if (err)
1419                 goto err_health_exit;
1420
1421         err = nsim_dev_port_add_all(nsim_dev, nsim_bus_dev->port_count);
1422         if (err)
1423                 goto err_psample_exit;
1424
1425         nsim_dev->take_snapshot = debugfs_create_file("take_snapshot",
1426                                                       0200,
1427                                                       nsim_dev->ddir,
1428                                                       nsim_dev,
1429                                                 &nsim_dev_take_snapshot_fops);
1430         return 0;
1431
1432 err_psample_exit:
1433         nsim_dev_psample_exit(nsim_dev);
1434 err_health_exit:
1435         nsim_dev_health_exit(nsim_dev);
1436 err_fib_destroy:
1437         nsim_fib_destroy(devlink, nsim_dev->fib_data);
1438 err_traps_exit:
1439         nsim_dev_traps_exit(devlink);
1440 err_dummy_region_exit:
1441         nsim_dev_dummy_region_exit(nsim_dev);
1442         return err;
1443 }
1444
1445 int nsim_dev_probe(struct nsim_bus_dev *nsim_bus_dev)
1446 {
1447         struct nsim_dev *nsim_dev;
1448         struct devlink *devlink;
1449         int err;
1450
1451         devlink = devlink_alloc_ns(&nsim_dev_devlink_ops, sizeof(*nsim_dev),
1452                                  nsim_bus_dev->initial_net, &nsim_bus_dev->dev);
1453         if (!devlink)
1454                 return -ENOMEM;
1455         nsim_dev = devlink_priv(devlink);
1456         nsim_dev->nsim_bus_dev = nsim_bus_dev;
1457         nsim_dev->switch_id.id_len = sizeof(nsim_dev->switch_id.id);
1458         get_random_bytes(nsim_dev->switch_id.id, nsim_dev->switch_id.id_len);
1459         INIT_LIST_HEAD(&nsim_dev->port_list);
1460         mutex_init(&nsim_dev->port_list_lock);
1461         nsim_dev->fw_update_status = true;
1462         nsim_dev->fw_update_overwrite_mask = 0;
1463         nsim_dev->max_macs = NSIM_DEV_MAX_MACS_DEFAULT;
1464         nsim_dev->test1 = NSIM_DEV_TEST1_DEFAULT;
1465         spin_lock_init(&nsim_dev->fa_cookie_lock);
1466
1467         dev_set_drvdata(&nsim_bus_dev->dev, nsim_dev);
1468
1469         err = nsim_dev_resources_register(devlink);
1470         if (err)
1471                 goto err_devlink_free;
1472
1473         err = devlink_register(devlink);
1474         if (err)
1475                 goto err_resources_unregister;
1476
1477         err = devlink_params_register(devlink, nsim_devlink_params,
1478                                       ARRAY_SIZE(nsim_devlink_params));
1479         if (err)
1480                 goto err_dl_unregister;
1481         nsim_devlink_set_params_init_values(nsim_dev, devlink);
1482
1483         err = nsim_dev_dummy_region_init(nsim_dev, devlink);
1484         if (err)
1485                 goto err_params_unregister;
1486
1487         err = nsim_dev_traps_init(devlink);
1488         if (err)
1489                 goto err_dummy_region_exit;
1490
1491         err = nsim_dev_debugfs_init(nsim_dev);
1492         if (err)
1493                 goto err_traps_exit;
1494
1495         nsim_dev->fib_data = nsim_fib_create(devlink, NULL);
1496         if (IS_ERR(nsim_dev->fib_data)) {
1497                 err = PTR_ERR(nsim_dev->fib_data);
1498                 goto err_debugfs_exit;
1499         }
1500
1501         err = nsim_dev_health_init(nsim_dev, devlink);
1502         if (err)
1503                 goto err_fib_destroy;
1504
1505         err = nsim_bpf_dev_init(nsim_dev);
1506         if (err)
1507                 goto err_health_exit;
1508
1509         err = nsim_dev_psample_init(nsim_dev);
1510         if (err)
1511                 goto err_bpf_dev_exit;
1512
1513         err = nsim_dev_port_add_all(nsim_dev, nsim_bus_dev->port_count);
1514         if (err)
1515                 goto err_psample_exit;
1516
1517         devlink_params_publish(devlink);
1518         devlink_reload_enable(devlink);
1519         nsim_dev->esw_mode = DEVLINK_ESWITCH_MODE_LEGACY;
1520         return 0;
1521
1522 err_psample_exit:
1523         nsim_dev_psample_exit(nsim_dev);
1524 err_bpf_dev_exit:
1525         nsim_bpf_dev_exit(nsim_dev);
1526 err_health_exit:
1527         nsim_dev_health_exit(nsim_dev);
1528 err_fib_destroy:
1529         nsim_fib_destroy(devlink, nsim_dev->fib_data);
1530 err_debugfs_exit:
1531         nsim_dev_debugfs_exit(nsim_dev);
1532 err_traps_exit:
1533         nsim_dev_traps_exit(devlink);
1534 err_dummy_region_exit:
1535         nsim_dev_dummy_region_exit(nsim_dev);
1536 err_params_unregister:
1537         devlink_params_unregister(devlink, nsim_devlink_params,
1538                                   ARRAY_SIZE(nsim_devlink_params));
1539 err_dl_unregister:
1540         devlink_unregister(devlink);
1541 err_resources_unregister:
1542         devlink_resources_unregister(devlink, NULL);
1543 err_devlink_free:
1544         devlink_free(devlink);
1545         return err;
1546 }
1547
1548 static void nsim_dev_reload_destroy(struct nsim_dev *nsim_dev)
1549 {
1550         struct devlink *devlink = priv_to_devlink(nsim_dev);
1551
1552         if (devlink_is_reload_failed(devlink))
1553                 return;
1554         debugfs_remove(nsim_dev->take_snapshot);
1555
1556         mutex_lock(&nsim_dev->nsim_bus_dev->vfs_lock);
1557         if (nsim_dev->nsim_bus_dev->num_vfs)
1558                 nsim_bus_dev_vfs_disable(nsim_dev->nsim_bus_dev);
1559         mutex_unlock(&nsim_dev->nsim_bus_dev->vfs_lock);
1560
1561         nsim_dev_port_del_all(nsim_dev);
1562         nsim_dev_psample_exit(nsim_dev);
1563         nsim_dev_health_exit(nsim_dev);
1564         nsim_fib_destroy(devlink, nsim_dev->fib_data);
1565         nsim_dev_traps_exit(devlink);
1566         nsim_dev_dummy_region_exit(nsim_dev);
1567         mutex_destroy(&nsim_dev->port_list_lock);
1568 }
1569
1570 void nsim_dev_remove(struct nsim_bus_dev *nsim_bus_dev)
1571 {
1572         struct nsim_dev *nsim_dev = dev_get_drvdata(&nsim_bus_dev->dev);
1573         struct devlink *devlink = priv_to_devlink(nsim_dev);
1574
1575         devlink_reload_disable(devlink);
1576
1577         nsim_dev_reload_destroy(nsim_dev);
1578
1579         nsim_bpf_dev_exit(nsim_dev);
1580         nsim_dev_debugfs_exit(nsim_dev);
1581         devlink_params_unregister(devlink, nsim_devlink_params,
1582                                   ARRAY_SIZE(nsim_devlink_params));
1583         devlink_unregister(devlink);
1584         devlink_resources_unregister(devlink, NULL);
1585         devlink_free(devlink);
1586 }
1587
1588 static struct nsim_dev_port *
1589 __nsim_dev_port_lookup(struct nsim_dev *nsim_dev, enum nsim_dev_port_type type,
1590                        unsigned int port_index)
1591 {
1592         struct nsim_dev_port *nsim_dev_port;
1593
1594         port_index = nsim_dev_port_index(type, port_index);
1595         list_for_each_entry(nsim_dev_port, &nsim_dev->port_list, list)
1596                 if (nsim_dev_port->port_index == port_index)
1597                         return nsim_dev_port;
1598         return NULL;
1599 }
1600
1601 int nsim_dev_port_add(struct nsim_bus_dev *nsim_bus_dev, enum nsim_dev_port_type type,
1602                       unsigned int port_index)
1603 {
1604         struct nsim_dev *nsim_dev = dev_get_drvdata(&nsim_bus_dev->dev);
1605         int err;
1606
1607         mutex_lock(&nsim_dev->port_list_lock);
1608         if (__nsim_dev_port_lookup(nsim_dev, type, port_index))
1609                 err = -EEXIST;
1610         else
1611                 err = __nsim_dev_port_add(nsim_dev, type, port_index);
1612         mutex_unlock(&nsim_dev->port_list_lock);
1613         return err;
1614 }
1615
1616 int nsim_dev_port_del(struct nsim_bus_dev *nsim_bus_dev, enum nsim_dev_port_type type,
1617                       unsigned int port_index)
1618 {
1619         struct nsim_dev *nsim_dev = dev_get_drvdata(&nsim_bus_dev->dev);
1620         struct nsim_dev_port *nsim_dev_port;
1621         int err = 0;
1622
1623         mutex_lock(&nsim_dev->port_list_lock);
1624         nsim_dev_port = __nsim_dev_port_lookup(nsim_dev, type, port_index);
1625         if (!nsim_dev_port)
1626                 err = -ENOENT;
1627         else
1628                 __nsim_dev_port_del(nsim_dev_port);
1629         mutex_unlock(&nsim_dev->port_list_lock);
1630         return err;
1631 }
1632
1633 int nsim_dev_init(void)
1634 {
1635         nsim_dev_ddir = debugfs_create_dir(DRV_NAME, NULL);
1636         return PTR_ERR_OR_ZERO(nsim_dev_ddir);
1637 }
1638
1639 void nsim_dev_exit(void)
1640 {
1641         debugfs_remove_recursive(nsim_dev_ddir);
1642 }