┌──────────────────────────────────────────┐
│           애플리케이션 (사용자 공간)       │
├──────────────────────────────────────────┤
│           논리적 파일 시스템              │
│    (파일 이름 → inode 변환, 보호 검사)    │
├──────────────────────────────────────────┤
│           파일 구성 모듈                  │
│    (논리 블록 → 물리 블록 매핑)           │
├──────────────────────────────────────────┤
│           기본 파일 시스템               │
│    (블록 I/O 요청 발행)                  │
├──────────────────────────────────────────┤
│           I/O 제어                       │
│    (장치 드라이버, 인터럽트 핸들러)       │
├──────────────────────────────────────────┤
│           저장 장치 (디스크/SSD)          │
└──────────────────────────────────────────┘

┌────────┬───────────┬──────────┬──────────┬─────────────────┐
│ Boot   │ Super     │ Free     │ inode    │ Data Blocks     │
│ Block  │ Block     │ Space    │ Table    │                 │
│        │           │ Mgmt     │          │                 │
│ 부트   │ 메타      │ 비트맵/  │ 파일     │ 실제 파일       │
│ 로더   │ 데이터    │ 리스트   │ 메타     │ 데이터          │
└────────┴───────────┴──────────┴──────────┴─────────────────┘

┌─────────────────────────────────────┐
│           inode 구조                 │
├─────────────────────────────────────┤
│ 파일 유형, 권한 (mode)              │
│ 소유자 (uid, gid)                   │
│ 크기 (size)                         │
│ 타임스탬프 (atime, mtime, ctime)    │
│ 링크 카운트                          │
│ 블록 카운트                          │
├─────────────────────────────────────┤
│ 직접 블록 포인터 [0-11]  → 데이터    │
│ 단일 간접 포인터         → 포인터 블록│
│ 이중 간접 포인터         → 포인터²    │
│ 삼중 간접 포인터         → 포인터³    │
└─────────────────────────────────────┘

// 간단화된 inode 구조체 (ext2 기반)
struct inode {
    uint16_t mode;        // 파일 유형 + 권한
    uint16_t uid;         // 소유자 ID
    uint32_t size;        // 파일 크기
    uint32_t atime;       // 접근 시간
    uint32_t mtime;       // 수정 시간
    uint32_t ctime;       // 상태 변경 시간
    uint16_t gid;         // 그룹 ID
    uint16_t links_count; // 하드 링크 수
    uint32_t blocks;      // 할당된 블록 수

    uint32_t direct[12];          // 직접 블록 포인터
    uint32_t single_indirect;     // 단일 간접 포인터
    uint32_t double_indirect;     // 이중 간접 포인터
    uint32_t triple_indirect;     // 삼중 간접 포인터
};

┌───────────────────────────────────────────────┐
│              커널 메모리                        │
│                                               │
│  ┌─────────────────┐  ┌───────────────────┐   │
│  │ 마운트 테이블    │  │ 디렉토리 캐시     │   │
│  │ (파일시스템 목록)│  │ (최근 경로 정보)  │   │
│  └─────────────────┘  └───────────────────┘   │
│                                               │
│  ┌─────────────────┐  ┌───────────────────┐   │
│  │ 시스템 전역      │  │ 프로세스별        │   │
│  │ 오픈 파일 테이블 │  │ 오픈 파일 테이블  │   │
│  └─────────────────┘  └───────────────────┘   │
│                                               │
│  ┌─────────────────┐                          │
│  │ 버퍼 캐시       │ ← 디스크 블록 캐시       │
│  └─────────────────┘                          │
└───────────────────────────────────────────────┘

           사용자 프로세스
        open() read() write()
               │
    ┌──────────┴──────────┐
    │         VFS          │
    │  (가상 파일 시스템)   │
    │                      │
    │  vnode 인터페이스     │
    └──┬──────┬──────┬─────┘
       │      │      │
    ┌──┴──┐┌──┴──┐┌──┴──┐
    │ext4 ││NFS  ││FAT  │
    │     ││     ││     │
    └──┬──┘└──┬──┘└──┬──┘
       │      │      │
    로컬    네트워크  USB
    디스크  서버     드라이브

