sk_buff 자료구조

Linux 커널 네트워크 스택(Network Stack)의 핵심 자료구조 sk_buff: 메모리 레이아웃, 데이터 조작 함수, clone/copy, 소켓(struct sock) 연동, 소켓 옵션, raw socket, 체크섬(Checksum) 오프로드, GSO/GRO, zero-copy 전송까지 종합 분석합니다. 커널 내부 데이터 경로, 핵심 자료구조/API, 운영 환경 튜닝 포인트와 장애 디버깅(Debugging) 절차까지 실무 관점으로 다룹니다.

개요

struct sk_buff(흔히 skb라 부름)는 Linux 네트워크 스택에서 모든 패킷을 표현하는 자료구조입니다. 수신 패킷이든 전송 패킷이든, L2 프레임이든 L4 세그먼트든, 커널 내에서 네트워크 데이터가 이동할 때는 항상 sk_buff가 사용됩니다.

O'Reilly의 "Understanding Linux Network Internals"에서 Christian Benvenuti는 sk_buff를 "네트워크 스택의 왕(king of networking)"이라 표현했습니다. 이 자료구조를 이해하지 않고는 Linux 네트워크 코드를 읽을 수 없습니다.

• 헤더 파일: <linux/skbuff.h>
• 주요 소스: net/core/skbuff.c
• 구조체 크기: x86_64에서 약 232바이트 (커널 6.x 기준)

struct sk_buff 주요 필드

/* include/linux/skbuff.h (주요 필드만 발췌) */
struct sk_buff {
    union {
        struct {
            struct sk_buff      *next;     /* 리스트 내 다음 skb */
            struct sk_buff      *prev;     /* 리스트 내 이전 skb */
        };
        struct rb_node rbnode;           /* TCP retransmit queue용 */
    };
    struct sock        *sk;             /* 소속 소켓 */
    struct net_device  *dev;            /* 수신/전송 네트워크 디바이스 */

    unsigned int        len;            /* 전체 데이터 길이 (linear + frags) */
    unsigned int        data_len;       /* 비선형(paged) 데이터 길이 */
    __u16               mac_len;        /* MAC 헤더 길이 */
    __u16               hdr_len;        /* 클론 시 writable 헤더 길이 */

    __be16              protocol;       /* 패킷 프로토콜 (ETH_P_IP 등) */
    __u32               priority;       /* QoS 우선순위 */

    sk_buff_data_t      transport_header; /* L4 헤더 오프셋 */
    sk_buff_data_t      network_header;   /* L3 헤더 오프셋 */
    sk_buff_data_t      mac_header;       /* L2 헤더 오프셋 */

    sk_buff_data_t      tail;            /* 데이터 끝 */
    sk_buff_data_t      end;             /* 할당된 버퍼 끝 */
    unsigned char      *head;           /* 할당된 버퍼 시작 */
    unsigned char      *data;           /* 실제 데이터 시작 */

    unsigned int        truesize;       /* 실제 메모리 사용량 */
    refcount_t          users;          /* 참조 카운트 */
};

자주 사용되는 추가 필드

위의 핵심 필드 외에도, sk_buff에는 프로토콜 처리와 성능 최적화에 쓰이는 중요한 필드들이 있습니다:

struct sk_buff {
    /* ... 위의 핵심 필드들 ... */

    char                cb[48];         /* 프로토콜별 제어 블록 (Control Buffer) */
    __u32               hash;           /* 패킷 해시 (RSS, flow steering) */
    __u8                pkt_type:3;     /* PACKET_HOST, PACKET_BROADCAST 등 */
    __u8                ip_summed:2;    /* 체크섬 오프로드 상태 */
    __u32               mark;           /* netfilter/tc 마킹 (iptables -j MARK) */
    __u16               queue_mapping;  /* 멀티큐 NIC 큐 인덱스 */
    unsigned int        napi_id;        /* NAPI 구조체 ID (busy polling) */
    union {
        __u32           tstamp;         /* 수신 타임스탬프 */
        u64             skb_mstamp_ns;  /* 고해상도 타임스탬프 */
    };
    __u8                cloned:1;       /* clone 여부 */
    __u8                nohdr:1;        /* 페이로드 참조만 (헤더 없음) */
    __u8                peeked:1;       /* MSG_PEEK으로 이미 확인됨 */
};

sk_buff 비트필드 및 플래그 완전 맵

sk_buff에는 수십 개의 1비트 플래그가 내장되어 있습니다. 이 플래그들은 네트워킹 서브시스템의 다양한 계층이 설정하며, 패킷의 현재 상태와 처리 방향을 결정합니다. 아래는 카테고리별로 분류한 완전한 목록입니다.

플래그 카테고리별 SVG 비트맵

네트워킹 플래그 상세

오프로드 플래그 상세

터널·캡슐화 플래그 상세

TC/QoS, 보안, 타임스탬프 플래그 상세

/* 수신 체크섬 상태에 따른 분기 처리 */
static inline int tcp_checksum_complete(struct sk_buff *skb)
{
    return !skb_csum_unnecessary(skb) &&
           __tcp_checksum_complete(skb);
}

/* ip_summed 값에 따른 체크섬 불필요 여부 판단 */
static inline bool skb_csum_unnecessary(const struct sk_buff *skb)
{
    /* CHECKSUM_UNNECESSARY: HW 검증 완료
     * CHECKSUM_COMPLETE: 합산값으로 검증 가능 (csum_valid 추가 확인)
     * CHECKSUM_PARTIAL: 송신 시 HW 위임, 수신에서는 미사용 */
    return ((skb->ip_summed == CHECKSUM_UNNECESSARY) ||
            (skb->ip_summed == CHECKSUM_COMPLETE && skb->csum_valid));
}

/* 드라이버에서 HW 체크섬 결과 설정 */
static void my_driver_rx_checksum(struct sk_buff *skb,
                                   struct hw_desc *desc)
{
    if (desc->csum_ok) {
        skb->ip_summed = CHECKSUM_UNNECESSARY;
    } else if (desc->csum_provided) {
        skb->ip_summed = CHECKSUM_COMPLETE;
        skb->csum = csum_unfold((__force __sum16)desc->csum_value);
    } else {
        skb->ip_summed = CHECKSUM_NONE;
    }
}

체크섬 오프로드와 ip_summed

ip_summed 필드는 NIC 하드웨어의 체크섬 오프로드 상태를 나타내는 핵심 플래그입니다:

/* 수신: 드라이버에서 체크섬 상태 설정 */
void my_driver_rx(struct sk_buff *skb, bool csum_ok)
{
    if (csum_ok) {
        skb->ip_summed = CHECKSUM_UNNECESSARY;  /* SW 검증 생략 */
    } else {
        skb->ip_summed = CHECKSUM_NONE;         /* SW 검증 필요 */
    }
}

/* 전송: CHECKSUM_PARTIAL 설정 예 */
skb->ip_summed = CHECKSUM_PARTIAL;
skb->csum_start = skb_transport_header(skb) - skb->head;
skb->csum_offset = offsetof(struct udphdr, check);

skb 할당과 해제

sk_buff 할당 함수는 사용 상황에 따라 여러 변형이 있습니다:

/* 일반적인 전송 경로 할당 */
struct sk_buff *skb = alloc_skb(MAX_HEADER + payload_len, GFP_KERNEL);
if (!skb)
    return -ENOMEM;
skb_reserve(skb, MAX_HEADER);  /* L2/L3/L4 헤더용 headroom */

/* NAPI 수신 경로 할당 (드라이버 내) */
struct sk_buff *skb = napi_alloc_skb(napi, 256);  /* 헤더만 linear */
/* 페이로드는 page fragment로 추가 */
skb_add_rx_frag(skb, 0, page, offset, size, truesize);

/* build_skb: XDP, 고성능 드라이버에서 사용 */
void *buf = page_address(page);
struct sk_buff *skb = build_skb(buf, PAGE_SIZE);
if (!skb) {
    put_page(page);
    return;
}
skb_reserve(skb, headroom);

해제 함수도 상황에 따라 구분됩니다:

__kfree_skb() 내부 해제 경로 소스 분석

sk_buff의 해제는 단순한 메모리 반환이 아닙니다. 참조 카운트 관리, 소멸자 콜백, 프래그먼트 정리, 클론 처리까지 여러 단계를 거칩니다. 커널 6.x에는 해제 이유를 추적하는 kfree_skb_reason() API도 추가되었습니다.

해제 경로 전체 흐름

skb_release_head_state() 상세 분석

skb_release_head_state()는 sk_buff가 보유한 외부 참조를 모두 해제합니다. 실제 메모리 반환보다 앞서 수행되어야 하는 정리 작업들을 담당합니다.

static void skb_release_head_state(struct sk_buff *skb)
{
    /* ① 라우팅 캐시 참조 해제
     * skb_dst(skb)는 dst 포인터와 noref 비트를 분리해서 반환.
     * noref가 설정되지 않은 경우만 dst_release() 호출. */
    skb_dst_drop(skb);

#ifdef CONFIG_XFRM
    /* ② IPsec 보안 경로(secpath) 참조 해제 */
    if (skb_sec_path(skb))
        secpath_put(skb_sec_path(skb));
#endif

    /* ③ 소멸자 콜백 실행
     * sock_wfree: 소켓 송신 큐 버퍼 카운터 감소 + 대기 프로세스 깨움
     * sock_rfree: 소켓 수신 큐 버퍼 카운터 감소
     * tcp_wfree: TCP 송신 + TSQ(TCP Small Queues) 처리
     * skb_kfree_head: skb_orphan 이후 간단 해제
     */
    if (skb->destructor) {
        WARN_ON(in_hardirq());
        skb->destructor(skb);
    }

#if IS_ENABLED(CONFIG_NF_CONNTRACK)
    /* ④ Netfilter 연결 추적(conntrack) 참조 해제 */
    nf_conntrack_put(skb_nfct(skb));
#endif

    skb_ext_put(skb);   /* ⑤ skb 확장 블록(tc_skb_ext 등) 해제 */
}

skb_release_data() 상세 분석

skb_release_data()는 선형 데이터 버퍼와 비선형 영역(페이지 프래그먼트, frag_list)을 정리합니다. 데이터가 여러 sk_buff에 의해 공유되는 경우 dataref 참조 카운트를 확인한 후 실제 해제 여부를 결정합니다.

static void skb_release_data(struct sk_buff *skb,
                               enum skb_drop_reason reason,
                               bool zerocopy_clean)
{
    struct skb_shared_info *shinfo = skb_shinfo(skb);
    int i;

    /* ① 제로-카피 완료 콜백 처리
     * ubuf_info가 있으면 MSG_ZEROCOPY 전송 완료 통지 */
    if (skb_zcopy(skb)) {
        bool skip_unref = shinfo->flags & SKBFL_DONT_ORPHAN;
        skb_zcopy_clear(skb, zerocopy_clean);
        if (skip_unref)
            return;
    }

    /* ② 공유 데이터 참조 카운트 확인
     * dataref가 0이 되지 않으면 다른 sk_buff가 아직 사용 중 */
    if (!skb_data_unref(skb, shinfo))
        return;   /* 다른 클론이 있으면 중단 */

    /* ③ skb_shared_info의 hw_timestamps 등 정리 */
    skb_zcopy_clear(skb, true);

    /* ④ 페이지 프래그먼트(frags[]) 참조 해제
     * nr_frags개의 각 페이지에 put_page() 수행 */
    for (i = 0; i < shinfo->nr_frags; i++)
        skb_frag_unref(skb, i);

    /* ⑤ frag_list 연결 skb들 재귀 해제
     * 각 frag skb에 대해 kfree_skb() 재귀 호출 */
    if (skb_has_frag_list(skb)) {
        struct sk_buff *frag, *tmp;
        skb_walk_frags(skb, frag) {
            tmp = frag;
            frag = frag->next;
            kfree_skb_reason(tmp, reason);
        }
    }

    /* ⑥ 선형 데이터 버퍼(head) 해제
     * 할당 크기에 따라 kfree() 또는 vfree() 선택 */
    skb_free_head(skb);
}

static void skb_free_head(struct sk_buff *skb)
{
    unsigned char *head = skb->head;

    if (skb->head_frag) {
        /* 페이지 기반 head 버퍼: put_page() */
        if (skb_pp_recycle(skb, head))
            return;  /* 페이지 풀 재사용 */
        skb_free_frag(head);
    } else {
        kfree(head);  /* kmalloc 기반 head 버퍼 */
    }
}

fclone skb 해제 경로

fclone(fast clone)은 TCP 송신 경로에서 자주 발생하는 skb_clone()을 최적화하기 위해, 원본 sk_buff와 클론 슬롯을 하나의 슬랩 객체에 같이 할당하는 방식입니다. skb_fclone_busy(sk, skb)로 클론 중인지 확인하며, 둘 다 해제되어야 슬랩 객체가 반환됩니다.

static void __kfree_skb(struct sk_buff *skb)
{
    skb_release_all(skb);
    kfree_skbmem(skb);
}

static void kfree_skbmem(struct sk_buff *skb)
{
    struct sk_buff_fclones *fclones;

    switch (skb->fclone) {
    case SKB_FCLONE_UNAVAILABLE:
        /* 일반 skb: skbuff_cache 슬랩에 반환 */
        kmem_cache_free(skbuff_cache, skb);
        return;

    case SKB_FCLONE_ORIG:
        /* 원본 fclone skb: 클론 슬롯 확인 */
        fclones = container_of(skb, struct sk_buff_fclones, skb1);

        /* 클론이 아직 살아있으면 원본만 DEAD 표시 후 종료.
         * 클론이 나중에 해제될 때 슬랩 객체 반환. */
        if (skb_fclone_busy(skb->sk, skb))
            break;

        fclones->skb1.fclone = SKB_FCLONE_UNAVAILABLE;
        goto fastpath;

    case SKB_FCLONE_CLONE:
        /* 클론 skb: 원본이 DEAD이면 함께 슬랩 반환 */
        fclones = container_of(skb, struct sk_buff_fclones, skb2);

        /* 원본 refcount 확인: 원본이 아직 살아있으면 클론만 해제 */
        if (!refcount_dec_and_test(&fclones->fclone_ref))
            return;
        break;
    }

fastpath:
    /* fclone 쌍 전체를 skbuff_fclone_cache에 반환 */
    kmem_cache_free(skbuff_fclone_cache, fclones);
}

kfree_skb_reason() — 6.x 해제 이유 추적

리눅스 커널 5.17부터 도입된 kfree_skb_reason()은 패킷이 드롭될 때 그 이유를 enum skb_drop_reason으로 기록합니다. 이 정보는 trace_kfree_skb 트레이스포인트를 통해 perf, bpftrace, ftrace로 관측할 수 있으며, 네트워크 패킷 드롭 디버깅에 매우 유용합니다.

/* 커널 코드: 드롭 원인 지정 해제 */
static int udp_rcv(struct sk_buff *skb)
{
    return __udp4_lib_rcv(skb, &udp_table, IPPROTO_UDP);
}

static int __udp4_lib_rcv(struct sk_buff *skb, ...)
{
    /* ... */
    if (udp4_csum_init(skb, uh, proto))
        goto csum_error;
    /* ... */

csum_error:
    kfree_skb_reason(skb, SKB_DROP_REASON_UDP_CSUM);
    return 0;
}

/* --- bpftrace로 드롭 이유 실시간 추적 --- */
/*
 * sudo bpftrace -e '
 *   tracepoint:skb:kfree_skb {
 *     @reason[args->reason] = count();
 *   }
 *   interval:s:5 { print(@reason); clear(@reason); }
 * '
 */

/* --- perf로 kfree_skb 이벤트 기록 --- */
/*
 * perf record -e skb:kfree_skb -ag -- sleep 10
 * perf script | awk '{print $NF}' | sort | uniq -c | sort -rn
 */

