Open Wide : Les outils pour le développement des systemes embarquesAlexandre LAHAYE
Découvrez comment l'utilisation maîtrisée des outils Open Source peut améliorer de façon significative l'efficience de vos équipes de développement et donc votre compétitivité.
Pour découvrir les autres présentations, rendez-vous sur notre site : http://ingenierie.openwide.fr/References/Conferences-techniques
These slides (in French language) explain how to build an embedded Linux distribution with reach features, without compromise on quality, using the tools offered by the Yocto Project.
They were presented in a seminar organized by Captronic in Aix en Provence, on May 15th, 2014
Concevoir un système Linux embarqué avec Yocto Project - Version réviséeChristian Charreyre
These slides (in French language) explain how to build an embedded Linux distribution with reach features, without compromise on quality, using the tools offered by the Yocto Project. This is the up to date version presented on December 4th, 2014.
Open Wide : Les outils pour le développement des systemes embarquesAlexandre LAHAYE
Découvrez comment l'utilisation maîtrisée des outils Open Source peut améliorer de façon significative l'efficience de vos équipes de développement et donc votre compétitivité.
Pour découvrir les autres présentations, rendez-vous sur notre site : http://ingenierie.openwide.fr/References/Conferences-techniques
These slides (in French language) explain how to build an embedded Linux distribution with reach features, without compromise on quality, using the tools offered by the Yocto Project.
They were presented in a seminar organized by Captronic in Aix en Provence, on May 15th, 2014
Concevoir un système Linux embarqué avec Yocto Project - Version réviséeChristian Charreyre
These slides (in French language) explain how to build an embedded Linux distribution with reach features, without compromise on quality, using the tools offered by the Yocto Project. This is the up to date version presented on December 4th, 2014.
NetBSD évolue constamment avec de nouvelles idées : The AnyKernel, gestionnaire de packages multiplate-formed pkgsrc, outil d'installation de paquet binaire pkgin, NetBSD Desktop project, NetBSD Logical Volume Manager (LVM) .NetBSD Veriexec subsystem, Common Address Redundancy Protocol (CARP) .
Cette conférence présentera NetBSD pour en détailler les points clés à travers sa dernière branche 6
Gestion des dépendances dans un projet PHP - Forum PHP 2012Jean-Marc Fontaine
Que ce soit un framework, des modules ou des libraires spécialisées, la plupart des application web modernes utilisent du code tiers. Ce code a son propre cycle de développement. Il faut donc pouvoir intégrer régulièrement les nouvelles versions sans pour autant perdre la maîtrise de son propre cycle. La tâche n'est pas aisée si elle n'a pas été été prévue dès la conception de l'application. Nous verrons différentes approches pour gérer les dépendances dont les gestionnaires de paquet du système d'exploitation, les liens externes dans les dépôts de code, les fichiers PHAR, l'installateur PEAR et le tout récent Composer.
Présentation au logiciel Eclipse et les outils de collaborations dont SVN. La deuxième partie est consacrée à la barre de développeur pour le
navigateur Firefox, on y retrouve les outils les plus utiles.
Les slides de la présentation faite par CIO Informatique Industrielle lors du salon Synergie NTIC, sur les utilisations de Linux en contexte embarqué et industriel
Créer sa distribution Linux embarqué avec Yocto ou AngströmChristian Charreyre
Création d'une distribution Linux embarqué riche à l'aide des outils de build de distribution Yocto et Angström : slides présentés lors du 5e meetup de Paris Embedded meetup
Open Wide : Les interfaces graphiques dans l'embarqueAlexandre LAHAYE
Cette nouvelle conférence a réuni plus de 30 professionnels de l'embarqué à Paris et plus de 60 à Toulouse qui ont pu découvrir différents outils permettant de construire des interfaces graphiques optimisées pour leurs plateformes matérielles.
Pour découvrir les autres présentations, rendez-vous sur notre site : http://ingenierie.openwide.fr/References/Conferences-techniques
Ce cours présente la notion de système d'exploitation et en particulier les Linux embarqués qui sont spécialement conçus pour des systèmes embarqués de haut niveau avec des processeurs à usage général (GPP) comme unité de calcul principale. Il explique ensuite comment Linux embarqué démarre, quelles sont les différentes phases et modalités de stockage du système d'exploitation. Enfin, il présente la BeagleBone Black, ses caractéristiques et comment la programmer. Le cours conclut en expliquant la notion de driver de périphérique et comment ils sont conçus sous Linux à l'aide de fichiers.
Yocto une solution robuste pour construire des applications à fort contenu ap...Christian Charreyre
Ce document est la présentation effectuée par CIO Informatique Industrielle lors de la conférence "Yocto et Linux, un couple d'avenir" du salon RTS 2013
Beaucoup de personnes ont entendu parler de Linux, savoir si cela peut être utile pour vous devient alors une autre réalité qu'il est possible d'imaginer en terme de productivité et de sécurité comme station de
travail;
Décider de tester Linux est déjà un grand pas. C'est également le début pour découvrir quelle « distro » est faite en fonction de vos besoins.
Virtualiastion des systèmes d'exploitations :
Installation et administration
Journée Logiciel Libre à la Faculté des Sciences Dhar El Mahraz.
Par KHAMILICH Jamal
NetBSD évolue constamment avec de nouvelles idées : The AnyKernel, gestionnaire de packages multiplate-formed pkgsrc, outil d'installation de paquet binaire pkgin, NetBSD Desktop project, NetBSD Logical Volume Manager (LVM) .NetBSD Veriexec subsystem, Common Address Redundancy Protocol (CARP) .
Cette conférence présentera NetBSD pour en détailler les points clés à travers sa dernière branche 6
Gestion des dépendances dans un projet PHP - Forum PHP 2012Jean-Marc Fontaine
Que ce soit un framework, des modules ou des libraires spécialisées, la plupart des application web modernes utilisent du code tiers. Ce code a son propre cycle de développement. Il faut donc pouvoir intégrer régulièrement les nouvelles versions sans pour autant perdre la maîtrise de son propre cycle. La tâche n'est pas aisée si elle n'a pas été été prévue dès la conception de l'application. Nous verrons différentes approches pour gérer les dépendances dont les gestionnaires de paquet du système d'exploitation, les liens externes dans les dépôts de code, les fichiers PHAR, l'installateur PEAR et le tout récent Composer.
Présentation au logiciel Eclipse et les outils de collaborations dont SVN. La deuxième partie est consacrée à la barre de développeur pour le
navigateur Firefox, on y retrouve les outils les plus utiles.
Les slides de la présentation faite par CIO Informatique Industrielle lors du salon Synergie NTIC, sur les utilisations de Linux en contexte embarqué et industriel
Créer sa distribution Linux embarqué avec Yocto ou AngströmChristian Charreyre
Création d'une distribution Linux embarqué riche à l'aide des outils de build de distribution Yocto et Angström : slides présentés lors du 5e meetup de Paris Embedded meetup
Open Wide : Les interfaces graphiques dans l'embarqueAlexandre LAHAYE
Cette nouvelle conférence a réuni plus de 30 professionnels de l'embarqué à Paris et plus de 60 à Toulouse qui ont pu découvrir différents outils permettant de construire des interfaces graphiques optimisées pour leurs plateformes matérielles.
Pour découvrir les autres présentations, rendez-vous sur notre site : http://ingenierie.openwide.fr/References/Conferences-techniques
Ce cours présente la notion de système d'exploitation et en particulier les Linux embarqués qui sont spécialement conçus pour des systèmes embarqués de haut niveau avec des processeurs à usage général (GPP) comme unité de calcul principale. Il explique ensuite comment Linux embarqué démarre, quelles sont les différentes phases et modalités de stockage du système d'exploitation. Enfin, il présente la BeagleBone Black, ses caractéristiques et comment la programmer. Le cours conclut en expliquant la notion de driver de périphérique et comment ils sont conçus sous Linux à l'aide de fichiers.
Yocto une solution robuste pour construire des applications à fort contenu ap...Christian Charreyre
Ce document est la présentation effectuée par CIO Informatique Industrielle lors de la conférence "Yocto et Linux, un couple d'avenir" du salon RTS 2013
Beaucoup de personnes ont entendu parler de Linux, savoir si cela peut être utile pour vous devient alors une autre réalité qu'il est possible d'imaginer en terme de productivité et de sécurité comme station de
travail;
Décider de tester Linux est déjà un grand pas. C'est également le début pour découvrir quelle « distro » est faite en fonction de vos besoins.
Virtualiastion des systèmes d'exploitations :
Installation et administration
Journée Logiciel Libre à la Faculté des Sciences Dhar El Mahraz.
Par KHAMILICH Jamal
Open Wide accompagne ses clients depuis plus de 10 ans sur le choix des plateformes embarquées et propose de partager son expérience à travers cette conférence organisée par CapTronic. Nous aborderons également l’impact du matériel pour le choix du système d'exploitation.
PHP Composer : Pourquoi ? Comment ? Et plus ...Romain Cambien
Présentation de la gestion de dépendance grâce à Composer. Comment l'installer et le principales commandes à connaitre. Présentation et demonstration du projet Toran Proxy.
Depuis quelques années Git s'est imposé comme le système de gestion de sources de référence. Simple, rapide , souple, il convient à la fois aux workflows traditionnels et aux workflows distribués. Après une introductions aux principes fondateurs de Git le stagiaire aura l'occasion d'apprendre à créer son premier repository git et à le manipuler localement avant de le partager avec les autres. La formation insistera sur la gestions des branches et la résolution des conflits et sur les commandes permettant d'aborder ces problématiques sereinement. A l'issue de cette formation le stagiaire sera autonome pour utiliser Git aussi bien individuellement qu'au sein d'une équipe.
Outils de construction pour la rechercheJohan Moreau
Le but de cette présentation est de découvrir les outils de construction d’applications dans le contexte d’un laboratoire de recherche : autoconf, cmake, scons
Bien que Docker soit facile d'utilisation, construire une image reste un exercice compliqué.
Optimisation, layers, et sécurité nécessitent de s'abstraire des Dockerfile basiques qu'on peut trouver sur internet.
Dans ce BBL, nous verrons comment bien packager une application Spring Boot dans une image Docker/OCI.
Nous allons parcourir les bonnes pratiques préconisées par Spring, les pièges à éviter, comment bien écrire un Dockerfile pour optimiser la construction et l'image finale pour une exécution dans Kubernetes et nous verrons aussi des moyens alternatifs de construction d'images Spring Boot et l'outillage d'analyse à ajouter à votre toolbox.
Après avoir conquis le marché des smartphones et tablettes, Android devient incontournable dans le domaine industriel. Son utilisation pour la conception de solutions embarquées industrielles soulève toutefois des problématiques techniques spécifiques : customisation de l'OS, développement de pilotes de périphériques, capacité à répondre à des contraintes temps réel.
S'appuyant sur son expertise des technologies Linux embarqué, Open Wide Ingénierie a accompagné avec succès la réalisation de nombreux systèmes sur mesure. Les experts du pôle Mobilité et Multimédia partage leur expérience à travers cette présentation en abordant les sujets techniques indispensables avant de migrer vers Android.
Oxalide Workshop #4 - Docker, des tours dans le petit bassinLudovic Piot
Oxalide Workshop #4 - Docker, des tours dans le petit bassin
4ème workshop @Oxalide, animé par Julien Follenfant, Théo Chamley (@MrTrustor) et Ludovic Piot (@lpiot), le 24 mai 2016.
Une entrée en matière sur la technologie Docker et son écosystème à date : pourquoi un tel engouement, à quel point Docker s'inscrit parfaitement dans la démarche DevOps…
Un TP sur le montage d'un cluster ElasticSearch avec le Dockerfile.
Une démo de kubernetes.
Subject: Oxalide's workshop about an overview of Docker and its ecosystem.
Date: 24-mai-2016
Speakers: Julien Follenfant (@Oxalide), Théo Chamley (@MrTrustor, @Oxalide) and Ludovic Piot (@lpiot, @Oxalide)
Language: french
Lien SpeakerDeck : https://speakerdeck.com/lpiot/oxalide-workshop-number-4-docker-des-tours-dans-le-petit-bassin
Lien SlideShare : http://www.slideshare.net/LudovicPiot/workshop-4-docker-des-tours-dans-le-petit-bassin
YouTube Video capture: https://youtu.be/xJuRS6QYAAk
Main topics:
* Introduction 15 min (Ludovic Piot)
** D’où vient Docker ?
** Les principales caractéristiques de Docker
*** POrtable (package)
*** DIsposable (cattle vs. pet)
*** LIve (git style)
*** SOcial (registry / Github style)
* Hands-on #1 - Mon premier container (Julien Follenfant 35 min)
** Un tour d’horizon de DockerHub
** Installation de Docker Toolbox
** Création d’un Dockerfile (outil stand-alone)
** Introspecter un container
** Configurer un container
** Monter un cluster Elasticsearch 3 nœuds
* Comment ça marche ? (Théo Chamley 20 min)
** Namespaces & cgroups
** Layered FS (les poupées russes)
** Cache Image
** Networking
** Volumes
* Nouvelles collaborations (Ludovic Piot 10 min)
** CaaS (infra + cluster de containers vs. containers + appli)
* Ecosystème 20 min
** Les produits Docker, inc. (Ludovic Piot)
** Les alternatives (CoreOS, OpenContainer Initiative, Warden/Garden) (Ludovic Piot)
** La registry (Docker Registry, Nexus) (Ludovic Piot)
** L’autodiscovery (Consul, etcd, ZooKeeper) (Ludovic Piot)
** Les composants réseaux (haproxy, traefik, zipnish) (Julien Follenfant)
** Les orchestrateurs (kubernetes (Théo Chamley), Mesos/Marathon, Swarm, Fleet) (Ludovic Piot)
** Les solutions PaaS/CaaS intégrées (OpenShift, Rancher (Théo Chamley), Deis, CloudFoundry) => screenshots (Ludovic Piot)
** Les services de cloud publics (AWS ECS et ECR, GKE) (Ludovic Piot)
* Demo - utilisation de Kubernetes 15 min (Théo Chamley)
* Questions / Réponses
Oxalide Workshop #4 - Docker, des tours dans le petit bassinOxalide
4ème workshop @Oxalide, animé par Julien Follenfant, Théo Chamley (@MrTrustor) et Ludovic Piot (@lpiot), le 24 mai 2016.
Une entrée en matière sur la technologie Docker et son écosystème à date : pourquoi un tel engouement, à quel point Docker s'inscrit parfaitement dans la démarche DevOps…
Un TP sur le montage d'un cluster ElasticSearch avec le Dockerfile.
Une démo de kubernetes.
Main topics:
* Introduction 15 min (Ludovic Piot)
** D’où vient Docker ?
** Les principales caractéristiques de Docker
*** POrtable (package)
*** DIsposable (cattle vs. pet)
*** LIve (git style)
*** SOcial (registry / Github style)
* Hands-on #1 - Mon premier container (Julien Follenfant 35 min)
** Un tour d’horizon de DockerHub
** Installation de Docker Toolbox
** Création d’un Dockerfile (outil stand-alone)
** Introspecter un container
** Configurer un container
** Monter un cluster Elasticsearch 3 nœuds
* Comment ça marche ? (Théo Chamley 20 min)
** Namespaces & cgroups
** Layered FS (les poupées russes)
** Cache Image
** Networking
** Volumes
* Nouvelles collaborations (Ludovic Piot 10 min)
** CaaS (infra + cluster de containers vs. containers + appli)
* Ecosystème 20 min
** Les produits Docker, inc. (Ludovic Piot)
** Les alternatives (CoreOS, OpenContainer Initiative, Warden/Garden) (Ludovic Piot)
** La registry (Docker Registry, Nexus) (Ludovic Piot)
** L’autodiscovery (Consul, etcd, ZooKeeper) (Ludovic Piot)
** Les composants réseaux (haproxy, traefik, zipnish) (Julien Follenfant)
** Les orchestrateurs (kubernetes (Théo Chamley), Mesos/Marathon, Swarm, Fleet) (Ludovic Piot)
** Les solutions PaaS/CaaS intégrées (OpenShift, Rancher (Théo Chamley), Deis, CloudFoundry) => screenshots (Ludovic Piot)
** Les services de cloud publics (AWS ECS et ECR, GKE) (Ludovic Piot)
* Demo - utilisation de Kubernetes 15 min (Théo Chamley)
* Questions / Réponses
Open Wide Ingénierie a présenté les différents types de licences existantes ainsi que leurs éventuelles répercussions. Par méconnaissance, ce sujet peut être un frein à l'adoption du libre dans certaines sociétés, il est donc incontournable.
Pour découvrir les autres présentations, rendez-vous sur notre site : http://ingenierie.openwide.fr/References/Conferences-techniques
Similaire à Distro Recipes 2013 : Yocto / OpenEmbedded (20)
Kernel Recipes 2019 - Driving the industry toward upstream firstAnne Nicolas
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-NMIAnne Nicolas
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 kernelAnne Nicolas
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 moneyAnne Nicolas
In I.T. we all use all kinds of metrics. Operations teams rely heavily on these, especially when things go south. These metrics are sometimes overrated. Let’s dive into a few real life stories together.
Aurélien Rougemont
Kernel Recipes 2019 - Kernel documentation: past, present, and futureAnne Nicolas
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...Anne Nicolas
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 dataAnne Nicolas
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...Anne Nicolas
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 BareboxAnne Nicolas
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 specialAnne Nicolas
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 SiliconAnne Nicolas
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) pictureAnne Nicolas
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 wayAnne Nicolas
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 matchmakerAnne Nicolas
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 integrationAnne Nicolas
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 debuggingAnne Nicolas
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 multimediaAnne Nicolas
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 startedAnne Nicolas
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 XDPAnne Nicolas
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)Anne Nicolas
System memory configuration is a transparent operation nowadays, something that we all came to expect to just work out of the box. Still, it does happen behind the scenes every single time we boot our computers. This requires the cooperation of hardware components on the mainboard and on memory modules themselves, as well as firmware code to drive these. While it is possible to just let it happen, having a deeper understanding of how it works makes it possible to access valuable information from the operating system at run-time.
I will take you through the history of system memory configuration from the mid 70s to now. We will explore the different types of memory modules, how their configuration data is stored and how the firmware can access them. We will see which problems had to be solved along the way and how they were solved. Lastly we will see how Linux supports reading the memory configuration information and what you can do with that information.
Jean Delvare
Kernel Recipes 2019 - Marvels of Memory Auto-configuration (SPD)
Distro Recipes 2013 : Yocto / OpenEmbedded
1. Introduction à Yocto / OpenEmbedded
Pierre Ficheux (pierre.ficheux@openwide.fr)
Avril 2013
Yocto / OpenEmbedded 1
2. Présentation Open Wide
● SSII/SSLL créée en septembre 2001 avec Thales et
Schneider
● Indépendante depuis 2009
● Environ 110 salariés sur Paris, Lyon et Toulouse
(depuis janvier 2012)
● Industrialisation de composants open source
● Trois activités :
– OW Système d'Information (Java/PHP)
– OW Outsourcing: hébergement
– OW Ingénierie: informatique industrielle
Yocto / OpenEmbedded 2
3. Présentation PF
● Utilisateur de logiciels libres depuis 1989
● Utilisateur de Linux depuis 1992
● Auteur des 4 éditions de l'ouvrage « Linux embarqué »
(Eyrolles), 4ème édition parue en juin 2012
● Auteur GNU Linux Magazine et Open Silicium
● CTO Open Wide Ingénierie, enseignant EPITA
Yocto / OpenEmbedded 3
4. Programme
● Créer une distribution embarquée
● Introduction à OpenEmbedded
● Yocto Project(s)
● Construction d'une distribution pour Raspberry Pi
● Exemple de recette simple (Hello World)
● Démonstration sur RPi
Yocto / OpenEmbedded 4
5. Créer une distribution
« embarquée »
● Choisir un outil commercial (Wind River, Montavista)
● Utiliser un outil de génération : Buildroot,
OpenEmbedded, OpenWrt, LTIB
● Adapter une distribution Linux classique
– Souvent limité au niveau matériel
– Empreinte mémoire et flash importante
– Temps de démarrage
● Créer la distribution « from scratch »
– Approche plutôt « pédagogique »
– Difficile/impossible à industrialiser → dépendances,
mise à jour
Yocto / OpenEmbedded 5
6. Les principaux outils disponibles
● OpenEmbedded
– Moteur écrit en Python (bitbake)
– Puissant mais lourd
– Basé sur des fichiers de configuration (?)
● Buildroot
– Basé sur la commande make
– Au départ un démonstrateur pour uClibc
– Bon outil mais pas de gestion de paquets
– Utilisé par Google Fiber project
● OpenWrt
– Dérivé de BR + gère les paquets IPK
– Orienté vers les IAD (Internet Access Device)
● Autres: LTIB (Freescale), PTXdist (Pengutronix)
Yocto / OpenEmbedded 6
7. OpenEmbedded, introduction
● OE est une « généralisation » de l'approche utilisée
dans BR → framework de compilation croisée
● Démarrage en 2003 pour OpenZaurus
● Utilise un moteur écrit en Python (bitbake) et un
ensemble de règles utilisant un principe d'héritage →
recipe (recette = fichier .bb)
● Gère la notion de paquet binaire, contrairement à
BR (IPK, RPM, DEB)
● Plusieurs milliers de paquets disponibles
● Par contre :
– Peu d'interfaces de configuration (en cours)
– Processus de compilation plus lourd qu'avec BR
● Très utilisé dans l'industrie (Yocto Project)
Yocto / OpenEmbedded 7
8. Yocto Project(s)
● Le projet « chapeau » le plus important autour de OE
(Poky, Eglibc, Hob, Matchbox, infrastructures de test,
QA, …)
● Contributions Intel, Wind River, Montavista, Mentor
Graphics, … (20 participants officiels)
● Architecte : Richard Purdie → rejoint la Linux
Foundation en tant que « fellow » en décembre 2010
● Organisation similaire à celle de l'équipe du noyau
Linux
« meritocracy presided over by a benevolent dictator »
● Forte présence d'Intel mais l’engagement de la
fondation Linux permet une collaboration fructueuse ;-)
Yocto / OpenEmbedded 8
9. Yocto Project(s), suite
● Utilisé par les éditeurs pour leurs produits commerciaux
● Utilisé par les fabricants de matériel pour les BSP
(Board Support Package)
● Pas réellement une « distribution » mais fournit des
templates et outils pour créer des distributions
– Support matériel (meta-intel, meta-raspberrypi)
– Portage de composants (meta-mono)
– Distributions (meta-yocto, meta-angstrom)
– Couches « métier » (meta-ivi) → GENIVI
It's not an embedded Linux distribution
– it creates a custom one for you
● Poky est le projet « distribution de référence »
– Poky 8.0 (danny) succède Poky 7.0 (denzel)
Poky 8.0 (Yocto Project 1.3 Reference Distro)
Yocto / OpenEmbedded 9
10. Quelques distributions
● Angstrom (meta-angstrom)
– Distribution basée sur OE, fait partie du projet Yocto
depuis 9/2012
– Approche binaire similaire aux distributions
classiques
● Arago (meta-arago-distro)
– Fournie par TI (OMAP)
● ELDK (meta-eldk)
– Embedded Linux Development Kit, Denx Software
● De plus en plus d'acteurs du domaine se rapprochent
de Yocto Project !
http://git.eukrea.fr
Yocto / OpenEmbedded 10
11. Métadonnées OE
● Les recettes (.bb) décrivent la manière de compiler un
paquet (ou plusieurs) pour la cible
$ bitbake ma_recette
● Un .bb peut décrire UN composant mais également
une distribution complète
● Les classes (.bbclass) décrivent des règles
communes aux recettes (comment traiter Autotools,
CMake, …)
● Les fichiers de configuration (.conf), définissent les
paramètres de la distribution cible (type de machine,
nombre de processus en parallèle, …)
● Extrait de conf/local.conf
BB_NUMBER_THREADS = "8"
PARALLEL_MAKE = "-j 8"
MACHINE ?= "raspberrypi"
Yocto / OpenEmbedded 11
12. Métadonnées OE
● Les recettes (.bb) décrivent la manière de compiler un
paquet (ou plusieurs) pour la cible :
$ bitbake ma_recette
● Un .bb peut décrire UN composant mais également
une distribution complète
● Les classes (classes/*.bbclass) décrivent des
règles communes aux recettes (autotools, cmake,
module, ...)
● Les fichiers de configuration (.conf), définissent les
paramètres de la distribution cible (poky.conf,
local.conf, ...)
● Extrait de conf/local.conf
BB_NUMBER_THREADS = "8"
PARALLEL_MAKE = "-j 8"
MACHINE ?= "raspberrypi"
Yocto / OpenEmbedded 12
13. Métadonnées OE, suite
● OE est rarement utilisé seul
● Il fournit les « métadonnées » principales (OE-Core)
permettant de construire des distributions
● Les autres couches (layers) sont disponibles sur :
http://layers.openembedded.org/layerindex
● OE fournit cependant des recettes pour des images de
test simples (QEMU)
$ cd meta/recipes-core/images/
$ ls -1 *.bb
build-appliance-image.bb
core-image-base.bb
core-image-minimal.bb
core-image-minimal-dev.bb
core-image-minimal-initramfs.bb
core-image-minimal-mtdutils.bb
Yocto / OpenEmbedded 13
14. Bitbake
● L’outil bitbake permet de créer un composant OE
allant du simple paquet à une distribution complète :
$ bitbake vim
$ bitbake core-image-minimal
$ bitbake rpi-basic-image
● Il parcourt les fichiers de configuration afin de
déterminer quels sont les composants à construire en
fonction des recettes
● L’outil est équivalent à make dans le cas de Buildroot
● Pour chaque paquet: fetch, unpack, patch, configure,
compile, stage, install, package, ...
Yocto / OpenEmbedded 14
15. Installation Yocto/OE pour RPi
● Installation de Poky (Yocto reference distro)
$ git clone git://git.yoctoproject.org/poky
● Installation de la couche RPi (meta-raspberrypi)
$ cd poky
$ git clone git://git.yoctoproject.org/meta-raspberrypi
● Création du répertoire de travail
$ . ./oe-init-build-env rpi-build
● Ajout de la couche RPi à conf/bblayers.conf
BBLAYERS ?= "
...
<path>/poky/meta-raspberrypi
"
● Ajout du type de machine à conf/local.conf
MACHINE ?= "raspberrypi"
Yocto / OpenEmbedded 15
16. Production d'une image de test
● Les archives des paquets sont stockées dans rpi-
build/downloads lors de l'étape fetch
● La couche RPi fournit une image de test dérivée de
core-image-minimal
$ ls -1 meta-raspberrypi/recipes-core/images/
rpi-basic-image.bb
rpi-hwup-image.bb
● On produit l'image par :
$ bitbake rpi-basic-image
● Par défaut, Poky utilise le format de paquet RPM (voir
conf/local.conf)
● L'image de la SD est produite automatiquement
● Environ 50 mn sur un 16 CPU Xeon mais 12h sur un
Core2 Duo...
Yocto / OpenEmbedded 16
17. Répertoires produits
● Le répertoire rpi-build/downloads contient les
archives téléchargées (à partager !)
● Le répertoire rpi-build/tmp est utilisé comme
« sortie » avec les sous-répertoires deploy et work
$ ls -1 deploy
images noyau et archives (root-fs) produits
ipk paquets IPK
$ ls -1 linux-raspberrypi
licenses COPYING
rpm paquets RPM generic_GPLv2
Yocto / OpenEmbedded 17
18. Répertoires produits, suite
● Le répertoire tmp/work fournit d'autres informations :
– Contenu du root-filesystem
– Liste des paquets installés
– Traces de construction
$ ls -1 work/raspberrypi-poky-linux-gnueabi/rpi-
basic-image/1.0-r0/
image-version-info bin
installed_pkgs.txt boot
dev
... etc log.do_populate_lic
... log.do_populate_lic.13363
rootfs var log.do_rootfs
temp log.do_rootfs.13927
log.do_rootfs.16374
...
Yocto / OpenEmbedded 18
19. Ajustement de la configuration
● La configuration peut être ajustée à plusieurs niveaux :
– Configuration locale conf/local.conf
– Recettes (.bb)
● Modification local.conf pour utiliser IPK
PACKAGE_CLASSES ?= "package_ipk"
● Ajout de « features » → x11, tools-debug, nfs-server, ...
IMAGE_FEATURES (dans la recette)
EXTRA_IMAGE_FEATURES (dans local.conf)
IMAGE_FEATURES += "ssh-server-dropbear splash"
● Suppression des répertoires de construction (work) !!
INHERIT += "rm_work"
Yocto / OpenEmbedded 19
20. Ajustement de la configuration, suite
● Par défaut la base RPM/IPK/DEB n'est pas disponible
sur l'image, voir core-image-minimal.bb
# remove not needed ipkg informations
ROOTFS_POSTPROCESS_COMMAND += "remove_packaging_data_files ; "
● On ne peut donc pas ajouter/supprimer des paquets
– Commenter la ligne précédente
– Ajouter à la configuration de la cible la ligne :
{EXTRA_}IMAGE_FEATURES += "package-management"
● La distribution RPM est deux fois plus volumineuse que
la version IPK !
Filesystem Size Used Available Use% Mounted on
/dev/root 290.5M 125.3M 150.2M 45% /
/dev/root 290.5M 53.5M 222.0M 19% /
Yocto / OpenEmbedded 20
21. Création du SDK
● On peut créer la chaîne croisée et produire un script
d'installation automatique
$ bitbake meta-toolchain
● On installe le SDK par :
$ ./tmp/deploy/sdk/poky-eglibc-x86_64-arm-toolchain-1.3+snapshot-
20130212.sh
...
Extracting SDK...done
Setting it up...done
SDK has been successfully set up and is ready to be used.
● Accès au SDK par :
$ source <path>/environment-setup-armv6-vfp-poky-linux-gnueabi
$ arm-poky-linux-gnueabi-gcc -v
...
Thread model: posix
gcc version 4.7.2 (GCC)
Yocto / OpenEmbedded 21
22. Exemple de recette (simple)
● L'exemple est un paquet « Hello World » basé sur un
Makefile générique (ni Autotools, ni CMake)
● Le fichier recette hello_1.0.bb est installé sur le
répertoire meta-raspberry/recipes-core/hello
● Les variables à définir sont :
– DESCRIPTION
– LICENSE
– LIC_FILES_CHKSUM
– PR Package Release
– SRC_URI
– SRC_URI[md5sum]
– SRC_URI[sha256sum]
Yocto / OpenEmbedded 22
24. Exemple de recette, suite
● L'archive des sources contient les fichiers suivants :
COPYING
hello_oe.c
Makefile
● Le Makefile doit contenir un but install utilisant la
variable DESTDIR :
install:
mkdir -p $(DESTDIR)/usr/bin
cp hello_oe $(DESTDIR)/usr/bin
● Construction du paquet par :
$ bitbake hello
Yocto / OpenEmbedded 24
25. Cas du paquet RPM
● L'archive .tar.gz est chargée sur le répertoire
downloads lors du fetch
● La compilation s'effectue sur :
tmp/work/armv6-vfp-poky-linux-gnueabi/hello
● Affichage du contenu du paquet
$ rpm -qpl tmp/deploy/rpm/armv6_vfp/hello-1.0-
r0.armv6_vfp.rpm
/usr
/usr/bin
/usr/bin/hello_oe
● On peut installer le paquet par la commande :
# rpm -ivh <path>/hello_1.0-r0_armv6-vfp.rpm
Yocto / OpenEmbedded 25
26. Cas du paquet IPK
● Affichage du contenu du paquet
$ dpkg -c tmp/deploy/ipk/armv6-vfp/hello_1.0-r0_armv6-vfp.ipk
drwxr-xr-x 0/0 0 2013-02-11 16:56 ./
drwxr-xr-x 0/0 0 2013-02-11 16:56 ./usr/
drwxr-xr-x 0/0 0 2013-02-11 16:56 ./usr/bin/
-rwxr-xr-x 0/0 2952 2013-02-11 16:56 ./usr/bin/hello_oe
● On installe le paquet par la commande :
# opkg install <path>/hello_1.0-r0_armv6-vfp.ipk
Yocto / OpenEmbedded 26
28. Conclusions
● Yocto/OpenEmbedded est un outil puissant mais
complexe
● La distribution produite est plus lourde que dans le cas
de Buildroot
● Niveau de complexité (taille) sur la RPi
– Raspian (Go)
– Poky (100 Mo si RPM, 50 Mo si IPK)
– Buildroot (20 Mo)
● On utilise Poky lorsque l'on veut une distribution
évoluée et non un firmware !
● Voir les démos sur la RPi
Yocto / OpenEmbedded 28
29. Bibliographie
● http://www.openembedded.org
● https://www.yoctoproject.org
● http://www.yoctoproject.org/docs/1.3/poky-ref-manual/poky-ref-
manual.html
● http://git.yoctoproject.org/cgit/cgit.cgi/poky/tree/meta/classes/core-
image.bbclass
● http://www.linuxfoundation.org/news-
media/announcements/2010/12/linux-foundation-appoints-new-fellow
● Chapitres 11 et 15 de l'ouvrage Linux embarqué, 4ème édition sur
http://www.editions-eyrolles.com/Livre/9782212134827/linux-embarque
● Démonstration OE sur carte Eukréa sur http://www.youtube.com/watch?
v=5VPB8LeCloM
● http://www.linuxembedded.fr/2011/08/ajouter-un-package-dans-
openembedded-en-5-minutes
Yocto / OpenEmbedded 29