// VFS 추상화의 주요 객체 (Linux 기반 의사 코드)

// 1. 슈퍼블록 객체: 파일 시스템 인스턴스 정보
struct super_block {
    struct list_head s_list;       // 슈퍼블록 목록
    dev_t            s_dev;        // 장치 식별자
    unsigned long    s_blocksize;  // 블록 크기
    struct super_operations *s_op; // 연산 테이블
    // ...
};

// 2. inode 객체: 개별 파일 정보
struct inode {
    umode_t          i_mode;       // 파일 유형 + 권한
    uid_t            i_uid;        // 소유자
    loff_t           i_size;       // 파일 크기
    struct inode_operations *i_op; // inode 연산
    struct file_operations  *i_fop;// 파일 연산
    // ...
};

// 3. dentry 객체: 디렉토리 엔트리 (경로명 컴포넌트)
struct dentry {
    struct inode     *d_inode;     // 관련 inode
    struct dentry    *d_parent;    // 부모 디렉토리
    struct qstr      d_name;      // 엔트리 이름
    struct dentry_operations *d_op;
    // ...
};

// 4. file 객체: 열린 파일 인스턴스
struct file {
    struct dentry    *f_dentry;    // 관련 dentry
    loff_t           f_pos;       // 현재 오프셋
    unsigned int     f_flags;     // 열기 플래그
    struct file_operations *f_op; // 파일 연산
    // ...
};

디렉토리 블록:
┌──────────┬────────┬──────────┬────────┬──────────┬────────┐
│ "file1"  │ inode  │ "file2"  │ inode  │ "file3"  │ inode  │
│          │  23    │          │  47    │          │  12    │
└──────────┴────────┴──────────┴────────┴──────────┴────────┘

검색: O(n) - 파일 이름을 처음부터 순차 탐색
장점: 구현 간단
단점: 대규모 디렉토리에서 느림

해시 함수: hash("filename") → 버킷 인덱스

버킷 0: ["file_a", inode 23] → ["file_d", inode 89] → NULL
버킷 1: ["file_b", inode 47] → NULL
버킷 2: NULL
버킷 3: ["file_c", inode 12] → ["file_e", inode 56] → NULL
...

검색: O(1) 평균 (해시 충돌 시 연결 리스트 탐색)
장점: 빠른 검색
단점: 고정 크기, 해시 충돌 관리 필요

디렉토리 엔트리:
┌────────┬───────────┬──────┐
│ 파일명 │ 시작 블록 │ 길이 │
├────────┼───────────┼──────┤
│ file_a │    2      │  3   │
│ file_b │    7      │  2   │
│ file_c │   14      │  4   │
└────────┴───────────┴──────┘

디스크 블록:
 0  1 [2  3  4] 5  6 [7  8] 9 10 11 12 13 [14 15 16 17]
         file_a          file_b                file_c

디렉토리:
┌────────┬──────┬──────┐
│ 파일명 │ 시작 │ 끝   │
├────────┼──────┼──────┤
│ file_a │  9   │  1   │
└────────┴──────┴──────┘

디스크 블록 (각 블록에 다음 블록 포인터 포함):
블록 9 → 블록 16 → 블록 25 → 블록 1 → NULL
[data|16] [data|25] [data|1]  [data|-1]

FAT 테이블 (메모리에 캐시):
┌─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│  0  │  1  │  2  │  3  │  4  │  5  │  6  │ ← 블록 번호
├─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│  3  │ EOF │  5  │  4  │ EOF │  1  │ FREE│ ← 다음 블록
└─────┴─────┴─────┴─────┴─────┴─────┴─────┘

파일 A: 시작=0 → 0→3→4→EOF (블록 0, 3, 4)
파일 B: 시작=2 → 2→5→1→EOF (블록 2, 5, 1)