/* trace_kfree_skb 트레이스포인트 정의 (include/trace/events/skb.h) */
TRACE_EVENT(kfree_skb,
    TP_PROTO(struct sk_buff *skb, void *location,
             enum skb_drop_reason reason),
    TP_ARGS(skb, location, reason),
    TP_STRUCT__entry(
        __field(void *, skbaddr)
        __field(void *, location)
        __field(unsigned short, protocol)
        __field(enum skb_drop_reason, reason)
    ),
    TP_fast_assign(
        __entry->skbaddr  = skb;
        __entry->location = location;
        __entry->protocol = ntohs(skb->protocol);
        __entry->reason   = reason;
    ),
    TP_printk("skbaddr=%p protocol=%u location=%p reason: %s",
              __entry->skbaddr, __entry->protocol,
              __entry->location,
              __print_symbolic(__entry->reason,
                               DEFINE_DROP_REASON(...)
              ))
);

skb_release_all()의 호출 순서가 중요한 이유

skb_release_head_state()가 skb_release_data()보다 먼저 호출되어야 합니다. 소멸자 콜백(destructor)인 sock_wfree()나 tcp_wfree()는 소켓의 송신 버퍼 카운터를 갱신하고 대기 중인 프로세스를 깨울 수 있습니다. 이때 소켓이 여전히 유효한 상태여야 하므로, 데이터 메모리 해제보다 소켓 참조 정리가 선행되어야 합니다.

마찬가지로 nf_conntrack_put()은 연결 추적 항목의 참조를 감소시켜 타임아웃 타이머가 돌아가도록 합니다. 이 작업 역시 데이터 버퍼와는 독립적으로 먼저 수행해야 레이스 컨디션이 발생하지 않습니다.

메모리 레이아웃

sk_buff의 데이터 영역은 4개의 핵심 포인터로 관리됩니다:

아래 다이어그램은 두 부분으로 구성됩니다. 상단은 struct sk_buff의 포인터 필드가 할당된 버퍼의 어느 영역을 가리키는지 보여주고, 하단은 skb_reserve/skb_put/skb_push/skb_pull 호출 시 포인터가 어떻게 이동하는지 단계별로 나타냅니다:

이 레이아웃은 불변식 head ≤ data ≤ tail ≤ end를 항상 유지합니다. 이 조건이 깨지면 커널 패닉(Kernel Panic) 또는 메모리 손상으로 이어집니다. skb_push()/skb_pull()/skb_put() 계열 함수는 호출 전에 이 불변식을 검증하며, 위반 시 skb_over_panic / skb_under_panic을 트리거합니다.

메모리 관련 주요 매크로(Macro)

sk_buff 버퍼 크기를 계산할 때 자주 사용되는 매크로입니다:

데이터 조작 함수

sk_buff의 데이터 영역은 head, data, tail, end 4개 포인터로 관리됩니다. 이 포인터들을 조작하는 함수들은 Linux 네트워크 코드에서 가장 빈번하게 사용되는 핵심 API입니다. 할당 직후의 빈 skb에서 프로토콜 헤더와 페이로드(Payload)를 채워가는 과정, 수신 패킷에서 헤더를 벗겨가는 과정 모두 이 함수들의 조합으로 이루어집니다.

skb_reserve — headroom 확보

/* include/linux/skbuff.h */
static inline void skb_reserve(struct sk_buff *skb, int len);

skb_reserve()는 data와 tail 포인터를 동시에 len만큼 뒤로 이동시켜 headroom(헤더 추가 공간)을 확보합니다. 반드시 할당 직후, 데이터를 넣기 전에만 호출해야 합니다.

/* 사용 예: 전송 경로에서 L2/L3/L4 헤더를 위한 headroom 확보 */
struct sk_buff *skb = alloc_skb(MAX_HEADER + payload_len, GFP_KERNEL);
if (!skb)
    return -ENOMEM;
skb_reserve(skb, MAX_HEADER);  /* data=tail=head+MAX_HEADER */
/* 이후 skb_put()으로 payload, skb_push()로 헤더 추가 */

/* 사용 예: 드라이버 수신 경로에서 NET_IP_ALIGN 정렬 */
struct sk_buff *skb = netdev_alloc_skb(dev, len + NET_IP_ALIGN);
skb_reserve(skb, NET_IP_ALIGN);  /* IP 헤더 4바이트 정렬 (x86 외) */

skb_put 계열 — 데이터 끝에 추가

skb_put() 계열 함수는 tail 포인터를 뒤로 이동하여 데이터 영역을 확장합니다. 주로 전송 경로에서 페이로드를 추가하거나, 수신 드라이버에서 수신된 데이터 크기를 설정할 때 사용됩니다.

/* 기본 사용: 페이로드 추가 */
unsigned char *p = skb_put(skb, payload_len);
memcpy(p, payload_data, payload_len);

/* skb_put_data: 위 두 줄을 한 줄로 (4.13+, 권장) */
skb_put_data(skb, payload_data, payload_len);

/* skb_put_zero: 패딩 영역을 0으로 채우기 */
skb_put_zero(skb, 4);  /* 4바이트 zero 패딩 추가 */

/* __skb_put: 드라이버에서 DMA 수신 버퍼 크기 설정 시 */
__skb_put(skb, rx_size);  /* 이미 할당 시 충분한 공간 확보됨 */

/* skb_put_u8: 1바이트 필드 추가 */
skb_put_u8(skb, MY_PROTO_VERSION);  /* version 필드 */
skb_put_u8(skb, MY_MSG_TYPE);       /* type 필드 */

/* 구조체 단위로 헤더 추가하는 패턴 */
struct my_hdr *hdr = skb_put_zero(skb, sizeof(*hdr));
hdr->version = 1;
hdr->payload_len = htons(data_len);

skb_push 계열 — 헤더 추가 (앞쪽 확장)

skb_push() 계열 함수는 data 포인터를 앞으로 이동하여 headroom에서 공간을 가져옵니다. 전송 경로에서 프로토콜 헤더를 추가할 때 사용됩니다 (L4 → L3 → L2 순서).

/* 전형적인 전송 경로: L4 → L3 → L2 순서로 헤더 추가 */

/* 1. UDP 헤더 추가 */
struct udphdr *uh = skb_push(skb, sizeof(*uh));
skb_reset_transport_header(skb);
uh->source = sport;
uh->dest = dport;
uh->len = htons(skb->len);
uh->check = 0;

/* 2. IP 헤더 추가 */
struct iphdr *iph = skb_push(skb, sizeof(*iph));
skb_reset_network_header(skb);
iph->version = 4;
iph->ihl = 5;
iph->tot_len = htons(skb->len);
/* ... 나머지 IP 필드 설정 ... */

/* 3. Ethernet 헤더 추가 */
struct ethhdr *eth = skb_push(skb, ETH_HLEN);
skb_reset_mac_header(skb);
ether_addr_copy(eth->h_dest, dst_mac);
ether_addr_copy(eth->h_source, src_mac);
eth->h_proto = htons(ETH_P_IP);

/* __skb_push: 터널 드라이버에서 outer 헤더 추가 시 */
/* headroom은 skb_cow_head()로 이미 확보된 상태 */
struct vxlanhdr *vxh = (struct vxlanhdr *)__skb_push(skb, sizeof(*vxh));

skb_pull 계열 — 헤더 제거 (앞쪽 축소)

skb_pull() 계열 함수는 data 포인터를 뒤로 이동하여 이미 처리된 헤더를 건너뜁니다. 수신 경로에서 프로토콜 레이어를 올라갈 때 사용됩니다 (L2 → L3 → L4 순서).

/* 수신 경로: eth_type_trans()가 L2 헤더를 처리 */
skb->protocol = eth_type_trans(skb, dev);
/* 내부적으로 skb_pull(skb, ETH_HLEN) 수행 → data가 L3 시작을 가리킴 */

/* IP 프로토콜 핸들러에서: IP 헤더 건너뛰기 */
skb_pull(skb, ip_hdrlen(skb));
skb_reset_transport_header(skb);
/* 이제 data가 L4 (TCP/UDP) 헤더를 가리킴 */

/* pskb_pull: 비선형 skb에서 안전하게 헤더 제거 */
/* GRO로 병합된 패킷은 페이로드가 frags에 있을 수 있음 */
if (!pskb_pull(skb, header_len))
    goto drop;

/* skb_pull_data: 검증 + 당기기를 한 번에 (5.14+, 권장) */
struct my_hdr *hdr;
if (!skb_pull_data(skb, sizeof(*hdr)))
    goto drop;  /* linear + paged 모두 검사 후 pull */

길이/공간 조회 함수

skb의 현재 데이터 크기와 남은 공간을 조회하는 인라인 함수들입니다. 데이터 추가 전 공간 확인, 비선형 여부 판단 등에 필수적으로 사용됩니다.

/* 공간 확인 후 안전하게 데이터 추가 */
if (skb_tailroom(skb) < extra_len) {
    /* tailroom 부족 → 확장 필요 */
    if (pskb_expand_head(skb, 0, extra_len, GFP_ATOMIC))
        goto drop;
}
skb_put_data(skb, extra_data, extra_len);

/* 비선형 여부에 따른 분기 처리 */
if (skb_is_nonlinear(skb)) {
    /* paged fragments가 있음 → skb_copy_bits() 등으로 접근 */
    skb_copy_bits(skb, offset, buf, len);
} else {
    /* 모든 데이터가 linear → 직접 포인터 접근 가능 */
    memcpy(buf, skb->data + offset, len);
}

/* headroom 확인: 터널 캡슐화 전 */
int needed_headroom = sizeof(struct iphdr) + sizeof(struct udphdr) + VXLAN_HLEN;
if (skb_headroom(skb) < needed_headroom) {
    /* skb_cow_head()가 내부적으로 이 검사 + expand를 수행 */
    if (skb_cow_head(skb, needed_headroom))
        goto tx_error;
}

skb_trim 계열 — 끝에서 자르기

skb_trim() 계열 함수는 skb의 전체 길이를 줄입니다. 패킷 끝의 불필요한 데이터 제거, 패딩 제거, IP total length에 맞게 자르기 등에 사용됩니다.

/* IP 수신 경로: 패킷을 IP total length에 맞게 trim */
unsigned int pkt_len = ntohs(iph->tot_len);
if (pkt_len < skb->len) {
    /* Ethernet padding 등으로 실제보다 길 수 있음 → 잘라내기 */
    if (pskb_trim_rcsum(skb, pkt_len))
        goto drop;
}

/* linear skb에서 단순 trim */
if (!skb_is_nonlinear(skb))
    skb_trim(skb, new_len);  /* tail 포인터 조정 */
else
    pskb_trim(skb, new_len); /* fragments도 처리 */

/* 커스텀 프로토콜에서 트레일러 제거 */
int trailer_len = my_trailer_size(skb);
pskb_trim(skb, skb->len - trailer_len);

skb_pad / skb_padto 계열 — 최소 길이 패딩

Ethernet은 최소 프레임 크기 60바이트(FCS 제외)를 요구합니다. 짧은 패킷을 전송할 때 최소 길이를 맞추기 위해 skb_pad()를 사용합니다.

/* 네트워크 드라이버 xmit: Ethernet 최소 프레임 크기 보장 */
static netdev_tx_t my_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
    /* ETH_ZLEN = 60. 짧은 패킷을 60바이트까지 0으로 패딩 */
    if (eth_skb_pad(skb))
        return NETDEV_TX_OK;  /* 실패 시 skb는 이미 해제됨 */

    /* ... DMA 매핑 및 전송 ... */
}

/* 특정 길이로 패딩 (예: 46바이트 최소 페이로드) */
if (skb->len < min_len) {
    if (skb_padto(skb, min_len))
        return -ENOMEM;  /* skb는 이미 해제됨 — 이중 해제 금지! */
    skb->len = min_len;  /* __skb_put_padto 사용 시 자동 갱신 */
}

전형적인 전송/수신 경로 조작 순서

/* ══════════════════════════════════════════════
 * 전송(TX) 경로: reserve → put → push × N
 * ══════════════════════════════════════════════ */
struct sk_buff *skb = alloc_skb(1500 + headroom, GFP_KERNEL);

/* 1. headroom 확보 */
skb_reserve(skb, headroom);   /* data=tail → head+headroom */

/* 2. 페이로드 추가 */
skb_put_data(skb, payload_data, payload_len);  /* tail ↓ */

/* 3. TCP 헤더 추가 */
struct tcphdr *th = skb_push(skb, sizeof(*th));  /* data ↑ */
skb_reset_transport_header(skb);

/* 4. IP 헤더 추가 */
struct iphdr *iph = skb_push(skb, sizeof(*iph));  /* data ↑↑ */
skb_reset_network_header(skb);

/* 5. Ethernet 헤더 추가 */
struct ethhdr *eh = skb_push(skb, ETH_HLEN);  /* data ↑↑↑ */
skb_reset_mac_header(skb);

/* ══════════════════════════════════════════════
 * 수신(RX) 경로: pull × N (위와 반대 순서)
 * ══════════════════════════════════════════════ */
/* 드라이버가 skb를 할당하고 DMA로 데이터 수신 */
skb_put(skb, rx_bytes);  /* 수신된 바이트만큼 len 설정 */

/* L2: eth_type_trans()가 Ethernet 헤더를 파싱하고 pull */
skb->protocol = eth_type_trans(skb, dev);  /* 내부적으로 skb_pull(ETH_HLEN) */

/* L3: IP 수신 핸들러 */
if (!pskb_may_pull(skb, sizeof(struct iphdr)))
    goto drop;
struct iphdr *iph = ip_hdr(skb);
skb_pull(skb, iph->ihl * 4);  /* IP 헤더 건너뛰기 */
skb_reset_transport_header(skb);

/* L4: TCP/UDP 핸들러에서 transport 헤더 접근 */
struct tcphdr *th = tcp_hdr(skb);
/* data는 여전히 TCP 헤더를 가리킴 (TCP가 직접 pull하지 않고 offset 사용) */

Clone/Copy 메커니즘

여러 곳에서 같은 패킷을 참조해야 할 때 (예: 패킷 미러링, tcpdump 캡처, netfilter bridge), 세 가지 복사 전략을 선택할 수 있습니다:

/* clone: sk_buff 메타데이터만 복사, 데이터 버퍼는 공유 (refcount 증가) */
struct sk_buff *clone = skb_clone(skb, GFP_ATOMIC);
/* clone->data == skb->data (같은 버퍼 참조) */
/* skb_shared_info.dataref 증가됨 */

/* pskb_copy: linear 헤더만 복사, paged data는 page refcount 증가 */
struct sk_buff *pcopy = pskb_copy(skb, GFP_ATOMIC);
/* 헤더를 수정해야 하지만 페이로드는 그대로인 경우 최적 */

/* copy: 메타데이터 + linear + paged 데이터 모두 완전 복사 */
struct sk_buff *copy = skb_copy(skb, GFP_ATOMIC);
/* copy->data != skb->data (독립적 버퍼) */

/* skb_share_check: 공유 여부 확인 후 필요 시 clone */
skb = skb_share_check(skb, GFP_ATOMIC);
if (!skb)
    return NET_RX_DROP;
/* 이제 skb를 독점적으로 소유 — 안전하게 메타데이터 수정 가능 */

프래그먼트와 scatter-gather

대용량 패킷은 linear 데이터 외에 paged fragments를 사용합니다. skb_shared_info는 end 포인터 바로 뒤에 위치하며, fragment 배열과 GSO 메타데이터를 관리합니다.

/* skb_shared_info: end 포인터 바로 뒤에 위치 */
struct skb_shared_info {
    __u8        nr_frags;           /* fragment 수 */
    __u8        tx_flags;
    unsigned short gso_size;       /* GSO 세그먼트 크기 */
    unsigned short gso_segs;       /* GSO 세그먼트 수 */
    unsigned short gso_type;       /* GSO 타입 */
    struct sk_buff *frag_list;     /* 연결된 skb 리스트 */
    skb_frag_t  frags[MAX_SKB_FRAGS]; /* page fragment 배열 */
    atomic_t    dataref;            /* 데이터 공유 참조 카운트 */
};

프래그먼트 접근 함수

프래그먼트 추가 함수

/* fragment 순회 */
struct skb_shared_info *si = skb_shinfo(skb);
for (int i = 0; i < si->nr_frags; i++) {
    skb_frag_t *frag = &si->frags[i];
    struct page *page = skb_frag_page(frag);
    unsigned int offset = skb_frag_off(frag);
    unsigned int size = skb_frag_size(frag);
    /* page + offset에서 size 바이트 데이터 */
}

