6.18.47-rc1 review
Subsystems (2)
Greg Kroah-Hartman
maintainercover 6.18.47-rc1 review
This is the start of the stable review cycle for the 6.18.47 release. There are 94 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 Thu, 27 Aug 2026 13:25:02 +0000. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
https://www.kernel.org/pub/linux/kernel/v6.x/stable-review/patch-6.18.47-rc1.gz
or in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.git linux-6.18.y
and the diffstat can be found below.
thanks,
greg k-h
-------------
Pseudo-Shortlog of commits:
Greg Kroah-Hartman <[email protected]>
Linux 6.18.47-rc1
Laxman Acharya Padhya <[email protected]>
Bluetooth: hci_aml: validate firmware segment lengths
Ali Ahmet Memis <[email protected]>
Bluetooth: MGMT: reject HCI_CMD_SYNC params_len above 255
Ali Ahmet Memis <[email protected]>
Bluetooth: ISO: zero the sockaddr before returning it in getname
Ali Ahmet Memis <[email protected]>
Bluetooth: ISO: do not force BT_LISTEN after a failed BIG sync
Chengfeng Ye <[email protected]>
Bluetooth: hci_sync: Fix accept list UAF during suspend
Laxman Acharya Padhya <[email protected]>
Bluetooth: hci_event: validate LE Set CIG Parameters response
Chengfeng Ye <[email protected]>
Bluetooth: hci_event: fix LE list UAF on reset
Linus Torvalds <[email protected]>
drm/xe: Don't hand out the flat CCS storage as usable VRAM
Michael Bommarito <[email protected]>
HID: hyperv: validate initial device info bounds
Ibrahim Hashimov <[email protected]>
HID: uclogic: fix use-after-free of inrange_timer on remove
Haoxiang Li <[email protected]>
HID: sensor: custom: Fix use-after-free in enable_sensor
Jann Horn <[email protected]>
HID: core: fix number/pointer type confusion on long items
Jiangshan Yi <[email protected]>
HID: nintendo: stop device IO before hid_hw_stop on probe failure
Jiangshan Yi <[email protected]>
HID: nintendo: register input device after capabilities are set
Ibrahim Hashimov <[email protected]>
HID: nintendo: fix out-of-bounds read in joycon_ctlr_read_handler()
Peter Zijlstra <[email protected]>
futex: Fix might_sleep() warning in futex_pivot_pending()
Hyunwoo Kim <[email protected]>
futex: Fix race on the initial mm->futex.phash.ref allocation
Thomas Gleixner <[email protected]>
futex/pi: Plug private futex exec() race
Thomas Gleixner <[email protected]>
futex: Sanitize and document task_struct::futex::state transitions
Kyle Zeng <[email protected]>
futex/pi: Reject cross-mm private futex owners
Donglin Lyu <[email protected]>
Input: atkbd - skip deactivate for HONOR ZQC-P
Cryolitia PukNgae <[email protected]>
Input: atkbd - skip deactivate for HONOR FMB-P's internal keyboard
Xiang Mei (Microsoft) <[email protected]>
xfrm: fix sk_dst_cache double-free in xfrm_user_policy()
Anand Khoje <[email protected]>
net/ionic: avoid OOB TX partner lookup for hwstamp RXQ
Baul Lee <[email protected]>
HID: pidff: fix OOB write when hid->inputs is empty
Baul Lee <[email protected]>
HID: core: fix OOB read of field->usage in hid_set_field()
Lee Jones <[email protected]>
HID: magicmouse: Prevent out-of-bounds (OOB) read during DOUBLE_REPORT_ID
Jose Villaseñor Montfort <[email protected]>
HID: magicmouse: do not keep a stale msc->input if no input is claimed
Christopher Kodama <[email protected]>
HID: magicmouse: re-enable multitouch after reset-resume
Andrei Fed <[email protected]>
HID: magicmouse: fix battery reporting for Bluetooth Magic Trackpad USB-C
Dawid Wróbel <[email protected]>
ASoC: codecs: lpass-tx-macro: Fix enum kcontrol accesses
Bryam Vargas <[email protected]>
selinux: require a class's permission values to cover its permission count
Christian Göttsche <[email protected]>
selinux: more strict policy parsing
Christian Göttsche <[email protected]>
selinux: use u16 for security classes
Shardul Bankar <[email protected]>
mptcp: pm: fix memory leak from alloc-during-teardown race
Matthieu Baerts (NGI0) <[email protected]>
mptcp: pm: uniform announced addresses helpers
Matthieu Baerts (NGI0) <[email protected]>
mptcp: pm: rename add_entry structure to add_addr
Matthieu Baerts (NGI0) <[email protected]>
mptcp: pm: use for_each_subflow helper
Yifei Gao <[email protected]>
nvmet: pci-epf: put CQ ref on create_cq mapping failure
Shin'ichiro Kawasaki <[email protected]>
nvmet: pci-epf: fix use-after-free in nvmet_pci_epf_exec_iod_work()
Greg Kroah-Hartman <[email protected]>
nvmet-tcp: Do not WARN on remotely-controlled oversized SGL allocations
Ibrahim Hashimov <[email protected]>
nvmet-tcp: bound SGL data length before allocating command buffers
Jiang HongHui <[email protected]>
nvmet-fc: fix invalid free in LS IOD error path
Bryam Vargas <[email protected]>
nvmet-auth: zero the AUTH_RECEIVE response buffer
Griffin Kroah-Hartman <[email protected]>
dmaengine: fsl-edma: Add error handling for devm_kasprintf
Griffin Kroah-Hartman <[email protected]>
mailbox: mchp-ipc-sbi: Add null check for devm_kasprintf()
Luxiao Xu <[email protected]>
ipv6: fix use-after-free in ip6_finish_output2()
Yong Wang <[email protected]>
ipv4: reject undersized MTUs in ip_do_fragment()
Maarten Lankhorst <[email protected]>
drm/xe: Fix DPT allocation paths.
Linmao Li <[email protected]>
nfc: nci: free destination parameters when closing a connection
Samuel Page <[email protected]>
nfc: nci: fix uninit-value in the RF discover/activated NTF handlers
Samuel Page <[email protected]>
nfc: nci: fix out-of-bounds write in nci_target_auto_activated()
Bryam Vargas <[email protected]>
nfc: nci: add data_len bound checks to activation parameter extractors
Doruk Tan Ozturk <[email protected]>
nfc: st21nfca: validate ATR_REQ length against the received frame
Xu Rao <[email protected]>
nfc: pn533: purge fragmented skbs during cleanup
Doruk Tan Ozturk <[email protected]>
nfc: llcp: reject PDUs shorter than the LLCP header
Muhammad Bilal <[email protected]>
nfc: llcp: fix OOB read and u8 offset wrap in TLV parsers
Doruk Tan Ozturk <[email protected]>
nfc: llcp: bound the connect_sn TLV walk to the skb
Pengpeng Hou <[email protected]>
nfc: microread: validate target discovery payload lengths
Bryam Vargas <[email protected]>
nfc: fdp: bound the device-reported read length and fix an skb leak
Doruk Tan Ozturk <[email protected]>
nfc: digital: clamp SENSF_RES length to the destination buffer
Pavitra Jha <[email protected]>
libceph: fix OOB read in decode_watchers() via missing bounds check
Hongling Zeng <[email protected]>
xfs: validate attr entry pointer before field access
Jiazi Liu <[email protected]>
ext4: fix incorrect function call when initializing s_resgid
Eric Biggers <[email protected]>
ext4: don't enable DAX on new encrypted files
Guanghui Yang <[email protected]>
ext4: propagate errors from fast commit range replay
Jia Zhu <[email protected]>
ext4: avoid tail write_begin walk for uptodate folios
Guanghui Yang <[email protected]>
ext4: clear error before retrying inode xattr space fallback
Ryusuke Konishi <[email protected]>
nilfs2: reject invalid block index in GC ioctl
Matthias Goergens <[email protected]>
ext4: stop retrying saturated xattr cache entries
Tetsuo Handa <[email protected]>
kcov: fix data corruption and race conditions on PREEMPT_RT
Rik van Riel <[email protected]>
null_blk: fix UBSAN shift-out-of-bounds when zone_size is 0 or overflows
Ian Bridges <[email protected]>
ocfs2: fix missing metadata reservation for large xattrs
Jens Axboe <[email protected]>
io_uring/uring_cmd: don't skip completion for a synchronous multishot cmd
Ali Ahmet Memis <[email protected]>
io_uring/rsrc: fix folio size overflow in io_vec_fill_bvec()
Vishnu Razdan <[email protected]>
io_uring/io-wq: fix worker accounting when canceling creation callbacks
Woraphat Khiaodaeng <[email protected]>
io_uring/cmd: fix iovec leak when the async cmd is not recycled
Takashi Iwai <[email protected]>
ALSA: dummy: Check card index validity at probe
Jens Axboe <[email protected]>
io_uring/futex: don't mark futex wake requests as inflight
Guixin Liu <[email protected]>
nvmet: fix NULL pointer dereference in nvmet_execute_identify_nslist()
Griffin Kroah-Hartman <[email protected]>
rndis_host: add overflow check in rndis_rx_fixup()
Geoffrey D. Bennett <[email protected]>
ALSA: scarlett2: Use a private URB for the notification endpoint
Geoffrey D. Bennett <[email protected]>
ALSA: FCP: Use a private URB for the notification endpoint
Peiyang He <[email protected]>
iommu/iommufd: Fix NULL pointer deref in iommufd_ioas_change_process when racing with iopt_map_file_pages
Shameer Kolothum <[email protected]>
iommu/tegra241-cmdqv: Fix CMD_SYNC use-after-free on teardown
Ali Ahmet Memis <[email protected]>
Bluetooth: RFCOMM: take rfcomm_mutex for the deferred setup accept
Steffen Persvold <[email protected]>
PCI: host-generic: Fix NULL pointer dereference on 32-bit CAM systems
Darrick J. Wong <[email protected]>
xfs: don't livelock in scrub on a circular unlinked list
Darrick J. Wong <[email protected]>
xfs: hoist per-bucket unlinked list check to helper
Darrick J. Wong <[email protected]>
xfs: rtsummary scrub should treat rtbitmap corruption errors as an xref error
Christoph Hellwig <[email protected]>
xfs: add a xchk_ip_set_corrupt helper
Luca Fresi <[email protected]>
serial: sc16is7xx: enable THRI before filling TX FIFO
Hugo Villeneuve <[email protected]>
serial: sc16is7xx: use guards for simple mutex locks
Hugo Villeneuve <[email protected]>
serial: sc16is7xx: rename EFR mutex with generic name
-------------
Diffstat:
Makefile | 4 +- drivers/block/null_blk/zoned.c | 10 +- drivers/bluetooth/hci_aml.c | 18 +- drivers/dma/fsl-edma-main.c | 2 + drivers/gpu/drm/xe/display/xe_fb_pin.c | 32 +-- drivers/gpu/drm/xe/xe_vram.c | 23 ++- drivers/hid/hid-core.c | 11 +- drivers/hid/hid-hyperv.c | 27 ++- drivers/hid/hid-input.c | 3 + drivers/hid/hid-magicmouse.c | 64 +++++- drivers/hid/hid-nintendo.c | 22 +- drivers/hid/hid-sensor-custom.c | 21 +- drivers/hid/hid-uclogic-core.c | 12 +- drivers/hid/usbhid/hid-pidff.c | 13 +- drivers/input/keyboard/atkbd.c | 23 ++- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 2 + drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h | 1 + drivers/iommu/arm/arm-smmu-v3/tegra241-cmdqv.c | 15 +- drivers/iommu/iommufd/ioas.c | 4 + drivers/mailbox/mailbox-mchp-ipc-sbi.c | 2 + drivers/net/ethernet/pensando/ionic/ionic_lif.c | 17 +- drivers/net/ethernet/pensando/ionic/ionic_txrx.c | 7 +- drivers/net/usb/rndis_host.c | 6 +- drivers/nfc/fdp/i2c.c | 27 +++ drivers/nfc/microread/microread.c | 31 ++- drivers/nfc/pn533/pn533.c | 1 + drivers/nfc/st21nfca/dep.c | 3 + drivers/nvme/target/admin-cmd.c | 2 +- drivers/nvme/target/fabrics-cmd-auth.c | 2 +- drivers/nvme/target/fc.c | 2 +- drivers/nvme/target/pci-epf.c | 10 +- drivers/nvme/target/tcp.c | 18 +- drivers/pci/controller/pci-host-generic.c | 11 +- drivers/pci/ecam.c | 13 ++ drivers/tty/serial/sc16is7xx.c | 40 ++-- fs/exec.c | 8 +- fs/ext4/crypto.c | 40 ++-- fs/ext4/fast_commit.c | 16 +- fs/ext4/ialloc.c | 4 + fs/ext4/inode.c | 11 +- fs/ext4/super.c | 2 +- fs/ext4/xattr.c | 7 +- fs/nilfs2/ioctl.c | 20 +- fs/ocfs2/xattr.c | 18 +- fs/xfs/libxfs/xfs_attr_leaf.c | 14 ++ fs/xfs/scrub/agheader.c | 94 ++++++--- fs/xfs/scrub/agheader_repair.c | 17 +- fs/xfs/scrub/bmap.c | 8 +- fs/xfs/scrub/common.c | 10 +- fs/xfs/scrub/common.h | 2 + fs/xfs/scrub/dir.c | 2 +- fs/xfs/scrub/dirtree.c | 4 +- fs/xfs/scrub/metapath.c | 6 +- fs/xfs/scrub/nlinks.c | 12 +- fs/xfs/scrub/parent.c | 6 +- fs/xfs/scrub/rtbitmap.c | 12 +- fs/xfs/scrub/rtsummary.c | 12 +- include/linux/futex.h | 2 + include/linux/pci-ecam.h | 3 + include/linux/sched.h | 8 + include/linux/wait.h | 1 + include/linux/wait_bit.h | 1 + io_uring/futex.c | 11 + io_uring/futex.h | 1 + io_uring/io-wq.c | 9 +- io_uring/opdef.c | 2 +- io_uring/rsrc.c | 2 +- io_uring/uring_cmd.c | 8 +- kernel/futex/core.c | 122 +++++++---- kernel/futex/futex.h | 9 + kernel/futex/pi.c | 125 +++++++++--- kernel/kcov.c | 90 ++++---- kernel/sched/wait.c | 15 ++ kernel/sched/wait_bit.c | 14 +- lib/Kconfig.debug | 5 +- net/bluetooth/hci_event.c | 8 +- net/bluetooth/hci_sync.c | 46 ++++- net/bluetooth/iso.c | 32 ++- net/bluetooth/mgmt.c | 8 + net/bluetooth/rfcomm/core.c | 24 ++- net/ceph/osd_client.c | 5 +- net/ipv4/ip_output.c | 4 + net/ipv6/ip6_output.c | 2 + net/mptcp/options.c | 2 +- net/mptcp/pm.c | 74 ++++--- net/mptcp/pm_kernel.c | 22 +- net/mptcp/pm_userspace.c | 10 +- net/mptcp/protocol.h | 25 +-- net/mptcp/subflow.c | 4 +- net/nfc/digital_technology.c | 2 + net/nfc/llcp_commands.c | 18 +- net/nfc/llcp_core.c | 15 +- net/nfc/nci/ntf.c | 36 +++- net/nfc/nci/rsp.c | 1 + net/xfrm/xfrm_state.c | 4 +- security/selinux/include/security.h | 1 + security/selinux/ss/avtab.c | 35 +++- security/selinux/ss/avtab.h | 13 ++ security/selinux/ss/conditional.c | 18 +- security/selinux/ss/constraint.h | 1 + security/selinux/ss/policydb.c | 248 +++++++++++++++++++---- security/selinux/ss/policydb.h | 31 ++- security/selinux/ss/services.c | 8 +- sound/drivers/dummy.c | 6 + sound/soc/codecs/lpass-tx-macro.c | 4 +- sound/usb/fcp.c | 38 ++-- sound/usb/mixer.c | 6 + sound/usb/mixer.h | 2 + sound/usb/mixer_scarlett2.c | 98 +++++---- 109 files changed, 1533 insertions(+), 570 deletions(-)
Greg Kroah-Hartman
maintainerPATCH 1/94 serial: sc16is7xx: rename EFR mutex with generic name
6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Hugo Villeneuve <[email protected]>
[ Upstream commit d9b2d7ddbb973b981c20b21e9228581bb156f66f ]
This mutex is used as a lock when accessing registers that share the same address space, not necessarily EFR registers.
For example, address 0x06 is shared by MSR, TCR and XOFF1 registers, independently of EFR.
Rename the mutex with a more generic name to avoid misinterpreting its usage.
Stable-dep-of: 246ac114f485 ("serial: sc16is7xx: enable THRI before filling TX FIFO")
--- drivers/tty/serial/sc16is7xx.c | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-)
drivers/tty/serial/sc16is7xx.c +13 -13
@@ -328,7 +328,7 @@ struct sc16is7xx_one_config {struct sc16is7xx_one {struct uart_port port;struct regmap *regmap; -struct mutex efr_lock;/* EFR registers access */ +struct mutex lock;/* For registers sharing same address space. */ struct kthread_work tx_work;struct kthread_work reg_work;struct kthread_delayed_work ms_work;
@@ -436,7 +436,7 @@ static void sc16is7xx_efr_lock(struct ua {struct sc16is7xx_one *one =to_sc16is7xx_one (port, port); -mutex_lock (&one->efr_lock); +mutex_lock (&one->lock);/* Backup content of LCR. */ one->old_lcr =sc16is7xx_port_read (port,SC16IS7XX_LCR_REG );
@@ -458,7 +458,7 @@ static void sc16is7xx_efr_unlock(struct/* Restore original content of LCR */ sc16is7xx_port_write (port,SC16IS7XX_LCR_REG , one->old_lcr); -mutex_unlock (&one->efr_lock); +mutex_unlock (&one->lock); }static void sc16is7xx_ier_clear (struct uart_port *port,u8 bit)
@@ -593,7 +593,7 @@ static int sc16is7xx_set_baud(struct uarSC16IS7XX_MCR_CLKSEL_BIT , prescaler == 1 ? 0 : SC16IS7XX_MCR_CLKSEL_BIT); -mutex_lock (&one->efr_lock); +mutex_lock (&one->lock);/* Backup LCR and access special register set (DLL/DLH) */ lcr =sc16is7xx_port_read (port,SC16IS7XX_LCR_REG );
@@ -609,7 +609,7 @@ static int sc16is7xx_set_baud(struct uar/* Restore LCR and access to general register set */ sc16is7xx_port_write (port,SC16IS7XX_LCR_REG , lcr); -mutex_unlock (&one->efr_lock); +mutex_unlock (&one->lock);return DIV_ROUND_CLOSEST ((clk / prescaler) /16 , div); }
@@ -756,7 +756,7 @@ static void sc16is7xx_update_mlines(struunsigned long flags;unsigned int status, changed; -lockdep_assert_held_once (&one->efr_lock); +lockdep_assert_held_once (&one->lock); status =sc16is7xx_get_hwmctrl (port); changed = status ^ one->old_mctrl;
@@ -787,7 +787,7 @@ static bool sc16is7xx_port_irq(struct scstruct uart_port *port = &s->p[portno].port;struct sc16is7xx_one *one =to_sc16is7xx_one (port, port); -mutex_lock (&one->efr_lock); +mutex_lock (&one->lock); iir =sc16is7xx_port_read (port,SC16IS7XX_IIR_REG );if (iir &SC16IS7XX_IIR_NO_INT_BIT ) {
@@ -834,7 +834,7 @@ static bool sc16is7xx_port_irq(struct sc } out_port_irq: -mutex_unlock (&one->efr_lock); +mutex_unlock (&one->lock);return rc; }
@@ -878,9 +878,9 @@ static void sc16is7xx_tx_proc(struct kth (port->rs485.delay_rts_before_send > 0))msleep (port->rs485.delay_rts_before_send); -mutex_lock (&one->efr_lock); +mutex_lock (&one->lock);sc16is7xx_handle_tx (port); -mutex_unlock (&one->efr_lock); +mutex_unlock (&one->lock); }static void sc16is7xx_reconf_rs485 (struct uart_port *port)
@@ -947,9 +947,9 @@ static void sc16is7xx_ms_proc(struct kthstruct sc16is7xx_port *s =dev_get_drvdata (one->port.dev);if (one->port.state) { -mutex_lock (&one->efr_lock); +mutex_lock (&one->lock);sc16is7xx_update_mlines (one); -mutex_unlock (&one->efr_lock); +mutex_unlock (&one->lock);kthread_queue_delayed_work (&s->kworker, &one->ms_work,HZ ); }
@@ -1635,7 +1635,7 @@ int sc16is7xx_probe(struct device *dev, s->p[i].old_mctrl =0 ; s->p[i].regmap = regmaps[i]; -mutex_init (&s->p[i].efr_lock); +mutex_init (&s->p[i].lock); ret =uart_get_rs485_mode (&s->p[i].port);if (ret)
Greg Kroah-Hartman
maintainerPATCH 2/94 serial: sc16is7xx: use guards for simple mutex locks
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Hugo Villeneuve <[email protected]>
[ Upstream commit 0f4f88bfd7e7bf3f3293045fffdc63586b0a889f ]
Guards can help to make the code more readable, so use them wherever they do so.
In sc16is7xx_port_irq(), labels and 'rc' locals are eliminated completely.
Stable-dep-of: 246ac114f485 ("serial: sc16is7xx: enable THRI before filling TX FIFO")
--- drivers/tty/serial/sc16is7xx.c | 23 ++++++++--------------- 1 file changed, 8 insertions(+), 15 deletions(-)
drivers/tty/serial/sc16is7xx.c +8 -15
@@ -11,6 +11,7 @@#define DEFAULT_SYMBOL_NAMESPACE "SERIAL_NXP_SC16IS7XX"#include <linux/bits.h> +#include <linux/cleanup.h> #include <linux/clk.h> #include <linux/delay.h> #include <linux/device.h>
@@ -782,18 +783,15 @@ static void sc16is7xx_update_mlines(strustatic bool sc16is7xx_port_irq (struct sc16is7xx_port *s,int portno) { -bool rc = true;unsigned int iir, rxlen;struct uart_port *port = &s->p[portno].port;struct sc16is7xx_one *one =to_sc16is7xx_one (port, port); -mutex_lock (&one->lock); +guard (mutex)(&one->lock); iir =sc16is7xx_port_read (port,SC16IS7XX_IIR_REG ); -if (iir &SC16IS7XX_IIR_NO_INT_BIT ) { - rc = false; - goto out_port_irq; - } +if (iir &SC16IS7XX_IIR_NO_INT_BIT ) +return false; iir &=SC16IS7XX_IIR_ID_MASK ;
@@ -833,10 +831,7 @@ static bool sc16is7xx_port_irq(struct scbreak ; } -out_port_irq: -mutex_unlock (&one->lock); - -return rc; +return true; }static irqreturn_t sc16is7xx_irq (int irq,void *dev_id)
@@ -878,9 +873,8 @@ static void sc16is7xx_tx_proc(struct kth (port->rs485.delay_rts_before_send > 0))msleep (port->rs485.delay_rts_before_send); -mutex_lock (&one->lock); +guard (mutex)(&one->lock);sc16is7xx_handle_tx (port); -mutex_unlock (&one->lock); }static void sc16is7xx_reconf_rs485 (struct uart_port *port)
@@ -947,9 +941,8 @@ static void sc16is7xx_ms_proc(struct kthstruct sc16is7xx_port *s =dev_get_drvdata (one->port.dev);if (one->port.state) { -mutex_lock (&one->lock); -sc16is7xx_update_mlines (one); -mutex_unlock (&one->lock); + scoped_guard(mutex, &one->lock) +sc16is7xx_update_mlines (one);kthread_queue_delayed_work (&s->kworker, &one->ms_work,HZ ); }
Greg Kroah-Hartman
maintainerPATCH 3/94 serial: sc16is7xx: enable THRI before filling TX FIFO
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Luca Fresi <[email protected]>
[ Upstream commit 246ac114f485c2affb454240f3ea4fabfce22456 ]
sc16is7xx_handle_tx() currently requests the THRI enable only after it has filled the TX FIFO. The request is asynchronous because the IER update is performed later by reg_work.
The SC16IS7xx generates a THRI interrupt when the TX FIFO crosses its trigger level. If the FIFO drains past that level before reg_work enables THRI, the chip does not generate a new interrupt. Characters remain queued indefinitely even though the hardware FIFO is empty.
This was observed on an SC16IS752 while both UART channels were active. During the stall the software TX buffer remained non-empty while TXLVL reported 64 bytes free, LSR reported THR and transmitter empty, IER had THRI enabled, and IIR reported no interrupt pending.
Enable THRI synchronously before filling the FIFO so the threshold crossing cannot be missed.
--- drivers/tty/serial/sc16is7xx.c | 3 +++ 1 file changed, 3 insertions(+)
drivers/tty/serial/sc16is7xx.c +3 -0
@@ -874,6 +874,9 @@ static void sc16is7xx_tx_proc(struct kthmsleep (port->rs485.delay_rts_before_send);guard (mutex)(&one->lock); +sc16is7xx_port_update (port,SC16IS7XX_IER_REG , +SC16IS7XX_IER_THRI_BIT , +SC16IS7XX_IER_THRI_BIT );sc16is7xx_handle_tx (port); }
Greg Kroah-Hartman
maintainerPATCH 4/94 xfs: add a xchk_ip_set_corrupt helper
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Christoph Hellwig <[email protected]>
[ Upstream commit aa7cfdb6e16b474328c79736f9b9dad09addc81c ]
Add a smaller wrapper to set a inode corrupted by the xfs_inode pointer.
Stable-dep-of: 8ed78104722b ("xfs: rtsummary scrub should treat rtbitmap corruption errors as an xref error")
--- fs/xfs/scrub/bmap.c | 8 ++++---- fs/xfs/scrub/common.c | 10 +++++----- fs/xfs/scrub/common.h | 2 ++ fs/xfs/scrub/dir.c | 2 +- fs/xfs/scrub/dirtree.c | 4 ++-- fs/xfs/scrub/metapath.c | 6 +++--- fs/xfs/scrub/nlinks.c | 12 ++++++------ fs/xfs/scrub/parent.c | 6 +++--- fs/xfs/scrub/rtbitmap.c | 12 ++++++------ fs/xfs/scrub/rtsummary.c | 12 ++++++------ 10 files changed, 38 insertions(+), 36 deletions(-)
fs/xfs/scrub/bmap.c +4 -4
@@ -1040,7 +1040,7 @@ xchk_bmap(case XFS_COW_FORK :/* No CoW forks filesystem doesn't support out of place writes */ if (!xfs_has_reflink (mp) && !xfs_has_zoned (mp)) { -xchk_ino_set_corrupt (sc, sc->ip->i_ino); +xchk_ip_set_corrupt (sc, sc->ip);return 0 ; }break ;
@@ -1052,7 +1052,7 @@ xchk_bmap(* attr here. */ if (!xfs_has_attr (mp)) -xchk_ino_set_corrupt (sc, sc->ip->i_ino); +xchk_ip_set_corrupt (sc, sc->ip);break ;default :ASSERT (whichfork ==XFS_DATA_FORK );
@@ -1137,7 +1137,7 @@ xchk_bmap_data(int error;if (xchk_file_looks_zapped (sc,XFS_SICK_INO_BMBTD_ZAPPED )) { -xchk_ino_set_corrupt (sc, sc->ip->i_ino); +xchk_ip_set_corrupt (sc, sc->ip);return 0 ; }
@@ -1165,7 +1165,7 @@ xchk_bmap_attr(* returning immediately. */ if (xchk_file_looks_zapped (sc,XFS_SICK_INO_BMBTA_ZAPPED )) { -xchk_ino_set_corrupt (sc, sc->ip->i_ino); +xchk_ip_set_corrupt (sc, sc->ip);return 0 ; }
fs/xfs/scrub/common.c +5 -5
@@ -1099,7 +1099,7 @@ xchk_install_live_inode( struct xfs_inode *ip) {if (!igrab (VFS_I (ip))) { -xchk_ino_set_corrupt (sc, ip->i_ino); +xchk_ip_set_corrupt (sc, ip);return -EFSCORRUPTED ; }
@@ -1428,13 +1428,13 @@ xchk_metadata_inode_forks(/* Metadata inodes don't live on the rt device. */ if (sc->ip->i_diflags &XFS_DIFLAG_REALTIME ) { -xchk_ino_set_corrupt (sc, sc->ip->i_ino); +xchk_ip_set_corrupt (sc, sc->ip);return 0 ; }/* They should never participate in reflink. */ if (xfs_is_reflink_inode (sc->ip)) { -xchk_ino_set_corrupt (sc, sc->ip->i_ino); +xchk_ip_set_corrupt (sc, sc->ip);return 0 ; }
@@ -1451,7 +1451,7 @@ xchk_metadata_inode_forks( &error))return error;if (shared) -xchk_ino_set_corrupt (sc, sc->ip->i_ino); +xchk_ip_set_corrupt (sc, sc->ip); }/*
@@ -1460,7 +1460,7 @@ xchk_metadata_inode_forks(*/ if (xfs_inode_hasattr (sc->ip)) {if (!xfs_has_metadir (sc->mp)) { -xchk_ino_set_corrupt (sc, sc->ip->i_ino); +xchk_ip_set_corrupt (sc, sc->ip);return 0 ; }
fs/xfs/scrub/common.h +2 -0
@@ -30,6 +30,8 @@ void xchk_set_corrupt(struct xfs_scrub *void xchk_block_set_corrupt (struct xfs_scrub *sc,struct xfs_buf *bp);void xchk_ino_set_corrupt (struct xfs_scrub *sc,xfs_ino_t ino); +#define xchk_ip_set_corrupt (_sc, _ip) \ + xchk_ino_set_corrupt((_sc), (_ip)->i_ino)void xchk_fblock_set_corrupt (struct xfs_scrub *sc,int whichfork,xfs_fileoff_t offset);#ifdef CONFIG_XFS_QUOTA
fs/xfs/scrub/dir.c +1 -1
@@ -1075,7 +1075,7 @@ xchk_directory(/* Plausible size? */ if (sc->ip->i_disk_size <xfs_dir2_sf_hdr_size (0 )) { -xchk_ino_set_corrupt (sc, sc->ip->i_ino); +xchk_ip_set_corrupt (sc, sc->ip);return 0 ; }
fs/xfs/scrub/dirtree.c +2 -2
@@ -979,10 +979,10 @@ xchk_dirtree(xchk_dirtree_evaluate (dl, &oc);if (xchk_dirtree_parentless (dl)) {if (oc.good || oc.bad || oc.suspect) -xchk_ino_set_corrupt (sc, sc->ip->i_ino); +xchk_ip_set_corrupt (sc, sc->ip); }else {if (oc.bad || oc.good + oc.suspect !=1 ) -xchk_ino_set_corrupt (sc, sc->ip->i_ino); +xchk_ip_set_corrupt (sc, sc->ip);if (oc.suspect)xchk_ino_xref_set_corrupt (sc, sc->ip->i_ino); }
fs/xfs/scrub/metapath.c +3 -3
@@ -314,7 +314,7 @@ xchk_metapath(/* Parent required to do anything else. */ if (mpath->dp ==NULL ) { -xchk_ino_set_corrupt (sc, sc->ip->i_ino); +xchk_ip_set_corrupt (sc, sc->ip);return 0 ; }
@@ -329,7 +329,7 @@ xchk_metapath(trace_xchk_metapath_lookup (sc, mpath->path, mpath->dp, ino);if (error == -ENOENT ) {/* No directory entry at all */ -xchk_ino_set_corrupt (sc, sc->ip->i_ino); +xchk_ip_set_corrupt (sc, sc->ip); error =0 ; goto out_ilock; }
@@ -337,7 +337,7 @@ xchk_metapath( goto out_ilock;if (ino != sc->ip->i_ino) {/* Pointing to wrong inode */ -xchk_ino_set_corrupt (sc, sc->ip->i_ino); +xchk_ip_set_corrupt (sc, sc->ip); } out_ilock:
fs/xfs/scrub/nlinks.c +6 -6
@@ -719,7 +719,7 @@ xchk_nlinks_compare_inode(* count, but it will let them decrease it. */ if (total_links >XFS_NLINK_PINNED ) { -xchk_ino_set_corrupt (sc, ip->i_ino); +xchk_ip_set_corrupt (sc, ip); goto out_corrupt; }else if (total_links >XFS_MAXLINK ) {xchk_ino_set_warning (sc, ip->i_ino);
@@ -727,7 +727,7 @@ xchk_nlinks_compare_inode(/* Link counts should match. */ if (total_links != actual_nlink) { -xchk_ino_set_corrupt (sc, ip->i_ino); +xchk_ip_set_corrupt (sc, ip); goto out_corrupt; }
@@ -748,7 +748,7 @@ xchk_nlinks_compare_inode(* back references. */ if (obs.backrefs !=0 ) { -xchk_ino_set_corrupt (sc, ip->i_ino); +xchk_ip_set_corrupt (sc, ip); goto out_corrupt; }
@@ -757,7 +757,7 @@ xchk_nlinks_compare_inode(* children. */ if (obs.children !=0 ) { -xchk_ino_set_corrupt (sc, ip->i_ino); +xchk_ip_set_corrupt (sc, ip); goto out_corrupt; } }
@@ -770,7 +770,7 @@ xchk_nlinks_compare_inode(* the root directory. */ if (obs.parents !=1 ) { -xchk_ino_set_corrupt (sc, ip->i_ino); +xchk_ip_set_corrupt (sc, ip); goto out_corrupt; } }else if (actual_nlink >0 ) {
@@ -779,7 +779,7 @@ xchk_nlinks_compare_inode(* least one parent. */ if (obs.parents ==0 ) { -xchk_ino_set_corrupt (sc, ip->i_ino); +xchk_ip_set_corrupt (sc, ip); goto out_corrupt; } }
fs/xfs/scrub/parent.c +3 -3
@@ -729,10 +729,10 @@ xchk_parent_count_pptrs( pp->pptrs_found++;if (VFS_I (sc->ip)->i_nlink ==0 && pp->pptrs_found >0 ) -xchk_ino_set_corrupt (sc, sc->ip->i_ino); +xchk_ip_set_corrupt (sc, sc->ip);else if (VFS_I (sc->ip)->i_nlink >0 && pp->pptrs_found ==0 ) -xchk_ino_set_corrupt (sc, sc->ip->i_ino); +xchk_ip_set_corrupt (sc, sc->ip); }else {/* * Starting with metadir, we allow checking of parent pointers
@@ -743,7 +743,7 @@ xchk_parent_count_pptrs( pp->pptrs_found++;if (VFS_I (sc->ip)->i_nlink != pp->pptrs_found) -xchk_ino_set_corrupt (sc, sc->ip->i_ino); +xchk_ip_set_corrupt (sc, sc->ip); }return 0 ;
fs/xfs/scrub/rtbitmap.c +6 -6
@@ -200,13 +200,13 @@ xchk_rtbitmap(/* Is sb_rextents correct? */ if (mp->m_sb.sb_rextents != rtb->rextents) { -xchk_ino_set_corrupt (sc, rbmip->i_ino); +xchk_ip_set_corrupt (sc, rbmip);return 0 ; }/* Is sb_rextslog correct? */ if (mp->m_sb.sb_rextslog != rtb->rextslog) { -xchk_ino_set_corrupt (sc, rbmip->i_ino); +xchk_ip_set_corrupt (sc, rbmip);return 0 ; }
@@ -215,17 +215,17 @@ xchk_rtbitmap(* case can we exceed 4bn bitmap blocks since the super field is a u32. */ if (rtb->rbmblocks >U32_MAX ) { -xchk_ino_set_corrupt (sc, rbmip->i_ino); +xchk_ip_set_corrupt (sc, rbmip);return 0 ; }if (mp->m_sb.sb_rbmblocks != rtb->rbmblocks) { -xchk_ino_set_corrupt (sc, rbmip->i_ino); +xchk_ip_set_corrupt (sc, rbmip);return 0 ; }/* The bitmap file length must be aligned to an fsblock. */ if (rbmip->i_disk_size & mp->m_blockmask) { -xchk_ino_set_corrupt (sc, rbmip->i_ino); +xchk_ip_set_corrupt (sc, rbmip);return 0 ; }
@@ -235,7 +235,7 @@ xchk_rtbitmap(* file can be larger than sb_rbmblocks. */ if (rbmip->i_disk_size <XFS_FSB_TO_B (mp, rtb->rbmblocks)) { -xchk_ino_set_corrupt (sc, rbmip->i_ino); +xchk_ip_set_corrupt (sc, rbmip);return 0 ; }
fs/xfs/scrub/rtsummary.c +6 -6
@@ -315,25 +315,25 @@ xchk_rtsummary(/* Is sb_rextents correct? */ if (mp->m_sb.sb_rextents != rts->rextents) { -xchk_ino_set_corrupt (sc, rbmip->i_ino); +xchk_ip_set_corrupt (sc, rbmip);return 0 ; }/* Is m_rsumlevels correct? */ if (mp->m_rsumlevels != rts->rsumlevels) { -xchk_ino_set_corrupt (sc, rsumip->i_ino); +xchk_ip_set_corrupt (sc, rsumip);return 0 ; }/* Is m_rsumsize correct? */ if (mp->m_rsumblocks != rts->rsumblocks) { -xchk_ino_set_corrupt (sc, rsumip->i_ino); +xchk_ip_set_corrupt (sc, rsumip);return 0 ; }/* The summary file length must be aligned to an fsblock. */ if (rsumip->i_disk_size & mp->m_blockmask) { -xchk_ino_set_corrupt (sc, rsumip->i_ino); +xchk_ip_set_corrupt (sc, rsumip);return 0 ; }
@@ -343,7 +343,7 @@ xchk_rtsummary(* the file can be larger than rsumsize. */ if (rsumip->i_disk_size <XFS_FSB_TO_B (mp, rts->rsumblocks)) { -xchk_ino_set_corrupt (sc, rsumip->i_ino); +xchk_ip_set_corrupt (sc, rsumip);return 0 ; }
@@ -359,7 +359,7 @@ xchk_rtsummary(* EFSCORRUPTED means the rtbitmap is corrupt, which is an xref * error since we're checking the summary file. */ -xchk_ino_set_corrupt (sc, rbmip->i_ino); +xchk_ip_set_corrupt (sc, rbmip);return 0 ; }if (error)
Greg Kroah-Hartman
maintainerPATCH 5/94 xfs: rtsummary scrub should treat rtbitmap corruption errors as an xref error
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: "Darrick J. Wong" <[email protected]>
[ Upstream commit 8ed78104722b57df69478b0b1608a408c1036085 ]
LOLLM notes the discrepancy between the comment saying that this is an xref error and the code, which marks a (non-xref) corruption error. This appears to be a regression.
--- fs/xfs/scrub/rtsummary.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/xfs/scrub/rtsummary.c +1 -1
@@ -359,7 +359,7 @@ xchk_rtsummary(* EFSCORRUPTED means the rtbitmap is corrupt, which is an xref * error since we're checking the summary file. */ -xchk_ip_set_corrupt (sc, rbmip); +xchk_ino_xref_set_corrupt (sc, rbmip->i_ino);return 0 ; }if (error)
Greg Kroah-Hartman
maintainerPATCH 6/94 xfs: hoist per-bucket unlinked list check to helper
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: "Darrick J. Wong" <[email protected]>
[ Upstream commit 7cdafd8f10ebdf745ba6046b9fa67490c343a17f ]
In the next patch we're going to make this loop more exciting, so hoist the code to a helper function to reduce clutter in the resulting code.
Stable-dep-of: 527eaaefddb6 ("xfs: don't livelock in scrub on a circular unlinked list")
--- fs/xfs/scrub/agheader.c | 62 +++++++++++++++++++++++++++++++----------------- 1 file changed, 41 insertions(+), 21 deletions(-)
fs/xfs/scrub/agheader.c +41 -21
@@ -933,6 +933,42 @@ xchk_agi_xref( }/* +* Walk the incore unlinked list for a particular AGI bucket to construct +* the unlinked inode bitmap for later reconstruction of the unlinked list. +* Returns 1 if we should keep checking, or 0 to stop checking. +*/ +static int +xchk_iunlink_bucket ( +struct xfs_scrub *sc, +unsigned int bucket, +xfs_agino_t agino) +{ +while (agino !=NULLAGINO ) { +struct xfs_inode *ip; + +if (agino %XFS_AGI_UNLINKED_BUCKETS != bucket) { +xchk_block_set_corrupt (sc, sc->sa.agi_bp); +return 0 ; + } + + ip =xfs_iunlink_lookup (sc->sa.pag, agino); +if (!ip) { +xchk_block_set_corrupt (sc, sc->sa.agi_bp); +return 0 ; + } + +if (!xfs_inode_on_unlinked_list (ip)) { +xchk_block_set_corrupt (sc, sc->sa.agi_bp); +return 0 ; + } + + agino = ip->i_next_unlinked; + } + +return 1 ; +} + +/* * Check the unlinked buckets for links to bad inodes. We hold the AGI, so * there cannot be any threads updating unlinked list pointers in this AG. */
@@ -942,30 +978,14 @@ xchk_iunlink( struct xfs_agi *agi) {unsigned int i; -struct xfs_inode *ip;for (i =0 ; i <XFS_AGI_UNLINKED_BUCKETS ; i++) { -xfs_agino_t agino =be32_to_cpu (agi->agi_unlinked[i]); +int ret; -while (agino !=NULLAGINO ) { -if (agino %XFS_AGI_UNLINKED_BUCKETS != i) { -xchk_block_set_corrupt (sc, sc->sa.agi_bp); -return ; - } - - ip =xfs_iunlink_lookup (sc->sa.pag, agino); -if (!ip) { -xchk_block_set_corrupt (sc, sc->sa.agi_bp); -return ; - } - -if (!xfs_inode_on_unlinked_list (ip)) { -xchk_block_set_corrupt (sc, sc->sa.agi_bp); -return ; - } - - agino = ip->i_next_unlinked; - } + ret =xchk_iunlink_bucket (sc, i, +be32_to_cpu (agi->agi_unlinked[i])); +if (ret <1 ) +return ; } }
Greg Kroah-Hartman
maintainerPATCH 7/94 xfs: dont livelock in scrub on a circular unlinked list
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: "Darrick J. Wong" <[email protected]>
[ Upstream commit 527eaaefddb6ec5c83a06c9a1559960dd6361753 ]
LOLLM points out that online fsck can livelock if an unlinked inode list contains a loop. Use a bitmap to detect cycles.
--- fs/xfs/scrub/agheader.c | 44 +++++++++++++++++++++++++++++++++-------- fs/xfs/scrub/agheader_repair.c | 17 +++++++++++++-- 2 files changed, 51 insertions(+), 10 deletions(-)
fs/xfs/scrub/agheader.c +36 -8
@@ -18,6 +18,8 @@#include "xfs_inode.h" #include "scrub/scrub.h" #include "scrub/common.h" +#include "scrub/bitmap.h" +#include "scrub/agino_bitmap.h" int xchk_setup_agheader(
@@ -935,7 +937,8 @@ xchk_agi_xref(/* * Walk the incore unlinked list for a particular AGI bucket to construct * the unlinked inode bitmap for later reconstruction of the unlinked list. -* Returns 1 if we should keep checking, or 0 to stop checking. +* Returns 1 if we should keep checking, 0 to stop checking, or a negative +* errno. */ static int xchk_iunlink_bucket(
@@ -943,36 +946,57 @@ xchk_iunlink_bucket( unsigned int bucket, xfs_agino_t agino) { +struct xagino_bitmap seen; +int ret; + +xagino_bitmap_init (&seen); +while (agino !=NULLAGINO ) {struct xfs_inode *ip; +unsigned int len =1 ;if (agino %XFS_AGI_UNLINKED_BUCKETS != bucket) {xchk_block_set_corrupt (sc, sc->sa.agi_bp); -return 0 ; + goto bad; + } + +if (xagino_bitmap_test (&seen, agino, &len)) { +xchk_block_set_corrupt (sc, sc->sa.agi_bp); + goto bad; } ip =xfs_iunlink_lookup (sc->sa.pag, agino);if (!ip) {xchk_block_set_corrupt (sc, sc->sa.agi_bp); -return 0 ; + goto bad; }if (!xfs_inode_on_unlinked_list (ip)) {xchk_block_set_corrupt (sc, sc->sa.agi_bp); -return 0 ; + goto bad; } + ret =xagino_bitmap_set (&seen, agino,1 ); +if (ret) + goto out_bitmap; + agino = ip->i_next_unlinked; } + ret =1 ; -return 1 ; +out_bitmap: +xagino_bitmap_destroy (&seen); +return ret; +bad: + ret =0 ; + goto out_bitmap; }/* * Check the unlinked buckets for links to bad inodes. We hold the AGI, so * there cannot be any threads updating unlinked list pointers in this AG. */ -STATIC void +STATIC intxchk_iunlink (struct xfs_scrub *sc,struct xfs_agi *agi)
@@ -985,8 +1009,10 @@ xchk_iunlink( ret =xchk_iunlink_bucket (sc, i,be32_to_cpu (agi->agi_unlinked[i]));if (ret <1 ) -return ; +return ret; } + +return 0 ; }/* Scrub the AGI. */
@@ -1073,7 +1099,9 @@ xchk_agi(if (pag->pagi_freecount !=be32_to_cpu (agi->agi_freecount))xchk_block_set_corrupt (sc, sc->sa.agi_bp); -xchk_iunlink (sc, agi); + error =xchk_iunlink (sc, agi); +if (error) + goto out;xchk_agi_xref (sc); out:
fs/xfs/scrub/agheader_repair.c +15 -2
@@ -1096,18 +1096,22 @@ xrep_iunlink_walk_ondisk_bucket( struct xrep_agi *ragi, unsigned int bucket) { +struct xagino_bitmap seen;struct xfs_scrub *sc = ragi->sc;struct xfs_agi *agi = ragi->agi_bp->b_addr;xfs_agino_t prev_agino =NULLAGINO ;xfs_agino_t next_agino;int error =0 ; +xagino_bitmap_init (&seen); + next_agino =be32_to_cpu (agi->agi_unlinked[bucket]);while (next_agino !=NULLAGINO ) {xfs_agino_t agino = next_agino; +unsigned int len =1 ;if (xchk_should_terminate (ragi->sc, &error)) -return error; + goto out_bitmap;trace_xrep_iunlink_walk_ondisk_bucket (sc->sa.pag, bucket, prev_agino, agino);
@@ -1115,6 +1119,9 @@ xrep_iunlink_walk_ondisk_bucket(if (bucket != agino %XFS_AGI_UNLINKED_BUCKETS )break ; +if (xagino_bitmap_test (&seen, agino, &len)) +break ; + next_agino =xrep_iunlink_next (sc, agino);if (!next_agino) { error = xrep_iunlink_reload_next(ragi, prev_agino,
@@ -1123,10 +1130,16 @@ xrep_iunlink_walk_ondisk_bucket(break ; } + error =xagino_bitmap_set (&seen, agino,1 ); +if (error) + goto out_bitmap; + prev_agino = agino; } -return 0 ; +out_bitmap: +xagino_bitmap_destroy (&seen); +return error; }/* Decide if this is an unlinked inode in this AG. */
Greg Kroah-Hartman
maintainerPATCH 8/94 PCI: host-generic: Fix NULL pointer dereference on 32-bit CAM systems
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Steffen Persvold <[email protected]>
commit 008cb88edb41f3c7c8e0ed763ff9f26719830984 upstream.
On 32-bit systems the config space is too large to ioremap in one go, so pci_ecam_create() maps each bus segment separately and relies on the ->add_bus callback (pci_ecam_add_bus) to populate the per-bus mapping in cfg->winp[]. pci_ecam_map_bus() then uses that mapping as the base for every config access.
The generic ECAM ops (pci_generic_ecam_ops) already provide the ->add_bus and ->remove_bus callbacks, but the CAM (legacy) ops in pci-host-generic.c do not. As a result, on a 32-bit host using "pci-host-cam-generic" the per-bus mapping is never set up and the first config read dereferences a NULL base, crashing during bus enumeration:
Unable to handle kernel NULL pointer dereference at virtual address 00000800 Oops [#1] CPU: 0 PID: 1 Comm: swapper Not tainted 6.9.7+ #43 Hardware name: Digilent Nexys-Video-A7 RV32 (DT) epc : pci_generic_config_read+0x40/0xb0 ra : pci_generic_config_read+0x2c/0xb0 [<c038db9c>] pci_generic_config_read+0x40/0xb0 [<c038da04>] pci_bus_read_config_dword+0x50/0xb0 [<c0391e94>] pci_bus_generic_read_dev_vendor_id+0x3c/0x1ec [<c039245c>] pci_scan_single_device+0xa4/0x11c [<c0392570>] pci_scan_slot+0x9c/0x23c [<c039388c>] pci_scan_child_bus_extend+0x58/0x2f4 [<c0393db0>] pci_scan_root_bus_bridge+0x64/0xe8 [<c0393e54>] pci_host_probe+0x20/0xc8 [<c03bc6f4>] pci_host_common_probe+0x144/0x1e4
Fix this by giving the CAM ops the same ->add_bus/->remove_bus callbacks. Since pci_ecam_add_bus() and pci_ecam_remove_bus() are static to ecam.c, move the CAM ops definition there as pci_generic_cam_ops (mirroring pci_generic_ecam_ops) and export it for pci-host-generic.c to reference.
--- drivers/pci/controller/pci-host-generic.c | 11 +---------- drivers/pci/ecam.c | 13 +++++++++++++ include/linux/pci-ecam.h | 3 +++ 3 files changed, 17 insertions(+), 10 deletions(-)
drivers/pci/controller/pci-host-generic.c +1 -10
@@ -16,15 +16,6 @@#include "pci-host-common.h" -static const struct pci_ecam_ops gen_pci_cfg_cam_bus_ops = { - .bus_shift =16 , - .pci_ops = { - .map_bus = pci_ecam_map_bus, - .read = pci_generic_config_read, - .write = pci_generic_config_write, - } -}; -static bool pci_dw_valid_device (struct pci_bus *bus,unsigned int devfn) {struct pci_config_window *cfg = bus->sysdata;
@@ -60,7 +51,7 @@ static const struct pci_ecam_ops pci_dw_static const struct of_device_id gen_pci_of_match[] = { { .compatible ="pci-host-cam-generic" , - .data = &gen_pci_cfg_cam_bus_ops }, + .data = &pci_generic_cam_ops }, { .compatible ="pci-host-ecam-generic" , .data = &pci_generic_ecam_ops },
drivers/pci/ecam.c +13 -0
@@ -208,6 +208,19 @@ const struct pci_ecam_ops pci_generic_ec };EXPORT_SYMBOL_GPL (pci_generic_ecam_ops); +/* CAM ops */ +const struct pci_ecam_ops pci_generic_cam_ops = { + .bus_shift =16 , + .pci_ops = { + .add_bus = pci_ecam_add_bus, + .remove_bus = pci_ecam_remove_bus, + .map_bus = pci_ecam_map_bus, + .read = pci_generic_config_read, + .write = pci_generic_config_write, + } +}; +EXPORT_SYMBOL_GPL (pci_generic_cam_ops); +#if defined(CONFIG_ACPI ) && defined(CONFIG_PCI_QUIRKS )/* ECAM ops for 32-bit access only (non-compliant) */ const struct pci_ecam_ops pci_32b_ops = {
include/linux/pci-ecam.h +3 -0
@@ -81,6 +81,9 @@ void __iomem *pci_ecam_map_bus(struct pc/* default ECAM ops */ extern const struct pci_ecam_ops pci_generic_ecam_ops; +/* default CAM ops */ +extern const struct pci_ecam_ops pci_generic_cam_ops; +#if defined(CONFIG_ACPI ) && defined(CONFIG_PCI_QUIRKS )extern const struct pci_ecam_ops pci_32b_ops;/* 32-bit accesses only */ extern const struct pci_ecam_ops pci_32b_read_ops;/* 32-bit read only */
Greg Kroah-Hartman
maintainerPATCH 9/94 Bluetooth: RFCOMM: take rfcomm_mutex for the deferred setup accept
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Ali Ahmet Memis <[email protected]>
commit 43a556b2fd43f2df6dded59c2e26560a27874c24 upstream.
rfcomm_sock_recvmsg() completes a deferred setup by calling rfcomm_dlc_accept() without holding any RFCOMM lock:
if (test_and_clear_bit(RFCOMM_DEFER_SETUP, &d->flags)) {
rfcomm_dlc_accept(d);
return 0;
}and rfcomm_dlc_accept() dereferences the session on its first line:
struct sock *sk = d->session->sock->sk;
Every other path that touches d->session runs under rfcomm_mutex:rfcomm_dlc_open(), rfcomm_dlc_close(), rfcomm_dlc_exists(), rfcomm_dlc_send_rpn(), and the RFCOMM thread through rfcomm_process_sessions(). rfcomm_connect_ind() is even documented as "called under rfcomm_lock()". This call site is the only one that skips it.
The RFCOMM_DEFER_SETUP bit looks like it serialises the accept against teardown, since __rfcomm_dlc_close() returns early when it wins the test_and_clear. But rfcomm_recv_disc() forces the state first:
d->state = BT_CLOSED; __rfcomm_dlc_close(d, err);
and the early return only covers BT_CONNECT, BT_CONFIG, BT_OPEN and BT_CONNECT2. With the state already BT_CLOSED that switch does not match, the bit is never consulted, and __rfcomm_dlc_close() falls through to rfcomm_dlc_unlink(), which sets d->session = NULL.
So a remote DISC on a deferred dlc clears the session while leaving RFCOMM_DEFER_SETUP set. The next recvmsg() then passes the test_and_clear and dereferences a NULL session. No timing window is
needed: once the DISC has been processed, the dereference is unconditional.
Give rfcomm_dlc_accept() the same shape as rfcomm_dlc_open() and rfcomm_dlc_close(): an exported wrapper that takes rfcomm_mutex and re-checks the session, around a __rfcomm_dlc_accept() that the two in-core callers, which already hold the mutex, keep using.
Reproduced on a KASAN + PROVE_LOCKING kernel with a BR/EDR peer emulated over /dev/vhci: the peer brings up an ACL link, opens L2CAP on the RFCOMM PSM, starts a session, opens a dlc on a channel bound with BT_DEFER_SETUP, and sends DISC after the socket is accepted. recv() on the accepted socket then hits:
Oops: general protection fault
KASAN: null-ptr-deref in range [0x0000000000000010-0x0000000000000017]
RIP: 0010:rfcomm_dlc_accept+0x54/0x350
Call Trace:
rfcomm_sock_recvmsg+0x1cd/0x230
sock_recvmsg+0x166/0x1c0
__sys_recvfrom+0x20d/0x3000x10 is the offset of sock in struct rfcomm_session. With this patch the same run completes with recv() returning 0 and no report, and lockdep stays quiet, confirming rfcomm_mutex is still taken before lock_sock on this path as it is on the thread side.
--- net/bluetooth/rfcomm/core.c | 24 +++++++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-)
net/bluetooth/rfcomm/core.c +21 -3
@@ -1334,7 +1334,10 @@ static struct rfcomm_session *rfcomm_recreturn s; } -void rfcomm_dlc_accept (struct rfcomm_dlc *d) +/* Must be called with rfcomm_mutex held, so that the session cannot be +* unlinked from under us. +*/ +static void __rfcomm_dlc_accept (struct rfcomm_dlc *d) {struct sock *sk = d->session->sock->sk;struct l2cap_conn *conn =l2cap_pi (sk)->chan->conn;
@@ -1356,6 +1359,21 @@ void rfcomm_dlc_accept(struct rfcomm_dlcrfcomm_send_msc (d->session,1 , d->dlci, d->v24_sig); } +void rfcomm_dlc_accept (struct rfcomm_dlc *d) +{ +rfcomm_lock (); + +/* rfcomm_recv_disc() sets the dlc state to BT_CLOSED before calling +* __rfcomm_dlc_close(), so the RFCOMM_DEFER_SETUP handshake there is +* skipped and the session can already be unlinked by the time the +* deferred accept runs from rfcomm_sock_recvmsg(). +*/ +if (d->session) +__rfcomm_dlc_accept (d); + +rfcomm_unlock (); +} +static void rfcomm_check_accept (struct rfcomm_dlc *d) {if (rfcomm_check_security (d)) {
@@ -1368,7 +1386,7 @@ static void rfcomm_check_accept(struct r d->state_change (d,0 );rfcomm_dlc_unlock (d); }else -rfcomm_dlc_accept (d); +__rfcomm_dlc_accept (d); }else {set_bit (RFCOMM_AUTH_PENDING , &d->flags);rfcomm_dlc_set_timer (d,RFCOMM_AUTH_TIMEOUT );
@@ -1953,7 +1971,7 @@ static void rfcomm_process_dlcs(struct r d->state_change (d,0 );rfcomm_dlc_unlock (d); }else -rfcomm_dlc_accept (d); +__rfcomm_dlc_accept (d); }continue ; }else if (test_and_clear_bit (RFCOMM_AUTH_REJECT , &d->flags)) {
Greg Kroah-Hartman
maintainerPATCH 10/94 iommu/tegra241-cmdqv: Fix CMD_SYNC use-after-free on teardown
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Shameer Kolothum <[email protected]>
commit 9ff145a25c5c8a26b06ef7cf558fb536b18bba6d upstream.
arm_smmu_impl_remove() is registered as a devres action in arm_smmu_impl_probe(), before arm_smmu_init_queues() allocates smmu->cmdq.q.base. On a devres unwind, whether a failed probe or an unbind, the queue is freed first and arm_smmu_impl_remove() then runs tegra241_cmdqv_remove_vintf(), whose VINTF deinit issues a CMD_SYNC on the freed memory.
Observed during testing with a QEMU hack that makes the VCMDQ fail to enable, so the impl reset fails and probe aborts into the devres unwind:
platform NVDA200C:00: tegra241_cmdqv: VINTF0: VCMDQ0/LVCMDQ0: failed to enable, STATUS=0x00000000 platform NVDA200C:00: tegra241_cmdqv: VINTF0: VCMDQ0/LVCMDQ0: GERRORN=0x0, GERROR=0x4, CONS=0x0 platform NVDA200C:00: tegra241_cmdqv: VINTF0: VCMDQ0/LVCMDQ0: uncleared error detected, resetting arm-smmu-v3 arm-smmu-v3.0.auto: failed to reset impl
arm-smmu-v3 arm-smmu-v3.0.auto: probe with driver arm-smmu-v3 failed with error -110
Unable to handle kernel paging request at virtual address ffff8000891e0098 ... Internal error: Oops: 0000000096000047 [#1] SMP ... Call trace: arm_smmu_cmdq_issue_cmdlist+0x320/0x6fc (P) tegra241_vcmdq_hw_deinit+0x98/0x168 tegra241_vintf_hw_deinit+0x5c/0x1b0 tegra241_cmdqv_remove_vintf+0x34/0xec tegra241_cmdqv_remove+0x40/0x9c arm_smmu_impl_remove+0x20/0x30 devm_action_release+0x14/0x20 devres_release_all+0xa8/0x110 device_unbind_cleanup+0x18/0x84 really_probe+0x1f0/0x29c
Drop the VINTF deinit from tegra241_cmdqv_remove_vintf() so the unwind no longer touches the freed queue. Quiesce the VINTFs earlier instead. Add a device_disable() impl op and run it from arm_smmu_disable_action() while the CMDQ is still up. That handles a live unbind. A failed reset is already handled because tegra241_vintf_hw_init() deinits the VINTF on its own error path. tegra241_cmdqv_remove_vintf() is also used by the iommufd viommu destroy path, so quiesce there too.
--- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 2 ++ drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h | 1 + drivers/iommu/arm/arm-smmu-v3/tegra241-cmdqv.c | 15 +++++++++++++-- 3 files changed, 16 insertions(+), 2 deletions(-)
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +2 -0
@@ -4929,6 +4929,8 @@ static void arm_smmu_device_shutdown(str {struct arm_smmu_device *smmu =platform_get_drvdata (pdev); +if (smmu->impl_ops && smmu->impl_ops->device_disable) + smmu->impl_ops->device_disable (smmu);arm_smmu_device_disable (smmu); }
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h +1 -0
@@ -718,6 +718,7 @@ struct arm_smmu_strtab_cfg {struct arm_smmu_impl_ops {int (*device_reset)(struct arm_smmu_device *smmu); +void (*device_disable)(struct arm_smmu_device *smmu);void (*device_remove)(struct arm_smmu_device *smmu);int (*init_structures)(struct arm_smmu_device *smmu); struct arm_smmu_cmdq *(*get_secondary_cmdq)(
drivers/iommu/arm/arm-smmu-v3/tegra241-cmdqv.c +13 -2
@@ -763,8 +763,6 @@ static void tegra241_cmdqv_remove_vintf(struct tegra241_vintf *vintf = cmdqv->vintfs[idx];u16 lidx; -tegra241_vintf_hw_deinit (vintf); -/* Remove LVCMDQ resources */ for (lidx =0 ; lidx < vintf->cmdqv->num_lvcmdqs_per_vintf; lidx++)if (vintf->lvcmdqs[lidx])
@@ -781,6 +779,17 @@ static void tegra241_cmdqv_remove_vintf( } } +static void tegra241_cmdqv_hw_disable (struct arm_smmu_device *smmu) +{ +struct tegra241_cmdqv *cmdqv = + container_of(smmu, struct tegra241_cmdqv, smmu); +u16 idx; + +for (idx =0 ; idx < cmdqv->num_vintfs; idx++) +if (cmdqv->vintfs[idx]) +tegra241_vintf_hw_deinit (cmdqv->vintfs[idx]); +} +static void tegra241_cmdqv_remove (struct arm_smmu_device *smmu) { struct tegra241_cmdqv *cmdqv =
@@ -846,6 +855,7 @@ static struct arm_smmu_impl_ops tegra241/* For in-kernel use */ .get_secondary_cmdq = tegra241_cmdqv_get_cmdq, .device_reset = tegra241_cmdqv_hw_reset, + .device_disable = tegra241_cmdqv_hw_disable, .device_remove = tegra241_cmdqv_remove,/* For user-space use */ .hw_info = tegra241_cmdqv_hw_info,
@@ -1212,6 +1222,7 @@ static void tegra241_cmdqv_destroy_vintfif (vintf->mmap_offset)iommufd_viommu_destroy_mmap (&vintf->vsmmu.core, vintf->mmap_offset); +tegra241_vintf_hw_deinit (vintf);tegra241_cmdqv_remove_vintf (vintf->cmdqv, vintf->idx); }
Greg Kroah-Hartman
maintainerPATCH 11/94 iommu/iommufd: Fix NULL pointer deref in iommufd_ioas_change_process when racing with iopt_map_file_pages
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Peiyang He <[email protected]>
commit d616de490ec0242dcf78f02f1adf7baa035c4d0d upstream.
iommufd_ioas_change_process() iterates every IOAS area while only holding every IOAS iova_rwsem, so it assumes every area has a non-NULL pages pointer. That assumption can be false when it runs concurrently with iopt_map_file_pages().
iopt_map_pages() executes in two phases. It first creates the area and inserts it into the interval tree under iova_rwsem, with area->pages still NULL. It then drops iova_rwsem and later fills area->pages under domains_rwsem. This leaves a window between area creation and area->pages fill where a concurrent iommufd_ioas_change_process() can observe the area and dereference a NULL area->pages pointer, leading to a NULL pointer dereference:
BUG: kernel NULL pointer dereference, address: 00000000000000c0 #PF: supervisor read access in kernel mode #PF: error_code(0x0000) - not-present page PGD 4b655067 P4D 4b655067 PUD 0 Oops: Oops: 0000 [#1] SMP NOPTI CPU: 0 UID: 0 PID: 11841 Comm: syz.1.628 Not tainted 7.1.0 #3 PREEMPT(full) Hardware name: QEMU Ubuntu 24.04 PC v2 (i440FX + PIIX, arch_caps fix, 1996), BIOS 1.16.3-debian-1.16.3-2 04/01/2014 RIP: 0010:iommufd_ioas_change_process+0x419/0xd50 drivers/iommu/iommufd/ioas.c:538 Code: 48 89 c3 48 85 c0 0f 84 cc 00 00 00 e8 10 f5 cb fd 48 8d 7b 68 e8 a7 b5 eb fd 48 8b 6b 68 48 8d bd c0 00 00 00 e8 17 b2 eb fd <8b> ad c0 00 00 00 bf 01 00 00 00 89 ee e8 85 ef cb fd 83 fd 01 74 RSP: 0018:ffffc90015c17d28 EFLAGS: 00010246 RAX: ffff8880186d5328 RBX: ffff88801d25e240 RCX: 0000000080000000 RDX: 00000000000002d7 RSI: ffffffff83ba9e10 RDI: 00000000000000c0 RBP: 0000000000000000 R08: ffffffff8e781eb8 R09: 0000000000000000 R10: 00000000000000c0 R11: ffffffff83ba9e29 R12: ffff88802e216008 R13: ffff88802e216000 R14: 0000000000000001 R15: 0000000000000000 FS: 00007f4aea3f66c0(0000) GS:ffff8880b1fa1000(0000) knlGS:0000000000000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 00000000000000c0 CR3: 000000004b75c000 CR4: 0000000000350ef0 Call Trace: <TASK> iommufd_fops_ioctl+0x287/0x400 drivers/iommu/iommufd/main.c:533 vfs_ioctl fs/ioctl.c:51 [inline] __do_sys_ioctl fs/ioctl.c:597 [inline] __se_sys_ioctl fs/ioctl.c:583 [inline] __x64_sys_ioctl+0x120/0x170 fs/ioctl.c:583 x64_sys_call+0x1092/0x1fb0 arch/x86/include/generated/asm/syscalls_64.h:17 do_syscall_x64 arch/x86/entry/syscall_64.c:63 [inline] do_syscall_64+0x10a/0x680 arch/x86/entry/syscall_64.c:94 entry_SYSCALL_64_after_hwframe+0x77/0x7f RIP: 0033:0x7f4aec1a82bd Code: ff c3 66 2e 0f 1f 84 00 00 00 00 00 90 f3 0f 1e fa 48 89 f8 48 89 f7 48 89 d6 48 89 ca 4d 89 c2 4d 89 c8 4c 8b 4c 24 08 0f 05 <48> 3d 01 f0 ff ff 73 01 c3 48 c7 c1 b0 ff ff ff f7 d8 64 89 01 48 RSP: 002b:00007f4aea3f6018 EFLAGS: 00000246 ORIG_RAX: 0000000000000010 RAX: ffffffffffffffda RBX: 00007f4aec436090 RCX: 00007f4aec1a82bd RDX: 0000200000000180 RSI: 0000000000003b92 RDI: 0000000000000003 RBP: 00007f4aec250295 R08: 0000000000000000 R09: 0000000000000000 R10: 0000000000000000 R11: 0000000000000246 R12: 0000000000000000 R13: 00007f4aec436128 R14: 00007f4aec436090 R15: 00007ffd04ef23e0 </TASK> Modules linked in: CR2: 00000000000000c0 ---[ end trace 0000000000000000 ]--- RIP: 0010:iommufd_ioas_change_process+0x419/0xd50 drivers/iommu/iommufd/ioas.c:538 Code: 48 89 c3 48 85 c0 0f 84 cc 00 00 00 e8 10 f5 cb fd 48 8d 7b 68 e8 a7 b5 eb fd 48 8b 6b 68 48 8d bd c0 00 00 00 e8 17 b2 eb fd <8b> ad c0 00 00 00 bf 01 00 00 00 89 ee e8 85 ef cb fd 83 fd 01 74 RSP: 0018:ffffc90015c17d28 EFLAGS: 00010246 RAX: ffff8880186d5328 RBX: ffff88801d25e240 RCX: 0000000080000000 RDX: 00000000000002d7 RSI: ffffffff83ba9e10 RDI: 00000000000000c0 RBP: 0000000000000000 R08: ffffffff8e781eb8 R09: 0000000000000000 R10: 00000000000000c0 R11: ffffffff83ba9e29 R12: ffff88802e216008 R13: ffff88802e216000 R14: 0000000000000001 R15: 0000000000000000 FS: 00007f4aea3f66c0(0000) GS:ffff8880b1fa1000(0000) knlGS:0000000000000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 00000000000000c0 CR3: 000000004b75c000 CR4: 0000000000350ef0 ---------------- Code disassembly (best guess): 0: 48 89 c3 mov %rax,%rbx 3: 48 85 c0 test %rax,%rax 6: 0f 84 cc 00 00 00 je 0xd8 c: e8 10 f5 cb fd call 0xfdcbf521 11: 48 8d 7b 68 lea 0x68(%rbx),%rdi 15: e8 a7 b5 eb fd call 0xfdebb5c1 1a: 48 8b 6b 68 mov 0x68(%rbx),%rbp 1e: 48 8d bd c0 00 00 00 lea 0xc0(%rbp),%rdi 25: e8 17 b2 eb fd call 0xfdebb241 * 2a: 8b ad c0 00 00 00 mov 0xc0(%rbp),%ebp <-- trapping instruction 30: bf 01 00 00 00 mov $0x1,%edi 35: 89 ee mov %ebp,%esi 37: e8 85 ef cb fd call 0xfdcbefc1 3c: 83 fd 01 cmp $0x1,%ebp 3f: 74 .byte 0x74
Fix by mirroring the handling logic in iopt_unmap_iova_range(), i.e. return -EBUSY if area->pages is NULL.
--- drivers/iommu/iommufd/ioas.c | 4 ++++ 1 file changed, 4 insertions(+)
drivers/iommu/iommufd/ioas.c +4 -0
@@ -541,6 +541,10 @@ int iommufd_ioas_change_process(struct ireturn rc;for_each_ioas_area (&ioas_list, index, ioas, area) { +if (!area->pages) { + rc = -EBUSY ; + goto out; + }if (area->pages->type !=IOPT_ADDRESS_FILE ) { rc = -EINVAL ; goto out;
Greg Kroah-Hartman
maintainerPATCH 12/94 ALSA: FCP: Use a private URB for the notification endpoint
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Geoffrey D. Bennett <[email protected]>
commit 918b8d231c571c50a00efe92ffc8404a537a0490 upstream.
fcp_init_notify() used mixer->urb, which snd_usb_mixer_status_create() allocates for the optional UAC2 status interrupt endpoint and mixer.c kills, resubmits and frees. On a device with that endpoint, fcp_init_notify()'s "already set up" early return fires on the status URB and returns success without doing anything. No FCP notification URB is submitted, and cmd_done is left zeroed because it is initialised past that early return and nowhere else. fcp_init() then issues init1_opcode and wait_for_completion_timeout() would crash adding to the zeroed wait.head. fcp_cleanup_urb() would also kill and free mixer.c's status URB.
Use a separate URB in fcp_data, and initialise cmd_done in fcp_init_private() where fcp_data is allocated. fcp_init_notify() is reached again after suspend via fcp_reinit(), and the URB kill path in fcp_notify() completes cmd_done, leaving a stale count that would satisfy the next command's wait before the device ACKs. Use reinit_completion() to clear it.
--- sound/usb/fcp.c | 38 +++++++++++++++++++++----------------- 1 file changed, 21 insertions(+), 17 deletions(-)
sound/usb/fcp.c +21 -17
@@ -82,6 +82,7 @@ struct fcp_data {struct mutex mutex;/* serialise access to the device */ struct completion cmd_done;/* wait for command completion */ struct file *file;/* hwdep file */ +struct urb *urb;/* FCP notification endpoint */ struct fcp_notify notify;
@@ -194,7 +195,7 @@ static int fcp_usb(struct usb_mixer_inteconst int max_retries =5 ;int err; -if (!mixer->urb) +if (!private->urb)return -ENODEV ; req =kmalloc (req_buf_size,GFP_KERNEL );
@@ -307,7 +308,7 @@ static int fcp_reinit(struct usb_mixer_i void *step0_resp __free(kfree) = NULL; void *step2_resp __free(kfree) = NULL; -if (mixer->urb) +if (private->urb)return 0 ; step0_resp =kmalloc (private->step0_resp_size,GFP_KERNEL );
@@ -901,13 +902,15 @@ static int fcp_hwdep_init(struct usb_mixstatic void fcp_cleanup_urb (struct usb_mixer_interface *mixer) { -if (!mixer->urb) +struct fcp_data *private = mixer->private_data; + +if (!private->urb)return ; -usb_kill_urb (mixer->urb); -kfree (mixer->urb->transfer_buffer); -usb_free_urb (mixer->urb); - mixer->urb =NULL ; +usb_kill_urb (private->urb); +kfree (private->urb->transfer_buffer); +usb_free_urb (private->urb); + private->urb =NULL ; }static void fcp_private_free (struct usb_mixer_interface *mixer)
@@ -978,37 +981,37 @@ static int fcp_init_notify(struct usb_miint err;/* Already set up */ -if (mixer->urb) +if (private->urb)return 0 ;if (usb_pipe_type_check (dev, pipe))return -EINVAL ; - mixer->urb =usb_alloc_urb (0 ,GFP_KERNEL ); -if (!mixer->urb) + private->urb =usb_alloc_urb (0 ,GFP_KERNEL ); +if (!private->urb)return -ENOMEM ; transfer_buffer =kmalloc (private->wMaxPacketSize,GFP_KERNEL );if (!transfer_buffer) { -usb_free_urb (mixer->urb); - mixer->urb =NULL ; +usb_free_urb (private->urb); + private->urb =NULL ;return -ENOMEM ; } -usb_fill_int_urb (mixer->urb, dev, pipe, +usb_fill_int_urb (private->urb, dev, pipe, transfer_buffer, private->wMaxPacketSize, fcp_notify, mixer, private->bInterval); -init_completion (&private->cmd_done); +reinit_completion (&private->cmd_done); - err =usb_submit_urb (mixer->urb,GFP_KERNEL ); + err =usb_submit_urb (private->urb,GFP_KERNEL );if (err) {usb_audio_err (mixer->chip,"%s: usb_submit_urb failed: %d\n" , __func__, err);kfree (transfer_buffer); -usb_free_urb (mixer->urb); - mixer->urb =NULL ; +usb_free_urb (private->urb); + private->urb =NULL ; }return err;
@@ -1059,6 +1062,7 @@ static int fcp_init_private(struct usb_mreturn -ENOMEM ;mutex_init (&private->mutex); +init_completion (&private->cmd_done);init_waitqueue_head (&private->notify.queue);spin_lock_init (&private->notify.lock);
Greg Kroah-Hartman
maintainerPATCH 13/94 ALSA: scarlett2: Use a private URB for the notification endpoint
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Geoffrey D. Bennett <[email protected]>
commit cd17d6ff7b7d2b1dd9bcc80ae7b4a83773f918c6 upstream.
scarlett2_init_notify() used mixer->urb, which snd_usb_mixer_status_create() allocates for the UAC2 status interrupt endpoint and mixer.c manages. On a device with that endpoint, the "already in use" check fires on the status URB and returns 0 for success without doing anything. No notification URB is submitted, and cmd_done is left zeroed because it is initialised past that check and nowhere else. scarlett2_usb_init() then issues SCARLETT2_USB_INIT_1 and wait_for_completion_timeout() would crash adding to the zeroed wait.head.
Use a separate URB in scarlett2_data, as done for FCP, and initialise cmd_done in scarlett2_init_private(). mixer.c was also freeing the URB in snd_usb_mixer_free() and resubmitting it in snd_usb_mixer_activate(), so scarlett2 must now do both: add scarlett2_cleanup_urb(), called from private_free and private_suspend, and a private_resume callback to re-establish the URB after resume. scarlett2_init_notify() is reached from there, and the URB kill path in scarlett2_notify() completes cmd_done, leaving a stale count that would satisfy the next command's wait before the device ACKs. Use reinit_completion() to clear it.
Also free the URB if the transfer buffer allocation fails, and both if usb_submit_urb() fails. Move scarlett2_init_notify() up next to scarlett2_cleanup_urb() so scarlett2_init_private() can reference it without a forward declaration.
--- sound/usb/mixer.c | 6 ++ sound/usb/mixer.h | 2 sound/usb/mixer_scarlett2.c | 98 ++++++++++++++++++++++++++++---------------- 3 files changed, 71 insertions(+), 35 deletions(-)
sound/usb/mixer.c +6 -0
@@ -3743,6 +3743,12 @@ int snd_usb_mixer_resume(struct usb_mixestruct usb_mixer_elem_list *list;int id, err; +if (mixer->private_resume) { + err = mixer->private_resume (mixer); +if (err <0 ) +return err; + } +/* restore cached mixer values */ for (id =0 ; id <MAX_ID_ELEMS ; id++) {for_each_mixer_elem (list, mixer, id) {
sound/usb/mixer.h +2 -0
@@ -18,6 +18,7 @@ struct usb_mixer_interface {struct usb_host_interface *hostif;struct list_head list;unsigned int ignore_ctl_error; +/* UAC2 status interrupt endpoint; owned by mixer.c */ struct urb *urb;/* array[MAX_ID_ELEMS], indexed by unit id */ struct usb_mixer_elem_list **id_elems;
@@ -42,6 +43,7 @@ struct usb_mixer_interface {void *private_data;void (*private_free)(struct usb_mixer_interface *mixer);void (*private_suspend)(struct usb_mixer_interface *mixer); +int (*private_resume)(struct usb_mixer_interface *mixer); };#define MAX_CHANNELS 16/* max logical channels */
sound/usb/mixer_scarlett2.c +63 -35
139 lines not on this page · raw message
Greg Kroah-Hartman
maintainerPATCH 14/94 rndis_host: add overflow check in rndis_rx_fixup()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Griffin Kroah-Hartman <[email protected]>
commit 965a251f23ff69cfb4486974d4532e9bb551c7fc upstream.
Add an overflow check to ensure that data_offset + data_len + 8 does not wrap, which would enable an OOB read of the USB data buffer.
--- drivers/net/usb/rndis_host.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)
drivers/net/usb/rndis_host.c +5 -1
@@ -14,6 +14,7 @@#include <linux/usb/cdc.h> #include <linux/usb/usbnet.h> #include <linux/usb/rndis_host.h> +#include <linux/overflow.h> /*
@@ -506,6 +507,7 @@ int rndis_rx_fixup(struct usbnet *dev, sstruct rndis_data_hdr *hdr = (void *)skb->data;struct sk_buff *skb2;u32 msg_type, msg_len, data_offset, data_len; +u32 overflow_check; msg_type =le32_to_cpu (hdr->msg_type); msg_len =le32_to_cpu (hdr->msg_len);
@@ -514,7 +516,9 @@ int rndis_rx_fixup(struct usbnet *dev, s/* don't choke if we see oob, per-packet data, etc */ if (unlikely (msg_type !=RNDIS_MSG_PACKET || skb->len < msg_len - || (data_offset + data_len +8 ) > msg_len)) { + || (data_offset + data_len +8 ) > msg_len + ||check_add_overflow (data_offset, data_len, &overflow_check) + ||check_add_overflow (overflow_check,8 , &overflow_check))) { dev->net->stats.rx_frame_errors++; netdev_dbg(dev->net, "bad rndis message %d/%d/%d/%d, len %d\n", le32_to_cpu(hdr->msg_type),
Greg Kroah-Hartman
maintainerPATCH 15/94 nvmet: fix NULL pointer dereference in nvmet_execute_identify_nslist()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Guixin Liu <[email protected]>
commit 79aba4c9403419d822972d2851f2a96a2c0531cf upstream.
When a host issues an Identify command with CNS 07h (Active Namespace ID List for a specific I/O Command Set), nvmet_execute_identify_nslist() is called with match_css set. The command-set filter dereferences req->ns, but this handler never calls nvmet_req_find_ns(), so req->ns is always NULL (nvmet_req_init() resets it to NULL). As soon as an enabled namespace with an NSID greater than the requested value exists, req->ns->csi dereferences a NULL pointer and oopses.
Besides the crash, the comparison is logically wrong: to filter the list by command set it must test the command set of the namespace being iterated, not a single fixed value. Use the loop variable ns->csi.
--- drivers/nvme/target/admin-cmd.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/nvme/target/admin-cmd.c +1 -1
@@ -963,7 +963,7 @@ static void nvmet_execute_identify_nslisnvmet_for_each_enabled_ns (&ctrl->subsys->namespaces, idx, ns) {if (ns->nsid <= min_nsid)continue ; -if (match_css && req->ns->csi != req->cmd->identify.csi) +if (match_css && ns->csi != req->cmd->identify.csi)continue ; list[i++] =cpu_to_le32 (ns->nsid);if (i == buf_size /sizeof (__le32))
Greg Kroah-Hartman
maintainerPATCH 16/94 io_uring/futex: dont mark futex wake requests as inflight
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Jens Axboe <[email protected]>
commit 73e7019097473fc9f83a334ef2c6ab3343709fef upstream.
Commit 079afb081c42 ("io_uring/futex: mark wait requests as inflight") added inflight tracking to ensure that do_exit() -> io_uring_files_cancel() finds and cancels pending futex waits before the mm goes away, as a private futex wait depends on the mm private futex hash staying alive for the duration of the request. However, as io_futex_prep() is shared between FUTEX_WAIT and FUTEX_WAKE, wake requests got marked as inflight as well.
A futex wake executes fully inline at issue time and never depends on the mm staying alive after completion, hence there's no need to track it. Kill it.
--- io_uring/futex.c | 11 +++++++++++ io_uring/futex.h | 1 + io_uring/opdef.c | 2 +- 3 files changed, 13 insertions(+), 1 deletion(-)
io_uring/futex.c +11 -0
@@ -144,6 +144,17 @@ int io_futex_prep(struct io_kiocb *req, !futex_validate_input(iof->futex_flags, iof->futex_mask)) return -EINVAL; +return 0 ; +} + +int io_futex_wait_prep (struct io_kiocb *req,const struct io_uring_sqe *sqe) +{ +int ret; + + ret =io_futex_prep (req, sqe); +if (unlikely (ret)) +return ret; +/* Mark as inflight, so file exit cancelation will find it */ io_req_track_inflight (req);return 0 ;
io_uring/futex.h +1 -0
@@ -3,6 +3,7 @@#include "cancel.h" int io_futex_prep (struct io_kiocb *req,const struct io_uring_sqe *sqe); +int io_futex_wait_prep (struct io_kiocb *req,const struct io_uring_sqe *sqe);int io_futexv_prep (struct io_kiocb *req,const struct io_uring_sqe *sqe);int io_futex_wait (struct io_kiocb *req,unsigned int issue_flags);int io_futexv_wait (struct io_kiocb *req,unsigned int issue_flags);
io_uring/opdef.c +1 -1
@@ -466,7 +466,7 @@ const struct io_issue_def io_issue_defs[ }, [IORING_OP_FUTEX_WAIT] = {#if defined(CONFIG_FUTEX ) - .prep = io_futex_prep, + .prep = io_futex_wait_prep, .issue = io_futex_wait, #else .prep = io_eopnotsupp_prep,
Greg Kroah-Hartman
maintainerPATCH 17/94 ALSA: dummy: Check card index validity at probe
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Takashi Iwai <[email protected]>
commit 02442d5fe8ee365a084b055d4fa81a0c1abfc3fd upstream.
snd_dummy_probe() blindly trusts that the given devptr->id value is within the proper card index range. It's OK for the devices the driver itself creates at the module probe time, but if the device is bound manually via sysfs interface, this could be -1 as "none", and this leads to OOB access for index[] and other parameters.
Add a sanity check for the card index and warn/correct it if it's a value out of the range.
--- sound/drivers/dummy.c | 6 ++++++ 1 file changed, 6 insertions(+)
sound/drivers/dummy.c +6 -0
@@ -1017,6 +1017,12 @@ static int snd_dummy_probe(struct platfoint idx, err;int dev = devptr->id; +if (dev <0 || dev >=SNDRV_CARDS ) { +dev_warn (&devptr->dev, +"Invalid card index %d, using default 0\n" , dev); + dev =0 ; + } + err =snd_devm_card_new (&devptr->dev, index[dev], id[dev],THIS_MODULE ,sizeof (struct snd_dummy ), &card);if (err <0 )
Greg Kroah-Hartman
maintainerPATCH 18/94 io_uring/cmd: fix iovec leak when the async cmd is not recycled
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Woraphat Khiaodaeng <[email protected]>
commit bb34ae5da3365699d53a756f4c96b6ea9f8ba0c1 upstream.
An io_async_cmd carries an iovec array in ->vec.iovec, allocated when the vec has to grow and kept across recycling through ctx->cmd_cache. On two paths nothing frees it and io_clean_op()'s kfree(req->async_data) drops the io_async_cmd without it.
io_req_uring_cleanup() clears the async data flags only when io_alloc_cache_put() succeeds, and the cache holds IO_ALLOC_CACHE_MAX == 128 entries, so once it is full the put fails and the vec is left behind. An NVMe passthrough workload gets there without doing anything unusual:nvme_uring_cmd_io() returns -EIOCBQUEUED, so the io_async_cmd stays attached for the lifetime of the command and the live object count tracks the queue depth. Above 128 the puts start failing.
->cleanup is the last chance to free an inherited vec, since io_req_uring_cleanup() returns early for an io-wq issued command and is not called at all for one completed without ever being issued. But io_clean_op() calls ->cleanup only if REQ_F_NEED_CLEANUP is set, and for uring_cmd that happens only where the vec has to grow, so a command reusing a large enough cached vec never sets it. io_rw_alloc_async() and io_msg_alloc_async() flag an inherited vec for exactly this reason; io_uring_cmd_prep() does not.
Flag an inherited vec in io_uring_cmd_prep(), and free the vec when the cache put fails, as io_req_rw_cleanup() does.
The leak is invisible under KASAN, where io_alloc_cache_vec_kasan() frees the vec unconditionally.
--- io_uring/uring_cmd.c | 4 ++++ 1 file changed, 4 insertions(+)
io_uring/uring_cmd.c +4 -0
@@ -38,6 +38,8 @@ static void io_req_uring_cleanup(structif (io_alloc_cache_put (&req->ctx->cmd_cache, ac)) { ioucmd->sqe =NULL ;io_req_async_data_clear (req,REQ_F_NEED_CLEANUP ); + }else { +io_vec_free (&ac->vec); } }
@@ -212,6 +214,8 @@ int io_uring_cmd_prep(struct io_kiocb *r ac =io_uring_alloc_async_data (&req->ctx->cmd_cache, req);if (!ac)return -ENOMEM ; +if (ac->vec.iovec) + req->flags |=REQ_F_NEED_CLEANUP ; ioucmd->sqe = sqe;return 0 ; }
Greg Kroah-Hartman
maintainerPATCH 19/94 io_uring/io-wq: fix worker accounting when canceling creation callbacks
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Vishnu Razdan <[email protected]>
commit 297b5ccea4acacaa47c150f043bce695202afbf1 upstream.
create_worker_cb() reserves an io-wq worker slot only after its task-work callback runs. If the callback is canceled before then, io_worker_cancel_cb() still decrements acct->nr_workers. When an existing worker retires with its creation callback pending, that worker has already decremented the same account's worker count.
The resulting undercount permits worker creation beyond the account's configured limit. On an AST2600 OpenBMC system, an unchanged sensor daemon reached 4,291 threads with the original kernel. With an equivalent downstream fix, 25 passive samples under its normal workload showed 6-9 threads.
Decrement nr_workers only when the canceled callback is not create_worker_cb(). Continuation callbacks still release their reserved slot, and both callback types retain the existing running-count, reference-count, and create-state cleanup.
--- io_uring/io-wq.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-)
io_uring/io-wq.c +6 -3
@@ -210,9 +210,12 @@ static void io_worker_cancel_cb(struct istruct io_wq *wq = worker->wq;atomic_dec (&acct->nr_running); -raw_spin_lock (&acct->workers_lock); - acct->nr_workers--; -raw_spin_unlock (&acct->workers_lock); +/* create_worker_cb() has not reserved a worker slot yet. */ +if (worker->create_work.func != create_worker_cb) { +raw_spin_lock (&acct->workers_lock); + acct->nr_workers--; +raw_spin_unlock (&acct->workers_lock); + }io_worker_ref_put (wq);clear_bit_unlock (0 , &worker->create_state);io_worker_release (worker);
Greg Kroah-Hartman
maintainerPATCH 20/94 io_uring/rsrc: fix folio size overflow in io_vec_fill_bvec()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Ali Ahmet Memis <[email protected]>
commit 3f3a6a16bbe8bde76532d9415438f8cdef439e5d upstream.
io_vec_fill_bvec() computes the folio size with a plain int 1:
unsigned long folio_size = 1 << imu->folio_shift;
imu->folio_shift is unsigned int and comes from folio_shift() of the folio backing the registered buffer, so it can be 32 or more on a 64 bit kernel. Shifting int 1 that far is undefined, and on x86 and arm64 the count is taken modulo 32, so a shift of 34 yields 4 rather than 16G. Every other folio_shift shift in this file already uses 1UL.
The result is that the segment estimate and the fill loop disagree. io_estimate_bvec_size() sizes the bvec array with the real shift:
max_segs += (iov[i].iov_len >> shift) + 2;
so a 1M iovec on a 16G folio is charged 2 segments, while io_vec_fill_bvec() then walks the same iovec in folio_size chunks of 4 bytes and writes res_bvec[bvec_idx] a quarter of a million times, past the end of the array it was given. src_bvec is advanced once per iteration as well, so imu->bvec is read past its end at the same time. validate_fixed_range() only checks that the range is inside the registered buffer and does not bound the segment count.
Reaching it needs a folio with a shift of at least 32, which means a gigantic hugetlb page: 16G on arm64 with 64K pages, where CONT_PMD_SHIFT is 34 and hugetlb_add_hstate(CONT_PMD_SHIFT - PAGE_SHIFT) registers that size, and likewise on powerpc. x86_64 tops out at 1G, so a shift of 30, which still fits in int and is unaffected.
Use 1UL, as the rest of the file does.
--- io_uring/rsrc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
io_uring/rsrc.c +1 -1
@@ -1349,7 +1349,7 @@ static int io_vec_fill_bvec(int ddir, st struct iovec *iovec, unsigned nr_iovs, struct iou_vec *vec) { - unsigned long folio_size = 1 << imu->folio_shift; + unsigned long folio_size = 1UL << imu->folio_shift;unsigned long folio_mask = folio_size -1 ;struct bio_vec *res_bvec = vec->bvec;size_t total_len =0 ;
Greg Kroah-Hartman
maintainerPATCH 21/94 io_uring/uring_cmd: dont skip completion for a synchronous multishot cmd
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Jens Axboe <[email protected]>
commit 360941242f09437a1e07cbed9b5a96663ffeabb6 upstream.
If IORING_URING_CMD_MULTISHOT is set, io_uring_cmd() treats any non-negative return from ->uring_cmd() as the driver having taken ownership of the request and returns IOU_ISSUE_SKIP_COMPLETE. But nothing guarantees that the driver did so, and any handler that just completes the command inline and returns 0 or a positive result then leaves the request orphaned, leaking the io_kiocb, the async data, and the file reference.
The special case isn't needed. ublk returns -EIOCBQUEUED for the multishot fetch command, which is passed through as-is, and the poll driven socket timestamp command returns -EAGAIN. Kill it, a multishot handler that wants to hang on to the request must return -EIOCBQUEUED or -EAGAIN like any other command.
--- io_uring/uring_cmd.c | 4 ---- 1 file changed, 4 deletions(-)
io_uring/uring_cmd.c +0 -4
@@ -265,10 +265,6 @@ int io_uring_cmd(struct io_kiocb *req, u } ret = file->f_op->uring_cmd (ioucmd, issue_flags); -if (ioucmd->flags &IORING_URING_CMD_MULTISHOT ) { -if (ret >=0 ) -return IOU_ISSUE_SKIP_COMPLETE ; - }if (ret == -EAGAIN ) { ioucmd->flags |=IORING_URING_CMD_REISSUE ;return ret;
Greg Kroah-Hartman
maintainerPATCH 22/94 ocfs2: fix missing metadata reservation for large xattrs
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Ian Bridges <[email protected]>
commit 0cdc7dde00ec63ac714271fa8b2918d630b8da1a upstream.
[BUG]lsetxattr() panics the kernel when setting a large xattr value on a fragmented filesystem where the file already has an external xattr block.
[CAUSE]ocfs2_calc_xattr_set_need() never reserves metadata blocks for a new xattr value's extent tree when the file already has an external xattr block. The not_found path leaves meta_add at zero, so meta_ac is NULL when ocfs2_xattr_extend_allocation() runs.
A new value root has room for a single extent record. On a fragmented filesystem, the allocator cannot satisfy the xattr value in one contiguous run, so each non-contiguous run requires its own extent record. When the value root's extent list is full and meta_ac is NULL, ocfs2_add_clusters_in_btree() returns RESTART_META, and ocfs2_xattr_extend_allocation() hits BUG_ON(why == RESTART_META).
[FIX]
The case where no xattr block exists yet already calls ocfs2_extend_meta_needed(&def_xv.xv.xr_list) to reserve value tree metadata. Add the same reservation to the case where an xattr block already exists, making the two cases consistent.
Replace the BUG_ON with a -ENOSPC return so that if RESTART_META is returned despite the reservation, the error propagates to userspace instead of panicking the kernel.
--- fs/ocfs2/xattr.c | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-)
fs/ocfs2/xattr.c +12 -6
@@ -736,12 +736,10 @@ static int ocfs2_xattr_extend_allocation prev_clusters;if (why !=RESTART_NONE && clusters_to_add) { -/* -* We can only fail in case the alloc file doesn't give -* up enough clusters. -*/ -BUG_ON (why ==RESTART_META ); - +if (why ==RESTART_META ) { + status = -ENOSPC ; +break ; + } credits =ocfs2_calc_extend_credits (inode->i_sb, &vb->vb_xv->xr_list); status =ocfs2_extend_trans (handle, credits);
@@ -3211,6 +3209,14 @@ meta_guess: credits +=OCFS2_SUBALLOC_ALLOC +1 ;/* +* Reserve metadata for the new xattr's value extent tree. +* The not_found path above adds credits for this tree but +* omits meta_add, leaving meta_ac NULL for large values. +*/ +if (xi->xi_value_len >OCFS2_XATTR_INLINE_SIZE ) + meta_add +=ocfs2_extend_meta_needed (&def_xv.xv.xr_list); + +/* * This cluster will be used either for new bucket or for * new xattr block. * If the cluster size is the same as the bucket size, one
Greg Kroah-Hartman
maintainerPATCH 23/94 null_blk: fix UBSAN shift-out-of-bounds when zone_size is 0 or overflows
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Rik van Riel <[email protected]>
commit 95491fb05105b61050cb623a5e0227eb26aa3525 upstream.
null_zone_no() does sect >> ilog2(dev->zone_size_sects). When zone_size_sects is 0, ilog2(0) returns -1, producing shift exponent -1 which UBSAN reports as shift-out-of-bounds.
UBSAN: shift-out-of-bounds in drivers/block/null_blk/zoned.c:21:14 shift exponent -1 is negative Call Trace: null_zone_no drivers/block/null_blk/zoned.c:21 [inline] null_process_zoned_cmd+0xf76/0xf80 drivers/block/null_blk/zoned.c:728 null_handle_cmd drivers/block/null_blk/main.c:1455 [inline] null_queue_rq+0x8bc/0xe70 drivers/block/null_blk/main.c:1703 __blk_mq_issue_directly block/blk-mq.c:2694 [inline] blk_mq_try_issue_directly+0x3f4/0x880 block/blk-mq.c:2754 blk_mq_submit_bio+0x20c0/0x2a40 block/blk-mq.c:3208 submit_bio_noacct_nocheck+0x2f4/0xa40 block/blk-core.c:790 block_read_full_folio+0x7a6/0x810 fs/buffer.c:2463 filemap_read_folio+0x12c/0x3a0 mm/filemap.c:2510 read_part_sector+0xb6/0x2b0 block/partitions/core.c:724 adfspart_check_ICS+0xb1/0x960 block/partitions/acorn.c:357 check_partition block/partitions/core.c:143 [inline] blk_add_partitions block/partitions/core.c:591 [inline] bdev_disk_changed+0x851/0x17a0 block/partitions/core.c:695 blkdev_get_whole+0x372/0x510 block/bdev.c:751 add_disk_final block/genhd.c:412 [inline] add_disk_fwnode+0x24b/0x3a0 block/genhd.c:606 null_add_dev+0x130b/0x1d70 drivers/block/null_blk/main.c:2052 nullb_device_power_store+0x240/0x380 drivers/block/null_blk/main.c:501 configfs_write_iter+0x337/0x430 fs/configfs/file.c:229
Syzkaller triggers this by creating a zoned null_blk device via configfs. The Call Trace shows configfs_write_iter in configfs/file.c handling a write to power file, which calls nullb_device_power_store in main.c, which calls null_add_dev in main.c, which calls add_disk in genhd.c, which triggers partition scan via bdev_disk_changed in partitions/core.c.
A zoned null_blk device with zone_size 0 should not be legal. Existing code tries to reject it via is_power_of_2() check in zoned.c and !zone_size check in main.c, but syzkaller can still reach null_zone_no() with zone_size_sects 0 via two paths:
1. Direct 0 via configfs: zone_size attribute store in main.c has NULLB_DEVICE_ATTR(zone_size, ulong, NULL) with no validation callback, so echo 0 > zone_size succeeds before power store. If zoned is false at power store time, the !zone_size check in main.c is skipped, and later zoned set true leaves zone_size 0.
2. Large value overflow: mb_to_sects() in zoned.c does (sector_t)mb * SZ_1M >> SECTOR_SHIFT which is mb * 2048. If mb is 1UL << 53 (9PB), mb * 2048 overflows 64-bit to 0. The value is power-of-two so is_power_of_2() passes, but mb_to_sects() returns 0.
Check for zero zone_size explicitly in null_init_zoned_dev() in zoned.c, returning -EINVAL with "must be non-zero power-of-two". Check for zero zone_size_sects after mb_to_sects() conversion, returning -EINVAL for overflow case. Keep defensive check in null_zone_no() returning 0 for zero sectors to avoid shift out-of-bounds even if zero slips through.
This change should be safe because zone_size is set once in null_init_zoned_dev() under device lock and never changes after, and 0 is never valid for a zoned device. Returning -EINVAL at init time fails device creation early with clear error, while defensive return 0 in null_zone_no() makes zoned command fail via offline zone check. No new locking is introduced.
--- drivers/block/null_blk/zoned.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)
drivers/block/null_blk/zoned.c +8 -2
@@ -18,6 +18,8 @@ static inline sector_t mb_to_sects(unsigstatic inline unsigned int null_zone_no (struct nullb_device *dev,sector_t sect) { +if (WARN_ON_ONCE (!dev->zone_size_sects)) +return 0 ;return sect >>ilog2 (dev->zone_size_sects); }
@@ -56,8 +58,8 @@ int null_init_zoned_dev(struct nullb_devsector_t sector =0 ;unsigned int i; -if (!is_power_of_2 (dev->zone_size)) { -pr_err ("zone_size must be power-of-two\n" ); +if (!dev->zone_size || !is_power_of_2 (dev->zone_size)) { +pr_err ("zone_size must be non-zero power-of-two\n" );return -EINVAL ; }if (dev->zone_size > dev->size) {
@@ -88,6 +90,10 @@ int null_init_zoned_dev(struct nullb_dev zone_capacity_sects =mb_to_sects (dev->zone_capacity); dev_capacity_sects =mb_to_sects (dev->size); dev->zone_size_sects =mb_to_sects (dev->zone_size); +if (!dev->zone_size_sects) { +pr_err ("zone_size too large or too small, leads to zero sectors\n" ); +return -EINVAL ; + } dev->nr_zones =round_up (dev_capacity_sects, dev->zone_size_sects) >>ilog2 (dev->zone_size_sects);
Greg Kroah-Hartman
maintainerPATCH 24/94 kcov: fix data corruption and race conditions on PREEMPT_RT
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Tetsuo Handa <[email protected]>
commit 2eed77fdcb0cc48e8eccb2bcd4b7f2c6d650e84c upstream.
syzbot is reporting KCOV state corruption on PREEMPT_RT kernels, for the temporary storage used for saving/restoring remote KCOV state is currently allocated as the per-CPU area.
On PREEMPT_RT kernels, softirq handlers run as preemptible task threads (e.g., ksoftirqd). If a softirq context preempts a task running a remote KCOV session, it safely saves the task's state into the per-CPU area. However, if that softirq thread is subsequently preempted by a higher- priority softirq thread on the same CPU, the second softirq will overwrite the same per-CPU area, permanently destroying the original task's KCOV state.
Fix this data corruption by moving the temporary storage from the per-CPU area to the per-thread area. Since each softirq thread now owns its own task context, nested softirq preemption no longer causes data overwrites.
Note that while the temporary storage is now on a per-thread basis, the per-CPU kcov_percpu_data.lock must be retained, for we need to ensure that kcov_remote_start() and kcov_remote_stop() operate atomically without racing against asynchronous interrupts that manipulate the current task's KCOV state.
It is likely that GFP_KERNEL allocation by vmalloc_node() in kcov_init() has already called panic() before returning NULL, for there will be no OOM-killable userspace processes when __init function of built-in module runs. But this patch also fixes crashing the kernel when vmalloc_node() in kcov_init() returned NULL, for kcov_init() left per-CPU irq_area == NULL but kcov_remote_start() depends on per-CPU irq_area != NULL, resulting in
(1) doing vmalloc() in kcov_remote_start() despite !in_task() context
(2) out-of-array-bounds access if (1) succeeded but
kcov->remote_size < CONFIG_KCOV_IRQ_AREA_SIZE
(3) always leak memory allocated by (1), eventually killing all OOM-killable userspace processes
problems.
--- include/linux/sched.h | 8 ++++ kernel/kcov.c | 90 ++++++++++++++++++++++++++------------------------ lib/Kconfig.debug | 5 +- 3 files changed, 58 insertions(+), 45 deletions(-)
include/linux/sched.h +8 -0
@@ -1540,6 +1540,14 @@ struct task_struct {/* Collect coverage from softirq context: */ unsigned int kcov_softirq; + +/* Temporary storage for preempting remote coverage collection: */ +unsigned int kcov_saved_mode; +unsigned int kcov_saved_size; +void *kcov_saved_area; +struct kcov *kcov_saved_kcov; +int kcov_saved_sequence; +#endif #ifdef CONFIG_MEMCG_V1
kernel/kcov.c +47 -43
169 lines not on this page · raw message
lib/Kconfig.debug +3 -2
@@ -2157,10 +2157,11 @@ config KCOV_INSTRUMENT_ALL config KCOV_IRQ_AREA_SIZE hex "Size of interrupt coverage collection area in words" depends on KCOV + range 0x80 0x1000000 default 0x40000 help - KCOV uses preallocated per-cpu areas to collect coverage from - soft interrupts. This specifies the size of those areas in the + KCOV uses preallocated areas to collect coverage from soft + interrupts. This specifies the size of those areas in the number of unsigned long words. config KCOV_SELFTEST
Greg Kroah-Hartman
maintainerPATCH 25/94 ext4: stop retrying saturated xattr cache entries
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Matthias Goergens <[email protected]>
commit 54b6bd40898de7906acb2bccc9a96d1b8e6b4323 upstream.
ext4_xattr_block_set() retries when a cache entry selected for reuse has a saturated reference count after taking the buffer lock. The retry returns to the mbcache lookup without making that entry ineligible, so it can select the same unusable entry indefinitely. A task spinning there can hold the parent directory's i_rwsem and leave concurrent rmdir callers blocked.
Normally a reusable entry has a reference count below EXT4_XATTR_REFCOUNT_MAX because the count and MBE_REUSABLE_B are updated under the same buffer lock. A corrupted filesystem can violate that invariant. The syzbot reproducer reports allocator and xattr corruption before triggering this retry loop.
Check the untrusted on-disk count before incrementing it, avoiding overflow, and clear MBE_REUSABLE_B when it is already saturated. The next lookup then skips the entry that was just proven unusable. This mirrors the normal transition at EXT4_XATTR_REFCOUNT_MAX; the release path marks the entry reusable again on the exact 1024-to-1023 transition.
Using the same QEMU harness and guest parameters, current unpatched Linux hung in 6 of 8 420-second trials with the do_rmdir signature; representative NMI backtraces caught the owner spinning in ext4_xattr_block_set(). The patched kernel completed 28 of 28 trials without a hung-task report; the final twelve trials exercised the reviewed overflow-safe form of the change. syzbot's patch testing also completed without reproducing the hang.
--- fs/ext4/xattr.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
fs/ext4/xattr.c +4 -2
@@ -2075,12 +2075,13 @@ inserted:* stable so we can check the additional * reference fits. */ - ref =le32_to_cpu (BHDR (new_bh)->h_refcount) +1 ; -if (ref >EXT4_XATTR_REFCOUNT_MAX ) { + ref =le32_to_cpu (BHDR (new_bh)->h_refcount); +if (ref >=EXT4_XATTR_REFCOUNT_MAX ) {/* * Undo everything and check mbcache * again. */ +clear_bit (MBE_REUSABLE_B , &ce->e_flags);unlock_buffer (new_bh); dquot_free_block(inode, EXT4_C2B(EXT4_SB(sb),
@@ -2091,6 +2092,7 @@ inserted: new_bh =NULL ; goto inserted; } + ref++;BHDR (new_bh)->h_refcount =cpu_to_le32 (ref);if (ref ==EXT4_XATTR_REFCOUNT_MAX )clear_bit (MBE_REUSABLE_B , &ce->e_flags);
Greg Kroah-Hartman
maintainerPATCH 26/94 nilfs2: reject invalid block index in GC ioctl
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Ryusuke Konishi <[email protected]>
commit a1735eae55448bc79c2da6593455791e886f6ed8 upstream.
Syzbot reported list corruption caused by a double list_add_tail() call on bh->b_assoc_buffers within nilfs_lookup_dirty_data_buffers().
Analysis revealed that the root cause was the insertion of a page/folio with a page index of ULONG_MAX into the page cache via the GC ioctl. filemap_get_folios_tag(), called by nilfs_lookup_dirty_data_buffers(), repeatedly detects a dirty folio with a page index of ULONG_MAX due to index wrap-around, leading to duplicate processing of dirty buffers.
As a preparatory step, the GC ioctl loads the page/folio of the block to be moved during GC and inserts it into the page cache based on information in the nilfs_vdesc structure passed as an argument. Normally, this does not cause issues because the user-space GC library configures the nilfs_vdesc structure properly. However, since there is no range check on the parameters determining the page index, a request with artificially crafted parameters -- such as those generated by Syzbot -- can result in a page/folio being inserted with a page index of ULONG_MAX, triggering the above problem.
This resolves the issue by checking the ranges of 'vd_offset' and 'vd_vblocknr' in the nilfs_vdesc structure that determine the page index, thereby preventing the invalid page/folio insertions.
--- fs/nilfs2/ioctl.c | 20 ++++++++++++++++++-- 1 file changed, 18 insertions(+), 2 deletions(-)
fs/nilfs2/ioctl.c +18 -2
@@ -527,6 +527,7 @@ static int nilfs_ioctl_get_bdescs(struct* Return: 0 on success, or one of the following negative error codes on * failure: * * %-EEXIST - Block conflict detected. +* * %-EINVAL - Invalid virtual block descriptor. * * %-EIO - I/O error. * * %-ENOENT - Requested block doesn't exist. * * %-ENOMEM - Insufficient memory available.
@@ -536,15 +537,30 @@ static int nilfs_ioctl_move_inode_block( struct list_head *buffers) {struct buffer_head *bh; +__u64 limit_blkidx = (__u64 )inode->i_sb->s_maxbytes >> inode->i_blkbits;int ret; -if (vdesc->vd_flags ==0 ) +/* +* vblocknr 0 is reserved as an invalid pointer. Also, limit_blkidx +* ensures that the page index converted from vd_vblocknr never +* overflows the page cache limit and respects the architecture's bmap +* key width. +*/ +if (unlikely (vdesc->vd_vblocknr ==0 || + vdesc->vd_vblocknr >= limit_blkidx)) +return -EINVAL ; + +if (vdesc->vd_flags ==0 ) { +if (unlikely (vdesc->vd_offset >= limit_blkidx)) +return -EINVAL ; + ret =nilfs_gccache_submit_read_data ( inode, vdesc->vd_offset, vdesc->vd_blocknr, vdesc->vd_vblocknr, &bh); -else + }else { ret =nilfs_gccache_submit_read_node ( inode, vdesc->vd_blocknr, vdesc->vd_vblocknr, &bh); + }if (unlikely (ret <0 )) {if (ret == -ENOENT )
Greg Kroah-Hartman
maintainerPATCH 27/94 ext4: clear error before retrying inode xattr space fallback
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Guanghui Yang <[email protected]>
commit 409a7f12a0933ff2c617fa814c76cef0bd1d457a upstream.
When ext4_xattr_make_inode_space() returns -ENOSPC, ext4_expand_extra_isize_ea() can retry the expansion with s_min_extra_isize. If that retry succeeds by finding enough ibody free space, control jumps directly to the shift label.
The previous -ENOSPC is still stored in error in that path, so the function can update i_extra_isize but still return -ENOSPC to the caller. Clear error before retrying so a successful fallback expansion returns success.
Reproduced with an ext4 image using 1 KiB blocks, project quota support, 256-byte inodes, and min_extra_isize/want_extra_isize set to 32. FS_IOC_FSSETXATTR failures dropped from 802 to 86 after the fix.
--- fs/ext4/xattr.c | 1 + 1 file changed, 1 insertion(+)
fs/ext4/xattr.c +1 -0
@@ -2841,6 +2841,7 @@ retry: s_min_extra_isize) { tried_min_extra_isize++; new_extra_isize = s_min_extra_isize; + error =0 ; goto retry; } goto cleanup;
Greg Kroah-Hartman
maintainerPATCH 28/94 ext4: avoid tail write_begin walk for uptodate folios
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Jia Zhu <[email protected]>
commit d09811183db2891776dbf0c0f1094540e29938f6 upstream.
Ext4 buffered writes into large folios also pay a full buffer_head walk in ext4_block_write_begin(). For a small overwrite of an existing cached folio, the folio is already uptodate and the write only needs to prepare the buffers through the written range. Walking the suffix still makes the write_begin cost proportional to the folio size.
Before ext4 enabled large folios for regular files, the same loop was bounded by a single page of buffers. That commit made the existing full-folio walk visible as a regression for cached small overwrites.
The suffix walk is needed for non-uptodate folios, where ext4 may have to submit reads for partial blocks, preserve new-buffer cleanup, and run error zeroing. Keep those folios on the old full walk.
For already-uptodate folios, keep the walk starting at the first buffer rather than seeking directly to from. This preserves the existing prefix buffer state handling. Stop once block_start reaches the end of the write range, because the skipped suffix would only repeat the outside-range uptodate handling for buffers beyond @to.
On current master, the libMicro ext4 large-folio overwrite test shows the following full-series result. Results are median usecs/call over 10 runs, lower is better:
case nofix this series improvement write_u1k 1.418 0.3405 76.0% write_u10k 1.887 0.4175 77.9% pwrite_u1k 1.6775 0.3390 79.8% pwrite_u10k 1.9035 0.4130 78.3%
--- fs/ext4/inode.c | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-)
fs/ext4/inode.c +6 -5
@@ -1179,6 +1179,7 @@ int ext4_block_write_begin(handle_t *hanint nr_wait =0 ;int i;bool should_journal_data =ext4_should_journal_data (inode); +bool folio_uptodate =folio_test_uptodate (folio);BUG_ON (!folio_test_locked (folio));BUG_ON (to >folio_size (folio));
@@ -1190,13 +1191,13 @@ int ext4_block_write_begin(handle_t *han bbits =ilog2 (blocksize); block = (sector_t )folio->index << (PAGE_SHIFT - bbits); -for (bh = head, block_start =0 ; bh != head || !block_start; +for (bh = head, block_start =0 ; + block_start < to || (!folio_uptodate && bh != head); block++, block_start = block_end, bh = bh->b_this_page) { block_end = block_start + blocksize;if (block_end <= from || block_start >= to) { -if (folio_test_uptodate (folio)) { +if (folio_uptodate)set_buffer_uptodate (bh); - }continue ; }if (WARN_ON_ONCE (buffer_new (bh)))
@@ -1217,7 +1218,7 @@ int ext4_block_write_begin(handle_t *hanif (should_journal_data)do_journal_get_write_access (handle, inode, bh); -if (folio_test_uptodate (folio)) { +if (folio_uptodate) {/* * Unlike __block_write_begin() we leave * dirtying of new uptodate buffers to
@@ -1234,7 +1235,7 @@ int ext4_block_write_begin(handle_t *hancontinue ; } } -if (folio_test_uptodate (folio)) { +if (folio_uptodate) {set_buffer_uptodate (bh);continue ; }
Greg Kroah-Hartman
maintainerPATCH 29/94 ext4: propagate errors from fast commit range replay
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Guanghui Yang <[email protected]>
commit d8b8dd3530bf41e14b118702cdaf9de64bb96885 upstream.
ext4_fc_replay() stops replaying fast commit tags only when a tag handler returns a negative error. However, ext4_fc_replay_add_range() and ext4_fc_replay_del_range() currently return 0 from their common exit paths even after internal failures.
This hides errors from ext4_fc_record_modified_inode(), ext4_map_blocks(), ext4_find_extent(), ext4_ext_insert_extent(), ext4_ext_replay_update_ex(), and ext4_ext_remove_space(). As a result, a failed ADD_RANGE or DEL_RANGE replay can be treated as successful and the replay code may continue with subsequent fast commit tags.
This is particularly problematic for DEL_RANGE because it may already have marked blocks as free before ext4_ext_remove_space() fails. If the error is swallowed, replay may continue from a partially applied range operation.
Return the saved error from the common exit paths and make the ERR_PTR() cases in ADD_RANGE store PTR_ERR() before jumping to out.
--- fs/ext4/fast_commit.c | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-)
fs/ext4/fast_commit.c +12 -4
@@ -1797,8 +1797,11 @@ static int ext4_fc_replay_add_range(struif (ret ==0 ) {/* Range is not mapped */ path =ext4_find_extent (inode, cur, path,0 ); -if (IS_ERR (path)) +if (IS_ERR (path)) { + ret =PTR_ERR (path); + path =NULL ; goto out; + }memset (&newex,0 ,sizeof (newex)); newex.ee_block =cpu_to_le32 (cur); ext4_ext_store_pblock(
@@ -1810,8 +1813,11 @@ static int ext4_fc_replay_add_range(stru path =ext4_ext_insert_extent (NULL , inode, path, &newex,0 );up_write ((&EXT4_I (inode)->i_data_sem)); -if (IS_ERR (path)) +if (IS_ERR (path)) { + ret =PTR_ERR (path); + path =NULL ; goto out; + } goto next; }
@@ -1858,10 +1864,11 @@ next: }ext4_ext_replay_shrink_inode (inode,i_size_read (inode) >> sb->s_blocksize_bits); + ret =0 ; out:ext4_free_ext_path (path);iput (inode); -return 0 ; +return ret; }/* Replay DEL_RANGE tag */
@@ -1922,9 +1929,10 @@ ext4_fc_replay_del_range(struct super_blext4_ext_replay_shrink_inode (inode,i_size_read (inode) >> sb->s_blocksize_bits);ext4_mark_inode_dirty (NULL , inode); + ret =0 ; out:iput (inode); -return 0 ; +return ret; }static void ext4_fc_set_bitmaps_and_counters (struct super_block *sb)
Greg Kroah-Hartman
maintainerPATCH 30/94 ext4: dont enable DAX on new encrypted files
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Eric Biggers <[email protected]>
commit da32af420d6d466e247c43ac0b829edeac7ae0ad upstream.
Currently, when a new encrypted regular file is created, the call to ext4_set_inode_flags(inode, init=true) in __ext4_new_inode() is made before EXT4_INODE_ENCRYPT is set. As a result, it can set S_DAX if the filesystem is mounted with "-o dax=always".
EXT4_INODE_ENCRYPT then actually gets set a bit later in __ext4_new_inode(), when it calls fscrypt_set_context() which calls ext4_set_context(). ext4_set_context() sets EXT4_INODE_ENCRYPT and calls ext4_set_inode_flags(inode, init=false) to set S_ENCRYPTED too.
This was intended to clear S_DAX as well. However, this was broken by commit 043546e46dc7 ("fs/ext4: Only change S_DAX on inode load"). This causes data written to the file to bypass encryption, also causing xfstests failures such as generic/548 (when "-o dax=always" is used).
Fix this by simplifying the flow by making __ext4_new_inode() set EXT4_INODE_ENCRYPT earlier. This makes it take effect in ext4_set_inode_flags(inode, init=true), making S_DAX never be set.
Similarly, make EXT4_STATE_MAY_INLINE_DATA never be set in the first place on new encrypted inodes. Then it doesn't need to be cleared.
As a result of these simplifications, ext4_set_context() no longer needs to change inode flags or state when 'handle != NULL'. Remove that too.
--- fs/ext4/crypto.c | 40 ++++++++++++++++++++-------------------- fs/ext4/ialloc.c | 4 ++++ 2 files changed, 24 insertions(+), 20 deletions(-)
fs/ext4/crypto.c +20 -20
@@ -144,7 +144,13 @@ static int ext4_set_context(struct inodeif (inode->i_ino ==EXT4_ROOT_INO )return -EPERM ; -if (WARN_ON_ONCE (IS_DAX (inode) &&i_size_read (inode))) +/* +* For new encrypted inodes, S_DAX is never set in the first place. +* +* For existing inodes, this is called only on empty directories. ext4 +* never sets S_DAX on directories. +*/ +if (WARN_ON_ONCE (IS_DAX (inode)))return -EINVAL ;if (ext4_test_inode_flag (inode,EXT4_INODE_DAX ))
@@ -164,27 +170,24 @@ static int ext4_set_context(struct inodeif (handle) {/* +* __ext4_new_inode() should have already set the encrypt flag +* on the inode and avoided enabling inline data. +*/ +if (WARN_ON_ONCE (!IS_ENCRYPTED (inode))) +return -EINVAL ; +if (WARN_ON_ONCE (ext4_test_inode_state (inode,EXT4_STATE_MAY_INLINE_DATA ))) +return -EINVAL ; +/* * Since the inode is new it is ok to pass the * XATTR_CREATE flag. This is necessary to match the * remaining journal credits check in the set_handle * function with the credits allocated for the new * inode. */ - res =ext4_xattr_set_handle (handle, inode, -EXT4_XATTR_INDEX_ENCRYPTION , -EXT4_XATTR_NAME_ENCRYPTION_CONTEXT , - ctx, len,XATTR_CREATE ); -if (!res) { -ext4_set_inode_flag (inode,EXT4_INODE_ENCRYPT ); -ext4_clear_inode_state (inode, -EXT4_STATE_MAY_INLINE_DATA ); -/* -* Update inode->i_flags - S_ENCRYPTED will be enabled, -* S_DAX may be disabled -*/ -ext4_set_inode_flags (inode, false); - } -return res; +return ext4_xattr_set_handle (handle, inode, +EXT4_XATTR_INDEX_ENCRYPTION , +EXT4_XATTR_NAME_ENCRYPTION_CONTEXT , + ctx, len,XATTR_CREATE ); } res =dquot_initialize (inode);
@@ -205,10 +208,7 @@ retry: ctx, len, 0);if (!res) {ext4_set_inode_flag (inode,EXT4_INODE_ENCRYPT ); -/* -* Update inode->i_flags - S_ENCRYPTED will be enabled, -* S_DAX may be disabled -*/ +/* Update inode->i_flags to set S_ENCRYPTED. */ ext4_set_inode_flags (inode, false); res =ext4_mark_inode_dirty (handle, inode);if (res)
fs/ext4/ialloc.c +4 -0
@@ -995,6 +995,8 @@ struct inode *__ext4_new_inode(struct mn err =fscrypt_prepare_new_inode (dir, inode, &encrypt);if (err) goto out; +if (encrypt) + i_flags |=EXT4_ENCRYPT_FL ; } err =dquot_initialize (inode);
@@ -1304,6 +1306,8 @@ got: ei->i_extra_isize = sbi->s_want_extra_isize; ei->i_inline_off =0 ;if (ext4_has_feature_inline_data (sb) && +/* Encrypted inodes cannot have inline data */ + !(ei->i_flags &EXT4_ENCRYPT_FL ) && (!(ei->i_flags & (EXT4_DAX_FL |EXT4_EA_INODE_FL )) ||S_ISDIR (mode)))ext4_set_inode_state (inode,EXT4_STATE_MAY_INLINE_DATA ); ret = inode;
Greg Kroah-Hartman
maintainerPATCH 31/94 ext4: fix incorrect function call when initializing s_resgid
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Jiazi Liu <[email protected]>
commit c87abbab6147dcc5aa1fd8f2a61734d58d8b99ec upstream.
In __ext4_fill_super(), s_resgid is initialized by calling ext4_get_resuid() instead of ext4_get_resgid(), resulting in the reserved GID being set to the same value as the reserved UID rather than the value stored in the superblock.
--- fs/ext4/super.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/ext4/super.c +1 -1
@@ -5291,7 +5291,7 @@ static int __ext4_fill_super(struct fs_cext4_set_def_opts (sb, es); sbi->s_resuid =make_kuid (&init_user_ns,ext4_get_resuid (es)); - sbi->s_resgid =make_kgid (&init_user_ns,ext4_get_resuid (es)); + sbi->s_resgid =make_kgid (&init_user_ns,ext4_get_resgid (es)); sbi->s_commit_interval =JBD2_DEFAULT_MAX_COMMIT_AGE *HZ ; sbi->s_min_batch_time =EXT4_DEF_MIN_BATCH_TIME ; sbi->s_max_batch_time =EXT4_DEF_MAX_BATCH_TIME ;
Greg Kroah-Hartman
maintainerPATCH 32/94 xfs: validate attr entry pointer before field access
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Hongling Zeng <[email protected]>
commit b7eea80be25f3334f131d52982b3131aba77b97d upstream.
xfs_attr3_leaf_verify_entry() accesses lentry/rentry fields (namelen, valuelen) before checking if the entry pointer itself is within bounds. If nameidx is crafted to point near the end of the buffer, these field accesses can read out-of-bounds before the bounds check at name_end > buf_end is performed.
Add explicit bounds checks for entry pointers before accessing their fields. Use offsetof() to check that the start of the flexible array member (nameval/name) is within bounds, which ensures all preceding fields are safe to access.
--- fs/xfs/libxfs/xfs_attr_leaf.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
fs/xfs/libxfs/xfs_attr_leaf.c +14 -0
@@ -268,6 +268,13 @@ xfs_attr3_leaf_verify_entry(*/ if (ent->flags &XFS_ATTR_LOCAL ) { lentry =xfs_attr3_leaf_name_local (leaf, idx); + +/* Validate lentry pointer is within bounds before field access */ +if ((char *)lentry >= buf_end) +return __this_address; +if ((char *)lentry + offsetof(struct xfs_attr_leaf_name_local , nameval) > buf_end) +return __this_address; + namesize =xfs_attr_leaf_entsize_local (lentry->namelen,be16_to_cpu (lentry->valuelen)); name_end = (char *)lentry + namesize;
@@ -275,6 +282,13 @@ xfs_attr3_leaf_verify_entry(return __this_address; }else { rentry =xfs_attr3_leaf_name_remote (leaf, idx); + +/* Validate rentry pointer is within bounds before field access */ +if ((char *)rentry >= buf_end) +return __this_address; +if ((char *)rentry + offsetof(struct xfs_attr_leaf_name_remote , name) > buf_end) +return __this_address; + namesize =xfs_attr_leaf_entsize_remote (rentry->namelen); name_end = (char *)rentry + namesize;if (rentry->namelen ==0 )
Greg Kroah-Hartman
maintainerPATCH 33/94 libceph: fix OOB read in decode_watchers() via missing bounds check
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pavitra Jha <[email protected]>
[ Upstream commit 00ead17c7de137a692edee59f2772e6af687e8eb ]
ceph_start_decoding() validates that struct_len bytes remain in the buffer after the encoding header, but accepts struct_len=0 as valid:ceph_decode_need(p, end, 0, bad) always passes. When a malicious or compromised OSD sends an obj_list_watch_response_t reply with struct_len=0, ceph_start_decoding() returns success with p == end, leaving zero bytes guaranteed for subsequent reads.
The immediately following ceph_decode_32(p) in decode_watchers() has no preceding bounds check. With p == end this is a 4-byte read past the validated buffer boundary. The garbage value is then passed directly to kzalloc_objs() as the watcher count.
The sibling function decode_watcher() already uses the safe variants (ceph_decode_copy_safe, ceph_decode_64_safe, ceph_decode_skip_32) after its own ceph_start_decoding() call. decode_watchers() is the only site that uses the bare variant, confirming an oversight.
Fix by replacing ceph_decode_32(p) with ceph_decode_32_safe(p, end, *num_watchers, bad), consistent with the established pattern.
Attacker model: a malicious or compromised OSD in a multi-tenant Ceph deployment (e.g. cloud) can trigger this against any kernel client that calls CEPH_OSD_OP_LIST_WATCHERS, without any further privileges beyond OSD session establishment.
[ idryomov: trim changelog ]
--- net/ceph/osd_client.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
net/ceph/osd_client.c +4 -1
@@ -5033,7 +5033,7 @@ static int decode_watchers(void **p, voiif (ret)return ret; - *num_watchers =ceph_decode_32 (p); +ceph_decode_32_safe (p, end, *num_watchers, bad); *watchers =kcalloc (*num_watchers,sizeof (**watchers),GFP_NOIO );if (!*watchers)return -ENOMEM ;
@@ -5047,6 +5047,9 @@ static int decode_watchers(void **p, voi }return 0 ; + +bad: +return -EINVAL ; }/*
Greg Kroah-Hartman
maintainerPATCH 34/94 nfc: digital: clamp SENSF_RES length to the destination buffer
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Doruk Tan Ozturk <[email protected]>
commit 344a56d7c8e0f3cbaff0bcb1bcd95a1a1db24b16 upstream.
digital_in_recv_sensf_res() memcpy()s resp->len bytes from a remote NFC-F device response into the NFC_SENSF_RES_MAXSIZE-byte target.sensf_res field without an upper-bound check. A nearby malicious NFC-F device can send an oversized SENSF_RES response to overflow the stack-local struct nfc_target.
Clamp resp->len to NFC_SENSF_RES_MAXSIZE before the copy.
Found by 0sec automated security-research tooling (https://0sec.ai).
--- net/nfc/digital_technology.c | 2 ++ 1 file changed, 2 insertions(+)
net/nfc/digital_technology.c +2 -0
@@ -778,6 +778,8 @@ static void digital_in_recv_sensf_res(st sensf_res = (struct digital_sensf_res *)resp->data; + resp->len = min_t(unsigned int, resp->len, NFC_SENSF_RES_MAXSIZE); +memcpy (target.sensf_res, sensf_res, resp->len); target.sensf_res_len = resp->len;
Greg Kroah-Hartman
maintainerPATCH 35/94 nfc: fdp: bound the device-reported read length and fix an skb leak
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Bryam Vargas <[email protected]>
commit 7ad21dcfeb5181af0c3ee2608808c0c0a5283aa1 upstream.
fdp_nci_i2c_read() takes the next packet length from two device-supplied bytes and never validates it. The value is a u16 used as the i2c_master_recv() count into a 261-byte on-stack buffer: a malicious, counterfeit or malfunctioning controller (or an i2c bus interposer) can drive it far past the buffer for a stack out-of-bounds write that clobbers the canary and return address, or below the minimum frame size (directly, or by truncating the computed sum) so the header/LRC strip and the next length read run past a short receive. Reject a length outside [FDP_NCI_I2C_MIN_PAYLOAD, FDP_NCI_I2C_MAX_PAYLOAD], as a corrupted packet already is, and force resynchronization.
The same loop allocates one data skb per iteration and assumes a length packet followed by a data packet; a device that sends two data packets in one call leaks the first skb when the second allocation overwrites it. Free a previously allocated skb before allocating the next.
--- drivers/nfc/fdp/i2c.c | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+)
drivers/nfc/fdp/i2c.c +27 -0
@@ -166,9 +166,36 @@ static int fdp_nci_i2c_read(struct fdp_i/* Packet that contains a length */ if (tmp[0 ] ==0 && tmp[1 ] ==0 ) { phy->next_read_size = (tmp[2 ] <<8 ) + tmp[3 ] +3 ; + +/* +* next_read_size is taken from the device and is used +* as the i2c_master_recv() count for the next packet +* and as the data skb size. A value above the receive +* buffer overflows tmp[]; one below the minimum frame +* size runs the header/LRC strip and the length-field +* read past a short receive. Either way the packet is +* corrupt: drop it and force resynchronization. +*/ +if (phy->next_read_size <FDP_NCI_I2C_MIN_PAYLOAD || + phy->next_read_size >FDP_NCI_I2C_MAX_PAYLOAD ) { +dev_dbg (&client->dev,"%s: corrupted packet\n" , + __func__); + phy->next_read_size =FDP_NCI_I2C_MIN_PAYLOAD ; + goto flush; + } }else { phy->next_read_size =FDP_NCI_I2C_MIN_PAYLOAD ; +/* +* Only one data packet is delivered per call; if the +* device sends another, do not overwrite and leak the +* skb allocated for the previous one. +*/ +if (*skb) { +kfree_skb (*skb); + *skb =NULL ; + } + *skb =alloc_skb (len,GFP_KERNEL );if (*skb ==NULL ) { r = -ENOMEM ;
Greg Kroah-Hartman
maintainerPATCH 36/94 nfc: microread: validate target discovery payload lengths
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pengpeng Hou <[email protected]>
commit 25519469972ef57c3edb1805dabd6c5612b90211 upstream.
microread_target_discovered() parses target discovery payloads from skb->data according to the HCI gate. The fixed field offsets and UID copies were checked only against the destination nfc_target buffers, not against the actual skb length.
Validate that each gate-specific payload contains the fixed fields and UID bytes before reading or copying them.
--- drivers/nfc/microread/microread.c | 31 +++++++++++++++++++++++++++++-- 1 file changed, 29 insertions(+), 2 deletions(-)
drivers/nfc/microread/microread.c +29 -2
@@ -483,13 +483,19 @@ static void microread_target_discovered(switch (gate) {case MICROREAD_GATE_ID_MREAD_ISO_A : +if (skb->len <=MICROREAD_EMCF_A_LEN ) { + r = -EINVAL ; + goto exit_free; + } + targets->supported_protocols =nfc_hci_sak_to_protocol (skb->data[MICROREAD_EMCF_A_SAK ]); targets->sens_res =be16_to_cpu (*(u16 *)&skb->data[MICROREAD_EMCF_A_ATQA ]); targets->sel_res = skb->data[MICROREAD_EMCF_A_SAK ]; targets->nfcid1_len = skb->data[MICROREAD_EMCF_A_LEN ]; -if (targets->nfcid1_len >sizeof (targets->nfcid1)) { +if (targets->nfcid1_len >sizeof (targets->nfcid1) || + targets->nfcid1_len > skb->len -MICROREAD_EMCF_A_UID ) { r = -EINVAL ; goto exit_free; }
@@ -497,13 +503,19 @@ static void microread_target_discovered( targets->nfcid1_len);break ;case MICROREAD_GATE_ID_MREAD_ISO_A_3 : +if (skb->len <=MICROREAD_EMCF_A3_LEN ) { + r = -EINVAL ; + goto exit_free; + } + targets->supported_protocols =nfc_hci_sak_to_protocol (skb->data[MICROREAD_EMCF_A3_SAK ]); targets->sens_res =be16_to_cpu (*(u16 *)&skb->data[MICROREAD_EMCF_A3_ATQA ]); targets->sel_res = skb->data[MICROREAD_EMCF_A3_SAK ]; targets->nfcid1_len = skb->data[MICROREAD_EMCF_A3_LEN ]; -if (targets->nfcid1_len >sizeof (targets->nfcid1)) { +if (targets->nfcid1_len >sizeof (targets->nfcid1) || + targets->nfcid1_len > skb->len -MICROREAD_EMCF_A3_UID ) { r = -EINVAL ; goto exit_free; }
@@ -511,11 +523,21 @@ static void microread_target_discovered( targets->nfcid1_len);break ;case MICROREAD_GATE_ID_MREAD_ISO_B : +if (skb->len <MICROREAD_EMCF_B_UID +4 ) { + r = -EINVAL ; + goto exit_free; + } + targets->supported_protocols =NFC_PROTO_ISO14443_B_MASK ;memcpy (targets->nfcid1, &skb->data[MICROREAD_EMCF_B_UID ],4 ); targets->nfcid1_len =4 ;break ;case MICROREAD_GATE_ID_MREAD_NFC_T1 : +if (skb->len <MICROREAD_EMCF_T1_UID +4 ) { + r = -EINVAL ; + goto exit_free; + } + targets->supported_protocols =NFC_PROTO_JEWEL_MASK ; targets->sens_res =le16_to_cpu (*(u16 *)&skb->data[MICROREAD_EMCF_T1_ATQA ]);
@@ -523,6 +545,11 @@ static void microread_target_discovered( targets->nfcid1_len =4 ;break ;case MICROREAD_GATE_ID_MREAD_NFC_T3 : +if (skb->len <MICROREAD_EMCF_T3_UID +8 ) { + r = -EINVAL ; + goto exit_free; + } + targets->supported_protocols =NFC_PROTO_FELICA_MASK ;memcpy (targets->nfcid1, &skb->data[MICROREAD_EMCF_T3_UID ],8 ); targets->nfcid1_len =8 ;
Greg Kroah-Hartman
maintainerPATCH 37/94 nfc: llcp: bound the connect_sn TLV walk to the skb
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Doruk Tan Ozturk <[email protected]>
commit 55c68ac93e7dacc0f5f608b9c39dd4ff48cf28e8 upstream.
Commit 27256cdb290e ("nfc: llcp: bound SNL TLV parsing to the skb and add length checks") fixed the unbounded TLV walk in nfc_llcp_recv_snl(), and commit d8bd2dedbde5 ("nfc: llcp: fix OOB read and u8 offset wrap in TLV parsers") subsequently bounded nfc_llcp_parse_gb_tlv() and nfc_llcp_parse_connection_tlv(). One sibling parser sharing the same pattern remains unbounded: nfc_llcp_connect_sn().
nfc_llcp_connect_sn() walks a TLV list, reading a two-byte header (type, length) followed by length bytes of value, without checking that the two header bytes or the declared length stay within the buffer. It returns a pointer to a service name of up to 255 bytes that may point past the end of the skb; it is subsequently consumed by memcmp() in nfc_llcp_sock_from_sn(). In addition tlv_array_len was computed as "skb->len - LLCP_HEADER_SIZE" in size_t, so a CONNECT/CC frame shorter than the LLCP header underflows to a huge length and the walk runs far past the buffer.
nfc_llcp_connect_sn() is reachable from nfc_llcp_recv_connect() and nfc_llcp_recv_cc(), i.e. from received CONNECT and CC PDUs. A nearby NFC device can reach this without authentication; LLCP link activation happens automatically after NFC-DEP, and the nfc_llcp_rx_skb() dispatcher applies no minimum-length guard.
Walk the TLV list by pointer, bounded by skb_tail_pointer(skb), and validate each declared length before use, matching the approach already used for nfc_llcp_recv_snl(). Starting the walk at &skb->data[LLCP_HEADER_SIZE] against the tail pointer also removes the size_t underflow for short frames.
Found by 0sec automated security-research tooling (https://0sec.ai).
--- net/nfc/llcp_core.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-)
net/nfc/llcp_core.c +6 -4
@@ -849,13 +849,16 @@ static struct nfc_llcp_sock *nfc_llcp_sostatic const u8 *nfc_llcp_connect_sn (const struct sk_buff *skb,size_t *sn_len) {u8 type, length; -const u8 *tlv = &skb->data[2 ]; -size_t tlv_array_len = skb->len -LLCP_HEADER_SIZE , offset =0 ; +const u8 *tlv = &skb->data[LLCP_HEADER_SIZE ]; +const u8 *tlv_end =skb_tail_pointer (skb); -while (offset < tlv_array_len) { +while (tlv +2 < tlv_end) { type = tlv[0 ]; length = tlv[1 ]; +if (tlv +2 + length > tlv_end) +break ; +pr_debug ("type 0x%x length %d\n" , type, length);if (type ==LLCP_TLV_SN ) {
@@ -863,7 +866,6 @@ static const u8 *nfc_llcp_connect_sn(conreturn &tlv[2 ]; } - offset += length +2 ; tlv += length +2 ; }
Greg Kroah-Hartman
maintainerPATCH 38/94 nfc: llcp: fix OOB read and u8 offset wrap in TLV parsers
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Muhammad Bilal <[email protected]>
commit 78b20c8eeacd2e44a2d8a4cb5316d3c521d90911 upstream.
nfc_llcp_parse_gb_tlv() and nfc_llcp_parse_connection_tlv() contain three related bugs in their TLV parsing loops:
1. 'offset' is declared u8 but tlv_array_len is u16. When TLV data advances offset past 255 it silently wraps to zero, causing infinite loops or double-processing of buffer data.
2. Before reading tlv[0] (type) and tlv[1] (length) there is no check that offset+2 <= tlv_array_len. A truncated TLV causes an OOB read of one byte past the buffer end.
3. After reading the length field, the value bytes are accessed without checking offset+2+length <= tlv_array_len. A crafted length=0xFF on a short buffer causes up to 255 bytes of OOB read past the buffer end.
Both functions are reachable without authentication via nfc_llcp_set_remote_gb() which feeds remote LLCP general bytes directly into nfc_llcp_parse_gb_tlv() with no additional validation.
Fix all three issues by widening offset from u8 to u16 and adding bounds checks for both the TLV header and value field before each access.
--- net/nfc/llcp_commands.c | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-)
net/nfc/llcp_commands.c +16 -2
@@ -193,7 +193,8 @@ int nfc_llcp_parse_gb_tlv(struct nfc_llc const u8 *tlv_array, u16 tlv_array_len) { const u8 *tlv = tlv_array; -u8 type, length, offset =0 ; +u8 type, length; +u16 offset =0 ;pr_debug ("TLV array length %d\n" , tlv_array_len);
@@ -201,9 +202,15 @@ int nfc_llcp_parse_gb_tlv(struct nfc_llcreturn -ENODEV ;while (offset < tlv_array_len) { +if (offset +2 > tlv_array_len) +return -EINVAL ; + type = tlv[0 ]; length = tlv[1 ]; +if (offset +2 + length > tlv_array_len) +return -EINVAL ; +pr_debug ("type 0x%x length %d\n" , type, length);switch (type) {
@@ -243,7 +250,8 @@ int nfc_llcp_parse_connection_tlv(struct const u8 *tlv_array, u16 tlv_array_len) { const u8 *tlv = tlv_array; -u8 type, length, offset =0 ; +u8 type, length; +u16 offset =0 ;pr_debug ("TLV array length %d\n" , tlv_array_len);
@@ -251,9 +259,15 @@ int nfc_llcp_parse_connection_tlv(structreturn -ENOTCONN ;while (offset < tlv_array_len) { +if (offset +2 > tlv_array_len) +return -EINVAL ; + type = tlv[0 ]; length = tlv[1 ]; +if (offset +2 + length > tlv_array_len) +return -EINVAL ; +pr_debug ("type 0x%x length %d\n" , type, length);switch (type) {
Greg Kroah-Hartman
maintainerPATCH 39/94 nfc: llcp: reject PDUs shorter than the LLCP header
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Doruk Tan Ozturk <[email protected]>
commit 95674f506c6376d6722a23144c9acd26609771ed upstream.
Every LLCP PDU begins with a two-byte header (DSAP/SSAP + PTYPE), but the receive path never checked that a frame is at least LLCP_HEADER_SIZE bytes before parsing it.
nfc_llcp_rx_skb() reads the header via nfc_llcp_ptype()/nfc_llcp_dsap()/ nfc_llcp_ssap(), which dereference pdu->data[0] and pdu->data[1], and a CONNECT or CC PDU then computes
tlv_array_len = skb->len - LLCP_HEADER_SIZE;
as a size_t and hands it to the TLV walk. When the frame is shorter than the header the subtraction wraps to a huge value and the walk runs far past the buffer, an out-of-bounds read.
A nearby NFC device can reach this without authentication; LLCP link activation happens automatically after NFC-DEP.
Guard the common receive choke point __nfc_llcp_recv(), shared by both the target (nfc_llcp_data_received()) and initiator (nfc_llcp_recv()) paths, so a short skb is dropped before the rx_work worker parses it. Use pskb_may_pull() rather than a skb->len test so the two header bytes are guaranteed to sit in the skb linear area even for a non-linear skb, matching how the sibling NCI and HCI receive paths validate their headers.
Reproduced with a KFENCE out-of-bounds read via /dev/virtual_nci on linux-next.
Found by 0sec automated security-research tooling (https://0sec.ai).
--- net/nfc/llcp_core.c | 5 +++++ 1 file changed, 5 insertions(+)
net/nfc/llcp_core.c +5 -0
@@ -1554,6 +1554,11 @@ static void nfc_llcp_rx_work(struct workstatic void __nfc_llcp_recv (struct nfc_llcp_local *local,struct sk_buff *skb) { +if (!pskb_may_pull (skb,LLCP_HEADER_SIZE )) { +kfree_skb (skb); +return ; + } + local->rx_pending = skb;timer_delete (&local->link_timer);schedule_work (&local->rx_work);
Greg Kroah-Hartman
maintainerPATCH 40/94 nfc: pn533: purge fragmented skbs during cleanup
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Xu Rao <[email protected]>
commit 5718fc62198c38c2de5316020a90506f9e75e0bb upstream.
pn53x_common_clean() purges resp_q before freeing the common PN533 state, but it leaves fragment_skb untouched. The fragmentation helpers queue transmit fragments there while sending large initiator or target-mode frames, and those skbs remain owned by the driver until they are sent or discarded.
If the device is removed while fragments are still queued, the common cleanup path frees the PN533 state without releasing the queued fragment skbs, leaking them.
Purge fragment_skb during cleanup alongside resp_q.
--- drivers/nfc/pn533/pn533.c | 1 + 1 file changed, 1 insertion(+)
drivers/nfc/pn533/pn533.c +1 -0
@@ -2799,6 +2799,7 @@ void pn53x_common_clean(struct pn533 *prdestroy_workqueue (priv->wq);skb_queue_purge (&priv->resp_q); +skb_queue_purge (&priv->fragment_skb);list_for_each_entry_safe (cmd, n, &priv->cmd_queue, queue) {list_del (&cmd->queue);
Greg Kroah-Hartman
maintainerPATCH 41/94 nfc: st21nfca: validate ATR_REQ length against the received frame
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Doruk Tan Ozturk <[email protected]>
commit 5cdcca5d62a66eda6b774110a44cba67bc1a8d1d upstream.
st21nfca_tm_recv_atr_req() checks that the received ATR_REQ frame is at least ST21NFCA_ATR_REQ_MIN_SIZE and that the self-declared atr_req->length is at least sizeof(struct st21nfca_atr_req), but never checks that atr_req->length does not exceed the actual received length (skb->len).
st21nfca_tm_send_atr_res() then trusts the declared length:
gb_len = atr_req->length - sizeof(struct st21nfca_atr_req); ... memcpy(atr_res->gbi, atr_req->gbi, gb_len);
so an RF peer that sends a short frame but sets atr_req->length larger than the frame makes gb_len exceed the general bytes actually present, and the memcpy reads out of bounds past the received skb. Those bytes are placed in the ATR_RES and sent back to the peer (kernel-memory disclosure to a proximity attacker); a larger declared length is an out-of-bounds read (DoS).
Reject frames whose declared length exceeds the received length. The adjacent nfc_tm_activated() path in the same function already derives its general-bytes length from skb->len rather than the declared field.
Found by 0sec (https://0sec.ai) using automated source analysis; the missing bound is evident from source. Compile-tested.
--- drivers/nfc/st21nfca/dep.c | 3 +++ 1 file changed, 3 insertions(+)
drivers/nfc/st21nfca/dep.c +3 -0
@@ -205,6 +205,9 @@ static int st21nfca_tm_recv_atr_req(struif (atr_req->length <sizeof (struct st21nfca_atr_req ))return -EPROTO ; +if (atr_req->length > skb->len) +return -EPROTO ; + r =st21nfca_tm_send_atr_res (hdev, atr_req);if (r)return r;
Greg Kroah-Hartman
maintainerPATCH 42/94 nfc: nci: add data_len bound checks to activation parameter extractors
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Bryam Vargas <[email protected]>
commit 0428fa2c22e2ba0cff766d3b80d461e149102045 upstream.
nci_extract_activation_params_iso_dep() and nci_extract_activation_params_nfc_dep() read an inner length byte from the NCI RF_INTF_ACTIVATED_NTF payload and use it to memcpy() into fixed kernel buffers, but neither function receives the caller-validated activation_params_len. A crafted NCI notification with activation_params_len=1 and an inner length byte of up to 20 (NFC-A) or 50 (NFC-B) causes memcpy() to read that many bytes past the one valid byte in the activation params region -- a slab out-of-bounds read of kernel memory adjacent to the NCI skb.
The sibling nci_extract_rf_params_*() family was given equivalent protection by commit 571dcbeb8e63 ("net: nfc: nci: Fix parameter validation for packet data"), but the two activation parameter extractors were not updated at that time.
Add a data_len parameter to both functions, guard against an empty region before consuming the inner length byte, decrement the remaining count after consuming it, and clamp the copy length to what is actually available. Update both call sites to pass ntf.activation_params_len, which is already validated against the skb at ntf.c:801.
--- net/nfc/nci/ntf.c | 26 ++++++++++++++++++++++---- 1 file changed, 22 insertions(+), 4 deletions(-)
net/nfc/nci/ntf.c +22 -4
@@ -525,15 +525,19 @@ static int nci_rf_discover_ntf_packet(ststatic int nci_extract_activation_params_iso_dep (struct nci_dev *ndev,struct nci_rf_intf_activated_ntf *ntf, -const __u8 *data) +const __u8 *data,__u8 data_len) {struct activation_params_nfca_poll_iso_dep *nfca_poll;struct activation_params_nfcb_poll_iso_dep *nfcb_poll;switch (ntf->activation_rf_tech_and_mode) {case NCI_NFC_A_PASSIVE_POLL_MODE : +if (data_len <1 ) +return NCI_STATUS_RF_PROTOCOL_ERROR ; nfca_poll = &ntf->activation_params.nfca_poll_iso_dep; nfca_poll->rats_res_len =min_t (__u8, *data++,NFC_ATS_MAXSIZE ); + data_len--; + nfca_poll->rats_res_len =min_t (__u8, nfca_poll->rats_res_len, data_len);pr_debug ("rats_res_len %d\n" , nfca_poll->rats_res_len);if (nfca_poll->rats_res_len >0 ) { memcpy(nfca_poll->rats_res,
@@ -542,8 +546,12 @@ static int nci_extract_activation_paramsbreak ;case NCI_NFC_B_PASSIVE_POLL_MODE : +if (data_len <1 ) +return NCI_STATUS_RF_PROTOCOL_ERROR ; nfcb_poll = &ntf->activation_params.nfcb_poll_iso_dep; nfcb_poll->attrib_res_len =min_t (__u8, *data++,50 ); + data_len--; + nfcb_poll->attrib_res_len =min_t (__u8, nfcb_poll->attrib_res_len, data_len);pr_debug ("attrib_res_len %d\n" , nfcb_poll->attrib_res_len);if (nfcb_poll->attrib_res_len >0 ) { memcpy(nfcb_poll->attrib_res,
@@ -562,7 +570,7 @@ static int nci_extract_activation_paramsstatic int nci_extract_activation_params_nfc_dep (struct nci_dev *ndev,struct nci_rf_intf_activated_ntf *ntf, -const __u8 *data) +const __u8 *data,__u8 data_len) {struct activation_params_poll_nfc_dep *poll;struct activation_params_listen_nfc_dep *listen;
@@ -570,9 +578,13 @@ static int nci_extract_activation_paramsswitch (ntf->activation_rf_tech_and_mode) {case NCI_NFC_A_PASSIVE_POLL_MODE :case NCI_NFC_F_PASSIVE_POLL_MODE : +if (data_len <1 ) +return NCI_STATUS_RF_PROTOCOL_ERROR ; poll = &ntf->activation_params.poll_nfc_dep; poll->atr_res_len =min_t (__u8, *data++,NFC_ATR_RES_MAXSIZE -2 ); + data_len--; + poll->atr_res_len =min_t (__u8, poll->atr_res_len, data_len);pr_debug ("atr_res_len %d\n" , poll->atr_res_len);if (poll->atr_res_len >0 )memcpy (poll->atr_res, data, poll->atr_res_len);
@@ -580,9 +592,13 @@ static int nci_extract_activation_paramscase NCI_NFC_A_PASSIVE_LISTEN_MODE :case NCI_NFC_F_PASSIVE_LISTEN_MODE : +if (data_len <1 ) +return NCI_STATUS_RF_PROTOCOL_ERROR ; listen = &ntf->activation_params.listen_nfc_dep; listen->atr_req_len =min_t (__u8, *data++,NFC_ATR_REQ_MAXSIZE -2 ); + data_len--; + listen->atr_req_len =min_t (__u8, listen->atr_req_len, data_len);pr_debug ("atr_req_len %d\n" , listen->atr_req_len);if (listen->atr_req_len >0 )memcpy (listen->atr_req, data, listen->atr_req_len);
@@ -806,12 +822,14 @@ static int nci_rf_intf_activated_ntf_pacswitch (ntf.rf_interface) {case NCI_RF_INTERFACE_ISO_DEP : err =nci_extract_activation_params_iso_dep (ndev, - &ntf, data); + &ntf, data, + ntf.activation_params_len);break ;case NCI_RF_INTERFACE_NFC_DEP : err =nci_extract_activation_params_nfc_dep (ndev, - &ntf, data); + &ntf, data, + ntf.activation_params_len);break ;case NCI_RF_INTERFACE_FRAME :
Greg Kroah-Hartman
maintainerPATCH 43/94 nfc: nci: fix out-of-bounds write in nci_target_auto_activated()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Samuel Page <[email protected]>
commit ac200079db50af81e6b04d058b33ec92901d8edd upstream.
nci_target_auto_activated() appends a target to the fixed-size array ndev->targets[NCI_MAX_DISCOVERED_TARGETS] and increments ndev->n_targets without first checking the array is full; unlike its sibling nci_add_new_target(), which bails out when n_targets already equals NCI_MAX_DISCOVERED_TARGETS.
ndev->n_targets is only cleared by nci_clear_target_list(), so an NFCC that repeatedly re-runs discovery (RF_DISCOVER_RSP, which re-enters NCI_DISCOVERY without clearing the target list) and reports an auto-activated target (RF_INTF_ACTIVATED_NTF) drives n_targets past the limit. The append then writes a struct nfc_target past the end of the array (a slab out-of-bounds write), and nfc_targets_found() goes on to walk the array with the inflated count:
BUG: KASAN: slab-out-of-bounds in nci_add_new_protocol+0x94/0x2ac [nci] Write of size 2 at addr ffff0000c7299a18 by task kworker/u8:0/12 Workqueue: nfc0_nci_rx_wq nci_rx_work [nci] Call trace: nci_add_new_protocol+0x94/0x2ac [nci] nci_ntf_packet+0xddc/0x11a0 [nci] nci_rx_work+0x15c/0x1e0 [nci] process_one_work+0x2dc/0x500 worker_thread+0x240/0x460 kthread+0x1c0/0x1d0 ret_from_fork+0x10/0x20 The buggy address belongs to the cache kmalloc-2k of size 2048 The buggy address is located 1024 bytes to the right of allocated 1560-byte region [ffff0000c7299000, ffff0000c7299618)
Guard nci_target_auto_activated() with the same check used by nci_add_new_target().
--- net/nfc/nci/ntf.c | 6 ++++++ 1 file changed, 6 insertions(+)
net/nfc/nci/ntf.c +6 -0
@@ -619,6 +619,12 @@ static void nci_target_auto_activated(ststruct nfc_target *target;int rc; +/* This is a new target, check if we've enough room */ +if (ndev->n_targets ==NCI_MAX_DISCOVERED_TARGETS ) { +pr_debug ("not enough room, ignoring new target...\n" ); +return ; + } + target = &ndev->targets[ndev->n_targets]; rc = nci_add_new_protocol(ndev, target, ntf->rf_protocol,
Greg Kroah-Hartman
maintainerPATCH 44/94 nfc: nci: fix uninit-value in the RF discover/activated NTF handlers
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Samuel Page <[email protected]>
commit 8cbe06c1e699c0a165dae5093a2550e65f914818 upstream.
nci_rf_discover_ntf_packet() and nci_rf_intf_activated_ntf_packet() each parse a notification into an on-stack struct (nci_rf_discover_ntf / nci_rf_intf_activated_ntf) that is not initialised. The RF technology-specific parameters are only extracted when rf_tech_specific_params_len is non-zero, so a notification that reports a zero length leaves the rf_tech_specific_params union uninitialised - and both handlers then pass it to nci_add_new_protocol(), which reads it:
- discover: nci_add_new_target() -> nci_add_new_protocol();
- activated: nci_target_auto_activated() -> nci_add_new_protocol().
nci_add_new_protocol() uses nfca_poll->nfcid1_len as both a branch condition and a memcpy() length and copies nfcid1/sens_res/sel_res into ndev->targets, which is later exposed to user space via NFC_CMD_GET_TARGET.
BUG: KMSAN: uninit-value in nci_add_new_protocol+0x624/0x6c0 nci_add_new_protocol+0x624/0x6c0 nci_ntf_packet+0x25b2/0x3c30 nci_rx_work+0x318/0x5d0 process_scheduled_works+0x84b/0x17a0 worker_thread+0xc10/0x11b0 kthread+0x376/0x500 Local variable ntf.i created at: nci_ntf_packet+0xbc2/0x3c30
Zero-initialise both on-stack notifications so the union reads back as zero when no technology-specific parameters are present.
--- net/nfc/nci/ntf.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
net/nfc/nci/ntf.c +2 -2
@@ -440,7 +440,7 @@ void nci_clear_target_list(struct nci_destatic int nci_rf_discover_ntf_packet (struct nci_dev *ndev,const struct sk_buff *skb) { -struct nci_rf_discover_ntf ntf; +struct nci_rf_discover_ntf ntf = {};const __u8 *data;bool add_target = true;
@@ -710,7 +710,7 @@ static int nci_rf_intf_activated_ntf_pac const struct sk_buff *skb) {struct nci_conn_info *conn_info; -struct nci_rf_intf_activated_ntf ntf; +struct nci_rf_intf_activated_ntf ntf = {};const __u8 *data;int err =NCI_STATUS_OK ;
Greg Kroah-Hartman
maintainerPATCH 45/94 nfc: nci: free destination parameters when closing a connection
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Linmao Li <[email protected]>
commit 2e65bafdfd3a8bba972b3d17b6a57816557530fc upstream.
When a connection is closed, nci_core_conn_close_rsp_packet() frees conn_info but not conn_info->dest_params, which is a separate devm allocation. Each connect/close cycle leaks one dest_params until the NFC device is removed. Free dest_params along with conn_info.
--- net/nfc/nci/rsp.c | 1 + 1 file changed, 1 insertion(+)
net/nfc/nci/rsp.c +1 -0
@@ -336,6 +336,7 @@ static void nci_core_conn_close_rsp_packlist_del (&conn_info->list);if (conn_info == ndev->rf_conn_info) ndev->rf_conn_info =NULL ; +devm_kfree (&ndev->nfc_dev->dev, conn_info->dest_params);devm_kfree (&ndev->nfc_dev->dev, conn_info); } }
Greg Kroah-Hartman
maintainerPATCH 46/94 drm/xe: Fix DPT allocation paths.
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Maarten Lankhorst <[email protected]>
commit fc648757908304aedbad74f74bf58192aec383db upstream.
Remove the fallback for VRAM to system memory, I tested it and that doesn't work at all, only a black screen with pipe fault errors were observed.
On systems with media GT, extra latency is added when accessing stolen memory when the GT is in MC6. Since we additionally aren't counting how much memory is used for stolen and we could in theory fill up the entire stolen area with DPT's, avoid using stolen and only use the default memory region.
Using stolen may also result in random system hangs under load.
--- drivers/gpu/drm/xe/display/xe_fb_pin.c | 32 ++++++++------------------------ 1 file changed, 8 insertions(+), 24 deletions(-)
drivers/gpu/drm/xe/display/xe_fb_pin.c +8 -24
@@ -101,30 +101,14 @@ static int __xe_pin_fb_vma_dpt(const str dpt_size =ALIGN (intel_rotation_info_size (&view->rotated) *8 ,XE_PAGE_SIZE ); -if (IS_DGFX (xe)) - dpt =xe_bo_create_pin_map_at_novm (xe, tile0, - dpt_size, ~0ull , - ttm_bo_type_kernel, -XE_BO_FLAG_VRAM0 | -XE_BO_FLAG_GGTT | -XE_BO_FLAG_PAGETABLE , - alignment, false); -else - dpt =xe_bo_create_pin_map_at_novm (xe, tile0, - dpt_size, ~0ull , - ttm_bo_type_kernel, -XE_BO_FLAG_STOLEN | -XE_BO_FLAG_GGTT | -XE_BO_FLAG_PAGETABLE , - alignment, false); -if (IS_ERR (dpt)) - dpt =xe_bo_create_pin_map_at_novm (xe, tile0, - dpt_size, ~0ull , - ttm_bo_type_kernel, -XE_BO_FLAG_SYSTEM | -XE_BO_FLAG_GGTT | -XE_BO_FLAG_PAGETABLE , - alignment, false); + dpt =xe_bo_create_pin_map_at_novm (xe, tile0, + dpt_size, ~0ull , + ttm_bo_type_kernel, +XE_BO_FLAG_VRAM_IF_DGFX (tile0) | +XE_BO_FLAG_GGTT | +XE_BO_FLAG_PAGETABLE | +XE_BO_FLAG_SCANOUT , + alignment, false);if (IS_ERR (dpt))return PTR_ERR (dpt);
Greg Kroah-Hartman
maintainerPATCH 47/94 ipv4: reject undersized MTUs in ip_do_fragment()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Yong Wang <[email protected]>
commit c0726f0caf8c6b3208552949e17d23634a2f3129 upstream.
ip_do_fragment() subtracts the IPv4 header length from the effective MTU and passes the resulting payload MTU to ip_frag_next().
If the effective MTU is smaller than hlen + 8, ip_frag_next() rounds the fragment payload length down to zero. The fragmentation state then never makes forward progress: state->left, state->ptr and state->offset stay unchanged while ip_do_fragment() keeps allocating and transmitting header-only fragments until the softlockup detector fires.
This is reproducible with a route installed using "mtu lock 20", but it is also reproducible without route MTU lock, for example by forwarding a packet to a device whose MTU is 20.
Fix it in ip_do_fragment() by rejecting mtu < hlen + 8 with -EMSGSIZE, matching the existing IPv6 fragmentation check.
--- net/ipv4/ip_output.c | 4 ++++ 1 file changed, 4 insertions(+)
net/ipv4/ip_output.c +4 -0
@@ -791,6 +791,10 @@ int ip_do_fragment(struct net *net, stru*/ hlen = iph->ihl *4 ; +if (mtu < hlen +8 ) { + err = -EMSGSIZE ; + goto fail; + } mtu = mtu - hlen;/* Size of data space */ IPCB (skb)->flags |=IPSKB_FRAG_COMPLETE ; ll_rs =LL_RESERVED_SPACE (rt->dst.dev);
Greg Kroah-Hartman
maintainerPATCH 48/94 ipv6: fix use-after-free in ip6_finish_output2()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Luxiao Xu <[email protected]>
commit d0d48d999b0eee6bb176ef4e39d9be868fa80f7e upstream.
ip6_finish_output2() caches a pointer to the IPv6 destination address (daddr) before invoking lwtunnel_xmit(). The LWT-BPF transmit path or other encapsulation operations within lwtunnel_xmit() can reallocate the skb head, freeing the memory that daddr points to. When lwtunnel_xmit() returns LWTUNNEL_XMIT_CONTINUE, the function continues to use the stale daddr pointer to compute the nexthop and to look up or create the neighbour entry. This results in a use-after-free read, which can leak sensitive kernel data, pollute the neighbour table with arbitrary values, misdirect traffic, or crash the system.
Fix this by re-fetching the IPv6 header and the destination address pointer after lwtunnel_xmit() returns LWTUNNEL_XMIT_CONTINUE, ensuring that the subsequent nexthop computation and neighbour lookup operate on valid memory.
--- net/ipv6/ip6_output.c | 2 ++ 1 file changed, 2 insertions(+)
net/ipv6/ip6_output.c +2 -0
@@ -116,6 +116,8 @@ static int ip6_finish_output2(struct netif (res !=LWTUNNEL_XMIT_CONTINUE )return res; + hdr =ipv6_hdr (skb); + daddr = &hdr->daddr; }IP6_UPD_PO_STATS (net, idev,IPSTATS_MIB_OUT , skb->len);
Greg Kroah-Hartman
maintainerPATCH 49/94 mailbox: mchp-ipc-sbi: Add null check for devm_kasprintf()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Griffin Kroah-Hartman <[email protected]>
commit b37c4d0a2fd90c0c31223acd37f763eb8953ed1a upstream.
Add a check to see if devm_kasprintf() is not NULL in mchp_ipc_get_cluster_aggr_irq(), returning -ENOMEM if the function failed.
--- drivers/mailbox/mailbox-mchp-ipc-sbi.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/mailbox/mailbox-mchp-ipc-sbi.c +2 -0
@@ -378,6 +378,8 @@ static int mchp_ipc_get_cluster_aggr_irqfor_each_online_cpu (cpuid) { hartid =cpuid_to_hartid_map (cpuid); irq_name =devm_kasprintf (ipc->dev,GFP_KERNEL ,"hart-%lu" , hartid); +if (!irq_name) +return -ENOMEM ; ret =platform_get_irq_byname_optional (pdev, irq_name);if (ret <=0 )continue ;
Greg Kroah-Hartman
maintainerPATCH 50/94 dmaengine: fsl-edma: Add error handling for devm_kasprintf
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Griffin Kroah-Hartman <[email protected]>
commit bf1af4dfdc017dfe989c0dbcf0e608dc95f1d2cb upstream.
Add error handling statement to fls_edma3_irq_init() for the devm_kasprintf call.
--- drivers/dma/fsl-edma-main.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/dma/fsl-edma-main.c +2 -0
@@ -414,6 +414,8 @@ static int fsl_edma3_irq_init(struct pla errirq_name =devm_kasprintf (&pdev->dev,GFP_KERNEL ,"%s-err" ,dev_name (&pdev->dev)); +if (!errirq_name) +return -ENOMEM ; ret =devm_request_irq (&pdev->dev, fsl_edma->errirq, fsl_edma3_err_handler_shared,0 , errirq_name, fsl_edma);
Greg Kroah-Hartman
maintainerPATCH 51/94 nvmet-auth: zero the AUTH_RECEIVE response buffer
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Bryam Vargas <[email protected]>
commit 3ddcfb013322aa37eaa7a0d344b73079c38dfa21 upstream.
nvmet_execute_auth_receive() allocates the response buffer with kmalloc() sized by the host-supplied AUTH_RECEIVE allocation length, but the DH-HMAC-CHAP builders write only a fixed-size message into it. The full allocation length is then copied to the wire by nvmet_copy_to_sgl(), so a remote initiator receives the bytes past the built message -- up to nearly a page of uninitialized slab -- during the pre-authentication handshake.
Allocate the buffer with kzalloc() so the unwritten tail is zeroed before it is sent; conforming responses are unaffected.
--- drivers/nvme/target/fabrics-cmd-auth.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/nvme/target/fabrics-cmd-auth.c +1 -1
@@ -558,7 +558,7 @@ void nvmet_execute_auth_receive(struct nreturn ; } - d =kmalloc (al,GFP_KERNEL ); + d =kzalloc (al,GFP_KERNEL );if (!d) { status =NVME_SC_INTERNAL ; goto done;
Greg Kroah-Hartman
maintainerPATCH 52/94 nvmet-fc: fix invalid free in LS IOD error path
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Jiang HongHui <[email protected]>
commit ba98d6796d12258e837ece065d2ecb59d76ce4ff upstream.
nvmet_fc_alloc_ls_iodlist() advances iod while initializing the LS IOD array. If an rqstbuf allocation or response buffer DMA mapping fails, the unwind loop decrements iod past the start of the array. The final kfree(iod) therefore frees an address before the allocated object.
This can be reproduced with nvme-fcloop and failslab by setting fail-nth to 6 before creating a target port. KASAN reports:
BUG: KASAN: invalid-free in nvmet_fc_register_targetport Free of addr ffff88816cf8ff48 by task nvmet_fail_nth/9552
Free the original allocation base stored in tgtport->iod instead. With this fix applied, the same sysfs write with fail-nth=6 returns -ENOMEM without any KASAN report.
--- drivers/nvme/target/fc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/nvme/target/fc.c +1 -1
@@ -569,7 +569,7 @@ out_fail:list_del (&iod->ls_rcv_list); } -kfree (iod); +kfree (tgtport->iod);return -EFAULT ; }
Greg Kroah-Hartman
maintainerPATCH 53/94 nvmet-tcp: bound SGL data length before allocating command buffers
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Ibrahim Hashimov <[email protected]>
commit 4a3f00262a044e8e15064b1a6860968bf0500bf4 upstream.
nvmet_tcp_map_data() reads the host-controlled 32-bit sgl->length and, for the in-capsule offset descriptor (type 0x01), checks it against port->inline_data_size before use. Any other SGL descriptor type -- including the non-inline transport SGL data-block descriptor (type (NVME_TRANSPORT_SGL_DATA_DESC << 4) | NVME_SGL_FMT_TRANSPORT_A, the type a real host uses for out-of-capsule writes) skips that check entirely and falls straight through to:
cmd->req.sg = sgl_alloc(len, GFP_KERNEL, &cmd->req.sg_cnt);
with len taken directly from the wire, unbounded up to 4 GiB.
nvmet_req_init() only parses the command and never inspects sgl->length, and nvmet_check_transfer_len() -- the only other place transfer_len is validated -- runs later, from req->execute(), after the allocation has already happened. For a write command the target responds with an R2T and parks the command waiting for the host to send the data; if the host (or an unauthenticated peer that simply never follows up) never does, the sgl_alloc() buffer stays resident for the life of the command. NVMe/TCP has no mandatory authentication in the default configuration, so any peer able to reach the target portal and complete a Fabrics connect can drive this with a single crafted command, repeatable across queues and connections for amplification. This is unbounded kernel memory allocation triggered by a remote, effectively unauthenticated peer.
Validate len against the same NVMET_TCP_MAXH2CDATA ceiling this file already uses to bound per-PDU H2C data, for every SGL descriptor type, before doing any allocation. This closes the gap for the non-inline descriptor while leaving the existing, tighter inline_data_size check in place for the in-capsule case.
Runtime-verified on a v6.19 KASAN stand: with this bound in place, a crafted write command carrying an oversized non-inline SGL length is rejected before sgl_alloc() runs, where the same request previously drove an unbounded ~256 MiB kernel allocation (up to 4 GiB) that stayed resident pending an R2T the host never satisfies.
--- drivers/nvme/target/tcp.c | 13 +++++++++++++ 1 file changed, 13 insertions(+)
drivers/nvme/target/tcp.c +13 -0
@@ -433,6 +433,19 @@ static int nvmet_tcp_map_data(struct nvmif (!len)return 0 ; +/* +* inline_data_size only bounds the in-capsule (type 0x01) SGL +* descriptor below. A non-inline transport SGL data-block +* descriptor skips that check entirely and would otherwise reach +* sgl_alloc() with an attacker-controlled len of up to 4 GiB, +* pinning that much kernel memory for a command that may never +* complete. Bound every descriptor type here, before allocating +* anything, using the same ceiling this file already applies to +* per-PDU H2C data. +*/ +if (len >NVMET_TCP_MAXH2CDATA ) +return NVME_SC_SGL_INVALID_DATA |NVME_STATUS_DNR ; +if (sgl->type == ((NVME_SGL_FMT_DATA_DESC <<4 ) |NVME_SGL_FMT_OFFSET )) {if (!nvme_is_write (cmd->req.cmd))
Greg Kroah-Hartman
maintainerPATCH 54/94 nvmet-tcp: Do not WARN on remotely-controlled oversized SGL allocations
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Greg Kroah-Hartman <[email protected]>
commit 737a3b535247226f6e1a7988fd9d6e63e7d6fc71 upstream.
When fuzzing the nvme target code, I tripped a kernel warning in nvmet_tcp_map_data() because the length passed into the allocator is controlled by the remote initiator.
A remote initiator that sends a command with an SGL claiming a huge number, can create a scatterlist and iovec allocation of over 1 million entries, which causes the backing kmalloc call to exceed MAX_PAGE_ORDER and then the page allocator will trip on a WARN_ON_ONCE_GFP() message:
WARNING: mm/page_alloc.c:5280 __alloc_frozen_pages_noprof Workqueue: nvmet_tcp_wq nvmet_tcp_io_work ... sgl_alloc_order nvmet_tcp_map_data nvmet_tcp_try_recv_pdu
As it's never good to trip a kernel warning remotely due to many systems having panic-on-warn enabled, let's silence it by just add GFP_NOWARN to the allocation flags.
--- drivers/nvme/target/tcp.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
drivers/nvme/target/tcp.c +3 -2
@@ -457,14 +457,15 @@ static int nvmet_tcp_map_data(struct nvm } cmd->req.transfer_len += len; - cmd->req.sg =sgl_alloc (len,GFP_KERNEL , &cmd->req.sg_cnt); + cmd->req.sg =sgl_alloc (len,GFP_KERNEL | __GFP_NOWARN, + &cmd->req.sg_cnt);if (!cmd->req.sg)return NVME_SC_INTERNAL ; cmd->cur_sg = cmd->req.sg;if (nvmet_tcp_has_data_in (cmd)) { cmd->iov =kmalloc_array (cmd->req.sg_cnt, -sizeof (*cmd->iov),GFP_KERNEL ); +sizeof (*cmd->iov),GFP_KERNEL | __GFP_NOWARN);if (!cmd->iov) goto err; }
Greg Kroah-Hartman
maintainerPATCH 55/94 nvmet: pci-epf: fix use-after-free in nvmet_pci_epf_exec_iod_work()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Shin'ichiro Kawasaki <[email protected]>
commit c9e9bb757971485b4e8414b1744507af186d72c9 upstream.
nvmet_pci_epf_exec_iod_work() submits an I/O command with req->execute() and then waits for the command to complete and transfers the data back to the host. This wait is not needed for commands that do not transfer data from the device to the host. To decide whether that wait is needed, it reads iod->data_len and iod->dma_dir after calling req->execute().
However, once req->execute() is called, the command may complete asynchronously on another CPU. For commands that do not require a device-to-host data transfer, nvmet_pci_epf_queue_response() calls nvmet_pci_epf_complete_iod() directly, which can free the iod before it reads iod->data_len and iod->dma_dir, resulting in the KFENCE use-after- free:
BUG: KFENCE: use-after-free read in nvmet_pci_epf_exec_iod_work+0x288/0x798 [nvmet_pci_epf]
Use-after-free read at 0x00000000fdfa6d03 (in kfence-#63):
nvmet_pci_epf_exec_iod_work+0x288/0x798 [nvmet_pci_epf] process_one_work+0x15c/0x4f0 worker_thread+0x18c/0x30c kthread+0x130/0x140 ret_from_fork+0x10/0x20
kfence-#63: 0x00000000e3de0e71-0x00000000c938ad62, size=712, cache=kmalloc-1k
allocated by task 10 on cpu 0 at 73.995480s (0.005122s ago):
mempool_kmalloc+0x1c/0x28 mempool_alloc_noprof+0x40/0x9c nvmet_pci_epf_poll_sqs_work+0xd4/0x344 [nvmet_pci_epf] process_one_work+0x15c/0x4f0 worker_thread+0x18c/0x30c kthread+0x130/0x140 ret_from_fork+0x10/0x20
freed by task 131 on cpu 3 at 73.995521s (0.008385s ago):
mempool_kfree+0x10/0x20 mempool_free+0x44/0x64 nvmet_pci_epf_free_iod+0x88/0x98 [nvmet_pci_epf] nvmet_pci_epf_cq_work+0xfc/0x280 [nvmet_pci_epf] process_one_work+0x15c/0x4f0 worker_thread+0x18c/0x30c kthread+0x130/0x140 ret_from_fork+0x10/0x20
Fix this by referring to iod->data_len and iod->dma_dir before calling req->execute(). The remaining iod accesses such as iod->status are only reached on the device-to-host read path. In this case, nvmet_pci_epf_queue_response() signals iod->done instead of freeing the iod, so the iod stays valid.
--- drivers/nvme/target/pci-epf.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-)
drivers/nvme/target/pci-epf.c +6 -3
@@ -1595,6 +1595,7 @@ static void nvmet_pci_epf_exec_iod_work(struct nvmet_pci_epf_iod *iod = container_of(work, struct nvmet_pci_epf_iod, work);struct nvmet_req *req = &iod->req; +bool no_wait;int ret;if (!iod->ctrl->link_up) {
@@ -1639,14 +1640,16 @@ static void nvmet_pci_epf_exec_iod_work( } } - req->execute (req); -/* * If we do not have data to transfer after the command execution * finishes, nvmet_pci_epf_queue_response() will complete the command * directly. No need to wait for the completion in this case. */ -if (!iod->data_len || iod->dma_dir !=DMA_TO_DEVICE ) + no_wait = !iod->data_len || iod->dma_dir !=DMA_TO_DEVICE ; + + req->execute (req); + +if (no_wait)return ;wait_for_completion (&iod->done);
Greg Kroah-Hartman
maintainerPATCH 56/94 nvmet: pci-epf: put CQ ref on create_cq mapping failure
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Yifei Gao <[email protected]>
commit 659ae9d02cb5d72c76f74fff7441eb8fb64d8f5c upstream.
nvmet_pci_epf_create_cq() calls nvmet_cq_create(), which takes a reference on the controller and installs the completion queue. If the subsequent PCI address-space mapping fails or returns a too-small partial mapping, the function jumps to err_internal / err_unmap_queue without calling nvmet_cq_put(). The matching put in nvmet_pci_epf_delete_cq() is gated on NVMET_PCI_EPF_Q_LIVE, which is only set after the mapping succeeds, so teardown never releases these references. A remote PCI host that drives Create IO CQ commands with a failing PRP1/pci_addr therefore leaks the CQ and a controller reference on each attempt.
Drop the CQ reference on the mapping-failure paths. The err_internal and err_unmap_queue labels are only reachable after nvmet_cq_create() has succeeded, so this pairs the create/put correctly.
--- drivers/nvme/target/pci-epf.c | 1 + 1 file changed, 1 insertion(+)
drivers/nvme/target/pci-epf.c +1 -0
@@ -1338,6 +1338,7 @@ err_unmap_queue:nvmet_pci_epf_mem_unmap (ctrl->nvme_epf, &cq->pci_map); err_internal: status =NVME_SC_INTERNAL |NVME_STATUS_DNR ; +nvmet_cq_put (&cq->nvme_cq); err:if (test_and_clear_bit (NVMET_PCI_EPF_Q_IRQ_ENABLED , &cq->flags))nvmet_pci_epf_remove_irq_vector (ctrl, cq->vector);
Greg Kroah-Hartman
maintainerPATCH 57/94 mptcp: pm: use for_each_subflow helper
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: "Matthieu Baerts (NGI0)" <[email protected]>
[ Upstream commit f81689172429885d6c2c7c3dd4926ec626e794bb ]
Similar to most places in the MPTCP code. So instead of passing the subflow list and use list_for_each_entry(subflow, list, node), pass the msk and use mptcp_for_each_subflow(msk, subflow).
That's clearer and more uniform with the rest.
While at it, add 'pm_' prefix for the exported one to easily identify the origin. Plus replace 'lookup' by 'has', because a bool is returned.
Stable-dep-of: efc33b5102ff ("mptcp: pm: fix memory leak from alloc-during-teardown race")
--- net/mptcp/pm.c | 6 +++--- net/mptcp/pm_kernel.c | 12 ++++++------ net/mptcp/pm_userspace.c | 2 +- net/mptcp/protocol.h | 4 ++-- 4 files changed, 12 insertions(+), 12 deletions(-)
net/mptcp/pm.c +3 -3
@@ -115,14 +115,14 @@ static bool mptcp_pm_is_init_remote_addrreturn mptcp_addresses_equal (&mpc_remote, remote, remote->port); } -bool mptcp_lookup_subflow_by_saddr (const struct list_head *list, -const struct mptcp_addr_info *saddr) +bool mptcp_pm_has_subflow_saddr (const struct mptcp_sock *msk, +const struct mptcp_addr_info *saddr) {struct mptcp_subflow_context *subflow;struct mptcp_addr_info cur;struct sock_common *skc; -list_for_each_entry (subflow, list, node) { +mptcp_for_each_subflow (msk, subflow) { skc = (struct sock_common *)mptcp_subflow_tcp_sock (subflow);mptcp_local_address (skc, &cur);
net/mptcp/pm_kernel.c +6 -6
@@ -86,13 +86,13 @@ u8 mptcp_pm_get_limit_extra_subflows(con }EXPORT_SYMBOL_GPL (mptcp_pm_get_limit_extra_subflows); -static bool lookup_subflow_by_daddr (const struct list_head *list, -const struct mptcp_addr_info *daddr) +static bool has_subflow_daddr (const struct mptcp_sock *msk, +const struct mptcp_addr_info *daddr) {struct mptcp_subflow_context *subflow;struct mptcp_addr_info cur; -list_for_each_entry (subflow, list, node) { +mptcp_for_each_subflow (msk, subflow) {struct sock *ssk =mptcp_subflow_tcp_sock (subflow); if (!((1 << inet_sk_state_load(ssk)) &
@@ -652,7 +652,7 @@ static void mptcp_pm_nl_add_addr_receivemptcp_pm_addr_send_ack (msk);mptcp_mpc_endpoint_setup (msk); -if (lookup_subflow_by_daddr (&msk->conn_list, &remote)) +if (has_subflow_daddr (msk, &remote))return ;/* pick id 0 port, if none is provided the remote address */
@@ -1074,7 +1074,7 @@ static int mptcp_nl_remove_subflow_and_s goto next;lock_sock (sk); - remove_subflow =mptcp_lookup_subflow_by_saddr (&msk->conn_list, addr); + remove_subflow =mptcp_pm_has_subflow_saddr (msk, addr);mptcp_pm_remove_anno_addr (msk, addr, remove_subflow && !(entry->flags &MPTCP_PM_ADDR_FLAG_IMPLICIT ));
@@ -1202,7 +1202,7 @@ static void mptcp_pm_flush_addrs_and_sublist_for_each_entry (entry, rm_list, list) {if (slist.nr <MPTCP_RM_IDS_MAX && -mptcp_lookup_subflow_by_saddr (&msk->conn_list, &entry->addr)) +mptcp_pm_has_subflow_saddr (msk, &entry->addr)) slist.ids[slist.nr++] =mptcp_endp_get_local_id (msk, &entry->addr); if (alist.nr < MPTCP_RM_IDS_MAX &&
net/mptcp/pm_userspace.c +1 -1
@@ -286,7 +286,7 @@ void mptcp_pm_remove_addr_entry(struct m/* only delete if either announced or matching a subflow */ if (mptcp_remove_anno_list_by_saddr (msk, &entry->addr)) anno_nr++; -else if (!mptcp_lookup_subflow_by_saddr (&msk->conn_list, &entry->addr)) +else if (!mptcp_pm_has_subflow_saddr (msk, &entry->addr))return ; alist.ids[alist.nr++] = entry->addr.id;
net/mptcp/protocol.h +2 -2
@@ -1087,8 +1087,8 @@ bool mptcp_pm_sport_in_anno_list(structstruct mptcp_pm_add_entry *mptcp_pm_del_add_timer (struct mptcp_sock *msk,const struct mptcp_addr_info *addr,bool check_id); -bool mptcp_lookup_subflow_by_saddr (const struct list_head *list, -const struct mptcp_addr_info *saddr); +bool mptcp_pm_has_subflow_saddr (const struct mptcp_sock *msk, +const struct mptcp_addr_info *saddr);bool mptcp_remove_anno_list_by_saddr (struct mptcp_sock *msk,const struct mptcp_addr_info *addr); int mptcp_pm_nl_set_flags(struct mptcp_pm_addr_entry *local,
Greg Kroah-Hartman
maintainerPATCH 58/94 mptcp: pm: rename add_entry structure to add_addr
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: "Matthieu Baerts (NGI0)" <[email protected]>
[ Upstream commit 350d76dd6e79468ac85767f2d236299a135572df ]
Using only the 'add' prefix is confusing: does it refer to a generic added entry or address, or specifically to ADD_ADDRs. Using add_addr removes this confusion.
Stable-dep-of: efc33b5102ff ("mptcp: pm: fix memory leak from alloc-during-teardown race")
--- net/mptcp/pm.c | 22 +++++++++++----------- net/mptcp/protocol.h | 2 +- 2 files changed, 12 insertions(+), 12 deletions(-)
net/mptcp/pm.c +11 -11
@@ -12,7 +12,7 @@#define ADD_ADDR_RETRANS_MAX 3 -struct mptcp_pm_add_entry { +struct mptcp_pm_add_addr {struct list_head list;struct mptcp_addr_info addr;u8 retrans_times;
@@ -133,11 +133,11 @@ bool mptcp_pm_has_subflow_saddr(const streturn false; } -static struct mptcp_pm_add_entry * +static struct mptcp_pm_add_addr *mptcp_lookup_anno_list_by_saddr (const struct mptcp_sock *msk,const struct mptcp_addr_info *addr) { -struct mptcp_pm_add_entry *entry; +struct mptcp_pm_add_addr *entry;lockdep_assert_held (&msk->pm.lock);
@@ -152,7 +152,7 @@ mptcp_lookup_anno_list_by_saddr(const stbool mptcp_remove_anno_list_by_saddr (struct mptcp_sock *msk,const struct mptcp_addr_info *addr) { -struct mptcp_pm_add_entry *entry; +struct mptcp_pm_add_addr *entry;bool ret; entry =mptcp_pm_del_add_timer (msk, addr, false);
@@ -164,7 +164,7 @@ bool mptcp_remove_anno_list_by_saddr(strbool mptcp_pm_sport_in_anno_list (struct mptcp_sock *msk,const struct sock *sk) { -struct mptcp_pm_add_entry *entry; +struct mptcp_pm_add_addr *entry;struct mptcp_addr_info saddr;bool ret = false;
@@ -340,8 +340,8 @@ static unsigned int mptcp_adjust_add_addstatic void mptcp_pm_add_timer (struct timer_list *timer) { -struct mptcp_pm_add_entry *entry =timer_container_of (entry, timer, - add_timer); +struct mptcp_pm_add_addr *entry =timer_container_of (entry, timer, + add_timer);struct mptcp_sock *msk = entry->sock;struct sock *sk = (struct sock *)msk;unsigned int timeout =0 ;
@@ -399,12 +399,12 @@ out:sock_put (sk); } -struct mptcp_pm_add_entry * +struct mptcp_pm_add_addr *mptcp_pm_del_add_timer (struct mptcp_sock *msk,const struct mptcp_addr_info *addr,bool check_id) { -struct mptcp_pm_add_entry *entry;struct sock *sk = (struct sock *)msk; +struct mptcp_pm_add_addr *entry;bool stop_timer = false;rcu_read_lock ();
@@ -436,7 +436,7 @@ mptcp_pm_del_add_timer(struct mptcp_sockbool mptcp_pm_alloc_anno_list (struct mptcp_sock *msk,const struct mptcp_addr_info *addr) { -struct mptcp_pm_add_entry *add_entry =NULL ; +struct mptcp_pm_add_addr *add_entry =NULL ;struct sock *sk = (struct sock *)msk;unsigned int timeout;
@@ -473,7 +473,7 @@ reset_timer:static void mptcp_pm_free_anno_list (struct mptcp_sock *msk) { -struct mptcp_pm_add_entry *entry, *tmp; +struct mptcp_pm_add_addr *entry, *tmp;struct sock *sk = (struct sock *)msk;LIST_HEAD (free_list);
net/mptcp/protocol.h +1 -1
@@ -1084,7 +1084,7 @@ int mptcp_pm_mp_prio_send_ack(struct mptbool mptcp_pm_alloc_anno_list (struct mptcp_sock *msk,const struct mptcp_addr_info *addr);bool mptcp_pm_sport_in_anno_list (struct mptcp_sock *msk,const struct sock *sk); -struct mptcp_pm_add_entry * +struct mptcp_pm_add_addr *mptcp_pm_del_add_timer (struct mptcp_sock *msk,const struct mptcp_addr_info *addr,bool check_id); bool mptcp_pm_has_subflow_saddr(const struct mptcp_sock *msk,
Greg Kroah-Hartman
maintainerPATCH 59/94 mptcp: pm: uniform announced addresses helpers
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: "Matthieu Baerts (NGI0)" <[email protected]>
[ Upstream commit 7d4dacc8ccca8e40fcb5f2ece9ea3e502da1bd3f ]
Similar to the previous commit, only using the 'add' or 'anno' prefixes is confusing -- generally associated to the action of adding something, or the Latin name for "year" -- and lack of uniformity.
This has been causing issues in the past, e.g. del_add_timer seemed to suggest the goal is to delete a previously added timer.
Instead, use the mptcp_pm_announced_ prefix.
While at it, slightly improves some helpers:
- mptcp_lookup_anno_list_by_saddr: no need to specify what is used to do the lookup: mptcp_pm_announced_lookup.
- mptcp_pm_sport_in_anno_list: it doesn't just compare the port, but the whole address linked to the sublow: mptcp_pm_announced_has_ssk.
- mptcp_pm_alloc_anno_list: it allocates one item of the list, not a whole list: mptcp_pm_announced_alloc.
Stable-dep-of: efc33b5102ff ("mptcp: pm: fix memory leak from alloc-during-teardown race")
--- net/mptcp/options.c | 2 +- net/mptcp/pm.c | 35 +++++++++++++++++------------------ net/mptcp/pm_kernel.c | 10 +++++----- net/mptcp/pm_userspace.c | 4 ++-- net/mptcp/protocol.h | 12 ++++++------ net/mptcp/subflow.c | 4 ++-- 6 files changed, 33 insertions(+), 34 deletions(-)
net/mptcp/options.c +1 -1
@@ -1259,7 +1259,7 @@ bool mptcp_incoming_options(struct sockMPTCP_INC_STATS (sock_net (sk),MPTCP_MIB_ADDADDR ); }else {mptcp_pm_add_addr_echoed (msk, &mp_opt.addr); -mptcp_pm_del_add_timer (msk, &mp_opt.addr, true); +mptcp_pm_announced_del_timer (msk, &mp_opt.addr, true);MPTCP_INC_STATS (sock_net (sk),MPTCP_MIB_ECHOADD ); }
net/mptcp/pm.c +17 -18
@@ -134,8 +134,8 @@ bool mptcp_pm_has_subflow_saddr(const st }static struct mptcp_pm_add_addr * -mptcp_lookup_anno_list_by_saddr (const struct mptcp_sock *msk, -const struct mptcp_addr_info *addr) +mptcp_pm_announced_lookup (const struct mptcp_sock *msk, +const struct mptcp_addr_info *addr) {struct mptcp_pm_add_addr *entry;
@@ -149,26 +149,26 @@ mptcp_lookup_anno_list_by_saddr(const streturn NULL ; } -bool mptcp_remove_anno_list_by_saddr (struct mptcp_sock *msk, -const struct mptcp_addr_info *addr) +bool mptcp_pm_announced_remove (struct mptcp_sock *msk, +const struct mptcp_addr_info *addr) {struct mptcp_pm_add_addr *entry;bool ret; - entry =mptcp_pm_del_add_timer (msk, addr, false); + entry =mptcp_pm_announced_del_timer (msk, addr, false); ret = entry;kfree_rcu (entry, rcu);return ret; } -bool mptcp_pm_sport_in_anno_list (struct mptcp_sock *msk,const struct sock *sk) +bool mptcp_pm_announced_has_ssk (struct mptcp_sock *msk,const struct sock *ssk) {struct mptcp_pm_add_addr *entry;struct mptcp_addr_info saddr;bool ret = false; -mptcp_local_address ((struct sock_common *)sk, &saddr); +mptcp_local_address ((struct sock_common *)ssk, &saddr);spin_lock_bh (&msk->pm.lock);list_for_each_entry (entry, &msk->pm.anno_list, list) {
@@ -365,7 +365,7 @@ static void mptcp_pm_add_timer(struct tispin_lock_bh (&msk->pm.lock); -/* The cancel path (mptcp_pm_del_add_timer()) can race with this +/* The cancel path (mptcp_pm_announced_del_timer()) can race with this * callback. Once cancel updates retrans_times to MAX, suppress further * retransmissions here. If this callback acquires pm.lock first, one * final transmit attempt is still possible.
@@ -400,8 +400,8 @@ out: }struct mptcp_pm_add_addr * -mptcp_pm_del_add_timer (struct mptcp_sock *msk, -const struct mptcp_addr_info *addr,bool check_id) +mptcp_pm_announced_del_timer (struct mptcp_sock *msk, +const struct mptcp_addr_info *addr,bool check_id) {struct sock *sk = (struct sock *)msk;struct mptcp_pm_add_addr *entry;
@@ -410,7 +410,7 @@ mptcp_pm_del_add_timer(struct mptcp_sockrcu_read_lock ();spin_lock_bh (&msk->pm.lock); - entry =mptcp_lookup_anno_list_by_saddr (msk, addr); + entry =mptcp_pm_announced_lookup (msk, addr);if (entry && (!check_id || entry->addr.id == addr->id)) { entry->retrans_times =ADD_ADDR_RETRANS_MAX ; stop_timer = true;
@@ -433,7 +433,7 @@ mptcp_pm_del_add_timer(struct mptcp_sockreturn entry; } -bool mptcp_pm_alloc_anno_list (struct mptcp_sock *msk, +bool mptcp_pm_announced_alloc (struct mptcp_sock *msk,const struct mptcp_addr_info *addr) {struct mptcp_pm_add_addr *add_entry =NULL ;
@@ -442,8 +442,7 @@ bool mptcp_pm_alloc_anno_list(struct mptlockdep_assert_held (&msk->pm.lock); - add_entry =mptcp_lookup_anno_list_by_saddr (msk, addr); - + add_entry =mptcp_pm_announced_lookup (msk, addr);if (add_entry) {if (WARN_ON_ONCE (mptcp_pm_is_kernel (msk)))return false;
@@ -471,7 +470,7 @@ reset_timer:return true; } -static void mptcp_pm_free_anno_list (struct mptcp_sock *msk) +static void mptcp_pm_free_announced_list (struct mptcp_sock *msk) {struct mptcp_pm_add_addr *entry, *tmp;struct sock *sk = (struct sock *)msk;
@@ -738,7 +737,7 @@ void mptcp_pm_add_addr_echoed(struct mptspin_lock_bh (&pm->lock); -if (mptcp_lookup_anno_list_by_saddr (msk, addr) &&READ_ONCE (pm->work_pending)) +if (mptcp_pm_announced_lookup (msk, addr) &&READ_ONCE (pm->work_pending))mptcp_pm_schedule_work (msk,MPTCP_PM_SUBFLOW_ESTABLISHED );spin_unlock_bh (&pm->lock);
@@ -947,7 +946,7 @@ out_unlock:* let the PM state machine progress. */ if (skip_add_addr) { -mptcp_pm_del_add_timer (msk, addr, true); +mptcp_pm_announced_del_timer (msk, addr, true);mptcp_pm_subflow_established (msk); }return ret;
@@ -1102,7 +1101,7 @@ void mptcp_pm_worker(struct mptcp_sock *void mptcp_pm_destroy (struct mptcp_sock *msk) { -mptcp_pm_free_anno_list (msk); +mptcp_pm_free_announced_list (msk);if (mptcp_pm_is_userspace (msk))mptcp_userspace_pm_free_local_addr_list (msk);
net/mptcp/pm_kernel.c +5 -5
@@ -359,7 +359,7 @@ static void mptcp_pm_create_subflow_or_s/* If the alloc fails, we are on memory pressure, not worth * continuing, and trying to create subflows. */ -if (!mptcp_pm_alloc_anno_list (msk, &local.addr)) +if (!mptcp_pm_announced_alloc (msk, &local.addr))return ;__clear_bit (endp_id, msk->pm.id_avail_bitmap);
@@ -1028,7 +1028,7 @@ out_free:return ret; } -static bool mptcp_pm_remove_anno_addr (struct mptcp_sock *msk, +static bool mptcp_pm_remove_announced (struct mptcp_sock *msk,const struct mptcp_addr_info *addr,bool force) {
@@ -1037,7 +1037,7 @@ static bool mptcp_pm_remove_anno_addr(st list.ids[list.nr++] =mptcp_endp_get_local_id (msk, addr); - ret =mptcp_remove_anno_list_by_saddr (msk, addr); + ret =mptcp_pm_announced_remove (msk, addr);if (ret || force) {spin_lock_bh (&msk->pm.lock);if (ret)
@@ -1075,7 +1075,7 @@ static int mptcp_nl_remove_subflow_and_slock_sock (sk); remove_subflow =mptcp_pm_has_subflow_saddr (msk, addr); -mptcp_pm_remove_anno_addr (msk, addr, remove_subflow && +mptcp_pm_remove_announced (msk, addr, remove_subflow && !(entry->flags &MPTCP_PM_ADDR_FLAG_IMPLICIT )); list.ids[0 ] =mptcp_endp_get_local_id (msk, addr);
@@ -1206,7 +1206,7 @@ static void mptcp_pm_flush_addrs_and_sub slist.ids[slist.nr++] =mptcp_endp_get_local_id (msk, &entry->addr);if (alist.nr <MPTCP_RM_IDS_MAX && -mptcp_remove_anno_list_by_saddr (msk, &entry->addr)) +mptcp_pm_announced_remove (msk, &entry->addr)) alist.ids[alist.nr++] =mptcp_endp_get_local_id (msk, &entry->addr); }
net/mptcp/pm_userspace.c +2 -2
@@ -231,7 +231,7 @@ int mptcp_pm_nl_announce_doit(struct sk_lock_sock (sk);spin_lock_bh (&msk->pm.lock); -if (mptcp_pm_alloc_anno_list (msk, &addr_val.addr)) { +if (mptcp_pm_announced_alloc (msk, &addr_val.addr)) { msk->pm.add_addr_signaled++;mptcp_pm_announce_addr (msk, &addr_val.addr, false);mptcp_pm_addr_send_ack (msk);
@@ -284,7 +284,7 @@ void mptcp_pm_remove_addr_entry(struct mint anno_nr =0 ;/* only delete if either announced or matching a subflow */ -if (mptcp_remove_anno_list_by_saddr (msk, &entry->addr)) +if (mptcp_pm_announced_remove (msk, &entry->addr)) anno_nr++;else if (!mptcp_pm_has_subflow_saddr (msk, &entry->addr))return ;
net/mptcp/protocol.h +6 -6
@@ -1081,16 +1081,16 @@ int mptcp_pm_mp_prio_send_ack(struct mptstruct mptcp_addr_info *addr, struct mptcp_addr_info *rem, u8 bkup); -bool mptcp_pm_alloc_anno_list (struct mptcp_sock *msk, +bool mptcp_pm_announced_alloc (struct mptcp_sock *msk,const struct mptcp_addr_info *addr); -bool mptcp_pm_sport_in_anno_list (struct mptcp_sock *msk,const struct sock *sk);struct mptcp_pm_add_addr * -mptcp_pm_del_add_timer (struct mptcp_sock *msk, -const struct mptcp_addr_info *addr,bool check_id); +mptcp_pm_announced_del_timer (struct mptcp_sock *msk, +const struct mptcp_addr_info *addr,bool check_id); +bool mptcp_pm_announced_remove (struct mptcp_sock *msk, +const struct mptcp_addr_info *addr); +bool mptcp_pm_announced_has_ssk (struct mptcp_sock *msk,const struct sock *ssk);bool mptcp_pm_has_subflow_saddr (const struct mptcp_sock *msk,const struct mptcp_addr_info *saddr); -bool mptcp_remove_anno_list_by_saddr (struct mptcp_sock *msk, -const struct mptcp_addr_info *addr);int mptcp_pm_nl_set_flags (struct mptcp_pm_addr_entry *local,struct genl_info *info); int mptcp_userspace_pm_set_flags(struct mptcp_pm_addr_entry *local,
net/mptcp/subflow.c +2 -2
@@ -235,7 +235,7 @@ again:pr_debug ("syn inet_sport=%d %d\n" ,ntohs (inet_sk (sk_listener)->inet_sport),ntohs (inet_sk ((struct sock *)subflow_req->msk)->inet_sport)); -if (!mptcp_pm_sport_in_anno_list (subflow_req->msk, sk_listener)) { +if (!mptcp_pm_announced_has_ssk (subflow_req->msk, sk_listener)) {SUBFLOW_REQ_INC_STATS (req,MPTCP_MIB_MISMATCHPORTSYNRX );subflow_add_reset_reason (skb,MPTCP_RST_EPROHIBIT );return -EPERM ;
@@ -928,7 +928,7 @@ create_child:pr_debug ("ack inet_sport=%d %d\n" ,ntohs (inet_sk (sk)->inet_sport),ntohs (inet_sk ((struct sock *)owner)->inet_sport)); -if (!mptcp_pm_sport_in_anno_list (owner, sk)) { +if (!mptcp_pm_announced_has_ssk (owner, sk)) {SUBFLOW_REQ_INC_STATS (req,MPTCP_MIB_MISMATCHPORTACKRX );subflow_add_reset_reason (skb,MPTCP_RST_EPROHIBIT ); goto dispose_child;
Greg Kroah-Hartman
maintainerPATCH 60/94 mptcp: pm: fix memory leak from alloc-during-teardown race
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Shardul Bankar <[email protected]>
[ Upstream commit efc33b5102ff859bacd390a5f30112d8e0c084c0 ]
mptcp_pm_destroy() empties msk->pm.anno_list and msk->pm.userspace_pm_local_addr_list under msk->pm.lock during socket teardown, dropping the lock between the two.
A concurrent userspace PM genl ANNOUNCE on the same msk holds a sock reference via mptcp_token_get_sock() and, in mptcp_pm_nl_announce_doit(), calls mptcp_userspace_pm_append_new_local_addr() and mptcp_pm_announced_alloc(). Both take msk->pm.lock briefly to add to their respective lists. Because the genl handler holds a sock reference, mptcp_pm_destroy() may run on the same msk via mptcp_disconnect(), which invokes mptcp_destroy_common() without dropping the sock refcount, before the handler completes.
If the lock acquisitions interleave such that mptcp_pm_destroy() empties a list first, the later alloc adds its entry to a list head that nothing else iterates for this msk, and the entry leaks. kmemleak reports both mptcp_pm_add_addr objects (from mptcp_pm_announced_alloc()) and mptcp_pm_addr_entry objects (from mptcp_userspace_pm_append_new_local_addr()) under sustained concurrent ANNOUNCE + close load against the userspace PM.
Add an MPTCP_PM_DESTROYING bit in msk->pm.status, set by mptcp_pm_destroy() under pm.lock before the lists are emptied and checked under pm.lock by the alloc paths. Either the alloc takes pm.lock first, in which case its entry is on the list when mptcp_pm_destroy() frees it; or mptcp_pm_destroy() takes pm.lock first, in which case the later alloc observes the bit and refuses.
Found by an MPTCP protocol-flow harness extending BRF (arXiv:2305.08782).
--- net/mptcp/pm.c | 13 +++++++++++-- net/mptcp/pm_userspace.c | 4 ++++ net/mptcp/protocol.h | 7 ++++--- 3 files changed, 19 insertions(+), 5 deletions(-)
net/mptcp/pm.c +11 -2
@@ -442,6 +442,9 @@ bool mptcp_pm_announced_alloc(struct mptlockdep_assert_held (&msk->pm.lock); +if (msk->pm.status &BIT (MPTCP_PM_DESTROYING )) +return false; + add_entry =mptcp_pm_announced_lookup (msk, addr);if (add_entry) {if (WARN_ON_ONCE (mptcp_pm_is_kernel (msk)))
@@ -1101,10 +1104,16 @@ void mptcp_pm_worker(struct mptcp_sock *void mptcp_pm_destroy (struct mptcp_sock *msk) { +spin_lock_bh (&msk->pm.lock); + msk->pm.status |=BIT (MPTCP_PM_DESTROYING ); +spin_unlock_bh (&msk->pm.lock); +mptcp_pm_free_announced_list (msk); -if (mptcp_pm_is_userspace (msk)) -mptcp_userspace_pm_free_local_addr_list (msk); +/* Free the userspace local address list unconditionally: the socket +* can be reused (mptcp_disconnect()) and re-selected to a different PM +*/ +mptcp_userspace_pm_free_local_addr_list (msk); }void mptcp_pm_data_reset (struct mptcp_sock *msk)
net/mptcp/pm_userspace.c +4 -0
@@ -54,6 +54,10 @@ static int mptcp_userspace_pm_append_newbitmap_zero (id_bitmap,MPTCP_PM_MAX_ADDR_ID +1 );spin_lock_bh (&msk->pm.lock); +if (msk->pm.status &BIT (MPTCP_PM_DESTROYING )) { + ret = -EINVAL ; + goto append_err; + }mptcp_for_each_userspace_pm_addr (msk, e) { addr_match =mptcp_addresses_equal (&e->addr, &entry->addr, true);if (addr_match && entry->addr.id ==0 && needs_id)
net/mptcp/protocol.h +4 -3
@@ -191,9 +191,10 @@ enum mptcp_pm_status {MPTCP_PM_ESTABLISHED ,MPTCP_PM_SUBFLOW_ESTABLISHED ,MPTCP_PM_ALREADY_ESTABLISHED ,/* persistent status, set after ESTABLISHED event */ -MPTCP_PM_MPC_ENDPOINT_ACCOUNTED /* persistent status, set after MPC local address is -* accounted int id_avail_bitmap -*/ +MPTCP_PM_MPC_ENDPOINT_ACCOUNTED ,/* persistent status, set after MPC local address is +* accounted int id_avail_bitmap +*/ + MPTCP_PM_DESTROYING, /* To fence out PM list allocs */ }; enum mptcp_pm_type {
Greg Kroah-Hartman
maintainerPATCH 61/94 selinux: use u16 for security classes
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Christian Göttsche <[email protected]>
[ Upstream commit fa79a596848fe38c55ccab8832ac35dac07fb00c ]
Security class identifiers are limited to 2^16, thus use the appropriate type u16 consistently.
Stable-dep-of: b98a8ac50775 ("selinux: require a class's permission values to cover its permission count")
--- security/selinux/ss/policydb.c | 5 +++-- security/selinux/ss/policydb.h | 10 +++++----- security/selinux/ss/services.c | 2 +- 3 files changed, 9 insertions(+), 8 deletions(-)
security/selinux/ss/policydb.c +3 -2
@@ -951,7 +951,7 @@ int policydb_load_isids(struct policydbreturn 0 ; } -int policydb_class_isvalid (struct policydb *p,unsigned int class) +int policydb_class_isvalid (struct policydb *p,u16 class) {if (!class || class > p->p_classes.nprim)return 0 ;
@@ -2042,7 +2042,8 @@ static int filename_trans_read_helper(ststruct filename_trans_key *ft =NULL ;struct filename_trans_datum **dst, *datum, *first =NULL ;char *name =NULL ; -u32 len, ttype, tclass, ndatum, i; +u32 len, ttype, ndatum, i; +u16 tclass;__le32 buf[3 ];int rc;
security/selinux/ss/policydb.h +5 -5
@@ -48,7 +48,7 @@ struct common_datum {/* Class attributes */ struct class_datum { -u32 value;/* class value */ +u16 value;/* class value */ char *comkey;/* common name */ struct common_datum *comdatum;/* common datum */ struct symtab permissions;/* class-specific permission symbol table */
@@ -82,7 +82,7 @@ struct role_datum {struct role_trans_key {u32 role;/* current role */ u32 type;/* program executable type, or new object type */ -u32 tclass;/* process class, or new object class */ +u16 tclass;/* process class, or new object class */ };struct role_trans_datum {
@@ -139,7 +139,7 @@ struct cat_datum {struct range_trans {u32 source_type;u32 target_type; -u32 target_class; +u16 target_class; };/* Boolean data type */
@@ -195,7 +195,7 @@ struct ocontext { } ibendport; } u;union { -u32 sclass;/* security class for genfs */ +u16 sclass;/* security class for genfs */ u32 behavior;/* labeling behavior for fs_use */ } v;struct context context[2 ];/* security context(s) */
@@ -322,7 +322,7 @@ struct policy_file {extern void policydb_destroy (struct policydb *p);extern int policydb_load_isids (struct policydb *p,struct sidtab *s);extern int policydb_context_isvalid (struct policydb *p,struct context *c); -extern int policydb_class_isvalid (struct policydb *p,unsigned int class); +extern int policydb_class_isvalid (struct policydb *p,u16 class);extern int policydb_type_isvalid (struct policydb *p,unsigned int type);extern int policydb_role_isvalid (struct policydb *p,unsigned int role);extern int policydb_read (struct policydb *p,struct policy_file *fp);
security/selinux/ss/services.c +1 -1
@@ -3290,7 +3290,7 @@ static int get_classes_callback(void *k, {struct class_datum *datum = d;char *name = k, **classes = args; -u32 value = datum->value -1 ; +u16 value = datum->value -1 ; classes[value] =kstrdup (name,GFP_ATOMIC );if (!classes[value])
Greg Kroah-Hartman
maintainerPATCH 62/94 selinux: more strict policy parsing
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Christian Göttsche <[email protected]>
[ Upstream commit 18fa21f10d008a0fc22565109c7d38f304295912 ]
Be more strict during parsing of policies and reject invalid values.
Add some error messages in the case of policy parse failures, to enhance debugging, either on a malformed policy or a too strict check.
Stable-dep-of: b98a8ac50775 ("selinux: require a class's permission values to cover its permission count")
--- security/selinux/include/security.h | 1 security/selinux/ss/avtab.c | 35 +++++- security/selinux/ss/avtab.h | 13 ++ security/selinux/ss/conditional.c | 18 +-- security/selinux/ss/constraint.h | 1 security/selinux/ss/policydb.c | 196 +++++++++++++++++++++++++++++------- security/selinux/ss/policydb.h | 23 +++- security/selinux/ss/services.c | 6 - 8 files changed, 233 insertions(+), 60 deletions(-)
security/selinux/include/security.h +1 -0
@@ -225,6 +225,7 @@ int security_read_policy(void **data, siint security_read_state_kernel (void **data,size_t *len);int security_policycap_supported (unsigned int req_cap); +/* Maximum supported number of permissions per class */ #define SEL_VEC_MAX 32struct av_decision {u32 allowed;
security/selinux/ss/avtab.c +29 -6
@@ -349,7 +349,7 @@ int avtab_read_item(struct avtab *a, strstruct avtab_extended_perms xperms;__le32 buf32[ARRAY_SIZE (xperms.perms.p)];int rc; -unsigned int set, vers = pol->policyvers; +unsigned int vers = pol->policyvers;memset (&key,0 ,sizeof (struct avtab_key ));memset (&datum,0 ,sizeof (struct avtab_datum ));
@@ -360,9 +360,12 @@ int avtab_read_item(struct avtab *a, strpr_err ("SELinux: avtab: truncated entry\n" );return rc; } +/* Read five or more items: source type, target type, +* target class, AV type, and at least one datum. +*/ items2 =le32_to_cpu (buf32[0 ]); -if (items2 >ARRAY_SIZE (buf32)) { -pr_err ("SELinux: avtab: entry overflow\n" ); +if (items2 <5 || items2 >ARRAY_SIZE (buf32)) { +pr_err ("SELinux: avtab: invalid item count\n" );return -EINVAL ; } rc =next_entry (buf32, fp,sizeof (u32) * items2);
@@ -391,6 +394,13 @@ int avtab_read_item(struct avtab *a, strreturn -EINVAL ; } +if (!policydb_type_isvalid (pol, key.source_type) || + !policydb_type_isvalid (pol, key.target_type) || + !policydb_class_isvalid (pol, key.target_class)) { +pr_err ("SELinux: avtab: invalid type or class\n" ); +return -EINVAL ; + } + val =le32_to_cpu (buf32[items++]); enabled = (val &AVTAB_ENABLED_OLD ) ?AVTAB_ENABLED :0 ;
@@ -409,6 +419,11 @@ int avtab_read_item(struct avtab *a, strfor (i =0 ; i <ARRAY_SIZE (spec_order); i++) {if (val & spec_order[i]) { +if (items >= items2) { +pr_err ("SELinux: avtab: entry has too many items (%d/%d)\n" , + items +1 , items2); +return -EINVAL ; + } key.specified = spec_order[i] | enabled; datum.u.data =le32_to_cpu (buf32[items++]); rc =insertf (a, &key, &datum, p);
@@ -444,9 +459,13 @@ int avtab_read_item(struct avtab *a, strreturn -EINVAL ; } - set =hweight16 (key.specified & (AVTAB_XPERMS |AVTAB_TYPE |AVTAB_AV )); -if (!set || set >1 ) { -pr_err ("SELinux: avtab: more than one specifier\n" ); +if (hweight16 (key.specified & ~AVTAB_ENABLED ) !=1 ) { +pr_err ("SELinux: avtab: not exactly one specifier\n" ); +return -EINVAL ; + } + +if (key.specified & ~AVTAB_SPECIFIER_MASK ) { +pr_err ("SELinux: avtab: invalid specifier\n" );return -EINVAL ; }
@@ -471,6 +490,10 @@ int avtab_read_item(struct avtab *a, strpr_err ("SELinux: avtab: truncated entry\n" );return rc; } +if (!avtab_is_valid_xperm_specified (xperms.specified)) +pr_warn_once_policyload (pol, +"SELinux: avtab: unsupported xperm specifier %#x\n" , + xperms.specified); rc =next_entry (&xperms.driver, fp,sizeof (u8));if (rc) {pr_err ("SELinux: avtab: truncated entry\n" );
security/selinux/ss/avtab.h +13 -0
@@ -44,6 +44,7 @@ struct avtab_key { AVTAB_XPERMS_DONTAUDIT)#define AVTAB_ENABLED_OLD 0x80000000/* reserved for used in cond_avtab */ #define AVTAB_ENABLED 0x8000/* reserved for used in cond_avtab */ +#define AVTAB_SPECIFIER_MASK (AVTAB_AV | AVTAB_TYPE | AVTAB_XPERMS | AVTAB_ENABLED)u16 specified;/* what field is specified */ };
@@ -68,6 +69,18 @@ struct avtab_extended_perms {struct extended_perms_data perms; }; +static inline bool avtab_is_valid_xperm_specified (u8 specified) +{ +switch (specified) { +case AVTAB_XPERMS_IOCTLFUNCTION : +case AVTAB_XPERMS_IOCTLDRIVER : +case AVTAB_XPERMS_NLMSG : +return true; +default : +return false; + } +} +struct avtab_datum {union {u32 data;/* access vector or type value */
security/selinux/ss/conditional.c +7 -11
@@ -199,19 +199,12 @@ int cond_index_bool(void *key, void *datreturn 0 ; } -static int bool_isvalid (struct cond_bool_datum *b) -{ -if (!(b->state ==0 || b->state ==1 )) -return 0 ; -return 1 ; -} -int cond_read_bool (struct policydb *p,struct symtab *s,struct policy_file *fp) {char *key =NULL ;struct cond_bool_datum *booldatum;__le32 buf[3 ]; -u32 len; +u32 len, val;int rc; booldatum =kzalloc (sizeof (*booldatum),GFP_KERNEL );
@@ -223,11 +216,12 @@ int cond_read_bool(struct policydb *p, s goto err; booldatum->value =le32_to_cpu (buf[0 ]); - booldatum->state =le32_to_cpu (buf[1 ]); + val =le32_to_cpu (buf[1 ]); rc = -EINVAL ; -if (!bool_isvalid (booldatum)) +if (!val_is_boolean (val)) goto err; + booldatum->state = (int )val; len =le32_to_cpu (buf[2 ]);
@@ -241,6 +235,7 @@ int cond_read_bool(struct policydb *p, sreturn 0 ; err: +pr_err ("SELinux: conditional: failed to read boolean\n" );cond_destroy_bool (key, booldatum,NULL );return rc; }
@@ -362,7 +357,8 @@ static int expr_node_isvalid(struct polireturn 0 ; } -if (expr->boolean > p->p_bools.nprim) { +if (expr->expr_type ==COND_BOOL && + (expr->boolean ==0 || expr->boolean > p->p_bools.nprim)) {pr_err ("SELinux: conditional expressions uses unknown bool.\n" );return 0 ; }
security/selinux/ss/constraint.h +1 -0
@@ -50,6 +50,7 @@ struct constraint_expr {u32 op;/* operator */ struct ebitmap names;/* names */ +/* internally unused, only forwarded via policydb_write() */ struct type_set *type_names;struct constraint_expr *next;/* next expression */
security/selinux/ss/policydb.c +161 -35
402 lines not on this page · raw message
security/selinux/ss/policydb.h +19 -4
@@ -74,7 +74,7 @@ struct class_datum {/* Role attributes */ struct role_datum {u32 value;/* internal role value */ -u32 bounds;/* boundary of role */ +u32 bounds;/* boundary of role, 0 for none */ struct ebitmap dominates;/* set of roles dominated by this role */ struct ebitmap types;/* set of authorized types for role */ };
@@ -110,7 +110,8 @@ struct role_allow {/* Type attributes */ struct type_datum {u32 value;/* internal type value */ -u32 bounds;/* boundary of type */ +u32 bounds;/* boundary of type, 0 for none */ +/* internally unused, only forwarded via policydb_write() */ unsigned char primary;/* primary name? */ unsigned char attribute;/* attribute ?*/ };
@@ -118,7 +119,7 @@ struct type_datum {/* User attributes */ struct user_datum {u32 value;/* internal user value */ -u32 bounds;/* bounds of user */ +u32 bounds;/* bounds of user, 0 for none */ struct ebitmap roles;/* set of authorized roles for user */ struct mls_range range;/* MLS range (min - max) for user */ struct mls_level dfltlevel;/* default login MLS level for user */
@@ -195,7 +196,7 @@ struct ocontext { } ibendport; } u;union { -u16 sclass;/* security class for genfs */ +u16 sclass;/* security class for genfs (can be 0 for wildcard) */ u32 behavior;/* labeling behavior for fs_use */ } v;struct context context[2 ];/* security context(s) */
@@ -388,9 +389,23 @@ static inline char *sym_name(struct poli return p->sym_val_to_name[sym_num][element_nr]; } +static inline bool val_is_boolean (u32 value) +{ +return value ==0 || value ==1 ; +} +extern int str_read (char **strp,gfp_t flags,struct policy_file *fp,u32 len);extern u16 string_to_security_class (struct policydb *p,const char *name);extern u32 string_to_av_perm (struct policydb *p,u16 tclass,const char *name); +#define pr_warn_once_policyload (policy, fmt, ...) \ + do { \ + static const void *prev_policy__; \ + if (prev_policy__ != policy) { \ + pr_warn(fmt, ##__VA_ARGS__); \ + prev_policy__ = policy; \ + } \ + } while (0) +#endif /* _SS_POLICYDB_H_ */
security/selinux/ss/services.c +2 -4
@@ -446,8 +446,6 @@ static int dump_masked_av_helper(void *kstruct perm_datum *pdatum = d;char **permission_names = args; -BUG_ON (pdatum->value <1 || pdatum->value >32 ); - permission_names[pdatum->value -1 ] = (char *)k;return 0 ;
@@ -466,7 +464,7 @@ static void security_dump_masked_av(struchar *tclass_name;char *scontext_name =NULL ;char *tcontext_name =NULL ; -char *permission_names[32 ]; +char *permission_names[SEL_VEC_MAX ];int index;u32 length;bool need_comma = false;
@@ -507,7 +505,7 @@ static void security_dump_masked_av(stru"scontext=%s tcontext=%s tclass=%s perms=" , reason, scontext_name, tcontext_name, tclass_name); -for (index =0 ; index <32 ; index++) { +for (index =0 ; index <SEL_VEC_MAX ; index++) {u32 mask = (1 << index);if ((mask & permissions) ==0 )
Greg Kroah-Hartman
maintainerPATCH 63/94 selinux: require a classs permission values to cover its permission count
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Bryam Vargas <[email protected]>
[ Upstream commit b98a8ac50775540f3804397ed08f61ef9910bcab ]
security_get_permissions() sizes an array by the class's permissions.nprim and fills it at value - 1, from the inherited common's permission table and then the class's own. A value no permission defines leaves a NULL that sel_make_perm_files() passes to d_alloc_name(), an oops inside sel_write_load() that strands selinux_state.policy_mutex and leaves every later load in uninterruptible sleep; two permissions sharing a value overwrite the first kstrdup(). Bounding each value by nprim catches neither, and neither would a count: the symbol table is keyed on the permission name, so duplicates pass.
Track the values each permission table claims and require them to cover exactly what its count declares, rejecting a count no value can reach. Conforming policies are unaffected.
--- security/selinux/ss/policydb.c | 51 ++++++++++++++++++++++++++++++++++++----- 1 file changed, 46 insertions(+), 5 deletions(-)
security/selinux/ss/policydb.c +46 -5
@@ -1139,7 +1139,18 @@ int str_read(char **strp, gfp_t flags, sreturn 0 ; } -static int perm_read (struct policydb *p,struct symtab *s,struct policy_file *fp) +/* +* Bitmap of the permission values a symtab has claimed. Values are 1-based +* and bounded by SEL_VEC_MAX, the width of an access vector, so the whole set +* fits in a u32 and the callers reject an nprim past that width. +*/ +static u32 perm_claimed_mask (u32 nprim) +{ +return nprim ?U32_MAX >> (SEL_VEC_MAX - nprim) :0 ; +} + +static int perm_read (struct policydb *p,struct symtab *s, +struct policy_file *fp,u32 *claimed) {char *key =NULL ;struct perm_datum *perdatum;
@@ -1171,6 +1182,10 @@ static int perm_read(struct policydb *p,/* indexes an nprim-sized array in security_get_permissions() */ if (perdatum->value > s->nprim) goto bad; +/* two permissions cannot share one slot of that array */ +if (*claimed & (1U << (perdatum->value -1 ))) + goto bad; + *claimed |=1U << (perdatum->value -1 );return 0 ; bad:
@@ -1183,7 +1198,7 @@ static int common_read(struct policydb *char *key =NULL ;struct common_datum *comdatum;__le32 buf[4 ]; -u32 i, len, nel; +u32 i, len, nel, claimed =0 ;int rc; comdatum =kzalloc (sizeof (*comdatum),GFP_KERNEL );
@@ -1205,17 +1220,28 @@ static int common_read(struct policydb *if (rc) goto bad; comdatum->permissions.nprim =le32_to_cpu (buf[2 ]); +/* no permission value can reach a slot past SEL_VEC_MAX */ + rc = -EINVAL ; +if (comdatum->permissions.nprim >SEL_VEC_MAX ) + goto bad; rc =str_read (&key,GFP_KERNEL , fp, len);if (rc) goto bad;for (i =0 ; i < nel; i++) { - rc =perm_read (p, &comdatum->permissions, fp); + rc =perm_read (p, &comdatum->permissions, fp, &claimed);if (rc) goto bad; } + rc = -EINVAL ; +if (claimed !=perm_claimed_mask (comdatum->permissions.nprim)) { +pr_err ("SELinux: common %s does not define every permission it declares\n" , + key); + goto bad; + } +hash_eval (&comdatum->permissions.table,"common_permissions" , key); rc =symtab_insert (s, key, comdatum);
@@ -1351,7 +1377,7 @@ static int class_read(struct policydb *pchar *key =NULL ;struct class_datum *cladatum;__le32 buf[6 ]; -u32 i, len, len2, ncons, nel, val; +u32 i, len, len2, ncons, nel, val, claimed =0 , inherited =0 ;int rc; cladatum =kzalloc (sizeof (*cladatum),GFP_KERNEL );
@@ -1379,6 +1405,10 @@ static int class_read(struct policydb *pif (rc) goto bad; cladatum->permissions.nprim =le32_to_cpu (buf[3 ]); +/* no permission value can reach a slot past SEL_VEC_MAX */ + rc = -EINVAL ; +if (cladatum->permissions.nprim >SEL_VEC_MAX ) + goto bad; ncons =le32_to_cpu (buf[5 ]);
@@ -1413,11 +1443,22 @@ static int class_read(struct policydb *p } }for (i =0 ; i < nel; i++) { - rc =perm_read (p, &cladatum->permissions, fp); + rc =perm_read (p, &cladatum->permissions, fp, &claimed);if (rc) goto bad; } +/* the class's own permissions must claim the slots the common leaves */ +if (cladatum->comdatum) + inherited = cladatum->comdatum->permissions.nprim; + rc = -EINVAL ; +if (claimed != (perm_claimed_mask (cladatum->permissions.nprim) & + ~perm_claimed_mask (inherited))) { +pr_err ("SELinux: class %s does not define every permission it declares\n" , + key); + goto bad; + } +hash_eval (&cladatum->permissions.table,"class_permissions" , key); rc =read_cons_helper (p, &cladatum->constraints, ncons,0 , fp);
Greg Kroah-Hartman
maintainerPATCH 64/94 ASoC: codecs: lpass-tx-macro: Fix enum kcontrol accesses
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Dawid Wróbel <[email protected]>
[ Upstream commit 1ba381759e45d5d0442452cfa5c42e836191a568 ]
The "DEC0 MODE" to "DEC7 MODE" controls are enumerated, but tx_macro_dec_mode_get() and tx_macro_dec_mode_put() access their value through ucontrol->value.integer.value[0] (a long) instead of ucontrol->value.enumerated.item[0] (an unsigned int).
This same pattern was fixed in the sibling drivers by commit bcfe5f76cc40 ("ASoC: codecs: rx-macro: fix accessing array out of bounds for enum type") and
commit 0ea5eff7c606 ("ASoC: codecs: va-macro: fix accessing array out of bounds for enum type"), but tx-macro was missed.
On 64-bit kernels built with CONFIG_SND_CTL_DEBUG, the elem value sanity check catches the 4 bytes written past the enumerated item and every read of these controls fails with -EINVAL:
snd-sm8250 sound: control 2:0:0:DEC0 MODE:0: access overflow
--- sound/soc/codecs/lpass-tx-macro.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
sound/soc/codecs/lpass-tx-macro.c +2 -2
@@ -1075,7 +1075,7 @@ static int tx_macro_dec_mode_get(structstruct soc_enum *e = (struct soc_enum *)kcontrol->private_value;int path = e->shift_l; - ucontrol->value.integer.value[0 ] = tx->dec_mode[path]; + ucontrol->value.enumerated.item[0 ] = tx->dec_mode[path];return 0 ; }
@@ -1084,7 +1084,7 @@ static int tx_macro_dec_mode_put(struct struct snd_ctl_elem_value *ucontrol) {struct snd_soc_component *component =snd_soc_kcontrol_component (kcontrol); -int value = ucontrol->value.integer.value[0 ]; +int value = ucontrol->value.enumerated.item[0 ];struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;int path = e->shift_l;struct tx_macro *tx =snd_soc_component_get_drvdata (component);
Greg Kroah-Hartman
maintainerPATCH 65/94 HID: magicmouse: fix battery reporting for Bluetooth Magic Trackpad USB-C
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Andrei Fed <[email protected]>
commit a1556b48efc157fdda07b52ecc56c7bd1e1786f0 upstream.
The Apple Magic Trackpad 2 (USB-C) reports a wildly wrong battery capacity over Bluetooth, for example a constant 4% for a pack that is actually at 74%.
The device's battery input report (0x90) is laid out as [report-id][status][charge]. hid-input's synchronous capacity query, hidinput_query_battery_capacity(), assumes the common [report-id][capacity] layout and returns buf[1], which for this device is the status byte rather than the charge (buf[2]).
magicmouse_fetch_battery(), which requests the battery report through hid_hw_request() so the reply is decoded via the report descriptor at the correct field offset, is gated to the USB models and never runs over Bluetooth. The device does not push battery reports on its own either, except a single one at connect time, which is delivered while probe holds driver_input_lock and is silently dropped. All userspace reads therefore go through the misparsing query, and the device is stuck reporting its status byte as the capacity.
Enabling the fetch for Bluetooth is not sufficient on its own: user space reacts to the power_supply registration immediately, so a query is typically already in flight when the fetch reply is parsed. hidinput_get_battery_property() stores the query result and marks the battery as queried without rechecking whether a report arrived while it was waiting, clobbering the just-reported correct value with the misparsed one.
Fix this by adding HID_BATTERY_QUIRK_AVOID_QUERY for the Bluetooth Magic Trackpad USB-C so the misparsing query path is never used, and by fetching the battery at the end of probe for this device. hidp has no asynchronous request() callback, so the fetch is serviced synchronously via __hid_request() while probe still holds driver_input_lock; call hid_device_io_start() first so the reply is processed instead of being discarded.
Tested with a Magic Trackpad USB-C (004c:0324) over Bluetooth on 6.18.37: the reported capacity now matches the device (verified against a raw GET_REPORT of report 0x90) and updates on reconnect.
--- drivers/hid/hid-input.c | 3 +++ drivers/hid/hid-magicmouse.c | 19 ++++++++++++++++++- 2 files changed, 21 insertions(+), 1 deletion(-)
drivers/hid/hid-input.c +3 -0
@@ -374,6 +374,9 @@ static const struct hid_device_id hid_ba {HID_BLUETOOTH_DEVICE (USB_VENDOR_ID_APPLE ,USB_DEVICE_ID_APPLE_MAGICTRACKPAD ), HID_BATTERY_QUIRK_IGNORE }, + { HID_BLUETOOTH_DEVICE(BT_VENDOR_ID_APPLE, +USB_DEVICE_ID_APPLE_MAGICTRACKPAD2_USBC ), + HID_BATTERY_QUIRK_AVOID_QUERY }, { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ELECOM,USB_DEVICE_ID_ELECOM_BM084 ), HID_BATTERY_QUIRK_IGNORE },
drivers/hid/hid-magicmouse.c +18 -1
@@ -812,6 +812,12 @@ static bool is_usb_magictrackpad2(__u32 product ==USB_DEVICE_ID_APPLE_MAGICTRACKPAD2_USBC ; } +static bool is_bt_magictrackpad2 (__u32 vendor,__u32 product) +{ +return vendor ==BT_VENDOR_ID_APPLE && + product ==USB_DEVICE_ID_APPLE_MAGICTRACKPAD2_USBC ; +} +static int magicmouse_fetch_battery (struct hid_device *hdev) {#ifdef CONFIG_HID_BATTERY_STRENGTH
@@ -820,7 +826,8 @@ static int magicmouse_fetch_battery(struif (!hdev->battery || (!is_usb_magicmouse2 (hdev->vendor, hdev->product) && - !is_usb_magictrackpad2 (hdev->vendor, hdev->product))) + !is_usb_magictrackpad2 (hdev->vendor, hdev->product) && + !is_bt_magictrackpad2 (hdev->vendor, hdev->product)))return -1 ; report_enum = &hdev->report_enum[hdev->battery_report_type];
@@ -953,6 +960,16 @@ static int magicmouse_probe(struct hid_dschedule_delayed_work (&msc->work,msecs_to_jiffies (500 )); } +/* +* Query the Bluetooth Magic Trackpad USB-C battery as done for USB. +* Start io first: probe holds driver_input_lock and the synchronous +* GET_REPORT reply would otherwise be dropped. +*/ +if (is_bt_magictrackpad2 (id->vendor, id->product)) { +hid_device_io_start (hdev); +magicmouse_fetch_battery (hdev); + } +return 0 ; err_stop_hw: if (is_usb_magicmouse2(id->vendor, id->product) ||
Greg Kroah-Hartman
maintainerPATCH 66/94 HID: magicmouse: re-enable multitouch after reset-resume
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Christopher Kodama <[email protected]>
commit 4253fe22b137c4ee68f36b707fdb1b44b191edc4 upstream.
When the Apple Magic Trackpad 2 (USB) is reset across a power transition (e.g. resume from hibernation) it drops out of multitouch mode: it keeps sending report ID 0x02 on its HID_TYPE_USBMOUSE interface, but the packet shrinks from 21 to 8 bytes and the trackpad2 handler drops it (size < 12). Clicks still work but pointer motion is lost until the device is re-plugged or the driver reloaded.
Re-enable multitouch from .reset_resume via the workqueue. Only .reset_resume is needed; suspend-to-idle keeps the device powered and retains multitouch.
--- drivers/hid/hid-magicmouse.c | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+)
drivers/hid/hid-magicmouse.c +19 -0
@@ -994,6 +994,22 @@ static void magicmouse_remove(struct hidhid_hw_stop (hdev); } +#ifdef CONFIG_PM +static int magicmouse_reset_resume (struct hid_device *hdev) +{ +struct magicmouse_sc *msc =hid_get_drvdata (hdev); + +/* The device drops out of multitouch mode on resume; re-send the +* enable report. Only the HID_TYPE_USBMOUSE interface accepts it, and +* it must be deferred. Sending it inline here is too early. +*/ +if (msc && hdev->type ==HID_TYPE_USBMOUSE ) +schedule_delayed_work (&msc->work,msecs_to_jiffies (500 )); + +return 0 ; +} +#endif +static const __u8 *magicmouse_report_fixup (struct hid_device *hdev,__u8 *rdesc,unsigned int *rsize) {
@@ -1057,6 +1073,9 @@ static struct hid_driver magicmouse_driv .event = magicmouse_event, .input_mapping = magicmouse_input_mapping, .input_configured = magicmouse_input_configured, +#ifdef CONFIG_PM + .reset_resume = magicmouse_reset_resume, +#endif };module_hid_driver (magicmouse_driver);
Greg Kroah-Hartman
maintainerPATCH 67/94 HID: magicmouse: do not keep a stale msc->input if no input is claimed
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Jose Villaseñor Montfort <[email protected]>
commit 0af3b89705688af01aa06025b84fa7a1e06ba6cc upstream.
magicmouse_input_mapping() caches the first hid_input's input_dev in msc->input while the report descriptor is parsed, and the rest of the driver treats a non-NULL msc->input as proof that an input device was registered.
That does not hold on the hid-input error path. If hidinput_connect() fails -- for instance because input_register_device() returns an error -- it unwinds through hidinput_disconnect(), which frees every input_dev it created, including the one cached in msc->input.
The failure does not abort the probe. hid_connect() only skips the claim:
if ((connect_mask & HID_CONNECT_HIDINPUT) && !hidinput_connect(hdev, connect_mask & HID_CONNECT_HIDINPUT_FORCE)) hdev->claimed |= HID_CLAIMED_INPUT;
and the "device has no listeners" bailout below it does not fire for this driver, which sets ->raw_event; on the USB Magic Mouse 2 / Magic Trackpad 2 paths hidraw and hiddev are claimed as well. hid_hw_start() therefore returns 0 and magicmouse_probe() continues with msc->input pointing at freed memory. Being non-NULL, it passes the "input not registered" check in probe and the NULL checks in ->raw_event and ->event, so the next input report dereferences freed memory.
Clear msc->input when the HID core did not claim an input device, so the existing NULL checks cover this case as well.
--- drivers/hid/hid-magicmouse.c | 10 ++++++++++ 1 file changed, 10 insertions(+)
drivers/hid/hid-magicmouse.c +10 -0
@@ -889,6 +889,16 @@ static int magicmouse_probe(struct hid_dreturn ret; } +/* +* When hidinput_connect() fails it frees every input device it +* created, but that does not fail hid_hw_start(): the core simply +* does not claim an input. msc->input, cached in ->input_mapping +* while the report descriptor was parsed, would then be a dangling +* pointer that passes every NULL check. Trust the core's claim. +*/ +if (!(hdev->claimed &HID_CLAIMED_INPUT )) + msc->input =NULL ; +if (is_usb_magicmouse2 (id->vendor, id->product) ||is_usb_magictrackpad2 (id->vendor, id->product)) {timer_setup (&msc->battery_timer, magicmouse_battery_timer_tick,0 );
Greg Kroah-Hartman
maintainerPATCH 68/94 HID: magicmouse: Prevent out-of-bounds (OOB) read during DOUBLE_REPORT_ID
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Lee Jones <[email protected]>
commit d93ba918a185aca2594da63e92fdc5495b559c0f upstream.
It is currently possible for a malicious or misconfigured USB device to cause an out-of-bounds (OOB) read when submitting reports using DOUBLE_REPORT_ID by specifying a large report length and providing a smaller one.
Let's prevent that by comparing the specified report length with the actual size of the data read in from userspace. If the actual data length ends up being smaller than specified, we'll politely warn the user and prevent any further processing.
--- drivers/hid/hid-magicmouse.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)
drivers/hid/hid-magicmouse.c +16 -0
@@ -390,6 +390,10 @@ static int magicmouse_raw_event(struct hstruct input_dev *input = msc->input;int x =0 , y =0 , ii, clicks =0 , npoints; +/* Protect against zero sized recursive calls from DOUBLE_REPORT_ID */ +if (size <1 ) +return 0 ; +switch (data[0 ]) {case TRACKPAD_REPORT_ID :case TRACKPAD2_BT_REPORT_ID :
@@ -490,6 +494,18 @@ static int magicmouse_raw_event(struct h/* Sometimes the trackpad sends two touch reports in one * packet. */ + +/* Ensure that we have at least 2 elements (report type and size) */ +if (size <2 ) +return 0 ; + +if (size < data[1 ] +2 ) { +hid_warn (hdev, +"received report length (%d) was smaller than specified (%d)" , + size, data[1 ] +2 ); +return 0 ; + } +magicmouse_raw_event (hdev, report, data +2 , data[1 ]);magicmouse_raw_event (hdev, report, data +2 + data[1 ], size -2 - data[1 ]);
Greg Kroah-Hartman
maintainerPATCH 69/94 HID: core: fix OOB read of field->usage in hid_set_field()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Baul Lee <[email protected]>
commit a13cdb19fcb223ed41bdab3bab42b98dba87e90b upstream.
hid_set_field() hands field->usage + offset to hid_dump_input() before the guard that bounds offset:
hid_dump_input(field->report->device, field->usage + offset, value);
if (offset >= field->report_count) {
hid_err(...);
return -1;
}Under CONFIG_DEBUG_FS hid_dump_input() dereferences that pointer, with buf = hid_resolv_usage(usage->hid, NULL). The usage[] array is allocated inline with the hid_field in hid_register_field() and holds field->maxusage entries, so an offset past it reads off the end of the kvzalloc()ed allocation and into a neighbouring object. Had the guard run first, offset < report_count <= maxusage would already have confined the pointer to the array.
A caller supplies such an offset today. picolcd_fb_send_tile() validates only report->maxfield before issuing hid_set_field(report->field[0], 11 + i, ...) for i = 0..31, so its offsets are fixed at 11..42 and are never checked against the bound field. When the device registers that field with fewer usages, the framebuffer deferred-io work drives the read on every tile. KASAN reports a 4-byte slab-out-of-bounds read in hid_dump_input() below hid_set_field(), and the same boot logs "offset (1) exceeds report_count (1)" from the guard that runs only afterwards.
Move the hid_dump_input() call below the guard. Because field->maxusage >= field->report_count, the guard then establishes that field->usage + offset lies inside the array before it is dereferenced, for every caller and without changing behaviour on the valid path.
Discovered by XBOW, triaged by Baul Lee <[email protected]>
--- drivers/hid/hid-core.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
drivers/hid/hid-core.c +3 -2
@@ -1925,13 +1925,14 @@ int hid_set_field(struct hid_field *fiel size = field->report_size; -hid_dump_input (field->report->device, field->usage + offset, value); -if (offset >= field->report_count) {hid_err (field->report->device,"offset (%d) exceeds report_count (%d)\n" , offset, field->report_count);return -1 ; } + +hid_dump_input (field->report->device, field->usage + offset, value); +if (field->logical_minimum <0 ) {if (value !=snto32 (s32ton (value, size), size)) {hid_err (field->report->device,"value %d is out of range\n" , value);
Greg Kroah-Hartman
maintainerPATCH 70/94 HID: pidff: fix OOB write when hid->inputs is empty
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Baul Lee <[email protected]>
commit 67bb1074e3d2d12fa059a9cc707e89398a4e4704 upstream.
hid_pidff_init_with_quirks() derives its input_dev from
list_entry(hid->inputs.next, struct hid_input, list)
without first checking that hid->inputs is non-empty. The list member of struct hid_input is at offset 0, so on an empty list list_entry() yields &hid->inputs itself and the following hidinput->input load reads an unrelated member of struct hid_device. dev is then a type-confused pointer, and force-feedback init writes through it: each set_bit(FF_*, dev->ffbit) stores 8 bytes at dev + 192, past the end of the object dev actually aliases, and input_ff_create() adds further writes of a heap pointer and two function pointers.
Until hid-universal-pidff the only caller was hid_pidff_init() from usbhid, which runs under HID_CLAIMED_INPUT and therefore always has at least one hid_input. universal_pidff_probe() starts the device with HID_CONNECT_DEFAULT & ~HID_CONNECT_FF and then calls hid_pidff_init_with_quirks() directly whenever the descriptor carries a PID usage page, bypassing that gate. A report descriptor whose only application collection is on HID_UP_PID leaves hid->inputs empty while hid_connect() still succeeds through the hidraw claim, so probe reaches the unguarded list_entry().
The write happens in the USB probe path, on the hotplug workqueue, so plugging in a malicious device is enough to trigger it; no attacker software and no logged-in user are required. KASAN reports an 8-byte out-of-bounds write in hid_pidff_init_with_quirks() reached from universal_pidff_probe().
Check for an empty list before deriving dev and return -ENODEV, as the other HID force-feedback drivers already do. universal_pidff_probe() propagates the error and unwinds.
Discovered by XBOW, triaged by Baul Lee <[email protected]>
--- drivers/hid/usbhid/hid-pidff.c | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-)
drivers/hid/usbhid/hid-pidff.c +10 -3
@@ -1520,13 +1520,20 @@ static int pidff_check_autocenter(structint hid_pidff_init_with_quirks (struct hid_device *hid,u32 initial_quirks) {struct pidff_device *pidff; -struct hid_input *hidinput = - list_entry(hid->inputs.next, struct hid_input, list); -struct input_dev *dev = hidinput->input; +struct hid_input *hidinput; +struct input_dev *dev;struct ff_device *ff;int max_effects;int error; +if (list_empty (&hid->inputs)) { +hid_err (hid,"no inputs found\n" ); +return -ENODEV ; + } + + hidinput = list_first_entry(&hid->inputs, struct hid_input, list); + dev = hidinput->input; +hid_dbg (hid,"starting pid init\n" );if (list_empty (&hid->report_enum[HID_OUTPUT_REPORT ].report_list)) {
Greg Kroah-Hartman
maintainerPATCH 71/94 net/ionic: avoid OOB TX partner lookup for hwstamp RXQ
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Anand Khoje <[email protected]>
commit d92255b405fb6f5acca408239ccd742e0a42c9cb upstream.
The dedicated hardware timestamp RX queue is allocated with q->index equal to lif->ionic->nrxqs_per_lif. The normal txqcqs array only contains the regular queue pairs, so using that index to set rxq->partner can read one entry past txqcqs[] and then write through the derived pointer.
Only link RX/TX partners for normal queue-pair indexes. Leave the hwstamp RX queue unpaired, and make the XDP_TX path abort cleanly if an RX queue has no TX partner.
--- drivers/net/ethernet/pensando/ionic/ionic_lif.c | 17 +++++++++++++++-- drivers/net/ethernet/pensando/ionic/ionic_txrx.c | 7 ++++++- 2 files changed, 21 insertions(+), 3 deletions(-)
drivers/net/ethernet/pensando/ionic/ionic_lif.c +15 -2
@@ -918,8 +918,21 @@ static int ionic_lif_rxq_init(struct ion };int err; - q->partner = &lif->txqcqs[q->index]->q; - q->partner->partner = q; + q->partner =NULL ; + +/* Only normal RX queues have matching TX queue partners. */ +if (q->index < lif->nxqs) { +if (!lif->txqcqs || + q->index >= lif->ionic->ntxqs_per_lif || + !lif->txqcqs[q->index]) { +dev_err (dev,"missing TX queue partner for RX queue %u\n" , + q->index); +return -ENXIO ; + } + + q->partner = &lif->txqcqs[q->index]->q; + q->partner->partner = q; + }if (!lif->xdp_prog || (lif->xdp_prog->aux && lif->xdp_prog->aux->xdp_has_frags))
drivers/net/ethernet/pensando/ionic/ionic_txrx.c +6 -1
@@ -545,13 +545,18 @@ static bool ionic_run_xdp(struct ionic_rbreak ;case XDP_TX : + txq = rxq->partner; +if (unlikely (!txq)) { + err = -EIO ; +break ; + } + xdpf =xdp_convert_buff_to_frame (&xdp_buf);if (!xdpf) { err = -ENOSPC ;break ; } - txq = rxq->partner; nq =netdev_get_tx_queue (netdev, txq->index);__netif_tx_lock (nq,smp_processor_id ());txq_trans_cond_update (nq);
Greg Kroah-Hartman
maintainerPATCH 72/94 xfrm: fix sk_dst_cache double-free in xfrm_user_policy()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Xiang Mei (Microsoft) <[email protected]>
[ Upstream commit c283e9ada7fcb7dd4b10592623086b2e6d2f9925 ]
xfrm_user_policy() clears the socket dst cache with __sk_dst_reset(), i.e. the non-atomic __sk_dst_set(sk, NULL): it reads sk_dst_cache with rcu_dereference_protected(), stores NULL and dst_release()s the old dst. That is only safe if no other thread modifies sk_dst_cache concurrently.
For a connected UDP socket that does not hold: the transmit fast path (udp_sendmsg -> sk_dst_check -> sk_dst_reset) resets the cache locklessly with an atomic xchg(). A per-socket policy change racing a send can make both sides observe the same old dst and each dst_release() it, dropping the socket's single reference twice and freeing the xfrm_dst bundle while it is still referenced:
BUG: KASAN: slab-use-after-free in dst_release Write of size 4 at addr ffff88801897b6c0 by task exploit/155 Call Trace: ... dst_release (... ./include/linux/rcuref.h:109) xfrm_user_policy (./include/net/sock.h:2239 ./include/net/sock.h:2256 net/xfrm/xfrm_state.c:3053) do_ip_setsockopt (net/ipv4/ip_sockglue.c:1347) ip_setsockopt (net/ipv4/ip_sockglue.c:1417) do_sock_setsockopt (net/socket.c:2368) __sys_setsockopt (net/socket.c:2393) __x64_sys_setsockopt (net/socket.c:2396) do_syscall_64 (arch/x86/entry/syscall_64.c:94) entry_SYSCALL_64_after_hwframe (arch/x86/entry/entry_64.S:121)
Reachable by an unprivileged user via a user+network namespace.
Use the atomic sk_dst_reset() so the cache is cleared and released with a single xchg(): whichever side wins releases the dst once, the other sees NULL and does nothing. Behaviour is otherwise unchanged.
--- net/xfrm/xfrm_state.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
net/xfrm/xfrm_state.c +2 -2
@@ -2975,7 +2975,7 @@ int xfrm_user_policy(struct sock *sk, int optname, sockptr_t optval, int optlen)if (sockptr_is_null (optval) && !optlen) {xfrm_sk_policy_insert (sk,XFRM_POLICY_IN ,NULL );xfrm_sk_policy_insert (sk,XFRM_POLICY_OUT ,NULL ); -__sk_dst_reset (sk); +sk_dst_reset (sk);return 0 ; }
@@ -3015,7 +3015,7 @@ int xfrm_user_policy(struct sock *sk, int optname, sockptr_t optval, int optlen)if (err >=0 ) {xfrm_sk_policy_insert (sk, err, pol);xfrm_pol_put (pol); -__sk_dst_reset (sk); +sk_dst_reset (sk); err =0 ; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 73/94 Input: atkbd - skip deactivate for HONOR FMB-Ps internal keyboard
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Cryolitia PukNgae <[email protected]>
[ Upstream commit 2aaf33c6e1e82561d7dce2345298a985a2483266 ]
After commit 9cf6e24c9fbf17e52de9fff07f12be7565ea6d61 ("Input: atkbd - do not skip atkbd_deactivate() when skipping ATKBD_CMD_GETID"), HONOR FMB-P, aka HONOR MagicBook Pro 14 2025's internal keyboard stops working. Adding the atkbd_deactivate_fixup quirk fixes it.
DMI: HONOR FMB-P/FMB-P-PCB, BIOS 1.13 05/08/2025
Stable-dep-of: 410c44b10967 ("Input: atkbd - skip deactivate for HONOR ZQC-P")
--- drivers/input/keyboard/atkbd.c | 7 +++++++ 1 file changed, 7 insertions(+)
drivers/input/keyboard/atkbd.c +7 -0
@@ -1938,6 +1938,13 @@ static const struct dmi_system_id atkbd_ .callback = atkbd_deactivate_fixup, }, { + .matches = { +DMI_MATCH (DMI_SYS_VENDOR ,"HONOR" ), + DMI_MATCH(DMI_PRODUCT_NAME, "FMB-P"), + }, + .callback = atkbd_deactivate_fixup, + }, + {/* Lenovo Yoga Air 14 (83QK) */ .matches = { DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
Greg Kroah-Hartman
maintainerPATCH 74/94 Input: atkbd - skip deactivate for HONOR ZQC-P
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Donglin Lyu <[email protected]>
[ Upstream commit 410c44b1096789d0c40fbee706520e981dba7bc1 ]
The internal keyboard on the HONOR ZQC-P (HONOR MagicBook Pro 14 2026) does not work after boot.
Using the kernel command line 'i8042.dumbkbd=1' makes the keyboard functional, but the CapsLock LED does not work. Adding the 'atkbd_deactivate_fixup' quirk fixes the keyboard and CapsLock LED natively without requiring boot parameters.
DMI: HONOR ZQC-P/ZQC-P-PCB, BIOS 1.09 03/19/2026
--- drivers/input/keyboard/atkbd.c | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-)
drivers/input/keyboard/atkbd.c +13 -5
@@ -1940,22 +1940,30 @@ static const struct dmi_system_id atkbd_ { .matches = { DMI_MATCH(DMI_SYS_VENDOR, "HONOR"), - DMI_MATCH(DMI_PRODUCT_NAME, "FMB-P"), + DMI_MATCH(DMI_PRODUCT_NAME, "BCC-N"), }, .callback = atkbd_deactivate_fixup, }, { - /* Lenovo Yoga Air 14 (83QK) */ .matches = { - DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), - DMI_MATCH(DMI_PRODUCT_NAME, "83QK"), + DMI_MATCH(DMI_SYS_VENDOR, "HONOR"), + DMI_MATCH(DMI_PRODUCT_NAME, "FMB-P"), }, .callback = atkbd_deactivate_fixup, }, { + /* HONOR MagicBook Pro 14 2026 */ .matches = { DMI_MATCH(DMI_SYS_VENDOR, "HONOR"), - DMI_MATCH(DMI_PRODUCT_NAME, "BCC-N"), + DMI_MATCH(DMI_PRODUCT_NAME, "ZQC-P"), + }, + .callback = atkbd_deactivate_fixup, + }, + { + /* Lenovo Yoga Air 14 (83QK) */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), + DMI_MATCH(DMI_PRODUCT_NAME, "83QK"), }, .callback = atkbd_deactivate_fixup, },
Greg Kroah-Hartman
maintainerPATCH 75/94 futex/pi: Reject cross-mm private futex owners
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Kyle Zeng <[email protected]>
commit 59b3732f95dda1fbd2234514d35f4fb6b5bb6d85 upstream.
A private futex key borrows the waiter's mm without taking an mm_users reference. Nevertheless, attach_to_pi_owner() currently accepts an owner from a different address space and copies the private key into the owner's PI state.
When that owner exits, exit_pi_state_list() uses the saved key to find the hash bucket and acquires a reference to the waiter's private hash. If the last user of the waiter's mm exits concurrently, futex_hash_free() frees the hash while the owner still uses its bucket and reference.
Prevent this by validating in attach_to_pi_owner() that, for private futexes, the owner mm and waiter mm are the same. Perform the check with the owner's pi_lock held and after validating owner::futex::state to serialize against a concurrent PI-state exit cleanup.
[ tglx: Amended comment ]
--- kernel/futex/core.c | 9 --------- kernel/futex/futex.h | 9 +++++++++ kernel/futex/pi.c | 20 ++++++++++++++++++++ 3 files changed, 29 insertions(+), 9 deletions(-)
---
kernel/futex/core.c +0 -9
@@ -133,15 +133,6 @@ static bool futex_ref_is_dead(struct futenum {FR_PERCPU =0 ,FR_ATOMIC }; -static inline bool futex_key_is_private (union futex_key *key) -{ -/* -* Relies on get_futex_key() to set either bit for shared -* futexes -- see comment with union futex_key. -*/ -return !(key->both.offset & (FUT_OFF_INODE |FUT_OFF_MMSHARED )); -} -static bool futex_private_hash_get (struct futex_private_hash *fph) {return futex_ref_get (fph);
kernel/futex/futex.h +9 -0
@@ -126,6 +126,15 @@ static inline bool should_fail_futex(boo }#endif +static inline bool futex_key_is_private (union futex_key *key) +{ +/* +* Relies on get_futex_key() to set either bit for shared +* futexes -- see comment with union futex_key. +*/ +return !(key->both.offset & (FUT_OFF_INODE |FUT_OFF_MMSHARED )); +} +/* * Hash buckets are shared by all the futex_keys that hash to the same * location. Each key may have multiple futex_q structures, one for each task
kernel/futex/pi.c +20 -0
@@ -464,6 +464,26 @@ static int attach_to_pi_owner(u32 __userreturn ret; } +/* +* If the owner is about to exit() or exec() and tries to modify +* p::futex::exit_state it is serialized against this code by +* p::pi_lock. +*/ +if (IS_ENABLED (CONFIG_MMU ) &&futex_key_is_private (key)) { +/* +* A private futex key holds a pointer to the waiter's mm +* without holding a reference on it. So it must not be attached +* to an owner in a different address space. Otherwise that +* owner's exit cleanup could access the private hash after the +* key's mm is freed. +*/ +if (unlikely (p->mm != key->private.mm)) { +raw_spin_unlock_irq (&p->pi_lock); +put_task_struct (p); +return -EPERM ; + } + } +__attach_to_pi_owner (p, key, ps);raw_spin_unlock_irq (&p->pi_lock);
Greg Kroah-Hartman
maintainerPATCH 76/94 futex: Sanitize and document task_struct::futex::state transitions
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Thomas Gleixner <[email protected]>
commit f9ece060cc43eae8a1f148737d193ba0d07b8f88 upstream.
The futex state is used to prevent a waiter from attaching to the lock owner while the owner runs the futex cleanup in exit() or exec().
Only the state transition from FUTEX_STATE_OK to FUTEX_STATE_EXITING must be done with the task's pi_lock held, the transition away from FUTEX_STATE_EXITING has no serialization requirements on the writer side, but it's completely non obvious why. It's magically protected by exit_pi_state(), which operates under tsk::pi_lock, as that's the state which has to be correct when the waiter observes the new state.
OTOH, taking the pi_lock in futex_cleanup_end() is not a performance issue because at that point the lock should be uncontended in the vast majority of cases.
Aside of that the handling of FUTEX_STATE_EXITING in attach_to_pi_owner() and handle_exit_race() is confusing at best.
Protect the store in futex_cleanup_end() with tsk::pi_lock, handle FUTEX_STATE_EXITING in attach_to_pi_owner() explicitly and document how this is supposed to work.
--- kernel/futex/core.c | 8 +-- kernel/futex/pi.c | 105 ++++++++++++++++++++++++++++++++++------------------ 2 files changed, 73 insertions(+), 40 deletions(-)
---
kernel/futex/core.c +3 -5
@@ -1498,11 +1498,9 @@ static void futex_cleanup_begin(struct tstatic void futex_cleanup_end (struct task_struct *tsk,int state) { -/* -* Lockless store. The only side effect is that an observer might -* take another loop until it becomes visible. -*/ - tsk->futex_state = state; +scoped_guard (raw_spinlock_irq, &tsk->pi_lock) + tsk->futex_state = state; +/* * Drop the exit protection. This unblocks waiters which observed * FUTEX_STATE_EXITING to reevaluate the state.
kernel/futex/pi.c +70 -35
143 lines not on this page · raw message
Greg Kroah-Hartman
maintainerPATCH 77/94 futex/pi: Plug private futex exec() race
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Thomas Gleixner <[email protected]>
commit c5f0bc9fd1cec4a00400cc727fcde03e0fde17cc upstream.
The check for private futexes whether the waiter's mm, which is stored in the futex_key and copied into the pi_state, is the same as the owner's mm is not sufficient for exec(). exec() has a gap where the mm check fails to give the correct answer:
exec()
...
exec_release_mm()
futex_exec_release()
tsk::futex::exit_state = EXITING;
cleanup_robust_list();
1) tsk::futex::exit_state = OK;
...
old_mm = tsk::mm;2) tsk::mm = ->mm;
Between #1 and #2 the check for the mm is wrong as that mm is about to be swapped out and eventually freed.
Plug this gap by:
1) Setting tsk::futex::exit_state to FUTEX_STATE_DEAD in futex_exec_release()
2) Setting tsk::futex::exit_state to FUTEX_STATE_OK after the mm has been switched.
Quoted 1 line
Quoted 1 line
From a futex point of view the task is dead after it finished the robust
list cleanup up to the point where it sets the state to OK again.
--- fs/exec.c | 8 +++++-- include/linux/futex.h | 2 + kernel/futex/core.c | 54 ++++++++++++++++++++++++++++++++++---------------- kernel/futex/pi.c | 22 ++++++++++++++------ 4 files changed, 61 insertions(+), 25 deletions(-)
---
fs/exec.c +6 -2
@@ -30,6 +30,7 @@#include <linux/mm.h> #include <linux/stat.h> #include <linux/fcntl.h> +#include <linux/futex.h> #include <linux/swap.h> #include <linux/string.h> #include <linux/init.h>
@@ -851,6 +852,7 @@ static int exec_mmap(struct mm_struct *m/* Notify parent that we're no longer interested in the old VM */ tsk = current; old_mm = current->mm; +/* Clean up futexes and release the mm */ exec_mm_release (tsk, old_mm); ret =down_write_killable (&tsk->signal->exec_update_lock);
@@ -899,9 +901,11 @@ static int exec_mmap(struct mm_struct *msetmax_mm_hiwater_rss (&tsk->signal->maxrss, old_mm);mm_update_next_owner (old_mm);mmput (old_mm); -return 0 ; + }else { +mmdrop_lazy_tlb (active_mm); } -mmdrop_lazy_tlb (active_mm); + +futex_exec_done (tsk);return 0 ; }
include/linux/futex.h +2 -0
@@ -77,6 +77,7 @@ static inline void futex_init_task(strucvoid futex_exit_recursive (struct task_struct *tsk);void futex_exit_release (struct task_struct *tsk);void futex_exec_release (struct task_struct *tsk); +void futex_exec_done (struct task_struct *tsk);long do_futex (u32 __user *uaddr,int op,u32 val,ktime_t *timeout,u32 __user *uaddr2,u32 val2,u32 val3);
@@ -98,6 +99,7 @@ static inline void futex_init_task(strucstatic inline void futex_exit_recursive (struct task_struct *tsk) { }static inline void futex_exit_release (struct task_struct *tsk) { }static inline void futex_exec_release (struct task_struct *tsk) { } +static inline void futex_exec_done (struct task_struct *tsk) { }static inline long do_futex (u32 __user *uaddr,int op,u32 val,ktime_t *timeout,u32 __user *uaddr2,u32 val2,u32 val3)
kernel/futex/core.c +37 -17
76 lines not on this page · raw message
kernel/futex/pi.c +16 -6
@@ -200,15 +200,25 @@ void put_pi_state(struct futex_pi_state* * - FUTEX_STATE_OK when the task is alive and waiters can be attached * -* - FUTEX_STATE_EXITING when the task cleans up the robust list and pi +* - FUTEX_STATE_EXITING when the task cleans up the robust list and PI * state. Concurrent waiters cannot attach anymore and have to wait until the -* cleanup is finished to re-evaluate the potential changes of robust list and -* pi state cleanups. +* cleanup is finished to re-evaluate the potential changes caused by the +* robust list and PI state cleanups. * -* - FUTEX_STATE_DEAD when the task has cleaned up the robust list and -* is about to fully exit. +* - FUTEX_STATE_DEAD when the task has cleaned up the robust list. This state +* is set independent of exit() or exec(). In the exit() case the task is +* gone. In the exec() case this ensures that nothing can attach to the task +* after cleaning up the robust list and PI state before it has switched to +* the new mm. From a futex point of view the task is dead until it sets the +* state to FUTEX_STATE_OK again after switching to the new mm. * -* exec() switches back to FUTEX_STATE_OK after the cleanup. +* The valid state transitions for exit(): +* +* FUTEX_STATE_OK -> FUTEX_STATE_EXITING -> FUTEX_STATE_DEAD +* +* The valid state transitions for exec(): +* +* FUTEX_STATE_OK -> FUTEX_STATE_EXITING -> FUTEX_STATE_DEAD -> FUTEX_STATE_OK * * The state has two related locks: *
Greg Kroah-Hartman
maintainerPATCH 78/94 futex: Fix race on the initial mm->futex.phash.ref allocation
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Hyunwoo Kim <[email protected]>
commit bde0238083647381d4747355c5a19115a3422b96 upstream.
futex_hash_allocate() allocates mm->futex.phash.ref without any locking. Commit d9b05321e21e ("futex: Move futex_hash_free() back to __mmput()") moved the allocation here and assumed that the process has just a single thread at this point.
Commit ee9dce44362b ("futex: Drop CLONE_THREAD requirement for private default hash alloc") widened need_futex_hash_allocate_default() to cover any CLONE_VM clone, but left out vfork because the parent is suspended and cannot race.
That no longer holds once vfork is nested. If a vfork child calls vfork again and is then killed with SIGKILL, the parent is released from its vfork wait and runs concurrently with the grandchild in the same mm. Neither of them went through futex_hash_allocate_default().
When both call prctl(PR_FUTEX_HASH, PR_FUTEX_HASH_SET_SLOTS) at the same time, each one sees mm->futex.phash.ref as NULL and stores its own percpu counter. Only the last store survives. The counter stored first is no longer reachable from the mm, so the references on it are not seen by __futex_ref_atomic_end(). A private hash that still has references is then considered dead and freed, and a task that still holds one of its buckets writes into freed memory in futex_q_lock().
Store the counter once with cmpxchg() and let the loser free_percpu() its own. The initial reference has to be taken before the store, otherwise another task can install a private hash while the counter is still 0.
--- kernel/futex/core.c | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-)
---
kernel/futex/core.c +10 -6
@@ -1839,14 +1839,18 @@ static int futex_hash_allocate(unsigned }if (!mm->futex_ref) { + unsigned int __percpu *ref = alloc_percpu(unsigned int); + +if (!ref) +return -ENOMEM ; +/* -* This will always be allocated by the first thread and -* therefore requires no locking. +* Tasks sharing the mm can run this concurrently, so take the +* initial reference before publishing the counter. */ - mm->futex_ref = alloc_percpu(unsigned int); -if (!mm->futex_ref) -return -ENOMEM ; -this_cpu_inc (*mm->futex_ref);/* 0 -> 1 */ +this_cpu_inc (*ref);/* 0 -> 1 */ +if (cmpxchg (&mm->futex_ref,NULL , ref)) +free_percpu (ref); } fph = kvzalloc(struct_size(fph, queues, hash_slots),
Greg Kroah-Hartman
maintainerPATCH 79/94 futex: Fix might_sleep() warning in futex_pivot_pending()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Peter Zijlstra <[email protected]>
commit d8aa5dd97944a72d4a9e3cc79bb80fcac7d6e829 upstream.
A younger me put a WARN in might_sleep() to warn about nested sleep loops. This younger me also build a wait-loop variant that can deal with it. This wait-loop variant doesn't have all the fancy wrappers, since it isn't used much. It also lacks wait-bit support.
Add the wait-bit support and use it to fix the nested wait issue.
--- include/linux/wait.h | 1 + include/linux/wait_bit.h | 1 + kernel/futex/core.c | 27 ++++++++++++++++++++++++++- kernel/sched/wait.c | 15 +++++++++++++++ kernel/sched/wait_bit.c | 14 +++++++++++--- 5 files changed, 54 insertions(+), 4 deletions(-)
---
include/linux/wait.h +1 -0
@@ -1213,6 +1213,7 @@ long prepare_to_wait_event(struct wait_qvoid finish_wait (struct wait_queue_head *wq_head,struct wait_queue_entry *wq_entry);long wait_woken (struct wait_queue_entry *wq_entry,unsigned mode,long timeout);int woken_wake_function (struct wait_queue_entry *wq_entry,unsigned mode,int sync,void *key); +int woken_wake_bit_function (struct wait_queue_entry *wq_entry,unsigned mode,int sync,void *key);int autoremove_wake_function (struct wait_queue_entry *wq_entry,unsigned mode,int sync,void *key);#define DEFINE_WAIT_FUNC (name, function) \
include/linux/wait_bit.h +1 -0
@@ -32,6 +32,7 @@ int out_of_line_wait_on_bit_timeout(unsiint out_of_line_wait_on_bit_lock (unsigned long *word,int ,wait_bit_action_f *action,unsigned int mode);struct wait_queue_head *bit_waitqueue (unsigned long *word,int bit);extern void __init wait_bit_init (void ); +extern struct wait_bit_key *__var_wake_key (struct wait_queue_entry *wq_entry,void *arg);int wake_bit_function (struct wait_queue_entry *wq_entry,unsigned mode,int sync,void *key);
kernel/futex/core.c +26 -1
@@ -44,6 +44,7 @@#include <linux/prctl.h> #include <linux/mempolicy.h> #include <linux/mmap_lock.h> +#include <linux/wait_bit.h> #include "futex.h" #include "../locking/rtmutex_common.h"
@@ -1866,11 +1867,35 @@ static int futex_hash_allocate(unsignedfutex_hash_bucket_init (&fph->queues[i], fph);if (custom) { +struct wait_bit_queue_entry __wbq_entry; +struct wait_queue_head *__wq_head; +/* * Only let prctl() wait / retry; don't unduly delay clone(). */ again: -wait_var_event (mm,futex_pivot_pending (mm)); + __wq_head =__var_waitqueue (mm); +init_wait_var_entry (&__wbq_entry, mm,0 ); + __wbq_entry.wq_entry.func = woken_wake_bit_function; +add_wait_queue (__wq_head, &__wbq_entry.wq_entry); + +/* +* add_wait_queue() futex_ref_put() +* MB (this) MB (implied) +* futex_pivot_pending() wake_up_var() +* waitqueue_active() +* +* Notably, it must not be possible to see +* !futex_pivot_pending() && !waitqueue_active(). +*/ +smp_mb (); + +while (!futex_pivot_pending (mm) && +wait_woken (&__wbq_entry.wq_entry,TASK_UNINTERRUPTIBLE , +MAX_SCHEDULE_TIMEOUT )) +/* empty */ ; + +remove_wait_queue (__wq_head, &__wbq_entry.wq_entry); } scoped_guard(mutex, &mm->futex_hash_lock) {
kernel/sched/wait.c +15 -0
@@ -5,6 +5,7 @@* (C) 2004 Nadia Yvette Chambers, Oracle */ #include "sched.h" +#include <linux/wait_bit.h> void __init_waitqueue_head (struct wait_queue_head *wq_head,const char *name,struct lock_class_key *key) {
@@ -463,3 +464,17 @@ int woken_wake_function(struct wait_queureturn default_wake_function (wq_entry, mode, sync, key); }EXPORT_SYMBOL (woken_wake_function); + +int woken_wake_bit_function (struct wait_queue_entry *wq_entry,unsigned mode,int sync,void *arg) +{ +struct wait_bit_key *key =__var_wake_key (wq_entry, arg); +if (!key) +return 0 ; + +/* Pairs with the smp_store_mb() in wait_woken(). */ +smp_mb ();/* C */ + wq_entry->flags |=WQ_FLAG_WOKEN ; + +return default_wake_function (wq_entry, mode, sync, key); +} +EXPORT_SYMBOL (woken_wake_bit_function);
kernel/sched/wait_bit.c +11 -3
@@ -167,9 +167,7 @@ wait_queue_head_t *__var_waitqueue(void }EXPORT_SYMBOL (__var_waitqueue); -static int -var_wake_function (struct wait_queue_entry *wq_entry,unsigned int mode, -int sync,void *arg) +struct wait_bit_key *__var_wake_key (struct wait_queue_entry *wq_entry,void *arg) {struct wait_bit_key *key = arg; struct wait_bit_queue_entry *wbq_entry =
@@ -177,6 +175,16 @@ var_wake_function(struct wait_queue_entrif (wbq_entry->key.flags != key->flags || wbq_entry->key.bit_nr != key->bit_nr) +return NULL ; + +return key; +} + +static int var_wake_function (struct wait_queue_entry *wq_entry,unsigned int mode, +int sync,void *arg) +{ +struct wait_bit_key *key =__var_wake_key (wq_entry, arg); +if (!key)return 0 ;return autoremove_wake_function (wq_entry, mode, sync, key);
Greg Kroah-Hartman
maintainerPATCH 80/94 HID: nintendo: fix out-of-bounds read in joycon_ctlr_read_handler()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Ibrahim Hashimov <[email protected]>
commit 27b376b945c0aac46fcdfcc950b14a85b874b557 upstream.
joycon_ctlr_read_handler() casts an incoming HID input report to struct joycon_input_report and parses it, guarding the cast only with a 12-byte length check:
if (size >= 12) /* make sure it contains the input report */ joycon_parse_report(ctlr, (struct joycon_input_report *)data);
struct joycon_input_report is 49 bytes: a 13-byte header followed by a union whose IMU arm is 36 bytes. For an IMU report joycon_parse_report() -> joycon_parse_imu_report() walks that union (struct offsets 13..48), so a report of exactly 12 bytes with data[0] == JC_INPUT_IMU_DATA passes the guard yet is read up to 37 bytes past its declared length. The over-read bytes are decoded into accelerometer/gyroscope values and forwarded to userspace through the "(IMU)" input device, leaking driver-internal memory. data[0] and size are fully controlled by a malicious or spoofed Joy-Con/Pro Controller.
Receive buffers are sized to the maximum report length, so this is an over-read within the allocation rather than a slab OOB, but the decoded bytes still reach userspace.
The sibling subcmd path in joycon_ctlr_handle_event() already bounds the same cast correctly:
if (size < sizeof(struct joycon_input_report) || data[0] != JC_INPUT_SUBCMD_REPLY) break;
Use the same sizeof(struct joycon_input_report) bound here.
--- drivers/hid/hid-nintendo.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
drivers/hid/hid-nintendo.c +6 -1
@@ -2559,7 +2559,12 @@ static int joycon_ctlr_read_handler(stru {if (data[0 ] ==JC_INPUT_SUBCMD_REPLY || data[0 ] ==JC_INPUT_IMU_DATA || data[0 ] ==JC_INPUT_MCU_DATA ) { -if (size >=12 )/* make sure it contains the input report */ +/* +* The whole struct is cast and parsed below, including the +* IMU/subcmd union, not just the 12-byte partial header this +* used to check for. +*/ +if (size >=sizeof (struct joycon_input_report ))joycon_parse_report (ctlr, (struct joycon_input_report *)data); }
Greg Kroah-Hartman
maintainerPATCH 81/94 HID: nintendo: register input device after capabilities are set
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Jiangshan Yi <[email protected]>
commit d723bc1fe2e72b9252234e94c11af644ec477bf7 upstream.
input_register_device() exposes the device to userspace immediately. In joycon_input_create() it was called before joycon_config_rumble() configures the FF_RUMBLE capability and the memless force-feedback device, so a concurrent EVIOCSFF could dereference a NULL dev->ff.
Registering early also means the initial udev event lacks button and axis information, which can make input managers ignore the device.
Move input_register_device() to the end of joycon_input_create(), after all capabilities, the IMU input device and the force-feedback callbacks have been configured.
--- drivers/hid/hid-nintendo.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
drivers/hid/hid-nintendo.c +4 -4
@@ -2138,10 +2138,6 @@ static int joycon_input_create(struct jo ctlr->input->phys = hdev->phys;input_set_drvdata (ctlr->input, ctlr); - ret =input_register_device (ctlr->input); -if (ret) -return ret; -if (joycon_type_is_right_joycon (ctlr)) {joycon_config_right_stick (ctlr->input);joycon_config_buttons (ctlr->input, right_joycon_button_mappings);
@@ -2181,6 +2177,10 @@ static int joycon_input_create(struct joif (joycon_has_rumble (ctlr))joycon_config_rumble (ctlr); + ret =input_register_device (ctlr->input); +if (ret) +return ret; +return 0 ; }
Greg Kroah-Hartman
maintainerPATCH 82/94 HID: nintendo: stop device IO before hid_hw_stop on probe failure
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Jiangshan Yi <[email protected]>
commit 1f74d3bff6fe04a64e02ab3661d2e0d554565aa6 upstream.
nintendo_hid_probe() calls hid_device_io_start() before joycon_init() and joycon_leds_create(). If either fails, the error path jumps to err_close which calls hid_hw_close()/hid_hw_stop() without first calling hid_device_io_stop().
hid_hw_stop() does not stop device IO, so hid_input_report() may still run and access driver data that is being torn down, resulting in a use-after-free.
Add an err_io_stop label that calls hid_device_io_stop() before hid_hw_close(), and point the two post-io_start error paths at it.
--- drivers/hid/hid-nintendo.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-)
drivers/hid/hid-nintendo.c +4 -3
@@ -2692,14 +2692,14 @@ static int nintendo_hid_probe(struct hid ret =joycon_init (hdev);if (ret) {hid_err (hdev,"Failed to initialize controller; ret=%d\n" , ret); - goto err_close; + goto err_io_stop; }/* Initialize the leds */ ret =joycon_leds_create (ctlr);if (ret) {hid_err (hdev,"Failed to create leds; ret=%d\n" , ret); - goto err_close; + goto err_io_stop; }/* Initialize the battery power supply */
@@ -2722,7 +2722,8 @@ static int nintendo_hid_probe(struct hid err_ida:ida_free (&nintendo_player_id_allocator, ctlr->player_id); -err_close: +err_io_stop: +hid_device_io_stop (hdev);hid_hw_close (hdev); err_stop:hid_hw_stop (hdev);
Greg Kroah-Hartman
maintainerPATCH 83/94 HID: core: fix number/pointer type confusion on long items
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Jann Horn <[email protected]>
commit 28abce951343fcec26e397610868efa4e1395c3f upstream.
When fetch_item() is called by hid_scan_report() on an item with HID_ITEM_TAG_LONG, it stores a pointer to the item data in item->data.longdata instead of storing a value directly in item->data.{u8/u16/u32}.
When item_udata() or item_sdata() encounters such an item, it incorrectly assumes that the item is in short format, and therefore returns the lower part of a kernel pointer reinterpreted as a number.
When a HID device is connected whose descriptor contains a HID_GLOBAL_ITEM_TAG_REPORT_SIZE encoded in long format with size=4, this causes the lower half of a kernel pointer to be printed into dmesg as a number, like this:
hid (null): invalid report_size 107953555
To fix it, let item_udata() and item_sdata() verify that the item is in short format.
Note that this bug only affects hid_scan_report(), while the main parsing pass hid_parse_collections() will always bail out when encountering a long item.
Sidenote: There are currently no users of data.longdata; maybe we should just remove any parsing of long-format descriptors as a follow-up.
--- drivers/hid/hid-core.c | 6 ++++++ 1 file changed, 6 insertions(+)
drivers/hid/hid-core.c +6 -0
@@ -379,6 +379,9 @@ static int hid_add_field(struct hid_parsstatic u32 item_udata (struct hid_item *item) { +if (item->format !=HID_ITEM_FORMAT_SHORT ) +return 0 ; +switch (item->size) {case 1 :return item->data.u8;case 2 :return item->data.u16;
@@ -389,6 +392,9 @@ static u32 item_udata(struct hid_item *istatic s32 item_sdata (struct hid_item *item) { +if (item->format !=HID_ITEM_FORMAT_SHORT ) +return 0 ; +switch (item->size) {case 1 :return item->data.s8;case 2 :return item->data.s16;
Greg Kroah-Hartman
maintainerPATCH 84/94 HID: sensor: custom: Fix use-after-free in enable_sensor
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Haoxiang Li <[email protected]>
commit ad8fb82b04422f49530d2aa2753cc81d1c60102c upstream.
enable_sensor_store() can call set_power_report_state(), which dereferences sensor_inst->power_state and sensor_inst->report_state. These pointers refer to entries in sensor_inst->fields.
Create the field attributes before exposing the enable_sensor sysfs attribute, so enable_sensor cannot be accessed before the state it depends on has been initialized.
On remove, delete enable_sensor before freeing the field attributes, so a concurrent sysfs write cannot dereference freed memory through power_state or report_state.
--- drivers/hid/hid-sensor-custom.c | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-)
drivers/hid/hid-sensor-custom.c +9 -8
@@ -1005,26 +1005,26 @@ static int hid_sensor_custom_probe(strucreturn ret; } - ret =sysfs_create_group (&sensor_inst->pdev->dev.kobj, - &enable_sensor_attr_group); + ret =hid_sensor_custom_add_attributes (sensor_inst);if (ret) goto err_remove_callback; - ret =hid_sensor_custom_add_attributes (sensor_inst); + ret =sysfs_create_group (&sensor_inst->pdev->dev.kobj, + &enable_sensor_attr_group);if (ret) - goto err_remove_group; + goto err_remove_attributes; ret =hid_sensor_custom_dev_if_add (sensor_inst);if (ret) - goto err_remove_attributes; + goto err_remove_group;return 0 ; -err_remove_attributes: -hid_sensor_custom_remove_attributes (sensor_inst); err_remove_group:sysfs_remove_group (&sensor_inst->pdev->dev.kobj, &enable_sensor_attr_group); +err_remove_attributes: +hid_sensor_custom_remove_attributes (sensor_inst); err_remove_callback:sensor_hub_remove_callback (hsdev, hsdev->usage);
@@ -1042,9 +1042,10 @@ static void hid_sensor_custom_remove(str }hid_sensor_custom_dev_if_remove (sensor_inst); -hid_sensor_custom_remove_attributes (sensor_inst); +/* Remove enable_sensor first as it uses fields via power_state/report_state. */ sysfs_remove_group (&sensor_inst->pdev->dev.kobj, &enable_sensor_attr_group); +hid_sensor_custom_remove_attributes (sensor_inst);sensor_hub_remove_callback (hsdev, hsdev->usage); }
Greg Kroah-Hartman
maintainerPATCH 85/94 HID: uclogic: fix use-after-free of inrange_timer on remove
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Ibrahim Hashimov <[email protected]>
commit 506fd50a9027340f0e9dcc587d10ccb03312dba6 upstream.
uclogic_remove() cancels the pen in-range timer and then stops the device:
timer_delete_sync(&drvdata->inrange_timer); hid_hw_stop(hdev);
timer_delete_sync() only guarantees the timer is idle at that instant. uclogic_raw_event_pen() keeps delivering pen reports until hid_hw_stop() stops the transport several lines later, and every report with pen->inrange == UCLOGIC_PARAMS_PEN_INRANGE_NONE re-arms the timer:
mod_timer(&drvdata->inrange_timer, jiffies + msecs_to_jiffies(100));
A report landing between the timer_delete_sync() call and the transport teardown in hid_hw_stop() re-arms inrange_timer after it was cancelled. uclogic_remove() then returns and the devm drvdata is freed, while hid_hw_stop() has already freed the input device drvdata->pen_input points at, so when the timer fires ~100 ms later uclogic_inrange_timeout() dereferences freed memory -- a use-after-free in timer-softirq context.
Swapping the two calls is not a fix: stopping the device first frees drvdata->pen_input via hidinput_disconnect() while the timer may still be pending, so a timer already armed before removal fires on the freed input device in the window before timer_delete_sync() runs.
Use timer_shutdown_sync() before hid_hw_stop() instead. It cancels the timer, waits for a running callback while pen_input is still valid, and prevents any further re-arming -- a later mod_timer() from an in-flight report is silently ignored -- so the timer is provably dead before hid_hw_stop() frees the inputs. This is the ordering the timer core documents for this "timer re-armed from another path" teardown case.
--- drivers/hid/hid-uclogic-core.c | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-)
drivers/hid/hid-uclogic-core.c +11 -1
@@ -533,7 +533,17 @@ static void uclogic_remove(struct hid_de {struct uclogic_drvdata *drvdata =hid_get_drvdata (hdev); -timer_delete_sync (&drvdata->inrange_timer); +/* +* Shut the in-range timer down before stopping the device. +* uclogic_raw_event_pen() re-arms inrange_timer on every pen report +* and keeps running until hid_hw_stop() stops the transport, so a +* plain timer_delete_sync() here can be undone by a report landing in +* the window before hid_hw_stop(). timer_shutdown_sync() cancels the +* timer and makes any later re-arm a no-op, so it is provably dead +* before hid_hw_stop() frees the input device drvdata->pen_input +* points at. +*/ +timer_shutdown_sync (&drvdata->inrange_timer);hid_hw_stop (hdev);kfree (drvdata->desc_ptr);uclogic_params_cleanup (&drvdata->params);
Greg Kroah-Hartman
maintainerPATCH 86/94 HID: hyperv: validate initial device info bounds
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Michael Bommarito <[email protected]>
commit 934b7778aa7b7c8f6bb073d2a73ba3674885bae0 upstream.
The Hyper-V synthetic HID host supplies SYNTH_HID_INITIAL_DEVICE_INFO messages that contain a HID descriptor followed by the report descriptor bytes. mousevsc_on_receive_device_info() trusts bLength and wDescriptorLength without checking that the received packet contains both byte ranges.
A malformed host or backend message can therefore make the guest read past the received VMBus packet while copying the report descriptor. Pass the received initial-device-info size into the parser and reject descriptor lengths that exceed the packet.
Impact: A malicious Hyper-V host or backend can crash a guest by sending a short initial device-info message with an oversized HID report descriptor length.
--- drivers/hid/hid-hyperv.c | 27 ++++++++++++++++++++++++--- 1 file changed, 24 insertions(+), 3 deletions(-)
drivers/hid/hid-hyperv.c +24 -3
@@ -171,18 +171,32 @@ static void mousevsc_free_device(struct }static void mousevsc_on_receive_device_info (struct mousevsc_dev *input_device, -struct synthhid_device_info *device_info) +struct synthhid_device_info *device_info, +u32 device_info_size) {int ret =0 ;struct hid_descriptor *desc;struct mousevsc_prt_msg ack; +size_t desc_offset; +size_t desc_size; input_device->dev_info_status = -ENOMEM ; +if (device_info_size <sizeof (*device_info)) { + input_device->dev_info_status = -EINVAL ; + goto cleanup; + } + input_device->hid_dev_info = device_info->hid_dev_info; desc = &device_info->hid_descriptor; + desc_offset = offsetof(struct synthhid_device_info , hid_descriptor); + desc_size = device_info_size - desc_offset;if (desc->bLength ==0 ) goto cleanup; +if (desc->bLength <sizeof (*desc) || desc->bLength > desc_size) { + input_device->dev_info_status = -EINVAL ; + goto cleanup; + }/* The pointer is not NULL when we resume from hibernation */ kfree (input_device->hid_desc);
@@ -197,6 +211,10 @@ static void mousevsc_on_receive_device_i input_device->dev_info_status = -EINVAL ; goto cleanup; } +if (input_device->report_desc_size > desc_size - desc->bLength) { + input_device->dev_info_status = -EINVAL ; + goto cleanup; + }/* The pointer is not NULL when we resume from hibernation */ kfree (input_device->report_desc);
@@ -273,14 +291,17 @@ static void mousevsc_on_receive(struct hbreak ;case SYNTH_HID_INITIAL_DEVICE_INFO : -WARN_ON (pipe_msg->size <sizeof (struct hv_input_dev_info )); +if (WARN_ON_ONCE (pipe_msg->size < +sizeof (struct synthhid_device_info ))) +break ;/* * Parse out the device info into device attr, * hid desc and report desc */ mousevsc_on_receive_device_info (input_dev, - (struct synthhid_device_info *)pipe_msg->data); + (struct synthhid_device_info *)pipe_msg->data, + pipe_msg->size);break ;case SYNTH_HID_INPUT_REPORT : input_report =
Greg Kroah-Hartman
maintainerPATCH 87/94 drm/xe: Dont hand out the flat CCS storage as usable VRAM
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Linus Torvalds <[email protected]>
commit 818bebeb63dd6bf5f4e07e145f6cdbace520a34c upstream.
get_flat_ccs_offset() reads the base of the flat CCS storage from the hardware, scales it by the number of enabled L3 nodes, and rounds the result up to 128K. Everything below that offset is then handed to the VRAM allocator as usable memory.
Rounding a limit that means "usable memory ends here" upwards publishes whatever lies between the real base and the rounded one as free memory, and that memory belongs to the compression hardware. The scaled value has no reason to be 128K aligned, and on a Battlemage G21 with 16 GiB it is not:
flat CCS base: raw 0x3fafff800, rounded 0x3fb000000
so the last 2 KiB of page 0x3fafff000 is CCS storage, in the allocator's pool. Whatever is allocated there gets that tail overwritten by the compression hardware, which needs no page-table entry, no buffer object and no GPU submission to do it, and does it before userspace exists.
On this machine a Mesa VM's level-3 page table landed on that page on every cold boot. It lost the entry covering the compositor's batch-buffer heap, so the compositor's first submission faulted fetching its batch and gdm restarted it forever: a black screen on an otherwise working machine. Restarting gdm cleared it because the next VM's page tables were allocated somewhere else.
Round down instead, to the page size the allocator works in. On this machine that excludes exactly one page.
Reading the reserved page afterwards shows what had been writing it:
[369] 0xcccc000000000000 [371] 0xcc77000000000000 [373] 0xcccc000000000000 [375] 0xcc77000000000000
compression metadata, two bytes per sixteen, sitting where the driver used to hand out memory.
The assertion that should have caught this compares the offset against GSMBASE - ccs_size for equality. That value is 128K aligned, so it agrees with the rounded-up offset precisely when the base is not aligned - the check cannot fail in the case it exists to catch, and is compiled out unless CONFIG_DRM_XE_DEBUG is set. Replace it with one that can fail: CCS storage must not run into GSM.
[ And this was a debug session from hell, enormously helped by an AI
doing much of the grunt-work.
I'd like to call it my tireless helper, but the AI several times stated flat out that this was impossible and unsolvable and that we should just write a report about it.
I suspect those things have been trained by people who may not be quite as stubborn as I am.
But while the AI was ready to give up several times, it did keep adding debug code and analyzing it faithfully when I pushed. So credit where credit is due and I let the AI write the commit message above.
This is basically a one-liner fixing a bogus "round_up()" to a "round_down()", but there were 24 patches adding more and more debug information to this, and 18 kernel boot to finally narrow it down to
this. - Linus ]
--- drivers/gpu/drm/xe/xe_vram.c | 23 ++++++++++++++++++----- 1 file changed, 18 insertions(+), 5 deletions(-)
drivers/gpu/drm/xe/xe_vram.c +18 -5
@@ -206,12 +206,25 @@ static inline u64 get_flat_ccs_offset(st offset = offset_hi <<32 ;/* HW view bits 39:32 */ offset |= offset_lo <<6 ;/* HW view bits 31:6 */ offset *= num_enabled;/* convert to SW view */ - offset =round_up (offset,SZ_128K );/* SW must round up to nearest 128K */ -/* We don't expect any holes */ -xe_assert_msg (xe, offset == (xe_mmio_read64_2x32 (>_to_tile (gt)->mmio,GSMBASE ) - - ccs_size), -"Hole between CCS and GSM.\n" ); +/* +* Everything below this offset is handed to the VRAM +* allocator, so it has to be the *first* address the +* compression hardware owns, rounded down. Rounding it up +* publishes CCS storage as free memory. +*/ + offset =round_down (offset,SZ_4K ); + +/* +* CCS storage must not run into GSM. The old check compared +* the offset against GSMBASE - ccs_size for equality, which +* could not fail: that value is 128K aligned, so it agreed +* with the rounded-up offset even when the base was not 128K +* aligned - exactly the case this fixes. +*/ +xe_assert_msg (xe, offset + ccs_size <= +xe_mmio_read64_2x32 (>_to_tile (gt)->mmio,GSMBASE ), +"CCS overlaps GSM.\n" ); }else { reg =xe_gt_mcr_unicast_read_any (gt,XEHP_FLAT_CCS_BASE_ADDR ); offset = (u64 )REG_FIELD_GET (XEHP_FLAT_CCS_PTR , reg) *SZ_64K ;
Greg Kroah-Hartman
maintainerPATCH 88/94 Bluetooth: hci_event: fix LE list UAF on reset
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Chengfeng Ye <[email protected]>
commit 33af47e847fe4a28b109673affb5874015d54f5a upstream.
hci_cc_reset() clears the LE accept and resolving lists without taking hdev->lock. Other command-complete handlers serialize updates to these lists with that lock, and the debugfs readers hold it while walking them.
This permits the reset completion and a debugfs read to interleave as follows:
hci_rx_work debugfs reader
----------- --------------
lock hdev->lock
fetch current entry
list_del(entry)
kfree(entry)
read entry fields
The reader then dereferences a freed list entry and may follow its stale next pointer.
KASAN reported:
BUG: KASAN: slab-use-after-free in white_list_show+0x15f/0x180 Read of size 1 at addr ffff8881015dab16 by task poc/95 Call Trace: white_list_show+0x15f/0x180 seq_read_iter+0x3ff/0x1190 seq_read+0x267/0x3d0 vfs_read+0x177/0xa20 ksys_read+0xf7/0x1c0 Allocated by task 91: hci_bdaddr_list_add+0x1a6/0x3a0 hci_cc_le_add_to_accept_list+0xab/0x140 hci_cmd_complete_evt+0x26c/0x9a0 hci_event_packet+0x454/0xb20 hci_rx_work+0x293/0x730 Freed by task 90: kfree+0x131/0x3c0 hci_bdaddr_list_clear+0xd8/0x160 hci_cc_reset+0x28a/0x370 hci_cmd_complete_evt+0x26c/0x9a0 hci_event_packet+0x454/0xb20 hci_rx_work+0x293/0x730
Take hdev->lock around both list clears. This matches the existing mutation and traversal locking convention.
--- net/bluetooth/hci_event.c | 2 ++ 1 file changed, 2 insertions(+)
net/bluetooth/hci_event.c +2 -0
@@ -293,8 +293,10 @@ static u8 hci_cc_reset(struct hci_dev *h hdev->ssp_debug_mode =0 ; +hci_dev_lock (hdev);hci_bdaddr_list_clear (&hdev->le_accept_list);hci_bdaddr_list_clear (&hdev->le_resolv_list); +hci_dev_unlock (hdev);return rp->status; }
Greg Kroah-Hartman
maintainerPATCH 89/94 Bluetooth: hci_event: validate LE Set CIG Parameters response
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Laxman Acharya Padhya <[email protected]>
commit 0acd4eeb4b225b9bebbf9ef96cc10cdd79b94899 upstream.
The Command Complete dispatch validates only the fixed part of the LE Set CIG Parameters response. After that part is pulled from the skb, hci_cc_le_set_cig_params() trusts num_handles and reads each entry in the trailing handle array.
Matching num_handles against the command's num_cis does not guarantee that the response contains the advertised handles. A truncated response from a malfunctioning controller can therefore make the handler read beyond the skb data.
Validate that the remaining skb data contains all advertised handles. Include this in the existing response validation so malformed responses also follow the established CIG failure handling.
--- net/bluetooth/hci_event.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
net/bluetooth/hci_event.c +4 -2
@@ -3817,8 +3817,10 @@ static u8 hci_cc_le_set_cig_params(strucbt_dev_dbg (hdev,"status 0x%2.2x" , rp->status); cp =hci_sent_cmd_data (hdev,HCI_OP_LE_SET_CIG_PARAMS ); -if (!rp->status && (!cp || rp->num_handles != cp->num_cis || - rp->cig_id != cp->cig_id)) { +if (!rp->status && + (!cp || rp->num_handles != cp->num_cis || + rp->cig_id != cp->cig_id || + skb->len <array_size (rp->num_handles,sizeof (*rp->handle)))) {bt_dev_err (hdev,"unexpected Set CIG Parameters response data" ); status =HCI_ERROR_UNSPECIFIED ; }
Greg Kroah-Hartman
maintainerPATCH 90/94 Bluetooth: hci_sync: Fix accept list UAF during suspend
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Chengfeng Ye <[email protected]>
commit f57b399c4fa1501b2d5451f52d861ece86bcf3db upstream.
hci_update_event_filter_sync() walks hdev->accept_list while sending a synchronous HCI command for each remote-wakeup device. The suspend path holds hdev->req_lock, but accept-list updates are serialized by hdev->lock. Consequently, remove_device() can free the current list entry during the controller wait.
The following interleaving causes the use-after-free:
hci_update_event_filter_sync() remove_device()
fetch accept-list entry
hci_set_event_filter_sync()
wait for controller response hci_dev_lock()
list_del()
kfree()
hci_dev_unlock()read the freed list.next
KASAN reported:
BUG: KASAN: slab-use-after-free in hci_suspend_sync+0x835/0x910 Read of size 8 at addr ffff88810bec8440 by task kworker/0:1/10 Workqueue: events vhci_suspend_work Call Trace: hci_suspend_sync+0x835/0x910 hci_suspend_dev+0x182/0x450 process_one_work+0x661/0x1090 worker_thread+0x45b/0xd10 Allocated by task 86: hci_bdaddr_list_add_with_flags+0x1a8/0x400 add_device+0x381/0x820 hci_sock_sendmsg+0x1033/0x1ea0 Freed by task 91: kfree+0x131/0x3c0 remove_device+0x429/0xb70 hci_sock_sendmsg+0x1033/0x1ea0
Snapshot the remote-wakeup addresses under hdev->lock. Release the lock before sending HCI commands. Clear the controller event filter before building the snapshot, and skip allocation and the second list traversal when there are no matching entries. This preserves the original filter and scan-state updates without retaining an accept-list node across a controller wait.
--- net/bluetooth/hci_sync.c | 50 ++++++++++++++++++++++++++++++++++++----------- 1 file changed, 39 insertions(+), 11 deletions(-)
net/bluetooth/hci_sync.c +39 -11
@@ -6239,6 +6239,8 @@ static int hci_pause_discovery_sync(strustatic int hci_update_event_filter_sync (struct hci_dev *hdev) {struct bdaddr_list_with_flags *b; +bdaddr_t *accept_list; +size_t i, num_entries =0 ;u8 scan =SCAN_DISABLED ;bool scanning =test_bit (HCI_PSCAN , &hdev->flags);int err;
@@ -6255,23 +6257,49 @@ static int hci_update_event_filter_sync(/* Always clear event filter when starting */ hci_clear_event_filter_sync (hdev); -list_for_each_entry (b, &hdev->accept_list, list) { -if (!(b->flags &HCI_CONN_FLAG_REMOTE_WAKEUP )) -continue ; - -bt_dev_dbg (hdev,"Adding event filters for %pMR" , &b->bdaddr); - - err =hci_set_event_filter_sync (hdev,HCI_FLT_CONN_SETUP , -HCI_CONN_SETUP_ALLOW_BDADDR , - &b->bdaddr, -HCI_CONN_SETUP_AUTO_ON ); +hci_dev_lock (hdev); + +list_for_each_entry (b, &hdev->accept_list, list) +if (b->flags &HCI_CONN_FLAG_REMOTE_WAKEUP ) + num_entries++; + +if (!num_entries) { +hci_dev_unlock (hdev); + goto update_scan; + } + + accept_list =kmalloc_array (num_entries,sizeof (*accept_list), +GFP_KERNEL ); +if (!accept_list) { +hci_dev_unlock (hdev); +return -ENOMEM ; + } + + i =0 ; +list_for_each_entry (b, &hdev->accept_list, list) +if (b->flags &HCI_CONN_FLAG_REMOTE_WAKEUP ) +bacpy (&accept_list[i++], &b->bdaddr); + +hci_dev_unlock (hdev); + +for (i =0 ; i < num_entries; i++) { +bt_dev_dbg (hdev,"Adding event filters for %pMR" , + &accept_list[i]); + + err =hci_set_event_filter_sync (hdev,HCI_FLT_CONN_SETUP , +HCI_CONN_SETUP_ALLOW_BDADDR , + &accept_list[i], +HCI_CONN_SETUP_AUTO_ON );if (err)bt_dev_err (hdev,"Failed to set event filter for %pMR" , - &b->bdaddr); + &accept_list[i]);else scan =SCAN_PAGE ; } +kfree (accept_list); + +update_scan:if (scan && !scanning)hci_write_scan_enable_sync (hdev, scan);else if (!scan && scanning)
Greg Kroah-Hartman
maintainerPATCH 91/94 Bluetooth: ISO: do not force BT_LISTEN after a failed BIG sync
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Ali Ahmet Memis <[email protected]>
commit 9838a80096ba472d5e03057136a112631aabae6e upstream.
iso_sock_recvmsg() handles the deferred setup of a broadcast sink by dropping the socket lock, calling iso_conn_big_sync() and taking the lock again:
release_sock(sk); iso_conn_big_sync(sk); lock_sock(sk); sk->sk_state = BT_LISTEN;
The state is written unconditionally, but iso_conn_big_sync() returns void and has paths that do nothing at all: hci_get_route() may fail, and after re-acquiring the socket lock the connection may already be gone, in which case it bails out without ever issuing an LE BIG Create Sync.
While the lock is dropped the connection can be torn down, for example when the controller reports HCI_EV_LE_PA_SYNC_LOST:
hci_le_pa_sync_lost_evt() hci_disconn_cfm() -> iso_disconn_cfm() -> iso_conn_del() iso_chan_del() iso_pi(sk)->conn = NULL sk->sk_state = BT_CLOSED sock_set_flag(sk, SOCK_ZAPPED)
iso_conn_big_sync() then finds conn == NULL and returns, but the caller still overwrites the BT_CLOSED that iso_chan_del() has just set. The socket ends up marked BT_LISTEN with no connection, so recvmsg() reports success for a setup that never happened and a later accept() waits for BIS connections that can never arrive instead of failing.
A concurrent shutdown() reaches the same write by another route:__iso_sock_close() takes the BT_CONNECT2 PA sync path to iso_sock_disconn(), which sets BT_DISCONN but leaves conn and conn->hcon in place, so iso_conn_big_sync() succeeds and BT_LISTEN is written over BT_DISCONN. Both the BT_CONNECT2 and the BT_CONNECTED case write the state the same way.
Let iso_conn_big_sync() report whether the BIG sync was started, and only move the socket to BT_LISTEN when it was and when the state has not changed while the lock was dropped, mirroring what the BT_CONNECT case of the same switch already does with iso_connect_cis(). Both conditions are needed, the error alone does not cover the shutdown() race.
This corrupts the socket state machine only, it is not a memory safety issue. KASAN and lockdep stayed quiet in all of the runs below.
Reproduced with an emulated controller over /dev/vhci on a KASAN + PROVE_LOCKING kernel. A PA sync broadcast sink socket is driven to BT_CONNECT2 and recvmsg() on it is raced against teardown, with a debug delay inside the lock-dropped section to widen the window:
- HCI_EV_LE_PA_SYNC_LOST injected: 64 of 64 rounds left the socket in BT_LISTEN with the connection gone, recvmsg() returned 0 and accept() on that fd returned EAGAIN, which iso_sock_accept() can only do while the socket is BT_LISTEN. With this patch, 0 of 64, recvmsg() returns an error and accept() returns EBADFD.
- shutdown() instead of a controller event: 24 of 32 rounds wedged in BT_LISTEN, 0 of 32 with this patch. With only the error check in place and a short window, one round still wedged while recvmsg() returned 0, which is the case the state re-check covers.
An unraced control round behaves the same before and after: recvmsg() returns 0, the socket reaches BT_LISTEN and an LE BIG Create Sync is issued.
--- net/bluetooth/iso.c | 30 ++++++++++++++++++++++-------- 1 file changed, 22 insertions(+), 8 deletions(-)
net/bluetooth/iso.c +22 -8
@@ -1537,9 +1537,9 @@ static void iso_conn_defer_accept(structhci_send_cmd (hdev,HCI_OP_LE_ACCEPT_CIS ,sizeof (cp), &cp); } -static void iso_conn_big_sync (struct sock *sk) +static int iso_conn_big_sync (struct sock *sk) { -int err; +int err =0 ;struct hci_dev *hdev;struct iso_conn *conn;bdaddr_t src, dst;
@@ -1554,7 +1554,7 @@ static void iso_conn_big_sync(struct soc hdev =hci_get_route (&dst, &src, src_type);if (!hdev) -return ; +return -EHOSTUNREACH ;/* hci_le_big_create_sync requires hdev lock to be held, since * it enqueues the HCI LE BIG Create Sync command via
@@ -1570,8 +1570,10 @@ static void iso_conn_big_sync(struct soc* both before dereferencing conn->hcon. */ conn =iso_pi (sk)->conn; -if (!conn || !conn->hcon) +if (!conn || !conn->hcon) { + err = -ENOTCONN ; goto unlock; + }if (!test_and_set_bit (BT_SK_BIG_SYNC , &iso_pi (sk)->flags)) { err = hci_conn_big_create_sync(hdev, conn->hcon,
@@ -1587,6 +1589,8 @@ unlock:release_sock (sk);hci_dev_unlock (hdev);hci_dev_put (hdev); + +return err; } static int iso_sock_recvmsg(struct socket *sock, struct msghdr *msg,
@@ -1611,10 +1615,19 @@ static int iso_sock_recvmsg(struct sockecase BT_CONNECT2 :if (test_bit (BT_SK_PA_SYNC , &pi->flags)) {release_sock (sk); -iso_conn_big_sync (sk); + err =iso_conn_big_sync (sk);lock_sock (sk); - sk->sk_state =BT_LISTEN ; +/* The socket lock was dropped, so the +* connection may have been torn down +* meanwhile and iso_chan_del() may have +* already moved the socket to BT_CLOSED. +* Only move on to BT_LISTEN if the BIG sync +* was actually started and nothing else has +* changed the state. +*/ +if (!err && sk->sk_state ==BT_CONNECT2 ) + sk->sk_state =BT_LISTEN ; }else {iso_conn_defer_accept (pi->conn->hcon); sk->sk_state =BT_CONFIG ;
@@ -1625,10 +1638,11 @@ static int iso_sock_recvmsg(struct sockecase BT_CONNECTED :if (test_bit (BT_SK_PA_SYNC , &iso_pi (sk)->flags)) {release_sock (sk); -iso_conn_big_sync (sk); + err =iso_conn_big_sync (sk);lock_sock (sk); - sk->sk_state =BT_LISTEN ; +if (!err && sk->sk_state ==BT_CONNECTED ) + sk->sk_state =BT_LISTEN ; early_ret = true; }
Greg Kroah-Hartman
maintainerPATCH 92/94 Bluetooth: ISO: zero the sockaddr before returning it in getname
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Ali Ahmet Memis <[email protected]>
commit 884cf2cc957da7ac178a0e6c6c69ddfec0481cc8 upstream.
iso_sock_getname() fills a struct sockaddr_iso in place and returns its size without clearing it first, so bytes it does not write are copied to user space from the kernel stack. The getsockname(2) and getpeername(2) paths both run through do_getsockname(), which hands getname() an uninitialized sockaddr_storage on the stack and copies back up to the number of bytes getname() returns, so the driver has to initialize every byte it accounts for.
Two ranges are left uninitialized:
- struct sockaddr_iso is 10 bytes but only 9 are written (family, iso_bdaddr, iso_bdaddr_type), leaking the trailing pad byte on every call.
- for a broadcast peer (BIS_LINK or PA_LINK) the returned length grows by sizeof(struct sockaddr_iso_bc), but only bc_sid, bc_num_bis and bc_bis are filled; bc_bdaddr and bc_bdaddr_type, the first 7 bytes of that structure, are never written.
An unprivileged process can open a BTPROTO_ISO socket and reach the pad leak with getsockname(); the broadcast leak needs an established BIS/PA connection. l2cap and rfcomm already memset their sockaddr in getname for the same reason; do the same here.
--- net/bluetooth/iso.c | 2 ++ 1 file changed, 2 insertions(+)
net/bluetooth/iso.c +2 -0
@@ -1415,6 +1415,7 @@ static int iso_sock_getname(struct sockelock_sock (sk); +memset (sa,0 ,sizeof (struct sockaddr_iso )); addr->sa_family =AF_BLUETOOTH ;if (peer) {
@@ -1425,6 +1426,7 @@ static int iso_sock_getname(struct socke sa->iso_bdaddr_type =iso_pi (sk)->dst_type;if (hcon && (hcon->type ==BIS_LINK || hcon->type ==PA_LINK )) { +memset (sa->iso_bc,0 ,sizeof (struct sockaddr_iso_bc )); sa->iso_bc->bc_sid =iso_pi (sk)->bc_sid; sa->iso_bc->bc_num_bis =iso_pi (sk)->bc_num_bis; memcpy(sa->iso_bc->bc_bis, iso_pi(sk)->bc_bis,
Greg Kroah-Hartman
maintainerPATCH 93/94 Bluetooth: MGMT: reject HCI_CMD_SYNC params_len above 255
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Ali Ahmet Memis <[email protected]>
commit 5d95286b6d6e8f1d304da7522bfa6860fc017e48 upstream.
mgmt_hci_cmd_sync() checks that the message length agrees with params_len but puts no upper bound on it. params_len is __le16 while the parameter length in the HCI command header is a u8:
struct hci_command_hdr {
__le16 opcode;
__u8 plen;
} __packed;hci_cmd_sync_alloc() assigns one to the other:
hdr->plen = plen; if (plen) skb_put_data(skb, param, plen);
so a params_len of 256 leaves plen at 0 while all 256 bytes are still appended. The frame handed to the driver then declares no parameters and carries 256 of them. On a length framed transport such as H:4 the controller takes the trailing bytes as the start of the next packet.
The mgmt socket MTU is HCI_MAX_FRAME_SIZE, so params_len can reach about 1KB this way. Commit 03f1700b9b4d ("Bluetooth: MGMT: reject malformed HCI_CMD_SYNC commands") only made params_len agree with the message length, a value that fits the message but not the header field is still accepted.
Reject params_len that does not fit the header field.
--- net/bluetooth/mgmt.c | 8 ++++++++ 1 file changed, 8 insertions(+)
net/bluetooth/mgmt.c +8 -0
@@ -2671,6 +2671,14 @@ static int mgmt_hci_cmd_sync(struct sockreturn mgmt_cmd_status (sk, hdev->id,MGMT_OP_HCI_CMD_SYNC ,MGMT_STATUS_INVALID_PARAMS ); +/* The HCI command header carries the parameter length in a u8, a +* larger value would be truncated there while the parameters are +* still appended to the frame in full. +*/ +if (le16_to_cpu (cp->params_len) >U8_MAX ) +return mgmt_cmd_status (sk, hdev->id,MGMT_OP_HCI_CMD_SYNC , +MGMT_STATUS_INVALID_PARAMS ); +hci_dev_lock (hdev); cmd =mgmt_pending_new (sk,MGMT_OP_HCI_CMD_SYNC , hdev, data, len);if (!cmd)
Greg Kroah-Hartman
maintainerPATCH 94/94 Bluetooth: hci_aml: validate firmware segment lengths
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Laxman Acharya Padhya <[email protected]>
commit 2bf6b9baca9372ea51b6d0f2820dc9bf29a83ef4 upstream.
aml_download_firmware() reads two lengths from the firmware header and uses them to build pointers before checking that the header and segment data are present. A truncated or inconsistent firmware image can make the driver read past firmware->data while constructing TCI commands.
Reject images shorter than the header and ensure that the ICCM and DCCM ranges fit within the loaded firmware before downloading either segment.
--- drivers/bluetooth/hci_aml.c | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-)
drivers/bluetooth/hci_aml.c +16 -2
@@ -247,7 +247,7 @@ static int aml_download_firmware(structstruct hci_uart *hu =hci_get_drvdata (hdev);struct aml_serdev *amldev =serdev_device_get_drvdata (hu->serdev);const struct firmware *firmware =NULL ; -struct aml_fw_len *fw_len =NULL ; +const struct aml_fw_len *fw_len =NULL ;u8 *iccm_start =NULL , *dccm_start =NULL ;u32 iccm_len, dccm_len;u32 value =0 ;
@@ -281,7 +281,21 @@ static int aml_download_firmware(struct goto exit; } - fw_len = (struct aml_fw_len *)firmware->data; +if (firmware->size <sizeof (*fw_len)) { +bt_dev_err (hdev,"Firmware is too small for its header" ); + ret = -EINVAL ; + goto exit; + } + + fw_len = (const struct aml_fw_len *)firmware->data; +if (fw_len->iccm_len < amldev->aml_dev_data->iccm_offset || + fw_len->iccm_len > firmware->size -sizeof (*fw_len) || + fw_len->dccm_len > firmware->size -sizeof (*fw_len) - + fw_len->iccm_len) { +bt_dev_err (hdev,"Invalid firmware segment lengths" ); + ret = -EINVAL ; + goto exit; + }/* Download ICCM */ iccm_start = (u8 *)(firmware->data) +sizeof (struct aml_fw_len )
Hi!
Quoted 4 lines
This is the start of the stable review cycle for the 6.18.47 release. There are 94 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.
CIP testing did not find any problems here:
https://gitlab.com/cip-project/cip-testing/linux-stable-rc-ci/-/tree/linux-6.18.y
Best regards,
Pavel
Quoted 9 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 6.18.47 release. There are 94 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 Thu, 27 Aug 2026 13:25:02 +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/v6.x/stable-review/patch-6.18.47-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-6.18.y
and the diffstat can be found below.thanks,
greg k-h
On ARCH_BRCMSTB using 32-bit and 64-bit ARM kernels, build tested on BMIPS_GENERIC:
Signature · 1 line
Florian
Quoted 9 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 6.18.47 release. There are 94 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 Thu, 27 Aug 2026 13:25:02 +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/v6.x/stable-review/patch-6.18.47-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-6.18.y
and the diffstat can be found below.thanks,
greg k-h
Compiled and booted on my test system. No dmesg regressions.
thanks,
-- Shuah
Quoted 9 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 6.18.47 release. There are 94 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 Thu, 27 Aug 2026 13:25:02 +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/v6.x/stable-review/patch-6.18.47-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-6.18.y
and the diffstat can be found below.thanks,
greg k-h
Built and booted successfully on RISC-V RV64 (HiFive Unmatched).
Hi,
Build tested in our x86,arm64,loongarch,riscv config successfully without error.
Best Regards
Wentao Guan
Linux version 6.18.47-rc1-g20dd49b80cb4 (guanwentao@uos-PC) (aarch64-linux-gnu-gcc-12 (Deepin 12.3.0-17deepin8) 12.3.0, GNU ld (GNU Binutils for Deepin) 2.41) # SMP PREEMPT_DYNAMIC Linux version 6.18.47-rc1-g20dd49b80cb4 (guanwentao@uos-PC) (aarch64-linux-gnu-gcc-12 (Deepin 12.3.0-17deepin8) 12.3.0, GNU ld (GNU Binutils for Deepin) 2.41) #2 SMP PREEMPT_DYNAMIC Wed Aug 26 10:57:27 CST 2026 Linux version 6.18.47-rc1-g20dd49b80cb4 (guanwentao@uos-PC) (loongarch64-linux-gnu-gcc-12 (Deepin 12.3.0-17deepin8) 12.3.0, GNU ld (GNU Binutils for Deepin) 2.41) # SMP PREEMPT_DYNAMIC Linux version 6.18.47-rc1-g20dd49b80cb4 (guanwentao@uos-PC) (loongarch64-linux-gnu-gcc-12 (Deepin 12.3.0-17deepin8) 12.3.0, GNU ld (GNU Binutils for Deepin) 2.41) #3 SMP PREEMPT_DYNAMIC Wed Aug 26 11:15:45 CST 2026 Linux version 6.18.47-rc1+ (guanwentao@uos-PC) (riscv64-linux-gnu-gcc-12 (Deepin 12.3.0-17deepin8) 12.3.0, GNU ld (GNU Binutils for Deepin) 2.41) # SMP PREEMPT
Linux version 6.18.47-rc1+ (guanwentao@uos-PC) (riscv64-linux-gnu-gcc-12 (Deepin 12.3.0-17deepin8) 12.3.0, GNU ld (GNU Binutils for Deepin) 2.41) #4 SMP PREEMPT Wed Aug 26 11:32:37 CST 2026 Linux version 6.18.47-rc1-g20dd49b80cb4 (guanwentao@uos-PC) (gcc (Deepin 12.3.0-17deepin15) 12.3.0, GNU ld (GNU Binutils for Deepin) 2.41) # SMP PREEMPT_DYNAMIC
Linux version 6.18.47-rc1-g20dd49b80cb4 (guanwentao@uos-PC) (gcc (Deepin 12.3.0-17deepin15) 12.3.0, GNU ld (GNU Binutils for Deepin) 2.41) #1 SMP PREEMPT_DYNAMIC Wed Aug 26 10:36:48 CST 2026
BRs
Wentao Guan
# Librecast Test Results
020/020 [ OK ] liblcrq
010/010 [ OK ] libmld
120/120 [ OK ] liblibrecast
CPU/kernel: Linux auntie 6.18.47-rc1-g20dd49b80cb4 #1 SMP PREEMPT_DYNAMIC Wed Aug 26 10:10:28 -00 2026 x86_64 AMD Ryzen 9 9950X 16-Core Processor AuthenticAMD GNU/Linux
Quoted 8 lines · On Tue, 25 Aug 2026 15:24:56 +0200 Greg Kroah-Hartman…
This is the start of the stable review cycle for the 6.18.47 release. There are 94 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 Thu, 27 Aug 2026 13:25:02 +0000. Anything received after that time might be too late.
Boot-tested under QEMU for Rust x86_64, arm64 and riscv64; built-tested for loongarch64 and arm32:
Thanks!
Cheers,
Miguel
Am 25.08.2026 um 15:24 schrieb Greg Kroah-Hartman:
Quoted 4 lines
This is the start of the stable review cycle for the 6.18.47 release. There are 94 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.
Builds, boots and works on my 2-socket Ivy Bridge Xeon E5-2697 v2 server. No dmesg oddities or regressions found.
Beste Grüße,
Peter Schneider
Signature · 8 lines
Climb the mountain not to plant your flag, but to embrace the challenge, enjoy the air and behold the view. Climb it so you can see the world, not so the world can see you. -- David McCullough Jr. OpenPGP: 0xA3828BD796CCE11A8CADE8866E3A92C92C3FF244 Download: https://www.peters-netzplatz.de/download/pschneider1968_pub.asc https://keys.mailvelope.com/pks/lookup?op=get&[email protected] https://keys.mailvelope.com/pks/lookup?op=get&[email protected]
Quoted 4 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 6.18.47 release. There are 94 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.