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 git://git.kernel.org/pub/scm/linux/kernel/git/davem/net

Pull networking fixes from David Miller:

1) Fix leak of unqueued fragments in ipv6 nf_defrag, from Guillaume
Nault.

2) Don't access the DDM interface unless the transceiver implements it
in bnx2x, from Mauro S. M. Rodrigues.

3) Don't double fetch 'len' from userspace in sock_getsockopt(), from
JingYi Hou.

4) Sign extension overflow in lio_core, from Colin Ian King.

5) Various netem bug fixes wrt. corrupted packets from Jakub Kicinski.

6) Fix epollout hang in hvsock, from Sunil Muthuswamy.

7) Fix regression in default fib6_type, from David Ahern.

8) Handle memory limits in tcp_fragment more appropriately, from Eric
Dumazet.

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net: (24 commits)
tcp: refine memory limit test in tcp_fragment()
inet: clear num_timeout reqsk_alloc()
net: mvpp2: debugfs: Add pmap to fs dump
ipv6: Default fib6_type to RTN_UNICAST when not set
net: hns3: Fix inconsistent indenting
net/af_iucv: always register net_device notifier
net/af_iucv: build proper skbs for HiperTransport
net/af_iucv: remove GFP_DMA restriction for HiperTransport
net: dsa: mv88e6xxx: fix shift of FID bits in mv88e6185_g1_vtu_loadpurge()
hvsock: fix epollout hang from race condition
net/udp_gso: Allow TX timestamp with UDP GSO
net: netem: fix use after free and double free with packet corruption
net: netem: fix backlog accounting for corrupted GSO frames
net: lio_core: fix potential sign-extension overflow on large shift
tipc: pass tunnel dev as NULL to udp_tunnel(6)_xmit_skb
ip6_tunnel: allow not to count pkts on tstats by passing dev as NULL
ip_tunnel: allow not to count pkts on tstats by setting skb's dev to NULL
tun: wake up waitqueues after IFF_UP is set
net: remove duplicate fetch in sock_getsockopt
tipc: fix issues with early FAILOVER_MSG from peer
...

Linus Torvalds c356dc4b 121bddf3

