IPC (Inter-Process Communication)

Linux 커널의 전통적 프로세스(Process) 간 통신(IPC)을 데이터 전달, 동기화 관점으로 체계화해 설명합니다. Pipe/FIFO 데이터 경로, 시그널(Signal) 처리, System V와 POSIX IPC의 자원 관리 모델, futex 기반 사용자 동기화, IPC 모범 사례와 디버깅(Debugging) 절차까지 심층 분석합니다.

IPC 개요와 분류

Linux 커널은 프로세스 간 데이터 교환, 동기화, 이벤트 통지를 위해 다양한 IPC 메커니즘을 제공합니다. 각 메커니즘은 서로 다른 사용 사례에 최적화되어 있으며, 커널 내부에서 별도의 서브시스템으로 구현됩니다.

IPC 메커니즘 분류

IPC Namespace

Linux 커널은 ipc_namespace를 통해 IPC 자원을 네임스페이스별로 격리합니다. System V IPC 객체(메시지 큐, 공유 메모리, 세마포어)는 모두 이 네임스페이스(Namespace)에 의해 격리되며, 컨테이너(Container) 환경에서 IPC 자원의 독립성을 보장합니다.

/* include/linux/ipc_namespace.h */
struct ipc_namespace {
    struct ipc_ids  ids[3];    /* IPC_SEM, IPC_MSG, IPC_SHM */

    int     sem_ctls[4];         /* SEMMSL, SEMMNS, SEMOPM, SEMMNI */
    int     msg_ctlmax;            /* MSGMAX */
    int     msg_ctlmnb;            /* MSGMNB */
    int     msg_ctlmni;            /* MSGMNI */
    size_t  shm_ctlmax;            /* SHMMAX */
    size_t  shm_ctlall;            /* SHMALL */
    int     shm_ctlmni;            /* SHMMNI */
    ...
};

/* IPC 식별자 관리 구조체 */
struct ipc_ids {
    int               in_use;        /* 사용 중인 IPC 객체 수 */
    unsigned short    seq;           /* 시퀀스 번호 */
    struct rw_semaphore rwsem;       /* 읽기/쓰기 세마포어 */
    struct idr        ipcs_idr;      /* IDR 기반 ID 관리 */
    int               max_idx;       /* 최대 인덱스 */
    ...
};

/* 모든 SysV IPC 객체의 공통 권한 구조체 */
struct kern_ipc_perm {
    spinlock_t  lock;
    int         id;                /* IPC 식별자 */
    key_t       key;               /* IPC 키 */
    kuid_t      uid, gid;          /* 소유자 */
    kuid_t      cuid, cgid;        /* 생성자 */
    umode_t     mode;              /* 접근 모드 */
    unsigned long seq;             /* 시퀀스 번호 */
    refcount_t  refcount;
    ...
};

Pipes & FIFOs

Pipe는 Linux에서 가장 기본적인 IPC 메커니즘으로, 두 개의 파일 디스크립터(읽기/쓰기)를 통해 단방향 바이트 스트림을 전달합니다. 커널 내부에서 pipe는 pipefs 가상 파일시스템(VFS) 위의 특수 inode로 구현됩니다.

Pipe 내부 구조

Pipe의 핵심 자료구조는 struct pipe_inode_info이며, 환형 버퍼(Buffer)로 구현됩니다. 기본 버퍼 크기는 16개 pipe_buffer 슬롯(총 64KB)이며, F_SETPIPE_SZ로 최대 1MB까지 조절 가능합니다.

/* include/linux/pipe_fs_i.h */
struct pipe_inode_info {
    struct mutex       mutex;        /* pipe 잠금 */
    wait_queue_head_t  rd_wait;      /* 읽기 대기 큐 */
    wait_queue_head_t  wr_wait;      /* 쓰기 대기 큐 */
    unsigned int       head;         /* 쓰기 위치 (생산자) */
    unsigned int       tail;         /* 읽기 위치 (소비자) */
    unsigned int       max_usage;    /* 최대 슬롯 수 */
    unsigned int       ring_size;    /* 할당된 링 크기 */
    unsigned int       readers;      /* 읽기 참조 카운트 */
    unsigned int       writers;      /* 쓰기 참조 카운트 */
    struct pipe_buffer *bufs;         /* pipe_buffer 배열 */
    ...
};

struct pipe_buffer {
    struct page     *page;          /* 데이터가 담긴 페이지 */
    unsigned int    offset;         /* 페이지 내 오프셋 */
    unsigned int    len;            /* 데이터 길이 */
    const struct pipe_buf_operations *ops;
    unsigned int    flags;
};

pipe2() 시스템 콜

pipe2()는 파이프를 생성하는 시스템 콜로, 커널 내부에서 do_pipe2()를 통해 처리됩니다. O_CLOEXEC과 O_NONBLOCK 플래그를 지원합니다.

/* fs/pipe.c - do_pipe2() 핵심 흐름 (간략화) */
static int do_pipe2(int __user *fildes, int flags)
{
    struct file *files[2];
    int fd[2];
    int error;

    /* 1. pipe inode + pipe_inode_info 할당 */
    error = __do_pipe_flags(fd, files, flags);
    if (!error) {
        /* 2. fd[0] = 읽기, fd[1] = 쓰기를 유저에 복사 */
        if (copy_to_user(fildes, fd, sizeof(fd))) {
            fput(files[0]);
            fput(files[1]);
            put_unused_fd(fd[0]);
            put_unused_fd(fd[1]);
            error = -EFAULT;
        } else {
            fd_install(fd[0], files[0]);
            fd_install(fd[1], files[1]);
        }
    }
    return error;
}

splice / tee / vmsplice

Linux는 파이프와 파일 사이에서 데이터를 복사 없이(zero-copy) 이동할 수 있는 시스템 콜을 제공합니다. 이들은 pipe_buffer의 페이지 참조를 직접 전달하여 불필요한 메모리 복사를 제거합니다.

Named Pipes (FIFO)

FIFO(Named Pipe)는 파일시스템(Filesystem)에 이름을 가지는 파이프로, mkfifo() 또는 mknod()로 생성합니다. 관계없는 프로세스 간에도 파이프 통신이 가능하며, 내부적으로는 anonymous pipe와 동일한 pipe_inode_info 구조를 사용합니다.

