# Volume Journaling Options in Apple Container: Configuring ext4 Persistence > Explore Apple Container's ext4 journaling options: ordered, writeback, and journal. Configure persistence and optimize performance with the journal= driver option. - Repository: [Apple/container](https://github.com/apple/container) - Tags: deep-dive - Published: 2026-06-20 --- **Apple Container supports three ext4 journaling modes—`ordered` (default), `writeback`, and `journal`—which control the balance between data durability and write performance through the `journal=[:]` driver option.** The `apple/container` repository implements persistent volume storage using the ext4 filesystem, exposing kernel-level journaling controls through a simple driver option interface. When you provision storage using `container volume create`, you can tune how aggressively the system protects data against crashes by selecting from three distinct volume journaling options. These configurations are parsed in [`VolumesService.swift`](https://github.com/apple/container/blob/main/VolumesService.swift) and translated into `EXT4.JournalConfig` instances that dictate the filesystem's behavior during commit operations. ## Available Journaling Modes Container maps the `journal` driver option directly to ext4’s journaling behavior. You must specify one of the following three modes, each offering a different trade-off between safety and speed. ### Ordered Mode (Default) **`ordered`** journals only metadata while guaranteeing that data is flushed to disk before its associated metadata commit completes. This mode provides robust protection against filesystem corruption after crashes without incurring the full performance penalty of data journaling. Use this for general-purpose workloads where data integrity matters but you also need reasonable I/O throughput. ### Writeback Mode **`writeback`** journals only metadata and provides no guarantees about the ordering of data writes relative to metadata commits. This is the fastest but least safe mode, as recent data might be lost during a system crash even if the filesystem structure remains intact. Select this for high-throughput workloads where speed overrides strict durability guarantees. ### Journal Mode **`journal`** performs full data journaling, writing both metadata and data blocks to the journal before committing them to the main filesystem. This is the safest mode and prevents data loss in almost all crash scenarios, but it incurs the highest write amplification and performance overhead. Use this for workloads that require maximum data protection, such as transactional databases, where you can tolerate the performance penalty. ## Configuration Syntax and Validation The journaling configuration follows the format `journal=[:]`, where the optional `:` suffix sets the journal’s allocation (e.g., `64m` for 64 MiB). If you omit the size, the kernel chooses a default based on the volume characteristics. According to the source code in [`Sources/Services/ContainerAPIService/Server/Volumes/VolumesService.swift`](https://github.com/apple/container/blob/main/Sources/Services/ContainerAPIService/Server/Volumes/VolumesService.swift) (lines 69-82), the server splits the input string on the colon delimiter and validates the mode against the three allowed values. Any other value causes the parser to throw an error, rejecting the volume creation request immediately. Lines 69-88 handle the translation of the parsed string into an `EXT4.JournalConfig` structure that the filesystem formatter consumes. ## Implementation Details The `VolumesService.parseJournalConfig` method implements the parsing logic referenced in the command documentation at [`docs/command-reference.md`](https://github.com/apple/container/blob/main/docs/command-reference.md) (lines 886-904). When the API server receives a volume creation request with the `--opt journal=...` flag, it invokes this parser to validate the mode and extract the optional size parameter. The implementation strictly enforces the three-mode constraint, ensuring that only `ordered`, `writeback`, or `journal` are passed to the underlying ext4 formatter. Unit tests in [`Tests/ContainerResourceTests/VolumeJournalConfigTests.swift`](https://github.com/apple/container/blob/main/Tests/ContainerResourceTests/VolumeJournalConfigTests.swift) verify the correct parsing of each mode and various size formats, providing regression protection for the configuration logic. ## Usage Examples Create volumes with specific journaling behaviors using the `container volume create` command: ```bash # Create a volume with ordered journaling (default) container volume create --opt journal=ordered myOrderedVol # Create a volume with writeback journaling and a 64 MiB journal container volume create --opt journal=writeback:64m myWritebackVol # Create a volume with full data journaling (journal mode) container volume create --opt journal=journal myFullJournalVol ``` These commands forward the `--opt` flags to the server, which applies the validated `EXT4.JournalConfig` during the formatting phase. ## Summary - Container volumes use ext4 with configurable journaling via the `journal=[:]` driver option. - Three modes are available: `ordered` (balanced safety/performance), `writeback` (maximum speed), and `journal` (maximum durability). - The parsing logic in [`VolumesService.swift`](https://github.com/apple/container/blob/main/VolumesService.swift) (lines 69-82) validates inputs against these three values and rejects invalid modes. - An optional size suffix controls journal allocation; otherwise, the kernel selects a default. - Documentation at [`docs/command-reference.md`](https://github.com/apple/container/blob/main/docs/command-reference.md) lines 886-904 provides the authoritative reference for these options. ## Frequently Asked Questions ### What is the default volume journaling mode in Container? The default mode is `ordered`, which journals only metadata while ensuring data is flushed to disk before the metadata commit. This provides a balance between safety and performance suitable for general-purpose workloads. ### How do I configure the journal size for a Container volume? Append the desired size after the mode using a colon separator, such as `journal=writeback:64m`. If you omit the size suffix, the kernel automatically selects a default journal size based on the volume characteristics. ### Which journaling mode should I use for database workloads? Use `journal` mode for databases or other applications requiring maximum data protection, as it journals both metadata and data blocks. Be aware this incurs the highest write amplification and performance cost compared to other modes. ### What happens if I provide an invalid journaling mode? The server rejects the request with an error because [`VolumesService.swift`](https://github.com/apple/container/blob/main/VolumesService.swift) validates the mode string against the three supported values during parsing (lines 69-82), throwing an error for any unrecognized input before the volume is formatted.