Speaker

Chris Simmonds

Chris Simmonds

Looking after the inner penguin

Chris Simmonds is a software consultant and trainer living in southern England. He has spent almost two decades designing and building open-source embedded systems of all shapes and sizes, and he has encapsulated much of that experience in his book, “Mastering Embedded Linux Programming”.

He is a frequent presenter at open source and embedded conferences, including the Embedded Linux Conference and Embedded World. You can see some of his work on the “Inner Penguin” blog at www.2net.co.uk

Why can't my app open that file? A deep dive into the Android app sandbox

Android keeps a close eye on what files your application can read and write. We call this the "application sandbox": a safe area for your code to run which prevents other apps from interfering with your data, and prevents you from interfering with other apps or the operating system

In this talk I will be looking at the rationale behind the sandbox, and how it works. I will look at file ownership, file access modes and the reasons for those "Permission denied" messages. I will dig down to find out exactly why an app can access only a well defined set of private files and shared storage. And I will explain
how SE Linux enforces all of this at at a deep level

You will be reassured that Android is a secure operating system. But, as you know there are always exceptions to the rules. So, in the final section of this talk I will show you how preinstalled system apps can crash though all the barriers

How to write a really good board support package for Yocto Project

In Yocto Project, a board support package (BSP) is the meta layer which contains all the configuration specific to a particular board. For example there is a BSP layer for the Raspberry Pi called meta-raspberrypi. The BSP layer becomes the base on which all the other meta layers will stand, and so it is probably the most important of them all. The BSP layer captures information about the SoC used, the storage technologies, GPIO mapping and much more besides.

In this presentation I will start with some background on Yocto Project meta layers and then I will show step-by-step how to build in the support for your board. Along the way, I will highlight some of the common pitfalls, and how to avail them.

If you want a single sentence that summarizes the whole presentation it is “keep it simple”.

Hardware Interfacing with Yocto Project

Computing is all about hardware: a program that does not touch hardware is … not a program. This is especially true in the embedded domain. This two day hands-on workshop will give you a chance to explore numerous types of hardware interfacing, including:
• GPIO
• i2c
• USB
• Graphics

We will be looking at these from the point of view of embedded systems, including Linux based IoT devices. For the hands-on portion of the workshop we will be using Raspberry Pi boards to implement a smart door bell

In the lectures, you will learn the theory necessary to implement such a device. Starting from power on, we will consider how Linux discovers what hardware is attached, and especially the role of the device tree in non PC systems. We will look how Linux represents hardware internally through the device driver model and the sysfs file system, and how it loads device drivers for each component of hardware. Then we will see how to interact with device drivers from user-space programs to make a working system.

We will be using the industry standard Yocto Project to build the disk images for the target. If you are not familiar with Yocto, don’t worry: we will be covering the fundamentals of Yocto as well.

The workshop is suitable for anyone working with Embedded Linux, or IoT devices, or is just curious about how things work

To get the best out of it you will need good command-line Linux skills (grep, find, bash), good C/C++ coding skills, and a basic knowledge of computer architecture (memory address spaces, interrupts, DMA)

Getting started with Yocto Project

Embedded computing is very diverse. The majority of devices use ARM architecture processors, but RISC-V is gaining in popularity, and there is of course x86. Each device has its own requirements and constraints. To cope with this diversity, we need tools to build the operating system and fundamental applications. Yocto Project is the tool most often used.

In this talk I will show you how to get started with Yocto, first using QEMU to create an emulated target board, and then using a Raspberry Pi. I will describe the basics of Yocto: Distro, Machine, Image. I will talk about Bitbake and bitbake recipes and I will show how recipes can be gathered together into layers. If you want to get a head start with Yocto Project and embedded Linux, this is the talk for you

Fundamentals of Embedded Linux

Linux is embedded into many of the devices around us: WiFi routers, the navigation and entertainment system in most cars, smart TVs, smart doorbells, smart speakers, … you get the picture. But, what makes embedded Linux “embedded”? How does it differ from “normal” Linux?

Based on over 20 years of experience I will give you some pointers about what embedded means and the way that we develop in this environment

I will talk about the underlying hardware: the System on Chip (SoC) and how that is packaged as a System on Module (SoM), or a Single Board Computer (SBC), or into a custom designed board. For each target, we need the four basic components of an embedded Linux system: the toolchain, the bootloader, the kernel and the root filesystem. Then, on top of that you need the applications that are going to turn it into a world-beating gadget. That may include graphics drivers to control a touch screen, network interfaces to connect to a cloud backend and databases to store structured data. There may even be real-time control tasks. Finally, I will consider how you combine the open source base operating system with your own proprietary code

