Time Namespaces

CRIU 복원 흐름

/* CRIU 복원 시 time namespace 설정 순서 (개념 코드) */

/* 1. 새 time namespace 생성 */
unshare(CLONE_NEWTIME);

/* 2. 체크포인트 이미지에서 원본 시간 읽기 */
time64_t saved_monotonic = 500;  /* checkpoint 시점의 monotonic */
time64_t saved_boottime  = 500;  /* checkpoint 시점의 boottime */

/* 3. 현재 호스트 시간 확인 */
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);  /* 호스트: 8000s */

/* 4. 오프셋 계산 및 설정 */
int fd = open("/proc/self/timens_offsets", O_WRONLY);
char buf[128];
snprintf(buf, sizeof(buf), "monotonic %lld 0\n",
         saved_monotonic - now.tv_sec);  /* 500 - 8000 = -7500 */
write(fd, buf, strlen(buf));

snprintf(buf, sizeof(buf), "boottime %lld 0\n",
         saved_boottime - now.tv_sec);
write(fd, buf, strlen(buf));
close(fd);

/* 5. 복원 프로세스 생성 (새 time NS에 진입) */
pid_t child = fork();
if (child == 0) {
    /* 자식: clock_gettime(MONOTONIC) = 500s (원래 값) */
    restore_process_state(...);
}

Checkpoint/Restore 시나리오 상세

# 1. Source Host에서 컨테이너 실행 중
$ docker exec container1 cat /proc/uptime
500.123 1800.456

# 2. Checkpoint
$ sudo criu dump -t $(docker inspect -f '{{.State.Pid}}' container1) \
    -D /tmp/checkpoint --shell-job --tcp-established

# 3. 이미지 전송
$ rsync -avz /tmp/checkpoint/ dest-host:/tmp/checkpoint/

# 4. Destination Host에서 복원
$ sudo criu restore -D /tmp/checkpoint --shell-job --tcp-established

# 5. 복원 확인 -- uptime이 연속됨
$ docker exec container1 cat /proc/uptime
502.789 1802.345   # checkpoint 시점 + 경과 시간

CRIU 라이브 마이그레이션 연동

라이브 마이그레이션에서는 다운타임을 최소화하면서 프로세스/컨테이너를 다른 호스트로 이전합니다. Time namespace는 이 과정에서 시간 연속성을 보장하는 핵심 역할을 합니다.

CRIU 오프셋 계산 알고리즘

/* CRIU 복원 시 time namespace 오프셋 계산 알고리즘 */

struct criu_timens_data {
    struct timespec64 saved_monotonic;  /* checkpoint 시 값 */
    struct timespec64 saved_boottime;   /* checkpoint 시 값 */
    time64_t          transfer_delay;   /* 전송 지연 보정 */
};

int criu_setup_timens(struct criu_timens_data *data)
{
    struct timespec64 host_mono, host_boot;
    int64_t mono_offset, boot_offset;

    /* 1. 현재 호스트 시간 측정 */
    clock_gettime(CLOCK_MONOTONIC, &host_mono);
    clock_gettime(CLOCK_BOOTTIME, &host_boot);

    /* 2. 전송 지연 보정 포함 오프셋 계산 */
    mono_offset = (data->saved_monotonic.tv_sec +
                   data->transfer_delay) -
                  host_mono.tv_sec;

    boot_offset = (data->saved_boottime.tv_sec +
                   data->transfer_delay) -
                  host_boot.tv_sec;

    /* 3. unshare(CLONE_NEWTIME) */
    unshare(CLONE_NEWTIME);

    /* 4. 오프셋 설정 */
    int fd = open("/proc/self/timens_offsets", O_WRONLY);
    dprintf(fd, "monotonic %lld %ld\n",
            mono_offset, data->saved_monotonic.tv_nsec);
    dprintf(fd, "boottime %lld %ld\n",
            boot_offset, data->saved_boottime.tv_nsec);
    close(fd);

    /* 5. fork() 후 자식에서 프로세스 복원 */
    return 0;
}

/* 주의: 전송 지연(transfer_delay)은 pre-dump 기간과
 * 최종 dump~restore 사이의 시간을 포함해야 합니다.
 * 이 값이 정확하지 않으면 복원된 프로세스의 타이머가
 * 약간 빠르거나 느리게 동작할 수 있습니다. */

futex/timerfd/nanosleep 동작

timerfd와 time namespace

timerfd는 MONOTONIC/BOOTTIME 시계를 사용하는 파일 디스크립터 기반 타이머입니다. Time namespace에서 timerfd가 올바르게 동작하려면, 절대 시간 지정 시 오프셋 역변환이 필요합니다.

#include <sys/timerfd.h>

/* timerfd + time namespace 동작 */
int tfd = timerfd_create(CLOCK_MONOTONIC, 0);

/* 상대 시간: 오프셋 영향 없음 (5초 후) */
struct itimerspec rel = {
    .it_value = { .tv_sec = 5, .tv_nsec = 0 },
};
timerfd_settime(tfd, 0, &rel, NULL);
/* 정확히 5초 후 만료 (모든 NS에서 동일) */

/* 절대 시간: 오프셋 역변환 적용 */
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now); /* NS 시간: 6000s (호스트: 1000s, offset: +5000) */

struct itimerspec abs = {
    .it_value = { .tv_sec = now.tv_sec + 10, .tv_nsec = 0 },
    /* NS 시간 6010s 에 만료하고 싶음
     * 커널은 이를 호스트 시간 1010s로 역변환 (6010 - 5000 = 1010)
     * 실제로 호스트 monotonic이 1010에 도달하면 만료 */
};
timerfd_settime(tfd, TFD_TIMER_ABSTIME, &abs, NULL);

futex와 time namespace

FUTEX_WAIT_BITSET에 FUTEX_CLOCK_REALTIME이 아닌 MONOTONIC 기반 절대 타임아웃을 사용하면 time namespace 오프셋이 적용됩니다.

/* futex의 time namespace 영향 */

/* 상대 타임아웃: 영향 없음 */
struct timespec timeout = { .tv_sec = 5, .tv_nsec = 0 };
futex(addr, FUTEX_WAIT, val, &timeout, NULL, 0);
/* 정확히 5초 대기 */

/* 절대 타임아웃 (CLOCK_MONOTONIC): 오프셋 적용 */
struct timespec abs_time;
clock_gettime(CLOCK_MONOTONIC, &abs_time);
abs_time.tv_sec += 5;
futex(addr, FUTEX_WAIT_BITSET, val, &abs_time, NULL, FUTEX_BITSET_MATCH_ANY);
/* 커널이 절대 시간을 호스트 시간으로 역변환 후 대기 */

nanosleep/clock_nanosleep

POSIX 타이머와 time namespace

timer_create()로 생성한 POSIX 타이머도 time namespace의 영향을 받습니다. 절대 시간 지정 시 오프셋 역변환이 적용되며, 커널 내부에서 timens_ktime_to_host()가 호출됩니다.

/* POSIX 타이머 + time namespace 동작 예시 */
#include <signal.h>
#include <time.h>

timer_t timerid;
struct sigevent sev = {
    .sigev_notify = SIGEV_SIGNAL,
    .sigev_signo = SIGALRM,
};

/* MONOTONIC 기반 타이머 생성 */
timer_create(CLOCK_MONOTONIC, &sev, &timerid);

/* 상대 시간: 오프셋 영향 없음 */
struct itimerspec its_rel = {
    .it_value = { .tv_sec = 10, .tv_nsec = 0 },
    .it_interval = { .tv_sec = 1, .tv_nsec = 0 },
};
timer_settime(timerid, 0, &its_rel, NULL);
/* 정확히 10초 후 첫 번째 만료, 이후 1초 간격 */

