네트워크 디바이스 드라이버 (net_device)

Linux 네트워크 디바이스 드라이버를 고처리량 데이터 경로와 운영 안정성 관점에서 심층 정리합니다. net_device/net_device_ops 초기화, NAPI 기반 RX 폴링(Polling), TX 큐 관리와 BQL, MSI-X/IRQ affinity 최적화, checksum/TSO/GRO 등 오프로드 기능, XDP/AF_XDP 연계, ethtool 통계와 링크 상태 관리, 물리 NIC와 TUN/TAP 같은 가상 netdev 공통 모델, tracepoint/perf/bpftrace를 활용한 병목(Bottleneck) 분석까지 실전 네트워크 드라이버 개발에 필요한 핵심을 다룹니다.

개요: net_device 드라이버의 역할

struct net_device 드라이버는 커널 네트워크 스택(Network Stack)과 실제/가상 링크 계층 사이의 어댑터입니다. 유저스페이스 입장에서는 eth0, ens3, tap0 모두 동일한 netdev 인터페이스처럼 보이지만, 내부 구현은 물리 NIC/가상 디바이스에 따라 크게 달라집니다.

struct net_device 핵심 필드 상세 분석

struct net_device는 리눅스 네트워크 스택에서 가장 핵심적인 구조체로, 하나의 네트워크 인터페이스가 가져야 할 모든 상태 정보를 담고 있습니다. 커널 6.x 기준 이 구조체의 크기는 약 2KB에 달하며, 수십 개의 필드가 캐시 라인 최적화(Cache Line Optimization)를 고려하여 배치되어 있습니다. 특히 핫 패스(Hot Path)에서 자주 접근하는 필드들은 ____cacheline_aligned_in_smp 어노테이션(Annotation)을 통해 동일한 캐시 라인에 모이도록 정렬됩니다. 이는 SMP 환경에서 캐시 바운싱(Cache Bouncing)을 최소화하고, 패킷 송수신 경로의 지연 시간(Latency)을 줄이기 위한 의도적 설계입니다. net_device는 include/linux/netdevice.h에 정의되며, alloc_netdev_mqs()를 통해 할당됩니다.

핵심 필드 분류

식별 및 이름

상태 및 플래그

네트워크 파라미터

콜백 테이블(Callback Table)

큐 및 성능

Feature 비트마스크

통계(Statistics)

참조 및 계층 구조

캐시 라인 최적화 배치

커널은 성능 최적화를 위해 struct net_device의 필드를 캐시 라인 경계에 맞춰 배치합니다. 핫 패스에서 빈번하게 읽히는 필드가 동일한 캐시 라인에 위치하면, CPU 캐시 미스(Cache Miss)를 최소화할 수 있습니다. 다음은 커널 소스에서 실제 사용되는 캐시 라인 정렬 패턴입니다.

/* 커널 소스 분석: include/linux/netdevice.h - struct net_device 캐시 라인 배치 */
struct net_device {
    /* ---- 첫 번째 캐시 라인: 이름 + 핫 패스 필드 ---- */
    char                    name[IFNAMSIZ];
    struct netdev_name_node  *name_node;
    struct dev_ifalias      __rcu *ifalias;

    unsigned long           mem_end;
    unsigned long           mem_start;
    unsigned long           base_addr;

    /* ---- 핫 패스 송신 경로 (____cacheline_aligned_in_smp) ---- */
    unsigned long           state;
    struct list_head        dev_list;
    struct list_head        napi_list;

    unsigned int            flags;
    unsigned int            priv_flags;
    const struct net_device_ops *netdev_ops;
    int                     ifindex;

    unsigned short          gflags;
    unsigned short          hard_header_len;
    unsigned int            mtu;
    unsigned short          needed_headroom;
    unsigned short          needed_tailroom;

    netdev_features_t       features;     /* 현재 활성 feature */
    netdev_features_t       hw_features;  /* HW 지원 가능 feature */
    netdev_features_t       wanted_features;

    /* ---- 수신 경로 캐시 라인 정렬 ---- */
    unsigned int            num_tx_queues
        ____cacheline_aligned_in_smp;
    unsigned int            real_num_tx_queues;
    struct Qdisc           *qdisc;
    unsigned int            tx_queue_len;

    unsigned int            num_rx_queues
        ____cacheline_aligned_in_smp;
    unsigned int            real_num_rx_queues;

    /* ---- 콜백 테이블 ---- */
    const struct ethtool_ops       *ethtool_ops;
    const struct header_ops        *header_ops;
    const struct xdp_metadata_ops *xdp_metadata_ops;

    unsigned char           operstate;
    unsigned char           link_mode;

    unsigned int            min_mtu;
    unsigned int            max_mtu;
    unsigned short          type;     /* ARPHRD_ETHER 등 */
    unsigned char           addr_len;

    unsigned char           *dev_addr;
    unsigned char           *broadcast;

    /* ---- per-CPU 통계 ---- */
    struct net_device_stats stats;
    enum netdev_pcpu_stat_type pcpu_stat_type;
    union {
        struct pcpu_sw_netstats __percpu  *tstats;
        struct pcpu_dstats      __percpu  *dstats;
        struct pcpu_lstats      __percpu  *lstats;
    };

    /* ---- 디바이스 모델 / 네임스페이스 ---- */
    struct device           dev;
    possible_net_t          nd_net;
    void                    *ip_ptr;
    void                    *ip6_ptr;

    enum netdev_reg_state { ... } reg_state;
    /* ... 그 외 다수 필드 ... */
};

flags 필드 상세 분석

flags 필드는 include/uapi/linux/if.h에 정의된 IFF_* 상수들의 비트 조합입니다. 사용자 공간에서 ioctl(SIOCSIFFLAGS) 또는 netlink를 통해 변경할 수 있으며, 커널 내부에서는 반드시 dev_change_flags()를 통해 변경해야 합니다.

/* 커널 소스 분석: net/core/dev.c - dev_change_flags() 내부 흐름 */
int dev_change_flags(struct net_device *dev, unsigned int flags,
                     struct netlink_ext_ack *extack)
{
    unsigned int changes;
    int ret;

    /* 이전 flags와 새 flags의 차이(XOR) 계산 */
    changes = flags ^ dev->flags;

    /* IFF_UP 변경 처리: 인터페이스 열기/닫기 */
    if (changes & IFF_UP) {
        if (flags & IFF_UP)
            ret = __dev_open(dev, extack);
        else
            __dev_close(dev);
    }

    /* IFF_PROMISC 변경 시 하드웨어 필터 업데이트 */
    if ((changes & IFF_PROMISC) && (dev->flags & IFF_UP)) {
        int inc = (flags & IFF_PROMISC) ? 1 : -1;
        dev_set_promiscuity(dev, inc);
    }

    /* IFF_ALLMULTI 변경 시 멀티캐스트 필터 업데이트 */
    if ((changes & IFF_ALLMULTI) && (dev->flags & IFF_UP)) {
        int inc = (flags & IFF_ALLMULTI) ? 1 : -1;
        dev_set_allmulti(dev, inc);
    }

    /* flags 갱신 후 notifier 체인으로 변경 알림 전파 */
    dev->flags = (flags & (IFF_DEBUG | IFF_NOTRAILERS | IFF_NOARP |
                           IFF_DYNAMIC | IFF_MULTICAST | IFF_PORTSEL |
                           IFF_AUTOMEDIA)) |
                 (dev->flags & (IFF_UP | IFF_VOLATILE | IFF_PROMISC |
                                IFF_ALLMULTI));

    /* NETDEV_CHANGE 이벤트 발송 → rtnetlink, bonding 등 수신 */
    if (changes)
        call_netdevice_notifiers(NETDEV_CHANGE, dev);

    return ret;
}

priv_flags 상세 분석

priv_flags는 커널 내부 또는 드라이버 전용 플래그로, 사용자 공간에서 직접 변경할 수 없습니다. 주로 가상 디바이스 유형 식별이나 내부 동작 제어에 사용됩니다. include/linux/netdevice.h에 IFF_* 이름으로 정의되어 있으며, 사용자 공간의 IFF_* 플래그와 네임스페이스가 다르다.

reg_state 등록 상태 전이

reg_state는 net_device의 등록 생명주기(Registration Lifecycle)를 추적하는 상태 머신입니다. register_netdevice()에서 NETREG_REGISTERED로 전이되고, unregister_netdevice()를 거쳐 최종적으로 free_netdev()에서 해제됩니다. 각 상태 전이는 RTNL 락(Lock) 하에서만 수행됩니다.

/* 커널 소스 분석: include/linux/netdevice.h - reg_state 열거형 */
enum {
    NETREG_UNINITIALIZED = 0,  /* alloc_netdev() 직후 */
    NETREG_REGISTERED,         /* register_netdevice() 완료 */
    NETREG_UNREGISTERING,       /* unregister_netdevice() 호출됨 */
    NETREG_UNREGISTERED,        /* netdev_run_todo() 완료 */
    NETREG_RELEASED,            /* netdev_release() → free 가능 */
    NETREG_DUMMY,               /* init_dummy_netdev()용 더미 */
};

operstate (RFC 2863) 운영 상태

operstate는 RFC 2863에서 정의한 인터페이스 운영 상태를 나타냅니다. 커널은 링크 상태, 상위/하위 레이어 상태를 종합하여 이 값을 자동으로 관리하며, linkwatch 서브시스템이 상태 변경 이벤트를 사용자 공간으로 전달합니다.

/* 커널 소스 분석: net/core/link_watch.c - operstate 결정 로직 */
static void rfc2863_policy(struct net_device *dev)
{
    unsigned char operstate = IF_OPER_DOWN;

    if (dev->flags & IFF_UP) {
        if (!netif_carrier_ok(dev))
            operstate = (dev->ifindex != LOOPBACK_IFINDEX)
                        ? IF_OPER_DOWN : IF_OPER_UNKNOWN;
        else if (netif_dormant(dev))
            operstate = IF_OPER_DORMANT;
        else
            operstate = IF_OPER_UP;
    }

    if (dev->operstate != operstate) {
        write_lock(&dev_base_lock);
        dev->operstate = operstate;
        write_unlock(&dev_base_lock);
    }
}

드라이버 수명주기와 필수 호출 순서

가장 흔한 실수는 등록/해제 순서를 뒤섞는 것입니다. 특히 NAPI, IRQ, queue start/stop 순서는 패킷(Packet) 손실과 use-after-free를 바로 유발합니다.

/* 개념 예시: net_device 수명주기와 등록 순서 */
#include <linux/netdevice.h>
#include <linux/etherdevice.h>

struct my_priv {
    struct net_device *ndev;
    struct napi_struct napi;
    spinlock_t tx_lock;
    void __iomem *bar0;
    int irq;
};

static int my_probe(struct pci_dev *pdev, const struct pci_device_id *id)
{
    struct net_device *ndev;
    struct my_priv *priv;
    int ret;

    ndev = alloc_etherdev_mqs(sizeof(*priv), 8, 8);
    if (!ndev)
        return -ENOMEM;

    priv = netdev_priv(ndev);
    priv->ndev = ndev;
    spin_lock_init(&priv->tx_lock);

    netif_napi_add(ndev, &priv->napi, my_napi_poll);
    ndev->netdev_ops = &my_netdev_ops;
    ndev->ethtool_ops = &my_ethtool_ops;

    ret = register_netdev(ndev);
    if (ret) {
        netif_napi_del(&priv->napi);
        free_netdev(ndev);
        return ret;
    }

    return 0;
}

static void my_remove(struct pci_dev *pdev)
{
    struct net_device *ndev = pci_get_drvdata(pdev);
    struct my_priv *priv = netdev_priv(ndev);

    unregister_netdev(ndev);
    netif_napi_del(&priv->napi);
    free_netdev(ndev);
}

할당/등록/해제 함수 내부 구현

net_device 구조체는 단순히 kmalloc()으로 할당하기에는 너무 크고 복잡합니다. 커널은 정렬(Alignment), 큐 배열, 사설 데이터(Private Data) 영역까지 한 번에 관리하는 전용 할당 함수를 제공하며, 등록/해제 과정에서도 sysfs, 해시 테이블, 알림 체인(Notifier Chain), 참조 카운트(Reference Count) 등 여러 서브시스템과 연동됩니다. 이 절에서는 이들 함수의 내부 구현을 커널 소스 수준에서 분석합니다.

alloc_netdev_mqs() 내부 분석

alloc_netdev_mqs()는 모든 네트워크 디바이스 할당의 핵심 함수입니다. alloc_etherdev(), alloc_netdev() 등 편의 매크로는 궁극적으로 이 함수를 호출합니다.

/* 커널 소스 분석: net/core/dev.c - alloc_netdev_mqs() */
struct net_device *alloc_netdev_mqs(
    int sizeof_priv,
    const char *name,
    unsigned char name_assign_type,
    void (*setup)(struct net_device *),
    unsigned int txqs,
    unsigned int rxqs)
{
    struct net_device *dev;
    unsigned int alloc_size;

    /* 커널 소스 분석: 전체 할당 크기 계산
     * net_device + private data를 NETDEV_ALIGN(32바이트)으로 정렬
     * ____cacheline_aligned_in_smp로 캐시 라인 경계 맞춤 */
    alloc_size = sizeof(struct net_device);
    if (sizeof_priv) {
        /* net_device 뒤에 private 영역 배치, 정렬 보장 */
        alloc_size = ALIGN(alloc_size, NETDEV_ALIGN);
        alloc_size += sizeof_priv;
    }
    /* 최종 크기도 NETDEV_ALIGN 단위로 올림 */
    alloc_size += NETDEV_ALIGN - 1;

    /* 커널 소스 분석: kvzalloc 사용 - kmalloc 아님!
     * net_device가 수 KB에 달할 수 있어 vmalloc 폴백 필요
     * GFP_KERNEL | __GFP_RETRY_MAYFAIL로 할당 실패 허용 */
    dev = kvzalloc(alloc_size, GFP_KERNEL | __GFP_RETRY_MAYFAIL);
    if (!dev)
        return NULL;

    /* 커널 소스 분석: 디바이스 주소 리스트 초기화 */
    dev_addr_init(dev);   /* MAC 주소 리스트 */
    dev_mc_init(dev);     /* 멀티캐스트 주소 리스트 */
    dev_uc_init(dev);     /* 유니캐스트 주소 리스트 */

    dev_net_set(dev, &init_net);  /* 현재 네트워크 네임스페이스 설정 */

    dev->gso_max_size = GSO_LEGACY_MAX_SIZE;
    dev->gso_max_segs = GSO_MAX_SEGS;
    dev->upper_level = 1;
    dev->lower_level = 1;

    INIT_LIST_HEAD(&dev->napi_list);
    INIT_LIST_HEAD(&dev->adj_list.upper);
    INIT_LIST_HEAD(&dev->adj_list.lower);

    dev->reg_state = NETREG_UNINITIALIZED;

    dev->num_tx_queues = txqs;
    dev->real_num_tx_queues = txqs;

    /* 커널 소스 분석: TX 큐 배열 할당 */
    if (netif_alloc_netdev_queues(dev))
        goto free_all;

    dev->num_rx_queues = rxqs;
    dev->real_num_rx_queues = rxqs;

    /* 커널 소스 분석: RX 큐 배열 할당 */
    if (netif_alloc_rx_queues(dev))
        goto free_all;

    strcpy(dev->name, name);
    dev->name_assign_type = name_assign_type;

    /* 커널 소스 분석: setup 콜백 호출
     * 이더넷이면 ether_setup(), CAN이면 can_setup() 등
     * 프로토콜별 기본값(MTU, 헤더 길이, 플래그 등) 설정 */
    setup(dev);

    return dev;

free_all:
    free_netdev(dev);
    return NULL;
}

아래 다이어그램은 alloc_netdev_mqs()가 할당하는 메모리 레이아웃(Memory Layout)을 보여줍니다. netdev_priv()은 net_device 구조체 바로 뒤의 정렬된 주소를 반환합니다.

ether_setup() 내부

ether_setup()은 이더넷(Ethernet) 디바이스의 기본 속성을 설정하는 setup 콜백입니다. alloc_etherdev() 계열 매크로가 alloc_netdev_mqs()에 이 함수를 전달합니다.

/* 커널 소스 분석: net/ethernet/eth.c - ether_setup() */
void ether_setup(struct net_device *dev)
{
    dev->header_ops      = &eth_header_ops;
    dev->type            = ARPHRD_ETHER;         /* ARP 하드웨어 타입: 이더넷 */
    dev->hard_header_len  = ETH_HLEN;             /* 14바이트 (DST 6 + SRC 6 + Type 2) */
    dev->min_header_len   = ETH_HLEN;
    dev->mtu             = ETH_DATA_LEN;         /* 1500바이트 */
    dev->min_mtu         = ETH_MIN_MTU;          /* 68바이트 (IPv4 최소) */
    dev->max_mtu         = ETH_MAX_MTU;          /* 65535바이트 */
    dev->addr_len        = ETH_ALEN;             /* 6바이트 (MAC 주소 길이) */
    dev->flags           = IFF_BROADCAST | IFF_MULTICAST;
    dev->priv_flags      |= IFF_TX_SKB_SHARING;

    /* 커널 소스 분석: 브로드캐스트 주소를 FF:FF:FF:FF:FF:FF로 설정 */
    eth_broadcast_addr(dev->broadcast);

    /* 커널 소스 분석: eth_header_ops는 eth_header(), eth_header_parse() 등 제공
     * 이더넷 헤더 생성·파싱을 표준화 */
}

편의 할당 매크로 패밀리

커널은 프로토콜별로 alloc_netdev_mqs()를 감싸는 다양한 편의 매크로(Convenience Macro)를 제공합니다.

register_netdev() / register_netdevice() 내부

register_netdev()는 RTNL 잠금(Lock)을 자동으로 관리하는 편의 함수이며, 실제 등록 로직은 register_netdevice()에 구현되어 있습니다.

/* 커널 소스 분석: net/core/dev.c - register_netdev() */
int register_netdev(struct net_device *dev)
{
    int err;

    /* 커널 소스 분석: RTNL(Routing Netlink) 잠금 획득
     * 네트워크 디바이스 등록/해제는 반드시 RTNL 잠금 하에서 수행 */
    rtnl_lock();
    err = register_netdevice(dev);
    rtnl_unlock();

    return err;
}

/* 커널 소스 분석: net/core/dev.c - register_netdevice() 핵심 흐름 */
int register_netdevice(struct net_device *dev)
{
    struct net *net = dev_net(dev);
    int ret;

    ASSERT_RTNL();  /* RTNL 잠금 보유 확인 */

    /* 커널 소스 분석: 이름 유효성 검증
     * "eth%d" 같은 패턴이면 사용 가능한 번호 자동 할당
     * 이름 충돌 시 에러 반환 */
    ret = dev_get_valid_name(net, dev, dev->name);
    if (ret < 0)
        goto out;

    /* ifindex 할당 (네임스페이스 내 고유) */
    dev->ifindex = dev_new_index(net);

    /* 커널 소스 분석: netdev_ops 유효성 검증 */
    if (dev->netdev_ops->ndo_init) {
        ret = dev->netdev_ops->ndo_init(dev);
        if (ret)
            goto out;
    }

    /* 커널 소스 분석: sysfs 등록 → /sys/class/net/<name>/ 생성 */
    ret = netdev_register_kobject(dev);
    if (ret)
        goto err_uninit;

    /* 커널 소스 분석: 상태 전이 - UNINITIALIZED → REGISTERED */
    dev->reg_state = NETREG_REGISTERED;

    /* 커널 소스 분석: 해시 테이블 삽입
     * name_hlist: 이름 기반 검색용 (dev_get_by_name)
     * index_hlist: 인덱스 기반 검색용 (dev_get_by_index) */
    list_netdevice(dev);

    /* 커널 소스 분석: 등록 알림 발송
     * 방화벽, 라우팅, netfilter 등 관심 모듈에 통지 */
    call_netdevice_notifiers(NETDEV_REGISTER, dev);

    return 0;

err_uninit:
    if (dev->netdev_ops->ndo_uninit)
        dev->netdev_ops->ndo_uninit(dev);
out:
    return ret;
}

unregister_netdev() 내부와 netdev_run_todo()

네트워크 디바이스의 해제(Unregistration)는 등록보다 복잡합니다. 참조 카운트가 0이 될 때까지 실제 해제를 지연시키는 2단계 프로세스(Two-Phase Process)를 사용합니다.

/* 커널 소스 분석: net/core/dev.c - unregister_netdev() */
void unregister_netdev(struct net_device *dev)
{
    rtnl_lock();
    unregister_netdevice_queue(dev, NULL);
    rtnl_unlock();
}

/* 커널 소스 분석: net/core/dev.c - unregister_netdevice_queue()
 * RTNL 잠금 보유 상태에서 호출됨 */
void unregister_netdevice_queue(struct net_device *dev,
                                struct list_head *head)
{
    ASSERT_RTNL();

    /* 커널 소스 분석: 1단계 - 해제 마킹 */
    dev->reg_state = NETREG_UNREGISTERING;

    /* 인터페이스 DOWN 처리 */
    if (dev->flags & IFF_UP)
        dev_close(dev);

    /* 해시 테이블에서 제거 */
    unlist_netdevice(dev);

    /* 알림 발송: 관련 모듈이 참조를 해제하도록 요청 */
    call_netdevice_notifiers(NETDEV_UNREGISTER, dev);

    /* 커널 소스 분석: 2단계 - todo 리스트에 추가
     * RTNL 잠금 범위 내에서는 즉시 해제하지 않음
     * rtnl_unlock() 시 netdev_run_todo() 자동 호출 */
    if (head) {
        list_add_tail(&dev->todo_list, head);
    } else {
        list_add_tail(&dev->todo_list, &net_todo_list);
    }
}

/* 커널 소스 분석: net/core/dev.c - netdev_run_todo()
 * rtnl_unlock() 내부에서 자동 호출됨 */
void netdev_run_todo(void)
{
    struct net_device *dev, *tmp;
    struct list_head list;

    /* todo 리스트를 로컬 리스트로 이동 (RTNL 밖에서 처리) */
    list_replace_init(&net_todo_list, &list);

    list_for_each_entry_safe(dev, tmp, &list, todo_list) {
        /* 커널 소스 분석: 참조 카운트가 0이 될 때까지 대기
         * RCU grace period 경과 + 모든 dev_put() 완료 대기
         * 타임아웃 시 경고 메시지 출력 */
        netdev_wait_allrefs_any(dev);

        /* sysfs 제거 */
        netdev_unregister_kobject(dev);

        /* 최종 상태 전이 */
        dev->reg_state = NETREG_UNREGISTERED;

        /* ndo_uninit 콜백 호출 */
        if (dev->netdev_ops->ndo_uninit)
            dev->netdev_ops->ndo_uninit(dev);

        /* NETDEV_UNREGISTER_FINAL 알림 (완전 해제 완료) */
        call_netdevice_notifiers(NETDEV_UNREGISTER_FINAL, dev);
    }
}

free_netdev() 내부

free_netdev()는 alloc_netdev_mqs()가 할당한 모든 리소스를 해제합니다. 반드시 unregister_netdev() 이후에 호출해야 합니다.

/* 커널 소스 분석: net/core/dev.c - free_netdev() */
void free_netdev(struct net_device *dev)
{
    /* 커널 소스 분석: 등록된 상태에서 free_netdev 호출 시 경고 */
    if (dev->reg_state == NETREG_REGISTERED)
        WARN_ON(1);  /* BUG: unregister 없이 free 시도 */

    /* 커널 소스 분석: TX/RX 큐 해제
     * alloc_netdev_mqs()에서 별도 kmalloc_array로 할당했으므로
     * net_device 본체와 별도로 해제 */
    netif_free_tx_queues(dev);
    netif_free_rx_queues(dev);

    /* MAC 주소 리스트 해제 */
    dev_addr_flush(dev);

    /* XPS(Transmit Packet Steering) CPU/RX 맵 해제 */
    netif_reset_xps_queues_gt(dev, 0);

    /* 커널 소스 분석: 최종 상태 전이 */
    dev->reg_state = NETREG_RELEASED;

    /* 커널 소스 분석: net_device 메모리 해제
     * kvzalloc으로 할당했으므로 kvfree 사용
     * (내부적으로 vmalloc/kmalloc 여부 판단) */
    kvfree(dev);
}

dev_get_by_name() / dev_get_by_index() 내부

커널은 네트워크 디바이스를 이름(Name) 또는 인덱스(Index)로 빠르게 검색하기 위해 네임스페이스(Namespace)별 해시 테이블을 유지합니다.

/* 커널 소스 분석: net/core/dev.c - dev_get_by_name() */
struct net_device *dev_get_by_name(struct net *net, const char *name)
{
    struct net_device *dev;

    /* 커널 소스 분석: RCU 읽기 잠금으로 해시 테이블 검색 */
    rcu_read_lock();
    dev = dev_get_by_name_rcu(net, name);

