1 // SPDX-License-Identifier: GPL-2.0-only 2 3 #include <net/netdev_queues.h> 4 5 #include "common.h" 6 #include "netlink.h" 7 #include "../core/dev.h" 8 9 struct rings_req_info { 10 struct ethnl_req_info base; 11 }; 12 13 struct rings_reply_data { 14 struct ethnl_reply_data base; 15 struct ethtool_ringparam ringparam; 16 struct kernel_ethtool_ringparam kernel_ringparam; 17 u32 supported_ring_params; 18 }; 19 20 #define RINGS_REPDATA(__reply_base) \ 21 container_of(__reply_base, struct rings_reply_data, base) 22 23 const struct nla_policy ethnl_rings_get_policy[] = { 24 [ETHTOOL_A_RINGS_HEADER] = 25 NLA_POLICY_NESTED(ethnl_header_policy), 26 }; 27 28 static int rings_prepare_data(const struct ethnl_req_info *req_base, 29 struct ethnl_reply_data *reply_base, 30 const struct genl_info *info) 31 { 32 struct rings_reply_data *data = RINGS_REPDATA(reply_base); 33 struct net_device *dev = reply_base->dev; 34 int ret; 35 36 if (!dev->ethtool_ops->get_ringparam) 37 return -EOPNOTSUPP; 38 39 data->supported_ring_params = dev->ethtool_ops->supported_ring_params; 40 ret = ethnl_ops_begin(dev); 41 if (ret < 0) 42 return ret; 43 44 data->kernel_ringparam.tcp_data_split = dev->cfg->hds_config; 45 data->kernel_ringparam.hds_thresh = dev->cfg->hds_thresh; 46 47 dev->ethtool_ops->get_ringparam(dev, &data->ringparam, 48 &data->kernel_ringparam, info->extack); 49 ethnl_ops_complete(dev); 50 51 return 0; 52 } 53 54 static int rings_reply_size(const struct ethnl_req_info *req_base, 55 const struct ethnl_reply_data *reply_base) 56 { 57 return nla_total_size(sizeof(u32)) + /* _RINGS_RX_MAX */ 58 nla_total_size(sizeof(u32)) + /* _RINGS_RX_MINI_MAX */ 59 nla_total_size(sizeof(u32)) + /* _RINGS_RX_JUMBO_MAX */ 60 nla_total_size(sizeof(u32)) + /* _RINGS_TX_MAX */ 61 nla_total_size(sizeof(u32)) + /* _RINGS_RX */ 62 nla_total_size(sizeof(u32)) + /* _RINGS_RX_MINI */ 63 nla_total_size(sizeof(u32)) + /* _RINGS_RX_JUMBO */ 64 nla_total_size(sizeof(u32)) + /* _RINGS_TX */ 65 nla_total_size(sizeof(u32)) + /* _RINGS_RX_BUF_LEN */ 66 nla_total_size(sizeof(u8)) + /* _RINGS_TCP_DATA_SPLIT */ 67 nla_total_size(sizeof(u32)) + /* _RINGS_CQE_SIZE */ 68 nla_total_size(sizeof(u8)) + /* _RINGS_TX_PUSH */ 69 nla_total_size(sizeof(u8)) + /* _RINGS_RX_PUSH */ 70 nla_total_size(sizeof(u32)) + /* _RINGS_TX_PUSH_BUF_LEN */ 71 nla_total_size(sizeof(u32)) + /* _RINGS_TX_PUSH_BUF_LEN_MAX */ 72 nla_total_size(sizeof(u32)) + /* _RINGS_HDS_THRESH */ 73 nla_total_size(sizeof(u32)); /* _RINGS_HDS_THRESH_MAX*/ 74 } 75 76 static int rings_fill_reply(struct sk_buff *skb, 77 const struct ethnl_req_info *req_base, 78 const struct ethnl_reply_data *reply_base) 79 { 80 const struct rings_reply_data *data = RINGS_REPDATA(reply_base); 81 const struct kernel_ethtool_ringparam *kr = &data->kernel_ringparam; 82 const struct ethtool_ringparam *ringparam = &data->ringparam; 83 u32 supported_ring_params = data->supported_ring_params; 84 85 WARN_ON(kr->tcp_data_split > ETHTOOL_TCP_DATA_SPLIT_ENABLED); 86 87 if ((ringparam->rx_max_pending && 88 (nla_put_u32(skb, ETHTOOL_A_RINGS_RX_MAX, 89 ringparam->rx_max_pending) || 90 nla_put_u32(skb, ETHTOOL_A_RINGS_RX, 91 ringparam->rx_pending))) || 92 (ringparam->rx_mini_max_pending && 93 (nla_put_u32(skb, ETHTOOL_A_RINGS_RX_MINI_MAX, 94 ringparam->rx_mini_max_pending) || 95 nla_put_u32(skb, ETHTOOL_A_RINGS_RX_MINI, 96 ringparam->rx_mini_pending))) || 97 (ringparam->rx_jumbo_max_pending && 98 (nla_put_u32(skb, ETHTOOL_A_RINGS_RX_JUMBO_MAX, 99 ringparam->rx_jumbo_max_pending) || 100 nla_put_u32(skb, ETHTOOL_A_RINGS_RX_JUMBO, 101 ringparam->rx_jumbo_pending))) || 102 (ringparam->tx_max_pending && 103 (nla_put_u32(skb, ETHTOOL_A_RINGS_TX_MAX, 104 ringparam->tx_max_pending) || 105 nla_put_u32(skb, ETHTOOL_A_RINGS_TX, 106 ringparam->tx_pending))) || 107 (kr->rx_buf_len && 108 (nla_put_u32(skb, ETHTOOL_A_RINGS_RX_BUF_LEN, kr->rx_buf_len))) || 109 (kr->tcp_data_split && 110 (nla_put_u8(skb, ETHTOOL_A_RINGS_TCP_DATA_SPLIT, 111 kr->tcp_data_split))) || 112 (kr->cqe_size && 113 (nla_put_u32(skb, ETHTOOL_A_RINGS_CQE_SIZE, kr->cqe_size))) || 114 nla_put_u8(skb, ETHTOOL_A_RINGS_TX_PUSH, !!kr->tx_push) || 115 nla_put_u8(skb, ETHTOOL_A_RINGS_RX_PUSH, !!kr->rx_push) || 116 ((supported_ring_params & ETHTOOL_RING_USE_TX_PUSH_BUF_LEN) && 117 (nla_put_u32(skb, ETHTOOL_A_RINGS_TX_PUSH_BUF_LEN_MAX, 118 kr->tx_push_buf_max_len) || 119 nla_put_u32(skb, ETHTOOL_A_RINGS_TX_PUSH_BUF_LEN, 120 kr->tx_push_buf_len))) || 121 ((supported_ring_params & ETHTOOL_RING_USE_HDS_THRS) && 122 (nla_put_u32(skb, ETHTOOL_A_RINGS_HDS_THRESH, 123 kr->hds_thresh) || 124 nla_put_u32(skb, ETHTOOL_A_RINGS_HDS_THRESH_MAX, 125 kr->hds_thresh_max)))) 126 return -EMSGSIZE; 127 128 return 0; 129 } 130 131 /* RINGS_SET */ 132 133 const struct nla_policy ethnl_rings_set_policy[] = { 134 [ETHTOOL_A_RINGS_HEADER] = 135 NLA_POLICY_NESTED(ethnl_header_policy), 136 [ETHTOOL_A_RINGS_RX] = { .type = NLA_U32 }, 137 [ETHTOOL_A_RINGS_RX_MINI] = { .type = NLA_U32 }, 138 [ETHTOOL_A_RINGS_RX_JUMBO] = { .type = NLA_U32 }, 139 [ETHTOOL_A_RINGS_TX] = { .type = NLA_U32 }, 140 [ETHTOOL_A_RINGS_RX_BUF_LEN] = NLA_POLICY_MIN(NLA_U32, 1), 141 [ETHTOOL_A_RINGS_TCP_DATA_SPLIT] = 142 NLA_POLICY_MAX(NLA_U8, ETHTOOL_TCP_DATA_SPLIT_ENABLED), 143 [ETHTOOL_A_RINGS_CQE_SIZE] = NLA_POLICY_MIN(NLA_U32, 1), 144 [ETHTOOL_A_RINGS_TX_PUSH] = NLA_POLICY_MAX(NLA_U8, 1), 145 [ETHTOOL_A_RINGS_RX_PUSH] = NLA_POLICY_MAX(NLA_U8, 1), 146 [ETHTOOL_A_RINGS_TX_PUSH_BUF_LEN] = { .type = NLA_U32 }, 147 [ETHTOOL_A_RINGS_HDS_THRESH] = { .type = NLA_U32 }, 148 }; 149 150 static int 151 ethnl_set_rings_validate(struct ethnl_req_info *req_info, 152 struct genl_info *info) 153 { 154 const struct ethtool_ops *ops = req_info->dev->ethtool_ops; 155 struct nlattr **tb = info->attrs; 156 157 if (tb[ETHTOOL_A_RINGS_RX_BUF_LEN] && 158 !(ops->supported_ring_params & ETHTOOL_RING_USE_RX_BUF_LEN)) { 159 NL_SET_ERR_MSG_ATTR(info->extack, 160 tb[ETHTOOL_A_RINGS_RX_BUF_LEN], 161 "setting rx buf len not supported"); 162 return -EOPNOTSUPP; 163 } 164 165 if (tb[ETHTOOL_A_RINGS_TCP_DATA_SPLIT] && 166 !(ops->supported_ring_params & ETHTOOL_RING_USE_TCP_DATA_SPLIT)) { 167 NL_SET_ERR_MSG_ATTR(info->extack, 168 tb[ETHTOOL_A_RINGS_TCP_DATA_SPLIT], 169 "setting TCP data split is not supported"); 170 return -EOPNOTSUPP; 171 } 172 173 if (tb[ETHTOOL_A_RINGS_HDS_THRESH] && 174 !(ops->supported_ring_params & ETHTOOL_RING_USE_HDS_THRS)) { 175 NL_SET_ERR_MSG_ATTR(info->extack, 176 tb[ETHTOOL_A_RINGS_HDS_THRESH], 177 "setting hds-thresh is not supported"); 178 return -EOPNOTSUPP; 179 } 180 181 if (tb[ETHTOOL_A_RINGS_CQE_SIZE] && 182 !(ops->supported_ring_params & ETHTOOL_RING_USE_CQE_SIZE)) { 183 NL_SET_ERR_MSG_ATTR(info->extack, 184 tb[ETHTOOL_A_RINGS_CQE_SIZE], 185 "setting cqe size not supported"); 186 return -EOPNOTSUPP; 187 } 188 189 if (tb[ETHTOOL_A_RINGS_TX_PUSH] && 190 !(ops->supported_ring_params & ETHTOOL_RING_USE_TX_PUSH)) { 191 NL_SET_ERR_MSG_ATTR(info->extack, 192 tb[ETHTOOL_A_RINGS_TX_PUSH], 193 "setting tx push not supported"); 194 return -EOPNOTSUPP; 195 } 196 197 if (tb[ETHTOOL_A_RINGS_RX_PUSH] && 198 !(ops->supported_ring_params & ETHTOOL_RING_USE_RX_PUSH)) { 199 NL_SET_ERR_MSG_ATTR(info->extack, 200 tb[ETHTOOL_A_RINGS_RX_PUSH], 201 "setting rx push not supported"); 202 return -EOPNOTSUPP; 203 } 204 205 if (tb[ETHTOOL_A_RINGS_TX_PUSH_BUF_LEN] && 206 !(ops->supported_ring_params & ETHTOOL_RING_USE_TX_PUSH_BUF_LEN)) { 207 NL_SET_ERR_MSG_ATTR(info->extack, 208 tb[ETHTOOL_A_RINGS_TX_PUSH_BUF_LEN], 209 "setting tx push buf len is not supported"); 210 return -EOPNOTSUPP; 211 } 212 213 return ops->get_ringparam && ops->set_ringparam ? 1 : -EOPNOTSUPP; 214 } 215 216 static int 217 ethnl_set_rings(struct ethnl_req_info *req_info, struct genl_info *info) 218 { 219 struct kernel_ethtool_ringparam kernel_ringparam; 220 struct net_device *dev = req_info->dev; 221 struct ethtool_ringparam ringparam; 222 struct nlattr **tb = info->attrs; 223 const struct nlattr *err_attr; 224 bool mod = false; 225 int ret; 226 227 ethtool_ringparam_get_cfg(dev, &ringparam, &kernel_ringparam, 228 info->extack); 229 230 ethnl_update_u32(&ringparam.rx_pending, tb[ETHTOOL_A_RINGS_RX], &mod); 231 ethnl_update_u32(&ringparam.rx_mini_pending, 232 tb[ETHTOOL_A_RINGS_RX_MINI], &mod); 233 ethnl_update_u32(&ringparam.rx_jumbo_pending, 234 tb[ETHTOOL_A_RINGS_RX_JUMBO], &mod); 235 ethnl_update_u32(&ringparam.tx_pending, tb[ETHTOOL_A_RINGS_TX], &mod); 236 ethnl_update_u32(&kernel_ringparam.rx_buf_len, 237 tb[ETHTOOL_A_RINGS_RX_BUF_LEN], &mod); 238 ethnl_update_u8(&kernel_ringparam.tcp_data_split, 239 tb[ETHTOOL_A_RINGS_TCP_DATA_SPLIT], &mod); 240 ethnl_update_u32(&kernel_ringparam.cqe_size, 241 tb[ETHTOOL_A_RINGS_CQE_SIZE], &mod); 242 ethnl_update_u8(&kernel_ringparam.tx_push, 243 tb[ETHTOOL_A_RINGS_TX_PUSH], &mod); 244 ethnl_update_u8(&kernel_ringparam.rx_push, 245 tb[ETHTOOL_A_RINGS_RX_PUSH], &mod); 246 ethnl_update_u32(&kernel_ringparam.tx_push_buf_len, 247 tb[ETHTOOL_A_RINGS_TX_PUSH_BUF_LEN], &mod); 248 ethnl_update_u32(&kernel_ringparam.hds_thresh, 249 tb[ETHTOOL_A_RINGS_HDS_THRESH], &mod); 250 if (!mod) 251 return 0; 252 253 if (kernel_ringparam.tcp_data_split == ETHTOOL_TCP_DATA_SPLIT_ENABLED && 254 dev_xdp_sb_prog_count(dev)) { 255 NL_SET_ERR_MSG_ATTR(info->extack, 256 tb[ETHTOOL_A_RINGS_TCP_DATA_SPLIT], 257 "tcp-data-split can not be enabled with single buffer XDP"); 258 return -EINVAL; 259 } 260 261 if (dev_get_min_mp_channel_count(dev)) { 262 if (kernel_ringparam.tcp_data_split != 263 ETHTOOL_TCP_DATA_SPLIT_ENABLED) { 264 NL_SET_ERR_MSG(info->extack, 265 "can't disable tcp-data-split while device has memory provider enabled"); 266 return -EINVAL; 267 } else if (kernel_ringparam.hds_thresh) { 268 NL_SET_ERR_MSG(info->extack, 269 "can't set non-zero hds_thresh while device is memory provider enabled"); 270 return -EINVAL; 271 } 272 } 273 274 /* ensure new ring parameters are within limits */ 275 if (ringparam.rx_pending > ringparam.rx_max_pending) 276 err_attr = tb[ETHTOOL_A_RINGS_RX]; 277 else if (ringparam.rx_mini_pending > ringparam.rx_mini_max_pending) 278 err_attr = tb[ETHTOOL_A_RINGS_RX_MINI]; 279 else if (ringparam.rx_jumbo_pending > ringparam.rx_jumbo_max_pending) 280 err_attr = tb[ETHTOOL_A_RINGS_RX_JUMBO]; 281 else if (ringparam.tx_pending > ringparam.tx_max_pending) 282 err_attr = tb[ETHTOOL_A_RINGS_TX]; 283 else if (kernel_ringparam.hds_thresh > kernel_ringparam.hds_thresh_max) 284 err_attr = tb[ETHTOOL_A_RINGS_HDS_THRESH]; 285 else 286 err_attr = NULL; 287 if (err_attr) { 288 NL_SET_ERR_MSG_ATTR(info->extack, err_attr, 289 "requested ring size exceeds maximum"); 290 return -EINVAL; 291 } 292 293 if (kernel_ringparam.tx_push_buf_len > kernel_ringparam.tx_push_buf_max_len) { 294 NL_SET_ERR_MSG_ATTR_FMT(info->extack, tb[ETHTOOL_A_RINGS_TX_PUSH_BUF_LEN], 295 "Requested TX push buffer exceeds the maximum of %u", 296 kernel_ringparam.tx_push_buf_max_len); 297 298 return -EINVAL; 299 } 300 301 dev->cfg_pending->hds_config = kernel_ringparam.tcp_data_split; 302 dev->cfg_pending->hds_thresh = kernel_ringparam.hds_thresh; 303 ethtool_ringparam_set_cfg(dev->cfg_pending, &ringparam); 304 305 ret = netdev_queue_config_revalidate(dev, info->extack); 306 if (ret) 307 return ret; 308 309 ret = dev->ethtool_ops->set_ringparam(dev, &ringparam, 310 &kernel_ringparam, info->extack); 311 if (ret < 0) 312 return ret; 313 314 /* Capture ring depth adjustments reported by the driver. */ 315 ethtool_ringparam_set_cfg(dev->cfg_pending, &ringparam); 316 return 1; 317 } 318 319 const struct ethnl_request_ops ethnl_rings_request_ops = { 320 .request_cmd = ETHTOOL_MSG_RINGS_GET, 321 .reply_cmd = ETHTOOL_MSG_RINGS_GET_REPLY, 322 .hdr_attr = ETHTOOL_A_RINGS_HEADER, 323 .req_info_size = sizeof(struct rings_req_info), 324 .reply_data_size = sizeof(struct rings_reply_data), 325 326 .prepare_data = rings_prepare_data, 327 .reply_size = rings_reply_size, 328 .fill_reply = rings_fill_reply, 329 330 .set_validate = ethnl_set_rings_validate, 331 .set = ethnl_set_rings, 332 .set_ntf_cmd = ETHTOOL_MSG_RINGS_NTF, 333 }; 334