/* FIFO 생성과 사용 (유저 공간) */
mkfifo("/tmp/myfifo", 0666);

/* Writer 프로세스 */
int wfd = open("/tmp/myfifo", O_WRONLY);
write(wfd, buf, len);

/* Reader 프로세스 */
int rfd = open("/tmp/myfifo", O_RDONLY);
read(rfd, buf, len);

Signals

시그널은 프로세스에 비동기적으로 이벤트를 통지하는 가장 오래된 IPC 메커니즘입니다. 커널은 시그널 전달 시 대상 프로세스의 task_struct에 시그널 정보를 큐잉하고, 해당 프로세스가 유저 모드로 복귀할 때 시그널 핸들러(Handler)를 실행합니다.

표준 시그널 목록

리눅스는 31개의 표준 시그널(1~31)을 정의합니다. 각 시그널의 기본 동작(default action)은 다섯 가지 중 하나입니다:

시그널 생성 경로

시그널은 네 가지 소스에서 생성됩니다:

/* 하드웨어 예외에 의한 시그널 생성 (arch/x86/kernel/traps.c 기반) */
/* 예: 0으로 나누기 → #DE 예외 → do_divide_error() */
static void do_error_trap(struct pt_regs *regs, long error_code,
                          char *str, unsigned long trapnr, int signr)
{
    /* 유저 모드에서 발생한 경우 시그널 전송 */
    if (user_mode(regs)) {
        force_sig(signr);  /* SIGFPE, SIGSEGV 등 */
        return;
    }
    /* 커널 모드면 oops/panic */
    die(str, regs, error_code);
}

/* 유저 프로세스에 의한 시그널 생성 (kernel/signal.c) */
/* kill(pid, sig) → sys_kill() → kill_something_info() */
SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
{
    struct kernel_siginfo info;
    prepare_kill_siginfo(sig, &info);
    return kill_something_info(sig, &info, pid);
}

시그널 전달 내부 구조

/* kernel/signal.c - __send_signal() 핵심 (간략화) */
static int __send_signal(int sig, struct kernel_siginfo *info,
                         struct task_struct *t, enum pid_type type)
{
    struct sigpending *pending;
    struct sigqueue *q;

    /* 프로세스/스레드 pending 큐 선택 */
    pending = (type != PIDTYPE_PID) ?
              &t->signal->shared_pending : &t->pending;

    /* 이미 동일 시그널이 pending이면 (비RT) 무시 */
    if (legacy_queue(pending, sig))
        goto ret;

    /* sigqueue 구조체 할당 */
    q = __sigqueue_alloc(sig, t, GFP_ATOMIC, override_rlimit);
    if (q) {
        list_add_tail(&q->list, &pending->list);
        copy_siginfo(&q->info, info);
    }

    /* 시그널 비트마스크 설정 */
    sigaddset(&pending->signal, sig);

    /* TIF_SIGPENDING 플래그 설정 → 유저 복귀 시 확인 */
    complete_signal(sig, t, type);
ret:
    return 0;
}

시그널 핸들러 실행 메커니즘

시그널 핸들러 실행은 커널이 유저 스택을 직접 조작하는 정교한 과정입니다. 프로세스가 시스템 콜이나 인터럽트에서 유저 모드로 복귀하기 직전에 do_signal()이 호출되며, pending 시그널이 있으면 handle_signal()을 통해 핸들러 실행을 설정합니다.

/* arch/x86/kernel/signal.c - 핸들러 실행 설정 (간략화) */
static int setup_rt_frame(struct ksignal *ksig,
                           struct pt_regs *regs)
{
    struct rt_sigframe __user *frame;

    /* 유저 스택에 rt_sigframe 공간 확보 */
    frame = get_sigframe(ksig, regs, sizeof(*frame));

    /* 현재 레지스터 상태를 ucontext에 저장 */
    put_user_sigcontext(&frame->uc.uc_mcontext, regs);

    /* siginfo 복사 */
    copy_siginfo_to_user(&frame->info, &ksig->info);

    /* 시그널 마스크 저장 */
    __put_user(current->blocked, &frame->uc.uc_sigmask);

    /* sigreturn 트램폴린 설정 (VDSO 사용) */
    frame->pretcode = current->mm->context.vdso +
                      vdso_image_32.sym___kernel_rt_sigreturn;

    /* 레지스터 조작: 핸들러가 실행되도록 설정 */
    regs->ip = (unsigned long)ksig->ka.sa.sa_handler;
    regs->sp = (unsigned long)frame;
    regs->di = ksig->sig;            /* 첫 번째 인자: signo */
    regs->si = (unsigned long)&frame->info;   /* SA_SIGINFO: siginfo */
    regs->dx = (unsigned long)&frame->uc;     /* SA_SIGINFO: ucontext */

    return 0;
}

/* 핸들러 종료 후 트램폴린이 호출하는 시스템 콜 */
SYSCALL_DEFINE0(rt_sigreturn)
{
    struct pt_regs *regs = current_pt_regs();
    struct rt_sigframe __user *frame;

    frame = (struct rt_sigframe __user *)(regs->sp - sizeof(long));

    /* ucontext에서 레지스터와 시그널 마스크 복원 */
    restore_sigcontext(regs, &frame->uc.uc_mcontext);
    set_current_blocked(&frame->uc.uc_sigmask);

    return regs->ax;  /* 원래 시스템 콜 반환값 복원 */
}

sighand_struct

sighand_struct는 프로세스(스레드 그룹)가 공유하는 시그널 핸들러 테이블을 관리합니다. 64개 시그널 각각에 대한 k_sigaction을 저장합니다.

/* include/linux/sched/signal.h */
struct sighand_struct {
    refcount_t        count;         /* 참조 카운트 */
    struct k_sigaction action[_NSIG]; /* 64개 시그널 핸들러 */
    spinlock_t        siglock;       /* 시그널 처리 잠금 */
    wait_queue_head_t signalfd_wqh;  /* signalfd 대기 큐 */
};

