네트워크 스택(Network Stack) 개요 (Network Stack Overview)

Linux 커널 네트워크 스택의 전체 처리 경로를 RX 인터럽트(Interrupt)부터 사용자 공간(User Space) 소켓(Socket)까지 단계별로 해설합니다. NAPI 폴링(Polling)과 softirq, sk_buff 수명주기, IPv4/IPv6·TCP/UDP 처리, 라우팅(Routing)/FIB 조회, Netfilter 훅, qdisc/TC 송신 경로를 연결해 설명하고, 실제 운영에서 자주 마주치는 지연(Latency)·드롭·재전송(Retransmission) 문제를 계측하고 튜닝하는 실무 절차까지 포함합니다.

전체 네트워크 스택 계층도

Linux 커널의 네트워크 스택은 유저 공간 애플리케이션에서 물리 NIC까지 7개 주요 계층으로 구성됩니다. 아래 대형 다이어그램은 각 계층의 핵심 모듈과 데이터 흐름을 한눈에 보여줍니다. 수신(RX) 경로는 아래에서 위로, 송신(TX) 경로는 위에서 아래로 진행합니다.

위 다이어그램에서 주목할 점은 다음과 같습니다:

• Netfilter와 TC는 네트워크 계층에 병렬로 삽입됩니다 — 두 프레임워크 모두 패킷 경로의 훅 포인트에 콜백(Callback)을 등록하는 구조입니다. Netfilter는 L3 계층 전후에, TC는 디바이스 출력 직전에 위치합니다.
• XDP는 드라이버 계층에서 동작합니다 — sk_buff 할당 전에 eBPF 프로그램을 실행하므로 최소 오버헤드(Overhead)로 패킷을 처리할 수 있습니다.
• GRO/GSO는 디바이스 계층의 최적화입니다 — 수신 시 GRO가 패킷을 병합하고, 송신 시 GSO가 세그먼트 분할을 지연합니다.
• AF_PACKET은 소켓 계층에서 직접 디바이스 계층에 접근합니다 — tcpdump 같은 패킷 캡처 도구가 사용하며, 전송/네트워크 계층을 우회합니다.

커널 내부 함수 호출 흐름 상세

아래 다이어그램들은 Linux 커널 네트워크 스택 내부의 함수 호출 흐름을 상세히 보여줍니다. 수신(RX)부터 송신(TX), IPSec 처리, 브리지 흐름까지 5개의 다이어그램으로 구성됩니다. sk_buff 구조체 상세는 sk_buff 문서를 참고하세요.

① RX 수신 경로: NIC 드라이버 → XDP → NAPI → GRO → 프로토콜 디스패치

패킷이 NIC 하드웨어에 도착하면 DMA로 메모리에 복사된 뒤, XDP 필터를 거치고 NAPI 폴링 루프에서 GRO 병합을 수행합니다. 이후 netif_receive_skb()를 통해 프로토콜 타입별 핸들러로 디스패치됩니다.

② IP 라우팅 & 분기: PRE_ROUTING → 라우팅 결정 → Local-In / Forward / Local-Out

ip_rcv()로 진입한 패킷은 Netfilter NF_INET_PRE_ROUTING 훅을 거친 뒤 FIB 테이블을 조회하여 세 가지 경로(로컬 수신, 포워딩, 로컬 출력)로 분기합니다.

③ xfrm/IPSec 처리: 복호화(RX) & 암호화(TX)

IPSec은 커널의 xfrm 서브시스템이 담당합니다. 수신 시 SAD를 조회해 ESP/AH를 복호화하고, 송신 시 SPD에 따라 암호화한 뒤 NF_INET_LOCAL_OUT으로 재주입합니다.

④ TX 출력 경로: dst_output → ip_output → Neighbour → NIC

라우팅/Local-Out/Forward에서 결정된 패킷은 dst_output()을 시작으로 Netfilter POST_ROUTING, GSO/단편화 판단, Neighbour 서브시스템의 L2 헤더 추가, TC/qdisc 스케줄링을 거쳐 NIC 드라이버로 전달됩니다.

⑤ Bridge 처리 흐름: br_handle_frame → NF_BR 훅 → FDB 분기

브리지 디바이스는 rx_handler로 등록된 br_handle_frame()에서 패킷을 가로채고, FDB 조회 결과에 따라 유니캐스트 포워딩, 플러딩, 멀티캐스트 전달, 로컬 수신으로 분기합니다.

네트워크 스택 개요

Linux 네트워크 스택은 OSI 7계층 모델에 대응하는 계층적 구조로 설계되어 있습니다. 패킷은 sk_buff(소켓 버퍼) 구조체(Struct)로 표현되며, 각 계층을 통과하면서 헤더가 추가/제거됩니다. 커널 소스에서 네트워크 코드는 net/ 디렉터리에 위치하며, 프로토콜별(net/ipv4/, net/ipv6/, net/core/)로 분리되어 있습니다.

네트워크 스택의 주요 설계 원칙은 다음과 같습니다:

• 프로토콜 독립성 — struct proto와 struct net_protocol을 통해 전송/네트워크 계층 프로토콜을 플러그인 방식으로 등록합니다. TCP, UDP, SCTP 등이 동일한 인터페이스를 구현합니다.
• 제로카피 경로 — sendfile(), splice(), MSG_ZEROCOPY를 통해 유저 공간 버퍼에서 NIC까지 복사를 최소화합니다.
• 네트워크 네임스페이스(Namespace) — struct net으로 네트워크 스택 전체를 격리(Isolation)합니다. 각 네임스페이스는 독립적인 라우팅 테이블(Routing Table), Netfilter 규칙, 인터페이스를 가집니다.
• 훅 기반 확장 — Netfilter, TC, XDP 등 데이터 경로 곳곳에 훅 포인트를 두어 패킷 검사/수정/리다이렉트를 가능하게 합니다.
• 멀티큐 병렬화 — NIC의 여러 RX/TX 큐를 별도 CPU에 바인딩하여 패킷 처리를 병렬화합니다. RSS, RPS, XPS가 이를 지원합니다.
• 지연 처리(Deferred Processing) — 하드 IRQ에서 최소 작업만 수행하고, softirq/NAPI 폴링으로 배치 처리하여 인터럽트 오버헤드를 줄입니다.

커널 소스 디렉토리 구조

Linux 커널의 네트워크 코드는 크게 세 디렉토리 트리에 분산되어 있습니다: 프로토콜 구현(net/), NIC 드라이버(drivers/net/), 헤더 파일(include/net/, include/linux/). 아래 표는 각 하위 디렉토리의 역할과 주요 소스 파일을 상세하게 정리합니다.

net/ 디렉토리 상세 맵

drivers/net/ 디렉토리 맵

include/ 헤더 파일 맵

커널 네트워크 코드 규모

Linux 커널의 네트워크 코드는 커널 전체 코드의 약 10-15%를 차지하는 대규모 서브시스템입니다. 아래 표는 주요 디렉토리별 대략적인 코드 규모를 보여줍니다:

핵심 소스 파일과 진입점(Entry Point)

네트워크 스택을 처음 분석할 때 아래 소스 파일부터 읽으면 전체 구조를 빠르게 파악할 수 있습니다:

패킷 수신 경로 (RX Path)

패킷이 NIC에 도달한 순간부터 유저 공간 recv()가 데이터를 받을 때까지의 전체 경로를 단계별로 추적합니다. 이 경로를 정확히 이해하면 지연 원인 분석과 드롭 포인트 추적이 훨씬 용이해집니다.

단계별 상세 설명

1단계 - NIC DMA 전송: NIC가 패킷을 수신하면 DMA(Direct Memory Access)를 통해 미리 할당된 RX Ring Buffer의 빈 슬롯에 패킷 데이터를 기록합니다. RX Ring Buffer는 드라이버 초기화 시 napi_alloc_skb() 또는 page_pool을 사용하여 할당한 메모리 영역입니다. DMA 완료 후 NIC는 하드웨어 인터럽트(IRQ)를 발생시킵니다.

2단계 - Hard IRQ 처리: 드라이버의 인터럽트 핸들러(Handler)가 실행됩니다. 이 핸들러는 최소한의 작업만 수행합니다: napi_schedule()를 호출하여 NAPI 폴링을 예약하고, 해당 큐의 인터럽트를 비활성화합니다. 이렇게 함으로써 고부하 시 인터럽트 폭풍(interrupt storm)을 방지합니다.

/* 드라이버 인터럽트 핸들러 전형적 패턴 */
static irqreturn_t driver_irq_handler(int irq, void *data)
{
    struct driver_priv *priv = data;

    /* 인터럽트 비활성화 (폴링 모드 전환) */
    driver_disable_irq(priv);

    /* NAPI 폴링 예약 */
    napi_schedule(&priv->napi);

    return IRQ_HANDLED;
}

3단계 - SoftIRQ / NAPI 폴링: NET_RX_SOFTIRQ가 트리거되면 net_rx_action()이 실행되어 예약된 NAPI 구조체의 poll() 콜백을 호출합니다. 이 콜백에서 드라이버는 RX Ring에서 수신된 패킷을 budget(기본 64) 개수만큼 배치로 처리합니다. budget 내에서 모든 패킷을 처리하면 napi_complete_done()으로 인터럽트를 재활성화합니다.

4단계 - GRO/XDP 처리: NAPI poll 내부에서 napi_gro_receive()가 호출되면 GRO(Generic Receive Offload)가 동일 플로우의 연속 패킷을 병합하여 상위 계층의 처리 횟수를 줄입니다. XDP 프로그램이 연결되어 있다면 bpf_prog_run_xdp()에서 XDP_DROP, XDP_TX, XDP_REDIRECT, XDP_PASS 중 하나를 결정합니다.

5단계 - L2 디멀티플렉싱: __netif_receive_skb()에서 skb->protocol 필드(이더넷의 EtherType)를 기반으로 적절한 L3 프로토콜 핸들러를 찾습니다. IPv4(ETH_P_IP), IPv6(ETH_P_IPV6), ARP(ETH_P_ARP) 등을 구분합니다. AF_PACKET 소켓(tcpdump 등)이 있다면 이 시점에 패킷 복사본이 전달됩니다.

6단계 - IP 계층 처리: ip_rcv()에서 IP 헤더 유효성을 검증하고 Netfilter NF_INET_PRE_ROUTING 훅을 통과시킵니다. ip_rcv_finish()에서 FIB(Forwarding Information Base) 조회를 수행하여 패킷의 목적지가 로컬인지, 포워딩 대상인지 결정합니다.

7단계 - L4 전달: 로컬 대상 패킷은 ip_local_deliver()를 거쳐 Netfilter NF_INET_LOCAL_IN 훅을 통과한 후, IP 프로토콜 번호에 따라 tcp_v4_rcv()(TCP) 또는 udp_rcv()(UDP) 등 전송 계층 핸들러로 전달됩니다.

8단계 - 소켓 수신 큐: 전송 계층이 패킷을 해당 소켓의 sk_receive_queue에 삽입하고 sk->sk_data_ready() 콜백으로 대기 중인 프로세스(Process)를 깨웁니다. 유저 공간의 recv()/recvmsg()가 큐에서 데이터를 꺼내 사용자 버퍼로 복사합니다.

net_rx_action() 내부 구현

NET_RX_SOFTIRQ가 트리거되면 net_rx_action()이 호출됩니다. 이 함수는 per-CPU softnet_data의 poll_list에 등록된 NAPI 구조체를 순회하며, 각각의 poll() 콜백을 호출합니다. 전체 budget(기본 300)과 시간 제한(2 jiffies)이라는 두 가지 제약 조건을 적용하여, softirq가 CPU를 과도하게 점유하지 않도록 합니다.

/* net/core/dev.c — net_rx_action() 핵심 로직 (간략화) */
static void net_rx_action(struct softirq_action *h)
{
    struct softnet_data *sd = this_cpu_ptr(&softnet_data);
    unsigned long time_limit = jiffies + 2;  /* 최대 2 jiffies */
    int budget = READ_ONCE(netdev_budget);       /* 기본 300 */
    LIST_HEAD(list);
    LIST_HEAD(repoll);

    local_irq_disable();
    list_splice_init(&sd->poll_list, &list);
    local_irq_enable();

    for (;;) {
        struct napi_struct *n;

        if (list_empty(&list)) {
            if (!sd_has_rps_ipi_waiting(sd) &&
                list_empty(&repoll))
                return;
            break;
        }

        n = list_first_entry(&list, struct napi_struct, poll_list);
        budget -= napi_poll(n, &repoll);

        /* budget 소진 또는 시간 초과 시 중단 */
        if (unlikely(budget <= 0 ||
                     time_after_eq(jiffies, time_limit))) {
            sd->time_squeeze++;   /* softnet_stat 두 번째 열 */
            break;
        }
    }
    /* 미처리 NAPI를 poll_list에 복원, softirq 재스케줄 */
    local_irq_disable();
    list_splice_tail_init(&sd->poll_list, &list);
    list_splice_tail(&repoll, &list);
    if (!list_empty(&list))
        __raise_softirq_irqoff(NET_RX_SOFTIRQ);
    local_irq_enable();
}

NAPI 폴링 루프 상세

드라이버의 poll() 콜백은 RX Ring Buffer에서 패킷을 꺼내 상위 계층으로 전달하는 핵심 루프입니다. budget 범위 내에서 가능한 많은 패킷을 처리하며, 모든 패킷을 소진하면 인터럽트를 재활성화합니다. 아래는 전형적인 드라이버 poll 함수의 구조입니다.

/* 전형적인 NIC 드라이버 NAPI poll 함수 */
static int driver_poll(struct napi_struct *napi, int budget)
{
    struct driver_ring *ring = container_of(napi, struct driver_ring, napi);
    int work_done = 0;

    while (work_done < budget) {
        struct sk_buff *skb;
        struct rx_desc *desc = &ring->desc[ring->next_to_clean];

        /* 디스크립터 소유권 확인 (DD 비트) */
        if (!(le32_to_cpu(desc->status) & RX_DESC_DONE))
            break;

        /* DMA 언맵 및 sk_buff 구성 */
        dma_sync_single_for_cpu(ring->dev, desc->dma_addr,
                                ring->buf_len, DMA_FROM_DEVICE);
        skb = ring->skb_array[ring->next_to_clean];
        skb_put(skb, desc->length);

        /* 프로토콜, 체크섬 오프로드 결과 설정 */
        skb->protocol = eth_type_trans(skb, ring->netdev);
        if (desc->status & RX_CSUM_VALID)
            skb->ip_summed = CHECKSUM_UNNECESSARY;

        /* GRO를 통해 상위 계층 전달 */
        napi_gro_receive(napi, skb);

        ring->next_to_clean = (ring->next_to_clean + 1) % ring->count;
        work_done++;
    }

    /* 새 버퍼 할당하여 RX Ring 보충 */
    driver_alloc_rx_buffers(ring);

    /* 모든 패킷 처리 완료 시 인터럽트 재활성화 */
    if (work_done < budget) {
        if (napi_complete_done(napi, work_done))
            driver_enable_irq(ring);
    }

    return work_done;
}

GRO 병합 메커니즘

GRO(Generic Receive Offload)는 동일 플로우의 연속 패킷을 하나의 큰 sk_buff로 병합하여 상위 스택의 처리 횟수를 줄이는 메커니즘입니다. napi_gro_receive()는 내부적으로 dev_gro_receive()를 호출하여 프로토콜별 GRO 콜백을 실행합니다.

/* net/core/gro.c — GRO 수신 처리 핵심 흐름 (간략화) */
gro_result_t dev_gro_receive(struct napi_struct *napi,
                             struct sk_buff *skb)
{
    struct list_head *gro_head = &napi->gro_hash[bucket].list;
    struct sk_buff *pp = NULL;

    /* 1. L2 프로토콜별 gro_receive 콜백 호출 */
    /*    IPv4 → inet_gro_receive() → tcp4_gro_receive() */
    /*    IPv6 → ipv6_gro_receive() → tcp6_gro_receive() */
    pp = call_gro_receive(ptype->callbacks.gro_receive, gro_head, skb);

    switch (ret) {
    case GRO_MERGED:
        /* skb가 기존 GRO 패킷에 병합됨 — skb 해제 */
        break;
    case GRO_MERGED_FREE:
        /* 병합 후 원본 skb 즉시 해제 */
        break;
    case GRO_HELD:
        /* skb를 GRO 리스트에 보관 (향후 병합 대기) */
        list_add(&skb->list, gro_head);
        napi->gro_hash[bucket].count++;
        break;
    case GRO_NORMAL:
        /* GRO 불가 — 일반 수신 경로로 전달 */
        gro_normal_one(napi, skb, 1);
        break;
    case GRO_CONSUMED:
        /* 프로토콜이 skb 소유권을 가져감 */
        break;
    }
    return ret;
}

GRO 병합이 성공하면 하나의 64KB sk_buff로 수십 개의 세그먼트를 전달할 수 있어, TCP 수신 경로의 함수 호출 횟수가 대폭 감소합니다. GRO 병합 조건은 다음과 같습니다:

Busy Polling (SO_BUSY_POLL)

Busy Polling은 유저 공간의 poll()/epoll_wait()/select()가 반환 전에 직접 NAPI poll을 호출하는 메커니즘입니다. softirq 스케줄링 지연을 제거하여 수 마이크로초 수준의 레이턴시 개선을 달성할 수 있습니다. 금융 트레이딩, HPC 메시지 패싱 등 초저지연 환경에서 유용합니다.

/* include/net/busy_poll.h — sk_busy_loop() 핵심 로직 (간략화) */
static inline void sk_busy_loop(struct sock *sk, int nonblock)
{
    unsigned int napi_id = READ_ONCE(sk->sk_napi_id);
    unsigned long end_time = busy_loop_end_time(sk);
    int (*busy_poll)(struct napi_struct *napi, int budget);

    if (!napi_id)
        return;

    do {
        local_bh_disable();
        /* 소켓에 연결된 NAPI를 직접 poll */
        napi_busy_loop(napi_id, nonblock ? NULL : busy_loop_current_should_spin,
                       sk->sk_prefer_busy_poll ? busy_poll : NULL,
                       BUSY_POLL_BUDGET);
        local_bh_enable();
    } while (!nonblock && !sk_has_rx_data(sk) &&
              !busy_loop_timeout(end_time));
}

/* Busy Polling 활성화: 유저 공간 설정 */
int busy_poll_usec = 50;  /* 50μs 동안 busy poll */
setsockopt(fd, SOL_SOCKET, SO_BUSY_POLL,
           &busy_poll_usec, sizeof(busy_poll_usec));

/* SO_PREFER_BUSY_POLL: 드라이버 전용 busy poll 콜백 사용 */
int prefer = 1;
setsockopt(fd, SOL_SOCKET, SO_PREFER_BUSY_POLL,
           &prefer, sizeof(prefer));

