CVE-2025-40261 in Linux
Сводка
по VulDB • 16.05.2026
Based on the kernel log provided, here is an analysis of the crash:
### **1. Core Issue: Invalid Opcode Exception** The key line is: ``` [ 1136.105127] ? asm_exc_invalid_op+0x1a/0x20
``` This indicates an **`#UD` (Invalid Opcode)** exception. The CPU encountered an instruction it did not recognize or was not allowed to execute.
### **2. Context: Kernel Worker Thread** The call trace shows the crash occurred in a **kernel worker thread**: ``` [ 1136.124733] move_linked_works+0x4a/0xa0
[ 1136.128485] worker_thread+0x216/0x3a0
[ 1136.132758] kthread+0xfa/0x240
``` - `worker_thread` is part of the Linux kernel's **workqueue subsystem**. - `move_linked_works` is a helper function used to manage work items in the workqueue list.
### **3. Likely Cause** An **Invalid Opcode** in a kernel worker thread is **highly unusual** and typically points to one of these scenarios:
#### **A. Corrupted Kernel Memory / Stack** - The most common cause is **memory corruption** (e.g., use-after-free, buffer overflow) that has overwritten the instruction pointer (`RIP`) or the code itself. - The `CR2` register (`00007fd207f90b80`) shows the faulting address, but since this is an `#UD` (not a page fault), `CR2` may not be directly relevant to the faulting instruction. However, it might indicate where the corrupted pointer was dereferenced.
#### **B. Incompatible or Corrupted Kernel Module** - A loadable kernel module may have been compiled for a different CPU architecture, or its code has been corrupted. - If a module was recently loaded/unloaded, it might have left the kernel in an inconsistent state.
#### **C. CPU Microcode Bug** - Rarely, a bug in the CPU's microcode can cause valid instructions to be misinterpreted. This is more likely if the crash is reproducible on specific hardware.
#### **D. Compiler Bug or Optimization Issue** - In rare cases, aggressive compiler optimizations (especially with `-O3` or `-Os`) can generate invalid instruction sequences, particularly if there are bugs in the compiler or if inline assembly is used incorrectly.
### **4. Debugging Steps**
1. **Check for Recent Changes**: - Did you recently update the kernel, load a new module, or change hardware? - Try booting with a previous kernel version to see if the issue persists.
2. **Enable Kernel Debugging**: - Boot with `slub_debug=F` to detect slab corruption. - Use `kmemleak` to detect memory leaks that might lead to corruption. - Enable `CONFIG_DEBUG_INFO` and `CONFIG_FRAME_POINTER` in your kernel config to get better stack traces.
3. **Check dmesg for Earlier Errors**: - Look for **earlier warnings** or **errors** in `dmesg` that might indicate memory corruption, I/O errors, or module loading issues.
4. **Verify CPU Microcode**: - Ensure your CPU microcode is up to date. - Check if other users of your hardware/kernel version report similar issues.
5. **Reproduce the Issue**: - If possible, try to reproduce the crash under controlled conditions (e.g., specific workload) to gather more data.
### **5. Conclusion** This is likely a **memory corruption** issue affecting the kernel's workqueue subsystem. The invalid opcode suggests that the CPU is trying to execute garbage data as code, which is a strong indicator of memory corruption.
**Recommendation**: - Update your kernel and microcode. - Run memory tests (e.g., `memtest86+`) to rule out hardware issues. - If the issue persists, consider filing a bug report with the full `dmesg` output, including the complete call trace and any earlier warnings.
If you want to get best quality of vulnerability data, you may have to visit VulDB.