struct k_sigaction {
    struct sigaction sa;
    /* sa.sa_handler: SIG_DFL, SIG_IGN, 또는 유저 핸들러 */
    /* sa.sa_flags: SA_RESTART, SA_SIGINFO, SA_NOCLDSTOP, ... */
    /* sa.sa_mask: 핸들러 실행 중 차단할 시그널 마스크 */
};

시그널 마스크

각 스레드(Thread)는 task_struct.blocked에 시그널 마스크(sigset_t)를 가지며, sigprocmask()로 제어합니다. 마스크된 시그널은 pending 상태로 유지되다가 마스크가 해제되면 전달됩니다. SIGKILL과 SIGSTOP은 마스크할 수 없습니다.

대체 시그널 스택 (sigaltstack)

시그널 핸들러는 기본적으로 현재 프로세스의 유저 스택에서 실행됩니다. 문제는 스택 오버플로(Stack Overflow)가 발생하면 SIGSEGV가 생성되는데, 핸들러도 같은 스택에서 실행하려 하면 또 다시 스택 오버플로가 발생하여 핸들러 자체를 실행할 수 없는 것입니다. sigaltstack()은 이 문제를 해결하기 위해 별도의 시그널 전용 스택을 설정합니다.

/* 유저 공간: 대체 시그널 스택 설정 */
stack_t ss;
ss.ss_sp = malloc(SIGSTKSZ);     /* 시그널 스택 메모리 할당 */
ss.ss_size = SIGSTKSZ;             /* 기본 크기 (보통 8192) */
ss.ss_flags = 0;
sigaltstack(&ss, NULL);

/* SA_ONSTACK 플래그로 핸들러 등록 */
struct sigaction sa;
sa.sa_handler = segv_handler;
sa.sa_flags = SA_ONSTACK;          /* 대체 스택에서 실행 */
sigaction(SIGSEGV, &sa, NULL);

/* kernel/signal.c - get_sigframe()에서 대체 스택 선택 로직 (간략화) */
static unsigned long get_sigframe(struct ksignal *ksig,
                                   struct pt_regs *regs,
                                   size_t frame_size)
{
    unsigned long sp = regs->sp;

    /* SA_ONSTACK 설정되었고, 현재 대체 스택 위가 아닌 경우 */
    if (ksig->ka.sa.sa_flags & SA_ONSTACK) {
        if (!on_sig_stack(sp) &&
            !(current->sas_ss_flags & SS_DISABLE))
            sp = current->sas_ss_sp + current->sas_ss_size;
    }

    sp -= frame_size;
    sp = round_down(sp, 16);  /* 16바이트 정렬 */
    return sp;
}

fork/exec 시그널 상속

fork()와 exec()는 시그널 관련 속성을 각각 다르게 처리합니다. 이 차이를 이해하는 것은 데몬 프로세스나 멀티프로세스 프로그램 설계에 중요합니다.

/* kernel/fork.c - copy_sighand() (fork 시 핸들러 테이블 복사) */
static int copy_sighand(unsigned long clone_flags,
                         struct task_struct *tsk)
{
    if (clone_flags & CLONE_SIGHAND) {
        /* 스레드 생성: sighand_struct 공유 (refcount++) */
        refcount_inc(&current->sighand->count);
        return 0;
    }
    /* 프로세스 fork: sighand_struct 복사 */
    struct sighand_struct *sig = kmem_cache_alloc(sighand_cachep, GFP_KERNEL);
    memcpy(sig->action, current->sighand->action, sizeof(sig->action));
    tsk->sighand = sig;
    return 0;
}

/* fs/exec.c - flush_signal_handlers() (exec 시 핸들러 리셋) */
void flush_signal_handlers(struct task_struct *t)
{
    struct k_sigaction *ka = &t->sighand->action[0];
    for (int i = _NSIG; i != 0; i--) {
        /* SIG_IGN은 유지, 나머지 핸들러는 SIG_DFL로 */
        if (ka->sa.sa_handler != SIG_IGN)
            ka->sa.sa_handler = SIG_DFL;
        ka->sa.sa_flags = 0;
        sigemptyset(&ka->sa.sa_mask);
        ka++;
    }
}

멀티스레드 시그널 전달

POSIX 스레드 모델에서 시그널 전달은 프로세스 지향(process-directed)과 스레드 지향(thread-directed)으로 나뉩니다. 커널은 이 두 종류를 shared_pending과 pending 큐로 구분합니다.

/* kernel/signal.c - complete_signal() (간략화)
 * 프로세스 지향 시그널의 대상 스레드 선택 알고리즘 */
static void complete_signal(int sig, struct task_struct *p,
                             enum pid_type type)
{
    struct task_struct *t, *signal_target;

    /* 1단계: 메인 스레드가 마스크 안 했으면 메인 스레드 선택 */
    signal_target = p;
    if (wants_signal(sig, p))
        goto found;

    /* 2단계: 마스크 안 한 스레드를 순회하여 찾기 */
    t = p;
    while_each_thread(p, t) {
        if (wants_signal(sig, t)) {
            signal_target = t;
            goto found;
        }
    }
    return;  /* 모든 스레드가 마스크 → pending으로 유지 */

found:
    /* TIF_SIGPENDING 설정하고 필요 시 깨움 */
    signal_wake_up(signal_target, sig == SIGKILL);
}

/* wants_signal(): 해당 스레드가 시그널을 받을 수 있는지 확인 */
static bool wants_signal(int sig, struct task_struct *p)
{
    if (sigismember(&p->blocked, sig))
        return false;        /* 마스크됨 */
    if (p->flags & PF_EXITING)
        return false;        /* 종료 중 */
    if (task_is_stopped_or_traced(p))
        return sig == SIGKILL; /* 중지 상태면 SIGKILL만 */
    return true;
}

실시간(Real-time) 시그널

표준 시그널(1~31)은 pending 비트마스크만 설정하므로 동일 시그널이 여러 번 발생해도 한 번만 전달됩니다. 실시간 시그널(SIGRTMIN~SIGRTMAX, 32~64)은 큐잉되어 발생 횟수만큼 전달되며, sigqueue()로 추가 데이터(sigval)를 전달할 수 있습니다.

signalfd

signalfd()는 시그널을 파일 디스크립터를 통해 동기적으로 수신할 수 있게 합니다. epoll/select/poll과 통합하여 이벤트 루프에서 시그널을 처리할 수 있습니다.

