Open Source Summit + Automotive Linux Summit Japan 2019

Linux kernel is the default choice for Cloud, Enterprise, Embedded, and many others.
LTSI had been established to find the Long Term way how to use Linux by the advocacy of using LTS version. By such activities, many companies are using LTS which is great. However, does it solve all the problem?

I will try to present kernel development statistics at first and then cover the rest of the problem such as testing Linux, community governance, Legal/Political and so on. Also, part of the activities to solve such a problem will be discussed.

You may be a Linux Kernel Maintainer, resulting from your contributions to the kernel, or you may want to become a Maintainer. This presentation will address
- how do you become a maintainer without knowing it?
- how do you become a maintainer on purpose?
- what are your roles and responsibilities?
- how do you fulfill those roles?
- what will make you a good maintainer?
- what resources are available to assist you?

In mission critical systems unscheduled downtimes must be avoided, but sometimes critical flaws in the kernel must be plugged as soon as possible.

Live patch is a way of changing the kernel internals without rebooting the system by redirecting the code execution.

The main motivation behind elivepatch is to provide an open source live patch build service, that works with any distributions, also in cases where distributions have no unified kernel across the user base (everybody has different GCC versions, different configs, etc) like for example with Gentoo.
Elivepatch is an open source service and is currently looking for users and feedback. The service is based on kpatch-build.

I will show the current progress on build reproducibility, security, and portability. I will also talk about what is still needed to be done.

Jitterdebugger is a new tool for testing the preempt_rt real time extensions for the Linux kernel. While the basic principles for this endeavour (run a cyclic task on one or more CPUs, and store the measured latencies) seem very straightforward at a first glance, the devil is in the details -- in particular, if evaluations beyond computing simple descriptive results should take place, and if machines and systems are subjected to systematic testing over long periods of time.
The talk starts with an introduction to architecture and usage of the jitterdebugger tool, and will (of course) also address the question how it differs from the cyclictest tool suite. We will then discuss archival strategies for keeping recorded data reproducible in the long run (a non-trivial problem!), and discuss several types of statistical evaluation that are made possible by jitterdebugger's new capabilities.

Application whitelisting is a technology that allows only applications that are explicitly listed in a whitelist to be executed on a computer system. We have implemented two versions of application whitelisting, one requiring system call interception and kernel modification, and the other requiring only SMACK rule configuration and user-level programming. In this talk, we will detail the SMACK-based application whitelisting implementation, and compare these two implementations in terms of their functionalities, system stability, development efforts, and run-time performance overheads.

Cameras are complex devices that need heavy hardware image processing. Control of the processing is based on software algorithms that have traditionally been implemented inside the camera. The industry increasingly moves those algorithms to the main CPU to save cost. Blurring the boundary between camera devices and Linux often left the user with no other option than, at best, a vendor-specific closed-source solution.

To address this problem the V4L2 community is collaborating with industry leaders to develop libcamera, a camera stack that is open-source-friendly while still protecting vendor core IP.

This talk will examine the libcamera architecture, and how it applies to all Linux systems. We will look at how vendors and developers can use the stack to their advantage, the areas they can contribute to, the benefits the stack will bring to them, and how they can influence the design.

Compact C Type Format (CTF) is a reduced form of debugging information whose main purpose is to describe the type of C entities such as structures, unions, typedefs and function arguments. It originated in the Solaris kernel and it has been ported to Linux as part of the DTrace for Linux project. It's been used (via libdtrace-ctf) to reduce the size of the debugging information for the Linux kernel and for use in DTrace.

There are many advantages to using CTF, due to its compactness, for many kinds of programs that can't rely on DWARF. DWARF's design strives for generality and expressive power, at the cost of being a rather heavy format. For example, evaluating DWARF expressions requires an interpreter for a stack-based machine. This, which is not problematic for typical "off-line" debugging programs such as symbolic debuggers (GDB), may be inconvenient for "on-line" debugging programs such as
unwinders and stack tracers, due to efficiency and security concerns. CTF is a promising format that helps maintain some level of debuggability, even when the size of the executable is an issue and the DWARF info is being stripped out.

For such reasons, we integrated CTF with the GNU toolchain on Linux. This talk will explain how CTF is structured, how we added CTF generation capabilities to gcc, how GDB consumes the CTF information and how binutils and elfutils have been extended to process this new format.

We believe CTF provides the right foundations for expressing the information needed by "on-line" debugging programs, in a most convenient way.

Real-time applications need to satisfy timing constraints, and we have to avoid kernel changes which might cause long delays. But we need tons of time for testing to detect those issues. So, it is the reason why we use automated testing frameworks.

We presented our test with “Fuego” in ELCE2018, which not only measures performance but also traces for detecting what cases delay. Now, we have developed Functional-test run-time logger to get clues to detect internal problem even if all of the test’s results is success. In this presentation we will share the detail of the run-time logger with showing our actual use case.

The Linux kernel contains a great deal of documentation, but it has not always been as well cared for as we might like.  In recent years a lot of work has been done to improve our documentation, including the adoption of a new, Sphinx-based toolchain.  This talk from the kernel documentation maintainer will cover what has been done to improve our docs and what is yet to come.

