Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net
Pull networking fixes from David Miller:
"Just a couple more stragglers, I really hope this is it.
1) Don't let frags slip down into the GRO segmentation handlers, from
Steffen Klassert.
2) Truesize under-estimation triggers warnings in TCP over loopback
with socket filters, 2 part fix from Eric Dumazet.
3) Fix undesirable reset of bonding MTU to ETH_HLEN on slave removal,
from Paolo Abeni.
4) If we flush the XFRM policy after garbage collection, it doesn't
work because stray entries can be created afterwards. Fix from Xin
Long.
5) Hung socket connection fixes in TIPC from Parthasarathy Bhuvaragan.
6) Fix GRO regression with IPSEC when netfilter is disabled, from
Sabrina Dubroca.
7) Fix cpsw driver Kconfig dependency regression, from Arnd Bergmann"
* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net:
net: hso: register netdev later to avoid a race condition
net: adjust skb->truesize in ___pskb_trim()
tcp: do not underestimate skb->truesize in tcp_trim_head()
bonding: avoid defaulting hard_header_len to ETH_HLEN on slave removal
ipv4: Don't pass IP fragments to upper layer GRO handlers.
cpsw/netcp: refine cpts dependency
tipc: close the connection if protocol messages contain errors
tipc: improve error validations for sockets in CONNECTING state
tipc: Fix missing connection request handling
xfrm: fix GRO for !CONFIG_NETFILTER
xfrm: do the garbage collection after flushing policy
+64
-22
+1
-1
drivers/net/bonding/bond_main.c
+1
-1
drivers/net/bonding/bond_main.c
···
1104
1104
gso_max_size = min(gso_max_size, slave->dev->gso_max_size);
1105
1105
gso_max_segs = min(gso_max_segs, slave->dev->gso_max_segs);
1106
1106
}
1107
+
bond_dev->hard_header_len = max_hard_header_len;
1107
1108
1108
1109
done:
1109
1110
bond_dev->vlan_features = vlan_features;
1110
1111
bond_dev->hw_enc_features = enc_features | NETIF_F_GSO_ENCAP_ALL;
1111
-
bond_dev->hard_header_len = max_hard_header_len;
1112
1112
bond_dev->gso_max_segs = gso_max_segs;
1113
1113
netif_set_gso_max_size(bond_dev, gso_max_size);
1114
1114
+3
-1
drivers/net/ethernet/ti/Kconfig
+3
-1
drivers/net/ethernet/ti/Kconfig
···
76
76
config TI_CPTS
77
77
bool "TI Common Platform Time Sync (CPTS) Support"
78
78
depends on TI_CPSW || TI_KEYSTONE_NETCP
79
-
depends on PTP_1588_CLOCK
79
+
depends on POSIX_TIMERS
80
80
---help---
81
81
This driver supports the Common Platform Time Sync unit of
82
82
the CPSW Ethernet Switch and Keystone 2 1g/10g Switch Subsystem.
···
87
87
tristate
88
88
depends on TI_CPTS
89
89
default y if TI_CPSW=y || TI_KEYSTONE_NETCP=y
90
+
select NET_PTP_CLASSIFY
91
+
imply PTP_1588_CLOCK
90
92
default m
91
93
92
94
config TI_KEYSTONE_NETCP
+7
-7
drivers/net/usb/hso.c
+7
-7
drivers/net/usb/hso.c
···
2534
2534
SET_NETDEV_DEV(net, &interface->dev);
2535
2535
SET_NETDEV_DEVTYPE(net, &hso_type);
2536
2536
2537
-
/* registering our net device */
2538
-
result = register_netdev(net);
2539
-
if (result) {
2540
-
dev_err(&interface->dev, "Failed to register device\n");
2541
-
goto exit;
2542
-
}
2543
-
2544
2537
/* start allocating */
2545
2538
for (i = 0; i < MUX_BULK_RX_BUF_COUNT; i++) {
2546
2539
hso_net->mux_bulk_rx_urb_pool[i] = usb_alloc_urb(0, GFP_KERNEL);
···
2552
2559
goto exit;
2553
2560
2554
2561
add_net_device(hso_dev);
2562
+
2563
+
/* registering our net device */
2564
+
result = register_netdev(net);
2565
+
if (result) {
2566
+
dev_err(&interface->dev, "Failed to register device\n");
2567
+
goto exit;
2568
+
}
2555
2569
2556
2570
hso_log_port(hso_dev);
2557
2571
+2
net/core/skbuff.c
+2
net/core/skbuff.c
+3
net/ipv4/af_inet.c
+3
net/ipv4/af_inet.c
+12
-7
net/ipv4/tcp_output.c
+12
-7
net/ipv4/tcp_output.c
···
1267
1267
* eventually). The difference is that pulled data not copied, but
1268
1268
* immediately discarded.
1269
1269
*/
1270
-
static void __pskb_trim_head(struct sk_buff *skb, int len)
1270
+
static int __pskb_trim_head(struct sk_buff *skb, int len)
1271
1271
{
1272
1272
struct skb_shared_info *shinfo;
1273
1273
int i, k, eat;
···
1277
1277
__skb_pull(skb, eat);
1278
1278
len -= eat;
1279
1279
if (!len)
1280
-
return;
1280
+
return 0;
1281
1281
}
1282
1282
eat = len;
1283
1283
k = 0;
···
1303
1303
skb_reset_tail_pointer(skb);
1304
1304
skb->data_len -= len;
1305
1305
skb->len = skb->data_len;
1306
+
return len;
1306
1307
}
1307
1308
1308
1309
/* Remove acked data from a packet in the transmit queue. */
1309
1310
int tcp_trim_head(struct sock *sk, struct sk_buff *skb, u32 len)
1310
1311
{
1312
+
u32 delta_truesize;
1313
+
1311
1314
if (skb_unclone(skb, GFP_ATOMIC))
1312
1315
return -ENOMEM;
1313
1316
1314
-
__pskb_trim_head(skb, len);
1317
+
delta_truesize = __pskb_trim_head(skb, len);
1315
1318
1316
1319
TCP_SKB_CB(skb)->seq += len;
1317
1320
skb->ip_summed = CHECKSUM_PARTIAL;
1318
1321
1319
-
skb->truesize -= len;
1320
-
sk->sk_wmem_queued -= len;
1321
-
sk_mem_uncharge(sk, len);
1322
-
sock_set_flag(sk, SOCK_QUEUE_SHRUNK);
1322
+
if (delta_truesize) {
1323
+
skb->truesize -= delta_truesize;
1324
+
sk->sk_wmem_queued -= delta_truesize;
1325
+
sk_mem_uncharge(sk, delta_truesize);
1326
+
sock_set_flag(sk, SOCK_QUEUE_SHRUNK);
1327
+
}
1323
1328
1324
1329
/* Any change of skb->len requires recalculation of tso factor. */
1325
1330
if (tcp_skb_pcount(skb) > 1)
+31
-5
net/tipc/socket.c
+31
-5
net/tipc/socket.c
···
866
866
if (!tsk_peer_msg(tsk, hdr))
867
867
goto exit;
868
868
869
+
if (unlikely(msg_errcode(hdr))) {
870
+
tipc_set_sk_state(sk, TIPC_DISCONNECTING);
871
+
tipc_node_remove_conn(sock_net(sk), tsk_peer_node(tsk),
872
+
tsk_peer_port(tsk));
873
+
sk->sk_state_change(sk);
874
+
goto exit;
875
+
}
876
+
869
877
tsk->probe_unacked = false;
870
878
871
879
if (mtyp == CONN_PROBE) {
···
1267
1259
struct sock *sk = sock->sk;
1268
1260
DEFINE_WAIT(wait);
1269
1261
long timeo = *timeop;
1270
-
int err;
1262
+
int err = sock_error(sk);
1263
+
1264
+
if (err)
1265
+
return err;
1271
1266
1272
1267
for (;;) {
1273
1268
prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
···
1291
1280
break;
1292
1281
err = sock_intr_errno(timeo);
1293
1282
if (signal_pending(current))
1283
+
break;
1284
+
1285
+
err = sock_error(sk);
1286
+
if (err)
1294
1287
break;
1295
1288
}
1296
1289
finish_wait(sk_sleep(sk), &wait);
···
1566
1551
struct sock *sk = &tsk->sk;
1567
1552
struct net *net = sock_net(sk);
1568
1553
struct tipc_msg *hdr = buf_msg(skb);
1554
+
u32 pport = msg_origport(hdr);
1555
+
u32 pnode = msg_orignode(hdr);
1569
1556
1570
1557
if (unlikely(msg_mcast(hdr)))
1571
1558
return false;
···
1575
1558
switch (sk->sk_state) {
1576
1559
case TIPC_CONNECTING:
1577
1560
/* Accept only ACK or NACK message */
1578
-
if (unlikely(!msg_connected(hdr)))
1579
-
return false;
1561
+
if (unlikely(!msg_connected(hdr))) {
1562
+
if (pport != tsk_peer_port(tsk) ||
1563
+
pnode != tsk_peer_node(tsk))
1564
+
return false;
1565
+
1566
+
tipc_set_sk_state(sk, TIPC_DISCONNECTING);
1567
+
sk->sk_err = ECONNREFUSED;
1568
+
sk->sk_state_change(sk);
1569
+
return true;
1570
+
}
1580
1571
1581
1572
if (unlikely(msg_errcode(hdr))) {
1582
1573
tipc_set_sk_state(sk, TIPC_DISCONNECTING);
1583
1574
sk->sk_err = ECONNREFUSED;
1575
+
sk->sk_state_change(sk);
1584
1576
return true;
1585
1577
}
1586
1578
1587
1579
if (unlikely(!msg_isdata(hdr))) {
1588
1580
tipc_set_sk_state(sk, TIPC_DISCONNECTING);
1589
1581
sk->sk_err = EINVAL;
1582
+
sk->sk_state_change(sk);
1590
1583
return true;
1591
1584
}
1592
1585
···
1608
1581
return true;
1609
1582
1610
1583
/* If empty 'ACK-' message, wake up sleeping connect() */
1611
-
if (waitqueue_active(sk_sleep(sk)))
1612
-
wake_up_interruptible(sk_sleep(sk));
1584
+
sk->sk_data_ready(sk);
1613
1585
1614
1586
/* 'ACK-' message is neither accepted nor rejected: */
1615
1587
msg_set_dest_droppable(hdr, 1);
+1
-1
net/xfrm/xfrm_input.c
+1
-1
net/xfrm/xfrm_input.c
···
395
395
if (xo)
396
396
xfrm_gro = xo->flags & XFRM_GRO;
397
397
398
-
err = x->inner_mode->afinfo->transport_finish(skb, async);
398
+
err = x->inner_mode->afinfo->transport_finish(skb, xfrm_gro || async);
399
399
if (xfrm_gro) {
400
400
skb_dst_drop(skb);
401
401
gro_cells_receive(&gro_cells, skb);