As memory size and CPU counts increase on the largest systems, certain paths in the kernel that are single-threaded today are not scaling well and will become even bigger bottlenecks in the future. Examples include zeroing the biggest huge pages (e.g. 1G on x86), walking a process’s entire page table, and freeing large ranges of pages. These paths have been well optimized in one thread, so now it's a matter of scaling up the CPUs to match the amount of work to be done. One solution to this problem is ktask, a generic framework built on top of workqueues that takes care of splitting up a large task, starting a number of threads appropriate for the size of the task and the system, and load balancing the work between these threads. ktask uses internal limits to maintain an appropriate level of concurrency across the system. I want to get feedback on the overall approach and discuss similar scalability issues others are having in the kernel.

It's useful to have bots automatically test proposed patches and notify authors when they fail to compile in certain configurations. Currently for Clang, a few folks interested in supporting it email authors when patches break things, but regression finding is currently not automated for Clang. I'd like to pick some brains as to what is a smart way to automatically test proposed patches for a seemingly limitless number of kernel configurations.

For weak performance isolation with multi-tenancy for some applications by allowing space partitioning of CPUs, there is a need for applications to specify soft affinity to some CPUs. So that one "group" does not interfere with other "groups", yet allow the group to occupy the full set of CPUs when no one else is using it. Currently, CFS allows time sharing of CPUs and sched_setaffinity allows for "hard" affinity (or restricting CPUs to a given mask or set). One solution could be to to add a new cpumask other than cpus_allowed (which is used for "hard" affinity). Let's say cpus_preferred. And allow an application to set a preference to a set of CPUs if it so desires.

During a recent project I encountered an issue where I needed support for thermal zones that get instantiated by a devicetree overlay. In our specific case we had temperature sensors on a daughtercard that is swap-able. I haven't found a good solution on how to make the current of-thermal code work with runtime added thermal-zones, (assumption is all thermal zones present at boot) and was wondering if people have clever ideas.

Test driven development is a proven concept for user land projects, and is as far as I have seen to some extent used for kernel development, but is currently limited to what can be tested from user land, either via system call interfaces or by creating mock environments to compile selected kernel code in user land. Testing for instance kernel internal algorithms or usage of them, such as rbtrees, radix trees or sg lists cannot easily be done this way. Also, once the test is in kernel code, there are some very interesting low hanging opportunities such as for instance error injection and simple code coverage. I'd like to demonstrate a tool I created for this purpose, and that we develop and use internally in Oracle. It will be made available on Github for people to look at ahead of this unconference. I submitted a talk proposal for this, but it did not reach up, but I modestly think it is such a simple and good idea that I simply cannot wait yet another year without talking about it!

A unit test framework for the Linux kernel

Discussion on the possible value of adding unit tests to the kernel.

Tying TPMs into the EFI boot stub

Introduction

A quick update on syzkaller

I'll present KernelMemorySanitizer, a new tool for detecting uses of uninitialized values in the kernel. (slides)

Kernel ABI

Update from the BoF

Fuzzers Panel

Discussion on ways to improve ktest and how it is used

Share best practices for debugging BPF programs in production systems and discuss possible improvements.

The Linux scheduler has become fairly complex and is not always able to preserve work-conservation. We present Ipanema, a DSL to write simple and safe schedulers with proven properties. (slides)

TPM2 Software Stack: Retrospective and Future Work (slides)

status and next steps for crypto system integration of TPM 2.0

Open Discussion for issues not covered

Discussion on a recent proposal to change the PM core so that it can reuse runtime PM callbacks directly for system suspend/resume in some situations.

A brief overview of SVM on ARM. (slides)

Status report on virtio-iommu, introduction of extensions for vSVM: page table handover, PASID and fault reporting. (slides)

The lowmemorykiller was dropped from staging, so this will cover what will replace it.

Discussion on problems related to supporting NVMe surprise removal

lessons from using kprobe text based api and proposed extensions

Discussion around changes made to Android and to the tests / requirements as part of Project Treble (slides)

A quick overview of Android common and LTS testing efforts. (slides)

Talk about how we want to deal with trace points as a user space interface

Report PCIe error statistics via sysfs

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

Introduction to the Android Microconference

A description of SDCardfs and the plans to upstream it. (slides)

A talk on compiling the Linux kernel with Clang/LLVM. (slides)

What's been done over the past year, and what's still needed?

A historical perspective and future outlook of the Android emulator and upstream QEMU and their differences. (slides)

Focused Efforts around LTS (slides)

How to selectively allow privileged actions from otherwise unprivileged containers? (slides)

An update on shiftfs and the next steps for remapping overlay filesystems.

The usual introduction talk

Status update on the PCI Endpoint Framework and next set of challenges (slides)

