OS 핵심 개념 완전 정리: 개발자 면접에 나오는 운영체제의 모든 것

┌─────────────────────────────────┐
│         PCB (Process            │
│         Control Block)          │
├─────────────────────────────────┤
│  Process ID (PID)               │
│  Process State                  │
│  Program Counter (PC)           │
│  CPU Registers                  │
│  CPU Scheduling Info            │
│  Memory Management Info         │
│  I/O Status Info                │
│  Accounting Info                │
└─────────────────────────────────┘

         ┌──────────┐
    생성  │          │  종료
  ──────▶│  Ready   │──────▶
         │          │
         └────┬─────┘
              │ dispatch
              ▼
         ┌──────────┐     I/O 요청
         │ Running  │───────────┐
         │          │           │
         └────┬─────┘           ▼
              │           ┌──────────┐
     선점    │           │ Waiting  │
  (preempt)  │           │ (Blocked)│
              └───────────┤          │
                          └──────────┘
                          I/O 완료 시 Ready로

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    pid_t pid = fork();  // 프로세스 복제

    if (pid < 0) {
        // fork 실패
        perror("fork failed");
        return 1;
    } else if (pid == 0) {
        // 자식 프로세스
        printf("Child PID: %d, Parent PID: %d\n", getpid(), getppid());
        // exec: 새로운 프로그램으로 교체
        execlp("ls", "ls", "-la", NULL);
        // exec 성공 시 이 줄은 실행되지 않음
        perror("exec failed");
    } else {
        // 부모 프로세스
        printf("Parent PID: %d, Child PID: %d\n", getpid(), pid);
        int status;
        waitpid(pid, &status, 0);  // 자식 프로세스 종료 대기
        printf("Child exited with status: %d\n", WEXITSTATUS(status));
    }
    return 0;
}

// Shared Memory 예시
#include <sys/mman.h>
#include <fcntl.h>
#include <string.h>

int main() {
    const char *name = "/my_shm";
    const int SIZE = 4096;

    // 공유 메모리 객체 생성
    int fd = shm_open(name, O_CREAT | O_RDWR, 0666);
    ftruncate(fd, SIZE);

    // 메모리 매핑
    void *ptr = mmap(0, SIZE, PROT_WRITE, MAP_SHARED, fd, 0);
    memcpy(ptr, "Hello from producer!", 20);

    // 정리: munmap, shm_unlink
    return 0;
}

# Python 멀티프로세싱 + 공유 메모리
from multiprocessing import Process, Value, Array

def worker(shared_counter, shared_array):
    shared_counter.value += 1
    shared_array[0] = 3.14

if __name__ == '__main__':
    counter = Value('i', 0)     # 정수 공유 변수
    arr = Array('d', [0.0, 0.0]) # 실수 공유 배열

    processes = [Process(target=worker, args=(counter, arr)) for _ in range(4)]
    for p in processes:
        p.start()
    for p in processes:
        p.join()

    print(f"Counter: {counter.value}, Array: {arr[:]}")

프로세스 A                프로세스 B
┌───────────────┐        ┌───────────────┐
│ Code  │ Data  │        │ Code  │ Data  │
│───────│───────│        │───────│───────│
│ Heap  │ Stack │        │ Heap  │ Stack │
│       │ (main)│        │       │ (main)│
└───────────────┘        └───────────────┘
  독립적 메모리 공간          독립적 메모리 공간

프로세스 C (멀티스레드)
┌───────────────────────────────┐
│ Code (공유) │  Data (공유)     │
│─────────────│─────────────────│
│ Heap (공유) │ Stack1 │ Stack2 │
│             │ (T1)   │ (T2)   │
└───────────────────────────────┘
  스레드는 Code, Data, Heap을 공유
  각 스레드는 독립적인 Stack만 보유

User-Level Thread (ULT):
┌─────────────────────────┐
│     User Space          │
│  Thread Library         │
│  ┌───┐ ┌───┐ ┌───┐    │
│  │ T1│ │ T2│ │ T3│    │
│  └───┘ └───┘ └───┘    │
│         |               │
│  ┌──────▼──────┐       │
│  │ Single      │       │
│  │ Kernel Thread│       │
│  └─────────────┘       │
└─────────────────────────┘
장점: 빠른 스위칭
단점: 하나가 블록되면 모두 블록