/* signalfd 사용 예 (유저 공간) */
sigset_t mask;
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
sigaddset(&mask, SIGTERM);

/* 시그널을 블록하고 fd로 수신 */
sigprocmask(SIG_BLOCK, &mask, NULL);
int sfd = signalfd(-1, &mask, SFD_NONBLOCK | SFD_CLOEXEC);

/* epoll에 등록 후 이벤트 루프에서 처리 */
struct signalfd_siginfo si;
read(sfd, &si, sizeof(si));
printf("signal %d from PID %d\\n", si.ssi_signo, si.ssi_pid);

pidfd_send_signal()

전통적인 kill() 시스템 콜은 PID로 대상 프로세스를 지정하는데, PID는 프로세스 종료 후 재사용될 수 있어 race condition이 발생할 수 있습니다. Linux 5.1에서 추가된 pidfd_send_signal()은 파일 디스크립터 기반으로 프로세스를 식별하여 이 문제를 해결합니다.

/* pidfd를 이용한 안전한 시그널 전송 (유저 공간) */
#include <sys/syscall.h>
#include <signal.h>

/* 1. 대상 프로세스의 pidfd 획득 (Linux 5.3+) */
int pidfd = syscall(SYS_pidfd_open, target_pid, 0);
if (pidfd < 0) {
    perror("pidfd_open");
    return -1;
}

/* 이 시점에서 target_pid가 종료되고 PID가 재사용되더라도
 * pidfd는 원래 프로세스를 가리킨다.
 * 원래 프로세스가 이미 종료되었으면 ESRCH 반환 */

/* 2. pidfd를 통해 시그널 전송 */
int ret = syscall(SYS_pidfd_send_signal, pidfd, SIGTERM, NULL, 0);
if (ret < 0)
    perror("pidfd_send_signal");

/* 3. pidfd는 pollable — waitid(P_PIDFD)와도 연동 가능 */
close(pidfd);

/* kernel/signal.c - pidfd_send_signal 구현 (간략화) */
SYSCALL_DEFINE4(pidfd_send_signal, int, pidfd, int, sig,
                siginfo_t __user *, info, unsigned int, flags)
{
    struct pid *pid;
    struct task_struct *task;

    /* pidfd에서 struct pid 획득 */
    pid = pidfd_to_pid(pidfd);

    /* pid에서 task_struct 조회 (RCU 보호) */
    task = pid_task(pid, PIDTYPE_PID);
    if (!task)
        return -ESRCH;  /* 프로세스 이미 종료 */

    /* 권한 검사 후 시그널 전송 */
    return group_send_sig_info(sig, &kinfo, task, PIDTYPE_TGID);
}

System V IPC

System V IPC는 메시지 큐, 공유 메모리, 세마포어의 세 가지 IPC 메커니즘을 제공하는 전통적인 UNIX IPC 인터페이스입니다. 커널의 ipc/ 디렉토리에 구현되어 있으며, 공통 인프라(ipc_ids, kern_ipc_perm)를 공유합니다.

SysV IPC 공통 인프라

/* ipc/util.h - IPC 연산 테이블 */
struct ipc_ops {
    int  (*getnew)(struct ipc_namespace *, struct ipc_params *);
    int  (*associate)(struct kern_ipc_perm *, int);
    int  (*more_checks)(struct kern_ipc_perm *, struct ipc_params *);
};

/* 공통 IPC 객체 조회/생성 흐름 */
/* xxxget() → ipcget() → ipcget_new() / ipcget_public()
   → ops->getnew() 또는 ops->associate() */

Message Queues (메시지 큐)

System V 메시지 큐는 프로세스 간에 메시지 경계가 보존되는 메시지를 주고받을 수 있게 합니다. 메시지는 타입 필드를 가지며, 수신자는 특정 타입의 메시지만 선택적으로 수신할 수 있습니다.

/* ipc/msg.c - 핵심 구조체 */
struct msg_queue {
    struct kern_ipc_perm q_perm;    /* 공통 IPC 권한 */
    time64_t             q_stime;   /* 마지막 msgsnd 시간 */
    time64_t             q_rtime;   /* 마지막 msgrcv 시간 */
    unsigned long        q_cbytes;  /* 큐 내 총 바이트 수 */
    unsigned long        q_qnum;    /* 큐 내 메시지 수 */
    unsigned long        q_qbytes;  /* 큐 최대 바이트 */
    struct list_head     q_messages; /* 메시지 연결 리스트 */
    struct list_head     q_receivers; /* 수신 대기 프로세스 */
    struct list_head     q_senders;  /* 송신 대기 프로세스 */
};

struct msg_msg {
    struct list_head m_list;
    long             m_type;       /* 메시지 타입 */
    size_t           m_ts;         /* 메시지 텍스트 크기 */
    struct msg_msgseg *next;       /* 큰 메시지용 세그먼트 */
    void            *security;
    /* 이후: 메시지 데이터 (인라인) */
};

/* 유저 공간 사용 예 */
#include <sys/msg.h>

struct msgbuf {
    long mtype;
    char mtext[256];
};

/* 메시지 큐 생성/열기 */
key_t key = ftok("/tmp/mqfile", 65);
int msqid = msgget(key, 0666 | IPC_CREAT);

/* 메시지 전송 */
struct msgbuf msg = { .mtype = 1 };
strcpy(msg.mtext, "Hello IPC");
msgsnd(msqid, &msg, strlen(msg.mtext) + 1, 0);

/* 메시지 수신 (타입 1만) */
struct msgbuf rcv;
msgrcv(msqid, &rcv, sizeof(rcv.mtext), 1, 0);

msgsnd/msgrcv 커널 내부 흐름

Shared Memory (공유 메모리)

System V 공유 메모리는 가장 빠른 IPC 메커니즘으로, 여러 프로세스가 동일한 물리 메모리(Physical Memory) 영역을 자신의 가상 주소 공간(Address Space)에 매핑하여 직접 접근합니다. 별도의 동기화 메커니즘(세마포어, futex 등)이 필요합니다.

