1 // SPDX-License-Identifier: GPL-2.0-only 2 3 #include <net/netdev_lock.h> 4 5 #include "netlink.h" 6 #include "common.h" 7 8 struct rss_req_info { 9 struct ethnl_req_info base; 10 u32 rss_context; 11 }; 12 13 struct rss_reply_data { 14 struct ethnl_reply_data base; 15 bool no_key_fields; 16 u32 indir_size; 17 u32 hkey_size; 18 u32 hfunc; 19 u32 input_xfrm; 20 u32 *indir_table; 21 u8 *hkey; 22 }; 23 24 #define RSS_REQINFO(__req_base) \ 25 container_of(__req_base, struct rss_req_info, base) 26 27 #define RSS_REPDATA(__reply_base) \ 28 container_of(__reply_base, struct rss_reply_data, base) 29 30 const struct nla_policy ethnl_rss_get_policy[] = { 31 [ETHTOOL_A_RSS_HEADER] = NLA_POLICY_NESTED(ethnl_header_policy), 32 [ETHTOOL_A_RSS_CONTEXT] = { .type = NLA_U32 }, 33 [ETHTOOL_A_RSS_START_CONTEXT] = { .type = NLA_U32 }, 34 }; 35 36 static int 37 rss_parse_request(struct ethnl_req_info *req_info, struct nlattr **tb, 38 struct netlink_ext_ack *extack) 39 { 40 struct rss_req_info *request = RSS_REQINFO(req_info); 41 42 if (tb[ETHTOOL_A_RSS_CONTEXT]) 43 request->rss_context = nla_get_u32(tb[ETHTOOL_A_RSS_CONTEXT]); 44 if (tb[ETHTOOL_A_RSS_START_CONTEXT]) { 45 NL_SET_BAD_ATTR(extack, tb[ETHTOOL_A_RSS_START_CONTEXT]); 46 return -EINVAL; 47 } 48 49 return 0; 50 } 51 52 static int 53 rss_prepare_get(const struct rss_req_info *request, struct net_device *dev, 54 struct rss_reply_data *data, const struct genl_info *info) 55 { 56 struct ethtool_rxfh_param rxfh = {}; 57 const struct ethtool_ops *ops; 58 u32 total_size, indir_bytes; 59 u8 *rss_config; 60 int ret; 61 62 ops = dev->ethtool_ops; 63 64 ret = ethnl_ops_begin(dev); 65 if (ret < 0) 66 return ret; 67 mutex_lock(&dev->ethtool->rss_lock); 68 69 data->indir_size = 0; 70 data->hkey_size = 0; 71 if (ops->get_rxfh_indir_size) 72 data->indir_size = ops->get_rxfh_indir_size(dev); 73 if (ops->get_rxfh_key_size) 74 data->hkey_size = ops->get_rxfh_key_size(dev); 75 76 indir_bytes = data->indir_size * sizeof(u32); 77 total_size = indir_bytes + data->hkey_size; 78 rss_config = kzalloc(total_size, GFP_KERNEL); 79 if (!rss_config) { 80 ret = -ENOMEM; 81 goto out_unlock; 82 } 83 84 if (data->indir_size) 85 data->indir_table = (u32 *)rss_config; 86 if (data->hkey_size) 87 data->hkey = rss_config + indir_bytes; 88 89 rxfh.indir_size = data->indir_size; 90 rxfh.indir = data->indir_table; 91 rxfh.key_size = data->hkey_size; 92 rxfh.key = data->hkey; 93 94 ret = ops->get_rxfh(dev, &rxfh); 95 if (ret) 96 goto out_unlock; 97 98 data->hfunc = rxfh.hfunc; 99 data->input_xfrm = rxfh.input_xfrm; 100 out_unlock: 101 mutex_unlock(&dev->ethtool->rss_lock); 102 ethnl_ops_complete(dev); 103 return ret; 104 } 105 106 static int 107 rss_prepare_ctx(const struct rss_req_info *request, struct net_device *dev, 108 struct rss_reply_data *data, const struct genl_info *info) 109 { 110 struct ethtool_rxfh_context *ctx; 111 u32 total_size, indir_bytes; 112 u8 *rss_config; 113 int ret; 114 115 data->no_key_fields = !dev->ethtool_ops->rxfh_per_ctx_key; 116 117 mutex_lock(&dev->ethtool->rss_lock); 118 ctx = xa_load(&dev->ethtool->rss_ctx, request->rss_context); 119 if (!ctx) { 120 ret = -ENOENT; 121 goto out_unlock; 122 } 123 124 data->indir_size = ctx->indir_size; 125 data->hkey_size = ctx->key_size; 126 data->hfunc = ctx->hfunc; 127 data->input_xfrm = ctx->input_xfrm; 128 129 indir_bytes = data->indir_size * sizeof(u32); 130 total_size = indir_bytes + data->hkey_size; 131 rss_config = kzalloc(total_size, GFP_KERNEL); 132 if (!rss_config) { 133 ret = -ENOMEM; 134 goto out_unlock; 135 } 136 137 data->indir_table = (u32 *)rss_config; 138 memcpy(data->indir_table, ethtool_rxfh_context_indir(ctx), indir_bytes); 139 140 if (data->hkey_size) { 141 data->hkey = rss_config + indir_bytes; 142 memcpy(data->hkey, ethtool_rxfh_context_key(ctx), 143 data->hkey_size); 144 } 145 146 ret = 0; 147 out_unlock: 148 mutex_unlock(&dev->ethtool->rss_lock); 149 return ret; 150 } 151 152 static int 153 rss_prepare(const struct rss_req_info *request, struct net_device *dev, 154 struct rss_reply_data *data, const struct genl_info *info) 155 { 156 if (request->rss_context) 157 return rss_prepare_ctx(request, dev, data, info); 158 return rss_prepare_get(request, dev, data, info); 159 } 160 161 static int 162 rss_prepare_data(const struct ethnl_req_info *req_base, 163 struct ethnl_reply_data *reply_base, 164 const struct genl_info *info) 165 { 166 struct rss_reply_data *data = RSS_REPDATA(reply_base); 167 struct rss_req_info *request = RSS_REQINFO(req_base); 168 struct net_device *dev = reply_base->dev; 169 const struct ethtool_ops *ops; 170 171 ops = dev->ethtool_ops; 172 if (!ops->get_rxfh) 173 return -EOPNOTSUPP; 174 175 /* Some drivers don't handle rss_context */ 176 if (request->rss_context && !ops->create_rxfh_context) 177 return -EOPNOTSUPP; 178 179 return rss_prepare(request, dev, data, info); 180 } 181 182 static int 183 rss_reply_size(const struct ethnl_req_info *req_base, 184 const struct ethnl_reply_data *reply_base) 185 { 186 const struct rss_reply_data *data = RSS_REPDATA(reply_base); 187 int len; 188 189 len = nla_total_size(sizeof(u32)) + /* _RSS_CONTEXT */ 190 nla_total_size(sizeof(u32)) + /* _RSS_HFUNC */ 191 nla_total_size(sizeof(u32)) + /* _RSS_INPUT_XFRM */ 192 nla_total_size(sizeof(u32) * data->indir_size) + /* _RSS_INDIR */ 193 nla_total_size(data->hkey_size); /* _RSS_HKEY */ 194 195 return len; 196 } 197 198 static int 199 rss_fill_reply(struct sk_buff *skb, const struct ethnl_req_info *req_base, 200 const struct ethnl_reply_data *reply_base) 201 { 202 const struct rss_reply_data *data = RSS_REPDATA(reply_base); 203 struct rss_req_info *request = RSS_REQINFO(req_base); 204 205 if (request->rss_context && 206 nla_put_u32(skb, ETHTOOL_A_RSS_CONTEXT, request->rss_context)) 207 return -EMSGSIZE; 208 209 if ((data->indir_size && 210 nla_put(skb, ETHTOOL_A_RSS_INDIR, 211 sizeof(u32) * data->indir_size, data->indir_table))) 212 return -EMSGSIZE; 213 214 if (data->no_key_fields) 215 return 0; 216 217 if ((data->hfunc && 218 nla_put_u32(skb, ETHTOOL_A_RSS_HFUNC, data->hfunc)) || 219 (data->input_xfrm && 220 nla_put_u32(skb, ETHTOOL_A_RSS_INPUT_XFRM, data->input_xfrm)) || 221 (data->hkey_size && 222 nla_put(skb, ETHTOOL_A_RSS_HKEY, data->hkey_size, data->hkey))) 223 return -EMSGSIZE; 224 225 return 0; 226 } 227 228 static void rss_cleanup_data(struct ethnl_reply_data *reply_base) 229 { 230 const struct rss_reply_data *data = RSS_REPDATA(reply_base); 231 232 kfree(data->indir_table); 233 } 234 235 struct rss_nl_dump_ctx { 236 unsigned long ifindex; 237 unsigned long ctx_idx; 238 239 /* User wants to only dump contexts from given ifindex */ 240 unsigned int match_ifindex; 241 unsigned int start_ctx; 242 }; 243 244 static struct rss_nl_dump_ctx *rss_dump_ctx(struct netlink_callback *cb) 245 { 246 NL_ASSERT_CTX_FITS(struct rss_nl_dump_ctx); 247 248 return (struct rss_nl_dump_ctx *)cb->ctx; 249 } 250 251 int ethnl_rss_dump_start(struct netlink_callback *cb) 252 { 253 const struct genl_info *info = genl_info_dump(cb); 254 struct rss_nl_dump_ctx *ctx = rss_dump_ctx(cb); 255 struct ethnl_req_info req_info = {}; 256 struct nlattr **tb = info->attrs; 257 int ret; 258 259 /* Filtering by context not supported */ 260 if (tb[ETHTOOL_A_RSS_CONTEXT]) { 261 NL_SET_BAD_ATTR(info->extack, tb[ETHTOOL_A_RSS_CONTEXT]); 262 return -EINVAL; 263 } 264 if (tb[ETHTOOL_A_RSS_START_CONTEXT]) { 265 ctx->start_ctx = nla_get_u32(tb[ETHTOOL_A_RSS_START_CONTEXT]); 266 ctx->ctx_idx = ctx->start_ctx; 267 } 268 269 ret = ethnl_parse_header_dev_get(&req_info, 270 tb[ETHTOOL_A_RSS_HEADER], 271 sock_net(cb->skb->sk), cb->extack, 272 false); 273 if (req_info.dev) { 274 ctx->match_ifindex = req_info.dev->ifindex; 275 ctx->ifindex = ctx->match_ifindex; 276 ethnl_parse_header_dev_put(&req_info); 277 req_info.dev = NULL; 278 } 279 280 return ret; 281 } 282 283 static int 284 rss_dump_one_ctx(struct sk_buff *skb, struct netlink_callback *cb, 285 struct net_device *dev, u32 rss_context) 286 { 287 const struct genl_info *info = genl_info_dump(cb); 288 struct rss_reply_data data = {}; 289 struct rss_req_info req = {}; 290 void *ehdr; 291 int ret; 292 293 req.rss_context = rss_context; 294 295 ehdr = ethnl_dump_put(skb, cb, ETHTOOL_MSG_RSS_GET_REPLY); 296 if (!ehdr) 297 return -EMSGSIZE; 298 299 ret = ethnl_fill_reply_header(skb, dev, ETHTOOL_A_RSS_HEADER); 300 if (ret < 0) 301 goto err_cancel; 302 303 ret = rss_prepare(&req, dev, &data, info); 304 if (ret) 305 goto err_cancel; 306 307 ret = rss_fill_reply(skb, &req.base, &data.base); 308 if (ret) 309 goto err_cleanup; 310 genlmsg_end(skb, ehdr); 311 312 rss_cleanup_data(&data.base); 313 return 0; 314 315 err_cleanup: 316 rss_cleanup_data(&data.base); 317 err_cancel: 318 genlmsg_cancel(skb, ehdr); 319 return ret; 320 } 321 322 static int 323 rss_dump_one_dev(struct sk_buff *skb, struct netlink_callback *cb, 324 struct net_device *dev) 325 { 326 struct rss_nl_dump_ctx *ctx = rss_dump_ctx(cb); 327 int ret; 328 329 if (!dev->ethtool_ops->get_rxfh) 330 return 0; 331 332 if (!ctx->ctx_idx) { 333 ret = rss_dump_one_ctx(skb, cb, dev, 0); 334 if (ret) 335 return ret; 336 ctx->ctx_idx++; 337 } 338 339 for (; xa_find(&dev->ethtool->rss_ctx, &ctx->ctx_idx, 340 ULONG_MAX, XA_PRESENT); ctx->ctx_idx++) { 341 ret = rss_dump_one_ctx(skb, cb, dev, ctx->ctx_idx); 342 if (ret) 343 return ret; 344 } 345 ctx->ctx_idx = ctx->start_ctx; 346 347 return 0; 348 } 349 350 int ethnl_rss_dumpit(struct sk_buff *skb, struct netlink_callback *cb) 351 { 352 struct rss_nl_dump_ctx *ctx = rss_dump_ctx(cb); 353 struct net *net = sock_net(skb->sk); 354 struct net_device *dev; 355 int ret = 0; 356 357 rtnl_lock(); 358 for_each_netdev_dump(net, dev, ctx->ifindex) { 359 if (ctx->match_ifindex && ctx->match_ifindex != ctx->ifindex) 360 break; 361 362 netdev_lock_ops(dev); 363 ret = rss_dump_one_dev(skb, cb, dev); 364 netdev_unlock_ops(dev); 365 if (ret) 366 break; 367 } 368 rtnl_unlock(); 369 370 return ret; 371 } 372 373 /* RSS_NTF */ 374 375 void ethtool_rss_notify(struct net_device *dev, u32 rss_context) 376 { 377 struct rss_req_info req_info = { 378 .rss_context = rss_context, 379 }; 380 381 ethnl_notify(dev, ETHTOOL_MSG_RSS_NTF, &req_info.base); 382 } 383 384 const struct ethnl_request_ops ethnl_rss_request_ops = { 385 .request_cmd = ETHTOOL_MSG_RSS_GET, 386 .reply_cmd = ETHTOOL_MSG_RSS_GET_REPLY, 387 .hdr_attr = ETHTOOL_A_RSS_HEADER, 388 .req_info_size = sizeof(struct rss_req_info), 389 .reply_data_size = sizeof(struct rss_reply_data), 390 391 .parse_request = rss_parse_request, 392 .prepare_data = rss_prepare_data, 393 .reply_size = rss_reply_size, 394 .fill_reply = rss_fill_reply, 395 .cleanup_data = rss_cleanup_data, 396 }; 397