skb = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);	if (!skb)		return NULL;	tot_len = sizeof(struct iphdr) + sizeof(struct udphdr) + data_len; 	skb_reset_mac_header(skb);	eth = skb_put(skb, sizeof(struct ethhdr));	eth_random_addr(eth->h_dest);	eth_random_addr(eth->h_source);	eth->h_proto = htons(ETH_P_IP);	skb->protocol = htons(ETH_P_IP); 	skb_set_network_header(skb, skb->len);	iph = skb_put(skb, sizeof(struct iphdr));	iph->protocol = IPPROTO_UDP;	iph->saddr = in_aton("192.0.2.1");	iph->daddr = in_aton("198.51.100.1");	iph->version = 0x4;	iph->frag_off = 0;	iph->ihl = 0x5;	iph->tot_len = htons(tot_len);	iph->ttl = 100;	iph->check = 0;	iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl); 	skb_set_transport_header(skb, skb->len);	udph = skb_put_zero(skb, sizeof(struct udphdr) + data_len);	get_random_bytes(&udph->source, sizeof(u16));	get_random_bytes(&udph->dest, sizeof(u16));	udph->len = htons(sizeof(struct udphdr) + data_len); 	return skb;} static void nsim_dev_trap_report(struct nsim_dev_port *nsim_dev_port){	struct nsim_dev *nsim_dev = nsim_dev_port->ns->nsim_dev;	struct devlink *devlink = priv_to_devlink(nsim_dev);	struct nsim_trap_data *nsim_trap_data;	int i; 	nsim_trap_data = nsim_dev->trap_data; 	spin_lock(&nsim_trap_data->trap_lock);	for (i = 0; i < ARRAY_SIZE(nsim_traps_arr); i++) {		struct flow_action_cookie *fa_cookie = NULL;		struct nsim_trap_item *nsim_trap_item;		struct sk_buff *skb;		bool has_fa_cookie; 		has_fa_cookie = nsim_traps_arr[i].metadata_cap &				DEVLINK_TRAP_METADATA_TYPE_F_FA_COOKIE; 		nsim_trap_item = &nsim_trap_data->trap_items_arr[i];		if (nsim_trap_item->action == DEVLINK_TRAP_ACTION_DROP)			continue; 		skb = nsim_dev_trap_skb_build();		if (!skb)			continue;		skb->dev = nsim_dev_port->ns->netdev; 		/* Trapped packets are usually passed to devlink in softIRQ,		 * but in this case they are generated in a workqueue. Disable		 * softIRQs to prevent lockdep from complaining about		 * "incosistent lock state".		 */ 		spin_lock_bh(&nsim_dev->fa_cookie_lock);		fa_cookie = has_fa_cookie ? nsim_dev->fa_cookie : NULL;		devlink_trap_report(devlink, skb, nsim_trap_item->trap_ctx,				    &nsim_dev_port->devlink_port, fa_cookie);		spin_unlock_bh(&nsim_dev->fa_cookie_lock);		consume_skb(skb);	}	spin_unlock(&nsim_trap_data->trap_lock);} #define NSIM_TRAP_REPORT_INTERVAL_MS	100 static void nsim_dev_trap_report_work(struct work_struct *work){	struct nsim_trap_data *nsim_trap_data;	struct nsim_dev_port *nsim_dev_port;	struct nsim_dev *nsim_dev; 	nsim_trap_data = container_of(work, struct nsim_trap_data,				      trap_report_dw.work);	nsim_dev = nsim_trap_data->nsim_dev; 	/* For each running port and enabled packet trap, generate a UDP	 * packet with a random 5-tuple and report it.	 */	mutex_lock(&nsim_dev->port_list_lock);	list_for_each_entry(nsim_dev_port, &nsim_dev->port_list, list) {		if (!netif_running(nsim_dev_port->ns->netdev))			continue; 		nsim_dev_trap_report(nsim_dev_port);	}	mutex_unlock(&nsim_dev->port_list_lock); 	schedule_delayed_work(&nsim_dev->trap_data->trap_report_dw,			      msecs_to_jiffies(NSIM_TRAP_REPORT_INTERVAL_MS));} static int nsim_dev_traps_init(struct devlink *devlink){	size_t policers_count = ARRAY_SIZE(nsim_trap_policers_arr);	struct nsim_dev *nsim_dev = devlink_priv(devlink);	struct nsim_trap_data *nsim_trap_data;	int err; 	nsim_trap_data = kzalloc(sizeof(*nsim_trap_data), GFP_KERNEL);	if (!nsim_trap_data)		return -ENOMEM; 	nsim_trap_data->trap_items_arr = kcalloc(ARRAY_SIZE(nsim_traps_arr),						 sizeof(struct nsim_trap_item),						 GFP_KERNEL);	if (!nsim_trap_data->trap_items_arr) {		err = -ENOMEM;		goto err_trap_data_free;	} 	nsim_trap_data->trap_policers_cnt_arr = kcalloc(policers_count,							sizeof(u64),							GFP_KERNEL);	if (!nsim_trap_data->trap_policers_cnt_arr) {		err = -ENOMEM;		goto err_trap_items_free;	} 	/* The lock is used to protect the action state of the registered	 * traps. The value is written by user and read in delayed work when	 * iterating over all the traps.	 */	spin_lock_init(&nsim_trap_data->trap_lock);	nsim_trap_data->nsim_dev = nsim_dev;	nsim_dev->trap_data = nsim_trap_data; 	err = devlink_trap_policers_register(devlink, nsim_trap_policers_arr,					     policers_count);	if (err)		goto err_trap_policers_cnt_free; 	err = devlink_trap_groups_register(devlink, nsim_trap_groups_arr,					   ARRAY_SIZE(nsim_trap_groups_arr));	if (err)		goto err_trap_policers_unregister; 	err = devlink_traps_register(devlink, nsim_traps_arr,				     ARRAY_SIZE(nsim_traps_arr), NULL);	if (err)		goto err_trap_groups_unregister; 	INIT_DELAYED_WORK(&nsim_dev->trap_data->trap_report_dw,			  nsim_dev_trap_report_work);	schedule_delayed_work(&nsim_dev->trap_data->trap_report_dw,			      msecs_to_jiffies(NSIM_TRAP_REPORT_INTERVAL_MS)); 	return 0; err_trap_groups_unregister:	devlink_trap_groups_unregister(devlink, nsim_trap_groups_arr,				       ARRAY_SIZE(nsim_trap_groups_arr));err_trap_policers_unregister:	devlink_trap_policers_unregister(devlink, nsim_trap_policers_arr,					 ARRAY_SIZE(nsim_trap_policers_arr));err_trap_policers_cnt_free:	kfree(nsim_trap_data->trap_policers_cnt_arr);err_trap_items_free:	kfree(nsim_trap_data->trap_items_arr);err_trap_data_free:	kfree(nsim_trap_data);	return err;} static void nsim_dev_traps_exit(struct devlink *devlink){	struct nsim_dev *nsim_dev = devlink_priv(devlink); 	cancel_delayed_work_sync(&nsim_dev->trap_data->trap_report_dw);	devlink_traps_unregister(devlink, nsim_traps_arr,				 ARRAY_SIZE(nsim_traps_arr));	devlink_trap_groups_unregister(devlink, nsim_trap_groups_arr,				       ARRAY_SIZE(nsim_trap_groups_arr));	devlink_trap_policers_unregister(devlink, nsim_trap_policers_arr,					 ARRAY_SIZE(nsim_trap_policers_arr));	kfree(nsim_dev->trap_data->trap_policers_cnt_arr);	kfree(nsim_dev->trap_data->trap_items_arr);	kfree(nsim_dev->trap_data);} static int nsim_dev_reload_create(struct nsim_dev *nsim_dev,				  struct netlink_ext_ack *extack);static void nsim_dev_reload_destroy(struct nsim_dev *nsim_dev); static int nsim_dev_reload_down(struct devlink *devlink, bool netns_change,				struct netlink_ext_ack *extack){	struct nsim_dev *nsim_dev = devlink_priv(devlink); 	if (nsim_dev->dont_allow_reload) {		/* For testing purposes, user set debugfs dont_allow_reload		 * value to true. So forbid it.		 */		NL_SET_ERR_MSG_MOD(extack, "User forbid the reload for testing purposes");		return -EOPNOTSUPP;	} 	nsim_dev_reload_destroy(nsim_dev);	return 0;} static int nsim_dev_reload_up(struct devlink *devlink,			      struct netlink_ext_ack *extack){	struct nsim_dev *nsim_dev = devlink_priv(devlink); 	if (nsim_dev->fail_reload) {		/* For testing purposes, user set debugfs fail_reload		 * value to true. Fail right away.		 */		NL_SET_ERR_MSG_MOD(extack, "User setup the reload to fail for testing purposes");		return -EINVAL;	} 	return nsim_dev_reload_create(nsim_dev, extack);} static int nsim_dev_info_get(struct devlink *devlink,			     struct devlink_info_req *req,			     struct netlink_ext_ack *extack){	return devlink_info_driver_name_put(req, DRV_NAME);} #define NSIM_DEV_FLASH_SIZE 500000#define NSIM_DEV_FLASH_CHUNK_SIZE 1000#define NSIM_DEV_FLASH_CHUNK_TIME_MS 10 static int nsim_dev_flash_update(struct devlink *devlink, const char *file_name,				 const char *component,				 struct netlink_ext_ack *extack){	struct nsim_dev *nsim_dev = devlink_priv(devlink);	int i; 	if (nsim_dev->fw_update_status) {		devlink_flash_update_begin_notify(devlink);		devlink_flash_update_status_notify(devlink,						   "Preparing to flash",						   component, 0, 0);	} 	for (i = 0; i < NSIM_DEV_FLASH_SIZE / NSIM_DEV_FLASH_CHUNK_SIZE; i++) {		if (nsim_dev->fw_update_status)			devlink_flash_update_status_notify(devlink, "Flashing",							   component,							   i * NSIM_DEV_FLASH_CHUNK_SIZE,							   NSIM_DEV_FLASH_SIZE);		msleep(NSIM_DEV_FLASH_CHUNK_TIME_MS);	} 	if (nsim_dev->fw_update_status) {		devlink_flash_update_status_notify(devlink, "Flashing",						   component,						   NSIM_DEV_FLASH_SIZE,						   NSIM_DEV_FLASH_SIZE);		devlink_flash_update_status_notify(devlink, "Flashing done",						   component, 0, 0);		devlink_flash_update_end_notify(devlink);	} 	return 0;} static struct nsim_trap_item *nsim_dev_trap_item_lookup(struct nsim_dev *nsim_dev, u16 trap_id){	struct nsim_trap_data *nsim_trap_data = nsim_dev->trap_data;	int i; 	for (i = 0; i < ARRAY_SIZE(nsim_traps_arr); i++) {		if (nsim_traps_arr[i].id == trap_id)			return &nsim_trap_data->trap_items_arr[i];	} 	return NULL;} static int nsim_dev_devlink_trap_init(struct devlink *devlink,				      const struct devlink_trap *trap,				      void *trap_ctx){	struct nsim_dev *nsim_dev = devlink_priv(devlink);	struct nsim_trap_item *nsim_trap_item; 	nsim_trap_item = nsim_dev_trap_item_lookup(nsim_dev, trap->id);	if (WARN_ON(!nsim_trap_item))		return -ENOENT; 	nsim_trap_item->trap_ctx = trap_ctx;	nsim_trap_item->action = trap->init_action; 	return 0;} static intnsim_dev_devlink_trap_action_set(struct devlink *devlink,				 const struct devlink_trap *trap,				 enum devlink_trap_action action,				 struct netlink_ext_ack *extack){	struct nsim_dev *nsim_dev = devlink_priv(devlink);	struct nsim_trap_item *nsim_trap_item; 	nsim_trap_item = nsim_dev_trap_item_lookup(nsim_dev, trap->id);	if (WARN_ON(!nsim_trap_item))		return -ENOENT; 	spin_lock(&nsim_dev->trap_data->trap_lock);	nsim_trap_item->action = action;	spin_unlock(&nsim_dev->trap_data->trap_lock); 	return 0;} static intnsim_dev_devlink_trap_group_set(struct devlink *devlink,				const struct devlink_trap_group *group,				const struct devlink_trap_policer *policer,				struct netlink_ext_ack *extack){	struct nsim_dev *nsim_dev = devlink_priv(devlink); 	if (nsim_dev->fail_trap_group_set)		return -EINVAL; 	return 0;} static intnsim_dev_devlink_trap_policer_set(struct devlink *devlink,				  const struct devlink_trap_policer *policer,				  u64 rate, u64 burst,				  struct netlink_ext_ack *extack){	struct nsim_dev *nsim_dev = devlink_priv(devlink); 	if (nsim_dev->fail_trap_policer_set) {		NL_SET_ERR_MSG_MOD(extack, "User setup the operation to fail for testing purposes");		return -EINVAL;	} 	return 0;} static intnsim_dev_devlink_trap_policer_counter_get(struct devlink *devlink,					  const struct devlink_trap_policer *policer,					  u64 *p_drops){	struct nsim_dev *nsim_dev = devlink_priv(devlink);	u64 *cnt; 	if (nsim_dev->fail_trap_policer_counter_get)		return -EINVAL; 	cnt = &nsim_dev->trap_data->trap_policers_cnt_arr[policer->id - 1];	*p_drops = (*cnt)++; 	return 0;} static const struct devlink_ops nsim_dev_devlink_ops = {	.reload_down = nsim_dev_reload_down,	.reload_up = nsim_dev_reload_up,	.info_get = nsim_dev_info_get,	.flash_update = nsim_dev_flash_update,	.trap_init = nsim_dev_devlink_trap_init,	.trap_action_set = nsim_dev_devlink_trap_action_set,	.trap_group_set = nsim_dev_devlink_trap_group_set,	.trap_policer_set = nsim_dev_devlink_trap_policer_set,	.trap_policer_counter_get = nsim_dev_devlink_trap_policer_counter_get,}; #define NSIM_DEV_MAX_MACS_DEFAULT 32#define NSIM_DEV_TEST1_DEFAULT true static int __nsim_dev_port_add(struct nsim_dev *nsim_dev,			       unsigned int port_index){	struct devlink_port_attrs attrs = {};	struct nsim_dev_port *nsim_dev_port;	struct devlink_port *devlink_port;	int err; 	nsim_dev_port = kzalloc(sizeof(*nsim_dev_port), GFP_KERNEL);	if (!nsim_dev_port)		return -ENOMEM;	nsim_dev_port->port_index = port_index; 	devlink_port = &nsim_dev_port->devlink_port;	attrs.flavour = DEVLINK_PORT_FLAVOUR_PHYSICAL;	attrs.phys.port_number = port_index + 1;	memcpy(attrs.switch_id.id, nsim_dev->switch_id.id, nsim_dev->switch_id.id_len);	attrs.switch_id.id_len = nsim_dev->switch_id.id_len;	devlink_port_attrs_set(devlink_port, &attrs);	err = devlink_port_register(priv_to_devlink(nsim_dev), devlink_port,				    port_index);	if (err)		goto err_port_free; 	err = nsim_dev_port_debugfs_init(nsim_dev, nsim_dev_port);	if (err)		goto err_dl_port_unregister; 	nsim_dev_port->ns = nsim_create(nsim_dev, nsim_dev_port);	if (IS_ERR(nsim_dev_port->ns)) {		err = PTR_ERR(nsim_dev_port->ns);		goto err_port_debugfs_exit;	} 	devlink_port_type_eth_set(devlink_port, nsim_dev_port->ns->netdev);	list_add(&nsim_dev_port->list, &nsim_dev->port_list); 	return 0; err_port_debugfs_exit:	nsim_dev_port_debugfs_exit(nsim_dev_port);err_dl_port_unregister:	devlink_port_unregister(devlink_port);err_port_free:	kfree(nsim_dev_port);	return err;} static void __nsim_dev_port_del(struct nsim_dev_port *nsim_dev_port){	struct devlink_port *devlink_port = &nsim_dev_port->devlink_port; 	list_del(&nsim_dev_port->list);	devlink_port_type_clear(devlink_port);	nsim_destroy(nsim_dev_port->ns);	nsim_dev_port_debugfs_exit(nsim_dev_port);	devlink_port_unregister(devlink_port);	kfree(nsim_dev_port);} static void nsim_dev_port_del_all(struct nsim_dev *nsim_dev){	struct nsim_dev_port *nsim_dev_port, *tmp; 	mutex_lock(&nsim_dev->port_list_lock);	list_for_each_entry_safe(nsim_dev_port, tmp,				 &nsim_dev->port_list, list)		__nsim_dev_port_del(nsim_dev_port);	mutex_unlock(&nsim_dev->port_list_lock);} static int nsim_dev_port_add_all(struct nsim_dev *nsim_dev,				 unsigned int port_count){	int i, err; 	for (i = 0; i < port_count; i++) {		err = __nsim_dev_port_add(nsim_dev, i);		if (err)			goto err_port_del_all;	}	return 0; err_port_del_all:	nsim_dev_port_del_all(nsim_dev);	return err;} static int nsim_dev_reload_create(struct nsim_dev *nsim_dev,				  struct netlink_ext_ack *extack){	struct nsim_bus_dev *nsim_bus_dev = nsim_dev->nsim_bus_dev;	struct devlink *devlink;	int err; 	devlink = priv_to_devlink(nsim_dev);	nsim_dev = devlink_priv(devlink);	INIT_LIST_HEAD(&nsim_dev->port_list);	mutex_init(&nsim_dev->port_list_lock);	nsim_dev->fw_update_status = true; 	nsim_dev->fib_data = nsim_fib_create(devlink, extack);	if (IS_ERR(nsim_dev->fib_data))		return PTR_ERR(nsim_dev->fib_data); 	nsim_devlink_param_load_driverinit_values(devlink); 	err = nsim_dev_dummy_region_init(nsim_dev, devlink);	if (err)

Lines 501–1000 of 1213. Previous lines Load more