    /* 커널 소스 분석: 찾았으면 참조 카운트 증가
     * 호출자가 dev_put()으로 해제해야 함 */
    if (dev)
        dev_hold(dev);
    rcu_read_unlock();

    return dev;
}

/* 커널 소스 분석: net/core/dev.c - dev_get_by_name_rcu()
 * RCU 읽기 구간 내에서만 유효한 포인터 반환
 * 참조 카운트를 증가시키지 않음 → 가볍지만 수명 제한 */
struct net_device *dev_get_by_name_rcu(struct net *net, const char *name)
{
    struct netdev_name_node *node;
    unsigned int hash;

    /* 커널 소스 분석: 이름을 해시 키로 변환 후 해시 테이블 검색
     * full_name_hash()는 djb2 기반 해시 함수 */
    hash = full_name_hash(net, name, strnlen(name, IFNAMSIZ));
    hlist_for_each_entry_rcu(node, &net->dev_name_head[hash & (NETDEV_HASHENTRIES - 1)],
                             hlist) {
        if (!strcmp(node->name, name))
            return node->dev;
    }
    return NULL;
}

/* 커널 소스 분석: net/core/dev.c - dev_get_by_index()
 * 이름 기반과 동일 패턴: RCU 검색 + dev_hold() */
struct net_device *dev_get_by_index(struct net *net, int ifindex)
{
    struct net_device *dev;

    rcu_read_lock();
    dev = dev_get_by_index_rcu(net, ifindex);
    if (dev)
        dev_hold(dev);
    rcu_read_unlock();

    return dev;
}

netdev_priv() 구현

netdev_priv()은 커널에서 가장 자주 호출되는 네트워크 인라인 함수(Inline Function) 중 하나입니다. net_device 포인터로부터 드라이버 사설 데이터의 시작 주소를 산출합니다.

/* 커널 소스 분석: include/linux/netdevice.h - netdev_priv() */
static inline void *netdev_priv(const struct net_device *dev)
{
    /* 커널 소스 분석: 단순 포인터 산술
     * net_device 구조체 바로 뒤, NETDEV_ALIGN 경계에 위치
     * 별도 메모리 할당 없이 한 블록 안에서 오프셋 계산 */
    return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN);
}

/* 커널 소스 분석: NETDEV_ALIGN 정의 */
#define NETDEV_ALIGN    32
/* SMP 캐시 라인 크기(보통 64바이트)와 별개로,
 * net_device/private 경계를 32바이트로 정렬하여
 * 하드웨어 DMA 엔진의 정렬 요구사항 충족 */

드라이버에서의 전형적인 사용 패턴은 다음과 같습니다.

/* 커널 소스 분석: 드라이버에서 netdev_priv() 사용 예시 */
struct my_priv {
    struct pci_dev   *pdev;
    void __iomem    *mmio_base;
    struct napi_struct napi;
    spinlock_t      lock;
    /* ... 드라이버별 필드 */
};

static int my_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
    struct net_device *ndev;
    struct my_priv *priv;

    /* sizeof(struct my_priv)만큼 private 영역 확보 */
    ndev = alloc_etherdev(sizeof(struct my_priv));
    if (!ndev)
        return -ENOMEM;

    /* 별도 할당 없이 포인터 산술로 즉시 접근 가능
     * → 할당 오버헤드 제로, 캐시 지역성 우수 */
    priv = netdev_priv(ndev);
    priv->pdev = pdev;
    spin_lock_init(&priv->lock);

    /* ... 하드웨어 초기화 */
}

핵심 콜백: net_device_ops 전체 분석

net_device_ops는 커널 6.x 기준 약 60개 이상의 콜백 함수 포인터(Callback Function Pointer)를 정의하는 거대한 구조체입니다. 네트워크 드라이버의 모든 동작 — 장치 수명주기, 데이터 전송, 주소 필터링, 오프로드 설정, 가상화 지원 — 이 이 구조체를 통해 커널 네트워크 스택과 계약(Contract)을 맺습니다. 드라이버가 모든 콜백을 구현할 필요는 없지만, 구현하는 각 콜백의 호출 컨텍스트(RTNL 보호 여부, softirq/process context), 반환값 계약(소유권 이전 규칙), 동시성 보장(어떤 락이 잡혀 있는지)을 정확히 이해해야 합니다. 잘못된 컨텍스트 가정은 데드락, 메모리 누수, 데이터 손상의 직접적 원인이 됩니다.

그룹별 콜백 종합 테이블

아래 테이블은 net_device_ops의 주요 콜백을 기능 그룹별로 분류하고, 각 콜백의 호출 시점, 실행 컨텍스트, 핵심 책임, 필수 여부를 정리한 것입니다.

그룹 A — 수명주기(Lifecycle)

그룹 B — 데이터 경로(Data Path)

그룹 C — 주소/필터 설정

그룹 D — VLAN

그룹 E — Feature/오프로드(Offload)

그룹 F — TC/XDP 오프로드

그룹 G — 브릿지/FDB

그룹 H — 에러/복구

그룹 I — ioctl/확장

그룹 J — 가상화(SR-IOV)

그룹 K — 네임스페이스/링크

ndo_open / ndo_stop 상세 분석

ndo_open()은 네트워크 장치가 "UP" 상태로 전환될 때 호출되며, 하드웨어를 완전한 동작 상태로 만드는 책임을 집니다. 이 콜백 내부의 초기화 순서는 엄격하게 지켜야 하며, 순서가 뒤바뀌면 인터럽트가 발생했을 때 아직 준비되지 않은 자료구조에 접근하여 커널 패닉이 발생할 수 있습니다.

/* 커널 소스 분석: ndo_open 구현의 올바른 초기화 순서 */
static int mydrv_open(struct net_device *dev)
{
    struct mydrv_priv *priv = netdev_priv(dev);
    int err;

    /* 1단계: DMA 링 버퍼 할당
     *   IRQ 요청 전에 반드시 완료해야 함.
     *   인터럽트 핸들러가 참조할 descriptor ring이
     *   아직 없으면 NULL 역참조 발생 */
    err = mydrv_alloc_rings(priv);
    if (err)
        return err;

    /* 2단계: HW 초기화 — MAC, 필터, DMA 엔진 활성화
     *   링 버퍼 주소를 HW 레지스터에 기록 */
    mydrv_hw_init(priv);

    /* 3단계: NAPI 활성화
     *   IRQ 핸들러가 napi_schedule()을 호출하기 전에
     *   NAPI가 활성화 상태여야 함.
     *   napi_enable() 없이 napi_schedule() → BUG_ON */
    for (int i = 0; i < priv->num_queues; i++)
        napi_enable(&priv->queues[i].napi);

    /* 4단계: IRQ 요청 (인터럽트 활성화)
     *   NAPI 활성화 이후에 요청해야 안전.
     *   MSI-X: 큐별 개별 IRQ 할당 */
    err = mydrv_request_irqs(priv);
    if (err)
        goto err_disable_napi;

    /* 5단계: carrier 상태 설정
     *   PHY 링크가 확인되면 carrier on */
    if (mydrv_link_is_up(priv))
        netif_carrier_on(dev);
    else
        netif_carrier_off(dev);

    /* 6단계: TX 큐 시작 — 반드시 마지막
     *   모든 준비가 완료된 후에만 패킷 수신/송신 허용.
     *   이 시점부터 ndo_start_xmit이 호출될 수 있음 */
    netif_tx_start_all_queues(dev);

    return 0;

err_disable_napi:
    for (int i = 0; i < priv->num_queues; i++)
        napi_disable(&priv->queues[i].napi);
    mydrv_free_rings(priv);
    return err;
}

ndo_stop()은 ndo_open()의 정확한 역순으로 자원을 해제해야 합니다. 순서를 지키지 않으면 해제 중에 인터럽트가 발생하여 이미 해제된 메모리에 접근하는 use-after-free가 발생합니다.

/* 커널 소스 분석: ndo_stop 구현의 올바른 해제 순서
 * ndo_open의 정확한 역순이어야 함 */
static int mydrv_stop(struct net_device *dev)
{
    struct mydrv_priv *priv = netdev_priv(dev);

    /* 1단계: TX 큐 정지 — 가장 먼저
     *   새로운 패킷이 ndo_start_xmit으로 들어오는 것을 차단 */
    netif_tx_stop_all_queues(dev);

    /* 2단계: carrier off */
    netif_carrier_off(dev);

    /* 3단계: IRQ 해제
     *   더 이상 새로운 인터럽트가 발생하지 않도록 보장.
     *   free_irq()는 현재 실행 중인 핸들러 완료를 기다림 */
    mydrv_free_irqs(priv);

    /* 4단계: NAPI 비활성화
     *   napi_disable()은 진행 중인 poll 완료를 기다림.
     *   IRQ 해제 후 호출해야 새로운 napi_schedule 방지 */
    for (int i = 0; i < priv->num_queues; i++)
        napi_disable(&priv->queues[i].napi);

    /* 5단계: HW 비활성화 — DMA 엔진 정지
     *   NAPI 비활성화 후에 해야 DMA 완료 이벤트가
     *   poll에 의해 정리된 후 엔진을 멈춤 */
    mydrv_hw_shutdown(priv);

    /* 6단계: DMA 링 해제 — 가장 마지막
     *   HW와 NAPI 모두 정지한 후에만 안전하게 해제 가능 */
    mydrv_free_rings(priv);

    return 0;
}

ndo_start_xmit 심층 분석

ndo_start_xmit()은 네트워크 스택의 TX(송신) 경로 최종 진입점으로, 상위 계층에서 구성된 sk_buff를 하드웨어 TX 링에 전달하는 역할을 합니다. 이 콜백은 성능 최적화의 핵심이며, 호출 빈도가 매우 높아 모든 코드 경로를 최적화해야 합니다.

커널 소스 분석: ndo_start_xmit 호출 경로

 상위 계층 (TCP/UDP/IP)
      │
      ▼
 dev_queue_xmit(skb)           ← net/core/dev.c
      │
      ▼
 __dev_queue_xmit(skb)
      │
      ├─ netdev_pick_tx()      ← TX 큐 선택 (ndo_select_queue)
      │
      ▼
 __dev_xmit_skb(skb, q, dev, txq)
      │
      ├─ qdisc가 있으면 → qdisc 큐에 enqueue
      │                    → sch_direct_xmit() 에서 dequeue 후 전송
      ├─ noqueue (loopback 등) → 직접 전송
      │
      ▼
 dev_hard_start_xmit(skb, dev, txq)
      │
      ▼
 netdev_start_xmit(skb, dev, txq, more)
      │
      ▼
 ops->ndo_start_xmit(skb, dev)   ← 드라이버 콜백 진입

반환값 계약(Return Value Contract)은 다음과 같습니다:

/* 커널 소스 분석: ndo_start_xmit 반환값 계약 */

/* NETDEV_TX_OK (0):
 *   - skb 소유권이 드라이버로 완전히 이전됨
 *   - 드라이버가 skb를 consume하거나, DMA 완료 후 free 해야 함
 *   - 호출자는 skb를 더 이상 참조하지 않음
 *   - 실패 시에도 skb를 free하고 TX_OK를 반환하는 것이 일반적 */
#define NETDEV_TX_OK     0x00

/* NETDEV_TX_BUSY:
 *   - skb 소유권이 호출자에게 유지됨 (드라이버가 free하면 안 됨)
 *   - 큐가 다시 시도해야 함을 의미
 *   - 현대 드라이버에서는 사용을 강력히 비권장
 *   - 대신: 큐가 차면 netif_tx_stop_queue()를 호출하고
 *           TX_OK를 반환, TX 완료 인터럽트에서 wake */
#define NETDEV_TX_BUSY   0x10

/* 커널 소스 분석: ndo_start_xmit 구현 패턴 */
static netdev_tx_t mydrv_start_xmit(struct sk_buff *skb,
                                      struct net_device *dev)
{
    struct mydrv_priv *priv = netdev_priv(dev);
    struct mydrv_tx_ring *ring;
    u16 qid = skb_get_queue_mapping(skb);

    ring = &priv->tx_rings[qid];

    /* linearization: HW가 scatter-gather를 지원하지 않거나
     * fragment 수가 HW descriptor 한계를 초과할 때 필요 */
    if (skb_shinfo(skb)->nr_frags > ring->max_frags) {
        if (skb_linearize(skb)) {
            dev_kfree_skb_any(skb);
            dev->stats.tx_dropped++;
            return NETDEV_TX_OK; /* skb 소비했으므로 TX_OK */
        }
    }

    /* TX descriptor가 부족하면 큐 정지 */
    if (mydrv_tx_avail(ring) < mydrv_tx_desc_needed(skb)) {
        netif_tx_stop_queue(netdev_get_tx_queue(dev, qid));

        /* 경쟁 조건 방지: 정지 직후 완료 인터럽트로
         * 공간이 확보되었을 수 있으므로 재확인 */
        smp_mb();
        if (mydrv_tx_avail(ring) >= mydrv_tx_desc_needed(skb)) {
            netif_tx_wake_queue(netdev_get_tx_queue(dev, qid));
        } else {
            return NETDEV_TX_BUSY;
        }
    }

    /* DMA 매핑 및 descriptor 채우기 */
    mydrv_tx_map(ring, skb);

    /* skb->xmit_more (netdev_xmit_more()):
     *   true면 뒤에 더 많은 패킷이 올 예정이므로
     *   doorbell(HW 알림)을 지연하여 배치 처리.
     *   false면 즉시 doorbell을 울려 HW에 전송 시작 알림 */
    if (!netdev_xmit_more())
        mydrv_ring_doorbell(ring);

    return NETDEV_TX_OK;
}

ndo_set_rx_mode 상세 분석

ndo_set_rx_mode()는 네트워크 장치의 수신 필터(Receive Filter)를 업데이트할 때 호출됩니다. 멀티캐스트 그룹 가입/탈퇴, 유니캐스트 주소 추가, 무차별 모드(Promiscuous Mode) 전환 시 커널이 이 콜백을 호출하여 드라이버에 HW 필터 재프로그래밍을 요청합니다.

/* 커널 소스 분석: ndo_set_rx_mode 구현 패턴 */
static void mydrv_set_rx_mode(struct net_device *dev)
{
    struct mydrv_priv *priv = netdev_priv(dev);
    u32 filter_flags = 0;

    /* 1. 전역 필터 플래그 확인
     *    IFF_PROMISC: 모든 프레임 수신 (tcpdump 등)
     *    IFF_ALLMULTI: 모든 멀티캐스트 프레임 수신 */
    if (dev->flags & IFF_PROMISC) {
        filter_flags |= MYDRV_FILTER_PROMISC;
        goto apply;
    }

    if (dev->flags & IFF_ALLMULTI) {
        filter_flags |= MYDRV_FILTER_ALLMULTI;
    } else {
        /* 2. 멀티캐스트 주소 목록 순회
         *    dev->mc: 멀티캐스트 주소 리스트 (netdev_hw_addr_list)
         *    HW 필터 테이블 용량 초과 시 ALLMULTI fallback */
        struct netdev_hw_addr *ha;
        int mc_count = 0;

        netdev_for_each_mc_addr(ha, dev) {
            if (mc_count >= MYDRV_MAX_MC_ENTRIES) {
                /* HW 필터 테이블 가득 참 → promiscuous fallback */
                filter_flags |= MYDRV_FILTER_ALLMULTI;
                break;
            }
            mydrv_write_mc_filter(priv, mc_count, ha->addr);
            mc_count++;
        }
        mydrv_set_mc_count(priv, mc_count);
    }

    /* 3. 유니캐스트 주소 목록 순회
     *    dev->uc: 보조 유니캐스트 주소 리스트
     *    macvlan 등에서 여러 유니캐스트 주소를 등록 */
    {
        struct netdev_hw_addr *ha;
        int uc_count = 0;

        netdev_for_each_uc_addr(ha, dev) {
            if (uc_count >= MYDRV_MAX_UC_ENTRIES) {
                filter_flags |= MYDRV_FILTER_PROMISC;
                break;
            }
            mydrv_write_uc_filter(priv, uc_count, ha->addr);
            uc_count++;
        }
        mydrv_set_uc_count(priv, uc_count);
    }

apply:
    /* 4. 필터 플래그를 HW 레지스터에 기록 */
    mydrv_write_filter_flags(priv, filter_flags);
}

ndo_change_mtu 상세 분석

ndo_change_mtu()는 사용자가 ip link set dev eth0 mtu 9000과 같이 MTU를 변경할 때 호출됩니다. 커널 코어(dev_set_mtu())가 dev->min_mtu / dev->max_mtu 범위 검증을 먼저 수행하므로, 드라이버는 HW 특화 검증과 실제 적용만 담당하면 됩니다.

/* 커널 소스 분석: dev_set_mtu() → ndo_change_mtu 호출 경로
 * net/core/dev.c */
static int dev_set_mtu_ext(struct net_device *dev, int new_mtu)
{
    /* 코어가 min_mtu / max_mtu 검증을 수행 */
    if (new_mtu < dev->min_mtu || new_mtu > dev->max_mtu)
        return -EINVAL;

    if (ops->ndo_change_mtu)
        err = ops->ndo_change_mtu(dev, new_mtu);
    else
        WRITE_ONCE(dev->mtu, new_mtu); /* 콜백 NULL → 자동 적용 */

    /* ... */
}

/* 커널 소스 분석: ndo_change_mtu 구현 패턴
 * running 상태에서 MTU 변경 시 stop/restart 필요 */
static int mydrv_change_mtu(struct net_device *dev, int new_mtu)
{
    struct mydrv_priv *priv = netdev_priv(dev);
    bool running = netif_running(dev);

    /* HW 특화 검증: 예를 들어 특정 MTU는 alignment 필요 */
    if (new_mtu % 4 != 0)
        return -EINVAL;

    /* running 상태에서는 ring 크기 변경이 필요할 수 있음.
     * 안전하게 stop → 변경 → restart 수행 */
    if (running)
        mydrv_stop(dev);

    /* RX 버퍼 크기를 새 MTU에 맞게 재계산 */
    priv->rx_buf_size = SKB_DATA_ALIGN(new_mtu + ETH_HLEN +
                                         ETH_FCS_LEN + VLAN_HLEN);
    WRITE_ONCE(dev->mtu, new_mtu);

    if (running)
        mydrv_open(dev);

    return 0;
}

ndo_get_stats64 상세 분석

ndo_get_stats64()는 ip -s link show, /proc/net/dev 조회, SNMP MIB 수집 등 여러 경로에서 네트워크 통계를 요청할 때 호출됩니다. 현대 드라이버는 per-CPU 통계를 사용하여 캐시라인 경합(Cache Line Bouncing)을 방지합니다.

/* 커널 소스 분석: per-CPU 통계 구조체와 u64_stats_sync */
struct mydrv_stats {
    u64 rx_packets;
    u64 rx_bytes;
    u64 tx_packets;
    u64 tx_bytes;
    struct u64_stats_sync syncp; /* 32비트 arch에서 64비트 원자적 읽기 보장 */
};

/* 드라이버 초기화에서:
 *   priv->pcpu_stats = netdev_alloc_pcpu_stats(struct mydrv_stats); */

/* TX 경로에서 통계 갱신 (per-CPU, 락 불필요) */
static void mydrv_tx_complete(struct mydrv_priv *priv,
                               unsigned int bytes)
{
    struct mydrv_stats *stats = this_cpu_ptr(priv->pcpu_stats);

    u64_stats_update_begin(&stats->syncp);
    stats->tx_packets++;
    stats->tx_bytes += bytes;
    u64_stats_update_end(&stats->syncp);
}

/* 커널 소스 분석: ndo_get_stats64 구현
 * 모든 CPU의 per-CPU 통계를 합산 */
static void mydrv_get_stats64(struct net_device *dev,
                                struct rtnl_link_stats64 *s)
{
    struct mydrv_priv *priv = netdev_priv(dev);
    int cpu;

    for_each_possible_cpu(cpu) {
        struct mydrv_stats *stats = per_cpu_ptr(priv->pcpu_stats, cpu);
        u64 rx_packets, rx_bytes, tx_packets, tx_bytes;
        unsigned int start;

        /* u64_stats_fetch_begin: 32비트 아키텍처에서
         * 64비트 값의 상위/하위 32비트가 일관되게 읽히도록 보장.
         * 64비트 arch에서는 no-op으로 최적화됨 */
        do {
            start = u64_stats_fetch_begin(&stats->syncp);
            rx_packets = stats->rx_packets;
            rx_bytes   = stats->rx_bytes;
            tx_packets = stats->tx_packets;
            tx_bytes   = stats->tx_bytes;
        } while (u64_stats_fetch_retry(&stats->syncp, start));

        s->rx_packets += rx_packets;
        s->rx_bytes   += rx_bytes;
        s->tx_packets += tx_packets;
        s->tx_bytes   += tx_bytes;
    }
}

ndo_features_check / ndo_fix_features / ndo_set_features 상호작용

네트워크 오프로드 기능(Feature)의 변경은 세 가지 콜백이 협력하여 처리됩니다. 이 세 콜백은 서로 다른 시점에 호출되며, 각각의 역할이 명확히 구분됩니다.

/* 커널 소스 분석: ndo_fix_features — HW 제약 강제 적용 */
static netdev_features_t mydrv_fix_features(struct net_device *dev,
                                              netdev_features_t features)
{
    /* HW 제약: TSO가 없으면 TX checksum offload 불가
     * TSO는 CSUM을 전제로 하므로, CSUM이 꺼지면 TSO도 꺼야 함 */
    if (!(features & NETIF_F_HW_CSUM))
        features &= ~(NETIF_F_TSO | NETIF_F_TSO6);

    /* HW 제약: scatter-gather 없으면 TSO 불가 */
    if (!(features & NETIF_F_SG))
        features &= ~(NETIF_F_TSO | NETIF_F_TSO6);

    return features;
}

/* 커널 소스 분석: ndo_set_features — 실제 HW 레지스터 변경 */
static int mydrv_set_features(struct net_device *dev,
                               netdev_features_t features)
{
    struct mydrv_priv *priv = netdev_priv(dev);
    netdev_features_t changed = features ^ dev->features;

    if (changed & NETIF_F_RXCSUM)
        mydrv_set_rx_csum(priv, !!(features & NETIF_F_RXCSUM));

    if (changed & (NETIF_F_TSO | NETIF_F_TSO6))
        mydrv_set_tso(priv, !!(features & NETIF_F_TSO));

    if (changed & NETIF_F_HW_VLAN_CTAG_RX)
        mydrv_set_vlan_strip(priv, !!(features & NETIF_F_HW_VLAN_CTAG_RX));

    return 0;
}

/* 커널 소스 분석: ndo_features_check — per-skb 호환성 검사
 * 터널 패킷 등 HW가 처리할 수 없는 조합 감지 */
static netdev_features_t mydrv_features_check(struct sk_buff *skb,
                                                 struct net_device *dev,
                                                 netdev_features_t features)
{
    /* 기본 VXLAN/GRE/Geneve 검사 적용 */
    features = vlan_features_check(skb, features);
    features = vxlan_features_check(skb, features);

    /* HW 제한: inner header offset이 256바이트 초과 시
     * TSO offload 불가 → SW로 fallback */
    if (skb_is_gso(skb) &&
        skb_inner_transport_offset(skb) > 256)
        features &= ~(NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_GSO_GRE);

    return features;
}

ndo_bpf / ndo_xdp_xmit 상세 분석

XDP(eXpress Data Path) 지원은 두 개의 콜백으로 구성됩니다. ndo_bpf()는 제어 경로(Control Path)에서 XDP 프로그램의 설치/제거를 처리하고, ndo_xdp_xmit()은 데이터 경로(Data Path)에서 XDP_TX/XDP_REDIRECT 액션의 프레임을 실제로 전송합니다.

/* 커널 소스 분석: ndo_bpf 구현 패턴
 * XDP 프로그램 설치/제거 처리 */
static int mydrv_bpf(struct net_device *dev, struct netdev_bpf *bpf)
{
    struct mydrv_priv *priv = netdev_priv(dev);

    switch (bpf->command) {
    case XDP_SETUP_PROG: {
        /* 소프트웨어 XDP 프로그램 설치 (드라이버 모드)
         * - RX ring에 XDP를 위한 headroom 확보 필요
         * - 기존 프로그램 교체 시 rcu_assign 사용 */
        struct bpf_prog *old_prog = priv->xdp_prog;
        struct bpf_prog *new_prog = bpf->prog;
        bool running = netif_running(dev);

        /* XDP 프로그램이 처음 설치될 때:
         * RX 버퍼에 XDP_PACKET_HEADROOM만큼 headroom 확보
         * → ring 재할당 필요 → stop/restart */
        if (running && (!!old_prog != !!new_prog)) {
            mydrv_stop(dev);
            priv->xdp_prog = new_prog;
            if (new_prog)
                priv->rx_headroom = XDP_PACKET_HEADROOM;
            else
                priv->rx_headroom = 0;
            mydrv_open(dev);
        } else {
            WRITE_ONCE(priv->xdp_prog, new_prog);
        }

        if (old_prog)
            bpf_prog_put(old_prog);

        return 0;
    }
    case XDP_SETUP_HW_OFFLOAD:
        /* SmartNIC HW 오프로드: BPF 프로그램을 NIC에 직접 로드
         * 대부분의 드라이버는 미지원 → -EOPNOTSUPP 반환 */
        return -EOPNOTSUPP;
    default:
        return -EINVAL;
    }
}

