CAN Bus (Controller Area Network)

CAN Bus와 Linux SocketCAN을 실시간 제어 네트워크 관점에서 심층 분석합니다. 클래식 CAN 2.0A/B와 CAN FD/CAN XL 프레임 구조, 비트 타이밍과 샘플 포인트 계산, 중재(Arbitration) 메커니즘, 오류 프레임 처리와 Fault Confinement, net_device 기반 드라이버 모델, SocketCAN RAW/BCM/ISOTP/J1939 소켓 프로토콜 활용, CAN Gateway 라우팅, 버스 오프 복구와 상태 모니터링, timestamp/queue 설정을 통한 지연시간 관리, 차량/산업 장비 환경에서의 진단 프레임 운용, candump/cansniffer/iproute2 기반 디버깅 절차까지 안정적 필드 운영을 위한 핵심 내용을 다룹니다.

개요

CAN(Controller Area Network)은 Robert Bosch GmbH가 1986년에 발표한 멀티마스터 시리얼 버스 프로토콜입니다. 원래 자동차 ECU(Electronic Control Unit) 간 통신을 위해 설계되었으나, 현재는 산업 자동화, 의료 기기, 항공우주, 해양, 철도 등 다양한 분야에서 사용됩니다.

CAN 버스 특성

CAN 프로토콜 버전 비교

CAN 프로토콜 계층

CAN 프레임 구조

CAN 프레임은 버스에서 전송되는 데이터의 기본 단위입니다. 프레임 유형에 따라 Data Frame, Remote Frame, Error Frame, Overload Frame으로 구분됩니다.

CAN 2.0 프레임 (struct can_frame)

#include <linux/can.h>

struct can_frame {
    canid_t can_id;         /* 11-bit (Standard) or 29-bit (Extended) + 플래그 */
    union {
        __u8 len;            /* 프레임 데이터 길이 (커널 6.x 이후) */
        __u8 can_dlc;        /* Data Length Code (0~8, 호환용) */
    };
    __u8    __pad;          /* 패딩 */
    __u8    __res0;         /* 예약 */
    __u8    len8_dlc;       /* 원래 DLC 값 (9~15 보존용) */
    __u8    data[8]  __attribute__((aligned(8)));  /* 페이로드 */
};

/* CAN ID 플래그 (can_id 상위 3비트) */
#define CAN_EFF_FLAG  0x80000000U  /* Extended Frame Format (29-bit ID) */
#define CAN_RTR_FLAG  0x40000000U  /* Remote Transmission Request */
#define CAN_ERR_FLAG  0x20000000U  /* Error Message Frame */

/* ID 마스크 */
#define CAN_SFF_MASK  0x000007FFU  /* Standard Frame: 11-bit ID */
#define CAN_EFF_MASK  0x1FFFFFFFU  /* Extended Frame: 29-bit ID */
#define CAN_ERR_MASK  0x1FFFFFFFU  /* Error 프레임 클래스 마스크 */

/* MTU 상수 */
#define CAN_MTU     sizeof(struct can_frame)      /* 16 bytes */
#define CANFD_MTU   sizeof(struct canfd_frame)    /* 72 bytes */
#define CANXL_MTU   sizeof(struct canxl_frame)    /* 2080 bytes */

CAN FD 프레임 (struct canfd_frame)

CAN FD(Flexible Data-rate)는 ISO 11898-1:2015에서 표준화되었으며, 최대 64바이트 페이로드와 BRS(Bit Rate Switch)를 통한 데이터 영역 고속 전송을 지원합니다.

struct canfd_frame {
    canid_t can_id;         /* 29-bit CAN ID + EFF/RTR/ERR 플래그 */
    __u8    len;            /* 실제 데이터 길이 (0, 1, ..., 8, 12, 16, 20, 24, 32, 48, 64) */
    __u8    flags;          /* CANFD_BRS, CANFD_ESI, CANFD_FDF */
    __u8    __res0;         /* 예약 */
    __u8    __res1;         /* 예약 */
    __u8    data[64]  __attribute__((aligned(8)));  /* 페이로드 */
};

#define CANFD_BRS  0x01  /* Bit Rate Switch: 데이터 영역 고속 전송 */
#define CANFD_ESI  0x02  /* Error State Indicator: 송신 노드가 Error Passive 상태 */
#define CANFD_FDF  0x04  /* FD Format: CAN FD 프레임 표시 (6.x+) */

CAN FD DLC-to-Length 매핑

/* DLC → 길이 변환 (커널 내부) */
static const u8 can_fd_dlc2len[] = {
    0, 1, 2, 3, 4, 5, 6, 7,
    8, 12, 16, 20, 24, 32, 48, 64
};

/* 길이 → DLC 변환 (가장 작은 DLC 선택) */
u8 can_fd_len2dlc(u8 len);   /* 예: 10 → 9 (12바이트로 패딩) */

CAN XL 프레임 (struct canxl_frame)

CAN XL(eXtra Long)은 CiA 610에서 정의된 차세대 CAN으로, 최대 2048바이트 페이로드와 10 Mbps 데이터 전송을 지원합니다. Linux 커널 6.3부터 지원됩니다.

/* include/uapi/linux/can.h (커널 6.3+) */
struct canxl_frame {
    canid_t prio;           /* 11-bit 우선순위 + CANXL_XLF 플래그 */
    __u8    flags;          /* CANXL_SEC 등 추가 플래그 */
    __u8    sdt;            /* SDU (Service Data Unit) Type */
    __u16   len;            /* 데이터 길이 (1~2048) */
    __u32   af;             /* Acceptance Field (32-bit) */
    __u8    data[2048]  __attribute__((aligned(8)));
};

#define CANXL_XLF     0x80  /* prio에 설정: XL Frame 식별 */
#define CANXL_SEC     0x01  /* flags: 보안(SecOC) 활성화 */
#define CANXL_MIN_DLEN  1   /* 최소 데이터 길이 */
#define CANXL_MAX_DLEN  2048 /* 최대 데이터 길이 */

SocketCAN 아키텍처

SocketCAN은 CAN 통신을 리눅스 네트워크 서브시스템에 통합하여 표준 BSD 소켓 API(PF_CAN)로 CAN 메시지를 송수신할 수 있게 합니다. 캐릭터 디바이스 방식의 기존 CAN 드라이버와 달리, net_device 기반으로 동작하여 ifconfig/ip 명령, 패킷 필터, 방화벽 등 기존 네트워크 도구와 통합됩니다.

SocketCAN 프로토콜 패밀리

SocketCAN API

CAN RAW 소켓

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <linux/can.h>
#include <linux/can/raw.h>
#include <net/if.h>

int main(void)
{
    int s;
    struct sockaddr_can addr;
    struct ifreq ifr;

    /* 1. CAN RAW 소켓 생성 */
    s = socket(PF_CAN, SOCK_RAW, CAN_RAW);
    if (s < 0) {
        perror("socket");
        return 1;
    }

    /* 2. 인터페이스 이름 → 인덱스 변환 */
    strncpy(ifr.ifr_name, "can0", IFNAMSIZ - 1);
    if (ioctl(s, SIOCGIFINDEX, &ifr) < 0) {
        perror("ioctl SIOCGIFINDEX");
        close(s);
        return 1;
    }

    /* 3. 소켓을 CAN 인터페이스에 바인딩 */
    memset(&addr, 0, sizeof(addr));
    addr.can_family = AF_CAN;
    addr.can_ifindex = ifr.ifr_ifindex;

    if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        perror("bind");
        close(s);
        return 1;
    }

    /* 4. CAN 프레임 송신 */
    struct can_frame tx_frame = {
        .can_id  = 0x123,
        .len     = 4,
        .data    = {0xDE, 0xAD, 0xBE, 0xEF},
    };

    if (write(s, &tx_frame, sizeof(tx_frame)) != sizeof(tx_frame)) {
        perror("write");
        close(s);
        return 1;
    }

    /* 5. CAN 프레임 수신 */
    struct can_frame rx_frame;
    ssize_t nbytes = read(s, &rx_frame, sizeof(rx_frame));
    if (nbytes < 0) {
        perror("read");
        close(s);
        return 1;
    }

    printf("RX: ID=0x%03X [%d] ", rx_frame.can_id & CAN_SFF_MASK, rx_frame.len);
    for (int i = 0; i < rx_frame.len; i++)
        printf("%02X ", rx_frame.data[i]);
    printf("\\n");

    close(s);
    return 0;
}

CAN 필터링

/* CAN ID 필터 구조체 */
struct can_filter {
    canid_t can_id;    /* 매칭할 CAN ID */
    canid_t can_mask;  /* 매칭 마스크: (received_id & mask) == (can_id & mask) */
};

/* 필터 설정 예제 */
struct can_filter rfilter[3];

/* 필터 1: ID 0x100~0x1FF 범위 수신 */
rfilter[0].can_id   = 0x100;
rfilter[0].can_mask = 0x700;

/* 필터 2: ID 0x200 정확히 매칭 */
rfilter[1].can_id   = 0x200;
rfilter[1].can_mask = CAN_SFF_MASK;

/* 필터 3: Extended ID 0x18FEF100 매칭 */
rfilter[2].can_id   = 0x18FEF100 | CAN_EFF_FLAG;
rfilter[2].can_mask = CAN_EFF_MASK | CAN_EFF_FLAG;

setsockopt(s, SOL_CAN_RAW, CAN_RAW_FILTER, &rfilter, sizeof(rfilter));

/* 모든 프레임 수신 (필터 비활성화) */
setsockopt(s, SOL_CAN_RAW, CAN_RAW_FILTER, NULL, 0);

/* 역 필터 (지정된 ID를 제외하고 모두 수신) */
canid_t exclude_id = 0x123;
rfilter[0].can_id   = exclude_id | CAN_INV_FILTER;
rfilter[0].can_mask = CAN_SFF_MASK | CAN_INV_FILTER;
setsockopt(s, SOL_CAN_RAW, CAN_RAW_FILTER, &rfilter, sizeof(rfilter[0]));

CAN RAW 소켓 옵션

/* 에러 프레임 수신 활성화 */
can_err_mask_t err_mask = (CAN_ERR_TX_TIMEOUT | CAN_ERR_BUSOFF |
                           CAN_ERR_BUSERROR | CAN_ERR_CRTL);
setsockopt(s, SOL_CAN_RAW, CAN_RAW_ERR_FILTER, &err_mask, sizeof(err_mask));

/* CAN FD 활성화 */
int enable_canfd = 1;
setsockopt(s, SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &enable_canfd, sizeof(enable_canfd));

/* 루프백 비활성화 */
int loopback = 0;
setsockopt(s, SOL_CAN_RAW, CAN_RAW_LOOPBACK, &loopback, sizeof(loopback));

비트 타이밍과 동기화

CAN 버스의 신뢰성은 모든 노드가 동일한 시점에 비트를 샘플링하는 데 달려 있습니다. 비트 타이밍은 하나의 비트를 여러 시간 세그먼트로 나누어 전파 지연을 보상하고, 샘플 포인트를 정확히 설정합니다.

비트 타이밍 상수 (can_bittiming_const)

/* include/linux/can/bittiming.h */
struct can_bittiming_const {
    char name[16];          /* 컨트롤러 이름 */
    __u32 tseg1_min;         /* PROP_SEG + PHASE_SEG1 최솟값 */
    __u32 tseg1_max;         /* PROP_SEG + PHASE_SEG1 최댓값 */
    __u32 tseg2_min;         /* PHASE_SEG2 최솟값 */
    __u32 tseg2_max;         /* PHASE_SEG2 최댓값 */
    __u32 sjw_max;           /* Synchronization Jump Width 최댓값 */
    __u32 brp_min;           /* Baud Rate Prescaler 최솟값 */
    __u32 brp_max;           /* Baud Rate Prescaler 최댓값 */
    __u32 brp_inc;           /* Prescaler 증가 단위 */
};

struct can_bittiming {
    __u32 bitrate;           /* 비트레이트 (bps) */
    __u32 sample_point;      /* 샘플 포인트 (0.1% 단위, 예: 875 = 87.5%) */
    __u32 tq;                /* Time Quantum (ns) */
    __u32 prop_seg;          /* Propagation Segment (tq) */
    __u32 phase_seg1;        /* Phase Buffer Segment 1 (tq) */
    __u32 phase_seg2;        /* Phase Buffer Segment 2 (tq) */
    __u32 sjw;               /* Synchronization Jump Width (tq) */
    __u32 brp;               /* Baud Rate Prescaler */
};

# 비트 타이밍 설정 (커널이 자동 계산)
$ sudo ip link set can0 type can bitrate 500000

# 샘플 포인트 명시
$ sudo ip link set can0 type can bitrate 500000 sample-point 0.875

# CAN FD 듀얼 비트레이트 (Nominal + Data)
$ sudo ip link set can0 type can bitrate 500000 dbitrate 4000000 fd on

# 수동 비트 타이밍 설정 (TQ 직접 지정)
$ sudo ip link set can0 type can \
    tq 125 prop-seg 6 phase-seg1 7 phase-seg2 2 sjw 1

# 현재 비트 타이밍 확인
$ ip -details link show can0
    can state ERROR-ACTIVE (berr-counter tx 0 rx 0) restart-ms 0
          bitrate 500000 sample-point 0.875
          tq 125 prop-seg 6 phase-seg1 7 phase-seg2 2 sjw 1
          mcp251x: tseg1 3..16 tseg2 2..8 sjw 1..4 brp 1..64 brp-inc 1
          clock 8000000

비트 타이밍 계산 예제

에러 핸들링과 Fault Confinement

CAN 버스의 핵심 안전 기능은 Fault Confinement 메커니즘입니다. 결함이 있는 노드가 버스 전체를 교란하지 않도록, 에러 카운터 기반의 자동 격리 시스템이 동작합니다.

CAN 에러 상태 (커널)

/* include/uapi/linux/can/netlink.h */
enum can_state {
    CAN_STATE_ERROR_ACTIVE,   /* 정상: TEC,REC < 96 */
    CAN_STATE_ERROR_WARNING,  /* 경고: TEC/REC 96~127 */
    CAN_STATE_ERROR_PASSIVE,  /* 수동: TEC/REC 128~255 */
    CAN_STATE_BUS_OFF,        /* 격리: TEC > 255 */
    CAN_STATE_STOPPED,        /* 인터페이스 중지 */
    CAN_STATE_SLEEPING,       /* 절전 모드 */
    CAN_STATE_MAX
};

에러 프레임 처리

/* 에러 프레임 수신 활성화 */
can_err_mask_t err_mask = CAN_ERR_MASK;  /* 모든 에러 */
setsockopt(s, SOL_CAN_RAW, CAN_RAW_ERR_FILTER, &err_mask, sizeof(err_mask));

/* 에러 프레임 수신 및 분석 */
struct can_frame frame;
read(s, &frame, sizeof(frame));

if (frame.can_id & CAN_ERR_FLAG) {
    printf("Error frame: class=0x%08X\\n", frame.can_id & CAN_ERR_MASK);

    /* 에러 클래스 분석 */
    if (frame.can_id & CAN_ERR_TX_TIMEOUT)
        printf("  TX timeout\\n");
    if (frame.can_id & CAN_ERR_LOSTARB)
        printf("  Lost arbitration at bit %d\\n", frame.data[0]);
    if (frame.can_id & CAN_ERR_CRTL) {
        if (frame.data[1] & CAN_ERR_CRTL_RX_WARNING)
            printf("  RX error warning\\n");
        if (frame.data[1] & CAN_ERR_CRTL_TX_PASSIVE)
            printf("  TX error passive\\n");
    }
    if (frame.can_id & CAN_ERR_PROT) {
        printf("  Protocol error: type=0x%02X loc=0x%02X\\n",
               frame.data[2], frame.data[3]);
    }
    if (frame.can_id & CAN_ERR_BUSOFF)
        printf("  Bus-off!\\n");
    if (frame.can_id & CAN_ERR_BUSERROR)
        printf("  Bus error (bit/form/stuff/CRC)\\n");

    /* 에러 카운터 (data[6]=TEC, data[7]=REC) */
    printf("  TEC=%d REC=%d\\n", frame.data[6], frame.data[7]);
}

에러 클래스 비트맵

CAN FD 실전 활용

/* CAN FD 송수신 완전 예제 */
#include <linux/can.h>
#include <linux/can/raw.h>

int can_fd_example(const char *ifname)
{
    int s = socket(PF_CAN, SOCK_RAW, CAN_RAW);
    struct ifreq ifr;
    struct sockaddr_can addr;

    /* CAN FD 활성화 (필수!) */
    int enable_fd = 1;
    setsockopt(s, SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &enable_fd, sizeof(enable_fd));

    /* 바인딩 */
    strncpy(ifr.ifr_name, ifname, IFNAMSIZ - 1);
    ioctl(s, SIOCGIFINDEX, &ifr);
    addr.can_family = AF_CAN;
    addr.can_ifindex = ifr.ifr_ifindex;
    bind(s, (struct sockaddr *)&addr, sizeof(addr));

    /* CAN FD 프레임 송신 (64바이트, BRS 활성) */
    struct canfd_frame fdframe = {
        .can_id = 0x123,
        .len    = 64,
        .flags  = CANFD_BRS,   /* 데이터 영역 고속 전송 */
    };
    memset(fdframe.data, 0xAA, 64);
    write(s, &fdframe, CANFD_MTU);

    /* 수신: CAN 2.0과 CAN FD 모두 처리 */
    struct canfd_frame rx;
    ssize_t nbytes = read(s, &rx, CANFD_MTU);

    if (nbytes == CAN_MTU) {
        printf("Classic CAN: ID=0x%03X len=%d\\n",
               rx.can_id & CAN_SFF_MASK, rx.len);
    } else if (nbytes == CANFD_MTU) {
        printf("CAN FD: ID=0x%03X len=%d flags=0x%02X\\n",
               rx.can_id & CAN_SFF_MASK, rx.len, rx.flags);
        if (rx.flags & CANFD_BRS)
            printf("  BRS (Bit Rate Switch) active\\n");
        if (rx.flags & CANFD_ESI)
            printf("  ESI (Error State Indicator)\\n");
    }

    close(s);
    return 0;
}

# CAN FD 인터페이스 설정
$ sudo ip link set can0 type can bitrate 500000 dbitrate 4000000 fd on
$ sudo ip link set up can0

# CAN FD MTU 확인 (72 = CANFD_MTU)
$ ip -details link show can0 | grep mtu
    ... mtu 72 ...

# CAN FD 프레임 송신 (can-utils)
$ cansend can0 123##1.DEADBEEFCAFEBABE1122334455667788
#                  ^ flags(BRS=1)  64바이트 페이로드

