RAM 디스크 (Ramdisk)

리눅스 커널의 RAM 디스크 서브시스템을 심층 분석합니다. BRD 블록 드라이버(drivers/block/brd.c), ramfs 파일시스템, 레거시 initrd와 현대적 initramfs 부팅 메커니즘, zram 압축 블록 디바이스, 메모리 백킹 전략, 블록 레이어 통합, 커널 부트 파라미터와 실전 활용 가이드까지 RAM 기반 스토리지의 모든 것을 다룹니다.

RAM 디스크 개요

RAM 디스크(Ramdisk)는 시스템 메모리(DRAM)의 일부를 디스크처럼 사용하는 기술입니다. 물리적 디스크 대비 수십~수백 배 빠른 I/O 성능을 제공하지만, 전원이 꺼지면 데이터가 소실됩니다. 리눅스 커널에서 RAM 디스크는 크게 네 가지 형태로 존재합니다:

역사적 배경

RAM 디스크의 역사는 리눅스 커널 초기부터 시작됩니다:

RAM 디스크 아키텍처 총괄

리눅스 커널에서 RAM 기반 스토리지는 두 가지 경로로 제공됩니다: 블록 디바이스 계층(BRD, zram)과 VFS 파일시스템 계층(ramfs, tmpfs). 각각의 커널 스택 위치와 데이터 흐름을 살펴봅시다.

BRD 드라이버 (drivers/block/brd.c)

BRD(Block RAM Device)는 리눅스 커널의 전통적인 RAM 디스크 블록 드라이버입니다. /dev/ram0, /dev/ram1, ... 형태의 블록 디바이스를 생성하며, 요청 시 페이지를 동적으로 할당하여 데이터를 저장합니다.

주요 자료구조

/* drivers/block/brd.c */

struct brd_device {
    int                 brd_number;     /* 디바이스 번호 (ram0, ram1, ...) */
    struct request_queue *brd_queue;    /* 블록 요청 큐 */
    struct gendisk      *brd_disk;     /* 제네릭 디스크 구조체 */

    struct list_head    brd_list;      /* 전역 BRD 리스트 */

    /*
     * 데이터 저장: XArray(Radix Tree)로 섹터 → 페이지 매핑
     * 키: 섹터 번호 >> PAGE_SECTORS_SHIFT
     * 값: struct page *
     */
    spinlock_t          brd_lock;      /* 페이지 트리 보호 락 */
    struct xarray       brd_pages;     /* 섹터→페이지 매핑 XArray */
};

/* 전역 변수 */
static struct list_head brd_devices;   /* 모든 BRD 디바이스 리스트 */
static int rd_nr = CONFIG_BLK_DEV_RAM_COUNT;  /* 디바이스 개수 (기본 16) */
static int rd_size = CONFIG_BLK_DEV_RAM_SIZE; /* 각 디바이스 크기 (KB, 기본 4096) */
static int max_part = 1;                       /* 파티션 수 */

모듈 파라미터

블록 연산

/* BRD 블록 연산 구조체 */
static const struct block_device_operations brd_fops = {
    .owner      = THIS_MODULE,
    .submit_bio = brd_submit_bio,  /* BIO 제출 콜백 (no-queue 방식) */
};

/*
 * brd_submit_bio() — BIO 제출 핸들러
 * 블록 레이어가 이 함수를 직접 호출 (요청 큐 바이패스)
 */
static void brd_submit_bio(struct bio *bio)
{
    struct brd_device *brd = bio->bi_bdev->bd_disk->private_data;
    struct bio_vec bvec;
    struct bvec_iter iter;

    bio_for_each_segment(bvec, bio, iter) {
        unsigned int len = bvec.bv_len;
        struct page *page = bvec.bv_page;
        /* 세그먼트별로 페이지 복사 수행 */
        err = brd_do_bvec(brd, page, len,
                          bvec.bv_offset, iter);
        if (err) { ... }
    }
    bio_endio(bio);  /* BIO 완료 통지 */
}

/*
 * brd_do_bvec() — 실제 데이터 전송
 * READ: BRD 페이지 → BIO 페이지 (memcpy_from_page)
 * WRITE: BIO 페이지 → BRD 페이지 (memcpy_to_page)
 */
static int brd_do_bvec(struct brd_device *brd,
                       struct page *page, unsigned int len,
                       unsigned int off, struct bvec_iter *iter)
{
    sector_t sector = iter->bi_sector;
    struct page *brd_page;

    if (op_is_write(iter->bi_opf)) {
        /* 쓰기: 페이지가 없으면 새로 할당 */
        brd_page = brd_insert_page(brd, sector);
        memcpy_to_page(brd_page, offset, kaddr + off, len);
    } else {
        /* 읽기: 페이지가 없으면 0 반환 */
        brd_page = brd_lookup_page(brd, sector);
        if (brd_page)
            memcpy_from_page(kaddr + off, brd_page, offset, len);
        else
            memzero_page(page, off, len);
    }
    return 0;
}

페이지 관리

BRD는 XArray(구 Radix Tree)를 사용하여 섹터 번호를 페이지에 매핑합니다. 쓰기 시 처음 접근하는 섹터에 대해서만 페이지를 할당하므로, 메모리 사용이 효율적입니다.

/*
 * brd_lookup_page() — 섹터에 해당하는 페이지 조회
 */
static struct page *brd_lookup_page(struct brd_device *brd,
                                     sector_t sector)
{
    unsigned long idx;
    struct page *page;

    idx = sector >> PAGE_SECTORS_SHIFT;  /* 섹터 → 페이지 인덱스 */
    page = xa_load(&brd->brd_pages, idx);
    BUG_ON(page && page->index != idx);

    return page;  /* NULL이면 해당 섹터에 아직 쓰기 없음 */
}

/*
 * brd_insert_page() — 새 페이지 할당 후 XArray에 삽입
 */
static struct page *brd_insert_page(struct brd_device *brd,
                                     sector_t sector)
{
    unsigned long idx;
    struct page *page, *cur;

    page = brd_lookup_page(brd, sector);
    if (page)
        return page;  /* 이미 존재하면 그대로 반환 */

    page = alloc_page(GFP_NOIO | __GFP_ZERO);  /* 0으로 초기화된 페이지 */
    if (!page)
        return NULL;

    idx = sector >> PAGE_SECTORS_SHIFT;
    page->index = idx;

    spin_lock(&brd->brd_lock);
    cur = xa_store(&brd->brd_pages, idx, page, GFP_NOIO);
    spin_unlock(&brd->brd_lock);

    if (cur) {
        __free_page(page);  /* 경합 시 중복 페이지 해제 */
        page = cur;
    }
    return page;
}

DISCARD 지원

BRD는 DISCARD(TRIM) 연산을 지원합니다. DISCARD가 들어오면 해당 섹터 범위의 페이지를 XArray에서 제거하고 메모리를 해제합니다. 이를 통해 fstrim이나 blkdiscard 명령으로 사용하지 않는 영역의 메모리를 회수할 수 있습니다.

/*
 * brd_do_discard() — 페이지 해제
 */
static void brd_do_discard(struct brd_device *brd,
                           sector_t sector, u32 size)
{
    while (size >= PAGE_SIZE) {
        unsigned long idx = sector >> PAGE_SECTORS_SHIFT;
        struct page *page;

        spin_lock(&brd->brd_lock);
        page = xa_erase(&brd->brd_pages, idx);  /* XArray에서 제거 */
        spin_unlock(&brd->brd_lock);

        if (page)
            __free_page(page);  /* 메모리 해제 */

        sector += PAGE_SECTORS;
        size -= PAGE_SIZE;
    }
}

ramfs 파일시스템

ramfs는 리눅스 커널에서 가장 단순한 파일시스템 중 하나입니다. 페이지 캐시를 직접 데이터 저장소로 사용하며, VFS의 simple_* 헬퍼로 구현됩니다. 커널 소스에서 "VFS 구현 예제"로도 자주 인용됩니다.

ramfs 내부 구현

/* fs/ramfs/inode.c — 핵심 구조 */

static const struct super_operations ramfs_ops = {
    .statfs     = simple_statfs,
    .drop_inode = generic_delete_inode,
    .show_options = ramfs_show_options,
};

static const struct inode_operations ramfs_dir_inode_operations = {
    .create     = ramfs_create,      /* 파일 생성 */
    .lookup     = simple_lookup,     /* 디렉터리 조회 */
    .link       = simple_link,       /* 하드링크 */
    .unlink     = simple_unlink,     /* 파일 삭제 */
    .symlink    = ramfs_symlink,     /* 심볼릭 링크 */
    .mkdir      = ramfs_mkdir,       /* 디렉터리 생성 */
    .rmdir      = simple_rmdir,      /* 디렉터리 삭제 */
    .mknod      = ramfs_mknod,       /* 특수 파일 생성 */
    .rename     = simple_rename,     /* 이름 변경 */
};

/* ramfs의 address_space_operations — 페이지 캐시 직접 사용 */
static const struct address_space_operations ramfs_aops = {
    .read_folio     = simple_read_folio,      /* 페이지 읽기 */
    .write_begin    = simple_write_begin,      /* 쓰기 시작 */
    .write_end      = simple_write_end,        /* 쓰기 완료 */
    .dirty_folio    = noop_dirty_folio,        /* dirty 마킹 (no-op) */
};

