RedBoot is a new embedded system debug/bootstrap environment from Red Hat. It is designed to replace the existing debug/boot tools CygMon and GDB stubs. It provides a complete bootstrap environment, including network downloading and debugging. It also provides a simple flash file system for boot images.



"RedBoot" may be thought of as an acronym for "Red Hat Embedded Debug and Bootstrap". RedBoot provides a wide set of tools for downloading and executing programs on embedded target systems, as well as tools for manipulating the target system's environment. It can be used for both product development (debug support) and for end product deployment (Flash and network booting). It is based on the eCos hardware abstraction layer (HAL).

Within the embedded industry, there exists no standard architecture or implementation for bootstrapping embedded computers. Because RedBoot is based on eCos, which is capable of running on many architectures, and because its debugging support is based on gdb, RedBoot can become a common embedded standard. Thus, RedBoot can provide a common basis for bootstrapping Embedded Linux, eCos, and many other operating systems.

RedBoot includes the following basic functionality:

• Remote debugging support -- connectivity between host and target systems over serial and Ethernet interfaces (gdb stubs)
  
  
• Simple command line interface -- available via serial or Ethernet
  
  
• Flash memory management -- download/update/erase of multiple flash boot images, boot direct from flash
  
  
• Network booting -- inc setup and download (bootp/dhcp, tftpboot)
  
  
• Attribute Configuration -- user control of aspects such as system
  time and date (if applicable), default Flash image to boot from, default failsafe image, static IP address, etc.
  
  
• Configurable and extensible -- easily adapted to the target environment
  
  
• Universality -- RedBoot supports GNUPro, eCos, and Embedded Linux use on the embedded target as well as other operating systems.

One of RedBoot's important benefits is that it includes support for -- and therefore enables -- remote debugging of the target board. Often, one has to use special devices hooked to embedded boards to debug the code running on them. This enables developers to run the debugger in a familiar host environment (e.g. the Linux desktop) that is remotely talking via a serial or Ethernet connection to the board from a desktop system, or from some remote machine over a network.

Supported platforms currently include: ARM, MIPS, MN10300, PowerPC, SH (Hitachi), NEC v850, and x86 (Intel architecture).

RedBoot currently provides three basic classes of commands:

• Program loading and execution
  
• Flash memory image and configuration management
  
• Miscellaneous commands

Of course, given the extensible and configurable nature of eCos and RedBoot, there may be more [or fewer] sets of commands available.

Although RedBoot is derived from eCos, it is not eCos but rather may be used as a generalized system debug and bootstrap control software for any embedded system and any operating system. For example, with appropriate additions, RedBoot could replace the commonly used BIOS of PC (and certain other) architectures. Red Hat is currently installing RedBoot on all embedded platforms as a standard practice, and RedBoot is now generally included as part of all Red Hat contracts for Embedded Linux and eCos ports.

Preliminary RedBoot documentation, including a draft of the RedBoot User Guide, is available on Red Hat's developer website. RedBoot documentation currently covers the following topics:

• RedBoot Overview
  
• How to install RedBoot on your hardware
  
• RedBoot commands and examples
  
• Building RedBoot from the supplied sources
  
• Configuring and extending RedBoot functionality -- including how to use RedBoot in a production environment, as opposed to its use for embedded computer development/debug.
  
• How to port RedBoot

Here are pointers to some currently available RedBoot information and documentation:

• RedBoot User's Manual -- the preliminary user's manual for RedBoot is available, in pdf format, here. It currently includes the following sections . . .
  Common commands
  Download Process
  Flash Image System
  Persistent state [flash-based configuration] control
  Program execution
  Installation and testing
  
  
• RedBoot Source Code -- the latest sources for RedBoot are part of the standard eCos source tree, which is available via anonymous CVS here.

Since RedBoot is an eCos package, you need only have the eCos sources to build it. Then, just enable/include the RedBoot package and you're done.

What's next?

Red Hat is presently working on adding such features as power-on-self-test (POST) and USB connectivity (including download and debug). Also, there are numerous ongoing ports to additional CPU and board architectures. Future enhancements will include incorporation of support for secure field upgrade of firmware and boot images remotely over the net, in a manner that will be compatible with Red Hat's new Red Hat Network.

Since announcing RedBoot, Red Hat has received strong interest in RedBoot from semiconductor companies and board manufacturers who are eager to provide a common, open source, portable, boot and debug solution that can support Embedded Linux and other OSes. Red Hat's aim is to make RedBoot an industry standard for embedded boot firmware -- both in the development and production environments.

---

Related stories:
Red Hat unveils embedded device startup/debug firmware
Red Hat announces Internet-based support infrastructure

Talkback:
    Do you have questions or comments on this article?   talkback here

Discuss RedBoot -- an open source boot/debug environment   >>> Be the FIRST to comment on this article!

>>> More Linux For Devices Articles Articles          >>> More By Rick Lehrbaum