Scatter/Gather I/O 심화

Scatter/Gather I/O는 물리적으로 비연속적인 메모리 영역을 하나의 논리적 전송 단위로 묶어 DMA 전송, 블록 I/O, 네트워크 패킷 처리, 사용자 공간 벡터 I/O 등 리눅스 커널 전반에서 핵심적으로 활용되는 메커니즘입니다. scatterlist 구조체와 sg_table 관리 API부터 DMA 매핑, IOMMU 통합, 블록 계층 bio_vec, 네트워크 스택 skb_frag_t, NVMe SGL/PRP, readv/writev, splice 제로 카피, Crypto API 연동, 드라이버 구현 패턴, 성능 최적화와 디버깅까지 전 영역을 상세히 다룹니다.

Scatter/Gather 개요

Scatter/Gather I/O(이하 SG I/O)는 물리적으로 연속되지 않은 여러 메모리 영역을 단일 I/O 작업으로 처리하는 기법입니다. "Scatter"는 하나의 데이터 소스를 여러 대상 버퍼에 분산하여 기록하는 것이고, "Gather"는 여러 소스 버퍼의 데이터를 모아 하나의 대상으로 전송하는 것입니다.

왜 Scatter/Gather가 필요한가

운영체제가 오래 실행되면 물리 메모리는 점차 단편화됩니다. 대규모 연속 메모리 할당은 실패할 확률이 높아지므로, 커널은 흩어진 페이지 단위의 메모리를 활용해야 합니다. 만약 SG I/O가 없다면 다음과 같은 비효율이 발생합니다:

SG I/O가 활용되는 커널 하위 시스템

커널 소스 트리 위치

핵심 개념: 비연속 메모리 전송

리눅스 커널에서 물리 메모리는 페이지(일반적으로 4KB) 단위로 관리됩니다. 버디 할당자(buddy allocator)가 연속된 물리 페이지를 반환하지만, 시스템이 오래 실행될수록 고차(high-order) 할당은 점점 어려워집니다. Scatter/Gather는 이 문제를 근본적으로 해결합니다.

물리 메모리 단편화와 SG 전송

64KB 데이터를 디바이스에 전송해야 하는 상황을 가정합니다. 물리 메모리가 단편화되어 16개의 연속 페이지(order-4)를 얻을 수 없다면, 커널은 4KB 페이지 16개를 개별적으로 할당합니다. 이 16개 페이지는 물리 주소가 비연속적이지만, SG 리스트로 묶으면 하드웨어가 한 번의 DMA 작업으로 모두 전송할 수 있습니다.

연속 vs 비연속 메모리 DMA 비교

Gather 방향과 Scatter 방향

용어 사용에 주의가 필요합니다. "Gather"는 여러 소스로부터 데이터를 수집하는 방향이고, "Scatter"는 하나의 소스에서 여러 대상으로 분배하는 방향입니다. DMA에서는 양 방향 모두 같은 scatterlist 구조체를 사용하며, DMA_TO_DEVICE(Gather)와 DMA_FROM_DEVICE(Scatter)로 방향만 구분합니다.

scatterlist 구조체

struct scatterlist은 리눅스 커널에서 SG I/O의 기본 빌딩 블록입니다. 각 엔트리는 하나의 메모리 조각(페이지 + 오프셋 + 길이)을 기술하며, DMA 매핑 후에는 DMA 주소와 DMA 길이 필드가 추가로 설정됩니다.

구조체 정의

/* include/linux/scatterlist.h */
struct scatterlist {
    unsigned long   page_link;    /* 페이지 포인터 + 플래그 (하위 2비트) */
    unsigned int    offset;       /* 페이지 내 시작 오프셋 */
    unsigned int    length;       /* 바이트 단위 데이터 길이 */
    dma_addr_t      dma_address;  /* DMA 매핑 후 디바이스 주소 */
#ifdef CONFIG_NEED_SG_DMA_LENGTH
    unsigned int    dma_length;   /* DMA 매핑 후 길이 (병합 시 length와 다름) */
#endif
#ifdef CONFIG_NEED_SG_DMA_FLAGS
    unsigned int    dma_flags;    /* DMA 플래그 (6.0+) */
#endif
};

page_link 필드의 비트 레이아웃

page_link 필드는 단순 포인터가 아니라, 하위 2비트를 플래그로 활용합니다. struct page는 최소 4바이트 정렬이므로 하위 2비트가 항상 0이라는 점을 이용합니다.

체이닝 메커니즘

커널은 대규모 SG 리스트를 위해 체이닝(chaining)을 지원합니다. 하나의 scatterlist 배열이 가득 차면 마지막 엔트리에 SG_CHAIN 플래그를 설정하고 page_link에 다음 scatterlist 배열의 주소를 저장합니다. 이를 통해 연결 리스트처럼 여러 배열을 이어 붙일 수 있으며, SG_ALLOC_SIZE (기본 PAGE_SIZE) 크기의 배열을 여러 개 연결하여 수천 개의 엔트리를 관리합니다.

핵심 인라인 헬퍼 함수

/* 페이지 포인터 추출 (하위 2비트 마스킹) */
static inline struct page *sg_page(struct scatterlist *sg)
{
    return (struct page *)((sg->page_link) & ~(0x3));
}

/* 페이지 설정 */
static inline void sg_set_page(struct scatterlist *sg,
                               struct page *page,
                               unsigned int len,
                               unsigned int offset)
{
    sg->page_link = (unsigned long)page | (sg->page_link & 0x3);
    sg->offset = offset;
    sg->length = len;
}

/* 커널 가상 주소로 직접 설정 */
static inline void sg_set_buf(struct scatterlist *sg,
                              const void *buf,
                              unsigned int buflen)
{
    sg_set_page(sg, virt_to_page(buf), buflen,
                offset_in_page(buf));
}

/* 가상 주소 변환 */
static inline void *sg_virt(struct scatterlist *sg)
{
    return page_address(sg_page(sg)) + sg->offset;
}

/* DMA 주소 접근 */
#define sg_dma_address(sg)    ((sg)->dma_address)
#define sg_dma_len(sg)        ((sg)->dma_length)

sg_table과 SG 관리 API

struct sg_table은 scatterlist 배열과 관련 메타데이터를 하나로 묶는 컨테이너입니다. 체이닝된 여러 scatterlist 배열을 투명하게 관리하며, DMA 매핑 전후의 엔트리 수를 별도로 추적합니다.

sg_table 구조체

/* include/linux/scatterlist.h */
struct sg_table {
    struct scatterlist *sgl;      /* 첫 번째 scatterlist 엔트리 포인터 */
    unsigned int       nents;     /* 실제 scatterlist 엔트리 수 */
    unsigned int       orig_nents;/* 원래 엔트리 수 (체인 포함하기 전) */
};

SG 관리 API 총정리

SG 테이블 생성 전체 예제

/* 4개 페이지로 구성된 SG 테이블 생성 예제 */
struct sg_table sgt;
struct scatterlist *sg;
struct page *pages[4];
int i, ret;

/* 1. 페이지 할당 */
for (i = 0; i < 4; i++) {
    pages[i] = alloc_page(GFP_KERNEL);
    if (!pages[i])
        goto err_free_pages;
}

/* 2. SG 테이블 할당 (4개 엔트리) */
ret = sg_alloc_table(&sgt, 4, GFP_KERNEL);
if (ret)
    goto err_free_pages;

/* 3. 각 엔트리에 페이지 설정 */
for_each_sgtable_sg(&sgt, sg, i)
    sg_set_page(sg, pages[i], PAGE_SIZE, 0);

/* 4. DMA 매핑 */
ret = dma_map_sgtable(dev, &sgt, DMA_TO_DEVICE, 0);
if (ret)
    goto err_free_sgt;

/* 5. DMA 전송 수행... */
for_each_sgtable_dma_sg(&sgt, sg, i) {
    dma_addr_t addr = sg_dma_address(sg);
    unsigned int len = sg_dma_len(sg);
    /* 디바이스 디스크립터에 addr, len 설정 */
    setup_dma_descriptor(desc++, addr, len);
}

/* 6. 정리 */
dma_unmap_sgtable(dev, &sgt, DMA_TO_DEVICE, 0);
err_free_sgt:
sg_free_table(&sgt);
err_free_pages:
for (i = 0; i < 4; i++)
    if (pages[i])
        __free_page(pages[i]);

sg_alloc_table_from_pages 활용

/* 페이지 배열로부터 최적화된 SG 테이블 생성 */
struct sg_table sgt;
struct page **pages;
int num_pages = 256;  /* 1MB (256 x 4KB) */
int ret;

pages = kvmalloc_array(num_pages, sizeof(*pages), GFP_KERNEL);
if (!pages)
    return -ENOMEM;

/* 페이지 할당 (예: pin_user_pages 등) */
for (int i = 0; i < num_pages; i++)
    pages[i] = alloc_page(GFP_KERNEL);

/* 인접한 물리 페이지를 자동으로 병합하여 SG 엔트리 최소화 */
ret = sg_alloc_table_from_pages(&sgt, pages, num_pages,
                                0,           /* 시작 오프셋 */
                                (size_t)num_pages << PAGE_SHIFT,
                                GFP_KERNEL);
if (ret) {
    pr_err("SG table alloc failed: %d\n", ret);
    goto err;
}

/* 결과: 256 페이지가 물리적으로 연속이면 엔트리 1개,
   완전히 분산되면 최대 256개 엔트리 */
pr_info("orig_nents=%u (최대 %d에서 병합)\n",
        sgt.orig_nents, num_pages);

SG 리스트 순회

scatterlist 순회에는 여러 매크로가 제공됩니다. 커널 5.x 이후에는 for_each_sgtable_* 계열을 권장하며, 이전의 for_each_sg()도 여전히 사용 가능합니다.

순회 매크로 비교

순회 매크로 내부 구현

/* for_each_sg: 기본 순회 매크로 */
#define for_each_sg(sglist, sg, nr, __i)   \
    for (__i = 0, sg = (sglist); __i < (nr); __i++, sg = sg_next(sg))

/* sg_next: 체이닝을 투명하게 처리하는 다음 엔트리 반환 */
static inline struct scatterlist *sg_next(struct scatterlist *sg)
{
    if (sg_is_last(sg))
        return NULL;

    sg++;

    if (sg_is_chain(sg))
        sg = sg_chain_ptr(sg);  /* 체인 포인터 따라감 */

    return sg;
}

/* sg_table 전용 매크로 (권장) */
#define for_each_sgtable_sg(sgt, sg, i) \
    for_each_sg((sgt)->sgl, sg, (sgt)->orig_nents, i)

#define for_each_sgtable_dma_sg(sgt, sg, i) \
    for_each_sg((sgt)->sgl, sg, (sgt)->nents, i)

실전 순회 패턴: 디바이스 디스크립터 설정

/* DMA 매핑 후 디바이스 디스크립터 링에 SG 엔트리 기록 */
struct scatterlist *sg;
struct my_dma_desc *desc;
int i, nents;

nents = dma_map_sgtable(dev, &sgt, DMA_TO_DEVICE, 0);
if (nents < 0)
    return nents;

desc = ring->next_free;
for_each_sgtable_dma_sg(&sgt, sg, i) {
    desc->dma_addr = sg_dma_address(sg);
    desc->dma_len  = sg_dma_len(sg);
    desc->flags    = (i == sgt.nents - 1) ? DESC_LAST : 0;
    desc = next_desc(ring, desc);
}

/* 디바이스에 전송 시작 알림 */
writel(sgt.nents, dev->regs + DOORBELL_REG);

DMA SG 매핑

DMA SG 매핑은 CPU가 보는 물리 주소를 디바이스가 접근 가능한 DMA 버스 주소로 변환하는 과정입니다. IOMMU 유무에 따라 매핑 결과가 크게 달라지며, IOMMU가 있으면 비연속 물리 페이지를 연속된 DMA 주소 공간으로 병합할 수 있습니다.

DMA SG 매핑 API

DMA 방향 플래그

dma_map_sgtable 내부 동작

/* kernel/dma/mapping.c (간략화) */
int dma_map_sgtable(struct device *dev, struct sg_table *sgt,
                    enum dma_data_direction dir,
                    unsigned long attrs)
{
    int nents;

    /* 백엔드별 매핑 수행 (직접/IOMMU/SWIOTLB) */
    nents = dma_map_sg_attrs(dev, sgt->sgl,
                              sgt->orig_nents, dir, attrs);
    if (nents < 0)
        return nents;
    if (nents == 0)
        return -EIO;

    sgt->nents = nents;  /* DMA 세그먼트 수 저장 */
    return 0;
}

IOMMU와 SG 통합

IOMMU(Input/Output Memory Management Unit)는 디바이스의 DMA 주소를 물리 주소로 변환하는 하드웨어입니다. SG I/O에서 IOMMU의 가장 중요한 역할은 세그먼트 병합(coalescing)입니다. 물리적으로 비연속인 여러 페이지를 IOMMU 페이지 테이블에서 연속 IOVA(I/O Virtual Address)로 매핑하면, 디바이스는 하나의 연속된 DMA 주소 범위로 인식합니다.

IOMMU SG 병합 원리

IOMMU 백엔드별 특성

SWIOTLB 바운스 버퍼와 SG

IOMMU가 없고 디바이스의 DMA 주소 마스크가 물리 메모리보다 작은 경우(예: 32비트 디바이스가 4GB 이상 메모리에 접근), SWIOTLB(Software I/O TLB)가 바운스 버퍼를 사용합니다. 이 경우 SG 엔트리마다 별도의 바운스 버퍼가 필요하며, 병합이 일어나지 않습니다. CPU가 데이터를 바운스 버퍼로 복사하므로 제로 카피 이점이 사라집니다.

블록 I/O에서의 Scatter/Gather