Kernel-Level Thread (KLT):
┌─────────────────────────┐
│     User Space          │
│  ┌───┐ ┌───┐ ┌───┐    │
│  │ T1│ │ T2│ │ T3│    │
│  └─┬─┘ └─┬─┘ └─┬─┘    │
└────┼──────┼──────┼──────┘
  ┌──▼──┐┌──▼──┐┌──▼──┐
  │ KT1 ││ KT2 ││ KT3 │
  └─────┘└─────┘└─────┘
장점: 진정한 병렬성
단점: 스위칭 비용 높음

#include <pthread.h>
#include <stdio.h>

#define NUM_THREADS 4

typedef struct {
    int thread_id;
    int start;
    int end;
    long result;
} ThreadArg;

void* sum_range(void* arg) {
    ThreadArg* targ = (ThreadArg*)arg;
    targ->result = 0;
    for (int i = targ->start; i <= targ->end; i++) {
        targ->result += i;
    }
    printf("Thread %d: sum(%d..%d) = %ld\n",
           targ->thread_id, targ->start, targ->end, targ->result);
    return NULL;
}

int main() {
    pthread_t threads[NUM_THREADS];
    ThreadArg args[NUM_THREADS];
    int range_per_thread = 250;  // 1-1000을 4등분

    for (int i = 0; i < NUM_THREADS; i++) {
        args[i].thread_id = i;
        args[i].start = i * range_per_thread + 1;
        args[i].end = (i + 1) * range_per_thread;
        pthread_create(&threads[i], NULL, sum_range, &args[i]);
    }

    long total = 0;
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
        total += args[i].result;
    }

    printf("Total sum: %ld\n", total);  // 500500
    return 0;
}

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    results := make(chan int, 4)

    for i := 0; i < 4; i++ {
        wg.Add(1)
        go func(id, start, end int) {
            defer wg.Done()
            sum := 0
            for j := start; j <= end; j++ {
                sum += j
            }
            results <- sum
            fmt.Printf("Goroutine %d: sum(%d..%d) = %d\n", id, start, end, sum)
        }(i, i*250+1, (i+1)*250)
    }

    go func() {
        wg.Wait()
        close(results)
    }()

    total := 0
    for r := range results {
        total += r
    }
    fmt.Printf("Total: %d\n", total)
}

import threading
import multiprocessing
import time

# CPU-bound 작업: GIL로 인해 스레드가 이점 없음
def cpu_bound(n):
    total = 0
    for i in range(n):
        total += i * i
    return total

# 스레드 방식 (GIL 제한)
def thread_test():
    threads = [threading.Thread(target=cpu_bound, args=(10_000_000,))
               for _ in range(4)]
    start = time.time()
    for t in threads:
        t.start()
    for t in threads:
        t.join()
    print(f"Threads: {time.time() - start:.2f}s")

# 프로세스 방식 (GIL 우회)
def process_test():
    processes = [multiprocessing.Process(target=cpu_bound, args=(10_000_000,))
                 for _ in range(4)]
    start = time.time()
    for p in processes:
        p.start()
    for p in processes:
        p.join()
    print(f"Processes: {time.time() - start:.2f}s")

# I/O-bound 작업: 스레드가 유효
# CPU-bound 작업: 멀티프로세싱 또는 C 확장 사용

Red-Black Tree (CFS)
       ┌───┐
       │ 8 │  vruntime이 가장 작은 노드가
       └─┬─┘  항상 가장 왼쪽에 위치
      ┌──┴──┐
    ┌─┤    ┌┤
    │5│    │12│
    └─┘    └──┘
   ↑
  다음 실행 대상

# nice 값으로 프로세스 우선순위 조정 (-20 ~ +19)
nice -n 10 ./my_program        # 낮은 우선순위로 실행
renice -n -5 -p 1234          # PID 1234의 우선순위 상향

# 실시간 스케줄링 정책 설정
chrt -f 50 ./realtime_program   # FIFO, 우선순위 50
chrt -r 50 ./realtime_program   # Round Robin, 우선순위 50

# 현재 스케줄링 정보 확인
chrt -p 1234

# cgroups v2로 CPU 사용량 제한
# /sys/fs/cgroup에 새 그룹 생성
mkdir /sys/fs/cgroup/my_group

# CPU 대역폭 제한: 50ms 주기에서 최대 25ms 사용 (50%)
echo "25000 50000" > /sys/fs/cgroup/my_group/cpu.max

# 프로세스를 cgroup에 추가
echo 1234 > /sys/fs/cgroup/my_group/cgroup.procs

