CVE-2022-50703 in Linux
Summary
by MITRE • 12/24/2025
In the Linux kernel, the following vulnerability has been resolved:
soc: qcom: smsm: Fix refcount leak bugs in qcom_smsm_probe()
There are two refcount leak bugs in qcom_smsm_probe():
(1) The 'local_node' is escaped out from for_each_child_of_node() as the break of iteration, we should call of_node_put() for it in error path or when it is not used anymore. (2) The 'node' is escaped out from for_each_available_child_of_node() as the 'goto', we should call of_node_put() for it in goto target.
If you want to get best quality of vulnerability data, you may have to visit VulDB.
Analysis
by VulDB Data Team • 02/24/2026
The vulnerability CVE-2022-50703 represents a critical reference counting issue within the Qualcomm SMSM (Shared Memory State Manager) subsystem of the Linux kernel. This flaw exists in the qcom_smsm_probe() function which handles the initialization of Qualcomm's shared memory state management driver. The vulnerability stems from improper handling of device tree node references, creating potential memory leaks that could accumulate over time and ultimately lead to system instability or resource exhaustion. The issue specifically affects embedded systems and mobile devices that utilize Qualcomm SoCs where the SMSM driver manages communication between different processor cores or subsystems through shared memory regions.
The technical implementation of this vulnerability manifests through two distinct reference counting errors within the device tree traversal logic. The first bug occurs when processing child nodes using for_each_child_of_node() macro where the 'local_node' reference is not properly released when control flow exits the loop via break statements. The second vulnerability appears in the processing of available child nodes using for_each_available_child_of_node() where the 'node' reference escapes the loop through goto statements without proper cleanup. Both scenarios result in device tree node references remaining in memory even when they are no longer needed, causing reference count leaks that can compound over multiple driver initialization cycles. This represents a classic kernel memory management flaw that aligns with CWE-404, which specifically addresses improper resource management and memory leaks in software systems.
The operational impact of CVE-2022-50703 extends beyond simple memory consumption issues to potentially compromise system reliability and availability. In embedded systems and mobile platforms where memory resources are constrained, these reference counting leaks can gradually consume available memory resources, leading to system slowdowns, application crashes, or even complete system hangs. The vulnerability is particularly concerning in automotive systems, industrial IoT devices, and mobile platforms where uninterrupted operation is critical. Attackers could potentially exploit this weakness to cause denial-of-service conditions by repeatedly triggering driver initialization sequences, though direct exploitation for privilege escalation or code execution appears unlikely given the nature of the flaw. The vulnerability affects systems running Linux kernel versions where the Qualcomm SMSM driver is present and actively utilized, making it relevant to a wide range of Qualcomm-based devices including smartphones, tablets, and embedded computing platforms.
Mitigation strategies for CVE-2022-50703 should focus on immediate kernel updates to patched versions that properly implement device tree node reference cleanup. System administrators should prioritize updating firmware and kernel images on affected devices, particularly those in critical infrastructure or mobile platforms where resource exhaustion could have severe consequences. The fix involves adding proper of_node_put() calls in error paths and goto targets to ensure that device tree node references are properly released when they are no longer needed. Additionally, monitoring systems should be implemented to track memory usage patterns and identify potential resource exhaustion conditions that may indicate the presence of this vulnerability. Organizations should also conduct thorough vulnerability assessments of their embedded systems to identify other potential reference counting issues within kernel drivers, as this vulnerability demonstrates the importance of proper resource management in kernel space code. The fix aligns with ATT&CK technique T1059.001 for privilege escalation through kernel exploits, though direct exploitation appears more likely through resource exhaustion rather than direct code execution.