Author: Thomas Petazzoni

Thomas Petazzoni is Bootlin's co-owner and CEO. Thomas joined Bootlin in 2008 as a kernel and embedded Linux engineer, became CTO in 2013, and co-owner/CEO in 2021. More details...

Android Builders Summit: day 2, and Yocto Developer Day

It’s now Thursday morning here in Redwood City, California, and I didn’t had the time yesterday morning to do a write-up about our second day at the Android Builders Summit. Hopefully the following write-up will give our readers some details about what happened during this day.

This second of Android Builders Summit was co-located with the Yocto Developer Day, and as my colleagues Maxime Ripard and Grégory Clément were attending the two tracks of Android Builders Summit, I decided that I would attend the Yocto Developer Day.

Yocto Developer Day

Yocto is an umbrella project that consists in creating an embedded Linux build system, called Poky and some associated development tools. Poky takes its roots into the OpenEmbedded community: it re-uses the bitbake recipe processor, and a set of recipes for building packages that are now shared between Yocto and OpenEmbedded through the openembedded-core repository. At Bootlin, we are strong contributors to the Buildroot build system, and we use it for many of our customer projects. However, being pushed very strongly by Intel and the Linux Foundation, Yocto is gaining traction, and the fact that Yocto provides stable releases every 6 months now makes it a lot more usable than OpenEmbedded, which had to be checked out through Git, leaving the user with the uncertainty on whether the version (s)he got would actually work or not. And moreover, Buildroot and Yocto are not really competing projects: Buildroot is a simple root filesystem image generator, while Yocto is more a cross-distribution generator, they target projects of different sizes.

I started attending the Yocto Developer Day with a general presentation talk about what Yocto is and why it is necessary. Nothing really new in this talk for someone who already uses embedded Linux build systems and understands the need for such tools. However, the thing that always surprises me is that the Yocto project claims everywhere to solve the fragmentation problem in the embedded Linux build system space (there are too many tools in this area) by creating the tool, and that they envision that in 5 years, everybody will link embedded Linux build with the Yocto project. It’s quite funny because at the moment, they have just created yet another build system 🙂 But it’s true that the project is gaining traction and seems to attract the SoC vendors, which is a good thing because having a standard build system is so much better than having crappy vendor-specific build systems.

Yocto Developer Day: Yocto introduction by Saul Wold from Intel
Yocto Developer Day: Yocto introduction by Saul Wold from Intel

The second talk, by Saul Wold, from Intel, went more into the details on how to use Yocto: what the different components are, how recipes are written, how configuration is defined, what tasks, images, recipes, etc are. I would have liked if the talk went a bit further into the details, but it gave a very good introduction to the Poky build system.

In the afternoon, I attended a hands-on session for new users to Yocto. The room setup was very impressive: about forty high-end PCs provided, each having a development board next to it. The first part of the hands-on session consisted in using Yocto to produce a basic filesystem image which we booted into Qemu. In order to solve the very long first build problem that all OpenEmbedded and Yocto users face, they had pre-built a number of packages and stored them into a shared state directory. Interestingly, the size of the Yocto output directory was about 30 GB, just to build an embedded Linux system with BusyBox and a few minor things. Once this was done, we went ahead in creating our own layer, in order to define our own image and its contents it terms of packages. We used it to add a graphical splashscreen, and I also extended it to include Dropbear into the build. The whole thing went quite well. One thing that worries me is that bitbake and the build process really looks like a black box, and it seems hard to understand what’s going on behind the scenes. With Buildroot, I am used to a very simple build system with which it is very easy to fully understand what’s going on. Here, even the people that give speeches about Yocto or deliver a bit of training, seem to not fully understand what’s going on. This impression is also validated by the complexity of the output directory (where all the build results are). But maybe it’s just a matter of spending some time using it and reading some code, but the fact that people that have been developing/using Yocto for a while still do not really understand its internals is a bit surprising. Or maybe it’s just a wrong impression on my side.

Yocto Developer Day: hands-on session starting
Yocto Developer Day: hands-on session starting

The next part of the hands-on was around the Eclipse integration of Yocto. First with ADT (Application Development Toolkit), which integrates the cross-development thing into Eclipse. Thanks to an agent running into the target, Eclipse is able to push the application binary to the target and start gdbserver on it, and therefore transparently start a debugging session for the user. I am not a big fan of Eclipse (I have been an Emacs user for a huge number of years), but it’s true that for people used to Integrated Development Environments, this ADT thing provides a quite nice experience. Then, we went ahead in trying to use HOB, which integrates into Eclipse the possibility of selecting which packages should be built and integrated into the image. Unfortunately, it seems it didn’t work for anybody (even though we were selecting the package in the GUI, it didn’t appear in the final filesystem image), but that wasn’t a big problem since I don’t really see the point in a tool such as HOB: editing configuration files is something that shouldn’t scare any embedded Linux developer.

Regardless of the contents of the hands-on, I was quite interested by how it was conducted. Instead of having some written lab instructions, and having everyone following, alone, those lab instructions, the instructor was simply demoing the various steps to be done on the video-projector screen, which we simply had to replicate. It makes the session quite interactive, with of course the drawback that everyone needs to progress at the same pace.

All in all, this Yocto Developer Day was interesting, and I hope to find some time soon to experiment further with Yocto.

Android Builders Summit