Webauthn is the latest standard for secure, scalable, passwordless authentication on the web. This talk will describe the protocol from the point of view of the Browser and Authenticator, not the Relying Party (so we won't cover how to build a webauthn enabled website, we will cover how to get a Linux laptop with a TPM to be able to take advantage securely of webauthn enabled websites). In the next part of this talk we'll give an overview of Linux USB gadgets and how they work (from the point of view of people wanting to use them, so no kernel internals experience necessary) and Finally we'll describe how to build a webauthn authenticator "token" using the Linux HID Gadget and TPM version 2. The source code for this project is available at https://git.kernel.org/pub/scm/linux/kernel/git/jejb/fido2-ctap-gadget.git/.

The Isar build system generates Debian images, primarily from binaries, for direct use in embedded devices. In this talk, we will walk through typical patterns for modeling real-world scenarios, in industrial device developments, for the Civil Infrastructure Platform or similar reusable base layers, and in demonstration and test images. Among the covered topics are typical customizations like own kernels or boot procedures, package patching, image descriptions, modeling commonalities and configuration management. We would like to share experiences from using Isar for products and open source projects over the past 2 years.

Nowadays security incident is increasing more and more. Then lots of vendor/community/institute are making efforts to find vulnerability on software. Not only commercial software, but also OSS is having a vulnerability (remember HeartBleed, DirtyCow, and so on). Then lots of security researchers are reporting vulnerability and publish it with CVE-ids which is assigned by MITRE.

In this LightningTalk, Kazuki Omo will report recently trends of OSS CVE from 2017 to 2019. Also, show some typical vulnerability PoC, then tell how you can protect those vulnerabilities by using OSS product/solution.

There's no doubt that Linux has always been played very well, especially in a variety of embedded system. But we put Linux into the context of IoT, things is different.  Mostly we run IoT edge systems across the safety-critical infrastructures, where on the one hand we should deliver responsibility in real time, and on the other hand, we have to consider safety and security at the same time.  So here we'd like to explore how to construct a safety, security and real time Linux, and also introduce some efforts from SIL2LinuxMP. Finally, our goal is to provide a common open framework to address different scenarios by extending and enabling some existing technologies:

• 1. Linuxkit
• 2. Preempt-RT patchset
• 3. Container as a VM
• 4. hardware features like SGX
• 5. Unikernel-based VM
• 6. EdgeX

Linux event polling (epoll) is quite a common way to do IO event notification, mainly due to its performance advantages over poll/select; despite some fundamental design issues, requiring careful programming to overcome them. This talk will illustrate, at a kernel level, some of the epoll architecture along with recent upstream changes that improve performance in different workloads. This will also cover some experimental patches that have been discussed in the past and could furthermore improve internal performance and scalability of epoll. In addition, new benchmarking tools and infrastructure will be shown, hoping that performance can get better coverage in the future and inviting future contributions.

Building an embedded Linux platform is like a puzzle; placing the suitable software components in the right positions will constitute an optimal platform. However, selecting suitable components is difficult since it depends on different application scenarios. The basic components of an embedded Linux platform include the bootloader, Linux kernel, toolchain, root filesystem, it also needs the tools for image generation, upgrade, and testing. There are abundant resources in the Linux ecosystem with these components and tools; however, selecting the suitable modules and tools is still a key challenge for system designers.

In this presentation, SZ Lin will analyze the features in each component and compare common open source software with each tool. In addition, he will also share the experiences in selecting each component and tools for industrial-grade embedded Linux platform.

With the increasing momentum of embedded devices getting smarter and always connected, it is prevalent to see that more and more industrial automation manufacturers (Siemens, Beckhoff, Inovance, etc) are combining multiple platforms (PLC, HMI, MC, Robotics, etc) into the single products. The virtualization is the key technologies to empower such kind of workload consolidation. However, one of the challenges is its strict Real-Time requirements. Some of the products need the Real-Time task’s scheduling latency to be less than 30us or even less. The traditional virtualization solution is unable to hard to achieve the Real-Time requirements above. For example, the KVM is only able to achieve 100us-level scheduling latency. This talk will present those challenges and how ARCN Real-time is designed to overcome those challenges and meet the industrial-grade Real-Time performance.

When it comes to Linux real time (RT), we have only two options today - PREEMPT_RT and XENOMAI. However it is still hard to choose one.

This talk is about designing a RT based hardware prototype model purely based on Linux and integrated with Xenomai RT capabilities. It also has an in-built intelligence for detecting sudden obstacle on its path and taking immediate action. The movement of this two-wheeler rover can also be controlled by using any Android Smart Phone and a light-weight framework built with Xenomai skin. This session will also demonstrate how Xenomai could be useful in improving the response time of the system (compared to normal Linux) during sudden obstacle detection, even on a heavy loaded system.

This presentation will end by sharing some of the pain-points (as a developer) in integrating Xenomai with Linux, along with some ideas onboard in improving the Xenomai ecosystem.

Non-Volatile DIMM(NVDIMM) is expected to be a next generation memory. It can be accessed by a cpu directly and its data can remain when electrical power is removed. In-Memory Database will be a good example of NVDIMM.
Many people have been making great efforts on Linux, NVDIMM drivers, filesystems, and management command, and many libraries have been well developed for a few years.
However, there are several issues on RAS of NVDIMM to solve. For example, NVDIMM does not have a feature to save its data when it becomes physically damaged. Users are need to know when is the proper time to backup the data and do the replacement.
In this presentation, I will talk about the basis of NVDIMM, how to make a good use of NVDIMM for enterprise, and features what would be developed for enterprise.

The problem with most of the monitoring systems and tools today is that they identify symptoms of the problem like a high cpu utilization but are unable to tell the cause. This leads to visible problems in conducting a proper root cause analysis of the problem. In the session we talk about a low level Linux kernel tracing mechanism called ebpf and how it can be used to perform fine grained monitoring of the systems we run. We take an example of a production database and how with very low overhead, metrics like performance of the block layer like block latency, build up of process queues or network congestion/packet drops can be detected. We also talk of generating flame graphs on the fly which can show the hot code on and off cpu. The talk also will entail some other tools like perf and how they can be used to provide microscopic view of systems and applications.