File System · Linux 6.18.37 LTS · source + diagram note

page cache

고정 v6.18.37 원문 기준: address_space의 XArray 조회, 조건부 readahead·folio 삽입, Dirty·Writeback 상태를 구분합니다.

전체 흐름

이 글은 filemap_read()의 buffered read와 filemap_add_folio()의 삽입 책임을 구분한다. 읽기는 mapping->i_pages에서 folio를 찾는다. 적중·유효 범위 검사, readahead 뒤 재조회, 필요할 때만 새 folio 생성·삽입으로 갈라진다. Dirty와 Writeback은 이 조회 분기의 다음 단계가 아닌 별도 상태다.

그림 1. page cache의 세 경계: 조회·보충·변경 상태
address_space → i_pages (XArray) → folio index 조회와 연결 여부를 다루는 공유 기반
읽기 적중 / 유효 범위 filemap_get_pages()가 batch 획득 → Uptodate 또는 허용된 부분 유효 범위 확인 → filemap_read()가 iter로 복사
빈 batch / 보충 경로 IOCB_NOIO면 -EAGAIN; 아니면 동기 readahead 후 재조회. 그래도 비면 조건부 create → add → read_folio
데이터 변경 / writeback Dirty와 Writeback은 수정·I/O 진행의 별도 상태. 캐시에 연결되거나 읽혔다는 사실만으로 Dirty가 되지 않음
세 갈래는 서로 다른 판정·작업 범위이며, 모두 거치는 단일 함수 체인이 아니다.

두 대표 함수의 범위를 표시한 지도다. 읽기 조건부 분기와 상태의 자세한 근거는 아래 그림 2–4 및 보충 SVG를 본다.

범위 고정 v6.18.37 근거 보장하지 않는 것
읽기 조회·복사 filemap_get_pages · filemap_read 적중만으로 모든 folio의 데이터가 유효하다는 뜻 아님
새 folio 삽입 filemap_create_folio · filemap_add_folio 삽입 자체가 파일 데이터 읽기 완료를 뜻하지 않음
Dirty·Writeback mm/page-writeback.c 조회·삽입이 자동으로 Dirty나 영속화를 뜻하지 않음

소스 코드 위치

먼저 확인할 Linux 6.18.37 LTS 소스 파일

원본 코드:
Linux 6.18.37 LTS: mm/filemap.c
Linux 6.18.37 LTS: mm/readahead.c
Linux 6.18.37 LTS: mm/page-writeback.c
Linux 6.18.37 LTS: include/linux/pagemap.h

설명: mm/filemap.c의 조회·삽입 코드와 mm/readahead.c, mm/page-writeback.c의 별도 역할을 구분해 읽는다.

대표 코드

filemap_read