/* 커널 소스 분석: ndo_xdp_xmit — XDP 프레임 배치 전송
 * NAPI 컨텍스트(softirq)에서 호출됨 */
static int mydrv_xdp_xmit(struct net_device *dev, int n,
                           struct xdp_frame **frames,
                           u32 flags)
{
    struct mydrv_priv *priv = netdev_priv(dev);
    struct mydrv_tx_ring *ring;
    int i, sent = 0;

    /* XDP 전용 TX 큐 사용 (일반 TX 큐와 분리하여 락 경합 방지) */
    ring = &priv->tx_rings[priv->xdp_tx_queue];

    for (i = 0; i < n; i++) {
        if (mydrv_tx_avail(ring) == 0)
            break;
        mydrv_xdp_tx_map(ring, frames[i]);
        sent++;
    }

    /* XDP_XMIT_FLUSH: 배치 전송 완료 후 doorbell 알림
     * 이 플래그가 설정되어야만 HW가 전송을 시작
     * XDP_REDIRECT 배치의 마지막 호출에만 설정됨 */
    if (flags & XDP_XMIT_FLUSH)
        mydrv_ring_doorbell(ring);

    return sent; /* 실제 전송된 프레임 수 반환 */
}

콜백 미구현 시 기본 동작

드라이버가 특정 콜백을 NULL로 남겨두면 커널 코어가 기본 동작(Default Behavior)을 제공합니다. 아래 테이블은 주요 콜백이 NULL일 때의 동작을 정리한 것입니다.

RX 경로: IRQ, NAPI, budget 처리

수신 경로는 인터럽트 기반 진입 후 NAPI poll로 전환하는 모델이 표준입니다. 드라이버는 budget를 존중하며 완료 시 napi_complete_done()를 호출해야 합니다.

/* 개념 예시: IRQ top-half와 NAPI poll 연계 */
static irqreturn_t my_irq_handler(int irq, void *data)
{
    struct my_priv *priv = data;

    my_mask_rx_irq(priv);
    napi_schedule_irqoff(&priv->napi);
    return IRQ_HANDLED;
}

static int my_napi_poll(struct napi_struct *napi, int budget)
{
    struct my_priv *priv = container_of(napi, struct my_priv, napi);
    int work_done = 0;

    while (work_done < budget) {
        struct sk_buff *skb = my_rx_one_skb(priv);

        if (!skb)
            break;

        skb->protocol = eth_type_trans(skb, priv->ndev);
        napi_gro_receive(napi, skb);
        work_done++;
    }

    if (work_done < budget) {
        napi_complete_done(napi, work_done);
        my_unmask_rx_irq(priv);
    }

    return work_done;
}

RX 전체 파이프라인(Pipeline)

아래 다이어그램은 물리 와이어 수신부터 애플리케이션 소켓(Socket) 버퍼 도달까지의 전체 수신 경로를 보여줍니다. 각 단계에서 일어나는 핵심 동작에 주의하세요.

GRO (Generic Receive Offload) 동작 원리

GRO는 네트워크 스택 진입 전에 동일 flow의 연속 패킷들을 하나의 대형 sk_buff로 집계(merge)하여 프로토콜 스택 처리 횟수를 줄이는 소프트웨어 오프로드 기술입니다. 하드웨어 LRO(Large Receive Offload)와 달리 GRO는 프로토콜 레이어에서 stateless하게 동작하여 포워딩 환경에서도 안전하게 사용할 수 있습니다.

GRO 집계 과정은 다음과 같습니다:

1. NAPI poll에서 napi_gro_receive() 호출 시, GRO 엔진은 napi→gro_hash[] 테이블에서 동일 flow를 검색합니다.
2. 매칭되는 flow가 있으면 현재 패킷의 payload를 기존 skb의 frag_list 또는 frags[]에 병합합니다.
3. flow가 완료되거나(PSH, FIN 등) 타이머(Timer)/카운트 제한에 도달하면 집계된 대형 skb를 netif_receive_skb()로 전달합니다.
4. 매칭되지 않으면 새 flow 엔트리를 생성하거나 즉시 전달합니다.

/* GRO 수신 경로 핵심 흐름 (개념 예시) */
gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
{
    gro_result_t ret;

    skb_gro_reset_offset(skb);

    ret = dev_gro_receive(napi, skb);    /* flow 매칭 + 병합 시도 */

    switch (ret) {
    case GRO_MERGED:
    case GRO_MERGED_FREE:
        break;                              /* 병합 성공, skb 보관 */
    case GRO_HELD:
        break;                              /* 새 flow로 보관 */
    case GRO_NORMAL:
        gro_normal_one(napi, skb, 1);    /* GRO 불가, 즉시 전달 */
        break;
    case GRO_CONSUMED:
        break;
    }
    return ret;
}

/* NAPI poll 종료 시 GRO flush — 보관 중인 flow를 모두 전달 */
void napi_complete_done(struct napi_struct *napi, int work_done)
{
    gro_normal_list(napi);           /* 버퍼링된 GRO 패킷 일괄 전달 */
    /* ... napi state 전환, IRQ 재활성화 ... */
}

NAPI 상태 머신

NAPI는 명확한 상태 전환 규약을 가진 상태 머신으로 동작합니다. 드라이버가 이 규약을 정확히 따르지 않으면 인터럽트 누수(IRQ 재활성화 누락)나 poll 미진입 같은 심각한 버그가 발생합니다.

/* NAPI enable/disable 올바른 순서 (개념 예시) */

/* === ndo_open: 활성화 순서 === */
static int my_open(struct net_device *ndev)
{
    struct my_priv *priv = netdev_priv(ndev);

    /* 1. 하드웨어 초기화 (ring 할당, DMA 설정) */
    my_hw_init(priv);

    /* 2. NAPI 활성화 — 이 시점부터 napi_schedule 가능 */
    napi_enable(&priv->napi);

    /* 3. IRQ 등록 — NAPI enable 후에 해야 schedule이 동작 */
    request_irq(priv->irq, my_irq_handler, 0, "mynic", priv);

    /* 4. TX 큐 시작 */
    netif_tx_start_all_queues(ndev);

    return 0;
}

/* === ndo_stop: 비활성화 순서 === */
static int my_stop(struct net_device *ndev)
{
    struct my_priv *priv = netdev_priv(ndev);

    /* 1. TX 큐 정지 — 새 xmit 진입 차단 */
    netif_tx_disable(ndev);

    /* 2. IRQ 비활성화 — 새 napi_schedule 차단 */
    disable_irq(priv->irq);

    /* 3. napi_disable — 진행 중인 poll 완료를 대기 (barrier 역할) */
    napi_disable(&priv->napi);
    /* 이 시점 이후 poll 콜백이 절대 실행되지 않음을 보장 */

    /* 4. IRQ 해제 */
    free_irq(priv->irq, priv);

    /* 5. 하드웨어 정리 (ring 해제, DMA 해제) */
    my_hw_cleanup(priv);

    return 0;
}

TX 경로: ndo_start_xmit, 큐 정지/재개, BQL

송신 경로의 핵심은 링 용량 관리입니다. TX ring이 포화됐을 때는 NETDEV_TX_BUSY를 남발하지 말고 queue stop/wake 모델을 일관되게 유지해야 합니다.

/* 개념 예시: 멀티큐 TX stop/wake + BQL 경로 */
static netdev_tx_t my_ndo_start_xmit(struct sk_buff *skb, struct net_device *ndev)
{
    struct my_priv *priv = netdev_priv(ndev);
    struct netdev_queue *txq = netdev_get_tx_queue(ndev, skb_get_queue_mapping(skb));
    unsigned long flags;

    spin_lock_irqsave(&priv->tx_lock, flags);

    if (my_tx_ring_avail(priv) < MAX_SKB_FRAGS + 2) {
        netif_tx_stop_queue(txq);
        spin_unlock_irqrestore(&priv->tx_lock, flags);
        return NETDEV_TX_BUSY;
    }

    my_map_skb_to_tx_desc(priv, skb);
    netdev_tx_sent_queue(txq, skb->len);
    my_ring_doorbell(priv);

    spin_unlock_irqrestore(&priv->tx_lock, flags);
    return NETDEV_TX_OK;
}

static void my_tx_complete(struct my_priv *priv, u16 qid)
{
    struct netdev_queue *txq = netdev_get_tx_queue(priv->ndev, qid);
    u32 bytes = 0, pkts = 0;

    my_reclaim_tx_desc(priv, &bytes, &pkts);
    netdev_tx_completed_queue(txq, pkts, bytes);

    if (netif_tx_queue_stopped(txq) && my_tx_ring_avail(priv) > 64)
        netif_tx_wake_queue(txq);
}

TX 전체 파이프라인

아래 다이어그램은 유저스페이스 send() 호출부터 물리 와이어 송출, TX 완료 인터럽트, 디스크립터 회수까지의 전체 송신 경로를 보여줍니다.

BQL (Byte Queue Limits): 버퍼블로트 방지와 동적 큐 제한

BQL(Byte Queue Limits)은 커널 lib/dynamic_queue_limits.c에 구현된 동적 큐 깊이 제어 알고리즘입니다. NIC TX 큐에 쌓을 수 있는 바이트 수를 실시간(Real-time)으로 조정하여, 큐가 과도하게 깊어지는 버퍼블로트(bufferbloat)를 방지하면서도 충분한 처리량을 유지합니다. TX 경로 앞 절에서 netdev_tx_sent_queue/netdev_tx_completed_queue를 호출한 것이 바로 BQL API입니다. 이 절에서는 그 내부 알고리즘, 자료구조, sysfs 튜닝, 그리고 qdisc와의 상호작용을 깊이 있게 살펴봅니다.

버퍼블로트 문제와 BQL의 필요성

NIC의 TX ring이 크거나 드라이버가 큐 깊이를 제한하지 않으면, 상위 계층(qdisc, TCP 혼잡 제어(Congestion Control))이 내린 결정과 무관하게 수백 ms에서 수 초 분량의 패킷이 하드웨어 큐에 쌓일 수 있습니다. 이 "버퍼블로트"는 지연(latency)을 극적으로 증가시키면서 처리량(throughput)은 거의 높이지 않습니다. BQL은 "지금 하드웨어에 내려보낸 바이트"와 "아직 완료되지 않은 바이트"를 추적하여 큐 깊이를 필요 최소한으로 동적 조절합니다.

BQL 동작 원리: 동적 한계 조정 알고리즘

BQL의 핵심은 lib/dynamic_queue_limits.c에 구현된 DQL(Dynamic Queue Limits) 알고리즘입니다. 드라이버가 패킷을 큐에 넣을 때(dql_queued)와 완료될 때(dql_completed)를 추적하여, 현재 inflight(미완료) 바이트가 LIMIT을 초과하면 큐를 멈추고, 완료 시 실제 사용 패턴에 따라 LIMIT을 올리거나 내립니다.

/* DQL 알고리즘 의사코드 (lib/dynamic_queue_limits.c 기반) */

/* ① 드라이버가 패킷을 큐에 넣을 때 */
void dql_queued(struct dql *dql, u32 count)
{
    dql->last_obj_cnt  = count;
    dql->num_queued   += count;

    /* inflight = num_queued - num_completed */
    if (inflight >= dql->adj_limit)
        netif_tx_stop_queue();   /* 큐 정지 — LIMIT 도달 */
}

/* ② TX 완료 인터럽트에서 */
void dql_completed(struct dql *dql, u32 count)
{
    dql->num_completed += count;
    ovlimit = dql->num_queued - dql->num_completed - dql->limit;

    if (ovlimit <= 0) {
        /* BELOW: inflight가 LIMIT 아래 — 과잉 제거 */
        dql->slack = min(dql->slack, ovlimit + dql->slack_start);
        if (slack_expired)
            new_limit = dql->limit - (ovlimit + dql->slack);
    } else {
        /* ABOVE: inflight가 LIMIT 이상 — LIMIT 확장 */
        new_limit = dql->limit + count / 16;  /* 완료분의 1/16 증가 */
    }
    dql->limit = clamp(new_limit, dql->min_limit, dql->max_limit);

    if (inflight < dql->adj_limit)
        netif_tx_wake_queue();   /* 큐 재개 */
}

핵심 자료구조: struct dql

BQL의 상태는 struct dql(include/linux/dynamic_queue_limits.h)에 저장됩니다. 각 TX 큐(struct netdev_queue)마다 하나의 dql 인스턴스가 내장되어 있습니다.

/* include/linux/dynamic_queue_limits.h */
struct dql {
    unsigned int  num_queued;       /* 큐에 넣은 누적 바이트 (단조 증가) */
    unsigned int  adj_limit;        /* 현재 유효 한계 (limit - num_completed) */
    unsigned int  last_obj_cnt;     /* 마지막 dql_queued 호출의 count */

    unsigned int  limit       ____cacheline_aligned_in_smp;
                                     /* 동적 LIMIT (바이트 단위) */
    unsigned int  num_completed;    /* 완료된 누적 바이트 (단조 증가) */

    unsigned int  prev_ovlimit;     /* 이전 주기의 오버리밋 값 */
    unsigned int  prev_num_queued;  /* 이전 주기의 num_queued */
    unsigned int  prev_last_obj_cnt;/* 이전 주기의 last_obj_cnt */

    unsigned int  lowest_slack;     /* 관찰된 최소 여유분 */
    unsigned long slack_start_time; /* slack 관찰 시작 시각 */

    unsigned int  max_limit;        /* sysfs 설정: LIMIT 상한 (기본 DQL_MAX_LIMIT) */
    unsigned int  min_limit;        /* sysfs 설정: LIMIT 하한 (기본 0) */
    unsigned int  slack_hold_time;  /* slack 관찰 윈도우 (기본 HZ=1초) */
};

드라이버 API 통합

드라이버가 BQL을 사용하려면 TX 경로의 세 지점에서 API를 호출합니다. 모든 API는 바이트 단위로 동작하며, 패킷 수가 아닌 누적 바이트를 전달해야 합니다.

/* BQL 드라이버 API 3종 — 호출 시점과 인자 */

/* ① ndo_start_xmit() 내부, skb를 ring에 넣은 직후 */
netdev_tx_sent_queue(txq, skb->len);
/*  txq  : netdev_get_tx_queue(ndev, queue_index)
 *  bytes: 전송한 바이트 수 (skb->len)
 *  내부: dql_queued(&txq->dql, bytes)
 *  inflight ≥ limit이면 __netif_tx_stop_queue() 호출 */

/* ② TX 완료 인터럽트/NAPI에서, 디스크립터 회수 후 */
netdev_tx_completed_queue(txq, pkts, bytes);
/*  pkts : 완료된 패킷 수 (BQL 자체는 bytes만 사용)
 *  bytes: 완료된 바이트 수
 *  내부: dql_completed(&txq->dql, bytes)
 *  LIMIT 재조정 + 큐 wake 판단 */

/* ③ ndo_stop() 또는 링크 다운/리셋 시 */
netdev_tx_reset_queue(txq);
/*  모든 BQL 카운터 초기화 (num_queued, num_completed 등)
 *  인터페이스 down → up 사이클에서 반드시 호출
 *  빠뜨리면 stale 카운터로 큐가 영구 정지될 수 있음 */

sysfs 인터페이스와 튜닝

각 TX 큐의 BQL 파라미터는 /sys/class/net/<dev>/queues/tx-<N>/byte_queue_limits/ 경로에 노출됩니다. 운영 환경에서 BQL 동작을 관찰하고 미세 조정할 수 있는 핵심 인터페이스입니다.

# BQL sysfs 파일 확인 (예: eth0의 tx-0 큐)
ls /sys/class/net/eth0/queues/tx-0/byte_queue_limits/
# 출력: hold_time  inflight  limit  limit_max  limit_min

# 현재 동적 LIMIT 확인 (알고리즘이 결정한 값)
cat /sys/class/net/eth0/queues/tx-0/byte_queue_limits/limit

# inflight 바이트 확인 (현재 NIC에서 처리 중인 양)
cat /sys/class/net/eth0/queues/tx-0/byte_queue_limits/inflight

# LIMIT 상한 조정 (기본값: DQL_MAX_LIMIT = 매우 큰 값)
# 지연에 민감한 워크로드에서 상한을 낮추면 지연이 더 줄어들 수 있음
echo 30000 > /sys/class/net/eth0/queues/tx-0/byte_queue_limits/limit_max

# LIMIT 하한 조정 (기본값: 0)
# 너무 낮은 LIMIT으로 인한 성능 저하 방지
echo 1500 > /sys/class/net/eth0/queues/tx-0/byte_queue_limits/limit_min

# slack 관찰 윈도우 조정 (기본값: 1000 = HZ, 즉 1초)
cat /sys/class/net/eth0/queues/tx-0/byte_queue_limits/hold_time

# 모든 큐의 BQL limit 한 번에 확인
for q in /sys/class/net/eth0/queues/tx-*/byte_queue_limits/limit; do
    echo "$(dirname $(dirname $q)): $(cat $q)"
done

BQL과 qdisc/TC의 상호작용

BQL은 qdisc 아래, NIC ring 위에 위치합니다. 패킷 흐름에서 BQL의 정확한 위치를 이해하면 fq_codel 같은 AQM(Active Queue Management)과의 시너지를 극대화할 수 있습니다.

실전 디버깅(Debugging)과 모니터링

BQL이 올바르게 동작하는지 확인하고, 문제 발생 시 원인을 추적하는 방법입니다.

# ── BQL 상태 종합 확인 ──
# 모든 TX 큐의 limit과 inflight를 한 번에 출력
for q in /sys/class/net/eth0/queues/tx-*/byte_queue_limits; do
    echo "=== $(basename $(dirname $q)) ==="
    echo "  limit:    $(cat $q/limit)"
    echo "  inflight: $(cat $q/inflight)"
    echo "  max:      $(cat $q/limit_max)"
    echo "  min:      $(cat $q/limit_min)"
done

# ── tc 통계와 BQL 연계 확인 ──
# qdisc의 backlog과 BQL의 inflight를 비교하여 병목 위치 판단
tc -s qdisc show dev eth0

# ── bpftrace로 BQL limit 변화 실시간 추적 ──
# dql_completed 호출 시 limit 값 변화를 추적
bpftrace -e 'kprobe:dql_completed {
    $dql = (struct dql *)arg0;
    printf("cpu=%d limit=%u completed=%u\n",
           cpu, $dql->limit, arg1);
}'

# ── perf로 BQL 관련 함수 호출 빈도 확인 ──
perf stat -e 'probe:dql_queued,probe:dql_completed' -a sleep 5

# ── 문제 진단 체크리스트 ──
# 1. limit이 0이면? → netdev_tx_reset_queue() 누락 가능
# 2. inflight가 limit과 같고 큐 정지? → 정상 (완료 대기 중)
# 3. limit이 limit_max에 고정? → 트래픽이 항상 LIMIT 소진 → limit_max 낮출 것
# 4. limit이 매우 작고 throughput 저하? → limit_min을 MTU 이상으로 설정

LLTX (NETIF_F_LLTX): lockless TX 계약과 실무 주의점

NETIF_F_LLTX는 TX 잠금(Lock)을 네트워크 코어가 아닌 드라이버가 직접 책임지는 오래된 모델입니다. 즉, ndo_start_xmit() 동시 호출에 대한 직렬화(Serialization)/경합(Contention) 제어를 드라이버가 스스로 보장해야 하며, 큐 stop/wake, timeout 복구, completion 경로까지 하나의 동시성 계약으로 맞춰야 합니다.

LLTX를 유지해야 하는 코드베이스라면 아래 4가지를 반드시 고정 규칙으로 문서화해야 합니다.

1. xmit 직렬화 규칙
   ndo_start_xmit()의 re-entry 허용 범위(전역/큐별)를 명시하고 락 순서를 고정
2. queue 상태 전이 규칙
   netif_tx_stop_queue()/netif_tx_wake_queue() 호출 조건을 단일 함수로 중앙화
3. completion 메모리 순서
   descriptor reclaim 이후 wake 판단 전까지의 barrier 규칙을 아키텍처별로 검증
4. timeout 복구 규칙
   ndo_tx_timeout()에서 즉시 리셋하지 말고 workqueue로 이관해 중복 reset 방지

/* LLTX 유지보수 시 권장되는 최소 패턴 (개념 예시) */
static netdev_tx_t my_lltx_xmit(struct sk_buff *skb, struct net_device *ndev)
{
    struct my_priv *priv = netdev_priv(ndev);
    unsigned long flags;

    /* LLTX에서는 드라이버가 자체 직렬화를 반드시 보장 */
    spin_lock_irqsave(&priv->tx_lock, flags);

    if (!my_has_room(priv)) {
        my_stop_txq_if_needed(priv);
        spin_unlock_irqrestore(&priv->tx_lock, flags);
        return NETDEV_TX_BUSY;
    }

    my_post_desc(priv, skb);
    my_kick_doorbell(priv);
    spin_unlock_irqrestore(&priv->tx_lock, flags);
    return NETDEV_TX_OK;
}

통계와 ethtool 연동

운영 환경에서는 “성능이 안 나옵니다”보다 “왜 안 나오는가”를 보여주는 통계가 더 중요합니다. ethtool -S로 확인 가능한 드라이버 통계를 설계하면 장애 분석 시간이 크게 줄어듭니다.

/* 개념 예시: ethtool 통계 구조와 per-CPU 집계 */
struct my_pcpu_stats {
    u64 rx_packets;
    u64 rx_bytes;
    u64 tx_packets;
    u64 tx_bytes;
    struct u64_stats_sync syncp;
};

static void my_ndo_get_stats64(struct net_device *ndev,
                               struct rtnl_link_stats64 *stats)
{
    int cpu;

    for_each_possible_cpu(cpu) {
        struct my_pcpu_stats *pcpu = per_cpu_ptr(my_stats, cpu);
        u64 rx_pkts, rx_bytes, tx_pkts, tx_bytes;
        unsigned int start;

        do {
            start = u64_stats_fetch_begin(&pcpu->syncp);
            rx_pkts = pcpu->rx_packets;
            rx_bytes = pcpu->rx_bytes;
            tx_pkts = pcpu->tx_packets;
            tx_bytes = pcpu->tx_bytes;
        } while (u64_stats_fetch_retry(&pcpu->syncp, start));

        stats->rx_packets += rx_pkts;
        stats->rx_bytes += rx_bytes;
        stats->tx_packets += tx_pkts;
        stats->tx_bytes += tx_bytes;
    }
}

링크 계층: PHY, phylib, phylink

현대 NIC/MAC 드라이버는 PHY 연결을 phylink로 통합하는 추세입니다. SFP, fixed-link, in-band status를 동시에 다뤄야 하는 경우 phylink가 사실상 표준입니다.

/* 개념 예시: phylink 초기화와 플랫폼별 연결 분기 */
static const struct phylink_mac_ops my_phylink_ops = {
    .mac_config = my_mac_config,
    .mac_link_up = my_mac_link_up,
    .mac_link_down = my_mac_link_down,
};

static int my_phylink_init(struct my_priv *priv)
{
    struct phylink_config *cfg = &priv->phylink_config;
    struct fwnode_handle *fwnode = dev_fwnode(priv->dev);
    phy_interface_t iface = priv->phy_mode; /* DT/ACPI 설정에서 파생 */

    priv->phylink = phylink_create(cfg, fwnode, iface,
                                 &my_phylink_ops);
    if (IS_ERR(priv->phylink))
        return PTR_ERR(priv->phylink);

    /* 펌웨어 타입(OF/fwnode)에 맞는 connect 경로를 선택 */
    if (is_of_node(fwnode))
        return phylink_of_phy_connect(priv->phylink, to_of_node(fwnode), 0);
    return phylink_fwnode_phy_connect(priv->phylink, fwnode, 0);
}

phylib 상태 머신 내부 분석

커널의 PHY 추상화 계층(phylib)은 drivers/net/phy/phy.c에 구현된 상태 머신(State Machine)을 중심으로 동작합니다. phy_state_machine() 함수가 delayed_work로 주기적으로 호출되며, PHY의 링크 상태를 감시하고 MAC 드라이버에 변화를 통지합니다.

PHY 상태 머신은 다음 6개 상태를 순환합니다.

커널 소스 drivers/net/phy/phy.c의 phy_state_machine() 핵심 로직을 분석하면 다음과 같습니다.

/* drivers/net/phy/phy.c - phy_state_machine() 핵심 흐름 분석 */
void phy_state_machine(struct work_struct *work)
{
    struct phy_device *phydev =
        container_of(to_delayed_work(work),
                     struct phy_device, state_queue);
    bool needs_aneg = false, do_suspend = false;
    enum phy_state old_state;
    int err = 0;

    mutex_lock(&phydev->lock);
    old_state = phydev->state;

    switch (phydev->state) {
    case PHY_DOWN:
    case PHY_READY:
        break; /* 대기 상태 — 외부 이벤트 대기 */
    case PHY_UP:
        needs_aneg = true; /* Auto-Negotiation 시작 */
        break;
    case PHY_NOLINK:
    case PHY_RUNNING:
        err = phy_check_link_status(phydev); /* MDIO 레지스터 읽기 */
        break;
    case PHY_HALTED:
        if (phydev->link) {
            phydev->link = 0;
            phy_link_down(phydev);
        }
        do_suspend = true;
        break;
    }

    mutex_unlock(&phydev->lock);

    if (needs_aneg)
        err = phy_start_aneg(phydev);

    /* 상태 변경이 있으면 콜백 호출 */
    if (old_state != phydev->state) {
        phydev_dbg(phydev, "PHY state change %s -> %s\n",
                   phy_state_to_str(old_state),
                   phy_state_to_str(phydev->state));
        if (phydev->drv && phydev->drv->link_change_notify)
            phydev->drv->link_change_notify(phydev);
    }

    /* 정지 상태가 아니면 작업 큐 재스케줄 */
    if (!do_suspend && phy_polling_mode(phydev))
        phy_queue_state_machine(phydev, PHY_STATE_TIME);
}

phy_check_link_status()는 MDIO 레지스터를 읽어 실제 링크 상태를 확인하고, phy_link_up() 또는 phy_link_down()을 호출하여 adjust_link 콜백을 트리거합니다. 상태 전이 흐름을 다이어그램으로 표현하면 다음과 같습니다.

phylink 콜백과 MAC 드라이버 계약

phylink은 phylink_mac_ops 구조체를 통해 MAC 드라이버에 링크 설정 변경을 통지합니다. drivers/net/phy/phylink.c의 phylink_resolve()가 PHY/in-band 상태를 종합하여 MAC 콜백을 호출하는 중앙 분기점입니다.

커널 소스 phylink_resolve()의 핵심 흐름을 분석하면, PHY 상태와 in-band 상태를 종합하여 최종 링크 상태를 결정하는 과정을 확인할 수 있습니다.

/* drivers/net/phy/phylink.c - phylink_resolve() 핵심 흐름 분석 */
static void phylink_resolve(struct work_struct *w)
{
    struct phylink *pl = container_of(w, struct phylink, resolve);
    struct phylink_link_state link_state;
    bool cur_link_is_up;

    mutex_lock(&pl->state_mutex);
    cur_link_is_up = pl->old_link_state;

    /* 1단계: PCS/PHY 상태를 수집하여 link_state 결정 */
    phylink_resolve_an_pause(&link_state);

    if (pl->phydev)
        phylink_get_phy_state(pl, &link_state);

    if (pl->pcs)
        phylink_pcs_get_state(pl, &link_state);

    /* 2단계: 링크 상태가 변경된 경우에만 MAC 콜백 호출 */
    if (link_state.link != cur_link_is_up) {
        if (!link_state.link) {
            /* 링크 다운: mac_link_down 호출 */
            pl->mac_ops->mac_link_down(pl->config,
                pl->cur_link_an_mode, pl->cur_interface);
        } else {
            /* 링크 업: mac_prepare - mac_config - mac_finish - mac_link_up */
            if (pl->mac_ops->mac_prepare)
                pl->mac_ops->mac_prepare(pl->config,
                    pl->cur_link_an_mode, pl->cur_interface);

            pl->mac_ops->mac_config(pl->config,
                pl->cur_link_an_mode, &link_state);

            if (pl->mac_ops->mac_finish)
                pl->mac_ops->mac_finish(pl->config,
                    pl->cur_link_an_mode, pl->cur_interface);

            pl->mac_ops->mac_link_up(pl->config, pl->phydev,
                pl->cur_link_an_mode, pl->cur_interface,
                link_state.speed, link_state.duplex,
                !!(link_state.pause & MLO_PAUSE_TX),
                !!(link_state.pause & MLO_PAUSE_RX));
        }
        pl->old_link_state = link_state.link;
    }
    mutex_unlock(&pl->state_mutex);
}

실제 MAC 드라이버에서 phylink_mac_ops를 구현하는 전체 패턴은 다음과 같습니다.

/* phylink_mac_ops 전체 구현 예시 */
static void my_mac_config(struct phylink_config *config,
                          unsigned int mode,
                          const struct phylink_link_state *state)
{
    struct my_priv *priv = container_of(config, struct my_priv,
                                         phylink_config);
    u32 mac_ctrl = my_read_reg(priv, MAC_CTRL);

    /* speed 설정 */
    mac_ctrl &= ~MAC_SPEED_MASK;
    switch (state->speed) {
    case SPEED_10000: mac_ctrl |= MAC_SPEED_10G; break;
    case SPEED_1000:  mac_ctrl |= MAC_SPEED_1G;  break;
    case SPEED_100:   mac_ctrl |= MAC_SPEED_100; break;
    }

    /* duplex 설정 */
    if (state->duplex == DUPLEX_FULL)
        mac_ctrl |= MAC_FULL_DUPLEX;
    else
        mac_ctrl &= ~MAC_FULL_DUPLEX;

    /* pause 프레임 설정 */
    mac_ctrl &= ~(MAC_TX_PAUSE | MAC_RX_PAUSE);
    if (state->pause & MLO_PAUSE_TX)
        mac_ctrl |= MAC_TX_PAUSE;
    if (state->pause & MLO_PAUSE_RX)
        mac_ctrl |= MAC_RX_PAUSE;

    my_write_reg(priv, MAC_CTRL, mac_ctrl);
}

static void my_mac_link_up(struct phylink_config *config,
                           struct phy_device *phy,
                           unsigned int mode, phy_interface_t interface,
                           int speed, int duplex,
                           bool tx_pause, bool rx_pause)
{
    struct my_priv *priv = container_of(config, struct my_priv,
                                         phylink_config);

    /* MAC TX 활성화 */
    my_set_bits(priv, MAC_CTRL, MAC_TX_EN | MAC_RX_EN);

    /* 커널 네트워크 스택에 캐리어 상태 통지 */
    netif_carrier_on(priv->ndev);
    netif_tx_wake_all_queues(priv->ndev);
}

static void my_mac_link_down(struct phylink_config *config,
                             unsigned int mode,
                             phy_interface_t interface)
{
    struct my_priv *priv = container_of(config, struct my_priv,
                                         phylink_config);

    /* TX 큐 정지 후 MAC 비활성화 */
    netif_tx_stop_all_queues(priv->ndev);
    netif_carrier_off(priv->ndev);
    my_clear_bits(priv, MAC_CTRL, MAC_TX_EN);

    /* DMA 진행 중인 프레임 완료 대기 */
    my_drain_tx_dma(priv);
}

static const struct phylink_mac_ops my_phylink_mac_ops = {
    .mac_config    = my_mac_config,
    .mac_link_up   = my_mac_link_up,
    .mac_link_down = my_mac_link_down,
};

SFP 케이지와 sfp_bus 통합

SFP(Small Form-factor Pluggable) 모듈을 지원하는 드라이버는 sfp_bus 프레임워크를 통해 모듈 삽입/제거 이벤트를 처리합니다. SFP 모듈 내부에 PHY가 포함된 경우(예: 1000BASE-T SFP) 자동으로 PHY 탐색(Discovery)과 연결이 수행됩니다.

SFP 통합의 핵심 구조는 sfp_upstream_ops 콜백입니다. 드라이버는 이 콜백을 구현하여 모듈 이벤트에 대응합니다.

/* sfp_upstream_ops를 통한 SFP 케이지 통합 */
static int my_sfp_module_insert(void *priv,
                                const struct sfp_eeprom_id *id)
{
    struct my_priv *p = priv;

    /* SFP EEPROM에서 모듈 타입/속도 확인 */
    dev_info(p->dev, "SFP module inserted: %s\n",
             id->base.vendor_name);

    /* phylink에 SFP 모듈 정보 전달 */
    return phylink_sfp_module_insert(p->phylink, id);
}

static void my_sfp_module_remove(void *priv)
{
    struct my_priv *p = priv;

    phylink_sfp_module_remove(p->phylink);
}

static void my_sfp_link_down(void *priv)
{
    struct my_priv *p = priv;

    phylink_sfp_link_down(p->phylink);
}

static void my_sfp_link_up(void *priv)
{
    struct my_priv *p = priv;

    phylink_sfp_link_up(p->phylink);
}

static const struct sfp_upstream_ops my_sfp_ops = {
    .module_insert  = my_sfp_module_insert,
    .module_remove  = my_sfp_module_remove,
    .link_down      = my_sfp_link_down,
    .link_up        = my_sfp_link_up,
    .attach         = phy_sfp_attach,
    .detach         = phy_sfp_detach,
    .connect_phy    = phy_sfp_connect_phy,
    .disconnect_phy = phy_sfp_disconnect_phy,
};

/* 프로브 시점에서 SFP 버스 등록 */
static int my_probe_sfp(struct my_priv *priv)
{
    struct sfp_bus *sfp_bus;

    /* phylink_config에 SFP 지원 플래그 설정 */
    priv->phylink_config.type = PHYLINK_NETDEV;
    __set_bit(PHY_INTERFACE_MODE_SGMII,
              priv->phylink_config.supported_interfaces);
    __set_bit(PHY_INTERFACE_MODE_1000BASEX,
              priv->phylink_config.supported_interfaces);

    /* SFP 버스를 fwnode에서 검색하여 등록 */
    sfp_bus = sfp_bus_find_fwnode(dev_fwnode(priv->dev));
    if (sfp_bus)
        sfp_bus_add_upstream(sfp_bus, priv, &my_sfp_ops);

    return 0;
}

In-band Auto-Negotiation과 fixed-link

phylink은 PHY 직접 연결 외에도 두 가지 대안적 링크 모드를 지원합니다. SGMII/1000BASE-X에서 사용하는 인밴드 Auto-Negotiation(In-band AN)과, 링크 파라미터가 고정된 고정 링크(fixed-link) 모드입니다.

in-band AN은 SGMII에서 PHY가 MAC에게 링크 파라미터를 전달하는 방식입니다. PCS(Physical Coding Sublayer)가 SGMII 제어 워드를 파싱하여 speed/duplex를 추출합니다.

/* In-band AN 지원을 위한 PCS 구현 예시 */
static void my_pcs_get_state(struct phylink_pcs *pcs,
                             struct phylink_link_state *state)
{
    struct my_pcs *mpcs = container_of(pcs, struct my_pcs, pcs);
    u32 status = my_pcs_read(mpcs, PCS_STATUS_REG);

    state->link = !!(status & PCS_LINK_UP);
    state->an_complete = !!(status & PCS_AN_COMPLETE);

    if (state->link) {
        /* SGMII 제어 워드에서 speed/duplex 추출 */
        u32 lpa = my_pcs_read(mpcs, PCS_LP_ABILITY_REG);

        switch ((lpa >> 10) & 0x3) {
        case 0: state->speed = SPEED_10;   break;
        case 1: state->speed = SPEED_100;  break;
        case 2: state->speed = SPEED_1000; break;
        }
        state->duplex = (lpa & PCS_SGMII_DUPLEX) ?
                        DUPLEX_FULL : DUPLEX_HALF;
    }
}

static int my_pcs_config(struct phylink_pcs *pcs,
                         unsigned int neg_mode,
                         phy_interface_t interface,
                         const unsigned long *advertising,
                         bool permit_pause_to_mac)
{
    struct my_pcs *mpcs = container_of(pcs, struct my_pcs, pcs);

    if (neg_mode == PHYLINK_PCS_NEG_INBAND_ENABLED) {
        /* In-band AN 활성화 */
        my_pcs_write(mpcs, PCS_CTRL_REG,
                     PCS_AN_ENABLE | PCS_AN_RESTART);
    } else {
        /* Forced 모드: AN 비활성화 */
        my_pcs_write(mpcs, PCS_CTRL_REG, 0);
    }

    return 0;
}

static const struct phylink_pcs_ops my_pcs_ops = {
    .pcs_get_state = my_pcs_get_state,
    .pcs_config    = my_pcs_config,
};

Fixed-link은 Device Tree에서 다음과 같이 설정됩니다.

/* Device Tree fixed-link 예시:
   &ethernet {
       fixed-link {
           speed = <1000>;
           full-duplex;
       };
   };
*/

/* 드라이버에서 fixed-link 처리 -- phylink이 자동으로 감지 */
static int my_setup_phylink(struct my_priv *priv)
{
    struct fwnode_handle *fwnode = dev_fwnode(priv->dev);

    priv->phylink_config.type = PHYLINK_NETDEV;
    priv->phylink_config.mac_capabilities =
        MAC_SYM_PAUSE | MAC_10 | MAC_100 | MAC_1000FD;

    /* phylink_create()는 fwnode에서 fixed-link 노드를 자동 탐색 */
    priv->phylink = phylink_create(&priv->phylink_config,
                                   fwnode, PHY_INTERFACE_MODE_SGMII,
                                   &my_phylink_mac_ops);

    /* fixed-link인 경우 phylink_of_phy_connect()는 내부적으로
     * phy_connect_direct()를 건너뛰고 고정 상태를 사용합니다 */
    return phylink_of_phy_connect(priv->phylink,
                                  to_of_node(fwnode), 0);
}

PHY 인터럽트 vs 폴링 모드

PHY 상태 변화를 감지하는 방식은 크게 인터럽트 구동(Interrupt-driven)과 타이머 구동(Timer-driven, 폴링) 두 가지입니다. 인터럽트 방식이 CPU 효율이 높지만, 모든 PHY/보드 조합에서 인터럽트가 올바르게 배선되어 있지는 않습니다.

인터럽트 모드에서 PHY 드라이버는 config_intr와 handle_interrupt 콜백을 구현해야 합니다. 커널의 phy_interrupt() 핸들러가 이 콜백들을 조율합니다.

/* drivers/net/phy/phy.c - phy_interrupt() 핵심 분석 */
static irqreturn_t phy_interrupt(int irq, void *phy_dat)
{
    struct phy_device *phydev = phy_dat;
    struct phy_driver *drv = phydev->drv;
    irqreturn_t ret;

    /* PHY 드라이버의 인터럽트 핸들러 호출 */
    ret = drv->handle_interrupt(phydev);

    if (ret == IRQ_HANDLED) {
        /* 인터럽트가 처리되면 상태 머신을 즉시 트리거 */
        phy_trigger_machine(phydev);
    }

    return ret;
}

/* PHY 드라이버의 인터럽트 콜백 구현 예시 (Realtek/Broadcom 패턴) */
static int my_phy_config_intr(struct phy_device *phydev)
{
    u16 val;

    if (phydev->interrupts == PHY_INTERRUPT_ENABLED) {
        /* 링크 상태 변경 인터럽트 활성화 */
        val = phy_read(phydev, MY_PHY_INTR_MASK);
        val |= MY_PHY_INTR_LINK_CHANGE;
        phy_write(phydev, MY_PHY_INTR_MASK, val);
    } else {
        /* 모든 인터럽트 비활성화 */
        phy_write(phydev, MY_PHY_INTR_MASK, 0);
    }

    return 0;
}

static irqreturn_t my_phy_handle_interrupt(struct phy_device *phydev)
{
    u16 status;

    /* 인터럽트 상태 읽기 (읽으면 자동 클리어) */
    status = phy_read(phydev, MY_PHY_INTR_STATUS);
    if (!(status & MY_PHY_INTR_LINK_CHANGE))
        return IRQ_NONE; /* 이 PHY의 인터럽트가 아님 */

    /* phylib에 인터럽트 발생 알림 */
    phy_trigger_machine(phydev);

    return IRQ_HANDLED;
}

/* 폴링 모드 전환: IRQ를 PHY_POLL로 설정하면 자동 폴링 */
static struct phy_driver my_phy_driver[] = {{
    .phy_id           = MY_PHY_ID,
    .phy_id_mask      = 0xfffffff0,
    .name             = "My PHY",
    .config_intr      = my_phy_config_intr,
    .handle_interrupt = my_phy_handle_interrupt,
    /* .irq = PHY_POLL 이면 폴링 모드로 동작 */
}};

phy_polling_mode()는 PHY의 IRQ가 PHY_POLL로 설정되었는지 확인합니다. 폴링 모드에서는 phy_state_machine()이 PHY_STATE_TIME(기본 1초) 간격으로 MDIO 레지스터를 읽어 링크 상태를 확인합니다. 인터럽트 모드에서는 phy_trigger_machine()이 상태 머신을 즉시 실행하므로 링크 변화에 대한 반응이 훨씬 빠릅니다.

XDP, AF_XDP, 드라이버 오프로드

XDP 지원 드라이버는 RX hot path 초기에 프로그램을 실행해 drop/redirect를 빠르게 처리합니다. ndo_bpf, zero-copy AF_XDP, page_pool의 조합이 고성능 경로의 핵심입니다.

/* 개념 예시: XDP action 분기와 프레임 반환 계약 */
static int my_xdp_run(struct my_priv *priv, struct xdp_buff *xdp)
{
    u32 act;

    act = bpf_prog_run_xdp(rcu_dereference(priv->xdp_prog), xdp);

    switch (act) {
    case XDP_PASS:
        return XDP_PASS;
    case XDP_DROP:
        xdp_return_frame_rx_napi(xdp);
        return XDP_DROP;
    case XDP_TX:
        my_xdp_xmit(priv, xdp);
        return XDP_TX;
    default:
        xdp_return_frame_rx_napi(xdp);
        return XDP_ABORTED;
    }
}

ndo_bpf 콜백 구현 상세

XDP 프로그램을 드라이버에 부착(Attach)하려면 ndo_bpf 콜백을 구현해야 합니다. 커널의 dev_xdp_install() 함수가 이 콜백을 호출하여 XDP 프로그램의 설치/제거를 드라이버에 통지합니다.

ndo_bpf는 XDP_SETUP_PROG 명령을 통해 프로그램을 설치합니다. 드라이버는 이 시점에 RX 링 크기 재설정, 헤더룸(Headroom) 확보 등을 수행해야 합니다.

/* net/core/dev.c - dev_xdp_install() 핵심 분석 */
static int dev_xdp_install(struct net_device *dev,
                           bpf_op_t bpf_op,
                           struct netlink_ext_ack *extack,
                           u32 flags,
                           struct bpf_prog *prog)
{
    struct netdev_bpf xdp;

    memset(&xdp, 0, sizeof(xdp));
    xdp.command = XDP_SETUP_PROG;
    xdp.extack = extack;
    xdp.flags = flags;
    xdp.prog = prog;

    /* 드라이버의 ndo_bpf 콜백 호출 */
    return bpf_op(dev, &xdp);
}

/* 드라이버 측 ndo_bpf 구현 예시 */
static int my_ndo_bpf(struct net_device *dev,
                      struct netdev_bpf *bpf)
{
    struct my_priv *priv = netdev_priv(dev);

    switch (bpf->command) {
    case XDP_SETUP_PROG:
        return my_xdp_setup_prog(priv, bpf->prog, bpf->extack);
    case XDP_SETUP_XSK_POOL:
        return my_xsk_pool_setup(priv, bpf->xsk.pool,
                                 bpf->xsk.queue_id);
    default:
        return -EINVAL;
    }
}

static int my_xdp_setup_prog(struct my_priv *priv,
                              struct bpf_prog *prog,
                              struct netlink_ext_ack *extack)
{
    struct bpf_prog *old_prog;
    bool need_reconfig;

    /* MTU 제한 검증: XDP는 단일 페이지에 맞아야 함 */
    if (prog && priv->ndev->mtu > MY_XDP_MAX_MTU) {
        NL_SET_ERR_MSG_MOD(extack,
            "MTU too large for XDP");
        return -EINVAL;
    }

    /* XDP 프로그램 유무에 따라 링 재설정 필요 여부 결정 */
    old_prog = rcu_dereference_protected(priv->xdp_prog,
        lockdep_is_held(&priv->lock));
    need_reconfig = (!!prog != !!old_prog);

    if (need_reconfig && netif_running(priv->ndev)) {
        /* RX 링 재설정: XDP headroom 확보 */
        my_stop_rx_rings(priv);
        my_reconfigure_rx_headroom(priv,
            prog ? XDP_PACKET_HEADROOM : 0);
        my_start_rx_rings(priv);
    }

    /* RCU로 프로그램 교체 */
    rcu_assign_pointer(priv->xdp_prog, prog);
    if (old_prog)
        bpf_prog_put(old_prog);

    return 0;
}

XDP 메타데이터와 힌트(Hints) 시스템

XDP 프로그램은 xdp_buff의 메타데이터(Metadata) 영역을 통해 드라이버로부터 하드웨어 힌트(Hints)를 수신할 수 있습니다. 메타데이터 영역은 data_meta에서 data 사이에 위치하며, 드라이버가 RX 타임스탬프(Timestamp), RSS 해시 등의 정보를 기록합니다.

커널 6.3 이후 도입된 kfunc 기반 메타데이터 접근 방식은 XDP 힌트(XDP Hints)라고 불리며, 구조화된 인터페이스를 제공합니다.

/* XDP 메타데이터 영역 구조:
 *
 * +------------------+------------------+------------------+
 * |   data_hard_start|     data_meta    |      data        |
 * +------------------+------------------+------------------+
 *                    |<-- metadata -->|<-- packet ------>|
 *                    |  (rx_timestamp)  |  (Ethernet frame) |
 *                    |  (rx_hash)       |                    |
 */

/* 드라이버 RX 경로에서 메타데이터 기록 */
static void my_rx_populate_metadata(struct xdp_buff *xdp,
                                    struct my_rx_desc *desc)
{
    struct xdp_hints_common *hints;

    /* 메타데이터 영역 확보 */
    hints = xdp->data - sizeof(*hints);
    if ((void *)hints < xdp->data_hard_start)
        return; /* 공간 부족 */

    /* RX 타임스탬프 기록 */
    if (desc->flags & RX_DESC_TS_VALID) {
        hints->rx_timestamp = my_hw_ts_to_ns(desc->timestamp);
        hints->flags |= XDP_HINTS_RX_TIMESTAMP;
    }

    /* RSS 해시 기록 */
    if (desc->flags & RX_DESC_HASH_VALID) {
        hints->rx_hash = desc->rss_hash;
        hints->rx_hash_type = my_hash_type_to_xdp(desc->hash_type);
        hints->flags |= XDP_HINTS_RX_HASH;
    }

    xdp->data_meta = (void *)hints;
}

/* XDP kfunc 기반 힌트 접근 (커널 6.3+) */
/* XDP 프로그램에서 bpf_xdp_metadata_rx_timestamp()으로 접근 가능 */
static int my_xdp_rx_timestamp(const struct xdp_md *ctx,
                               u64 *timestamp)
{
    struct xdp_buff *xdp = (struct xdp_buff *)ctx;
    struct my_rx_ring *ring = my_get_rx_ring(xdp);
    struct my_rx_desc *desc = my_get_current_desc(ring);

    if (!(desc->flags & RX_DESC_TS_VALID))
        return -ENODATA;

    *timestamp = my_hw_ts_to_ns(desc->timestamp);
    return 0;
}

static const struct xdp_metadata_ops my_xdp_metadata_ops = {
    .xmo_rx_timestamp = my_xdp_rx_timestamp,
    .xmo_rx_hash      = my_xdp_rx_hash,
};

AF_XDP Zero-Copy 드라이버 통합

AF_XDP(Address Family XDP)의 제로 카피(Zero-Copy) 모드는 커널 메모리 복사 없이 유저스페이스와 NIC 간 직접 DMA 전송을 수행합니다. 드라이버는 xsk_pool을 등록하고, UMEM(User Memory) 영역의 버퍼를 직접 DMA 맵핑하여 사용합니다.

/* AF_XDP zero-copy를 지원하는 NAPI poll 구현 */
static int my_xsk_napi_poll(struct napi_struct *napi, int budget)
{
    struct my_qvec *qv = container_of(napi, struct my_qvec, napi);
    struct my_priv *priv = qv->priv;
    struct xsk_buff_pool *pool = qv->xsk_pool;
    int rx_done = 0, tx_done = 0;

    if (pool) {
        /* Zero-copy RX 처리 */
        rx_done = my_xsk_rx_clean(qv, budget);

        /* Zero-copy TX 처리 */
        tx_done = my_xsk_tx_clean(qv);

        /* XSK wakeup 처리 */
        if (xsk_uses_need_wakeup(pool))
            xsk_set_tx_need_wakeup(pool);
    } else {
        /* 일반 경로 */
        rx_done = my_rx_clean(qv, budget);
        tx_done = my_tx_clean(qv);
    }

    if (rx_done < budget) {
        napi_complete_done(napi, rx_done);
        my_enable_irq(qv);
    }

    return rx_done;
}

