Implementing Linux RDMA provider software for a new device from scratch

New IOCTL ABI and issues related

RDMA User-space Consolidation: Update and Future projects discussion

Chase that bug …

Integrating functionality for GPUs, network, PCI devices

1 hour lunch break

Using Containers with RDMA devices

New network technologies (fabrics, NICs and even APIs) have recently surfaced.

RDMA Roadmap and Interoperability Testing

Support for richer offloads in the Verbs API

Current and Future Licensing Approach to the RDMA Subsystem Codebase

Introduction to the micro-conference

Update on the past year of LXC, LXCFS and LXD development

A quick update on where we are, where we want to go and which major issues we’re facing with clear containers.

an overview of new stuff in OpenVZ 7

Learn how runc and ocitools make it easy to run containers

An update on the past year’s work in the rkt container runtime

The new cgroupv2 API: getting more consistent and more well organized.

Update on file capabilities in containers

State of the kernel support for containers

Loosely based on Dinesh Subhraveti’s PhD thesis, the vPlay system enables the minimal runtime state of the container to be captured such that when restored, application would retrace its execution for a specified time interval. The key observation is that during the last moments of an application crash, where the root cause typically lies, the application only accesses a small subset of its address space and only those pages need to be saved. The technique, dubbed partial checkpointing, is combined with logging to be used for debugging. Because all interactions of the application with the kernel are logged, the execution can be natively replayed even on BSD or Windows.

Open discussion on a number of current topics

Introduce agenda and people

A discussion about the revived Device Tree validation via shemas.

Where should configuration and policy information be located; devicetree or elsewhere?

Ask questions about and make suggestions regarding overlays, connectors, plugins, overlay managers

Review of recently added debug tools. Discussion of what additional tools would be useful.

Introduction to the problem space of using programmable logic in general purpose datacenter and embedded environments

Existing and emerging mechanisms for enumerating FPGAs

Configuring and using FPGAs and programmable devices through assignment

Orchestration and provisioning of FPGAs and programmable logic devices

Identifying target use cases of focus for future work on FPGAs

An update on the current development of the fpga mgr framework

Open floor discussion of next steps for collaboration

Summarize and discuss obstacles when enabling Livepatch support on different architectures.

Brainstorming about save modification of data structures used by the patched functions.

Live Patching: prioritizing next steps in upstream codebase

This talk covers areas of improvements to help livepatching be widely adopted and used

Explore the pros and cons of enforcing hard module dependencies for patch modules.

Compare the different tools and approaches used for livepatch module creation and try to come up with common in-tree tooling to support it.

Describe one of the livepatch limitations – patching of scheduler functions – and try to come up with a feasible solution.

Describe different GCC optimizations which have certain impact on kernel live patching.

Summarize recent advances in CPUFreq development and discuss the next steps.

Overview of kernel energy model proposal and its related DT bindings to describe energy model parameters.

Discuss some limitations of PELT, their impact and how to improve the situation.

Using the scheduler’s ASYM_PACKING feature for the handling of cores with different maximum turbo frequencies

Unifying idle management for CPUs, clusters and IO devices

Why forced idle? Update and explore idle injection methods in Linux

Discussion on enabling per-task tuning of kernel policies using a well defined user-space interface

Describe and discuss the current status of the PM infrastructure in the Linux kernel.

Provide an overview of current kernel test efforts

Making syzkaller even more efficient

Trinity: Next directions.

Experiences gained while fuzzing the complex perf_event_open() system call.

Learn how we overcame the practical and computational limitations of mutation testing to identify real problems in projects as complex as the Kernel, and how you too can adopt this technique.

Linux may soon have linker table support, where did this come from and what does this mean?

Collecting, running and contributing kernel tests is still a challenge

Very quick review of Android items in staging

Summary of experiences with deploying EAS on Android

SchedTune and SCHED_DEADLINE utility for Android

Overview of the background updates feature in Android N

Status of the vDSO on arm64 and the proposed addition of a 32-bit vDSO.

A hands on session explaining behavioral analysis in the kernel and the tooling built around it. The eventual goal is to have “behaviors” defined for a wide range of sub-systems in the Linux kernel.

New ION heap for large pages to reduce device TLB

Discussion of the progress to move Ion out of staging

Cover a brief history of the drm_hwcomposer library, an overview of the code, composition strategies, basic pointers to running Android on
DRM/KMS, and future direction.

Update on the effort to add Explicit Fencing to mainline kernel using the Android Sync Framework as a base.

Brillo’s always-on-latest-LTS kernel plan

Overview and discussion on OPTEE and Trusty

Discussion on Linaro’s and other’s HAL unification/consolidation/dynamic-modularization work along with single kernel/single user-space efforts.

Lightning talk on HiKey in AOSP, and what its been useful for

The android.system package lets you do things you used to have to turn to native code for, without giving up the benefits of a managed runtime.

AOSP’s switch to Clang based toolchains

State of the Git Union

Git Series Discussion

We’ve all written umpteen Git scripts. Any standardization on the horizon?

Let’s make sure Git development is useful!

Some scripting to obtain token-level git blame results.

Introduction

Introduction to the IBM TSS 2.0 stack

Introduction to the Intel TSS 2.0 stack

A description of Google’s TPM stack and components

How can we make it easier to seal secrets to TPMs?

Standardizing Device Tree bindings for TPM, thereby enabling a defacto mechanism for DT based platforms.

Discussion around MSI generation and routing for devices passed through to KVM guests on arm64 machines.

Discussion around direct injection of MSIs into KVM guests on arm64

Discuss current issues in PCIIOMMU interaction.

New resource ALT allocation (small size than alignment)
and test module for pci resource allocation.

Discuss and draft a plan to consolidate PCI
resources (memory, IO, IRQs) management across architectures.

PCIe domains re-enumeration

Support for configurable PCIe endpoint

Discussion on use-cases facilitated by combining trace buffering (e.g. Ftrace, Perf, LTTng) and live aggregation (e.g. eBPF, SystemTAP) technologies.

Adding a trace-cmd server for guests and remote machines

This talk will cover kernelscope, a tool we use inside of Facebook to debug complex problems.

New approach to fast user space tracing with a help of the kernel

Discuss and learn about the way BCC uses clang’s rewrite functionality to create valid bpf programs, and how to improve support to create a better tracer.

Executing efficient checkpoint/restart for distributed applications

In this presentation, we will talk about some of the open challenges in checkpointing.

Few words about why current restorer sucks and how to make it work better.

Decrease downtime during process migration using userfaultfd to restore memory pages on demand.

In this talk I’ll cover the ways we use checkpoint restore in LXD, as well as some challenges we face.

Why CRIU can’t dump any set of processes

Missing pieces for full ARM/AArch64 support and new use cases from ARM work hopefully worth sharing across all architectures