Open Source Summit Europe 2024

In this session, we're going to talk about how we can easily record the API calls of any user-level application at Kernel using an EBPF program and convert those to realistic test cases and data mocks/stubs without writing any scripts. How we can set our testing pipelines on auto-pilot? We'll be discussing how to utilise UProbes and KProbes for the same. We'll also talk about how we can integrate this pipeline in popular language native testing libraries like JUnit, Jest, and Go-Test and easily achieve high test coverage on functional test suites. Since testing is very use-case specific, developers often avoid spending effort in writing test cases. Manual effort is being spent by QA to test apps and the industry standard for test automation is 24%. On average 50% of engineering efforts are spent to write and maintain the test scripts. Creating dummy test data is also very time-consuming and still, it is unrealistic test -data, leaving bugs leaking to production. The new-gen AI LLM-based test generation tools like ChatGPT are not fire-and-forget, since it requires effort to understand and correct the scripts generated by those tools and the dummy data is again unrealistic.

The C runtime offers a range of string processing routines, such as strcmp() and strlen(). The throughput of these routines has a significant impact on many applications and benchmarks, so they are one of the many optimization targets of toolchain developers. Unfortunately, these functions have certain properties and corner cases that limit the optimization opportunities. This talk makes a journey through common optimization techniques ranging from utilization of alignment information in the compiler. It ends with specific instructions that speed up string processing (RISC-V’s orc.b instruction). Further, the talk will show how these optimizations can boost the throughput on real HW by orders of magnitudes in synthetic benchmarks and the impact on the SPEC CPU 2017 benchmark suite. The presentation will include assembly listings, so basic assembly knowledge will help follow the talk.

The year 2038 problem is a well known integer overflow issue on many 32 bit platforms, some of which will be still in use on the day when it happens: January 19 2038. In this talk I would like to present where the problem comes from, what the Yocto project has done to address the issue, which base work in kernel and libc has been utilized to avoid a total system collapse, how to test a system's readiness for that date, and which further issues this has uncovered in common open source components. I hope this prompts an interesting discussion and further ideas to ensure the world does not go down in 14 years.

his presentation will focus on CXL (Compute Express Link) as an advanced interconnect between machines and peripherals. CXL allows to leverage the PCIe physical interconnect to link together different device types (CPU, memory, I/O, cache, switches etc) into a combined hierarchy. This allows IHVs to create tailored solutions for eg large-scale AI systems or dynamic resource pooling between machines. As it's also possible to connect or pool memory resources it means the we can end up with some really interesting NUMA topologies. Plus we need to look at memory placement, as CXL memory is inherently hotpluggable, and as such not really suitable for some data structures like DMA areas etc. In this talk I will give an overview over CXL and the implications for NUMA topologies, and I'll be giving a short demo with an emulated CXL instance under qemu.

Come learn about the great accomplishments of our Outreachy Linux Kernel Interns! Outreachy offers open source internships to people subject to systemic bias and impacted by under-representation in the technical industry where they are living. Julia Lawall offers an overview of the Outreachy Linux Kernel Community followed by intern presentations showcasing their projects and experiences: * Dorcas Litunya: Improving support for the Vivid Test Driver * Khadija Kamran: Analyzing Linux Kernel Security Subsystems * Tahera Fahimi: Improving Landlock Access Control Linux Kernel Maintainer Hans Verkuil wraps up the panel by sharing his experience as an Outreachy mentor.

Implementing Type-C support in Linux is not a simple task, platforms implementers have to understand different pieces of the Type-C stack (and various USB standards). This talk provides overview of the Linux USB-C subsystem and its different parts, basing on my experience with implementing and improving USB-C support for different Qualcomm platforms.

The PCI Endpoint framework enables the Linux kernel to act as a PCI Endpoint device. It allows software to describe the behavior of a PCIe function, which is a logical unit within a PCI device. This session will present the design and implementation of a virtio-net device using this framework.　Virtio is a para-virtualization framework designed to improve the efficiency of device I/O operations in virtualized environments. It enables software to emulate device behavior, leading to efficient data transfers in this case.　This session will discuss the architecture and current status of the proposed virtio-net PCI function driver based on the PCI endpoint framework. Additionally, it will introduce an API for controlling virtio virtqueues, which are used for data transfer. This API is generic and can be used to implement PCI Endpoint devices for other virtio devices.

In recent years, the Rust programming language has gained popularity for its ability to provide safety guarantees for concurrent code, making it an ideal choice for developers looking to create secure open source products. However, while Rust offers robust features to prevent common programming errors and vulnerabilities, developers still play a crucial role in ensuring the correctness of their code. This presentation will explore the safety guarantees of Rust for concurrent async code and discuss how developers can take ownership of writing secure and correct code. Key Points: 1. Overview of Rust's safety guarantees for concurrent code 2. Understanding the role of developers in ensuring code correctness 3. Best practices for writing secure Rust code 4. Challenges and limitations of using Rust for developing secure software Overall, this presentation aims to educate attendees on the benefits and challenges of using Rust for developing secure products. By empowering developers to take charge of writing correct code, we can collectively contribute to a safer and more reliable digital ecosystem.

Conference attendees to Till: Printing works better than under Windows or Mac! Michael Tunnell, TuxDigital, says in one of his videos: There is no such thing like a pain-free experience of printing under Windows ... Linux printing is ridiculously good ... Till Kamppeter, leader of the OpenPrinting project, and fellow of the Linux Foundation, will give an overview of his work. Going through OpenPrinting's history the components of the printing infrastructure of modern Linux (and other Posix-style) operating systems will get shown. - How did the Internet Printing Protocol (IPP) with the printing system CUPS being an implementation of it simplify printing a lot? - The printer driver challenge, good and bad cooperation with manufacturers, packaging and distributing ... - Desktop integration, GUI toolkits, print dialogs, setup tools, portals, ... Especially also the New Architecture of all-IPP printing and scanning and also the integration in immutable OS distributions will be treated ...

Application Binary Interface (ABI), in contrast to the more often heard Application Programming Interface (API), is not as widely discussed, but is every bit as important as the latter. It is what allows us to run programs that are compiled 10 years ago on the latest system, and still expect it to work. In this talk, we will introduce the audience to the concept of ABI, explain its difference from API, and and lay out what exactly breaks ABI, as well as cover the symptoms of such breakage. Further more, we will detail how ABI breakage can be detected or prevented, and discuss some specific cases: Linux Kernel's ABI, Python's stable ABI, and Foreign Function Interface.