Kernel Recipes 2016 - kernelci.org: 1.5 million kernel boots (and counting)

Rust promises developers the execution speed of non-managed languages like C++, with the safety guarantees of managed languages like Go. Its fast rise in popularity shows this promise has been largely upheld. However, the situation is a bit muddier for the newer asynchronous extensions. This talk will explore some of the pitfalls that users may face while developing asynchronous Rust applications that have direct consequences in their ability to hit that sweet low p99. We will see how the Glommio asynchronous executor tries to deal with some of those problems, and what the future holds.

From printk to QEMU: Xen/Linux Kernel debugging

The Linux Foundation

Current experience shows that a lot of developers working on Xen/Linux kernel use mainly only small set of debugging tools. Often they are sufficient for generic work. However, when unusual problem arises which could not be easily debugged using known tools sometimes they are trying to reinvent the wheel. Goal of this session is to present wide range of debugging tools starting from simplest one to most feature reach solutions in context of Xen/Linux kernel debugging. It will describe pros and cons of printk (serial, debug console, etc.), gdb, gdbsx, kgdb, QEMU, kdump and others. Additionally, there will be some information about possible new solutions and current kexec/kdump developments for Xen.

Linux Locking Mechanisms

Kernel TLV

High-Performance Networking Using eBPF, XDP, and io_uring

In the networking world there are a number of ways to increase performance over naive use of basic Berkeley sockets. These techniques have ranged from polling blocking sockets, non-blocking sockets controlled by Epoll, all the way through completely bypassing the Linux kernel for maximum network performance where you talk directly to the network interface card by using something like DPDK or Netmap. All these tools have their place, and generally occupy a space from convenience to performance. But in recent years, that landscape has changed massively.. The tools available to the average Linux systems developer have improved from the creation of io_uring, to the expansion of bpf from a simple filtering language to a full-on programming environment embedded directly in the kernel. Along with that came something called XDP (express datapath). This was Linux kernel's answer to kernel-bypass networking. AF_XDP is the new socket type created by this feature, and generally works very similarly to something like DPDK. History lessons out of the way, this talk will look into, and discuss the merits of this technology, it's place in the broader ecosystem and how it can be used to attain the highest level of performance possible. This talk will dive into crucial details, such as how AF_XDP works, how it can be integrated into a larger system and finally more advanced topics such as request sharding/load balancing. There will be detailed look at the design of AF_XDP, the eBpf code used, as well as the userspace code required to drive it all. It will also include performance numbers from this setup compared to regular kernel networking. And most importantly how to put all this together to handle as much data as possible on a single modern multi-core system.

What is special about community-industry collaboration around an open architecture like RISC-V is that the community can join development around key kernel subsystems in parallel with the semiconductor companies and manufacturers as they are producing the new chipsets and boards. Open silicon design, open board design, and open kernel software speeds bring-up of new boards and fosters greater innovation due to the diversity of talent contributing to the technology. For many kernel developers, tackling RISC-V is becoming harder to resist now that commercially viable and scalable hardware has begun to enter the market. A private beta program launched by the BeagleBoard Foundation in March 2021 placed an affordable, yet powerful prototype RISC-V board into the hands of Roman Shaposhnik. What did Roman do? He joined a diverse team of software and hardware hackers to tackle bringing up Linux on the new board. In this talk, Roman will tell you about his experience porting Alpine Linux and LF Edge EVE-OS to the new RISC-V architecture.

Kernel Recipes 2017 - Build farm again - Willy Tarreau

Kernel Recipes 2016 -

Vanquishing Latency Outliers in the Lightbits LightOS Software Defined Storag...

Linux rt in financial markets

Adrien Mahieux

Whoops! I Rewrote It in Rust

Three engineers, at various points, each take their own approach adding Rust to a C codebase, each being more and more ambitious. I initially just wanted to replace the server’s networking and event loop with an equally fast Rust implementation. We’d reuse many core components that were in C and just call into them from Rust. Surely it wouldn’t be that much code… Pelikan is Twitter’s open source and modular framework for in-memory caching, allowing us to replace Memcached and Redis forks with a single codebase and achieve better performance. At Twitter, we operate hundreds of cache clusters storing hundreds of terabytes of small objects in memory. In-memory caching is critical, and demands performance, reliability, and efficiency. In this talk, I’ll share my adventures in working on Pelikan and how rewriting it in Rust can be more than just a meme.

