Embedded and realtime systems are among the fastest growing fields of R&D where Free Software solutions become important. Operating System development has always been a very important topic in Free Software. As embedded and realtime systems typically have special OS requirements, we organise this Free Embedded and OS development track at the FOSDEM.

This track at FOSDEM provides a remarkable opportunity to present the ongoing work in these areas, and we invite developers to present their current projects.

The Program Committee evaluated the received abstracts and consists of:

List of abstracts for embedded and kernel development track at fosdem 2003 Sat 8th and Sun 9th Feb 2003, Brussels.

OpenCores is a repository of open source freely available Intellectual Property (IP) cores. It is the hardware counterpart of the free software movement. Currently OpenCores hosts 185 projects, maintained by 657 developers. Many projects are still in the development stage and some will never reach maturity. But 65 projects are currently mature enough to be used in designs.

In order to start development access to tools is required. For software development the GNU toolchain provides a solid foundation. For hardware development freely available tools are either not (yet) available, or simply not mature enough. Testing is an even bigger problem. Software can be tested on the same system it is being developed, by simply running the program. Hardware can be tested by running simulations, but testing IP cores in real hardware always requires some form of programmable logic. Fortunately FPGA vendors provide an array of test and development boards for their devices. Also the major FPGA vendors are releasing 'lite' versions of their synthesis and Place&Route tools. This proved to be a major boost for open source hardware projects.

IP cores need to be interconnected via a common bus. OpenCores adopted the 'WISHBONE System-on-Chip (SoC) Interconnect Architecture for Portable IP Cores', or WISHBONE bus for short. WISHBONE provides a common, logical interface between IP cores. This improves portability and reliability of the system, and results in faster time to market. Especially when combining a multitude of cores from different designers from different backgrounds. Currently OpenCores maintains stewardship over the WISHBONE standard.

To prove the concept of OpenCores and the quality of the cores available from OpenCores we created a System-on-Chip (SoC). All IP cores needed to build the SoC are available from OpenCores. The used cores include a 32bit RISC (OpenRISC), JTAG Test Access Port for the OpenRISC, memory controller, UART, 10/100 Ethernet MAC, VGA controller, PS/2 keyboard controller, and an AC97 audio controller.

The 32bit OpenRISC 1200 forms the heart of the SoC. It is the first available implementation of the OpenRISC 1000 architecture. The OpenRISC 1000 architecture is available under the GNU LGPL license.

Software development for the OpenRISC 1000 Architecture is supported by a genuine GNU Toolchain Port and an advanced Architectural Simulator. A uCLinux port is also available, RTEMS and Linux ports are under development.

To conclude the presentation a demo will be shown using the working System-on-Chip.

Traditionally, it has been common to develop a home grown operation system for embedded use. However, according to a study carried out by Evans Data Corporation, there is a shift towards adopting standard systems, in particular such based on embedded Linux. This is partly due to the fact that embedded systems are nowadays as powerful as desktop systems were not too long ago. While embedded systems still have unique requirements, they are now more comparable to desktop systems than ever. This suggests the possibility that a standard operating system and its applications can be taken and adapted for embedded usage. The focus will be on the changes required in Debian to be better suited for embedded use. In particular, crucial changes to Debian's powerful package management system, dpkg, will be discussed. For example, embedded systems must avoid installing files which occupy storage but do not provide required functionality. This includes documentation and translation files. The iPKG package manager, closely related to dpkg, but developed specifically to meet the needs to embedded systems, will be presented. Additionally, for embedded use, large applications have to be replaced by smaller programs with similar functionality. BusyBox, which combines tiny versions of many common UNIX utilities into a single small executable, is important in this regard. Also, it will be discussed what is needed to replace bash with dash, a POSIX compliant shell much smaller than bash. Alternatives to the powerful but big libc6 library, such as dietlibc, will be presented.

Portable programming is an important requirement for system level programming, especially in embedded systems. However, as CPU and system architectures have become more complex over the years, this is a growing challenge. System programmers have to cope with such things as noncoherent I/O, out of order memory accesses, various busses and address tranlations next to things like endianess mismatches and alignment issues. We will discuss these issues and give ideas on how to build a device driver framework to allow for portable system programming.

Wonka is a clean-room implementation of the Virtual Machine and class library specifications for Java, developed by Belgian company Acunia. It was developed specifically to meet Acunia's needs for Java in embedded and mobile systems. Wonka is Java2 compliant, and supports the CDC/FC profile plus some additional packages. A selective JIT compiler is currently under test.

Wonka is available under a BSD licence. In this presentation we will discuss some of the challenges involved in implementing a high level of Java functionality in an embedded context, and outline some current areas of development and research.

The Linux kernel is well known for its portability and extendability. One of the recent extensions is bringing realtime operating systems under the kernel hood so that realtime software can run on the same platform as the user(-space) programs. Examples are RTAI (www.rtai.org) and RTLinux (www.fsmlabs.com). Since realtime programs introduce a complexity far beyond device drivers, better programming methodologies become a must to control the realtime softwares complexity. The C++ programming language facilitates object oriented development and design, which can be used to manage complex programs. There are reports of realtime operating systems being written entirely in C++ (e.g. eCos).

I will introduce how the Linux kernel can be extended to support C++ to the extent that all C++ programs can be brought in the kernel, except for exceptions. A second logical step is to bring the standard C++ library into the kernel, which will also be explained.

What are the problems with cross-compiling programs that use GNU Autotools to configure themselves?

How these problems can be solved?

Autotools is used mostly by Linux desktop software (KDE, Gnome) which are normally compiled natively. Why one would want to have all that software on an embedded device? What are the requirements for embedded desktop system software and how they match to what Open Source can currently offer?

eCos is a highly configurable, portable, open source, royalty free Operating System for real time embedded applications. This presentation provides a brief, mainly technical, overview of eCos: its history, implementation, configuration system and future directions.

One of the key technological innovations in eCos is a highly sophisticated configuration system. The configuration system allows the application writer to impose their requirements on the run-time components, both in terms of their functionality and implementation. eCos provides both a graphical configuration tool that runs on both Windows and Linux, and a command line tool that can be used to automate the configuration process.

eCos is designed to be portable to a wide range of target architectures and target platforms including 16, 32, and 64 bit architectures, MPUs, MCUs and DSPs. The eCos kernel, libraries and runtime components are layered on the Hardware Abstraction Layer (HAL), and thus will run on any target once the HAL and relevant device drivers have been ported to the target's processor architecture and board. Currently eCos supports a large range of different target architectures (ARM, Intel StrongARM and XScale, Hitachi SH3/4, Intel x86, MIPS, Matsushita AM3x, NEC V850, Motorola PowerPC, SPARC and several others), including many of the popular variants of these architectures and evaluation boards.

eCos has been designed to support applications with real-time requirements, providing features such as full preemptability, minimal interrupt latencies, and all the necessary synchronization primitives, scheduling policies, and interrupt handling mechanisms needed for these type of applications. eCos also provides all the functionality required for general embedded application support including device drivers, memory management, exception handling, networking, file systems, standard C and math libraries, POSIX and uITRON compatibility etc.

To permit proprietary application code to be linked with eCos without itself being forced to be released under the GPL, eCos is distributed under the GPL license with an exception. It is also royalty and buyout free, making it an attractive alternative to license inhibited, closed source or commercial real-time operating systems.

RTAI is a GNU/Linux-based real-time interface for applications with strict timing constraints which has recently been ported over Adeos, a flexible environment for sharing hardware resources among concurrent operating systems.

We will discuss the process of migrating the RTAI core over the Adeos nanokernel, describing the pipelining scheme Adeos implements in order to dispatch hardware and system events to RTAI, so that real-time tasks have absolute priority over regular Linux activities.

We will conclude by considering the new paths this migration opens for extending RTAI while still keeping a high degree of determinism.

In understanding the needs of building current and next generation telephony services we have to consider that in the past such services were often built from proprietary realtime operating systems. Changes in the last 20 years in the power and capabilities of commercial off the shelf commercial platforms and free oper- ating systems have largely replaced the need for specialized proprietary realtime systems, but not the realtime requirements that still exist today. This paper is meant to provide an overview and introduction of the challenges and needs in providing realtime Linux services to support current and next generation telephone networks, but is not meant to be a rigorous analysis on the topic.