/* 절대 시간: 오프셋 역변환 적용 */
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);

struct itimerspec its_abs = {
    .it_value = {
        .tv_sec = now.tv_sec + 30,  /* NS 기준 30초 후 */
        .tv_nsec = 0,
    },
};
timer_settime(timerid, TIMER_ABSTIME, &its_abs, NULL);
/* 커널이 NS 시간을 호스트 시간으로 역변환 후
 * 호스트 MONOTONIC 기준으로 hrtimer 설정 */

타이머 커널 경로 분석

/* do_timer_settime() 내 time namespace 처리
 * kernel/time/posix-timers.c (간략화) */
static int do_timer_settime(timer_t timer_id,
                           int tmr_flags,
                           struct itimerspec64 *new_spec64,
                           struct itimerspec64 *old_spec64)
{
    struct k_itimer *timr;

    timr = lock_timer(timer_id, &flags);

    /* 절대 시간 + MONOTONIC/BOOTTIME이면 오프셋 역변환 */
    if (tmr_flags & TIMER_ABSTIME) {
        ktime_t exp = timespec64_to_ktime(new_spec64->it_value);
        /* NS 시간 → 호스트 시간 변환 */
        exp = timens_ktime_to_host(timr->it_clock, exp);
        new_spec64->it_value = ktime_to_timespec64(exp);
    }

    /* hrtimer에 호스트 시간 기준으로 설정 */
    common_timer_set(timr, tmr_flags, new_spec64);

    return 0;
}

futex2와 time namespace

Linux 5.16에서 도입된 futex_waitv() 시스템 콜도 time namespace를 지원합니다. 절대 타임아웃 지정 시 오프셋 역변환이 적용됩니다.

/* futex_waitv + time namespace 동작 */
struct futex_waitv waiters[2] = {
    { .val = 0, .uaddr = (__u64)&futex1,
      .flags = FUTEX_32 | FUTEX_PRIVATE_FLAG },
    { .val = 0, .uaddr = (__u64)&futex2,
      .flags = FUTEX_32 | FUTEX_PRIVATE_FLAG },
};

struct timespec timeout;
clock_gettime(CLOCK_MONOTONIC, &timeout);
timeout.tv_sec += 10;  /* NS 시간 기준 10초 후 */

/* futex_waitv는 절대 시간 지정 시
 * 커널 내부에서 timens_ktime_to_host() 호출 */
syscall(SYS_futex_waitv, waiters, 2,
        0, &timeout, CLOCK_MONOTONIC);

시간 네임스페이스와 컨테이너 런타임

컨테이너 런타임별 지원 현황

OCI Runtime Spec 통합

/* OCI Runtime Spec에서 time namespace 설정
 * config.json (JSON 형식) */

# OCI config.json 예시 (time namespace 포함)
# {
#   "linux": {
#     "namespaces": [
#       { "type": "pid" },
#       { "type": "network" },
#       { "type": "mount" },
#       { "type": "ipc" },
#       { "type": "uts" },
#       { "type": "cgroup" },
#       { "type": "time" }
#     ],
#     "timeOffsets": {
#       "monotonic": { "secs": 1000, "nanosecs": 0 },
#       "boottime":  { "secs": 2000, "nanosecs": 0 }
#     }
#   }
# }

# runc에서 직접 실행
$ sudo runc create --bundle /path/to/bundle container1
$ sudo runc start container1

# 컨테이너 내부에서 확인
$ runc exec container1 cat /proc/uptime
1000.123 ...  # monotonic offset 반영

LXC/LXD에서 time namespace

# LXC 설정 파일에서 time namespace 활성화
# /var/lib/lxc/mycontainer/config
lxc.namespace.time = ""

# LXD에서 time namespace 사용
$ lxc config set mycontainer raw.lxc "lxc.namespace.time ="
$ lxc restart mycontainer

# 확인
$ lxc exec mycontainer -- cat /proc/uptime
$ lxc exec mycontainer -- readlink /proc/self/ns/time

Kubernetes Checkpoint/Restore

Kubernetes 1.25부터 컨테이너 체크포인트 기능이 알파로 도입되었습니다. CRI (Container Runtime Interface)를 통해 CRIU를 호출하며, time namespace 오프셋은 자동으로 처리됩니다.

# Kubernetes 컨테이너 체크포인트 (알파 기능, 1.25+)
# Feature gate 활성화 필요: ContainerCheckpoint=true

# 1. 체크포인트 생성
$ kubectl checkpoint pod/myapp --container=main \
    --timeout=30s

# 2. 체크포인트 이미지 확인
$ ls /var/lib/kubelet/checkpoints/
checkpoint-myapp-main-2024-01-15T10:30:00Z.tar

# 3. 다른 노드에서 복원 (Pod 생성 시 지정)
# apiVersion: v1
# kind: Pod
# metadata:
#   annotations:
#     io.kubernetes.cri.checkpoint-restore: "true"
# spec:
#   containers:
#   - name: main
#     image: checkpoint-myapp-main:latest

# crictl을 통한 직접 체크포인트 (CRI 레벨)
$ crictl checkpoint --export=/tmp/cp.tar $CONTAINER_ID
$ crictl create --restore=/tmp/cp.tar $POD_ID config.json

예제 코드

Time Namespace 생성

#define _GNU_SOURCE
#include <sched.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sys/wait.h>

void print_clocks(const char *label)
{
    struct timespec mono, boot;
    clock_gettime(CLOCK_MONOTONIC, &mono);
    clock_gettime(CLOCK_BOOTTIME, &boot);
    printf("[%s] MONOTONIC=%ld.%09ld  BOOTTIME=%ld.%09ld\n",
           label, mono.tv_sec, mono.tv_nsec,
           boot.tv_sec, boot.tv_nsec);
}

int main(void)
{
    print_clocks("Parent before");

    /* 새 Time Namespace 생성 */
    if (unshare(CLONE_NEWTIME) == -1) {
        perror("unshare(CLONE_NEWTIME)");
        return 1;
    }

    /* 오프셋 설정: MONOTONIC +1000초, BOOTTIME +2000초 */
    int fd = open("/proc/self/timens_offsets", O_WRONLY);
    if (fd < 0) { perror("open"); return 1; }

    dprintf(fd, "monotonic %d %d\n", 1000, 0);
    dprintf(fd, "boottime %d %d\n", 2000, 0);
    close(fd);

    print_clocks("Parent after offset");
    /* 부모는 여전히 기존 NS: 값 변화 없음 */

    pid_t pid = fork();
    if (pid == -1) { perror("fork"); return 1; }

    if (pid == 0) {
        /* 자식: 새 time NS에 진입 */
        print_clocks("Child (new NS)");
        /* MONOTONIC +1000s, BOOTTIME +2000s 적용됨 */
        _exit(0);
    }

    waitpid(pid, NULL, 0);
    print_clocks("Parent after child");
    return 0;
}

/* 예상 출력:
[Parent before]      MONOTONIC=1234.000000000  BOOTTIME=1234.000000000
[Parent after offset] MONOTONIC=1234.000100000  BOOTTIME=1234.000100000
[Child (new NS)]     MONOTONIC=2234.000200000  BOOTTIME=3234.000200000
[Parent after child] MONOTONIC=1234.000300000  BOOTTIME=1234.000300000
*/

nsenter/unshare 명령행 예제

# 호스트 현재 시간 확인
$ cat /proc/uptime
12345.67 48000.89