원본 코드: mm/filemap.c:2717-2829 · v6.18.37 · 로컬 원문
filemap_read 함수 전체 (113줄)
ssize_t filemap_read(struct kiocb *iocb, struct iov_iter *iter,
		ssize_t already_read)
{
	struct file *filp = iocb->ki_filp;
	struct file_ra_state *ra = &filp->f_ra;
	struct address_space *mapping = filp->f_mapping;
	struct inode *inode = mapping->host;
	struct folio_batch fbatch;
	int i, error = 0;
	bool writably_mapped;
	loff_t isize, end_offset;
	loff_t last_pos = ra->prev_pos;

	if (unlikely(iocb->ki_pos < 0))
		return -EINVAL;
	if (unlikely(iocb->ki_pos >= inode->i_sb->s_maxbytes))
		return 0;
	if (unlikely(!iov_iter_count(iter)))
		return 0;

	iov_iter_truncate(iter, inode->i_sb->s_maxbytes - iocb->ki_pos);
	folio_batch_init(&fbatch);

	do {
		cond_resched();

		/*
		 * If we've already successfully copied some data, then we
		 * can no longer safely return -EIOCBQUEUED. Hence mark
		 * an async read NOWAIT at that point.
		 */
		if ((iocb->ki_flags & IOCB_WAITQ) && already_read)
			iocb->ki_flags |= IOCB_NOWAIT;

		if (unlikely(iocb->ki_pos >= i_size_read(inode)))
			break;

		error = filemap_get_pages(iocb, iter->count, &fbatch, false);
		if (error < 0)
			break;

		/*
		 * i_size must be checked after we know the pages are Uptodate.
		 *
		 * Checking i_size after the check allows us to calculate
		 * the correct value for "nr", which means the zero-filled
		 * part of the page is not copied back to userspace (unless
		 * another truncate extends the file - this is desired though).
		 */
		isize = i_size_read(inode);
		if (unlikely(iocb->ki_pos >= isize))
			goto put_folios;
		end_offset = min_t(loff_t, isize, iocb->ki_pos + iter->count);

		/*
		 * Once we start copying data, we don't want to be touching any
		 * cachelines that might be contended:
		 */
		writably_mapped = mapping_writably_mapped(mapping);

		/*
		 * When a read accesses the same folio several times, only
		 * mark it as accessed the first time.
		 */
		if (!pos_same_folio(iocb->ki_pos, last_pos - 1,
				    fbatch.folios[0]))
			folio_mark_accessed(fbatch.folios[0]);

		for (i = 0; i < folio_batch_count(&fbatch); i++) {
			struct folio *folio = fbatch.folios[i];
			size_t fsize = folio_size(folio);
			size_t offset = iocb->ki_pos & (fsize - 1);
			size_t bytes = min_t(loff_t, end_offset - iocb->ki_pos,
					     fsize - offset);
			size_t copied;

			if (end_offset < folio_pos(folio))
				break;
			if (i > 0)
				folio_mark_accessed(folio);
			/*
			 * If users can be writing to this folio using arbitrary
			 * virtual addresses, take care of potential aliasing
			 * before reading the folio on the kernel side.
			 */
			if (writably_mapped)
				flush_dcache_folio(folio);

			copied = copy_folio_to_iter(folio, offset, bytes, iter);

			already_read += copied;
			iocb->ki_pos += copied;
			last_pos = iocb->ki_pos;

			if (copied < bytes) {
				error = -EFAULT;
				break;
			}
		}
put_folios:
		for (i = 0; i < folio_batch_count(&fbatch); i++) {
			struct folio *folio = fbatch.folios[i];

			filemap_end_dropbehind_read(folio);
			folio_put(folio);
		}
		folio_batch_init(&fbatch);
	} while (iov_iter_count(iter) && iocb->ki_pos < isize && !error);

	file_accessed(filp);
	ra->prev_pos = last_pos;
	return already_read ? already_read : error;
}

확인 사항: 음수 위치는 -EINVAL이며 읽을 범위를 s_maxbytes - ki_pos로 제한한다. folio를 얻은 뒤 파일 크기를 다시 확인하고 복사량과 ki_pos를 갱신한다. 일부 복사 뒤 오류가 나면 복사량을 우선 반환하며 folio 참조와 dropbehind 상태를 정리한다.

filemap_add_folio

원본 코드: mm/filemap.c:962-1002 · v6.18.37 · 로컬 원문
int filemap_add_folio(struct address_space *mapping, struct folio *folio,
				pgoff_t index, gfp_t gfp)
{
	void *shadow = NULL;
	int ret;
	struct mem_cgroup *tmp;
	bool kernel_file = test_bit(AS_KERNEL_FILE, &mapping->flags);

	if (kernel_file)
		tmp = set_active_memcg(root_mem_cgroup);
	ret = mem_cgroup_charge(folio, NULL, gfp);
	if (kernel_file)
		set_active_memcg(tmp);
	if (ret)
		return ret;

	__folio_set_locked(folio);
	ret = __filemap_add_folio(mapping, folio, index, gfp, &shadow);
	if (unlikely(ret)) {
		mem_cgroup_uncharge(folio);
		__folio_clear_locked(folio);
	} else {
		/*
		 * The folio might have been evicted from cache only
		 * recently, in which case it should be activated like
		 * any other repeatedly accessed folio.
		 * The exception is folios getting rewritten; evicting other
		 * data from the working set, only to cache data that will
		 * get overwritten with something else, is a waste of memory.
		 */
		WARN_ON_ONCE(folio_test_active(folio));
		if (!(gfp & __GFP_WRITE) && shadow)
			workingset_refault(folio, shadow);
		folio_add_lru(folio);
		if (kernel_file)
			mod_node_page_state(folio_pgdat(folio),
					    NR_KERNEL_FILE_PAGES,
					    folio_nr_pages(folio));
	}
	return ret;
}