/*
 * 핵심 포인트: ramfs는 writeback 하지 않음
 * dirty_folio가 noop이므로 페이지가 dirty로 표시되지 않고,
 * 따라서 커널의 writeback 메커니즘이 동작하지 않습니다.
 * 데이터는 페이지 캐시에 영원히 남습니다.
 */

/* fs/ramfs/inode.c — ramfs_fill_super(): 슈퍼블록 초기화 */

static int ramfs_fill_super(struct super_block *sb, struct fs_context *fc)
{
    struct ramfs_fs_info *fsi = sb->s_fs_info;
    struct inode *inode;

    /* 슈퍼블록 기본 설정 */
    sb->s_maxbytes    = MAX_LFS_FILESIZE;  /* 최대 파일 크기 */
    sb->s_blocksize   = PAGE_SIZE;         /* 블록 크기 = 페이지 크기 */
    sb->s_blocksize_bits = PAGE_SHIFT;
    sb->s_magic       = RAMFS_MAGIC;       /* 0x858458f6 */
    sb->s_op          = &ramfs_ops;
    sb->s_time_gran   = 1;                 /* 1나노초 해상도 */

    /* 루트 inode 생성 */
    inode = ramfs_get_inode(sb, NULL,
                S_IFDIR | fsi->mount_opts.mode, 0);
    /* ramfs_get_inode():
     *   inode = new_inode(sb);
     *   inode->i_mapping->a_ops = &ramfs_aops;  ← 핵심!
     *   inode->i_atime = inode->i_mtime = inode->i_ctime
     *       = current_time(inode);
     */

    /* 루트 dentry 생성 */
    sb->s_root = d_make_root(inode);
    if (!sb->s_root)
        return -ENOMEM;
    return 0;
}

/* init/do_mounts.c — rootfs로서의 ramfs 등록 */
/*
 * 커널 부팅 초기에 rootfs가 마운트됩니다.
 * CONFIG_TMPFS가 활성화되면 tmpfs가, 아니면 ramfs가 rootfs로 사용됩니다.
 * initramfs의 cpio 내용은 이 rootfs 위에 풀립니다.
 */
static struct file_system_type rootfs_fs_type = {
    .name       = "rootfs",
    .init_fs_context = rootfs_init_fs_context,
    /* CONFIG_TMPFS=y → shmem_init_fs_context()
     * CONFIG_TMPFS=n → ramfs_init_fs_context() */
};

마운트와 옵션

# ramfs 마운트 (크기 제한 없음!)
mount -t ramfs ramfs /mnt/ramdisk

# 마운트 옵션
mount -t ramfs -o mode=0755 ramfs /mnt/ramdisk

# ramfs는 size 옵션을 무시합니다 (크기 제한이 없음)
# 아래 명령의 size=100m은 효과 없음
mount -t ramfs -o size=100m ramfs /mnt/ramdisk

ramfs vs tmpfs 핵심 차이

tmpfs/shmem 개요

tmpfs는 ramfs를 확장한 메모리 기반 파일시스템으로, 내부적으로 shmem(Shared Memory) 인프라를 사용합니다. ramfs와 달리 크기 제한, 스왑 지원, xattr, POSIX ACL 등 완전한 파일시스템 기능을 제공합니다.

/* mm/shmem.c — shmem_get_folio() 핵심 흐름 */

/*
 * shmem_get_folio_gfp() — tmpfs 페이지 조회/할당의 핵심
 * 1. XArray에서 folio 조회
 * 2. 캐시 히트 → 바로 반환
 * 3. swap entry 발견 → shmem_swapin_folio()로 스왑인
 * 4. 없음 → 새 folio 할당
 */
static int shmem_get_folio_gfp(struct inode *inode,
    pgoff_t index, struct folio **foliop,
    enum sgp_type sgp, gfp_t gfp,
    struct mm_struct *fault_mm, int *fault_type)
{
    struct address_space *mapping = inode->i_mapping;
    struct shmem_inode_info *info = SHMEM_I(inode);
    struct folio *folio;

repeat:
    /* 1. XArray에서 folio 조회 */
    folio = filemap_get_folio(mapping, index);
    if (!IS_ERR(folio)) {
        /* 캐시 히트: folio가 이미 메모리에 있음 */
        if (sgp == SGP_WRITE)
            folio_set_referenced(folio);
        return 0;
    }

    /* 2. XArray에 swap entry가 있는 경우 → 스왑인 */
    folio = shmem_swapin_folio(inode, index, ...);
    if (folio)
        goto got_folio;

    /* 3. 새 folio 할당 */
    folio = shmem_alloc_folio(gfp, info, index);
    if (!folio)
        return -ENOMEM;

    /* THP: huge=always이면 2MB folio 할당 시도 */
    if (shmem_huge_enabled(inode)) {
        folio = shmem_alloc_and_add_folio(mapping, gfp | __GFP_COMP,
                    index, HPAGE_PMD_ORDER, ...);
    }
    ...
}

/* shmem_swapin_folio() — 스왑에서 folio 복구 */
static int shmem_swapin_folio(struct inode *inode, pgoff_t index, ...)
{
    swp_entry_t swap;

    /* XArray에서 swap entry 추출 */
    swap = radix_to_swp_entry(
        xa_load(&inode->i_mapping->i_pages, index));

    /* swap 영역에서 데이터 읽기 */
    folio = swap_cache_get_folio(swap, NULL, 0);
    if (!folio) {
        folio = shmem_swapin(swap, gfp, info, index);
        /* 디스크/zram에서 4KB 데이터 읽기 */
    }

    /* XArray에서 swap entry를 folio로 교체 */
    xa_store(&mapping->i_pages, index, folio, GFP_KERNEL);
    info->swapped--;

    return 0;
}

/* shmem_writepage() — 메모리 부족 시 스왑 아웃 */
static int shmem_writepage(struct page *page,
    struct writeback_control *wbc)
{
    struct shmem_inode_info *info = SHMEM_I(inode);
    swp_entry_t swap;

    /* 1. 스왑 슬롯 할당 */
    swap = get_swap_page(folio);
    if (!swap.val)
        return 0;  /* 스왑 공간 부족 → 메모리에 유지 */

    /* 2. XArray에 swap entry 저장 (shadow) */
    xa_store(&mapping->i_pages, folio->index,
             swp_to_radix_entry(swap), GFP_ATOMIC);

    /* 3. folio를 스왑 캐시로 이동 */
    set_page_dirty(page);
    add_to_swap_cache(folio, swap, ...);

    info->swapped++;
    /* → kswapd가 나중에 실제 디스크/zram에 기록 */
    return 0;
}

# tmpfs 마운트 — 다양한 옵션
mount -t tmpfs -o size=512m,nr_inodes=10k,mode=1777 tmpfs /tmp

# 주요 마운트 옵션
#   size=512m       — 최대 크기 (기본: RAM의 50%)
#   nr_inodes=10k   — 최대 inode 수
#   mode=1777       — 루트 디렉터리 권한
#   uid=0,gid=0     — 소유자/그룹
#   huge=always      — Transparent Huge Pages 사용
#   noswap           — 스왑 비활성화 (5.18+)

# 시스템에서 기본 사용되는 tmpfs
df -h -t tmpfs
# tmpfs           7.8G  1.2G  6.7G  15% /run
# tmpfs           7.8G     0  7.8G   0% /dev/shm
# tmpfs           7.8G  4.0K  7.8G   1% /tmp

# /proc/meminfo에서 tmpfs(shmem) 메모리 사용 확인
grep -E 'Shmem|SwapCached|SwapTotal|SwapFree' /proc/meminfo
# Shmem:           1234568 kB   ← tmpfs가 사용하는 총 메모리
# SwapCached:        45678 kB   ← 스왑에서 다시 읽어온 페이지
# SwapTotal:       4194304 kB   ← 전체 스왑 공간
# SwapFree:        3891200 kB   ← 사용 가능한 스왑

# shmem이 스왑 아웃되는 과정 관찰
# 1. tmpfs에 대량 데이터 쓰기
dd if=/dev/urandom of=/tmp/bigfile bs=1M count=2048

# 2. 메모리 압박 유발 → shmem 페이지 스왑 아웃
cat /proc/vmstat | grep pswp
# pswpout 12345   ← 스왑 아웃된 페이지 수
# pswpin  6789    ← 스왑 인 된 페이지 수

# 3. 스왑 아웃된 shmem 페이지 수 확인
cat /proc/meminfo | grep Shmem
# Shmem:           1234568 kB   ← 메모리 상주 shmem
# ShmemHugePages:     0 kB      ← THP로 할당된 shmem
# ShmemPmdMapped:     0 kB      ← PMD로 매핑된 shmem

initrd (레거시 RAM 디스크)

initrd(Initial RAM Disk)는 커널 2.0부터 사용된 레거시 초기 루트 파일시스템 메커니즘입니다. 부트로더가 압축된 디스크 이미지를 메모리에 로드하면, 커널이 이를 /dev/ram0(BRD)에 기록하고 파일시스템으로 마운트하여 초기 사용자 공간을 제공합니다.

initrd 부팅 흐름

커널 코드 분석

/* init/do_mounts_rd.c — initrd 이미지 로딩 */

/*
 * rd_load_image() — initrd 이미지를 /dev/ram0에 기록
 * 부트로더가 메모리에 로드한 initrd를 BRD 디바이스에 복사
 */