# Time namespace 생성 + 오프셋 설정 + 진입
$ sudo unshare --time --fork --map-current-user /bin/bash -c '
  echo "monotonic 86400 0" > /proc/self/timens_offsets
  echo "boottime 86400 0" >> /proc/self/timens_offsets
  exec /bin/bash
'

# 새 namespace에서 확인 (+86400초 = +1일)
$ cat /proc/uptime
98745.67 ...

# namespace ID 확인
$ ls -l /proc/self/ns/time
lrwxrwxrwx ... /proc/self/ns/time -> 'time:[4026532XXX]'

# 다른 터미널에서 nsenter로 같은 namespace 진입
$ sudo nsenter -T -t $PID /bin/bash
$ cat /proc/uptime    # 같은 오프셋 적용

Python에서 Time Namespace 활용

#!/usr/bin/env python3
"""time_namespace.py -- Python에서 time namespace 생성 및 검증"""

import ctypes
import os
import time
import struct

# libc 함수 바인딩
libc = ctypes.CDLL("libc.so.6", use_errno=True)

# clone(2) 플래그
CLONE_NEWTIME = 0x00000080

# unshare(2) 호출
def unshare(flags):
    ret = libc.unshare(flags)
    if ret != 0:
        errno = ctypes.get_errno()
        raise OSError(errno, os.strerror(errno))

def get_monotonic():
    return time.clock_gettime(time.CLOCK_MONOTONIC)

def get_boottime():
    return time.clock_gettime(time.CLOCK_BOOTTIME)

def main():
    print(f"Before unshare:")
    print(f"  MONOTONIC = {get_monotonic():.9f}")
    print(f"  BOOTTIME  = {get_boottime():.9f}")

    # 새 time namespace 생성 (현재 프로세스는 영향 없음)
    unshare(CLONE_NEWTIME)

    # 오프셋 설정: +1000초 monotonic, +2000초 boottime
    with open("/proc/self/timens_offsets", "w") as f:
        f.write("monotonic 1000 0\n")
        f.write("boottime 2000 0\n")

    # fork()로 자식이 새 NS에 진입
    pid = os.fork()
    if pid == 0:
        # 자식: 새 time namespace
        print(f"Child (new NS):")
        print(f"  MONOTONIC = {get_monotonic():.9f}  (+1000s)")
        print(f"  BOOTTIME  = {get_boottime():.9f}  (+2000s)")

        # 오프셋 확인
        with open("/proc/self/timens_offsets") as f:
            print(f"  Offsets: {f.read().strip()}")
        os._exit(0)
    else:
        os.waitpid(pid, 0)
        print(f"Parent (still init NS):")
        print(f"  MONOTONIC = {get_monotonic():.9f}")

if __name__ == "__main__":
    main()

Go에서 Time Namespace 활용

// timens_example.go -- Go에서 time namespace 생성
package main

import (
    "fmt"
    "os"
    "os/exec"
    "syscall"
    "time"
)

const CLONE_NEWTIME = 0x00000080

func getMonotonic() time.Duration {
    var ts syscall.Timespec
    syscall.ClockGettime(syscall.CLOCK_MONOTONIC, &ts)
    return time.Duration(ts.Sec)*time.Second +
           time.Duration(ts.Nsec)*time.Nanosecond
}

func main() {
    if os.Getenv("IN_TIMENS") == "1" {
        // 자식 프로세스: 새 time NS 내부에서 실행 중
        fmt.Printf("Child MONOTONIC: %v\n", getMonotonic())
        return
    }

    fmt.Printf("Parent MONOTONIC: %v\n", getMonotonic())

    // 자식 프로세스를 새 time namespace에서 실행
    cmd := exec.Command("/proc/self/exe")
    cmd.Env = append(os.Environ(), "IN_TIMENS=1")
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    cmd.SysProcAttr = &syscall.SysProcAttr{
        Cloneflags: CLONE_NEWTIME,
    }

    // 오프셋은 /proc/[child-pid]/timens_offsets에 설정해야 함
    // SysProcAttr에서는 직접 지원하지 않으므로
    // 별도 wrapper 스크립트나 helper 프로세스 필요

    if err := cmd.Run(); err != nil {
        fmt.Fprintf(os.Stderr, "Error: %v\n", err)
        os.Exit(1)
    }
}

커널 설정

# Time Namespace 필수
CONFIG_TIME_NS=y           # Time Namespace 지원 (Linux 5.6+)

# 관련 namespace (일반적으로 함께 활성화)
CONFIG_UTS_NS=y
CONFIG_IPC_NS=y
CONFIG_PID_NS=y
CONFIG_NET_NS=y
CONFIG_USER_NS=y
CONFIG_CGROUP_NS=y
CONFIG_MNT_NS=y

# vDSO 지원 (time NS에 필수)
CONFIG_GENERIC_VDSO_TIME_NS=y  # 아키텍처별 vDSO time NS 지원 */

아키텍처별 지원 현황

procfs/sysfs 인터페이스

# namespace ID 확인
$ ls -l /proc/self/ns/time
lrwxrwxrwx 1 user user 0 ... /proc/self/ns/time -> 'time:[4026531834]'

# 자식용 namespace 확인 (unshare 후 달라짐)
$ ls -l /proc/self/ns/time_for_children

# 오프셋 확인
$ cat /proc/self/timens_offsets
monotonic           0         0
boottime            0         0

# 특정 PID의 time NS 확인
$ readlink /proc/1234/ns/time
time:[4026532001]

제약사항

CLOCK_REALTIME 격리 불가

CLOCK_REALTIME은 time namespace의 영향을 받지 않습니다. 이는 의도된 설계입니다.

VDSO 페이지 전환 제약

실행 중인 프로세스의 VDSO 페이지 매핑을 안전하게 교체할 수 없기 때문에, setns()로 다른 time namespace에 직접 진입하는 것은 불가능합니다. 반드시 fork()를 통해 자식 프로세스가 진입해야 합니다.

/* setns()로 time NS 직접 진입 시도 -- 동작하지 않음 */
int ns_fd = open("/proc/1234/ns/time", O_RDONLY);
int ret = setns(ns_fd, CLONE_NEWTIME);
/* ret == -1, errno == EINVAL
 * setns()는 time_ns_for_children만 변경
 * 실제 전환은 fork() 후 자식에서 발생 */

Frozen Offset

# 오프셋 동결 후 쓰기 시도
$ echo "monotonic 2000 0" > /proc/self/timens_offsets
bash: /proc/self/timens_offsets: Permission denied
# errno: EACCES (frozen_offsets == true)

운영 패턴

컨테이너별 독립 uptime

#!/bin/bash
# 컨테이너별 독립 uptime 구현

# 현재 호스트 monotonic 확인
HOST_MONO=$(awk '{print int($1)}' /proc/uptime)

# 컨테이너에서 0부터 시작하는 uptime 제공
OFFSET="-${HOST_MONO}"

sudo unshare --time --fork /bin/bash -c "
  echo 'monotonic ${OFFSET} 0' > /proc/self/timens_offsets
  echo 'boottime ${OFFSET} 0' >> /proc/self/timens_offsets
  exec /bin/bash
"

# 컨테이너 내부: /proc/uptime = 0 부터 시작

모니터링 영향

CI/CD 파이프라인에서 시간 테스트

#!/bin/bash
# ci-time-test.sh -- CI 파이프라인에서 시간 의존 테스트 자동화
# Time namespace를 활용하여 시간 이동 테스트 수행

set -euo pipefail

# 테스트 매트릭스: 다양한 시간 오프셋으로 테스트
declare -a OFFSETS=(
    "0"             # 기본 (오프셋 없음)
    "86400"         # +1일
    "2592000"       # +30일
    "31536000"      # +1년
    "-3600"         # -1시간 (과거)
)