OSv Unikernel — Optimizing Guest OS to Run Stateless and Serverless Apps in t...

Unikernels have been demonstrated to deliver excellent performance in terms of throughput and latency, while providing high isolation. However they have also been shown to underperform in some types of workloads when compared to a generic OS like Linux. In this presentation, we demonstrate that certain types of workloads - web servers, microservices, and other stateless and/or serverless apps - can greatly benefit from OSv optimized networking stack and other features. We describe number of experiments where OSv outperforms Linux guest: most notably we note 1.6 throughput (req/s) and 0.6 latency improvement (at p99 percentile) when running nginx and 1.7 throughput (req/s) and 0.6 latency improvement (at p99 percentile) when running simple microservice implemented in Golang. We also show that OSv' small kernel, low boot time and memory consumption allow for very high density when running server-less workloads. The experiment described in this presentation shows we can boot 1,800 OSv microVMs per second on AWS c5n.metal machine with 72 CPUs (25 boots/sec on single CPU) with guest boot time recorded as low as 8.98ms at p50 and 31.49ms at p99 percentile respectively. Lastly we also demonstrate how to automate the build process of the OSv kernel tailored exactly to the specific app and/or VMM so that only the code and symbols needed are part of the kernel and nothing more. OSv is an open source project and can be found at https://github.com/cloudius-systems/osv.

Qemu Introduction

Chiawei Wang

Crimson: Ceph for the Age of NVMe and Persistent Memory

Ceph is a mature open source software-defined storage solution that was created over a decade ago. During that time new faster storage technologies have emerged including NVMe and Persistent memory. The crimson project aim is to create a better Ceph OSD that is more well suited to those faster devices. The crimson OSD is built on the Seastar C++ framework and can leverage these devices by minimizing latency, cpu overhead, and cross-core communication. This talk will discuss the project design, our current status, and our future plans.

The Linux Kernel Scheduler (For Beginners) - SFO17-421

Session ID: SFO17-421 Session Name: The Linux Kernel Scheduler (For Beginners) - SFO17-421 Speaker: Viresh Kumar Track: Power Management ★ Session Summary ★ This talk will take you through the internals of the Linux Kernel scheduler. --------------------------------------------------- ★ Resources ★ Event Page: http://connect.linaro.org/resource/sfo17/sfo17-421/ Presentation: Video: https://www.youtube.com/watch?v=q283Wm__QQ0 --------------------------------------------------- ★ Event Details ★ Linaro Connect San Francisco 2017 (SFO17) 25-29 September 2017 Hyatt Regency San Francisco Airport --------------------------------------------------- Keyword: 'http://www.linaro.org' 'http://connect.linaro.org' --------------------------------------------------- Follow us on Social Media https://www.facebook.com/LinaroOrg https://twitter.com/linaroorg https://www.youtube.com/user/linaroorg?sub_confirmation=1 https://www.linkedin.com/company/1026961

Dead Lock Analysis of spin_lock() in Linux Kernel (english)

Sneeker Yeh

UWE Linux Boot Camp 2007: Hacking embedded Linux on the cheap

QEMU and Raspberry Pi. Instant Embedded Development

GlobalLogic Ukraine

This presentation is about creating software for for hardware which does not exist yet. In particular, it explains how to add support of new hardware to QEMU (I2C Accelerometer), how to simulate new hardware, write a simple application to work with accelerometer, and demonstrate that it works on the real platform as well as under QEMU. Presentation by Igor Kaplinsky (Senior Embedded Software Developer, GlobalLogic, Kyiv), Taras Protsiv (Embedded Software Developer GlobalLogic, Kyiv), and Volodymyr Shymanskyy (Embedded Software Developer, GlobalLogic, Kyiv), Embedded TechTalk, Lviv, 2014. More details - http://www.globallogic.com.ua/press-releases/embedded-lviv-techtalk-2-coverage

Unikraft: Fast, Specialized Unikernels the Easy Way

