Linux Bridge 심화

Linux 커널 Bridge(소프트웨어 L2 스위치) 심화 분석: net_bridge/net_bridge_port 아키텍처, FDB(Forwarding Database), STP/RSTP 루프 방지, IGMP/MLD Snooping 멀티캐스트 최적화, br_netfilter와 ebtables, TC flower HW 오프로드, XDP redirect, ftrace/bpftrace 진단까지 실무 관점으로 다룹니다.

Linux Bridge

Linux Bridge는 IEEE 802.1D 표준을 구현하는 소프트웨어 L2 스위치입니다. 물리/가상 인터페이스를 포트로 추가하여 동일 브로드캐스트 도메인으로 연결하며, MAC 주소 학습(FDB), STP/RSTP, VLAN 필터링을 지원합니다.

Bridge 아키텍처 (net_bridge)

커널 내부에서 브리지는 struct net_bridge로 표현됩니다. 각 포트는 struct net_bridge_port로 관리되며, FDB(Forwarding Database)는 해시 테이블 기반입니다.

/* net/bridge/br_private.h — 브리지 핵심 구조체 */
struct net_bridge {
    spinlock_t              lock;
    struct list_head        port_list;        /* 브리지 포트 목록 */
    struct net_device       *dev;             /* 브리지 net_device */
    struct pcpu_sw_netstats __percpu *stats;

    struct hlist_head       fdb_list;         /* FDB 엔트리 목록 */
    struct rhashtable       fdb_hash_tbl;     /* FDB 해시 테이블 */
    unsigned long           ageing_time;      /* FDB 에이징 타이머 (기본 300초) */

    u16                     group_fwd_mask;
    u16                     default_pvid;     /* VLAN-aware 모드: 기본 PVID */

    /* 멀티캐스트 관련 필드 */
    struct bridge_mcast_own_query ip4_own_query;
    struct bridge_mcast_own_query ip6_own_query;
    u8                      multicast_igmp_version; /* IGMP 버전 (2 또는 3) */
    u8                      multicast_mld_version;  /* MLD 버전 (1 또는 2) */
    bool                    multicast_disabled;     /* Snooping 비활성 여부 */
    bool                    multicast_querier;      /* Querier 기능 */
    u32                     hash_max;               /* MDB 해시 테이블 최대 크기 */

    bool                    vlan_enabled;     /* VLAN filtering 활성화 */
    u16                     vlan_proto;       /* ETH_P_8021Q 또는 ETH_P_8021AD */

    struct net_bridge_vlan_group __rcu *vlgrp;  /* VLAN 그룹 */

    /* STP 관련 필드 */
    bridge_id               designated_root;
    bridge_id               bridge_id;
    unsigned char           topology_change;
    u32                     root_path_cost;
    struct timer_list       hello_timer;
    struct timer_list       tcn_timer;
    struct timer_list       topology_change_timer;
    /* ... */
};

/* net/bridge/br_private.h — 브리지 포트 구조체 */
struct net_bridge_port {
    struct net_bridge       *br;              /* 소속 브리지 */
    struct net_device       *dev;             /* 포트의 net_device */
    struct list_head        list;

    unsigned long           flags;
    port_id                 port_id;          /* STP 포트 ID */
    u8                      state;            /* BR_STATE_DISABLED/LISTENING/... */
    u8                      priority;

    struct net_bridge_vlan_group __rcu *vlgrp;  /* 포트별 VLAN 그룹 */

    u16                     backup_port;
    /* ... */
};

/* net/bridge/br_private.h — VLAN 엔트리 구조체 */
struct net_bridge_vlan {
    struct rhash_head       vnode;            /* VLAN 해시 테이블 노드 */
    struct rhash_head       tnode;            /* tunnel 해시 테이블 노드 */
    u16                     vid;              /* VLAN ID */
    u16                     flags;            /* VLAN 플래그 */
#define BRIDGE_VLAN_INFO_MASTER   BIT(0)    /* 브리지 자체 VLAN */
#define BRIDGE_VLAN_INFO_PVID     BIT(1)    /* Port VLAN ID */
#define BRIDGE_VLAN_INFO_UNTAGGED BIT(2)    /* egress 시 태그 제거 */
#define BRIDGE_VLAN_INFO_RANGE_BEGIN BIT(3)  /* VLAN 범위 시작 */
#define BRIDGE_VLAN_INFO_RANGE_END   BIT(4)  /* VLAN 범위 끝 */
#define BRIDGE_VLAN_INFO_BRENTRY  BIT(5)    /* 브리지 VLAN 엔트리 */
    struct pcpu_sw_netstats __percpu *stats;  /* per-CPU 통계 */
    union {
        struct net_bridge_vlan *brvlan;       /* 포트 VLAN → 브리지 VLAN 참조 */
        struct net_bridge_vlan_group __rcu *br_vg; /* 브리지 VLAN 그룹 */
    };
    struct rcu_head         rcu;
};

FDB (Forwarding Database)

FDB는 MAC 주소와 포트 매핑을 저장하는 테이블입니다. 수신 패킷의 소스 MAC을 학습(learning)하고, 목적지 MAC으로 출력 포트를 결정(forwarding)합니다.

/* net/bridge/br_private.h — FDB 엔트리 */
struct net_bridge_fdb_entry {
    struct rhash_head       rhnode;
    struct net_bridge_port  *dst;             /* 출력 포트 (NULL=로컬) */

    struct {
        unsigned char       addr[6];          /* MAC 주소 */
        u16                 vlan_id;          /* VLAN ID (0=untagged) */
    } key;

    unsigned long           flags;
#define BR_FDB_LOCAL    0                         /* 브리지 자체 MAC */
#define BR_FDB_STATIC   1                         /* 정적 엔트리 */
#define BR_FDB_ADDED_BY_USER 2                  /* 사용자가 추가 */

    unsigned long           updated;          /* 마지막 갱신 시간 (jiffies) */
    unsigned long           used;             /* 마지막 참조 시간 */
    struct rcu_head         rcu;
};

# FDB 테이블 조회
bridge fdb show dev br0

# 정적 FDB 엔트리 추가
bridge fdb add 00:11:22:33:44:55 dev eth0 master static

# FDB 에이징 타임 설정 (초)
ip link set br0 type bridge ageing_time 30000

FDB rhashtable 해시 알고리즘 상세

FDB는 rhashtable(Resizable Hash Table)을 사용하여 O(1) 평균 조회 성능을 제공합니다. 해시 키는 MAC 주소(6바이트) + VLAN ID(2바이트)를 결합한 8바이트이며, jhash(Jenkins Hash)로 해시됩니다.

/* net/bridge/br_fdb.c — rhashtable 파라미터 */
static const struct rhashtable_params br_fdb_rht_params = {
    .head_offset     = offsetof(struct net_bridge_fdb_entry, rhnode),
    .key_offset      = offsetof(struct net_bridge_fdb_entry, key),
    .key_len         = sizeof(struct net_bridge_fdb_key),  /* 8 bytes: MAC[6] + VID[2] */
    .automatic_shrinking = true,
    .hashfn          = jhash,           /* Jenkins Hash */
};

/* FDB 키 구조체 */
struct net_bridge_fdb_key {
    unsigned char   addr[6];           /* MAC 주소 */
    u16             vlan_id;           /* VLAN ID (0 = untagged) */
};

/* net/bridge/br_fdb.c — FDB 조회 경로 */
static struct net_bridge_fdb_entry *
br_fdb_find_rcu(struct net_bridge *br,
                const unsigned char *addr, __u16 vid)
{
    struct net_bridge_fdb_key key;

    /* 해시 키 구성: MAC + VLAN ID */
    memcpy(key.addr, addr, ETH_ALEN);
    key.vlan_id = vid;

    /* rhashtable_lookup: jhash(key, 8) → 버킷 → 체이닝 탐색 */
    return rhashtable_lookup(&br->fdb_hash_tbl, &key,
                            br_fdb_rht_params);
    /* RCU 보호 하에 lock-free 조회 (fast path) */
}

FDB 학습/에이징/통지 경로

FDB 엔트리의 전체 생명주기: 학습(learning) → 갱신(update) → 에이징(aging) → 삭제(cleanup) → 통지(notify).

/* net/bridge/br_fdb.c — FDB 학습 (소스 MAC 갱신) */
bool br_fdb_update(struct net_bridge *br,
                   struct net_bridge_port *source,
                   const unsigned char *addr, u16 vid,
                   unsigned long flags)
{
    struct net_bridge_fdb_entry *fdb;

    fdb = br_fdb_find_rcu(br, addr, vid);
    if (likely(fdb)) {
        /* 기존 엔트리: 타임스탬프만 갱신 */
        if (unlikely(source != fdb->dst)) {
            /* MAC이 다른 포트로 이동 → 포트 갱신 */
            fdb->dst = source;
            modified = true;
        }
        if (fdb->updated != jiffies)
            fdb->updated = jiffies;
    } else {
        /* 새 MAC: 엔트리 생성 → 해시 삽입 */
        fdb = fdb_create(br, source, addr, vid, flags);
        if (!fdb)
            return false;

        /* rhashtable에 삽입 */
        rhashtable_lookup_insert_fast(&br->fdb_hash_tbl,
                                      &fdb->rhnode,
                                      br_fdb_rht_params);

        /* switchdev 통지: HW FDB에도 추가 */
        br_switchdev_fdb_notify(br, fdb, RTM_NEWNEIGH);

        /* Netlink 통지: userspace에 전달 */
        br_fdb_notify(br, fdb, RTM_NEWNEIGH, false);
    }
    return true;
}

