Commit 715feb71 authored by WenChen's avatar WenChen Committed by JangShui Yang
Browse files

urma: upload kernel patch for 20240516_day 

driver inclusion
category: bugfix
bugzilla: https://gitee.com/openeuler/kernel/issues/I91DSN


CVE: NA

--------------------------------

Upload kernel patch for 20240516_day, detailed
fixes are as follows:
1. Remove the -L parameter for cross compilation
2. Addition of modify tp implement
3. Change the content of the urma_admin help manual.
4. Improve uvs_alarm.
5. Modify bw_test for urma_tp_test.

Fixes: 329bf7f3 ("ubcore: fix the bug of tp negotiation concurrency")
Signed-off-by: default avatarWenChen <chenwen54@huawei.com>
Signed-off-by: default avatarWeibo Zhao <zhaoweibo3@huawei.com>
parent 5d130e2c

drivers/ub/urma/ubcore/ubcore_cdev_file.c

+108 −0
Original line number Diff line number Diff line
@@ -535,6 +535,112 @@ static ssize_t driver_name_show(struct device *dev, struct device_attribute *att 


static DEVICE_ATTR_RO(driver_name);



static ssize_t reserved_jetty_id_min_show_cb(struct ubcore_device *dev, char *buf)

{

	int ret = 0;



	ret = ubcore_query_device_attr(dev, &dev->attr);

	if (ret != 0) {

		ubcore_log_err("failed query device attr.\n");

		return ret;

	}

	return snprintf(buf, UBCORE_MAX_VALUE_LEN, "%u\n",

		dev->attr.reserved_jetty_id_min);

}



static ssize_t reserved_jetty_id_min_show(struct device *dev, struct device_attribute *attr,

	char *buf)

{

	return ubcore_show_dev_attr(dev, attr, buf, reserved_jetty_id_min_show_cb);

}



static ssize_t reserved_jetty_id_min_store_cb(struct ubcore_device *dev, const char *buf,

	size_t len)

{

	uint32_t value;

	int ret;

	struct ubcore_device_cfg cfg = {0};



	ret = kstrtou32(buf, 0, &value);

	if (ret != 0)

		return -EINVAL;



	cfg.mask.bs.reserved_jetty_id_min = 1;

	cfg.reserved_jetty_id_min = value;



	ret = ubcore_config_device(dev, &cfg);

	if (ret != 0)

		return -EINVAL;



	ret = ubcore_query_device_attr(dev, &dev->attr);

	if (ret != 0) {

		ubcore_log_err("failed query device attr.\n");

		return ret;

	}

	return (ssize_t)len;

}



static ssize_t reserved_jetty_id_min_store(struct device *dev, struct device_attribute *attr,

	const char *buf, size_t len)

{

	return ubcore_store_dev_attr(dev, attr, buf, len, reserved_jetty_id_min_store_cb);

}



static DEVICE_ATTR_RW(reserved_jetty_id_min); // 0644



static ssize_t reserved_jetty_id_max_show_cb(struct ubcore_device *dev, char *buf)

{

	int ret = 0;



	ret = ubcore_query_device_attr(dev, &dev->attr);

	if (ret != 0) {

		ubcore_log_err("failed query device attr.\n");

		return ret;

	}

	return snprintf(buf, UBCORE_MAX_VALUE_LEN, "%u\n",

		dev->attr.reserved_jetty_id_max);

}



static ssize_t reserved_jetty_id_max_show(struct device *dev, struct device_attribute *attr,

	char *buf)

{

	return ubcore_show_dev_attr(dev, attr, buf, reserved_jetty_id_max_show_cb);

}



static ssize_t reserved_jetty_id_max_store_cb(struct ubcore_device *dev, const char *buf,

	size_t len)

{

	uint32_t value;

	int ret;

	struct ubcore_device_cfg cfg = {0};



	ret = kstrtou32(buf, 0, &value);

	if (ret != 0)

		return -EINVAL;



	cfg.mask.bs.reserved_jetty_id_max = 1;

	cfg.reserved_jetty_id_max = value;



	ret = ubcore_config_device(dev, &cfg);

	if (ret != 0)

		return -EINVAL;



	ret = ubcore_query_device_attr(dev, &dev->attr);

	if (ret != 0) {

		ubcore_log_err("failed query device attr.\n");

		return ret;

	}

	return (ssize_t)len;

}



static ssize_t reserved_jetty_id_max_store(struct device *dev, struct device_attribute *attr,

	const char *buf, size_t len)

{

	return ubcore_store_dev_attr(dev, attr, buf, len, reserved_jetty_id_max_store_cb);

}



static DEVICE_ATTR_RW(reserved_jetty_id_max); // 0644



/* One eid line has upto 51 bytes with the format:

 * "4294967295 0000:0000:0000:0000:0000:ffff:7f00:0001\n"

 * sysfs buf size is PAGESIZE, upto 80 eid lines are supported in the sysfs
@@ -615,6 +721,8 @@ static struct attribute *ubcore_dev_attrs[] = { 
	&dev_attr_virtualization.attr,

	&dev_attr_transport_type.attr,

	&dev_attr_driver_name.attr,

	&dev_attr_reserved_jetty_id_min.attr,

	&dev_attr_reserved_jetty_id_max.attr,

	NULL,

};

drivers/ub/urma/ubcore/ubcore_device.c

+14 −1
Original line number Diff line number Diff line
@@ -977,7 +977,7 @@ static int init_ubcore_device(struct ubcore_device *dev) 
		return -1;

	}



	if (dev->transport_type == UBCORE_TRANSPORT_UB && dev->attr.tp_maintainer) {

	if (ubcore_is_ub_device(dev) && dev->attr.tp_maintainer) {

		if (ubcore_sip_table_init(&dev->sip_table,

			dev->attr.dev_cap.max_netaddr_cnt) != 0) {

			ubcore_log_err("Failed init sip table.\n");
@@ -1057,6 +1057,9 @@ static void uninit_ubcore_device(struct ubcore_device *dev) 
		if (ubcore_get_netlink_valid() && ubcore_send_remove_tpf_dev_info(dev) != 0)

			ubcore_log_warn("failed to remove tpf dev info %s", dev->dev_name);

	}



	if (dev->transport_type == UBCORE_TRANSPORT_HNS_UB && dev->attr.tp_maintainer)

		ubcore_sip_table_uninit(&dev->sip_table);

}



static int ubcore_nego_ver_rsp_msg_cb(struct ubcore_device *dev,
@@ -1153,6 +1156,11 @@ static int ubcore_config_device_rsp_msg_cb(struct ubcore_device *dev, 
	cfg.rc_cfg.rc_cnt = data->rc_cnt;

	cfg.rc_cfg.depth = data->rc_depth;



	cfg.mask.bs.reserved_jetty_id_min = 1;

	cfg.mask.bs.reserved_jetty_id_max = 1;

	cfg.reserved_jetty_id_min = UBCORE_RESERVED_JETTY_ID_MIN;

	cfg.reserved_jetty_id_max = UBCORE_RESERVED_JETTY_ID_MAX;



	cfg.mask.bs.slice = data->set_slice;

	cfg.slice = data->slice;
@@ -1183,6 +1191,11 @@ static int ubcore_config_device_default(struct ubcore_device *dev) 
	cfg.rc_cfg.rc_cnt = dev->attr.dev_cap.max_rc;

	cfg.rc_cfg.depth = dev->attr.dev_cap.max_rc_depth;



	cfg.mask.bs.reserved_jetty_id_min = 1;

	cfg.mask.bs.reserved_jetty_id_max = 1;

	cfg.reserved_jetty_id_min = UBCORE_RESERVED_JETTY_ID_MIN;

	cfg.reserved_jetty_id_max = UBCORE_RESERVED_JETTY_ID_MAX;



	/* slice and mask.slice are set to 0 by default */



	/* If suspend_period and cnt cannot be read, do not need to configure it */

drivers/ub/urma/ubcore/ubcore_main.c

+2 −4
Original line number Diff line number Diff line
@@ -466,8 +466,7 @@ static void ubcore_handle_update_sip(struct ubcore_device *tpf_dev, 
static int ubcore_handle_update_net_addr(struct ubcore_device *tpf_dev, uint32_t fe_idx,

	struct ubcore_update_net_addr_req *req, bool async)

{

	/* only UB dev need sip */

	if (tpf_dev->transport_type == UBCORE_TRANSPORT_UB && req->sip_present) {

	if (ubcore_is_ub_device(tpf_dev) && req->sip_present) {

		if (req->op == UBCORE_ADD_NET_ADDR)

			ubcore_handle_add_sip(tpf_dev, &req->sip_info, async);

		else if (req->op == UBCORE_DEL_NET_ADDR)
@@ -689,8 +688,7 @@ int ubcore_update_net_addr(struct ubcore_device *dev, struct net_device *netdev, 
	int ret = 0;



	req.op = op;

	// Only UB DEV need save net_addr as sip

	if (dev->transport_type == UBCORE_TRANSPORT_UB) {

	if (ubcore_is_ub_device(dev) && dev->dynamic_eid) {

		ubcore_sip_init(&req.sip_info, dev, netaddr, netdev);

		req.sip_present = true;

	}

drivers/ub/urma/ubcore/ubcore_priv.h

+6 −0
Original line number Diff line number Diff line
@@ -202,4 +202,10 @@ static inline bool ubcore_jfr_need_advise(struct ubcore_jfr *jfr) 
	       jfr->jfr_cfg.trans_mode == UBCORE_TP_RM;

}



static inline bool ubcore_is_ub_device(struct ubcore_device *dev)

{

	return (dev->transport_type == UBCORE_TRANSPORT_UB ||

			dev->transport_type == UBCORE_TRANSPORT_HNS_UB);

}



#endif

drivers/ub/urma/ubcore/ubcore_uvs_cmd.c

+228 −0
Original line number Diff line number Diff line
@@ -3054,6 +3054,232 @@ static int ubcore_cmd_list_migrate_entry(struct ubcore_cmd_hdr *hdr) 
	return ret;

}



static void ubcore_fill_stats_val(struct ubcore_stats_com_val com_val,

	struct ubcore_cmd_opt_dfx_query_stats *arg)

{

	arg->out.tx_pkt = com_val.tx_pkt;

	arg->out.rx_pkt = com_val.rx_pkt;

	arg->out.tx_bytes = com_val.tx_bytes;

	arg->out.rx_bytes = com_val.rx_bytes;

	arg->out.tx_pkt_err = com_val.tx_pkt_err;

	arg->out.rx_pkt_err = com_val.rx_pkt_err;

}



static void ubcore_fill_fe_stats_val(struct ubcore_fe_stats stats,

	struct ubcore_cmd_opt_dfx_query_stats *arg)

{

	arg->out.tx_pkt = stats.tx_pkt;

	arg->out.rx_pkt = stats.rx_pkt;

	arg->out.tx_bytes = stats.tx_bytes;

	arg->out.rx_bytes = stats.rx_bytes;

	arg->out.tx_pkt_err = stats.tx_pkt_err;

	arg->out.rx_pkt_err = stats.rx_pkt_err;



	arg->out.tx_timeout_cnt = stats.tx_timeout_cnt;

	arg->out.rx_ce_pkt = stats.rx_ce_pkt;

}



static int ubcore_dfx_query_stats(struct ubcore_device *dev,

	struct ubcore_cmd_opt_dfx_query_stats *arg)

{

	struct ubcore_stats_com_val com_val;

	struct ubcore_stats_key key;

	struct ubcore_stats_val val;

	int ret;



	if (dev->ops == NULL || dev->ops->query_stats == NULL) {

		ubcore_log_warn("dev ops does not contain query_stats");

		return 0;

	}

	key.type = arg->in.type;

	key.key = arg->in.id;

	val.addr = (uint64_t)&com_val;

	val.len = (uint32_t)sizeof(struct ubcore_stats_com_val);



	ret = ubcore_query_stats(dev, &key, &val);

	if (ret != 0) {

		ubcore_log_err("fail to query stats");

		return ret;

	}



	ubcore_fill_stats_val(com_val, arg);

	return ret;

}



static int ubcore_dfx_query_fe_stats(struct ubcore_device *dev,

	struct ubcore_cmd_opt_dfx_query_stats *arg)

{

	struct ubcore_fe_stats stats;

	int ret;



	uint16_t fe_idx = (uint16_t)arg->in.id;



	if (dev == NULL || dev->ops == NULL || dev->ops->query_fe_stats == NULL) {

		ubcore_log_err("Invalid dev.\n");

		return -1;

	}



	ret = dev->ops->query_fe_stats(dev, 1, &fe_idx, &stats);

	if (ret != 0) {

		ubcore_log_err("Fail to query_fe_stats, ret: %d, dev_name: %s", ret, dev->dev_name);

		return -1;

	}



	ubcore_fill_fe_stats_val(stats, arg);

	return ret;

}



static int ubcore_cmd_opt_dfx_query_stats(struct ubcore_cmd_hdr *hdr)

{

	struct ubcore_cmd_opt_dfx_query_stats arg;

	struct ubcore_device *dev;

	int ret;



	ret = ubcore_copy_from_user(&arg, (void __user *)(uintptr_t)hdr->args_addr,

		sizeof(struct ubcore_cmd_opt_dfx_query_stats));

	if (ret != 0)

		return ret;



	arg.in.dev_name[UBCORE_MAX_DEV_NAME - 1] = '\0';

	dev = ubcore_find_device_with_name(arg.in.dev_name);

	if (dev == NULL) {

		ubcore_log_warn("fail to find dev:%s\n", arg.in.dev_name);

		return -ENODEV;

	}



	switch (arg.in.type) {

	case UBCORE_STATS_KEY_VTP:

	case UBCORE_STATS_KEY_TP:

	case UBCORE_STATS_KEY_TPG:

		ret = ubcore_dfx_query_stats(dev, &arg);

		break;

	case UBCORE_STATS_KEY_URMA_DEV:

		ret = ubcore_dfx_query_fe_stats(dev, &arg);

		break;

	default:

		ret = -1;

		break;

	}



	if (ret != 0) {

		ubcore_log_err("fail to query stats, dev: %s, type: %u\n",

			arg.in.dev_name, arg.in.type);

		goto put_device;

	}



	ret = ubcore_copy_to_user((void __user *)(uintptr_t)hdr->args_addr, &arg,

		sizeof(struct ubcore_cmd_opt_dfx_query_stats));



put_device:

	ubcore_put_device(dev);

	return ret;

}



static int ubcore_fill_tpg_info(struct ubcore_device *dev, struct ubcore_res_tpg_val tpg,

	struct ubcore_cmd_opt_dfx_query_res *arg)

{

	enum ubcore_tp_state tp_state[UBCORE_MAX_TP_CNT_IN_GRP] = {0};

	struct ubcore_tp *tp_infos = NULL;

	int i = 0;



	for (i = 0; i < tpg.tp_cnt; i++) {

		tp_infos = ubcore_find_get_tp(dev, tpg.tp_list[i]);

		if (tp_infos == NULL) {

			ubcore_log_err("Unknown tpn: %d", tpg.tp_list[i]);

			return -1;

		}

		tp_state[i] = tp_infos->state;

		ubcore_tp_kref_put(tp_infos);

	}

	(void)memcpy(arg->out.tpg.tp_state,

		tp_state, sizeof(arg->out.tpg.tp_state));

	(void)memcpy(arg->out.tpg.tpn, tpg.tp_list,

		tpg.tp_cnt * sizeof(*(tpg.tp_list)));

	arg->out.tpg.dscp = tpg.dscp;

	arg->out.tpg.tp_cnt = tpg.tp_cnt;

	return 0;

}



static int ubcore_cmd_opt_dfx_query_res_with_type(struct ubcore_device *dev,

	struct ubcore_cmd_opt_dfx_query_res *arg)

{

	struct ubcore_res_tpg_val tpg = {0};

	struct ubcore_res_key key = {0};

	struct ubcore_res_val val = {0};

	int ret = -1;



	key.type = (uint8_t)arg->in.type;

	key.key = arg->in.key;

	key.key_ext = arg->in.key_ext;

	key.key_cnt = arg->in.key_cnt;



	switch (arg->in.type) {

	case UBCORE_RES_KEY_VTP:

		val.addr = (uint64_t)&arg->out.vtp;

		val.len = (uint32_t)sizeof(struct ubcore_res_vtp_val);

		break;

	case UBCORE_RES_KEY_TP:

		val.addr = (uint64_t)&arg->out.tp;

		val.len = (uint32_t)sizeof(struct ubcore_res_tp_val);

		break;

	case UBCORE_RES_KEY_TPG:

		val.addr = (uint64_t)&tpg;

		val.len = (uint32_t)sizeof(struct ubcore_res_tpg_val);

		break;

	case UBCORE_RES_KEY_UTP:

		val.addr = (uint64_t)&arg->out.utp;

		val.len = (uint32_t)sizeof(struct ubcore_res_utp_val);

		break;

	case UBCORE_RES_KEY_DEV_TP:

		val.addr = (uint64_t)&arg->out.tpf;

		val.len = (uint32_t)sizeof(struct ubcore_res_dev_tp_val);

		break;

	default:

		ubcore_log_err("Unsupported type: %d", arg->in.type);

		return -1;

	}



	ret = ubcore_query_resource(dev, &key, &val);

	if (ret == 0 && arg->in.type == UBCORE_RES_KEY_TPG) {

		ret = ubcore_fill_tpg_info(dev, tpg, arg);

		vfree(tpg.tp_list);

	}

	return ret;

}



static int ubcore_cmd_opt_dfx_query_res(struct ubcore_cmd_hdr *hdr)

{

	struct ubcore_cmd_opt_dfx_query_res arg;

	struct ubcore_device *dev;

	int ret;



	ret = ubcore_copy_from_user(&arg, (void __user *)(uintptr_t)hdr->args_addr,

		sizeof(struct ubcore_cmd_opt_dfx_query_res));

	if (ret != 0)

		return ret;



	arg.in.dev_name[UBCORE_MAX_DEV_NAME - 1] = '\0';

	dev = ubcore_find_device_with_name(arg.in.dev_name);

	if (dev == NULL) {

		ubcore_log_warn("fail to find dev:%s\n", arg.in.dev_name);

		return -ENODEV;

	}



	ret = ubcore_cmd_opt_dfx_query_res_with_type(dev, &arg);

	if (ret != 0) {

		ubcore_log_err("fail to query res, dev: %s, type: %u\n",

			arg.in.dev_name, arg.in.type);

		goto put_device;

	}



	ret = ubcore_copy_to_user((void __user *)(uintptr_t)hdr->args_addr, &arg,

		sizeof(struct ubcore_cmd_opt_dfx_query_res));



put_device:

	ubcore_put_device(dev);

	return ret;

}



typedef int (*ubcore_uvs_cmd_handler)(struct ubcore_cmd_hdr *hdr);

struct ubcore_uvs_cmd_func {

	ubcore_uvs_cmd_handler func;
@@ -3106,6 +3332,8 @@ static struct ubcore_uvs_cmd_func g_ubcore_uvs_cmd_funcs[] = { 
	[UBCORE_CMD_MAP_TARGET_VTP] = {ubcore_cmd_map_target_vtp, false},

	[UBCORE_CMD_LIST_MIGRATE_ENTRY] = {ubcore_cmd_list_migrate_entry, false},

	[UBCORE_CMD_QUERY_DSCP_VL] = {ubcore_cmd_opt_query_dscp_vl, false},

	[UBCORE_CMD_DFX_QUERY_STATS] = {ubcore_cmd_opt_dfx_query_stats, false},

	[UBCORE_CMD_DFX_QUERY_RES] = {ubcore_cmd_opt_dfx_query_res, false},

};



int ubcore_uvs_cmd_parse(struct ubcore_cmd_hdr *hdr)