FreeDOS-32

Introducing FreeDOS-32

FreeDOS-32 (or fd32 for short) is an open source operating system under development, primarily targetted towards embedded systems and real-time applications.

Some of its key features are:

MultiBoot technology

FreeDOS-32 is started using a MultiBoot boot loader, such as GNU GRUB. This means that, in order to install the operating system, you just need to copy its files in your file system and you are ready to go.

Hard real-time microkernel

The core of the operating system is a microkernel that provides deterministic, bounded in time operations. A simple scheduler controls execution of one or more threads and interrupts. Other operating system services are run in separate threads either in privileged or unprivileged modes.

Open-source license

FreeDOS-32 will be released under the GNU General Public License version 3, with an exception to allow its use as a whole in commercial applications, but excluding reuse of parts of it with a different proprietary operating system.

Portable, object-oriented design

A subset of the C++ language has been chosen to keep code clean and easy to study and maintain. FreeDOS-32 is developed on and for IA-32 (i386), but other ports planned, such as AMD64, ARM and ColdFire.

Simplicity and extensibility

By default everything runs in kernel mode, there is no memory protection, paging is disabled. The default environment can be changed or enhanced using appropriate modules.

API and ABI compatibility

Through appropriate modules, it will be possible to run applications and drivers written for other operating systems, starting from DOS protected mode programs.

Discover FreeDOS-32

As a modular operating system, FreeDOS-32 allows you to build your environment according to your needs. Here is the list of currently available modules, with a hint of their current development status.

  • Library
    • C library
    • C++ library
    • Utility library
  • Boot
  • Kernel
  • Memory management
    • Physical page allocator
    • Slab allocator
    • Subpage allocator
  • I/O
    • Floppy
    • ATA (IDE)
    • ATAPI (CD-ROM)
  • File system
    • FAT
    • LEAN
    • ISO 9660
  • ABI
    • DPMI

Hover your mouse on the list

to learn more about each module

C library

FreeDOS-32 provides a limited subset of the standard C library for use by operating system services and applications running in kernel mode.

If you are looking for memcmp or strlcpy (in the global namespace, if using C++), this is where you should look for.

C++ library

FreeDOS-32 provides a limited subset of the standard C++ library for use by operating system services and applications running in kernel mode.

Header files with standard names provide functionality commonly found in the std namespace, such as pairs, numeric limits, and C string functions.

Utility library

This is a collection of utility library developed for fd32. It includes template-based collections such as singly- and doubly-linked lists, hash tables and binary heaps, all using an intrusive paradigm to avoid relying on dynamic memory allocation.

Boot

The boot module is the first module that is ever exetuded when fd32 is started. It receives control from the Multiboot bootloader, sets up address spaces, interrupts and memory management, then loads and dynamically links any provided boot module and finally initializes the kernel to start actual system activity.

Currently, this module also includes the dynamic linker for object files in ELF format, in order to relocate and resolve symbols of passed Multiboot modules.

Kernel

The kernel is the core module of fd32. It provides functionality to run system services and applications as threads, and provides means to synchronize them, such as mutexes, semaphores and message queues.

A simple hard real-time scheduler controls which thread should be executed on a CPU at any given time. Tasks that would otherwise be carried on in interrupt context can be moved to thread context for maximum control and to keep interrupt latency at a minimum.

Physical page memory allocator

This module tracks allocation of physical memory chunks whose size is multiple of a memory page as specified by the architecture (typically 4 KiB).

This is the basic allocator that manages physical memory with a fairly high granularity. Other memory allocators can be built on top of it, for example to implement virtual memory, or allocators for chunks smaller than a page.

This is an efficient allocator that approximates a best-fit policy and operates is constant time.

Slab memory allocator

The slab memory allocator subdivides a memory page (typically 4 KiB) in smaller chunks all of the same size, letting clients allocate fairly precise amount of memory for small objects.

This approach avoids per-chunk overhead, because the chunk size is stored per-page, but may require several pages, perhaps only partially used, if chunks of several sizes are needed.

This is an efficient allocator using an exact-fit policy that operates is constant time, except when a new page is needed, in which case the complexity depends on the underlying page allocator.

Subpage memory allocator

This memory allocator subdivides a memory page (typically 4 KiB) in smaller chunks of arbitrary size, letting clients allocate fairly precise amount of memory for small objects.

Memory chunks of different sizes, either allocated or available, may exist in the same page. Each chunk has a 32-bit header that specifies its size and information to coalesce adjacent free chunks. This means that every chunk has a fixed absolute overhead of 4 bytes.

This is an efficient allocator that approximates a best-fit policy and operates is constant time, except when a new page is needed, in which case the complexity depends on the underlying page allocator.

Floppy disk driver

The floppy driver provides functionality to read and write legacy floppy disks.

ATA disk driver

Provides support for ATA (also known as IDE) disks, typically hard disks.

ATAPI disc driver

Provides support for ATAPI CD and DVD drives.

FAT file system

Provides read/write access to the ubiquitous Microsoft FAT file system, used by DOS and Windows systems and several embedded devices.

The three variants, FAT12, FAT16 and FAT32, are supported, and all with long file names (LFN).

LEAN file system

LEAN (backronym for Lean yet Effective Allocation and Naming, a play on the word FAT) is a free and simple file system created as part of the FreeDOS-32 project to provide an alternative to the proprietary -and partly patented- Microsoft FAT file system.

LEAN aims to be the simplest file system providing the full set of most common and useful file system features: big volumes, extents, large files, Unicode long file names, extended attributes, POSIX compatibility. Any design choices have gone in the direction of the greatest simplicity rather than performance. LEAN is designed for use even on platforms with limited memory and CPU power.

To learn more, visit the LEAN home page.

ISO 9660 file system

ISO 9660, also known as CDFS, is a read only file system for optical media such as CDs and DVDs. This module provides read support for the ISO 9660 file system with Joliet extensions for Unicode long file names and support for multisession discs.

DOS Protected Mode Interface ABI

This module provides the Application Binary Interface layer to execute regular DOS protected mode programs in FreeDOS-32. This primarily includes system calls based on the famous interrupts 21h (DOS) and 31h (DPMI).