Linux kernel Intel i915 GPU bug could leak memory between users due to improper TLB flushing, now fixed in kernel updates.

Linux kernel patches “performance can be harmful” bug in video driver

Remember all those funkily named bugs like Spectre and Meltdown? This new Linux kernel issue shows the same lesson again — that performance optimizations in modern CPUs and GPUs can sometimes introduce hidden security risks instead of just improving speed.

Modern CPUs rely on shared resources for performance, but that increases complexity

Today’s processors use shared memory and multi-core designs to maximize performance and efficiency. While this makes systems faster and easier to program compared to older “share-nothing” designs, it also introduces complex interactions that can sometimes lead to unexpected security side effects.

Shared hardware state can unintentionally leak data between processes

Because multiple programs share the same physical CPU and memory hardware, cached data and internal processor states may not always be fully cleared. In some cases, this leftover information can be observed by other programs, creating potential data leakage risks similar to Spectre-style vulnerabilities.

Linux GPU driver vulnerability (CVE-2022-0330) affects Intel i915 systems

A newly patched issue in the Linux kernel affects the Intel i915 GPU driver. The vulnerability could allow memory data to leak between different users or GPU processes under certain conditions, especially in shared or multi-user environments.

Exploitation requires local access and GPU execution privileges

The bug is not easily exploitable remotely. An attacker would generally need local system access and the ability to run GPU workloads, which limits its real-world impact but still makes it relevant in shared computing systems.

Issue comes from improper handling of the GPU’s TLB

The root cause lies in the GPU’s TLB, a hardware component used to speed up memory address translation. If this cache is not properly cleared after a task finishes, old memory mappings can remain active and be reused incorrectly.

Stale memory mappings can expose data between different GPU users

If the system reuses GPU memory without flushing old TLB entries, a new process may accidentally access memory that previously belonged to another user, leading to unintended data exposure.