PASS=0
FAIL=0

for offset in "${OFFSETS[@]}"; do
    echo "=== Testing with monotonic offset: ${offset}s ==="

    if sudo unshare --time --fork /bin/bash -c "
        if [ '${offset}' != '0' ]; then
            echo 'monotonic ${offset} 0' > /proc/self/timens_offsets
            echo 'boottime ${offset} 0' >> /proc/self/timens_offsets
        fi
        exec ./run_tests.sh --time-offset=${offset}
    "; then
        echo "PASS: offset=${offset}"
        PASS=$((PASS + 1))
    else
        echo "FAIL: offset=${offset}"
        FAIL=$((FAIL + 1))
    fi
done

echo "Results: ${PASS} passed, ${FAIL} failed"
[ "${FAIL}" -eq 0 ]

멀티 테넌트 시간 관리

여러 컨테이너/테넌트가 각각 독립된 시간을 갖도록 구성하는 패턴입니다.

#!/bin/bash
# multi-tenant-time.sh -- 테넌트별 독립 시간 할당

create_tenant_ns() {
    local tenant_id="$1"
    local mono_offset="$2"
    local boot_offset="$3"

    echo "[${tenant_id}] Creating time NS: mono=${mono_offset}s, boot=${boot_offset}s"

    sudo unshare --time --fork /bin/bash -c "
        echo 'monotonic ${mono_offset} 0' > /proc/self/timens_offsets
        echo 'boottime ${boot_offset} 0' >> /proc/self/timens_offsets

        # PID 파일 생성 (다른 프로세스가 nsenter로 진입 가능)
        echo \$\$ > /run/tenant-${tenant_id}.pid

        # 테넌트 서비스 실행
        exec /usr/bin/tenant-service --id=${tenant_id}
    " &
}

# 테넌트별 시간 격리
# 테넌트 A: 10일 전 uptime 시뮬레이션 (-864000초)
create_tenant_ns "tenant-a" "-864000" "-864000"

# 테넌트 B: 기본 호스트 시간
create_tenant_ns "tenant-b" "0" "0"

# 테넌트 C: 미래 시간 (+30일)
create_tenant_ns "tenant-c" "2592000" "2592000"

wait

안전한 오프셋 계산 패턴

#define _GNU_SOURCE
#include <stdio.h>
#include <time.h>
#include <sched.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>

/*
 * 안전한 오프셋 계산:
 * 결과 시간이 음수가 되지 않도록 검증
 */
int safe_set_timens_offset(
    long target_mono_sec,   /* 원하는 monotonic 시작값 */
    long target_boot_sec    /* 원하는 boottime 시작값 */
)
{
    struct timespec cur_mono, cur_boot;
    clock_gettime(CLOCK_MONOTONIC, &cur_mono);
    clock_gettime(CLOCK_BOOTTIME, &cur_boot);

    long mono_offset = target_mono_sec - cur_mono.tv_sec;
    long boot_offset = target_boot_sec - cur_boot.tv_sec;

    /* 결과가 음수가 되지 않도록 검증 */
    if (cur_mono.tv_sec + mono_offset < 0) {
        fprintf(stderr,
            "Warning: mono offset %ld would make time negative, clamping to -%ld\n",
            mono_offset, cur_mono.tv_sec);
        mono_offset = -cur_mono.tv_sec;
    }
    if (cur_boot.tv_sec + boot_offset < 0) {
        fprintf(stderr,
            "Warning: boot offset %ld would make time negative, clamping to -%ld\n",
            boot_offset, cur_boot.tv_sec);
        boot_offset = -cur_boot.tv_sec;
    }

    int fd = open("/proc/self/timens_offsets", O_WRONLY);
    if (fd < 0) {
        if (errno == EACCES)
            fprintf(stderr, "Error: offsets already frozen\n");
        return -1;
    }

    dprintf(fd, "monotonic %ld 0\n", mono_offset);
    dprintf(fd, "boottime %ld 0\n", boot_offset);
    close(fd);

    printf("Set offsets: mono=%+ld  boot=%+ld\n",
           mono_offset, boot_offset);
    return 0;
}

성능 분석

vDSO 오프셋 적용 오버헤드

Time namespace가 활성화되면 clock_gettime()의 vDSO 경로에서 오프셋 덧셈이 추가됩니다. 이 연산의 오버헤드를 측정합니다.

/*
 * timens_vdso_bench.c -- vDSO clock_gettime 벤치마크
 * 컴파일: gcc -O2 -o timens_bench timens_vdso_bench.c
 */
#define _GNU_SOURCE
#include <stdio.h>
#include <time.h>
#include <stdint.h>

#define ITERATIONS  10000000

static inline uint64_t rdtsc(void)
{
    uint32_t lo, hi;
    __asm__ volatile ("rdtsc" : "=a"(lo), "=d"(hi));
    return ((uint64_t)hi << 32) | lo;
}

int main(void)
{
    struct timespec ts;
    uint64_t start, end;
    int clocks[] = { CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW,
                     CLOCK_BOOTTIME, CLOCK_REALTIME };
    const char *names[] = { "MONOTONIC", "MONOTONIC_RAW",
                             "BOOTTIME",  "REALTIME" };

    for (int c = 0; c < 4; c++) {
        start = rdtsc();
        for (int i = 0; i < ITERATIONS; i++)
            clock_gettime(clocks[c], &ts);
        end = rdtsc();

        printf("%-18s  %8.1f cycles/call  (%llu total cycles)\n",
               names[c],
               (double)(end - start) / ITERATIONS,
               (unsigned long long)(end - start));
    }
    return 0;
}

메모리 오버헤드

확장성 테스트

#!/bin/bash
# timens_scalability.sh -- Time namespace 확장성 벤치마크

MAX_NS=500
echo "Creating ${MAX_NS} time namespaces..."

# 메모리 사용량 기준선
MEM_BEFORE=$(awk '/MemAvailable/ {print $2}' /proc/meminfo)

PIDS=()
for i in $(seq 1 $MAX_NS); do
    sudo unshare --time --fork /bin/bash -c "
        echo 'monotonic ${i}00 0' > /proc/self/timens_offsets
        echo 'boottime ${i}00 0' >> /proc/self/timens_offsets
        exec sleep 300
    " &
    PIDS+=($!)
done

sleep 2

MEM_AFTER=$(awk '/MemAvailable/ {print $2}' /proc/meminfo)
MEM_USED=$(( (MEM_BEFORE - MEM_AFTER) ))

echo "Created ${MAX_NS} namespaces"
echo "Memory used: ${MEM_USED} KB ($(( MEM_USED / MAX_NS )) KB/ns)"
echo "Active time namespaces:"
sudo lsns -t time | wc -l

# 정리
for pid in "${PIDS[@]}"; do kill $pid 2>/dev/null; done
wait

타이머 정확도 영향

Time namespace의 오프셋은 ktime_add()으로 적용되며, 타이머 정확도 자체에는 영향을 미치지 않습니다. 다만 VVAR seqcount 경쟁(contention) 시 읽기 재시도가 발생할 수 있습니다.

디버깅

Time Namespace 확인

# 프로세스의 time namespace 확인
$ ls -l /proc/$$/ns/time
lrwxrwxrwx 1 user user 0 ... /proc/12345/ns/time -> 'time:[4026531834]'

# init namespace인지 확인 (4026531834는 보통 init)
$ readlink /proc/1/ns/time   # init 프로세스의 time NS
time:[4026531834]

# 현재 프로세스가 init NS에 있는지 비교
$ if [ "$(readlink /proc/self/ns/time)" = "$(readlink /proc/1/ns/time)" ]; then
    echo "init time namespace"
  else
    echo "custom time namespace"
  fi

# 오프셋 확인
$ cat /proc/self/timens_offsets
monotonic       1000          0
boottime        2000  500000000

# 시간 비교 (호스트 vs NS)
$ nsenter -T -t 1 /usr/bin/cat /proc/uptime   # 호스트 시간
$ cat /proc/uptime                              # NS 시간

Tracing

# ftrace로 timens 관련 함수 추적
# echo 'timens_*' > /sys/kernel/debug/tracing/set_ftrace_filter
# echo function > /sys/kernel/debug/tracing/current_tracer
# echo 1 > /sys/kernel/debug/tracing/tracing_on

# bpftrace로 오프셋 적용 추적
$ sudo bpftrace -e '
kprobe:timens_add_monotonic {
    printf("pid=%d comm=%s\n", pid, comm);
}'

# strace로 clock_gettime 확인
$ strace -e trace=clock_gettime -p 1234 2>&1 | head
clock_gettime(CLOCK_MONOTONIC, {tv_sec=6234, tv_nsec=...}) = 0

디버깅 체크리스트

고급 bpftrace 추적

#!/usr/bin/env bpftrace
# timens_offset_trace.bt - Time namespace 오프셋 적용 상세 추적

# 오프셋 적용 추적 (monotonic)
$ sudo bpftrace -e '
kprobe:timens_add_monotonic {
    @mono[comm, pid] = count();
    printf("%-16s pid=%-6d applying monotonic offset\n", comm, pid);
}

kprobe:timens_add_boottime {
    @boot[comm, pid] = count();
    printf("%-16s pid=%-6d applying boottime offset\n", comm, pid);
}

kretprobe:timens_ktime_to_host {
    printf("%-16s pid=%-6d ns->host ktime conversion ret=%lld\n",
           comm, pid, retval);
}

END {
    printf("\n=== Monotonic offset calls ===\n");
    print(@mono);
    printf("\n=== Boottime offset calls ===\n");
    print(@boot);
}
'

# vDSO 경로 vs syscall 경로 비교 추적
$ sudo bpftrace -e '
tracepoint:syscalls:sys_enter_clock_gettime {
    @syscall_path[comm, pid, args->which_clock] = count();
}

kprobe:do_clock_gettime {
    @kernel_path[comm, pid] = count();
}

interval:s:5 {
    printf("\n=== syscall fallback (vDSO miss) ===\n");
    print(@syscall_path);
    printf("\n=== kernel path ===\n");
    print(@kernel_path);
    clear(@syscall_path);
    clear(@kernel_path);
}
'

perf 기반 성능 분석

# clock_gettime syscall 오버헤드 측정 (vDSO bypass 시)
$ sudo perf stat -e 'syscalls:sys_enter_clock_gettime' \
    -e 'syscalls:sys_exit_clock_gettime' \
    -p $PID -- sleep 10

# vDSO 내부 실행 시간 프로파일링
$ sudo perf record -e cpu-clock -g -p $PID -- sleep 5
$ sudo perf report --no-children --sort=symbol | grep -i vdso

# VVAR 페이지 접근 패턴 확인
$ sudo perf mem record -p $PID -- sleep 5
$ sudo perf mem report | grep vvar

# time namespace 전환 시 TLB flush 영향 측정
$ sudo perf stat -e 'dTLB-load-misses,dTLB-store-misses,iTLB-load-misses' \
    -p $PID -- sleep 10

VVAR 페이지 매핑 디버깅

# 프로세스의 VVAR/VDSO 매핑 확인
$ cat /proc/$PID/maps | grep -E '(vvar|vdso)'
7ffce16f5000-7ffce16f9000 r--p 00000000 00:00 0  [vvar]
7ffce16f9000-7ffce16fb000 r-xp 00000000 00:00 0  [vdso]

# 두 프로세스의 VVAR 페이지가 다른 물리 주소인지 확인
# (다른 time NS에 속하면 별도 VVAR 페이지 사용)
$ sudo cat /proc/$PID1/pagemap | xxd | head
$ sudo cat /proc/$PID2/pagemap | xxd | head

# VVAR 페이지 크기 확인 (time NS 활성 시 추가 페이지 할당됨)
$ sudo cat /proc/$PID/smaps | grep -A 15 vvar
Size:                 16 kB    # 일반: 16KB, time NS: 추가 페이지
Rss:                  16 kB
Pss:                   4 kB
AnonHugePages:         0 kB

# systemtap으로 vvar_fault 추적 (아키텍처 디버깅용)
# stap -e 'probe kernel.function("vvar_fault") {
#     printf("%s(%d): vvar fault vmf->pgoff=%d\n",
#            execname(), pid(), $vmf->pgoff)
# }'

디버깅 도구 요약

보안 고려사항

공격 표면 분석

보안 강화 설정

# 1. time namespace 생성 수 제한 (sysctl)
$ sudo sysctl -w user.max_time_namespaces=10
# 시스템 전체에서 최대 10개 time NS만 허용

# 2. seccomp으로 "시간 변경" syscall 제한
# Docker seccomp 프로파일 예시
# {
#   "names": ["clock_settime", "settimeofday", "adjtimex"],
#   "action": "SCMP_ACT_ERRNO",
#   "errnoRet": 1
# }
# 주의: 관측용 clock_gettime()/gettimeofday()는 vDSO 경로 때문에
# seccomp만으로 완전 차단되지 않을 수 있음

# 3. LSM (AppArmor/SELinux) 정책
# AppArmor: time namespace 생성 차단
# deny unshare w,  # CLONE_NEWTIME 포함

# SELinux: time namespace 접근 제어
# allow container_t container_t : nstype { time_ns_create };

# 4. audit 로그로 time NS 생성 추적
$ sudo auditctl -a always,exit -F arch=b64 \
    -S unshare -F a0=0x80 -k timens_create
# 0x80 = CLONE_NEWTIME

# 5. 시간 NS 현황 모니터링
$ sudo lsns -t time
        NS TYPE  NPROCS   PID USER    COMMAND
4026531834 time     100     1 root    /sbin/init
4026532001 time       5  1234 user    /usr/bin/app

보안 모범 사례

실전 활용

컨테이너 라이브 마이그레이션

# 1. Source Host에서 checkpoint
$ sudo criu dump -t $CONTAINER_PID -D /tmp/checkpoint \
    --shell-job --tcp-established --ext-unix-sk

# 2. Destination Host로 checkpoint 이미지 전송
$ rsync -avz /tmp/checkpoint/ dest:/tmp/checkpoint/

# 3. Destination Host에서 restore (time namespace 자동 설정)
$ sudo criu restore -D /tmp/checkpoint \
    --shell-job --tcp-established --ext-unix-sk

시간 의존 애플리케이션 테스트

#!/bin/bash
# 미래 시간 시뮬레이션 (uptime +30일)
OFFSET=$((30 * 86400))  # 2,592,000초

sudo unshare --time --fork /bin/bash -c "
  echo 'monotonic ${OFFSET} 0' > /proc/self/timens_offsets
  echo 'boottime ${OFFSET} 0' >> /proc/self/timens_offsets
  exec /bin/bash -c '
    echo \"Simulated uptime: $(cat /proc/uptime)\"
    ./myapp --test-long-running
  '
"

Kubernetes/Docker 통합

# Docker: time namespace 사용 (runc 지원 시)
$ docker run --security-opt=time-namespace=host alpine cat /proc/uptime