P99 CONF Unikernels are famous for providing excellent performance in terms of boot times, throughput and memory consumption, to name a few metrics. However, they are infamous for making it hard and extremely time consuming to extract such performance, and for needing significant engineering effort in order to port applications to them. We introduce Unikraft, a novel micro-library OS that (1) fully modularizes OS primitives so that it is easy to customize the unikernel and include only relevant components and (2) exposes a set of composable, performance-oriented APIs in order to make it easy for developers to obtain high performance. Our evaluation using off-the-shelf applications such as nginx, SQLite, and Redis shows that running them on Unikraft results in a 1.7x-2.7x performance improvement compared to Linux guests. In addition, Unikraft images for these apps are around 1MB, require less than 10MB of RAM to run, and boot in around 1ms on top of the VMM time (total boot time 3ms-40ms). Unikraft is a Linux Foundation open source project and can be found at www.unikraft.org.

Prerequisite knowledge for shared memory concurrency

Viller Hsiao

An End to OrderRobert Burrell Donkin

UKUUG presentation about µCLinux on Pluto 6

The Silence of the Canaries

Kernel TLV

QEMU in Cross building

Tetsuyuki Kobayashi

An End to Order (many cores with java, session two)

Robert Burrell Donkin

BKK16-306 ART ii

An overview of the infrastructure the Linaro LMG team is using for the ART development, describing some of the interaction between Gerrit, Jenkins and Lava, the differences between target and host tests as well as a high level overview of most of the Linaro ART Jenkins tests. The presentation is aimed at providing a better understanding of our infrastructure to any ART new starter as well as to anyone that is interesting in putting together a similar infrastructure for any other software project.

Kernel Recipes 2015: How to choose a kernel to ship with a product

It’s often difficult to select a kernel for products that are shipped to customers. Several branches exist, bugs need to be avoided as much as possible and updates must be rare enough not to upset customers. All this must be true during all the product’s lifecycle. This presentation will show how the quality of stable kernels evolves over time and when it’s best to pick them and how to help improve them. Willy Tarreau, HAProxy Technologies

What's hot

RISC-V on Edge: Porting EVE and Alpine Linux to RISC-V

Kernel Recipes 2017 - Build farm again - Willy Tarreau

Kernel Recipes 2016 -

Vanquishing Latency Outliers in the Lightbits LightOS Software Defined Storag...

Linux rt in financial markets

Adrien Mahieux

Whoops! I Rewrote It in Rust

OSv Unikernel — Optimizing Guest OS to Run Stateless and Serverless Apps in t...

Qemu Introduction

Chiawei Wang

Crimson: Ceph for the Age of NVMe and Persistent Memory

The Linux Kernel Scheduler (For Beginners) - SFO17-421

Dead Lock Analysis of spin_lock() in Linux Kernel (english)

Sneeker Yeh

UWE Linux Boot Camp 2007: Hacking embedded Linux on the cheap

QEMU and Raspberry Pi. Instant Embedded Development

GlobalLogic Ukraine

Unikraft: Fast, Specialized Unikernels the Easy Way

Prerequisite knowledge for shared memory concurrency

Viller Hsiao

An End to OrderRobert Burrell Donkin

UKUUG presentation about µCLinux on Pluto 6

The Silence of the Canaries

Kernel TLV

QEMU in Cross building

Tetsuyuki Kobayashi

An End to Order (many cores with java, session two)

Robert Burrell Donkin

What's hot (20)

RISC-V on Edge: Porting EVE and Alpine Linux to RISC-V

Kernel Recipes 2017 - Build farm again - Willy Tarreau

Kernel Recipes 2016 -

Vanquishing Latency Outliers in the Lightbits LightOS Software Defined Storag...

Linux rt in financial markets

Whoops! I Rewrote It in Rust

OSv Unikernel — Optimizing Guest OS to Run Stateless and Serverless Apps in t...

Qemu Introduction

Crimson: Ceph for the Age of NVMe and Persistent Memory

The Linux Kernel Scheduler (For Beginners) - SFO17-421

Dead Lock Analysis of spin_lock() in Linux Kernel (english)

UWE Linux Boot Camp 2007: Hacking embedded Linux on the cheap

QEMU and Raspberry Pi. Instant Embedded Development

Unikraft: Fast, Specialized Unikernels the Easy Way

Prerequisite knowledge for shared memory concurrency

An End to Order

UKUUG presentation about µCLinux on Pluto 6

