tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

rtnetlink: Pack newlink() params into struct

There are 4 net namespaces involved when creating links:

- source netns - where the netlink socket resides,
- target netns - where to put the device being created,
- link netns - netns associated with the device (backend),
- peer netns - netns of peer device.

Currently, two nets are passed to newlink() callback - "src_net"
parameter and "dev_net" (implicitly in net_device). They are set as
follows, depending on netlink attributes in the request.

+------------+-------------------+---------+---------+
| peer netns | IFLA_LINK_NETNSID | src_net | dev_net |
+------------+-------------------+---------+---------+
| | absent | source | target |
| absent +-------------------+---------+---------+
| | present | link | link |
+------------+-------------------+---------+---------+
| | absent | peer | target |
| present +-------------------+---------+---------+
| | present | peer | link |
+------------+-------------------+---------+---------+

When IFLA_LINK_NETNSID is present, the device is created in link netns
first and then moved to target netns. This has some side effects,
including extra ifindex allocation, ifname validation and link events.
These could be avoided if we create it in target netns from
the beginning.

On the other hand, the meaning of src_net parameter is ambiguous. It
varies depending on how parameters are passed. It is the effective
link (or peer netns) by design, but some drivers ignore it and use
dev_net instead.

To provide more netns context for drivers, this patch packs existing
newlink() parameters, along with the source netns, link netns and peer
netns, into a struct. The old "src_net" is renamed to "net" to avoid
confusion with real source netns, and will be deprecated later. The use
of src_net are converted to params->net trivially.

Signed-off-by: Xiao Liang <shaw.leon@gmail.com>
Reviewed-by: Kuniyuki Iwashima <kuniyu@amazon.com>
Link: https://patch.msgid.link/20250219125039.18024-3-shaw.leon@gmail.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

authored by

Xiao Liang and committed by
Jakub Kicinski 69c7be1b ec061546