# 현재 Docker/containerd는 time NS를 기본 활성화하지 않음
# CRIU를 통한 checkpoint/restore에서 자동 설정

# Kubernetes: CRIU 기반 체크포인트 (실험적)
$ kubectl checkpoint pod/my-pod --container=my-container \
    --export=/tmp/checkpoint

분산 시스템 시간 불일치 시뮬레이션

Time namespace를 활용하여 분산 시스템에서 발생할 수 있는 시간 스큐(skew)를 안전하게 시뮬레이션할 수 있습니다.

#!/bin/bash
# clock-skew-test.sh -- 분산 시스템 clock skew 시뮬레이션
# 3개 노드가 각각 다른 시간 오프셋을 갖는 환경 구성

set -euo pipefail

# 노드별 시간 스큐 (초 단위)
NODE_OFFSETS=(
    0       # 노드 1: 기준 시간
    5       # 노드 2: +5초 앞서감
    -3      # 노드 3: -3초 뒤처짐
)

echo "=== Clock Skew Simulation ==="
echo "Testing Raft consensus with clock offsets: ${NODE_OFFSETS[*]}"

for i in 0 1 2; do
    offset=${NODE_OFFSETS[$i]}
    port=$((8000 + i))

    sudo unshare --time --fork /bin/bash -c "
        if [ '${offset}' != '0' ]; then
            echo 'monotonic ${offset} 0' > /proc/self/timens_offsets
            echo 'boottime ${offset} 0' >> /proc/self/timens_offsets
        fi
        exec ./raft-node --id=${i} --port=${port} --peers=localhost:8000,localhost:8001,localhost:8002
    " &

    echo "Node ${i}: port=${port}, offset=${offset}s, pid=$!"
done

echo "Waiting for consensus test..."
sleep 30

# 결과 수집
echo "=== Test Results ==="
curl -s localhost:8000/status
curl -s localhost:8001/status
curl -s localhost:8002/status

재현 가능한 버그 디버깅

시간 의존 버그를 재현하기 위해 특정 uptime을 시뮬레이션하는 패턴입니다. 예를 들어 "49.7일 후 발생하는 jiffy 래핑 버그"를 테스트할 수 있습니다.

#!/bin/bash
# reproduce-time-bug.sh -- 특정 uptime에서 발생하는 버그 재현

# 32비트 jiffy 래핑 시점 (49.7일 = 4,294,967 초)
TARGET_UPTIME=4294960  # 래핑 7초 전

# 현재 uptime 확인
CURRENT=$(awk '{print int($1)}' /proc/uptime)
OFFSET=$((TARGET_UPTIME - CURRENT))

echo "Current uptime: ${CURRENT}s"
echo "Target uptime:  ${TARGET_UPTIME}s"
echo "Offset needed:  +${OFFSET}s"

sudo unshare --time --fork /bin/bash -c "
    echo 'monotonic ${OFFSET} 0' > /proc/self/timens_offsets
    echo 'boottime ${OFFSET} 0' >> /proc/self/timens_offsets
    exec /bin/bash -c '
        echo \"Simulated uptime: \$(cat /proc/uptime)\"
        echo \"Monitoring for jiffy wrap bug...\"
        ./buggy-driver-test --watch-jiffies --duration=15
    '
"

모니터링 대시보드 통합

#!/bin/bash
# timens-monitor.sh -- 시스템 내 모든 time namespace 모니터링

echo "=== Time Namespace Monitor ==="
printf "%-8s %-20s %-15s %-12s %-12s\n" \
    "PID" "COMMAND" "NS_ID" "MONO_OFFSET" "BOOT_OFFSET"
echo "-------------------------------------------------------------------"

for pid in $(ls /proc/ | grep -E '^[0-9]+$'); do
    [ -r /proc/$pid/ns/time ] || continue

    ns_id=$(readlink /proc/$pid/ns/time 2>/dev/null) || continue
    comm=$(cat /proc/$pid/comm 2>/dev/null) || continue
    offsets=$(cat /proc/$pid/timens_offsets 2>/dev/null) || continue

    # init NS는 건너뜀
    init_ns=$(readlink /proc/1/ns/time 2>/dev/null)
    [ "$ns_id" = "$init_ns" ] && continue

    mono=$(echo "$offsets" | awk '/monotonic/ {printf "%d.%09d", $2, $3}')
    boot=$(echo "$offsets" | awk '/boottime/ {printf "%d.%09d", $2, $3}')

    printf "%-8s %-20s %-15s %-12s %-12s\n" \
        "$pid" "$comm" "$ns_id" "$mono" "$boot"
done

echo "-------------------------------------------------------------------"
echo "Total time namespaces: $(sudo lsns -t time --no-headings | wc -l)"

timens_offsets 구조 심화

timens_offsets 구조체는 Time Namespace의 핵심 데이터입니다. 이 구조체가 커널 내부에서 어떻게 초기화되고, 검증되며, 적용되는지 세부적으로 분석합니다.

오프셋 초기화 경로

/* kernel/time/namespace.c -- clone_time_ns() */
static struct time_namespace *clone_time_ns(
    struct user_namespace *user_ns,
    struct time_namespace *old_ns)
{
    struct time_namespace *ns;

    ns = kmalloc(sizeof(*ns), GFP_KERNEL_ACCOUNT);
    if (!ns)
        return ERR_PTR(-ENOMEM);

    refcount_set(&ns->ns.count, 1);
    ns->vvar_page = NULL;
    ns->user_ns = get_user_ns(user_ns);
    ns->ucounts = inc_time_namespaces(user_ns);
    if (!ns->ucounts) {
        kfree(ns);
        return ERR_PTR(-ENOSPC);
    }

    /* 오프셋을 0으로 초기화 -- 이 시점에서는 frozen=false */
    ns->offsets.monotonic = (struct timespec64){0, 0};
    ns->offsets.boottime  = (struct timespec64){0, 0};
    ns->frozen_offsets = false;

    return ns;
}

오프셋 값 검증 상세

오프셋 쓰기 시 커널은 여러 단계의 검증을 수행합니다.

/* proc_timens_offsets_write() 내부 검증 흐름 */
static ssize_t timens_offsets_write(struct file *file,
    const char __user *buf, size_t count, loff_t *ppos)
{
    struct time_namespace *ns;
    char *kbuf;
    struct proc_timens_offset offsets[2];
    int noffsets;

    /* 검증 1: frozen 상태 확인 */
    ns = current->nsproxy->time_ns_for_children;
    if (ns->frozen_offsets)
        return -EACCES;

    /* 검증 2: user namespace 내 CAP_SYS_TIME 확인 */
    if (!ns_capable(ns->user_ns, CAP_SYS_TIME))
        return -EPERM;

    /* 검증 3: 입력 파싱 ("monotonic sec nsec" 형식) */
    kbuf = memdup_user_nul(buf, count);
    if (IS_ERR(kbuf))
        return PTR_ERR(kbuf);

    noffsets = parse_offsets(kbuf, offsets);

    /* 검증 4: nsec 범위 (0 ~ 999,999,999) */
    for (int i = 0; i < noffsets; i++) {
        if (offsets[i].val.tv_nsec < 0 ||
            offsets[i].val.tv_nsec >= NSEC_PER_SEC)
            return -EINVAL;
    }

    /* 검증 5: clock 이름이 "monotonic" 또는 "boottime"인지 */
    /* 다른 clock 이름은 -EINVAL */

    /* 적용 */
    ns->offsets.monotonic = offsets[0].val;
    ...
}

오프셋 경계 조건

/proc/PID/timens_offsets 파일 형식