/* 드라이버 수신: DMA로 받은 페이지를 fragment로 추가 */
struct sk_buff *skb = napi_alloc_skb(napi, 256);  /* 헤더만 linear */
skb_put(skb, header_len);
memcpy(skb->data, dma_buf, header_len);

/* 페이로드는 DMA 페이지를 fragment로 직접 참조 (zero-copy) */
skb_add_rx_frag(skb, 0, rx_page, rx_offset, payload_size, PAGE_SIZE);
/* 내부적으로: skb->len += payload_size,
 *            skb->data_len += payload_size,
 *            skb->truesize += PAGE_SIZE */

/* zero-copy 전송: sendfile에서 파일 페이지를 fragment로 */
skb_fill_page_desc(skb, frag_idx, file_page, page_offset, chunk_size);
skb->len += chunk_size;
skb->data_len += chunk_size;
skb->truesize += chunk_size;  /* 호출자가 직접 갱신 */

/* frag_list 순회 (GRO 병합, IP 재조립 결과) */
struct sk_buff *frag_iter;
skb_walk_frags(skb, frag_iter) {
    /* frag_iter는 frag_list의 각 skb */
    pr_debug("frag_list skb len=%u
", frag_iter->len);
}

고급 데이터 조작

패킷 처리 시 데이터 레이아웃을 변경해야 하는 상황이 자주 발생합니다. 비선형(paged) 데이터 처리, headroom 확장, clone된 skb의 쓰기 권한 확보 등 고급 시나리오를 다루는 함수들입니다.

pskb_may_pull — linear 영역 확보 (★★★ 최중요)

/* include/linux/skbuff.h */
static inline int pskb_may_pull(struct sk_buff *skb, unsigned int len);

pskb_may_pull()은 프로토콜 헤더 파싱 전에 반드시 호출해야 하는 필수 함수입니다. linear 영역에 최소 len 바이트가 있는지 확인하고, 부족하면 paged fragments에서 linear 영역으로 데이터를 당겨옵니다.

/* 기본 패턴: 프로토콜 헤더 파싱 전 linear 확보 */
static int my_protocol_rcv(struct sk_buff *skb)
{
    struct my_hdr *hdr;

    /* 1단계: 고정 크기 헤더만큼 확보 */
    if (!pskb_may_pull(skb, sizeof(*hdr)))
        goto drop;

    hdr = (struct my_hdr *)skb_transport_header(skb);
    /* 이제 hdr-> 필드에 안전하게 접근 가능 */

    /* 2단계: 가변 길이 헤더 (옵션 등) */
    if (!pskb_may_pull(skb, hdr->hdr_len))
        goto drop;

    hdr = (struct my_hdr *)skb_transport_header(skb); /* ★ 포인터 재취득! */
    /* ... 처리 ... */
}

/* 실제 커널 코드 예: IPv6 옵션 헤더 파싱 */
/* net/ipv6/exthdrs.c */
if (!pskb_may_pull(skb, skb_transport_offset(skb) + 8))
    goto fail;
struct ipv6_opt_hdr *opth = (struct ipv6_opt_hdr *)skb_transport_header(skb);
int optlen = ipv6_optlen(opth);
if (!pskb_may_pull(skb, skb_transport_offset(skb) + optlen))
    goto fail;
opth = (struct ipv6_opt_hdr *)skb_transport_header(skb); /* ★ 재취득 */

skb_ensure_writable — 쓰기 가능 영역 확보 (6.x+ 권장)

int skb_ensure_writable(struct sk_buff *skb, unsigned int write_len);

skb_ensure_writable()는 패킷 데이터를 수정하기 전에 호출하는 통합 함수입니다. 내부적으로 clone 상태 해제(skb_unclone) + linear 영역 확보(pskb_may_pull)를 모두 수행합니다. skb_make_writable()의 개선 버전으로, netfilter/tc 등에서 패킷 수정 전 표준 패턴입니다.

/* netfilter/tc에서 패킷 내용 수정 전 */
if (skb_ensure_writable(skb, skb_network_header_len(skb) + sizeof(struct tcphdr)))
    goto drop;

/* 이제 IP + TCP 헤더 영역을 안전하게 수정 가능 */
struct iphdr *iph = ip_hdr(skb);   /* ★ 포인터 재취득 */
iph->ttl = 64;
struct tcphdr *th = tcp_hdr(skb);  /* ★ 포인터 재취득 */
th->window = htons(new_window);

/* NAT 구현: 소스 IP 변경 */
if (skb_ensure_writable(skb, skb_network_offset(skb) + sizeof(struct iphdr)))
    return NF_DROP;
iph = ip_hdr(skb);
csum_replace4(&iph->check, iph->saddr, new_saddr);
iph->saddr = new_saddr;

skb_linearize — 전체 linearize

static inline int skb_linearize(struct sk_buff *skb);

모든 paged fragments와 frag_list의 데이터를 하나의 연속 linear 버퍼에 합칩니다. 내부적으로 __pskb_pull_tail(skb, skb->data_len)을 호출합니다.

/* scatter-gather를 지원하지 않는 레거시 장치 */
if (skb_is_nonlinear(skb)) {
    if (skb_linearize(skb))
        goto drop;  /* -ENOMEM: 새 버퍼 할당 실패 */
    /* 이제 모든 데이터가 head~tail 사이에 연속 존재 */
}

/* 디버깅/검증: 전체 패킷 덤프 전 */
if (skb_linearize(skb) == 0)
    print_hex_dump(KERN_DEBUG, "pkt: ", DUMP_PREFIX_OFFSET,
                   16, 1, skb->data, skb->len, true);

pskb_expand_head — headroom/tailroom 확장

int pskb_expand_head(struct sk_buff *skb, int nhead, int ntail, gfp_t gfp_mask);

skb의 headroom을 nhead바이트, tailroom을 ntail바이트 추가로 확장합니다. 필요 시 새 버퍼를 할당하고 linear 데이터를 복사합니다. clone 상태의 skb는 자동으로 unclone됩니다.

/* 터널 캡슐화 전: headroom 확장 */
int max_headroom = LL_RESERVED_SPACE(tun_dev) + sizeof(struct iphdr)
                   + sizeof(struct udphdr) + GENEVE_HLEN;

if (skb_headroom(skb) < max_headroom || skb_header_cloned(skb)) {
    if (pskb_expand_head(skb, max_headroom, 0, GFP_ATOMIC))
        goto tx_error;
}

/* skb_expand_head: 더 간단한 API (5.12+) */
if (skb_expand_head(skb, needed_headroom))
    return NETDEV_TX_OK;  /* 실패 시 skb 이미 해제됨! */

/* skb_realloc_headroom: 원본을 보존하며 새 skb 생성 */
struct sk_buff *new_skb = skb_realloc_headroom(skb, needed);
if (!new_skb)
    goto drop;
consume_skb(skb);  /* 원본 해제 */
skb = new_skb;

/* skb_copy_expand: 완전 복사 + 확장 */
struct sk_buff *expanded = skb_copy_expand(skb, extra_head, extra_tail, GFP_ATOMIC);
if (!expanded)
    goto drop;
/* expanded는 완전히 독립된 복사본 + 확장된 headroom/tailroom */

skb_cow 계열 — Copy-On-Write

clone된(공유 버퍼를 가진) skb의 데이터를 수정하려면, 먼저 독점적 쓰기 권한을 확보해야 합니다. skb_cow 계열 함수가 이를 처리합니다.

/* skb_cow_head: 터널 encapsulation 전 (★가장 흔한 패턴) */
static int my_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
{
    int hdr_len = sizeof(struct iphdr) + sizeof(struct gre_hdr);

    /* 클론 상태 해제 + headroom 확보를 동시에 수행 */
    if (skb_cow_head(skb, hdr_len + LL_RESERVED_SPACE(dev))) {
        kfree_skb(skb);
        return NETDEV_TX_OK;
    }

    /* 이제 안전하게 헤더 추가 가능 (독점 소유) */
    skb_push(skb, hdr_len);
    /* ... GRE + IP 헤더 설정 ... */
}

/* skb_cow: 포워딩 경로에서 TTL 수정 */
if (skb_cow(skb, LL_RESERVED_SPACE(rt->dst.dev)))
    goto drop;
ip_hdr(skb)->ttl--;  /* linear 데이터 수정 안전 */
ip_send_check(ip_hdr(skb));

/* skb_cow_data: IPSec ESP 암호화 전 */
struct sk_buff *trailer;
int nfrags = skb_cow_data(skb, esp_trailer_len, &trailer);
if (nfrags < 0)
    goto error;
/* 이제 paged data를 포함한 전체 패킷을 수정 가능 */
/* trailer는 마지막 fragment의 skb를 가리킴 (ESP padding 추가용) */

공유 상태 확인 및 해제 함수

skb가 clone되었거나 여러 곳에서 참조되는지 확인하고, 필요 시 독점 소유를 확보하는 함수들입니다.

/* 수신 핸들러: 패킷 수정 전 독점 소유 확보 */
static int my_netfilter_hook(struct sk_buff *skb)
{
    /* 1. 메타데이터 공유 해제 (여러 수신자가 같은 skb를 참조할 수 있음) */
    skb = skb_share_check(skb, GFP_ATOMIC);
    if (!skb)
        return NET_RX_DROP;

    /* 2. 데이터 쓰기 권한 확보 (clone된 데이터 버퍼 독립화) */
    if (skb_ensure_writable(skb, skb_network_header_len(skb)))
        goto drop;

    /* 이제 안전하게 패킷 수정 가능 */
    ip_hdr(skb)->tos = new_tos;
    return NET_RX_SUCCESS;
}

/* 브리지에서 패킷을 여러 포트로 복제 전송 */
if (skb_shared(skb)) {
    /* 이미 다른 곳에서 참조 중 → clone으로 분리 */
    struct sk_buff *new_skb = skb_clone(skb, GFP_ATOMIC);
    if (!new_skb)
        return;
    /* new_skb를 해당 포트로 전송 */
}

/* clone 상태 해제 (linear 데이터 독립화) */
if (skb_cloned(skb)) {
    if (skb_unclone(skb, GFP_ATOMIC))
        goto drop;
    /* 이제 linear 데이터를 수정해도 원본에 영향 없음 */
}

skb_make_writable — 레거시 호환

int skb_make_writable(struct sk_buff *skb, unsigned int writable_len);

writable_len 바이트까지 쓰기 가능하게 만듭니다. skb_ensure_writable()와 거의 동일하지만, writable_len > skb->len이면 실패를 반환하는 추가 검사가 있습니다. 새 코드에서는 skb_ensure_writable()를 사용하세요.

헤더 포인터 조작 함수

sk_buff는 L2/L3/L4 각 프로토콜 레이어의 헤더 위치를 mac_header, network_header, transport_header 세 개의 오프셋(Offset)으로 추적합니다. 이 오프셋을 설정/조회하는 함수들은 패킷 처리의 기반입니다.

헤더 포인터 접근 함수

헤더 포인터 설정/리셋 함수

헤더 오프셋/길이 조회 함수

/* 프로토콜별 편의 매크로 (헤더 포인터 + 캐스팅) */
struct ethhdr  *eth = eth_hdr(skb);      /* (struct ethhdr *)skb_mac_header(skb) */
struct iphdr   *iph = ip_hdr(skb);       /* (struct iphdr *)skb_network_header(skb) */
struct ipv6hdr *ip6h = ipv6_hdr(skb);   /* (struct ipv6hdr *)skb_network_header(skb) */
struct tcphdr  *th = tcp_hdr(skb);       /* (struct tcphdr *)skb_transport_header(skb) */
struct udphdr  *uh = udp_hdr(skb);       /* (struct udphdr *)skb_transport_header(skb) */
struct icmphdr *icmph = icmp_hdr(skb);   /* (struct icmphdr *)skb_transport_header(skb) */

/* 터널 캡슐화 시 inner/outer 헤더 구분 */
struct iphdr *outer_iph = ip_hdr(skb);
skb_set_inner_network_header(skb, skb_network_offset(skb));
skb_set_inner_transport_header(skb, skb_transport_offset(skb));
/* outer 헤더 추가 후 */
skb_push(skb, outer_hdr_len);
skb_reset_network_header(skb);
/* 이제 ip_hdr(skb)는 outer, skb_inner_network_header(skb)는 inner */

/* 포워딩 후 L2 헤더 재구성 */
if (skb_mac_header_was_set(skb))
    skb_mac_header_rebuild(skb);  /* mac_header를 network_header 앞으로 이동 */

데이터 접근 및 복사 함수

비선형(paged) skb에서 데이터를 읽거나 쓰려면, linear 영역 너머의 fragments까지 처리하는 전용 함수가 필요합니다. 직접 포인터 접근(skb->data + offset)은 linear 영역만 가능합니다.

skb_header_pointer — 비선형 안전 헤더 접근 (★★ 매우 중요)

static inline void *skb_header_pointer(
    const struct sk_buff *skb,
    int offset, int len,
    void *buffer);

skb->data + offset에서 len 바이트를 안전하게 접근합니다. 데이터가 linear 영역에 있으면 직접 포인터를 반환하고, paged 영역에 걸쳐 있으면 buffer에 복사 후 buffer 포인터를 반환합니다. 실패 시 NULL을 반환합니다.

/* 전형적 사용법: netfilter에서 TCP 포트 확인 */
struct tcphdr _tcph;  /* 스택에 임시 버퍼 */
const struct tcphdr *th;

th = skb_header_pointer(skb,
    skb_network_header_len(skb),   /* IP 헤더 뒤 */
    sizeof(_tcph),                 /* TCP 헤더 크기 */
    &_tcph);                       /* 임시 복사 버퍼 */
if (!th)
    return NF_DROP;  /* 데이터 부족 */
/* th가 linear 데이터를 직접 가리키거나, _tcph의 복사본을 가리킴 */
pr_info("src port: %u
", ntohs(th->source));

/* 읽기 전용 접근에 최적: 복사 불필요 시 zero-copy */
/* 쓰기가 필요하면 skb_ensure_writable() + 직접 접근이 더 적합 */

/* 중첩된 프로토콜 헤더 접근 */
struct gre_base_hdr _greh;
const struct gre_base_hdr *greh;
int gre_offset = skb_transport_offset(skb) + sizeof(struct udphdr);
greh = skb_header_pointer(skb, gre_offset, sizeof(_greh), &_greh);

skb_copy_bits / skb_store_bits — 비선형 데이터 읽기/쓰기

/* 비선형 skb에서 특정 오프셋의 데이터 읽기 */
u8 buf[64];
if (skb_copy_bits(skb, offset, buf, sizeof(buf)) < 0)
    goto drop;  /* offset + len > skb->len */

/* 비선형 skb의 특정 위치에 데이터 쓰기 */
__be16 new_port = htons(8080);
skb_store_bits(skb, transport_offset + offsetof(struct udphdr, dest),
               &new_port, sizeof(new_port));

/* 소켓 수신 경로: 사용자 공간으로 복사 */
int my_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int flags)
{
    struct sk_buff *skb = skb_recv_datagram(sk, flags, &err);
    if (!skb)
        return err;

    /* 비선형 skb에서도 안전하게 사용자 공간에 복사 */
    err = skb_copy_datagram_msg(skb, header_len, msg, copy_len);
    skb_free_datagram(sk, skb);
    return err ? err : copy_len;
}

체크섬 조작 함수

패킷의 체크섬(Checksum)은 데이터 무결성 확인의 핵심입니다. skb 데이터를 수정할 때마다 관련 체크섬을 갱신해야 하며, 하드웨어 오프로드 상태도 고려해야 합니다.

/* NAT: 소스 IP + 포트 변경 시 체크섬 갱신 */
static void nat_saddr(struct sk_buff *skb, __be32 new_saddr, __be16 new_sport)
{
    struct iphdr *iph = ip_hdr(skb);
    struct tcphdr *th = tcp_hdr(skb);

    /* IP 체크섬: 소스 IP 변경 반영 */
    csum_replace4(&iph->check, iph->saddr, new_saddr);
    iph->saddr = new_saddr;

    /* TCP 체크섬: pseudo-header의 소스 IP 변경 + 소스 포트 변경 */
    inet_proto_csum_replace4(&th->check, skb,
                             iph->saddr, new_saddr, true);  /* pseudohdr=true */
    inet_proto_csum_replace2(&th->check, skb,
                             th->source, new_sport, false);
    th->source = new_sport;
}

/* 수신 경로: 체크섬 검증 */
if (skb->ip_summed == CHECKSUM_COMPLETE) {
    /* HW가 전체 체크섬 제공 → 빠른 검증 */
    if (skb_checksum_complete(skb))
        goto csum_error;
} else if (skb->ip_summed != CHECKSUM_UNNECESSARY) {
    /* SW 체크섬 계산 필요 */
    skb_checksum_init(skb, IPPROTO_TCP, inet_compute_pseudo);
    if (skb_checksum_complete(skb))
        goto csum_error;
}

/* CHECKSUM_PARTIAL → SW 체크섬으로 강제 변환 */
/* (e.g., netfilter REDIRECT 후 loopback으로 재진입 시) */
if (skb_checksum_help(skb))
    goto drop;

skb 분할/병합/변형 함수

GSO/TSO, TCP 재전송, 패킷 포워딩 등에서 skb를 분할하거나 변형해야 하는 경우에 사용되는 함수들입니다.

/* skb_split: TCP 세그먼트 분할 (재전송 시) */
struct sk_buff *buff = alloc_skb(nsize, GFP_ATOMIC);
if (!buff)
    return -ENOMEM;
skb_split(skb, buff, len);
/* skb: 0 ~ len-1 바이트 (재전송할 부분) */
/* buff: len ~ 끝 (나중에 전송할 부분) */
skb_queue_after(&sk->sk_write_queue, skb, buff);

/* skb_segment: GSO → 개별 MSS 세그먼트로 분할 */
/* NIC가 TSO를 지원하지 않는 경로에서 SW GSO 수행 */
struct sk_buff *segs = skb_gso_segment(skb, dev->features);
if (IS_ERR(segs)) {
    kfree_skb(skb);
    return PTR_ERR(segs);
}
/* segs는 연결된 skb 리스트 (각각 MSS 크기) */
consume_skb(skb);
skb_list_walk_safe(segs, seg, next) {
    skb_mark_not_on_list(seg);
    dev_queue_xmit(seg);
}

/* skb_orphan: qdisc에서 소켓 메모리 즉시 해제 */
/* fq_codel 등에서 큐잉 시간이 길어질 수 있으므로 */
skb_orphan(skb);
/* skb->sk = NULL, destructor가 호출되어 sk_wmem_alloc 감소 */
/* → 소켓이 새 데이터를 전송할 수 있게 됨 */

/* skb_scrub_packet: 네임스페이스 간 포워딩 시 */
skb_scrub_packet(skb, true);  /* xnet=true: 네트워크 네임스페이스 경계 */
/* mark, priority, pkt_type, hash 등 초기화됨 */

/* skb_condense: 소켓 수신 큐 메모리 최적화 */
/* GRO 후 linear 영역에 slack이 클 수 있음 */
skb_condense(skb);
/* data_len이 0이 아니고 truesize > SKB_TRUESIZE(skb_end_offset(skb))이면 */
/* paged data를 가능한 한 linear으로 옮기고 slack 해제 */

참조 카운트 및 소유권 함수

skb의 수명주기를 관리하는 참조 카운트와 소유권 관련 함수들입니다.

/* skb_get: 패킷 미러링 — 원본을 유지하면서 다른 경로로도 전달 */
struct sk_buff *mirror = skb_get(skb);
/* mirror와 skb는 동일한 sk_buff 구조체 (users == 2) */
/* 주의: 데이터 수정 시 skb_clone() + skb_ensure_writable() 사용 */
netif_rx(mirror);  /* 미러 포트로 전달 */

/* skb_dst_force: qdisc 큐잉 전 dst 참조 고정 */
/* RCU read-side에서 noref로 설정된 dst는 RCU 밖에서 무효화될 수 있음 */
skb_dst_force(skb);
__skb_queue_tail(&qdisc->q, skb);

/* skb_orphan: 소켓 메모리 즉시 반환이 필요한 경우 */
/* 예: TCP 전송 경로에서 qdisc 큐에 오래 대기하면 */
/*     sk_wmem_alloc이 sk_sndbuf에 도달하여 전송 차단 */
skb_orphan(skb);
/* → destructor(sock_wfree) 호출 → sk_wmem_alloc 감소 */
/* → 소켓이 새 데이터를 write 할 수 있게 됨 */

해시/메타데이터 조작 함수

skb에 연결된 패킷 해시, 큐 매핑, 리다이렉트 플래그 등 메타데이터를 조작하는 함수들입니다. RSS/RPS 스티어링, TC 분류, 멀티큐 NIC 큐 선택 등에 사용됩니다.

/* 드라이버에서 HW RSS 해시 설정 */
static void my_rx_handler(struct sk_buff *skb, u32 hw_hash)
{
    skb_set_hash(skb, hw_hash, PKT_HASH_TYPE_L4);
    skb_record_rx_queue(skb, rx_ring->queue_idx);
    napi_gro_receive(&rx_ring->napi, skb);
}

/* NAT 후 해시 무효화 (IP/포트가 변경됨) */
skb_clear_hash(skb);
/* 다음 skb_get_hash() 호출 시 flow dissector가 재계산 */

/* TC에서 특정 TX 큐로 스티어링 */
skb_set_queue_mapping(skb, target_queue);

/* XDP 리다이렉트 후 마킹 */
skb_set_redirected(skb, true);  /* from_ingress = true */

sk_buff 리스트/큐 관리

struct sk_buff_head는 spinlock을 내장한 이중 연결 리스트로, 소켓 수신/전송 큐, qdisc 큐, TCP 재전송 큐 등에서 skb를 관리하는 데 사용됩니다. lock이 필요한 함수(spinlock 기반)와 lock 없는 함수(__ 접두사)가 쌍으로 존재합니다.

/* sk_buff_head: 이중 연결 리스트의 head (sentinel) */
struct sk_buff_head {
    struct sk_buff *next;
    struct sk_buff *prev;
    __u32           qlen;   /* 큐 내 skb 수 */
    spinlock_t      lock;   /* 동시성 보호 */
};

초기화 및 추가/제거

조회 및 순회

일괄 처리 (splice/purge)

/* 초기화 */
struct sk_buff_head my_queue;
skb_queue_head_init(&my_queue);

/* 기본 enqueue/dequeue (FIFO) */
skb_queue_tail(&my_queue, skb);
struct sk_buff *s = skb_dequeue(&my_queue);

/* 큐 전체 순회 + 조건부 제거 */
struct sk_buff *skb, *tmp;
spin_lock(&my_queue.lock);
skb_queue_walk_safe(&my_queue, skb, tmp) {
    if (should_drop(skb)) {
        __skb_unlink(skb, &my_queue);
        kfree_skb(skb);
    }
}
spin_unlock(&my_queue.lock);

/* splice: NAPI poll에서 per-CPU 큐를 소켓 큐로 이동 */
struct sk_buff_head process_queue;
skb_queue_head_init(&process_queue);
spin_lock(&napi_queue.lock);
skb_queue_splice_tail_init(&napi_queue, &process_queue);
spin_unlock(&napi_queue.lock);
/* 이제 lock 없이 process_queue를 처리 */
while ((skb = __skb_dequeue(&process_queue)) != NULL)
    netif_receive_skb(skb);

/* 큐 비우기 (모듈 언로드, 소켓 닫기 시) */
skb_queue_purge(&my_queue);

소켓과 sk_buff의 관계

sk_buff의 sk 필드는 해당 패킷이 소속된 소켓(struct sock)을 가리킵니다. 이 연결은 소켓 메모리 계산, 소켓 옵션 적용, 프로토콜별 처리의 기반이 됩니다.

struct sock 계층 구조

커널 소켓은 3단계 계층으로 구성됩니다:

/* 소켓 구조체 계층 (간략) */
struct socket {              /* BSD 소켓 (사용자 공간 인터페이스) */
    socket_state             state;    /* SS_UNCONNECTED, SS_CONNECTED 등 */
    struct file             *file;     /* VFS file (fd와 연결) */
    struct sock             *sk;       /* 네트워크 레이어 소켓 */
    const struct proto_ops  *ops;      /* connect, sendmsg 등 */
};

struct sock {                /* 프로토콜 무관 공통 소켓 */
    struct sk_buff_head  sk_receive_queue; /* 수신 skb 큐 */
    struct sk_buff_head  sk_write_queue;   /* 전송 skb 큐 */
    struct sk_buff_head  sk_error_queue;   /* 에러 큐 (ICMP 등) */
    struct {
        struct sk_buff *head, *tail;
    }                    sk_backlog;       /* backlog 큐 (lock 중 수신) */

    atomic_t             sk_rmem_alloc;    /* 수신 큐 메모리 사용량 */
    atomic_t             sk_wmem_alloc;    /* 전송 큐 메모리 사용량 */
    int                  sk_rcvbuf;        /* SO_RCVBUF 값 */
    int                  sk_sndbuf;        /* SO_SNDBUF 값 */
    unsigned long        sk_flags;         /* 소켓 플래그 */
    struct proto        *sk_prot;          /* 프로토콜 핸들러 */
    void                (*sk_data_ready)(struct sock *sk);  /* 수신 알림 */
    /* ... */
};

/* 프로토콜별 확장 (임베디드 패턴) */
struct inet_sock {           /* IPv4/IPv6 공통 */
    struct sock      sk;           /* 공통 sock 내장 */
    __be32           inet_saddr;   /* 소스 IP */
    __be32           inet_daddr;   /* 목적지 IP */
    __be16           inet_sport;   /* 소스 포트 */
    __be16           inet_dport;   /* 목적지 포트 */
    __u8             tos;          /* IP_TOS 옵션 */
    __u8             min_ttl;      /* IP_MINTTL 옵션 */
    __s16            uc_ttl;       /* IP_TTL 옵션 (-1 = 기본값) */
    struct ip_options_rcu *inet_opt; /* IP 옵션 */
    /* ... */
};

struct tcp_sock {
    struct inet_connection_sock inet_conn; /* inet_sock ⊃ sock 내장 */
    u32  snd_una;      /* 가장 오래된 미확인 시퀀스 */
    u32  snd_nxt;      /* 다음 전송 시퀀스 */
    u32  rcv_nxt;      /* 다음 수신 기대 시퀀스 */
    u32  mss_cache;    /* MSS (최대 세그먼트 크기) */
    /* ... 수십 개 TCP 전용 필드 ... */
};

struct udp_sock {
    struct inet_sock  inet;
    int               pending;      /* cork 상태 */
    __u8              encap_type;   /* UDP encap (VXLAN 등) */
    /* ... */
};

/* 캐스팅 매크로 */
#define inet_sk(sk)  ((struct inet_sock *)(sk))
#define tcp_sk(sk)   ((struct tcp_sock *)(sk))
#define udp_sk(sk)   ((struct udp_sock *)(sk))

skb↔sk 바인딩과 소켓 메모리 관리(Memory Management)

skb->sk가 설정되면 해당 skb의 메모리 사용량이 소켓에 과금됩니다. 이 메커니즘이 SO_RCVBUF/SO_SNDBUF 제한을 실현합니다:

/* skb를 소켓에 연결 — 메모리 과금 시작 */
static inline void skb_set_owner_r(struct sk_buff *skb, struct sock *sk)
{
    skb->sk = sk;
    skb->destructor = sock_rfree;  /* 해제 시 콜백 */
    atomic_add(skb->truesize, &sk->sk_rmem_alloc);
    /* → 수신 큐 메모리 사용량에 truesize만큼 추가 */
}

static inline void skb_set_owner_w(struct sk_buff *skb, struct sock *sk)
{
    skb->sk = sk;
    skb->destructor = sock_wfree;  /* 해제 시 콜백 */
    refcount_add(skb->truesize, &sk->sk_wmem_alloc);
    /* → 전송 큐 메모리 사용량에 truesize만큼 추가 */
}

/* skb 해제 시: destructor 콜백이 메모리 차감 */
void sock_rfree(struct sk_buff *skb)
{
    struct sock *sk = skb->sk;
    atomic_sub(skb->truesize, &sk->sk_rmem_alloc);
    /* → 수신 큐 메모리 사용량에서 차감 */
}

/* 수신 큐 과부하 확인 — 소켓 버퍼 제한 */
static inline bool sk_rmem_schedule(struct sock *sk, struct sk_buff *skb, int size)
{
    /* sk_rmem_alloc + size > sk_rcvbuf 이면 false → 패킷 드롭 */
    return __sk_mem_schedule(sk, size, SK_MEM_RECV);
}

sk 참조 카운트(Reference Count)와 수명주기

skb->sk가 가리키는 소켓이 skb보다 먼저 해제되면 Use-After-Free가 발생합니다. 이를 방지하기 위해 커널은 참조 카운트 기반 수명주기 관리를 합니다. struct sock의 sk_refcnt가 0이 되어야 소켓이 실제로 해제됩니다.

/* include/net/sock.h — sk 참조 카운트 API */

/* 소켓 할당: sk_refcnt = 1로 시작 */
struct sock *sk_alloc(struct net *net, int family,
                      gfp_t priority, struct proto *prot, int kern)
{
    struct sock *sk = sk_prot_alloc(prot, priority, family);
    if (sk) {
        refcount_set(&sk->sk_refcnt, 1);
        /* net 참조, 프로토콜 핸들러 설정 등 */
        sock_net_set(sk, get_net(net));
        sk->sk_prot = prot;
    }
    return sk;
}

/* 참조 카운트 증가 — sk를 장기 보유할 때 호출 */
static inline void sock_hold(struct sock *sk)
{
    refcount_inc(&sk->sk_refcnt);
}

/* 참조 카운트 감소 — 0이면 sk_free() 호출 */
static inline void sock_put(struct sock *sk)
{
    if (refcount_dec_and_test(&sk->sk_refcnt))
        sk_free(sk);
}

/* 소켓 해제 체인 */
void sk_free(struct sock *sk)
{
    /* 1. sk->sk_destruct 콜백 호출 (프로토콜별 정리) */
    if (sk->sk_destruct)
        sk->sk_destruct(sk);

    /* 2. 필터(BPF) 해제 */
    sk_filter_uncharge(sk, sk->sk_filter);

    /* 3. net namespace 참조 해제 */
    put_net(sock_net(sk));

    /* 4. 프로토콜별 slab에서 메모리 반환 */
    sk_prot_free(sk->sk_prot, sk);
}

/* inet_sock_destruct: AF_INET 소켓의 sk_destruct 콜백 */
void inet_sock_destruct(struct sock *sk)
{
    /* 수신/전송/에러 큐의 잔여 skb 전부 해제 */
    __skb_queue_purge(&sk->sk_receive_queue);
    __skb_queue_purge(&sk->sk_write_queue);
    __skb_queue_purge(&sk->sk_error_queue);

    /* 메모리 추적 검증: 모든 skb가 해제된 후 0이어야 함 */
    WARN_ON(atomic_read(&sk->sk_rmem_alloc));
    WARN_ON(refcount_read(&sk->sk_wmem_alloc));
    WARN_ON(sk->sk_forward_alloc);

    /* IP 옵션, cork 등 해제 */
    kfree(rcu_dereference_protected(
        inet_sk(sk)->inet_opt, 1));
    /* dst_cache 해제 */
    dst_release(rcu_dereference_protected(
        sk->sk_dst_cache, 1));
}

skb_orphan과 소유권(Ownership) 전이

skb_orphan()은 skb와 소켓의 연결을 끊어 소유권을 해제합니다. 이 함수는 네트워크 스택의 여러 전환점에서 호출되며, 소켓 메모리 회계와 소켓 수명주기에 직접 영향을 미칩니다.

/* include/linux/skbuff.h — skb_orphan */
static inline void skb_orphan(struct sk_buff *skb)
{
    /* destructor가 있으면 호출 → 소켓 메모리 회계 정리 */
    if (skb->destructor) {
        skb->destructor(skb);  /* sock_wfree/sock_rfree 등 */
        skb->destructor = NULL;
    }
    skb->sk = NULL;            /* 소켓 참조 해제 */
}

/* skb_orphan_partial: TX 경로에서 wmem만 반환, sk 참조 유지 */
void skb_orphan_partial(struct sk_buff *skb)
{
    if (skb_is_tcp_pure_ack(skb))
        return;  /* pure ACK은 건드리지 않음 */

    if (skb->destructor) {
        /* 현재 destructor 호출 → wmem_alloc 차감 */
        skb->destructor(skb);
        /* sock_efree로 교체 → sk만 유지 (wmem 0) */
        skb->destructor = sock_efree;
        sock_hold(skb->sk);  /* sk 참조 유지 (refcnt++) */
    }
}

/* sock_efree: sk 참조만 해제 (메모리 회계 없음) */
void sock_efree(struct sk_buff *skb)
{
    sock_put(skb->sk);  /* refcnt-- → 0이면 sk_free */
}

/* 실제 사용 예: qdisc enqueue 시 orphan */
static inline int __dev_xmit_skb(struct sk_buff *skb,
                                   struct Qdisc *q, ...)
{
    /* sysctl net.core.skb_orphan_first = 1일 때 */
    if (READ_ONCE(netdev_budget_usecs))
        skb_orphan_partial(skb);
    /* → qdisc에 진입하면서 소켓 메모리 예산 즉시 반환
     *   이후 NIC 전송 완료까지 skb는 sk 없이(또는 efree 참조만으로) 존재 */
    return q->enqueue(skb, q, ...);
}

/* IP 포워딩 시 orphan */
int ip_forward(struct sk_buff *skb)
{
    /* 포워딩 패킷은 로컬 소켓과 무관 */
    skb_orphan(skb);  /* 완전 orphan */
    /* ... TTL 감소, checksum 재계산, 라우팅 ... */
    return ip_forward_finish(net, sk, skb);
}

skb->destructor 콜백(Callback) 상세

skb->destructor는 skb가 해제될 때 호출되는 콜백 함수 포인터로, 소켓 메모리 회계의 핵심입니다. 커널은 용도별로 다양한 destructor를 사용합니다:

/* net/core/sock.c — sock_wfree (전송 경로 destructor) */
void sock_wfree(struct sk_buff *skb)
{
    struct sock *sk = skb->sk;

    /* wmem_alloc에서 truesize 차감 */
    if (refcount_sub_and_test(skb->truesize, &sk->sk_wmem_alloc)) {
        /* wmem_alloc이 0이 되면 → 마지막 전송 skb 해제
         * → 대기 중인 송신자 wakeup 가능 */
    }

    /* 쓰기 공간이 확보되었음을 알림 */
    if (sock_flag(sk, SOCK_USE_WRITE_QUEUE)) {
        /* TCP: sk_write_space → tcp_write_space → epollout 트리거 */
    } else {
        sk->sk_write_space(sk);
    }
    sock_put(sk);  /* sk 참조 카운트 감소 */
}

/* net/ipv4/tcp_output.c — tcp_wfree (TCP 전용 destructor) */
void tcp_wfree(struct sk_buff *skb)
{
    struct sock *sk = skb->sk;
    struct tcp_sock *tp = tcp_sk(sk);
    unsigned long flags, nval, oval;

    /* TSQ (TCP Small Queue) 제어:
     * NIC 전송 완료 → tcp_wfree → 추가 세그먼트 전송 허용
     * → 지연시간 감소 (qdisc 큐에 과도한 패킷 축적 방지) */
    tcp_tsq_write(sk);

    /* wmem_alloc 차감 */
    refcount_sub(skb->truesize - 1, &sk->sk_wmem_alloc);
    sk->sk_tsq_flags |= TSQF_THROTTLED;
    sock_put(sk);
}

/* kfree_skb 호출 체인에서 destructor가 호출되는 위치 */
void __kfree_skb(struct sk_buff *skb)
{
    skb_release_all(skb);
    /* → skb_release_head_state(skb)
     *   → if (skb->destructor)
     *        skb->destructor(skb);   ← 여기서 호출!
     * → skb_release_data(skb)
     * → kfree_skbmem(skb) */
}

sk_forward_alloc과 메모리 예산(Memory Budget)

매 skb마다 __sk_mem_schedule()를 호출하면 atomic 연산 비용이 높습니다. 커널은 sk_forward_alloc이라는 선급 예산을 두어 소켓별로 한 번에 큰 단위로 메모리를 할당받고, skb 단위에서는 이 예산에서 차감하는 방식으로 최적화합니다.

/* net/core/sock.c — __sk_mem_schedule */
int __sk_mem_schedule(struct sock *sk, int size, int kind)
{
    int amt = sk_mem_pages(size);
    /* size를 페이지 단위로 올림:
     * sk_mem_pages(size) = (size + PAGE_SIZE - 1) >> PAGE_SHIFT */

    sk->sk_forward_alloc += amt * SK_MEM_QUANTUM;
    /* SK_MEM_QUANTUM = PAGE_SIZE = 4096 (일반적)
     * → 한 번 충전에 최소 4KB 예산 확보 */

    /* 전역 프로토콜 메모리에서 차감 */
    atomic_long_add(amt, sk->sk_prot->memory_allocated);

    /* 메모리 압력 상태 확인 */
    if (mem_cgroup_sockets_enabled && sk->sk_memcg) {
        /* cgroup v2: cgroup 단위 메모리 제한도 적용 */
        if (!mem_cgroup_charge_skmem(sk->sk_memcg, amt,
                                     sk->sk_prot->memory_pressure))
            goto suppress;
    }

    /* tcp_mem[0] (low), tcp_mem[1] (pressure), tcp_mem[2] (high) */
    if (atomic_long_read(sk->sk_prot->memory_allocated) >
        sk->sk_prot->sysctl_mem[2]) {
        /* high 초과 → 거부 (새 skb 할당 실패) */
        sk->sk_prot->enter_memory_pressure(sk);
        goto suppress;
    }
    return 1;  /* 성공 */

suppress:
    /* 예산 롤백 */
    sk->sk_forward_alloc -= amt * SK_MEM_QUANTUM;
    atomic_long_sub(amt, sk->sk_prot->memory_allocated);
    return 0;  /* 실패 → 호출자가 패킷 드롭 */
}

/* sk_mem_reclaim: 잔여 예산을 전역 풀에 반환 */
void sk_mem_reclaim(struct sock *sk)
{
    if (sk->sk_forward_alloc >= SK_MEM_QUANTUM) {
        /* 사용하지 않는 예산을 전역에 반환 → 다른 소켓이 사용 */
        __sk_mem_reclaim(sk, sk->sk_forward_alloc - 1);
    }
}

/* 수신 경로에서의 예산 소비 예시 */
static int tcp_try_rmem_schedule(struct sock *sk, struct sk_buff *skb,
                                unsigned int size)
{
    if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf) {
        /* SO_RCVBUF 초과 → OOM 경로 */
        tcp_try_coalesce(sk, skb, ...);  /* 병합 시도 */
        if (...)
            goto drop;
    }
    if (!sk_rmem_schedule(sk, skb, size)) {
        /* sk_forward_alloc 부족 + __sk_mem_schedule 실패
         * → 메모리 압력 상태: pruning (OOO 큐 정리) 시도 */
        tcp_prune_ofo_queue(sk);
        if (!sk_rmem_schedule(sk, skb, size))
            goto drop;
    }
    return 0;
drop:
    /* → TCPRcvQDrop 카운터 증가 → /proc/net/snmp */
    return -1;
}