/* net/bridge/br_fdb.c — FDB 에이징 (GC 타이머) */
void br_fdb_cleanup(struct work_struct *work)
{
    struct net_bridge *br = container_of(work, ...);
    unsigned long timeout = br->ageing_time; /* 기본 300초 = 30000 centisec */

    /* FDB 리스트 순회 */
    hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
        /* 정적(static)/로컬(local) 엔트리는 에이징 대상 아님 */
        if (test_bit(BR_FDB_STATIC, &f->flags) ||
            test_bit(BR_FDB_LOCAL, &f->flags))
            continue;

        /* jiffies 비교: 마지막 갱신 후 ageing_time 경과? */
        if (time_after(jiffies, f->updated + timeout)) {
            /* 에이징 만료: 삭제 + 통지 */
            br_switchdev_fdb_notify(br, f, RTM_DELNEIGH);
            br_fdb_notify(br, f, RTM_DELNEIGH, true);
            fdb_delete(br, f, true);
        }
    }

    /* 다음 GC 주기 스케줄링 (ageing_time / 2 간격) */
    mod_delayed_work(system_long_wq, &br->gc_work,
                     br->ageing_time / 2);
}

# ── FDB 변경 모니터링 (Netlink RTM_NEWNEIGH/RTM_DELNEIGH) ──

# 실시간 FDB 이벤트 감시
bridge monitor fdb

# 출력 예시:
# aa:bb:cc:dd:ee:ff dev eth0 master br0 state learned
# aa:bb:cc:dd:ee:ff dev eth0 master br0 state deleted

# ip monitor로도 가능
ip monitor neigh

# bpftrace로 FDB 학습 추적
bpftrace -e 'kprobe:br_fdb_update {
    $mac = (uint8 *)arg2;
    printf("FDB update: %02x:%02x:%02x:%02x:%02x:%02x vid=%d\n",
           $mac[0], $mac[1], $mac[2], $mac[3], $mac[4], $mac[5], arg3);
}'

FDB 제한/보안

FDB는 보안 관점에서 MAC 스푸핑, MAC flooding 공격에 취약할 수 있습니다. 정적 엔트리, 포트 격리, MAC 제한 등의 기법으로 방어합니다.

# ── FDB 보안 설정 예시 ──

# 1. 정적 FDB: MAC 스푸핑 방지
bridge fdb add 00:11:22:33:44:55 dev eth0 master static
bridge fdb add 00:11:22:33:44:66 dev eth1 master static

# 2. 동적 학습 비활성화 (정적 엔트리 이외 통신 차단)
bridge link set dev eth0 learning off
bridge link set dev eth1 learning off

# 3. 포트 격리: eth0↔eth1 직접 통신 차단 (업링크만 통신 가능)
bridge link set dev eth0 isolated on
bridge link set dev eth1 isolated on
# eth2(업링크)는 isolated off 유지 → eth0/eth1 모두 eth2와만 통신

# 4. Unknown unicast flooding 차단
bridge link set dev eth0 flood off
# FDB에 없는 MAC으로의 패킷이 eth0으로 flood되지 않음

# 5. 포트별 플래그 확인
bridge -d link show dev eth0
# 출력 예: learning off flood off isolated on

# 6. MAC flooding 공격 탐지
# FDB 엔트리 수 모니터링
watch -n1 'bridge fdb show br br0 | wc -l'
# 급증 시 MAC flooding 공격 의심

STP / RSTP

STP(Spanning Tree Protocol, IEEE 802.1D)는 브리지 루프를 방지합니다. RSTP(Rapid STP, IEEE 802.1w)는 수렴 시간을 크게 단축합니다.

# 브리지 생성 및 포트 추가
ip link add name br0 type bridge
ip link set br0 up

ip link set eth0 master br0
ip link set eth1 master br0

# STP 활성화
ip link set br0 type bridge stp_state 1

# STP 상태 확인
bridge link show
cat /sys/class/net/br0/bridge/stp_state

# 브리지 우선순위 설정 (루트 브리지 선출)
ip link set br0 type bridge priority 4096

# 포트별 STP 비용 설정
ip link set eth0 type bridge_slave cost 100

브리지 패킷 처리 흐름

브리지로 수신된 패킷은 br_handle_frame()에서 처리됩니다. BPDU인지 확인 후, FDB 룩업을 통해 unicast forwarding 또는 flooding을 수행합니다.

/* net/bridge/br_input.c — 브리지 패킷 수신 흐름 */

/* 1. NIC 드라이버 → netif_receive_skb() → br_handle_frame() */
static rx_handler_result_t br_handle_frame(
    struct sk_buff **pskb)
{
    struct net_bridge_port *p = br_port_get_rcu(skb->dev);

    /* STP BPDU 처리 */
    if (unlikely(is_link_local_ether_addr(dest)))
        return br_handle_local_finish(skb);

    /* 포트 상태가 FORWARDING이 아니면 드롭 */
    if (p->state == BR_STATE_FORWARDING) {
        /* 2. 소스 MAC 학습 → FDB 갱신 */
        br_fdb_update(br, p, eth_hdr(skb)->h_source, vid, ...);

        /* 3. VLAN 필터링 (vlan_enabled 시) */
        if (!br_allowed_ingress(br, ...))
            goto drop;

        /* 4. 목적지 MAC으로 FDB 룩업 */
        dst = br_fdb_find_rcu(br, dest, vid);
        if (dst) {
            /* unicast: 해당 포트로 전달 */
            br_forward(dst->dst, skb, ...);
        } else {
            /* unknown unicast: 모든 포트로 flooding */
            br_flood(br, skb, ...);
        }
    }
}

Netfilter 훅을 포함한 완전한 브리지 패킷 처리 경로:

netif_receive_skb
  └→ br_handle_frame          (rx_handler 등록)
       ├→ NF_BR_PRE_ROUTING   (ebtables PREROUTING)
       ├→ br_fdb_update        (소스 MAC 학습)
       ├→ br_allowed_ingress   (VLAN ingress 필터)
       ├→ NF_BR_FORWARD        (ebtables FORWARD)
       ├→ br_fdb_find_rcu      (목적지 MAC 룩업)
       ├→ br_forward()         (unicast)
       │    └→ deliver_clone()
       │         └→ br_dev_queue_push_xmit()
       │              └→ NF_BR_POST_ROUTING → dev_queue_xmit()
       └→ br_flood()           (unknown unicast / broadcast)
            └→ 각 포트에 deliver_clone() 반복

  [switchdev 오프로드 분기]
  br_fdb_update() → br_switchdev_fdb_notify()
                     → SWITCHDEV_FDB_ADD_TO_DEVICE 이벤트
                     → NIC 드라이버 hardware FDB 갱신

VLAN-aware Bridge 동작 원리

Linux Bridge는 커널 4.2+부터 VLAN-aware 모드(vlan_filtering 1)를 지원합니다. 이 모드에서는 브리지 자체가 802.1Q VLAN 필터링을 수행하며, 각 포트에 PVID, tagged, untagged 속성을 독립적으로 설정할 수 있습니다. 기존 VLAN 서브인터페이스 방식(bridge + vlan subif)보다 확장성과 성능이 뛰어납니다.

br_allowed_ingress() / br_allowed_egress() 코드

VLAN-aware 브리지에서 패킷의 ingress/egress 허용 여부를 결정하는 핵심 함수입니다. ingress에서는 untagged 패킷에 PVID를 부여하고, egress에서는 UNTAGGED 플래그에 따라 태그를 제거합니다.

/* net/bridge/br_vlan.c — Ingress VLAN 필터링 */
bool br_allowed_ingress(const struct net_bridge *br,
                        struct net_bridge_vlan_group *vg,
                        struct sk_buff *skb, u16 *vid,
                        u8 *state,
                        struct net_bridge_vlan **vlan)
{
    /* VLAN filtering 비활성이면 항상 허용 */
    if (!br->vlan_enabled) {
        BR_INPUT_SKB_CB(skb)->vlan_filtered = false;
        return true;
    }

    /* skb에서 VLAN 태그 추출 */
    if (!br_vlan_get_tag(skb, vid)) {
        /* tagged 패킷: VID가 포트의 allowed 목록에 있는지 확인 */
        v = br_vlan_find(vg, *vid);
        if (!v || !br_vlan_should_use(v))
            goto drop;  /* 허용되지 않은 VLAN → 드롭 */
    } else {
        /* untagged 패킷: PVID 확인 */
        if (!br_vlan_get_pvid_state(vg, vid, state))
            goto drop;  /* PVID 없으면 드롭! */

        /* PVID 태그를 skb에 부여 */
        __vlan_hwaccel_put_tag(skb, br->vlan_proto, *vid);
    }