My colleagues attended multiple talks about Android during this second day of the conference. In the morning, they attended Headless Android, Towards a Standard Audio HAL for Android, Android on eMMC: Optimizing for Performance.

Android Builders Summit: Real-time Android
Android Builders Summit: Real-time Android

In the afternoon, Grégory attended the Real-Time Android talk, which he said, was interesting. It showed that it was possible to integrate the PREEMPT_RT patches together with the Android kernel modifications, and provide a system having real-time capabilities for native (C/C++) applications and still the nice aspect of the Android user interface. During the same slot, Maxime attended the Android Services Black Magic, given by Aleksandar (Saša) Gargenta from Marakana. As usual with the Gargenta brothers, the talk was highly interesting and gave a lot of detailed information about Android services.

Some other thoughts…

At the organization level, the conference organizers should make it clear in the conference program and flyer the location where the slides will be posted. At almost every talk there is someone that asked if and where the slides will be posted, and the speakers are sometimes a bit uncomfortable because there is no clearly identified place to post the slides. In the past years, it was made clear that the slides would be posted on the elinux.org wiki, but this year, things are very unclear. Moreover, it’s even more surprising since speakers are asked to post their slides into their Linux Foundation website account, but those slides are not being made visible. Maybe a good suggestion for the Linux Foundation would be to improve how slides are handled and posted online.

Another thought about the Android Builders Summit is the surprising absence of Google, the developer and maker of Android. Google sponsors the Embedded Linux Conference which takes place right after the Android Builders Summit, but they do not sponsor the Android Builders Summit. There is also no talk from Google developers, and I haven’t seen any Google person in the attendees. It’s even more surprising when we know that the conference takes place in a location about 18 minutes away by car from Google headquarters in Mountain View. Maybe Google doesn’t want to see Android being used in application areas other than phones and tablets?

First day at the Android Builders Summit

Yesterday was the first day at the Android Builders Summit 2012, here in Redwood City, near San Francisco, California. My colleagues Grégory Clément and Maxime Ripard as well as myself are fortunate to attend this conference, and the contents of the first day were really interesting.

Amongst others:

  • A talk from Karim Yaghmour, well-known for having worked on the original version of the Linux Trace Toolkit, on the Adeos patch, as well as for its activity around Android. He delivered a 30 minutes talk about Leveraging Linux’s history in Android, which covered the differences in architecture between a standard embedded Linux system and Android, as well as how to nicely integrate BusyBox or tools like the Linux Trace Toolkit into Android. The presentation was really impressive: in just 30 minutes, Karim covered a huge number of slides, and made several live demonstrations. It is also worth noting that Karim, following the direction that Bootlin has drawn 7 years ago, has decided to release his Android training materials under a Creative Commons BY-SA license.
  • A panel with multiple kernel developers and people involved in Android on how to integrate the specific Android kernel patches into the mainline kernel. Not many new things learned here: the issue with the Android patches is that they add a lot of new userspace-to-kernel APIs, and such code is much much harder to get in mainline than conventional driver or platform code, since such APIs need to be maintained forever. Interestingly, Zach Pfeffer from Linaro pointed out the fact that the major problems with Android integration these days are not due to the kernel patches, but rather to the horrible binary blobs and related drivers that are needed for 3D acceleration ARM SoCs (Systems On a Chip).
    Panel « Android and the Linux Kernel Mainline: Where Are We? »
    Panel « Android and the Linux Kernel Mainline: Where Are We? »
  • A talk from Marko Gargenta on how to customize Android. He explained how to expose a specific Linux kernel driver functionality to Android applications, through a native C library, the JNI mechanism and an Android service, with complete details in terms of source code and build system integration. This presentation, just like last year’s presentation from Marko, was absolutely excellent. A lot of content, very dynamic presentation, a lot of things learned.
  • A talk on how ADB (Android Debugger) works. The contents were really good as well here, with lots of details about the ADB architecture, some tips and tricks about its usage, and more. Unfortunately, the speaker was really not familiar with English, and most of its presentation was spent reading the slides. This is a bit unfortunate because the technical contents was really, really excellent. The slides are available at http://www.slideshare.net/tetsu.koba/adbandroid-debug-bridge-how-it-works.
  • Using Android in safety-critical medical devices. This talk was not about technical issues, but rather about the reason for using Android in medical devices (get those devices connected together and collect some data to learn more about medical practices, their efficiency and cost) and also the legal requirements to get such devices validated by the Food and Drugs Administration in the US. A lot of useful arguments on how to convince managers that Android and Linux in general are usable in safety-critical medical devices.
  • A talk about Over-The-Air updates in Android, which I didn’t attend, but my colleague Maxime Ripard and other attendees gave an excellent feedback about it. It detailed an advanced system for safely upgrading an Android system, using binary diffs and other techniques.
    Customizing Android by Marko Gargenta, Marakana
    Customizing Android by Marko Gargenta, Marakana
  • The talk about Integrating Projects Using Their Own Build System Into the Android Build System had a really promising title and abstract, but unfortunately, the contents were disappointing. The speaker took 25 minutes just to explain how to build BusyBox (outside of any Android context) and then another 20 minutes to explain how to integrate it in the Android build system, on unreadable slides.
  • The talk about Android Device Porting Walkthrough was really great. Benjamin Zores exhausted its time slot with a 1h15 talk instead of the 50 minutes slot allocated, but fortunately, it was the last talk of the day in this session. During this talk, Benjamin gave a huge amount of information and many details about various issues encountered in the process of adapting Android for an Alcatel business VoIP phone (the ones you see in business desks). Issues like filesystem layout, input subsystem configuration, touchscreen configuration, graphics and much much more were covered. Be sure to check out Benjamin slides at http://www.slideshare.net/gxben/android-device-porting-walkthrough.
  • Finally, the day ended with a lightning talk session moderated by Karim Yaghmour. Lightning talks are really nice, because in less than 5 minutes, you quickly hear about a project or an idea. When the speaker is not good or the topic uninteresting, you know that after 5 minutes, you’ll hear someone else speaking about a different topic. The lightning talk on the integration of GStreamer in Android was really interesting, as was the lightning talk from Karim about its CyborgStack initiative, which creates an upstream Android source to integrate all the Android modifications that will never be mainlined by Google. See Karim slides at http://www.cyborgstack.org/sites/default/files/cyborgstack-120213.pdf for details.