디렉토리:
┌────────┬─────────────┐
│ 파일명 │ 인덱스 블록 │
├────────┼─────────────┤
│ file_a │     19      │
└────────┴─────────────┘

인덱스 블록 19:          데이터 블록:
┌─────────────┐          블록 9:  [data...]
│  9          │ ────→    블록 16: [data...]
│ 16          │ ────→    블록 25: [data...]
│ 25          │ ────→    블록 1:  [data...]
│  1          │ ────→
│ -1 (끝)     │
└─────────────┘

블록 번호: 0  1  2  3  4  5  6  7  8  9  10 11 12
비트맵:    1  1  0  1  1  0  0  1  0  0  0  1  0

1 = 사용 중, 0 = 비어 있음

빈 블록 찾기: 비트맵에서 첫 번째 0 비트 탐색
장점: 연속 빈 공간 찾기 쉬움
단점: 대용량 디스크에서 비트맵 크기가 커짐
      (1TB 디스크, 4KB 블록 → 32MB 비트맵)

// 비트맵에서 빈 블록 찾기
int find_free_block(uint32_t *bitmap, int total_blocks) {
    int words = total_blocks / 32;
    for (int i = 0; i < words; i++) {
        if (bitmap[i] != 0xFFFFFFFF) {  // 모두 사용 중이 아니면
            // 첫 번째 0 비트 위치 찾기
            for (int j = 0; j < 32; j++) {
                if (!(bitmap[i] & (1 << j))) {
                    return i * 32 + j;
                }
            }
        }
    }
    return -1;  // 빈 블록 없음
}

Free Space Head → 블록 2 → 블록 5 → 블록 6 → 블록 8 → NULL

각 빈 블록이 다음 빈 블록을 가리킴
장점: 구현 간단
단점: 연속 빈 공간 찾기 어려움, 순회 비용

TRIM 없이:                      TRIM 사용 시:
1. 파일 삭제 → 메타만 제거      1. 파일 삭제 → 메타 제거
2. SSD는 블록이 빈 줄 모름      2. TRIM 명령으로 SSD에 알림
3. 나중에 쓰기 시:              3. SSD가 미리 블록 삭제
   읽기 → 삭제 → 쓰기 필요     4. 나중에 쓰기 시: 바로 쓰기
   (쓰기 성능 저하)                (쓰기 성능 유지)

일반 쓰기 (저널링 없음):
1. 데이터 블록 쓰기
2. inode 업데이트
3. 비트맵 업데이트
→ 2단계에서 충돌 시 불일치 발생!

저널링 쓰기:
┌──────────────────────────────────────┐
│          저널 영역 (Log)             │
│                                      │
│  1. 트랜잭션 시작 (TxB)             │
│  2. 메타데이터 변경 사항 기록         │
│  3. 트랜잭션 커밋 (TxE)             │
│                                      │
│  → 커밋 완료 후 실제 위치에 적용     │
│  → 적용 완료 후 저널 삭제           │
└──────────────────────────────────────┘

// 저널링 트랜잭션 의사 코드
void journaled_write(struct transaction *tx) {
    // 1. 저널에 트랜잭션 시작 기록
    journal_write_begin(tx);

    // 2. 변경할 메타데이터를 저널에 기록
    journal_write_metadata(tx, inode_data);
    journal_write_metadata(tx, bitmap_data);

    // 3. 저널에 트랜잭션 커밋 기록
    journal_write_commit(tx);

    // 4. 실제 파일 시스템 위치에 적용 (체크포인트)
    write_to_actual_location(inode_data);
    write_to_actual_location(bitmap_data);

    // 5. 저널에서 트랜잭션 제거
    journal_free(tx);
}

// 복구 시: 커밋된 트랜잭션은 재실행, 미커밋은 무시
void recover_from_crash() {
    for_each_transaction(journal) {
        if (transaction_committed(tx))
            replay_transaction(tx);  // 재실행
        else
            discard_transaction(tx); // 폐기
    }
}