\documentclass[aspectratio=169,obeyspaces,spaces,hyphens,dvipsnames]{beamer}
\usepackage[utf8]{inputenc}
\usepackage{lmodern}% http://ctan.org/pkg/lm
\usepackage{minted}
\usepackage{hyperref}
\usepackage{xcolor}
\usepackage{pgfplots}
\usepackage{tikz}
\usepackage{tabularx}
\usepackage[normalem]{ulem}

\mode<presentation>
\usetheme{Bootlin}

\def\signed #1{{\leavevmode\unskip\nobreak\hfil\penalty50\hskip2em
  \hbox{}\nobreak\hfil(#1)
  \parfillskip=0pt \finalhyphendemerits=0 \endgraf}}

\graphicspath{ {./images/} }

\newsavebox\mybox
\newenvironment{aquote}[1]
  {\savebox\mybox{#1}\begin{quotation}}
  {\signed{\usebox\mybox}\end{quotation}}

\title{Building embedded Debian / Ubuntu systems with ELBE}
\authors{Köry Maincent}
\email{kory.maincent@bootlin.com}
\slidesurl{https://bootlin.com/pub/conferences/2020/elce/maincent-building-embedded-debian-ubuntu-systems-elbe/}
\institute{Bootlin}
\conference{Conference}

\begin{document}

\addtocontents{toc}{\protect\setcounter{tocdepth}{-1}}
\section{Building embedded Debian / Ubuntu systems with ELBE}
\addtocontents{toc}{\protect\setcounter{tocdepth}{2}}

\begin{frame}{Köry Maincent}
  \begin{columns}
    \column{0.7\textwidth}
    \begin{itemize}
    \item Embedded Linux engineer at Bootlin
      \begin{itemize}
      \item Embedded Linux, Linux kernel, Yocto, Buildroot {\bf
          expertise}
      \item {\bf Development}, consulting and training
      \item Strong open-source focus
      \end{itemize}
    \item Open-source contributor
      \begin{itemize}
      \item Contributed Ubuntu support to ELBE
      \item Used ELBE to build Ubuntu systems for an ARM32 i.MX6
        platform and an ARM64 Rockchip RK3399 platform
      \end{itemize}
    \item Living in {\bf Toulouse}, France
    \end{itemize}
    \column{0.3\textwidth}
    \includegraphics[width=\textwidth]{common/logo-penguins.pdf}
  \end{columns}
\end{frame}

\begin{frame}{Agenda}
  \begin{itemize}
  \item System integration: available options
  \item Overview of ELBE
  \item Building simple Debian/Ubuntu images with ELBE
  \item Customizing the images contents
  \end{itemize}
\end{frame}

\begin{frame}{System integration: several possibilities}
  \begin{center}
  \tiny
  \begin{tabularx}{13cm}{|X|X|X|}
    \hline
    & {\bf Pros} & {\bf Cons} \\
    \hline
    {\bf Building everything manually} &
    Full flexibility \newline
    Learning experience &
    Dependency hell \newline
    Need to understand a lot of details \newline
    Version compatibility \newline
    Lack of reproducibility \\
    \hline
    {\bf Binary distribution} \newline Debian, Ubuntu, Fedora, etc.
    &
    Easy to create and extend \newline
    Large set of existing packages \newline
    Well-known tools for non-embedded experts \newline
    Robust and regular security updates
    &
    Hard to customize \newline
    Hard to optimize (boot time, size) \newline
    Hard to rebuild the full system from source \newline
    Large system \newline
    Uses native compilation (slow) \newline
    No well-defined mechanism to generate an image \newline
    Lots of mandatory dependencies \newline
    Not available for all architectures \\
    \hline
    {\bf Build systems} \newline Buildroot, Yocto, PTXdist, etc.
    &
    Nearly full flexibility \newline
    Built from source: customization and optimization are easy \newline
    Fully reproducible \newline
    Uses cross-compilation \newline
    Have embedded specific packages not necessarily in desktop distros \newline
    Make more features optional
    &
    Not as easy as a binary distribution \newline
    Build time \\
    \hline
  \end{tabularx}
  \end{center}
\end{frame}

%        \\
%        \url{https://elbe-rfs.org/}\\

\begin{frame}{Debian build systems}
  \begin{columns}
    \column{0.7\textwidth}
    Several projects have been created to automate the process of
    building and customizing a Debian image:
    \begin{itemize}
    \item Hand-made scripts
      \only<2>{
        \begin{itemize}
        \item Hardly reproducible and maintable
        \item Everybody rolls his own
        \end{itemize}
      }
    \item ELBE
      \only<3>{
        \begin{itemize}
        \item First release in 2015
        \item Python code to use generic Debian tools
        \item Only supported Debian, but we (Bootlin) contributed
          Ubuntu support
        \item \url{https://elbe-rfs.org/}
        \item {\bf The focus of this talk}
        \end{itemize}
      }
    \item Debos
      \only<4>{
        \begin{itemize}
        \item Image and partition customizable
        \item Possibility to tune the rootfs
        \item Can not build custom packages from source
        \item Written in Go
        \item \url{https://github.com/go-debos/debos}
        \end{itemize}
      }
    \item Isar
      \only<5>{
        \begin{itemize}
        \item Uses bitbake, needs Yocto knowledge
        \item Not tested (less active than ELBE?)
        \item \url{https://github.com/ilbers/isar}
        \end{itemize}
      }
    \end{itemize}
    \column{0.3\textwidth}
    \only<3>{
      \includegraphics[width=\textwidth]{elbe-logo.png}
    }
  \end{columns}
\end{frame}

\begin{frame}{ELBE advantages}
  \begin{itemize}
  \item Builds a Debian distribution
    \begin{itemize}
    \item Powerful package management
    \item Huge amount of packages
    \item Let the Debian/Ubuntu maintainers do all the work on packages
    \item Have reliable and regular security updates
    \end{itemize}
  \item Build your own packages
  \item Manage licences
  \item Several architectures, several image generation options
  \item Tune your rootfs
  \end{itemize}
\end{frame}

\begin{frame}{Overall ELBE process}
\begin{center}
\includegraphics[width=1\textwidth]{elbe-process.png}\\
\begin{tiny}
\textit{Source: \url{https://wiki.dh-electronics.com/index.php/ELBE_Overview}}
\end{tiny}
\end{center}
\end{frame}

\begin{frame}[fragile]{ELBE: getting started}
  \begin{enumerate}
  \item Download ELBE from its Git repository
  \item Create the {\em initvm}, a Debian virtual machine that
    includes the ELBE daemon.
    \begin{block}{}
      \fontsize{9}{9}\selectfont
\begin{minted}{bash}
$ ./elbe initvm create
\end{minted}
    \end{block}
  \item Then, after each reboot, you need to make sure the {\em
      initvm} is started:
    \begin{block}{}
      \fontsize{9}{9}\selectfont
\begin{minted}{bash}
$ ./elbe initvm start
\end{minted}
    \end{block}
  \end{enumerate}
\end{frame}

\begin{frame}[fragile]{ELBE: build a basic Debian or Ubuntu image}
  \begin{itemize}
  \item In ELBE, the system to generate is described by an XML file
  \item To build a Debian system for the BeagleBone Black, including
    bootloader and Linux kernel:
    \begin{block}{}
      \fontsize{9}{9}\selectfont
\begin{minted}{bash}
$ ./elbe initvm submit examples/armhf-ti-beaglebone-black.xml
\end{minted}
    \end{block}
    The build takes approximately 50 min on my laptop
  \item To build a basic Ubuntu system, with no bootloader or kernel:
    \begin{block}{}
      \fontsize{9}{9}\selectfont
\begin{minted}{bash}
$ ./elbe initvm submit examples/armhf-ubuntu.xml
\end{minted}
    \end{block}
    The build takes approximately 30 minutes
  \end{itemize}
\end{frame}

\begin{frame}[fragile]{ELBE: result directory}
  Contents of the result directory, with the \code{--build-sdk} option
  enabled:
  \begin{columns}
    \column{0.5\textwidth}
    \begin{itemize}
    \item \code{bin-cdrom.iso}
    \item \code{image.tgz}
    \item \code{license-*}
    \item \code{setup-elbe...sh}
    \item \code{source.xml}
    \item \code{src-cdrom.iso}
    \item \code{sysroot.tar.xz}
    \end{itemize}
    \column{0.5\textwidth}
    \begin{block}{}
      \fontsize{8}{8}\selectfont
\begin{minted}{bash}
$ ls elbe-build-20200903-113635
bin-cdrom.iso
elbe-report.txt
image.tgz
licence-chroot.txt
licence-chroot.xml
licence-sysroot-host.txt
licence-sysroot-host.xml
licence-sysroot-target.txt
licence-sysroot-target.xml
licence-target.txt
licence-target.xml
log.txt
setup-elbe-sdk-arm-[...]-armhf-ubuntu-1.0.sh
source.xml
src-cdrom.iso
sysroot.tar.xz
validation.txt
\end{minted}
    \end{block}
  \end{columns}
\end{frame}

\begin{frame}[fragile]{ELBE: contents of the XML file}
  \begin{itemize}
  \item Global node:
  \begin{onlyenv}<2>
    \begin{block}{}
      \fontsize{8}{8}\selectfont
\begin{minted}{xml}
<ns0:RootFileSystem ... >
...
</ns0:RootFileSystem>
\end{minted}
    \end{block}
  \end{onlyenv}
  \item Project node:
  \begin{onlyenv}<3>
    \begin{block}{}
      \fontsize{8}{8}\selectfont
\begin{minted}{xml}
<project>
  <name>Image name</name>
  <version>1.0</version>
  <description>
    Image description
  </description>
  <buildtype>armhf</buildtype>
  <mirror>
    <primary_host>ftp.de.debian.org</primary_host>
    <primary_path>/debian</primary_path>
    <primary_proto>http</primary_proto>
  </mirror>
  <suite>buster</suite>
</project>
\end{minted}
    \end{block}
  \end{onlyenv}
  \item Target node:
  \begin{onlyenv}<4>
    \begin{block}{}
      \fontsize{8}{8}\selectfont
\begin{minted}{xml}
<target>
  <hostname>myImage</hostname>
  <domain>tec.linutronix.de</domain>
  <passwd>foo</passwd>
  <console>ttyS0,115200</console>
  <images> ...  </images>
  <fstab> ...  </fstab>
  <package> ... </package>
  <finetuning> ... </finetuning>
  <pkg-list> ... </pkg-list>
</target>
\end{minted}
    \end{block}
  \end{onlyenv}
  \end{itemize}
\end{frame}

\begin{frame}{ELBE: day to day work}
  \begin{columns}
    \column{0.6\textwidth}
    \begin{itemize}
    \item The ELBE \code{submit} command allows to build an image from scratch
      \begin{itemize}
      \item Builds all parts described in the XML file in one command
      \item Good for releases/deliveries
      \item But rebuilds everything!
      \end{itemize}
    \item The ELBE \code{control} command allows to work in a more-fine
      grained way
      \begin{itemize}
      \item Doesn't build all parts described in the XML file
      \item Good for day-to-day work, image adjustement and customization
      \end{itemize}
    \end{itemize}
    \column{0.4\textwidth}
\includegraphics[width=\textwidth]{compiling.png}
  \end{columns}
\end{frame}

\begin{frame}[fragile]{ELBE: using the control command (1/2)}
  \begin{itemize}
  \item Create a project
    \begin{block}{}
    \fontsize{9}{9}\selectfont
\begin{minted}{bash}
$ ./elbe control create_project
/var/cache/elbe/0a7b1788-b2ab-4b53-9319-0a810dab30d9
$ PRJ="/var/cache/elbe/0a7b1788-b2ab-4b53-9319-0a810dab30d9"
\end{minted}
  \end{block}
\item Define the image/system to build based on its XML file
  \begin{block}{}
    \fontsize{9}{9}\selectfont
\begin{minted}{bash}
$ ./elbe control set_xml $PRJ armhf-ti-beaglebone-black.xml
\end{minted}
  \end{block}
\item Start the build and wait until it completes
  \begin{block}{}
    \fontsize{9}{9}\selectfont
\begin{minted}{bash}
$ ./elbe control build $PRJ
$ ./elbe control wait_busy $PRJ
\end{minted}
  \end{block}
\end{itemize}
\end{frame}

\begin{frame}[fragile]{ELBE: using the control command (2/2)}
  \begin{itemize}
\item Now you can update/tweak your XML file, and restart the build
  \begin{block}{}
    \fontsize{9}{9}\selectfont
\begin{minted}{bash}
$ ./elbe control set_xml $PRJ armhf-ti-beaglebone-black.xml
$ ./elbe control build $PRJ
$ ./elbe control wait_busy $PRJ
\end{minted}
  \end{block}
\item And retrieve the build results
  \begin{block}{}
    \fontsize{9}{9}\selectfont
\begin{minted}{bash}
$ ./elbe control get_files $PRJ
$ ./elbe control get_file $PRJ sdcard.img.tar.gz
    \end{minted}
  \end{block}
\end{itemize}
\end{frame}

\begin{frame}{Image customization}
  ELBE allows to
  \begin{itemize}
  \item Do various tweaks on the resulting filesystem from the XML
    file
  \item Add more files/directories to your rootfs with an overlay
  \item Add Debian packages to the image
  \item Build your own packages
  \item Add your packages to the delivery XML image file
  \end{itemize}
\end{frame}

\begin{frame}[fragile]{Customize: tune your rootfs/image}
  \begin{itemize}
    \begin{block}{}
      \fontsize{7}{7}\selectfont
\begin{minted}{xml}
<finetuning>
\end{minted}
    \end{block}
\item Copy or move files: bootloader and kernel images in
  \code{/boot}
  \begin{onlyenv}<2>
    \begin{block}{}
      \fontsize{7}{7}\selectfont
\begin{minted}{xml}
   <cp path="/usr/lib/u-boot/am335x_boneblack/MLO">/boot/MLO</cp>
   <cp path="/usr/lib/u-boot/am335x_boneblack/u-boot.img">/boot/u-boot.img</cp>
   <mv path="/usr/lib/linux-image-*-armmp/am335x-boneblack.dtb">/boot/am335x-boneblack.dtb</mv>
   <mv path="/boot/initrd.img-*-armmp">/boot/initrd.img-armmp</mv>
   <mv path="/boot/vmlinuz-*-armmp">/boot/vmlinuz-armmp</mv>
\end{minted}
    \end{block}
  \end{onlyenv}
  \item Use shell commands
    \begin{onlyenv}<3>
      \begin{block}{}
        \fontsize{7}{7}\selectfont
\begin{minted}{xml}
   <command>echo "uenvcmd=setenv bootargs 'console=ttyO0,115200 root=/dev/mmcblk0p2';
 load mmc 0:1 0x84000000 vmlinuz-armmp;load mmc 0:1 0x82000000 am335x-boneblack.dtb;
 load mmc 0:1 0x88000000 initrd.img-armmp;bootz 0x84000000 0x88000000:\${filesize} 0x82000000" >
 /boot/uEnv.txt</command>
\end{minted}
      \end{block}
    \end{onlyenv}
  \item Remove useless files/directories to shrink the image size
    \begin{onlyenv}<4>
      \begin{block}{}
        \fontsize{7}{7}\selectfont
\begin{minted}{xml}
  <rm>/var/cache/apt/archives/*.deb</rm>
  <rm>/var/cache/apt/*.bin</rm>
  <rm>/var/lib/apt/lists/ftp*</rm>
\end{minted}
      \end{block}
    \end{onlyenv}
  \item Extract file from chroot in the initvm to the output build directory
    \begin{onlyenv}<5>
      \begin{block}{}
        \fontsize{7}{7}\selectfont
\begin{minted}{xml}
  <artifact>/usr/lib/u-boot/am335x_boneblack/MLO</artifact>
  <artifact>/boot/am335x-boneblack.dtb</artifact>
\end{minted}
      \end{block}
    \end{onlyenv}
      \begin{block}{}
        \fontsize{7}{7}\selectfont
\begin{minted}{xml}
</finetuning>
\end{minted}
      \end{block}
    \item \url{https://elbe-rfs.org/docs/sphinx/article-elbe-schema-reference.html#type-finetuning}
\end{itemize}
\end{frame}

\begin{frame}[fragile]{Customize: add an overlay to the image}
  \begin{itemize}
  \item An {\bf overlay} is a set of files/directories to copy over
    the root filesystem, at end of the build process
  \item Create the contents of the overlay
  \begin{block}{}
    \fontsize{9}{9}\selectfont
    \begin{minted}{bash}
$ mdkir -p overlay/etc/ssh/
$ cp ssh_config overlay/etc/ssh/
\end{minted}
  \end{block}
\item Load the overlay contents in the project. They will be stored
  base64-encoded into the XML file.
  \begin{block}{}
    \fontsize{9}{9}\selectfont
    \begin{minted}{bash}
$ ./elbe chg_archive project.xml overlay
$ cat project.xml
...
<archive>QlpoOTFBWSZTWcCETrAAASl/hciQAEBKd//wf+9d0f/v/+EAAIAIAAhQA9vTnIjbbt3GnQSimBCe
o00elJ6T8pMQ/VPKPUND1DQZAD1GNQaaJo0jU2qNE2o2iAZAPRBgmmgMIaASIkJiJk2qb0hqPQg0
...
gQQryzKUutO3vhovrNrCuxRapzudUWmgdIumfO9YPKi0aOFJL/i7kinChIYEInWA
</archive></ns0:RootFileSystem>
\end{minted}
  \end{block}
\end{itemize}
\end{frame}

\begin{frame}[fragile]{Customize: add a Debian package}
  \begin{itemize}
  \item Adding a Debian package from official repository is as easy as
    listing it in the \code{<pkg-list>} XML node.
  \begin{block}{\code{project.xml}}
    \fontsize{9}{9}\selectfont
    \begin{minted}{xml}
<pkg-list>
  <pkg>openssh-server</pkg>
</pkg-list>
    \end{minted}
  \end{block}
\end{itemize}
\end{frame}

\begin{frame}{Customize: build your packages}
  \begin{itemize}
  \item In addition to packages from the official Debian repository,
    one will often want to build custom packages
    \begin{itemize}
    \item For a bootloader or kernel image configured specifically for
      the platform
    \item For a customized variant of packages available in the
      official repositories
    \item For in-house/custom applications and libraries
    \end{itemize}
  \item The following steps must be followed
    \begin{enumerate}
    \item Follow the Debian packaging procedure by {\em debianizing}
      the source code.
    \item Add your {\em debianized} package to the image.
    \item Build your package with ELBE
    \end{enumerate}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]{Build your packages: debianize the source}
  \begin{itemize}
  \item For some well-known packages (U-Boot, Barebox, Linux), use the
    \code{debianize} command to generates some sane default providing a
    complete and usable \code{debian/} folder
  \item This command will show an UI that allows to set the configuration.
  \item The basics items are the version, the name, the Release state, the architecture,
the configurations and some information relative to the owner.
  \end{itemize}
\end{frame}

\begin{frame}[fragile]{Build your packages: debianize the source}
\begin{columns}
  \column{0.5\textwidth}
    \begin{block}{}
      \fontsize{9}{9}\selectfont
\begin{minted}{bash}
$ export PATH=$PATH:`pwd`
$ cd ../linux
$ elbe debianize
\end{minted}
    \end{block}
  \begin{onlyenv}<3>
    \begin{block}{}
      \fontsize{9}{9}\selectfont
\begin{minted}{bash}
$ ls debian
changelog
compat
control
copyright
linux-headers-4.14-kernel.install
linux-image-4.14-kernel.install
linux-libc-dev-4.14-kernel.install
postinst
postrm
preinst
prerm
rules
source
\end{minted}
    \end{block}
  \end{onlyenv}
  \column{0.5\textwidth}
  \begin{onlyenv}<2,3>
    \includegraphics[width=\textwidth]{debianize.png}
  \end{onlyenv}
  \end{columns}
\end{frame}

\begin{frame}[fragile]{Build your packages: debianize the source}
  \begin{itemize}
  \item For other packages, you have to do it manually by creating the required files for debianizing your package.
  \item The information about these files are in the following link
  \item \url{https://www.debian.org/doc/manuals/maint-guide/dreq.en.html}
  \item Use or inspire yourself from already debianized packages if you can
  \end{itemize}
\end{frame}


\begin{frame}[fragile]{Build your packages: build process}
  \begin{itemize}
  \item Packages are built using the Debian {\em pbuilder} tool, which
    builds inside a {\em chroot}. This {\em chroot} needs to be
    created once:
    \begin{block}{}
      \fontsize{7}{7}\selectfont
\begin{minted}{bash}
$ elbe pbuilder create --xmlfile=project.xml --writeproject=project.prj --cross
$ PRJ=$(cat project.prj)
\end{minted}
    \end{block}
  \item Go to the source directory of the package to build, create the
    output directory
    \begin{block}{}
      \fontsize{7}{7}\selectfont
\begin{minted}{bash}
$ cd ../linux
$ mkdir ../out
\end{minted}
    \end{block}
  \item Start the build. By default, uses native build with Qemu,
    \code{--cross} enables cross-building.
    \begin{block}{}
      \fontsize{7}{7}\selectfont
\begin{minted}{bash}
$ elbe pbuilder build --cross --project $PRJ --out ../out
\end{minted}
    \end{block}
  \item Grab the results from the \code{out} folder
    \begin{block}{}
      \fontsize{7}{7}\selectfont
\begin{minted}{bash}
$ ls ../out
linux-headers-4.14-kernel_1.0_armhf.deb
linux-image-4.14-kernel_1.0_armhf.deb
linux-libc-dev-4.14-kernel_1.0_armhf.deb
    \end{minted}
    \end{block}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]{Build your packages: add your packages to the image}
  \begin{itemize}
  \item When the \code{elbe pbuilder} command completes, the package
    is automatically added to the local repository in the {\em initvm}
    project directory (\$PRJ).
  \item You only need to add your package to the \code{<pkg-list>}
    node in the XML file to bring it into the image.
    \begin{block}{\code{project.xml}}
      \fontsize{9}{9}\selectfont
\begin{minted}{xml}
<pkg-list>
  <pkg>linux-image-4.14-kernel</pkg>
  <pkg>linux-headers-4.14-kernel</pkg>
</pkg-list>
\end{minted}
    \end{block}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]{Build your package: automatically build the package}
  \begin{itemize}
  \item The procedure describes so far, which uses \code{elbe
      pbuilder} manually is perfect during development
  \item Allows to quickly rebuild just the package that needs to be
    rebuilt
  \item For a final release, one will want a procedure that rebuilds
    everything: all packages, and the image.
  \item This can be done by adding a \code{<pbuilder>} node to the XML
    file:
    \begin{block}{\code{project.xml}}
      \fontsize{9}{9}\selectfont
\begin{minted}{xml}
<pbuilder>
  <git revision="xxx">git@github.com:kmaincent/linux.git</git>
</pbuilder>
\end{minted}
    \end{block}
  \item Currently, the build of packages described in the
    \code{<pbuilder>} node are built natively. There are patches on the
    mailing list to enable cross-compilation, which we have successfully
    used.
  \end{itemize}
\end{frame}

\begin{frame}[fragile]{Tip: avoid rebuilding packages}
  \begin{itemize}
  \item When creating a new project, you may not want to build all
    your packages if you already have them compiled.
  \item The \code{prjrepo upload} command allows to add existing
    \code{.deb} packages to the local repository of the project,
    saving build time.
    \begin{block}{}
      \fontsize{9}{9}\selectfont
\begin{minted}{bash}
$ ./elbe control create_project
/var/cache/elbe/0a7b1788-b2ab-4b53-9319-0a810dab30d9
$ PRJ="/var/cache/elbe/0a7b1788-b2ab-4b53-9319-0a810dab30d9"
$ ./elbe control set_xml $PRJ project.xml
$ cd ../out
$ find . -name "*.changes" | xargs -I '{}' elbe prjrepo upload_pkg $PRJ {}
$ cd -
$ ./elbe control build $PRJ
$ ./elbe control wait_busy $PRJ
\end{minted}
    \end{block}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]{SDK}
  \begin{itemize}
  \item ELBE can generate a SDK, which provides a cross-compiler and
    libraries to build code for the target.
  \item Provided as a self-extractible shell script, much like the
    Yocto Project SDK.
  \item \code{setup-elbe-sdk-arm-linux-gnueabihf-armhf-ubuntu-1.0.sh}
  \item Sometimes, it is necessary to add more packages to the SDK,
    for example Qt tools if the target system contains Qt:
    \begin{block}{\code{project.xml}}
      \fontsize{9}{9}\selectfont
\begin{minted}{xml}
<hostsdk-pkg-list>
  <pkg>qt5-qmake-bin</pkg>
  <pkg>qtbase5-dev-tools</pkg>
</hostsdk-pkg-list>
\end{minted}
    \end{block}
  \end{itemize}
\end{frame}

\begin{frame}{Conclusion and references}
  \begin{itemize}
  \item ELBE is an interesting and friendly build System
  \item A small xml file describe all your distribution
  \item The Distribution is customizable with your own packages
  \item References
    \begin{itemize}
    \item \url{https://elbe-rfs.org/}
    \item \url{https://elinux.org/images/e/e5/Using\_ELBE\_to\_Build\_Debian\_Based\_Embedded\_Systems.pdf}
    \item \url{https://wiki.dh-electronics.com/index.php/ELBE\_Overview}
    \end{itemize}
  \end{itemize}
\end{frame}

\questionslide

\end{document}