+223 -110
+5 -2
drivers/infiniband/ulp/ipoib/ipoib_netlink.c
··· 97 97 return ret; 98 98 } 99 99 100 - static int ipoib_new_child_link(struct net *src_net, struct net_device *dev, 101 - struct nlattr *tb[], struct nlattr *data[], 100 + static int ipoib_new_child_link(struct net_device *dev, 101 + struct rtnl_newlink_params *params, 102 102 struct netlink_ext_ack *extack) 103 103 { 104 + struct nlattr **data = params->data; 105 + struct net *src_net = params->net; 106 + struct nlattr **tb = params->tb; 104 107 struct net_device *pdev; 105 108 struct ipoib_dev_priv *ppriv; 106 109 u16 child_pkey;
+5 -2
drivers/net/amt.c
··· 3161 3161 return 0; 3162 3162 } 3163 3163 3164 - static int amt_newlink(struct net *net, struct net_device *dev, 3165 - struct nlattr *tb[], struct nlattr *data[], 3164 + static int amt_newlink(struct net_device *dev, 3165 + struct rtnl_newlink_params *params, 3166 3166 struct netlink_ext_ack *extack) 3167 3167 { 3168 3168 struct amt_dev *amt = netdev_priv(dev); 3169 + struct nlattr **data = params->data; 3170 + struct nlattr **tb = params->tb; 3171 + struct net *net = params->net; 3169 3172 int err = -EINVAL; 3170 3173 3171 3174 amt->net = net;
+5 -2
drivers/net/bareudp.c
··· 698 698 unregister_netdevice_queue(dev, head); 699 699 } 700 700 701 - static int bareudp_newlink(struct net *net, struct net_device *dev, 702 - struct nlattr *tb[], struct nlattr *data[], 701 + static int bareudp_newlink(struct net_device *dev, 702 + struct rtnl_newlink_params *params, 703 703 struct netlink_ext_ack *extack) 704 704 { 705 + struct nlattr **data = params->data; 706 + struct nlattr **tb = params->tb; 707 + struct net *net = params->net; 705 708 struct bareudp_conf conf; 706 709 int err; 707 710
+4 -2
drivers/net/bonding/bond_netlink.c
··· 564 564 return 0; 565 565 } 566 566 567 - static int bond_newlink(struct net *src_net, struct net_device *bond_dev, 568 - struct nlattr *tb[], struct nlattr *data[], 567 + static int bond_newlink(struct net_device *bond_dev, 568 + struct rtnl_newlink_params *params, 569 569 struct netlink_ext_ack *extack) 570 570 { 571 + struct nlattr **data = params->data; 572 + struct nlattr **tb = params->tb; 571 573 int err; 572 574 573 575 err = bond_changelink(bond_dev, tb, data, extack);
+2 -2
drivers/net/can/dev/netlink.c
··· 624 624 return -EMSGSIZE; 625 625 } 626 626 627 - static int can_newlink(struct net *src_net, struct net_device *dev, 628 - struct nlattr *tb[], struct nlattr *data[], 627 + static int can_newlink(struct net_device *dev, 628 + struct rtnl_newlink_params *params, 629 629 struct netlink_ext_ack *extack) 630 630 { 631 631 return -EOPNOTSUPP;
+5 -2
drivers/net/can/vxcan.c
··· 172 172 /* forward declaration for rtnl_create_link() */ 173 173 static struct rtnl_link_ops vxcan_link_ops; 174 174 175 - static int vxcan_newlink(struct net *peer_net, struct net_device *dev, 176 - struct nlattr *tb[], struct nlattr *data[], 175 + static int vxcan_newlink(struct net_device *dev, 176 + struct rtnl_newlink_params *params, 177 177 struct netlink_ext_ack *extack) 178 178 { 179 + struct nlattr **data = params->data; 180 + struct net *peer_net = params->net; 181 + struct nlattr **tb = params->tb; 179 182 struct vxcan_priv *priv; 180 183 struct net_device *peer; 181 184
+5 -2
drivers/net/ethernet/qualcomm/rmnet/rmnet_config.c
··· 117 117 rmnet_unregister_real_device(bridge_dev); 118 118 } 119 119 120 - static int rmnet_newlink(struct net *src_net, struct net_device *dev, 121 - struct nlattr *tb[], struct nlattr *data[], 120 + static int rmnet_newlink(struct net_device *dev, 121 + struct rtnl_newlink_params *params, 122 122 struct netlink_ext_ack *extack) 123 123 { 124 124 u32 data_format = RMNET_FLAGS_INGRESS_DEAGGREGATION; 125 + struct nlattr **data = params->data; 126 + struct net *src_net = params->net; 127 + struct nlattr **tb = params->tb; 125 128 struct net_device *real_dev; 126 129 int mode = RMNET_EPMODE_VND; 127 130 struct rmnet_endpoint *ep;
+5 -2
drivers/net/geneve.c
··· 1614 1614 geneve_change_mtu(dev, ldev_mtu - info->options_len); 1615 1615 } 1616 1616 1617 - static int geneve_newlink(struct net *net, struct net_device *dev, 1618 - struct nlattr *tb[], struct nlattr *data[], 1617 + static int geneve_newlink(struct net_device *dev, 1618 + struct rtnl_newlink_params *params, 1619 1619 struct netlink_ext_ack *extack) 1620 1620 { 1621 + struct nlattr **data = params->data; 1622 + struct nlattr **tb = params->tb; 1623 + struct net *net = params->net; 1621 1624 struct geneve_config cfg = { 1622 1625 .df = GENEVE_DF_UNSET, 1623 1626 .use_udp6_rx_checksums = false,
+4 -2
drivers/net/gtp.c
··· 1462 1462 #define GTP_TH_MAXLEN (sizeof(struct udphdr) + sizeof(struct gtp0_header)) 1463 1463 #define GTP_IPV6_MAXLEN (sizeof(struct ipv6hdr) + GTP_TH_MAXLEN) 1464 1464 1465 - static int gtp_newlink(struct net *src_net, struct net_device *dev, 1466 - struct nlattr *tb[], struct nlattr *data[], 1465 + static int gtp_newlink(struct net_device *dev, 1466 + struct rtnl_newlink_params *params, 1467 1467 struct netlink_ext_ack *extack) 1468 1468 { 1469 + struct nlattr **data = params->data; 1470 + struct net *src_net = params->net; 1469 1471 unsigned int role = GTP_ROLE_GGSN; 1470 1472 struct gtp_dev *gtp; 1471 1473 struct gtp_net *gn;
+1 -2
drivers/net/ipvlan/ipvlan.h
··· 166 166 void *ipvlan_get_L3_hdr(struct ipvl_port *port, struct sk_buff *skb, int *type); 167 167 void ipvlan_count_rx(const struct ipvl_dev *ipvlan, 168 168 unsigned int len, bool success, bool mcast); 169 - int ipvlan_link_new(struct net *src_net, struct net_device *dev, 170 - struct nlattr *tb[], struct nlattr *data[], 169 + int ipvlan_link_new(struct net_device *dev, struct rtnl_newlink_params *params, 171 170 struct netlink_ext_ack *extack); 172 171 void ipvlan_link_delete(struct net_device *dev, struct list_head *head); 173 172 void ipvlan_link_setup(struct net_device *dev);
+4 -2
drivers/net/ipvlan/ipvlan_main.c
··· 532 532 return ret; 533 533 } 534 534 535 - int ipvlan_link_new(struct net *src_net, struct net_device *dev, 536 - struct nlattr *tb[], struct nlattr *data[], 535 + int ipvlan_link_new(struct net_device *dev, struct rtnl_newlink_params *params, 537 536 struct netlink_ext_ack *extack) 538 537 { 539 538 struct ipvl_dev *ipvlan = netdev_priv(dev); 539 + struct nlattr **data = params->data; 540 + struct net *src_net = params->net; 541 + struct nlattr **tb = params->tb; 540 542 struct ipvl_port *port; 541 543 struct net_device *phy_dev; 542 544 int err;
+3 -3
drivers/net/ipvlan/ipvtap.c
··· 73 73 netdev_update_features(vlan->dev); 74 74 } 75 75 76 - static int ipvtap_newlink(struct net *src_net, struct net_device *dev, 77 - struct nlattr *tb[], struct nlattr *data[], 76 + static int ipvtap_newlink(struct net_device *dev, 77 + struct rtnl_newlink_params *params, 78 78 struct netlink_ext_ack *extack) 79 79 { 80 80 struct ipvtap_dev *vlantap = netdev_priv(dev); ··· 97 97 /* Don't put anything that may fail after macvlan_common_newlink 98 98 * because we can't undo what it does. 99 99 */ 100 - err = ipvlan_link_new(src_net, dev, tb, data, extack); 100 + err = ipvlan_link_new(dev, params, extack); 101 101 if (err) { 102 102 netdev_rx_handler_unregister(dev); 103 103 return err;
+5 -2
drivers/net/macsec.c
··· 4141 4141 4142 4142 static struct lock_class_key macsec_netdev_addr_lock_key; 4143 4143 4144 - static int macsec_newlink(struct net *net, struct net_device *dev, 4145 - struct nlattr *tb[], struct nlattr *data[], 4144 + static int macsec_newlink(struct net_device *dev, 4145 + struct rtnl_newlink_params *params, 4146 4146 struct netlink_ext_ack *extack) 4147 4147 { 4148 4148 struct macsec_dev *macsec = macsec_priv(dev); 4149 + struct nlattr **data = params->data; 4150 + struct nlattr **tb = params->tb; 4151 + struct net *net = params->net; 4149 4152 rx_handler_func_t *rx_handler; 4150 4153 u8 icv_len = MACSEC_DEFAULT_ICV_LEN; 4151 4154 struct net_device *real_dev;
+11 -8
drivers/net/macvlan.c
··· 1440 1440 return 0; 1441 1441 } 1442 1442 1443 - int macvlan_common_newlink(struct net *src_net, struct net_device *dev, 1444 - struct nlattr *tb[], struct nlattr *data[], 1443 + int macvlan_common_newlink(struct net_device *dev, 1444 + struct rtnl_newlink_params *params, 1445 1445 struct netlink_ext_ack *extack) 1446 1446 { 1447 1447 struct macvlan_dev *vlan = netdev_priv(dev); 1448 - struct macvlan_port *port; 1448 + struct nlattr **data = params->data; 1449 + struct net *src_net = params->net; 1450 + struct nlattr **tb = params->tb; 1449 1451 struct net_device *lowerdev; 1450 - int err; 1451 - int macmode; 1452 + struct macvlan_port *port; 1452 1453 bool create = false; 1454 + int macmode; 1455 + int err; 1453 1456 1454 1457 if (!tb[IFLA_LINK]) 1455 1458 return -EINVAL; ··· 1568 1565 } 1569 1566 EXPORT_SYMBOL_GPL(macvlan_common_newlink); 1570 1567 1571 - static int macvlan_newlink(struct net *src_net, struct net_device *dev, 1572 - struct nlattr *tb[], struct nlattr *data[], 1568 + static int macvlan_newlink(struct net_device *dev, 1569 + struct rtnl_newlink_params *params, 1573 1570 struct netlink_ext_ack *extack) 1574 1571 { 1575 - return macvlan_common_newlink(src_net, dev, tb, data, extack); 1572 + return macvlan_common_newlink(dev, params, extack); 1576 1573 } 1577 1574 1578 1575 void macvlan_dellink(struct net_device *dev, struct list_head *head)
+3 -3
drivers/net/macvtap.c
··· 77 77 netdev_update_features(vlan->dev); 78 78 } 79 79 80 - static int macvtap_newlink(struct net *src_net, struct net_device *dev, 81 - struct nlattr *tb[], struct nlattr *data[], 80 + static int macvtap_newlink(struct net_device *dev, 81 + struct rtnl_newlink_params *params, 82 82 struct netlink_ext_ack *extack) 83 83 { 84 84 struct macvtap_dev *vlantap = netdev_priv(dev); ··· 105 105 /* Don't put anything that may fail after macvlan_common_newlink 106 106 * because we can't undo what it does. 107 107 */ 108 - err = macvlan_common_newlink(src_net, dev, tb, data, extack); 108 + err = macvlan_common_newlink(dev, params, extack); 109 109 if (err) { 110 110 netdev_rx_handler_unregister(dev); 111 111 return err;
+9 -5
drivers/net/netkit.c
··· 327 327 328 328 static struct rtnl_link_ops netkit_link_ops; 329 329 330 - static int netkit_new_link(struct net *peer_net, struct net_device *dev, 331 - struct nlattr *tb[], struct nlattr *data[], 330 + static int netkit_new_link(struct net_device *dev, 331 + struct rtnl_newlink_params *params, 332 332 struct netlink_ext_ack *extack) 333 333 { 334 - struct nlattr *peer_tb[IFLA_MAX + 1], **tbp = tb, *attr; 335 - enum netkit_action policy_prim = NETKIT_PASS; 336 - enum netkit_action policy_peer = NETKIT_PASS; 337 334 enum netkit_scrub scrub_prim = NETKIT_SCRUB_DEFAULT; 338 335 enum netkit_scrub scrub_peer = NETKIT_SCRUB_DEFAULT; 336 + struct nlattr *peer_tb[IFLA_MAX + 1], **tbp, *attr; 337 + enum netkit_action policy_prim = NETKIT_PASS; 338 + enum netkit_action policy_peer = NETKIT_PASS; 339 + struct nlattr **data = params->data; 340 + struct net *peer_net = params->net; 339 341 enum netkit_mode mode = NETKIT_L3; 340 342 unsigned char ifname_assign_type; 343 + struct nlattr **tb = params->tb; 341 344 u16 headroom = 0, tailroom = 0; 342 345 struct ifinfomsg *ifmp = NULL; 343 346 struct net_device *peer; ··· 348 345 struct netkit *nk; 349 346 int err; 350 347 348 + tbp = tb; 351 349 if (data) { 352 350 if (data[IFLA_NETKIT_MODE]) 353 351 mode = nla_get_u32(data[IFLA_NETKIT_MODE]);
+3 -2
drivers/net/pfcp.c
··· 184 184 return PTR_ERR_OR_ZERO(pfcp->sock); 185 185 } 186 186 187 - static int pfcp_newlink(struct net *net, struct net_device *dev, 188 - struct nlattr *tb[], struct nlattr *data[], 187 + static int pfcp_newlink(struct net_device *dev, 188 + struct rtnl_newlink_params *params, 189 189 struct netlink_ext_ack *extack) 190 190 { 191 191 struct pfcp_dev *pfcp = netdev_priv(dev); 192 + struct net *net = params->net; 192 193 struct pfcp_net *pn; 193 194 int err; 194 195
+5 -2
drivers/net/ppp/ppp_generic.c
··· 1303 1303 return 0; 1304 1304 } 1305 1305 1306 - static int ppp_nl_newlink(struct net *src_net, struct net_device *dev, 1307 - struct nlattr *tb[], struct nlattr *data[], 1306 + static int ppp_nl_newlink(struct net_device *dev, 1307 + struct rtnl_newlink_params *params, 1308 1308 struct netlink_ext_ack *extack) 1309 1309 { 1310 + struct nlattr **data = params->data; 1311 + struct net *src_net = params->net; 1312 + struct nlattr **tb = params->tb; 1310 1313 struct ppp_config conf = { 1311 1314 .unit = -1, 1312 1315 .ifname_is_set = true,
+4 -2
drivers/net/team/team_core.c
··· 2218 2218 dev->features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX; 2219 2219 } 2220 2220 2221 - static int team_newlink(struct net *src_net, struct net_device *dev, 2222 - struct nlattr *tb[], struct nlattr *data[], 2221 + static int team_newlink(struct net_device *dev, 2222 + struct rtnl_newlink_params *params, 2223 2223 struct netlink_ext_ack *extack) 2224 2224 { 2225 + struct nlattr **tb = params->tb; 2226 + 2225 2227 if (tb[IFLA_ADDRESS] == NULL) 2226 2228 eth_hw_addr_random(dev); 2227 2229
+5 -2
drivers/net/veth.c
··· 1765 1765 return 0; 1766 1766 } 1767 1767 1768 - static int veth_newlink(struct net *peer_net, struct net_device *dev, 1769 - struct nlattr *tb[], struct nlattr *data[], 1768 + static int veth_newlink(struct net_device *dev, 1769 + struct rtnl_newlink_params *params, 1770 1770 struct netlink_ext_ack *extack) 1771 1771 { 1772 + struct nlattr **data = params->data; 1773 + struct net *peer_net = params->net; 1774 + struct nlattr **tb = params->tb; 1772 1775 int err; 1773 1776 struct net_device *peer; 1774 1777 struct veth_priv *priv;
+3 -2
drivers/net/vrf.c
··· 1675 1675 unregister_netdevice_queue(dev, head); 1676 1676 } 1677 1677 1678 - static int vrf_newlink(struct net *src_net, struct net_device *dev, 1679 - struct nlattr *tb[], struct nlattr *data[], 1678 + static int vrf_newlink(struct net_device *dev, 1679 + struct rtnl_newlink_params *params, 1680 1680 struct netlink_ext_ack *extack) 1681 1681 { 1682 1682 struct net_vrf *vrf = netdev_priv(dev); 1683 + struct nlattr **data = params->data; 1683 1684 struct netns_vrf *nn_vrf; 1684 1685 bool *add_fib_rules; 1685 1686 struct net *net;
+5 -2
drivers/net/vxlan/vxlan_core.c
··· 4400 4400 return 0; 4401 4401 } 4402 4402 4403 - static int vxlan_newlink(struct net *src_net, struct net_device *dev, 4404 - struct nlattr *tb[], struct nlattr *data[], 4403 + static int vxlan_newlink(struct net_device *dev, 4404 + struct rtnl_newlink_params *params, 4405 4405 struct netlink_ext_ack *extack) 4406 4406 { 4407 + struct nlattr **data = params->data; 4408 + struct net *src_net = params->net; 4409 + struct nlattr **tb = params->tb; 4407 4410 struct vxlan_config conf; 4408 4411 int err; 4409 4412
+3 -2
drivers/net/wireguard/device.c
··· 307 307 wg->dev = dev; 308 308 } 309 309 310 - static int wg_newlink(struct net *src_net, struct net_device *dev, 311 - struct nlattr *tb[], struct nlattr *data[], 310 + static int wg_newlink(struct net_device *dev, 311 + struct rtnl_newlink_params *params, 312 312 struct netlink_ext_ack *extack) 313 313 { 314 314 struct wg_device *wg = netdev_priv(dev); 315 + struct net *src_net = params->net; 315 316 int ret = -ENOMEM; 316 317 317 318 rcu_assign_pointer(wg->creating_net, src_net);
+4 -2
drivers/net/wireless/virtual/virt_wifi.c
··· 519 519 } 520 520 521 521 /* Called with rtnl lock held. */ 522 - static int virt_wifi_newlink(struct net *src_net, struct net_device *dev, 523 - struct nlattr *tb[], struct nlattr *data[], 522 + static int virt_wifi_newlink(struct net_device *dev, 523 + struct rtnl_newlink_params *params, 524 524 struct netlink_ext_ack *extack) 525 525 { 526 526 struct virt_wifi_netdev_priv *priv = netdev_priv(dev); 527 + struct net *src_net = params->net; 528 + struct nlattr **tb = params->tb; 527 529 int err; 528 530 529 531 if (!tb[IFLA_LINK])
+12 -4
drivers/net/wwan/wwan_core.c
··· 967 967 return dev; 968 968 } 969 969 970 - static int wwan_rtnl_newlink(struct net *src_net, struct net_device *dev, 971 - struct nlattr *tb[], struct nlattr *data[], 970 + static int wwan_rtnl_newlink(struct net_device *dev, 971 + struct rtnl_newlink_params *params, 972 972 struct netlink_ext_ack *extack) 973 973 { 974 974 struct wwan_device *wwandev = wwan_dev_get_by_parent(dev->dev.parent); 975 - u32 link_id = nla_get_u32(data[IFLA_WWAN_LINK_ID]); 976 975 struct wwan_netdev_priv *priv = netdev_priv(dev); 976 + struct nlattr **data = params->data; 977 + u32 link_id; 977 978 int ret; 979 + 980 + link_id = nla_get_u32(data[IFLA_WWAN_LINK_ID]); 978 981 979 982 if (IS_ERR(wwandev)) 980 983 return PTR_ERR(wwandev); ··· 1064 1061 { 1065 1062 struct nlattr *tb[IFLA_MAX + 1], *linkinfo[IFLA_INFO_MAX + 1]; 1066 1063 struct nlattr *data[IFLA_WWAN_MAX + 1]; 1064 + struct rtnl_newlink_params params = { 1065 + .net = &init_net, 1066 + .tb = tb, 1067 + .data = data, 1068 + }; 1067 1069 struct net_device *dev; 1068 1070 struct nlmsghdr *nlh; 1069 1071 struct sk_buff *msg; ··· 1113 1105 if (WARN_ON(IS_ERR(dev))) 1114 1106 goto unlock; 1115 1107 1116 - if (WARN_ON(wwan_rtnl_newlink(&init_net, dev, tb, data, NULL))) { 1108 + if (WARN_ON(wwan_rtnl_newlink(dev, &params, NULL))) { 1117 1109 free_netdev(dev); 1118 1110 goto unlock; 1119 1111 }
+4 -2
include/linux/if_macvlan.h
··· 59 59 60 60 extern void macvlan_common_setup(struct net_device *dev); 61 61 62 - extern int macvlan_common_newlink(struct net *src_net, struct net_device *dev, 63 - struct nlattr *tb[], struct nlattr *data[], 62 + struct rtnl_newlink_params; 63 + 64 + extern int macvlan_common_newlink(struct net_device *dev, 65 + struct rtnl_newlink_params *params, 64 66 struct netlink_ext_ack *extack); 65 67 66 68 extern void macvlan_dellink(struct net_device *dev, struct list_head *head);
+21 -4
include/net/rtnetlink.h
··· 70 70 } 71 71 72 72 /** 73 + * struct rtnl_newlink_params - parameters of rtnl_link_ops::newlink() 74 + * 75 + * @net: Netns of interest 76 + * @src_net: Source netns of rtnetlink socket 77 + * @link_net: Link netns by IFLA_LINK_NETNSID, NULL if not specified 78 + * @peer_net: Peer netns 79 + * @tb: IFLA_* attributes 80 + * @data: IFLA_INFO_DATA attributes 81 + */ 82 + struct rtnl_newlink_params { 83 + struct net *net; 84 + struct net *src_net; 85 + struct net *link_net; 86 + struct net *peer_net; 87 + struct nlattr **tb; 88 + struct nlattr **data; 89 + }; 90 + 91 + /** 73 92 * struct rtnl_link_ops - rtnetlink link operations 74 93 * 75 94 * @list: Used internally, protected by link_ops_mutex and SRCU ··· 144 125 struct nlattr *data[], 145 126 struct netlink_ext_ack *extack); 146 127 147 - int (*newlink)(struct net *src_net, 148 - struct net_device *dev, 149 - struct nlattr *tb[], 150 - struct nlattr *data[], 128 + int (*newlink)(struct net_device *dev, 129 + struct rtnl_newlink_params *params, 151 130 struct netlink_ext_ack *extack); 152 131 int (*changelink)(struct net_device *dev, 153 132 struct nlattr *tb[],
+5 -2
net/8021q/vlan_netlink.c
··· 135 135 return 0; 136 136 } 137 137 138 - static int vlan_newlink(struct net *src_net, struct net_device *dev, 139 - struct nlattr *tb[], struct nlattr *data[], 138 + static int vlan_newlink(struct net_device *dev, 139 + struct rtnl_newlink_params *params, 140 140 struct netlink_ext_ack *extack) 141 141 { 142 142 struct vlan_dev_priv *vlan = vlan_dev_priv(dev); 143 + struct nlattr **data = params->data; 144 + struct net *src_net = params->net; 145 + struct nlattr **tb = params->tb; 143 146 struct net_device *real_dev; 144 147 unsigned int max_mtu; 145 148 __be16 proto;
+4 -5
net/batman-adv/soft-interface.c
··· 1077 1077 1078 1078 /** 1079 1079 * batadv_softif_newlink() - pre-initialize and register new batadv link 1080 - * @src_net: the applicable net namespace 1081 1080 * @dev: network device to register 1082 - * @tb: IFLA_INFO_DATA netlink attributes 1083 - * @data: enum batadv_ifla_attrs attributes 1081 + * @params: rtnl newlink parameters 1084 1082 * @extack: extended ACK report struct 1085 1083 * 1086 1084 * Return: 0 if successful or error otherwise. 1087 1085 */ 1088 - static int batadv_softif_newlink(struct net *src_net, struct net_device *dev, 1089 - struct nlattr *tb[], struct nlattr *data[], 1086 + static int batadv_softif_newlink(struct net_device *dev, 1087 + struct rtnl_newlink_params *params, 1090 1088 struct netlink_ext_ack *extack) 1091 1089 { 1092 1090 struct batadv_priv *bat_priv = netdev_priv(dev); 1091 + struct nlattr **data = params->data; 1093 1092 const char *algo_name; 1094 1093 int err; 1095 1094
+4 -2
net/bridge/br_netlink.c
··· 1553 1553 return 0; 1554 1554 } 1555 1555 1556 - static int br_dev_newlink(struct net *src_net, struct net_device *dev, 1557 - struct nlattr *tb[], struct nlattr *data[], 1556 + static int br_dev_newlink(struct net_device *dev, 1557 + struct rtnl_newlink_params *params, 1558 1558 struct netlink_ext_ack *extack) 1559 1559 { 1560 1560 struct net_bridge *br = netdev_priv(dev); 1561 + struct nlattr **data = params->data; 1562 + struct nlattr **tb = params->tb; 1561 1563 int err; 1562 1564 1563 1565 err = register_netdevice(dev);
+3 -2
net/caif/chnl_net.c
··· 438 438 } 439 439 } 440 440 441 - static int ipcaif_newlink(struct net *src_net, struct net_device *dev, 442 - struct nlattr *tb[], struct nlattr *data[], 441 + static int ipcaif_newlink(struct net_device *dev, 442 + struct rtnl_newlink_params *params, 443 443 struct netlink_ext_ack *extack) 444 444 { 445 + struct nlattr **data = params->data; 445 446 int ret; 446 447 struct chnl_net *caifdev; 447 448 ASSERT_RTNL();
+11 -4
net/core/rtnetlink.c
··· 3767 3767 struct netlink_ext_ack *extack) 3768 3768 { 3769 3769 unsigned char name_assign_type = NET_NAME_USER; 3770 - struct net *net = sock_net(skb->sk); 3770 + struct rtnl_newlink_params params = { 3771 + .src_net = sock_net(skb->sk), 3772 + .link_net = link_net, 3773 + .peer_net = peer_net, 3774 + .tb = tb, 3775 + .data = data, 3776 + }; 3771 3777 u32 portid = NETLINK_CB(skb).portid; 3772 3778 struct net_device *dev; 3773 3779 char ifname[IFNAMSIZ]; ··· 3798 3792 3799 3793 dev->ifindex = ifm->ifi_index; 3800 3794 3795 + params.net = params.src_net; 3801 3796 if (link_net) 3802 - net = link_net; 3797 + params.net = link_net; 3803 3798 if (peer_net) 3804 - net = peer_net; 3799 + params.net = peer_net; 3805 3800 3806 3801 if (ops->newlink) 3807 - err = ops->newlink(net, dev, tb, data, extack); 3802 + err = ops->newlink(dev, &params, extack); 3808 3803 else 3809 3804 err = register_netdevice(dev); 3810 3805 if (err < 0) {
+4 -2
net/hsr/hsr_netlink.c
··· 29 29 /* Here, it seems a netdevice has already been allocated for us, and the 30 30 * hsr_dev_setup routine has been executed. Nice! 31 31 */ 32 - static int hsr_newlink(struct net *src_net, struct net_device *dev, 33 - struct nlattr *tb[], struct nlattr *data[], 32 + static int hsr_newlink(struct net_device *dev, 33 + struct rtnl_newlink_params *params, 34 34 struct netlink_ext_ack *extack) 35 35 { 36 + struct nlattr **data = params->data; 37 + struct net *src_net = params->net; 36 38 enum hsr_version proto_version; 37 39 unsigned char multicast_spec; 38 40 u8 proto = HSR_PROTOCOL_HSR;
+3 -2
net/ieee802154/6lowpan/core.c
··· 129 129 return 0; 130 130 } 131 131 132 - static int lowpan_newlink(struct net *src_net, struct net_device *ldev, 133 - struct nlattr *tb[], struct nlattr *data[], 132 + static int lowpan_newlink(struct net_device *ldev, 133 + struct rtnl_newlink_params *params, 134 134 struct netlink_ext_ack *extack) 135 135 { 136 + struct nlattr **tb = params->tb; 136 137 struct net_device *wdev; 137 138 int ret; 138 139
+11 -5
net/ipv4/ip_gre.c
··· 1396 1396 return 0; 1397 1397 } 1398 1398 1399 - static int ipgre_newlink(struct net *src_net, struct net_device *dev, 1400 - struct nlattr *tb[], struct nlattr *data[], 1399 + static int ipgre_newlink(struct net_device *dev, 1400 + struct rtnl_newlink_params *params, 1401 1401 struct netlink_ext_ack *extack) 1402 1402 { 1403 + struct nlattr **data = params->data; 1404 + struct nlattr **tb = params->tb; 1403 1405 struct ip_tunnel_parm_kern p; 1404 1406 __u32 fwmark = 0; 1405 1407 int err; ··· 1416 1414 return ip_tunnel_newlink(dev, tb, &p, fwmark); 1417 1415 } 1418 1416 1419 - static int erspan_newlink(struct net *src_net, struct net_device *dev, 1420 - struct nlattr *tb[], struct nlattr *data[], 1417 + static int erspan_newlink(struct net_device *dev, 1418 + struct rtnl_newlink_params *params, 1421 1419 struct netlink_ext_ack *extack) 1422 1420 { 1421 + struct nlattr **data = params->data; 1422 + struct nlattr **tb = params->tb; 1423 1423 struct ip_tunnel_parm_kern p; 1424 1424 __u32 fwmark = 0; 1425 1425 int err; ··· 1701 1697 struct net_device *gretap_fb_dev_create(struct net *net, const char *name, 1702 1698 u8 name_assign_type) 1703 1699 { 1700 + struct rtnl_newlink_params params = { .net = net }; 1704 1701 struct nlattr *tb[IFLA_MAX + 1]; 1705 1702 struct net_device *dev; 1706 1703 LIST_HEAD(list_kill); ··· 1709 1704 int err; 1710 1705 1711 1706 memset(&tb, 0, sizeof(tb)); 1707 + params.tb = tb; 1712 1708 1713 1709 dev = rtnl_create_link(net, name, name_assign_type, 1714 1710 &ipgre_tap_ops, tb, NULL); ··· 1720 1714 t = netdev_priv(dev); 1721 1715 t->collect_md = true; 1722 1716 1723 - err = ipgre_newlink(net, dev, tb, NULL, NULL); 1717 + err = ipgre_newlink(dev, &params, NULL); 1724 1718 if (err < 0) { 1725 1719 free_netdev(dev); 1726 1720 return ERR_PTR(err);
+4 -2
net/ipv4/ip_vti.c
··· 575 575 *fwmark = nla_get_u32(data[IFLA_VTI_FWMARK]); 576 576 } 577 577 578 - static int vti_newlink(struct net *src_net, struct net_device *dev, 579 - struct nlattr *tb[], struct nlattr *data[], 578 + static int vti_newlink(struct net_device *dev, 579 + struct rtnl_newlink_params *params, 580 580 struct netlink_ext_ack *extack) 581 581 { 582 + struct nlattr **data = params->data; 582 583 struct ip_tunnel_parm_kern parms; 584 + struct nlattr **tb = params->tb; 583 585 __u32 fwmark = 0; 584 586 585 587 vti_netlink_parms(data, &parms, &fwmark);
+4 -2
net/ipv4/ipip.c
··· 436 436 *fwmark = nla_get_u32(data[IFLA_IPTUN_FWMARK]); 437 437 } 438 438 439 - static int ipip_newlink(struct net *src_net, struct net_device *dev, 440 - struct nlattr *tb[], struct nlattr *data[], 439 + static int ipip_newlink(struct net_device *dev, 440 + struct rtnl_newlink_params *params, 441 441 struct netlink_ext_ack *extack) 442 442 { 443 443 struct ip_tunnel *t = netdev_priv(dev); 444 + struct nlattr **data = params->data; 445 + struct nlattr **tb = params->tb; 444 446 struct ip_tunnel_encap ipencap; 445 447 struct ip_tunnel_parm_kern p; 446 448 __u32 fwmark = 0;
+10 -4
net/ipv6/ip6_gre.c
··· 2005 2005 return err; 2006 2006 } 2007 2007 2008 - static int ip6gre_newlink(struct net *src_net, struct net_device *dev, 2009 - struct nlattr *tb[], struct nlattr *data[], 2008 + static int ip6gre_newlink(struct net_device *dev, 2009 + struct rtnl_newlink_params *params, 2010 2010 struct netlink_ext_ack *extack) 2011 2011 { 2012 2012 struct ip6_tnl *nt = netdev_priv(dev); 2013 + struct nlattr **data = params->data; 2014 + struct net *src_net = params->net; 2015 + struct nlattr **tb = params->tb; 2013 2016 struct net *net = dev_net(dev); 2014 2017 struct ip6gre_net *ign; 2015 2018 int err; ··· 2244 2241 netif_keep_dst(dev); 2245 2242 } 2246 2243 2247 - static int ip6erspan_newlink(struct net *src_net, struct net_device *dev, 2248 - struct nlattr *tb[], struct nlattr *data[], 2244 + static int ip6erspan_newlink(struct net_device *dev, 2245 + struct rtnl_newlink_params *params, 2249 2246 struct netlink_ext_ack *extack) 2250 2247 { 2251 2248 struct ip6_tnl *nt = netdev_priv(dev); 2249 + struct nlattr **data = params->data; 2250 + struct net *src_net = params->net; 2251 + struct nlattr **tb = params->tb; 2252 2252 struct net *net = dev_net(dev); 2253 2253 struct ip6gre_net *ign; 2254 2254 int err;
+4 -2
net/ipv6/ip6_tunnel.c
··· 2002 2002 parms->fwmark = nla_get_u32(data[IFLA_IPTUN_FWMARK]); 2003 2003 } 2004 2004 2005 - static int ip6_tnl_newlink(struct net *src_net, struct net_device *dev, 2006 - struct nlattr *tb[], struct nlattr *data[], 2005 + static int ip6_tnl_newlink(struct net_device *dev, 2006 + struct rtnl_newlink_params *params, 2007 2007 struct netlink_ext_ack *extack) 2008 2008 { 2009 + struct nlattr **data = params->data; 2010 + struct nlattr **tb = params->tb; 2009 2011 struct net *net = dev_net(dev); 2010 2012 struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id); 2011 2013 struct ip_tunnel_encap ipencap;
+3 -2
net/ipv6/ip6_vti.c
··· 997 997 parms->fwmark = nla_get_u32(data[IFLA_VTI_FWMARK]); 998 998 } 999 999 1000 - static int vti6_newlink(struct net *src_net, struct net_device *dev, 1001 - struct nlattr *tb[], struct nlattr *data[], 1000 + static int vti6_newlink(struct net_device *dev, 1001 + struct rtnl_newlink_params *params, 1002 1002 struct netlink_ext_ack *extack) 1003 1003 { 1004 + struct nlattr **data = params->data; 1004 1005 struct net *net = dev_net(dev); 1005 1006 struct ip6_tnl *nt; 1006 1007
+4 -2
net/ipv6/sit.c
··· 1550 1550 } 1551 1551 #endif 1552 1552 1553 - static int ipip6_newlink(struct net *src_net, struct net_device *dev, 1554 - struct nlattr *tb[], struct nlattr *data[], 1553 + static int ipip6_newlink(struct net_device *dev, 1554 + struct rtnl_newlink_params *params, 1555 1555 struct netlink_ext_ack *extack) 1556 1556 { 1557 + struct nlattr **data = params->data; 1558 + struct nlattr **tb = params->tb; 1557 1559 struct net *net = dev_net(dev); 1558 1560 struct ip_tunnel *nt; 1559 1561 struct ip_tunnel_encap ipencap;
+4 -3
net/xfrm/xfrm_interface_core.c
··· 814 814 parms->collect_md = true; 815 815 } 816 816 817 - static int xfrmi_newlink(struct net *src_net, struct net_device *dev, 818 - struct nlattr *tb[], struct nlattr *data[], 819 - struct netlink_ext_ack *extack) 817 + static int xfrmi_newlink(struct net_device *dev, 818 + struct rtnl_newlink_params *params, 819 + struct netlink_ext_ack *extack) 820 820 { 821 + struct nlattr **data = params->data; 821 822 struct net *net = dev_net(dev); 822 823 struct xfrm_if_parms p = {}; 823 824 struct xfrm_if *xi;