소켓 메모리 압력(Memory Pressure) 시스템

커널은 프로토콜별로 전역 메모리 압력 상태를 관리합니다. TCP, UDP 등 각 프로토콜은 memory_allocated와 sysctl_mem[] 임계값으로 시스템 전체의 소켓 메모리를 제어합니다.

/* include/net/sock.h — 프로토콜별 메모리 관리 구조체 */
struct proto {
    /* ... */
    atomic_long_t   *memory_allocated;   /* 프로토콜 전체 할당 페이지 수 */
    int             *memory_pressure;    /* 압력 상태 플래그 (0 or 1) */
    long            *sysctl_mem;         /* [low, pressure, high] 배열 */
    int             *sysctl_rmem;        /* [min, default, max] 수신 */
    int             *sysctl_wmem;        /* [min, default, max] 전송 */
    /* ... */
};

/* TCP 프로토콜의 메모리 관련 전역 변수 */
atomic_long_t tcp_memory_allocated;  /* TCP 전체 메모리 (페이지 단위) */
int tcp_memory_pressure;              /* TCP 압력 플래그 */
long sysctl_tcp_mem[3];              /* 부팅 시 자동 계산 */

/* tcp_init_mem: tcp_mem 자동 계산 (부팅 시) */
void tcp_init_mem(void)
{
    unsigned long limit = nr_free_buffer_pages() / 8;
    limit = max(limit, 128UL);
    sysctl_tcp_mem[0] = limit * 3 / 4;   /* low: 전체의 3/32 */
    sysctl_tcp_mem[1] = limit;             /* pressure: 전체의 1/8 */
    sysctl_tcp_mem[2] = limit * 3 / 2;   /* high: 전체의 3/16 */
}