static int __init rd_load_image(char *from)
{
    int nblocks, i;
    struct file *in_file, *out_file;

    /* initrd 원본 열기 (커널이 물리 주소를 /initrd.image로 매핑) */
    in_file = filp_open(from, O_RDONLY, 0);

    /* /dev/ram0 출력 열기 */
    out_file = filp_open("/dev/ram0", O_RDWR, 0);

    /* 이미지가 gzip/bzip2 압축인지 확인 */
    identify_ramdisk_image(in_file, &decompressor);

    /* 블록 단위로 복사 */
    for (i = 0; i < nblocks; i++) {
        kernel_read(in_file, buf, BLOCK_SIZE, &in_pos);
        kernel_write(out_file, buf, BLOCK_SIZE, &out_pos);
    }

    return 1;
}

/* init/do_mounts.c — initrd 마운트와 전환 */
void __init prepare_namespace(void)
{
    if (initrd_load()) {
        /* /dev/ram0을 루트로 마운트 성공 */
        /* /linuxrc 실행 → 실제 루트 탐색 */
        handle_initrd();
    }
    mount_root();  /* 실제 루트 파일시스템 마운트 */
}

/*
 * handle_initrd() 흐름:
 * 1. mount /dev/ram0 as root
 * 2. execute /linuxrc (사용자 스크립트)
 * 3. mount real root device
 * 4. pivot_root(new_root, put_old)
 * 5. umount old ramdisk, free memory
 */

initrd 이미지 포맷

# initrd 이미지의 매직 바이트 확인 (hexdump)
hexdump -C /boot/initrd.img | head -3
# 00000000  1f 8b 08 00 00 00 00 00  00 03 ...  ← gzip 압축 (0x1F 0x8B)

# 압축 해제 후 cpio인지 ext2인지 확인
file /boot/initrd.img
# /boot/initrd.img: gzip compressed data, ...

# gzip 해제 후 내부 확인
zcat /boot/initrd.img | file -
# /dev/stdin: ASCII cpio archive (SVR4 with no CRC)  ← initramfs (cpio)

# 레거시 initrd ext2 이미지의 슈퍼블록 매직 확인
# 오프셋 1080 (0x438)에 2바이트 리틀엔디언 = 0xEF53
hexdump -C initrd-legacy.img -s 0x438 -n 2
# 00000438  53 ef                                  ← ext2 매직!

/* init/do_mounts_rd.c — identify_ramdisk_image() 핵심 로직 */

static int __init identify_ramdisk_image(int fd, int start_block,
                                          decompress_fn *decompressor)
{
    const int size = 512;  /* 첫 512바이트 읽기 */
    struct ext2_super_block *ext2sb;
    int nblocks = -1;
    unsigned char *buf;

    buf = kmalloc(size, GFP_KERNEL);
    sys_lseek(fd, start_block * BLOCK_SIZE, 0);
    sys_read(fd, buf, size);

    /* 1단계: 압축 감지 — 매직 바이트로 decompressor 선택 */
    *decompressor = decompress_method(buf, size, NULL);
    if (*decompressor) {
        printk(KERN_NOTICE "RAMDISK: compressed image found "
               "at block %d\n", start_block);
        nblocks = 0;  /* 압축 → 크기 알 수 없음 */
        goto done;
    }

    /* 2단계: ext2 슈퍼블록 확인 (오프셋 1024) */
    sys_lseek(fd, start_block * BLOCK_SIZE + 1024, 0);
    sys_read(fd, buf, sizeof(struct ext2_super_block));
    ext2sb = (struct ext2_super_block *)buf;

    if (ext2sb->s_magic == cpu_to_le16(EXT2_SUPER_MAGIC)) {
        /* ext2 이미지 → initrd로 처리 */
        nblocks = le32_to_cpu(ext2sb->s_blocks_count);
        printk(KERN_NOTICE "RAMDISK: ext2 filesystem found "
               "at block %d\n", start_block);
        goto done;
    }

    /* 3단계: romfs, minix 등 기타 파일시스템 확인 */
    ...

done:
    kfree(buf);
    return nblocks;  /* -1 = 인식 불가, 0 = 압축, >0 = 블록 수 */
}

initrd 생성 방법

# 레거시 initrd 이미지 수동 생성 (ext2 기반)
dd if=/dev/zero of=initrd.img bs=1M count=32
mkfs.ext2 -F initrd.img
mkdir /tmp/initrd_mount
mount -o loop initrd.img /tmp/initrd_mount

# 필요한 파일 복사
cp -a /bin/busybox /tmp/initrd_mount/bin/
# /linuxrc 스크립트 생성
cat > /tmp/initrd_mount/linuxrc << 'SCRIPT'
#!/bin/busybox sh
/bin/busybox --install -s /bin
mount -t proc proc /proc
mount -t sysfs sysfs /sys
# 드라이버 모듈 로드
insmod /lib/modules/scsi_mod.ko
insmod /lib/modules/sd_mod.ko
# 실제 루트 디바이스 설정
echo 0x0801 > /proc/sys/kernel/real-root-dev
SCRIPT
chmod +x /tmp/initrd_mount/linuxrc

umount /tmp/initrd_mount
gzip initrd.img  # → initrd.img.gz

initramfs (cpio 기반)

initramfs는 커널 2.6에서 도입된 현대적 초기 루트 파일시스템 메커니즘입니다. cpio 아카이브를 커널이 직접 rootfs(tmpfs 인스턴스)에 풀어놓고 /init을 실행합니다. BRD 블록 디바이스가 불필요하고, 메모리 사용도 효율적입니다.

커널 언패킹 코드

/* init/initramfs.c — 핵심 언패킹 코드 */

/*
 * populate_rootfs() — initramfs 메인 진입점
 * 빌트인 + 외부 initramfs를 순서대로 rootfs에 풀어놓음
 */
static int __init populate_rootfs(void)
{
    /* 1. 빌트인 initramfs (항상 존재, 최소 /dev/console 포함) */
    err = unpack_to_rootfs(__initramfs_start, __initramfs_size);

    /* 2. 외부 initramfs (부트로더가 전달한 경우) */
    if (initrd_start) {
        err = unpack_to_rootfs((char *)initrd_start,
                               initrd_end - initrd_start);
        if (!err) {
            free_initrd();  /* 원본 메모리 해제 */
            return 0;
        }
        /* cpio가 아니면 레거시 initrd로 폴백 */
        ...
    }
    return 0;
}

/*
 * unpack_to_rootfs() — cpio 아카이브 언패킹
 * newc 포맷 (070701) 파싱 → 파일/디렉터리/링크 생성
 */
static int __init unpack_to_rootfs(char *buf, unsigned long len)
{
    /* 압축 감지 및 해제 */
    decompress_fn decompress = decompress_method(buf, len, &compress_name);
    if (decompress) {
        /* gz/lz4/zstd 등 압축 해제 → cpio 스트림 */
        int res = decompress(buf, len, NULL, flush_buffer, ...);
    }

    /* cpio 엔트리 순회 */
    while (!eof) {
        if (S_ISDIR(mode))
            do_mkdir(name, mode);           /* 디렉터리 생성 */
        else if (S_ISREG(mode))
            do_create(name, mode, body);    /* 일반 파일 생성 */
        else if (S_ISLNK(mode))
            do_symlink(name, target);       /* 심볼릭 링크 */
        else
            do_mknod(name, mode, rdev);     /* 디바이스 노드 */
    }
    return 0;
}

빌트인 initramfs

모든 리눅스 커널에는 최소한의 빌트인 initramfs가 포함됩니다. CONFIG_INITRAMFS_SOURCE를 설정하면 커널 이미지에 직접 initramfs를 내장할 수 있습니다.

# .config에서 빌트인 initramfs 설정
CONFIG_INITRAMFS_SOURCE="/path/to/initramfs_list"

# initramfs_list 예시 (gen_init_cpio 포맷)
# 형식: file/dir/nod/slink <name> <mode> <uid> <gid> [추가인자]
dir  /dev              0755  0  0
nod  /dev/console      0600  0  0  c  5  1
nod  /dev/null         0666  0  0  c  1  3
dir  /bin              0755  0  0
file /init             /path/to/init       0755  0  0
file /bin/busybox      /path/to/busybox    0755  0  0
slink /bin/sh          /bin/busybox        0777  0  0

# 또는 디렉터리를 직접 지정
CONFIG_INITRAMFS_SOURCE="/my/initramfs/root"

# 빌드 시 커널 이미지에 포함됨
make bzImage  # vmlinuz 안에 initramfs 포함

외부 initramfs

대부분의 배포판은 외부 initramfs 파일을 별도로 생성하여 부트로더에서 커널과 함께 로드합니다.

# GRUB 설정 예시
menuentry 'Linux' {
    linux  /vmlinuz root=/dev/sda2 ro
    initrd /initramfs.img    # 외부 initramfs
}

# initramfs 내용 확인
file /boot/initramfs-$(uname -r).img
# → /boot/initramfs-6.1.0.img: gzip compressed data

# 내용 추출
mkdir /tmp/initramfs && cd /tmp/initramfs
zcat /boot/initramfs-$(uname -r).img | cpio -idmv
# 또는 (microcode + main cpio 결합 형태)
skipcpio /boot/initramfs-$(uname -r).img | zcat | cpio -idmv