# CPU 가중치 설정 (기본 100, 범위 1-10000)
echo 200 > /sys/fs/cgroup/my_group/cpu.weight

// 레이스 컨디션 예시 — 동기화 없는 카운터
#include <pthread.h>
#include <stdio.h>

int counter = 0;  // 공유 변수

void* increment(void* arg) {
    for (int i = 0; i < 1000000; i++) {
        counter++;  // 원자적이지 않음! (read -> modify -> write)
    }
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, increment, NULL);
    pthread_create(&t2, NULL, increment, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    printf("Counter: %d (expected 2000000)\n", counter);
    // 실제로는 2000000보다 작은 값 출력
    return 0;
}

#include <pthread.h>
#include <stdio.h>

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
int counter = 0;

void* safe_increment(void* arg) {
    for (int i = 0; i < 1000000; i++) {
        pthread_mutex_lock(&lock);     // 잠금 획득
        counter++;                      // 임계 영역
        pthread_mutex_unlock(&lock);   // 잠금 해제
    }
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, safe_increment, NULL);
    pthread_create(&t2, NULL, safe_increment, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    printf("Counter: %d\n", counter);  // 정확히 2000000
    return 0;
}

#include <semaphore.h>
#include <pthread.h>
#include <stdio.h>

sem_t semaphore;

void* worker(void* arg) {
    int id = *(int*)arg;
    printf("Thread %d waiting...\n", id);
    sem_wait(&semaphore);     // 세마포어 값 감소, 0이면 대기
    printf("Thread %d entered critical section\n", id);
    sleep(2);                 // 작업 수행
    printf("Thread %d leaving\n", id);
    sem_post(&semaphore);     // 세마포어 값 증가
    return NULL;
}

int main() {
    sem_init(&semaphore, 0, 3);  // 동시에 3개 스레드 허용

    pthread_t threads[10];
    int ids[10];
    for (int i = 0; i < 10; i++) {
        ids[i] = i;
        pthread_create(&threads[i], NULL, worker, &ids[i]);
    }
    for (int i = 0; i < 10; i++) {
        pthread_join(threads[i], NULL);
    }
    sem_destroy(&semaphore);
    return 0;
}

#include <pthread.h>

pthread_spinlock_t spinlock;
int counter = 0;

void* spin_increment(void* arg) {
    for (int i = 0; i < 1000000; i++) {
        pthread_spin_lock(&spinlock);    // 잠금 획득까지 busy-wait
        counter++;
        pthread_spin_unlock(&spinlock);
    }
    return NULL;
}
// 스핀락은 임계 영역이 매우 짧을 때 유용
// 컨텍스트 스위치 비용 > 스핀 대기 비용인 경우에 사용

import threading

class ReadWriteLock:
    def __init__(self):
        self._read_ready = threading.Condition(threading.Lock())
        self._readers = 0
        self._writers = 0

    def acquire_read(self):
        with self._read_ready:
            while self._writers > 0:
                self._read_ready.wait()
            self._readers += 1

    def release_read(self):
        with self._read_ready:
            self._readers -= 1
            if self._readers == 0:
                self._read_ready.notify_all()

    def acquire_write(self):
        with self._read_ready:
            while self._readers > 0 or self._writers > 0:
                self._read_ready.wait()
            self._writers += 1

    def release_write(self):
        with self._read_ready:
            self._writers -= 1
            self._read_ready.notify_all()

  Thread A              Thread B
  ┌──────┐             ┌──────┐
  │Lock X│────대기────▶│Lock Y│
  │보유   │             │보유   │
  └──────┘◀────대기────└──────┘

import threading
import time

lock_a = threading.Lock()
lock_b = threading.Lock()

def thread_1():
    print("Thread 1: Acquiring lock_a")
    lock_a.acquire()
    time.sleep(0.1)  # 타이밍 이슈를 위한 지연
    print("Thread 1: Acquiring lock_b")
    lock_b.acquire()  # 데드락! Thread 2가 lock_b를 보유 중
    lock_b.release()
    lock_a.release()

def thread_2():
    print("Thread 2: Acquiring lock_b")
    lock_b.acquire()
    time.sleep(0.1)
    print("Thread 2: Acquiring lock_a")
    lock_a.acquire()  # 데드락! Thread 1이 lock_a를 보유 중
    lock_a.release()
    lock_b.release()

# 데드락 발생!
t1 = threading.Thread(target=thread_1)
t2 = threading.Thread(target=thread_2)
t1.start()
t2.start()

