Login

Linux Plumbers Conference 2025

11–13 Dec 2025
Asia/Tokyo timezone

2025

Topics

177 / 237
410. Aspects of Dependable Linux Systems
Kate Stewart (Linux Foundation), Philipp Ahmann (Etas GmbH (BOSCH))
12/12/2025, 10:00

In regulated industries, Linux is widely used due to its strong software capabilities in areas such as dependability, reliability, and robustness. These industries follow best practices in terms of processes for requirements, design, verification, and change management. These processes are defined in standards that are typically not accessible to the open source kernel community.

However,...
398. NVIDIA Approach for Achieving ASIL B Qualified Linux: minimizing expectations from upstream kernel processes
Igor Stoppa (nvidia)
12/12/2025, 10:10

Unlike the typical path chosen for attempting to use Linux in safety applications, the approach developed by NVIDIA strives to avoid placing any burden on upstream maintainers and developers.

Upstream maintainers should not have to become safety experts, nor the linux kernel should become encumbered by verbose descriptions of what the code does, for it to achieve safety.

We want to start...
369. Applying Program Verification to Linux Kernel Code: Challenges, Practices, and Automation
Keisuke Nishimura
12/12/2025, 10:35

To maintain software safety, defining specifications and ensuring that implementations meet them are both important. The former has become popular in the Linux kernel in various ways [1,2], while the latter still depends on developers' manual effort. Recent advances in techniques and tools, however, have made it feasible to systematically apply program verification to Linux kernel code.

In...
79. Defining and maintaining requirements in the Linux Kernel
Chuck Wolber, Gabriele Paoloni (Red Hat), Kate Stewart (Linux Foundation)
12/12/2025, 11:00

Last year in Vienna we held a session about "Improving kernel design documentation and involving experts".
Following such session the ELISA Architecture working group drafted an initial template for the SW Requirements definition, started documenting the expected behaviour for different functions in the TRACING subsystem and made upstream contribution accordingly and finally also started...
249. KUnit Testing Insufficiencies
Matthew Whitehead (The Boeing Company)
12/12/2025, 12:00

High-integrity applications require rigorous testing to ensure both reliability and compliance with industry standards. Current testing frameworks for the Linux kernel, such as KUnit, face challenges in scalability and integration, particularly in environments with strict certification requirements.

KUnit tests, which are currently the most widely accepted and used solution for testing...
432. Exploring possibilities for integrating StrictDoc with ELISA's requirements template approach for the Linux kernel
Tobias Deiminger (Linutronix GmbH)
12/12/2025, 12:25

The ELISA project currently works on bringing the Linux kernel closer to safety compliance by proposing enhancements to the kernel documentation. This includes a model expressed as requirement templates inlined to source code. At the same time, comparable efforts with a similar goal are also ongoing in the wider open-source ecosystem. For example, the Zephyr OS is using the FLOSS StrictDoc...
437. BASIL: Open Source Traceability for Safety-Critical Systems”
Luigi Pellecchia
12/12/2025, 12:40

Ensuring traceability and compliance remains a major challenge in the development of safety-critical systems. BASIL — The FuSa Spice — is an open-source tool from the ELISA Project that helps engineers manage traceability across documentation, requirements, implementation, testing, and safety evidence.
Designed to integrate seamlessly with existing tools and test infrastructures, BASIL offers...
443. Tooling and Sharing Traceability Discussion
Luigi Pellecchia, Matthew Whitehead (The Boeing Company), Tobias Deiminger (Linutronix GmbH)
12/12/2025, 12:55

Open Discussion based on previous agenda items
444. Wrap up and next steps
Kate Stewart (Linux Foundation), Philipp Ahmann (Etas GmbH (BOSCH))
12/12/2025, 13:20
40. Android MC
John Stultz (Google), Karim Yaghmour (Opersys inc.), Sumit Semwal (Linaro)

CFP ends on September 30th (CLOSED)
The Android Micro Conference brings the upstream community and Android systems developers together to discuss issues and changes to the Android platform and their dependencies and interactions with the Linux kernel, allowing for collaboration on solutions for upstream.

Some highlights of progress made since last year’s MC:

  • Community...
176. Android Ashmem to Memfd
Isaac Manjarres (Google)

Android relies on the anonymous shared memory–ashmem–allocator to allocate anonymous (i.e. not file-backed) buffers that can easily and quickly be shared between processes via file descriptors.

Ashmem is an Android specific memory allocator that is implemented on top of the Linux kernel’s shmem subsystem, which allows for fast memory sharing, as all processes that refer to a shmem buffer...
151. Android Boot: Next Steps
Mr Dmitrii Merkurev (Google)

Android boot flow and GBL quick recap
    - Current problems
    - GBL updates

Android meets FIT (Flattened Image Tree)
    - Existing boot headers structures vs FIT
    - Adoption proposal
    - Expected problems

Android + EFIStub
    - UKI (Unified Kernel Image) adoption
    - GBL as a EFIStub proposal

54. AOSP on taped-out RISC-V SoC without RVA22/23, I came back to finish what I started.
"Ruinland" ChuanTzu Tsai (Andes Technology)

Running Android on RISC-V platforms has been a long-standing goal, filled with technical hurdles and real world economical evaluation.

Initially I proposed the idea at Andes Technology, it didn't pan out, leading me to pursue its realization at SiFive. However, due to org restructuring, I was eventually laid off from SiFive. (Hi Samuel 👋)

Ultimately, I returned to Andes to finish what I...
303. Bootloader-Based S2D(suspend to disk) Mechanism on mobile
Tengfei Fan

In an increasing number of scenarios, the use of S2D (Suspend to Disk) functionality is required or expected on mobile. For example, when a mobile is running lowing on battery, it can use the S2D suspend process to save the user’s current state and then enter a power-down mode. Once the battery level is sufficient again, the device can quickly resume the previous state through the S2D resume...
228. BPF Based Telemetry, Metrics, and Accounting on Android
Isaac Manjarres (Google), T.J. Mercier (Google - Android Kernel Team)

Android currently collects telemetry data from devices in the field. While these metrics are important and can indicate overall system health issues, they are often lacking enough low-level system information that is necessary for finding root causes.

Android has been striving to improve BPF support to enable developers to extend the Linux kernel by creating BPF programs. This development...
297. Cooperation between CPU and system level cache by using MPAM
Yiwei Huang

MPAM enables fine-grained control over shared resources such as CPU caches, memory bandwidth, and interconnect bandwidth. In a typical memory hierarchy, the data path looks like this:
CPU(L2/L3)/GPU/NPU/... ⇄ NoC ⇄ SLC ⇄ DDR
This structure introduces several components including System Level Cache between clients and DDR memory. This raises an important question: how can CPU caches and...
348. Ferrochrome: A Linux VM on Android host via Android Virtualization Framework (AVF)
Jeongik Cha (Google)

Running a full-featured Linux VM on Android has been a long-standing desire for developers and power users. This presentation details Ferrochrome, a project that leverages the Android Virtualization Framework (AVF) to run a guest Debian OS with deep integration into the host Android environment.

We will discuss recent advancements, including the implementation of hardware-accelerated...
131. How do we make KUnit work for us?
Tiffany Yang (Google)

KUnit is the only unit testing framework in the Linux kernel, but Android kernel changes are rarely accompanied by KUnit tests. Aside from the relative monotony associated with writing tests, one of the main barriers to more widespread KUnit testing seems to its inability (perceived or actual) to accommodate the complex use cases that we are developing features for.

When test code doesn't...
172. HW/SW design recommendations for 16kb devices
Juan Yescas, Kalesh Singh (Google)

Content:

Android's transition to 16kb page sizes necessitates that hardware components work seamlessly with 16kb page sizes in order to get optimal performance. This presentation will focus on hardware and software recommendations for devices running with 16kb page sizes.

This section will highlight the hardware design decisions that need to be made to support 16kb page sizes...
173. Memory optimizations for 16kb kernel
Juan Yescas (Google), Kalesh Singh (Google)

Content:

Android already supports 16kb page sizes and the number of devices supporting 16kb page sizes will increase in the future. A key challenge with 16kb page sizes is their potential to increase the memory footprint. In this presentation, we will explore several memory optimization strategies that partners should consider to help mitigate this issue, focusing on areas such...
393. Pixel 6 support upstream and on android-mainline
William McVicker

This talk dives into the progress Google and Linaro have made upstreaming Pixel 6 and the hurdles we’ve faced including:

  • Integrating with existing Exynos drivers
  • Challenges of modularizing critical drivers like timers, clocks, and regulators
  • What’s coming next upstream?

Lastly, we will talk about how we are integrating the Pixel 6 upstream drivers into...
287. Ramdump for Trusted VMs: Efficient Crash Debugging Without Reboot
Cong Zhang

In virtualization environments, system reliability and efficient debugging are essential—especially for memory-sensitive trusted virtual machines (VMs). This presentation introduces a ramdump-based solution that captures key memory data when a VM crashes, without rebooting the device. It helps developers quickly analyze system states and resolve issues, improving reliability and maintainability.
288. SDEI Applications in Trusted VM Fatal Handling: Secure Device Sanitization and Reset
Cong Zhang