/* sk_under_memory_pressure: 프로토콜 압력 확인 */
static inline bool sk_under_memory_pressure(const struct sock *sk)
{
    /* cgroup 메모리 제한도 고려 */
    if (mem_cgroup_sockets_enabled && sk->sk_memcg &&
        mem_cgroup_under_socket_pressure(sk->sk_memcg))
        return true;
    return !!*sk->sk_prot->memory_pressure;
}

/* tcp_enter_memory_pressure: 압력 상태 진입 */
void tcp_enter_memory_pressure(struct sock *sk)
{
    unsigned long val;

    if (READ_ONCE(tcp_memory_pressure))
        return;
    WRITE_ONCE(tcp_memory_pressure, 1);
    /* → /proc/net/sockstat의 "TCP: ... pressure 1"로 확인 가능 */
}

/* tcp_leave_memory_pressure: 압력 상태 해제 */
void tcp_leave_memory_pressure(struct sock *sk)
{
    unsigned long val;

    if (!READ_ONCE(tcp_memory_pressure))
        return;
    if (atomic_long_read(&tcp_memory_allocated) <
        sysctl_tcp_mem[0])
        WRITE_ONCE(tcp_memory_pressure, 0);
}

# 소켓 메모리 압력 상태 모니터링

# TCP 메모리 사용량과 압력 상태 확인
cat /proc/net/sockstat
# sockets: used 1024
# TCP: inuse 80 orphan 2 tw 15 alloc 85 mem 1520   ← mem = 페이지
# UDP: inuse 12 mem 3
# → mem * PAGE_SIZE = 실제 바이트 (1520 * 4096 ≈ 6.2MB)

# TCP 메모리 임계값 확인/조정 (페이지 단위)
cat /proc/sys/net/ipv4/tcp_mem
# 191232  254976  382464   ← low  pressure  high
# → 750MB  1000MB  1500MB (4KB 페이지 기준)

# UDP 메모리 임계값
cat /proc/sys/net/ipv4/udp_mem
# 191232  254976  382464

# 소켓별 메모리 사용량 확인 (ss)
ss -tm
# ESTAB  0  0  192.168.1.1:80  10.0.0.1:12345
#   skmem:(r0,rb1048576,t0,tb2626560,f0,w0,o0,bl0,d0)
#   r=rmem_alloc  rb=rcvbuf  t=wmem_alloc  tb=sndbuf
#   f=forward_alloc  w=wmem_queued  o=opt_mem  bl=backlog  d=drop

# TCP 압력 상태 실시간 추적
watch -n1 'grep "TCP:" /proc/net/sockstat'

소켓 잠금(Lock)과 backlog 처리

소켓의 수신 큐에 skb를 넣으려면 소켓 잠금이 필요합니다. 사용자 프로세스가 recvmsg() 중이라 소켓을 잠그고 있을 때, softirq에서 도착한 패킷은 backlog 큐에 임시 저장됩니다. release_sock() 시점에 backlog이 한꺼번에 처리됩니다.

/* include/net/sock.h — 소켓 잠금 관련 구조와 API */
struct sock {
    /* socket_lock_t sk_lock: 소켓 잠금 */
    struct {
        spinlock_t  slock;     /* softirq 보호용 스핀록 */
        int         owned;     /* 1 = 프로세스가 소유 중 */
        wait_queue_head_t wq;  /* lock 대기 큐 */
    } sk_lock;

    /* backlog 큐 */
    struct {
        atomic_t         rmem_alloc;  /* backlog skb 메모리 */
        int              len;         /* backlog 총 길이 */
        struct sk_buff  *head, *tail; /* backlog 리스트 */
    } sk_backlog;

    /* backlog 처리 콜백 (프로토콜별) */
    int (*sk_backlog_rcv)(struct sock *sk, struct sk_buff *skb);
    /* TCP: tcp_v4_do_rcv
     * UDP: __udp_queue_rcv_skb */
};

/* lock_sock: 프로세스 컨텍스트에서 소켓 잠금 */
void lock_sock(struct sock *sk)
{
    lock_sock_nested(sk, 0);
    /* 1. spin_lock_bh(&sk->sk_lock.slock)  — BH 비활성화
     * 2. sk->sk_lock.owned = 1           — 소유 표시
     * 3. spin_unlock_bh(&sk->sk_lock.slock)
     * → 이후 softirq는 owned=1을 보고 backlog 사용 */
}

/* release_sock: 소켓 잠금 해제 + backlog 처리 */
void release_sock(struct sock *sk)
{
    spin_lock_bh(&sk->sk_lock.slock);
    if (sk->sk_backlog.tail) {
        __release_sock(sk);  /* backlog 소진 */
    }
    sk->sk_lock.owned = 0;
    if (waitqueue_active(&sk->sk_lock.wq))
        wake_up(&sk->sk_lock.wq);
    spin_unlock_bh(&sk->sk_lock.slock);
}

/* __release_sock: backlog 큐의 모든 skb 처리 */
static void __release_sock(struct sock *sk)
{
    struct sk_buff *skb, *next;

    while ((skb = sk->sk_backlog.head) != NULL) {
        sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
        spin_unlock_bh(&sk->sk_lock.slock);

        do {
            next = skb->next;
            skb->next = NULL;
            /* 프로토콜별 수신 처리 */
            sk->sk_backlog_rcv(sk, skb);
            /* TCP: tcp_v4_do_rcv() → ACK 처리, 데이터 큐잉 */
            skb = next;
        } while (skb != NULL);

        spin_lock_bh(&sk->sk_lock.slock);
        /* 처리 중 새 backlog이 쌓였을 수 있음 → while 반복 */
    }
}

/* __sk_add_backlog: softirq에서 backlog에 skb 추가 */
static inline int __sk_add_backlog(struct sock *sk, struct sk_buff *skb)
{
    /* backlog 크기 제한 확인 */
    if (sk->sk_backlog.len >= sk_rcvqueues_full(sk))
        return -ENOBUFS;  /* → 패킷 드롭 */

    /* 리스트에 추가 */
    if (!sk->sk_backlog.tail)
        sk->sk_backlog.head = skb;
    else
        sk->sk_backlog.tail->next = skb;
    sk->sk_backlog.tail = skb;
    sk->sk_backlog.len += skb->truesize;
    return 0;
}

TCP 소켓 버퍼 자동 튜닝(Autotuning)

사용자가 SO_RCVBUF를 명시적으로 설정하지 않으면, TCP는 네트워크 조건에 따라 수신 버퍼를 자동으로 조절합니다. 이를 autotuning이라 하며 tcp_moderate_rcvbuf sysctl로 제어합니다.

/* net/ipv4/tcp_input.c — tcp_rcv_space_adjust */
void tcp_rcv_space_adjust(struct sock *sk)
{
    struct tcp_sock *tp = tcp_sk(sk);
    u32 time, space;

    /* SOCK_RCVBUF_LOCK: 사용자가 SO_RCVBUF 설정 → autotuning 중단 */
    if (sock_flag(sk, SOCK_RCVBUF_LOCK))
        return;

    /* 최근 수신 처리량 측정 (bytes/time) */
    time = tcp_jiffies32 - tp->rcvq_space.time;
    if (time < (tp->rcv_rtt_est.rtt_us >> 3) || tp->rcv_rtt_est.rtt_us == 0)
        return;

    /* 수신 공간 필요량 계산:
     * space = 수신 처리량 × 2 (BDP의 2배 여유) */
    space = tp->rcvq_space.space * 2;

    /* sk_rcvbuf 상한: tcp_rmem[2] (기본 6MB) */
    space = min(space, tcp_space_from_win(tp,
                READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_rmem[2])));

    if (space > sk->sk_rcvbuf) {
        /* 수신 버퍼 확장 */
        WRITE_ONCE(sk->sk_rcvbuf, space);
        /* → 더 큰 수신 윈도우를 상대에게 광고
         * → throughput 향상 (특히 고지연 네트워크) */
    }

    tp->rcvq_space.space = tp->copied_seq - tp->rcvq_space.seq;
    tp->rcvq_space.seq = tp->copied_seq;
    tp->rcvq_space.time = tcp_jiffies32;
}

