Thursday, October 9, 2008

Embedded Linux System Kernel Considerations

The kernel is the most fundamental software component of all Linux systems. It is responsible for managing the bare hardware within your chosen target system and bringing order to what would otherwise be a chaotic struggle between each of the many various software components on a typical system.

In essence, this means the kernel is a resource broker. It takes care of scheduling use of (and mediating access to) the available hardware resources within a particular Linux system. Resources managed by the kernel include system processor time given to programs, use of available RAM, and indirect access to a multitude of hardware devices— including those customs to your chosen target. The kernel provides a variety of software abstractions through which application programs can request access to system resources, without communicating with the hardware directly.

The precise capabilities provided by any particular build of the Linux kernel are configurable when that kernel is built. Kernel configuration allows you to remove support for unnecessary or obscure capabilities that will never be used. For example, it is possible to remove support for the many different networked filesystems from an embedded device that has no networking support. Conversely, it is possible to add support for a particular peripheral device unique to a chosen target system. Depending on their function, many capabilities can also be built into optional, runtime-loadable, modular components. These can be loaded later when the particular capability is required.

Most desktop or enterprise Linux vendors ship prebuilt Linux kernels as part of their distributions. Such kernels include support for the wide range of generic hardware devices typically available within modern consumer-grade or enterprise-level computing systems. Many of these capabilities are built into runtime-loadable modules, which are demand loaded by a variety of automated tools as hardware devices are detected. This one-size-fits-all approach allows Linux vendors to support a wide range of target systems with a single prebuilt binary kernel package, at the cost of a certain amount of generalization and the occasional performance impact that goes alongside it.

Unlike their desktop, server, or enterprise counterparts, embedded Linux systems usually do not make use of such all-encompassing prebuilt, vendor-supplied kernels. The reasons for this are varied, but include an inability for generic kernels to handle certain embedded, target-specific customizations, as well as a general underlying desire to keep the kernel configuration as simple as possible. A simpler configuration is both easier to debug and typically requires a reduced resource footprint when compared with its more generic counterpart. Building an embedded system from scratch is tough enough already without worrying about the many kernel capabilities you will never use.

Source of Information : OReilly Building Embedded Linux Systems

No comments: