GNU Binutils 완전 가이드

커널 및 모듈 분석에서 Binutils를 어떻게 조합해 쓰는지 실전 흐름으로 정리합니다. `readelf`/`objdump`로 ELF 구조와 디스어셈블 확인, `nm`/`addr2line`로 심볼 역추적, `objcopy`/`strip`으로 배포용 바이너리 가공, `ar`/`ranlib`로 정적 라이브러리 관리, `elfedit`로 헤더 조정까지 디버깅·성능 분석·릴리스 준비 단계에서 필요한 절차를 상세히 설명합니다.

개요 및 도구 목록

GNU Binutils(GNU Binary Utilities)는 오브젝트 파일과 실행 파일을 생성·분석·변환하는 명령행 도구 모음입니다. 버전 2.46(2026년 2월)을 기준으로 하며, 리눅스 커널 빌드, 크로스 컴파일, 펌웨어 개발, 역공학 분석 모두에 필수적입니다.

ELF 파일 구조

Binutils 전체 도구가 다루는 핵심 파일 형식인 ELF(Executable and Linkable Format)의 내부 구조를 이해하면 각 도구의 동작 원리를 훨씬 명확히 파악할 수 있습니다. ELF 파일 형식의 심화 내용은 ELF 파일 형식 페이지를 참고하세요.

도구 선택 매트릭스

작업 목적에 따라 최적의 Binutils 도구를 선택하는 기준표입니다.

ar — 아카이브 관리

ar은 여러 오브젝트 파일을 하나의 아카이브(정적 라이브러리, .a)로 묶거나 추출합니다. 정적 라이브러리는 링크 시 링커가 필요한 오브젝트만 선택해 실행 파일에 포함시킵니다.

기본 문법

ar [-]키[플래그] [relpos] [count] 아카이브 [멤버…]

키(operation)는 반드시 하나를 지정합니다:

플래그(modifier)는 여러 개를 조합할 수 있습니다:

자주 쓰는 예제

# 정적 라이브러리 생성 (c: 경고 없이 생성, r: 삽입, s: 심볼 인덱스)
ar crs libfoo.a foo.o bar.o baz.o

# 멤버 목록 출력
ar t libfoo.a

# 특정 멤버 추출
ar x libfoo.a bar.o

# 결정론적 모드로 재생성 (빌드 재현성 보장)
ar crsD libfoo.a *.o

# Thin 아카이브 (커널 빌드에서 빌드 속도 향상 목적으로 사용)
ar crsT libkernel.a built-in.o

# 특정 멤버 삭제
ar d libfoo.a old.o

# 멤버 내용 보기 (표준 출력)
ar p libfoo.a foo.o | less

nm — 심볼 테이블 분석

nm은 오브젝트 파일, 정적 라이브러리, 실행 파일의 심볼 테이블을 출력합니다. 링크 오류 디버깅, 심볼 충돌 분석, 커널 모듈 심볼 확인에 필수적입니다.

출력 형식

# 기본 출력: 값(value)  타입(type)  이름(name)
$ nm vmlinux | head
ffffffff81000000 T startup_64
ffffffff81000060 T secondary_startup_64
ffffffff81001000 T do_early_param
0000000000000000 A _text_offset
                 U printk

심볼 타입

주요 옵션

# C++ 디맹글링 + 파일명 출력 + 주소 기준 정렬
nm -C -A -n vmlinux | grep "schedule"

# 정의되지 않은 심볼 확인 (링크 오류 원인 파악)
nm -u mymodule.ko

# 크기 포함 출력 (심볼 크기 확인)
nm -S --size-sort vmlinux | tail -20

# 동적 심볼 확인 (공유 라이브러리)
nm -D /lib/x86_64-linux-gnu/libc.so.6 | grep "malloc"

# 아카이브 내 심볼 인덱스 출력
nm -s libfoo.a

# POSIX 포맷 출력
nm --format=posix vmlinux | head

System.map과 /proc/kallsyms

System.map은 커널 빌드 시 nm -n vmlinux로 생성되는 정적 심볼 주소 파일입니다. 커널 OOPS/패닉 메시지의 주소를 심볼로 변환하거나, 부트로더·디버거가 커널 심볼을 참조할 때 사용됩니다. 런타임에는 /proc/kallsyms가 로드된 모듈 심볼까지 포함한 동적 심볼 정보를 제공합니다.

System.map 포맷

# System.map 예시 — 형식: 주소  타입  심볼명
ffffffff81000000 T startup_64
ffffffff81001000 T do_early_param
ffffffff81a00000 D init_task
ffffffff82000000 B __bss_start
ffffffff82800000 A _end            # 링커 스크립트 정의 커널 끝 마커

# System.map 수동 생성 (커널 빌드 루트에서)
# scripts/mksysmap이 내부적으로 실행하는 방식과 동일
nm -n vmlinux | grep -v ' [aUwVW] ' | sort > System.map
# [aUwVW]: 로컬 절대값·미정의·weak 심볼·weak 오브젝트 제외

# 주소로 심볼 검색 (커널 OOPS 해석)
grep "ffffffff810a1234" /boot/System.map-$(uname -r)

# 주소 직전 심볼 찾기 (함수 내 오프셋 파악)
awk '$1 <= "ffffffff810a1234" {sym=$0} END{print sym}' \
    /boot/System.map-$(uname -r)

# /proc/kallsyms — 런타임 심볼 (로드된 모듈 포함)
grep "schedule" /proc/kallsyms | head -5
# ffffffff81a12340 T schedule
# fffff88001234560 t my_func  [my_module]

# root 권한 없이 접근하면 주소가 0으로 마스킹됨 (kptr_restrict)
sudo cat /proc/kallsyms | grep " T schedule"

심볼 가시성 (Symbol Visibility)

ELF는 심볼마다 가시성(visibility) 속성을 갖습니다. 이 속성은 링크 시 심볼이 다른 오브젝트에 어떻게 보이는지를 결정하며, 공유 라이브러리·커널 모듈 설계에 직접 영향을 줍니다.

# nm으로 가시성 확인 (-W: wide 출력, Ndx 컬럼 참고)
nm -W libfoo.so | grep "HIDDEN\|DEFAULT"

# readelf로 심볼 가시성 상세 확인
readelf -sW libfoo.so | awk '$5 == "HIDDEN"'

# objcopy로 심볼 가시성 변경 (전역 → hidden)
objcopy --hide-symbol=internal_func libfoo.so libfoo_hidden.so

# 모든 전역 심볼을 hidden으로 변환 후 원하는 것만 공개
objcopy --localize-hidden \
        --globalize-symbol=public_api \
        libfoo.so libfoo_api.so

/* GCC 속성으로 가시성 제어 */
#define EXPORT __attribute__((visibility("default")))
#define INTERNAL __attribute__((visibility("hidden")))

EXPORT  int public_api(void);    /* .so 외부에서 접근 가능 */
INTERNAL int helper(void);      /* 이 .so 내부 전용 */

