5.7.16-rc1 review
Subsystems (4)
Greg Kroah-Hartman
maintainerPATCH 327/393 net: initialize fastreuse on inet_inherit_port
In reply to Greg Kroah-HartmanFrom: Tim Froidcoeur <[email protected]>
[ Upstream commit d76f3351cea2d927fdf70dd7c06898235035e84e ]
In the case of TPROXY, bind_conflict optimizations for SO_REUSEADDR or SO_REUSEPORT are broken, possibly resulting in O(n) instead of O(1) bind behaviour or in the incorrect reuse of a bind.
the kernel keeps track for each bind_bucket if all sockets in the bind_bucket support SO_REUSEADDR or SO_REUSEPORT in two fastreuse flags. These flags allow skipping the costly bind_conflict check when possible (meaning when all sockets have the proper SO_REUSE option).
For every socket added to a bind_bucket, these flags need to be updated. As soon as a socket that does not support reuse is added, the flag is set to false and will never go back to true, unless the bind_bucket is deleted.
Note that there is no mechanism to re-evaluate these flags when a socket is removed (this might make sense when removing a socket that would not allow reuse; this leaves room for a future patch).
For this optimization to work, it is mandatory that these flags are properly initialized and updated.
When a child socket is created from a listen socket in __inet_inherit_port, the TPROXY case could create a new bind bucket without properly initializing these flags, thus preventing the optimization to work. Alternatively, a socket not allowing reuse could be added to an existing bind bucket without updating the flags, causing bind_conflict to never be called as it should.
Call inet_csk_update_fastreuse when __inet_inherit_port decides to create a new bind_bucket or use a different bind_bucket than the one of the listen socket.
--- net/ipv4/inet_hashtables.c | 1 + 1 file changed, 1 insertion(+)
net/ipv4/inet_hashtables.c +1 -0
@@ -163,6 +163,7 @@ int __inet_inherit_port(const struct socreturn -ENOMEM ; } } +inet_csk_update_fastreuse (tb, child); }inet_bind_hash (child, tb, port);spin_unlock (&head->lock);
Greg Kroah-Hartman
maintainerPATCH 328/393 vsock: fix potential null pointer dereference in vsock_poll()
In reply to Greg Kroah-HartmanFrom: Stefano Garzarella <[email protected]>
[ Upstream commit 1980c05844830a44708c98c96d600833aa3fae08 ]
syzbot reported this issue where in the vsock_poll() we find the socket state at TCP_ESTABLISHED, but 'transport' is null:
general protection fault, probably for non-canonical address 0xdffffc0000000012: 0000 [#1] PREEMPT SMP KASAN KASAN: null-ptr-deref in range [0x0000000000000090-0x0000000000000097] CPU: 0 PID: 8227 Comm: syz-executor.2 Not tainted 5.8.0-rc7-syzkaller #0 Hardware name: Google Google Compute Engine/Google Compute Engine, BIOS Google 01/01/2011 RIP: 0010:vsock_poll+0x75a/0x8e0 net/vmw_vsock/af_vsock.c:1038 Call Trace: sock_poll+0x159/0x460 net/socket.c:1266 vfs_poll include/linux/poll.h:90 [inline] do_pollfd fs/select.c:869 [inline] do_poll fs/select.c:917 [inline] do_sys_poll+0x607/0xd40 fs/select.c:1011 __do_sys_poll fs/select.c:1069 [inline] __se_sys_poll fs/select.c:1057 [inline] __x64_sys_poll+0x18c/0x440 fs/select.c:1057 do_syscall_64+0x60/0xe0 arch/x86/entry/common.c:384 entry_SYSCALL_64_after_hwframe+0x44/0xa9
This issue can happen if the TCP_ESTABLISHED state is set after we read the vsk->transport in the vsock_poll().
We could put barriers to synchronize, but this can only happen during connection setup, so we can simply check that 'transport' is valid.
--- net/vmw_vsock/af_vsock.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
net/vmw_vsock/af_vsock.c +1 -1
@@ -1032,7 +1032,7 @@ static __poll_t vsock_poll(struct file * }/* Connected sockets that can produce data can be written. */ -if (sk->sk_state ==TCP_ESTABLISHED ) { +if (transport && sk->sk_state ==TCP_ESTABLISHED ) {if (!(sk->sk_shutdown &SEND_SHUTDOWN )) {bool space_avail_now = false; int ret = transport->notify_poll_out(
Greg Kroah-Hartman
maintainerPATCH 329/393 net: phy: marvell10g: fix null pointer dereference
In reply to Greg Kroah-HartmanFrom: "Marek Behún" <[email protected]>
[ Upstream commit 1b8ef1423dbfd34de2439a2db457b84480b7c8a8 ]
Commit c3e302edca24 ("net: phy: marvell10g: fix temperature sensor on 2110") added a check for PHY ID via phydev->drv->phy_id in a function which is called by devres at a time when phydev->drv is already set to null by phy_remove function.
This null pointer dereference can be triggered via SFP subsystem with a SFP module containing this Marvell PHY. When the SFP interface is put down, the SFP subsystem removes the PHY.
--- drivers/net/phy/marvell10g.c | 18 +++++++----------- 1 file changed, 7 insertions(+), 11 deletions(-)
drivers/net/phy/marvell10g.c +7 -11
@@ -205,13 +205,6 @@ static int mv3310_hwmon_config(struct ph MV_V2_TEMP_CTRL_MASK, val); } -static void mv3310_hwmon_disable (void *data) -{ -struct phy_device *phydev = data; - -mv3310_hwmon_config (phydev, false); -} -static int mv3310_hwmon_probe (struct phy_device *phydev) {struct device *dev = &phydev->mdio.dev;
@@ -235,10 +228,6 @@ static int mv3310_hwmon_probe(struct phyif (ret)return ret; - ret =devm_add_action_or_reset (dev, mv3310_hwmon_disable, phydev); -if (ret) -return ret; - priv->hwmon_dev =devm_hwmon_device_register_with_info (dev, priv->hwmon_name, phydev, &mv3310_hwmon_chip_info,NULL );
@@ -423,6 +412,11 @@ static int mv3310_probe(struct phy_devicreturn phy_sfp_probe (phydev, &mv3310_sfp_ops); } +static void mv3310_remove (struct phy_device *phydev) +{ +mv3310_hwmon_config (phydev, false); +} +static int mv3310_suspend (struct phy_device *phydev) {return mv3310_power_down (phydev);
@@ -763,6 +757,7 @@ static struct phy_driver mv3310_drivers[ .read_status = mv3310_read_status, .get_tunable = mv3310_get_tunable, .set_tunable = mv3310_set_tunable, + .remove = mv3310_remove, }, { .phy_id = MARVELL_PHY_ID_88E2110,
@@ -778,6 +773,7 @@ static struct phy_driver mv3310_drivers[ .read_status = mv3310_read_status, .get_tunable = mv3310_get_tunable, .set_tunable = mv3310_set_tunable, + .remove = mv3310_remove, }, };
Greg Kroah-Hartman
maintainerPATCH 330/393 USB: serial: cp210x: re-enable auto-RTS on open
In reply to Greg Kroah-HartmanFrom: Brant Merryman <[email protected]>
commit c7614ff9b73a1e6fb2b1b51396da132ed22fecdb upstream.
CP210x hardware disables auto-RTS but leaves auto-CTS when in hardware flow control mode and UART on cp210x hardware is disabled. When re-opening the port, if auto-CTS is enabled on the cp210x, then auto-RTS must be re-enabled in the driver.
--- drivers/usb/serial/cp210x.c | 17 +++++++++++++++++ 1 file changed, 17 insertions(+)
drivers/usb/serial/cp210x.c +17 -0
@@ -915,6 +915,7 @@ static void cp210x_get_termios_port(struu32 baud;u16 bits;u32 ctl_hs; +u32 flow_repl;cp210x_read_u32_reg (port,CP210X_GET_BAUDRATE , &baud);
@@ -1015,6 +1016,22 @@ static void cp210x_get_termios_port(stru ctl_hs =le32_to_cpu (flow_ctl.ulControlHandshake);if (ctl_hs &CP210X_SERIAL_CTS_HANDSHAKE ) {dev_dbg (dev,"%s - flow control = CRTSCTS\n" , __func__); +/* +* When the port is closed, the CP210x hardware disables +* auto-RTS and RTS is deasserted but it leaves auto-CTS when +* in hardware flow control mode. When re-opening the port, if +* auto-CTS is enabled on the cp210x, then auto-RTS must be +* re-enabled in the driver. +*/ + flow_repl =le32_to_cpu (flow_ctl.ulFlowReplace); + flow_repl &= ~CP210X_SERIAL_RTS_MASK ; + flow_repl |=CP210X_SERIAL_RTS_SHIFT (CP210X_SERIAL_RTS_FLOW_CTL ); + flow_ctl.ulFlowReplace =cpu_to_le32 (flow_repl); +cp210x_write_reg_block (port, +CP210X_SET_FLOW , + &flow_ctl, +sizeof (flow_ctl)); + cflag |=CRTSCTS ; }else {dev_dbg (dev,"%s - flow control = NONE\n" , __func__);
Greg Kroah-Hartman
maintainerPATCH 331/393 USB: serial: cp210x: enable usb generic throttle/unthrottle
In reply to Greg Kroah-HartmanFrom: Brant Merryman <[email protected]>
commit 4387b3dbb079d482d3c2b43a703ceed4dd27ed28 upstream.
Assign the .throttle and .unthrottle functions to be generic function in the driver structure to prevent data loss that can otherwise occur if the host does not enable USB throttling.
--- drivers/usb/serial/cp210x.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/usb/serial/cp210x.c +2 -0
@@ -272,6 +272,8 @@ static struct usb_serial_driver cp210x_d .break_ctl = cp210x_break_ctl, .set_termios = cp210x_set_termios, .tx_empty = cp210x_tx_empty, + .throttle = usb_serial_generic_throttle, + .unthrottle = usb_serial_generic_unthrottle, .tiocmget = cp210x_tiocmget, .tiocmset = cp210x_tiocmset, .attach = cp210x_attach,
Greg Kroah-Hartman
maintainerPATCH 332/393 usb: cdns3: gadget: always zeroed TRB buffer when enable endpoint
In reply to Greg Kroah-HartmanFrom: Peter Chen <[email protected]>
commit 95f5acfc4f58f01a22b66d8c9c0ffb72aa96271c upstream.
During the endpoint dequeue operation, it changes dequeued TRB as link TRB, when the endpoint is disabled and re-enabled, the DMA fetches the TRB before the link TRB, after it handles current TRB, the DMA pointer will advance to the TRB after link TRB, but enqueue and dequene variables don't know it due to no hardware interrupt at the time, when the next TRB is added to link TRB position, the DMA will not handle this TRB due to its pointer is already at the next TRB. See the trace log like below:
file-storage-675 [001] d..1 86.585657: usb_ep_queue: ep0: req 00000000df9b3a4f length 0/0 sgs 0/0 stream 0 zsI status 0 --> 0
file-storage-675 [001] d..1 86.585663: cdns3_ep_queue: ep1out: req: 000000002ebce364, req buff 00000000f5bc96b4, length: 0/1024 zsi, status: -115, trb: [start:0, end:0: virt addr (null)], flags:0 SID: 0
file-storage-675 [001] d..1 86.585671: cdns3_prepare_trb: ep1out: trb 000000007f770303, dma buf: 0xbd195800, size: 1024, burst: 128 ctrl: 0x00000425 (C=1, T=0, ISP, IOC, Normal) SID:0 LAST_SID:0
file-storage-675 [001] d..1 86.585676: cdns3_ring:
Ring contents for ep1out:
Ring deq index: 0, trb: 000000007f770303 (virt), 0xc4003000 (dma)
Ring enq index: 1, trb: 0000000049c1ba21 (virt), 0xc400300c (dma)
free trbs: 38, CCS=1, PCS=1
@0x00000000c4003000 bd195800 80020400 00000425
@0x00000000c400300c c4003018 80020400 00001811
@0x00000000c4003018 bcfcc000 0000001f 00000426
@0x00000000c4003024 bcfce800 0000001f 00000426
... irq/144-5b13000-698 [000] d... 87.619286: usb_gadget_giveback_request: ep1in: req 0000000031b832eb length 13/13 sgs 0/0 stream 0 zsI status 0 --> 0
file-storage-675 [001] d..1 87.619287: cdns3_ep_queue: ep1out: req: 000000002ebce364, req buff 00000000f5bc96b4, length: 0/1024 zsi, status: -115, trb: [start:0, end:0: virt addr 0x80020400c400300c], flags:0 SID: 0
file-storage-675 [001] d..1 87.619294: cdns3_prepare_trb: ep1out: trb 0000000049c1ba21, dma buf: 0xbd198000, size: 1024, burst: 128 ctrl: 0x00000425 (C=1, T=0, ISP, IOC, Normal) SID:0 LAST_SID:0
file-storage-675 [001] d..1 87.619297: cdns3_ring:
Ring contents for ep1out:
Ring deq index: 1, trb: 0000000049c1ba21 (virt), 0xc400300c (dma)
Ring enq index: 2, trb: 0000000059b34b67 (virt), 0xc4003018 (dma)
free trbs: 38, CCS=1, PCS=1
@0x00000000c4003000 bd195800 0000001f 00000427
@0x00000000c400300c bd198000 80020400 00000425
@0x00000000c4003018 bcfcc000 0000001f 00000426
@0x00000000c4003024 bcfce800 0000001f 00000426
...
file-storage-675 [001] d..1 87.619305: cdns3_doorbell_epx: ep1out, ep_trbaddr c4003018
file-storage-675 [001] .... 87.619308: usb_ep_queue: ep1out: req 000000002ebce364 length 0/1024 sgs 0/0 stream 0 zsI status -115 --> 0
irq/144-5b13000-698 [000] d..1 87.619315: cdns3_epx_irq: IRQ for ep1out: 01000c80 TRBERR , ep_traddr: c4003018 ep_last_sid: 00000000 use_streams: 0
irq/144-5b13000-698 [000] d..1 87.619395: cdns3_usb_irq: IRQ 00000008 = Hot Reset--- drivers/usb/cdns3/gadget.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/usb/cdns3/gadget.c +2 -1
@@ -242,9 +242,10 @@ int cdns3_allocate_trb_pool(struct cdns3return -ENOMEM ; priv_ep->alloc_ring_size = ring_size; -memset (priv_ep->trb_pool,0 , ring_size); } +memset (priv_ep->trb_pool,0 , ring_size); + priv_ep->num_trbs = num_trbs;if (!priv_ep->num)
Greg Kroah-Hartman
maintainerPATCH 333/393 vdpasim: protect concurrent access to iommu iotlb
In reply to Greg Kroah-HartmanFrom: Max Gurtovoy <[email protected]>
commit 0ea9ee430e74b16c6b17e70757d1c26d8d140e1f upstream.
Iommu iotlb can be accessed by different cores for performing IO using multiple virt queues. Add a spinlock to synchronize iotlb accesses.
This could be easily reproduced when using more than 1 pktgen threads to inject traffic to vdpa simulator.
--- drivers/vdpa/vdpa_sim/vdpa_sim.c | 31 +++++++++++++++++++++++++++---- 1 file changed, 27 insertions(+), 4 deletions(-)
drivers/vdpa/vdpa_sim/vdpa_sim.c +27 -4
@@ -70,6 +70,8 @@ struct vdpasim {u32 status;u32 generation;u64 features; +/* spinlock to synchronize iommu table */ +spinlock_t iommu_lock; };static struct vdpasim *vdpasim_dev;
@@ -118,7 +120,9 @@ static void vdpasim_reset(struct vdpasimfor (i =0 ; i <VDPASIM_VQ_NUM ; i++)vdpasim_vq_reset (&vdpasim->vqs[i]); +spin_lock (&vdpasim->iommu_lock);vhost_iotlb_reset (vdpasim->iommu); +spin_unlock (&vdpasim->iommu_lock); vdpasim->features =0 ; vdpasim->status =0 ;
@@ -235,8 +239,10 @@ static dma_addr_t vdpasim_map_page(struc/* For simplicity, use identical mapping to avoid e.g iova * allocator. */ +spin_lock (&vdpasim->iommu_lock); ret =vhost_iotlb_add_range (iommu, pa, pa + size -1 , pa,dir_to_perm (dir)); +spin_unlock (&vdpasim->iommu_lock);if (ret)return DMA_MAPPING_ERROR ;
@@ -250,8 +256,10 @@ static void vdpasim_unmap_page(struct destruct vdpasim *vdpasim =dev_to_sim (dev);struct vhost_iotlb *iommu = vdpasim->iommu; +spin_lock (&vdpasim->iommu_lock);vhost_iotlb_del_range (iommu, (u64 )dma_addr, (u64 )dma_addr + size -1 ); +spin_unlock (&vdpasim->iommu_lock); } static void *vdpasim_alloc_coherent(struct device *dev, size_t size,
@@ -263,9 +271,10 @@ static void *vdpasim_alloc_coherent(struvoid *addr =kmalloc (size, flag);int ret; -if (!addr) +spin_lock (&vdpasim->iommu_lock); +if (!addr) { *dma_addr =DMA_MAPPING_ERROR ; -else { + }else {u64 pa =virt_to_phys (addr); ret = vhost_iotlb_add_range(iommu, (u64)pa,
@@ -278,6 +287,7 @@ static void *vdpasim_alloc_coherent(stru }else *dma_addr = (dma_addr_t )pa; } +spin_unlock (&vdpasim->iommu_lock);return addr; }
@@ -289,8 +299,11 @@ static void vdpasim_free_coherent(structstruct vdpasim *vdpasim =dev_to_sim (dev);struct vhost_iotlb *iommu = vdpasim->iommu; +spin_lock (&vdpasim->iommu_lock);vhost_iotlb_del_range (iommu, (u64 )dma_addr, (u64 )dma_addr + size -1 ); +spin_unlock (&vdpasim->iommu_lock); +kfree (phys_to_virt ((uintptr_t )dma_addr)); }
@@ -531,6 +544,7 @@ static int vdpasim_set_map(struct vdpa_du64 start =0ULL , last =0ULL -1 ;int ret; +spin_lock (&vdpasim->iommu_lock);vhost_iotlb_reset (vdpasim->iommu); for (map = vhost_iotlb_itree_first(iotlb, start, last); map;
@@ -540,10 +554,12 @@ static int vdpasim_set_map(struct vdpa_dif (ret) goto err; } +spin_unlock (&vdpasim->iommu_lock);return 0 ; err:vhost_iotlb_reset (vdpasim->iommu); +spin_unlock (&vdpasim->iommu_lock);return ret; }
@@ -551,16 +567,23 @@ static int vdpasim_dma_map(struct vdpa_d u64 pa, u32 perm) {struct vdpasim *vdpasim =vdpa_to_sim (vdpa); +int ret; -return vhost_iotlb_add_range (vdpasim->iommu, iova, - iova + size -1 , pa, perm); +spin_lock (&vdpasim->iommu_lock); + ret =vhost_iotlb_add_range (vdpasim->iommu, iova, iova + size -1 , pa, + perm); +spin_unlock (&vdpasim->iommu_lock); + +return ret; }static int vdpasim_dma_unmap (struct vdpa_device *vdpa,u64 iova,u64 size) {struct vdpasim *vdpasim =vdpa_to_sim (vdpa); +spin_lock (&vdpasim->iommu_lock);vhost_iotlb_del_range (vdpasim->iommu, iova, iova + size -1 ); +spin_unlock (&vdpasim->iommu_lock);return 0 ; }
Greg Kroah-Hartman
maintainerPATCH 334/393 ALSA: hda - fix the micmute led status for Lenovo ThinkCentre AIO
In reply to Greg Kroah-HartmanFrom: Hui Wang <[email protected]>
commit 386a6539992b82fe9ac4f9dc3f548956fd894d8c upstream.
After installing the Ubuntu Linux, the micmute led status is not correct. Users expect that the led is on if the capture is disabled, but with the current kernel, the led is off with the capture disabled.
We tried the old linux kernel like linux-4.15, there is no this issue. It looks like we introduced this issue when switching to the led_cdev.
--- sound/pci/hda/patch_realtek.c | 1 + 1 file changed, 1 insertion(+)
sound/pci/hda/patch_realtek.c +1 -0
@@ -4391,6 +4391,7 @@ static void alc233_fixup_lenovo_line2_mi {struct alc_spec *spec = codec->spec; + spec->micmute_led_polarity =1 ;alc_fixup_hp_gpio_led (codec, action,0 ,0x04 );if (action ==HDA_FIXUP_ACT_PRE_PROBE ) { spec->init_amp =ALC_INIT_DEFAULT ;
Greg Kroah-Hartman
maintainerPATCH 335/393 ALSA: usb-audio: Creative USB X-Fi Pro SB1095 volume knob support
In reply to Greg Kroah-HartmanFrom: Mirko Dietrich <[email protected]>
commit fec9008828cde0076aae595ac031bfcf49d335a4 upstream.
Adds an entry for Creative USB X-Fi to the rc_config array in mixer_quirks.c to allow use of volume knob on the device. Adds support for newer X-Fi Pro card, known as "Model No. SB1095" with USB ID "041e:3263"
--- sound/usb/mixer_quirks.c | 1 + 1 file changed, 1 insertion(+)
sound/usb/mixer_quirks.c +1 -0
@@ -185,6 +185,7 @@ static const struct rc_config { { USB_ID(0x041e, 0x3042), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 */ { USB_ID(0x041e, 0x30df), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */ { USB_ID(0x041e, 0x3237), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */ + { USB_ID(0x041e, 0x3263), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */ { USB_ID(0x041e, 0x3048), 2, 2, 6, 6, 2, 0x6e91 }, /* Toshiba SB0500 */ };
Greg Kroah-Hartman
maintainerPATCH 336/393 ALSA: usb-audio: fix overeager device match for MacroSilicon MS2109
In reply to Greg Kroah-HartmanFrom: Hector Martin <[email protected]>
commit 14a720dc1f5332f3bdf30a23a3bc549e81be974c upstream.
Matching by device matches all interfaces, which breaks the video/HID portions of the device depending on module load order.
--- sound/usb/quirks-table.h | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-)
sound/usb/quirks-table.h +7 -1
@@ -3623,7 +3623,13 @@ ALC1220_VB_DESKTOP(0x26ce, 0x0a01), /* A* with. */ { - USB_DEVICE(0x534d, 0x2109), + .match_flags = USB_DEVICE_ID_MATCH_DEVICE | +USB_DEVICE_ID_MATCH_INT_CLASS | + USB_DEVICE_ID_MATCH_INT_SUBCLASS, + .idVendor = 0x534d, + .idProduct = 0x2109, + .bInterfaceClass = USB_CLASS_AUDIO, + .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, .driver_info = (unsigned long ) &(const struct snd_usb_audio_quirk ) { .vendor_name ="MacroSilicon" , .product_name ="MS2109" ,
Greg Kroah-Hartman
maintainerPATCH 337/393 ALSA: usb-audio: work around streaming quirk for MacroSilicon MS2109
In reply to Greg Kroah-HartmanFrom: Hector Martin <[email protected]>
commit 1b7ecc241a67ad6b584e071bd791a54e0cd5f097 upstream.
Further investigation of the L-R swap problem on the MS2109 reveals that the problem isn't that the channels are swapped, but rather that they are swapped and also out of phase by one sample. In other words, the issue is actually that the very first frame that comes from the hardware is a half-frame containing only the right channel, and after that everything becomes offset.
So introduce a new quirk field to drop the very first 2 bytes that come in after the format is configured and a capture stream starts. This puts the channels in phase and in the correct order.
--- sound/usb/card.h | 1 + sound/usb/pcm.c | 6 ++++++ sound/usb/quirks.c | 3 +++ sound/usb/stream.c | 1 + 4 files changed, 11 insertions(+)
sound/usb/card.h +1 -0
@@ -133,6 +133,7 @@ struct snd_usb_substream { unsigned int tx_length_quirk:1; /* add length specifier to transfers */unsigned int fmt_type;/* USB audio format type (1-3) */ unsigned int pkt_offset_adj;/* Bytes to drop from beginning of packets (for non-compliant devices) */ +unsigned int stream_offset_adj;/* Bytes to drop from beginning of stream (for non-compliant devices) */ unsigned int running: 1; /* running status */
sound/usb/pcm.c +6 -0
@@ -1416,6 +1416,12 @@ static void retire_capture_urb(struct sn// continue; } bytes = urb->iso_frame_desc[i].actual_length; +if (subs->stream_offset_adj >0 ) { +unsigned int adj =min (subs->stream_offset_adj, bytes); + cp += adj; + bytes -= adj; + subs->stream_offset_adj -= adj; + } frames = bytes / stride;if (!subs->txfr_quirk) bytes = frames * stride;
sound/usb/quirks.c +3 -0
@@ -1468,6 +1468,9 @@ void snd_usb_set_format_quirk(struct sndcase USB_ID (0x041e ,0x3f19 ):/* E-Mu 0204 USB */ set_format_emu_quirk (subs, fmt);break ; +case USB_ID (0x534d ,0x2109 ):/* MacroSilicon MS2109 */ + subs->stream_offset_adj =2 ; +break ; } }
sound/usb/stream.c +1 -0
@@ -94,6 +94,7 @@ static void snd_usb_init_substream(struc subs->tx_length_quirk = as->chip->tx_length_quirk; subs->speed =snd_usb_get_speed (subs->dev); subs->pkt_offset_adj =0 ; + subs->stream_offset_adj =0 ;snd_usb_set_pcm_ops (as->pcm, stream);
Greg Kroah-Hartman
maintainerPATCH 338/393 ALSA: usb-audio: add quirk for Pioneer DDJ-RB
In reply to Greg Kroah-HartmanFrom: Hector Martin <[email protected]>
commit 6e8596172ee1cd46ec0bfd5adcf4ff86371478b6 upstream.
This is just another Pioneer device with fixed endpoints. Input is dummy but used as feedback (it always returns silence).
--- sound/usb/quirks-table.h | 56 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+)
sound/usb/quirks-table.h +56 -0
@@ -3570,6 +3570,62 @@ AU0828_DEVICE(0x2040, 0x7270, "Hauppauge } } }, +{ +/* +* PIONEER DJ DDJ-RB +* PCM is 4 channels out, 2 dummy channels in @ 44.1 fixed +* The feedback for the output is the dummy input. +*/ + USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000e), + .driver_info = (unsigned long ) &(const struct snd_usb_audio_quirk ) { + .ifnum =QUIRK_ANY_INTERFACE , + .type =QUIRK_COMPOSITE , + .data = (const struct snd_usb_audio_quirk []) { + { + .ifnum =0 , + .type =QUIRK_AUDIO_FIXED_ENDPOINT , + .data = &(const struct audioformat ) { + .formats =SNDRV_PCM_FMTBIT_S24_3LE , + .channels =4 , + .iface =0 , + .altsetting =1 , + .altset_idx =1 , + .endpoint =0x01 , + .ep_attr =USB_ENDPOINT_XFER_ISOC | +USB_ENDPOINT_SYNC_ASYNC , + .rates =SNDRV_PCM_RATE_44100 , + .rate_min =44100 , + .rate_max =44100 , + .nr_rates =1 , + .rate_table = (unsigned int []) {44100 } + } + }, + { + .ifnum =0 , + .type =QUIRK_AUDIO_FIXED_ENDPOINT , + .data = &(const struct audioformat ) { + .formats =SNDRV_PCM_FMTBIT_S24_3LE , + .channels =2 , + .iface =0 , + .altsetting =1 , + .altset_idx =1 , + .endpoint =0x82 , + .ep_attr =USB_ENDPOINT_XFER_ISOC | +USB_ENDPOINT_SYNC_ASYNC | +USB_ENDPOINT_USAGE_IMPLICIT_FB , + .rates =SNDRV_PCM_RATE_44100 , + .rate_min =44100 , + .rate_max =44100 , + .nr_rates =1 , + .rate_table = (unsigned int []) {44100 } + } + }, + { + .ifnum =-1 + } + } + } +}, #define ALC1220_VB_DESKTOP(vend, prod) { \ USB_DEVICE(vend, prod), \
Greg Kroah-Hartman
maintainerPATCH 339/393 tpm: Unify the mismatching TPM space buffer sizes
In reply to Greg Kroah-HartmanFrom: Jarkko Sakkinen <[email protected]>
commit 6c4e79d99e6f42b79040f1a33cd4018f5425030b upstream.
The size of the buffers for storing context's and sessions can vary from arch to arch as PAGE_SIZE can be anything between 4 kB and 256 kB (the maximum for PPC64). Define a fixed buffer size set to 16 kB. This should be enough for most use with three handles (that is how many we allow at the moment). Parametrize the buffer size while doing this, so that it is easier to revisit this later on if required.
--- drivers/char/tpm/tpm-chip.c | 9 ++------- drivers/char/tpm/tpm.h | 5 ++++- drivers/char/tpm/tpm2-space.c | 26 ++++++++++++++++---------- drivers/char/tpm/tpmrm-dev.c | 2 +- include/linux/tpm.h | 1 + 5 files changed, 24 insertions(+), 19 deletions(-)
drivers/char/tpm/tpm-chip.c +2 -7
@@ -386,13 +386,8 @@ struct tpm_chip *tpm_chip_alloc(struct d chip->cdev.owner =THIS_MODULE ; chip->cdevs.owner =THIS_MODULE ; - chip->work_space.context_buf =kzalloc (PAGE_SIZE ,GFP_KERNEL ); -if (!chip->work_space.context_buf) { - rc = -ENOMEM ; - goto out; - } - chip->work_space.session_buf =kzalloc (PAGE_SIZE ,GFP_KERNEL ); -if (!chip->work_space.session_buf) { + rc =tpm2_init_space (&chip->work_space,TPM2_SPACE_BUFFER_SIZE ); +if (rc) { rc = -ENOMEM ; goto out; }
drivers/char/tpm/tpm.h +4 -1
@@ -59,6 +59,9 @@ enum tpm_addr {#define TPM_TAG_RQU_COMMAND 193 +/* TPM2 specific constants. */ +#define TPM2_SPACE_BUFFER_SIZE 16384/* 16 kB */ +struct stclear_flags_t {__be16 tag;u8 deactivated;
@@ -228,7 +231,7 @@ unsigned long tpm2_calc_ordinal_durationint tpm2_probe (struct tpm_chip *chip);int tpm2_get_cc_attrs_tbl (struct tpm_chip *chip);int tpm2_find_cc (struct tpm_chip *chip,u32 cc); -int tpm2_init_space (struct tpm_space *space); +int tpm2_init_space (struct tpm_space *space,unsigned int buf_size);void tpm2_del_space (struct tpm_chip *chip,struct tpm_space *space);void tpm2_flush_space (struct tpm_chip *chip); int tpm2_prepare_space(struct tpm_chip *chip, struct tpm_space *space, u8 *cmd,
drivers/char/tpm/tpm2-space.c +16 -10
@@ -38,18 +38,21 @@ static void tpm2_flush_sessions(struct t } } -int tpm2_init_space (struct tpm_space *space) +int tpm2_init_space (struct tpm_space *space,unsigned int buf_size) { - space->context_buf =kzalloc (PAGE_SIZE ,GFP_KERNEL ); + space->context_buf =kzalloc (buf_size,GFP_KERNEL );if (!space->context_buf)return -ENOMEM ; - space->session_buf =kzalloc (PAGE_SIZE ,GFP_KERNEL ); + space->session_buf =kzalloc (buf_size,GFP_KERNEL );if (space->session_buf ==NULL ) {kfree (space->context_buf); +/* Prevent caller getting a dangling pointer. */ + space->context_buf =NULL ;return -ENOMEM ; } + space->buf_size = buf_size;return 0 ; }
@@ -311,8 +314,10 @@ int tpm2_prepare_space(struct tpm_chip * sizeof(space->context_tbl));memcpy (&chip->work_space.session_tbl, &space->session_tbl,sizeof (space->session_tbl)); -memcpy (chip->work_space.context_buf, space->context_buf,PAGE_SIZE ); -memcpy (chip->work_space.session_buf, space->session_buf,PAGE_SIZE ); +memcpy (chip->work_space.context_buf, space->context_buf, + space->buf_size); +memcpy (chip->work_space.session_buf, space->session_buf, + space->buf_size); rc =tpm2_load_space (chip);if (rc) {
@@ -492,7 +497,7 @@ static int tpm2_save_space(struct tpm_chcontinue ; rc =tpm2_save_context (chip, space->context_tbl[i], - space->context_buf,PAGE_SIZE , + space->context_buf, space->buf_size, &offset);if (rc == -ENOENT ) { space->context_tbl[i] =0 ;
@@ -509,9 +514,8 @@ static int tpm2_save_space(struct tpm_chcontinue ; rc =tpm2_save_context (chip, space->session_tbl[i], - space->session_buf,PAGE_SIZE , + space->session_buf, space->buf_size, &offset); -if (rc == -ENOENT ) {/* handle error saving session, just forget it */ space->session_tbl[i] =0 ;
@@ -557,8 +561,10 @@ int tpm2_commit_space(struct tpm_chip *c sizeof(space->context_tbl));memcpy (&space->session_tbl, &chip->work_space.session_tbl,sizeof (space->session_tbl)); -memcpy (space->context_buf, chip->work_space.context_buf,PAGE_SIZE ); -memcpy (space->session_buf, chip->work_space.session_buf,PAGE_SIZE ); +memcpy (space->context_buf, chip->work_space.context_buf, + space->buf_size); +memcpy (space->session_buf, chip->work_space.session_buf, + space->buf_size);return 0 ; out:
drivers/char/tpm/tpmrm-dev.c +1 -1
@@ -21,7 +21,7 @@ static int tpmrm_open(struct inode *inodif (priv ==NULL )return -ENOMEM ; - rc =tpm2_init_space (&priv->space); + rc =tpm2_init_space (&priv->space,TPM2_SPACE_BUFFER_SIZE );if (rc) {kfree (priv);return -ENOMEM ;
include/linux/tpm.h +1 -0
@@ -96,6 +96,7 @@ struct tpm_space {u8 *context_buf;u32 session_tbl[3 ];u8 *session_buf; +u32 buf_size; };struct tpm_bios_log {
Greg Kroah-Hartman
maintainerPATCH 340/393 pstore: Fix linking when crypto API disabled
In reply to Greg Kroah-HartmanFrom: Matteo Croce <[email protected]>
commit fd49e03280e596e54edb93a91bc96170f8e97e4a upstream.
When building a kernel with CONFIG_PSTORE=y and CONFIG_CRYPTO not set, a build error happens:
ld: fs/pstore/platform.o: in function `pstore_dump':
platform.c:(.text+0x3f9): undefined reference to `crypto_comp_compress'
ld: fs/pstore/platform.o: in function `pstore_get_backend_records':
platform.c:(.text+0x784): undefined reference to `crypto_comp_decompress'
This because some pstore code uses crypto_comp_(de)compress regardless of the CONFIG_CRYPTO status. Fix it by wrapping the (de)compress usage by IS_ENABLED(CONFIG_PSTORE_COMPRESS)
--- fs/pstore/platform.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
fs/pstore/platform.c +4 -1
@@ -275,6 +275,9 @@ static int pstore_compress(const void *i {int ret; +if (!IS_ENABLED (CONFIG_PSTORE_COMPRESSION )) +return -EINVAL ; + ret =crypto_comp_compress (tfm, in, inlen, out, &outlen);if (ret) {pr_err ("crypto_comp_compress failed, ret = %d!\n" , ret);
@@ -661,7 +664,7 @@ static void decompress_record(struct pstint unzipped_len;char *unzipped, *workspace; -if (!record->compressed) +if (!IS_ENABLED (CONFIG_PSTORE_COMPRESSION ) || !record->compressed)return ;/* Only PSTORE_TYPE_DMESG support compression. */
Greg Kroah-Hartman
maintainerPATCH 341/393 crypto: hisilicon - dont sleep of CRYPTO_TFM_REQ_MAY_SLEEP was not specified
In reply to Greg Kroah-HartmanFrom: Mikulas Patocka <[email protected]>
commit 5ead051780404b5cb22147170acadd1994dc3236 upstream.
There is this call chain:sec_alg_skcipher_encrypt -> sec_alg_skcipher_crypto -> sec_alg_alloc_and_calc_split_sizes -> kcalloc
where we call sleeping allocator function even if CRYPTO_TFM_REQ_MAY_SLEEP was not specified.
--- drivers/crypto/hisilicon/sec/sec_algs.c | 34 ++++++++++++++++---------------- 1 file changed, 18 insertions(+), 16 deletions(-)
drivers/crypto/hisilicon/sec/sec_algs.c +18 -16
@@ -175,7 +175,8 @@ static int sec_alloc_and_fill_hw_sgl(strdma_addr_t *psec_sgl, struct scatterlist *sgl, int count, - struct sec_dev_info *info) + struct sec_dev_info *info, + gfp_t gfp) { struct sec_hw_sgl *sgl_current = NULL;struct sec_hw_sgl *sgl_next;
@@ -190,7 +191,7 @@ static int sec_alloc_and_fill_hw_sgl(str sge_index = i %SEC_MAX_SGE_NUM ;if (sge_index ==0 ) { sgl_next =dma_pool_zalloc (info->hw_sgl_pool, -GFP_KERNEL , &sgl_next_dma); + gfp, &sgl_next_dma);if (!sgl_next) { ret = -ENOMEM ; goto err_free_hw_sgls;
@@ -545,14 +546,14 @@ void sec_alg_callback(struct sec_bd_info }static int sec_alg_alloc_and_calc_split_sizes (int length,size_t **split_sizes, -int *steps) +int *steps,gfp_t gfp) {size_t *sizes;int i;/* Split into suitable sized blocks */ *steps =roundup (length,SEC_REQ_LIMIT ) /SEC_REQ_LIMIT ; - sizes =kcalloc (*steps,sizeof (*sizes),GFP_KERNEL ); + sizes =kcalloc (*steps,sizeof (*sizes), gfp);if (!sizes)return -ENOMEM ;
@@ -568,7 +569,7 @@ static int sec_map_and_split_sg(struct s int steps, struct scatterlist ***splits, int **splits_nents, int sgl_len_in, - struct device *dev) + struct device *dev, gfp_t gfp) { int ret, count;
@@ -576,12 +577,12 @@ static int sec_map_and_split_sg(struct sif (!count)return -EINVAL ; - *splits =kcalloc (steps,sizeof (struct scatterlist *),GFP_KERNEL ); + *splits =kcalloc (steps,sizeof (struct scatterlist *), gfp);if (!*splits) { ret = -ENOMEM ; goto err_unmap_sg; } - *splits_nents =kcalloc (steps,sizeof (int ),GFP_KERNEL ); + *splits_nents =kcalloc (steps,sizeof (int ), gfp);if (!*splits_nents) { ret = -ENOMEM ; goto err_free_splits;
@@ -589,7 +590,7 @@ static int sec_map_and_split_sg(struct s/* output the scatter list before and after this */ ret =sg_split (sgl, count,0 , steps, split_sizes, - *splits, *splits_nents,GFP_KERNEL ); + *splits, *splits_nents, gfp);if (ret) { ret = -ENOMEM ; goto err_free_splits_nents;
@@ -630,13 +631,13 @@ static struct sec_request_el int el_size, bool different_dest, struct scatterlist *sgl_in, int n_ents_in, struct scatterlist *sgl_out, int n_ents_out, - struct sec_dev_info *info) + struct sec_dev_info *info, gfp_t gfp) { struct sec_request_el *el;struct sec_bd_info *req;int ret; - el =kzalloc (sizeof (*el),GFP_KERNEL ); + el =kzalloc (sizeof (*el), gfp);if (!el)return ERR_PTR (-ENOMEM ); el->el_length = el_size;
@@ -668,7 +669,7 @@ static struct sec_request_el el->sgl_in = sgl_in; ret =sec_alloc_and_fill_hw_sgl (&el->in, &el->dma_in, el->sgl_in, - n_ents_in, info); + n_ents_in, info, gfp);if (ret) goto err_free_el;
@@ -679,7 +680,7 @@ static struct sec_request_el el->sgl_out = sgl_out; ret =sec_alloc_and_fill_hw_sgl (&el->out, &el->dma_out, el->sgl_out, - n_ents_out, info); + n_ents_out, info, gfp);if (ret) goto err_free_hw_sgl_in;
@@ -720,6 +721,7 @@ static int sec_alg_skcipher_crypto(strucint *splits_out_nents =NULL ;struct sec_request_el *el, *temp;bool split = skreq->src != skreq->dst; +gfp_t gfp = skreq->base.flags &CRYPTO_TFM_REQ_MAY_SLEEP ?GFP_KERNEL :GFP_ATOMIC ;mutex_init (&sec_req->lock); sec_req->req_base = &skreq->base;
@@ -728,13 +730,13 @@ static int sec_alg_skcipher_crypto(struc sec_req->len_in =sg_nents (skreq->src); ret =sec_alg_alloc_and_calc_split_sizes (skreq->cryptlen, &split_sizes, - &steps); + &steps, gfp);if (ret)return ret; sec_req->num_elements = steps; ret =sec_map_and_split_sg (skreq->src, split_sizes, steps, &splits_in, &splits_in_nents, sec_req->len_in, - info->dev); + info->dev, gfp);if (ret) goto err_free_split_sizes;
@@ -742,7 +744,7 @@ static int sec_alg_skcipher_crypto(struc sec_req->len_out =sg_nents (skreq->dst); ret =sec_map_and_split_sg (skreq->dst, split_sizes, steps, &splits_out, &splits_out_nents, - sec_req->len_out, info->dev); + sec_req->len_out, info->dev, gfp);if (ret) goto err_unmap_in_sg; }
@@ -775,7 +777,7 @@ static int sec_alg_skcipher_crypto(struc splits_in[i], splits_in_nents[i], split ? splits_out[i] :NULL , split ? splits_out_nents[i] :0 , - info); + info, gfp);if (IS_ERR (el)) { ret =PTR_ERR (el); goto err_free_elements;
Greg Kroah-Hartman
maintainerPATCH 342/393 crypto: qat - fix double free in qat_uclo_create_batch_init_list
In reply to Greg Kroah-HartmanFrom: Tom Rix <[email protected]>
commit c06c76602e03bde24ee69a2022a829127e504202 upstream.
clang static analysis flags this error
qat_uclo.c:297:3: warning: Attempt to free released memory
[unix.Malloc]
kfree(*init_tab_base);
^~~~~~~~~~~~~~~~~~~~~When input *init_tab_base is null, the function allocates memory for the head of the list. When there is problem allocating other list elements the list is unwound and freed. Then a check is made if the list head was allocated and is also freed.
Keeping track of the what may need to be freed is the variable 'tail_old'. The unwinding/freeing block is
while (tail_old) {
mem_init = tail_old->next;
kfree(tail_old);
tail_old = mem_init;
}The problem is that the first element of tail_old is also what was allocated for the list head
init_header = kzalloc(sizeof(*init_header), GFP_KERNEL); ... *init_tab_base = init_header; flag = 1; } tail_old = init_header;
So *init_tab_base/init_header are freed twice.
There is another problem.
When the input *init_tab_base is non null the tail_old is calculated by traveling down the list to first non null entry.
tail_old = init_header; while (tail_old->next) tail_old = tail_old->next;
When the unwinding free happens, the last entry of the input list will be freed.
So the freeing needs a general changed.
If locally allocated the first element of tail_old is freed, else it is skipped. As a bit of cleanup, reset *init_tab_base if it came in as null.
--- drivers/crypto/qat/qat_common/qat_uclo.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-)
drivers/crypto/qat/qat_common/qat_uclo.c +7 -2
@@ -332,13 +332,18 @@ static int qat_uclo_create_batch_init_li }return 0 ; out_err: +/* Do not free the list head unless we allocated it. */ + tail_old = tail_old->next; +if (flag) { +kfree (*init_tab_base); + *init_tab_base =NULL ; + } +while (tail_old) { mem_init = tail_old->next;kfree (tail_old); tail_old = mem_init; } -if (flag) -kfree (*init_tab_base);return -ENOMEM ; }
Greg Kroah-Hartman
maintainerPATCH 343/393 crypto: ccp - Fix use of merged scatterlists
In reply to Greg Kroah-HartmanFrom: John Allen <[email protected]>
commit 8a302808c60d441d9884cb00ea7f2b534f2e3ca5 upstream.
Running the crypto manager self tests with CONFIG_CRYPTO_MANAGER_EXTRA_TESTS may result in several types of errors when using the ccp-crypto driver:
alg: skcipher: cbc-des3-ccp encryption failed on test vector 0; expected_error=0, actual_error=-5 ...
alg: skcipher: ctr-aes-ccp decryption overran dst buffer on test vector 0 ...
alg: ahash: sha224-ccp test failed (wrong result) on test vector ...
These errors are the result of improper processing of scatterlists mapped for DMA.
Given a scatterlist in which entries are merged as part of mapping the scatterlist for DMA, the DMA length of a merged entry will reflect the combined length of the entries that were merged. The subsequent scatterlist entry will contain DMA information for the scatterlist entry after the last merged entry, but the non-DMA information will be that of the first merged entry.
The ccp driver does not take this scatterlist merging into account. To address this, add a second scatterlist pointer to track the current position in the DMA mapped representation of the scatterlist. Both the DMA representation and the original representation of the scatterlist must be tracked as while most of the driver can use just the DMA representation, scatterlist_map_and_copy() must use the original representation and expects the scatterlist pointer to be accurate to the original representation.
In order to properly walk the original scatterlist, the scatterlist must be walked until the combined lengths of the entries seen is equal to the DMA length of the current entry being processed in the DMA mapped representation.
--- drivers/crypto/ccp/ccp-dev.h | 1 + drivers/crypto/ccp/ccp-ops.c | 37 ++++++++++++++++++++++++++----------- 2 files changed, 27 insertions(+), 11 deletions(-)
drivers/crypto/ccp/ccp-dev.h +1 -0
@@ -469,6 +469,7 @@ struct ccp_sg_workarea {unsigned int sg_used;struct scatterlist *dma_sg; +struct scatterlist *dma_sg_head;struct device *dma_dev;unsigned int dma_count;enum dma_data_direction dma_dir;
drivers/crypto/ccp/ccp-ops.c +26 -11
@@ -63,7 +63,7 @@ static u32 ccp_gen_jobid(struct ccp_devistatic void ccp_sg_free (struct ccp_sg_workarea *wa) {if (wa->dma_count) -dma_unmap_sg (wa->dma_dev, wa->dma_sg, wa->nents, wa->dma_dir); +dma_unmap_sg (wa->dma_dev, wa->dma_sg_head, wa->nents, wa->dma_dir); wa->dma_count =0 ; }
@@ -92,6 +92,7 @@ static int ccp_init_sg_workarea(struct creturn 0 ; wa->dma_sg = sg; + wa->dma_sg_head = sg; wa->dma_dev = dev; wa->dma_dir = dma_dir; wa->dma_count =dma_map_sg (dev, sg, wa->nents, dma_dir);
@@ -104,14 +105,28 @@ static int ccp_init_sg_workarea(struct cstatic void ccp_update_sg_workarea (struct ccp_sg_workarea *wa,unsigned int len) {unsigned int nbytes =min_t (u64, len, wa->bytes_left); +unsigned int sg_combined_len =0 ;if (!wa->sg)return ; wa->sg_used += nbytes; wa->bytes_left -= nbytes; -if (wa->sg_used == wa->sg->length) { - wa->sg =sg_next (wa->sg); +if (wa->sg_used ==sg_dma_len (wa->dma_sg)) { +/* Advance to the next DMA scatterlist entry */ + wa->dma_sg =sg_next (wa->dma_sg); + +/* In the case that the DMA mapped scatterlist has entries +* that have been merged, the non-DMA mapped scatterlist +* must be advanced multiple times for each merged entry. +* This ensures that the current non-DMA mapped entry +* corresponds to the current DMA mapped entry. +*/ +do { + sg_combined_len += wa->sg->length; + wa->sg =sg_next (wa->sg); + }while (wa->sg_used > sg_combined_len); + wa->sg_used =0 ; } }
@@ -299,7 +314,7 @@ static unsigned int ccp_queue_buf(struct/* Update the structures and generate the count */ buf_count =0 ;while (sg_wa->bytes_left && (buf_count < dm_wa->length)) { - nbytes =min (sg_wa->sg->length - sg_wa->sg_used, + nbytes =min (sg_dma_len (sg_wa->dma_sg) - sg_wa->sg_used, dm_wa->length - buf_count); nbytes =min_t (u64, sg_wa->bytes_left, nbytes);
@@ -331,11 +346,11 @@ static void ccp_prepare_data(struct ccp_* and destination. The resulting len values will always be <= UINT_MAX * because the dma length is an unsigned int. */ - sg_src_len =sg_dma_len (src->sg_wa.sg) - src->sg_wa.sg_used; + sg_src_len =sg_dma_len (src->sg_wa.dma_sg) - src->sg_wa.sg_used; sg_src_len =min_t (u64, src->sg_wa.bytes_left, sg_src_len);if (dst) { - sg_dst_len =sg_dma_len (dst->sg_wa.sg) - dst->sg_wa.sg_used; + sg_dst_len =sg_dma_len (dst->sg_wa.dma_sg) - dst->sg_wa.sg_used; sg_dst_len =min_t (u64, src->sg_wa.bytes_left, sg_dst_len); op_len =min (sg_src_len, sg_dst_len); }else {
@@ -365,7 +380,7 @@ static void ccp_prepare_data(struct ccp_/* Enough data in the sg element, but we need to * adjust for any previously copied data */ - op->src.u.dma.address =sg_dma_address (src->sg_wa.sg); + op->src.u.dma.address =sg_dma_address (src->sg_wa.dma_sg); op->src.u.dma.offset = src->sg_wa.sg_used; op->src.u.dma.length = op_len & ~(block_size -1 );
@@ -386,7 +401,7 @@ static void ccp_prepare_data(struct ccp_/* Enough room in the sg element, but we need to * adjust for any previously used area */ - op->dst.u.dma.address =sg_dma_address (dst->sg_wa.sg); + op->dst.u.dma.address =sg_dma_address (dst->sg_wa.dma_sg); op->dst.u.dma.offset = dst->sg_wa.sg_used; op->dst.u.dma.length = op->src.u.dma.length; }
@@ -2028,7 +2043,7 @@ ccp_run_passthru_cmd(struct ccp_cmd_queu dst.sg_wa.sg_used =0 ;for (i =1 ; i <= src.sg_wa.dma_count; i++) {if (!dst.sg_wa.sg || - (dst.sg_wa.sg->length < src.sg_wa.sg->length)) { + (sg_dma_len (dst.sg_wa.sg) <sg_dma_len (src.sg_wa.sg))) { ret = -EINVAL ; goto e_dst; }
@@ -2054,8 +2069,8 @@ ccp_run_passthru_cmd(struct ccp_cmd_queu goto e_dst; } - dst.sg_wa.sg_used += src.sg_wa.sg->length; -if (dst.sg_wa.sg_used == dst.sg_wa.sg->length) { + dst.sg_wa.sg_used +=sg_dma_len (src.sg_wa.sg); +if (dst.sg_wa.sg_used ==sg_dma_len (dst.sg_wa.sg)) { dst.sg_wa.sg =sg_next (dst.sg_wa.sg); dst.sg_wa.sg_used =0 ; }
Greg Kroah-Hartman
maintainerPATCH 344/393 crypto: cpt - dont sleep of CRYPTO_TFM_REQ_MAY_SLEEP was not specified
In reply to Greg Kroah-HartmanFrom: Mikulas Patocka <[email protected]>
commit 9e27c99104707f083dccd3b4d79762859b5a0614 upstream.
There is this call chain:cvm_encrypt -> cvm_enc_dec -> cptvf_do_request -> process_request -> kzalloc where we call sleeping allocator function even if CRYPTO_TFM_REQ_MAY_SLEEP was not specified.
--- drivers/crypto/cavium/cpt/cptvf_algs.c | 1 + drivers/crypto/cavium/cpt/cptvf_reqmanager.c | 12 ++++++------ drivers/crypto/cavium/cpt/request_manager.h | 2 ++ 3 files changed, 9 insertions(+), 6 deletions(-)
drivers/crypto/cavium/cpt/cptvf_algs.c +1 -0
@@ -200,6 +200,7 @@ static inline int cvm_enc_dec(struct skcint status;memset (req_info,0 ,sizeof (struct cpt_request_info )); + req_info->may_sleep = (req->base.flags &CRYPTO_TFM_REQ_MAY_SLEEP ) !=0 ;memset (fctx,0 ,sizeof (struct fc_context ));create_input_list (req, enc, enc_iv_len);create_output_list (req, enc_iv_len);
drivers/crypto/cavium/cpt/cptvf_reqmanager.c +6 -6
@@ -133,7 +133,7 @@ static inline int setup_sgio_list(struct/* Setup gather (input) components */ g_sz_bytes = ((req->incnt +3 ) /4 ) *sizeof (struct sglist_component ); - info->gather_components =kzalloc (g_sz_bytes,GFP_KERNEL ); + info->gather_components =kzalloc (g_sz_bytes, req->may_sleep ?GFP_KERNEL :GFP_ATOMIC );if (!info->gather_components) { ret = -ENOMEM ; goto scatter_gather_clean;
@@ -150,7 +150,7 @@ static inline int setup_sgio_list(struct/* Setup scatter (output) components */ s_sz_bytes = ((req->outcnt +3 ) /4 ) *sizeof (struct sglist_component ); - info->scatter_components =kzalloc (s_sz_bytes,GFP_KERNEL ); + info->scatter_components =kzalloc (s_sz_bytes, req->may_sleep ?GFP_KERNEL :GFP_ATOMIC );if (!info->scatter_components) { ret = -ENOMEM ; goto scatter_gather_clean;
@@ -167,7 +167,7 @@ static inline int setup_sgio_list(struct/* Create and initialize DPTR */ info->dlen = g_sz_bytes + s_sz_bytes +SG_LIST_HDR_SIZE ; - info->in_buffer =kzalloc (info->dlen,GFP_KERNEL ); + info->in_buffer =kzalloc (info->dlen, req->may_sleep ?GFP_KERNEL :GFP_ATOMIC );if (!info->in_buffer) { ret = -ENOMEM ; goto scatter_gather_clean;
@@ -195,7 +195,7 @@ static inline int setup_sgio_list(struct }/* Create and initialize RPTR */ - info->out_buffer =kzalloc (COMPLETION_CODE_SIZE ,GFP_KERNEL ); + info->out_buffer =kzalloc (COMPLETION_CODE_SIZE , req->may_sleep ?GFP_KERNEL :GFP_ATOMIC );if (!info->out_buffer) { ret = -ENOMEM ; goto scatter_gather_clean;
@@ -421,7 +421,7 @@ int process_request(struct cpt_vf *cptvfstruct cpt_vq_command vq_cmd;union cpt_inst_s cptinst; - info =kzalloc (sizeof (*info),GFP_KERNEL ); + info =kzalloc (sizeof (*info), req->may_sleep ?GFP_KERNEL :GFP_ATOMIC );if (unlikely (!info)) {dev_err (&pdev->dev,"Unable to allocate memory for info_buffer\n" );return -ENOMEM ;
@@ -443,7 +443,7 @@ int process_request(struct cpt_vf *cptvf* Get buffer for union cpt_res_s response * structure and its physical address */ - info->completion_addr =kzalloc (sizeof (union cpt_res_s ),GFP_KERNEL ); + info->completion_addr =kzalloc (sizeof (union cpt_res_s ), req->may_sleep ?GFP_KERNEL :GFP_ATOMIC );if (unlikely (!info->completion_addr)) {dev_err (&pdev->dev,"Unable to allocate memory for completion_addr\n" ); ret = -ENOMEM ;
drivers/crypto/cavium/cpt/request_manager.h +2 -0
@@ -62,6 +62,8 @@ struct cpt_request_info {union ctrl_info ctrl;/* User control information */ struct cptvf_request req;/* Request Information (Core specific) */ +bool may_sleep; +struct buf_ptr in[MAX_BUF_CNT ];struct buf_ptr out[MAX_BUF_CNT ];
Greg Kroah-Hartman
maintainerPATCH 345/393 tick/nohz: Narrow down noise while setting current tasks tick dependency
In reply to Greg Kroah-HartmanFrom: Frederic Weisbecker <[email protected]>
commit 3c8920e2dbd1a55f72dc14d656df9d0097cf5c72 upstream.
Setting a tick dependency on any task, including the case where a task sets that dependency on itself, triggers an IPI to all CPUs. That is of course suboptimal but it had previously not been an issue because it was only used by POSIX CPU timers on nohz_full, which apparently never occurs in latency-sensitive workloads in production. (Or users of such systems are suffering in silence on the one hand or venting their ire on the wrong people on the other.)
But RCU now sets a task tick dependency on the current task in order to fix stall issues that can occur during RCU callback processing. Thus, RCU callback processing triggers frequent system-wide IPIs from nohz_full CPUs. This is quite counter-productive, after all, avoiding IPIs is what nohz_full is supposed to be all about.
This commit therefore optimizes tasks' self-setting of a task tick dependency by using tick_nohz_full_kick() to avoid the system-wide IPI. Instead, only the execution of the one task is disturbed, which is acceptable given that this disturbance is well down into the noise compared to the degree to which the RCU callback processing itself disturbs execution.
--- kernel/time/tick-sched.c | 22 +++++++++++++++------- 1 file changed, 15 insertions(+), 7 deletions(-)
kernel/time/tick-sched.c +15 -7
@@ -351,16 +351,24 @@ void tick_nohz_dep_clear_cpu(int cpu, enEXPORT_SYMBOL_GPL (tick_nohz_dep_clear_cpu);/* -* Set a per-task tick dependency. Posix CPU timers need this in order to elapse -* per task timers. +* Set a per-task tick dependency. RCU need this. Also posix CPU timers +* in order to elapse per task timers. */ void tick_nohz_dep_set_task (struct task_struct *tsk,enum tick_dep_bits bit) { -/* -* We could optimize this with just kicking the target running the task -* if that noise matters for nohz full users. -*/ -tick_nohz_dep_set_all (&tsk->tick_dep_mask, bit); +if (!atomic_fetch_or (BIT (bit), &tsk->tick_dep_mask)) { +if (tsk == current) { +preempt_disable (); +tick_nohz_full_kick (); +preempt_enable (); + }else { +/* +* Some future tick_nohz_full_kick_task() +* should optimize this. +*/ +tick_nohz_full_kick_all (); + } + } }EXPORT_SYMBOL_GPL (tick_nohz_dep_set_task);
Greg Kroah-Hartman
maintainerPATCH 346/393 bitfield.h: dont compile-time validate _val in FIELD_FIT
In reply to Greg Kroah-HartmanFrom: Jakub Kicinski <[email protected]>
commit 444da3f52407d74c9aa12187ac6b01f76ee47d62 upstream.
When ur_load_imm_any() is inlined into jeq_imm(), it's possible for the compiler to deduce a case where _val can only have the value of -1 at compile time. Specifically,
/* struct bpf_insn: _s32 imm */
u64 imm = insn->imm; /* sign extend */
if (imm >> 32) { /* non-zero only if insn->imm is negative */
/* inlined from ur_load_imm_any */
u32 __imm = imm >> 32; /* therefore, always 0xffffffff */ if (__builtin_constant_p(__imm) && __imm > 255)
compiletime_assert_XXX()
This can result in tripping a BUILD_BUG_ON() in __BF_FIELD_CHECK() that checks that a given value is representable in one byte (interpreted as unsigned).
FIELD_FIT() should return true or false at runtime for whether a value can fit for not. Don't break the build over a value that's too large for the mask. We'd prefer to keep the inlining and compiler optimizations though we know this case will always return false.
--- include/linux/bitfield.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
include/linux/bitfield.h +1 -1
@@ -77,7 +77,7 @@*/ #define FIELD_FIT (_mask, _val) \ ({ \ - __BF_FIELD_CHECK(_mask, 0ULL, _val, "FIELD_FIT: "); \ + __BF_FIELD_CHECK(_mask, 0ULL, 0ULL, "FIELD_FIT: "); \ !((((typeof(_mask))_val) << __bf_shf(_mask)) & ~(_mask)); \ })
Greg Kroah-Hartman
maintainerPATCH 347/393 fs/minix: check return value of sb_getblk()
In reply to Greg Kroah-HartmanFrom: Eric Biggers <[email protected]>
commit da27e0a0e5f655f0d58d4e153c3182bb2b290f64 upstream.
Patch series "fs/minix: fix syzbot bugs and set s_maxbytes".
This series fixes all syzbot bugs in the minix filesystem:
KASAN: null-ptr-deref Write in get_block KASAN: use-after-free Write in get_block KASAN: use-after-free Read in get_block WARNING in inc_nlink KMSAN: uninit-value in get_block WARNING in drop_nlink
It also fixes the minix filesystem to set s_maxbytes correctly, so that userspace sees the correct behavior when exceeding the max file size.
This patch (of 6):
sb_getblk() can fail, so check its return value.
This fixes a NULL pointer dereference.
Originally from Qiujun Huang.
--- fs/minix/itree_common.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-)
fs/minix/itree_common.c +7 -1
@@ -75,6 +75,7 @@ static int alloc_branch(struct inode *inint n =0 ;int i;int parent =minix_new_block (inode); +int err = -ENOSPC ; branch[0 ].key =cpu_to_block (parent);if (parent)for (n =1 ; n < num; n++) {
@@ -85,6 +86,11 @@ static int alloc_branch(struct inode *inbreak ; branch[n].key =cpu_to_block (nr); bh =sb_getblk (inode->i_sb, parent); +if (!bh) { +minix_free_block (inode, nr); + err = -ENOMEM ; +break ; + }lock_buffer (bh);memset (bh->b_data,0 , bh->b_size); branch[n].bh = bh;
@@ -103,7 +109,7 @@ static int alloc_branch(struct inode *inbforget (branch[i].bh);for (i =0 ; i < n; i++)minix_free_block (inode,block_to_cpu (branch[i].key)); -return -ENOSPC ; +return err; } static inline int splice_branch(struct inode *inode,
Greg Kroah-Hartman
maintainerPATCH 348/393 fs/minix: dont allow getting deleted inodes
In reply to Greg Kroah-HartmanFrom: Eric Biggers <[email protected]>
commit facb03dddec04e4aac1bb2139accdceb04deb1f3 upstream.
If an inode has no links, we need to mark it bad rather than allowing it to be accessed. This avoids WARNINGs in inc_nlink() and drop_nlink() when doing directory operations on a fuzzed filesystem.
--- fs/minix/inode.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
fs/minix/inode.c +14 -0
@@ -468,6 +468,13 @@ static struct inode *V1_minix_iget(struciget_failed (inode);return ERR_PTR (-EIO ); } +if (raw_inode->i_nlinks ==0 ) { +printk ("MINIX-fs: deleted inode referenced: %lu\n" , + inode->i_ino); +brelse (bh); +iget_failed (inode); +return ERR_PTR (-ESTALE ); + } inode->i_mode = raw_inode->i_mode;i_uid_write (inode, raw_inode->i_uid);i_gid_write (inode, raw_inode->i_gid);
@@ -501,6 +508,13 @@ static struct inode *V2_minix_iget(struciget_failed (inode);return ERR_PTR (-EIO ); } +if (raw_inode->i_nlinks ==0 ) { +printk ("MINIX-fs: deleted inode referenced: %lu\n" , + inode->i_ino); +brelse (bh); +iget_failed (inode); +return ERR_PTR (-ESTALE ); + } inode->i_mode = raw_inode->i_mode;i_uid_write (inode, raw_inode->i_uid);i_gid_write (inode, raw_inode->i_gid);
Greg Kroah-Hartman
maintainerPATCH 349/393 fs/minix: reject too-large maximum file size
In reply to Greg Kroah-HartmanFrom: Eric Biggers <[email protected]>
commit 270ef41094e9fa95273f288d7d785313ceab2ff3 upstream.
If the minix filesystem tries to map a very large logical block number to its on-disk location, block_to_path() can return offsets that are too large, causing out-of-bounds memory accesses when accessing indirect index blocks. This should be prevented by the check against the maximum file size, but this doesn't work because the maximum file size is read directly from the on-disk superblock and isn't validated itself.
Fix this by validating the maximum file size at mount time.
--- fs/minix/inode.c | 22 ++++++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-)
fs/minix/inode.c +20 -2
@@ -150,6 +150,23 @@ static int minix_remount (struct super_breturn 0 ; } +static bool minix_check_superblock (struct minix_sb_info *sbi) +{ +if (sbi->s_imap_blocks ==0 || sbi->s_zmap_blocks ==0 ) +return false; + +/* +* s_max_size must not exceed the block mapping limitation. This check +* is only needed for V1 filesystems, since V2/V3 support an extra level +* of indirect blocks which places the limit well above U32_MAX. +*/ +if (sbi->s_version ==MINIX_V1 && + sbi->s_max_size > (7 +512 +512 *512 ) *BLOCK_SIZE ) +return false; + +return true; +} +static int minix_fill_super (struct super_block *s,void *data,int silent) {struct buffer_head *bh;
@@ -228,11 +245,12 @@ static int minix_fill_super(struct super }else goto out_no_fs; +if (!minix_check_superblock (sbi)) + goto out_illegal_sb; +/* * Allocate the buffer map to keep the superblock small. */ -if (sbi->s_imap_blocks ==0 || sbi->s_zmap_blocks ==0 ) - goto out_illegal_sb; i = (sbi->s_imap_blocks + sbi->s_zmap_blocks) *sizeof (bh); map =kzalloc (i,GFP_KERNEL );if (!map)
Greg Kroah-Hartman
maintainerPATCH 350/393 kvm: x86: replace kvm_spec_ctrl_test_value with runtime test on the host
In reply to Greg Kroah-HartmanFrom: Maxim Levitsky <[email protected]>
commit 841c2be09fe4f495fe5224952a419bd8c7e5b455 upstream.
To avoid complex and in some cases incorrect logic in kvm_spec_ctrl_test_value, just try the guest's given value on the host processor instead, and if it doesn't #GP, allow the guest to set it.
One such case is when host CPU supports STIBP mitigation but doesn't support IBRS (as is the case with some Zen2 AMD cpus), and in this case we were giving guest #GP when it tried to use STIBP
The reason why can can do the host test is that IA32_SPEC_CTRL msr is passed to the guest, after the guest sets it to a non zero value for the first time (due to performance reasons),
and as as result of this, it is pointless to emulate #GP condition on this first access, in a different way than what the host CPU does.
This is based on a patch from Sean Christopherson, who suggested this idea.
Message-Id: <[email protected]>
--- arch/x86/kvm/svm/svm.c | 2 +- arch/x86/kvm/vmx/vmx.c | 2 +- arch/x86/kvm/x86.c | 40 ++++++++++++++++++++++------------------ arch/x86/kvm/x86.h | 2 +- 4 files changed, 25 insertions(+), 21 deletions(-)
arch/x86/kvm/svm/svm.c +1 -1
@@ -2509,7 +2509,7 @@ static int svm_set_msr(struct kvm_vcpu * !guest_cpuid_has(vcpu, X86_FEATURE_AMD_SSBD))return 1 ; -if (data & ~kvm_spec_ctrl_valid_bits (vcpu)) +if (kvm_spec_ctrl_test_value (data))return 1 ; svm->spec_ctrl = data;
arch/x86/kvm/vmx/vmx.c +1 -1
@@ -2015,7 +2015,7 @@ static int vmx_set_msr(struct kvm_vcpu * !guest_cpuid_has(vcpu, X86_FEATURE_SPEC_CTRL))return 1 ; -if (data & ~kvm_spec_ctrl_valid_bits (vcpu)) +if (kvm_spec_ctrl_test_value (data))return 1 ; vmx->spec_ctrl = data;
arch/x86/kvm/x86.c +22 -18
@@ -10573,28 +10573,32 @@ bool kvm_arch_no_poll(struct kvm_vcpu *v }EXPORT_SYMBOL_GPL (kvm_arch_no_poll); -u64 kvm_spec_ctrl_valid_bits (struct kvm_vcpu *vcpu) + +int kvm_spec_ctrl_test_value (u64 value) { -uint64_t bits =SPEC_CTRL_IBRS |SPEC_CTRL_STIBP |SPEC_CTRL_SSBD ; +/* +* test that setting IA32_SPEC_CTRL to given value +* is allowed by the host processor +*/ + +u64 saved_value; +unsigned long flags; +int ret =0 ; + +local_irq_save (flags); + +if (rdmsrl_safe (MSR_IA32_SPEC_CTRL , &saved_value)) + ret =1 ; +else if (wrmsrl_safe (MSR_IA32_SPEC_CTRL , value)) + ret =1 ; +else +wrmsrl (MSR_IA32_SPEC_CTRL , saved_value); -/* The STIBP bit doesn't fault even if it's not advertised */ -if (!guest_cpuid_has (vcpu,X86_FEATURE_SPEC_CTRL ) && - !guest_cpuid_has (vcpu,X86_FEATURE_AMD_IBRS )) - bits &= ~(SPEC_CTRL_IBRS |SPEC_CTRL_STIBP ); -if (!boot_cpu_has (X86_FEATURE_SPEC_CTRL ) && - !boot_cpu_has (X86_FEATURE_AMD_IBRS )) - bits &= ~(SPEC_CTRL_IBRS |SPEC_CTRL_STIBP ); - -if (!guest_cpuid_has (vcpu,X86_FEATURE_SPEC_CTRL_SSBD ) && - !guest_cpuid_has (vcpu,X86_FEATURE_AMD_SSBD )) - bits &= ~SPEC_CTRL_SSBD ; -if (!boot_cpu_has (X86_FEATURE_SPEC_CTRL_SSBD ) && - !boot_cpu_has (X86_FEATURE_AMD_SSBD )) - bits &= ~SPEC_CTRL_SSBD ; +local_irq_restore (flags); -return bits; +return ret; } -EXPORT_SYMBOL_GPL (kvm_spec_ctrl_valid_bits); +EXPORT_SYMBOL_GPL (kvm_spec_ctrl_test_value);EXPORT_TRACEPOINT_SYMBOL_GPL (kvm_exit);EXPORT_TRACEPOINT_SYMBOL_GPL (kvm_fast_mmio);
arch/x86/kvm/x86.h +1 -1
@@ -357,6 +357,6 @@ static inline bool kvm_dr7_valid(u64 datvoid kvm_load_guest_xsave_state (struct kvm_vcpu *vcpu);void kvm_load_host_xsave_state (struct kvm_vcpu *vcpu); -u64 kvm_spec_ctrl_valid_bits (struct kvm_vcpu *vcpu); +int kvm_spec_ctrl_test_value (u64 value);#endif
Greg Kroah-Hartman
maintainerPATCH 351/393 9p: Fix memory leak in v9fs_mount
In reply to Greg Kroah-HartmanFrom: Zheng Bin <[email protected]>
commit cb0aae0e31c632c407a2cab4307be85a001d4d98 upstream.
v9fs_mount
v9fs_session_init
v9fs_cache_session_get_cookie
v9fs_random_cachetag -->alloc cachetag
v9ses->fscache = fscache_acquire_cookie -->maybe NULL
sb = sget -->fail, goto clunk
clunk_fid:
v9fs_session_close
if (v9ses->fscache) -->NULL
kfree(v9ses->cachetag)Thus memleak happens.
--- fs/9p/v9fs.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-)
fs/9p/v9fs.c +2 -3
@@ -500,10 +500,9 @@ void v9fs_session_close(struct v9fs_sess }#ifdef CONFIG_9P_FSCACHE -if (v9ses->fscache) { +if (v9ses->fscache)v9fs_cache_session_put_cookie (v9ses); -kfree (v9ses->cachetag); - } +kfree (v9ses->cachetag);#endif kfree (v9ses->uname);kfree (v9ses->aname);
Greg Kroah-Hartman
maintainerPATCH 352/393 driver core: Fix probe_count imbalance in really_probe()
In reply to Greg Kroah-HartmanFrom: Tetsuo Handa <[email protected]>
commit b292b50b0efcc7095d8bf15505fba6909bb35dce upstream.
syzbot is reporting hung task in wait_for_device_probe() [1]. At least, we always need to decrement probe_count if we incremented probe_count in really_probe().
However, since I can't find "Resources present before probing" message in the console log, both "this message simply flowed off" and "syzbot is not hitting this path" will be possible. Therefore, while we are at it, let's also prepare for concurrent wait_for_device_probe() calls by replacing wake_up() with wake_up_all().
[1] https://syzkaller.appspot.com/bug?id=25c833f1983c9c1d512f4ff860dd0d7f5a2e2c0f
--- drivers/base/dd.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-)
drivers/base/dd.c +4 -3
@@ -276,7 +276,7 @@ static void deferred_probe_timeout_work_list_for_each_entry_safe (private, p, &deferred_probe_pending_list, deferred_probe)dev_info (private->device,"deferred probe pending" ); -wake_up (&probe_timeout_waitqueue); +wake_up_all (&probe_timeout_waitqueue); } static DECLARE_DELAYED_WORK(deferred_probe_timeout_work, deferred_probe_timeout_work_func);
@@ -487,7 +487,8 @@ static int really_probe(struct device *d drv->bus->name, __func__, drv->name, dev_name(dev));if (!list_empty (&dev->devres_head)) {dev_crit (dev,"Resources present before probing\n" ); -return -EBUSY ; + ret = -EBUSY ; + goto done; } re_probe:
@@ -608,7 +609,7 @@ pinctrl_bind_failed: ret =0 ; done:atomic_dec (&probe_count); -wake_up (&probe_waitqueue); +wake_up_all (&probe_waitqueue);return ret; }
Greg Kroah-Hartman
maintainerPATCH 353/393 media: media-request: Fix crash if memory allocation fails
In reply to Greg Kroah-HartmanFrom: Tuomas Tynkkynen <[email protected]>
commit e30cc79cc80fd919b697a15c5000d9f57487de8e upstream.
Syzbot reports a NULL-ptr deref in the kref_put() call:
BUG: KASAN: null-ptr-deref in media_request_put drivers/media/mc/mc-request.c:81 [inline] kref_put include/linux/kref.h:64 [inline] media_request_put drivers/media/mc/mc-request.c:81 [inline] media_request_close+0x4d/0x170 drivers/media/mc/mc-request.c:89 __fput+0x2ed/0x750 fs/file_table.c:281 task_work_run+0x147/0x1d0 kernel/task_work.c:123 tracehook_notify_resume include/linux/tracehook.h:188 [inline] exit_to_usermode_loop arch/x86/entry/common.c:165 [inline] prepare_exit_to_usermode+0x48e/0x600 arch/x86/entry/common.c:196
What led to this crash was an injected memory allocation failure in media_request_alloc():
FAULT_INJECTION: forcing a failure.
name failslab, interval 1, probability 0, space 0, times 0
should_failslab+0x5/0x20 kmem_cache_alloc_trace+0x57/0x300 ? anon_inode_getfile+0xe5/0x170 media_request_alloc+0x339/0x440 media_device_request_alloc+0x94/0xc0 media_device_ioctl+0x1fb/0x330 ? do_vfs_ioctl+0x6ea/0x1a00 ? media_ioctl+0x101/0x120 ? __media_device_usb_init+0x430/0x430 ? media_poll+0x110/0x110 __se_sys_ioctl+0xf9/0x160 do_syscall_64+0xf3/0x1b0
When that allocation fails, filp->private_data is left uninitialized which media_request_close() does not expect and crashes.
To avoid this, reorder media_request_alloc() such that allocating the struct file happens as the last step thus media_request_close() will no longer get called for a partially created media request.
--- drivers/media/mc/mc-request.c | 31 +++++++++++++++++-------------- 1 file changed, 17 insertions(+), 14 deletions(-)
drivers/media/mc/mc-request.c +17 -14
@@ -296,9 +296,18 @@ int media_request_alloc(struct media_devif (WARN_ON (!mdev->ops->req_alloc ^ !mdev->ops->req_free))return -ENOMEM ; +if (mdev->ops->req_alloc) + req = mdev->ops->req_alloc (mdev); +else + req =kzalloc (sizeof (*req),GFP_KERNEL ); +if (!req) +return -ENOMEM ; + fd =get_unused_fd_flags (O_CLOEXEC ); -if (fd <0 ) -return fd; +if (fd <0 ) { + ret = fd; + goto err_free_req; + } filp =anon_inode_getfile ("request" , &request_fops,NULL ,O_CLOEXEC );if (IS_ERR (filp)) {
@@ -306,15 +315,6 @@ int media_request_alloc(struct media_dev goto err_put_fd; } -if (mdev->ops->req_alloc) - req = mdev->ops->req_alloc (mdev); -else - req =kzalloc (sizeof (*req),GFP_KERNEL ); -if (!req) { - ret = -ENOMEM ; - goto err_fput; - } - filp->private_data = req; req->mdev = mdev; req->state =MEDIA_REQUEST_STATE_IDLE ;
@@ -336,12 +336,15 @@ int media_request_alloc(struct media_devreturn 0 ; -err_fput: -fput (filp); - err_put_fd:put_unused_fd (fd); +err_free_req: +if (mdev->ops->req_free) + mdev->ops->req_free (req); +else +kfree (req); +return ret; }
Greg Kroah-Hartman
maintainerPATCH 354/393 drm/ttm/nouveau: dont call tt destroy callback on alloc failure.
In reply to Greg Kroah-HartmanFrom: Dave Airlie <[email protected]>
commit 5de5b6ecf97a021f29403aa272cb4e03318ef586 upstream.
This is confusing, and from my reading of all the drivers only nouveau got this right.
Just make the API act under driver control of it's own allocation failing, and don't call destroy, if the page table fails to create there is nothing to cleanup here.
(I'm willing to believe I've missed something here, so please review deeply).
--- drivers/gpu/drm/nouveau/nouveau_sgdma.c | 9 +++------ drivers/gpu/drm/ttm/ttm_tt.c | 3 --- 2 files changed, 3 insertions(+), 9 deletions(-)
drivers/gpu/drm/nouveau/nouveau_sgdma.c +3 -6
@@ -96,12 +96,9 @@ nouveau_sgdma_create_ttm(struct ttm_buffelse nvbe->ttm.ttm.func = &nv50_sgdma_backend; -if (ttm_dma_tt_init (&nvbe->ttm, bo, page_flags)) -/* -* A failing ttm_dma_tt_init() will call ttm_tt_destroy() -* and thus our nouveau_sgdma_destroy() hook, so we don't need -* to free nvbe here. -*/ +if (ttm_dma_tt_init (&nvbe->ttm, bo, page_flags)) { +kfree (nvbe);return NULL ; + }return &nvbe->ttm.ttm; }
drivers/gpu/drm/ttm/ttm_tt.c +0 -3
@@ -242,7 +242,6 @@ int ttm_tt_init(struct ttm_tt *ttm, struttm_tt_init_fields (ttm, bo, page_flags);if (ttm_tt_alloc_page_directory (ttm)) { -ttm_tt_destroy (ttm);pr_err ("Failed allocating page table\n" );return -ENOMEM ; }
@@ -266,7 +265,6 @@ int ttm_dma_tt_init(struct ttm_dma_tt *tINIT_LIST_HEAD (&ttm_dma->pages_list);if (ttm_dma_tt_alloc_page_directory (ttm_dma)) { -ttm_tt_destroy (ttm);pr_err ("Failed allocating page table\n" );return -ENOMEM ; }
@@ -288,7 +286,6 @@ int ttm_sg_tt_init(struct ttm_dma_tt *ttelse ret =ttm_dma_tt_alloc_page_directory (ttm_dma);if (ret) { -ttm_tt_destroy (ttm);pr_err ("Failed allocating page table\n" );return -ENOMEM ; }
Greg Kroah-Hartman
maintainerPATCH 355/393 io_uring: set ctx sq/cq entry count earlier
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
commit bd74048108c179cea0ff52979506164c80f29da7 upstream.
If we hit an earlier error path in io_uring_create(), then we will have accounted memory, but not set ctx->{sq,cq}_entries yet. Then when the ring is torn down in error, we use those values to unaccount the memory.
Ensure we set the ctx entries before we're able to hit a potential error path.
--- fs/io_uring.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
fs/io_uring.c +4 -2
@@ -7869,6 +7869,10 @@ static int io_allocate_scq_urings(structstruct io_rings *rings;size_t size, sq_array_offset; +/* make sure these are sane, as we already accounted them */ + ctx->sq_entries = p->sq_entries; + ctx->cq_entries = p->cq_entries; + size =rings_size (p->sq_entries, p->cq_entries, &sq_array_offset);if (size ==SIZE_MAX )return -EOVERFLOW ;
@@ -7885,8 +7889,6 @@ static int io_allocate_scq_urings(struct rings->cq_ring_entries = p->cq_entries; ctx->sq_mask = rings->sq_ring_mask; ctx->cq_mask = rings->cq_ring_mask; - ctx->sq_entries = rings->sq_ring_entries; - ctx->cq_entries = rings->cq_ring_entries; size =array_size (sizeof (struct io_uring_sqe ), p->sq_entries);if (size ==SIZE_MAX ) {
Greg Kroah-Hartman
maintainerPATCH 356/393 io_uring: use TWA_SIGNAL for task_work uncondtionally
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
commit 0ba9c9edcd152158a0e321a4c13ac1dfc571ff3d upstream.
An earlier commit:
b7db41c9e03b ("io_uring: fix regression with always ignoring signals in io_cqring_wait()")
ensured that we didn't get stuck waiting for eventfd reads when it's registered with the io_uring ring for event notification, but we still have cases where the task can be waiting on other events in the kernel and need a bigger nudge to make forward progress. Or the task could be in the kernel and running, but on its way to blocking.
This means that TWA_RESUME cannot reliably be used to ensure we make progress. Use TWA_SIGNAL unconditionally.
--- fs/io_uring.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)
fs/io_uring.c +8 -8
@@ -4161,22 +4161,22 @@ static int io_req_task_work_add(struct i {struct task_struct *tsk = req->task;struct io_ring_ctx *ctx = req->ctx; -int ret, notify =TWA_RESUME ; +int ret, notify;/* -* SQPOLL kernel thread doesn't need notification, just a wakeup. -* If we're not using an eventfd, then TWA_RESUME is always fine, -* as we won't have dependencies between request completions for -* other kernel wait conditions. +* SQPOLL kernel thread doesn't need notification, just a wakeup. For +* all other cases, use TWA_SIGNAL unconditionally to ensure we're +* processing task_work. There's no reliable way to tell if TWA_RESUME +* will do the job. */ -if (ctx->flags &IORING_SETUP_SQPOLL ) - notify =0 ; -else if (ctx->cq_ev_fd) + notify =0 ; +if (!(ctx->flags &IORING_SETUP_SQPOLL )) notify =TWA_SIGNAL ; ret =task_work_add (tsk, cb, notify);if (!ret)wake_up_process (tsk); +return ret; }
Greg Kroah-Hartman
maintainerPATCH 357/393 io_uring: fail poll arm on queue proc failure
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
commit a36da65c46565d2527eec3efdb546251e38253fd upstream.
Check the ipt.error value, it must have been either cleared to zero or set to another error than the default -EINVAL if we don't go through the waitqueue proc addition. Just give up on poll at that point and return failure, this will fallback to async work.
io_poll_add() doesn't suffer from this failure case, as it returns the error value directly.
--- fs/io_uring.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/io_uring.c +1 -1
@@ -4544,7 +4544,7 @@ static bool io_arm_poll_handler(struct i ret =__io_arm_poll_handler (req, &apoll->poll, &ipt, mask, io_async_wake); -if (ret) { +if (ret || ipt.error) {io_poll_remove_double (req, apoll->double_poll);spin_unlock_irq (&ctx->completion_lock);memcpy (&req->work, &apoll->work,sizeof (req->work));
Greg Kroah-Hartman
maintainerPATCH 358/393 NFS: Dont move layouts to plh_return_segs list while in use
In reply to Greg Kroah-HartmanFrom: Trond Myklebust <[email protected]>
commit ff041727e9e029845857cac41aae118ead5e261b upstream.
If the layout segment is still in use for a read or a write, we should not move it to the layout plh_return_segs list. If we do, we can end up returning the layout while I/O is still in progress.
--- fs/nfs/pnfs.c | 12 +----------- 1 file changed, 1 insertion(+), 11 deletions(-)
fs/nfs/pnfs.c +1 -11
@@ -2392,16 +2392,6 @@ out_forget:return ERR_PTR (-EAGAIN ); } -static int -mark_lseg_invalid_or_return (struct pnfs_layout_segment *lseg, -struct list_head *tmp_list) -{ -if (!mark_lseg_invalid (lseg, tmp_list)) -return 0 ; -pnfs_cache_lseg_for_layoutreturn (lseg->pls_layout, lseg); -return 1 ; -} -/** * pnfs_mark_matching_lsegs_return - Free or return matching layout segments * @lo: pointer to layout header
@@ -2438,7 +2428,7 @@ pnfs_mark_matching_lsegs_return(struct p lseg, lseg->pls_range.iomode, lseg->pls_range.offset, lseg->pls_range.length); -if (mark_lseg_invalid_or_return (lseg, tmp_list)) +if (mark_lseg_invalid (lseg, tmp_list))continue ; remaining++;set_bit (NFS_LSEG_LAYOUTRETURN , &lseg->pls_flags);
Greg Kroah-Hartman
maintainerPATCH 359/393 NFS: Dont return layout segments that are in use
In reply to Greg Kroah-HartmanFrom: Trond Myklebust <[email protected]>
commit d474f96104bd4377573526ebae2ee212205a6839 upstream.
If the NFS_LAYOUT_RETURN_REQUESTED flag is set, we want to return the layout as soon as possible, meaning that the affected layout segments should be marked as invalid, and should no longer be in use for I/O.
--- fs/nfs/pnfs.c | 34 +++++++++++++++------------------- 1 file changed, 15 insertions(+), 19 deletions(-)
fs/nfs/pnfs.c +15 -19
@@ -1226,31 +1226,27 @@ out:return status; } +static bool +pnfs_layout_segments_returnable (struct pnfs_layout_hdr *lo, +enum pnfs_iomode iomode, +u32 seq) +{ +struct pnfs_layout_range recall_range = { + .length =NFS4_MAX_UINT64 , + .iomode = iomode, + }; +return pnfs_mark_matching_lsegs_return (lo, &lo->plh_return_segs, + &recall_range, seq) != -EBUSY ; +} +/* Return true if layoutreturn is needed */ static bool pnfs_layout_need_return (struct pnfs_layout_hdr *lo) { -struct pnfs_layout_segment *s; -enum pnfs_iomode iomode; -u32 seq; -if (!test_bit (NFS_LAYOUT_RETURN_REQUESTED , &lo->plh_flags))return false; - - seq = lo->plh_return_seq; - iomode = lo->plh_return_iomode; - -/* Defer layoutreturn until all recalled lsegs are done */ -list_for_each_entry (s, &lo->plh_segs, pls_list) { -if (seq &&pnfs_seqid_is_newer (s->pls_seq, seq)) -continue ; -if (iomode !=IOMODE_ANY && s->pls_range.iomode != iomode) -continue ; -if (test_bit (NFS_LSEG_LAYOUTRETURN , &s->pls_flags)) -return false; - } - -return true; +return pnfs_layout_segments_returnable (lo, lo->plh_return_iomode, + lo->plh_return_seq); }static void pnfs_layoutreturn_before_put_layout_hdr (struct pnfs_layout_hdr *lo)
Greg Kroah-Hartman
maintainerPATCH 360/393 cpufreq: Fix locking issues with governors
In reply to Greg Kroah-HartmanFrom: Viresh Kumar <[email protected]>
commit 8cc46ae565c393f77417cb9530b1265eb50f5d2e upstream.
The locking around governors handling isn't adequate currently.
The list of governors should never be traversed without the locking in place. Also governor modules must not be removed while the code in them is still in use.
--- drivers/cpufreq/cpufreq.c | 58 +++++++++++++++++++++++++++------------------- 1 file changed, 35 insertions(+), 23 deletions(-)
drivers/cpufreq/cpufreq.c +35 -23
@@ -621,6 +621,24 @@ static struct cpufreq_governor *find_govreturn NULL ; } +static struct cpufreq_governor *get_governor (const char *str_governor) +{ +struct cpufreq_governor *t; + +mutex_lock (&cpufreq_governor_mutex); + t =find_governor (str_governor); +if (!t) + goto unlock; + +if (!try_module_get (t->owner)) + t =NULL ; + +unlock: +mutex_unlock (&cpufreq_governor_mutex); + +return t; +} +static unsigned int cpufreq_parse_policy (char *str_governor) {if (!strncasecmp (str_governor,"performance" ,CPUFREQ_NAME_LEN ))
@@ -640,28 +658,14 @@ static struct cpufreq_governor *cpufreq_ {struct cpufreq_governor *t; -mutex_lock (&cpufreq_governor_mutex); - - t =find_governor (str_governor); -if (!t) { -int ret; + t =get_governor (str_governor); +if (t) +return t; -mutex_unlock (&cpufreq_governor_mutex); +if (request_module ("cpufreq_%s" , str_governor)) +return NULL ; - ret =request_module ("cpufreq_%s" , str_governor); -if (ret) -return NULL ; - -mutex_lock (&cpufreq_governor_mutex); - - t =find_governor (str_governor); - } -if (t && !try_module_get (t->owner)) - t =NULL ; - -mutex_unlock (&cpufreq_governor_mutex); - -return t; +return get_governor (str_governor); }/**
@@ -815,12 +819,14 @@ static ssize_t show_scaling_available_go goto out; } +mutex_lock (&cpufreq_governor_mutex);for_each_governor (t) {if (i >= (ssize_t ) ((PAGE_SIZE /sizeof (char )) - (CPUFREQ_NAME_LEN +2 ))) - goto out; +break ; i +=scnprintf (&buf[i],CPUFREQ_NAME_PLEN ,"%s " , t->name); } +mutex_unlock (&cpufreq_governor_mutex); out: i +=sprintf (&buf[i],"\n" );return i;
@@ -1058,15 +1064,17 @@ static int cpufreq_init_policy(struct cpstruct cpufreq_governor *def_gov =cpufreq_default_governor ();struct cpufreq_governor *gov =NULL ;unsigned int pol =CPUFREQ_POLICY_UNKNOWN ; +int ret;if (has_target ()) {/* Update policy governor to the one used before hotplug. */ - gov =find_governor (policy->last_governor); + gov =get_governor (policy->last_governor);if (gov) {pr_debug ("Restoring governor %s for cpu %d\n" , policy->governor->name, policy->cpu); }else if (def_gov) { gov = def_gov; +__module_get (gov->owner); }else {return -ENODATA ; }
@@ -1089,7 +1097,11 @@ static int cpufreq_init_policy(struct cpreturn -ENODATA ; } -return cpufreq_set_policy (policy, gov, pol); + ret =cpufreq_set_policy (policy, gov, pol); +if (gov) +module_put (gov->owner); + +return ret; }static int cpufreq_add_policy_cpu (struct cpufreq_policy *policy,unsigned int cpu)
Greg Kroah-Hartman
maintainerPATCH 361/393 cpufreq: dt: fix oops on armada37xx
In reply to Greg Kroah-HartmanFrom: Ivan Kokshaysky <[email protected]>
commit 10470dec3decaf5ed3c596f85debd7c42777ae12 upstream.
Commit 0c868627e617e43a295d8 (cpufreq: dt: Allow platform specific intermediate callbacks) added two function pointers to the struct cpufreq_dt_platform_data. However, armada37xx_cpufreq_driver_init() has this struct (pdata) located on the stack and uses only "suspend" and "resume" fields. So these newly added "get_intermediate" and "target_intermediate" pointers are uninitialized and contain arbitrary non-null values, causing all kinds of trouble.
For instance, here is an oops on espressobin after an attempt to change the cpefreq governor:
[ 29.174554] Unable to handle kernel execute from non-executable memory at virtual address ffff00003f87bdc0 ... [ 29.269373] pc : 0xffff00003f87bdc0 [ 29.272957] lr : __cpufreq_driver_target+0x138/0x580
...
Fixed by zeroing out pdata before use.
--- drivers/cpufreq/armada-37xx-cpufreq.c | 1 + 1 file changed, 1 insertion(+)
drivers/cpufreq/armada-37xx-cpufreq.c +1 -0
@@ -456,6 +456,7 @@ static int __init armada37xx_cpufreq_dri/* Now that everything is setup, enable the DVFS at hardware level */ armada37xx_cpufreq_enable_dvfs (nb_pm_base); +memset (&pdata,0 ,sizeof (pdata)); pdata.suspend = armada37xx_cpufreq_suspend; pdata.resume = armada37xx_cpufreq_resume;
Greg Kroah-Hartman
maintainerPATCH 362/393 include/asm-generic/vmlinux.lds.h: align ro_after_init
In reply to Greg Kroah-HartmanFrom: Romain Naour <[email protected]>
commit 7f897acbe5d57995438c831670b7c400e9c0dc00 upstream.
Since the patch [1], building the kernel using a toolchain built with binutils 2.33.1 prevents booting a sh4 system under Qemu. Apply the patch provided by Alan Modra [2] that fix alignment of rodata.
[1] https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=ebd2263ba9a9124d93bbc0ece63d7e0fae89b40e
[2] https://www.sourceware.org/ml/binutils/2019-12/msg00112.html
--- include/asm-generic/vmlinux.lds.h | 1 + 1 file changed, 1 insertion(+)
include/asm-generic/vmlinux.lds.h +1 -0
@@ -375,6 +375,7 @@*/ #ifndef RO_AFTER_INIT_DATA #define RO_AFTER_INIT_DATA \ + . = ALIGN(8); \ __start_ro_after_init = .; \ *(.data..ro_after_init) \ JUMP_TABLE_DATA \
Greg Kroah-Hartman
maintainerPATCH 363/393 PM / devfreq: rk3399_dmc: Fix kernel oops when rockchip,pmu is absent
In reply to Greg Kroah-HartmanFrom: Marc Zyngier <[email protected]>
commit 63ef91f24f9bfc70b6446319f6cabfd094481372 upstream.
Booting a recent kernel on a rk3399-based system (nanopc-t4), equipped with a recent u-boot and ATF results in an Oops due to a NULL pointer dereference.
This turns out to be due to the rk3399-dmc driver looking for an *undocumented* property (rockchip,pmu), and happily using a NULL pointer when the property isn't there.
Instead, make most of what was brought in with 9173c5ceb035 ("PM / devfreq: rk3399_dmc: Pass ODT and auto power down parameters to TF-A.") conditioned on finding this property in the device-tree, preventing the driver from exploding.
--- drivers/devfreq/rk3399_dmc.c | 42 +++++++++++++++++++++++------------------- 1 file changed, 23 insertions(+), 19 deletions(-)
drivers/devfreq/rk3399_dmc.c +23 -19
@@ -95,18 +95,20 @@ static int rk3399_dmcfreq_target(structmutex_lock (&dmcfreq->lock); -if (target_rate >= dmcfreq->odt_dis_freq) - odt_enable = true; - -/* -* This makes a SMC call to the TF-A to set the DDR PD (power-down) -* timings and to enable or disable the ODT (on-die termination) -* resistors. -*/ -arm_smccc_smc (ROCKCHIP_SIP_DRAM_FREQ , dmcfreq->odt_pd_arg0, - dmcfreq->odt_pd_arg1, -ROCKCHIP_SIP_CONFIG_DRAM_SET_ODT_PD , - odt_enable,0 ,0 ,0 , &res); +if (dmcfreq->regmap_pmu) { +if (target_rate >= dmcfreq->odt_dis_freq) + odt_enable = true; + +/* +* This makes a SMC call to the TF-A to set the DDR PD +* (power-down) timings and to enable or disable the +* ODT (on-die termination) resistors. +*/ +arm_smccc_smc (ROCKCHIP_SIP_DRAM_FREQ , dmcfreq->odt_pd_arg0, + dmcfreq->odt_pd_arg1, +ROCKCHIP_SIP_CONFIG_DRAM_SET_ODT_PD , + odt_enable,0 ,0 ,0 , &res); + }/* * If frequency scaling from low to high, adjust voltage first.
@@ -371,13 +373,14 @@ static int rk3399_dmcfreq_probe(struct p } node =of_parse_phandle (np,"rockchip,pmu" ,0 ); -if (node) { - data->regmap_pmu =syscon_node_to_regmap (node); -of_node_put (node); -if (IS_ERR (data->regmap_pmu)) { - ret =PTR_ERR (data->regmap_pmu); - goto err_edev; - } +if (!node) + goto no_pmu; + + data->regmap_pmu =syscon_node_to_regmap (node); +of_node_put (node); +if (IS_ERR (data->regmap_pmu)) { + ret =PTR_ERR (data->regmap_pmu); + goto err_edev; }regmap_read (data->regmap_pmu,RK3399_PMUGRF_OS_REG2 , &val);
@@ -399,6 +402,7 @@ static int rk3399_dmcfreq_probe(struct p goto err_edev; }; +no_pmu:arm_smccc_smc (ROCKCHIP_SIP_DRAM_FREQ ,0 ,0 ,ROCKCHIP_SIP_CONFIG_DRAM_INIT ,0 ,0 ,0 ,0 , &res);
Greg Kroah-Hartman
maintainerPATCH 364/393 PM / devfreq: Fix indentaion of devfreq_summary debugfs node
In reply to Greg Kroah-HartmanFrom: Chanwoo Choi <[email protected]>
commit 0aae11bcdefb4894b6100656ad24cbd85ff34b52 upstream.
The commit 66d0e797bf09 ("Revert "PM / devfreq: Modify the device name as devfreq(X) for sysfs"") roll back the device name from 'devfreqX' to device name explained in DT. After applied commit 66d0e797bf09, the indentation of devfreq_summary debugfs node was broken.
So, fix indentaion of devfreq_summary debugfs node as following:
For example on Exynos5422-based Odroid-XU3 board,
$ cat /sys/kernel/debug/devfreq/devfreq_summary dev parent_dev governor polling_ms cur_freq_Hz min_freq_Hz max_freq_Hz ------------------------------ ------------------------------ --------------- ---------- ------------ ------------ ------------ 10c20000.memory-controller null simple_ondemand 0 413000000 165000000 825000000 soc:bus_wcore null simple_ondemand 50 88700000 88700000 532000000 soc:bus_noc soc:bus_wcore passive 0 66600000 66600000 111000000 soc:bus_fsys_apb soc:bus_wcore passive 0 111000000 111000000 222000000 soc:bus_fsys soc:bus_wcore passive 0 75000000 75000000 200000000 soc:bus_fsys2 soc:bus_wcore passive 0 75000000 75000000 200000000 soc:bus_mfc soc:bus_wcore passive 0 83250000 83250000 333000000 soc:bus_gen soc:bus_wcore passive 0 88700000 88700000 266000000 soc:bus_peri soc:bus_wcore passive 0 66600000 66600000 66600000 soc:bus_g2d soc:bus_wcore passive 0 83250000 83250000 333000000 soc:bus_g2d_acp soc:bus_wcore passive 0 0 66500000 266000000 soc:bus_jpeg soc:bus_wcore passive 0 0 75000000 300000000 soc:bus_jpeg_apb soc:bus_wcore passive 0 0 83250000 166500000 soc:bus_disp1_fimd soc:bus_wcore passive 0 0 120000000 200000000 soc:bus_disp1 soc:bus_wcore passive 0 0 120000000 300000000 soc:bus_gscl_scaler soc:bus_wcore passive 0 0 150000000 300000000 soc:bus_mscl soc:bus_wcore passive 0 0 84000000 666000000
--- drivers/devfreq/devfreq.c | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-)
drivers/devfreq/devfreq.c +4 -7
@@ -1660,8 +1660,7 @@ static int devfreq_summary_show(struct sunsigned long cur_freq, min_freq, max_freq;unsigned int polling_ms; - seq_printf(s, "%-30s %-10s %-10s %-15s %10s %12s %12s %12s\n", - "dev_name", + seq_printf(s, "%-30s %-30s %-15s %10s %12s %12s %12s\n", "dev", "parent_dev", "governor",
@@ -1669,10 +1668,9 @@ static int devfreq_summary_show(struct s"cur_freq_Hz" ,"min_freq_Hz" , "max_freq_Hz"); - seq_printf(s, "%30s %10s %10s %15s %10s %12s %12s %12s\n", + seq_printf(s, "%30s %30s %15s %10s %12s %12s %12s\n", + "------------------------------", "------------------------------", - "----------", - "----------", "---------------", "----------", "------------",
@@ -1701,8 +1699,7 @@ static int devfreq_summary_show(struct smutex_unlock (&devfreq->lock); seq_printf(s, - "%-30s %-10s %-10s %-15s %10d %12ld %12ld %12ld\n", - dev_name(devfreq->dev.parent), + "%-30s %-30s %-15s %10d %12ld %12ld %12ld\n", dev_name(&devfreq->dev), p_devfreq ? dev_name(&p_devfreq->dev) : "null", devfreq->governor_name,
Greg Kroah-Hartman
maintainerPATCH 365/393 spi: spidev: Align buffers for DMA
In reply to Greg Kroah-HartmanFrom: Christian Eggers <[email protected]>
commit aa9e862d7d5bcecd4dca9f39e8b684b93dd84ee7 upstream.
Simply copying all xfers from userspace into one bounce buffer causes alignment problems if the SPI controller uses DMA.
Ensure that all transfer data blocks within the rx and tx bounce buffers are aligned for DMA (according to ARCH_KMALLOC_MINALIGN).
Alignment may increase the usage of the bounce buffers. In some cases, the buffers may need to be increased using the "bufsiz" module parameter.
--- drivers/spi/spidev.c | 21 +++++++++++++-------- 1 file changed, 13 insertions(+), 8 deletions(-)
drivers/spi/spidev.c +13 -8
@@ -223,6 +223,11 @@ static int spidev_message(struct spidev_for (n = n_xfers, k_tmp = k_xfers, u_tmp = u_xfers; n; n--, k_tmp++, u_tmp++) { +/* Ensure that also following allocations from rx_buf/tx_buf will meet +* DMA alignment requirements. +*/ +unsigned int len_aligned =ALIGN (u_tmp->len,ARCH_KMALLOC_MINALIGN ); + k_tmp->len = u_tmp->len; total += k_tmp->len;
@@ -238,17 +243,17 @@ static int spidev_message(struct spidev_if (u_tmp->rx_buf) {/* this transfer needs space in RX bounce buffer */ - rx_total += k_tmp->len; + rx_total += len_aligned;if (rx_total > bufsiz) { status = -EMSGSIZE ; goto done; } k_tmp->rx_buf = rx_buf; - rx_buf += k_tmp->len; + rx_buf += len_aligned; }if (u_tmp->tx_buf) {/* this transfer needs space in TX bounce buffer */ - tx_total += k_tmp->len; + tx_total += len_aligned;if (tx_total > bufsiz) { status = -EMSGSIZE ; goto done;
@@ -258,7 +263,7 @@ static int spidev_message(struct spidev_ (uintptr_t) u_tmp->tx_buf, u_tmp->len)) goto done; - tx_buf += k_tmp->len; + tx_buf += len_aligned; } k_tmp->cs_change = !!u_tmp->cs_change;
@@ -292,16 +297,16 @@ static int spidev_message(struct spidev_ goto done;/* copy any rx data out of bounce buffer */ - rx_buf = spidev->rx_buffer; -for (n = n_xfers, u_tmp = u_xfers; n; n--, u_tmp++) { +for (n = n_xfers, k_tmp = k_xfers, u_tmp = u_xfers; + n; + n--, k_tmp++, u_tmp++) {if (u_tmp->rx_buf) {if (copy_to_user ((u8 __user *) - (uintptr_t ) u_tmp->rx_buf, rx_buf, + (uintptr_t ) u_tmp->rx_buf, k_tmp->rx_buf, u_tmp->len)) { status = -EFAULT ; goto done; } - rx_buf += u_tmp->len; } } status = total;
Greg Kroah-Hartman
maintainerPATCH 366/393 mtd: rawnand: qcom: avoid write to unavailable register
In reply to Greg Kroah-HartmanFrom: Sivaprakash Murugesan <[email protected]>
commit 443440cc4a901af462239d286cd10721aa1c7dfc upstream.
SFLASHC_BURST_CFG is only available on older ipq NAND platforms, this register has been removed when the NAND controller got implemented in the qpic controller.
Avoid writing this register on devices which are based on qpic NAND controller.
--- drivers/mtd/nand/raw/qcom_nandc.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
drivers/mtd/nand/raw/qcom_nandc.c +6 -1
@@ -459,11 +459,13 @@ struct qcom_nand_host {* among different NAND controllers. * @ecc_modes - ecc mode for NAND * @is_bam - whether NAND controller is using BAM +* @is_qpic - whether NAND CTRL is part of qpic IP * @dev_cmd_reg_start - NAND_DEV_CMD_* registers starting offset */ struct qcom_nandc_props {u32 ecc_modes;bool is_bam; +bool is_qpic;u32 dev_cmd_reg_start; };
@@ -2774,7 +2776,8 @@ static int qcom_nandc_setup(struct qcom_u32 nand_ctrl;/* kill onenand */ -nandc_write (nandc,SFLASHC_BURST_CFG ,0 ); +if (!nandc->props->is_qpic) +nandc_write (nandc,SFLASHC_BURST_CFG ,0 );nandc_write (nandc,dev_cmd_reg_addr (nandc,NAND_DEV_CMD_VLD ),NAND_DEV_CMD_VLD_VAL );
@@ -3030,12 +3033,14 @@ static const struct qcom_nandc_props ipqstatic const struct qcom_nandc_props ipq4019_nandc_props = { .ecc_modes = (ECC_BCH_4BIT |ECC_BCH_8BIT ), .is_bam = true, + .is_qpic = true, .dev_cmd_reg_start =0x0 , };static const struct qcom_nandc_props ipq8074_nandc_props = { .ecc_modes = (ECC_BCH_4BIT |ECC_BCH_8BIT ), .is_bam = true, + .is_qpic = true, .dev_cmd_reg_start =0x7000 , };
Greg Kroah-Hartman
maintainerPATCH 367/393 mtd: spi-nor: intel-spi: Simulate WRDI command
In reply to Greg Kroah-HartmanFrom: Alexander Sverdlin <[email protected]>
commit 44a80df4bfce02f5d51fe5040bdbdf10d0d78f4e upstream.
After spi_nor_write_disable() return code checks were introduced in the spi-nor front end intel-spi backend stopped to work because WRDI was never supported and always failed.
Just pretend it was sucessful and ignore the command itself. HW sequencer shall do the right thing automatically, while with SW sequencer we cannot do it anyway, because the only tool we had was preopcode and it makes no sense for WRDI.
--- drivers/mtd/spi-nor/controllers/intel-spi.c | 9 +++++++++ 1 file changed, 9 insertions(+)
drivers/mtd/spi-nor/controllers/intel-spi.c +9 -0
@@ -612,6 +612,15 @@ static int intel_spi_write_reg(struct spreturn 0 ; } +/* +* We hope that HW sequencer will do the right thing automatically and +* with the SW sequencer we cannot use preopcode anyway, so just ignore +* the Write Disable operation and pretend it was completed +* successfully. +*/ +if (opcode ==SPINOR_OP_WRDI ) +return 0 ; +writel (0 , ispi->base +FADDR );/* Write the value beforehand */
Greg Kroah-Hartman
maintainerPATCH 368/393 erofs: fix extended inode could cross boundary
In reply to Greg Kroah-HartmanFrom: Gao Xiang <[email protected]>
commit 0dcd3c94e02438f4a571690e26f4ee997524102a upstream.
Each ondisk inode should be aligned with inode slot boundary (32-byte alignment) because of nid calculation formula, so all compact inodes (32 byte) cannot across page boundary. However, extended inode is now 64-byte form, which can across page boundary in principle if the location is specified on purpose, although it's hard to be generated by mkfs due to the allocation policy and rarely used by Android use case now mainly for > 4GiB files.
For now, only two fields i_ctime_nsec and `i_nlink' couldn't be read from disk properly and cause out-of-bound memory read with random value.
Let's fix now.
--- fs/erofs/inode.c | 121 +++++++++++++++++++++++++++++++++++-------------------- 1 file changed, 79 insertions(+), 42 deletions(-)
fs/erofs/inode.c +79 -42
@@ -8,31 +8,80 @@#include <trace/events/erofs.h> -/* no locking */ -static int erofs_read_inode (struct inode *inode,void *data) +/* +* if inode is successfully read, return its inode page (or sometimes +* the inode payload page if it's an extended inode) in order to fill +* inline data if possible. +*/ +static struct page *erofs_read_inode (struct inode *inode, +unsigned int *ofs) { +struct super_block *sb = inode->i_sb; +struct erofs_sb_info *sbi =EROFS_SB (sb);struct erofs_inode *vi =EROFS_I (inode); -struct erofs_inode_compact *dic = data; -struct erofs_inode_extended *die; +const erofs_off_t inode_loc =iloc (sbi, vi->nid); -const unsigned int ifmt =le16_to_cpu (dic->i_format); -struct erofs_sb_info *sbi =EROFS_SB (inode->i_sb); -erofs_blk_t nblks =0 ; +erofs_blk_t blkaddr, nblks =0 ; +struct page *page; +struct erofs_inode_compact *dic; +struct erofs_inode_extended *die, *copied =NULL ; +unsigned int ifmt; +int err; - vi->datalayout =erofs_inode_datalayout (ifmt); + blkaddr =erofs_blknr (inode_loc); + *ofs =erofs_blkoff (inode_loc); +erofs_dbg ("%s, reading inode nid %llu at %u of blkaddr %u" , + __func__, vi->nid, *ofs, blkaddr); + + page =erofs_get_meta_page (sb, blkaddr); +if (IS_ERR (page)) { +erofs_err (sb,"failed to get inode (nid: %llu) page, err %ld" , + vi->nid,PTR_ERR (page)); +return page; + } + + dic =page_address (page) + *ofs; + ifmt =le16_to_cpu (dic->i_format); + + vi->datalayout =erofs_inode_datalayout (ifmt);if (vi->datalayout >=EROFS_INODE_DATALAYOUT_MAX ) {erofs_err (inode->i_sb,"unsupported datalayout %u of nid %llu" , vi->datalayout, vi->nid); -DBG_BUGON (1 ); -return -EOPNOTSUPP ; + err = -EOPNOTSUPP ; + goto err_out; }switch (erofs_inode_version (ifmt)) {case EROFS_INODE_LAYOUT_EXTENDED : - die = data; - vi->inode_isize =sizeof (struct erofs_inode_extended ); +/* check if the inode acrosses page boundary */ +if (*ofs + vi->inode_isize <=PAGE_SIZE ) { + *ofs += vi->inode_isize; + die = (struct erofs_inode_extended *)dic; + }else { +const unsigned int gotten =PAGE_SIZE - *ofs; + + copied =kmalloc (vi->inode_isize,GFP_NOFS ); +if (!copied) { + err = -ENOMEM ; + goto err_out; + } +memcpy (copied, dic, gotten); +unlock_page (page); +put_page (page); + + page =erofs_get_meta_page (sb, blkaddr +1 ); +if (IS_ERR (page)) { +erofs_err (sb,"failed to get inode payload page (nid: %llu), err %ld" , + vi->nid,PTR_ERR (page)); +kfree (copied); +return page; + } + *ofs = vi->inode_isize - gotten; +memcpy ((u8 *)copied + gotten,page_address (page), *ofs); + die = copied; + } vi->xattr_isize =erofs_xattr_ibody_size (die->i_xattr_icount); inode->i_mode =le16_to_cpu (die->i_mode);
@@ -69,9 +118,12 @@ static int erofs_read_inode(struct inode/* total blocks for compressed files */ if (erofs_inode_is_data_compressed (vi->datalayout)) nblks =le32_to_cpu (die->i_u.compressed_blocks); + +kfree (copied);break ;case EROFS_INODE_LAYOUT_COMPACT : vi->inode_isize =sizeof (struct erofs_inode_compact ); + *ofs += vi->inode_isize; vi->xattr_isize =erofs_xattr_ibody_size (dic->i_xattr_icount); inode->i_mode =le16_to_cpu (dic->i_mode);
@@ -111,8 +163,8 @@ static int erofs_read_inode(struct inodeerofs_err (inode->i_sb,"unsupported on-disk inode version %u of nid %llu" ,erofs_inode_version (ifmt), vi->nid); -DBG_BUGON (1 ); -return -EOPNOTSUPP ; + err = -EOPNOTSUPP ; + goto err_out; }if (!nblks)
@@ -120,13 +172,18 @@ static int erofs_read_inode(struct inode inode->i_blocks =roundup (inode->i_size,EROFS_BLKSIZ ) >>9 ; else inode->i_blocks = nblks << LOG_SECTORS_PER_BLOCK; -return 0 ; +return page; bogusimode:erofs_err (inode->i_sb,"bogus i_mode (%o) @ nid %llu" , inode->i_mode, vi->nid); + err = -EFSCORRUPTED ; +err_out:DBG_BUGON (1 ); -return -EFSCORRUPTED ; +kfree (copied); +unlock_page (page); +put_page (page); +return ERR_PTR (err); } static int erofs_fill_symlink(struct inode *inode, void *data,
@@ -146,7 +203,7 @@ static int erofs_fill_symlink(struct inoif (!lnk)return -ENOMEM ; - m_pofs += vi->inode_isize + vi->xattr_isize; + m_pofs += vi->xattr_isize;/* inline symlink data shouldn't cross page boundary as well */ if (m_pofs + inode->i_size >PAGE_SIZE ) {kfree (lnk);
@@ -167,37 +224,17 @@ static int erofs_fill_symlink(struct inostatic int erofs_fill_inode (struct inode *inode,int isdir) { -struct super_block *sb = inode->i_sb;struct erofs_inode *vi =EROFS_I (inode);struct page *page; -void *data; -int err; -erofs_blk_t blkaddr;unsigned int ofs; -erofs_off_t inode_loc; +int err =0 ;trace_erofs_fill_inode (inode, isdir); - inode_loc =iloc (EROFS_SB (sb), vi->nid); - blkaddr =erofs_blknr (inode_loc); - ofs =erofs_blkoff (inode_loc); - -erofs_dbg ("%s, reading inode nid %llu at %u of blkaddr %u" , - __func__, vi->nid, ofs, blkaddr); - page =erofs_get_meta_page (sb, blkaddr); - -if (IS_ERR (page)) { -erofs_err (sb,"failed to get inode (nid: %llu) page, err %ld" , - vi->nid,PTR_ERR (page)); +/* read inode base data from disk */ + page =erofs_read_inode (inode, &ofs); +if (IS_ERR (page))return PTR_ERR (page); - } - -DBG_BUGON (!PageUptodate (page)); - data =page_address (page); - - err =erofs_read_inode (inode, data + ofs); -if (err) - goto out_unlock;/* setup the new inode */ switch (inode->i_mode &S_IFMT ) {
@@ -210,7 +247,7 @@ static int erofs_fill_inode(struct inode inode->i_fop = &erofs_dir_fops;break ;case S_IFLNK : - err =erofs_fill_symlink (inode, data, ofs); + err =erofs_fill_symlink (inode,page_address (page), ofs);if (err) goto out_unlock;inode_nohighmem (inode);
Greg Kroah-Hartman
maintainerPATCH 369/393 Revert "parisc: Improve interrupt handling in arch_spin_lock_flags()"
In reply to Greg Kroah-HartmanFrom: Helge Deller <[email protected]>
commit 3d05b8aebc5f10ee3ab129b61100196855dd7249 upstream.
This reverts commit 2772f0efd5bbd5413db3d22e363b779ca0fa5310. It turns out that we want to implement the spinlock code differently.
--- arch/parisc/include/asm/spinlock.h | 25 ++++++++----------------- 1 file changed, 8 insertions(+), 17 deletions(-)
arch/parisc/include/asm/spinlock.h +8 -17
@@ -10,34 +10,25 @@static inline int arch_spin_is_locked (arch_spinlock_t *x) {volatile unsigned int *a =__ldcw_align (x); -smp_mb ();return *a ==0 ; } -static inline void arch_spin_lock (arch_spinlock_t *x) -{ -volatile unsigned int *a; - - a =__ldcw_align (x); -while (__ldcw (a) ==0 ) -while (*a ==0 ) -cpu_relax (); -} +#define arch_spin_lock (lock) arch_spin_lock_flags(lock, 0)static inline void arch_spin_lock_flags (arch_spinlock_t *x,unsigned long flags) {volatile unsigned int *a; -unsigned long flags_dis; a =__ldcw_align (x); -while (__ldcw (a) ==0 ) { -local_save_flags (flags_dis); -local_irq_restore (flags); +while (__ldcw (a) ==0 )while (*a ==0 ) -cpu_relax (); -local_irq_restore (flags_dis); - } +if (flags &PSW_SM_I ) { +local_irq_enable (); +cpu_relax (); +local_irq_disable (); + }else +cpu_relax (); }#define arch_spin_lock_flags arch_spin_lock_flags
Greg Kroah-Hartman
maintainerPATCH 370/393 Revert "parisc: Drop LDCW barrier in CAS code when running UP"
In reply to Greg Kroah-HartmanFrom: Helge Deller <[email protected]>
commit 462fb756c7de1ffe5bc6099149136031c2d9c02a upstream.
This reverts commit e6eb5fe9123f05dcbf339ae5c0b6d32fcc0685d5. We need to optimize it differently. A follow up patch will correct it.
--- arch/parisc/kernel/syscall.S | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-)
arch/parisc/kernel/syscall.S +4 -8
@@ -641,8 +641,7 @@ cas_action: 2: stw %r24, 0(%r26) /* Free lock */ #ifdef CONFIG_SMP -98: LDCW 0(%sr2,%r20), %r1 /* Barrier */ -99: ALTERNATIVE(98b, 99b, ALT_COND_NO_SMP, INSN_NOP) + LDCW 0(%sr2,%r20), %r1 /* Barrier */ #endif stw %r20, 0(%sr2,%r20) #if ENABLE_LWS_DEBUG
@@ -659,8 +658,7 @@ cas_action: /* Error occurred on load or store */ /* Free lock */ #ifdef CONFIG_SMP -98: LDCW 0(%sr2,%r20), %r1 /* Barrier */ -99: ALTERNATIVE(98b, 99b, ALT_COND_NO_SMP, INSN_NOP) + LDCW 0(%sr2,%r20), %r1 /* Barrier */ #endif stw %r20, 0(%sr2,%r20) #if ENABLE_LWS_DEBUG
@@ -864,8 +862,7 @@ cas2_action: cas2_end: /* Free lock */ #ifdef CONFIG_SMP -98: LDCW 0(%sr2,%r20), %r1 /* Barrier */ -99: ALTERNATIVE(98b, 99b, ALT_COND_NO_SMP, INSN_NOP) + LDCW 0(%sr2,%r20), %r1 /* Barrier */ #endif stw %r20, 0(%sr2,%r20) /* Enable interrupts */
@@ -878,8 +875,7 @@ cas2_end: /* Error occurred on load or store */ /* Free lock */ #ifdef CONFIG_SMP -98: LDCW 0(%sr2,%r20), %r1 /* Barrier */ -99: ALTERNATIVE(98b, 99b, ALT_COND_NO_SMP, INSN_NOP) + LDCW 0(%sr2,%r20), %r1 /* Barrier */ #endif stw %r20, 0(%sr2,%r20) ssm PSW_SM_I, %r0
Greg Kroah-Hartman
maintainerPATCH 371/393 Revert "parisc: Use ldcw instruction for SMP spinlock release barrier"
In reply to Greg Kroah-HartmanFrom: Helge Deller <[email protected]>
commit 6e9f06ee6c9566f3606d93182ac8f803a148504b upstream.
This reverts commit 9e5c602186a692a7e848c0da17aed40f49d30519. No need to use the ldcw instruction as SMP spinlock release barrier. Revert it to gain back speed again.
--- arch/parisc/include/asm/spinlock.h | 4 --- arch/parisc/kernel/entry.S | 43 +++++++++++++++++-------------------- arch/parisc/kernel/syscall.S | 16 +++---------- 3 files changed, 24 insertions(+), 39 deletions(-)
arch/parisc/include/asm/spinlock.h +0 -4
@@ -37,11 +37,7 @@ static inline void arch_spin_unlock(archvolatile unsigned int *a; a =__ldcw_align (x); -#ifdef CONFIG_SMP - (void )__ldcw (a); -#else mb (); -#endif *a =1 ; }
arch/parisc/kernel/entry.S +20 -23
156 lines not on this page · raw message
arch/parisc/kernel/syscall.S +4 -12
@@ -640,9 +640,7 @@ cas_action: sub,<> %r28, %r25, %r0 2: stw %r24, 0(%r26) /* Free lock */ -#ifdef CONFIG_SMP - LDCW 0(%sr2,%r20), %r1 /* Barrier */ -#endif + sync stw %r20, 0(%sr2,%r20) #if ENABLE_LWS_DEBUG /* Clear thread register indicator */
@@ -657,9 +655,7 @@ cas_action: 3: /* Error occurred on load or store */ /* Free lock */ -#ifdef CONFIG_SMP - LDCW 0(%sr2,%r20), %r1 /* Barrier */ -#endif + sync stw %r20, 0(%sr2,%r20) #if ENABLE_LWS_DEBUG stw %r0, 4(%sr2,%r20)
@@ -861,9 +857,7 @@ cas2_action: cas2_end: /* Free lock */ -#ifdef CONFIG_SMP - LDCW 0(%sr2,%r20), %r1 /* Barrier */ -#endif + sync stw %r20, 0(%sr2,%r20) /* Enable interrupts */ ssm PSW_SM_I, %r0
@@ -874,9 +868,7 @@ cas2_end: 22: /* Error occurred on load or store */ /* Free lock */ -#ifdef CONFIG_SMP - LDCW 0(%sr2,%r20), %r1 /* Barrier */ -#endif + sync stw %r20, 0(%sr2,%r20) ssm PSW_SM_I, %r0 ldo 1(%r0),%r28
Greg Kroah-Hartman
maintainerPATCH 372/393 Revert "parisc: Revert "Release spinlocks using ordered store""
In reply to Greg Kroah-HartmanFrom: Helge Deller <[email protected]>
commit 157e9afcc4fa25068b0e8743bc254a9b56010e13 upstream.
This reverts commit 86d4d068df573a8c2105554624796c086d6bec3d.
--- arch/parisc/include/asm/spinlock.h | 4 ++-- arch/parisc/kernel/syscall.S | 12 ++++-------- 2 files changed, 6 insertions(+), 10 deletions(-)
arch/parisc/include/asm/spinlock.h +2 -2
@@ -37,8 +37,8 @@ static inline void arch_spin_unlock(archvolatile unsigned int *a; a =__ldcw_align (x); -mb (); - *a =1 ; +/* Release with ordered store. */ + __asm__ __volatile__("stw,ma %0,0(%1)" : :"r" (1 ),"r" (a) :"memory" ); }static inline int arch_spin_trylock (arch_spinlock_t *x)
arch/parisc/kernel/syscall.S +4 -8
@@ -640,8 +640,7 @@ cas_action: sub,<> %r28, %r25, %r0 2: stw %r24, 0(%r26) /* Free lock */ - sync - stw %r20, 0(%sr2,%r20) + stw,ma %r20, 0(%sr2,%r20) #if ENABLE_LWS_DEBUG /* Clear thread register indicator */ stw %r0, 4(%sr2,%r20)
@@ -655,8 +654,7 @@ cas_action: 3: /* Error occurred on load or store */ /* Free lock */ - sync - stw %r20, 0(%sr2,%r20) + stw,ma %r20, 0(%sr2,%r20) #if ENABLE_LWS_DEBUG stw %r0, 4(%sr2,%r20) #endif
@@ -857,8 +855,7 @@ cas2_action: cas2_end: /* Free lock */ - sync - stw %r20, 0(%sr2,%r20) + stw,ma %r20, 0(%sr2,%r20) /* Enable interrupts */ ssm PSW_SM_I, %r0 /* Return to userspace, set no error */
@@ -868,8 +865,7 @@ cas2_end: 22: /* Error occurred on load or store */ /* Free lock */ - sync - stw %r20, 0(%sr2,%r20) + stw,ma %r20, 0(%sr2,%r20) ssm PSW_SM_I, %r0 ldo 1(%r0),%r28 b lws_exit
Greg Kroah-Hartman
maintainerPATCH 373/393 parisc: Do not use an ordered store in pa_tlb_lock()
In reply to Greg Kroah-HartmanFrom: John David Anglin <[email protected]>
commit e72b23dec1da5e62a0090c5da1d926778284e230 upstream.
No need to use an ordered store in pa_tlb_lock() and update the comment regarng usage of the sid register to unlocak a spinlock in tlb_unlock0().
--- arch/parisc/kernel/entry.S | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-)
arch/parisc/kernel/entry.S +7 -2
@@ -455,7 +455,7 @@ LDREG 0(\ptp),\pte bb,<,n \pte,_PAGE_PRESENT_BIT,3f b \fault - stw,ma \spc,0(\tmp) + stw \spc,0(\tmp) 99: ALTERNATIVE(98b, 99b, ALT_COND_NO_SMP, INSN_NOP) #endif 2: LDREG 0(\ptp),\pte
@@ -463,7 +463,12 @@ 3: .endm - /* Release pa_tlb_lock lock without reloading lock address. */ + /* Release pa_tlb_lock lock without reloading lock address. + Note that the values in the register spc are limited to + NR_SPACE_IDS (262144). Thus, the stw instruction always + stores a nonzero value even when register spc is 64 bits. + We use an ordered store to ensure all prior accesses are + performed prior to releasing the lock. */ .macro tlb_unlock0 spc,tmp #ifdef CONFIG_SMP 98: or,COND(=) %r0,\spc,%r0
Greg Kroah-Hartman
maintainerPATCH 374/393 parisc: Implement __smp_store_release and __smp_load_acquire barriers
In reply to Greg Kroah-HartmanFrom: John David Anglin <[email protected]>
commit e96ebd589debd9a6a793608c4ec7019c38785dea upstream.
This patch implements the __smp_store_release and __smp_load_acquire barriers using ordered stores and loads. This avoids the sync instruction present in the generic implementation.
--- arch/parisc/include/asm/barrier.h | 61 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+)
arch/parisc/include/asm/barrier.h +61 -0
@@ -26,6 +26,67 @@#define __smp_rmb () mb()#define __smp_wmb () mb() +#define __smp_store_release (p, v) \ +do { \ + typeof(p) __p = (p); \ + union { typeof(*p) __val; char __c[1]; } __u = \ + { .__val = (__force typeof(*p)) (v) }; \ + compiletime_assert_atomic_type(*p); \ + switch (sizeof(*p)) { \ + case 1: \ + asm volatile("stb,ma %0,0(%1)" \ + : : "r"(*(__u8 *)__u.__c), "r"(__p) \ + : "memory"); \ + break; \ + case 2: \ + asm volatile("sth,ma %0,0(%1)" \ + : : "r"(*(__u16 *)__u.__c), "r"(__p) \ + : "memory"); \ + break; \ + case 4: \ + asm volatile("stw,ma %0,0(%1)" \ + : : "r"(*(__u32 *)__u.__c), "r"(__p) \ + : "memory"); \ + break; \ + case 8: \ + if (IS_ENABLED(CONFIG_64BIT)) \ + asm volatile("std,ma %0,0(%1)" \ + : : "r"(*(__u64 *)__u.__c), "r"(__p) \ + : "memory"); \ + break; \ + } \ +} while (0) + +#define __smp_load_acquire (p) \ +({ \ + union { typeof(*p) __val; char __c[1]; } __u; \ + typeof(p) __p = (p); \ + compiletime_assert_atomic_type(*p); \ + switch (sizeof(*p)) { \ + case 1: \ + asm volatile("ldb,ma 0(%1),%0" \ + : "=r"(*(__u8 *)__u.__c) : "r"(__p) \ + : "memory"); \ + break; \ + case 2: \ + asm volatile("ldh,ma 0(%1),%0" \ + : "=r"(*(__u16 *)__u.__c) : "r"(__p) \ + : "memory"); \ + break; \ + case 4: \ + asm volatile("ldw,ma 0(%1),%0" \ + : "=r"(*(__u32 *)__u.__c) : "r"(__p) \ + : "memory"); \ + break; \ + case 8: \ + if (IS_ENABLED(CONFIG_64BIT)) \ + asm volatile("ldd,ma 0(%1),%0" \ + : "=r"(*(__u64 *)__u.__c) : "r"(__p) \ + : "memory"); \ + break; \ + } \ + __u.__val; \ +})#include <asm-generic/barrier.h> #endif /* !__ASSEMBLY__ */
Greg Kroah-Hartman
maintainerPATCH 375/393 parisc: mask out enable and reserved bits from sba imask
In reply to Greg Kroah-HartmanFrom: Sven Schnelle <[email protected]>
commit 5b24993c21cbf2de11aff077a48c5cb0505a0450 upstream.
When using kexec the SBA IOMMU IBASE might still have the RE bit set. This triggers a WARN_ON when trying to write back the IBASE register later, and it also makes some mask calculations fail.
--- drivers/parisc/sba_iommu.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/parisc/sba_iommu.c +1 -1
@@ -1270,7 +1270,7 @@ sba_ioc_init_pluto(struct parisc_device** (one that doesn't overlap memory or LMMIO space) in the ** IBASE and IMASK registers. */ - ioc->ibase =READ_REG (ioc->ioc_hpa +IOC_IBASE ); + ioc->ibase =READ_REG (ioc->ioc_hpa +IOC_IBASE ) & ~0x1fffffULL ; iova_space_size = ~(READ_REG (ioc->ioc_hpa +IOC_IMASK ) &0xFFFFFFFFUL ) +1 ;if ((ioc->ibase <0xfed00000UL ) && ((ioc->ibase + iova_space_size) >0xfee00000UL )) {
Greg Kroah-Hartman
maintainerPATCH 376/393 ARM: dts: exynos: Extend all Exynos5800 A15s OPPs with max voltage data
In reply to Greg Kroah-HartmanFrom: Marek Szyprowski <[email protected]>
commit d644853ff8fcbb7a4e3757f9d8ccc39d930b7e3c upstream.
On Exynos5422/5800 the regulator supply for the A15 cores ("vdd_arm") is coupled with the regulator supply for the SoC internal circuits ("vdd_int"), thus all operating points that modify one of those supplies have to specify a triplet of the min/target/max values to properly work with regulator coupling.
--- arch/arm/boot/dts/exynos5800.dtsi | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
arch/arm/boot/dts/exynos5800.dtsi +3 -3
@@ -23,17 +23,17 @@ &cluster_a15_opp_table { opp-2000000000 { opp-hz = /bits/ 64 <2000000000>; - opp-microvolt = <1312500>; + opp-microvolt = <1312500 1312500 1500000>; clock-latency-ns = <140000>; }; opp-1900000000 { opp-hz = /bits/ 64 <1900000000>; - opp-microvolt = <1262500>; + opp-microvolt = <1262500 1262500 1500000>; clock-latency-ns = <140000>; }; opp-1800000000 { opp-hz = /bits/ 64 <1800000000>; - opp-microvolt = <1237500>; + opp-microvolt = <1237500 1237500 1500000>; clock-latency-ns = <140000>; }; opp-1700000000 {
Greg Kroah-Hartman
maintainerPATCH 377/393 ARM: 8992/1: Fix unwind_frame for clang-built kernels
In reply to Greg Kroah-HartmanFrom: Nathan Huckleberry <[email protected]>
commit b4d5ec9b39f8b31d98f65bc5577b5d15d93795d7 upstream.
Since clang does not push pc and sp in function prologues, the current implementation of unwind_frame does not work. By using the previous frame's lr/fp instead of saved pc/sp we get valid unwinds on clang-built kernels.
The bounds check on next frame pointer must be changed as well since there are 8 less bytes between frames.
This fixes /proc/<pid>/stack.
--- arch/arm/kernel/stacktrace.c | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)
arch/arm/kernel/stacktrace.c +24 -0
@@ -22,6 +22,19 @@* A simple function epilogue looks like this: * ldm sp, {fp, sp, pc} * +* When compiled with clang, pc and sp are not pushed. A simple function +* prologue looks like this when built with clang: +* +* stmdb {..., fp, lr} +* add fp, sp, #x +* sub sp, sp, #y +* +* A simple function epilogue looks like this when built with clang: +* +* sub sp, fp, #x +* ldm {..., fp, pc} +* +* * Note that with framepointer enabled, even the leaf functions have the same * prologue and epilogue, therefore we can ignore the LR value in this case. */
@@ -34,6 +47,16 @@ int notrace unwind_frame(struct stackfra low = frame->sp; high =ALIGN (low,THREAD_SIZE ); +#ifdef CONFIG_CC_IS_CLANG +/* check current frame pointer is within bounds */ +if (fp < low +4 || fp > high -4 ) +return -EINVAL ; + + frame->sp = frame->fp; + frame->fp = *(unsigned long *)(fp); + frame->pc = frame->lr; + frame->lr = *(unsigned long *)(fp +4 ); +#else /* check current frame pointer is within bounds */ if (fp < low +12 || fp > high -4 )return -EINVAL ;
@@ -42,6 +65,7 @@ int notrace unwind_frame(struct stackfra frame->fp = *(unsigned long *)(fp -12 ); frame->sp = *(unsigned long *)(fp -8 ); frame->pc = *(unsigned long *)(fp -4 ); +#endif return 0 ; }
Greg Kroah-Hartman
maintainerPATCH 378/393 firmware: qcom_scm: Fix legacy convention SCM accessors
In reply to Greg Kroah-HartmanFrom: Jonathan McDowell <[email protected]>
commit b88c28280c3f7097546db93824686db1e7dceee1 upstream.
The move to a combined driver for the QCOM SCM hardware changed the io_writel and io_readl helpers to use non-atomic calls, despite the commit message saying that atomic was a better option. This breaks these helpers on hardware that uses the old legacy convention (access fails with a -95 return code). Switch back to using the atomic calls.
Observed as a failure routing GPIO interrupts to the Apps processor on an IPQ8064; fix is confirmed as correctly allowing the interrupts to be routed and observed.
--- drivers/firmware/qcom_scm.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-)
drivers/firmware/qcom_scm.c +3 -4
@@ -391,7 +391,7 @@ static int __qcom_scm_set_dload_mode(str desc.args[1 ] = enable ?QCOM_SCM_BOOT_SET_DLOAD_MODE :0 ; -return qcom_scm_call (__scm->dev, &desc,NULL ); +return qcom_scm_call_atomic (__scm->dev, &desc,NULL ); }static void qcom_scm_set_download_mode (bool enable)
@@ -650,7 +650,7 @@ int qcom_scm_io_readl(phys_addr_t addr,int ret; - ret =qcom_scm_call (__scm->dev, &desc, &res); + ret =qcom_scm_call_atomic (__scm->dev, &desc, &res);if (ret >=0 ) *val = res.result[0 ];
@@ -669,8 +669,7 @@ int qcom_scm_io_writel(phys_addr_t addr, .owner = ARM_SMCCC_OWNER_SIP, }; - -return qcom_scm_call (__scm->dev, &desc,NULL ); +return qcom_scm_call_atomic (__scm->dev, &desc,NULL ); }EXPORT_SYMBOL (qcom_scm_io_writel);
Greg Kroah-Hartman
maintainerPATCH 379/393 irqdomain/treewide: Free firmware node after domain removal
In reply to Greg Kroah-HartmanFrom: Jon Derrick <[email protected]>
commit ec0160891e387f4771f953b888b1fe951398e5d9 upstream.
Commit 711419e504eb ("irqdomain: Add the missing assignment of domain->fwnode for named fwnode") unintentionally caused a dangling pointer page fault issue on firmware nodes that were freed after IRQ domain allocation. Commit e3beca48a45b fixed that dangling pointer issue by only freeing the firmware node after an IRQ domain allocation failure. That fix no longer frees the firmware node immediately, but leaves the firmware node allocated after the domain is removed.
The firmware node must be kept around through irq_domain_remove, but should be freed it afterwards.
Add the missing free operations after domain removal where where appropriate.
--- arch/mips/pci/pci-xtalk-bridge.c | 3 +++ arch/x86/kernel/apic/io_apic.c | 5 +++++ drivers/iommu/intel_irq_remapping.c | 8 ++++++++ drivers/mfd/ioc3.c | 6 ++++++ drivers/pci/controller/vmd.c | 3 +++ 5 files changed, 25 insertions(+)
arch/mips/pci/pci-xtalk-bridge.c +3 -0
@@ -728,6 +728,7 @@ err_free_resource:pci_free_resource_list (&host->windows); err_remove_domain:irq_domain_remove (domain); +irq_domain_free_fwnode (fn);return err; }
@@ -735,8 +736,10 @@ static int bridge_remove(struct platform {struct pci_bus *bus =platform_get_drvdata (pdev);struct bridge_controller *bc =BRIDGE_CONTROLLER (bus); +struct fwnode_handle *fn = bc->domain->fwnode;irq_domain_remove (bc->domain); +irq_domain_free_fwnode (fn);pci_lock_rescan_remove ();pci_stop_root_bus (bus);pci_remove_root_bus (bus);
arch/x86/kernel/apic/io_apic.c +5 -0
@@ -2348,8 +2348,13 @@ static int mp_irqdomain_create(int ioapistatic void ioapic_destroy_irqdomain (int idx) { +struct ioapic_domain_cfg *cfg = &ioapics[idx].irqdomain_cfg; +struct fwnode_handle *fn = ioapics[idx].irqdomain->fwnode; +if (ioapics[idx].irqdomain) {irq_domain_remove (ioapics[idx].irqdomain); +if (!cfg->dev) +irq_domain_free_fwnode (fn); ioapics[idx].irqdomain =NULL ; } }
drivers/iommu/intel_irq_remapping.c +8 -0
@@ -628,13 +628,21 @@ out_free_table:static void intel_teardown_irq_remapping (struct intel_iommu *iommu) { +struct fwnode_handle *fn; +if (iommu && iommu->ir_table) {if (iommu->ir_msi_domain) { + fn = iommu->ir_msi_domain->fwnode; +irq_domain_remove (iommu->ir_msi_domain); +irq_domain_free_fwnode (fn); iommu->ir_msi_domain =NULL ; }if (iommu->ir_domain) { + fn = iommu->ir_domain->fwnode; +irq_domain_remove (iommu->ir_domain); +irq_domain_free_fwnode (fn); iommu->ir_domain =NULL ; } free_pages((unsigned long)iommu->ir_table->base,
drivers/mfd/ioc3.c +6 -0
@@ -616,7 +616,10 @@ static int ioc3_mfd_probe(struct pci_dev/* Remove all already added MFD devices */ mfd_remove_devices (&ipd->pdev->dev);if (ipd->domain) { +struct fwnode_handle *fn = ipd->domain->fwnode; +irq_domain_remove (ipd->domain); +irq_domain_free_fwnode (fn);free_irq (ipd->domain_irq, (void *)ipd); }pci_iounmap (pdev, regs);
@@ -643,7 +646,10 @@ static void ioc3_mfd_remove(struct pci_d/* Release resources */ mfd_remove_devices (&ipd->pdev->dev);if (ipd->domain) { +struct fwnode_handle *fn = ipd->domain->fwnode; +irq_domain_remove (ipd->domain); +irq_domain_free_fwnode (fn);free_irq (ipd->domain_irq, (void *)ipd); }pci_iounmap (pdev, ipd->regs);
drivers/pci/controller/vmd.c +3 -0
@@ -560,6 +560,7 @@ static int vmd_enable_domain(struct vmd_if (!vmd->bus) {pci_free_resource_list (&resources);irq_domain_remove (vmd->irq_domain); +irq_domain_free_fwnode (fn);return -ENODEV ; }
@@ -673,6 +674,7 @@ static void vmd_cleanup_srcu(struct vmd_static void vmd_remove (struct pci_dev *dev) {struct vmd_dev *vmd =pci_get_drvdata (dev); +struct fwnode_handle *fn = vmd->irq_domain->fwnode;sysfs_remove_link (&vmd->dev->dev.kobj,"domain" );pci_stop_root_bus (vmd->bus);
@@ -680,6 +682,7 @@ static void vmd_remove(struct pci_dev *dvmd_cleanup_srcu (vmd);vmd_detach_resources (vmd);irq_domain_remove (vmd->irq_domain); +irq_domain_free_fwnode (fn); }#ifdef CONFIG_PM_SLEEP
Greg Kroah-Hartman
maintainerPATCH 380/393 firmware_loader: EFI firmware loader must handle pre-allocated buffer
In reply to Greg Kroah-HartmanFrom: Kees Cook <[email protected]>
commit 4fb60b158afd3ac9e0fe9975aa476213f5cc0a4d upstream.
The EFI platform firmware fallback would clobber any pre-allocated buffers. Instead, correctly refuse to reallocate when too small (as already done in the sysfs fallback), or perform allocation normally when needed.
--- drivers/base/firmware_loader/fallback_platform.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
drivers/base/firmware_loader/fallback_platform.c +4 -1
@@ -25,7 +25,10 @@ int firmware_fallback_platform(struct fwif (rc)return rc;/* rc == -ENOENT when the fw was not found */ - fw_priv->data =vmalloc (size); +if (fw_priv->data && size > fw_priv->allocated_size) +return -ENOMEM ; +if (!fw_priv->data) + fw_priv->data =vmalloc (size);if (!fw_priv->data)return -ENOMEM ;
Greg Kroah-Hartman
maintainerPATCH 381/393 xen/balloon: fix accounting in alloc_xenballooned_pages error path
In reply to Greg Kroah-HartmanFrom: Roger Pau Monne <[email protected]>
commit 1951fa33ec259abdf3497bfee7b63e7ddbb1a394 upstream.
target_unpopulated is incremented with nr_pages at the start of the function, but the call to free_xenballooned_pages will only subtract pgno number of pages, and thus the rest need to be subtracted before returning or else accounting will be skewed.
--- drivers/xen/balloon.c | 6 ++++++ 1 file changed, 6 insertions(+)
drivers/xen/balloon.c +6 -0
@@ -631,6 +631,12 @@ int alloc_xenballooned_pages(int nr_page out_undo:mutex_unlock (&balloon_mutex);free_xenballooned_pages (pgno, pages); +/* +* NB: free_xenballooned_pages will only subtract pgno pages, but since +* target_unpopulated is incremented with nr_pages at the start we need +* to remove the remaining ones also, or accounting will be screwed. +*/ + balloon_stats.target_unpopulated -= nr_pages - pgno;return ret; }EXPORT_SYMBOL (alloc_xenballooned_pages);
Greg Kroah-Hartman
maintainerPATCH 382/393 xen/balloon: make the balloon wait interruptible
In reply to Greg Kroah-HartmanFrom: Roger Pau Monne <[email protected]>
commit 88a479ff6ef8af7f07e11593d58befc644244ff7 upstream.
So it can be killed, or else processes can get hung indefinitely waiting for balloon pages.
--- drivers/xen/balloon.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
drivers/xen/balloon.c +4 -2
@@ -569,11 +569,13 @@ static int add_ballooned_pages(int nr_paif (xen_hotplug_unpopulated) { st =reserve_additional_memory ();if (st !=BP_ECANCELED ) { +int rc; +mutex_unlock (&balloon_mutex); -wait_event (balloon_wq, + rc =wait_event_interruptible (balloon_wq, !list_empty (&ballooned_pages));mutex_lock (&balloon_mutex); -return 0 ; +return rc ? -ENOMEM :0 ; } }
Greg Kroah-Hartman
maintainerPATCH 383/393 xen/gntdev: Fix dmabuf import with non-zero sgt offset
In reply to Greg Kroah-HartmanFrom: Oleksandr Andrushchenko <[email protected]>
commit 5fa4e6f1c2d8c9a4e47e1931b42893172d388f2b upstream.
It is possible that the scatter-gather table during dmabuf import has non-zero offset of the data, but user-space doesn't expect that. Fix this by failing the import, so user-space doesn't access wrong data.
--- drivers/xen/gntdev-dmabuf.c | 8 ++++++++ 1 file changed, 8 insertions(+)
drivers/xen/gntdev-dmabuf.c +8 -0
@@ -613,6 +613,14 @@ dmabuf_imp_to_refs(struct gntdev_dmabuf_ goto fail_detach; } +/* Check that we have zero offset. */ +if (sgt->sgl->offset) { + ret =ERR_PTR (-EINVAL ); +pr_debug ("DMA buffer has %d bytes offset, user-space expects 0\n" , + sgt->sgl->offset); + goto fail_unmap; + } +/* Check number of pages that imported buffer has. */ if (attach->dmabuf->size != gntdev_dmabuf->nr_pages <<PAGE_SHIFT ) { ret =ERR_PTR (-EINVAL );
Greg Kroah-Hartman
maintainerPATCH 384/393 drm/xen-front: Fix misused IS_ERR_OR_NULL checks
In reply to Greg Kroah-HartmanFrom: Oleksandr Andrushchenko <[email protected]>
commit 14dee058610446aa464254fc5c8e88c7535195e0 upstream.
The patch c575b7eeb89f: "drm/xen-front: Add support for Xen PV display frontend" from Apr 3, 2018, leads to the following static checker warning:
drivers/gpu/drm/xen/xen_drm_front_gem.c:140 xen_drm_front_gem_create() warn: passing zero to 'ERR_CAST'
drivers/gpu/drm/xen/xen_drm_front_gem.c
133 struct drm_gem_object *xen_drm_front_gem_create(struct drm_device *dev,
134 size_t size)
135 {
136 struct xen_gem_object *xen_obj;
137
138 xen_obj = gem_create(dev, size);
139 if (IS_ERR_OR_NULL(xen_obj))
140 return ERR_CAST(xen_obj);
Fix this and the rest of misused places with IS_ERR_OR_NULL in the driver.
--- drivers/gpu/drm/xen/xen_drm_front.c | 4 ++-- drivers/gpu/drm/xen/xen_drm_front_gem.c | 8 ++++---- drivers/gpu/drm/xen/xen_drm_front_kms.c | 2 +- 3 files changed, 7 insertions(+), 7 deletions(-)
drivers/gpu/drm/xen/xen_drm_front.c +2 -2
@@ -400,8 +400,8 @@ static int xen_drm_drv_dumb_create(struc args->size = args->pitch * args->height; obj =xen_drm_front_gem_create (dev, args->size); -if (IS_ERR_OR_NULL (obj)) { - ret =PTR_ERR_OR_ZERO (obj); +if (IS_ERR (obj)) { + ret =PTR_ERR (obj); goto fail; }
drivers/gpu/drm/xen/xen_drm_front_gem.c +4 -4
@@ -83,7 +83,7 @@ static struct xen_gem_object *gem_create size =round_up (size,PAGE_SIZE ); xen_obj =gem_create_obj (dev, size); -if (IS_ERR_OR_NULL (xen_obj)) +if (IS_ERR (xen_obj))return xen_obj;if (drm_info->front_info->cfg.be_alloc) {
@@ -117,7 +117,7 @@ static struct xen_gem_object *gem_create*/ xen_obj->num_pages =DIV_ROUND_UP (size,PAGE_SIZE ); xen_obj->pages =drm_gem_get_pages (&xen_obj->base); -if (IS_ERR_OR_NULL (xen_obj->pages)) { +if (IS_ERR (xen_obj->pages)) { ret =PTR_ERR (xen_obj->pages); xen_obj->pages =NULL ; goto fail;
@@ -136,7 +136,7 @@ struct drm_gem_object *xen_drm_front_gemstruct xen_gem_object *xen_obj; xen_obj =gem_create (dev, size); -if (IS_ERR_OR_NULL (xen_obj)) +if (IS_ERR (xen_obj))return ERR_CAST (xen_obj);return &xen_obj->base;
@@ -194,7 +194,7 @@ xen_drm_front_gem_import_sg_table(struct size = attach->dmabuf->size; xen_obj =gem_create_obj (dev, size); -if (IS_ERR_OR_NULL (xen_obj)) +if (IS_ERR (xen_obj))return ERR_CAST (xen_obj); ret =gem_alloc_pages_array (xen_obj, size);
drivers/gpu/drm/xen/xen_drm_front_kms.c +1 -1
@@ -60,7 +60,7 @@ fb_create(struct drm_device *dev, structint ret; fb =drm_gem_fb_create_with_funcs (dev, filp, mode_cmd, &fb_funcs); -if (IS_ERR_OR_NULL (fb)) +if (IS_ERR (fb))return fb; gem_obj = fb->obj[0 ];
Greg Kroah-Hartman
maintainerPATCH 385/393 s390/dasd: fix inability to use DASD with DIAG driver
In reply to Greg Kroah-HartmanFrom: Stefan Haberland <[email protected]>
commit 9f4aa52387c68049403b59939df5c0dd8e3872cc upstream.
During initialization of the DASD DIAG driver a request is issued that has a bio structure that resides on the stack. With virtually mapped kernel stacks this bio address might be in virtual storage which is unsuitable for usage with the diag250 call.
In this case the device can not be set online using the DIAG discipline and fails with -EOPNOTSUP.
In the system journal the following error message is presented:
dasd: X.X.XXXX Setting the DASD online with discipline DIAG failed with rc=-95
Fix by allocating the bio structure instead of having it on the stack.
--- drivers/s390/block/dasd_diag.c | 25 +++++++++++++++++-------- 1 file changed, 17 insertions(+), 8 deletions(-)
drivers/s390/block/dasd_diag.c +17 -8
@@ -319,7 +319,7 @@ dasd_diag_check_device(struct dasd_devicstruct dasd_diag_characteristics *rdc_data;struct vtoc_cms_label *label;struct dasd_block *block; -struct dasd_diag_bio bio; +struct dasd_diag_bio *bio;unsigned int sb, bsize;blocknum_t end_block;int rc;
@@ -395,29 +395,36 @@ dasd_diag_check_device(struct dasd_devic rc = -ENOMEM ; goto out; } + bio =kzalloc (sizeof (*bio),GFP_KERNEL ); +if (bio ==NULL ) { +DBF_DEV_EVENT (DBF_WARNING , device,"%s" , +"No memory to allocate initialization bio" ); + rc = -ENOMEM ; + goto out_label; + } rc =0 ; end_block =0 ;/* try all sizes - needed for ECKD devices */ for (bsize =512 ; bsize <=PAGE_SIZE ; bsize <<=1 ) {mdsk_init_io (device, bsize,0 , &end_block); -memset (&bio,0 ,sizeof (struct dasd_diag_bio )); - bio.type =MDSK_READ_REQ ; - bio.block_number = private->pt_block +1 ; - bio.buffer = label; +memset (bio,0 ,sizeof (*bio)); + bio->type =MDSK_READ_REQ ; + bio->block_number = private->pt_block +1 ; + bio->buffer = label;memset (&private->iob,0 ,sizeof (struct dasd_diag_rw_io )); private->iob.dev_nr = rdc_data->dev_nr; private->iob.key =0 ; private->iob.flags =0 ;/* do synchronous io */ private->iob.block_count =1 ; private->iob.interrupt_params =0 ; - private->iob.bio_list = &bio; + private->iob.bio_list = bio; private->iob.flaga =DASD_DIAG_FLAGA_DEFAULT ; rc =dia250 (&private->iob,RW_BIO );if (rc ==3 ) {pr_warn ("%s: A 64-bit DIAG call failed\n" ,dev_name (&device->cdev->dev)); rc = -EOPNOTSUPP ; - goto out_label; + goto out_bio; }mdsk_term_io (device);if (rc ==0 )
@@ -427,7 +434,7 @@ dasd_diag_check_device(struct dasd_devicpr_warn ("%s: Accessing the DASD failed because of an incorrect format (rc=%d)\n" ,dev_name (&device->cdev->dev), rc); rc = -EIO ; - goto out_label; + goto out_bio; }/* check for label block */ if (memcmp(label->label_id, DASD_DIAG_CMS1,
@@ -457,6 +464,8 @@ dasd_diag_check_device(struct dasd_devic (rc == 4) ? ", read-only device" : ""); rc =0 ; } +out_bio: +kfree (bio); out_label:free_page ((long ) label); out:
Greg Kroah-Hartman
maintainerPATCH 386/393 s390/numa: set node distance to LOCAL_DISTANCE
In reply to Greg Kroah-HartmanFrom: Alexander Gordeev <[email protected]>
commit 535e4fc623fab2e09a0653fc3a3e17f382ad0251 upstream.
The node distance is hardcoded to 0, which causes a trouble for some user-level applications. In particular, "libnuma" expects the distance of a node to itself as LOCAL_DISTANCE. This update removes the offending node distance override.
--- arch/s390/include/asm/topology.h | 6 ------ 1 file changed, 6 deletions(-)
arch/s390/include/asm/topology.h +0 -6
@@ -86,12 +86,6 @@ static inline const struct cpumask *cpum#define pcibus_to_node (bus) __pcibus_to_node(bus) -#define node_distance (a, b) __node_distance(a, b) -static inline int __node_distance (int a,int b) -{ -return 0 ; -} -#else /* !CONFIG_NUMA */ #define numa_node_id numa_node_id
Greg Kroah-Hartman
maintainerPATCH 387/393 s390/gmap: improve THP splitting
In reply to Greg Kroah-HartmanFrom: Gerald Schaefer <[email protected]>
commit ba925fa35057a062ac98c3e8138b013ce4ce351c upstream.
During s390_enable_sie(), we need to take care of splitting all qemu user process THP mappings. This is currently done with follow_page(FOLL_SPLIT), by simply iterating over all vma ranges, with PAGE_SIZE increment.
This logic is sub-optimal and can result in a lot of unnecessary overhead, especially when using qemu and ASAN with large shadow map. Ilya reported significant system slow-down with one CPU busy for a long time and overall unresponsiveness.
Fix this by using walk_page_vma() and directly calling split_huge_pmd() only for present pmds, which greatly reduces overhead.
--- arch/s390/mm/gmap.c | 27 ++++++++++++++++++++------- 1 file changed, 20 insertions(+), 7 deletions(-)
arch/s390/mm/gmap.c +20 -7
@@ -2485,23 +2485,36 @@ void gmap_sync_dirty_log_pmd(struct gmap }EXPORT_SYMBOL_GPL (gmap_sync_dirty_log_pmd); +#ifdef CONFIG_TRANSPARENT_HUGEPAGE +static int thp_split_walk_pmd_entry (pmd_t *pmd,unsigned long addr, +unsigned long end,struct mm_walk *walk) +{ +struct vm_area_struct *vma = walk->vma; + +split_huge_pmd (vma, pmd, addr); +return 0 ; +} + +static const struct mm_walk_ops thp_split_walk_ops = { + .pmd_entry = thp_split_walk_pmd_entry, +}; +static inline void thp_split_mm (struct mm_struct *mm) { -#ifdef CONFIG_TRANSPARENT_HUGEPAGE struct vm_area_struct *vma; -unsigned long addr;for (vma = mm->mmap; vma !=NULL ; vma = vma->vm_next) { -for (addr = vma->vm_start; - addr < vma->vm_end; - addr +=PAGE_SIZE ) -follow_page (vma, addr,FOLL_SPLIT ); vma->vm_flags &= ~VM_HUGEPAGE ; vma->vm_flags |=VM_NOHUGEPAGE ; +walk_page_vma (vma, &thp_split_walk_ops,NULL ); } mm->def_flags |=VM_NOHUGEPAGE ; -#endif } +#else +static inline void thp_split_mm (struct mm_struct *mm) +{ +} +#endif /* CONFIG_TRANSPARENT_HUGEPAGE */ /* * Remove all empty zero pages from the mapping for lazy refaulting
Greg Kroah-Hartman
maintainerPATCH 388/393 io_uring: sanitize double poll handling
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
commit d4e7cd36a90e38e0276d6ce0c20f5ccef17ec38c upstream.
There's a bit of confusion on the matching pairs of poll vs double poll, depending on if the request is a pure poll (IORING_OP_POLL_ADD) or poll driven retry.
Add io_poll_get_double() that returns the double poll waitqueue, if any, and io_poll_get_single() that returns the original poll waitqueue. With that, remove the argument to io_poll_remove_double().
Finally ensure that wait->private is cleared once the double poll handler has run, so that remove knows it's already been seen.
--- fs/io_uring.c | 32 ++++++++++++++++++++++++-------- 1 file changed, 24 insertions(+), 8 deletions(-)
fs/io_uring.c +24 -8
@@ -4233,9 +4233,24 @@ static bool io_poll_rewait(struct io_kioreturn false; } -static void io_poll_remove_double (struct io_kiocb *req,void *data) +static struct io_poll_iocb *io_poll_get_double (struct io_kiocb *req) { -struct io_poll_iocb *poll = data; +/* pure poll stashes this in ->io, poll driven retry elsewhere */ +if (req->opcode ==IORING_OP_POLL_ADD ) +return (struct io_poll_iocb *) req->io; +return req->apoll->double_poll; +} + +static struct io_poll_iocb *io_poll_get_single (struct io_kiocb *req) +{ +if (req->opcode ==IORING_OP_POLL_ADD ) +return &req->poll; +return &req->apoll->poll; +} + +static void io_poll_remove_double (struct io_kiocb *req) +{ +struct io_poll_iocb *poll =io_poll_get_double (req);lockdep_assert_held (&req->ctx->completion_lock);
@@ -4255,7 +4270,7 @@ static void io_poll_complete(struct io_k {struct io_ring_ctx *ctx = req->ctx; -io_poll_remove_double (req, req->io); +io_poll_remove_double (req); req->poll.done = true;io_cqring_fill_event (req, error ? error :mangle_poll (mask));io_commit_cqring (ctx);
@@ -4297,7 +4312,7 @@ static int io_poll_double_wake(struct wa int sync, void *key) { struct io_kiocb *req = wait->private; -struct io_poll_iocb *poll = req->apoll->double_poll; +struct io_poll_iocb *poll =io_poll_get_single (req);__poll_t mask =key_to_poll (key);/* for instances that support it check for an event match first: */
@@ -4311,6 +4326,8 @@ static int io_poll_double_wake(struct wa done =list_empty (&poll->wait.entry);if (!done)list_del_init (&poll->wait.entry); +/* make sure double remove sees this as being gone */ + wait->private =NULL ;spin_unlock (&poll->head->lock);if (!done)__io_async_wake (req, poll, mask, io_poll_task_func);
@@ -4545,7 +4562,7 @@ static bool io_arm_poll_handler(struct i ret =__io_arm_poll_handler (req, &apoll->poll, &ipt, mask, io_async_wake);if (ret || ipt.error) { -io_poll_remove_double (req, apoll->double_poll); +io_poll_remove_double (req);spin_unlock_irq (&ctx->completion_lock);memcpy (&req->work, &apoll->work,sizeof (req->work));kfree (apoll->double_poll);
@@ -4578,14 +4595,13 @@ static bool io_poll_remove_one(struct io {bool do_complete; +io_poll_remove_double (req); +if (req->opcode ==IORING_OP_POLL_ADD ) { -io_poll_remove_double (req, req->io); do_complete =__io_poll_remove_one (req, &req->poll); }else {struct async_poll *apoll = req->apoll; -io_poll_remove_double (req, apoll->double_poll); -/* non-poll requests have submit ref still */ do_complete =__io_poll_remove_one (req, &apoll->poll);if (do_complete) {
Greg Kroah-Hartman
maintainerPATCH 389/393 io_uring: Fix NULL pointer dereference in loop_rw_iter()
In reply to Greg Kroah-HartmanFrom: Guoyu Huang <[email protected]>
commit 2dd2111d0d383df104b144e0d1f6b5a00cb7cd88 upstream.
loop_rw_iter() does not check whether the file has a read or write function. This can lead to NULL pointer dereference when the user passes in a file descriptor that does not have read or write function.
The crash log looks like this:
[ 99.834071] BUG: kernel NULL pointer dereference, address: 0000000000000000 [ 99.835364] #PF: supervisor instruction fetch in kernel mode [ 99.836522] #PF: error_code(0x0010) - not-present page [ 99.837771] PGD 8000000079d62067 P4D 8000000079d62067 PUD 79d8c067 PMD 0 [ 99.839649] Oops: 0010 [#2] SMP PTI [ 99.840591] CPU: 1 PID: 333 Comm: io_wqe_worker-0 Tainted: G D 5.8.0 #2 [ 99.842622] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.13.0-1ubuntu1 04/01/2014 [ 99.845140] RIP: 0010:0x0 [ 99.845840] Code: Bad RIP value. [ 99.846672] RSP: 0018:ffffa1c7c01ebc08 EFLAGS: 00010202 [ 99.848018] RAX: 0000000000000000 RBX: ffff92363bd67300 RCX: ffff92363d461208 [ 99.849854] RDX: 0000000000000010 RSI: 00007ffdbf696bb0 RDI: ffff92363bd67300 [ 99.851743] RBP: ffffa1c7c01ebc40 R08: 0000000000000000 R09: 0000000000000000 [ 99.853394] R10: ffffffff9ec692a0 R11: 0000000000000000 R12: 0000000000000010 [ 99.855148] R13: 0000000000000000 R14: ffff92363d461208 R15: ffffa1c7c01ebc68 [ 99.856914] FS: 0000000000000000(0000) GS:ffff92363dd00000(0000) knlGS:0000000000000000 [ 99.858651] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 99.860032] CR2: ffffffffffffffd6 CR3: 000000007ac66000 CR4: 00000000000006e0 [ 99.861979] Call Trace: [ 99.862617] loop_rw_iter.part.0+0xad/0x110 [ 99.863838] io_write+0x2ae/0x380 [ 99.864644] ? kvm_sched_clock_read+0x11/0x20 [ 99.865595] ? sched_clock+0x9/0x10 [ 99.866453] ? sched_clock_cpu+0x11/0xb0 [ 99.867326] ? newidle_balance+0x1d4/0x3c0 [ 99.868283] io_issue_sqe+0xd8f/0x1340 [ 99.869216] ? __switch_to+0x7f/0x450 [ 99.870280] ? __switch_to_asm+0x42/0x70 [ 99.871254] ? __switch_to_asm+0x36/0x70 [ 99.872133] ? lock_timer_base+0x72/0xa0 [ 99.873155] ? switch_mm_irqs_off+0x1bf/0x420 [ 99.874152] io_wq_submit_work+0x64/0x180 [ 99.875192] ? kthread_use_mm+0x71/0x100 [ 99.876132] io_worker_handle_work+0x267/0x440 [ 99.877233] io_wqe_worker+0x297/0x350 [ 99.878145] kthread+0x112/0x150 [ 99.878849] ? __io_worker_unuse+0x100/0x100 [ 99.879935] ? kthread_park+0x90/0x90 [ 99.880874] ret_from_fork+0x22/0x30 [ 99.881679] Modules linked in: [ 99.882493] CR2: 0000000000000000 [ 99.883324] ---[ end trace 4453745f4673190b ]--- [ 99.884289] RIP: 0010:0x0 [ 99.884837] Code: Bad RIP value. [ 99.885492] RSP: 0018:ffffa1c7c01ebc08 EFLAGS: 00010202 [ 99.886851] RAX: 0000000000000000 RBX: ffff92363acd7f00 RCX: ffff92363d461608 [ 99.888561] RDX: 0000000000000010 RSI: 00007ffe040d9e10 RDI: ffff92363acd7f00 [ 99.890203] RBP: ffffa1c7c01ebc40 R08: 0000000000000000 R09: 0000000000000000 [ 99.891907] R10: ffffffff9ec692a0 R11: 0000000000000000 R12: 0000000000000010 [ 99.894106] R13: 0000000000000000 R14: ffff92363d461608 R15: ffffa1c7c01ebc68 [ 99.896079] FS: 0000000000000000(0000) GS:ffff92363dd00000(0000) knlGS:0000000000000000 [ 99.898017] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 99.899197] CR2: ffffffffffffffd6 CR3: 000000007ac66000 CR4: 00000000000006e0
--- fs/io_uring.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
fs/io_uring.c +6 -2
@@ -2614,8 +2614,10 @@ static int io_read(struct io_kiocb *req,if (req->file->f_op->read_iter) ret2 =call_read_iter (req->file, kiocb, &iter); -else +else if (req->file->f_op->read) ret2 =loop_rw_iter (READ , req->file, kiocb, &iter); +else + ret2 = -EINVAL ;/* Catch -EAGAIN return for forced non-blocking submission */ if (!force_nonblock || ret2 != -EAGAIN ) {
@@ -2729,8 +2731,10 @@ static int io_write(struct io_kiocb *reqif (req->file->f_op->write_iter) ret2 =call_write_iter (req->file, kiocb, &iter); -else +else if (req->file->f_op->write) ret2 =loop_rw_iter (WRITE , req->file, kiocb, &iter); +else + ret2 = -EINVAL ;if (!force_nonblock) current->signal->rlim[RLIMIT_FSIZE ].rlim_cur =RLIM_INFINITY ;
Greg Kroah-Hartman
maintainerPATCH 390/393 task_work: only grab task signal lock when needed
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
commit ebf0d100df0731901c16632f78d78d35f4123bc4 upstream.
If JOBCTL_TASK_WORK is already set on the targeted task, then we need not go through {lock,unlock}_task_sighand() to set it again and queue a signal wakeup. This is safe as we're checking it _after_ adding the new task_work with cmpxchg().
The ordering is as follows:
task_work_add() get_signal()
--------------------------------------------------------------STORE(task->task_works, new_work); STORE(task->jobctl);mb(); mb();LOAD(task->jobctl); LOAD(task->task_works);
This speeds up TWA_SIGNAL handling quite a bit, which is important now that io_uring is relying on it for all task_work deliveries.
--- kernel/signal.c | 16 +++++++++++++++- kernel/task_work.c | 8 +++++++- 2 files changed, 22 insertions(+), 2 deletions(-)
kernel/signal.c +15 -1
@@ -2541,7 +2541,21 @@ bool get_signal(struct ksignal *ksig) relock:spin_lock_irq (&sighand->siglock); - current->jobctl &= ~JOBCTL_TASK_WORK ; +/* +* Make sure we can safely read ->jobctl() in task_work add. As Oleg +* states: +* +* It pairs with mb (implied by cmpxchg) before READ_ONCE. So we +* roughly have +* +* task_work_add: get_signal: +* STORE(task->task_works, new_work); STORE(task->jobctl); +* mb(); mb(); +* LOAD(task->jobctl); LOAD(task->task_works); +* +* and we can rely on STORE-MB-LOAD [ in task_work_add]. +*/ +smp_store_mb (current->jobctl, current->jobctl & ~JOBCTL_TASK_WORK );if (unlikely (current->task_works)) {spin_unlock_irq (&sighand->siglock);task_work_run ();
kernel/task_work.c +7 -1
@@ -42,7 +42,13 @@ task_work_add(struct task_struct *task,set_notify_resume (task);break ;case TWA_SIGNAL : -if (lock_task_sighand (task, &flags)) { +/* +* Only grab the sighand lock if we don't already have some +* task_work pending. This pairs with the smp_store_mb() +* in get_signal(), see comment there. +*/ +if (!(READ_ONCE (task->jobctl) &JOBCTL_TASK_WORK ) && +lock_task_sighand (task, &flags)) { task->jobctl |=JOBCTL_TASK_WORK ;signal_wake_up (task,0 );unlock_task_sighand (task, &flags);
Greg Kroah-Hartman
maintainerPATCH 391/393 io_uring: add missing REQ_F_COMP_LOCKED for nested requests
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
commit 9b7adba9eaec28e0e4343c96d0dbeb9578802f5f upstream.
When we traverse into failing links or timeouts, we need to ensure we propagate the REQ_F_COMP_LOCKED flag to ensure that we correctly signal to the completion side that we already hold the completion lock.
--- fs/io_uring.c | 24 +++++++++++++++++++----- 1 file changed, 19 insertions(+), 5 deletions(-)
fs/io_uring.c +19 -5
@@ -1484,12 +1484,9 @@ static void io_req_link_next(struct io_k/* * Called if REQ_F_LINK_HEAD is set, and we fail the head request */ -static void io_fail_links (struct io_kiocb *req) +static void __io_fail_links (struct io_kiocb *req) {struct io_ring_ctx *ctx = req->ctx; -unsigned long flags; - -spin_lock_irqsave (&ctx->completion_lock, flags);while (!list_empty (&req->link_list)) { struct io_kiocb *link = list_first_entry(&req->link_list,
@@ -1503,13 +1500,29 @@ static void io_fail_links(struct io_kiocio_link_cancel_timeout (link); }else {io_cqring_fill_event (link, -ECANCELED ); + link->flags |=REQ_F_COMP_LOCKED ;__io_double_put_req (link); } req->flags &= ~REQ_F_LINK_TIMEOUT ; }io_commit_cqring (ctx); -spin_unlock_irqrestore (&ctx->completion_lock, flags); +} + +static void io_fail_links (struct io_kiocb *req) +{ +struct io_ring_ctx *ctx = req->ctx; + +if (!(req->flags &REQ_F_COMP_LOCKED )) { +unsigned long flags; + +spin_lock_irqsave (&ctx->completion_lock, flags); +__io_fail_links (req); +spin_unlock_irqrestore (&ctx->completion_lock, flags); + }else { +__io_fail_links (req); + } +io_cqring_ev_posted (ctx); }
@@ -4828,6 +4841,7 @@ static int io_timeout_cancel(struct io_rreturn -EALREADY ;req_set_fail_links (req); + req->flags |=REQ_F_COMP_LOCKED ;io_cqring_fill_event (req, -ECANCELED );io_put_req (req);return 0 ;
Greg Kroah-Hartman
maintainerPATCH 392/393 io_uring: enable lookup of links holding inflight files
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
commit f254ac04c8744cf7bfed012717eac34eacc65dfb upstream.
When a process exits, we cancel whatever requests it has pending that are referencing the file table. However, if a link is holding a reference, then we cannot find it by simply looking at the inflight list.
Enable checking of the poll and timeout list to find the link, and cancel it appropriately.
--- fs/io_uring.c | 97 ++++++++++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 87 insertions(+), 10 deletions(-)
fs/io_uring.c +87 -10
@@ -4638,6 +4638,7 @@ static bool io_poll_remove_one(struct ioio_cqring_fill_event (req, -ECANCELED );io_commit_cqring (req->ctx); req->flags |=REQ_F_COMP_LOCKED ; +req_set_fail_links (req);io_put_req (req); }
@@ -4820,6 +4821,23 @@ static enum hrtimer_restart io_timeout_freturn HRTIMER_NORESTART ; } +static int __io_timeout_cancel (struct io_kiocb *req) +{ +int ret; + +list_del_init (&req->list); + + ret =hrtimer_try_to_cancel (&req->io->timeout.timer); +if (ret ==-1 ) +return -EALREADY ; + +req_set_fail_links (req); + req->flags |=REQ_F_COMP_LOCKED ; +io_cqring_fill_event (req, -ECANCELED ); +io_put_req (req); +return 0 ; +} +static int io_timeout_cancel (struct io_ring_ctx *ctx,__u64 user_data) {struct io_kiocb *req;
@@ -4827,7 +4845,6 @@ static int io_timeout_cancel(struct io_rlist_for_each_entry (req, &ctx->timeout_list, list) {if (user_data == req->user_data) { -list_del_init (&req->list); ret =0 ;break ; }
@@ -4836,15 +4853,7 @@ static int io_timeout_cancel(struct io_rif (ret == -ENOENT )return ret; - ret =hrtimer_try_to_cancel (&req->io->timeout.timer); -if (ret ==-1 ) -return -EALREADY ; - -req_set_fail_links (req); - req->flags |=REQ_F_COMP_LOCKED ; -io_cqring_fill_event (req, -ECANCELED ); -io_put_req (req); -return 0 ; +return __io_timeout_cancel (req); } static int io_timeout_remove_prep(struct io_kiocb *req,
@@ -7579,6 +7588,71 @@ static int io_uring_release(struct inodereturn 0 ; } +/* +* Returns true if 'preq' is the link parent of 'req' +*/ +static bool io_match_link (struct io_kiocb *preq,struct io_kiocb *req) +{ +struct io_kiocb *link; + +if (!(preq->flags &REQ_F_LINK_HEAD )) +return false; + +list_for_each_entry (link, &preq->link_list, link_list) { +if (link == req) +return true; + } + +return false; +} + +/* +* We're looking to cancel 'req' because it's holding on to our files, but +* 'req' could be a link to another request. See if it is, and cancel that +* parent request if so. +*/ +static bool io_poll_remove_link (struct io_ring_ctx *ctx,struct io_kiocb *req) +{ +struct hlist_node *tmp; +struct io_kiocb *preq; +bool found = false; +int i; + +spin_lock_irq (&ctx->completion_lock); +for (i =0 ; i < (1U << ctx->cancel_hash_bits); i++) { +struct hlist_head *list; + + list = &ctx->cancel_hash[i]; +hlist_for_each_entry_safe (preq, tmp, list, hash_node) { + found =io_match_link (preq, req); +if (found) { +io_poll_remove_one (preq); +break ; + } + } + } +spin_unlock_irq (&ctx->completion_lock); +return found; +} + +static bool io_timeout_remove_link (struct io_ring_ctx *ctx, +struct io_kiocb *req) +{ +struct io_kiocb *preq; +bool found = false; + +spin_lock_irq (&ctx->completion_lock); +list_for_each_entry (preq, &ctx->timeout_list, list) { + found =io_match_link (preq, req); +if (found) { +__io_timeout_cancel (preq); +break ; + } + } +spin_unlock_irq (&ctx->completion_lock); +return found; +} +static void io_uring_cancel_files (struct io_ring_ctx *ctx,struct files_struct *files) {
@@ -7629,6 +7703,9 @@ static void io_uring_cancel_files(struct } }else {io_wq_cancel_work (ctx->io_wq, &cancel_req->work); +/* could be a link, check and remove if it is */ +if (!io_poll_remove_link (ctx, cancel_req)) +io_timeout_remove_link (ctx, cancel_req);io_put_req (cancel_req); }
Greg Kroah-Hartman
maintainerPATCH 393/393 io_uring: hold ctx reference around task_work queue + execute
In reply to Greg Kroah-HartmanFrom: Jens Axboe <[email protected]>
commit 6d816e088c359866f9867057e04f244c608c42fe upstream.
We're holding the request reference, but we need to go one higher to ensure that the ctx remains valid after the request has finished. If the ring is closed with pending task_work inflight, and the given io_kiocb finishes sync during issue, then we need a reference to the ring itself around the task_work execution cycle.
--- fs/io_uring.c | 6 ++++++ 1 file changed, 6 insertions(+)
fs/io_uring.c +6 -0
@@ -4214,6 +4214,8 @@ static int __io_async_wake(struct io_kio tsk = req->task; req->result = mask;init_task_work (&req->task_work, func); +percpu_ref_get (&req->ctx->refs); +/* * If this fails, then the task is exiting. When a task exits, the * work gets canceled, so just cancel this request as well instead
@@ -4313,6 +4315,7 @@ static void io_poll_task_handler(structstatic void io_poll_task_func (struct callback_head *cb) { struct io_kiocb *req = container_of(cb, struct io_kiocb, task_work); +struct io_ring_ctx *ctx = req->ctx;struct io_kiocb *nxt =NULL ;io_poll_task_handler (req, &nxt);
@@ -4323,6 +4326,7 @@ static void io_poll_task_func(struct cal__io_queue_sqe (nxt,NULL );mutex_unlock (&ctx->uring_lock); } +percpu_ref_put (&ctx->refs); } static int io_poll_double_wake(struct wait_queue_entry *wait, unsigned mode,
@@ -4439,6 +4443,7 @@ static void io_async_task_func(struct caif (io_poll_rewait (req, &apoll->poll)) {spin_unlock_irq (&ctx->completion_lock); +percpu_ref_put (&ctx->refs);return ; }
@@ -4476,6 +4481,7 @@ end_req:kfree (apoll->double_poll);kfree (apoll); +percpu_ref_put (&ctx->refs); } static int io_async_wake(struct wait_queue_entry *wait, unsigned mode, int sync,
Jon Hunter
maintainerQuoted 9 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.7.16 release. There are 393 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Wed, 19 Aug 2020 14:36:49 +0000. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
Quoted 8 lines
https://www.kernel.org/pub/linux/kernel/v5.x/stable-review/patch-5.7.16-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-5.7.y
and the diffstat can be found below.thanks,
greg k-h
All tests passing for Tegra ...
Test results for stable-v5.7:
11 builds: 11 pass, 0 fail
26 boots: 26 pass, 0 fail
56 tests: 56 pass, 0 failLinux version: 5.7.16-rc1-g833b53db2607
Boards tested: tegra124-jetson-tk1, tegra186-p2771-0000,
tegra194-p2972-0000, tegra20-ventana,
tegra210-p2371-2180, tegra210-p3450-0000,
tegra30-cardhu-a04Jon
Quoted 10 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.7.16 release. There are 393 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Wed, 19 Aug 2020 14:36:49 +0000. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
Quoted 8 lines
https://www.kernel.org/pub/linux/kernel/v5.x/stable-review/patch-5.7.16-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-5.7.y
and the diffstat can be found below.thanks,
greg k-h
Results from Linaro’s test farm.
No regressions on arm64, arm, x86_64, and i386.
Summary
------------------------------------------------------------------------
kernel: 5.7.16-rc1
git repo: https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.git
git branch: linux-5.7.y
git commit: 833b53db2607bc32cd4574e9cf2ddf924310a571
git describe: v5.7.15-394-g833b53db2607
Test details: https://qa-reports.linaro.org/lkft/linux-stable-rc-5.7-oe/build/v5.7.15-394-g833b53db2607
No regressions (compared to build v5.7.15)
No fixes (compared to build v5.7.15)
Ran 32256 total tests in the following environments and test suites.
Environments
--------------
- dragonboard-410c
- hi6220-hikey
- i386
- juno-r2
- juno-r2-compat
- juno-r2-kasan
- nxp-ls2088
- qemu_arm
- qemu_arm64
- qemu_i386
- qemu_x86_64
- x15
- x86
- x86-kasan
Test Suites
-----------
* build
* igt-gpu-tools
* install-android-platform-tools-r2600
* kselftest
* kselftest/drivers
* kselftest/filesystems
* kselftest/net
* libhugetlbfs
* linux-log-parser
* ltp-commands-tests
* ltp-containers-tests
* ltp-cve-tests
* ltp-dio-tests
* ltp-fcntl-locktests-tests
* ltp-filecaps-tests
* ltp-fs_bind-tests
* ltp-fs_perms_simple-tests
* ltp-fsx-tests
* ltp-hugetlb-tests
* ltp-io-tests
* ltp-ipc-tests
* ltp-math-tests
* ltp-mm-tests
* ltp-nptl-tests
* ltp-pty-tests
* ltp-securebits-tests
* ltp-syscalls-tests
* ltp-tracing-tests
* perf
* v4l2-compliance
* ltp-controllers-tests
* ltp-sched-tests
* network-basic-tests
* ltp-cap_bounds-tests
* ltp-cpuhotplug-tests
* ltp-crypto-tests
* ltp-fs-tests
* ltp-open-posix-tests
* kselftest-vsyscall-mode-native
* kselftest-vsyscall-mode-native/drivers
* kselftest-vsyscall-mode-native/filesystems
* kselftest-vsyscall-mode-native/net
* kselftest-vsyscall-mode-none
* kselftest-vsyscall-mode-none/drivers
* kselftest-vsyscall-mode-none/filesystems
* kselftest-vsyscall-mode-none/net
* ssuite
Signature · 2 lines
Linaro LKFT https://lkft.linaro.org
Quoted 8 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.7.16 release. There are 393 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Wed, 19 Aug 2020 14:36:49 +0000. Anything received after that time might be too late.
Build results:
total: 158 pass: 158 fail: 0 Qemu test results: total: 431 pass: 431 fail: 0
Guenter
Quoted 9 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 5.7.16 release. There are 393 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Wed, 19 Aug 2020 14:36:49 +0000. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
Quoted 9 lines
https://www.kernel.org/pub/linux/kernel/v5.x/stable-review/patch-5.7.16-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-5.7.y
and the diffstat can be found below.thanks,
greg k-h
Compiled and booted on my test system. No dmesg regressions.
thanks,
-- Shuah