# 시스템 전역 busy poll 설정 (sysctl)
sysctl -w net.core.busy_poll=50       # poll/select/epoll 기본 busy poll 시간(μs)
sysctl -w net.core.busy_read=50       # read/recv 기본 busy poll 시간(μs)

# NAPI ID 기반 소켓 바인딩 확인
cat /proc/net/tcp | awk '{print $13}'  # napi_id 열 확인

RX 경로 성능 카운터 심층 분석

/proc/net/softnet_stat은 per-CPU 네트워크 소프트 인터럽트 통계를 16진수로 출력합니다. 각 행이 하나의 CPU에 대응하며, 패킷 드롭과 softirq 스케줄링 문제를 진단하는 핵심 도구입니다.

/* net/core/net-procfs.c — softnet_stat 출력 형식 */
/* include/linux/netdevice.h — softnet_data 구조체 */
struct softnet_data {
    struct list_head    poll_list;        /* 폴링 대기 NAPI 리스트 */
    struct sk_buff_head input_pkt_queue;  /* non-NAPI 또는 RPS 입력 큐 */
    struct sk_buff_head process_queue;    /* 처리 중인 패킷 큐 */

    unsigned int        processed;        /* 열 1: 총 처리 패킷 수 */
    unsigned int        time_squeeze;     /* 열 2: budget/시간 초과 횟수 */
    unsigned int        received_rps;     /* 열 9: RPS 수신 횟수 */
    unsigned int        dropped;          /* input_pkt_queue 오버플로우 */
    unsigned int        flow_limit_count; /* 열 10: flow limit 드롭 */
    unsigned int        cpu_collision;    /* 열 8: TX CPU 충돌 */
    unsigned int        backlog_len;      /* 현재 backlog 길이 */
};

# softnet_stat 실시간 모니터링
watch -n1 'cat /proc/net/softnet_stat'

# 특정 CPU의 time_squeeze 변화 추적
while true; do
  awk 'NR==1 {printf "CPU0 processed=%d time_squeeze=%d dropped=%d\n", \
    strtonum("0x"$1), strtonum("0x"$2), strtonum("0x"$3)}' \
    /proc/net/softnet_stat
  sleep 1
done

# budget 관련 sysctl 튜닝
sysctl -w net.core.netdev_budget=600            # 기본 300
sysctl -w net.core.netdev_budget_usecs=4000     # 기본 2000 (2ms)
sysctl -w net.core.netdev_max_backlog=2000      # 기본 1000

RPS/RFS/XPS 패킷 스티어링

멀티큐 NIC에서도 모든 큐가 효율적으로 사용되지 않거나, 단일 큐 NIC에서 멀티코어를 활용하기 위해 소프트웨어 패킷 스티어링이 필요합니다. RPS(Receive Packet Steering), RFS(Receive Flow Steering), XPS(Transmit Packet Steering)는 패킷 처리를 여러 CPU에 분산합니다.

/* net/core/dev.c — RPS 처리 (get_rps_cpu) 핵심 로직 (간략화) */
static int get_rps_cpu(struct net_device *dev,
                      struct sk_buff *skb,
                      struct rps_dev_flow **rflowp)
{
    const struct rps_sock_flow_table *sock_flow_table;
    struct netdev_rx_queue *rxqueue = dev->_rx;
    u32 flow_hash;
    int cpu = -1;

    /* 1. 패킷의 플로우 해시 계산 (5-tuple) */
    flow_hash = skb_get_hash(skb);
    if (!flow_hash)
        goto done;

    /* 2. RFS: 소켓이 마지막으로 실행된 CPU로 스티어링 */
    sock_flow_table = rcu_dereference(rps_sock_flow_table);
    if (sock_flow_table) {
        u32 ident = sock_flow_table->ents[flow_hash &
                    sock_flow_table->mask];
        cpu = ident & ~0x80000000U;  /* CPU 번호 추출 */
    }

    /* 3. RPS fallback: 해시 기반 CPU 선택 */
    if (cpu < 0) {
        u32 map_len = map->len;
        cpu = map->cpus[reciprocal_scale(flow_hash, map_len)];
    }

    return cpu;
}

# RPS 설정 (CPU 0-3에 분배)
echo f > /sys/class/net/eth0/queues/rx-0/rps_cpus

# RFS 활성화 (전역 플로우 테이블 크기)
echo 32768 > /proc/sys/net/core/rps_sock_flow_entries
echo 4096 > /sys/class/net/eth0/queues/rx-0/rps_flow_cnt

# XPS 설정 (CPU 0 → TX 큐 0, CPU 1 → TX 큐 1)
echo 1 > /sys/class/net/eth0/queues/tx-0/xps_cpus
echo 2 > /sys/class/net/eth0/queues/tx-1/xps_cpus

# RSS 인다이렉션 테이블 확인
ethtool -x eth0

# RSS 해시 키 설정
ethtool -X eth0 equal 4  # 4개 큐에 균등 분배

패킷 송신 경로 (TX Path)

유저 공간의 send()/sendmsg() 호출부터 NIC가 패킷을 와이어에 전송할 때까지의 경로입니다. 수신 경로의 역순이지만, qdisc(큐잉 규칙)와 GSO(Generic Segmentation Offload)가 개입하는 점이 핵심 차이입니다.

TX 경로의 핵심 처리 흐름

소켓 계층에서 전송 계층까지: 유저 공간의 send() 시스템 콜(System Call)은 sock_sendmsg()를 거쳐 프로토콜별 sendmsg() 구현으로 전달됩니다. TCP의 경우 tcp_sendmsg()가 유저 데이터를 소켓의 sk_write_queue에 sk_buff 형태로 복사하고, Nagle 알고리즘과 혼잡 제어(Congestion Control)를 거쳐 tcp_write_xmit()에서 실제 전송을 결정합니다. UDP는 udp_sendmsg()에서 즉시 IP 계층으로 전달합니다.

IP 계층 처리: ip_queue_xmit()에서 라우팅 결과(dst_entry)를 참조하여 소스 IP, 출력 인터페이스를 결정하고 IP 헤더를 추가합니다. Netfilter NF_INET_LOCAL_OUT과 NF_INET_POST_ROUTING 훅을 통과합니다. IP 단편화(Fragmentation)가 필요하면 ip_fragment()에서 MTU에 맞게 분할합니다.

TC/qdisc 계층: __dev_queue_xmit()에서 출력 디바이스의 qdisc에 패킷을 enqueue합니다. 기본 qdisc는 pfifo_fast 또는 fq_codel이며, htb, tbf 등으로 대역폭(Bandwidth) 제한과 트래픽 셰이핑을 수행할 수 있습니다. dequeue된 패킷은 dev_hard_start_xmit()으로 드라이버에 전달됩니다.

드라이버 전송: ndo_start_xmit() 콜백에서 DMA 매핑(Mapping) 후 TX Ring Buffer에 디스크립터를 기록하고, NIC의 doorbell 레지스터(Register)에 쓰기를 수행하여 전송을 시작합니다. TX 완료 인터럽트로 sk_buff를 해제합니다.

__dev_queue_xmit() 내부 구현

__dev_queue_xmit()은 IP 계층에서 내려온 sk_buff를 출력 디바이스의 qdisc에 전달하는 핵심 함수입니다. qdisc가 없거나(noqueue) 조건을 만족하면 qdisc를 우회하여 직접 전송하는 경로도 있습니다.

/* net/core/dev.c — __dev_queue_xmit() 핵심 로직 (간략화) */
static int __dev_queue_xmit(struct sk_buff *skb,
                            struct net_device *sb_dev)
{
    struct net_device *dev = skb->dev;
    struct netdev_queue *txq;
    struct Qdisc *q;

    /* 1. TC egress 처리 (tc filter/action) */
    skb = sch_handle_egress(skb, &rc, dev);
    if (!skb)
        goto out;

    /* 2. TX 큐 선택 (XPS 또는 해시 기반) */
    txq = netdev_core_pick_tx(dev, skb, sb_dev);
    q = rcu_dereference_bh(txq->qdisc);

    if (q->enqueue) {
        /* 3a. qdisc 경로: enqueue 후 dequeue/전송 */
        rc = __dev_xmit_skb(skb, q, dev, txq);
    } else {
        /* 3b. qdisc 우회 (noqueue): 직접 전송 */
        if (dev_xmit_recursion()) {
            net_crit_ratelimited("Recursion! dev=%s\n", dev->name);
            goto drop;
        }

        /* BQL 체크 후 직접 전송 */
        skb_get_tx_queue(skb, txq);
        PRANDOM_ADD_NOISE(skb, dev, txq, jiffies);
        rc = dev_hard_start_xmit(skb, dev, txq, NULL);
    }
    return rc;
}

qdisc 처리 흐름

qdisc에 패킷이 enqueue되면, __qdisc_run()이 dequeue 루프를 실행하여 패킷을 드라이버로 전달합니다. 이 과정은 qdisc 락을 보유한 상태에서 수행되므로, 다른 CPU와의 경합이 발생할 수 있습니다.

/* net/sched/sch_generic.c — qdisc 실행 흐름 (간략화) */
void __qdisc_run(struct Qdisc *q)
{
    int quota = READ_ONCE(dev_tx_weight);  /* 기본 64 */
    int packets;

    while (qdisc_restart(q, &packets)) {
        quota -= packets;
        if (quota <= 0) {
            /* quota 소진 시 softirq로 연기 */
            __netif_schedule(q);
            break;
        }
    }
}

/* qdisc_restart() 내부 */
static inline bool qdisc_restart(struct Qdisc *q, int *packets)
{
    struct sk_buff *skb = dequeue_skb(q, packets);
    if (unlikely(!skb))
        return false;

    /* GSO 세그먼테이션이 필요하면 이 시점에서 수행 */
    if (sch_direct_xmit(skb, q, dev, txq, NULL, true))
        return true;   /* dequeue 계속 */

    return false;      /* 드라이버 큐 full — 중단 */
}

GSO 세그먼테이션 내부

GSO(Generic Segmentation Offload)는 TCP/UDP 대형 패킷을 MSS 크기의 세그먼트로 분할하는 소프트웨어 메커니즘입니다. dev_hard_start_xmit()에서 NIC가 TSO를 지원하지 않으면 __skb_gso_segment()를 호출하여 분할합니다.

/* net/core/skbuff.c — GSO 세그먼테이션 핵심 경로 (간략화) */
struct sk_buff *__skb_gso_segment(struct sk_buff *skb,
                                  netdev_features_t features, bool tx_path)
{
    struct sk_buff *segs;

    /* skb_shared_info→gso_type에 따라 콜백 선택 */
    /* SKB_GSO_TCPV4 → tcp4_gso_segment() */
    /* SKB_GSO_TCPV6 → tcp6_gso_segment() */
    /* SKB_GSO_UDP_L4 → __udp_gso_segment() */
    segs = skb_mac_gso_segment(skb, features);

    return segs; /* 세그먼트 sk_buff 연결 리스트 */
}

/* TCP GSO 세그먼테이션 (net/ipv4/tcp_offload.c) */
struct sk_buff *tcp4_gso_segment(struct sk_buff *skb,
                                netdev_features_t features)
{
    /* gso_size = MSS, gso_segs = 원본 길이 / MSS */
    unsigned int mss = skb_shinfo(skb)->gso_size;

    /* skb_segment()로 실제 분할 수행 */
    /* 각 세그먼트에 TCP/IP 헤더 복사, 시퀀스 번호 조정 */
    /* 마지막 세그먼트에만 PSH 플래그 설정 */
    segs = tcp_gso_segment(skb, features);

    /* 각 세그먼트의 체크섬 재계산 */
    return segs;
}

TX Completion과 BQL

TX Completion은 NIC가 패킷 전송을 완료한 후 DMA 매핑을 해제하고 sk_buff를 반환하는 과정입니다. BQL(Byte Queue Limits)은 드라이버의 TX 큐에 과도한 바이트가 적체되는 것을 방지하여 qdisc 계층의 지연을 최소화합니다.

/* TX Completion 처리 (NAPI TX clean) — 드라이버 패턴 */
static int driver_tx_clean(struct driver_ring *ring, int budget)
{
    unsigned int total_bytes = 0, total_packets = 0;

    while (total_packets < budget) {
        struct tx_desc *desc = &ring->desc[ring->next_to_clean];

        if (!(desc->status & TX_DESC_DONE))
            break;

        /* DMA 매핑 해제 */
        dma_unmap_single(ring->dev, desc->dma_addr,
                         desc->length, DMA_TO_DEVICE);

        /* sk_buff 해제 — 정상 전송이므로 consume_skb 사용 */
        total_bytes += ring->tx_buf[ring->next_to_clean].bytecount;
        dev_consume_skb_any(ring->tx_buf[ring->next_to_clean].skb);

        total_packets++;
        ring->next_to_clean = (ring->next_to_clean + 1) % ring->count;
    }

    /* BQL 완료 통지 — 큐에서 제거된 바이트 수 보고 */
    netdev_tx_completed_queue(ring->txq, total_packets, total_bytes);

    /* TX 큐가 멈췄으면 재개 */
    if (unlikely(netif_tx_queue_stopped(ring->txq)) &&
        driver_desc_unused(ring) >= TX_WAKE_THRESHOLD)
        netif_tx_wake_queue(ring->txq);

    return total_packets;
}

패킷 수명주기 End-to-End 추적

실제 운영 환경에서 TCP 연결의 패킷 하나가 생성되고 소멸되기까지의 전체 여정을 추적합니다. 아래는 클라이언트가 send()로 데이터를 보내고 서버가 recv()로 받는 과정에서 커널 내부에서 발생하는 모든 주요 이벤트를 시간순으로 정리한 것입니다.

패킷별 커널 내부 타임스탬프 추적

패킷의 지연을 정밀하게 분석하려면 각 단계의 타임스탬프를 기록해야 합니다. Linux 커널은 SO_TIMESTAMPING 소켓 옵션을 통해 소프트웨어/하드웨어 타임스탬프를 제공합니다.

/* SO_TIMESTAMPING으로 패킷별 정밀 타임스탬프 수집 */
int flags = SOF_TIMESTAMPING_TX_SOFTWARE |
           SOF_TIMESTAMPING_RX_SOFTWARE |
           SOF_TIMESTAMPING_SOFTWARE |
           SOF_TIMESTAMPING_TX_HARDWARE |
           SOF_TIMESTAMPING_RX_HARDWARE |
           SOF_TIMESTAMPING_RAW_HARDWARE;

setsockopt(fd, SOL_SOCKET, SO_TIMESTAMPING, &flags, sizeof(flags));

주요 추적 지점과 tracepoint

# ftrace로 패킷 경로 추적
echo 1 > /sys/kernel/debug/tracing/events/net/netif_receive_skb/enable
echo 1 > /sys/kernel/debug/tracing/events/net/net_dev_start_xmit/enable
echo 1 > /sys/kernel/debug/tracing/events/skb/kfree_skb/enable
cat /sys/kernel/debug/tracing/trace_pipe

# bpftrace로 TCP 재전송 추적
bpftrace -e 'tracepoint:tcp:tcp_retransmit_skb {
    printf("retransmit: sport=%d dport=%d state=%d\n",
           args->sport, args->dport, args->state);
}'

# perf로 패킷 드롭 위치 추적
perf record -g -e skb:kfree_skb -- sleep 10
perf script | head -50

sk_buff 구조체

struct sk_buff는 네트워크 패킷을 표현하는 핵심 자료구조입니다. head/data/tail/end 4개 포인터로 버퍼를 관리하며, 각 프로토콜 계층이 skb_push()/skb_pull()로 헤더를 추가/제거합니다. 소속 소켓(sk), 네트워크 디바이스(dev), 프로토콜(protocol), 계층별 헤더 오프셋(Offset) 등 메타데이터를 포함합니다.

주요 sk_buff 조작 함수

sk_buff 할당 내부 구현

alloc_skb()는 네트워크 스택에서 가장 빈번하게 호출되는 할당 함수입니다. sk_buff 메타데이터 구조체와 데이터 버퍼를 별도로 할당하며, 캐시 효율성을 위해 SLAB/SLUB 할당자의 전용 캐시(skbuff_head_cache)를 사용합니다.

/* net/core/skbuff.c — alloc_skb() 내부 구현 (간략화) */
struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask,
                            int flags, int node)
{
    struct sk_buff *skb;
    u8 *data;
    unsigned int osize;

    /* 1. sk_buff 메타데이터 할당 (전용 kmem_cache) */
    skb = kmem_cache_alloc_node(skbuff_head_cache,
                                gfp_mask & ~GFP_DMA, node);
    if (unlikely(!skb))
        return NULL;

    /* 2. 데이터 버퍼 할당 (size + skb_shared_info 크기) */
    size = SKB_DATA_ALIGN(size);
    size += SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
    data = kmalloc_reserve(size, gfp_mask, node, &osize);
    if (unlikely(!data))
        goto nodata;

    size = osize - SKB_DATA_ALIGN(sizeof(struct skb_shared_info));

    /* 3. sk_buff 필드 초기화 */
    skb->head = data;
    skb->data = data;
    skb_reset_tail_pointer(skb);
    skb->end = skb->tail + size;
    skb->mac_header = (typeof(skb->mac_header))~0U;
    skb->transport_header = (typeof(skb->transport_header))~0U;

    /* 4. skb_shared_info 초기화 (end 포인터 직후) */
    struct skb_shared_info *shinfo = skb_shinfo(skb);
    memset(shinfo, 0, offsetof(struct skb_shared_info, dataref));
    atomic_set(&shinfo->dataref, 1);

    skb_set_kcov_handle(skb, kcov_common_handle());
    return skb;
}

Paged Data와 skb_shared_info

skb_shared_info는 sk_buff의 데이터 버퍼 끝(end 포인터 위치)에 배치되는 메타데이터 구조체입니다. 선형 데이터 영역 외에 페이지 기반 데이터(paged data), GSO 정보, frag_list를 관리합니다.

/* include/linux/skbuff.h — skb_shared_info 구조체 */
struct skb_shared_info {
    __u8            flags;           /* SKBFL_* 플래그 */
    __u8            meta_len;        /* 메타데이터 길이 */
    __u8            nr_frags;        /* frags[] 사용 수 (최대 17) */
    __u8            tx_flags;        /* SKBTX_* 플래그 */
    unsigned short  gso_size;        /* GSO 세그먼트 크기 (MSS) */
    unsigned short  gso_segs;        /* GSO 세그먼트 수 */
    unsigned int    gso_type;        /* SKB_GSO_* 플래그 */
    struct sk_buff  *frag_list;      /* IP 단편/GRO 리스트 */
    struct skb_shared_hwtstamps hwtstamps; /* HW 타임스탬프 */
    atomic_t        dataref;         /* 데이터 참조 카운트 */
    unsigned int    xdp_frags_size;  /* XDP 프래그먼트 총 크기 */

