Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'net-6.18-rc7' of git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net
Pull networking fixes from Jakub Kicinski:
"Including fixes from IPsec and wireless.
Previous releases - regressions:
- prevent NULL deref in generic_hwtstamp_ioctl_lower(),
newer APIs don't populate all the pointers in the request
- phylink: add missing supported link modes for the fixed-link
- mptcp: fix false positive warning in mptcp_pm_nl_rm_addr
Previous releases - always broken:
- openvswitch: remove never-working support for setting NSH fields
- xfrm: number of fixes for error paths of xfrm_state creation/
modification/deletion
- xfrm: fixes for offload
- fix the determination of the protocol of the inner packet
- don't push locally generated packets directly to L2 tunnel
mode offloading, they still need processing from the standard
xfrm path
- mptcp: fix a couple of corner cases in fallback and fastclose
handling
- wifi: rtw89: hw_scan: prevent connections from getting stuck,
work around apparent bug in FW by tweaking messages we send
- af_unix: fix duplicate data if PEEK w/ peek_offset needs to wait
- veth: more robust handing of race to avoid txq getting stuck
- eth: ps3_gelic_net: handle skb allocation failures"
* tag 'net-6.18-rc7' of git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net: (47 commits)
vsock: Ignore signal/timeout on connect() if already established
be2net: pass wrb_params in case of OS2BMC
l2tp: reset skb control buffer on xmit
net: dsa: microchip: lan937x: Fix RGMII delay tuning
selftests: mptcp: add a check for 'add_addr_accepted'
mptcp: fix address removal logic in mptcp_pm_nl_rm_addr
selftests: mptcp: join: userspace: longer timeout
selftests: mptcp: join: endpoints: longer timeout
selftests: mptcp: join: fastclose: remove flaky marks
mptcp: fix duplicate reset on fastclose
mptcp: decouple mptcp fastclose from tcp close
mptcp: do not fallback when OoO is present
mptcp: fix premature close in case of fallback
mptcp: avoid unneeded subflow-level drops
mptcp: fix ack generation for fallback msk
wifi: rtw89: hw_scan: Don't let the operating channel be last
net: phylink: add missing supported link modes for the fixed-link
selftest: af_unix: Add test for SO_PEEK_OFF.
af_unix: Read sk_peek_offset() again after sleeping in unix_stream_read_generic().
net/mlx5: Clean up only new IRQ glue on request_irq() failure
...
+521
-252
-1
MAINTAINERS
-1
MAINTAINERS
+12
-2
drivers/net/dsa/hirschmann/hellcreek_ptp.c
+12
-2
drivers/net/dsa/hirschmann/hellcreek_ptp.c
···
376
376
hellcreek_set_brightness(hellcreek, STATUS_OUT_IS_GM, 1);
377
377
378
378
/* Register both leds */
379
-
led_classdev_register(hellcreek->dev, &hellcreek->led_sync_good);
380
-
led_classdev_register(hellcreek->dev, &hellcreek->led_is_gm);
379
+
ret = led_classdev_register(hellcreek->dev, &hellcreek->led_sync_good);
380
+
if (ret) {
381
+
dev_err(hellcreek->dev, "Failed to register sync_good LED\n");
382
+
goto out;
383
+
}
384
+
385
+
ret = led_classdev_register(hellcreek->dev, &hellcreek->led_is_gm);
386
+
if (ret) {
387
+
dev_err(hellcreek->dev, "Failed to register is_gm LED\n");
388
+
led_classdev_unregister(&hellcreek->led_sync_good);
389
+
goto out;
390
+
}
381
391
382
392
ret = 0;
383
393
+1
drivers/net/dsa/microchip/lan937x_main.c
+1
drivers/net/dsa/microchip/lan937x_main.c
+1
-1
drivers/net/ethernet/airoha/airoha_ppe.c
+1
-1
drivers/net/ethernet/airoha/airoha_ppe.c
+4
-3
drivers/net/ethernet/emulex/benet/be_main.c
+4
-3
drivers/net/ethernet/emulex/benet/be_main.c
···
1296
1296
(adapter->bmc_filt_mask & BMC_FILT_MULTICAST)
1297
1297
1298
1298
static bool be_send_pkt_to_bmc(struct be_adapter *adapter,
1299
-
struct sk_buff **skb)
1299
+
struct sk_buff **skb,
1300
+
struct be_wrb_params *wrb_params)
1300
1301
{
1301
1302
struct ethhdr *eh = (struct ethhdr *)(*skb)->data;
1302
1303
bool os2bmc = false;
···
1361
1360
* to BMC, asic expects the vlan to be inline in the packet.
1362
1361
*/
1363
1362
if (os2bmc)
1364
-
*skb = be_insert_vlan_in_pkt(adapter, *skb, NULL);
1363
+
*skb = be_insert_vlan_in_pkt(adapter, *skb, wrb_params);
1365
1364
1366
1365
return os2bmc;
1367
1366
}
···
1388
1387
/* if os2bmc is enabled and if the pkt is destined to bmc,
1389
1388
* enqueue the pkt a 2nd time with mgmt bit set.
1390
1389
*/
1391
-
if (be_send_pkt_to_bmc(adapter, &skb)) {
1390
+
if (be_send_pkt_to_bmc(adapter, &skb, &wrb_params)) {
1392
1391
BE_WRB_F_SET(wrb_params.features, OS2BMC, 1);
1393
1392
wrb_cnt = be_xmit_enqueue(adapter, txo, skb, &wrb_params);
1394
1393
if (unlikely(!wrb_cnt))
+19
-3
drivers/net/ethernet/intel/ice/ice_ptp.c
+19
-3
drivers/net/ethernet/intel/ice/ice_ptp.c
···
3246
3246
3247
3247
err = ice_ptp_init_port(pf, &ptp->port);
3248
3248
if (err)
3249
-
goto err_exit;
3249
+
goto err_clean_pf;
3250
3250
3251
3251
/* Start the PHY timestamping block */
3252
3252
ice_ptp_reset_phy_timestamping(pf);
···
3263
3263
dev_info(ice_pf_to_dev(pf), "PTP init successful\n");
3264
3264
return;
3265
3265
3266
+
err_clean_pf:
3267
+
mutex_destroy(&ptp->port.ps_lock);
3268
+
ice_ptp_cleanup_pf(pf);
3266
3269
err_exit:
3267
3270
/* If we registered a PTP clock, release it */
3268
3271
if (pf->ptp.clock) {
3269
3272
ptp_clock_unregister(ptp->clock);
3270
3273
pf->ptp.clock = NULL;
3271
3274
}
3272
-
ptp->state = ICE_PTP_ERROR;
3275
+
/* Keep ICE_PTP_UNINIT state to avoid ambiguity at driver unload
3276
+
* and to avoid duplicated resources release.
3277
+
*/
3278
+
ptp->state = ICE_PTP_UNINIT;
3273
3279
dev_err(ice_pf_to_dev(pf), "PTP failed %d\n", err);
3274
3280
}
3275
3281
···
3288
3282
*/
3289
3283
void ice_ptp_release(struct ice_pf *pf)
3290
3284
{
3291
-
if (pf->ptp.state != ICE_PTP_READY)
3285
+
if (pf->ptp.state == ICE_PTP_UNINIT)
3292
3286
return;
3287
+
3288
+
if (pf->ptp.state != ICE_PTP_READY) {
3289
+
mutex_destroy(&pf->ptp.port.ps_lock);
3290
+
ice_ptp_cleanup_pf(pf);
3291
+
if (pf->ptp.clock) {
3292
+
ptp_clock_unregister(pf->ptp.clock);
3293
+
pf->ptp.clock = NULL;
3294
+
}
3295
+
return;
3296
+
}
3293
3297
3294
3298
pf->ptp.state = ICE_PTP_UNINIT;
3295
3299
+2
drivers/net/ethernet/intel/idpf/idpf_main.c
+2
drivers/net/ethernet/intel/idpf/idpf_main.c
+2
-4
drivers/net/ethernet/mellanox/mlx5/core/pci_irq.c
+2
-4
drivers/net/ethernet/mellanox/mlx5/core/pci_irq.c
···
324
324
free_irq(irq->map.virq, &irq->nh);
325
325
err_req_irq:
326
326
#ifdef CONFIG_RFS_ACCEL
327
-
if (i && rmap && *rmap) {
328
-
free_irq_cpu_rmap(*rmap);
329
-
*rmap = NULL;
330
-
}
327
+
if (i && rmap && *rmap)
328
+
irq_cpu_rmap_remove(*rmap, irq->map.virq);
331
329
err_irq_rmap:
332
330
#endif
333
331
if (i && pci_msix_can_alloc_dyn(dev->pdev))
+2
drivers/net/ethernet/mellanox/mlxsw/core_linecards.c
+2
drivers/net/ethernet/mellanox/mlxsw/core_linecards.c
+4
-2
drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c
+4
-2
drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c
···
830
830
return -EINVAL;
831
831
832
832
rule = mlxsw_sp_acl_rule_lookup(mlxsw_sp, ruleset, f->cookie);
833
-
if (!rule)
834
-
return -EINVAL;
833
+
if (!rule) {
834
+
err = -EINVAL;
835
+
goto err_rule_get_stats;
836
+
}
835
837
836
838
err = mlxsw_sp_acl_rule_get_stats(mlxsw_sp, rule, &packets, &bytes,
837
839
&drops, &lastuse, &used_hw_stats);
+3
-2
drivers/net/ethernet/qlogic/qede/qede_fp.c
+3
-2
drivers/net/ethernet/qlogic/qede/qede_fp.c
···
4
4
* Copyright (c) 2019-2020 Marvell International Ltd.
5
5
*/
6
6
7
+
#include <linux/array_size.h>
7
8
#include <linux/netdevice.h>
8
9
#include <linux/etherdevice.h>
9
10
#include <linux/skbuff.h>
···
961
960
{
962
961
int i;
963
962
964
-
for (i = 0; cqe->len_list[i]; i++)
963
+
for (i = 0; cqe->len_list[i] && i < ARRAY_SIZE(cqe->len_list); i++)
965
964
qede_fill_frag_skb(edev, rxq, cqe->tpa_agg_index,
966
965
le16_to_cpu(cqe->len_list[i]));
967
966
···
986
985
dma_unmap_page(rxq->dev, tpa_info->buffer.mapping,
987
986
PAGE_SIZE, rxq->data_direction);
988
987
989
-
for (i = 0; cqe->len_list[i]; i++)
988
+
for (i = 0; cqe->len_list[i] && i < ARRAY_SIZE(cqe->len_list); i++)
990
989
qede_fill_frag_skb(edev, rxq, cqe->tpa_agg_index,
991
990
le16_to_cpu(cqe->len_list[i]));
992
991
if (unlikely(i > 1))
+34
-11
drivers/net/ethernet/toshiba/ps3_gelic_net.c
+34
-11
drivers/net/ethernet/toshiba/ps3_gelic_net.c
···
260
260
if (atomic_dec_if_positive(&card->users) == 0) {
261
261
pr_debug("%s: real do\n", __func__);
262
262
napi_disable(&card->napi);
263
+
timer_delete_sync(&card->rx_oom_timer);
263
264
/*
264
265
* Disable irq. Wireless interrupts will
265
266
* be disabled later if any
···
971
970
* gelic_card_decode_one_descr - processes an rx descriptor
972
971
* @card: card structure
973
972
*
974
-
* returns 1 if a packet has been sent to the stack, otherwise 0
973
+
* returns 1 if a packet has been sent to the stack, -ENOMEM on skb alloc
974
+
* failure, otherwise 0
975
975
*
976
976
* processes an rx descriptor by iommu-unmapping the data buffer and passing
977
977
* the packet up to the stack
···
983
981
struct gelic_descr_chain *chain = &card->rx_chain;
984
982
struct gelic_descr *descr = chain->head;
985
983
struct net_device *netdev = NULL;
986
-
int dmac_chain_ended;
984
+
int dmac_chain_ended = 0;
985
+
int prepare_rx_ret;
987
986
988
987
status = gelic_descr_get_status(descr);
989
988
990
989
if (status == GELIC_DESCR_DMA_CARDOWNED)
991
990
return 0;
992
991
993
-
if (status == GELIC_DESCR_DMA_NOT_IN_USE) {
992
+
if (status == GELIC_DESCR_DMA_NOT_IN_USE || !descr->skb) {
994
993
dev_dbg(ctodev(card), "dormant descr? %p\n", descr);
995
-
return 0;
994
+
dmac_chain_ended = 1;
995
+
goto refill;
996
996
}
997
997
998
998
/* netdevice select */
···
1052
1048
refill:
1053
1049
1054
1050
/* is the current descriptor terminated with next_descr == NULL? */
1055
-
dmac_chain_ended =
1056
-
be32_to_cpu(descr->hw_regs.dmac_cmd_status) &
1057
-
GELIC_DESCR_RX_DMA_CHAIN_END;
1051
+
if (!dmac_chain_ended)
1052
+
dmac_chain_ended =
1053
+
be32_to_cpu(descr->hw_regs.dmac_cmd_status) &
1054
+
GELIC_DESCR_RX_DMA_CHAIN_END;
1058
1055
/*
1059
1056
* So that always DMAC can see the end
1060
1057
* of the descriptor chain to avoid
···
1067
1062
gelic_descr_set_status(descr, GELIC_DESCR_DMA_NOT_IN_USE);
1068
1063
1069
1064
/*
1070
-
* this call can fail, but for now, just leave this
1071
-
* descriptor without skb
1065
+
* this call can fail, propagate the error
1072
1066
*/
1073
-
gelic_descr_prepare_rx(card, descr);
1067
+
prepare_rx_ret = gelic_descr_prepare_rx(card, descr);
1068
+
if (prepare_rx_ret)
1069
+
return prepare_rx_ret;
1074
1070
1075
1071
chain->tail = descr;
1076
1072
chain->head = descr->next;
···
1093
1087
return 1;
1094
1088
}
1095
1089
1090
+
static void gelic_rx_oom_timer(struct timer_list *t)
1091
+
{
1092
+
struct gelic_card *card = timer_container_of(card, t, rx_oom_timer);
1093
+
1094
+
napi_schedule(&card->napi);
1095
+
}
1096
+
1096
1097
/**
1097
1098
* gelic_net_poll - NAPI poll function called by the stack to return packets
1098
1099
* @napi: napi structure
···
1112
1099
{
1113
1100
struct gelic_card *card = container_of(napi, struct gelic_card, napi);
1114
1101
int packets_done = 0;
1102
+
int work_result = 0;
1115
1103
1116
1104
while (packets_done < budget) {
1117
-
if (!gelic_card_decode_one_descr(card))
1105
+
work_result = gelic_card_decode_one_descr(card);
1106
+
if (work_result != 1)
1118
1107
break;
1119
1108
1120
1109
packets_done++;
1110
+
}
1111
+
1112
+
if (work_result == -ENOMEM) {
1113
+
napi_complete_done(napi, packets_done);
1114
+
mod_timer(&card->rx_oom_timer, jiffies + 1);
1115
+
return packets_done;
1121
1116
}
1122
1117
1123
1118
if (packets_done < budget) {
···
1596
1575
atomic_set(&card->tx_timeout_task_counter, 0);
1597
1576
mutex_init(&card->updown_lock);
1598
1577
atomic_set(&card->users, 0);
1578
+
1579
+
timer_setup(&card->rx_oom_timer, gelic_rx_oom_timer, 0);
1599
1580
1600
1581
return card;
1601
1582
}
+1
drivers/net/ethernet/toshiba/ps3_gelic_net.h
+1
drivers/net/ethernet/toshiba/ps3_gelic_net.h
+3
drivers/net/phy/phylink.c
+3
drivers/net/phy/phylink.c
···
637
637
638
638
static void phylink_fill_fixedlink_supported(unsigned long *supported)
639
639
{
640
+
linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT, supported);
641
+
linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, supported);
642
+
linkmode_set_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, supported);
640
643
linkmode_set_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, supported);
641
644
linkmode_set_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, supported);
642
645
linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, supported);
+20
-18
drivers/net/veth.c
+20
-18
drivers/net/veth.c
···
392
392
}
393
393
/* Restore Eth hdr pulled by dev_forward_skb/eth_type_trans */
394
394
__skb_push(skb, ETH_HLEN);
395
-
/* Depend on prior success packets started NAPI consumer via
396
-
* __veth_xdp_flush(). Cancel TXQ stop if consumer stopped,
397
-
* paired with empty check in veth_poll().
398
-
*/
399
395
netif_tx_stop_queue(txq);
400
-
smp_mb__after_atomic();
401
-
if (unlikely(__ptr_ring_empty(&rq->xdp_ring)))
402
-
netif_tx_wake_queue(txq);
396
+
/* Makes sure NAPI peer consumer runs. Consumer is responsible
397
+
* for starting txq again, until then ndo_start_xmit (this
398
+
* function) will not be invoked by the netstack again.
399
+
*/
400
+
__veth_xdp_flush(rq);
403
401
break;
404
402
case NET_RX_DROP: /* same as NET_XMIT_DROP */
405
403
drop:
···
898
900
struct veth_xdp_tx_bq *bq,
899
901
struct veth_stats *stats)
900
902
{
901
-
struct veth_priv *priv = netdev_priv(rq->dev);
902
-
int queue_idx = rq->xdp_rxq.queue_index;
903
-
struct netdev_queue *peer_txq;
904
-
struct net_device *peer_dev;
905
903
int i, done = 0, n_xdpf = 0;
906
904
void *xdpf[VETH_XDP_BATCH];
907
-
908
-
/* NAPI functions as RCU section */
909
-
peer_dev = rcu_dereference_check(priv->peer, rcu_read_lock_bh_held());
910
-
peer_txq = peer_dev ? netdev_get_tx_queue(peer_dev, queue_idx) : NULL;
911
905
912
906
for (i = 0; i < budget; i++) {
913
907
void *ptr = __ptr_ring_consume(&rq->xdp_ring);
···
949
959
rq->stats.vs.xdp_packets += done;
950
960
u64_stats_update_end(&rq->stats.syncp);
951
961
952
-
if (peer_txq && unlikely(netif_tx_queue_stopped(peer_txq)))
953
-
netif_tx_wake_queue(peer_txq);
954
-
955
962
return done;
956
963
}
957
964
···
956
969
{
957
970
struct veth_rq *rq =
958
971
container_of(napi, struct veth_rq, xdp_napi);
972
+
struct veth_priv *priv = netdev_priv(rq->dev);
973
+
int queue_idx = rq->xdp_rxq.queue_index;
974
+
struct netdev_queue *peer_txq;
959
975
struct veth_stats stats = {};
976
+
struct net_device *peer_dev;
960
977
struct veth_xdp_tx_bq bq;
961
978
int done;
962
979
963
980
bq.count = 0;
981
+
982
+
/* NAPI functions as RCU section */
983
+
peer_dev = rcu_dereference_check(priv->peer, rcu_read_lock_bh_held());
984
+
peer_txq = peer_dev ? netdev_get_tx_queue(peer_dev, queue_idx) : NULL;
964
985
965
986
xdp_set_return_frame_no_direct();
966
987
done = veth_xdp_rcv(rq, budget, &bq, &stats);
···
990
995
if (stats.xdp_tx > 0)
991
996
veth_xdp_flush(rq, &bq);
992
997
xdp_clear_return_frame_no_direct();
998
+
999
+
/* Release backpressure per NAPI poll */
1000
+
smp_rmb(); /* Paired with netif_tx_stop_queue set_bit */
1001
+
if (peer_txq && netif_tx_queue_stopped(peer_txq)) {
1002
+
txq_trans_cond_update(peer_txq);
1003
+
netif_tx_wake_queue(peer_txq);
1004
+
}
993
1005
994
1006
return done;
995
1007
}
+7
drivers/net/wireless/realtek/rtw89/fw.c
+7
drivers/net/wireless/realtek/rtw89/fw.c
···
7694
7694
INIT_LIST_HEAD(&list);
7695
7695
7696
7696
list_for_each_entry_safe(ch_info, tmp, &scan_info->chan_list, list) {
7697
+
/* The operating channel (tx_null == true) should
7698
+
* not be last in the list, to avoid breaking
7699
+
* RTL8851BU and RTL8832BU.
7700
+
*/
7701
+
if (list_len + 1 == RTW89_SCAN_LIST_LIMIT_AX && ch_info->tx_null)
7702
+
break;
7703
+
7697
7704
list_move_tail(&ch_info->list, &list);
7698
7705
7699
7706
list_len++;
-1
drivers/s390/net/ctcm_mpc.c
-1
drivers/s390/net/ctcm_mpc.c
+2
-1
include/net/xfrm.h
+2
-1
include/net/xfrm.h
···
536
536
537
537
static inline const struct xfrm_mode *xfrm_ip2inner_mode(struct xfrm_state *x, int ipproto)
538
538
{
539
-
if ((ipproto == IPPROTO_IPIP && x->props.family == AF_INET) ||
539
+
if ((x->sel.family != AF_UNSPEC) ||
540
+
(ipproto == IPPROTO_IPIP && x->props.family == AF_INET) ||
540
541
(ipproto == IPPROTO_IPV6 && x->props.family == AF_INET6))
541
542
return &x->inner_mode;
542
543
else
+3
net/core/dev_ioctl.c
+3
net/core/dev_ioctl.c
+3
-1
net/devlink/rate.c
+3
-1
net/devlink/rate.c
···
828
828
if (!devlink_rate->parent)
829
829
continue;
830
830
831
-
refcount_dec(&devlink_rate->parent->refcnt);
832
831
if (devlink_rate_is_leaf(devlink_rate))
833
832
ops->rate_leaf_parent_set(devlink_rate, NULL, devlink_rate->priv,
834
833
NULL, NULL);
835
834
else if (devlink_rate_is_node(devlink_rate))
836
835
ops->rate_node_parent_set(devlink_rate, NULL, devlink_rate->priv,
837
836
NULL, NULL);
837
+
838
+
refcount_dec(&devlink_rate->parent->refcnt);
839
+
devlink_rate->parent = NULL;
838
840
}
839
841
list_for_each_entry_safe(devlink_rate, tmp, &devlink->rate_list, list) {
840
842
if (devlink_rate_is_node(devlink_rate)) {
+4
-2
net/ipv4/esp4_offload.c
+4
-2
net/ipv4/esp4_offload.c
···
122
122
struct sk_buff *skb,
123
123
netdev_features_t features)
124
124
{
125
-
__be16 type = x->inner_mode.family == AF_INET6 ? htons(ETH_P_IPV6)
126
-
: htons(ETH_P_IP);
125
+
const struct xfrm_mode *inner_mode = xfrm_ip2inner_mode(x,
126
+
XFRM_MODE_SKB_CB(skb)->protocol);
127
+
__be16 type = inner_mode->family == AF_INET6 ? htons(ETH_P_IPV6)
128
+
: htons(ETH_P_IP);
127
129
128
130
return skb_eth_gso_segment(skb, features, type);
129
131
}
+4
-2
net/ipv6/esp6_offload.c
+4
-2
net/ipv6/esp6_offload.c
···
158
158
struct sk_buff *skb,
159
159
netdev_features_t features)
160
160
{
161
-
__be16 type = x->inner_mode.family == AF_INET ? htons(ETH_P_IP)
162
-
: htons(ETH_P_IPV6);
161
+
const struct xfrm_mode *inner_mode = xfrm_ip2inner_mode(x,
162
+
XFRM_MODE_SKB_CB(skb)->protocol);
163
+
__be16 type = inner_mode->family == AF_INET ? htons(ETH_P_IP)
164
+
: htons(ETH_P_IPV6);
163
165
164
166
return skb_eth_gso_segment(skb, features, type);
165
167
}
+3
-3
net/l2tp/l2tp_core.c
+3
-3
net/l2tp/l2tp_core.c
···
1246
1246
else
1247
1247
l2tp_build_l2tpv3_header(session, __skb_push(skb, session->hdr_len));
1248
1248
1249
-
/* Reset skb netfilter state */
1250
-
memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
1251
-
IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED | IPSKB_REROUTED);
1249
+
/* Reset control buffer */
1250
+
memset(skb->cb, 0, sizeof(skb->cb));
1251
+
1252
1252
nf_reset_ct(skb);
1253
1253
1254
1254
/* L2TP uses its own lockdep subclass to avoid lockdep splats caused by
+53
-1
net/mptcp/options.c
+53
-1
net/mptcp/options.c
···
838
838
839
839
opts->suboptions = 0;
840
840
841
+
/* Force later mptcp_write_options(), but do not use any actual
842
+
* option space.
843
+
*/
841
844
if (unlikely(__mptcp_check_fallback(msk) && !mptcp_check_infinite_map(skb)))
842
-
return false;
845
+
return true;
843
846
844
847
if (unlikely(skb && TCP_SKB_CB(skb)->tcp_flags & TCPHDR_RST)) {
845
848
if (mptcp_established_options_fastclose(sk, &opt_size, remaining, opts) ||
···
1044
1041
WRITE_ONCE(msk->snd_una, new_snd_una);
1045
1042
}
1046
1043
1044
+
static void rwin_update(struct mptcp_sock *msk, struct sock *ssk,
1045
+
struct sk_buff *skb)
1046
+
{
1047
+
struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
1048
+
struct tcp_sock *tp = tcp_sk(ssk);
1049
+
u64 mptcp_rcv_wnd;
1050
+
1051
+
/* Avoid touching extra cachelines if TCP is going to accept this
1052
+
* skb without filling the TCP-level window even with a possibly
1053
+
* outdated mptcp-level rwin.
1054
+
*/
1055
+
if (!skb->len || skb->len < tcp_receive_window(tp))
1056
+
return;
1057
+
1058
+
mptcp_rcv_wnd = atomic64_read(&msk->rcv_wnd_sent);
1059
+
if (!after64(mptcp_rcv_wnd, subflow->rcv_wnd_sent))
1060
+
return;
1061
+
1062
+
/* Some other subflow grew the mptcp-level rwin since rcv_wup,
1063
+
* resync.
1064
+
*/
1065
+
tp->rcv_wnd += mptcp_rcv_wnd - subflow->rcv_wnd_sent;
1066
+
subflow->rcv_wnd_sent = mptcp_rcv_wnd;
1067
+
}
1068
+
1047
1069
static void ack_update_msk(struct mptcp_sock *msk,
1048
1070
struct sock *ssk,
1049
1071
struct mptcp_options_received *mp_opt)
···
1236
1208
*/
1237
1209
if (mp_opt.use_ack)
1238
1210
ack_update_msk(msk, sk, &mp_opt);
1211
+
rwin_update(msk, sk, skb);
1239
1212
1240
1213
/* Zero-data-length packets are dropped by the caller and not
1241
1214
* propagated to the MPTCP layer, so the skb extension does not
···
1323
1294
1324
1295
if (rcv_wnd_new != rcv_wnd_old) {
1325
1296
raise_win:
1297
+
/* The msk-level rcv wnd is after the tcp level one,
1298
+
* sync the latter.
1299
+
*/
1300
+
rcv_wnd_new = rcv_wnd_old;
1326
1301
win = rcv_wnd_old - ack_seq;
1327
1302
tp->rcv_wnd = min_t(u64, win, U32_MAX);
1328
1303
new_win = tp->rcv_wnd;
···
1349
1316
}
1350
1317
1351
1318
update_wspace:
1319
+
WRITE_ONCE(msk->old_wspace, tp->rcv_wnd);
1320
+
subflow->rcv_wnd_sent = rcv_wnd_new;
1321
+
}
1322
+
1323
+
static void mptcp_track_rwin(struct tcp_sock *tp)
1324
+
{
1325
+
const struct sock *ssk = (const struct sock *)tp;
1326
+
struct mptcp_subflow_context *subflow;
1327
+
struct mptcp_sock *msk;
1328
+
1329
+
if (!ssk)
1330
+
return;
1331
+
1332
+
subflow = mptcp_subflow_ctx(ssk);
1333
+
msk = mptcp_sk(subflow->conn);
1352
1334
WRITE_ONCE(msk->old_wspace, tp->rcv_wnd);
1353
1335
}
1354
1336
···
1658
1610
TCPOLEN_MPTCP_RST,
1659
1611
opts->reset_transient,
1660
1612
opts->reset_reason);
1613
+
return;
1614
+
} else if (unlikely(!opts->suboptions)) {
1615
+
/* Fallback to TCP */
1616
+
mptcp_track_rwin(tp);
1661
1617
return;
1662
1618
}
1663
1619
+13
-7
net/mptcp/pm.c
+13
-7
net/mptcp/pm.c
···
18
18
u8 retrans_times;
19
19
struct timer_list add_timer;
20
20
struct mptcp_sock *sock;
21
+
struct rcu_head rcu;
21
22
};
22
23
23
24
static DEFINE_SPINLOCK(mptcp_pm_list_lock);
···
156
155
157
156
entry = mptcp_pm_del_add_timer(msk, addr, false);
158
157
ret = entry;
159
-
kfree(entry);
158
+
kfree_rcu(entry, rcu);
160
159
161
160
return ret;
162
161
}
···
346
345
{
347
346
struct mptcp_pm_add_entry *entry;
348
347
struct sock *sk = (struct sock *)msk;
349
-
struct timer_list *add_timer = NULL;
348
+
bool stop_timer = false;
349
+
350
+
rcu_read_lock();
350
351
351
352
spin_lock_bh(&msk->pm.lock);
352
353
entry = mptcp_lookup_anno_list_by_saddr(msk, addr);
353
354
if (entry && (!check_id || entry->addr.id == addr->id)) {
354
355
entry->retrans_times = ADD_ADDR_RETRANS_MAX;
355
-
add_timer = &entry->add_timer;
356
+
stop_timer = true;
356
357
}
357
358
if (!check_id && entry)
358
359
list_del(&entry->list);
359
360
spin_unlock_bh(&msk->pm.lock);
360
361
361
-
/* no lock, because sk_stop_timer_sync() is calling timer_delete_sync() */
362
-
if (add_timer)
363
-
sk_stop_timer_sync(sk, add_timer);
362
+
/* Note: entry might have been removed by another thread.
363
+
* We hold rcu_read_lock() to ensure it is not freed under us.
364
+
*/
365
+
if (stop_timer)
366
+
sk_stop_timer_sync(sk, &entry->add_timer);
364
367
368
+
rcu_read_unlock();
365
369
return entry;
366
370
}
367
371
···
421
415
422
416
list_for_each_entry_safe(entry, tmp, &free_list, list) {
423
417
sk_stop_timer_sync(sk, &entry->add_timer);
424
-
kfree(entry);
418
+
kfree_rcu(entry, rcu);
425
419
}
426
420
}
427
421
+1
-1
net/mptcp/pm_kernel.c
+1
-1
net/mptcp/pm_kernel.c
···
672
672
673
673
void mptcp_pm_nl_rm_addr(struct mptcp_sock *msk, u8 rm_id)
674
674
{
675
-
if (rm_id && WARN_ON_ONCE(msk->pm.add_addr_accepted == 0)) {
675
+
if (rm_id && !WARN_ON_ONCE(msk->pm.add_addr_accepted == 0)) {
676
676
u8 limit_add_addr_accepted =
677
677
mptcp_pm_get_limit_add_addr_accepted(msk);
678
678
+53
-25
net/mptcp/protocol.c
+53
-25
net/mptcp/protocol.c
···
78
78
if (__mptcp_check_fallback(msk))
79
79
return true;
80
80
81
+
/* The caller possibly is not holding the msk socket lock, but
82
+
* in the fallback case only the current subflow is touching
83
+
* the OoO queue.
84
+
*/
85
+
if (!RB_EMPTY_ROOT(&msk->out_of_order_queue))
86
+
return false;
87
+
81
88
spin_lock_bh(&msk->fallback_lock);
82
89
if (!msk->allow_infinite_fallback) {
83
90
spin_unlock_bh(&msk->fallback_lock);
···
944
937
945
938
bool mptcp_schedule_work(struct sock *sk)
946
939
{
947
-
if (inet_sk_state_load(sk) != TCP_CLOSE &&
948
-
schedule_work(&mptcp_sk(sk)->work)) {
949
-
/* each subflow already holds a reference to the sk, and the
950
-
* workqueue is invoked by a subflow, so sk can't go away here.
951
-
*/
952
-
sock_hold(sk);
940
+
if (inet_sk_state_load(sk) == TCP_CLOSE)
941
+
return false;
942
+
943
+
/* Get a reference on this socket, mptcp_worker() will release it.
944
+
* As mptcp_worker() might complete before us, we can not avoid
945
+
* a sock_hold()/sock_put() if schedule_work() returns false.
946
+
*/
947
+
sock_hold(sk);
948
+
949
+
if (schedule_work(&mptcp_sk(sk)->work))
953
950
return true;
954
-
}
951
+
952
+
sock_put(sk);
955
953
return false;
956
954
}
957
955
···
2411
2399
2412
2400
/* flags for __mptcp_close_ssk() */
2413
2401
#define MPTCP_CF_PUSH BIT(1)
2414
-
#define MPTCP_CF_FASTCLOSE BIT(2)
2415
2402
2416
2403
/* be sure to send a reset only if the caller asked for it, also
2417
2404
* clean completely the subflow status when the subflow reaches
···
2421
2410
unsigned int flags)
2422
2411
{
2423
2412
if (((1 << ssk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN)) ||
2424
-
(flags & MPTCP_CF_FASTCLOSE)) {
2413
+
subflow->send_fastclose) {
2425
2414
/* The MPTCP code never wait on the subflow sockets, TCP-level
2426
2415
* disconnect should never fail
2427
2416
*/
···
2468
2457
2469
2458
lock_sock_nested(ssk, SINGLE_DEPTH_NESTING);
2470
2459
2471
-
if ((flags & MPTCP_CF_FASTCLOSE) && !__mptcp_check_fallback(msk)) {
2472
-
/* be sure to force the tcp_close path
2473
-
* to generate the egress reset
2474
-
*/
2475
-
ssk->sk_lingertime = 0;
2476
-
sock_set_flag(ssk, SOCK_LINGER);
2477
-
subflow->send_fastclose = 1;
2478
-
}
2460
+
if (subflow->send_fastclose && ssk->sk_state != TCP_CLOSE)
2461
+
tcp_set_state(ssk, TCP_CLOSE);
2479
2462
2480
2463
need_push = (flags & MPTCP_CF_PUSH) && __mptcp_retransmit_pending_data(sk);
2481
2464
if (!dispose_it) {
···
2565
2560
2566
2561
if (ssk_state != TCP_CLOSE &&
2567
2562
(ssk_state != TCP_CLOSE_WAIT ||
2568
-
inet_sk_state_load(sk) != TCP_ESTABLISHED))
2563
+
inet_sk_state_load(sk) != TCP_ESTABLISHED ||
2564
+
__mptcp_check_fallback(msk)))
2569
2565
continue;
2570
2566
2571
2567
/* 'subflow_data_ready' will re-sched once rx queue is empty */
···
2774
2768
struct mptcp_sock *msk = mptcp_sk(sk);
2775
2769
2776
2770
mptcp_set_state(sk, TCP_CLOSE);
2777
-
mptcp_for_each_subflow_safe(msk, subflow, tmp)
2778
-
__mptcp_close_ssk(sk, mptcp_subflow_tcp_sock(subflow),
2779
-
subflow, MPTCP_CF_FASTCLOSE);
2771
+
2772
+
/* Explicitly send the fastclose reset as need */
2773
+
if (__mptcp_check_fallback(msk))
2774
+
return;
2775
+
2776
+
mptcp_for_each_subflow_safe(msk, subflow, tmp) {
2777
+
struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
2778
+
2779
+
lock_sock(ssk);
2780
+
2781
+
/* Some subflow socket states don't allow/need a reset.*/
2782
+
if ((1 << ssk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
2783
+
goto unlock;
2784
+
2785
+
subflow->send_fastclose = 1;
2786
+
tcp_send_active_reset(ssk, ssk->sk_allocation,
2787
+
SK_RST_REASON_TCP_ABORT_ON_CLOSE);
2788
+
unlock:
2789
+
release_sock(ssk);
2790
+
}
2780
2791
}
2781
2792
2782
2793
static void mptcp_worker(struct work_struct *work)
···
2820
2797
__mptcp_close_subflow(sk);
2821
2798
2822
2799
if (mptcp_close_tout_expired(sk)) {
2800
+
struct mptcp_subflow_context *subflow, *tmp;
2801
+
2823
2802
mptcp_do_fastclose(sk);
2803
+
mptcp_for_each_subflow_safe(msk, subflow, tmp)
2804
+
__mptcp_close_ssk(sk, subflow->tcp_sock, subflow, 0);
2824
2805
mptcp_close_wake_up(sk);
2825
2806
}
2826
2807
···
3249
3222
/* msk->subflow is still intact, the following will not free the first
3250
3223
* subflow
3251
3224
*/
3252
-
mptcp_destroy_common(msk, MPTCP_CF_FASTCLOSE);
3225
+
mptcp_do_fastclose(sk);
3226
+
mptcp_destroy_common(msk);
3253
3227
3254
3228
/* The first subflow is already in TCP_CLOSE status, the following
3255
3229
* can't overlap with a fallback anymore
···
3429
3401
msk->rcvq_space.space = TCP_INIT_CWND * TCP_MSS_DEFAULT;
3430
3402
}
3431
3403
3432
-
void mptcp_destroy_common(struct mptcp_sock *msk, unsigned int flags)
3404
+
void mptcp_destroy_common(struct mptcp_sock *msk)
3433
3405
{
3434
3406
struct mptcp_subflow_context *subflow, *tmp;
3435
3407
struct sock *sk = (struct sock *)msk;
···
3438
3410
3439
3411
/* join list will be eventually flushed (with rst) at sock lock release time */
3440
3412
mptcp_for_each_subflow_safe(msk, subflow, tmp)
3441
-
__mptcp_close_ssk(sk, mptcp_subflow_tcp_sock(subflow), subflow, flags);
3413
+
__mptcp_close_ssk(sk, mptcp_subflow_tcp_sock(subflow), subflow, 0);
3442
3414
3443
3415
__skb_queue_purge(&sk->sk_receive_queue);
3444
3416
skb_rbtree_purge(&msk->out_of_order_queue);
···
3456
3428
3457
3429
/* allow the following to close even the initial subflow */
3458
3430
msk->free_first = 1;
3459
-
mptcp_destroy_common(msk, 0);
3431
+
mptcp_destroy_common(msk);
3460
3432
sk_sockets_allocated_dec(sk);
3461
3433
}
3462
3434
+2
-1
net/mptcp/protocol.h
+2
-1
net/mptcp/protocol.h
···
509
509
u64 remote_key;
510
510
u64 idsn;
511
511
u64 map_seq;
512
+
u64 rcv_wnd_sent;
512
513
u32 snd_isn;
513
514
u32 token;
514
515
u32 rel_write_seq;
···
977
976
local_bh_enable();
978
977
}
979
978
980
-
void mptcp_destroy_common(struct mptcp_sock *msk, unsigned int flags);
979
+
void mptcp_destroy_common(struct mptcp_sock *msk);
981
980
982
981
#define MPTCP_TOKEN_MAX_RETRIES 4
983
982
+1
-67
net/openvswitch/actions.c
+1
-67
net/openvswitch/actions.c
···
572
572
return 0;
573
573
}
574
574
575
-
static int set_nsh(struct sk_buff *skb, struct sw_flow_key *flow_key,
576
-
const struct nlattr *a)
577
-
{
578
-
struct nshhdr *nh;
579
-
size_t length;
580
-
int err;
581
-
u8 flags;
582
-
u8 ttl;
583
-
int i;
584
-
585
-
struct ovs_key_nsh key;
586
-
struct ovs_key_nsh mask;
587
-
588
-
err = nsh_key_from_nlattr(a, &key, &mask);
589
-
if (err)
590
-
return err;
591
-
592
-
/* Make sure the NSH base header is there */
593
-
if (!pskb_may_pull(skb, skb_network_offset(skb) + NSH_BASE_HDR_LEN))
594
-
return -ENOMEM;
595
-
596
-
nh = nsh_hdr(skb);
597
-
length = nsh_hdr_len(nh);
598
-
599
-
/* Make sure the whole NSH header is there */
600
-
err = skb_ensure_writable(skb, skb_network_offset(skb) +
601
-
length);
602
-
if (unlikely(err))
603
-
return err;
604
-
605
-
nh = nsh_hdr(skb);
606
-
skb_postpull_rcsum(skb, nh, length);
607
-
flags = nsh_get_flags(nh);
608
-
flags = OVS_MASKED(flags, key.base.flags, mask.base.flags);
609
-
flow_key->nsh.base.flags = flags;
610
-
ttl = nsh_get_ttl(nh);
611
-
ttl = OVS_MASKED(ttl, key.base.ttl, mask.base.ttl);
612
-
flow_key->nsh.base.ttl = ttl;
613
-
nsh_set_flags_and_ttl(nh, flags, ttl);
614
-
nh->path_hdr = OVS_MASKED(nh->path_hdr, key.base.path_hdr,
615
-
mask.base.path_hdr);
616
-
flow_key->nsh.base.path_hdr = nh->path_hdr;
617
-
switch (nh->mdtype) {
618
-
case NSH_M_TYPE1:
619
-
for (i = 0; i < NSH_MD1_CONTEXT_SIZE; i++) {
620
-
nh->md1.context[i] =
621
-
OVS_MASKED(nh->md1.context[i], key.context[i],
622
-
mask.context[i]);
623
-
}
624
-
memcpy(flow_key->nsh.context, nh->md1.context,
625
-
sizeof(nh->md1.context));
626
-
break;
627
-
case NSH_M_TYPE2:
628
-
memset(flow_key->nsh.context, 0,
629
-
sizeof(flow_key->nsh.context));
630
-
break;
631
-
default:
632
-
return -EINVAL;
633
-
}
634
-
skb_postpush_rcsum(skb, nh, length);
635
-
return 0;
636
-
}
637
-
638
575
/* Must follow skb_ensure_writable() since that can move the skb data. */
639
576
static void set_tp_port(struct sk_buff *skb, __be16 *port,
640
577
__be16 new_port, __sum16 *check)
···
1067
1130
get_mask(a, struct ovs_key_ethernet *));
1068
1131
break;
1069
1132
1070
-
case OVS_KEY_ATTR_NSH:
1071
-
err = set_nsh(skb, flow_key, a);
1072
-
break;
1073
-
1074
1133
case OVS_KEY_ATTR_IPV4:
1075
1134
err = set_ipv4(skb, flow_key, nla_data(a),
1076
1135
get_mask(a, struct ovs_key_ipv4 *));
···
1103
1170
case OVS_KEY_ATTR_CT_LABELS:
1104
1171
case OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4:
1105
1172
case OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6:
1173
+
case OVS_KEY_ATTR_NSH:
1106
1174
err = -EINVAL;
1107
1175
break;
1108
1176
}
+8
-56
net/openvswitch/flow_netlink.c
+8
-56
net/openvswitch/flow_netlink.c
···
1305
1305
return 0;
1306
1306
}
1307
1307
1308
+
/*
1309
+
* Constructs NSH header 'nh' from attributes of OVS_ACTION_ATTR_PUSH_NSH,
1310
+
* where 'nh' points to a memory block of 'size' bytes. It's assumed that
1311
+
* attributes were previously validated with validate_push_nsh().
1312
+
*/
1308
1313
int nsh_hdr_from_nlattr(const struct nlattr *attr,
1309
1314
struct nshhdr *nh, size_t size)
1310
1315
{
···
1319
1314
u8 ttl = 0;
1320
1315
int mdlen = 0;
1321
1316
1322
-
/* validate_nsh has check this, so we needn't do duplicate check here
1323
-
*/
1324
1317
if (size < NSH_BASE_HDR_LEN)
1325
1318
return -ENOBUFS;
1326
1319
···
1358
1355
/* nsh header length = NSH_BASE_HDR_LEN + mdlen */
1359
1356
nh->ver_flags_ttl_len = 0;
1360
1357
nsh_set_flags_ttl_len(nh, flags, ttl, NSH_BASE_HDR_LEN + mdlen);
1361
-
1362
-
return 0;
1363
-
}
1364
-
1365
-
int nsh_key_from_nlattr(const struct nlattr *attr,
1366
-
struct ovs_key_nsh *nsh, struct ovs_key_nsh *nsh_mask)
1367
-
{
1368
-
struct nlattr *a;
1369
-
int rem;
1370
-
1371
-
/* validate_nsh has check this, so we needn't do duplicate check here
1372
-
*/
1373
-
nla_for_each_nested(a, attr, rem) {
1374
-
int type = nla_type(a);
1375
-
1376
-
switch (type) {
1377
-
case OVS_NSH_KEY_ATTR_BASE: {
1378
-
const struct ovs_nsh_key_base *base = nla_data(a);
1379
-
const struct ovs_nsh_key_base *base_mask = base + 1;
1380
-
1381
-
nsh->base = *base;
1382
-
nsh_mask->base = *base_mask;
1383
-
break;
1384
-
}
1385
-
case OVS_NSH_KEY_ATTR_MD1: {
1386
-
const struct ovs_nsh_key_md1 *md1 = nla_data(a);
1387
-
const struct ovs_nsh_key_md1 *md1_mask = md1 + 1;
1388
-
1389
-
memcpy(nsh->context, md1->context, sizeof(*md1));
1390
-
memcpy(nsh_mask->context, md1_mask->context,
1391
-
sizeof(*md1_mask));
1392
-
break;
1393
-
}
1394
-
case OVS_NSH_KEY_ATTR_MD2:
1395
-
/* Not supported yet */
1396
-
return -ENOTSUPP;
1397
-
default:
1398
-
return -EINVAL;
1399
-
}
1400
-
}
1401
1358
1402
1359
return 0;
1403
1360
}
···
2802
2839
return err;
2803
2840
}
2804
2841
2805
-
static bool validate_nsh(const struct nlattr *attr, bool is_mask,
2806
-
bool is_push_nsh, bool log)
2842
+
static bool validate_push_nsh(const struct nlattr *attr, bool log)
2807
2843
{
2808
2844
struct sw_flow_match match;
2809
2845
struct sw_flow_key key;
2810
-
int ret = 0;
2811
2846
2812
2847
ovs_match_init(&match, &key, true, NULL);
2813
-
ret = nsh_key_put_from_nlattr(attr, &match, is_mask,
2814
-
is_push_nsh, log);
2815
-
return !ret;
2848
+
return !nsh_key_put_from_nlattr(attr, &match, false, true, log);
2816
2849
}
2817
2850
2818
2851
/* Return false if there are any non-masked bits set.
···
2954
2995
flow_key->ip.proto != IPPROTO_SCTP)
2955
2996
return -EINVAL;
2956
2997
2957
-
break;
2958
-
2959
-
case OVS_KEY_ATTR_NSH:
2960
-
if (eth_type != htons(ETH_P_NSH))
2961
-
return -EINVAL;
2962
-
if (!validate_nsh(nla_data(a), masked, false, log))
2963
-
return -EINVAL;
2964
2998
break;
2965
2999
2966
3000
default:
···
3389
3437
return -EINVAL;
3390
3438
}
3391
3439
mac_proto = MAC_PROTO_NONE;
3392
-
if (!validate_nsh(nla_data(a), false, true, true))
3440
+
if (!validate_push_nsh(nla_data(a), log))
3393
3441
return -EINVAL;
3394
3442
break;
3395
3443
-2
net/openvswitch/flow_netlink.h
-2
net/openvswitch/flow_netlink.h
···
65
65
void ovs_nla_free_flow_actions(struct sw_flow_actions *);
66
66
void ovs_nla_free_flow_actions_rcu(struct sw_flow_actions *);
67
67
68
-
int nsh_key_from_nlattr(const struct nlattr *attr, struct ovs_key_nsh *nsh,
69
-
struct ovs_key_nsh *nsh_mask);
70
68
int nsh_hdr_from_nlattr(const struct nlattr *attr, struct nshhdr *nh,
71
69
size_t size);
72
70
+1
-2
net/unix/af_unix.c
+1
-2
net/unix/af_unix.c
···
2954
2954
2955
2955
u = unix_sk(sk);
2956
2956
2957
+
redo:
2957
2958
/* Lock the socket to prevent queue disordering
2958
2959
* while sleeps in memcpy_tomsg
2959
2960
*/
···
2966
2965
struct sk_buff *skb, *last;
2967
2966
int chunk;
2968
2967
2969
-
redo:
2970
2968
unix_state_lock(sk);
2971
2969
if (sock_flag(sk, SOCK_DEAD)) {
2972
2970
err = -ECONNRESET;
···
3015
3015
goto out;
3016
3016
}
3017
3017
3018
-
mutex_lock(&u->iolock);
3019
3018
goto redo;
3020
3019
unlock:
3021
3020
unix_state_unlock(sk);
+31
-9
net/vmw_vsock/af_vsock.c
+31
-9
net/vmw_vsock/af_vsock.c
···
1661
1661
timeout = schedule_timeout(timeout);
1662
1662
lock_sock(sk);
1663
1663
1664
-
if (signal_pending(current)) {
1665
-
err = sock_intr_errno(timeout);
1666
-
sk->sk_state = sk->sk_state == TCP_ESTABLISHED ? TCP_CLOSING : TCP_CLOSE;
1667
-
sock->state = SS_UNCONNECTED;
1668
-
vsock_transport_cancel_pkt(vsk);
1669
-
vsock_remove_connected(vsk);
1670
-
goto out_wait;
1671
-
} else if ((sk->sk_state != TCP_ESTABLISHED) && (timeout == 0)) {
1672
-
err = -ETIMEDOUT;
1664
+
/* Connection established. Whatever happens to socket once we
1665
+
* release it, that's not connect()'s concern. No need to go
1666
+
* into signal and timeout handling. Call it a day.
1667
+
*
1668
+
* Note that allowing to "reset" an already established socket
1669
+
* here is racy and insecure.
1670
+
*/
1671
+
if (sk->sk_state == TCP_ESTABLISHED)
1672
+
break;
1673
+
1674
+
/* If connection was _not_ established and a signal/timeout came
1675
+
* to be, we want the socket's state reset. User space may want
1676
+
* to retry.
1677
+
*
1678
+
* sk_state != TCP_ESTABLISHED implies that socket is not on
1679
+
* vsock_connected_table. We keep the binding and the transport
1680
+
* assigned.
1681
+
*/
1682
+
if (signal_pending(current) || timeout == 0) {
1683
+
err = timeout == 0 ? -ETIMEDOUT : sock_intr_errno(timeout);
1684
+
1685
+
/* Listener might have already responded with
1686
+
* VIRTIO_VSOCK_OP_RESPONSE. Its handling expects our
1687
+
* sk_state == TCP_SYN_SENT, which hereby we break.
1688
+
* In such case VIRTIO_VSOCK_OP_RST will follow.
1689
+
*/
1673
1690
sk->sk_state = TCP_CLOSE;
1674
1691
sock->state = SS_UNCONNECTED;
1692
+
1693
+
/* Try to cancel VIRTIO_VSOCK_OP_REQUEST skb sent out by
1694
+
* transport->connect().
1695
+
*/
1675
1696
vsock_transport_cancel_pkt(vsk);
1697
+
1676
1698
goto out_wait;
1677
1699
}
1678
1700
+1
-1
net/xfrm/xfrm_device.c
+1
-1
net/xfrm/xfrm_device.c
+6
-2
net/xfrm/xfrm_output.c
+6
-2
net/xfrm/xfrm_output.c
···
698
698
return;
699
699
700
700
if (x->outer_mode.encap == XFRM_MODE_TUNNEL) {
701
-
switch (x->outer_mode.family) {
701
+
switch (skb_dst(skb)->ops->family) {
702
702
case AF_INET:
703
703
xo->inner_ipproto = ip_hdr(skb)->protocol;
704
704
break;
···
772
772
/* Exclusive direct xmit for tunnel mode, as
773
773
* some filtering or matching rules may apply
774
774
* in transport mode.
775
+
* Locally generated packets also require
776
+
* the normal XFRM path for L2 header setup,
777
+
* as the hardware needs the L2 header to match
778
+
* for encryption, so skip direct output as well.
775
779
*/
776
-
if (x->props.mode == XFRM_MODE_TUNNEL)
780
+
if (x->props.mode == XFRM_MODE_TUNNEL && !skb->sk)
777
781
return xfrm_dev_direct_output(sk, x, skb);
778
782
779
783
return xfrm_output_resume(sk, skb, 0);
+22
-8
net/xfrm/xfrm_state.c
+22
-8
net/xfrm/xfrm_state.c
···
592
592
}
593
593
EXPORT_SYMBOL(xfrm_state_free);
594
594
595
+
static void xfrm_state_delete_tunnel(struct xfrm_state *x);
595
596
static void xfrm_state_gc_destroy(struct xfrm_state *x)
596
597
{
597
598
if (x->mode_cbs && x->mode_cbs->destroy_state)
···
608
607
kfree(x->replay_esn);
609
608
kfree(x->preplay_esn);
610
609
xfrm_unset_type_offload(x);
610
+
xfrm_state_delete_tunnel(x);
611
611
if (x->type) {
612
612
x->type->destructor(x);
613
613
xfrm_put_type(x->type);
···
808
806
}
809
807
EXPORT_SYMBOL(__xfrm_state_destroy);
810
808
811
-
static void xfrm_state_delete_tunnel(struct xfrm_state *x);
812
809
int __xfrm_state_delete(struct xfrm_state *x)
813
810
{
814
811
struct net *net = xs_net(x);
···
2074
2073
return x;
2075
2074
2076
2075
error:
2076
+
x->km.state = XFRM_STATE_DEAD;
2077
2077
xfrm_state_put(x);
2078
2078
out:
2079
2079
return NULL;
···
2159
2157
xfrm_state_insert(xc);
2160
2158
} else {
2161
2159
if (xfrm_state_add(xc) < 0)
2162
-
goto error;
2160
+
goto error_add;
2163
2161
}
2164
2162
2165
2163
return xc;
2164
+
error_add:
2165
+
if (xuo)
2166
+
xfrm_dev_state_delete(xc);
2166
2167
error:
2168
+
xc->km.state = XFRM_STATE_DEAD;
2167
2169
xfrm_state_put(xc);
2168
2170
return NULL;
2169
2171
}
···
2197
2191
}
2198
2192
2199
2193
if (x1->km.state == XFRM_STATE_ACQ) {
2200
-
if (x->dir && x1->dir != x->dir)
2194
+
if (x->dir && x1->dir != x->dir) {
2195
+
to_put = x1;
2201
2196
goto out;
2197
+
}
2202
2198
2203
2199
__xfrm_state_insert(x);
2204
2200
x = NULL;
2205
2201
} else {
2206
-
if (x1->dir != x->dir)
2202
+
if (x1->dir != x->dir) {
2203
+
to_put = x1;
2207
2204
goto out;
2205
+
}
2208
2206
}
2209
2207
err = 0;
2210
2208
···
3308
3298
void xfrm_state_fini(struct net *net)
3309
3299
{
3310
3300
unsigned int sz;
3301
+
int i;
3311
3302
3312
3303
flush_work(&net->xfrm.state_hash_work);
3313
3304
xfrm_state_flush(net, 0, false);
···
3316
3305
3317
3306
WARN_ON(!list_empty(&net->xfrm.state_all));
3318
3307
3308
+
for (i = 0; i <= net->xfrm.state_hmask; i++) {
3309
+
WARN_ON(!hlist_empty(net->xfrm.state_byseq + i));
3310
+
WARN_ON(!hlist_empty(net->xfrm.state_byspi + i));
3311
+
WARN_ON(!hlist_empty(net->xfrm.state_bysrc + i));
3312
+
WARN_ON(!hlist_empty(net->xfrm.state_bydst + i));
3313
+
}
3314
+
3319
3315
sz = (net->xfrm.state_hmask + 1) * sizeof(struct hlist_head);
3320
-
WARN_ON(!hlist_empty(net->xfrm.state_byseq));
3321
3316
xfrm_hash_free(net->xfrm.state_byseq, sz);
3322
-
WARN_ON(!hlist_empty(net->xfrm.state_byspi));
3323
3317
xfrm_hash_free(net->xfrm.state_byspi, sz);
3324
-
WARN_ON(!hlist_empty(net->xfrm.state_bysrc));
3325
3318
xfrm_hash_free(net->xfrm.state_bysrc, sz);
3326
-
WARN_ON(!hlist_empty(net->xfrm.state_bydst));
3327
3319
xfrm_hash_free(net->xfrm.state_bydst, sz);
3328
3320
free_percpu(net->xfrm.state_cache_input);
3329
3321
}
+7
-1
net/xfrm/xfrm_user.c
+7
-1
net/xfrm/xfrm_user.c
···
947
947
948
948
if (attrs[XFRMA_SA_PCPU]) {
949
949
x->pcpu_num = nla_get_u32(attrs[XFRMA_SA_PCPU]);
950
-
if (x->pcpu_num >= num_possible_cpus())
950
+
if (x->pcpu_num >= num_possible_cpus()) {
951
+
err = -ERANGE;
952
+
NL_SET_ERR_MSG(extack, "pCPU number too big");
951
953
goto error;
954
+
}
952
955
}
953
956
954
957
err = __xfrm_init_state(x, extack);
···
3038
3035
}
3039
3036
3040
3037
xfrm_state_free(x);
3038
+
xfrm_dev_policy_delete(xp);
3039
+
xfrm_dev_policy_free(xp);
3040
+
security_xfrm_policy_free(xp->security);
3041
3041
kfree(xp);
3042
3042
3043
3043
return 0;
+1
tools/testing/selftests/net/.gitignore
+1
tools/testing/selftests/net/.gitignore
+1
tools/testing/selftests/net/af_unix/Makefile
+1
tools/testing/selftests/net/af_unix/Makefile
+162
tools/testing/selftests/net/af_unix/so_peek_off.c
+162
tools/testing/selftests/net/af_unix/so_peek_off.c
···
1
+
// SPDX-License-Identifier: GPL-2.0
2
+
/* Copyright 2025 Google LLC */
3
+
4
+
#include <stdlib.h>
5
+
#include <unistd.h>
6
+
7
+
#include <sys/socket.h>
8
+
9
+
#include "../../kselftest_harness.h"
10
+
11
+
FIXTURE(so_peek_off)
12
+
{
13
+
int fd[2]; /* 0: sender, 1: receiver */
14
+
};
15
+
16
+
FIXTURE_VARIANT(so_peek_off)
17
+
{
18
+
int type;
19
+
};
20
+
21
+
FIXTURE_VARIANT_ADD(so_peek_off, stream)
22
+
{
23
+
.type = SOCK_STREAM,
24
+
};
25
+
26
+
FIXTURE_VARIANT_ADD(so_peek_off, dgram)
27
+
{
28
+
.type = SOCK_DGRAM,
29
+
};
30
+
31
+
FIXTURE_VARIANT_ADD(so_peek_off, seqpacket)
32
+
{
33
+
.type = SOCK_SEQPACKET,
34
+
};
35
+
36
+
FIXTURE_SETUP(so_peek_off)
37
+
{
38
+
struct timeval timeout = {
39
+
.tv_sec = 0,
40
+
.tv_usec = 3000,
41
+
};
42
+
int ret;
43
+
44
+
ret = socketpair(AF_UNIX, variant->type, 0, self->fd);
45
+
ASSERT_EQ(0, ret);
46
+
47
+
ret = setsockopt(self->fd[1], SOL_SOCKET, SO_RCVTIMEO_NEW,
48
+
&timeout, sizeof(timeout));
49
+
ASSERT_EQ(0, ret);
50
+
51
+
ret = setsockopt(self->fd[1], SOL_SOCKET, SO_PEEK_OFF,
52
+
&(int){0}, sizeof(int));
53
+
ASSERT_EQ(0, ret);
54
+
}
55
+
56
+
FIXTURE_TEARDOWN(so_peek_off)
57
+
{
58
+
close_range(self->fd[0], self->fd[1], 0);
59
+
}
60
+
61
+
#define sendeq(fd, str, flags) \
62
+
do { \
63
+
int bytes, len = strlen(str); \
64
+
\
65
+
bytes = send(fd, str, len, flags); \
66
+
ASSERT_EQ(len, bytes); \
67
+
} while (0)
68
+
69
+
#define recveq(fd, str, buflen, flags) \
70
+
do { \
71
+
char buf[(buflen) + 1] = {}; \
72
+
int bytes; \
73
+
\
74
+
bytes = recv(fd, buf, buflen, flags); \
75
+
ASSERT_NE(-1, bytes); \
76
+
ASSERT_STREQ(str, buf); \
77
+
} while (0)
78
+
79
+
#define async \
80
+
for (pid_t pid = (pid = fork(), \
81
+
pid < 0 ? \
82
+
__TH_LOG("Failed to start async {}"), \
83
+
_metadata->exit_code = KSFT_FAIL, \
84
+
__bail(1, _metadata), \
85
+
0xdead : \
86
+
pid); \
87
+
!pid; exit(0))
88
+
89
+
TEST_F(so_peek_off, single_chunk)
90
+
{
91
+
sendeq(self->fd[0], "aaaabbbb", 0);
92
+
93
+
recveq(self->fd[1], "aaaa", 4, MSG_PEEK);
94
+
recveq(self->fd[1], "bbbb", 100, MSG_PEEK);
95
+
}
96
+
97
+
TEST_F(so_peek_off, two_chunks)
98
+
{
99
+
sendeq(self->fd[0], "aaaa", 0);
100
+
sendeq(self->fd[0], "bbbb", 0);
101
+
102
+
recveq(self->fd[1], "aaaa", 4, MSG_PEEK);
103
+
recveq(self->fd[1], "bbbb", 100, MSG_PEEK);
104
+
}
105
+
106
+
TEST_F(so_peek_off, two_chunks_blocking)
107
+
{
108
+
async {
109
+
usleep(1000);
110
+
sendeq(self->fd[0], "aaaa", 0);
111
+
}
112
+
113
+
recveq(self->fd[1], "aaaa", 4, MSG_PEEK);
114
+
115
+
async {
116
+
usleep(1000);
117
+
sendeq(self->fd[0], "bbbb", 0);
118
+
}
119
+
120
+
/* goto again; -> goto redo; in unix_stream_read_generic(). */
121
+
recveq(self->fd[1], "bbbb", 100, MSG_PEEK);
122
+
}
123
+
124
+
TEST_F(so_peek_off, two_chunks_overlap)
125
+
{
126
+
sendeq(self->fd[0], "aaaa", 0);
127
+
recveq(self->fd[1], "aa", 2, MSG_PEEK);
128
+
129
+
sendeq(self->fd[0], "bbbb", 0);
130
+
131
+
if (variant->type == SOCK_STREAM) {
132
+
/* SOCK_STREAM tries to fill the buffer. */
133
+
recveq(self->fd[1], "aabb", 4, MSG_PEEK);
134
+
recveq(self->fd[1], "bb", 100, MSG_PEEK);
135
+
} else {
136
+
/* SOCK_DGRAM and SOCK_SEQPACKET returns at the skb boundary. */
137
+
recveq(self->fd[1], "aa", 100, MSG_PEEK);
138
+
recveq(self->fd[1], "bbbb", 100, MSG_PEEK);
139
+
}
140
+
}
141
+
142
+
TEST_F(so_peek_off, two_chunks_overlap_blocking)
143
+
{
144
+
async {
145
+
usleep(1000);
146
+
sendeq(self->fd[0], "aaaa", 0);
147
+
}
148
+
149
+
recveq(self->fd[1], "aa", 2, MSG_PEEK);
150
+
151
+
async {
152
+
usleep(1000);
153
+
sendeq(self->fd[0], "bbbb", 0);
154
+
}
155
+
156
+
/* Even SOCK_STREAM does not wait if at least one byte is read. */
157
+
recveq(self->fd[1], "aa", 100, MSG_PEEK);
158
+
159
+
recveq(self->fd[1], "bbbb", 100, MSG_PEEK);
160
+
}
161
+
162
+
TEST_HARNESS_MAIN
+7
tools/testing/selftests/net/forwarding/lib_sh_test.sh
+7
tools/testing/selftests/net/forwarding/lib_sh_test.sh
···
30
30
do_test "tfail" false
31
31
}
32
32
33
+
tfail2()
34
+
{
35
+
do_test "tfail2" false
36
+
}
37
+
33
38
txfail()
34
39
{
35
40
FAIL_TO_XFAIL=yes do_test "txfail" false
···
137
132
ret_subtest $ksft_fail "tfail" txfail tfail
138
133
139
134
ret_subtest $ksft_xfail "txfail" txfail txfail
135
+
136
+
ret_subtest $ksft_fail "tfail2" tfail2 tfail
140
137
}
141
138
142
139
exit_status_tests_run()
+1
-1
tools/testing/selftests/net/lib.sh
+1
-1
tools/testing/selftests/net/lib.sh
+16
-11
tools/testing/selftests/net/mptcp/mptcp_join.sh
+16
-11
tools/testing/selftests/net/mptcp/mptcp_join.sh
···
3500
3500
fastclose_tests()
3501
3501
{
3502
3502
if reset_check_counter "fastclose test" "MPTcpExtMPFastcloseTx"; then
3503
-
MPTCP_LIB_SUBTEST_FLAKY=1
3504
3503
test_linkfail=1024 fastclose=client \
3505
3504
run_tests $ns1 $ns2 10.0.1.1
3506
3505
chk_join_nr 0 0 0
···
3508
3509
fi
3509
3510
3510
3511
if reset_check_counter "fastclose server test" "MPTcpExtMPFastcloseRx"; then
3511
-
MPTCP_LIB_SUBTEST_FLAKY=1
3512
3512
test_linkfail=1024 fastclose=server \
3513
3513
run_tests $ns1 $ns2 10.0.1.1
3514
3514
join_rst_nr=1 \
···
3804
3806
continue_if mptcp_lib_has_file '/proc/sys/net/mptcp/pm_type'; then
3805
3807
set_userspace_pm $ns1
3806
3808
pm_nl_set_limits $ns2 2 2
3807
-
{ test_linkfail=128 speed=5 \
3809
+
{ timeout_test=120 test_linkfail=128 speed=5 \
3808
3810
run_tests $ns1 $ns2 10.0.1.1 & } 2>/dev/null
3809
3811
local tests_pid=$!
3810
3812
wait_mpj $ns1
···
3837
3839
continue_if mptcp_lib_has_file '/proc/sys/net/mptcp/pm_type'; then
3838
3840
set_userspace_pm $ns2
3839
3841
pm_nl_set_limits $ns1 0 1
3840
-
{ test_linkfail=128 speed=5 \
3842
+
{ timeout_test=120 test_linkfail=128 speed=5 \
3841
3843
run_tests $ns1 $ns2 10.0.1.1 & } 2>/dev/null
3842
3844
local tests_pid=$!
3843
3845
wait_mpj $ns2
···
3865
3867
continue_if mptcp_lib_has_file '/proc/sys/net/mptcp/pm_type'; then
3866
3868
set_userspace_pm $ns2
3867
3869
pm_nl_set_limits $ns1 0 1
3868
-
{ test_linkfail=128 speed=5 \
3870
+
{ timeout_test=120 test_linkfail=128 speed=5 \
3869
3871
run_tests $ns1 $ns2 10.0.1.1 & } 2>/dev/null
3870
3872
local tests_pid=$!
3871
3873
wait_mpj $ns2
···
3886
3888
continue_if mptcp_lib_has_file '/proc/sys/net/mptcp/pm_type'; then
3887
3889
set_userspace_pm $ns2
3888
3890
pm_nl_set_limits $ns1 0 1
3889
-
{ test_linkfail=128 speed=5 \
3891
+
{ timeout_test=120 test_linkfail=128 speed=5 \
3890
3892
run_tests $ns1 $ns2 10.0.1.1 & } 2>/dev/null
3891
3893
local tests_pid=$!
3892
3894
wait_mpj $ns2
···
3910
3912
continue_if mptcp_lib_has_file '/proc/sys/net/mptcp/pm_type'; then
3911
3913
set_userspace_pm $ns1
3912
3914
pm_nl_set_limits $ns2 1 1
3913
-
{ test_linkfail=128 speed=5 \
3915
+
{ timeout_test=120 test_linkfail=128 speed=5 \
3914
3916
run_tests $ns1 $ns2 10.0.1.1 & } 2>/dev/null
3915
3917
local tests_pid=$!
3916
3918
wait_mpj $ns1
···
3941
3943
pm_nl_set_limits $ns1 2 2
3942
3944
pm_nl_set_limits $ns2 2 2
3943
3945
pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
3944
-
{ test_linkfail=128 speed=slow \
3946
+
{ timeout_test=120 test_linkfail=128 speed=slow \
3945
3947
run_tests $ns1 $ns2 10.0.1.1 & } 2>/dev/null
3946
3948
local tests_pid=$!
3947
3949
···
3968
3970
pm_nl_set_limits $ns2 0 3
3969
3971
pm_nl_add_endpoint $ns2 10.0.1.2 id 1 dev ns2eth1 flags subflow
3970
3972
pm_nl_add_endpoint $ns2 10.0.2.2 id 2 dev ns2eth2 flags subflow
3971
-
{ test_linkfail=128 speed=5 \
3973
+
{ timeout_test=120 test_linkfail=128 speed=5 \
3972
3974
run_tests $ns1 $ns2 10.0.1.1 & } 2>/dev/null
3973
3975
local tests_pid=$!
3974
3976
···
4046
4048
# broadcast IP: no packet for this address will be received on ns1
4047
4049
pm_nl_add_endpoint $ns1 224.0.0.1 id 2 flags signal
4048
4050
pm_nl_add_endpoint $ns1 10.0.1.1 id 42 flags signal
4049
-
{ test_linkfail=128 speed=5 \
4051
+
{ timeout_test=120 test_linkfail=128 speed=5 \
4050
4052
run_tests $ns1 $ns2 10.0.1.1 & } 2>/dev/null
4051
4053
local tests_pid=$!
4052
4054
···
4055
4057
$ns1 10.0.2.1 id 1 flags signal
4056
4058
chk_subflow_nr "before delete" 2
4057
4059
chk_mptcp_info subflows 1 subflows 1
4060
+
chk_mptcp_info add_addr_signal 2 add_addr_accepted 1
4058
4061
4059
4062
pm_nl_del_endpoint $ns1 1 10.0.2.1
4060
4063
pm_nl_del_endpoint $ns1 2 224.0.0.1
4061
4064
sleep 0.5
4062
4065
chk_subflow_nr "after delete" 1
4063
4066
chk_mptcp_info subflows 0 subflows 0
4067
+
chk_mptcp_info add_addr_signal 0 add_addr_accepted 0
4064
4068
4065
4069
pm_nl_add_endpoint $ns1 10.0.2.1 id 1 flags signal
4066
4070
pm_nl_add_endpoint $ns1 10.0.3.1 id 2 flags signal
4067
4071
wait_mpj $ns2
4068
4072
chk_subflow_nr "after re-add" 3
4069
4073
chk_mptcp_info subflows 2 subflows 2
4074
+
chk_mptcp_info add_addr_signal 2 add_addr_accepted 2
4070
4075
4071
4076
pm_nl_del_endpoint $ns1 42 10.0.1.1
4072
4077
sleep 0.5
4073
4078
chk_subflow_nr "after delete ID 0" 2
4074
4079
chk_mptcp_info subflows 2 subflows 2
4080
+
chk_mptcp_info add_addr_signal 2 add_addr_accepted 2
4075
4081
4076
4082
pm_nl_add_endpoint $ns1 10.0.1.1 id 99 flags signal
4077
4083
wait_mpj $ns2
4078
4084
chk_subflow_nr "after re-add ID 0" 3
4079
4085
chk_mptcp_info subflows 3 subflows 3
4086
+
chk_mptcp_info add_addr_signal 3 add_addr_accepted 2
4080
4087
4081
4088
pm_nl_del_endpoint $ns1 99 10.0.1.1
4082
4089
sleep 0.5
4083
4090
chk_subflow_nr "after re-delete ID 0" 2
4084
4091
chk_mptcp_info subflows 2 subflows 2
4092
+
chk_mptcp_info add_addr_signal 2 add_addr_accepted 2
4085
4093
4086
4094
pm_nl_add_endpoint $ns1 10.0.1.1 id 88 flags signal
4087
4095
wait_mpj $ns2
4088
4096
chk_subflow_nr "after re-re-add ID 0" 3
4089
4097
chk_mptcp_info subflows 3 subflows 3
4098
+
chk_mptcp_info add_addr_signal 3 add_addr_accepted 2
4090
4099
mptcp_lib_kill_group_wait $tests_pid
4091
4100
4092
4101
kill_events_pids
···
4126
4121
# broadcast IP: no packet for this address will be received on ns1
4127
4122
pm_nl_add_endpoint $ns1 224.0.0.1 id 2 flags signal
4128
4123
pm_nl_add_endpoint $ns2 10.0.3.2 id 3 flags subflow
4129
-
{ test_linkfail=128 speed=20 \
4124
+
{ timeout_test=120 test_linkfail=128 speed=20 \
4130
4125
run_tests $ns1 $ns2 10.0.1.1 & } 2>/dev/null
4131
4126
local tests_pid=$!
4132
4127