/* XSK RX 경로: UMEM 버퍼를 직접 DMA로 수신 */
static int my_xsk_rx_clean(struct my_qvec *qv, int budget)
{
    struct xsk_buff_pool *pool = qv->xsk_pool;
    int cleaned = 0;

    while (cleaned < budget) {
        struct xdp_buff *xdp;
        struct my_rx_desc *desc = my_get_next_rx_desc(qv);

        if (!desc)
            break;

        /* FILL ring에서 UMEM 프레임 가져오기 */
        xdp = xsk_buff_alloc(pool);
        if (!xdp)
            break;

        /* 디스크립터에서 길이 가져와서 xdp_buff에 설정 */
        xsk_buff_set_size(xdp, desc->length);
        xsk_buff_dma_sync_for_cpu(xdp, pool);

        /* XDP 프로그램 실행 */
        u32 act = bpf_prog_run_xdp(
            rcu_dereference(qv->priv->xdp_prog), xdp);

        switch (act) {
        case XDP_PASS:
            /* SKB로 변환하여 스택으로 전달 */
            my_xsk_to_skb(qv, xdp);
            break;
        case XDP_REDIRECT:
            xdp_do_redirect(qv->priv->ndev, xdp,
                rcu_dereference(qv->priv->xdp_prog));
            break;
        default:
            xsk_buff_free(xdp);
            break;
        }
        cleaned++;
    }

    /* FILL ring 리필 */
    my_xsk_refill_rx(qv, pool);

    return cleaned;
}

XDP 멀티버퍼(Multi-Buffer) 지원

XDP 멀티버퍼(Multi-Buffer)는 커널 6.0에서 도입된 기능으로, 단일 페이지를 초과하는 프레임(예: 점보 프레임(Jumbo Frame))을 XDP에서 처리할 수 있게 합니다. xdp_buff에 mb(multi-buffer) 플래그가 설정되면, 추가 프래그먼트(Fragment)가 skb_shared_info 구조체를 통해 연결됩니다.

/* 드라이버에서 XDP 멀티버퍼 프레임 구성 */
static void my_rx_build_xdp_mb(struct my_qvec *qv,
                               struct xdp_buff *xdp,
                               struct my_rx_desc *first_desc)
{
    struct skb_shared_info *sinfo;
    struct my_rx_desc *desc = first_desc;
    int nr_frags = 0;

    /* 첫 번째 디스크립터: 선형 데이터 */
    xdp_init_buff(xdp, MY_RX_BUF_SIZE, &qv->xdp_rxq);
    xdp_prepare_buff(xdp, page_address(desc->page),
                     XDP_PACKET_HEADROOM, desc->length, true);

    /* multi-buffer 플래그 설정 */
    xdp->flags |= XDP_FLAGS_HAS_FRAGS;

    /* tailroom에 skb_shared_info 배치 */
    sinfo = xdp_get_shared_info_from_buff(xdp);
    sinfo->nr_frags = 0;

    /* 후속 디스크립터들을 프래그먼트로 추가 */
    while (!(desc->flags & RX_DESC_EOP)) {
        desc = my_get_next_rx_desc(qv);
        if (!desc || nr_frags >= MAX_SKB_FRAGS)
            break;

        skb_frag_fill_page_desc(&sinfo->frags[nr_frags],
                                desc->page, 0, desc->length);
        sinfo->nr_frags = ++nr_frags;
        sinfo->xdp_frags_size += desc->length;
    }
}

/* ndo_bpf에서 멀티버퍼 능력 광고 */
static int my_xdp_setup_prog(struct my_priv *priv,
                              struct bpf_prog *prog,
                              struct netlink_ext_ack *extack)
{
    /* 멀티버퍼 미지원 프로그램이 점보 프레임 환경에서 동작하면 거부 */
    if (prog && !prog->aux->xdp_has_frags &&
        priv->ndev->mtu > MY_XDP_MAX_MTU) {
        NL_SET_ERR_MSG_MOD(extack,
            "Non-multi-buffer XDP prog with jumbo MTU");
        return -EINVAL;
    }

    /* ... 이하 프로그램 설치 로직 ... */
    return 0;
}

멀티큐, RSS, IRQ affinity 설계

10/25/100GbE 구간에서는 단일 큐 모델이 거의 항상 병목입니다. 드라이버는 RX/TX 큐, MSI-X vector, NAPI 인스턴스를 1:1 또는 N:1로 설계하고, NUMA/CPU 토폴로지(Topology)에 맞춰 IRQ affinity를 배치해야 합니다.

/* 개념 예시: 멀티큐 qvec와 MSI-X 벡터 매핑 */
struct my_qvec {
    struct napi_struct napi;
    int qid;
    int irq;
};

static int my_alloc_qvecs(struct my_priv *priv, int num_q)
{
    int i;

    for (i = 0; i < num_q; i++) {
        struct my_qvec *qv = &priv->qvec[i];

        qv->qid = i;
        netif_napi_add(priv->ndev, &qv->napi, my_qvec_poll);
        my_request_msix_vector(priv, i, &qv->irq, my_msix_irq_handler);
    }

    return 0;
}

RSS 해시 함수와 Indirection Table 내부

RSS(Receive Side Scaling)는 수신 패킷을 여러 RX 큐에 분산하는 하드웨어 메커니즘입니다. 핵심은 토플리츠 해시(Toeplitz Hash) 알고리즘으로, 패킷의 소스/목적지 IP와 포트를 입력으로 받아 해시 값을 계산하고, 간접 테이블(Indirection Table)을 통해 최종 큐 번호를 결정합니다.

토플리츠 해시는 비밀 키(Secret Key)와 입력 데이터의 비트별 XOR 연산으로 구성됩니다. 커널은 netdev_rss_key_fill()로 부팅 시 랜덤 키를 생성하여 모든 디바이스에 공유합니다.

/* net/core/ethtool.c - RSS 키와 indirection table 관리 */

/* netdev_rss_key_fill(): 전역 RSS 키를 랜덤 생성 */
void netdev_rss_key_fill(void *buffer, size_t len)
{
    static u8 netdev_rss_key[NETDEV_RSS_KEY_LEN] __read_mostly;
    static bool rss_key_initialized = false;

    if (!rss_key_initialized) {
        get_random_bytes(netdev_rss_key, sizeof(netdev_rss_key));
        rss_key_initialized = true;
    }

    memcpy(buffer, netdev_rss_key, len);
}

/* 드라이버에서 RSS indirection table 설정 */
static int my_set_rxfh(struct net_device *dev,
                       struct ethtool_rxfh_param *rxfh,
                       struct netlink_ext_ack *extack)
{
    struct my_priv *priv = netdev_priv(dev);
    int i;

    /* 해시 함수 변경 */
    if (rxfh->hfunc != ETH_RSS_HASH_NO_CHANGE) {
        if (rxfh->hfunc != ETH_RSS_HASH_TOP)
            return -EOPNOTSUPP; /* Toeplitz만 지원 */
        priv->rss_hfunc = rxfh->hfunc;
    }

    /* RSS 키 갱신 */
    if (rxfh->key)
        memcpy(priv->rss_key, rxfh->key, MY_RSS_KEY_SIZE);

    /* Indirection table 갱신 */
    if (rxfh->indir) {
        for (i = 0; i < MY_RSS_INDIR_SIZE; i++) {
            if (rxfh->indir[i] >= priv->num_rx_queues)
                return -EINVAL;
            priv->rss_indir[i] = rxfh->indir[i];
        }
    }

    /* 하드웨어에 새 RSS 설정 적용 */
    return my_hw_write_rss_config(priv);
}

/* 대칭 RSS (Symmetric RSS): 양방향 플로우를 같은 큐로 */
/* 대칭 Toeplitz는 src/dst를 XOR하여 순서 무관하게 동일 해시 생성 */
static u32 my_symmetric_toeplitz_hash(const u8 *key,
                                       __be32 saddr, __be32 daddr,
                                       __be16 sport, __be16 dport)
{
    /* src XOR dst를 입력으로 사용하면 A->B와 B->A가 동일 해시 */
    __be32 addr_xor = saddr ^ daddr;
    __be16 port_xor = sport ^ dport;

    return toeplitz_hash(key, addr_xor, port_xor);
}

MSI-X 벡터 할당과 IRQ affinity

고성능 NIC 드라이버는 MSI-X(Message Signaled Interrupts - Extended) 인터럽트를 사용하여 각 RX/TX 큐에 독립적인 인터럽트 벡터를 할당합니다. pci_alloc_irq_vectors()가 벡터를 할당하고, irq_set_affinity_hint()가 CPU 친화도(Affinity)를 설정합니다.

/* MSI-X 벡터 할당과 managed affinity 설정 */
static int my_alloc_msix(struct my_priv *priv)
{
    struct irq_affinity affd = {
        .pre_vectors  = 1,  /* 관리/이벤트 벡터 1개 예약 */
        .post_vectors = 0,
    };
    int num_vecs, ret;

    /* 원하는 큐 수 + 관리 벡터 */
    num_vecs = priv->num_queues + affd.pre_vectors;

    /* managed affinity로 벡터 할당 — 커널이 NUMA 최적 배치 */
    ret = pci_alloc_irq_vectors_affinity(priv->pdev,
        affd.pre_vectors + 1,  /* 최소: 관리 + 큐 1개 */
        num_vecs,               /* 최대 */
        PCI_IRQ_MSIX | PCI_IRQ_AFFINITY,
        &affd);

    if (ret < 0)
        return ret;

    priv->num_msix_vecs = ret;
    priv->num_queues = ret - affd.pre_vectors;

    /* 각 큐 벡터에 대해 IRQ 핸들러 등록 */
    for (int i = 0; i < priv->num_queues; i++) {
        int vec = i + affd.pre_vectors;
        struct my_qvec *qv = &priv->qvec[i];

        qv->irq = pci_irq_vector(priv->pdev, vec);

        ret = request_irq(qv->irq, my_msix_handler,
                          0, qv->name, qv);
        if (ret)
            goto err_free;

        /* managed affinity 사용 시 hint는 불필요
         * 비-managed인 경우에만 수동 설정 */
        if (!(priv->pdev->msix_enabled))
            irq_set_affinity_hint(qv->irq,
                get_cpu_mask(cpumask_local_spread(i,
                    dev_to_node(&priv->pdev->dev))));
    }

    /* 관리 벡터 등록 (벡터 0) */
    priv->mgmt_irq = pci_irq_vector(priv->pdev, 0);
    ret = request_irq(priv->mgmt_irq, my_mgmt_handler,
                      0, "my-mgmt", priv);

    return ret;

err_free:
    while (--i >= 0)
        free_irq(priv->qvec[i].irq, &priv->qvec[i]);
    pci_free_irq_vectors(priv->pdev);
    return ret;
}

XPS (Transmit Packet Steering) 내부 동작

XPS(Transmit Packet Steering)는 송신 패킷을 특정 TX 큐로 유도하여 캐시 효율을 높이는 메커니즘입니다. CPU 맵(CPU map)과 RX 큐 맵(RX queue map) 두 가지 모드가 있습니다.

/* net/core/dev.c - __netif_set_xps_queue() 핵심 분석 */
/* XPS는 dev->xps_maps에 CPU/RX큐 -> TX큐 매핑을 저장 */

/* XPS와 ndo_select_queue의 상호작용 */
static u16 my_select_queue(struct net_device *dev,
                           struct sk_buff *skb,
                           struct net_device *sb_dev)
{
    /* 커널 기본 경로:
     * 1. skb->queue_mapping이 설정되어 있으면 그대로 사용
     * 2. XPS 맵에서 현재 CPU에 해당하는 TX 큐 선택
     * 3. XPS가 없으면 해시 기반 분산 (skb_tx_hash)
     */

    /* 드라이버가 특별한 큐 선택 로직이 필요한 경우에만 구현 */
    /* 예: TC(Traffic Class) 기반 큐 선택 */
    if (skb->priority >= MY_PRIO_THRESHOLD)
        return priv->high_prio_queue;

    /* 기본 XPS/해시 선택에 위임 */
    return netdev_pick_tx(dev, skb, sb_dev);
}

/* sysfs를 통한 XPS CPU map 설정 예시 */
/*
 * # TX 큐 0은 CPU 0,1에서 사용
 * echo 3 > /sys/class/net/eth0/queues/tx-0/xps_cpus
 *
 * # TX 큐 1은 CPU 2,3에서 사용
 * echo c > /sys/class/net/eth0/queues/tx-1/xps_cpus
 *
 * # RX 큐 맵: TX 큐 0은 RX 큐 0의 응답 경로
 * echo 1 > /sys/class/net/eth0/queues/tx-0/xps_rxqs
 */

RPS/RFS 소프트웨어 스티어링

RPS(Receive Packet Steering)와 RFS(Receive Flow Steering)는 하드웨어 RSS를 지원하지 않는 디바이스에서 소프트웨어적으로 패킷을 여러 CPU에 분산하는 메커니즘입니다. RPS는 패킷 해시 기반으로, RFS는 애플리케이션의 소켓 위치 기반으로 CPU를 선택합니다.

/* net/core/dev.c - 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;
    struct rps_dev_flow_table *flow_table;
    struct rps_map *map;
    u32 hash, next_cpu, ident;
    int cpu = -1;

    /* 1단계: 패킷 해시 계산 (또는 HW 해시 재사용) */
    hash = skb_get_hash(skb);
    if (!hash)
        goto done;

    /* 2단계: RPS 맵에서 해시 기반 CPU 선택 */
    map = rcu_dereference(rxqueue->rps_map);
    if (map) {
        cpu = map->cpus[hash & (map->len - 1)]; /* reciprocal_scale 대신 간소화 */
    }

    /* 3단계: RFS 활성화 시 소켓 CPU와 비교 */
    sock_flow_table = rcu_dereference(rps_sock_flow_table);
    if (sock_flow_table) {
        ident = sock_flow_table->ents[hash & sock_flow_table->mask];
        next_cpu = ident & rps_cpu_mask;

        /* 소켓이 처리 중인 CPU가 RPS 맵에 있으면 그 CPU 선택 */
        if (cpu_online(next_cpu))
            cpu = next_cpu;
    }

    /* 4단계: 디바이스 플로우 테이블 갱신 */
    flow_table = rcu_dereference(rxqueue->rps_flow_table);
    if (flow_table) {
        struct rps_dev_flow *rflow =
            &flow_table->flows[hash & flow_table->mask];
        rflow->cpu = cpu;
        *rflowp = rflow;
    }

done:
    return cpu;
}

/* RPS/RFS 활성화 예시 (sysfs) */
/*
 * # 모든 CPU에서 RPS 활성화 (8 CPU 시스템)
 * echo ff > /sys/class/net/eth0/queues/rx-0/rps_cpus
 *
 * # RFS 플로우 테이블 크기 설정 (보통 32768)
 * echo 32768 > /proc/sys/net/core/rps_sock_flow_entries
 *
 * # 디바이스별 플로우 테이블 크기
 * echo 2048 > /sys/class/net/eth0/queues/rx-0/rps_flow_cnt
 */

NUMA 친화적 큐 배치 전략

NUMA(Non-Uniform Memory Access) 시스템에서 네트워크 드라이버의 성능은 큐, 인터럽트, 메모리 할당이 올바른 NUMA 노드에 배치되었는지에 크게 좌우됩니다. 원격 NUMA 노드의 메모리 접근은 로컬 접근 대비 1.5~3배의 지연이 발생합니다.

/* NUMA 친화적 큐 초기화 패턴 (ixgbe/mlx5 참고) */
static int my_alloc_queue_resources(struct my_priv *priv, int qid)
{
    struct device *dev = &priv->pdev->dev;
    int numa_node = dev_to_node(dev);
    struct my_ring *rx_ring, *tx_ring;

    /* 1. 링 구조체를 NIC의 NUMA 노드에 할당 */
    rx_ring = kzalloc_node(sizeof(*rx_ring), GFP_KERNEL, numa_node);
    tx_ring = kzalloc_node(sizeof(*tx_ring), GFP_KERNEL, numa_node);
    if (!rx_ring || !tx_ring)
        return -ENOMEM;

    /* 2. DMA 일관성 메모리도 같은 노드에서 할당 */
    rx_ring->desc = dma_alloc_coherent(dev,
        rx_ring->size * sizeof(struct my_rx_desc),
        &rx_ring->dma_addr, GFP_KERNEL);

    /* 3. page_pool을 같은 NUMA 노드로 설정 */
    struct page_pool_params pp = {
        .nid    = numa_node,
        .dev    = dev,
        .flags  = PP_FLAG_DMA_MAP | PP_FLAG_DMA_SYNC_DEV,
        .dma_dir = DMA_FROM_DEVICE,
    };
    rx_ring->pp = page_pool_create(&pp);

    /* 4. IRQ affinity: cpumask_local_spread()로 로컬 CPU 우선 */
    int target_cpu = cpumask_local_spread(qid, numa_node);
    irq_set_affinity_hint(priv->qvec[qid].irq,
                          get_cpu_mask(target_cpu));

    /* 5. XPS 설정: TX 큐를 로컬 CPU에 매핑 */
    netif_set_xps_queue(priv->ndev,
                        get_cpu_mask(target_cpu), qid);

    priv->rx_ring[qid] = rx_ring;
    priv->tx_ring[qid] = tx_ring;

    return 0;
}

/* cpumask_local_spread() 동작 원리:
 *   - idx=0이면 numa_node의 첫 번째 온라인 CPU 반환
 *   - idx가 로컬 CPU 수를 초과하면 원격 NUMA 노드 CPU 반환
 *   - 이렇게 하면 큐 0~N은 로컬 CPU에 우선 배치되고,
 *     남는 큐는 원격 CPU에 할당됩니다
 */

/* 실무: ethtool로 NUMA 배치 확인 */
/*
 * # NIC의 NUMA 노드 확인
 * cat /sys/class/net/eth0/device/numa_node
 *
 * # 각 큐의 IRQ affinity 확인
 * for irq in $(grep eth0 /proc/interrupts | awk '{print $1}' | tr -d ':'); do
 *     echo "IRQ $irq: $(cat /proc/irq/$irq/smp_affinity_list)"
 * done
 *
 * # NUMA 노드별 메모리 사용 확인
 * numastat -p $(pidof ksoftirqd/0)
 */

RX 메모리 경로: page_pool과 DMA recycling

고속 수신 경로에서 alloc_pages()/dma_map를 패킷마다 반복하면 CPU 비용이 폭증합니다. page_pool 기반 재사용은 대부분의 고성능 NIC 드라이버에서 사실상 표준 패턴입니다.

/* 개념 예시: page_pool 기반 RX 메모리 재사용 */
static int my_rx_pool_init(struct my_priv *priv)
{
    struct page_pool_params pp = {
        .flags = PP_FLAG_DMA_MAP | PP_FLAG_DMA_SYNC_DEV,
        .order = 0,
        .pool_size = 4096,
        .nid = dev_to_node(priv->dev),
        .dev = priv->dev,
        .dma_dir = DMA_FROM_DEVICE,
    };

    priv->rx_pp = page_pool_create(&pp);
    if (IS_ERR(priv->rx_pp))
        return PTR_ERR(priv->rx_pp);

    return 0;
}

static void my_rx_recycle_page(struct my_priv *priv, struct page *page)
{
    page_pool_recycle_direct(priv->rx_pp, page);
}

page_pool 내부 자료구조와 할당 경로

struct page_pool은 크게 세 가지 계층으로 구성됩니다. 가장 빠른 경로인 alloc 캐시(alloc cache)는 per-CPU 배열(기본 128개)로, NAPI 폴링 컨텍스트에서 락 없이 페이지를 꺼내옵니다. 캐시가 비면 ptr_ring 기반 리사이클 링으로 폴백(fallback)하며, 여기서도 부족하면 슬로 패스(slow path)로 버디 할당자(Buddy Allocator)에서 새 페이지를 할당합니다.

커널 소스(net/core/page_pool.c)에서 page_pool_alloc_pages()의 핵심 흐름을 분석하면 다음과 같습니다.

/* net/core/page_pool.c — 할당 경로 핵심 분석 */
struct page *page_pool_alloc_pages(struct page_pool *pool,
                                    gfp_t gfp)
{
    struct page *page;

    /* 1단계: alloc 캐시에서 꺼냄 (가장 빠름, 락 없음) */
    if (likely(pool->alloc.count)) {
        page = pool->alloc.cache[--pool->alloc.count];
        return page;
    }

    /* 2단계: ptr_ring에서 벌크로 캐시 채움 */
    page = __page_pool_get_cached(pool);
    if (page)
        return page;

    /* 3단계: 슬로 패스 — 버디 할당자에서 새 페이지 할당 + DMA 매핑 */
    page = __page_pool_alloc_pages_slow(pool, gfp);
    return page;
}

/* 슬로 패스: DMA 매핑 포함 */
static struct page *__page_pool_alloc_pages_slow(
    struct page_pool *pool, gfp_t gfp)
{
    struct page *page;

    page = alloc_pages_node(pool->p.nid, gfp, pool->p.order);
    if (unlikely(!page))
        return NULL;

    /* PP_FLAG_DMA_MAP이 설정된 경우 자동 DMA 매핑 */
    if (pool->p.flags & PP_FLAG_DMA_MAP) {
        if (__page_pool_dma_map(pool, page)) {
            put_page(page);
            return NULL;
        }
    }

    page_pool_set_pp_info(pool, page);
    pool->pages_state_hold_cnt++;
    return page;
}

핵심 포인트는 alloc 캐시가 비었을 때 ptr_ring에서 최대 PP_ALLOC_CACHE_REFILL(기본 64)개를 한 번에 가져와 캐시를 채우는 벌크 리필(bulk refill) 전략입니다. 이 방식으로 ptr_ring 락 경합을 최소화합니다.

PP_FLAG 옵션 상세

page_pool_params에 설정하는 플래그(Flag)는 page_pool의 동작을 근본적으로 변경합니다. 각 플래그의 의미와 성능 영향을 정확히 이해해야 합니다.

page_pool 통계와 모니터링

page_pool은 커널 6.2부터 ethtool 통계 인터페이스를 통해 재활용 효율(Recycle Efficiency)을 실시간으로 모니터링할 수 있습니다. 재활용 히트율(Hit Ratio)이 90% 이하로 떨어지면 패킷 처리 성능이 급격히 저하됩니다.

/* ethtool을 통한 page_pool 통계 조회 */
/* $ ethtool -S eth0 | grep page_pool */
/*   page_pool_alloc_fast: 1234567   ← alloc 캐시 히트 */
/*   page_pool_alloc_slow: 456       ← 버디 할당자 폴백 */
/*   page_pool_alloc_refill: 12345   ← ptr_ring 리필 */
/*   page_pool_recycle_cached: 1234000 ← 직접 캐시 반환 */
/*   page_pool_recycle_ring: 567      ← ptr_ring 반환 */
/*   page_pool_recycle_released: 89   ← 풀로 못 돌려 해제 */

/* 드라이버에서 page_pool 통계를 ethtool에 노출하는 방법 */
static void my_get_ethtool_stats(struct net_device *ndev,
                                  struct ethtool_stats *stats,
                                  u64 *data)
{
    struct my_priv *priv = netdev_priv(ndev);
    struct page_pool_stats pp_stats = {};
    int i = 0;

    /* per-queue 통계 수집 */
    for (int q = 0; q < priv->num_rx_queues; q++) {
        if (!priv->rx_ring[q].page_pool)
            continue;
        page_pool_get_stats(priv->rx_ring[q].page_pool,
                            &pp_stats);
    }

    data[i++] = pp_stats.alloc_stats.fast;
    data[i++] = pp_stats.alloc_stats.slow;
    data[i++] = pp_stats.alloc_stats.slow_high_order;
    data[i++] = pp_stats.alloc_stats.empty;
    data[i++] = pp_stats.alloc_stats.refill;
    data[i++] = pp_stats.alloc_stats.waive;
    data[i++] = pp_stats.recycle_stats.cached;
    data[i++] = pp_stats.recycle_stats.cache_full;
    data[i++] = pp_stats.recycle_stats.ring;
    data[i++] = pp_stats.recycle_stats.ring_full;
    data[i++] = pp_stats.recycle_stats.released_refcnt;
}

bpftrace를 사용하면 런타임에 page_pool 슬로 패스 진입 빈도를 추적할 수 있습니다.

/* bpftrace: page_pool 슬로 패스 추적 */
/* $ sudo bpftrace -e '
   kprobe:__page_pool_alloc_pages_slow {
       @slow_alloc[comm] = count();
   }
   kprobe:page_pool_alloc_pages {
       @total_alloc[comm] = count();
   }
   interval:s:5 {
       print(@slow_alloc);
       print(@total_alloc);
       clear(@slow_alloc);
       clear(@total_alloc);
   }
' */

프래그먼트 모드와 Header/Data Split

PP_FLAG_PAGE_FRAG를 설정하면 page_pool은 하나의 페이지를 여러 개의 작은 프래그먼트(Fragment)로 나누어 할당합니다. 예를 들어 4KB 페이지에서 256바이트짜리 DNS 패킷용 버퍼 15개를 할당할 수 있어 메모리 효율이 크게 향상됩니다.

헤더/데이터 분리(Header/Data Split) 패턴에서는 이더넷(Ethernet) 프레임의 헤더 부분(일반적으로 128~256바이트)만 선형 버퍼(Linear Buffer)에 배치하고, 나머지 페이로드(Payload)는 page_pool 프래그먼트로 구성합니다. 이 방식은 캐시 효율과 제로 카피(Zero-copy) 전달을 동시에 만족시킵니다.

/* 프래그먼트 기반 RX 경로 구현 예시 */
static struct sk_buff *my_rx_build_skb_frag(
    struct my_rx_ring *ring,
    struct my_rx_desc *desc)
{
    struct page *page = ring->rx_buf[desc->idx].page;
    unsigned int offset = ring->rx_buf[desc->idx].offset;
    unsigned int len = desc->length;
    unsigned int hdr_len = min_t(unsigned int, len,
                                  ring->rx_hdr_size);
    unsigned int data_len = len - hdr_len;
    struct sk_buff *skb;

    /* 헤더 부분으로 SKB 생성 */
    skb = napi_alloc_skb(&ring->napi, hdr_len);
    if (unlikely(!skb))
        return NULL;

    /* 헤더 복사 (캐시 효율적, 작은 크기) */
    memcpy(skb_put(skb, hdr_len),
           page_address(page) + offset, hdr_len);

    /* 데이터 부분은 프래그먼트로 추가 (제로 카피) */
    if (data_len) {
        skb_add_rx_frag(skb, 0, page,
                        offset + hdr_len, data_len,
                        ring->rx_buf_size);
        /* page_pool 재활용을 위해 마킹 */
        skb_mark_for_recycle(skb);
    } else {
        /* 헤더만으로 충분한 소형 패킷: 페이지 즉시 반환 */
        page_pool_put_full_page(ring->page_pool,
                                page, false);
    }

    return skb;
}

/* page_pool 프래그먼트 모드 초기화 */
static int my_setup_page_pool_frag(struct my_priv *priv)
{
    struct page_pool_params pp = {
        .order       = 0,
        .pool_size   = priv->rx_ring_size * 2,
        .nid         = dev_to_node(&priv->pdev->dev),
        .dev         = &priv->pdev->dev,
        .dma_dir     = DMA_FROM_DEVICE,
        .flags       = PP_FLAG_DMA_MAP |
                       PP_FLAG_DMA_SYNC_DEV |
                       PP_FLAG_PAGE_FRAG,
        .max_len     = PAGE_SIZE,
    };

    priv->rx_pp = page_pool_create(&pp);
    return IS_ERR(priv->rx_pp) ?
           PTR_ERR(priv->rx_pp) : 0;
}

제어 경로: RTNL, RTNETLINK, feature 토글

데이터 경로가 빠르더라도 제어 경로가 불안정하면 운영 장애가 반복됩니다. MTU 변경, queue 개수 변경, 링크 down/up, offload 토글은 모두 RTNL 보호 하에서 일관되게 처리해야 합니다.

/* 개념 예시: MTU 변경 시 stop/open 오류 경로 보강 */
static int my_ndo_change_mtu(struct net_device *ndev, int new_mtu)
{
    int ret;
    int old_mtu = ndev->mtu;

    if (new_mtu < 68 || new_mtu > 9700)
        return -EINVAL;

    if (netif_running(ndev)) {
        ret = my_ndo_stop(ndev);
        if (ret)
            return ret;

        ndev->mtu = new_mtu;
        ret = my_ndo_open(ndev);
        if (ret) {
            ndev->mtu = old_mtu;
            return ret;
        }
        return 0;
    }

    ndev->mtu = new_mtu;
    return 0;
}

static int my_ndo_set_features(struct net_device *ndev, netdev_features_t features)
{
    netdev_features_t changed = ndev->features ^ features;

    if (changed & NETIF_F_TSO)
        my_hw_toggle_tso(ndev, !!(features & NETIF_F_TSO));
    if (changed & NETIF_F_GRO)
        my_hw_toggle_gro(ndev, !!(features & NETIF_F_GRO));

    return 0;
}

RTNL 락 계층과 보호 영역

RTNL(Routing Netlink) 락은 리눅스 네트워크 스택에서 가장 광범위한 뮤텍스(Mutex)입니다. net_device의 등록/해제, 주소 변경, 링크 상태 변경, offload 토글 등 거의 모든 제어 경로 작업이 RTNL 보호 하에서 수행됩니다. 커널 6.13부터는 per-namespace RTNL이 도입되어 네트워크 네임스페이스(Network Namespace) 간 병렬성이 개선되었습니다.

/* net/core/rtnetlink.c — RTNL 락 구현 */
static DEFINE_MUTEX(rtnl_mutex);

void rtnl_lock(void)
{
    mutex_lock(&rtnl_mutex);
}

void rtnl_unlock(void)
{
    /* 언락 전에 대기 중인 netdev 해제 요청 처리 */
    netdev_run_todo();
    mutex_unlock(&rtnl_mutex);
}

int rtnl_trylock(void)
{
    return mutex_trylock(&rtnl_mutex);
}

/* per-namespace RTNL (v6.13+) — net->rtnl_lock */
void rtnl_net_lock(struct net *net)
{
    rtnl_lock();             /* 전역 RTNL 먼저 */
    mutex_lock(&net->rtnl_lock); /* 이후 ns RTNL */
}

RTNETLINK 메시지 처리 경로

RTNETLINK는 사용자 공간에서 커널 네트워크 설정을 변경하는 주요 인터페이스입니다. ip link add, ip link set 같은 명령은 모두 RTM_NEWLINK, RTM_SETLINK 등의 RTNETLINK 메시지로 변환됩니다.

/* 커스텀 netdev를 위한 rtnl_link_ops 등록 예시 */
static int my_virt_newlink(struct net *src_net,
                           struct net_device *dev,
                           struct nlattr *tb[],
                           struct nlattr *data[],
                           struct netlink_ext_ack *extack)
{
    struct my_virt_priv *priv = netdev_priv(dev);
    int err;

    /* IFLA_MY_MODE 등 드라이버 전용 속성 파싱 */
    if (data && data[IFLA_MY_MODE])
        priv->mode = nla_get_u32(data[IFLA_MY_MODE]);

    err = register_netdevice(dev);
    if (err)
        return err;

    netif_carrier_off(dev);
    return 0;
}

static void my_virt_dellink(struct net_device *dev,
                            struct list_head *head)
{
    unregister_netdevice_queue(dev, head);
}

static const struct nla_policy my_virt_policy[IFLA_MY_MAX + 1] = {
    [IFLA_MY_MODE] = { .type = NLA_U32 },
    [IFLA_MY_FLAGS] = { .type = NLA_U32 },
};

static struct rtnl_link_ops my_virt_link_ops = {
    .kind         = "my_virt",
    .priv_size    = sizeof(struct my_virt_priv),
    .setup        = my_virt_setup,
    .newlink      = my_virt_newlink,
    .dellink      = my_virt_dellink,
    .policy       = my_virt_policy,
    .maxtype      = IFLA_MY_MAX,
};

/* 모듈 초기화 시 등록 */
static int __init my_virt_init(void)
{
    return rtnl_link_register(&my_virt_link_ops);
}

RTNETLINK 메시지 처리 흐름은 다음과 같습니다. 사용자가 ip link add 명령을 실행하면, RTM_NEWLINK 메시지가 소켓을 통해 커널에 도달합니다. rtnetlink_rcv_msg()가 메시지를 디스패치하고, rtnl_newlink()가 rtnl_link_ops를 찾아 newlink 콜백을 호출합니다.

ethtool-netlink 인터페이스

커널 5.6부터 ethtool은 기존 ioctl 인터페이스를 대체하는 Netlink 기반 인터페이스를 제공합니다. ethtool-netlink(이하 ethnl)은 확장성이 뛰어나고, 변경 알림(Notification)을 지원하며, 구조화된 데이터 전달이 가능합니다.

/* ethtool-netlink 코얼레싱 ops 구현 예시 */
static int my_get_coalesce(struct net_device *ndev,
                           struct ethtool_coalesce *ec,
                           struct kernel_ethtool_coalesce *kec,
                           struct netlink_ext_ack *extack)
{
    struct my_priv *priv = netdev_priv(ndev);

    ec->rx_coalesce_usecs = priv->rx_usecs;
    ec->rx_max_coalesced_frames = priv->rx_frames;
    ec->tx_coalesce_usecs = priv->tx_usecs;
    ec->tx_max_coalesced_frames = priv->tx_frames;
    ec->use_adaptive_rx_coalesce = priv->adaptive_rx;
    ec->use_adaptive_tx_coalesce = priv->adaptive_tx;

    return 0;
}

static int my_set_coalesce(struct net_device *ndev,
                           struct ethtool_coalesce *ec,
                           struct kernel_ethtool_coalesce *kec,
                           struct netlink_ext_ack *extack)
{
    struct my_priv *priv = netdev_priv(ndev);

    if (ec->rx_coalesce_usecs > MY_MAX_COAL_USECS) {
        NL_SET_ERR_MSG_MOD(extack,
            "rx-usecs exceeds maximum");
        return -ERANGE;
    }

    priv->rx_usecs = ec->rx_coalesce_usecs;
    priv->rx_frames = ec->rx_max_coalesced_frames;
    priv->tx_usecs = ec->tx_coalesce_usecs;
    priv->tx_frames = ec->tx_max_coalesced_frames;
    priv->adaptive_rx = ec->use_adaptive_rx_coalesce;
    priv->adaptive_tx = ec->use_adaptive_tx_coalesce;

    /* 하드웨어에 새 코얼레싱 값 적용 */
    my_hw_set_coalesce(priv);

    return 0;
}

static const struct ethtool_ops my_ethtool_ops = {
    .supported_coalesce_params = ETHTOOL_COALESCE_USECS |
                                  ETHTOOL_COALESCE_MAX_FRAMES |
                                  ETHTOOL_COALESCE_USE_ADAPTIVE,
    .get_coalesce   = my_get_coalesce,
    .set_coalesce   = my_set_coalesce,
    /* ... 기타 ops ... */
};

채널/큐 동적 재구성

ethtool -L 명령으로 채널(Channel) 수를 동적으로 변경할 때, 드라이버는 stop → 재구성 → restart 패턴을 따라야 합니다. 이 과정에서 패킷 손실을 최소화하고, 경쟁 상태(Race Condition)를 방지하는 것이 핵심입니다.

/* 안전한 채널 재구성 구현 */
static int my_set_channels(struct net_device *ndev,
                           struct ethtool_channels *ch)
{
    struct my_priv *priv = netdev_priv(ndev);
    unsigned int new_rx = ch->combined_count ?: ch->rx_count;
    unsigned int new_tx = ch->combined_count ?: ch->tx_count;
    int err;

    /* 검증: 하드웨어 최대값 초과 방지 */
    if (new_rx > priv->max_rx_queues ||
        new_tx > priv->max_tx_queues)
        return -EINVAL;

    /* XDP가 활성화된 경우 TX 큐 수 제한 확인 */
    if (priv->xdp_prog && new_tx < new_rx)
        return -EINVAL;

    /* 인터페이스가 UP 상태인 경우만 재시작 필요 */
    if (netif_running(ndev)) {
        /* 1단계: 데이터 경로 중단 */
        netif_tx_disable(ndev);
        my_napi_disable_all(priv);
        my_free_irqs(priv);
        my_free_rings(priv);

        /* 2단계: 새 큐 수 적용 */
        priv->num_rx_queues = new_rx;
        priv->num_tx_queues = new_tx;

        /* 3단계: 새 링/NAPI/IRQ 할당 */
        err = my_alloc_rings(priv);
        if (err)
            goto err_rollback;

        err = my_request_irqs(priv);
        if (err)
            goto err_free_rings;

        /* 4단계: 데이터 경로 재시작 */
        my_napi_enable_all(priv);
        netif_tx_start_all_queues(ndev);

        /* netdev 큐 수 갱신 (XPS/RPS 재설정) */
        netif_set_real_num_rx_queues(ndev, new_rx);
        netif_set_real_num_tx_queues(ndev, new_tx);
    } else {
        priv->num_rx_queues = new_rx;
        priv->num_tx_queues = new_tx;
    }

    return 0;

err_free_rings:
    my_free_rings(priv);
err_rollback:
    /* 롤백: 이전 큐 수로 복원 시도 */
    priv->num_rx_queues = priv->prev_rx_queues;
    priv->num_tx_queues = priv->prev_tx_queues;
    my_alloc_rings(priv);
    my_request_irqs(priv);
    my_napi_enable_all(priv);
    netif_tx_start_all_queues(ndev);
    return err;
}

TC/NFT 오프로드와 switchdev 연계

데이터센터 NIC는 tc flower 규칙을 하드웨어 테이블로 오프로드해 CPU 부하를 낮춥니다. 이때 드라이버는 수용 가능한 매치/액션 집합을 명확히 제한하고, 부분 실패 시 fallback 정책을 분명히 해야 합니다.

/* 개념 예시: TC setup type별 오프로드 분기 */
static int my_ndo_setup_tc(struct net_device *ndev, enum tc_setup_type type, void *type_data)
{
    switch (type) {
    case TC_SETUP_BLOCK:
        return my_tc_block_cb_setup(ndev, type_data);
    case TC_SETUP_QDISC_MQPRIO:
        return my_mqprio_setup(ndev, type_data);
    default:
        return -EOPNOTSUPP;
    }
}

tc flower 오프로드 내부 흐름

tc flower 오프로드는 FLOW_CLS_REPLACE, FLOW_CLS_DESTROY, FLOW_CLS_STATS 세 가지 명령으로 구성됩니다. 사용자가 tc filter add를 실행하면 커널은 fl_hw_replace_filter()를 통해 드라이버의 ndo_setup_tc를 호출하고, 드라이버는 하드웨어 플로 테이블(Flow Table)에 규칙을 삽입합니다.

/* 완전한 flower 오프로드 콜백 구현 */
static int my_flower_replace(struct my_priv *priv,
                             struct flow_cls_offload *f)
{
    struct flow_rule *rule = flow_cls_offload_flow_rule(f);
    struct flow_match_eth_addrs match_eth;
    struct flow_match_ipv4_addrs match_ip;
    struct flow_match_ports match_ports;
    struct my_flow_entry *entry;
    int err;

    /* 매치 키 파싱 */
    if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ETH_ADDRS))
        flow_rule_match_eth_addrs(rule, &match_eth);

    if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_IPV4_ADDRS))
        flow_rule_match_ipv4_addrs(rule, &match_ip);

    if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_PORTS))
        flow_rule_match_ports(rule, &match_ports);

    /* 지원하지 않는 매치 키 검사 */
    if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_KEYID)) {
        NL_SET_ERR_MSG_MOD(f->common.extack,
            "tunnel key match not supported");
        return -EOPNOTSUPP;
    }

    /* 액션 파싱 */
    if (!flow_action_has_entries(&rule->action))
        return -EINVAL;

    entry = kzalloc(sizeof(*entry), GFP_KERNEL);
    if (!entry)
        return -ENOMEM;

    entry->cookie = f->cookie;

    /* HW 플로 테이블에 규칙 삽입 */
    err = my_hw_add_flow(priv, entry, rule);
    if (err) {
        kfree(entry);
        return err;
    }

    /* 쿠키 기반 해시 테이블에 저장 (나중에 삭제/통계 조회용) */
    hash_add(priv->flow_table, &entry->node,
             entry->cookie);
    return 0;
}

static int my_flower_destroy(struct my_priv *priv,
                             struct flow_cls_offload *f)
{
    struct my_flow_entry *entry;

    entry = my_flow_lookup(priv, f->cookie);
    if (!entry)
        return -ENOENT;

    my_hw_del_flow(priv, entry);
    hash_del(&entry->node);
    kfree(entry);
    return 0;
}

static int my_flower_stats(struct my_priv *priv,
                            struct flow_cls_offload *f)
{
    struct my_flow_entry *entry;
    u64 packets, bytes, lastused;

    entry = my_flow_lookup(priv, f->cookie);
    if (!entry)
        return -ENOENT;

    my_hw_read_flow_stats(priv, entry,
                          &packets, &bytes, &lastused);
    flow_stats_update(&f->stats, bytes, packets,
                      0, lastused,
                      FLOW_ACTION_HW_STATS_DELAYED);
    return 0;
}

/* block 콜백 진입점 */
static int my_tc_block_cb(enum tc_setup_type type,
                          void *type_data, void *cb_priv)
{
    struct my_priv *priv = cb_priv;
    struct flow_cls_offload *f = type_data;

    if (type != TC_SETUP_CLSFLOWER)
        return -EOPNOTSUPP;

    switch (f->command) {
    case FLOW_CLS_REPLACE:
        return my_flower_replace(priv, f);
    case FLOW_CLS_DESTROY:
        return my_flower_destroy(priv, f);
    case FLOW_CLS_STATS:
        return my_flower_stats(priv, f);
    default:
        return -EOPNOTSUPP;
    }
}

하드웨어 Flow Table 관리

하드웨어 플로 테이블(Hardware Flow Table)은 TCAM(Ternary Content-Addressable Memory) 또는 eSwitch의 플로 테이블로 구현됩니다. 테이블 항목의 생명주기를 올바르게 관리하지 않으면 규칙 누수(Rule Leak)나 스톨(Stall) 오프로드(Stale Offload)가 발생합니다.

각 플로 항목은 tc가 할당한 쿠키(Cookie)로 식별됩니다. 쿠키는 규칙의 전체 생명주기 동안 유일하며, FLOW_CLS_DESTROY 시 드라이버는 이 쿠키로 대응하는 하드웨어 항목을 찾아 삭제합니다.

/* 부분 오프로드 처리 패턴 */
static int my_flower_replace_partial(struct my_priv *priv,
                                     struct flow_cls_offload *f)
{
    struct flow_rule *rule = flow_cls_offload_flow_rule(f);
    const struct flow_action_entry *act;
    int i;

    /* 모든 액션 순회하며 HW 지원 여부 확인 */
    flow_action_for_each(i, act, &rule->action) {
        switch (act->id) {
        case FLOW_ACTION_DROP:
        case FLOW_ACTION_REDIRECT:
        case FLOW_ACTION_MIRRED:
            break;  /* 지원 */

        case FLOW_ACTION_MANGLE:
            /* 헤더 수정: L3/L4만 지원, L2 수정은 SW fallback */
            if (act->mangle.htype == FLOW_ACT_MANGLE_HDR_TYPE_ETH) {
                NL_SET_ERR_MSG_MOD(f->common.extack,
                    "L2 header modification not supported in HW");
                return -EOPNOTSUPP;
            }
            break;

        default:
            NL_SET_ERR_MSG_MOD(f->common.extack,
                "unsupported action for HW offload");
            return -EOPNOTSUPP;
        }
    }

    /* HW 테이블 용량 확인 */
    if (atomic_read(&priv->flow_count) >= priv->max_flows) {
        NL_SET_ERR_MSG_MOD(f->common.extack,
            "HW flow table full");
        return -ENOSPC;
    }

    return my_hw_insert_flow(priv, f);
}

switchdev 통합과 FDB 오프로드

switchdev 모델은 하드웨어 스위치 ASIC를 리눅스 브리지(Linux Bridge)와 통합하는 프레임워크입니다. 드라이버는 SWITCHDEV_OBJ_ID_PORT_FDB 등의 알림(Notification)을 처리하여 FDB(Forwarding Database) 항목을 하드웨어에 오프로드합니다.

/* switchdev 알림 등록과 FDB 오프로드 */
static int my_switchdev_event(struct notifier_block *nb,
                              unsigned long event,
                              void *ptr)
{
    struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
    struct switchdev_notifier_fdb_info *fdb_info;

    if (!my_is_our_port(dev))
        return NOTIFY_DONE;

    switch (event) {
    case SWITCHDEV_FDB_ADD_TO_DEVICE:
        fdb_info = ptr;
        /* 비동기 처리를 위해 workqueue에 이관 */
        my_schedule_fdb_work(dev, fdb_info, true);
        break;

    case SWITCHDEV_FDB_DEL_TO_DEVICE:
        fdb_info = ptr;
        my_schedule_fdb_work(dev, fdb_info, false);
        break;
    }

    return NOTIFY_DONE;
}

static struct notifier_block my_switchdev_nb = {
    .notifier_call = my_switchdev_event,
};

/* 모듈 초기화 시 등록 */
static int __init my_sw_init(void)
{
    int err;

    err = register_switchdev_notifier(&my_switchdev_nb);
    if (err)
        return err;

    err = register_switchdev_blocking_notifier(
              &my_switchdev_blocking_nb);
    if (err) {
        unregister_switchdev_notifier(&my_switchdev_nb);
        return err;
    }

    return 0;
}

UDP 터널 오프로드

VXLAN(Virtual Extensible LAN), Geneve 등의 UDP 터널은 NIC 하드웨어가 외부 UDP 포트를 인식해야 내부 패킷의 RSS, checksum offload 등이 올바르게 동작합니다. udp_tunnel_nic_info 구조체를 통해 드라이버는 지원하는 터널 유형과 최대 포트 수를 선언합니다.

/* UDP 터널 오프로드 구성 */
static const struct udp_tunnel_nic_info my_tunnel_info = {
    .set_port   = my_udp_tunnel_set_port,
    .unset_port = my_udp_tunnel_unset_port,
    .sync_table = my_udp_tunnel_sync,
    .flags      = UDP_TUNNEL_NIC_INFO_MAY_SLEEP |
                  UDP_TUNNEL_NIC_INFO_OPEN_ONLY,
    .tables     = {
        {
            .n_entries  = 2,  /* 최대 2개 VXLAN 포트 */
            .tunnel_types = UDP_TUNNEL_TYPE_VXLAN,
        },
        {
            .n_entries  = 2,  /* 최대 2개 Geneve 포트 */
            .tunnel_types = UDP_TUNNEL_TYPE_GENEVE,
        },
    },
};

/* set_port 콜백: HW에 UDP 포트 등록 */
static int my_udp_tunnel_set_port(
    struct net_device *ndev,
    unsigned int table, unsigned int entry,
    struct udp_tunnel_info *ti)
{
    struct my_priv *priv = netdev_priv(ndev);
    u16 port = ntohs(ti->port);

    netdev_info(ndev,
        "adding UDP tunnel port %u type %d\n",
        port, ti->type);

    /* 하드웨어 레지스터에 터널 포트 설정 */
    my_hw_write_tunnel_port(priv, table, entry, port,
                            ti->type);

    /* RSS 해시 정책을 터널 내부 헤더 기반으로 변경 */
    my_hw_set_inner_rss(priv, true);

    return 0;
}

/* ndo_open 시 터널 포트 동기화 요청 */
static int my_ndo_open_with_tunnel(struct net_device *ndev)
{
    int err;

    err = my_hw_init(ndev);
    if (err)
        return err;

    /* 커널에 등록된 터널 포트를 HW로 푸시 */
    udp_tunnel_nic_reset_ntf(ndev);

    netif_tx_start_all_queues(ndev);
    return 0;
}

리셋/장애 복구: devlink health와 watchdog

실서비스에서는 드라이버의 평균 성능보다 복구 전략이 더 중요합니다. TX timeout, 펌웨어 hang, PCI AER 오류에서 자동 복구가 되지 않으면 장기 장애로 이어집니다.

/* 개념 예시: tx_timeout 복구를 workqueue로 분리 */
static void my_tx_timeout(struct net_device *ndev, unsigned int txqueue)
{
    struct my_priv *priv = netdev_priv(ndev);

    netdev_warn(ndev, "tx timeout on queue %u\\n", txqueue);
    schedule_work(&priv->reset_work);
}

static void my_reset_work(struct work_struct *work)
{
    struct my_priv *priv = container_of(work, struct my_priv, reset_work);

    rtnl_lock();
    my_ndo_stop(priv->ndev);
    my_hw_function_reset(priv);
    my_ndo_open(priv->ndev);
    rtnl_unlock();
}

• watchdog: ndo_tx_timeout()에서 즉시 heavy reset을 수행하지 말고 workqueue로 이관
• devlink health: reporter dump/recover 콜백으로 운영팀의 장애 자동화와 연동
• AER 연계: PCIe fatal/non-fatal 이벤트를 reset state machine과 통합

devlink health reporter 등록과 사용

devlink health 프레임워크는 NIC 드라이버의 장애 감지, 진단, 자동 복구를 체계화하는 인프라입니다. 리포터(Reporter)를 등록하면 devlink health 명령으로 운영팀이 장애 상태를 조회하고, 자동 복구를 트리거할 수 있습니다.

/* 완전한 devlink health reporter 구현 */
static int my_health_recover(struct devlink_health_reporter *reporter,
                             void *priv_ctx,
                             struct netlink_ext_ack *extack)
{
    struct my_priv *priv = devlink_health_reporter_priv(reporter);
    int err;

    netdev_info(priv->ndev, "health recover: performing FLR\n");