/* 커널 모듈 심볼 내보내기 */
EXPORT_SYMBOL(my_func);          /* GPL·비GPL 모두 사용 가능 */
EXPORT_SYMBOL_GPL(my_func_gpl);  /* GPL 라이선스 모듈만 사용 가능 */

objcopy — 오브젝트 파일 변환 및 조작

objcopy는 오브젝트 파일을 복사하면서 포맷 변환, 섹션 추가·제거, 심볼 조작, 주소 재배치 등을 수행합니다. 커널 이미지 변환(ELF → 바이너리), 펌웨어 패키징, 디버그 심볼 분리 등에 광범위하게 활용됩니다.

기본 문법

objcopy [옵션] 입력파일 [출력파일]

포맷 변환 옵션

섹션 조작 옵션

심볼 조작 옵션

자주 쓰는 예제

# ELF → 순수 바이너리 변환 (부트로더, 펌웨어)
objcopy -O binary vmlinux vmlinux.bin

# 특정 섹션만 추출 (예: .text 코드 영역)
objcopy -j .text -O binary vmlinux text.bin

# 디버그 심볼 분리 (원본 보존 + 심볼 파일 별도 저장)
objcopy --only-keep-debug vmlinux vmlinux.debug    # 디버그 정보 추출
objcopy --strip-debug -O elf64-x86-64 vmlinux vmlinux.nodebug  # 배포용
objcopy --add-gnu-debuglink=vmlinux.debug vmlinux.nodebug       # 링크 등록

# 섹션 추가 (바이너리 파일을 오브젝트에 임베드)
objcopy --add-section .rodata.fw=firmware.bin \
        --set-section-flags .rodata.fw=alloc,load,readonly \
        input.o output.o

# 바이너리 파일을 링크 가능한 오브젝트로 변환
objcopy -I binary -O elf64-x86-64 \
        -B i386:x86-64 firmware.bin firmware.o

# 섹션 제거 (DWARF 디버그 정보 전체 제거)
objcopy -R .debug_info -R .debug_abbrev -R .debug_aranges \
        -R .debug_line -R .debug_str input.o output.o

# 심볼 이름 변경 (이름 충돌 해결)
objcopy --redefine-sym old_func=new_func module.o

# 모든 심볼 weak으로 변경 (테스트 오버라이드용)
objcopy --weaken original.o weak.o

### 커널 debuginfo 분리 패키지 구조 (배포판 빌드 방식) ###
# 1단계: 원본 vmlinux에서 디버그 정보만 별도 파일로 추출
objcopy --only-keep-debug vmlinux vmlinux.debug

# 2단계: strip된 배포용 파일 생성 (-o로 원본 보존)
strip --strip-debug -o vmlinux.stripped vmlinux
#   strip만 쓰면 vmlinux를 in-place로 파괴하므로 반드시 -o 지정

# 3단계: 배포용 파일에 디버그 파일 링크 등록
objcopy --add-gnu-debuglink=vmlinux.debug vmlinux.stripped
# → vmlinux.stripped: 배포 패키지 / vmlinux.debug: debuginfo 패키지
# gdb/addr2line이 실행 파일의 GNU_DEBUGLINK 섹션을 참조해 자동 탐색

### initramfs를 커널 이미지에 정적 임베드 ###
# initramfs cpio를 링크 가능 오브젝트로 변환
objcopy -B i386 -I binary -O elf64-x86-64 \
        initramfs.cpio.gz initramfs.o
# 생성된 심볼: _binary_initramfs_cpio_gz_start/end/size
# 이후 vmlinux 링크 시 initramfs.o를 함께 링크

### bzImage에서 압축 커널 추출 (분석용) ###
# bzImage의 압축 페이로드 오프셋/크기 확인
readelf -S arch/x86/boot/compressed/vmlinux | grep .rodata
# 또는 매직 바이트로 gzip/zstd 오프셋 탐색
od -A x -t x1z /boot/vmlinuz | grep "1f 8b" | head -1
# 해당 오프셋부터 압축 해제하면 vmlinux.bin 복원 가능

objdump — 오브젝트 파일 덤프 및 역어셈블

objdump는 오브젝트 파일의 다양한 정보를 사람이 읽기 좋은 형태로 출력합니다. ELF 헤더부터 역어셈블까지 폭넓게 활용되며, 커널 디버깅 시 crash와 함께 자주 쓰입니다. GDB와 함께 사용하는 소스 레벨 디버깅 방법은 GDB 페이지를 참고하세요.

주요 옵션

자주 쓰는 예제

# 섹션 헤더 요약
objdump -h vmlinux

# 특정 함수 역어셈블 (소스 혼합)
objdump -dS --disassemble=schedule vmlinux | less

# 색상 + 점프 시각화 역어셈블
objdump -d --disassembler-color=terminal --visualize-jumps vmlinux | less

# 재배치 항목 확인
objdump -r mymodule.ko

# 섹션 전체 내용 16진수 덤프
objdump -s -j .rodata mymodule.ko

# DWARF 디버깅 정보 전체 출력
objdump -W vmlinux | less

# x86_64에서 Intel 문법으로 역어셈블
objdump -d -M intel vmlinux | less

# ARM64에서 역어셈블
aarch64-linux-gnu-objdump -dS vmlinux | less

# 주소 범위 지정 역어셈블
objdump -d --start-address=0xffffffff81000000 \
           --stop-address=0xffffffff81001000 vmlinux

재배치(Relocation) 메커니즘

재배치(Relocation)는 링커나 동적 로더가 심볼 참조를 실제 주소로 해석하는 과정입니다. 오브젝트 파일에는 재배치 엔트리가 포함되어 링커가 최종 주소를 결정할 때 어떤 위치의 어떤 값을 어떻게 수정해야 하는지 알려줍니다.

재배치 엔트리 구조

ELF 재배치 엔트리에는 두 종류가 있습니다.

x86-64 주요 재배치 타입

AArch64 주요 재배치 타입

재배치 엔트리 읽기

# REL/RELA 섹션 표시
readelf -r foo.o

# objdump로 재배치 표시
objdump -r foo.o      # REL 타입
objdump -R foo.so     # 동적(RELA) 재배치

# 실행 파일의 동적 재배치 확인
readelf -r /lib/x86_64-linux-gnu/libc.so.6 | head -40

PLT · GOT 동작 원리

공유 라이브러리의 외부 함수 호출은 PLT(Procedure Linkage Table)와 GOT(Global Offset Table)를 통해 지연 바인딩됩니다.

커널에서의 재배치 — 정적 재배치 테이블

리눅스 커널은 KASLR(Kernel Address Space Layout Randomization) 지원을 위해 빌드 시 생성된 재배치 테이블(.rela.dyn 또는 arch/x86/kernel/relocs)을 통해 부팅 시 자기 자신을 재배치합니다.