    /* Paged data — 각 프래그먼트는 page + offset + size */
    skb_frag_t      frags[MAX_SKB_FRAGS]; /* 최대 17개 */
};

/* skb_frag_t — 페이지 프래그먼트 */
typedef struct skb_frag {
    struct {
        struct page *p;       /* 물리 페이지 */
    } bv_page;
    __u32   bv_offset;              /* 페이지 내 오프셋 */
    __u32   bv_len;                 /* 데이터 길이 */
} skb_frag_t;

sk_buff 참조 카운트와 수명 관리

sk_buff에는 두 가지 참조 카운트가 존재합니다: skb->users(sk_buff 구조체 자체)와 skb_shared_info->dataref(데이터 버퍼)입니다. 이 이중 참조 모델은 메타데이터와 데이터의 독립적인 수명 관리를 가능하게 합니다.

/* sk_buff 참조 카운트 관리 함수들 */

/* skb_get() — sk_buff 참조 카운트 증가 */
static inline struct sk_buff *skb_get(struct sk_buff *skb)
{
    refcount_inc(&skb->users);
    return skb;
}

/* kfree_skb() — 드롭으로 인한 해제 (drop_monitor 추적) */
void kfree_skb_reason(struct sk_buff *skb,
                      enum skb_drop_reason reason)
{
    if (!skb_unref(skb))
        return;

    /* drop_reason 추적 포인트 발생 */
    trace_kfree_skb(skb, __builtin_return_address(0), reason);
    __kfree_skb(skb);
}

/* consume_skb() — 정상 소비로 해제 (drop_monitor 무시) */
void consume_skb(struct sk_buff *skb)
{
    if (!skb_unref(skb))
        return;

    /* consume 추적 포인트 발생 (drop으로 기록하지 않음) */
    trace_consume_skb(skb);
    __kfree_skb(skb);
}

Page Pool 프레임워크

Page Pool은 NIC 드라이버의 RX 경로에서 페이지 할당/해제 오버헤드를 줄이기 위한 페이지 재활용 프레임워크입니다. 페이지를 DMA 매핑 상태로 캐싱하여, 매 패킷마다 alloc_page()/dma_map_page()를 호출하는 비용을 제거합니다.

/* include/net/page_pool/types.h — Page Pool 생성 */
struct page_pool_params {
    unsigned int   flags;           /* PP_FLAG_* */
    unsigned int   order;           /* 페이지 order (보통 0) */
    unsigned int   pool_size;       /* 풀 크기 (Ring Buffer 크기) */
    int            nid;             /* NUMA 노드 */
    struct device  *dev;            /* DMA 매핑용 디바이스 */
    enum dma_data_direction dma_dir; /* DMA_FROM_DEVICE */
    unsigned int   max_len;         /* 최대 버퍼 길이 */
    unsigned int   offset;          /* headroom 오프셋 */
};

/* 드라이버 초기화 시 Page Pool 생성 */
struct page_pool *pool = page_pool_create(&params);

/* NAPI poll에서 페이지 할당 (DMA 매핑 포함) */
struct page *page = page_pool_dev_alloc_pages(pool);

/* 패킷 처리 완료 후 페이지 반환 (재활용) */
page_pool_put_full_page(pool, page, false);

/* sk_buff에서 Page Pool 페이지 사용 시 */
skb_mark_for_recycle(skb);  /* consume_skb 시 자동 재활용 */

소켓 API와 커널 내부 매핑

유저 공간의 BSD 소켓 API 호출이 커널 내부에서 어떤 함수 체인으로 변환되는지를 정리합니다. 이 매핑을 알면 네트워크 문제 디버깅(Debugging) 시 커널 소스의 어디를 확인해야 하는지 바로 파악할 수 있습니다.

소켓 계층 (Socket Layer)

소켓은 유저스페이스 프로세스와 커널 네트워크 스택을 연결하는 인터페이스입니다. struct socket(VFS 인터페이스)과 struct sock(프로토콜 계층)의 이중 구조로 설계되어, 유저 공간 시스템 콜과 프로토콜 구현을 깔끔하게 분리합니다.

struct socket {                    /* VFS/유저 인터페이스 */
    socket_state        state;       /* SS_CONNECTED 등 */
    short               type;        /* SOCK_STREAM, SOCK_DGRAM */
    struct file         *file;       /* VFS file 연결 */
    struct sock         *sk;         /* 프로토콜 소켓 */
    const struct proto_ops *ops;   /* sendmsg/recvmsg 등 */
};

struct sock {                      /* 프로토콜 계층 (TCP/UDP) */
    struct sock_common  __sk_common;
    struct sk_buff_head sk_receive_queue;  /* 수신 큐 */
    struct sk_buff_head sk_write_queue;    /* 송신 큐 */
    atomic_t            sk_wmem_alloc;     /* 송신 버퍼 사용량 */
    atomic_t            sk_rmem_alloc;     /* 수신 버퍼 사용량 */
    int                 sk_sndbuf;         /* SO_SNDBUF */
    int                 sk_rcvbuf;         /* SO_RCVBUF */
    /* ... */
};

소켓 생성 과정

유저 공간에서 socket(AF_INET, SOCK_STREAM, 0)을 호출하면 커널 내부에서 다음 과정이 진행됩니다:

1. sys_socket() → __sock_create(): struct socket 할당
2. inet_create(): AF_INET 패밀리에 등록된 프로토콜(TCP)에서 struct sock 할당
3. sock_map_fd(): VFS 파일 디스크립터(File Descriptor)에 매핑하여 read()/write()/poll() 가능하게 함
4. 프로토콜별 초기화: tcp_v4_init_sock()에서 TCP 관련 필드(혼잡 제어, 재전송 타이머(Timer) 등) 초기화

/* net/socket.c — __sock_create() 핵심 로직 (간략화) */
int __sock_create(struct net *net, int family, int type,
                 int protocol, struct socket **res, int kern)
{
    struct socket *sock;
    const struct net_proto_family *pf;

    /* 1. socket 구조체 할당 (inode 포함) */
    sock = sock_alloc();
    if (!sock)
        return -ENFILE;

    sock->type = type;

    /* 2. 주소 패밀리별 핸들러 조회 */
    pf = rcu_dereference(net_families[family]);
    /* AF_INET → inet_family_ops */
    /* AF_UNIX → unix_family_ops */

    /* 3. 패밀리별 create 호출 */
    err = pf->create(net, sock, protocol, kern);
    /* inet_create(): struct sock 할당, 프로토콜 ops 연결 */

    /* 4. BPF cgroup 소켓 생성 훅 */
    err = security_socket_post_create(sock, family, type, protocol, kern);

    *res = sock;
    return 0;
}

소켓-VFS 연결 구조

소켓은 VFS의 파일 디스크립터를 통해 유저 공간에 노출됩니다. socket() 시스템 콜은 내부적으로 sock_alloc()으로 inode를 생성하고, sock_map_fd()로 파일 디스크립터에 매핑합니다. 이 구조 덕분에 select()/poll()/epoll()로 소켓을 다른 파일과 함께 멀티플렉싱할 수 있습니다.

/* VFS → 소켓 연결 체인 */
/* fd → struct file → file->private_data → struct socket */
/* struct socket → socket->sk → struct sock */
/* struct sock → (struct tcp_sock 또는 struct udp_sock) */

/* 소켓 파일 연산: 소켓도 파일처럼 동작합니다 */
static const struct file_operations socket_file_ops = {
    .owner      = THIS_MODULE,
    .llseek     = no_llseek,       /* seek 미지원 */
    .read_iter  = sock_read_iter,  /* read() → recvmsg() */
    .write_iter = sock_write_iter, /* write() → sendmsg() */
    .poll       = sock_poll,       /* poll/epoll 지원 */
    .unlocked_ioctl = sock_ioctl,  /* ioctl 지원 */
    .mmap       = sock_mmap,       /* mmap (AF_PACKET 등) */
    .release    = sock_close,      /* close() → 소켓 정리 */
    .fasync     = sock_fasync,     /* SIGIO 비동기 알림 */
    .sendpage   = sock_sendpage,   /* sendfile/splice 지원 */
    .splice_write = generic_splice_sendpage,
    .splice_read  = sock_splice_read,
};

주요 소켓 주소 패밀리

소켓 메모리 관리

소켓은 송신/수신 버퍼 크기를 sk_sndbuf/sk_rcvbuf로 제한하며, 실제 사용량을 sk_wmem_alloc/sk_rmem_alloc으로 추적합니다. TCP의 경우 전역 메모리 압력(memory pressure) 메커니즘이 모든 TCP 소켓의 메모리 할당을 조절합니다.

/* net/core/sock.c — 소켓 메모리 회계 핵심 로직 */

/* 수신 방향: sk_buff를 수신 큐에 추가할 때 */
int __sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
{
    unsigned long flags;
    int err = 0;

    /* sk_rmem_alloc + skb->truesize가 sk_rcvbuf 초과 시 드롭 */
    if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
        (unsigned int)READ_ONCE(sk->sk_rcvbuf)) {
        err = -ENOMEM;
        goto out;
    }

    /* skb->truesize만큼 수신 메모리 사용량 증가 */
    skb_set_owner_r(skb, sk);
    __skb_queue_tail(&sk->sk_receive_queue, skb);
    sk->sk_data_ready(sk);  /* 대기 프로세스 깨움 */
out:
    return err;
}

/* TCP 전역 메모리 압력 (sysctl tcp_mem) */
/* tcp_mem[0]: 정상 — 모든 소켓 자유롭게 할당 */
/* tcp_mem[1]: 압력 — 새 할당 제한 시작 */
/* tcp_mem[2]: 한계 — 새 할당 거부 (OOM) */
long sysctl_tcp_mem[3];  /* 페이지 단위 */

# 소켓 메모리 관련 sysctl 확인
sysctl net.ipv4.tcp_mem              # 전역 TCP 메모리 한도 (페이지)
sysctl net.ipv4.tcp_rmem             # 소켓당 수신 버퍼 [min default max]
sysctl net.ipv4.tcp_wmem             # 소켓당 송신 버퍼 [min default max]
sysctl net.core.rmem_max             # SO_RCVBUF 최대값
sysctl net.core.wmem_max             # SO_SNDBUF 최대값

# 현재 TCP 메모리 사용량 확인
cat /proc/net/sockstat | grep TCP    # TCP: inuse, orphan, tw, alloc, mem

TCP 자동 버퍼 튜닝 (Autotuning)

Linux TCP는 수신/송신 버퍼 크기를 연결의 RTT와 대역폭에 따라 자동으로 조정합니다. tcp_rmem/tcp_wmem의 min/default/max 값이 자동 튜닝의 범위를 결정합니다.

/* net/ipv4/tcp_input.c — TCP 자동 수신 버퍼 조정 (간략화) */
void tcp_rcv_space_adjust(struct sock *sk)
{
    struct tcp_sock *tp = tcp_sk(sk);
    int time, space;

    /* RTT 동안 수신된 데이터량으로 필요 버퍼 추정 */
    time = tcp_stamp_us_delta(tp->tcp_mstamp, tp->rcvq_space.time);
    if (time < (tp->rcv_rtt_est.rtt_us >> 3))
        return;

    /* BDP (Bandwidth-Delay Product) 계산 */
    space = 2 * (tp->copied_seq - tp->rcvq_space.seq);
    space = max(tp->rcvq_space.space, space);

    /* sk_rcvbuf 조정 (tcp_rmem[2]가 상한) */
    if (space > READ_ONCE(sk->sk_rcvbuf)) {
        int new_rcvbuf = min(space, READ_ONCE(
            sock_net(sk)->ipv4.sysctl_tcp_rmem[2]));
        WRITE_ONCE(sk->sk_rcvbuf, new_rcvbuf);
    }

    /* 수신 윈도우 스케일링도 같이 조정 */
    tp->rcvq_space.space = space;
    tp->rcvq_space.seq = tp->copied_seq;
    tp->rcvq_space.time = tp->tcp_mstamp;
}

# TCP 자동 튜닝 확인
sysctl net.ipv4.tcp_moderate_rcvbuf    # 1 = 자동 튜닝 활성 (기본)

# 특정 연결의 현재 버퍼 크기 확인
ss -tim dst 10.0.0.1:443
# 출력: skmem:(r0,rb6291456,t0,tb87380,...)
# rb = 현재 수신 버퍼 크기 (자동 조정됨)
# tb = 현재 송신 버퍼 크기

# 자동 튜닝 비활성화 (특정 소켓에서)
# setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size));
# SO_RCVBUF를 명시적으로 설정하면 해당 소켓의 자동 튜닝이 비활성화됩니다

# cgroup v2 소켓 메모리 확인
cat /sys/fs/cgroup/system.slice/docker-<ID>.scope/memory.stat | grep sock
# sock 12345678  (소켓 버퍼 사용량, 바이트)

SO_REUSEPORT와 eBPF 소켓 선택

SO_REUSEPORT는 여러 소켓이 동일한 주소:포트에 바인드할 수 있게 하여, 수신 연결을 여러 프로세스/스레드에 분산합니다. 기본적으로 해시 기반으로 소켓을 선택하며, BPF 프로그램을 부착하여 커스텀 선택 로직을 구현할 수 있습니다.

/* SO_REUSEPORT 기본 사용법 */
int opt = 1;
setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));
bind(fd, addr, addrlen);
listen(fd, backlog);

/* BPF 소켓 선택 프로그램 부착 */
/* net/core/sock_reuseport.c — reuseport_select_sock() */
struct sock *reuseport_select_sock(struct sock *sk,
    u32 hash, struct sk_buff *skb, int hdr_len)
{
    struct sock_reuseport *reuse = rcu_dereference(sk->sk_reuseport_cb);
    struct bpf_prog *prog;

    prog = rcu_dereference(reuse->prog);
    if (prog) {
        /* BPF 프로그램이 소켓 인덱스를 반환 */
        u32 index = bpf_prog_run_save_cb(prog, skb);
        sk2 = reuse->socks[index];
    } else {
        /* 기본: 해시 기반 소켓 선택 */
        sk2 = reuse->socks[reciprocal_scale(hash, reuse->num_socks)];
    }
    return sk2;
}

epoll과 소켓 통합

epoll은 소켓의 이벤트(수신 데이터, 연결 완료, 쓰기 가능 등)를 효율적으로 감시하는 I/O 멀티플렉싱 메커니즘입니다. 소켓의 sk_data_ready, sk_write_space 등의 콜백이 epoll의 대기 큐와 연결됩니다.

/* fs/eventpoll.c + net/core/sock.c — epoll-소켓 연동 경로 */

/* 1. epoll_ctl(EPOLL_CTL_ADD) 시 */
/*    → ep_insert() → ep_item_poll() → sock_poll() */
/*    → init_waitqueue_func_entry(&ep_entry->wait, ep_poll_callback) */
/*    → add_wait_queue(sk_sleep(sk), &ep_entry->wait) */

/* 2. 패킷 수신 시 콜백 체인 */
/*    tcp_v4_rcv() → tcp_data_queue() */
/*    → sk->sk_data_ready(sk) */
/*    → sock_def_readable() */
/*    → wake_up_interruptible_sync_poll(sk_wq, EPOLLIN) */
/*    → ep_poll_callback() */
/*    → ep를 rdllist에 추가 → epoll_wait() 반환 */

/* 3. Edge-Triggered vs Level-Triggered */
struct epoll_event ev;
ev.events = EPOLLIN | EPOLLET;   /* Edge-Triggered */
ev.data.fd = sockfd;
epoll_ctl(epfd, EPOLL_CTL_ADD, sockfd, &ev);

/* ET 모드에서는 데이터를 모두 읽을 때까지 반복해야 합니다 */
/* 그렇지 않으면 새 데이터 도착까지 알림을 받지 못합니다 */

소켓 해시 테이블 조회

수신 패킷이 전송 계층에 도달하면, 4-tuple(소스 IP/포트, 목적지 IP/포트) 해시를 기반으로 대상 소켓을 찾습니다. TCP는 inet_hashinfo 해시 테이블에서, UDP는 udp_table에서 조회합니다.

/* net/ipv4/inet_hashtables.c — TCP 소켓 조회 (간략화) */
struct sock *__inet_lookup_established(
    struct net *net,
    struct inet_hashinfo *hashinfo,
    const __be32 saddr, const __be16 sport,
    const __be32 daddr, const u16 hnum,
    const int dif, const int sdif)
{
    /* 1. 4-tuple 해시 계산 */
    unsigned int hash = inet_ehashfn(net, daddr, hnum,
                                      saddr, sport);
    unsigned int slot = hash & hashinfo->ehash_mask;

    /* 2. 해시 버킷에서 ESTABLISHED 소켓 검색 */
    struct inet_ehash_bucket *head = &hashinfo->ehash[slot];
    sk_for_each_rcu(sk, &head->chain) {
        if (sk->sk_hash != hash)
            continue;
        if (inet_match(net, sk, saddr, daddr, sport, hnum, dif, sdif))
            return sk;
    }

    /* 3. 없으면 LISTEN 해시에서 검색 */
    return __inet_lookup_listener(net, hashinfo, skb,
                                  doff, saddr, sport, daddr, hnum, dif, sdif);
}

# TCP 해시 테이블 크기 확인
dmesg | grep "TCP established hash"
# TCP established hash table entries: 524288 (order: 10, 4194304 bytes)

# 현재 소켓 통계
ss -s                                 # 전체 소켓 요약
cat /proc/net/sockstat                # TCP/UDP 소켓 상세 통계
cat /proc/net/sockstat6               # IPv6 소켓 통계

# LISTEN 소켓의 accept queue 상태
ss -lnt | awk '{print $2, $3, $4}'    # Recv-Q Send-Q Local Address
# Recv-Q = 현재 accept queue 대기 수
# Send-Q = accept queue 최대 크기 (backlog)

네트워크 계층 (IP)

네트워크 계층은 패킷의 소스/목적지 주소 관리, 라우팅, 단편화/재조립을 담당합니다. Linux 커널은 IPv4(net/ipv4/)와 IPv6(net/ipv6/)를 독립적으로 구현하며, 듀얼 스택으로 동시 운영합니다.

IPv4 수신 처리 흐름

/* net/ipv4/ip_input.c — IPv4 수신 진입점 */
int ip_rcv(struct sk_buff *skb, struct net_device *dev,
          struct packet_type *pt, struct net_device *orig_dev)
{
    struct net *net = dev_net(dev);

    /* 1. IP 헤더 길이, 버전, 체크섬 검증 */
    /* 2. pskb_may_pull()로 헤더 접근 보장 */

    /* 3. Netfilter NF_INET_PRE_ROUTING 훅 통과 */
    return NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING,
                  net, NULL, skb, dev, NULL,
                  ip_rcv_finish);
}

/* ip_rcv_finish → ip_route_input_noref()로 FIB 조회 */
/* 결과에 따라: */
/*   로컬 대상 → ip_local_deliver() → L4 전달 */
/*   포워딩   → ip_forward() → ip_output() */
/*   멀티캐스트 → ip_mr_input() */

