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

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

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

Discussion on throttling only processes, which are causing thermal issues

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

Current status of namespacing of the Linux Integrity Measurement Architecture

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.

Discuss usage of userfaultfd-WP for iterative container migration (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.

Can LXC be used to run OCI application container images? (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.

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)

Open Fabrics Alliance - Status and New Directions

Configuration Request Retry Status (CRS) (slides)

Exposure of various device counters through rdmatool

Connection information through RDMAtool

Going forward with a flexible and secure RDMA kABI

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 ?

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

Discuss boot-time issues with the RDMA subsystem

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

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

Simulate workloads with rt-app

Check for power/perf regressions.

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

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

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

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

RDMA and ULPs

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

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

Give flexibility to users to register memory

One PD to rule them all

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

Update on CPU cluster idling

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

IPsec crypto offload using flow steering verbs

schedutil usage/aggregation of utilization signals

Discuss simple userspace daemon for placing tasks in heterogenous CPU systems

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

Kernel-assisted trace re-construction for JITed code

distributed checkpoint restart protocols

Making Linux Security Modules available to containers. (slides)

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

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

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

Briefing the preliminary dyninst based study, and then discussions.

Quick discussion of future BPF analysis tools

Discuss about using CTF to do BPF introspection

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

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

Let's put RoCE in containers

overview and discussion of uftrace tracing both user and kernel space

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

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.

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

Open Discussion

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

Binder performance enhancements in 'Oreo' to support Treble (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)

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?

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

What is Ion in 2017 (slides)

Energy Aware scheduler development (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)

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

The usual introduction talk

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

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

Focused Efforts around LTS (slides)

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

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

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

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

Introduction to the Android Microconference

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

Report PCIe error statistics via sysfs

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

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

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

lessons from using kprobe text based api and proposed extensions

Discussion on problems related to supporting NVMe surprise removal

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

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

A brief overview of SVM on ARM. (slides)

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.

Open Discussion for issues not covered

status and next steps for crypto system integration of TPM 2.0

TPM2 Software Stack: Retrospective and Future Work (slides)

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)

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

Discussion on ways to improve ktest and how it is used

Fuzzers Panel

Update from the BoF

Kernel ABI

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

A quick update on syzkaller

Introduction

Tying TPMs into the EFI boot stub

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

A unit test framework for the Linux kernel

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!

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.

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.

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.

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.