# 순환 대기 제거: 락 순서 강제
def safe_thread_1():
    lock_a.acquire()   # 항상 lock_a를 먼저
    lock_b.acquire()
    # ... 작업 ...
    lock_b.release()
    lock_a.release()

def safe_thread_2():
    lock_a.acquire()   # 항상 lock_a를 먼저 (같은 순서)
    lock_b.acquire()
    # ... 작업 ...
    lock_b.release()
    lock_a.release()

┌────────────────────┐  속도: 매우 빠름
│    CPU Registers   │  용량: 수 KB
├────────────────────┤
│    L1 Cache        │  ~1ns, 64KB
├────────────────────┤
│    L2 Cache        │  ~4ns, 256KB
├────────────────────┤
│    L3 Cache        │  ~12ns, 수 MB
├────────────────────┤
│    Main Memory     │  ~100ns, 수 GB
│    (DRAM)          │
├────────────────────┤
│    SSD             │  ~100us, 수 TB
├────────────────────┤  속도: 매우 느림
│    HDD             │  ~10ms, 수 TB
└────────────────────┘

논리 주소 공간              물리 메모리
┌───────────┐              ┌───────────┐
│  Page 0   │──────────▶  │  Frame 3  │
├───────────┤              ├───────────┤
│  Page 1   │──────────▶  │  Frame 7  │
├───────────┤              ├───────────┤
│  Page 2   │──────────▶  │  Frame 1  │
├───────────┤              ├───────────┤
│  Page 3   │──────────▶  │  Frame 5  │
└───────────┘              └───────────┘

페이지 테이블:
Page 0 -> Frame 3
Page 1 -> Frame 7
Page 2 -> Frame 1
Page 3 -> Frame 5

논리 주소 ──▶ TLB 확인 ──hit──▶ 물리 주소
                  │
                 miss
                  │
                  ▼
              페이지 테이블
              조회 후 TLB 갱신

1. CPU가 논리 주소 접근
2. 페이지 테이블에서 유효 비트(valid bit) 확인
3. 유효하지 않음 → 페이지 폴트 인터럽트 발생
4. OS가 디스크에서 해당 페이지 찾기
5. 빈 프레임 할당 (없으면 페이지 교체)
6. 디스크에서 프레임으로 로드
7. 페이지 테이블 갱신 (유효 비트 = 1)
8. 중단된 명령어 재실행

CPU 사용률
 100% │       ╱╲
      │      ╱  ╲
      │     ╱    ╲
      │    ╱      ╲  ← 스래싱 시작
      │   ╱        ╲
      │  ╱          ╲
      │ ╱            ╲
   0% └──────────────────▶
      적음    멀티프로그래밍 정도    많음

┌─────────────────────────────┐
│           inode              │
├─────────────────────────────┤
│ 파일 타입 (regular, dir...) │
│ 권한 (rwxrwxrwx)           │
│ 소유자 (UID, GID)          │
│ 파일 크기                    │
│ 타임스탬프 (atime,mtime,ctime)│
│ 링크 카운트                  │
├─────────────────────────────┤
│ Direct Blocks (12개)        │ → 데이터 블록
│ Single Indirect Block       │ → 포인터 블록 → 데이터
│ Double Indirect Block       │ → 포인터 → 포인터 → 데이터
│ Triple Indirect Block       │ → 3단계 간접
└─────────────────────────────┘

1. 저널에 트랜잭션 시작 기록
2. 변경할 메타데이터/데이터를 저널에 기록
3. 저널에 트랜잭션 완료 기록
4. 실제 파일 시스템에 변경 적용
5. 저널에서 트랜잭션 제거

사용자 프로그램
    │
    ▼
VFS (Virtual File System)
    │
    ├──▶ ext4
    ├──▶ XFS
    ├──▶ NFS (네트워크)
    ├──▶ procfs (/proc)
    └──▶ sysfs (/sys)

# /proc — 프로세스 및 커널 정보
cat /proc/cpuinfo          # CPU 정보
cat /proc/meminfo          # 메모리 정보
cat /proc/1234/status      # PID 1234의 상태
cat /proc/1234/maps        # PID 1234의 메모리 맵
cat /proc/sys/vm/swappiness # 스왑 사용 정도 (0-100)

# /sys — 커널 및 디바이스 정보
ls /sys/class/net/         # 네트워크 인터페이스
cat /sys/block/sda/queue/scheduler  # I/O 스케줄러