The Silence of the Canaries

QEMU in Cross building

An End to Order (many cores with java, session two)

Similar to Kernel Recipes 2016 - kernelci.org: 1.5 million kernel boots (and counting)

BKK16-306 ART ii

Kernel Recipes 2015: How to choose a kernel to ship with a product

What I learned building a parallel processor from scratch

Andreas Olofsson

Title: What I learned building a parallel processor from scratch Presenter: Andreas Olofsson Location: ISPASS 2015 Keynote Date: March Abstract: In 2008 I left my long time employer (Analog Devices) to start a company with a mission to build a new type of parallel computer. This talk will present the inspiration, design philosophy, mistakes, success, iterations and surprises encountered in designing the Epiphany computer architecture, four generations of Epiphany chips, and the $99 Parallella credit card sized “supercomputer” project.

LCE12: Intro Training: Upstreaming 101

SFO15-BFO2: Reducing the arm linux kernel size without losing your mind

SFO15-BF02: Reducing the arm linux kernel size without losing your mind Speaker: Nicolas Pitre Date: September 24, 2015 ★ Session Description ★ Automatically reducing the Linux kernel size may be achieved in different ways. Using LTO (Link Time Optimization) is one such way with many advantages, but it also has major issues. A simpler alternative is linker section garbage collection. However, it turns out that even “simpler” solutions have their share of unsuspected pitfalls, especially on ARM. Those pitfalls and proposed solutions are the subjects of this discussion. ★ Resources ★ Video: https://www.youtube.com/watch?v=tnKO0TKi3wo Presentation: http://www.slideshare.net/linaroorg/sfo15bfo2-reducing-the-arm-linux-kernel-size-without-losing-your-mind Pathable: https://sfo15.pathable.com/meetings/318624 ★ Event Details ★ Linaro Connect San Francisco 2015 - #SFO15 September 21-25, 2015 Hyatt Regency Hotel http://www.linaro.org http://connect.linaro.org

LCE13: Test and Validation Summit: The future of testing at Linaro

LCE13: Test and Validation Mini-Summit: Review Current Linaro Engineering Pro...

BUD17-405: Building a reference IoT product with Zephyr

"Session ID: BUD17-405 Session Name: Building a reference IoT product with Zephyr - BUD17-405 Speaker: Michael Scott, Ricardo Salveti Track: LTD ★ Session Summary ★ An example of a reference IoT product can be thought of supporting several core technologies such as IPv4/IPv6, 6LoWPAN, Bluetooth LE and also several protocols such as MQTT, CoAP and LWM2M. Additional requirements such as having a complete secure boot and execution environment, besides being able to be securely updated with FOTA support are also critically important. This session will cover the development and challenges faced when producing a reference IoT product implementation with Zephyr, describing the state of the project, and the current gaps to productization. --------------------------------------------------- ★ Resources ★ Event Page: http://connect.linaro.org/resource/bud17/bud17-405/ Presentation: https://www.slideshare.net/linaroorg/bud17405-building-a-reference-iot-product-with-zephyr Video: https://youtu.be/TOJkzIJ_3jg --------------------------------------------------- ★ Event Details ★ Linaro Connect Budapest 2017 (BUD17) 6-10 March 2017 Corinthia Hotel, Budapest, Erzsébet krt. 43-49, 1073 Hungary --------------------------------------------------- Keyword: LTD, Zephyr. IoT http://www.linaro.org http://connect.linaro.org --------------------------------------------------- Follow us on Social Media https://www.facebook.com/LinaroOrg https://twitter.com/linaroorg https://www.youtube.com/user/linaroorg?sub_confirmation=1 https://www.linkedin.com/company/1026961"

Embedded platform choices

Tavish Naruka

kci-linuxconTyler Baker

MOVED: The challenge of SVE in QEMU - SFO17-103

How To Get The Most Out Of Your Hibernate, JBoss EAP 7 Application (Ståle Ped...

Red Hat Developers

The fifth major release of Hibernate sports contains many internal changes developed in collaboration between the Hibernate team and the Red Hat middleware performance team. Efficient access to databases is crucial to get scalable and responsive applications. Hibernate 5 received much attention in this area. You’ll benefit from many of these improvements by merely upgrading. But it's important to understand some of these new, performance-boosting features because you will need to explicitly enable them. We'll explain the development background on all of these powerful new features and the investigation process for performance improvements. Our aim is to provide good guidance so you can make the most of it on your own applications. We'll also peek at other performance improvements made on JBoss EAP 7, like on the caching layer, the connection manager, and the web tier. We want to make sure you can all enjoy better-performing applications—that require less power and less servers—without compromising on your developer’s productivity.

VolatileMark Veltzer

Q1.12: Unorthodox Connect Engineering

“Show Me the Garbage!”, Garbage Collection a Friend or a Foe

Haim Yadid

“Just leave the garbage outside and we will take care of it for you”. This is the panacea promised by garbage collection mechanisms built into most software stacks available today. So, we don’t need to think about it anymore, right? Wrong! When misused, garbage collectors can fail miserably. When this happens they slow down your application and lead to unacceptable pauses. In this talk we will go over different garbage collectors approaches and understand under which conditions they function well.

Perl Continous Integration

Michael Peters

Java vs. C/C++

Azul Systems Inc.

Presentation by Dr. Cliff Click, Jr. Mention Java performance to a C hacker, or vice versa, and a flame war will surely ensue. The Web is full of broken benchmarks and crazy claims about Java and C performance. This session will aim to give a fair(er) comparison between the languages, striving to give a balanced view of each language's various strengths and weaknesses. It will also point out what's broken about many of the Java-versus-C Websites, so when you come across one, you can see the flaws and know that the Website isn't telling you what it (generally) claims to be telling you. (It's surely telling you "something," but almost just as surely is "not realistically" telling you why X is better than Y).

Building a Small Datacenter

ssuser4b98f0

Nova Updates - Kilo Edition

OpenStack Foundation

Ake hedman why we need to unite and why vscp is a solution to a problem

WithTheBest

The world is «many», not «one», and it will always will be that way. Just as different cars drive on the same side of the road and adhere to the same rules, protocols and solutions in IoT and M2M must come to understandings that make them work beside each other and together. What we see today is efforts on standardizing the «roads» while we really need to standardize on how we «travel» on them. This is really no different then what HTML did for hypertext in the past and which made the world wide web a success. To take an example a temperature sent from a device must always be understood by a receiving device to be useful for it, which means it's coding and its unit must be coded in a standard way. Obvious to us all maybe, but not something the IoT/M2M standardizing groups work with today. VSCP have solution for this and for device discovery, uniform configuration, self contained and serverless functionality, firmware updates and is free and open and will stay that way. It works equally well if communication is through a cable or over the air and it makes sure that the sender and the receiver understands each other. In this presentation, Ake will pinpoint the problems and the trends and present one possible solution to the problem. Åke Hedman, Maintainer, VSCP | Founder, Paradise of the Frog

Similar to Kernel Recipes 2016 - kernelci.org: 1.5 million kernel boots (and counting) (20)

BKK16-306 ART ii

Kernel Recipes 2015: How to choose a kernel to ship with a product

What I learned building a parallel processor from scratch

LCE12: Intro Training: Upstreaming 101

SFO15-BFO2: Reducing the arm linux kernel size without losing your mind

LCE13: Test and Validation Summit: The future of testing at Linaro

LCE13: Test and Validation Mini-Summit: Review Current Linaro Engineering Pro...

BUD17-405: Building a reference IoT product with Zephyr

Embedded platform choices

kci-linuxcon

MOVED: The challenge of SVE in QEMU - SFO17-103