/* ipc/shm.c - 핵심 구조체 */
struct shmid_kernel {
    struct kern_ipc_perm shm_perm;
    struct file         *shm_file;   /* shmem/hugetlb 파일 */
    unsigned long        shm_nattch;  /* attach 카운트 */
    size_t               shm_segsz;   /* 세그먼트 크기 */
    time64_t             shm_atim;    /* 마지막 attach 시간 */
    time64_t             shm_dtim;    /* 마지막 detach 시간 */
    pid_t                shm_cprid;   /* 생성자 PID */
    pid_t                shm_lprid;   /* 마지막 작업 PID */
    ...
};

Semaphores (세마포어)

System V 세마포어는 프로세스 간 동기화를 위한 카운팅 세마포어 배열을 제공합니다. 하나의 세마포어 세트에 여러 개의 세마포어를 포함할 수 있으며, semop()으로 원자적(Atomic) 다중 연산을 수행합니다.

/* ipc/sem.c - 핵심 구조체 */
struct sem_array {
    struct kern_ipc_perm sem_perm;
    time64_t             sem_ctime;    /* 마지막 변경 시간 */
    struct list_head     pending_alter; /* 대기 중인 연산 */
    struct list_head     pending_const; /* 대기 중인 연산 (0 대기) */
    struct sem          *sems;         /* 세마포어 배열 */
};

struct sem {
    int              semval;   /* 현재 값 */
    pid_t            sempid;   /* 마지막 연산 PID */
    struct list_head pending_alter;
    struct list_head pending_const;
    time64_t         sem_otime; /* 마지막 semop 시간 */
};

/* semop() 연산 구조체 */
struct sembuf {
    unsigned short sem_num;   /* 세마포어 인덱스 */
    short          sem_op;    /* 연산 (+n, -n, 0) */
    short          sem_flg;   /* IPC_NOWAIT, SEM_UNDO */
};

세마포어 사용 예제

#include <sys/sem.h>
#include <sys/ipc.h>
#include <stdio.h>
#include <stdlib.h>

/* semctl()용 공용체 (일부 시스템에서 직접 정의 필요) */
union semun {
    int              val;
    struct semid_ds *buf;
    unsigned short  *array;
};

/* 세마포어 P 연산 (wait/lock) */
void sem_wait(int semid)
{
    struct sembuf sb = {
        .sem_num = 0,
        .sem_op  = -1,         /* 값 감소 (잠금) */
        .sem_flg = SEM_UNDO    /* 프로세스 종료 시 자동 복원 */
    };
    semop(semid, &sb, 1);
}

/* 세마포어 V 연산 (signal/unlock) */
void sem_signal(int semid)
{
    struct sembuf sb = {
        .sem_num = 0,
        .sem_op  = 1,          /* 값 증가 (해제) */
        .sem_flg = SEM_UNDO
    };
    semop(semid, &sb, 1);
}

int main(void)
{
    key_t key = ftok("/tmp/semfile", 65);

    /* 세마포어 세트 생성 (1개 세마포어) */
    int semid = semget(key, 1, 0666 | IPC_CREAT);

    /* 초기값 1로 설정 (바이너리 세마포어) */
    union semun arg = { .val = 1 };
    semctl(semid, 0, SETVAL, arg);

    /* 임계 구역 진입 */
    sem_wait(semid);
    printf("임계 구역 실행 중...\n");
    /* ... 공유 자원 접근 ... */
    sem_signal(semid);

    /* 정리: 세마포어 세트 삭제 */
    semctl(semid, 0, IPC_RMID);
    return 0;
}

semop() 커널 내부 흐름

POSIX IPC

POSIX IPC는 System V IPC의 현대적 대안으로, 파일 디스크립터 기반의 일관된 API를 제공합니다. 이름 규칙(/name), 에러 처리, 권한 모델이 일반 파일 API와 유사하여 사용이 직관적입니다.

POSIX MQ / SHM / Sem

POSIX Message Queue 커널 내부

POSIX 메시지 큐는 전용 가상 파일시스템인 mqueue(ipc/mqueue.c)를 통해 구현됩니다. 각 큐는 mqueue_inode_info 구조체로 관리되며, 메시지들은 우선순위(Priority)에 따라 정렬된 레드-블랙 트리(Red-Black Tree)로 저장됩니다. 이를 통해 mq_receive()는 항상 가장 높은 우선순위의 메시지를 먼저 반환합니다.

/* ipc/mqueue.c - 핵심 구조체 */
struct mqueue_inode_info {
    spinlock_t           lock;
    struct rb_root       msg_tree;       /* RB-tree: 우선순위별 메시지 */
    struct posix_msg_tree_node *node_cache;
    struct mq_attr       attr;           /* mq_maxmsg, mq_msgsize 등 */
    struct sigevent      notify;         /* mq_notify 설정 */
    struct pid          *notify_owner;  /* 통지 대상 프로세스 */
    struct user_namespace *notify_user_ns;
    struct ucounts      *ucounts;       /* 사용자별 큐 카운트 */
    unsigned long        qsize;          /* 큐 내 총 바이트 */
    struct inode         vfs_inode;
    struct list_head     e_wait_q[2];   /* [0]=수신대기, [1]=송신대기 */
};

/* 우선순위별 메시지 트리 노드 */
struct posix_msg_tree_node {
    struct rb_node       rb_node;
    struct list_head     msg_list;       /* 동일 우선순위 메시지 리스트 */
    int                  priority;
};

mq_notify()는 큐에 메시지가 도착했을 때 비동기 알림을 받을 수 있게 합니다. 두 가지 주요 통지 방식이 있습니다:

POSIX MQ 우선순위 예제

#include <mqueue.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    struct mq_attr attr = {
        .mq_maxmsg  = 10,
        .mq_msgsize = 256
    };

    /* 큐 생성 (이름은 반드시 '/'로 시작) */
    mqd_t mq = mq_open("/test_queue", O_CREAT | O_RDWR, 0644, &attr);

    /* 우선순위별 메시지 전송 (높은 숫자 = 높은 우선순위) */
    mq_send(mq, "low priority",  13, 1);   /* 우선순위 1 */
    mq_send(mq, "high priority", 14, 10);  /* 우선순위 10 */
    mq_send(mq, "mid priority",  13, 5);   /* 우선순위 5 */

    /* 수신: 항상 가장 높은 우선순위부터 */
    char buf[256];
    unsigned int prio;
    mq_receive(mq, buf, 256, &prio);
    printf("1st: %s (prio=%u)\n", buf, prio);  /* "high priority" (10) */

    mq_receive(mq, buf, 256, &prio);
    printf("2nd: %s (prio=%u)\n", buf, prio);  /* "mid priority" (5) */

    mq_close(mq);
    mq_unlink("/test_queue");
    return 0;
}