# 디렉터리 구조 확인
ls -la
# init -> /usr/lib/systemd/systemd  (또는 /init 스크립트)
# bin/ sbin/ lib/ etc/ dev/ proc/ sys/ ...

# microcode + initramfs 결합 이미지 분석
# 최신 배포판은 CPU microcode + 실제 initramfs를 하나의 파일에 결합
# 첫 번째 cpio = microcode, 두 번째 cpio = initramfs

# 크기별 분석
cpio -t < /boot/initramfs-$(uname -r).img 2>/dev/null | head -5
# early_cpio 부분 → kernel/x86/microcode/AuthenticAMD.bin

# initramfs 전체 크기와 구성 파악
lsinitrd /boot/initramfs-$(uname -r).img 2>/dev/null | tail -20
# 또는 Debian/Ubuntu:
lsinitramfs /boot/initrd.img-$(uname -r) 2>/dev/null | wc -l
# → 일반적으로 500~3000개 파일

initramfs 생성

# Debian/Ubuntu: mkinitramfs
mkinitramfs -o /boot/initramfs-$(uname -r).img $(uname -r)

# RHEL/Fedora: dracut
dracut /boot/initramfs-$(uname -r).img $(uname -r)

# dracut 옵션 예시
dracut --force --verbose \
    --add "lvm dm crypt" \
    --drivers "ahci nvme" \
    /boot/initramfs-custom.img $(uname -r)

# 수동 cpio 생성
cd /my/initramfs/root
find . | cpio -o -H newc | gzip > /boot/initramfs-custom.img

# 수동 cpio 생성 (zstd 압축, 더 빠름)
find . | cpio -o -H newc | zstd -19 > /boot/initramfs-custom.img.zst

#!/bin/sh
# === 최소 initramfs /init 스크립트 예시 ===
# initramfs 내 /init으로 저장 (실행 권한 필수)

mount -t proc proc /proc
mount -t sysfs sysfs /sys
mount -t devtmpfs devtmpfs /dev

# 커널 모듈 로드 (필요시)
modprobe ext4
modprobe nvme

# 실제 루트 마운트
ROOTDEV=$(cat /proc/cmdline | sed 's/.*root=\([^ ]*\).*/\1/')
mount -o ro "$ROOTDEV" /mnt/root

# switch_root: rootfs를 정리하고 새 루트로 전환
exec switch_root /mnt/root /sbin/init

# dracut 모듈 구조 (모듈 방식 initramfs 생성)
# /usr/lib/dracut/modules.d/
#   90lvm/          — LVM 볼륨 활성화
#   90crypt/        — LUKS 암호화 볼륨 해제
#   95rootfs-block/  — 블록 디바이스 루트 마운트
#   99base/          — 기본 init 프레임워크

# dracut으로 특정 모듈만 포함한 최소 initramfs 생성
dracut --no-hostonly --force \
    --modules "base rootfs-block" \
    --drivers "ext4 nvme" \
    /boot/initramfs-minimal.img $(uname -r)

initrd vs initramfs 비교

/* init/initramfs.c — initramfs vs initrd 자동 판별 핵심 코드 */

/*
 * populate_rootfs()에서 initramfs와 initrd를 자동 판별:
 * 1. __initramfs_start에 빌트인 initramfs가 있으면 먼저 풀기
 * 2. initrd_start가 설정되어 있으면:
 *    a. cpio 매직("070701")이면 → initramfs로 풀기
 *    b. ext2 매직(0xEF53)이면 → /dev/ram0에 복사 (레거시 initrd)
 *    c. 압축되어 있으면 → 해제 후 재판별
 */
static int __init populate_rootfs(void)
{
    /* 빌트인 initramfs 풀기 (항상 존재, 최소 빈 cpio) */
    unpack_to_rootfs(__initramfs_start, __initramfs_size);

    if (initrd_start) {
        /* 외부 initrd/initramfs 처리 */
        err = unpack_to_rootfs((char *)initrd_start,
                               initrd_end - initrd_start);
        if (err) {
            /* cpio가 아님 → 레거시 initrd로 처리 */
            /* /initrd.image에 저장 후 rd_load_image()로 /dev/ram0 복사 */
            clean_rootfs();
            populate_initrd_image(initrd_start);
        }
        free_initrd();
    }
    return 0;
}

zram 압축 블록 디바이스

zram은 메모리 내 압축 블록 디바이스입니다. 데이터를 쓰면 실시간으로 압축하여 저장하고, 읽을 때 해제하여 반환합니다. 주로 스왑 파티션으로 사용하여 메모리 용량을 실질적으로 2~3배 늘리는 효과를 얻습니다. Android, Chrome OS, Fedora 등에서 기본 활성화되어 있습니다.

zram 아키텍처

주요 자료구조

/* drivers/block/zram/zram_drv.h */

struct zram {
    struct zram_table_entry *table;  /* 섹터별 메타데이터 배열 */
    struct zs_pool *mem_pool;        /* zsmalloc 메모리 풀 */
    struct zcomp *comps[ZRAM_MAX_COMPS]; /* 압축 알고리즘 */
    struct gendisk *disk;            /* 블록 디바이스 */
    struct rw_semaphore init_lock;   /* 초기화 락 */

    /* 통계 */
    atomic64_t stats[NR_ZRAM_STAT_ITEM];
    u64 disksize;                    /* 디스크 크기 (비압축 기준) */

    /* Writeback 관련 */
    struct block_device *backing_dev;  /* 백킹 디바이스 */
    spinlock_t wb_limit_lock;
    unsigned long *bitmap;             /* writeback 비트맵 */
    ...
};

struct zram_table_entry {
    union {
        unsigned long handle;     /* zsmalloc 핸들 (압축 데이터 위치) */
        unsigned long element;    /* same_element 값 */
    };
    unsigned int flags;           /* ZRAM_SAME, ZRAM_WB, ZRAM_HUGE 등 */
#ifdef CONFIG_ZRAM_TRACK_ENTRY_ACTIME
    ktime_t ac_time;              /* 접근 시간 (writeback 판단용) */
#endif
};

/* 플래그 비트 */
#define ZRAM_SAME       (1 << 0)  /* 모든 바이트가 동일 (예: 0으로 채워진 페이지) */
#define ZRAM_WB         (1 << 1)  /* backing device로 writeback됨 */
#define ZRAM_HUGE       (1 << 2)  /* 압축이 비효율적 (원본 저장) */
#define ZRAM_IDLE       (1 << 3)  /* 유휴 상태 (writeback 후보) */

압축 알고리즘

# zram 압축 알고리즘 변경
echo lz4 > /sys/block/zram0/comp_algorithm

# 사용 가능한 알고리즘 확인 (현재 선택은 [ ] 표시)
cat /sys/block/zram0/comp_algorithm
# lzo lzo-rle [lz4] zstd 842 deflate

# 다중 압축 스트림 (커널 6.2+)
# 기본(빠른) + 보조(높은 압축률) 이중 압축
echo zstd > /sys/block/zram0/recomp_algorithm
echo type=huge > /sys/block/zram0/recompress  # 비효율 페이지 재압축

zram writeback

zram writeback은 유휴(idle) 페이지나 비압축(huge) 페이지를 실제 디스크로 이동하여 메모리를 추가로 확보하는 기능입니다. 커널 4.14에서 도입되었습니다.

# 1. backing device 설정 (초기화 전에)
echo /dev/sdb1 > /sys/block/zram0/backing_dev

# 2. zram 디스크 크기 설정 및 활성화
echo 4G > /sys/block/zram0/disksize
mkswap /dev/zram0
swapon /dev/zram0

# 3. 유휴 페이지 마킹
echo all > /sys/block/zram0/idle  # 모든 페이지를 idle로 마킹

# 4. writeback 실행
echo idle > /sys/block/zram0/writeback     # idle 페이지 writeback
echo huge > /sys/block/zram0/writeback     # huge(비압축) 페이지 writeback
echo huge_idle > /sys/block/zram0/writeback # 둘 다

# 5. writeback 제한 (바이트 단위)
echo $((512*1024*1024)) > /sys/block/zram0/writeback_limit  # 512MB 제한

/* drivers/block/zram/zram_drv.c — writeback 핵심 함수 */

static int zram_writeback_page(struct zram *zram, u32 index)
{
    struct bio bio;
    struct bio_vec bvec;
    struct page *page;
    unsigned long handle;
    int ret;

    /* 1. 플래그 확인: IDLE 또는 HUGE만 writeback 대상 */
    if (!zram_test_flag(zram, index, ZRAM_IDLE) &&
        !zram_test_flag(zram, index, ZRAM_HUGE))
        return 0;

    /* 이미 writeback 된 페이지는 건너뜀 */
    if (zram_test_flag(zram, index, ZRAM_WB))
        return 0;

    /* 2. backing device의 빈 블록 찾기 (bitmap 검색) */
    unsigned long blk_idx;
    blk_idx = alloc_block_bdev(zram);
    if (!blk_idx)
        return -ENOSPC;  /* backing 공간 부족 */

    /* 3. zsmalloc에서 압축 데이터 읽기 → 해제 → 임시 페이지 */
    page = alloc_page(GFP_NOIO);
    handle = zram->table[index].handle;
    src = zs_map_object(zram->mem_pool, handle, ZS_MM_RO);
    zcomp_decompress(zram->comps[ZRAM_PRIMARY_COMP],
                     src, PAGE_SIZE, page_address(page));
    zs_unmap_object(zram->mem_pool, handle);

    /* 4. backing device에 페이지 크기(4KB) 기록 */
    bio_init(&bio, zram->backing_dev, &bvec, 1,
             REQ_OP_WRITE | REQ_SYNC);
    bio.bi_iter.bi_sector = blk_idx * (PAGE_SIZE >> 9);
    bio_add_page(&bio, page, PAGE_SIZE, 0);
    ret = submit_bio_wait(&bio);

    /* 5. 메타데이터 갱신 */
    if (!ret) {
        /* zsmalloc 핸들 해제 → 메모리 반환! */
        zs_free(zram->mem_pool, handle);

        /* entry를 WB 상태로 전환 */
        zram_set_flag(zram, index, ZRAM_WB);
        zram_set_element(zram, index, blk_idx);
        /* handle → blk_idx (backing device 오프셋) */

        atomic64_inc(&zram->stats[ZRAM_WB_COUNT]);
    }

    __free_page(page);
    return ret;
}

/* 커널 6.2+: recompression — huge 페이지를 더 강한 알고리즘으로 재압축 */

/*
 * lz4로 1차 압축한 페이지 중 압축률이 낮은(huge) 것을
 * zstd로 재압축하여 메모리 절약. writeback 전 시도.
 *
 * echo algo=zstd > /sys/block/zram0/recomp_algorithm
 * echo type=huge > /sys/block/zram0/recompress
 */
static int zram_recompress(struct zram *zram, u32 index,
                           struct page *page, int *comp_len_p,
                           u32 prio)
{
    /* 1차 압축 데이터를 해제 */
    src = zs_map_object(zram->mem_pool, handle, ZS_MM_RO);
    zcomp_decompress(zram->comps[ZRAM_PRIMARY_COMP], ...);

    /* 보조 알고리즘(zstd 등)으로 재압축 */
    ret = zcomp_compress(zram->comps[prio], page, dst, comp_len_p);

    if (*comp_len_p < old_comp_len) {
        /* 재압축 성공: 새 핸들 할당 후 교체 */
        new_handle = zs_malloc(zram->mem_pool, *comp_len_p, ...);
        zs_free(zram->mem_pool, old_handle);
        /* → 메모리 절약 */
    }
    return ret;
}

# writeback 제한(limit) 관리
# writeback_limit은 backing device 사용량 제한 (4KB 페이지 단위)
echo 131072 > /sys/block/zram0/writeback_limit  # 512MB 제한 (131072 * 4KB)
echo 1 > /sys/block/zram0/writeback_limit_enable

# backing device 통계 확인
cat /sys/block/zram0/bd_stat
# bd_count  bd_reads  bd_writes
# 12345     6789      12345
# writeback된 페이지 수 / backing에서 읽은 횟수 / 쓴 횟수

zsmalloc 내부 구조

zsmalloc은 zram 전용 메모리 할당자로, 가변 크기 압축 데이터를 효율적으로 저장합니다. 일반 slab/slub 할당자는 고정 크기 객체에 최적화되어 있어 가변 크기 압축 데이터에는 내부 단편화가 심합니다. zsmalloc은 여러 물리 페이지를 하나의 zspage로 결합하여 단편화를 최소화합니다.

/* mm/zsmalloc.c — 핵심 API */

/* zs_malloc: 압축 데이터 저장 공간 할당 */
unsigned long zs_malloc(struct zs_pool *pool, size_t size, gfp_t gfp)
{
    struct size_class *class;
    struct zspage *zspage;
    unsigned long handle;

    /* 1. 크기 클래스 결정 (16바이트 단위 올림) */
    class = pool->size_class[get_size_class_index(size)];

    /* 2. ALMOST_EMPTY에서 빈 슬롯이 있는 zspage 검색 */
    zspage = find_get_zspage(class);
    if (!zspage) {
        /* 3. 새 zspage 할당 (class->pages_per_zspage개의 페이지) */
        zspage = alloc_zspage(pool, class, gfp);
    }

    /* 4. 빈 슬롯에서 obj_index 할당 */
    obj = obj_malloc(pool, zspage, handle);

    /* 5. fullness group 재분류 */
    fix_fullness_group(class, zspage);

    return handle;  /* PFN + obj_index 인코딩 */
}

/* zs_map_object: handle → 가상 주소 매핑 */
void *zs_map_object(struct zs_pool *pool, unsigned long handle,
                    enum zs_mapmode mm)
{
    /* handle에서 PFN, obj_index 디코딩 */
    obj_to_location(handle, &page, &obj_idx);

    /* 객체가 페이지 경계를 넘는 경우:
     * 두 페이지를 연속 가상 주소로 매핑 (kmap) */
    if (ZS_HANDLE_SIZE + size > PAGE_SIZE) {
        /* cross-page mapping */
        area->vm_buf = kmap_local_page(page);
        area->vm_buf2 = kmap_local_page(next_page);
        memcpy(area->vm_buf, ...);  /* 임시 버퍼로 복사 */
    }
    return area->vm_addr + obj_offset;
}

/* zs_free: 객체 해제 */
void zs_free(struct zs_pool *pool, unsigned long handle)
{
    obj_to_location(handle, &page, &obj_idx);
    zspage = get_zspage(page);
    class = zspage_class(pool, zspage);

    obj_free(class->size, handle);  /* 프리리스트에 반환 */

    /* zspage가 완전히 비었으면 페이지 해제 */
    if (get_fullness_group(class, zspage) == ZS_EMPTY) {
        free_zspage(pool, class, zspage);
    }
}

zcomp 압축 스트림

zram의 압축/해제는 zcomp(zram compression) 계층을 통해 수행됩니다. 각 CPU에 전용 압축 스트림(zcomp_strm)을 할당하여 락 경합 없이 병렬 처리합니다.

/* drivers/block/zram/zcomp.c — per-CPU 스트림 관리 */

struct zcomp_strm {
    struct crypto_comp *tfm;  /* 커널 crypto API 핸들 */
    void *buffer;             /* 압축 출력 버퍼 (PAGE_SIZE * 2) */
};

struct zcomp {
    struct zcomp_strm __percpu *stream;  /* per-CPU 스트림 배열 */
    const char *name;                     /* 알고리즘 이름 */
};

/* 현재 CPU의 스트림 획득 (preempt 비활성화) */
struct zcomp_strm *zcomp_stream_get(struct zcomp *comp)
{
    return get_cpu_ptr(comp->stream);
    /* preempt_disable() → 현재 CPU의 zcomp_strm 반환
     * 다른 CPU로 마이그레이션 방지 → 락 불필요 */
}

void zcomp_stream_put(struct zcomp *comp)
{
    put_cpu_ptr(comp->stream);
    /* preempt_enable() */
}

/* 압축 실행 */
int zcomp_compress(struct zcomp *comp, struct page *page,
                   void *dst, unsigned int *dst_len)
{
    struct zcomp_strm *strm = zcomp_stream_get(comp);

    /* 커널 crypto API로 압축 */
    *dst_len = PAGE_SIZE * 2;  /* 최대 출력 크기 */
    ret = crypto_comp_compress(strm->tfm,
            page_address(page), PAGE_SIZE,  /* 입력: 4KB */
            strm->buffer, dst_len);          /* 출력: 압축 데이터 */

    memcpy(dst, strm->buffer, *dst_len);
    zcomp_stream_put(comp);
    return ret;
}

sysfs 인터페이스

# mm_stat 해석 (공백 구분, 9개 필드)
cat /sys/block/zram0/mm_stat
# orig_data_size  compr_data_size  mem_used_total  mem_limit  max_used
# same_pages  pages_compacted  huge_pages  huge_pages_since

# 예시 해석:
# 2147483648  715827882  734003200  0  891289600  12345  0  567  890
# 원본 2GB → 압축 후 682MB → 실제 메모리 700MB (오버헤드 포함)
# 압축률: 715827882 / 2147483648 ≈ 33% (3:1 압축)

zram swap 설정

# === 기본 zram swap 설정 ===

# 1. 모듈 로드 (num_devices로 디바이스 수 지정)
modprobe zram num_devices=1

# 2. 압축 알고리즘 선택
echo lz4 > /sys/block/zram0/comp_algorithm

# 3. 디스크 크기 설정 (물리 RAM의 50~100%)
echo 4G > /sys/block/zram0/disksize

# 4. 스왑으로 활성화 (높은 우선순위)
mkswap /dev/zram0
swapon -p 100 /dev/zram0

# 5. 확인
swapon --show
# NAME       TYPE      SIZE  USED PRIO
# /dev/zram0 partition 4G    1.2G 100

# === systemd-zram-setup (Fedora/Arch) ===
# /etc/systemd/zram-generator.conf
# [zram0]
# zram-size = ram / 2
# compression-algorithm = zstd
# swap-priority = 100

# === 해제 ===
swapoff /dev/zram0
echo 1 > /sys/block/zram0/reset

메모리 백킹 메커니즘

RAM 디스크의 네 가지 유형은 각각 다른 메모리 관리 전략을 사용합니다. 이 차이가 성능, 메모리 효율, 기능의 근본적인 차이를 만듭니다.

# NUMA 환경에서 tmpfs 메모리 할당 정책 설정
# mpol=interleave: 모든 NUMA 노드에 균등 분배
mount -t tmpfs -o size=4g,mpol=interleave tmpfs /mnt/balanced

# mpol=bind:0: 특정 노드에만 할당 (지역성 최적화)
mount -t tmpfs -o size=2g,mpol=bind:0 tmpfs /mnt/node0

# mpol=prefer:1: 노드 1 선호, 불가능하면 다른 노드
mount -t tmpfs -o size=2g,mpol=prefer:1 tmpfs /mnt/prefer1

# BRD와 zram은 NUMA 비인식 (NUMA_NO_NODE로 할당)
# → 어떤 NUMA 노드에서 페이지가 할당될지 예측 불가

페이지 캐시 기반 (ramfs/tmpfs)

/*
 * ramfs: 페이지 캐시(address_space)를 직접 데이터 저장소로 사용
 *
 * 일반 파일시스템에서 페이지 캐시는 "디스크 데이터의 캐시"이지만,
 * ramfs에서는 페이지 캐시가 "유일한 데이터 저장소"입니다.
 * writeback이 없으므로 dirty 페이지가 영원히 메모리에 남습니다.
 */

/* 읽기: 페이지 캐시에서 직접 반환 */
static int ramfs_read_folio(struct file *file, struct folio *folio)
{
    folio_zero_range(folio, 0, folio_size(folio));
    folio_mark_uptodate(folio);
    folio_unlock(folio);
    return 0;
}

/* 쓰기: 페이지 캐시에 직접 기록 (디스크 writeback 없음) */
static int ramfs_write_begin(struct file *file,
    struct address_space *mapping, loff_t pos, unsigned len,
    struct page **pagep, void **fsdata)
{
    return simple_write_begin(file, mapping, pos, len, pagep, fsdata);
    /* simple_write_begin은 grab_cache_page_write_begin() 호출 */
    /* → 페이지 캐시에 페이지 할당/조회 */
}

/*
 * tmpfs (shmem): 유사하지만 스왑 지원
 * - shmem_get_folio()로 페이지 조회/할당
 * - 메모리 부족 시 shmem 페이지를 스왑 파일/파티션으로 이동
 * - shmem_swapin_folio()로 스왑에서 복구
 */

XArray 기반 (BRD)

/*
 * BRD: XArray로 섹터→페이지 매핑 관리
 *
 * 파일시스템의 페이지 캐시와 독립적으로 동작.
 * 블록 디바이스이므로 그 위에 어떤 파일시스템이든 마운트 가능.
 *
 * 메모리 레이아웃:
 *   XArray[0] → struct page (섹터 0~7, 4KB)
 *   XArray[1] → struct page (섹터 8~15, 4KB)
 *   XArray[2] → NULL (아직 미사용)
 *   XArray[3] → struct page (섹터 24~31, 4KB)
 *   ...
 *
 * 특징:
 * - 쓰기 시에만 페이지 할당 (온디맨드)
 * - DISCARD로 페이지 해제 가능
 * - 읽기 시 NULL이면 0 반환 (할당 없이)
 */

/* BRD 위에 ext4 마운트 예시 */
// dd → brd_submit_bio → brd_insert_page → XArray 저장
// mount → ext4 → BIO → brd_submit_bio → brd_lookup_page → XArray 조회
// fstrim → DISCARD → brd_do_discard → xa_erase → __free_page

zsmalloc 기반 (zram)

/*
 * zram: zsmalloc으로 압축 데이터 관리
 *
 * zsmalloc은 "가변 크기 작은 객체"를 효율적으로 저장하는 할당자.
 * 일반 slab/slub은 고정 크기 객체에 최적화되어 있지만,
 * 압축 데이터는 크기가 가변적이므로 zsmalloc이 적합.
 *
 * zsmalloc 내부 동작:
 * 1. 크기 클래스(size class) 결정 — 16바이트 단위
 * 2. 해당 클래스의 zspage에서 빈 슬롯 할당
 * 3. 여러 물리 페이지를 하나의 zspage로 결합 (외부 단편화 최소화)
 * 4. handle 반환 (페이지 + 오프셋 인코딩)
 */

/* 쓰기 흐름 */
static int zram_write_page(struct zram *zram, struct page *page, u32 index)
{
    unsigned int comp_len;
    unsigned long handle;
    void *dst, *src;

    src = kmap_local_page(page);

    /* 1. 전체 0인 페이지 체크 (same_page 최적화) */
    if (page_same_filled(src, &element)) {
        zram_set_flag(zram, index, ZRAM_SAME);
        zram_set_element(zram, index, element);
        kunmap_local(src);
        return 0;  /* 메모리 할당 없이 플래그만 저장 */
    }

    /* 2. 압축 */
    comp_len = PAGE_SIZE;  /* 최대 출력 크기 */
    zcomp_compress(zram->comps[ZRAM_PRIMARY_COMP],
                   src, dst, &comp_len);

    /* 3. 압축 효과 없으면 원본 저장 (huge) */
    if (comp_len >= PAGE_SIZE) {
        comp_len = PAGE_SIZE;
        zram_set_flag(zram, index, ZRAM_HUGE);
    }

    /* 4. zsmalloc 할당 + 복사 */
    handle = zs_malloc(zram->mem_pool, comp_len, GFP_NOIO);
    dst = zs_map_object(zram->mem_pool, handle, ZS_MM_WO);
    memcpy(dst, compressed_data, comp_len);
    zs_unmap_object(zram->mem_pool, handle);

    /* 5. 메타데이터 저장 */
    zram->table[index].handle = handle;
    zram->table[index].flags = ...;

    return 0;
}

블록 레이어 통합

BRD와 zram은 블록 디바이스로서 리눅스 블록 레이어와 통합됩니다. 그러나 실제 하드웨어 디스크와 달리 I/O 스케줄링이 불필요하며, BIO를 직접 처리하는 특수한 방식을 사용합니다.

BIO 처리 흐름

요청 큐 설정

/* BRD: submit_bio 방식 (no-queue) */
static const struct block_device_operations brd_fops = {
    .owner      = THIS_MODULE,
    .submit_bio = brd_submit_bio,  /* 직접 BIO 처리, 큐 없음 */
};

/* BRD 디스크 초기화 — brd_alloc() 전체 분석 */
static int brd_alloc(int i)
{
    struct brd_device *brd;
    struct gendisk *disk;

    brd = kzalloc(sizeof(*brd), GFP_KERNEL);
    xa_init(&brd->brd_pages);  /* XArray 초기화 */

    /* gendisk 할당 (NUMA 노드 무관) */
    disk = blk_alloc_disk(NUMA_NO_NODE);

    /* 디바이스 번호 설정 */
    disk->major = RAMDISK_MAJOR;  /* major 1 (/dev/ram*) */
    disk->first_minor = i * max_part;
    disk->minors = max_part;
    disk->fops = &brd_fops;
    disk->private_data = brd;
    snprintf(disk->disk_name, sizeof(disk->disk_name),
             "ram%d", i);

    /* 큐 속성 설정 */
    blk_queue_physical_block_size(disk->queue, PAGE_SIZE);
    blk_queue_max_hw_sectors(disk->queue, 1024);
    blk_queue_flag_set(QUEUE_FLAG_NONROT, disk->queue);
    /* NONROT: 회전 미디어 아님 → 스케줄러 힌트 */

    /* DISCARD 지원 — fstrim/TRIM으로 페이지 해제 */
    blk_queue_max_discard_sectors(disk->queue, UINT_MAX);

    /* 디스크 용량 (512바이트 섹터 단위) */
    set_capacity(disk, rd_size * 2);
    /* rd_size=4096(KB) → 4096*2=8192 섹터 → 4MB */

    brd->brd_disk = disk;
    list_add_tail(&brd->brd_list, &brd_devices);
    add_disk(disk);  /* /dev/ram{i} 등록 */
    return 0;
}

/*
 * zram: 마찬가지로 submit_bio 방식 사용
 * drivers/block/zram/zram_drv.c
 */
static const struct block_device_operations zram_devops = {
    .submit_bio = zram_submit_bio,
    .open       = zram_open,
    .owner      = THIS_MODULE,
};

I/O 스케줄러

RAM 디스크는 탐색 시간(seek time)이 없으므로 I/O 스케줄링이 불필요합니다. BRD/zram은 submit_bio 콜백을 사용하여 스케줄러를 완전히 바이패스합니다.

# 스케줄러 확인 (none이면 바이패스)
cat /sys/block/ram0/queue/scheduler
# none

cat /sys/block/zram0/queue/scheduler
# none

# 비교: 실제 디스크
cat /sys/block/sda/queue/scheduler
# [mq-deadline] kyber bfq none

# RAM 디스크의 큐 깊이와 I/O 속성 확인
cat /sys/block/ram0/queue/nr_requests       # 128 (기본)
cat /sys/block/ram0/queue/read_ahead_kb     # 128 (기본)
cat /sys/block/ram0/queue/rotational        # 0 (비회전 미디어)
cat /sys/block/ram0/queue/physical_block_size  # 4096 (PAGE_SIZE)
cat /sys/block/ram0/queue/logical_block_size   # 512

RAM 디스크 유형 비교

# 모든 RAM 디스크 유형의 상태를 한 번에 확인하는 스크립트
echo "=== BRD ==="
lsblk -d | grep ram 2>/dev/null || echo "(none)"

echo -e "\n=== tmpfs ==="
df -h -t tmpfs 2>/dev/null

echo -e "\n=== zram ==="
zramctl 2>/dev/null || echo "(none)"

echo -e "\n=== Memory Usage ==="
grep -E 'MemTotal|MemAvailable|Shmem|Buffers|SwapTotal' /proc/meminfo

/* 각 RAM 디스크 유형의 file_system_type / block_device_operations 비교 */

/* BRD — 블록 디바이스 */
static const struct block_device_operations brd_fops = {
    .submit_bio = brd_submit_bio,       /* BIO 직접 처리 */
};

/* zram — 블록 디바이스 */
static const struct block_device_operations zram_devops = {
    .submit_bio = zram_submit_bio,      /* 압축 + zsmalloc */
    .open = zram_open,
};

/* ramfs — 파일시스템 */
static struct file_system_type ramfs_fs_type = {
    .name = "ramfs",
    .init_fs_context = ramfs_init_fs_context,
    .kill_sb = ramfs_kill_sb,           /* 슈퍼블록 해제 */
};

/* tmpfs — 파일시스템 */
static struct file_system_type shmem_fs_type = {
    .name = "tmpfs",
    .init_fs_context = shmem_init_fs_context,
    .kill_sb = kill_litter_super,
    .fs_flags = FS_USERNS_MOUNT | FS_ALLOW_IDMAP,  /* 네임스페이스 지원 */
};

CONFIG 옵션 종합

# 현재 커널의 CONFIG 확인
zcat /proc/config.gz | grep -E 'BLK_DEV_RAM|ZRAM|INITRAMFS|TMPFS'

# 또는
grep -E 'BLK_DEV_RAM|ZRAM|INITRAMFS|TMPFS' /boot/config-$(uname -r)

# 필요한 CONFIG 한 번에 확인하는 스크립트
for opt in BLK_DEV_RAM ZRAM ZRAM_WRITEBACK ZRAM_MULTI_COMP \
           ZSMALLOC TMPFS BLK_DEV_INITRD; do
    val=$(zcat /proc/config.gz 2>/dev/null | grep "CONFIG_${opt}=" || echo "not set")
    printf "%-30s %s\n" "CONFIG_${opt}" "$val"
done
# CONFIG_BLK_DEV_RAM            CONFIG_BLK_DEV_RAM=m
# CONFIG_ZRAM                   CONFIG_ZRAM=m
# CONFIG_ZRAM_WRITEBACK         CONFIG_ZRAM_WRITEBACK=y
# ...

커널 부트 파라미터

# GRUB에서 BRD를 루트로 사용 (테스트/복구)
linux /vmlinuz root=/dev/ram0 ramdisk_size=262144 rw
initrd /initrd.img

# initramfs 디버깅: /init 대신 셸 실행
linux /vmlinuz rdinit=/bin/sh

# initramfs 무시하고 직접 루트 마운트
linux /vmlinuz noinitrd root=/dev/sda2 rootfstype=ext4

# 실전 GRUB menuentry: LUKS + LVM + initramfs
menuentry 'Linux (encrypted root)' {
    set root='hd0,gpt2'
    linux /vmlinuz-6.8.0 \
        root=/dev/mapper/vg0-root \
        rd.luks.uuid=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx \
        rd.lvm.lv=vg0/root \
        rootfstype=ext4 \
        resume=/dev/mapper/vg0-swap \
        quiet splash
    initrd /initramfs-6.8.0.img
}

# Device Tree에서 initrd 전달 (ARM/ARM64)
# chosen {
#     linux,initrd-start = <0x48000000>;
#     linux,initrd-end   = <0x49000000>;
#     bootargs = "root=/dev/mmcblk0p2 rootfstype=ext4";
# };

실전 활용 가이드

성능 벤치마크 방법

# === BRD 벤치마크 ===

# 1. BRD 생성 및 파일시스템 구성
modprobe brd rd_nr=1 rd_size=1048576  # 1GB
mkfs.ext4 /dev/ram0
mount /dev/ram0 /mnt/ramdisk

# 2. fio 벤치마크
fio --name=seqwrite --directory=/mnt/ramdisk \
    --rw=write --bs=4k --size=512m --numjobs=4 \
    --group_reporting --runtime=30

fio --name=randread --directory=/mnt/ramdisk \
    --rw=randread --bs=4k --size=512m --numjobs=4 \
    --group_reporting --runtime=30

# 3. dd 간단 테스트
dd if=/dev/zero of=/mnt/ramdisk/test bs=1M count=512 oflag=direct
dd if=/mnt/ramdisk/test of=/dev/null bs=1M iflag=direct

# === tmpfs 벤치마크 ===
mount -t tmpfs -o size=1g tmpfs /mnt/tmpfs
fio --name=seqwrite --directory=/mnt/tmpfs \
    --rw=write --bs=4k --size=512m --numjobs=4 \
    --group_reporting

# === zram 벤치마크 ===
echo 2G > /sys/block/zram0/disksize
mkfs.ext4 /dev/zram0
mount /dev/zram0 /mnt/zram

fio --name=seqwrite --directory=/mnt/zram \
    --rw=write --bs=4k --size=1g --numjobs=4 \
    --group_reporting

# 압축률 확인
cat /sys/block/zram0/mm_stat | awk '{printf "압축률: %.1f:1\n", $1/$2}'

데이터 영속성 처리

# RAM 디스크 데이터는 전원 꺼짐 시 소실
# 주기적으로 디스크에 동기화하는 방법:

# 방법 1: rsync 주기적 동기화
while true; do
    rsync -a /mnt/ramdisk/ /backup/ramdisk/ --delete
    sleep 300  # 5분마다
done

# 방법 2: systemd timer
# /etc/systemd/system/ramdisk-sync.service
# [Service]
# Type=oneshot
# ExecStart=/usr/bin/rsync -a /mnt/ramdisk/ /backup/ramdisk/ --delete

# 방법 3: 종료 시 자동 백업 (systemd)
# /etc/systemd/system/ramdisk-backup.service
# [Unit]
# Description=Backup ramdisk on shutdown
# DefaultDependencies=no
# Before=shutdown.target reboot.target halt.target
# [Service]
# Type=oneshot
# ExecStart=/usr/bin/rsync -a /mnt/ramdisk/ /backup/ramdisk/
# [Install]
# WantedBy=halt.target reboot.target shutdown.target

# 방법 4: tmpfs + overlayfs (읽기 전용 베이스 + RAM 변경분)
mount -t overlay overlay \
    -o lowerdir=/base,upperdir=/mnt/ramdisk/upper,workdir=/mnt/ramdisk/work \
    /merged

컨테이너/Docker 활용

# === Docker에서 tmpfs 활용 ===

# 컨테이너에 tmpfs 마운트 (메모리 제한 포함)
docker run --tmpfs /tmp:rw,size=256m,noexec,nosuid \
    --tmpfs /run:rw,size=64m \
    -it ubuntu:24.04 bash

# Docker Compose에서 tmpfs 설정
# services:
#   app:
#     tmpfs:
#       - /tmp:size=512m,mode=1777
#       - /run:size=64m

# Kubernetes에서 emptyDir tmpfs
# volumes:
#   - name: cache
#     emptyDir:
#       medium: Memory
#       sizeLimit: 1Gi

# === 컨테이너에서 zram swap ===

# 호스트에서 zram 설정 (모든 컨테이너가 공유)
echo lz4 > /sys/block/zram0/comp_algorithm
echo 4G > /sys/block/zram0/disksize
mkswap /dev/zram0
swapon -p 100 /dev/zram0

# cgroup v2에서 컨테이너별 메모리/스왑 제한
# memory.max = 2G    (메모리 제한)
# memory.swap.max = 4G (zram 스왑 제한)

임베디드/IoT 최적 설정

# === 512MB RAM IoT 디바이스에서 zram 최적 설정 ===

# 물리 RAM의 50%를 zram swap으로 할당
modprobe zram num_devices=1
echo lz4 > /sys/block/zram0/comp_algorithm  # 저지연
echo 256M > /sys/block/zram0/disksize
mkswap /dev/zram0
swapon -p 100 /dev/zram0

# vm 파라미터 튜닝 (임베디드 최적화)
echo 60 > /proc/sys/vm/swappiness  # 스왑 적극 사용
echo 100 > /proc/sys/vm/vfs_cache_pressure  # 캐시 적극 회수

# === 읽기 전용 rootfs + tmpfs overlay (임베디드) ===
# 부팅 시 실행:
mount -t tmpfs -o size=64m tmpfs /mnt/overlay
mkdir -p /mnt/overlay/upper /mnt/overlay/work
mount -t overlay overlay \
    -o lowerdir=/,upperdir=/mnt/overlay/upper,workdir=/mnt/overlay/work \
    /mnt/merged
# → 읽기 전용 NAND/eMMC + RAM 변경분 = 쓰기 수명 보호

CI/CD 빌드 가속

# === BRD를 빌드 디렉터리로 활용 ===

# 4GB RAM 디스크 생성
modprobe brd rd_nr=1 rd_size=4194304  # 4GB
mkfs.ext4 -E lazy_itable_init=0 /dev/ram0
mount -o noatime,discard /dev/ram0 /build

# 빌드 실행 (디스크 I/O 제거 → 빌드 30~50% 가속)
cd /build
git clone --depth 1 https://github.com/project/repo .
make -j$(nproc)

# === tmpfs를 빌드 디렉터리로 (더 간단) ===
mount -t tmpfs -o size=4g tmpfs /build
# tmpfs가 BRD보다 빠름 (블록 레이어 바이패스)

