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 if (napi->irq >= 0 && nla_put_u32(rsp, NETDEV_A_NAPI_IRQ, napi->irq)) 184 goto nla_put_failure; 185 186 genlmsg_end(rsp, hdr); 187 188 return 0; 189 190 nla_put_failure: 191 genlmsg_cancel(rsp, hdr); 192 return -EMSGSIZE; 193 } 194 195 int netdev_nl_napi_get_doit(struct sk_buff *skb, struct genl_info *info) 196 { 197 struct napi_struct *napi; 198 struct sk_buff *rsp; 199 u32 napi_id; 200 int err; 201 202 if (GENL_REQ_ATTR_CHECK(info, NETDEV_A_NAPI_ID)) 203 return -EINVAL; 204 205 napi_id = nla_get_u32(info->attrs[NETDEV_A_NAPI_ID]); 206 207 rsp = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL); 208 if (!rsp) 209 return -ENOMEM; 210 211 rtnl_lock(); 212 213 napi = napi_by_id(napi_id); 214 if (napi) 215 err = netdev_nl_napi_fill_one(rsp, napi, info); 216 else 217 err = -EINVAL; 218 219 rtnl_unlock(); 220 221 if (err) 222 goto err_free_msg; 223 224 return genlmsg_reply(rsp, info); 225 226 err_free_msg: 227 nlmsg_free(rsp); 228 return err; 229 } 230 231 static int 232 netdev_nl_napi_dump_one(struct net_device *netdev, struct sk_buff *rsp, 233 const struct genl_info *info, 234 struct netdev_nl_dump_ctx *ctx) 235 { 236 struct napi_struct *napi; 237 int err = 0; 238 239 if (!(netdev->flags & IFF_UP)) 240 return err; 241 242 list_for_each_entry(napi, &netdev->napi_list, dev_list) { 243 if (ctx->napi_id && napi->napi_id >= ctx->napi_id) 244 continue; 245 246 err = netdev_nl_napi_fill_one(rsp, napi, info); 247 if (err) 248 return err; 249 ctx->napi_id = napi->napi_id; 250 } 251 return err; 252 } 253 254 int netdev_nl_napi_get_dumpit(struct sk_buff *skb, struct netlink_callback *cb) 255 { 256 struct netdev_nl_dump_ctx *ctx = netdev_dump_ctx(cb); 257 const struct genl_info *info = genl_info_dump(cb); 258 struct net *net = sock_net(skb->sk); 259 struct net_device *netdev; 260 u32 ifindex = 0; 261 int err = 0; 262 263 if (info->attrs[NETDEV_A_NAPI_IFINDEX]) 264 ifindex = nla_get_u32(info->attrs[NETDEV_A_NAPI_IFINDEX]); 265 266 rtnl_lock(); 267 if (ifindex) { 268 netdev = __dev_get_by_index(net, ifindex); 269 if (netdev) 270 err = netdev_nl_napi_dump_one(netdev, skb, info, ctx); 271 else 272 err = -ENODEV; 273 } else { 274 for_each_netdev_dump(net, netdev, ctx->ifindex) { 275 err = netdev_nl_napi_dump_one(netdev, skb, info, ctx); 276 if (err < 0) 277 break; 278 ctx->napi_id = 0; 279 } 280 } 281 rtnl_unlock(); 282 283 if (err != -EMSGSIZE) 284 return err; 285 286 return skb->len; 287 } 288 289 static int 290 netdev_nl_queue_fill_one(struct sk_buff *rsp, struct net_device *netdev, 291 u32 q_idx, u32 q_type, const struct genl_info *info) 292 { 293 struct netdev_rx_queue *rxq; 294 struct netdev_queue *txq; 295 void *hdr; 296 297 hdr = genlmsg_iput(rsp, info); 298 if (!hdr) 299 return -EMSGSIZE; 300 301 if (nla_put_u32(rsp, NETDEV_A_QUEUE_ID, q_idx) || 302 nla_put_u32(rsp, NETDEV_A_QUEUE_TYPE, q_type) || 303 nla_put_u32(rsp, NETDEV_A_QUEUE_IFINDEX, netdev->ifindex)) 304 goto nla_put_failure; 305 306 switch (q_type) { 307 case NETDEV_QUEUE_TYPE_RX: 308 rxq = __netif_get_rx_queue(netdev, q_idx); 309 if (rxq->napi && nla_put_u32(rsp, NETDEV_A_QUEUE_NAPI_ID, 310 rxq->napi->napi_id)) 311 goto nla_put_failure; 312 break; 313 case NETDEV_QUEUE_TYPE_TX: 314 txq = netdev_get_tx_queue(netdev, q_idx); 315 if (txq->napi && nla_put_u32(rsp, NETDEV_A_QUEUE_NAPI_ID, 316 txq->napi->napi_id)) 317 goto nla_put_failure; 318 } 319 320 genlmsg_end(rsp, hdr); 321 322 return 0; 323 324 nla_put_failure: 325 genlmsg_cancel(rsp, hdr); 326 return -EMSGSIZE; 327 } 328 329 static int netdev_nl_queue_validate(struct net_device *netdev, u32 q_id, 330 u32 q_type) 331 { 332 switch (q_type) { 333 case NETDEV_QUEUE_TYPE_RX: 334 if (q_id >= netdev->real_num_rx_queues) 335 return -EINVAL; 336 return 0; 337 case NETDEV_QUEUE_TYPE_TX: 338 if (q_id >= netdev->real_num_tx_queues) 339 return -EINVAL; 340 } 341 return 0; 342 } 343 344 static int 345 netdev_nl_queue_fill(struct sk_buff *rsp, struct net_device *netdev, u32 q_idx, 346 u32 q_type, const struct genl_info *info) 347 { 348 int err = 0; 349 350 if (!(netdev->flags & IFF_UP)) 351 return err; 352 353 err = netdev_nl_queue_validate(netdev, q_idx, q_type); 354 if (err) 355 return err; 356 357 return netdev_nl_queue_fill_one(rsp, netdev, q_idx, q_type, info); 358 } 359 360 int netdev_nl_queue_get_doit(struct sk_buff *skb, struct genl_info *info) 361 { 362 u32 q_id, q_type, ifindex; 363 struct net_device *netdev; 364 struct sk_buff *rsp; 365 int err; 366 367 if (GENL_REQ_ATTR_CHECK(info, NETDEV_A_QUEUE_ID) || 368 GENL_REQ_ATTR_CHECK(info, NETDEV_A_QUEUE_TYPE) || 369 GENL_REQ_ATTR_CHECK(info, NETDEV_A_QUEUE_IFINDEX)) 370 return -EINVAL; 371 372 q_id = nla_get_u32(info->attrs[NETDEV_A_QUEUE_ID]); 373 q_type = nla_get_u32(info->attrs[NETDEV_A_QUEUE_TYPE]); 374 ifindex = nla_get_u32(info->attrs[NETDEV_A_QUEUE_IFINDEX]); 375 376 rsp = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL); 377 if (!rsp) 378 return -ENOMEM; 379 380 rtnl_lock(); 381 382 netdev = __dev_get_by_index(genl_info_net(info), ifindex); 383 if (netdev) 384 err = netdev_nl_queue_fill(rsp, netdev, q_id, q_type, info); 385 else 386 err = -ENODEV; 387 388 rtnl_unlock(); 389 390 if (err) 391 goto err_free_msg; 392 393 return genlmsg_reply(rsp, info); 394 395 err_free_msg: 396 nlmsg_free(rsp); 397 return err; 398 } 399 400 static int 401 netdev_nl_queue_dump_one(struct net_device *netdev, struct sk_buff *rsp, 402 const struct genl_info *info, 403 struct netdev_nl_dump_ctx *ctx) 404 { 405 int err = 0; 406 int i; 407 408 if (!(netdev->flags & IFF_UP)) 409 return err; 410 411 for (i = ctx->rxq_idx; i < netdev->real_num_rx_queues;) { 412 err = netdev_nl_queue_fill_one(rsp, netdev, i, 413 NETDEV_QUEUE_TYPE_RX, info); 414 if (err) 415 return err; 416 ctx->rxq_idx = i++; 417 } 418 for (i = ctx->txq_idx; i < netdev->real_num_tx_queues;) { 419 err = netdev_nl_queue_fill_one(rsp, netdev, i, 420 NETDEV_QUEUE_TYPE_TX, info); 421 if (err) 422 return err; 423 ctx->txq_idx = i++; 424 } 425 426 return err; 427 } 428 429 int netdev_nl_queue_get_dumpit(struct sk_buff *skb, struct netlink_callback *cb) 430 { 431 struct netdev_nl_dump_ctx *ctx = netdev_dump_ctx(cb); 432 const struct genl_info *info = genl_info_dump(cb); 433 struct net *net = sock_net(skb->sk); 434 struct net_device *netdev; 435 u32 ifindex = 0; 436 int err = 0; 437 438 if (info->attrs[NETDEV_A_QUEUE_IFINDEX]) 439 ifindex = nla_get_u32(info->attrs[NETDEV_A_QUEUE_IFINDEX]); 440 441 rtnl_lock(); 442 if (ifindex) { 443 netdev = __dev_get_by_index(net, ifindex); 444 if (netdev) 445 err = netdev_nl_queue_dump_one(netdev, skb, info, ctx); 446 else 447 err = -ENODEV; 448 } else { 449 for_each_netdev_dump(net, netdev, ctx->ifindex) { 450 err = netdev_nl_queue_dump_one(netdev, skb, info, ctx); 451 if (err < 0) 452 break; 453 ctx->rxq_idx = 0; 454 ctx->txq_idx = 0; 455 } 456 } 457 rtnl_unlock(); 458 459 if (err != -EMSGSIZE) 460 return err; 461 462 return skb->len; 463 } 464 465 static int netdev_genl_netdevice_event(struct notifier_block *nb, 466 unsigned long event, void *ptr) 467 { 468 struct net_device *netdev = netdev_notifier_info_to_dev(ptr); 469 470 switch (event) { 471 case NETDEV_REGISTER: 472 netdev_genl_dev_notify(netdev, NETDEV_CMD_DEV_ADD_NTF); 473 break; 474 case NETDEV_UNREGISTER: 475 netdev_genl_dev_notify(netdev, NETDEV_CMD_DEV_DEL_NTF); 476 break; 477 case NETDEV_XDP_FEAT_CHANGE: 478 netdev_genl_dev_notify(netdev, NETDEV_CMD_DEV_CHANGE_NTF); 479 break; 480 } 481 482 return NOTIFY_OK; 483 } 484 485 static struct notifier_block netdev_genl_nb = { 486 .notifier_call = netdev_genl_netdevice_event, 487 }; 488 489 static int __init netdev_genl_init(void) 490 { 491 int err; 492 493 err = register_netdevice_notifier(&netdev_genl_nb); 494 if (err) 495 return err; 496 497 err = genl_register_family(&netdev_nl_family); 498 if (err) 499 goto err_unreg_ntf; 500 501 return 0; 502 503 err_unreg_ntf: 504 unregister_netdevice_notifier(&netdev_genl_nb); 505 return err; 506 } 507 508 subsys_initcall(netdev_genl_init); 509