IP 단편화와 재조립

MTU(Maximum Transmission Unit)보다 큰 패킷은 단편화가 필요합니다. 송신 측에서 ip_fragment()가 수행하며, 수신 측에서 ip_defrag()가 단편을 재조립합니다. DF(Don't Fragment) 비트가 설정된 경우 단편화 대신 ICMP "Fragmentation Needed" 메시지를 반환합니다. Path MTU Discovery는 이 메커니즘을 활용합니다.

이웃 서브시스템 (Neighbour Subsystem)

이웃 서브시스템은 L3 주소(IP)를 L2 주소(MAC)로 변환하는 프레임워크입니다. IPv4에서는 ARP, IPv6에서는 NDP(Neighbor Discovery Protocol)를 사용합니다. struct neighbour는 이웃 항목을 나타내며, 상태 머신을 통해 주소 해석의 진행 상황을 관리합니다.

/* include/net/neighbour.h — struct neighbour 핵심 필드 */
struct neighbour {
    struct neighbour       *next;           /* 해시 체인 */
    struct neigh_table     *tbl;            /* ARP 또는 NDP 테이블 */
    struct neigh_parms     *parms;          /* 인터페이스별 파라미터 */
    unsigned long          updated;         /* 마지막 업데이트 시각 */
    rwlock_t               lock;
    refcount_t             refcnt;
    unsigned int           arp_queue_len_bytes;
    struct sk_buff_head    arp_queue;       /* 해석 대기 패킷 큐 */
    struct timer_list      timer;           /* 상태 전이 타이머 */
    unsigned long          used;            /* 마지막 사용 시각 */
    atomic_t               probes;          /* 보낸 프로브 수 */
    u8                     nud_state;       /* NUD_* 상태 */
    u8                     type;
    u8                     dead;
    u8                     protocol;
    u8                     ha[ALIGN(MAX_ADDR_LEN, sizeof(unsigned long))];
                                             /* 하드웨어 주소 (MAC) */
    struct net_device      *dev;            /* 출력 디바이스 */
    const struct neigh_ops *ops;            /* 출력 콜백 */
    u8                     primary_key[];   /* L3 주소 (IP) */
};

/* net/ipv4/arp.c — arp_process() 핵심 로직 (간략화) */
static int arp_process(struct net *net, struct sock *sk,
                      struct sk_buff *skb)
{
    struct arphdr *arp = arp_hdr(skb);
    unsigned char *sha, *tha;   /* 소스/타깃 하드웨어 주소 */
    __be32 sip, tip;            /* 소스/타깃 IP 주소 */

    /* ARP 헤더에서 주소 추출 */
    arp_ptr = (unsigned char *)(arp + 1);
    sha = arp_ptr;              /* Sender Hardware Address */
    memcpy(&sip, arp_ptr + dev->addr_len, 4);  /* Sender IP */
    tha = arp_ptr + dev->addr_len + 4;          /* Target HA */
    memcpy(&tip, arp_ptr + 2 * dev->addr_len + 4, 4);

    if (arp->ar_op == htons(ARPOP_REQUEST)) {
        /* ARP Request: 대상 IP가 로컬이면 ARP Reply 전송 */
        if (inet_addr_type(net, tip) == RTN_LOCAL) {
            arp_send_dst(ARPOP_REPLY, ETH_P_ARP, sip, dev,
                         tip, sha, dev->dev_addr, sha, reply_dst);
        }
        /* Sender의 MAC-IP 매핑을 이웃 캐시에 갱신 */
        neigh_event_ns(&arp_tbl, sha, &sip, dev);
    } else if (arp->ar_op == htons(ARPOP_REPLY)) {
        /* ARP Reply: Sender의 MAC-IP 매핑 갱신 */
        n = __neigh_lookup(&arp_tbl, &sip, dev, 0);
        if (n) {
            neigh_update(n, sha, NUD_REACHABLE, ...);
            /* arp_queue의 대기 패킷 전송 */
        }
    }
}

/* net/core/neighbour.c — neigh_resolve_output() TX 경로 */
/* IP → 이웃 → dev_queue_xmit 출력 흐름 */
int neigh_resolve_output(struct neighbour *neigh,
                        struct sk_buff *skb)
{
    if (!neigh_event_send(neigh, skb)) {
        /* MAC 주소 해석 완료 → L2 헤더 추가 후 전송 */
        rc = dev_hard_header(skb, dev, ntohs(skb->protocol),
                             neigh->ha, NULL, skb->len);
        if (rc >= 0)
            rc = dev_queue_xmit(skb);
    }
    /* neigh_event_send()가 1을 반환하면: */
    /* ARP/NDP 요청 전송 후 skb를 arp_queue에 대기 */
    return rc;
}

# ARP/이웃 캐시 관리 명령어
ip neigh show                          # ARP 캐시 전체 표시
ip neigh show dev eth0                 # eth0의 이웃 항목만
ip neigh add 192.168.1.1 lladdr aa:bb:cc:dd:ee:ff dev eth0  # 정적 항목 추가
ip neigh flush dev eth0                # eth0의 캐시 초기화

# 이웃 파라미터 조정
sysctl -w net.ipv4.neigh.eth0.base_reachable_time_ms=30000  # REACHABLE 타임아웃
sysctl -w net.ipv4.neigh.eth0.gc_stale_time=60              # STALE GC 시간
sysctl -w net.ipv4.neigh.default.gc_thresh3=4096            # 최대 이웃 항목 수

# IPv6 이웃 탐색
ip -6 neigh show                       # NDP 캐시

ip_rcv_finish() 내부 상세

ip_rcv_finish()는 Netfilter PRE_ROUTING 훅을 통과한 패킷의 라우팅 결정과 목적지 캐시 설정을 담당합니다. Early Demux 최적화를 통해 TCP/UDP 소켓이 이미 결정된 경우 FIB 조회를 생략할 수 있습니다.

/* net/ipv4/ip_input.c — ip_rcv_finish() 핵심 로직 (간략화) */
static int ip_rcv_finish(struct net *net, struct sock *sk,
                         struct sk_buff *skb)
{
    struct net_device *dev = skb->dev;
    int err;

    /* 1. Early Demux — 소켓 캐시에서 dst_entry 획득 */
    if (READ_ONCE(net->ipv4.sysctl_ip_early_demux) &&
        !skb_dst(skb) && !skb->sk) {
        int protocol = ip_hdr(skb)->protocol;

        /* TCP/UDP의 early_demux 콜백 호출 */
        /* 4-tuple로 소켓을 미리 찾아 dst_entry 캐시 사용 */
        ipprot = rcu_dereference(inet_protos[protocol]);
        if (ipprot && ipprot->early_demux)
            ipprot->early_demux(skb);
    }

    /* 2. dst_entry가 없으면 FIB 조회 수행 */
    if (!skb_valid_dst(skb)) {
        err = ip_route_input_noref(skb, ip_hdr(skb)->daddr,
                                   ip_hdr(skb)->saddr,
                                   ip_hdr(skb)->tos, dev);
        if (unlikely(err))
            goto drop;
    }

    /* 3. dst_entry의 input 함수 호출 */
    /*    로컬: ip_local_deliver() */
    /*    포워딩: ip_forward() */
    return dst_input(skb);
}

IP 단편화/재조립 내부

IP 단편화는 패킷이 출력 인터페이스의 MTU를 초과할 때 ip_do_fragment()에서 수행됩니다. 재조립은 수신 측에서 ip_defrag()가 단편을 수집하여 원본 패킷을 복원합니다.

/* net/ipv4/ip_output.c — ip_do_fragment() 핵심 로직 (간략화) */
int ip_do_fragment(struct net *net, struct sock *sk,
                   struct sk_buff *skb,
                   int (*output)(struct net *, struct sock *,
                                struct sk_buff *))
{
    unsigned int mtu = ip_skb_dst_mtu(sk, skb);
    unsigned int hlen = ip_hdrlen(skb);
    unsigned int left = skb->len - hlen;   /* 페이로드 길이 */
    unsigned int len = (mtu - hlen) & ~7;  /* 8바이트 정렬 */
    unsigned int offset = (ntohs(ip_hdr(skb)->frag_off) &
                           IP_OFFSET) << 3;

    /* DF 비트 설정 시 ICMP "Fragmentation Needed" 반환 */
    if (unlikely((ip_hdr(skb)->frag_off & htons(IP_DF)) &&
                 !skb->ignore_df)) {
        icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
                  htonl(mtu));
        goto fail;
    }

    /* 각 단편에 대해: */
    while (left > 0) {
        /* 단편 sk_buff 생성 */
        /* IP 헤더 복사, frag_off 설정, MF 비트 설정 */
        /* output() 콜백으로 전송 */
        left -= len;
        offset += len;
    }
}

/* net/ipv4/ip_fragment.c — ip_defrag() 재조립 핵심 (간략화) */
int ip_defrag(struct net *net, struct sk_buff *skb, u32 user)
{
    struct ipq *qp;

    /* IP ID + 소스/목적지 IP로 재조립 큐 검색/생성 */
    qp = ip_find(net, ip_hdr(skb), user, vif);
    if (!qp)
        goto drop;

    /* 단편을 큐에 삽입 (오프셋 순서 유지) */
    ip_frag_queue(qp, skb);

    /* 모든 단편이 도착했는지 확인 */
    if (ip_frag_reasm(qp, skb, prev_tail, net)) {
        /* 재조립 완료 — 원본 패킷 복원 */
        return 0;
    }
    return -EINPROGRESS;  /* 아직 단편 대기 중 */
}

# IP 단편화 관련 sysctl 설정
sysctl net.ipv4.ipfrag_time              # 재조립 타임아웃 (기본 30초)
sysctl net.ipv4.ipfrag_high_thresh       # 메모리 상한 (기본 4MB)
sysctl net.ipv4.ipfrag_low_thresh        # 메모리 하한 (기본 3MB)
sysctl net.ipv4.ipfrag_max_dist          # 비순차 단편 최대 수 (기본 64)

# 단편화 통계 확인
cat /proc/net/snmp | grep -A1 Ip
# ReasmTimeout ReasmReqds ReasmOKs ReasmFails
# FragOKs FragFails FragCreates

nstat -az | grep -i frag
# IpReasmReqds — 재조립 요청 수
# IpReasmOKs — 재조립 성공 수
# IpReasmFails — 재조립 실패 수
# IpFragOKs — 단편화 성공 수
# IpFragFails — 단편화 실패 수 (DF 비트 등)

# PMTU Discovery 관련
sysctl net.ipv4.ip_no_pmtu_disc          # 0: PMTUD 활성 (기본)
sysctl net.ipv4.tcp_mtu_probing          # 0: 비활성, 1: ICMP 차단 시만, 2: 항상

# 경로 MTU 캐시 확인
ip route get 10.0.0.1                    # mtu 필드 확인
ip route show cache                      # PMTU 캐시된 경로

IP 옵션과 확장 헤더

IPv4 옵션과 IPv6 확장 헤더는 패킷에 추가 정보를 전달하는 메커니즘입니다. 보안과 성능에 영향을 미치므로, 커널은 각 옵션을 엄격하게 검증합니다.

# Source Routing 차단 (보안 강화)
sysctl -w net.ipv4.conf.all.accept_source_route=0
sysctl -w net.ipv6.conf.all.accept_source_route=0

# Reverse Path Filtering (스푸핑 방어)
sysctl -w net.ipv4.conf.all.rp_filter=1     # strict mode
sysctl -w net.ipv4.conf.all.rp_filter=2     # loose mode (멀티호밍 시)

# ICMP 리다이렉트 차단
sysctl -w net.ipv4.conf.all.accept_redirects=0
sysctl -w net.ipv4.conf.all.send_redirects=0
sysctl -w net.ipv6.conf.all.accept_redirects=0

전송 계층 (Transport Layer)

전송 계층은 종단 간 데이터 전달의 신뢰성, 흐름 제어(Flow Control), 멀티플렉싱을 담당합니다. Linux 커널은 struct proto 인터페이스를 통해 다양한 전송 프로토콜을 플러그인 방식으로 지원합니다.

TCP 개요

Linux TCP 구현은 RFC 793 상태 머신(CLOSED, LISTEN, SYN_SENT, SYN_RECEIVED, ESTABLISHED, FIN_WAIT_1, FIN_WAIT_2, CLOSE_WAIT, CLOSING, LAST_ACK, TIME_WAIT)을 정밀하게 구현합니다. 플러그인 방식의 혼잡 제어(CUBIC 기본, BBR, Reno, DCTCP 등), kTLS, Zero-Copy sendfile, RACK/TLP 재전송을 지원합니다.

/* 혼잡 제어 알고리즘 등록 인터페이스 */
struct tcp_congestion_ops {
    struct list_head  list;
    u32               key;
    u32               flags;

    /* 혼잡 이벤트 콜백 */
    void (*init)(struct sock *sk);
    void (*cong_avoid)(struct sock *sk, u32 ack, u32 acked);
    u32  (*ssthresh)(struct sock *sk);
    void (*cwnd_event)(struct sock *sk, enum tcp_ca_event ev);
    void (*pkts_acked)(struct sock *sk, const struct ack_sample *sample);
    /* ... */

    char              name[TCP_CA_NAME_MAX];
    struct module     *owner;
};

# TCP 혼잡 제어 알고리즘 관리
sysctl net.ipv4.tcp_congestion_control           # 현재 기본 알고리즘
sysctl net.ipv4.tcp_available_congestion_control  # 사용 가능한 알고리즘
sysctl net.ipv4.tcp_allowed_congestion_control    # 비root 사용 허용

# BBR 활성화
sysctl -w net.core.default_qdisc=fq              # BBR은 fq qdisc 필요
sysctl -w net.ipv4.tcp_congestion_control=bbr

# 소켓별 혼잡 제어 변경 (프로그래밍)
# setsockopt(fd, IPPROTO_TCP, TCP_CONGESTION, "bbr", 3);

# TCP 상태별 소켓 수 확인
ss -s | grep TCP
cat /proc/net/sockstat | grep TCP

# 특정 연결의 TCP 내부 상태 확인
ss -ti dst 10.0.0.1:443
# 출력: cubic wscale:7,7 rto:204 rtt:1.234/0.567
# cwnd:10 ssthresh:7 bytes_sent:12345 retrans:0/0

TCP 윈도우 관리

TCP는 수신 윈도우(rwnd)와 혼잡 윈도우(cwnd)의 최솟값으로 전송 속도를 결정합니다. 수신 윈도우는 수신자의 버퍼 가용 공간을 나타내고, 혼잡 윈도우는 네트워크의 가용 용량을 추정합니다.

/* TCP 전송 가능량 결정 */
/* effective_window = min(cwnd, rwnd) - in_flight */

/* net/ipv4/tcp_output.c — tcp_write_xmit() 핵심 로직 (간략화) */
static bool tcp_write_xmit(struct sock *sk,
                           unsigned int mss_now, int nonagle,
                           int push_one, gfp_t gfp)
{
    struct tcp_sock *tp = tcp_sk(sk);
    unsigned int cwnd_quota;

    while ((skb = tcp_send_head(sk))) {
        cwnd_quota = tcp_cwnd_test(tp, skb);
        if (!cwnd_quota) {
            /* cwnd 초과 — 전송 중단 */
            tcp_chrono_start(sk, TCP_CHRONO_RWND_LIMITED);
            break;
        }

        /* Nagle 알고리즘 확인 */
        if (unlikely(!tcp_nagle_test(tp, skb, mss_now, nonagle)))
            break;

        /* 수신 윈도우 확인 */
        if (unlikely(!tcp_snd_wnd_test(tp, skb, mss_now)))
            break;

        /* TSO/GSO 세그먼트 수 결정 */
        tso_segs = tcp_init_tso_segs(skb, mss_now);

        /* 전송 */
        tcp_transmit_skb(sk, skb, 1, gfp);
        tcp_event_new_data_sent(sk, skb);
    }
    return !tp->packets_out;
}

UDP 개요

UDP는 비연결형 프로토콜로, 상태 머신이나 혼잡 제어 없이 패킷을 전달합니다. udp_sendmsg()에서 IP 계층으로 즉시 전달하고, udp_rcv()에서 포트 번호 기반으로 소켓에 전달합니다. UDP-GRO를 지원하여 수신 성능을 개선하며, QUIC(UDP 기반 HTTP/3) 프로토콜의 기반이 됩니다.

kTLS (Kernel TLS)

kTLS는 TLS 레코드 계층의 암호화/복호화를 커널 공간에서 수행하는 기능입니다. 유저 공간의 TLS 라이브러리(OpenSSL 등)가 핸드셰이크를 완료한 후, 세션 키를 커널에 전달하면 이후의 데이터 전송은 커널 TCP 계층에서 직접 암호화됩니다. sendfile()과 결합하면 TLS 정적 파일 서빙에서 유저 공간 복사를 완전히 제거할 수 있습니다.

/* kTLS 설정 — 유저 공간 (OpenSSL 핸드셰이크 후) */

/* 1. ULP(Upper Layer Protocol)로 TLS 설정 */
setsockopt(fd, SOL_TCP, TCP_ULP, "tls", sizeof("tls"));

/* 2. TX 방향 암호화 키 설정 */
struct tls12_crypto_info_aes_gcm_128 crypto_info;
crypto_info.info.version = TLS_1_2_VERSION;
crypto_info.info.cipher_type = TLS_CIPHER_AES_GCM_128;
memcpy(crypto_info.iv, iv, TLS_CIPHER_AES_GCM_128_IV_SIZE);
memcpy(crypto_info.key, key, TLS_CIPHER_AES_GCM_128_KEY_SIZE);
memcpy(crypto_info.salt, salt, TLS_CIPHER_AES_GCM_128_SALT_SIZE);
memcpy(crypto_info.rec_seq, rec_seq, TLS_CIPHER_AES_GCM_128_REC_SEQ_SIZE);

setsockopt(fd, SOL_TLS, TLS_TX, &crypto_info, sizeof(crypto_info));

/* 3. RX 방향 복호화 키 설정 (선택적) */
setsockopt(fd, SOL_TLS, TLS_RX, &crypto_info_rx, sizeof(crypto_info_rx));

/* 이후 send()/sendfile()은 커널에서 자동 암호화 */
sendfile(fd, file_fd, NULL, file_size);
/* 파일 → 페이지 캐시 → 커널 TLS 암호화 → NIC */
/* 유저 공간 복사 0회! */

# kTLS 활성화 확인
grep TLS /boot/config-$(uname -r)     # CONFIG_TLS=m
modprobe tls                           # 모듈 로드

# kTLS 통계 확인
cat /proc/net/tls_stat
# TlsCurrTxSw   TlsCurrRxSw   TlsCurrTxDevice   TlsCurrRxDevice
# TlsTxSw       TlsRxSw       TlsTxDevice        TlsRxDevice