Describes current efforts to replace the out-of-tree Android xt_qtaguid kernel code with an upstream solution based on eBPF cgroup filters. (slides)

Energy Aware scheduler development (slides)

What is Ion in 2017 (slides)

Reworking the IPI logic to implement the RT (and deadline) scheduler for push/pull logic

The potential difference in max and delivered CPU performance (capacity) is growing (thermal and peak current management), can we keep ignoring it, or should load-balancing factor the constraints in?

Describes current efforts to replace the out-of-tree Android xt_qtaguid kernel code with an upstream solution based on eBPF cgroup filters. (slides)

Binder performance enhancements in 'Oreo' to support Treble (slides)

Recent and future developments on devboards supported in AOSP. (slides)

Open Discussion

Discussion on which workloads to use (or what is recommended etc) for the evaluation of CPU PM changes in the kernel.

CGroup V2 is pretty different from CGroup V1 and the two can't fully operate in parallel leading to problems running containers which only support one or the other.

Correlate traces from ebpf, perf and LTTng of large systems using the Trace Compass tool

overview and discussion of uftrace tracing both user and kernel space

Let's put RoCE in containers

Presentation of upcoming Common Trace Format (CTF) 2.0, discussion of use-cases. (slides)

Improving event tracing, post-processing tools and scheduler models. (slides)

Discuss about using CTF to do BPF introspection

Quick discussion of future BPF analysis tools

Briefing the preliminary dyninst based study, and then discussions.

Review of a possible alternative solution to the "decay-clamp" idea.

Discussion on the proposal for a per-task API to bias OPP selection.

Syncless technique for tracing virtual machine on any layer (nested too) (slides)

Making Linux Security Modules available to containers. (slides)

distributed checkpoint restart protocols

Kernel-assisted trace re-construction for JITed code

user stack trace to name resolution is hard. Thankfully kernel can help

Discuss simple userspace daemon for placing tasks in heterogenous CPU systems

schedutil usage/aggregation of utilization signals

IPsec crypto offload using flow steering verbs

How to achieve or make operations in OSPM atomic for CPU frequency scaling using platform firmware interface on ARM platforms ? (slides)

Update on CPU cluster idling

A highlight of the recent changes made to genpd and an update of ongoing/next developments.

One PD to rule them all

Give flexibility to users to register memory

The talk is about our experience at CRIU with testing C/R technology.

How to integrate P.Haul with Docker and how to fix criu pre-dump. (slides)

RDMA and ULPs

Discuss IOMMU changes needed for supporting guest use of shared virtual memory (SVM) (slides)

Review vSVM requirements, use cases and technical challenges (slides)

Talk about ways to make using BPF less awful for non-kernel hackers.

Discuss the various ways BPF can be used to categorize workloads and use it to build generic workload simulators.

Check for power/perf regressions.

Simulate workloads with rt-app

Introduction to the problem of cgroup limits visibility to userspace and the approach taken by LXCFS. (slides)

Improving JVM migration and profiling by comibing C/R with internal JVM knowledge/techniques. (slides)

Discuss boot-time issues with the RDMA subsystem

Maximum payload size vs. Maximum Read Request Size (slides)

More and more devices in RDMA are dependent on netdev as well as other subsystems -- target, NFS, scsi, block, cgroups, SELinux.... Can we make backporting task for distro people easier ?

Going forward with a flexible and secure RDMA kABI

Connection information through RDMAtool

Exposure of various device counters through rdmatool

Configuration Request Retry Status (CRS) (slides)

Open Fabrics Alliance - Status and New Directions

QEMU's limited RDMA support leaves it behind other modern hypervisors. Marcel and/or Yuval will present the implementation of an emulated RDMA device, analyze its performance and usability, and finally talk about future plans for a possible virtio-rdma device. (slides)

Lets try to avoid using specialized tools and APIs for the RDMA stack and try to support the Linux network tools and APIs as much as possible.

Can LXC be used to run OCI application container images? (slides)

This talk presents AppSwitch, a completely new TCP-layer network element similar to a router at IP layer or a bridge at link layer, that addresses a number of issues in modern environments, especially ones based on microservices.

Discuss usage of userfaultfd-WP for iterative container migration (slides)

This talk will present the Popcorn Linux infrastructure, composed of compiler/operating system/virtualization support to enable application and thread migration across cores or machines of different Instruction-Set-Architecture.

Current status of namespacing of the Linux Integrity Measurement Architecture

Status report of high-level PM frameworks in the Linux kernel.

Discussion on throttling only processes, which are causing thermal issues

In this talk we will present current roadblocks to a more defensive design that affect all container runtimes.

Get LKMM installed and make use of it! (slides)

Quick overview of Linux kernel memory model: How to install and use (slides)