RTFiles-32 is a FAT file system for 32-bit x86 embedded systems. RTFiles-32 is a library that can be linked to embedded systems programs. It contains the core file handling functions as well as the required device drivers. Several different APIs are provided for compatibility with other systems. No source code modifications of existing programs are required.

• FAT-12, FAT-16, and FAT-32
  RTFiles-32 supports the same FAT (File Allocation Table) formats as DOS and Windows. Storage media can be shared between RTFiles-32 and standard operating systems to exchange data.
   
• Supports Diskettes, Hard Disks, Flash Disks and SRAM Cards
  RTFiles-32 supports the following devices: diskette drives and media with 360k, 1.2M, 720k, 1.44M, and 2.88M capacity, IDE and flash disks with CHS (Cylinder, Head, Sector) or LBA (Logical Block Addressing) interface, M-Systems DiskOnChip flash disks, linear flash, and PCMCIA SRAM cards.
   
• PCMCIA Support
  With RTTarget-32's PCMCIA driver, ATA-Flash, CompactFlash, and SRAM cards can also be used and hot-swapped.
   
• Hard Disks up to 2 Terabytes
  The latest standards (such as LBA, ATA-6) for extended sector addressing are supported, if also supported by the disk controller. For FAT-32 volumes, there is no practical limit on partition size.
   
• Partitioning and Formatting
  RTFiles-32 has functions to partition and format storage devices. Embedded systems manufactured with virgin disks can automatically format their disks when first powered on.
   
• Efficient Cache Support
  RTFiles-32 will cache frequently accessed data such as a volume’s FAT or directories. The application has full control over the size of the cache. Large data blocks read or written in a contiguous manner are not cached to avoid cache thrashing.
   
• Contiguous Files
  RTFiles-32 can preallocate files to reside in a single contiguous chain of sectors. In this way, it can guarantee that no extra seek operations are required for contiguous read or write operations.
   
• Committed and Lazy Write Files
  RTFiles-32 behavior can be fine-tuned for best data security (e.g. always commit all file write operations to disk immediately) or best throughput (e.g. data is kept in cache as long as possible to eliminate redundant write operations).
   
• Extensive Diagnostics Support
  RTFiles-32 provides functions to query the state of its cache in great detail. For each file or even a complete volume, the degree of fragmentation can be determined.
   
• Native API
  RTFiles-32 has its own API con-sisting of about 50 functions. While many of these functions appear in all file systems (e.g. open, read, write, etc.), some address advanced features tailored to the needs of embedded systems. For example, RTFExtend can create contiguous (unfragmented) files and RTFBufferInfo returns detailed statistics about RTFiles-32’s internal sector buffer cache.
   
• Raw I/O Functions
  RTFiles-32 allows the application to call device driver functions directly. Applications can completely bypass the high-level file system and perform sector-level I/O.
   
• File System Analysis and Repair
  RTFiles-32's RTFCheckDisk function can detect and automatically repair common file system errors, such as file chain crosslinks, lost clusters, invalid directory entries, etc.
   
• Customizable Critical Error Handler
  Applications have full control over how RTFiles-32 handles disk I/O errors. All errors can be passed back to the calling application using standard error codes, or RTFiles-32 can call custom error handlers of the application, which in turn can decide whether the operation should be failed or retried (possibly after prompting the user).
   
• Win32 Compatible API
  RTFiles-32 emulates about 30 file I/O related Win32 functions. Existing Win32 programs accessing files are supported without source code modifications.
   
• C/C++ and Pascal Run-Time System Support
  Through RTFiles-32’s Win32 API emulation, all of the run-time systems' file I/O functions are fully supported. C functions such as fopen, fread, etc., work unmodified with RTFiles-32. The same is true for C++ classes such as iostream.
   
• Multitasking Support
  When RTFiles-32 is used with RTKernel-32, all RTFiles-32 operations perform appropriate locking to support simultaneous calls from several tasks. Simultaneous access to different devices is fully supported. I/O device wait times are made available to other tasks by blocking the waiting tasks at a semaphore until the device signals I/O completion by an interrupt.
   
• Low Interrupt Latencies
  Although RTFiles-32’s device drivers are interrupt-driven, they never disable interrupts and do not process data transfers in interrupt handlers.
   
• Installable Device Drivers
  RTFiles-32’s device driver interface is very simple. Only three functions are required to access a device: MountDevice, ReadSectors, and WriteSectors. All drivers (except for the M-Systems DiskOnChip driver) shipped with RTFiles-32 come with complete source code, which can be used as a model to implement custom drivers.
   
• Portable
  RTFiles-32 is written in ANSI C and does not contain any system or hardware dependencies. All device-specific code is encapsulated in device drivers which are always delivered with full source code (the DiskOnChip driver's source code can be licensed from M-Systems). The portable file system's source code is available at extra charge. By supplying an alternate System Driver, RTFiles-32 can easily be ported to other operating systems or CPUs.