# 커널 재배치 섹션 확인
readelf -r vmlinux | grep -c RELATIVE
readelf -r vmlinux | head -20

# 모듈 재배치 확인 (.ko 파일은 SHT_RELA 섹션 포함)
readelf -r my_module.ko

# 재배치 오류 디버깅 (링크 시 오버플로우)
ld -Map=output.map -o vmlinux ...
# "relocation truncated to fit" 오류는 32비트 재배치 범위 초과 의미

arch/x86/tools/relocs와 CONFIG 옵션

arch/x86/tools/relocs 도구는 x86 커널 빌드 과정에서 vmlinux의 재배치 엔트리를 처리하여 부트 시 자기 재배치(self-relocation)에 필요한 테이블을 생성합니다. CONFIG_RELOCATABLE=y이면 커널이 임의 주소에 로드되어도 정상 동작하고, CONFIG_RANDOMIZE_BASE=y(KASLR)이면 부팅마다 로드 주소가 무작위화됩니다.

# x86-64 커널 재배치 테이블 생성 확인 (빌드 시)
# arch/x86/tools/relocs 실행 로그는 make V=1 로 확인
make V=1 bzImage 2>&1 | grep relocs

# 재배치 오버플로우 디버깅: .text가 2GB 초과하면 R_X86_64_PC32 범위 초과
# 링크 오류: "relocation truncated to fit: R_X86_64_PC32 against symbol"
# 원인: 두 심볼 간 거리가 ±2GB 초과
ld -Map=vmlinux.map -o vmlinux $(KBUILD_VMLINUX_OBJS) -T vmlinux.lds
grep "\.text" vmlinux.map | awk '{print $1, $2}' | head -5

# ARM64 PIE 커널: 64비트 절대 재배치 사용 → 범위 제한 없음
readelf -r vmlinux | grep "RELATIVE" | wc -l

# 재배치 섹션 상세 분석 (모듈 .ko의 재배치 엔트리)
readelf -r my_module.ko | head -30

readelf — ELF 파일 상세 분석

readelf는 ELF(Executable and Linkable Format) 파일의 구조를 상세히 표시합니다. BFD 라이브러리를 거치지 않고 ELF를 직접 파싱하므로 objdump보다 더 정확한 ELF 구조 분석이 가능합니다. ELF 파일만 지원합니다.

주요 옵션

DWARF 서브 옵션 (-w)

# 파일 헤더 (아키텍처, 엔트리 포인트, ABI 확인)
readelf -h vmlinux

# 섹션 헤더 목록
readelf -S vmlinux | less

# 프로그램 헤더 (로드 세그먼트)
readelf -l vmlinux

# 심볼 테이블 (C++ 디맹글링 포함)
readelf -s --demangle vmlinux | grep schedule

# 동적 섹션 (공유 라이브러리 의존성)
readelf -d /lib/x86_64-linux-gnu/libc.so.6

# 재배치 항목 출력
readelf -r mymodule.ko

# DWARF 소스 줄번호 정보
readelf -wl vmlinux | less

# DWARF 전체 정보 (매우 많음)
readelf -wi vmlinux | less

# Note 섹션 (빌드 ID 확인)
readelf -n vmlinux

# 특정 섹션 16진수 덤프
readelf -x .rodata vmlinux | less

# 특정 섹션 문자열 덤프
readelf -p .comment vmlinux

# 80컬럼 이상 출력 (긴 심볼명 잘림 방지)
readelf -sW vmlinux | grep "schedule"

# ELF 구조 경고 검사
readelf -L vmlinux

strip — 심볼 및 섹션 제거

strip은 오브젝트 파일에서 심볼 테이블, 디버깅 정보, 재배치 항목 등을 제거해 파일 크기를 줄입니다. 릴리스 빌드, 커널 이미지 최적화, 배포 패키지 생성 시 활용합니다.

주요 옵션

# 모든 심볼 제거 (릴리스 실행 파일)
strip --strip-all myapp

# 디버그 심볼만 제거 (커널 모듈)
strip --strip-debug mymodule.ko

# 원본 유지하며 스트립된 버전 생성
strip -o myapp.stripped myapp

# 특정 심볼 유지하며 나머지 제거
strip --strip-all -K important_func myapp

# DWARF 섹션만 선택적 제거
strip -R .debug_info -R .debug_abbrev -R .debug_line myapp

# 디버그 정보 분리 저장 (gdb 분리 디버깅용)
objcopy --only-keep-debug vmlinux vmlinux.debug
strip --strip-debug -o vmlinux.stripped vmlinux
objcopy --add-gnu-debuglink=vmlinux.debug vmlinux.stripped

addr2line — 주소를 소스 위치로 변환

addr2line은 실행 파일의 주소(또는 함수명+오프셋)를 소스 파일명과 라인 번호로 변환합니다. 커널 패닉 콜 트레이스의 주소 분석, 크래시 보고서 해석에 필수입니다. 커널 크래시 전체 분석 절차는 커널 디버깅 및 크래시 분석 페이지를 참고하세요.

주요 옵션

# 커널 패닉 주소 분석 (vmlinux에 디버그 심볼 필요)
addr2line -e vmlinux ffffffff810a1234

# 함수명 + 파일명:라인 출력
addr2line -f -e vmlinux ffffffff810a1234

# 인라인 함수 포함 + 가독성 좋은 출력
addr2line -f -i -p -e vmlinux ffffffff810a1234

# C++ 프로그램 분석 (디맹글링)
addr2line -C -f -e myapp 0x401234

# 파이프로 여러 주소 한 번에 분석
echo "ffffffff810a1234
ffffffff810b5678" | addr2line -f -e vmlinux

# 커널 패닉 콜 트레이스 자동 변환 스크립트
grep "Call Trace" -A 30 dmesg.log | \
  grep -oP '0xffffffff[0-9a-f]+' | \
  addr2line -f -i -e vmlinux

decode_stacktrace.sh 자동 분석

scripts/decode_stacktrace.sh는 리눅스 커널 소스에 포함된 셸 스크립트로, addr2line을 내부적으로 호출해 커널 OOPS·패닉의 콜 트레이스를 사람이 읽을 수 있는 형태로 자동 변환합니다. 모듈 주소도 처리하려면 모듈 디렉토리를 지정해야 합니다.

# 기본 사용법 — dmesg 출력을 파이프로 전달
dmesg | ./scripts/decode_stacktrace.sh vmlinux

# vmlinux 경로와 모듈 디렉토리 명시
dmesg | ./scripts/decode_stacktrace.sh \
    /path/to/vmlinux \
    /lib/modules/$(uname -r)/kernel

# 저장된 크래시 로그 분석
./scripts/decode_stacktrace.sh vmlinux /lib/modules/$(uname -r) \
    < crash.log

# 인라인 함수 추적: -i 옵션이 내부적으로 적용됨
# 최적화(-O2)로 인라인된 함수도 정확히 추적됨

# 스크립트가 없는 환경에서 동일한 효과
grep -oP '(?<=\[<)[0-9a-f]+(?=>\])' crash.log | \
    addr2line -f -i -p -e vmlinux

c++filt — C++ 이름 디맹글링

C++ 컴파일러는 함수 오버로딩을 지원하기 위해 함수명을 인코딩(맹글링)합니다. c++filt는 맹글링된 심볼(_ZN3foo3barEv)을 원래 C++ 표현(foo::bar())으로 복원합니다.

주요 옵션

# 직접 심볼 디맹글링
c++filt _ZN3foo3barEv
# 출력: foo::bar()

# 표준 입력에서 읽기
nm myapp.o | c++filt

# 특정 심볼 파이프
echo "_ZNSt6vectorIiSaIiEE9push_backERKi" | c++filt
# 출력: std::vector<int, std::allocator<int>>::push_back(int const&)

# nm 출력과 결합 (C++ 오브젝트 분석)
nm -C myapp.o
# nm -C 옵션이 내부적으로 c++filt와 동일한 디맹글링 수행

# 매개변수 타입 없이 함수명만 출력
c++filt -p _ZN3foo3barERKiPc
# 출력: foo::bar

strings — 문자열 추출

strings는 파일에서 출력 가능한 문자열(기본 4글자 이상)을 추출합니다. 바이너리 파일 분석, 악성 코드 초기 분석, 커널 이미지에 포함된 버전 문자열·설정 정보 확인에 활용합니다.

주요 옵션

# 커널 이미지에서 버전 문자열 추출
strings vmlinux | grep "Linux version"

# 전체 파일 스캔 (모든 섹션)
strings -a vmlinux | head -50

# 최소 길이 10 이상 문자열만
strings -n 10 /boot/vmlinuz-$(uname -r)

# 오프셋(16진수) 포함 출력
strings -t x myapp | grep "password"

# 파일명 + 문자열 (여러 파일 동시 분석)
strings -f *.ko | grep "MODULE_VERSION"

# UTF-16 LE 문자열 추출 (Windows 실행 파일)
strings -e l windows.exe

# 유니코드 이스케이프 표시
strings -U e vmlinux | grep "©"

size — 섹션 크기 분석

size는 오브젝트 파일 또는 실행 파일의 섹션 크기(text, data, bss)를 표시합니다. 메모리 풋프린트 분석, 커널 모듈 크기 최적화에 활용합니다.

주요 옵션

# 기본 출력 (Berkeley 포맷)
$ size vmlinux
   text    data     bss     dec     hex filename
23068672  3145728  524288 26738688 1980000 vmlinux

# SysV 포맷 (섹션별 상세)
size -A mymodule.ko

# GNU 포맷 (할당 섹션만)
size -G vmlinux

# 여러 파일 비교
size -t *.ko

# 16진수 출력
size -x vmlinux

# 커널 모듈 크기 정렬 비교
size *.ko | sort -k4 -n

ranlib — 아카이브 심볼 인덱스

ranlib은 정적 라이브러리(.a)에 심볼 인덱스를 추가하거나 갱신합니다. 인덱스가 있으면 링커가 라이브러리 검색 시 모든 멤버를 스캔하지 않아도 되므로 링크 속도가 향상됩니다. ar s와 동일한 기능입니다.

# 심볼 인덱스 생성/갱신
ranlib libfoo.a

# 결정론적 모드 (타임스탬프를 0으로 고정)
ranlib -D libfoo.a

# 비결정론적 모드 (실제 타임스탬프 사용)
ranlib -U libfoo.a

# 인덱스 없이 타임스탬프만 갱신
ranlib -t libfoo.a

elfedit — ELF 헤더 직접 편집

elfedit은 ELF 파일의 헤더 필드를 직접 수정합니다. 재컴파일 없이 OS/ABI, 머신 타입, ELF 파일 유형 등을 변경할 때 사용합니다.

주요 옵션

# OS/ABI를 Linux(3)으로 변경
elfedit --output-osabi=Linux myapp

# 머신 타입 변경 (비정상적인 경우 수정)
elfedit --output-mach=x86-64 myapp

# ELF 파일 타입을 공유 오브젝트(ET_DYN)로 변경
elfedit --output-type=ET_DYN myapp

# 변경 후 확인
readelf -h myapp | grep "OS/ABI\|Machine\|Type"

GNU 어셈블러 (as) 기초

as는 GNU 어셈블러로, 어셈블리 소스를 ELF 오브젝트 파일로 변환합니다. GCC 컴파일 파이프라인에서 gcc -S로 생성한 .s 파일을 .o로 변환할 때 내부적으로 호출됩니다. x86-64·AArch64 어셈블리 명령어 집합 참조는 어셈블리 페이지를, GCC 컴파일 옵션은 GCC 페이지를 참고하세요.

기본 사용법

# 어셈블리 파일을 오브젝트로 변환
as -o foo.o foo.s

# 64비트 모드 명시 (x86-64)
as --64 -o foo.o foo.s

# 32비트 모드
as --32 -o foo.o foo.s

# 디버그 정보 포함
as -g -o foo.o foo.s

# 경고를 오류로 처리
as --fatal-warnings -o foo.o foo.s

# 리스팅 파일 생성 (주소, 인코딩, 소스 나란히)
as -a=foo.lst -o foo.o foo.s

# 크로스 어셈블 (타겟 지정)
aarch64-linux-gnu-as -o foo.o foo.s

주요 GAS 지시어(Directives)

x86-64 어셈블리 예제

/* hello.s — x86-64 AT&T 문법 */

        .section .rodata
msg:    .string "Hello, Kernel!\n"
msg_len = . - msg

        .section .text
        .global _start
        .type   _start, @function
_start:
        movq    $1,        %rax    /* sys_write */
        movq    $1,        %rdi    /* stdout fd */
        leaq    msg(%rip), %rsi    /* 문자열 주소 (RIP 상대) */
        movq    $msg_len,  %rdx    /* 길이 */
        syscall
        movq    $60, %rax          /* sys_exit */
        xorq    %rdi, %rdi
        syscall
        .size   _start, .-_start

# 어셈블 + 링크
as --64 -o hello.o hello.s
ld -o hello hello.o
./hello

인라인 어셈블리와의 관계

/* 커널 코드에서 자주 쓰이는 인라인 어셈블리 패턴 */
static __always_inline void native_cpuid(unsigned int *eax, unsigned int *ebx,
                                          unsigned int *ecx, unsigned int *edx)
{
    /* GCC extended asm — clobber list에 "cc" 포함 */
    asm volatile("cpuid"
        : "=a" (*eax), "=b" (*ebx), "=c" (*ecx), "=d" (*edx)
        : "0" (*eax), "2" (*ecx)
        : "memory");
}

/* 컴파일 후 GCC가 as를 호출해 임시 .s 파일 어셈블 */
/* gcc -S -O2 -o foo.s foo.c → as -o foo.o foo.s */