# NIC kTLS 하드웨어 오프로드 확인
ethtool -k eth0 | grep tls
# tls-hw-tx-offload: on
# tls-hw-rx-offload: on

SCTP 개요

SCTP(Stream Control Transmission Protocol)는 멀티스트리밍과 멀티호밍을 지원하는 전송 프로토콜입니다. 하나의 연결(association) 내에 여러 스트림을 가질 수 있어 Head-of-Line Blocking을 방지하고, 여러 IP 주소를 동시에 사용하여 경로 장애에 대한 복원력을 제공합니다.

TCP 수신 경로 내부 (tcp_v4_rcv)

tcp_v4_rcv()는 IP 계층에서 TCP 패킷을 수신하는 진입점입니다. 소켓 조회, 시퀀스 번호 검증, ACK 처리, 데이터 큐잉을 수행합니다. 성능을 위해 Fast Path(헤더 예측)와 Slow Path를 구분합니다.

/* net/ipv4/tcp_ipv4.c — tcp_v4_rcv() 핵심 로직 (간략화) */
int tcp_v4_rcv(struct sk_buff *skb)
{
    const struct tcphdr *th = tcp_hdr(skb);
    struct sock *sk;

    /* 1. TCP 체크섬 검증 */
    if (skb_checksum_init(skb, IPPROTO_TCP, inet_compute_pseudo))
        goto csum_error;

    /* 2. 소켓 조회 (4-tuple 해시) */
    sk = __inet_lookup_skb(&tcp_hashinfo, skb, __tcp_hdrlen(th),
                           th->source, th->dest, sdif, &refcounted);
    if (!sk)
        goto no_tcp_socket;

    /* 3. TIME_WAIT 상태 처리 */
    if (sk->sk_state == TCP_TIME_WAIT)
        goto do_time_wait;

    /* 4. 소켓 락 획득 시도 */
    if (!sock_owned_by_user(sk)) {
        /* Fast path: 소켓 락 미보유 → 즉시 처리 */
        ret = tcp_v4_do_rcv(sk, skb);
    } else {
        /* Slow path: 유저 프로세스가 락 보유 중 */
        /* backlog 큐에 추가, release_sock() 시 처리 */
        if (!tcp_add_backlog(sk, skb))
            goto discard_and_relse;
    }
    return ret;
}

/* net/ipv4/tcp_input.c — TCP Fast Path (Header Prediction) */
int tcp_rcv_established(struct sock *sk, struct sk_buff *skb)
{
    struct tcp_sock *tp = tcp_sk(sk);

    /* 헤더 예측: 예상 시퀀스, 예상 ACK, 단순 데이터 패킷 */
    if ((tcp_flag_word(th) & TCP_HP_BITS) == tp->pred_flags &&
        TCP_SKB_CB(skb)->seq == tp->rcv_nxt) {

        /* ★ Fast Path — 99%+ 패킷이 이 경로 */

        /* 순수 ACK (데이터 없음) */
        if (skb->len == tcp_header_len) {
            tcp_ack(sk, skb, 0);
            __kfree_skb(skb);
            return;
        }

        /* 데이터 패킷 — 소켓 수신 큐에 직접 추가 */
        eaten = tcp_queue_rcv(sk, skb, &fragstolen);
        tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
        tcp_event_data_recv(sk, skb);
        __tcp_ack_snd_check(sk, 0);  /* 지연 ACK 확인 */
        return;
    }

    /* ★ Slow Path — OOO, 재전송, FIN 등 */
    tcp_data_queue(sk, skb);
}

TCP 타이머 시스템

TCP는 신뢰성 있는 전송을 위해 여러 타이머를 운영합니다. 각 타이머는 특정 상태에서 활성화되며, 만료 시 재전송, 연결 종료, 또는 keepalive 프로브를 수행합니다.

/* net/ipv4/tcp_timer.c — TCP 타이머 콜백 등록 */
void tcp_init_xmit_timers(struct sock *sk)
{
    /* 재전송/TLP 타이머 */
    inet_csk_init_xmit_timers(sk,
        &tcp_write_timer,     /* 재전송 타이머 만료 시 */
        &tcp_delack_timer,    /* 지연 ACK 타이머 만료 시 */
        &tcp_keepalive_timer); /* Keepalive 타이머 만료 시 */
}

/* tcp_write_timer() → tcp_retransmit_timer() */
void tcp_retransmit_timer(struct sock *sk)
{
    struct tcp_sock *tp = tcp_sk(sk);

    /* RTO 만료: 가장 오래된 미확인 세그먼트 재전송 */
    if (tcp_retransmit_skb(sk, tcp_rtx_queue_head(sk), 1))
        return;

    /* RTO 지수 백오프 (최대 120초) */
    inet_csk(sk)->icsk_rto = min(inet_csk(sk)->icsk_rto << 1,
                                   TCP_RTO_MAX);

    /* 최대 재시도 횟수 초과 시 연결 중단 */
    if (tcp_out_of_resources(sk, true))
        return;

    tcp_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
                         inet_csk(sk)->icsk_rto, TCP_RTO_MAX);
}

TCP 제로카피 메커니즘

TCP에서 제로카피(Zero-Copy)는 유저 공간 버퍼의 데이터를 커널 버퍼로 복사하지 않고 직접 NIC에 전달하는 기법입니다. MSG_ZEROCOPY(송신), sendfile()(파일→소켓), TCP receive zero-copy(수신) 등 여러 방식이 있습니다.

/* MSG_ZEROCOPY 송신 — 유저 공간 */
setsockopt(fd, SOL_SOCKET, SO_ZEROCOPY, &one, sizeof(one));

/* 제로카피 전송 */
send(fd, buf, len, MSG_ZEROCOPY);

/* 완료 통지 수신 (errqueue에서) */
struct msghdr msg = {};
struct sock_extended_err *serr;
char cmsg_buf[64];

msg.msg_control = cmsg_buf;
msg.msg_controllen = sizeof(cmsg_buf);

/* MSG_ERRQUEUE에서 완료 통지 읽기 */
recvmsg(fd, &msg, MSG_ERRQUEUE);

/* serr->ee_origin == SO_EE_ORIGIN_ZEROCOPY */
/* serr->ee_data = 완료된 전송의 카운터 */
/* 이 시점 이후 buf를 안전하게 재사용할 수 있습니다 */

/* sendfile() — 커널 내부 경로 */
/* sys_sendfile() → do_sendfile() → do_splice_direct() */
/*   → splice_direct_to_actor() → pipe + tcp_splice_read/write */

/* sendfile(out_fd, in_fd, offset, count) */
/* 파일 → 파이프 → 소켓 전송 (유저 공간 복사 없음) */
/* 페이지 캐시의 페이지를 sk_buff의 frags[]에 직접 매핑 */

/* 커널 내부: tcp_sendpage() 또는 tcp_sendmsg_locked() */
/* skb_fill_page_desc()로 파일 페이지를 skb에 추가 */
skb_fill_page_desc(skb, i, page, offset, len);
/* → NIC DMA scatter-gather로 직접 전송 */

TCP 연결 관리 내부

TCP 연결 수립은 SYN Queue(half-open)와 Accept Queue(established)의 이중 큐 구조로 관리됩니다. SYN Flood 공격 방어를 위한 SYN Cookie 메커니즘과, 지연을 줄이기 위한 TCP Fast Open도 구현되어 있습니다.

/* TCP 연결 수립 큐 구조 */

/* SYN Queue (half-open 연결): request_sock */
/* 클라이언트 SYN → request_sock 생성 → SYN+ACK 전송 */
/* 최대 크기: sysctl tcp_max_syn_backlog (기본 256) */

/* Accept Queue (완전 연결): */
/* 클라이언트 ACK → full sock 생성 → accept queue 삽입 */
/* 최대 크기: listen(fd, backlog)의 backlog 인수 */
/* 또는 sysctl net.core.somaxconn (기본 4096) */

/* SYN Cookie 메커니즘 */
/* SYN Queue 오버플로우 시 활성화 (tcp_syncookies=1) */
u32 __cookie_v4_init_sequence(const struct iphdr *iph,
                              const struct tcphdr *th,
                              u16 *mssp)
{
    /* ISN에 MSS, 타임스탬프, 비밀 키를 인코딩 */
    /* SYN+ACK의 시퀀스 번호 자체에 연결 정보 저장 */
    /* → request_sock 할당 불필요 → 메모리 고갈 방지 */
    return secure_tcp_syn_cookie(saddr, daddr, sport, dport,
                                 sseq, data);
}

/* TCP Fast Open (TFO) */
/* 첫 연결: 쿠키 요청 (TCP option) */
/* 이후 연결: SYN + 쿠키 + 데이터 → 0-RTT 핸드셰이크 */
/* sysctl: net.ipv4.tcp_fastopen = 3 (클라이언트+서버) */

UDP 내부 상세

UDP는 TCP에 비해 단순하지만, 고성능 처리를 위한 다양한 최적화가 구현되어 있습니다. VXLAN, WireGuard 등의 터널링 프로토콜이 UDP 캡슐화를 사용하므로, UDP 수신 경로의 성능은 네트워크 가상화에 직접적인 영향을 미칩니다.

/* net/ipv4/udp.c — __udp4_lib_rcv() 핵심 로직 (간략화) */
int __udp4_lib_rcv(struct sk_buff *skb,
                   struct udp_table *udptable, int proto)
{
    struct sock *sk;
    const struct udphdr *uh = udp_hdr(skb);

    /* 1. UDP 체크섬 검증 */
    if (udp4_csum_init(skb, uh, proto))
        goto csum_error;

    /* 2. 소켓 조회 (dest port 해시) */
    sk = __udp4_lib_lookup_skb(skb, uh->source, uh->dest, udptable);

    if (sk) {
        /* 3a. UDP 캡슐화 (VXLAN, WireGuard 등) */
        if (udp_sk(sk)->encap_type) {
            int ret = udp_sk(sk)->encap_rcv(sk, skb);
            if (ret <= 0)
                return -ret;
            /* ret > 0: 캡슐화 처리 안 함, 일반 UDP 계속 */
        }

        /* 3b. 일반 UDP 수신 */
        return udp_unicast_rcv_skb(sk, skb, uh);
    }

    /* 4. 소켓 없음 → ICMP Port Unreachable */
    icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
    goto drop;
}

UDP-GRO와 UDP GSO

UDP-GRO는 NIC 또는 GRO 계층에서 동일 플로우의 연속 UDP 패킷을 하나의 큰 sk_buff로 병합합니다. UDP GSO는 반대로 대형 UDP 데이터그램을 세그먼트로 분할하여 전송합니다. 두 기능 모두 QUIC, WireGuard 등 UDP 기반 프로토콜의 성능을 크게 향상시킵니다.

/* UDP GSO 송신 — 유저 공간 설정 */
int gso_size = 1472;  /* 세그먼트 크기 (MTU - IP/UDP 헤더) */
setsockopt(fd, IPPROTO_UDP, UDP_SEGMENT,
           &gso_size, sizeof(gso_size));

/* 대형 데이터그램 전송 (최대 64KB) */
/* 커널이 자동으로 gso_size 단위로 분할 */
send(fd, large_buf, 65507, 0);

/* 또는 sendmsg로 세그먼트 크기 지정 */
struct msghdr msg = {};
char cmsg_buf[CMSG_SPACE(sizeof(uint16_t))];
msg.msg_control = cmsg_buf;
msg.msg_controllen = sizeof(cmsg_buf);

struct cmsghdr *cm = CMSG_FIRSTHDR(&msg);
cm->cmsg_level = SOL_UDP;
cm->cmsg_type = UDP_SEGMENT;
cm->cmsg_len = CMSG_LEN(sizeof(uint16_t));
*(uint16_t *)CMSG_DATA(cm) = gso_size;

sendmsg(fd, &msg, 0);

/* UDP-GRO 수신 — 유저 공간 설정 */
int val = 1;
setsockopt(fd, IPPROTO_UDP, UDP_GRO, &val, sizeof(val));

/* recvmsg()에서 GRO된 대형 데이터그램 수신 */
/* cmsg로 각 세그먼트의 크기 정보 전달 */
struct cmsghdr *cm;
for (cm = CMSG_FIRSTHDR(&msg); cm; cm = CMSG_NXTHDR(&msg, cm)) {
    if (cm->cmsg_type == UDP_GRO) {
        uint16_t gro_size = *(uint16_t *)CMSG_DATA(cm);
        /* gro_size 단위로 수신 데이터를 분리 처리 */
    }
}

UDP 송신 코크 모드 (Cork Mode)

UDP 코크 모드(UDP_CORK)는 여러 send() 호출의 데이터를 하나의 UDP 데이터그램으로 결합하여 전송합니다. 애플리케이션이 여러 조각의 데이터를 순차적으로 기록한 후 하나의 패킷으로 전송해야 할 때 유용합니다.

/* UDP Cork 모드 사용 */
int cork = 1;
setsockopt(fd, IPPROTO_UDP, UDP_CORK, &cork, sizeof(cork));

/* 여러 write()가 하나의 UDP 데이터그램에 축적 */
send(fd, header, header_len, 0);   /* 아직 전송 안 됨 */
send(fd, payload, payload_len, 0); /* 아직 전송 안 됨 */
send(fd, trailer, trailer_len, 0); /* 아직 전송 안 됨 */

/* Cork 해제 시 축적된 데이터를 하나의 데이터그램으로 전송 */
cork = 0;
setsockopt(fd, IPPROTO_UDP, UDP_CORK, &cork, sizeof(cork));
/* 이 시점에 header+payload+trailer가 하나의 UDP 패킷으로 전송 */

프로토콜 등록 메커니즘

Linux 커널의 네트워크 스택은 프로토콜 독립적인 프레임워크로 설계되어, 새로운 네트워크/전송 프로토콜을 모듈로 등록할 수 있습니다. 이 구조 덕분에 IPv4, IPv6, TCP, UDP, SCTP 등이 동일한 인터페이스를 통해 동작합니다.

L3 프로토콜 등록: packet_type

L2(이더넷 등) 위에서 동작하는 L3 프로토콜은 struct packet_type을 dev_add_pack()으로 등록합니다. 패킷이 __netif_receive_skb()에 도달하면 skb->protocol(EtherType)에 따라 등록된 핸들러가 호출됩니다.

/* net/ipv4/af_inet.c — IPv4 프로토콜 등록 */
static struct packet_type ip_packet_type __read_mostly = {
    .type = cpu_to_be16(ETH_P_IP),   /* EtherType 0x0800 */
    .func = ip_rcv,                   /* 수신 핸들러 */
};

/* 초기화 시 등록 */
dev_add_pack(&ip_packet_type);

/* IPv6의 경우: ETH_P_IPV6 (0x86DD) → ipv6_rcv() */
/* ARP의 경우: ETH_P_ARP (0x0806) → arp_rcv() */

L4 프로토콜 등록: net_protocol

IP 계층 위에서 동작하는 L4 프로토콜은 struct net_protocol을 inet_add_protocol()로 등록합니다. IP 헤더의 프로토콜 번호에 따라 해당 핸들러가 호출됩니다.

/* net/ipv4/af_inet.c — TCP/UDP/ICMP 프로토콜 등록 */
static const struct net_protocol tcp_protocol = {
    .handler     = tcp_v4_rcv,       /* TCP 수신 핸들러 */
    .err_handler = tcp_v4_err,       /* ICMP 에러 핸들러 */
    .no_policy   = 1,
};

static const struct net_protocol udp_protocol = {
    .handler     = udp_rcv,          /* UDP 수신 핸들러 */
    .err_handler = udp_err,
    .no_policy   = 1,
};

/* IP 프로토콜 번호로 등록 */
inet_add_protocol(&tcp_protocol, IPPROTO_TCP);   /* 프로토콜 6 */
inet_add_protocol(&udp_protocol, IPPROTO_UDP);   /* 프로토콜 17 */
inet_add_protocol(&icmp_protocol, IPPROTO_ICMP); /* 프로토콜 1 */

소켓 프로토콜 등록: struct proto

소켓 계층에서 사용할 프로토콜은 struct proto를 proto_register()로 등록합니다. 이 구조체는 connect(), sendmsg(), recvmsg() 등의 프로토콜별 구현을 담습니다.

/* net/ipv4/tcp_ipv4.c — TCP 프로토콜 오퍼레이션 */
struct proto tcp_prot = {
    .name           = "TCP",
    .owner          = THIS_MODULE,
    .close          = tcp_close,
    .connect        = tcp_v4_connect,
    .disconnect     = tcp_disconnect,
    .accept         = inet_csk_accept,
    .sendmsg        = tcp_sendmsg,
    .recvmsg        = tcp_recvmsg,
    .setsockopt     = tcp_setsockopt,
    .getsockopt     = tcp_getsockopt,
    .hash           = inet_hash,
    .unhash         = inet_unhash,
    .obj_size       = sizeof(struct tcp_sock),
    /* ... */
};
EXPORT_SYMBOL(tcp_prot);

주소 패밀리 등록: inet_protosw

소켓 타입(SOCK_STREAM, SOCK_DGRAM 등)과 프로토콜의 매핑은 struct inet_protosw 배열로 정의됩니다. socket(AF_INET, SOCK_STREAM, 0) 호출 시 이 배열에서 적절한 프로토콜을 찾습니다.

/* net/ipv4/af_inet.c — AF_INET 프로토콜 스위치 */
static struct inet_protosw inetsw_array[] = {
    {
        .type     = SOCK_STREAM,       /* 스트림 소켓 */
        .protocol = IPPROTO_TCP,       /* → TCP */
        .prot     = &tcp_prot,         /* struct proto */
        .ops      = &inet_stream_ops,  /* struct proto_ops */
    },
    {
        .type     = SOCK_DGRAM,        /* 데이터그램 소켓 */
        .protocol = IPPROTO_UDP,       /* → UDP */
        .prot     = &udp_prot,
        .ops      = &inet_dgram_ops,
    },
    {
        .type     = SOCK_RAW,          /* RAW 소켓 */
        .protocol = IPPROTO_IP,        /* → RAW */
        .prot     = &raw_prot,
        .ops      = &inet_sockraw_ops,
    },
};

Netfilter 프레임워크

Netfilter는 커널의 패킷 필터링 프레임워크입니다. 네트워크 스택의 5개 훅 포인트에 콜백을 등록하여 패킷을 검사, 수정, 차단합니다. iptables/nftables, conntrack, NAT의 백엔드입니다.

Netfilter 훅별 역할

conntrack (연결 추적(Connection Tracking))

Netfilter의 연결 추적 시스템(nf_conntrack)은 모든 연결의 상태를 추적하여 stateful 방화벽(Firewall)과 NAT를 가능하게 합니다. 각 연결은 struct nf_conn으로 표현되며, 해시 테이블(Hash Table)에 저장됩니다. 연결 상태는 NEW, ESTABLISHED, RELATED, INVALID로 분류됩니다.