And now, it’s time for breakfast, before the conferences of the second day of this Android Builders Summit.

Bootlin at the Android Builders Summit and the Embedded Linux Conference: one talk and video recording

A good part of the Bootlin team will be in San Francisco (actually, not in San Francisco, but in the Bay Area) from February, 13th to 17th for the Android Builders Summit and the Embedded Linux Conference.

Android Builders Summit 2012
Android Builders Summit 2012

The Android Builders Summit is the second edition of this conference dedicated to Android system development (and not application development). Compared to last year, the conference has been extended to three parallel tracks during two days. There are many talks about Android customization, Android internals, Android porting, usage of Android in specific markets (medical devices, vehicle infotainment), etc. A lot of useful talks for developers working at the Android system level.

Embedded Linux Conference 2012
Embedded Linux Conference 2012

The Embedded Linux Conference is now a well-established conference. Again for this 2012 edition, there will be three parallel tracks during three days. There will be talks about many, many topics: performance and optimization, power management, build systems, drivers for various types of devices, multimedia, ARM kernel support and much more.

I will be giving a talk about Buildroot: A Nice, Simple and Efficient Embedded Linux Build System on the second day of the conference. The aim of the talk is to give a status on where Buildroot is, three years after a maintainer was chosen and a big clean up work was started. The project has changed a lot compared to its state three years ago, so I thought it would be nice to make a status on where Buildroot and where it is going.

With my colleagues Grégory Clément and Maxime Ripard, we will also record all the talks from the Embedded Linux Conference in order to put the videos online, freely available, after the conference, as we have done for many past conferences.

We hope to meet you in San Francisco for the Android Builders Summit and the Embedded Linux Conference!

Announcing our “Android System Development” training

Android RobotFor multiple years, Bootlin has provided two typical training courses for embedded Linux developers: an Embedded Linux system development course that focuses on the basics for embedded Linux development (bootloader and kernel configuration, compiling and usage, system integration and build systems, cross-compiling, filesystems, application development and debugging, etc.) and an embedded Linux kernel and driver development course that focuses on kernel and driver development (kernel APIs for drivers, character drivers, device model, power management, kernel porting, etc.). In total, we have given dozens of editions of these sessions in multiple locations all around the world. We have kept our commitment to release all the training materials under a free license (the Creative Commons CC-BY-SA license), and they are therefore freely accessible for anyone at /docs/.

We are now announcing a new course, called Android System Development. It is a four day training session that targets engineers who need to develop embedded systems with Google Android.

Through theory and practical labs, the course makes you familiar with compiling and booting Android, with adapting Android to support a new embedded board (assuming that it is already supported by the Linux kernel), and with building a real system through accessing specific hardware, customizing the filesystem and using debugging techniques. See the complete agenda. The training materials for this session will also be made available under the same Creative Commons CC-BY-SA license.

If you are interested in this training session, you can:

  • Join the public session organized in Toulouse, France, on June 11-14, 2012.
  • Order an on-site training session to be held at your location. See registration details.

This training course will be given by our engineer Maxime Ripard who has gained Android experience by working at Archos on Android tablets, by making Android work on multiple TI OMAP3 based platforms and also by participating to the Android Builders Summit conference.

Do not hesitate to contact us for further details about this new training course.

Bootlin at FOSDEM: two talks and video recording

I'm going to FOSDEMAs usual, Bootlin will again be present at the FOSDEM conference in Brussels, on February, 4th and February 5th. We will of course mostly be attending the Embedded DevRoom, with multiple talks around development in the embedded space.

We will also be giving two talks this year:

  • My colleague Maxime Ripard will be giving a talk about IIO, a new subsystem for I/O devices. In short, IIO is a new subsystem in the kernel to write drivers for devices like Analog-to-Digital converters. Maxime has worked on a driver inside the IIO subsystem for the internal ADCs of the AT91 processors from Atmel, and will base his talk mostly on the experience developing this driver. This talk will take place on Saturday, 12:00 AM to 1:00 PM in the Lameere room.
  • I will be giving a talk on Using Qt for non-graphical applications. It is a talk that has already been given at the Embedded Linux Conference Europe, but the audience of FOSDEM and ELCE being quite different, we have chosen to propose it for FOSDEM as well, and it got accepted. This talk will take place on Sunday, 1:00 PM to 2:00 PM in the Lameere room.

