inode 구조 (inode Structure)

파일 메타데이터의 핵심 단위인 inode를 기준으로 커널이 파일의 정체성과 상태를 어떻게 관리하는지 다룹니다. `struct inode` 주요 필드, inode_operations와 file_operations의 분리 설계, inode/dentry 캐시(Cache) 결합, 생성·갱신·삭제·회수 경로, 링크 카운트와 권한/타임스탬프 일관성, ext4·XFS·Btrfs 구현 차이를 실제 함수 흐름에 맞춰 상세히 정리합니다.

inode 개요

struct inode는 파일시스템의 파일(또는 디렉터리, 심볼릭 링크 등)을 나타내는 메타데이터 객체입니다. 파일명이 아닌 파일 자체의 속성을 저장합니다 — 파일명은 dentry가 담당합니다.

inode라는 이름은 Unix의 원래 논문에서 유래했습니다. Dennis Ritchie와 Ken Thompson은 1974년 논문에서 이 개념을 "index node"의 줄임말로 사용했습니다. 오늘날 리눅스 커널에서 struct inode는 약 600바이트 크기의 구조체로, VFS(Virtual File System) 계층의 핵심 데이터 구조입니다.

리눅스 커널에서 inode가 다루는 핵심 정보는 다음과 같습니다:

inode 추상화 원리

Unix/Linux 파일시스템의 핵심 설계 원리는 "이름(name)과 메타데이터(metadata)의 분리"입니다:

• dentry (디렉터리 엔트리): 파일의 이름과 부모-자식 관계(경로 구조)를 관리합니다. 하나의 inode에 여러 dentry가 연결될 수 있습니다(하드 링크).
• inode: 파일의 실체 — 크기, 권한, 타임스탬프, 데이터 위치 등 파일 자체의 속성을 저장합니다. 고유한 inode 번호(i_ino)로 식별됩니다.

이 분리 덕분에 하드 링크(같은 inode에 여러 이름), 파일 이동(dentry만 변경, inode 불변), 삭제된 파일의 계속 접근(열린 파일 디스크립터(File Descriptor)가 inode 참조 유지) 등이 가능합니다.

VFS inode vs 파일시스템별 inode

커널은 2단계 inode 구조를 사용합니다:

• VFS inode (struct inode): 모든 파일시스템에 공통인 메타데이터(크기, 권한, 타임스탬프, 참조 카운트 등). VFS 계층이 직접 접근합니다.
• FS-specific inode (예: struct ext4_inode_info): 파일시스템 고유의 데이터(extent 트리, 저널링(Journaling) 정보 등). container_of() 매크로(Macro)로 VFS inode에서 역추적(Backtrace)합니다.

각 파일시스템은 자체 inode 구조체에 VFS inode를 임베드합니다. 이 패턴은 상속 없이 다형성을 달성하는 커널의 전형적인 객체 지향 기법입니다.

inode 캐시 동작 원리

VFS는 inode 캐시(icache)를 유지하여 디스크 I/O를 최소화합니다. 동작 원리는 다음과 같습니다:

1. 해시 테이블(Hash Table) 조회: 파일 접근 시 (superblock, inode 번호) 쌍으로 해시 테이블을 검색합니다. 히트하면 디스크 읽기 없이 즉시 반환합니다.
2. LRU 관리: 참조 카운트(i_count)가 0이 된 inode는 LRU 리스트에 들어갑니다. 즉시 삭제하지 않고 캐시에 유지하여, 재접근 시 빠르게 활용합니다.
3. 메모리 회수(Memory Reclaim): 메모리 압력 시 커널의 shrinker가 LRU 끝에서부터 inode를 회수합니다. vm.vfs_cache_pressure sysctl로 회수 적극성을 조절합니다 (기본값 100, 높으면 더 적극적 회수).

struct inode 주요 필드

struct inode {
    umode_t             i_mode;      /* 파일 유형 + 권한 */
    unsigned short      i_opflags;
    kuid_t              i_uid;       /* 소유자 UID */
    kgid_t              i_gid;       /* 소유자 GID */
    unsigned int        i_flags;

    const struct inode_operations *i_op;   /* inode 연산 */
    struct super_block  *i_sb;        /* 소속 superblock */
    struct address_space *i_mapping;  /* 페이지 캐시 매핑 */

    unsigned long       i_ino;       /* inode 번호 */
    atomic_t            i_count;     /* 참조 카운트 */
    unsigned int        i_nlink;     /* 하드 링크 수 */
    loff_t              i_size;      /* 파일 크기 (바이트) */
    struct timespec64   __i_atime;   /* 최종 접근 시간 */
    struct timespec64   __i_mtime;   /* 최종 수정 시간 */
    struct timespec64   __i_ctime;   /* 최종 변경 시간 */
    blkcnt_t            i_blocks;    /* 할당된 블록 수 */

    const struct file_operations *i_fop; /* file 연산 */
    struct list_head    i_devices;
    union {
        struct pipe_inode_info *i_pipe;
        struct cdev  *i_cdev;
        char         *i_link;    /* symlink target */
    };
    void                *i_private;  /* fs-specific data */
};

struct super_operations 주요 콜백

struct super_operations는 파일시스템 전체(슈퍼블록 단위)에 대한 연산을 정의합니다. inode의 할당·해제·읽기·쓰기·evict를 포함하며, 파일시스템 드라이버가 구현하여 super_block.s_op에 등록합니다.

/* include/linux/fs.h — 주요 super_operations 콜백 */
struct super_operations {
    struct inode *(*alloc_inode)(struct super_block *sb); /* fs별 inode 할당 */
    void          (*free_inode) (struct inode *);           /* inode 메모리 해제 */
    void          (*destroy_inode)(struct inode *);         /* 비동기 해제 (call_rcu) */
    void          (*dirty_inode)(struct inode *, int flags); /* dirty 마킹 통지 */
    int           (*write_inode)(struct inode *,
                                  struct writeback_control *); /* inode를 디스크에 기록 */
    int           (*drop_inode) (struct inode *);           /* i_count 0 시 보존 여부 결정 */
    void          (*evict_inode)(struct inode *);           /* inode 최종 제거 (nlink==0) */
    void          (*put_super)  (struct super_block *);     /* umount 시 자원 해제 */
    int           (*sync_fs)   (struct super_block *, int); /* fsync/sync 시 플러시 */
    int           (*freeze_super)(struct super_block *,
                                   enum freeze_holder);     /* 스냅샷 전 freeze */
    int           (*unfreeze_super)(struct super_block *,
                                     enum freeze_holder);   /* freeze 해제 */
    int           (*statfs)    (struct dentry *,
                                  struct kstatfs *);        /* statfs(2) 통계 */
    int           (*show_options)(struct seq_file *,
                                   struct dentry *);         /* /proc/mounts 마운트 옵션 */
    long          (*nr_cached_objects)(struct super_block *,
                                        struct shrink_control *); /* slab shrinker용 */
    long          (*free_cached_objects)(struct super_block *,
                                          struct shrink_control *); /* slab shrinker용 */
};

inode_operations

struct inode_operations는 inode 자체에 대한 연산(생성, 검색, 삭제, 속성 변경)을 정의합니다. 각 파일시스템은 자체 콜백(Callback)을 구현하여 VFS에 등록합니다. NULL인 콜백은 "미지원"을 의미하며, VFS가 기본 동작을 수행하거나 에러를 반환합니다.

struct inode_operations {
    struct dentry *(*lookup)(struct inode *, struct dentry *, unsigned int);
    int (*create)(struct mnt_idmap *, struct inode *, struct dentry *, umode_t, bool);
    int (*link)(struct dentry *, struct inode *, struct dentry *);
    int (*unlink)(struct inode *, struct dentry *);
    int (*symlink)(struct mnt_idmap *, struct inode *, struct dentry *, const char *);
    int (*mkdir)(struct mnt_idmap *, struct inode *, struct dentry *, umode_t);
    int (*rmdir)(struct inode *, struct dentry *);
    int (*mknod)(struct mnt_idmap *, struct inode *, struct dentry *, umode_t, dev_t);
    int (*rename)(struct mnt_idmap *, struct inode *, struct dentry *,
                  struct inode *, struct dentry *, unsigned int);
    int (*setattr)(struct mnt_idmap *, struct dentry *, struct iattr *);
    int (*getattr)(struct mnt_idmap *, const struct path *, struct kstat *, u32, unsigned int);
    int (*permission)(struct mnt_idmap *, struct inode *, int);
    struct posix_acl *(*get_inode_acl)(struct inode *, int, bool);
    int (*tmpfile)(struct mnt_idmap *, struct inode *, struct file *, umode_t);
    int (*atomic_open)(struct inode *, struct dentry *, struct file *, unsigned, umode_t);
    int (*fileattr_set)(struct mnt_idmap *, struct dentry *, struct fileattr *);
    int (*fileattr_get)(struct dentry *, struct fileattr *);
};

주요 콜백 상세

Casefold: 대소문자 무시 조회

커널 5.2부터 ext4, 5.11부터 F2FS에서 대소문자 무시(case-insensitive) 디렉터리를 지원합니다. 이 기능은 inode_operations의 lookup 콜백에서 Unicode 정규화(NFKD + casefold)를 적용하여 이름 비교를 수행합니다.

/* include/linux/fs.h — casefold 관련 필드 */
struct inode {
    /* ... */
    unsigned int i_flags;  /* S_CASEFOLD 플래그 포함 */
    /* ... */
};

/* S_CASEFOLD 매크로 — inode에 casefold 활성화 여부 */
#define S_CASEFOLD    (1 << 15)
#define IS_CASEFOLDED(inode) ((inode)->i_flags & S_CASEFOLD)

/* fs/libfs.c — casefold를 적용한 이름 비교 */
int generic_ci_d_compare(const struct dentry *dentry,
                        unsigned int len, const char *str,
                        const struct qstr *name)
{
    const struct dentry *parent = READ_ONCE(dentry->d_parent);
    const struct inode *dir = d_inode_rcu(parent);
    const struct unicode_map *um = dir->i_sb->s_encoding;

    if (!dir || !IS_CASEFOLDED(dir))
        return 1;  /* 일반 비교 폴백 */

    /* Unicode NFKD+casefold로 정규화하여 비교 */
    return utf8_strncasecmp(um, name, &(struct qstr)QSTR_INIT(str, len));
}

inode 캐시

VFS는 inode 캐시(icache)를 유지하여 디스크 접근을 최소화합니다. 사용 중이지 않은 inode는 LRU 리스트에 들어가며, 메모리 압력 시 회수됩니다.

inode 파일 유형

ext4 inode 확장

각 파일시스템은 VFS inode를 자체 구조체에 임베드합니다. ext4의 경우:

struct ext4_inode_info {
    __le32  i_data[15];     /* block pointers or extent tree */
    __u32   i_flags;
    ext4_fsblk_t i_file_acl;
    /* ... ext4 specific fields ... */
    struct inode vfs_inode;  /* VFS inode 임베드 */
};

/* VFS inode에서 ext4 inode로 변환 */
static inline struct ext4_inode_info *EXT4_I(struct inode *inode)
{
    return container_of(inode, struct ext4_inode_info, vfs_inode);
}

inode 생명주기

inode는 할당 → 초기화 → 사용 → 해제의 생명주기를 가집니다. 참조 카운트(i_count)와 하드 링크 수(i_nlink)가 모두 0이 되면 삭제됩니다.

/* 새 inode 할당 (파일시스템별 alloc_inode 호출) */
struct inode *inode = new_inode(sb);

/* inode 번호 할당 및 해시 테이블에 삽입 */
inode->i_ino = get_next_ino();
insert_inode_hash(inode);

/* 초기 속성 설정 */
inode->i_mode = S_IFREG | 0644;
inode_init_owner(idmap, inode, dir, mode);
inode->i_op = &myfs_inode_ops;
inode->i_fop = &myfs_file_ops;
inode->i_mapping->a_ops = &myfs_aops;

/* 참조 카운트 관리 */
ihold(inode);     /* i_count++ (참조 획득) */
iput(inode);      /* i_count-- (참조 해제, 0이면 evict) */

/* inode 삭제 경로 */
/* i_nlink == 0 && i_count == 0 → evict_inode() 호출 */

파일시스템별 inode 할당

각 파일시스템은 alloc_inode()와 free_inode()를 구현하여 자체 확장 inode를 관리합니다:

static struct kmem_cache *myfs_inode_cachep;

static struct inode *myfs_alloc_inode(struct super_block *sb)
{
    struct myfs_inode_info *mi;
    mi = alloc_inode_sb(sb, myfs_inode_cachep, GFP_KERNEL);
    if (!mi)
        return NULL;
    /* fs-specific 필드 초기화 */
    mi->i_disksize = 0;
    return &mi->vfs_inode;
}

static void myfs_free_inode(struct inode *inode)
{
    kmem_cache_free(myfs_inode_cachep, MYFS_I(inode));
}

static const struct super_operations myfs_sops = {
    .alloc_inode  = myfs_alloc_inode,
    .free_inode   = myfs_free_inode,
    .write_inode  = myfs_write_inode,
    .evict_inode  = myfs_evict_inode,
};

dentry-inode 연결 함수

새로 생성하거나 디스크에서 읽은 inode를 dentry에 연결하는 것은 VFS 경로 조회의 핵심 단계입니다. 연결 방식에 따라 여러 함수가 제공되며, 잘못된 함수를 사용하면 경로 조회 실패, 중복 dentry, NFS 불일치 등이 발생합니다.

d_instantiate() / d_instantiate_new()

/* fs/dcache.c — d_instantiate(): dentry에 inode 연결 */
void d_instantiate(struct dentry *entry, struct inode *inode)
{
    if (inode) {
        security_d_instantiate(entry, inode);  /* LSM 알림 */
    }
    spin_lock(&entry->d_lock);
    __d_set_inode_and_type(entry, inode, add_flags);
    /* dentry의 d_inode = inode 설정 */
    /* inode의 i_dentry 리스트에 이 dentry 추가 (하드 링크 추적) */
    if (inode)
        hlist_add_head(&entry->d_u.d_alias, &inode->i_dentry);
    spin_unlock(&entry->d_lock);
}

/* d_instantiate_new(): d_instantiate + unlock_new_inode 통합 */
void d_instantiate_new(struct dentry *entry, struct inode *inode)
{
    BUG_ON(!(inode->i_state & I_NEW));  /* I_NEW 상태 필수 */
    d_instantiate(entry, inode);
    unlock_new_inode(inode);             /* I_NEW 해제 + 대기자 깨우기 */
}

d_splice_alias()

lookup 콜백에서 디스크에서 찾은 inode를 dentry에 연결할 때 사용합니다. 동일 inode에 대한 기존 dentry(alias)가 있으면 그것을 반환하고, 없으면 새로 연결합니다.

/* fs/dcache.c — d_splice_alias() 핵심 로직 */
struct dentry *d_splice_alias(struct inode *inode,
                              struct dentry *dentry)
{
    if (!inode) {
        /* 파일 없음 → negative dentry로 캐시 */
        d_add(dentry, NULL);
        return NULL;
    }

    /* 디렉터리 inode: 기존 alias 검색 */
    if (S_ISDIR(inode->i_mode)) {
        struct dentry *alias = __d_find_alias(inode);
        if (alias) {
            /* 기존 alias가 있으면 그것을 반환 (splice) */
            /* 전달된 dentry는 negative로 유지 */
            __d_move(alias, dentry, false);
            return alias;
        }
    }

    /* 비디렉터리이거나 기존 alias 없음 → 직접 연결 */
    d_add(dentry, inode);
    return NULL;
}

/* lookup 콜백에서의 전형적인 사용 */
static struct dentry *myfs_lookup(struct inode *dir,
                                   struct dentry *dentry,
                                   unsigned int flags)
{
    struct inode *inode = NULL;
    ino_t ino;

    /* 디스크에서 이름으로 inode 번호 검색 */
    ino = myfs_find_entry(dir, &dentry->d_name);
    if (ino)
        inode = myfs_iget(dir->i_sb, ino);

    return d_splice_alias(inode, dentry);
}

d_make_root()

파일시스템 마운트 시 루트(/) 디렉터리의 dentry를 생성합니다.

/* fs/dcache.c — d_make_root() */
struct dentry *d_make_root(struct inode *root_inode)
{
    struct dentry *dentry;

    if (!root_inode)
        return NULL;

    /* "/" 이름의 dentry 할당 */
    dentry = d_alloc_anon(root_inode->i_sb);
    if (!dentry) {
        iput(root_inode);  /* 실패 시 inode 해제 */
        return NULL;
    }
    d_instantiate(dentry, root_inode);
    return dentry;
}

/* fill_super에서의 사용 */
static int myfs_fill_super(struct super_block *sb, ...)
{
    struct inode *root_inode;

    root_inode = myfs_iget(sb, MYFS_ROOT_INO);
    if (IS_ERR(root_inode))
        return PTR_ERR(root_inode);

    sb->s_root = d_make_root(root_inode);
    if (!sb->s_root)
        return -ENOMEM;  /* d_make_root가 이미 iput() 호출 */
    return 0;
}

O_TMPFILE: 이름 없는 inode 생성

커널 3.11에서 도입된 O_TMPFILE 플래그는 디렉터리에 연결되지 않은 inode를 생성합니다. dentry 없이 inode와 file 구조체만 존재하므로, 파일명 충돌·레이스 컨디션·보안 노출 없이 안전하게 임시 파일을 사용할 수 있습니다.

/* 사용자 공간 — O_TMPFILE 사용 패턴 */
int fd = open("/tmp", O_TMPFILE | O_RDWR, 0600);
/* fd로 데이터 기록 */
write(fd, data, len);

/* 패턴 1: 작업 완료 후 원자적으로 이름 부여 (linkat) */
char procpath[64];
snprintf(procpath, sizeof(procpath), "/proc/self/fd/%d", fd);
linkat(AT_FDCWD, procpath, AT_FDCWD, "/tmp/final.dat", AT_SYMLINK_FOLLOW);

/* 패턴 2: 이름 부여 없이 close → inode 자동 삭제 */
close(fd);  /* nlink==0, count==0 → evict */

/* 커널 내부 — O_TMPFILE 경로 (fs/namei.c) */
static int do_tmpfile(struct nameidata *nd, unsigned flags,
                      const struct open_flags *op,
                      struct file *file)
{
    struct inode *dir = nd->path.dentry->d_inode;

    /* 1. 디렉터리의 inode_operations->tmpfile 콜백 확인 */
    if (!dir->i_op->tmpfile)
        return -EOPNOTSUPP;

    /* 2. FS별 tmpfile 콜백 호출 → 새 inode 할당 */
    /*    nlink=0인 상태로 생성, dentry 연결 안 함 */
    error = dir->i_op->tmpfile(idmap, dir, file, op->mode);

    /* 3. d_tmpfile()으로 특수 dentry 연결 */
    /*    해시 테이블 미등록, 부모 미연결 */
    return error;
}

/* ext4의 tmpfile 구현 — fs/ext4/namei.c */
static int ext4_tmpfile(struct mnt_idmap *idmap,
                        struct inode *dir,
                        struct file *file, umode_t mode)
{
    struct inode *inode;

    /* 1. 새 inode 할당 + 초기화 */
    inode = ext4_new_inode_start_handle(idmap, dir, mode, ...);

    /* 2. nlink = 0 (orphan 상태) */
    /*    저널의 orphan 리스트에 등록 → 크래시 시 자동 정리 */
    ext4_orphan_add(handle, inode);

    /* 3. 연산 테이블 연결 */
    inode->i_op  = &ext4_file_inode_operations;
    inode->i_fop = &ext4_file_operations;

    /* 4. d_tmpfile()로 file에 연결 */
    d_tmpfile(file, inode);
    return finish_open_simple(file, 0);
}

확장 속성 (xattr)

inode에 추가적인 이름-값 쌍 메타데이터를 저장합니다. 보안 레이블(SELinux), ACL, 사용자 데이터 등에 사용됩니다.

/* xattr 핸들러 등록 */
static const struct xattr_handler myfs_xattr_user_handler = {
    .prefix = XATTR_USER_PREFIX,
    .get    = myfs_xattr_get,
    .set    = myfs_xattr_set,
};

static const struct xattr_handler *myfs_xattr_handlers[] = {
    &myfs_xattr_user_handler,
    &myfs_xattr_security_handler,
    NULL,
};

sb->s_xattr = myfs_xattr_handlers;

# xattr 조작 명령어
# 설정
setfattr -n user.description -v "project config" /path/to/file
# 조회
getfattr -n user.description /path/to/file
# 전체 나열
getfattr -d -m ".*" /path/to/file
# 삭제
setfattr -x user.description /path/to/file

# SELinux 보안 컨텍스트 확인
getfattr -n security.selinux /path/to/file

# xattr 크기 제한 확인
# ext4: 개별 값 최대 64KB, 총 1블록(4KB) 제한 (인라인+외부)
# XFS: 개별 64KB, 총 제한 없음 (B+tree 확장)
# Btrfs: 개별 64KB, 총 제한 없음

inode 이벤트 감시 (inotify/fanotify)

inode 변경 사항을 유저스페이스에 알리는 커널 메커니즘입니다:

/* 커널 내부: 파일 변경 시 이벤트 발생 */
fsnotify_modify(file);        /* 파일 내용 수정 */
fsnotify_access(file);        /* 파일 읽기 */
fsnotify_create(dir, dentry); /* 파일 생성 */
fsnotify_delete(dir, dentry); /* 파일 삭제 */

/* VFS 계층에서 자동 호출됨 (vfs_write, vfs_read 등) */

Btrfs의 inode 확장

Btrfs는 전통적 inode 번호 대신 (subvolume_id, objectid) 쌍으로 파일을 식별합니다:

struct btrfs_inode {
    struct inode vfs_inode;

    u64 root_objectid;        /* subvolume ID */
    struct btrfs_key location; /* (objectid, type, offset) */

    u64 disk_i_size;          /* 디스크 상의 크기 */
    u64 generation;           /* CoW 트랜잭션 세대 */
    u64 flags;                /* NODATASUM, COMPRESS 등 */

    struct btrfs_ordered_inode_tree ordered_tree;
    struct list_head delalloc_inodes;
};

파일시스템별 inode 고려사항

앞서 ext4와 Btrfs의 inode 확장을 살펴보았습니다. 다음으로 파일시스템 설계 시 고려해야 할 inode 관련 공통 사항 — inode 고갈, 크기 제한, 성능 특성 등을 정리합니다.

inode 고갈 문제

# inode 사용량 확인
df -i
# Filesystem        Inodes   IUsed   IFree IUse% Mounted on
# /dev/sda1       6553600  234567 6319033    4% /

# ext4: inode 수는 mkfs 시 결정 (이후 변경 불가!)
mkfs.ext4 -N 10000000 /dev/sda1   # inode 천만 개
mkfs.ext4 -i 4096 /dev/sda1       # 4KB당 1개 inode (소파일 많은 환경)

# XFS: inode는 동적 할당 (고갈 문제 적음)
# Btrfs: inode 번호 동적 (고갈 없음)

inode 크기와 인라인 데이터

inode 타임스탬프와 성능

/* inode의 세 가지 타임스탬프 */
struct inode {
    struct timespec64 __i_atime;  /* 마지막 접근 시간 (read) */
    struct timespec64 __i_mtime;  /* 마지막 수정 시간 (write) */
    struct timespec64 __i_ctime;  /* 마지막 변경 시간 (메타데이터) */
    /* ext4는 crtime (생성 시간)도 저장 — statx()로 조회 */
};

/* atime 마운트 옵션과 성능 영향 */
/* noatime   — atime 갱신 완전 비활성화 (최고 성능) */
/* relatime  — mtime보다 오래된 경우에만 atime 갱신 (기본값) */
/* strictatime — 매 접근마다 갱신 (성능 나쁨) */
/* lazytime  — atime을 메모리에서만 갱신, 주기적으로 디스크 기록 (5.6+) */

하드 링크와 inode 공유

하드 링크는 여러 dentry가 동일한 inode를 가리키는 구조입니다. 파일의 실체(데이터와 메타데이터)는 하나이고, 이름만 여러 개입니다. i_nlink 필드가 연결된 dentry 수를 추적하며, 이 값이 0이 되고 참조 카운트도 0이면 inode가 해제됩니다.

/* 하드 링크 생성 — fs/namei.c: vfs_link() */
int vfs_link(struct dentry *old_dentry,
            struct mnt_idmap *idmap,
            struct inode *dir,
            struct dentry *new_dentry,
            struct inode **delegated_inode)
{
    struct inode *inode = d_inode(old_dentry);

    /* 1. 제한 사항 검사 */
    if (S_ISDIR(inode->i_mode))
        return -EPERM;  /* 디렉터리 하드 링크 금지 */

    if (inode->i_nlink >= inode->i_sb->s_max_links)
        return -EMLINK; /* 최대 링크 수 초과 */

    /* 2. 보안 검사 */
    error = security_inode_link(old_dentry, dir, new_dentry);

    /* 3. FS별 link 콜백 호출 */
    error = dir->i_op->link(old_dentry, dir, new_dentry);
    /* → inode->i_nlink++ */
    /* → 새 dentry를 dir에 추가 */

    /* 4. fsnotify 이벤트 발생 */
    fsnotify_link(dir, inode, new_dentry);
    return 0;
}

Reflink (CoW 복사)

하드 링크와 달리 reflink는 별도의 inode를 생성하되 데이터 extent를 공유합니다. 쓰기 시 CoW(Copy-on-Write)로 분리되어, 스냅샷과 공간 효율적 복사의 기반 기술입니다.

# reflink 복사 (Btrfs, XFS 4.16+)
cp --reflink=always source.img dest.img
# → 즉시 완료 (데이터 복사 없음, extent 참조만 공유)
# → dest.img에 쓰기 시 해당 extent만 CoW 분리

# reflink 지원 여부 확인
xfs_info /mnt/data | grep reflink
# reflink=1 이면 지원

# 하드 링크 vs reflink vs 일반 복사
# 하드 링크:  같은 inode, 같은 데이터 (모든 변경 공유)
# reflink:   다른 inode, extent 공유 (쓰기 시 분리)
# cp:        다른 inode, 데이터 완전 복사

struct inode 필드별 상세 분석

struct inode는 약 40개 이상의 필드를 가지며, 파일 메타데이터의 모든 측면을 관리합니다. 여기서는 핵심 필드를 그룹별로 분석합니다.

식별 필드 (i_ino, i_sb, i_mode)

/* i_mode 비트 레이아웃 (16비트) */
/*  ┌─ 파일 유형 (4비트) ─┐┌─ setuid/gid/sticky ─┐┌─ rwx rwx rwx ─┐ */
/*  15  14  13  12          11   10    9             8..6 5..3 2..0    */

#define S_IFMT   00170000  /* 유형 마스크 */
#define S_IFREG  0100000   /* 일반 파일 */
#define S_IFDIR  0040000   /* 디렉터리 */
#define S_IFLNK  0120000   /* 심볼릭 링크 */
#define S_IFBLK  0060000   /* 블록 디바이스 */
#define S_IFCHR  0020000   /* 캐릭터 디바이스 */
#define S_IFIFO  0010000   /* FIFO */
#define S_IFSOCK 0140000   /* 소켓 */

/* 유형 검사 매크로 */
#define S_ISREG(m)  (((m) & S_IFMT) == S_IFREG)
#define S_ISDIR(m)  (((m) & S_IFMT) == S_IFDIR)
#define S_ISLNK(m)  (((m) & S_IFMT) == S_IFLNK)

/* 권한 비트 */
#define S_ISUID  0004000   /* set-user-ID */
#define S_ISGID  0002000   /* set-group-ID */
#define S_ISVTX  0001000   /* sticky bit */
#define S_IRWXU  00700     /* owner rwx */
#define S_IRWXG  00070     /* group rwx */
#define S_IRWXO  00007     /* others rwx */

소유권/크기 필드

연산 테이블 필드

struct inode는 세 가지 연산 테이블을 참조하여 파일시스템별 다형성을 구현합니다:

/* i_op vs i_fop 구분 원리:
 * - i_op: 파일을 "찾고/만들고/삭제"하는 디렉터리 수준 연산
 * - i_fop: 파일을 "열고/읽고/쓰는" 데이터 수준 연산
 *
 * 예: open("/home/user/test.txt", O_RDONLY)
 * 1. VFS가 /home의 i_op->lookup으로 "user" dentry 찾기
 * 2. VFS가 /home/user의 i_op->lookup으로 "test.txt" dentry 찾기
 * 3. test.txt inode의 i_fop을 struct file에 복사
 * 4. 이후 read(fd, ...)는 file->f_op->read_iter 호출
 */

/* 디렉터리 inode의 전형적인 설정 */
static const struct inode_operations myfs_dir_iops = {
    .lookup  = myfs_lookup,
    .create  = myfs_create,
    .mkdir   = myfs_mkdir,
    .unlink  = myfs_unlink,
    .rmdir   = myfs_rmdir,
    .rename  = myfs_rename,
};

/* 일반 파일 inode의 전형적인 설정 */
static const struct inode_operations myfs_file_iops = {
    .setattr = myfs_setattr,
    .getattr = myfs_getattr,
};

static const struct file_operations myfs_file_fops = {
    .read_iter   = generic_file_read_iter,
    .write_iter  = generic_file_write_iter,
    .mmap        = generic_file_mmap,
    .fsync       = generic_file_fsync,
    .splice_read = filemap_splice_read,
    .llseek      = generic_file_llseek,
    .open        = generic_file_open,
};

잠금 및 상태 필드

inode 할당 과정

새로운 inode가 생성되거나 디스크에서 읽힐 때의 할당 과정을 추적합니다. VFS는 여러 할당 경로를 제공하며, 각각 다른 사용 사례에 최적화되어 있습니다.

주요 할당 함수

/* ===== 경로 1: 새 파일 생성 (예: create 시스템콜) ===== */
static int myfs_create(struct mnt_idmap *idmap,
                       struct inode *dir,
                       struct dentry *dentry,
                       umode_t mode, bool excl)
{
    struct inode *inode;

    /* 1. 새 inode 할당 (sb->s_op->alloc_inode 호출) */
    inode = new_inode(dir->i_sb);
    if (!inode)
        return -ENOMEM;

    /* 2. inode 번호 할당 */
    inode->i_ino = myfs_alloc_ino(dir->i_sb);

    /* 3. 소유권/권한 설정 */
    inode_init_owner(idmap, inode, dir, mode);

    /* 4. 연산 테이블 연결 */
    inode->i_op  = &myfs_file_iops;
    inode->i_fop = &myfs_file_fops;
    inode->i_mapping->a_ops = &myfs_aops;

    /* 5. 타임스탬프 설정 */
    simple_inode_init_ts(inode);

    /* 6. 해시 테이블에 삽입 */
    insert_inode_hash(inode);

    /* 7. 디스크에 기록 */
    myfs_write_inode_to_disk(inode);

    /* 8. dentry와 연결 */
    d_instantiate_new(dentry, inode);
    return 0;
}

/* ===== 경로 2: 디스크에서 inode 읽기 (예: lookup) ===== */
static struct inode *myfs_iget(struct super_block *sb,
                                unsigned long ino)
{
    struct inode *inode;
    struct myfs_inode_info *mi;

    /* 1. 해시 테이블 검색 또는 새 할당 */
    inode = iget_locked(sb, ino);
    if (!inode)
        return ERR_PTR(-ENOMEM);

    /* 2. 이미 캐시에 있으면 즉시 반환 */
    if (!(inode->i_state & I_NEW))
        return inode;

    /* 3. 새로 할당된 경우: 디스크에서 읽기 */
    mi = MYFS_I(inode);
    myfs_read_inode_from_disk(sb, ino, mi);

    /* 4. VFS inode 필드 채우기 */
    inode->i_mode = myfs_to_vfs_mode(mi->disk_mode);
    inode->i_size = mi->disk_size;
    set_nlink(inode, mi->disk_nlink);

    /* 5. 연산 테이블 연결 (유형에 따라) */
    if (S_ISREG(inode->i_mode)) {
        inode->i_op  = &myfs_file_iops;
        inode->i_fop = &myfs_file_fops;
    } else if (S_ISDIR(inode->i_mode)) {
        inode->i_op  = &myfs_dir_iops;
        inode->i_fop = &myfs_dir_fops;
    }

    /* 6. I_NEW 해제 → 다른 대기자 깨우기 */
    unlock_new_inode(inode);
    return inode;
}

iget_locked() 콜 체인 상세 분석

iget_locked(sb, ino)는 inode 캐시 조회 → 미스 시 할당 → 초기화 잠금 획득의 세 단계를 원자적으로 수행합니다. 아래는 fs/inode.c의 실제 구현 흐름입니다.

/* fs/inode.c — iget_locked() 전체 콜 체인 */

/* ── 진입점 ─────────────────────────────────────── */
struct inode *iget_locked(struct super_block *sb, unsigned long ino)
{
    struct hlist_head *head = inode_hashtable + hash(sb, ino);
    struct inode *inode;
again:
    spin_lock(&inode_hash_lock);                  /* 해시 버킷 잠금 */
    inode = find_inode_fast(sb, head, ino);       /* ① 해시 조회 */
    spin_unlock(&inode_hash_lock);
    if (inode) {
        if (IS_ERR(inode))
            return NULL;
        wait_on_inode(inode);                      /* I_NEW 대기 */
        if (unlikely(inode_unhashed(inode))) {
            iput(inode);
            goto again;                            /* evict 경쟁 재시도 */
        }
        return inode;                              /* 캐시 히트 반환 */
    }

    /* ② 캐시 미스: 새 inode 할당 */
    inode = alloc_inode(sb);                      /* s_op->alloc_inode 호출 */
    if (inode) {
        struct inode *old;
        spin_lock(&inode_hash_lock);
        old = find_inode_fast(sb, head, ino);      /* TOCTOU 방지 재검사 */
        if (!old) {
            inode->i_ino = ino;
            spin_lock(&inode->i_lock);
            inode->i_state = I_NEW;                /* ③ 초기화 잠금 표시 */
            hlist_add_head(&inode->i_hash, head); /* 해시에 선점 등록 */
            spin_unlock(&inode->i_lock);
            inode_sb_list_add(inode);             /* sb->s_inodes 목록 추가 */
            spin_unlock(&inode_hash_lock);
            return inode;                          /* I_NEW 상태로 반환 */
        }
        spin_unlock(&inode_hash_lock);
        destroy_inode(inode);                     /* 경쟁 패배: 방금 할당 해제 */
        inode = old;
        wait_on_inode(inode);
    }
    return inode;
}

/* ── ① 해시 조회 ────────────────────────────────── */
static struct inode *find_inode_fast(
    struct super_block *sb, struct hlist_head *head, unsigned long ino)
{
    struct inode *inode;
    hlist_for_each_entry(inode, head, i_hash) {
        if (inode->i_ino != ino || inode->i_sb != sb)
            continue;
        spin_lock(&inode->i_lock);
        if (inode->i_state & (I_FREEING | I_WILL_FREE)) {
            __wait_on_freeing_inode(inode);        /* evict 완료 대기 후 재시도 */
            return ERR_PTR(-1);                   /* 호출자에게 재검사 요청 */
        }
        __iget(inode);                             /* i_count 증가 */
        spin_unlock(&inode->i_lock);
        return inode;
    }
    return NULL;
}

/* ── ② inode 할당 ───────────────────────────────── */
static struct inode *alloc_inode(struct super_block *sb)
{
    const struct super_operations *ops = sb->s_op;
    struct inode *inode;

    if (ops->alloc_inode)
        inode = ops->alloc_inode(sb);              /* fs별 kmem_cache 할당 */
    else
        inode = kmem_cache_alloc(inode_cachep, GFP_KERNEL); /* 기본 slab */
    if (!inode)
        return NULL;
    if (unlikely(inode_init_always(sb, inode))) {  /* VFS 필드 초기화 */
        if (ops->destroy_inode) {
            ops->destroy_inode(inode);
            return NULL;
        }
        kmem_cache_free(inode_cachep, inode);
        return NULL;
    }
    return inode;
}

/* ── ③ 초기화 완료 후 잠금 해제 ─────────────────── */
void unlock_new_inode(struct inode *inode)
{
    spin_lock(&inode->i_lock);
    if (WARN_ON(!(inode->i_state & I_NEW)))        /* 디버그: I_NEW 필수 확인 */
        goto out;
    inode->i_state &= ~I_NEW & ~I_CREATING;       /* I_NEW 비트 제거 */
    smp_mb();                                      /* 메모리 배리어 */
    wake_up_bit(&inode->i_state, __I_NEW);        /* 대기 중인 스레드 깨우기 */
out:
    spin_unlock(&inode->i_lock);
}

inode 해시 테이블과 룩업

VFS는 전역 해시 테이블 inode_hashtable을 유지하여 빠른 inode 검색을 제공합니다. 키는 (superblock 포인터, inode 번호) 쌍이며, 해시 충돌은 체이닝으로 해결합니다.

/* fs/inode.c — 전역 해시 테이블 */
static struct hlist_head *inode_hashtable __read_mostly;

/* 해시 함수: superblock 주소와 inode 번호를 조합 */
static unsigned long hash(struct super_block *sb,
                          unsigned long hashval)
{
    unsigned long tmp;
    tmp = (hashval * (unsigned long)sb) ^ (GOLDEN_RATIO_PRIME + hashval) /
          L1_CACHE_BYTES;
    tmp = tmp ^ ((tmp ^ GOLDEN_RATIO_PRIME) >> i_hash_shift);
    return tmp & i_hash_mask;
}

/* 해시 테이블 검색 (find_inode_fast) */
static struct inode *find_inode_fast(
    struct super_block *sb,
    struct hlist_head *head,
    unsigned long ino)
{
    struct inode *inode;
    hlist_for_each_entry(inode, head, i_hash) {
        if (inode->i_ino != ino)  /* 번호 불일치 */
            continue;
        if (inode->i_sb != sb)    /* superblock 불일치 */
            continue;
        spin_lock(&inode->i_lock);
        if (inode->i_state & (I_FREEING|I_WILL_FREE)) {
            __wait_on_freeing_inode(inode);
            return NULL;  /* 재검색 필요 */
        }
        __iget(inode);  /* i_count++ */
        spin_unlock(&inode->i_lock);
        return inode;
    }
    return NULL;
}

해시 테이블 연산

inode 상태 머신

각 inode는 i_state 필드에 상태 플래그의 조합을 저장합니다. 이 플래그들은 inode의 생명주기 단계를 추적하며, 동시성 제어와 writeback에 핵심적입니다.

/* inode dirty 마킹 — fs/fs-writeback.c */
void __mark_inode_dirty(struct inode *inode, int flags)
{
    struct super_block *sb = inode->i_sb;
    struct bdi_writeback *wb = NULL;

    /* 이미 설정된 플래그는 무시 */
    if ((inode->i_state & flags) == flags)
        return;

    spin_lock(&inode->i_lock);
    /* I_NEW, I_FREEING, I_WILL_FREE 상태면 무시 */
    if (inode->i_state & (I_NEW | I_FREEING | I_WILL_FREE)) {
        spin_unlock(&inode->i_lock);
        return;
    }

    /* FS에 dirty_inode 콜백이 있으면 호출 */
    if (sb->s_op->dirty_inode)
        sb->s_op->dirty_inode(inode, flags);

    /* dirty 플래그 설정 */
    inode->i_state |= flags;

    /* writeback 큐에 등록 */
    if (!(inode->i_state & I_DIRTY_ALL))
        inode_io_list_move_locked(inode, wb, &wb->b_dirty);

    spin_unlock(&inode->i_lock);
}

mark_inode_dirty() 내부 구현 상세

mark_inode_dirty()는 inode가 변경되었음을 VFS에 알려 writeback 대상에 포함시키는 핵심 함수입니다. 내부적으로 __mark_inode_dirty()를 호출하여 BDI(Backing Device Info) writeback 큐에 등록합니다.

/* fs/fs-writeback.c — __mark_inode_dirty() 전체 구현 */
void __mark_inode_dirty(struct inode *inode, int flags)
{
    struct super_block *sb = inode->i_sb;
    struct bdi_writeback *wb = NULL;

    /* 1. 이미 해당 dirty 비트가 설정되어 있으면 빠른 종료 */
    if ((inode->i_state & flags) == flags)
        return;

    /* 2. s_op->dirty_inode() 콜백 호출 (ext4: 저널 컨텍스트 확인) */
    if (sb->s_op->dirty_inode)
        sb->s_op->dirty_inode(inode, flags & (I_DIRTY_INODE | I_DIRTY_TIME));

    /* 3. I_DIRTY_TIME → I_DIRTY_SYNC 승격 검사 */
    /*    lazytime이고 DIRTY_TIME만 설정하면 dirty list에 안 넣음 */
    if ((flags & I_DIRTY_TIME) &&
        !(flags & ~I_DIRTY_TIME) &&
        !(inode->i_state & I_DIRTY_INODE))
    {
        spin_lock(&inode->i_lock);
        if (inode->i_state & I_DIRTY_TIME) {
            spin_unlock(&inode->i_lock);
            return;  /* 이미 DIRTY_TIME, b_dirty_time에 있음 */
        }
        inode->i_state |= I_DIRTY_TIME;
        spin_unlock(&inode->i_lock);

        /* b_dirty_time 리스트에만 추가 (즉시 writeback 안 함) */
        inode_io_list_move_locked(inode, wb, &wb->b_dirty_time);
        return;
    }

    /* 4. dirty 비트 설정 + writeback 큐 등록 */
    spin_lock(&inode->i_lock);
    if ((inode->i_state & flags) != flags) {
        const int was_dirty = inode->i_state & I_DIRTY;

        inode->i_state |= flags;  /* dirty 비트 설정 */

        if (!was_dirty) {
            /* ⑤ 새로 dirty → writeback 큐에 등록 */
            inode->dirtied_when = jiffies;   /* dirty 시각 기록 */

            /* cgroup writeback: inode의 소속 wb 결정 */
            wb = locked_inode_to_wb_and_lock_list(inode);

            /* b_dirty 리스트에 추가 */
            inode_io_list_move_locked(inode, wb, &wb->b_dirty);

            spin_unlock(&wb->list_lock);

            /* ⑥ writeback 스레드 깨우기 (dirty_writeback_interval 후) */
            wb_wakeup_delayed(wb);
        }
    }
    spin_unlock(&inode->i_lock);
}

address_space와 inode 연결

inode의 i_mapping 필드는 페이지 캐시와의 연결점입니다. struct address_space는 inode에 임베드되어 있으며(i_data 필드), 파일 데이터의 페이지를 관리합니다.

struct address_space {
    struct inode       *host;        /* 소유 inode */
    struct xarray       i_pages;      /* 페이지 캐시 (XArray) */
    atomic_t           i_mmap_writable; /* VM_SHARED 매핑 수 */
    struct rb_root_cached i_mmap;      /* private/shared 매핑 트리 */
    unsigned long      nrpages;      /* 총 페이지 수 */
    pgoff_t            writeback_index; /* writeback 시작 위치 */
    const struct address_space_operations *a_ops;
    unsigned long      flags;        /* gfp_mask, 에러 상태 */
    struct rw_semaphore i_mmap_rwsem; /* mmap 보호 */
    void              *private_data; /* FS별 데이터 */
};

/* inode 내부의 임베드된 address_space */
struct inode {
    /* ... */
    struct address_space *i_mapping; /* 일반적으로 &i_data를 가리킴 */
    struct address_space  i_data;    /* 임베드된 address_space */
    /* ... */
};

/* 초기화 시 i_mapping = &i_data로 설정됨 */
/* 블록 디바이스의 경우: 여러 파일이 같은 address_space를 공유할 수 있음 */

주요 address_space_operations 콜백

inode와 mmap 연동

mmap()은 파일의 address_space를 프로세스의 가상 주소 공간(Address Space)에 매핑합니다. 이 매핑은 inode의 i_mapping을 통해 페이지 캐시와 직접 연결되므로, 여러 프로세스가 같은 파일을 mmap하면 같은 물리 페이지를 공유합니다.

/* vm_operations_struct — mmap 페이지 폴트 핸들러 */
static const struct vm_operations_struct ext4_file_vm_ops = {
    .fault       = filemap_fault,       /* 읽기 폴트 → 페이지 캐시에서 folio 매핑 */
    .map_pages   = filemap_map_pages,   /* 주변 페이지 선제 매핑 (TLB miss 줄임) */
    .page_mkwrite = ext4_page_mkwrite,  /* 쓰기 폴트 → 블록 할당 + dirty 마킹 */
};

/* page_mkwrite — 쓰기 폴트 시 FS에 알림 */
static vm_fault_t ext4_page_mkwrite(struct vm_fault *vmf)
{
    struct inode *inode = file_inode(vmf->vma->vm_file);

    /* 1. i_rwsem 공유 잠금 획득 */
    sb_start_pagefault(inode->i_sb);

    /* 2. 블록이 아직 할당 안 됐으면 할당 (delalloc) */
    ext4_map_blocks(handle, inode, &map, ...);

    /* 3. 페이지를 dirty로 마킹 → writeback 대상에 포함 */
    folio_mark_dirty(folio);
    folio_wait_stable(folio);  /* 저널링: stable write 대기 */

    return VM_FAULT_LOCKED;
}

ACL과 권한 검사

파일 접근 시 VFS는 inode_permission()을 통해 권한을 검사합니다. 이 과정에서 전통적인 Unix 권한(rwx), POSIX ACL, 보안 모듈(LSM) 검사가 순차적으로 수행됩니다.

/* fs/namei.c — 권한 검사 진입점 */
int inode_permission(struct mnt_idmap *idmap,
                    struct inode *inode, int mask)
{
    int retval;

    /* 1. sb 레벨 읽기 전용 검사 */
    retval = sb_permission(inode->i_sb, inode, mask);
    if (retval)
        return retval;

    /* 2. FS별 permission 콜백 또는 generic_permission */
    if (inode->i_op->permission)
        retval = inode->i_op->permission(idmap, inode, mask);
    else
        retval = generic_permission(idmap, inode, mask);

    if (retval)
        return retval;

    /* 3. LSM 검사 (SELinux, AppArmor 등) */
    retval = security_inode_permission(inode, mask);
    return retval;
}

/* generic_permission 내부 흐름 */
int generic_permission(struct mnt_idmap *idmap,
                      struct inode *inode, int mask)
{
    /* (a) ACL이 있으면 ACL 검사 우선 */
    if (IS_POSIXACL(inode) && ...) {
        retval = posix_acl_permission(idmap, inode, acl, mask);
    }
    /* (b) 전통적 owner/group/other 검사 */
    else {
        retval = acl_permission_check(idmap, inode, mask);
    }
    /* (c) DAC override: CAP_DAC_OVERRIDE, CAP_DAC_READ_SEARCH */
    if (retval && capable_wrt_inode_uidgid(idmap, inode,
                                            CAP_DAC_OVERRIDE))
        retval = 0;
    return retval;
}

POSIX ACL 상세

# POSIX ACL 사용 예시

# 현재 ACL 확인
getfacl /home/user/shared/

# 특정 사용자에게 읽기/쓰기 권한 부여
setfacl -m u:bob:rw /home/user/shared/report.txt

# 그룹에 읽기 권한 부여
setfacl -m g:devteam:r /home/user/shared/report.txt

# default ACL 설정 (새 파일에 자동 적용)
setfacl -d -m u:bob:rwx /home/user/shared/

# ACL 제거
setfacl -b /home/user/shared/report.txt

# 마스크 확인 (effective 권한 상한)
getfacl --omit-header /home/user/shared/report.txt
# user:bob:rw-      #effective:r--  (마스크=r--인 경우)

setattr/getattr 헬퍼 함수

VFS는 inode 속성 변경(chmod, chown, truncate)과 조회(stat)를 위한 공통 헬퍼를 제공합니다. 파일시스템은 이 헬퍼를 호출한 뒤 FS 고유의 추가 작업(저널, 블록 할당 등)을 수행합니다.

notify_change() — 속성 변경 진입점

chmod(2), chown(2), truncate(2), utimes(2) 등의 시스템콜은 모두 notify_change()를 통해 inode 속성을 변경합니다.

/* fs/attr.c — notify_change() 핵심 흐름 */
int notify_change(struct mnt_idmap *idmap,
                  struct dentry *dentry,
                  struct iattr *attr,
                  struct inode **delegated_inode)
{
    struct inode *inode = dentry->d_inode;
    int error;

    /* 1. SGID 비트 자동 제거 (비소유자 write 시) */
    if (attr->ia_valid & ATTR_MODE) {
        if (!in_group_or_capable(idmap, inode, attr->ia_vfsgid))
            attr->ia_mode &= ~S_ISGID;
    }

    /* 2. 보안/사전 검사 */
    error = security_inode_setattr(idmap, dentry, attr);
    if (error)
        return error;

    /* 3. FS별 setattr 콜백 호출 */
    if (inode->i_op->setattr)
        error = inode->i_op->setattr(idmap, dentry, attr);
    else
        error = simple_setattr(idmap, dentry, attr);

    if (!error) {
        /* 4. fsnotify 이벤트 발생 */
        fsnotify_change(dentry, attr->ia_valid);
    }
    return error;
}

/* simple_setattr — 기본 setattr 구현 (tmpfs, ramfs 등) */
int simple_setattr(struct mnt_idmap *idmap,
                   struct dentry *dentry,
                   struct iattr *iattr)
{
    struct inode *inode = d_inode(dentry);
    int error;

    error = setattr_prepare(idmap, dentry, iattr);
    if (error)
        return error;

    if (iattr->ia_valid & ATTR_SIZE)
        truncate_setsize(inode, iattr->ia_size);

    setattr_copy(idmap, inode, iattr);
    mark_inode_dirty(inode);
    return 0;
}

setattr_prepare() — 사전 검증

setattr_prepare()는 속성 변경이 허용되는지 사전에 검증합니다. 모든 파일시스템의 setattr 콜백에서 반드시 호출해야 합니다.

/* fs/attr.c — setattr_prepare() */
int setattr_prepare(struct mnt_idmap *idmap,
                    struct dentry *dentry,
                    struct iattr *attr)
{
    struct inode *inode = d_inode(dentry);
    unsigned int ia_valid = attr->ia_valid;

    /* 1. immutable/append-only 검사 */
    if (IS_IMMUTABLE(inode))
        return -EPERM;
    if (IS_APPEND(inode) && (ia_valid & (ATTR_MODE | ATTR_UID |
                               ATTR_GID | ATTR_TIMES_SET | ATTR_SIZE)))
        return -EPERM;

    /* 2. UID 변경: 소유자이거나 CAP_CHOWN 필요 */
    if (ia_valid & ATTR_UID) {
        vfsuid_t vfsuid = make_vfsuid(idmap, ...);
        if (!inode_owner_or_capable(idmap, inode) &&
            !capable_wrt_inode_uidgid(idmap, inode, CAP_CHOWN))
            return -EPERM;
    }

    /* 3. GID 변경: 소유자이거나 CAP_CHOWN 필요 */
    if (ia_valid & ATTR_GID) {
        /* 유사한 검사 */
    }

    /* 4. 크기 변경: 쓰기 권한 + 파일 크기 제한 검사 */
    if (ia_valid & ATTR_SIZE) {
        int error = inode_newsize_ok(inode, attr->ia_size);
        if (error)
            return error;
    }

    /* 5. 모드(권한) 변경: 소유자이거나 CAP_FOWNER 필요 */
    if (ia_valid & ATTR_MODE) {
        if (!inode_owner_or_capable(idmap, inode))
            return -EPERM;
        /* 비소유 그룹이면 SGID 제거 */
    }

    /* 6. 타임스탬프 변경: 소유자이거나 쓰기 권한 */
    if (ia_valid & ATTR_TIMES_SET) {
        if (!inode_owner_or_capable(idmap, inode))
            return -EPERM;
    }

    return 0;
}

setattr_copy() — 필드 복사

/* fs/attr.c — setattr_copy(): iattr에서 inode로 필드 복사 */
void setattr_copy(struct mnt_idmap *idmap,
                  struct inode *inode,
                  const struct iattr *attr)
{
    unsigned int ia_valid = attr->ia_valid;

    /* UID 복사 (idmap 변환 적용) */
    if (ia_valid & ATTR_UID)
        inode->i_uid = vfsuid_into_kuid(attr->ia_vfsuid);

    /* GID 복사 */
    if (ia_valid & ATTR_GID)
        inode->i_gid = vfsgid_into_kgid(attr->ia_vfsgid);

    /* 크기 복사 (truncate_setsize가 이미 처리했을 수 있음) */
    if (ia_valid & ATTR_SIZE)
        i_size_write(inode, attr->ia_size);

    /* 타임스탬프 복사 */
    if (ia_valid & ATTR_ATIME)
        inode_set_atime_to_ts(inode, attr->ia_atime);
    if (ia_valid & ATTR_MTIME)
        inode_set_mtime_to_ts(inode, attr->ia_mtime);
    if (ia_valid & ATTR_CTIME)
        inode_set_ctime_to_ts(inode, attr->ia_ctime);

    /* 모드 복사 + SGID 조건부 제거 */
    if (ia_valid & ATTR_MODE) {
        umode_t mode = attr->ia_mode;
        /* 그룹 실행 비트 없으면 SGID 무의미 → 제거 */
        if (!in_group_or_capable(idmap, inode,
                                i_gid_into_vfsgid(idmap, inode)))
            mode &= ~S_ISGID;
        inode->i_mode = mode;
    }
}

generic_fillattr() — stat 채우기

stat(2)/statx(2) 시스템콜에서 VFS가 inode_operations.getattr을 호출하면, 파일시스템은 generic_fillattr()를 사용하여 struct kstat를 채웁니다.

/* fs/stat.c — generic_fillattr() */
void generic_fillattr(struct mnt_idmap *idmap,
                      u32 request_mask,
                      struct inode *inode,
                      struct kstat *stat)
{
    /* idmap 변환 적용 후 uid/gid 설정 */
    stat->uid   = vfsuid_into_kuid(i_uid_into_vfsuid(idmap, inode));
    stat->gid   = vfsgid_into_kgid(i_gid_into_vfsgid(idmap, inode));

    stat->dev     = inode->i_sb->s_dev;
    stat->ino     = inode->i_ino;
    stat->mode    = inode->i_mode;
    stat->nlink   = inode->i_nlink;
    stat->size    = i_size_read(inode);
    stat->blocks  = inode->i_blocks;
    stat->blksize = i_blocksize(inode);

    /* 타임스탬프 복사 (접근자 사용) */
    stat->atime = inode_get_atime(inode);
    stat->mtime = inode_get_mtime(inode);
    stat->ctime = inode_get_ctime(inode);

    /* rdev — 블록/캐릭터 디바이스 번호 */
    stat->rdev = inode->i_rdev;
    stat->result_mask |= STATX_BASIC_STATS;
}

/* 파일시스템의 getattr 구현 예시 */
static int myfs_getattr(struct mnt_idmap *idmap,
                        const struct path *path,
                        struct kstat *stat,
                        u32 request_mask, unsigned int query_flags)
{
    struct inode *inode = d_inode(path->dentry);

    /* 기본 필드 채우기 */
    generic_fillattr(idmap, request_mask, inode, stat);

    /* FS 고유 확장 정보 (statx) */
    if (request_mask & STATX_BTIME)
        stat->btime = MYFS_I(inode)->i_crtime;

    stat->attributes |= STATX_ATTR_IMMUTABLE;
    stat->attributes_mask |= STATX_ATTR_IMMUTABLE;
    return 0;
}

타임스탬프 정밀도와 Y2038

inode 타임스탬프는 파일 메타데이터 중 가장 빈번하게 갱신되는 필드입니다. 커널은 struct timespec64로 나노초 정밀도를 지원하지만, 실제 저장 정밀도는 파일시스템에 따라 다릅니다.

/* VFS 타임스탬프 API (커널 6.x) */

/* 타임스탬프 읽기 — 접근자 함수 사용 필수 */
struct timespec64 ts = inode_get_atime(inode);
struct timespec64 ts = inode_get_mtime(inode);
struct timespec64 ts = inode_get_ctime(inode);

/* 타임스탬프 설정 */
inode_set_atime_to_ts(inode, ts);
inode_set_mtime_to_ts(inode, ts);
inode_set_ctime_to_ts(inode, ts);

/* 현재 시간으로 설정 (FS의 정밀도에 맞춰 자동 truncate) */
inode_set_ctime_current(inode);

/* 정밀도 선언 — superblock에서 설정 */
sb->s_time_gran = 1;           /* 나노초 정밀도 */
sb->s_time_gran = NSEC_PER_SEC; /* 초 단위 정밀도 */
sb->s_time_min  = (s64)0;      /* 최소 타임스탬프 */
sb->s_time_max  = (s64)U32_MAX; /* 최대 타임스탬프 */

/* Y2038 안전성 — timespec64는 64비트 초 필드 사용 */
struct timespec64 {
    time64_t  tv_sec;   /* 64비트 초 (Y2038 안전) */
    long      tv_nsec;  /* 나노초 (0 ~ 999999999) */
};

# statx로 확장 타임스탬프 확인 (crtime 포함)
python3 -c "
import os
result = os.stat('/home/user/test.txt')
print(f'atime: {result.st_atime}')
print(f'mtime: {result.st_mtime}')
print(f'ctime: {result.st_ctime}')
"

# 또는 stat 명령어 사용
stat /home/user/test.txt
# 출력에서 Access, Modify, Change, Birth 시간 확인

# lazytime 마운트 옵션: atime을 메모리에서만 갱신
mount -o remount,lazytime /

# relatime 확인 (기본값)
mount | grep relatime

inotify/fanotify 이벤트 통지

VFS 파일 이벤트 통지 시스템은 fsnotify 인프라 위에 구축됩니다. inode에 감시 마크(watch mark)를 부착하면, 해당 inode에서 발생하는 이벤트가 유저스페이스로 전달됩니다.

fsnotify 아키텍처

/* fs/notify 구조 */
/*
 * fsnotify_group  — 이벤트 수신자 (inotify fd 또는 fanotify fd)
 * fsnotify_mark   — inode/mount/sb에 부착된 감시 마크
 * fsnotify_event  — 발생한 이벤트 (큐에 저장)
 */

struct fsnotify_mark {
    struct fsnotify_group *group;    /* 소속 그룹 */
    union {
        struct inode *inode;           /* inode 마크 */
        struct vfsmount *mnt;         /* 마운트 마크 */
        struct super_block *sb;       /* sb 마크 (fanotify) */
    } connector_target;
    __u32              mask;        /* 감시할 이벤트 마스크 */
    __u32              ignore_mask; /* 무시할 이벤트 */
};

/* VFS 내부에서 이벤트 발생 호출 (예: vfs_write 완료 시) */
void fsnotify_modify(struct file *file)
{
    struct inode *inode = file_inode(file);
    if (!(inode->i_fsnotify_mask & FS_MODIFY))
        return;
    fsnotify_parent(file->f_path.dentry, FS_MODIFY, file, FSNOTIFY_EVENT_PATH);
    fsnotify(inode, FS_MODIFY, file, FSNOTIFY_EVENT_PATH, NULL, 0);
}

inotify vs fanotify 비교

writeback 파이프라인(Pipeline)

dirty inode의 데이터를 디스크에 기록하는 과정을 writeback이라 합니다. 커널은 백그라운드 워커 스레드(Thread)를 통해 비동기적으로 writeback을 수행하며, 이 과정에서 inode의 상태 플래그가 핵심 역할을 합니다.

writeback 발동 조건

/* writeback 워커 핵심 루프 — fs/fs-writeback.c */
static long writeback_sb_inodes(struct super_block *sb,
                               struct bdi_writeback *wb,
                               struct wb_writeback_work *work)
{
    while (!list_empty(&wb->b_io)) {
        struct inode *inode = wb_inode(wb->b_io.prev);

        spin_lock(&inode->i_lock);

        /* I_SYNC 설정 (다른 스레드의 동시 writeback 방지) */
        inode->i_state |= I_SYNC;

        spin_unlock(&inode->i_lock);

        /* dirty 페이지 기록 */
        __writeback_single_inode(inode, &wbc);

        spin_lock(&inode->i_lock);
        inode->i_state &= ~I_SYNC;

        /* writeback 중 재-dirty되었으면 b_more_io로 이동 */
        if (inode->i_state & I_DIRTY)
            inode_io_list_move_locked(inode, wb, &wb->b_more_io);
        else
            list_del_init(&inode->i_io_list);  /* clean */

        spin_unlock(&inode->i_lock);
    }
}

파일시스템 Freeze/Thaw와 inode

파일시스템 freeze는 모든 쓰기 I/O를 중단시키고 일관된 스냅샷 상태를 만드는 메커니즘입니다. LVM 스냅샷, 온라인 백업 등에 필수적이며, inode의 dirty 상태와 writeback에 직접적 영향을 줍니다.

/* fs/super.c — freeze/thaw 핵심 경로 */

/* freeze 수준 (단계적 진행) */
enum {
    SB_UNFROZEN      = 0,  /* 정상 */
    SB_FREEZE_WRITE  = 1,  /* 새 쓰기 거부 */
    SB_FREEZE_PAGEFAULT = 2, /* mmap 쓰기 폴트 거부 */
    SB_FREEZE_FS     = 3,  /* FS 내부 트랜잭션 완료 대기 */
    SB_FREEZE_COMPLETE = 4, /* 완전 freeze 완료 */
};

int freeze_super(struct super_block *sb, enum freeze_holder who)
{
    /* 1. SB_FREEZE_WRITE → 새 write/truncate 차단 */
    sb_wait_write(sb, SB_FREEZE_WRITE);

    /* 2. SB_FREEZE_PAGEFAULT → mmap page_mkwrite 차단 */
    sb_wait_write(sb, SB_FREEZE_PAGEFAULT);

    /* 3. dirty inode writeback 강제 실행 + 대기 */
    sync_filesystem(sb);

    /* 4. SB_FREEZE_FS → FS별 freeze 콜백 */
    if (sb->s_op->freeze_fs)
        sb->s_op->freeze_fs(sb);
    /*    ext4: 저널 커밋 + 배리어 */
    /*    XFS: 로그 quiesce */
    /*    Btrfs: 트랜잭션 커밋 */
}

# 사용자 공간에서 freeze/thaw
fsfreeze -f /mnt/data    # freeze → 모든 I/O 중단
# ... LVM 스냅샷 생성, 블록 레벨 백업 등 ...
fsfreeze -u /mnt/data    # thaw → I/O 재개

# freeze 상태 확인
cat /proc/mounts | grep /mnt/data
# 또는
xfs_freeze -s /mnt/data  # XFS 전용 (fsfreeze와 동일)

파일시스템별 inode 구현 비교

각 파일시스템은 VFS struct inode를 자체 구조체에 임베드하여 확장합니다. 이 패턴은 C 언어에서 상속 없이 다형성을 구현하는 커널의 대표적 기법입니다.

container_of 패턴

/* container_of 매크로 — include/linux/container_of.h */
#define container_of(ptr, type, member) ({            \
    void *__mptr = (void *)(ptr);                     \
    (type *)(__mptr - offsetof(type, member)); })

/* 각 파일시스템의 변환 매크로 */
/* ext4 */
static inline struct ext4_inode_info *EXT4_I(struct inode *inode)
{
    return container_of(inode, struct ext4_inode_info, vfs_inode);
}

/* XFS */
static inline struct xfs_inode *XFS_I(struct inode *inode)
{
    return container_of(inode, struct xfs_inode, vfs_inode);
}

/* Btrfs */
static inline struct btrfs_inode *BTRFS_I(struct inode *inode)
{
    return container_of(inode, struct btrfs_inode, vfs_inode);
}

/* 사용 예시: VFS에서 FS-specific 데이터 접근 */
static int ext4_file_open(struct inode *inode,
                         struct file *filp)
{
    struct ext4_inode_info *ei = EXT4_I(inode);
    /* ei->i_data, ei->i_flags 등 접근 */
}

파일시스템 inode 확장 필드 비교

inode 캐시와 LRU 관리

사용이 끝난 inode(i_count == 0)는 즉시 삭제되지 않고 LRU 리스트에 들어가 캐시됩니다. 이후 동일 파일 재접근 시 디스크 I/O 없이 즉시 반환할 수 있습니다.

LRU 메커니즘

/* iput() — 참조 해제 경로 */
void iput(struct inode *inode)
{
    if (!inode)
        return;

    if (atomic_dec_and_lock(&inode->i_count, &inode->i_lock)) {
        /* i_count가 0이 됨 */
        if (inode->i_nlink &&
            (inode->i_state & ~I_DIRTY_TIME) == 0) {
            /* 링크 남아있고 clean → LRU에 추가 */
            inode_add_lru(inode);
            spin_unlock(&inode->i_lock);
        } else {
            /* nlink==0이면 즉시 evict */
            inode->i_state |= I_WILL_FREE;
            spin_unlock(&inode->i_lock);
            evict(inode);
        }
    }
}

/* LRU 추가 — i_lru 리스트에 연결 */
static void inode_add_lru(struct inode *inode)
{
    if (!(inode->i_sb->s_flags & SB_ACTIVE))
        return;
    /* I_REFERENCED 설정 → 2차 기회 */
    inode->i_state |= I_REFERENCED;
    list_lru_add(&inode->i_sb->s_inode_lru, &inode->i_lru);
    /* percpu 카운터 증가 */
    this_cpu_inc(nr_unused);
}

# inode 캐시 모니터링

# 할당된 inode 수 / free inode 수
cat /proc/sys/fs/inode-nr
# 예: 45678  234  (할당 45678, 빈 234)

# 상태별 inode 수
cat /proc/sys/fs/inode-state
# nr_inodes  nr_free_inodes  preshrink

# slab 캐시에서 inode 캐시 확인
slabtop -o | grep inode_cache
# 또는
cat /proc/slabinfo | grep inode_cache

# vfs_cache_pressure 확인 및 변경
cat /proc/sys/vm/vfs_cache_pressure
# 기본값: 100

# 파일 서버에서 inode 캐시 유지 선호
echo 50 > /proc/sys/vm/vfs_cache_pressure

# dentry 캐시와의 비교
cat /proc/sys/fs/dentry-state
# nr_dentry  nr_unused  age_limit  want_pages

디스크 inode 레이아웃 (ext4)

메모리의 VFS inode와 달리, 디스크 inode는 파일시스템 포맷에 따라 고정된 레이아웃을 가집니다. ext4를 예로 들어 디스크 inode의 물리적 구조를 살펴봅니다.

/* include/linux/ext4.h — 디스크 inode 구조 */
struct ext4_inode {
    __le16  i_mode;         /* 파일 유형 + 권한 */
    __le16  i_uid;          /* 소유자 UID 하위 16비트 */
    __le32  i_size_lo;      /* 파일 크기 하위 32비트 */
    __le32  i_atime;        /* 접근 시간 (초) */
    __le32  i_ctime;        /* inode 변경 시간 */
    __le32  i_mtime;        /* 데이터 수정 시간 */
    __le32  i_dtime;        /* 삭제 시간 */
    __le16  i_gid;          /* 그룹 GID 하위 16비트 */
    __le16  i_links_count;  /* 하드 링크 수 */
    __le32  i_blocks_lo;    /* 512B 블록 수 */
    __le32  i_flags;        /* ext4 플래그 */
    union {
        struct { __le32 l_i_version; } linux1;
    } osd1;
    __le32  i_block[15];    /* 60바이트: extent tree 또는 블록 포인터 */
    __le32  i_generation;   /* NFS 파일 핸들 세대 */
    __le32  i_file_acl_lo;  /* ACL 블록 (하위) */
    __le32  i_size_high;    /* 파일 크기 상위 32비트 */
    /* --- 128바이트 경계 --- */
    /* 확장 필드 (256B inode) */
    __le16  i_extra_isize;  /* 확장 필드 크기 */
    __le16  i_checksum_hi;  /* crc32c 상위 */
    __le32  i_ctime_extra;  /* ctime 나노초 + 에포크 확장 */
    __le32  i_mtime_extra;  /* mtime 나노초 */
    __le32  i_atime_extra;  /* atime 나노초 */
    __le32  i_crtime;       /* 생성 시간 (초) */
    __le32  i_crtime_extra; /* 생성 시간 나노초 */
    __le32  i_version_hi;   /* NFS 버전 상위 */
    __le32  i_projid;       /* 프로젝트 ID */
};

# ext4 디스크 inode 직접 조회

# debugfs로 inode 정보 확인
debugfs -R "stat <42>" /dev/sda1
# Inode: 42   Type: regular    Mode:  0644   Flags: 0x80000
# Generation: 1234567890   Version: 0x00000001
# User:  1000   Group:  1000   Size: 4096
# File ACL: 0
# Links: 1   Blockcount: 8
# Fragment:  Address: 0    Number: 0    Size: 0
# ctime: 0x65a12345:12345678 -- ...
# atime: 0x65a12346:00000000 -- ...
# mtime: 0x65a12345:12345678 -- ...
# crtime: 0x65a00000:00000000 -- ...
# EXTENTS:
# (0):1234567

# inode 크기 확인
tune2fs -l /dev/sda1 | grep "Inode size"
# Inode size:             256

# inode 테이블 위치 확인
dumpe2fs /dev/sda1 | grep "Inode table"
# Group 0: Inode table at 1025-1536

# statx로 crtime 확인 (유저스페이스)
stat /home/user/test.txt
# Birth: 2024-01-15 10:30:00.123456789 +0900

VFS 객체 관계 종합

지금까지 다룬 inode와 관련된 VFS 핵심 객체들의 관계를 종합적으로 정리합니다. superblock, inode, dentry, file 네 객체가 어떻게 연결되는지 이해하는 것이 VFS 전체를 파악하는 핵심입니다.

inode evict 경로

inode가 시스템에서 완전히 제거되는 과정을 evict라 합니다. evict는 메모리 회수(LRU shrinker) 또는 파일 삭제(i_nlink == 0) 시 발생합니다.

/* fs/inode.c — evict() 핵심 */
static void evict(struct inode *inode)
{
    const struct super_operations *op = inode->i_sb->s_op;

    /* 1. BDI writeback 큐에서 제거 */
    inode_io_list_del(inode);

    /* 2. sb의 inode 리스트에서 제거 */
    inode_sb_list_del(inode);

    /* 3. I_FREEING 상태 설정 (다른 스레드에게 evict 중임을 알림) */
    spin_lock(&inode->i_lock);
    inode->i_state |= I_FREEING;
    spin_unlock(&inode->i_lock);

    /* 4. FS별 evict_inode 호출 */
    if (op->evict_inode)
        op->evict_inode(inode);
    else {
        truncate_inode_pages_final(&inode->i_data);
        clear_inode(inode);
    }

    /* 5. 해시 테이블에서 제거 */
    remove_inode_hash(inode);

    /* 6. I_CLEAR 설정, 대기자 깨우기 */
    spin_lock(&inode->i_lock);
    wake_up_bit(&inode->i_state, __I_NEW);
    inode->i_state = I_FREEING | I_CLEAR;
    spin_unlock(&inode->i_lock);

    /* 7. 메모리 해제 */
    destroy_inode(inode);  /* → free_inode() 또는 kmem_cache_free() */
}

/* FS별 evict_inode 구현 예시 (ext4) */
void ext4_evict_inode(struct inode *inode)
{
    if (inode->i_nlink || is_bad_inode(inode))
        goto no_delete;

    /* nlink == 0: 실제 삭제 */
    dquot_initialize(inode);  /* 쿼타 정보 초기화 */
    ext4_begin_ordered_truncate(inode, 0);
    truncate_inode_pages_final(&inode->i_data);

    /* 저널에 삭제 트랜잭션 기록 */
    handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, ...);
    ext4_mark_inode_dirty(handle, inode);
    ext4_free_inode(handle, inode);  /* inode 비트맵 해제 */
    ext4_journal_stop(handle);
    return;

no_delete:
    /* 링크 남아있음: 데이터 페이지만 해제 */
    truncate_inode_pages_final(&inode->i_data);
    clear_inode(inode);
}

iput() 전체 콜 체인

iput()는 inode 참조를 해제하는 핵심 함수입니다. i_count를 감소시키고, 0이 되면 inode의 i_nlink과 dirty 상태에 따라 LRU 캐시 보존 또는 evict(메모리 해제)를 결정합니다.

/* fs/inode.c — iput() 전체 구현 */

void iput(struct inode *inode)
{
    if (!inode)
        return;

    /* i_count를 감소시키면서 동시에 i_lock을 원자적으로 획득 */
    if (atomic_dec_and_lock(&inode->i_count, &inode->i_lock))
        iput_final(inode);  /* i_count == 0: 최종 처리 */
}

static void iput_final(struct inode *inode)
{
    struct super_block *sb = inode->i_sb;
    const struct super_operations *op = sb->s_op;
    unsigned long state;
    int drop;

    /* ① s_op->drop_inode()로 즉시 evict 여부 결정 */
    if (op->drop_inode)
        drop = op->drop_inode(inode);
    else
        drop = generic_drop_inode(inode);

    if (!drop &&
        !(inode->i_state & I_DONTCACHE) &&
        (sb->s_flags & SB_ACTIVE)) {
        /* ② nlink > 0이고 FS 활성 상태: LRU에 보존 */
        __inode_add_lru(inode, true);
        spin_unlock(&inode->i_lock);
        return;                    /* 캐시에 유지, evict 안 함 */
    }

    state = inode->i_state;
    if (!drop) {
        /* I_DONTCACHE: 캐시 보존하지 않고 즉시 evict */
        WRITE_ONCE(inode->i_state, state | I_WILL_FREE);
        spin_unlock(&inode->i_lock);

        /* ③ dirty inode를 디스크에 기록 후 evict */
        write_inode_now(inode, 1);  /* sync writeback */

        spin_lock(&inode->i_lock);
        WRITE_ONCE(inode->i_state, (state & ~I_WILL_FREE) | I_FREEING);
    } else {
        /* ④ nlink == 0 또는 drop_inode가 1 반환: 즉시 evict */
        WRITE_ONCE(inode->i_state, state | I_FREEING);
    }

    inode_lru_list_del(inode);  /* LRU에서 제거 (있었다면) */
    spin_unlock(&inode->i_lock);

    /* ⑤ 실제 evict 수행 → FS별 evict_inode → destroy_inode */
    evict(inode);
}

/* generic_drop_inode — 기본 drop 정책 */
int generic_drop_inode(struct inode *inode)
{
    /* nlink == 0이면 삭제 → drop=1 → 즉시 evict */
    /* 또는 unhashed이면(remove_inode_hash 호출됨) drop=1 */
    return !inode->i_nlink || inode_unhashed(inode);
}

inode Truncation 경로

파일 크기를 줄이는 truncate()는 inode의 i_size를 변경하고, 잘려나간 범위의 데이터 블록과 페이지 캐시를 해제하는 복잡한 과정입니다. hole punch(fallocate PUNCH_HOLE)도 유사한 경로를 사용합니다.

/* mm/truncate.c — 페이지 캐시 truncation */
void truncate_setsize(struct inode *inode, loff_t newsize)
{
    loff_t oldsize = inode->i_size;

    /* i_size를 원자적으로 갱신 */
    i_size_write(inode, newsize);

    if (newsize > oldsize)
        pagecache_isize_extended(inode, oldsize, newsize);
    else
        truncate_pagecache(inode, newsize);
}

void truncate_pagecache(struct inode *inode, loff_t newsize)
{
    struct address_space *mapping = inode->i_mapping;
    loff_t holebegin = round_up(newsize, PAGE_SIZE);

    /* 1. mmap된 PTE 무효화 → SIGBUS 방지 */
    if (mapping_mapped(mapping))
        unmap_mapping_range(mapping, holebegin, 0, 1);

    /* 2. 페이지 캐시에서 해당 범위 제거 */
    truncate_inode_pages(mapping, newsize);

    /* 3. 재확인 (race 방지) */
    unmap_mapping_range(mapping, holebegin, 0, 1);
}

/* ext4 truncate — fs/ext4/inode.c */
void ext4_truncate(struct inode *inode)
{
    /* 1. 저널 트랜잭션 시작 */
    handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, needed);

    /* 2. extent tree에서 잘린 범위의 extent 제거 */
    ext4_ext_truncate(handle, inode);
    /*    → 블록 비트맵 해제, 그룹 디스크립터 갱신 */
    /*    → 저널에 메타데이터 변경 기록 */

    /* 3. inode dirty 마킹 */
    ext4_mark_inode_dirty(handle, inode);

    /* 4. 저널 트랜잭션 종료 */
    ext4_journal_stop(handle);
}

Orphan Inode 리스트

Orphan inode는 nlink가 0이지만 아직 사용 중인(열려 있는) inode입니다. unlink 후 열린 fd가 남아있거나, O_TMPFILE로 생성된 파일이 이에 해당합니다. 저널링 파일시스템은 orphan 리스트를 유지하여 크래시 후에도 이런 inode의 공간을 올바르게 회수합니다.

/* fs/ext4/namei.c — orphan 리스트 추가 */
int ext4_orphan_add(handle_t *handle, struct inode *inode)
{
    struct super_block *sb = inode->i_sb;
    struct ext4_sb_info *sbi = EXT4_SB(sb);

    /* 1. 메모리: 슈퍼블록의 orphan 리스트에 추가 */
    list_add(&EXT4_I(inode)->i_orphan, &sbi->s_orphan);

    /* 2. 디스크: 슈퍼블록의 s_last_orphan 체인에 연결 */
    /*    inode의 i_dtime 필드를 다음 orphan의 ino로 사용 */
    /*    슈퍼블록 → ino_A → ino_B → ino_C → 0 (종료) */
    NEXT_ORPHAN(inode) = le32_to_cpu(sbi->s_es->s_last_orphan);
    sbi->s_es->s_last_orphan = cpu_to_le32(inode->i_ino);

    /* 3. 저널에 기록 → 크래시 시에도 복구 가능 */
    ext4_handle_dirty_metadata(handle, NULL, sbi->s_sbh);
    ext4_mark_iloc_dirty(handle, inode, &iloc);

    return 0;
}

/* fs/ext4/super.c — 마운트 시 orphan 정리 */
static void ext4_orphan_cleanup(struct super_block *sb,
                                struct ext4_super_block *es)
{
    unsigned int s_flags = sb->s_flags;
    int nr_orphans = 0;

    /* s_last_orphan 체인을 순회하며 정리 */
    while (es->s_last_orphan) {
        struct inode *inode;
        ino = le32_to_cpu(es->s_last_orphan);

        inode = ext4_iget(sb, ino, ...);

        if (inode->i_nlink == 0) {
            /* nlink=0: 실제 삭제 수행 */
            iput(inode);  /* → evict_inode → ext4_free_inode */
        } else {
            /* nlink>0: truncate 미완 → 자르기 완료 */
            ext4_truncate(inode);
            iput(inode);
        }
        nr_orphans++;
    }
    /* "EXT4-fs: N orphan inodes cleaned up" 커널 로그 */
}

inode 잠금 체계

inode 관련 동시성 제어는 여러 레벨의 잠금으로 구성됩니다. 잘못된 잠금 순서는 데드락을 유발하므로, 커널은 엄격한 잠금 순서(lock ordering)를 정의합니다.

/* 잠금 순서 예시: 버퍼드 write */

/* 1. i_rwsem (exclusive) 획득 */
inode_lock(inode);

    /* 2. 페이지 획득 및 write_begin */
    a_ops->write_begin(file, mapping, pos, len, &folio);

        /* 3. folio lock (xa_lock 아래) */
        folio_lock(folio);

            /* 4. 블록 매핑 */
            ext4_map_blocks(handle, inode, &map, ...);

        folio_unlock(folio);  /* write_begin 내부에서 */

    /* 사용자 데이터 복사 */
    copy_page_from_iter_atomic(page, offset, bytes, from);

    a_ops->write_end(file, mapping, pos, len, copied, folio);

inode_unlock(inode);

/* 다중 inode 잠금 (rename 시) */
/* lock_rename()은 두 디렉터리를 inode 포인터 순서로 잠금 */
struct dentry *lock_rename(struct dentry *p1, struct dentry *p2)
{
    if (p1 == p2) {
        inode_lock_nested(p1->d_inode, I_MUTEX_PARENT);
        return NULL;
    }
    /* 포인터 주소 순서로 잠금 → 데드락 방지 */
    if (p1->d_inode < p2->d_inode) {
        inode_lock_nested(p1->d_inode, I_MUTEX_PARENT);
        inode_lock_nested(p2->d_inode, I_MUTEX_PARENT2);
    } else {
        inode_lock_nested(p2->d_inode, I_MUTEX_PARENT);
        inode_lock_nested(p1->d_inode, I_MUTEX_PARENT2);
    }
    return p1;
}

inode 유틸리티 함수/매크로 종합

VFS는 inode 필드를 안전하게 조작하기 위한 유틸리티 함수와 매크로를 제공합니다. 필드를 직접 수정하면 원자성(Atomicity) 위반, dirty 마킹 누락, NFS 불일치 등 미묘한 버그가 발생하므로 반드시 이 API를 사용해야 합니다.

i_size_read() / i_size_write()

i_size는 64비트 필드이므로 32비트 아키텍처에서 원자적(Atomic) 접근이 불가능합니다. VFS는 seqcount 기반의 접근자를 제공합니다.

/* include/linux/fs.h — i_size 접근자 */

/* 64비트 아키텍처: 직접 읽기/쓰기 (원자적) */
/* 32비트 아키텍처: seqcount_t로 tear-free 보장 */