# conntrack 상태 확인
conntrack -L                          # 전체 연결 목록
conntrack -C                          # 현재 추적 중인 연결 수
cat /proc/sys/net/netfilter/nf_conntrack_max  # 최대 추적 수
cat /proc/sys/net/netfilter/nf_conntrack_count # 현재 추적 수

Netfilter 훅 등록 내부

Netfilter 훅 함수는 nf_register_net_hook()으로 등록하며, 각 훅 포인트에 우선순위(priority) 기반으로 정렬됩니다. 패킷이 훅 포인트를 통과할 때 nf_hook_slow()가 등록된 함수들을 순서대로 호출합니다.

/* include/linux/netfilter.h — 훅 등록 구조체 */
struct nf_hook_ops {
    nf_hookfn           *hook;       /* 훅 콜백 함수 */
    struct net_device   *dev;        /* 디바이스 필터 (선택) */
    int                 hooknum;     /* NF_INET_* 훅 포인트 */
    int                 priority;    /* 실행 우선순위 */
};

/* net/netfilter/core.c — nf_hook_slow() 처리 루프 (간략화) */
int nf_hook_slow(struct sk_buff *skb,
                struct nf_hook_state *state,
                const struct nf_hook_entries *e,
                unsigned int s)
{
    unsigned int verdict;

    for (; s < e->num_hook_entries; s++) {
        verdict = nf_hook_entry_hookfn(&e->hooks[s], skb, state);
        switch (verdict & NF_VERDICT_MASK) {
        case NF_ACCEPT:
            break;              /* 다음 훅으로 계속 */
        case NF_DROP:
            kfree_skb(skb);
            return NF_DROP;     /* 패킷 폐기 */
        case NF_STOLEN:
            return NF_STOLEN;   /* 모듈이 소유권 가져감 */
        case NF_QUEUE:
            /* NFQUEUE로 유저 공간 전달 */
            return nf_queue(skb, state, s, verdict);
        case NF_REPEAT:
            s--;                   /* 현재 훅 재실행 */
            break;
        }
    }
    return 1;  /* 모든 훅 통과 */
}

nf_conntrack 내부 구현

연결 추적은 패킷의 5-tuple(프로토콜, 소스/목적지 IP:포트)을 기반으로 해시 테이블에서 연결 항목(struct nf_conn)을 조회합니다. NAT 변환 시 원본 방향(original)과 응답 방향(reply)의 tuple 쌍이 저장됩니다.

/* net/netfilter/nf_conntrack_core.c — 연결 추적 핵심 (간략화) */
unsigned int nf_conntrack_in(struct sk_buff *skb,
                             const struct nf_hook_state *state)
{
    struct nf_conn *ct;
    enum ip_conntrack_info ctinfo;
    struct nf_conntrack_tuple tuple;

    /* 1. 패킷에서 tuple 추출 (프로토콜, IP, 포트) */
    if (!nf_ct_get_tuple(skb, &tuple))
        return NF_ACCEPT;

    /* 2. 해시 테이블에서 기존 연결 조회 */
    u32 hash = hash_conntrack_raw(&tuple, zone);
    ct = __nf_conntrack_find_get(net, zone, &tuple, hash);

    if (!ct) {
        /* 3. 새 연결: nf_conn 할당, NEW 상태 */
        ct = init_conntrack(net, tmpl, &tuple, skb, dataoff, hash);
        if (!ct || IS_ERR(ct))
            return NF_DROP;
    }

    /* 4. 프로토콜별 추적 업데이트 */
    /* TCP: 상태 머신 전이 (SYN_SENT→ESTABLISHED 등) */
    /* UDP: 타임아웃 갱신 */
    ret = nf_conntrack_handle_packet(ct, skb, dataoff, ctinfo, state);

    /* 5. skb에 conntrack 정보 연결 */
    nf_ct_set(skb, ct, ctinfo);
    return ret;
}

# conntrack 튜닝 명령어

# 최대 추적 수 증가 (기본 65536)
sysctl -w net.netfilter.nf_conntrack_max=262144

# 해시 버킷 수 조정 (모듈 로드 시)
# modprobe nf_conntrack hashsize=65536
echo 65536 > /sys/module/nf_conntrack/parameters/hashsize

# 타임아웃 최적화
sysctl -w net.netfilter.nf_conntrack_tcp_timeout_established=86400
sysctl -w net.netfilter.nf_conntrack_tcp_timeout_time_wait=30
sysctl -w net.netfilter.nf_conntrack_udp_timeout=30
sysctl -w net.netfilter.nf_conntrack_udp_timeout_stream=120

# conntrack 이벤트 모니터링
conntrack -E                          # 실시간 이벤트 감시
conntrack -E -e NEW,DESTROY           # 연결 생성/삭제만

# conntrack 통계
cat /proc/net/stat/nf_conntrack       # per-CPU 통계
# 열: searched found new invalid ignore delete ...
# drop early_drop error search_restart

nftables vs iptables 아키텍처

nftables는 iptables의 후속으로, 바이트코드 VM 기반의 유연한 패킷 분류 엔진을 제공합니다. iptables의 테이블/체인/규칙 구조를 유지하면서도, set 인프라(해시/RB-tree/bitmap)와 verdict map으로 성능과 표현력을 개선합니다.

nftables 바이트코드 VM 명령어 예시

nft add rule inet filter input tcp dport 80 accept 의 내부 표현:

명령어 1: meta load l4proto → reg1
  [ meta load l4proto => reg 1 ]
명령어 2: cmp eq reg1 0x06 (TCP)
  [ cmp eq reg 1 0x00000006 ]
명령어 3: payload load 2b @ transport header + 2 → reg1
  [ payload load 2b @ transport header + 2 => reg 1 ]
명령어 4: cmp eq reg1 0x0050 (포트 80)
  [ cmp eq reg 1 0x00005000 ]
명령어 5: immediate verdict accept
  [ immediate reg 0 accept ]

Set을 사용한 O(1) 조회 예시:

nft add set inet filter allowed_ports { type inet_service; }
nft add element inet filter allowed_ports { 80, 443, 8080 }
nft add rule inet filter input tcp dport @allowed_ports accept
→ lookup 명령이 해시 테이블에서 O(1) 조회

Flowtable 가속 경로

Netfilter Flowtable은 ESTABLISHED 연결의 패킷을 Netfilter 훅을 우회하여 빠르게 전달하는 가속 메커니즘입니다. conntrack이 연결을 추적한 후, Flowtable에 등록된 플로우는 PRE_ROUTING 단계에서 바로 출력 인터페이스로 전달됩니다.

/* net/netfilter/nf_flow_table_core.c — Flowtable 동작 원리 */

/* 1. nftables에서 flowtable 정의 */
/*    nft add flowtable inet filter ft { */
/*        hook ingress priority 0; */
/*        devices = { eth0, eth1 }; */
/*    } */

/* 2. forward 체인에서 flow offload 규칙 추가 */
/*    nft add rule inet filter forward */
/*        ct state established flow add @ft */

/* 3. 커널 내부: flow 엔트리 조회 및 fast path */
unsigned int nf_flow_offload_ip_hook(void *priv,
                                     struct sk_buff *skb,
                                     const struct nf_hook_state *state)
{
    struct flow_offload_tuple_rhash *tuplehash;
    struct nf_flowtable *flow_table = priv;

    /* flow 테이블에서 조회 (rhashtable) */
    tuplehash = flow_offload_lookup(flow_table, &tuple);
    if (!tuplehash)
        return NF_ACCEPT;  /* 미등록: 일반 경로 */

    /* Fast path: IP TTL 감소, MAC 헤더 교체 */
    ip_decrease_ttl(ip_hdr(skb));
    nf_flow_nat_ip(flow, skb, thoff, dir);  /* NAT 적용 */
    skb->dev = outdev;
    neigh_xmit(NEIGH_ARP_TABLE, outdev, &nexthop, skb);
    return NF_STOLEN;  /* Netfilter 훅 체인 우회 */
}

네트워크 디바이스와 NAPI

struct net_device는 네트워크 인터페이스(eth0, wlan0 등)를 나타냅니다. net_device_ops로 드라이버 콜백을 등록하고, NAPI를 통해 고속 패킷 처리를 수행합니다.

net_device 핵심 필드

struct net_device {
    char                       name[IFNAMSIZ];    /* 인터페이스 이름 */
    unsigned int               mtu;               /* 최대 전송 단위 */
    unsigned int               flags;             /* IFF_UP, IFF_PROMISC 등 */
    unsigned char              dev_addr[MAX_ADDR_LEN]; /* MAC 주소 */

    const struct net_device_ops  *netdev_ops;     /* 드라이버 콜백 */
    const struct ethtool_ops    *ethtool_ops;    /* ethtool 콜백 */

    struct netdev_rx_queue      *_rx;             /* RX 큐 배열 */
    unsigned int               num_rx_queues;    /* RX 큐 수 */
    struct netdev_queue         *_tx;             /* TX 큐 배열 */
    unsigned int               num_tx_queues;    /* TX 큐 수 */

    struct Qdisc               *qdisc;           /* 기본 qdisc */
    /* ... */
};

NAPI 동작 흐름

NAPI(New API)는 인터럽트와 폴링을 혼합하여 고부하 네트워크에서 인터럽트 폭풍을 방지하는 수신 경로 프레임워크입니다. 핵심 동작은 다음과 같습니다:

1. 패킷 도착 / IRQ 발생 — NIC가 패킷을 수신하면 하드웨어 인터럽트를 발생시킵니다.
2. 폴링 모드 전환 — 드라이버 IRQ 핸들러가 napi_schedule()를 호출하고 인터럽트를 비활성화합니다.
3. 배치 처리 — NET_RX_SOFTIRQ에서 poll() 콜백이 budget(기본 64)만큼 패킷을 배치로 처리합니다.
4. 인터럽트 복귀 — 큐가 비면 napi_complete_done()으로 인터럽트를 재활성화합니다.

net_device 등록 과정

register_netdev()는 네트워크 디바이스를 커널에 등록하는 함수입니다. RTNL(Routing Netlink) 락을 획득한 상태에서 register_netdevice()를 호출하며, 디바이스 이름 할당, sysfs 등록, 알림(notification) 발송 등을 수행합니다.

/* net/core/dev.c — register_netdevice() 핵심 단계 (간략화) */
int register_netdevice(struct net_device *dev)
{
    struct net *net = dev_net(dev);

    /* 1. ndo_init() 콜백 호출 (드라이버 초기화) */
    if (dev->netdev_ops->ndo_init) {
        ret = dev->netdev_ops->ndo_init(dev);
        if (ret)
            goto err;
    }

    /* 2. 디바이스 이름이 %d 패턴이면 자동 할당 */
    if (strchr(dev->name, '%'))
        dev_alloc_name(dev, dev->name);

    /* 3. 네트워크 네임스페이스의 디바이스 리스트에 추가 */
    list_netdevice(dev);

    /* 4. sysfs/procfs 등록 */
    netdev_register_kobject(dev);

    /* 5. NETDEV_REGISTER 알림 발송 */
    call_netdevice_notifiers(NETDEV_REGISTER, dev);

    /* 6. default qdisc 할당 */
    dev_init_scheduler(dev);

    /* 7. 디바이스 상태를 REGISTERED로 변경 */
    dev->reg_state = NETREG_REGISTERED;
    return 0;
}

# 네트워크 디바이스 정보 확인
ip -d link show eth0                   # 상세 디바이스 정보
ethtool -i eth0                        # 드라이버/펌웨어 정보
ethtool -l eth0                        # RX/TX 큐 수
ethtool -g eth0                        # Ring Buffer 크기
ethtool -k eth0                        # 오프로드 기능 목록

# 인터럽트 상태 확인
cat /proc/interrupts | grep eth0       # per-CPU 인터럽트 분배
cat /proc/irq/<IRQ>/smp_affinity       # IRQ CPU 친화성

# NAPI 상태 확인
cat /sys/class/net/eth0/napi_defer_hard_irqs  # IRQ 지연 횟수
cat /sys/class/net/eth0/gro_flush_timeout     # GRO 플러시 타임아웃

인터럽트 코얼레싱 (Interrupt Coalescing)

인터럽트 코얼레싱은 여러 패킷을 모아서 하나의 인터럽트로 처리하여 CPU 오버헤드를 줄이는 NIC 하드웨어 기능입니다. ethtool -C로 설정하며, 지연(latency)과 처리량(throughput)의 트레이드오프를 조절합니다.

# 인터럽트 코얼레싱 현재 설정 확인
ethtool -c eth0

# 설정 변경
# rx-usecs: 인터럽트 발생까지 최대 대기 시간 (μs)
# rx-frames: 인터럽트 발생까지 최대 패킷 수
ethtool -C eth0 rx-usecs 50 rx-frames 64
ethtool -C eth0 tx-usecs 50 tx-frames 64

# 적응형 코얼레싱 (트래픽 패턴에 따라 자동 조정)
ethtool -C eth0 adaptive-rx on adaptive-tx on

# 초저지연 설정 (금융 트레이딩 등)
ethtool -C eth0 rx-usecs 0 rx-frames 1
ethtool -C eth0 tx-usecs 0 tx-frames 1

드라이버 모델: ndo_* 콜백

struct net_device_ops는 드라이버가 구현해야 하는 콜백 함수 집합입니다. 패킷 전송, 인터페이스 설정, 멀티캐스트 필터, TC 오프로드 등 모든 디바이스 동작이 이 인터페이스를 통해 추상화됩니다.

/* include/linux/netdevice.h — net_device_ops 핵심 콜백 */
struct net_device_ops {
    /* 인터페이스 관리 */
    int  (*ndo_open)(struct net_device *dev);
    int  (*ndo_stop)(struct net_device *dev);

    /* 패킷 전송 (TX 핵심 경로) */
    netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb,
                                  struct net_device *dev);

    /* TX 큐 선택 (멀티큐) */
    u16  (*ndo_select_queue)(struct net_device *dev,
                            struct sk_buff *skb,
                            struct net_device *sb_dev);

    /* MAC 주소/멀티캐스트 필터 */
    void (*ndo_set_rx_mode)(struct net_device *dev);
    int  (*ndo_set_mac_address)(struct net_device *dev, void *addr);

    /* MTU 변경 */
    int  (*ndo_change_mtu)(struct net_device *dev, int new_mtu);

    /* TC 하드웨어 오프로드 */
    int  (*ndo_setup_tc)(struct net_device *dev,
                        enum tc_setup_type type,
                        void *type_data);

    /* XDP 프로그램 부착 */
    int  (*ndo_bpf)(struct net_device *dev,
                   struct netdev_bpf *bpf);

    /* VLAN 필터 */
    int  (*ndo_vlan_rx_add_vid)(struct net_device *dev,
                               __be16 proto, u16 vid);
    /* ... 50개 이상의 콜백 */
};

주요 자료구조 관계도

Linux 네트워크 스택의 핵심 자료구조들은 서로 긴밀하게 연결되어 있습니다. 아래 다이어그램은 패킷 처리에 관여하는 주요 구조체 간의 관계를 보여줍니다.

주요 자료구조 메모리 사용량 추적

# SLAB 캐시에서 네트워크 관련 객체 확인
slabtop -s c | head -20

# 개별 SLAB 캐시 상세 확인
cat /proc/slabinfo | grep -E "^(sk_buff|tcp_sock|sock_inode|request_sock)"

# 소켓 메모리 사용량 요약
cat /proc/net/sockstat
# sockets: used 1234
# TCP: inuse 567 orphan 0 tw 89 alloc 600 mem 123
# UDP: inuse 12 mem 3

# TCP 메모리 압력 상태 확인
cat /proc/sys/net/ipv4/tcp_mem
# 세 값: low(정상) pressure(경고) high(제한) — 페이지 단위

# 네트워크 버퍼 메모리 사용량 (바이트)
cat /proc/sys/net/core/optmem_max
cat /proc/sys/net/core/rmem_default
cat /proc/sys/net/core/wmem_default

자료구조 상속 계층

네트워크 자료구조는 C 언어의 구조체 내포(embedding)를 통해 상속 패턴을 구현합니다:

이 패턴 덕분에 struct sock *sk 포인터를 tcp_sk(sk), inet_sk(sk) 등의 매크로(Macro)로 캐스팅하여 프로토콜별 필드에 접근할 수 있습니다. 커널의 네트워크 코드에서 가장 빈번하게 사용되는 패턴입니다.

/* 소켓 캐스팅 매크로 */
struct tcp_sock *tp = tcp_sk(sk);    /* sock → tcp_sock */
struct inet_sock *inet = inet_sk(sk); /* sock → inet_sock */
struct inet_connection_sock *icsk = inet_csk(sk);

/* TCP 혼잡 윈도우 접근 */
u32 cwnd = tp->snd_cwnd;
u32 srtt = tp->srtt_us >> 3;  /* 마이크로초 단위 */

/* IP 주소 접근 */
__be32 saddr = inet->inet_saddr;
__be32 daddr = inet->inet_daddr;
__be16 sport = inet->inet_sport;

라우팅 서브시스템

Linux 라우팅은 FIB(Forwarding Information Base)를 기반으로 Longest Prefix Match(LPM) 조회를 수행합니다. FIB는 내부적으로 LC-trie(Level-Compressed trie) 자료구조를 사용하여 대규모 라우팅 테이블에서도 효율적인 조회를 보장합니다.

라우팅 조회 과정

1. FIB 조회 — fib_lookup()에서 목적지 IP에 대한 LPM(Longest Prefix Match) 조회를 수행합니다.
2. dst_entry 생성 — 조회 결과로 struct dst_entry를 생성하여 sk_buff에 연결합니다. 이 구조체는 출력 인터페이스, 다음 홉, MTU 정보를 포함합니다.
3. 이웃 조회 — 다음 홉의 L2 주소(MAC)를 ARP/NDP 캐시에서 조회합니다. 캐시 미스 시 ARP 요청을 보내고 패킷을 neigh->arp_queue에 대기시킵니다.

라우팅 테이블 구조

# 라우팅 테이블 확인
ip route show table main           # 기본 라우팅 테이블
ip route show table local          # 로컬 주소 테이블
ip rule list                       # Policy Routing 규칙

# 특정 목적지에 대한 라우팅 결정 확인
ip route get 8.8.8.8               # FIB 조회 결과
ip route get 8.8.8.8 from 10.0.0.1 iif eth0  # 소스/인터페이스 지정

FIB 조회 내부 구현

fib_lookup()은 Policy Routing 규칙(ip rule)을 순회하며, 매칭되는 규칙의 라우팅 테이블에서 LPM 조회를 수행합니다. 내부적으로 LC-trie(Level-Compressed Trie) 자료구조를 사용하여 대규모 BGP 라우팅 테이블(수십만 엔트리)에서도 효율적으로 조회합니다.