POSIX Shared Memory 커널 내부

POSIX 공유 메모리는 shm_open()으로 생성하며, 실제로는 tmpfs(/dev/shm) 위에 일반 파일을 여는 것과 동일합니다. glibc의 shm_open()은 내부적으로 /dev/shm/ 경로에 대해 open()을 호출합니다. 이후 ftruncate()로 크기를 설정하고 mmap()으로 주소 공간에 매핑합니다.

/* POSIX 공유 메모리 예제 */
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>

#define SHM_SIZE 4096

int main(void)
{
    /* 공유 메모리 객체 생성 (이름 '/'로 시작) */
    int fd = shm_open("/my_shm", O_CREAT | O_RDWR, 0644);

    /* 크기 설정 */
    ftruncate(fd, SHM_SIZE);

    /* 주소 공간에 매핑 */
    void *ptr = mmap(NULL, SHM_SIZE,
                     PROT_READ | PROT_WRITE,
                     MAP_SHARED, fd, 0);
    close(fd);  /* fd는 mmap 후 닫아도 됨 */

    /* 공유 메모리에 데이터 기록 */
    strcpy(ptr, "Hello from POSIX SHM");
    printf("Written: %s\n", (char *)ptr);

    /* 정리 */
    munmap(ptr, SHM_SIZE);
    shm_unlink("/my_shm");
    return 0;
}

int fd = memfd_create("shared_data", MFD_CLOEXEC);
ftruncate(fd, 4096);
void *p = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
/* fd를 SCM_RIGHTS로 다른 프로세스에 전달 가능 */

POSIX Named Semaphore 내부 구현

POSIX Named Semaphore는 sem_open()으로 생성하며, glibc 내부에서 /dev/shm/sem.NAME 경로에 파일을 생성합니다. 파일 내용은 sem_t 구조체가 매핑되며, 실제 동기화는 커널의 futex 메커니즘을 통해 수행됩니다. 경합이 없는 경우(uncontended) 커널 진입 없이 원자적 연산만으로 처리됩니다.

/* glibc 내부 sem_t 구조 (간략화) - nptl/internaltypes.h */
struct new_sem {
    unsigned int value;       /* 세마포어 현재 값 (atomic) */
    unsigned int nwaiters;    /* 대기 중인 스레드 수 */
    int          private;      /* FUTEX_PRIVATE_FLAG 여부 */
};
/*
 * sem_wait() 흐름:
 *   1. atomic_decrement(&value) — 성공(>0)이면 즉시 리턴 (Fast Path)
 *   2. 실패(0)이면 → futex(FUTEX_WAIT, &value, 0) → 커널 슬립
 *
 * sem_post() 흐름:
 *   1. atomic_increment(&value)
 *   2. nwaiters > 0 이면 → futex(FUTEX_WAKE, &value, 1)
 */

SysV vs POSIX 비교

Futex (Fast Userspace Mutex)

Futex는 유저 공간에서 빠르게 동기화를 수행하고, 경합(contention)이 발생할 때만 커널에 진입하는 하이브리드 동기화 메커니즘입니다. glibc의 pthread_mutex, pthread_cond, sem_wait() 등 거의 모든 유저 공간 동기화 프리미티브의 근간입니다.

Futex 동작 원리

futex() 시스템 콜

/* kernel/futex/waitwake.c - futex_wait() 핵심 (간략화) */
int futex_wait(u32 __user *uaddr, unsigned int flags,
              u32 val, ktime_t *abs_time, u32 bitset)
{
    struct futex_hash_bucket *hb;
    struct futex_q q = futex_q_init;

    /* 1. futex 키 계산 (공유/비공유) */
    get_futex_key(uaddr, flags, &q.key);

    /* 2. hash bucket 결정 및 잠금 */
    hb = futex_q_lock(&q);

    /* 3. 현재 값 검증 (값이 바뀌었으면 즉시 리턴) */
    if (futex_get_value_locked(&uval, uaddr))
        goto out;
    if (uval != val) {
        futex_q_unlock(hb);
        return -EAGAIN;
    }

    /* 4. 대기 큐에 등록하고 슬립 */
    futex_wait_queue(hb, &q, abs_time);

    return 0;
}

PI-Futex (Priority Inheritance)

PI-Futex는 우선순위 역전(Priority Inversion) 문제를 해결하기 위해 FUTEX_LOCK_PI/FUTEX_UNLOCK_PI 연산을 제공합니다. 우선순위 역전은 실시간(Real-Time) 시스템에서 치명적인 문제로, 높은 우선순위의 태스크가 낮은 우선순위 태스크가 보유한 lock을 기다리는 동안, 중간 우선순위의 태스크가 실행되어 전체 시스템의 응답 시간이 무한히 늘어나는 현상입니다.

PI-Futex는 커널 내부의 rt_mutex 인프라를 활용합니다. FUTEX_LOCK_PI 호출 시 유저 공간 futex 값의 하위 비트에 소유자 TID가 기록되며, 경합 발생 시 커널이 소유자의 우선순위를 자동으로 조정합니다.

/* kernel/futex/pi.c - PI futex 핵심 흐름 (간략화) */
int futex_lock_pi(u32 __user *uaddr, unsigned int flags,
                  ktime_t *time, int trylock)
{
    struct rt_mutex_waiter rt_waiter;
    struct futex_pi_state *pi_state;
    struct task_struct *exiting = NULL;

    /* 1. futex 키 계산, hash bucket 잠금 */
    get_futex_key(uaddr, flags, &q.key);
    hb = futex_q_lock(&q);

    /* 2. 유저 공간 값에서 소유자 TID 확인 */
    get_futex_value_locked(&uval, uaddr);

    /* 3. 소유자가 없으면 CAS로 즉시 획득 (fast path) */
    if (!(uval & FUTEX_TID_MASK)) {
        futex_atomic_cmpxchg_inatomic(uaddr, uval,
                                       uval | current->pid);
        return 0;
    }

    /* 4. 소유자 task_struct 조회, PI state 연결 */
    attach_to_pi_state(uval, pi_state, &exiting);

    /* 5. rt_mutex를 통한 PI 대기 (소유자 우선순위 부스트) */
    rt_mutex_slowlock_block(&pi_state->pi_mutex,
                            &rt_waiter, NULL);
    /* 깨어나면 lock 획득 완료, 유저값에 자신의 TID 기록 */
    return 0;
}

