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

Configure Feed

Select the types of activity you want to include in your feed.

Merge branch 'net-improve-netns-handling-in-rtnetlink'

Xiao Liang says:

====================
net: Improve netns handling in rtnetlink

This patch series includes some netns-related improvements and fixes for
rtnetlink, to make link creation more intuitive:

1) Creating link in another net namespace doesn't conflict with link
names in current one.
2) Refector rtnetlink link creation. Create link in target namespace
directly.

So that

# ip link add netns ns1 link-netns ns2 tun0 type gre ...

will create tun0 in ns1, rather than create it in ns2 and move to ns1.
And don't conflict with another interface named "tun0" in current netns.

Patch 01 avoids link name conflict in different netns.

To achieve 2), there're mainly 3 steps:

- Patch 02 packs newlink() parameters into a struct, including
the original "src_net" along with more netns context. No semantic
changes are introduced.
- Patch 03 ~ 09 converts device drivers to use the explicit netns
extracted from params.
- Patch 10 ~ 11 removes the old netns parameter, and converts
rtnetlink to create device in target netns directly.

Patch 12 ~ 13 adds some tests for link name and link netns.

---

Please note there're some issues found in current code:

- In amt_newlink() drivers/net/amt.c:

amt->net = net;
...
amt->stream_dev = dev_get_by_index(net, ...

Uses net, but amt_lookup_upper_dev() only searches in dev_net.
So the AMT device may not be properly deleted if it's in a different
netns from lower dev.

- In lowpan_newlink() in net/ieee802154/6lowpan/core.c:

wdev = dev_get_by_index(dev_net(ldev), nla_get_u32(tb[IFLA_LINK]));

Looks for IFLA_LINK in dev_net, but in theory the ifindex is defined
in link netns.

And thanks to Kuniyuki for fixing related issues in gtp and pfcp:
https://lore.kernel.org/netdev/20250110014754.33847-1-kuniyu@amazon.com/

v9: https://lore.kernel.org/20250210133002.883422-1-shaw.leon@gmail.com
v8: https://lore.kernel.org/20250113143719.7948-1-shaw.leon@gmail.com
v7: https://lore.kernel.org/20250104125732.17335-1-shaw.leon@gmail.com
v6: https://lore.kernel.org/20241218130909.2173-1-shaw.leon@gmail.com
v5: https://lore.kernel.org/20241209140151.231257-1-shaw.leon@gmail.com
v4: https://lore.kernel.org/20241118143244.1773-1-shaw.leon@gmail.com
v3: https://lore.kernel.org/20241113125715.150201-1-shaw.leon@gmail.com
v2: https://lore.kernel.org/20241107133004.7469-1-shaw.leon@gmail.com
v1: https://lore.kernel.org/20241023023146.372653-1-shaw.leon@gmail.com
====================

Link: https://patch.msgid.link/20250219125039.18024-1-shaw.leon@gmail.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

Jakub Kicinski 376cd9a2 4fe67dd2

+486 -181
+6 -3
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 net *link_net = rtnl_newlink_link_net(params); 105 + struct nlattr **data = params->data; 106 + struct nlattr **tb = params->tb; 104 107 struct net_device *pdev; 105 108 struct ipoib_dev_priv *ppriv; 106 109 u16 child_pkey; ··· 112 109 if (!tb[IFLA_LINK]) 113 110 return -EINVAL; 114 111 115 - pdev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK])); 112 + pdev = __dev_get_by_index(link_net, nla_get_u32(tb[IFLA_LINK])); 116 113 if (!pdev || pdev->type != ARPHRD_INFINIBAND) 117 114 return -ENODEV; 118 115
+7 -4
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 + struct net *link_net = rtnl_newlink_link_net(params); 3168 3169 struct amt_dev *amt = netdev_priv(dev); 3170 + struct nlattr **data = params->data; 3171 + struct nlattr **tb = params->tb; 3169 3172 int err = -EINVAL; 3170 3173 3171 - amt->net = net; 3174 + amt->net = link_net; 3172 3175 amt->mode = nla_get_u32(data[IFLA_AMT_MODE]); 3173 3176 3174 3177 if (data[IFLA_AMT_MAX_TUNNELS] && ··· 3186 3183 amt->hash_buckets = AMT_HSIZE; 3187 3184 amt->nr_tunnels = 0; 3188 3185 get_random_bytes(&amt->hash_seed, sizeof(amt->hash_seed)); 3189 - amt->stream_dev = dev_get_by_index(net, 3186 + amt->stream_dev = dev_get_by_index(link_net, 3190 3187 nla_get_u32(data[IFLA_AMT_LINK])); 3191 3188 if (!amt->stream_dev) { 3192 3189 NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_AMT_LINK],
+6 -3
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 net *link_net = rtnl_newlink_link_net(params); 706 + struct nlattr **data = params->data; 707 + struct nlattr **tb = params->tb; 705 708 struct bareudp_conf conf; 706 709 int err; 707 710 ··· 712 709 if (err) 713 710 return err; 714 711 715 - err = bareudp_configure(net, dev, &conf, extack); 712 + err = bareudp_configure(link_net, dev, &conf, extack); 716 713 if (err) 717 714 return err; 718 715
+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 net *peer_net = rtnl_newlink_peer_net(params); 180 + struct nlattr **data = params->data; 181 + struct nlattr **tb = params->tb; 179 182 struct vxcan_priv *priv; 180 183 struct net_device *peer; 181 184
+6 -3
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 + struct net *link_net = rtnl_newlink_link_net(params); 124 125 u32 data_format = RMNET_FLAGS_INGRESS_DEAGGREGATION; 126 + struct nlattr **data = params->data; 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; ··· 137 134 return -EINVAL; 138 135 } 139 136 140 - real_dev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK])); 137 + real_dev = __dev_get_by_index(link_net, nla_get_u32(tb[IFLA_LINK])); 141 138 if (!real_dev) { 142 139 NL_SET_ERR_MSG_MOD(extack, "link does not exist"); 143 140 return -ENODEV;
+6 -3
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 net *link_net = rtnl_newlink_link_net(params); 1622 + struct nlattr **data = params->data; 1623 + struct nlattr **tb = params->tb; 1621 1624 struct geneve_config cfg = { 1622 1625 .df = GENEVE_DF_UNSET, 1623 1626 .use_udp6_rx_checksums = false, ··· 1634 1631 if (err) 1635 1632 return err; 1636 1633 1637 - err = geneve_configure(net, dev, extack, &cfg); 1634 + err = geneve_configure(link_net, dev, extack, &cfg); 1638 1635 if (err) 1639 1636 return err; 1640 1637
+6 -4
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 net *link_net = rtnl_newlink_link_net(params); 1470 + struct nlattr **data = params->data; 1469 1471 unsigned int role = GTP_ROLE_GGSN; 1470 1472 struct gtp_dev *gtp; 1471 1473 struct gtp_net *gn; ··· 1498 1496 gtp->restart_count = nla_get_u8_default(data[IFLA_GTP_RESTART_COUNT], 1499 1497 0); 1500 1498 1501 - gtp->net = src_net; 1499 + gtp->net = link_net; 1502 1500 1503 1501 err = gtp_hashtable_new(gtp, hashsize); 1504 1502 if (err < 0) ··· 1528 1526 goto out_encap; 1529 1527 } 1530 1528 1531 - gn = net_generic(src_net, gtp_net_id); 1529 + gn = net_generic(link_net, gtp_net_id); 1532 1530 list_add(&gtp->list, &gn->gtp_dev_list); 1533 1531 dev->priv_destructor = gtp_destructor; 1534 1532
+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);
+5 -3
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 { 538 + struct net *link_net = rtnl_newlink_link_net(params); 539 539 struct ipvl_dev *ipvlan = netdev_priv(dev); 540 + struct nlattr **data = params->data; 541 + struct nlattr **tb = params->tb; 540 542 struct ipvl_port *port; 541 543 struct net_device *phy_dev; 542 544 int err; ··· 547 545 if (!tb[IFLA_LINK]) 548 546 return -EINVAL; 549 547 550 - phy_dev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK])); 548 + phy_dev = __dev_get_by_index(link_net, nla_get_u32(tb[IFLA_LINK])); 551 549 if (!phy_dev) 552 550 return -ENODEV; 553 551
+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;
+6 -3
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 + struct net *link_net = rtnl_newlink_link_net(params); 4148 4149 struct macsec_dev *macsec = macsec_priv(dev); 4150 + struct nlattr **data = params->data; 4151 + struct nlattr **tb = params->tb; 4149 4152 rx_handler_func_t *rx_handler; 4150 4153 u8 icv_len = MACSEC_DEFAULT_ICV_LEN; 4151 4154 struct net_device *real_dev; ··· 4157 4154 4158 4155 if (!tb[IFLA_LINK]) 4159 4156 return -EINVAL; 4160 - real_dev = __dev_get_by_index(net, nla_get_u32(tb[IFLA_LINK])); 4157 + real_dev = __dev_get_by_index(link_net, nla_get_u32(tb[IFLA_LINK])); 4161 4158 if (!real_dev) 4162 4159 return -ENODEV; 4163 4160 if (real_dev->type != ARPHRD_ETHER)
+12 -9
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 + struct net *link_net = rtnl_newlink_link_net(params); 1447 1448 struct macvlan_dev *vlan = netdev_priv(dev); 1448 - struct macvlan_port *port; 1449 + struct nlattr **data = params->data; 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; 1456 1459 1457 - lowerdev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK])); 1460 + lowerdev = __dev_get_by_index(link_net, nla_get_u32(tb[IFLA_LINK])); 1458 1461 if (lowerdev == NULL) 1459 1462 return -ENODEV; 1460 1463 ··· 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; 334 + struct net *peer_net = rtnl_newlink_peer_net(params); 337 335 enum netkit_scrub scrub_prim = NETKIT_SCRUB_DEFAULT; 338 336 enum netkit_scrub scrub_peer = NETKIT_SCRUB_DEFAULT; 337 + struct nlattr *peer_tb[IFLA_MAX + 1], **tbp, *attr; 338 + enum netkit_action policy_prim = NETKIT_PASS; 339 + enum netkit_action policy_peer = NETKIT_PASS; 340 + struct nlattr **data = params->data; 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]);
+5 -4
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 + struct net *link_net = rtnl_newlink_link_net(params); 191 192 struct pfcp_dev *pfcp = netdev_priv(dev); 192 193 struct pfcp_net *pn; 193 194 int err; 194 195 195 - pfcp->net = net; 196 + pfcp->net = link_net; 196 197 197 198 err = pfcp_add_sock(pfcp); 198 199 if (err) { ··· 207 206 goto exit_del_pfcp_sock; 208 207 } 209 208 210 - pn = net_generic(net, pfcp_net_id); 209 + pn = net_generic(link_net, pfcp_net_id); 211 210 list_add(&pfcp->list, &pn->pfcp_dev_list); 212 211 213 212 netdev_dbg(dev, "registered new PFCP interface\n");
+6 -3
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 net *link_net = rtnl_newlink_link_net(params); 1311 + struct nlattr **data = params->data; 1312 + struct nlattr **tb = params->tb; 1310 1313 struct ppp_config conf = { 1311 1314 .unit = -1, 1312 1315 .ifname_is_set = true, ··· 1346 1343 if (!tb[IFLA_IFNAME] || !nla_len(tb[IFLA_IFNAME]) || !*(char *)nla_data(tb[IFLA_IFNAME])) 1347 1344 conf.ifname_is_set = false; 1348 1345 1349 - err = ppp_dev_configure(src_net, dev, &conf); 1346 + err = ppp_dev_configure(link_net, dev, &conf); 1350 1347 1351 1348 out_unlock: 1352 1349 mutex_unlock(&ppp_mutex);
+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 net *peer_net = rtnl_newlink_peer_net(params); 1773 + struct nlattr **data = params->data; 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;
+6 -3
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 net *link_net = rtnl_newlink_link_net(params); 4408 + struct nlattr **data = params->data; 4409 + struct nlattr **tb = params->tb; 4407 4410 struct vxlan_config conf; 4408 4411 int err; 4409 4412 ··· 4414 4411 if (err) 4415 4412 return err; 4416 4413 4417 - return __vxlan_dev_create(src_net, dev, &conf, extack); 4414 + return __vxlan_dev_create(link_net, dev, &conf, extack); 4418 4415 } 4419 4416 4420 4417 static int vxlan_changelink(struct net_device *dev, struct nlattr *tb[],
+4 -3
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 + struct net *link_net = rtnl_newlink_link_net(params); 314 315 struct wg_device *wg = netdev_priv(dev); 315 316 int ret = -ENOMEM; 316 317 317 - rcu_assign_pointer(wg->creating_net, src_net); 318 + rcu_assign_pointer(wg->creating_net, link_net); 318 319 init_rwsem(&wg->static_identity.lock); 319 320 mutex_init(&wg->socket_update_lock); 320 321 mutex_init(&wg->device_update_lock);
+5 -3
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 *link_net = rtnl_newlink_link_net(params); 528 + struct nlattr **tb = params->tb; 527 529 int err; 528 530 529 531 if (!tb[IFLA_LINK]) ··· 534 532 netif_carrier_off(dev); 535 533 536 534 priv->upperdev = dev; 537 - priv->lowerdev = __dev_get_by_index(src_net, 535 + priv->lowerdev = __dev_get_by_index(link_net, 538 536 nla_get_u32(tb[IFLA_LINK])); 539 537 540 538 if (!priv->lowerdev)
+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 + .src_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);
+3 -2
include/net/ip_tunnels.h
··· 407 407 bool log_ecn_error); 408 408 int ip_tunnel_changelink(struct net_device *dev, struct nlattr *tb[], 409 409 struct ip_tunnel_parm_kern *p, __u32 fwmark); 410 - int ip_tunnel_newlink(struct net_device *dev, struct nlattr *tb[], 411 - struct ip_tunnel_parm_kern *p, __u32 fwmark); 410 + int ip_tunnel_newlink(struct net *net, struct net_device *dev, 411 + struct nlattr *tb[], struct ip_tunnel_parm_kern *p, 412 + __u32 fwmark); 412 413 void ip_tunnel_setup(struct net_device *dev, unsigned int net_id); 413 414 414 415 bool ip_tunnel_netlink_encap_parms(struct nlattr *data[],
+36 -4
include/net/rtnetlink.h
··· 70 70 } 71 71 72 72 /** 73 + * struct rtnl_newlink_params - parameters of rtnl_link_ops::newlink() 74 + * 75 + * @src_net: Source netns of rtnetlink socket 76 + * @link_net: Link netns by IFLA_LINK_NETNSID, NULL if not specified 77 + * @peer_net: Peer netns 78 + * @tb: IFLA_* attributes 79 + * @data: IFLA_INFO_DATA attributes 80 + */ 81 + struct rtnl_newlink_params { 82 + struct net *src_net; 83 + struct net *link_net; 84 + struct net *peer_net; 85 + struct nlattr **tb; 86 + struct nlattr **data; 87 + }; 88 + 89 + /* Get effective link netns from newlink params. Generally, this is link_net 90 + * and falls back to src_net. But for compatibility, a driver may * choose to 91 + * use dev_net(dev) instead. 92 + */ 93 + static inline struct net *rtnl_newlink_link_net(struct rtnl_newlink_params *p) 94 + { 95 + return p->link_net ? : p->src_net; 96 + } 97 + 98 + /* Get peer netns from newlink params. Fallback to link netns if peer netns is 99 + * not specified explicitly. 100 + */ 101 + static inline struct net *rtnl_newlink_peer_net(struct rtnl_newlink_params *p) 102 + { 103 + return p->peer_net ? : rtnl_newlink_link_net(p); 104 + } 105 + 106 + /** 73 107 * struct rtnl_link_ops - rtnetlink link operations 74 108 * 75 109 * @list: Used internally, protected by link_ops_mutex and SRCU ··· 159 125 struct nlattr *data[], 160 126 struct netlink_ext_ack *extack); 161 127 162 - int (*newlink)(struct net *src_net, 163 - struct net_device *dev, 164 - struct nlattr *tb[], 165 - struct nlattr *data[], 128 + int (*newlink)(struct net_device *dev, 129 + struct rtnl_newlink_params *params, 166 130 struct netlink_ext_ack *extack); 167 131 int (*changelink)(struct net_device *dev, 168 132 struct nlattr *tb[],
+6 -3
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 + struct net *link_net = rtnl_newlink_link_net(params); 142 143 struct vlan_dev_priv *vlan = vlan_dev_priv(dev); 144 + struct nlattr **data = params->data; 145 + struct nlattr **tb = params->tb; 143 146 struct net_device *real_dev; 144 147 unsigned int max_mtu; 145 148 __be16 proto; ··· 158 155 return -EINVAL; 159 156 } 160 157 161 - real_dev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK])); 158 + real_dev = __dev_get_by_index(link_net, nla_get_u32(tb[IFLA_LINK])); 162 159 if (!real_dev) { 163 160 NL_SET_ERR_MSG_MOD(extack, "link does not exist"); 164 161 return -ENODEV;
+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();
+18 -16
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]; ··· 3789 3783 name_assign_type = NET_NAME_ENUM; 3790 3784 } 3791 3785 3792 - dev = rtnl_create_link(link_net ? : tgt_net, ifname, 3793 - name_assign_type, ops, tb, extack); 3786 + dev = rtnl_create_link(tgt_net, ifname, name_assign_type, ops, tb, 3787 + extack); 3794 3788 if (IS_ERR(dev)) { 3795 3789 err = PTR_ERR(dev); 3796 3790 goto out; ··· 3798 3792 3799 3793 dev->ifindex = ifm->ifi_index; 3800 3794 3801 - if (link_net) 3802 - net = link_net; 3803 - if (peer_net) 3804 - net = peer_net; 3805 - 3806 3795 if (ops->newlink) 3807 - err = ops->newlink(net, dev, tb, data, extack); 3796 + err = ops->newlink(dev, &params, extack); 3808 3797 else 3809 3798 err = register_netdevice(dev); 3810 3799 if (err < 0) { ··· 3810 3809 err = rtnl_configure_link(dev, ifm, portid, nlh); 3811 3810 if (err < 0) 3812 3811 goto out_unregister; 3813 - if (link_net) { 3814 - err = dev_change_net_namespace(dev, tgt_net, ifname); 3815 - if (err < 0) 3816 - goto out_unregister; 3817 - } 3818 3812 if (tb[IFLA_MASTER]) { 3819 3813 err = do_set_master(dev, nla_get_u32(tb[IFLA_MASTER]), extack); 3820 3814 if (err) ··· 3863 3867 { 3864 3868 struct nlattr ** const tb = tbs->tb; 3865 3869 struct net *net = sock_net(skb->sk); 3870 + struct net *device_net; 3866 3871 struct net_device *dev; 3867 3872 struct ifinfomsg *ifm; 3868 3873 bool link_specified; 3869 3874 3875 + /* When creating, lookup for existing device in target net namespace */ 3876 + device_net = (nlh->nlmsg_flags & NLM_F_CREATE) && 3877 + (nlh->nlmsg_flags & NLM_F_EXCL) ? 3878 + tgt_net : net; 3879 + 3870 3880 ifm = nlmsg_data(nlh); 3871 3881 if (ifm->ifi_index > 0) { 3872 3882 link_specified = true; 3873 - dev = __dev_get_by_index(net, ifm->ifi_index); 3883 + dev = __dev_get_by_index(device_net, ifm->ifi_index); 3874 3884 } else if (ifm->ifi_index < 0) { 3875 3885 NL_SET_ERR_MSG(extack, "ifindex can't be negative"); 3876 3886 return -EINVAL; 3877 3887 } else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME]) { 3878 3888 link_specified = true; 3879 - dev = rtnl_dev_get(net, tb); 3889 + dev = rtnl_dev_get(device_net, tb); 3880 3890 } else { 3881 3891 link_specified = false; 3882 3892 dev = NULL;
+7 -5
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 net *link_net = rtnl_newlink_link_net(params); 37 + struct nlattr **data = params->data; 36 38 enum hsr_version proto_version; 37 39 unsigned char multicast_spec; 38 40 u8 proto = HSR_PROTOCOL_HSR; ··· 48 46 NL_SET_ERR_MSG_MOD(extack, "Slave1 device not specified"); 49 47 return -EINVAL; 50 48 } 51 - link[0] = __dev_get_by_index(src_net, 49 + link[0] = __dev_get_by_index(link_net, 52 50 nla_get_u32(data[IFLA_HSR_SLAVE1])); 53 51 if (!link[0]) { 54 52 NL_SET_ERR_MSG_MOD(extack, "Slave1 does not exist"); ··· 58 56 NL_SET_ERR_MSG_MOD(extack, "Slave2 device not specified"); 59 57 return -EINVAL; 60 58 } 61 - link[1] = __dev_get_by_index(src_net, 59 + link[1] = __dev_get_by_index(link_net, 62 60 nla_get_u32(data[IFLA_HSR_SLAVE2])); 63 61 if (!link[1]) { 64 62 NL_SET_ERR_MSG_MOD(extack, "Slave2 does not exist"); ··· 71 69 } 72 70 73 71 if (data[IFLA_HSR_INTERLINK]) 74 - interlink = __dev_get_by_index(src_net, 72 + interlink = __dev_get_by_index(link_net, 75 73 nla_get_u32(data[IFLA_HSR_INTERLINK])); 76 74 77 75 if (interlink && interlink == link[0]) {
+5 -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 ··· 142 141 pr_debug("adding new link\n"); 143 142 144 143 if (!tb[IFLA_LINK]) 144 + return -EINVAL; 145 + if (params->link_net && !net_eq(params->link_net, dev_net(ldev))) 145 146 return -EINVAL; 146 147 /* find and hold wpan device */ 147 148 wdev = dev_get_by_index(dev_net(ldev), nla_get_u32(tb[IFLA_LINK]));
+15 -7
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; ··· 1413 1411 err = ipgre_netlink_parms(dev, data, tb, &p, &fwmark); 1414 1412 if (err < 0) 1415 1413 return err; 1416 - return ip_tunnel_newlink(dev, tb, &p, fwmark); 1414 + return ip_tunnel_newlink(params->link_net ? : dev_net(dev), dev, tb, &p, 1415 + fwmark); 1417 1416 } 1418 1417 1419 - static int erspan_newlink(struct net *src_net, struct net_device *dev, 1420 - struct nlattr *tb[], struct nlattr *data[], 1418 + static int erspan_newlink(struct net_device *dev, 1419 + struct rtnl_newlink_params *params, 1421 1420 struct netlink_ext_ack *extack) 1422 1421 { 1422 + struct nlattr **data = params->data; 1423 + struct nlattr **tb = params->tb; 1423 1424 struct ip_tunnel_parm_kern p; 1424 1425 __u32 fwmark = 0; 1425 1426 int err; ··· 1434 1429 err = erspan_netlink_parms(dev, data, tb, &p, &fwmark); 1435 1430 if (err) 1436 1431 return err; 1437 - return ip_tunnel_newlink(dev, tb, &p, fwmark); 1432 + return ip_tunnel_newlink(params->link_net ? : dev_net(dev), dev, tb, &p, 1433 + fwmark); 1438 1434 } 1439 1435 1440 1436 static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[], ··· 1703 1697 struct net_device *gretap_fb_dev_create(struct net *net, const char *name, 1704 1698 u8 name_assign_type) 1705 1699 { 1700 + struct rtnl_newlink_params params = { .src_net = net }; 1706 1701 struct nlattr *tb[IFLA_MAX + 1]; 1707 1702 struct net_device *dev; 1708 1703 LIST_HEAD(list_kill); ··· 1711 1704 int err; 1712 1705 1713 1706 memset(&tb, 0, sizeof(tb)); 1707 + params.tb = tb; 1714 1708 1715 1709 dev = rtnl_create_link(net, name, name_assign_type, 1716 1710 &ipgre_tap_ops, tb, NULL); ··· 1722 1714 t = netdev_priv(dev); 1723 1715 t->collect_md = true; 1724 1716 1725 - err = ipgre_newlink(net, dev, tb, NULL, NULL); 1717 + err = ipgre_newlink(dev, &params, NULL); 1726 1718 if (err < 0) { 1727 1719 free_netdev(dev); 1728 1720 return ERR_PTR(err);
+3 -4
net/ipv4/ip_tunnel.c
··· 1213 1213 } 1214 1214 EXPORT_SYMBOL_GPL(ip_tunnel_delete_nets); 1215 1215 1216 - int ip_tunnel_newlink(struct net_device *dev, struct nlattr *tb[], 1217 - struct ip_tunnel_parm_kern *p, __u32 fwmark) 1216 + int ip_tunnel_newlink(struct net *net, struct net_device *dev, 1217 + struct nlattr *tb[], struct ip_tunnel_parm_kern *p, 1218 + __u32 fwmark) 1218 1219 { 1219 1220 struct ip_tunnel *nt; 1220 - struct net *net = dev_net(dev); 1221 1221 struct ip_tunnel_net *itn; 1222 1222 int mtu; 1223 1223 int err; ··· 1326 1326 } 1327 1327 1328 1328 tunnel->dev = dev; 1329 - tunnel->net = dev_net(dev); 1330 1329 strscpy(tunnel->parms.name, dev->name); 1331 1330 iph->version = 4; 1332 1331 iph->ihl = 5;
+6 -3
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); 586 - return ip_tunnel_newlink(dev, tb, &parms, fwmark); 588 + return ip_tunnel_newlink(params->link_net ? : dev_net(dev), dev, tb, 589 + &parms, fwmark); 587 590 } 588 591 589 592 static int vti_changelink(struct net_device *dev, struct nlattr *tb[],
+6 -3
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; ··· 455 453 } 456 454 457 455 ipip_netlink_parms(data, &p, &t->collect_md, &fwmark); 458 - return ip_tunnel_newlink(dev, tb, &p, fwmark); 456 + return ip_tunnel_newlink(params->link_net ? : dev_net(dev), dev, tb, &p, 457 + fwmark); 459 458 } 460 459 461 460 static int ipip_changelink(struct net_device *dev, struct nlattr *tb[],
+14 -12
net/ipv6/ip6_gre.c
··· 1498 1498 tunnel = netdev_priv(dev); 1499 1499 1500 1500 tunnel->dev = dev; 1501 - tunnel->net = dev_net(dev); 1502 1501 strcpy(tunnel->parms.name, dev->name); 1503 1502 1504 1503 ret = dst_cache_init(&tunnel->dst_cache, GFP_KERNEL); ··· 1881 1882 tunnel = netdev_priv(dev); 1882 1883 1883 1884 tunnel->dev = dev; 1884 - tunnel->net = dev_net(dev); 1885 1885 strcpy(tunnel->parms.name, dev->name); 1886 1886 1887 1887 ret = dst_cache_init(&tunnel->dst_cache, GFP_KERNEL); ··· 1969 1971 return ret; 1970 1972 } 1971 1973 1972 - static int ip6gre_newlink_common(struct net *src_net, struct net_device *dev, 1974 + static int ip6gre_newlink_common(struct net *link_net, struct net_device *dev, 1973 1975 struct nlattr *tb[], struct nlattr *data[], 1974 1976 struct netlink_ext_ack *extack) 1975 1977 { ··· 1990 1992 eth_hw_addr_random(dev); 1991 1993 1992 1994 nt->dev = dev; 1993 - nt->net = dev_net(dev); 1995 + nt->net = link_net; 1994 1996 1995 1997 err = register_netdevice(dev); 1996 1998 if (err) ··· 2003 2005 return err; 2004 2006 } 2005 2007 2006 - static int ip6gre_newlink(struct net *src_net, struct net_device *dev, 2007 - struct nlattr *tb[], struct nlattr *data[], 2008 + static int ip6gre_newlink(struct net_device *dev, 2009 + struct rtnl_newlink_params *params, 2008 2010 struct netlink_ext_ack *extack) 2009 2011 { 2012 + struct net *net = params->link_net ? : dev_net(dev); 2010 2013 struct ip6_tnl *nt = netdev_priv(dev); 2011 - struct net *net = dev_net(dev); 2014 + struct nlattr **data = params->data; 2015 + struct nlattr **tb = params->tb; 2012 2016 struct ip6gre_net *ign; 2013 2017 int err; 2014 2018 ··· 2025 2025 return -EEXIST; 2026 2026 } 2027 2027 2028 - err = ip6gre_newlink_common(src_net, dev, tb, data, extack); 2028 + err = ip6gre_newlink_common(net, dev, tb, data, extack); 2029 2029 if (!err) { 2030 2030 ip6gre_tnl_link_config(nt, !tb[IFLA_MTU]); 2031 2031 ip6gre_tunnel_link_md(ign, nt); ··· 2241 2241 netif_keep_dst(dev); 2242 2242 } 2243 2243 2244 - static int ip6erspan_newlink(struct net *src_net, struct net_device *dev, 2245 - struct nlattr *tb[], struct nlattr *data[], 2244 + static int ip6erspan_newlink(struct net_device *dev, 2245 + struct rtnl_newlink_params *params, 2246 2246 struct netlink_ext_ack *extack) 2247 2247 { 2248 + struct net *net = params->link_net ? : dev_net(dev); 2248 2249 struct ip6_tnl *nt = netdev_priv(dev); 2249 - struct net *net = dev_net(dev); 2250 + struct nlattr **data = params->data; 2251 + struct nlattr **tb = params->tb; 2250 2252 struct ip6gre_net *ign; 2251 2253 int err; 2252 2254 ··· 2264 2262 return -EEXIST; 2265 2263 } 2266 2264 2267 - err = ip6gre_newlink_common(src_net, dev, tb, data, extack); 2265 + err = ip6gre_newlink_common(net, dev, tb, data, extack); 2268 2266 if (!err) { 2269 2267 ip6erspan_tnl_link_config(nt, !tb[IFLA_MTU]); 2270 2268 ip6erspan_tunnel_link_md(ign, nt);
+11 -7
net/ipv6/ip6_tunnel.c
··· 253 253 static int ip6_tnl_create2(struct net_device *dev) 254 254 { 255 255 struct ip6_tnl *t = netdev_priv(dev); 256 - struct net *net = dev_net(dev); 257 - struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id); 256 + struct ip6_tnl_net *ip6n = net_generic(t->net, ip6_tnl_net_id); 258 257 int err; 259 258 260 259 dev->rtnl_link_ops = &ip6_link_ops; ··· 1877 1878 int t_hlen; 1878 1879 1879 1880 t->dev = dev; 1880 - t->net = dev_net(dev); 1881 1881 1882 1882 ret = dst_cache_init(&t->dst_cache, GFP_KERNEL); 1883 1883 if (ret) ··· 1938 1940 struct net *net = dev_net(dev); 1939 1941 struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id); 1940 1942 1943 + t->net = net; 1941 1944 t->parms.proto = IPPROTO_IPV6; 1942 1945 1943 1946 rcu_assign_pointer(ip6n->tnls_wc[0], t); ··· 2001 2002 parms->fwmark = nla_get_u32(data[IFLA_IPTUN_FWMARK]); 2002 2003 } 2003 2004 2004 - static int ip6_tnl_newlink(struct net *src_net, struct net_device *dev, 2005 - struct nlattr *tb[], struct nlattr *data[], 2005 + static int ip6_tnl_newlink(struct net_device *dev, 2006 + struct rtnl_newlink_params *params, 2006 2007 struct netlink_ext_ack *extack) 2007 2008 { 2008 - struct net *net = dev_net(dev); 2009 - struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id); 2009 + struct nlattr **data = params->data; 2010 + struct nlattr **tb = params->tb; 2010 2011 struct ip_tunnel_encap ipencap; 2012 + struct ip6_tnl_net *ip6n; 2011 2013 struct ip6_tnl *nt, *t; 2014 + struct net *net; 2012 2015 int err; 2013 2016 2017 + net = params->link_net ? : dev_net(dev); 2018 + ip6n = net_generic(net, ip6_tnl_net_id); 2014 2019 nt = netdev_priv(dev); 2020 + nt->net = net; 2015 2021 2016 2022 if (ip_tunnel_netlink_encap_parms(data, &ipencap)) { 2017 2023 err = ip6_tnl_encap_setup(nt, &ipencap);
+8 -6
net/ipv6/ip6_vti.c
··· 177 177 static int vti6_tnl_create2(struct net_device *dev) 178 178 { 179 179 struct ip6_tnl *t = netdev_priv(dev); 180 - struct net *net = dev_net(dev); 181 - struct vti6_net *ip6n = net_generic(net, vti6_net_id); 180 + struct vti6_net *ip6n = net_generic(t->net, vti6_net_id); 182 181 int err; 183 182 184 183 dev->rtnl_link_ops = &vti6_link_ops; ··· 924 925 struct ip6_tnl *t = netdev_priv(dev); 925 926 926 927 t->dev = dev; 927 - t->net = dev_net(dev); 928 928 netdev_hold(dev, &t->dev_tracker, GFP_KERNEL); 929 929 netdev_lockdep_set_classes(dev); 930 930 return 0; ··· 956 958 struct net *net = dev_net(dev); 957 959 struct vti6_net *ip6n = net_generic(net, vti6_net_id); 958 960 961 + t->net = net; 959 962 t->parms.proto = IPPROTO_IPV6; 960 963 961 964 rcu_assign_pointer(ip6n->tnls_wc[0], t); ··· 996 997 parms->fwmark = nla_get_u32(data[IFLA_VTI_FWMARK]); 997 998 } 998 999 999 - static int vti6_newlink(struct net *src_net, struct net_device *dev, 1000 - struct nlattr *tb[], struct nlattr *data[], 1000 + static int vti6_newlink(struct net_device *dev, 1001 + struct rtnl_newlink_params *params, 1001 1002 struct netlink_ext_ack *extack) 1002 1003 { 1003 - struct net *net = dev_net(dev); 1004 + struct nlattr **data = params->data; 1004 1005 struct ip6_tnl *nt; 1006 + struct net *net; 1005 1007 1008 + net = params->link_net ? : dev_net(dev); 1006 1009 nt = netdev_priv(dev); 1007 1010 vti6_netlink_parms(data, &nt->parms); 1008 1011 1009 1012 nt->parms.proto = IPPROTO_IPV6; 1013 + nt->net = net; 1010 1014 1011 1015 if (vti6_locate(net, &nt->parms, 0)) 1012 1016 return -EEXIST;
+12 -8
net/ipv6/sit.c
··· 201 201 static int ipip6_tunnel_create(struct net_device *dev) 202 202 { 203 203 struct ip_tunnel *t = netdev_priv(dev); 204 - struct net *net = dev_net(dev); 205 - struct sit_net *sitn = net_generic(net, sit_net_id); 204 + struct sit_net *sitn = net_generic(t->net, sit_net_id); 206 205 int err; 207 206 208 207 __dev_addr_set(dev, &t->parms.iph.saddr, 4); ··· 268 269 269 270 nt = netdev_priv(dev); 270 271 272 + nt->net = net; 271 273 nt->parms = *parms; 272 274 if (ipip6_tunnel_create(dev) < 0) 273 275 goto failed_free; ··· 1449 1449 int err; 1450 1450 1451 1451 tunnel->dev = dev; 1452 - tunnel->net = dev_net(dev); 1453 1452 strcpy(tunnel->parms.name, dev->name); 1454 1453 1455 1454 ipip6_tunnel_bind_dev(dev); ··· 1549 1550 } 1550 1551 #endif 1551 1552 1552 - static int ipip6_newlink(struct net *src_net, struct net_device *dev, 1553 - struct nlattr *tb[], struct nlattr *data[], 1553 + static int ipip6_newlink(struct net_device *dev, 1554 + struct rtnl_newlink_params *params, 1554 1555 struct netlink_ext_ack *extack) 1555 1556 { 1556 - struct net *net = dev_net(dev); 1557 + struct nlattr **data = params->data; 1558 + struct nlattr **tb = params->tb; 1557 1559 struct ip_tunnel *nt; 1558 1560 struct ip_tunnel_encap ipencap; 1559 1561 #ifdef CONFIG_IPV6_SIT_6RD 1560 1562 struct ip_tunnel_6rd ip6rd; 1561 1563 #endif 1564 + struct net *net; 1562 1565 int err; 1563 1566 1567 + net = params->link_net ? : dev_net(dev); 1564 1568 nt = netdev_priv(dev); 1569 + nt->net = net; 1565 1570 1566 1571 if (ip_tunnel_netlink_encap_parms(data, &ipencap)) { 1567 1572 err = ip_tunnel_encap_setup(nt, &ipencap); ··· 1861 1858 */ 1862 1859 sitn->fb_tunnel_dev->netns_local = true; 1863 1860 1861 + t = netdev_priv(sitn->fb_tunnel_dev); 1862 + t->net = net; 1863 + 1864 1864 err = register_netdev(sitn->fb_tunnel_dev); 1865 1865 if (err) 1866 1866 goto err_reg_dev; 1867 1867 1868 1868 ipip6_tunnel_clone_6rd(sitn->fb_tunnel_dev, sitn); 1869 1869 ipip6_fb_tunnel_init(sitn->fb_tunnel_dev); 1870 - 1871 - t = netdev_priv(sitn->fb_tunnel_dev); 1872 1870 1873 1871 strcpy(t->parms.name, sitn->fb_tunnel_dev->name); 1874 1872 return 0;
+8 -7
net/xfrm/xfrm_interface_core.c
··· 242 242 gro_cells_destroy(&xi->gro_cells); 243 243 } 244 244 245 - static int xfrmi_create(struct net_device *dev) 245 + static int xfrmi_create(struct net *net, struct net_device *dev) 246 246 { 247 247 struct xfrm_if *xi = netdev_priv(dev); 248 - struct net *net = dev_net(dev); 249 248 struct xfrmi_net *xfrmn = net_generic(net, xfrmi_net_id); 250 249 int err; 251 250 ··· 813 814 parms->collect_md = true; 814 815 } 815 816 816 - static int xfrmi_newlink(struct net *src_net, struct net_device *dev, 817 - struct nlattr *tb[], struct nlattr *data[], 818 - 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) 819 820 { 820 - struct net *net = dev_net(dev); 821 + struct nlattr **data = params->data; 821 822 struct xfrm_if_parms p = {}; 822 823 struct xfrm_if *xi; 824 + struct net *net; 823 825 int err; 824 826 827 + net = params->link_net ? : dev_net(dev); 825 828 xfrmi_netlink_parms(data, &p); 826 829 if (p.collect_md) { 827 830 struct xfrmi_net *xfrmn = net_generic(net, xfrmi_net_id); ··· 852 851 xi->net = net; 853 852 xi->dev = dev; 854 853 855 - err = xfrmi_create(dev); 854 + err = xfrmi_create(net, dev); 856 855 return err; 857 856 } 858 857
+1
tools/testing/selftests/net/Makefile
··· 36 36 TEST_PROGS += test_so_rcv.sh 37 37 TEST_PROGS += cmsg_time.sh cmsg_ipv6.sh 38 38 TEST_PROGS += netns-name.sh 39 + TEST_PROGS += link_netns.py 39 40 TEST_PROGS += nl_netdev.py 40 41 TEST_PROGS += rtnetlink.py 41 42 TEST_PROGS += srv6_end_dt46_l3vpn_test.sh
+5
tools/testing/selftests/net/config
··· 107 107 CONFIG_XFRM_USER=m 108 108 CONFIG_IP_NF_MATCH_RPFILTER=m 109 109 CONFIG_IP6_NF_MATCH_RPFILTER=m 110 + CONFIG_IPVLAN=m 111 + CONFIG_CAN=m 112 + CONFIG_CAN_DEV=m 113 + CONFIG_CAN_VXCAN=m 114 + CONFIG_NETKIT=y
+1 -1
tools/testing/selftests/net/lib/py/__init__.py
··· 2 2 3 3 from .consts import KSRC 4 4 from .ksft import * 5 - from .netns import NetNS 5 + from .netns import NetNS, NetNSEnter 6 6 from .nsim import * 7 7 from .utils import * 8 8 from .ynl import NlError, YnlFamily, EthtoolFamily, NetdevFamily, RtnlFamily, RtnlAddrFamily
+18
tools/testing/selftests/net/lib/py/netns.py
··· 1 1 # SPDX-License-Identifier: GPL-2.0 2 2 3 3 from .utils import ip 4 + import ctypes 4 5 import random 5 6 import string 7 + 8 + libc = ctypes.cdll.LoadLibrary('libc.so.6') 6 9 7 10 8 11 class NetNS: ··· 32 29 33 30 def __repr__(self): 34 31 return f"NetNS({self.name})" 32 + 33 + 34 + class NetNSEnter: 35 + def __init__(self, ns_name): 36 + self.ns_path = f"/run/netns/{ns_name}" 37 + 38 + def __enter__(self): 39 + self.saved = open("/proc/thread-self/ns/net") 40 + with open(self.ns_path) as ns_file: 41 + libc.setns(ns_file.fileno(), 0) 42 + return self 43 + 44 + def __exit__(self, exc_type, exc_value, traceback): 45 + libc.setns(self.saved.fileno(), 0) 46 + self.saved.close()
+10
tools/testing/selftests/net/netns-name.sh
··· 78 78 fail "Can still find alt-name after move" 79 79 ip -netns $test_ns link del $DEV || fail 80 80 81 + # 82 + # Test no conflict of the same name/ifindex in different netns 83 + # 84 + ip -netns $NS link add name $DEV index 100 type dummy || fail 85 + ip -netns $NS link add netns $test_ns name $DEV index 100 type dummy || 86 + fail "Can create in netns without moving" 87 + ip -netns $test_ns link show dev $DEV >> /dev/null || fail "Device not found" 88 + ip -netns $NS link del $DEV || fail 89 + ip -netns $test_ns link del $DEV || fail 90 + 81 91 echo -ne "$(basename $0) \t\t\t\t" 82 92 if [ $RET_CODE -eq 0 ]; then 83 93 echo "[ OK ]"