/* net/ipv4/fib_rules.c — fib_lookup() 핵심 로직 (간략화) */
int fib_lookup(struct net *net,
              const struct flowi4 *flp,
              struct fib_result *res, unsigned int flags)
{
    /* Policy Routing 비활성 시 (대부분의 서버) */
    /* main + local 테이블만 직접 조회 (빠른 경로) */
    if (!net->ipv4.fib_has_custom_rules) {
        res->tclassid = 0;

        /* 1. local 테이블 조회 (로컬 주소, 브로드캐스트) */
        err = fib_table_lookup(local_table, flp, res, flags);
        if (err != -EAGAIN)
            return err;

        /* 2. main 테이블 조회 */
        err = fib_table_lookup(main_table, flp, res, flags);
        if (err != -EAGAIN)
            return err;

        return -ENETUNREACH;
    }

    /* Policy Routing 활성 시: 규칙 순회 */
    return __fib_lookup(net, flp, res, flags);
}

/* net/ipv4/fib_trie.c — fib_table_lookup() LC-trie 조회 */
int fib_table_lookup(struct fib_table *tb,
                    const struct flowi4 *flp,
                    struct fib_result *res, int fib_flags)
{
    struct trie *t = (struct trie *)tb->tb_data;
    t_key key = ntohl(flp->daddr);  /* 목적지 IP */
    struct key_vector *n, *pn;
    t_key cindex;

    /* Trie 루트에서 시작하여 목적지 IP 비트를 따라 탐색 */
    n = get_child_rcu(t->kv, key);
    while (n) {
        /* Leaf 노드: 프리픽스 매칭 확인 */
        /* Internal 노드: 다음 비트로 자식 탐색 */
        /* Longest Prefix Match를 위해 백트래킹 */
        /* ... */
    }
    /* fib_result에 nexthop, 출력 디바이스, 경로 타입 설정 */
    return err;
}

dst_entry 캐시와 라우팅 캐시

dst_entry는 라우팅 결정의 결과를 캐싱하는 구조체입니다. 커널 3.6부터 전역 라우팅 캐시(rt_hash_table)가 제거되고, 소켓별/FIB 엔트리별 캐시로 대체되었습니다. Early Demux에서 소켓의 dst_entry를 재사용하는 것이 현재의 주된 캐싱 전략입니다.

/* include/net/dst.h — dst_entry 핵심 필드 */
struct dst_entry {
    struct net_device  *dev;          /* 출력 디바이스 */
    struct dst_ops     *ops;          /* IPv4/IPv6 ops */
    unsigned long      expires;       /* 만료 시간 */
    int                (*input)(struct sk_buff *skb);
    int                (*output)(struct net *net,
                                 struct sock *sk,
                                 struct sk_buff *skb);
    unsigned int       flags;         /* DST_* 플래그 */
    int                error;
    struct neighbour  *_neighbour;    /* 다음 홉 이웃 */
    /* ... */
};

/* 수신 패킷: input 콜백 사용 */
/*   로컬 대상: input = ip_local_deliver */
/*   포워딩:   input = ip_forward */

/* 송신 패킷: output 콜백 사용 */
/*   유니캐스트: output = ip_output */
/*   멀티캐스트: output = ip_mc_output */

# 라우팅 캐시/FIB 통계 확인
cat /proc/net/fib_trie                 # FIB trie 구조 (상세)
cat /proc/net/fib_triestat             # FIB trie 통계
# Aver depth:     2.52
# Max depth:      7
# Leaves:         834
# Internal nodes: 312

# rt_cache 통계 (레거시, 참고용)
cat /proc/net/stat/rt_cache

# ECMP (Equal-Cost Multi-Path) 설정
ip route add 10.0.0.0/8 \
  nexthop via 192.168.1.1 weight 1 \
  nexthop via 192.168.1.2 weight 1

# ECMP 해시 기반 선택 (L3 또는 L3+L4)
sysctl net.ipv4.fib_multipath_hash_policy  # 0=L3, 1=L3+L4, 2=L3+L4+src

Policy Routing과 ip rule

Policy Routing은 소스 IP, 마킹(fwmark), 인터페이스 등 다양한 조건에 따라 서로 다른 라우팅 테이블을 적용하는 기능입니다. ip rule 명령으로 규칙을 관리하며, 규칙은 우선순위(priority) 순서로 평가됩니다.

# Policy Routing 기본 규칙 확인
ip rule list
# 0:       from all lookup local        → 로컬 주소 매칭
# 32766:   from all lookup main         → 기본 라우팅
# 32767:   from all lookup default      → 기본값

# 소스 IP 기반 라우팅 (멀티호밍)
ip rule add from 10.0.1.0/24 table 100 prio 100
ip route add default via 192.168.1.1 table 100

# fwmark 기반 라우팅 (Netfilter 연동)
iptables -t mangle -A OUTPUT -p tcp --dport 80 -j MARK --set-mark 1
ip rule add fwmark 1 table 200 prio 200
ip route add default via 10.0.0.1 table 200

# 인터페이스 기반 라우팅
ip rule add iif eth1 table 300 prio 300

# VRF (Virtual Routing and Forwarding) 설정
ip link add vrf-red type vrf table 10
ip link set dev vrf-red up
ip link set dev eth1 master vrf-red
# eth1의 모든 트래픽이 table 10으로 라우팅됩니다

# 라우팅 결정 디버깅
ip route get 8.8.8.8 from 10.0.1.5    # 소스 IP 지정 조회
ip route get 8.8.8.8 mark 1           # fwmark 지정 조회
ip route get fibmatch 10.0.0.0/24     # 정확한 FIB 매칭 조회

IPv6 라우팅 특이사항

IPv6 라우팅은 IPv4와 유사하지만 몇 가지 중요한 차이가 있습니다. IPv6는 확장 헤더를 사용하며, NDP(Neighbor Discovery Protocol)로 ARP를 대체하고, Router Advertisement(RA)를 통한 자동 주소 설정(SLAAC)을 지원합니다.

# IPv6 라우팅 확인
ip -6 route show                       # IPv6 라우팅 테이블
ip -6 route get 2001:db8::1            # IPv6 경로 조회
ip -6 neigh show                       # NDP 이웃 캐시

# Router Advertisement 확인
radvdump                               # RA 패킷 덤프

# IPv6 관련 sysctl
sysctl net.ipv6.conf.all.forwarding    # IPv6 포워딩 (라우터 모드)
sysctl net.ipv6.conf.all.accept_ra     # RA 수락 (SLAAC)
sysctl net.ipv6.conf.all.use_tempaddr  # Privacy Extensions

TC (Traffic Control)와 qdisc

패킷 스케줄링과 트래픽 셰이핑을 담당합니다. 각 네트워크 디바이스에 qdisc(큐잉 규칙)가 연결됩니다. TC는 3개 구성 요소로 이루어집니다: qdisc(큐잉 규칙), class(계층적 분류), filter(패킷 분류기).

주요 qdisc 유형

# TC 기본 사용 예제
tc qdisc show dev eth0                       # 현재 qdisc 확인
tc qdisc add dev eth0 root fq_codel          # fq_codel 설정
tc qdisc add dev eth0 root netem delay 100ms # 100ms 지연 추가

# HTB로 대역폭 제한
tc qdisc add dev eth0 root handle 1: htb default 10
tc class add dev eth0 parent 1: classid 1:10 htb rate 100mbit ceil 200mbit
tc class add dev eth0 parent 1: classid 1:20 htb rate 50mbit ceil 100mbit

# TC BPF 프로그램 부착
tc qdisc add dev eth0 clsact
tc filter add dev eth0 ingress bpf da obj prog.o sec classifier

fq_codel 내부 동작

fq_codel은 Fair Queuing과 CoDel(Controlled Delay) AQM(Active Queue Management)을 결합한 qdisc로, 현재 Linux의 기본 qdisc입니다. 각 플로우에 별도의 큐를 할당하여 공정성을 보장하고, CoDel 알고리즘으로 큐잉 지연이 target(기본 5ms)을 초과하면 패킷을 드롭하여 버퍼블로트(Bufferbloat)를 방지합니다.

/* net/sched/sch_fq_codel.c — fq_codel 핵심 구조 (간략화) */
struct fq_codel_sched_data {
    u32             flows_cnt;     /* 플로우 큐 수 (기본 1024) */
    u32             quantum;       /* DRR 양자 (기본 1514) */
    u32             drop_batch_size; /* 한번에 드롭할 패킷 수 */
    struct codel_params cparams;   /* CoDel 파라미터 */
    struct fq_codel_flow *flows;   /* 플로우 큐 배열 */
    struct list_head  new_flows;   /* 새 플로우 리스트 */
    struct list_head  old_flows;   /* 기존 플로우 리스트 */
};

/* CoDel 파라미터 */
/* target: 허용 큐잉 지연 (기본 5ms) */
/* interval: 판단 주기 (기본 100ms) */
/* 큐잉 지연이 target을 interval 동안 */
/* 지속적으로 초과하면 드롭 시작 */

/* 패킷 분류: skb_get_hash()로 플로우 해시 계산 */
/* → hash % flows_cnt로 플로우 큐 결정 */
/* Deficit Round Robin으로 플로우 간 공정 dequeue */

# fq_codel 상세 통계 확인
tc -s qdisc show dev eth0

# 전형적인 출력:
# qdisc fq_codel 0: root refcnt 2 limit 10240p flows 1024
#   quantum 1514 target 5ms interval 100ms memory_limit 32Mb
#   ecn_mark 0 ce_threshold 0us
#  Sent 123456789 bytes 987654 pkt (dropped 12, overlimits 34 requeues 5)
#  backlog 0b 0p requeues 5
#   maxpacket 1514 drop_overlimit 0 new_flow_count 456
#   ecn_mark 0 new_flows_len 0 old_flows_len 2

# fq_codel 파라미터 조정
tc qdisc replace dev eth0 root fq_codel \
  target 1ms \       # 저지연 환경: 1ms 타깃
  interval 50ms \    # 판단 주기 단축
  flows 4096 \       # 플로우 큐 수 증가
  quantum 1514       # DRR 양자

멀티코어 패킷 분산

고속 네트워크에서 단일 CPU로는 패킷 처리량(Throughput)이 부족합니다. Linux 커널은 여러 메커니즘으로 패킷 처리를 여러 CPU에 분산합니다.

# RSS 설정: 큐 수 확인/변경
ethtool -l eth0                           # 채널(큐) 수 확인
ethtool -L eth0 combined 8                # 8개 결합 큐로 설정

# IRQ-CPU 매핑 확인
cat /proc/interrupts | grep eth0          # NIC 인터럽트 분포

# RPS 활성화 (예: 8코어 시스템에서 CPU 0-7)
echo ff > /sys/class/net/eth0/queues/rx-0/rps_cpus

# softnet 통계 확인 (드롭 모니터링)
cat /proc/net/softnet_stat

Flow Dissector

Flow Dissector는 패킷의 L3/L4 헤더를 파싱하여 플로우 키(5-tuple)를 추출하는 커널 프레임워크입니다. RSS, RPS, fq_codel, TC 등 플로우 기반 처리를 수행하는 모든 서브시스템이 이 프레임워크를 사용합니다.

/* net/core/flow_dissector.c — Flow Dissector 핵심 구조 */
struct flow_keys {
    struct flow_dissector_key_control control;
    struct flow_dissector_key_basic   basic;    /* n_proto, ip_proto */
    struct flow_dissector_key_ipv4_addrs addrs;  /* src, dst IP */
    struct flow_dissector_key_ports  ports;    /* src, dst port */
    struct flow_dissector_key_tags   tags;     /* VLAN ID 등 */
    struct flow_dissector_key_vlan   vlan;     /* VLAN 정보 */
    struct flow_dissector_key_keyid  keyid;    /* 터널 키 */
};

/* 패킷에서 플로우 키 추출 */
u32 skb_get_hash(struct sk_buff *skb)
{
    if (!skb->l4_hash && !skb->sw_hash) {
        /* NIC가 RSS 해시를 제공하지 않으면 소프트웨어 해시 계산 */
        __skb_get_hash(skb);
        /* → skb_flow_dissect_flow_keys() */
        /* → __skb_flow_dissect() — 프로토콜별 파싱 */
        /* → flow_hash_from_keys() — jhash2 기반 해시 */
    }
    return skb->hash;
}

IRQ 친화성(Affinity) 최적화

고성능 네트워크에서는 NIC 인터럽트를 적절한 CPU에 분배하는 것이 중요합니다. 각 RX/TX 큐의 IRQ를 특정 CPU에 고정하고, NAPI 처리와 유저 프로세스가 같은 CPU에서 실행되도록 구성합니다.

# irqbalance 중지 (수동 IRQ 관리 시)
systemctl stop irqbalance

# NIC IRQ 번호 확인
grep eth0 /proc/interrupts | awk '{print $1, $NF}'

# IRQ별 CPU 친화성 설정
# eth0-rx-0 → CPU 0, eth0-rx-1 → CPU 1, ...
echo 1 > /proc/irq/<IRQ0>/smp_affinity   # CPU 0
echo 2 > /proc/irq/<IRQ1>/smp_affinity   # CPU 1
echo 4 > /proc/irq/<IRQ2>/smp_affinity   # CPU 2
echo 8 > /proc/irq/<IRQ3>/smp_affinity   # CPU 3

# 자동화 스크립트 (set_irq_affinity 도구 사용)
# Intel 드라이버 패키지에 포함된 스크립트:
/usr/local/bin/set_irq_affinity.sh eth0

# NUMA 노드 확인
cat /sys/class/net/eth0/device/numa_node
# NIC가 연결된 NUMA 노드의 CPU에 IRQ를 할당하면
# 메모리 접근 지연이 줄어 성능이 향상됩니다

# 처리 확인
watch -n1 'cat /proc/interrupts | grep eth0'
# 각 CPU의 인터럽트 카운트가 균등한지 확인

네트워크 오프로드 기술

CPU 부하를 줄이기 위해 네트워크 처리의 일부를 NIC 하드웨어 또는 커널 소프트웨어 계층에서 최적화합니다. 오프로드 기능은 ethtool -k로 확인하고 ethtool -K로 제어합니다.

# 오프로드 상태 확인
ethtool -k eth0 | grep -E "tcp-segmentation|generic-segmentation|generic-receive|checksum"

# 오프로드 제어
ethtool -K eth0 tso on              # TSO 활성화
ethtool -K eth0 gro on              # GRO 활성화
ethtool -K eth0 gso on              # GSO 활성화
ethtool -K eth0 tx-checksum-ipv4 on # TX 체크섬 오프로드

체크섬 오프로드 내부 동작

체크섬 오프로드는 NIC 하드웨어에서 IP/TCP/UDP 체크섬을 계산(TX) 또는 검증(RX)하여 CPU 부하를 줄입니다. skb->ip_summed 필드가 체크섬 상태를 나타냅니다.

TX 체크섬 오프로드 — 커널 내부

TCP/UDP 송신 시 의사 헤더 체크섬만 계산하며, ip_summed = CHECKSUM_PARTIAL을 설정합니다.

• csum_start: 체크섬 계산 시작 오프셋
• csum_offset: 체크섬 삽입 위치 (TCP: 16, UDP: 6)

NIC 드라이버가 TX 디스크립터에 체크섬 오프로드 플래그를 설정하면, NIC 하드웨어가 csum_start부터 패킷 끝까지 체크섬을 계산하고 csum_offset 위치에 결과를 삽입합니다.

NIC가 체크섬 오프로드를 지원하지 않으면: dev_hard_start_xmit() → skb_csum_hwoffload_help() → skb_checksum_help()로 소프트웨어 체크섬을 계산합니다.

XDP와 네트워크 스택 우회

XDP(eXpress Data Path)는 드라이버 레벨에서 eBPF 프로그램을 실행하여 sk_buff 할당 전에 패킷을 처리합니다. DDoS 방어, 패킷 필터링, 로드 밸런싱 등에서 10Mpps 이상의 성능을 달성할 수 있습니다.

/* XDP 프로그램의 반환값 (verdict) */
enum xdp_action {
    XDP_ABORTED = 0,    /* 오류 발생 — 패킷 드롭 + 추적 */
    XDP_DROP,            /* 패킷 드롭 (가장 빠름) */
    XDP_PASS,            /* 일반 네트워크 스택으로 전달 */
    XDP_TX,              /* 수신 인터페이스로 재전송 */
    XDP_REDIRECT,        /* 다른 인터페이스/AF_XDP로 리다이렉트 */
};

/* XDP 프로그램 예시: 특정 IP 드롭 (DDoS 방어) */
SEC("xdp")
int xdp_firewall(struct xdp_md *ctx)
{
    void *data = (void *)(long)ctx->data;
    void *data_end = (void *)(long)ctx->data_end;

    struct ethhdr *eth = data;
    if ((void *)(eth + 1) > data_end)
        return XDP_PASS;

    if (eth->h_proto != bpf_htons(ETH_P_IP))
        return XDP_PASS;

    struct iphdr *ip = data + sizeof(*eth);
    if ((void *)(ip + 1) > data_end)
        return XDP_PASS;

    /* BPF 맵에서 차단 IP 조회 */
    if (bpf_map_lookup_elem(&blocked_ips, &ip->saddr))
        return XDP_DROP;  /* sk_buff 할당 전 드롭 */

    return XDP_PASS;
}

# XDP 프로그램 부착
ip link set dev eth0 xdpgeneric obj prog.o sec xdp  # 소프트웨어 XDP
ip link set dev eth0 xdp obj prog.o sec xdp         # 드라이버 XDP (네이티브)

# XDP 프로그램 상태 확인
ip link show eth0 | grep xdp

# XDP 프로그램 제거
ip link set dev eth0 xdp off

# XDP 통계 확인
bpftool prog show
bpftool map dump id <MAP_ID>

네트워크 네임스페이스와 가상 디바이스

네트워크 네임스페이스(struct net)는 네트워크 스택 전체를 격리하는 커널 기능입니다. 각 네임스페이스는 독립적인 네트워크 인터페이스, 라우팅 테이블, Netfilter 규칙, 소켓 공간을 가집니다. 컨테이너(Docker, Kubernetes)의 네트워크 격리 기반이 됩니다.

네트워크 네임스페이스 내부 구조

커널 내부에서 모든 네트워크 관련 함수는 struct net *net 매개변수를 통해 현재 네임스페이스를 전달받습니다. 예를 들어 라우팅 조회 시 fib_lookup(net, ...)으로 해당 네임스페이스의 라우팅 테이블만 조회합니다.