/* PI-Futex 사용 예 (glibc pthread_mutex_init에서 자동 사용) */
#include <pthread.h>

pthread_mutex_t pi_mutex;
pthread_mutexattr_t attr;

/* PI 프로토콜 설정 */
pthread_mutexattr_init(&attr);
pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
pthread_mutex_init(&pi_mutex, &attr);

/* 이후 pthread_mutex_lock()은 내부적으로 FUTEX_LOCK_PI 사용 */
pthread_mutex_lock(&pi_mutex);
/* 임계 구역 */
pthread_mutex_unlock(&pi_mutex);

Robust Futex

Robust futex는 lock을 보유한 프로세스가 비정상 종료(crash)했을 때 deadlock을 방지하는 메커니즘입니다. 일반 futex에서는 lock 소유자가 죽으면 다른 대기자들이 영원히 깨어나지 못하는 문제가 발생합니다. Robust futex는 이 문제를 커널이 자동으로 감지하고 복구합니다.

동작 원리는 다음과 같습니다:

1. 프로세스가 set_robust_list()로 robust futex 리스트의 헤드를 커널에 등록합니다.
2. glibc의 pthread_mutex_lock()이 lock 획득 시 해당 futex를 robust 리스트에 연결합니다.
3. 프로세스가 비정상 종료하면 커널이 exit_robust_list()를 호출합니다.
4. 리스트의 각 futex에 FUTEX_OWNER_DIED 비트(bit 30)를 설정합니다.
5. 해당 futex에서 대기 중인 프로세스가 깨어나 EOWNERDEAD를 받고 복구 절차를 수행합니다.

/* Robust futex 사용 예 */
#include <pthread.h>
#include <stdio.h>
#include <errno.h>

/* 공유 메모리에 배치된 mutex (프로세스 간 공유) */
pthread_mutex_t *shared_mutex;  /* mmap으로 공유 메모리에 매핑 */

void init_robust_mutex(void)
{
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);

    /* robust 속성 설정 */
    pthread_mutexattr_setrobust(&attr, PTHREAD_MUTEX_ROBUST);

    /* 프로세스 간 공유 설정 */
    pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);

    pthread_mutex_init(shared_mutex, &attr);
}

void safe_lock(void)
{
    int ret = pthread_mutex_lock(shared_mutex);

    if (ret == EOWNERDEAD) {
        /* 이전 소유자가 죽었음 → 공유 상태 복구 필요 */
        printf("이전 소유자 사망 감지, 상태 복구 중...\n");

        /* ... 공유 데이터 일관성 복구 ... */

        /* mutex를 일관된 상태로 표시 */
        pthread_mutex_consistent(shared_mutex);
    } else if (ret == ENOTRECOVERABLE) {
        /* 복구 불가능 상태 (consistent 호출 안 하고 unlock한 경우) */
        fprintf(stderr, "mutex 복구 불가\n");
        return;
    }

    /* 정상 임계 구역 진입 */
    /* ... */

    pthread_mutex_unlock(shared_mutex);
}

/* 커널 내부: exit_robust_list() 핵심 (간략화) */
/* kernel/futex/core.c */
void exit_robust_list(struct task_struct *curr)
{
    struct robust_list_head __user *head = curr->robust_list;
    struct robust_list __user *entry, *next_entry;

    /* robust 리스트 순회 */
    for (entry = head->list.next; entry != &head->list;
         entry = next_entry) {
        next_entry = entry->next;

        /* futex 값에서 소유자 TID 확인 */
        get_user(uval, futex_uaddr);

        if ((uval & FUTEX_TID_MASK) == curr->pid) {
            /* FUTEX_OWNER_DIED 비트 설정 */
            handle_futex_death(futex_uaddr, curr);
            /* → FUTEX_WAKE로 대기자 깨움 */
        }
    }
}

ntsync — NT 동기화 프리미티브 (v6.14+)

커널 6.14에서 ntsync 서브시스템이 추가되었습니다. Windows NT 커널의 동기화 원시 객체(뮤텍스, 세마포어, 이벤트)를 Linux 커널에 네이티브로 구현하여, Wine/Proton의 게임 에뮬레이션 성능을 크게 향상시킵니다.

IPC 흔한 실수와 모범 사례

IPC 프로그래밍에서 자주 발생하는 실수와 이를 방지하기 위한 모범 사례를 정리합니다.

IPC 종합 비교

전통적 IPC와 현대 IPC를 포함한 전체 비교표입니다. 현대 메커니즘(eventfd, epoll, Netlink, memfd, pidfd 등)의 상세 설명은 현대 리눅스 IPC 메커니즘 페이지를 참고하세요.

IPC 디버깅

커널 IPC 자원의 상태를 진단하고 문제를 해결하기 위한 도구들입니다.

ipcs / ipcrm

# System V IPC 자원 조회
ipcs -a              # 모든 IPC 자원 (MQ, SHM, SEM)
ipcs -m              # 공유 메모리만
ipcs -q              # 메시지 큐만
ipcs -s              # 세마포어만
ipcs -l              # 시스템 제한값 표시

# IPC 자원 삭제
ipcrm -m <shmid>     # 공유 메모리 삭제
ipcrm -q <msqid>     # 메시지 큐 삭제
ipcrm -s <semid>     # 세마포어 삭제

/proc/sysvipc

# 커널이 노출하는 IPC 정보
cat /proc/sysvipc/msg    # 메시지 큐 상세
cat /proc/sysvipc/shm    # 공유 메모리 상세
cat /proc/sysvipc/sem    # 세마포어 상세

