Linux Plumbers Conference 2022

Session

LPC Refereed Track

12 Sept 2022, 10:00

"Lansdowne" (Clayton Hotel on Burlington Road)

58. PREEMPT_RT - how not to break it.

Sebastian Siewior

12/09/2022, 10:00

The PREEMPT_RT patch set has only a handful patches left until it can be
enabled on the X86 Architecture at the time of writing.
The work has not finished once the patches are fully merged. A new issue
is how to not break parts of PREEMPT_RT in future development by making
assumption which are not compatible or lead to large latencies.
Another problem is how to address limitations on...

44. Launching new processes with `io_uring_spawn` for fast builds

Josh Triplett

12/09/2022, 10:45

io_uring allows running a batch of operations fast, on behalf of the current process. As the name suggests, this works exceptionally well for I/O workloads. However, one of the most prominent workloads in software development involves executing other processes: make and other build systems launch many other processes over the course of a build. How can we launch those processes...

101. Exercising the Linux scheduler with Yogini

Len Brown (Intel Open Source Technology Center)

12/09/2022, 12:00

Introducing "yogini", a flexible Linux tool for stretching the Linux scheduler and measuring the result.

Yogini includes an extensible catalogue of simple workloads, including execution, cache and memory bound, as well as advanced (Intel) ISAs. The workloads are assigned to threads, which can be run at prescribed rates at prescribed times.

At the same time, yogini can run a periodic...

62. OS Scheduling with Nest: Keeping Tasks Close Together on Warm Cores

Julia Lawall (Inria)

12/09/2022, 12:45

To best support highly parallel applications, Linux's CFS scheduler tends to spread tasks across the machine on task creation and wakeup. It has been observed, however, that in a server environment, such a strategy leads to tasks being unnecessarily placed on long-idle cores that are running at lower frequencies, reducing performance, and to tasks being unnecessarily distributed across...

46. RV: where are we?

Daniel Bristot de Oliveira (Red Hat, Inc.)

12/09/2022, 15:00

RV: Where are we?

Over the last years, I've been exploring the possibility of verifying the Linux kernel behavior using Runtime Verification.

Runtime Verification (RV) is a lightweight (yet rigorous) method that complements classical exhaustive verification techniques (such as model checking and theorem proving) with a more practical approach for complex systems.

Instead of relying on...

115. Modularization for Lockdep

Boqun Feng

12/09/2022, 15:45

Lockdep is a powerful tool for developers to uncover lock issues. However there are things that still need to improve:

• The error messages are sometimes confusing and difficult to understand, and require experts to decode them. This not only makes read deadlock scenarios challenging to understand, but also makes internal bugs hard to debug.

• Once one lock issue is reported, all the...

169. Make RCU do less (save power)!

Joel Fernandes, Rushikesh Kadam, Uladzislau Rezki

12/09/2022, 17:00

On battery-powered systems, RCU can be a major consumer of power. Different strategies can be tried to mitigate power which we will show along with power data. Also I have been working on some patches to further reduce RCU activity in frequently-called paths like file close. This presentation is to discuss some test results mostly on the power consumption side on battery-powered Android and...

51. Restartable Sequences: Scheduler-Aware Scaling of Memory Use on Many-Core Systems

Mathieu Desnoyers (EfficiOS Inc.)

12/09/2022, 17:45

Using per-core data structures in user-space for memory allocators, ring buffers, statistics counters, and other general or specialized purposes typically comes with a trade-off between speed and scaling of memory use for workloads which consist of fewer threads than available cores.

This is especially true for single-threaded processes (quite common) and for containers which are...

15. How I started chasing speculative type confusion bugs in the kernel and ended up with 'real' ones

Jakob Koschel (VUSec Amsterdam)

13/09/2022, 10:00

This talk will illustrate my journey in kernel development as a PhD student in Computer Systems Security. I've started with [Kasper][1], a tool I have co-designed and implemented, that finds speculative vulnerabilities in the Linux kernel. With the help of compilers Kasper emulates speculative execution to apply sanitizers on the speculative path.
Building a generic vulnerability scanner...