There are also other talks that are worth noting: a SoC power management talk from Jean Pihet who works on OMAP power management support in the Linux kernel, a talk about OpenCores and OpenRISC, a talk about Safe Upgrade of Embedded Systems by Arnout Vandecappelle, who contributes a lot to Buildroot, and also other talks about OpenWRT, Yocto, licensing issues in Android, the EFL libraries, and more.

We will also be carrying our camcorder to video record those talks. We are trying to see with the FOSDEM organization team if it possible to record the audio directly from the room sound systems in order to provide better audio quality in our videos.

If you happen to be at FOSDEM, we’d be very happy to meet you!

Buildroot Developer Day, Brussels edition

BuildrootAround each FOSDEM conference and Embedded Linux Conference Europe event, we have been organizing a Buildroot Developer Day for a few years, in order to gather some developers and users of the Buildroot build system, in order to discuss the development of Buildroot, its features, development process, design, and more.

In Prague at the last Embedded Linux Conference Europe in October 2011, we had a very interesting meeting that gathered developers from other build systems (OE-lite, OpenBricks and PXTdist), and we published a report of this meeting.

The next Buildroot Developer Day will take place on Friday, 3rd February, just before the FOSDEM conference, in Brussels. This is the first meeting that will gather such a number of Buildroot developers: Peter Korsgaard (Buildroot maintainer), Arnout Vandecapelle (developer from Essensium/Mind, who has been contributing a lot to Buildroot lately), Thomas De Schampheleire (also a big contributor in the last year or so), Luca Ceresoli, Yann E. Morin (developer of Crosstool-NG), my colleague Maxime Ripard (who contributed package enhancements and improvements of the package infrastructure) and myself.

This meeting is open to all Buildroot developers and users, and will take place in a location easily accessible in the center of Brussels. Do not hesitate to contact me at thomas.petazzoni@bootlin.com if you want to take part to this meeting.

mkenvimage: a tool to generate a U-Boot environment binary image

Many embedded devices these days use the U-Boot bootloader. This bootloader stores its configuration into an area of the flash called the environment that can be manipulated from within U-Boot using the printenv, setenv and saveenv commands, or from Linux using the fw_printenv and fw_setenv userspace utilities provided with the U-Boot source code.

This environment is typically stored in a specific flash location, defined in the board configuration header in U-Boot. The environment is basically stored as a sequence of null-terminated strings, with a little header containing a checksum at the beginning.

While this environment can easily be manipulated from U-Boot or from Linux using the above mentioned commands, it is sometimes desirable to be able to generate a binary image of an environment that can be directly flashed next to the bootloader, kernel and root filesystem into the device’s flash memory. For example, on AT91 devices, the SAM-BA utility provided by Atmel is capable of completely reflashing an AT91 based system connected through the serial port of the USB device port. Or, in factory, initial flashing of devices typically takes place either through specific CPU monitors, or through a JTAG interface. For all of these cases, having a binary environment image is desirable.

David Wagner, who has been an intern with us at Bootlin from April to September 2011, has written a utility called mkenvimage which just does this: generate a valid binary environment image from a text file describing the key=value pairs of the environment. This utility has been merged into the U-Boot Git repository (see the commit) and will therefore be part of the next U-Boot release.

With mkenvimage you can write a text file uboot-env.txt describing the environment, like:

bootargs=console=ttyS0,115200
bootcmd=tftp 22000000 uImage; bootm
[...]

Then use mkenvimage as follows:

./tools/mkenvimage -s 0x4200 -o uboot-env.bin uboot-env.txt

The -s option allows to specify the size of the image to create. It must match the size of the flash area reserved for the U-Boot environment. Another option worth having in mind is -r, which must be used when there are two copies of the environment stored in the flash thanks to the CONFIG_ENV_ADDR_REDUND and CONFIG_ENV_SIZE_REDUND. Unfortunately, U-Boot has chosen to have a different environment layout in those two cases, so you must tell mkenvimage whether you’re using a redundant environment or a single environment.

This utility has proven to be really useful, as it allows to automatically reflash a device with an environment know to work. It also allows to very easily generate a different environment image per-device, for example to contain the device MAC address and/or the device serial number.

Buildroot 2011.11 released: details on new features

As planned, Buildroot 2011.11 has been released at the end of November. You can download this release as a tarball or through the Git repository.

This release brings a set of new features on which I thought it would be nice to give some details.

The file and local site method

Each package in Buildroot defines from where the source code for the particular component being built is fetched. Buildroot has of course always supported fetching a tarball from HTTP of FTP servers. Later on, Buildroot has added support for fetching from Git, Subversion and Bazaar repositories, for example by doing:

MYPKG_SITE = http://somelocation.com/svn/foobar/trunk
MYPKG_SITE_METHOD = svn

or

MYPKG_SITE = git://somelocation.com/foobar.git

The <pkg>_SITE_METHOD variable allows to define the fetching method. When not specified, Buildroot tries to guess it from the <pkg>_SITE value. Of course, in ambiguous cases such as Subversion or Git repositories over HTTP (as shown in the first example), the <pkg>_SITE_METHOD must be specified.

This new version of Buildroot brings two new site methods: file and local.

The file site method allows to specify the location of a local tarball as the source code for the component to be built. For example:

MYPKG_SITE = /opt/software/something-special-1.0.tar.gz
MYPKG_SITE_METHOD = file

This can be useful for internal software that isn’t publicly available on a HTTP or FTP server or in a revision control system. This new site method was added by David Wagner, who has been an intern at Bootlin between April and September this year.

The new local site method allows to specify the location of the source code to be built as a local directory. Buildroot will automatically copy the contents of this directory into the build directory of the component and build it from here. This is very useful because it allows to version control your source code as you wish, make changes to it, and easily tell Buildroot to rebuild your component. Note that the copy is using rsync so that further copies are very fast (see the pkg-reconfigure and pkg-rebuild targets below). An example of using the local site method:

MYPKG_SITE = /opt/software/something-special/
MYPKG_SITE_METHOD = local

This new site method has been implemented by myself, as the result from my experience of using Buildroot with various Bootlin customers.

The source directory override mechanism

The local site method described above is great for packaging special components that are specific to the embedded device one is working on, like the end-user application, or special internal libraries, etc.

However, there are cases where it is needed to work with a specific version of an open-source component. This is typically the case for the Linux kernel or the chosen bootloader (U-Boot, Barebox) or with other components. In that case, one may want to keep using Buildroot to build those components, but tell Buildroot to fetch the source code from a different location than the official tarball of the component. This is what the source directory override mechanism provide.

For example, if you want Buildroot to use the source code of the Linux kernel from /opt/project/linux/ rather than download it from a Git repository or as a tarball, you can write the following variable definition in a board/company/project/local.mk file:

LINUX_OVERRIDE_SRCDIR = /opt/project/linux

Then, you reference this file through the BR2_PACKAGE_OVERRIDE_FILE option, in Build options -> location of a package override file. When building the Linux kernel, Buildroot will copy the source code from /opt/project/linux into the kernel build directory, output/build/linux-VERSION/ and then start the build process of the kernel.

Basically, this mechanism is exactly like the local site method described previously, except that it is possible to override the source directory of a package without modifying the package .mk file, which is nice for open-source packages supported in Buildroot but that require local modifications.

To summarize, here is my recommendation on how to use Buildroot for packages that require project-specific modifications:

  • You are using an existing open-source component on which you make some tiny bug fixes or modifications. In this case, the easiest solution is to add additional patches to the package directory, in package/<thepackage>/.
  • You are using an existing open-source component, but are making major changes to it, that require proper version control outside of Buildroot. In this case, using the source directory override feature is recommended: it allows to keep the Buildroot package .mk file unmodified while still using your custom source code for the package.
  • You have project-specific libraries or applications and want to integrate them in the build. My commendation is to version control them outside of Buildroot, and then create Buildroot packages for them using the local site method. Note that in the pkg_SITE variable, you can use the $(TOPDIR) variable to reference the top source directory of Buildroot. I for example often use MYAPP_SITE = $(TOPDIR)/../myapplication/.

The <pkg>-rebuild and <pkg>-reconfigure targets

For a long time, when one wanted to completely rebuild a given package from scratch, a possibility was has been to remove its build directory completely before restarting the build process:

rm -rf output/build/mypackage-1.0/
make

Or, using the -dirclean target available for each package:

make avahi-dirclean
make

As these commands remove completely the build directory, the build process is restarted from the beginning: extracting the source code, patching the source code, configuring, compiling, installing.

In 2011.11, we have added two new per-package targets to make it easy to use Buildroot during the development of components:

  • make mypkg-reconfigure will restart the build process of mypkg from the configuration step (the source code is not re-extracted or repatched, so modifications made to the build directory are preserved)
  • make mypkg-rebuild will restart the build process of mypkg from the compilation step (the source code is not re-extracted or repatched, the configuration step is not redone)

So, a typical usage could be:

emacs output/build/mypkg-1.0/src/foobar.c
make foobar-rebuild

However, beware that all build directories are removed when you do make clean, so the above example is only useful for quick testing of changes.

The case where the -reconfigure and -rebuild are really useful is in combination with the local site method or the source override directory mechanism. In this case, when pkg-reconfigure or pkg-rebuild is invoked, a synchronization of the source code is done between the source directory and the build directory is done before restarting the build.

Let’s take the example of a package named mypkg for which package/mypkg/mypkg.mk contains:

MYPKG_SITE = /opt/mypkg
MYPKG_SITE_METHOD = local

Then, to work on your package, you can simply do

emacs /opt/mypkg/foobar.c    # Edit as usual your project
make mypkg-rebuild           # Synchronizes the source code from
                             # /opt/mypkg to the build directory
                             # and restart the build

Integration of real-time extensions

In this 2011.11, an interesting addition is the integration of the Xenomai and RTAI real-time extensions to the Linux kernel. The Xenomai integration was initially proposed by Thomas de Schampheleire and then extended by myself, and I have also added the RTAI integration. This integration allows to seamlessly integrate the kernel patching process and the compilation of the required userspace libraries for those real-time extensions.

Conversion of the documentation to asciidoc

Back in 2004, one of my first contribution to Buildroot was to start writing documentation. At the time, the amount of documentation was small, so a single and simple HTML document was sufficient. Nowadays, Buildroot documentation has been extended significantly, and will have to be extended even further in the future. The approach of a single raw HTML document was no longer up to the task.