Secure devices play a critical role in trusted virtual machines (VMs), serving as the foundation for protecting sensitive data and maintaining system integrity. When a trusted VM enters an abnormal or compromised state, it becomes essential to sanitize and reset secure devices properly to prevent the leakage of confidential information into untrusted environments. This presentation explores...
175. The Challenge of Loading 4kB-Aligned ELFs on 16kB Systems
Juan Yescas (Google), Kalesh Singh (Google)

The transition to a 16kB base page size creates a significant compatibility issue for legacy ELFs built with 4kB segment alignment. This misalignment can place Read-Execute (RX) and Read-Write (RW) segments within a single page, which would require insecure RWX mappings. While recompiling is the ideal fix, it is often impossible for apps that depend on **unmaintained, closed-source third-party...
48. Build Systems MC
Mr Behan Webster (Linaro), Mr Frank Vasquez, Philip Balister (OpenEmbedded)

CFP ends on October 3rd (CLOSED)
The Linux ecosystem supports a diverse set of methods for assembling complete, bootable systems, ranging from binary distributions to source-based systems, embedded platforms, and container-native environments. Despite differences in tooling and architecture, all of these systems face shared challenges: managing build complexity, ensuring security and...
119. A Debian Official Debug Kernel for All?: Moving Beyond 'Build-It-Yourself' with Feasible Strategies for Proactive Security Hardening and Bug Detection
Yunseong Kim (Ericsson), seonghee jin (Georgia Institute of Technology)

Problem Statement

The security and stability of the Linux kernel are paramount to the entire open-source ecosystem. A critical component in achieving this is the availability of debug kernels—builds specifically enabled with intensive debugging features like KASAN, UBSAN, and other sanitizers. While enterprise distributions such as RHEL, Fedora, and SUSE rely heavily on official...
71. Build System Analysis for Kernel Development and Customization
Mr Alejandro Hernandez Samaniego (Microsoft)

When building a custom Linux OS, a pivotal decision involves selecting an appropriate build system from the available options within the ecosystem. The suitability of a particular build system may vary based on product requirements, constraints and development preferences, with kernel development and customization capabilities representing a key aspect for this decision.

This presentation...
232. Improving Build Time SBoMs
Joshua Watt (Garmin)

As SBoMs become more and more important for regulatory compliance and supply chain security, there is a noticeable shift to include more build time information in them [1], [2]. In addition to the supply chain security goals, there is also an increasing desire to use build time information to help fine down the flood of vulnerability information by discarding vulnerabilities that do not match...
185. OpenWrt (One) build system: lessons in *all* the compliance and how to broadly apply them
Denver Gingerich (Software Freedom Conservancy)

When we designed the OpenWrt One, the OpenWrt build system allowed us to easily create a self-contained source tarball that included everything needed for GPL and other compliance purposes. Because of its history in supporting embedded OS deployment on a wide range of heterogeneous devices, the OpenWrt build system has a variety of features that lend themselves to this swift assemblage of the...
28. Confidential Computing MC
Dhaval Giani, Joerg Roedel (AMD)

CFP ends on September 30th (CLOSED)
The Confidential Computing microconferences of the past years have been a significant catalyst for better supporting trusted execution workloads in the Linux virtualization and general software stack. Since the last occurrence of the microconference AMD SEV-SNP and Intel TDX support for KVM were merged into the mainline Linux kernel as well as support...
385. A Linux Bus for SVSM Services: Build New, Reuse VIRTIO, or Both?
Stefano Garzarella (Red Hat)

The Secure VM Service Module (SVSM) for Confidential VMs can expose multiple services and virtual devices to the Linux guest. To manage these, we need a proper bus in the kernel for discovery and enumeration.

So, what is the right architectural choice for this bus? Should we write a new, minimalist bus from scratch? Or should we adapt the standardized VIRTIO framework for its broad...
399. Discussion: TDISP, VM migration, and paravisors
John Starks (Microsoft)

TDISP, designed to allow a confidential VM to establish a trust relationship with a PCI device, creates new headaches for the Linux PCI stack and for virtualization components:

  • Evaluating whether a device is trustworthy.
  • Establishing trust with the device.
  • And in particular, re-establishing trust across a VM migration to a different physical device, without workload...
116. Optimizing guest_memfd shared/private conversions
Ackerley Tng

HugeTLB support in guest_memfd is making steady progress, and has also led to some new problems that come with huge page support. HugeTLB support currently relies on runtime folio restructuring (split/merge) for accurate refcount tracking that integrates well with other users of struct folio.

Current support ends up introducing significant cost in terms of conversion performance. Folio...
388. PCI device authentication & encryption
Alexey Kardashevskiy (AMD), Mathieu Poirier (Linaro)

This presentation is to revive last [year's discussion][1] on PCIe device attestation. The first thing to understand is if last year's consensus to use netlink sockets to convey device attestation information to user space still holds. The second thing to review is the device attestation workflow itself. Given the difference between the CMA and PCI/TSM scenarios, it may be better to build...
280. Secure Interrupt delivery: Lessons Learned from Alternate Injection Enablement
Melody Wang (AMD)

To protect SEV-SNP guests against malicious injection attacks, the SEV-SNP
Alternate Injection feature facilitates the services of a Secure VM Service
Module (SVSM) and its APIC emulation to secure interrupt delivery into an
SEV-SNP guest.

This session will explore the lessons learned during enabling Alternate
Injection, including KVM, SVSM, OVMF and the guest kernel. It will cover...
416. Standardization of Attested TLS Protocols
Muhammad Usama Sardar (TU Dresden)

Summary

This talk is a follow-up of LPC'24, where the community had diverse opinions on the suitable approach of attested TLS protocols for confidential computing. Meanwhile, we have defended our position (cf. [expat BoF][1]) to standardize the protocol in the [IETF][2], and a new Working Group named [Secure Evidence and Attestation Layer (SEAL)][3] is being formed to exclusively tackle...
294. Toward a standard device attestation token for device assignment
Mathieu Poirier (Linaro), Thomas Fossati (Linaro)

The open-source community is hard at work on building the framework
and mechanisms allowing the assignment of devices to a trusted virtual
machine (TVM), a process commonly known as device assignment (DA).
For the TVM to trust a device, the device must provide the TVM with
Evidence claims [[RFC9334]][1] confirming its identity, the state of its firmware and
its configuration. Since...
25. Containers and checkpoint/restore MC
Adrian Reber (Red Hat), Mr Christian Brauner, Mike Rapoport, Stéphane Graber (Zabbly)

CFP ends on October 10th
The Containers and Checkpoint/Restore micro-conference focuses on both userspace and kernel related work.

The micro-conference targets the wider container ecosystem ideally with participants from all major container runtimes as well as init system developers.

The microconference will be discussing recent advancements in container technologies with some of...
33. Device and Specific Purpose Memory MC
Adam Manzanares (Samsung Electronics), Dan Williams (Intel)

CFP ends on September 30th (CLOSED)
The Device and Specific Purpose Memory Microconference is proposed as a space to discuss topics that cross MM, Virtualization, and Memory device-driver boundaries. Beyond CXL this includes software methods for device-coherent memory via ZONE_DEVICE, physical memory pooling / sharing, and specific purpose memory application ABIs like device-dax,...
206. CXL HDM-DB support for Linux
Davidlohr Bueso (Samsung Semiconductor)

Host-managed Device Memory – Device-coherent with Back-invalidate support (HDM-DB) is a type of device memory introduced in CXL 3.0. It allows Type 2 and Type 3 devices to manage memory coherence directly. With HDM-DB, the device acts as the final arbiter of coherence for addresses it owns. This mechanism enables devices to implement inclusive snoop filters to track host caching of device...
96. DAMON-based Pages Migration for {C,G,X}PU [un]attached NUMA nodes
SeongJae Park

Modern systems feature increasingly complex NUMA (Non-Uniform Memory Access) topologies, often with multiple nodes that may or may not be equipped with CPUs, GPUs, or other accelerators. This complexity makes it crucial to migrate memory pages efficiently based on access patterns.

DAMON, a Linux kernel subsystem, offers effective monitoring of system and workload data access patterns. It...
421. Famfs Update: Status, DAX Challenges & Use Cases
John Groves (Micron)

Famfs (the Fabric-Attached Memory File System) formats device memory into a scale-out file systems.
With large memory appliances now in early deployment, accessing multi-terabyte memory objects as files (with POSIX permissions) is proving valuable.

Famfs is progressing toward upstreaming, while navigating challenges from the recent DAX subsystem refactoring.
As the first file...
289. Kernel CXL Cache (safe) support
Alejandro Lucero (AMD)

With CXL Type2 devices comes CXL cache, implying CXL-capable devices to read/write to Host memory through system cache coherency infrastructure. If virtual machines want to take advantage of this functionality the kernel needs to properly configure the system for avoiding arbitrary access from a device to Host memory not allocated to the related VM controlling such a device. While for DMA...
98. Protected DMAbufs and its dynamic memory assignment woes
Sumit Garg

Protected memory refers to memory buffers behind a hardware enforced firewall. It is not accessible to the kernel during normal circumstances but rather only accessible to certain hardware IPs or CPUs executing in higher or differently privileged mode than the kernel itself. The use-cases driving this feature in TEE subsystem are secure video playback, trusted UI, secure video recording,...
117. To online or not to online CXL memory
Hannes Reinecke (SUSE Labs)

There have been discussions around auto-onlining of CXL memory
(https://lore.kernel.org/linux-mm/aIcxs2nk3RNWWbD6@localhost.localdomain/)
but we haven't really made progress there.
Problem was that we can try to fixup / modfiy / tweak the algorithm for auto-onlining CXL memory, or we could go in the other direction and not online CXL memory (or any memory in ZONE_MOVABLE) but delegate...
285. Unifying sources of page hotness information
Bharata Bhasker Rao (AMD)

In the Linux kernel, hot page information can potentially be obtained from multiple sources:

a. PROT_NONE faults (NUMA balancing)
b. PTE Access bit (LRU scanning)
c. Hardware provided page hotness info (AMD IBS, CXL HMU)

This information is further used to migrate (or promote) pages from slow to top memory tier for optimal performance.

Currently, the sources a) and b) above work...
346. “Parallel Paths to High-Bandwidth Memory for ML/AI: Specific Purpose Memory vs. Driver‑Managed Approaches”
Mr Rajneesh Bhardwaj (AMD)