    /* 포트 상태 검사 (STP Blocking이면 드롭) */
    if (*state == BR_STATE_FORWARDING ||
        *state == BR_STATE_LEARNING) {
        *vlan = v;
        return true;
    }

drop:
    kfree_skb(skb);
    return false;
}

/* net/bridge/br_vlan.c — Egress VLAN 처리 */
static int br_vlan_egress(const struct net_bridge *br,
                           const struct net_bridge_vlan *v,
                           struct sk_buff *skb)
{
    /* UNTAGGED 플래그: egress 시 VLAN 태그 제거 */
    if (v->flags & BRIDGE_VLAN_INFO_UNTAGGED)
        __vlan_hwaccel_clear_tag(skb);

    /* tagged 포트: 태그 유지, 물리 NIC이 802.1Q 헤더 삽입 */
    return 0;
}

/* br_allowed_egress(): 출력 포트에서 해당 VID 허용 여부 */
bool br_allowed_egress(struct net_bridge_vlan_group *vg,
                       const struct sk_buff *skb)
{
    u16 vid;

    /* VLAN filtering 비활성이면 항상 허용 */
    if (!BR_INPUT_SKB_CB(skb)->vlan_filtered)
        return true;

    br_vlan_get_tag(skb, &vid);
    if (br_vlan_find(vg, vid))
        return true;  /* 해당 VID가 출력 포트에 허용됨 */

    return false;  /* 드롭 */
}

VLAN-aware Bridge 설정

VLAN-aware 브리지 생성부터 포트별 PVID/tagged/untagged 설정까지 완전한 예제입니다.

# ── 1. VLAN-aware 브리지 생성 ──
ip link add name br0 type bridge vlan_filtering 1 vlan_default_pvid 1
ip link set br0 up

# 포트 추가
ip link set eth0 master br0
ip link set eth1 master br0
ip link set eth2 master br0

# ── 2. Access 포트 설정 (eth0: VLAN 1 기본, VLAN 10/20도 허용) ──
# 기본 PVID=1이 자동 설정됨; 추가 VLAN 허용
bridge vlan add dev eth0 vid 10
bridge vlan add dev eth0 vid 20

# ── 3. Access 포트 설정 (eth1: VLAN 10 전용) ──
# 기본 PVID=1 제거 후 PVID=10으로 변경
bridge vlan del dev eth1 vid 1
bridge vlan add dev eth1 vid 10 pvid untagged

# ── 4. Trunk 포트 설정 (eth2: VLAN 10, 20 tagged) ──
bridge vlan del dev eth2 vid 1
bridge vlan add dev eth2 vid 10
bridge vlan add dev eth2 vid 20
# pvid/untagged 플래그 없음 → tagged 트렁크

# ── 5. 브리지 자체(self)에도 VLAN 추가 (L3 라우팅용) ──
bridge vlan add dev br0 vid 10 self
bridge vlan add dev br0 vid 20 self

# VLAN별 IP 할당 (L3 SVI 역할)
ip link add link br0 name br0.10 type vlan id 10
ip addr add 192.168.10.1/24 dev br0.10
ip link set br0.10 up

# ── 6. 설정 확인 ──
bridge vlan show
# port      vlan-id
# eth0      1 PVID Egress Untagged
#           10
#           20
# eth1      10 PVID Egress Untagged
# eth2      10
#           20

PVID / Tagged / Untagged 비교

802.1ad QinQ (Provider Bridge)

QinQ(802.1ad)는 기존 802.1Q 태그 위에 S-VLAN(Service VLAN) 태그를 추가하는 이중 태깅 기술입니다. ISP가 고객 트래픽을 서비스 VLAN으로 캡슐화하여 공급자 네트워크를 통과시킬 때 사용합니다. Linux Bridge는 vlan_protocol 802.1ad로 S-VLAN 브리지를 구성할 수 있습니다.

# ── 802.1ad QinQ 브리지 설정 ──

# S-VLAN 브리지 생성 (vlan_protocol 802.1ad)
ip link add name br-provider type bridge \
    vlan_filtering 1 \
    vlan_protocol 802.1ad \
    vlan_default_pvid 0
ip link set br-provider up

# 고객 포트: S-VLAN 100 할당 (untagged ingress → S-VLAN 100 태그 추가)
ip link set eth0 master br-provider
bridge vlan add dev eth0 vid 100 pvid untagged

# 업링크 포트: S-VLAN 100, 200 trunk
ip link set eth1 master br-provider
bridge vlan add dev eth1 vid 100
bridge vlan add dev eth1 vid 200

# 결과: eth0에서 수신된 고객 패킷(C-VLAN 태그 포함)에
# S-VLAN 100 (EtherType 0x88A8) 태그가 추가되어 eth1로 전달
# 프레임 구조: [DA][SA][0x88A8][S-VID=100][0x8100][C-VID=10][payload]

# QinQ 확인
bridge vlan show
tcpdump -i eth1 -e -nn 'ether proto 0x88a8'

IGMP/MLD Snooping

IGMP Snooping은 멀티캐스트 트래픽을 필요한 포트에만 전달하는 L2 최적화입니다. 브리지가 IGMP 메시지를 감청(snooping)하여 MDB(Multicast Database)를 관리하고, 멀티캐스트 스트림을 등록된 수신자 포트에만 전달합니다.

/* net/bridge/br_multicast.c — MDB 핵심 구조체 */
struct net_bridge_mdb_entry {
    struct hlist_node       hlist[2];         /* MDB 해시 버킷 */
    struct net_bridge       *br;
    struct br_ip            addr;             /* 멀티캐스트 그룹 주소 (IPv4/IPv6) */
    struct hlist_head       ports;            /* 수신자 포트 그룹 목록 */
    struct timer_list       timer;            /* 그룹 멤버십 타이머 */
    struct rcu_head         rcu;
};

struct net_bridge_port_group {
    struct net_bridge_port  *key.port;        /* 포트 참조 */
    struct hlist_node       mglist;
    struct timer_list       timer;            /* 포트별 멤버십 타이머 */
    unsigned char           flags;
#define MDB_PG_FLAGS_PERMANENT BIT(0)         /* 정적 엔트리 */
#define MDB_PG_FLAGS_OFFLOAD   BIT(1)         /* HW 오프로드됨 */
#define MDB_PG_FLAGS_FAST_LEAVE BIT(2)        /* Fast Leave 활성 */
    struct rcu_head         rcu;
};

/* 멀티캐스트 처리 핵심 함수 */

/* IGMP/MLD 패킷 수신 시 호출 */
int br_multicast_rcv(struct net_bridge_mcast *brmctx,
                    struct net_bridge_mcast_port *pmctx,
                    struct net_bridge_vlan *vlan,
                    struct sk_buff *skb, u16 vid);

/* MDB 그룹 추가/갱신 */
struct net_bridge_mdb_entry *br_multicast_add_group(
    struct net_bridge_mcast *brmctx,
    struct net_bridge_mcast_port *pmctx,
    struct br_ip *group, ...);

/* 멀티캐스트 패킷 선별 전달 */
static void br_multicast_flood(struct net_bridge_mdb_entry *mdst,
                               struct sk_buff *skb, ...);

# IGMP Snooping 활성화
ip link set br0 type bridge mcast_snooping 1

# IGMP Querier 활성화 (라우터 없는 환경)
ip link set br0 type bridge mcast_querier 1

# IGMP v3 사용 설정 (SSM 지원)
ip link set br0 type bridge mcast_igmp_version 3
ip link set br0 type bridge mcast_mld_version 2

# MDB (Multicast Database) 조회
bridge mdb show
bridge mdb show dev br0

# 정적 MDB 엔트리 추가
bridge mdb add dev br0 port eth1 grp 239.1.1.1 permanent

# Fast Leave 설정 (포트에 단일 수신자만 있을 때 즉시 탈퇴)
bridge link set dev eth1 mcast_fast_leave on

# VLAN-aware MDB (VLAN별 멀티캐스트 분리)
ip link set br0 type bridge mcast_vlan_snooping 1
bridge mdb add dev br0 port eth1 grp 239.1.1.1 vid 10 permanent

# Snooping 통계 확인
bridge -s mdb show

RSTP + STP 보안 기능

IEEE 802.1w RSTP(Rapid Spanning Tree Protocol)는 STP를 개선하여 1~2초 내 수렴을 달성합니다. Linux 커널에서 BPDU Guard, Root Guard, PortFast 등의 보안 기능을 통해 STP 공격을 방어합니다.