메모리 cgroup 과금이 성공한 뒤 folio를 잠금 상태로 만들고 __filemap_add_folio()로 mapping에 연결한다. 연결 실패 시 과금과 잠금 표시를 되돌린다. 성공 경로는 shadow entry를 이용한 refault 처리와 LRU 추가를 수행한다. 삽입 성공이 파일 데이터 읽기 완료를 뜻하지는 않는다.

함수별 분석

파일 읽기는 먼저 XArray에서 folio를 찾고, 없을 때에만 readahead 또는 새 folio 생성 경로를 고려한다. 쓰기와 writeback은 별도의 상태 변화다.

filemap_read()와 filemap_add_folio()는 항상 이어지는 두 함수가 아니다. 삽입 함수는 읽기 miss 후에도 조건부로만 호출된다.

그림 2. 읽기 경로의 함수 경계
filemap_read읽기 범위와 반환값 관리
→
filemap_get_pagesXArray 조회·조건부 readahead
→
folio → iter확인된 데이터 범위를 복사

XArray 조회가 비어 있고 readahead 뒤에도 folio가 없을 때 filemap_create_folio()가 할당 → filemap_add_folio()로 삽입 → filemap_read_folio()로 데이터 읽기를 시도한다. 적중 경로에는 이 생성 단계가 없다. 근거: mm/filemap.c:2549–2599, 2616–2674, 2754–2805.

1. filemap_read

filemap_get_pages()를 통해 batch를 얻고, 파일 크기를 다시 확인한 뒤 읽을 수 있는 folio 범위를 iterator에 복사한다. 반환값은 실제 복사한 바이트 수 또는 오류다. 조회가 적중하면 새 folio를 삽입하지 않는다.

확인할 분기: 빈 batch에서 IOCB_NOIO는 -EAGAIN을 반환하고, I/O가 허용되면 동기 readahead 후 재조회한다.

2. filemap_add_folio

이미 마련된 folio와 mapping·index를 받아 과금, 잠금 표시, XArray 삽입, LRU 등록을 처리한다. 성공 시 해당 index에 folio가 존재하지만, 파일 데이터가 준비되었거나 dirty라는 뜻은 아니다.

확인할 분기: 같은 index의 기존 folio와 충돌하면 -EEXIST가 가능하며, 호출자는 재시도 여부를 결정한다.

함수입력확인 가능한 결과소스에서 볼 분기
filemap_readkiocb, iov_iter준비된 범위의 복사 바이트 수 또는 오류조회·readahead·생성 조건
filemap_add_foliomapping, 이미 할당한 folio, index, gfp성공 시 XArray 연결·LRU 등록; 데이터 읽기 완료는 별개삽입 충돌·과금 되돌림

구조체와 필드

객체 관계와 실행 조건을 나누어 읽는다. address_space의 XArray가 index를 folio에 연결하지만, readahead는 조회 결과에 따라 시작되는 별도 요청이다.

그림 3. 캐시 객체의 연결 관계
address_space파일별 캐시 mapping
→
i_pages (XArray)index → folio
→
folio데이터 범위·상태 flags

readahead_control은 이 객체 사슬의 다음 단계가 아니다. 읽기 batch가 비었을 때의 동기 readahead나 readahead 표식이 있는 folio에서의 비동기 readahead에 쓰이는 요청 문맥이다. 근거: mm/filemap.c:2634–2660.

객체 연결과 조건부 요청 문맥을 구분해 읽는다.

객체·상태읽는 법
address_space파일별 캐시 mapping을 관리한다.
i_pages (XArray)index에서 folio를 찾는다. 삽입만으로 내용 유효성이 보장되지는 않는다.
folio flagsUptodate·Dirty·Writeback은 서로 다른 조건을 나타낸다.
readahead_control조건부 readahead 호출에 전달하는 요청 문맥이다.

읽기와 쓰기의 상태 변화

조회 실패는 읽기 경로의 분기이고, Dirty·Writeback은 파일 데이터 변경과 I/O 진행을 나타내는 별도 상태다. 읽기 miss가 반드시 dirty로 이어지지는 않는다.

그림 4. 두 경로를 한 줄로 연결하지 않는다
읽기XArray 조회 → 유효 범위 확인 → 복사
데이터 변경Dirty 표시 → 별도 writeback 경로