static inline loff_t i_size_read(const struct inode *inode)
{
#if BITS_PER_LONG == 32 && defined(CONFIG_SMP)
    loff_t i_size;
    unsigned int seq;

    do {
        seq = read_seqcount_begin(&inode->i_size_seqcount);
        i_size = inode->i_size;
    } while (read_seqcount_retry(&inode->i_size_seqcount, seq));
    return i_size;
#else
    return inode->i_size;  /* 64비트: 단일 load 명령으로 원자적 */
#endif
}

static inline void i_size_write(struct inode *inode, loff_t i_size)
{
#if BITS_PER_LONG == 32 && defined(CONFIG_SMP)
    preempt_disable();
    write_seqcount_begin(&inode->i_size_seqcount);
    inode->i_size = i_size;
    write_seqcount_end(&inode->i_size_seqcount);
    preempt_enable();
#else
    inode->i_size = i_size;
#endif
}

타임스탬프 접근자 함수

커널 6.6부터 inode 타임스탬프 필드(__i_atime, __i_mtime, __i_ctime)는 직접 접근이 금지되고 접근자(Accessor) 함수를 통해서만 조작합니다. multi-grain 타임스탬프(Multi-grain Timestamp) 지원을 위한 리팩토링의 결과입니다.

/* include/linux/fs.h — 타임스탬프 접근자 구현 */
static inline struct timespec64 inode_get_atime(const struct inode *inode)
{
    return inode->__i_atime;
}

static inline struct timespec64
inode_set_atime_to_ts(struct inode *inode, struct timespec64 ts)
{
    inode->__i_atime = ts;
    return ts;
}

static inline struct timespec64
inode_set_atime(struct inode *inode, time64_t sec, long nsec)
{
    struct timespec64 ts = { .tv_sec = sec, .tv_nsec = nsec };
    return inode_set_atime_to_ts(inode, ts);
}

/* fs/inode.c — 현재 시간으로 ctime 설정 */
struct timespec64 inode_set_ctime_current(struct inode *inode)
{
    struct timespec64 now = current_time(inode);
    /* multi-grain: coarse 시간과 비교하여 fine-grain 필요 여부 판단 */
    inode_set_ctime_to_ts(inode, now);
    return now;
}

/* fs/libfs.c — 새 inode 타임스탬프 일괄 초기화 */
struct timespec64 simple_inode_init_ts(struct inode *inode)
{
    struct timespec64 ts = inode_set_ctime_current(inode);
    inode_set_atime_to_ts(inode, ts);
    inode_set_mtime_to_ts(inode, ts);
    return ts;
}

/* 파일시스템에서의 전형적인 사용 */
static int myfs_create(struct mnt_idmap *idmap,
                       struct inode *dir,
                       struct dentry *dentry, umode_t mode, bool excl)
{
    struct inode *inode = new_inode(dir->i_sb);
    simple_inode_init_ts(inode);           /* atime=mtime=ctime=now */
    inode_set_mtime_to_ts(dir,
        inode_set_ctime_current(dir));       /* 부모 dir 시간 갱신 */
    /* ... */
}

nlink 조작 함수

하드 링크 수(i_nlink)를 직접 수정하면 dirty 마킹이 누락되어 디스크 불일치가 발생합니다. 반드시 아래 API를 사용해야 합니다.

/* fs/inode.c — nlink 조작 함수 */

/* 절대값 설정 (디스크에서 읽을 때) */
void set_nlink(struct inode *inode, unsigned int nlink)
{
    if (!nlink) {
        clear_nlink(inode);   /* 0이면 별도 처리 */
    } else {
        /* 먼저 I_LINKABLE 비트를 지움 (nlink>0이면 불필요) */
        if (inode->i_nlink == 0)
            inode->i_state &= ~I_LINKABLE;
        inode->i_nlink = nlink;
    }
}

/* nlink 감소 (unlink, rmdir 시) */
void drop_nlink(struct inode *inode)
{
    WARN_ON(inode->i_nlink == 0);  /* 이미 0이면 BUG */
    inode->i_nlink--;
}

/* nlink 0으로 설정 (orphan 처리) */
void clear_nlink(struct inode *inode)
{
    if (inode->i_nlink) {
        inode->i_nlink = 0;
        atomic_long_inc(&inode->i_sb->s_remove_count);
    }
}

/* nlink 증가 (link 시) */
void inc_nlink(struct inode *inode)
{
    if (unlikely(inode->i_nlink == 0))
        WARN_ON(!(inode->i_state & I_LINKABLE));
    inode->i_nlink++;
}

/* 고수준 래퍼: nlink 변경 + dirty 마킹 */
static inline void inode_inc_link_count(struct inode *inode)
{
    inc_nlink(inode);
    mark_inode_dirty(inode);  /* nlink 변경을 디스크에 반영 */
}

static inline void inode_dec_link_count(struct inode *inode)
{
    drop_nlink(inode);
    mark_inode_dirty(inode);
}

inode 상태/플래그 헬퍼 매크로

inode->i_flags의 S_* 상수를 검사하는 IS_*() 매크로입니다. 마운트 옵션, 파일시스템 기능, 파일별 속성을 반영합니다.

/* include/linux/fs.h — inode S_* 플래그와 IS_*() 매크로 */

#define S_SYNC        (1 << 0)   /* 동기 쓰기 (mount -o sync) */
#define S_NOATIME     (1 << 1)   /* atime 갱신 안 함 */
#define S_APPEND      (1 << 2)   /* 추가 전용 (chattr +a) */
#define S_IMMUTABLE   (1 << 3)   /* 변경 불가 (chattr +i) */
#define S_DEAD        (1 << 4)   /* 삭제된 디렉터리 */
#define S_NOQUOTA     (1 << 5)   /* 쿼타 면제 */
#define S_DIRSYNC     (1 << 6)   /* 디렉터리 동기 쓰기 */
#define S_NOCMTIME    (1 << 7)   /* VFS가 ctime/mtime 자동 갱신 안 함 */
#define S_SWAPFILE    (1 << 8)   /* 스왑 파일 (이름 변경/삭제 불가) */
#define S_PRIVATE     (1 << 9)   /* LSM 검사 제외 (내부 inode) */
#define S_IMA         (1 << 10)  /* IMA 무결성 검증 대상 */
#define S_AUTOMOUNT   (1 << 11)  /* 자동 마운트 트리거 */
#define S_NOSEC       (1 << 12)  /* 보안 xattr 없음 (캐시 최적화) */
#define S_DAX         (1 << 13)  /* DAX 모드 (페이지 캐시 우회) */
#define S_ENCRYPTED   (1 << 14)  /* fscrypt 암호화 */
#define S_CASEFOLD    (1 << 15)  /* 대소문자 무시 디렉터리 */
#define S_VERITY      (1 << 16)  /* fs-verity 활성화 */

/* 검사 매크로 */
#define IS_IMMUTABLE(inode)   ((inode)->i_flags & S_IMMUTABLE)
#define IS_APPEND(inode)      ((inode)->i_flags & S_APPEND)
#define IS_SYNC(inode)        ((inode)->i_flags & S_SYNC)
#define IS_DIRSYNC(inode)     ((inode)->i_flags & S_DIRSYNC)
#define IS_DEADDIR(inode)     ((inode)->i_flags & S_DEAD)
#define IS_POSIXACL(inode)    ((inode)->i_sb->s_flags & SB_POSIXACL)
#define IS_PRIVATE(inode)     ((inode)->i_flags & S_PRIVATE)
#define IS_AUTOMOUNT(inode)   ((inode)->i_flags & S_AUTOMOUNT)
#define IS_NOSEC(inode)       ((inode)->i_flags & S_NOSEC)
#define IS_SWAPFILE(inode)    ((inode)->i_flags & S_SWAPFILE)
#define IS_DAX(inode)         ((inode)->i_flags & S_DAX)
#define IS_ENCRYPTED(inode)   ((inode)->i_flags & S_ENCRYPTED)
#define IS_VERITY(inode)      ((inode)->i_flags & S_VERITY)

make_bad_inode() / is_bad_inode()

I/O 에러나 파일시스템 손상(Corruption)으로 inode를 정상적으로 읽을 수 없을 때, "bad inode"로 표시하여 모든 연산이 -EIO를 반환하도록 합니다.

/* fs/bad_inode.c — bad inode 구현 */

void make_bad_inode(struct inode *inode)
{
    remove_inode_hash(inode);          /* 해시 테이블에서 제거 */
    inode->i_mode = S_IFREG;           /* 유형을 일반 파일로 변경 */
    inode_set_atime(inode, 0, 0);
    inode_set_mtime(inode, 0, 0);
    inode_set_ctime_to_ts(inode, (struct timespec64){0});
    inode->i_op  = &bad_inode_ops;     /* 모든 inode op → -EIO */
    inode->i_fop = &bad_file_ops;      /* 모든 file op → -EIO */
}

bool is_bad_inode(struct inode *inode)
{
    return (inode->i_op == &bad_inode_ops);
}

/* 파일시스템에서의 사용 예 */
struct inode *myfs_iget(struct super_block *sb, unsigned long ino)
{
    struct inode *inode = iget_locked(sb, ino);
    if (!(inode->i_state & I_NEW))
        return inode;

    if (myfs_read_disk_inode(sb, ino, inode)) {
        make_bad_inode(inode);      /* 읽기 실패 → bad 표시 */
        unlock_new_inode(inode);
        iput(inode);
        return ERR_PTR(-EIO);
    }
    unlock_new_inode(inode);
    return inode;
}

file_inode() 매크로

/* include/linux/fs.h */
static inline struct inode *file_inode(const struct file *f)
{
    return f->f_inode;
}

/* f_inode은 file 구조체에 직접 캐싱된 inode 포인터.
 * f->f_path.dentry->d_inode 경로보다 역참조(Dereference)가 1단계 적어
 * 성능상 유리하고, RCU 워크에서도 안전합니다.
 * VFS가 open() 시 f_inode = d_inode(dentry)로 설정합니다. */

/* 사용 예: file_operations 콜백 내부 */
static ssize_t myfs_read(struct file *file, ...)
{
    struct inode *inode = file_inode(file);
    struct myfs_inode_info *mi = MYFS_I(inode);
    /* ... */
}

inode_owner_or_capable() / inode_newsize_ok()

/* fs/inode.c — 소유자 또는 capability 검사 */
bool inode_owner_or_capable(struct mnt_idmap *idmap,
                            const struct inode *inode)
{
    struct user_namespace *ns;
    vfsuid_t vfsuid = i_uid_into_vfsuid(idmap, inode);

    /* 1. 현재 프로세스가 소유자인가? */
    if (vfsuid_eq_kuid(vfsuid, current_fsuid()))
        return true;

    /* 2. CAP_FOWNER capability가 있는가? */
    ns = current_user_ns();
    if (ns_capable(ns, CAP_FOWNER) &&
        kuid_has_mapping(ns, vfsuid_into_kuid(vfsuid)))
        return true;

    return false;
}

/* fs/attr.c — 새 파일 크기 유효성 검사 */
int inode_newsize_ok(const struct inode *inode, loff_t offset)
{
    /* 1. 파일 크기 제한 (rlimit) */
    if (offset > rlimit(RLIMIT_FSIZE))
        return -EFBIG;

    /* 2. 파일시스템 최대 파일 크기 */
    if (offset > inode->i_sb->s_maxbytes)
        return -EFBIG;

    return 0;
}

DIO (Direct I/O) 동기화 헬퍼

Direct I/O와 버퍼드 I/O 간의 경합을 방지하기 위한 카운터 기반 동기화 API입니다.

/* include/linux/fs.h — DIO 동기화 */

static inline void inode_dio_begin(struct inode *inode)
{
    atomic_inc(&inode->i_dio_count);
}

static inline void inode_dio_end(struct inode *inode)
{
    if (atomic_dec_and_test(&inode->i_dio_count))
        wake_up_bit(&inode->i_state, __I_DIO_WAKEUP);
}

/* fs/inode.c — 모든 진행 중 DIO 완료 대기 */
void inode_dio_wait(struct inode *inode)
{
    if (atomic_read(&inode->i_dio_count))
        __inode_dio_wait(inode);
}

/* 전형적 사용: truncate 전에 진행 중 DIO 완료 대기 */
static int myfs_setattr(struct mnt_idmap *idmap,
                        struct dentry *dentry, struct iattr *attr)
{
    struct inode *inode = d_inode(dentry);
    if (attr->ia_valid & ATTR_SIZE) {
        inode_dio_wait(inode);      /* DIO 완료까지 대기 */
        truncate_setsize(inode, attr->ia_size);
    }
    /* ... */
}

VFS 잠금 래퍼

inode->i_rwsem을 직접 조작하는 대신 VFS 래퍼를 사용하면 lockdep 클래스가 올바르게 적용됩니다.

/* include/linux/fs.h — 잠금 래퍼 */
static inline void inode_lock(struct inode *inode)
{
    down_write(&inode->i_rwsem);
}

static inline void inode_unlock(struct inode *inode)
{
    up_write(&inode->i_rwsem);
}

static inline void inode_lock_shared(struct inode *inode)
{
    down_read(&inode->i_rwsem);
}

static inline int inode_trylock(struct inode *inode)
{
    return down_write_trylock(&inode->i_rwsem);
}

static inline void inode_lock_nested(struct inode *inode,
                                     unsigned subclass)
{
    down_write_nested(&inode->i_rwsem, subclass);
}

/* Lockdep 잠금 클래스 상수 */
enum inode_i_mutex_lock_class {
    I_MUTEX_NORMAL,       /* 단일 inode 잠금 */
    I_MUTEX_PARENT,       /* 부모 디렉터리 (create, unlink) */
    I_MUTEX_PARENT2,      /* rename 시 두 번째 부모 */
    I_MUTEX_CHILD,        /* 자식 inode */
    I_MUTEX_XATTR,        /* xattr 연산 중 */
    I_MUTEX_NONDIR2,      /* rename 시 비디렉터리 타겟 */
};

기타 유틸리티

inode 번호 할당 전략

파일시스템마다 inode 번호를 할당하는 전략이 다릅니다. 이 전략은 파일 생성 성능, inode 고갈 가능성, 32비트/64비트 호환성에 직접적인 영향을 미칩니다.

/* ext4 inode 할당: Orlov 알고리즘 */
/* 디렉터리를 여러 블록 그룹에 분산하여 부모-자식 근접성 유지 */

static int find_group_orlov(struct super_block *sb,
                           struct inode *parent, ...)
{
    /* 최상위 디렉터리: 가장 여유 있는 그룹 선택 */
    if (parent == d_inode(sb->s_root)) {
        /* free inode 수, free block 수, 디렉터리 수 기준 */
        best_group = find_best_group(sb, ...);
    }
    /* 하위 디렉터리: 부모와 같은 그룹 선호 */
    else {
        group = ext4_inode_to_goal_block(parent);
        /* 부모 근처에서 시작하여 빈 슬롯 탐색 */
    }
}

/* XFS inode 할당: finobt (free inode B+tree) */
/* 각 AG에 free inode를 추적하는 B+tree 유지 */
/* → O(log n)에 빈 inode 슬롯 탐색 가능 */

/* tmpfs / procfs 등 pseudo-FS */
unsigned int get_next_ino(void)
{
    unsigned int *p = &get_cpu_var(last_ino);
    unsigned int res = *p;
    /* percpu 카운터로 락-프리 할당 */
    *p = ++res;
    put_cpu_var(last_ino);
    return res;
}

inode Generation 번호 (i_generation)

i_generation 필드는 inode 번호가 재사용될 때 같은 번호의 서로 다른 파일을 구별하기 위한 세대 번호입니다. NFS 파일 핸들의 핵심 구성 요소이며, inode가 삭제되고 같은 번호로 새 파일이 생성되었을 때 오래된 핸들로 접근하는 것을 방지합니다.

/* include/linux/fs.h */
struct inode {
    /* ... */
    __u32  i_generation;  /* 세대 번호 — inode 재사용 시 증가 */
    /* ... */
};

/* NFS 파일 핸들 구조 (개념적) */
struct nfs_fh {
    __u64  ino;         /* inode 번호 */
    __u32  generation;  /* i_generation — "stale" 검출 핵심 */
    __u32  fsid;        /* 파일시스템 ID */
};

/* ext4 — inode 할당 시 generation 설정 */
/* fs/ext4/ialloc.c — __ext4_new_inode() */
inode->i_generation = get_random_u32();
/* 또는 이전 값 + 1 (커널 버전에 따라 다름) */

/* NFS 서버 — export 시 파일 핸들 구성 */
/* fs/exportfs/expfs.c */
static int export_encode_fh(struct inode *inode, ...)
{
    fh[0] = inode->i_ino;
    fh[1] = inode->i_generation;  /* 핵심: 세대 번호 포함 */
    /* ... */
}

/* NFS 클라이언트가 오래된 핸들로 접근 시 */
/* → 서버가 ino로 inode 검색 후 generation 비교 */
/* → 불일치 → -ESTALE 반환 */

# generation 번호 확인 (ext4)
debugfs -R "stat <inode_number>" /dev/sda1
# ... Generation: 1234567890 ...

# NFS 파일 핸들 정보 확인
nfs4_getfacl /mnt/nfs/file
# filehandle에 generation이 포함됨

# ESTALE 오류 재현
# 서버: rm /export/file && touch /export/file
# 클라이언트: cat /mnt/nfs/file → Stale file handle

inode 보안: LSM 연동

Linux Security Module(LSM) 프레임워크는 inode 수준에서 세밀한 보안 정책을 적용합니다. inode에 보안 레이블(security label)을 부착하고, 모든 접근 시 MAC(Mandatory Access Control) 검사를 수행합니다.

/* inode 내 보안 관련 필드 */
struct inode {
    /* ... */
    void  *i_security;  /* LSM별 보안 데이터 (SELinux: inode_security_struct) */
    /* ... */
};

/* LSM 훅 호출 순서 (inode 생성 시) */
/* 1. security_inode_alloc()    — 보안 구조체 할당 */
/* 2. security_inode_init_security() — 보안 레이블 초기화 */
/* 3. security_inode_post_create()  — 생성 후 처리 */

/* LSM 훅 호출 순서 (inode 접근 시) */
/* inode_permission()에서: */
/* 1. DAC 검사 (전통적 권한 + ACL) */
/* 2. security_inode_permission() ← LSM 훅 */
/*    → SELinux: selinux_inode_permission() */
/*    → AppArmor: apparmor_inode_permission() */

/* SELinux 보안 컨텍스트 확인 */
/* ls -Z /home/user/test.txt */
/* -rw-r--r--. user group unconfined_u:object_r:user_home_t:s0 test.txt */

Idmapped Mounts와 inode

커널 5.12에서 도입된 idmapped mounts는 마운트 지점마다 UID/GID 매핑을 다르게 적용합니다. inode의 i_uid/i_gid를 변경하지 않고, VFS 계층에서 매핑을 적용하여 컨테이너 환경에서의 파일 소유권 문제를 해결합니다.

/* inode_operations 콜백의 mnt_idmap 파라미터 */
int (*create)(struct mnt_idmap *idmap,
             struct inode *dir, struct dentry *dentry,
             umode_t mode, bool excl);

/* UID 매핑 적용 예시 (VFS 내부) */
static inline vfsuid_t i_uid_into_vfsuid(
    struct mnt_idmap *idmap,
    const struct inode *inode)
{
    /* inode의 실제 uid를 mnt_idmap으로 매핑 */
    return make_vfsuid(idmap, i_user_ns(inode), inode->i_uid);
}

/* 파일 생성 시: vfsuid를 inode uid로 역매핑 */
void inode_init_owner(struct mnt_idmap *idmap,
                      struct inode *inode,
                      const struct inode *dir,
                      umode_t mode)
{
    /* 프로세스의 fsuid를 idmap 역변환하여 inode에 저장 */
    vfsuid_t vfsuid = mapped_fsuid(idmap, i_user_ns(dir));
    inode->i_uid = vfsuid_into_kuid(vfsuid);
}

# idmapped mount 설정 (mount_setattr)
# util-linux 2.39+ 또는 mount-idmapped 도구 사용

# 예: 호스트 uid 1000을 컨테이너 uid 0으로 매핑
mount-idmapped --map-mount b:0:1000:1 \
    /host/share /container/rootfs/share

# systemd-nspawn에서 자동 idmapped mount
systemd-nspawn --bind=/host/share:/share \
    --private-users=pick \
    --private-users-ownership=map

# 커널 지원 확인
# CONFIG_IDMAP_MOUNTS=y (5.12+)

특수 inode와 의사 파일시스템

리눅스 커널에는 디스크에 저장되지 않는 특수 inode들이 존재합니다. 파이프, 소켓, 익명 inode, procfs/sysfs의 가상 파일들은 모두 메모리 전용 inode로 관리됩니다.

의사 파일시스템의 inode

/* new_inode_pseudo() — 의사 FS용 inode 할당 */
/* 일반 new_inode()와의 차이: sb의 inode 리스트에 추가하지 않음 */
struct inode *new_inode_pseudo(struct super_block *sb)
{
    struct inode *inode = alloc_inode(sb);
    if (inode) {
        spin_lock(&inode->i_lock);
        inode->i_state = 0;
        spin_unlock(&inode->i_lock);
        /* sb->s_inodes 리스트에 추가하지 않음! */
        /* → umount 시 s_inodes 순회에서 제외 */
    }
    return inode;
}

/* 익명 inode — 단일 공유 inode로 여러 fd 생성 */
/* epoll_create → anon_inode_getfd("[eventpoll]") */
/* timerfd_create → anon_inode_getfd("[timerfd]") */
/* eventfd → anon_inode_getfd("[eventfd]") */
/* userfaultfd → anon_inode_getfd("[userfaultfd]") */

int anon_inode_getfd(const char *name,
                    const struct file_operations *fops,
                    void *priv, int flags)
{
    /* 전역 anon_inode_inode를 공유 사용 */
    /* 새 struct file만 생성하여 fd에 할당 */
    struct file *file;
    int fd;

    fd = get_unused_fd_flags(flags);
    file = anon_inode_getfile(name, fops, priv, flags);
    fd_install(fd, file);
    return fd;
}

/* /proc/PID/fd에서 확인 */
/* $ ls -la /proc/self/fd/3 */
/* lrwx------ 1 user user 64 ... 3 -> anon_inode:[eventpoll] */

파이프와 소켓의 inode

/* 파이프 inode — fs/pipe.c */
struct inode {
    /* ... */
    union {
        struct pipe_inode_info *i_pipe;  /* 파이프일 때 */
        struct cdev  *i_cdev;            /* 캐릭터 디바이스일 때 */
        char         *i_link;             /* 심볼릭 링크 타겟 */
        unsigned      i_dir_seq;          /* 디렉터리일 때 */
    };
};

/* pipe(2) → create_pipe_files() */
/* 1. pipefs에서 new_inode_pseudo() */
/* 2. i_pipe = alloc_pipe_info() */
/* 3. inode->i_fop = &pipefifo_fops */
/* 4. 두 개의 struct file 생성 (읽기/쓰기) */

/* 소켓 inode — net/socket.c */
struct socket_alloc {
    struct socket socket;     /* 소켓 구조체 */
    struct inode vfs_inode;   /* VFS inode (임베드) */
};

/* socket(2) → sock_alloc() */
/* sockfs의 new_inode_pseudo()로 할당 */
/* container_of로 inode ↔ socket 상호 변환 */
static inline struct socket *SOCKET_I(struct inode *inode)
{
    return &container_of(inode, struct socket_alloc,
                         vfs_inode)->socket;
}

예약된 inode 번호

대부분의 파일시스템은 특별한 용도의 예약 inode 번호를 가지고 있습니다.

# 루트 디렉터리의 inode 번호 확인
stat -c '%i' /
# ext4: 2 (항상)

# ext4 저널 inode 확인
debugfs -R "stat <8>" /dev/sda1
# Type: regular    Mode: 0600
# Size: 134217728   (128MB 저널)

# 예약된 inode 수 확인
tune2fs -l /dev/sda1 | grep "First inode"
# First inode:              11
# → inode 1~10은 예약됨

# lost+found 디렉터리 inode (ext4)
stat -c '%i' /lost+found
# 일반적으로 11 (첫 비예약 inode)

inode 디버깅과 추적

inode 관련 문제를 진단할 때 사용할 수 있는 도구와 기법을 정리합니다. 커널 트레이싱, proc/sysfs 인터페이스, 사용자 공간(User Space) 유틸리티를 활용하여 inode 동작을 실시간(Real-time)으로 관찰할 수 있습니다.

proc/sysfs를 통한 inode 모니터링

# ===== 시스템 전체 inode 상태 =====

# 할당된 inode 수 (nr_inodes, nr_free_inodes)
cat /proc/sys/fs/inode-nr
# 출력: 56789  1234
# 의미: 총 56789개 할당, 1234개 미사용(LRU 캐시)

# inode 상태 상세
cat /proc/sys/fs/inode-state
# nr_inodes  nr_free_inodes  preshrink  unused

# 파일시스템별 inode 사용량
df -i
# Filesystem      Inodes  IUsed   IFree IUse% Mounted on
# /dev/sda1     6553600 234567 6319033    4% /
# tmpfs          505872      5  505867    1% /dev/shm

# slab 캐시에서 inode 메모리 사용량 확인
slabtop -o -s c | head -20
# 또는 특정 캐시만
grep -E 'inode_cache|ext4_inode_cache|xfs_inode' /proc/slabinfo
# ext4_inode_cache  12345 12500 1096  29    8 : tunables ... 
# 의미: 12345개 활성 객체, 각 1096바이트

# 특정 파일의 inode 상세 정보
stat /home/user/test.txt
# File: test.txt
# Size: 4096       Blocks: 8          IO Block: 4096   regular file
# Device: 801h/2049d     Inode: 1234567     Links: 1
# Access: (0644/-rw-r--r--)  Uid: (1000/user)   Gid: (1000/user)
# Access: 2024-01-15 10:30:00.000000000 +0900
# Modify: 2024-01-15 10:30:00.000000000 +0900
# Change: 2024-01-15 10:30:00.000000000 +0900
# Birth:  2024-01-15 10:30:00.000000000 +0900

# statx로 확장 정보 (크기, 블록, 마운트 ID, DAX 상태 등)
python3 -c "
import os
r = os.stat('/home/user/test.txt')
print(f'inode: {r.st_ino}')
print(f'nlink: {r.st_nlink}')
print(f'size:  {r.st_size}')
print(f'blocks: {r.st_blocks}')
print(f'uid: {r.st_uid}, gid: {r.st_gid}')
print(f'mode: {oct(r.st_mode)}')
"

ftrace/perf를 통한 inode 추적

# ===== ftrace로 inode 관련 함수 추적 =====

# inode 할당/해제 추적
echo 1 > /sys/kernel/debug/tracing/events/writeback/writeback_dirty_inode/enable
echo 1 > /sys/kernel/debug/tracing/events/writeback/writeback_written/enable
cat /sys/kernel/debug/tracing/trace_pipe

# 특정 시스템콜의 inode 경로 추적
perf trace -e 'open*,close,stat*,unlink' ls /tmp/
# 출력: 각 시스템콜의 인자와 반환값

# inode evict 추적 (메모리 압력 진단)
echo 1 > /sys/kernel/debug/tracing/events/writeback/writeback_lazytime_iput/enable

# ===== BPF/bpftrace로 세밀한 추적 =====

# inode 할당 빈도 측정
bpftrace -e 'kprobe:new_inode { @[comm] = count(); }'

# inode evict 추적
bpftrace -e '
kprobe:evict {
    $inode = (struct inode *)arg0;
    printf("evict: ino=%lu, nlink=%u, i_count=%d\n",
           $inode->i_ino, $inode->i_nlink,
           $inode->i_count.counter);
}'

# iput() 호출 스택 추적 (누가 참조를 해제하는지)
bpftrace -e '
kprobe:iput {
    $inode = (struct inode *)arg0;
    if ($inode->i_count.counter == 1) {
        printf("last iput: ino=%lu\n", $inode->i_ino);
        print(kstack);
    }
}'

# writeback dirty inode 추적
bpftrace -e '
kprobe:__mark_inode_dirty {
    $inode = (struct inode *)arg0;
    $flags = arg1;
    printf("dirty: ino=%lu flags=0x%x comm=%s\n",
           $inode->i_ino, $flags, comm);
}'

파일시스템별 디버깅 도구

# ===== ext4 디버깅 실전 예시 =====

# 1. 삭제된 파일이 디스크를 점유하는 문제 진단
# 삭제되었지만 열린 fd가 있어 디스크 해제가 안 됨
lsof +L1
# COMMAND   PID USER   FD   TYPE DEVICE SIZE/OFF NLINK NODE NAME
# java    12345 app   23u   REG   8,1  2147483648  0  987654 /var/log/app.log (deleted)
# → PID 12345의 fd 23이 삭제된 2GB 파일을 잡고 있음

# 해결: 프로세스 재시작 또는 fd truncate
: > /proc/12345/fd/23  # 파일 크기를 0으로 (재시작 불가 시)

# 2. inode 고갈 진단
df -i /
# IUse% 가 100%이면 inode 고갈
# 소파일이 많은 디렉터리 찾기:
find / -xdev -printf '%h\n' | sort | uniq -c | sort -rn | head -20

# 3. ext4 inode extent 상태 확인
debugfs -R "dump_extents <42>" /dev/sda1
# Level Entries  Logical      Physical Length Flags
#  0/ 0   1/  4    0 -  1023  1234 -  2257   1024

# 4. 삭제된 파일 복구 시도 (ext4)
debugfs /dev/sda1
# debugfs: lsdel
# Inode  Owner  Mode    Size      Blocks   Time deleted
# 987654  1000  100644  4096      8/8      Sat Jan 15 10:30:00 2024
# debugfs: dump <987654> /tmp/recovered_file

inode와 네트워크 파일시스템

NFS, CIFS/SMB 등 네트워크 파일시스템에서 inode는 로컬 파일시스템과 다른 특수한 도전 과제를 가집니다. 서버와 클라이언트 간의 일관성 유지가 핵심입니다.

NFS inode 특성

/* NFS inode 확장 구조체 */
struct nfs_inode {
    struct inode     vfs_inode;

    /* NFS 파일 핸들 — 서버에서 inode를 식별하는 불투명 토큰 */
    struct nfs_fh    fh;

    /* 변경 속성 — 서버 inode가 변경되면 증가 */
    u64              change_attr;

    /* 속성 캐시 타임아웃 */
    unsigned long    attrtimeo;       /* 현재 유효 기간 */
    unsigned long    attrtimeo_timestamp;
    unsigned long    attr_gencount;

    /* delegation — 서버가 클라이언트에 부여한 권한 */
    struct nfs_delegation *delegation;

    /* 캐시 유효성 카운터 */
    unsigned long    cache_validity;  /* NFS_INO_INVALID_* */
};

/* NFS inode 재검증 플래그 */
#define NFS_INO_INVALID_DATA    (1 << 1)  /* 데이터 캐시 무효 */
#define NFS_INO_INVALID_ATIME   (1 << 2)  /* atime 무효 */
#define NFS_INO_INVALID_ACCESS  (1 << 3)  /* 접근 권한 캐시 무효 */
#define NFS_INO_INVALID_ACL     (1 << 4)  /* ACL 캐시 무효 */
#define NFS_INO_INVALID_SIZE    (1 << 6)  /* 파일 크기 무효 */
#define NFS_INO_INVALID_CHANGE  (1 << 10) /* change attr 무효 */

/* 속성 캐시 마운트 옵션 */
/* mount -t nfs -o acregmin=3,acregmax=60,acdirmin=30,acdirmax=60 */
/* acregmin: 일반 파일 속성 캐시 최소 유효 기간 (초) */
/* acregmax: 일반 파일 속성 캐시 최대 유효 기간 (초) */
/* acdirmin/max: 디렉터리 속성 캐시 유효 기간 */

inode 관련 sysctl 튜닝 종합

inode 캐시와 관련된 sysctl 파라미터를 종합적으로 정리합니다. 워크로드에 따른 최적 설정값은 다를 수 있으므로, 벤치마크와 모니터링을 통해 결정해야 합니다.

# ===== inode 관련 sysctl 설정 예시 =====

# 파일 서버 프로파일
# /etc/sysctl.d/99-fileserver.conf
vm.vfs_cache_pressure = 50
vm.dirty_background_ratio = 5
vm.dirty_ratio = 40
vm.dirty_expire_centisecs = 3000
fs.inotify.max_user_watches = 524288
fs.file-max = 2097152

# DB 서버 프로파일
# /etc/sysctl.d/99-database.conf
vm.vfs_cache_pressure = 150
vm.dirty_background_ratio = 5
vm.dirty_ratio = 10
vm.dirty_writeback_centisecs = 100
vm.dirty_expire_centisecs = 1000

# 적용
sysctl -p /etc/sysctl.d/99-fileserver.conf

# 현재 dirty 상태 모니터링
watch -n 1 'grep -E "Dirty|Writeback|NFS" /proc/meminfo'
# Dirty:              12345 kB
# Writeback:            567 kB
# NFS_Unstable:           0 kB

# inode 캐시 수동 해제 (비상 시만)
echo 2 > /proc/sys/vm/drop_caches  # dentry + inode 캐시 해제
# 주의: 프로덕션에서는 성능 저하 유발

statx 시스템콜과 확장 inode 정보

statx(2)는 기존 stat(2)의 한계를 극복하기 위해 커널 4.11에서 도입된 확장 stat 시스템콜입니다. 생성 시간(birth time), 마운트 ID, DAX 상태 등 기존 stat으로 얻을 수 없었던 inode 정보를 제공합니다.

/* include/uapi/linux/stat.h — statx 구조체 */
struct statx {
    __u32  stx_mask;        /* 유효한 필드 마스크 */
    __u32  stx_blksize;     /* I/O 블록 크기 */
    __u64  stx_attributes;  /* 파일 속성 플래그 */
    __u32  stx_nlink;       /* 하드 링크 수 */
    __u32  stx_uid;         /* 소유자 UID */
    __u32  stx_gid;         /* 소유자 GID */
    __u16  stx_mode;        /* 파일 유형 + 권한 */
    __u64  stx_ino;         /* inode 번호 */
    __u64  stx_size;        /* 파일 크기 */
    __u64  stx_blocks;      /* 512B 블록 수 */
    __u64  stx_attributes_mask;

    /* 타임스탬프 (나노초 정밀도) */
    struct statx_timestamp  stx_atime;
    struct statx_timestamp  stx_btime;  /* 생성 시간! */
    struct statx_timestamp  stx_ctime;
    struct statx_timestamp  stx_mtime;

    /* 디바이스 정보 */
    __u32  stx_rdev_major;
    __u32  stx_rdev_minor;
    __u32  stx_dev_major;
    __u32  stx_dev_minor;

    __u64  stx_mnt_id;      /* 마운트 ID (5.8+) */
    __u32  stx_dio_mem_align;  /* DIO 메모리 정렬 (6.1+) */
    __u32  stx_dio_offset_align; /* DIO 오프셋 정렬 */
};

/* stx_attributes 플래그 */
#define STATX_ATTR_COMPRESSED   0x00000004  /* 압축됨 */
#define STATX_ATTR_IMMUTABLE    0x00000010  /* 변경 불가 */
#define STATX_ATTR_APPEND       0x00000020  /* 추가만 가능 */
#define STATX_ATTR_NODUMP       0x00000040  /* dump 제외 */
#define STATX_ATTR_ENCRYPTED    0x00000800  /* 암호화됨 */
#define STATX_ATTR_VERITY       0x00100000  /* fs-verity */
#define STATX_ATTR_DAX          0x00200000  /* DAX 모드 */

/* 사용 예시 */
struct statx stx;
statx(AT_FDCWD, "/home/user/test.txt",
      AT_STATX_SYNC_AS_STAT, STATX_ALL, &stx);

if (stx.stx_mask & STATX_BTIME)
    printf("Birth: %lld.%09u\n",
           stx.stx_btime.tv_sec, stx.stx_btime.tv_nsec);

stat vs statx 비교

inode 관련 성능 패턴과 안티패턴

실무에서 자주 마주치는 inode 관련 성능 문제와 해결 패턴을 정리합니다.

패턴/안티패턴 요약

# ===== 성능 문제 진단 원라이너 모음 =====

# 1. 삭제되었지만 열린 파일 (디스크 점유) 찾기
lsof +L1 | awk '{total += $7} END {printf "Total: %.1f GB\n", total/1024/1024/1024}'

# 2. inode 사용률이 높은 파일시스템 찾기
df -i | awk '$5+0 > 80 {print "WARNING:", $0}'

# 3. 디렉터리별 파일 수 상위 20개
find / -xdev -type d -exec sh -c 'echo "$(ls -1 "{}" 2>/dev/null | wc -l) {}"' \; 2>/dev/null | sort -rn | head -20

# 4. inode 캐시 메모리 사용량 (MB)
grep inode_cache /proc/slabinfo | awk '{printf "%.1f MB (%d objects)\n", $3*$4/1024/1024, $2}'

# 5. dirty inode writeback 지연 확인
cat /proc/meminfo | grep -E "Dirty|Writeback"

# 6. 파일 단편화 확인
filefrag -v /path/to/large/file
# extents 수가 많으면 단편화

# 7. 특정 프로세스의 열린 파일 수
ls -la /proc/$PID/fd | wc -l
# 또는 시스템 전체
cat /proc/sys/fs/file-nr
# 할당된 fd  미사용 fd  최대 fd

inode와 Direct I/O

Direct I/O(DIO)는 페이지 캐시를 우회하여 사용자 버퍼와 디스크 간에 직접 데이터를 전송합니다. 데이터베이스처럼 자체 캐시를 가진 애플리케이션에서 이중 캐싱을 피하기 위해 사용됩니다. inode 관점에서 DIO는 특수한 잠금과 일관성 요구사항을 가집니다.

/* Direct I/O와 inode의 상호작용 */

/* 1. DIO 읽기: i_rwsem을 공유(shared) 모드로 획득 */
/*    → 다른 DIO 읽기와 병렬 가능 */
/*    → 버퍼드 write/truncate와는 배타적 */

/* 2. DIO 쓰기: i_rwsem을 배타적(exclusive) 모드로 획득 */
/*    → 다른 모든 I/O와 직렬화 */
/*    (단, inode_dio_wait 패턴으로 최적화 가능) */

/* DIO와 페이지 캐시 일관성 */
ssize_t ext4_dio_write_iter(struct kiocb *iocb,
                           struct iov_iter *from)
{
    struct inode *inode = file_inode(iocb->ki_filp);

    /* i_rwsem 획득 */
    inode_lock(inode);

    /* 페이지 캐시의 dirty 데이터를 먼저 기록 */
    ret = filemap_write_and_wait_range(
        inode->i_mapping, offset, offset + count - 1);

    /* 해당 범위의 페이지 캐시를 무효화 */
    invalidate_inode_pages2_range(
        inode->i_mapping, offset >> PAGE_SHIFT,
        (offset + count - 1) >> PAGE_SHIFT);

    /* DIO 쓰기 진행 중임을 표시 */
    inode_dio_begin(inode);

    /* 실제 DIO 수행 */
    ret = iomap_dio_rw(iocb, from, &ext4_iomap_ops,
                        &ext4_dio_write_ops, ...);

    inode_dio_end(inode);
    inode_unlock(inode);
    return ret;
}

/* inode_dio_begin/end — DIO 진행 추적 */
static inline void inode_dio_begin(struct inode *inode)
{
    atomic_inc(&inode->i_dio_count);
}
static inline void inode_dio_end(struct inode *inode)
{
    if (atomic_dec_and_test(&inode->i_dio_count))
        wake_up_bit(&inode->i_state, __I_DIO_WAKEUP);
}

/* truncate 시 DIO 완료 대기 */
inode_dio_wait(inode);  /* i_dio_count가 0이 될 때까지 대기 */

DIO 정렬 요구사항

# DIO 정렬 요구사항 확인 (커널 6.1+)
python3 -c "
import os, struct
# statx 시스템콜로 DIO 정렬 확인
# stx_dio_mem_align, stx_dio_offset_align 필드 확인
r = os.stat('/home/user/test.txt')
print(f'Block size: {r.st_blksize}')
"

# O_DIRECT로 파일 열기 (사용자 공간)
# dd if=/dev/zero of=test.dat bs=4k count=100 oflag=direct

# xfs_io로 DIO 테스트
xfs_io -d -c "pread 0 4096" /path/to/file  # -d: O_DIRECT

# fio로 DIO 성능 벤치마크
fio --name=dio_test --filename=/path/to/file \
    --rw=randread --bs=4k --direct=1 \
    --numjobs=4 --iodepth=32 --runtime=30

inode와 DAX (Direct Access)

DAX(Direct Access)는 영구 메모리(Persistent Memory, PMEM)에서 페이지 캐시를 완전히 우회하여 사용자 공간에서 스토리지에 직접 load/store 명령으로 접근하는 기술입니다. inode의 S_DAX 플래그가 DAX 모드를 표시하며, address_space의 동작이 근본적으로 달라집니다.

/* DAX 관련 inode 플래그 */
#define S_DAX  (1 << 13)   /* DAX 모드 활성화 */
#define IS_DAX(inode)  ((inode)->i_flags & S_DAX)

/* DAX 모드에서의 read/write — 페이지 캐시 없음! */
/* 1. read: dax_iomap_rw() → 직접 memcpy from PMEM */
/* 2. write: dax_iomap_rw() → 직접 memcpy to PMEM */
/* 3. mmap: dax_iomap_fault() → PMEM 물리 주소를 PTE에 직접 매핑 */

/* ext4 DAX address_space_operations */
static const struct address_space_operations ext4_dax_aops = {
    .writepages      = ext4_dax_writepages,
    .direct_IO       = noop_direct_IO,  /* DIO 경로 미사용 */
    .dirty_folio     = noop_dirty_folio,
};

/* DAX mmap — 페이지 폴트 시 PMEM 직접 매핑 */
static vm_fault_t ext4_dax_huge_fault(struct vm_fault *vmf,
                                      unsigned int order)
{
    /* PMEM의 물리 주소를 PTE에 직접 매핑 */
    /* → 사용자 공간에서 load/store로 직접 접근 */
    /* → memcpy 오버헤드 제거 */
    return dax_iomap_fault(vmf, order, NULL, NULL,
                           &ext4_iomap_ops);
}

# DAX 설정
# 1. PMEM 장치 확인
ndctl list -N
# 2. fsdax 모드로 namespace 설정
ndctl create-namespace -m fsdax -e namespace0.0
# 3. 파일시스템 생성 + 마운트
mkfs.ext4 /dev/pmem0
mount -o dax=always /dev/pmem0 /mnt/pmem

# 파일별 DAX 설정 (커널 5.8+, per-file DAX)
xfs_io -c "chattr +x" /mnt/pmem/file   # DAX 활성화
xfs_io -c "chattr -x" /mnt/pmem/file   # DAX 비활성화

# DAX 상태 확인
statx /mnt/pmem/file | grep -i dax
# STATX_ATTR_DAX: set

# 마운트 옵션
# dax=always  — 모든 파일에 DAX 강제
# dax=never   — DAX 비활성화
# dax=inode   — 파일별 FS_XFLAG_DAX 기반 (기본)

inode와 디스크 쿼타

디스크 쿼타는 사용자/그룹/프로젝트별로 inode 수와 블록 사용량을 제한합니다. inode 생성·삭제 시 VFS가 쿼타 검사를 수행하며, 한도 초과 시 -EDQUOT를 반환합니다.

/* include/linux/quota.h — 쿼타 정보 구조 */
struct dquot {
    struct super_block  *dq_sb;
    kqid_t              dq_id;     /* uid/gid/projid */
    struct mem_dqblk    dq_dqb;    /* 사용량 + 한도 */
};

struct mem_dqblk {
    qsize_t  dqb_bhardlimit;  /* 블록 하드 리밋 */
    qsize_t  dqb_bsoftlimit;  /* 블록 소프트 리밋 */
    qsize_t  dqb_curspace;    /* 현재 사용 블록 */
    qsize_t  dqb_ihardlimit;  /* inode 하드 리밋 */
    qsize_t  dqb_isoftlimit;  /* inode 소프트 리밋 */
    qsize_t  dqb_curinodes;   /* 현재 사용 inode 수 */
    struct timespec64 dqb_btime; /* 블록 소프트 리밋 유예 기한 */
    struct timespec64 dqb_itime; /* inode 소프트 리밋 유예 기한 */
};

/* inode 생성 시 쿼타 검사 흐름 */
/* 1. dquot_initialize(dir)    — 부모 디렉터리 쿼타 초기화 */
/* 2. dquot_alloc_inode(inode)  — inode 쿼타 할당 (카운트++) */
/*    → dqb_curinodes++ */
/*    → dqb_ihardlimit 초과 시 -EDQUOT 반환 */
/* 3. dquot_alloc_block(inode, count) — 블록 쿼타 할당 */

/* inode 삭제 시 쿼타 반환 */
/* evict_inode() → dquot_free_inode(inode) */
/*               → dqb_curinodes-- */

# 쿼타 설정 (ext4)
# 1. 마운트 옵션에 쿼타 활성화
mount -o usrquota,grpquota /dev/sda1 /home

# 2. 쿼타 파일 생성 + 초기화
quotacheck -cug /home
quotaon /home

# 3. 사용자 쿼타 설정 (블록 소프트/하드, inode 소프트/하드)
setquota -u user1 100M 120M 10000 12000 /home
# → inode 최대 12,000개, 블록 최대 120MB

# 쿼타 확인
repquota -as /home
# 또는
quota -u user1

# XFS 프로젝트 쿼타 (디렉터리 단위)
echo "1:/home/project_a" >> /etc/projects
echo "project_a:1" >> /etc/projid
xfs_quota -x -c "project -s project_a" /home
xfs_quota -x -c "limit -p bhard=10G 1" /home

파일시스템 드라이버의 inode 구현 체크리스트

새로운 파일시스템 드라이버를 작성할 때 inode 관련 필수 구현 항목을 체크리스트로 정리합니다.

필수 구현 항목

/* 최소 파일시스템의 inode 구현 뼈대 */

/* 1. FS-specific inode 정의 */
struct myfs_inode_info {
    __u32   i_disk_flags;
    __u64   i_disk_size;
    sector_t i_first_block;
    struct inode vfs_inode;  /* 반드시 임베드 */
};

static inline struct myfs_inode_info *MYFS_I(struct inode *i)
{
    return container_of(i, struct myfs_inode_info, vfs_inode);
}

/* 2. slab 캐시 */
static struct kmem_cache *myfs_inode_cachep;

static int __init myfs_init_inodecache(void)
{
    myfs_inode_cachep = kmem_cache_create(
        "myfs_inode_cache",
        sizeof(struct myfs_inode_info),
        0,
        SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT,
        NULL);
    return myfs_inode_cachep ? 0 : -ENOMEM;
}

/* 3-4. alloc/free_inode */
static struct inode *myfs_alloc_inode(struct super_block *sb)
{
    struct myfs_inode_info *mi;
    mi = alloc_inode_sb(sb, myfs_inode_cachep, GFP_KERNEL);
    if (!mi)
        return NULL;
    mi->i_disk_flags = 0;
    mi->i_disk_size  = 0;
    mi->i_first_block = 0;
    return &mi->vfs_inode;
}

static void myfs_free_inode(struct inode *inode)
{
    kmem_cache_free(myfs_inode_cachep, MYFS_I(inode));
}

/* 5. write_inode */
static int myfs_write_inode(struct inode *inode,
                           struct writeback_control *wbc)
{
    struct myfs_inode_info *mi = MYFS_I(inode);
    struct buffer_head *bh;

    /* 디스크의 inode 블록을 읽어서 */
    bh = sb_bread(inode->i_sb, myfs_inode_block(inode));
    /* VFS inode 필드를 디스크 형식으로 변환하여 기록 */
    myfs_fill_disk_inode(bh->b_data, inode, mi);
    mark_buffer_dirty(bh);
    if (wbc->sync_mode == WB_SYNC_ALL)
        sync_dirty_buffer(bh);
    brelse(bh);
    return 0;
}

/* 6. evict_inode */
static void myfs_evict_inode(struct inode *inode)
{
    truncate_inode_pages_final(&inode->i_data);
    if (!inode->i_nlink) {
        /* 실제 삭제: 디스크의 inode와 데이터 블록 해제 */
        myfs_free_disk_inode(inode);
        myfs_free_data_blocks(inode);
    }
    clear_inode(inode);
}

/* 7. super_operations 등록 */
static const struct super_operations myfs_sops = {
    .alloc_inode  = myfs_alloc_inode,
    .free_inode   = myfs_free_inode,
    .write_inode  = myfs_write_inode,
    .evict_inode  = myfs_evict_inode,
    .statfs       = simple_statfs,
    .drop_inode   = generic_delete_inode,
};

자주 발생하는 실수

소스 참조 및 더 읽기

inode 구현과 관련된 커널 소스 파일과 외부 참고 자료를 정리합니다.

커널 소스 파일