/* net/bridge/br_private.h — 포트 플래그 비트 필드 */
#define BR_HAIRPIN_MODE         BIT(0)   /* 헤어핀: 수신 포트로 재전달 허용 */
#define BR_BPDU_GUARD           BIT(1)   /* BPDU Guard: BPDU 수신 시 포트 차단 */
#define BR_ROOT_BLOCK           BIT(2)   /* Root Guard: 루트 경로 변경 차단 */
#define BR_MULTICAST_FAST_LEAVE BIT(3)   /* Fast Leave */
#define BR_ADMIN_COST           BIT(4)   /* 관리자 지정 path cost */
#define BR_LEARNING             BIT(5)   /* MAC 학습 허용 */
#define BR_FLOOD                BIT(6)   /* flooding 허용 */
#define BR_AUTO_MASK            (BR_FLOOD | BR_LEARNING)
#define BR_PROMISC              BIT(7)   /* 무차별 모드 */
#define BR_PROXYARP             BIT(8)   /* Proxy ARP */
#define BR_LEARNING_SYNC        BIT(9)   /* 학습 동기화 */
#define BR_PORT_LOCKED          BIT(13)  /* 포트 잠금 */
#define BR_PORT_MAB             BIT(14)  /* MAC Auth Bypass */

/* BPDU Guard 동작: br_stp_rcv() 내부 */
static void br_stp_rcv(const struct stp_proto *proto,
                       struct sk_buff *skb,
                       struct net_device *dev)
{
    struct net_bridge_port *p = br_port_get_rtnl(dev);

    /* BPDU Guard: 엣지 포트에서 BPDU 수신 시 Error-Disabled */
    if (p->flags & BR_BPDU_GUARD) {
        br_log_state(p);
        br_stp_disable_port(p);          /* 포트 비활성화 */
        return;
    }

    /* Root Guard: 더 나은 BPDU 수신해도 루트 경로 변경 차단 */
    if (p->flags & BR_ROOT_BLOCK) {
        if (br_is_superior_bpdu(p, bpdu)) {
            p->state = BR_STATE_LISTENING;  /* Root-Inconsistent */
            return;
        }
    }
}

# PortFast: 엣지 포트 즉시 Forwarding (호스트 연결 포트용)
bridge link set dev eth0 portfast on

# PortFast auto: 연결 타입에 따라 자동 판단
bridge link set dev eth0 portfast auto

# BPDU Guard: BPDU 수신 시 포트 Error-Disabled
bridge link set dev eth0 guard on

# Root Guard: 루트 브리지 경로 변경 차단
bridge link set dev eth0 root_block on

# 현재 포트 STP 설정 확인
bridge -d link show

# BPDU Guard로 비활성화된 포트 수동 복구
ip link set eth0 down
ip link set eth0 up

# STP 우선순위 및 포트 비용 설정
ip link set br0 type bridge priority 4096          # 루트 브리지 선출 (낮을수록 유리)
ip link set eth0 type bridge_slave cost 10         # 포트 비용 설정
ip link set eth0 type bridge_slave priority 32     # 포트 우선순위 설정

# Hello Time, Max Age, Forward Delay 설정
ip link set br0 type bridge hello_time 200         # 2초 (단위: 1/100초)
ip link set br0 type bridge max_age 2000           # 20초
ip link set br0 type bridge forward_delay 1500     # 15초

STP 상태 전이 다이어그램

STP(802.1D)에서 포트는 5개의 상태(Disabled → Blocking → Listening → Learning → Forwarding)를 순서대로 전이합니다. RSTP(802.1w)는 Disabled/Blocking/Listening을 Discarding 하나로 통합하여 상태 머신을 단순화하고, Proposal/Agreement 메커니즘으로 수렴 시간을 획기적으로 단축합니다.

BPDU 패킷 형식 상세

BPDU(Bridge Protocol Data Unit)는 브리지 간 토폴로지 정보를 교환하는 L2 프레임입니다. Configuration BPDU(Type 0x00)와 TCN(Topology Change Notification) BPDU(Type 0x80)가 있으며, RSTP는 Version 2 BPDU(Type 0x02)를 사용합니다.

/* net/bridge/br_private_stp.h — BPDU 구조체 */
struct br_config_bpdu {
    unsigned    topology_change:1;         /* TC 플래그 */
    unsigned    topology_change_ack:1;     /* TCA 플래그 */
    bridge_id   root;                        /* Root Bridge ID */
    int         root_path_cost;              /* Root Path Cost */
    bridge_id   bridge_id;                   /* Sender Bridge ID */
    port_id     port_id;                     /* Port ID */
    int         message_age;                 /* Message Age (1/256초) */
    int         max_age;                     /* Max Age */
    int         hello_time;                  /* Hello Time */
    int         forward_delay;               /* Forward Delay */
};

/* net/bridge/br_stp_bpdu.c — BPDU 수신 파싱 */
void br_stp_rcv(const struct stp_proto *proto,
                struct sk_buff *skb, struct net_device *dev)
{
    u8 *buf = skb->data;
    struct br_config_bpdu bpdu;

    /* Protocol ID 확인 (0x0000) */
    if (buf[0] || buf[1])
        goto out;

    /* BPDU Type에 따라 분기 */
    switch (buf[3]) {
    case BPDU_TYPE_CONFIG:       /* 0x00 */
    case BPDU_TYPE_RST:          /* 0x02 (RSTP) */
        br_received_config_bpdu(p, &bpdu);
        break;
    case BPDU_TYPE_TCN:          /* 0x80 */
        br_received_tcn_bpdu(p);
        break;
    }
}

Hairpin 모드와 Proxy ARP

특수한 네트워크 토폴로지에서 브리지 포트의 기본 동작을 수정해야 하는 경우가 있습니다. Hairpin 모드는 수신 포트와 송신 포트가 동일한 경우의 패킷 전달을 허용하고, Proxy ARP는 브리지가 ARP 요청에 대신 응답하여 BUM 트래픽을 줄입니다.

Hairpin 모드 (BR_HAIRPIN_MODE)

Hairpin 설정 및 커널 내부

# Hairpin 모드 활성화
bridge link set dev eth0 hairpin on

# sysfs를 통한 설정 (레거시)
echo 1 > /sys/class/net/br0/brif/eth0/hairpin_mode

# 현재 설정 확인
bridge -d link show dev eth0
# 출력 예: ... hairpin on learning on ...

# Docker에서 자동 설정 확인
bridge -d link show dev vethXXX | grep hairpin
# Docker daemon은 veth 생성 시 자동으로 hairpin on 설정

/* net/bridge/br_forward.c — Hairpin 모드 검사 */
static int deliver_clone(const struct net_bridge_port *prev,
                         struct sk_buff *skb,
                         bool local_orig)
{
    /* ... */
}

/* br_forward()에서 hairpin 확인 */
static void __br_forward(const struct net_bridge_port *to,
                          struct sk_buff *skb, bool local_orig)
{
    struct net_bridge_port *inp = br_port_get_rcu(skb->dev);

    /* 핵심: 입력 포트와 출력 포트가 같으면 hairpin 검사 */
    if (inp == to) {
        if (!(to->flags & BR_HAIRPIN_MODE))
            return;  /* hairpin 미설정 → DROP */
    }

    /* hairpin 설정됨 → 동일 포트로 재전달 허용 */
    __br_deliver(to, skb);
}

/* Docker/libnetwork는 veth 생성 시 BR_HAIRPIN_MODE 자동 설정
 * drivers/net/veth.c + dockerd bridge driver
 * → iptables DNAT로 컨테이너 자체 접근 시 hairpin 필수 */

Proxy ARP (BR_PROXYARP)

브리지의 Proxy ARP 기능은 호스트를 대신하여 ARP 요청에 응답합니다. 이는 VXLAN/EVPN 환경에서 ARP flooding 비용을 줄이거나, 브리지 뒤의 호스트가 직접 ARP 응답을 생성할 수 없는 환경에서 유용합니다.

# Proxy ARP 활성화
bridge link set dev eth0 proxyarp on

# Proxy ARP + WiFi (AP 모드에서 클라이언트 간 ARP 대리 응답)
bridge link set dev wlan0 proxyarp_wifi on

# Neighbor table 확인 (Proxy ARP가 참조하는 정보)
ip neigh show dev br0
bridge fdb show dev eth0

# VXLAN + Proxy ARP 조합
ip link add vxlan10 type vxlan id 10 dstport 4789 local 10.0.0.1 nolearning proxy
bridge link set dev vxlan10 proxyarp on

/* net/bridge/br_input.c — Proxy ARP 처리 */
static int br_do_proxy_arp(struct sk_buff *skb,
                            struct net_bridge *br,
                            u16 vid,
                            struct net_bridge_port *p)
{
    struct arphdr *parp;
    u8 *arpptr, *sha;
    __be32 sip, tip;
    struct neighbour *n;

    if (!(p->flags & BR_PROXYARP))
        return 0;

    /* ARP Request(op=1)만 처리 */
    if (parp->ar_op != htons(ARPOP_REQUEST))
        return 0;

    /* 타겟 IP의 neighbor entry 조회 */
    n = neigh_lookup(&arp_tbl, &tip, br->dev);
    if (n) {
        /* neighbor가 존재하면 ARP Reply를 대신 생성 */
        arp_send(ARPOP_REPLY, ETH_P_ARP,
                 sip, skb->dev, tip,
                 sha, n->ha, sha);
        neigh_release(n);
        return 1;  /* 대리 응답 완료, 원본 ARP 전파 중단 */
    }
    return 0;
}