/* 전송 측 autotuning: sk_sndbuf도 유사하게 동적 조절 */
/* tcp_sndbuf_expand() — TCP pacing과 연동 */
void tcp_sndbuf_expand(struct sock *sk)
{
    if (sock_flag(sk, SOCK_SNDBUF_LOCK))
        return;  /* SO_SNDBUF 설정 시 중단 */

    /* sk_pacing_rate 기반 전송 버퍼 크기 계산 */
    int sndmem = SKB_TRUESIZE(tp->mss_cache) *
                max_t(int, tp->snd_cwnd, tp->reordering + 1);
    sndmem *= 2;  /* 여유 계수 */

    if (sndmem > sk->sk_sndbuf)
        WRITE_ONCE(sk->sk_sndbuf,
                   min(sndmem,
                       READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_wmem[2])));
}

# TCP 자동 튜닝 관련 sysctl

# 자동 튜닝 활성화/비활성화 (기본값: 1)
sysctl net.ipv4.tcp_moderate_rcvbuf
# 1 = 자동 튜닝 활성 (권장)
# 0 = 비활성 → tcp_rmem[1](default)로 고정

# TCP 수신 버퍼 범위 (바이트 단위)
sysctl net.ipv4.tcp_rmem
# 4096  131072  6291456
#  ↑min   ↑default  ↑max (autotuning 상한)
# min: 메모리 압력 시 최소 보장
# default: 새 소켓 초기값
# max: autotuning이 확장 가능한 최대값

# TCP 전송 버퍼 범위 (바이트 단위)
sysctl net.ipv4.tcp_wmem
# 4096  16384  4194304

# 특정 소켓의 autotuning 상태 확인
ss -tmi dst 10.0.0.1
# skmem:(r4096,rb1048576,...,f262144,...)
# rb = sk_rcvbuf (autotuning 결과 값)
# f  = sk_forward_alloc (잔여 예산)

# 고대역폭 장거리 네트워크 (10Gbps, 50ms RTT)에서 최적 설정
# BDP = 10Gbps × 50ms = 62.5MB → tcp_rmem max를 이 이상으로
sysctl -w net.ipv4.tcp_rmem="4096 131072 67108864"   # max 64MB
sysctl -w net.ipv4.tcp_wmem="4096 16384 67108864"    # max 64MB

sk_clone_lock — TCP accept 시 소켓 복제(Clone)

TCP 서버가 accept()를 호출하면, 리스닝(listening) 소켓의 설정을 상속받은 새 소켓이 생성됩니다. 커널은 sk_clone_lock()으로 리스닝 소켓을 복제하여 연결별 소켓을 만듭니다.

/* net/core/sock.c — sk_clone_lock */
struct sock *sk_clone_lock(const struct sock *sk, const gfp_t priority)
{
    struct proto *prot = READ_ONCE(sk->sk_prot);
    struct sock *newsk;

    /* 프로토콜 slab에서 새 소켓 할당 */
    newsk = sk_prot_alloc(prot, priority, sk->sk_family);
    if (!newsk)
        return NULL;

    /* 원본 소켓 전체를 메모리 복사 (shallow copy) */
    sock_copy(newsk, sk);
    /* → sk_rcvbuf, sk_sndbuf, sk_priority, sk_mark 등 상속 */

    /* 복제된 소켓의 고유 필드 초기화 */
    refcount_set(&newsk->sk_refcnt, 2);
    /* refcnt=2: 1(소켓 자체) + 1(caller 참조) */

    /* 큐 초기화 (원본의 큐를 공유하면 안 됨) */
    skb_queue_head_init(&newsk->sk_receive_queue);
    skb_queue_head_init(&newsk->sk_write_queue);
    skb_queue_head_init(&newsk->sk_error_queue);

    /* 메모리 회계 초기화 */
    atomic_set(&newsk->sk_rmem_alloc, 0);
    refcount_set(&newsk->sk_wmem_alloc, 1);
    /* wmem_alloc=1: "sentinel" — 0이 되기 전까지 해제 방지
     * → sock_put() 호출 시 __sk_free 대신 대기 */

    newsk->sk_forward_alloc = 0;
    newsk->sk_backlog.head = newsk->sk_backlog.tail = NULL;
    newsk->sk_backlog.len = 0;

    /* BPF 필터 상속 */
    if (sk->sk_filter) {
        sk_filter_charge(newsk, sk->sk_filter);
        /* BPF 프로그램 참조 카운트 증가 */
    }

    /* net namespace 참조 */
    get_net(sock_net(newsk));

    /* dst_cache (라우팅 캐시) 초기화 */
    sk_dst_reset(newsk);

    /* 잠금은 caller가 해제 */
    bh_lock_sock(newsk);
    return newsk;
}

/* TCP accept 경로 요약:
 * inet_csk_accept()
 *   → reqsk_queue_remove() — SYN 큐에서 완성된 연결 가져옴
 *   → newsk = listen_sk→clone(listen_sk)
 *     → inet_csk_clone_lock()
 *       → sk_clone_lock()
 *       → inet_sk_set_state(newsk, TCP_SYN_RECV → TCP_ESTABLISHED)
 *   → 새 소켓의 fd 생성 → 사용자 공간 반환 */

/* TCP 3-way handshake에서 소켓 복제 시점 */
/*
 * [Client]          [Server listen_sk]
 *   SYN →           → tcp_conn_request()
 *                     → request_sock 할당 (경량)
 *   ← SYN+ACK       ← tcp_v4_send_synack()
 *   ACK →           → tcp_check_req()
 *                     → tcp_v4_syn_recv_sock()
 *                       → sk_clone_lock(listen_sk)  ← 여기서 복제!
 *                       → inet_csk_clone_lock()
 *                       → tcp_create_openreq_child()
 *                       → 새 소켓 완성
 *                     → inet_csk_complete_hashdance()
 *   accept() →       → inet_csk_accept()
 *                       → 완성된 소켓 반환
 */

소켓 BPF 필터와 skb

사용자 공간에서 SO_ATTACH_FILTER 또는 SO_ATTACH_BPF로 부착한 BPF 프로그램은 skb가 소켓 수신 큐에 들어가기 전에 실행됩니다. 이 필터는 sk->sk_filter에 저장되며, sk_filter_trim_cap()에서 호출됩니다:

/* include/linux/filter.h — sk_filter 구조 */
struct sk_filter {
    refcount_t          refcnt;     /* 참조 카운트 (clone 시 공유) */
    struct rcu_head     rcu;
    struct bpf_prog    *prog;      /* JIT 컴파일된 BPF 프로그램 */
};

/* net/core/filter.c — sk_filter_trim_cap */
int sk_filter_trim_cap(struct sock *sk, struct sk_buff *skb,
                      unsigned int cap)
{
    struct sk_filter *filter;
    int err;

    /* security_sock_rcv_skb: LSM (SELinux 등) 검사 */
    err = security_sock_rcv_skb(sk, skb);
    if (err)
        return err;

    /* BPF 필터 실행 */
    filter = rcu_dereference(sk->sk_filter);
    if (filter) {
        struct sock *save_sk = skb->sk;
        unsigned int pkt_len;

        skb->sk = sk;  /* BPF가 소켓 정보 접근할 수 있게 */
        pkt_len = bpf_prog_run_save_cb(filter->prog, skb);
        skb->sk = save_sk;

        /* pkt_len=0 → 패킷 드롭
         * pkt_len>0 → skb->len을 pkt_len으로 트림(trim) */
        err = pkt_len ? pskb_trim(skb, max(cap, pkt_len)) : -EPERM;
    }
    return err;
}

/* 호출 위치 예시 */
/* TCP: tcp_v4_do_rcv() → tcp_filter() → sk_filter_trim_cap()
 * UDP: __udp_queue_rcv_skb() → sk_filter_trim_cap()
 * Raw: raw_rcv() → raw_rcv_skb() → sk_filter_trim_cap() */

/* 사용자 공간에서 필터 부착 */
struct sock_fprog bpf = {
    .len = ARRAY_SIZE(code),
    .filter = code,
};
setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &bpf, sizeof(bpf));
/* → sock_attach_prog() → sk->sk_filter 설정
 * → 이후 모든 수신 skb가 이 필터를 통과해야 소켓 큐 진입 */

소켓 옵션(setsockopt)과 sk_buff

사용자 공간(User Space)의 setsockopt() 호출은 struct sock 필드를 변경하고, 이것이 skb 생성·처리에 직접 반영됩니다:

/* 전송 경로에서 sock 옵션 → skb 필드 복사 과정 */
static void ip_copy_addrs(struct iphdr *iph, const struct flowi4 *fl4)
{
    /* flowi4는 routing lookup 입력: sock의 IP/포트에서 구성 */
    iph->saddr = fl4->saddr;
    iph->daddr = fl4->daddr;
}

/* ip_queue_xmit: TCP 전송 시 sock 옵션 적용 */
int __ip_queue_xmit(struct sock *sk, struct sk_buff *skb, ...)
{
    struct inet_sock *inet = inet_sk(sk);

    /* SK 옵션 → skb 필드 전파 */
    skb->priority = sk->sk_priority;    /* SO_PRIORITY */
    skb->mark = sk->sk_mark;            /* SO_MARK */

    /* IP 헤더 필드: inet_sock에서 가져옴 */
    iph->tos = inet->tos;               /* IP_TOS */
    iph->ttl = ip_select_ttl(inet, ...); /* IP_TTL 또는 기본값 */
    /* ... */
}

/* SO_RCVBUF 설정과 수신 큐 제한의 관계 */
/* 사용자 공간 */
int bufsize = 262144;  /* 256KB */
setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &bufsize, sizeof(bufsize));
/* 커널: sk->sk_rcvbuf = min(bufsize * 2, sysctl_rmem_max)
 *       → 실제 커널 값은 요청값의 2배 (overhead 고려)
 *
 * 수신 시: atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf 이면
 *          → 새 패킷 드롭 (ENOMEM) */

Raw Socket과 sk_buff

Raw socket(SOCK_RAW)은 프로토콜 스택의 일부를 우회하여 직접 패킷을 구성하거나 수신합니다. 일반 SOCK_STREAM/SOCK_DGRAM과 달리 커널의 L4 프로토콜 처리를 거치지 않고 skb를 직접 다루므로, 네트워크 도구(ping, traceroute, tcpdump, nmap 등)와 프로토콜 구현의 핵심입니다.

Raw Socket 타입 비교

Raw Socket 권한 모델

Raw socket 생성에는 CAP_NET_RAW capability가 필요합니다. 커널은 sock_create() → inet_create() 경로에서 capability를 검사합니다:

/* net/ipv4/af_inet.c — inet_create() */
static int inet_create(struct net *net, struct socket *sock,
                       int protocol, int kern)
{
    struct inet_protosw *answer;
    struct sock *sk;

    /* SOCK_RAW 사용 시 CAP_NET_RAW 검사 */
    if (sock->type == SOCK_RAW && !kern &&
        !ns_capable(net->user_ns, CAP_NET_RAW))
        return -EPERM;

    /* protocol 번호로 inetsw[] 해시 테이블에서 프로토콜 핸들러 검색 */
    answer = inet_protosw_lookup(sock->type, protocol);
    /* SOCK_RAW → raw_prot (net/ipv4/raw.c)
     * SOCK_STREAM → tcp_prot
     * SOCK_DGRAM → udp_prot */

    sk = sk_alloc(net, PF_INET, GFP_KERNEL, answer->prot, kern);
    /* ... */
}

/* net/packet/af_packet.c — AF_PACKET도 CAP_NET_RAW 필요 */
static int packet_create(struct net *net, struct socket *sock,
                        int protocol, int kern)
{
    if (!kern && !ns_capable(net->user_ns, CAP_NET_RAW))
        return -EPERM;
    /* ... */
}

커널 내부 자료구조 — struct raw_sock

/* include/net/raw.h */
struct raw_sock {
    struct inet_sock  inet;       /* inet_sock 상속 (→ sock → sock_common) */
    struct icmp_filter filter;    /* ICMP 타입별 필터 비트맵 */
    u32               ipmr_table; /* 멀티캐스트 라우팅 테이블 ID */
};

/* raw socket 프로토콜 해시 테이블
 * protocol 번호로 해싱하여 수신 시 O(1) 조회 */
struct raw_hashinfo {
    spinlock_t           lock;
    struct hlist_head    ht[RAW_HTABLE_SIZE]; /* 256 버킷 */
};

/* 전역 raw 해시 테이블 — 모든 AF_INET SOCK_RAW 소켓 관리 */
struct raw_hashinfo raw_v4_hashinfo;  /* IPv4 */
struct raw_hashinfo raw_v6_hashinfo;  /* IPv6 */

/* 해시 함수: protocol 번호를 버킷 인덱스로 변환 */
static inline u32 raw_hashfunc(const struct net *net, u32 proto)
{
    return proto & (RAW_HTABLE_SIZE - 1); /* 0~255 */
}

/* raw socket의 프로토콜 연산 테이블 */
struct proto raw_prot = {
    .name       = "RAW",
    .owner      = THIS_MODULE,
    .close      = raw_close,
    .connect    = ip4_datagram_connect,
    .sendmsg    = raw_sendmsg,
    .recvmsg    = raw_recvmsg,
    .bind       = raw_bind,
    .hash       = raw_hash_sk,
    .unhash     = raw_unhash_sk,
    .obj_size   = sizeof(struct raw_sock),
};

AF_INET SOCK_RAW 수신 경로

IP 계층에서 패킷이 로컬로 배달될 때, TCP/UDP 디먹싱 이전에 raw socket으로의 복제가 먼저 수행됩니다. 즉, raw socket은 패킷의 사본을 받으며, 원본 skb는 정상 프로토콜 스택으로 계속 진행합니다:

/* net/ipv4/ip_input.c — ip_local_deliver_finish()
 * 패킷이 로컬 배달될 때 raw socket에 먼저 전달 */
static int ip_local_deliver_finish(struct net *net, struct sock *sk,
                                  struct sk_buff *skb)
{
    __skb_pull(skb, skb_network_header_len(skb));

    int protocol = ip_hdr(skb)->protocol;
    const struct net_protocol *ipprot;

    /* ① raw socket이 있으면 먼저 skb 사본 전달 */
    raw_local_deliver(skb, protocol);

    /* ② 등록된 프로토콜 핸들러 호출 (tcp_v4_rcv, udp_rcv 등) */
    ipprot = rcu_dereference(inet_protos[protocol]);
    if (ipprot) {
        ret = INDIRECT_CALL_2(ipprot->handler, tcp_v4_rcv, udp_rcv,
                              skb);
    }
}

/* net/ipv4/raw.c — raw_local_deliver()
 * 해당 프로토콜의 raw socket들을 해시 테이블에서 찾아 전달 */
int raw_local_deliver(struct sk_buff *skb, int protocol)
{
    struct raw_hashinfo *h = &raw_v4_hashinfo;
    struct hlist_head *head;
    int hash;

    hash = raw_hashfunc(dev_net(skb_dst(skb)->dev), protocol);
    head = &h->ht[hash];

    if (!hlist_empty(head)) {
        /* 매칭되는 모든 raw socket에 skb 복제본 전달 */
        raw_v4_input(skb, ip_hdr(skb), hash);
    }
    return 0;
}

/* net/ipv4/raw.c — raw_v4_input()
 * 프로토콜 번호와 목적지 주소가 매칭되는 모든 raw socket에 전달 */