블록 계층은 struct bio와 struct bio_vec를 사용하여 디스크 I/O 요청을 구성합니다. bio_vec는 본질적으로 scatterlist와 동일한 역할을 하며, 하나의 bio는 여러 비연속 페이지에 걸친 I/O 요청을 표현합니다.

bio_vec 구조체

/* include/linux/bvec.h */
struct bio_vec {
    struct page  *bv_page;    /* 페이지 포인터 */
    unsigned int  bv_len;     /* 바이트 길이 */
    unsigned int  bv_offset;  /* 페이지 내 오프셋 */
};

/* scatterlist와 대응 관계:
 * bio_vec.bv_page   ↔ scatterlist.page_link (sg_page)
 * bio_vec.bv_len    ↔ scatterlist.length
 * bio_vec.bv_offset ↔ scatterlist.offset
 */

bio 구조체의 SG 특성

/* include/linux/bio.h (핵심 필드만) */
struct bio {
    struct block_device  *bi_bdev;     /* 대상 블록 디바이스 */
    sector_t             bi_iter.bi_sector; /* 시작 섹터 */
    unsigned short       bi_vcnt;      /* bio_vec 배열 엔트리 수 */
    unsigned short       bi_max_vecs;  /* bio_vec 배열 최대 크기 */
    struct bio_vec      *bi_io_vec;    /* bio_vec 배열 포인터 */
    /* ... */
};

blk_rq_map_sg 변환 과정

/* 블록 드라이버에서 request → scatterlist 변환 */
static int my_blk_queue_rq(struct blk_mq_hw_ctx *hctx,
                            const struct blk_mq_queue_data *bd)
{
    struct request *rq = bd->rq;
    struct scatterlist sglist[MAX_SG_ENTRIES];
    int nents;

    sg_init_table(sglist, MAX_SG_ENTRIES);

    /* bio_vec → scatterlist 변환 + 인접 세그먼트 병합 */
    nents = blk_rq_map_sg(rq->q, rq, sglist);

    /* DMA 매핑 */
    nents = dma_map_sg(dev, sglist, nents, rq_dma_dir(rq));
    if (!nents)
        return BLK_STS_RESOURCE;

    /* 디바이스 전송... */
    return BLK_STS_OK;
}

블록 디바이스 SG 제한 파라미터

네트워크 스택의 Scatter/Gather

네트워크 스택은 struct sk_buff의 paged data 영역에서 SG를 활용합니다. skb_frag_t는 패킷의 비선형(non-linear) 데이터를 기술하며, NETIF_F_SG 피처를 지원하는 NIC은 이 조각들을 하드웨어 레벨에서 직접 처리합니다.

skb_frag_t 구조체

/* include/linux/skbuff.h */
typedef struct skb_frag {
    struct {
        struct page *p;       /* 페이지 포인터 */
    } bv_page;
    __u32 bv_len;              /* 조각 길이 */
    __u32 bv_offset;           /* 페이지 내 오프셋 */
} skb_frag_t;

/* sk_buff의 paged data:
 * skb->data_len   = sum of all frag lengths
 * skb->nr_frags   = 실제 사용 중인 frag 수
 * skb_shinfo(skb)->frags[0..nr_frags-1] = skb_frag_t 배열
 */

네트워크 SG 관련 피처 플래그

네트워크 드라이버 SG 송신 코드 패턴

/* NIC 드라이버 ndo_start_xmit 핵심 SG 처리 */
static netdev_tx_t my_nic_xmit(struct sk_buff *skb,
                                struct net_device *ndev)
{
    struct my_tx_ring *ring = &priv->tx_ring;
    int nr_frags = skb_shinfo(skb)->nr_frags;
    int i;

    /* 1. linear 데이터 (헤더) 매핑 */
    ring->desc[ring->head].addr =
        dma_map_single(dev, skb->data, skb_headlen(skb),
                       DMA_TO_DEVICE);
    ring->desc[ring->head].len = skb_headlen(skb);
    ring->head = (ring->head + 1) % RING_SIZE;

    /* 2. paged frag 매핑 (SG) */
    for (i = 0; i < nr_frags; i++) {
        const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];

        ring->desc[ring->head].addr =
            skb_frag_dma_map(dev, frag, 0,
                             skb_frag_size(frag),
                             DMA_TO_DEVICE);
        ring->desc[ring->head].len = skb_frag_size(frag);
        ring->desc[ring->head].flags =
            (i == nr_frags - 1) ? TX_DESC_EOP : 0;
        ring->head = (ring->head + 1) % RING_SIZE;
    }

    /* 3. 도어벨: 하드웨어에 전송 알림 */
    writel(ring->head, priv->regs + TX_DOORBELL);
    return NETDEV_TX_OK;
}

NVMe SGL과 PRP

NVMe 프로토콜은 호스트와 컨트롤러 간 데이터 전송을 위해 두 가지 주소 지정 방식을 정의합니다: PRP(Physical Region Page)와 SGL(Scatter Gather List). PRP는 NVMe 1.0부터 지원되는 기본 방식이고, SGL은 NVMe 1.1에서 추가된 보다 유연한 방식입니다.

PRP vs SGL 비교

NVMe SGL 디스크립터 구조

/* include/linux/nvme.h */
struct nvme_sgl_desc {
    __le64  addr;     /* 데이터 또는 세그먼트 주소 */
    __le32  length;   /* 바이트 길이 */
    __u8    rsvd[3];
    __u8    type;     /* SGL 디스크립터 타입 */
};

/* SGL 디스크립터 타입 */
#define NVME_SGL_FMT_DATA_DESC      0x00  /* 데이터 블록 */
#define NVME_SGL_FMT_SEG_DESC       0x02  /* SGL 세그먼트 (체이닝) */
#define NVME_SGL_FMT_LAST_SEG_DESC  0x03  /* 마지막 세그먼트 */

/* PRP 엔트리 (비교용) */
struct nvme_prp_entry {
    __le64  prp;  /* 물리 주소 (8바이트) */
};

scatterlist에서 PRP/SGL 변환

/* drivers/nvme/host/pci.c (간략화) */
static blk_status_t nvme_map_data(struct nvme_dev *dev,
                                     struct request *req,
                                     struct nvme_command *cmnd)
{
    struct nvme_iod *iod = blk_mq_rq_to_pdu(req);
    int nr_mapped;

    /* bio_vec → scatterlist 변환 */
    iod->sg = mempool_alloc(dev->iod_mempool, GFP_ATOMIC);
    sg_init_table(iod->sg, blk_rq_nr_phys_segments(req));
    iod->nents = blk_rq_map_sg(req->q, req, iod->sg);

    /* DMA 매핑 */
    nr_mapped = dma_map_sg_attrs(dev->dev, iod->sg,
                                  iod->nents, rq_dma_dir(req),
                                  DMA_ATTR_NO_WARN);

    /* 컨트롤러 능력에 따라 PRP 또는 SGL 선택 */
    if (nvme_pci_use_sgls(dev, req, nr_mapped))
        return nvme_pci_setup_sgls(dev, req, cmnd, nr_mapped);
    else
        return nvme_pci_setup_prps(dev, req, cmnd);
}

readv/writev와 사용자 공간 SG

사용자 공간에서도 Scatter/Gather I/O를 직접 활용할 수 있습니다. readv()/writev() 시스템 콜은 struct iovec 배열을 통해 비연속 버퍼에 대한 벡터 I/O를 수행합니다. 커널 내부에서는 struct iov_iter로 다양한 벡터 타입(iovec, bvec, kvec, pipe, xarray)을 통합하여 처리합니다.

iovec 구조체

/* include/uapi/linux/uio.h */
struct iovec {
    void __user *iov_base;  /* 사용자 공간 버퍼 시작 주소 */
    __kernel_size_t iov_len;/* 버퍼 길이 */
};

/* 사용자 공간 사용 예:
 * struct iovec iov[3];
 * iov[0] = { .iov_base = header_buf, .iov_len = 64 };
 * iov[1] = { .iov_base = data_buf,   .iov_len = 4096 };
 * iov[2] = { .iov_base = footer_buf, .iov_len = 32 };
 * writev(fd, iov, 3);
 */

iov_iter 구조체 (커널 내부 통합 순회자)

/* include/linux/uio.h */
struct iov_iter {
    u8             iter_type;   /* ITER_IOVEC, ITER_BVEC, ITER_KVEC, ... */
    bool           nofault;     /* 페이지 폴트 허용 여부 */
    bool           data_source; /* 0=읽기(from iter), 1=쓰기(to iter) */
    size_t         iov_offset;  /* 현재 iov 내 소비된 바이트 */
    size_t         count;       /* 남은 총 바이트 수 */
    union {
        const struct iovec  *__iov;  /* 사용자 공간 벡터 */
        const struct kvec   *kvec;   /* 커널 공간 벡터 */
        const struct bio_vec *bvec;   /* 페이지 벡터 */
        struct xarray        *xarray; /* XArray 기반 */
        void __user          *ubuf;   /* 단일 사용자 버퍼 */
    };
    union {
        unsigned long  nr_segs;    /* 세그먼트 수 */
    };
};

iov_iter 타입별 사용 문맥

사용자 공간 벡터 I/O 예제

/* 사용자 공간에서 writev() 활용 예제 */
#include <sys/uio.h>