GNU 링커 (ld) 완전 가이드

ld는 GNU 링커로, 여러 오브젝트 파일과 라이브러리를 합쳐 최종 실행 파일 또는 공유 라이브러리를 생성합니다. GCC는 내부적으로 collect2를 통해 ld를 호출합니다. 링커 스크립트를 통해 메모리 레이아웃을 완전히 제어할 수 있어 커널 및 임베디드 펌웨어 개발에 필수적입니다.

기본 사용법

# 오브젝트 파일 링크
ld -o myapp foo.o bar.o

# 라이브러리 경로 + 라이브러리 지정
ld -o myapp foo.o -L/usr/lib -lc

# 공유 라이브러리 생성
ld -shared -o libfoo.so foo.o

# PIE 실행 파일 (Position Independent Executable)
ld -pie -o myapp foo.o

# 심볼 맵 파일 생성 (디버깅용) / -M 단축 옵션
ld -Map=output.map -o myapp foo.o
ld -M -o myapp foo.o > myapp.map

# 링커 스크립트 지정
ld -T mykernel.ld -o vmlinux *.o

# 사용되지 않는 섹션 제거
ld --gc-sections -o myapp foo.o

# verbose 모드 (어떤 파일이 링크되는지 + 기본 링커 스크립트 출력)
ld --verbose -o myapp foo.o 2>&1 | head -100

# 아카이브 전체 포함 (정적 초기화 등 모든 심볼 강제 링크)
ld --whole-archive libfoo.a --no-whole-archive -o myapp foo.o

# 부분 링크 (재배치 가능 출력, 추후 추가 링크)
ld -r -o combined.o foo.o bar.o

# 상태 스택으로 옵션 적용 범위 제어
ld --push-state --whole-archive libfoo.a --pop-state -o myapp foo.o

GCC를 통한 ld 옵션 전달 (-Wl)

GCC를 통해 ld를 간접 호출하는 경우 -Wl,옵션 형식으로 링커 옵션을 전달합니다. 콤마(,)로 옵션과 인수를 구분합니다.

# 링크 맵 파일 생성
gcc -Wl,-Map=output.map -o myapp foo.o bar.o

# 사용되지 않는 섹션 제거 (데드 코드 제거)
gcc -Wl,--gc-sections -ffunction-sections -fdata-sections -o myapp foo.o

# 아카이브 순환 참조 해결 (--start-group / --end-group)
gcc -Wl,--start-group -lfoo -lbar -lbaz -Wl,--end-group -o myapp foo.o

# soname 지정하여 공유 라이브러리 생성
gcc -shared -Wl,-soname,libfoo.so.1 -o libfoo.so.1.2.3 foo.o

# rpath 삽입 (런타임 라이브러리 검색 경로)
gcc -Wl,-rpath,/opt/myapp/lib -o myapp foo.o -L/opt/myapp/lib -lfoo

# 보안 강화 옵션 조합 (Full RELRO + 스택 실행 방지)
gcc -Wl,-z,relro -Wl,-z,now -Wl,-z,noexecstack -o myapp foo.o

# 링커 스크립트 지정
gcc -Wl,-T,mykernel.ld -o vmlinux *.o

# 동적/정적 라이브러리 혼합 지정
gcc foo.o -Wl,-Bstatic -lfoo -Wl,-Bdynamic -lbar -o myapp

동적 링킹 및 공유 라이브러리 옵션

공유 라이브러리를 생성하거나 동적 링킹 동작을 제어하는 옵션들입니다.

# 공유 라이브러리 생성 (soname 포함)
ld -shared -soname libfoo.so.2 -o libfoo.so.2.0.1 foo.o

# DT_RUNPATH 삽입 (DT_RPATH 대신 권장)
ld -o myapp foo.o -rpath /opt/myapp/lib --enable-new-dtags

# 필요한 DSO만 링크 (빌드 최적화)
ld --as-needed -o myapp foo.o -L/usr/lib -lfoo -lbar

보안 강화 링커 옵션 (-z)

-z keyword 형식으로 보안 관련 ELF 출력 속성을 제어합니다. 현대 리눅스 배포판은 이 옵션들을 기본 활성화하여 메모리 안전성을 높입니다.

# 보안 강화 실행 파일 빌드 (Full RELRO + NX 스택)
gcc -o myapp foo.o \
    -Wl,-z,relro \
    -Wl,-z,now \
    -Wl,-z,noexecstack

# RELRO 적용 여부 확인
readelf -l myapp | grep GNU_RELRO
readelf -d myapp | grep BIND_NOW

환경 변수

ld는 동작 제어를 위해 다음 환경 변수를 참조합니다.

# 사용 가능한 에뮬레이션 목록 확인
ld --verbose 2>&1 | grep -i emulation

# GNUTARGET으로 입력 포맷 명시
GNUTARGET=elf32-i386 ld -o myapp foo.o

# 링커 통계 출력
LD_STATS=1 ld -o myapp foo.o bar.o 2>&1

링커 스크립트 개요 (VMA vs LMA)

링커 스크립트(.ld)는 텍스트 파일로, C 스타일 주석(/* ... */)을 지원하며 명령어는 세미콜론(;)으로 구분합니다. 핵심 개념인 VMA와 LMA를 이해하는 것이 중요합니다.

임베디드 시스템에서는 코드가 ROM(LMA)에 저장되지만 RAM(VMA)으로 복사하여 실행하는 경우가 많습니다. AT(lma) 지시자로 LMA를 VMA와 다르게 지정합니다. --verbose 옵션으로 현재 플랫폼의 기본 링커 스크립트를 확인할 수 있습니다.

# 기본 링커 스크립트 확인
ld --verbose 2>&1 | grep -A 200 "using internal linker script"

링커 스크립트 기본 구조

링커 스크립트(.ld)는 출력 파일의 메모리 레이아웃을 직접 제어합니다. 커널·임베디드 펌웨어에서 필수적입니다.

/* 최소 링커 스크립트 예제 (x86-64 커널 스타일) */
OUTPUT_FORMAT("elf64-x86-64")
OUTPUT_ARCH(i386:x86-64)
ENTRY(startup_64)                   /* 엔트리 포인트 */

PHDRS {
    text PT_LOAD FLAGS(5);          /* r-x */
    data PT_LOAD FLAGS(6);          /* rw- */
}

SECTIONS {
    . = 0xffffffff81000000;         /* 커널 가상 주소 시작 */

    .text : AT(ADDR(.text) - PAGE_OFFSET) {
        _text = .;
        *(.text.head)               /* 헤드 코드 먼저 */
        *(.text)
        *(.text.*)
        _etext = .;
    } :text

    . = ALIGN(4096);                /* 페이지 경계 정렬 */

    .rodata : {
        *(.rodata)
        *(.rodata.*)
    } :data

    .data : {
        _data = .;
        *(.data)
        *(.data.*)
        _edata = .;
    } :data

    .bss : {
        _bss = .;
        *(.bss)
        *(COMMON)
        _ebss = .;
    } :data

    /DISCARD/ : {
        *(.comment)
        *(.note.*)
    }
}