static int raw_v4_input(struct sk_buff *skb, const struct iphdr *iph,
                       int hash)
{
    struct sock *sk;
    struct hlist_head *head = &raw_v4_hashinfo.ht[hash];
    int delivered = 0;

    rcu_read_lock();
    sk_for_each_rcu(sk, head) {
        /* 프로토콜 번호, 목적지 IP, 소스 IP, 네트워크 네임스페이스 매칭 */
        if (raw_v4_match(net, sk, iph->protocol,
                         iph->saddr, iph->daddr,
                         skb->dev->ifindex, sdif)) {
            /* skb를 clone하여 해당 raw socket에 전달 */
            raw_rcv(sk, skb);
            delivered++;
        }
    }
    rcu_read_unlock();
    return delivered;
}

/* net/ipv4/raw.c — raw_rcv()
 * skb clone → IP 헤더 포함한 상태로 수신 큐에 추가 */
int raw_rcv(struct sock *sk, struct sk_buff *skb)
{
    struct raw_sock *rp = raw_sk(sk);

    /* ICMP 필터 적용: 관심 없는 ICMP 타입은 드롭 */
    if (sk->sk_protocol == IPPROTO_ICMP) {
        struct icmphdr *icmph = icmp_hdr(skb);
        if (raw_icmp_type_filtered(rp, icmph->type))
            return 0; /* 필터에 의해 드롭 */
    }

    /* skb 복제: 원본은 프로토콜 스택이 계속 사용 */
    struct sk_buff *clone = skb_clone(skb, GFP_ATOMIC);
    if (!clone)
        return 0;

    /* 핵심: data 포인터를 network_header (IP 헤더) 위치로 복원
     * ip_local_deliver_finish()에서 __skb_pull로 L4까지 당겼으므로
     * raw socket은 IP 헤더부터 보여줘야 함 */
    skb_push(clone, clone->data - skb_network_header(clone));

    /* 수신 큐에 추가 → recvmsg()로 사용자에게 전달 */
    if (sock_queue_rcv_skb(sk, clone) < 0)
        kfree_skb(clone);

    return 0;
}

AF_INET SOCK_RAW 전송 경로

Raw socket의 전송 경로는 IP_HDRINCL 옵션에 따라 두 가지로 분기됩니다:

/* net/ipv4/raw.c — raw_sendmsg()
 * 사용자 공간의 sendto()/sendmsg() → raw_sendmsg() */
static int raw_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
{
    struct inet_sock *inet = inet_sk(sk);
    struct flowi4 fl4;
    struct rtable *rt;
    int err;

    /* 목적지 주소 결정 */
    struct sockaddr_in *usin = (struct sockaddr_in *)msg->msg_name;
    __be32 daddr;

    if (usin) {
        daddr = usin->sin_addr.s_addr;
    } else {
        /* connect()로 미리 바인딩된 주소 사용 */
        daddr = inet->inet_daddr;
        if (!daddr)
            return -EDESTADDRREQ;
    }

    /* 라우팅 테이블 조회 */
    flowi4_init_output(&fl4, ...);
    rt = ip_route_output_flow(net, &fl4, sk);

    if (inet->hdrincl) {
        /* ── IP_HDRINCL 모드 ──
         * 사용자가 IP 헤더를 직접 작성
         * 커널은 최소한의 필드만 보정 */
        err = raw_send_hdrinc(sk, &fl4, msg, len, &rt, msg->msg_flags);
    } else {
        /* ── 일반 raw 모드 ──
         * 커널이 IP 헤더를 자동 생성
         * 사용자 데이터는 L4 페이로드로 취급 */
        err = ip_append_data(sk, &fl4, raw_getfrag,
                             msg, len, 0, &ipc, &rt, msg->msg_flags);
        if (!err) {
            err = ip_push_pending_frames(sk, &fl4);
            /* → ip_output() → dev_queue_xmit() */
        }
    }
    ip_rt_put(rt);
    return err;
}

IP_HDRINCL 상세 — 커널의 보정 동작

IP_HDRINCL을 설정하면 사용자가 IP 헤더를 직접 작성하지만, 커널은 안전성과 정확성을 위해 일부 필드를 자동 보정합니다:

/* net/ipv4/raw.c — raw_send_hdrinc()
 * IP_HDRINCL 모드의 실제 전송 처리 */
static int raw_send_hdrinc(struct sock *sk, struct flowi4 *fl4,
                          struct msghdr *msg, unsigned int len,
                          struct rtable **rtp, unsigned int flags)
{
    struct iphdr *iph;
    struct sk_buff *skb;
    unsigned int iphlen;

    /* skb 할당: IP 헤더 + 페이로드 크기 */
    skb = sock_alloc_send_skb(sk,
        len + LL_ALLOCATED_SPACE(rt->dst.dev), /* L2 headroom 확보 */
        flags & MSG_DONTWAIT, &err);
    if (!skb)
        return err;

    /* L2 헤더 공간 예약 */
    skb_reserve(skb, LL_RESERVED_SPACE(rt->dst.dev));
    skb->protocol = htons(ETH_P_IP);

    /* 사용자 데이터를 skb에 복사 (IP 헤더 포함) */
    skb_put(skb, len);
    skb->network_header = skb->data;
    skb_copy_datagram_from_iter(skb, 0, &msg->msg_iter, len);

    iph = ip_hdr(skb);

    /* ── 커널이 자동 보정하는 필드 ── */

    /* (1) tot_len: 0이면 커널이 skb->len으로 설정 */
    if (!iph->tot_len)
        iph->tot_len = htons(len);

    /* (2) saddr: 0이면 라우팅 결과의 소스 IP로 채움 */
    if (!iph->saddr)
        iph->saddr = fl4->saddr;

    /* (3) id: 0이면 커널이 고유 ID 할당 */
    if (!iph->id)
        ip_select_ident(net, skb, NULL);

    /* (4) check: 항상 커널이 재계산 (사용자 값 무시) */
    iph->check = 0;
    iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);

    /* Netfilter OUTPUT 체인 통과 후 전송 */
    err = NF_HOOK(NFPROTO_IPV4, NF_INET_LOCAL_OUT,
                  net, sk, skb, NULL, rt->dst.dev,
                  dst_output);
    return err;
}

raw_recvmsg() — 사용자 공간으로 전달

/* net/ipv4/raw.c — raw_recvmsg()
 * 사용자의 recvfrom()/recvmsg() 처리 */
static int raw_recvmsg(struct sock *sk, struct msghdr *msg,
                      size_t len, int flags, int *addr_len)
{
    struct sk_buff *skb;
    struct sockaddr_in *sin = (struct sockaddr_in *)msg->msg_name;
    int err, copied;

    /* 수신 큐에서 skb 꺼내기 (대기 가능) */
    skb = skb_recv_datagram(sk, flags, &err);
    if (!skb)
        return err;

    /* skb에서 사용자 버퍼로 데이터 복사
     * → IP 헤더부터 전체 패킷이 사용자에게 전달됨 */
    copied = skb->len;
    if (len < copied) {
        msg->msg_flags |= MSG_TRUNC; /* 잘림 알림 */
        copied = len;
    }
    skb_copy_datagram_msg(skb, 0, msg, copied);

    /* 소스 주소 정보 채우기 */
    if (sin) {
        sin->sin_family = AF_INET;
        sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
        sin->sin_port = 0; /* raw socket은 포트 개념 없음 */
    }

    /* IP_PKTINFO, IP_TTL 등 ancillary data (cmsg) 전달 */
    if (inet_cmsg_flags(inet))
        ip_cmsg_recv(msg, skb);

    skb_free_datagram(sk, skb);
    return copied;
}

ICMP 필터 (ICMP_FILTER)

IPPROTO_ICMP raw socket에서 관심 있는 ICMP 타입만 수신하도록 비트맵(Bitmap) 필터를 설정할 수 있습니다:

/* include/uapi/linux/icmp.h */
struct icmp_filter {
    __u32 data;  /* 비트맵: bit N이 1이면 ICMP type N을 필터링(드롭) */
};

/* 사용자 공간 예: Echo Reply(type 0)만 수신, 나머지 필터링 */
struct icmp_filter filt;
filt.data = ~(1 << ICMP_ECHOREPLY);  /* type 0만 통과 */
setsockopt(fd, SOL_RAW, ICMP_FILTER, &filt, sizeof(filt));

/* 커널 내부: raw_rcv()에서 필터 검사 */
static inline bool raw_icmp_type_filtered(const struct raw_sock *rp,
                                           u8 type)
{
    /* type에 해당하는 비트가 1이면 필터링(드롭) */
    return (rp->filter.data >> type) & 1;
}

IPv6 Raw Socket (AF_INET6 SOCK_RAW)

IPv6 raw socket은 IPv4와 유사하지만 중요한 차이점이 있습니다:

/* IPv6 raw socket에서 ICMPv6 체크섬은 커널이 자동 계산 */
/* net/ipv6/raw.c — rawv6_send_hdrinc() 내부 */

/* IPV6_CHECKSUM 소켓 옵션: 체크섬 계산 위치 지정 */
int offset = 2;  /* 페이로드 시작부터 체크섬 필드의 바이트 오프셋 */
setsockopt(fd, IPPROTO_IPV6, IPV6_CHECKSUM, &offset, sizeof(offset));
/* 커널이 IPv6 pseudo-header 포함 체크섬을 해당 오프셋에 기록 */

/* ICMPv6 raw socket (protocol = IPPROTO_ICMPV6)은
 * IPV6_CHECKSUM이 자동으로 offset=2에 설정됨
 * → ICMPv6 체크섬 필드 위치가 헤더 시작+2바이트 */

/* ICMPv6 필터 예: Neighbor Solicitation만 수신 */
struct icmp6_filter filt;
ICMP6_FILTER_SETBLOCKALL(&filt);
ICMP6_FILTER_SETPASS(ND_NEIGHBOR_SOLICIT, &filt);
setsockopt(fd, IPPROTO_ICMPV6, ICMPV6_FILTER, &filt, sizeof(filt));

AF_PACKET — L2 프레임 접근

AF_PACKET 소켓은 Ethernet 프레임 수준에서 패킷을 캡처/전송합니다. tcpdump, wireshark, dhclient, arping 등이 사용합니다.

/* net/packet/af_packet.c — packet_type 등록
 * AF_PACKET 소켓 생성 시 packet_type을 등록하여
 * NIC 드라이버의 수신 경로에 후킹 */
static int packet_create(struct net *net, struct socket *sock,
                        int protocol, int kern)
{
    struct packet_sock *po;
    struct sock *sk;

    sk = sk_alloc(net, PF_PACKET, GFP_KERNEL, &packet_proto, kern);
    po = pkt_sk(sk);

    /* packet_type 구조체 설정 */
    po->prot_hook.func = packet_rcv;       /* 수신 콜백 */
    po->prot_hook.af_packet_priv = sk;    /* 소켓 포인터 */

    if (protocol) {
        po->prot_hook.type = protocol;    /* ETH_P_ALL, ETH_P_IP 등 */
        __register_prot_hook(sk);
        /* → dev_add_pack() → ptype_all 또는 ptype_base[] 리스트에 등록
         * → netif_receive_skb() 경로에서 모든 수신 패킷에 대해 콜백 */
    }
}

/* 수신 콜백: netif_receive_skb() → deliver_skb() → packet_rcv() */
static int packet_rcv(struct sk_buff *skb, struct net_device *dev,
                      struct packet_type *pt, struct net_device *orig_dev)
{
    struct sock *sk = pt->af_packet_priv;
    struct sk_buff *copy;
    unsigned int snaplen, res;

    /* BPF 필터 적용 (setsockopt SO_ATTACH_FILTER) */
    res = run_filter(skb, sk, snaplen);
    if (!res)
        goto drop;  /* BPF 필터에 의해 드롭 */

    /* ETH_P_ALL인 경우 모든 패킷에 대해 호출됨 */
    copy = skb_clone(skb, GFP_ATOMIC);
    if (!copy)
        goto drop;

    /* SOCK_RAW: MAC 헤더부터 전체 프레임 노출 */
    if (sk->sk_type == SOCK_RAW)
        skb_push(copy, skb_mac_header_len(skb));

    /* sockaddr_ll에 수신 메타데이터 기록 */
    struct sockaddr_ll *sll = &PACKET_SKB_CB(copy)->sa.ll;
    sll->sll_ifindex = orig_dev->ifindex;
    sll->sll_hatype = dev->type;
    sll->sll_pkttype = skb->pkt_type;  /* PACKET_HOST, PACKET_BROADCAST 등 */

    sock_queue_rcv_skb(sk, copy);
    return 0;
drop:
    kfree_skb(skb);
    return 0;
}

/* AF_PACKET 전송: 사용자 → dev_queue_xmit() 직접 전달 */
static int packet_sendmsg(struct socket *sock, struct msghdr *msg,
                         size_t len)
{
    /* SOCK_RAW: 사용자가 Ethernet 헤더 포함 전체 프레임 작성 */
    /* SOCK_DGRAM: sockaddr_ll에서 목적지 MAC, 커널이 Ethernet 헤더 생성 */

    struct sk_buff *skb = packet_alloc_skb(sk, ...);

    /* 사용자 데이터 복사 */
    skb_copy_datagram_from_iter(skb, 0, &msg->msg_iter, len);

    /* IP 스택을 완전히 우회하여 직접 디바이스 큐로 전송 */
    err = dev_queue_xmit(skb);
    /* → qdisc → NIC 드라이버 → 물리 전송 */
}

TPACKET — mmap 기반 고성능 캡처

TPACKET(PACKET_MMAP)은 커널-사용자 간 mmap된 공유 ring buffer를 사용하여 recvmsg()/sendmsg() 시스템콜 오버헤드 없이 패킷을 교환합니다. tcpdump, libpcap, suricata 등 고성능 캡처 도구의 핵심입니다.

/* TPACKET_V3 ring buffer 설정 예 (사용자 공간) */
struct tpacket_req3 req = {
    .tp_block_size  = 1 << 22,     /* 4MB 블록 */
    .tp_block_nr    = 64,          /* 64개 블록 = 256MB */
    .tp_frame_size  = TPACKET_ALIGNMENT << 7, /* 프레임 정렬 */
    .tp_frame_nr    = (1 << 22) * 64 / (TPACKET_ALIGNMENT << 7),
    .tp_retire_blk_tov = 60,      /* 블록 타임아웃 60ms */
    .tp_feature_req_word = TP_FT_REQ_FILL_RXHASH,
};

/* TPACKET 버전 설정 */
int ver = TPACKET_V3;
setsockopt(fd, SOL_PACKET, PACKET_VERSION, &ver, sizeof(ver));

/* RX ring buffer 설정 */
setsockopt(fd, SOL_PACKET, PACKET_RX_RING, &req, sizeof(req));

/* 커널-사용자 공유 메모리 매핑 */
void *ring = mmap(NULL, req.tp_block_size * req.tp_block_nr,
                  PROT_READ | PROT_WRITE, MAP_SHARED | MAP_LOCKED,
                  fd, 0);

/* 패킷 수신 루프 (V3 블록 기반) */
while (1) {
    struct tpacket_block_desc *pbd = block_descs[current_block];

    /* 블록이 준비될 때까지 대기 */
    while (!(pbd->hdr.bh1.block_status & TP_STATUS_USER))
        poll(&pfd, 1, -1);

    /* 블록 내 모든 패킷 순회 */
    int num_pkts = pbd->hdr.bh1.num_pkts;
    struct tpacket3_hdr *ppd = (struct tpacket3_hdr *)
        ((uint8_t *)pbd + pbd->hdr.bh1.offset_to_first_pkt);

    for (int i = 0; i < num_pkts; i++) {
        uint8_t *pkt_data = (uint8_t *)ppd + ppd->tp_mac;
        uint32_t pkt_len = ppd->tp_snaplen;

        process_packet(pkt_data, pkt_len);  /* 패킷 처리 */

        ppd = (struct tpacket3_hdr *)
              ((uint8_t *)ppd + ppd->tp_next_offset);
    }

    /* 블록을 커널에 반환 */
    pbd->hdr.bh1.block_status = TP_STATUS_KERNEL;
    current_block = (current_block + 1) % req.tp_block_nr;
}

/* 커널 내부: TPACKET_V3 수신 처리
 * net/packet/af_packet.c — tpacket_rcv() */