136. Profiling data structures

Arnaldo Carvalho de Melo (Red Hat Inc.)

13/09/2022, 10:45

The Linux perf tools shows where, in terms of code, a myriad of events take place (cache misses, CPU cycles, etc), resolving instruction pointer addresses to functions in the kernel, BPF or user space.

There are tools such as 'perf mem' and 'perf c2c' that help translating data addresses where events take place to variables, and those will be described, both where the data comes from, such...

56. Inside the Linux Kernel Random Number Generator

Jason Donenfeld

13/09/2022, 12:00

Over the last year, the kernel’s random number generator has seen significant changes and modernization. Long a contentious topic, filled with all sorts of opinions on how to do things right, the RNG is now converging on a particular threat model, and makes use of cryptographic constructions to meet that threat model. This talk will be an in depth look at the various algorithms and techniques...

49. Live in a world with multiple memory types

Mr Ying Huang

13/09/2022, 12:45

Initially, all memory are DRAM, then we have graphics memory, PMEM,
CXL, ... Linux kernel has recently gained the basic support to manage
systems with multiple memory types and memory tiers, and the ability
to optimize performance by demoting/promoting memory between the
tiers. And we are working on enhancing Linux's capabilities further.

In this talk, we will discuss the current...

124. Kernel Live Patching at Scale

Song Liu (Meta), Rik van Riel (Meta), David Vernet (Meta)

13/09/2022, 15:00

Kernel live patching (KLP) makes it possible to apply quick fixes to a live Linux kernel, without having to shut down the workload to reboot a server. The kpatch tool chain and the livepatch infrastructure generally work well. However, using them on a closely monitored fleet with several million servers uncovers many corner cases. During the deployment of KLP at Meta, we ran into issues,...

140. TCP memory isolation on multi-tenant servers

Christian Warloe (Google), Shakeel Butt (Google), Wei Wang (Google)

13/09/2022, 15:45

On Linux, tcp_mem sysctl is used to limit the amount of memory consumed by active TCP connections. However that limit is shared between all the jobs running on the system. Potentially a low priority job can hog all the available TCP memory and starve the high priority jobs collocated with it. Indeed we have seen production incidences of low priority jobs negatively impacting the network...

34. Meta’s CXL Journey and Learnings in Linux

Jonathan Zhang

13/09/2022, 17:00

Compute Express Link (CXL) is a new open interconnect technology built on top of PCIe.
Among other features, it enables memory expansion, unified system address space and cache
coherency. It has the potential to enable SDM (Software Defined Memory) and emerging
usage models of accelerators.

Meta has been working on CXL with current focus on memory expansion. This presentation
will...

139. nouveau in the times of nvidia firmware and open source kernel module

David Airlie

13/09/2022, 17:45

This talk will look at the recent NVIDIA firmware release and open source kernel module contents, define what exists, what can happen.

It will then address the nouveau project and what this means to it, and what sort of plans are in place to use what NVIDIA has provided to move the project forward.

It will also discuss possible future projects in the area.

80. Once upon an API

Michael Kerrisk (man7.org Training and Consulting)

Even a seemingly simple API can turn out to have complex and surprising behaviors, as I illustrate by telling the story of an API feature that was added to Linux in 1997 and looking how it interacts (and has evolved) with other parts of the Linux API. These kinds of complexities and surprises of course create pain for user-space programmers, and so I also muse about some of the reasons that...

80. Once upon an API

Michael Kerrisk (man7.org Training and Consulting)

Even a seemingly simple API can turn out to have complex and surprising behaviors, as I illustrate by telling the story of an API feature that was added to Linux in 1997 and looking how it interacts (and has evolved) with other parts of the Linux API. These kinds of complexities and surprises of course create pain for user-space programmers, and so I also muse about some of the reasons that...