링커 스크립트 핵심 명령어

SECTIONS 명령어 심화

출력 섹션의 전체 형식은 다음과 같습니다. 대부분의 선택적 항목은 생략 가능합니다.

/* 출력 섹션 완전 형식 */
/* section [address] [(type)] :
     [AT(lma)]
     [ALIGN(section_align) | ALIGN_WITH_INPUT]
     [SUBALIGN(subsection_align)]
     {
       output-section-commands
     } [>region] [AT>lma_region] [:phdr ...] [=fillexp] */

입력 섹션 선택의 주요 패턴들입니다.

SECTIONS {
    .text : {
        /* 와일드카드 패턴: *, ?, [chars] */
        *(.text)            /* 모든 .text 섹션 */
        *(.text.*)          /* .text.foo, .text.bar 등 */
        foo?.o(.text)       /* foo1.o, foo2.o 등의 .text */

        /* 특정 파일 제외 */
        EXCLUDE_FILE(*crtbegin*.o *crtend*.o) *(.ctors)

        /* 이름 순 정렬 */
        SORT_BY_NAME(*(.init_array*))
        SORT_BY_ALIGNMENT(*(.data*))
        SORT_BY_INIT_PRIORITY(*(.init_array.*))

        /* gc-sections에서 보호 */
        KEEP(*(.vectors))
        KEEP(*(.init))

        /* 초기화되지 않은 전역 변수 */
        *(COMMON)
    }

    /* NOLOAD: 메모리 미할당, 주소만 예약 */
    .debug (NOLOAD) : { *(.debug) }

    /* 섹션 명시적 제거 */
    /DISCARD/ : { *(.comment) *(.note.*) }
}

MEMORY 명령어

임베디드 시스템에서 ROM/RAM 영역을 정의하고 섹션을 배정합니다. 속성 문자: R(읽기전용), W(읽기/쓰기), X(실행), A(할당), I(초기화), !(반전).

MEMORY {
    rom  (rx)  : ORIGIN = 0x08000000, LENGTH = 512K
    ram  (rwx) : ORIGIN = 0x20000000, LENGTH = 128K
    ccm  (rw)  : ORIGIN = 0x10000000, LENGTH = 64K
}

SECTIONS {
    /* 코드 → ROM */
    .text : {
        *(.text*)
        *(.rodata*)
    } > rom

    /* 초기화 데이터: LMA=ROM, VMA=RAM */
    .data : {
        _sdata = .;
        *(.data*)
        _edata = .;
    } > ram AT > rom        /* VMA는 ram, 저장은 rom */

    _data_load = LOADADDR(.data);   /* 부트 코드가 복사할 LMA */

    /* BSS → RAM (파일에 저장 불필요) */
    .bss : {
        _sbss = .;
        *(.bss*)
        *(COMMON)
        _ebss = .;
    } > ram

    /* 고속 CCM 메모리 활용 */
    .ccm_data (NOLOAD) : {
        *(.ccm_data)
    } > ccm
}

/* MEMORY 영역 함수: ORIGIN(rom) → 0x08000000, LENGTH(ram) → 131072 */

REGION_ALIAS(alias, region)를 사용하면 아키텍처별 메모리 구성을 추상화하여 동일한 링커 스크립트를 여러 플랫폼에 재사용할 수 있습니다.

PHDRS 명령어 (ELF 프로그램 헤더)

ELF 프로그램 헤더(세그먼트)를 수동으로 정의합니다. PHDRS를 사용하면 ld가 자동 생성하는 헤더가 없어지므로 필요한 헤더를 모두 명시해야 합니다.

/* PHDRS 구문: name type [FILEHDR] [PHDRS] [AT(address)] [FLAGS(flags)] */
/* FLAGS: PF_R=4, PF_W=2, PF_X=1 */

PHDRS {
    headers PT_PHDR    FILEHDR PHDRS FLAGS(5);  /* 헤더 자체 포함 */
    interp  PT_INTERP  FLAGS(4);                /* 동적 링커 경로 */
    text    PT_LOAD    FILEHDR PHDRS FLAGS(5);  /* r-x (읽기+실행) */
    data    PT_LOAD    FLAGS(6);                /* rw- (읽기+쓰기) */
    dynamic PT_DYNAMIC FLAGS(6);                /* .dynamic 섹션 */
}

SECTIONS {
    /* :phdr_name 으로 세그먼트에 배정 */
    .interp : { *(.interp) }               :text :interp
    .text   : { *(.text*) }                :text
    .rodata : { *(.rodata*) }              :text

    . = DATA_SEGMENT_ALIGN(0x200000, 0x1000);

    .data   : { *(.data*) }                :data
    .dynamic: { *(.dynamic) }             :data :dynamic
    .bss    : { *(.bss*) *(COMMON) }       :data

    /* :NONE 으로 세그먼트 미배정 */
    /DISCARD/ : { *(.comment) }
}

VERSION 명령어 (심볼 버전 스크립트)

공유 라이브러리의 ABI 버전을 관리합니다. global:은 외부에 공개, local:은 은닉(라이브러리 내부 전용)입니다.

/* libfoo.map — 버전 스크립트 */
VERS_1.0 {
    global:
        foo_init;       /* 공개 API */
        foo_destroy;
        foo_process;
    local:
        *;              /* 나머지 모두 은닉 */
};

/* 버전 노드 상속: VERS_2.0은 VERS_1.0의 심볼을 포함 */
VERS_2.0 {
    global:
        foo_init_ex;    /* 새 API 추가 */
        foo_query;
} VERS_1.0;             /* VERS_1.0 상속 */

# 버전 스크립트로 공유 라이브러리 빌드
gcc -shared -Wl,--version-script=libfoo.map -o libfoo.so.2 foo.o

# 버전 심볼 확인
nm -D libfoo.so.2 | grep "@@"
objdump -p libfoo.so.2 | grep -A 5 "Version definitions"

빌트인 함수 레퍼런스

링커 스크립트 표현식(SECTIONS 내)에서 사용할 수 있는 내장 함수들입니다.

SECTIONS {
    .text : { *(.text*) }
    .rodata : { *(.rodata*) }

    /* LMA 복사를 위한 심볼 */
    _sdata_lma = LOADADDR(.data);
    _sdata_size = SIZEOF(.data);

    .data : {
        _sdata = .;
        *(.data*)
        _edata = .;
    } > ram AT > rom

    /* DEFINED로 조건부 심볼 정의 */
    PROVIDE(_stack_start = DEFINED(__stack_start) ?
                           __stack_start :
                           ORIGIN(ram) + LENGTH(ram));

    /* MAX 활용 */
    . = MAX(., ALIGN(16));
}

링크 오류 해석

실전 활용 예제