두 상자는 서로 다른 경로다. Writeback은 진행 중인 I/O를 나타내며, 이 표시만으로 디스크 영속화를 단정하지 않는다. 근거: mm/filemap.c:2754–2805, 3897–3917, mm/page-writeback.c:2985–3067.

아래 분기 그림과 상태 표에서 조회, 데이터 유효성, Dirty, Writeback을 각각 확인한다.

읽기 분기와 독립 상태

개념 설명의 과금·삽입·LRU 순서와 달리, 여기서는 읽기 요청이 언제 캐시 적중, IOCB_NOIO 거절, readahead, 새 folio 생성으로 갈라지는지 본다.

보충 그림. 캐시 조회 뒤의 세 분기
filemap_read의 XArray 조회가 적중, IOCB_NOIO의 EAGAIN, I/O 허용 후 readahead와 조건부 folio 생성으로 갈라지는 소스 기반 분기 그림

소스 기준의 설명용 분기이며 실측 trace가 아니다. filemap_add_folio()는 folio 삽입만 맡고 데이터 읽기는 뒤의 filemap_read_folio()가 맡는다. mm/filemap.c:2549–2674.

그림 크게 열기 · 작은 화면에서는 그림을 가로로 스크롤할 수 있다.

같은 folio를 볼 때 서로 따로 확인할 네 가지 상태
판정 축소스에서 바뀌는 지점이 상태만으로 알 수 없는 것
XArray에 연결__filemap_add_folio()가 mapping->i_pages에 저장하고 nrpages를 갱신한다. filemap.c:880–959파일 데이터가 이미 읽혔는지는 알 수 없다.
읽을 범위 유효Uptodate 또는 허용된 부분 유효 범위를 검사하고, 필요하면 folio를 갱신한다. filemap.c:2466–2545읽기 가능성이 Dirty 표시를 뜻하지 않는다.
Dirty예를 들어 mmap 쓰기 fault 경로는 folio_mark_dirty()를 호출한다. filemap.c:3897–3917, page-writeback.c:2795–2830디스크 반영 완료나 읽기 miss 직후 상태를 뜻하지 않는다.
Writeback시작 시 PG_writeback을 설정하고, mapping이 writeback tag를 쓰면 XArray tag도 표시한다. 종료 시 표시와 계수를 정리한다. page-writeback.c:2985–3067표시만으로 I/O 완료나 영속화를 뜻하지 않는다.

표의 축은 단일 정상 진행 순서가 아니다. folio의 연결 여부, 읽을 범위의 유효성, 수정 여부, writeback 진행 여부를 각각 확인한다.

Buffered write의 바이트 수

앞선 읽기 경로와 달리, Linux v6.18.37의 generic_file_write_iter()는 inode를 잠그고 쓰기 조건을 검사한 뒤 내부 쓰기 함수를 부릅니다. 잠금을 풀고 나서 양수 결과에 generic_write_sync()를 적용합니다. 이 설명은 이 generic 경로를 이용하는 경우의 계약이며, 모든 파일 시스템의 write_iter 구현이 같다는 뜻은 아닙니다.

inode_lock → generic_write_checks → __generic_file_write_iter → inode_unlock → 조건부 generic_write_sync 순서입니다. 내부 함수는 권한 비트·시간 갱신을 처리하고 direct I/O 여부에 따라 분기합니다. 보통의 buffered 경로는 generic_perform_write()로 들어갑니다. 읽기 miss에서 새 folio를 삽입하는 흐름과 하나의 직선 경로로 연결하지 않습니다.

요청량, 복사량, 인정된 쓰기량은 서로 다를 수 있습니다
단계직접 하는 일결과를 읽는 기준
write_begina_ops->write_begin()이 파일 시스템에 쓸 folio 준비를 요청음수면 루프 중단. 준비 성공만으로 쓰기·영속화가 완료되지 않음
copycopy_folio_from_iter_atomic()이 iterator에서 folio로 복사copied는 실제 복사량. 요청한 bytes보다 작을 수 있음
write_enda_ops->write_end()가 결과를 받아 인정한 바이트 수 또는 오류 반환양수 status로 위치와 누적 쓰기량 전진. copied와 다르면 iterator 보정
sync바깥 wrapper가 잠금 해제 뒤 양수 결과를 동기화 helper에 전달조건에 따라 fsync 호출, writeback 시작 요청 또는 바이트 수 반환. 모두 같은 완료 조건이 아님

