1 // SPDX-License-Identifier: GPL-2.0-only 2 3 #include <linux/netdevice.h> 4 #include <linux/notifier.h> 5 #include <linux/rtnetlink.h> 6 #include <net/net_namespace.h> 7 #include <net/sock.h> 8 #include <net/xdp.h> 9 #include <net/xdp_sock.h> 10 #include <net/netdev_rx_queue.h> 11 #include <net/busy_poll.h> 12 13 #include "netdev-genl-gen.h" 14 #include "dev.h" 15 16 struct netdev_nl_dump_ctx { 17 unsigned long ifindex; 18 unsigned int rxq_idx; 19 unsigned int txq_idx; 20 unsigned int napi_id; 21 }; 22 23 static struct netdev_nl_dump_ctx *netdev_dump_ctx(struct netlink_callback *cb) 24 { 25 NL_ASSERT_DUMP_CTX_FITS(struct netdev_nl_dump_ctx); 26 27 return (struct netdev_nl_dump_ctx *)cb->ctx; 28 } 29 30 static int 31 netdev_nl_dev_fill(struct net_device *netdev, struct sk_buff *rsp, 32 const struct genl_info *info) 33 { 34 u64 xsk_features = 0; 35 u64 xdp_rx_meta = 0; 36 void *hdr; 37 38 hdr = genlmsg_iput(rsp, info); 39 if (!hdr) 40 return -EMSGSIZE; 41 42 #define XDP_METADATA_KFUNC(_, flag, __, xmo) \ 43 if (netdev->xdp_metadata_ops && netdev->xdp_metadata_ops->xmo) \ 44 xdp_rx_meta |= flag; 45 XDP_METADATA_KFUNC_xxx 46 #undef XDP_METADATA_KFUNC 47 48 if (netdev->xsk_tx_metadata_ops) { 49 if (netdev->xsk_tx_metadata_ops->tmo_fill_timestamp) 50 xsk_features |= NETDEV_XSK_FLAGS_TX_TIMESTAMP; 51 if (netdev->xsk_tx_metadata_ops->tmo_request_checksum) 52 xsk_features |= NETDEV_XSK_FLAGS_TX_CHECKSUM; 53 } 54 55 if (nla_put_u32(rsp, NETDEV_A_DEV_IFINDEX, netdev->ifindex) || 56 nla_put_u64_64bit(rsp, NETDEV_A_DEV_XDP_FEATURES, 57 netdev->xdp_features, NETDEV_A_DEV_PAD) || 58 nla_put_u64_64bit(rsp, NETDEV_A_DEV_XDP_RX_METADATA_FEATURES, 59 xdp_rx_meta, NETDEV_A_DEV_PAD) || 60 nla_put_u64_64bit(rsp, NETDEV_A_DEV_XSK_FEATURES, 61 xsk_features, NETDEV_A_DEV_PAD)) { 62 genlmsg_cancel(rsp, hdr); 63 return -EINVAL; 64 } 65 66 if (netdev->xdp_features & NETDEV_XDP_ACT_XSK_ZEROCOPY) { 67 if (nla_put_u32(rsp, NETDEV_A_DEV_XDP_ZC_MAX_SEGS, 68 netdev->xdp_zc_max_segs)) { 69 genlmsg_cancel(rsp, hdr); 70 return -EINVAL; 71 } 72 } 73 74 genlmsg_end(rsp, hdr); 75 76 return 0; 77 } 78 79 static void 80 netdev_genl_dev_notify(struct net_device *netdev, int cmd) 81 { 82 struct genl_info info; 83 struct sk_buff *ntf; 84 85 if (!genl_has_listeners(&netdev_nl_family, dev_net(netdev), 86 NETDEV_NLGRP_MGMT)) 87 return; 88 89 genl_info_init_ntf(&info, &netdev_nl_family, cmd); 90 91 ntf = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL); 92 if (!ntf) 93 return; 94 95 if (netdev_nl_dev_fill(netdev, ntf, &info)) { 96 nlmsg_free(ntf); 97 return; 98 } 99 100 genlmsg_multicast_netns(&netdev_nl_family, dev_net(netdev), ntf, 101 0, NETDEV_NLGRP_MGMT, GFP_KERNEL); 102 } 103 104 int netdev_nl_dev_get_doit(struct sk_buff *skb, struct genl_info *info) 105 { 106 struct net_device *netdev; 107 struct sk_buff *rsp; 108 u32 ifindex; 109 int err; 110 111 if (GENL_REQ_ATTR_CHECK(info, NETDEV_A_DEV_IFINDEX)) 112 return -EINVAL; 113 114 ifindex = nla_get_u32(info->attrs[NETDEV_A_DEV_IFINDEX]); 115 116 rsp = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL); 117 if (!rsp) 118 return -ENOMEM; 119 120 rtnl_lock(); 121 122 netdev = __dev_get_by_index(genl_info_net(info), ifindex); 123 if (netdev) 124 err = netdev_nl_dev_fill(netdev, rsp, info); 125 else 126 err = -ENODEV; 127 128 rtnl_unlock(); 129 130 if (err) 131 goto err_free_msg; 132 133 return genlmsg_reply(rsp, info); 134 135 err_free_msg: 136 nlmsg_free(rsp); 137 return err; 138 } 139 140 int netdev_nl_dev_get_dumpit(struct sk_buff *skb, struct netlink_callback *cb) 141 { 142 struct netdev_nl_dump_ctx *ctx = netdev_dump_ctx(cb); 143 struct net *net = sock_net(skb->sk); 144 struct net_device *netdev; 145 int err = 0; 146 147 rtnl_lock(); 148 for_each_netdev_dump(net, netdev, ctx->ifindex) { 149 err = netdev_nl_dev_fill(netdev, skb, genl_info_dump(cb)); 150 if (err < 0) 151 break; 152 } 153 rtnl_unlock(); 154 155 if (err != -EMSGSIZE) 156 return err; 157 158 return skb->len; 159 } 160 161 static int 162 netdev_nl_napi_fill_one(struct sk_buff *rsp, struct napi_struct *napi, 163 const struct genl_info *info) 164 { 165 void *hdr; 166 167 if (WARN_ON_ONCE(!napi->dev)) 168 return -EINVAL; 169 if (!(napi->dev->flags & IFF_UP)) 170 return 0; 171 172 hdr = genlmsg_iput(rsp, info); 173 if (!hdr) 174 return -EMSGSIZE; 175 176 if (napi->napi_id >= MIN_NAPI_ID && 177 nla_put_u32(rsp, NETDEV_A_NAPI_ID, napi->napi_id)) 178 goto nla_put_failure; 179 180 if (nla_put_u32(rsp, NETDEV_A_NAPI_IFINDEX, napi->dev->ifindex)) 181 goto nla_put_failure; 182 183 genlmsg_end(rsp, hdr); 184 return 0; 185 186 nla_put_failure: 187 genlmsg_cancel(rsp, hdr); 188 return -EMSGSIZE; 189 } 190 191 int netdev_nl_napi_get_doit(struct sk_buff *skb, struct genl_info *info) 192 { 193 struct napi_struct *napi; 194 struct sk_buff *rsp; 195 u32 napi_id; 196 int err; 197 198 if (GENL_REQ_ATTR_CHECK(info, NETDEV_A_NAPI_ID)) 199 return -EINVAL; 200 201 napi_id = nla_get_u32(info->attrs[NETDEV_A_NAPI_ID]); 202 203 rsp = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL); 204 if (!rsp) 205 return -ENOMEM; 206 207 rtnl_lock(); 208 209 napi = napi_by_id(napi_id); 210 if (napi) 211 err = netdev_nl_napi_fill_one(rsp, napi, info); 212 else 213 err = -EINVAL; 214 215 rtnl_unlock(); 216 217 if (err) 218 goto err_free_msg; 219 220 return genlmsg_reply(rsp, info); 221 222 err_free_msg: 223 nlmsg_free(rsp); 224 return err; 225 } 226 227 static int 228 netdev_nl_napi_dump_one(struct net_device *netdev, struct sk_buff *rsp, 229 const struct genl_info *info, 230 struct netdev_nl_dump_ctx *ctx) 231 { 232 struct napi_struct *napi; 233 int err = 0; 234 235 if (!(netdev->flags & IFF_UP)) 236 return err; 237 238 list_for_each_entry(napi, &netdev->napi_list, dev_list) { 239 if (ctx->napi_id && napi->napi_id >= ctx->napi_id) 240 continue; 241 242 err = netdev_nl_napi_fill_one(rsp, napi, info); 243 if (err) 244 return err; 245 ctx->napi_id = napi->napi_id; 246 } 247 return err; 248 } 249 250 int netdev_nl_napi_get_dumpit(struct sk_buff *skb, struct netlink_callback *cb) 251 { 252 struct netdev_nl_dump_ctx *ctx = netdev_dump_ctx(cb); 253 const struct genl_info *info = genl_info_dump(cb); 254 struct net *net = sock_net(skb->sk); 255 struct net_device *netdev; 256 u32 ifindex = 0; 257 int err = 0; 258 259 if (info->attrs[NETDEV_A_NAPI_IFINDEX]) 260 ifindex = nla_get_u32(info->attrs[NETDEV_A_NAPI_IFINDEX]); 261 262 rtnl_lock(); 263 if (ifindex) { 264 netdev = __dev_get_by_index(net, ifindex); 265 if (netdev) 266 err = netdev_nl_napi_dump_one(netdev, skb, info, ctx); 267 else 268 err = -ENODEV; 269 } else { 270 for_each_netdev_dump(net, netdev, ctx->ifindex) { 271 err = netdev_nl_napi_dump_one(netdev, skb, info, ctx); 272 if (err < 0) 273 break; 274 ctx->napi_id = 0; 275 } 276 } 277 rtnl_unlock(); 278 279 if (err != -EMSGSIZE) 280 return err; 281 282 return skb->len; 283 } 284 285 static int 286 netdev_nl_queue_fill_one(struct sk_buff *rsp, struct net_device *netdev, 287 u32 q_idx, u32 q_type, const struct genl_info *info) 288 { 289 struct netdev_rx_queue *rxq; 290 struct netdev_queue *txq; 291 void *hdr; 292 293 hdr = genlmsg_iput(rsp, info); 294 if (!hdr) 295 return -EMSGSIZE; 296 297 if (nla_put_u32(rsp, NETDEV_A_QUEUE_ID, q_idx) || 298 nla_put_u32(rsp, NETDEV_A_QUEUE_TYPE, q_type) || 299 nla_put_u32(rsp, NETDEV_A_QUEUE_IFINDEX, netdev->ifindex)) 300 goto nla_put_failure; 301 302 switch (q_type) { 303 case NETDEV_QUEUE_TYPE_RX: 304 rxq = __netif_get_rx_queue(netdev, q_idx); 305 if (rxq->napi && nla_put_u32(rsp, NETDEV_A_QUEUE_NAPI_ID, 306 rxq->napi->napi_id)) 307 goto nla_put_failure; 308 break; 309 case NETDEV_QUEUE_TYPE_TX: 310 txq = netdev_get_tx_queue(netdev, q_idx); 311 if (txq->napi && nla_put_u32(rsp, NETDEV_A_QUEUE_NAPI_ID, 312 txq->napi->napi_id)) 313 goto nla_put_failure; 314 } 315 316 genlmsg_end(rsp, hdr); 317 318 return 0; 319 320 nla_put_failure: 321 genlmsg_cancel(rsp, hdr); 322 return -EMSGSIZE; 323 } 324 325 static int netdev_nl_queue_validate(struct net_device *netdev, u32 q_id, 326 u32 q_type) 327 { 328 switch (q_type) { 329 case NETDEV_QUEUE_TYPE_RX: 330 if (q_id >= netdev->real_num_rx_queues) 331 return -EINVAL; 332 return 0; 333 case NETDEV_QUEUE_TYPE_TX: 334 if (q_id >= netdev->real_num_tx_queues) 335 return -EINVAL; 336 } 337 return 0; 338 } 339 340 static int 341 netdev_nl_queue_fill(struct sk_buff *rsp, struct net_device *netdev, u32 q_idx, 342 u32 q_type, const struct genl_info *info) 343 { 344 int err = 0; 345 346 if (!(netdev->flags & IFF_UP)) 347 return err; 348 349 err = netdev_nl_queue_validate(netdev, q_idx, q_type); 350 if (err) 351 return err; 352 353 return netdev_nl_queue_fill_one(rsp, netdev, q_idx, q_type, info); 354 } 355 356 int netdev_nl_queue_get_doit(struct sk_buff *skb, struct genl_info *info) 357 { 358 u32 q_id, q_type, ifindex; 359 struct net_device *netdev; 360 struct sk_buff *rsp; 361 int err; 362 363 if (GENL_REQ_ATTR_CHECK(info, NETDEV_A_QUEUE_ID) || 364 GENL_REQ_ATTR_CHECK(info, NETDEV_A_QUEUE_TYPE) || 365 GENL_REQ_ATTR_CHECK(info, NETDEV_A_QUEUE_IFINDEX)) 366 return -EINVAL; 367 368 q_id = nla_get_u32(info->attrs[NETDEV_A_QUEUE_ID]); 369 q_type = nla_get_u32(info->attrs[NETDEV_A_QUEUE_TYPE]); 370 ifindex = nla_get_u32(info->attrs[NETDEV_A_QUEUE_IFINDEX]); 371 372 rsp = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL); 373 if (!rsp) 374 return -ENOMEM; 375 376 rtnl_lock(); 377 378 netdev = __dev_get_by_index(genl_info_net(info), ifindex); 379 if (netdev) 380 err = netdev_nl_queue_fill(rsp, netdev, q_id, q_type, info); 381 else 382 err = -ENODEV; 383 384 rtnl_unlock(); 385 386 if (err) 387 goto err_free_msg; 388 389 return genlmsg_reply(rsp, info); 390 391 err_free_msg: 392 nlmsg_free(rsp); 393 return err; 394 } 395 396 static int 397 netdev_nl_queue_dump_one(struct net_device *netdev, struct sk_buff *rsp, 398 const struct genl_info *info, 399 struct netdev_nl_dump_ctx *ctx) 400 { 401 int err = 0; 402 int i; 403 404 if (!(netdev->flags & IFF_UP)) 405 return err; 406 407 for (i = ctx->rxq_idx; i < netdev->real_num_rx_queues;) { 408 err = netdev_nl_queue_fill_one(rsp, netdev, i, 409 NETDEV_QUEUE_TYPE_RX, info); 410 if (err) 411 return err; 412 ctx->rxq_idx = i++; 413 } 414 for (i = ctx->txq_idx; i < netdev->real_num_tx_queues;) { 415 err = netdev_nl_queue_fill_one(rsp, netdev, i, 416 NETDEV_QUEUE_TYPE_TX, info); 417 if (err) 418 return err; 419 ctx->txq_idx = i++; 420 } 421 422 return err; 423 } 424 425 int netdev_nl_queue_get_dumpit(struct sk_buff *skb, struct netlink_callback *cb) 426 { 427 struct netdev_nl_dump_ctx *ctx = netdev_dump_ctx(cb); 428 const struct genl_info *info = genl_info_dump(cb); 429 struct net *net = sock_net(skb->sk); 430 struct net_device *netdev; 431 u32 ifindex = 0; 432 int err = 0; 433 434 if (info->attrs[NETDEV_A_QUEUE_IFINDEX]) 435 ifindex = nla_get_u32(info->attrs[NETDEV_A_QUEUE_IFINDEX]); 436 437 rtnl_lock(); 438 if (ifindex) { 439 netdev = __dev_get_by_index(net, ifindex); 440 if (netdev) 441 err = netdev_nl_queue_dump_one(netdev, skb, info, ctx); 442 else 443 err = -ENODEV; 444 } else { 445 for_each_netdev_dump(net, netdev, ctx->ifindex) { 446 err = netdev_nl_queue_dump_one(netdev, skb, info, ctx); 447 if (err < 0) 448 break; 449 ctx->rxq_idx = 0; 450 ctx->txq_idx = 0; 451 } 452 } 453 rtnl_unlock(); 454 455 if (err != -EMSGSIZE) 456 return err; 457 458 return skb->len; 459 } 460 461 static int netdev_genl_netdevice_event(struct notifier_block *nb, 462 unsigned long event, void *ptr) 463 { 464 struct net_device *netdev = netdev_notifier_info_to_dev(ptr); 465 466 switch (event) { 467 case NETDEV_REGISTER: 468 netdev_genl_dev_notify(netdev, NETDEV_CMD_DEV_ADD_NTF); 469 break; 470 case NETDEV_UNREGISTER: 471 netdev_genl_dev_notify(netdev, NETDEV_CMD_DEV_DEL_NTF); 472 break; 473 case NETDEV_XDP_FEAT_CHANGE: 474 netdev_genl_dev_notify(netdev, NETDEV_CMD_DEV_CHANGE_NTF); 475 break; 476 } 477 478 return NOTIFY_OK; 479 } 480 481 static struct notifier_block netdev_genl_nb = { 482 .notifier_call = netdev_genl_netdevice_event, 483 }; 484 485 static int __init netdev_genl_init(void) 486 { 487 int err; 488 489 err = register_netdevice_notifier(&netdev_genl_nb); 490 if (err) 491 return err; 492 493 err = genl_register_family(&netdev_nl_family); 494 if (err) 495 goto err_unreg_ntf; 496 497 return 0; 498 499 err_unreg_ntf: 500 unregister_netdevice_notifier(&netdev_genl_nb); 501 return err; 502 } 503 504 subsys_initcall(netdev_genl_init); 505