아래 예제들은 커널 개발 현장에서 자주 쓰이는 Binutils 활용 패턴입니다. 커널 디버깅 전반은 커널 디버깅 페이지를, GDB를 이용한 소스 레벨 분석은 GDB 페이지를 함께 참고하세요.

커널 패닉 콜 트레이스 분석

# 1. dmesg에서 콜 트레이스 추출
dmesg | grep -A 40 "Call Trace" > trace.txt

# 2. 각 주소를 addr2line으로 변환
grep -oP 'ffffffff[0-9a-f]+' trace.txt | \
  addr2line -f -i -p -e /usr/lib/debug/boot/vmlinux-$(uname -r)

# 또는 커널 스크립트 활용
dmesg | ./scripts/decode_stacktrace.sh vmlinux

정적 라이브러리 빌드 자동화

# Makefile 예제
OBJS = foo.o bar.o baz.o
LIB  = libmylib.a

$(LIB): $(OBJS)
	ar crsD $@ $^     # D: 결정론적 모드 (재현 가능 빌드)

# 빌드 후 심볼 확인
nm -C libmylib.a

커널 모듈 심볼 분석

# 모듈이 내보내는 심볼 확인
nm mymodule.ko | grep " T "

# 모듈이 참조하는 외부 심볼 (커널이 제공해야 하는 것)
nm mymodule.ko | grep " U "

# 커널 심볼 테이블에서 제공 여부 확인
nm /boot/System.map-$(uname -r) | grep "schedule"

# 모듈 크기 분석
size mymodule.ko

ELF 파일 완전 분석 워크플로

# 1. 기본 정보
readelf -h target.elf

# 2. 섹션 목록
readelf -S target.elf

# 3. 심볼 테이블
readelf -s target.elf | sort -k3 -n

# 4. 동적 의존성 (공유 라이브러리)
readelf -d target.elf | grep "NEEDED"

# 5. 역어셈블 (Intel 문법)
objdump -dS -M intel target.elf | less

# 6. 크기 분석
size -A target.elf

# 7. 문자열 추출
strings -t x target.elf | grep -i "version\|config\|error"

크로스 컴파일 환경에서의 Binutils

# ARM64용 크로스 컴파일 도구 접두사
CROSS = aarch64-linux-gnu-

# 크로스 컴파일된 커널 분석
${CROSS}nm -C vmlinux | grep schedule
${CROSS}readelf -h vmlinux
${CROSS}objdump -d --disassemble=do_fork vmlinux | head -100
${CROSS}size vmlinux

# ARM64 ELF → 바이너리 변환 (U-Boot raw 이미지)
${CROSS}objcopy -O binary vmlinux Image

펌웨어 임베딩

# 바이너리 파일을 ELF 오브젝트로 변환하여 링크
objcopy -I binary -O elf64-x86-64 -B i386:x86-64 \
        firmware.bin firmware.o

# 링크 후 C 코드에서 참조

extern const char _binary_firmware_bin_start[];
extern const char _binary_firmware_bin_end[];
extern const size_t _binary_firmware_bin_size;

/* 사용 */
size_t fw_size = (size_t)(&_binary_firmware_bin_end -
                          &_binary_firmware_bin_start);

지원 BFD 타겟 및 아키텍처

Binutils가 지원하는 오브젝트 포맷과 아키텍처는 빌드 시 설정에 따라 다릅니다.

# 지원 포맷 목록
objdump -i

# 주요 BFD 타겟 이름
elf64-x86-64       # x86_64 ELF64
elf32-i386         # x86 ELF32
elf64-aarch64      # AArch64/ARM64 ELF64
elf32-littlearm    # ARM (Little Endian) ELF32
elf64-littleriscv  # RISC-V 64 ELF64
elf32-littleriscv  # RISC-V 32 ELF32
elf64-powerpc      # PowerPC 64-bit ELF
elf64-s390         # IBM S/390 ELF64
binary             # 순수 바이너리 (포맷 없음)
ihex               # Intel HEX 포맷
srec               # Motorola S-Record 포맷

커널 특수 ELF 섹션

리눅스 커널은 일반 사용자 공간 ELF와 달리 커널 전용 특수 섹션을 사용합니다. 이 섹션들은 링커 스크립트(arch/x86/kernel/vmlinux.lds.S)와 include/linux/init.h, include/linux/export.h 등의 매크로로 정의됩니다.

초기화 관련 섹션

심볼 내보내기 섹션

섹션 배열 패턴 (linker set)

커널은 링커가 섹션 내 항목들을 자동으로 수집하는 패턴을 광범위하게 사용합니다.

특수 섹션 분석 명령

# 커널 내보낸 심볼 수 확인
readelf -S vmlinux | grep ksymtab
nm vmlinux | grep "__ksymtab_" | wc -l

# 초기화 코드 크기 확인 (부팅 후 해제될 메모리)
size vmlinux
readelf -S vmlinux | grep "\.init"

# 예외 테이블 엔트리 확인
readelf -S vmlinux | grep ex_table
objdump -j __ex_table -s vmlinux | head -40

# jump label 엔트리 수
readelf -S vmlinux | grep jump_table

# 대체 명령어 패치 테이블 분석
objdump -j .altinstructions -d vmlinux 2>/dev/null | head -30

# 모듈의 ksymtab 확인
readelf -S my_module.ko | grep ksymtab
nm my_module.ko | grep "__ksymtab\b"

# 모듈 파라미터 섹션
objdump -j __param -s my_module.ko

섹션 크기 비교 예시

# vmlinux 주요 섹션 크기 분석
readelf -S vmlinux | awk '/\[/{name=$2} /PROGBITS|NOBITS/{
  cmd = "printf \"%10d  %s\n\", 0x"$6", name"
  system(cmd)
}' | sort -rn | head -20

# 또는 간단히
size -A vmlinux | sort -k2 -rn | head -20

커널 이미지 빌드 파이프라인

리눅스 커널 빌드는 vmlinux(ELF 실행 파일) 생성부터 최종 부트 이미지 패키징까지 여러 단계를 거칩니다. 각 단계에서 Binutils 도구가 핵심 역할을 담당합니다.

단계별 상세

# 1단계: 소스 컴파일 → 오브젝트 파일 생성
make -j$(nproc) vmlinux

# 2단계: System.map 자동 생성 (make가 내부적으로 scripts/mksysmap 실행)
nm -n vmlinux | grep -v ' [aUwVW] ' | sort > System.map

# 3단계: ELF → 순수 바이너리 변환
objcopy -O binary -R .note -R .comment -S vmlinux vmlinux.bin

# 4단계: 압축 (arch/x86/boot/compressed/ 에서 수행)
gzip -n -f -9 vmlinux.bin  # → vmlinux.bin.gz

# 5단계: bzImage 조합 (x86 전용)
make bzImage
# → arch/x86/boot/bzImage (부트 섹터 + 설정 헤더 + 압축 커널)