struct iovec iov[3];
char header[] = "HTTP/1.1 200 OK\r\nContent-Length: 4096\r\n\r\n";
char body[4096];
char footer[] = "\r\n--END--\r\n";

/* 3개의 비연속 버퍼를 하나의 write로 전송 */
iov[0].iov_base = header;
iov[0].iov_len  = sizeof(header) - 1;
iov[1].iov_base = body;
iov[1].iov_len  = sizeof(body);
iov[2].iov_base = footer;
iov[2].iov_len  = sizeof(footer) - 1;

ssize_t n = writev(sockfd, iov, 3);
/* 커널은 3개 iovec을 iov_iter로 변환하여 소켓 계층에 전달
 * TCP는 SG를 활용하여 복사 없이 skb frag로 매핑 가능 */

splice와 제로 카피

splice() 시스템 콜은 파이프를 매개체로 사용하여 두 파일 디스크립터 사이에서 데이터를 전송합니다. 핵심은 실제 데이터 복사 없이 페이지 참조만 이동시키는 제로 카피(zero-copy) 방식입니다. 이는 본질적으로 Scatter/Gather 개념의 사용자 공간 확장입니다.

제로 카피 시스템 콜 비교

splice 구현 핵심 경로

/* fs/splice.c (간략화) — sendfile → splice 내부 경로 */

/* 파일 → 파이프: 페이지 캐시 참조를 파이프 버퍼에 삽입 */
static ssize_t splice_read(struct file *in,
                           struct pipe_inode_info *pipe, ...)
{
    /* 페이지 캐시에서 페이지 참조 획득 */
    struct page *page = find_get_page(mapping, index);

    /* 파이프 버퍼에 페이지 참조 저장 (복사 없음) */
    buf->page = page;
    buf->offset = offset;
    buf->len = len;
    buf->ops = &page_cache_pipe_buf_ops;
    pipe->nrbufs++;
}

/* 파이프 → 소켓: 파이프 버퍼의 페이지를 skb frag로 매핑 */
static ssize_t splice_to_socket(struct pipe_inode_info *pipe,
                                struct socket *sock, ...)
{
    /* 파이프 버퍼의 페이지를 skb의 paged frag로 전달 */
    skb_fill_page_desc(skb, frag_idx,
                       buf->page, buf->offset, buf->len);
    /* NIC이 NETIF_F_SG 지원 시 이 페이지를 직접 DMA 전송 */
}

Crypto API의 SG 활용

리눅스 Crypto API는 암호화, 해시, 압축 등의 입출력 버퍼로 scatterlist를 직접 사용합니다. 이를 통해 비연속 메모리에 분산된 데이터를 한 번의 암호화 작업으로 처리할 수 있습니다. 특히 네트워크(IPSec, kTLS)와 스토리지(dm-crypt) 암호화에서 SG는 필수적입니다.

Crypto API의 SG 사용 패턴

SG 기반 대칭 암호화 예제

/* scatterlist를 활용한 AES-GCM 암호화 예제 */
struct crypto_aead *tfm;
struct aead_request *req;
struct scatterlist sg_src[3], sg_dst[3];
u8 *aad, *plaintext, *tag;
u8 iv[12];

/* 1. 변환 할당 */
tfm = crypto_alloc_aead("gcm(aes)", 0, 0);
crypto_aead_setkey(tfm, key, key_len);
crypto_aead_setauthsize(tfm, 16);  /* 128비트 태그 */

/* 2. SG 설정: AAD + 평문 + 태그 공간 */
sg_init_table(sg_src, 3);
sg_set_buf(&sg_src[0], aad, aad_len);        /* AAD */
sg_set_buf(&sg_src[1], plaintext, pt_len);   /* 평문 */
sg_set_buf(&sg_src[2], tag, 16);             /* 태그 출력 공간 */

sg_init_table(sg_dst, 3);
sg_set_buf(&sg_dst[0], aad, aad_len);
sg_set_buf(&sg_dst[1], ciphertext, pt_len);  /* 암호문 출력 */
sg_set_buf(&sg_dst[2], tag, 16);

/* 3. 요청 설정 및 암호화 */
req = aead_request_alloc(tfm, GFP_KERNEL);
aead_request_set_crypt(req, sg_src, sg_dst, pt_len, iv);
aead_request_set_ad(req, aad_len);

int ret = crypto_aead_encrypt(req);
/* ret == 0: 성공, 암호문과 태그가 sg_dst에 기록됨
 * ret == -EINPROGRESS: 비동기 처리 중 (하드웨어 가속) */

SG 유틸리티 함수

디바이스 드라이버 SG 구현 패턴