Exploring Android internals with ADB

We all use ADB during development for debugging and admin tasks. But, what else can you find out and what can you do with it?

In this talk I will show how to use ADB as a window into the internal workings of the Android operating system. I will begin with system services, which are the core of Android, and show how to dump state, interact with them from the command line, and how to send binder messages. You can, for example, place a
phone call from the command line

At an even lower level, we have native services. These are Unix daemons that are started during early boot. You can list them, start and stop them, and even restart the Android run-time

Next, file permissions: what prevents an app or service from accessing a file? This is a story of Unix file permissions and SELinux policy. I will show how you can see the permissions and the policy, and change them - but only if you have root access

Finally, I will look at system properties. These are global variables used throughout Android to tune the framework, to record status information and to act as signals when a property changes

Building Android

Everybody knows how to write apps for Android, but few know how to create the Android platform itself. This workshop will show you how. Using source code from the Android Open Source Project (AOSP) you will will build a custom Android image based on Android 11 and a 5.4 kernel. The target hardware is Goldfish, known to most people as the Android emulator

You will get a chance to go through a complete – but intensive – product cycle, starting from a bare device configuration. You will make it buildable by adding it to the lunch menu, then customize the image by selecting the packages to add, and finishing up with a few customizations such as adding a boot animation

The second part of the workshop is to use this base platform to create a (simple) smart doorcam. For this you will be writing a platform app – the kind that is bundled with the system images – and using lock task mode to create a single use “kiosk mode” device

This workshop is very much hands-on. As a takeaway you will have the slides, workbook notes and the end result. Plus, worked examples to help you along

An Introduction to Android Automotive OS

Android Automotive OS is a version of Android tailored for In-Vehicle Infotainment (IVI) – navigation, vehicle status, audio, and more. The first car to use AAOS is the Polestar 2. In this presentation I will talk about the changes Google have made to Android to make it ready for the road. There is a a new hardware abstraction layer that allows applications to access the vehicle bus in a controlled way. There are changes to the Android audio subsystem to handle the complexities multiple input and output channels. And, there is a new sub system to handle the rear view cameras.

Amongst other things, I will be asking: how does a car differ from a smartphone? What are the consequences of running a consumer operating system in the IVI head unit? Which parts are open source and which proprietary? Come along to find answers

How did Linux become a mainstream embedded operating system?

Today, Linux is woven into the fabric of our technology. Printers, routers, TVs and Smartphones all have their own "Inner Penguin". Yet it was never intended to be used beyond desktops and servers. A lot of things had to happen before Linux could break out of the PC environment and make its way in the world as a jobbing jack-of-all-trades.

This talk follows the evolution of Linux as it morphed from a desktop operating system into something truly flexible that could be used to control devices of all shapes and sizes. It had to be made smaller, and more portable. It had to be able to read and write flash memory. Tools like Buildroot, OpenEmbedded and the Yocto Project had to be created to
help put everything together.

Each of these steps was initiated by individuals or small groups of people, each having a profound affect on the direction and capabilities of the whole project. Looking to the future, it is clear that embedded computing is going to play an ever increasing part on our lives. It is my belief that developers will continue to step up and adapt Linux to match the new computing landscape.

Fast Track to OpenEmbedded and Yocto Project

If you are working with embedded Linux you will be aware that the Yocto Project is a key component for generating device firmware. This intensive two day workshop will teach you how to make effective use of OpenEmbedded and Yocto Project to create highly functional, reliable system images for your target device. It will show you how to select packages, how to customise system behaviour, and how to create your own meta layers. With the relevant information under your belt you will have your embedded Linux system up and running in no time!

Audience
This workshop is ideal for software engineers who are familiar with embedded devices but need to apply that knowledge to Linux development,
and to those who are familiar with Linux, but want to apply that knowledge to embedded systems.

Prerequisites
Attendees should know C/C++ pretty well, and be familiar with Linux command-line tools such as 'find', 'grep' and 'make'

Laptop setup
About half of this workshop is dedicated to hands-on sessions. Consequently you will need to bring a laptop along with you. Pretty much any recent laptop be fine so long as it has at least dual cores and more than 4 GB memory, but *no Macintoshes*. I will provide USB flash drives (which are yours to keep) with a copy of Ubuntu pre-installed. You just need boot your laptop from the USB drive. Please note that this means you must be able to able to change your BIOS settings to boot from an external USB device using legacy boot mode

droidcon London 2023 Sessionize Event

October 2023 London, United Kingdom

Chris Simmonds

Looking after the inner penguin