mirror of
https://github.com/apache/nuttx.git
synced 2026-08-01 20:28:58 +00:00
e0cc0244c5
ROMFS is the usual way to carry executables on a NOMMU target with memory mapped NOR flash: it can hand out a real flash pointer from mmap(), so the NXFLAT loader maps a module's text in place instead of copying it into RAM. But a ROMFS image is built on the host and is read only, so a module cannot be downloaded onto the board at run time. xipfs is a writable file system with the same in-place property. Each file is stored as one physically contiguous, erase-block aligned extent, so an mmap() of it resolves to flash_base + extent_offset and a loader can execute the file where it already lies. This needs the underlying MTD driver to answer BIOC_XIPBASE; on the RP2350 rp23xx_flash_mtd.c does. Files are write once. A file is created, its size is declared, it is written sequentially, closed, and is thereafter immutable until it is deleted. That is the whole life cycle of a downloaded module, and it is what licenses the design: the exact extent is reserved at create time, so no file ever grows, moves, or fragments internally. Random writes, appends and truncation of a written file are not supported and are refused. The only source of fragmentation is therefore free space holes left by deletes. Allocation fails with -ENOSPC when no single contiguous run is large enough, and never defragments on its own; the caller decides whether to compact and retry, through XIPFSIOC_DEFRAG. Defragmentation is manual, best effort and interruptible: it is a loop of atomic single-extent relocations, each one copy, commit, erase, so every stop point -- a time budget, a pinned extent, an erase error -- leaves a consistent layout that is simply less compact. It reports the largest contiguous run it achieved, which is what tells the caller whether the retry will fit. Metadata is committed power safely. Two metadata block sets are used in ping-pong, each generation carrying a sequence number and a CRC, and every state change is ordered as write the new data, flip the metadata reference, then erase what the old one referenced. Mount scans both sets and selects the last fully valid generation, so a torn write costs the interrupted operation and nothing else. A mapping takes a pin on the extent, and the pin lives on the extent rather than on the file descriptor, so three running instances of one module hold three pins and the extent becomes movable only when the last one goes. Defragmentation skips pinned extents, which is what stops it relocating code that is executing. The pin is released by munmap() or by the task teardown walk, so a task that dies without unmapping does not leak it. Directories are records in that same generation, carrying their own identity and the identity of the directory holding them; the root is implicit and owns identity zero. They are deliberately NOT objects in the data region, which is what keeps the commit story in one piece: mkdir and rmdir add or remove a record and commit one generation, exactly as create and unlink do, so there is never a multi-object update to journal or an orphan to collect at mount. An empty directory therefore exists, survives a remount, and costs one entry out of the volume's fixed supply and no flash blocks at all. A name is one path component; depth comes from the parent, so XIPFS_NAME_MAX bounds a component, which is what statfs reports it as. Mount rebuilds the tree and checks that it is one: identities unique, names unique within a directory, every parent a live directory, and following parents reaching the root -- a cycle on the medium would otherwise hang a path walk rather than merely answering wrongly. '.' and '..' are refused as components, since an entry stored under either could never be reached again. The commands that act on the volume rather than on one file -- XIPFSIOC_DEFRAG and XIPFSIOC_LISTPINNED -- are reached through the ioctldir method, on a descriptor for the mountpoint directory. They are accepted on a descriptor for a file inside the volume too, but that route holds the file open for the duration and an open extent cannot be relocated, so a pass asked for that way is obstructed by the act of asking. mmap() falls back to the generic RAM copy for ordinary readers when the media cannot be addressed directly. A module loader must not silently get a RAM copy, so MAP_XIP_STRICT is added: with it the mapping either resolves in place or fails with -ENXIO, which the caller can turn into defragment and retry. Assisted-by: Claude Code:claude-opus-5 Signed-off-by: Marco Casaroli <marco.casaroli@gmail.com>
42 lines
1.5 KiB
Text
42 lines
1.5 KiB
Text
#
|
|
# For a description of the syntax of this configuration file,
|
|
# see the file kconfig-language.txt in the NuttX tools repository.
|
|
#
|
|
|
|
config FS_XIPFS
|
|
bool "XIPFS contiguous execute-in-place file system"
|
|
default n
|
|
depends on !DISABLE_MOUNTPOINT && MTD
|
|
---help---
|
|
Enable support for XIPFS, a file system that stores each file as a
|
|
single physically contiguous, erase-block aligned extent on memory
|
|
mapped flash.
|
|
|
|
Because files are contiguous and the media is directly addressable,
|
|
XIPFS can return a real pointer into flash from mmap(), so a module
|
|
can be executed in place without its read-only text and rodata ever
|
|
being copied into RAM. This requires the underlying MTD driver to
|
|
implement the BIOC_XIPBASE ioctl.
|
|
|
|
Files are write once: a file is created at a known size, written
|
|
sequentially, closed, and is immutable thereafter until it is
|
|
deleted. Random writes, appends and growth are not supported.
|
|
|
|
Directories are supported. They are records in the same metadata
|
|
generation the files are, not objects in the data region, so an
|
|
empty one costs one entry out of the volume's fixed supply and no
|
|
flash blocks at all.
|
|
|
|
if FS_XIPFS
|
|
|
|
config FS_XIPFS_FAULT_INJECT
|
|
bool "XIPFS flash fault injection"
|
|
default n
|
|
---help---
|
|
Add a countdown to the XIPFS flash write and erase paths so that a
|
|
test can fail an arbitrary flash operation and then remount, which
|
|
models a power loss at that exact point.
|
|
|
|
This is a test-only facility. Do not enable it in production.
|
|
|
|
endif # FS_XIPFS
|