디바이스 드라이버에서 SG I/O를 구현할 때는 일관된 패턴을 따라야 합니다. DMA 디스크립터 링과 SG 리스트의 연동, 오류 처리, 매핑 해제 순서 등을 정확히 지켜야 메모리 누수와 데이터 손상을 방지할 수 있습니다.

완전한 DMA SG 드라이버 패턴

/* 범용 DMA SG 전송 함수 패턴 */
struct my_sg_request {
    struct sg_table       sgt;
    struct my_dma_desc   *first_desc;
    int                   desc_count;
    enum dma_data_direction dir;
    void                 (*callback)(void *data);
    void                 *cb_data;
};

static int my_submit_sg_transfer(struct device *dev,
                                  struct my_sg_request *sgr,
                                  struct page **pages,
                                  int num_pages,
                                  enum dma_data_direction dir)
{
    struct scatterlist *sg;
    struct my_dma_desc *desc;
    int i, ret;

    /* 1. SG 테이블 할당 */
    ret = sg_alloc_table_from_pages(&sgr->sgt, pages, num_pages,
                                    0, (size_t)num_pages << PAGE_SHIFT,
                                    GFP_KERNEL);
    if (ret)
        return ret;

    /* 2. DMA 매핑 */
    ret = dma_map_sgtable(dev, &sgr->sgt, dir, 0);
    if (ret)
        goto err_free_sgt;

    /* 3. DMA 디스크립터 설정 */
    sgr->desc_count = 0;
    sgr->dir = dir;
    desc = alloc_dma_descs(dev, sgr->sgt.nents);
    if (!desc) {
        ret = -ENOMEM;
        goto err_unmap;
    }
    sgr->first_desc = desc;

    for_each_sgtable_dma_sg(&sgr->sgt, sg, i) {
        desc[i].src_addr = sg_dma_address(sg);
        desc[i].length   = sg_dma_len(sg);
        desc[i].next     = (i < sgr->sgt.nents - 1)
                           ? &desc[i + 1] : NULL;
        desc[i].flags    = (i == sgr->sgt.nents - 1)
                           ? DESC_IRQ | DESC_LAST : 0;
        sgr->desc_count++;
    }

    /* 4. 하드웨어에 전송 시작 */
    writel(desc_dma_addr(sgr->first_desc),
           priv->regs + DMA_DESC_ADDR_REG);
    writel(DMA_START, priv->regs + DMA_CTRL_REG);

    return 0;

err_unmap:
    dma_unmap_sgtable(dev, &sgr->sgt, dir, 0);
err_free_sgt:
    sg_free_table(&sgr->sgt);
    return ret;
}

/* DMA 완료 인터럽트 핸들러 */
static irqreturn_t my_dma_irq(int irq, void *data)
{
    struct my_sg_request *sgr = data;

    /* CPU에서 데이터 읽기 전 동기화 (DMA_FROM_DEVICE) */
    if (sgr->dir == DMA_FROM_DEVICE)
        dma_sync_sgtable_for_cpu(dev, &sgr->sgt, sgr->dir);

    /* 콜백 호출 */
    if (sgr->callback)
        sgr->callback(sgr->cb_data);

    /* 정리: 반드시 unmap → free 순서 */
    dma_unmap_sgtable(dev, &sgr->sgt, sgr->dir, 0);
    sg_free_table(&sgr->sgt);
    free_dma_descs(dev, sgr->first_desc, sgr->desc_count);

    return IRQ_HANDLED;
}

흔한 SG 드라이버 버그와 해결책

성능 최적화와 튜닝

Scatter/Gather I/O의 성능은 SG 엔트리 수, 세그먼트 크기, IOMMU 매핑 오버헤드, 디바이스 하드웨어 능력 등 여러 요소에 의해 결정됩니다. 적절한 튜닝으로 처리량을 크게 향상시킬 수 있습니다.

SG 세그먼트 병합 최적화

SG 처리 성능 벤치마크 참고 데이터

IOMMU 성능 영향

IOMMU는 SG 병합이라는 큰 이점을 제공하지만, 페이지 테이블 관리와 IOTLB 미스로 인한 오버헤드도 존재합니다. 다음은 IOMMU 관련 성능 튜닝 옵션입니다:

블록 장치 SG 파라미터 확인 및 튜닝

/* sysfs를 통한 블록 디바이스 SG 파라미터 확인 */
$ cat /sys/block/nvme0n1/queue/max_segments
128

$ cat /sys/block/nvme0n1/queue/max_segment_size
65536

$ cat /sys/block/nvme0n1/queue/max_hw_sectors_kb
512

/* IOMMU 그룹 확인 */
$ ls /sys/kernel/iommu_groups/
0  1  2  3  ...

/* 특정 디바이스의 IOMMU 그룹 */
$ readlink /sys/bus/pci/devices/0000:03:00.0/iommu_group
../../kernel/iommu_groups/15