Therefore, I have worked on converting the existing documentation over to the asciidoc format. This allows us to split the source of the documentation in several files, for easier edition, and allows to generates a documentation in multiple formats: single HTML, split HTML, raw text or PDF.

Just run make manual in Buildroot 2011.11 to generate the manual. Note that the version available on the website is still the old HTML version, but it should soon be updated to the new asciidoc version.

Bootlin contributions

Bootlin has again contributed to this Buildroot release:

$ git shortlog -sen 2011.08..2011.11 | head -12
   126	Peter Korsgaard
   104	Gustavo Zacarias
    62	Thomas Petazzoni, from Bootlin
    27	Yann E. MORIN
    21	Sven Neumann
    13	Yegor Yefremov
    10	Thomas De Schampheleire
     7	H Hartley Sweeten
     5	Frederic Bassaler
     4	Arnout Vandecappelle (Essensium/Mind)
     4	Maxime Ripard, from Bootlin
     3	Baruch Siach

Our contributions have been:

  • Implementation of the source directory override mechanism
  • Implementation of the local and file site methods
  • Implementation of the pkg-rebuild and pkg-reconfigure targets
  • Conversion of the documentation to asciidoc and documentation improvements
  • Various improvements for external toolchain support: optimization of the toolchain extraction and copy (reduced build time), integration of the support of the CodeSourcery x86 toolchains, update of all CodeSourcery toolchains to the latest available versions
  • Removed useless arguments from the CMAKETARGETS, AUTOTARGETS and GENTARGETS macros, used by all packages in Buildroot. Instead, such pieces of information are automatically figured out from the package .mk file location in the source tree
  • Added the cifs-utils package (for mounting CIFS network filesystems), the libplayer package, the picocom package.
  • Cleanup, improve and merge the Xenomai integration done by Thomas de Schampheleire, and implement the RTAI integration
  • Did a lot of cleanup in the source tree by creating a new support/ directory to contain various tools and scripts needed by Buildroot that were spread over the rest of the tree: the kconfig source code, the special libtool patches, various scripts, etc.

Next release cycle and next Buildroot meeting

The next release cycle has already started. After the meeting in Prague, it was decided that Peter Korsgaard (Buildroot maintainer) would maintain a next branch between the -rc1 and the final version of every release, in order to keep merging the new features for the next release while debugging the current release. This next branch for 2012.02 has already been merged. For example, the addition of the scp and Mercurial site methods has already been merged for 2012.02, as well as numerous other package updates.

On my side, besides usual package updates, I’d like to focus my work for this 2012.02 cycle on improving the testing coverage and on improving the documentation. My colleague Maxime Ripard is working on integrating systemd into Buildroot, as an alternate init mechanism.

The Buildroot community will also be organizing its next meeting in Brussels, on Friday February, 3rd 2012, right before the FOSDEM conference. Buildroot users and developers are invited to join, just contact us through the Buildroot mailing list.

Embedded Linux Conference Europe 2011 videos

One week after the end of the Embedded Linux Conference Europe 2011, we are pleased to release the videos of all talks that took place during this event. We would like to thank the Linux Foundation for allowing us to record those talks and to share freely the resulting videos on-line, and also thank the Clarion Congress Hotel technical staff for helping us with technical details related to video recording.

Below, you’ll find 51 videos, in both a 1920×1080 HD format and a reduced 800×450 format. In total, it represents 28 GB of video, for a duration of 2214 minutes, that is more of 36 hours of video. We hope that you will enjoy those videos and that these will be useful to those who couldn’t attend the conference.

Jim ZemlinVideo capture
Executive Director of The Linux Foundation
Imagine a World Without Linux
Video (24 minutes):
full HD (220M), 450×800 (76M)

Linus Torvalds, Alan Cox, Thomas Gleixner, Paul McKenneyVideo capture
moderated by Lennart Poettering
Kernel Developer Panel
Video (55 minutes):
full HD (622M), 450×800 (191M)

Zach PfefferVideo capture
Linaro
Linaro’s Android Platform
Video (45 minutes):
full HD (604M), 450×800 (164M)

Thomas GleixnerVideo capture
Linutronix
State of PREEMPT_RT
Video (46 minutes):
full HD (374M), 450×800 (147M)

Jessica ZhangVideo capture
Intel
The Yocto Project Eclipse plug-in: An effective IDE environment for both Embedded Application and System developers
Video (45 minutes):
full HD (431M), 450×800 (118M)

Satoru UedaVideo capture
Sony Corporation / Japan OSS Promotion Forum
Contributing to the Community? Does your Manager Support You?
Video (42 minutes):
full HD (556M), 450×800 (140M)

Benjamin ZoresVideo capture
Alcatel-Lucent
Embedded Linux Optimization Techniques: How Not To Be Slow
Slides
Video (44 minutes):
full HD (328M), 450×800 (125M)

Ohad Ben-CohenVideo capture
Texas Instruments
Remote Processor Messaging
Slides
Video (48 minutes):
full HD (433M), 450×800 (131M)

Jeff Osier-MixonVideo capture
Intel
Collaborative Initiatives in Embedded Linux
Video (26 minutes):
full HD (266M), 450×800 (73M)

Karim YaghmourVideo capture
Opersys Inc.
Leveraging Android’s Linux Heritage
Video (51 minutes):
full HD (419M), 450×800 (168M)