// Blocking I/O — read()가 데이터 도착까지 블록
char buf[1024];
int n = read(fd, buf, sizeof(buf));  // 블로킹!

// Non-blocking I/O
int flags = fcntl(fd, F_GETFL, 0);
fcntl(fd, F_SETFL, flags | O_NONBLOCK);
int n = read(fd, buf, sizeof(buf));
if (n == -1 && errno == EAGAIN) {
    // 데이터 없음, 나중에 다시 시도
}

#include <sys/epoll.h>

int epoll_fd = epoll_create1(0);

struct epoll_event ev;
ev.events = EPOLLIN | EPOLLET;  // Edge-Triggered
ev.data.fd = listen_fd;
epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_fd, &ev);

struct epoll_event events[MAX_EVENTS];
while (1) {
    int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
    for (int i = 0; i < nfds; i++) {
        if (events[i].data.fd == listen_fd) {
            // 새 연결 수락
            int conn_fd = accept(listen_fd, ...);
            // conn_fd도 epoll에 등록
        } else {
            // 데이터 읽기/쓰기
            handle_client(events[i].data.fd);
        }
    }
}

┌─────────────────────────┐
│     User Space          │
│  ┌──────────────────┐   │
│  │ Submission Queue  │───┼───▶ 커널이 처리
│  │ (SQ)             │   │
│  └──────────────────┘   │
│  ┌──────────────────┐   │
│  │ Completion Queue  │◀──┼─── 커널이 완료 통지
│  │ (CQ)             │   │
│  └──────────────────┘   │
└─────────────────────────┘

전통적 방식 (4번 복사):
디스크 → 커널 버퍼 → 유저 버퍼 → 소켓 버퍼 → NIC

Zero-Copy (sendfile):
디스크 → 커널 버퍼 → NIC (2번 또는 그 이하)

#include <sys/sendfile.h>
// 파일을 소켓으로 직접 전송 (유저 공간 복사 없음)
sendfile(socket_fd, file_fd, NULL, file_size);

사용자 프로그램
    │
    │  write(fd, buf, count)
    ▼
┌─────────────────┐
│  C Library      │  ← glibc의 write() 래퍼
│  (glibc)        │
└────────┬────────┘
         │ syscall 명령어
         ▼
┌─────────────────┐
│  Kernel Space   │  ← sys_write() 커널 함수
│                 │
└─────────────────┘

# 프로세스의 시스템 콜 추적
strace -p 1234

# 특정 시스템 콜만 필터링
strace -e trace=open,read,write ./my_program

# 시간 정보 포함
strace -T -e trace=network ./my_server

# 통계 요약
strace -c ./my_program

# CPU 프로파일링
perf record -g ./my_program
perf report

# 캐시 미스 확인
perf stat -e cache-misses,cache-references ./my_program

# 특정 이벤트 카운팅
perf stat -e context-switches,cpu-migrations ./my_program

# bpftrace를 사용한 간단한 eBPF 프로그래밍

# 모든 시스템 콜 카운트
bpftrace -e 'tracepoint:raw_syscalls:sys_enter { @[comm] = count(); }'

# 프로세스별 파일 열기 추적
bpftrace -e 'tracepoint:syscalls:sys_enter_openat {
    printf("%s opened %s\n", comm, str(args->filename));
}'

# 디스크 I/O 지연 히스토그램
bpftrace -e 'tracepoint:block:block_rq_complete {
    @usecs = hist(args->nr_sector);
}'

# 새 PID namespace에서 셸 실행
sudo unshare --pid --mount-proc --fork /bin/bash
# 이 셸에서 ps aux를 하면 격리된 프로세스만 보임

# 새 네트워크 namespace
sudo ip netns add myns
sudo ip netns exec myns ip addr  # 격리된 네트워크 스택

# Docker의 cgroups 자원 제한 예시
docker run --cpus="0.5"           # CPU 50% 제한
docker run --memory="512m"        # 메모리 512MB 제한
docker run --pids-limit=100       # 최대 100개 프로세스
docker run --device-read-bps /dev/sda:10mb  # 디스크 읽기 제한

Container Layer (읽기/쓰기)
    │
    ▼
┌─────────────────────┐
│   OverlayFS         │
│   (merged view)     │
└─────────────────────┘
    │         │
    ▼         ▼
Image Layer 3  Image Layer 2  Image Layer 1 (읽기 전용)
(app code)     (dependencies)  (base OS)