동적 크기 조정

# === tmpfs 온라인 리사이즈 ===
# tmpfs는 마운트 상태에서 즉시 크기 변경 가능 (데이터 보존)
mount -o remount,size=2g /tmp

# BRD: 리사이즈 불가 (재생성 필요)
umount /mnt/ramdisk
rmmod brd
modprobe brd rd_nr=1 rd_size=2097152  # 2GB
mkfs.ext4 /dev/ram0
mount /dev/ram0 /mnt/ramdisk

# zram: 리셋 후 재설정 필요
swapoff /dev/zram0
echo 1 > /sys/block/zram0/reset
echo 8G > /sys/block/zram0/disksize
mkswap /dev/zram0
swapon -p 100 /dev/zram0

# zram: hot_add/hot_remove로 동적 추가/제거
cat /sys/class/zram-control/hot_add    # 새 zram 디바이스 번호 반환
echo 1 > /sys/class/zram-control/hot_remove  # zram1 제거

디버깅과 트러블슈팅

# === BRD 디버깅 ===

# BRD 디바이스 확인
ls -la /dev/ram*
lsblk | grep ram
cat /proc/devices | grep ramdisk  # major 1

# BRD 메모리 사용량 (근사값)
for dev in /sys/block/ram*/size; do
    name=$(dirname $dev | xargs basename)
    sectors=$(cat $dev)
    echo "$name: $((sectors * 512 / 1024 / 1024))MB capacity"
done

# === zram 디버깅 ===

# zram 상태 종합 확인
zramctl
# NAME       ALGORITHM DISKSIZE   DATA  COMPR  TOTAL STREAMS MOUNTPOINT
# /dev/zram0 lz4            4G  2.1G  712M  734M       8 [SWAP]

# 상세 통계
cat /sys/block/zram0/mm_stat
cat /sys/block/zram0/io_stat
cat /sys/block/zram0/bd_stat

# 디버그 메시지 (커널 로그)
dmesg | grep -i "zram\|brd\|ramdisk\|initramfs\|initrd"

# === initramfs 디버깅 ===

# initramfs 내용 확인
lsinitrd /boot/initramfs-$(uname -r).img  # RHEL/Fedora
lsinitramfs /boot/initrd.img-$(uname -r)   # Debian/Ubuntu

# initramfs 부팅 문제 디버깅
# 커널 파라미터에 추가:
#   rd.break          — initramfs의 switch_root 직전에 셸 진입
#   rd.debug          — dracut 디버그 로그 활성화
#   rdinit=/bin/sh    — /init 대신 셸 실행

# === 메모리 추적 ===
# /proc/meminfo에서 RAM 디스크 관련 항목
grep -E 'Shmem|Buffers|Cached' /proc/meminfo
# Buffers:      BRD가 사용하는 블록 버퍼 캐시
# Shmem:        tmpfs가 사용하는 메모리
# Cached:       페이지 캐시 (ramfs 포함)

# slabinfo에서 zsmalloc 확인
grep zspage /proc/slabinfo

# === ftrace로 brd_submit_bio 추적 ===

# 1. function tracer 설정
cd /sys/kernel/debug/tracing
echo function > current_tracer
echo brd_submit_bio > set_ftrace_filter
echo 1 > tracing_on

# 2. BRD에 I/O 발생시키기
dd if=/dev/zero of=/dev/ram0 bs=4k count=100

# 3. 추적 결과 확인
cat trace
#  dd-12345  [002]  ...  brd_submit_bio <-submit_bio_noacct
#  dd-12345  [002]  ...  brd_submit_bio <-submit_bio_noacct

echo 0 > tracing_on
echo > set_ftrace_filter

# === bpftrace: zram 압축률 실시간 모니터링 ===

# 압축 전후 크기 추적 (zram_write_page 프로브)
bpftrace -e '
kprobe:zram_write_page {
    @write_count = count();
}
kretprobe:zram_write_page /retval == 0/ {
    @success = count();
}
interval:s:5 {
    printf("writes: %d, success: %d\n",
           @write_count, @success);
    clear(@write_count);
    clear(@success);
}
'

# zram I/O 레이턴시 히스토그램
bpftrace -e '
kprobe:zram_submit_bio { @start[tid] = nsecs; }
kretprobe:zram_submit_bio /@start[tid]/ {
    @latency_us = hist((nsecs - @start[tid]) / 1000);
    delete(@start[tid]);
}
'

# === /proc/vmstat zram 관련 카운터 해석 ===

grep -E 'pswpin|pswpout|pgfault|pgmajfault' /proc/vmstat
# pswpin 12345    ← 스왑 인 페이지 수 (zram 읽기 포함)
# pswpout 67890   ← 스왑 아웃 페이지 수 (zram 쓰기 포함)
# pgfault 1234567 ← 페이지 폴트 총 수
# pgmajfault 456  ← major 폴트 (디스크/스왑 접근)

# zram이 스왑 대상일 때: pswpin/pswpout이 zram 압축/해제 횟수
# pgmajfault가 높으면 → 메모리 부족, 스왑 thrashing 의심

# === OOM 시나리오: ramfs 메모리 고갈 재현 ===

# 주의: 테스트 환경에서만 실행!
mount -t ramfs ramfs /mnt/test
# ramfs는 크기 제한이 없으므로 아래 명령은 OOM을 유발
# dd if=/dev/zero of=/mnt/test/oom bs=1M count=999999
# → OOM killer 발동 → dmesg에 기록

# === cgroup v2에서 shmem(tmpfs) 메모리 추적 ===

# cgroup v2 memory controller
cat /sys/fs/cgroup/user.slice/memory.stat | grep shmem
# shmem 12345678  ← 이 cgroup의 tmpfs 사용량 (바이트)
# shmem_pmdmapped 0

# 특정 컨테이너의 tmpfs 사용량 모니터링
cat /sys/fs/cgroup/system.slice/docker-*.scope/memory.stat | grep shmem

커널 버전별 변화

보안 고려사항

RAM 디스크는 메모리 기반이라 물리적 디스크와 다른 보안 특성을 가집니다. 전원 꺼짐 시 데이터가 사라지는 점은 보안에 유리하지만, 메모리 상의 데이터는 cold boot attack이나 메모리 덤프로 노출될 수 있습니다.

# === initramfs 서명 검증 (IMA/EVM) ===

# IMA 정책으로 initramfs 내 파일 무결성 검증
# /etc/ima/ima-policy:
# measure func=KEXEC_INITRAMFS_CHECK
# appraise func=KEXEC_INITRAMFS_CHECK appraise_type=imasig

# initramfs에 IMA 서명 추가
evmctl ima_sign -k /etc/keys/privkey_ima.pem /boot/initramfs.img

# Secure Boot 체인: UEFI → shim → GRUB → vmlinuz (서명) → initramfs (IMA)

# === zram 데이터 안전 삭제 ===

# swapoff만으로는 zsmalloc 메모리가 즉시 해제되지 않을 수 있음
swapoff /dev/zram0

# 완전 초기화 (메모리 + 메타데이터 전부 해제)
echo 1 > /sys/block/zram0/reset

# 민감 환경: zram 사용 후 반드시 reset 수행
# reset → zs_destroy_pool() → 모든 zspage __free_page()

# === tmpfs에서 민감 데이터 처리 ===

# memfd_secret: 커널도 접근 불가한 비밀 메모리 (5.14+)
# 프로그래밍 방식:
#   fd = memfd_secret(0);
#   ftruncate(fd, 4096);
#   ptr = mmap(NULL, 4096, PROT_READ|PROT_WRITE,
#              MAP_SHARED, fd, 0);
# → 이 메모리는 /proc/pid/mem으로도 읽을 수 없음

# tmpfs 파일 안전 삭제
shred -u /tmp/secret_file  # 0으로 덮어쓴 후 삭제

# === tmpfs 보안 강화 마운트 예시 ===

# /tmp: noexec,nosuid,nodev — 실행 파일/setuid/디바이스 파일 차단
mount -t tmpfs -o size=1g,mode=1777,noexec,nosuid,nodev tmpfs /tmp

# /dev/shm: 공유 메모리 크기 제한
mount -t tmpfs -o size=512m,noexec,nosuid,nodev tmpfs /dev/shm

# fstab 설정
# tmpfs  /tmp      tmpfs  defaults,size=1g,noexec,nosuid,nodev,mode=1777  0  0
# tmpfs  /dev/shm  tmpfs  defaults,size=512m,noexec,nosuid,nodev           0  0
# tmpfs  /run      tmpfs  defaults,size=256m,noexec,nosuid,nodev,mode=755  0  0

/* init/initramfs.c — initramfs 서명 검증 (IMA 연동) */

/*
 * CONFIG_IMA_APPRAISE_SIGNED_INIT 활성화 시
 * initramfs의 모든 파일이 IMA 서명을 가져야 부팅 가능
 *
 * 검증 흐름:
 * 1. unpack_to_rootfs() → 각 파일을 rootfs에 생성
 * 2. 파일 접근 시 → ima_file_check() → 서명 검증
 * 3. 서명 불일치 → -EACCES → 부팅 실패
 *
 * 서명 포함 방법:
 * - evmctl ima_sign --key /path/to/key 파일
 * - security.ima xattr에 서명 저장
 * - cpio 아카이브에 xattr 포함하여 패키징
 */

관련 문서