Back to home page

OSCL-LXR
 
 

     

0001 /*
0002  * Copyright (c) 2018 Cumulus Networks. All rights reserved.
0003  * Copyright (c) 2018 David Ahern <dsa@cumulusnetworks.com>
0004  * Copyright (c) 2019 Mellanox Technologies. All rights reserved.
0005  *
0006  * This software is licensed under the GNU General License Version 2,
0007  * June 1991 as shown in the file COPYING in the top-level directory of this
0008  * source tree.
0009  *
0010  * THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS"
0011  * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
0012  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
0013  * FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE
0014  * OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME
0015  * THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
0016  */
0017 
0018 #include <linux/debugfs.h>
0019 #include <linux/device.h>
0020 #include <linux/etherdevice.h>
0021 #include <linux/inet.h>
0022 #include <linux/jiffies.h>
0023 #include <linux/kernel.h>
0024 #include <linux/list.h>
0025 #include <linux/mutex.h>
0026 #include <linux/random.h>
0027 #include <linux/rtnetlink.h>
0028 #include <linux/workqueue.h>
0029 #include <net/devlink.h>
0030 #include <net/ip.h>
0031 #include <net/flow_offload.h>
0032 #include <uapi/linux/devlink.h>
0033 #include <uapi/linux/ip.h>
0034 #include <uapi/linux/udp.h>
0035 
0036 #include "netdevsim.h"
0037 
0038 static unsigned int
0039 nsim_dev_port_index(enum nsim_dev_port_type type, unsigned int port_index)
0040 {
0041     switch (type) {
0042     case NSIM_DEV_PORT_TYPE_VF:
0043         port_index = NSIM_DEV_VF_PORT_INDEX_BASE + port_index;
0044         break;
0045     case NSIM_DEV_PORT_TYPE_PF:
0046         break;
0047     }
0048 
0049     return port_index;
0050 }
0051 
0052 static inline unsigned int nsim_dev_port_index_to_vf_index(unsigned int port_index)
0053 {
0054     return port_index - NSIM_DEV_VF_PORT_INDEX_BASE;
0055 }
0056 
0057 static struct dentry *nsim_dev_ddir;
0058 
0059 unsigned int nsim_dev_get_vfs(struct nsim_dev *nsim_dev)
0060 {
0061     WARN_ON(!lockdep_rtnl_is_held() &&
0062         !devl_lock_is_held(priv_to_devlink(nsim_dev)));
0063 
0064     return nsim_dev->nsim_bus_dev->num_vfs;
0065 }
0066 
0067 static void
0068 nsim_bus_dev_set_vfs(struct nsim_bus_dev *nsim_bus_dev, unsigned int num_vfs)
0069 {
0070     rtnl_lock();
0071     nsim_bus_dev->num_vfs = num_vfs;
0072     rtnl_unlock();
0073 }
0074 
0075 #define NSIM_DEV_DUMMY_REGION_SIZE (1024 * 32)
0076 
0077 static int
0078 nsim_dev_take_snapshot(struct devlink *devlink,
0079                const struct devlink_region_ops *ops,
0080                struct netlink_ext_ack *extack,
0081                u8 **data)
0082 {
0083     void *dummy_data;
0084 
0085     dummy_data = kmalloc(NSIM_DEV_DUMMY_REGION_SIZE, GFP_KERNEL);
0086     if (!dummy_data)
0087         return -ENOMEM;
0088 
0089     get_random_bytes(dummy_data, NSIM_DEV_DUMMY_REGION_SIZE);
0090 
0091     *data = dummy_data;
0092 
0093     return 0;
0094 }
0095 
0096 static ssize_t nsim_dev_take_snapshot_write(struct file *file,
0097                         const char __user *data,
0098                         size_t count, loff_t *ppos)
0099 {
0100     struct nsim_dev *nsim_dev = file->private_data;
0101     struct devlink *devlink;
0102     u8 *dummy_data;
0103     int err;
0104     u32 id;
0105 
0106     devlink = priv_to_devlink(nsim_dev);
0107 
0108     err = nsim_dev_take_snapshot(devlink, NULL, NULL, &dummy_data);
0109     if (err)
0110         return err;
0111 
0112     err = devlink_region_snapshot_id_get(devlink, &id);
0113     if (err) {
0114         pr_err("Failed to get snapshot id\n");
0115         kfree(dummy_data);
0116         return err;
0117     }
0118     err = devlink_region_snapshot_create(nsim_dev->dummy_region,
0119                          dummy_data, id);
0120     devlink_region_snapshot_id_put(devlink, id);
0121     if (err) {
0122         pr_err("Failed to create region snapshot\n");
0123         kfree(dummy_data);
0124         return err;
0125     }
0126 
0127     return count;
0128 }
0129 
0130 static const struct file_operations nsim_dev_take_snapshot_fops = {
0131     .open = simple_open,
0132     .write = nsim_dev_take_snapshot_write,
0133     .llseek = generic_file_llseek,
0134     .owner = THIS_MODULE,
0135 };
0136 
0137 static ssize_t nsim_dev_trap_fa_cookie_read(struct file *file,
0138                         char __user *data,
0139                         size_t count, loff_t *ppos)
0140 {
0141     struct nsim_dev *nsim_dev = file->private_data;
0142     struct flow_action_cookie *fa_cookie;
0143     unsigned int buf_len;
0144     ssize_t ret;
0145     char *buf;
0146 
0147     spin_lock(&nsim_dev->fa_cookie_lock);
0148     fa_cookie = nsim_dev->fa_cookie;
0149     if (!fa_cookie) {
0150         ret = -EINVAL;
0151         goto errout;
0152     }
0153     buf_len = fa_cookie->cookie_len * 2;
0154     buf = kmalloc(buf_len, GFP_ATOMIC);
0155     if (!buf) {
0156         ret = -ENOMEM;
0157         goto errout;
0158     }
0159     bin2hex(buf, fa_cookie->cookie, fa_cookie->cookie_len);
0160     spin_unlock(&nsim_dev->fa_cookie_lock);
0161 
0162     ret = simple_read_from_buffer(data, count, ppos, buf, buf_len);
0163 
0164     kfree(buf);
0165     return ret;
0166 
0167 errout:
0168     spin_unlock(&nsim_dev->fa_cookie_lock);
0169     return ret;
0170 }
0171 
0172 static ssize_t nsim_dev_trap_fa_cookie_write(struct file *file,
0173                          const char __user *data,
0174                          size_t count, loff_t *ppos)
0175 {
0176     struct nsim_dev *nsim_dev = file->private_data;
0177     struct flow_action_cookie *fa_cookie;
0178     size_t cookie_len;
0179     ssize_t ret;
0180     char *buf;
0181 
0182     if (*ppos != 0)
0183         return -EINVAL;
0184     cookie_len = (count - 1) / 2;
0185     if ((count - 1) % 2)
0186         return -EINVAL;
0187     buf = kmalloc(count, GFP_KERNEL | __GFP_NOWARN);
0188     if (!buf)
0189         return -ENOMEM;
0190 
0191     ret = simple_write_to_buffer(buf, count, ppos, data, count);
0192     if (ret < 0)
0193         goto free_buf;
0194 
0195     fa_cookie = kmalloc(sizeof(*fa_cookie) + cookie_len,
0196                 GFP_KERNEL | __GFP_NOWARN);
0197     if (!fa_cookie) {
0198         ret = -ENOMEM;
0199         goto free_buf;
0200     }
0201 
0202     fa_cookie->cookie_len = cookie_len;
0203     ret = hex2bin(fa_cookie->cookie, buf, cookie_len);
0204     if (ret)
0205         goto free_fa_cookie;
0206     kfree(buf);
0207 
0208     spin_lock(&nsim_dev->fa_cookie_lock);
0209     kfree(nsim_dev->fa_cookie);
0210     nsim_dev->fa_cookie = fa_cookie;
0211     spin_unlock(&nsim_dev->fa_cookie_lock);
0212 
0213     return count;
0214 
0215 free_fa_cookie:
0216     kfree(fa_cookie);
0217 free_buf:
0218     kfree(buf);
0219     return ret;
0220 }
0221 
0222 static const struct file_operations nsim_dev_trap_fa_cookie_fops = {
0223     .open = simple_open,
0224     .read = nsim_dev_trap_fa_cookie_read,
0225     .write = nsim_dev_trap_fa_cookie_write,
0226     .llseek = generic_file_llseek,
0227     .owner = THIS_MODULE,
0228 };
0229 
0230 static ssize_t nsim_bus_dev_max_vfs_read(struct file *file, char __user *data,
0231                      size_t count, loff_t *ppos)
0232 {
0233     struct nsim_dev *nsim_dev = file->private_data;
0234     char buf[11];
0235     ssize_t len;
0236 
0237     len = scnprintf(buf, sizeof(buf), "%u\n",
0238             READ_ONCE(nsim_dev->nsim_bus_dev->max_vfs));
0239 
0240     return simple_read_from_buffer(data, count, ppos, buf, len);
0241 }
0242 
0243 static ssize_t nsim_bus_dev_max_vfs_write(struct file *file,
0244                       const char __user *data,
0245                       size_t count, loff_t *ppos)
0246 {
0247     struct nsim_vf_config *vfconfigs;
0248     struct nsim_dev *nsim_dev;
0249     char buf[10];
0250     ssize_t ret;
0251     u32 val;
0252 
0253     if (*ppos != 0)
0254         return 0;
0255 
0256     if (count >= sizeof(buf))
0257         return -ENOSPC;
0258 
0259     ret = copy_from_user(buf, data, count);
0260     if (ret)
0261         return -EFAULT;
0262     buf[count] = '\0';
0263 
0264     ret = kstrtouint(buf, 10, &val);
0265     if (ret)
0266         return -EINVAL;
0267 
0268     /* max_vfs limited by the maximum number of provided port indexes */
0269     if (val > NSIM_DEV_VF_PORT_INDEX_MAX - NSIM_DEV_VF_PORT_INDEX_BASE)
0270         return -ERANGE;
0271 
0272     vfconfigs = kcalloc(val, sizeof(struct nsim_vf_config),
0273                 GFP_KERNEL | __GFP_NOWARN);
0274     if (!vfconfigs)
0275         return -ENOMEM;
0276 
0277     nsim_dev = file->private_data;
0278     devl_lock(priv_to_devlink(nsim_dev));
0279     /* Reject if VFs are configured */
0280     if (nsim_dev_get_vfs(nsim_dev)) {
0281         ret = -EBUSY;
0282     } else {
0283         swap(nsim_dev->vfconfigs, vfconfigs);
0284         WRITE_ONCE(nsim_dev->nsim_bus_dev->max_vfs, val);
0285         *ppos += count;
0286         ret = count;
0287     }
0288     devl_unlock(priv_to_devlink(nsim_dev));
0289 
0290     kfree(vfconfigs);
0291     return ret;
0292 }
0293 
0294 static const struct file_operations nsim_dev_max_vfs_fops = {
0295     .open = simple_open,
0296     .read = nsim_bus_dev_max_vfs_read,
0297     .write = nsim_bus_dev_max_vfs_write,
0298     .llseek = generic_file_llseek,
0299     .owner = THIS_MODULE,
0300 };
0301 
0302 static int nsim_dev_debugfs_init(struct nsim_dev *nsim_dev)
0303 {
0304     char dev_ddir_name[sizeof(DRV_NAME) + 10];
0305     int err;
0306 
0307     sprintf(dev_ddir_name, DRV_NAME "%u", nsim_dev->nsim_bus_dev->dev.id);
0308     nsim_dev->ddir = debugfs_create_dir(dev_ddir_name, nsim_dev_ddir);
0309     if (IS_ERR(nsim_dev->ddir))
0310         return PTR_ERR(nsim_dev->ddir);
0311     nsim_dev->ports_ddir = debugfs_create_dir("ports", nsim_dev->ddir);
0312     if (IS_ERR(nsim_dev->ports_ddir))
0313         return PTR_ERR(nsim_dev->ports_ddir);
0314     debugfs_create_bool("fw_update_status", 0600, nsim_dev->ddir,
0315                 &nsim_dev->fw_update_status);
0316     debugfs_create_u32("fw_update_overwrite_mask", 0600, nsim_dev->ddir,
0317                 &nsim_dev->fw_update_overwrite_mask);
0318     debugfs_create_u32("max_macs", 0600, nsim_dev->ddir,
0319                &nsim_dev->max_macs);
0320     debugfs_create_bool("test1", 0600, nsim_dev->ddir,
0321                 &nsim_dev->test1);
0322     nsim_dev->take_snapshot = debugfs_create_file("take_snapshot",
0323                               0200,
0324                               nsim_dev->ddir,
0325                               nsim_dev,
0326                         &nsim_dev_take_snapshot_fops);
0327     debugfs_create_bool("dont_allow_reload", 0600, nsim_dev->ddir,
0328                 &nsim_dev->dont_allow_reload);
0329     debugfs_create_bool("fail_reload", 0600, nsim_dev->ddir,
0330                 &nsim_dev->fail_reload);
0331     debugfs_create_file("trap_flow_action_cookie", 0600, nsim_dev->ddir,
0332                 nsim_dev, &nsim_dev_trap_fa_cookie_fops);
0333     debugfs_create_bool("fail_trap_group_set", 0600,
0334                 nsim_dev->ddir,
0335                 &nsim_dev->fail_trap_group_set);
0336     debugfs_create_bool("fail_trap_policer_set", 0600,
0337                 nsim_dev->ddir,
0338                 &nsim_dev->fail_trap_policer_set);
0339     debugfs_create_bool("fail_trap_policer_counter_get", 0600,
0340                 nsim_dev->ddir,
0341                 &nsim_dev->fail_trap_policer_counter_get);
0342     /* caution, dev_max_vfs write takes devlink lock */
0343     debugfs_create_file("max_vfs", 0600, nsim_dev->ddir,
0344                 nsim_dev, &nsim_dev_max_vfs_fops);
0345 
0346     nsim_dev->nodes_ddir = debugfs_create_dir("rate_nodes", nsim_dev->ddir);
0347     if (IS_ERR(nsim_dev->nodes_ddir)) {
0348         err = PTR_ERR(nsim_dev->nodes_ddir);
0349         goto err_out;
0350     }
0351     debugfs_create_bool("fail_trap_drop_counter_get", 0600,
0352                 nsim_dev->ddir,
0353                 &nsim_dev->fail_trap_drop_counter_get);
0354     nsim_udp_tunnels_debugfs_create(nsim_dev);
0355     return 0;
0356 
0357 err_out:
0358     debugfs_remove_recursive(nsim_dev->ports_ddir);
0359     debugfs_remove_recursive(nsim_dev->ddir);
0360     return err;
0361 }
0362 
0363 static void nsim_dev_debugfs_exit(struct nsim_dev *nsim_dev)
0364 {
0365     debugfs_remove_recursive(nsim_dev->nodes_ddir);
0366     debugfs_remove_recursive(nsim_dev->ports_ddir);
0367     debugfs_remove_recursive(nsim_dev->ddir);
0368 }
0369 
0370 static ssize_t nsim_dev_rate_parent_read(struct file *file,
0371                      char __user *data,
0372                      size_t count, loff_t *ppos)
0373 {
0374     char **name_ptr = file->private_data;
0375     size_t len;
0376 
0377     if (!*name_ptr)
0378         return 0;
0379 
0380     len = strlen(*name_ptr);
0381     return simple_read_from_buffer(data, count, ppos, *name_ptr, len);
0382 }
0383 
0384 static const struct file_operations nsim_dev_rate_parent_fops = {
0385     .open = simple_open,
0386     .read = nsim_dev_rate_parent_read,
0387     .llseek = generic_file_llseek,
0388     .owner = THIS_MODULE,
0389 };
0390 
0391 static int nsim_dev_port_debugfs_init(struct nsim_dev *nsim_dev,
0392                       struct nsim_dev_port *nsim_dev_port)
0393 {
0394     struct nsim_bus_dev *nsim_bus_dev = nsim_dev->nsim_bus_dev;
0395     unsigned int port_index = nsim_dev_port->port_index;
0396     char port_ddir_name[16];
0397     char dev_link_name[32];
0398 
0399     sprintf(port_ddir_name, "%u", port_index);
0400     nsim_dev_port->ddir = debugfs_create_dir(port_ddir_name,
0401                          nsim_dev->ports_ddir);
0402     if (IS_ERR(nsim_dev_port->ddir))
0403         return PTR_ERR(nsim_dev_port->ddir);
0404 
0405     sprintf(dev_link_name, "../../../" DRV_NAME "%u", nsim_bus_dev->dev.id);
0406     if (nsim_dev_port_is_vf(nsim_dev_port)) {
0407         unsigned int vf_id = nsim_dev_port_index_to_vf_index(port_index);
0408 
0409         debugfs_create_u16("tx_share", 0400, nsim_dev_port->ddir,
0410                    &nsim_dev->vfconfigs[vf_id].min_tx_rate);
0411         debugfs_create_u16("tx_max", 0400, nsim_dev_port->ddir,
0412                    &nsim_dev->vfconfigs[vf_id].max_tx_rate);
0413         nsim_dev_port->rate_parent = debugfs_create_file("rate_parent",
0414                                  0400,
0415                                  nsim_dev_port->ddir,
0416                                  &nsim_dev_port->parent_name,
0417                                  &nsim_dev_rate_parent_fops);
0418     }
0419     debugfs_create_symlink("dev", nsim_dev_port->ddir, dev_link_name);
0420 
0421     return 0;
0422 }
0423 
0424 static void nsim_dev_port_debugfs_exit(struct nsim_dev_port *nsim_dev_port)
0425 {
0426     debugfs_remove_recursive(nsim_dev_port->ddir);
0427 }
0428 
0429 static int nsim_dev_resources_register(struct devlink *devlink)
0430 {
0431     struct devlink_resource_size_params params = {
0432         .size_max = (u64)-1,
0433         .size_granularity = 1,
0434         .unit = DEVLINK_RESOURCE_UNIT_ENTRY
0435     };
0436     int err;
0437 
0438     /* Resources for IPv4 */
0439     err = devl_resource_register(devlink, "IPv4", (u64)-1,
0440                      NSIM_RESOURCE_IPV4,
0441                      DEVLINK_RESOURCE_ID_PARENT_TOP,
0442                      &params);
0443     if (err) {
0444         pr_err("Failed to register IPv4 top resource\n");
0445         goto out;
0446     }
0447 
0448     err = devl_resource_register(devlink, "fib", (u64)-1,
0449                      NSIM_RESOURCE_IPV4_FIB,
0450                      NSIM_RESOURCE_IPV4, &params);
0451     if (err) {
0452         pr_err("Failed to register IPv4 FIB resource\n");
0453         return err;
0454     }
0455 
0456     err = devl_resource_register(devlink, "fib-rules", (u64)-1,
0457                      NSIM_RESOURCE_IPV4_FIB_RULES,
0458                      NSIM_RESOURCE_IPV4, &params);
0459     if (err) {
0460         pr_err("Failed to register IPv4 FIB rules resource\n");
0461         return err;
0462     }
0463 
0464     /* Resources for IPv6 */
0465     err = devl_resource_register(devlink, "IPv6", (u64)-1,
0466                      NSIM_RESOURCE_IPV6,
0467                      DEVLINK_RESOURCE_ID_PARENT_TOP,
0468                      &params);
0469     if (err) {
0470         pr_err("Failed to register IPv6 top resource\n");
0471         goto out;
0472     }
0473 
0474     err = devl_resource_register(devlink, "fib", (u64)-1,
0475                      NSIM_RESOURCE_IPV6_FIB,
0476                      NSIM_RESOURCE_IPV6, &params);
0477     if (err) {
0478         pr_err("Failed to register IPv6 FIB resource\n");
0479         return err;
0480     }
0481 
0482     err = devl_resource_register(devlink, "fib-rules", (u64)-1,
0483                      NSIM_RESOURCE_IPV6_FIB_RULES,
0484                      NSIM_RESOURCE_IPV6, &params);
0485     if (err) {
0486         pr_err("Failed to register IPv6 FIB rules resource\n");
0487         return err;
0488     }
0489 
0490     /* Resources for nexthops */
0491     err = devl_resource_register(devlink, "nexthops", (u64)-1,
0492                      NSIM_RESOURCE_NEXTHOPS,
0493                      DEVLINK_RESOURCE_ID_PARENT_TOP,
0494                      &params);
0495 
0496 out:
0497     return err;
0498 }
0499 
0500 enum nsim_devlink_param_id {
0501     NSIM_DEVLINK_PARAM_ID_BASE = DEVLINK_PARAM_GENERIC_ID_MAX,
0502     NSIM_DEVLINK_PARAM_ID_TEST1,
0503 };
0504 
0505 static const struct devlink_param nsim_devlink_params[] = {
0506     DEVLINK_PARAM_GENERIC(MAX_MACS,
0507                   BIT(DEVLINK_PARAM_CMODE_DRIVERINIT),
0508                   NULL, NULL, NULL),
0509     DEVLINK_PARAM_DRIVER(NSIM_DEVLINK_PARAM_ID_TEST1,
0510                  "test1", DEVLINK_PARAM_TYPE_BOOL,
0511                  BIT(DEVLINK_PARAM_CMODE_DRIVERINIT),
0512                  NULL, NULL, NULL),
0513 };
0514 
0515 static void nsim_devlink_set_params_init_values(struct nsim_dev *nsim_dev,
0516                         struct devlink *devlink)
0517 {
0518     union devlink_param_value value;
0519 
0520     value.vu32 = nsim_dev->max_macs;
0521     devlink_param_driverinit_value_set(devlink,
0522                        DEVLINK_PARAM_GENERIC_ID_MAX_MACS,
0523                        value);
0524     value.vbool = nsim_dev->test1;
0525     devlink_param_driverinit_value_set(devlink,
0526                        NSIM_DEVLINK_PARAM_ID_TEST1,
0527                        value);
0528 }
0529 
0530 static void nsim_devlink_param_load_driverinit_values(struct devlink *devlink)
0531 {
0532     struct nsim_dev *nsim_dev = devlink_priv(devlink);
0533     union devlink_param_value saved_value;
0534     int err;
0535 
0536     err = devlink_param_driverinit_value_get(devlink,
0537                          DEVLINK_PARAM_GENERIC_ID_MAX_MACS,
0538                          &saved_value);
0539     if (!err)
0540         nsim_dev->max_macs = saved_value.vu32;
0541     err = devlink_param_driverinit_value_get(devlink,
0542                          NSIM_DEVLINK_PARAM_ID_TEST1,
0543                          &saved_value);
0544     if (!err)
0545         nsim_dev->test1 = saved_value.vbool;
0546 }
0547 
0548 #define NSIM_DEV_DUMMY_REGION_SNAPSHOT_MAX 16
0549 
0550 static const struct devlink_region_ops dummy_region_ops = {
0551     .name = "dummy",
0552     .destructor = &kfree,
0553     .snapshot = nsim_dev_take_snapshot,
0554 };
0555 
0556 static int nsim_dev_dummy_region_init(struct nsim_dev *nsim_dev,
0557                       struct devlink *devlink)
0558 {
0559     nsim_dev->dummy_region =
0560         devl_region_create(devlink, &dummy_region_ops,
0561                    NSIM_DEV_DUMMY_REGION_SNAPSHOT_MAX,
0562                    NSIM_DEV_DUMMY_REGION_SIZE);
0563     return PTR_ERR_OR_ZERO(nsim_dev->dummy_region);
0564 }
0565 
0566 static void nsim_dev_dummy_region_exit(struct nsim_dev *nsim_dev)
0567 {
0568     devl_region_destroy(nsim_dev->dummy_region);
0569 }
0570 
0571 static int
0572 __nsim_dev_port_add(struct nsim_dev *nsim_dev, enum nsim_dev_port_type type,
0573             unsigned int port_index);
0574 static void __nsim_dev_port_del(struct nsim_dev_port *nsim_dev_port);
0575 
0576 static int nsim_esw_legacy_enable(struct nsim_dev *nsim_dev,
0577                   struct netlink_ext_ack *extack)
0578 {
0579     struct devlink *devlink = priv_to_devlink(nsim_dev);
0580     struct nsim_dev_port *nsim_dev_port, *tmp;
0581 
0582     devl_rate_nodes_destroy(devlink);
0583     list_for_each_entry_safe(nsim_dev_port, tmp, &nsim_dev->port_list, list)
0584         if (nsim_dev_port_is_vf(nsim_dev_port))
0585             __nsim_dev_port_del(nsim_dev_port);
0586     nsim_dev->esw_mode = DEVLINK_ESWITCH_MODE_LEGACY;
0587     return 0;
0588 }
0589 
0590 static int nsim_esw_switchdev_enable(struct nsim_dev *nsim_dev,
0591                      struct netlink_ext_ack *extack)
0592 {
0593     struct nsim_dev_port *nsim_dev_port, *tmp;
0594     int i, err;
0595 
0596     for (i = 0; i < nsim_dev_get_vfs(nsim_dev); i++) {
0597         err = __nsim_dev_port_add(nsim_dev, NSIM_DEV_PORT_TYPE_VF, i);
0598         if (err) {
0599             NL_SET_ERR_MSG_MOD(extack, "Failed to initialize VFs' netdevsim ports");
0600             pr_err("Failed to initialize VF id=%d. %d.\n", i, err);
0601             goto err_port_add_vfs;
0602         }
0603     }
0604     nsim_dev->esw_mode = DEVLINK_ESWITCH_MODE_SWITCHDEV;
0605     return 0;
0606 
0607 err_port_add_vfs:
0608     list_for_each_entry_safe(nsim_dev_port, tmp, &nsim_dev->port_list, list)
0609         if (nsim_dev_port_is_vf(nsim_dev_port))
0610             __nsim_dev_port_del(nsim_dev_port);
0611     return err;
0612 }
0613 
0614 static int nsim_devlink_eswitch_mode_set(struct devlink *devlink, u16 mode,
0615                      struct netlink_ext_ack *extack)
0616 {
0617     struct nsim_dev *nsim_dev = devlink_priv(devlink);
0618 
0619     if (mode == nsim_dev->esw_mode)
0620         return 0;
0621 
0622     if (mode == DEVLINK_ESWITCH_MODE_LEGACY)
0623         return nsim_esw_legacy_enable(nsim_dev, extack);
0624     if (mode == DEVLINK_ESWITCH_MODE_SWITCHDEV)
0625         return nsim_esw_switchdev_enable(nsim_dev, extack);
0626 
0627     return -EINVAL;
0628 }
0629 
0630 static int nsim_devlink_eswitch_mode_get(struct devlink *devlink, u16 *mode)
0631 {
0632     struct nsim_dev *nsim_dev = devlink_priv(devlink);
0633 
0634     *mode = nsim_dev->esw_mode;
0635     return 0;
0636 }
0637 
0638 struct nsim_trap_item {
0639     void *trap_ctx;
0640     enum devlink_trap_action action;
0641 };
0642 
0643 struct nsim_trap_data {
0644     struct delayed_work trap_report_dw;
0645     struct nsim_trap_item *trap_items_arr;
0646     u64 *trap_policers_cnt_arr;
0647     u64 trap_pkt_cnt;
0648     struct nsim_dev *nsim_dev;
0649     spinlock_t trap_lock;   /* Protects trap_items_arr */
0650 };
0651 
0652 /* All driver-specific traps must be documented in
0653  * Documentation/networking/devlink/netdevsim.rst
0654  */
0655 enum {
0656     NSIM_TRAP_ID_BASE = DEVLINK_TRAP_GENERIC_ID_MAX,
0657     NSIM_TRAP_ID_FID_MISS,
0658 };
0659 
0660 #define NSIM_TRAP_NAME_FID_MISS "fid_miss"
0661 
0662 #define NSIM_TRAP_METADATA DEVLINK_TRAP_METADATA_TYPE_F_IN_PORT
0663 
0664 #define NSIM_TRAP_DROP(_id, _group_id)                        \
0665     DEVLINK_TRAP_GENERIC(DROP, DROP, _id,                     \
0666                  DEVLINK_TRAP_GROUP_GENERIC_ID_##_group_id,       \
0667                  NSIM_TRAP_METADATA)
0668 #define NSIM_TRAP_DROP_EXT(_id, _group_id, _metadata)                 \
0669     DEVLINK_TRAP_GENERIC(DROP, DROP, _id,                     \
0670                  DEVLINK_TRAP_GROUP_GENERIC_ID_##_group_id,       \
0671                  NSIM_TRAP_METADATA | (_metadata))
0672 #define NSIM_TRAP_EXCEPTION(_id, _group_id)                   \
0673     DEVLINK_TRAP_GENERIC(EXCEPTION, TRAP, _id,                \
0674                  DEVLINK_TRAP_GROUP_GENERIC_ID_##_group_id,       \
0675                  NSIM_TRAP_METADATA)
0676 #define NSIM_TRAP_CONTROL(_id, _group_id, _action)                \
0677     DEVLINK_TRAP_GENERIC(CONTROL, _action, _id,               \
0678                  DEVLINK_TRAP_GROUP_GENERIC_ID_##_group_id,       \
0679                  NSIM_TRAP_METADATA)
0680 #define NSIM_TRAP_DRIVER_EXCEPTION(_id, _group_id)                \
0681     DEVLINK_TRAP_DRIVER(EXCEPTION, TRAP, NSIM_TRAP_ID_##_id,          \
0682                 NSIM_TRAP_NAME_##_id,                 \
0683                 DEVLINK_TRAP_GROUP_GENERIC_ID_##_group_id,        \
0684                 NSIM_TRAP_METADATA)
0685 
0686 #define NSIM_DEV_TRAP_POLICER_MIN_RATE  1
0687 #define NSIM_DEV_TRAP_POLICER_MAX_RATE  8000
0688 #define NSIM_DEV_TRAP_POLICER_MIN_BURST 8
0689 #define NSIM_DEV_TRAP_POLICER_MAX_BURST 65536
0690 
0691 #define NSIM_TRAP_POLICER(_id, _rate, _burst)                     \
0692     DEVLINK_TRAP_POLICER(_id, _rate, _burst,                  \
0693                  NSIM_DEV_TRAP_POLICER_MAX_RATE,              \
0694                  NSIM_DEV_TRAP_POLICER_MIN_RATE,              \
0695                  NSIM_DEV_TRAP_POLICER_MAX_BURST,             \
0696                  NSIM_DEV_TRAP_POLICER_MIN_BURST)
0697 
0698 static const struct devlink_trap_policer nsim_trap_policers_arr[] = {
0699     NSIM_TRAP_POLICER(1, 1000, 128),
0700     NSIM_TRAP_POLICER(2, 2000, 256),
0701     NSIM_TRAP_POLICER(3, 3000, 512),
0702 };
0703 
0704 static const struct devlink_trap_group nsim_trap_groups_arr[] = {
0705     DEVLINK_TRAP_GROUP_GENERIC(L2_DROPS, 0),
0706     DEVLINK_TRAP_GROUP_GENERIC(L3_DROPS, 1),
0707     DEVLINK_TRAP_GROUP_GENERIC(L3_EXCEPTIONS, 1),
0708     DEVLINK_TRAP_GROUP_GENERIC(BUFFER_DROPS, 2),
0709     DEVLINK_TRAP_GROUP_GENERIC(ACL_DROPS, 3),
0710     DEVLINK_TRAP_GROUP_GENERIC(MC_SNOOPING, 3),
0711 };
0712 
0713 static const struct devlink_trap nsim_traps_arr[] = {
0714     NSIM_TRAP_DROP(SMAC_MC, L2_DROPS),
0715     NSIM_TRAP_DROP(VLAN_TAG_MISMATCH, L2_DROPS),
0716     NSIM_TRAP_DROP(INGRESS_VLAN_FILTER, L2_DROPS),
0717     NSIM_TRAP_DROP(INGRESS_STP_FILTER, L2_DROPS),
0718     NSIM_TRAP_DROP(EMPTY_TX_LIST, L2_DROPS),
0719     NSIM_TRAP_DROP(PORT_LOOPBACK_FILTER, L2_DROPS),
0720     NSIM_TRAP_DRIVER_EXCEPTION(FID_MISS, L2_DROPS),
0721     NSIM_TRAP_DROP(BLACKHOLE_ROUTE, L3_DROPS),
0722     NSIM_TRAP_EXCEPTION(TTL_ERROR, L3_EXCEPTIONS),
0723     NSIM_TRAP_DROP(TAIL_DROP, BUFFER_DROPS),
0724     NSIM_TRAP_DROP_EXT(INGRESS_FLOW_ACTION_DROP, ACL_DROPS,
0725                DEVLINK_TRAP_METADATA_TYPE_F_FA_COOKIE),
0726     NSIM_TRAP_DROP_EXT(EGRESS_FLOW_ACTION_DROP, ACL_DROPS,
0727                DEVLINK_TRAP_METADATA_TYPE_F_FA_COOKIE),
0728     NSIM_TRAP_CONTROL(IGMP_QUERY, MC_SNOOPING, MIRROR),
0729     NSIM_TRAP_CONTROL(IGMP_V1_REPORT, MC_SNOOPING, TRAP),
0730 };
0731 
0732 #define NSIM_TRAP_L4_DATA_LEN 100
0733 
0734 static struct sk_buff *nsim_dev_trap_skb_build(void)
0735 {
0736     int tot_len, data_len = NSIM_TRAP_L4_DATA_LEN;
0737     struct sk_buff *skb;
0738     struct udphdr *udph;
0739     struct ethhdr *eth;
0740     struct iphdr *iph;
0741 
0742     skb = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);
0743     if (!skb)
0744         return NULL;
0745     tot_len = sizeof(struct iphdr) + sizeof(struct udphdr) + data_len;
0746 
0747     skb_reset_mac_header(skb);
0748     eth = skb_put(skb, sizeof(struct ethhdr));
0749     eth_random_addr(eth->h_dest);
0750     eth_random_addr(eth->h_source);
0751     eth->h_proto = htons(ETH_P_IP);
0752     skb->protocol = htons(ETH_P_IP);
0753 
0754     skb_set_network_header(skb, skb->len);
0755     iph = skb_put(skb, sizeof(struct iphdr));
0756     iph->protocol = IPPROTO_UDP;
0757     iph->saddr = in_aton("192.0.2.1");
0758     iph->daddr = in_aton("198.51.100.1");
0759     iph->version = 0x4;
0760     iph->frag_off = 0;
0761     iph->ihl = 0x5;
0762     iph->tot_len = htons(tot_len);
0763     iph->ttl = 100;
0764     iph->check = 0;
0765     iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
0766 
0767     skb_set_transport_header(skb, skb->len);
0768     udph = skb_put_zero(skb, sizeof(struct udphdr) + data_len);
0769     get_random_bytes(&udph->source, sizeof(u16));
0770     get_random_bytes(&udph->dest, sizeof(u16));
0771     udph->len = htons(sizeof(struct udphdr) + data_len);
0772 
0773     return skb;
0774 }
0775 
0776 static void nsim_dev_trap_report(struct nsim_dev_port *nsim_dev_port)
0777 {
0778     struct nsim_dev *nsim_dev = nsim_dev_port->ns->nsim_dev;
0779     struct devlink *devlink = priv_to_devlink(nsim_dev);
0780     struct nsim_trap_data *nsim_trap_data;
0781     int i;
0782 
0783     nsim_trap_data = nsim_dev->trap_data;
0784 
0785     spin_lock(&nsim_trap_data->trap_lock);
0786     for (i = 0; i < ARRAY_SIZE(nsim_traps_arr); i++) {
0787         struct flow_action_cookie *fa_cookie = NULL;
0788         struct nsim_trap_item *nsim_trap_item;
0789         struct sk_buff *skb;
0790         bool has_fa_cookie;
0791 
0792         has_fa_cookie = nsim_traps_arr[i].metadata_cap &
0793                 DEVLINK_TRAP_METADATA_TYPE_F_FA_COOKIE;
0794 
0795         nsim_trap_item = &nsim_trap_data->trap_items_arr[i];
0796         if (nsim_trap_item->action == DEVLINK_TRAP_ACTION_DROP)
0797             continue;
0798 
0799         skb = nsim_dev_trap_skb_build();
0800         if (!skb)
0801             continue;
0802         skb->dev = nsim_dev_port->ns->netdev;
0803 
0804         /* Trapped packets are usually passed to devlink in softIRQ,
0805          * but in this case they are generated in a workqueue. Disable
0806          * softIRQs to prevent lockdep from complaining about
0807          * "incosistent lock state".
0808          */
0809 
0810         spin_lock_bh(&nsim_dev->fa_cookie_lock);
0811         fa_cookie = has_fa_cookie ? nsim_dev->fa_cookie : NULL;
0812         devlink_trap_report(devlink, skb, nsim_trap_item->trap_ctx,
0813                     &nsim_dev_port->devlink_port, fa_cookie);
0814         spin_unlock_bh(&nsim_dev->fa_cookie_lock);
0815         consume_skb(skb);
0816     }
0817     spin_unlock(&nsim_trap_data->trap_lock);
0818 }
0819 
0820 #define NSIM_TRAP_REPORT_INTERVAL_MS    100
0821 
0822 static void nsim_dev_trap_report_work(struct work_struct *work)
0823 {
0824     struct nsim_trap_data *nsim_trap_data;
0825     struct nsim_dev_port *nsim_dev_port;
0826     struct nsim_dev *nsim_dev;
0827 
0828     nsim_trap_data = container_of(work, struct nsim_trap_data,
0829                       trap_report_dw.work);
0830     nsim_dev = nsim_trap_data->nsim_dev;
0831 
0832     /* For each running port and enabled packet trap, generate a UDP
0833      * packet with a random 5-tuple and report it.
0834      */
0835     if (!devl_trylock(priv_to_devlink(nsim_dev))) {
0836         schedule_delayed_work(&nsim_dev->trap_data->trap_report_dw, 0);
0837         return;
0838     }
0839 
0840     list_for_each_entry(nsim_dev_port, &nsim_dev->port_list, list) {
0841         if (!netif_running(nsim_dev_port->ns->netdev))
0842             continue;
0843 
0844         nsim_dev_trap_report(nsim_dev_port);
0845     }
0846     devl_unlock(priv_to_devlink(nsim_dev));
0847 
0848     schedule_delayed_work(&nsim_dev->trap_data->trap_report_dw,
0849                   msecs_to_jiffies(NSIM_TRAP_REPORT_INTERVAL_MS));
0850 }
0851 
0852 static int nsim_dev_traps_init(struct devlink *devlink)
0853 {
0854     size_t policers_count = ARRAY_SIZE(nsim_trap_policers_arr);
0855     struct nsim_dev *nsim_dev = devlink_priv(devlink);
0856     struct nsim_trap_data *nsim_trap_data;
0857     int err;
0858 
0859     nsim_trap_data = kzalloc(sizeof(*nsim_trap_data), GFP_KERNEL);
0860     if (!nsim_trap_data)
0861         return -ENOMEM;
0862 
0863     nsim_trap_data->trap_items_arr = kcalloc(ARRAY_SIZE(nsim_traps_arr),
0864                          sizeof(struct nsim_trap_item),
0865                          GFP_KERNEL);
0866     if (!nsim_trap_data->trap_items_arr) {
0867         err = -ENOMEM;
0868         goto err_trap_data_free;
0869     }
0870 
0871     nsim_trap_data->trap_policers_cnt_arr = kcalloc(policers_count,
0872                             sizeof(u64),
0873                             GFP_KERNEL);
0874     if (!nsim_trap_data->trap_policers_cnt_arr) {
0875         err = -ENOMEM;
0876         goto err_trap_items_free;
0877     }
0878 
0879     /* The lock is used to protect the action state of the registered
0880      * traps. The value is written by user and read in delayed work when
0881      * iterating over all the traps.
0882      */
0883     spin_lock_init(&nsim_trap_data->trap_lock);
0884     nsim_trap_data->nsim_dev = nsim_dev;
0885     nsim_dev->trap_data = nsim_trap_data;
0886 
0887     err = devl_trap_policers_register(devlink, nsim_trap_policers_arr,
0888                       policers_count);
0889     if (err)
0890         goto err_trap_policers_cnt_free;
0891 
0892     err = devl_trap_groups_register(devlink, nsim_trap_groups_arr,
0893                     ARRAY_SIZE(nsim_trap_groups_arr));
0894     if (err)
0895         goto err_trap_policers_unregister;
0896 
0897     err = devl_traps_register(devlink, nsim_traps_arr,
0898                   ARRAY_SIZE(nsim_traps_arr), NULL);
0899     if (err)
0900         goto err_trap_groups_unregister;
0901 
0902     INIT_DELAYED_WORK(&nsim_dev->trap_data->trap_report_dw,
0903               nsim_dev_trap_report_work);
0904     schedule_delayed_work(&nsim_dev->trap_data->trap_report_dw,
0905                   msecs_to_jiffies(NSIM_TRAP_REPORT_INTERVAL_MS));
0906 
0907     return 0;
0908 
0909 err_trap_groups_unregister:
0910     devl_trap_groups_unregister(devlink, nsim_trap_groups_arr,
0911                     ARRAY_SIZE(nsim_trap_groups_arr));
0912 err_trap_policers_unregister:
0913     devl_trap_policers_unregister(devlink, nsim_trap_policers_arr,
0914                       ARRAY_SIZE(nsim_trap_policers_arr));
0915 err_trap_policers_cnt_free:
0916     kfree(nsim_trap_data->trap_policers_cnt_arr);
0917 err_trap_items_free:
0918     kfree(nsim_trap_data->trap_items_arr);
0919 err_trap_data_free:
0920     kfree(nsim_trap_data);
0921     return err;
0922 }
0923 
0924 static void nsim_dev_traps_exit(struct devlink *devlink)
0925 {
0926     struct nsim_dev *nsim_dev = devlink_priv(devlink);
0927 
0928     /* caution, trap work takes devlink lock */
0929     cancel_delayed_work_sync(&nsim_dev->trap_data->trap_report_dw);
0930     devl_traps_unregister(devlink, nsim_traps_arr,
0931                   ARRAY_SIZE(nsim_traps_arr));
0932     devl_trap_groups_unregister(devlink, nsim_trap_groups_arr,
0933                     ARRAY_SIZE(nsim_trap_groups_arr));
0934     devl_trap_policers_unregister(devlink, nsim_trap_policers_arr,
0935                       ARRAY_SIZE(nsim_trap_policers_arr));
0936     kfree(nsim_dev->trap_data->trap_policers_cnt_arr);
0937     kfree(nsim_dev->trap_data->trap_items_arr);
0938     kfree(nsim_dev->trap_data);
0939 }
0940 
0941 static int nsim_dev_reload_create(struct nsim_dev *nsim_dev,
0942                   struct netlink_ext_ack *extack);
0943 static void nsim_dev_reload_destroy(struct nsim_dev *nsim_dev);
0944 
0945 static int nsim_dev_reload_down(struct devlink *devlink, bool netns_change,
0946                 enum devlink_reload_action action, enum devlink_reload_limit limit,
0947                 struct netlink_ext_ack *extack)
0948 {
0949     struct nsim_dev *nsim_dev = devlink_priv(devlink);
0950 
0951     if (nsim_dev->dont_allow_reload) {
0952         /* For testing purposes, user set debugfs dont_allow_reload
0953          * value to true. So forbid it.
0954          */
0955         NL_SET_ERR_MSG_MOD(extack, "User forbid the reload for testing purposes");
0956         return -EOPNOTSUPP;
0957     }
0958 
0959     nsim_dev_reload_destroy(nsim_dev);
0960     return 0;
0961 }
0962 
0963 static int nsim_dev_reload_up(struct devlink *devlink, enum devlink_reload_action action,
0964                   enum devlink_reload_limit limit, u32 *actions_performed,
0965                   struct netlink_ext_ack *extack)
0966 {
0967     struct nsim_dev *nsim_dev = devlink_priv(devlink);
0968     int ret;
0969 
0970     if (nsim_dev->fail_reload) {
0971         /* For testing purposes, user set debugfs fail_reload
0972          * value to true. Fail right away.
0973          */
0974         NL_SET_ERR_MSG_MOD(extack, "User setup the reload to fail for testing purposes");
0975         return -EINVAL;
0976     }
0977 
0978     *actions_performed = BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT);
0979     ret = nsim_dev_reload_create(nsim_dev, extack);
0980     return ret;
0981 }
0982 
0983 static int nsim_dev_info_get(struct devlink *devlink,
0984                  struct devlink_info_req *req,
0985                  struct netlink_ext_ack *extack)
0986 {
0987     return devlink_info_driver_name_put(req, DRV_NAME);
0988 }
0989 
0990 #define NSIM_DEV_FLASH_SIZE 500000
0991 #define NSIM_DEV_FLASH_CHUNK_SIZE 1000
0992 #define NSIM_DEV_FLASH_CHUNK_TIME_MS 10
0993 
0994 static int nsim_dev_flash_update(struct devlink *devlink,
0995                  struct devlink_flash_update_params *params,
0996                  struct netlink_ext_ack *extack)
0997 {
0998     struct nsim_dev *nsim_dev = devlink_priv(devlink);
0999     int i;
1000 
1001     if ((params->overwrite_mask & ~nsim_dev->fw_update_overwrite_mask) != 0)
1002         return -EOPNOTSUPP;
1003 
1004     if (nsim_dev->fw_update_status) {
1005         devlink_flash_update_status_notify(devlink,
1006                            "Preparing to flash",
1007                            params->component, 0, 0);
1008     }
1009 
1010     for (i = 0; i < NSIM_DEV_FLASH_SIZE / NSIM_DEV_FLASH_CHUNK_SIZE; i++) {
1011         if (nsim_dev->fw_update_status)
1012             devlink_flash_update_status_notify(devlink, "Flashing",
1013                                params->component,
1014                                i * NSIM_DEV_FLASH_CHUNK_SIZE,
1015                                NSIM_DEV_FLASH_SIZE);
1016         msleep(NSIM_DEV_FLASH_CHUNK_TIME_MS);
1017     }
1018 
1019     if (nsim_dev->fw_update_status) {
1020         devlink_flash_update_status_notify(devlink, "Flashing",
1021                            params->component,
1022                            NSIM_DEV_FLASH_SIZE,
1023                            NSIM_DEV_FLASH_SIZE);
1024         devlink_flash_update_timeout_notify(devlink, "Flash select",
1025                             params->component, 81);
1026         devlink_flash_update_status_notify(devlink, "Flashing done",
1027                            params->component, 0, 0);
1028     }
1029 
1030     return 0;
1031 }
1032 
1033 static struct nsim_trap_item *
1034 nsim_dev_trap_item_lookup(struct nsim_dev *nsim_dev, u16 trap_id)
1035 {
1036     struct nsim_trap_data *nsim_trap_data = nsim_dev->trap_data;
1037     int i;
1038 
1039     for (i = 0; i < ARRAY_SIZE(nsim_traps_arr); i++) {
1040         if (nsim_traps_arr[i].id == trap_id)
1041             return &nsim_trap_data->trap_items_arr[i];
1042     }
1043 
1044     return NULL;
1045 }
1046 
1047 static int nsim_dev_devlink_trap_init(struct devlink *devlink,
1048                       const struct devlink_trap *trap,
1049                       void *trap_ctx)
1050 {
1051     struct nsim_dev *nsim_dev = devlink_priv(devlink);
1052     struct nsim_trap_item *nsim_trap_item;
1053 
1054     nsim_trap_item = nsim_dev_trap_item_lookup(nsim_dev, trap->id);
1055     if (WARN_ON(!nsim_trap_item))
1056         return -ENOENT;
1057 
1058     nsim_trap_item->trap_ctx = trap_ctx;
1059     nsim_trap_item->action = trap->init_action;
1060 
1061     return 0;
1062 }
1063 
1064 static int
1065 nsim_dev_devlink_trap_action_set(struct devlink *devlink,
1066                  const struct devlink_trap *trap,
1067                  enum devlink_trap_action action,
1068                  struct netlink_ext_ack *extack)
1069 {
1070     struct nsim_dev *nsim_dev = devlink_priv(devlink);
1071     struct nsim_trap_item *nsim_trap_item;
1072 
1073     nsim_trap_item = nsim_dev_trap_item_lookup(nsim_dev, trap->id);
1074     if (WARN_ON(!nsim_trap_item))
1075         return -ENOENT;
1076 
1077     spin_lock(&nsim_dev->trap_data->trap_lock);
1078     nsim_trap_item->action = action;
1079     spin_unlock(&nsim_dev->trap_data->trap_lock);
1080 
1081     return 0;
1082 }
1083 
1084 static int
1085 nsim_dev_devlink_trap_group_set(struct devlink *devlink,
1086                 const struct devlink_trap_group *group,
1087                 const struct devlink_trap_policer *policer,
1088                 struct netlink_ext_ack *extack)
1089 {
1090     struct nsim_dev *nsim_dev = devlink_priv(devlink);
1091 
1092     if (nsim_dev->fail_trap_group_set)
1093         return -EINVAL;
1094 
1095     return 0;
1096 }
1097 
1098 static int
1099 nsim_dev_devlink_trap_policer_set(struct devlink *devlink,
1100                   const struct devlink_trap_policer *policer,
1101                   u64 rate, u64 burst,
1102                   struct netlink_ext_ack *extack)
1103 {
1104     struct nsim_dev *nsim_dev = devlink_priv(devlink);
1105 
1106     if (nsim_dev->fail_trap_policer_set) {
1107         NL_SET_ERR_MSG_MOD(extack, "User setup the operation to fail for testing purposes");
1108         return -EINVAL;
1109     }
1110 
1111     return 0;
1112 }
1113 
1114 static int
1115 nsim_dev_devlink_trap_policer_counter_get(struct devlink *devlink,
1116                       const struct devlink_trap_policer *policer,
1117                       u64 *p_drops)
1118 {
1119     struct nsim_dev *nsim_dev = devlink_priv(devlink);
1120     u64 *cnt;
1121 
1122     if (nsim_dev->fail_trap_policer_counter_get)
1123         return -EINVAL;
1124 
1125     cnt = &nsim_dev->trap_data->trap_policers_cnt_arr[policer->id - 1];
1126     *p_drops = (*cnt)++;
1127 
1128     return 0;
1129 }
1130 
1131 #define NSIM_LINK_SPEED_MAX     5000 /* Mbps */
1132 #define NSIM_LINK_SPEED_UNIT    125000 /* 1 Mbps given in bytes/sec to avoid
1133                     * u64 overflow during conversion from
1134                     * bytes to bits.
1135                     */
1136 
1137 static int nsim_rate_bytes_to_units(char *name, u64 *rate, struct netlink_ext_ack *extack)
1138 {
1139     u64 val;
1140     u32 rem;
1141 
1142     val = div_u64_rem(*rate, NSIM_LINK_SPEED_UNIT, &rem);
1143     if (rem) {
1144         pr_err("%s rate value %lluBps not in link speed units of 1Mbps.\n",
1145                name, *rate);
1146         NL_SET_ERR_MSG_MOD(extack, "TX rate value not in link speed units of 1Mbps.");
1147         return -EINVAL;
1148     }
1149 
1150     if (val > NSIM_LINK_SPEED_MAX) {
1151         pr_err("%s rate value %lluMbps exceed link maximum speed 5000Mbps.\n",
1152                name, val);
1153         NL_SET_ERR_MSG_MOD(extack, "TX rate value exceed link maximum speed 5000Mbps.");
1154         return -EINVAL;
1155     }
1156     *rate = val;
1157     return 0;
1158 }
1159 
1160 static int nsim_leaf_tx_share_set(struct devlink_rate *devlink_rate, void *priv,
1161                   u64 tx_share, struct netlink_ext_ack *extack)
1162 {
1163     struct nsim_dev_port *nsim_dev_port = priv;
1164     struct nsim_dev *nsim_dev = nsim_dev_port->ns->nsim_dev;
1165     int vf_id = nsim_dev_port_index_to_vf_index(nsim_dev_port->port_index);
1166     int err;
1167 
1168     err = nsim_rate_bytes_to_units("tx_share", &tx_share, extack);
1169     if (err)
1170         return err;
1171 
1172     nsim_dev->vfconfigs[vf_id].min_tx_rate = tx_share;
1173     return 0;
1174 }
1175 
1176 static int nsim_leaf_tx_max_set(struct devlink_rate *devlink_rate, void *priv,
1177                 u64 tx_max, struct netlink_ext_ack *extack)
1178 {
1179     struct nsim_dev_port *nsim_dev_port = priv;
1180     struct nsim_dev *nsim_dev = nsim_dev_port->ns->nsim_dev;
1181     int vf_id = nsim_dev_port_index_to_vf_index(nsim_dev_port->port_index);
1182     int err;
1183 
1184     err = nsim_rate_bytes_to_units("tx_max", &tx_max, extack);
1185     if (err)
1186         return err;
1187 
1188     nsim_dev->vfconfigs[vf_id].max_tx_rate = tx_max;
1189     return 0;
1190 }
1191 
1192 struct nsim_rate_node {
1193     struct dentry *ddir;
1194     struct dentry *rate_parent;
1195     char *parent_name;
1196     u16 tx_share;
1197     u16 tx_max;
1198 };
1199 
1200 static int nsim_node_tx_share_set(struct devlink_rate *devlink_rate, void *priv,
1201                   u64 tx_share, struct netlink_ext_ack *extack)
1202 {
1203     struct nsim_rate_node *nsim_node = priv;
1204     int err;
1205 
1206     err = nsim_rate_bytes_to_units("tx_share", &tx_share, extack);
1207     if (err)
1208         return err;
1209 
1210     nsim_node->tx_share = tx_share;
1211     return 0;
1212 }
1213 
1214 static int nsim_node_tx_max_set(struct devlink_rate *devlink_rate, void *priv,
1215                 u64 tx_max, struct netlink_ext_ack *extack)
1216 {
1217     struct nsim_rate_node *nsim_node = priv;
1218     int err;
1219 
1220     err = nsim_rate_bytes_to_units("tx_max", &tx_max, extack);
1221     if (err)
1222         return err;
1223 
1224     nsim_node->tx_max = tx_max;
1225     return 0;
1226 }
1227 
1228 static int nsim_rate_node_new(struct devlink_rate *node, void **priv,
1229                   struct netlink_ext_ack *extack)
1230 {
1231     struct nsim_dev *nsim_dev = devlink_priv(node->devlink);
1232     struct nsim_rate_node *nsim_node;
1233 
1234     if (!nsim_esw_mode_is_switchdev(nsim_dev)) {
1235         NL_SET_ERR_MSG_MOD(extack, "Node creation allowed only in switchdev mode.");
1236         return -EOPNOTSUPP;
1237     }
1238 
1239     nsim_node = kzalloc(sizeof(*nsim_node), GFP_KERNEL);
1240     if (!nsim_node)
1241         return -ENOMEM;
1242 
1243     nsim_node->ddir = debugfs_create_dir(node->name, nsim_dev->nodes_ddir);
1244 
1245     debugfs_create_u16("tx_share", 0400, nsim_node->ddir, &nsim_node->tx_share);
1246     debugfs_create_u16("tx_max", 0400, nsim_node->ddir, &nsim_node->tx_max);
1247     nsim_node->rate_parent = debugfs_create_file("rate_parent", 0400,
1248                              nsim_node->ddir,
1249                              &nsim_node->parent_name,
1250                              &nsim_dev_rate_parent_fops);
1251 
1252     *priv = nsim_node;
1253     return 0;
1254 }
1255 
1256 static int nsim_rate_node_del(struct devlink_rate *node, void *priv,
1257                   struct netlink_ext_ack *extack)
1258 {
1259     struct nsim_rate_node *nsim_node = priv;
1260 
1261     debugfs_remove(nsim_node->rate_parent);
1262     debugfs_remove_recursive(nsim_node->ddir);
1263     kfree(nsim_node);
1264     return 0;
1265 }
1266 
1267 static int nsim_rate_leaf_parent_set(struct devlink_rate *child,
1268                      struct devlink_rate *parent,
1269                      void *priv_child, void *priv_parent,
1270                      struct netlink_ext_ack *extack)
1271 {
1272     struct nsim_dev_port *nsim_dev_port = priv_child;
1273 
1274     if (parent)
1275         nsim_dev_port->parent_name = parent->name;
1276     else
1277         nsim_dev_port->parent_name = NULL;
1278     return 0;
1279 }
1280 
1281 static int nsim_rate_node_parent_set(struct devlink_rate *child,
1282                      struct devlink_rate *parent,
1283                      void *priv_child, void *priv_parent,
1284                      struct netlink_ext_ack *extack)
1285 {
1286     struct nsim_rate_node *nsim_node = priv_child;
1287 
1288     if (parent)
1289         nsim_node->parent_name = parent->name;
1290     else
1291         nsim_node->parent_name = NULL;
1292     return 0;
1293 }
1294 
1295 static int
1296 nsim_dev_devlink_trap_drop_counter_get(struct devlink *devlink,
1297                        const struct devlink_trap *trap,
1298                        u64 *p_drops)
1299 {
1300     struct nsim_dev *nsim_dev = devlink_priv(devlink);
1301     u64 *cnt;
1302 
1303     if (nsim_dev->fail_trap_drop_counter_get)
1304         return -EINVAL;
1305 
1306     cnt = &nsim_dev->trap_data->trap_pkt_cnt;
1307     *p_drops = (*cnt)++;
1308 
1309     return 0;
1310 }
1311 
1312 static const struct devlink_ops nsim_dev_devlink_ops = {
1313     .eswitch_mode_set = nsim_devlink_eswitch_mode_set,
1314     .eswitch_mode_get = nsim_devlink_eswitch_mode_get,
1315     .supported_flash_update_params = DEVLINK_SUPPORT_FLASH_UPDATE_COMPONENT |
1316                      DEVLINK_SUPPORT_FLASH_UPDATE_OVERWRITE_MASK,
1317     .reload_actions = BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT),
1318     .reload_down = nsim_dev_reload_down,
1319     .reload_up = nsim_dev_reload_up,
1320     .info_get = nsim_dev_info_get,
1321     .flash_update = nsim_dev_flash_update,
1322     .trap_init = nsim_dev_devlink_trap_init,
1323     .trap_action_set = nsim_dev_devlink_trap_action_set,
1324     .trap_group_set = nsim_dev_devlink_trap_group_set,
1325     .trap_policer_set = nsim_dev_devlink_trap_policer_set,
1326     .trap_policer_counter_get = nsim_dev_devlink_trap_policer_counter_get,
1327     .rate_leaf_tx_share_set = nsim_leaf_tx_share_set,
1328     .rate_leaf_tx_max_set = nsim_leaf_tx_max_set,
1329     .rate_node_tx_share_set = nsim_node_tx_share_set,
1330     .rate_node_tx_max_set = nsim_node_tx_max_set,
1331     .rate_node_new = nsim_rate_node_new,
1332     .rate_node_del = nsim_rate_node_del,
1333     .rate_leaf_parent_set = nsim_rate_leaf_parent_set,
1334     .rate_node_parent_set = nsim_rate_node_parent_set,
1335     .trap_drop_counter_get = nsim_dev_devlink_trap_drop_counter_get,
1336 };
1337 
1338 #define NSIM_DEV_MAX_MACS_DEFAULT 32
1339 #define NSIM_DEV_TEST1_DEFAULT true
1340 
1341 static int __nsim_dev_port_add(struct nsim_dev *nsim_dev, enum nsim_dev_port_type type,
1342                    unsigned int port_index)
1343 {
1344     struct devlink_port_attrs attrs = {};
1345     struct nsim_dev_port *nsim_dev_port;
1346     struct devlink_port *devlink_port;
1347     int err;
1348 
1349     if (type == NSIM_DEV_PORT_TYPE_VF && !nsim_dev_get_vfs(nsim_dev))
1350         return -EINVAL;
1351 
1352     nsim_dev_port = kzalloc(sizeof(*nsim_dev_port), GFP_KERNEL);
1353     if (!nsim_dev_port)
1354         return -ENOMEM;
1355     nsim_dev_port->port_index = nsim_dev_port_index(type, port_index);
1356     nsim_dev_port->port_type = type;
1357 
1358     devlink_port = &nsim_dev_port->devlink_port;
1359     if (nsim_dev_port_is_pf(nsim_dev_port)) {
1360         attrs.flavour = DEVLINK_PORT_FLAVOUR_PHYSICAL;
1361         attrs.phys.port_number = port_index + 1;
1362     } else {
1363         attrs.flavour = DEVLINK_PORT_FLAVOUR_PCI_VF;
1364         attrs.pci_vf.pf = 0;
1365         attrs.pci_vf.vf = port_index;
1366     }
1367     memcpy(attrs.switch_id.id, nsim_dev->switch_id.id, nsim_dev->switch_id.id_len);
1368     attrs.switch_id.id_len = nsim_dev->switch_id.id_len;
1369     devlink_port_attrs_set(devlink_port, &attrs);
1370     err = devl_port_register(priv_to_devlink(nsim_dev), devlink_port,
1371                  nsim_dev_port->port_index);
1372     if (err)
1373         goto err_port_free;
1374 
1375     err = nsim_dev_port_debugfs_init(nsim_dev, nsim_dev_port);
1376     if (err)
1377         goto err_dl_port_unregister;
1378 
1379     nsim_dev_port->ns = nsim_create(nsim_dev, nsim_dev_port);
1380     if (IS_ERR(nsim_dev_port->ns)) {
1381         err = PTR_ERR(nsim_dev_port->ns);
1382         goto err_port_debugfs_exit;
1383     }
1384 
1385     if (nsim_dev_port_is_vf(nsim_dev_port)) {
1386         err = devl_rate_leaf_create(&nsim_dev_port->devlink_port,
1387                         nsim_dev_port);
1388         if (err)
1389             goto err_nsim_destroy;
1390     }
1391 
1392     devlink_port_type_eth_set(devlink_port, nsim_dev_port->ns->netdev);
1393     list_add(&nsim_dev_port->list, &nsim_dev->port_list);
1394 
1395     return 0;
1396 
1397 err_nsim_destroy:
1398     nsim_destroy(nsim_dev_port->ns);
1399 err_port_debugfs_exit:
1400     nsim_dev_port_debugfs_exit(nsim_dev_port);
1401 err_dl_port_unregister:
1402     devl_port_unregister(devlink_port);
1403 err_port_free:
1404     kfree(nsim_dev_port);
1405     return err;
1406 }
1407 
1408 static void __nsim_dev_port_del(struct nsim_dev_port *nsim_dev_port)
1409 {
1410     struct devlink_port *devlink_port = &nsim_dev_port->devlink_port;
1411 
1412     list_del(&nsim_dev_port->list);
1413     if (nsim_dev_port_is_vf(nsim_dev_port))
1414         devl_rate_leaf_destroy(&nsim_dev_port->devlink_port);
1415     devlink_port_type_clear(devlink_port);
1416     nsim_destroy(nsim_dev_port->ns);
1417     nsim_dev_port_debugfs_exit(nsim_dev_port);
1418     devl_port_unregister(devlink_port);
1419     kfree(nsim_dev_port);
1420 }
1421 
1422 static void nsim_dev_port_del_all(struct nsim_dev *nsim_dev)
1423 {
1424     struct nsim_dev_port *nsim_dev_port, *tmp;
1425 
1426     list_for_each_entry_safe(nsim_dev_port, tmp,
1427                  &nsim_dev->port_list, list)
1428         __nsim_dev_port_del(nsim_dev_port);
1429 }
1430 
1431 static int nsim_dev_port_add_all(struct nsim_dev *nsim_dev,
1432                  unsigned int port_count)
1433 {
1434     int i, err;
1435 
1436     for (i = 0; i < port_count; i++) {
1437         err = __nsim_dev_port_add(nsim_dev, NSIM_DEV_PORT_TYPE_PF, i);
1438         if (err)
1439             goto err_port_del_all;
1440     }
1441     return 0;
1442 
1443 err_port_del_all:
1444     nsim_dev_port_del_all(nsim_dev);
1445     return err;
1446 }
1447 
1448 static int nsim_dev_reload_create(struct nsim_dev *nsim_dev,
1449                   struct netlink_ext_ack *extack)
1450 {
1451     struct nsim_bus_dev *nsim_bus_dev = nsim_dev->nsim_bus_dev;
1452     struct devlink *devlink;
1453     int err;
1454 
1455     devlink = priv_to_devlink(nsim_dev);
1456     nsim_dev = devlink_priv(devlink);
1457     INIT_LIST_HEAD(&nsim_dev->port_list);
1458     nsim_dev->fw_update_status = true;
1459     nsim_dev->fw_update_overwrite_mask = 0;
1460 
1461     nsim_devlink_param_load_driverinit_values(devlink);
1462 
1463     err = nsim_dev_dummy_region_init(nsim_dev, devlink);
1464     if (err)
1465         return err;
1466 
1467     err = nsim_dev_traps_init(devlink);
1468     if (err)
1469         goto err_dummy_region_exit;
1470 
1471     nsim_dev->fib_data = nsim_fib_create(devlink, extack);
1472     if (IS_ERR(nsim_dev->fib_data)) {
1473         err = PTR_ERR(nsim_dev->fib_data);
1474         goto err_traps_exit;
1475     }
1476 
1477     err = nsim_dev_health_init(nsim_dev, devlink);
1478     if (err)
1479         goto err_fib_destroy;
1480 
1481     err = nsim_dev_psample_init(nsim_dev);
1482     if (err)
1483         goto err_health_exit;
1484 
1485     err = nsim_dev_hwstats_init(nsim_dev);
1486     if (err)
1487         goto err_psample_exit;
1488 
1489     err = nsim_dev_port_add_all(nsim_dev, nsim_bus_dev->port_count);
1490     if (err)
1491         goto err_hwstats_exit;
1492 
1493     nsim_dev->take_snapshot = debugfs_create_file("take_snapshot",
1494                               0200,
1495                               nsim_dev->ddir,
1496                               nsim_dev,
1497                         &nsim_dev_take_snapshot_fops);
1498     return 0;
1499 
1500 err_hwstats_exit:
1501     nsim_dev_hwstats_exit(nsim_dev);
1502 err_psample_exit:
1503     nsim_dev_psample_exit(nsim_dev);
1504 err_health_exit:
1505     nsim_dev_health_exit(nsim_dev);
1506 err_fib_destroy:
1507     nsim_fib_destroy(devlink, nsim_dev->fib_data);
1508 err_traps_exit:
1509     nsim_dev_traps_exit(devlink);
1510 err_dummy_region_exit:
1511     nsim_dev_dummy_region_exit(nsim_dev);
1512     return err;
1513 }
1514 
1515 int nsim_drv_probe(struct nsim_bus_dev *nsim_bus_dev)
1516 {
1517     struct nsim_dev *nsim_dev;
1518     struct devlink *devlink;
1519     int err;
1520 
1521     devlink = devlink_alloc_ns(&nsim_dev_devlink_ops, sizeof(*nsim_dev),
1522                  nsim_bus_dev->initial_net, &nsim_bus_dev->dev);
1523     if (!devlink)
1524         return -ENOMEM;
1525     devl_lock(devlink);
1526     nsim_dev = devlink_priv(devlink);
1527     nsim_dev->nsim_bus_dev = nsim_bus_dev;
1528     nsim_dev->switch_id.id_len = sizeof(nsim_dev->switch_id.id);
1529     get_random_bytes(nsim_dev->switch_id.id, nsim_dev->switch_id.id_len);
1530     INIT_LIST_HEAD(&nsim_dev->port_list);
1531     nsim_dev->fw_update_status = true;
1532     nsim_dev->fw_update_overwrite_mask = 0;
1533     nsim_dev->max_macs = NSIM_DEV_MAX_MACS_DEFAULT;
1534     nsim_dev->test1 = NSIM_DEV_TEST1_DEFAULT;
1535     spin_lock_init(&nsim_dev->fa_cookie_lock);
1536 
1537     dev_set_drvdata(&nsim_bus_dev->dev, nsim_dev);
1538 
1539     nsim_dev->vfconfigs = kcalloc(nsim_bus_dev->max_vfs,
1540                       sizeof(struct nsim_vf_config),
1541                       GFP_KERNEL | __GFP_NOWARN);
1542     if (!nsim_dev->vfconfigs) {
1543         err = -ENOMEM;
1544         goto err_devlink_unlock;
1545     }
1546 
1547     err = nsim_dev_resources_register(devlink);
1548     if (err)
1549         goto err_vfc_free;
1550 
1551     err = devlink_params_register(devlink, nsim_devlink_params,
1552                       ARRAY_SIZE(nsim_devlink_params));
1553     if (err)
1554         goto err_dl_unregister;
1555     nsim_devlink_set_params_init_values(nsim_dev, devlink);
1556 
1557     err = nsim_dev_dummy_region_init(nsim_dev, devlink);
1558     if (err)
1559         goto err_params_unregister;
1560 
1561     err = nsim_dev_traps_init(devlink);
1562     if (err)
1563         goto err_dummy_region_exit;
1564 
1565     err = nsim_dev_debugfs_init(nsim_dev);
1566     if (err)
1567         goto err_traps_exit;
1568 
1569     nsim_dev->fib_data = nsim_fib_create(devlink, NULL);
1570     if (IS_ERR(nsim_dev->fib_data)) {
1571         err = PTR_ERR(nsim_dev->fib_data);
1572         goto err_debugfs_exit;
1573     }
1574 
1575     err = nsim_dev_health_init(nsim_dev, devlink);
1576     if (err)
1577         goto err_fib_destroy;
1578 
1579     err = nsim_bpf_dev_init(nsim_dev);
1580     if (err)
1581         goto err_health_exit;
1582 
1583     err = nsim_dev_psample_init(nsim_dev);
1584     if (err)
1585         goto err_bpf_dev_exit;
1586 
1587     err = nsim_dev_hwstats_init(nsim_dev);
1588     if (err)
1589         goto err_psample_exit;
1590 
1591     err = nsim_dev_port_add_all(nsim_dev, nsim_bus_dev->port_count);
1592     if (err)
1593         goto err_hwstats_exit;
1594 
1595     nsim_dev->esw_mode = DEVLINK_ESWITCH_MODE_LEGACY;
1596     devlink_set_features(devlink, DEVLINK_F_RELOAD);
1597     devl_unlock(devlink);
1598     devlink_register(devlink);
1599     return 0;
1600 
1601 err_hwstats_exit:
1602     nsim_dev_hwstats_exit(nsim_dev);
1603 err_psample_exit:
1604     nsim_dev_psample_exit(nsim_dev);
1605 err_bpf_dev_exit:
1606     nsim_bpf_dev_exit(nsim_dev);
1607 err_health_exit:
1608     nsim_dev_health_exit(nsim_dev);
1609 err_fib_destroy:
1610     nsim_fib_destroy(devlink, nsim_dev->fib_data);
1611 err_debugfs_exit:
1612     nsim_dev_debugfs_exit(nsim_dev);
1613 err_traps_exit:
1614     nsim_dev_traps_exit(devlink);
1615 err_dummy_region_exit:
1616     nsim_dev_dummy_region_exit(nsim_dev);
1617 err_params_unregister:
1618     devlink_params_unregister(devlink, nsim_devlink_params,
1619                   ARRAY_SIZE(nsim_devlink_params));
1620 err_dl_unregister:
1621     devl_resources_unregister(devlink);
1622 err_vfc_free:
1623     kfree(nsim_dev->vfconfigs);
1624 err_devlink_unlock:
1625     devl_unlock(devlink);
1626     devlink_free(devlink);
1627     dev_set_drvdata(&nsim_bus_dev->dev, NULL);
1628     return err;
1629 }
1630 
1631 static void nsim_dev_reload_destroy(struct nsim_dev *nsim_dev)
1632 {
1633     struct devlink *devlink = priv_to_devlink(nsim_dev);
1634 
1635     if (devlink_is_reload_failed(devlink))
1636         return;
1637     debugfs_remove(nsim_dev->take_snapshot);
1638 
1639     if (nsim_dev_get_vfs(nsim_dev)) {
1640         nsim_bus_dev_set_vfs(nsim_dev->nsim_bus_dev, 0);
1641         if (nsim_esw_mode_is_switchdev(nsim_dev))
1642             nsim_esw_legacy_enable(nsim_dev, NULL);
1643     }
1644 
1645     nsim_dev_port_del_all(nsim_dev);
1646     nsim_dev_hwstats_exit(nsim_dev);
1647     nsim_dev_psample_exit(nsim_dev);
1648     nsim_dev_health_exit(nsim_dev);
1649     nsim_fib_destroy(devlink, nsim_dev->fib_data);
1650     nsim_dev_traps_exit(devlink);
1651     nsim_dev_dummy_region_exit(nsim_dev);
1652 }
1653 
1654 void nsim_drv_remove(struct nsim_bus_dev *nsim_bus_dev)
1655 {
1656     struct nsim_dev *nsim_dev = dev_get_drvdata(&nsim_bus_dev->dev);
1657     struct devlink *devlink = priv_to_devlink(nsim_dev);
1658 
1659     devlink_unregister(devlink);
1660     devl_lock(devlink);
1661     nsim_dev_reload_destroy(nsim_dev);
1662 
1663     nsim_bpf_dev_exit(nsim_dev);
1664     nsim_dev_debugfs_exit(nsim_dev);
1665     devlink_params_unregister(devlink, nsim_devlink_params,
1666                   ARRAY_SIZE(nsim_devlink_params));
1667     devl_resources_unregister(devlink);
1668     kfree(nsim_dev->vfconfigs);
1669     devl_unlock(devlink);
1670     devlink_free(devlink);
1671     dev_set_drvdata(&nsim_bus_dev->dev, NULL);
1672 }
1673 
1674 static struct nsim_dev_port *
1675 __nsim_dev_port_lookup(struct nsim_dev *nsim_dev, enum nsim_dev_port_type type,
1676                unsigned int port_index)
1677 {
1678     struct nsim_dev_port *nsim_dev_port;
1679 
1680     port_index = nsim_dev_port_index(type, port_index);
1681     list_for_each_entry(nsim_dev_port, &nsim_dev->port_list, list)
1682         if (nsim_dev_port->port_index == port_index)
1683             return nsim_dev_port;
1684     return NULL;
1685 }
1686 
1687 int nsim_drv_port_add(struct nsim_bus_dev *nsim_bus_dev, enum nsim_dev_port_type type,
1688               unsigned int port_index)
1689 {
1690     struct nsim_dev *nsim_dev = dev_get_drvdata(&nsim_bus_dev->dev);
1691     int err;
1692 
1693     devl_lock(priv_to_devlink(nsim_dev));
1694     if (__nsim_dev_port_lookup(nsim_dev, type, port_index))
1695         err = -EEXIST;
1696     else
1697         err = __nsim_dev_port_add(nsim_dev, type, port_index);
1698     devl_unlock(priv_to_devlink(nsim_dev));
1699     return err;
1700 }
1701 
1702 int nsim_drv_port_del(struct nsim_bus_dev *nsim_bus_dev, enum nsim_dev_port_type type,
1703               unsigned int port_index)
1704 {
1705     struct nsim_dev *nsim_dev = dev_get_drvdata(&nsim_bus_dev->dev);
1706     struct nsim_dev_port *nsim_dev_port;
1707     int err = 0;
1708 
1709     devl_lock(priv_to_devlink(nsim_dev));
1710     nsim_dev_port = __nsim_dev_port_lookup(nsim_dev, type, port_index);
1711     if (!nsim_dev_port)
1712         err = -ENOENT;
1713     else
1714         __nsim_dev_port_del(nsim_dev_port);
1715     devl_unlock(priv_to_devlink(nsim_dev));
1716     return err;
1717 }
1718 
1719 int nsim_drv_configure_vfs(struct nsim_bus_dev *nsim_bus_dev,
1720                unsigned int num_vfs)
1721 {
1722     struct nsim_dev *nsim_dev = dev_get_drvdata(&nsim_bus_dev->dev);
1723     struct devlink *devlink = priv_to_devlink(nsim_dev);
1724     int ret = 0;
1725 
1726     devl_lock(devlink);
1727     if (nsim_bus_dev->num_vfs == num_vfs)
1728         goto exit_unlock;
1729     if (nsim_bus_dev->num_vfs && num_vfs) {
1730         ret = -EBUSY;
1731         goto exit_unlock;
1732     }
1733     if (nsim_bus_dev->max_vfs < num_vfs) {
1734         ret = -ENOMEM;
1735         goto exit_unlock;
1736     }
1737 
1738     nsim_bus_dev_set_vfs(nsim_bus_dev, num_vfs);
1739     if (nsim_esw_mode_is_switchdev(nsim_dev)) {
1740         if (num_vfs) {
1741             ret = nsim_esw_switchdev_enable(nsim_dev, NULL);
1742             if (ret) {
1743                 nsim_bus_dev_set_vfs(nsim_bus_dev, 0);
1744                 goto exit_unlock;
1745             }
1746         } else {
1747             nsim_esw_legacy_enable(nsim_dev, NULL);
1748         }
1749     }
1750 
1751 exit_unlock:
1752     devl_unlock(devlink);
1753 
1754     return ret;
1755 }
1756 
1757 int nsim_dev_init(void)
1758 {
1759     nsim_dev_ddir = debugfs_create_dir(DRV_NAME, NULL);
1760     return PTR_ERR_OR_ZERO(nsim_dev_ddir);
1761 }
1762 
1763 void nsim_dev_exit(void)
1764 {
1765     debugfs_remove_recursive(nsim_dev_ddir);
1766 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!