write_end 결과가 복사량과 다르면 iov_iter_revert(i, copied - max(status, 0L))로 아직 인정되지 않은 부분을 되돌립니다. 예를 들어 4,096바이트를 복사했지만 2,048바이트만 인정됐다면 iterator를 2,048바이트 되돌리고 파일 위치도 인정된 2,048바이트만 전진합니다. 이는 소스 계산을 설명하는 예이며 특정 파일 시스템의 실행 결과가 아닙니다.

결과가 0이면 큰 chunk를 줄이고, 일부 복사했다면 그 크기로 다시 시도합니다. 복사량도 0이면 folio 잠금이 풀린 뒤 사용자 입력 범위를 fault-in하여 진행을 시도하며, 해당 범위 전체가 여전히 읽히지 않으면 -EFAULT로 끝납니다. 앞서 성공한 바이트가 있으면 루프 뒤 오류가 나더라도 누적 양수를 반환할 수 있습니다. 따라서 짧은 양수 반환을 요청 전체 성공으로 읽지 않습니다. 다만 뒤의 동기화가 실패하면 wrapper는 동기화 오류를 반환할 수 있습니다.

IOCB_DIRECT도 항상 page cache를 완전히 우회한다는 보장은 아닙니다. 이 구현은 direct 쓰기 뒤 남은 입력이 있고 오류가 아니며 IS_DAX(inode)가 아닌 경우 buffered fallback을 시도합니다. 이 조건을 모든 파일 시스템의 direct-I/O 구현으로 일반화하지 않습니다.

generic_write_sync()는 IOCB_DSYNC 또는 inode의 동기화 조건에 해당하면 쓴 범위에 vfs_fsync_range()를 호출합니다. IOCB_SYNC 여부로 data-only 인자를 구분하며 오류를 전파합니다. 그 조건이 아니면서 IOCB_DONTCACHE이면 filemap_fdatawrite_range_kick()로 writeback 시작을 요청하는 별도 분기입니다. helper를 호출했다는 사실만으로 항상 fsync를 기다렸다고 읽지 않습니다.

generic 루프만 보고 모든 파일 시스템이 write_end의 같은 위치에서 Dirty를 표시한다고 단정하지 않습니다. 캐시에 복사함, 쓰기량을 인정함, Dirty 표시, writeback 진행, 동기화 계약의 완료는 별개의 판정입니다. 여기서는 커널·파일 시스템을 실행하거나 저장장치의 전원 장애 내구성을 시험하지 않았습니다.

English summary

The generic buffered-write loop distinguishes requested bytes, copied bytes and the count accepted by write_end. It rolls back unaccepted iterator progress and may return a partial count. Direct-I/O fallback is conditional and excludes DAX here. The wrapper unlocks the inode before optional synchronization; a sync error can replace a positive write result. No filesystem execution or power-loss durability test was performed.

고정 원문: filemap.c의 쓰기 루프와 wrapper, fs.h의 동기화 조건. folio 삽입 개념 설명은 별도 범위입니다.

불변 조건과 실패 사례

조회와 데이터 유효성

XArray에 folio가 있어도 filemap_get_pages()는 Uptodate 또는 허용된 부분 유효 범위를 확인한다. 필요하면 filemap_update_page()가 읽기를 시도한다.

삽입 충돌과 되돌림

filemap_add_folio()는 memcg 과금 뒤 folio를 잠금 표시한다. __filemap_add_folio() 실패 시 과금·잠금을 되돌리고, 충돌하면 -EEXIST가 가능하다.

읽기 제약

빈 batch에서 IOCB_NOIO는 -EAGAIN이다. I/O가 허용된 경우 readahead 후에도 비어 있어야 조건부 새 folio 생성 경로로 간다.

Dirty와 Writeback

읽기 miss나 folio 삽입만으로 Dirty가 되지 않는다. Writeback 표시는 진행 중인 I/O 상태이며 지속성 완료와 구분한다.

주의

page cache와 buffer cache를 혼동함

주의

dirty page가 곧 disk 반영이라고 봄

주의

mmap fault와 read path가 같은 mapping을 공유하는 점을 놓침

계측과 검증