Neighbor Suppression

VXLAN 환경에서 Neighbor Suppression은 ARP/ND(IPv6 Neighbor Discovery) 요청이 VXLAN 터널을 통해 불필요하게 flooding되는 것을 방지합니다. 브리지가 로컬 neighbor 테이블을 기반으로 대리 응답하여 BUM(Broadcast/Unknown-unicast/Multicast) 트래픽을 대폭 감소시킵니다.

# VXLAN + Bridge에서 Neighbor Suppression 활성화
ip link add br0 type bridge vlan_filtering 1
ip link add vxlan10 type vxlan id 10 dstport 4789 local 10.0.0.1 nolearning proxy
ip link set vxlan10 master br0

# Neighbor Suppression 활성화 (neigh_suppress)
bridge link set dev vxlan10 neigh_suppress on

# 수동으로 neighbor 엔트리 추가 (EVPN 컨트롤러가 자동 배포)
bridge fdb append 00:11:22:33:44:55 dev vxlan10 dst 10.0.0.2
ip neigh add 192.168.1.100 lladdr 00:11:22:33:44:55 dev vxlan10

# BUM 트래픽 감소 확인
bridge -s link show dev vxlan10
# neigh_suppress on 후 ARP 브로드캐스트가 로컬 응답으로 대체됨

switchdev HW 오프로드 프레임워크

switchdev는 리눅스 커널이 하드웨어 스위치 ASIC을 소프트웨어 브리지와 동일한 API로 제어할 수 있게 하는 프레임워크입니다. 사용자 공간에서 ip/bridge/tc 명령으로 설정하면, 커널 브리지가 switchdev 콜백을 통해 하드웨어 FDB/VLAN/MDB 테이블을 직접 프로그래밍합니다.

switchdev 이벤트 종류

/* net/bridge/br_switchdev.c — switchdev 알림 전송 */
int br_switchdev_fdb_notify(struct net_bridge *br,
                            const struct net_bridge_fdb_entry *fdb,
                            int type)
{
    struct switchdev_notifier_fdb_info info = {
        .addr     = fdb->key.addr.addr,
        .vid      = fdb->key.vlan_id,
        .added_by_user = test_bit(BR_FDB_ADDED_BY_USER, &fdb->flags),
        .offloaded = test_bit(BR_FDB_OFFLOADED, &fdb->flags),
    };

    switch (type) {
    case RTM_NEWNEIGH:
        return call_switchdev_notifiers(
            SWITCHDEV_FDB_ADD_TO_DEVICE,
            fdb->dst->dev, &info.info, NULL);
    case RTM_DELNEIGH:
        return call_switchdev_notifiers(
            SWITCHDEV_FDB_DEL_TO_DEVICE,
            fdb->dst->dev, &info.info, NULL);
    }
    return 0;
}

/* 드라이버 측: switchdev 이벤트 수신 등록 */
static struct notifier_block mlx5_swdev_nb = {
    .notifier_call = mlx5_esw_bridge_switchdev_event,
};
register_switchdev_notifier(&mlx5_swdev_nb);

switchdev 지원 NIC 비교

switchdev + bridge 설정 예제

# ━━━ Mellanox ConnectX-6 switchdev 모드 설정 ━━━

# 1. eSwitch 모드를 switchdev로 전환
devlink dev eswitch set pci/0000:03:00.0 mode switchdev

# 2. VF representor 자동 생성 확인
ip link show | grep enp3s0f0
# enp3s0f0: PF (uplink representor)
# enp3s0f0_0: VF0 representor
# enp3s0f0_1: VF1 representor

# 3. Bridge 생성 및 포트 연결
ip link add br0 type bridge vlan_filtering 1
ip link set br0 up
ip link set enp3s0f0 master br0
ip link set enp3s0f0_0 master br0
ip link set enp3s0f0_1 master br0
ip link set enp3s0f0 up
ip link set enp3s0f0_0 up
ip link set enp3s0f0_1 up

# 4. VLAN 설정 → HW VLAN 테이블에 자동 오프로드
bridge vlan add dev enp3s0f0_0 vid 100 pvid untagged
bridge vlan add dev enp3s0f0_1 vid 200 pvid untagged
bridge vlan add dev enp3s0f0 vid 100
bridge vlan add dev enp3s0f0 vid 200

# 5. 오프로드 상태 확인
bridge fdb show br br0 | grep offloaded
# 00:11:22:33:44:55 dev enp3s0f0_0 master br0 offloaded

# 6. TC flower 규칙도 HW 오프로드 가능
tc qdisc add dev enp3s0f0 ingress
tc filter add dev enp3s0f0 ingress protocol ip flower \
    dst_mac 00:11:22:33:44:55 action mirred egress redirect dev enp3s0f0_0

# ━━━ DSA 임베디드 스위치 (mv88e6xxx) 설정 ━━━

# DSA 스위치 포트는 자동으로 netdev 생성
ip link show | grep lan
# lan1, lan2, lan3, lan4: 각 물리 포트
# wan: 업링크 포트

# Bridge에 DSA 포트 연결
ip link add br-lan type bridge vlan_filtering 1
ip link set lan1 master br-lan
ip link set lan2 master br-lan
ip link set lan3 master br-lan
ip link set lan4 master br-lan

# HW 오프로드 자동 적용 확인
bridge -d link show | grep offload
# lan1: ... offload

br_netfilter와 ebtables

br_netfilter 커널 모듈은 브리지 트래픽이 Netfilter(iptables/nftables) 훅을 통과하도록 합니다. 이 모듈 없이는 브리지를 통과하는 패킷이 iptables 규칙의 영향을 받지 않아 Docker/Kubernetes 환경에서 네트워크 정책이 제대로 동작하지 않습니다.

/* net/bridge/br_netfilter_hooks.c — br_netfilter 훅 등록 */

/* PRE_ROUTING 훅: L3 주소를 위한 skb 전처리 */
static unsigned int br_nf_pre_routing(void *priv,
    struct sk_buff *skb,
    const struct nf_hook_state *state)
{
    struct net_bridge_port *p = br_port_get_rcu(skb->dev);

    /* skb->dev를 브리지 디바이스로 변경 (iptables가 브리지를 인식하도록) */
    skb->dev = p->br->dev;

    /* IPv4/IPv6 분기 처리 */
    if (skb->protocol == htons(ETH_P_IP))
        return br_nf_pre_routing_ipv4(priv, skb, state);
    return NF_ACCEPT;
}

/* br_netfilter 훅 배열 */
static const struct nf_hook_ops br_nf_ops[] = {
    {
        .hook     = br_nf_pre_routing,
        .pf       = NFPROTO_BRIDGE,
        .hooknum  = NF_BR_PRE_ROUTING,
        .priority = NF_BR_PRI_BRNF,
    },
    {
        .hook     = br_nf_forward_ip,
        .pf       = NFPROTO_BRIDGE,
        .hooknum  = NF_BR_FORWARD,
        .priority = NF_BR_PRI_BRNF,
    },
    /* ... POST_ROUTING, LOCAL_IN, LOCAL_OUT ... */
};

# br_netfilter 모듈 로드
modprobe br_netfilter

# 부팅 시 자동 로드 설정
echo "br_netfilter" > /etc/modules-load.d/br_netfilter.conf

# sysctl 설정 (브리지 트래픽 → iptables/nftables 적용)
sysctl net.bridge.bridge-nf-call-iptables=1
sysctl net.bridge.bridge-nf-call-ip6tables=1
sysctl net.bridge.bridge-nf-call-arptables=1

# 영구 설정 (재부팅 후에도 유지)
cat > /etc/sysctl.d/k8s.conf <<EOF
net.bridge.bridge-nf-call-iptables = 1
net.bridge.bridge-nf-call-ip6tables = 1
EOF
sysctl --system

# ebtables: L2 수준 MAC 주소 필터링
ebtables -A FORWARD -s 00:11:22:33:44:55 -j DROP

# ebtables: VLAN 태그 기반 필터링
ebtables -A FORWARD --vlan-id 100 -j DROP

# nftables bridge 체인 (ebtables 대체 권장)
nft add table bridge filter
nft add chain bridge filter forward { type filter hook forward priority 0 \; }
nft add rule bridge filter forward vlan id 100 drop

# br_netfilter 상태 확인
lsmod | grep br_netfilter
sysctl net.bridge

Docker/Kubernetes Bridge 네트워킹

컨테이너 네트워킹은 Linux Bridge를 핵심 인프라로 사용합니다. Docker는 docker0 브리지와 veth pair를 통해 컨테이너에 L2 연결을 제공하고, Kubernetes는 CNI 플러그인 체인(bridge + IPAM)을 통해 Pod 네트워크를 구성합니다. br_netfilter 모듈은 브리지 트래픽에 iptables 규칙을 적용하여 NetworkPolicy와 kube-proxy가 정상 동작하도록 합니다.

Docker bridge 네트워크 내부 동작

Docker의 기본 네트워크 드라이버인 bridge는 Linux Bridge를 기반으로 합니다. docker network create 시 브리지 netdev가 생성되고, docker run 시 veth pair가 생성되어 컨테이너의 네트워크 네임스페이스에 연결됩니다.

# ━━━ Docker bridge 네트워크 생성 흐름 ━━━

# 기본 docker0 브리지 확인
ip link show docker0
bridge link show master docker0
ip addr show docker0
# docker0: 172.17.0.1/16

# 커스텀 브리지 네트워크 생성
docker network create --driver bridge \
    --subnet 192.168.100.0/24 \
    --gateway 192.168.100.1 \
    --opt com.docker.network.bridge.name=br-custom \
    my-network

# 생성된 브리지 확인
ip link show br-custom
bridge fdb show br br-custom

# ━━━ 컨테이너 실행 시 네트워크 설정 과정 ━━━

# 1. veth pair 생성
docker run -d --name web --net my-network -p 8080:80 nginx

# 2. 호스트 측 veth 확인 (br-custom에 연결)
bridge link show master br-custom
# vethXXX: master br-custom state forwarding

# 3. 컨테이너 측 네트워크 확인
docker exec web ip addr show eth0
# eth0: 192.168.100.2/24
docker exec web ip route
# default via 192.168.100.1 dev eth0

# 4. Hairpin 자동 설정 확인
bridge -d link show dev vethXXX | grep hairpin
# hairpin on

# ━━━ NAT / 포트 포워딩 iptables 규칙 ━━━

# MASQUERADE: 컨테이너 → 외부 통신 시 호스트 IP로 SNAT
iptables -t nat -L POSTROUTING -n -v | grep 192.168.100
# MASQUERADE  all  --  192.168.100.0/24  0.0.0.0/0

# DNAT: -p 8080:80 포트 포워딩
iptables -t nat -L DOCKER -n -v
# DNAT  tcp  --  0.0.0.0/0  0.0.0.0/0  tcp dpt:8080 to:192.168.100.2:80

# 컨테이너 간 통신 허용 (ICC: Inter-Container Communication)
iptables -L DOCKER-ISOLATION-STAGE-1 -n -v
# 서로 다른 브리지 네트워크 간 격리 규칙

Kubernetes CNI bridge 플러그인

Kubernetes는 CNI(Container Network Interface) 사양을 통해 네트워크를 추상화합니다. bridge CNI 플러그인은 가장 기본적인 구현으로, Linux Bridge + veth pair + IPAM으로 Pod 네트워크를 구성합니다.

// /etc/cni/net.d/10-bridge.conflist — CNI bridge 설정
{
    "cniVersion": "1.0.0",
    "name": "k8s-pod-network",
    "plugins": [
        {
            "type": "bridge",
            "bridge": "cni0",
            "isGateway": true,
            "isDefaultGateway": true,
            "hairpinMode": true,
            "ipMasq": true,
            "ipam": {
                "type": "host-local",
                "ranges": [[{"subnet": "10.244.1.0/24"}]],
                "routes": [{"dst": "0.0.0.0/0"}]
            }
        },
        {
            "type": "portmap",
            "capabilities": {"portMappings": true}
        }
    ]
}

# ━━━ CNI bridge 플러그인 실행 과정 ━━━

# 1. kubelet → CRI (containerd) → CNI 호출
# CNI_COMMAND=ADD CNI_CONTAINERID=xxx CNI_NETNS=/proc/.../ns/net

# 2. bridge 플러그인: cni0 브리지 생성 (없으면)
ip link add cni0 type bridge
ip link set cni0 up
ip addr add 10.244.1.1/24 dev cni0

# 3. veth pair 생성 + 연결
ip link add vethXXX type veth peer name eth0 netns $POD_NS
ip link set vethXXX master cni0
ip link set vethXXX up

# 4. Pod 네임스페이스 내 설정
ip -n $POD_NS addr add 10.244.1.2/24 dev eth0
ip -n $POD_NS link set eth0 up
ip -n $POD_NS route add default via 10.244.1.1

# 5. hairpin 모드 설정
bridge link set dev vethXXX hairpin on

# ━━━ Pod-to-Pod 통신 확인 ━━━

# 같은 노드: L2 bridge forwarding
kubectl exec pod-a -- ping 10.244.1.3
# → veth → cni0 FDB 조회 → veth → pod-b (직접 L2)

# 다른 노드: L3 routing (또는 overlay)
kubectl exec pod-a -- ping 10.244.2.5
# → veth → cni0 → host routing → eth0 → remote-node → cni0 → veth → pod

# cni0 브리지 FDB 확인
bridge fdb show br cni0
bridge link show master cni0

컨테이너 네트워크 트러블슈팅

# 필수 sysctl 한 번에 확인
sysctl net.ipv4.ip_forward net.bridge.bridge-nf-call-iptables net.bridge.bridge-nf-call-ip6tables
# 모두 1이어야 정상

# 영구 설정
cat <<EOF > /etc/sysctl.d/99-kubernetes.conf
net.ipv4.ip_forward = 1
net.bridge.bridge-nf-call-iptables = 1
net.bridge.bridge-nf-call-ip6tables = 1
EOF
sysctl --system

TC flower 오프로드와 XDP redirect

소프트웨어 브리지의 CPU 부담을 극복하기 위해 두 가지 하드웨어 가속 방식을 사용합니다: TC flower는 NIC 하드웨어에서 포워딩을 처리하고, XDP redirect는 커널 스택 초기에 패킷을 리다이렉트하여 SW 브리지 오버헤드를 완전히 우회합니다.

/* drivers/net/ethernet/intel/i40e/i40e_main.c — TC flower 오프로드 패턴 */

/* ndo_setup_tc: TC_SETUP_CLSFLOWER 처리 */
static int i40e_setup_tc(struct net_device *netdev,
                        enum tc_setup_type type, void *type_data)
{
    switch (type) {
    case TC_SETUP_CLSFLOWER:
        return i40e_setup_tc_cls_flower(np, type_data);
    /* ... */
    }
}

/* XDP BPF 브리지: bpf_redirect()로 직접 포워딩 */
SEC("xdp")
int xdp_bridge(struct xdp_md *ctx) {
    void *data_end = (void *)(long)ctx->data_end;
    void *data     = (void *)(long)ctx->data;
    struct ethhdr *eth = data;

    if (eth + 1 > data_end)
        return XDP_DROP;

    /* FDB BPF map에서 목적지 포트 ifindex 조회 */
    __u32 *ifindex = bpf_map_lookup_elem(&fdb_map, eth->h_dest);
    if (!ifindex)
        return XDP_PASS;  /* SW 경로로 fallback */

    return bpf_redirect(*ifindex, 0);  /* 목적지 NIC으로 직접 전달 */
}

# TC flower 오프로드: VLAN 10 트래픽을 eth1로 리다이렉트
tc qdisc add dev eth0 ingress
tc filter add dev eth0 ingress \
    flower vlan_id 10 vlan_ethtype ip \
    action mirred egress redirect dev eth1

# 오프로드 확인 (in_hw 표시)
tc filter show dev eth0 ingress
# filter protocol 802.1Q pref 49152 flower chain 0 handle 0x1
#   in_hw in_hw_count 1       ← 하드웨어 오프로드 확인

# TC flower: MAC 주소 기반 포워딩
tc filter add dev eth0 ingress \
    flower dst_mac 00:11:22:33:44:55 \
    action mirred egress redirect dev eth2

# XDP 프로그램 로드
ip link set eth0 xdp obj bridge_xdp.o sec xdp

# XDP 상태 확인
ip link show eth0
# xdp/id:42  ← XDP 프로그램 로드됨

# XDP 제거
ip link set eth0 xdp off

Open vSwitch vs Linux Bridge 비교

가상화·클라우드 네트워킹에서 Linux Bridge와 Open vSwitch(OVS)는 가장 널리 쓰이는 소프트웨어 스위치입니다. Linux Bridge는 커널 내장 L2 스위치로 단순하고 안정적이며, OVS는 OpenFlow 기반의 유연한 SDN 데이터플레인을 제공합니다. OVS-DPDK는 커널을 완전히 우회하여 극한의 성능을 달성합니다.

상세 비교 테이블

OVS-DPDK 고성능 설정 예시

# 1. Hugepages 설정 (2MB × 2048 = 4GB)
echo 2048 > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages
mkdir -p /dev/hugepages
mount -t hugetlbfs nodev /dev/hugepages

# 2. DPDK 드라이버 바인딩 (VFIO-PCI 권장)
modprobe vfio-pci
dpdk-devbind --bind=vfio-pci 0000:03:00.0
dpdk-devbind --bind=vfio-pci 0000:03:00.1

# 3. OVS DPDK 초기화
ovs-vsctl --no-wait set Open_vSwitch . other_config:dpdk-init=true
ovs-vsctl --no-wait set Open_vSwitch . other_config:dpdk-socket-mem="1024,1024"
ovs-vsctl --no-wait set Open_vSwitch . other_config:dpdk-lcore-mask="0x2"

# 4. OVS 재시작
systemctl restart openvswitch