    rtnl_lock();
    if (netif_running(priv->ndev))
        my_ndo_stop(priv->ndev);

    err = my_hw_function_reset(priv);
    if (err) {
        NL_SET_ERR_MSG_MOD(extack, "FLR failed");
        rtnl_unlock();
        return err;
    }

    err = my_ndo_open(priv->ndev);
    rtnl_unlock();
    return err;
}

static int my_health_dump(struct devlink_health_reporter *reporter,
                          struct devlink_fmsg *fmsg, void *priv_ctx,
                          struct netlink_ext_ack *extack)
{
    struct my_priv *priv = devlink_health_reporter_priv(reporter);
    struct my_err_ctx *ctx = priv_ctx;
    int err;

    err = devlink_fmsg_obj_nest_start(fmsg);
    if (err)
        return err;

    if (ctx) {
        devlink_fmsg_put(fmsg, "error_type", ctx->err_type);
        devlink_fmsg_put(fmsg, "queue_id", ctx->queue_id);
        devlink_fmsg_put(fmsg, "timestamp", ctx->timestamp);
    }

    devlink_fmsg_put(fmsg, "fw_state", my_hw_read_fw_state(priv));
    devlink_fmsg_put(fmsg, "hw_status", my_hw_read_status(priv));

    devlink_fmsg_pair_nest_start(fmsg, "queues");
    devlink_fmsg_arr_pair_nest_start(fmsg, "tx_queues");
    for (int i = 0; i < priv->num_tx_queues; i++) {
        devlink_fmsg_obj_nest_start(fmsg);
        devlink_fmsg_put(fmsg, "idx", i);
        devlink_fmsg_put(fmsg, "head", priv->tx_ring[i].head);
        devlink_fmsg_put(fmsg, "tail", priv->tx_ring[i].tail);
        devlink_fmsg_obj_nest_end(fmsg);
    }
    devlink_fmsg_arr_pair_nest_end(fmsg);
    devlink_fmsg_pair_nest_end(fmsg);

    return devlink_fmsg_obj_nest_end(fmsg);
}

static int my_health_diagnose(struct devlink_health_reporter *reporter,
                              struct devlink_fmsg *fmsg,
                              struct netlink_ext_ack *extack)
{
    struct my_priv *priv = devlink_health_reporter_priv(reporter);

    devlink_fmsg_obj_nest_start(fmsg);
    devlink_fmsg_put(fmsg, "link_up", netif_carrier_ok(priv->ndev));
    devlink_fmsg_put(fmsg, "fw_heartbeat", my_hw_check_heartbeat(priv));
    devlink_fmsg_put(fmsg, "pci_status", my_check_pci_status(priv));
    return devlink_fmsg_obj_nest_end(fmsg);
}

static const struct devlink_health_reporter_ops my_health_ops = {
    .name     = "tx",
    .recover  = my_health_recover,
    .dump     = my_health_dump,
    .diagnose = my_health_diagnose,
};

/* 프로브 시 리포터 등록 */
static int my_probe_health(struct my_priv *priv)
{
    priv->health_reporter = devlink_health_reporter_create(
        priv->devlink, &my_health_ops, 0, priv);
    return IS_ERR(priv->health_reporter) ?
           PTR_ERR(priv->health_reporter) : 0;
}

/* tx_timeout에서 health report 트리거 */
static void my_tx_timeout_health(struct net_device *ndev,
                                 unsigned int txqueue)
{
    struct my_priv *priv = netdev_priv(ndev);
    struct my_err_ctx ctx = {
        .err_type = "tx_timeout",
        .queue_id = txqueue,
        .timestamp = ktime_get_real_ns(),
    };
    devlink_health_report(priv->health_reporter,
                          "TX timeout detected", &ctx);
}

리셋 수준 세분화

NIC 리셋은 영향 범위에 따라 여러 수준으로 나뉩니다. 가능한 한 가장 좁은 범위의 리셋을 먼저 시도하고, 실패 시 더 넓은 범위로 에스컬레이션(Escalation)하는 것이 서비스 영향을 최소화하는 핵심입니다.

/* 다단계 리셋 구현 */
static int my_escalated_reset(struct my_priv *priv,
                              enum my_reset_level level)
{
    int err;
    switch (level) {
    case MY_RESET_QUEUE:
        netdev_info(priv->ndev, "attempting queue-level reset\n");
        err = my_hw_queue_reset(priv, priv->err_queue);
        if (!err) return 0;
        /* fall through */
    case MY_RESET_FLR:
        my_ndo_stop(priv->ndev);
        err = pcie_flr(priv->pdev);
        if (!err && !my_hw_reinit(priv)) {
            my_ndo_open(priv->ndev);
            return 0;
        }
        /* fall through */
    case MY_RESET_PF:
        err = my_hw_pf_reset(priv);
        if (!err) { my_ndo_open(priv->ndev); return 0; }
        netdev_err(priv->ndev, "PF reset failed\n");
        return err;
    default: return -EINVAL;
    }
}

/* devlink reload 지원 */
static int my_devlink_reload_down(struct devlink *devlink, bool netns_change,
    enum devlink_reload_action action, enum devlink_reload_limit limit,
    struct netlink_ext_ack *extack)
{
    struct my_priv *priv = devlink_priv(devlink);
    if (action == DEVLINK_RELOAD_ACTION_DRIVER_REINIT) {
        rtnl_lock();
        if (netif_running(priv->ndev)) my_ndo_stop(priv->ndev);
        rtnl_unlock();
    }
    return 0;
}

static int my_devlink_reload_up(struct devlink *devlink,
    enum devlink_reload_action action, enum devlink_reload_limit limit,
    u32 *actions_performed, struct netlink_ext_ack *extack)
{
    struct my_priv *priv = devlink_priv(devlink);
    *actions_performed = BIT(action);
    my_hw_reinit(priv);
    rtnl_lock(); my_ndo_open(priv->ndev); rtnl_unlock();
    return 0;
}

PCIe AER 복구 통합

PCIe AER(Advanced Error Reporting)은 하드웨어 오류를 감지하고 복구하는 PCIe 표준 메커니즘입니다. NIC 드라이버는 pci_error_handlers를 등록하여 커널의 AER 복구 흐름에 참여합니다. 복구는 error_detected → slot_reset → resume 세 단계로 진행됩니다.

/* 완전한 pci_error_handlers 구현 */
static pci_ers_result_t my_pci_error_detected(struct pci_dev *pdev,
                                                pci_channel_state_t state)
{
    struct my_priv *priv = pci_get_drvdata(pdev);
    netdev_info(priv->ndev, "PCI error detected, state=%d\n", state);
    if (state == pci_channel_io_perm_failure)
        return PCI_ERS_RESULT_DISCONNECT;
    rtnl_lock();
    netif_device_detach(priv->ndev);
    if (netif_running(priv->ndev)) my_ndo_stop(priv->ndev);
    rtnl_unlock();
    set_bit(MY_FLAG_PCI_ERR, &priv->flags);
    pci_disable_device(pdev);
    return PCI_ERS_RESULT_NEED_RESET;
}

static pci_ers_result_t my_pci_slot_reset(struct pci_dev *pdev)
{
    struct my_priv *priv = pci_get_drvdata(pdev);
    int err;
    err = pci_enable_device(pdev);
    if (err) return PCI_ERS_RESULT_DISCONNECT;
    pci_set_master(pdev);
    pci_restore_state(pdev);
    pci_save_state(pdev);
    err = my_hw_reinit(priv);
    if (err) return PCI_ERS_RESULT_DISCONNECT;
    return PCI_ERS_RESULT_RECOVERED;
}

static void my_pci_resume(struct pci_dev *pdev)
{
    struct my_priv *priv = pci_get_drvdata(pdev);
    clear_bit(MY_FLAG_PCI_ERR, &priv->flags);
    rtnl_lock();
    my_ndo_open(priv->ndev);
    netif_device_attach(priv->ndev);
    rtnl_unlock();
    devlink_health_reporter_state_update(priv->health_reporter,
        DEVLINK_HEALTH_REPORTER_STATE_HEALTHY);
}

static const struct pci_error_handlers my_pci_err_handlers = {
    .error_detected = my_pci_error_detected,
    .slot_reset     = my_pci_slot_reset,
    .resume         = my_pci_resume,
};

펌웨어 리셋과 라이브 패치

devlink dev flash 명령은 NIC 펌웨어를 라이브 업데이트합니다. 드라이버는 devlink_flash_update_params를 통해 업데이트 요청을 받고, 펌웨어를 하드웨어에 기록한 후 활성화(Activation) 방식을 결정합니다.

/* 펌웨어 업데이트와 알림 구현 */
static int my_devlink_flash_update(struct devlink *devlink,
    struct devlink_flash_update_params *params,
    struct netlink_ext_ack *extack)
{
    struct my_priv *priv = devlink_priv(devlink);
    const struct firmware *fw = params->fw;
    u32 offset = 0;
    int err;

    err = my_fw_validate_header(priv, fw->data, fw->size);
    if (err) {
        NL_SET_ERR_MSG_MOD(extack, "invalid firmware header");
        return err;
    }

    if (!(params->overwrite_mask & DEVLINK_FLASH_OVERWRITE_SETTINGS)) {
        if (my_fw_is_downgrade(priv, fw)) {
            NL_SET_ERR_MSG_MOD(extack, "firmware downgrade not allowed");
            return -EPERM;
        }
    }

    devlink_flash_update_status_notify(devlink, "Preparing", NULL, 0, 0);

    while (offset < fw->size) {
        u32 chunk = min_t(u32, fw->size - offset, MY_FW_CHUNK_SIZE);
        err = my_hw_write_fw_chunk(priv, fw->data + offset, chunk, offset);
        if (err) return err;
        offset += chunk;
        devlink_flash_update_status_notify(devlink,
            "Flashing", NULL, offset, fw->size);
    }

    if (priv->caps & MY_CAP_FW_LIVE_PATCH) {
        err = my_hw_fw_activate(priv, MY_FW_ACTIVATE_IMMEDIATE);
        devlink_flash_update_status_notify(devlink,
            "Activated (live)", NULL, 0, 0);
    } else {
        err = my_hw_fw_activate(priv, MY_FW_ACTIVATE_PENDING);
        devlink_flash_update_status_notify(devlink,
            "Pending reset", NULL, 0, 0);
    }

    devlink_flash_update_timeout_notify(devlink,
        "Flash complete", NULL, 120);
    return err;
}

static const struct devlink_ops my_devlink_ops = {
    .reload_actions = BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT) |
                      BIT(DEVLINK_RELOAD_ACTION_FW_ACTIVATE),
    .reload_down    = my_devlink_reload_down,
    .reload_up      = my_devlink_reload_up,
    .flash_update   = my_devlink_flash_update,
};

오프로드 계약: checksum/GSO/GRO/VLAN

오프로드 기능은 “켜고 끄는 옵션”이 아니라 드라이버와 스택 사이의 계약입니다. advertise한 기능을 데이터 경로에서 일관되게 지키지 않으면 패킷 손실, checksum 오류, MTU 이상 동작이 발생합니다.

/* 개념 예시: feature dependency를 fix_features에서 강제 */
static netdev_features_t my_ndo_fix_features(struct net_device *ndev,
                                       netdev_features_t features)
{
    /* HW가 IPv6 TSO를 지원하지 않으면 강제 비활성화 */
    if (!(features & NETIF_F_IP_CSUM))
        features &= ~NETIF_F_TSO;

    if (!my_hw_supports_tso6(ndev))
        features &= ~NETIF_F_TSO6;

    return features;
}

static netdev_features_t my_ndo_features_check(struct sk_buff *skb,
                                            struct net_device *ndev,
                                            netdev_features_t features)
{
    /* 헤더 길이/세그먼트 조건 미충족 시 SW fallback */
    if (skb_is_gso(skb) && skb_shinfo(skb)->gso_segs > 512)
        features &= ~(NETIF_F_GSO_MASK);

    return features;
}

PTP 하드웨어 타임스탬프와 시간 동기화

금융/통신/분산 DB 워크로드에서는 네트워크 성능만큼 시간 정확도가 중요합니다. PTP 지원 NIC 드라이버는 SIOCSHWTSTAMP 설정, TX timestamp completion, PHC 노출을 안정적으로 제공해야 합니다.

/* 개념 예시: HW timestamp 사용자 요청 검증 */
static int my_hwtstamp_set(struct net_device *ndev, struct ifreq *ifr)
{
    struct hwtstamp_config cfg;

    if (copy_from_user(&cfg, ifr->ifr_data, sizeof(cfg)))
        return -EFAULT;

    if (cfg.tx_type != HWTSTAMP_TX_OFF && cfg.tx_type != HWTSTAMP_TX_ON)
        return -ERANGE;

    my_hw_config_timestamp(ndev, &cfg);

    if (copy_to_user(ifr->ifr_data, &cfg, sizeof(cfg)))
        return -EFAULT;

    return 0;
}

• PHC: /dev/ptpN 제공과 ptp4l/phc2sys 연동 검증
• TX timestamp: skb 소유권과 timestamp completion 경합 방지
• RX filter: 지원 가능한 timestamp filter를 정확히 반환

SR-IOV, representor, 스위치 모드 전환

클라우드 환경에서는 PF/VF 분리와 representor netdev 운영이 기본입니다. 드라이버는 legacy 모드와 switchdev 모드 전환 시 control-plane 일관성을 보장해야 합니다.

/* 개념 예시: eswitch 모드 전환과 대표자 netdev 동기화 */
static int my_eswitch_mode_set(struct my_priv *priv, u16 mode)
{
    if (mode == DEVLINK_ESWITCH_MODE_SWITCHDEV)
        return my_enable_representors(priv);
    if (mode == DEVLINK_ESWITCH_MODE_LEGACY)
        return my_disable_representors(priv);

    return -EOPNOTSUPP;
}

검증 매트릭스: 릴리스 전 체크 항목

TX 큐 선택: ndo_select_queue, XPS, CPU locality

멀티큐 NIC에서 ndo_start_xmit() 성능은 큐 선택 품질에 크게 좌우됩니다. 플로우 해시(Hash), CPU affinity, XPS 정책이 맞지 않으면 lock 경합과 cache miss가 급증합니다.

/* 개념 예시: qdisc/XPS 힌트를 반영한 TX queue 선택 */
static u16 my_ndo_select_queue(struct net_device *dev, struct sk_buff *skb,
                               struct net_device *sb_dev)
{
    u32 hash = skb_get_hash(skb);
    u16 q = reciprocal_scale(hash, dev->real_num_tx_queues);

    /* 로컬 CPU 우선 정책이 있으면 q를 재매핑 */
    q = my_xps_remap(dev, q, raw_smp_processor_id());
    return q;
}

• XPS: /sys/class/net/<dev>/queues/tx-*/xps_cpus와 드라이버 큐 매핑(Mapping) 일치
• RFS/RPS와 충돌 회피: RX CPU와 TX completion CPU가 지나치게 분산되지 않도록 설계
• NUMA: queue memory, IRQ, NAPI poll CPU를 같은 노드로 묶어 캐시 효율 확보

Doorbell 메커니즘과 DMA 메모리 배리어(Memory Barrier)

약한 메모리 모델 CPU(ARM64 등)에서 descriptor write와 doorbell MMIO write의 순서가 보장되지 않으면 간헐적 TX hang이 생깁니다. 게시 경로에서 barrier 사용 규칙을 문서화해야 합니다.

Doorbell이란?

Doorbell은 PCIe BAR 공간의 장치 레지스터(Register)에 MMIO write를 수행하여 NIC에 새 작업(디스크립터)이 준비되었음을 알리는 메커니즘입니다. Doorbell이 없으면 NIC이 링 버퍼(Ring Buffer)를 지속적으로 폴링해야 하며, 이는 PCIe 대역폭(Bandwidth) 낭비와 전력 소모 증가를 초래합니다.

Doorbell의 핵심 속성은 다음과 같습니다.

• 단일 원자적(Atomic) MMIO write: 일반적으로 4바이트(32비트) 크기이며, CPU의 단일 스토어 명령으로 실행됩니다.
• PCIe 트랜잭션(Transaction) 비용: doorbell 1회당 수백 나노초(200~500 ns)가 소요되며, PCIe TLP(Transaction Layer Packet) 오버헤드를 포함합니다.
• 메모리 배리어 선행 필수: doorbell 이전에 반드시 적절한 메모리 배리어(dma_wmb())가 선행되어야 디바이스가 완전한 디스크립터를 읽을 수 있습니다.

서브시스템별 Doorbell 비교

Doorbell 메커니즘은 NIC뿐 아니라 다양한 PCIe 디바이스 서브시스템에서 사용됩니다. 아래 표는 주요 서브시스템별 doorbell 특성을 비교합니다.

Doorbell 최적화 기법

Doorbell은 PCIe MMIO 트랜잭션이므로 호출 빈도를 줄이는 것이 성능 최적화의 핵심입니다. 주요 기법은 다음과 같습니다.

• 배치 게시(Batch Posting): 여러 디스크립터를 작성한 후 doorbell을 1회만 수행합니다. NVMe의 commit_rqs 콜백이 대표적인 패턴으로, 다수의 SQ entry를 기록한 뒤 마지막에 한 번만 tail doorbell을 갱신합니다. NIC 드라이버에서도 xmit_more 플래그를 확인하여 배치 doorbell을 구현할 수 있습니다.
• Shadow Doorbell: MMIO 대신 호스트 메모리 영역에 tail 값을 기록하고, 디바이스가 해당 메모리를 폴링하는 방식입니다. NVMe 1.3+ 스펙의 Shadow Doorbell Buffer가 대표적이며, PCIe MMIO 왕복 비용을 제거하여 수십 퍼센트의 IOPS 향상을 달성할 수 있습니다.
• Write Combining: doorbell 레지스터가 위치한 PCIe BAR 페이지(Page)를 WC(Write Combining) 매핑하여, 여러 doorbell write가 단일 PCIe 트랜잭션으로 합쳐지도록 합니다. 이를 통해 PCIe TLP 오버헤드를 줄이고 대역폭 효율을 향상시킵니다.

/* 개념 예시: doorbell 전 메모리 배리어 보장 */
static void my_post_tx_desc(struct my_priv *priv, struct my_desc *d)
{
    priv->tx_ring[d->idx] = *d;

    /* descriptor 메모리 write 완료 보장 */
    dma_wmb();

    /* 이후 doorbell write */
    writel(d->idx, priv->tx_doorbell);
}

Busy Poll/NAPI 조합과 지연 최적화

초저지연 워크로드에서는 interrupt moderation보다 busy-poll이 유리할 수 있습니다. 드라이버는 NAPI 상태 전이를 안정적으로 유지해 busy-poll 사용자와 일반 트래픽이 충돌하지 않게 해야 합니다.

# 실습 예제: busy poll 파라미터 조정 및 즉시 확인
# 소켓 단위 busy poll (마이크로초)
sysctl -w net.core.busy_poll=50
sysctl -w net.core.busy_read=50

# NIC interrupt moderation과 함께 튜닝
ethtool -C eth0 rx-usecs 0
ethtool -C eth0 tx-usecs 0

Busy Poll 내부 동작 원리

Busy poll의 핵심은 napi_busy_loop() 함수입니다. 소켓(Socket)이 데이터를 기다릴 때 인터럽트 기반 수신 대신 NAPI poll 함수를 직접 호출하여 패킷을 가져옵니다. 이 과정에서 커널은 sk_can_busy_loop()으로 소켓이 busy poll 가능 상태인지 먼저 확인합니다.

/* net/core/dev.c - napi_busy_loop() 핵심 경로 분석 */
void napi_busy_loop(unsigned int napi_id,
                    bool (*loop_end)(void *, unsigned long),
                    void *loop_end_arg, bool prefer_busy_poll,
                    u16 budget)
{
    unsigned long start_time = loop_end ? busy_loop_current_time() : 0;
    int (*napi_poll)(struct napi_struct *napi, int budget);
    struct napi_struct *napi;

    restart:
    napi_poll = NULL;

    rcu_read_lock();
    napi = napi_by_id(napi_id);
    if (!napi)
        goto out;

    /* NAPI가 스케줄 가능 상태인지 확인 */
    if (!test_bit(NAPI_STATE_SCHED, &napi->state))
        goto out;

    /* prefer_busy_poll 플래그로 NAPI 독점 모드 요청 */
    if (prefer_busy_poll)
        set_bit(NAPI_STATE_PREFER_BUSY_POLL, &napi->state);

    for (;;) {
        /* napi_poll 함수 포인터를 통해 드라이버의 poll 직접 호출 */
        work = napi_poll(napi, budget);

        if (loop_end && loop_end(loop_end_arg, start_time))
            break;

        /* 타임아웃 또는 시그널 확인 */
        if (need_resched())
            break;

        cpu_relax();  /* 전력 소모를 약간 줄이는 힌트 */
    }
out:
    rcu_read_unlock();
}

sk_can_busy_loop()은 소켓의 busy poll 적격 여부를 판단합니다. NAPI ID가 할당되어 있고, 소켓에 SO_BUSY_POLL 옵션이 설정되어 있어야 합니다.

/* include/net/busy_poll.h - busy poll 적격 판단 */
static inline bool sk_can_busy_loop(const struct sock *sk)
{
    /* 1) NAPI ID가 유효한지 (드라이버가 할당했는지) */
    /* 2) 소켓에 busy_poll 타임아웃이 설정되어 있는지 */
    /* 3) 소켓이 커널에 의해 잠기지 않았는지 */
    return sk->sk_napi_id &&
           READ_ONCE(sk->sk_ll_usec) &&
           !skb_queue_empty_lockless(&sk->sk_receive_queue);
}

Poll 예산(Budget)은 busy-poll 모드에서 일반 NAPI poll과 다르게 동작합니다. 기본 NAPI poll의 예산이 64인 반면, busy-poll에서는 소켓별로 설정된 예산을 사용하며, 이는 처리량과 독점 방지 사이의 균형을 조절합니다. NAPI_STATE_SCHED 비트가 설정되어 있어야 busy-poll이 NAPI를 접근할 수 있으며, 일반 인터럽트 기반 NAPI 스케줄링과 상호 배제됩니다.

드라이버 Busy Poll 지원 요구사항

현대 커널(v4.11+)에서 busy poll은 더 이상 별도의 ndo_busy_poll 콜백을 필요로 하지 않습니다. 대신 NAPI 기반 busy poll을 사용하며, 드라이버가 NAPI를 올바르게 구현하고 napi_id를 소켓에 연결하면 자동으로 지원됩니다.

드라이버의 busy poll 지원 핵심 요구사항은 다음과 같습니다.

• NAPI ID 할당: netif_napi_add() 호출 시 자동으로 고유 napi_id가 할당됩니다.
• 소켓-NAPI 연결: RX 경로에서 skb_mark_napi_id()를 호출하여 소켓이 어느 NAPI에서 패킷을 받는지 기록합니다.
• prefer_busy_poll 플래그: NAPI_STATE_PREFER_BUSY_POLL 비트가 설정되면 일반 인터럽트 기반 NAPI 스케줄링이 양보합니다.
• 예산 존중: poll 함수가 전달받은 budget 인자를 정확하게 존중해야 합니다.

/* 드라이버 busy poll 지원 확인 패턴 */
static int my_driver_rx_poll(struct napi_struct *napi, int budget)
{
    struct my_rx_ring *ring = container_of(napi, struct my_rx_ring, napi);
    int work_done = 0;

    while (work_done < budget) {
        struct sk_buff *skb = my_fetch_rx_packet(ring);
        if (!skb)
            break;

        /* 핵심: NAPI ID를 skb에 기록 → 소켓과 NAPI 연결 */
        skb_mark_napi_id(skb, napi);

        napi_gro_receive(napi, skb);
        work_done++;
    }

    if (work_done < budget) {
        napi_complete_done(napi, work_done);
        /* 인터럽트 재활성화 */
        my_enable_rx_irq(ring);
    }

    return work_done;
}

/* 드라이버 초기화에서 NAPI 등록 */
static void my_driver_init_napi(struct my_priv *priv)
{
    /* netif_napi_add()가 napi_id를 자동 할당 */
    netif_napi_add(priv->netdev, &priv->rx_ring.napi,
                   my_driver_rx_poll);
    napi_enable(&priv->rx_ring.napi);
}

소켓 레벨 Busy Poll 설정

소켓 레벨에서 busy poll을 활성화하는 방법은 두 가지입니다. 시스템 전역 sysctl 설정과 소켓별 옵션 설정이며, 소켓별 설정이 우선합니다. epoll 기반 이벤트 루프에서도 busy poll을 활용할 수 있습니다.

/* 애플리케이션 레벨 busy poll 설정 예시 */
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/epoll.h>