부팅한 시스템의 결과 지표와 이미 활성화된 trace를 읽기 전용으로 확인한다. 전역 tracefs 설정을 바꾸지 않으며, 집계 수치만으로 개별 파일의 cache hit·miss나 folio 삽입 분기를 판정하지 않는다.

읽기 전용 관찰 알 수 있는 것 한계
cat /proc/meminfo Cached, Dirty, Writeback 등 전역 메모리 상태 특정 파일의 적중률·쓰기 영속화 여부가 아님
cat /proc/vmstat 파일 페이지·refault·dirty/writeback 관련 전역 카운터 folio 하나의 상태나 filemap_read 분기 결과를 직접 보여주지 않음
cat /sys/kernel/tracing/available_events tracefs가 이미 마운트된 경우 사용 가능한 filemap·writeback·vmscan event 이름 목록만 읽으며 이벤트를 활성화하거나 수집하지 않음
cat /sys/kernel/tracing/trace 이미 설정·수집된 trace의 현재 snapshot 비어 있어도 해당 코드 경로가 실행되지 않았다는 증거는 아님
읽기 전용 예시:
cat /proc/meminfo
cat /proc/vmstat
# tracefs가 이미 마운트되고 수집 중일 때만:
cat /sys/kernel/tracing/available_events
cat /sys/kernel/tracing/trace

추가 확인 사항

  • 이 읽기에서 XArray batch는 적중했는가, 아니면 readahead 뒤 다시 조회했는가?
  • folio가 연결돼 있다면 필요한 범위가 Uptodate 또는 부분 유효한가? IOCB_NOIO·NOWAIT·WAITQ는 어떤 반환 분기를 택하는가?
  • 새 folio를 만들었다면 filemap_add_folio() 성공과 read_folio() 성공을 구분했는가?
  • Dirty와 Writeback의 관찰값을 이 읽기 요청 자체의 결과로 오인하지 않았는가?

write() 반환과 영속 저장의 완료 조건

일반적인 buffered file write의 양수 반환은 그만큼의 데이터를 받아들였다는 뜻입니다. 변경 내용은 dirty folio에 남아 있다가 writeback으로 내려갈 수 있으므로, 이것만으로 전원 장애 뒤 복구를 보장하지 않습니다. direct I/O나 동기화 플래그를 사용한 경로는 완료 조건을 따로 확인합니다. 앞의 write_end() 반환량과 partial write 설명 역시 저장장치의 영속성 보장과는 다른 문제입니다.

fsync(fd)는 파일 데이터와 관련 메타데이터를 저장장치로 동기화하며, 장치가 완료를 알릴 때까지 기다립니다. fdatasync(fd)는 이후 데이터를 읽는 데 필요하지 않은 메타데이터 갱신을 생략할 수 있지만, 파일 크기처럼 읽기에 필요한 변경은 포함합니다. 새 파일 생성이나 rename 뒤 디렉터리 항목까지 지속되어야 한다면 파일의 동기화와 별개로 디렉터리 fd의 fsync()도 검토해야 합니다. 반환값과 지연된 I/O 오류를 확인하고, 장치·드라이버가 cache flush 계약을 제대로 수행하는지도 전제로 둡니다.

ext4 기본 data=ordered 모드는 메타데이터를 저널링하고 그 커밋 전에 관련 데이터 블록의 쓰기 순서를 확보합니다. data=writeback은 이 데이터 순서를 보장하지 않고, data=journal은 데이터도 저널에 기록합니다. 저널이 있다는 사실만으로 임의의 충돌에서 모든 파일 내용이 복원되는 것은 아닙니다. 응용 프로그램의 파일·디렉터리 갱신 순서와 동기화 호출은 여전히 중요합니다.

분석에서는 write() 반환, dirty 상태, writeback 시작·종료, 동기화 완료와 오류를 구분합니다. 모든 파일시스템이 같은 worker 순서로 동작하거나 모든 bio 완료가 hard IRQ 문맥이라는 식으로 일반화하지 않습니다. 이 보완은 API와 문서를 대조한 설명이며 전원 차단 시험을 수행한 결과가 아닙니다.

기준: fsync(2)와 fdatasync(2) · ext4 journal의 데이터 모드.

English summary. A successful buffered write is not a durability receipt. File and directory synchronization have separate roles; ext4 journaling modes provide different data-ordering guarantees. Check synchronization errors and the storage flush contract.