/* 커널의 timens_offsets 출력 포맷팅 */
static int proc_timens_offsets_show(struct seq_file *m, void *v)
{
    struct time_namespace *ns;
    struct timens_offsets *offsets;

    ns = get_time_ns(current->nsproxy->time_ns_for_children);
    offsets = &ns->offsets;

    /* 형식: "clock_name    seconds    nanoseconds" */
    seq_printf(m, "monotonic %10lld %9lu\n",
               offsets->monotonic.tv_sec,
               offsets->monotonic.tv_nsec);
    seq_printf(m, "boottime  %10lld %9lu\n",
               offsets->boottime.tv_sec,
               offsets->boottime.tv_nsec);

    put_time_ns(ns);
    return 0;
}

vDSO Fast Path 심화

Time Namespace에서 vDSO가 시스템 콜 없이 올바른 시간을 반환하는 메커니즘을 아키텍처별로 상세히 분석합니다.

아키텍처별 vDSO 구현

/* lib/vdso/gettimeofday.c -- 아키텍처 공통 vDSO 코드 */
static __always_inline const struct vdso_data *
__arch_get_timens_vdso_data(const struct vdso_data *vd)
{
    /* VVAR 페이지 영역에서 timens용 데이터 위치 계산
     * init NS: NULL 반환 -- 글로벌 vdso_data 사용
     * custom NS: NS별 VVAR 페이지의 vdso_data 포인터 반환
     *
     * x86에서는 VVAR 페이지가 다음과 같이 배치됨:
     *   [VVAR_PAGE]       -- 글로벌 vdso_data (init NS)
     *   [VVAR_TIMENS_PAGE] -- time NS용 vdso_data */
    return (const struct vdso_data *)
        ((char *)vd + VVAR_TIMENS_PAGE_OFFSET * PAGE_SIZE);
}

/* x86 아키텍처: arch/x86/include/asm/vdso/gettimeofday.h */
static __always_inline const struct vdso_data *
__x86_get_timens_vdso_data(const struct vdso_data *vd)
{
    if (likely(!vd->clock_mode))
        return NULL;  /* init NS -- 추가 페이지 불필요 */

    return (const struct vdso_data *)
        ((char *)vd + PAGE_SIZE);
}

VVAR 페이지 매핑 상세

/* arch/x86/entry/vdso/vma.c -- VVAR 페이지 fault 처리 */
static vm_fault_t vvar_fault(
    const struct vm_special_mapping *sm,
    struct vm_area_struct *vma,
    struct vm_fault *vmf)
{
    if (vmf->pgoff == VVAR_DATA_PAGE_OFFSET) {
        /* 글로벌 vdso_data 매핑 */
        return vmf_insert_pfn(vma, vmf->address,
            __pa_symbol(_vdso_data) >> PAGE_SHIFT);
    }

    if (vmf->pgoff == VVAR_TIMENS_PAGE_OFFSET) {
        struct time_namespace *ns = current->nsproxy->time_ns;

        /* init NS이면 fault -- 이 페이지가 필요하지 않음 */
        if (ns == &init_time_ns)
            return VM_FAULT_SIGBUS;

        /* NS별 VVAR 페이지 매핑 */
        return vmf_insert_pfn(vma, vmf->address,
            page_to_pfn(ns->vvar_page));
    }

    return VM_FAULT_SIGBUS;
}

CRIU 라이브 마이그레이션 심화

CRIU의 Time Namespace 통합은 단순한 오프셋 설정을 넘어, checkpoint 시점의 시간 정보 수집, 이미지 포맷 내 시간 메타데이터 저장, restore 시 정밀한 오프셋 계산을 포함하는 복잡한 워크플로우입니다.

CRIU 이미지 내 시간 메타데이터

/* CRIU 복원 코드 (pie/restorer.c 기반 개념 코드) */
static int restore_time_namespace(
    int64_t saved_mono_sec, int64_t saved_mono_nsec,
    int64_t saved_boot_sec, int64_t saved_boot_nsec)
{
    struct timespec host_mono, host_boot;
    int fd;
    char buf[256];

    /* 현재 호스트 시간 측정 */
    clock_gettime(CLOCK_MONOTONIC, &host_mono);
    clock_gettime(CLOCK_BOOTTIME, &host_boot);

    /* 오프셋 계산: saved_time - current_host_time */
    int64_t mono_off_sec = saved_mono_sec - host_mono.tv_sec;
    int64_t mono_off_nsec = saved_mono_nsec - host_mono.tv_nsec;

    /* 나노초 정규화 */
    if (mono_off_nsec < 0) {
        mono_off_sec--;
        mono_off_nsec += 1000000000LL;
    }

    /* timens_offsets 쓰기 */
    fd = open("/proc/self/timens_offsets", O_WRONLY);
    snprintf(buf, sizeof(buf),
        "monotonic %lld %lld\nboottime %lld %lld\n",
        mono_off_sec, mono_off_nsec,
        saved_boot_sec - host_boot.tv_sec,
        saved_boot_nsec - host_boot.tv_nsec);
    write(fd, buf, strlen(buf));
    close(fd);

    return 0;
}

다중 컨테이너 마이그레이션

futex 동작 심화

futex(Fast Userspace muTEX)는 glibc의 pthread_mutex, pthread_cond, sem_wait 등이 내부적으로 사용하는 핵심 동기화 원시 연산입니다. Time Namespace는 futex의 절대 시간 기반 타임아웃에 영향을 미칩니다.

futex clock 선택과 오프셋

