regmap: fix alignment issue
Subsystems (14)
Sasha Levin
maintainerPATCH 1/27 regmap: fix alignment issue
From: Jens Thoms Toerring <[email protected]>
[ Upstream commit 53d860952c8215cf9ae1ea33409c8cb71ad6ad3d ]
The assembly and disassembly of data to be sent to or received from a device invoke functions regmap_format_XX() and regmap_parse_XX() that extract or insert data items from or into a buffer, using assignments. In some cases the functions are called with a buffer pointer with an odd address. On architectures with strict alignment requirements this can result in a kernel crash. The assignments have been replaced by functions that take alignment into account.
--- drivers/base/regmap/regmap.c | 100 ++++++++++++++++------------------- 1 file changed, 46 insertions(+), 54 deletions(-)
drivers/base/regmap/regmap.c +46 -54
@@ -21,6 +21,7 @@#include <linux/delay.h> #include <linux/log2.h> #include <linux/hwspinlock.h> +#include <asm/unaligned.h> #define CREATE_TRACE_POINTS #include "trace.h"
@@ -232,22 +233,20 @@ static void regmap_format_8(void *buf, unsigned int val, unsigned int shift)static void regmap_format_16_be (void *buf,unsigned int val,unsigned int shift) { -__be16 *b = buf; - - b[0 ] =cpu_to_be16 (val << shift); +put_unaligned_be16 (val << shift, buf); }static void regmap_format_16_le (void *buf,unsigned int val,unsigned int shift) { -__le16 *b = buf; - - b[0 ] =cpu_to_le16 (val << shift); +put_unaligned_le16 (val << shift, buf); }static void regmap_format_16_native (void *buf,unsigned int val,unsigned int shift) { - *(u16 *)buf = val << shift; +u16 v = val << shift; + +memcpy (buf, &v,sizeof (v)); }static void regmap_format_24 (void *buf,unsigned int val,unsigned int shift)
@@ -263,43 +262,39 @@ static void regmap_format_24(void *buf, unsigned int val, unsigned int shift)static void regmap_format_32_be (void *buf,unsigned int val,unsigned int shift) { -__be32 *b = buf; - - b[0 ] =cpu_to_be32 (val << shift); +put_unaligned_be32 (val << shift, buf); }static void regmap_format_32_le (void *buf,unsigned int val,unsigned int shift) { -__le32 *b = buf; - - b[0 ] =cpu_to_le32 (val << shift); +put_unaligned_le32 (val << shift, buf); }static void regmap_format_32_native (void *buf,unsigned int val,unsigned int shift) { - *(u32 *)buf = val << shift; +u32 v = val << shift; + +memcpy (buf, &v,sizeof (v)); }#ifdef CONFIG_64BIT static void regmap_format_64_be (void *buf,unsigned int val,unsigned int shift) { -__be64 *b = buf; - - b[0 ] =cpu_to_be64 ((u64 )val << shift); +put_unaligned_be64 ((u64 ) val << shift, buf); }static void regmap_format_64_le (void *buf,unsigned int val,unsigned int shift) { -__le64 *b = buf; - - b[0 ] =cpu_to_le64 ((u64 )val << shift); +put_unaligned_le64 ((u64 ) val << shift, buf); }static void regmap_format_64_native (void *buf,unsigned int val,unsigned int shift) { - *(u64 *)buf = (u64 )val << shift; +u64 v = (u64 ) val << shift; + +memcpy (buf, &v,sizeof (v)); }#endif
@@ -316,35 +311,34 @@ static unsigned int regmap_parse_8(const void *buf)static unsigned int regmap_parse_16_be (const void *buf) { -const __be16 *b = buf; - -return be16_to_cpu (b[0 ]); +return get_unaligned_be16 (buf); }static unsigned int regmap_parse_16_le (const void *buf) { -const __le16 *b = buf; - -return le16_to_cpu (b[0 ]); +return get_unaligned_le16 (buf); }static void regmap_parse_16_be_inplace (void *buf) { -__be16 *b = buf; +u16 v =get_unaligned_be16 (buf); - b[0 ] =be16_to_cpu (b[0 ]); +memcpy (buf, &v,sizeof (v)); }static void regmap_parse_16_le_inplace (void *buf) { -__le16 *b = buf; +u16 v =get_unaligned_le16 (buf); - b[0 ] =le16_to_cpu (b[0 ]); +memcpy (buf, &v,sizeof (v)); }static unsigned int regmap_parse_16_native (const void *buf) { -return *(u16 *)buf; +u16 v; + +memcpy (&v, buf,sizeof (v)); +return v; }static unsigned int regmap_parse_24 (const void *buf)
@@ -359,69 +353,67 @@ static unsigned int regmap_parse_24(const void *buf)static unsigned int regmap_parse_32_be (const void *buf) { -const __be32 *b = buf; - -return be32_to_cpu (b[0 ]); +return get_unaligned_be32 (buf); }static unsigned int regmap_parse_32_le (const void *buf) { -const __le32 *b = buf; - -return le32_to_cpu (b[0 ]); +return get_unaligned_le32 (buf); }static void regmap_parse_32_be_inplace (void *buf) { -__be32 *b = buf; +u32 v =get_unaligned_be32 (buf); - b[0 ] =be32_to_cpu (b[0 ]); +memcpy (buf, &v,sizeof (v)); }static void regmap_parse_32_le_inplace (void *buf) { -__le32 *b = buf; +u32 v =get_unaligned_le32 (buf); - b[0 ] =le32_to_cpu (b[0 ]); +memcpy (buf, &v,sizeof (v)); }static unsigned int regmap_parse_32_native (const void *buf) { -return *(u32 *)buf; +u32 v; + +memcpy (&v, buf,sizeof (v)); +return v; }#ifdef CONFIG_64BIT static unsigned int regmap_parse_64_be (const void *buf) { -const __be64 *b = buf; - -return be64_to_cpu (b[0 ]); +return get_unaligned_be64 (buf); }static unsigned int regmap_parse_64_le (const void *buf) { -const __le64 *b = buf; - -return le64_to_cpu (b[0 ]); +return get_unaligned_le64 (buf); }static void regmap_parse_64_be_inplace (void *buf) { -__be64 *b = buf; +u64 v =get_unaligned_be64 (buf); - b[0 ] =be64_to_cpu (b[0 ]); +memcpy (buf, &v,sizeof (v)); }static void regmap_parse_64_le_inplace (void *buf) { -__le64 *b = buf; +u64 v =get_unaligned_le64 (buf); - b[0 ] =le64_to_cpu (b[0 ]); +memcpy (buf, &v,sizeof (v)); }static unsigned int regmap_parse_64_native (const void *buf) { -return *(u64 *)buf; +u64 v; + +memcpy (&v, buf,sizeof (v)); +return v; }#endif
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 2/27 ARM: dts: omap4-droid4: Fix spi configuration and increase rate
From: Tony Lindgren <[email protected]>
[ Upstream commit 0df12a01f4857495816b05f048c4c31439446e35 ]
We can currently sometimes get "RXS timed out" errors and "EOT timed out" errors with spi transfers.
These errors can be made easy to reproduce by reading the cpcap iio values in a loop while keeping the CPUs busy by also reading /dev/urandom.
The "RXS timed out" errors we can fix by adding spi-cpol and spi-cpha in addition to the spi-cs-high property we already have.
The "EOT timed out" errors we can fix by increasing the spi clock rate to 9.6 MHz. Looks similar MC13783 PMIC says it works at spi clock rates up to 20 MHz, so let's assume we can pick any rate up to 20 MHz also for cpcap.
--- arch/arm/boot/dts/motorola-cpcap-mapphone.dtsi | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
arch/arm/boot/dts/motorola-cpcap-mapphone.dtsi +3 -1
@@ -16,8 +16,10 @@ cpcap: pmic@0 { #interrupt-cells = <2>; #address-cells = <1>; #size-cells = <0>; - spi-max-frequency = <3000000>; + spi-max-frequency = <9600000>; spi-cs-high; + spi-cpol; + spi-cpha; cpcap_adc: adc { compatible = "motorola,mapphone-cpcap-adc";
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 3/27 drm/tegra: hub: Do not enable orphaned window group
In reply to Sasha LevinFrom: Nicolin Chen <[email protected]>
[ Upstream commit ef4e417eb3ec7fe657928f10ac1d2154d8a5fb38 ]
Though the unconditional enable/disable code is not a final solution, we don't want to run into a NULL pointer situation when window group doesn't link to its DC parent if the DC is disabled in Device Tree.
So this patch simply adds a check to make sure that window group has a valid parent before running into tegra_windowgroup_enable/disable.
--- drivers/gpu/drm/tegra/hub.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
drivers/gpu/drm/tegra/hub.c +6 -2
@@ -143,7 +143,9 @@ int tegra_display_hub_prepare(struct tegra_display_hub *hub)for (i =0 ; i < hub->soc->num_wgrps; i++) {struct tegra_windowgroup *wgrp = &hub->wgrps[i]; -tegra_windowgroup_enable (wgrp); +/* Skip orphaned window group whose parent DC is disabled */ +if (wgrp->parent) +tegra_windowgroup_enable (wgrp); }return 0 ;
@@ -160,7 +162,9 @@ void tegra_display_hub_cleanup(struct tegra_display_hub *hub)for (i =0 ; i < hub->soc->num_wgrps; i++) {struct tegra_windowgroup *wgrp = &hub->wgrps[i]; -tegra_windowgroup_disable (wgrp); +/* Skip orphaned window group whose parent DC is disabled */ +if (wgrp->parent) +tegra_windowgroup_disable (wgrp); } }
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 4/27 gpu: host1x: Detach driver on unregister
In reply to Sasha LevinFrom: Thierry Reding <[email protected]>
[ Upstream commit d9a0a05bf8c76e6dc79230669a8b5d685b168c30 ]
Currently when a host1x device driver is unregistered, it is not detached from the host1x controller, which means that the device will stay around and when the driver is registered again, it may bind to the old, stale device rather than the new one that was created from scratch upon driver registration. This in turn can cause various weird crashes within the driver core because it is confronted with a device that was already deleted.
Fix this by detaching the driver from the host1x controller when it is unregistered. This ensures that the deleted device also is no longer present in the device list that drivers will bind to.
--- drivers/gpu/host1x/bus.c | 9 +++++++++ 1 file changed, 9 insertions(+)
drivers/gpu/host1x/bus.c +9 -0
@@ -632,8 +632,17 @@ EXPORT_SYMBOL(host1x_driver_register_full);*/ void host1x_driver_unregister (struct host1x_driver *driver) { +struct host1x *host1x; +driver_unregister (&driver->driver); +mutex_lock (&devices_lock); + +list_for_each_entry (host1x, &devices, list) +host1x_detach_driver (host1x, driver); + +mutex_unlock (&devices_lock); +mutex_lock (&drivers_lock);list_del_init (&driver->list);mutex_unlock (&drivers_lock);
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 5/27 btrfs: use kfree() in btrfs_ioctl_get_subvol_info()
In reply to Sasha LevinFrom: Waiman Long <[email protected]>
[ Upstream commit b091f7fede97cc64f7aaad3eeb37965aebee3082 ]
In btrfs_ioctl_get_subvol_info(), there is a classic case where kzalloc() was incorrectly paired with kzfree(). According to David Sterba, there isn't any sensitive information in the subvol_info that needs to be cleared before freeing. So kzfree() isn't really needed, use kfree() instead.
--- fs/btrfs/ioctl.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/btrfs/ioctl.c +1 -1
@@ -2723,7 +2723,7 @@ static int btrfs_ioctl_get_subvol_info(struct file *file, void __user *argp) out:btrfs_free_path (path); -kzfree (subvol_info); +kfree (subvol_info);return ret; }
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 6/27 net: usb: ax88179_178a: fix packet alignment padding
In reply to Sasha LevinFrom: Jeremy Kerr <[email protected]>
[ Upstream commit e869e7a17798d85829fa7d4f9bbe1eebd4b2d3f6 ]
Using a AX88179 device (0b95:1790), I see two bytes of appended data on every RX packet. For example, this 48-byte ping, using 0xff as a payload byte:
04:20:22.528472 IP 192.168.1.1 > 192.168.1.2: ICMP echo request, id 2447, seq 1, length 64
0x0000: 000a cd35 ea50 000a cd35 ea4f 0800 4500 0x0010: 0054 c116 4000 4001 f63e c0a8 0101 c0a8 0x0020: 0102 0800 b633 098f 0001 87ea cd5e 0000 0x0030: 0000 dcf2 0600 0000 0000 ffff ffff ffff 0x0040: ffff ffff ffff ffff ffff ffff ffff ffff 0x0050: ffff ffff ffff ffff ffff ffff ffff ffff 0x0060: ffff 961f
Those last two bytes - 96 1f - aren't part of the original packet.
In the ax88179 RX path, the usbnet rx_fixup function trims a 2-byte 'alignment pseudo header' from the start of the packet, and sets the length from a per-packet field populated by hardware. It looks like that length field *includes* the 2-byte header; the current driver assumes that it's excluded.
This change trims the 2-byte alignment header after we've set the packet length, so the resulting packet length is correct. While we're moving the comment around, this also fixes the spelling of 'pseudo'.
--- drivers/net/usb/ax88179_178a.c | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-)
drivers/net/usb/ax88179_178a.c +6 -5
@@ -1400,10 +1400,10 @@ static int ax88179_rx_fixup(struct usbnet *dev, struct sk_buff *skb) }if (pkt_cnt ==0 ) { -/* Skip IP alignment psudo header */ -skb_pull (skb,2 ); skb->len = pkt_len; -skb_set_tail_pointer (skb, pkt_len); +/* Skip IP alignment pseudo header */ +skb_pull (skb,2 ); +skb_set_tail_pointer (skb, skb->len); skb->truesize = pkt_len +sizeof (struct sk_buff );ax88179_rx_checksum (skb, pkt_hdr);return 1 ;
@@ -1412,8 +1412,9 @@ static int ax88179_rx_fixup(struct usbnet *dev, struct sk_buff *skb) ax_skb =skb_clone (skb,GFP_ATOMIC );if (ax_skb) { ax_skb->len = pkt_len; - ax_skb->data = skb->data +2 ; -skb_set_tail_pointer (ax_skb, pkt_len); +/* Skip IP alignment pseudo header */ +skb_pull (ax_skb,2 ); +skb_set_tail_pointer (ax_skb, ax_skb->len); ax_skb->truesize = pkt_len +sizeof (struct sk_buff );ax88179_rx_checksum (ax_skb, pkt_hdr);usbnet_skb_return (dev, ax_skb);
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 7/27 usb: usbtest: fix missing kfree(dev->buf) in usbtest_disconnect
In reply to Sasha LevinFrom: Zqiang <[email protected]>
[ Upstream commit 28ebeb8db77035e058a510ce9bd17c2b9a009dba ]
BUG: memory leak
unreferenced object 0xffff888055046e00 (size 256):
comm "kworker/2:9", pid 2570, jiffies 4294942129 (age 1095.500s)
hex dump (first 32 bytes):
00 70 04 55 80 88 ff ff 18 bb 5a 81 ff ff ff ff .p.U......Z.....
f5 96 78 81 ff ff ff ff 37 de 8e 81 ff ff ff ff ..x.....7.......
backtrace:
[<00000000d121dccf>] kmemleak_alloc_recursive
include/linux/kmemleak.h:43 [inline]
[<00000000d121dccf>] slab_post_alloc_hook mm/slab.h:586 [inline]
[<00000000d121dccf>] slab_alloc_node mm/slub.c:2786 [inline]
[<00000000d121dccf>] slab_alloc mm/slub.c:2794 [inline]
[<00000000d121dccf>] kmem_cache_alloc_trace+0x15e/0x2d0 mm/slub.c:2811
[<000000005c3c3381>] kmalloc include/linux/slab.h:555 [inline]
[<000000005c3c3381>] usbtest_probe+0x286/0x19d0
drivers/usb/misc/usbtest.c:2790
[<000000001cec6910>] usb_probe_interface+0x2bd/0x870
drivers/usb/core/driver.c:361
[<000000007806c118>] really_probe+0x48d/0x8f0 drivers/base/dd.c:551
[<00000000a3308c3e>] driver_probe_device+0xfc/0x2a0 drivers/base/dd.c:724
[<000000003ef66004>] __device_attach_driver+0x1b6/0x240
drivers/base/dd.c:831
[<00000000eee53e97>] bus_for_each_drv+0x14e/0x1e0 drivers/base/bus.c:431
[<00000000bb0648d0>] __device_attach+0x1f9/0x350 drivers/base/dd.c:897
[<00000000838b324a>] device_initial_probe+0x1a/0x20 drivers/base/dd.c:944
[<0000000030d501c1>] bus_probe_device+0x1e1/0x280 drivers/base/bus.c:491
[<000000005bd7adef>] device_add+0x131d/0x1c40 drivers/base/core.c:2504
[<00000000a0937814>] usb_set_configuration+0xe84/0x1ab0
drivers/usb/core/message.c:2030
[<00000000e3934741>] generic_probe+0x6a/0xe0 drivers/usb/core/generic.c:210
[<0000000098ade0f1>] usb_probe_device+0x90/0xd0
drivers/usb/core/driver.c:266
[<000000007806c118>] really_probe+0x48d/0x8f0 drivers/base/dd.c:551
[<00000000a3308c3e>] driver_probe_device+0xfc/0x2a0 drivers/base/dd.c:724--- drivers/usb/misc/usbtest.c | 1 + 1 file changed, 1 insertion(+)
drivers/usb/misc/usbtest.c +1 -0
@@ -2853,6 +2853,7 @@ static void usbtest_disconnect(struct usb_interface *intf)usb_set_intfdata (intf,NULL );dev_dbg (&intf->dev,"disconnect\n" ); +kfree (dev->buf);kfree (dev); }
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 8/27 spi: spidev: fix a race between spidev_release and spidev_remove
In reply to Sasha LevinFrom: Zhenzhong Duan <[email protected]>
[ Upstream commit abd42781c3d2155868821f1b947ae45bbc33330d ]
Imagine below scene, spidev is referenced after it's freed.
spidev_release() spidev_remove()
...
spin_lock_irq(&spidev->spi_lock);
spidev->spi = NULL;
spin_unlock_irq(&spidev->spi_lock);
mutex_lock(&device_list_lock);
dofree = (spidev->spi == NULL);
if (dofree)
kfree(spidev);
mutex_unlock(&device_list_lock);
mutex_lock(&device_list_lock);
list_del(&spidev->device_entry);
device_destroy(spidev_class, spidev->devt);
clear_bit(MINOR(spidev->devt), minors);
if (spidev->users == 0)
kfree(spidev);
mutex_unlock(&device_list_lock);Fix it by resetting spidev->spi in device_list_lock's protection.
--- drivers/spi/spidev.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/spi/spidev.c +2 -2
@@ -782,13 +782,13 @@ static int spidev_remove(struct spi_device *spi) {struct spidev_data *spidev =spi_get_drvdata (spi); +/* prevent new opens */ +mutex_lock (&device_list_lock);/* make sure ops on existing fds can abort cleanly */ spin_lock_irq (&spidev->spi_lock); spidev->spi =NULL ;spin_unlock_irq (&spidev->spi_lock); -/* prevent new opens */ -mutex_lock (&device_list_lock);list_del (&spidev->device_entry);device_destroy (spidev_class, spidev->devt);clear_bit (MINOR (spidev->devt), minors);
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 9/27 spi: spidev: fix a potential use-after-free in spidev_release()
In reply to Sasha LevinFrom: Zhenzhong Duan <[email protected]>
[ Upstream commit 06096cc6c5a84ced929634b0d79376b94c65a4bd ]
If an spi device is unbounded from the driver before the release process, there will be an NULL pointer reference when it's referenced in spi_slave_abort().
Fix it by checking it's already freed before reference.
--- drivers/spi/spidev.c | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-)
drivers/spi/spidev.c +10 -10
@@ -607,15 +607,20 @@ static int spidev_open(struct inode *inode, struct file *filp)static int spidev_release (struct inode *inode,struct file *filp) {struct spidev_data *spidev; +int dofree;mutex_lock (&device_list_lock); spidev = filp->private_data; filp->private_data =NULL ; +spin_lock_irq (&spidev->spi_lock); +/* ... after we unbound from the underlying device? */ + dofree = (spidev->spi ==NULL ); +spin_unlock_irq (&spidev->spi_lock); +/* last close? */ spidev->users--;if (!spidev->users) { -int dofree;kfree (spidev->tx_buffer); spidev->tx_buffer =NULL ;
@@ -623,19 +628,14 @@ static int spidev_release(struct inode *inode, struct file *filp)kfree (spidev->rx_buffer); spidev->rx_buffer =NULL ; -spin_lock_irq (&spidev->spi_lock); -if (spidev->spi) - spidev->speed_hz = spidev->spi->max_speed_hz; - -/* ... after we unbound from the underlying device? */ - dofree = (spidev->spi ==NULL ); -spin_unlock_irq (&spidev->spi_lock); -if (dofree)kfree (spidev); +else + spidev->speed_hz = spidev->spi->max_speed_hz; }#ifdef CONFIG_SPI_SLAVE -spi_slave_abort (spidev->spi); +if (!dofree) +spi_slave_abort (spidev->spi);#endif mutex_unlock (&device_list_lock);
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 10/27 tg3: driver sleeps indefinitely when EEH errors exceed eeh_max_freezes
In reply to Sasha LevinFrom: David Christensen <[email protected]>
[ Upstream commit 3a2656a211caf35e56afc9425e6e518fa52f7fbc ]
The driver function tg3_io_error_detected() calls napi_disable twice, without an intervening napi_enable, when the number of EEH errors exceeds eeh_max_freezes, resulting in an indefinite sleep while holding rtnl_lock.
Add check for pcierr_recovery which skips code already executed for the "Frozen" state.
--- drivers/net/ethernet/broadcom/tg3.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/net/ethernet/broadcom/tg3.c +2 -2
@@ -18229,8 +18229,8 @@ static pci_ers_result_t tg3_io_error_detected(struct pci_dev *pdev,rtnl_lock (); -/* We probably don't have netdev yet */ -if (!netdev || !netif_running (netdev)) +/* Could be second call or maybe we don't have netdev yet */ +if (!netdev || tp->pcierr_recovery || !netif_running (netdev)) goto done;/* We needn't recover from permanent error */
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 11/27 ixgbe: protect ring accesses with READ- and WRITE_ONCE
In reply to Sasha LevinFrom: Ciara Loftus <[email protected]>
[ Upstream commit f140ad9fe2ae16f385f8fe4dc9cf67bb4c51d794 ]
READ_ONCE should be used when reading rings prior to accessing the statistics pointer. Introduce this as well as the corresponding WRITE_ONCE usage when allocating and freeing the rings, to ensure protected access.
--- drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c | 12 ++++++------ drivers/net/ethernet/intel/ixgbe/ixgbe_main.c | 14 +++++++++++--- 2 files changed, 17 insertions(+), 9 deletions(-)
drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c +6 -6
@@ -923,7 +923,7 @@ static int ixgbe_alloc_q_vector(struct ixgbe_adapter *adapter, ring->queue_index = txr_idx;/* assign ring to adapter */ - adapter->tx_ring[txr_idx] = ring; +WRITE_ONCE (adapter->tx_ring[txr_idx], ring);/* update count and index */ txr_count--;
@@ -950,7 +950,7 @@ static int ixgbe_alloc_q_vector(struct ixgbe_adapter *adapter,set_ring_xdp (ring);/* assign ring to adapter */ - adapter->xdp_ring[xdp_idx] = ring; +WRITE_ONCE (adapter->xdp_ring[xdp_idx], ring);/* update count and index */ xdp_count--;
@@ -993,7 +993,7 @@ static int ixgbe_alloc_q_vector(struct ixgbe_adapter *adapter, ring->queue_index = rxr_idx;/* assign ring to adapter */ - adapter->rx_ring[rxr_idx] = ring; +WRITE_ONCE (adapter->rx_ring[rxr_idx], ring);/* update count and index */ rxr_count--;
@@ -1022,13 +1022,13 @@ static void ixgbe_free_q_vector(struct ixgbe_adapter *adapter, int v_idx)ixgbe_for_each_ring (ring, q_vector->tx) {if (ring_is_xdp (ring)) - adapter->xdp_ring[ring->queue_index] =NULL ; +WRITE_ONCE (adapter->xdp_ring[ring->queue_index],NULL );else - adapter->tx_ring[ring->queue_index] =NULL ; +WRITE_ONCE (adapter->tx_ring[ring->queue_index],NULL ); }ixgbe_for_each_ring (ring, q_vector->rx) - adapter->rx_ring[ring->queue_index] =NULL ; +WRITE_ONCE (adapter->rx_ring[ring->queue_index],NULL ); adapter->q_vector[v_idx] =NULL ;napi_hash_del (&q_vector->napi);
drivers/net/ethernet/intel/ixgbe/ixgbe_main.c +11 -3
@@ -7005,7 +7005,10 @@ void ixgbe_update_stats(struct ixgbe_adapter *adapter) }for (i =0 ; i < adapter->num_rx_queues; i++) { -struct ixgbe_ring *rx_ring = adapter->rx_ring[i]; +struct ixgbe_ring *rx_ring =READ_ONCE (adapter->rx_ring[i]); + +if (!rx_ring) +continue ; non_eop_descs += rx_ring->rx_stats.non_eop_descs; alloc_rx_page += rx_ring->rx_stats.alloc_rx_page; alloc_rx_page_failed += rx_ring->rx_stats.alloc_rx_page_failed;
@@ -7026,15 +7029,20 @@ void ixgbe_update_stats(struct ixgbe_adapter *adapter) packets =0 ;/* gather some stats to the adapter struct that are per queue */ for (i =0 ; i < adapter->num_tx_queues; i++) { -struct ixgbe_ring *tx_ring = adapter->tx_ring[i]; +struct ixgbe_ring *tx_ring =READ_ONCE (adapter->tx_ring[i]); + +if (!tx_ring) +continue ; restart_queue += tx_ring->tx_stats.restart_queue; tx_busy += tx_ring->tx_stats.tx_busy; bytes += tx_ring->stats.bytes; packets += tx_ring->stats.packets; }for (i =0 ; i < adapter->num_xdp_queues; i++) { -struct ixgbe_ring *xdp_ring = adapter->xdp_ring[i]; +struct ixgbe_ring *xdp_ring =READ_ONCE (adapter->xdp_ring[i]); +if (!xdp_ring) +continue ; restart_queue += xdp_ring->tx_stats.restart_queue; tx_busy += xdp_ring->tx_stats.tx_busy; bytes += xdp_ring->stats.bytes;
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 12/27 i40e: protect ring accesses with READ- and WRITE_ONCE
In reply to Sasha LevinFrom: Ciara Loftus <[email protected]>
[ Upstream commit d59e267912cd90b0adf33b4659050d831e746317 ]
READ_ONCE should be used when reading rings prior to accessing the statistics pointer. Introduce this as well as the corresponding WRITE_ONCE usage when allocating and freeing the rings, to ensure protected access.
--- drivers/net/ethernet/intel/i40e/i40e_main.c | 29 ++++++++++++++------- 1 file changed, 19 insertions(+), 10 deletions(-)
drivers/net/ethernet/intel/i40e/i40e_main.c +19 -10
@@ -446,11 +446,15 @@ static void i40e_get_netdev_stats_struct(struct net_device *netdev,i40e_get_netdev_stats_struct_tx (ring, stats);if (i40e_enabled_xdp_vsi (vsi)) { - ring++; + ring =READ_ONCE (vsi->xdp_rings[i]); +if (!ring) +continue ;i40e_get_netdev_stats_struct_tx (ring, stats); } - ring++; + ring =READ_ONCE (vsi->rx_rings[i]); +if (!ring) +continue ; do { start = u64_stats_fetch_begin_irq(&ring->syncp); packets = ring->stats.packets;
@@ -793,6 +797,8 @@ static void i40e_update_vsi_stats(struct i40e_vsi *vsi)for (q =0 ; q < vsi->num_queue_pairs; q++) {/* locate Tx ring */ p =READ_ONCE (vsi->tx_rings[q]); +if (!p) +continue ; do { start = u64_stats_fetch_begin_irq(&p->syncp);
@@ -806,8 +812,11 @@ static void i40e_update_vsi_stats(struct i40e_vsi *vsi) tx_linearize += p->tx_stats.tx_linearize; tx_force_wb += p->tx_stats.tx_force_wb; -/* Rx queue is part of the same block as Tx queue */ - p = &p[1 ]; +/* locate Rx ring */ + p =READ_ONCE (vsi->rx_rings[q]); +if (!p) +continue ; + do { start = u64_stats_fetch_begin_irq(&p->syncp); packets = p->stats.packets;
@@ -10196,10 +10205,10 @@ static void i40e_vsi_clear_rings(struct i40e_vsi *vsi)if (vsi->tx_rings && vsi->tx_rings[0 ]) {for (i =0 ; i < vsi->alloc_queue_pairs; i++) {kfree_rcu (vsi->tx_rings[i], rcu); - vsi->tx_rings[i] =NULL ; - vsi->rx_rings[i] =NULL ; +WRITE_ONCE (vsi->tx_rings[i],NULL ); +WRITE_ONCE (vsi->rx_rings[i],NULL );if (vsi->xdp_rings) - vsi->xdp_rings[i] =NULL ; +WRITE_ONCE (vsi->xdp_rings[i],NULL ); } } }
@@ -10233,7 +10242,7 @@ static int i40e_alloc_rings(struct i40e_vsi *vsi)if (vsi->back->hw_features &I40E_HW_WB_ON_ITR_CAPABLE ) ring->flags =I40E_TXR_FLAGS_WB_ON_ITR ; ring->itr_setting = pf->tx_itr_default; - vsi->tx_rings[i] = ring++; +WRITE_ONCE (vsi->tx_rings[i], ring++);if (!i40e_enabled_xdp_vsi (vsi)) goto setup_rx;
@@ -10251,7 +10260,7 @@ static int i40e_alloc_rings(struct i40e_vsi *vsi) ring->flags =I40E_TXR_FLAGS_WB_ON_ITR ;set_ring_xdp (ring); ring->itr_setting = pf->tx_itr_default; - vsi->xdp_rings[i] = ring++; +WRITE_ONCE (vsi->xdp_rings[i], ring++); setup_rx: ring->queue_index = i;
@@ -10264,7 +10273,7 @@ static int i40e_alloc_rings(struct i40e_vsi *vsi) ring->size =0 ; ring->dcb_tc =0 ; ring->itr_setting = pf->rx_itr_default; - vsi->rx_rings[i] = ring; +WRITE_ONCE (vsi->rx_rings[i], ring); }return 0 ;
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 13/27 usbnet: smsc95xx: Fix use-after-free after removal
In reply to Sasha LevinFrom: Tuomas Tynkkynen <[email protected]>
[ Upstream commit b835a71ef64a61383c414d6bf2896d2c0161deca ]
Syzbot reports an use-after-free in workqueue context:
BUG: KASAN: use-after-free in mutex_unlock+0x19/0x40 kernel/locking/mutex.c:737 mutex_unlock+0x19/0x40 kernel/locking/mutex.c:737 __smsc95xx_mdio_read drivers/net/usb/smsc95xx.c:217 [inline] smsc95xx_mdio_read+0x583/0x870 drivers/net/usb/smsc95xx.c:278 check_carrier+0xd1/0x2e0 drivers/net/usb/smsc95xx.c:644 process_one_work+0x777/0xf90 kernel/workqueue.c:2274 worker_thread+0xa8f/0x1430 kernel/workqueue.c:2420 kthread+0x2df/0x300 kernel/kthread.c:255
It looks like that smsc95xx_unbind() is freeing the structures that are still in use by the concurrently running workqueue callback. Thus switch to using cancel_delayed_work_sync() to ensure the work callback really is no longer active.
--- drivers/net/usb/smsc95xx.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/net/usb/smsc95xx.c +1 -1
@@ -1338,7 +1338,7 @@ static void smsc95xx_unbind(struct usbnet *dev, struct usb_interface *intf)struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0 ]);if (pdata) { -cancel_delayed_work (&pdata->carrier_check); +cancel_delayed_work_sync (&pdata->carrier_check);netif_dbg (dev, ifdown, dev->net,"free pdata\n" );kfree (pdata); pdata =NULL ;
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 14/27 drm: panel-orientation-quirks: Add quirk for Asus T101HA panel
In reply to Sasha LevinFrom: Hans de Goede <[email protected]>
[ Upstream commit 6c22bc18a3b93a38018844636557ad02e588e055 ]
Like the Asus T100HA the Asus T101HA also uses a panel which has been mounted 90 degrees rotated, albeit in the opposite direction. Add a quirk for this.
--- drivers/gpu/drm/drm_panel_orientation_quirks.c | 6 ++++++ 1 file changed, 6 insertions(+)
drivers/gpu/drm/drm_panel_orientation_quirks.c +6 -0
@@ -107,6 +107,12 @@ static const struct dmi_system_id orientation_data[] = { DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "T100HAN"), }, .driver_data = (void *)&asus_t100ha, + }, { /* Asus T101HA */ + .matches = { +DMI_EXACT_MATCH (DMI_SYS_VENDOR ,"ASUSTeK COMPUTER INC." ), + DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "T101HA"), + }, + .driver_data = (void *)&lcd800x1280_rightside_up, }, { /* GPD MicroPC (generic strings, also match on bios date) */ .matches = { DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Default string"),
Signature · 6 lines
2.25.1 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
Sasha Levin
maintainerPATCH 15/27 drm: panel-orientation-quirks: Use generic orientation-data for Acer S1003
In reply to Sasha LevinFrom: Hans de Goede <[email protected]>
[ Upstream commit a05caf9e62a85d12da27e814ac13195f4683f21c ]
The Acer S1003 has proper DMI strings for sys-vendor and product-name, so we do not need to match by BIOS-date.
This means that the Acer S1003 can use the generic lcd800x1280_rightside_up drm_dmi_panel_orientation_data struct which is also used by other quirks.
--- drivers/gpu/drm/drm_panel_orientation_quirks.c | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-)
drivers/gpu/drm/drm_panel_orientation_quirks.c +1 -7
@@ -30,12 +30,6 @@ struct drm_dmi_panel_orientation_data {int orientation; }; -static const struct drm_dmi_panel_orientation_data acer_s1003 = { - .width =800 , - .height =1280 , - .orientation =DRM_MODE_PANEL_ORIENTATION_RIGHT_UP , -}; -static const struct drm_dmi_panel_orientation_data asus_t100ha = { .width =800 , .height =1280 ,
@@ -100,7 +94,7 @@ static const struct dmi_system_id orientation_data[] = {DMI_EXACT_MATCH (DMI_SYS_VENDOR ,"Acer" ), DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "One S1003"), }, - .driver_data = (void *)&acer_s1003, + .driver_data = (void *)&lcd800x1280_rightside_up, }, { /* Asus T100HA */ .matches = { DMI_EXACT_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
Signature · 6 lines
2.25.1 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
Sasha Levin
maintainerPATCH 16/27 s390/kasan: fix early pgm check handler execution
In reply to Sasha LevinFrom: Vasily Gorbik <[email protected]>
[ Upstream commit 998f5bbe3dbdab81c1cfb1aef7c3892f5d24f6c7 ]
Currently if early_pgm_check_handler is called it ends up in pgm check loop. The problem is that early_pgm_check_handler is instrumented by KASAN but executed without DAT flag enabled which leads to addressing exception when KASAN checks try to access shadow memory.
Fix that by executing early handlers with DAT flag on under KASAN as expected.
--- arch/s390/kernel/early.c | 2 ++ 1 file changed, 2 insertions(+)
arch/s390/kernel/early.c +2 -0
@@ -155,6 +155,8 @@ static noinline __init void setup_lowcore_early(void)psw_t psw; psw.mask =PSW_MASK_BASE |PSW_DEFAULT_KEY |PSW_MASK_EA |PSW_MASK_BA ; +if (IS_ENABLED (CONFIG_KASAN )) + psw.mask |=PSW_MASK_DAT ; psw.addr = (unsigned long ) s390_base_ext_handler; S390_lowcore.external_new_psw = psw; psw.addr = (unsigned long ) s390_base_pgm_handler;
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 17/27 s390/debug: avoid kernel warning on too large number of pages
In reply to Sasha LevinFrom: Christian Borntraeger <[email protected]>
[ Upstream commit 827c4913923e0b441ba07ba4cc41e01181102303 ]
When specifying insanely large debug buffers a kernel warning is printed. The debug code does handle the error gracefully, though. Instead of duplicating the check let us silence the warning to avoid crashes when panic_on_warn is used.
--- arch/s390/kernel/debug.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
arch/s390/kernel/debug.c +2 -1
@@ -198,9 +198,10 @@ static debug_entry_t ***debug_areas_alloc(int pages_per_area, int nr_areas)if (!areas) goto fail_malloc_areas;for (i =0 ; i < nr_areas; i++) { +/* GFP_NOWARN to avoid user triggerable WARN, we handle fails */ areas[i] =kmalloc_array (pages_per_area,sizeof (debug_entry_t *), -GFP_KERNEL ); +GFP_KERNEL | __GFP_NOWARN);if (!areas[i]) goto fail_malloc_areas2;for (j =0 ; j < pages_per_area; j++) {
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 18/27 cifs: Fix double add page to memcg when cifs_readpages
In reply to Sasha LevinFrom: Zhang Xiaoxu <[email protected]>
[ Upstream commit 95a3d8f3af9b0d63b43f221b630beaab9739d13a ]
When xfstests generic/451, there is an BUG at mm/memcontrol.c:
page:ffffea000560f2c0 refcount:2 mapcount:0 mapping:000000008544e0ea
index:0xf
mapping->aops:cifs_addr_ops dentry name:"tst-aio-dio-cycle-write.451"
flags: 0x2fffff80000001(locked)
raw: 002fffff80000001 ffffc90002023c50 ffffea0005280088 ffff88815cda0210
raw: 000000000000000f 0000000000000000 00000002ffffffff ffff88817287d000
page dumped because: VM_BUG_ON_PAGE(page->mem_cgroup)
page->mem_cgroup:ffff88817287d000
------------[ cut here ]------------
kernel BUG at mm/memcontrol.c:2659!
invalid opcode: 0000 [#1] SMP
CPU: 2 PID: 2038 Comm: xfs_io Not tainted 5.8.0-rc1 #44
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS ?-20190727_
073836-buildvm-ppc64le-16.ppc.4
RIP: 0010:commit_charge+0x35/0x50
Code: 0d 48 83 05 54 b2 02 05 01 48 89 77 38 c3 48 c7
c6 78 4a ea ba 48 83 05 38 b2 02 05 01 e8 63 0d9
RSP: 0018:ffffc90002023a50 EFLAGS: 00010202
RAX: 0000000000000000 RBX: ffff88817287d000 RCX: 0000000000000000
RDX: 0000000000000000 RSI: ffff88817ac97ea0 RDI: ffff88817ac97ea0
RBP: ffffea000560f2c0 R08: 0000000000000203 R09: 0000000000000005
R10: 0000000000000030 R11: ffffc900020237a8 R12: 0000000000000000
R13: 0000000000000001 R14: 0000000000000001 R15: ffff88815a1272c0
FS: 00007f5071ab0800(0000) GS:ffff88817ac80000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 000055efcd5ca000 CR3: 000000015d312000 CR4: 00000000000006e0
DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400
Call Trace:
mem_cgroup_charge+0x166/0x4f0
__add_to_page_cache_locked+0x4a9/0x710
add_to_page_cache_locked+0x15/0x20
cifs_readpages+0x217/0x1270
read_pages+0x29a/0x670
page_cache_readahead_unbounded+0x24f/0x390
__do_page_cache_readahead+0x3f/0x60
ondemand_readahead+0x1f1/0x470
page_cache_async_readahead+0x14c/0x170
generic_file_buffered_read+0x5df/0x1100
generic_file_read_iter+0x10c/0x1d0
cifs_strict_readv+0x139/0x170
new_sync_read+0x164/0x250
__vfs_read+0x39/0x60
vfs_read+0xb5/0x1e0
ksys_pread64+0x85/0xf0
__x64_sys_pread64+0x22/0x30
do_syscall_64+0x69/0x150
entry_SYSCALL_64_after_hwframe+0x44/0xa9
RIP: 0033:0x7f5071fcb1af
Code: Bad RIP value.
RSP: 002b:00007ffde2cdb8e0 EFLAGS: 00000293 ORIG_RAX: 0000000000000011
RAX: ffffffffffffffda RBX: 00007ffde2cdb990 RCX: 00007f5071fcb1af
RDX: 0000000000001000 RSI: 000055efcd5ca000 RDI: 0000000000000003
RBP: 0000000000000003 R08: 0000000000000000 R09: 0000000000000000
R10: 0000000000001000 R11: 0000000000000293 R12: 0000000000000001
R13: 000000000009f000 R14: 0000000000000000 R15: 0000000000001000
Modules linked in:
---[ end trace 725fa14a3e1af65c ]---Since commit 3fea5a499d57 ("mm: memcontrol: convert page cache to a new mem_cgroup_charge() API") not cancel the page charge, the pages maybe double add to pagecache:
thread1 | thread2cifs_readpagesreadpages_get_pages
add_to_page_cache_locked(head,index=n)=0
| readpages_get_pages
| add_to_page_cache_locked(head,index=n+1)=0 add_to_page_cache_locked(head, index=n+1)=-EEXIST then, will next loop with list head page's index=n+1 and the page->mapping not NULLreadpages_get_pages add_to_page_cache_locked(head, index=n+1)
commit_charge
VM_BUG_ON_PAGE
So, we should not do the next loop when any page add to page cache failed.
--- fs/cifs/file.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-)
fs/cifs/file.c +7 -4
@@ -3804,7 +3804,8 @@ readpages_get_pages(struct address_space *mapping, struct list_head *page_list,break ;__SetPageLocked (page); -if (add_to_page_cache_locked (page, mapping, page->index, gfp)) { + rc =add_to_page_cache_locked (page, mapping, page->index, gfp); +if (rc) {__ClearPageLocked (page);break ; }
@@ -3820,6 +3821,7 @@ static int cifs_readpages(struct file *file, struct address_space *mapping, struct list_head *page_list, unsigned num_pages) { int rc; +int err =0 ;struct list_head tmplist;struct cifsFileInfo *open_file = file->private_data;struct cifs_sb_info *cifs_sb =CIFS_FILE_SB (file);
@@ -3860,7 +3862,7 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,* the order of declining indexes. When we put the pages in * the rdata->pages, then we want them in increasing order. */ -while (!list_empty (page_list)) { +while (!list_empty (page_list) && !err) {unsigned int i, nr_pages, bytes, rsize;loff_t offset;struct page *page, *tpage;
@@ -3883,9 +3885,10 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,return 0 ; } - rc =readpages_get_pages (mapping, page_list, rsize, &tmplist, + nr_pages =0 ; + err =readpages_get_pages (mapping, page_list, rsize, &tmplist, &nr_pages, &offset, &bytes); -if (rc) { +if (!nr_pages) {add_credits_and_wake_if (server, credits,0 );break ; }
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 19/27 drm/sun4i: mixer: Call of_dma_configure if there's an IOMMU
In reply to Sasha LevinFrom: Maxime Ripard <[email protected]>
[ Upstream commit 842ec61f4006a6477a9deaedd69131e9f46e4cb5 ]
The main DRM device is actually a virtual device so it doesn't have the iommus property, which is instead on the DMA masters, in this case the mixers.
Add a call to of_dma_configure with the mixers DT node but on the DRM virtual device to configure it in the same way than the mixers.
[Maxime: Applied to -fixes since it missed the merge window and display is
broken without it]
--- drivers/gpu/drm/sun4i/sun8i_mixer.c | 13 +++++++++++++ 1 file changed, 13 insertions(+)
drivers/gpu/drm/sun4i/sun8i_mixer.c +13 -0
@@ -435,6 +435,19 @@ static int sun8i_mixer_bind(struct device *dev, struct device *master, mixer->engine.ops = &sun8i_engine_ops; mixer->engine.node = dev->of_node; +if (of_find_property (dev->of_node,"iommus" ,NULL )) { +/* +* This assume we have the same DMA constraints for +* all our the mixers in our pipeline. This sounds +* bad, but it has always been the case for us, and +* DRM doesn't do per-device allocation either, so we +* would need to fix DRM first... +*/ + ret =of_dma_configure (drm->dev, dev->of_node, true); +if (ret) +return ret; + } +/* * While this function can fail, we shouldn't do anything * if this happens. Some early DE2 DT entries don't provide
Signature · 6 lines
2.25.1 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
Sasha Levin
maintainerPATCH 20/27 cifs: update ctime and mtime during truncate
In reply to Sasha LevinFrom: Zhang Xiaoxu <[email protected]>
[ Upstream commit 5618303d8516f8ac5ecfe53ee8e8bc9a40eaf066 ]
As the man description of the truncate, if the size changed, then the st_ctime and st_mtime fields should be updated. But in cifs, we doesn't do it.
It lead the xfstests generic/313 failed.
So, add the ATTR_MTIME|ATTR_CTIME flags on attrs when change the file size
--- fs/cifs/inode.c | 9 +++++++++ 1 file changed, 9 insertions(+)
fs/cifs/inode.c +9 -0
@@ -2219,6 +2219,15 @@ cifs_set_file_size(struct inode *inode, struct iattr *attrs,if (rc ==0 ) { cifsInode->server_eof = attrs->ia_size;cifs_setsize (inode, attrs->ia_size); + +/* +* The man page of truncate says if the size changed, +* then the st_ctime and st_mtime fields for the file +* are updated. +*/ + attrs->ia_ctime = attrs->ia_mtime =current_time (inode); + attrs->ia_valid |=ATTR_CTIME |ATTR_MTIME ; +cifs_truncate_page (inode->i_mapping, inode->i_size); }
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 21/27 ARM: imx6: add missing put_device() call in imx6q_suspend_init()
In reply to Sasha LevinFrom: yu kuai <[email protected]>
[ Upstream commit 4845446036fc9c13f43b54a65c9b757c14f5141b ]
if of_find_device_by_node() succeed, imx6q_suspend_init() doesn't have a corresponding put_device(). Thus add a jump target to fix the exception handling for this function implementation.
--- arch/arm/mach-imx/pm-imx6.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-)
arch/arm/mach-imx/pm-imx6.c +6 -4
@@ -497,14 +497,14 @@ static int __init imx6q_suspend_init(const struct imx6_pm_socdata *socdata)if (!ocram_pool) {pr_warn ("%s: ocram pool unavailable!\n" , __func__); ret = -ENODEV ; - goto put_node; + goto put_device; } ocram_base =gen_pool_alloc (ocram_pool,MX6Q_SUSPEND_OCRAM_SIZE );if (!ocram_base) {pr_warn ("%s: unable to alloc ocram!\n" , __func__); ret = -ENOMEM ; - goto put_node; + goto put_device; } ocram_pbase =gen_pool_virt_to_phys (ocram_pool, ocram_base);
@@ -527,7 +527,7 @@ static int __init imx6q_suspend_init(const struct imx6_pm_socdata *socdata) ret =imx6_pm_get_base (&pm_info->mmdc_base, socdata->mmdc_compat);if (ret) {pr_warn ("%s: failed to get mmdc base %d!\n" , __func__, ret); - goto put_node; + goto put_device; } ret =imx6_pm_get_base (&pm_info->src_base, socdata->src_compat);
@@ -574,7 +574,7 @@ static int __init imx6q_suspend_init(const struct imx6_pm_socdata *socdata) &imx6_suspend, MX6Q_SUSPEND_OCRAM_SIZE - sizeof(*pm_info)); - goto put_node; + goto put_device; pl310_cache_map_failed:iounmap (pm_info->gpc_base.vbase);
@@ -584,6 +584,8 @@ static int __init imx6q_suspend_init(const struct imx6_pm_socdata *socdata)iounmap (pm_info->src_base.vbase); src_map_failed:iounmap (pm_info->mmdc_base.vbase); +put_device: +put_device (&pdev->dev); put_node:of_node_put (node);
Signature · 7 lines
2.25.1 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Sasha Levin
maintainerPATCH 22/27 scsi: mptscsih: Fix read sense data size
In reply to Sasha LevinFrom: Tomas Henzl <[email protected]>
[ Upstream commit afe89f115e84edbc76d316759e206580a06c6973 ]
The sense data buffer in sense_buf_pool is allocated with size of MPT_SENSE_BUFFER_ALLOC(64) (multiplied by req_depth) while SNS_LEN(sc)(96) is used when reading the data. That may lead to a read from unallocated area, sometimes from another (unallocated) page. To fix this, limit the read size to MPT_SENSE_BUFFER_ALLOC.
--- drivers/message/fusion/mptscsih.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)
drivers/message/fusion/mptscsih.c +1 -3
@@ -118,8 +118,6 @@ int mptscsih_suspend(struct pci_dev *pdev, pm_message_t state);int mptscsih_resume (struct pci_dev *pdev);#endif -#define SNS_LEN (scp) SCSI_SENSE_BUFFERSIZE -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ /*
@@ -2420,7 +2418,7 @@ mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR/* Copy the sense received into the scsi command block. */ req_index =le16_to_cpu (mf->u.frame.hwhdr.msgctxu.fld.req_idx); sense_data = ((u8 *)ioc->sense_buf_pool + (req_index *MPT_SENSE_BUFFER_ALLOC )); -memcpy (sc->sense_buffer, sense_data,SNS_LEN (sc)); +memcpy (sc->sense_buffer, sense_data,MPT_SENSE_BUFFER_ALLOC );/* Log SMART data (asc = 0x5D, non-IM case only) if required. */
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 23/27 usb: dwc3: pci: Fix reference count leak in dwc3_pci_resume_work
In reply to Sasha LevinFrom: Aditya Pakki <[email protected]>
[ Upstream commit 2655971ad4b34e97dd921df16bb0b08db9449df7 ]
dwc3_pci_resume_work() calls pm_runtime_get_sync() that increments the reference counter. In case of failure, decrement the reference before returning.
--- drivers/usb/dwc3/dwc3-pci.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
drivers/usb/dwc3/dwc3-pci.c +3 -1
@@ -204,8 +204,10 @@ static void dwc3_pci_resume_work(struct work_struct *work)int ret; ret =pm_runtime_get_sync (&dwc3->dev); -if (ret) +if (ret) { +pm_runtime_put_sync_autosuspend (&dwc3->dev);return ; + }pm_runtime_mark_last_busy (&dwc3->dev);pm_runtime_put_sync_autosuspend (&dwc3->dev);
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 24/27 block: release bip in a right way in error path
In reply to Sasha LevinFrom: Chengguang Xu <[email protected]>
[ Upstream commit 0b8eb629a700c0ef15a437758db8255f8444e76c ]
Release bip using kfree() in error path when that was allocated by kmalloc().
--- block/bio-integrity.c | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-)
block/bio-integrity.c +14 -9
@@ -38,6 +38,18 @@ void blk_flush_integrity(void)flush_workqueue (kintegrityd_wq); } +void __bio_integrity_free (struct bio_set *bs,struct bio_integrity_payload *bip) +{ +if (bs &&mempool_initialized (&bs->bio_integrity_pool)) { +if (bip->bip_vec) +bvec_free (&bs->bvec_integrity_pool, bip->bip_vec, + bip->bip_slab); +mempool_free (bip, &bs->bio_integrity_pool); + }else { +kfree (bip); + } +} +/** * bio_integrity_alloc - Allocate integrity payload and attach it to bio * @bio: bio to attach integrity metadata to
@@ -90,7 +102,7 @@ struct bio_integrity_payload *bio_integrity_alloc(struct bio *bio,return bip; err: -mempool_free (bip, &bs->bio_integrity_pool); +__bio_integrity_free (bs, bip);return ERR_PTR (-ENOMEM ); }EXPORT_SYMBOL (bio_integrity_alloc);
@@ -111,14 +123,7 @@ static void bio_integrity_free(struct bio *bio)kfree (page_address (bip->bip_vec->bv_page) + bip->bip_vec->bv_offset); -if (bs &&mempool_initialized (&bs->bio_integrity_pool)) { -bvec_free (&bs->bvec_integrity_pool, bip->bip_vec, bip->bip_slab); - -mempool_free (bip, &bs->bio_integrity_pool); - }else { -kfree (bip); - } - +__bio_integrity_free (bs, bip); bio->bi_integrity =NULL ; bio->bi_opf &= ~REQ_INTEGRITY ; }
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 25/27 nvme-rdma: assign completion vector correctly
In reply to Sasha LevinFrom: Max Gurtovoy <[email protected]>
[ Upstream commit 032a9966a22a3596addf81dacf0c1736dfedc32a ]
The completion vector index that is given during CQ creation can't exceed the number of support vectors by the underlying RDMA device. This violation currently can accure, for example, in case one will try to connect with N regular read/write queues and M poll queues and the sum of N + M > num_supported_vectors. This will lead to failure in establish a connection to remote target. Instead, in that case, share a completion vector between queues.
--- drivers/nvme/host/rdma.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/nvme/host/rdma.c +1 -1
@@ -447,7 +447,7 @@ static int nvme_rdma_create_queue_ib(struct nvme_rdma_queue *queue)* Spread I/O queues completion vectors according their queue index. * Admin queues can always go on completion vector 0. */ - comp_vector = idx ==0 ? idx : idx -1 ; + comp_vector = (idx ==0 ? idx : idx -1 ) % ibdev->num_comp_vectors;/* +1 for ib_stop_cq */ queue->ib_cq = ib_alloc_cq(ibdev, queue,
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 26/27 x86/entry: Increase entry_stack size to a full page
In reply to Sasha LevinFrom: Peter Zijlstra <[email protected]>
[ Upstream commit c7aadc09321d8f9a1d3bd1e6d8a47222ecddf6c5 ]
Marco crashed in bad_iret with a Clang11/KCSAN build due to overflowing the stack. Now that we run C code on it, expand it to a full page.
--- arch/x86/include/asm/processor.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/x86/include/asm/processor.h +1 -1
@@ -336,7 +336,7 @@ struct x86_hw_tss {#define INVALID_IO_BITMAP_OFFSET 0x8000struct entry_stack { -unsigned long words[64 ]; +char stack[PAGE_SIZE ]; };struct entry_stack_page {
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 27/27 kgdb: Avoid suspicious RCU usage warning
In reply to Sasha LevinFrom: Douglas Anderson <[email protected]>
[ Upstream commit 440ab9e10e2e6e5fd677473ee6f9e3af0f6904d6 ]
At times when I'm using kgdb I see a splat on my console about suspicious RCU usage. I managed to come up with a case that could reproduce this that looked like this:
WARNING: suspicious RCU usage
5.7.0-rc4+ #609 Not tainted
-----------------------------
kernel/pid.c:395 find_task_by_pid_ns() needs rcu_read_lock() protection!
other info that might help us debug this:
rcu_scheduler_active = 2, debug_locks = 1
3 locks held by swapper/0/1:
#0: ffffff81b6b8e988 (&dev->mutex){....}-{3:3}, at: __device_attach+0x40/0x13c #1: ffffffd01109e9e8 (dbg_master_lock){....}-{2:2}, at: kgdb_cpu_enter+0x20c/0x7ac #2: ffffffd01109ea90 (dbg_slave_lock){....}-{2:2}, at: kgdb_cpu_enter+0x3ec/0x7ac
stack backtrace: CPU: 7 PID: 1 Comm: swapper/0 Not tainted 5.7.0-rc4+ #609 Hardware name: Google Cheza (rev3+) (DT) Call trace: dump_backtrace+0x0/0x1b8 show_stack+0x1c/0x24 dump_stack+0xd4/0x134 lockdep_rcu_suspicious+0xf0/0x100 find_task_by_pid_ns+0x5c/0x80 getthread+0x8c/0xb0 gdb_serial_stub+0x9d4/0xd04 kgdb_cpu_enter+0x284/0x7ac kgdb_handle_exception+0x174/0x20c kgdb_brk_fn+0x24/0x30 call_break_hook+0x6c/0x7c brk_handler+0x20/0x5c do_debug_exception+0x1c8/0x22c el1_sync_handler+0x3c/0xe4 el1_sync+0x7c/0x100 rpmh_rsc_probe+0x38/0x420 platform_drv_probe+0x94/0xb4 really_probe+0x134/0x300 driver_probe_device+0x68/0x100 __device_attach_driver+0x90/0xa8 bus_for_each_drv+0x84/0xcc __device_attach+0xb4/0x13c device_initial_probe+0x18/0x20 bus_probe_device+0x38/0x98 device_add+0x38c/0x420
If I understand properly we should just be able to blanket kgdb under one big RCU read lock and the problem should go away. We'll add it to the beast-of-a-function known as kgdb_cpu_enter().
With this I no longer get any splats and things seem to work fine.
--- kernel/debug/debug_core.c | 4 ++++ 1 file changed, 4 insertions(+)
kernel/debug/debug_core.c +4 -0
@@ -489,6 +489,7 @@ static int kgdb_cpu_enter(struct kgdb_state *ks, struct pt_regs *regs, arch_kgdb_ops.disable_hw_break (regs); acquirelock: +rcu_read_lock ();/* * Interrupts will be restored by the 'trap return' code, except when * single stepping.
@@ -545,6 +546,7 @@ static int kgdb_cpu_enter(struct kgdb_state *ks, struct pt_regs *regs,atomic_dec (&slaves_in_kgdb);dbg_touch_watchdogs ();local_irq_restore (flags); +rcu_read_unlock ();return 0 ; }cpu_relax ();
@@ -563,6 +565,7 @@ static int kgdb_cpu_enter(struct kgdb_state *ks, struct pt_regs *regs,raw_spin_unlock (&dbg_master_lock);dbg_touch_watchdogs ();local_irq_restore (flags); +rcu_read_unlock (); goto acquirelock; }
@@ -686,6 +689,7 @@ static int kgdb_cpu_enter(struct kgdb_state *ks, struct pt_regs *regs,raw_spin_unlock (&dbg_master_lock);dbg_touch_watchdogs ();local_irq_restore (flags); +rcu_read_unlock ();return kgdb_info[cpu].ret_state; }
Signature · 1 line
2.25.1