Introduction

TPM2 Software Stack: Retrospective and Future Work

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

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

Tying TPMs into the EFI boot stub

status and next steps for crypto system integration of TPM 2.0

The usual introduction talk

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

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.

Making Linux Security Modules available to containers.

Can LXC be used to run OCI application container images?

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.

Current status of namespacing of the Linux Integrity Measurement Architecture

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

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

How to selectively allow privileged actions from otherwise unprivileged containers?

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?

schedutil usage/aggregation of utilization signals

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

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

Discuss simple userspace daemon for placing tasks in heterogenous CPU systems

Discussion on throttling only processes, which are causing thermal issues

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

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.

Update on CPU cluster idling

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

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

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

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.

Discuss boot-time issues with the RDMA subsystem

Open Fabrics Alliance – Status and New Directions

Open Discussion

Introduction to the Android Microconference

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

Focused Efforts around LTS

A quick overview of Android common and LTS testing efforts.

Recent and future developments on devboards supported in AOSP.

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

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

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

Binder performance enhancements in ‘Oreo’ to support Treble

Energy Aware scheduler development

What is Ion in 2017

A description of SDCardfs and the plans to upstream it.

Open Discussion for issues not covered

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.

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

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

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

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.

Review vSVM requirements, use cases and technical challenges

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

A brief overview of SVM on ARM.

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

Report PCIe error statistics via sysfs

Configuration Request Retry Status (CRS)

Maximum payload size vs. Maximum Read Request Size

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

Discussion on problems related to supporting NVMe surprise removal

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

Get LKMM installed and make use of it!

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.

A quick update on syzkaller

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

A unit test framework for the Linux 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.

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.

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.

distributed checkpoint restart protocols

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

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.

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

Discuss usage of userfaultfd-WP for iterative container migration

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

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

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

Kernel-assisted trace re-construction for JITed code

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

Briefing the preliminary dyninst based study, and then discussions.

Quick discussion of future BPF analysis tools

Discuss about using CTF to do BPF introspection

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

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

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

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

lessons from using kprobe text based api and proposed extensions

overview and discussion of uftrace tracing both user and kernel space

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!

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.