From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from lists.gentoo.org (pigeon.gentoo.org [208.92.234.80]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by finch.gentoo.org (Postfix) with ESMTPS id 8AB0A138334 for ; Sat, 23 Feb 2019 14:40:58 +0000 (UTC) Received: from pigeon.gentoo.org (localhost [127.0.0.1]) by pigeon.gentoo.org (Postfix) with SMTP id 834EFE092C; Sat, 23 Feb 2019 14:40:57 +0000 (UTC) Received: from smtp.gentoo.org (smtp.gentoo.org [140.211.166.183]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by pigeon.gentoo.org (Postfix) with ESMTPS id 4EF58E092C for ; Sat, 23 Feb 2019 14:40:57 +0000 (UTC) Received: from oystercatcher.gentoo.org (unknown [IPv6:2a01:4f8:202:4333:225:90ff:fed9:fc84]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id 9D49133BEB8 for ; Sat, 23 Feb 2019 14:40:55 +0000 (UTC) Received: from localhost.localdomain (localhost [IPv6:::1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id B567B54A for ; Sat, 23 Feb 2019 14:40:53 +0000 (UTC) From: "Mike Pagano" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Mike Pagano" Message-ID: <1550932832.29eec363a56cc46e3f5f2891fdacf07cd66d115d.mpagano@gentoo> Subject: [gentoo-commits] proj/linux-patches:4.4 commit in: / X-VCS-Repository: proj/linux-patches X-VCS-Files: 0000_README 1175_linux-4.4.176.patch X-VCS-Directories: / X-VCS-Committer: mpagano X-VCS-Committer-Name: Mike Pagano X-VCS-Revision: 29eec363a56cc46e3f5f2891fdacf07cd66d115d X-VCS-Branch: 4.4 Date: Sat, 23 Feb 2019 14:40:53 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Auto-Response-Suppress: DR, RN, NRN, OOF, AutoReply X-Archives-Salt: 0b4d3866-4e13-463d-804d-23c5e55db651 X-Archives-Hash: aea6a8602442810271c34c0aef18fc94 commit: 29eec363a56cc46e3f5f2891fdacf07cd66d115d Author: Mike Pagano gentoo org> AuthorDate: Sat Feb 23 14:40:32 2019 +0000 Commit: Mike Pagano gentoo org> CommitDate: Sat Feb 23 14:40:32 2019 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=29eec363 proj/linux-patches: Linux patch 4.4.176 Signed-off-by: Mike Pagano gentoo.org> 0000_README | 4 + 1175_linux-4.4.176.patch | 597 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 601 insertions(+) diff --git a/0000_README b/0000_README index ac4792e..f0602c1 100644 --- a/0000_README +++ b/0000_README @@ -743,6 +743,10 @@ Patch: 1174_linux-4.4.175.patch From: http://www.kernel.org Desc: Linux 4.4.175 +Patch: 1175_linux-4.4.176.patch +From: http://www.kernel.org +Desc: Linux 4.4.176 + Patch: 1500_XATTR_USER_PREFIX.patch From: https://bugs.gentoo.org/show_bug.cgi?id=470644 Desc: Support for namespace user.pax.* on tmpfs. diff --git a/1175_linux-4.4.176.patch b/1175_linux-4.4.176.patch new file mode 100644 index 0000000..1bac36a --- /dev/null +++ b/1175_linux-4.4.176.patch @@ -0,0 +1,597 @@ +diff --git a/Makefile b/Makefile +index 5f0bdef2af99..d7a3b832e0fd 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,6 +1,6 @@ + VERSION = 4 + PATCHLEVEL = 4 +-SUBLEVEL = 175 ++SUBLEVEL = 176 + EXTRAVERSION = + NAME = Blurry Fish Butt + +diff --git a/arch/x86/kernel/livepatch.c b/arch/x86/kernel/livepatch.c +index d1d35ccffed3..579f8f813ce0 100644 +--- a/arch/x86/kernel/livepatch.c ++++ b/arch/x86/kernel/livepatch.c +@@ -58,6 +58,7 @@ int klp_write_module_reloc(struct module *mod, unsigned long type, + val = (s32)value; + break; + case R_X86_64_PC32: ++ case R_X86_64_PLT32: + val = (u32)(value - loc); + break; + default: +diff --git a/arch/x86/kvm/vmx.c b/arch/x86/kvm/vmx.c +index aee2886a387c..14553f6c03a6 100644 +--- a/arch/x86/kvm/vmx.c ++++ b/arch/x86/kvm/vmx.c +@@ -4628,7 +4628,9 @@ static u8 vmx_msr_bitmap_mode(struct kvm_vcpu *vcpu) + { + u8 mode = 0; + +- if (irqchip_in_kernel(vcpu->kvm) && apic_x2apic_mode(vcpu->arch.apic)) { ++ if (cpu_has_secondary_exec_ctrls() && ++ (vmcs_read32(SECONDARY_VM_EXEC_CONTROL) & ++ SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE)) { + mode |= MSR_BITMAP_MODE_X2APIC; + if (enable_apicv) + mode |= MSR_BITMAP_MODE_X2APIC_APICV; +diff --git a/drivers/hwmon/lm80.c b/drivers/hwmon/lm80.c +index cb6606a0470d..be60bd5bab78 100644 +--- a/drivers/hwmon/lm80.c ++++ b/drivers/hwmon/lm80.c +@@ -393,8 +393,10 @@ static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr, + } + + rv = lm80_read_value(client, LM80_REG_FANDIV); +- if (rv < 0) ++ if (rv < 0) { ++ mutex_unlock(&data->update_lock); + return rv; ++ } + reg = (rv & ~(3 << (2 * (nr + 1)))) + | (data->fan_div[nr] << (2 * (nr + 1))); + lm80_write_value(client, LM80_REG_FANDIV, reg); +diff --git a/drivers/isdn/mISDN/timerdev.c b/drivers/isdn/mISDN/timerdev.c +index 9438d7ec3308..8b29e97cf668 100644 +--- a/drivers/isdn/mISDN/timerdev.c ++++ b/drivers/isdn/mISDN/timerdev.c +@@ -168,8 +168,8 @@ dev_expire_timer(unsigned long data) + spin_lock_irqsave(&timer->dev->lock, flags); + if (timer->id >= 0) + list_move_tail(&timer->list, &timer->dev->expired); +- spin_unlock_irqrestore(&timer->dev->lock, flags); + wake_up_interruptible(&timer->dev->wait); ++ spin_unlock_irqrestore(&timer->dev->lock, flags); + } + + static int +diff --git a/drivers/mfd/as3722.c b/drivers/mfd/as3722.c +index 924ea90494ae..e1f597f97f86 100644 +--- a/drivers/mfd/as3722.c ++++ b/drivers/mfd/as3722.c +@@ -405,6 +405,8 @@ static int as3722_i2c_probe(struct i2c_client *i2c, + goto scrub; + } + ++ device_init_wakeup(as3722->dev, true); ++ + dev_dbg(as3722->dev, "AS3722 core driver initialized successfully\n"); + return 0; + +@@ -422,6 +424,29 @@ static int as3722_i2c_remove(struct i2c_client *i2c) + return 0; + } + ++static int __maybe_unused as3722_i2c_suspend(struct device *dev) ++{ ++ struct as3722 *as3722 = dev_get_drvdata(dev); ++ ++ if (device_may_wakeup(dev)) ++ enable_irq_wake(as3722->chip_irq); ++ disable_irq(as3722->chip_irq); ++ ++ return 0; ++} ++ ++static int __maybe_unused as3722_i2c_resume(struct device *dev) ++{ ++ struct as3722 *as3722 = dev_get_drvdata(dev); ++ ++ enable_irq(as3722->chip_irq); ++ ++ if (device_may_wakeup(dev)) ++ disable_irq_wake(as3722->chip_irq); ++ ++ return 0; ++} ++ + static const struct of_device_id as3722_of_match[] = { + { .compatible = "ams,as3722", }, + {}, +@@ -434,10 +459,15 @@ static const struct i2c_device_id as3722_i2c_id[] = { + }; + MODULE_DEVICE_TABLE(i2c, as3722_i2c_id); + ++static const struct dev_pm_ops as3722_pm_ops = { ++ SET_SYSTEM_SLEEP_PM_OPS(as3722_i2c_suspend, as3722_i2c_resume) ++}; ++ + static struct i2c_driver as3722_i2c_driver = { + .driver = { + .name = "as3722", + .of_match_table = as3722_of_match, ++ .pm = &as3722_pm_ops, + }, + .probe = as3722_i2c_probe, + .remove = as3722_i2c_remove, +diff --git a/drivers/net/ethernet/marvell/sky2.c b/drivers/net/ethernet/marvell/sky2.c +index 6e5065f0907b..4b97aa24559a 100644 +--- a/drivers/net/ethernet/marvell/sky2.c ++++ b/drivers/net/ethernet/marvell/sky2.c +@@ -5079,7 +5079,7 @@ static int sky2_probe(struct pci_dev *pdev, const struct pci_device_id *ent) + INIT_WORK(&hw->restart_work, sky2_restart); + + pci_set_drvdata(pdev, hw); +- pdev->d3_delay = 200; ++ pdev->d3_delay = 300; + + return 0; + +diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_ethtool.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_ethtool.c +index 2e51b816a7e8..fbf701e5f1e9 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_ethtool.c ++++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_ethtool.c +@@ -614,25 +614,27 @@ static int stmmac_ethtool_op_set_eee(struct net_device *dev, + struct ethtool_eee *edata) + { + struct stmmac_priv *priv = netdev_priv(dev); ++ int ret; + +- priv->eee_enabled = edata->eee_enabled; +- +- if (!priv->eee_enabled) ++ if (!edata->eee_enabled) { + stmmac_disable_eee_mode(priv); +- else { ++ } else { + /* We are asking for enabling the EEE but it is safe + * to verify all by invoking the eee_init function. + * In case of failure it will return an error. + */ +- priv->eee_enabled = stmmac_eee_init(priv); +- if (!priv->eee_enabled) ++ edata->eee_enabled = stmmac_eee_init(priv); ++ if (!edata->eee_enabled) + return -EOPNOTSUPP; +- +- /* Do not change tx_lpi_timer in case of failure */ +- priv->tx_lpi_timer = edata->tx_lpi_timer; + } + +- return phy_ethtool_set_eee(priv->phydev, edata); ++ ret = phy_ethtool_set_eee(dev->phydev, edata); ++ if (ret) ++ return ret; ++ ++ priv->eee_enabled = edata->eee_enabled; ++ priv->tx_lpi_timer = edata->tx_lpi_timer; ++ return 0; + } + + static u32 stmmac_usec2riwt(u32 usec, struct stmmac_priv *priv) +diff --git a/drivers/net/vxlan.c b/drivers/net/vxlan.c +index c41378214ede..553908adf3c5 100644 +--- a/drivers/net/vxlan.c ++++ b/drivers/net/vxlan.c +@@ -1881,7 +1881,7 @@ static void vxlan_encap_bypass(struct sk_buff *skb, struct vxlan_dev *src_vxlan, + struct pcpu_sw_netstats *tx_stats, *rx_stats; + union vxlan_addr loopback; + union vxlan_addr *remote_ip = &dst_vxlan->default_dst.remote_ip; +- struct net_device *dev = skb->dev; ++ struct net_device *dev; + int len = skb->len; + + tx_stats = this_cpu_ptr(src_vxlan->dev->tstats); +@@ -1901,8 +1901,15 @@ static void vxlan_encap_bypass(struct sk_buff *skb, struct vxlan_dev *src_vxlan, + #endif + } + ++ rcu_read_lock(); ++ dev = skb->dev; ++ if (unlikely(!(dev->flags & IFF_UP))) { ++ kfree_skb(skb); ++ goto drop; ++ } ++ + if (dst_vxlan->flags & VXLAN_F_LEARN) +- vxlan_snoop(skb->dev, &loopback, eth_hdr(skb)->h_source); ++ vxlan_snoop(dev, &loopback, eth_hdr(skb)->h_source); + + u64_stats_update_begin(&tx_stats->syncp); + tx_stats->tx_packets++; +@@ -1915,8 +1922,10 @@ static void vxlan_encap_bypass(struct sk_buff *skb, struct vxlan_dev *src_vxlan, + rx_stats->rx_bytes += len; + u64_stats_update_end(&rx_stats->syncp); + } else { ++drop: + dev->stats.rx_dropped++; + } ++ rcu_read_unlock(); + } + + static void vxlan_xmit_one(struct sk_buff *skb, struct net_device *dev, +diff --git a/include/linux/netdev_features.h b/include/linux/netdev_features.h +index f0d87347df19..0508fcc67480 100644 +--- a/include/linux/netdev_features.h ++++ b/include/linux/netdev_features.h +@@ -11,6 +11,8 @@ + #define _LINUX_NETDEV_FEATURES_H + + #include ++#include ++#include + + typedef u64 netdev_features_t; + +@@ -125,8 +127,26 @@ enum { + #define NETIF_F_HW_L2FW_DOFFLOAD __NETIF_F(HW_L2FW_DOFFLOAD) + #define NETIF_F_BUSY_POLL __NETIF_F(BUSY_POLL) + +-#define for_each_netdev_feature(mask_addr, bit) \ +- for_each_set_bit(bit, (unsigned long *)mask_addr, NETDEV_FEATURE_COUNT) ++/* Finds the next feature with the highest number of the range of start till 0. ++ */ ++static inline int find_next_netdev_feature(u64 feature, unsigned long start) ++{ ++ /* like BITMAP_LAST_WORD_MASK() for u64 ++ * this sets the most significant 64 - start to 0. ++ */ ++ feature &= ~0ULL >> (-start & ((sizeof(feature) * 8) - 1)); ++ ++ return fls64(feature) - 1; ++} ++ ++/* This goes for the MSB to the LSB through the set feature bits, ++ * mask_addr should be a u64 and bit an int ++ */ ++#define for_each_netdev_feature(mask_addr, bit) \ ++ for ((bit) = find_next_netdev_feature((mask_addr), \ ++ NETDEV_FEATURE_COUNT); \ ++ (bit) >= 0; \ ++ (bit) = find_next_netdev_feature((mask_addr), (bit) - 1)) + + /* Features valid for ethtool to change */ + /* = all defined minus driver/device-class-related */ +diff --git a/include/net/ax25.h b/include/net/ax25.h +index e602f8177ebf..b507ce2b1952 100644 +--- a/include/net/ax25.h ++++ b/include/net/ax25.h +@@ -199,6 +199,18 @@ static inline void ax25_hold_route(ax25_route *ax25_rt) + + void __ax25_put_route(ax25_route *ax25_rt); + ++extern rwlock_t ax25_route_lock; ++ ++static inline void ax25_route_lock_use(void) ++{ ++ read_lock(&ax25_route_lock); ++} ++ ++static inline void ax25_route_lock_unuse(void) ++{ ++ read_unlock(&ax25_route_lock); ++} ++ + static inline void ax25_put_route(ax25_route *ax25_rt) + { + if (atomic_dec_and_test(&ax25_rt->refcount)) +diff --git a/include/net/inetpeer.h b/include/net/inetpeer.h +index 235c7811a86a..408d76f47bd2 100644 +--- a/include/net/inetpeer.h ++++ b/include/net/inetpeer.h +@@ -40,6 +40,7 @@ struct inet_peer { + + u32 metrics[RTAX_MAX]; + u32 rate_tokens; /* rate limiting for ICMP */ ++ u32 n_redirects; + unsigned long rate_last; + union { + struct list_head gc_list; +diff --git a/include/net/tcp.h b/include/net/tcp.h +index a99f75ef6a73..14ec97309581 100644 +--- a/include/net/tcp.h ++++ b/include/net/tcp.h +@@ -1457,6 +1457,7 @@ static inline void tcp_write_queue_purge(struct sock *sk) + sk_wmem_free_skb(sk, skb); + sk_mem_reclaim(sk); + tcp_clear_all_retrans_hints(tcp_sk(sk)); ++ inet_csk(sk)->icsk_backoff = 0; + } + + static inline struct sk_buff *tcp_write_queue_head(const struct sock *sk) +diff --git a/net/ax25/ax25_ip.c b/net/ax25/ax25_ip.c +index 2fa3be965101..cd9a24e5b97a 100644 +--- a/net/ax25/ax25_ip.c ++++ b/net/ax25/ax25_ip.c +@@ -114,6 +114,7 @@ netdev_tx_t ax25_ip_xmit(struct sk_buff *skb) + dst = (ax25_address *)(bp + 1); + src = (ax25_address *)(bp + 8); + ++ ax25_route_lock_use(); + route = ax25_get_route(dst, NULL); + if (route) { + digipeat = route->digipeat; +@@ -206,9 +207,8 @@ netdev_tx_t ax25_ip_xmit(struct sk_buff *skb) + ax25_queue_xmit(skb, dev); + + put: +- if (route) +- ax25_put_route(route); + ++ ax25_route_lock_unuse(); + return NETDEV_TX_OK; + } + +diff --git a/net/ax25/ax25_route.c b/net/ax25/ax25_route.c +index d39097737e38..149f82bd83fd 100644 +--- a/net/ax25/ax25_route.c ++++ b/net/ax25/ax25_route.c +@@ -40,7 +40,7 @@ + #include + + static ax25_route *ax25_route_list; +-static DEFINE_RWLOCK(ax25_route_lock); ++DEFINE_RWLOCK(ax25_route_lock); + + void ax25_rt_device_down(struct net_device *dev) + { +@@ -349,6 +349,7 @@ const struct file_operations ax25_route_fops = { + * Find AX.25 route + * + * Only routes with a reference count of zero can be destroyed. ++ * Must be called with ax25_route_lock read locked. + */ + ax25_route *ax25_get_route(ax25_address *addr, struct net_device *dev) + { +@@ -356,7 +357,6 @@ ax25_route *ax25_get_route(ax25_address *addr, struct net_device *dev) + ax25_route *ax25_def_rt = NULL; + ax25_route *ax25_rt; + +- read_lock(&ax25_route_lock); + /* + * Bind to the physical interface we heard them on, or the default + * route if none is found; +@@ -379,11 +379,6 @@ ax25_route *ax25_get_route(ax25_address *addr, struct net_device *dev) + if (ax25_spe_rt != NULL) + ax25_rt = ax25_spe_rt; + +- if (ax25_rt != NULL) +- ax25_hold_route(ax25_rt); +- +- read_unlock(&ax25_route_lock); +- + return ax25_rt; + } + +@@ -414,9 +409,12 @@ int ax25_rt_autobind(ax25_cb *ax25, ax25_address *addr) + ax25_route *ax25_rt; + int err = 0; + +- if ((ax25_rt = ax25_get_route(addr, NULL)) == NULL) ++ ax25_route_lock_use(); ++ ax25_rt = ax25_get_route(addr, NULL); ++ if (!ax25_rt) { ++ ax25_route_lock_unuse(); + return -EHOSTUNREACH; +- ++ } + if ((ax25->ax25_dev = ax25_dev_ax25dev(ax25_rt->dev)) == NULL) { + err = -EHOSTUNREACH; + goto put; +@@ -451,8 +449,7 @@ int ax25_rt_autobind(ax25_cb *ax25, ax25_address *addr) + } + + put: +- ax25_put_route(ax25_rt); +- ++ ax25_route_lock_unuse(); + return err; + } + +diff --git a/net/core/dev.c b/net/core/dev.c +index e03c1d2f6707..49f78bce5795 100644 +--- a/net/core/dev.c ++++ b/net/core/dev.c +@@ -6421,7 +6421,7 @@ static netdev_features_t netdev_sync_upper_features(struct net_device *lower, + netdev_features_t feature; + int feature_bit; + +- for_each_netdev_feature(&upper_disables, feature_bit) { ++ for_each_netdev_feature(upper_disables, feature_bit) { + feature = __NETIF_F_BIT(feature_bit); + if (!(upper->wanted_features & feature) + && (features & feature)) { +@@ -6441,7 +6441,7 @@ static void netdev_sync_lower_features(struct net_device *upper, + netdev_features_t feature; + int feature_bit; + +- for_each_netdev_feature(&upper_disables, feature_bit) { ++ for_each_netdev_feature(upper_disables, feature_bit) { + feature = __NETIF_F_BIT(feature_bit); + if (!(features & feature) && (lower->features & feature)) { + netdev_dbg(upper, "Disabling feature %pNF on lower dev %s.\n", +diff --git a/net/core/skbuff.c b/net/core/skbuff.c +index fea7c24e99d0..2f63a90065e6 100644 +--- a/net/core/skbuff.c ++++ b/net/core/skbuff.c +@@ -374,6 +374,8 @@ static void *__netdev_alloc_frag(unsigned int fragsz, gfp_t gfp_mask) + */ + void *netdev_alloc_frag(unsigned int fragsz) + { ++ fragsz = SKB_DATA_ALIGN(fragsz); ++ + return __netdev_alloc_frag(fragsz, GFP_ATOMIC | __GFP_COLD); + } + EXPORT_SYMBOL(netdev_alloc_frag); +@@ -387,6 +389,8 @@ static void *__napi_alloc_frag(unsigned int fragsz, gfp_t gfp_mask) + + void *napi_alloc_frag(unsigned int fragsz) + { ++ fragsz = SKB_DATA_ALIGN(fragsz); ++ + return __napi_alloc_frag(fragsz, GFP_ATOMIC | __GFP_COLD); + } + EXPORT_SYMBOL(napi_alloc_frag); +diff --git a/net/ipv4/inetpeer.c b/net/ipv4/inetpeer.c +index 86fa45809540..0c5862914f05 100644 +--- a/net/ipv4/inetpeer.c ++++ b/net/ipv4/inetpeer.c +@@ -448,6 +448,7 @@ relookup: + atomic_set(&p->rid, 0); + p->metrics[RTAX_LOCK-1] = INETPEER_METRICS_NEW; + p->rate_tokens = 0; ++ p->n_redirects = 0; + /* 60*HZ is arbitrary, but chosen enough high so that the first + * calculation of tokens is at its maximum. + */ +diff --git a/net/ipv4/route.c b/net/ipv4/route.c +index 3251dede1815..80ce6b0672d2 100644 +--- a/net/ipv4/route.c ++++ b/net/ipv4/route.c +@@ -876,13 +876,15 @@ void ip_rt_send_redirect(struct sk_buff *skb) + /* No redirected packets during ip_rt_redirect_silence; + * reset the algorithm. + */ +- if (time_after(jiffies, peer->rate_last + ip_rt_redirect_silence)) ++ if (time_after(jiffies, peer->rate_last + ip_rt_redirect_silence)) { + peer->rate_tokens = 0; ++ peer->n_redirects = 0; ++ } + + /* Too many ignored redirects; do not send anything + * set dst.rate_last to the last seen redirected packet. + */ +- if (peer->rate_tokens >= ip_rt_redirect_number) { ++ if (peer->n_redirects >= ip_rt_redirect_number) { + peer->rate_last = jiffies; + goto out_put_peer; + } +@@ -899,6 +901,7 @@ void ip_rt_send_redirect(struct sk_buff *skb) + icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, gw); + peer->rate_last = jiffies; + ++peer->rate_tokens; ++ ++peer->n_redirects; + #ifdef CONFIG_IP_ROUTE_VERBOSE + if (log_martians && + peer->rate_tokens == ip_rt_redirect_number) +diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c +index b7492aabe710..f3a4d2dcbf7a 100644 +--- a/net/ipv4/tcp.c ++++ b/net/ipv4/tcp.c +@@ -2253,7 +2253,6 @@ int tcp_disconnect(struct sock *sk, int flags) + tp->write_seq += tp->max_window + 2; + if (tp->write_seq == 0) + tp->write_seq = 1; +- icsk->icsk_backoff = 0; + tp->snd_cwnd = 2; + icsk->icsk_probes_out = 0; + tp->packets_out = 0; +diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c +index ee8399f11fd0..b3d6b8e77300 100644 +--- a/net/ipv4/tcp_ipv4.c ++++ b/net/ipv4/tcp_ipv4.c +@@ -466,14 +466,15 @@ void tcp_v4_err(struct sk_buff *icmp_skb, u32 info) + if (sock_owned_by_user(sk)) + break; + ++ skb = tcp_write_queue_head(sk); ++ if (WARN_ON_ONCE(!skb)) ++ break; ++ + icsk->icsk_backoff--; + icsk->icsk_rto = tp->srtt_us ? __tcp_set_rto(tp) : + TCP_TIMEOUT_INIT; + icsk->icsk_rto = inet_csk_rto_backoff(icsk, TCP_RTO_MAX); + +- skb = tcp_write_queue_head(sk); +- BUG_ON(!skb); +- + remaining = icsk->icsk_rto - + min(icsk->icsk_rto, + tcp_time_stamp - tcp_skb_timestamp(skb)); +diff --git a/net/ipv6/addrconf.c b/net/ipv6/addrconf.c +index 4dde1e0e7d37..086cdf9f0501 100644 +--- a/net/ipv6/addrconf.c ++++ b/net/ipv6/addrconf.c +@@ -1043,7 +1043,8 @@ check_cleanup_prefix_route(struct inet6_ifaddr *ifp, unsigned long *expires) + list_for_each_entry(ifa, &idev->addr_list, if_list) { + if (ifa == ifp) + continue; +- if (!ipv6_prefix_equal(&ifa->addr, &ifp->addr, ++ if (ifa->prefix_len != ifp->prefix_len || ++ !ipv6_prefix_equal(&ifa->addr, &ifp->addr, + ifp->prefix_len)) + continue; + if (ifa->flags & (IFA_F_PERMANENT | IFA_F_NOPREFIXROUTE)) +diff --git a/net/vmw_vsock/vmci_transport.c b/net/vmw_vsock/vmci_transport.c +index d24773552b64..217810674c35 100644 +--- a/net/vmw_vsock/vmci_transport.c ++++ b/net/vmw_vsock/vmci_transport.c +@@ -1656,6 +1656,10 @@ static void vmci_transport_cleanup(struct work_struct *work) + + static void vmci_transport_destruct(struct vsock_sock *vsk) + { ++ /* transport can be NULL if we hit a failure at init() time */ ++ if (!vmci_trans(vsk)) ++ return; ++ + /* Ensure that the detach callback doesn't use the sk/vsk + * we are about to destruct. + */ +diff --git a/net/x25/af_x25.c b/net/x25/af_x25.c +index c6ab4da4b8e2..8d7b2802d33f 100644 +--- a/net/x25/af_x25.c ++++ b/net/x25/af_x25.c +@@ -352,17 +352,15 @@ static unsigned int x25_new_lci(struct x25_neigh *nb) + unsigned int lci = 1; + struct sock *sk; + +- read_lock_bh(&x25_list_lock); +- +- while ((sk = __x25_find_socket(lci, nb)) != NULL) { ++ while ((sk = x25_find_socket(lci, nb)) != NULL) { + sock_put(sk); + if (++lci == 4096) { + lci = 0; + break; + } ++ cond_resched(); + } + +- read_unlock_bh(&x25_list_lock); + return lci; + } + +diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c +index e4be695eb789..fce48d11ae07 100644 +--- a/virt/kvm/kvm_main.c ++++ b/virt/kvm/kvm_main.c +@@ -2711,14 +2711,15 @@ static int kvm_ioctl_create_device(struct kvm *kvm, + return ret; + } + ++ kvm_get_kvm(kvm); + ret = anon_inode_getfd(ops->name, &kvm_device_fops, dev, O_RDWR | O_CLOEXEC); + if (ret < 0) { ++ kvm_put_kvm(kvm); + ops->destroy(dev); + return ret; + } + + list_add(&dev->vm_node, &kvm->devices); +- kvm_get_kvm(kvm); + cd->fd = ret; + return 0; + }