/* kernel/futex/futex.h -- futex 타임아웃 처리 */
static int futex_setup_timer(ktime_t *time,
    struct hrtimer_sleeper *timeout,
    int flags, u64 range_ns)
{
    if (!time)
        return 0;

    if (flags & FLAGS_CLOCKRT) {
        /* CLOCK_REALTIME: time NS 무관 */
        hrtimer_init_sleeper_on_stack(timeout,
            CLOCK_REALTIME, HRTIMER_MODE_ABS);
    } else {
        /* CLOCK_MONOTONIC: time NS 오프셋 역변환 필요 */
        hrtimer_init_sleeper_on_stack(timeout,
            CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
    }

    /* 절대 시간을 호스트 시간으로 역변환 */
    timeout->timer.node.expires =
        timens_ktime_to_host(flags & FLAGS_CLOCKRT ?
            CLOCK_REALTIME : CLOCK_MONOTONIC, *time);

    return 0;
}

futex 시나리오별 동작

pthread 라이브러리 영향

/* pthread_cond_timedwait은 내부적으로 futex 사용
 *
 * 기본 clock: CLOCK_REALTIME -- timens 영향 없음
 * CLOCK_MONOTONIC으로 설정 시: timens 오프셋 적용
 *
 * 시나리오: time NS (offset +5000s) 내에서 */
struct timespec abs;
clock_gettime(CLOCK_MONOTONIC, &abs);  /* NS 시간: 6000s */
abs.tv_sec += 10;                      /* 6010s에 타임아웃 */

pthread_cond_timedwait(&cond, &mutex, &abs);
/* 커널: timens_ktime_to_host(MONOTONIC, 6010s)
 *       6010 - 5000 = 1010s (호스트 시간)
 * hrtimer: 호스트 1010s에 만료
 * 호스트 현재 1000s -- 10초 후 만료 (정확) */

timerfd 동작 심화

timerfd는 파일 디스크립터 기반 타이머로, epoll/select/poll 이벤트 루프에서 핵심적으로 사용됩니다. Time Namespace에서 timerfd의 정확한 동작을 이해하는 것은 컨테이너 내 이벤트 루프 기반 애플리케이션의 안정성에 직결됩니다.

timerfd 커널 내부 경로

/* fs/timerfd.c -- timerfd_settime 내부 */
static int do_timerfd_settime(int ufd, int flags,
    const struct itimerspec64 *new,
    struct itimerspec64 *old)
{
    struct timerfd_ctx *ctx = file->private_data;
    ktime_t expires;

    if (flags & TFD_TIMER_ABSTIME) {
        /* 절대 시간: namespace 시간 -- 호스트 시간 변환 */
        expires = timespec64_to_ktime(new->it_value);
        expires = timens_ktime_to_host(ctx->clockid, expires);
    } else {
        /* 상대 시간: 변환 불필요 */
        expires = timespec64_to_ktime(new->it_value);
    }

    hrtimer_start(&ctx->t.tmr, expires,
        (flags & TFD_TIMER_ABSTIME) ?
        HRTIMER_MODE_ABS : HRTIMER_MODE_REL);
    return 0;
}

timerfd clock 유형별 영향

timer_list과 hrtimer 내부

커널 내부의 타이머 서브시스템이 time namespace 오프셋을 어떻게 처리하는지 분석합니다.

hrtimer 오프셋 변환 함수

/* kernel/time/namespace.c -- 핵심 변환 함수 */
ktime_t timens_ktime_to_host(clockid_t clockid, ktime_t tim)
{
    struct time_namespace *ns = current->nsproxy->time_ns;
    ktime_t offset;

    if (ns == &init_time_ns)
        return tim;  /* init NS: 변환 불필요 */

    switch (clockid) {
    case CLOCK_MONOTONIC:
    case CLOCK_MONOTONIC_RAW:
    case CLOCK_MONOTONIC_COARSE:
        offset = timespec64_to_ktime(ns->offsets.monotonic);
        break;
    case CLOCK_BOOTTIME:
    case CLOCK_BOOTTIME_ALARM:
        offset = timespec64_to_ktime(ns->offsets.boottime);
        break;
    default:
        return tim;
    }

    /* host_time = ns_time - offset */
    return ktime_sub(tim, offset);
}

커널 모듈 타이머 호환성

다른 네임스페이스와의 상호작용

Time Namespace는 독립적으로 동작하지만, 다른 namespace와 결합될 때 중요한 상호작용이 존재합니다.

PID Namespace와의 상호작용

/proc/PID/timens_offsets 접근 시 PID namespace가 PID 번역을 담당합니다. 중첩 PID NS에서 외부 PID(예: 12345)와 내부 PID(예: 1)가 같은 프로세스를 가리킵니다.

Mount Namespace와 /proc

# 일반적인 namespace 조합 (mount NS 포함)
$ unshare --pid --time --mount --fork /bin/bash

# 새 /proc 마운트 (mount NS 내에서)
$ mount -t proc proc /proc

# 이제 /proc/uptime은 time NS 오프셋 반영
# mount NS 없이 time NS만 사용하면 /proc 정보 불일치 가능

User Namespace와 권한

# 비특권 사용자도 user NS 내에서 time NS 생성 가능
$ unshare --user --time --map-root-user --fork /bin/bash

# user NS 내에서 root로 매핑됨
$ id
uid=0(root) gid=0(root)

# timens_offsets 쓰기 가능
$ echo "monotonic 1000 0" > /proc/self/timens_offsets

보안 고려사항 심화

CAP_SYS_TIME과 Time Namespace

/* CAP_SYS_TIME의 범위 */

/* 1. settimeofday() -- 전역 CLOCK_REALTIME 변경
 *    CAP_SYS_TIME (init user NS에서만 유효)
 *    time NS와 무관 */

/* 2. timens_offsets 쓰기
 *    CAP_SYS_TIME (해당 time NS의 소유 user NS에서)
 *    user NS 내에서도 가능 */

/* 3. adjtimex() -- NTP 조정
 *    CAP_SYS_TIME (init user NS)
 *    time NS와 무관 */

보안 강화 권장사항

# 1. seccomp로 time NS 생성 차단
# CLONE_NEWTIME = 0x80
# Docker seccomp 프로필에서 unshare 제한 가능

# 2. sysctl로 비특권 NS 생성 제한
$ sysctl kernel.unprivileged_userns_clone=0

# 3. time NS 최대 개수 제한
$ cat /proc/sys/user/max_time_namespaces
31924
$ echo 100 > /proc/sys/user/max_time_namespaces

# 4. audit 로그로 time NS 생성 추적
$ sudo auditctl -a always,exit -F arch=b64 \
    -S unshare -F a0=0x80 -k timens_create

테스트 및 디버깅 심화

커널 셀프테스트

# 커널 소스의 Time Namespace 셀프테스트
$ cd /usr/src/linux
$ make -C tools/testing/selftests/timens run_tests

# 개별 테스트
$ cd tools/testing/selftests/timens
$ ./timens          # 기본 오프셋
$ ./timerfd         # timerfd 오프셋
$ ./timer           # POSIX 타이머
$ ./clock_nanosleep # nanosleep
$ ./procfs          # /proc 인터페이스
$ ./exec_after_fork # fork+exec 후 오프셋 유지

고급 추적 기법

# bpftrace로 timens 오프셋 적용 모니터링
$ sudo bpftrace -e '
kprobe:timens_ktime_to_host {
    printf("pid=%d comm=%s clock=%d\n", pid, comm, arg0);
}
kretprobe:timens_ktime_to_host {
    printf("  result=%lld\n", retval);
}'

# /proc/PID/maps에서 VVAR 매핑 확인
$ grep vvar /proc/$$/maps
7ffce1a00000-7ffce1a02000 r--p 00000000 00:00 0  [vvar]
# 2페이지 = init NS + timens 페이지

# perf로 vDSO fallback 감지
$ sudo perf record -e 'syscalls:sys_enter_clock_gettime' -p $PID
# vDSO 정상이면 이벤트 거의 없음. 많으면 fallback 발생

자주 발생하는 문제

다른 시간 가상화 접근법 비교

Linux Time Namespace 외에도 시간 가상화를 달성하는 여러 방법이 있습니다.

접근법 비교 표

libfaketime과의 비교

# libfaketime: LD_PRELOAD로 시간 함수 후킹
$ LD_PRELOAD=/usr/lib/libfaketime.so.1 FAKETIME="+1y" date
# 출력: 내년 날짜 (CLOCK_REALTIME도 변경)

# libfaketime 한계 (vs Time Namespace):
# 1. vDSO 경로 우회 불가 -- clock_gettime() 미후킹 가능
# 2. 멀티프로세스 일관성 보장 어려움
# 3. setuid 바이너리에서 LD_PRELOAD 무시
# 4. 커널 내부 타이머에 영향 불가
# 5. Go/Rust non-glibc 런타임에서 불완전

참고자료

• time_namespaces(7) man page
• LWN: Time namespaces
• LWN: Time namespaces in 5.6
• CRIU Time Namespace Guide
• Time namespace patchset (Dmitry Safonov)
• unshare(2) man page
• setns(2) man page
• vdso(7) man page
• kernel/time/namespace.c — Time namespace 핵심 구현 (~500줄)
• include/linux/time_namespace.h — 헤더 파일, timens_offsets 정의
• kernel/time/posix-timers.c — POSIX 타이머 오프셋 적용
• kernel/nsproxy.c — namespace 프록시, timens 전환 로직
• arch/x86/entry/vdso/ — x86 vDSO 구현
• arch/x86/entry/vdso/vma.c — VVAR 페이지 매핑, vvar_fault()
• fs/proc/namespaces.c — /proc/[pid]/ns/time 구현
• Kernel unshare Documentation
• OCI Runtime Specification - Linux Container