# IPC 제한 파라미터 확인/변경
sysctl kernel.msgmax     # 최대 메시지 크기
sysctl kernel.shmmax     # 최대 공유 메모리 세그먼트 크기
sysctl kernel.sem        # SEMMSL SEMMNS SEMOPM SEMMNI

strace / bpftrace

# IPC 관련 시스템 콜 추적
strace -e trace=ipc ./program           # SysV IPC 시스템 콜 추적
strace -e trace=%signal ./program       # 시그널 관련 추적
strace -e read,write -e fd=3 ./program  # 특정 fd의 read/write 추적

# bpftrace로 pipe 쓰기 모니터링
bpftrace -e 'tracepoint:syscalls:sys_enter_write
  /args->fd > 2/ { @bytes = hist(args->count); }'

# futex 경합 분석
bpftrace -e 'tracepoint:syscalls:sys_enter_futex
  { @ops = count(); @cmd[args->op & 0xf] = count(); }'

lsof로 IPC 자원 조회

# 특정 프로세스의 열린 IPC 관련 fd 조회
lsof -p <PID> | grep -E 'pipe|socket|eventfd|signalfd|timerfd'

# Unix 도메인 소켓 사용 현황
lsof -U                          # 모든 Unix 소켓
lsof -U -a -c nginx              # nginx의 Unix 소켓만

# 특정 파이프/소켓의 양쪽 끝 찾기
lsof | grep 'pipe:\[12345\]'      # inode 번호로 pipe 양쪽 프로세스 식별

# /proc/PID/fdinfo로 상세 정보 확인
cat /proc/<PID>/fdinfo/3        # fd 3의 상세 정보
# eventfd-count: 0               ← eventfd의 현재 카운터
# sigmask: 0000000000000006      ← signalfd의 시그널 마스크
# clockid: 0                     ← timerfd의 클럭 소스

# /proc/PID/fd 심볼릭 링크로 fd 타입 확인
ls -la /proc/<PID>/fd/
# lrwx------ 1 user user 0 ... 3 -> pipe:[12345]
# lrwx------ 1 user user 0 ... 4 -> socket:[67890]
# lrwx------ 1 user user 0 ... 5 -> anon_inode:[eventfd]

perf를 사용한 IPC 성능 분석

# IPC 중 컨텍스트 스위치 횟수 측정
perf stat -e context-switches,cpu-migrations,page-faults \
    -p <PID> -- sleep 10

# 시스템 콜 레이턴시 추적 (IPC 관련)
perf trace -e sendmsg,recvmsg,read,write,epoll_wait \
    -p <PID> -s 2>/dev/null

# 특정 IPC 시스템 콜의 지연 시간 히스토그램
perf trace -e epoll_wait --duration 1 -p <PID> 2>&1 | \
    awk '{print $NF}' | sort -n

# flamegraph로 IPC 병목 지점 식별
perf record -g -p <PID> -- sleep 30
perf script | stackcollapse-perf.pl | flamegraph.pl > ipc-flame.svg

# bpftrace로 pipe/socket read 지연 시간 측정
bpftrace -e 'tracepoint:syscalls:sys_enter_read { @start[tid] = nsecs; }
tracepoint:syscalls:sys_exit_read /@start[tid]/ {
    @usecs = hist((nsecs - @start[tid]) / 1000);
    delete(@start[tid]);
}'

일반적인 IPC 문제 진단

참고 링크

• Linux Kernel — IPC Userspace API — 커널 공식 문서의 IPC 유저스페이스 API 섹션입니다
• sysvipc(7) — System V IPC 메커니즘(메시지 큐, 세마포어, 공유 메모리) 전체 개요 매뉴얼입니다
• pipe(7) — 파이프와 FIFO의 용량, 원자성 보장, O_NONBLOCK 동작을 설명합니다
• pipe(2) — pipe() 및 pipe2() 시스템 콜의 인터페이스와 플래그를 다룹니다
• mq_overview(7) — POSIX 메시지 큐의 생성, 속성, 알림 메커니즘을 설명합니다
• shm_overview(7) — POSIX 공유 메모리 객체의 생성과 메모리 매핑 방법을 다룹니다
• sem_overview(7) — POSIX 세마포어(named/unnamed)의 동작과 사용법을 설명합니다
• msgget(2) — System V 메시지 큐 생성 및 접근 시스템 콜입니다
• shmget(2) — System V 공유 메모리 세그먼트 할당 시스템 콜입니다
• semget(2) — System V 세마포어 집합 생성 시스템 콜입니다
• futex(2) — Fast Userspace Mutex 시스템 콜의 op 코드와 동작을 다룹니다
• signal(7) — 리눅스 시그널의 종류, 기본 동작, 실시간 시그널 확장을 설명합니다
• LWN: Scalability of pipes — 파이프 구현의 확장성 개선 패치와 성능 분석을 다룹니다
• LWN: A futex overview and update — futex의 내부 구현과 PI futex, robust futex를 심층 분석합니다
• POSIX.1-2024 (IEEE Std 1003.1) — IPC 관련 POSIX 표준 규격의 최신 버전입니다
• ipc/msg.c — System V 메시지 큐의 커널 구현부입니다
• ipc/shm.c — System V 공유 메모리의 커널 구현부입니다
• ipc/sem.c — System V 세마포어의 커널 구현부입니다
• ipc/mqueue.c — POSIX 메시지 큐의 커널 구현부입니다
• fs/pipe.c — 파이프와 FIFO의 커널 구현부입니다
• kernel/futex/ — futex 서브시스템 전체 구현 디렉터리입니다
• kernel/signal.c — 시그널 처리의 커널 구현부입니다

관련 문서

• 현대 리눅스 IPC 메커니즘 - eventfd/signalfd/timerfd, epoll, Netlink, memfd, pidfd, Android Binder
• Unix Domain Socket - AF_UNIX 커널 구현, SCM_RIGHTS, GC, 성능 최적화
• 동기화 기법 - spinlock, mutex, rwlock 등 커널 내부 동기화 프리미티브
• 시그널 처리 - 프로세스 간 신호 기반 IPC
• 네트워크 스택 - Netlink 심층 구현
• 네임스페이스 - IPC namespace를 포함한 커널 네임스페이스 격리
• 프로세스 관리 - task_struct, 시그널 핸들링, fork/exec