static int tpacket_rcv(struct sk_buff *skb, struct net_device *dev,
                      struct packet_type *pt,
                      struct net_device *orig_dev)
{
    /* V3: 현재 블록에 패킷 추가 (가변 크기)
     * → skb 데이터를 mmap 버퍼에 직접 복사
     * → 블록이 가득 차거나 타임아웃 시 TP_STATUS_USER로 전환
     * → 사용자는 poll()로 알림 받고 mmap 메모리에서 직접 읽음
     * → recvmsg() 시스콜 불필요 = zero-copy 수신 */

    /* BPF 필터 먼저 실행 */
    res = run_filter(skb, sk, snaplen);
    if (!res)
        goto drop;

    /* ring buffer의 현재 블록에 패킷 데이터 복사 */
    h.raw = packet_current_rx_frame(po, skb, ...);
    skb_copy_bits(skb, 0, h.raw + macoff, snaplen);

    /* 패킷 메타데이터 기록: 타임스탬프, 길이, VLAN 등 */
    h.h3->tp_sec = ts.tv_sec;
    h.h3->tp_nsec = ts.tv_nsec;
    h.h3->tp_snaplen = snaplen;
    h.h3->tp_len = skb->len;
}

PACKET_FANOUT — 멀티코어 패킷 분산

여러 AF_PACKET 소켓이 동일 인터페이스에서 패킷을 분산 처리할 수 있습니다. suricata, PF_RING 대안으로 사용됩니다:

/* PACKET_FANOUT 모드 */
#define PACKET_FANOUT_HASH         0  /* 흐름 해시 기반 분배 (기본) */
#define PACKET_FANOUT_LB           1  /* 라운드 로빈 */
#define PACKET_FANOUT_CPU          2  /* CPU ID 기반 (RSS 활용) */
#define PACKET_FANOUT_ROLLOVER     3  /* 큐 가득 차면 다음 소켓으로 */
#define PACKET_FANOUT_RND          4  /* 랜덤 분배 */
#define PACKET_FANOUT_QM           5  /* skb 큐 매핑 기반 */
#define PACKET_FANOUT_CBPF         6  /* cBPF 프로그램으로 분배 결정 */
#define PACKET_FANOUT_EBPF         7  /* eBPF 프로그램으로 분배 결정 */

/* 사용 예: 4개 워커 스레드가 흐름 해시 기반으로 패킷 분산 */
int fanout_arg = (PACKET_FANOUT_HASH | PACKET_FANOUT_FLAG_DEFRAG)
                 | (group_id << 16);
setsockopt(fd, SOL_PACKET, PACKET_FANOUT, &fanout_arg,
           sizeof(fanout_arg));

/* 커널 내부: fanout_demux() — 소켓 선택 */
static struct sock *fanout_demux_hash(
    struct packet_fanout *f, struct sk_buff *skb, unsigned int num)
{
    /* skb 흐름 해시를 소켓 수로 나눠 분배 */
    return f->arr[reciprocal_scale(
        __skb_get_hash_symmetric(skb), num)];
}

/* PACKET_FANOUT_FLAG 옵션 */
#define PACKET_FANOUT_FLAG_ROLLOVER  0x1000 /* 소켓 백로그 시 롤오버 */
#define PACKET_FANOUT_FLAG_UNIQUEID  0x2000 /* 고유 그룹 ID 자동 할당 */
#define PACKET_FANOUT_FLAG_DEFRAG    0x8000 /* IP 단편화 재조합 후 분배 */

Raw Socket과 Netfilter 관계

Raw socket으로 전송하는 패킷도 Netfilter 체인을 통과합니다. 수신은 프로토콜 핸들러(Handler) 이전(raw_local_deliver)에 처리되므로 INPUT 체인보다 먼저 clone이 발생합니다:

Raw Socket의 bind()와 connect()

/* AF_INET SOCK_RAW에서 bind()와 connect()의 역할 */

/* bind() — 수신 필터링: 특정 로컬 IP로의 패킷만 수신 */
struct sockaddr_in addr = {
    .sin_family = AF_INET,
    .sin_addr.s_addr = inet_addr("192.168.1.10"),
};
bind(fd, (struct sockaddr *)&addr, sizeof(addr));
/* → raw_v4_match()에서 daddr 매칭에 사용
 * → 해당 IP가 목적지인 패킷만 수신 큐에 전달 */

/* connect() — 기본 목적지 설정 + 수신 필터링 */
struct sockaddr_in dest = {
    .sin_family = AF_INET,
    .sin_addr.s_addr = inet_addr("10.0.0.1"),
};
connect(fd, (struct sockaddr *)&dest, sizeof(dest));
/* → send()에서 목적지 주소 생략 가능 (sendto 대신 send 사용)
 * → 수신 시 해당 소스 IP에서 온 패킷만 수신 (소스 필터) */

/* AF_PACKET에서 bind() — 특정 인터페이스에 바인딩 */
struct sockaddr_ll sll = {
    .sll_family   = AF_PACKET,
    .sll_protocol = htons(ETH_P_ALL),
    .sll_ifindex  = if_nametoindex("eth0"),
};
bind(fd, (struct sockaddr *)&sll, sizeof(sll));
/* → 해당 인터페이스의 패킷만 수신
 * → 바인딩 없으면 모든 인터페이스의 패킷 수신 */

실용 예제

/* 예제 1: ICMP Echo Request 전송 (ping 구현) */
int fd = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
/* CAP_NET_RAW 필요 */

struct {
    struct icmphdr hdr;
    char data[56];   /* 페이로드 (타임스탬프 등) */
} pkt;

pkt.hdr.type = ICMP_ECHO;
pkt.hdr.code = 0;
pkt.hdr.un.echo.id = htons(getpid());
pkt.hdr.un.echo.sequence = htons(seq++);
pkt.hdr.checksum = 0;
pkt.hdr.checksum = icmp_checksum(&pkt, sizeof(pkt));

struct sockaddr_in dest = { .sin_family = AF_INET,
    .sin_addr.s_addr = inet_addr("8.8.8.8") };

sendto(fd, &pkt, sizeof(pkt), 0,
       (struct sockaddr *)&dest, sizeof(dest));
/* 커널이 IP 헤더를 자동 생성 (IP_HDRINCL 미설정이므로)
 * → skb 할당 → ICMP 페이로드 복사 → IP 헤더 추가
 * → raw_sendmsg() → ip_append_data() → ip_push_pending_frames()
 * → Netfilter OUTPUT → ip_output() → dev_queue_xmit() */

/* 수신: raw socket은 모든 ICMP 패킷을 받으므로 필터 설정 */
struct icmp_filter filt;
filt.data = ~(1 << ICMP_ECHOREPLY);
setsockopt(fd, SOL_RAW, ICMP_FILTER, &filt, sizeof(filt));

char buf[1500];
struct sockaddr_in from;
socklen_t fromlen = sizeof(from);
int n = recvfrom(fd, buf, sizeof(buf), 0,
                 (struct sockaddr *)&from, &fromlen);
/* buf[0..19] = IP 헤더 (raw socket은 항상 IP 헤더 포함 수신)
 * buf[20..]  = ICMP 헤더 + 페이로드 */

/* 예제 2: ARP Request 전송 (AF_PACKET SOCK_RAW) */
int fd = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ARP));

/* 전체 Ethernet 프레임을 직접 구성 */
struct {
    struct ethhdr  eth;    /* Ethernet 헤더 (14 bytes) */
    struct arphdr  arp;    /* ARP 헤더 */
    uint8_t ar_sha[6];     /* 송신자 MAC */
    uint8_t ar_sip[4];     /* 송신자 IP */
    uint8_t ar_tha[6];     /* 대상 MAC (ARP Request에서는 0) */
    uint8_t ar_tip[4];     /* 대상 IP */
} frame;

/* Ethernet 헤더: 브로드캐스트 */
memset(frame.eth.h_dest, 0xff, ETH_ALEN); /* FF:FF:FF:FF:FF:FF */
memcpy(frame.eth.h_source, my_mac, ETH_ALEN);
frame.eth.h_proto = htons(ETH_P_ARP);

/* ARP 헤더: ARP Request */
frame.arp.ar_hrd = htons(ARPHRD_ETHER);
frame.arp.ar_pro = htons(ETH_P_IP);
frame.arp.ar_hln = 6;
frame.arp.ar_pln = 4;
frame.arp.ar_op  = htons(ARPOP_REQUEST);

/* sockaddr_ll로 출력 인터페이스 지정 */
struct sockaddr_ll sll = {
    .sll_ifindex = if_nametoindex("eth0"),
    .sll_halen   = ETH_ALEN,
};
memset(sll.sll_addr, 0xff, ETH_ALEN);

sendto(fd, &frame, sizeof(frame), 0,
       (struct sockaddr *)&sll, sizeof(sll));
/* → packet_sendmsg() → dev_queue_xmit()
 * → IP 스택, Netfilter 완전 우회
 * → 직접 NIC 드라이버로 전달 */

/* 예제 3: IP_HDRINCL로 커스텀 IP 패킷 전송 */
int fd = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
/* IPPROTO_RAW (255)는 자동으로 IP_HDRINCL 활성화 */

struct {
    struct iphdr  ip;
    struct udphdr udp;
    char payload[64];
} pkt;

/* IP 헤더 구성 */
pkt.ip.version  = 4;
pkt.ip.ihl      = 5;
pkt.ip.tos      = 0;
pkt.ip.tot_len  = htons(sizeof(pkt));
pkt.ip.id       = 0;     /* 커널이 자동 할당 */
pkt.ip.frag_off = htons(IP_DF);
pkt.ip.ttl      = 64;
pkt.ip.protocol = IPPROTO_UDP;
pkt.ip.check    = 0;     /* 커널이 자동 계산 */
pkt.ip.saddr    = inet_addr("10.0.0.1");
pkt.ip.daddr    = inet_addr("10.0.0.2");

/* UDP 헤더 구성 */
pkt.udp.source = htons(12345);
pkt.udp.dest   = htons(53);
pkt.udp.len    = htons(sizeof(pkt.udp) + sizeof(pkt.payload));
pkt.udp.check  = 0;     /* UDP 체크섬은 사용자가 계산해야 함 */

sendto(fd, &pkt, sizeof(pkt), 0, ...);
/* → raw_sendmsg() → inet->hdrincl=1이므로 raw_send_hdrinc()
 * → 커널은 check, tot_len(0이면), id(0이면), saddr(0이면)만 보정
 * → NF_HOOK(NF_INET_LOCAL_OUT) → dst_output() → dev_queue_xmit() */

보안 고려사항

# CAP_NET_RAW 관련 보안 설정

# 특정 바이너리에만 CAP_NET_RAW 부여 (setuid 대체)
setcap cap_net_raw+ep /usr/bin/ping

# ping socket 허용 범위 설정 (CAP_NET_RAW 불필요)
# GID 0~2147483647 범위의 사용자가 ICMP ping 가능
sysctl -w net.ipv4.ping_group_range="0 2147483647"

# Reverse Path Filtering (IP 스푸핑 방지)
sysctl -w net.ipv4.conf.all.rp_filter=1       # strict mode
sysctl -w net.ipv4.conf.all.rp_filter=2       # loose mode

# 컨테이너에서 CAP_NET_RAW 제거 (Docker)
docker run --cap-drop=NET_RAW ...

# seccomp으로 raw socket 시스콜 차단
# socket(AF_PACKET, ...) 또는 socket(AF_INET, SOCK_RAW, ...) 블록

# 열린 raw socket 확인
ss -w -a          # RAW 소켓 목록
cat /proc/net/raw # IPv4 raw socket 상세 정보
cat /proc/net/raw6 # IPv6 raw socket 상세 정보
cat /proc/net/packet # AF_PACKET 소켓 목록

소켓 디먹싱과 skb 전달

수신된 skb가 올바른 소켓을 찾아가는 과정 (디먹싱):

/* TCP 수신 디먹싱: 4-tuple 해시 → 소켓 lookup */
/* tcp_v4_rcv() 내부 */
struct sock *sk = __inet_lookup_skb(
    &tcp_hashinfo,  /* TCP 소켓 해시 테이블 */
    skb,
    __tcp_hdrlen(th),
    th->source,      /* 소스 포트 */
    th->dest,        /* 목적지 포트 */
    iph->saddr,      /* 소스 IP */
    iph->daddr,      /* 목적지 IP */
    sdif);
/* 반환: established 소켓 또는 listen 소켓 */

/* UDP 수신 디먹싱 */
struct sock *sk = __udp4_lib_lookup_skb(skb, uh->source, uh->dest,
                                         udptable);

/* 소켓을 찾은 후 skb를 수신 큐에 전달 */
if (!sock_owned_by_user(sk)) {
    /* 소켓이 lock 상태가 아니면 직접 수신 큐에 추가 */
    __skb_queue_tail(&sk->sk_receive_queue, skb);
    sk->sk_data_ready(sk);  /* epoll/poll/select wakeup */
} else {
    /* 소켓이 lock 중이면 backlog에 임시 저장 */
    __sk_add_backlog(sk, skb);
    /* → release_sock() 시 backlog 처리 */
}

Zero-copy 전송

대용량 데이터를 전송할 때, 사용자 공간 버퍼를 커널로 복사하지 않고 직접 NIC에 전달하여 CPU 사용량과 지연을 줄일 수 있습니다:

/* 커널 내부: sendfile의 skb 구성 */
/* 파일 페이지를 skb fragment로 직접 참조 */
skb_fill_page_desc(skb, frag_idx, page, offset, size);
/* page refcount 증가, 복사 없음 */

/* MSG_ZEROCOPY: 사용자 버퍼 페이지를 pin */
/* skb->destructor = sock_zerocopy_callback;
 * 전송 완료 시 사용자 공간에 completion notification 전달
 * (errqueue에서 SO_EE_ORIGIN_ZEROCOPY 메시지 수신) */

/* 드라이버: skb_page_frag_refill로 페이지 풀 활용 */
struct page_frag_cache *nc = &this_cpu_ptr(&nf_skb_cache)->pf_cache;
if (!skb_page_frag_refill(size, nc, GFP_ATOMIC))
    return -ENOMEM;
/* nc->va + nc->offset 에서 size 바이트 사용 가능 */

수신/전송 경로에서의 skb 변형

sk_buff 생애주기 (Lifecycle)

sk_buff는 네트워크 패킷의 전체 생명주기 동안 커널 메모리를 차지하며, 할당부터 해제까지 다양한 변형을 거칩니다. 다음 다이어그램은 수신(RX)과 송신(TX) 경로에서 sk_buff의 생애주기를 보여줍니다.

참조 카운트와 메모리 관리

/* sk_buff의 참조 카운트는 users 필드로 관리 */
struct sk_buff {
    atomic_t users;  /* 참조 카운트 (skb_get/skb_put으로 증감) */
    /* ... */
};

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

/* 참조 카운트 감소 — 0이 되면 해제 */
static inline void kfree_skb(struct sk_buff *skb)
{
    if (!skb) return;
    if (refcount_dec_and_test(&skb->users))
        __kfree_skb(skb);  /* 실제 해제 */
}

/* 정상 소비 (드롭 아님) — 통계 구분 */
static inline void consume_skb(struct sk_buff *skb)
{
    if (!skb) return;
    if (refcount_dec_and_test(&skb->users))
        __kfree_skb(skb);
}

/* 사용 예: 소켓 큐에서 꺼낸 후 해제 */
struct sk_buff *skb = skb_dequeue(&sk->sk_receive_queue);
if (skb) {
    process_packet(skb);
    consume_skb(skb);  /* 정상 소비 */
}

/* 드롭 시 kfree_skb 사용 (디버깅 추적 가능) */
if (!pskb_may_pull(skb, sizeof(struct iphdr))) {
    kfree_skb(skb);  /* 드롭: perf/dropwatch로 추적됨 */
    return -EINVAL;
}

수신/송신 경로에서의 데이터 영역 변화

수신 경로: 각 계층에서 헤더를 제거하며 data 포인터가 앞으로 이동합니다.

송신 경로: 각 계층에서 헤더를 추가하며 data 포인터가 뒤로 이동합니다.

eth_type_trans() 호출 전후 skb 필드 변화

NIC 드라이버가 eth_type_trans(skb, dev)를 호출하면 다음 필드들이 갱신됩니다: