CVE
stringlengths 13
16
| Description
stringlengths 20
3.95k
| KeyPhrases
stringlengths 2
343
|
|---|---|---|
CVE-2024-26711 | In the Linux kernel, the following vulnerability has been resolved:iio: adc: ad4130: zero-initialize clock init dataThe clk_init_data struct does not have all its membersinitialized, causing issues when trying to expose the internalclock on the CLK pin.Fix this by zero-initializing the clk_init_data struct. | [] |
CVE-2024-26712 | In the Linux kernel, the following vulnerability has been resolved:powerpc/kasan: Fix addr error caused by page alignmentIn kasan_init_region, when k_start is not page aligned, at the begin offor loop, k_cur = k_start & PAGE_MASK is less than k_start, and then`va = block + k_cur - k_start` is less than block, the addr va is invalid,because the memory address space from va to block is not alloced bymemblock_alloc, which will not be reserved by memblock_reserve later, itwill be used by other places.As a result, memory overwriting occurs.for example:int __init __weak kasan_init_region(void *start, size_t size){[...] /* if say block(dcd97000) k_start(feef7400) k_end(feeff3fe) */ block = memblock_alloc(k_end - k_start, PAGE_SIZE); [...] for (k_cur = k_start & PAGE_MASK; k_cur < k_end; k_cur += PAGE_SIZE) { /* at the begin of for loop * block(dcd97000) va(dcd96c00) k_cur(feef7000) k_start(feef7400) * va(dcd96c00) is less than block(dcd97000), va is invalid */ void *va = block + k_cur - k_start; [...] }[...]}Therefore, page alignment is performed on k_start beforememblock_alloc() to ensure the validity of the VA address. | ['memory overwriting', 'memory overwrite'] |
CVE-2024-26713 | In the Linux kernel, the following vulnerability has been resolved:powerpc/pseries/iommu: Fix iommu initialisation during DLPAR addWhen a PCI device is dynamically added, the kernel oopses with a NULLpointer dereference: BUG: Kernel NULL pointer dereference on read at 0x00000030 Faulting instruction address: 0xc0000000006bbe5c Oops: Kernel access of bad area, sig: 11 [#1] LE PAGE_SIZE=64K MMU=Radix SMP NR_CPUS=2048 NUMA pSeries Modules linked in: rpadlpar_io rpaphp rpcsec_gss_krb5 auth_rpcgss nfsv4 dns_resolver nfs lockd grace fscache netfs xsk_diag bonding nft_compat nf_tables nfnetlink rfkill binfmt_misc dm_multipath rpcrdma sunrpc rdma_ucm ib_srpt ib_isert iscsi_target_mod target_core_mod ib_umad ib_iser libiscsi scsi_transport_iscsi ib_ipoib rdma_cm iw_cm ib_cm mlx5_ib ib_uverbs ib_core pseries_rng drm drm_panel_orientation_quirks xfs libcrc32c mlx5_core mlxfw sd_mod t10_pi sg tls ibmvscsi ibmveth scsi_transport_srp vmx_crypto pseries_wdt psample dm_mirror dm_region_hash dm_log dm_mod fuse CPU: 17 PID: 2685 Comm: drmgr Not tainted 6.7.0-203405+ #66 Hardware name: IBM,9080-HEX POWER10 (raw) 0x800200 0xf000006 of:IBM,FW1060.00 (NH1060_008) hv:phyp pSeries NIP: c0000000006bbe5c LR: c000000000a13e68 CTR: c0000000000579f8 REGS: c00000009924f240 TRAP: 0300 Not tainted (6.7.0-203405+) MSR: 8000000000009033 <SF,EE,ME,IR,DR,RI,LE> CR: 24002220 XER: 20040006 CFAR: c000000000a13e64 DAR: 0000000000000030 DSISR: 40000000 IRQMASK: 0 ... NIP sysfs_add_link_to_group+0x34/0x94 LR iommu_device_link+0x5c/0x118 Call Trace: iommu_init_device+0x26c/0x318 (unreliable) iommu_device_link+0x5c/0x118 iommu_init_device+0xa8/0x318 iommu_probe_device+0xc0/0x134 iommu_bus_notifier+0x44/0x104 notifier_call_chain+0xb8/0x19c blocking_notifier_call_chain+0x64/0x98 bus_notify+0x50/0x7c device_add+0x640/0x918 pci_device_add+0x23c/0x298 of_create_pci_dev+0x400/0x884 of_scan_pci_dev+0x124/0x1b0 __of_scan_bus+0x78/0x18c pcibios_scan_phb+0x2a4/0x3b0 init_phb_dynamic+0xb8/0x110 dlpar_add_slot+0x170/0x3b8 [rpadlpar_io] add_slot_store.part.0+0xb4/0x130 [rpadlpar_io] kobj_attr_store+0x2c/0x48 sysfs_kf_write+0x64/0x78 kernfs_fop_write_iter+0x1b0/0x290 vfs_write+0x350/0x4a0 ksys_write+0x84/0x140 system_call_exception+0x124/0x330 system_call_vectored_common+0x15c/0x2ecCommit a940904443e4 ("powerpc/iommu: Add iommu_ops to report capabilitiesand allow blocking domains") broke DLPAR add of PCI devices.The above added iommu_device structure to pci_controller. Duringsystem boot, PCI devices are discovered and this newly added iommu_devicestructure is initialized by a call to iommu_device_register().During DLPAR add of a PCI device, a new pci_controller structure isallocated but there are no calls made to iommu_device_register()interface.Fix is to register the iommu device during DLPAR add as well.[mpe: Trim oops and tweak some change log wording] | ['pci_controller'] |
CVE-2024-26714 | In the Linux kernel, the following vulnerability has been resolved:interconnect: qcom: sc8180x: Mark CO0 BCM keepaliveThe CO0 BCM needs to be up at all times, otherwise some hardware (likethe UFS controller) loses its connection to the rest of the SoC,resulting in a hang of the platform, accompanied by a spectacularlogspam.Mark it as keepalive to prevent such cases. | ['hang'] |
CVE-2024-26715 | In the Linux kernel, the following vulnerability has been resolved:usb: dwc3: gadget: Fix NULL pointer dereference in dwc3_gadget_suspendIn current scenario if Plug-out and Plug-In performed continuouslythere could be a chance while checking for dwc->gadget_driver indwc3_gadget_suspend, a NULL pointer dereference may occur.Call Stack: CPU1: CPU2: gadget_unbind_driver dwc3_suspend_common dwc3_gadget_stop dwc3_gadget_suspend dwc3_disconnect_gadgetCPU1 basically clears the variable and CPU2 checks the variable.Consider CPU1 is running and right before gadget_driver is clearedand in parallel CPU2 executes dwc3_gadget_suspend where it findsdwc->gadget_driver which is not NULL and resumes execution and thenCPU1 completes execution. CPU2 executes dwc3_disconnect_gadget whereit checks dwc->gadget_driver is already NULL because of which theNULL pointer deference occur. | ['null pointer dereference'] |
CVE-2024-26716 | In the Linux kernel, the following vulnerability has been resolved:usb: core: Prevent null pointer dereference in update_port_device_stateCurrently, the function update_port_device_state gets the usb_hub fromudev->parent by calling usb_hub_to_struct_hub.However, in case the actconfig or the maxchild is 0, the usb_hub wouldbe NULL and upon further accessing to get port_dev would result in nullpointer dereference.Fix this by introducing an if check after the usb_hub is populated. | ['null pointer dereference', 'nullpointer dereference'] |
CVE-2024-26717 | In the Linux kernel, the following vulnerability has been resolved:HID: i2c-hid-of: fix NULL-deref on failed power upA while back the I2C HID implementation was split in an ACPI and OFpart, but the new OF driver never initialises the client pointer whichis dereferenced on power-up failures. | ['null-deref'] |
CVE-2024-26718 | In the Linux kernel, the following vulnerability has been resolved:dm-crypt, dm-verity: disable taskletsTasklets have an inherent problem with memory corruption. The functiontasklet_action_common calls tasklet_trylock, then it calls the taskletcallback and then it calls tasklet_unlock. If the tasklet callback freesthe structure that contains the tasklet or if it calls some code that mayfree it, tasklet_unlock will write into free memory.The commits 8e14f610159d and d9a02e016aaf try to fix it for dm-crypt, butit is not a sufficient fix and the data corruption can still happen [1].There is no fix for dm-verity and dm-verity will write into free memorywith every tasklet-processed bio.There will be atomic workqueues implemented in the kernel 6.9 [2]. Theywill have better interface and they will not suffer from the memorycorruption problem.But we need something that stops the memory corruption now and that can bebackported to the stable kernels. So, I'm proposing this commit thatdisables tasklets in both dm-crypt and dm-verity. This commit doesn'tremove the tasklet support, because the tasklet code will be reused whenatomic workqueues will be implemented.[1] https://lore.kernel.org/all/[email protected]/T/[2] https://lore.kernel.org/lkml/[email protected]/ | ['memory corruption', 'data corruption'] |
CVE-2024-26719 | In the Linux kernel, the following vulnerability has been resolved:nouveau: offload fence uevents work to workqueueThis should break the deadlock between the fctx lock and the irq lock.This offloads the processing off the work from the irq into a workqueue. | [] |
CVE-2024-2672 | A vulnerability was found in Campcodes Online Job Finder System 1.0. It has been rated as critical. Affected by this issue is some unknown functionality of the file /admin/user/controller.php. The manipulation of the argument UESRID leads to sql injection. The attack may be launched remotely. The exploit has been disclosed to the public and may be used. The identifier of this vulnerability is VDB-257372. | ['sql injection'] |
CVE-2024-26720 | In the Linux kernel, the following vulnerability has been resolved:mm/writeback: fix possible divide-by-zero in wb_dirty_limits(), again(struct dirty_throttle_control *)->thresh is an unsigned long, but ispassed as the u32 divisor argument to div_u64(). On architectures whereunsigned long is 64 bytes, the argument will be implicitly truncated.Use div64_u64() instead of div_u64() so that the value used in the "isthis a safe division" check is the same as the divisor.Also, remove redundant cast of the numerator to u64, as that should happenimplicitly.This would be difficult to exploit in memcg domain, given the ratio-basedarithmetic domain_drity_limits() uses, but is much easier in globalwriteback domain with a BDI_CAP_STRICTLIMIT-backing device, using e.g. vm.dirty_bytes=(1<<32)*PAGE_SIZE so that dtc->thresh == (1<<32) | ['divide-by-zero'] |
CVE-2024-26721 | In the Linux kernel, the following vulnerability has been resolved:drm/i915/dsc: Fix the macro that calculates DSCC_/DSCA_ PPS reg addressCommit bd077259d0a9 ("drm/i915/vdsc: Add function to read any PPSregister") defines a new macro to calculate the DSC PPS registeraddresses with PPS number as an input. This macro correctly calculatesthe addresses till PPS 11 since the addresses increment by 4. So in thatcase the following macro works correctly to give correct registeraddress:_MMIO(_DSCA_PPS_0 + (pps) * 4)However after PPS 11, the register address for PPS 12 increments by 12because of RC Buffer memory allocation in between. Because of thisdiscontinuity in the address space, the macro calculates wrong addressesfor PPS 12 - 16 resulting into incorrect DSC PPS parameter valueread/writes causing DSC corruption.This fixes it by correcting this macro to add the offset of 12 for PPS>=12.v3: Add correct paranthesis for pps argument (Jani Nikula)(cherry picked from commit 6074be620c31dc2ae11af96a1a5ea95580976fb5) | ['dsc corruption'] |
CVE-2024-26722 | In the Linux kernel, the following vulnerability has been resolved:ASoC: rt5645: Fix deadlock in rt5645_jack_detect_work()There is a path in rt5645_jack_detect_work(), where rt5645->jd_mutexis left locked forever. That may lead to deadlockwhen rt5645_jack_detect_work() is called for the second time.Found by Linux Verification Center (linuxtesting.org) with SVACE. | [] |
CVE-2024-26723 | In the Linux kernel, the following vulnerability has been resolved:lan966x: Fix crash when adding interface under a lagThere is a crash when adding one of the lan966x interfaces under a laginterface. The issue can be reproduced like this:ip link add name bond0 type bond miimon 100 mode balance-xorip link set dev eth0 master bond0The reason is because when adding a interface under the lag it would gothrough all the ports and try to figure out which other ports are underthat lag interface. And the issue is that lan966x can have ports that areNULL pointer as they are not probed. So then iterating over these portsit would just crash as they are NULL pointers.The fix consists in actually checking for NULL pointers before accessingsomething from the ports. Like we do in other places. | ['crash'] |
CVE-2024-26724 | In the Linux kernel, the following vulnerability has been resolved:net/mlx5: DPLL, Fix possible use after free after delayed work timer triggersI managed to hit following use after free warning recently:[ 2169.711665] ==================================================================[ 2169.714009] BUG: KASAN: slab-use-after-free in __run_timers.part.0+0x179/0x4c0[ 2169.716293] Write of size 8 at addr ffff88812b326a70 by task swapper/4/0[ 2169.719022] CPU: 4 PID: 0 Comm: swapper/4 Not tainted 6.8.0-rc2jiri+ #2[ 2169.720974] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS rel-1.13.0-0-gf21b5a4aeb02-prebuilt.qemu.org 04/01/2014[ 2169.722457] Call Trace:[ 2169.722756] <IRQ>[ 2169.723024] dump_stack_lvl+0x58/0xb0[ 2169.723417] print_report+0xc5/0x630[ 2169.723807] ? __virt_addr_valid+0x126/0x2b0[ 2169.724268] kasan_report+0xbe/0xf0[ 2169.724667] ? __run_timers.part.0+0x179/0x4c0[ 2169.725116] ? __run_timers.part.0+0x179/0x4c0[ 2169.725570] __run_timers.part.0+0x179/0x4c0[ 2169.726003] ? call_timer_fn+0x320/0x320[ 2169.726404] ? lock_downgrade+0x3a0/0x3a0[ 2169.726820] ? kvm_clock_get_cycles+0x14/0x20[ 2169.727257] ? ktime_get+0x92/0x150[ 2169.727630] ? lapic_next_deadline+0x35/0x60[ 2169.728069] run_timer_softirq+0x40/0x80[ 2169.728475] __do_softirq+0x1a1/0x509[ 2169.728866] irq_exit_rcu+0x95/0xc0[ 2169.729241] sysvec_apic_timer_interrupt+0x6b/0x80[ 2169.729718] </IRQ>[ 2169.729993] <TASK>[ 2169.730259] asm_sysvec_apic_timer_interrupt+0x16/0x20[ 2169.730755] RIP: 0010:default_idle+0x13/0x20[ 2169.731190] Code: c0 08 00 00 00 4d 29 c8 4c 01 c7 4c 29 c2 e9 72 ff ff ff cc cc cc cc 8b 05 9a 7f 1f 02 85 c0 7e 07 0f 00 2d cf 69 43 00 fb f4 <fa> c3 66 66 2e 0f 1f 84 00 00 00 00 00 65 48 8b 04 25 c0 93 04 00[ 2169.732759] RSP: 0018:ffff888100dbfe10 EFLAGS: 00000242[ 2169.733264] RAX: 0000000000000001 RBX: ffff888100d9c200 RCX: ffffffff8241bd62[ 2169.733925] RDX: ffffed109a848b15 RSI: 0000000000000004 RDI: ffffffff8127ac55[ 2169.734566] RBP: 0000000000000004 R08: 0000000000000000 R09: ffffed109a848b14[ 2169.735200] R10: ffff8884d42458a3 R11: 000000000000ba7e R12: ffffffff83d7d3a0[ 2169.735835] R13: 1ffff110201b7fc6 R14: 0000000000000000 R15: ffff888100d9c200[ 2169.736478] ? ct_kernel_exit.constprop.0+0xa2/0xc0[ 2169.736954] ? do_idle+0x285/0x290[ 2169.737323] default_idle_call+0x63/0x90[ 2169.737730] do_idle+0x285/0x290[ 2169.738089] ? arch_cpu_idle_exit+0x30/0x30[ 2169.738511] ? mark_held_locks+0x1a/0x80[ 2169.738917] ? lockdep_hardirqs_on_prepare+0x12e/0x200[ 2169.739417] cpu_startup_entry+0x30/0x40[ 2169.739825] start_secondary+0x19a/0x1c0[ 2169.740229] ? set_cpu_sibling_map+0xbd0/0xbd0[ 2169.740673] secondary_startup_64_no_verify+0x15d/0x16b[ 2169.741179] </TASK>[ 2169.741686] Allocated by task 1098:[ 2169.742058] kasan_save_stack+0x1c/0x40[ 2169.742456] kasan_save_track+0x10/0x30[ 2169.742852] __kasan_kmalloc+0x83/0x90[ 2169.743246] mlx5_dpll_probe+0xf5/0x3c0 [mlx5_dpll][ 2169.743730] auxiliary_bus_probe+0x62/0xb0[ 2169.744148] really_probe+0x127/0x590[ 2169.744534] __driver_probe_device+0xd2/0x200[ 2169.744973] device_driver_attach+0x6b/0xf0[ 2169.745402] bind_store+0x90/0xe0[ 2169.745761] kernfs_fop_write_iter+0x1df/0x2a0[ 2169.746210] vfs_write+0x41f/0x790[ 2169.746579] ksys_write+0xc7/0x160[ 2169.746947] do_syscall_64+0x6f/0x140[ 2169.747333] entry_SYSCALL_64_after_hwframe+0x46/0x4e[ 2169.748049] Freed by task 1220:[ 2169.748393] kasan_save_stack+0x1c/0x40[ 2169.748789] kasan_save_track+0x10/0x30[ 2169.749188] kasan_save_free_info+0x3b/0x50[ 2169.749621] poison_slab_object+0x106/0x180[ 2169.750044] __kasan_slab_free+0x14/0x50[ 2169.750451] kfree+0x118/0x330[ 2169.750792] mlx5_dpll_remove+0xf5/0x110 [mlx5_dpll][ 2169.751271] auxiliary_bus_remove+0x2e/0x40[ 2169.751694] device_release_driver_internal+0x24b/0x2e0[ 2169.752191] unbind_store+0xa6/0xb0[ 2169.752563] kernfs_fo---truncated--- | ['use after free'] |
CVE-2024-26725 | In the Linux kernel, the following vulnerability has been resolved:dpll: fix possible deadlock during netlink dump operationRecently, I've been hitting following deadlock warning during dpll pindump:[52804.637962] ======================================================[52804.638536] WARNING: possible circular locking dependency detected[52804.639111] 6.8.0-rc2jiri+ #1 Not tainted[52804.639529] ------------------------------------------------------[52804.640104] python3/2984 is trying to acquire lock:[52804.640581] ffff88810e642678 (nlk_cb_mutex-GENERIC){+.+.}-{3:3}, at: netlink_dump+0xb3/0x780[52804.641417] but task is already holding lock:[52804.642010] ffffffff83bde4c8 (dpll_lock){+.+.}-{3:3}, at: dpll_lock_dumpit+0x13/0x20[52804.642747] which lock already depends on the new lock.[52804.643551] the existing dependency chain (in reverse order) is:[52804.644259] -> #1 (dpll_lock){+.+.}-{3:3}:[52804.644836] lock_acquire+0x174/0x3e0[52804.645271] __mutex_lock+0x119/0x1150[52804.645723] dpll_lock_dumpit+0x13/0x20[52804.646169] genl_start+0x266/0x320[52804.646578] __netlink_dump_start+0x321/0x450[52804.647056] genl_family_rcv_msg_dumpit+0x155/0x1e0[52804.647575] genl_rcv_msg+0x1ed/0x3b0[52804.648001] netlink_rcv_skb+0xdc/0x210[52804.648440] genl_rcv+0x24/0x40[52804.648831] netlink_unicast+0x2f1/0x490[52804.649290] netlink_sendmsg+0x36d/0x660[52804.649742] __sock_sendmsg+0x73/0xc0[52804.650165] __sys_sendto+0x184/0x210[52804.650597] __x64_sys_sendto+0x72/0x80[52804.651045] do_syscall_64+0x6f/0x140[52804.651474] entry_SYSCALL_64_after_hwframe+0x46/0x4e[52804.652001] -> #0 (nlk_cb_mutex-GENERIC){+.+.}-{3:3}:[52804.652650] check_prev_add+0x1ae/0x1280[52804.653107] __lock_acquire+0x1ed3/0x29a0[52804.653559] lock_acquire+0x174/0x3e0[52804.653984] __mutex_lock+0x119/0x1150[52804.654423] netlink_dump+0xb3/0x780[52804.654845] __netlink_dump_start+0x389/0x450[52804.655321] genl_family_rcv_msg_dumpit+0x155/0x1e0[52804.655842] genl_rcv_msg+0x1ed/0x3b0[52804.656272] netlink_rcv_skb+0xdc/0x210[52804.656721] genl_rcv+0x24/0x40[52804.657119] netlink_unicast+0x2f1/0x490[52804.657570] netlink_sendmsg+0x36d/0x660[52804.658022] __sock_sendmsg+0x73/0xc0[52804.658450] __sys_sendto+0x184/0x210[52804.658877] __x64_sys_sendto+0x72/0x80[52804.659322] do_syscall_64+0x6f/0x140[52804.659752] entry_SYSCALL_64_after_hwframe+0x46/0x4e[52804.660281] other info that might help us debug this:[52804.661077] Possible unsafe locking scenario:[52804.661671] CPU0 CPU1[52804.662129] ---- ----[52804.662577] lock(dpll_lock);[52804.662924] lock(nlk_cb_mutex-GENERIC);[52804.663538] lock(dpll_lock);[52804.664073] lock(nlk_cb_mutex-GENERIC);[52804.664490]The issue as follows: __netlink_dump_start() calls control->start(cb)with nlk->cb_mutex held. In control->start(cb) the dpll_lock is taken.Then nlk->cb_mutex is released and taken again in netlink_dump(), whiledpll_lock still being held. That leads to ABBA deadlock when anotherCPU races with the same operation.Fix this by moving dpll_lock taking into dumpit() callback which ensurescorrect lock taking order. | [] |
CVE-2024-26726 | In the Linux kernel, the following vulnerability has been resolved:btrfs: don't drop extent_map for free space inode on write errorWhile running the CI for an unrelated change I hit the following panicwith generic/648 on btrfs_holes_spacecache.assertion failed: block_start != EXTENT_MAP_HOLE, in fs/btrfs/extent_io.c:1385------------[ cut here ]------------kernel BUG at fs/btrfs/extent_io.c:1385!invalid opcode: 0000 [#1] PREEMPT SMP NOPTICPU: 1 PID: 2695096 Comm: fsstress Kdump: loaded Tainted: G W 6.8.0-rc2+ #1RIP: 0010:__extent_writepage_io.constprop.0+0x4c1/0x5c0Call Trace: <TASK> extent_write_cache_pages+0x2ac/0x8f0 extent_writepages+0x87/0x110 do_writepages+0xd5/0x1f0 filemap_fdatawrite_wbc+0x63/0x90 __filemap_fdatawrite_range+0x5c/0x80 btrfs_fdatawrite_range+0x1f/0x50 btrfs_write_out_cache+0x507/0x560 btrfs_write_dirty_block_groups+0x32a/0x420 commit_cowonly_roots+0x21b/0x290 btrfs_commit_transaction+0x813/0x1360 btrfs_sync_file+0x51a/0x640 __x64_sys_fdatasync+0x52/0x90 do_syscall_64+0x9c/0x190 entry_SYSCALL_64_after_hwframe+0x6e/0x76This happens because we fail to write out the free space cache in oneinstance, come back around and attempt to write it again. However onthe second pass through we go to call btrfs_get_extent() on the inode toget the extent mapping. Because this is a new block group, and with thefree space inode we always search the commit root to avoid deadlockingwith the tree, we find nothing and return a EXTENT_MAP_HOLE for therequested range.This happens because the first time we try to write the space cache outwe hit an error, and on an error we drop the extent mapping. This isnormal for normal files, but the free space cache inode is special. Wealways expect the extent map to be correct. Thus the second timethrough we end up with a bogus extent map.Since we're deprecating this feature, the most straightforward way tofix this is to simply skip dropping the extent map range for this failedrange.I shortened the test by using error injection to stress the area to makeit easier to reproduce. With this patch in place we no longer panicwith my error injection test. | [] |
CVE-2024-26727 | In the Linux kernel, the following vulnerability has been resolved:btrfs: do not ASSERT() if the newly created subvolume already got read[BUG]There is a syzbot crash, triggered by the ASSERT() during subvolumecreation: assertion failed: !anon_dev, in fs/btrfs/disk-io.c:1319 ------------[ cut here ]------------ kernel BUG at fs/btrfs/disk-io.c:1319! invalid opcode: 0000 [#1] PREEMPT SMP KASAN RIP: 0010:btrfs_get_root_ref.part.0+0x9aa/0xa60 <TASK> btrfs_get_new_fs_root+0xd3/0xf0 create_subvol+0xd02/0x1650 btrfs_mksubvol+0xe95/0x12b0 __btrfs_ioctl_snap_create+0x2f9/0x4f0 btrfs_ioctl_snap_create+0x16b/0x200 btrfs_ioctl+0x35f0/0x5cf0 __x64_sys_ioctl+0x19d/0x210 do_syscall_64+0x3f/0xe0 entry_SYSCALL_64_after_hwframe+0x63/0x6b ---[ end trace 0000000000000000 ]---[CAUSE]During create_subvol(), after inserting root item for the newly createdsubvolume, we would trigger btrfs_get_new_fs_root() to get thebtrfs_root of that subvolume.The idea here is, we have preallocated an anonymous device number forthe subvolume, thus we can assign it to the new subvolume.But there is really nothing preventing things like backref walk to readthe new subvolume.If that happens before we call btrfs_get_new_fs_root(), the subvolumewould be read out, with a new anonymous device number assigned already.In that case, we would trigger ASSERT(), as we really expect no one toread out that subvolume (which is not yet accessible from the fs).But things like backref walk is still possible to trigger the read onthe subvolume.Thus our assumption on the ASSERT() is not correct in the first place.[FIX]Fix it by removing the ASSERT(), and just free the @anon_dev, reset itto 0, and continue.If the subvolume tree is read out by something else, it should havealready get a new anon_dev assigned thus we only need to free thepreallocated one. | ['crash'] |
CVE-2024-26728 | In the Linux kernel, the following vulnerability has been resolved:drm/amd/display: fix null-pointer dereference on edid readingUse i2c adapter when there isn't aux_mode in dc_link to fix anull-pointer derefence that happens when runningigt@kms_force_connector_basic in a system with DCN2.1 and HDMI connectordetected as below:[ +0.178146] BUG: kernel NULL pointer dereference, address: 00000000000004c0[ +0.000010] #PF: supervisor read access in kernel mode[ +0.000005] #PF: error_code(0x0000) - not-present page[ +0.000004] PGD 0 P4D 0[ +0.000006] Oops: 0000 [#1] PREEMPT SMP NOPTI[ +0.000006] CPU: 15 PID: 2368 Comm: kms_force_conne Not tainted 6.5.0-asdn+ #152[ +0.000005] Hardware name: HP HP ENVY x360 Convertible 13-ay1xxx/8929, BIOS F.01 07/14/2021[ +0.000004] RIP: 0010:i2c_transfer+0xd/0x100[ +0.000011] Code: ea fc ff ff 66 0f 1f 84 00 00 00 00 00 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 f3 0f 1e fa 0f 1f 44 00 00 41 54 55 53 <48> 8b 47 10 48 89 fb 48 83 38 00 0f 84 b3 00 00 00 83 3d 2f 80 16[ +0.000004] RSP: 0018:ffff9c4f89c0fad0 EFLAGS: 00010246[ +0.000005] RAX: 0000000000000000 RBX: 0000000000000005 RCX: 0000000000000080[ +0.000003] RDX: 0000000000000002 RSI: ffff9c4f89c0fb20 RDI: 00000000000004b0[ +0.000003] RBP: ffff9c4f89c0fb80 R08: 0000000000000080 R09: ffff8d8e0b15b980[ +0.000003] R10: 00000000000380e0 R11: 0000000000000000 R12: 0000000000000080[ +0.000002] R13: 0000000000000002 R14: ffff9c4f89c0fb0e R15: ffff9c4f89c0fb0f[ +0.000004] FS: 00007f9ad2176c40(0000) GS:ffff8d90fe9c0000(0000) knlGS:0000000000000000[ +0.000003] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033[ +0.000004] CR2: 00000000000004c0 CR3: 0000000121bc4000 CR4: 0000000000750ee0[ +0.000003] PKRU: 55555554[ +0.000003] Call Trace:[ +0.000006] <TASK>[ +0.000006] ? __die+0x23/0x70[ +0.000011] ? page_fault_oops+0x17d/0x4c0[ +0.000008] ? preempt_count_add+0x6e/0xa0[ +0.000008] ? srso_alias_return_thunk+0x5/0x7f[ +0.000011] ? exc_page_fault+0x7f/0x180[ +0.000009] ? asm_exc_page_fault+0x26/0x30[ +0.000013] ? i2c_transfer+0xd/0x100[ +0.000010] drm_do_probe_ddc_edid+0xc2/0x140 [drm][ +0.000067] ? srso_alias_return_thunk+0x5/0x7f[ +0.000006] ? _drm_do_get_edid+0x97/0x3c0 [drm][ +0.000043] ? __pfx_drm_do_probe_ddc_edid+0x10/0x10 [drm][ +0.000042] edid_block_read+0x3b/0xd0 [drm][ +0.000043] _drm_do_get_edid+0xb6/0x3c0 [drm][ +0.000041] ? __pfx_drm_do_probe_ddc_edid+0x10/0x10 [drm][ +0.000043] drm_edid_read_custom+0x37/0xd0 [drm][ +0.000044] amdgpu_dm_connector_mode_valid+0x129/0x1d0 [amdgpu][ +0.000153] drm_connector_mode_valid+0x3b/0x60 [drm_kms_helper][ +0.000000] __drm_helper_update_and_validate+0xfe/0x3c0 [drm_kms_helper][ +0.000000] ? amdgpu_dm_connector_get_modes+0xb6/0x520 [amdgpu][ +0.000000] ? srso_alias_return_thunk+0x5/0x7f[ +0.000000] drm_helper_probe_single_connector_modes+0x2ab/0x540 [drm_kms_helper][ +0.000000] status_store+0xb2/0x1f0 [drm][ +0.000000] kernfs_fop_write_iter+0x136/0x1d0[ +0.000000] vfs_write+0x24d/0x440[ +0.000000] ksys_write+0x6f/0xf0[ +0.000000] do_syscall_64+0x60/0xc0[ +0.000000] ? srso_alias_return_thunk+0x5/0x7f[ +0.000000] ? syscall_exit_to_user_mode+0x2b/0x40[ +0.000000] ? srso_alias_return_thunk+0x5/0x7f[ +0.000000] ? do_syscall_64+0x6c/0xc0[ +0.000000] ? do_syscall_64+0x6c/0xc0[ +0.000000] entry_SYSCALL_64_after_hwframe+0x6e/0xd8[ +0.000000] RIP: 0033:0x7f9ad46b4b00[ +0.000000] Code: 40 00 48 8b 15 19 b3 0d 00 f7 d8 64 89 02 48 c7 c0 ff ff ff ff eb b7 0f 1f 00 80 3d e1 3a 0e 00 00 74 17 b8 01 00 00 00 0f 05 <48> 3d 00 f0 ff ff 77 58 c3 0f 1f 80 00 00 00 00 48 83 ec 28 48 89[ +0.000000] RSP: 002b:00007ffcbd3bd6d8 EFLAGS: 00000202 ORIG_RAX: 0000000000000001[ +0.000000] RAX: ffffffffffffffda RBX: 0000000000000000 RCX: 00007f9ad46b4b00[ +0.000000] RDX: 0000000000000002 RSI: 00007f9ad48a7417 RDI: 0000000000000009[ +0.000000] RBP: 0000000000000002 R08---truncated--- | ['null-pointer dereference', 'null pointer', 'null pointer dereference'] |
CVE-2024-26729 | In the Linux kernel, the following vulnerability has been resolved:drm/amd/display: Fix potential null pointer dereference in dc_dmub_srvFixes potential null pointer dereference warnings in thedc_dmub_srv_cmd_list_queue_execute() and dc_dmub_srv_is_hw_pwr_up()functions.In both functions, the 'dc_dmub_srv' variable was being dereferencedbefore it was checked for null. This could lead to a null pointerdereference if 'dc_dmub_srv' is null. The fix is to check if'dc_dmub_srv' is null before dereferencing it.Thus moving the null checks for 'dc_dmub_srv' to the beginning of thefunctions to ensure that 'dc_dmub_srv' is not null when it isdereferenced.Found by smatch & thus fixing the below:drivers/gpu/drm/amd/amdgpu/../display/dc/dc_dmub_srv.c:133 dc_dmub_srv_cmd_list_queue_execute() warn: variable dereferenced before check 'dc_dmub_srv' (see line 128)drivers/gpu/drm/amd/amdgpu/../display/dc/dc_dmub_srv.c:1167 dc_dmub_srv_is_hw_pwr_up() warn: variable dereferenced before check 'dc_dmub_srv' (see line 1164) | ['null pointer dereference'] |
CVE-2024-2673 | A vulnerability classified as critical has been found in Campcodes Online Job Finder System 1.0. This affects an unknown part of the file /admin/login.php. The manipulation of the argument user_email leads to sql injection. It is possible to initiate the attack remotely. The exploit has been disclosed to the public and may be used. The identifier VDB-257373 was assigned to this vulnerability. | ['sql injection'] |
CVE-2024-26730 | In the Linux kernel, the following vulnerability has been resolved:hwmon: (nct6775) Fix access to temperature configuration registersThe number of temperature configuration registers doesnot always match the total number of temperature registers.This can result in access errors reported if KASAN is enabled.BUG: KASAN: global-out-of-bounds in nct6775_probe+0x5654/0x6fe9 nct6775_core | [] |
CVE-2024-26731 | In the Linux kernel, the following vulnerability has been resolved:bpf, sockmap: Fix NULL pointer dereference in sk_psock_verdict_data_ready()syzbot reported the following NULL pointer dereference issue [1]: BUG: kernel NULL pointer dereference, address: 0000000000000000 [...] RIP: 0010:0x0 [...] Call Trace: <TASK> sk_psock_verdict_data_ready+0x232/0x340 net/core/skmsg.c:1230 unix_stream_sendmsg+0x9b4/0x1230 net/unix/af_unix.c:2293 sock_sendmsg_nosec net/socket.c:730 [inline] __sock_sendmsg+0x221/0x270 net/socket.c:745 ____sys_sendmsg+0x525/0x7d0 net/socket.c:2584 ___sys_sendmsg net/socket.c:2638 [inline] __sys_sendmsg+0x2b0/0x3a0 net/socket.c:2667 do_syscall_64+0xf9/0x240 entry_SYSCALL_64_after_hwframe+0x6f/0x77If sk_psock_verdict_data_ready() and sk_psock_stop_verdict() are calledconcurrently, psock->saved_data_ready can be NULL, causing the above issue.This patch fixes this issue by calling the appropriate data ready functionusing the sk_psock_data_ready() helper and protecting it from concurrencywith sk->sk_callback_lock. | ['bpf', 'null pointer dereference'] |
CVE-2024-26732 | In the Linux kernel, the following vulnerability has been resolved:net: implement lockless setsockopt(SO_PEEK_OFF)syzbot reported a lockdep violation [1] involving af_unixsupport of SO_PEEK_OFF.Since SO_PEEK_OFF is inherently not thread safe (it uses a per-socketsk_peek_off field), there is really no point to enforce a pointlessthread safety in the kernel.After this patch :- setsockopt(SO_PEEK_OFF) no longer acquires the socket lock.- skb_consume_udp() no longer has to acquire the socket lock.- af_unix no longer needs a special version of sk_set_peek_off(), because it does not lock u->iolock anymore.As a followup, we could replace prot->set_peek_off to be a booleanand avoid an indirect call, since we always use sk_set_peek_off().[1]WARNING: possible circular locking dependency detected6.8.0-rc4-syzkaller-00267-g0f1dd5e91e2b #0 Not taintedsyz-executor.2/30025 is trying to acquire lock: ffff8880765e7d80 (&u->iolock){+.+.}-{3:3}, at: unix_set_peek_off+0x26/0xa0 net/unix/af_unix.c:789but task is already holding lock: ffff8880765e7930 (sk_lock-AF_UNIX){+.+.}-{0:0}, at: lock_sock include/net/sock.h:1691 [inline] ffff8880765e7930 (sk_lock-AF_UNIX){+.+.}-{0:0}, at: sockopt_lock_sock net/core/sock.c:1060 [inline] ffff8880765e7930 (sk_lock-AF_UNIX){+.+.}-{0:0}, at: sk_setsockopt+0xe52/0x3360 net/core/sock.c:1193which lock already depends on the new lock.the existing dependency chain (in reverse order) is:-> #1 (sk_lock-AF_UNIX){+.+.}-{0:0}: lock_acquire+0x1e3/0x530 kernel/locking/lockdep.c:5754 lock_sock_nested+0x48/0x100 net/core/sock.c:3524 lock_sock include/net/sock.h:1691 [inline] __unix_dgram_recvmsg+0x1275/0x12c0 net/unix/af_unix.c:2415 sock_recvmsg_nosec+0x18e/0x1d0 net/socket.c:1046 ____sys_recvmsg+0x3c0/0x470 net/socket.c:2801 ___sys_recvmsg net/socket.c:2845 [inline] do_recvmmsg+0x474/0xae0 net/socket.c:2939 __sys_recvmmsg net/socket.c:3018 [inline] __do_sys_recvmmsg net/socket.c:3041 [inline] __se_sys_recvmmsg net/socket.c:3034 [inline] __x64_sys_recvmmsg+0x199/0x250 net/socket.c:3034 do_syscall_64+0xf9/0x240 entry_SYSCALL_64_after_hwframe+0x6f/0x77-> #0 (&u->iolock){+.+.}-{3:3}: check_prev_add kernel/locking/lockdep.c:3134 [inline] check_prevs_add kernel/locking/lockdep.c:3253 [inline] validate_chain+0x18ca/0x58e0 kernel/locking/lockdep.c:3869 __lock_acquire+0x1345/0x1fd0 kernel/locking/lockdep.c:5137 lock_acquire+0x1e3/0x530 kernel/locking/lockdep.c:5754 __mutex_lock_common kernel/locking/mutex.c:608 [inline] __mutex_lock+0x136/0xd70 kernel/locking/mutex.c:752 unix_set_peek_off+0x26/0xa0 net/unix/af_unix.c:789 sk_setsockopt+0x207e/0x3360 do_sock_setsockopt+0x2fb/0x720 net/socket.c:2307 __sys_setsockopt+0x1ad/0x250 net/socket.c:2334 __do_sys_setsockopt net/socket.c:2343 [inline] __se_sys_setsockopt net/socket.c:2340 [inline] __x64_sys_setsockopt+0xb5/0xd0 net/socket.c:2340 do_syscall_64+0xf9/0x240 entry_SYSCALL_64_after_hwframe+0x6f/0x77other info that might help us debug this: Possible unsafe locking scenario: CPU0 CPU1 ---- ---- lock(sk_lock-AF_UNIX); lock(&u->iolock); lock(sk_lock-AF_UNIX); lock(&u->iolock); *** DEADLOCK ***1 lock held by syz-executor.2/30025: #0: ffff8880765e7930 (sk_lock-AF_UNIX){+.+.}-{0:0}, at: lock_sock include/net/sock.h:1691 [inline] #0: ffff8880765e7930 (sk_lock-AF_UNIX){+.+.}-{0:0}, at: sockopt_lock_sock net/core/sock.c:1060 [inline] #0: ffff8880765e7930 (sk_lock-AF_UNIX){+.+.}-{0:0}, at: sk_setsockopt+0xe52/0x3360 net/core/sock.c:1193stack backtrace:CPU: 0 PID: 30025 Comm: syz-executor.2 Not tainted 6.8.0-rc4-syzkaller-00267-g0f1dd5e91e2b #0Hardware name: Google Google C---truncated--- | [] |
CVE-2024-26733 | In the Linux kernel, the following vulnerability has been resolved:arp: Prevent overflow in arp_req_get().syzkaller reported an overflown write in arp_req_get(). [0]When ioctl(SIOCGARP) is issued, arp_req_get() looks up an neighbourentry and copies neigh->ha to struct arpreq.arp_ha.sa_data.The arp_ha here is struct sockaddr, not struct sockaddr_storage, sothe sa_data buffer is just 14 bytes.In the splat below, 2 bytes are overflown to the next int field,arp_flags. We initialise the field just after the memcpy(), so it'snot a problem.However, when dev->addr_len is greater than 22 (e.g. MAX_ADDR_LEN),arp_netmask is overwritten, which could be set as htonl(0xFFFFFFFFUL)in arp_ioctl() before calling arp_req_get().To avoid the overflow, let's limit the max length of memcpy().Note that commit b5f0de6df6dc ("net: dev: Convert sa_data to flexiblearray in struct sockaddr") just silenced syzkaller.[0]:memcpy: detected field-spanning write (size 16) of single field "r->arp_ha.sa_data" at net/ipv4/arp.c:1128 (size 14)WARNING: CPU: 0 PID: 144638 at net/ipv4/arp.c:1128 arp_req_get+0x411/0x4a0 net/ipv4/arp.c:1128Modules linked in:CPU: 0 PID: 144638 Comm: syz-executor.4 Not tainted 6.1.74 #31Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.16.0-debian-1.16.0-5 04/01/2014RIP: 0010:arp_req_get+0x411/0x4a0 net/ipv4/arp.c:1128Code: fd ff ff e8 41 42 de fb b9 0e 00 00 00 4c 89 fe 48 c7 c2 20 6d ab 87 48 c7 c7 80 6d ab 87 c6 05 25 af 72 04 01 e8 5f 8d ad fb <0f> 0b e9 6c fd ff ff e8 13 42 de fb be 03 00 00 00 4c 89 e7 e8 a6RSP: 0018:ffffc900050b7998 EFLAGS: 00010286RAX: 0000000000000000 RBX: ffff88803a815000 RCX: 0000000000000000RDX: 0000000000000000 RSI: ffffffff8641a44a RDI: 0000000000000001RBP: ffffc900050b7a98 R08: 0000000000000001 R09: 0000000000000000R10: 0000000000000000 R11: 203a7970636d656d R12: ffff888039c54000R13: 1ffff92000a16f37 R14: ffff88803a815084 R15: 0000000000000010FS: 00007f172bf306c0(0000) GS:ffff88805aa00000(0000) knlGS:0000000000000000CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033CR2: 00007f172b3569f0 CR3: 0000000057f12005 CR4: 0000000000770ef0DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400PKRU: 55555554Call Trace: <TASK> arp_ioctl+0x33f/0x4b0 net/ipv4/arp.c:1261 inet_ioctl+0x314/0x3a0 net/ipv4/af_inet.c:981 sock_do_ioctl+0xdf/0x260 net/socket.c:1204 sock_ioctl+0x3ef/0x650 net/socket.c:1321 vfs_ioctl fs/ioctl.c:51 [inline] __do_sys_ioctl fs/ioctl.c:870 [inline] __se_sys_ioctl fs/ioctl.c:856 [inline] __x64_sys_ioctl+0x18e/0x220 fs/ioctl.c:856 do_syscall_x64 arch/x86/entry/common.c:51 [inline] do_syscall_64+0x37/0x90 arch/x86/entry/common.c:81 entry_SYSCALL_64_after_hwframe+0x64/0xceRIP: 0033:0x7f172b262b8dCode: 66 2e 0f 1f 84 00 00 00 00 00 0f 1f 00 f3 0f 1e fa 48 89 f8 48 89 f7 48 89 d6 48 89 ca 4d 89 c2 4d 89 c8 4c 8b 4c 24 08 0f 05 <48> 3d 01 f0 ff ff 73 01 c3 48 c7 c1 b8 ff ff ff f7 d8 64 89 01 48RSP: 002b:00007f172bf300b8 EFLAGS: 00000246 ORIG_RAX: 0000000000000010RAX: ffffffffffffffda RBX: 00007f172b3abf80 RCX: 00007f172b262b8dRDX: 0000000020000000 RSI: 0000000000008954 RDI: 0000000000000003RBP: 00007f172b2d3493 R08: 0000000000000000 R09: 0000000000000000R10: 0000000000000000 R11: 0000000000000246 R12: 0000000000000000R13: 000000000000000b R14: 00007f172b3abf80 R15: 00007f172bf10000 </TASK> | ['overflow'] |
CVE-2024-26734 | In the Linux kernel, the following vulnerability has been resolved:devlink: fix possible use-after-free and memory leaks in devlink_init()The pernet operations structure for the subsystem must be registeredbefore registering the generic netlink family.Make an unregister in case of unsuccessful registration. | ['use-after-free', 'memory leaks', 'use after free'] |
CVE-2024-26735 | In the Linux kernel, the following vulnerability has been resolved:ipv6: sr: fix possible use-after-free and null-ptr-derefThe pernet operations structure for the subsystem must be registeredbefore registering the generic netlink family. | ['use-after-free', 'null-ptr-derefthe', 'use after free'] |
CVE-2024-26736 | In the Linux kernel, the following vulnerability has been resolved:afs: Increase buffer size in afs_update_volume_status()The max length of volume->vid value is 20 characters.So increase idbuf[] size up to 24 to avoid overflow.Found by Linux Verification Center (linuxtesting.org) with SVACE.[DH: Actually, it's 20 + NUL, so increase it to 24 and use snprintf()] | ['overflow'] |
CVE-2024-26737 | In the Linux kernel, the following vulnerability has been resolved:bpf: Fix racing between bpf_timer_cancel_and_free and bpf_timer_cancelThe following race is possible between bpf_timer_cancel_and_freeand bpf_timer_cancel. It will lead a UAF on the timer->timer.bpf_timer_cancel(); spin_lock(); t = timer->time; spin_unlock(); bpf_timer_cancel_and_free(); spin_lock(); t = timer->timer; timer->timer = NULL; spin_unlock(); hrtimer_cancel(&t->timer); kfree(t); /* UAF on t */ hrtimer_cancel(&t->timer);In bpf_timer_cancel_and_free, this patch frees the timer->timerafter a rcu grace period. This requires a rcu_head additionto the "struct bpf_hrtimer". Another kfree(t) happens in bpf_timer_init,this does not need a kfree_rcu because it is still under thespin_lock and timer->timer has not been visible by others yet.In bpf_timer_cancel, rcu_read_lock() is added because this helpercan be used in a non rcu critical section context (e.g. froma sleepable bpf prog). Other timer->timer usages in helpers.chave been audited, bpf_timer_cancel() is the only place wheretimer->timer is used outside of the spin_lock.Another solution considered is to mark a t->flag in bpf_timer_canceland clear it after hrtimer_cancel() is done. In bpf_timer_cancel_and_free,it busy waits for the flag to be cleared before kfree(t). This patchgoes with a straight forward solution and frees timer->timer aftera rcu grace period. | ['uaf'] |
CVE-2024-26738 | In the Linux kernel, the following vulnerability has been resolved:powerpc/pseries/iommu: DLPAR add doesn't completely initialize pci_controllerWhen a PCI device is dynamically added, the kernel oopses with a NULLpointer dereference: BUG: Kernel NULL pointer dereference on read at 0x00000030 Faulting instruction address: 0xc0000000006bbe5c Oops: Kernel access of bad area, sig: 11 [#1] LE PAGE_SIZE=64K MMU=Radix SMP NR_CPUS=2048 NUMA pSeries Modules linked in: rpadlpar_io rpaphp rpcsec_gss_krb5 auth_rpcgss nfsv4 dns_resolver nfs lockd grace fscache netfs xsk_diag bonding nft_compat nf_tables nfnetlink rfkill binfmt_misc dm_multipath rpcrdma sunrpc rdma_ucm ib_srpt ib_isert iscsi_target_mod target_core_mod ib_umad ib_iser libiscsi scsi_transport_iscsi ib_ipoib rdma_cm iw_cm ib_cm mlx5_ib ib_uverbs ib_core pseries_rng drm drm_panel_orientation_quirks xfs libcrc32c mlx5_core mlxfw sd_mod t10_pi sg tls ibmvscsi ibmveth scsi_transport_srp vmx_crypto pseries_wdt psample dm_mirror dm_region_hash dm_log dm_mod fuse CPU: 17 PID: 2685 Comm: drmgr Not tainted 6.7.0-203405+ #66 Hardware name: IBM,9080-HEX POWER10 (raw) 0x800200 0xf000006 of:IBM,FW1060.00 (NH1060_008) hv:phyp pSeries NIP: c0000000006bbe5c LR: c000000000a13e68 CTR: c0000000000579f8 REGS: c00000009924f240 TRAP: 0300 Not tainted (6.7.0-203405+) MSR: 8000000000009033 <SF,EE,ME,IR,DR,RI,LE> CR: 24002220 XER: 20040006 CFAR: c000000000a13e64 DAR: 0000000000000030 DSISR: 40000000 IRQMASK: 0 ... NIP sysfs_add_link_to_group+0x34/0x94 LR iommu_device_link+0x5c/0x118 Call Trace: iommu_init_device+0x26c/0x318 (unreliable) iommu_device_link+0x5c/0x118 iommu_init_device+0xa8/0x318 iommu_probe_device+0xc0/0x134 iommu_bus_notifier+0x44/0x104 notifier_call_chain+0xb8/0x19c blocking_notifier_call_chain+0x64/0x98 bus_notify+0x50/0x7c device_add+0x640/0x918 pci_device_add+0x23c/0x298 of_create_pci_dev+0x400/0x884 of_scan_pci_dev+0x124/0x1b0 __of_scan_bus+0x78/0x18c pcibios_scan_phb+0x2a4/0x3b0 init_phb_dynamic+0xb8/0x110 dlpar_add_slot+0x170/0x3b8 [rpadlpar_io] add_slot_store.part.0+0xb4/0x130 [rpadlpar_io] kobj_attr_store+0x2c/0x48 sysfs_kf_write+0x64/0x78 kernfs_fop_write_iter+0x1b0/0x290 vfs_write+0x350/0x4a0 ksys_write+0x84/0x140 system_call_exception+0x124/0x330 system_call_vectored_common+0x15c/0x2ecCommit a940904443e4 ("powerpc/iommu: Add iommu_ops to report capabilitiesand allow blocking domains") broke DLPAR add of PCI devices.The above added iommu_device structure to pci_controller. Duringsystem boot, PCI devices are discovered and this newly added iommu_devicestructure is initialized by a call to iommu_device_register().During DLPAR add of a PCI device, a new pci_controller structure isallocated but there are no calls made to iommu_device_register()interface.Fix is to register the iommu device during DLPAR add as well. | ['pci_controller'] |
CVE-2024-26739 | In the Linux kernel, the following vulnerability has been resolved:net/sched: act_mirred: don't override retval if we already lost the skbIf we're redirecting the skb, and haven't called tcf_mirred_forward(),yet, we need to tell the core to drop the skb by setting the retcodeto SHOT. If we have called tcf_mirred_forward(), however, the skbis out of our hands and returning SHOT will lead to UaF.Move the retval override to the error path which actually need it. | ['uaf'] |
CVE-2024-2674 | A vulnerability classified as critical was found in Campcodes Online Job Finder System 1.0. This vulnerability affects unknown code of the file /admin/employee/index.php. The manipulation of the argument id leads to sql injection. The attack can be initiated remotely. The exploit has been disclosed to the public and may be used. VDB-257374 is the identifier assigned to this vulnerability. | ['sql injection'] |
CVE-2024-26740 | In the Linux kernel, the following vulnerability has been resolved:net/sched: act_mirred: use the backlog for mirred ingressThe test Davide added in commit ca22da2fbd69 ("act_mirred: use the backlogfor nested calls to mirred ingress") hangs our testing VMs every 10 or soruns, with the familiar tcp_v4_rcv -> tcp_v4_rcv deadlock reported bylockdep.The problem as previously described by Davide (see Link) is thatif we reverse flow of traffic with the redirect (egress -> ingress)we may reach the same socket which generated the packet. And we maystill be holding its socket lock. The common solution to such deadlocksis to put the packet in the Rx backlog, rather than run the Rx pathinline. Do that for all egress -> ingress reversals, not just oncewe started to nest mirred calls.In the past there was a concern that the backlog indirection willlead to loss of error reporting / less accurate stats. But the currentworkaround does not seem to address the issue. | ['hang'] |
CVE-2024-26741 | In the Linux kernel, the following vulnerability has been resolved:dccp/tcp: Unhash sk from ehash for tb2 alloc failure after check_estalblished().syzkaller reported a warning [0] in inet_csk_destroy_sock() with norepro. WARN_ON(inet_sk(sk)->inet_num && !inet_csk(sk)->icsk_bind_hash);However, the syzkaller's log hinted that connect() failed just beforethe warning due to FAULT_INJECTION. [1]When connect() is called for an unbound socket, we search for anavailable ephemeral port. If a bhash bucket exists for the port, wecall __inet_check_established() or __inet6_check_established() to checkif the bucket is reusable.If reusable, we add the socket into ehash and set inet_sk(sk)->inet_num.Later, we look up the corresponding bhash2 bucket and try to allocateit if it does not exist.Although it rarely occurs in real use, if the allocation fails, we mustrevert the changes by check_established(). Otherwise, an unconnectedsocket could illegally occupy an ehash entry.Note that we do not put tw back into ehash because sk might havealready responded to a packet for tw and it would be better to freetw earlier under such memory presure.[0]:WARNING: CPU: 0 PID: 350830 at net/ipv4/inet_connection_sock.c:1193 inet_csk_destroy_sock (net/ipv4/inet_connection_sock.c:1193)Modules linked in:Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS rel-1.16.0-0-gd239552ce722-prebuilt.qemu.org 04/01/2014RIP: 0010:inet_csk_destroy_sock (net/ipv4/inet_connection_sock.c:1193)Code: 41 5c 41 5d 41 5e e9 2d 4a 3d fd e8 28 4a 3d fd 48 89 ef e8 f0 cd 7d ff 5b 5d 41 5c 41 5d 41 5e e9 13 4a 3d fd e8 0e 4a 3d fd <0f> 0b e9 61 fe ff ff e8 02 4a 3d fd 4c 89 e7 be 03 00 00 00 e8 05RSP: 0018:ffffc9000b21fd38 EFLAGS: 00010293RAX: 0000000000000000 RBX: 0000000000009e78 RCX: ffffffff840bae40RDX: ffff88806e46c600 RSI: ffffffff840bb012 RDI: ffff88811755cca8RBP: ffff88811755c880 R08: 0000000000000003 R09: 0000000000000000R10: 0000000000009e78 R11: 0000000000000000 R12: ffff88811755c8e0R13: ffff88811755c892 R14: ffff88811755c918 R15: 0000000000000000FS: 00007f03e5243800(0000) GS:ffff88811ae00000(0000) knlGS:0000000000000000CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033CR2: 0000001b32f21000 CR3: 0000000112ffe001 CR4: 0000000000770ef0PKRU: 55555554Call Trace: <TASK> ? inet_csk_destroy_sock (net/ipv4/inet_connection_sock.c:1193) dccp_close (net/dccp/proto.c:1078) inet_release (net/ipv4/af_inet.c:434) __sock_release (net/socket.c:660) sock_close (net/socket.c:1423) __fput (fs/file_table.c:377) __fput_sync (fs/file_table.c:462) __x64_sys_close (fs/open.c:1557 fs/open.c:1539 fs/open.c:1539) do_syscall_64 (arch/x86/entry/common.c:52 arch/x86/entry/common.c:83) entry_SYSCALL_64_after_hwframe (arch/x86/entry/entry_64.S:129)RIP: 0033:0x7f03e53852bbCode: 03 00 00 00 0f 05 48 3d 00 f0 ff ff 77 41 c3 48 83 ec 18 89 7c 24 0c e8 43 c9 f5 ff 8b 7c 24 0c 41 89 c0 b8 03 00 00 00 0f 05 <48> 3d 00 f0 ff ff 77 35 44 89 c7 89 44 24 0c e8 a1 c9 f5 ff 8b 44RSP: 002b:00000000005dfba0 EFLAGS: 00000293 ORIG_RAX: 0000000000000003RAX: ffffffffffffffda RBX: 0000000000000004 RCX: 00007f03e53852bbRDX: 0000000000000002 RSI: 0000000000000002 RDI: 0000000000000003RBP: 0000000000000000 R08: 0000000000000000 R09: 000000000000167cR10: 0000000008a79680 R11: 0000000000000293 R12: 00007f03e4e43000R13: 00007f03e4e43170 R14: 00007f03e4e43178 R15: 00007f03e4e43170 </TASK>[1]:FAULT_INJECTION: forcing a failure.name failslab, interval 1, probability 0, space 0, times 0CPU: 0 PID: 350833 Comm: syz-executor.1 Not tainted 6.7.0-12272-g2121c43f88f5 #9Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS rel-1.16.0-0-gd239552ce722-prebuilt.qemu.org 04/01/2014Call Trace: <TASK> dump_stack_lvl (lib/dump_stack.c:107 (discriminator 1)) should_fail_ex (lib/fault-inject.c:52 lib/fault-inject.c:153) should_failslab (mm/slub.c:3748) kmem_cache_alloc (mm/slub.c:3763 mm/slub.c:3842 mm/slub.c:3867) inet_bind2_bucket_create ---truncated--- | [] |
CVE-2024-26742 | In the Linux kernel, the following vulnerability has been resolved:scsi: smartpqi: Fix disable_managed_interruptsCorrect blk-mq registration issue with module parameterdisable_managed_interrupts enabled.When we turn off the default PCI_IRQ_AFFINITY flag, the driver needs toregister with blk-mq using blk_mq_map_queues(). The driver is currentlycalling blk_mq_pci_map_queues() which results in a stack trace and possiblyundefined behavior.Stack Trace:[ 7.860089] scsi host2: smartpqi[ 7.871934] WARNING: CPU: 0 PID: 238 at block/blk-mq-pci.c:52 blk_mq_pci_map_queues+0xca/0xd0[ 7.889231] Modules linked in: sd_mod t10_pi sg uas smartpqi(+) crc32c_intel scsi_transport_sas usb_storage dm_mirror dm_region_hash dm_log dm_mod ipmi_devintf ipmi_msghandler fuse[ 7.924755] CPU: 0 PID: 238 Comm: kworker/0:3 Not tainted 4.18.0-372.88.1.el8_6_smartpqi_test.x86_64 #1[ 7.944336] Hardware name: HPE ProLiant DL380 Gen10/ProLiant DL380 Gen10, BIOS U30 03/08/2022[ 7.963026] Workqueue: events work_for_cpu_fn[ 7.978275] RIP: 0010:blk_mq_pci_map_queues+0xca/0xd0[ 7.978278] Code: 48 89 de 89 c7 e8 f6 0f 4f 00 3b 05 c4 b7 8e 01 72 e1 5b 31 c0 5d 41 5c 41 5d 41 5e 41 5f e9 7d df 73 00 31 c0 e9 76 df 73 00 <0f> 0b eb bc 90 90 0f 1f 44 00 00 41 57 49 89 ff 41 56 41 55 41 54[ 7.978280] RSP: 0018:ffffa95fc3707d50 EFLAGS: 00010216[ 7.978283] RAX: 00000000ffffffff RBX: 0000000000000000 RCX: 0000000000000010[ 7.978284] RDX: 0000000000000004 RSI: 0000000000000000 RDI: ffff9190c32d4310[ 7.978286] RBP: 0000000000000000 R08: ffffa95fc3707d38 R09: ffff91929b81ac00[ 7.978287] R10: 0000000000000001 R11: ffffa95fc3707ac0 R12: 0000000000000000[ 7.978288] R13: ffff9190c32d4000 R14: 00000000ffffffff R15: ffff9190c4c950a8[ 7.978290] FS: 0000000000000000(0000) GS:ffff9193efc00000(0000) knlGS:0000000000000000[ 7.978292] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033[ 8.172814] CR2: 000055d11166c000 CR3: 00000002dae10002 CR4: 00000000007706f0[ 8.172816] DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000[ 8.172817] DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400[ 8.172818] PKRU: 55555554[ 8.172819] Call Trace:[ 8.172823] blk_mq_alloc_tag_set+0x12e/0x310[ 8.264339] scsi_add_host_with_dma.cold.9+0x30/0x245[ 8.279302] pqi_ctrl_init+0xacf/0xc8e [smartpqi][ 8.294085] ? pqi_pci_probe+0x480/0x4c8 [smartpqi][ 8.309015] pqi_pci_probe+0x480/0x4c8 [smartpqi][ 8.323286] local_pci_probe+0x42/0x80[ 8.337855] work_for_cpu_fn+0x16/0x20[ 8.351193] process_one_work+0x1a7/0x360[ 8.364462] ? create_worker+0x1a0/0x1a0[ 8.379252] worker_thread+0x1ce/0x390[ 8.392623] ? create_worker+0x1a0/0x1a0[ 8.406295] kthread+0x10a/0x120[ 8.418428] ? set_kthread_struct+0x50/0x50[ 8.431532] ret_from_fork+0x1f/0x40[ 8.444137] ---[ end trace 1bf0173d39354506 ]--- | [] |
CVE-2024-26743 | In the Linux kernel, the following vulnerability has been resolved:RDMA/qedr: Fix qedr_create_user_qp error flowAvoid the following warning by making sure to free the allocatedresources in case that qedr_init_user_queue() fail.-----------[ cut here ]-----------WARNING: CPU: 0 PID: 143192 at drivers/infiniband/core/rdma_core.c:874 uverbs_destroy_ufile_hw+0xcf/0xf0 [ib_uverbs]Modules linked in: tls target_core_user uio target_core_pscsi target_core_file target_core_iblock ib_srpt ib_srp scsi_transport_srp nfsd nfs_acl rpcsec_gss_krb5 auth_rpcgss nfsv4 dns_resolver nfs lockd grace fscache netfs 8021q garp mrp stp llc ext4 mbcache jbd2 opa_vnic ib_umad ib_ipoib sunrpc rdma_ucm ib_isert iscsi_target_mod target_core_mod ib_iser libiscsi scsi_transport_iscsi rdma_cm iw_cm ib_cm hfi1 intel_rapl_msr intel_rapl_common mgag200 qedr sb_edac drm_shmem_helper rdmavt x86_pkg_temp_thermal drm_kms_helper intel_powerclamp ib_uverbs coretemp i2c_algo_bit kvm_intel dell_wmi_descriptor ipmi_ssif sparse_keymap kvm ib_core rfkill syscopyarea sysfillrect video sysimgblt irqbypass ipmi_si ipmi_devintf fb_sys_fops rapl iTCO_wdt mxm_wmi iTCO_vendor_support intel_cstate pcspkr dcdbas intel_uncore ipmi_msghandler lpc_ich acpi_power_meter mei_me mei fuse drm xfs libcrc32c qede sd_mod ahci libahci t10_pi sg crct10dif_pclmul crc32_pclmul crc32c_intel qed libata tg3ghash_clmulni_intel megaraid_sas crc8 wmi [last unloaded: ib_srpt]CPU: 0 PID: 143192 Comm: fi_rdm_tagged_p Kdump: loaded Not tainted 5.14.0-408.el9.x86_64 #1Hardware name: Dell Inc. PowerEdge R430/03XKDV, BIOS 2.14.0 01/25/2022RIP: 0010:uverbs_destroy_ufile_hw+0xcf/0xf0 [ib_uverbs]Code: 5d 41 5c 41 5d 41 5e e9 0f 26 1b dd 48 89 df e8 67 6a ff ff 49 8b 86 10 01 00 00 48 85 c0 74 9c 4c 89 e7 e8 83 c0 cb dd eb 92 <0f> 0b eb be 0f 0b be 04 00 00 00 48 89 df e8 8e f5 ff ff e9 6d ffRSP: 0018:ffffb7c6cadfbc60 EFLAGS: 00010286RAX: ffff8f0889ee3f60 RBX: ffff8f088c1a5200 RCX: 00000000802a0016RDX: 00000000802a0017 RSI: 0000000000000001 RDI: ffff8f0880042600RBP: 0000000000000001 R08: 0000000000000001 R09: 0000000000000000R10: ffff8f11fffd5000 R11: 0000000000039000 R12: ffff8f0d5b36cd80R13: ffff8f088c1a5250 R14: ffff8f1206d91000 R15: 0000000000000000FS: 0000000000000000(0000) GS:ffff8f11d7c00000(0000) knlGS:0000000000000000CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033CR2: 0000147069200e20 CR3: 00000001c7210002 CR4: 00000000001706f0Call Trace:<TASK>? show_trace_log_lvl+0x1c4/0x2df? show_trace_log_lvl+0x1c4/0x2df? ib_uverbs_close+0x1f/0xb0 [ib_uverbs]? uverbs_destroy_ufile_hw+0xcf/0xf0 [ib_uverbs]? __warn+0x81/0x110? uverbs_destroy_ufile_hw+0xcf/0xf0 [ib_uverbs]? report_bug+0x10a/0x140? handle_bug+0x3c/0x70? exc_invalid_op+0x14/0x70? asm_exc_invalid_op+0x16/0x20? uverbs_destroy_ufile_hw+0xcf/0xf0 [ib_uverbs]ib_uverbs_close+0x1f/0xb0 [ib_uverbs]__fput+0x94/0x250task_work_run+0x5c/0x90do_exit+0x270/0x4a0do_group_exit+0x2d/0x90get_signal+0x87c/0x8c0arch_do_signal_or_restart+0x25/0x100? ib_uverbs_ioctl+0xc2/0x110 [ib_uverbs]exit_to_user_mode_loop+0x9c/0x130exit_to_user_mode_prepare+0xb6/0x100syscall_exit_to_user_mode+0x12/0x40do_syscall_64+0x69/0x90? syscall_exit_work+0x103/0x130? syscall_exit_to_user_mode+0x22/0x40? do_syscall_64+0x69/0x90? syscall_exit_work+0x103/0x130? syscall_exit_to_user_mode+0x22/0x40? do_syscall_64+0x69/0x90? do_syscall_64+0x69/0x90? common_interrupt+0x43/0xa0entry_SYSCALL_64_after_hwframe+0x72/0xdcRIP: 0033:0x1470abe3ec6bCode: Unable to access opcode bytes at RIP 0x1470abe3ec41.RSP: 002b:00007fff13ce9108 EFLAGS: 00000246 ORIG_RAX: 0000000000000010RAX: fffffffffffffffc RBX: 00007fff13ce9218 RCX: 00001470abe3ec6bRDX: 00007fff13ce9200 RSI: 00000000c0181b01 RDI: 0000000000000004RBP: 00007fff13ce91e0 R08: 0000558d9655da10 R09: 0000558d9655dd00R10: 00007fff13ce95c0 R11: 0000000000000246 R12: 00007fff13ce9358R13: 0000000000000013 R14: 0000558d9655db50 R15: 00007fff13ce9470</TASK>--[ end trace 888a9b92e04c5c97 ]-- | [] |
CVE-2024-26744 | In the Linux kernel, the following vulnerability has been resolved:RDMA/srpt: Support specifying the srpt_service_guid parameterMake loading ib_srpt with this parameter set work. The current behavior isthat setting that parameter while loading the ib_srpt kernel moduletriggers the following kernel crash:BUG: kernel NULL pointer dereference, address: 0000000000000000Call Trace: <TASK> parse_one+0x18c/0x1d0 parse_args+0xe1/0x230 load_module+0x8de/0xa60 init_module_from_file+0x8b/0xd0 idempotent_init_module+0x181/0x240 __x64_sys_finit_module+0x5a/0xb0 do_syscall_64+0x5f/0xe0 entry_SYSCALL_64_after_hwframe+0x6e/0x76 | ['null pointer dereference'] |
CVE-2024-26747 | In the Linux kernel, the following vulnerability has been resolved:usb: roles: fix NULL pointer issue when put module's referenceIn current design, usb role class driver will get usb_role_switch parent'smodule reference after the user get usb_role_switch device and put thereference after the user put the usb_role_switch device. However, theparent device of usb_role_switch may be removed before the user put theusb_role_switch. If so, then, NULL pointer issue will be met when the userput the parent module's reference.This will save the module pointer in structure of usb_role_switch. Then,we don't need to find module by iterating long relations. | ['null pointer issue'] |
CVE-2024-26748 | In the Linux kernel, the following vulnerability has been resolved:usb: cdns3: fix memory double free when handle zero packet829 if (request->complete) {830 spin_unlock(&priv_dev->lock);831 usb_gadget_giveback_request(&priv_ep->endpoint,832 request);833 spin_lock(&priv_dev->lock);834 }835836 if (request->buf == priv_dev->zlp_buf)837 cdns3_gadget_ep_free_request(&priv_ep->endpoint, request);Driver append an additional zero packet request when queue a packet, whichlength mod max packet size is 0. When transfer complete, run to line 831,usb_gadget_giveback_request() will free this requestion. 836 condition istrue, so cdns3_gadget_ep_free_request() free this request again.Log:[ 1920.140696][ T150] BUG: KFENCE: use-after-free read in cdns3_gadget_giveback+0x134/0x2c0 [cdns3][ 1920.140696][ T150][ 1920.151837][ T150] Use-after-free read at 0x000000003d1cd10b (in kfence-#36):[ 1920.159082][ T150] cdns3_gadget_giveback+0x134/0x2c0 [cdns3][ 1920.164988][ T150] cdns3_transfer_completed+0x438/0x5f8 [cdns3]Add check at line 829, skip call usb_gadget_giveback_request() if it isadditional zero length packet request. Needn't callusb_gadget_giveback_request() because it is allocated in this driver. | ['memory double free', 'use after free'] |
CVE-2024-26749 | In the Linux kernel, the following vulnerability has been resolved:usb: cdns3: fixed memory use after free at cdns3_gadget_ep_disable() ... cdns3_gadget_ep_free_request(&priv_ep->endpoint, &priv_req->request); list_del_init(&priv_req->list); ...'priv_req' actually free at cdns3_gadget_ep_free_request(). Butlist_del_init() use priv_req->list after it.[ 1542.642868][ T534] BUG: KFENCE: use-after-free read in __list_del_entry_valid+0x10/0xd4[ 1542.642868][ T534][ 1542.653162][ T534] Use-after-free read at 0x000000009ed0ba99 (in kfence-#3):[ 1542.660311][ T534] __list_del_entry_valid+0x10/0xd4[ 1542.665375][ T534] cdns3_gadget_ep_disable+0x1f8/0x388 [cdns3][ 1542.671571][ T534] usb_ep_disable+0x44/0xe4[ 1542.675948][ T534] ffs_func_eps_disable+0x64/0xc8[ 1542.680839][ T534] ffs_func_set_alt+0x74/0x368[ 1542.685478][ T534] ffs_func_disable+0x18/0x28Move list_del_init() before cdns3_gadget_ep_free_request() to resolve thisproblem. | ['memory use after free'] |
CVE-2024-2675 | A vulnerability, which was classified as critical, has been found in Campcodes Online Job Finder System 1.0. This issue affects some unknown processing of the file /admin/company/index.php. The manipulation of the argument id leads to sql injection. The attack may be initiated remotely. The exploit has been disclosed to the public and may be used. The associated identifier of this vulnerability is VDB-257375. | ['sql injection'] |
CVE-2024-26751 | In the Linux kernel, the following vulnerability has been resolved:ARM: ep93xx: Add terminator to gpiod_lookup_tableWithout the terminator, if a con_id is passed to gpio_find() thatdoes not exist in the lookup table the function will not stop loopingcorrectly, and eventually cause an oops. | ['oops'] |
CVE-2024-26752 | In the Linux kernel, the following vulnerability has been resolved:l2tp: pass correct message length to ip6_append_datal2tp_ip6_sendmsg needs to avoid accounting for the transport headertwice when splicing more data into an already partially-occupied skbuff.To manage this, we check whether the skbuff contains data usingskb_queue_empty when deciding how much data to append usingip6_append_data.However, the code which performed the calculation was incorrect: ulen = len + skb_queue_empty(&sk->sk_write_queue) ? transhdrlen : 0;...due to C operator precedence, this ends up setting ulen totranshdrlen for messages with a non-zero length, which results incorrupted packets on the wire.Add parentheses to correct the calculation in line with the originalintent. | [] |
CVE-2024-26753 | In the Linux kernel, the following vulnerability has been resolved:crypto: virtio/akcipher - Fix stack overflow on memcpysizeof(struct virtio_crypto_akcipher_session_para) is less thansizeof(struct virtio_crypto_op_ctrl_req::u), copying more bytes fromstack variable leads stack overflow. Clang reports this issue bycommands:make -j CC=clang-14 mrproper >/dev/null 2>&1make -j O=/tmp/crypto-build CC=clang-14 allmodconfig >/dev/null 2>&1make -j O=/tmp/crypto-build W=1 CC=clang-14 drivers/crypto/virtio/ virtio_crypto_akcipher_algs.o | ['stack overflow'] |
CVE-2024-26754 | In the Linux kernel, the following vulnerability has been resolved:gtp: fix use-after-free and null-ptr-deref in gtp_genl_dump_pdp()The gtp_net_ops pernet operations structure for the subsystem must beregistered before registering the generic netlink family.Syzkaller hit 'general protection fault in gtp_genl_dump_pdp' bug:general protection fault, probably for non-canonical address0xdffffc0000000002: 0000 [#1] PREEMPT SMP KASAN NOPTIKASAN: null-ptr-deref in range [0x0000000000000010-0x0000000000000017]CPU: 1 PID: 5826 Comm: gtp Not tainted 6.8.0-rc3-std-def-alt1 #1Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.16.0-alt1 04/01/2014RIP: 0010:gtp_genl_dump_pdp+0x1be/0x800 [gtp]Code: c6 89 c6 e8 64 e9 86 df 58 45 85 f6 0f 85 4e 04 00 00 e8 c5 ee 86 df 48 8b 54 24 18 48 b8 00 00 00 00 00 fc ff df 48 c1 ea 03 <80> 3c 02 00 0f 85 de 05 00 00 48 8b 44 24 18 4c 8b 30 4c 39 f0 74RSP: 0018:ffff888014107220 EFLAGS: 00010202RAX: dffffc0000000000 RBX: 0000000000000000 RCX: 0000000000000000RDX: 0000000000000002 RSI: 0000000000000000 RDI: 0000000000000000RBP: 0000000000000000 R08: 0000000000000000 R09: 0000000000000000R10: 0000000000000000 R11: 0000000000000000 R12: 0000000000000000R13: ffff88800fcda588 R14: 0000000000000001 R15: 0000000000000000FS: 00007f1be4eb05c0(0000) GS:ffff88806ce80000(0000) knlGS:0000000000000000CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033CR2: 00007f1be4e766cf CR3: 000000000c33e000 CR4: 0000000000750ef0PKRU: 55555554Call Trace: <TASK> ? show_regs+0x90/0xa0 ? die_addr+0x50/0xd0 ? exc_general_protection+0x148/0x220 ? asm_exc_general_protection+0x22/0x30 ? gtp_genl_dump_pdp+0x1be/0x800 [gtp] ? __alloc_skb+0x1dd/0x350 ? __pfx___alloc_skb+0x10/0x10 genl_dumpit+0x11d/0x230 netlink_dump+0x5b9/0xce0 ? lockdep_hardirqs_on_prepare+0x253/0x430 ? __pfx_netlink_dump+0x10/0x10 ? kasan_save_track+0x10/0x40 ? __kasan_kmalloc+0x9b/0xa0 ? genl_start+0x675/0x970 __netlink_dump_start+0x6fc/0x9f0 genl_family_rcv_msg_dumpit+0x1bb/0x2d0 ? __pfx_genl_family_rcv_msg_dumpit+0x10/0x10 ? genl_op_from_small+0x2a/0x440 ? cap_capable+0x1d0/0x240 ? __pfx_genl_start+0x10/0x10 ? __pfx_genl_dumpit+0x10/0x10 ? __pfx_genl_done+0x10/0x10 ? security_capable+0x9d/0xe0 | ['use after free'] |
CVE-2024-26755 | In the Linux kernel, the following vulnerability has been resolved:md: Don't suspend the array for interrupted reshapemd_start_sync() will suspend the array if there are spares that can beadded or removed from conf, however, if reshape is still in progress,this won't happen at all or data will be corrupted(remove_and_add_spareswon't be called from md_choose_sync_action for reshape), hence there isno need to suspend the array if reshape is not done yet.Meanwhile, there is a potential deadlock for raid456:1) reshape is interrupted;2) set one of the disk WantReplacement, and add a new disk to the array, however, recovery won't start until the reshape is finished;3) then issue an IO across reshpae position, this IO will wait for reshape to make progress;4) continue to reshape, then md_start_sync() found there is a spare disk that can be added to conf, mddev_suspend() is called;Step 4 and step 3 is waiting for each other, deadlock triggered. Notedthis problem is found by code review, and it's not reporduced yet.Fix this porblem by don't suspend the array for interrupted reshape,this is safe because conf won't be changed until reshape is done. | [] |
CVE-2024-26756 | In the Linux kernel, the following vulnerability has been resolved:md: Don't register sync_thread for reshape directlyCurrently, if reshape is interrupted, then reassemble the array willregister sync_thread directly from pers->run(), in this case'MD_RECOVERY_RUNNING' is set directly, however, there is no guaranteethat md_do_sync() will be executed, hence stop_sync_thread() will hangbecause 'MD_RECOVERY_RUNNING' can't be cleared.Last patch make sure that md_do_sync() will set MD_RECOVERY_DONE,however, following hang can still be triggered by dm-raid testshell/lvconvert-raid-reshape.sh occasionally:[root@fedora ~]# cat /proc/1982/stack[<0>] stop_sync_thread+0x1ab/0x270 [md_mod][<0>] md_frozen_sync_thread+0x5c/0xa0 [md_mod][<0>] raid_presuspend+0x1e/0x70 [dm_raid][<0>] dm_table_presuspend_targets+0x40/0xb0 [dm_mod][<0>] __dm_destroy+0x2a5/0x310 [dm_mod][<0>] dm_destroy+0x16/0x30 [dm_mod][<0>] dev_remove+0x165/0x290 [dm_mod][<0>] ctl_ioctl+0x4bb/0x7b0 [dm_mod][<0>] dm_ctl_ioctl+0x11/0x20 [dm_mod][<0>] vfs_ioctl+0x21/0x60[<0>] __x64_sys_ioctl+0xb9/0xe0[<0>] do_syscall_64+0xc6/0x230[<0>] entry_SYSCALL_64_after_hwframe+0x6c/0x74Meanwhile mddev->recovery is:MD_RECOVERY_RUNNING |MD_RECOVERY_INTR |MD_RECOVERY_RESHAPE |MD_RECOVERY_FROZENFix this problem by remove the code to register sync_thread directlyfrom raid10 and raid5. And let md_check_recovery() to registersync_thread. | ['hang'] |
CVE-2024-26757 | In the Linux kernel, the following vulnerability has been resolved:md: Don't ignore read-only array in md_check_recovery()Usually if the array is not read-write, md_check_recovery() won'tregister new sync_thread in the first place. And if the array isread-write and sync_thread is registered, md_set_readonly() willunregister sync_thread before setting the array read-only. md/raidfollow this behavior hence there is no problem.After commit f52f5c71f3d4 ("md: fix stopping sync thread"), followinghang can be triggered by test shell/integrity-caching.sh:1) array is read-only. dm-raid update super block:rs_update_sbs ro = mddev->ro mddev->ro = 0 -> set array read-write md_update_sb2) register new sync thread concurrently.3) dm-raid set array back to read-only:rs_update_sbs mddev->ro = ro4) stop the array:raid_dtr md_stop stop_sync_thread set_bit(MD_RECOVERY_INTR, &mddev->recovery); md_wakeup_thread_directly(mddev->sync_thread); wait_event(..., !test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))5) sync thread done: md_do_sync set_bit(MD_RECOVERY_DONE, &mddev->recovery); md_wakeup_thread(mddev->thread);6) daemon thread can't unregister sync thread: md_check_recovery if (!md_is_rdwr(mddev) && !test_bit(MD_RECOVERY_NEEDED, &mddev->recovery)) return; -> -> MD_RECOVERY_RUNNING can't be cleared, hence step 4 hang;The root cause is that dm-raid manipulate 'mddev->ro' by itself,however, dm-raid really should stop sync thread before setting thearray read-only. Unfortunately, I need to read more code before Ican refacter the handler of 'mddev->ro' in dm-raid, hence let's fixthe problem the easy way for now to prevent dm-raid regression. | [] |
CVE-2024-26758 | In the Linux kernel, the following vulnerability has been resolved:md: Don't ignore suspended array in md_check_recovery()mddev_suspend() never stop sync_thread, hence it doesn't make sense toignore suspended array in md_check_recovery(), which might causesync_thread can't be unregistered.After commit f52f5c71f3d4 ("md: fix stopping sync thread"), followinghang can be triggered by test shell/integrity-caching.sh:1) suspend the array:raid_postsuspend mddev_suspend2) stop the array:raid_dtr md_stop __md_stop_writes stop_sync_thread set_bit(MD_RECOVERY_INTR, &mddev->recovery); md_wakeup_thread_directly(mddev->sync_thread); wait_event(..., !test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))3) sync thread done:md_do_sync set_bit(MD_RECOVERY_DONE, &mddev->recovery); md_wakeup_thread(mddev->thread);4) daemon thread can't unregister sync thread:md_check_recovery if (mddev->suspended) return; -> return directly md_read_sync_thread clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery); -> MD_RECOVERY_RUNNING can't be cleared, hence step 2 hang;This problem is not just related to dm-raid, fix it by ignoringsuspended array in md_check_recovery(). And follow up patches willimprove dm-raid better to frozen sync thread during suspend. | [] |
CVE-2024-26759 | In the Linux kernel, the following vulnerability has been resolved:mm/swap: fix race when skipping swapcacheWhen skipping swapcache for SWP_SYNCHRONOUS_IO, if two or more threadsswapin the same entry at the same time, they get different pages (A, B). Before one thread (T0) finishes the swapin and installs page (A) to thePTE, another thread (T1) could finish swapin of page (B), swap_free theentry, then swap out the possibly modified page reusing the same entry. It breaks the pte_same check in (T0) because PTE value is unchanged,causing ABA problem. Thread (T0) will install a stalled page (A) into thePTE and cause data corruption.One possible callstack is like this:CPU0 CPU1---- ----do_swap_page() do_swap_page() with same entry<direct swapin path> <direct swapin path><alloc page A> <alloc page B>swap_read_folio() <- read to page A swap_read_folio() <- read to page B<slow on later locks or interrupt> <finished swapin first>... set_pte_at() swap_free() <- entry is free <write to page B, now page A stalled> <swap out page B to same swap entry>pte_same() <- Check pass, PTE seems unchanged, but page A is stalled!swap_free() <- page B content lost!set_pte_at() <- staled page A installed!And besides, for ZRAM, swap_free() allows the swap device to discard theentry content, so even if page (B) is not modified, if swap_read_folio()on CPU0 happens later than swap_free() on CPU1, it may also cause dataloss.To fix this, reuse swapcache_prepare which will pin the swap entry usingthe cache flag, and allow only one thread to swap it in, also prevent anyparallel code from putting the entry in the cache. Release the pin afterPT unlocked.Racers just loop and wait since it's a rare and very short event. Aschedule_timeout_uninterruptible(1) call is added to avoid repeated pagefaults wasting too much CPU, causing livelock or adding too much noise toperf statistics. A similar livelock issue was described in commit029c4628b2eb ("mm: swap: get rid of livelock in swapin readahead")Reproducer:This race issue can be triggered easily using a well constructedreproducer and patched brd (with a delay in read path) [1]:With latest 6.8 mainline, race caused data loss can be observed easily:$ gcc -g -lpthread test-thread-swap-race.c && ./a.out Polulating 32MB of memory region... Keep swapping out... Starting round 0... Spawning 65536 workers... 32746 workers spawned, wait for done... Round 0: Error on 0x5aa00, expected 32746, got 32743, 3 data loss! Round 0: Error on 0x395200, expected 32746, got 32743, 3 data loss! Round 0: Error on 0x3fd000, expected 32746, got 32737, 9 data loss! Round 0 Failed, 15 data loss!This reproducer spawns multiple threads sharing the same memory regionusing a small swap device. Every two threads updates mapped pages one byone in opposite direction trying to create a race, with one dedicatedthread keep swapping out the data out using madvise.The reproducer created a reproduce rate of about once every 5 minutes, sothe race should be totally possible in production.After this patch, I ran the reproducer for over a few hundred rounds andno data loss observed.Performance overhead is minimal, microbenchmark swapin 10G from 32Gzram:Before: 10934698 usAfter: 11157121 usCached: 13155355 us (Dropping SWP_SYNCHRONOUS_IO flag)[[email protected]: v4] Link: https://lkml.kernel.org/r/[email protected] | ['discard theentry content', 'swap it in'] |
CVE-2024-2676 | A vulnerability, which was classified as critical, was found in Campcodes Online Job Finder System 1.0. Affected is an unknown function of the file /admin/company/controller.php. The manipulation of the argument id leads to sql injection. It is possible to launch the attack remotely. The exploit has been disclosed to the public and may be used. The identifier of this vulnerability is VDB-257376. | ['sql injection'] |
CVE-2024-26760 | In the Linux kernel, the following vulnerability has been resolved:scsi: target: pscsi: Fix bio_put() for error caseAs of commit 066ff571011d ("block: turn bio_kmalloc into a simple kmallocwrapper"), a bio allocated by bio_kmalloc() must be freed by bio_uninit()and kfree(). That is not done properly for the error case, hitting WARN andNULL pointer dereference in bio_free(). | [] |
CVE-2024-26761 | In the Linux kernel, the following vulnerability has been resolved:cxl/pci: Fix disabling memory if DVSEC CXL Range does not match a CFMWS windowThe Linux CXL subsystem is built on the assumption that HPA == SPA.That is, the host physical address (HPA) the HDM decoder registers areprogrammed with are system physical addresses (SPA).During HDM decoder setup, the DVSEC CXL range registers (cxl-3.1,8.1.3.8) are checked if the memory is enabled and the CXL range is ina HPA window that is described in a CFMWS structure of the CXL hostbridge (cxl-3.1, 9.18.1.3).Now, if the HPA is not an SPA, the CXL range does not match a CFMWSwindow and the CXL memory range will be disabled then. The HDM decoderstops working which causes system memory being disabled and further asystem hang during HDM decoder initialization, typically when a CXLenabled kernel boots.Prevent a system hang and do not disable the HDM decoder if thedecoder's CXL range is not found in a CFMWS window.Note the change only fixes a hardware hang, but does not implementHPA/SPA translation. Support for this can be added in a follow onpatch series. | ['hang'] |
CVE-2024-26762 | In the Linux kernel, the following vulnerability has been resolved:cxl/pci: Skip to handle RAS errors if CXL.mem device is detachedThe PCI AER model is an awkward fit for CXL error handling. While theexpectation is that a PCI device can escalate to link reset to recoverfrom an AER event, the same reset on CXL amounts to a surprise memoryhotplug of massive amounts of memory.At present, the CXL error handler attempts some optimistic errorhandling to unbind the device from the cxl_mem driver after reaping someRAS register values. This results in a "hopeful" attempt to unplug thememory, but there is no guarantee that will succeed.A subsequent AER notification after the memdev unbind event can nolonger assume the registers are mapped. Check for memdev bind beforereaping status register values to avoid crashes of the form: BUG: unable to handle page fault for address: ffa00000195e9100 #PF: supervisor read access in kernel mode #PF: error_code(0x0000) - not-present page [...] RIP: 0010:__cxl_handle_ras+0x30/0x110 [cxl_core] [...] Call Trace: <TASK> ? __die+0x24/0x70 ? page_fault_oops+0x82/0x160 ? kernelmode_fixup_or_oops+0x84/0x110 ? exc_page_fault+0x113/0x170 ? asm_exc_page_fault+0x26/0x30 ? __pfx_dpc_reset_link+0x10/0x10 ? __cxl_handle_ras+0x30/0x110 [cxl_core] ? find_cxl_port+0x59/0x80 [cxl_core] cxl_handle_rp_ras+0xbc/0xd0 [cxl_core] cxl_error_detected+0x6c/0xf0 [cxl_core] report_error_detected+0xc7/0x1c0 pci_walk_bus+0x73/0x90 pcie_do_recovery+0x23f/0x330Longer term, the unbind and PCI_ERS_RESULT_DISCONNECT behavior mightneed to be replaced with a new PCI_ERS_RESULT_PANIC. | ['crash'] |
CVE-2024-26763 | In the Linux kernel, the following vulnerability has been resolved:dm-crypt: don't modify the data when using authenticated encryptionIt was said that authenticated encryption could produce invalid tag whenthe data that is being encrypted is modified [1]. So, fix this problem bycopying the data into the clone bio first and then encrypt them inside theclone bio.This may reduce performance, but it is needed to prevent the user fromcorrupting the device by writing data with O_DIRECT and modifying them atthe same time.[1] https://lore.kernel.org/all/[email protected]/T/ | ['performance'] |
CVE-2024-26764 | In the Linux kernel, the following vulnerability has been resolved:fs/aio: Restrict kiocb_set_cancel_fn() to I/O submitted via libaioIf kiocb_set_cancel_fn() is called for I/O submitted via io_uring, thefollowing kernel warning appears:WARNING: CPU: 3 PID: 368 at fs/aio.c:598 kiocb_set_cancel_fn+0x9c/0xa8Call trace: kiocb_set_cancel_fn+0x9c/0xa8 ffs_epfile_read_iter+0x144/0x1d0 io_read+0x19c/0x498 io_issue_sqe+0x118/0x27c io_submit_sqes+0x25c/0x5fc __arm64_sys_io_uring_enter+0x104/0xab0 invoke_syscall+0x58/0x11c el0_svc_common+0xb4/0xf4 do_el0_svc+0x2c/0xb0 el0_svc+0x2c/0xa4 el0t_64_sync_handler+0x68/0xb4 el0t_64_sync+0x1a4/0x1a8Fix this by setting the IOCB_AIO_RW flag for read and write I/O that issubmitted by libaio. | [] |
CVE-2024-26765 | In the Linux kernel, the following vulnerability has been resolved:LoongArch: Disable IRQ before init_fn() for nonboot CPUsDisable IRQ before init_fn() for nonboot CPUs when hotplug, in order tosilence such warnings (and also avoid potential errors due to unexpectedinterrupts):WARNING: CPU: 1 PID: 0 at kernel/rcu/tree.c:4503 rcu_cpu_starting+0x214/0x280CPU: 1 PID: 0 Comm: swapper/1 Not tainted 6.6.17+ #1198pc 90000000048e3334 ra 90000000047bd56c tp 900000010039c000 sp 900000010039fdd0a0 0000000000000001 a1 0000000000000006 a2 900000000802c040 a3 0000000000000000a4 0000000000000001 a5 0000000000000004 a6 0000000000000000 a7 90000000048e3f4ct0 0000000000000001 t1 9000000005c70968 t2 0000000004000000 t3 000000000005e56et4 00000000000002e4 t5 0000000000001000 t6 ffffffff80000000 t7 0000000000040000t8 9000000007931638 u0 0000000000000006 s9 0000000000000004 s0 0000000000000001s1 9000000006356ac0 s2 9000000007244000 s3 0000000000000001 s4 0000000000000001s5 900000000636f000 s6 7fffffffffffffff s7 9000000002123940 s8 9000000001ca55f8 ra: 90000000047bd56c tlb_init+0x24c/0x528 ERA: 90000000048e3334 rcu_cpu_starting+0x214/0x280 CRMD: 000000b0 (PLV0 -IE -DA +PG DACF=CC DACM=CC -WE) PRMD: 00000000 (PPLV0 -PIE -PWE) EUEN: 00000000 (-FPE -SXE -ASXE -BTE) ECFG: 00071000 (LIE=12 VS=7)ESTAT: 000c0000 [BRK] (IS= ECode=12 EsubCode=0) PRID: 0014c010 (Loongson-64bit, Loongson-3A5000)CPU: 1 PID: 0 Comm: swapper/1 Not tainted 6.6.17+ #1198Stack : 0000000000000000 9000000006375000 9000000005b61878 900000010039c000 900000010039fa30 0000000000000000 900000010039fa38 900000000619a140 9000000006456888 9000000006456880 900000010039f950 0000000000000001 0000000000000001 cb0cb028ec7e52e1 0000000002b90000 9000000100348700 0000000000000000 0000000000000001 ffffffff916d12f1 0000000000000003 0000000000040000 9000000007930370 0000000002b90000 0000000000000004 9000000006366000 900000000619a140 0000000000000000 0000000000000004 0000000000000000 0000000000000009 ffffffffffc681f2 9000000002123940 9000000001ca55f8 9000000006366000 90000000047a4828 00007ffff057ded8 00000000000000b0 0000000000000000 0000000000000000 0000000000071000 ...Call Trace:[<90000000047a4828>] show_stack+0x48/0x1a0[<9000000005b61874>] dump_stack_lvl+0x84/0xcc[<90000000047f60ac>] __warn+0x8c/0x1e0[<9000000005b0ab34>] report_bug+0x1b4/0x280[<9000000005b63110>] do_bp+0x2d0/0x480[<90000000047a2e20>] handle_bp+0x120/0x1c0[<90000000048e3334>] rcu_cpu_starting+0x214/0x280[<90000000047bd568>] tlb_init+0x248/0x528[<90000000047a4c44>] per_cpu_trap_init+0x124/0x160[<90000000047a19f4>] cpu_probe+0x494/0xa00[<90000000047b551c>] start_secondary+0x3c/0xc0[<9000000005b66134>] smpboot_entry+0x50/0x58 | [] |
CVE-2024-26766 | In the Linux kernel, the following vulnerability has been resolved:IB/hfi1: Fix sdma.h tx->num_descs off-by-one errorUnfortunately the commit `fd8958efe877` introduced another errorcausing the `descs` array to overflow. This reults in further crasheseasily reproducible by `sendmsg` system call.[ 1080.836473] general protection fault, probably for non-canonical address 0x400300015528b00a: 0000 [#1] PREEMPT SMP PTI[ 1080.869326] RIP: 0010:hfi1_ipoib_build_ib_tx_headers.constprop.0+0xe1/0x2b0 [hfi1]--[ 1080.974535] Call Trace:[ 1080.976990] <TASK>[ 1081.021929] hfi1_ipoib_send_dma_common+0x7a/0x2e0 [hfi1][ 1081.027364] hfi1_ipoib_send_dma_list+0x62/0x270 [hfi1][ 1081.032633] hfi1_ipoib_send+0x112/0x300 [hfi1][ 1081.042001] ipoib_start_xmit+0x2a9/0x2d0 [ib_ipoib][ 1081.046978] dev_hard_start_xmit+0xc4/0x210--[ 1081.148347] __sys_sendmsg+0x59/0xa0crash> ipoib_txreq 0xffff9cfeba229f00struct ipoib_txreq { txreq = { list = { next = 0xffff9cfeba229f00, prev = 0xffff9cfeba229f00 }, descp = 0xffff9cfeba229f40, coalesce_buf = 0x0, wait = 0xffff9cfea4e69a48, complete = 0xffffffffc0fe0760 <hfi1_ipoib_sdma_complete>, packet_len = 0x46d, tlen = 0x0, num_desc = 0x0, desc_limit = 0x6, next_descq_idx = 0x45c, coalesce_idx = 0x0, flags = 0x0, descs = {{ qw = {0x8024000120dffb00, 0x4} # SDMA_DESC0_FIRST_DESC_FLAG (bit 63) }, { qw = { 0x3800014231b108, 0x4} }, { qw = { 0x310000e4ee0fcf0, 0x8} }, { qw = { 0x3000012e9f8000, 0x8} }, { qw = { 0x59000dfb9d0000, 0x8} }, { qw = { 0x78000e02e40000, 0x8} }} }, sdma_hdr = 0x400300015528b000, <<< invalid pointer in the tx request structure sdma_status = 0x0, SDMA_DESC0_LAST_DESC_FLAG (bit 62) complete = 0x0, priv = 0x0, txq = 0xffff9cfea4e69880, skb = 0xffff9d099809f400}If an SDMA send consists of exactly 6 descriptors and requires dwordpadding (in the 7th descriptor), the sdma_txreq descriptor array is notproperly expanded and the packet will overflow into the containerstructure. This results in a panic when the send completion runs. Theexact panic varies depending on what elements of the container structureget corrupted. The fix is to use the correct expression in_pad_sdma_tx_descs() to test the need to expand the descriptor array.With this patch the crashes are no longer reproducible and the machine isstable. | ['crash'] |
CVE-2024-26767 | In the Linux kernel, the following vulnerability has been resolved:drm/amd/display: fixed integer types and null check locations[why]:issues fixed:- comparison with wider integer type in loop condition which can causeinfinite loops- pointer dereference before null check | ['null check locations', 'pointer dereference'] |
CVE-2024-26768 | In the Linux kernel, the following vulnerability has been resolved:LoongArch: Change acpi_core_pic[NR_CPUS] to acpi_core_pic[MAX_CORE_PIC]With default config, the value of NR_CPUS is 64. When HW platform hasmore then 64 cpus, system will crash on these platforms. MAX_CORE_PICis the maximum cpu number in MADT table (max physical number) which canexceed the supported maximum cpu number (NR_CPUS, max logical number),but kernel should not crash. Kernel should boot cpus with NR_CPUS, letthe remainder cpus stay in BIOS.The potential crash reason is that the array acpi_core_pic[NR_CPUS] canbe overflowed when parsing MADT table, and it is obvious that CORE_PICshould be corresponding to physical core rather than logical core, so itis better to define the array as acpi_core_pic[MAX_CORE_PIC].With the patch, system can boot up 64 vcpus with qemu parameter -smp 128,otherwise system will crash with the following message.[ 0.000000] CPU 0 Unable to handle kernel paging request at virtual address 0000420000004259, era == 90000000037a5f0c, ra == 90000000037a46ec[ 0.000000] Oops[#1]:[ 0.000000] CPU: 0 PID: 0 Comm: swapper Not tainted 6.8.0-rc2+ #192[ 0.000000] Hardware name: QEMU QEMU Virtual Machine, BIOS unknown 2/2/2022[ 0.000000] pc 90000000037a5f0c ra 90000000037a46ec tp 9000000003c90000 sp 9000000003c93d60[ 0.000000] a0 0000000000000019 a1 9000000003d93bc0 a2 0000000000000000 a3 9000000003c93bd8[ 0.000000] a4 9000000003c93a74 a5 9000000083c93a67 a6 9000000003c938f0 a7 0000000000000005[ 0.000000] t0 0000420000004201 t1 0000000000000000 t2 0000000000000001 t3 0000000000000001[ 0.000000] t4 0000000000000003 t5 0000000000000000 t6 0000000000000030 t7 0000000000000063[ 0.000000] t8 0000000000000014 u0 ffffffffffffffff s9 0000000000000000 s0 9000000003caee98[ 0.000000] s1 90000000041b0480 s2 9000000003c93da0 s3 9000000003c93d98 s4 9000000003c93d90[ 0.000000] s5 9000000003caa000 s6 000000000a7fd000 s7 000000000f556b60 s8 000000000e0a4330[ 0.000000] ra: 90000000037a46ec platform_init+0x214/0x250[ 0.000000] ERA: 90000000037a5f0c efi_runtime_init+0x30/0x94[ 0.000000] CRMD: 000000b0 (PLV0 -IE -DA +PG DACF=CC DACM=CC -WE)[ 0.000000] PRMD: 00000000 (PPLV0 -PIE -PWE)[ 0.000000] EUEN: 00000000 (-FPE -SXE -ASXE -BTE)[ 0.000000] ECFG: 00070800 (LIE=11 VS=7)[ 0.000000] ESTAT: 00010000 [PIL] (IS= ECode=1 EsubCode=0)[ 0.000000] BADV: 0000420000004259[ 0.000000] PRID: 0014c010 (Loongson-64bit, Loongson-3A5000)[ 0.000000] Modules linked in:[ 0.000000] Process swapper (pid: 0, threadinfo=(____ptrval____), task=(____ptrval____))[ 0.000000] Stack : 9000000003c93a14 9000000003800898 90000000041844f8 90000000037a46ec[ 0.000000] 000000000a7fd000 0000000008290000 0000000000000000 0000000000000000[ 0.000000] 0000000000000000 0000000000000000 00000000019d8000 000000000f556b60[ 0.000000] 000000000a7fd000 000000000f556b08 9000000003ca7700 9000000003800000[ 0.000000] 9000000003c93e50 9000000003800898 9000000003800108 90000000037a484c[ 0.000000] 000000000e0a4330 000000000f556b60 000000000a7fd000 000000000f556b08[ 0.000000] 9000000003ca7700 9000000004184000 0000000000200000 000000000e02b018[ 0.000000] 000000000a7fd000 90000000037a0790 9000000003800108 0000000000000000[ 0.000000] 0000000000000000 000000000e0a4330 000000000f556b60 000000000a7fd000[ 0.000000] 000000000f556b08 000000000eaae298 000000000eaa5040 0000000000200000[ 0.000000] ...[ 0.000000] Call Trace:[ 0.000000] [<90000000037a5f0c>] efi_runtime_init+0x30/0x94[ 0.000000] [<90000000037a46ec>] platform_init+0x214/0x250[ 0.000000] [<90000000037a484c>] setup_arch+0x124/0x45c[ 0.000000] [<90000000037a0790>] start_kernel+0x90/0x670[ 0.000000] [<900000000378b0d8>] kernel_entry+0xd8/0xdc | ['crash'] |
CVE-2024-26769 | In the Linux kernel, the following vulnerability has been resolved:nvmet-fc: avoid deadlock on delete association pathWhen deleting an association the shutdown path is deadlocking because wetry to flush the nvmet_wq nested. Avoid this by deadlock by deferringthe put work into its own work item. | [] |
CVE-2024-2677 | A vulnerability has been found in Campcodes Online Job Finder System 1.0 and classified as critical. Affected by this vulnerability is an unknown functionality of the file /admin/category/controller.php. The manipulation of the argument CATEGORYID leads to sql injection. The attack can be launched remotely. The exploit has been disclosed to the public and may be used. The identifier VDB-257377 was assigned to this vulnerability. | ['sql injection'] |
CVE-2024-26770 | In the Linux kernel, the following vulnerability has been resolved:HID: nvidia-shield: Add missing null pointer checks to LED initializationdevm_kasprintf() returns a pointer to dynamically allocated memorywhich can be NULL upon failure. Ensure the allocation was successfulby checking the pointer validity.[[email protected]: tweak changelog a bit] | ['null pointer'] |
CVE-2024-26771 | In the Linux kernel, the following vulnerability has been resolved:dmaengine: ti: edma: Add some null pointer checks to the edma_probedevm_kasprintf() returns a pointer to dynamically allocated memorywhich can be NULL upon failure. Ensure the allocation was successfulby checking the pointer validity. | ['null pointer'] |
CVE-2024-26772 | In the Linux kernel, the following vulnerability has been resolved:ext4: avoid allocating blocks from corrupted group in ext4_mb_find_by_goal()Places the logic for checking if the group's block bitmap is corrupt underthe protection of the group lock to avoid allocating blocks from the groupwith a corrupted block bitmap. | ['corrupted group'] |
CVE-2024-26773 | In the Linux kernel, the following vulnerability has been resolved:ext4: avoid allocating blocks from corrupted group in ext4_mb_try_best_found()Determine if the group block bitmap is corrupted before using ac_b_ex inext4_mb_try_best_found() to avoid allocating blocks from a group with acorrupted block bitmap in the following concurrency and making thesituation worse.ext4_mb_regular_allocator ext4_lock_group(sb, group) ext4_mb_good_group // check if the group bbitmap is corrupted ext4_mb_complex_scan_group // Scan group gets ac_b_ex but doesn't use it ext4_unlock_group(sb, group) ext4_mark_group_bitmap_corrupted(group) // The block bitmap was corrupted during // the group unlock gap. ext4_mb_try_best_found ext4_lock_group(ac->ac_sb, group) ext4_mb_use_best_found mb_mark_used // Allocating blocks in block bitmap corrupted group | ['corrupted group'] |
CVE-2024-26774 | In the Linux kernel, the following vulnerability has been resolved:ext4: avoid dividing by 0 in mb_update_avg_fragment_size() when block bitmap corruptDetermine if bb_fragments is 0 instead of determining bb_free to eliminatethe risk of dividing by zero when the block bitmap is corrupted. | [] |
CVE-2024-26775 | In the Linux kernel, the following vulnerability has been resolved:aoe: avoid potential deadlock at set_capacityMove set_capacity() outside of the section procected by (&d->lock).To avoid possible interrupt unsafe locking scenario: CPU0 CPU1 ---- ----[1] lock(&bdev->bd_size_lock); local_irq_disable(); [2] lock(&d->lock); [3] lock(&bdev->bd_size_lock); <Interrupt>[4] lock(&d->lock); *** DEADLOCK ***Where [1](&bdev->bd_size_lock) hold by zram_add()->set_capacity().[2]lock(&d->lock) hold by aoeblk_gdalloc(). And aoeblk_gdalloc()is trying to acquire [3](&bdev->bd_size_lock) at set_capacity() call.In this situation an attempt to acquire [4]lock(&d->lock) fromaoecmd_cfg_rsp() will lead to deadlock.So the simplest solution is breaking lock dependency[2](&d->lock) -> [3](&bdev->bd_size_lock) by moving set_capacity()outside. | [] |
CVE-2024-26776 | In the Linux kernel, the following vulnerability has been resolved:spi: hisi-sfc-v3xx: Return IRQ_NONE if no interrupts were detectedReturn IRQ_NONE from the interrupt handler when no interrupt wasdetected. Because an empty interrupt will cause a null pointer error: Unable to handle kernel NULL pointer dereference at virtual address 0000000000000008 Call trace: complete+0x54/0x100 hisi_sfc_v3xx_isr+0x2c/0x40 [spi_hisi_sfc_v3xx] __handle_irq_event_percpu+0x64/0x1e0 handle_irq_event+0x7c/0x1cc | ['null pointer'] |
CVE-2024-26777 | In the Linux kernel, the following vulnerability has been resolved:fbdev: sis: Error out if pixclock equals zeroThe userspace program could pass any values to the driver throughioctl() interface. If the driver doesn't check the value of pixclock,it may cause divide-by-zero error.In sisfb_check_var(), var->pixclock is used as a divisor to caculatedrate before it is checked against zero. Fix this by checking itat the beginning.This is similar to CVE-2022-3061 in i740fb which was fixed bycommit 15cf0b8. | [] |
CVE-2024-26778 | In the Linux kernel, the following vulnerability has been resolved:fbdev: savage: Error out if pixclock equals zeroThe userspace program could pass any values to the driver throughioctl() interface. If the driver doesn't check the value of pixclock,it may cause divide-by-zero error.Although pixclock is checked in savagefb_decode_var(), but it is notchecked properly in savagefb_probe(). Fix this by checking whetherpixclock is zero in the function savagefb_check_var() beforeinfo->var.pixclock is used as the divisor.This is similar to CVE-2022-3061 in i740fb which was fixed bycommit 15cf0b8. | [] |
CVE-2024-26779 | In the Linux kernel, the following vulnerability has been resolved:wifi: mac80211: fix race condition on enabling fast-xmitfast-xmit must only be enabled after the sta has been uploaded to the driver,otherwise it could end up passing the not-yet-uploaded sta via drv_tx callsto the driver, leading to potential crashes because of uninitialized drv_privdata.Add a missing sta->uploaded check and re-check fast xmit after inserting a sta. | ['race condition', 'crash'] |
CVE-2024-2678 | A vulnerability was found in Campcodes Online Job Finder System 1.0 and classified as critical. Affected by this issue is some unknown functionality of the file /admin/applicants/controller.php. The manipulation of the argument JOBREGID leads to sql injection. The attack may be launched remotely. The exploit has been disclosed to the public and may be used. VDB-257378 is the identifier assigned to this vulnerability. | ['sql injection'] |
CVE-2024-2679 | A vulnerability was found in Campcodes Online Job Finder System 1.0. It has been classified as problematic. This affects an unknown part of the file /admin/vacancy/index.php. The manipulation of the argument view leads to cross site scripting. It is possible to initiate the attack remotely. The exploit has been disclosed to the public and may be used. The associated identifier of this vulnerability is VDB-257379. | ['cross site scripting', 'cross-site scripting'] |
CVE-2024-2680 | A vulnerability was found in Campcodes Online Job Finder System 1.0. It has been declared as problematic. This vulnerability affects unknown code of the file /admin/user/index.php. The manipulation of the argument view leads to cross site scripting. The attack can be initiated remotely. The exploit has been disclosed to the public and may be used. The identifier of this vulnerability is VDB-257380. | ['cross site scripting'] |
CVE-2024-2681 | A vulnerability was found in Campcodes Online Job Finder System 1.0. It has been rated as problematic. This issue affects some unknown processing of the file /admin/employee/index.php. The manipulation of the argument view leads to cross site scripting. The attack may be initiated remotely. The exploit has been disclosed to the public and may be used. The identifier VDB-257381 was assigned to this vulnerability. | ['cross site scripting'] |
CVE-2024-2682 | A vulnerability classified as problematic has been found in Campcodes Online Job Finder System 1.0. Affected is an unknown function of the file /admin/employee/controller.php. The manipulation of the argument EMPLOYEEID leads to cross site scripting. It is possible to launch the attack remotely. The exploit has been disclosed to the public and may be used. VDB-257382 is the identifier assigned to this vulnerability. | ['cross site scripting', 'cross-site scripting'] |
CVE-2024-2683 | A vulnerability classified as problematic was found in Campcodes Online Job Finder System 1.0. Affected by this vulnerability is an unknown functionality of the file /admin/company/index.php. The manipulation of the argument view leads to cross site scripting. The attack can be launched remotely. The exploit has been disclosed to the public and may be used. The associated identifier of this vulnerability is VDB-257383. | ['cross site scripting'] |
CVE-2024-2684 | A vulnerability, which was classified as problematic, has been found in Campcodes Online Job Finder System 1.0. Affected by this issue is some unknown functionality of the file /admin/category/index.php. The manipulation of the argument view leads to cross site scripting. The attack may be launched remotely. The exploit has been disclosed to the public and may be used. The identifier of this vulnerability is VDB-257384. | ['cross site scripting'] |
CVE-2024-2685 | A vulnerability, which was classified as problematic, was found in Campcodes Online Job Finder System 1.0. This affects an unknown part of the file /admin/applicants/index.php. The manipulation of the argument view leads to cross site scripting. It is possible to initiate the attack remotely. The exploit has been disclosed to the public and may be used. The identifier VDB-257385 was assigned to this vulnerability. | ['cross site scripting', 'cross-site scripting'] |
CVE-2024-2686 | A vulnerability has been found in Campcodes Online Job Finder System 1.0 and classified as problematic. This vulnerability affects unknown code of the file /admin/applicants/controller.php. The manipulation of the argument JOBREGID leads to cross site scripting. The attack can be initiated remotely. The exploit has been disclosed to the public and may be used. VDB-257386 is the identifier assigned to this vulnerability. | ['cross site scripting'] |
CVE-2024-2687 | A vulnerability was found in Campcodes Online Job Finder System 1.0 and classified as critical. This issue affects some unknown processing of the file /admin/applicants/index.php. The manipulation of the argument id leads to sql injection. The attack may be initiated remotely. The exploit has been disclosed to the public and may be used. The associated identifier of this vulnerability is VDB-257387. | ['sql injection'] |
CVE-2024-2688 | The EmbedPress Embed PDF, Google Docs, Vimeo, Wistia, Embed YouTube Videos, Audios, Maps & Embed Any Documents in Gutenberg & Elementor plugin for WordPress is vulnerable to Stored Cross-Site Scripting via the EmbedPress document widget in all versions up to, and including, 3.9.12 due to insufficient input sanitization and output escaping on user supplied attributes. This makes it possible for authenticated attackers, with contributor-level access and above, to inject arbitrary web scripts in pages that will execute whenever a user accesses an injected page. | ['inject arbitrary web scripts', 'stored cross-site scripting'] |
CVE-2024-2689 | Denial of Service in Temporal Server prior to version 1.20.5, 1.21.6, and 1.22.7 allows an authenticated user who has permissions to interact with workflows and has crafted an invalid UTF-8 string for submission to potentially cause a crashloop. If left unchecked, the task containing the invalid UTF-8 will become stuck in the queue, causing an increase in queue lag. Eventually, all processes handling these queues will become stuck and the system will run out of resources. The workflow ID of the failing task will be visible in the logs, and can be used to remove that workflow as a mitigation. Version 1.23 is not impacted.In this context, a user is an operator of Temporal Server. | ['interact with workflows and has crafted an invalid', 'invalid string', 'queue lag'] |
CVE-2024-2690 | A vulnerability was found in SourceCodester Online Discussion Forum Site 1.0. It has been classified as critical. Affected is an unknown function of the file /uupdate.php. The manipulation of the argument ima leads to unrestricted upload. It is possible to launch the attack remotely. The exploit has been disclosed to the public and may be used. The identifier of this vulnerability is VDB-257388. | ['unrestricted upload'] |
CVE-2024-2692 | SiYuan version 3.0.3 allows executing arbitrary commands on the server. This is possible because the application is vulnerable to Server Side XSS. | ['executing arbitrary commands', 'Server Side XSS', 'server side xss', 'execute arbitrary'] |
CVE-2024-2702 | Missing Authorization vulnerability in Olive Themes Olive One Click Demo Import allows importing settings and data, ultimately leading to XSS.This issue affects Olive One Click Demo Import: from n/a through 1.1.1. | ['XSS.This issue affects Olive One Click Demo Import', 'missing authorization', 'xss'] |
CVE-2024-2703 | A vulnerability classified as critical has been found in Tenda AC10U 15.03.06.49. Affected is the function formSetDeviceName of the file /goform/SetOnlineDevName. The manipulation of the argument mac leads to stack-based buffer overflow. It is possible to launch the attack remotely. The exploit has been disclosed to the public and may be used. VDB-257454 is the identifier assigned to this vulnerability. NOTE: The vendor was contacted early about this disclosure but did not respond in any way. | ['stack-based buffer overflow', 'stack based buffer overflow', 'disclosure'] |
CVE-2024-2704 | A vulnerability classified as critical was found in Tenda AC10U 15.03.06.49. Affected by this vulnerability is the function formSetFirewallCfg of the file /goform/SetFirewallCfg. The manipulation of the argument firewallEn leads to stack-based buffer overflow. The attack can be launched remotely. The exploit has been disclosed to the public and may be used. The associated identifier of this vulnerability is VDB-257455. NOTE: The vendor was contacted early about this disclosure but did not respond in any way. | ['stack-based buffer overflow', 'stack based buffer overflow', 'disclosure'] |
CVE-2024-2705 | A vulnerability, which was classified as critical, has been found in Tenda AC10U 1.0/15.03.06.49. Affected by this issue is the function formSetQosBand of the file /goform/SetNetControlList. The manipulation of the argument list leads to stack-based buffer overflow. The attack may be launched remotely. The exploit has been disclosed to the public and may be used. The identifier of this vulnerability is VDB-257456. NOTE: The vendor was contacted early about this disclosure but did not respond in any way. | ['stack-based buffer overflow', 'stack based buffer overflow', 'disclosure'] |
CVE-2024-2706 | A vulnerability, which was classified as critical, was found in Tenda AC10U 15.03.06.49. This affects the function formWifiWpsStart of the file /goform/WifiWpsStart. The manipulation of the argument index leads to stack-based buffer overflow. It is possible to initiate the attack remotely. The exploit has been disclosed to the public and may be used. The identifier VDB-257457 was assigned to this vulnerability. NOTE: The vendor was contacted early about this disclosure but did not respond in any way. | ['stack-based buffer overflow', 'stack based buffer overflow', 'disclosure'] |
CVE-2024-2707 | A vulnerability has been found in Tenda AC10U 15.03.06.49 and classified as critical. This vulnerability affects the function formWriteFacMac of the file /goform/WriteFacMac. The manipulation of the argument mac leads to os command injection. The attack can be initiated remotely. The exploit has been disclosed to the public and may be used. VDB-257458 is the identifier assigned to this vulnerability. NOTE: The vendor was contacted early about this disclosure but did not respond in any way. | ['os command injection', 'disclosure'] |
CVE-2024-2708 | A vulnerability was found in Tenda AC10U 15.03.06.49 and classified as critical. This issue affects the function formexeCommand of the file /goform/execCommand. The manipulation of the argument cmdinput leads to stack-based buffer overflow. The attack may be initiated remotely. The exploit has been disclosed to the public and may be used. The associated identifier of this vulnerability is VDB-257459. NOTE: The vendor was contacted early about this disclosure but did not respond in any way. | ['stack-based buffer overflow', 'stack based buffer overflow', 'disclosure'] |
CVE-2024-27081 | ESPHome is a system to control your ESP8266/ESP32. A security misconfiguration in the edit configuration file API in the dashboard component of ESPHome version 2023.12.9 (command line installation) allows authenticated remote attackers to read and write arbitrary files under the configuration directory rendering remote code execution possible. This vulnerability is patched in 2024.2.1. | ['write arbitrary files', 'read and write arbitrary files under the configuration', 'security misconfiguration', 'remote code execution'] |
CVE-2024-27083 | Flask-AppBuilder is an application development framework, built on top of Flask. A Cross-Site Scripting (XSS) vulnerability has been discovered on the OAuth login page. An attacker could trick a user to follow a specially crafted URL to the OAuth login page. This URL could inject and execute malicious javascript code that would get executed on the user's browser. This issue was introduced on 4.1.4 and patched on 4.2.1. | ['cross-site scripting (xss)'] |
CVE-2024-27085 | Discourse is an open source platform for community discussion. In affected versions users that are allowed to invite others can inject arbitrarily large data in parameters used in the invite route. The problem has been patched in the latest version of Discourse. Users are advised to upgrade. Users unable to upgrade should disable invites or restrict access to them using the `invite allowed groups` site setting. | ['arbitrarily large data'] |
CVE-2024-27087 | Kirby is a content management system. The new link field introduced in Kirby 4 allows several different link types that each validate the entered link to the relevant URL format. It also includes a "Custom" link type for advanced use cases that don't fit any of the pre-defined link formats. As the "Custom" link type is meant to be flexible, it also allows the javascript: URL scheme. In some use cases this can be intended, but it can also be misused by attackers to execute arbitrary JavaScript code when a user or visitor clicks on a link that is generated from the contents of the link field. This vulnerability is patched in 4.1.1. | ['execute arbitrary JavaScript code', 'the relevant URL format', 'execute arbitrary JavaScript code when a user or', 'arbitrary javascript code'] |
CVE-2024-27088 | es5-ext contains ECMAScript 5 extensions. Passing functions with very long names or complex default argument names into `function#copy` or `function#toStringTokens` may cause the script to stall. The vulnerability is patched in v0.10.63. | ['stall'] |
CVE-2024-2709 | A vulnerability was found in Tenda AC10U 15.03.06.49. It has been classified as critical. Affected is the function fromSetRouteStatic of the file /goform/SetStaticRouteCfg. The manipulation of the argument list leads to stack-based buffer overflow. It is possible to launch the attack remotely. The exploit has been disclosed to the public and may be used. The identifier of this vulnerability is VDB-257460. NOTE: The vendor was contacted early about this disclosure but did not respond in any way. | ['stack-based buffer overflow', 'stack based buffer overflow', 'disclosure'] |
CVE-2024-27091 | GeoNode is a geospatial content management system, a platform for the management and publication of geospatial data. An issue exists within GEONODE where the current rich text editor is vulnerable to Stored XSS. The applications cookies are set securely, but it is possible to retrieve a victims CSRF token and issue a request to change another user's email address to perform a full account takeover. Due to the script element not impacting the CORS policy, requests will succeed. This vulnerability is fixed in 4.2.3. | ['stored xss'] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.