/* DMA 매핑 통계 (DMA_API_DEBUG 활성 시) */
$ cat /sys/kernel/debug/dma-api/driver_filter
$ cat /sys/kernel/debug/dma-api/num_errors

디버깅과 트러블슈팅

SG I/O 관련 버그는 데이터 손상, DMA 매핑 누수, IOMMU 폴트 등 심각한 문제를 유발합니다. 커널은 이를 진단하기 위한 다양한 디버깅 도구를 제공합니다.

DMA-debug 프레임워크

CONFIG_DMA_API_DEBUG를 활성화하면 커널이 모든 DMA 매핑/해제 작업을 추적하고 다음과 같은 오류를 자동으로 감지합니다:

ftrace를 활용한 DMA SG 추적

# DMA 매핑 이벤트 추적 활성화
$ echo 1 > /sys/kernel/debug/tracing/events/dma/enable

# SG 매핑 이벤트만 필터링
$ echo 1 > /sys/kernel/debug/tracing/events/dma/map_sg/enable

# 추적 로그 확인
$ cat /sys/kernel/debug/tracing/trace

# 출력 예시:
#  kworker/0:1-123  [000] .... 1234.567: map_sg: nvme0n1 
#    nents=32 mapped=4 dir=DMA_TO_DEVICE
#    sg[0]: dma=0xfffe0000 len=32768
#    sg[1]: dma=0xffff0000 len=32768
#    sg[2]: dma=0x100000000 len=32768
#    sg[3]: dma=0x100010000 len=32768

IOMMU 폴트 디버깅

# IOMMU 폴트 메시지 (dmesg)
# DMAR: [DMA Read] Request device [03:00.0] PASID ffffffff
#   fault addr 7f800000 [fault reason 06] PTE Read access is not set

# IOMMU 디버깅 활성화
$ echo 1 > /sys/kernel/debug/iommu/intel/dmar_perf

# IOMMU 매핑 덤프
$ cat /sys/kernel/debug/iommu/intel/dmar0/domain_translation_struct

# IOMMU 통계
$ cat /sys/kernel/debug/iommu/intel/ir_translation_struct

SG 관련 커널 경고 메시지 해석

커널 설정

Scatter/Gather I/O와 관련된 커널 설정 옵션들입니다. 올바른 설정이 성능과 안정성에 직접적인 영향을 미칩니다.

필수/권장 커널 설정

부팅 파라미터

참고자료

커널 공식 문서

• DMA API Guide (kernel.org) -- DMA 매핑 API 공식 문서
• DMA API HOWTO (kernel.org) -- DMA 매핑 실전 가이드
• DMA-BUF (kernel.org) -- DMA 버퍼 공유 프레임워크
• Block Layer Documentation (kernel.org) -- 블록 I/O 계층 문서
• Crypto API (kernel.org) -- 커널 암호화 프레임워크

커널 소스 코드

• include/linux/scatterlist.h -- scatterlist, sg_table 정의
• lib/scatterlist.c -- SG 관리 함수 구현
• include/linux/dma-mapping.h -- DMA 매핑 API 헤더
• kernel/dma/mapping.c -- DMA 매핑 코어
• kernel/dma/direct.c -- 직접 DMA 매핑 (IOMMU 없음)
• kernel/dma/swiotlb.c -- SWIOTLB 바운스 버퍼
• drivers/iommu/ -- IOMMU 프레임워크 및 드라이버
• include/linux/bio.h -- bio, bio_vec 정의
• include/linux/skbuff.h -- sk_buff, skb_frag_t 정의
• drivers/nvme/host/pci.c -- NVMe PCI 드라이버 (SG/PRP/SGL 변환)
• fs/splice.c -- splice, sendfile 구현
• lib/iov_iter.c -- iov_iter 순회 구현

규격 및 표준

• NVMe Base Specification -- NVMe SGL/PRP 상세 규격
• Intel VT-d Specification -- Intel IOMMU DMA 리매핑 규격
• AMD I/O Virtualization Technology (IOMMU) Specification

관련 문서 (이 사이트)

• DMA (Direct Memory Access) -- DMA 기초 및 전체 API
• Block I/O -- 블록 계층 아키텍처
• sk_buff -- 네트워크 버퍼 관리
• NVMe -- NVMe 드라이버 상세
• io_uring -- 비동기 I/O 프레임워크
• GSO/GRO -- 네트워크 오프로드
• IOMMU -- IOMMU 프레임워크
• Crypto API -- 커널 암호화 프레임워크
• Direct I/O & Buffered I/O -- 파일 I/O 경로
• DMA Engine -- 소프트웨어 DMA 엔진