# 5. DPDK 브리지 생성
ovs-vsctl add-br br-dpdk -- set bridge br-dpdk datapath_type=netdev

# 6. DPDK 포트 추가 (PMD 스레드가 직접 폴링)
ovs-vsctl add-port br-dpdk dpdk-p0 -- set Interface dpdk-p0 \
    type=dpdk options:dpdk-devargs=0000:03:00.0
ovs-vsctl add-port br-dpdk dpdk-p1 -- set Interface dpdk-p1 \
    type=dpdk options:dpdk-devargs=0000:03:00.1

# 7. PMD 스레드 CPU 고정 (NUMA 인지 배치)
ovs-vsctl set Open_vSwitch . other_config:pmd-cpu-mask="0xC"   # CPU 2,3

# 8. Rx 큐 개수 (멀티큐 → 멀티 PMD)
ovs-vsctl set Interface dpdk-p0 options:n_rxq=2
ovs-vsctl set Interface dpdk-p1 options:n_rxq=2

# 9. OpenFlow 플로우 설정 (L2 포워딩)
ovs-ofctl add-flow br-dpdk "in_port=dpdk-p0,actions=output:dpdk-p1"
ovs-ofctl add-flow br-dpdk "in_port=dpdk-p1,actions=output:dpdk-p0"

# 10. PMD 통계 확인
ovs-appctl dpif-netdev/pmd-stats-show
ovs-appctl dpif-netdev/pmd-rxq-show

Bridge 보안 강화

Linux Bridge는 단순한 L2 스위치를 넘어 다양한 보안 기능을 제공합니다. 포트 격리, MAC 잠금, 802.1X 인증, 브로드캐스트 폭풍 제어를 조합하면 엔터프라이즈급 보안 요구사항을 충족할 수 있습니다.

포트 격리 (BR_ISOLATED)

BR_ISOLATED 플래그가 설정된 포트끼리는 직접 통신이 불가능합니다. 격리된 포트는 비격리(uplink) 포트로만 트래픽을 전달할 수 있으며, 멀티 테넌트 환경이나 공용 WiFi AP에서 클라이언트 간 격리에 사용됩니다.

# 포트 격리 설정
bridge link set dev eth1 isolated on
bridge link set dev eth2 isolated on

# 확인: isolated 플래그
bridge link show dev eth1
# 출력: ... state forwarding ... isolated

# eth1 ↔ eth2 직접 통신 차단, eth1 → uplink(eth0)는 허용
bridge link set dev eth0 isolated off   # uplink는 비격리

커널 내부에서는 br_forward()에서 격리 검사가 수행됩니다:

/* net/bridge/br_forward.c */
static bool should_deliver(const struct net_bridge_port *p,
                           const struct sk_buff *skb)
{
    struct net_bridge_port *src = br_port_get_rcu(skb->dev);

    /* 격리 포트끼리는 포워딩 금지 */
    if (src && (src->flags & BR_ISOLATED) &&
        (p->flags & BR_ISOLATED))
        return false;

    return p->state == BR_STATE_FORWARDING &&
           br_allowed_egress(p, skb) &&
           nbp_switchdev_allowed_egress(p, skb);
}

MAC 주소 제한 및 포트 잠금

BR_PORT_LOCKED 플래그는 동적 MAC 학습을 비활성화하여 명시적으로 등록된 정적 FDB 엔트리만 허용합니다. BR_PORT_MAB(MAC Auth Bypass)는 802.1X 인증 실패 시 MAC 주소 기반 대체 인증을 제공합니다.

# 포트 잠금: 동적 학습 차단, 정적 FDB만 허용
bridge link set dev eth1 locked on

# 허용할 MAC 주소를 정적으로 등록
bridge fdb add aa:bb:cc:dd:ee:01 dev eth1 master static
bridge fdb add aa:bb:cc:dd:ee:02 dev eth1 master static

# MAC Auth Bypass (802.1X 대체 — 커널 6.1+)
bridge link set dev eth1 locked on mab on

# 잠금 상태 확인
bridge -d link show dev eth1
# ... locked mab ...

# 등록되지 않은 MAC → FDB 미학습, 패킷 드롭

802.1X 통합 — hostapd

Linux Bridge와 hostapd를 연동하면 유선 이더넷 포트에서도 802.1X 포트 기반 인증을 구현할 수 있습니다. 인증 전에는 포트가 잠겨(locked) EAP 트래픽만 허용되고, RADIUS 인증 성공 후 포트가 열립니다.

# /etc/hostapd/wired.conf — 유선 802.1X 설정
interface=eth1
driver=wired
ieee8021x=1
eap_reauth_period=3600
use_pae_group_addr=1

# RADIUS 서버
auth_server_addr=192.168.1.10
auth_server_port=1812
auth_server_shared_secret=radius_secret

# 브리지 포트 사전 잠금
bridge link set dev eth1 locked on

# hostapd 시작 → PAE(Port Access Entity) 인증 시작
hostapd /etc/hostapd/wired.conf

# 인증 플로우:
# 1. 클라이언트 → EAPoL Start → eth1 (PAE 포트)
# 2. hostapd → EAP-Request/Identity → 클라이언트
# 3. 클라이언트 → EAP-Response → hostapd → RADIUS
# 4. RADIUS → Access-Accept → hostapd
# 5. hostapd → bridge fdb add → 포트 인증 완료, 트래픽 허용

Storm Control (브로드캐스트 폭풍 방지)

브로드캐스트/멀티캐스트 폭풍은 브리지 전체를 마비시킬 수 있습니다. TC police 액션으로 브리지 포트별 속도 제한을 적용합니다.

# 브로드캐스트 폭풍 방지: ARP 브로드캐스트 100kbit 제한
tc qdisc add dev eth1 ingress
tc filter add dev eth1 ingress protocol arp \
    flower \
    eth_type 0x0806 \
    action police rate 100kbit burst 32k conform-exceed drop/continue

# 멀티캐스트 제한: 전체 멀티캐스트 1Mbit 제한
tc filter add dev eth1 ingress protocol ip \
    flower \
    dst_mac 01:00:00:00:00:00/01:00:00:00:00:00 \
    action police rate 1mbit burst 64k conform-exceed drop/continue

# 전체 브로드캐스트 (ff:ff:ff:ff:ff:ff) 500kbit 제한
tc filter add dev eth1 ingress protocol all \
    flower \
    dst_mac ff:ff:ff:ff:ff:ff \
    action police rate 500kbit burst 32k conform-exceed drop/continue

# 알 수 없는 유니캐스트(flooding) 제한
# → FDB에 없는 목적지 MAC → 모든 포트로 flood → 제한 필요
tc filter add dev eth1 ingress protocol all \
    flower \
    action police rate 10mbit burst 128k conform-exceed drop/continue

# 적용된 필터 확인
tc filter show dev eth1 ingress

Bridge 보안 체크리스트

고급 진단: ftrace / bpftrace / perf

브리지 동작을 커널 내부까지 추적하려면 ftrace, bpftrace, perf를 활용합니다. FDB 학습/에이징, VLAN 드롭, STP 상태 전환, 멀티캐스트 그룹 변경 등을 실시간으로 관찰할 수 있습니다.

ftrace로 브리지 내부 추적

# function_graph: br_handle_frame 내부 호출 트리 추적
echo function_graph > /sys/kernel/debug/tracing/current_tracer
echo br_handle_frame > /sys/kernel/debug/tracing/set_graph_function
echo 1 > /sys/kernel/debug/tracing/tracing_on
# ... 트래픽 발생 ...
cat /sys/kernel/debug/tracing/trace | head -60
echo 0 > /sys/kernel/debug/tracing/tracing_on

# kprobe: FDB 학습 이벤트 캡처 (소스 MAC, VLAN ID)
echo 'p:fdb_learn br_fdb_update br=%di port=%si src=+0(%dx):x64 vid=%cx' \
    > /sys/kernel/debug/tracing/kprobe_events
echo 1 > /sys/kernel/debug/tracing/events/kprobes/fdb_learn/enable
cat /sys/kernel/debug/tracing/trace_pipe

# STP 상태 전환 추적
echo 'p:stp_change br_set_state port=%di state=%si' \
    > /sys/kernel/debug/tracing/kprobe_events
echo 1 > /sys/kernel/debug/tracing/events/kprobes/stp_change/enable

bpftrace로 브리지 통계

# FDB 히트/미스 통계 (1초마다 출력)
bpftrace -e '
kprobe:br_fdb_find_rcu { @fdb_lookup = count(); }
kretprobe:br_fdb_find_rcu / retval == 0 / { @fdb_miss = count(); }
interval:s:1 {
    printf("FDB lookup: %d, miss: %d, miss rate: %d%%\n",
           @fdb_lookup, @fdb_miss,
           @fdb_lookup > 0 ? @fdb_miss * 100 / @fdb_lookup : 0);
    clear(@fdb_lookup); clear(@fdb_miss);
}'

# VLAN ingress 드롭 추적 (드롭된 VLAN ID 빈도)
bpftrace -e '
kprobe:br_vlan_check_allowed {
    @drops[arg0] = count();  // arg0: vlan_id
}
interval:s:5 { print(@drops); clear(@drops); }'

# STP 상태 전환 감지 (포트명, old/new 상태)
bpftrace -e '
kprobe:br_set_state {
    $port = (struct net_bridge_port *)arg0;
    printf("STP state change: %s %d -> %d\n",
           str($port->dev->name), $port->state, arg1);
}'

# IGMP 멤버십 보고서 수신 추적
bpftrace -e '
kprobe:br_multicast_rcv { @igmp_rcv = count(); }
kprobe:br_multicast_add_group { @group_add = count(); }
interval:s:5 {
    printf("IGMP rcv: %d, group_add: %d\n", @igmp_rcv, @group_add);
    clear(@igmp_rcv); clear(@group_add);
}'

perf 및 기타 도구

# perf: 브리지 관련 커널 함수 프로파일링
perf record -g -e cycles:u -p $(pgrep dhcpcd) -- sleep 10
perf record -g -F 99 -- sleep 10
perf report --stdio | grep br_

# perf stat: 네트워크 이벤트 카운트
perf stat -e net:netif_receive_skb,net:net_dev_xmit sleep 10

# bridge 내장 통계
bridge -s link show                          # 포트별 TX/RX 통계
bridge -s fdb show                           # FDB 통계
watch -n 1 'bridge -s link show'            # 실시간 모니터링

# nft trace: nftables를 통한 패킷 추적
nft add rule bridge filter forward meta nftrace set 1
nft monitor trace

# dropwatch: 커널 패킷 드롭 위치 추적
dropwatch -l kas

# VLAN 통계 확인
bridge vlan show dev eth0 -s               # VLAN별 RX/TX 바이트/패킷

# ethtool로 NIC 오프로드 상태 확인
ethtool -k eth0 | grep -E 'tx-checksum|rx-checksum|hw-tc-offload'

# 브리지 상세 정보 (STP, VLAN, 멀티캐스트 설정)
bridge -d link show
bridge -d vlan show

커널 소스 구조

Linux Bridge 전체 소스는 net/bridge/ 디렉터리에 위치하며, 약 20개의 C 파일과 1개의 내부 헤더로 구성됩니다. 각 파일은 명확한 단일 책임을 갖습니다.

소스 파일 목록

net/bridge/
├── br.c                     # 모듈 초기화 (__init br_init, br_fdb_init, br_netfilter_init)
├── br_device.c              # net_device_ops 구현 (br_dev_xmit, br_dev_ioctl, br_change_mtu)
├── br_fdb.c                 # FDB 관리 (rhashtable, 학습, 에이징, fdb_insert, fdb_delete)
├── br_forward.c             # 패킷 포워딩 로직 (br_forward, br_flood, __br_forward)
├── br_if.c                  # 포트 추가/제거 (br_add_if, br_del_if, new_nbp)
├── br_input.c               # 수신 처리 진입점 (br_handle_frame, br_handle_frame_finish)
├── br_ioctl.c               # Legacy ioctl 인터페이스 (brctl 호환)
├── br_multicast.c           # IGMP/MLD snooping (br_multicast_rcv, mdb 관리)
├── br_multicast_eht.c       # Explicit Host Tracking (IGMPv3/MLDv2 소스별 추적)
├── br_mst.c                 # Multiple Spanning Tree (MST) 지원
├── br_netfilter_hooks.c     # br_netfilter 훅 (br_nf_pre_routing, br_nf_forward 등)
├── br_netfilter_ipv6.c      # br_netfilter IPv6 전용 처리
├── br_netlink.c             # Netlink RTNL 인터페이스 (iproute2/bridge 명령 통신)
├── br_nf_core.c             # br_netfilter 코어 (가짜 dst_entry 관리)
├── br_private.h             # 내부 헤더 (net_bridge, net_bridge_port, net_bridge_fdb_entry)
├── br_private_stp.h         # STP 내부 구조체/매크로
├── br_stp.c                 # STP 상태 머신 (br_received_config_bpdu, br_topology_change)
├── br_stp_bpdu.c            # BPDU 프레임 송수신 (br_send_config_bpdu, br_stp_rcv)
├── br_stp_if.c              # STP 포트 인터페이스 (br_stp_enable_port, br_stp_set_path_cost)
├── br_stp_timer.c           # STP 타이머 (hello, max_age, forward_delay)
├── br_switchdev.c           # switchdev 이벤트 통지 (FDB/VLAN 오프로드)
├── br_sysfs_br.c            # sysfs 브리지 속성 (/sys/class/net/br0/bridge/*)
├── br_sysfs_if.c            # sysfs 포트 속성 (/sys/class/net/br0/brif/eth0/*)
├── br_vlan.c                # VLAN 필터링 (nbp_vlan_add, br_allowed_ingress/egress)
├── br_vlan_options.c        # VLAN 옵션 Netlink 처리
├── br_vlan_tunnel.c         # VLAN-to-tunnel ID 매핑 (VXLAN 연동)
└── netfilter/               # ebtables 모듈 (ebt_*.c, ebtable_*.c)
    ├── ebtables.c           # ebtables 코어 프레임워크
    ├── ebt_among.c          # MAC/IP 쌍 매칭
    ├── ebt_arp.c            # ARP 필드 매칭
    ├── ebt_ip.c             # IPv4 헤더 매칭
    ├── ebt_ip6.c            # IPv6 헤더 매칭
    ├── ebt_stp.c            # STP BPDU 필드 매칭
    └── ebt_vlan.c           # VLAN 태그 매칭

주요 함수/심볼 테이블

성능 튜닝 및 벤치마킹

Linux Bridge의 성능은 NIC 하드웨어 오프로드부터 커널 파라미터, 브리지 자체 설정까지 다계층 튜닝이 가능합니다. 체계적 벤치마킹으로 병목을 식별하고 단계별로 최적화하는 것이 중요합니다.

성능 튜닝 파라미터 테이블

벤치마킹 방법론

# ============================================================
# 1. iperf3 처리량 테스트 (대역폭 측정)
# ============================================================

# 서버 측 (브리지 뒤 호스트)
iperf3 -s -B 192.168.1.2

# 클라이언트 측 (단일 스트림)
iperf3 -c 192.168.1.2 -t 30 -P 1

# 클라이언트 측 (멀티 스트림 — CPU 병렬 활용)
iperf3 -c 192.168.1.2 -t 30 -P 8

# UDP PPS 측정 (64바이트 패킷)
iperf3 -c 192.168.1.2 -u -b 10G -l 64 -t 30

# ============================================================
# 2. pktgen — 커널 패킷 생성기 (PPS 측정)
# ============================================================

modprobe pktgen

# pktgen 스레드 설정 (CPU 0)
echo "rem_device_all" > /proc/net/pktgen/kpktgend_0
echo "add_device eth1" > /proc/net/pktgen/kpktgend_0

# 패킷 설정
echo "pkt_size 64"        > /proc/net/pktgen/eth1
echo "count 10000000"     > /proc/net/pktgen/eth1
echo "dst 192.168.1.2"    > /proc/net/pktgen/eth1
echo "dst_mac aa:bb:cc:dd:ee:02" > /proc/net/pktgen/eth1
echo "delay 0"            > /proc/net/pktgen/eth1

# 실행
echo "start" > /proc/net/pktgen/pgctrl

# 결과 확인
cat /proc/net/pktgen/eth1
# Result: OK: ... (pps) ... (Mb/sec)

# ============================================================
# 3. perf — CPU 오버헤드 프로파일링
# ============================================================

# 브리지 관련 함수 핫스팟 확인
perf top -g -p 0 -- sleep 10

# 브리지 포워딩 경로 프로파일링
perf record -g -a -- sleep 10
perf report --sort comm,dso,symbol | grep "br_"

# 함수별 시간 비율 (상위 20개)
perf report --stdio --sort symbol --no-children | head -30

# 특정 브리지 함수 추적
perf stat -e "cycles,instructions,cache-misses" \
    -a -- sleep 10

# ============================================================
# 4. 브리지 통계 실시간 모니터링
# ============================================================

# 포트별 패킷 카운터
watch -n 1 "ip -s link show master br0"

# FDB 엔트리 수 모니터링
watch -n 1 "bridge fdb show br br0 | wc -l"

# softirq CPU 사용률
watch -n 1 "cat /proc/softirqs | grep NET"

FDB/MDB 크기별 성능 영향

관련 문서

이 주제와 관련된 다른 문서를 더 깊이 이해하고 싶다면 다음을 참고하세요.

• VLAN/VXLAN/Switchdev — VLAN, VXLAN 오버레이, switchdev HW 오프로드
• Bonding/Team/MACVLAN — NIC 이중화, 가상 NIC, veth, TUN/TAP
• 네트워크 스택 — TCP/IP 프로토콜 스택 구조
• sk_buff — 네트워크 패킷 관리
• Netfilter — 패킷 필터링과 NAT
• TC (Traffic Control) — 리눅스 트래픽 제어
• eSwitch (Embedded Switch) — eSwitch 아키텍처, switchdev 모드