/* include/net/net_namespace.h — 네트워크 네임스페이스 핵심 필드 */
struct net {
    struct list_head       list;           /* 전역 네임스페이스 리스트 */
    struct ns_common       ns;             /* 공통 네임스페이스 정보 */
    struct net_device      *loopback_dev;  /* lo 인터페이스 */
    struct hlist_head      *dev_name_head; /* 이름별 디바이스 해시 */
    struct hlist_head      *dev_index_head;/* 인덱스별 디바이스 해시 */
    struct netns_ipv4     ipv4;           /* IPv4 전용 데이터 */
    struct netns_ipv6     ipv6;           /* IPv6 전용 데이터 */
    struct netns_nf       nf;             /* Netfilter 데이터 */
    struct netns_ct       ct;             /* conntrack 데이터 */
    struct sock           *rtnl;          /* rtnetlink 소켓 */
    /* ... */
};

# 네트워크 네임스페이스 생성 및 관리
ip netns add ns1                    # 네임스페이스 생성
ip netns list                       # 네임스페이스 목록
ip netns exec ns1 ip addr show      # 네임스페이스 내에서 명령 실행

# veth 페어로 네임스페이스 연결
ip link add veth0 type veth peer name veth1
ip link set veth1 netns ns1
ip addr add 10.0.0.1/24 dev veth0
ip netns exec ns1 ip addr add 10.0.0.2/24 dev veth1
ip link set veth0 up
ip netns exec ns1 ip link set veth1 up

가상 네트워크 디바이스 유형

Linux 커널은 다양한 가상 네트워크 디바이스를 제공합니다. 각 유형은 특정 네트워크 아키텍처 패턴에 맞게 설계되었습니다.

가상 디바이스 생성 명령 예시

# veth 쌍 생성
ip link add veth0 type veth peer name veth1

# Linux Bridge 생성 및 포트 추가
ip link add br0 type bridge
ip link set eth0 master br0
ip link set veth0 master br0
ip link set br0 up

# MACVLAN 생성 (bridge 모드)
ip link add macvlan0 link eth0 type macvlan mode bridge
ip addr add 10.0.0.100/24 dev macvlan0
ip link set macvlan0 up

# IPVLAN 생성 (L3 모드)
ip link add ipvlan0 link eth0 type ipvlan mode l3
ip addr add 10.0.0.101/24 dev ipvlan0
ip link set ipvlan0 up

# VXLAN 생성 (멀티캐스트 기반)
ip link add vxlan100 type vxlan id 100 \
   group 239.1.1.1 dev eth0 dstport 4789
ip link set vxlan100 up

# GENEVE 생성
ip link add geneve100 type geneve id 100 \
   remote 10.0.0.2 dstport 6081
ip link set geneve100 up

# TUN 디바이스 생성
ip tuntap add name tun0 mode tun
ip addr add 10.1.0.1/24 dev tun0
ip link set tun0 up

# Bond 생성 (802.3ad LACP)
ip link add bond0 type bond mode 802.3ad
ip link set eth0 master bond0
ip link set eth1 master bond0
ip link set bond0 up

# VRF 생성
ip link add vrf-red type vrf table 100
ip link set vrf-red up
ip link set eth2 master vrf-red

컨테이너 네트워킹 아키텍처 비교

네트워크 네임스페이스 내부 구현

네트워크 네임스페이스(struct net)의 내부 구현을 이해하면 컨테이너 네트워킹의 성능 특성과 제약을 파악할 수 있습니다. 이 섹션에서는 네임스페이스 생성/삭제 과정과 프로토콜 스택 격리 메커니즘을 설명합니다.

네임스페이스 생성 과정

clone(CLONE_NEWNET) 또는 unshare(CLONE_NEWNET) 시스템 콜로 새 네트워크 네임스페이스를 생성하면 커널 내부에서 다음 과정이 진행됩니다:

1. struct net 할당 — copy_net_ns()가 새 struct net을 할당합니다. 각 네임스페이스 서브시스템(IPv4, IPv6, Netfilter 등)의 pernet_operations가 초기화됩니다.
2. loopback 디바이스 생성 — loopback_net_init()이 새 네임스페이스 전용 lo 인터페이스를 생성합니다. 이것이 네임스페이스의 최초 네트워크 인터페이스입니다.
3. 프로토콜별 초기화 — IPv4 라우팅 테이블(fib_net_init()), Netfilter 상태(nf_conntrack_pernet_init()), proc 파일시스템(Filesystem) 엔트리 등이 네임스페이스별로 초기화됩니다.
4. sysctl 복사 — 네트워크 관련 sysctl 변수가 네임스페이스별로 독립 복사됩니다. /proc/sys/net/ 아래의 모든 항목이 네임스페이스별로 격리됩니다.

/* net/core/net_namespace.c — 네임스페이스 생성 핵심 */
static struct net *setup_net(struct net *net, struct user_namespace *user_ns)
{
    /* 참조 카운트 초기화 */
    refcount_set(&net->ns.count, 1);

    /* 모든 pernet_operations의 init 콜백 호출 */
    list_for_each_entry(ops, &pernet_list, list) {
        if (ops->init) {
            error = ops->init(net);
            if (error < 0)
                goto out_undo;
        }
    }
    /* ... */
}

pernet_operations 등록 메커니즘

각 네트워크 서브시스템은 struct pernet_operations를 등록하여 네임스페이스 생성/삭제 시 호출되는 콜백을 정의합니다. 이 메커니즘 덕분에 새로운 네트워크 기능을 추가해도 네임스페이스 격리가 자동으로 적용됩니다.

/* 서브시스템별 pernet_operations 등록 예시 */
static struct pernet_operations ipv4_net_ops = {
    .init = ipv4_net_init,
    .exit = ipv4_net_exit,
};

/* 초기화 시 등록 */
register_pernet_subsys(&ipv4_net_ops);

/* 네임스페이스 생성 시 ipv4_net_init() 자동 호출 */
/* 네임스페이스 삭제 시 ipv4_net_exit() 자동 호출 */

네임스페이스 간 디바이스 이동

ip link set dev eth0 netns ns1 명령은 dev_change_net_namespace() 함수를 호출합니다. 이 과정에서 디바이스의 nd_net 포인터가 대상 네임스페이스로 변경되고, 기존 네임스페이스의 디바이스 리스트에서 제거된 후 대상 네임스페이스의 리스트에 삽입됩니다. 디바이스의 모든 qdisc, 소켓 연결, Netfilter 상태가 재초기화됩니다.

네임스페이스에서 격리되는 자원

가상 네트워크 디바이스 유형

Linux는 다양한 가상 네트워크 디바이스를 제공하여 네트워크 토폴로지를 소프트웨어로 구성할 수 있습니다. 각 디바이스 유형은 고유한 성능 특성과 사용 시나리오를 가집니다.

/* drivers/net/veth.c — veth 패킷 전달 핵심 (간략화) */
static netdev_tx_t veth_xmit(struct sk_buff *skb,
                              struct net_device *dev)
{
    struct veth_priv *priv = netdev_priv(dev);
    struct net_device *rcv = rcu_dereference(priv->peer);

    if (unlikely(!rcv)) {
        kfree_skb(skb);
        return NETDEV_TX_OK;
    }

    /* 피어 디바이스로 패킷 전달 */
    skb->dev = rcv;                      /* 수신 디바이스 변경 */
    skb->protocol = eth_type_trans(skb, rcv);
    skb->pkt_type = PACKET_HOST;

    /* XDP 프로그램이 있으면 실행 */
    if (likely(veth_xdp_rx(rq, skb)))
        goto xmit;

    /* NAPI를 통해 피어 네임스페이스에서 수신 처리 */
    if (netif_receive_skb(skb) == NET_RX_SUCCESS)
        return NETDEV_TX_OK;

    return NETDEV_TX_OK;
}

# 가상 디바이스 생성 명령어 모음

# veth 페어 생성
ip link add veth0 type veth peer name veth1
ip link set veth1 netns ns1

# Linux 브릿지 생성
ip link add br0 type bridge
ip link set eth0 master br0
ip link set veth0 master br0
ip link set br0 up

# MACVLAN 생성
ip link add macvlan0 link eth0 type macvlan mode bridge
ip link set macvlan0 netns ns1

# IPVLAN 생성
ip link add ipvlan0 link eth0 type ipvlan mode l3

# VXLAN 터널 생성
ip link add vxlan100 type vxlan id 100 \
  local 192.168.1.1 remote 192.168.1.2 \
  dstport 4789 dev eth0

# WireGuard 인터페이스 생성
ip link add wg0 type wireguard
wg set wg0 private-key /path/to/private.key \
  listen-port 51820 \
  peer PEER_PUBLIC_KEY= endpoint 10.0.0.2:51820 \
  allowed-ips 10.10.10.0/24

# TUN 디바이스 생성 (유저 공간 프로그램에서)
ip tuntap add dev tun0 mode tun

제로카피 네트워킹 (Zero-Copy Networking)

제로카피(Zero-Copy)는 유저 공간과 커널 공간 사이의 데이터 복사를 제거하여 CPU 사용률과 메모리 대역폭을 절약하는 기법입니다. Linux 네트워크 스택은 송신(sendfile, MSG_ZEROCOPY), 수신(tcp_mmap), 그리고 io_uring을 통한 비동기 소켓 I/O까지 다양한 제로카피 메커니즘을 제공합니다.

io_uring 소켓 통합

io_uring은 커널 5.6부터 소켓 I/O를 지원하며, IORING_OP_SEND, IORING_OP_RECV, IORING_OP_ACCEPT 등의 비동기 소켓 연산을 제공합니다. Submission Queue(SQ)와 Completion Queue(CQ)를 유저-커널 간 공유하여 시스템 콜 오버헤드를 최소화합니다.

/* io_uring 제로카피 소켓 전송 (IORING_OP_SEND_ZC) */
struct io_uring_sqe *sqe = io_uring_get_sqe(ring);

/* 제로카피 전송 설정 */
io_uring_prep_send_zc(sqe, sockfd, buf, len, 0, 0);
sqe->flags |= IOSQE_CQE_SKIP_SUCCESS;

/* 제출 — 시스템 콜 없이 SQ에 직접 기록 */
io_uring_submit(ring);

/* 완료 확인 — CQ에서 결과 수집 */
struct io_uring_cqe *cqe;
io_uring_wait_cqe(ring, &cqe);

/* IORING_CQE_F_NOTIF: 제로카피 완료 통지 */
/* 이 CQE 이후 buf를 재사용할 수 있습니다 */
if (cqe->flags & IORING_CQE_F_NOTIF)
    io_uring_cqe_seen(ring, cqe);

splice와 vmsplice

splice()는 파이프를 중간 매개체로 사용하여 두 파일 디스크립터(File Descriptor) 간에 제로카피 데이터 전송을 수행합니다. vmsplice()는 유저 공간 메모리를 파이프에 제로카피로 주입합니다.

/* splice 기반 소켓 전송 — 유저 공간 */
int pipefd[2];
pipe(pipefd);

/* 1. 파일 → 파이프 (splice) */
splice(file_fd, &off, pipefd[1], NULL, len, SPLICE_F_MOVE);

/* 2. 파이프 → 소켓 (splice) */
splice(pipefd[0], NULL, sock_fd, NULL, len, SPLICE_F_MOVE);

/* vmsplice: 유저 메모리 → 파이프 (제로카피) */
struct iovec iov = { .iov_base = buf, .iov_len = len };
vmsplice(pipefd[1], &iov, 1, SPLICE_F_GIFT);
/* SPLICE_F_GIFT: 페이지 소유권을 파이프에 양도 */
/* → 이후 buf 수정 금지, 파이프가 페이지 해제 */

성능 비교와 선택 가이드

네트워크 초기화 시퀀스 (Network Initialization)

Linux 커널의 네트워크 스택은 부팅 시 특정 순서로 초기화됩니다. 각 서브시스템은 의존성을 고려하여 올바른 순서로 로드되어야 하며, core_initcall, subsys_initcall, fs_initcall 등의 initcall 매크로로 순서를 지정합니다.

/* net/socket.c — 네트워크 초기화 진입점 */
static int __init sock_init(void)
{
    /* 1. sk_buff SLAB 캐시 초기화 */
    skb_init();

    /* 2. VFS 소켓 파일시스템 등록 */
    init_inodecache();
    register_filesystem(&sock_fs_type);
    sock_mnt = kern_mount(&sock_fs_type);

    /* 3. Netfilter 프레임워크 초기화 */
    netfilter_init();

    return 0;
}
core_initcall(sock_init);  /* 최우선 초기화 */

/* net/ipv4/af_inet.c — inet_init() IPv4 스택 초기화 */
static int __init inet_init(void)
{
    /* 1. 프로토콜 구조체 등록 */
    proto_register(&tcp_prot, 1);
    proto_register(&udp_prot, 1);
    proto_register(&raw_prot, 1);
    proto_register(&ping_prot, 1);

    /* 2. AF_INET 소켓 패밀리 등록 */
    sock_register(&inet_family_ops);

    /* 3. ARP 초기화 */
    arp_init();

    /* 4. IP 계층 초기화 */
    ip_init();

    /* 5. TCP/UDP L4 프로토콜 등록 */
    inet_add_protocol(&icmp_protocol, IPPROTO_ICMP);
    inet_add_protocol(&udp_protocol, IPPROTO_UDP);
    inet_add_protocol(&tcp_protocol, IPPROTO_TCP);

    /* 6. TCP 서브시스템 초기화 */
    tcp_init();          /* 해시 테이블, 메모리, 타이머 */
    udp_init();          /* UDP 해시 테이블 */
    udplite_init();      /* UDP-Lite */

    /* 7. ICMP/IGMP 초기화 */
    icmp_init();
    igmp_mc_init();

    /* 8. IP L3 패킷 핸들러 등록 (EtherType 0x0800) */
    dev_add_pack(&ip_packet_type);

    /* 9. IP 단편화, FIB, 이웃 테이블 등 */
    ip_mr_init();
    inet_initpeers();

    return 0;
}
fs_initcall(inet_init);  /* sock_init 이후 실행 */

초기화 순서와 의존성

/* net/core/dev.c — net_dev_init() per-CPU 구조체 초기화 */
static int __init net_dev_init(void)
{
    int i;

    /* per-CPU softnet_data 초기화 */
    for_each_possible_cpu(i) {
        struct softnet_data *sd = &per_cpu(softnet_data, i);

        INIT_LIST_HEAD(&sd->poll_list);
        skb_queue_head_init(&sd->input_pkt_queue);
        skb_queue_head_init(&sd->process_queue);
        sd->backlog.poll = process_backlog;
        sd->backlog.weight = 64;  /* NAPI weight */
    }

    /* NET_RX_SOFTIRQ / NET_TX_SOFTIRQ 등록 */
    open_softirq(NET_TX_SOFTIRQ, net_tx_action);
    open_softirq(NET_RX_SOFTIRQ, net_rx_action);

    return 0;
}
subsys_initcall(net_dev_init);

부팅 로그에서 네트워크 초기화 확인

# 네트워크 초기화 관련 부팅 메시지 확인
dmesg | grep -iE "(tcp|udp|ipv4|ipv6|netfilter|napi|conntrack)" | head -30

# 전형적인 출력 예시:
# [    0.123456] TCP established hash table entries: 524288
# [    0.123789] TCP bind hash table entries: 65536
# [    0.124012] TCP: Hash tables configured (established 524288 bind 65536)
# [    0.124234] UDP hash table entries: 32768
# [    0.124567] UDP-Lite hash table entries: 32768
# [    0.456789] NET: Registered PF_INET protocol family
# [    0.567890] NET: Registered PF_INET6 protocol family
# [    1.234567] nf_conntrack version 0.5.0 (131072 buckets, 524288 max)

# initcall 타이밍 분석 (커널 파라미터 initcall_debug 필요)
dmesg | grep "initcall.*returned" | grep -i net

# 프로토콜 패밀리 등록 상태
cat /proc/net/protocols                # 등록된 프로토콜 목록
# protocol  size sockets  memory press maxhdr  slab module
# TCPv6     2416    123     234    no    320   yes  kernel
# UDPv6     1216     45      12    no      0   yes  kernel
# TCP       2080    567     890    no    320   yes  kernel
# UDP        960    234      56    no      0   yes  kernel

네트워크 스택 추적(Tracing) 포인트

커널은 네트워크 스택의 주요 경로에 tracepoint를 제공합니다. 이를 통해 패킷의 전체 경로를 추적하고, 성능 병목과 드롭 원인을 정밀하게 분석할 수 있습니다.

# 사용 가능한 네트워크 tracepoint 확인
ls /sys/kernel/debug/tracing/events/net/
ls /sys/kernel/debug/tracing/events/skb/
ls /sys/kernel/debug/tracing/events/napi/
ls /sys/kernel/debug/tracing/events/tcp/
ls /sys/kernel/debug/tracing/events/sock/

# 패킷 드롭 추적 (kfree_skb)
perf trace --no-syscalls -e skb:kfree_skb -a -- sleep 5

# 특정 인터페이스의 NAPI 이벤트 추적
echo 1 > /sys/kernel/debug/tracing/events/napi/napi_poll/enable
cat /sys/kernel/debug/tracing/trace_pipe | head -20

# TCP 재전송 추적
perf trace --no-syscalls -e tcp:tcp_retransmit_skb -a -- sleep 10

# TCP 상태 전이 추적
perf trace --no-syscalls -e sock:inet_sock_set_state -a -- sleep 5

# bpftrace를 이용한 고급 추적
bpftrace -e 'tracepoint:skb:kfree_skb {
    printf("drop reason=%d location=%s\n",
           args->reason, ksym(args->location));
}'

# 네트워크 계층별 지연 측정 (bpftrace)
bpftrace -e 'kprobe:ip_rcv { @start[tid] = nsecs; }
             kretprobe:ip_rcv /@start[tid]/ {
                 @latency_ns = hist(nsecs - @start[tid]);
                 delete(@start[tid]);
             }'

커널 빌드 옵션 (Kconfig)

네트워크 스택의 각 기능은 커널 빌드 시 Kconfig 옵션으로 활성화/비활성화합니다. 프로덕션 환경에서 필요한 기능을 정확히 활성화하면 커널 크기를 줄이고 보안 공격 면을 최소화할 수 있습니다.

핵심 네트워크 Kconfig 옵션

NIC 드라이버 Kconfig

# 현재 커널의 네트워크 관련 Kconfig 확인
zcat /proc/config.gz | grep -E "^CONFIG_(NET|INET|IPV6|NETFILTER|BPF|XDP)" 2>/dev/null || \
grep -E "^CONFIG_(NET|INET|IPV6|NETFILTER|BPF|XDP)" /boot/config-$(uname -r)

# 특정 드라이버 모듈 로드 상태 확인
lsmod | grep -E "ixgbe|i40e|ice|mlx5|bnxt|virtio_net"

# 커널 빌드 시 네트워크 설정 메뉴
make menuconfig   # Networking support → Networking options

Kconfig 의존성 관계

네트워크 Kconfig 옵션들은 복잡한 의존성 관계를 가집니다. 아래는 주요 의존성 체인입니다: