OpenEmbedded Workshop 2020

Brussels is an important place in the history of OpenEmbedded. I'll introduce the workshop and talk a little bit about OpenEmbedded and Brussels

Being a interpreted language python allows very good opportunities for interactive debugging. This allows not just debugging the code but also is a great way to introduce oneself to the new code by freely examining the runtime.

This talk will explore how to apply that approach for examining and debugging python tasks in bitbake.

Flexible, connected platforms are core components in leading computing fields
(i.e. IoT, NFV, SDN, PaaS, IaaS, etc). These modern systems and applications
drive requirements on the core platform that lead to the convergence of
enterprise and embedded operating environments. As a result, existing methods
for build, deployment and maintenance of embedded platforms are augmented with
"Enterprise-like" functionality.

Bruce will discuss how the layers and technologies in the OpenEmbedded ecosystem
can be used to produce many different types of cloud native systems. The
presentation will show how to produce standard containers, microservices to full
containerized operating environments. Discussions around OpenEmbedded benefits,
such as optimized (performance, footprint, licensing, development), will be
highlighted as part of this talk.

This talk is a humorous review of the ridiculous things people do in
their board support packages, why these bad BSPs impact OpenEmbedded
and the embedded ecosystem. Names will be changed to protect the
guilty!

This presentation will discuss what OpenEmbedded currently brings to the table for building container images in the areas of container size, reproducibility, security vulnerability fixing, and license compliance. The available options for building application and system container images with OpenEmbedded will be discussed with pointers to examples. This presentation is an update of previous content from ELC 2018 and Yocto Project Dev Day at ELC 2019 to cover changes in the Zeus and upcoming Dunfell releases.

We will discuss some of the considerations device manufacturers should consider when designing Linux-based connected devices. These devices are increasingly common in the Internet of Things (IoT). We will discuss hardware, software, security, and how to bring it all together. We will present a demo solution using a Raspberry Pi device and provide a build environment and instructions for attendees to use on their own hardware.

We will start by defining IoT and its basics. We will cover the various applications, including the consumer, industrial, enterprise, and municipal markets. Design considerations for IoT development will be covered as well as the Cloud Infrastructure options available.

The selection process will be covered, including hardware (on-board peripherals, form factor), system software (OS, system development tools, deployment strategies), and application software criteria.

With containers more prevalent on embedded devices, this talk will
look at the ways people have tried to incorporate them in
OpenEmbedded. Specifically, we will look at how Oryx Embedded Linux
uses OpenEmbedded, mender and containers (both the successes and
failures) to create OTA containerized updatable firmware images.

Embedded Linux devices are very fragmented in their design and implementation. We will discuss and give an overview of the four components of embedded Linux systems: toolchain, bootloader, kernel, root filesystem and then how they are combined into a basic embedded Linux system.

Typically, as a developer you will be given some or all of these components as a package when you decide on your development board but they may not contain the optimum choices for you because the requirements for your particular embedded application may vastly differ.

We will then present and discuss some best approaches on how one can structure for components so that BSPs follow a commonly understood layout, discuss how to best approach customizing a recipe for a BSP particular to your embedded application.

A BSP layer contains the Board Support Package for a device. Every project has one: it's the part that describes the hardware platform that you are using. If you purchased your board from one of the embedded board manufacturers then they will most likely have given you a Yocto Project compatible BSP layer already. If not, you will have to write the layer yourself. This talk is for you.

In this talk, I will describe the steps of creating a BSP layer from scratch, giving tips for
best practice and pointing out pit-falls as I go. I will introduce the two
guiding principles: keep it simple, and don't break things.
The "keep it simple part" is all about defining only the features that are
necessary. What you leave out can be as important as what you put in.
The "don't break things" part concerns the interaction with other layers.
Your BSP layer should not conflict with or prevent the use of other layers
that developers are likely to want.

The aim is to create a world with perfect BSP layers. A world in which
downstream users can create wonderful products with minimum effort.
Your customers will thank you.

Many upstream components integrated via OpenEmbedded already support cryptographic signatures for authentication (kernel, FIT images, update artifacts, boot images).

There is already some existing support for signing using keys stored in the file-system (uboot-sign.bbclass, meta-rauc's bundle.bbclass, meta-secure-core). In larger projects, there is often the requirement to support more secure key storage devices such as HSMs (Hardware Security Modules).

Fortunately, support for the standard API to use keys on hardware tokens (PKCS#11) is widespread by now. We can use this API and SoftHSM (a PKCS#11 simulator) to decouple individual packages from the key configuration. This simplifies testing, as almost the same code is used during development with keys loaded from the file-system and during release with a real HSM.

Jan will present his implementation (a single .bbclass) and some example packages. He is looking for feedback, additional use-cases and testing.

OpenEmbedded dates from 2004 and the Yocto Project from 2010. This talk covers the evolution of the project from a community driven project into the foundation for large scale commercial deployments. After talking about how we arrived at this workshop, the speaker will seek guidance from the audience for future directions and how we can achieve them.