아키텍처별 커널 이미지 포맷

커널 모듈 빌드와 심볼 검증

커널 모듈(.ko)은 커널 빌드 시스템과 별도로 빌드되지만, modpost 단계에서 심볼 의존성·라이선스·버전을 엄격히 검증합니다. Binutils 도구는 빌드된 모듈의 심볼 구조를 분석하는 데 필수적입니다.

모듈 빌드 기본 패턴

# 최소 Makefile (외부 모듈 빌드용)
obj-m += my_module.o

# 여러 소스 파일로 구성된 모듈
my_module-objs := main.o helper.o ops.o

# 외부 모듈 빌드
make -C /lib/modules/$(uname -r)/build M=$(pwd) modules

# 설치
make -C /lib/modules/$(uname -r)/build M=$(pwd) modules_install

# 빌드 결과물 확인
ls *.ko *.o .*.cmd

modpost 심볼 검증

scripts/mod/modpost.c는 모듈 빌드의 핵심 검증 단계입니다. 미정의 심볼 참조, 섹션 불일치, GPL 전용 심볼 무단 사용 등을 체크합니다.

# 모듈의 미정의 심볼 확인 (커널에서 제공해야 함)
nm -u my_module.ko

# 모듈이 사용하는 커널 심볼이 실제 존재하는지 확인
nm -u my_module.ko | awk '{print $2}' | \
    while read sym; do
        grep -q " $sym$" /proc/kallsyms || echo "MISSING: $sym"
    done

# 모듈이 내보내는 심볼 확인 (__ksymtab 섹션)
nm my_module.ko | grep "__ksymtab\b"

# 모듈 섹션 구조 전체 확인
readelf -S my_module.ko | grep -E "ksymtab|kcrctab|modinfo|param"

CONFIG_MODVERSIONS와 ABI 검증

CONFIG_MODVERSIONS=y이면 커널은 각 내보내기 심볼에 CRC 체크섬을 계산해 __kcrctab 섹션에 저장합니다. 모듈 로드 시 커널 CRC와 모듈 CRC를 비교해 ABI 불일치를 방지합니다.

# 모듈의 버전 CRC 확인
readelf -S my_module.ko | grep kcrctab
nm my_module.ko | grep "__crc_"

# 커널 Module.symvers 파일 확인 (심볼별 CRC 목록)
grep "my_exported_func" Module.symvers
# 출력: CRC  심볼명  vmlinux/모듈경로  라이선스

# 모듈 로드 오류: "disagrees about version of symbol"
# → 모듈이 다른 커널 버전용으로 빌드되었거나 Module.symvers 불일치
dmesg | grep "disagrees about version"

MODULE_LICENSE와 EXPORT_SYMBOL_GPL

/* 모듈 라이선스 선언 — GPL이어야 _GPL 심볼 접근 가능 */
MODULE_LICENSE("GPL v2");

/* 비GPL 모듈도 접근 가능한 일반 심볼 */
EXPORT_SYMBOL(my_public_func);

/* GPL 라이선스 모듈만 접근 가능 */
EXPORT_SYMBOL_GPL(my_gpl_only_func);

# GPL 전용 심볼 사용 여부 확인
nm -u my_module.ko | grep "_gpl"

# .modinfo 섹션에서 라이선스 확인
readelf -p .modinfo my_module.ko
# 또는
modinfo my_module.ko | grep license

모듈 로드 시 심볼 해석 흐름

모듈이 insmod/modprobe로 로드될 때 커널의 kernel/module/core.c가 심볼 해석을 수행합니다.

# 모듈 로드 및 심볼 해석 흐름 추적
# 1. insmod → sys_finit_module() 시스템 콜
# 2. kernel/module/core.c: load_module() → resolve_symbol_wait()
# 3. __ksymtab 섹션 순회 → CRC 검증 (MODVERSIONS) → 주소 패치

# 로드 후 심볼 주소 확인
grep "my_module" /proc/kallsyms

# 모듈의 의존성 그래프 확인
modinfo -F depends my_module.ko

CONFIG_MODULE_SIG — 서명된 모듈 분석

CONFIG_MODULE_SIG=y이면 scripts/sign-file로 모듈에 서명을 추가합니다. 서명은 .ko 파일 끝에 추가되거나 별도 섹션에 저장됩니다.

# 모듈 서명 추가 (빌드 시스템이 자동 수행)
scripts/sign-file sha256 signing_key.pem signing_cert.pem my_module.ko

# 서명 섹션 확인
readelf -S my_module.ko | grep -i sig
# CONFIG_MODULE_SIG_FORMAT=PKCS7이면 .ko 끝에 바이너리 PKCS7 블록 추가

# 서명 존재 여부 확인 (파일 끝의 매직 바이트)
tail -c 28 my_module.ko | od -An -tx1 | grep "7e 4d 6f 64"
# "~Module signature appended~" 매직 확인

# 빌드 → 검증 → 로드 전체 흐름
make -C /lib/modules/$(uname -r)/build M=$(pwd) modules
nm my_module.ko | grep -E "T |U "   # 심볼 확인
readelf -S my_module.ko | head -30   # 섹션 구조 확인
sudo insmod my_module.ko             # 로드
dmesg | tail -5                      # 로드 결과 확인

참고 자료

• GNU Binutils 공식 매뉴얼 — GNU Binary Utilities, Roland H. Pesch, Jeffrey M. Osier (버전 2.46, 2026년 2월)
• GNU Linker 매뉴얼 — Using ld, 링커 스크립트·메모리 레이아웃·섹션 배치 상세
• GNU Assembler 매뉴얼 — Using as, GAS 지시어·문법·아키텍처별 확장
• Binutils 소스 저장소 (Sourceware Git) — binutils-gdb 통합 저장소
• 리눅스 커널 소스: scripts/decode_stacktrace.sh, scripts/kallsyms.c, arch/x86/kernel/vmlinux.lds.S
• ELF 명세 — System V Application Binary Interface, ELF 파일 형식 정의 (PDF)
• DWARF 명세 — DWARF Debugging Information Format 버전 5 (dwarfstd.org)
• x86-64 ABI 명세 — System V AMD64 ABI, 재배치 타입·호출 규약·ELF 확장 정의

관련 페이지

• ELF 파일 형식 — ELF 구조 심화, 동적 링킹, 인터프리터
• GCC — 컴파일 파이프라인, 최적화 옵션, 인라인 어셈블리
• GDB — 소스 레벨 디버깅, DWARF 활용, 원격 디버깅
• GNU Assembler (as) — as 커맨드라인 옵션, GAS 지시자 완전 참조, CFI 지시자, 아키텍처별 기능
• 어셈블리 — x86-64·AArch64 명령어 집합, AT&T/Intel 문법
• 커널 디버깅 — printk, KASAN, kprobe, ftrace 통합 디버깅 기법
• 크래시 분석 — 커널 패닉·콜 트레이스 해석, crash 도구