Yocto or PetaLinux?

PetaLinux [1] and Yocto [2] are both build tools for creating custom embedded Linux platforms. Recently, I got into a discussion with a colleague as to which to use for an embedded Linux project. Given PetaLinux simplifies to some degree the complexities of Yocto, my colleague’s initial instinct was to use PetaLinux. However, I have on occasion bumped into the limitations of PetaLinux. This got me thinking that a comparison of the two would make for an interesting article.

It’s worth noting that PetaLinux was created by Xilinx, which has now been purchased by AMD [3]. At the time of writing the support forums and documentation hosting have moved over to AMD. But the Xilinx wiki lives on, and it seems unlikely that the APIs and code will have all their Xilinx references removed (function names beginning with X or Xil for example). I’ll continue to refer to Xilinx throughout this article as we are talking about the Xilinx part of the AMD portfolio.

PetaLinux is targeted at designs involving a Field Programmable Gate Array (FPGA), for example a FPGA-based System-on-Chip (SoC), and implies the use of Xilinx hardware.

FPGAs are integrated circuits that can be reprogrammed for different tasks, they excel at high performance applications. Meanwhile SoCs package Central Processor Units (CPUs), memory, I/O ports, and other specialised processing units (like FPGAs) onto a single chip. The benefits of SoCs are they allow for smaller, lighter and more power efficient solutions.

The benefit of a SoC that includes an FPGA is that you have the benefits of a general-purpose processor (for example access to existing software platforms such as Linux and everything that comes with it), and a reprogrammable integrated circuit that can be used to execute high performance specialised tasks.

At Plextek we specialise in low size, weight and power (SWaP) solutions and often find ourselves utilising SoCs.

Yocto is a set of build tools for creating embedded Linux operating systems. Broadly speaking Yocto also encapsulates the poky reference distribution and components from the OpenEmbedded project [6] [7]. The key components for the purpose of this discussion are:

1. Distributions
2. Layers
3. BitBake

A distribution (typically abbreviated to distro) is a Linux based operating system. Yocto has a reference distribution called “poky” that has a set of image definitions you can use as a starting point.

A layer is a set of software components that can be added to your Yocto project. A Yocto project consists of a number of layers:

• Base layers (such poky and OpenEmbedded)
• Device specific layers (such as meta-xilinx)
• Layers that fulfil dependencies for your applications (e.g. if you needed libmetal then meta-openamp would fulfil this requirement)
• Project specific layers (such as board support and software)

Yocto makes use of the OpenEmbedded BitBake tool [8] for its build engine. You will be using the “bitbake” command line tool on a day-to-day basis for a Yocto project. BitBake is a generic task execution engine, which runs tasks written in shell script and Python. Essentially, it allows you to build packages (software components) and images (deployable files).

PetaLinux is a set of tools that utilises many of the same underlying tools as Yocto, and as such can be seen as a wrapper for Yocto (although this is a simplification).

The first thing to note is that there are actually a few things called “PetaLinux”:

• A set of tools (a sort of Yocto wrapper)
• A reference distro
• A meta layer (meta-petalinux)

The PetaLinux set of tools includes the meta-petalinux layer, which defines the PetaLinux distribution. Xilinx provide quick start packages for boards (e.g. Xilinx ZCU102 etc) which can be fed into the petalinux-create command. This gets you a usable image for a reference board within a couple of commands.

The focus of PetaLinux is on getting you as a developer up and running with a development system as quickly as possible. This allows you to focus on specific elements, for example an FPGA and the software on the processor that utilises it.

Ultimately PetaLinux is not intended for productisation and therefore lacks some key ingredients; it does not support SELinux (a mechanism for implementing security polices) and has no mechanism for security updates. Meanwhile, Yocto allows you to create your own distro.

A Common Vulnerability and Exposure (CVE) is a security flaw that has been listed on a publicly accessible catalogue. Yocto CVEs reference the NIST NVD CVE database where each CVE has its own unique ID [15]. At a high level you can look at the poky/OpenEmbedded-Core CVEs by release on the yocto-metrics page [17].

A Yocto project can take advantage of the cve-check feature to check for CVEs at build time. It is also possible to use BitBake to check for CVEs on a certain package. Yocto has a process that you can follow to apply patches for CVEs, and the cve-check feature can note CVEs as patched based on the commit information [16].

The PetaLinux (set of tools) comes with a PetaLinux distribution. Likewise, Yocto comes with a reference distribution called poky. But just using Yocto is not the full answer here, as poky is just that, a reference, and should be replaced with your own distribution for products. This is further evidenced by the latest versions of poky giving the following warning:

“Poky is a reference Yocto Project distribution that should be used for testing and development purposes only. It is recommended that you create your own distribution for production use.”

Broadly speaking there are two key reasons why you would want your own distribution [10]:

1. Reducing the attack surface: Poky enables most hardware and software features leaving a broad attack surface from a security perspective
2. Greater control over configuration:
   1. Package alternative selections
   2. Compile-time options
   3. Low-level configurations

You can create your own distribution with Yocto.