Background and Motivation
High‑bandwidth memory (HBM) has become a critical resource for modern machine‑learning and AI workloads, offering orders‑of‑magnitude improvements in bandwidth and latency compared to traditional DDR DRAM. As HBM adoption grows—whether on GPU accelerators like AMD’s MI200 series or NVIDIA’s Grace Hopper/Blackwell architectures—platform firmware and...
14. Devicetree MC
Bartosz Golaszewski (Linaro), Casey Connolly (Linaro), Mr Krzysztof Kozlowski (Linaro)

CFP ends on September 14th (CLOSED)
The Devicetree Microconference focuses on discussing and solving problems present in the systems using Devicetree as firmware representation. This notably is Linux kernel and U-Boot, but also can cover topics relevant to Zephyr or System Devicetrees. Systems using Devicetree are majority of embedded boards, mobile devices and ARM64 laptops (and many...
104. "Exclusive" resources that are not exclusive - the case of shared GPIOs in DT systems
Mr Bartosz Golaszewski (Linaro)

The high-level idea behind the linux kernel GPIO consumer API is that lines are an exclusive resource - only one logical consumer can request and control a GPIO pin. This results naturally from the type of operations that a low-level user can perform on GPIO lines - after all: one user setting the line's direction to output while another sets it to input is an example of a very clear conflict...
198. Device Tree Metadata: How Bootloaders DTBs Pick and Apply Overlays
Chen-Yu Tsai (Google, LLC)

On many device tree based devices, the device tree blobs are commonly shipped with the kernel or OS image, not the firmware. If the image is meant to be generic, it would include multiple DTBs and possibly many DTBO combinations. The bootloader selects a DTB and optionally applies overlays matching the hardware. Known image "standards" include:
- FIT image: maps a compatible string to a...
15. Devicetree loading for dummies (EFI edition)
Casey Connolly

Devicetree evolved from systems that were tightly vertically integrated, and this has been a continuing trend throughout its adoption in early Linux. This is not a problem when the same organisation is responsible for building the bootloader, the kernel, and the OS - they can just do whatever they want, often with little care given to forward compatibility, or compatibility with custom...
229. DT formatter - a maintainer's and contributor's elusive dream?
Konrad Dybcio (Qualcomm)

A large percentage of feedback when reviewing DTS changes ends up being style-related. This ends up hurting both the reviewer and submitter, as the former wants to maintain codebase coherence, while the latter wants their changes to get merged.

This session will be a discussion on where we currently stand, what functionality should be targeted and what are the obvious roadblocks.
181. MiPi vs ACPI vs Device tree bindings
Srini Kandagatla

MiPi Specifications defines standard device properties that endup into ACPI tables. Whoever Device tree bindings evolve in a very different way.
Even-though all the three are defining hardware, there is no consideration of MiPi or ACPI while defining the bindings.

where do we draw a line?

Is there some consolidation that needs to happen?

How can drivers written for ACPI be use able...
299. Optimizing dependency tracking through DTC changes
Saravana Kannan

fw_devlink currently parses about 20+ properties to track dependencies between DT nodes. While this is not terribly slow, it's still an overhead and needs to be maintained as more common DT properties are added.

There are also a ton of other bespoke device specific DT properties that aren't supported today.

This talk about be about the various ways the DTC could make this a lot more...
196. Power Sequencing for Enumerable Busses - What's Still Missing From the Device Tree and Kernel
Chen-Yu Tsai (Google, LLC)

On x86 / ACPI platforms, devices on enumerable busses can normally be seen directly by the OS. On DT platforms, these devices sometimes require extra power sequencing like toggling regulator supplies or GPIO lines. Over the years most of these cases have been solved, but there are still some gaps.

This talk will go through what already works, and attempts to identify:
- What's missing...
170. Status of DTS validation in the Linux kernel (and how to improve it)
Mr Krzysztof Kozlowski (Linaro)

The great benefit of Devicetree bindings in the current DT schema format is the ability to validate the correctness of DTS (Devicetree sources) against those bindings. However, once validation was introduced, we discovered that many in-kernel DTS files simply did not pass.

A few years and thousands of commits later, we can now ask:
1. What is the current status of in-kernel DTS...
43. Embedded & Internet of Things MC
Jan Lübbe (Pengutronix), Stefan Schmidt

CFP ends on October 3rd (CLOSED)
The Embedded and IoT Micro-conference is a forum for developers to discuss all things Embedded and IoT. Topics include tools, telemetry, device drivers, protocols and standards in not only the Linux kernel but also Real-Time Operating Systems.

Current Problems that require attention (stakeholders):

  • Boot time optimizations (Tim Bird, Khasim Syed...
370. Firmware ABI stability
Marek Vasut

Contemporary embedded systems increasingly come with bootloaders and firmware which expose some sort of ABI toward the Linux kernel, and the Linux kernel depends on such ABI to start other CPU cores, configure clock, power domains, pin multiplexing and other vital parts of the system.

With existing firmware interfaces like ACPI, the ABI stability is strictly enforced and ABI breakage seldom...
212. Fixing Clock Tree Propagation in the Common Clk Framework
Mr Brian Masney (Red Hat)

The Common Clk Framework (CCF) is expected to keep a clock’s rate stable after setting a new rate with "clk_set_rate(clk, NEW_RATE)". However, several longstanding issues affect how rate changes propagate through the clock tree when CLK_SET_RATE_PARENT is involved.

Current behavior allows a child clock to change its parent’s rate to satisfy its own request, but this adjustment happens...
190. How to extract a bare metal flavor of code out of Zephyr to use in RTOS ?
Khasim Syed Mohammed (Texas Instruments)

Zephyr RTOS offers a rich ecosystem, but embedded engineers often face the challenge of porting code across environments—from Zephyr to another RTOS or even to bare metal. This discussion is about a practical guide to extracting a “bare metal flavor” of code out of Zephyr so that it can run independently of Zephyr’s driver and subsystem layers.

NOTE: The HAL approach isn't the right...
327. Improving stability for TCPM using boards that are not self-powered
Sebastian Reichel (Collabora)

In this session we will discuss how to improve system stability of boards using fusb302 (or similar) chips for their USB-C port without any backup power source. This kind of setup is often found on Rockchip boards (e.g. Libre Computer ROC-RK3399-PC, Radxa ROCK 5B or ArmSoM Sige 5) and quite a pain, because a hard-reset effectively kills the board power.

The session starts with a short...
315. Reducing Android Boot Times: Evaluating Proactive File Prefetching
Akilesh Kailash

Proactive file prefetching has proven effective in reducing system boot times. This presentation details the evaluation of a prefetch solution for Android, inspired by its successful deployment on ChromeOS. We analyze its performance impact through Perfetto traces, confirming notable boot time reductions. The core of the implementation involves a two-phase "Record and Replay" process, and we...
4. Gaming on Linux MC
André Almeida (Igalia), David Vernet (Meta)

CFP ends on October 8th (CLOSED)
The Gaming on Linux Microconference welcomes the community to discuss a broad range of topics around performance improvements for Gaming devices running Linux. Gaming on Linux has pushed the kernel to improve in several areas and has helped create new features for Linux, such as the futex_waitv() syscall, the Unicode subsystem, HDR support, and much more....
205. A new API for robust futex list
André Almeida (Igalia)

Emulators and translation layers have been pushing the limits of the existing syscalls and Linux APIs, creating the need for new interfaces. One of such interfaces is the get/set_robust_list() syscall.

This syscall gets as an argument a user pointer to a user linked list. This syscall assumes that the pointer size is the native size, depending on the kernel build. This doesn't works when...
396. Level Up Your Game: OS Kernel and Game Interactions revealed with Perfetto
Mr Ramesh Peri (Meta)

Perfetto is a powerful instrumentation-based tool that enables deep insights into the behavior of computing platforms. In this talk, we’ll demonstrate how Perfetto can be leveraged to analyze the performance of mobile and VR games, focusing on their interactions with the Linux kernel.

We’ll present real-world examples illustrating how Perfetto helps us understand the complex relationships...
431. Proactive and crash-time data collection on Steam Deck
Guilherme G. Piccoli (Igalia)

Steam Deck is a successful console from Valve that runs on top of FOSS, having Linux as its operating system.

For the regular gamers, user experience is smooth and they don’t even need to think about what’s going under the hood to ensure such good experience is possible. Specially, there are interesting bits from the tracing system and in-kernel debug features leveraged in order to achieve...
433. Steps Towards a Gaming-Optimized Scheduler
Dr Changwoo Min (Igalia)

The CPU scheduler plays a decisive role in the Linux gaming experience. By controlling which task runs first, for how long, and on which CPU, the scheduler directly impacts stutter, latency, energy efficiency, and overall performance.

This talk asks whether a gaming-optimized scheduler is feasible, and if so, what fundamental properties it should preserve. We will outline potential...
34. Kernel Memory Management MC
David Hildenbrand (Red Hat)

CFP ends on September 30th (CLOSED)
Memory management keeps on being exciting. With a lot of activity on all different kinds of projects, some more controversial subjects that might be worth discussing this year:

  • Making Transparent Huge Pages more ... transparent (toggles, policies, khugepaged, ...)
  • Making (m)THP/large folios a first-class citizen in MM
  • What other improvements...
226. CMA allocations fail due to pinned MOVABLE pages
Juan Yescas (Google), Kalesh Singh (Google)

When device drivers reserve big blocks of MIGRATE_CMA pages, the underutilized MIGRATE_CMA can be used for MIGRATE_MOVABLE requests and these pages can be short-term pin for DMA, so if we require MIGRATE_CMA pages, the allocations might fail.

This topic has been discussed...
114. Decoupling Large Folios from Transparent Huge Pages
Pankaj Raghav (Samsung)

Large folios were initially implemented with dependencies on Transparent Huge Pages (THP) infrastructure. As large folio adoption expands across the kernel, CONFIG_TRANSPARENT_HUGEPAGE has become an overloaded configuration option, sometimes used as a proxy for large folio support [1][2].

While this coupling was discussed during the THP cabal, the specific dependencies remain unclear. This...
347. Memory Allocation Profiling upcoming features
Sourav Panda (Google), Suren Baghdasaryan

Memory allocation profiling infrastructure provides a low-overhead
mechanism to make all kernel allocations in the system visible. This
allows for monitoring memory usage, tracking hotspots, detecting
leaks, and identifying regressions.

Over the past year there were a number of suggested new features from its users, including:
- NUMA awareness
- MEMCG awareness
- Context capture...
379. Memory descriptors for DEVICE_PRIVATE memory
Alistair Popple

Device private memory is used by device drivers to interact with the core mm to migrate data to memory that is inaccessible or unaddressable from the CPU. Currently that interaction uses struct pages and sometimes folios.

It has been pointed out[1] that if everything is converted to folios maybe we don't need these special struct pages anymore. I would like to explore whether removing...
223. Mempolicy is dead, long live memory policy!
Gregory Price (Meta)

The default global mempolicy is inclusive of all NUMA nodes - where the fallback allocation behavior is typically defined by NUMA distances. Tasks and cgroups are then expected to opt-in to more restrictive policies via set_mempolicy and cpusets interfaces.

This is the opposite of a typical isolation mechanisms - and leads to global resource (such as unmapped pagecache) having poor...
125. Per-cgroup Swap Device Control
Chris Li (Google), YoungJun Park (LG Electronics)

ABSTRACT

Enabling cgroup-level control over swap devices

PROPOSAL

In certain restricted environments, there is a technical requirement to use otherwise idle devices as extended swap memory - including remote storage systems accessible over the network. A motivating scenario is to configure background processes to use these slower network-backed swap devices, while foreground...
126. Racing with kswapd during fallback allocations
Joshua Hahn (Meta)

While investigating how kernel memory in CXL impacts performance, we came across an interesting phenomenon: when the local node runs out of memory, fallback allocations do not reliably happen on remote nodes (i.e. CXL) when they are onlined as ZONE_MOVABLE.

Looking deeper, we were able to trace the root of the issue: when DRAM runs of out memory but must allocate a kernel entry (e.g. slab...
403. Taming Zombie Cgroups: Should Reparenting Be Simple or Smart?
Harry Yoo (Oracle), Kamalesh Babulal (Oracle)

The "zombie memory cgroup" problem is a long-standing issue in the Linux Kernel. It occurs when a memory cgroup is destroyed by users, but kernel metadata cannot be freed because its Least Recently Used (LRU) pages, particularly shared file pages, remain charged to it. These pages can outlive the cgroup that originally owned them, acting as a permanent pin. In environments where cgroups are...
264. The life cycle of the mm_struct
Liam Howlett (Oracle)

There have been several recent cases where the mm_struct is used without being fully initialized, in an unstable state, or taken longer than expected to exit. The most likely issues are often caused by external complications (zswap, oom, pte lock contention, and perf for example) which require mitigation one at a time.

I'd like to discuss what can be done to avoid having to fix each area...
282. The Past, Present & Future of the Anonymous Reverse Mapping
Lorenzo Stoakes (Oracle)

The anonymous memory reverse mapping is complicated, confusing and entails
overhead both in terms of locking and kernel metadata.

This talk explores how it functions in practice, how it interacts with other
aspects of mm as well as real-world impact of the current implementation.

Importantly it will examine how anon_vma locking functions and how this impacts workloads.

The talk will...
363. Transparent Huge-Page support for guest_memfd
Michael Roth (AMD)

Supporting hugepages is critical to unlocking the performance potential of confidential VMs. While there has been a lot of recent development activity around adding hugepage support to guest_memfd to support HugeTLB-like use-cases, there are also efforts underway to enable hugepage support for guest_memfd via the normal buddy allocator and leveraging Transparent Huge-Pages to provide hugepage...
404. type-based slab allocation: kmalloc_obj family
Kees Cook (Google)

Right now the generic interface to the slab allocator is strictly size based, but most of the allocations done via slab are actually instantiating specific objects, and their type information is much more useful to expose to the allocator than their size. (Though size is still important, give dynamically sized objects via flexible arrays.)

Type information is needed to make better choices...
1. Kernel Testing & Dependability MC
Arisu Tachibana

CFP ends on September 30th (CLOSED)
The Kernel Testing & Dependability Micro-Conference (a.k.a. Testing MC) focuses on advancing the current state of testing of the Linux Kernel and its related infrastructure.

Building upon the momentum from previous years, the Testing MC's main purpose is to promote collaboration between all communities and individuals involved with kernel testing and...
382. A fast path to benchmarking
Mark Brown

Most of our upstream efforts with kernel quality have thus far tended to focus on functional testing, but performance is also critical to actual user experiences. There are a large number of benchmarks out there but not much shared tooling or common practices with what or how we benchmark. How can we do better here?

To start the discussion this presentation introduces Fastpath, a tool Arm...
305. Automating Scope-Based Resource Cleanup with Coccinelle
Erick Muthama

Manual management of resources, from locks to reference counts, is a persistent source of bugs, resource leaks, and reduced code robustness. Scope-based resource management, offers a far more reliable approach by automatically releasing resources when they fall out of scope.
This session will demonstrate the practical application of Coccinelle to automate the transition to scope-based...
330. KernelCI kci-dev: Closing the developer feedback loop
Arisu Tachibana

KernelCI has become a backbone for Linux kernel review across diverse hardware labs.
kci-dev aims to bring that same power directly into developers workflows both for pre and post merge.
kci-dev can also be useful for doing analysis and validation from your terminal.
This testing discussion topic try to draw a concrete plan to align kci-dev, KernelCI APIs with Kernel...
89. KFuzzTest: Targeted Fuzzing of Internal Kernel Functions
Ethan Graham (ETH Zurich)

Fuzz testing the Linux kernel with system-call fuzzers has been highly effective, but this approach struggles to reach and test deeply nested internal kernel functions. This leaves significant parts of the kernel’s logic, particularly complex data parsers, under-tested and potentially vulnerable. We introduce KFuzzTest, a novel framework aiming to bridge this gap by directly exposing stateless...
72. Kselftests augmented: running kernelspace tests from userspace
Ricardo Cañuelo (Igalia)

The kernel testing ecosystem is roughly split into kernelspace tests, commonly implemented using the KUnit framework, and an assortment of userspace tests, the most representative of which are kselftests.

Both types have different goals and are used differently: while KUnit tests are meant to be run in a known scenario on a freshly booted kernel, with little or no interactions and no...
337. syzbot ci: continuous patch series fuzzing
Aleksandr Nogikh (Google)

For the past 9 years, [syzbot][1] has reported more than 13,000 findings to the Linux kernel mailing by continuously fuzzing upstream Linux trees. However, a notable latency often exists between the introduction of a bug and its discovery, complicating and delaying its resolution. Many regressions, including build/boot failures and shallow bugs, can stall the broader fuzzing effort once they...
200. SYZOS: Practical KVM fuzzing
Alexander Potapenko (Google)

Fuzzing the Linux kernel with coverage-guided tools like syzkaller has proven to be an extremely effective method for finding kernel bugs. However, complex subsystems like KVM present unique and significant challenges that standard syscall fuzzing cannot easily address. Fuzzing KVM effectively requires managing complex state across both the host and the guest, and necessitates the coordinated...
308. The singularity is here for testing: genai advancements on kdevops
Luis Chamberlain (Samsung)

The [kdevops][1] project automates complex Linux kernel development subsystem testing. Around Q3 we started evaluating advances in generative AI. The experimentation on kdevops shows project significantly enhances the speed and accuracy of generative AI for extending its features and adding new workflows. This capability was a core design principle. While generative [AI may not yet be optimal...
60. UAPI testing with KUnit
Thomas Weißschuh (Linutronix)

Today the kernel's UAPIs are tested through userspace testcases using the kselftests framework, which provides a uniform build system and output formatting infrastructure. However it does currently not provide an out-of-the-box solution to run the tests against the current in-development kernel tree.

I am proposing a framework which allows to build the test applications as part of the...
24. Linux System Monitoring and Observability MC
Breno Leitao (Meta), Guilherme Piccoli (Igalia), Jason Xing (Tencent), Usama Arif

CFP ends on October 10th
The Linux System Monitoring and Observability Track brings together developers, maintainers, system engineers, and researchers focused on understanding, monitoring, and maintaining the health of Linux systems at scale. This track addresses the needs of engineers managing millions of Linux servers, where proactive monitoring, rapid problem detection, and automated...
274. Actionable Data Access Monitoring Output Data and Format
SeongJae Park

DAMON simplifies the collection of system and workload data access patterns. However, interpreting this data and transforming it into actionable insights for humans remains a challenge. Representing the data in an actionable format is difficult. While efforts have been made to visualize this data, opinions vary on its accessibility. This session will review past attempts to make the data...
103. Extending Flamegraphs for Multi-Dimensional Performance Analysis
Mr Gavin Guo

Over the past decade, Brendan Gregg’s Flamegraph has become an indispensable tool for pinpointing performance bottlenecks. Based on the canonical Flamegraph, it has been evolving into various flavors tailored to address specific performance issues in the production systems. We'll share how the novel approach generates Flamegraphs from latency, memory usage, crashdump, and kern.log traces....
265. From Tool To ToolBox: How bpftrace is evolving to become more composable and expressive
Adin Scannell, Jordan Rome

This talk will cover the on-going effort to evolve [bpftrace][1] from an observability tool into a flexible, composable framework that can make many observability tools and drive the larger BPF observability ecosystem - instead of trailing behind it.

Over the past year, the bpftrace development team has focused on removing obstacles that hinder users from efficiently observing and debugging...
78. Guider: Lightweight Real-Time Performance & Fault Monitoring Framework for Embedded Linux Platforms
Mr Peace Lee (Hyundai Motor Company)

Guider is an open-source, self-contained performance monitoring and observability framework designed for embedded and custom Linux platforms such as AGL, Android, Tizen, webOS, and custom distros.

With over 180 built-in commands and support for TCP/UDS-based remote APIs, Guider provides a flexible yet lightweight system for real-time monitoring, profiling, and fault detection. It...
395. Improving page_owner for profiling and monitoring memory usage per allocation stack trace
Mauricio Faria de Oliveira (Igalia)

The existing page_owner debug feature tracks the stack trace of memory allocations in the system at the page level. It can answer questions like: 'What allocated this page?' and 'How many pages are allocated by what?' -- pointing right at the source code.

That allows for profiling and monitoring all of the system memory per allocation stack trace to identify trends, leaks, spikes,...
76. Methodology and Practice in Observing Kernel Networking
Jason Xing (Tencent)

Title

Methodology and Practice in Observing Kernel Networking

Abstract

Blindly enumerating all counters extracted from the kernel and haphazardly monitoring every function in the hot path is hardly practical in production. Three key issues deserve greater attention: 1) performance degradation, 2) ineffective metrics, and 3) the prohibitive cost of massive data storage. In most time,...
295. Module Error Injection with eBPF
Daniel Gomez

We build robust kernel code by properly handling errors and recovering
gracefully. But many critical error conditions are hard to replicate
in testing, so error injection becomes essential for validation. Past
error injection approaches were often considered too intrusive and got
rejected [1].

This talk presents moderr, an eBPF tool using libbpf for error injection
in the kernel module...
293. Proactive and crash-time data collection on Steam Deck
Guilherme G. Piccoli (Igalia)

Steam Deck is a successful console from Valve that runs on top of FOSS, having Linux as its operating system.

For the regular gamers, user experience is smooth and they don’t even need to think about what’s going under the hood to ensure such good experience is possible. Specially, there are interesting bits from the tracing system and in-kernel debug features leveraged in order to achieve...
450. Reading memcg stats more efficiently
JP Kobryn (Meta)

Context: https://lore.kernel.org/all/20251001045456.313750-1-inwardvessel@gmail.com/

Periodically reading data directly through memory.stat can be expensive across a large enough fleet. Most of the overhead lies in the string formatting and numeric conversion not only in the kernel but also by any user mode program parsing the data. I’d like to discuss the proposed kfuncs in the patch and...
440. Scaling Kernel Production Monitoring @ Meta
Vlad Poenaru (Meta)

Monitoring the kernel on millions of servers in production poses significant problems in terms of scale and diversity of the environment, both in terms of software and hardware. An observability system should allow detecting, debugging and fixing a large number of issues, as well as allowing engineers to focus on the most important ones in terms of spread and severity. This is made challenging...
9. Live Update MC
Alexander Graf, David Matlack (Google), Mike Rapoport, Pasha Tatashin

CFP ends on September 10th (CLOSED)
Live Update is a specialized reboot process where selected devices are kept operational and kernel state is preserved and recreated across a kexec. For devices, DMA and interrupts may continue during the reboot.

The primary use-case of Live Update is to enable hypervisor updates in cloud environments with minimal disruption to running virtual...
246. Blackout Reduction
Pasha Tatashin

An open discussion on improving kexec performance during live updates. Minimizing the downtime associated with reboots is critical. This session will explore potential optimizations, including methods to speed up ACPI discovery, enhance serialization/deserialization, and ideas like orphaned VMs. We invite the audience to contribute their own ideas and experiences to collaboratively identify...
180. IDPF live-update support
Brian Vazquez

This microconference proposal aims to facilitate a discussion on the challenges and solutions for adding live-update support to Linux networking drivers, using the IDPF driver as a primary case study. Live-update is a specialized reboot process that preserves selected devices and kernel state, minimizing disruption in cloud environments. A key use case is enabling hypervisor updates while...
165. IOMMU State Preservation for Kernel Liveupdate
Samiullah Khawaja

During a kernel live update, devices owned by a virtual machine may continue to perform DMA operations. For these operations to succeed, the IOMMU state must be preserved. Normally, a kexec reboot would reinitialize the IOMMU, causing the loss of all state and pre-existing DMA mappings.

To prevent this loss and ensure device continuity, the DMA mappings setup for a preserved device must...
268. Kexec Handover Performance Improvements
Jason Miu

The KHO framework's initial design relies on a stateful, linear serialization step that creates a scalability bottleneck on large-memory hosts. This talk will detail our effort at making KHO stateless by changing the data structures which manage preserved physical pages.

The session will also facilitate an open discussion on future optimizations. We will explore potential designs for making...
227. KSTATE as [de]serializer of kernel's state.
Andrey Ryabinin

Hello, I'd like to propose discussion about KSTATE
as a solution for [de]serializing kernel's state.

Thanks,
Andrey

245. Live Update Orchestrator
Pasha Tatashin

Introduce the Live Update Orchestrator (LUO) and its daemon, LUOD, a new framework designed to provide user API, state machine, resource management, and resource ownership model for live update operations. Detail the architecture of LUO, explaining its core components and states. The talk will walk through the typical workflow.

We will cover the current status of the project, including key...
221. Managing serialization versions for LUO objects
Pratyush Yadav

As LUO grows and various subsystems evolve, there will eventually be a need to update the serialization format for a particular subsystem. This new version of the format needs to be understood by the next kernel. This talk will discuss how the versions can be managed and negotiated between the current and the next kernel to ensure live update actually succeeds.
91. Memory preservation using LUO
Pratyush Yadav

The Live Update Orchestrator (LUO) allows userspace to hand over resources identified by file descriptors (FDs) to the next kernel. Memory is one of the most fundamental resources managed by the kernel. Memory can be identified by a FD via memfd. This makes memfd a great candidate for the first LUO user.

This talk will discuss the design of memfd preservation with LUO, current state of...
88. PCI liveupdate subsystem and PCI device
Chris Li (Google)

Live Updating GPU device is a big usage case for the Hypervisor liveupdate project.

The PCI liveupdate subsystem is built on top of the Live Update Orchestrator to manage the PCI device and its depended device for the livedupate.

The PCI device probing needs heavily modification to embrace the device livedupate. The device is already running and have device state left by the previous...
220. PCSC: Caching PCI Config Space Accesses for faster Live Updates
Evangelos Petrongonas (Amazon Web Services)

At scale, virtualization uncovers hidden bottlenecks, including the cost of PCI configuration space accesses. In SR-IOV deployments with thousands of VFs, each configuration read triggers a hardware transaction. As VFs increase, these accesses scale linearly, leading to longer VM boot times, heavier bus contention, and noticeable startup delays.

The PCI subsystem today treats every...
233. Supporting Hypervisor Kexec with Modern Devices
Adithya Jayachandran (NVIDIA), Saeed Mahameed (Nvidia)

Restarting a node running a stateful workload for an infrastructure software upgrade can be an extremely costly operation. Modern infrastructure software upgrades must also account for applications which are using accelerators such as GPUs, RDMA NICs and NIC stateful flow accelerators. While these workloads may typically run in isolated VMs, a hypervisor reboot for a kernel update can lead to...
156. Supporting Live Update in VFIO
David Matlack (Google), Josh Hilke (KVM Team @ Google)

In this talk, we'll discuss our work to support Live Update in VFIO for PCI devices.

Live Update is a mechanism to quickly update the kernel while running virtual machines using kexec. VFIO is a kernel module to allow devices to be controlled by userspace and virtual machines.

During our talk we will cover the problems that need to be solved to support Live Updates in VFIO, and our...
352. mail test
James Bottomley (Microsoft)

mail test
46. Power and Thermal management MC
Daniel Lezcano (Linaro)

CFP ends on October 15th
The Power Management and Thermal Control microconference is about all things related to saving energy and managing heat. Among other things, we care about thermal control infrastructure, CPU, and device power-management mechanisms, energy models, and power capping.

This year has been mainly focused on the maintenance of the frameworks,...
29. RISC-V MC
ATISH PATRA (Rivos), Björn Töpel (N/A), Palmer Dabbelt (Google)

CFP ends on September 29th (CLOSED)
We’d like to propose bringing back the RISC-V Microconference at Linux Plumbers 2025. As the RISC-V ecosystem continues to grow, so does the importance of having a space where developers, hardware vendors, toolchain maintainers, and distro folks can come together to solve real-world problems. This microconference has always been a great venue for open,...
273. Debugging RISC-V Kernel Crashes: KDUMP, vmcore, and Crash Utility Enhancements
Austin Kim (LG Electronics)

Background

When we bring up a RISC-V board from a chipset vendor, the kernel log cannot give us enough details about what happens inside the kernel. Kernel logs do not contain sufficient debugging information. Because of this, a vmcore is necessary to understand what is really happening inside the kernel.

For binary analysis, many Linux developers use the vmcore file. They usually enable...
351. Declaring WARL on the ISA string.
Radim Krčmář (Ventana Micro Systems)

A RISC-V ISA has a lot of variables, and the ISA string describes a small subset of those variables, so some of the remaining ones are current discovered by directly interacting with the ISA implementation through trial and error (WARL).

WARL hinders virtualization as the discovery is done through registers that we don't want to trap and emulate for performance reasons, and there is no...
100. Finer-grained kernel control flow integrity and challenges
Mr Deepak Gupta

Kernel control flow integrity RFC patches [1] are out. It uses existing hooks in shadow call stack config for riscv hardware assisted shadow stack. Forward cfi is finer grained cfi using a toolchain which matches landing pad labels between callsite and taken-targets. Talk will focus on following emerging challenges, proposed solutions and further discussions/comments on them.

Forward cfi
-...
391. Preparing RISC-V Linux for RVA23
Charlie Jenkins (Rivos)

The number of RISC-V extensions is ever increasing. To manage the wide variety of extensions that are available to hardware vendors, RISC-V International (RVI) has introduced "profiles" that define groupings of extensions for different classes of hardware.

The currently relevant profile is named RVA23 and specifies a set of extensions that supervisor and userspace software vendors can rely...
378. RISC-V QoS: CBQRI, RQSC and resctrl
Drew Fustini (Tenstorrent)

QoS Background

Some of the next generation of RISC-V SoCs are expected to have QoS (Quality-of Service) functionality to control and monitor the usage of resources such as cache capacity and memory bandwidth. The RISC-V Quality-of-Service Identifiers (Ssqosid) extension [1] adds the srmcfg CSR to configure a hart with two identifiers: a Resource Control ID (RCID)...
53. Schism: Splitting RV32 from `arch/riscv` - - We Could Both Be Better as We Part Ways
"Ruinland" ChuanTzu Tsai (Andes Technology), ChunWei Shu (SiFive)

It’s the elephant in the room: in the Linux kernel, RV64 has become significantly more popular and better supported than its smaller sibling — the RISC-V 32-bit platform.

There have been multiple open discussions about dropping RISC-V 32 support to "liberate" kernel development.

However - - and it’s a big however - - many people actively use RISC-V 32 Linux in production, and some of...
199. Solving Pre-silicon Kernel Upstream for RISC-V First Ever
Yuning Liang (DeepComputing)

Upstreaming kernel support traditionally happens only after silicon becomes available, but this approach often delays software enablement and ecosystem readiness. For the first time in the RISC-V world, we are tackling the challenge of pre-silicon kernel upstreaming—enabling Linux kernel features ahead of actual chip availability.
In this session, we will share the methodology, toolchains,...
47. Rust MC
Miguel Ojeda

CFP ends on September 30th (CLOSED)
Rust is a systems programming language that is making great strides in becoming the next big one in the domain. Rust for Linux is the project adding support for the Rust language to the Linux kernel.

Rust has a key property that makes it very interesting as the second language in the kernel: it guarantees no undefined...

332. External locking for internally synchronized data structures
Mr Andreas Hindborg (Samsung)

Some C kernel data structures exposed to Rust code apply internal
synchronization (XArray). Depending on the type of lock, such data structures
need to unlock locks when allocating memory. Sometimes it is beneficial to use a
single external lock to protect multiple such data structures.

In Rust this creates a problem that is not present in C. This is because that
mutably borrowing...
55. Initialization in Rust with pin-init
Benno Lossin

Rust in the Linux kernel uses the pin-init library for initialization. This library handles ergonomic and safe initialization of address-sensitive types such as Mutex<T> (the abstraction of struct mutex).

Since address sensitivity is an inherited property (a type containing an address-sensitive type also becomes one), lots of types require using the pin-init API to initialize them....
418. Moving kernel swapping infrastructure to Rust
Vitaly Wool

This talk will briefly cover this historical background and then the focus for the discussion will be which parts of the swapping subsystem and related drivers (e. g. zram) are better off reimplemented in Rust, and why.
240. Overflowing with Fear: Detecting and Mitigating Implicit Panics in Rust
Alexandre Courbot (NVIDIA)

One of the main selling points for Rust's inclusion in the kernel is safety, which is strongly associated with a reduction of runtime panics. Yet, in Rust an integer overflow or out-of-bounds array access translates into an implicit panic, inserted without any warning to the programmer.

The inability to easily identify where these implicit panic sites are introduced creates a blind spot...
407. Rex and its integration with Rust-for-Linux
Jinghao Jia (University of Illinois Urbana-Champaign), Ruowen Qin

TL;DR We propose to present the Rex project (Rust-based kernel extension) and discuss its integration with Rust for Linux.

Rex is a Rust-based kernel extension framework (https://github.com/rex-rs/rex). It offers similar safety guarantees as eBPF. Different from eBPF, which verifies the safety of extension code via an in-kernel verifier, Rex builds its safety guarantees atop the...
319. Rust language evolutions for better kernel developer experience
Xiangfei Ding

This activity comprises of two parts. First it will be a short update on the development of language features as we close the chapter on the Rust project goal 2025H2, covering features like arbitrary_self_types and trait evolution and the projected availability of the features on stable Rust releases and focusing on how this enables better kernel developer experience when working on Linux...
82. Tackling challenges with HID and related device driver support in Rust
Rahul Rameshbabu

As HID support in Rust is being developed, a number of challenges are arising during the development process. Binding the C API that represents different HID structures will grow verbose as more HID logic is supported in Rust. Specialized HID device drivers will want to make use of APIs from other subsystems, such as input and DRM. Otherwise, such drivers tend to be isolated to HID report...
329. Tyr: a new Rust GPU driver
Mrs Alice Ryhl (Google), Daniel Almeida (Collabora)

Showcase the current state of Tyr, a new Rust kernel driver for Arm Mali GPUs, briefly mentioning current status of the driver and the associated Rust abstractions needed to support it, as well as the future plans for both upstream and Android.

The discussion should be centered on whether the current upstreaming plan makes sense to the DRM community, considering our efforts both upstream...
2. Safe Systems with Linux MC
Kate Stewart (Linux Foundation), Philipp Ahmann (Etas GmbH (BOSCH))

CFP ends on October 5th (CLOSED)
As Linux continues to be deployed in systems with varying criticality constraints, progress needs to be made in establishing consistent linkage between code, tests, and requirements, to improve overall efficiency and ability to support necessary analysis.
This MC addresses critical challenges in expectation management (aka requirements tracking),...
17. sched_ext: The BPF extensible scheduler class MC
Mr Joel Fernandes (NVIDIA), Mr Daniel Hodges (Meta), Changwoo Min (Igalia), Andrea Righi (NVIDIA)

CFP ends on September 30th (CLOSED)
sched_ext[1] is a Linux kernel feature which enables implementing safe task schedulers in BPF, and dynamically loading them at runtime. sched_ext enables safe and rapid iterations of scheduler implementations, thus radically widening the scope of scheduling strategies that can be experimented with and deployed, even in massive and complex production...
73. Accelerating AI training fleets with sched_ext
Patrick Lu, Valentin Andrei (Meta)

We present one of the first deployments of sched_ext to a large fleet of AI training hardware composed of multi CPU socket systems with attached Nvidia GPUs. GPU training workflows run frequent synchronization across all the training processes which makes them extremely sensitive to task scheduling micro-delays that prevent work from being dispatched to the GPUs. In addition, the training...
271. Automated Workload-Aware Scheduling with SCX to Improve Performance
Neeraj Kumar (Meta)

Applications can greatly benefit from a workload-aware scheduling policy of worker threads that optimizes cache usage. For example, if a scheduling policy is aware of a workload’s data access patterns, it can make informed decisions on how to schedule threads to cores to take advantage of cache locality. However, a key technical challenge is achieving this in a workload-agnostic manner.

The...
84. Can ProxyExec and sched_ext get along?
John Stultz (Google)

Proxy Execution provides a generalized form of priority inheritance, which leaves mutex-blocked tasks on the run-queue. Then if the scheduler tries to run a mutex-blocked task, it will instead run the mutex owner on the blocked task's behalf, so the mutex can be released.

In order for this to work, we introduced the idea of split contexts (scheduler and execution), tracking both the task...
66. From Fragmentation to Integration: Enhancing sched_ext BPF Scheduler Interoperability with Linux
Daniel Hodges (Meta)

In this talk, we will explore the challenges and opportunities in improving the interoperability of sched_ext BPF schedulers with various Linux and in particular existing scheduler code as well as other subsystems. While sched_ext BPF schedulers offer powerful and flexible scheduling capabilities, their integration with other kernel components can often be fragmented and complex. This talk...
139. How do we make a Steamdeck scheduler work on large servers
David Dai

With the proliferations of many sched_ext schedulers, including ones that caters for very specific workloads within Meta. There exists a need for a "default" fleet scheduler that "just works" for a wide range of hardware and use cases. SCX_LAVD is one such candidate as one of the more mature sched_ext schedulers out there with various heuristics to favor latency critical threads.

The talk...
57. Optimizing GPU bound workloads with sched_ext via scx_layered
pat somaru

Optimizing GPU bound workloads with sched_ext via scx_layered

In this talk, I will discuss how to optimize GPU bound workloads through the use of the sched_ext scheduler, scx_layered and how API changes could make make this simpler.

I will use a well understood open source GPU benchmark job (something like mnist or resnet) and a common cpu-bound open source workload (something like...
90. sched_ext: current status and future plans
Andrea Righi (NVIDIA)

This talk will kick off the sched_ext MC session with a brief overview of the project's current state: what features are available, what's missing and what remains under development.

We'll also look ahead to discuss gaps in the framework, ideas yet to be explored, and how we envision the sched_ext community growing.

The goal is to align contributors and spark discussions around...
92. Scheduler composability with arena-based data structures
Emil Tsalapatis (Meta Platforms)

This talk will present our progress on arena-based data structures for quickly evolving scheduler abstractions (DSQs, CPU topology).

We currently write scheduling algorithms in terms of operations on primitives provided by the kernel (BPF hash maps/arrays, CPU bitmasks, DSQs). Adding new operations to these primitives is work-intensive because it requires modifying the underlying kernel...
87. scx_chaos: Pushing the sched_ext API to schedule badly
Jake Hillion (Meta)

sched_ext has guardrails in kernel and lots of examples in BPF for how to schedule tasks effectively. We use sensible defaults for idle tracking, NUMA aware masks, and prevent you losing track of tasks in BPF. But what happens when you try to schedule badly?

scx_chaos builds on top of scx_p2dq, another sched_ext scheduler. It adds options for introducing delays, randomly decreasing CPU...
113. Taming the Chiplet: High Performance CCX scheduling via BPF
Aniket Gattani (Google), Josh Don (Google)

Thread placement on machines with complex cache hierarchies (such as AMD CPU Core Complexes (CCX’es)) requires careful management for optimal performance. Unlike NUMA domains, which are large enough that hard partitioning is a viable strategy, these chiplet domains are too small to schedule efficiently without a means of enforcing some degree of soft affinity. Spillover of threads to...
164. The Current Status and Future Direction of the LAVD Scheduler
Dr Changwoo Min (Igalia)

The LAVD scheduler is a sched_ext scheduler designed to optimize latency and energy efficiency, with an initial focus on gaming workloads. This talk will present the current state of LAVD development and explore its future roadmap. In particular, we will discuss how LAVD leverages heterogeneous CPU architectures (Intel P/E cores, ARM big.LITTLE) to improve performance per watt, along with...
23. Scheduler and Real-Time MC
Vincent Guittot (Linaro)

CFP ends on September 30th (CLOSED)
For Linux Plumber 2025, we propose a joint microconference for Real Time and Scheduler as in the past. These two areas have always been tightly linked and continue to generate cross functional changes especially after PREEMPT_RT has been merged. The scheduler is at the core of Linux performance; With different topologies and workloads, giving the user...
39. Cache Aware Scheduling
Mr Tim Chen (Intel)

Scheduler Micro conference Proposal

Title:
Cache Aware Scheduling

Presenters:
Tim Chen (tim.c.chen@linux.intel.com)
Chen Yu (yu.c.chen@intel.com)

We have proposed RFC patch series that implemented cache aware scheduling.
The primary motivation is to keep threads sharing data together in the
same last level cache domain, to reduce cache bouncing.

We'll like community feedback...
118. CPU Isolation and IPI interference
Valentin Schneider (Red Hat)

CPU Isolation enables a system administrator to shield a subset of CPUs from
most kernel interference, but not all of it. Activity on the housekeeping CPUs
can still trigger IPIs targeting isolated CPUs, which defeats the requested
isolation.

At Red Hat, we've mostly observed IPIs caused by instruction patching
(e.g. static key updates) and TLB flushes (e.g. due to vmap'd stacks...
313. Enabling Push call back in Fair class
Vincent Guittot (Linaro)

The wakeup path and the periodic load balance don’t cover all cases where we’d like to migrate a task on another CPU for the fair scheduling class. There are situations where we’d like to push tasks in a similar way than the wake up one. The EAS is one user which would benefit from a push mechanism as it disables periodic load balance but wants to migrate tasks more often than at wakeup. Non...
86. Paravirt Scheduling: Framework for better physical CPU utilization
Ilya Leoshkevich, Shrikanth Hegde

In para-virtualized environment, vCPU overcommit is a common configuration which helps customer to make better use of CPU resources since not all VMs would be active at the same time and hence underlying hypervisor will be able to meet the CPU demand and workloads running on VMs can benefit from the extra resource.

Acronyms:
vCPU - virtual CPU - CPU in VM
pCPU - physical CPU - CPU...
384. Push based load-balancing for fair tasks
Prateek Nayak (AMD Inc.)

During the discussion at OSPM ’25, the idea of using push-based load balancing as an alternate to idle and newidle balance was proposed. A prototype [1] was sent soon after OSPM to gather feedback from the community.

During the review, Peter mentioned optimizing the global nohz idle tracking to be reduced to per-LLC tracking to reduce the cost of access and update to this shared data being...
422. Rethinking Android's Priority Inheritance
Carlos Llamas

The Binder driver is a lightweight IPC that serves as the communication backbone between processes in Android. It implements a very peculiar Priority Inheritance model that has been rejected upstream. This presentation re-examines this design and presents a few upstream-friendly alternatives to the current model.
345. Runtime verification monitors for real-time
Nam Cao (Linutronix)

PREEMPT_RT has finally been merged. The mainline Linux kernel is now capable of providing real-time guarantees. However, the kernel is only one piece of the puzzle: to achieve real-time behavior, the userspace counterpart must also be designed correctly.

Unfortunately, userspace applications often introduce undesirable latency due to incorrect design. The root cause is that it’s unclear...
350. RV and real-time properties
Gabriele Monaco (Red Hat Inc.)

With the ongoing work on RV and the deadline scheduler, coupled with timed automata, we introduced a practical way to validate timing properties in the kernel.

Now we can have models guaranteeing that tasks are throttled when consuming their runtime and don't miss their deadline.

The few models for the deadline scheduler are barely scratching the surface of what could be done to validate...
38. System Boot and Security MC
Daniel Kiper, Piotr Król (3mdeb)

CFP ends on September 30th (CLOSED)
The System Boot and Security Microconference has been a critical platform for
enthusiasts and professionals working on firmware, bootloaders, system boot,
and security. This year, once again, we want to focus on the challenges that
arise when upstreaming boot process improvements to the Linux kernel and
bootloaders. Our experience shows that the...
334. Oak stage0: a minimal firmware for (confidential) virtual machines
Mr Andri Saar (Google)

Oak stage0 is a VM firmware, mainly targeting QEMU microvm and Q35 machines (and compatible VMMs) that is simpler (and less featureful) than the traditional choices of EDK2/OVMF and SeaBIOS. The main purpose of stage0 is to provide a smaller and simpler method of booting confidential virtual machines to reduce the TCB. To that end, stage0 supports AMD SEV-SNP and Intel TDX; stage0 is the first...
401. Reconcilable Differences: Booting Linux on IBM PowerVM LPARs
George Wilson (IBM)

When booting Linux on PowerVM LPARs, there are unique characteristics vs UEFI-based systems that developers must consider. Expanding on last year's talk that discussed booting without a bootloader, this talk explores additional aspects of booting Linux on Power, current platform status, and potential future enhancements. Topics include verified and measured boot with PQC, proposals for...
423. Ultraviolet: A Code Integrity Model for Minimal Container Hosts
James Morris

We’re seeing increased adoption of boot security technologies in Linux and utilization of platform root-of-rust mechanisms. There’s also been significant progress in open community efforts around image-based systems, where typically the root partition and/or the usr partition are implemented as signed DM-Verity volumes.

We’d like to demonstrate how to extend the integrity chain from boot...
58. Who Authenticates Linux? Rethinking PAM & NSS in the Age of Cloud Identity
Mr David Mulder (SUSE)

Who authenticates Linux? In the age of Azure Entra ID, Okta, Google Workspace, and beyond, the answer is increasingly "not your local LDAP or Kerberos realm." Modern identity providers rely on OAuth2, device compliance, and custom multi-factor authentication (MFA) flows that are fundamentally browser-centric — which sits at odds with how a Linux login works.

PAM was designed decades ago for...
63. Toolchains MC
Jose E. Marchesi (GNU Project, Oracle Inc.)

CFP ends on October 10th
The goal of the Toolchains micro-conference is to hold discussions about toolchain related topics that are relevant to the Linux kernel. This covers both the GNU toolchain and the Clang/LLVM toolchain.

In the last years we have had either a micro-conference or a complete track to discuss about Toolchain topics during LPC, and along with LSFMMBPF they have...
447. Adding C library wrappers for all Linux syscalls
Mr Carlos O'Donell (Red Hat)

In 2014 I added "WIP: Kernel syscalls wrappers" [1] item to the upstream glibc consensus documentation.

Over the last 11 years the idea that we should add C library wrappers for all Linux syscalls has waxed and waned, but I would like to revisit the idea with the help of the kernel community.

I want to look at the...

429. Challenges with Kernels built with LTO
Song Liu (Meta), Yonghong Song

We have been using CONFIG_LTO_CLANG_THIN in our production kernel for a few years. While delivering non-trivial performance improvements, kernels with CONFIG_LTO_CLANG_THIN enabled also bring challenges to our work:
LTO causes confusion for tracing users. With LTO, the compiler is more likely to do selective inlining, i.e., inline a kernel function at some call sites, but not some others....
400. Distributed ThinLTO Build Support in Kbuild
Rong Xu (Google)

We're going to talk about the work we've done to enable distributed ThinLTO builds for the kernel. We'll cover why we're doing this, how we implemented it, and how it compares to in-process builds. We'll also discuss the changes we made to other components, like livepatch.
310. Exciting new compiler flags for kernel security
Florent Revest (Google)

I'd like to share some toolchain experiences encountered as part of my work on hardening the kernel running on Google's production servers.

I'll discuss "profile guided hardening" (aka "selective sanitization") on how to make kernel cold paths extra hardened using -lower-allow-check-percentile-cutoff-hot and -fsanitize-ignorelist

I'll also share my excitement around the recent Clang...
438. GCC BPF and Linux kernel
Jose E. Marchesi (GNU Project, Oracle Inc.)

The goal of this activity is to go through a list of specific problems and issues concerning the BPF support in GCC.

TBD
35. VFIO/IOMMU/PCI MC
Alex Williamson, Bjorn Helgaas (Google), Joerg Roedel (AMD), Krzysztof Wilczyński, Lorenzo Pieralisi

CFP ends on September 30th (CLOSED)
The [PCI][1] interconnect specification, the devices that implement it, and the system IOMMUs that provide memory and access control to them are nowadays a de-facto standard for connecting high-speed components, incorporating more and more features such as:

  • Address Translation Service (ATS)/Page Request Interface (PRI)
  • [Single-root I/O...
129. A Hyper-V Based pvIOMMU Built on Generic I/O Page Table
Yu Zhang

We present a Hyper-V based pvIOMMU implementation for Linux guest, built upon the community-driven Generic I/O Page Table framework. Our approach leverages stage-1 page tables in the guest(w/ nested translation) to drive DMA remapping(including vSVA). This also eliminates the need for complex device-specific emulation and map/unmap overhead, meanwhile staying scalable across...
298. Confidential Devices (TEE I/O): A series of modest proposals
Dan Williams (Intel)

With required updates to the PCI core, device core, CPU arch, KVM, VFIO, IOMMUFD, and DMABUF the TEE I/O effort has a significant amount of work to do reach the starting line of the race to address Confidential Device use cases. Then, the mechanisms for devices to enter the locked state, the attestation and policy infrastructure for deploying secrets to TEE VMs, and the ability to recover a...
339. iommu page table consolidation and iommufd
Mr Jason Gunthorpe (NVIDIA Networking)

Review the current state of the page table consolidation project.

Depending on progress in the next months this may be a primer on the design of the consolidated page table system to help reviewers, or a discussion on the next steps to land along the project.

https://patch.msgid.link/r/0-v5-116c4948af3d+68091-iommu_pt_jgg@nvidia.com

Additionally any iommufd related topics that people...
70. PCI Pwrctrl woes
Manivannan Sadhasivam

On non-ACPI systems, such as the ones using DeviceTree for hardware description, the PCI host bridge drivers were responsible for managing the endpoint power supplies. While it worked for some simple use cases like the endpoints requiring 12V, 3.3V supplies, it didn't work for complex supplies required by some endpoint devices like the integrated WLAN/BT devices.

The PCI Pwrctrl framework...
353. Plumbing SDXI into Linux: From DMA Engine to User‑Space Offloads
Wei Huang

The Smart Data Accelerator Interface (SDXI) is a new SNIA standard that extends traditional DMA engines with support for multiple address spaces, user-space ownership, and extensible offloads such as memory data movement. This talk reports on the progress of Linux enablement in two phases: an initial DMA-engine integration already upstream for review, and a full SDXI 1.0 implementation with a...
31. x86 MC
Boris Petkov, Dave Hansen

CFP ends on October 13th
x86-focused material has historically been spread out at Plumbers. This will be an x86-focused microconference. Broadly speaking, anything that might affect arch/x86 is on topic, except where there may be a more focused discussion occurring, like around Confidential Computing or KVM.

This microconference would look at how to address new x86 processor features...
253. Address Space Isolation is ready
Brendan Jackman (Google)

Last year at LPC I presented the latest status of Address Space Isolation.

The key feedback was: we aren't really interested if it only works for the KVM use-case. x86 folks would still need to develop & maintain the bespoke mitigations. We only want it if it also protects against native attackers.

Since then, I've developed a [version that does that][1]. It performed very badly! At...
120. Dynamic mitigations
David Kaplan (AMD)

The kernel command line is an awkward place for CPU mitigation settings especially in environments where security policy needs aren’t known until user-space loads. Dynamic mitigations solve this problem by enabling re-selection of CPU mitigation settings at runtime via sysfs. In response to new settings, the kernel re-patches alternatives, retpolines, etc. just like if it was booted with the...
251. Leveraging New General-Purpose Registers in the Kernel
Chang Bae (Intel Corporation)

Registers are the fundamental programmable resources of any architecture. While x86 has evolved over time with specialized registers for vector processing and security, the general-purpose register (GPR) set has remained unchanged since the introduction of x86-64 nearly two decades ago. The new Advanced Performance Extensions (APX) expand the GPR set, providing additional scratch registers...
162. The new kernel CPUID API
Ahmed S. Darwish (Linutronix GmbH)

Over multiple mainline iterations, a new CPUID API is slowly getting in shape for both drivers and internal x86 architecture code.

This talk will show that new API, plus its benefits for call-sites.

The API's interaction with the existing X86_FEATURE mechanisms will be covered at the second half of the talk.
Powered by Indico