How To Get The Most Out Of Your Hibernate, JBoss EAP 7 Application (Ståle Ped...

Volatile

Q1.12: Unorthodox Connect Engineering

“Show Me the Garbage!”, Garbage Collection a Friend or a Foe

Perl Continous Integration

Java vs. C/C++

Building a Small Datacenter

Nova Updates - Kilo Edition

Ake hedman why we need to unite and why vscp is a solution to a problem

More from Anne Nicolas

Kernel Recipes 2019 - Driving the industry toward upstream first

Wanting to avoid the Android experience, Google developers always aimed to make their Chrome OS Linux kernels as close to mainline as possible. However, when Chromebooks were first created, Google was left with no choice, the mainline kernel, in some subsystems, still did not have all the functionalities needed by Chromebooks. Hence, similarly to Android, Chrome OS had to develop their own out-of-tree code for the kernel and maintain that for a few different kernel versions. Luckily, over the last few years a strong and consistent effort has been happening to bring Chromebook devices closer to mainline. It has led to significant improvements that now make it possible to run mainline on Chrome OS devices. And not only Chromebooks, as these significant strides are also improving Arm-based SOCs and other key components of the rich Chromebook hardware ecosystem. In this talk, we will look at how and why upstream support for Chromebooks improved, the current status of various models, and what we expect in the future. Enric Balletbò i Serra

Kernel Recipes 2019 - No NMI? No Problem! – Implementing Arm64 Pseudo-NMI

As the name would suggest, a Non-Maskable Interrupt (NMI) is an interrupt-like feature that is unaffected by the disabling of classic interrupts. In Linux, NMIs are involved in some features such as performance event monitoring, hard-lockup detector, on demand state dumping, etc… Their potential to fire when least expected can fill the most seasoned kernel hackers with dread. AArch64 (aka arm64 in the Linux tree) does not provide architected NMIs, a consequence being that features benefiting from NMIs see their use limited on AArch64. However, the Arm Generic Interrupt Controller (GIC) supports interrupt prioritization and masking, which, among other things, provides a way to control whether or not a set of interrupts can be signaled to a CPU. This talk will cover how, using the GIC interrupt priorities, we provide a way to configure some interrupts to behave in an NMI-like manner on AArch64. We’ll discuss the implementation, some of the complications that ensued and also some of the benefits obtained from it. Julien Thierry

Kernel Recipes 2019 - Hunting and fixing bugs all over the Linux kernel

At a rate of almost 9 changes per hour (24/7), the Linux kernel is definitely a scary beast. Bugs are introduced on a daily basis and, through the use of multiple code analyzers, *some* of them are detected and fixed before they hit mainline. Over the course of the last few years, Gustavo has been fixing such bugs and many different issues in every corner of the Linux kernel. Recently, he was in charge of leading the efforts to globally enable -Wimplicit-fallthrough; which appears by default in Linux v5.3. This presentation is a report on all the stuff Gustavo has found and fixed in the kernel with the support of the Core Infrastructure Initiative. Gustavo A.R. Silva

Kernel Recipes 2019 - Metrics are money

Kernel Recipes 2019 - Kernel documentation: past, present, and future

The Linux kernel project includes a huge amount of documentation, but that information has seen little in the way of care over the years. The amount of care has increased significantly recently, though, and things are improving quickly. Listen as the kernel’s documentation maintainer discusses the current state of the kernel’s docs, how we got here, where we’re trying to go, and how you can help. Jonathan Corbet

Embedded Recipes 2019 - Knowing your ARM from your ARSE: wading through the t...

Modern SoC designs incorporate technologies from numerous vendors, each with their own inconsistent, confusing, undocumented and even contradictory terminology. The result is a mess of acronyms and product names which have a surprising impact on the ability to develop reusable, modular code thanks to the nature of the underlying IP being obscured. This presentation will dive into some of the misnomers plaguing the Arm ecosystem, with the aim of explaining why things are like they are, how they fit together under the architectural umbrella and how you, as a developer, can decipher the baffling ingredients list of your next SoC design! Will Deacon

Kernel Recipes 2019 - GNU poke, an extensible editor for structured binary data

GNU poke is a new interactive editor for binary data. Not limited to editing basic ntities such as bits and bytes, it provides a full-fledged procedural, interactive programming language designed to describe data structures and to operate on them. Once a user has defined a structure for binary data (usually matching some file format) she can search, inspect, create, shuffle and modify abstract entities such as ELF relocations, MP3 tags, DWARF expressions, partition table entries, and so on, with primitives resembling simple editing of bits and bytes. The program comes with a library of already written descriptions (or “pickles” in poke parlance) for many binary formats. GNU poke is useful in many domains. It is very well suited to aid in the development of programs that operate on binary files, such as assemblers and linkers. This was in fact the primary inspiration that brought me to write it: easily injecting flaws into ELF files in order to reproduce toolchain bugs. Also, due to its flexibility, poke is also very useful for reverse engineering, where the real structure of the data being edited is discovered by experiment, interactively. It is also good for the fast development of prototypes for programs like linkers, compressors or filters, and it provides a convenient foundation to write other utilities such as diff and patch tools for binary files. This talk (unlike Gaul) is divided into four parts. First I will introduce the program and show what it does: from simple bits/bytes editing to user-defined structures. Then I will show some of the internals, and how poke is implemented. The third block will cover the way of using Poke to describe user data, which is to say the art of writing “pickles”. The presentation ends with a status of the project, a call for hackers, and a hint at future works. Jose E. Marchesi

Kernel Recipes 2019 - Analyzing changes to the binary interface exposed by th...

Operating system distributors often face challenges that are somewhat different from that of upstream kernel developers. For instance, some kernel updates often need to stay at least binary compatible with modules that might be “out of tree” for some time. In that context, being able to automatically detect and analyze changes to the binary interface exposed by the kernel to its module does have some noticeable value. The Libabigail framework is capable of analyzing ELF binaries along with their accompanying debug info in the DWARF format, detect and report changes in types, functions, variables and ELF symbols. It has historically supported that for user space shared libraries and application so we worked to make it understand the Linux kernel binaries. In this presentation, we are going to present the current support of ABI analysis for Linux Kernel binaries, the challenges we face, how we address them and the plans we have for the future. Dodji Seketeli, Jessica Yu, Matthias Männich

Embedded Recipes 2019 - Remote update adventures with RAUC, Yocto and Barebox

Different upgrade and update strategies exist when it comes to embedded Linux system. If at development time none of these strategies have been chosen, adding them afterwards can be tedious task. Even harder it gets when the system is already deployed in the field and only accessible via a 3G connection. This talk is a developer experience of putting in place exactly that. Giving a return of experience on one way of doing it on a system running Barebox and a Yocto-based distribution. Patrick Boettcher

Embedded Recipes 2019 - Making embedded graphics less special

Traditionally graphics drivers were one of the last hold-outs of proprietary software in an embedded Linux system. This situation is changing with open-source graphics drivers showing up for almost all of the graphics acceleration peripherals on the market right now. This talk will show how open-source graphics drivers are making embedded systems less special, as well as trying to provide an overview of the Linux graphics stack, de-mystifying what is often seen as black magic GPU stuff from outside observers. Lucas Stach

Embedded Recipes 2019 - Linux on Open Source Hardware and Libre Silicon

This talk will explore Open Source Hardware projects relevant to Linux, including boards like BeagleBone, Olimex OLinuXino, Giant board and more. Looking at the benefits and challenges of designing Open Source Hardware for a Linux system, along with BeagleBoard.org’s experience of working with community, manufacturers, and distributors to create an Open Source Hardware platform. In closing also looking at the future, Libre Silicon like RISC-V designs, and where this might take Linux. Drew Fustini

Embedded Recipes 2019 - From maintaining I2C to the big (embedded) picture

The I2C subsystem is not the shiniest part of the Linux Kernel. For embedded devices, though, it is one of the many puzzle pieces which just have to work. Wolfram Sang has the experience of maintaining this subsystem for nearly 7 years now. This talk gives a short overview of how maintaining works in general and specifically in this subsystem. But mainly, it will highlight noteworthy points in the timeline and lessons learnt from that. It will present trends, not so much regarding I2C but more the Linux Kernel and the embedded ecosystem in general. And of course, there will be plenty of anecdotes and bits from behind the scenes for your entertainment. Wolfram Sang

Embedded Recipes 2019 - Testing firmware the devops way

ITRenew is selling recertified OCP servers under the Sesame brand, those servers come either with their original UEFI BIOS or with LinuxBoot. The LinuxBoot project is pushing the Linux kernel inside bios flash and using userland programs as bootloader. To achieve quality on our software stack, as any project, we need to test it. Traditional BIOS are tested by hand, this is 2019 we need to do it automatically! We already presented the hardware setup behind the LinuxBoot CI, this talk will focus on the software. We use u-root for our userland bootloader; this software is written in Go so we naturally choose to use Go for our testing too. We will present how we are using and extending the Go native test framework `go test` for testing embedded systems (serial console) and improving the report format for integration to a CI. Julien Viard de Galbert

Embedded Recipes 2019 - Herd your socs become a matchmaker

About 60% of the Linux kernel source tree is devoted to drivers for a large variety of supported hardware components. Especially in the embedded world, the number of different SoC families, versions, and revisions, integrating a myriad of “IP cores”, keeps on growing. In this presentation, Geert will explain how to match drivers against hardware, and how to support a wide variety of (dis)similar devices, without turning platform and driver code into an entangled bowl of spaghetti.tra Starting with a brief history of driver matching in Linux, he will fast-forward to device-tree based matching. He will discuss ways to handle slight variations of the same hardware devices, and different SoC revisions, each with their own quirks and bugs. Finally, Geert will show best practices for evolving device drivers in a maintainable way, based on his experiences as an embedded Linux kernel developer and maintainer. Geert Uytterhoeven

Embedded Recipes 2019 - LLVM / Clang integration

Buildroot is a popular and easy to use embedded Linux build system. It generates, in few minutes, lightweight and customized Linux systems, including the cross-compilation toolchain, kernel and bootloader images, as well as a wide variety of userspace libraries and programs. This talk is about the integration of LLVM/clang into Buildroot. In 2018, Valentin Korenblit, supervised by Romain Naour, worked on this topic during his internship at Smile ECS. After a short introduction about llvm/clang and Buildroot, this talk will go through the numerous issues discovered while adding llvm/clang componants and how these issues were fixed. Romain will also detail the work in progress and the work to be done based on llvm/clang libraries (OpenCL, Compiler-rt, BCC. Chromium, ldd). Romain Naour

Embedded Recipes 2019 - Introduction to JTAG debugging

This talk introduces JTAG debugging capabilities, both for debugging hardware and software. Marek first explains what the JTAG stands for and explains the operation of the JTAG state machine. This is followed by an introduction to free software JTAG tools, OpenOCD and urJTAG. Marek shortly explains how to debug software using those tools and how that ties into the JTAG state machine. However, JTAG was designed for testing hardware. Marek explains what boundary scan testing (BST) is, what are BSDL files and their format, and practically demonstrates how to blink an LED using BST and only free software tools. Marek Vasut

Embedded Recipes 2019 - Pipewire a new foundation for embedded multimedia

PipeWire is an open source project that aims to greatly improve audio and video handling under Linux. Utilising a fresh design, it bridges use cases that have been previously addressed by different tools – or not addressed at all -, providing ground for building complex, yet secure and efficient, multimedia systems. In this talk, Julien is going to present the PipeWire project and the concepts that make up its design. In addition, he is going to give an update of the current and future work going on around PipeWire, both upstream and in Automotive Grade Linux, an early adopter that Julien is actively working on. Julian Bouzas

Kernel Recipes 2019 - ftrace: Where modifying a running kernel all started

Ftrace’s most powerful feature is the function tracer (and function graph tracer which is built from it). But to have this enabled on production systems, it had to have its overhead be negligible when disabled. As the function tracer uses gcc’s profiling mechanism, which adds a call to “mcount” (or more recently fentry, don’t worry if you don’t know what this is, it will all be explained) at the start of almost all functions, it had to do something about the overhead that causes. The solution was to turn those calls into “nops” (an instruction that the CPU simply ignores). But this was no easy feat. It took a lot to come up with a solution (and also turning a few network cards into bricks). This talk will explain the history of how ftrace came about implementing the function tracer, and brought with it the possibility of static branches and soon static calls! Steven Rostedt

Kernel Recipes 2019 - Suricata and XDP

Suricata is a network threat detection engine using network packets capture to reconstruct the traffic till the application layer and find threats on the network using rules that define behavior to detect. This task is really CPU intensive and discarding non interesting traffic is a solution to enable a scaling of Suricata to 40gbps and other. This talk will present the latest evolution of Suricata that knows uses eBPF and XDP to bypass traffic. Suricata 5.0 is supporting the hardware XDP to provide ypass with network card such as Netronome. It also takes advantage of pinned maps to get persistance of the bypassed flows. This talk will cover the different usage of XDP and eBPF in Suricata and shows how it impact performance and usability. If development time permit, the talk will also cover AF_XDP and the impact on this new capture method on Suricata. Eric Leblond

Kernel Recipes 2019 - Marvels of Memory Auto-configuration (SPD)