1 // SPDX-License-Identifier: GPL-2.0-only 2 3 #include "netlink.h" 4 #include "common.h" 5 6 struct rings_req_info { 7 struct ethnl_req_info base; 8 }; 9 10 struct rings_reply_data { 11 struct ethnl_reply_data base; 12 struct ethtool_ringparam ringparam; 13 struct kernel_ethtool_ringparam kernel_ringparam; 14 }; 15 16 #define RINGS_REPDATA(__reply_base) \ 17 container_of(__reply_base, struct rings_reply_data, base) 18 19 const struct nla_policy ethnl_rings_get_policy[] = { 20 [ETHTOOL_A_RINGS_HEADER] = 21 NLA_POLICY_NESTED(ethnl_header_policy), 22 }; 23 24 static int rings_prepare_data(const struct ethnl_req_info *req_base, 25 struct ethnl_reply_data *reply_base, 26 struct genl_info *info) 27 { 28 struct rings_reply_data *data = RINGS_REPDATA(reply_base); 29 struct netlink_ext_ack *extack = info ? info->extack : NULL; 30 struct net_device *dev = reply_base->dev; 31 int ret; 32 33 if (!dev->ethtool_ops->get_ringparam) 34 return -EOPNOTSUPP; 35 ret = ethnl_ops_begin(dev); 36 if (ret < 0) 37 return ret; 38 dev->ethtool_ops->get_ringparam(dev, &data->ringparam, 39 &data->kernel_ringparam, extack); 40 ethnl_ops_complete(dev); 41 42 return 0; 43 } 44 45 static int rings_reply_size(const struct ethnl_req_info *req_base, 46 const struct ethnl_reply_data *reply_base) 47 { 48 return nla_total_size(sizeof(u32)) + /* _RINGS_RX_MAX */ 49 nla_total_size(sizeof(u32)) + /* _RINGS_RX_MINI_MAX */ 50 nla_total_size(sizeof(u32)) + /* _RINGS_RX_JUMBO_MAX */ 51 nla_total_size(sizeof(u32)) + /* _RINGS_TX_MAX */ 52 nla_total_size(sizeof(u32)) + /* _RINGS_RX */ 53 nla_total_size(sizeof(u32)) + /* _RINGS_RX_MINI */ 54 nla_total_size(sizeof(u32)) + /* _RINGS_RX_JUMBO */ 55 nla_total_size(sizeof(u32)) + /* _RINGS_TX */ 56 nla_total_size(sizeof(u32)) + /* _RINGS_RX_BUF_LEN */ 57 nla_total_size(sizeof(u8)) + /* _RINGS_TCP_DATA_SPLIT */ 58 nla_total_size(sizeof(u32) + /* _RINGS_CQE_SIZE */ 59 nla_total_size(sizeof(u8))); /* _RINGS_TX_PUSH */ 60 } 61 62 static int rings_fill_reply(struct sk_buff *skb, 63 const struct ethnl_req_info *req_base, 64 const struct ethnl_reply_data *reply_base) 65 { 66 const struct rings_reply_data *data = RINGS_REPDATA(reply_base); 67 const struct kernel_ethtool_ringparam *kr = &data->kernel_ringparam; 68 const struct ethtool_ringparam *ringparam = &data->ringparam; 69 70 WARN_ON(kr->tcp_data_split > ETHTOOL_TCP_DATA_SPLIT_ENABLED); 71 72 if ((ringparam->rx_max_pending && 73 (nla_put_u32(skb, ETHTOOL_A_RINGS_RX_MAX, 74 ringparam->rx_max_pending) || 75 nla_put_u32(skb, ETHTOOL_A_RINGS_RX, 76 ringparam->rx_pending))) || 77 (ringparam->rx_mini_max_pending && 78 (nla_put_u32(skb, ETHTOOL_A_RINGS_RX_MINI_MAX, 79 ringparam->rx_mini_max_pending) || 80 nla_put_u32(skb, ETHTOOL_A_RINGS_RX_MINI, 81 ringparam->rx_mini_pending))) || 82 (ringparam->rx_jumbo_max_pending && 83 (nla_put_u32(skb, ETHTOOL_A_RINGS_RX_JUMBO_MAX, 84 ringparam->rx_jumbo_max_pending) || 85 nla_put_u32(skb, ETHTOOL_A_RINGS_RX_JUMBO, 86 ringparam->rx_jumbo_pending))) || 87 (ringparam->tx_max_pending && 88 (nla_put_u32(skb, ETHTOOL_A_RINGS_TX_MAX, 89 ringparam->tx_max_pending) || 90 nla_put_u32(skb, ETHTOOL_A_RINGS_TX, 91 ringparam->tx_pending))) || 92 (kr->rx_buf_len && 93 (nla_put_u32(skb, ETHTOOL_A_RINGS_RX_BUF_LEN, kr->rx_buf_len))) || 94 (kr->tcp_data_split && 95 (nla_put_u8(skb, ETHTOOL_A_RINGS_TCP_DATA_SPLIT, 96 kr->tcp_data_split))) || 97 (kr->cqe_size && 98 (nla_put_u32(skb, ETHTOOL_A_RINGS_CQE_SIZE, kr->cqe_size))) || 99 nla_put_u8(skb, ETHTOOL_A_RINGS_TX_PUSH, !!kr->tx_push)) 100 return -EMSGSIZE; 101 102 return 0; 103 } 104 105 /* RINGS_SET */ 106 107 const struct nla_policy ethnl_rings_set_policy[] = { 108 [ETHTOOL_A_RINGS_HEADER] = 109 NLA_POLICY_NESTED(ethnl_header_policy), 110 [ETHTOOL_A_RINGS_RX] = { .type = NLA_U32 }, 111 [ETHTOOL_A_RINGS_RX_MINI] = { .type = NLA_U32 }, 112 [ETHTOOL_A_RINGS_RX_JUMBO] = { .type = NLA_U32 }, 113 [ETHTOOL_A_RINGS_TX] = { .type = NLA_U32 }, 114 [ETHTOOL_A_RINGS_RX_BUF_LEN] = NLA_POLICY_MIN(NLA_U32, 1), 115 [ETHTOOL_A_RINGS_CQE_SIZE] = NLA_POLICY_MIN(NLA_U32, 1), 116 [ETHTOOL_A_RINGS_TX_PUSH] = NLA_POLICY_MAX(NLA_U8, 1), 117 }; 118 119 static int 120 ethnl_set_rings_validate(struct ethnl_req_info *req_info, 121 struct genl_info *info) 122 { 123 const struct ethtool_ops *ops = req_info->dev->ethtool_ops; 124 struct nlattr **tb = info->attrs; 125 126 if (tb[ETHTOOL_A_RINGS_RX_BUF_LEN] && 127 !(ops->supported_ring_params & ETHTOOL_RING_USE_RX_BUF_LEN)) { 128 NL_SET_ERR_MSG_ATTR(info->extack, 129 tb[ETHTOOL_A_RINGS_RX_BUF_LEN], 130 "setting rx buf len not supported"); 131 return -EOPNOTSUPP; 132 } 133 134 if (tb[ETHTOOL_A_RINGS_CQE_SIZE] && 135 !(ops->supported_ring_params & ETHTOOL_RING_USE_CQE_SIZE)) { 136 NL_SET_ERR_MSG_ATTR(info->extack, 137 tb[ETHTOOL_A_RINGS_CQE_SIZE], 138 "setting cqe size not supported"); 139 return -EOPNOTSUPP; 140 } 141 142 if (tb[ETHTOOL_A_RINGS_TX_PUSH] && 143 !(ops->supported_ring_params & ETHTOOL_RING_USE_TX_PUSH)) { 144 NL_SET_ERR_MSG_ATTR(info->extack, 145 tb[ETHTOOL_A_RINGS_TX_PUSH], 146 "setting tx push not supported"); 147 return -EOPNOTSUPP; 148 } 149 150 return ops->get_ringparam && ops->set_ringparam ? 1 : -EOPNOTSUPP; 151 } 152 153 static int 154 ethnl_set_rings(struct ethnl_req_info *req_info, struct genl_info *info) 155 { 156 struct kernel_ethtool_ringparam kernel_ringparam = {}; 157 struct ethtool_ringparam ringparam = {}; 158 struct net_device *dev = req_info->dev; 159 struct nlattr **tb = info->attrs; 160 const struct nlattr *err_attr; 161 bool mod = false; 162 int ret; 163 164 dev->ethtool_ops->get_ringparam(dev, &ringparam, 165 &kernel_ringparam, info->extack); 166 167 ethnl_update_u32(&ringparam.rx_pending, tb[ETHTOOL_A_RINGS_RX], &mod); 168 ethnl_update_u32(&ringparam.rx_mini_pending, 169 tb[ETHTOOL_A_RINGS_RX_MINI], &mod); 170 ethnl_update_u32(&ringparam.rx_jumbo_pending, 171 tb[ETHTOOL_A_RINGS_RX_JUMBO], &mod); 172 ethnl_update_u32(&ringparam.tx_pending, tb[ETHTOOL_A_RINGS_TX], &mod); 173 ethnl_update_u32(&kernel_ringparam.rx_buf_len, 174 tb[ETHTOOL_A_RINGS_RX_BUF_LEN], &mod); 175 ethnl_update_u32(&kernel_ringparam.cqe_size, 176 tb[ETHTOOL_A_RINGS_CQE_SIZE], &mod); 177 ethnl_update_u8(&kernel_ringparam.tx_push, 178 tb[ETHTOOL_A_RINGS_TX_PUSH], &mod); 179 if (!mod) 180 return 0; 181 182 /* ensure new ring parameters are within limits */ 183 if (ringparam.rx_pending > ringparam.rx_max_pending) 184 err_attr = tb[ETHTOOL_A_RINGS_RX]; 185 else if (ringparam.rx_mini_pending > ringparam.rx_mini_max_pending) 186 err_attr = tb[ETHTOOL_A_RINGS_RX_MINI]; 187 else if (ringparam.rx_jumbo_pending > ringparam.rx_jumbo_max_pending) 188 err_attr = tb[ETHTOOL_A_RINGS_RX_JUMBO]; 189 else if (ringparam.tx_pending > ringparam.tx_max_pending) 190 err_attr = tb[ETHTOOL_A_RINGS_TX]; 191 else 192 err_attr = NULL; 193 if (err_attr) { 194 NL_SET_ERR_MSG_ATTR(info->extack, err_attr, 195 "requested ring size exceeds maximum"); 196 return -EINVAL; 197 } 198 199 ret = dev->ethtool_ops->set_ringparam(dev, &ringparam, 200 &kernel_ringparam, info->extack); 201 return ret < 0 ? ret : 1; 202 } 203 204 const struct ethnl_request_ops ethnl_rings_request_ops = { 205 .request_cmd = ETHTOOL_MSG_RINGS_GET, 206 .reply_cmd = ETHTOOL_MSG_RINGS_GET_REPLY, 207 .hdr_attr = ETHTOOL_A_RINGS_HEADER, 208 .req_info_size = sizeof(struct rings_req_info), 209 .reply_data_size = sizeof(struct rings_reply_data), 210 211 .prepare_data = rings_prepare_data, 212 .reply_size = rings_reply_size, 213 .fill_reply = rings_fill_reply, 214 215 .set_validate = ethnl_set_rings_validate, 216 .set = ethnl_set_rings, 217 .set_ntf_cmd = ETHTOOL_MSG_RINGS_NTF, 218 }; 219