+123 -112
+1 -1
drivers/net/dsa/mv88e6xxx/global1_vtu.c
··· 415 415 * VTU DBNum[7:4] are located in VTU Operation 11:8 416 416 */ 417 417 op |= entry->fid & 0x000f; 418 - op |= (entry->fid & 0x00f0) << 8; 418 + op |= (entry->fid & 0x00f0) << 4; 419 419 } 420 420 421 421 return mv88e6xxx_g1_vtu_op(chip, op);
+2 -1
drivers/net/ethernet/broadcom/bnx2x/bnx2x_ethtool.c
··· 1609 1609 } 1610 1610 1611 1611 if (!sff8472_comp || 1612 - (diag_type & SFP_EEPROM_DIAG_ADDR_CHANGE_REQ)) { 1612 + (diag_type & SFP_EEPROM_DIAG_ADDR_CHANGE_REQ) || 1613 + !(diag_type & SFP_EEPROM_DDM_IMPLEMENTED)) { 1613 1614 modinfo->type = ETH_MODULE_SFF_8079; 1614 1615 modinfo->eeprom_len = ETH_MODULE_SFF_8079_LEN; 1615 1616 } else {
+1
drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.h
··· 62 62 #define SFP_EEPROM_DIAG_TYPE_ADDR 0x5c 63 63 #define SFP_EEPROM_DIAG_TYPE_SIZE 1 64 64 #define SFP_EEPROM_DIAG_ADDR_CHANGE_REQ (1<<2) 65 + #define SFP_EEPROM_DDM_IMPLEMENTED (1<<6) 65 66 #define SFP_EEPROM_SFF_8472_COMP_ADDR 0x5e 66 67 #define SFP_EEPROM_SFF_8472_COMP_SIZE 1 67 68
+1 -1
drivers/net/ethernet/cavium/liquidio/lio_core.c
··· 964 964 965 965 if (droq->ops.poll_mode) { 966 966 droq->ops.napi_fn(droq); 967 - oct_priv->napi_mask |= (1 << oq_no); 967 + oct_priv->napi_mask |= BIT_ULL(oq_no); 968 968 } else { 969 969 tasklet_schedule(&oct_priv->droq_tasklet); 970 970 }
+1 -1
drivers/net/ethernet/hisilicon/hns3/hns3_enet.c
··· 3803 3803 ret = hns3_client_start(handle); 3804 3804 if (ret) { 3805 3805 dev_err(priv->dev, "hns3_client_start fail! ret=%d\n", ret); 3806 - goto out_client_start; 3806 + goto out_client_start; 3807 3807 } 3808 3808 3809 3809 hns3_dcbnl_setup(handle);
+3
drivers/net/ethernet/marvell/mvpp2/mvpp2_debugfs.c
··· 566 566 debugfs_create_file("hits", 0444, prs_entry_dir, entry, 567 567 &mvpp2_dbgfs_prs_hits_fops); 568 568 569 + debugfs_create_file("pmap", 0444, prs_entry_dir, entry, 570 + &mvpp2_dbgfs_prs_pmap_fops); 571 + 569 572 return 0; 570 573 } 571 574
+9 -10
drivers/net/tun.c
··· 1014 1014 /* Net device open. */ 1015 1015 static int tun_net_open(struct net_device *dev) 1016 1016 { 1017 - struct tun_struct *tun = netdev_priv(dev); 1018 - int i; 1019 - 1020 1017 netif_tx_start_all_queues(dev); 1021 - 1022 - for (i = 0; i < tun->numqueues; i++) { 1023 - struct tun_file *tfile; 1024 - 1025 - tfile = rtnl_dereference(tun->tfiles[i]); 1026 - tfile->socket.sk->sk_write_space(tfile->socket.sk); 1027 - } 1028 1018 1029 1019 return 0; 1030 1020 } ··· 3624 3634 { 3625 3635 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 3626 3636 struct tun_struct *tun = netdev_priv(dev); 3637 + int i; 3627 3638 3628 3639 if (dev->rtnl_link_ops != &tun_link_ops) 3629 3640 return NOTIFY_DONE; ··· 3633 3642 case NETDEV_CHANGE_TX_QUEUE_LEN: 3634 3643 if (tun_queue_resize(tun)) 3635 3644 return NOTIFY_BAD; 3645 + break; 3646 + case NETDEV_UP: 3647 + for (i = 0; i < tun->numqueues; i++) { 3648 + struct tun_file *tfile; 3649 + 3650 + tfile = rtnl_dereference(tun->tfiles[i]); 3651 + tfile->socket.sk->sk_write_space(tfile->socket.sk); 3652 + } 3636 3653 break; 3637 3654 default: 3638 3655 break;
+6 -3
include/net/ip6_tunnel.h
··· 158 158 memset(skb->cb, 0, sizeof(struct inet6_skb_parm)); 159 159 pkt_len = skb->len - skb_inner_network_offset(skb); 160 160 err = ip6_local_out(dev_net(skb_dst(skb)->dev), sk, skb); 161 - if (unlikely(net_xmit_eval(err))) 162 - pkt_len = -1; 163 - iptunnel_xmit_stats(dev, pkt_len); 161 + 162 + if (dev) { 163 + if (unlikely(net_xmit_eval(err))) 164 + pkt_len = -1; 165 + iptunnel_xmit_stats(dev, pkt_len); 166 + } 164 167 } 165 168 #endif 166 169 #endif
+3
include/net/request_sock.h
··· 97 97 sk_node_init(&req_to_sk(req)->sk_node); 98 98 sk_tx_queue_clear(req_to_sk(req)); 99 99 req->saved_syn = NULL; 100 + req->num_timeout = 0; 101 + req->num_retrans = 0; 102 + req->sk = NULL; 100 103 refcount_set(&req->rsk_refcnt, 0); 101 104 102 105 return req;
-3
net/core/sock.c
··· 1477 1477 { 1478 1478 u32 meminfo[SK_MEMINFO_VARS]; 1479 1479 1480 - if (get_user(len, optlen)) 1481 - return -EFAULT; 1482 - 1483 1480 sk_get_meminfo(sk, meminfo); 1484 1481 1485 1482 len = min_t(unsigned int, len, sizeof(meminfo));
-4
net/ipv4/inet_connection_sock.c
··· 752 752 static void reqsk_queue_hash_req(struct request_sock *req, 753 753 unsigned long timeout) 754 754 { 755 - req->num_retrans = 0; 756 - req->num_timeout = 0; 757 - req->sk = NULL; 758 - 759 755 timer_setup(&req->rsk_timer, reqsk_timer_handler, TIMER_PINNED); 760 756 mod_timer(&req->rsk_timer, jiffies + timeout); 761 757
+6 -3
net/ipv4/ip_tunnel_core.c
··· 76 76 __ip_select_ident(net, iph, skb_shinfo(skb)->gso_segs ?: 1); 77 77 78 78 err = ip_local_out(net, sk, skb); 79 - if (unlikely(net_xmit_eval(err))) 80 - pkt_len = 0; 81 - iptunnel_xmit_stats(dev, pkt_len); 79 + 80 + if (dev) { 81 + if (unlikely(net_xmit_eval(err))) 82 + pkt_len = 0; 83 + iptunnel_xmit_stats(dev, pkt_len); 84 + } 82 85 } 83 86 EXPORT_SYMBOL_GPL(iptunnel_xmit); 84 87
-4
net/ipv4/tcp_fastopen.c
··· 221 221 struct sock *child; 222 222 bool own_req; 223 223 224 - req->num_retrans = 0; 225 - req->num_timeout = 0; 226 - req->sk = NULL; 227 - 228 224 child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, req, NULL, 229 225 NULL, &own_req); 230 226 if (!child)
+2 -1
net/ipv4/tcp_output.c
··· 1296 1296 if (nsize < 0) 1297 1297 nsize = 0; 1298 1298 1299 - if (unlikely((sk->sk_wmem_queued >> 1) > sk->sk_sndbuf)) { 1299 + if (unlikely((sk->sk_wmem_queued >> 1) > sk->sk_sndbuf && 1300 + tcp_queue != TCP_FRAG_IN_WRITE_QUEUE)) { 1300 1301 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPWQUEUETOOBIG); 1301 1302 return -ENOMEM; 1302 1303 }
+5
net/ipv4/udp_offload.c
··· 224 224 seg = segs; 225 225 uh = udp_hdr(seg); 226 226 227 + /* preserve TX timestamp flags and TS key for first segment */ 228 + skb_shinfo(seg)->tskey = skb_shinfo(gso_skb)->tskey; 229 + skb_shinfo(seg)->tx_flags |= 230 + (skb_shinfo(gso_skb)->tx_flags & SKBTX_ANY_TSTAMP); 231 + 227 232 /* compute checksum adjustment based on old length versus new */ 228 233 newlen = htons(sizeof(*uh) + mss); 229 234 check = csum16_add(csum16_sub(uh->check, uh->len), newlen);
+12 -10
net/ipv6/netfilter/nf_conntrack_reasm.c
··· 261 261 262 262 prev = fq->q.fragments_tail; 263 263 err = inet_frag_queue_insert(&fq->q, skb, offset, end); 264 - if (err) 264 + if (err) { 265 + if (err == IPFRAG_DUP) { 266 + /* No error for duplicates, pretend they got queued. */ 267 + kfree_skb(skb); 268 + return -EINPROGRESS; 269 + } 265 270 goto insert_error; 271 + } 266 272 267 273 if (dev) 268 274 fq->iif = dev->ifindex; ··· 295 289 skb->_skb_refdst = 0UL; 296 290 err = nf_ct_frag6_reasm(fq, skb, prev, dev); 297 291 skb->_skb_refdst = orefdst; 298 - return err; 292 + 293 + /* After queue has assumed skb ownership, only 0 or 294 + * -EINPROGRESS must be returned. 295 + */ 296 + return err ? -EINPROGRESS : 0; 299 297 } 300 298 301 299 skb_dst_drop(skb); 302 300 return -EINPROGRESS; 303 301 304 302 insert_error: 305 - if (err == IPFRAG_DUP) 306 - goto err; 307 303 inet_frag_kill(&fq->q); 308 304 err: 309 305 skb_dst_drop(skb); ··· 483 475 skb->transport_header = savethdr; 484 476 ret = 0; 485 477 } 486 - 487 - /* after queue has assumed skb ownership, only 0 or -EINPROGRESS 488 - * must be returned. 489 - */ 490 - if (ret) 491 - ret = -EINPROGRESS; 492 478 493 479 spin_unlock_bh(&fq->q.lock); 494 480 inet_frag_put(&fq->q);
+1 -1
net/ipv6/route.c
··· 3184 3184 3185 3185 rt->fib6_table = table; 3186 3186 rt->fib6_metric = cfg->fc_metric; 3187 - rt->fib6_type = cfg->fc_type; 3187 + rt->fib6_type = cfg->fc_type ? : RTN_UNICAST; 3188 3188 rt->fib6_flags = cfg->fc_flags & ~RTF_GATEWAY; 3189 3189 3190 3190 ipv6_addr_prefix(&rt->fib6_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
+36 -13
net/iucv/af_iucv.c
··· 14 14 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 15 15 16 16 #include <linux/module.h> 17 + #include <linux/netdevice.h> 17 18 #include <linux/types.h> 18 19 #include <linux/list.h> 19 20 #include <linux/errno.h> ··· 348 347 if (imsg) 349 348 memcpy(&phs_hdr->iucv_hdr, imsg, sizeof(struct iucv_message)); 350 349 351 - skb_push(skb, ETH_HLEN); 352 - memset(skb->data, 0, ETH_HLEN); 353 - 354 350 skb->dev = iucv->hs_dev; 355 351 if (!skb->dev) { 356 352 err = -ENODEV; 357 353 goto err_free; 358 354 } 355 + 356 + dev_hard_header(skb, skb->dev, ETH_P_AF_IUCV, NULL, NULL, skb->len); 357 + 359 358 if (!(skb->dev->flags & IFF_UP) || !netif_carrier_ok(skb->dev)) { 360 359 err = -ENETDOWN; 361 360 goto err_free; ··· 368 367 skb_trim(skb, skb->dev->mtu); 369 368 } 370 369 skb->protocol = cpu_to_be16(ETH_P_AF_IUCV); 370 + 371 + __skb_header_release(skb); 371 372 nskb = skb_clone(skb, GFP_ATOMIC); 372 373 if (!nskb) { 373 374 err = -ENOMEM; ··· 469 466 /* Send controlling flags through an IUCV socket for HIPER transport */ 470 467 static int iucv_send_ctrl(struct sock *sk, u8 flags) 471 468 { 469 + struct iucv_sock *iucv = iucv_sk(sk); 472 470 int err = 0; 473 471 int blen; 474 472 struct sk_buff *skb; 475 473 u8 shutdown = 0; 476 474 477 - blen = sizeof(struct af_iucv_trans_hdr) + ETH_HLEN; 475 + blen = sizeof(struct af_iucv_trans_hdr) + 476 + LL_RESERVED_SPACE(iucv->hs_dev); 478 477 if (sk->sk_shutdown & SEND_SHUTDOWN) { 479 478 /* controlling flags should be sent anyway */ 480 479 shutdown = sk->sk_shutdown; ··· 593 588 594 589 sk->sk_destruct = iucv_sock_destruct; 595 590 sk->sk_sndtimeo = IUCV_CONN_TIMEOUT; 596 - sk->sk_allocation = GFP_DMA; 597 591 598 592 sock_reset_flag(sk, SOCK_ZAPPED); 599 593 ··· 786 782 memcpy(iucv->src_user_id, iucv_userid, 8); 787 783 sk->sk_state = IUCV_BOUND; 788 784 iucv->transport = AF_IUCV_TRANS_IUCV; 785 + sk->sk_allocation |= GFP_DMA; 789 786 if (!iucv->msglimit) 790 787 iucv->msglimit = IUCV_QUEUELEN_DEFAULT; 791 788 goto done_unlock; ··· 811 806 return -EPROTO; 812 807 813 808 memcpy(iucv->src_user_id, iucv_userid, 8); 809 + iucv->transport = AF_IUCV_TRANS_IUCV; 810 + sk->sk_allocation |= GFP_DMA; 814 811 815 812 write_lock_bh(&iucv_sk_list.lock); 816 813 __iucv_auto_name(iucv); ··· 1138 1131 * segmented records using the MSG_EOR flag), but 1139 1132 * for SOCK_STREAM we might want to improve it in future */ 1140 1133 if (iucv->transport == AF_IUCV_TRANS_HIPER) { 1141 - headroom = sizeof(struct af_iucv_trans_hdr) + ETH_HLEN; 1134 + headroom = sizeof(struct af_iucv_trans_hdr) + 1135 + LL_RESERVED_SPACE(iucv->hs_dev); 1142 1136 linear = len; 1143 1137 } else { 1144 1138 if (len < PAGE_SIZE) { ··· 1789 1781 1790 1782 niucv = iucv_sk(nsk); 1791 1783 iucv_sock_init(nsk, sk); 1784 + niucv->transport = AF_IUCV_TRANS_IUCV; 1785 + nsk->sk_allocation |= GFP_DMA; 1792 1786 1793 1787 /* Set the new iucv_sock */ 1794 1788 memcpy(niucv->dst_name, ipuser + 8, 8); ··· 2440 2430 return err; 2441 2431 } 2442 2432 2433 + static void afiucv_iucv_exit(void) 2434 + { 2435 + device_unregister(af_iucv_dev); 2436 + driver_unregister(&af_iucv_driver); 2437 + pr_iucv->iucv_unregister(&af_iucv_handler, 0); 2438 + } 2439 + 2443 2440 static int __init afiucv_init(void) 2444 2441 { 2445 2442 int err; ··· 2480 2463 err = afiucv_iucv_init(); 2481 2464 if (err) 2482 2465 goto out_sock; 2483 - } else 2484 - register_netdevice_notifier(&afiucv_netdev_notifier); 2466 + } 2467 + 2468 + err = register_netdevice_notifier(&afiucv_netdev_notifier); 2469 + if (err) 2470 + goto out_notifier; 2471 + 2485 2472 dev_add_pack(&iucv_packet_type); 2486 2473 return 0; 2487 2474 2475 + out_notifier: 2476 + if (pr_iucv) 2477 + afiucv_iucv_exit(); 2488 2478 out_sock: 2489 2479 sock_unregister(PF_IUCV); 2490 2480 out_proto: ··· 2505 2481 static void __exit afiucv_exit(void) 2506 2482 { 2507 2483 if (pr_iucv) { 2508 - device_unregister(af_iucv_dev); 2509 - driver_unregister(&af_iucv_driver); 2510 - pr_iucv->iucv_unregister(&af_iucv_handler, 0); 2484 + afiucv_iucv_exit(); 2511 2485 symbol_put(iucv_if); 2512 - } else 2513 - unregister_netdevice_notifier(&afiucv_netdev_notifier); 2486 + } 2487 + 2488 + unregister_netdevice_notifier(&afiucv_netdev_notifier); 2514 2489 dev_remove_pack(&iucv_packet_type); 2515 2490 sock_unregister(PF_IUCV); 2516 2491 proto_unregister(&iucv_proto);
+1 -2
net/netfilter/nft_masq.c
··· 304 304 305 305 MODULE_LICENSE("GPL"); 306 306 MODULE_AUTHOR("Arturo Borrero Gonzalez <arturo@debian.org>"); 307 - MODULE_ALIAS_NFT_AF_EXPR(AF_INET6, "masq"); 308 - MODULE_ALIAS_NFT_AF_EXPR(AF_INET, "masq"); 307 + MODULE_ALIAS_NFT_EXPR("masq");
+1 -2
net/netfilter/nft_redir.c
··· 291 291 292 292 MODULE_LICENSE("GPL"); 293 293 MODULE_AUTHOR("Arturo Borrero Gonzalez <arturo@debian.org>"); 294 - MODULE_ALIAS_NFT_AF_EXPR(AF_INET, "redir"); 295 - MODULE_ALIAS_NFT_AF_EXPR(AF_INET6, "redir"); 294 + MODULE_ALIAS_NFT_EXPR("nat");
+14 -12
net/sched/sch_netem.c
··· 439 439 struct netem_skb_cb *cb; 440 440 struct sk_buff *skb2; 441 441 struct sk_buff *segs = NULL; 442 - unsigned int len = 0, last_len, prev_len = qdisc_pkt_len(skb); 443 - int nb = 0; 442 + unsigned int prev_len = qdisc_pkt_len(skb); 444 443 int count = 1; 445 444 int rc = NET_XMIT_SUCCESS; 446 445 int rc_drop = NET_XMIT_DROP; ··· 493 494 */ 494 495 if (q->corrupt && q->corrupt >= get_crandom(&q->corrupt_cor)) { 495 496 if (skb_is_gso(skb)) { 496 - segs = netem_segment(skb, sch, to_free); 497 - if (!segs) 497 + skb = netem_segment(skb, sch, to_free); 498 + if (!skb) 498 499 return rc_drop; 499 - } else { 500 - segs = skb; 500 + segs = skb->next; 501 + skb_mark_not_on_list(skb); 502 + qdisc_skb_cb(skb)->pkt_len = skb->len; 501 503 } 502 - 503 - skb = segs; 504 - segs = segs->next; 505 504 506 505 skb = skb_unshare(skb, GFP_ATOMIC); 507 506 if (unlikely(!skb)) { ··· 517 520 } 518 521 519 522 if (unlikely(sch->q.qlen >= sch->limit)) { 523 + /* re-link segs, so that qdisc_drop_all() frees them all */ 524 + skb->next = segs; 520 525 qdisc_drop_all(skb, sch, to_free); 521 526 return rc_drop; 522 527 } ··· 592 593 593 594 finish_segs: 594 595 if (segs) { 596 + unsigned int len, last_len; 597 + int nb = 0; 598 + 599 + len = skb->len; 600 + 595 601 while (segs) { 596 602 skb2 = segs->next; 597 603 skb_mark_not_on_list(segs); ··· 612 608 } 613 609 segs = skb2; 614 610 } 615 - sch->q.qlen += nb; 616 - if (nb > 1) 617 - qdisc_tree_reduce_backlog(sch, 1 - nb, prev_len - len); 611 + qdisc_tree_reduce_backlog(sch, -nb, prev_len - len); 618 612 } 619 613 return NET_XMIT_SUCCESS; 620 614 }
-1
net/tipc/link.c
··· 1728 1728 * node has entered SELF_DOWN_PEER_LEAVING and both peer nodes 1729 1729 * would have to start over from scratch instead. 1730 1730 */ 1731 - WARN_ON(l && tipc_link_is_up(l)); 1732 1731 tnl->drop_point = 1; 1733 1732 tnl->failover_reasm_skb = NULL; 1734 1733
+7 -3
net/tipc/node.c
··· 766 766 * disturbance, wrong session, etc.) 767 767 * 3. Link <1B-2B> up 768 768 * 4. Link endpoint 2A down (e.g. due to link tolerance timeout) 769 - * 5. Node B starts failover onto link <1B-2B> 769 + * 5. Node 2 starts failover onto link <1B-2B> 770 770 * 771 - * ==> Node A does never start link/node failover! 771 + * ==> Node 1 does never start link/node failover! 772 772 * 773 773 * @n: tipc node structure 774 774 * @l: link peer endpoint failingover (- can be NULL) ··· 781 781 { 782 782 /* Avoid to be "self-failover" that can never end */ 783 783 if (!tipc_link_is_up(tnl)) 784 + return; 785 + 786 + /* Don't rush, failure link may be in the process of resetting */ 787 + if (l && !tipc_link_is_reset(l)) 784 788 return; 785 789 786 790 tipc_link_fsm_evt(tnl, LINK_SYNCH_END_EVT); ··· 1710 1706 /* Initiate or update failover mode if applicable */ 1711 1707 if ((usr == TUNNEL_PROTOCOL) && (mtyp == FAILOVER_MSG)) { 1712 1708 syncpt = oseqno + exp_pkts - 1; 1713 - if (pl && tipc_link_is_up(pl)) { 1709 + if (pl && !tipc_link_is_reset(pl)) { 1714 1710 __tipc_node_link_down(n, &pb_id, xmitq, &maddr); 1715 1711 trace_tipc_node_link_down(n, true, 1716 1712 "node link down <- failover!");
+3 -5
net/tipc/udp_media.c
··· 176 176 goto tx_error; 177 177 } 178 178 179 - skb->dev = rt->dst.dev; 180 179 ttl = ip4_dst_hoplimit(&rt->dst); 181 180 udp_tunnel_xmit_skb(rt, ub->ubsock->sk, skb, src->ipv4.s_addr, 182 181 dst->ipv4.s_addr, 0, ttl, 0, src->port, ··· 194 195 if (err) 195 196 goto tx_error; 196 197 ttl = ip6_dst_hoplimit(ndst); 197 - err = udp_tunnel6_xmit_skb(ndst, ub->ubsock->sk, skb, 198 - ndst->dev, &src->ipv6, 199 - &dst->ipv6, 0, ttl, 0, src->port, 200 - dst->port, false); 198 + err = udp_tunnel6_xmit_skb(ndst, ub->ubsock->sk, skb, NULL, 199 + &src->ipv6, &dst->ipv6, 0, ttl, 0, 200 + src->port, dst->port, false); 201 201 #endif 202 202 } 203 203 return err;
+8 -31
net/vmw_vsock/hyperv_transport.c
··· 211 211 set_channel_pending_send_size(chan, 212 212 HVS_PKT_LEN(HVS_SEND_BUF_SIZE)); 213 213 214 - /* See hvs_stream_has_space(): we must make sure the host has seen 215 - * the new pending send size, before we can re-check the writable 216 - * bytes. 217 - */ 218 - virt_mb(); 219 - } 220 - 221 - static void hvs_clear_channel_pending_send_size(struct vmbus_channel *chan) 222 - { 223 - set_channel_pending_send_size(chan, 0); 224 - 225 - /* Ditto */ 226 214 virt_mb(); 227 215 } 228 216 ··· 280 292 if (hvs_channel_readable(chan)) 281 293 sk->sk_data_ready(sk); 282 294 283 - /* See hvs_stream_has_space(): when we reach here, the writable bytes 284 - * may be already less than HVS_PKT_LEN(HVS_SEND_BUF_SIZE). 285 - */ 286 295 if (hv_get_bytes_to_write(&chan->outbound) > 0) 287 296 sk->sk_write_space(sk); 288 297 } ··· 379 394 380 395 set_per_channel_state(chan, conn_from_host ? new : sk); 381 396 vmbus_set_chn_rescind_callback(chan, hvs_close_connection); 397 + 398 + /* Set the pending send size to max packet size to always get 399 + * notifications from the host when there is enough writable space. 400 + * The host is optimized to send notifications only when the pending 401 + * size boundary is crossed, and not always. 402 + */ 403 + hvs_set_channel_pending_send_size(chan); 382 404 383 405 if (conn_from_host) { 384 406 new->sk_state = TCP_ESTABLISHED; ··· 680 688 static s64 hvs_stream_has_space(struct vsock_sock *vsk) 681 689 { 682 690 struct hvsock *hvs = vsk->trans; 683 - struct vmbus_channel *chan = hvs->chan; 684 - s64 ret; 685 691 686 - ret = hvs_channel_writable_bytes(chan); 687 - if (ret > 0) { 688 - hvs_clear_channel_pending_send_size(chan); 689 - } else { 690 - /* See hvs_channel_cb() */ 691 - hvs_set_channel_pending_send_size(chan); 692 - 693 - /* Re-check the writable bytes to avoid race */ 694 - ret = hvs_channel_writable_bytes(chan); 695 - if (ret > 0) 696 - hvs_clear_channel_pending_send_size(chan); 697 - } 698 - 699 - return ret; 692 + return hvs_channel_writable_bytes(hvs->chan); 700 693 } 701 694 702 695 static u64 hvs_stream_rcvhiwat(struct vsock_sock *vsk)