6.18.57-rc1 review
Subsystems (4)
Greg Kroah-Hartman
maintainerPATCH 216/621 greybus: raw: fix use-after-free on cdev close
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Damien Riégel <[email protected]>
[ Upstream commit 983cc2c7efbce04ecbf6328448d895044dd6ab31 ]
This addresses a use-after-free bug when a raw bundle is disconnected but its chardev is still opened by an application. When the application releases the cdev, it causes the following panic when init on free is enabled (CONFIG_INIT_ON_FREE_DEFAULT_ON=y):
refcount_t: underflow; use-after-free.
WARNING: CPU: 0 PID: 139 at lib/refcount.c:28 refcount_warn_saturate+0xd0/0x130
...
Call Trace:
<TASK>
cdev_put+0x18/0x30
__fput+0x255/0x2a0
__x64_sys_close+0x3d/0x80
do_syscall_64+0xa4/0x290
entry_SYSCALL_64_after_hwframe+0x77/0x7fThe cdev is contained in the "gb_raw" structure, which is freed in the disconnect operation. When the cdev is released at a later time, cdev_put gets an address that points to freed memory.
To fix this use-after-free, convert the struct device from a pointer to being embedded, that makes the lifetime of the cdev and of this device the same. Then, use cdev_device_add, which guarantees that the device won't be released until all references to the cdev have been released. Finally, delegate the freeing of the structure to the device release function, instead of freeing immediately in the disconnect callback.
--- drivers/staging/greybus/raw.c | 67 +++++++++++++++++------------------ 1 file changed, 33 insertions(+), 34 deletions(-)
drivers/staging/greybus/raw.c +33 -34
@@ -21,9 +21,8 @@ struct gb_raw {struct list_head list;int list_data;struct mutex list_lock; -dev_t dev;struct cdev cdev; -struct device *device; +struct device dev; };struct raw_data {
@@ -148,6 +147,15 @@ static int gb_raw_send(struct gb_raw *raw, u32 len, const char __user *data)return retval; } +static void raw_dev_release (struct device *dev) +{ + struct gb_raw *raw = container_of(dev, struct gb_raw, dev); + +ida_free (&minors,MINOR (raw->dev.devt)); + +kfree (raw); +} +static int gb_raw_probe (struct gb_bundle *bundle,const struct greybus_bundle_id *id) {
@@ -164,15 +172,30 @@ static int gb_raw_probe(struct gb_bundle *bundle,if (cport_desc->protocol_id !=GREYBUS_PROTOCOL_RAW )return -ENODEV ; + minor =ida_alloc (&minors,GFP_KERNEL ); +if (minor <0 ) +return minor; + raw =kzalloc (sizeof (*raw),GFP_KERNEL ); -if (!raw) +if (!raw) { +ida_free (&minors, minor);return -ENOMEM ; + } + +device_initialize (&raw->dev); + raw->dev.devt =MKDEV (raw_major, minor); + raw->dev.class = &raw_class; + raw->dev.parent = &bundle->dev; + raw->dev.release = raw_dev_release; + retval =dev_set_name (&raw->dev,"gb!raw%d" , minor); +if (retval) + goto error_put_device; connection =gb_connection_create (bundle,le16_to_cpu (cport_desc->id), gb_raw_request_handler);if (IS_ERR (connection)) { retval =PTR_ERR (connection); - goto error_free; + goto error_put_device; }INIT_LIST_HEAD (&raw->list);
@@ -181,46 +204,26 @@ static int gb_raw_probe(struct gb_bundle *bundle, raw->connection = connection;greybus_set_drvdata (bundle, raw); - minor =ida_alloc (&minors,GFP_KERNEL ); -if (minor <0 ) { - retval = minor; - goto error_connection_destroy; - } - - raw->dev =MKDEV (raw_major, minor);cdev_init (&raw->cdev, &raw_fops); retval =gb_connection_enable (connection);if (retval) - goto error_remove_ida; + goto error_connection_destroy; - retval =cdev_add (&raw->cdev, raw->dev,1 ); + retval =cdev_device_add (&raw->cdev, &raw->dev);if (retval) goto error_connection_disable; - raw->device =device_create (&raw_class, &connection->bundle->dev, - raw->dev, raw,"gb!raw%d" , minor); -if (IS_ERR (raw->device)) { - retval =PTR_ERR (raw->device); - goto error_del_cdev; - } -return 0 ; -error_del_cdev: -cdev_del (&raw->cdev); - error_connection_disable:gb_connection_disable (connection); -error_remove_ida: -ida_free (&minors, minor); - error_connection_destroy:gb_connection_destroy (connection); -error_free: -kfree (raw); +error_put_device: +put_device (&raw->dev);return retval; }
@@ -231,11 +234,8 @@ static void gb_raw_disconnect(struct gb_bundle *bundle)struct raw_data *raw_data;struct raw_data *temp; -// FIXME - handle removing a connection when the char device node is open. -device_destroy (&raw_class, raw->dev); -cdev_del (&raw->cdev); +cdev_device_del (&raw->cdev, &raw->dev);gb_connection_disable (connection); -ida_free (&minors,MINOR (raw->dev));gb_connection_destroy (connection);mutex_lock (&raw->list_lock);
@@ -244,8 +244,7 @@ static void gb_raw_disconnect(struct gb_bundle *bundle)kfree (raw_data); }mutex_unlock (&raw->list_lock); - -kfree (raw); +put_device (&raw->dev); }/*
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 217/621 powerpc/64s: Fix unmap race with PMD migration entries
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Ritesh Harjani (IBM) <[email protected]>
[ Upstream commit bbcbf045d6c778e82b47a35fc8728387708e9a3d ]
The following race is possible with migration swap entries or device-private THP entries. e.g. when move_pages is called on a PMD THP page, then there maybe an intermediate state, where PMD entry acts as a migration swap entry (pmd_present() is true). Then if an munmap happens at the same time, then this VM_BUG_ON() can happen in pmdp_huge_get_and_clear_full().
This patch fixes that.
Thread A: move_pages() syscall
add_folio_for_migration()
mmap_read_lock(mm)
folio_isolate_lru(folio)
mmap_read_unlock(mm)
do_move_pages_to_node()
migrate_pages()
try_to_migrate_one()
spin_lock(ptl)
set_pmd_migration_entry()
pmdp_invalidate() # PMD: _PAGE_INVALID | _PAGE_PTE | pfn
set_pmd_at() # PMD: migration swap entry (pmd_present=0)
spin_unlock(ptl)
[page copy phase] # <--- RACE WINDOW -->
Thread B: munmap()
mmap_write_downgrade(mm)
unmap_vmas() -> zap_pmd_range()
zap_huge_pmd()
__pmd_trans_huge_lock()
pmd_is_huge(): # !pmd_present && !pmd_none -> TRUE (swap entry)
pmd_lock() -> # spin_lock(ptl), waits for Thread A to release ptl
pmdp_huge_get_and_clear_full()
VM_BUG_ON(!pmd_present(*pmdp)) # HITS![ 287.738700][ T1867] ------------[ cut here ]------------
[ 287.743843][ T1867] kernel BUG at arch/powerpc/mm/book3s64/pgtable.c:187!
cpu 0x0: Vector: 700 (Program Check) at [c00000044037f4f0]
pc: c000000000094ca4: pmdp_huge_get_and_clear_full+0x6c/0x23c
lr: c000000000645dec: zap_huge_pmd+0xb0/0x868
sp: c00000044037f790
msr: 800000000282b033
current = 0xc0000004032c1a00
paca = 0xc000000004fe0000 irqmask: 0x03 irq_happened: 0x09
pid = 1867, comm = a.outkernel BUG at :187!
Linux version 6.19.0-12136-g14360d4f917c-dirty (powerpc64le-linux-gnu-gcc (Debian 12.2.0-14) 12.2.0, GNU ld (GNU Binutils for Debian) 2.40) #27 SMP PREEMPT Sun Feb 22 10:38:56 IST 2026 enter ? for help
[link register ] c000000000645dec zap_huge_pmd+0xb0/0x868
[c00000044037f790] c00000044037f7d0 (unreliable)
[c00000044037f7d0] c000000000645dcc zap_huge_pmd+0x90/0x868
[c00000044037f840] c0000000005724cc unmap_page_range+0x176c/0x1f40
[c00000044037fa00] c000000000572ea0 unmap_vmas+0xb0/0x1d8
[c00000044037fa90] c0000000005af254 unmap_region+0xb4/0x128
[c00000044037fb50] c0000000005af400 vms_complete_munmap_vmas+0x138/0x310
[c00000044037fbe0] c0000000005b0f1c do_vmi_align_munmap+0x1ec/0x238
[c00000044037fd30] c0000000005b3688 __vm_munmap+0x170/0x1f8
[c00000044037fdf0] c000000000587f74 sys_munmap+0x2c/0x40
[c00000044037fe10] c000000000032668 system_call_exception+0x128/0x350
[c00000044037fe50] c00000000000d05c system_call_vectored_common+0x15c/0x2ec
---- Exception: 3000 (System Call Vectored) at 0000000010064a2c
SP (7fff9b1ee9c0) is in userspace
0:mon> zh
commit a30b48bf1b24 ("mm/migrate_device: implement THP migration of zone device pages"), enabled migration for device-private PMD entries. Hence this is one
other path where this warning could get trigger from.
------------[ cut here ]------------ WARNING: arch/powerpc/mm/book3s64/hash_pgtable.c:199 at hash__pmd_hugepage_update+0x48/0x284, CPU#3: hmm-tests/1905 Modules linked in: test_hmm CPU: 3 UID: 0 PID: 1905 Comm: hmm-tests Tainted: G B W L N 7.0.0-rc1-01438-g7e2f0ee7581c #21 PREEMPT Tainted: [B]=BAD_PAGE, [W]=WARN, [L]=SOFTLOCKUP, [N]=TEST Hardware name: IBM pSeries (emulated by qemu) POWER10 (architected) 0x801200 0xf000006 of:SLOF,git-ee03ae pSeries NIP [c000000000096b70] hash__pmd_hugepage_update+0x48/0x284 LR [c000000000096e7c] hash__pmdp_huge_get_and_clear+0xd0/0xd4 Call Trace: [c000000604707670] [c000000004e102b8] 0xc000000004e102b8 (unreliable) [c000000604707700] [c00000000064ec3c] set_pmd_migration_entry+0x414/0x498 [c000000604707760] [c00000000063e5a4] migrate_vma_collect_pmd+0x12e8/0x16c4 [c000000604707890] [c00000000059282c] walk_pgd_range+0x7fc/0xd2c [c000000604707990] [c000000000592e40] __walk_page_range+0xe4/0x2ac [c000000604707a10] [c000000000593534] walk_page_range_mm_unsafe+0x204/0x2a4 [c000000604707ab0] [c00000000063af10] migrate_vma_setup+0x1dc/0x2e8 [c000000604707b10] [c008000006a21838] dmirror_migrate_to_system.constprop.0+0x210/0x4b0 [test_hmm] [c000000604707c30] [c008000006a245b0] dmirror_fops_unlocked_ioctl+0x454/0xa5c [test_hmm] [c000000604707d20] [c0000000006aab84] sys_ioctl+0x4ec/0x1178 [c000000604707e10] [c0000000000326a8] system_call_exception+0x128/0x350 [c000000604707e50] [c00000000000d05c] system_call_vectored_common+0x15c/0x2ec ---- interrupt: 3000 at 0x7fffbe44f50c
--- arch/powerpc/include/asm/book3s/64/pgtable.h | 15 +++++++++++++++ arch/powerpc/mm/book3s64/pgtable.c | 13 +++++++++---- 2 files changed, 24 insertions(+), 4 deletions(-)
arch/powerpc/include/asm/book3s/64/pgtable.h +15 -0
@@ -1284,6 +1284,21 @@ extern int pudp_test_and_clear_young(struct vm_area_struct *vma,static inline pmd_t pmdp_huge_get_and_clear (struct mm_struct *mm,unsigned long addr,pmd_t *pmdp) { +/* +* Non-present PMDs can be migration entries or device-private THP +* entries. This can happen at 2 places: +* - When the address space is being unmapped zap_huge_pmd(), and we +* encounter non-present pmds. +* - migrate_vma_collect_huge_pmd() could calls this during migration +* of device-private pmd entries. +*/ +if (!pmd_present (*pmdp)) { +pmd_t old_pmd =READ_ONCE (*pmdp); + +pmd_clear (pmdp); +return old_pmd; + } +if (radix_enabled ())return radix__pmdp_huge_get_and_clear (mm, addr, pmdp);return hash__pmdp_huge_get_and_clear (mm, addr, pmdp);
arch/powerpc/mm/book3s64/pgtable.c +9 -4
@@ -202,16 +202,21 @@ pmd_t pmdp_huge_get_and_clear_full(struct vm_area_struct *vma, unsigned long addr, pmd_t *pmdp, int full) { pmd_t pmd; +bool was_present =pmd_present (*pmdp); +VM_BUG_ON (addr & ~HPAGE_PMD_MASK ); -VM_BUG_ON ((pmd_present (*pmdp) && !pmd_trans_huge (*pmdp)) || - !pmd_present (*pmdp)); +VM_BUG_ON (was_present && !pmd_trans_huge (*pmdp)); +/* +* Check pmdp_huge_get_and_clear() for non-present pmd case. +*/ pmd =pmdp_huge_get_and_clear (vma->vm_mm, addr, pmdp);/* * if it not a fullmm flush, then we can possibly end up converting * this PMD pte entry to a regular level 0 PTE by a parallel page fault. -* Make sure we flush the tlb in this case. +* Make sure we flush the tlb in this case. TLB flush not needed for +* non-present case. */ -if (!full) +if (was_present && !full)flush_pmd_tlb_range (vma, addr, addr +HPAGE_PMD_SIZE );return pmd; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 218/621 ublk: reset per-IO canceled flag on each fetch
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Uday Shankar <[email protected]>
[ Upstream commit 0842186d2c4e67d2f8c8c2d1d779e8acffd41b5b ]
If a ublk server starts recovering devices but dies before issuing fetch commands for all IOs, cancellation of the fetch commands that were successfully issued may never complete. This is because the per-IO canceled flag can remain set even after the fetch for that IO has been submitted - the per-IO canceled flags for all IOs in a queue are reset together only once all IOs for that queue have been fetched. So if a nonempty proper subset of the IOs for a queue are fetched when the ublk server dies, the IOs in that subset will never successfully be canceled, as their canceled flags remain set, and this prevents ublk_cancel_cmd from actually calling io_uring_cmd_done on the commands, despite the fact that they are outstanding.
Fix this by resetting the per-IO cancel flags immediately when each IO is fetched instead of waiting for all IOs for the queue (which may never happen).
--- drivers/block/ublk_drv.c | 28 +++++++++++++--------------- 1 file changed, 13 insertions(+), 15 deletions(-)
drivers/block/ublk_drv.c +13 -15
@@ -2141,30 +2141,28 @@ static void ublk_stop_dev(struct ublk_device *ub)/* reset ublk io_uring queue & io flags */ static void ublk_reset_io_flags (struct ublk_device *ub) { -int i, j; - -for (i =0 ; i < ub->dev_info.nr_hw_queues; i++) { -struct ublk_queue *ubq =ublk_get_queue (ub, i); +int i; -/* UBLK_IO_FLAG_CANCELED can be cleared now */ -spin_lock (&ubq->cancel_lock); -for (j =0 ; j < ubq->q_depth; j++) - ubq->ios[j].flags &= ~UBLK_IO_FLAG_CANCELED ; -spin_unlock (&ubq->cancel_lock); - ubq->fail_io = false; - } +for (i =0 ; i < ub->dev_info.nr_hw_queues; i++) +ublk_get_queue (ub, i)->fail_io = false;mutex_lock (&ub->cancel_mutex);ublk_set_canceling (ub, false);mutex_unlock (&ub->cancel_mutex); }/* device can only be started after all IOs are ready */ -static void ublk_mark_io_ready (struct ublk_device *ub) +static void ublk_mark_io_ready (struct ublk_device *ub,struct ublk_queue *ubq, +struct ublk_io *io) __must_hold(&ub->mutex) {if (!ub->unprivileged_daemons && !capable (CAP_SYS_ADMIN )) ub->unprivileged_daemons = true; +/* UBLK_IO_FLAG_CANCELED can be cleared now */ +spin_lock (&ubq->cancel_lock); + io->flags &= ~UBLK_IO_FLAG_CANCELED ; +spin_unlock (&ubq->cancel_lock); + ub->nr_io_ready++;if (ublk_dev_ready (ub)) {/*
@@ -2370,7 +2368,7 @@ static int ublk_check_fetch_buf(const struct ublk_device *ub, __u64 buf_addr) }static int ublk_fetch (struct io_uring_cmd *cmd,struct ublk_device *ub, -struct ublk_io *io,__u64 buf_addr) +struct ublk_queue *ubq,struct ublk_io *io,__u64 buf_addr) {int ret =0 ;
@@ -2400,7 +2398,7 @@ static int ublk_fetch(struct io_uring_cmd *cmd, struct ublk_device *ub, goto out;WRITE_ONCE (io->task,get_task_struct (current)); -ublk_mark_io_ready (ub); +ublk_mark_io_ready (ub, ubq, io); out:mutex_unlock (&ub->mutex);return ret;
@@ -2505,7 +2503,7 @@ static int ublk_ch_uring_cmd_local(struct io_uring_cmd *cmd, ret =ublk_check_fetch_buf (ub, addr);if (ret) goto out; - ret =ublk_fetch (cmd, ub, io, addr); + ret =ublk_fetch (cmd, ub, ubq, io, addr);if (ret) goto out;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 219/621 ptp: ocp: Make ptp_ocp_unregister_ext() NULL-aware
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Andy Shevchenko <[email protected]>
[ Upstream commit 590f5d1fa6ee22b1ec07283d5fa870326f47b2f6 ]
It's a common practice to make resource release functions be NULL-aware. Make ptp_ocp_unregister_ext() NULL-aware.
Stable-dep-of: 627366c51145 ("ptp: ocp: fix resource freeing order")
--- drivers/ptp/ptp_ocp.c | 24 ++++++++++-------------- 1 file changed, 10 insertions(+), 14 deletions(-)
drivers/ptp/ptp_ocp.c +10 -14
@@ -2227,6 +2227,9 @@ ptp_ocp_ts_enable(void *priv, u32 req, bool enable)static void ptp_ocp_unregister_ext (struct ptp_ocp_ext_src *ext) { +if (!ext) +return ; + ext->info->enable (ext, ~0 , false);pci_free_irq (ext->bp->pdev, ext->irq_vec, ext);kfree (ext);
@@ -4558,21 +4561,14 @@ ptp_ocp_detach(struct ptp_ocp *bp)ptp_ocp_detach_sysfs (bp);ptp_ocp_attr_group_del (bp);timer_delete_sync (&bp->watchdog); -if (bp->ts0) -ptp_ocp_unregister_ext (bp->ts0); -if (bp->ts1) -ptp_ocp_unregister_ext (bp->ts1); -if (bp->ts2) -ptp_ocp_unregister_ext (bp->ts2); -if (bp->ts3) -ptp_ocp_unregister_ext (bp->ts3); -if (bp->ts4) -ptp_ocp_unregister_ext (bp->ts4); -if (bp->pps) -ptp_ocp_unregister_ext (bp->pps); +ptp_ocp_unregister_ext (bp->ts0); +ptp_ocp_unregister_ext (bp->ts1); +ptp_ocp_unregister_ext (bp->ts2); +ptp_ocp_unregister_ext (bp->ts3); +ptp_ocp_unregister_ext (bp->ts4); +ptp_ocp_unregister_ext (bp->pps);for (i =0 ; i <4 ; i++) -if (bp->signal_out[i]) -ptp_ocp_unregister_ext (bp->signal_out[i]); +ptp_ocp_unregister_ext (bp->signal_out[i]);for (i =0 ; i < __PORT_COUNT; i++)if (bp->port[i].line !=-1 )serial8250_unregister_port (bp->port[i].line);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 220/621 ptp: ocp: fix resource freeing order
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Vadim Fedorenko <[email protected]>
[ Upstream commit 627366c51145a07f675b1800fb5ea2ec960bd900 ]
Commit a60fc3294a37 ("ptp: rework ptp_clock_unregister() to disable events") added a call to ptp_disable_all_events() which changes the configuration of pins if they support EXTTS events. In ptp_ocp_detach() pins resources are freed before ptp_clock_unregister() and it leads to use-after-free during driver removal. Fix it by changing the order of free/unregister calls. To avoid irq handler running on the other core while ptp device unregistering, call synchronize_irq() after HW is configured to stop producing irqs and no irqs are in-flight.
--- drivers/ptp/ptp_ocp.c | 24 +++++++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-)
drivers/ptp/ptp_ocp.c +21 -3
@@ -2217,8 +2217,13 @@ ptp_ocp_ts_enable(void *priv, u32 req, bool enable)iowrite32 (1 , ®->intr_mask);iowrite32 (1 , ®->intr); }else { +int irq_vec =pci_irq_vector (bp->pdev, ext->irq_vec); +iowrite32 (0 , ®->intr_mask);iowrite32 (0 , ®->enable); +ioread32 (®->intr_mask); +if (irq_vec >0 ) +synchronize_irq (irq_vec); }return 0 ;
@@ -4561,6 +4566,22 @@ ptp_ocp_detach(struct ptp_ocp *bp)ptp_ocp_detach_sysfs (bp);ptp_ocp_attr_group_del (bp);timer_delete_sync (&bp->watchdog); +/* Disable interrupts on all timestampers */ +if (bp->ts0) +ptp_ocp_ts_enable (bp->ts0,0 , false); +if (bp->ts1) +ptp_ocp_ts_enable (bp->ts1,0 , false); +if (bp->ts2) +ptp_ocp_ts_enable (bp->ts2,0 , false); +if (bp->ts3) +ptp_ocp_ts_enable (bp->ts3,0 , false); +if (bp->ts4) +ptp_ocp_ts_enable (bp->ts4,0 , false); +if (bp->pps) +ptp_ocp_ts_enable (bp->pps, ~0 , false); +if (bp->ptp) +ptp_clock_unregister (bp->ptp); +kfree (bp->ptp_info.pin_config);ptp_ocp_unregister_ext (bp->ts0);ptp_ocp_unregister_ext (bp->ts1);ptp_ocp_unregister_ext (bp->ts2);
@@ -4578,9 +4599,6 @@ ptp_ocp_detach(struct ptp_ocp *bp)clk_hw_unregister_fixed_rate (bp->i2c_clk);if (bp->n_irqs)pci_free_irq_vectors (bp->pdev); -if (bp->ptp) -ptp_clock_unregister (bp->ptp); -kfree (bp->ptp_info.pin_config);device_unregister (&bp->dev); }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 221/621 wifi: cfg80211: enforce HE/EHT cap/oper consistency
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Johannes Berg <[email protected]>
[ Upstream commit cb9959ab5f99611d27a06586add84811fe8102dc ]
Xiang Mei reports that mac80211 could crash if eht_cap is set but eht_oper isn't. Rather than fixing that for the individual user(s), enforce that both HE/EHT have consistent elements.
--- net/wireless/nl80211.c | 6 ++++++ 1 file changed, 6 insertions(+)
net/wireless/nl80211.c +6 -0
@@ -6532,6 +6532,12 @@ static int nl80211_calculate_ap_params(struct cfg80211_ap_settings *params)return -EINVAL ; } +if (!!params->he_cap != !!params->he_oper) +return -EINVAL ; + +if (!!params->eht_cap != !!params->eht_oper) +return -EINVAL ; +return 0 ; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 222/621 drm/amd/display: Wrap DCN32 phantom-plane allocation in DC_RUN_WITH_PREEMPTION_ENABLED
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Mikhail Gavrilov <[email protected]>
[ Upstream commit 183182235f6d53bac62c6c39014738a54a68dfa6 ]
[Why]dcn32_validate_bandwidth() wraps dcn32_internal_validate_bw() with DC_FP_START()/DC_FP_END(). In x86 non-RT, DC_FP_START takes fpregs_lock(), which disables local softirqs.
The DML1 path through dcn32_enable_phantom_plane() calls kvzalloc() to allocate ~335 KiB for dc_plane_state. This triggers the vmalloc path, which calls BUG_ON(in_interrupt()) because it's invoked within the FPU-enabled (softirq disabled) region, leading to a kernel crash.
[How]
Wrap the dc_state_create_phantom_plane() call with the DC_RUN_WITH_PREEMPTION_ENABLED() macro to allow preemption during this memory allocation.
--- .../drm/amd/display/dc/resource/dcn32/dcn32_resource.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-)
drivers/gpu/drm/amd/display/dc/resource/dcn32/dcn32_resource.c +7 -1
@@ -91,9 +91,14 @@#include "dml/dcn32/dcn32_fpu.h" #include "dc_state_priv.h" +#include "dc_fpu.h" #include "dml2/dml2_wrapper.h" +#if !defined(DC_RUN_WITH_PREEMPTION_ENABLED ) +#define DC_RUN_WITH_PREEMPTION_ENABLED (code) code +#endif +#define DC_LOGGER_INIT (logger)enum dcn32_clk_src_array_id {
@@ -1650,7 +1655,8 @@ static void dcn32_enable_phantom_plane(struct dc *dc,if (curr_pipe->top_pipe && curr_pipe->top_pipe->plane_state == curr_pipe->plane_state) phantom_plane = prev_phantom_plane;else - phantom_plane =dc_state_create_phantom_plane (dc, context, curr_pipe->plane_state); +DC_RUN_WITH_PREEMPTION_ENABLED (phantom_plane = +dc_state_create_phantom_plane (dc, context, curr_pipe->plane_state));if (!phantom_plane)continue ;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 223/621 net: phonet: do not BUG_ON() in pn_socket_autobind() on failed bind
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Morduan Zang <[email protected]>
[ Upstream commit 5b0c911bcdbd982f7748d11c0b39ec5808eae2de ]
syzbot reported a kernel BUG triggered from pn_socket_sendmsg() via pn_socket_autobind():
kernel BUG at net/phonet/socket.c:213!
RIP: 0010:pn_socket_autobind net/phonet/socket.c:213 [inline] RIP: 0010:pn_socket_sendmsg+0x240/0x250 net/phonet/socket.c:421 Call Trace: sock_sendmsg_nosec+0x112/0x150 net/socket.c:797 __sock_sendmsg net/socket.c:812 [inline] __sys_sendto+0x402/0x590 net/socket.c:2280 ...
pn_socket_autobind() calls pn_socket_bind() with port 0 and, on -EINVAL, assumes the socket was already bound and asserts that the port is non-zero:
err = pn_socket_bind(sock, ..., sizeof(struct sockaddr_pn));
if (err != -EINVAL)
return err;
BUG_ON(!pn_port(pn_sk(sock->sk)->sobject));
return 0; /* socket was already bound */However pn_socket_bind() also returns -EINVAL when sk->sk_state is not TCP_CLOSE, even when the socket has never been bound and pn_port() is still 0. In that case the BUG_ON() fires and panics the kernel from a user-triggerable path.
Treat the "bind returned -EINVAL but pn_port() is still 0" case as a regular error and propagate -EINVAL to the caller instead of crashing. Existing callers already translate a non-zero return from pn_socket_autobind() into -ENOBUFS/-EAGAIN, so returning -EINVAL here only changes behaviour from panic to a normal errno.
--- net/phonet/socket.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)
net/phonet/socket.c +8 -2
@@ -208,9 +208,15 @@ static int pn_socket_autobind(struct socket *sock) sa.spn_family =AF_PHONET ; err =pn_socket_bind (sock, (struct sockaddr *)&sa,sizeof (struct sockaddr_pn )); -if (err != -EINVAL ) +/* +* pn_socket_bind() also returns -EINVAL when sk_state != TCP_CLOSE +* without a prior bind, so -EINVAL alone is not sufficient to infer +* that the socket was already bound. Only treat it as "already +* bound" when the port is non-zero; otherwise propagate the error +* instead of crashing the kernel. +*/ +if (err != -EINVAL ||unlikely (!pn_port (pn_sk (sock->sk)->sobject)))return err; -BUG_ON (!pn_port (pn_sk (sock->sk)->sobject));return 0 ;/* socket was already bound */ }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 224/621 workqueue: devres: Add device-managed allocate workqueue
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Krzysztof Kozlowski <[email protected]>
[ Upstream commit 1dfc9d60a69ec148e1cb709256617d86e5f0e8f8 ]
Add a Resource-managed version of alloc_workqueue() to fix common problem of drivers mixing devm() calls with destroy_workqueue. Such naive and discouraged driver approach leads to difficult to debug bugs when the driver:
1. Allocates workqueue in standard way and destroys it in driver remove() callback,
2. Sets work struct with devm_work_autocancel(),
3. Registers interrupt handler with devm_request_threaded_irq().
Which leads to following unbind/removal path:
1. destroy_workqueue() via driver remove(),
Any interrupt coming now would still execute the interrupt handler, which queues work on destroyed workqueue.
2. devm_irq_release(),
3. devm_work_drop() -> cancel_work_sync() on destroyed workqueue.
devm_alloc_workqueue() has two benefits:
1. Solves above problem of mix-and-match devres and non-devres code in driver,
2. Simplify any sane drivers which were correctly using alloc_workqueue() + devm_add_action_or_reset().
Stable-dep-of: 1e668baadefb ("power: supply: max77705: Free allocated workqueue and fix removal order")
--- .../driver-api/driver-model/devres.rst | 4 +++ include/linux/workqueue.h | 22 +++++++++++++++ kernel/workqueue.c | 28 +++++++++++++++++++ 3 files changed, 54 insertions(+)
Documentation/driver-api/driver-model/devres.rst +4 -0
@@ -466,3 +466,7 @@ SPI WATCHDOG devm_watchdog_register_device() + +WORKQUEUE + devm_alloc_workqueue() + devm_alloc_ordered_workqueue()
include/linux/workqueue.h +22 -0
@@ -512,6 +512,26 @@ __printf(1, 4) struct workqueue_struct * alloc_workqueue_noprof(const char *fmt, unsigned int flags, int max_active, ...);#define alloc_workqueue (...) alloc_hooks(alloc_workqueue_noprof(__VA_ARGS__)) +/** +* devm_alloc_workqueue - Resource-managed allocate a workqueue +* @dev: Device to allocate workqueue for +* @fmt: printf format for the name of the workqueue +* @flags: WQ_* flags +* @max_active: max in-flight work items, 0 for default +* @...: args for @fmt +* +* Resource managed workqueue, see alloc_workqueue() for details. +* +* The workqueue will be automatically destroyed on driver detach. Typically +* this should be used in drivers already relying on devm interafaces. +* +* RETURNS: +* Pointer to the allocated workqueue on success, %NULL on failure. +*/ +__printf(2, 5) struct workqueue_struct * +devm_alloc_workqueue (struct device *dev,const char *fmt,unsigned int flags, +int max_active, ...); +#ifdef CONFIG_LOCKDEP /** * alloc_workqueue_lockdep_map - allocate a workqueue with user-defined lockdep_map
@@ -568,6 +588,8 @@ alloc_workqueue_lockdep_map(const char *fmt, unsigned int flags, int max_active,*/ #define alloc_ordered_workqueue(fmt, flags, args...) \ alloc_workqueue(fmt, WQ_UNBOUND | __WQ_ORDERED | (flags), 1, ##args) +#define devm_alloc_ordered_workqueue(dev, fmt, flags, args...) \ + devm_alloc_workqueue(dev, fmt, WQ_UNBOUND | __WQ_ORDERED | (flags), 1, ##args)#define create_workqueue (name) \ alloc_workqueue("%s", __WQ_LEGACY | WQ_MEM_RECLAIM | WQ_PERCPU, 1, (name))
kernel/workqueue.c +28 -0
@@ -41,6 +41,7 @@#include <linux/mempolicy.h> #include <linux/freezer.h> #include <linux/debug_locks.h> +#include <linux/device/devres.h> #include <linux/lockdep.h> #include <linux/idr.h> #include <linux/jhash.h>
@@ -5894,6 +5895,33 @@ struct workqueue_struct *alloc_workqueue_noprof(const char *fmt, }EXPORT_SYMBOL_GPL (alloc_workqueue_noprof); +static void devm_workqueue_release (void *res) +{ +destroy_workqueue (res); +} + +__printf(2, 5) struct workqueue_struct * +devm_alloc_workqueue (struct device *dev,const char *fmt,unsigned int flags, +int max_active, ...) +{ +struct workqueue_struct *wq; +va_list args; +int ret; + +va_start (args, max_active); + wq =alloc_workqueue (fmt, flags, max_active, args); +va_end (args); +if (!wq) +return NULL ; + + ret =devm_add_action_or_reset (dev, devm_workqueue_release, wq); +if (ret) +return NULL ; + +return wq; +} +EXPORT_SYMBOL_GPL (devm_alloc_workqueue); +#ifdef CONFIG_LOCKDEP __printf(1, 5) struct workqueue_struct *
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 225/621 power: supply: max77705: Drop duplicated IRQ error message
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Krzysztof Kozlowski <[email protected]>
[ Upstream commit 2064c64ceb1996ee02a6bbb1de05fd6e8028e3e4 ]
Core already prints error message on devm_request_threaded_irq() failure, so no need to do that second time.
Stable-dep-of: 1e668baadefb ("power: supply: max77705: Free allocated workqueue and fix removal order")
--- drivers/power/supply/max77705_charger.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)
drivers/power/supply/max77705_charger.c +1 -3
@@ -633,10 +633,8 @@ static int max77705_charger_probe(struct i2c_client *i2c)NULL , max77705_chgin_irq,IRQF_TRIGGER_NONE , "chgin-irq", chg); -if (ret) { -dev_err_probe (dev, ret,"Failed to Request chgin IRQ\n" ); +if (ret) goto destroy_wq; - } ret =max77705_charger_enable (chg);if (ret) {
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 226/621 power: supply: max77705: Free allocated workqueue and fix removal order
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Krzysztof Kozlowski <[email protected]>
[ Upstream commit 1e668baadefb16e81269dbfebf3ffc2672e3a3bb ]
Use devm interface for allocating workqueue to fix two bugs at the same time:
1. Driver leaks the memory on remove(), because the workqueue is not destroyed.
2. Driver allocates workqueue and then registers interrupt handlers with devm interface. This means that probe error paths will not use a reversed order, but first destroy the workqueue and then, via devm release handlers, free the interrupt.
The interrupt handler schedules work on this exact workqueue, thus if interrupt is hit in this short time window - after destroying workqueue, but before devm() frees the interrupt - the schedulled work will lead to use of freed memory.
Change is not equivalent in the workqueue itself: use non-legacy API which does not set (__WQ_LEGACY | WQ_MEM_RECLAIM). The workqueue is used to update power supply (power_supply_changed()) status, thus there is no point to run it for memory reclaim. Note that dev_name() is not directly used in second argument to prevent possible unlikely parsing any "%" character in device name as format.
--- drivers/power/supply/max77705_charger.c | 26 ++++++++----------------- 1 file changed, 8 insertions(+), 18 deletions(-)
drivers/power/supply/max77705_charger.c +8 -18
@@ -613,40 +613,30 @@ static int max77705_charger_probe(struct i2c_client *i2c)if (ret)return dev_err_probe (dev, ret,"failed to add irq chip\n" ); - chg->wqueue =create_singlethread_workqueue (dev_name (dev)); + chg->wqueue =devm_alloc_ordered_workqueue (dev,"%s" ,0 ,dev_name (dev));if (!chg->wqueue)return -ENOMEM ; ret =devm_work_autocancel (dev, &chg->chgin_work, max77705_chgin_isr_work); -if (ret) { -dev_err_probe (dev, ret,"failed to initialize interrupt work\n" ); - goto destroy_wq; - } +if (ret) +return dev_err_probe (dev, ret,"failed to initialize interrupt work\n" ); ret =max77705_charger_initialize (chg); -if (ret) { -dev_err_probe (dev, ret,"failed to initialize charger IC\n" ); - goto destroy_wq; - } +if (ret) +return dev_err_probe (dev, ret,"failed to initialize charger IC\n" ); ret =devm_request_threaded_irq (dev,regmap_irq_get_virq (irq_data,MAX77705_CHGIN_I ),NULL , max77705_chgin_irq,IRQF_TRIGGER_NONE ,"chgin-irq" , chg);if (ret) - goto destroy_wq; +return ret; ret =max77705_charger_enable (chg); -if (ret) { -dev_err_probe (dev, ret,"failed to enable charge\n" ); - goto destroy_wq; - } +if (ret) +return dev_err_probe (dev, ret,"failed to enable charge\n" );return devm_add_action_or_reset (dev, max77705_charger_disable, chg); - -destroy_wq: -destroy_workqueue (chg->wqueue); -return ret; }static const struct of_device_id max77705_charger_of_match[] = {
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 227/621 fbdev: omap2: fix inconsistent lock returns in omapfb_mmap
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Hongling Zeng <[email protected]>
[ Upstream commit 98cf7df6e0844f7076df1db690c1ede9d69b61ff ]
Fix the warning about inconsistent returns for '&rg->lock' in omapfb_mmap() function. The warning arises because the error path uses 'ofbi->region' while the normal path uses 'rg'.
smatch warnings:drivers/video/fbdev/omap2/omapfb/omapfb-main.c:1126 omapfb_mmap()
warn: inconsistent returns '&rg->lock'.
Stable-dep-of: 7958e67375aa ("fbdev: omap2: fix use-after-free in omapfb_mmap")
--- drivers/video/fbdev/omap2/omapfb/omapfb-main.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/video/fbdev/omap2/omapfb/omapfb-main.c +1 -1
@@ -1121,7 +1121,7 @@ static int omapfb_mmap(struct fb_info *fbi, struct vm_area_struct *vma)return 0 ; error: -omapfb_put_mem_region (ofbi->region); +omapfb_put_mem_region (rg);return r; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 228/621 fbdev: omap2: fix use-after-free in omapfb_mmap
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Hongling Zeng <[email protected]>
[ Upstream commit 7958e67375aa111522086286bba13cfc0816ce8d ]
omapfb_mmap() has a race condition with OMAPFB_SETUP_PLANE ioctl that can lead to use-after-free:
The fb_mmap() entry point holds mm_lock but not lock (fb_info->lock), while ioctl handlers like OMAPFB_SETUP_PLANE hold lock but not mm_lock. This allows concurrent execution.
In omapfb_mmap():
1. rg = omapfb_get_mem_region(ofbi->region); // Get old region ref
2. start = omapfb_get_region_paddr(ofbi); // Read from NEW region
3. len = fix->smem_len; // Read from NEW region
4. vm_iomap_memory(vma, start, len); // Map NEW region memory
5. atomic_inc(&rg->map_count); // Increment OLD region!
Concurrently, OMAPFB_SETUP_PLANE can:
- Reassign ofbi->region = new_rg
- Update fix->smem_len
- OMAPFB_SETUP_MEM then checks NEW region's map_count (0!) and frees it
This leaves userspace with a mapping to freed physical memory.
The fix is to read all required values (start, len) from the same region reference (rg) that will have its map_count incremented, preventing the region from being freed while still mapped.
--- drivers/video/fbdev/omap2/omapfb/omapfb-main.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)
drivers/video/fbdev/omap2/omapfb/omapfb-main.c +8 -1
@@ -1099,7 +1099,11 @@ static int omapfb_mmap(struct fb_info *fbi, struct vm_area_struct *vma) rg =omapfb_get_mem_region (ofbi->region); - start =omapfb_get_region_paddr (ofbi); +if (ofbi->rotation_type ==OMAP_DSS_ROT_VRFB ) + start = rg->vrfb.paddr[0 ]; +else + start = rg->paddr; + len = fix->smem_len; DBG("user mmap region start %lx, len %d, off %lx\n", start, len,
@@ -1109,6 +1113,8 @@ static int omapfb_mmap(struct fb_info *fbi, struct vm_area_struct *vma) vma->vm_ops = &mmap_user_ops; vma->vm_private_data = rg; +atomic_inc (&rg->map_count); + r =vm_iomap_memory (vma, start, len);if (r) goto error;
@@ -1121,6 +1127,7 @@ static int omapfb_mmap(struct fb_info *fbi, struct vm_area_struct *vma)return 0 ; error: +atomic_dec (&rg->map_count);omapfb_put_mem_region (rg);return r;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 229/621 f2fs: read COW data with the original inode during atomic write
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Mikhail Lobanov <[email protected]>
[ Upstream commit a41075acde0124d2f8a5f563068a5d63e8ffd57b ]
When updating an atomic-write file, f2fs_write_begin() may read the previously written data back from the COW inode:prepare_atomic_write_begin() locates the block in the COW inode and sets use_cow, and the read bio is then built with the COW inode:
f2fs_submit_page_read(use_cow ? F2FS_I(inode)->cow_inode : inode, ...);
and f2fs_grab_read_bio() decides whether to schedule fs-layer decryption (STEP_DECRYPT) for the bio based on that inode via fscrypt_inode_uses_fs_layer_crypto().
However, the folio being filled belongs to the original inode (folio->mapping->host == inode), and the data stored in the COW block was encrypted (or left as plaintext) using the original inode's context, not the COW inode's -- see f2fs_encrypt_one_page(), which keys off fio->page->mapping->host. fscrypt_decrypt_pagecache_blocks() likewise operates on folio->mapping->host.
The COW inode is created as a tmpfile in the parent directory and inherits its encryption policy from there. With test_dummy_encryption the newly created COW inode gets the dummy policy and becomes encrypted, while a pre-existing regular file -- created before the policy applied, e.g. already present in the on-disk image -- stays unencrypted. The read path then sets STEP_DECRYPT based on the encrypted COW inode and calls fscrypt_decrypt_pagecache_blocks() on a folio whose host (the unencrypted original inode) has a NULL ->i_crypt_info, dereferencing it:
Oops: general protection fault, probably for non-canonical address ... KASAN: null-ptr-deref in range [0x0000000000000008-0x000000000000000f] RIP: 0010:fscrypt_decrypt_pagecache_blocks+0xa0/0x310 Workqueue: f2fs_post_read_wq f2fs_post_read_work Call Trace: fscrypt_decrypt_bio+0x1eb/0x340 f2fs_post_read_work+0xba/0x140 process_one_work+0x91c/0x1a40 worker_thread+0x677/0xe90 kthread+0x2bc/0x3a0
The COW inode is only needed to locate the on-disk block, and that block address is already resolved into @blkaddr by prepare_atomic_write_begin() via __find_data_block(cow_inode, ...); f2fs_submit_page_read() then reads from that physical @blkaddr directly, so the inode argument only selects the post-read crypto context, not which block is fetched. Reading with @inode therefore returns the same (latest, not-yet-committed) COW data, while making both the fs-layer decryption decision and the inline crypto path use the correct (original inode's) key.
With the COW inode no longer used at the read site, the use_cow flag has no remaining consumer; drop it from f2fs_write_begin() and prepare_atomic_write_begin().
--- fs/f2fs/data.c | 27 ++++++++++++++++----------- 1 file changed, 16 insertions(+), 11 deletions(-)
fs/f2fs/data.c +16 -11
@@ -3562,7 +3562,7 @@ static int __reserve_data_block(struct inode *inode, pgoff_t index,static int prepare_atomic_write_begin (struct f2fs_sb_info *sbi,struct folio *folio,loff_t pos,unsigned int len, -block_t *blk_addr,bool *node_changed,bool *use_cow) +block_t *blk_addr,bool *node_changed) {struct inode *inode = folio->mapping->host;struct inode *cow_inode =F2FS_I (inode)->cow_inode;
@@ -3577,14 +3577,14 @@ static int prepare_atomic_write_begin(struct f2fs_sb_info *sbi,/* Look for the block in COW inode first */ err =__find_data_block (cow_inode, index, blk_addr); -if (err) { +if (err)return err; - }else if (__is_valid_data_blkaddr (*blk_addr)) { - *use_cow = true; + +if (__is_valid_data_blkaddr (*blk_addr))return 0 ; - }else if (*blk_addr ==NEW_ADDR ) { + +if (*blk_addr ==NEW_ADDR ) cow_has_reserved_block = true; - }if (is_inode_flag_set (inode,FI_ATOMIC_REPLACE )) goto reserve_block;
@@ -3619,7 +3619,6 @@ static int f2fs_write_begin(const struct kiocb *iocb,struct folio *folio;pgoff_t index = pos >>PAGE_SHIFT ;bool need_balance = false; -bool use_cow = false;block_t blkaddr =NULL_ADDR ;int err =0 ;
@@ -3681,7 +3680,7 @@ static int f2fs_write_begin(const struct kiocb *iocb,if (f2fs_is_atomic_file (inode)) err =prepare_atomic_write_begin (sbi, folio, pos, len, - &blkaddr, &need_balance, &use_cow); + &blkaddr, &need_balance);else err =prepare_write_begin (sbi, folio, pos, len, &blkaddr, &need_balance);
@@ -3721,9 +3720,15 @@ static int f2fs_write_begin(const struct kiocb *iocb, err = -EFSCORRUPTED ; goto put_folio; } -f2fs_submit_page_read (use_cow ? -F2FS_I (inode)->cow_inode : inode, - folio, blkaddr,0 , true); +/* +* Although the block may be stored in the COW inode, the folio +* belongs to @inode and its data was encrypted (or not) using +* @inode's context (see f2fs_encrypt_one_page()). Read with +* @inode so the post-read decryption decision matches the +* folio's owner; otherwise an unencrypted @inode whose COW inode +* is encrypted hits a NULL ->i_crypt_info on decryption. +*/ +f2fs_submit_page_read (inode, folio, blkaddr,0 , true);folio_lock (folio);if (unlikely (folio->mapping != mapping)) {
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 230/621 netfilter: nf_tables: add hook transactions for device deletions
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
[ Upstream commit 10f79dbd7719d1da9f5884d13060322d8729f091 ]
Restore the flag that indicates that the hook is going away, ie. NFT_HOOK_REMOVE, but add a new transaction object to track deletion of hooks without altering the basechain/flowtable hook_list during the preparation phase.
The existing approach that moves the hook from the basechain/flowtable hook_list to transaction hook_list breaks netlink dump path readers of this RCU-protected list.
It should be possible use an array for nft_trans_hook to store the deleted hooks to compact the representation but I am not expecting many hook object, specially now that wildcard support for devices is in place.
Note that the nft_trans_chain_hooks() list contains a list of struct nft_trans_hook objects for DELCHAIN and DELFLOWTABLE commands, while this list stores struct nft_hook objects for NEWCHAIN and NEWFLOWTABLE. Note that new commands can be updated to use nft_trans_hook for consistency.
This patch also adapts the event notification path to deal with the list of hook transactions.
--- include/net/netfilter/nf_tables.h | 13 ++ net/netfilter/nf_tables_api.c | 264 +++++++++++++++++++++++------- 2 files changed, 217 insertions(+), 60 deletions(-)
include/net/netfilter/nf_tables.h +13 -0
@@ -1208,12 +1208,15 @@ struct nft_stats {struct u64_stats_sync syncp; }; +#define NFT_HOOK_REMOVE (1 << 0) +struct nft_hook {struct list_head list;struct list_head ops_list;struct rcu_head rcu;char ifname[IFNAMSIZ ];u8 ifnamelen; +u8 flags; }; struct nf_hook_ops *nft_hook_find_ops(const struct nft_hook *hook,
@@ -1670,6 +1673,16 @@ struct nft_trans { u8 put_net:1; }; +/** +* struct nft_trans_hook - nf_tables hook update in transaction +* @list: used internally +* @hook: struct nft_hook with the device hook +*/ +struct nft_trans_hook { +struct list_head list; +struct nft_hook *hook; +}; +/** * struct nft_trans_binding - nf_tables object with binding support in transaction * @nft_trans: base structure, MUST be first member
net/netfilter/nf_tables_api.c +204 -60
494 lines not on this page · raw message
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 231/621 drm/amdgpu: fix amdgpu_hmm_range_get_pages
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Christian König <[email protected]>
[ Upstream commit 962d684b5dc0741dcd93485d41b450de402d5592 ]
The notifier sequence must only be read once or otherwise we could work with invalid pages.
While at it also fix the coding style, e.g. drop the pre-initialized return value and use the common define for 2G range.
--- drivers/gpu/drm/amd/amdgpu/amdgpu_hmm.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_hmm.c +7 -7
@@ -51,8 +51,6 @@#include "amdgpu_amdkfd.h" #include "amdgpu_hmm.h" -#define MAX_WALK_BYTE (2UL << 30) -/** * amdgpu_hmm_invalidate_gfx - callback to notify about mm change *
@@ -172,11 +170,13 @@ int amdgpu_hmm_range_get_pages(struct mmu_interval_notifier *notifier,void *owner, struct hmm_range **phmm_range) { + const u64 max_bytes = SZ_2G; +struct hmm_range *hmm_range; -unsigned long end;unsigned long timeout;unsigned long *pfns; -int r =0 ; +unsigned long end; +int r; hmm_range =kzalloc (sizeof (*hmm_range),GFP_KERNEL );if (unlikely (!hmm_range))
@@ -197,8 +197,9 @@ int amdgpu_hmm_range_get_pages(struct mmu_interval_notifier *notifier, end = start + npages *PAGE_SIZE ; hmm_range->dev_private_owner = owner; + hmm_range->notifier_seq =mmu_interval_read_begin (notifier); do { - hmm_range->end = min(hmm_range->start + MAX_WALK_BYTE, end); + hmm_range->end = min(hmm_range->start + max_bytes, end); pr_debug("hmm range: start = 0x%lx, end = 0x%lx", hmm_range->start, hmm_range->end);
@@ -206,7 +207,6 @@ int amdgpu_hmm_range_get_pages(struct mmu_interval_notifier *notifier, timeout = jiffies +msecs_to_jiffies (HMM_RANGE_DEFAULT_TIMEOUT ); retry: - hmm_range->notifier_seq =mmu_interval_read_begin (notifier); r =hmm_range_fault (hmm_range);if (unlikely (r)) {if (r == -EBUSY && !time_after (jiffies, timeout))
@@ -216,7 +216,7 @@ int amdgpu_hmm_range_get_pages(struct mmu_interval_notifier *notifier,if (hmm_range->end == end)break ; - hmm_range->hmm_pfns +=MAX_WALK_BYTE >>PAGE_SHIFT ; + hmm_range->hmm_pfns += max_bytes >>PAGE_SHIFT ; hmm_range->start = hmm_range->end; }while (hmm_range->end < end);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 232/621 KVM: arm64: Correctly cap ZCR_EL2 provided by a guest hypervisor
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Mark Brown <[email protected]>
[ Upstream commit 83726330748981372bde86ed5411d7b306612991 ]
ZCR_EL2 can be updated by a VHE guest hypervisor either using ZCR_EL2 (which traps) or ZCR_EL1 (which does not trap). KVM handles both in different way:
- on ZCR_EL2 trap, ZCR_EL2.LEN is immediately capped at the VM's own VL limit. This has the potential to break existing SW that relies on the full LEN field to be stateful.
- on ZCR_EL1 access, we do absolutely nothing.
On restoring the SVE context for an L2 guest, we directly restore the guest hypervisor's view of ZCR_EL2 into the physical ZCR_EL2. If the guest's view of the register was updated using the ZCR_EL2 accessor, the value has already been sanitised (with the caveat mentioned above).
But if the guest used ZCR_EL1, the raw value is written into the HW, and the L2 guest can now access VLs that it shouldn't.
Fix all the above by moving the VL capping to the restore points, ensuring that:
- the HW is always programmed with a capped value, irrespective of the accessor being used,
- the ZCR_EL2.LEN field is always completely stateful, irrespective of the accessor being used.
Additionally, move ZCR_EL2 to be a sanitised register, ensuring that only the LEN field is actually stateful. This requires some creative construction of the RES0 mask, as the sysreg generation script does not yet generate RAZ/WI fields.
--- arch/arm64/include/asm/kvm_host.h | 2 +- arch/arm64/kvm/hyp/include/hyp/switch.h | 16 ++++++++++------ arch/arm64/kvm/nested.c | 4 ++++ arch/arm64/kvm/sys_regs.c | 11 +++-------- 4 files changed, 18 insertions(+), 15 deletions(-)
arch/arm64/include/asm/kvm_host.h +1 -1
@@ -493,7 +493,6 @@ enum vcpu_sysreg {ACTLR_EL2 ,/* Auxiliary Control Register (EL2) */ CPTR_EL2 ,/* Architectural Feature Trap Register (EL2) */ HACR_EL2 ,/* Hypervisor Auxiliary Control Register */ -ZCR_EL2 ,/* SVE Control Register (EL2) */ TTBR0_EL2 ,/* Translation Table Base Register 0 (EL2) */ TTBR1_EL2 ,/* Translation Table Base Register 1 (EL2) */ TCR_EL2, /* Translation Control Register (EL2) */
@@ -524,6 +523,7 @@ enum vcpu_sysreg {SCTLR2_EL2 ,/* System Control Register 2 (EL2) */ MDCR_EL2 ,/* Monitor Debug Configuration Register (EL2) */ CNTHCTL_EL2 ,/* Counter-timer Hypervisor Control register */ +ZCR_EL2 ,/* SVE Control Register (EL2) */ /* Any VNCR-capable reg goes after this point */ MARKER(__VNCR_START__),
arch/arm64/kvm/hyp/include/hyp/switch.h +10 -6
@@ -438,11 +438,13 @@ static inline bool kvm_hyp_handle_mops(struct kvm_vcpu *vcpu, u64 *exit_code)static inline void __hyp_sve_restore_guest (struct kvm_vcpu *vcpu) { +u64 zcr_el2 =vcpu_sve_max_vq (vcpu) -1 ; +/* * The vCPU's saved SVE state layout always matches the max VL of the * vCPU. Start off with the max VL so we can load the SVE state. */ -sve_cond_update_zcr_vq (vcpu_sve_max_vq (vcpu) -1 ,SYS_ZCR_EL2 ); +sve_cond_update_zcr_vq (zcr_el2,SYS_ZCR_EL2 );__sve_restore_state (vcpu_sve_pffr (vcpu), &vcpu->arch.ctxt.fp_regs.fpsr, true);
@@ -452,8 +454,10 @@ static inline void __hyp_sve_restore_guest(struct kvm_vcpu *vcpu)* nested guest, as the guest hypervisor could select a smaller VL. Slap * that into hardware before wrapping up. */ -if (is_nested_ctxt (vcpu)) -sve_cond_update_zcr_vq (__vcpu_sys_reg (vcpu,ZCR_EL2 ),SYS_ZCR_EL2 ); +if (is_nested_ctxt (vcpu)) { + zcr_el2 =min (zcr_el2,__vcpu_sys_reg (vcpu,ZCR_EL2 )); +sve_cond_update_zcr_vq (zcr_el2,SYS_ZCR_EL2 ); + }write_sysreg_el1 (__vcpu_sys_reg (vcpu,vcpu_sve_zcr_elx (vcpu)),SYS_ZCR ); }
@@ -477,11 +481,11 @@ static inline void fpsimd_lazy_switch_to_guest(struct kvm_vcpu *vcpu)return ;if (vcpu_has_sve (vcpu)) { + zcr_el2 =vcpu_sve_max_vq (vcpu) -1 ; +/* A guest hypervisor may restrict the effective max VL. */ if (is_nested_ctxt (vcpu)) - zcr_el2 =__vcpu_sys_reg (vcpu,ZCR_EL2 ); -else - zcr_el2 =vcpu_sve_max_vq (vcpu) -1 ; + zcr_el2 =min (zcr_el2,__vcpu_sys_reg (vcpu,ZCR_EL2 ));write_sysreg_el2 (zcr_el2,SYS_ZCR );
arch/arm64/kvm/nested.c +4 -0
@@ -1840,6 +1840,10 @@ int kvm_init_nv_sysregs(struct kvm_vcpu *vcpu)/* VNCR_EL2 */ set_sysreg_masks (kvm,VNCR_EL2 ,VNCR_EL2_RES0 ,VNCR_EL2_RES1 ); +/* ZCR_EL2 - bits 8:4 are RAZ/WI so treat them as RES0 */ +set_sysreg_masks (kvm,ZCR_EL2 , ZCR_ELx_RES0 |GENMASK_ULL (8 ,4 ), + ZCR_ELx_RES1); + out:for (enum vcpu_sysreg sr = __SANITISED_REG_START__; sr <NR_SYS_REGS ; sr++) __vcpu_rmw_sys_reg(vcpu, sr, |=, 0);
arch/arm64/kvm/sys_regs.c +3 -8
@@ -2750,21 +2750,16 @@ static bool access_zcr_el2(struct kvm_vcpu *vcpu,struct sys_reg_params *p, const struct sys_reg_desc *r) { - unsigned int vq; - if (guest_hyp_sve_traps_enabled(vcpu)) {kvm_inject_nested_sve_trap (vcpu );return false; } -if (!p->is_write) { +if (!p->is_write) p->regval =__vcpu_sys_reg (vcpu,ZCR_EL2 ); -return true; - } +else +__vcpu_assign_sys_reg (vcpu,ZCR_EL2 , p->regval); - vq =SYS_FIELD_GET (ZCR_ELx,LEN , p->regval) +1 ; - vq =min (vq,vcpu_sve_max_vq (vcpu)); -__vcpu_assign_sys_reg (vcpu,ZCR_EL2 , vq -1 );return true; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 233/621 net: Introduce skb tc depth field to track packet loops
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Jamal Hadi Salim <[email protected]>
[ Upstream commit 98b34f3e8c3492cfc89ff943c9d92b4d52863d1d ]
Add a 2-bit per-skb tc depth field to track packet loops across the stack.
The previous per-CPU loop counters like MIRRED_NEST_LIMIT assume a single call stack and lose state in two cases:
1) When a packet is queued and reprocessed later (e.g., egress->ingress via backlog), the per-cpu state is gone by the time it is dequeued.
2) With XPS/RPS a packet may arrive on one CPU and be processed on another.
A per-skb field solves both by travelling with the packet itself.
The field fits in existing padding, using 2 bits that were previously a hole:
pahole before(-) and after (+) diff looks like:
__u8 slow_gro:1; /* 132: 3 1 */ __u8 csum_not_inet:1; /* 132: 4 1 */ __u8 unreadable:1; /* 132: 5 1 */ + __u8 tc_depth:2; /* 132: 6 1 */
- /* XXX 2 bits hole, try to pack */
/* XXX 1 byte hole, try to pack */
__u16 tc_index; /* 134 2 */
There used to be a ttl field which was removed as part of tc_verd in commit aec745e2c520 ("net-tc: remove unused tc_verd fields"). It was already unused by that time, due to remove earlier in commit c19ae86a510c ("tc: remove unused redirect ttl").
The first user of this field is netem, which increments tc_depth on duplicated packets before re-enqueueing them at the root qdisc. On re-entry, netem skips duplication for any skb with tc_depth already set, bounding recursion to a single level regardless of tree topology.
The other user is mirred which increments it on each pass and limits to depth to MIRRED_DEFER_LIMIT (3).
The new field was called ttl in earlier versions of this patch but renamed to tc_depth to avoid confusion with IP ttl.
Note (looking at you Sashiko! Dont ignore me and continue bringing this up):
1. Since both mirred and netem utilize the same 2-bit tc_depth field it is possible when netem and mirred are used together that netem qdisc to skip the duplication step. This is a known trade-off, as a 2-bit field cannot independently track both features' recursion depths and it is not considered sane to have a setup that addresses both features on at the same time.
2. skb_scrub_packet does not clear tc_depth. This means a packet's loop history is preserved even across namespaces. While this might be restrictive for some topologies, it is also design intent to provide robustness against loops across namespaces.
Stable-dep-of: 9552b11e3eda ("net/sched: fix packet loop on netem when duplicate is on")
--- include/linux/skbuff.h | 2 ++ 1 file changed, 2 insertions(+)
include/linux/skbuff.h +2 -0
@@ -821,6 +821,7 @@ enum skb_tstamp_type {* @_sk_redir: socket redirection information for skmsg * @_nfct: Associated connection, if any (with nfctinfo bits) * @skb_iif: ifindex of device we arrived on +* @tc_depth: counter for packet duplication * @tc_index: Traffic control index * @hash: the packet hash * @queue_mapping: Queue mapping for multiqueue devices
@@ -1030,6 +1031,7 @@ struct sk_buff { __u8 csum_not_inet:1;#endif __u8 unreadable:1; + __u8 tc_depth:2;#if defined(CONFIG_NET_SCHED ) || defined(CONFIG_NET_XGRESS )__u16 tc_index;/* traffic control index */ #endif
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 234/621 net/sched: fix packet loop on netem when duplicate is on
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Jamal Hadi Salim <[email protected]>
[ Upstream commit 9552b11e3edabc97cfcd9f29103d5afbce7ae183 ]
When netem duplicates a packet it re-enqueues the copy at the root qdisc. If another netem sits in the tree the copy can be duplicated again, recursing until the stack or memory is exhausted.
The original duplication guard temporarily zeroed q->duplicate around the re-enqueue, but that does not cover all cases because it is per-qdisc state shared across all concurrent enqueue paths and is not safe without additional locking.
Use the skb tc_depth field introduced in an earlier patch:
- increment it on the duplicate before re-enqueue
- skip duplication for any skb whose tc_depth is already non-zero.
This marks the packet itself rather than mutating qdisc state, therefore it is safe regardless of tree topology or concurrency.
--- net/sched/sch_netem.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-)
net/sched/sch_netem.c +3 -4
@@ -460,7 +460,8 @@ static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch, skb->prev =NULL ;/* Random duplication */ -if (q->duplicate && q->duplicate >=get_crandom (&q->dup_cor, &q->prng)) +if (q->duplicate && skb->tc_depth ==0 && + q->duplicate >=get_crandom (&q->dup_cor, &q->prng)) ++count;/* Drop packet? */
@@ -539,11 +540,9 @@ static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch,*/ if (skb2) {struct Qdisc *rootq =qdisc_root_bh (sch); -u32 dupsave = q->duplicate;/* prevent duplicating a dup... */ - q->duplicate =0 ; + skb2->tc_depth++;/* prevent duplicating a dup... */ rootq->enqueue (skb2, rootq, to_free); - q->duplicate = dupsave; skb2 =NULL ; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 235/621 ACPI: button: Adjust event notification routines
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Rafael J. Wysocki <[email protected]>
[ Upstream commit 93dc5db6d47aaa3b4b458ddfddfa3369c24e22f4 ]
Adjust the event notification routines in the ACPI button driver to take a struct acpi_button pointer as an argument istead of a struct acpi_device one where applicable, which allows the use of acpi_driver_data() to be limited and will facilitate subsequent changes.
No intentional functional impact.
Stable-dep-of: fe80251152fe ("ACPI: button: Fix ACPI GPE handler leak during removal")
--- drivers/acpi/button.c | 67 +++++++++++++++++++++---------------------- 1 file changed, 33 insertions(+), 34 deletions(-)
drivers/acpi/button.c +33 -34
@@ -169,6 +169,7 @@ static struct acpi_driver acpi_button_driver = { };struct acpi_button { +struct acpi_device *adev;unsigned int type;struct input_dev *input;char phys[32 ];/* for input device */
@@ -202,9 +203,9 @@ static int acpi_lid_evaluate_state(struct acpi_device *device)return lid_state ?1 :0 ; } -static int acpi_lid_notify_state (struct acpi_device *device,int state) +static int acpi_lid_notify_state (struct acpi_button *button,int state) { -struct acpi_button *button =acpi_driver_data (device); +struct acpi_device *device = button->adev;ktime_t next_report;bool do_update;
@@ -287,18 +288,18 @@ static int acpi_lid_notify_state(struct acpi_device *device, int state)static int __maybe_unused acpi_button_state_seq_show (struct seq_file *seq,void *offset) { -struct acpi_device *device = seq->private; +struct acpi_button *button = seq->private;int state; - state =acpi_lid_evaluate_state (device); + state =acpi_lid_evaluate_state (button->adev);seq_printf (seq,"state: %s\n" , state <0 ?"unsupported" : (state ?"open" :"closed" ));return 0 ; } -static int acpi_button_add_fs (struct acpi_device *device) +static int acpi_button_add_fs (struct acpi_button *button) { -struct acpi_button *button =acpi_driver_data (device); +struct acpi_device *device = button->adev;struct proc_dir_entry *entry =NULL ;int ret =0 ;
@@ -333,7 +334,7 @@ static int acpi_button_add_fs(struct acpi_device *device)/* create /proc/acpi/button/lid/LID/state */ entry =proc_create_single_data (ACPI_BUTTON_FILE_STATE ,S_IRUGO ,acpi_device_dir (device), acpi_button_state_seq_show, - device); + button);if (!entry) { ret = -ENODEV ; goto remove_dev_dir;
@@ -355,9 +356,9 @@ static int acpi_button_add_fs(struct acpi_device *device) goto done; } -static int acpi_button_remove_fs (struct acpi_device *device) +static int acpi_button_remove_fs (struct acpi_button *button) { -struct acpi_button *button =acpi_driver_data (device); +struct acpi_device *device = button->adev;if (button->type !=ACPI_BUTTON_TYPE_LID )return 0 ;
@@ -385,9 +386,10 @@ int acpi_lid_open(void) }EXPORT_SYMBOL (acpi_lid_open); -static int acpi_lid_update_state (struct acpi_device *device, +static int acpi_lid_update_state (struct acpi_button *button,bool signal_wakeup) { +struct acpi_device *device = button->adev;int state; state =acpi_lid_evaluate_state (device);
@@ -397,19 +399,17 @@ static int acpi_lid_update_state(struct acpi_device *device,if (state && signal_wakeup)acpi_pm_wakeup_event (&device->dev); -return acpi_lid_notify_state (device, state); +return acpi_lid_notify_state (button, state); } -static void acpi_lid_initialize_state (struct acpi_device *device) +static void acpi_lid_initialize_state (struct acpi_button *button) { -struct acpi_button *button =acpi_driver_data (device); -switch (lid_init_state) {case ACPI_BUTTON_LID_INIT_OPEN : - (void )acpi_lid_notify_state (device,1 ); + (void )acpi_lid_notify_state (button,1 );break ;case ACPI_BUTTON_LID_INIT_METHOD : - (void )acpi_lid_update_state (device, false); + (void )acpi_lid_update_state (button, false);break ;case ACPI_BUTTON_LID_INIT_IGNORE :default :
@@ -421,8 +421,8 @@ static void acpi_lid_initialize_state(struct acpi_device *device)static void acpi_lid_notify (acpi_handle handle,u32 event,void *data) { -struct acpi_device *device = data; -struct acpi_button *button; +struct acpi_button *button = data; +struct acpi_device *device = button->adev;if (event !=ACPI_BUTTON_NOTIFY_STATUS ) { acpi_handle_debug(device->handle, "Unsupported event [0x%x]\n",
@@ -430,17 +430,16 @@ static void acpi_lid_notify(acpi_handle handle, u32 event, void *data)return ; } - button =acpi_driver_data (device);if (!button->lid_state_initialized)return ; -acpi_lid_update_state (device, true); +acpi_lid_update_state (button, true); }static void acpi_button_notify (acpi_handle handle,u32 event,void *data) { -struct acpi_device *device = data; -struct acpi_button *button; +struct acpi_button *button = data; +struct acpi_device *device = button->adev;struct input_dev *input;int keycode;
@@ -457,7 +456,6 @@ static void acpi_button_notify(acpi_handle handle, u32 event, void *data)acpi_pm_wakeup_event (&device->dev); - button =acpi_driver_data (device);if (button->suspended || event ==ACPI_BUTTON_NOTIFY_WAKE )return ;
@@ -505,7 +503,7 @@ static int acpi_button_resume(struct device *dev)if (button->type ==ACPI_BUTTON_TYPE_LID ) { button->last_state = !!acpi_lid_evaluate_state (device); button->last_time =ktime_get (); -acpi_lid_initialize_state (device); +acpi_lid_initialize_state (button); }if (button->type ==ACPI_BUTTON_TYPE_POWER ) {
@@ -521,12 +519,12 @@ static int acpi_button_resume(struct device *dev)static int acpi_lid_input_open (struct input_dev *input) { -struct acpi_device *device =input_get_drvdata (input); -struct acpi_button *button =acpi_driver_data (device); +struct acpi_button *button =input_get_drvdata (input); +struct acpi_device *device = button->adev; button->last_state = !!acpi_lid_evaluate_state (device); button->last_time =ktime_get (); -acpi_lid_initialize_state (device); +acpi_lid_initialize_state (button);return 0 ; }
@@ -551,6 +549,7 @@ static int acpi_button_add(struct acpi_device *device) device->driver_data = button; + button->adev = device; button->input = input =input_allocate_device ();if (!input) { error = -ENOMEM ;
@@ -587,7 +586,7 @@ static int acpi_button_add(struct acpi_device *device) }if (!error) - error =acpi_button_add_fs (device); + error =acpi_button_add_fs (button);if (error) {input_free_device (input);
@@ -617,7 +616,7 @@ static int acpi_button_add(struct acpi_device *device)break ; } -input_set_drvdata (input, device); +input_set_drvdata (input, button); error =input_register_device (input);if (error) {input_free_device (input);
@@ -628,17 +627,17 @@ static int acpi_button_add(struct acpi_device *device)case ACPI_BUS_TYPE_POWER_BUTTON : status =acpi_install_fixed_event_handler (ACPI_EVENT_POWER_BUTTON , acpi_button_event, - device); + button);break ;case ACPI_BUS_TYPE_SLEEP_BUTTON : status =acpi_install_fixed_event_handler (ACPI_EVENT_SLEEP_BUTTON , acpi_button_event, - device); + button);break ;default : status =acpi_install_notify_handler (device->handle,ACPI_ALL_NOTIFY , handler, - device); + button);break ; }if (ACPI_FAILURE (status)) {
@@ -661,7 +660,7 @@ static int acpi_button_add(struct acpi_device *device) err_input_unregister:input_unregister_device (input); err_remove_fs: -acpi_button_remove_fs (device); +acpi_button_remove_fs (button); err_free_button:kfree (button);return error;
@@ -689,7 +688,7 @@ static void acpi_button_remove(struct acpi_device *device) }acpi_os_wait_events_complete (); -acpi_button_remove_fs (device); +acpi_button_remove_fs (button);input_unregister_device (button->input);kfree (button); }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 236/621 ACPI: button: Convert the driver to a platform one
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Rafael J. Wysocki <[email protected]>
[ Upstream commit 52d86401963666423cb9a56d117136c846093db0 ]
While binding drivers directly to struct acpi_device objects allows basic functionality to be provided, at least in the majority of cases, there are some problems with it, related to general consistency, sysfs layout, power management operation ordering, and code cleanliness.
Overall, it is better to bind drivers to platform devices than to their ACPI companions, so convert the ACPI button driver to a platform one.
While this is not expected to alter functionality, it changes sysfs layout and so it will be visible to user space.
Stable-dep-of: fe80251152fe ("ACPI: button: Fix ACPI GPE handler leak during removal")
--- drivers/acpi/button.c | 61 +++++++++++++++++++++++-------------------- 1 file changed, 32 insertions(+), 29 deletions(-)
drivers/acpi/button.c +32 -29
@@ -19,6 +19,7 @@#include <linux/slab.h> #include <linux/acpi.h> #include <linux/dmi.h> +#include <linux/platform_device.h> #include <acpi/button.h> #define ACPI_BUTTON_CLASS "button"
@@ -145,8 +146,8 @@ static const struct dmi_system_id dmi_lid_quirks[] = { {} }; -static int acpi_button_add (struct acpi_device *device); -static void acpi_button_remove (struct acpi_device *device); +static int acpi_button_probe (struct platform_device *pdev); +static void acpi_button_remove (struct platform_device *pdev);#ifdef CONFIG_PM_SLEEP static int acpi_button_suspend (struct device *dev);
@@ -157,19 +158,19 @@ static int acpi_button_resume(struct device *dev);#endif static SIMPLE_DEV_PM_OPS(acpi_button_pm, acpi_button_suspend, acpi_button_resume); -static struct acpi_driver acpi_button_driver = { - .name ="button" , - .class =ACPI_BUTTON_CLASS , - .ids = button_device_ids, - .ops = { - .add = acpi_button_add, - .remove = acpi_button_remove, +static struct platform_driver acpi_button_driver = { + .probe = acpi_button_probe, + .remove = acpi_button_remove, + .driver = { + .name ="acpi-button" , + .acpi_match_table = button_device_ids, + .pm = &acpi_button_pm, }, - .drv.pm = &acpi_button_pm, };struct acpi_button {struct acpi_device *adev; +struct platform_device *pdev;unsigned int type;struct input_dev *input;char phys[32 ];/* for input device */
@@ -397,7 +398,7 @@ static int acpi_lid_update_state(struct acpi_button *button,return state;if (state && signal_wakeup) -acpi_pm_wakeup_event (&device->dev); +acpi_pm_wakeup_event (&button->pdev->dev);return acpi_lid_notify_state (button, state); }
@@ -454,7 +455,7 @@ static void acpi_button_notify(acpi_handle handle, u32 event, void *data)return ; } -acpi_pm_wakeup_event (&device->dev); +acpi_pm_wakeup_event (&button->pdev->dev);if (button->suspended || event ==ACPI_BUTTON_NOTIFY_WAKE )return ;
@@ -486,8 +487,7 @@ static u32 acpi_button_event(void *data)#ifdef CONFIG_PM_SLEEP static int acpi_button_suspend (struct device *dev) { -struct acpi_device *device =to_acpi_device (dev); -struct acpi_button *button =acpi_driver_data (device); +struct acpi_button *button =dev_get_drvdata (dev); button->suspended = true;return 0 ;
@@ -495,9 +495,9 @@ static int acpi_button_suspend(struct device *dev)static int acpi_button_resume (struct device *dev) { +struct acpi_button *button =dev_get_drvdata (dev); +struct acpi_device *device =ACPI_COMPANION (dev);struct input_dev *input; -struct acpi_device *device =to_acpi_device (dev); -struct acpi_button *button =acpi_driver_data (device); button->suspended = false;if (button->type ==ACPI_BUTTON_TYPE_LID ) {
@@ -529,8 +529,9 @@ static int acpi_lid_input_open(struct input_dev *input)return 0 ; } -static int acpi_button_add (struct acpi_device *device) +static int acpi_button_probe (struct platform_device *pdev) { +struct acpi_device *device =ACPI_COMPANION (&pdev->dev);acpi_notify_handler handler;struct acpi_button *button;struct input_dev *input;
@@ -547,8 +548,9 @@ static int acpi_button_add(struct acpi_device *device)if (!button)return -ENOMEM ; - device->driver_data = button; +platform_set_drvdata (pdev, button); + button->pdev = pdev; button->adev = device; button->input = input =input_allocate_device ();if (!input) {
@@ -599,7 +601,7 @@ static int acpi_button_add(struct acpi_device *device) input->phys = button->phys; input->id.bustype =BUS_HOST ; input->id.product = button->type; - input->dev.parent = &device->dev; + input->dev.parent = &pdev->dev;switch (button->type) {case ACPI_BUTTON_TYPE_POWER :
@@ -653,7 +655,7 @@ static int acpi_button_add(struct acpi_device *device) lid_device = device; } -device_init_wakeup (&device->dev, true); +device_init_wakeup (&pdev->dev, true);pr_info ("%s [%s]\n" , name,acpi_device_bid (device));return 0 ;
@@ -666,9 +668,10 @@ static int acpi_button_add(struct acpi_device *device)return error; } -static void acpi_button_remove (struct acpi_device *device) +static void acpi_button_remove (struct platform_device *pdev) { -struct acpi_button *button =acpi_driver_data (device); +struct acpi_device *device =ACPI_COMPANION (&pdev->dev); +struct acpi_button *button =platform_get_drvdata (pdev);switch (device->device_type) {case ACPI_BUS_TYPE_POWER_BUTTON :
@@ -727,7 +730,7 @@ module_param_call(lid_init_state, NULL, 0644);MODULE_PARM_DESC (lid_init_state,"Behavior for reporting LID initial state" ); -static int acpi_button_register_driver (struct acpi_driver *driver) +static int __init acpi_button_init (void ) {const struct dmi_system_id *dmi_id;
@@ -743,20 +746,20 @@ static int acpi_button_register_driver(struct acpi_driver *driver)* Modules such as nouveau.ko and i915.ko have a link time dependency * on acpi_lid_open(), and would therefore not be loadable on ACPI * capable kernels booted in non-ACPI mode if the return value of -* acpi_bus_register_driver() is returned from here with ACPI disabled +* platform_driver_register() is returned from here with ACPI disabled * when this driver is built as a module. */ if (acpi_disabled)return 0 ; -return acpi_bus_register_driver (driver); +return platform_driver_register (&acpi_button_driver); } -static void acpi_button_unregister_driver (struct acpi_driver *driver) +static void __exit acpi_button_exit(void) {if (!acpi_disabled) -acpi_bus_unregister_driver (driver); +platform_driver_unregister (&acpi_button_driver); } -module_driver (acpi_button_driver, acpi_button_register_driver, - acpi_button_unregister_driver); +module_init (acpi_button_init); +module_exit (acpi_button_exit);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 237/621 ACPI: button: Tweak acpi_button_remove()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Rafael J. Wysocki <[email protected]>
[ Upstream commit 1abdf9e7967f154b3d4bfe0681dd38b8e036ee63 ]
Modify acpi_button_remove() to get the ACPI device object pointer from button->adev instead of retrieving it with the help of the ACPI_COMPANION() macro to reduce overhead slightly.
While at it, rename the struct acpi_device pointer variable in acpi_button_remove() to adev.
No intentional functional impact.
Stable-dep-of: fe80251152fe ("ACPI: button: Fix ACPI GPE handler leak during removal")
--- drivers/acpi/button.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/acpi/button.c +3 -3
@@ -670,10 +670,10 @@ static int acpi_button_probe(struct platform_device *pdev)static void acpi_button_remove (struct platform_device *pdev) { -struct acpi_device *device =ACPI_COMPANION (&pdev->dev);struct acpi_button *button =platform_get_drvdata (pdev); +struct acpi_device *adev = button->adev; -switch (device->device_type) { +switch (adev->device_type) {case ACPI_BUS_TYPE_POWER_BUTTON :acpi_remove_fixed_event_handler (ACPI_EVENT_POWER_BUTTON , acpi_button_event);
@@ -683,7 +683,7 @@ static void acpi_button_remove(struct platform_device *pdev) acpi_button_event);break ;default : -acpi_remove_notify_handler (device->handle,ACPI_DEVICE_NOTIFY , +acpi_remove_notify_handler (adev->handle,ACPI_DEVICE_NOTIFY , button->type ==ACPI_BUTTON_TYPE_LID ? acpi_lid_notify : acpi_button_notify);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 238/621 ACPI: button: Fix ACPI GPE handler leak during removal
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Rafael J. Wysocki <[email protected]>
[ Upstream commit fe80251152fed5b185f795ef2cd9f7fe9c3162e0 ]
Commit a7e23ec17fee ("ACPI: button: Install notifier for system events as well") changed the ACPI notify handler type for ACPI buttons to ACPI_ALL_NOTIFY, but it forgot to update acpi_button_remove() to reflect that change. This leads to leaking the notify handler past driver removal, which may cause a kernel crash to occur if ACPI notify on the given device is triggered after removing the driver, and causes a subsequent probe of the given device with the same driver to fail.
Address this by updating the acpi_remove_notify_handler() call in acpi_button_remove() as appropriate.
--- drivers/acpi/button.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/acpi/button.c +1 -1
@@ -683,7 +683,7 @@ static void acpi_button_remove(struct platform_device *pdev) acpi_button_event);break ;default : -acpi_remove_notify_handler (adev->handle,ACPI_DEVICE_NOTIFY , +acpi_remove_notify_handler (adev->handle,ACPI_ALL_NOTIFY , button->type ==ACPI_BUTTON_TYPE_LID ? acpi_lid_notify : acpi_button_notify);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 239/621 nvme-pci: fix dma mapping leak on data setup error
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Keith Busch <[email protected]>
[ Upstream commit 1bf86336e4b6cf40873fda47a7fe191446864937 ]
We're leaking the initial DMA mapping during iteration if we fail to allocate the tracking descriptor for both PRP and SGL. Unmap the iterator directly; we can't use the existing unmap helper because it depends on the tracking descriptor being successfully allocated, so a new one for an in-use iterator is provided.
The mappings were also leaking when the driver detects an invalid bio_vec when mapping PRPs, so fix that too.
--- drivers/nvme/host/pci.c | 25 ++++++++++++++++++++++--- 1 file changed, 22 insertions(+), 3 deletions(-)
drivers/nvme/host/pci.c +22 -3
@@ -827,6 +827,17 @@ static bool nvme_pci_prp_iter_next(struct request *req, struct device *dma_dev,return nvme_pci_prp_save_mapping (req, dma_dev, iter); } +static void nvme_unmap_iter (struct request *req,struct blk_dma_iter *iter, +struct dma_iova_state *state) +{ +struct nvme_queue *nvmeq = req->mq_hctx->driver_data; +struct device *dev = nvmeq->dev->dev; + +if (!blk_dma_unmap (req, dev, state, iter->len, + iter->p2pdma.map ==PCI_P2PDMA_MAP_BUS_ADDR )) +dma_unmap_page (dev, iter->addr, iter->len,rq_dma_dir (req)); +} +static blk_status_t nvme_pci_setup_data_prp (struct request *req,struct blk_dma_iter *iter) {
@@ -837,8 +848,10 @@ static blk_status_t nvme_pci_setup_data_prp(struct request *req,unsigned int prp_len, i;__le64 *prp_list; -if (!nvme_pci_prp_save_mapping (req, nvmeq->dev->dev, iter)) +if (!nvme_pci_prp_save_mapping (req, nvmeq->dev->dev, iter)) { +nvme_unmap_iter (req, iter, &iod->dma_state);return iter->status; + }/* * PRP1 always points to the start of the DMA transfers.
@@ -943,6 +956,7 @@ static blk_status_t nvme_pci_setup_data_prp(struct request *req,dev_err_once (nvmeq->dev->dev,"Incorrectly formed request for payload:%d nents:%d\n" ,blk_rq_payload_bytes (req),blk_rq_nr_phys_segments (req)); +nvme_unmap_data (req);return BLK_STS_IOERR ; }
@@ -986,8 +1000,11 @@ static blk_status_t nvme_pci_setup_data_sgl(struct request *req, sg_list =dma_pool_alloc (nvme_dma_pool (nvmeq, iod),GFP_ATOMIC , &sgl_dma); -if (!sg_list) +if (!sg_list) { +nvme_unmap_iter (req, iter, &iod->dma_state);return BLK_STS_RESOURCE ; + } + iod->descriptors[iod->nr_descriptors++] = sg_list; do {
@@ -1119,8 +1136,10 @@ static blk_status_t nvme_pci_setup_meta_iter(struct request *req) sg_list =dma_pool_alloc (nvmeq->descriptor_pools.small,GFP_ATOMIC , &sgl_dma); -if (!sg_list) +if (!sg_list) { +nvme_unmap_iter (req, &iter, &iod->meta_dma_state);return BLK_STS_RESOURCE ; + } iod->meta_descriptor = sg_list; iod->meta_dma = sgl_dma;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 240/621 nvme-pci: fix dma_vecs leak on p2p memory
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Keith Busch <[email protected]>
[ Upstream commit 85686c72966c5ee637893f124ddb31a1cace7bee ]
We don't unmap P2P memory, so we don't need to track it. The dma_vec allocation was getting leaked on the completion.
--- drivers/nvme/host/pci.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/nvme/host/pci.c +2 -1
@@ -795,7 +795,8 @@ static bool nvme_pci_prp_save_mapping(struct request *req, {struct nvme_iod *iod =blk_mq_rq_to_pdu (req); -if (dma_use_iova (&iod->dma_state) || !dma_need_unmap (dma_dev)) +if (dma_use_iova (&iod->dma_state) || !dma_need_unmap (dma_dev) || + (req->cmd_flags &REQ_P2PDMA ))return true;if (!iod->nr_dma_vecs) {
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 241/621 cachefiles: Fix error return when vfs_mkdir() fails
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Hongling Zeng <[email protected]>
[ Upstream commit 8a220d1c312c66194f4a33dd52d1fba42bc2b341 ]
When vfs_mkdir() fails, the error code is not extracted from the returned error pointer. This causes mkdir_error to be reached with ret=0, which leads to returning ERR_PTR(0) (NULL) instead of a proper error pointer.
Fix this by extracting the error code from the error pointer when vfs_mkdir() fails.
--- fs/cachefiles/namei.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-)
fs/cachefiles/namei.c +5 -2
@@ -129,10 +129,13 @@ struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache,if (ret <0 ) goto mkdir_error; ret =cachefiles_inject_write_error (); -if (ret ==0 ) +if (ret ==0 ) { subdir =vfs_mkdir (&nop_mnt_idmap,d_inode (dir), subdir,0700 ); -else +if (IS_ERR (subdir)) + ret =PTR_ERR (subdir); + }else { subdir =ERR_PTR (ret); + }if (IS_ERR (subdir)) {trace_cachefiles_vfs_error (NULL ,d_inode (dir), ret, cachefiles_trace_mkdir_error);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 242/621 afs: Fix the locking used by afs_get_link()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: David Howells <[email protected]>
[ Upstream commit c0410adf3da6db46f3513411fcf95e63c2f1d1ad ]
The afs filesystem in the kernel doesn't do locking correctly for symbolic links. There are a number of problems:
(1) It doesn't do any locking around afs_read_single() to prevent races
between multiple ->get_link() calls, thereby allowing the possibility
of leaks.(2) It doesn't use RCU barriering when accessing the buffer pointers during RCU pathwalk.
(3) It can race with another thread updating the contents of the symlink if a third party updated it on the server.
Fix this by the following means:
(0) Move symlink handling into its own file as this makes it more complicated.
(1) Take the validate_lock around afs_read_single() to prevent races
between multiple ->get_link() calls.
(2) Keep a separate copy of the symlink contents with an rcu_head. This is always going to be a lot smaller than a page, so it can be kmalloc'd and save quite a bit of memory. It also needs a refcount for non-RCU pathwalk.
(3) Split the symlink read and write-to-cache routines in afs from those for directories.
(4) Discard the I/O buffer as soon as the write-to-cache completes as this is a full page (plus a folio_queue).
(5) If there's no cache, discard the I/O buffer immediately after reading and copying if there is no cache.
--- fs/afs/Makefile | 1 + fs/afs/dir.c | 68 +++++------ fs/afs/fsclient.c | 4 +- fs/afs/inode.c | 96 +-------------- fs/afs/internal.h | 34 ++++-- fs/afs/symlink.c | 278 ++++++++++++++++++++++++++++++++++++++++++++ fs/afs/validation.c | 14 ++- fs/afs/yfsclient.c | 4 +- 8 files changed, 357 insertions(+), 142 deletions(-) create mode 100644 fs/afs/symlink.c
fs/afs/Makefile +1 -0
@@ -30,6 +30,7 @@ kafs-y := \ server.o \ server_list.o \ super.o \ + symlink.o \ validation.o \ vlclient.o \ vl_alias.o \
fs/afs/dir.c +34 -34
156 lines not on this page · raw message
fs/afs/fsclient.c +2 -2
@@ -889,7 +889,7 @@ void afs_fs_symlink(struct afs_operation *op) namesz = name->len; padsz = (4 - (namesz &3 )) &3 ; - c_namesz =strlen (op->create.symlink); + c_namesz =strlen (op->create.symlink->content); c_padsz = (4 - (c_namesz &3 )) &3 ; reqsz = (6 *4 ) + namesz + padsz + c_namesz + c_padsz + (6 *4 );
@@ -913,7 +913,7 @@ void afs_fs_symlink(struct afs_operation *op) bp = (void *) bp + padsz; } *bp++ =htonl (c_namesz); -memcpy (bp, op->create.symlink, c_namesz); +memcpy (bp, op->create.symlink->content, c_namesz); bp = (void *) bp + c_namesz;if (c_padsz >0 ) {memset (bp,0 , c_padsz);
fs/afs/inode.c +4 -92
120 lines not on this page · raw message
fs/afs/internal.h +26 -8
@@ -712,6 +712,7 @@ struct afs_vnode {#define AFS_VNODE_DIR_READ 11/* Set if we've read a dir's contents */ struct folio_queue *directory;/* Directory contents */ +struct afs_symlink __rcu *symlink;/* Symlink content */ struct list_head wb_keys;/* List of keys available for writeback */ struct list_head pending_locks;/* locks waiting to be granted */ struct list_head granted_locks;/* locks granted on this file */
@@ -778,6 +779,15 @@ struct afs_permits { struct afs_permit permits[] __counted_by(nr_permits); /* List of permits sorted by key pointer */ }; +/* +* Copy of symlink content for normal use. +*/ +struct afs_symlink { +struct rcu_head rcu; +refcount_t ref; +char content[]; +}; +/* * Error prioritisation and accumulation. */
@@ -889,7 +899,7 @@ struct afs_operation {struct {int reason;/* enum afs_edit_dir_reason */ mode_t mode; -const char *symlink; +struct afs_symlink *symlink; } create;struct {bool need_rehash;
@@ -1100,13 +1110,10 @@ extern const struct inode_operations afs_dir_inode_operations;extern const struct address_space_operations afs_dir_aops;extern const struct dentry_operations afs_fs_dentry_operations; -ssize_t afs_read_single (struct afs_vnode *dvnode,struct file *file); ssize_t afs_read_dir(struct afs_vnode *dvnode, struct file *file) __acquires(&dvnode->validate_lock);extern void afs_d_release (struct dentry *);extern void afs_check_for_remote_deletion (struct afs_operation *); -int afs_single_writepages (struct address_space *mapping, -struct writeback_control *wbc);/* * dir_edit.c
@@ -1256,10 +1263,6 @@ extern void afs_fs_probe_cleanup(struct afs_net *);*/ extern const struct afs_operation_ops afs_fetch_status_operation; -void afs_init_new_symlink (struct afs_vnode *vnode,struct afs_operation *op); -const char *afs_get_link (struct dentry *dentry,struct inode *inode, -struct delayed_call *callback); -int afs_readlink (struct dentry *dentry,char __user *buffer,int buflen);extern void afs_vnode_commit_status (struct afs_operation *,struct afs_vnode_param *);extern int afs_fetch_status (struct afs_vnode *,struct key *,bool ,afs_access_t *);extern int afs_ilookup5_test_by_fid (struct inode *,void *);
@@ -1610,6 +1613,21 @@ void afs_detach_volume_from_servers(struct afs_volume *volume, struct afs_serverextern int __init afs_fs_init (void );extern void afs_fs_exit (void ); +/* +* symlink.c +*/ +extern const struct inode_operations afs_symlink_inode_operations; +extern const struct address_space_operations afs_symlink_aops; + +void afs_invalidate_symlink (struct afs_vnode *vnode); +void afs_evict_symlink (struct afs_vnode *vnode); +void afs_init_new_symlink (struct afs_vnode *vnode,struct afs_operation *op); +const char *afs_get_link (struct dentry *dentry,struct inode *inode, +struct delayed_call *callback); +int afs_readlink (struct dentry *dentry,char __user *buffer,int buflen); +int afs_symlink_writepages (struct address_space *mapping, +struct writeback_control *wbc); +/* * validation.c */
fs/afs/symlink.c new file +278 -0
278 lines not on this page · raw message
fs/afs/validation.c +10 -4
@@ -465,11 +465,17 @@ int afs_validate(struct afs_vnode *vnode, struct key *key) vnode->cb_ro_snapshot = cb_ro_snapshot; vnode->cb_scrub = cb_scrub; -/* if the vnode's data version number changed then its contents are -* different */ +/* If the vnode's data version number changed then its contents are +* different. Note that afs_apply_status() doesn't set ZAP_DATA on +* directories. +*/ zap |=test_and_clear_bit (AFS_VNODE_ZAP_DATA , &vnode->flags); -if (zap) -afs_zap_data (vnode); +if (zap) { +if (S_ISREG (vnode->netfs.inode.i_mode)) +afs_zap_data (vnode); +else if (S_ISLNK (vnode->netfs.inode.i_mode)) +afs_invalidate_symlink (vnode); + }up_write (&vnode->validate_lock);_leave (" = 0" );return 0 ;
fs/afs/yfsclient.c +2 -2
@@ -960,7 +960,7 @@ void yfs_fs_symlink(struct afs_operation *op)_enter ("" ); - contents_sz =strlen (op->create.symlink); + contents_sz =strlen (op->create.symlink->content); call = afs_alloc_flat_call(op->net, &yfs_RXYFSSymlink, sizeof(__be32) + sizeof(struct yfs_xdr_RPCFlags) +
@@ -981,7 +981,7 @@ void yfs_fs_symlink(struct afs_operation *op) bp =xdr_encode_u32 (bp,0 );/* RPC flags */ bp =xdr_encode_YFSFid (bp, &dvp->fid); bp =xdr_encode_name (bp, name); - bp =xdr_encode_string (bp, op->create.symlink, contents_sz); + bp =xdr_encode_string (bp, op->create.symlink->content, contents_sz); bp =xdr_encode_YFSStoreStatus (bp, &mode, &op->mtime);yfs_check_req (call, bp);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 243/621 netfs: Fix missing barriers when accessing stream->subrequests locklessly
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: David Howells <[email protected]>
[ Upstream commit b5782e2d462c028096f922abca46318cec890670 ]
The list of subrequests attached to stream->subrequests is accessed without locks by netfs_collect_read_results() and netfs_collect_write_results(), and then they access subreq->flags without taking a barrier after getting the subreq pointer from the list. Relatedly, the functions that build the list don't use any sort of write barrier when constructing the list to make sure that the NETFS_SREQ_IN_PROGRESS flag is perceived to be set first if no lock is taken.
Fix this by:
(1) Add a new list_add_tail_release() function that uses a release barrier to set the pointer to the new member of the list.
(2) Add a new list_first_entry_or_null_acquire() function that uses an acquire barrier to read the pointer to the first member in a list (or return NULL).
(3) Use list_add_tail_release() when adding a subreq to ->subrequests.
(4) Use list_first_entry_or_null_acquire() when initially accessing the front of the list (when an item is removed, the pointer to the new front iterm is obtained under the same lock).
--- fs/netfs/buffered_read.c | 3 ++- fs/netfs/misc.c | 1 + fs/netfs/read_collect.c | 6 ++++-- fs/netfs/write_collect.c | 6 ++++-- fs/netfs/write_issue.c | 3 ++- include/linux/list.h | 37 +++++++++++++++++++++++++++++++++++++ 6 files changed, 50 insertions(+), 6 deletions(-)
fs/netfs/buffered_read.c +2 -1
@@ -170,7 +170,8 @@ void netfs_queue_read(struct netfs_io_request *rreq,* remove entries off of the front. */ spin_lock (&rreq->lock); -list_add_tail (&subreq->rreq_link, &stream->subrequests); +/* Write IN_PROGRESS before pointer to new subreq */ +list_add_tail_release (&subreq->rreq_link, &stream->subrequests);if (list_is_first (&subreq->rreq_link, &stream->subrequests)) {if (!stream->active) { stream->collected_to = subreq->start;
fs/netfs/misc.c +1 -0
@@ -361,6 +361,7 @@ void netfs_wait_for_in_progress_stream(struct netfs_io_request *rreq,DEFINE_WAIT (myself);list_for_each_entry (subreq, &stream->subrequests, rreq_link) { +smp_rmb ();/* Read ->next before IN_PROGRESS. */ if (!netfs_check_subreq_in_progress (subreq))continue ;
fs/netfs/read_collect.c +4 -2
@@ -221,8 +221,10 @@ static void netfs_collect_read_results(struct netfs_io_request *rreq)* in progress. The issuer thread may be adding stuff to the tail * whilst we're doing this. */ - front =list_first_entry_or_null (&stream->subrequests, - struct netfs_io_subrequest, rreq_link); + front =list_first_entry_or_null_acquire (&stream->subrequests, + struct netfs_io_subrequest, rreq_link); +/* Read first subreq pointer before IN_PROGRESS flag. */ +while (front) {size_t transferred;
fs/netfs/write_collect.c +4 -2
@@ -228,8 +228,10 @@ static void netfs_collect_write_results(struct netfs_io_request *wreq)if (!smp_load_acquire (&stream->active))continue ; - front =list_first_entry_or_null (&stream->subrequests, - struct netfs_io_subrequest, rreq_link); + front =list_first_entry_or_null_acquire (&stream->subrequests, + struct netfs_io_subrequest, rreq_link); +/* Read first subreq pointer before IN_PROGRESS flag. */ +while (front) {trace_netfs_collect_sreq (wreq, front);//_debug("sreq [%x] %llx %zx/%zx",
fs/netfs/write_issue.c +2 -1
@@ -206,7 +206,8 @@ void netfs_prepare_write(struct netfs_io_request *wreq,* remove entries off of the front. */ spin_lock (&wreq->lock); -list_add_tail (&subreq->rreq_link, &stream->subrequests); +/* Write IN_PROGRESS before pointer to new subreq */ +list_add_tail_release (&subreq->rreq_link, &stream->subrequests);if (list_is_first (&subreq->rreq_link, &stream->subrequests)) {if (!stream->active) { stream->collected_to = subreq->start;
include/linux/list.h +37 -0
@@ -198,6 +198,29 @@ static inline void list_add_tail(struct list_head *new, struct list_head *head)__list_add (new, head->prev, head); } +/** +* list_add_tail_release - add a new entry with release barrier +* @new: new entry to be added +* @head: list head to add it before +* +* Insert a new entry before the specified head, using a release barrier to set +* the ->next pointer that points to it. This is useful for implementing +* queues, in particular one that the elements will be walked through forwards +* locklessly. +*/ +static inline void list_add_tail_release (struct list_head *new, +struct list_head *head) +{ +struct list_head *prev = head->prev; + +if (__list_add_valid (new, prev, head)) { + new->next = head; + new->prev = prev; + head->prev = new; +smp_store_release (&prev->next, new); + } +} +/* * Delete a list entry by making the prev/next entries * point to each other.
@@ -651,6 +674,20 @@ static inline void list_splice_tail_init(struct list_head *list, pos__ != head__ ?list_entry (pos__, type, member) :NULL ; \ }) +/** +* list_first_entry_or_null_acquire - get the first element from a list with barrier +* @ptr: the list head to take the element from. +* @type: the type of the struct this is embedded in. +* @member: the name of the list_head within the struct. +* +* Note that if the list is empty, it returns NULL. +*/ +#define list_first_entry_or_null_acquire (ptr, type, member) ({ \ + struct list_head *head__ = (ptr); \ + struct list_head *pos__ = smp_load_acquire(&head__->next); \ + pos__ != head__ ? list_entry(pos__, type, member) : NULL; \ +}) +/** * list_last_entry_or_null - get the last element from a list * @ptr: the list head to take the element from.
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 244/621 netfilter: x_tables: allow initial table replace without emitting audit log message
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Florian Westphal <[email protected]>
[ Upstream commit 8e72510db9fa2d41f2b06d5c01fe9020e076fee4 ]
At the moment we emit the audit log a bit too early, which makes it necessary to also emit an unregister log in case we have to unwind errors after possible hook register failure.
Followup patch will be slightly simpler if we can delay the register message until after the hooks have been wired up.
Stable-dep-of: b62eb8dcf2c4 ("netfilter: x_tables: allocate hook ops while under mutex")
--- net/netfilter/x_tables.c | 29 ++++++++++++++++++++--------- 1 file changed, 20 insertions(+), 9 deletions(-)
net/netfilter/x_tables.c +20 -9
@@ -1408,11 +1408,9 @@ struct xt_counters *xt_counters_alloc(unsigned int counters) }EXPORT_SYMBOL (xt_counters_alloc); -struct xt_table_info * -xt_replace_table (struct xt_table *table, -unsigned int num_counters, -struct xt_table_info *newinfo, -int *error) +static struct xt_table_info * +do_replace_table (struct xt_table *table,unsigned int num_counters, +struct xt_table_info *newinfo,int *error) {struct xt_table_info *private;unsigned int cpu;
@@ -1467,10 +1465,23 @@ xt_replace_table(struct xt_table *table, } } -audit_log_nfcfg (table->name, table->af, private->number, - !private->number ?AUDIT_XT_OP_REGISTER : -AUDIT_XT_OP_REPLACE , -GFP_KERNEL ); +return private; +} + +struct xt_table_info * +xt_replace_table (struct xt_table *table,unsigned int num_counters, +struct xt_table_info *newinfo, +int *error) +{ +struct xt_table_info *private; + + private =do_replace_table (table, num_counters, newinfo, error); +if (private) +audit_log_nfcfg (table->name, table->af, private->number, + !private->number ?AUDIT_XT_OP_REGISTER : +AUDIT_XT_OP_REPLACE , +GFP_KERNEL ); +return private; }EXPORT_SYMBOL_GPL (xt_replace_table);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 245/621 netfilter: x_tables: allocate hook ops while under mutex
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Florian Westphal <[email protected]>
[ Upstream commit b62eb8dcf2c47d4d676a434efbd57c4f776f7829 ]
arp/ip(6)t_register_table() add the table to the per-netns list via xt_register_table() before allocating the per-netns hook ops copy via kmemdup_array(). This leaves a window where the table is visible in the list with ops=NULL.
If the pernet exit happens runs concurrently the pre_exit callback finds the table via xt_find_table() and passes the NULL ops pointer to nf_unregister_net_hooks(), causing a NULL dereference:
general protection fault in nf_unregister_net_hooks+0xbc/0x150
RIP: nf_unregister_net_hooks (net/netfilter/core.c:613)
Call Trace:
ipt_unregister_table_pre_exit
iptable_mangle_net_pre_exit
ops_pre_exit_list
cleanup_netFix by moving the ops allocation into the xtables core so the table is never in the list without valid ops. Also ensure the table is no longer processing packets before its torn down on error unwind. nf_register_net_hooks might have published at least one hook; call synchronize_rcu() if there was an error.
audit log register message gets deferred until all operations have passed, this avoids need to emit another ureg message in case of error unwinding.
Based on earlier patch by Tristan Madani.
--- include/linux/netfilter/x_tables.h | 1 + net/ipv4/netfilter/arp_tables.c | 35 +++------------------ net/ipv4/netfilter/ip_tables.c | 41 +++--------------------- net/ipv6/netfilter/ip6_tables.c | 38 +++-------------------- net/netfilter/x_tables.c | 50 +++++++++++++++++++++++++----- 5 files changed, 55 insertions(+), 110 deletions(-)
include/linux/netfilter/x_tables.h +1 -0
@@ -297,6 +297,7 @@ struct xt_counters *xt_counters_alloc(unsigned int counters);struct xt_table *xt_register_table (struct net *net,const struct xt_table *table, +const struct nf_hook_ops *template_ops,struct xt_table_info *bootstrap,struct xt_table_info *newinfo);void xt_unregister_table_pre_exit (struct net *net,u8 af,const char *name);
net/ipv4/netfilter/arp_tables.c +4 -31
@@ -1518,13 +1518,11 @@ int arpt_register_table(struct net *net,const struct arpt_replace *repl, const struct nf_hook_ops *template_ops) { - struct nf_hook_ops *ops; -unsigned int num_ops; -int ret, i; -struct xt_table_info *newinfo; struct xt_table_info bootstrap = {0}; -void *loc_cpu_entry; +struct xt_table_info *newinfo;struct xt_table *new_table; +void *loc_cpu_entry; +int ret; newinfo =xt_alloc_table_info (repl->size);if (!newinfo)
@@ -1539,7 +1537,7 @@ int arpt_register_table(struct net *net,return ret; } - new_table =xt_register_table (net, table, &bootstrap, newinfo); + new_table =xt_register_table (net, table, template_ops, &bootstrap, newinfo);if (IS_ERR (new_table)) {struct arpt_entry *iter;
@@ -1549,31 +1547,6 @@ int arpt_register_table(struct net *net,return PTR_ERR (new_table); } - num_ops =hweight32 (table->valid_hooks); -if (num_ops ==0 ) { - ret = -EINVAL ; - goto out_free; - } - - ops =kmemdup_array (template_ops, num_ops,sizeof (*ops),GFP_KERNEL ); -if (!ops) { - ret = -ENOMEM ; - goto out_free; - } - -for (i =0 ; i < num_ops; i++) - ops[i].priv = new_table; - - new_table->ops = ops; - - ret =nf_register_net_hooks (net, ops, num_ops); -if (ret !=0 ) - goto out_free; - -return ret; - -out_free: -__arpt_unregister_table (net, new_table);return ret; }
net/ipv4/netfilter/ip_tables.c +4 -37
61 lines not on this page · raw message
net/ipv6/netfilter/ip6_tables.c +4 -34
@@ -1734,13 +1734,11 @@ int ip6t_register_table(struct net *net, const struct xt_table *table,const struct ip6t_replace *repl, const struct nf_hook_ops *template_ops) { - struct nf_hook_ops *ops; -unsigned int num_ops; -int ret, i; -struct xt_table_info *newinfo; struct xt_table_info bootstrap = {0}; -void *loc_cpu_entry; +struct xt_table_info *newinfo;struct xt_table *new_table; +void *loc_cpu_entry; +int ret; newinfo =xt_alloc_table_info (repl->size);if (!newinfo)
@@ -1755,7 +1753,7 @@ int ip6t_register_table(struct net *net, const struct xt_table *table,return ret; } - new_table =xt_register_table (net, table, &bootstrap, newinfo); + new_table =xt_register_table (net, table, template_ops, &bootstrap, newinfo);if (IS_ERR (new_table)) {struct ip6t_entry *iter;
@@ -1765,34 +1763,6 @@ int ip6t_register_table(struct net *net, const struct xt_table *table,return PTR_ERR (new_table); } -if (!template_ops) -return 0 ; - - num_ops =hweight32 (table->valid_hooks); -if (num_ops ==0 ) { - ret = -EINVAL ; - goto out_free; - } - - ops =kmemdup_array (template_ops, num_ops,sizeof (*ops),GFP_KERNEL ); -if (!ops) { - ret = -ENOMEM ; - goto out_free; - } - -for (i =0 ; i < num_ops; i++) - ops[i].priv = new_table; - - new_table->ops = ops; - - ret =nf_register_net_hooks (net, ops, num_ops); -if (ret !=0 ) - goto out_free; - -return ret; - -out_free: -__ip6t_unregister_table (net, new_table);return ret; }
net/netfilter/x_tables.c +42 -8
90 lines not on this page · raw message
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 246/621 wifi: mac80211: fix missing RX bitrate update for mesh forwarding path
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Sarika Sharma <[email protected]>
[ Upstream commit cc18fffa3a51792637169872886df3407bd5bb84 ]
Currently, RX bitrate statistics are not updated for packets received on the mesh forwarding path during fast RX processing. This results in incomplete RX rate tracking in station dump outputs for mesh scenarios.
Update ieee80211_invoke_fast_rx() to record the RX rate using sta_stats_encode_rate() and store it in the last_rate field of ieee80211_sta_rx_stats when RX_QUEUED is returned from ieee80211_rx_mesh_data(). This ensures that RX bitrate is properly accounted for in both RSS and non-RSS paths.
Stable-dep-of: d71c841be5d9 ("wifi: mac80211: capture fast-RX rate before mesh reuses skb->cb")
--- net/mac80211/rx.c | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-)
net/mac80211/rx.c +7 -5
@@ -4918,6 +4918,11 @@ static bool ieee80211_invoke_fast_rx(struct ieee80211_rx_data *rx,/* after this point, don't punt to the slowpath! */ +if (fast_rx->uses_rss) + stats =this_cpu_ptr (rx->link_sta->pcpu_rx_stats); +else + stats = &rx->link_sta->rx_stats; +if (rx->key && !(status->flag &RX_FLAG_MIC_STRIPPED ) &&pskb_trim (skb, skb->len - fast_rx->icv_len)) goto drop;
@@ -4952,6 +4957,8 @@ static bool ieee80211_invoke_fast_rx(struct ieee80211_rx_data *rx, res =ieee80211_rx_mesh_data (rx->sdata, rx->sta, rx->skb);switch (res) {case RX_QUEUED : + stats->last_rx = jiffies; + stats->last_rate =sta_stats_encode_rate (status);return true;case RX_CONTINUE :break ;
@@ -4965,11 +4972,6 @@ static bool ieee80211_invoke_fast_rx(struct ieee80211_rx_data *rx, drop:dev_kfree_skb (skb); -if (fast_rx->uses_rss) - stats =this_cpu_ptr (rx->link_sta->pcpu_rx_stats); -else - stats = &rx->link_sta->rx_stats; - stats->dropped++;return true; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 247/621 wifi: mac80211: capture fast-RX rate before mesh reuses skb->cb
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Zhao Li <[email protected]>
[ Upstream commit d71c841be5d9e586ee7f36c0dc8ed4db0d9a1349 ]
ieee80211_invoke_fast_rx() reads RX status through IEEE80211_SKB_RXCB(skb), which aliases the same skb->cb storage that ieee80211_rx_mesh_data() reuses as IEEE80211_TX_INFO. In the unicast forward path, mesh_data does:
info = IEEE80211_SKB_CB(fwd_skb); memset(info, 0, sizeof(*info));
on the same skb the caller still names via rx->skb, then either queues the skb for TX (success) or kfree_skb()'s it (no-route) before returning RX_QUEUED. The caller's RX_QUEUED arm then calls sta_stats_encode_rate(status) on memory that is either zeroed (success path) or freed (no-route path). The latter is KASAN slab-use-after-free in ieee80211_prepare_and_rx_handle.
Fix by encoding the rate from status before invoking ieee80211_rx_mesh_data(), so the RX_QUEUED arm consumes a value captured while status was still backed by valid memory.
--- net/mac80211/rx.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)
net/mac80211/rx.c +5 -1
@@ -4847,6 +4847,7 @@ static bool ieee80211_invoke_fast_rx(struct ieee80211_rx_data *rx,u8 sa[ETH_ALEN ]; } addrs__aligned(2) ;struct ieee80211_sta_rx_stats *stats; +u32 encoded_rate;/* for parallel-rx, we need to have DUP_VALIDATED, otherwise we write * to a common data structure; drivers can implement that per queue
@@ -4954,11 +4955,14 @@ static bool ieee80211_invoke_fast_rx(struct ieee80211_rx_data *rx,/* push the addresses in front */ memcpy (skb_push (skb,sizeof (addrs)), &addrs,sizeof (addrs)); +/* capture before mesh forward may memset or free skb->cb */ + encoded_rate =sta_stats_encode_rate (status); + res =ieee80211_rx_mesh_data (rx->sdata, rx->sta, rx->skb);switch (res) {case RX_QUEUED : stats->last_rx = jiffies; - stats->last_rate =sta_stats_encode_rate (status); + stats->last_rate = encoded_rate;return true;case RX_CONTINUE :break ;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 248/621 net: hsr: defer node table free until after RCU readers
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Michael Bommarito <[email protected]>
[ Upstream commit aaec7096f9961eb223b5b149abe9495525c205d9 ]
HSR node-list and node-status generic-netlink operations run under rcu_read_lock(). They walk hsr->node_db through hsr_get_next_node() and hsr_get_node_data(), but RTM_DELLINK teardown removes the same node table with plain list_del() and frees each node immediately.
That lets a generic-netlink reader hold a struct hsr_node pointer across hsr_dellink(). In a KASAN build, widening the reader window after hsr_get_next_node() obtains the node reproduces a slab-use-after-free when the reader copies node->macaddress_A; the freeing stack is hsr_del_nodes() from hsr_dellink().
Use list_del_rcu() and defer the free through the existing hsr_free_node_rcu() callback. This matches the lifetime rule used by the HSR prune paths, which already delete nodes with list_del_rcu() and call_rcu().
--- net/hsr/hsr_framereg.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
net/hsr/hsr_framereg.c +4 -2
@@ -129,8 +129,10 @@ void hsr_del_nodes(struct list_head *node_db)struct hsr_node *node;struct hsr_node *tmp; -list_for_each_entry_safe (node, tmp, node_db, mac_list) -kfree (node); +list_for_each_entry_safe (node, tmp, node_db, mac_list) { +list_del_rcu (&node->mac_list); +kfree_rcu (node, rcu_head); + } } void prp_handle_san_frame(bool san, enum hsr_port_type port,
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 249/621 erofs: fix metabuf leak in inode xattr initialization
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Jia Zhu <[email protected]>
[ Upstream commit 79b09c54c6563df9846ca3094bcfd72082c3e1d7 ]
commit bb88e8da0025 ("erofs: use meta buffers for xattr operations") converted xattr operations to use on-stack erofs_buf instances. erofs_init_inode_xattrs() uses such a metabuf while reading the inline xattr header and shared xattr id array.
Some error paths after erofs_read_metabuf() leave through out_unlock without dropping the metabuf, so the folio reference can leak.
Consolidate the cleanup at out_unlock. erofs_put_metabuf() is a no-op if no folio has been acquired, and this keeps all paths after taking EROFS_I_BL_XATTR_BIT covered by a single cleanup site.
--- fs/erofs/xattr.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
fs/erofs/xattr.c +3 -3
@@ -34,6 +34,8 @@ static int erofs_init_inode_xattrs(struct inode *inode)struct super_block *sb = inode->i_sb;int ret =0 ; + it.buf = __EROFS_BUF_INITIALIZER; +/* the most case is that xattrs of this inode are initialized. */ if (test_bit (EROFS_I_EA_INITED_BIT , &vi->flags)) {/*
@@ -76,7 +78,6 @@ static int erofs_init_inode_xattrs(struct inode *inode) goto out_unlock; } - it.buf = __EROFS_BUF_INITIALIZER; ret =erofs_init_metabuf (&it.buf, sb,erofs_inode_in_metabox (inode));if (ret) goto out_unlock;
@@ -95,7 +96,6 @@ static int erofs_init_inode_xattrs(struct inode *inode) vi->xattr_shared_xattrs =kmalloc_array (vi->xattr_shared_count,sizeof (uint),GFP_KERNEL );if (!vi->xattr_shared_xattrs) { -erofs_put_metabuf (&it.buf); ret = -ENOMEM ; goto out_unlock; }
@@ -114,13 +114,13 @@ static int erofs_init_inode_xattrs(struct inode *inode) vi->xattr_shared_xattrs[i] =le32_to_cpu (*(__le32 *)it.kaddr); it.pos +=sizeof (__le32); } -erofs_put_metabuf (&it.buf);/* paired with smp_mb() at the beginning of the function. */ smp_mb ();set_bit (EROFS_I_EA_INITED_BIT , &vi->flags); out_unlock: +erofs_put_metabuf (&it.buf);clear_and_wake_up_bit (EROFS_I_BL_XATTR_BIT , &vi->flags);return ret; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 250/621 drm/msm/adreno: Fix a reference leak in a6xx_gpu_init()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Felix Gu <[email protected]>
[ Upstream commit e64bca63647db1d5518198d6c5ca2dbcc66b182b ]
In a6xx_gpu_init(), node is obtained via of_parse_phandle(). While there was a manual of_node_put() at the end of the common path, several early error returns would bypass this call, resulting in a reference leak.
Fix this by using the __free(device_node) cleanup handler to release the reference when the variable goes out of scope.
Patchwork: https://patchwork.freedesktop.org/patch/700661/
Message-ID: <[email protected]>
--- drivers/gpu/drm/msm/adreno/a6xx_gpu.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-)
drivers/gpu/drm/msm/adreno/a6xx_gpu.c +2 -3
@@ -2633,7 +2633,6 @@ struct msm_gpu *a6xx_gpu_init(struct drm_device *dev)struct msm_drm_private *priv = dev->dev_private;struct platform_device *pdev = priv->gpu_pdev;struct adreno_platform_config *config = pdev->dev.platform_data; -struct device_node *node;struct a6xx_gpu *a6xx_gpu;struct adreno_gpu *adreno_gpu;struct msm_gpu *gpu;
@@ -2653,7 +2652,8 @@ struct msm_gpu *a6xx_gpu_init(struct drm_device *dev) adreno_gpu->registers =NULL ;/* Check if there is a GMU phandle and set it up */ - node =of_parse_phandle (pdev->dev.of_node,"qcom,gmu" ,0 ); + struct device_node *node __free(device_node) = +of_parse_phandle (pdev->dev.of_node,"qcom,gmu" ,0 );/* FIXME: How do we gracefully handle this? */ BUG_ON (!node);
@@ -2701,7 +2701,6 @@ struct msm_gpu *a6xx_gpu_init(struct drm_device *dev) ret =a6xx_gmu_wrapper_init (a6xx_gpu, node); else ret =a6xx_gmu_init (a6xx_gpu, node); -of_node_put (node);if (ret) {a6xx_destroy (&(a6xx_gpu->base.base));return ERR_PTR (ret);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 251/621 netfs: Fix zeropoint update where i_size > remote_i_size
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: David Howells <[email protected]>
[ Upstream commit 4543a4d737944134a1394afe797622546fbcc98a ]
Fix the update of the zero point[*] by netfs_release_folio() when there is uncommitted data in the pagecache beyond the folio being released but the on-server EOF is in this folio (ie. i_size > remote_i_size). The update needs to limit zero_point to remote_i_size, not i_size as i_size is a local phenomenon reflecting updates made locally to the pagecache, not stuff written to the server. remote_i_size tracks the server's i_size.
[*] The zero point is the file position from which we can assume that the
server will just return zeros, so we can avoid generating reads.
Note that netfs_invalidate_folio() probably doesn't need fixing as zero_point should be updated by setattr after truncation or fallocate.
Found with:
fsx -q -N 1000000 -p 10000 -o 128000 -l 600000 \
/xfstest.test/junk --replay-ops=junk.fsxopsusing the following as junk.fsxops:
truncate 0x0 0x1bbae 0x82864
write 0x3ef2e 0xf9c8 0x1bbae
write 0x67e05 0xcb5a 0x4e8f6
mapread 0x57781 0x85b6 0x7495f
copy_range 0x5d3d 0x10329 0x54fac 0x7495f
write 0x64710 0x1c2b 0x7495f
mapread 0x64000 0x1000 0x7495fon cifs with the default cache option.
It shows read-gaps on folio 0x64 failing with a short read (ie. it hits EOF) if the FMODE_READ check is commented out in netfs_perform_write():
if (//(file->f_mode & FMODE_READ) ||
netfs_is_cache_enabled(ctx)) {and no fscache. This was initially found with the generic/522 xfstest.
--- fs/netfs/misc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/netfs/misc.c +1 -1
@@ -303,7 +303,7 @@ bool netfs_release_folio(struct folio *folio, gfp_t gfp)if (folio_test_dirty (folio))return false; - end =umin (folio_pos (folio) +folio_size (folio),i_size_read (&ctx->inode)); + end =umin (folio_pos (folio) +folio_size (folio), ctx->remote_i_size);if (end > ctx->zero_point) ctx->zero_point = end;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 252/621 KVM: guest_memfd: Treat memslot binding offset+size as unsigned values
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Sean Christopherson <[email protected]>
[ Upstream commit eba85fee7fc6cf28fec38a5bf3c378bef9a79ca6 ]
When binding a memslot to a guest_memfd file, treat the offset and size as unsigned values to fix a bug where the sum of the two can result in a false negative when checking for overflow against the size of the file. Passing unsigned values also avoids relying on somewhat obscure checks in other flows for safety, and tracks the offset and size as they are intended to be tracked, as unsigned values.
On 64-bit kernels, the number of pages a memslot contains and thus the size (and offset) of its guest_memfd binding are unsigned 64-bit values. Taking the offset+size as an loff_t instead of a uoff_t inadvertently converts the unsigned value to a signed value if the offset and/or size is massive.
Locally storing the offset and size as signed values is benign in and of itself (though even that is *extremely* difficult to discern), but operating on their sum is not.
For the offset, KVM explicitly checks against a negative value, which might seem like a bug as KVM could incorrectly reject a legitimate binding, but that's not actually the case as KVM_CREATE_GUEST_MEMFD takes a signed value for its size, i.e. a would-be-negative offset is also greater than the maximum possible size of any guest_memfd file.
Regarding the size, while KVM lacks an explicit check for a negative value, i.e. seemingly has a flawed overflow check, KVM restricts the number of pages in a single memslot to the largest positive signed 32-bit value:
if (id < KVM_USER_MEM_SLOTS &&
(mem->memory_size >> PAGE_SHIFT) > KVM_MEM_MAX_NR_PAGES)
return -EINVAL;and so that maximum "size" will ever be is 0x7fffffff000.
The sum of the two is, however, problematic. While the size is restricted by KVM's memslot logic, the offset is not, i.e. the offset is completely unchecked until the "offset + size > i_size_read(inode)" check. If the offset is the (nearly) largest possible _positive_ value, then adding size to the offset can result in a signed, negative 64-bit value. When compared against the size of the file (guaranteed to be positive), the negative sum is always smaller, and KVM incorrectly allows the absurd offset.
Opportunistically add missing includes in kvm_mm.h (instead of relying on its parents).
--- virt/kvm/guest_memfd.c | 8 ++++---- virt/kvm/kvm_mm.h | 7 +++++-- 2 files changed, 9 insertions(+), 6 deletions(-)
virt/kvm/guest_memfd.c +4 -4
@@ -560,15 +560,16 @@ int kvm_gmem_create(struct kvm *kvm, struct kvm_create_guest_memfd *args) }int kvm_gmem_bind (struct kvm *kvm,struct kvm_memory_slot *slot, -unsigned int fd,loff_t offset) +unsigned int fd,u64 offset) { -loff_t size = slot->npages <<PAGE_SHIFT ; +u64 size = slot->npages <<PAGE_SHIFT ;unsigned long start, end;struct kvm_gmem *gmem;struct inode *inode;struct file *file;int r = -EINVAL ; +BUILD_BUG_ON (sizeof (gpa_t) !=sizeof (offset));BUILD_BUG_ON (sizeof (gfn_t) !=sizeof (slot->gmem.pgoff)); file =fget (fd);
@@ -584,8 +585,7 @@ int kvm_gmem_bind(struct kvm *kvm, struct kvm_memory_slot *slot, inode =file_inode (file); -if (offset <0 || !PAGE_ALIGNED (offset) || - offset + size >i_size_read (inode)) +if (!PAGE_ALIGNED (offset) || offset + size >i_size_read (inode)) goto err;filemap_invalidate_lock (inode->i_mapping);
virt/kvm/kvm_mm.h +5 -2
@@ -3,6 +3,9 @@#ifndef __KVM_MM_H__#define __KVM_MM_H__ 1 +#include <linux/kvm.h> +#include <linux/kvm_types.h> +/* * Architectures can choose whether to use an rwlock or spinlock * for the mmu_lock. These macros, for use in common code
@@ -71,7 +74,7 @@ static inline void gfn_to_pfn_cache_invalidate_start(struct kvm *kvm,void kvm_gmem_init (struct module *module);int kvm_gmem_create (struct kvm *kvm,struct kvm_create_guest_memfd *args);int kvm_gmem_bind (struct kvm *kvm,struct kvm_memory_slot *slot, -unsigned int fd,loff_t offset); +unsigned int fd,u64 offset);void kvm_gmem_unbind (struct kvm_memory_slot *slot);#else static inline void kvm_gmem_init (struct module *module)
@@ -81,7 +84,7 @@ static inline void kvm_gmem_init(struct module *module)static inline int kvm_gmem_bind (struct kvm *kvm,struct kvm_memory_slot *slot, -unsigned int fd,loff_t offset) +unsigned int fd,u64 offset) {WARN_ON_ONCE (1 );return -EIO ;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 253/621 wifi: mt76: mt7921/mt7925: fix NULL dereference in CSA beacon
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Arjan van de Ven <[email protected]>
[ Upstream commit 351dd7d2c80d23e56dcce6faa4e62bea5b0877c7 ]
This patch is based on a BUG as reported by Bongani Hlope at
https://lore.kernel.org/all/[email protected]/
When a channel-switch announcement (CSA) beacon is received, cfg80211 queues a wiphy work item that eventually calls mt7921_channel_switch_rx_beacon(). If the station disconnects (or the channel context is otherwise torn down) between the time the work is queued and the time it runs, the driver's dev->new_ctx pointer can already have been cleared to NULL. mt7921_channel_switch_rx_beacon() then dereferences new_ctx unconditionally, triggering a NULL pointer dereference at address 0x0:
BUG: kernel NULL pointer dereference, address: 0000000000000000 RIP: 0010:mt7921_channel_switch_rx_beacon+0x1f/0x100 [mt7921_common]
The same missing guard exists in mt7925_channel_switch_rx_beacon(), which shares the same code pattern introduced by the same commit.
Add an early-return NULL check for dev->new_ctx in both mt7921_channel_switch_rx_beacon() and mt7925_channel_switch_rx_beacon(). When new_ctx is NULL there is no pending channel switch to process, so returning immediately is the correct and safe action.
Oops-Analysis: http://oops.fenrus.org/reports/lkml/[email protected]/report.html
--- drivers/net/wireless/mediatek/mt76/mt7921/main.c | 3 +++ 1 file changed, 3 insertions(+)
drivers/net/wireless/mediatek/mt76/mt7921/main.c +3 -0
@@ -1508,6 +1508,9 @@ static void mt7921_channel_switch_rx_beacon(struct ieee80211_hw *hw,struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;u16 beacon_interval = vif->bss_conf.beacon_int; +if (!dev->new_ctx) +return ; +if (cfg80211_chandef_identical (&chsw->chandef, &dev->new_ctx->def) && chsw->count) {
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 254/621 smb/client: fix chown/chgrp with SMB3 POSIX Extensions
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Ralph Boehme <[email protected]>
[ Upstream commit 760ef2c579c2609cf17fb1cd5392f64d42d43d33 ]
Ownership (chown) and group (chgrp) modifications were being ignored when mounting with SMB3 POSIX Extensions unless CIFS_MOUNT_CIFS_ACL or CIFS_MOUNT_MODE_FROM_SID were also explicitly set.
Fix this by checking for posix_extensions in cifs_setattr_nounix() when updating UID and GID, ensuring that id_mode_to_cifs_acl() is called to map and set the ownership/group information on the server.
--- fs/smb/client/inode.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
fs/smb/client/inode.c +2 -1
@@ -3382,7 +3382,8 @@ cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs) gid = attrs->ia_gid;if ((cifs_sb_flags (cifs_sb) &CIFS_MOUNT_CIFS_ACL ) || - (cifs_sb_flags (cifs_sb) &CIFS_MOUNT_MODE_FROM_SID )) { + (cifs_sb_flags (cifs_sb) &CIFS_MOUNT_MODE_FROM_SID ) || + posix) {if (uid_valid (uid) ||gid_valid (gid)) { mode =NO_CHANGE_64 ; rc = id_mode_to_cifs_acl(inode, full_path, &mode,
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 255/621 ksmbd: prevent path traversal bypass by restricting caseless retry
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Namjae Jeon <[email protected]>
[ Upstream commit 54bab9ba5a9f156ffa9324fcbe5a356fd0242f95 ]
ksmbd_vfs_path_lookup() enforces LOOKUP_BENEATH to restrict path resolution within the share root. When a crafted path attempts to escape the share boundary using parent-directory components ('..'), vfs_path_parent_lookup() detects this and immediately fails, returning -EXDEV.
However, a bug exists in __ksmbd_vfs_kern_path() under caseless mode. The function fails to intercept the -EXDEV error and erroneously falls through to the caseless retry logic, which is intended only for genuinely missing files. During this retry process, the path is reconstructed, leading to an unintended LOOKUP_BENEATH bypass that allows write-capable users to create zero-length files or directories outside the exported share.
Fix this by ensuring that the execution only proceeds to the caseless lookup retry when the error is specifically -ENOENT. Any other errors, such as -EXDEV from a path traversal attempt, must be returned immediately.
--- fs/smb/server/vfs.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/smb/server/vfs.c +1 -1
@@ -1238,7 +1238,7 @@ int __ksmbd_vfs_kern_path(struct ksmbd_work *work, char *filepath, retry: err =ksmbd_vfs_path_lookup (share_conf, filepath, flags, path, do_lock); -if (!err || !caseless) +if (!err || err != -ENOENT || !caseless)return err; path_len =strlen (filepath);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 256/621 drm/amdgpu: Fix kernel panic during driver load failure
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Harish Kasiviswanathan <[email protected]>
[ Upstream commit a279bd143b3c184358b658e43a057e31ee8c4de5 ]
Avoid kernel panic if MES init fails during driver load. The KIQ ring is falsely marked as ready as ASICs that use MES, KIQ is owned by MES.
BUG: kernel NULL pointer dereference, address: 0000000000000000 RIP: 0010:gfx_v12_1_wait_reg_mem+0x5a/0x1f0 [amdgpu] Call Trace: gfx_v12_1_ring_emit_reg_write_reg_wait+0x1f/0x30 [amdgpu] amdgpu_gmc_fw_reg_write_reg_wait+0xb2/0x190 [amdgpu] amdgpu_gmc_flush_gpu_tlb+0x1cc/0x230 [amdgpu] amdgpu_gart_invalidate_tlb+0x81/0xa0 [amdgpu] amdgpu_gart_unbind+0x72/0x90 [amdgpu] amdgpu_ttm_backend_unbind+0xa4/0xb0 [amdgpu] amdgpu_ttm_tt_unpopulate+0x13/0xd0 [amdgpu] amdttm_tt_unpopulate+0x29/0x70 [amdttm] ttm_bo_put+0x1eb/0x360 [amdttm] amdgpu_bo_free_kernel+0xf9/0x1f0 [amdgpu] amdgpu_ih_ring_fini+0x5a/0x90 [amdgpu] amdgpu_irq_fini_hw+0x58/0x80 [amdgpu] amdgpu_device_fini_hw+0x4e0/0x5b0 [amdgpu] amdgpu_driver_load_kms+0x60/0xa0 [amdgpu] amdgpu_pci_probe+0x28e/0x6d0 [amdgpu] pci_device_probe+0x19f/0x220 really_probe+0x1ed/0x340 driver_probe_device+0x1e/0x80 __driver_attach+0xd3/0x1a0 bus_for_each_dev+0x68/0xa0 bus_add_driver+0x19f/0x270 driver_register+0x5d/0xf0 do_one_initcall+0xac/0x200 do_init_module+0x1ec/0x280 __se_sys_finit_module+0x2de/0x310 do_syscall_64+0x6a/0x250 entry_SYSCALL_64_after_hwframe+0x4b/0x53
--- drivers/gpu/drm/amd/amdgpu/gfx_v12_0.c | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-)
drivers/gpu/drm/amd/amdgpu/gfx_v12_0.c +11 -2
@@ -3473,10 +3473,19 @@ static int gfx_v12_0_cp_resume(struct amdgpu_device *adev)gfx_v12_0_cp_gfx_enable (adev, true); } -if (adev->enable_mes_kiq && adev->mes.kiq_hw_init) +if (adev->enable_mes_kiq && adev->mes.kiq_hw_init) { r =amdgpu_mes_kiq_hw_init (adev); -else +/* +* With MES, GFX KIQ ring is owned by the MES and is never +* initialized/used directly by the driver, so it must +* not be left flagged as ready. mes_v12_0_hw_init() clears +* but clear here if MES init fails +*/ +if (r) + adev->gfx.kiq[0 ].ring.sched.ready = false; + }else { r =gfx_v12_0_kiq_resume (adev); + }if (r)return r;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 257/621 drm/i915/gt: Fix NULL deref on sched_engine alloc failure
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Joonas Lahtinen <[email protected]>
[ Upstream commit 82ec992c404c3dc774c5e9f3d4aa858e97187675 ]
Avoid using intel_context_put() before intel_context_init() in execlists_create_virtual() as the kref_put() inside would lead to NULL deref on the IOCTL path when sched_engine allocation fails.
Discovered using AI-assisted static analysis confirmed by Intel Product Security.
--- .../drm/i915/gt/intel_execlists_submission.c | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-)
drivers/gpu/drm/i915/gt/intel_execlists_submission.c +10 -9
@@ -3930,11 +3930,11 @@ execlists_create_virtual(struct intel_engine_cs **siblings, unsigned int count,struct drm_i915_private *i915 = siblings[0 ]->i915;struct virtual_engine *ve;unsigned int n; -int err; +int err = -ENOMEM ; ve =kzalloc (struct_size (ve, siblings, count),GFP_KERNEL );if (!ve) -return ERR_PTR (-ENOMEM ); + goto err; ve->base.i915 = i915; ve->base.gt = siblings[0 ]->gt;
@@ -3966,10 +3966,8 @@ execlists_create_virtual(struct intel_engine_cs **siblings, unsigned int count,intel_engine_init_execlists (&ve->base); ve->base.sched_engine =i915_sched_engine_create (ENGINE_VIRTUAL ); -if (!ve->base.sched_engine) { - err = -ENOMEM ; - goto err_put; - } +if (!ve->base.sched_engine) + goto err_noput; ve->base.sched_engine->private_data = &ve->base; ve->base.cops = &virtual_context_ops;
@@ -3985,10 +3983,8 @@ execlists_create_virtual(struct intel_engine_cs **siblings, unsigned int count,intel_context_init (&ve->context, &ve->base); ve->base.breadcrumbs =intel_breadcrumbs_create (NULL ); -if (!ve->base.breadcrumbs) { - err = -ENOMEM ; +if (!ve->base.breadcrumbs) goto err_put; - }for (n =0 ; n < count; n++) {struct intel_engine_cs *sibling = siblings[n];
@@ -4063,8 +4059,13 @@ execlists_create_virtual(struct intel_engine_cs **siblings, unsigned int count,virtual_engine_initial_hint (ve);return &ve->context; +err_noput: +kfree (ve); + goto err; + err_put:intel_context_put (&ve->context); +err:return ERR_PTR (err); }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 258/621 idpf: fix max_vport related crash on allocation error during init
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Emil Tantilov <[email protected]>
[ Upstream commit 237f1f7653b8729169af11fae79f01b90d00b87e ]
Set adapter->max_vports only after successful allocation of vports, netdevs and vport_config buffers. This fixes possible crashes on reset or rmmod, following failed allocation on init
[ 305.981402] idpf 0000:83:00.0: enabling device (0100 -> 0102) [ 305.994464] idpf 0000:83:00.0: Device HW Reset initiated [ 320.416872] BUG: kernel NULL pointer dereference, address: 0000000000000000 [ 320.416918] #PF: supervisor read access in kernel mode [ 320.416942] #PF: error_code(0x0000) - not-present page [ 320.416963] PGD 2099657067 P4D 0 [ 320.416983] Oops: Oops: 0000 [#1] SMP NOPTI ... [ 320.417093] RIP: 0010:idpf_remove+0x118/0x200 [idpf] [ 320.417130] Code: 8b bb 98 09 00 00 e8 17 0f 5b e5 48 8b bb e8 08 00 00 e8 0b 0f 5b e5 66 83 bb 28 06 00 00 00 48 8b bb 20 06 00 00 74 49 31 ed <48> 8b 04 ef 48 85 c0 74 2f 48 8b 78 20 e8 66 58 91 e5 48 8b 83 20 [ 320.417183] RSP: 0018:ff7322212903fdb8 EFLAGS: 00010246 [ 320.417205] RAX: 0000000000000000 RBX: ff4463de40300000 RCX: ff7322212903fd4c [ 320.417228] RDX: 0000000000000001 RSI: ffffffffa7f7d100 RDI: 0000000000000000 [ 320.417250] RBP: 0000000000000000 R08: 0000000000000001 R09: 0000000000000000 [ 320.417272] R10: 0000000000000001 R11: ff4463de3a638f58 R12: ff4463be89ac7000 [ 320.417294] R13: ff4463be89ac7198 R14: ff4463be94fc7198 R15: ffffffffc0f10f20 [ 320.417317] FS: 00007f963c0e6740(0000) GS:ff4463fdd65d8000(0000) knlGS:0000000000000000 [ 320.417342] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 320.417362] CR2: 0000000000000000 CR3: 00000020ba674002 CR4: 0000000000773ef0 [ 320.417385] PKRU: 55555554 [ 320.417398] Call Trace: [ 320.417412] <TASK> [ 320.417429] pci_device_remove+0x42/0xb0 [ 320.417459] device_release_driver_internal+0x1a9/0x210 [ 320.417492] driver_detach+0x4b/0x90 [ 320.417516] bus_remove_driver+0x70/0x100 [ 320.417539] pci_unregister_driver+0x2e/0xb0 [ 320.417564] __do_sys_delete_module.constprop.0+0x190/0x2f0 [ 320.417592] ? kmem_cache_free+0x31e/0x550 [ 320.417619] ? lockdep_hardirqs_on_prepare+0xde/0x190 [ 320.417644] ? do_syscall_64+0x38/0x6b0 [ 320.417665] do_syscall_64+0xc8/0x6b0 [ 320.417683] ? clear_bhb_loop+0x30/0x80 [ 320.417706] entry_SYSCALL_64_after_hwframe+0x76/0x7e [ 320.417727] RIP: 0033:0x7f963bb30beb
--- drivers/net/ethernet/intel/idpf/idpf_virtchnl.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
drivers/net/ethernet/intel/idpf/idpf_virtchnl.c +6 -1
@@ -3496,7 +3496,6 @@ int idpf_vc_core_init(struct idpf_adapter *adapter)pci_sriov_set_totalvfs (adapter->pdev,idpf_get_max_vfs (adapter)); num_max_vports =idpf_get_max_vports (adapter); - adapter->max_vports = num_max_vports; adapter->vports =kcalloc (num_max_vports,sizeof (*adapter->vports),GFP_KERNEL );if (!adapter->vports)
@@ -3519,6 +3518,12 @@ int idpf_vc_core_init(struct idpf_adapter *adapter) goto err_netdev_alloc; } +/* Set max_vports only after vports, netdevs and vport_config buffers +* are allocated to make sure max_vport bound loops don't end up +* crashing, following allocation errors on init. +*/ + adapter->max_vports = num_max_vports; +/* Start the mailbox task before requesting vectors. This will ensure * vector information response from mailbox is handled */
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 259/621 LoongArch: BPF: Zero-extend signed ALU32 div/mod results
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Nicholas Dudar <[email protected]>
[ Upstream commit dacd348b8a993373576fe2ee2d8b114740ba57a6 ]
ALU32 operations write a 32-bit result and leave the upper 32 bits of the BPF register zero. The LoongArch JIT sign-extends the result of signed ALU32 BPF_DIV and BPF_MOD (off=1), so a negative 32-bit quotient or remainder leaves bits 63:32 set in JITted code while the verifier and interpreter model those bits as zero.
Keep sign-extension on the operands, which signed divide needs, and zero-extend the ALU32 result after the divide or modulo instruction, matching the unsigned ALU32 div/mod paths and every other ALU32 operation in this JIT.
--- arch/loongarch/net/bpf_jit.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
arch/loongarch/net/bpf_jit.c +4 -4
@@ -620,7 +620,7 @@ static int build_insn(const struct bpf_insn *insn, struct jit_ctx *ctx, bool extmove_reg (ctx, t1, src);emit_sext_32 (ctx, t1, is32);emit_insn (ctx, divd, dst, dst, t1); -emit_sext_32 (ctx, dst, is32); +emit_zext_32 (ctx, dst, is32); }break ;
@@ -637,7 +637,7 @@ static int build_insn(const struct bpf_insn *insn, struct jit_ctx *ctx, bool extemit_sext_32 (ctx, t1, is32);emit_sext_32 (ctx, dst, is32);emit_insn (ctx, divd, dst, dst, t1); -emit_sext_32 (ctx, dst, is32); +emit_zext_32 (ctx, dst, is32); }break ;
@@ -655,7 +655,7 @@ static int build_insn(const struct bpf_insn *insn, struct jit_ctx *ctx, bool extmove_reg (ctx, t1, src);emit_sext_32 (ctx, t1, is32);emit_insn (ctx, modd, dst, dst, t1); -emit_sext_32 (ctx, dst, is32); +emit_zext_32 (ctx, dst, is32); }break ;
@@ -672,7 +672,7 @@ static int build_insn(const struct bpf_insn *insn, struct jit_ctx *ctx, bool extemit_sext_32 (ctx, t1, is32);emit_sext_32 (ctx, dst, is32);emit_insn (ctx, modd, dst, dst, t1); -emit_sext_32 (ctx, dst, is32); +emit_zext_32 (ctx, dst, is32); }break ;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 260/621 drm/xe/vf: Add drm_dev guards when detaching CCS read/write buffers
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Satyanarayana K V P <[email protected]>
[ Upstream commit 4c92afb4c143526d340545ca581e88e6952ea511 ]
CCS read/write buffers are freed during BO destruction. In some cases, BOs may be destroyed after the device is unbound but while the DRM structure remains valid, leading to NULL pointer dereferences when accessing device resources.
BUG: kernel NULL pointer dereference, address: 0000000000000000 PGD 0 P4D 0 Oops: Oops: 0000 [#1] SMP NOPTI CPU: 0 UID: 0 PID: 9376 Comm: xe_pat Not tainted 7.2.0-rc2+ #1 PREEMPT(lazy) RIP: 0010:xe_sriov_vf_ccs_rw_update_bb_addr+0x4d/0xa0 [xe] RSP: 0018:ffffcf304110b9c8 EFLAGS: 00010246 RAX: ffff8a85c38a0a00 RBX: 00000000810ef000 RCX: 0000000000000000 RDX: 0000000000000000 RSI: 0000000000000000 RDI: ffff8a85c39c1888 RBP: ffffcf304110b9e8 R08: 0000000000000000 R09: 0000000000000000 R10: 0000000000000000 R11: 0000000000000000 R12: ffff8a85c39c1888 R13: 0000000000000000 R14: ffff8a85c39b4f28 R15: ffff8a85c3885000 FS: 0000000000000000(0000) GS:ffff8a878b809000(0000) knlGS:0000000000000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 0000000000000000 CR3: 000000010314a002 CR4: 0000000000772ef0 PKRU: 55555554 Call Trace: <TASK> xe_migrate_ccs_rw_copy_clear+0x98/0x120 [xe] xe_sriov_vf_ccs_detach_bo+0x2c/0x60 [xe] xe_ttm_bo_delete_mem_notify+0xc8/0xe0 [xe] ttm_bo_cleanup_memtype_use+0x26/0x80 [ttm] ttm_bo_release+0x29e/0x2d0 [ttm] ttm_bo_fini+0x39/0x70 [ttm] xe_gem_object_free+0x1f/0x30 [xe] drm_gem_object_free+0x1d/0x40 ttm_bo_vm_close+0x5f/0x90 [ttm] remove_vma+0x2c/0x70 tear_down_vmas+0x63/0xf0 exit_mmap+0x20d/0x3f0 __mmput+0x45/0x170 mmput+0x31/0x40 do_exit+0x2ba/0xac0 do_group_exit+0x2d/0xb0 __x64_sys_exit_group+0x18/0x20 x64_sys_call+0x14a0/0x2390 do_syscall_64+0xdd/0x640 ? count_memcg_events+0xea/0x240 ? handle_mm_fault+0x1ec/0x2f0
--- drivers/gpu/drm/xe/xe_migrate.c | 17 +++++++++++------ drivers/gpu/drm/xe/xe_migrate.h | 3 ++- drivers/gpu/drm/xe/xe_sriov_vf_ccs.c | 14 ++++++++++++-- 3 files changed, 25 insertions(+), 9 deletions(-)
drivers/gpu/drm/xe/xe_migrate.c +11 -6
@@ -1171,6 +1171,7 @@ int xe_migrate_ccs_rw_copy(struct xe_tile *tile, struct xe_exec_queue *q,* content. * @src_bo: The buffer object @src is currently bound to. * @read_write : Creates BB commands for CCS read/write. +* @bound: Device is bound * * Directly clearing the BB lacks atomicity and can lead to undefined * behavior if the vCPU is halted mid-operation during the clearing
@@ -1183,7 +1184,8 @@ int xe_migrate_ccs_rw_copy(struct xe_tile *tile, struct xe_exec_queue *q,* Returns: None. */ void xe_migrate_ccs_rw_copy_clear (struct xe_bo *src_bo, -enum xe_sriov_vf_ccs_rw_ctxs read_write) +enum xe_sriov_vf_ccs_rw_ctxs read_write, +bool bound) {struct xe_bb *bb = src_bo->bb_ccs[read_write];struct xe_device *xe =xe_bo_device (src_bo);
@@ -1197,13 +1199,16 @@ void xe_migrate_ccs_rw_copy_clear(struct xe_bo *src_bo, bb_pool = ctx->mem.ccs_bb_pool;guard (mutex) (xe_sa_bo_swap_guard (bb_pool)); -xe_sa_bo_swap_shadow (bb_pool); - cs =xe_sa_bo_cpu_addr (bb->bo); -memset (cs,MI_NOOP , bb->len *sizeof (u32)); -xe_sriov_vf_ccs_rw_update_bb_addr (ctx); +if (bound) { +xe_sa_bo_swap_shadow (bb_pool); -xe_sa_bo_sync_shadow (bb->bo); + cs =xe_sa_bo_cpu_addr (bb->bo); +memset (cs,MI_NOOP , bb->len *sizeof (u32)); +xe_sriov_vf_ccs_rw_update_bb_addr (ctx); + +xe_sa_bo_sync_shadow (bb->bo); + }xe_bb_free (bb,NULL ); src_bo->bb_ccs[read_write] =NULL ;
drivers/gpu/drm/xe/xe_migrate.h +2 -1
@@ -137,7 +137,8 @@ int xe_migrate_ccs_rw_copy(struct xe_tile *tile, struct xe_exec_queue *q, enum xe_sriov_vf_ccs_rw_ctxs read_write);void xe_migrate_ccs_rw_copy_clear (struct xe_bo *src_bo, -enum xe_sriov_vf_ccs_rw_ctxs read_write); +enum xe_sriov_vf_ccs_rw_ctxs read_write, +bool bound);struct xe_lrc *xe_migrate_lrc (struct xe_migrate *migrate);struct xe_exec_queue *xe_migrate_exec_queue (struct xe_migrate *migrate);
drivers/gpu/drm/xe/xe_sriov_vf_ccs.c +12 -2
@@ -3,6 +3,8 @@* Copyright © 2025 Intel Corporation */ +#include <drm/drm_drv.h> +#include "instructions/xe_mi_commands.h" #include "instructions/xe_gpu_commands.h" #include "xe_bb.h"
@@ -372,7 +374,7 @@ int xe_sriov_vf_ccs_attach_bo(struct xe_bo *bo, struct ttm_resource *new_mem)*/ for_each_ccs_rw_ctx (ctx_id) {if (bo->bb_ccs[ctx_id]) -xe_migrate_ccs_rw_copy_clear (bo, ctx_id); +xe_migrate_ccs_rw_copy_clear (bo, ctx_id, true); }return err; }
@@ -392,19 +394,27 @@ int xe_sriov_vf_ccs_detach_bo(struct xe_bo *bo)struct xe_device *xe =xe_bo_device (bo);enum xe_sriov_vf_ccs_rw_ctxs ctx_id;struct xe_bb *bb; +bool bound; +int idx;xe_assert (xe,IS_VF_CCS_READY (xe));if (!xe_bo_has_valid_ccs_bb (bo))return 0 ; + bound =drm_dev_enter (&xe->drm, &idx); +for_each_ccs_rw_ctx (ctx_id) { bb = bo->bb_ccs[ctx_id];if (!bb)continue ; -xe_migrate_ccs_rw_copy_clear (bo, ctx_id); +xe_migrate_ccs_rw_copy_clear (bo, ctx_id, bound); } + +if (bound) +drm_dev_exit (idx); +return 0 ; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 261/621 cifs: prevent readdir from changing file size due to stale directory metadata
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Frank Sorenson <[email protected]>
[ Upstream commit e8a8d54c2d508891c142a928fc7d298c4c8bd0dd ]
Windows Server's directory enumeration metadata lags behind the actual file size after a write+close or rename. A concurrent readdir() in the window between close() returning to userspace and stat() being called overwrites the correct cached i_size with the stale server value, causing stat() to return the wrong size.
Once _cifsFileInfo_put() removes the last writable handle from openFileList, is_size_safe_to_change() permits readdir to overwrite i_size. smb2_close_getattr() then stamps cifs_i->time = jiffies, making the corrupt cached value appear fresh to the next stat().
The existing check (see Fixes:) only blocked stale size updates while an active RW lease was held, not after the last writable handle closes.
Add cifsInodeInfo->time_last_write, written via smp_store_release() at writable close and on setattr/truncate. is_size_safe_to_change() checks is_inode_writable() first (acquiring open_file_lock), then rejects a readdir size update if time_last_write falls within acregmax jiffies. The spinlock release in _cifsFileInfo_put() forms a store-release barrier that pairs with the spin_lock() (load-acquire) in is_inode_writable(), ensuring the subsequent smp_load_acquire() on time_last_write observes any update from a concurrent close(). When a size update is rejected and the server value differs from the cached one, cifs_i->time is cleared to force a fresh QUERY_INFO on the next stat().
readdir is also blocked from changing i_size while writable handles are open or an RW lease is held, even on direct-IO mounts.
For deferred close (closetimeo > 0), time_last_write is refreshed at the actual server close in smb2_deferred_work_close() and in the cifs_close_deferred_file*() drain paths invoked by lease/oplock breaks and tcon teardown, anchoring the protection window to the real close time rather than the earlier userspace close.
time_last_write == 0 skips the time_before() check to avoid false positives near boot on 32-bit systems where jiffies starts close to INITIAL_JIFFIES.
Does not reproduce against Samba or with actimeo=0.
Stable-dep-of: c2f2e83e3bbc ("cifs: fix cifsFileInfo leak on kmalloc failure in deferred close drain paths")
--- fs/smb/client/cifsfs.c | 1 + fs/smb/client/cifsglob.h | 1 + fs/smb/client/file.c | 70 ++++++++++++++++++++++++++++++++++++---- fs/smb/client/inode.c | 7 +++- fs/smb/client/misc.c | 35 ++++++++++++++++---- 5 files changed, 101 insertions(+), 13 deletions(-)
fs/smb/client/cifsfs.c +1 -0
@@ -474,6 +474,7 @@ cifs_alloc_inode(struct super_block *sb)return NULL ; cifs_inode->cifsAttrs =ATTR_ARCHIVE ;/* default */ cifs_inode->time =0 ; + cifs_inode->time_last_write =0 ;/* * Until the file is open and we have gotten oplock info back from the * server, can not assume caching of file data or metadata.
fs/smb/client/cifsglob.h +1 -0
@@ -1579,6 +1579,7 @@ struct cifsInodeInfo {spinlock_t writers_lock;unsigned int writers;/* Number of writers on this inode */ unsigned long time;/* jiffies of last update of inode */ +unsigned long time_last_write;/* jiffies of last writable close or truncate */ u64 uniqueid;/* server inode number */ u64 createtime;/* creation time on server */ __u8 lease_key[SMB2_LEASE_KEY_SIZE ];/* lease key for this inode */
fs/smb/client/file.c +64 -6
104 lines not on this page · raw message
fs/smb/client/inode.c +6 -1
@@ -236,6 +236,8 @@ cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr,if (is_size_safe_to_change (cifs_i, fattr->cf_eof, from_readdir)) {i_size_write (inode, fattr->cf_eof); inode->i_blocks =CIFS_INO_BLOCKS (fattr->cf_bytes); + }else if (from_readdir &&i_size_read (inode) != fattr->cf_eof) { + cifs_i->time =0 ; }if (S_ISLNK (fattr->cf_mode) && fattr->cf_symlink_target) {
@@ -3123,8 +3125,11 @@ int cifs_file_set_size(const unsigned int xid, struct dentry *dentry,cifs_put_tlink (tlink); set_size_out: -if (rc ==0 ) +if (rc ==0 ) { +/* Pairs with smp_load_acquire() in is_size_safe_to_change(). */ +smp_store_release (&cifsInode->time_last_write, jiffies);cifs_resize_file_locked (inode, size); + }return rc; }
fs/smb/client/misc.c +29 -6
@@ -791,7 +791,8 @@ cifs_close_deferred_file(struct cifsInodeInfo *cifs_inode)cifs_del_deferred_close (cfile);spin_unlock (&cifs_inode->deferred_lock); - tmp_list =kmalloc (sizeof (struct file_list ),GFP_ATOMIC ); + tmp_list = kmalloc_obj(struct file_list, +GFP_ATOMIC );if (tmp_list ==NULL )break ; tmp_list->cfile = cfile;
@@ -802,7 +803,14 @@ cifs_close_deferred_file(struct cifsInodeInfo *cifs_inode)spin_unlock (&cifs_inode->open_file_lock);list_for_each_entry_safe (tmp_list, tmp_next_list, &file_head, list) { -_cifsFileInfo_put (tmp_list->cfile, false, false); +struct cifsFileInfo *cfile = tmp_list->cfile; + +if (OPEN_FMODE (cfile->f_flags) &FMODE_WRITE ) { +/* Pairs with smp_load_acquire() in is_size_safe_to_change(). */ +smp_store_release (&CIFS_I (d_inode (cfile->dentry))->time_last_write, + jiffies); + } +_cifsFileInfo_put (cfile, false, false);list_del (&tmp_list->list);kfree (tmp_list); }
@@ -823,7 +831,8 @@ cifs_close_all_deferred_files(struct cifs_tcon *tcon)cifs_del_deferred_close (cfile);spin_unlock (&CIFS_I (d_inode (cfile->dentry))->deferred_lock); - tmp_list =kmalloc (sizeof (struct file_list ),GFP_ATOMIC ); + tmp_list = kmalloc_obj(struct file_list, +GFP_ATOMIC );if (tmp_list ==NULL )break ; tmp_list->cfile = cfile;
@@ -834,7 +843,14 @@ cifs_close_all_deferred_files(struct cifs_tcon *tcon)spin_unlock (&tcon->open_file_lock);list_for_each_entry_safe (tmp_list, tmp_next_list, &file_head, list) { -_cifsFileInfo_put (tmp_list->cfile, true, false); +struct cifsFileInfo *cfile = tmp_list->cfile; + +if (OPEN_FMODE (cfile->f_flags) &FMODE_WRITE ) { +/* Pairs with smp_load_acquire() in is_size_safe_to_change(). */ +smp_store_release (&CIFS_I (d_inode (cfile->dentry))->time_last_write, + jiffies); + } +_cifsFileInfo_put (cfile, true, false);list_del (&tmp_list->list);kfree (tmp_list); }
@@ -893,7 +909,7 @@ void cifs_close_deferred_file_under_dentry(struct cifs_tcon *tcon,cifs_del_deferred_close (cfile);spin_unlock (&CIFS_I (d_inode (cfile->dentry))->deferred_lock); - tmp_list =kmalloc (sizeof (struct file_list ),GFP_ATOMIC ); + tmp_list = kmalloc_obj(struct file_list, GFP_ATOMIC);if (tmp_list ==NULL )break ; tmp_list->cfile = cfile;
@@ -903,7 +919,14 @@ void cifs_close_deferred_file_under_dentry(struct cifs_tcon *tcon,spin_unlock (&tcon->open_file_lock);list_for_each_entry_safe (tmp_list, tmp_next_list, &file_head, list) { -_cifsFileInfo_put (tmp_list->cfile, true, false); +struct cifsFileInfo *cfile = tmp_list->cfile; + +if (OPEN_FMODE (cfile->f_flags) &FMODE_WRITE ) { +/* Pairs with smp_load_acquire() in is_size_safe_to_change(). */ +smp_store_release (&CIFS_I (d_inode (cfile->dentry))->time_last_write, + jiffies); + } +_cifsFileInfo_put (cfile, true, false);list_del (&tmp_list->list);kfree (tmp_list); }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 262/621 cifs: fix cifsFileInfo leak on kmalloc failure in deferred close drain paths
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Frank Sorenson <[email protected]>
[ Upstream commit c2f2e83e3bbc5483730fd4ee903182761f1ae50f ]
In cifs_close_deferred_file(), cifs_close_all_deferred_files(), and cifs_close_deferred_file_under_dentry(), when a pending deferred close is cancelled via cancel_delayed_work(), the subsequent kmalloc_obj() to add the file to the local processing list may fail under memory pressure. The loop breaks immediately, but the cancelled work is no longer pending (it would have called _cifsFileInfo_put()), and the cfile is never added to file_head for processing. The cifsFileInfo reference and the open server handle both leak.
Fix by saving the cfile that failed allocation in a local variable, breaking as before, and calling _cifsFileInfo_put() on it after releasing the lock. Any files later in the iteration are unaffected since their deferred work is still pending and will fire normally.
--- fs/smb/client/misc.c | 45 ++++++++++++++++++++++++++++++++++++++------ 1 file changed, 39 insertions(+), 6 deletions(-)
fs/smb/client/misc.c +39 -6
@@ -776,7 +776,7 @@ cifs_del_deferred_close(struct cifsFileInfo *cfile)void cifs_close_deferred_file (struct cifsInodeInfo *cifs_inode) { -struct cifsFileInfo *cfile =NULL ; +struct cifsFileInfo *cfile =NULL , *failed_cfile =NULL ;struct file_list *tmp_list, *tmp_next_list;LIST_HEAD (file_head);
@@ -793,8 +793,10 @@ cifs_close_deferred_file(struct cifsInodeInfo *cifs_inode) tmp_list = kmalloc_obj(struct file_list,GFP_ATOMIC ); -if (tmp_list ==NULL ) +if (tmp_list ==NULL ) { + failed_cfile = cfile;break ; + } tmp_list->cfile = cfile;list_add_tail (&tmp_list->list, &file_head); }
@@ -802,6 +804,15 @@ cifs_close_deferred_file(struct cifsInodeInfo *cifs_inode) }spin_unlock (&cifs_inode->open_file_lock); +if (failed_cfile) { +if (OPEN_FMODE (failed_cfile->f_flags) &FMODE_WRITE ) { +/* Pairs with smp_load_acquire() in is_size_safe_to_change(). */ +smp_store_release (&CIFS_I (d_inode (failed_cfile->dentry))->time_last_write, + jiffies); + } +_cifsFileInfo_put (failed_cfile, false, false); + } +list_for_each_entry_safe (tmp_list, tmp_next_list, &file_head, list) {struct cifsFileInfo *cfile = tmp_list->cfile;
@@ -819,7 +830,7 @@ cifs_close_deferred_file(struct cifsInodeInfo *cifs_inode)void cifs_close_all_deferred_files (struct cifs_tcon *tcon) { -struct cifsFileInfo *cfile; +struct cifsFileInfo *cfile, *failed_cfile =NULL ;struct file_list *tmp_list, *tmp_next_list;LIST_HEAD (file_head);
@@ -833,8 +844,10 @@ cifs_close_all_deferred_files(struct cifs_tcon *tcon) tmp_list = kmalloc_obj(struct file_list,GFP_ATOMIC ); -if (tmp_list ==NULL ) +if (tmp_list ==NULL ) { + failed_cfile = cfile;break ; + } tmp_list->cfile = cfile;list_add_tail (&tmp_list->list, &file_head); }
@@ -842,6 +855,15 @@ cifs_close_all_deferred_files(struct cifs_tcon *tcon) }spin_unlock (&tcon->open_file_lock); +if (failed_cfile) { +if (OPEN_FMODE (failed_cfile->f_flags) &FMODE_WRITE ) { +/* Pairs with smp_load_acquire() in is_size_safe_to_change(). */ +smp_store_release (&CIFS_I (d_inode (failed_cfile->dentry))->time_last_write, + jiffies); + } +_cifsFileInfo_put (failed_cfile, true, false); + } +list_for_each_entry_safe (tmp_list, tmp_next_list, &file_head, list) {struct cifsFileInfo *cfile = tmp_list->cfile;
@@ -897,7 +919,7 @@ void cifs_close_deferred_file_under_dentry(struct cifs_tcon *tcon, struct dentry *dentry) {struct file_list *tmp_list, *tmp_next_list; -struct cifsFileInfo *cfile; +struct cifsFileInfo *cfile, *failed_cfile =NULL ;LIST_HEAD (file_head);spin_lock (&tcon->open_file_lock);
@@ -910,14 +932,25 @@ void cifs_close_deferred_file_under_dentry(struct cifs_tcon *tcon,spin_unlock (&CIFS_I (d_inode (cfile->dentry))->deferred_lock); tmp_list = kmalloc_obj(struct file_list, GFP_ATOMIC); -if (tmp_list ==NULL ) +if (tmp_list ==NULL ) { + failed_cfile = cfile;break ; + } tmp_list->cfile = cfile;list_add_tail (&tmp_list->list, &file_head); } }spin_unlock (&tcon->open_file_lock); +if (failed_cfile) { +if (OPEN_FMODE (failed_cfile->f_flags) &FMODE_WRITE ) { +/* Pairs with smp_load_acquire() in is_size_safe_to_change(). */ +smp_store_release (&CIFS_I (d_inode (failed_cfile->dentry))->time_last_write, + jiffies); + } +_cifsFileInfo_put (failed_cfile, true, false); + } +list_for_each_entry_safe (tmp_list, tmp_next_list, &file_head, list) {struct cifsFileInfo *cfile = tmp_list->cfile;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 263/621 tipc: serialize udp bearer replicast list updates
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Weiming Shi <[email protected]>
[ Upstream commit 350e592ff4e30e48ffb55e142d11a73e63f4869c ]
tipc_udp_rcast_add() and cleanup_bearer() both update ub->rcast.list with list_add_rcu() / list_del_rcu(), but nothing serializes them. The add runs from the encap receive softirq (via tipc_udp_rcast_disc()) without rtnl_lock(), so it can race the cleanup delete and corrupt the list:
list_del corruption. prev->next should be ffff8880298d7ab8,
but was ffff88802449ad38. (prev=ffff888027e3ec98) kernel BUG at lib/list_debug.c:62! RIP: __list_del_entry_valid_or_report+0x17a/0x200 Workqueue: events cleanup_bearer Call Trace: cleanup_bearer (net/tipc/udp_media.c:811) process_one_work (kernel/workqueue.c:3302) worker_thread (kernel/workqueue.c:3466)
The bearer can be enabled from an unprivileged user namespace, as the TIPCv2 generic-netlink ops carry no GENL_ADMIN_PERM.
Add a spinlock to struct udp_bearer and take it around the list_add_rcu() in tipc_udp_rcast_add() and the list_del_rcu() loop in cleanup_bearer() so the two writers can no longer corrupt the list.
Reject a duplicate peer under the same lock before allocating, and remove tipc_udp_is_known_peer(). The old lockless pre-check in tipc_udp_rcast_disc() was racy: two softirqs discovering the same peer could both find it absent and add it twice.
cleanup_bearer() runs from a workqueue after tipc_udp_disable() clears the bearer's up bit, so an encap softirq can still reach tipc_udp_rcast_add() and add a peer after cleanup_bearer() has already emptied the list, leaking that entry when the bearer is freed. Mark the bearer disabled under rcast_lock once the list is emptied and refuse further additions.
--- net/tipc/udp_media.c | 56 +++++++++++++++++++++----------------------- 1 file changed, 27 insertions(+), 29 deletions(-)
net/tipc/udp_media.c +27 -29
@@ -94,6 +94,8 @@ struct udp_replicast {* @ifindex: local address scope * @work: used to schedule deferred work on a bearer * @rcast: associated udp_replicast container +* @rcast_lock: serialize updates to @rcast.list against concurrent updaters +* @disabled: bearer is being torn down; reject further @rcast.list additions */ struct udp_bearer {struct tipc_bearer __rcu *bearer;
@@ -101,6 +103,8 @@ struct udp_bearer {u32 ifindex;struct work_struct work;struct udp_replicast rcast; +spinlock_t rcast_lock; +bool disabled; };static int tipc_udp_is_mcast_addr (struct udp_media_addr *addr)
@@ -279,26 +283,6 @@ static int tipc_udp_send_msg(struct net *net, struct sk_buff *skb,return err; } -static bool tipc_udp_is_known_peer (struct tipc_bearer *b, -struct udp_media_addr *addr) -{ -struct udp_replicast *rcast, *tmp; -struct udp_bearer *ub; - - ub =rcu_dereference_rtnl (b->media_ptr); -if (!ub) { -pr_err_ratelimited ("UDP bearer instance not found\n" ); -return false; - } - -list_for_each_entry_safe (rcast, tmp, &ub->rcast.list, list) { -if (!memcmp (&rcast->addr, addr,sizeof (struct udp_media_addr ))) -return true; - } - -return false; -} -static int tipc_udp_rcast_add (struct tipc_bearer *b,struct udp_media_addr *addr) {
@@ -309,16 +293,34 @@ static int tipc_udp_rcast_add(struct tipc_bearer *b,if (!ub)return -ENODEV ; +spin_lock_bh (&ub->rcast_lock); +if (ub->disabled) { +spin_unlock_bh (&ub->rcast_lock); +return 0 ; + } +list_for_each_entry (rcast, &ub->rcast.list, list) { +if (!memcmp (&rcast->addr, addr,sizeof (*addr))) { +spin_unlock_bh (&ub->rcast_lock); +return 0 ; + } + } + rcast =kmalloc (sizeof (*rcast),GFP_ATOMIC ); -if (!rcast) +if (!rcast) { +spin_unlock_bh (&ub->rcast_lock);return -ENOMEM ; + }if (dst_cache_init (&rcast->dst_cache,GFP_ATOMIC )) { +spin_unlock_bh (&ub->rcast_lock);kfree (rcast);return -ENOMEM ; }memcpy (&rcast->addr, addr,sizeof (struct udp_media_addr )); +list_add_rcu (&rcast->list, &ub->rcast.list); + b->bcast_addr.broadcast =TIPC_REPLICAST_SUPPORT ; +spin_unlock_bh (&ub->rcast_lock);if (ntohs (addr->proto) ==ETH_P_IP )pr_info ("New replicast peer: %pI4\n" , &rcast->addr.ipv4);
@@ -326,8 +328,6 @@ static int tipc_udp_rcast_add(struct tipc_bearer *b, else if (ntohs(addr->proto) == ETH_P_IPV6) pr_info("New replicast peer: %pI6\n", &rcast->addr.ipv6);#endif - b->bcast_addr.broadcast =TIPC_REPLICAST_SUPPORT ; -list_add_rcu (&rcast->list, &ub->rcast.list);return 0 ; }
@@ -362,9 +362,6 @@ static int tipc_udp_rcast_disc(struct tipc_bearer *b, struct sk_buff *skb)return 0 ; } -if (likely (tipc_udp_is_known_peer (b, &src))) -return 0 ; -return tipc_udp_rcast_add (b, &src); }
@@ -646,9 +643,6 @@ int tipc_udp_nl_bearer_add(struct tipc_bearer *b, struct nlattr *attr)return -EINVAL ; } -if (tipc_udp_is_known_peer (b, &addr)) -return 0 ; -return tipc_udp_rcast_add (b, &addr); }
@@ -680,6 +674,7 @@ static int tipc_udp_enable(struct net *net, struct tipc_bearer *b,return -ENOMEM ;INIT_LIST_HEAD (&ub->rcast.list); +spin_lock_init (&ub->rcast_lock);if (!attrs[TIPC_NLA_BEARER_UDP_OPTS ]) goto err;
@@ -809,11 +804,14 @@ static void cleanup_bearer(struct work_struct *work)struct udp_replicast *rcast, *tmp;struct tipc_net *tn; +spin_lock_bh (&ub->rcast_lock);list_for_each_entry_safe (rcast, tmp, &ub->rcast.list, list) {dst_cache_destroy (&rcast->dst_cache);list_del_rcu (&rcast->list);kfree_rcu (rcast, rcu); } + ub->disabled = true; +spin_unlock_bh (&ub->rcast_lock); tn =tipc_net (sock_net (ub->ubsock->sk));
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 264/621 fwctl/bnxt_en: Refactor aux bus functions to be more generic
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pavan Chebbi <[email protected]>
[ Upstream commit 2c7c85c8c7881d57c5fa1114f4b0dbd7fc53a36f ]
Up until now there was only one auxiliary device that bnxt created and that was for RoCE driver. bnxt fwctl is also going to use an aux bus device that bnxt should create. This requires some nomenclature changes and refactoring of the existing bnxt aux dev functions.
Convert 'aux_priv' and 'edev' members of struct bnxt into arrays where each element contains supported auxbus device's data. Move struct bnxt_aux_priv from bnxt.h to ulp.h because that is where it belongs. Make aux bus init/uninit/add/del functions more generic which will loop through all the aux device types. Make bnxt_ulp_start/stop functions (the only other common functions applicable to any aux device) loop through the aux devices to update their config and states. Make callers of bnxt_ulp_start() call it only when there are no errors.
Also, as an improvement in code, bnxt_register_dev() can skip unnecessary dereferencing of edev from bp, instead use the edev pointer from the function parameter.
Future patches will reuse these functions to add an aux bus device for fwctl.
Stable-dep-of: 1cb8553c02e9 ("bnxt_en: Handle partially initialized auxiliary devices")
--- drivers/net/ethernet/broadcom/bnxt/bnxt.c | 47 ++- drivers/net/ethernet/broadcom/bnxt/bnxt.h | 19 +- .../net/ethernet/broadcom/bnxt/bnxt_devlink.c | 8 +- .../net/ethernet/broadcom/bnxt/bnxt_ethtool.c | 2 +- drivers/net/ethernet/broadcom/bnxt/bnxt_ulp.c | 341 +++++++++++------- include/linux/bnxt/ulp.h | 25 +- 6 files changed, 275 insertions(+), 167 deletions(-)
drivers/net/ethernet/broadcom/bnxt/bnxt.c +28 -19
@@ -6894,7 +6894,8 @@ int bnxt_hwrm_vnic_cfg(struct bnxt *bp, struct bnxt_vnic_info *vnic)#endif if ((bp->flags &BNXT_FLAG_STRIP_VLAN ) || def_vlan) req->flags |=cpu_to_le32 (VNIC_CFG_REQ_FLAGS_VLAN_STRIP_MODE ); -if (vnic->vnic_id ==BNXT_VNIC_DEFAULT &&bnxt_ulp_registered (bp->edev)) +if (vnic->vnic_id ==BNXT_VNIC_DEFAULT && +bnxt_ulp_registered (bp->edev[BNXT_AUXDEV_RDMA ])) req->flags |=cpu_to_le32 (bnxt_get_roce_vnic_mode (bp));return hwrm_req_send (bp, req);
@@ -8012,6 +8013,7 @@ static int bnxt_get_avail_msix(struct bnxt *bp, int num);static int __bnxt_reserve_rings (struct bnxt *bp) { +struct bnxt_en_dev *edev = bp->edev[BNXT_AUXDEV_RDMA ];struct bnxt_hw_rings hwr = {0 };int rx_rings, old_rx_rings, rc;int cp = bp->cp_nr_rings;
@@ -8022,7 +8024,7 @@ static int __bnxt_reserve_rings(struct bnxt *bp)if (!bnxt_need_reserve_rings (bp))return 0 ; -if (BNXT_NEW_RM (bp) && !bnxt_ulp_registered (bp->edev)) { +if (BNXT_NEW_RM (bp) && !bnxt_ulp_registered (edev)) { ulp_msix =bnxt_get_avail_msix (bp, bp->ulp_num_msix_want);if (!ulp_msix)bnxt_set_ulp_stat_ctxs (bp,0 );
@@ -8075,8 +8077,7 @@ static int __bnxt_reserve_rings(struct bnxt *bp) } rx_rings =min_t (int, rx_rings, hwr.grp); hwr.cp =min_t (int, hwr.cp, bp->cp_nr_rings); -if (bnxt_ulp_registered (bp->edev) && - hwr.stat >bnxt_get_ulp_stat_ctxs (bp)) +if (bnxt_ulp_registered (edev) && hwr.stat >bnxt_get_ulp_stat_ctxs (bp)) hwr.stat -=bnxt_get_ulp_stat_ctxs (bp); hwr.cp =min_t (int, hwr.cp, hwr.stat); rc =bnxt_trim_rings (bp, &rx_rings, &hwr.tx, hwr.cp, sh);
@@ -8115,7 +8116,7 @@ static int __bnxt_reserve_rings(struct bnxt *bp) !netif_is_rxfh_configured(bp->dev))bnxt_set_dflt_rss_indir_tbl (bp,NULL ); -if (!bnxt_ulp_registered (bp->edev) &&BNXT_NEW_RM (bp)) { +if (!bnxt_ulp_registered (edev) &&BNXT_NEW_RM (bp)) {int resv_msix, resv_ctx, ulp_ctxs;struct bnxt_hw_resc *hw_resc;
@@ -11514,6 +11515,7 @@ static void bnxt_clear_int_mode(struct bnxt *bp)int bnxt_reserve_rings (struct bnxt *bp,bool irq_re_init) { +struct bnxt_en_dev *edev = bp->edev[BNXT_AUXDEV_RDMA ];bool irq_cleared = false;bool irq_change = false;int tcs = bp->num_tc;
@@ -11523,7 +11525,7 @@ int bnxt_reserve_rings(struct bnxt *bp, bool irq_re_init)if (!bnxt_need_reserve_rings (bp))return 0 ; -if (BNXT_NEW_RM (bp) && !bnxt_ulp_registered (bp->edev)) { +if (BNXT_NEW_RM (bp) && !bnxt_ulp_registered (edev)) {int ulp_msix =bnxt_get_avail_msix (bp, bp->ulp_num_msix_want);if (ulp_msix > bp->ulp_num_msix_want)
@@ -14626,7 +14628,7 @@ static void bnxt_fw_echo_reply(struct bnxt *bp)static void bnxt_ulp_restart (struct bnxt *bp) {bnxt_ulp_stop (bp); -bnxt_ulp_start (bp,0 ); +bnxt_ulp_start (bp); }static void bnxt_sp_task (struct work_struct *work)
@@ -14786,7 +14788,7 @@ int bnxt_check_rings(struct bnxt *bp, int tx, int rx, bool sh, int tcs, hwr.cp_p5 = hwr.tx + rx; rc =bnxt_hwrm_check_rings (bp, &hwr);if (!rc &&pci_msix_can_alloc_dyn (bp->pdev)) { -if (!bnxt_ulp_registered (bp->edev)) { +if (!bnxt_ulp_registered (bp->edev[BNXT_AUXDEV_RDMA ])) { hwr.cp +=bnxt_get_ulp_msix_num (bp); hwr.cp =min_t (int, hwr.cp,bnxt_get_max_func_irqs (bp)); }
@@ -15309,7 +15311,7 @@ static void bnxt_fw_reset_task(struct work_struct *work) }netdev_unlock (bp->dev);rtnl_unlock (); -bnxt_ulp_start (bp,0 ); +bnxt_ulp_start (bp);bnxt_reenable_sriov (bp);netdev_lock (bp->dev);bnxt_vf_reps_alloc (bp);
@@ -15331,7 +15333,8 @@ static void bnxt_fw_reset_task(struct work_struct *work)bnxt_fw_reset_abort (bp, rc);netdev_unlock (bp->dev); ulp_start: -bnxt_ulp_start (bp, rc); +if (!rc) +bnxt_ulp_start (bp); }static int bnxt_init_board (struct pci_dev *pdev,struct net_device *dev)
@@ -16378,12 +16381,13 @@ static void bnxt_remove_one(struct pci_dev *pdev)if (BNXT_PF (bp))__bnxt_sriov_disable (bp); -bnxt_rdma_aux_device_del (bp); +bnxt_aux_devices_del (bp);unregister_netdev (dev);bnxt_ptp_clear (bp); -bnxt_rdma_aux_device_uninit (bp); +bnxt_aux_devices_uninit (bp); +bnxt_auxdev_id_free (bp, bp->auxdev_id);bnxt_free_l2_filters (bp, true);bnxt_free_ntp_fltrs (bp, true);
@@ -16969,7 +16973,9 @@ static int bnxt_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)bnxt_set_tpa_flags (bp);bnxt_init_ring_params (bp);bnxt_set_ring_params (bp); -bnxt_rdma_aux_device_init (bp); +mutex_init (&bp->auxdev_lock); +if (!bnxt_auxdev_id_alloc (bp)) +bnxt_aux_devices_init (bp); rc =bnxt_set_dflt_rings (bp, true);if (rc) {if (BNXT_VF (bp) && rc == -ENODEV ) {
@@ -17034,7 +17040,7 @@ static int bnxt_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)bnxt_dl_fw_reporters_create (bp); -bnxt_rdma_aux_device_add (bp); +bnxt_aux_devices_add (bp);bnxt_print_device_info (bp);
@@ -17042,7 +17048,8 @@ static int bnxt_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)return 0 ; init_err_cleanup: -bnxt_rdma_aux_device_uninit (bp); +bnxt_aux_devices_uninit (bp); +bnxt_auxdev_id_free (bp, bp->auxdev_id);bnxt_dl_unregister (bp); init_err_dl:bnxt_shutdown_tc (bp);
@@ -17178,9 +17185,10 @@ static int bnxt_resume(struct device *device) resume_exit:netdev_unlock (bp->dev);rtnl_unlock (); -bnxt_ulp_start (bp, rc); -if (!rc) +if (!rc) { +bnxt_ulp_start (bp);bnxt_reenable_sriov (bp); + }return rc; }
@@ -17362,9 +17370,10 @@ static void bnxt_io_resume(struct pci_dev *pdev)netdev_unlock (netdev);rtnl_unlock (); -bnxt_ulp_start (bp, err); -if (!err) +if (!err) { +bnxt_ulp_start (bp);bnxt_reenable_sriov (bp); + } }static const struct pci_error_handlers bnxt_err_handler = {
drivers/net/ethernet/broadcom/bnxt/bnxt.h +10 -9
@@ -24,12 +24,12 @@#include <linux/interrupt.h> #include <linux/rhashtable.h> #include <linux/crash_dump.h> -#include <linux/auxiliary_bus.h> #include <net/devlink.h> #include <net/dst_metadata.h> #include <net/xdp.h> #include <linux/dim.h> #include <linux/io-64-nonatomic-lo-hi.h> +#include <linux/bnxt/ulp.h> #ifdef CONFIG_TEE_BNXT_FW #include <linux/firmware/broadcom/tee_bnxt_fw.h> #endif
@@ -2084,12 +2084,6 @@ struct bnxt_fw_health {#define BNXT_FW_IF_RETRY 10#define BNXT_FW_SLOT_RESET_RETRY 4 -struct bnxt_aux_priv { -struct auxiliary_device aux_dev; -struct bnxt_en_dev *edev; -int id; -}; -enum board_idx {BCM57301 ,BCM57302 ,
@@ -2349,8 +2343,8 @@ struct bnxt {#define BNXT_CHIP_P5_AND_MINUS (bp) \ (BNXT_CHIP_P3(bp) || BNXT_CHIP_P4(bp) || BNXT_CHIP_P5(bp)) -struct bnxt_aux_priv *aux_priv; -struct bnxt_en_dev *edev; +struct bnxt_aux_priv *aux_priv[__BNXT_AUXDEV_MAX]; +struct bnxt_en_dev *edev[__BNXT_AUXDEV_MAX];struct bnxt_napi **bnapi;
@@ -2761,6 +2755,13 @@ struct bnxt {struct bnxt_ctx_pg_info *fw_crash_mem;u32 fw_crash_len;struct bnxt_bs_trace_info bs_trace[BNXT_TRACE_MAX ]; +int auxdev_id; +/* synchronize validity checks of available aux devices */ +struct mutex auxdev_lock; +u8 auxdev_state[__BNXT_AUXDEV_MAX]; +#define BNXT_ADEV_STATE_NONE 0 +#define BNXT_ADEV_STATE_INIT 1 +#define BNXT_ADEV_STATE_ADD 2 };#define BNXT_NUM_RX_RING_STATS 8
drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c +4 -4
@@ -440,13 +440,13 @@ static int bnxt_dl_reload_down(struct devlink *dl, bool netns_change, "reload is unsupported while VFs are allocated or being configured");netdev_unlock (bp->dev);rtnl_unlock (); -bnxt_ulp_start (bp,0 ); +bnxt_ulp_start (bp);return -EOPNOTSUPP ; }if (bp->dev->reg_state ==NETREG_UNREGISTERED ) {netdev_unlock (bp->dev);rtnl_unlock (); -bnxt_ulp_start (bp,0 ); +bnxt_ulp_start (bp);return -ENODEV ; }if (netif_running (bp->dev))
@@ -578,8 +578,8 @@ static int bnxt_dl_reload_up(struct devlink *dl, enum devlink_reload_action acti }netdev_unlock (bp->dev);rtnl_unlock (); -if (action ==DEVLINK_RELOAD_ACTION_DRIVER_REINIT ) -bnxt_ulp_start (bp, rc); +if (!rc && action ==DEVLINK_RELOAD_ACTION_DRIVER_REINIT ) +bnxt_ulp_start (bp);return rc; }
drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c +1 -1
@@ -5088,7 +5088,7 @@ static void bnxt_self_test(struct net_device *dev, struct ethtool_test *etest,memset (buf,0 ,sizeof (u64) * bp->num_tests);if (etest->flags Ð_TEST_FL_OFFLINE && -bnxt_ulp_registered (bp->edev)) { +bnxt_ulp_registered (bp->edev[BNXT_AUXDEV_RDMA ])) { etest->flags |=ETH_TEST_FL_FAILED ;netdev_warn (dev,"Offline tests cannot be run with RoCE driver loaded\n" );return ;
drivers/net/ethernet/broadcom/bnxt/bnxt_ulp.c +212 -129
501 lines not on this page · raw message
include/linux/bnxt/ulp.h +20 -5
@@ -10,6 +10,8 @@#ifndef BNXT_ULP_H #define BNXT_ULP_H +#include <linux/auxiliary_bus.h> +#define BNXT_MIN_ROCE_CP_RINGS 2#define BNXT_MIN_ROCE_STAT_CTXS 1
@@ -20,6 +22,17 @@struct hwrm_async_event_cmpl ;struct bnxt ; +enum bnxt_auxdev_type { +BNXT_AUXDEV_RDMA =0 , + __BNXT_AUXDEV_MAX +}; + +struct bnxt_aux_priv { +struct auxiliary_device aux_dev; +struct bnxt_en_dev *edev; +int id; +}; +struct bnxt_msix_entry {u32 vector;u32 ring_idx;
@@ -111,19 +124,21 @@ void bnxt_set_ulp_stat_ctxs(struct bnxt *bp, int num_ctxs);int bnxt_get_ulp_stat_ctxs_in_use (struct bnxt *bp);void bnxt_set_dflt_ulp_stat_ctxs (struct bnxt *bp);void bnxt_ulp_stop (struct bnxt *bp); -void bnxt_ulp_start (struct bnxt *bp,int err); +void bnxt_ulp_start (struct bnxt *bp);void bnxt_ulp_sriov_cfg (struct bnxt *bp,int num_vfs);void bnxt_ulp_irq_stop (struct bnxt *bp);void bnxt_ulp_irq_restart (struct bnxt *bp,int err);void bnxt_ulp_async_events (struct bnxt *bp,struct hwrm_async_event_cmpl *cmpl); -void bnxt_rdma_aux_device_uninit (struct bnxt *bp); -void bnxt_rdma_aux_device_del (struct bnxt *bp); -void bnxt_rdma_aux_device_add (struct bnxt *bp); -void bnxt_rdma_aux_device_init (struct bnxt *bp); +void bnxt_aux_devices_uninit (struct bnxt *bp); +void bnxt_aux_devices_del (struct bnxt *bp); +void bnxt_aux_devices_add (struct bnxt *bp); +void bnxt_aux_devices_init (struct bnxt *bp);int bnxt_register_dev (struct bnxt_en_dev *edev,struct bnxt_ulp_ops *ulp_ops,void *handle);void bnxt_unregister_dev (struct bnxt_en_dev *edev);int bnxt_send_msg (struct bnxt_en_dev *edev,struct bnxt_fw_msg *fw_msg);void bnxt_register_async_events (struct bnxt_en_dev *edev,unsigned long *events_bmap,u16 max_id); +int bnxt_auxdev_id_alloc (struct bnxt *bp); +void bnxt_auxdev_id_free (struct bnxt *bp,int id);#endif
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 265/621 bnxt_en: Handle partially initialized auxiliary devices
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Ruoyu Wang <[email protected]>
[ Upstream commit 1cb8553c02e93e5a150cebd42f9ee3db0ece4707 ]
bnxt_aux_devices_init() calls auxiliary_device_init() before all fields used by bnxt_aux_dev_release() are initialized. After auxiliary_device_init() succeeds, later errors must unwind with auxiliary_device_uninit(), which invokes the release callback.
The release callback assumes that aux_priv->id, aux_priv->edev, edev->net and edev->ulp_tbl are all populated. If allocation fails after auxiliary_device_init(), the release path can otherwise dereference or clear partially initialized state.
Allocate and attach the bnxt_en_dev and ULP table before calling auxiliary_device_init(), so the release callback only sees a fully initialized auxiliary private object. If auxiliary_device_init() itself fails, free those allocations directly because device_initialize() has not run and the release callback will not be invoked.
This issue was found by a static analysis checker and confirmed by manual source review.
--- drivers/net/ethernet/broadcom/bnxt/bnxt_ulp.c | 39 ++++++++++--------- 1 file changed, 20 insertions(+), 19 deletions(-)
drivers/net/ethernet/broadcom/bnxt/bnxt_ulp.c +20 -19
@@ -558,6 +558,18 @@ void bnxt_aux_devices_init(struct bnxt *bp)if (!aux_priv) goto next_auxdev; + edev =kzalloc_obj (*edev); +if (!edev) + goto aux_priv_free; + aux_priv->edev = edev; +bnxt_set_edev_info (edev, bp); + + ulp =kzalloc_obj (*ulp); +if (!ulp) + goto edev_free; + edev->ulp_tbl = ulp; + aux_priv->id = idx; + aux_dev = &aux_priv->aux_dev; aux_dev->id = bp->auxdev_id; aux_dev->name = bnxt_aux_devices[idx].name;
@@ -565,37 +577,26 @@ void bnxt_aux_devices_init(struct bnxt *bp) aux_dev->dev.release = bnxt_aux_dev_release; rc =auxiliary_device_init (aux_dev); -if (rc) { -kfree (aux_priv); - goto next_auxdev; - } +if (rc) + goto ulp_free; bp->aux_priv[idx] = aux_priv;/* From this point, all cleanup will happen via the .release * callback & any error unwinding will need to include a call * to auxiliary_device_uninit. */ - edev =kzalloc_obj (*edev); -if (!edev) - goto aux_dev_uninit; - - aux_priv->edev = edev; -bnxt_set_edev_info (edev, bp); - - ulp =kzalloc_obj (*ulp); -if (!ulp) - goto aux_dev_uninit; - - edev->ulp_tbl = ulp; bp->edev[idx] = edev;if (idx ==BNXT_AUXDEV_RDMA ) bp->ulp_num_msix_want =bnxt_set_dflt_ulp_msix (bp); - aux_priv->id = idx;bnxt_auxdev_set_state (bp, idx,BNXT_ADEV_STATE_INIT );continue ; -aux_dev_uninit: -auxiliary_device_uninit (aux_dev); +ulp_free: +kfree (ulp); +edev_free: +kfree (edev); +aux_priv_free: +kfree (aux_priv); next_auxdev:if (idx ==BNXT_AUXDEV_RDMA ) bp->flags &= ~BNXT_FLAG_ROCE_CAP ;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 266/621 drm/xe/guc: Hold device ref until queue teardown completes
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Arvind Yadav <[email protected]>
[ Upstream commit 9b7e60184f4b22e893d4ae95234d5f26261a430c ]
GuC exec queue destruction can run asynchronously. If the final device put happens from a destroy worker, drmm cleanup can end up draining the same workqueue and deadlock.
Hold a drm_device reference for the queue lifetime and drop it after queue teardown completes. This keeps drmm cleanup from running while async destroy work is still pending.
Move GuC destroy work to a module-lifetime Xe workqueue and flush it on PCI remove so hot-unbind/rebind still waits for pending destroy work.
With queue-held device refs, guc_submit_sw_fini() cannot run with live GuC IDs. Replace the fini wait with an assertion and remove the unused fini_wq.
v2:
- Rebase
v3:
- Switch to queue-lifetime drm_dev_get()/drm_dev_put() model. (Matt)
- Queue async teardown on system_dfl_wq instead of xe->destroy_wq. (Matt)
- Drop separate deferred drm_dev_put worker.
- Remove stale drain_workqueue(xe->destroy_wq) from guc_submit_sw_fini().
v4:
- Replace the guc_submit_sw_fini() wait with an assertion and remove the now-unused fini_wq. (sashiko)
v5:
- Move destroy work to a module-lifetime Xe workqueue instead of system_dfl_wq. (Matt)
- Flush the module-lifetime destroy workqueue during PCI remove to preserve the old device-remove wait semantics.
v6:
- Keep SVM pagemap destroy work on the per-device destroy_wq to avoid letting it outlive the xe_device/drm_device. (Sashiko)
- Use WQ_MEM_RECLAIM for xe->destroy_wq because SVM pagemap destroy work can be queued from the reclaim path.
v7:
- Drop the per-device xe->destroy_wq and use the module-level destroy WQ for SVM pagemap destroy as well. (Matt)
- Rename xe_exec_queue_destroy_wq_*() helpers to xe_destroy_wq_*() helpers because the WQ is no longer exec-queue specific. (Matt)
v8:
- Rebase.
v9:
- Keep SVM pagemap destroy work on the per-device WQ_MEM_RECLAIM destroy_wq because it can be queued from reclaim and embeds the dev_pagemap used by devres teardown. (Sashiko)
- Keep the module-level destroy WQ GuC-only and drop WQ_MEM_RECLAIM from it.
- Update the module-WQ kdoc to document the GuC/SVM split.
v10:
- Keep xe->destroy_wq per-cpu while adding WQ_MEM_RECLAIM to fix the workqueue allocation warning.
v11:
- Drop the SVM pagemap destroy comment as it was revision-specific. (Thomas)
v12:
- Rebase.
--- drivers/gpu/drm/xe/xe_device.c | 2 +- drivers/gpu/drm/xe/xe_device_types.h | 2 +- drivers/gpu/drm/xe/xe_guc_submit.c | 59 +++++++++++++++++----------- drivers/gpu/drm/xe/xe_guc_types.h | 2 - drivers/gpu/drm/xe/xe_module.c | 49 +++++++++++++++++++++++ drivers/gpu/drm/xe/xe_module.h | 5 +++ drivers/gpu/drm/xe/xe_pci.c | 6 +++ 7 files changed, 97 insertions(+), 28 deletions(-)
drivers/gpu/drm/xe/xe_device.c +1 -1
@@ -487,7 +487,7 @@ struct xe_device *xe_device_create(struct pci_dev *pdev, WQ_MEM_RECLAIM); xe->ordered_wq =alloc_ordered_workqueue ("xe-ordered-wq" ,0 ); xe->unordered_wq =alloc_workqueue ("xe-unordered-wq" ,0 ,0 ); - xe->destroy_wq =alloc_workqueue ("xe-destroy-wq" ,0 ,0 ); + xe->destroy_wq =alloc_workqueue ("xe-destroy-wq" ,WQ_MEM_RECLAIM ,0 );if (!xe->ordered_wq || !xe->unordered_wq || !xe->preempt_fence_wq || !xe->destroy_wq) {/*
drivers/gpu/drm/xe/xe_device_types.h +1 -1
@@ -452,7 +452,7 @@ struct xe_device {/** @unordered_wq: used to serialize unordered work */ struct workqueue_struct *unordered_wq; -/** @destroy_wq: used to serialize user destroy work, like queue */ +/** @destroy_wq: used to serialize SVM pagemap destroy work */ struct workqueue_struct *destroy_wq;/** @tiles: device tiles */
drivers/gpu/drm/xe/xe_guc_submit.c +35 -24
141 lines not on this page · raw message
drivers/gpu/drm/xe/xe_guc_types.h +0 -2
@@ -100,8 +100,6 @@ struct xe_guc {* even initialized - before that not even the lock is valid */ bool initialized; -/** @submission_state.fini_wq: submit fini wait queue */ -wait_queue_head_t fini_wq; } submission_state;/** @hwconfig: Hardware config state */
drivers/gpu/drm/xe/xe_module.c +49 -0
67 lines not on this page · raw message
drivers/gpu/drm/xe/xe_module.h +5 -0
@@ -8,6 +8,8 @@#include <linux/types.h> +struct work_struct ; +/* Module modprobe variables */ struct xe_modparam {bool force_execlist;
@@ -27,5 +29,8 @@ struct xe_modparam {extern struct xe_modparam xe_modparam; +bool xe_destroy_wq_queue (struct work_struct *work); +void xe_destroy_wq_flush (void ); +#endif
drivers/gpu/drm/xe/xe_pci.c +6 -0
@@ -798,6 +798,12 @@ static void xe_pci_remove(struct pci_dev *pdev)return ;xe_device_remove (xe); + +/* +* Preserve remove-time flush after moving destroy work to module +* lifetime. +*/ +xe_destroy_wq_flush ();xe_pm_fini (xe); }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 267/621 drm/xe/guc: Keep scheduler timeline name alive
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Arvind Yadav <[email protected]>
[ Upstream commit 299bc6d50b1bed7d1f408391736712f01a0855e2 ]
The scheduler keeps a pointer to the timeline name, but q->name is freed with the exec queue while scheduler fences can still reference it.
Store the name in struct xe_guc_exec_queue so it shares the scheduler's RCU-deferred lifetime.
--- drivers/gpu/drm/xe/xe_guc_exec_queue_types.h | 5 +++++ drivers/gpu/drm/xe/xe_guc_submit.c | 4 +++- 2 files changed, 8 insertions(+), 1 deletion(-)
drivers/gpu/drm/xe/xe_guc_exec_queue_types.h +5 -0
@@ -10,6 +10,7 @@#include <linux/workqueue.h> #include "xe_gpu_scheduler_types.h" +#include "xe_hw_fence_types.h" struct dma_fence ;struct xe_exec_queue ;
@@ -24,6 +25,10 @@ struct xe_guc_exec_queue {struct rcu_head rcu;/** @sched: GPU scheduler for this xe_exec_queue */ struct xe_gpu_scheduler sched; +/** +* @name: Scheduler timeline name, kept with @sched until RCU free. +*/ +char name[MAX_FENCE_NAME_LEN ];/** @entity: Scheduler entity for this xe_exec_queue */ struct xe_sched_entity entity;/**
drivers/gpu/drm/xe/xe_guc_submit.c +3 -1
@@ -1684,7 +1684,7 @@ static int guc_exec_queue_init(struct xe_exec_queue *q) err =xe_sched_init (&ge->sched, &drm_sched_ops, &xe_sched_ops,NULL , q->lrc[0 ]->ring.size /MAX_JOB_SIZE_BYTES ,64 , timeout,guc_to_gt (guc)->ordered_wq,NULL , - q->name,gt_to_xe (q->gt)->drm.dev); + ge->name,gt_to_xe (q->gt)->drm.dev);if (err) goto err_free;
@@ -1711,6 +1711,8 @@ static int guc_exec_queue_init(struct xe_exec_queue *q)xe_exec_queue_assign_name (q, q->guc->id); +strscpy (ge->name, q->name,sizeof (ge->name)); +trace_xe_exec_queue_create (q);return 0 ;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 268/621 bpf: Use rcu_read_lock_dont_migrate in bpf_sk_storage.c
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Fushuai Wang <[email protected]>
[ Upstream commit 0db4941d9dae159d887e7e2eac7e54e60c3aac87 ]
Use rcu_read_lock_dont_migrate() and rcu_read_unlock_migrate() in bpf_sk_storage.c to obtain better performance when PREEMPT_RCU is not enabled.
Stable-dep-of: 7cbd0c4cebe4 ("bpf: Fix UAF in sock clone early bailouts")
--- net/core/bpf_sk_storage.c | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-)
net/core/bpf_sk_storage.c +4 -8
@@ -50,16 +50,14 @@ void bpf_sk_storage_free(struct sock *sk) {struct bpf_local_storage *sk_storage; -migrate_disable (); -rcu_read_lock (); +rcu_read_lock_dont_migrate (); sk_storage =rcu_dereference (sk->sk_bpf_storage);if (!sk_storage) goto out;bpf_local_storage_destroy (sk_storage); out: -rcu_read_unlock (); -migrate_enable (); +rcu_read_unlock_migrate (); }static void bpf_sk_storage_map_free (struct bpf_map *map)
@@ -161,8 +159,7 @@ int bpf_sk_storage_clone(const struct sock *sk, struct sock *newsk)RCU_INIT_POINTER (newsk->sk_bpf_storage,NULL ); -migrate_disable (); -rcu_read_lock (); +rcu_read_lock_dont_migrate (); sk_storage =rcu_dereference (sk->sk_bpf_storage);if (!sk_storage ||hlist_empty (&sk_storage->list))
@@ -213,8 +210,7 @@ int bpf_sk_storage_clone(const struct sock *sk, struct sock *newsk) } out: -rcu_read_unlock (); -migrate_enable (); +rcu_read_unlock_migrate ();/* In case of an error, don't free anything explicitly here, the * caller is responsible to call bpf_sk_storage_free.
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 269/621 bpf: Fix UAF in sock clone early bailouts
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Matt Bobrowski <[email protected]>
[ Upstream commit 7cbd0c4cebe4c9f678d15e6b9ba975e1155a107f ]
Similar to recent commit 9b51a6155d14 ("bpf,fork: wipe ->bpf_storage before bailouts that access it"), sk_clone() performs an initial shallow copy of the socket field ->sk_bpf_storage via sock_copy() for the cloned socket newsk.
If sk_clone() bails out early (e.g. if sk_filter_charge() fails) prior to calling bpf_sk_storage_clone(), newsk->sk_bpf_storage still points to the parent socket's BPF local storage. When newsk is subsequently freed via sk_free(), the deallocation path (__sk_destruct() -> bpf_sk_storage_free()) destroys the parent socket's BPF local storage, leading to a use-after-free (UAF) on the parent socket.
Fix this by resetting newsk->sk_bpf_storage to NULL immediately after sock_copy() in sk_clone(), and remove the now redundant initialization from bpf_sk_storage_clone().
--- net/core/bpf_sk_storage.c | 2 -- net/core/sock.c | 3 +++ 2 files changed, 3 insertions(+), 2 deletions(-)
net/core/bpf_sk_storage.c +0 -2
@@ -157,8 +157,6 @@ int bpf_sk_storage_clone(const struct sock *sk, struct sock *newsk)struct bpf_local_storage_elem *selem;int ret =0 ; -RCU_INIT_POINTER (newsk->sk_bpf_storage,NULL ); -rcu_read_lock_dont_migrate (); sk_storage =rcu_dereference (sk->sk_bpf_storage);
net/core/sock.c +3 -0
@@ -2468,6 +2468,9 @@ struct sock *sk_clone_lock(const struct sock *sk, const gfp_t priority)sock_copy (newsk, sk); newsk->sk_prot_creator = prot; +#ifdef CONFIG_BPF_SYSCALL +RCU_INIT_POINTER (newsk->sk_bpf_storage,NULL ); +#endif /* SANITY */ if (likely (newsk->sk_net_refcnt)) {
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 270/621 wifi: cfg80211: use wiphy work for socket owner autodisconnect
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Cen Zhang <[email protected]>
[ Upstream commit 0c2ed186bbe14304415476d6707b747dddcd8583 ]
nl80211_netlink_notify() walks the cfg80211 wireless device list when a NETLINK_GENERIC socket is released. If the socket owns a connection, the notifier queues the embedded wdev->disconnect_wk work item.
That work is a plain work_struct today. NETDEV_GOING_DOWN cancels it, but a NETLINK_URELEASE notifier that already observed conn_owner_nlportid can queue it after that cancel returns. _cfg80211_unregister_wdev() then removes the wdev from the list and waits for RCU readers, but synchronize_net() does not drain work queued by such a reader.
Make the autodisconnect work a wiphy_work instead. The callback already needs the wiphy mutex, and wiphy_work runs under that mutex. This lets teardown cancel pending autodisconnect work while holding the mutex, without a cancel_work_sync() vs. worker locking concern.
Also cancel the wiphy work after list_del_rcu() and synchronize_net(). Any NETLINK_URELEASE notifier that had already reached the wdev list has then either queued the work and it is removed, or can no longer find the wdev.
--- include/net/cfg80211.h | 2 +- net/wireless/core.c | 7 ++++--- net/wireless/core.h | 2 +- net/wireless/nl80211.c | 3 ++- net/wireless/sme.c | 6 ++---- 5 files changed, 10 insertions(+), 10 deletions(-)
include/net/cfg80211.h +1 -1
@@ -6813,7 +6813,7 @@ struct wireless_dev {enum ieee80211_bss_type conn_bss_type;u32 conn_owner_nlportid; -struct work_struct disconnect_wk; +struct wiphy_work disconnect_wk;u8 disconnect_bssid[ETH_ALEN ];struct list_head event_list;
net/wireless/core.c +4 -3
@@ -1385,6 +1385,7 @@ static void _cfg80211_unregister_wdev(struct wireless_dev *wdev,list_del_rcu (&wdev->list);synchronize_net (); rdev->devlist_generation++; +wiphy_work_cancel (wdev->wiphy, &wdev->disconnect_wk);cfg80211_mlme_purge_registrations (wdev);
@@ -1568,7 +1569,7 @@ void cfg80211_init_wdev(struct wireless_dev *wdev) wdev->iftype == NL80211_IFTYPE_ADHOC) && !wdev->use_4addr) wdev->netdev->priv_flags |= IFF_DONT_BRIDGE; -INIT_WORK (&wdev->disconnect_wk, cfg80211_autodisconnect_wk); +wiphy_work_init (&wdev->disconnect_wk, cfg80211_autodisconnect_wk); } void cfg80211_register_wdev(struct cfg80211_registered_device *rdev,
@@ -1676,9 +1677,9 @@ static int cfg80211_netdev_notifier_call(struct notifier_block *nb, scoped_guard(wiphy, &rdev->wiphy) {cfg80211_leave (rdev, wdev);cfg80211_remove_links (wdev); +/* since we just did cfg80211_leave() nothing to do there */ +wiphy_work_cancel (wdev->wiphy, &wdev->disconnect_wk); } -/* since we just did cfg80211_leave() nothing to do there */ -cancel_work_sync (&wdev->disconnect_wk);break ;case NETDEV_DOWN :wiphy_lock (&rdev->wiphy);
net/wireless/core.h +1 -1
@@ -434,7 +434,7 @@ void __cfg80211_port_authorized(struct wireless_dev *wdev, const u8 *peer_addr, const u8 *td_bitmap, u8 td_bitmap_len);int cfg80211_mgd_wext_connect (struct cfg80211_registered_device *rdev,struct wireless_dev *wdev); -void cfg80211_autodisconnect_wk (struct work_struct *work); +void cfg80211_autodisconnect_wk (struct wiphy *wiphy,struct wiphy_work *work);/* SME implementation */ void cfg80211_conn_work (struct work_struct *work);
net/wireless/nl80211.c +2 -1
@@ -21956,7 +21956,8 @@ static int nl80211_netlink_notify(struct notifier_block * nb, wdev->nl_owner_dead = true;schedule_work (&rdev->destroy_work); }else if (wdev->conn_owner_nlportid == notify->portid) { -schedule_work (&wdev->disconnect_wk); +wiphy_work_queue (wdev->wiphy, + &wdev->disconnect_wk); }cfg80211_release_pmsr (wdev, notify->portid);
net/wireless/sme.c +2 -4
@@ -1577,13 +1577,11 @@ int cfg80211_disconnect(struct cfg80211_registered_device *rdev,* Used to clean up after the connection / connection attempt owner socket * disconnects */ -void cfg80211_autodisconnect_wk (struct work_struct *work) +void cfg80211_autodisconnect_wk (struct wiphy *wiphy,struct wiphy_work *work) {struct wireless_dev *wdev = container_of(work, struct wireless_dev, disconnect_wk); -struct cfg80211_registered_device *rdev =wiphy_to_rdev (wdev->wiphy); - -guard (wiphy)(wdev->wiphy); +struct cfg80211_registered_device *rdev =wiphy_to_rdev (wiphy);if (wdev->conn_owner_nlportid) {switch (wdev->iftype) {
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 271/621 drm/amd/display: use kvzalloc to allocate struct dc
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Honglei Huang <[email protected]>
[ Upstream commit 75050390151a14802be433c3856ddcb483cecd24 ]
struct dc has grown large over time (most of it the two inlined dc_scratch_space copies) and now sits close to the page allocator's 4 MiB contiguous allocation limit. Its actual size is not fixed by the source alone, it also depends on the compiler and the .config, so it can easily cross 4 MiB, e.g. with a newer GCC or a config change.
dc_create() allocates it with kzalloc(). Once struct dc exceeds 4 MiB the request is rounded up to order 11 (8 MiB), which is above MAX_PAGE_ORDER, so the page allocator warns and returns NULL. dc_create() then fails, DM init fails and amdgpu probe aborts with -EINVAL:
WARNING: mm/page_alloc.c:5197 at __alloc_frozen_pages_noprof+0x2f9/0x380 dc_create+0x38/0x660 [amdgpu] amdgpu_dm_init+0x2d9/0x510 [amdgpu] dm_hw_init+0x1b/0x90 [amdgpu] amdgpu_device_init.cold+0x150d/0x1e13 [amdgpu] amdgpu_driver_load_kms+0x19/0x80 [amdgpu] amdgpu_pci_probe+0x1e2/0x4c0 [amdgpu]
dc_create() then returns NULL and DM init fails, which aborts the whole GPU init and makes amdgpu probe fail with -EINVAL ("hw_init of IP block <dm> failed -22"), leaving the display unusable. The subsequent amdgpu_irq_put() warnings during teardown are just fallout of unwinding a half-initialized device.
struct dc is a software-only bookkeeping structure that is never handed to hardware DMA and is only ever kept as an opaque pointer, so it does not require physically contiguous memory. Allocate it with kvzalloc() (and free it with kvfree()) so that the allocator can fall back to vmalloc() when a contiguous allocation of that size is not available, which also avoids the MAX_PAGE_ORDER warning entirely.
v2:
- Rebase to amd-staging-drm-next.
--- drivers/gpu/drm/amd/display/dc/core/dc.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/gpu/drm/amd/display/dc/core/dc.c +3 -3
@@ -1482,7 +1482,7 @@ static void disable_vbios_mode_if_required(struct dc *dc_create (const struct dc_init_data *init_params) { -struct dc *dc =kzalloc (sizeof (*dc),GFP_KERNEL ); +struct dc *dc =kvzalloc (sizeof (*dc),GFP_KERNEL );unsigned int full_pipe_count;if (!dc)
@@ -1530,7 +1530,7 @@ struct dc *dc_create(const struct dc_init_data *init_params) destruct_dc:dc_destruct (dc); -kfree (dc); +kvfree (dc);return NULL ; }
@@ -1580,7 +1580,7 @@ void dc_deinit_callbacks(struct dc *dc)void dc_destroy (struct dc **dc) {dc_destruct (*dc); -kfree (*dc); +kvfree (*dc); *dc =NULL ; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 272/621 net/sched: Handle TC_ACT_REDIRECT from qdisc filter chains
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Jamal Hadi Salim <[email protected]>
[ Upstream commit ec48b3be2c8595dd290be883dbd4fb8b2f9f5d5e ]
When a TC filter attached to a qdisc filter chain returns TC_ACT_REDIRECT (ex: via an eBPF program calling bpf_redirect() or an act_bpf action), the redirect was silently lost i.e no qdisc classify function handled TC_ACT_REDIRECT, so the packet fell through the switch and was enqueued normally instead of being redirected.
This has been broken since bpf_redirect() was introduced for TC in commit 27b29f63058d ("bpf: add bpf_redirect() helper"). We got lucky for a long time because bpf_net_context was a per-CPU variable that was always available.
commit 401cb7dae813 ("net: Reference bpf_redirect_info via task_struct on PREEMPT_RT.") turned bpf_net_context into a task_struct member that is only set up by explicit callers. Without a caller setting it up, bpf_redirect() itself crashes with a NULL pointer dereference in bpf_net_ctx_get_ri(). However, even with bpf_net_context available, TC_ACT_REDIRECT from qdisc filter chains cannot be honored without adding skb_do_redirect() calls to every qdisc classify function, which would require changes across net/sched/. Isolate it to ebpf core where it belongs.
Instead, add a tcf_classify_qdisc() inline helper in pkt_cls.h, as a wrapper around tcf_classify() for use by qdisc classify functions and tcf_qevent_handle(). When the classify verdict is TC_ACT_REDIRECT, the wrapper converts it to TC_ACT_SHOT, dropping the packet rather than letting it continue silently. Dropping is preferred over letting the packet through because the user immediately sees packet loss. Silently passing the packet through would hide the problem and leave the user wondering why their redirect is not working.
The clsact fast path, tc_run() continues to call tcf_classify() directly and is unaffected: TC_ACT_REDIRECT is returned as-is and handled by sch_handle_egress/ingress() calling skb_do_redirect() as before.
--- include/net/pkt_cls.h | 14 +++++++++++++- net/sched/cls_api.c | 4 +--- net/sched/sch_cake.c | 2 +- net/sched/sch_drr.c | 2 +- net/sched/sch_dualpi2.c | 2 +- net/sched/sch_ets.c | 2 +- net/sched/sch_fq_codel.c | 2 +- net/sched/sch_fq_pie.c | 2 +- net/sched/sch_hfsc.c | 2 +- net/sched/sch_htb.c | 2 +- net/sched/sch_multiq.c | 2 +- net/sched/sch_prio.c | 2 +- net/sched/sch_qfq.c | 2 +- net/sched/sch_sfb.c | 2 +- net/sched/sch_sfq.c | 2 +- 15 files changed, 27 insertions(+), 17 deletions(-)
include/net/pkt_cls.h +13 -1
@@ -156,8 +156,20 @@ static inline int tcf_classify(struct sk_buff *skb, {return TC_ACT_UNSPEC ; } -#endif +static inline int tcf_classify_qdisc (struct sk_buff *skb, +const struct tcf_proto *tp, +struct tcf_result *res,bool compat_mode) +{ +int ret =tcf_classify (skb,NULL , tp, res, compat_mode); + +/* TC_ACT_REDIRECT from qdisc filter chains is not supported. +* Use BPF via tcx or mirred redirect instead. +*/ +if (unlikely (ret ==TC_ACT_REDIRECT )) + ret =TC_ACT_SHOT ; +return ret; +}static inline unsigned long __cls_set_class (unsigned long *clp,unsigned long cl)
net/sched/cls_api.c +1 -3
@@ -4082,9 +4082,7 @@ struct sk_buff *tcf_qevent_handle(struct tcf_qevent *qe, struct Qdisc *sch, stru fl =rcu_dereference_bh (qe->filter_chain); -switch (tcf_classify (skb,NULL , fl, &cl_res, false)) { -case TC_ACT_REDIRECT : - fallthrough; +switch (tcf_classify_qdisc (skb, fl, &cl_res, false)) {case TC_ACT_SHOT :qdisc_qstats_drop (sch);__qdisc_drop (skb, to_free);
net/sched/sch_cake.c +1 -1
@@ -1709,7 +1709,7 @@ static u32 cake_classify(struct Qdisc *sch, struct cake_tin_data **t, goto hash; *qerr =NET_XMIT_SUCCESS | __NET_XMIT_BYPASS; - result =tcf_classify (skb,NULL , filter, &res, false); + result =tcf_classify_qdisc (skb, filter, &res, false);if (result >=0 ) {#ifdef CONFIG_NET_CLS_ACT
net/sched/sch_drr.c +1 -1
@@ -313,7 +313,7 @@ static struct drr_class *drr_classify(struct sk_buff *skb, struct Qdisc *sch, *qerr =NET_XMIT_SUCCESS | __NET_XMIT_BYPASS; fl =rcu_dereference_bh (q->filter_list); - result =tcf_classify (skb,NULL , fl, &res, false); + result =tcf_classify_qdisc (skb, fl, &res, false);if (result >=0 ) {#ifdef CONFIG_NET_CLS_ACT switch (result) {
net/sched/sch_dualpi2.c +1 -1
@@ -367,7 +367,7 @@ static int dualpi2_skb_classify(struct dualpi2_sched_data *q,if (!fl)return NET_XMIT_SUCCESS ; - result =tcf_classify (skb,NULL , fl, &res, false); + result =tcf_classify_qdisc (skb, fl, &res, false);if (result >=0 ) {#ifdef CONFIG_NET_CLS_ACT switch (result) {
net/sched/sch_ets.c +1 -1
@@ -389,7 +389,7 @@ static struct ets_class *ets_classify(struct sk_buff *skb, struct Qdisc *sch, *qerr =NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;if (TC_H_MAJ (skb->priority) != sch->handle) { fl =rcu_dereference_bh (q->filter_list); - err =tcf_classify (skb,NULL , fl, &res, false); + err =tcf_classify_qdisc (skb, fl, &res, false);#ifdef CONFIG_NET_CLS_ACT switch (err) {case TC_ACT_STOLEN :
net/sched/sch_fq_codel.c +1 -1
@@ -91,7 +91,7 @@ static unsigned int fq_codel_classify(struct sk_buff *skb, struct Qdisc *sch,return fq_codel_hash (q, skb) +1 ; *qerr =NET_XMIT_SUCCESS | __NET_XMIT_BYPASS; - result =tcf_classify (skb,NULL , filter, &res, false); + result =tcf_classify_qdisc (skb, filter, &res, false);if (result >=0 ) {#ifdef CONFIG_NET_CLS_ACT switch (result) {
net/sched/sch_fq_pie.c +1 -1
@@ -96,7 +96,7 @@ static unsigned int fq_pie_classify(struct sk_buff *skb, struct Qdisc *sch,return fq_pie_hash (q, skb) +1 ; *qerr =NET_XMIT_SUCCESS | __NET_XMIT_BYPASS; - result =tcf_classify (skb,NULL , filter, &res, false); + result =tcf_classify_qdisc (skb, filter, &res, false);if (result >=0 ) {#ifdef CONFIG_NET_CLS_ACT switch (result) {
net/sched/sch_hfsc.c +1 -1
@@ -1154,7 +1154,7 @@ hfsc_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr) head = &q->root; drift =HFSC_CLASSIFY_MAX_DRIFT ; tcf =rcu_dereference_bh (q->root.filter_list); -while (tcf && (result =tcf_classify (skb,NULL , tcf, &res, false)) >=0 ) { +while (tcf && (result =tcf_classify_qdisc (skb, tcf, &res, false)) >=0 ) {#ifdef CONFIG_NET_CLS_ACT switch (result) {case TC_ACT_QUEUED :
net/sched/sch_htb.c +1 -1
@@ -243,7 +243,7 @@ static struct htb_class *htb_classify(struct sk_buff *skb, struct Qdisc *sch, } *qerr =NET_XMIT_SUCCESS | __NET_XMIT_BYPASS; -while (tcf && (result =tcf_classify (skb,NULL , tcf, &res, false)) >=0 ) { +while (tcf && (result =tcf_classify_qdisc (skb, tcf, &res, false)) >=0 ) {#ifdef CONFIG_NET_CLS_ACT switch (result) {case TC_ACT_QUEUED :
net/sched/sch_multiq.c +1 -1
@@ -36,7 +36,7 @@ multiq_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr)int err; *qerr =NET_XMIT_SUCCESS | __NET_XMIT_BYPASS; - err =tcf_classify (skb,NULL , fl, &res, false); + err =tcf_classify_qdisc (skb, fl, &res, false);#ifdef CONFIG_NET_CLS_ACT switch (err) {case TC_ACT_STOLEN :
net/sched/sch_prio.c +1 -1
@@ -39,7 +39,7 @@ prio_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr) *qerr =NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;if (TC_H_MAJ (skb->priority) != sch->handle) { fl =rcu_dereference_bh (q->filter_list); - err =tcf_classify (skb,NULL , fl, &res, false); + err =tcf_classify_qdisc (skb, fl, &res, false);#ifdef CONFIG_NET_CLS_ACT switch (err) {case TC_ACT_STOLEN :
net/sched/sch_qfq.c +1 -1
@@ -709,7 +709,7 @@ static struct qfq_class *qfq_classify(struct sk_buff *skb, struct Qdisc *sch, *qerr =NET_XMIT_SUCCESS | __NET_XMIT_BYPASS; fl =rcu_dereference_bh (q->filter_list); - result =tcf_classify (skb,NULL , fl, &res, false); + result =tcf_classify_qdisc (skb, fl, &res, false);if (result >=0 ) {#ifdef CONFIG_NET_CLS_ACT switch (result) {
net/sched/sch_sfb.c +1 -1
@@ -260,7 +260,7 @@ static bool sfb_classify(struct sk_buff *skb, struct tcf_proto *fl,struct tcf_result res;int result; - result =tcf_classify (skb,NULL , fl, &res, false); + result =tcf_classify_qdisc (skb, fl, &res, false);if (result >=0 ) {#ifdef CONFIG_NET_CLS_ACT switch (result) {
net/sched/sch_sfq.c +1 -1
@@ -171,7 +171,7 @@ static unsigned int sfq_classify(struct sk_buff *skb, struct Qdisc *sch,return sfq_hash (q, skb) +1 ; *qerr =NET_XMIT_SUCCESS | __NET_XMIT_BYPASS; - result =tcf_classify (skb,NULL , fl, &res, false); + result =tcf_classify_qdisc (skb, fl, &res, false);if (result >=0 ) {#ifdef CONFIG_NET_CLS_ACT switch (result) {
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 273/621 wifi: mac80211: validate extension-frame layout before RX
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Zhao Li <[email protected]>
[ Upstream commit 57d503ce32eccfa7650065ca4c560f7e29a2e676 ]
Extension frames only have the extension header at the regular 802.11 header offset. The generic RX path can still reach helpers and interface dispatch code that read regular header address fields before unsupported extension subtypes are dropped.
mac80211 currently only handles S1G beacon extension frames. Drop other extension subtypes before they can reach regular-header RX processing. For S1G beacons, linearize the SKB with the management-frame path and require the fixed S1G beacon header, including optional fixed fields indicated by frame control, before generic RX dispatch.
Route S1G beacons through the station/default-link RX path without regular-header station lookup. Avoid regular-header address reads in the mac80211 RX paths that process S1G extension beacons, including accept-frame, duplicate-detection, address-copy, and MLO address-translation paths.
Also make ieee80211_get_bssid() length-safe before returning the S1G source-address pointer.
--- net/mac80211/rx.c | 34 ++++++++++++++++++++++++++++++++-- net/mac80211/util.c | 3 +++ 2 files changed, 35 insertions(+), 2 deletions(-)
net/mac80211/rx.c +32 -2
@@ -1443,6 +1443,9 @@ ieee80211_rx_h_check_dup(struct ieee80211_rx_data *rx)if (status->flag &RX_FLAG_DUP_VALIDATED )return RX_CONTINUE ; +if (ieee80211_is_ext (hdr->frame_control)) +return RX_CONTINUE ; +/* * Drop duplicate 802.11 retransmissions * (IEEE 802.11-2012: 9.3.2.10 "Duplicate detection and recovery")
@@ -4387,8 +4390,12 @@ static bool ieee80211_accept_frame(struct ieee80211_rx_data *rx)struct ieee80211_hdr *hdr = (void *)skb->data;struct ieee80211_rx_status *status =IEEE80211_SKB_RXCB (skb);u8 *bssid =ieee80211_get_bssid (hdr, skb->len, sdata->vif.type); -bool multicast =is_multicast_ether_addr (hdr->addr1) || -ieee80211_is_s1g_beacon (hdr->frame_control); +bool multicast; + +if (ieee80211_is_s1g_beacon (hdr->frame_control)) +return sdata->vif.type ==NL80211_IFTYPE_STATION && bssid; + + multicast =is_multicast_ether_addr (hdr->addr1);switch (sdata->vif.type) {case NL80211_IFTYPE_STATION :
@@ -5037,6 +5044,11 @@ static bool ieee80211_prepare_and_rx_handle(struct ieee80211_rx_data *rx, hdr = (struct ieee80211_hdr *)rx->skb->data; } +if (ieee80211_is_s1g_beacon (hdr->frame_control)) { +ieee80211_invoke_rx_handlers (rx); +return true; + } + if (unlikely(rx->sta && rx->sta->sta.mlo) && is_unicast_ether_addr(hdr->addr1) && !ieee80211_is_probe_resp(hdr->frame_control) &&
@@ -5121,6 +5133,13 @@ static bool ieee80211_rx_for_interface(struct ieee80211_rx_data *rx,struct sta_info *sta;int link_id =-1 ; +if (ieee80211_is_s1g_beacon (hdr->frame_control)) { +if (!ieee80211_rx_data_set_sta (rx,NULL ,-1 )) +return false; + +return ieee80211_prepare_and_rx_handle (rx, skb, consume); + } +/* * Look up link station first, in case there's a * chance that they might have a link address that
@@ -5196,6 +5215,17 @@ static void __ieee80211_rx_handle_packet(struct ieee80211_hw *hw, err = -ENOBUFS ; else err =skb_linearize (skb); + }else if (ieee80211_is_s1g_beacon (fc)) { +size_t s1g_hdr_len = offsetof(struct ieee80211_ext , + u.s1g_beacon.variable) + +ieee80211_s1g_optional_len (fc); + +if (skb->len < s1g_hdr_len) + err = -ENOBUFS ; +else + err =skb_linearize (skb); + }else if (ieee80211_is_ext (fc)) { + err = -EINVAL ; }else { err = !pskb_may_pull (skb,ieee80211_hdrlen (fc)); }
net/mac80211/util.c +3 -0
@@ -73,6 +73,9 @@ u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len,if (ieee80211_is_s1g_beacon (fc)) {struct ieee80211_ext *ext = (void *) hdr; + if (len < offsetofend(struct ieee80211_ext, u.s1g_beacon.sa)) +return NULL ; +return ext->u.s1g_beacon.sa; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 274/621 ata: libata-core: Disable LPM on Silicon Motion MD619{H,G}XCLDE3TC
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Niklas Cassel <[email protected]>
[ Upstream commit 6ce0dd9f54ea9773c0aedfaab7b858fc68a848ba ]
According to a user report, the Silicon Motion MD619HXCLDE3TC SSD and the Silicon Motion MD619GXCLDE3TC SSD have problems with LPM.
Stable-dep-of: 462775c62019 ("ata: libata-core: Add NOLPM quirk for PNY CS900 1TB SSD")
--- drivers/ata/libata-core.c | 4 ++++ 1 file changed, 4 insertions(+)
drivers/ata/libata-core.c +4 -0
@@ -4281,6 +4281,10 @@ static const struct ata_dev_quirks_entry __ata_dev_quirks[] = {/* Apacer models with LPM issues */ { "Apacer AS340*", NULL, ATA_QUIRK_NOLPM }, +/* Silicon Motion models with LPM issues */ + { "MD619HXCLDE3TC", "TCVAID", ATA_QUIRK_NOLPM }, + { "MD619GXCLDE3TC", "TCV35D", ATA_QUIRK_NOLPM }, +/* These specific Samsung models/firmware-revs do not handle LPM well */ { "SAMSUNG MZMPC128HBFU-000MV", "CXM14M1Q", ATA_QUIRK_NOLPM }, { "SAMSUNG SSD PM830 mSATA *", "CXM13D1Q", ATA_QUIRK_NOLPM },
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 275/621 ata: libata-core: Add NOLPM quirk for PNY CS900 1TB SSD
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 462775c620197adaabc983ce847e5b9878ff4cb0 ]
The PNY CS900 1TB SSD (Phison PS3111-S11, DRAM-less) drops off the bus after entering Device-Initiated Slumber during idle. With the default med_power_with_dipm policy the link goes down (SStatus 1 SControl 300) and does not recover, forcing the filesystem read-only. Forcing max_performance keeps the link stable across prolonged idle.
Add a NOLPM quirk so link power management is disabled for this drive specifically, leaving it intact for other devices on the host.
--- drivers/ata/libata-core.c | 3 +++ 1 file changed, 3 insertions(+)
drivers/ata/libata-core.c +3 -0
@@ -4281,6 +4281,9 @@ static const struct ata_dev_quirks_entry __ata_dev_quirks[] = {/* Apacer models with LPM issues */ { "Apacer AS340*", NULL, ATA_QUIRK_NOLPM }, +/* PNY CS900 (Phison PS3111-S11, DRAM-less) drops the link on DIPM */ + { "PNY CS900 1TB SSD", NULL, ATA_QUIRK_NOLPM }, +/* Silicon Motion models with LPM issues */ { "MD619HXCLDE3TC", "TCVAID", ATA_QUIRK_NOLPM }, { "MD619GXCLDE3TC", "TCV35D", ATA_QUIRK_NOLPM },
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 276/621 accel/amdxdna: reject user command submission without a command BO
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]>
[ Upstream commit 261c1fe3327ad24508f54552c6366e3e4db82c15 ]
amdxdna_drm_submit_execbuf() passes the user-supplied command BO handle straight into amdxdna_cmd_submit() with drv_cmd == NULL. When the handle is AMDXDNA_INVALID_BO_HANDLE (0), the block that fetches job->cmd_bo is skipped, leaving it NULL, and no check rejects it on the user path (the !job->cmd_bo guard lives inside the != INVALID branch).
The job is then armed and pushed to the DRM scheduler. aie2_sched_job_run() takes the drv_cmd == NULL path and calls amdxdna_cmd_set_state(job->cmd_bo) -> amdxdna_gem_vmap(NULL) -> to_gobj(NULL)->dev, a NULL pointer dereference in the drm_sched worker. A process with access to the accel node on a system with a probed AMD NPU can trigger a kernel oops with a single AMDXDNA_EXEC_CMD ioctl (cmd_handles = 0).
Only internal driver commands (SYNC_DEBUG_BO / ATTACH_DEBUG_BO) legitimately pass AMDXDNA_INVALID_BO_HANDLE, and they always set drv_cmd. Reject the invalid handle for user submissions (drv_cmd == NULL) at the submit choke point so every user path is covered.
Found by 0sec automated security-research tooling (https://0sec.ai).
--- drivers/accel/amdxdna/amdxdna_ctx.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)
drivers/accel/amdxdna/amdxdna_ctx.c +8 -1
@@ -423,7 +423,14 @@ int amdxdna_cmd_submit(struct amdxdna_client *client, goto free_job; } }else { - job->cmd_bo =NULL ; +/* +* A command submission with the invalid handle would leave +* job->cmd_bo NULL and later fault when the scheduler +* dereferences it in amdxdna_cmd_set_state(). +*/ +XDNA_DBG (xdna,"Command BO handle required for user submission" ); + ret = -EINVAL ; + goto free_job; } ret =amdxdna_arg_bos_lookup (client, job, arg_bo_hdls, arg_bo_cnt);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 277/621 net/liquidio: drop cached VF pci_dev LUT
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Yuho Choi <[email protected]>
[ Upstream commit 5c0e3ba4f500fd4314ceb42f07f16bc445156431 ]
The PF SR-IOV enable path caches VF pci_dev pointers in dpiring_to_vfpcidev_lut[] by iterating with pci_get_device(). Those entries do not own a reference, because the iterator drops the previous device reference on each step. The cached pointer is then dereferenced later when handling OCTEON_VF_FLR_REQUEST.
Replace the cached VF mapping with runtime lookup on the mailbox DPI
ring: derive the VF index from q_no, resolve the VF via exported PCI IOV helpers, validate it with the PF pointer and VF ID, then issue pcie_flr() and drop the reference with pci_dev_put(). Remove the unused VF lookup table initialization and cleanup.
--- .../net/ethernet/cavium/liquidio/lio_main.c | 27 --------------- .../ethernet/cavium/liquidio/octeon_device.h | 3 -- .../ethernet/cavium/liquidio/octeon_mailbox.c | 33 ++++++++++++++++++- 3 files changed, 32 insertions(+), 31 deletions(-)
drivers/net/ethernet/cavium/liquidio/lio_main.c +0 -27
@@ -3791,9 +3791,7 @@ static int setup_nic_devices(struct octeon_device *octeon_dev)static int octeon_enable_sriov (struct octeon_device *oct) {unsigned int num_vfs_alloced = oct->sriov_info.num_vfs_alloced; -struct pci_dev *vfdev;int err; -u32 u;if (OCTEON_CN23XX_PF (oct) && num_vfs_alloced) { err = pci_enable_sriov(oct->pci_dev,
@@ -3806,23 +3804,6 @@ static int octeon_enable_sriov(struct octeon_device *oct)return err; } oct->sriov_info.sriov_enabled =1 ; - -/* init lookup table that maps DPI ring number to VF pci_dev -* struct pointer -*/ - u =0 ; - vfdev =pci_get_device (PCI_VENDOR_ID_CAVIUM , -OCTEON_CN23XX_VF_VID ,NULL ); -while (vfdev) { -if (vfdev->is_virtfn && - (vfdev->physfn == oct->pci_dev)) { - oct->sriov_info.dpiring_to_vfpcidev_lut[u] = - vfdev; - u += oct->sriov_info.rings_per_vf; - } - vfdev =pci_get_device (PCI_VENDOR_ID_CAVIUM , -OCTEON_CN23XX_VF_VID , vfdev); - } }return num_vfs_alloced;
@@ -3830,8 +3811,6 @@ static int octeon_enable_sriov(struct octeon_device *oct)static int lio_pci_sriov_disable (struct octeon_device *oct) { -int u; -if (pci_vfs_assigned (oct->pci_dev)) {dev_err (&oct->pci_dev->dev,"VFs are still assigned to VMs.\n" );return -EPERM ;
@@ -3839,12 +3818,6 @@ static int lio_pci_sriov_disable(struct octeon_device *oct)pci_disable_sriov (oct->pci_dev); - u =0 ; -while (u <MAX_POSSIBLE_VFS ) { - oct->sriov_info.dpiring_to_vfpcidev_lut[u] =NULL ; - u += oct->sriov_info.rings_per_vf; - } - oct->sriov_info.num_vfs_alloced =0 ;dev_info (&oct->pci_dev->dev,"oct->pf_num:%d disabled VFs\n" , oct->pf_num);
drivers/net/ethernet/cavium/liquidio/octeon_device.h +0 -3
@@ -390,9 +390,6 @@ struct octeon_sriov_info {struct lio_trusted_vf trusted_vf; -/*lookup table that maps DPI ring number to VF pci_dev struct pointer*/ -struct pci_dev *dpiring_to_vfpcidev_lut[MAX_POSSIBLE_VFS ]; -u64 vf_macaddr[MAX_POSSIBLE_VFS ];u16 vf_vlantci[MAX_POSSIBLE_VFS ];
drivers/net/ethernet/cavium/liquidio/octeon_mailbox.c +32 -1
@@ -26,6 +26,31 @@#include "octeon_mailbox.h" #include "cn23xx_pf_device.h" +static struct pci_dev *lio_vf_pci_dev_by_qno (struct octeon_device *oct,u32 q_no) +{ +struct pci_dev *vfdev =NULL ; +int vfidx; + +if (!oct->sriov_info.rings_per_vf) +return NULL ; + +if (q_no % oct->sriov_info.rings_per_vf) +return NULL ; + + vfidx = q_no / oct->sriov_info.rings_per_vf; +if (vfidx >= oct->sriov_info.num_vfs_alloced) +return NULL ; + +while ((vfdev =pci_get_device (PCI_VENDOR_ID_CAVIUM , +OCTEON_CN23XX_VF_VID , vfdev))) { +if (pci_physfn (vfdev) &&pci_physfn (vfdev) == oct->pci_dev && +pci_iov_vf_id (vfdev) == vfidx) +return vfdev; + } + +return NULL ; +} +/** * octeon_mbox_read: * @mbox: Pointer mailbox
@@ -237,6 +262,7 @@ static int octeon_mbox_process_cmd(struct octeon_mbox *mbox, struct octeon_mbox_cmd *mbox_cmd) {struct octeon_device *oct = mbox->oct_dev; +struct pci_dev *vfdev;switch (mbox_cmd->msg.s.cmd) {case OCTEON_VF_ACTIVE :
@@ -260,7 +286,12 @@ static int octeon_mbox_process_cmd(struct octeon_mbox *mbox,dev_info (&oct->pci_dev->dev,"got a request for FLR from VF that owns DPI ring %u\n" , mbox->q_no); -pcie_flr (oct->sriov_info.dpiring_to_vfpcidev_lut[mbox->q_no]); + vfdev =lio_vf_pci_dev_by_qno (oct, mbox->q_no); +if (!vfdev) +break ; + +pcie_flr (vfdev); +pci_dev_put (vfdev);break ;case OCTEON_PF_CHANGED_VF_MACADDR :
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 278/621 accel/amdxdna: Fill invalid payload for failed command
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Lizhi Hou <[email protected]>
[ Upstream commit 89ff45359abbf9d8d3c4aa3f5a57ed0be82b5a12 ]
Newer userspace applications may read the payload of a failed command to obtain detailed error information. However, the driver and old firmware versions may not support returning advanced error information. In this case, initialize the command payload with an invalid value so userspace can detect that no detailed error information is available.
Stable-dep-of: 1ba02717e821 ("accel/amdxdna: Fix VMA access race")
--- drivers/accel/amdxdna/aie2_ctx.c | 23 ++++++++--------------- drivers/accel/amdxdna/amdxdna_ctx.c | 27 +++++++++++++++++++++++++++ drivers/accel/amdxdna/amdxdna_ctx.h | 3 +++ 3 files changed, 38 insertions(+), 15 deletions(-)
drivers/accel/amdxdna/aie2_ctx.c +8 -15
@@ -204,13 +204,13 @@ aie2_sched_resp_handler(void *handle, void __iomem *data, size_t size) cmd_abo = job->cmd_bo;if (unlikely (job->job_timeout)) { -amdxdna_cmd_set_state (cmd_abo,ERT_CMD_STATE_TIMEOUT ); +amdxdna_cmd_set_error (cmd_abo, job,0 ,ERT_CMD_STATE_TIMEOUT ); ret = -EINVAL ; goto out; }if (unlikely (!data) ||unlikely (size !=sizeof (u32))) { -amdxdna_cmd_set_state (cmd_abo,ERT_CMD_STATE_ABORT ); +amdxdna_cmd_set_error (cmd_abo, job,0 ,ERT_CMD_STATE_ABORT ); ret = -EINVAL ; goto out; }
@@ -220,7 +220,7 @@ aie2_sched_resp_handler(void *handle, void __iomem *data, size_t size)if (status ==AIE2_STATUS_SUCCESS )amdxdna_cmd_set_state (cmd_abo,ERT_CMD_STATE_COMPLETED );else -amdxdna_cmd_set_state (cmd_abo,ERT_CMD_STATE_ERROR ); +amdxdna_cmd_set_error (cmd_abo, job,0 ,ERT_CMD_STATE_ERROR ); out:aie2_sched_notify (job);
@@ -264,13 +264,13 @@ aie2_sched_cmdlist_resp_handler(void *handle, void __iomem *data, size_t size) cmd_abo = job->cmd_bo;if (unlikely (job->job_timeout)) { -amdxdna_cmd_set_state (cmd_abo,ERT_CMD_STATE_TIMEOUT ); +amdxdna_cmd_set_error (cmd_abo, job,0 ,ERT_CMD_STATE_TIMEOUT ); ret = -EINVAL ; goto out; }if (unlikely (!data) ||unlikely (size !=sizeof (u32) *3 )) { -amdxdna_cmd_set_state (cmd_abo,ERT_CMD_STATE_ABORT ); +amdxdna_cmd_set_error (cmd_abo, job,0 ,ERT_CMD_STATE_ABORT ); ret = -EINVAL ; goto out; }
@@ -290,19 +290,12 @@ aie2_sched_cmdlist_resp_handler(void *handle, void __iomem *data, size_t size) fail_cmd_idx, fail_cmd_status);if (fail_cmd_status ==AIE2_STATUS_SUCCESS ) { -amdxdna_cmd_set_state (cmd_abo,ERT_CMD_STATE_ABORT ); +amdxdna_cmd_set_error (cmd_abo, job, fail_cmd_idx,ERT_CMD_STATE_ABORT ); ret = -EINVAL ; - goto out; + }else { +amdxdna_cmd_set_error (cmd_abo, job, fail_cmd_idx,ERT_CMD_STATE_ERROR ); } -amdxdna_cmd_set_state (cmd_abo,ERT_CMD_STATE_ERROR ); - -if (amdxdna_cmd_get_op (cmd_abo) ==ERT_CMD_CHAIN ) { -struct amdxdna_cmd_chain *cc =amdxdna_cmd_get_payload (cmd_abo,NULL ); - cc->error_index = fail_cmd_idx; -if (cc->error_index >= cc->command_count) - cc->error_index =0 ; - } out:aie2_sched_notify (job);return ret;
drivers/accel/amdxdna/amdxdna_ctx.c +27 -0
@@ -135,6 +135,33 @@ int amdxdna_cmd_get_cu_idx(struct amdxdna_gem_obj *abo)return -1 ; } +int amdxdna_cmd_set_error (struct amdxdna_gem_obj *abo, +struct amdxdna_sched_job *job,u32 cmd_idx, +enum ert_cmd_state error_state) +{ +struct amdxdna_client *client = job->hwctx->client; +struct amdxdna_cmd *cmd = abo->mem.kva; +struct amdxdna_cmd_chain *cc =NULL ; + + cmd->header &= ~AMDXDNA_CMD_STATE ; + cmd->header |=FIELD_PREP (AMDXDNA_CMD_STATE , error_state); + +if (amdxdna_cmd_get_op (abo) ==ERT_CMD_CHAIN ) { + cc =amdxdna_cmd_get_payload (abo,NULL ); + cc->error_index = (cmd_idx < cc->command_count) ? cmd_idx :0 ; + abo =amdxdna_gem_get_obj (client, cc->data[cc->error_index],AMDXDNA_BO_CMD ); +if (!abo) +return -EINVAL ; + cmd = abo->mem.kva; + } + +memset (cmd->data,0xff , abo->mem.size -sizeof (*cmd)); +if (cc) +amdxdna_gem_put_obj (abo); + +return 0 ; +} +/* * This should be called in close() and remove(). DO NOT call in other syscalls. * This guarantee that when hwctx and resources will be released, if user
drivers/accel/amdxdna/amdxdna_ctx.h +3 -0
@@ -139,6 +139,9 @@ amdxdna_cmd_get_state(struct amdxdna_gem_obj *abo)void *amdxdna_cmd_get_payload (struct amdxdna_gem_obj *abo,u32 *size);int amdxdna_cmd_get_cu_idx (struct amdxdna_gem_obj *abo); +int amdxdna_cmd_set_error (struct amdxdna_gem_obj *abo, +struct amdxdna_sched_job *job,u32 cmd_idx, +enum ert_cmd_state error_state);void amdxdna_sched_job_cleanup (struct amdxdna_sched_job *job);void amdxdna_hwctx_remove_all (struct amdxdna_client *client);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 279/621 accel/amdxdna: Refactor GEM BO handling and add helper APIs for address retrieval
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Max Zhen <[email protected]>
[ Upstream commit d76856beb4a4a6c42244054cd780c00f2d33de4e ]
Refactor amdxdna GEM buffer object (BO) handling to simplify address management and unify BO type semantics.
Introduce helper APIs to retrieve commonly used BO addresses:
- User virtual address (UVA)
- Kernel virtual address (KVA)
- Device address (IOVA/PA)
These helpers centralize address lookup logic and avoid duplicating BO-specific handling across submission and execution paths. This also improves readability and reduces the risk of inconsistent address handling in future changes.
As part of the refactor:
- Rename SHMEM BO type to SHARE to better reflect its usage.
- Merge CMD BO handling into SHARE, removing special-case logic for command buffers.
- Consolidate BO type handling paths to reduce code duplication and simplify maintenance.
No functional change is intended. The refactor prepares the driver for future enhancements by providing a cleaner abstraction for BO address management.
Only the user-mapping bookkeeping part of the refactor is carried here:umap_release() resets the cached user address once the last mapping is gone, and hmm_register() records it when the first mapping is added, both under notifier_lock. The remaining address-helper, BO type and UAPI changes are not needed by the follow-up fix and are dropped.
Stable-dep-of: 1ba02717e821 ("accel/amdxdna: Fix VMA access race")
--- drivers/accel/amdxdna/amdxdna_gem.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-)
drivers/accel/amdxdna/amdxdna_gem.c +7 -4
@@ -160,16 +160,19 @@ static void amdxdna_hmm_unregister(struct amdxdna_gem_obj *abo,static void amdxdna_umap_release (struct kref *ref) { struct amdxdna_umap *mapp = container_of(ref, struct amdxdna_umap, refcnt); +struct amdxdna_gem_obj *abo = mapp->abo;struct vm_area_struct *vma = mapp->vma;struct amdxdna_dev *xdna;mmu_interval_notifier_remove (&mapp->notifier); -if (is_import_bo (mapp->abo) && vma->vm_file && vma->vm_file->f_mapping) +if (is_import_bo (abo) && vma->vm_file && vma->vm_file->f_mapping)mapping_clear_unevictable (vma->vm_file->f_mapping); xdna =to_xdna_dev (to_gobj (mapp->abo)->dev);down_write (&xdna->notifier_lock);list_del (&mapp->node); +if (list_empty (&abo->mem.umap_list)) + abo->mem.userptr =AMDXDNA_INVALID_ADDR ;up_write (&xdna->notifier_lock);kvfree (mapp->range.hmm_pfns);
@@ -202,7 +205,7 @@ static int amdxdna_hmm_register(struct amdxdna_gem_obj *abo,if (!xdna->dev_info->ops->hmm_invalidate)return 0 ; - mapp =kzalloc (sizeof (*mapp),GFP_KERNEL ); + mapp =kzalloc_obj (*mapp);if (!mapp)return -ENOMEM ;
@@ -232,13 +235,13 @@ static int amdxdna_hmm_register(struct amdxdna_gem_obj *abo, mapp->abo = abo;kref_init (&mapp->refcnt); -if (abo->mem.userptr ==AMDXDNA_INVALID_ADDR ) - abo->mem.userptr = addr;INIT_WORK (&mapp->hmm_unreg_work, amdxdna_hmm_unreg_work);if (is_import_bo (abo) && vma->vm_file && vma->vm_file->f_mapping)mapping_set_unevictable (vma->vm_file->f_mapping);down_write (&xdna->notifier_lock); +if (list_empty (&abo->mem.umap_list)) + abo->mem.userptr = addr;list_add_tail (&mapp->node, &abo->mem.umap_list);up_write (&xdna->notifier_lock);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 280/621 accel/amdxdna: Fix VMA access race
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Lizhi Hou <[email protected]>
[ Upstream commit 1ba02717e821cf14ece642273958647e79698d3d ]
aie2_populate_range() and amdxdna_umap_release() access a saved VMA pointer that may have already been freed, leading to a potential use-after-free.
Remove the VMA accesses from these functions to avoid the race.
--- drivers/accel/amdxdna/aie2_ctx.c | 2 -- drivers/accel/amdxdna/amdxdna_gem.c | 31 +++++++++++++++++++---------- drivers/accel/amdxdna/amdxdna_gem.h | 1 - 3 files changed, 21 insertions(+), 13 deletions(-)
drivers/accel/amdxdna/aie2_ctx.c +0 -2
@@ -831,8 +831,6 @@ static int aie2_populate_range(struct amdxdna_gem_obj *abo)up_write (&xdna->notifier_lock); -XDNA_DBG (xdna,"populate memory range %lx %lx" , - mapp->vma->vm_start, mapp->vma->vm_end); mm = mapp->notifier.mm;if (!mmget_not_zero (mm)) {amdxdna_umap_put (mapp);
drivers/accel/amdxdna/amdxdna_gem.c +21 -10
@@ -108,7 +108,7 @@ static bool amdxdna_hmm_invalidate(struct mmu_interval_notifier *mni, xdna =to_xdna_dev (to_gobj (abo)->dev);XDNA_DBG (xdna,"Invalidating range 0x%lx, 0x%lx, type %d" , - mapp->vma->vm_start, mapp->vma->vm_end, abo->type); + mapp->range.start, mapp->range.end, abo->type);if (!mmu_notifier_range_blockable (range))return false;
@@ -137,15 +137,23 @@ static const struct mmu_interval_notifier_ops amdxdna_hmm_ops = { .invalidate = amdxdna_hmm_invalidate, }; +static inline bool compare_range (struct amdxdna_umap *mapp, +struct mm_struct *mm, +unsigned long start,unsigned long end) +{ +return (!mapp->unmapped && mapp->notifier.mm == mm && + mapp->range.start == start && mapp->range.end == end); +} +static void amdxdna_hmm_unregister (struct amdxdna_gem_obj *abo,struct vm_area_struct *vma) {struct amdxdna_dev *xdna =to_xdna_dev (to_gobj (abo)->dev);struct amdxdna_umap *mapp; -down_read (&xdna->notifier_lock); +down_write (&xdna->notifier_lock);list_for_each_entry (mapp, &abo->mem.umap_list, node) { -if (!vma || mapp->vma == vma) { +if (!vma ||compare_range (mapp, vma->vm_mm, vma->vm_start, vma->vm_end)) {if (!mapp->unmapped) {queue_work (xdna->notifier_wq, &mapp->hmm_unreg_work); mapp->unmapped = true;
@@ -154,19 +162,16 @@ static void amdxdna_hmm_unregister(struct amdxdna_gem_obj *abo,break ; } } -up_read (&xdna->notifier_lock); +up_write (&xdna->notifier_lock); }static void amdxdna_umap_release (struct kref *ref) { struct amdxdna_umap *mapp = container_of(ref, struct amdxdna_umap, refcnt);struct amdxdna_gem_obj *abo = mapp->abo; -struct vm_area_struct *vma = mapp->vma;struct amdxdna_dev *xdna;mmu_interval_notifier_remove (&mapp->notifier); -if (is_import_bo (abo) && vma->vm_file && vma->vm_file->f_mapping) -mapping_clear_unevictable (vma->vm_file->f_mapping); xdna =to_xdna_dev (to_gobj (mapp->abo)->dev);down_write (&xdna->notifier_lock);
@@ -205,6 +210,15 @@ static int amdxdna_hmm_register(struct amdxdna_gem_obj *abo,if (!xdna->dev_info->ops->hmm_invalidate)return 0 ; +down_read (&xdna->notifier_lock); +list_for_each_entry (mapp, &abo->mem.umap_list, node) { +if (compare_range (mapp, current->mm, addr, addr + len)) { +up_read (&xdna->notifier_lock); +return 0 ; + } + } +up_read (&xdna->notifier_lock); + mapp =kzalloc_obj (*mapp);if (!mapp)return -ENOMEM ;
@@ -231,13 +245,10 @@ static int amdxdna_hmm_register(struct amdxdna_gem_obj *abo, mapp->range.start = vma->vm_start; mapp->range.end = vma->vm_end; mapp->range.default_flags =HMM_PFN_REQ_FAULT ; - mapp->vma = vma; mapp->abo = abo;kref_init (&mapp->refcnt);INIT_WORK (&mapp->hmm_unreg_work, amdxdna_hmm_unreg_work); -if (is_import_bo (abo) && vma->vm_file && vma->vm_file->f_mapping) -mapping_set_unevictable (vma->vm_file->f_mapping);down_write (&xdna->notifier_lock);if (list_empty (&abo->mem.umap_list))
drivers/accel/amdxdna/amdxdna_gem.h +0 -1
@@ -9,7 +9,6 @@#include <linux/hmm.h> struct amdxdna_umap { -struct vm_area_struct *vma;struct mmu_interval_notifier notifier;struct hmm_range range;struct work_struct hmm_unreg_work;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 281/621 Bluetooth: 6lowpan: avoid untracked enable work
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Cen Zhang <[email protected]>
[ Upstream commit 352a59dc1f4a41314b6f827c17e16af7ca88271a ]
lowpan_enable_set() allocates a temporary work item and schedules do_enable_set() on system_wq, then returns to debugfs. The debugfs active operation has ended at that point, but the worker still executes module text and manipulates enable_6lowpan and listen_chan.
bt_6lowpan_exit() removes the debugfs files and immediately closes and puts listen_chan. It has no pointer to the queued work item, so it cannot cancel or flush it before tearing down the state that the worker uses.
The buggy scenario involves two paths, with each column showing the order within that path:
debugfs enable write module exit
1. lowpan_enable_set() allocates 1. bt_6lowpan_exit() removes
set_enable work the debugfs file
2. schedule_work() queues 2. bt_6lowpan_exit() closes
do_enable_set() and puts listen_chan
3. the write operation returns 3. module teardown can continue
4. do_enable_set() later runs
against stale state
Run the enable state transition synchronously in lowpan_enable_set() instead. The simple debugfs setter can sleep, and this file already handles the 6LoWPAN control write synchronously under the same set_lock. Once the setter returns, debugfs removal covers the whole operation and exit can no longer race with an untracked work item.
Validation reproduced this kernel report:
BUG: KASAN: slab-use-after-free in do_enable_set+0x113/0x2e0 Workqueue: events do_enable_set [bluetooth_6lowpan] The buggy address belongs to the object at ffff888109cb8000
--- net/bluetooth/6lowpan.c | 27 ++++----------------------- 1 file changed, 4 insertions(+), 23 deletions(-)
net/bluetooth/6lowpan.c +4 -23
@@ -1068,23 +1068,15 @@ static void disconnect_all_peers(void) }while (nchans); } -struct set_enable { -struct work_struct work; -bool flag; -}; - -static void do_enable_set (struct work_struct *work) +static void do_enable_set (bool flag) { -struct set_enable *set_enable =container_of (work, - struct set_enable, work); - -if (!set_enable->flag || enable_6lowpan != set_enable->flag) +if (!flag || enable_6lowpan != flag)/* Disconnect existing connections if 6lowpan is * disabled */ disconnect_all_peers (); - enable_6lowpan = set_enable->flag; + enable_6lowpan = flag;mutex_lock (&set_lock);if (listen_chan) {
@@ -1096,22 +1088,11 @@ static void do_enable_set(struct work_struct *work) listen_chan =bt_6lowpan_listen ();mutex_unlock (&set_lock); - -kfree (set_enable); }static int lowpan_enable_set (void *data,u64 val) { -struct set_enable *set_enable; - - set_enable =kzalloc (sizeof (*set_enable),GFP_KERNEL ); -if (!set_enable) -return -ENOMEM ; - - set_enable->flag = !!val; -INIT_WORK (&set_enable->work, do_enable_set); - -schedule_work (&set_enable->work); +do_enable_set (!!val);return 0 ; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 282/621 net/mlx5: LAG, Fix off-by-one in single-FDB error rollback
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Shay Drory <[email protected]>
[ Upstream commit 0f0e4ae6975c773f7854fc48932a267f6c79088f ]
On failure at index i, the reverse cleanup loop in mlx5_lag_create_single_fdb() starts from i, so the failed index itself is rolled back. That can operate on uninitialized state or double-tear-down a rule the add_one path already self-rolled-back.
Start the rollback from i - 1 so only successfully-installed entries are undone.
--- drivers/net/ethernet/mellanox/mlx5/core/lag/lag.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/net/ethernet/mellanox/mlx5/core/lag/lag.c +1 -1
@@ -685,7 +685,7 @@ static int mlx5_lag_create_single_fdb(struct mlx5_lag *ldev) }return 0 ; err: -mlx5_ldev_for_each_reverse (j, i, first_idx +1 , ldev) +mlx5_ldev_for_each_reverse (j, i -1 , first_idx +1 , ldev)mlx5_eswitch_offloads_single_fdb_del_one (master_esw, ldev->pf[j].dev->priv.eswitch);return err;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 283/621 iomap: release pages on atomic dio size mismatch
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Fengnan Chang <[email protected]>
[ Upstream commit 681e452683b69a8e1a571cba0f238f8ceacf55d2 ]
If bio_iov_iter_get_pages() or the bounce helper succeeds but builds a short bio, the REQ_ATOMIC size check rejects it before submission. The old error path only dropped the bio reference, leaving any pages already attached to the bio unreleased.
Release or unbounce the pages before falling through to out_put_bio on this error path.
This bug was reported by sashiko:
https://sashiko.dev/#/patchset/20260608073134.95964-1-changfengnan%40bytedance.com
--- fs/iomap/direct-io.c | 1 + 1 file changed, 1 insertion(+)
fs/iomap/direct-io.c +1 -0
@@ -470,6 +470,7 @@ static int iomap_dio_bio_iter(struct iomap_iter *iter, struct iomap_dio *dio)* bio_iov_iter_get_pages() returns an error, above. */ ret = -EINVAL ; +bio_release_pages (bio, false);bio_put (bio); goto zero_tail; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 284/621 xen/pvcalls: bound backend response req_id before indexing rsp[]
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Michael Bommarito <[email protected]>
[ Upstream commit d33846c8dcc06b83b7acdeac1e8bfbb5c0c26cb2 ]
pvcalls_front_event_handler() takes req_id directly from the backend-supplied ring response and uses it to index the fixed-size bedata->rsp[] array for a memcpy() and a store, with no range check. A malicious or buggy backend can set req_id past PVCALLS_NR_RSP_PER_RING and drive an out-of-bounds write past the bedata allocation.
req_id was also declared int while the wire field rsp->req_id is u32, so a range check on the signed value alone is insufficient: a backend req_id of 0xffffffff becomes -1, passes a >= PVCALLS_NR_RSP_PER_RING test and indexes bedata->rsp[-1]. Declare req_id as u32 so a single bound covers both ends.
A backend that sends an out-of-range req_id has violated the wire protocol, so rather than silently dropping the response, log once and stop trusting the backend: set bedata->disabled. The event handler then ignores further responses, and the request paths that wait for a response return -EIO instead of blocking forever. This mirrors the fatal-error handling xen-netback uses (xenvif_fatal_tx_err()).
The pvcalls frontend currently trusts its backend, so this is not a classic-Xen security issue, but it matters for hardening PV frontends against malicious backends (confidential and disaggregated deployments).
Message-ID: <[email protected]>
--- drivers/xen/pvcalls-front.c | 88 ++++++++++++++++++++++++++++++++----- 1 file changed, 76 insertions(+), 12 deletions(-)
drivers/xen/pvcalls-front.c +76 -12
@@ -32,6 +32,7 @@ struct pvcalls_bedata {struct xen_pvcalls_front_ring ring;grant_ref_t ref;int irq; +bool disabled;struct list_head socket_mappings;spinlock_t socket_lock;
@@ -131,6 +132,20 @@ static inline int get_request(struct pvcalls_bedata *bedata, int *req_id)return 0 ; } +/* +* Wait for the backend's response to req_id, or for the frontend to be +* disabled because the backend violated the wire protocol. Returns 0 once +* the response has arrived, or -EIO if the frontend was disabled. +*/ +static int pvcalls_front_wait_rsp (struct pvcalls_bedata *bedata,u32 req_id) +{ +wait_event (bedata->inflight_req, +READ_ONCE (bedata->rsp[req_id].req_id) == req_id || +READ_ONCE (bedata->disabled)); + +return READ_ONCE (bedata->disabled) ? -EIO :0 ; +} +static bool pvcalls_front_write_todo (struct sock_mapping *map) {struct pvcalls_data_intf *intf = map->active.ring;
@@ -168,7 +183,8 @@ static irqreturn_t pvcalls_front_event_handler(int irq, void *dev_id)struct pvcalls_bedata *bedata;struct xen_pvcalls_response *rsp;uint8_t *src, *dst; -int req_id =0 , more =0 , done =0 ; +u32 req_id =0 ; +int more =0 , done =0 ;if (dev ==NULL )return IRQ_HANDLED ;
@@ -179,12 +195,31 @@ static irqreturn_t pvcalls_front_event_handler(int irq, void *dev_id)pvcalls_exit ();return IRQ_HANDLED ; } +if (READ_ONCE (bedata->disabled)) { +pvcalls_exit (); +return IRQ_HANDLED ; + } again:while (RING_HAS_UNCONSUMED_RESPONSES (&bedata->ring)) { rsp =RING_GET_RESPONSE (&bedata->ring, bedata->ring.rsp_cons); req_id = rsp->req_id; +if (req_id >=PVCALLS_NR_RSP_PER_RING ) { +/* +* The backend supplied a req_id that would index +* bedata->rsp[] out of bounds: a protocol violation +* from a malicious or buggy backend. Log once, stop +* trusting this backend and disable the frontend rather +* than silently dropping the response and continuing. +*/ +pr_err_once ("pvcalls: backend sent out-of-range req_id %u, disabling frontend\n" , + req_id); +WRITE_ONCE (bedata->disabled, true); + bedata->ring.rsp_cons++; + done =1 ; +break ; + }if (rsp->cmd ==PVCALLS_POLL ) {struct sock_mapping *map = (struct sock_mapping *)(uintptr_t ) rsp->u.poll.id;
@@ -217,7 +252,7 @@ static irqreturn_t pvcalls_front_event_handler(int irq, void *dev_id) }RING_FINAL_CHECK_FOR_RESPONSES (&bedata->ring, more); -if (more) +if (more && !READ_ONCE (bedata->disabled)) goto again;if (done)wake_up (&bedata->inflight_req);
@@ -330,8 +365,11 @@ int pvcalls_front_socket(struct socket *sock)if (notify)notify_remote_via_irq (bedata->irq); -wait_event (bedata->inflight_req, -READ_ONCE (bedata->rsp[req_id].req_id) == req_id); + ret =pvcalls_front_wait_rsp (bedata, req_id); +if (ret) { +pvcalls_exit (); +return ret; + }/* read req_id, then the content */ smp_rmb ();
@@ -477,8 +515,11 @@ int pvcalls_front_connect(struct socket *sock, struct sockaddr *addr,if (notify)notify_remote_via_irq (bedata->irq); -wait_event (bedata->inflight_req, -READ_ONCE (bedata->rsp[req_id].req_id) == req_id); + ret =pvcalls_front_wait_rsp (bedata, req_id); +if (ret) { +pvcalls_exit_sock (sock); +return ret; + }/* read req_id, then the content */ smp_rmb ();
@@ -711,8 +752,11 @@ int pvcalls_front_bind(struct socket *sock, struct sockaddr *addr, int addr_len)if (notify)notify_remote_via_irq (bedata->irq); -wait_event (bedata->inflight_req, -READ_ONCE (bedata->rsp[req_id].req_id) == req_id); + ret =pvcalls_front_wait_rsp (bedata, req_id); +if (ret) { +pvcalls_exit_sock (sock); +return ret; + }/* read req_id, then the content */ smp_rmb ();
@@ -761,8 +805,11 @@ int pvcalls_front_listen(struct socket *sock, int backlog)if (notify)notify_remote_via_irq (bedata->irq); -wait_event (bedata->inflight_req, -READ_ONCE (bedata->rsp[req_id].req_id) == req_id); + ret =pvcalls_front_wait_rsp (bedata, req_id); +if (ret) { +pvcalls_exit_sock (sock); +return ret; + }/* read req_id, then the content */ smp_rmb ();
@@ -820,6 +867,14 @@ int pvcalls_front_accept(struct socket *sock, struct socket *newsock, } } +if (READ_ONCE (bedata->disabled)) { +clear_bit (PVCALLS_FLAG_ACCEPT_INFLIGHT , + (void *)&map->passive.flags); +wake_up (&map->passive.inflight_accept_req); +pvcalls_exit_sock (sock); +return -EIO ; + } + map2 =kzalloc (sizeof (*map2),GFP_KERNEL );if (map2 ==NULL ) { clear_bit(PVCALLS_FLAG_ACCEPT_INFLIGHT,
@@ -880,10 +935,18 @@ int pvcalls_front_accept(struct socket *sock, struct socket *newsock, }if (wait_event_interruptible (bedata->inflight_req, -READ_ONCE (bedata->rsp[req_id].req_id) == req_id)) { +READ_ONCE (bedata->rsp[req_id].req_id) == req_id || +READ_ONCE (bedata->disabled))) {pvcalls_exit_sock (sock);return -EINTR ; } +if (READ_ONCE (bedata->disabled)) { +clear_bit (PVCALLS_FLAG_ACCEPT_INFLIGHT , + (void *)&map->passive.flags); +wake_up (&map->passive.inflight_accept_req); +pvcalls_exit_sock (sock); +return -EIO ; + }/* read req_id, then the content */ smp_rmb ();
@@ -1054,7 +1117,8 @@ int pvcalls_front_release(struct socket *sock)notify_remote_via_irq (bedata->irq);wait_event (bedata->inflight_req, -READ_ONCE (bedata->rsp[req_id].req_id) == req_id); +READ_ONCE (bedata->rsp[req_id].req_id) == req_id || +READ_ONCE (bedata->disabled));if (map->active_socket) {/*
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 285/621 drm/panthor: Always use the IRQ-safe variant when acquiring the fence lock
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Boris Brezillon <[email protected]>
[ Upstream commit 778c57d624974e64535ef1c9d9b4d8e5066153f4 ]
Since dma_fence objects can be shared with other subsystems, they may be accessed from hardirq context in those drivers, and we have to take that into account by also using the IRQ-safe variant when acquiring the lock.
While at it, switch to the guard model.
--- drivers/gpu/drm/panthor/panthor_sched.c | 34 ++++++++++++------------- 1 file changed, 16 insertions(+), 18 deletions(-)
drivers/gpu/drm/panthor/panthor_sched.c +16 -18
@@ -1427,7 +1427,7 @@ cs_slot_process_fault_event_locked(struct panthor_device *ptdev,u64 cs_extract = queue->iface.output->extract;struct panthor_job *job; -spin_lock (&queue->fence_ctx.lock); +guard (spinlock_irqsave)(&queue->fence_ctx.lock);list_for_each_entry (job, &queue->fence_ctx.in_flight_jobs, node) {if (cs_extract >= job->ringbuf.end)continue ;
@@ -1437,7 +1437,6 @@ cs_slot_process_fault_event_locked(struct panthor_device *ptdev,dma_fence_set_error (job->done_fence, -EINVAL ); } -spin_unlock (&queue->fence_ctx.lock); }if (group) {
@@ -2104,13 +2103,13 @@ group_term_post_processing(struct panthor_group *group)if (!queue)continue ; -spin_lock (&queue->fence_ctx.lock); -list_for_each_entry_safe (job, tmp, &queue->fence_ctx.in_flight_jobs, node) { -list_move_tail (&job->node, &faulty_jobs); -dma_fence_set_error (job->done_fence, err); -dma_fence_signal_locked (job->done_fence); + scoped_guard(spinlock_irqsave, &queue->fence_ctx.lock) { +list_for_each_entry_safe (job, tmp, &queue->fence_ctx.in_flight_jobs, node) { +list_move_tail (&job->node, &faulty_jobs); +dma_fence_set_error (job->done_fence, err); +dma_fence_signal_locked (job->done_fence); + } } -spin_unlock (&queue->fence_ctx.lock);/* Manually update the syncobj seqno to unblock waiters. */ syncobj = group->syncobjs->kmap + (i *sizeof (*syncobj));
@@ -2991,15 +2990,15 @@ static void group_sync_upd_work(struct work_struct *work) syncobj = group->syncobjs->kmap + (queue_idx *sizeof (*syncobj)); -spin_lock (&queue->fence_ctx.lock); -list_for_each_entry_safe (job, job_tmp, &queue->fence_ctx.in_flight_jobs, node) { -if (syncobj->seqno < job->done_fence->seqno) -break ; + scoped_guard(spinlock_irqsave, &queue->fence_ctx.lock) { +list_for_each_entry_safe (job, job_tmp, &queue->fence_ctx.in_flight_jobs, node) { +if (syncobj->seqno < job->done_fence->seqno) +break ; -list_move_tail (&job->node, &done_jobs); -dma_fence_signal_locked (job->done_fence); +list_move_tail (&job->node, &done_jobs); +dma_fence_signal_locked (job->done_fence); + } } -spin_unlock (&queue->fence_ctx.lock); }dma_fence_end_signalling (cookie);
@@ -3244,9 +3243,8 @@ queue_run_job(struct drm_sched_job *sched_job) job->ringbuf.end = job->ringbuf.start + (instrs.count *sizeof (u64));panthor_job_get (&job->base); -spin_lock (&queue->fence_ctx.lock); -list_add_tail (&job->node, &queue->fence_ctx.in_flight_jobs); -spin_unlock (&queue->fence_ctx.lock); + scoped_guard(spinlock_irqsave, &queue->fence_ctx.lock) +list_add_tail (&job->node, &queue->fence_ctx.in_flight_jobs);/* Make sure the ring buffer is updated before the INSERT * register.
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 286/621 tipc: fix UAF in cleanup_bearer() due to premature dst_cache_destroy()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Eric Dumazet <[email protected]>
[ Upstream commit 7116764ca53ff529335d7ab7c364a69f094b23a5 ]
TIPC UDP media bearer teardown calls dst_cache_destroy() on its replicast caches before calling synchronize_net() to wait for concurrent RCU readers (transmitters) to finish:
static void cleanup_bearer(struct work_struct *work) {
...
list_for_each_entry_safe(rcast, tmp, &ub->rcast.list, list) {
dst_cache_destroy(&rcast->dst_cache);
list_del_rcu(&rcast->list);
kfree_rcu(rcast, rcu);
}
...
dst_cache_destroy(&ub->rcast.dst_cache);
udp_tunnel_sock_release(ub->sk);
synchronize_net();...
}
This is highly buggy because dst_cache_destroy() immediately frees the per-CPU cache memory (free_percpu()) and releases the cached dst entries without any synchronization.
If a concurrent transmitter (e.g., tipc_udp_xmit()) is running on another CPU under RCU protection, it can call dst_cache_get() concurrently, leading to:
1. Use-After-Free on the per-CPU cache pointer itself (crash).
2. "rcuref - imbalanced put()" warning if it attempts to release a dst that was concurrently released by dst_cache_destroy().
Furthermore, calling kfree(ub) immediately after synchronize_net() without closing the socket first (or waiting after closing it) leaves a window where a concurrent receiver (tipc_udp_recv()) could start after synchronize_net(), access ub, and suffer a UAF when kfree(ub) runs.
To fix this, we must defer dst_cache_destroy() and kfree(ub) until after we have ensured that no more readers can see the bearer/socket and all existing readers have finished:
1. Defer rcast entry destruction (both dst_cache_destroy() and kfree()) to an RCU callback using call_rcu_hurry().
Using call_rcu_hurry() ensures the dst entries are released quickly.
2. Release the bearer socket using udp_tunnel_sock_release() (stops new receive readers).
3. Call synchronize_net() to wait for all outstanding RCU readers (both transmit and receive) to finish.
4. Now that it is safe, call dst_cache_destroy() on the main bearer cache, and free ub.
Note: 3) and 4) can be changed later in net-next to also use call_rcu_hurry() and get rid of the synchronize_net() latency.
--- net/tipc/udp_media.c | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-)
net/tipc/udp_media.c +11 -4
@@ -797,6 +797,14 @@ static int tipc_udp_enable(struct net *net, struct tipc_bearer *b,return err; } +static void rcast_free_rcu (struct rcu_head *rcu) +{ + struct udp_replicast *rcast = container_of(rcu, struct udp_replicast, rcu); + +dst_cache_destroy (&rcast->dst_cache); +kfree (rcast); +} +/* cleanup_bearer - break the socket/bearer association */ static void cleanup_bearer (struct work_struct *work) {
@@ -806,20 +814,19 @@ static void cleanup_bearer(struct work_struct *work)spin_lock_bh (&ub->rcast_lock);list_for_each_entry_safe (rcast, tmp, &ub->rcast.list, list) { -dst_cache_destroy (&rcast->dst_cache);list_del_rcu (&rcast->list); -kfree_rcu (rcast, rcu); +call_rcu_hurry (&rcast->rcu, rcast_free_rcu); } ub->disabled = true;spin_unlock_bh (&ub->rcast_lock); tn =tipc_net (sock_net (ub->ubsock->sk)); -dst_cache_destroy (&ub->rcast.dst_cache);udp_tunnel_sock_release (ub->ubsock); -/* Note: could use a call_rcu() to avoid another synchronize_net() */ synchronize_net (); + +dst_cache_destroy (&ub->rcast.dst_cache);atomic_dec (&tn->wq_count);kfree (ub); }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 287/621 bpf: net: netfilter: drop dead NULL checks
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Puranjay Mohan <[email protected]>
[ Upstream commit bddaf9adda72447061a52b328c2d4c64b327fa30 ]
bpf_xdp_ct_lookup() and bpf_skb_ct_lookup() receive bpf_tuple and opts parameter that are expected to be not NULL for real usages (see doc string above functions). They return an error if NULL is passed for opts or tuple.
The verifier will now reject programs that pass NULL to these parameters, the kfuns can assume that these are always valid pointer, so drop the NULL checks for these parameters.
Stable-dep-of: 6f6183a39533 ("bpf: Guard conntrack opts error writes")
--- net/netfilter/nf_conntrack_bpf.c | 14 ++++---------- 1 file changed, 4 insertions(+), 10 deletions(-)
net/netfilter/nf_conntrack_bpf.c +4 -10
@@ -114,8 +114,6 @@ __bpf_nf_ct_alloc_entry(struct net *net, struct bpf_sock_tuple *bpf_tuple,struct nf_conn *ct;int err; -if (!opts || !bpf_tuple) -return ERR_PTR (-EINVAL );if (!(opts_len ==NF_BPF_CT_OPTS_SZ || opts_len ==12 ))return ERR_PTR (-EINVAL );if (opts_len ==NF_BPF_CT_OPTS_SZ ) {
@@ -299,8 +297,7 @@ bpf_xdp_ct_alloc(struct xdp_md *xdp_ctx, struct bpf_sock_tuple *bpf_tuple, nfct =__bpf_nf_ct_alloc_entry (dev_net (ctx->rxq->dev), bpf_tuple, tuple__sz, opts, opts__sz,10 );if (IS_ERR (nfct)) { -if (opts) - opts->error =PTR_ERR (nfct); + opts->error =PTR_ERR (nfct);return NULL ; }
@@ -334,8 +331,7 @@ bpf_xdp_ct_lookup(struct xdp_md *xdp_ctx, struct bpf_sock_tuple *bpf_tuple, caller_net =dev_net (ctx->rxq->dev); nfct =__bpf_nf_ct_lookup (caller_net, bpf_tuple, tuple__sz, opts, opts__sz);if (IS_ERR (nfct)) { -if (opts) - opts->error =PTR_ERR (nfct); + opts->error =PTR_ERR (nfct);return NULL ; }return nfct;
@@ -367,8 +363,7 @@ bpf_skb_ct_alloc(struct __sk_buff *skb_ctx, struct bpf_sock_tuple *bpf_tuple, net = skb->dev ?dev_net (skb->dev) :sock_net (skb->sk); nfct =__bpf_nf_ct_alloc_entry (net, bpf_tuple, tuple__sz, opts, opts__sz,10 );if (IS_ERR (nfct)) { -if (opts) - opts->error =PTR_ERR (nfct); + opts->error =PTR_ERR (nfct);return NULL ; }
@@ -402,8 +397,7 @@ bpf_skb_ct_lookup(struct __sk_buff *skb_ctx, struct bpf_sock_tuple *bpf_tuple, caller_net = skb->dev ?dev_net (skb->dev) :sock_net (skb->sk); nfct =__bpf_nf_ct_lookup (caller_net, bpf_tuple, tuple__sz, opts, opts__sz);if (IS_ERR (nfct)) { -if (opts) - opts->error =PTR_ERR (nfct); + opts->error =PTR_ERR (nfct);return NULL ; }return nfct;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 288/621 bpf: Guard conntrack opts error writes
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Yiyang Chen <[email protected]>
[ Upstream commit 6f6183a39533d727deaa5061cadae6dd9e6744d0 ]
The conntrack lookup and allocation kfuncs take an opts pointer together with an opts__sz argument. The verifier checks only the memory range described by opts__sz, but the wrappers unconditionally write opts->error whenever the internal lookup or allocation helper returns an error.
For an invalid size smaller than the end of opts->error, that write can land outside the verifier-checked range. Keep returning NULL for invalid arguments, but only report the error through opts->error when the supplied size includes the field.
This preserves error reporting for the supported 12-byte and 16-byte layouts, and for other invalid sizes that still include opts->error.
--- net/netfilter/nf_conntrack_bpf.c | 35 ++++++++++++-------------------- 1 file changed, 13 insertions(+), 22 deletions(-)
net/netfilter/nf_conntrack_bpf.c +13 -22
@@ -64,6 +64,15 @@ enum { NF_BPF_CT_OPTS_SZ = 16, }; +static void *bpf_ct_opts_result (struct bpf_ct_opts *opts,u32 opts__sz,void *ret) +{ +if (!IS_ERR (ret)) +return ret; + if (opts__sz >= offsetofend(struct bpf_ct_opts, error)) + opts->error =PTR_ERR (ret); +return NULL ; +} +static int bpf_nf_ct_tuple_parse (struct bpf_sock_tuple *bpf_tuple,u32 tuple_len,u8 protonum,u8 dir,struct nf_conntrack_tuple *tuple)
@@ -296,12 +305,7 @@ bpf_xdp_ct_alloc(struct xdp_md *xdp_ctx, struct bpf_sock_tuple *bpf_tuple, nfct =__bpf_nf_ct_alloc_entry (dev_net (ctx->rxq->dev), bpf_tuple, tuple__sz, opts, opts__sz,10 ); -if (IS_ERR (nfct)) { - opts->error =PTR_ERR (nfct); -return NULL ; - } - -return (struct nf_conn___init *)nfct; +return (struct nf_conn___init *)bpf_ct_opts_result (opts, opts__sz, nfct); }/* bpf_xdp_ct_lookup - Lookup CT entry for the given tuple, and acquire a
@@ -330,11 +334,7 @@ bpf_xdp_ct_lookup(struct xdp_md *xdp_ctx, struct bpf_sock_tuple *bpf_tuple, caller_net =dev_net (ctx->rxq->dev); nfct =__bpf_nf_ct_lookup (caller_net, bpf_tuple, tuple__sz, opts, opts__sz); -if (IS_ERR (nfct)) { - opts->error =PTR_ERR (nfct); -return NULL ; - } -return nfct; +return bpf_ct_opts_result (opts, opts__sz, nfct); }/* bpf_skb_ct_alloc - Allocate a new CT entry
@@ -362,12 +362,7 @@ bpf_skb_ct_alloc(struct __sk_buff *skb_ctx, struct bpf_sock_tuple *bpf_tuple, net = skb->dev ?dev_net (skb->dev) :sock_net (skb->sk); nfct =__bpf_nf_ct_alloc_entry (net, bpf_tuple, tuple__sz, opts, opts__sz,10 ); -if (IS_ERR (nfct)) { - opts->error =PTR_ERR (nfct); -return NULL ; - } - -return (struct nf_conn___init *)nfct; +return (struct nf_conn___init *)bpf_ct_opts_result (opts, opts__sz, nfct); }/* bpf_skb_ct_lookup - Lookup CT entry for the given tuple, and acquire a
@@ -396,11 +391,7 @@ bpf_skb_ct_lookup(struct __sk_buff *skb_ctx, struct bpf_sock_tuple *bpf_tuple, caller_net = skb->dev ?dev_net (skb->dev) :sock_net (skb->sk); nfct =__bpf_nf_ct_lookup (caller_net, bpf_tuple, tuple__sz, opts, opts__sz); -if (IS_ERR (nfct)) { - opts->error =PTR_ERR (nfct); -return NULL ; - } -return nfct; +return bpf_ct_opts_result (opts, opts__sz, nfct); }/* bpf_ct_insert_entry - Add the provided entry into a CT map
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 289/621 md/raid10: fix writes_pending leak on write request failures
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Abd-Alrhman Masalkhi <[email protected]>
[ Upstream commit e045d6ed33f8faa3e3dd6dc33c62ec01e3ad275d ]
raid10_make_request() acquires a writes_pending reference with md_write_start() before dispatching write requests. Several failure paths in raid10_write_request() complete the bio and return without reaching the normal write completion path, causing the corresponding md_write_end() to be skipped.
Make raid10_write_request() return a status indicating whether the write request was successfully queued. This allows raid10_make_request() to release the writes_pending reference with md_write_end() when a write request fails.
--- drivers/md/raid10.c | 23 +++++++++++++++-------- 1 file changed, 15 insertions(+), 8 deletions(-)
drivers/md/raid10.c +15 -8
@@ -1341,7 +1341,7 @@ static void wait_blocked_dev(struct mddev *mddev, struct r10bio *r10_bio) } } -static void raid10_write_request (struct mddev *mddev,struct bio *bio, +static bool raid10_write_request (struct mddev *mddev,struct bio *bio,struct r10bio *r10_bio) {struct r10conf *conf = mddev->private;
@@ -1358,7 +1358,7 @@ static void raid10_write_request(struct mddev *mddev, struct bio *bio,/* Bail out if REQ_NOWAIT is set for the bio */ if (bio->bi_opf &REQ_NOWAIT ) {bio_wouldblock_error (bio); -return ; +return false; }for (;;) { prepare_to_wait(&conf->wait_barrier,
@@ -1374,7 +1374,7 @@ static void raid10_write_request(struct mddev *mddev, struct bio *bio, sectors = r10_bio->sectors;if (!regular_request_wait (mddev, conf, bio, sectors)) {free_r10bio (r10_bio); -return ; +return false; } if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
@@ -1391,7 +1391,7 @@ static void raid10_write_request(struct mddev *mddev, struct bio *bio,if (bio->bi_opf &REQ_NOWAIT ) {allow_barrier (conf);bio_wouldblock_error (bio); -return ; +return false; }mddev_add_trace_msg (conf->mddev,"raid10 wait reshape metadata" );
@@ -1500,7 +1500,8 @@ static void raid10_write_request(struct mddev *mddev, struct bio *bio,raid10_write_one_disk (mddev, r10_bio, bio, true, i); }one_write_done (r10_bio); -return ; +return true; + err_handle:for (k =0 ; k < i; k++) {int d = r10_bio->devs[k].devnum;
@@ -1518,10 +1519,12 @@ static void raid10_write_request(struct mddev *mddev, struct bio *bio, }raid_end_bio_io (r10_bio); +return false; } -static void __make_request (struct mddev *mddev,struct bio *bio,int sectors) +static bool __make_request (struct mddev *mddev,struct bio *bio,int sectors) { +bool ret;struct r10conf *conf = mddev->private;struct r10bio *r10_bio;
@@ -1537,10 +1540,13 @@ static void __make_request(struct mddev *mddev, struct bio *bio, int sectors)memset (r10_bio->devs,0 ,sizeof (r10_bio->devs[0 ]) * conf->geo.raid_disks); + ret = true;if (bio_data_dir (bio) ==READ )raid10_read_request (mddev, bio, r10_bio, true);else -raid10_write_request (mddev, bio, r10_bio); + ret =raid10_write_request (mddev, bio, r10_bio); + +return ret; }static void raid_end_discard_bio (struct r10bio *r10bio)
@@ -1891,7 +1897,8 @@ static bool raid10_make_request(struct mddev *mddev, struct bio *bio) sectors = chunk_sects - (bio->bi_iter.bi_sector & (chunk_sects -1 )); -__make_request (mddev, bio, sectors); +if (!__make_request (mddev, bio, sectors)) +md_write_end (mddev);/* In case raid10d snuck in to freeze_array */ wake_up_barrier (conf);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 290/621 md/raid1: fix writes_pending and barrier reference leaks on write failures
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Abd-Alrhman Masalkhi <[email protected]>
[ Upstream commit 8e065a1602511282fc0da2dc89445e0eb71a681c ]
raid1_make_request() acquires a writes_pending reference with md_write_start() before calling raid1_write_request(). Several failure paths in raid1_write_request() complete the bio and return without reaching the normal write completion path, causing the corresponding md_write_end() to be skipped.
Make raid1_write_request() return a status indicating whether the write request was successfully queued. This allows raid1_make_request() to call md_write_end() when raid1_write_request() fails.
Additionally, if wait_blocked_rdev() fails after wait_barrier() succeeds, the associated barrier reference is not released.
Call allow_barrier() before returning from that path to keep the barrier accounting balanced.
--- drivers/md/raid1.c | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-)
drivers/md/raid1.c +12 -7
@@ -1482,7 +1482,7 @@ static void raid1_start_write_behind(struct mddev *mddev, struct r1bio *r1_bio, } -static void raid1_write_request (struct mddev *mddev,struct bio *bio, +static bool raid1_write_request (struct mddev *mddev,struct bio *bio,int max_write_sectors) {struct r1conf *conf = mddev->private;
@@ -1493,6 +1493,7 @@ static void raid1_write_request(struct mddev *mddev, struct bio *bio,int max_sectors;bool write_behind = false;bool is_discard = (bio_op (bio) ==REQ_OP_DISCARD ); +sector_t sector = bio->bi_iter.bi_sector;if (mddev_is_clustered (mddev) && mddev->cluster_ops->area_resyncing(mddev, WRITE,
@@ -1501,7 +1502,7 @@ static void raid1_write_request(struct mddev *mddev, struct bio *bio,DEFINE_WAIT (w);if (bio->bi_opf &REQ_NOWAIT ) {bio_wouldblock_error (bio); -return ; +return false; }for (;;) { prepare_to_wait(&conf->wait_barrier,
@@ -1523,12 +1524,13 @@ static void raid1_write_request(struct mddev *mddev, struct bio *bio,if (!wait_barrier (conf, bio->bi_iter.bi_sector, bio->bi_opf &REQ_NOWAIT )) {bio_wouldblock_error (bio); -return ; +return false; }if (!wait_blocked_rdev (mddev, bio)) {bio_wouldblock_error (bio); -return ; +allow_barrier (conf, sector); +return false; } r1_bio =alloc_r1bio (mddev, bio);
@@ -1687,7 +1689,8 @@ static void raid1_write_request(struct mddev *mddev, struct bio *bio,/* In case raid1d snuck in to freeze_array */ wake_up_barrier (conf); -return ; +return true; + err_handle:for (k =0 ; k < i; k++) {if (r1_bio->bios[k]) {
@@ -1697,6 +1700,7 @@ static void raid1_write_request(struct mddev *mddev, struct bio *bio, }raid_end_bio_io (r1_bio); +return false; }static bool raid1_make_request (struct mddev *mddev,struct bio *bio)
@@ -1720,8 +1724,9 @@ static bool raid1_make_request(struct mddev *mddev, struct bio *bio)if (bio_data_dir (bio) ==READ )raid1_read_request (mddev, bio, sectors,NULL );else { -md_write_start (mddev,bio); -raid1_write_request (mddev, bio, sectors); +md_write_start (mddev, bio); +if (!raid1_write_request (mddev, bio, sectors)) +md_write_end (mddev); }return true; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 291/621 i3c: mipi-i3c-hci: Fix race in i3c_hci_addr_to_dev()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Adrian Hunter <[email protected]>
[ Upstream commit 650716f23eac488c6696babdc7805f6a6b7427ad ]
i3c_hci_addr_to_dev() walks bus->devs.i3c, which is protected by bus.lock (rwsem). However, it is invoked from the MIPI I3C HCI IRQ handler, which cannot take bus.lock. This allows concurrent device addition/removal in the I3C core to modify the list while it is being traversed, potentially leading to use-after-free or crashes.
Remove the dependency on the bus device list and introduce a dedicated lookup table. Add an ibi_devs[] array indexed by DAT entry, maintained under hci->lock. Update the array when IBIs are enabled or disabled, so that it always reflects the set of devices allowed to generate IBIs. Also update when IBIs are freed, to cover the corner case when an IBI is freed without first being disabled (e.g. oldedev in i3c_master_add_i3c_dev_locked()).
Move i3c_hci_addr_to_dev() into core.c, reimplement it using the new array, and add a lockdep assertion to enforce that hci->lock is held by callers.
Demote a message in PIO and DMA IBI handling, from an error to a debug message, because there is a race window when the condition can arise normally.
--- drivers/i3c/master/mipi-i3c-hci/core.c | 37 ++++++++++++++++++++++++-- drivers/i3c/master/mipi-i3c-hci/dma.c | 12 +++++++-- drivers/i3c/master/mipi-i3c-hci/hci.h | 1 + drivers/i3c/master/mipi-i3c-hci/ibi.h | 13 +-------- drivers/i3c/master/mipi-i3c-hci/pio.c | 7 +++-- 5 files changed, 52 insertions(+), 18 deletions(-)
drivers/i3c/master/mipi-i3c-hci/core.c +35 -2
@@ -21,6 +21,7 @@#include "ext_caps.h" #include "cmd.h" #include "dat.h" +#include "ibi.h" /*
@@ -119,6 +120,7 @@ static inline struct i3c_hci *to_i3c_hci(struct i3c_master_controller *m)static int i3c_hci_bus_init (struct i3c_master_controller *m) {struct i3c_hci *hci =to_i3c_hci (m); +struct device *dev = hci->master.dev.parent;struct i3c_device_info info;int ret;
@@ -139,6 +141,10 @@ static int i3c_hci_bus_init(struct i3c_master_controller *m)if (ret)return ret; + hci->ibi_devs =devm_kcalloc (dev, hci->DAT_entries,sizeof (*hci->ibi_devs),GFP_KERNEL ); +if (!hci->ibi_devs) +return -ENOMEM ; + ret = hci->io->init (hci);if (ret)return ret;
@@ -477,14 +483,40 @@ static int i3c_hci_request_ibi(struct i3c_dev_desc *dev,return hci->io->request_ibi (hci, dev, req); } +static void __i3c_hci_disable_ibi (struct i3c_hci *hci,struct i3c_dev_desc *dev) +{ +struct i3c_hci_dev_data *dev_data =i3c_dev_get_master_data (dev); + + mipi_i3c_hci_dat_v1.set_flags (hci, dev_data->dat_idx,DAT_0_SIR_REJECT ,0 ); +scoped_guard (spinlock_irqsave, &hci->lock) + hci->ibi_devs[dev_data->dat_idx] = NULL; +} +static void i3c_hci_free_ibi (struct i3c_dev_desc *dev) {struct i3c_master_controller *m =i3c_dev_get_master (dev);struct i3c_hci *hci =to_i3c_hci (m); +/* Must ensure the IBI has been disabled */ +__i3c_hci_disable_ibi (hci, dev); hci->io->free_ibi (hci, dev); } +struct i3c_dev_desc *i3c_hci_addr_to_dev (struct i3c_hci *hci,unsigned int addr) +{ +int dat_idx; + +lockdep_assert_held (&hci->lock); + +for (dat_idx =0 ; dat_idx < hci->DAT_entries; dat_idx++) { +struct i3c_dev_desc *dev = hci->ibi_devs[dat_idx]; + +if (dev && dev->info.dyn_addr == addr) +return dev; + } +return NULL ; +} +static int i3c_hci_enable_ibi (struct i3c_dev_desc *dev) {struct i3c_master_controller *m =i3c_dev_get_master (dev);
@@ -492,6 +524,8 @@ static int i3c_hci_enable_ibi(struct i3c_dev_desc *dev)struct i3c_hci_dev_data *dev_data =i3c_dev_get_master_data (dev); mipi_i3c_hci_dat_v1.clear_flags (hci, dev_data->dat_idx,DAT_0_SIR_REJECT ,0 ); +scoped_guard (spinlock_irqsave, &hci->lock) + hci->ibi_devs[dev_data->dat_idx] = dev;return i3c_master_enec_locked (m, dev->info.dyn_addr,I3C_CCC_EVENT_SIR ); }
@@ -499,9 +533,8 @@ static int i3c_hci_disable_ibi(struct i3c_dev_desc *dev) {struct i3c_master_controller *m =i3c_dev_get_master (dev);struct i3c_hci *hci =to_i3c_hci (m); -struct i3c_hci_dev_data *dev_data =i3c_dev_get_master_data (dev); - mipi_i3c_hci_dat_v1.set_flags (hci, dev_data->dat_idx,DAT_0_SIR_REJECT ,0 ); +__i3c_hci_disable_ibi (hci, dev);return i3c_master_disec_locked (m, dev->info.dyn_addr,I3C_CCC_EVENT_SIR ); }
drivers/i3c/master/mipi-i3c-hci/dma.c +10 -2
@@ -710,10 +710,15 @@ static void hci_dma_process_ibi(struct i3c_hci *hci, struct hci_rh_data *rh) }/* determine who this is for */ +spin_lock (&hci->lock); dev =i3c_hci_addr_to_dev (hci, ibi_addr);if (!dev) { -dev_err (&hci->master.dev, -"IBI for unknown device %#x\n" , ibi_addr); +/* +* Either an IBI received just before IBI's were disabled, or +* the controller is broken. Assume the former. +*/ +dev_dbg (&hci->master.dev,"IBI when not enabled at address %#x\n" , ibi_addr); +spin_unlock (&hci->lock); goto done; }
@@ -722,6 +727,7 @@ static void hci_dma_process_ibi(struct i3c_hci *hci, struct hci_rh_data *rh)if (ibi_size > dev_ibi->max_len) {dev_err (&hci->master.dev,"IBI payload too big (%d > %d)\n" , ibi_size, dev_ibi->max_len); +spin_unlock (&hci->lock); goto done; }
@@ -738,6 +744,7 @@ static void hci_dma_process_ibi(struct i3c_hci *hci, struct hci_rh_data *rh) slot =i3c_generic_ibi_get_free_slot (dev_ibi->pool);if (!slot) {dev_err (&hci->master.dev,"no free slot for IBI\n" ); +spin_unlock (&hci->lock); goto done; }
@@ -768,6 +775,7 @@ static void hci_dma_process_ibi(struct i3c_hci *hci, struct hci_rh_data *rh) slot->dev = dev; slot->len = ibi_size;i3c_master_queue_ibi (dev, slot); +spin_unlock (&hci->lock); done:/* take care to update the ibi dequeue pointer atomically */
drivers/i3c/master/mipi-i3c-hci/hci.h +1 -0
@@ -54,6 +54,7 @@ struct i3c_hci {unsigned int DAT_entries;unsigned int DAT_entry_size;void *DAT_data; +struct i3c_dev_desc **ibi_devs;unsigned int DCT_entries;unsigned int DCT_entry_size;u8 version_major;
drivers/i3c/master/mipi-i3c-hci/ibi.h +1 -12
@@ -26,17 +26,6 @@#define IBI_DATA_LENGTH GENMASK(7, 0)/* handy helpers */ -static inline struct i3c_dev_desc * -i3c_hci_addr_to_dev (struct i3c_hci *hci,unsigned int addr) -{ -struct i3c_bus *bus =i3c_master_get_bus (&hci->master); -struct i3c_dev_desc *dev; - -i3c_bus_for_each_i3cdev (bus, dev) { -if (dev->info.dyn_addr == addr) -return dev; - } -return NULL ; -} +struct i3c_dev_desc *i3c_hci_addr_to_dev (struct i3c_hci *hci,unsigned int addr);#endif
drivers/i3c/master/mipi-i3c-hci/pio.c +5 -2
@@ -839,8 +839,11 @@ static bool hci_pio_prep_new_ibi(struct i3c_hci *hci, struct hci_pio_data *pio) dev =i3c_hci_addr_to_dev (hci, ibi->addr);if (!dev) { -dev_err (&hci->master.dev, -"IBI for unknown device %#x\n" , ibi->addr); +/* +* Either an IBI received just before IBI's were disabled, or +* the controller is broken. Assume the former. +*/ +dev_dbg (&hci->master.dev,"IBI when not enabled at address %#x\n" , ibi->addr);return true; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 292/621 fs/ntfs3: Reformat code and update terminology
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Konstantin Komarov <[email protected]>
[ Upstream commit a846cd0d0a05364c6fa5c4988e75d3b639d6dae5 ]
Reformatted the driver code according to the current .clang-format rules and updated description of used terminology. No functional changes intended.
Stable-dep-of: e8ed78f40eec ("fs/ntfs3: call _ntfs_bad_inode() when failing to rename")
--- fs/ntfs3/dir.c | 3 +-- fs/ntfs3/file.c | 6 +++--- fs/ntfs3/frecord.c | 7 ++++--- fs/ntfs3/inode.c | 19 +++++++++++-------- fs/ntfs3/namei.c | 6 +++--- fs/ntfs3/ntfs_fs.h | 6 +++--- fs/ntfs3/super.c | 31 +++++++++++++++++-------------- 7 files changed, 42 insertions(+), 36 deletions(-)
fs/ntfs3/dir.c +1 -2
@@ -334,8 +334,7 @@ static inline bool ntfs_dir_emit(struct ntfs_sb_info *sbi,* It does additional locks/reads just to get the type of name. * Should we use additional mount option to enable branch below? */ -if (fname->dup.extend_data && - ino != ni->mi.rno) { +if (fname->dup.extend_data && ino != ni->mi.rno) {struct inode *inode =ntfs_iget5 (sbi->sb, &e->ref,NULL );if (!IS_ERR_OR_NULL (inode)) { dt_type =fs_umode_to_dtype (inode->i_mode);
fs/ntfs3/file.c +3 -3
@@ -1114,8 +1114,8 @@ static ssize_t ntfs_compress_write(struct kiocb *iocb, struct iov_iter *from)size_t cp, tail =PAGE_SIZE - off; folio =page_folio (pages[ip]); - cp =copy_folio_from_iter_atomic (folio, off, -min (tail, bytes), from); + cp =copy_folio_from_iter_atomic ( + folio, off,min (tail, bytes), from);flush_dcache_folio (folio); copied += cp;
@@ -1312,7 +1312,7 @@ static int ntfs_file_release(struct inode *inode, struct file *file)if (sbi->options->prealloc && ((file->f_mode &FMODE_WRITE ) &&atomic_read (&inode->i_writecount) ==1 ) -/* +/* * The only file when inode->i_fop = &ntfs_file_operations and * init_rwsem(&ni->file.run_lock) is not called explicitly is MFT. *
fs/ntfs3/frecord.c +4 -3
@@ -3072,8 +3072,8 @@ int ni_rename(struct ntfs_inode *dir_ni, struct ntfs_inode *new_dir_ni, err =ni_add_name (new_dir_ni, ni, new_de);if (!err) { err =ni_remove_name (dir_ni, ni, de, &de2, &undo); -WARN_ON (err &&ni_remove_name (new_dir_ni, ni, new_de, &de2, - &undo)); +WARN_ON (err && +ni_remove_name (new_dir_ni, ni, new_de, &de2, &undo)); }/*
@@ -3224,7 +3224,8 @@ static bool ni_update_parent(struct ntfs_inode *ni, struct NTFS_DUP_INFO *dup,if (attr) {const struct REPARSE_POINT *rp; - rp =resident_data_ex (attr,sizeof (struct REPARSE_POINT )); + rp =resident_data_ex (attr, +sizeof (struct REPARSE_POINT ));/* If ATTR_REPARSE exists 'rp' can't be NULL. */ if (rp) dup->extend_data = rp->ReparseTag;
fs/ntfs3/inode.c +11 -8
@@ -989,9 +989,9 @@ int ntfs_write_begin(const struct kiocb *iocb, struct address_space *mapping,/* * ntfs_write_end - Address_space_operations::write_end. */ -int ntfs_write_end (const struct kiocb *iocb, -struct address_space *mapping,loff_t pos, -u32 len,u32 copied,struct folio *folio,void *fsdata) +int ntfs_write_end (const struct kiocb *iocb,struct address_space *mapping, +loff_t pos,u32 len,u32 copied,struct folio *folio, +void *fsdata) {struct inode *inode = mapping->host;struct ntfs_inode *ni =ntfs_i (inode);
@@ -1113,7 +1113,7 @@ ntfs_create_reparse_buffer(struct ntfs_sb_info *sbi, const char *symname,typeof (rp->SymbolicLinkReparseBuffer) *rs;bool is_absolute; - is_absolute = (strlen (symname) >1 && symname[1 ] ==':' ); + is_absolute = symname[0 ] && symname[1 ] ==':' ; rp =kzalloc (ntfs_reparse_bytes (2 * size +2 , is_absolute),GFP_NOFS );if (!rp)
@@ -1150,17 +1150,19 @@ ntfs_create_reparse_buffer(struct ntfs_sb_info *sbi, const char *symname,/* PrintName + SubstituteName. */ rs->SubstituteNameOffset =cpu_to_le16 (sizeof (short ) * err); - rs->SubstituteNameLength =cpu_to_le16 (sizeof (short ) * err + (is_absolute ?8 :0 )); + rs->SubstituteNameLength = +cpu_to_le16 (sizeof (short ) * err + (is_absolute ?8 :0 )); rs->PrintNameLength = rs->SubstituteNameOffset;/* * TODO: Use relative path if possible to allow Windows to * parse this path. -* 0-absolute path 1- relative path (SYMLINK_FLAG_RELATIVE). +* 0-absolute path, 1- relative path (SYMLINK_FLAG_RELATIVE). */ rs->Flags =cpu_to_le32 (is_absolute ?0 :SYMLINK_FLAG_RELATIVE ); -memmove (rp_name + err + (is_absolute ?4 :0 ), rp_name,sizeof (short ) * err); +memmove (rp_name + err + (is_absolute ?4 :0 ), rp_name, +sizeof (short ) * err);if (is_absolute) {/* Decorate SubstituteName. */
@@ -1649,7 +1651,8 @@ int ntfs_create_inode(struct mnt_idmap *idmap, struct inode *dir,* Use ni_find_attr cause layout of MFT record may be changed * in ntfs_init_acl and ntfs_save_wsl_perm. */ - attr =ni_find_attr (ni,NULL ,NULL ,ATTR_NAME ,NULL ,0 ,NULL ,NULL ); + attr =ni_find_attr (ni,NULL ,NULL ,ATTR_NAME ,NULL ,0 ,NULL , +NULL );if (attr) {struct ATTR_FILE_NAME *fn;
fs/ntfs3/namei.c +3 -3
@@ -207,13 +207,13 @@ static int ntfs_symlink(struct mnt_idmap *idmap, struct inode *dir, }/* -* ntfs_mkdir- inode_operations::mkdir +* ntfs_mkdir - inode_operations::mkdir */ static struct dentry *ntfs_mkdir (struct mnt_idmap *idmap,struct inode *dir,struct dentry *dentry,umode_t mode) { -return ERR_PTR (ntfs_create_inode (idmap, dir, dentry,NULL ,S_IFDIR | mode,0 , -NULL ,0 ,NULL )); +return ERR_PTR (ntfs_create_inode (idmap, dir, dentry,NULL , +S_IFDIR | mode,0 ,NULL ,0 ,NULL )); }/*
fs/ntfs3/ntfs_fs.h +3 -3
@@ -585,7 +585,8 @@ int ni_add_name(struct ntfs_inode *dir_ni, struct ntfs_inode *ni, struct NTFS_DE *de);int ni_rename (struct ntfs_inode *dir_ni,struct ntfs_inode *new_dir_ni, -struct ntfs_inode *ni,struct NTFS_DE *de,struct NTFS_DE *new_de); +struct ntfs_inode *ni,struct NTFS_DE *de, +struct NTFS_DE *new_de);bool ni_is_dirty (struct inode *inode);int ni_write_parents (struct ntfs_inode *ni,int sync);
@@ -711,8 +712,7 @@ int ntfs_set_size(struct inode *inode, u64 new_size);int ntfs_get_block (struct inode *inode,sector_t vbn,struct buffer_head *bh_result,int create);int ntfs_write_begin (const struct kiocb *iocb,struct address_space *mapping, -loff_t pos,u32 len,struct folio **foliop, -void **fsdata); +loff_t pos,u32 len,struct folio **foliop,void **fsdata);int ntfs_write_end (const struct kiocb *iocb,struct address_space *mapping,loff_t pos,u32 len,u32 copied,struct folio *folio,void *fsdata);
fs/ntfs3/super.c +17 -14
@@ -16,6 +16,13 @@* mi - MFT inode - One MFT record(usually 1024 bytes or 4K), consists of attributes. * ni - NTFS inode - Extends linux inode. consists of one or more mft inodes. * index - unit inside directory - 2K, 4K, <=page size, does not depend on cluster size. +* resident attribute - Attribute with content stored directly in the MFT record +* non-resident attribute - Attribute with content stored in clusters +* data_size - Size of attribute content in bytes. Equal to inode->i_size +* valid_size - Number of bytes written to the non-resident attribute +* allocated_size - Total size of clusters allocated for non-resident content +* total_size - Actual size of allocated clusters for sparse or compressed attributes +* - Constraint: valid_size <= data_size <= allocated_size * * WSL - Windows Subsystem for Linux * https://docs.microsoft.com/en-us/windows/wsl/file-permissions
@@ -289,10 +296,8 @@ static const struct fs_parameter_spec ntfs_fs_parameters[] = {/* * Load nls table or if @nls is utf8 then return NULL. * -* It is good idea to use here "const char *nls". -* But load_nls accepts "char*". */ -static struct nls_table *ntfs_load_nls (char *nls) +static struct nls_table *ntfs_load_nls (const char *nls) {struct nls_table *ret;
@@ -567,10 +572,8 @@ static void ntfs_create_procdir(struct super_block *sb)if (e) {struct ntfs_sb_info *sbi = sb->s_fs_info; -proc_create_data ("volinfo" ,0444 , e, - &ntfs3_volinfo_fops, sb); -proc_create_data ("label" ,0644 , e, - &ntfs3_label_fops, sb); +proc_create_data ("volinfo" ,0444 , e, &ntfs3_volinfo_fops, sb); +proc_create_data ("label" ,0644 , e, &ntfs3_label_fops, sb); sbi->procdir = e; } }
@@ -601,10 +604,12 @@ static void ntfs_remove_proc_root(void) } }#else -static void ntfs_create_procdir (struct super_block *sb) {} -static void ntfs_remove_procdir (struct super_block *sb) {} -static void ntfs_create_proc_root (void ) {} -static void ntfs_remove_proc_root (void ) {} +// clang-format off +static void ntfs_create_procdir (struct super_block *sb){} +static void ntfs_remove_procdir (struct super_block *sb){} +static void ntfs_create_proc_root (void ){} +static void ntfs_remove_proc_root (void ){} +// clang-format on #endif static struct kmem_cache *ntfs_inode_cachep;
@@ -1241,8 +1246,7 @@ static int ntfs_fill_super(struct super_block *sb, struct fs_context *fc) sb->s_export_op = &ntfs_export_ops; sb->s_time_gran =NTFS_TIME_GRAN ;// 100 nsec sb->s_xattr = ntfs_xattr_handlers; -if (options->nocase) -set_default_d_op (sb, &ntfs_dentry_ops); +set_default_d_op (sb, options->nocase ? &ntfs_dentry_ops :NULL ); options->nls =ntfs_load_nls (options->nls_name);if (IS_ERR (options->nls)) {
@@ -1666,7 +1670,6 @@ static int ntfs_fill_super(struct super_block *sb, struct fs_context *fc) out:ntfs3_put_sbi (sbi);kfree (boot2); -ntfs3_put_sbi (sbi);return err; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 293/621 fs/ntfs3: call _ntfs_bad_inode() when failing to rename
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Helen Koike <[email protected]>
[ Upstream commit e8ed78f40eecd0176fda71d673f6957c98e7ffbe ]
It is safe to call _ntfs_bad_inode on live inodes since:
commit 519b078998ce ("fs/ntfs3: Exclude call make_bad_inode for live nodes.")
The WARN_ON was added when it wasn't safe by:
commit d99208b91933 ("fs/ntfs3: cancle set bad inode after removing name fails")
Replace the WARN_ON with a call to _ntfs_bad_inode() to prevent further operations on the inconsistent inode.
--- fs/ntfs3/frecord.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
fs/ntfs3/frecord.c +2 -2
@@ -3072,8 +3072,8 @@ int ni_rename(struct ntfs_inode *dir_ni, struct ntfs_inode *new_dir_ni, err =ni_add_name (new_dir_ni, ni, new_de);if (!err) { err =ni_remove_name (dir_ni, ni, de, &de2, &undo); -WARN_ON (err && -ni_remove_name (new_dir_ni, ni, new_de, &de2, &undo)); +if (err &&ni_remove_name (new_dir_ni, ni, new_de, &de2, &undo)) +_ntfs_bad_inode (&ni->vfs_inode); }/*
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 294/621 net: optimize enqueue_to_backlog() for the fast path
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Eric Dumazet <[email protected]>
[ Upstream commit a086e9860ce6a751acd71dbec54d24a819dd6baa ]
Add likely() and unlikely() clauses for the common cases:
Device is running.
Queue is not full.
Queue is less than half capacity.
Add max_backlog parameter to skb_flow_limit() to avoid a second READ_ONCE(net_hotdata.max_backlog).
skb_flow_limit() does not need the backlog_lock protection, and can be called before we acquire the lock, for even better resistance to attacks.
Stable-dep-of: 46762cefe7f4 ("net: serialize netif_running() check in enqueue_to_backlog()")
--- net/core/dev.c | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-)
net/core/dev.c +10 -8
@@ -5282,14 +5282,15 @@ void kick_defer_list_purge(unsigned int cpu)int netdev_flow_limit_table_len__read_mostly = (1 <<12 );#endif -static bool skb_flow_limit (struct sk_buff *skb,unsigned int qlen) +static bool skb_flow_limit (struct sk_buff *skb,unsigned int qlen, +int max_backlog) {#ifdef CONFIG_NET_FLOW_LIMIT -struct sd_flow_limit *fl; -struct softnet_data *sd;unsigned int old_flow, new_flow; +const struct softnet_data *sd; +struct sd_flow_limit *fl; -if (qlen < (READ_ONCE (net_hotdata.max_backlog) >>1 )) +if (likely (qlen < (max_backlog >>1 )))return false; sd =this_cpu_ptr (&softnet_data);
@@ -5334,19 +5335,19 @@ static int enqueue_to_backlog(struct sk_buff *skb, int cpu,u32 tail; reason =SKB_DROP_REASON_DEV_READY ; -if (!netif_running (skb->dev)) +if (unlikely (!netif_running (skb->dev))) goto bad_dev; - reason =SKB_DROP_REASON_CPU_BACKLOG ; sd = &per_cpu (softnet_data, cpu); qlen =skb_queue_len_lockless (&sd->input_pkt_queue); max_backlog =READ_ONCE (net_hotdata.max_backlog); -if (unlikely (qlen > max_backlog)) +if (unlikely (qlen > max_backlog) || +skb_flow_limit (skb, qlen, max_backlog)) goto cpu_backlog_drop;backlog_lock_irq_save (sd, &flags); qlen =skb_queue_len (&sd->input_pkt_queue); -if (qlen <= max_backlog && !skb_flow_limit (skb, qlen)) { +if (likely (qlen <= max_backlog)) {if (!qlen) {/* Schedule NAPI for backlog device. We can use * non atomic operation as we own the queue lock.
@@ -5367,6 +5368,7 @@ static int enqueue_to_backlog(struct sk_buff *skb, int cpu,backlog_unlock_irq_restore (sd, &flags); cpu_backlog_drop: + reason =SKB_DROP_REASON_CPU_BACKLOG ;numa_drop_add (&sd->drop_counters,1 ); bad_dev:dev_core_stats_rx_dropped_inc (skb->dev);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 295/621 net: fully inline backlog_unlock_irq_restore()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Eric Dumazet <[email protected]>
[ Upstream commit 27a01c1969a5d5ed4739e45777957445af96322d ]
Some arches (like x86) do not inline spin_unlock_irqrestore().
backlog_unlock_irq_restore() is in RPS/RFS critical path, we prefer using spin_unlock() + local_irq_restore() for optimal performance.
Also change backlog_unlock_irq_restore() second argument to avoid a pointless dereference.
No difference in net/core/dev.o code size.
Stable-dep-of: 46762cefe7f4 ("net: serialize netif_running() check in enqueue_to_backlog()")
--- net/core/dev.c | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-)
net/core/dev.c +6 -7
@@ -246,12 +246,11 @@ static inline void backlog_lock_irq_disable(struct softnet_data *sd) }static inline void backlog_unlock_irq_restore (struct softnet_data *sd, -unsigned long *flags) +unsigned long flags) {if (IS_ENABLED (CONFIG_RPS ) ||use_backlog_threads ()) -spin_unlock_irqrestore (&sd->input_pkt_queue.lock, *flags); -else -local_irq_restore (*flags); +spin_unlock (&sd->input_pkt_queue.lock); +local_irq_restore (flags); }static inline void backlog_unlock_irq_enable (struct softnet_data *sd)
@@ -5271,7 +5270,7 @@ void kick_defer_list_purge(unsigned int cpu)if (!__test_and_set_bit (NAPI_STATE_SCHED , &sd->backlog.state))__napi_schedule_irqoff (&sd->backlog); -backlog_unlock_irq_restore (sd, &flags); +backlog_unlock_irq_restore (sd, flags); }else if (!cmpxchg (&sd->defer_ipi_scheduled,0 ,1 )) {smp_call_function_single_async (cpu, &sd->defer_csd);
@@ -5358,14 +5357,14 @@ static int enqueue_to_backlog(struct sk_buff *skb, int cpu, }__skb_queue_tail (&sd->input_pkt_queue, skb); tail =rps_input_queue_tail_incr (sd); -backlog_unlock_irq_restore (sd, &flags); +backlog_unlock_irq_restore (sd, flags);/* save the tail outside of the critical section */ rps_input_queue_tail_save (qtail, tail);return NET_RX_SUCCESS ; } -backlog_unlock_irq_restore (sd, &flags); +backlog_unlock_irq_restore (sd, flags); cpu_backlog_drop: reason =SKB_DROP_REASON_CPU_BACKLOG ;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 296/621 net: serialize netif_running() check in enqueue_to_backlog()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Eric Dumazet <[email protected]>
[ Upstream commit 46762cefe7f4e5bffc1eb467810a7bbb02e461d7 ]
Syzbot reported a KASAN slab-use-after-free in fib_rules_lookup().
The root cause is a race condition where packets can escape the backlog flushing during device unregistration (e.g., during netns exit).
Commit e9e4dd3267d0 ("net: do not process device backlog during unregistration") introduced a lockless netif_running() check in enqueue_to_backlog() to prevent queuing packets to an unregistering device.
However, this creates a TOCTOU race window.
A lockless transmitter (like veth_xmit) can pass
the check before dev_close() clears IFF_UP. If the transmitter is then delayed, flush_all_backlogs() can run and finish before the transmitter grabs the backlog lock and queues the packet. The packet then escapes the flush and triggers UAF later when processed.
Fix this by moving the netif_running() check inside the backlog lock. This serializes the check with the flush work (which also grabs the lock). We then either queue the packet before the flush runs (so it gets flushed), or check netif_running() after the flush/close completes (so it gets dropped).
--- net/core/dev.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
net/core/dev.c +4 -2
@@ -5334,8 +5334,6 @@ static int enqueue_to_backlog(struct sk_buff *skb, int cpu,u32 tail; reason =SKB_DROP_REASON_DEV_READY ; -if (unlikely (!netif_running (skb->dev))) - goto bad_dev; sd = &per_cpu (softnet_data, cpu);
@@ -5347,6 +5345,10 @@ static int enqueue_to_backlog(struct sk_buff *skb, int cpu,backlog_lock_irq_save (sd, &flags); qlen =skb_queue_len (&sd->input_pkt_queue);if (likely (qlen <= max_backlog)) { +if (unlikely (!netif_running (skb->dev))) { +backlog_unlock_irq_restore (sd, flags); + goto bad_dev; + }if (!qlen) {/* Schedule NAPI for backlog device. We can use * non atomic operation as we own the queue lock.
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 297/621 RDMA/bnxt_re: Add a max slot check for SQ
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Selvin Xavier <[email protected]>
[ Upstream commit dc95931b7e1326dacae547874bf38c092e5960d8 ]
The variable WQE mode must be validated against the maximum slots supported by HW. The max supported value is 64K. Adding a max and min check and fail if user supplied value is more than the max supported and zero.
--- drivers/infiniband/hw/bnxt_re/ib_verbs.c | 3 +++ drivers/infiniband/hw/bnxt_re/qplib_sp.h | 1 + 2 files changed, 4 insertions(+)
drivers/infiniband/hw/bnxt_re/ib_verbs.c +3 -0
@@ -1473,6 +1473,9 @@ static int bnxt_re_init_qp_attr(struct bnxt_re_qp *qp, struct bnxt_re_pd *pd, } qplqp->type = (u8 )qptype; qplqp->wqe_mode =bnxt_re_is_var_size_supported (rdev, uctx); +if (uctx && qplqp->wqe_mode ==BNXT_QPLIB_WQE_MODE_VARIABLE && + (!ureq->sq_slots || ureq->sq_slots >BNXT_RE_MAX_SQ_SLOTS )) +return -EINVAL ;if (init_attr->qp_type ==IB_QPT_RC ) { qplqp->max_rd_atomic = dev_attr->max_qp_rd_atom; qplqp->max_dest_rd_atomic = dev_attr->max_qp_init_rd_atom;
drivers/infiniband/hw/bnxt_re/qplib_sp.h +1 -0
@@ -367,6 +367,7 @@ int bnxt_qplib_destroy_flow(struct bnxt_qplib_res *res);#define BNXT_VAR_MAX_SLOT_ALIGN 256#define BNXT_VAR_MAX_SGE 13#define BNXT_RE_MAX_RQ_WQES 65536 +#define BNXT_RE_MAX_SQ_SLOTS 65536#define BNXT_STATIC_MAX_SGE 6
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 298/621 RDMA/bnxt_re: Free CQ toggle page after firmware teardown
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Selvin Xavier <[email protected]>
[ Upstream commit bb45e06f9914ca64ac95341a80a0c20bb8dd46a9 ]
Free the toggle page only after firmware teardown completes so that an NQ interrupt arriving during bnxt_qplib_destroy_cq() won't write the toggle value to an already-freed page. Move free_page() after bnxt_qplib_destroy_cq.
--- drivers/infiniband/hw/bnxt_re/ib_verbs.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/infiniband/hw/bnxt_re/ib_verbs.c +3 -3
@@ -3105,11 +3105,11 @@ int bnxt_re_destroy_cq(struct ib_cq *ib_cq, struct ib_udata *udata) nq = cq->qplib_cq.nq; cctx = rdev->chip_ctx; -if (cctx->modes.toggle_bits &BNXT_QPLIB_CQ_TOGGLE_BIT ) { -free_page ((unsigned long )cq->uctx_cq_page); +if (cctx->modes.toggle_bits &BNXT_QPLIB_CQ_TOGGLE_BIT )hash_del (&cq->hash_entry); - }bnxt_qplib_destroy_cq (&rdev->qplib_res, &cq->qplib_cq); +if (cctx->modes.toggle_bits &BNXT_QPLIB_CQ_TOGGLE_BIT ) +free_page ((unsigned long )cq->uctx_cq_page);bnxt_re_put_nq (rdev, nq);ib_umem_release (cq->umem);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 299/621 netfilter: nft_fwd_netdev: add device and headroom validate with neigh forwarding
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
[ Upstream commit 0a0b35f0bf10b4c2be607465f5c9c12c8681305b ]
The ttl field has been decremented already and evaluation of this rule would proceed, just drop this packet instead if there is no destination device to forwards this packet. This is exactly what nf_dup already does in this case.
Moreover, check for headroom and call skb_expand_head() like in the IP output path to ensure there is sufficient headroom when forwarding this via neigh_xmit().
Stable-dep-of: 2354e975932d ("netfilter: nf_dup_netdev: add nf_dev_xmit_recursion*() helpers and use them")
--- net/netfilter/nft_fwd_netdev.c | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-)
net/netfilter/nft_fwd_netdev.c +14 -2
@@ -101,6 +101,7 @@ static void nft_fwd_neigh_eval(const struct nft_expr *expr,unsigned int verdict =NF_STOLEN ;struct sk_buff *skb = pkt->skb;struct net_device *dev; +unsigned int hh_len;int neigh_table;switch (priv->nfproto) {
@@ -152,8 +153,19 @@ static void nft_fwd_neigh_eval(const struct nft_expr *expr, } dev =dev_get_by_index_rcu (nft_net (pkt), oif); -if (dev ==NULL ) -return ; +if (dev ==NULL ) { + verdict =NF_DROP ; + goto out; + } + + hh_len =LL_RESERVED_SPACE (dev); +if (unlikely (skb_headroom (skb) < hh_len && dev->header_ops)) { + skb =skb_expand_head (skb, hh_len); +if (!skb) { + verdict =NF_STOLEN ; + goto out; + } + } skb->dev = dev;skb_clear_tstamp (skb);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 300/621 netfilter: nft_fwd_netdev: use recursion counter in neigh egress path
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Weiming Shi <[email protected]>
[ Upstream commit 1d47b55b36d2ec73fe6901212c8b28a593c3b27c ]
nft_fwd_neigh can be used in egress chains (NF_NETDEV_EGRESS). When the forwarding rule targets the same device or two devices forward to each other, neigh_xmit() triggers dev_queue_xmit() which re-enters nf_hook_egress(), causing infinite recursion and stack overflow.
Move the nf_get_nf_dup_skb_recursion() accessor and NF_RECURSION_LIMIT to the shared header nf_dup_netdev.h as a static inline, so that nft_fwd_netdev can use the recursion counter directly without exported function call overhead. Guard neigh_xmit() with the same recursion limit already used in nf_do_netdev_egress().
[ Updated to cache the nf_get_nf_dup_skb_recursion pointer. --pablo ]
Stable-dep-of: 2354e975932d ("netfilter: nf_dup_netdev: add nf_dev_xmit_recursion*() helpers and use them")
--- include/net/netfilter/nf_dup_netdev.h | 13 +++++++++++++ net/netfilter/nf_dup_netdev.c | 16 ---------------- net/netfilter/nft_fwd_netdev.c | 8 ++++++++ 3 files changed, 21 insertions(+), 16 deletions(-)
include/net/netfilter/nf_dup_netdev.h +13 -0
@@ -3,10 +3,23 @@#define _NF_DUP_NETDEV_H_#include <net/netfilter/nf_tables.h> +#include <linux/netdevice.h> +#include <linux/sched.h> void nf_dup_netdev_egress (const struct nft_pktinfo *pkt,int oif);void nf_fwd_netdev_egress (const struct nft_pktinfo *pkt,int oif); +#define NF_RECURSION_LIMIT 2 + +static inline u8 *nf_get_nf_dup_skb_recursion (void ) +{ +#ifndef CONFIG_PREEMPT_RT +return this_cpu_ptr (&softnet_data.xmit.nf_dup_skb_recursion); +#else +return ¤t->net_xmit.nf_dup_skb_recursion; +#endif +} +struct nft_offload_ctx ;struct nft_flow_rule ;
net/netfilter/nf_dup_netdev.c +0 -16
@@ -13,22 +13,6 @@#include <net/netfilter/nf_tables_offload.h> #include <net/netfilter/nf_dup_netdev.h> -#define NF_RECURSION_LIMIT 2 - -#ifndef CONFIG_PREEMPT_RT -static u8 *nf_get_nf_dup_skb_recursion (void ) -{ -return this_cpu_ptr (&softnet_data.xmit.nf_dup_skb_recursion); -} -#else - -static u8 *nf_get_nf_dup_skb_recursion (void ) -{ -return ¤t->net_xmit.nf_dup_skb_recursion; -} - -#endif -static void nf_do_netdev_egress (struct sk_buff *skb,struct net_device *dev,enum nf_dev_hooks hook) {
net/netfilter/nft_fwd_netdev.c +8 -0
@@ -95,6 +95,7 @@ static void nft_fwd_neigh_eval(const struct nft_expr *expr,struct nft_regs *regs, const struct nft_pktinfo *pkt) { + u8 *nf_dup_skb_recursion = nf_get_nf_dup_skb_recursion();struct nft_fwd_neigh *priv =nft_expr_priv (expr);void *addr = ®s->data[priv->sreg_addr];int oif = regs->data[priv->sreg_dev];
@@ -152,6 +153,11 @@ static void nft_fwd_neigh_eval(const struct nft_expr *expr, goto out; } +if (*nf_dup_skb_recursion >NF_RECURSION_LIMIT ) { + verdict =NF_DROP ; + goto out; + } + dev =dev_get_by_index_rcu (nft_net (pkt), oif);if (dev ==NULL ) { verdict =NF_DROP ;
@@ -169,7 +175,9 @@ static void nft_fwd_neigh_eval(const struct nft_expr *expr, skb->dev = dev;skb_clear_tstamp (skb); + (*nf_dup_skb_recursion)++;neigh_xmit (neigh_table, dev, addr, skb); + (*nf_dup_skb_recursion)--; out: regs->verdict.code = verdict; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 301/621 netfilter: nf_dup_netdev: add nf_dev_xmit_recursion*() helpers and use them
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Pablo Neira Ayuso <[email protected]>
[ Upstream commit 2354e975932dabb06fad239f07a3b68fd1809737 ]
Update nft_dup and nft_fwd to use the nf_dev_xmit_recursion() helpers. This patch also disables BH when transmitting the skb to address a possible migration to different CPU leading to imbalanced decrementation of the recursion counters.
This is modeled after Florian Westphal's dev_xmit_recursion*() API available since commit 97cdcf37b57e ("net: place xmit recursion in softnet data") according to its current state in the tree.
--- include/net/netfilter/nf_dup_netdev.h | 34 +++++++++++++++++++++++---- net/netfilter/nf_dup_netdev.c | 15 ++++++------ net/netfilter/nft_fwd_netdev.c | 17 ++++++++------ 3 files changed, 47 insertions(+), 19 deletions(-)
include/net/netfilter/nf_dup_netdev.h +29 -5
@@ -11,15 +11,39 @@ void nf_fwd_netdev_egress(const struct nft_pktinfo *pkt, int oif);#define NF_RECURSION_LIMIT 2 -static inline u8 *nf_get_nf_dup_skb_recursion (void ) -{#ifndef CONFIG_PREEMPT_RT -return this_cpu_ptr (&softnet_data.xmit.nf_dup_skb_recursion); +static inline bool nf_dev_xmit_recursion (void ) +{ +return unlikely (__this_cpu_read (softnet_data.xmit.nf_dup_skb_recursion) > +NF_RECURSION_LIMIT ); +} + +static inline void nf_dev_xmit_recursion_inc (void ) +{ +__this_cpu_inc (softnet_data.xmit.nf_dup_skb_recursion); +} + +static inline void nf_dev_xmit_recursion_dec (void ) +{ +__this_cpu_dec (softnet_data.xmit.nf_dup_skb_recursion); +}#else -return ¤t->net_xmit.nf_dup_skb_recursion; -#endif +static inline bool nf_dev_xmit_recursion (void ) +{ +return unlikely (current->net_xmit.nf_dup_skb_recursion >NF_RECURSION_LIMIT ); +} + +static inline void nf_dev_xmit_recursion_inc (void ) +{ + current->net_xmit.nf_dup_skb_recursion++; } +static inline void nf_dev_xmit_recursion_dec (void ) +{ + current->net_xmit.nf_dup_skb_recursion--; +} +#endif +struct nft_offload_ctx ;struct nft_flow_rule ;
net/netfilter/nf_dup_netdev.c +8 -7
@@ -16,11 +16,6 @@static void nf_do_netdev_egress (struct sk_buff *skb,struct net_device *dev,enum nf_dev_hooks hook) { -u8 *nf_dup_skb_recursion =nf_get_nf_dup_skb_recursion (); - -if (*nf_dup_skb_recursion >NF_RECURSION_LIMIT ) - goto err; -if (hook ==NF_NETDEV_INGRESS &&skb_mac_header_was_set (skb)) {if (skb_cow_head (skb, skb->mac_len)) goto err;
@@ -30,9 +25,15 @@ static void nf_do_netdev_egress(struct sk_buff *skb, struct net_device *dev, skb->dev = dev;skb_clear_tstamp (skb); - (*nf_dup_skb_recursion)++; +local_bh_disable (); +if (nf_dev_xmit_recursion ()) { +local_bh_enable (); + goto err; + } +nf_dev_xmit_recursion_inc ();dev_queue_xmit (skb); - (*nf_dup_skb_recursion)--; +nf_dev_xmit_recursion_dec (); +local_bh_enable ();return ; err:kfree_skb (skb);
net/netfilter/nft_fwd_netdev.c +10 -7
@@ -95,7 +95,6 @@ static void nft_fwd_neigh_eval(const struct nft_expr *expr,struct nft_regs *regs, const struct nft_pktinfo *pkt) { - u8 *nf_dup_skb_recursion = nf_get_nf_dup_skb_recursion(); struct nft_fwd_neigh *priv = nft_expr_priv(expr);void *addr = ®s->data[priv->sreg_addr];int oif = regs->data[priv->sreg_dev];
@@ -153,13 +152,15 @@ static void nft_fwd_neigh_eval(const struct nft_expr *expr, goto out; } -if (*nf_dup_skb_recursion >NF_RECURSION_LIMIT ) { + dev =dev_get_by_index_rcu (nft_net (pkt), oif); +if (!dev) { verdict =NF_DROP ; goto out; } - dev =dev_get_by_index_rcu (nft_net (pkt), oif); -if (dev ==NULL ) { +local_bh_disable (); +if (nf_dev_xmit_recursion ()) { +local_bh_enable (); verdict =NF_DROP ; goto out; }
@@ -168,16 +169,18 @@ static void nft_fwd_neigh_eval(const struct nft_expr *expr,if (unlikely (skb_headroom (skb) < hh_len && dev->header_ops)) { skb =skb_expand_head (skb, hh_len);if (!skb) { - verdict =NF_STOLEN ; +local_bh_enable (); goto out; } } skb->dev = dev;skb_clear_tstamp (skb); - (*nf_dup_skb_recursion)++; + +nf_dev_xmit_recursion_inc ();neigh_xmit (neigh_table, dev, addr, skb); - (*nf_dup_skb_recursion)--; +nf_dev_xmit_recursion_dec (); +local_bh_enable (); out: regs->verdict.code = verdict; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 302/621 cxl/region: Block region delete during region creation
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Dan Williams <[email protected]>
[ Upstream commit d91feb88692e81b00cd22f0125cfcd04970b4a0b ]
Expand the range lock, rename it "regions_lock", to disable region deletion in the critical period between construct_region() and attach_target(), as well as the period between device_add() and registering the remove actions.
Otherwise, userspace can confuse the kernel. It can violate the assumption the region stays registered through the completion of cxl_add_to_region(). It can violate the assumption that devm_add_action_or_reset() is working with a live 'struct cxl_region'.
It is ok for the region to disappear outside of those windows as that mirrors device hotplug flows where the proper locks are held.
--- drivers/cxl/core/port.c | 2 +- drivers/cxl/core/region.c | 12 ++++++++++-- drivers/cxl/cxl.h | 4 ++-- 3 files changed, 13 insertions(+), 5 deletions(-)
drivers/cxl/core/port.c +1 -1
@@ -1995,7 +1995,7 @@ struct cxl_root_decoder *cxl_root_decoder_alloc(struct cxl_port *port,return ERR_PTR (rc); } -mutex_init (&cxlrd->range_lock); +mutex_init (&cxlrd->regions_lock); cxld = &cxlsd->cxld; cxld->dev.type = &cxl_decoder_root_type;
drivers/cxl/core/region.c +10 -2
@@ -2629,6 +2629,10 @@ static ssize_t create_region_store(struct device *dev, const char *buf,if (rc !=1 )return -EINVAL ; +ACQUIRE (mutex_intr, regions_lock)(&cxlrd->regions_lock); +if ((rc =ACQUIRE_ERR (mutex_intr, ®ions_lock))) +return rc; + cxlr =__create_region (cxlrd, mode, id);if (IS_ERR (cxlr))return PTR_ERR (cxlr);
@@ -2688,6 +2692,11 @@ static ssize_t delete_region_store(struct device *dev,struct cxl_root_decoder *cxlrd =to_cxl_root_decoder (dev);struct cxl_port *port =to_cxl_port (dev->parent);struct cxl_region *cxlr; +int rc; + +ACQUIRE (mutex_intr, regions_lock)(&cxlrd->regions_lock); +if ((rc =ACQUIRE_ERR (mutex_intr, ®ions_lock))) +return rc; cxlr =cxl_find_region_by_name (cxlrd, buf);if (IS_ERR (cxlr))
@@ -3575,12 +3584,11 @@ int cxl_add_to_region(struct cxl_endpoint_decoder *cxled)* Ensure that if multiple threads race to construct_region() for @hpa * one does the construction and the others add to that. */ -mutex_lock (&cxlrd->range_lock); +guard (mutex)(&cxlrd->regions_lock); struct cxl_region *cxlr __free(put_cxl_region) =cxl_find_region_by_range (cxlrd, hpa);if (!cxlr) cxlr =construct_region (cxlrd, cxled); -mutex_unlock (&cxlrd->range_lock); rc =PTR_ERR_OR_ZERO (cxlr);if (rc)
drivers/cxl/cxl.h +2 -2
@@ -449,7 +449,7 @@ struct cxl_rd_ops {* @cache_size: extended linear cache size if exists, otherwise zero. * @region_id: region id for next region provisioning event * @platform_data: platform specific configuration data -* @range_lock: sync region autodiscovery by address range +* @regions_lock: sync region discovery, construction, and deletion * @qos_class: QoS performance class cookie * @ops: CXL root decoder operations * @cxlsd: base cxl switch decoder
@@ -459,7 +459,7 @@ struct cxl_root_decoder {resource_size_t cache_size;atomic_t region_id;void *platform_data; -struct mutex range_lock; +struct mutex regions_lock;int qos_class;struct cxl_rd_ops *ops;struct cxl_switch_decoder cxlsd;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 303/621 iommu/dma-iommu: Fix wrong scatterlist length assignment in P2PDMA path
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Li RongQing <[email protected]>
[ Upstream commit db50fb87015b955a5a0c155293b2dd40d63a3b9e ]
In iommu_dma_map_sg(), when handling PCI P2PDMA cases, the DMA length of the current scatterlist segment s is incorrectly assigned from the head entry sg->length instead of the current entry s->length.
This typo causes all P2PDMA segments in the scatterlist to inherit the length of the first segment, leading to corrupted DMA lengths for multi- segment scatterlists.
Fix this by using s->length instead of sg->length.
--- drivers/iommu/dma-iommu.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/iommu/dma-iommu.c +1 -1
@@ -1441,7 +1441,7 @@ int iommu_dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,*/ s->dma_address =pci_p2pdma_bus_addr_map (&p2pdma_state,sg_phys (s)); -sg_dma_len (s) = sg->length; +sg_dma_len (s) = s->length;sg_dma_mark_bus_address (s);continue ;default :
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 304/621 ext4: add mext_check_validity() to do basic check
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Zhang Yi <[email protected]>
[ Upstream commit 22218516e462d59b27ffcfc9dd75d4f98e482c51 ]
Currently, the basic validation checks during the move extent operation are scattered across __ext4_ioctl() and ext4_move_extents(), which makes the code somewhat disorganized. Introduce a new helper, mext_check_validity(), to handle these checks. This change involves only code relocation without any logical modifications.
Message-ID: <[email protected]>
Stable-dep-of: c143957520c6 ("ext4: validate donor file superblock early in EXT4_IOC_MOVE_EXT")
--- fs/ext4/ioctl.c | 10 ----- fs/ext4/move_extent.c | 102 +++++++++++++++++++++++++++--------------- 2 files changed, 65 insertions(+), 47 deletions(-)
fs/ext4/ioctl.c +0 -10
@@ -1654,16 +1654,6 @@ static long __ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)if (!(fd_file (donor)->f_mode &FMODE_WRITE ))return -EBADF ; -if (ext4_has_feature_bigalloc (sb)) { -ext4_msg (sb,KERN_ERR , -"Online defrag not supported with bigalloc" ); -return -EOPNOTSUPP ; - }else if (IS_DAX (inode)) { -ext4_msg (sb,KERN_ERR , -"Online defrag not supported with DAX" ); -return -EOPNOTSUPP ; - } - err =mnt_want_write_file (filp);if (err)return err;
fs/ext4/move_extent.c +65 -37
114 lines not on this page · raw message
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 305/621 ext4: validate donor file superblock early in EXT4_IOC_MOVE_EXT
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Yun Zhou <[email protected]>
[ Upstream commit c143957520c6c9b5cd72e0de8b52b814f0c576fe ]
Reject the EXT4_IOC_MOVE_EXT ioctl early if the donor file does not belong to the same superblock as the original file. Currently, this validation is performed inside ext4_move_extents() by mext_check_validity(), but only after lock_two_nondirectories() has already acquired the inode locks. When the donor fd refers to a file on a different filesystem (e.g., overlayfs), this late validation creates a circular lock dependency:
CPU0 (overlayfs write) CPU1 (ext4 ioctl)
---- ----
inode_lock(ovl_inode)
mnt_want_write_file(filp)
sb_start_write(ext4_sb) [sb_writers]
backing_file_write_iter()
vfs_iter_write(real_file)
file_start_write(real_file)
sb_start_write(ext4_sb) [blocked by freeze]
lock_two_nondirectories()
inode_lock(ovl_inode) [blocked]
With a concurrent freeze operation holding sb_writers write side, this forms a deadlock cycle: CPU0 waits for freeze to complete, freeze waits for CPU1's sb_writers reader to exit, CPU1 waits for CPU0's inode lock.
Since EXT4_IOC_MOVE_EXT exchanges physical extents between two files, it fundamentally requires both files to reside on the same ext4 filesystem. Moving the superblock check before any lock acquisition is both semantically correct and eliminates the circular dependency by ensuring that cross-filesystem donor fds are rejected before sb_writers or inode locks are taken.
--- fs/ext4/ioctl.c | 3 +++ 1 file changed, 3 insertions(+)
fs/ext4/ioctl.c +3 -0
@@ -1654,6 +1654,9 @@ static long __ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)if (!(fd_file (donor)->f_mode &FMODE_WRITE ))return -EBADF ; +if (file_inode (filp)->i_sb !=file_inode (fd_file (donor))->i_sb) +return -EXDEV ; + err =mnt_want_write_file (filp);if (err)return err;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 306/621 ixgbe: do not configure xps for XDP queues
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Larysa Zaremba <[email protected]>
[ Upstream commit 7bd4355272de34c2e90e34b72c5613736d03c32b ]
netif_set_xps_queue() should not be called for an XDP Tx queue, since such queues are not netdev-exposed. On systems with number of CPUs >=64, on E610 adapter, netdev is configured with maximum number queue pairs being 63 (due to MSI-X assignment), but configuring XDP results in 64 XDP queues.
So, during XDP program load, when netif_set_xps_queue() is called for the last XDP queue, we get a WARNING with a call trace and KASAN report afterwards (if enabled).
[ 2012.699800] WARNING: net/core/dev.c:2854 at __netif_set_xps_queue+0x116a/0x1e40, CPU#36: xdpsock/103668 [...] [ 2012.700029] RIP: 0010:__netif_set_xps_queue+0x116a/0x1e40 [ 2012.700035] Code: b6 34 06 48 89 f8 83 e0 07 83 c0 01 40 38 f0 7c 09 40 84 f6 0f 85 03 0a 00 00 0f b7 44 24 40 66 43 89 44 6a 18 e9 01 fb ff ff <0f> 0b e9 f2 ee ff ff 44 8b 44 24 44 45 85 c0 74 50 4d 85 e4 0f 84 [ 2012.700040] RSP: 0018:ffff8882369aeb28 EFLAGS: 00010246 [ 2012.700046] RAX: 0000000000000000 RBX: 000000000000003f RCX: 0000000000000000 [ 2012.700050] RDX: 1ffff1111da3d891 RSI: ffff888120e34250 RDI: ffff8888ed1ec488 [ 2012.700054] RBP: ffff888913281560 R08: 0000000000000000 R09: ffff8888ed1ec000 [ 2012.700058] R10: ffff8888a2e83180 R11: 0000000000000000 R12: 0000000000007fa8 [ 2012.700061] R13: 000000000000003f R14: ffff888120e34854 R15: ffff8889132817c8 [ 2012.700065] FS: 00007fc8ea9ff740(0000) GS:ffff88884cefe000(0000) knlGS:0000000000000000 [ 2012.700069] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 2012.700073] CR2: 00007f81c8000020 CR3: 00000002299f8006 CR4: 00000000007726f0 [ 2012.700077] PKRU: 55555554 [ 2012.700080] Call Trace: [ 2012.700084] <TASK> [ 2012.700087] ? ktime_get+0x61/0x150 [ 2012.700097] ? usleep_range_state+0x133/0x1b0 [ 2012.700108] ? __pfx_usleep_range_state+0x10/0x10 [ 2012.700114] netif_set_xps_queue+0x31/0x50 [ 2012.700119] ixgbe_configure_tx_ring+0x472/0x920 [ixgbe] [...] [ 2012.700486] ixgbe_xdp+0x38f/0x750 [ixgbe]
[...]
[ 2012.701094] BUG: KASAN: slab-out-of-bounds in __netif_set_xps_queue+0x1ac5/0x1e40 [ 2012.701100] Write of size 4 at addr ffff88888d43cff8 by task xdpsock/103668
Skip XPS configuration for XDP Tx queues.
--- drivers/net/ethernet/intel/ixgbe/ixgbe_main.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/net/ethernet/intel/ixgbe/ixgbe_main.c +2 -1
@@ -3958,7 +3958,8 @@ void ixgbe_configure_tx_ring(struct ixgbe_adapter *adapter, }/* initialize XPS */ -if (!test_and_set_bit (__IXGBE_TX_XPS_INIT_DONE, &ring->state)) { +if (!ring_is_xdp (ring) && + !test_and_set_bit (__IXGBE_TX_XPS_INIT_DONE, &ring->state)) {struct ixgbe_q_vector *q_vector = ring->q_vector;if (q_vector)
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 307/621 wifi: ieee80211: split S1G definitions out
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Johannes Berg <[email protected]>
[ Upstream commit 00105d7600bfb171037783da5f26e2565c7d2106 ]
The ieee80211.h file has gotten very long, continue splitting it by putting S1G definitions into a separate file.
Stable-dep-of: b224d18b1e5d ("wifi: mac80211: bound S1G TIM PVB walk to the TIM element")
--- include/linux/ieee80211-s1g.h | 575 +++++++++++++++++++++++++++++++++ include/linux/ieee80211.h | 585 +--------------------------------- 2 files changed, 591 insertions(+), 569 deletions(-) create mode 100644 include/linux/ieee80211-s1g.h
include/linux/ieee80211-s1g.h new file +575 -0
@@ -0,0 +1,575 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* IEEE 802.11 S1G definitions +* +* Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen +* <[email protected]> +* Copyright (c) 2002-2003, Jouni Malinen <[email protected]> +* Copyright (c) 2005, Devicescape Software, Inc. +* Copyright (c) 2006, Michael Wu <[email protected]> +* Copyright (c) 2013 - 2014 Intel Mobile Communications GmbH +* Copyright (c) 2016 - 2017 Intel Deutschland GmbH +* Copyright (c) 2018 - 2025 Intel Corporation +*/ + +#ifndef LINUX_IEEE80211_S1G_H +#define LINUX_IEEE80211_S1G_H + +#include <linux/types.h> +#include <linux/if_ether.h> + +/* bits unique to S1G beacon frame control */ +#define IEEE80211_S1G_BCN_NEXT_TBTT 0x100 +#define IEEE80211_S1G_BCN_CSSID 0x200 +#define IEEE80211_S1G_BCN_ANO 0x400 + +/* see 802.11ah-2016 9.9 NDP CMAC frames */ +#define IEEE80211_S1G_1MHZ_NDP_BITS 25 +#define IEEE80211_S1G_1MHZ_NDP_BYTES 4 +#define IEEE80211_S1G_2MHZ_NDP_BITS 37 +#define IEEE80211_S1G_2MHZ_NDP_BYTES 5 + +/** +* ieee80211_is_s1g_beacon - check if IEEE80211_FTYPE_EXT && +* IEEE80211_STYPE_S1G_BEACON +* @fc: frame control bytes in little-endian byteorder +* Return: whether or not the frame is an S1G beacon +*/ +static inline bool ieee80211_is_s1g_beacon (__le16 fc) +{ +return (fc &cpu_to_le16 (IEEE80211_FCTL_FTYPE | +IEEE80211_FCTL_STYPE )) == +cpu_to_le16 (IEEE80211_FTYPE_EXT |IEEE80211_STYPE_S1G_BEACON ); +} + +/** +* ieee80211_s1g_has_next_tbtt - check if IEEE80211_S1G_BCN_NEXT_TBTT +* @fc: frame control bytes in little-endian byteorder +* Return: whether or not the frame contains the variable-length +* next TBTT field +*/ +static inline bool ieee80211_s1g_has_next_tbtt (__le16 fc) +{ +return ieee80211_is_s1g_beacon (fc) && + (fc &cpu_to_le16 (IEEE80211_S1G_BCN_NEXT_TBTT )); +} + +/** +* ieee80211_s1g_has_ano - check if IEEE80211_S1G_BCN_ANO +* @fc: frame control bytes in little-endian byteorder +* Return: whether or not the frame contains the variable-length +* ANO field +*/ +static inline bool ieee80211_s1g_has_ano (__le16 fc) +{ +return ieee80211_is_s1g_beacon (fc) && + (fc &cpu_to_le16 (IEEE80211_S1G_BCN_ANO )); +} + +/** +* ieee80211_s1g_has_cssid - check if IEEE80211_S1G_BCN_CSSID +* @fc: frame control bytes in little-endian byteorder +* Return: whether or not the frame contains the variable-length +* compressed SSID field +*/ +static inline bool ieee80211_s1g_has_cssid (__le16 fc) +{ +return ieee80211_is_s1g_beacon (fc) && + (fc &cpu_to_le16 (IEEE80211_S1G_BCN_CSSID )); +} + +/** +* enum ieee80211_s1g_chanwidth - S1G channel widths +* These are defined in IEEE802.11-2016ah Table 10-20 +* as BSS Channel Width +* +* @IEEE80211_S1G_CHANWIDTH_1MHZ: 1MHz operating channel +* @IEEE80211_S1G_CHANWIDTH_2MHZ: 2MHz operating channel +* @IEEE80211_S1G_CHANWIDTH_4MHZ: 4MHz operating channel +* @IEEE80211_S1G_CHANWIDTH_8MHZ: 8MHz operating channel +* @IEEE80211_S1G_CHANWIDTH_16MHZ: 16MHz operating channel +*/ +enum ieee80211_s1g_chanwidth { +IEEE80211_S1G_CHANWIDTH_1MHZ =0 , +IEEE80211_S1G_CHANWIDTH_2MHZ =1 , +IEEE80211_S1G_CHANWIDTH_4MHZ =3 , +IEEE80211_S1G_CHANWIDTH_8MHZ =7 , +IEEE80211_S1G_CHANWIDTH_16MHZ =15 , +}; + +/** +* enum ieee80211_s1g_pri_chanwidth - S1G primary channel widths +* described in IEEE80211-2024 Table 10-39. +* +* @IEEE80211_S1G_PRI_CHANWIDTH_2MHZ: 2MHz primary channel +* @IEEE80211_S1G_PRI_CHANWIDTH_1MHZ: 1MHz primary channel +*/ +enum ieee80211_s1g_pri_chanwidth { +IEEE80211_S1G_PRI_CHANWIDTH_2MHZ =0 , +IEEE80211_S1G_PRI_CHANWIDTH_1MHZ =1 , +}; + +/** +* struct ieee80211_s1g_bcn_compat_ie - S1G Beacon Compatibility element +* @compat_info: Compatibility Information +* @beacon_int: Beacon Interval +* @tsf_completion: TSF Completion +* +* This structure represents the payload of the "S1G Beacon +* Compatibility element" as described in IEEE Std 802.11-2020 section +* 9.4.2.196. +*/ +struct ieee80211_s1g_bcn_compat_ie { +__le16 compat_info; +__le16 beacon_int; +__le32 tsf_completion; +} __packed; + +/** +* struct ieee80211_s1g_oper_ie - S1G Operation element +* @ch_width: S1G Operation Information Channel Width +* @oper_class: S1G Operation Information Operating Class +* @primary_ch: S1G Operation Information Primary Channel Number +* @oper_ch: S1G Operation Information Channel Center Frequency +* @basic_mcs_nss: Basic S1G-MCS and NSS Set +* +* This structure represents the payload of the "S1G Operation +* element" as described in IEEE Std 802.11-2020 section 9.4.2.212. +*/ +struct ieee80211_s1g_oper_ie { +u8 ch_width; +u8 oper_class; +u8 primary_ch; +u8 oper_ch; +__le16 basic_mcs_nss; +} __packed; + +/** +* struct ieee80211_aid_response_ie - AID Response element +* @aid: AID/Group AID +* @switch_count: AID Switch Count +* @response_int: AID Response Interval +* +* This structure represents the payload of the "AID Response element" +* as described in IEEE Std 802.11-2020 section 9.4.2.194. +*/ +struct ieee80211_aid_response_ie { +__le16 aid; +u8 switch_count; +__le16 response_int; +} __packed; + +struct ieee80211_s1g_cap { +u8 capab_info[10 ]; +u8 supp_mcs_nss[5 ]; +} __packed; + +/** +* ieee80211_s1g_optional_len - determine length of optional S1G beacon fields +* @fc: frame control bytes in little-endian byteorder +* Return: total length in bytes of the optional fixed-length fields +* +* S1G beacons may contain up to three optional fixed-length fields that +* precede the variable-length elements. Whether these fields are present +* is indicated by flags in the frame control field. +* +* From IEEE 802.11-2024 section 9.3.4.3: +* - Next TBTT field may be 0 or 3 bytes +* - Short SSID field may be 0 or 4 bytes +* - Access Network Options (ANO) field may be 0 or 1 byte +*/ +static inline size_t +ieee80211_s1g_optional_len (__le16 fc) +{ +size_t len =0 ; + +if (ieee80211_s1g_has_next_tbtt (fc)) + len +=3 ; + +if (ieee80211_s1g_has_cssid (fc)) + len +=4 ; + +if (ieee80211_s1g_has_ano (fc)) + len +=1 ; + +return len; +} + +/* S1G Capabilities Information field */ +#define IEEE80211_S1G_CAPABILITY_LEN 15 + +#define S1G_CAP0_S1G_LONG BIT(0) +#define S1G_CAP0_SGI_1MHZ BIT(1) +#define S1G_CAP0_SGI_2MHZ BIT(2) +#define S1G_CAP0_SGI_4MHZ BIT(3) +#define S1G_CAP0_SGI_8MHZ BIT(4) +#define S1G_CAP0_SGI_16MHZ BIT(5) +#define S1G_CAP0_SUPP_CH_WIDTH GENMASK(7, 6) + +#define S1G_SUPP_CH_WIDTH_2 0 +#define S1G_SUPP_CH_WIDTH_4 1 +#define S1G_SUPP_CH_WIDTH_8 2 +#define S1G_SUPP_CH_WIDTH_16 3 +#define S1G_SUPP_CH_WIDTH_MAX (cap) ((1 << FIELD_GET(S1G_CAP0_SUPP_CH_WIDTH, \ + cap[0])) << 1) + +#define S1G_CAP1_RX_LDPC BIT(0) +#define S1G_CAP1_TX_STBC BIT(1) +#define S1G_CAP1_RX_STBC BIT(2) +#define S1G_CAP1_SU_BFER BIT(3) +#define S1G_CAP1_SU_BFEE BIT(4) +#define S1G_CAP1_BFEE_STS GENMASK(7, 5) + +#define S1G_CAP2_SOUNDING_DIMENSIONS GENMASK(2, 0) +#define S1G_CAP2_MU_BFER BIT(3) +#define S1G_CAP2_MU_BFEE BIT(4) +#define S1G_CAP2_PLUS_HTC_VHT BIT(5) +#define S1G_CAP2_TRAVELING_PILOT GENMASK(7, 6) + +#define S1G_CAP3_RD_RESPONDER BIT(0) +#define S1G_CAP3_HT_DELAYED_BA BIT(1) +#define S1G_CAP3_MAX_MPDU_LEN BIT(2) +#define S1G_CAP3_MAX_AMPDU_LEN_EXP GENMASK(4, 3) +#define S1G_CAP3_MIN_MPDU_START GENMASK(7, 5) + +#define S1G_CAP4_UPLINK_SYNC BIT(0) +#define S1G_CAP4_DYNAMIC_AID BIT(1) +#define S1G_CAP4_BAT BIT(2) +#define S1G_CAP4_TIME_ADE BIT(3) +#define S1G_CAP4_NON_TIM BIT(4) +#define S1G_CAP4_GROUP_AID BIT(5) +#define S1G_CAP4_STA_TYPE GENMASK(7, 6) + +#define S1G_CAP5_CENT_AUTH_CONTROL BIT(0) +#define S1G_CAP5_DIST_AUTH_CONTROL BIT(1) +#define S1G_CAP5_AMSDU BIT(2) +#define S1G_CAP5_AMPDU BIT(3) +#define S1G_CAP5_ASYMMETRIC_BA BIT(4) +#define S1G_CAP5_FLOW_CONTROL BIT(5) +#define S1G_CAP5_SECTORIZED_BEAM GENMASK(7, 6) + +#define S1G_CAP6_OBSS_MITIGATION BIT(0) +#define S1G_CAP6_FRAGMENT_BA BIT(1) +#define S1G_CAP6_NDP_PS_POLL BIT(2) +#define S1G_CAP6_RAW_OPERATION BIT(3) +#define S1G_CAP6_PAGE_SLICING BIT(4) +#define S1G_CAP6_TXOP_SHARING_IMP_ACK BIT(5) +#define S1G_CAP6_VHT_LINK_ADAPT GENMASK(7, 6) + +#define S1G_CAP7_TACK_AS_PS_POLL BIT(0) +#define S1G_CAP7_DUP_1MHZ BIT(1) +#define S1G_CAP7_MCS_NEGOTIATION BIT(2) +#define S1G_CAP7_1MHZ_CTL_RESPONSE_PREAMBLE BIT(3) +#define S1G_CAP7_NDP_BFING_REPORT_POLL BIT(4) +#define S1G_CAP7_UNSOLICITED_DYN_AID BIT(5) +#define S1G_CAP7_SECTOR_TRAINING_OPERATION BIT(6) +#define S1G_CAP7_TEMP_PS_MODE_SWITCH BIT(7) + +#define S1G_CAP8_TWT_GROUPING BIT(0) +#define S1G_CAP8_BDT BIT(1) +#define S1G_CAP8_COLOR GENMASK(4, 2) +#define S1G_CAP8_TWT_REQUEST BIT(5) +#define S1G_CAP8_TWT_RESPOND BIT(6) +#define S1G_CAP8_PV1_FRAME BIT(7) + +#define S1G_CAP9_LINK_ADAPT_PER_CONTROL_RESPONSE BIT(0) + +#define S1G_OPER_CH_WIDTH_PRIMARY BIT(0) +#define S1G_OPER_CH_WIDTH_OPER GENMASK(4, 1) +#define S1G_OPER_CH_PRIMARY_LOCATION BIT(5) + +#define S1G_2M_PRIMARY_LOCATION_LOWER 0 +#define S1G_2M_PRIMARY_LOCATION_UPPER 1 + +#define LISTEN_INT_USF GENMASK(15, 14) +#define LISTEN_INT_UI GENMASK(13, 0) + +#define IEEE80211_MAX_USF FIELD_MAX(LISTEN_INT_USF) +#define IEEE80211_MAX_UI FIELD_MAX(LISTEN_INT_UI) + +/* S1G encoding types */ +#define IEEE80211_S1G_TIM_ENC_MODE_BLOCK 0 +#define IEEE80211_S1G_TIM_ENC_MODE_SINGLE 1 +#define IEEE80211_S1G_TIM_ENC_MODE_OLB 2 + +enum ieee80211_s1g_actioncode { +WLAN_S1G_AID_SWITCH_REQUEST , +WLAN_S1G_AID_SWITCH_RESPONSE , +WLAN_S1G_SYNC_CONTROL , +WLAN_S1G_STA_INFO_ANNOUNCE , +WLAN_S1G_EDCA_PARAM_SET , +WLAN_S1G_EL_OPERATION , +WLAN_S1G_TWT_SETUP , +WLAN_S1G_TWT_TEARDOWN , +WLAN_S1G_SECT_GROUP_ID_LIST , +WLAN_S1G_SECT_ID_FEEDBACK , +WLAN_S1G_TWT_INFORMATION =11 , +}; + +/** +* ieee80211_is_s1g_short_beacon - check if frame is an S1G short beacon +* @fc: frame control bytes in little-endian byteorder +* @variable: pointer to the beacon frame elements +* @variable_len: length of the frame elements +* Return: whether or not the frame is an S1G short beacon. As per +* IEEE80211-2024 11.1.3.10.1, The S1G beacon compatibility element shall +* always be present as the first element in beacon frames generated at a +* TBTT (Target Beacon Transmission Time), so any frame not containing +* this element must have been generated at a TSBTT (Target Short Beacon +* Transmission Time) that is not a TBTT. Additionally, short beacons are +* prohibited from containing the S1G beacon compatibility element as per +* IEEE80211-2024 9.3.4.3 Table 9-76, so if we have an S1G beacon with +* either no elements or the first element is not the beacon compatibility +* element, we have a short beacon. +*/ +static inline bool ieee80211_is_s1g_short_beacon (__le16 fc,const u8 *variable, +size_t variable_len) +{ +if (!ieee80211_is_s1g_beacon (fc)) +return false; + +/* +* If the frame does not contain at least 1 element (this is perfectly +* valid in a short beacon) and is an S1G beacon, we have a short +* beacon. +*/ +if (variable_len <2 ) +return true; + +return variable[0 ] !=WLAN_EID_S1G_BCN_COMPAT ; +} + +struct s1g_tim_aid { +u16 aid; +u8 target_blk;/* Target block index */ +u8 target_subblk;/* Target subblock index */ +u8 target_subblk_bit;/* Target subblock bit */ +}; + +struct s1g_tim_enc_block { +u8 enc_mode; +bool inverse; +const u8 *ptr; +u8 len; + +/* +* For an OLB encoded block that spans multiple blocks, this +* is the offset into the span described by that encoded block. +*/ +u8 olb_blk_offset; +}; + +/* +* Helper routines to quickly extract the length of an encoded block. Validation +* is also performed to ensure the length extracted lies within the TIM. +*/ + +static inline int ieee80211_s1g_len_bitmap (const u8 *ptr,const u8 *end) +{ +u8 blkmap; +u8 n_subblks; + +if (ptr >= end) +return -EINVAL ; + + blkmap = *ptr; + n_subblks =hweight8 (blkmap); + +if (ptr +1 + n_subblks > end) +return -EINVAL ; + +return 1 + n_subblks; +} + +static inline int ieee80211_s1g_len_single (const u8 *ptr,const u8 *end) +{ +return (ptr +1 > end) ? -EINVAL :1 ; +} + +static inline int ieee80211_s1g_len_olb (const u8 *ptr,const u8 *end) +{ +if (ptr >= end) +return -EINVAL ; + +return (ptr +1 + *ptr > end) ? -EINVAL :1 + *ptr; +} + +/* +* Enumerate all encoded blocks until we find the encoded block that describes +* our target AID. OLB is a special case as a single encoded block can describe +* multiple blocks as a single encoded block. +*/ +static inline int ieee80211_s1g_find_target_block (struct s1g_tim_enc_block *enc, +const struct s1g_tim_aid *aid, +const u8 *ptr,const u8 *end) +{ +/* need at least block-control octet */ +while (ptr +1 <= end) { +u8 ctrl = *ptr++; +u8 mode = ctrl &0x03 ; +bool contains, inverse = ctrl &BIT (2 ); +u8 span, blk_off = ctrl >>3 ; +int len; + +switch (mode) { +case IEEE80211_S1G_TIM_ENC_MODE_BLOCK : + len =ieee80211_s1g_len_bitmap (ptr, end); + contains = blk_off == aid->target_blk; +break ; +case IEEE80211_S1G_TIM_ENC_MODE_SINGLE : + len =ieee80211_s1g_len_single (ptr, end); + contains = blk_off == aid->target_blk; +break ; +case IEEE80211_S1G_TIM_ENC_MODE_OLB : + len =ieee80211_s1g_len_olb (ptr, end); +/* +* An OLB encoded block can describe more then one +* block, meaning an encoded OLB block can span more +* then a single block. +*/ +if (len >0 ) { +/* Minus one for the length octet */ + span =DIV_ROUND_UP (len -1 ,8 ); +/* +* Check if our target block lies within the +* block span described by this encoded block. +*/ + contains = (aid->target_blk >= blk_off) && + (aid->target_blk < blk_off + span); + } +break ; +default : +return -EOPNOTSUPP ; + } + +if (len <0 ) +return len; + +if (contains) { + enc->enc_mode = mode; + enc->inverse = inverse; + enc->ptr = ptr; + enc->len = (u8 )len; + enc->olb_blk_offset = blk_off; +return 0 ; + } + + ptr += len; + } + +return -ENOENT ; +} + +static inline bool ieee80211_s1g_parse_bitmap (struct s1g_tim_enc_block *enc, +struct s1g_tim_aid *aid) +{ +const u8 *ptr = enc->ptr; +u8 blkmap = *ptr++; + +/* +* If our block bitmap does not contain a set bit that corresponds +* to our AID, it could mean a variety of things depending on if +* the encoding mode is inverted or not. +* +* 1. If inverted, it means the entire subblock is present and hence +* our AID has been set. +* 2. If not inverted, it means our subblock is not present and hence +* it is all zero meaning our AID is not set. +*/ +if (!(blkmap &BIT (aid->target_subblk))) +return enc->inverse; + +/* +* Increment ptr by the number of set subblocks that appear before our +* target subblock. If our target subblock is 0, do nothing as ptr +* already points to our target subblock. +*/ +if (aid->target_subblk) + ptr +=hweight8 (blkmap &GENMASK (aid->target_subblk -1 ,0 )); + +return !!(*ptr &BIT (aid->target_subblk_bit)) ^ enc->inverse; +} + +static inline bool ieee80211_s1g_parse_single (struct s1g_tim_enc_block *enc, +struct s1g_tim_aid *aid) +{ +/* +* Single AID mode describes, as the name suggests, a single AID +* within the block described by the encoded block. The octet +* contains the 6 LSBs of the AID described in the block. The other +* 2 bits are reserved. When inversed, every single AID described +* by the current block have buffered traffic except for the AID +* described in the single AID octet. +*/ +return ((*enc->ptr &0x3f ) == (aid->aid &0x3f )) ^ enc->inverse; +} + +static inline bool ieee80211_s1g_parse_olb (struct s1g_tim_enc_block *enc, +struct s1g_tim_aid *aid) +{ +const u8 *ptr = enc->ptr; +u8 blk_len = *ptr++; +/* +* Given an OLB encoded block that describes multiple blocks, +* calculate the offset into the span. Then calculate the +* subblock location normally. +*/ +u16 span_offset = aid->target_blk - enc->olb_blk_offset; +u16 subblk_idx = span_offset *8 + aid->target_subblk; + +if (subblk_idx >= blk_len) +return enc->inverse; + +return !!(ptr[subblk_idx] &BIT (aid->target_subblk_bit)) ^ enc->inverse; +} + +/* +* An S1G PVB has 3 non optional encoding types, each that can be inverted. +* An S1G PVB is constructed with zero or more encoded block subfields. Each +* encoded block represents a single "block" of AIDs (64), and each encoded +* block can contain one of the 3 encoding types alongside a single bit for +* whether the bits should be inverted. +* +* As the standard makes no guarantee about the ordering of encoded blocks, +* we must parse every encoded block in the worst case scenario given an +* AID that lies within the last block. +*/ +static inline bool ieee80211_s1g_check_tim (const struct ieee80211_tim_ie *tim, +u8 tim_len,u16 aid) +{ +int err; +struct s1g_tim_aid target_aid; +struct s1g_tim_enc_block enc_blk; + +if (tim_len <3 ) +return false; + + target_aid.aid = aid; + target_aid.target_blk = (aid >>6 ) &0x1f ; + target_aid.target_subblk = (aid >>3 ) &0x7 ; + target_aid.target_subblk_bit = aid &0x7 ; + +/* +* Find our AIDs target encoded block and fill &enc_blk with the +* encoded blocks information. If no entry is found or an error +* occurs return false. +*/ + err =ieee80211_s1g_find_target_block (&enc_blk, &target_aid, + tim->virtual_map, + (const u8 *)tim + tim_len +2 ); +if (err) +return false; + +switch (enc_blk.enc_mode) { +case IEEE80211_S1G_TIM_ENC_MODE_BLOCK : +return ieee80211_s1g_parse_bitmap (&enc_blk, &target_aid); +case IEEE80211_S1G_TIM_ENC_MODE_SINGLE : +return ieee80211_s1g_parse_single (&enc_blk, &target_aid); +case IEEE80211_S1G_TIM_ENC_MODE_OLB : +return ieee80211_s1g_parse_olb (&enc_blk, &target_aid); +default : +return false; + } +} + +#endif /* LINUX_IEEE80211_H */
include/linux/ieee80211.h +16 -569
650 lines not on this page · raw message
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 308/621 wifi: mac80211: bound S1G TIM PVB walk to the TIM element
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 b224d18b1e5d1cddfc67f63f41d80023b2ec8889 ]
ieee80211_s1g_check_tim() parses the S1G Partial Virtual Bitmap (PVB) of a received TIM element. The TIM is handed in as the element payload:ieee802_11_parse_elems_full() stores elems->tim = elem->data and elems->tim_len = elem->datalen (net/mac80211/parse.c), so the valid bytes are [tim, tim + tim_len).
When walking the encoded blocks the function passes the walker an end sentinel of (const u8 *)tim + tim_len + 2, i.e. two bytes past the end of the element. ieee80211_s1g_find_target_block() loops while (ptr + 1 <= end) and dereferences ptr (and the per-mode ieee80211_s1g_len_*() helpers read *ptr), so it can read up to two bytes beyond the TIM element -- an out-of-bounds read of adjacent skb/heap data when the TIM is the last element in the frame. The +2 appears to account for the element id/len header, but tim already points past that header at the element payload, so the addend is wrong.
Pass the correct element end, (const u8 *)tim + tim_len.
--- include/linux/ieee80211-s1g.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
include/linux/ieee80211-s1g.h +1 -1
@@ -556,7 +556,7 @@ static inline bool ieee80211_s1g_check_tim(const struct ieee80211_tim_ie *tim,*/ err =ieee80211_s1g_find_target_block (&enc_blk, &target_aid, tim->virtual_map, - (const u8 *)tim + tim_len +2 ); + (const u8 *)tim + tim_len);if (err)return false;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 309/621 bpf: Reject sleepable BPF_LSM_CGROUP programs at load time
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: David Windsor <[email protected]>
[ Upstream commit 5b038319be442c620f774e6fc9e9283deeca1c75 ]
The cgroup shim runs under rcu_read_lock_dont_migrate(), so we should not attach any sleepable BPF programs there. Add support to the verifier to explicitly reject attempts to load sleepable BPF programs destined for LSM cgroup attachment.
Without this, we get the following splat from a BPF_LSM_CGROUP program marked BPF_F_SLEEPABLE attached to file_open when it calls bpf_get_dentry_xattr():
BUG: sleeping function called from invalid context at kernel/locking/rwsem.c:1567 in_atomic(): 0, irqs_disabled(): 0, non_block: 0, pid: 34317, name: load preempt_count: 0, expected: 0 RCU nest depth: 2, expected: 0 Call Trace: down_read+0x76/0x480 ext4_xattr_get+0x11f/0x700 __vfs_getxattr+0xf0/0x150 bpf_get_dentry_xattr+0xbb/0xf0 bpf_prog_e76a298dac9218c6_test_open+0x6a/0x85 __cgroup_bpf_run_lsm_current+0x326/0x840 bpf_trampoline_6442534646+0x62/0x14d security_file_open+0x34/0x60 do_dentry_open+0x340/0x1260 vfs_open+0x7a/0x440 path_openat+0x1bac/0x30a0
libbpf provides a .s named section variant for every sleepable program type except lsm_cgroup, reflecting that per-cgroup LSM programs are intended to only run in a non-sleepable context.
The above splat was obtained by bypassing libbpf by using bpf(2) directly.
--- kernel/bpf/verifier.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
kernel/bpf/verifier.c +4 -2
@@ -24479,8 +24479,10 @@ static bool can_be_sleepable(struct bpf_prog *prog)return false; } } -return prog->type ==BPF_PROG_TYPE_LSM || - prog->type ==BPF_PROG_TYPE_KPROBE /* only for uprobes */ || +if (prog->type ==BPF_PROG_TYPE_LSM ) +return prog->expected_attach_type !=BPF_LSM_CGROUP ; + +return prog->type ==BPF_PROG_TYPE_KPROBE /* only for uprobes */ || prog->type ==BPF_PROG_TYPE_STRUCT_OPS ; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 310/621 ocfs2: validate fast symlink target during inode read
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Zhang Cen <[email protected]>
[ Upstream commit e234973f286ed2e8961a24561ec91594ec3e3ff8 ]
ocfs2_validate_inode_block() already rejects several inconsistent self-contained dinodes before they are exposed to the rest of the filesystem. Fast symlinks need the same treatment.
A zero-cluster symlink is treated as a fast symlink and later read through page_get_link() and ocfs2_fast_symlink_read_folio(). That path uses strnlen() on the inline payload and then copies len + 1 bytes into the folio. If a corrupt dinode stores an i_size that does not fit the inline area or omits the terminating NUL at i_size, that copy reads past the end of the inode block buffer.
Reject zero-cluster symlink dinodes whose i_size exceeds the inline fast-symlink capacity or whose inline payload is not NUL-terminated exactly at i_size when the inode block is validated. This keeps malformed fast symlinks from reaching the read path.
Validation reproduced this kernel report:
KASAN use-after-free in ocfs2_fast_symlink_read_folio+0x12c/0x1f0
RIP: 0033:0x7f5c6d859aa7 Read of size 3905 Call trace: dump_stack_lvl+0x66/0xa0 (?:?) print_report+0xce/0x630 (?:?) ocfs2_fast_symlink_read_folio+0x12c/0x1f0 (fs/ocfs2/inode.c:?) srso_alias_return_thunk+0x5/0xfbef5 (?:?) __virt_addr_valid+0x19f/0x330 (?:?) kasan_report+0xe0/0x110 (?:?) kasan_check_range+0x105/0x1b0 (?:?) __asan_memcpy+0x23/0x60 (?:?) filemap_read_folio+0x27/0xe0 (?:?) filemap_read_folio+0x35/0xe0 (?:?) do_read_cache_folio+0x138/0x230 (?:?) __page_get_link+0x26/0x110 (?:?) page_get_link+0x2e/0x70 (?:?) vfs_readlink+0x15e/0x250 (?:?) touch_atime+0x4d/0x370 (?:?) do_readlinkat+0x186/0x200 (?:?) do_user_addr_fault+0x65a/0x890 (?:?) __x64_sys_readlink+0x46/0x60 (?:?) do_syscall_64+0x115/0x6a0 (arch/x86/entry/syscall_64.c:87) entry_SYSCALL_64_after_hwframe+0x77/0x7f (?:?)
--- fs/ocfs2/inode.c | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+)
fs/ocfs2/inode.c +23 -0
@@ -1665,6 +1665,29 @@ int ocfs2_validate_inode_block(struct super_block *sb, } } +if (S_ISLNK (le16_to_cpu (di->i_mode)) && + !le32_to_cpu (di->i_clusters)) { +int max_inline =ocfs2_fast_symlink_chars (sb); +u64 i_size =le64_to_cpu (di->i_size); + +if (i_size >= max_inline) { + rc =ocfs2_error (sb, +"Invalid dinode #%llu: fast symlink i_size %llu exceeds max %d\n" , + (unsigned long long )bh->b_blocknr, + (unsigned long long )i_size, + max_inline -1 ); + goto bail; + } + +if (strnlen ((char *)di->id2.i_symlink, i_size +1 ) != i_size) { + rc =ocfs2_error (sb, +"Invalid dinode #%llu: fast symlink is not NUL-terminated at i_size %llu\n" , + (unsigned long long )bh->b_blocknr, + (unsigned long long )i_size); + goto bail; + } + } +if (ocfs2_dinode_has_extents (di)) {struct ocfs2_extent_list *el = &di->id2.i_list;u16 count =le16_to_cpu (el->l_count);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 311/621 wifi: ath12k: fix inconsistent arvif state in vdev_create error paths
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Wei Zhang <[email protected]>
[ Upstream commit c972636efc63f0f43d725b59805dd1ae5bc4b31e ]
ath12k_mac_vdev_create() has three error path issues that leave arvif in an inconsistent state:
1. When ath12k_wmi_vdev_create() fails, the function returns directly without clearing arvif->ar, which was already set before the WMI call. Subsequent code checking arvif->ar to determine vdev readiness will see a non-NULL value despite no vdev existing in firmware.
2. When ath12k_wmi_send_peer_delete_cmd() fails in err_peer_del, the code jumped to err: skipping the DP peer cleanup and vdev rollback, leaving num_created_vdevs, vdev maps and arvif list membership live.
3. When ath12k_wait_for_peer_delete_done() fails, the code jumped to
err_vdev_del: skipping the DP peer cleanup.
Fix by changing the ath12k_wmi_vdev_create() failure to goto err instead of returning directly, routing both err_peer_del failure paths througherr_dp_peer_del: for proper DP peer and vdev rollback, and consolidating the arvif state cleanup at err:.
Tested-on: WCN7850 hw2.0 PCI WLAN.HMT.1.1.c5-00302-QCAHMTSWPL_V1.0_V2.0_SILICONZ-1.115823.3
--- drivers/net/wireless/ath/ath12k/mac.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-)
drivers/net/wireless/ath/ath12k/mac.c +3 -4
@@ -9745,7 +9745,7 @@ int ath12k_mac_vdev_create(struct ath12k *ar, struct ath12k_link_vif *arvif)if (ret) {ath12k_warn (ab,"failed to create WMI vdev %d: %d\n" , arvif->vdev_id, ret); -return ret; + goto err; } ar->num_created_vdevs++;
@@ -9874,7 +9874,7 @@ int ath12k_mac_vdev_create(struct ath12k *ar, struct ath12k_link_vif *arvif)if (ret) {ath12k_warn (ar->ab,"failed to delete peer vdev_id %d addr %pM\n" , arvif->vdev_id, arvif->bssid); - goto err; + goto err_vdev_del; } ret = ath12k_wait_for_peer_delete_done(ar, arvif->vdev_id,
@@ -9893,8 +9893,6 @@ int ath12k_mac_vdev_create(struct ath12k *ar, struct ath12k_link_vif *arvif)ath12k_wmi_vdev_delete (ar, arvif->vdev_id); ar->num_created_vdevs--; - arvif->is_created = false; - arvif->ar =NULL ; ar->allocated_vdev_map &= ~(1LL << arvif->vdev_id); ab->free_vdev_map |=1LL << arvif->vdev_id; ab->free_vdev_stats_id_map &= ~(1LL << arvif->vdev_stats_id);
@@ -9903,6 +9901,7 @@ int ath12k_mac_vdev_create(struct ath12k *ar, struct ath12k_link_vif *arvif)spin_unlock_bh (&ar->data_lock); err: + arvif->is_created = false; arvif->ar =NULL ;return ret; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 312/621 wifi: ath12k: fix memory leak in ath12k_wifi7_dp_rx_h_verify_tkip_mic()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Miaoqing Pan <[email protected]>
[ Upstream commit 98d4f92ab6a1af2ea2ab590d7e2801b203110981 ]
In ath12k_wifi7_dp_rx_h_verify_tkip_mic(), the call to ath12k_dp_rx_check_nwifi_hdr_len_valid() may return false when the NWIFI header length is invalid, causing the function to abort early with -EINVAL.
When this happens, the error propagates to ath12k_wifi7_dp_rx_h_defrag(), which clears first_frag by setting it to NULL. As a result, the corresponding MSDU is no longer referenced by the defragmentation path and is never freed.
This leads to a memory leak for the affected MSDU on this error path. Proper cleanup is required to ensure the MSDU is released when header validation fails during TKIP MIC verification.
Tested-on: WCN7850 hw2.0 PCI WLAN.HMT.1.1.c5-00302-QCAHMTSWPL_V1.0_V2.0_SILICONZ-1.115823.3
--- drivers/net/wireless/ath/ath12k/dp_rx.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
drivers/net/wireless/ath/ath12k/dp_rx.c +3 -1
@@ -3238,8 +3238,10 @@ static int ath12k_dp_rx_h_verify_tkip_mic(struct ath12k *ar, struct ath12k_peerRX_FLAG_IV_STRIPPED |RX_FLAG_DECRYPTED ;skb_pull (msdu, hal_rx_desc_sz); -if (unlikely (!ath12k_dp_rx_check_nwifi_hdr_len_valid (ab, rx_desc, msdu))) +if (unlikely (!ath12k_dp_rx_check_nwifi_hdr_len_valid (ab, rx_desc, msdu))) { +dev_kfree_skb_any (msdu);return -EINVAL ; + }ath12k_dp_rx_h_ppdu (ar, &rx_info); ath12k_dp_rx_h_undecap(ar, msdu, rx_desc,
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 313/621 md: replace wait loop with wait_event() in md_handle_request()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Abd-Alrhman Masalkhi <[email protected]>
[ Upstream commit 8e8278ac702e2d5d44211b4b10599aa3b2cb0555 ]
The wait loop is equivalent to wait_event() and can be simplified by usaing it for improving readability.
Stable-dep-of: ba976e350111 ("md/raid1,raid10: fix bio accounting for split md cloned bios")
--- drivers/md/md.c | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-)
drivers/md/md.c +1 -9
@@ -397,20 +397,12 @@ bool md_handle_request(struct mddev *mddev, struct bio *bio) { check_suspended:if (is_suspended (mddev, bio)) { -DEFINE_WAIT (__wait);/* Bail out if REQ_NOWAIT is set for the bio */ if (bio->bi_opf &REQ_NOWAIT ) {bio_wouldblock_error (bio);return true; } -for (;;) { -prepare_to_wait (&mddev->sb_wait, &__wait, -TASK_UNINTERRUPTIBLE ); -if (!is_suspended (mddev, bio)) -break ; -schedule (); - } -finish_wait (&mddev->sb_wait, &__wait); +wait_event (mddev->sb_wait, !is_suspended (mddev, bio)); }if (!percpu_ref_tryget_live (&mddev->active_io)) goto check_suspended;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 314/621 md/raid1,raid10: fix deadlock in read error recovery path
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Abd-Alrhman Masalkhi <[email protected]>
[ Upstream commit 7b15c24f805339a585cfe7d72f446b7e88b9bcc0 ]
raid1d and raid10d may resubmit a split md cloned bio while handling a read error. In this case, resubmitting the bio can lead to a deadlock if the array is suspended before md_handle_request() acquires an active_io reference via percpu_ref_tryget_live().
Since the cloned bio already holds an active_io reference, trying to acquire another reference via percpu_ref_tryget_live() can lead to a deadlock while the array is suspended.
Fix this by using percpu_ref_get() for md cloned bios.
Stable-dep-of: ba976e350111 ("md/raid1,raid10: fix bio accounting for split md cloned bios")
--- drivers/md/md.c | 25 ++++++++++++++++--------- drivers/md/md.h | 5 +++++ 2 files changed, 21 insertions(+), 9 deletions(-)
drivers/md/md.c +16 -9
@@ -396,17 +396,24 @@ static bool is_suspended(struct mddev *mddev, struct bio *bio)bool md_handle_request (struct mddev *mddev,struct bio *bio) { check_suspended: -if (is_suspended (mddev, bio)) { -/* Bail out if REQ_NOWAIT is set for the bio */ -if (bio->bi_opf &REQ_NOWAIT ) { -bio_wouldblock_error (bio); -return true; +if (unlikely (md_cloned_bio (mddev, bio))) { +/* +* This bio is an MD cloned bio and already holds an +* active_io reference, so percpu_ref_get() is safe here. +*/ +percpu_ref_get (&mddev->active_io); + }else { +if (is_suspended (mddev, bio)) { +/* Bail out if REQ_NOWAIT is set for the bio */ +if (bio->bi_opf &REQ_NOWAIT ) { +bio_wouldblock_error (bio); +return true; + } +wait_event (mddev->sb_wait, !is_suspended (mddev, bio)); } -wait_event (mddev->sb_wait, !is_suspended (mddev, bio)); +if (!percpu_ref_tryget_live (&mddev->active_io)) + goto check_suspended; } -if (!percpu_ref_tryget_live (&mddev->active_io)) - goto check_suspended; -if (!mddev->pers->make_request (mddev, bio)) {percpu_ref_put (&mddev->active_io);if (!mddev->gendisk && mddev->pers->prepare_suspend)
drivers/md/md.h +5 -0
@@ -1043,6 +1043,11 @@ void mddev_update_io_opt(struct mddev *mddev, unsigned int nr_stripes);extern const struct block_device_operations md_fops; +static inline bool md_cloned_bio (struct mddev *mddev,struct bio *bio) +{ +return bio->bi_pool == &mddev->io_clone_set; +} +/* * MD devices can be used undeneath by DM, in which case ->gendisk is NULL. */
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 315/621 md/raid1,raid10: fix bio accounting for split md cloned bios
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Abd-Alrhman Masalkhi <[email protected]>
[ Upstream commit ba976e3501111d11c550848b3b7341a73035f582 ]
Use md_cloned_bio() to control bio accounting instead of relying on r1bio_existed in raid1 or the io_accounting flag in raid10.
The previous logic does not reliably reflect whether a bio is an md cloned bio. When a failed bio is split and resubmitted via bio_submit_split_bioset() on the error path, this can lead to either double accounting for md cloned bios, or missing accounting for bios returned from bio_submit_split_bioset()
Fix this by using md_cloned_bio() to detect md cloned bios and skip accounting accordingly.
--- drivers/md/raid1.c | 2 +- drivers/md/raid10.c | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-)
drivers/md/raid1.c +1 -1
@@ -1399,7 +1399,7 @@ static void raid1_read_request(struct mddev *mddev, struct bio *bio, } r1_bio->read_disk = rdisk; -if (!r1bio_existed) { +if (likely (!md_cloned_bio (mddev, bio))) {md_account_bio (mddev, &bio); r1_bio->master_bio = bio; }
drivers/md/raid10.c +4 -4
@@ -1146,7 +1146,7 @@ static bool regular_request_wait(struct mddev *mddev, struct r10conf *conf, }static void raid10_read_request (struct mddev *mddev,struct bio *bio, -struct r10bio *r10_bio,bool io_accounting) +struct r10bio *r10_bio) {struct r10conf *conf = mddev->private;struct bio *read_bio;
@@ -1218,7 +1218,7 @@ static void raid10_read_request(struct mddev *mddev, struct bio *bio, } slot = r10_bio->read_slot; -if (io_accounting) { +if (likely (!md_cloned_bio (mddev, bio))) {md_account_bio (mddev, &bio); r10_bio->master_bio = bio; }
@@ -1542,7 +1542,7 @@ static bool __make_request(struct mddev *mddev, struct bio *bio, int sectors) ret = true;if (bio_data_dir (bio) ==READ ) -raid10_read_request (mddev, bio, r10_bio, true); +raid10_read_request (mddev, bio, r10_bio);else ret =raid10_write_request (mddev, bio, r10_bio);
@@ -2871,7 +2871,7 @@ static void handle_read_error(struct mddev *mddev, struct r10bio *r10_bio)rdev_dec_pending (rdev, mddev); r10_bio->state =0 ; -raid10_read_request (mddev, r10_bio->master_bio, r10_bio, false); +raid10_read_request (mddev, r10_bio->master_bio, r10_bio);/* * allow_barrier after re-submit to ensure no sync io * can be issued while regular io pending.
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 316/621 md/raid1,raid10: fix error-path detection with md_cloned_bio()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Abd-Alrhman Masalkhi <[email protected]>
[ Upstream commit 811545e0926d02a6a0b1a1258bb5544777c164d4 ]
Detect the error path using md_cloned_bio() instead of relying on r1_bio in raid1 or r10_bio->read_slot in raid10, which may be NULL or -1 after splitting and resubmitting a failed bio.
As a result, the error path may not be recognized and memory allocations can incorrectly use GFP_NOIO instead of (GFP_NOIO | __GFP_HIGH), which can lead to a deadlock under memory pressure.
--- drivers/md/raid1.c | 13 ++++++++++--- drivers/md/raid10.c | 20 ++++++++++++++------ 2 files changed, 24 insertions(+), 9 deletions(-)
drivers/md/raid1.c +10 -3
@@ -1322,11 +1322,18 @@ static void raid1_read_request(struct mddev *mddev, struct bio *bio,bool nowait = bio->bi_opf &REQ_NOWAIT ;/* -* If r1_bio is set, we are blocking the raid1d thread -* so there is a tiny risk of deadlock. So ask for +* An md cloned bio indicates we are in the error path. +* This is more reliable than checking r1_bio, which might +* be NULL even in the error path if a failed bio was split. +*/ +bool err_path =md_cloned_bio (mddev, bio); + +/* +* If we are in the error path, we are blocking the raid1d +* thread so there is a tiny risk of deadlock. So ask for * emergency memory if needed. */ -gfp_t gfp = r1_bio ? (GFP_NOIO | __GFP_HIGH) :GFP_NOIO ; +gfp_t gfp = err_path ? (GFP_NOIO | __GFP_HIGH) :GFP_NOIO ;/* * Still need barrier for READ in case that whole
drivers/md/raid10.c +14 -6
@@ -1155,7 +1155,20 @@ static void raid10_read_request(struct mddev *mddev, struct bio *bio,char b[BDEVNAME_SIZE ];int slot = r10_bio->read_slot;struct md_rdev *err_rdev =NULL ; -gfp_t gfp =GFP_NOIO ; + +/* +* An md cloned bio indicates we are in the error path. +* This is more reliable than checking slot, which might +* be -1 even in the error path if a failed bio was split. +*/ +bool err_path =md_cloned_bio (mddev, bio); + +/* +* If we are in the error path, we are blocking the raid10d +* thread so there is a tiny risk of deadlock. So ask for +* emergency memory if needed. +*/ +gfp_t gfp = err_path ? (GFP_NOIO | __GFP_HIGH) :GFP_NOIO ;if (slot >=0 && r10_bio->devs[slot].rdev) {/*
@@ -1166,11 +1179,6 @@ static void raid10_read_request(struct mddev *mddev, struct bio *bio,* we lose the device name in error messages. */ int disk; -/* -* As we are blocking raid10, it is a little safer to -* use __GFP_HIGH. -*/ - gfp =GFP_NOIO | __GFP_HIGH; disk = r10_bio->devs[slot].devnum; err_rdev = conf->mirrors[disk].rdev;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 317/621 drm/amd/display: Fix divide-by-zero in calculate_mcache_setting on zero viewport
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: George Zhang <[email protected]>
[ Upstream commit f327e389c07cfc3a2f6ff54f6214e1a52d457edc ]
If a plane reaches calculate_mcache_setting with a zero-area viewport, calculate_mcache_setting exits early with num_mcaches == 0 and mvmpg_width/height == 0. This will cause a divide-by-zero panic and can also cause an underflow on num_mcaches.
Fix this by changing calculate_mcache_setting to bool and adding guards after each calculate_mcache_row_bytes call. If num_mcaches or mvmpg_width/height is zero, return a false. Callers will propagate the failure as a rejected mode, which prevents the panic.
--- .../src/dml2_core/dml2_core_dcn4_calcs.c | 31 +++++++++++++++---- 1 file changed, 25 insertions(+), 6 deletions(-)
drivers/gpu/drm/amd/display/dc/dml2/dml21/src/dml2_core/dml2_core_dcn4_calcs.c +25 -6
@@ -2412,7 +2412,7 @@ static void calculate_mcache_row_bytes(DML_ASSERT (*p->num_mcaches >0 ); } -static void calculate_mcache_setting ( +static bool calculate_mcache_setting (struct dml2_core_internal_scratch *scratch,struct dml2_core_calcs_calculate_mcache_setting_params *p) {
@@ -2438,7 +2438,7 @@ static void calculate_mcache_setting( *p->lc_comb_mcache =0 ;if (!p->dcc_enable) -return ; +return true; l->is_dual_plane =dml_is_420 (p->source_format) || p->source_format == dml2_rgbe_alpha;
@@ -2475,7 +2475,14 @@ static void calculate_mcache_setting( l->l_p.mvmpg_per_mcache_lb = &l->mvmpg_per_mcache_lb_l;calculate_mcache_row_bytes (scratch, &l->l_p); -DML_ASSERT (*p->num_mcaches_l >0 ); +if (*p->num_mcaches_l ==0 || + (p->surf_vert ? l->mvmpg_height_l : l->mvmpg_width_l) ==0 ) { +DML_LOG_VERBOSE ("DML::%s: degenerate luma viewport (num_mcaches_l=%u mvmpg_%s_l=%u) — mode not supported\n" , + __func__, *p->num_mcaches_l, + p->surf_vert ?"height" :"width" , + p->surf_vert ? l->mvmpg_height_l : l->mvmpg_width_l); +return false; + }if (l->is_dual_plane) { l->c_p.num_chans = p->num_chans;
@@ -2511,7 +2518,14 @@ static void calculate_mcache_setting( l->c_p.mvmpg_per_mcache_lb = &l->mvmpg_per_mcache_lb_c;calculate_mcache_row_bytes (scratch, &l->c_p); -DML_ASSERT (*p->num_mcaches_c >0 ); +if (*p->num_mcaches_c ==0 || + (p->surf_vert ? l->mvmpg_height_c : l->mvmpg_width_c) ==0 ) { +DML_LOG_VERBOSE ("DML::%s: degenerate chroma viewport (num_mcaches_c=%u mvmpg_%s_c=%u) — mode not supported\n" , + __func__, *p->num_mcaches_c, + p->surf_vert ?"height" :"width" , + p->surf_vert ? l->mvmpg_height_c : l->mvmpg_width_c); +return false; + } }// Sharing for iMALL access
@@ -2621,6 +2635,7 @@ static void calculate_mcache_setting( *p->mcache_shift_granularity_l = l->mvmpg_access_width_l; *p->mcache_shift_granularity_c = l->mvmpg_access_width_c; +return true; } static void calculate_mall_bw_overhead_factor(
@@ -9373,7 +9388,10 @@ static bool dml_core_mode_support(struct dml2_core_calcs_mode_support_ex *in_out calculate_mcache_setting_params->mall_comb_mcache_c = &mode_lib->ms.mall_comb_mcache_c[k]; calculate_mcache_setting_params->lc_comb_mcache = &mode_lib->ms.lc_comb_mcache[k]; -calculate_mcache_setting (&mode_lib->scratch, calculate_mcache_setting_params); +if (!calculate_mcache_setting (&mode_lib->scratch, calculate_mcache_setting_params)) { + mode_lib->ms.support.ModeSupport = false; +return false; + } } calculate_mall_bw_overhead_factor(
@@ -10844,7 +10862,8 @@ static bool dml_core_mode_programming(struct dml2_core_calcs_mode_programming_ex calculate_mcache_setting_params->mall_comb_mcache_l = &mode_lib->mp.mall_comb_mcache_l[k]; calculate_mcache_setting_params->mall_comb_mcache_c = &mode_lib->mp.mall_comb_mcache_c[k]; calculate_mcache_setting_params->lc_comb_mcache = &mode_lib->mp.lc_comb_mcache[k]; -calculate_mcache_setting (&mode_lib->scratch, calculate_mcache_setting_params); +if (!calculate_mcache_setting (&mode_lib->scratch, calculate_mcache_setting_params)) +return false; } calculate_mall_bw_overhead_factor(
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 318/621 s390/zcrypt: Move inline function rng_type6cprb_msgx from header to code
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Harald Freudenberger <[email protected]>
[ Upstream commit 23a4757d6d699e602b358808359149d0e8be6db9 ]
Function rng_type6cprb_msgx() is only used once and thus no need to provide it in header file any more. Move it at the place within the code where it is used.
Stable-dep-of: e935cd525af4 ("s390/zcrypt: Close speculative mem read possibility")
--- drivers/s390/crypto/zcrypt_msgtype6.c | 49 +++++++++++++++++++++++++++ drivers/s390/crypto/zcrypt_msgtype6.h | 49 --------------------------- 2 files changed, 49 insertions(+), 49 deletions(-)
drivers/s390/crypto/zcrypt_msgtype6.c +49 -0
@@ -1247,6 +1247,55 @@ static long zcrypt_msgtype6_send_ep11_cprb(bool userspace, struct zcrypt_queue *return rc; } +/** +* Prepare a type6 CPRB message for random number generation +* +* @ap_dev: AP device pointer +* @ap_msg: pointer to AP message +*/ +static inline void rng_type6cprb_msgx (struct ap_message *ap_msg, +unsigned int random_number_length, +unsigned int *domain) +{ +struct { +struct type6_hdr hdr; +struct CPRBX cprbx; +char function_code[2 ]; +short int rule_length; +char rule[8 ]; +short int verb_length; +short int key_length; + } __packed * msg = ap_msg->msg; +static struct type6_hdr static_type6_hdrX = { + .type =0x06 , + .offset1 =0x00000058 , + .agent_id = {'C' ,'A' }, + .function_code = {'R' ,'L' }, + .tocardlen1 =sizeof (*msg) -sizeof (msg->hdr), + .fromcardlen1 =sizeof (*msg) -sizeof (msg->hdr), + }; +static struct CPRBX local_cprbx = { + .cprb_len =0x00dc , + .cprb_ver_id =0x02 , + .func_id = {0x54 ,0x32 }, + .req_parml =sizeof (*msg) -sizeof (msg->hdr) - +sizeof (msg->cprbx), + .rpl_msgbl =sizeof (*msg) -sizeof (msg->hdr), + }; + + msg->hdr = static_type6_hdrX; + msg->hdr.fromcardlen2 = random_number_length; + msg->cprbx = local_cprbx; + msg->cprbx.rpl_datal = random_number_length; +memcpy (msg->function_code, msg->hdr.function_code,0x02 ); + msg->rule_length =0x0a ; +memcpy (msg->rule,"RANDOM " ,8 ); + msg->verb_length =0x02 ; + msg->key_length =0x02 ; + ap_msg->len =sizeof (*msg); + *domain = (unsigned short )msg->cprbx.domain; +} +/* * Prepare a CEXXC get random request ap message. * This function assumes that ap_msg has been initialized with
drivers/s390/crypto/zcrypt_msgtype6.h +0 -49
55 lines not on this page · raw message
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 319/621 s390/zcrypt: Rework domain processing within zcrypt device driver
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Harald Freudenberger <[email protected]>
[ Upstream commit e2c6d91eb8b1533753755f07803e47eceed263d0 ]
Slight rework of the domain handling within the zcrypt dd:
Remove this curious construct to give a pointer to the domain field within the CPRB struct to the zcrypt API and later fill in the target domain via this pointer. Now the domain is filled in with the send function when the ready constructed AP message is about to be pushed down into the software queue for AP queue processing. So now the domain handling for CCA, EP11 and (internal) rng CPRBs is the same. With this comes a slight reshuffle of the code related to domain processing in the zcrypt API and the message type 60 protocol implementation code.
Stable-dep-of: e935cd525af4 ("s390/zcrypt: Close speculative mem read possibility")
--- drivers/s390/crypto/zcrypt_api.c | 36 +++++++++++---------------- drivers/s390/crypto/zcrypt_msgtype6.c | 22 ++++++++++------ drivers/s390/crypto/zcrypt_msgtype6.h | 2 +- 3 files changed, 29 insertions(+), 31 deletions(-)
drivers/s390/crypto/zcrypt_api.c +14 -22
@@ -854,13 +854,12 @@ static long _zcrypt_send_cprb(u32 xflags, struct ap_perms *perms, struct ica_xcRB *xcrb) {bool userspace = xflags &ZCRYPT_XFLAG_USERSPACE ; -struct zcrypt_card *zc, *pref_zc; -struct zcrypt_queue *zq, *pref_zq; -struct ap_message ap_msg; +unsigned int domain, func_code =0 ;unsigned int wgt =0 , pref_wgt =0 ; -unsigned int func_code =0 ; -unsigned short *domain, tdom; +struct zcrypt_queue *zq, *pref_zq; +struct zcrypt_card *zc, *pref_zc;int cpen, qpen, qid =0 , rc; +struct ap_message ap_msg;struct module *mod;trace_s390_zcrypt_req (xcrb,TB_ZSECSENDCPRB );
@@ -878,10 +877,9 @@ static long _zcrypt_send_cprb(u32 xflags, struct ap_perms *perms,print_hex_dump_debug ("ccareq: " ,DUMP_PREFIX_ADDRESS ,16 ,1 , ap_msg.msg, ap_msg.len, false); - tdom = *domain; -if (perms != &ap_perms && tdom <AP_DOMAINS ) { +if (perms != &ap_perms && domain <AP_DOMAINS ) {if (ap_msg.flags &AP_MSG_FLAG_ADMIN ) { -if (!test_bit_inv (tdom, perms->adm)) { +if (!test_bit_inv (domain, perms->adm)) { rc = -ENODEV ; goto out; }
@@ -894,10 +892,10 @@ static long _zcrypt_send_cprb(u32 xflags, struct ap_perms *perms,* If a valid target domain is set and this domain is NOT a usage * domain but a control only domain, autoselect target domain. */ -if (tdom <AP_DOMAINS && - !ap_test_config_usage_domain (tdom) && -ap_test_config_ctrl_domain (tdom)) - tdom =AUTOSEL_DOM ; +if (domain <AP_DOMAINS && + !ap_test_config_usage_domain (domain) && +ap_test_config_ctrl_domain (domain)) + domain =AUTOSEL_DOM ; pref_zc =NULL ; pref_zq =NULL ;
@@ -929,8 +927,8 @@ static long _zcrypt_send_cprb(u32 xflags, struct ap_perms *perms,/* check for device usable and eligible */ if (!zq->online || !zq->ops->send_cprb || !ap_queue_usable (zq->queue) || - (tdom !=AUTOSEL_DOM && - tdom !=AP_QID_QUEUE (zq->queue->qid))) + (domain !=AUTOSEL_DOM && + domain !=AP_QID_QUEUE (zq->queue->qid)))continue ;/* check if device node has admission for this queue */ if (!zcrypt_check_queue(perms,
@@ -953,16 +951,11 @@ static long _zcrypt_send_cprb(u32 xflags, struct ap_perms *perms,if (!pref_zq) {pr_debug ("no match for address %02x.%04x => ENODEV\n" , - xcrb->user_defined, *domain); + xcrb->user_defined, domain); rc = -ENODEV ; goto out; } -/* in case of auto select, provide the correct domain */ - qid = pref_zq->queue->qid; -if (*domain ==AUTOSEL_DOM ) - *domain =AP_QID_QUEUE (qid); - rc = pref_zq->ops->send_cprb (userspace, pref_zq, xcrb, &ap_msg);if (!rc) { print_hex_dump_debug("ccarpl: ", DUMP_PREFIX_ADDRESS, 16, 1,
@@ -1218,7 +1211,6 @@ static long zcrypt_rng(char *buffer)unsigned int wgt =0 , pref_wgt =0 ;unsigned int func_code =0 ;struct ap_message ap_msg; -unsigned int domain;int qid =0 , rc = -ENODEV ;struct module *mod;
@@ -1227,7 +1219,7 @@ static long zcrypt_rng(char *buffer) rc =ap_init_apmsg (&ap_msg,0 );if (rc) goto out; - rc =prep_rng_ap_msg (&ap_msg, &func_code, &domain); + rc =prep_rng_ap_msg (&ap_msg, &func_code,NULL );if (rc) goto out;
drivers/s390/crypto/zcrypt_msgtype6.c +14 -8
@@ -329,7 +329,7 @@ struct type86_fmt2_msg {static int xcrb_msg_to_type6cprb_msgx (bool userspace,struct ap_message *ap_msg,struct ica_xcRB *xcrb,unsigned int *fcode, -unsigned short **dom) +unsigned int *domain) {static struct type6_hdr static_type6_hdrX = { .type =0x06 ,
@@ -413,7 +413,8 @@ static int xcrb_msg_to_type6cprb_msgx(bool userspace, struct ap_message *ap_msg, sizeof(msg->hdr.function_code)); *fcode = (msg->hdr.function_code[0 ] <<8 ) | msg->hdr.function_code[1 ]; - *dom = (unsigned short *)&msg->cprbx.domain; +if (domain) + *domain = msg->cprbx.domain;/* check subfunction, US and AU need special flag with NQAP */ if (memcmp(function_code, "US", 2) == 0 ||
@@ -530,7 +531,8 @@ static int xcrb_msg_to_type6_ep11cprb_msgx(bool userspace, struct ap_message *apelse ap_msg->flags |=AP_MSG_FLAG_USAGE ; - *domain = msg->cprbx.target_id; +if (domain) + *domain = msg->cprbx.target_id;return 0 ; }
@@ -1053,7 +1055,7 @@ static long zcrypt_msgtype6_modexpo_crt(struct zcrypt_queue *zq,*/ int prep_cca_ap_msg (bool userspace,struct ica_xcRB *xcrb,struct ap_message *ap_msg, -unsigned int *func_code,unsigned short **dom) +unsigned int *func_code,unsigned int *domain) {struct ap_response_type *resp_type = &ap_msg->response;
@@ -1061,7 +1063,8 @@ int prep_cca_ap_msg(bool userspace, struct ica_xcRB *xcrb, ap_msg->psmid = (((unsigned long )current->pid) <<32 ) +atomic_inc_return (&zcrypt_step); resp_type->type =CEXXC_RESPONSE_TYPE_XCRB ; -return xcrb_msg_to_type6cprb_msgx (userspace, ap_msg, xcrb, func_code, dom); +return xcrb_msg_to_type6cprb_msgx (userspace, ap_msg, + xcrb, func_code, domain); }/*
@@ -1106,6 +1109,9 @@ static long zcrypt_msgtype6_send_cprb(bool userspace, struct zcrypt_queue *zq, msg->hdr.fromcardlen1 -= delta; } +/* update domain field within the CPRB struct */ + msg->cprbx.domain =AP_QID_QUEUE (zq->queue->qid); +init_completion (&resp_type->work); rc =ap_queue_message (zq->queue, ap_msg);if (rc)
@@ -1211,8 +1217,7 @@ static long zcrypt_msgtype6_send_ep11_cprb(bool userspace, struct zcrypt_queue * lfmt =1 ;/* length format #1 */ } payload_hdr = (struct pld_hdr *)((&msg->pld_lenfmt) + lfmt); - payload_hdr->dom_val = (unsigned int ) -AP_QID_QUEUE (zq->queue->qid); + payload_hdr->dom_val =AP_QID_QUEUE (zq->queue->qid); }/*
@@ -1293,7 +1298,8 @@ static inline void rng_type6cprb_msgx(struct ap_message *ap_msg, msg->verb_length =0x02 ; msg->key_length =0x02 ; ap_msg->len =sizeof (*msg); - *domain = (unsigned short )msg->cprbx.domain; +if (domain) + *domain = msg->cprbx.domain; }/*
drivers/s390/crypto/zcrypt_msgtype6.h +1 -1
@@ -96,7 +96,7 @@ struct type86_fmt2_ext {int prep_cca_ap_msg (bool userspace,struct ica_xcRB *xcrb,struct ap_message *ap_msg, -unsigned int *fc,unsigned short **dom); +unsigned int *fc,unsigned int *dom);int prep_ep11_ap_msg (bool userspace,struct ep11_urb *xcrb,struct ap_message *ap_msg,unsigned int *fc,unsigned int *dom);
Signature · 1 line
2.53.0