# CAN FD candump (길이 자동 식별)
$ candump can0
  can0  123  [64]  DE AD BE EF CA FE BA BE 11 22 33 44 55 66 77 88 ...

상위 프로토콜

ISO-TP (ISO 15765-2)

ISO-TP는 CAN의 8/64바이트 한계를 극복하여 최대 4095바이트(확장 주소 시 더 많은)의 데이터를 여러 CAN 프레임으로 분할/재조합하는 전송 프로토콜입니다. 자동차 진단(UDS/OBD-II)의 기반이며, Linux 커널 5.10부터 메인라인에 포함되었습니다.

#include <linux/can/isotp.h>

/* ISO-TP 소켓 생성 */
int s = socket(PF_CAN, SOCK_DGRAM, CAN_ISOTP);

/* ISO-TP 옵션 설정 */
struct can_isotp_options opts = {
    .flags    = CAN_ISOTP_TX_PADDING | CAN_ISOTP_RX_PADDING,
    .txpad_content = 0xCC,     /* TX 패딩 바이트 */
    .rxpad_content = 0xCC,     /* RX 패딩 바이트 */
    .ext_address   = 0x00,     /* Extended Address (0이면 미사용) */
};
setsockopt(s, SOL_CAN_ISOTP, CAN_ISOTP_OPTS, &opts, sizeof(opts));

/* 흐름 제어 파라미터 설정 */
struct can_isotp_fc_options fc = {
    .bs    = 0,     /* Block Size: 0 = 제한 없음 */
    .stmin = 5,     /* Separation Time min: 5ms */
    .wftmax = 0,    /* Wait Frame 최대 수 */
};
setsockopt(s, SOL_CAN_ISOTP, CAN_ISOTP_RECV_FC, &fc, sizeof(fc));

/* 주소 바인딩 (TX CAN ID = 0x7E0, RX CAN ID = 0x7E8) */
struct sockaddr_can addr = {
    .can_family = AF_CAN,
    .can_ifindex = ifr.ifr_ifindex,
    .can_addr.tp.tx_id = 0x7E0,
    .can_addr.tp.rx_id = 0x7E8,
};
bind(s, (struct sockaddr *)&addr, sizeof(addr));

/* UDS 진단 요청 전송 (예: Read DTC Information) */
uint8_t uds_req[] = {0x19, 0x02, 0xFF};  /* SID=0x19, SubFunc=0x02 */
write(s, uds_req, sizeof(uds_req));

/* 응답 수신 (자동 분할/재조합) */
uint8_t resp[4096];
ssize_t len = read(s, resp, sizeof(resp));
printf("ISO-TP response: %zd bytes\\n", len);

# ISO-TP 명령행 도구 (can-utils)
# isotpsend: ISO-TP 데이터 송신
$ echo "19 02 FF" | isotpsend -s 7E0 -d 7E8 can0

# isotprecv: ISO-TP 데이터 수신 (별도 터미널)
$ isotprecv -s 7E8 -d 7E0 can0

# isotpdump: ISO-TP 프레임 추적
$ isotpdump -s 7E0 -d 7E8 can0

J1939 (SAE J1939)

J1939는 상용차(트럭, 버스, 농기계, 건설 장비)에서 사용되는 CAN 기반 상위 프로토콜입니다. 29-bit Extended CAN ID를 우선순위(3bit) + PGN(Parameter Group Number, 18bit) + Source Address(8bit)로 분해합니다.

J1939 CAN ID 구조

#include <linux/can/j1939.h>

/* J1939 소켓 생성 */
int s = socket(PF_CAN, SOCK_DGRAM, CAN_J1939);

/* J1939 주소 바인딩 */
struct sockaddr_can addr = {
    .can_family = AF_CAN,
    .can_ifindex = ifr.ifr_ifindex,
    .can_addr.j1939 = {
        .name = J1939_NO_NAME,       /* NAME 미사용 (주소 직접 지정) */
        .addr = 0x80,                /* Source Address */
        .pgn  = J1939_NO_PGN,        /* 모든 PGN 수신 */
    },
};
bind(s, (struct sockaddr *)&addr, sizeof(addr));

/* 우선순위 설정 (setsockopt) */
int prio = 3;
setsockopt(s, SOL_CAN_J1939, SO_J1939_SEND_PRIO, &prio, sizeof(prio));

/* J1939 메시지 송신 (PGN 0xFEF1 = Cruise Control/Vehicle Speed) */
struct sockaddr_can dst = {
    .can_family = AF_CAN,
    .can_addr.j1939 = {
        .name = J1939_NO_NAME,
        .addr = J1939_NO_ADDR,       /* 브로드캐스트 */
        .pgn  = 0xFEF1,              /* PGN: CCVS */
    },
};
uint8_t data[8] = {0xFF, 0xFF, 0x00, 0x64, 0xFF, 0xFF, 0xFF, 0xFF};
sendto(s, data, 8, 0, (struct sockaddr *)&dst, sizeof(dst));

/* J1939 Transport Protocol (TP) — 8바이트 초과 자동 분할 */
uint8_t big_data[1785];
memset(big_data, 0x55, sizeof(big_data));
sendto(s, big_data, sizeof(big_data), 0,
       (struct sockaddr *)&dst, sizeof(dst));
/* 커널이 BAM(Broadcast Announce Message) 또는 CMDT 프로토콜로 자동 분할 */

CAN BCM (Broadcast Manager)

CAN BCM은 주기적 CAN 메시지 전송과 메시지 변경 감지를 커널 공간에서 처리하는 고급 프로토콜입니다. 사용자 공간에서 타이머를 돌리는 것보다 정확하고 효율적입니다.

#include <linux/can/bcm.h>

/* BCM 소켓 생성 (반드시 SOCK_DGRAM) */
int s = socket(PF_CAN, SOCK_DGRAM, CAN_BCM);

/* connect (BCM은 bind 대신 connect 사용) */
struct sockaddr_can addr = {
    .can_family = AF_CAN,
    .can_ifindex = ifr.ifr_ifindex,
};
connect(s, (struct sockaddr *)&addr, sizeof(addr));

/* BCM 메시지 구조 (TX_SETUP: 주기적 전송) */
struct {
    struct bcm_msg_head msg_head;
    struct can_frame frames[1];
} bcm_msg;

memset(&bcm_msg, 0, sizeof(bcm_msg));
bcm_msg.msg_head.opcode  = TX_SETUP;
bcm_msg.msg_head.can_id  = 0x100;
bcm_msg.msg_head.flags   = SETTIMER | STARTTIMER;
bcm_msg.msg_head.nframes = 1;
bcm_msg.msg_head.ival2.tv_sec  = 0;
bcm_msg.msg_head.ival2.tv_usec = 100000;  /* 100ms 주기 */

bcm_msg.frames[0].can_id  = 0x100;
bcm_msg.frames[0].len     = 4;
bcm_msg.frames[0].data[0] = 0x01;
bcm_msg.frames[0].data[1] = 0x02;
bcm_msg.frames[0].data[2] = 0x03;
bcm_msg.frames[0].data[3] = 0x04;

write(s, &bcm_msg, sizeof(bcm_msg));
/* 커널이 100ms마다 0x100#01020304를 자동 송신 */

/* RX_SETUP: 변경 감지 (content filter) */
struct {
    struct bcm_msg_head msg_head;
    struct can_frame frames[1];
} bcm_rx;

memset(&bcm_rx, 0, sizeof(bcm_rx));
bcm_rx.msg_head.opcode  = RX_SETUP;
bcm_rx.msg_head.can_id  = 0x200;
bcm_rx.msg_head.flags   = RX_FILTER_ID;  /* ID만 필터 (데이터 무시) */
bcm_rx.msg_head.nframes = 0;

write(s, &bcm_rx, sizeof(bcm_rx.msg_head));
/* 0x200 프레임이 수신되면 read()로 알림 수신 */

BCM 명령어 (Opcode)

CAN Gateway (cangw)

CAN Gateway는 CAN 인터페이스 간 프레임을 라우팅하고, 선택적으로 CAN ID나 데이터를 변환하는 커널 기능입니다. Netlink 소켓으로 설정합니다.

# CAN Gateway 모듈 로드
$ sudo modprobe can-gw

# can0 → can1 프레임 포워딩 (모든 프레임)
$ sudo cangw -A -s can0 -d can1 -e

# can0 → can1 프레임 포워딩 (특정 ID만, ID 변환 포함)
$ sudo cangw -A -s can0 -d can1 -f 123:7FF -m SET:I:456
#   -f 123:7FF  : ID 0x123만 필터
#   -m SET:I:456: 대상 CAN ID를 0x456으로 변경

# 데이터 바이트 수정 (XOR 마스크)
$ sudo cangw -A -s can0 -d can1 -f 100:7FF -m XOR:D:FF00000000000000
#   data[0]에 0xFF를 XOR

# 양방향 게이트웨이 (can0 ↔ can1)
$ sudo cangw -A -s can0 -d can1 -e
$ sudo cangw -A -s can1 -d can0 -e

# 현재 게이트웨이 규칙 목록
$ cangw -L

# 게이트웨이 규칙 삭제
$ sudo cangw -D -s can0 -d can1 -e

# 모든 규칙 초기화
$ sudo cangw -F

Virtual CAN (vcan/vxcan)

가상 CAN 인터페이스를 사용하면 실제 하드웨어 없이 CAN 통신을 테스트할 수 있습니다.

# === vcan: 단일 가상 인터페이스 (루프백) ===
$ sudo modprobe vcan
$ sudo ip link add dev vcan0 type vcan
$ sudo ip link set up vcan0

# vcan0 확인
$ ip link show vcan0
4: vcan0: <NOARP,UP,LOWER_UP> mtu 72 qdisc noqueue state UNKNOWN

# CAN FD 지원 vcan (MTU=72)
$ sudo ip link add dev vcan0 type vcan
$ ip link show vcan0 | grep mtu
    ... mtu 72 ...   # CAN FD 지원 (72 = CANFD_MTU)

# === vxcan: 네임스페이스 간 가상 CAN 터널 ===
# (veth처럼 동작하는 CAN 인터페이스 페어)
$ sudo modprobe vxcan
$ sudo ip link add dev vxcan0 type vxcan
# vxcan0과 vxcan1이 한 쌍으로 생성됨
$ sudo ip link set up vxcan0
$ sudo ip link set up vxcan1

# 네임스페이스 분리 테스트
$ sudo ip netns add can_ns
$ sudo ip link set vxcan1 netns can_ns
$ sudo ip netns exec can_ns ip link set up vxcan1

# 터미널 1: vxcan0에서 수신
$ candump vxcan0

# 터미널 2: 네임스페이스 내 vxcan1에서 송신
$ sudo ip netns exec can_ns cansend vxcan1 123#DEADBEEF

# 인터페이스 삭제
$ sudo ip link delete vcan0
$ sudo ip link delete vxcan0

can-utils 진단 도구

# can-utils 설치
$ sudo apt install can-utils   # Debian/Ubuntu
$ sudo dnf install can-utils   # Fedora/RHEL

# === cansend: 단일 프레임 송신 ===
$ cansend can0 123#DEADBEEF               # Standard ID
$ cansend can0 12345678#1122334455667788  # Extended ID (자동 감지)
$ cansend can0 123#R                       # RTR 프레임
$ cansend can0 123##1.AABBCCDD             # CAN FD (flags.data)

# === candump: 프레임 수신/덤프 ===
$ candump can0                            # 모든 프레임
$ candump can0 -t a                       # 절대 타임스탬프
$ candump can0 -t d                       # 이전 프레임과의 시간 차이
$ candump can0 -x                         # 확장 포맷 (FD 플래그 표시)
$ candump can0 -e                         # 에러 프레임 포함
$ candump can0,123:7FF                    # ID 0x123만 필터
$ candump can0,100:700,200:7FF            # 복수 필터 (OR)
$ candump can0 -l                         # 로그 파일 저장
$ candump can0 -L                         # 콤팩트 로그 형식

# === cangen: 트래픽 생성기 ===
$ cangen can0 -g 10                       # 10ms 간격 랜덤 프레임
$ cangen can0 -I 100 -L 8 -D i -g 1      # ID=0x100, 8byte, 증가 데이터
$ cangen can0 -f -L 64 -g 5               # CAN FD 64byte

# === cansniffer: 실시간 메시지 변경 감시 ===
$ cansniffer can0 -c                      # 색상 하이라이트
# 변경된 바이트만 색상으로 표시 → 리버스 엔지니어링에 유용

# === canplayer: 로그 파일 재생 ===
$ canplayer -I candump.log                # 타이밍 무시 재생
$ canplayer -I candump.log -t             # 원래 타이밍 유지

# === canbusload: 버스 부하율 측정 ===
$ canbusload can0@500000 -r 1 -b -c
# 500Kbps 기준으로 1초 간격 부하율 표시

CAN 하드웨어와 드라이버

slcan (Serial Line CAN)

# slcan: 시리얼 포트를 CAN 인터페이스로 변환
$ sudo modprobe slcan

# USB-CAN 어댑터 설정 (예: Lawicel CANUSB)
$ sudo slcand -o -s6 -t hw -S 3000000 /dev/ttyUSB0 slcan0
$ sudo ip link set up slcan0

# slcan 속도 코드
#   s0 = 10 Kbps     s1 = 20 Kbps
#   s2 = 50 Kbps     s3 = 100 Kbps
#   s4 = 125 Kbps    s5 = 250 Kbps
#   s6 = 500 Kbps    s7 = 800 Kbps
#   s8 = 1 Mbps

MCP2515 (SPI CAN 컨트롤러)

/* Device Tree Overlay (Raspberry Pi + MCP2515) */
/* /boot/config.txt에 추가: */
/* dtoverlay=mcp2515-can0,oscillator=16000000,interrupt=25,spimaxfrequency=2000000 */

&spi0 {
    status = "okay";
    mcp2515: can@0 {
        compatible = "microchip,mcp2515";
        reg = <0>;
        spi-max-frequency = <2000000>;
        clocks = <&mcp2515_osc>;
        interrupt-parent = <&gpio>;
        interrupts = <25 0x2>;    /* GPIO25, 하강 에지 */
    };
};

mcp2515_osc: mcp2515-osc {
    compatible = "fixed-clock";
    #clock-cells = <0>;
    clock-frequency = <16000000>;  /* 16MHz 크리스탈 */
};

# 재부팅 후 can0 인터페이스 확인
$ ip link show can0
$ sudo ip link set can0 type can bitrate 500000
$ sudo ip link set up can0
$ dmesg | grep mcp251x
[   12.345678] mcp251x spi0.0 can0: MCP2515 successfully initialized.

주요 CAN 드라이버 목록

CAN 디바이스 드라이버 작성

CAN 드라이버는 alloc_candev()로 net_device를 할당하고, can_priv 구조체의 비트 타이밍/모드 정보를 설정한 후, register_candev()로 등록합니다.

#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/can.h>
#include <linux/can/dev.h>

struct my_can_priv {
    struct can_priv can;     /* 반드시 첫 번째 멤버 */
    void __iomem *base;
    struct clk *clk;
    int irq;
};

/* 비트 타이밍 상수 (하드웨어 사양) */
static const struct can_bittiming_const my_bittiming_const = {
    .name      = "my_can",
    .tseg1_min = 1,   .tseg1_max = 16,
    .tseg2_min = 1,   .tseg2_max = 8,
    .sjw_max   = 4,
    .brp_min   = 1,   .brp_max   = 64,  .brp_inc = 1,
};

/* 인터페이스 열기 */
static int my_can_open(struct net_device *dev)
{
    struct my_can_priv *priv = netdev_priv(dev);
    int err;

    /* CAN 공통 열기 (비트 타이밍 적용, 에러 카운터 초기화) */
    err = open_candev(dev);
    if (err)
        return err;

    /* 하드웨어 초기화: 레지스터 설정, IRQ 등록 등 */
    /* ... */

    netif_start_queue(dev);
    return 0;
}

/* 프레임 송신 */
static netdev_tx_t my_can_start_xmit(struct sk_buff *skb,
                                       struct net_device *dev)
{
    struct my_can_priv *priv = netdev_priv(dev);
    struct can_frame *cf = (struct can_frame *)skb->data;

    if (can_dropped_invalid_skb(dev, skb))
        return NETDEV_TX_OK;

    netif_stop_queue(dev);

    /* Echo SKB 저장 (루프백용) */
    can_put_echo_skb(skb, dev, 0, 0);

    /* 하드웨어 TX 버퍼에 프레임 기록 */
    /* ... writel(cf->can_id, priv->base + TX_ID_REG) ... */

    return NETDEV_TX_OK;
}

/* TX 완료 인터럽트 핸들러에서 호출 */
static void my_can_tx_done(struct net_device *dev)
{
    dev->stats.tx_bytes += can_get_echo_skb(dev, 0, NULL);
    dev->stats.tx_packets++;
    netif_wake_queue(dev);
}

static const struct net_device_ops my_can_netdev_ops = {
    .ndo_open       = my_can_open,
    .ndo_stop       = my_can_close,
    .ndo_start_xmit = my_can_start_xmit,
    .ndo_change_mtu = can_change_mtu,
};

static int my_can_probe(struct platform_device *pdev)
{
    struct net_device *dev;
    struct my_can_priv *priv;
    int err;

    /* CAN net_device 할당 (echo_skb 1개) */
    dev = alloc_candev(sizeof(struct my_can_priv), 1);
    if (!dev)
        return -ENOMEM;

    priv = netdev_priv(dev);

    /* CAN 속성 설정 */
    priv->can.bittiming_const = &my_bittiming_const;
    priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK |
                                    CAN_CTRLMODE_LISTENONLY |
                                    CAN_CTRLMODE_FD;
    priv->can.clock.freq = clk_get_rate(priv->clk);

    dev->netdev_ops = &my_can_netdev_ops;
    dev->flags |= IFF_ECHO;  /* 로컬 에코 지원 */

    platform_set_drvdata(pdev, dev);

    err = register_candev(dev);
    if (err) {
        free_candev(dev);
        return err;
    }

    netdev_info(dev, "my_can registered (clock=%dHz)\\n",
                priv->can.clock.freq);
    return 0;
}

CAN 인터페이스 설정

# === 기본 설정 ===
$ sudo ip link set can0 type can bitrate 500000
$ sudo ip link set up can0

# === CAN FD 설정 ===
$ sudo ip link set can0 type can bitrate 500000 dbitrate 4000000 fd on

# === 자동 재시작 (Bus-off 복구) ===
$ sudo ip link set can0 type can restart-ms 100

# === 수동 재시작 ===
$ sudo ip link set can0 type can restart

# === 제어 모드 ===
$ sudo ip link set can0 type can loopback on     # 내부 루프백 테스트
$ sudo ip link set can0 type can listen-only on   # 수신만 (ACK 안 함)
$ sudo ip link set can0 type can one-shot on      # 재전송 비활성화
$ sudo ip link set can0 type can berr-reporting on # 버스 에러 보고 활성화

# === 상태 및 통계 확인 ===
$ ip -details -statistics link show can0
3: can0: <NOARP,UP,LOWER_UP,ECHO> mtu 16 qdisc pfifo_fast state UP
    link/can
    can state ERROR-ACTIVE (berr-counter tx 0 rx 0) restart-ms 100
          bitrate 500000 sample-point 0.875
          tq 125 prop-seg 6 phase-seg1 7 phase-seg2 2 sjw 1
          m_can: tseg1 2..256 tseg2 1..128 sjw 1..128 brp 1..512 brp-inc 1
          clock 80000000
          re-started bus-errors arbit-lost error-warn error-pass bus-off
          0          0          0          0          0          0
    RX: bytes  packets  errors  dropped  missed  mcast
    1234       150      0       0        0       0
    TX: bytes  packets  errors  dropped  carrier  collsns
    5678       200      0       0        0        0

CAN 제어 모드

Timestamp와 지연 분석

/* 하드웨어 타임스탬프 활성화 */
struct hwtstamp_config cfg = {
    .tx_type    = HWTSTAMP_TX_ON,
    .rx_filter  = HWTSTAMP_FILTER_ALL,
};
struct ifreq ifr;
strncpy(ifr.ifr_name, "can0", IFNAMSIZ - 1);
ifr.ifr_data = (void *)&cfg;
ioctl(s, SIOCSHWTSTAMP, &ifr);

/* cmsg로 타임스탬프 수신 */
int enable = 1;
setsockopt(s, SOL_SOCKET, SO_TIMESTAMPNS, &enable, sizeof(enable));

struct msghdr msg = { 0 };
struct iovec iov;
char cmsg_buf[256];
struct canfd_frame frame;

iov.iov_base = &frame;
iov.iov_len  = sizeof(frame);
msg.msg_iov     = &iov;
msg.msg_iovlen  = 1;
msg.msg_control    = cmsg_buf;
msg.msg_controllen = sizeof(cmsg_buf);

recvmsg(s, &msg, 0);

/* cmsg에서 타임스탬프 추출 */
struct cmsghdr *cmsg;
for (cmsg = CMSG_FIRSTHDR(&msg); cmsg;
     cmsg = CMSG_NXTHDR(&msg, cmsg)) {
    if (cmsg->cmsg_level == SOL_SOCKET &&
        cmsg->cmsg_type == SO_TIMESTAMPNS) {
        struct timespec *ts = (struct timespec *)CMSG_DATA(cmsg);
        printf("Timestamp: %ld.%09ld\\n", ts->tv_sec, ts->tv_nsec);
    }
}

커널 설정

# CAN bus 서브시스템
CONFIG_CAN=y                      # CAN 프로토콜 패밀리
CONFIG_CAN_RAW=y                  # CAN RAW 프로토콜
CONFIG_CAN_BCM=y                  # CAN Broadcast Manager
CONFIG_CAN_GW=y                   # CAN Gateway (프레임 라우팅)
CONFIG_CAN_ISOTP=m                # ISO-TP (ISO 15765-2)
CONFIG_CAN_J1939=m                # SAE J1939 (상용차)

# 가상 CAN
CONFIG_CAN_VCAN=m                 # Virtual CAN (루프백)
CONFIG_CAN_VXCAN=m                # Virtual CAN 터널 (페어)
CONFIG_CAN_SLCAN=m                # Serial Line CAN

# CAN Device Drivers
CONFIG_CAN_DEV=y                  # CAN 디바이스 공통 프레임워크
CONFIG_CAN_CALC_BITTIMING=y       # 커널 내 비트 타이밍 자동 계산

# SPI CAN 컨트롤러
CONFIG_CAN_MCP251X=m              # Microchip MCP2515/MCP25625
CONFIG_CAN_MCP251XFD=m            # Microchip MCP2517FD/MCP2518FD (FD)

# Platform CAN 컨트롤러
CONFIG_CAN_M_CAN=m                # Bosch M_CAN (FD 지원)
CONFIG_CAN_M_CAN_PLATFORM=m       # M_CAN Platform (SoC 내장)
CONFIG_CAN_M_CAN_TCAN4X5X=m      # TI TCAN4550 SPI CAN FD
CONFIG_CAN_C_CAN=m                # Bosch C_CAN/D_CAN
CONFIG_CAN_FLEXCAN=m              # NXP FlexCAN (i.MX, LS)
CONFIG_CAN_RCAR_CANFD=m           # Renesas R-Car CAN FD

# USB CAN 어댑터
CONFIG_CAN_GS_USB=m               # Geschwister Schneider USB/CAN
CONFIG_CAN_PEAK_USB=m             # PEAK-System PCAN-USB
CONFIG_CAN_KVASER_USB=m           # Kvaser USB
CONFIG_CAN_EMS_USB=m              # EMS CPC-USB/ARM7
CONFIG_CAN_8DEV_USB=m             # 8 Devices USB2CAN

디버깅과 문제 해결

# === 상태 확인 ===
$ ip -details -statistics link show can0

# === 에러 카운터 모니터링 ===
$ watch -n1 "ip -details link show can0 | grep 'berr-counter\\|state'"

# === 에러 프레임 실시간 관찰 ===
$ candump can0,0:0,#FFFFFFFF -e
# 에러 프레임만 필터링하여 표시

# === 버스 부하율 측정 ===
$ canbusload can0@500000 -r 1 -b -c
# can0 @500Kbps, 1초 간격, 바 그래프, 색상

# === CAN 통계 (procfs) ===
$ cat /proc/net/can/stats
        4 transmitted frames (TFF)
       16 received frames (RFF)
        0 matched frames (MFF)
       20 frames/s max (MAXFPS)
        5 current frames/s (CRFPS)

# === 프로토콜 통계 ===
$ cat /proc/net/can/rcvlist_all
$ cat /proc/net/can/rcvlist_fil

# === dmesg CAN 로그 ===
$ dmesg | grep -i can
[  12.345] m_can_platform 40600000.can can0: m_can device registered (irq=52)
[  15.678] can0: bus-off

# === 네트워크 네임스페이스 격리 테스트 ===
$ sudo ip netns add ns_can
$ sudo ip link add vxcan0 type vxcan
$ sudo ip link set vxcan1 netns ns_can
$ sudo ip link set up vxcan0
$ sudo ip netns exec ns_can ip link set up vxcan1
$ sudo ip netns exec ns_can candump vxcan1 &
$ cansend vxcan0 123#DEADBEEF

CAN FD/XL 프레임 구조 심화

CAN FD와 CAN XL은 클래식 CAN의 대역폭 한계를 극복하기 위해 설계된 차세대 프로토콜입니다. CAN FD는 기존 물리 계층을 유지하면서 데이터 영역만 고속 전환(BRS)하여 호환성을 확보했고, CAN XL은 완전히 새로운 프레임 포맷으로 이더넷급 페이로드를 지원합니다.

CAN FD 비트 레벨 구조

CAN FD 프레임은 중재(Arbitration) 영역과 데이터(Data) 영역에서 서로 다른 비트레이트를 사용할 수 있습니다. BRS(Bit Rate Switch) 비트가 recessive이면 데이터 영역이 고속으로 전환됩니다.

CAN XL 상세 구조

CAN XL은 기존 CAN FD와 물리적으로 호환되면서 최대 2048바이트 페이로드와 10 Mbps 데이터 전송을 지원합니다. 가장 큰 차이점은 SDT(SDU Type) 필드로 상위 프로토콜을 식별하고, AF(Acceptance Field) 32비트로 확장된 수신 필터링을 제공하는 것입니다.

/* CAN XL 프레임 상세 필드 (커널 6.3+) */

/* canxl_frame.prio 필드 구조:
 * bits 10-0 : 11-bit 우선순위 (CAN ID와 유사)
 * bit  11   : VCID (Virtual CAN Network ID) 활성화
 * bits 23-12: VCID 값 (가상 네트워크 식별)
 * bit  31   : CANXL_XLF (XL Frame 식별 필수) */

/* SDT(Service Data Unit Type) 사전 정의 값 */
#define CANXL_SDT_CONTENT_BASED  0x01  /* 콘텐츠 기반 라우팅 */
#define CANXL_SDT_TUNNELING      0x03  /* CAN 2.0/FD 터널링 */
#define CANXL_SDT_ETHERNET       0x04  /* 이더넷 프레임 캡슐화 */
#define CANXL_SDT_IEEE802_1AS    0x05  /* 시간 동기화 (gPTP) */

/* CAN XL 소켓 사용 예제 */
int s = socket(PF_CAN, SOCK_RAW, CAN_RAW);

/* XL 프레임 활성화 (CAN FD도 함께 활성화해야 함) */
int enable_fd = 1, enable_xl = 1;
setsockopt(s, SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &enable_fd, sizeof(enable_fd));
setsockopt(s, SOL_CAN_RAW, CAN_RAW_XL_FRAMES, &enable_xl, sizeof(enable_xl));

/* XL 프레임 송신 */
struct canxl_frame xl = {
    .prio  = 0x42 | CANXL_XLF,  /* 우선순위 0x42 + XL 플래그 */
    .flags = 0,
    .sdt   = 0x03,              /* CAN FD 터널링 */
    .len   = 256,               /* 256바이트 데이터 */
    .af    = 0x12345678,        /* Acceptance Field */
};
memset(xl.data, 0xAA, 256);
write(s, &xl, CANXL_HEAD_SZ + xl.len);

/* 수신: MTU로 프레임 유형 구분 */
union {
    struct can_frame   cc;
    struct canfd_frame fd;
    struct canxl_frame xl;
} rxbuf;

ssize_t nbytes = read(s, &rxbuf, sizeof(rxbuf));
if (nbytes == CAN_MTU)
    printf("Classic CAN\\n");
else if (nbytes == CANFD_MTU)
    printf("CAN FD\\n");
else if (nbytes >= CANXL_HEAD_SZ && (rxbuf.xl.prio & CANXL_XLF))
    printf("CAN XL: len=%u sdt=0x%02X af=0x%08X\\n",
           rxbuf.xl.len, rxbuf.xl.sdt, rxbuf.xl.af);

AF_CAN 프로토콜 패밀리 상세

SocketCAN의 핵심은 AF_CAN(= PF_CAN) 프로토콜 패밀리입니다. net/can/af_can.c에서 구현되며, CAN 프레임의 수신 분배(dispatch), 프로토콜 모듈 등록, 수신 필터 관리를 담당합니다.

/* net/can/af_can.c — 핵심 API */

/* 프로토콜 모듈 등록 */
int can_proto_register(const struct can_proto *cp);
void can_proto_unregister(const struct can_proto *cp);

/* 수신 핸들러 등록/해제 */
int can_rx_register(struct net_device *dev, canid_t can_id,
                    canid_t mask, void (*func)(struct sk_buff *, void *),
                    void *data, char *ident, struct sock *sk);
void can_rx_unregister(struct net_device *dev, canid_t can_id,
                      canid_t mask, void (*func)(struct sk_buff *, void *),
                      void *data);

/* CAN 프레임 송신 */
int can_send(struct sk_buff *skb, int loop);

/* can_proto 구조체 — 프로토콜 모듈 정의 */
struct can_proto {
    int type;                              /* SOCK_RAW or SOCK_DGRAM */
    int protocol;                           /* CAN_RAW, CAN_BCM 등 */
    const struct proto_ops *ops;          /* 소켓 연산 */
    struct proto *prot;                    /* 프로토콜 핸들러 */
};

/* 수신 필터 동작 원리:
 * 1. 드라이버가 netif_rx() / can_rx_offload_receive_skb()로 프레임 전달
 * 2. af_can.c의 can_receive()가 호출됨
 * 3. can_rcv_filter()가 등록된 모든 수신 리스트를 순회
 * 4. (received_id & mask) == (registered_id & mask)인 핸들러에 sk_buff 클론 전달
 * 5. 매칭된 각 소켓의 수신 큐에 프레임 삽입 */

sockaddr_can 구조체 상세

에러 핸들링 심화

CAN 프로토콜의 에러 관리는 5가지 에러 검출 메커니즘과 Fault Confinement 상태 머신으로 구성됩니다. 이 절에서는 각 에러 유형의 발생 조건, TEC/REC 카운터 증감 규칙, Bus-Off 복구 전략을 심층 분석합니다.

5가지 에러 검출 메커니즘

TEC/REC 카운터 증감 규칙

/* Bus-Off 자동 복구 설정 */

/* 방법 1: iproute2로 설정 */
/* restart-ms: Bus-Off 후 자동 재시작까지 대기 시간 (밀리초)
 * 0: 자동 재시작 비활성화 (수동 재시작 필요)
 * 100: 100ms 후 자동 재시작 */

/* 방법 2: 커널 드라이버에서 */
static void my_can_bus_off(struct net_device *dev)
{
    struct my_can_priv *priv = netdev_priv(dev);

    netif_stop_queue(dev);
    can_bus_off(dev);  /* CAN 코어에 Bus-Off 보고 */

    /* can_bus_off() 내부 동작:
     * 1. priv->can.state = CAN_STATE_BUS_OFF
     * 2. priv->can.can_stats.bus_off++
     * 3. restart-ms > 0이면 지연 워크큐 스케줄링
     * 4. restart-ms == 0이면 수동 재시작 대기 */
}

/* 커널 내 에러 상태 변경 보고 */
static void my_can_error_handler(struct net_device *dev,
                                  u8 tec, u8 rec)
{
    struct can_frame *cf;
    struct sk_buff *skb;
    enum can_state new_state;

    /* 에러 카운터로 새 상태 결정 */
    if (tec >= 256)
        new_state = CAN_STATE_BUS_OFF;
    else if (tec >= 128 || rec >= 128)
        new_state = CAN_STATE_ERROR_PASSIVE;
    else if (tec >= 96 || rec >= 96)
        new_state = CAN_STATE_ERROR_WARNING;
    else
        new_state = CAN_STATE_ERROR_ACTIVE;

    /* 에러 프레임 생성 및 전송 */
    skb = alloc_can_err_skb(dev, &cf);
    if (skb) {
        cf->can_id |= CAN_ERR_CRTL;
        cf->data[6] = tec;
        cf->data[7] = rec;
        can_change_state(dev, cf, new_state, new_state);
        netif_rx(skb);
    }
}

# 에러 카운터 실시간 모니터링 스크립트
$ while true; do
    ip -details link show can0 | \
      grep -oP '(state \S+|berr-counter tx \d+ rx \d+)' | \
      tr '\n' ' '
    echo "$(date +%T)"
    sleep 0.5
  done

# 출력 예:
# state ERROR-ACTIVE berr-counter tx 0 rx 0 14:23:01
# state ERROR-WARNING berr-counter tx 96 rx 32 14:23:01
# state ERROR-PASSIVE berr-counter tx 128 rx 64 14:23:02
# state BUS-OFF berr-counter tx 256 rx 128 14:23:02

# Bus-Off 수동 재시작
$ sudo ip link set can0 type can restart

# Bus-Off 자동 재시작 설정 (100ms 후)
$ sudo ip link set can0 type can restart-ms 100

비트 타이밍 계산 심화

커널의 비트 타이밍 자동 계산 알고리즘은 drivers/net/can/dev/bittiming.c의 can_calc_bittiming() 함수에서 구현됩니다. 목표 비트레이트와 샘플 포인트에 가장 근접한 BRP/TSEG1/TSEG2 조합을 탐색합니다.

CAN FD 듀얼 비트 타이밍 계산

CAN FD는 Nominal(중재 영역)과 Data(데이터 영역) 두 개의 비트 타이밍을 독립적으로 설정합니다. 두 비트 타이밍은 동일한 CAN 클럭(f_clk)을 공유하되 BRP가 다를 수 있습니다.

# CAN FD 듀얼 비트 타이밍 계산 예제
# f_clk = 80 MHz, Nominal 500K, Data 4M

# Nominal: 500 Kbps, SP = 80%
# BRP = 10, tq = 125 ns, bt = 16 tq
# SYNC=1, PROP+PHASE1=12, PHASE2=3
# SP = (1+12)/16 = 81.25%

# Data: 4 Mbps, SP = 75%
# BRP = 2, tq = 25 ns, bt = 10 tq
# SYNC=1, PROP+PHASE1=6, PHASE2=3
# SP = (1+6)/10 = 70%

$ sudo ip link set can0 type can \
    bitrate 500000 sample-point 0.800 \
    dbitrate 4000000 dsample-point 0.750 \
    fd on

# 결과 확인
$ ip -details link show can0
    can state ERROR-ACTIVE
          bitrate 500000 sample-point 0.812
          tq 125 prop-seg 6 phase-seg1 6 phase-seg2 3 sjw 1
          dbitrate 4000000 dsample-point 0.700
          dtq 25 dprop-seg 3 dphase-seg1 3 dphase-seg2 3 dsjw 1

# TDC (Transmitter Delay Compensation) 설정
# 고속 데이터 비트레이트에서 루프 지연 보상 필요
$ sudo ip link set can0 type can \
    bitrate 500000 dbitrate 5000000 fd on \
    tdcv 0 tdco 7 tdcf 0
# tdcv: TDC 값 (0=자동), tdco: TDC 오프셋, tdcf: TDC 필터

J1939 프로토콜 스택 심화

J1939 커널 구현(net/can/j1939/)은 주소 클레임(Address Claim), 전송 프로토콜(TP: BAM/CMDT), PGN 기반 라우팅, 64-bit NAME 관리를 커널 공간에서 처리합니다.

J1939 64-bit NAME 구조

/* J1939 소켓 상세 사용법 */
#include <linux/can/j1939.h>

/* J1939 NAME 구성 */
__u64 my_name = J1939_NO_NAME;
/* NAME 필드 조합:
 * AAC=1 | IG=1(Highway) | VSI=0 | VS=0 | Func=0(Engine) |
 * FI=0 | EI=0 | Mfr=0x123 | ID=0x456789 */
my_name = (1ULL << 63) |  /* Arbitrary Address Capable */
          (1ULL << 59) |  /* Industry Group = Highway */
          (0x123ULL << 21) |  /* Manufacturer Code */
          0x456789ULL;       /* Identity Number */

/* NAME으로 바인딩 (주소 클레임 자동 수행) */
struct sockaddr_can addr = {
    .can_family = AF_CAN,
    .can_ifindex = ifr.ifr_ifindex,
    .can_addr.j1939 = {
        .name = my_name,
        .addr = 0x80,         /* 원하는 소스 주소 */
        .pgn  = J1939_NO_PGN, /* 모든 PGN 수신 */
    },
};
bind(s, (struct sockaddr *)&addr, sizeof(addr));

/* J1939 소켓 옵션 */
int prio = 3;
setsockopt(s, SOL_CAN_J1939, SO_J1939_SEND_PRIO, &prio, sizeof(prio));

/* J1939 필터 (특정 PGN만 수신) */
struct j1939_filter filt = {
    .name      = J1939_NO_NAME,
    .name_mask = 0,
    .addr      = J1939_NO_ADDR,
    .addr_mask = 0,
    .pgn       = 0xFEF1,       /* CCVS PGN */
    .pgn_mask  = 0x3FFFF,      /* 정확한 PGN 매칭 */
};
setsockopt(s, SOL_CAN_J1939, SO_J1939_FILTER,
          &filt, sizeof(filt));

/* J1939 Transport Protocol (TP) — 큰 데이터 전송
 * 8바이트 초과 시 커널이 자동으로 TP 프로토콜 수행:
 * - 브로드캐스트: BAM(Broadcast Announce Message) + DT 패킷
 * - 점대점: RTS/CTS/EndOfMsgAck 핸드셰이크 + DT 패킷
 * 최대 1785바이트 (255 패킷 x 7바이트) */
uint8_t big_msg[1785];
memset(big_msg, 0xAA, sizeof(big_msg));

struct sockaddr_can dst = {
    .can_family = AF_CAN,
    .can_addr.j1939 = {
        .name = J1939_NO_NAME,
        .addr = 0x00,           /* 특정 대상 주소 */
        .pgn  = 0xEF00,          /* Proprietary A PGN */
    },
};
/* 커널이 RTS/CTS/DT/EndOfMsgAck 자동 수행 */
sendto(s, big_msg, sizeof(big_msg), 0,
       (struct sockaddr *)&dst, sizeof(dst));

J1939 전송 프로토콜 유형

ISO-TP (ISO 15765-2) 전송 프로토콜 심화

ISO-TP는 자동차 진단(UDS/OBD-II)의 핵심 전송 계층입니다. Linux 커널 5.10부터 net/can/isotp.c에 메인라인으로 포함되어, 사용자 공간에서 SOCK_DGRAM 소켓으로 투명하게 분할/재조합을 수행합니다.

ISO-TP 소켓 옵션 상세

/* ISO-TP CAN FD 모드 사용 */
struct can_isotp_ll_options ll_opts = {
    .mtu     = CANFD_MTU,   /* CAN FD 사용 */
    .tx_dl   = 64,           /* TX DLC = 64바이트 */
    .tx_flags = CANFD_BRS,  /* BRS 활성화 */
};
setsockopt(s, SOL_CAN_ISOTP, CAN_ISOTP_LL_OPTS,
          &ll_opts, sizeof(ll_opts));

/* CAN FD + ISO-TP 조합의 이점:
 * - 클래식 CAN: SF 최대 7바이트, CF 최대 7바이트/프레임
 * - CAN FD: SF 최대 62바이트, CF 최대 63바이트/프레임
 * - 4095바이트 전송 시: CAN 2.0은 ~586프레임, CAN FD는 ~66프레임 */

/* 확장 주소 모드 (ISO-TP Extended Addressing) */
struct can_isotp_options opts = {
    .flags = CAN_ISOTP_EXTEND_ADDR | CAN_ISOTP_TX_PADDING,
    .ext_address    = 0x01,  /* TX 확장 주소 */
    .rx_ext_address = 0x02,  /* RX 확장 주소 */
    .txpad_content  = 0xCC,
};
setsockopt(s, SOL_CAN_ISOTP, CAN_ISOTP_OPTS, &opts, sizeof(opts));

/* UDS 진단 예제: DTC 읽기
 * SID 0x19: Read DTC Information
 * SubFunc 0x02: Report DTC By Status Mask
 * Status Mask 0xFF: 모든 DTC */
uint8_t req[] = {0x19, 0x02, 0xFF};
write(s, req, sizeof(req));

uint8_t resp[4096];
ssize_t len = read(s, resp, sizeof(resp));
/* resp[0] == 0x59: 긍정 응답 (SID + 0x40)
 * resp[0] == 0x7F: 부정 응답 (NRC) */
if (resp[0] == 0x59) {
    printf("DTC 응답: %zd 바이트\\n", len);
    /* DTC 파싱: 3바이트 DTC + 1바이트 Status 반복 */
    for (int i = 3; i + 3 < len; i += 4) {
        printf("  DTC: %02X%02X%02X Status: %02X\\n",
               resp[i], resp[i+1], resp[i+2], resp[i+3]);
    }
}

CAN 네트워크 브릿지 (can-gw) 심화

CAN Gateway(net/can/gw.c)는 Netlink 인터페이스(NETLINK_ROUTE)를 통해 커널 내에서 CAN 프레임을 라우팅, 변환, 필터링하는 고성능 프레임 프로세싱 엔진입니다.

# === CAN Gateway 고급 설정 예제 ===

# 1. 조건부 포워딩: can0의 ID 0x100~0x1FF만 can1으로
$ sudo cangw -A -s can0 -d can1 -f 100:700 -e

# 2. ID 변환: can0의 0x123 → can1의 0x456으로 변환
$ sudo cangw -A -s can0 -d can1 -f 123:7FF -m SET:I:456

# 3. 데이터 변환: data[0]을 0xFF로 고정, 나머지 유지
$ sudo cangw -A -s can0 -d can1 -f 200:7FF \
    -m AND:D:00FFFFFFFFFFFFFF \
    -m OR:D:FF00000000000000

# 4. DLC 변경: 4바이트로 자르기
$ sudo cangw -A -s can0 -d can1 -f 300:7FF -m SET:L:4

# 5. XOR8 체크섬 자동 업데이트 (data[7]에 체크섬)
$ sudo cangw -A -s can0 -d can1 -f 400:7FF \
    -m SET:D:AA00000000000000 \
    -x 0:6:7
#   -x from_idx:to_idx:result_idx (XOR8 체크섬)

# 6. CRC8 체크섬 업데이트
$ sudo cangw -A -s can0 -d can1 -f 500:7FF \
    -c 0:6:7:1D:FF:00
#   -c from:to:result:init:poly:xor_out (CRC8)

# 7. 프레임 삭제 (블랙리스트)
# src == dst 로 설정하면 해당 프레임 드롭 효과
$ sudo cangw -A -s can0 -d can0 -f 666:7FF -m SET:D:0000000000000000

# 8. 통계 확인
$ cangw -L
  can0 -> can1: filter=0x100:0x700 mod=none
  can0 -> can1: filter=0x123:0x7FF mod=SET:I:0x456
# ... 전체 규칙 + 전달된 프레임 수 표시

# 9. 규칙 플러시 (전체 삭제)
$ sudo cangw -F

가상 CAN (vcan/vxcan) 심화

가상 CAN 인터페이스는 실제 하드웨어 없이 CAN 애플리케이션을 개발하고 테스트하는 데 필수적입니다. vcan은 로컬 루프백, vxcan은 양방향 터널(veth와 유사)을 제공합니다.

vcan 내부 구현

/* drivers/net/can/vcan.c — 핵심 동작 */

/* vcan의 xmit 함수: 실제 하드웨어 접근 없음 */
static netdev_tx_t vcan_tx(struct sk_buff *skb,
                            struct net_device *dev)
{
    struct canfd_frame *cfd = (struct canfd_frame *)skb->data;
    struct net_device_stats *stats = &dev->stats;
    int loop;

    if (can_dropped_invalid_skb(dev, skb))
        return NETDEV_TX_OK;

    stats->tx_packets++;
    stats->tx_bytes += cfd->len;

    /* 에코/루프백: VCAN_RX_ALL이면 netif_rx_ni()로 수신 큐에 삽입 */
    loop = skb->pkt_type == PACKET_LOOPBACK;
    if (loop) {
        skb->pkt_type = PACKET_BROADCAST;
        netif_rx_ni(skb);  /* 루프백으로 다시 수신 */
        return NETDEV_TX_OK;
    }

    kfree_skb(skb);
    return NETDEV_TX_OK;
}

/* vcan은 CAN/CAN FD/CAN XL 모두 지원
 * MTU 설정:
 * - CAN_MTU (16): Classic CAN만
 * - CANFD_MTU (72): CAN FD 포함
 * - CANXL_MAX_MTU (2080): CAN XL 포함 (6.3+) */

vxcan과 네트워크 네임스페이스 활용

# === 컨테이너/네임스페이스 격리 테스트 환경 ===

# 1. 네임스페이스 생성
$ sudo ip netns add ecu_sim
$ sudo ip netns add tester

# 2. vxcan 페어 생성
$ sudo ip link add vxcan_ecu type vxcan
# vxcan_ecu와 vxcan_ecupeer가 생성됨

# 3. 각 네임스페이스에 할당
$ sudo ip link set vxcan_ecu netns ecu_sim
$ sudo ip link set vxcan_ecupeer netns tester

# 4. 인터페이스 활성화
$ sudo ip netns exec ecu_sim ip link set up vxcan_ecu
$ sudo ip netns exec tester ip link set up vxcan_ecupeer

# 5. ECU 시뮬레이터 (네임스페이스 ecu_sim에서)
$ sudo ip netns exec ecu_sim \
    cangen vxcan_ecu -I 7E8 -L 8 -D i -g 100 &

# 6. 테스터 (네임스페이스 tester에서)
$ sudo ip netns exec tester candump vxcan_ecupeer

# 7. CAN Gateway를 이용한 네임스페이스 간 브리지
# (호스트에서 설정, 두 개의 vxcan 페어를 연결)
$ sudo ip link add vxcan_a type vxcan
$ sudo ip link add vxcan_b type vxcan
$ sudo ip link set up vxcan_a
$ sudo ip link set up vxcan_b
$ sudo ip link set up vxcan_apeer
$ sudo ip link set up vxcan_bpeer
$ sudo cangw -A -s vxcan_apeer -d vxcan_bpeer -e
$ sudo cangw -A -s vxcan_bpeer -d vxcan_apeer -e

# 정리
$ sudo ip netns del ecu_sim
$ sudo ip netns del tester

CAN 드라이버 작성 가이드 심화

CAN 디바이스 드라이버 개발에서 자주 마주치는 패턴들을 정리합니다. RX 처리, 에러 인터럽트 핸들링, NAPI 폴링, 전원 관리(PM), Devres 패턴을 다룹니다.

RX 프레임 처리와 NAPI

/* CAN RX 처리 — 2가지 방식 */

/* 방식 1: 인터럽트에서 직접 수신 (저속/단순 컨트롤러) */
static void my_can_rx_irq(struct net_device *dev)
{
    struct my_can_priv *priv = netdev_priv(dev);
    struct can_frame *cf;
    struct sk_buff *skb;

    skb = alloc_can_skb(dev, &cf);
    if (!skb) {
        dev->stats.rx_dropped++;
        return;
    }

    /* 하드웨어 레지스터에서 프레임 읽기 */
    cf->can_id = readl(priv->base + RX_ID_REG);
    cf->len = can_cc_dlc2len(readl(priv->base + RX_DLC_REG) & 0xF);
    for (int i = 0; i < cf->len; i++)
        cf->data[i] = readb(priv->base + RX_DATA_REG + i);

    dev->stats.rx_packets++;
    dev->stats.rx_bytes += cf->len;

    netif_rx(skb);  /* Softirq 컨텍스트에서 프레임 전달 */
}

/* 방식 2: can_rx_offload (NAPI 기반, 고속 컨트롤러) */
#include <linux/can/rx-offload.h>

static int my_can_probe(struct platform_device *pdev)
{
    struct net_device *dev;
    struct my_can_priv *priv;

    dev = alloc_candev(sizeof(*priv), 1);
    priv = netdev_priv(dev);

    /* NAPI 기반 RX offload 초기화 */
    priv->can.rx_offload.mailbox_read = my_can_mailbox_read;
    can_rx_offload_add_timestamp(dev, &priv->can.rx_offload);
    /* 또는: can_rx_offload_add_fifo(dev, &priv->can.rx_offload, weight); */

    return register_candev(dev);
}

/* mailbox_read 콜백: NAPI 폴링에서 호출 */
static struct sk_buff *my_can_mailbox_read(
    struct can_rx_offload *offload, unsigned int n,
    u32 *timestamp, bool drop)
{
    struct net_device *dev = offload->dev;
    struct can_frame *cf;
    struct sk_buff *skb;

    if (drop) {
        /* 프레임 드롭 요청: 하드웨어 FIFO에서 읽되 버림 */
        readl(priv->base + RX_RELEASE_REG);
        return ERR_PTR(-ENOBUFS);
    }

    skb = alloc_can_skb(dev, &cf);
    if (!skb)
        return ERR_PTR(-ENOMEM);

    /* 하드웨어에서 프레임 + 타임스탬프 읽기 */
    *timestamp = readl(priv->base + RX_TS_REG);
    /* ... 프레임 데이터 복사 ... */

    return skb;
}

전원 관리 (Suspend/Resume)

/* CAN 드라이버 PM 콜백 */
static int my_can_suspend(struct device *dev)
{
    struct net_device *ndev = dev_get_drvdata(dev);
    struct my_can_priv *priv = netdev_priv(ndev);

    if (netif_running(ndev)) {
        netif_stop_queue(ndev);
        netif_device_detach(ndev);

        /* 하드웨어를 절전 모드로 */
        my_can_set_sleep_mode(priv);
        priv->can.state = CAN_STATE_SLEEPING;
    }

    clk_disable_unprepare(priv->clk);
    return 0;
}

static int my_can_resume(struct device *dev)
{
    struct net_device *ndev = dev_get_drvdata(dev);
    struct my_can_priv *priv = netdev_priv(ndev);

    clk_prepare_enable(priv->clk);

    if (netif_running(ndev)) {
        my_can_set_normal_mode(priv);
        priv->can.state = CAN_STATE_ERROR_ACTIVE;

        netif_device_attach(ndev);
        netif_start_queue(ndev);
    }

    return 0;
}

static DEFINE_SIMPLE_DEV_PM_OPS(my_can_pm_ops,
                               my_can_suspend, my_can_resume);

static struct platform_driver my_can_driver = {
    .probe  = my_can_probe,
    .remove = my_can_remove,
    .driver = {
        .name = "my_can",
        .pm   = pm_sleep_ptr(&my_can_pm_ops),
        .of_match_table = my_can_of_match,
    },
};

CAN 드라이버 개발 체크리스트

보안 고려사항

CAN 버스는 원래 폐쇄 네트워크를 가정하고 설계되었기 때문에, 인증/암호화/접근 제어 메커니즘이 프로토콜 자체에 내장되어 있지 않습니다. 커넥티드 카 시대에 이는 심각한 보안 위협이 됩니다.

Linux CAN 보안 조치

# === 1. CAN Gateway로 보안 필터링 ===
# 허용된 CAN ID만 통과 (화이트리스트 방식)
# can0 (외부) → can1 (내부): 특정 ID만 허용
$ sudo cangw -A -s can0 -d can1 -f 100:7FF -e  # 0x100만 허용
$ sudo cangw -A -s can0 -d can1 -f 200:7FF -e  # 0x200만 허용
# 나머지 CAN ID는 자동으로 차단됨

# === 2. SocketCAN 필터로 수신 제한 ===
# 애플리케이션별 필요한 CAN ID만 수신

# === 3. 네트워크 네임스페이스 격리 ===
# vxcan으로 CAN 인터페이스를 네임스페이스별 격리
$ sudo ip netns add secure_zone
$ sudo ip link add vxcan_sec type vxcan
$ sudo ip link set vxcan_secpeer netns secure_zone
# secure_zone 네임스페이스 내 프로세스만 vxcan_secpeer 접근 가능

# === 4. SELinux/AppArmor CAN 소켓 제한 ===
# AppArmor 프로파일 예제:
# /etc/apparmor.d/usr.sbin.can-app
# profile can-app /usr/sbin/can-app {
#   network can raw,
#   network can dgram,
#   # deny network inet,  # 인터넷 접근 차단
# }

# === 5. CAN 버스 이상 탐지 (IDS) ===
# candump 로그를 분석하여 비정상 패턴 탐지
$ candump can0 -l -t d > /var/log/can/bus.log &
# 분석: 비정상적인 CAN ID, 주기 이상, 대량 트래픽 등

AUTOSAR SecOC와 CAN XL 보안

성능 최적화

CAN 버스 시스템의 성능 최적화는 버스 부하율 관리, 메시지 우선순위 설계, 지연시간 최소화, 커널 튜닝에 중점을 둡니다.

버스 부하율 계산

# 버스 부하율 측정
$ canbusload can0@500000 -r 1 -b -c
  can0@500000   988  50113  49420 [|||||||||||         ] 49%

# TX 큐 크기 조정 (고부하 환경)
$ sudo ip link set can0 txqueuelen 1000

# 소켓 수신 버퍼 크기 조정
$ sudo sysctl -w net.core.rmem_max=8388608
$ sudo sysctl -w net.core.rmem_default=1048576

# CAN 프레임 타임스탬프 정밀도 확인
$ candump can0 -t d
  (000.001023) can0 123 [8] DE AD BE EF CA FE BA BE
  (000.001015) can0 124 [8] 11 22 33 44 55 66 77 88
# 프레임 간 ~1ms 간격 확인

참고자료

• Linux SocketCAN Documentation
• can-utils GitHub
• CAN in Automation (CiA) — CAN 표준 관리 기관
• ISO 11898-1:2015 — CAN / CAN FD 데이터 링크 계층
• ISO 15765-2:2016 — ISO-TP 전송 프로토콜
• SAE J1939 — 상용차 CAN 프로토콜
• AUTOSAR SecOC — 차량 보안 통신
• net/can/ — SocketCAN 커널 구현
• net/can/j1939/ — J1939 프로토콜 스택
• net/can/isotp.c — ISO-TP 전송 프로토콜
• net/can/gw.c — CAN Gateway
• drivers/net/can/ — CAN 디바이스 드라이버
• include/uapi/linux/can.h — CAN API 정의
• include/linux/can/dev.h — CAN 드라이버 인터페이스
• include/linux/can/rx-offload.h — RX offload (NAPI)
• Documentation/networking/can.rst — 커널 소스 문서