Pierre TardyVideo capture
Intel
Using pytimechart For Real World Analysis
Slides
Video (51 minutes):
full HD (495M), 450×800 (132M)

Arnd BergmannVideo capture
Linaro
Optimizations for Cheap Flash Media
Video (44 minutes):
full HD (524M), 450×800 (146M)

Vitaly WoolVideo capture
Sony Ericsson
Saving Power with Wi-Fi: How to Prolong Your Battery Life and Still Stay Connected
Slides
Video (50 minutes):
full HD (371M), 450×800 (143M)

David StewartVideo capture
Intel
Developing Embedded Linux Devices Using the Yocto Project and What’s new in 1.1
Slides
Video (47 minutes):
full HD (370M), 450×800 (124M)

Tetsuyuki KobayashiVideo capture
Kyoto Micro Computer
Android is NOT Just “Java on Linux”
Slides
Video (37 minutes):
full HD (542M), 450×800 (129M)

Thomas PetazzoniVideo capture
Bootlin
Using Buildroot For a Real Project
Slides
Video (55 minutes):
full HD (408M), 450×800 (156M)

Tim BirdVideo capture
Sony Network Entertainment
Status of Embedded Linux BoFs
Slides
Video (60 minutes):
full HD (877M), 450×800 (213M)

Lauro Ramos Venancio and Samuel OrtizVideo capture
Instituto Nokia de Tecnologia, Intel
The Linux NFC Subsystem
Slides
Video (31 minutes):
full HD (229M), 450×800 (87M)

David AndersVideo capture
Texas Instruments
Board Bringup: LCD and Display Interfaces
Slides
Video (39 minutes):
full HD (242M), 450×800 (98M)

Antti AumoVideo capture
President of Global Solutions at Ixonos
Re-Defining the Cloud Phone
Video (32 minutes):
full HD (360M), 450×800 (108M)

Dirk HohndelVideo capture
Chief Linux and Open Source Technologist at Intel
Reflection on 20 Years of Linux
Video (30 minutes):
full HD (235M), 450×800 (92M)

Grant LikelyVideo capture
Secret Lab
Device Tree Status Report
Video (51 minutes):
full HD (775M), 450×800 (178M)

Laurent PinchartVideo capture
Ideas on Board
Success Story of the Open-Source Camera Stack: The Nokia N9 Case
Slides
Video (48 minutes):
full HD (308M), 450×800 (120M)

Avinash Mahadeva and Vishwanth SripathyVideo capture
Texas Instuments
SOC Power Management – Debugging and Optimization Techniques
Video (41 minutes):
full HD (288M), 450×800 (108M)

Rafael J. WysockiVideo capture
Faculty of Physics, U. Warsaw / SUSE Labs
Power Management Using PM Domains on SH7372
Slides
Video (46 minutes):
full HD (692M), 450×800 (157M)

Sascha HauerVideo capture
Pengutronix e.K.
A Generic Clock Framework in the Kernel: Why We Need It and Why We Still Don’t Have It
Video (45 minutes):
full HD (345M), 450×800 (134M)

Ruud DerwigVideo capture
Synopsys
Android Platform Optimizations
Slides
Video (43 minutes):
full HD (266M), 450×800 (105M)

Inki DaeVideo capture
Samsung Electronics
DRM Driver Development For Embedded Systems
Slides
Video (22 minutes):
full HD (367M), 450×800 (91M)

Lorenzo PieralisiVideo capture
ARM Ltd.
Consolidating Linux Power Management on ARM Multiprocessor Systems
Slides
Video (46 minutes):
full HD (283M), 450×800 (113M)

Thomas PetazzoniVideo capture
Bootlin
Using Qt For Non-Graphical Applications
Slides
Video (49 minutes):
full HD (340M), 450×800 (124M)

Marek Szyprowski and Kyungmin ParkVideo capture
Samsung Electronics
ARM DMA-Mapping Framework Redesign and IOMMU Integration
Slides
Video (49 minutes):
full HD (790M), 450×800 (195M)

Keerthyd Jagadeesh and Vishwanath SripathyVideo capture
Texas Instruments
Thermal Framework for ARM based SOCs
Video (42 minutes):
full HD (316M), 450×800 (113M)

Marc TitingerVideo capture
ST Microelectronics
Efficient JTAG-Based Linux Kernel Debugging
Slides
Video (57 minutes):
full HD (382M), 450×800 (141M)

Tsugikazu ShibataVideo capture
NEC and Linux Foundation Board Member
Toward the Long Term Stable Kernel tree for The Embedded Industry
Video (32 minutes):
full HD (606M), 450×800 (145M)

Lisko LappalainenVideo capture
MontaVista Software
Secure Virtualization in Automotive
Video (40 minutes):
full HD (301M), 450×800 (116M)

Jeff Osier-MixonVideo capture
Intel
Yocto Project Community BoFs
Video (60 minutes):
full HD (451M), 450×800 (167M)

Jon CorbetVideo capture
Editor at LWN.net
The Kernel Report: 20th Anniversary Edition
Video (28 minutes):
full HD (218M), 450×800 (88M)

Wim CoekaertsVideo capture
Senior Vice President, Linux and Virtualization Engineering at Oracle
Engineered Systems With Linux
Video (21 minutes):
full HD (175M), 450×800 (68M)

