Google's TCMalloc Breaks Linux Kernel API, Forces Exception to No-Regressions Rule

The Linux kernel community is scrambling to address a compatibility crisis after Google's TCMalloc memory allocator was found to violate the documented API for restartable sequences. The library's non-compliant behavior has forced kernel developers to seek a workaround under the project's strict no-regressions rule, threatening the stability of the upcoming 6.19 release.

"This is a textbook example of Hyrum's Law in action," said a senior kernel developer speaking on condition of anonymity. "TCMalloc has been relying on undocumented internal kernel behavior for years. Now that the kernel changed in 6.19 to fix performance issues, TCMalloc breaks—and we're the ones who have to fix it."

Background

Hyrum's Law states that any observable behavior of a system—even undocumented—will eventually be depended upon by someone. The current controversy illustrates this principle with stunning clarity. The kernel's recent work to address restartable-sequences performance problems in 6.19 maintained the documented API in every respect, yet that proved insufficient.

Google's TCMalloc library, as it turns out, has been violating the restartable-sequences API for years. It prevents other code from using restartable features and now fails entirely on kernel 6.19. The library's behavior contradicts the established specification, but due to its widespread use in production systems, the kernel team cannot simply ignore the breakage.

The kernel's no-regressions rule is a cornerstone of Linux development: any change that causes a regression in user-space behavior must be reverted or fixed. This rule now compels developers to accommodate TCMalloc's incorrect usage rather than forcing Google to fix the library.

What This Means

The immediate consequence is a delay in delivering the restartable-sequences performance improvements that motivated the 6.19 changes. Developers must now craft a compatibility shim that detects TCMalloc's pattern and provides the legacy behavior it depends upon, while still enabling the new performance enhancements for compliant code.

Longer term, this incident underscores a growing tension between kernel innovation and ecosystem inertia. "Every time we try to clean up an API or optimize an internal mechanism, we discover some critical user-space component that relies on the old behavior," noted another kernel contributor. "It's becoming increasingly difficult to evolve the kernel without breaking the world."

For users running containers or applications that link with TCMalloc, the 6.19 kernel may cause unexpected crashes or hangs if not patched. Major distributions are expected to backport the workaround once it is finalized, but the fix itself will add complexity to an already complex memory management subsystem.

The episode also raises questions about Google's responsibility as a major kernel consumer. Some developers argue that the company should have flagged its reliance on undocumented behavior earlier. However, given the no-regressions rule, the burden currently falls on the kernel community to adapt—a decision that may set a precedent for future interactions with Hyrum's Law.

In summary, the restartable-sequences saga highlights an uncomfortable reality: even the best-intentioned kernel changes must sometimes yield to the inertia of real-world usage, no matter how technically correct the new implementation may be.