int setup_busy_poll_socket(int sockfd)
{
    int busy_poll_usec = 50;       /* 50μs busy poll 시간 */
    int prefer_busy_poll = 1;      /* busy poll 우선 모드 */
    int busy_budget = 8;           /* poll당 최대 처리 패킷 수 */

    /* SO_BUSY_POLL: 소켓별 busy poll 타임아웃 (μs) */
    setsockopt(sockfd, SOL_SOCKET, SO_BUSY_POLL,
               &busy_poll_usec, sizeof(busy_poll_usec));

    /* SO_PREFER_BUSY_POLL: 인터럽트 대신 busy poll 우선 */
    setsockopt(sockfd, SOL_SOCKET, SO_PREFER_BUSY_POLL,
               &prefer_busy_poll, sizeof(prefer_busy_poll));

    /* SO_BUSY_POLL_BUDGET: poll 1회당 처리 예산 */
    setsockopt(sockfd, SOL_SOCKET, SO_BUSY_POLL_BUDGET,
               &busy_budget, sizeof(busy_budget));

    return 0;
}

/* epoll 기반 busy poll 활용 */
int busy_poll_event_loop(int epfd, int sockfd)
{
    struct epoll_event events[64];

    setup_busy_poll_socket(sockfd);

    for (;;) {
        /* epoll_wait timeout=0 → busy poll이 데이터 폴링 */
        int n = epoll_wait(epfd, events, 64, 0);

        for (int i = 0; i < n; i++) {
            if (events[i].events & EPOLLIN) {
                /* 데이터 즉시 수신 가능 — 지연 최소화 */
                process_packet(events[i].data.fd);
            }
        }
    }
}

Busy Poll 성능 분석과 트레이드오프

Busy poll은 지연 시간을 극적으로 줄이지만 CPU 사용률이라는 대가를 치릅니다. 워크로드 특성에 따라 이 트레이드오프가 유리할 수도, 불리할 수도 있습니다.

Busy poll이 유리한 경우:

• 고빈도 트레이딩(HFT, High-Frequency Trading) 환경에서 마이크로초 단위 지연이 수익에 직결되는 경우
• DPDK 도입이 어려운 환경에서 커널 네트워크 스택을 유지하면서 지연을 최소화해야 하는 경우
• 전용 CPU 코어를 네트워크 처리에 할당할 수 있는 경우 (isolcpus, cpuset 활용)
• 패킷 도착률이 높아 인터럽트 오버헤드가 CPU 부하의 주요 원인인 경우

Busy poll이 불리한 경우:

• 멀티 테넌트(Multi-tenant) 환경에서 CPU를 공유해야 하는 경우
• 전력 소모가 제한된 임베디드(Embedded) 또는 모바일 환경
• 패킷 도착률이 낮아 대부분의 시간을 유휴 폴링에 소비하는 경우
• 다수의 소켓에서 동시에 busy poll을 사용하여 CPU 경합이 발생하는 경우

# bpftrace로 busy poll 효과 측정
# napi_busy_loop 진입/종료 시간 측정
bpftrace -e '
kprobe:napi_busy_loop {
    @start[tid] = nsecs;
}
kretprobe:napi_busy_loop /@start[tid]/ {
    @busy_loop_ns = hist(nsecs - @start[tid]);
    delete(@start[tid]);
}
'

# busy poll에서 실제 패킷을 처리한 비율 확인
bpftrace -e '
tracepoint:napi:napi_poll {
    @total++;
    if (args->work > 0) { @useful++; }
}
interval:s:5 {
    printf("유효 poll 비율: %d/%d (%d%%)\n",
           @useful, @total,
           @total ? @useful * 100 / @total : 0);
    clear(@total); clear(@useful);
}
'

# 지연 시간 비교: busy poll ON vs OFF
# 1) busy poll 비활성화 상태 측정
sysctl -w net.core.busy_poll=0
sockperf under-load -i 10.0.0.1 -p 12345 --mps=10000 -t 30

# 2) busy poll 활성화 상태 측정
sysctl -w net.core.busy_poll=50
sockperf under-load -i 10.0.0.1 -p 12345 --mps=10000 -t 30

회귀 테스트: packetdrill, kselftest, fault injection

netdev 드라이버는 환경 의존성이 커서 재현 테스트가 어렵습니다. 릴리스 전에 최소 회귀 시나리오를 자동화하면 “간헐적 링크 다운” 같은 문제를 조기에 차단할 수 있습니다.

netdevsim을 활용한 드라이버 테스트

netdevsim은 실제 하드웨어 없이 네트워크 드라이버 기능을 테스트할 수 있는 가상 장치(Virtual Device)입니다. TC 오프로드, devlink health, XDP, flow offload 등 다양한 드라이버 인터페이스를 시뮬레이션하므로 CI/CD 파이프라인에 통합하기 적합합니다.

netdevsim이 지원하는 주요 테스트 영역은 다음과 같습니다.

• TC flower 오프로드: 하드웨어 TC 규칙 추가/삭제/수정 테스트
• devlink health: reporter 등록, 진단 덤프, 자동 복구 테스트
• XDP: XDP 프로그램 로드/언로드, 다양한 verdict(PASS, DROP, TX, REDIRECT) 테스트
• devlink trap: 하드웨어 drop 이벤트 시뮬레이션
• devlink params: 드라이버 매개변수 설정/조회 테스트

# netdevsim 테스트 스크립트
#!/bin/bash

set -e

# 1. netdevsim 장치 생성
modprobe netdevsim
echo "1 1" > /sys/bus/netdevsim/new_device
DEV_NAME=$(ls /sys/bus/netdevsim/devices/netdevsim1/net/)
echo "netdevsim 인터페이스: $DEV_NAME"

# 인터페이스 활성화
ip link set dev $DEV_NAME up

# 2. TC flower 오프로드 테스트
echo "--- TC flower 오프로드 테스트 ---"
tc qdisc add dev $DEV_NAME ingress
tc filter add dev $DEV_NAME ingress protocol ip \
    flower src_ip 192.168.1.0/24 dst_ip 10.0.0.0/8 \
    action drop skip_sw

# 오프로드된 규칙 확인
tc -s filter show dev $DEV_NAME ingress
echo "TC 오프로드 규칙 수:"
tc -s filter show dev $DEV_NAME ingress | grep -c "in_hw"

# 3. devlink health reporter 테스트
echo "--- devlink health 테스트 ---"
DEVLINK_DEV=$(devlink dev show | head -1 | awk '{print $1}')
devlink health show $DEVLINK_DEV

# 4. XDP 프로그램 로드 테스트
echo "--- XDP 로드 테스트 ---"
# 간단한 XDP_PASS 프로그램 (사전 컴파일 필요)
if [ -f /tmp/xdp_pass.o ]; then
    ip link set dev $DEV_NAME xdp obj /tmp/xdp_pass.o sec xdp
    ip link show dev $DEV_NAME | grep xdp
    ip link set dev $DEV_NAME xdp off
fi

# 5. devlink trap 테스트
echo "--- devlink trap 테스트 ---"
devlink trap show $DEVLINK_DEV 2>/dev/null | head -10

# 6. 정리
echo "--- 정리 ---"
tc qdisc del dev $DEV_NAME ingress 2>/dev/null
echo 1 > /sys/bus/netdevsim/del_device
echo "netdevsim 테스트 완료"

kselftest 네트워크 테스트 실행

커널 소스 트리의 tools/testing/selftests/net/ 디렉터리에는 네트워크 기능을 검증하는 자동화 테스트가 포함되어 있습니다. 드라이버 개발자는 변경 사항이 기존 기능을 깨뜨리지 않는지 kselftest를 통해 검증해야 합니다.

주요 테스트 카테고리는 다음과 같습니다.

# kselftest 네트워크 테스트 실행 가이드

# 1. 커널 소스에서 전체 네트워크 셀프테스트 빌드 및 실행
cd /path/to/linux
make -C tools/testing/selftests TARGETS=net run_tests

# 2. 특정 테스트만 실행
# 포워딩 테스트
make -C tools/testing/selftests TARGETS=net/forwarding run_tests

# 3. 개별 테스트 스크립트 직접 실행
cd tools/testing/selftests/net
./fib_tests.sh
./gro.sh

# 4. 커스텀 kselftest 예시: 드라이버 기능 검증
#!/bin/bash
# SPDX-License-Identifier: GPL-2.0
# 드라이버 MTU 변경 테스트

source lib.sh

# 네임스페이스 생성
setup_ns NS1 NS2
trap cleanup_ns EXIT

# veth 쌍 생성
ip link add veth0 netns $NS1 type veth peer name veth1 netns $NS2
ip -n $NS1 link set veth0 up
ip -n $NS2 link set veth1 up
ip -n $NS1 addr add 10.0.0.1/24 dev veth0
ip -n $NS2 addr add 10.0.0.2/24 dev veth1

# MTU 변경 테스트
for mtu in 576 1500 9000; do
    ip -n $NS1 link set veth0 mtu $mtu
    ip -n $NS2 link set veth1 mtu $mtu

    # ping으로 연결 확인 (MTU - IP/ICMP 헤더)
    payload_size=$((mtu - 28))
    if ip netns exec $NS1 ping -c 3 -s $payload_size -M do 10.0.0.2 >/dev/null 2>&1; then
        echo "PASS: MTU $mtu - ping 성공"
    else
        echo "FAIL: MTU $mtu - ping 실패"
        exit 1
    fi
done

echo "모든 MTU 테스트 통과"
exit 0

Fault Injection을 통한 복구 경로 검증

정상 경로(Happy Path)만 테스트해서는 드라이버의 안정성을 보장할 수 없습니다. DMA 매핑 실패, 메모리 할당 실패, 함수 에러 반환 등 오류 경로를 의도적으로 유발하여 드라이버의 복구 로직이 올바르게 동작하는지 검증해야 합니다.

커널은 다양한 오류 주입(Fault Injection) 프레임워크를 제공합니다.

• fail_function: 특정 커널 함수가 에러를 반환하도록 설정합니다. DMA 매핑 함수(dma_map_single)를 실패시켜 드라이버의 DMA 에러 처리를 검증할 수 있습니다.
• fail_page_alloc: 페이지 할당 실패를 시뮬레이션합니다. 링 버퍼 리필(Refill) 실패 시 드라이버가 graceful하게 대응하는지 확인합니다.
• fail_make_request: 블록 I/O 요청 실패를 유발합니다 (네트워크보다는 스토리지 드라이버에 유용).
• KFENCE: 메모리 접근 오류를 샘플링 기반으로 감지합니다.

# Fault Injection 테스트 스크립트
#!/bin/bash

set -e

DEV="eth0"
FAULT_DIR="/sys/kernel/debug/fail_function"

echo "=== Fault Injection 복구 경로 테스트 ==="

# 필수 커널 설정 확인
# CONFIG_FAULT_INJECTION=y
# CONFIG_FAIL_FUNCTION=y
# CONFIG_FAULT_INJECTION_DEBUG_FS=y

if [ ! -d "$FAULT_DIR" ]; then
    echo "ERROR: fail_function not available"
    echo "커널 CONFIG_FAIL_FUNCTION=y 필요"
    exit 1
fi

# 테스트 1: DMA 매핑 실패 시 복구
echo "--- 테스트 1: dma_map_single 실패 ---"
echo dma_map_single > $FAULT_DIR/inject

# 확률 설정: 10% 확률로 실패
echo 10 > /sys/kernel/debug/fail_function/probability
echo 1 > /sys/kernel/debug/fail_function/times
echo 0 > /sys/kernel/debug/fail_function/space
echo 1 > /sys/kernel/debug/fail_function/verbose

# 부하 생성하여 오류 경로 유발
ping -c 100 -f 10.0.0.2 2>/dev/null || true

# 드라이버 상태 확인 (크래시/행 여부)
if ip link show $DEV >/dev/null 2>&1; then
    echo "PASS: 인터페이스 정상 유지"
else
    echo "FAIL: 인터페이스 비정상"
fi

# 오류 주입 해제
echo > $FAULT_DIR/inject

# 테스트 2: 메모리 할당 실패 (fail_page_alloc)
echo "--- 테스트 2: 페이지 할당 실패 ---"
echo 1 > /proc/sys/vm/fault_injection/fail_page_alloc/probability
echo 5 > /proc/sys/vm/fault_injection/fail_page_alloc/times

# RX 링 리필 경로 유발 (대량 패킷 수신)
ip netns exec ns_remote iperf3 -c 10.0.0.1 -t 5 -b 1G 2>/dev/null || true

# 오류 주입 해제
echo 0 > /proc/sys/vm/fault_injection/fail_page_alloc/probability

# 통계 확인
echo "--- 드라이버 에러 카운터 ---"
ethtool -S $DEV | grep -iE "alloc.*fail|dma.*err|drop"

# dmesg에서 드라이버 경고/에러 확인
echo "--- 관련 dmesg ---"
dmesg | tail -20 | grep -iE "$DEV|dma|alloc|fail"

echo "Fault injection 테스트 완료"

네트워크 네임스페이스 기반 격리 테스트

네트워크 네임스페이스(Network Namespace)를 사용하면 호스트 네트워크에 영향을 주지 않고 드라이버 기능을 안전하게 테스트할 수 있습니다. veth 쌍으로 격리된 환경을 만들고, iperf3/netperf로 부하를 생성하며, tcpdump/tshark로 패킷을 검증하는 테스트 하네스(Test Harness)를 구축합니다.

# 네임스페이스 기반 종합 테스트 하네스
#!/bin/bash

set -e

# 네임스페이스 이름
NS1="ns_sender"
NS2="ns_receiver"
RESULTS="/tmp/netns-test-$(date +%s)"
mkdir -p $RESULTS

cleanup() {
    ip netns del $NS1 2>/dev/null || true
    ip netns del $NS2 2>/dev/null || true
    echo "정리 완료"
}
trap cleanup EXIT

# 1. 네임스페이스 및 veth 쌍 생성
echo "=== 네임스페이스 환경 구성 ==="
ip netns add $NS1
ip netns add $NS2

ip link add veth-s type veth peer name veth-r
ip link set veth-s netns $NS1
ip link set veth-r netns $NS2

# IP 설정
ip netns exec $NS1 ip addr add 10.0.0.1/24 dev veth-s
ip netns exec $NS2 ip addr add 10.0.0.2/24 dev veth-r
ip netns exec $NS1 ip link set veth-s up
ip netns exec $NS2 ip link set veth-r up
ip netns exec $NS1 ip link set lo up
ip netns exec $NS2 ip link set lo up

# 2. 기본 연결 테스트
echo "--- 기본 연결 ---"
ip netns exec $NS1 ping -c 3 10.0.0.2 | tail -1

# 3. MTU 변경 테스트
echo "--- MTU 테스트 ---"
for mtu in 68 576 1500 9000; do
    ip netns exec $NS1 ip link set veth-s mtu $mtu
    ip netns exec $NS2 ip link set veth-r mtu $mtu
    if ip netns exec $NS1 ping -c 1 -s $((mtu - 28)) -M do 10.0.0.2 >/dev/null 2>&1; then
        echo "  MTU $mtu: PASS"
    else
        echo "  MTU $mtu: FAIL"
    fi
done

# MTU 복원
ip netns exec $NS1 ip link set veth-s mtu 1500
ip netns exec $NS2 ip link set veth-r mtu 1500

# 4. 처리량 테스트 (iperf3)
echo "--- 처리량 테스트 ---"
ip netns exec $NS2 iperf3 -s -D -p 5201
sleep 1
ip netns exec $NS1 iperf3 -c 10.0.0.2 -t 10 -p 5201 \
    --json > $RESULTS/iperf3.json
# 결과 추출
python3 -c "
import json, sys
data = json.load(open('$RESULTS/iperf3.json'))
bps = data['end']['sum_sent']['bits_per_second']
print(f'  처리량: {bps/1e9:.2f} Gbps')
"

# 5. 패킷 캡처 검증
echo "--- 패킷 캡처 테스트 ---"
ip netns exec $NS2 tcpdump -i veth-r -c 10 -w $RESULTS/capture.pcap &
TCPDUMP_PID=$!
sleep 1
ip netns exec $NS1 ping -c 5 10.0.0.2 >/dev/null
sleep 2
kill $TCPDUMP_PID 2>/dev/null || true
echo "  캡처 파일: $RESULTS/capture.pcap"
tcpdump -r $RESULTS/capture.pcap -q 2>/dev/null | wc -l | \
    xargs -I{} echo "  캡처된 패킷: {} 개"

# 6. GRO/GSO 테스트
echo "--- GRO/GSO 오프로드 테스트 ---"
for feature in gro gso tso; do
    ip netns exec $NS1 ethtool -K veth-s $feature off 2>/dev/null
    ip netns exec $NS1 ping -c 1 10.0.0.2 >/dev/null 2>&1 && \
        echo "  $feature off: PASS" || echo "  $feature off: FAIL"
    ip netns exec $NS1 ethtool -K veth-s $feature on 2>/dev/null
done

# iperf3 서버 정리
pkill -f "iperf3 -s" 2>/dev/null || true

echo "=== 테스트 완료. 결과: $RESULTS ==="

QoS/DCB: mqprio, ETS, PFC 운영 포인트

데이터센터 환경에서는 대역폭 분배와 무손실 트래픽 제어(Traffic Control)가 중요합니다. 드라이버가 mqprio, DCB, PFC를 부분 지원하는 경우 지원 범위를 명확히 노출해야 운영 오해를 줄일 수 있습니다.

# 실습 예제: mqprio/ethtool로 큐 정책 검증
# mqprio qdisc 예시 (TC별 큐 매핑)
tc qdisc replace dev eth0 root mqprio num_tc 4 \
  map 0 1 2 3 3 3 3 3 \
  queues 1@0 1@1 2@2 4@4 hw 1

# DCB/PFC 상태 확인 예시 (환경별 도구 상이)
dcbtool gc eth0 dcb
ethtool --show-priv-flags eth0

mqprio hw vs sw 모드

mqprio qdisc는 트래픽 클래스(Traffic Class, TC)별로 TX 큐를 매핑하는 멀티큐 우선순위 스케줄러입니다. hw 0(소프트웨어 모드)과 hw 1(하드웨어 오프로드 모드)의 차이를 정확히 이해해야 올바른 QoS 정책을 구현할 수 있습니다.

hw 1 모드에서는 TC_MQPRIO_HW_OFFLOAD_TCS 플래그가 드라이버에 전달되며, 드라이버는 하드웨어 스케줄러에 TC-to-queue 매핑을 프로그래밍해야 합니다. 소프트웨어 모드에서는 커널이 큐 선택만 수행하고 실제 우선순위 처리는 하지 않습니다.

# mqprio 설정 및 검증 예시

# 1. 소프트웨어 모드: TC별 큐 분리만 수행
tc qdisc replace dev eth0 root mqprio \
    num_tc 4 \
    map 0 1 2 3 3 3 3 3 0 1 2 3 3 3 3 3 \
    queues 2@0 2@2 2@4 2@6 \
    hw 0

# 2. 하드웨어 오프로드 모드: NIC scheduler에 TC 매핑
tc qdisc replace dev eth0 root mqprio \
    num_tc 4 \
    map 0 1 2 3 3 3 3 3 0 1 2 3 3 3 3 3 \
    queues 2@0 2@2 2@4 2@6 \
    hw 1 \
    mode dcb

# 3. 채널(Channel) 모드: TC별 독립 qdisc 연결 가능
tc qdisc replace dev eth0 root mqprio \
    num_tc 3 \
    map 0 1 2 2 2 2 2 2 \
    queues 4@0 4@4 4@8 \
    hw 1 \
    mode channel \
    shaper bw_rlimit \
    min_rate 1Gbit 2Gbit 0 \
    max_rate 5Gbit 8Gbit 10Gbit

# 검증: TC 매핑 확인
tc qdisc show dev eth0
tc class show dev eth0

# 큐별 패킷 통계로 분배 확인
ethtool -S eth0 | grep -E "tx_queue_[0-9]+_packets"

PFC 데드락 방지와 워치독

우선순위 기반 흐름 제어(Priority Flow Control, PFC)는 IEEE 802.1Qbb 표준으로, 특정 우선순위의 트래픽에 대해서만 pause 프레임(Pause Frame)을 보내 무손실(Lossless) 전송을 보장합니다. 그러나 PFC 스톰(PFC Storm)이 발생하면 해당 우선순위의 트래픽이 완전히 차단되는 데드락(Deadlock) 상태에 빠질 수 있습니다.

PFC pause 프레임의 동작 원리는 다음과 같습니다.

• 수신 측: 수신 버퍼가 임계값에 도달하면 해당 우선순위의 pause 프레임을 송신 측에 전송합니다.
• 송신 측: pause 프레임을 수신하면 해당 우선순위의 전송을 일시 중단합니다. 다른 우선순위의 트래픽은 영향받지 않습니다.
• 타이머: pause 프레임에는 quanta 단위의 타이머가 포함되어 있어, 타이머 만료 후 자동으로 전송이 재개됩니다.

PFC 스톰은 수신 측이 지속적으로 pause 프레임을 보내는 상태로, 네트워크 전체로 전파(Head-of-Line Blocking)될 수 있습니다. 이를 감지하고 자동 복구하는 워치독(Watchdog) 메커니즘이 필요합니다.

# PFC 설정 및 모니터링

# 1. PFC 활성화 (priority 3, 4에 대해)
mlnx_qos -i eth0 --pfc 0,0,0,1,1,0,0,0

# lldptool을 사용한 PFC 설정 (lldpad 사용 시)
lldptool -T -i eth0 -V PFC enabled=0,0,0,1,1,0,0,0

# 2. PFC 카운터 모니터링
ethtool -S eth0 | grep -iE "pfc|pause"
# 주요 카운터:
# rx_pfc_pri_N_pause   - 수신한 PFC pause 프레임 수
# tx_pfc_pri_N_pause   - 송신한 PFC pause 프레임 수
# rx_pfc_pri_N_duration - pause 지속 시간 (quanta)

# 3. PFC 워치독 상태 확인 (드라이버 지원 시)
devlink health show pci/0000:03:00.0 reporter tx

# 4. PFC 스톰 감지 스크립트
PREV_PAUSE=0
while true; do
    CURR_PAUSE=$(ethtool -S eth0 | grep rx_pfc_pri_3_pause | awk '{print $2}')
    RATE=$((CURR_PAUSE - PREV_PAUSE))
    if [ $RATE -gt 1000 ]; then
        echo "[경고] PFC 스톰 의심: priority 3, rate=$RATE/sec"
        # 자동 대응: PFC 비활성화 또는 관리자 알림
    fi
    PREV_PAUSE=$CURR_PAUSE
    sleep 1
done

CBS/TAS IEEE 802.1Qav/Qbv 오프로드

시간 민감 네트워킹(Time-Sensitive Networking, TSN)에서는 CBS(Credit Based Shaper, IEEE 802.1Qav)와 TAS(Time-Aware Shaper, IEEE 802.1Qbv)가 핵심 트래픽 제어 메커니즘입니다. 리눅스 커널은 cbs와 taprio qdisc를 통해 이들을 지원하며, 하드웨어 오프로드가 가능한 NIC에서는 정밀한 타이밍 제어가 가능합니다.

• CBS (802.1Qav): 크레딧 기반 쉐이핑으로, 각 트래픽 클래스에 대역폭 한도를 설정합니다. 크레딧이 양수일 때만 전송이 허용되어 대역폭을 공정하게 분배합니다.
• TAS (802.1Qbv): 시간 기반 게이트 제어로, 사전 정의된 스케줄에 따라 특정 시점에 특정 트래픽 클래스만 전송을 허용합니다. 결정론적(Deterministic) 지연을 보장합니다.
• taprio qdisc: TAS를 리눅스에서 구현한 qdisc입니다. flags 0x2로 하드웨어 오프로드, flags 0x1로 전체 오프로드를 설정합니다.

# TSN 설정 예시

# 1. CBS qdisc 설정 (802.1Qav)
# TC 0에 대해 idleSlope=100Mbit, sendSlope=-900Mbit (1Gbit 링크 기준)
tc qdisc replace dev eth0 parent root handle 100 mqprio \
    num_tc 3 map 2 2 1 0 2 2 2 2 \
    queues 1@0 1@1 2@2 hw 0

tc qdisc replace dev eth0 parent 100:1 cbs \
    idleslope 100000 sendslope -900000 \
    hicredit 12 locredit -88 offload 1

# 2. taprio qdisc 설정 (802.1Qbv)
# 1ms 주기: TC0 200us, TC1 300us, TC2 500us
tc qdisc replace dev eth0 parent root taprio \
    num_tc 3 \
    map 2 2 1 0 2 2 2 2 2 2 2 2 2 2 2 2 \
    queues 1@0 1@1 2@2 \
    base-time 1000000000 \
    sched-entry S 01 200000 \
    sched-entry S 02 300000 \
    sched-entry S 04 500000 \
    flags 0x2 \
    clockid CLOCK_TAI

# 검증: taprio 스케줄 확인
tc qdisc show dev eth0 root

# PTP 클럭 동기화 확인 (TSN 필수 조건)
ptp4l -i eth0 -m &
phc2sys -s eth0 -c CLOCK_REALTIME -w -m &

TSN 기능별 드라이버 지원 현황은 다음과 같습니다.