A method for capturing the interface signature and checking for consistency of all interfaces at link time ultimately preventing execution of incoherent binaries (slides)

This talk will present and demonstrate a simple and nonintrusive framework for writing and selectively running unit tests on external and internal kernel APIs.

how to use public cloud for kernel testing and how to build and share such infrastructure with kernel communities?

Discover plumbing pain-points from automating decryption.

Transpiling directly from python to bpf and the cool stuff it allows us to build.

Despite more than 20 years of active research and development, a lot of scalable synchronization remains inaccessible to many students, engineers and open-source projects. Why? And what has been done so far?

Discuss the possible solution for the challenges we found during our testing and optimizing to use swap on fast NVMe disk.

Measuring CFS-based CPU scheduling performance on multi-tenant hosts

New lessons learned after handin out even more commit rights. (slides)

Symbolic debuggers are one of the most important tools in the programmer’s toolkit, but also one of the most overlooked pieces of technology. They have to work in some of the harshest conditions, supporting a huge set of programming languages and aggressive transformations by compilers. This talk explores how these debuggers work and how they fail.

Transparently storing compressed data on fast persistent storage like SSD and NVMe not only extends life and increases capacity of the device, it also significantly enhances I/O performance as seen by our exciting results.

Control-flow Enforcement Technology (CET) is a set of processor-based measures that combat prevailing, hard-to-detect exploits in buffer overflow and “instruction gadgets” used by malware.

Introduce the current status and the future of hibernation

This presentation will help you determine why stall warnings happen and what you can do about them.

Display Port Compliance requires that kernel drivers, hot-plug events, video modesetting and the userspace compositors/desktop environment all work together to handle a link failure. How did we achieve this in upstream Linux?

EFI + Intel TXT and TPM + Xen/Linux - how to make it work

As new kernel maintainers and developers work with a 25 year old code base, email2git helps them understand better the context in which code changes were made by linking those changes' Git commits back to their reviews. (slides)

The new feature from Intel called Intel Resource Director Technology brings a new way to monitor and control L3 cache allocations, but, Is this feature enough? or need an extra ingredient to create a good Quality of Service

Summarize the design and challenges in implementing end to end lossless compression in the graphics stack. (slides)

Redesigning the memory NUMA abstraction taking into account new memory technologies where inter node distance will no longer be the only deciding factor for memory allocation and placement. (slides)

What must Linux do for quantum computing and vice versa, and where is quantum computing most likely to succeed? (slides)

Recent hugetlbfs features and unique characteristics (slides)

Leveling the playing field: basic introduction to legal issues kernel developers talk about.

A summary of what has been happening on Graphics & Media to enable Android, ChromeOS and others to use more and more mainline features.

This talk will examine the role of the individual contributor to the kernel and its related ecosystem, examining the role of corporations and how individuals fit into the big picture.

How to debug the kernel in virtualized and cloud environments

The purpose of this talk is to describe status quo of the Live Kernel Patching implementation and identify future steps needed to improve the implementation (slides)

Extending the user/kernel ABI to cope with increasingly large and numerous CPU registers turns out to be non-trivial, yet CPU architectures are already evolving to require it. How do we minimise ABI breakage? (slides)

You thought you knew the licensing of the kernel? You don't! Join me to find out why.

We will talk about the challenges of designing and upstreaming an open-source Flash Translation Layer into the Linux Kernel.

This talk will discuss new performance analysis capabilities and tools using enhanced BPF, including scheduler, FS, and TCP analysis, beginning a new generation of advanced tools and visualizations. (slides)

There are still challenges facing Linux power management developers in both system-wide and working-state PM areas. (slides)

Discuss features and design of a fair, sleepable range reader/writer lock for the linux kernel. (slides)

Redesigning multipath taking into account modern kernel features and new technologies

A scalable mutex and rwsem design for large multicore machines.

Discussion about the open issues of the deadline scheduler. (slides)

An alternate to Overlay Networking solutions

A few years ago, things were "easy": There was gcc and binutils. Now we have gcc, clang, binutils, lld, and more. (slides)

This talk will describe flexible management of heterogeneous and multi-tiered memory systems that gives applications more say without complicating them. (slides)

Testing an operative systems is not easy, even more testing all the packages installed is a hard task. Let's test the system according its operation and not for the packages installed.

The trials and tribulations of being the maintainer of an obscure subsystem, why he feels he‘s a two-bit maintainer and what we, as a community, can do about that.

Tunnels are not so easily shared between network namespaces...

What factors might interfere with the kernel development community's future growth? (slides)

How much of the topology problem can we solve in user-space, allowing the kernel to remain simple and fast?

Throughput optimized futexes and kernel rw-semaphore reader optimistic spinning for better userspace and kernel locking performance.

In this talk Jarkko Sakkinen & Philip Tricca give overview and status report on current TPM2 software stack development from kernel to user space applications.

Find out precisely which source files were built and how by tracing a build to reconstruct a kernel build graph.

uNet's implementation required a novel approach to how a networking protocol interfaces with the kernel, userspace applications and configuration utilities.

A discussion of approaches to obtain contiguous memory in user space for DMA including a POSIX conformant mmap API (slides)

userfaultfd: current features and limitations and future development (slides)

In-depth comparison of kernel allocators for compressed pages in high load conditions, with some extra attention on z3fold and its optimizations.

Lots is happening with kernel documentation; here's a summary of where we are and how you can help.

xxwrqewf

A new interface for a new bread of User-mode filesystems that require extremely Low-Latency, synchronous, NUMA aware, DAX capable FileSystems. (slides)