Andrea GalloVideo capture
ST-Ericsson
ARM Linux Kernel Alignment and Benefits For Snowball
Slides
Video (47 minutes):
full HD (394M), 450×800 (133M)

Liam Girdwood and Peter UjfalusiVideo capture
Texas Instruments
Smart Audio: Next-Generation ASoC For Smart Phones
Video (50 minutes):
full HD (367M), 450×800 (124M)

Pawel MollVideo capture
ARM Ltd.
Linux on Non-Existing SoCs
Video (52 minutes):
full HD (483M), 450×800 (143M)

Koen KooiVideo capture
The Angstrom Distribution
Integrating systemd: Booting Userspace in Less Than 1 Second
Slides
Video (44 minutes):
full HD (343M), 450×800 (125M)

Sylvain Leroy and Philippe ThierryVideo capture
Grsecurity in Embedded Linux Used in Android Operating System
Slides
Video (40 minutes):
full HD (384M), 450×800 (110M)

MyungJoo HamVideo capture
Samsung Electronics
Charger Manager: Aggregating Chargers, Fuel-Gauges and Batteries
Slides
Video (33 minutes):
full HD (434M), 450×800 (109M)

Arnd BergmannVideo capture
Linaro
News From the ARM Architecture
Video (49 minutes):
full HD (421M), 450×800 (150M)

Frank RowandVideo capture
Sony Network Entertainment
How Linux PREEMPT_RT Works
Slides
Video (45 minutes):
full HD (378M), 450×800 (135M)

Catalin MarinasVideo capture
ARM Ltd.
Linux Support for the ARM Large Physical Address Extensions
Slides
Video (52 minutes):
full HD (594M), 450×800 (170M)

Jim HuangVideo capture
0xlab
Build Community Android Distribution and Ensure the Quality
Video (44 minutes):
full HD (472M), 450×800 (143M)

Till JaegerVideo capture
JBB Rechtsanwälte
The Case AVM v. Cybits: The GPL and Embedded Systems
Video (42 minutes):
full HD (362M), 450×800 (124M)

Darren HartVideo capture
Intel
Tuning Linux For Embedded Systems: When Less is More
Slides
Video (45 minutes):
full HD (482M), 450×800 (135M)

Wolfram SangVideo capture
Pengutronix e.K.
Developer’s Diary: It’s About Time
Video (49 minutes):
full HD (482M), 450×800 (141M)

Report from the Buildroot Developer Day

Right after the Embedded Linux Conference Europe, a new edition of the Buildroot Developer Day took place on Saturday, 29th October 2011 in Prague.

Unlike past Buildroot Developer Day that were followed only by Buildroot developers and Yann E. Morin as the crosstool-NG maintainer, this edition of the Buildroot Developer Day was followed by developers of other build systems: Robert Schwebel from PTXdist, Esben Haabendal from OE-lite and we also had the opportunity to discuss with Benjamin Zores and Davide Calvalca from OpenBricks. This made the day very interesting, even though if it was a bit less focused on Buildroot than expected.

I have written and sent a complete report of the discussions, which were about the following topics:

  • Expanding the send-patches.org initiative. This was an important topic, as developers of several build systems had the opportunity to discuss it during this meeting.
  • The testing infrastructure of Buildroot, how to improve it.
  • Package management. A long requested feature for Buildroot, but which would make Buildroot a lot more complicated and probably less reliable. Following this meeting, our position is to not implement such a feature and to keep Buildroot simple. Should package management be necessary, there are other build systems that implement such a feature (at the expense of higher complexity, of course).
  • Toolchain backend. We will soon switch to using the crosstool-NG backend as the default method of building toolchains in Buildroot. Long term, we would like to get rid of the code that builds a toolchain in Buildroot in order to factorize the efforts at the level of the crosstool-NG project.
  • Migration of the documentation to the asciidoc format has been accepted, and the next version of Buildroot will feature this updated documentation.
  • Out-of-tree build of packages. This is a very internal question to how Buildroot builds package. See the report for details.
  • Website improvement, because the current Buildroot website is quite ugly.
  • Maintenance process. We are seeing a quite significant increase in the number of contributions to Buildroot and some of these contributions are taking more and more time to get integrated. We discussed the topic and came up with a few proposals on how to improve the situation.
  • Host packages visible in menuconfig. Traditionally, packages built for the host are not user-selectable as Buildroot since they are just dependencies to build target packages. However, we had the case of some host packages that should be user-selectable. The principle has been agreed upon.
  • Per-package device file handling. A mechanism proposed by Maxime Ripard, from Bootlin, to allow each package to specify special permissions/owernships/device files to install in the target filesystem.
  • Relocatable toolchain and SDK. Buildroot produces a SDK (set of utilities and libraries to build applications for the target independently from Buildroot), but this SDK is currently not relocatable. We discussed the various issues to fix to make it relocatable.
  • Licensing report generation, which is also a feature that has been requested in the past.

All in all, it was a very interesting and motivating day, that got closed by a short visit of Prague’s center and a nice dinner. The next edition of the Buildroot Developer day will take place on Friday, 3rd 2012 in Brussels, the day before the FOSDEM conference. It is open to all Buildroot users and developers!

Regarding Buildroot itself, the maintainer Peter Korsgaard will release 2011.11-rc1 early next week, and 2011.11 by the end of November. This release will have several new useful features, which we will cover in details in a future blog post.