디버깅을 통해 배우는 리눅스 커널의 구조와 원리 2(위키북스 유닉스 & 리눅스 시리즈 4)

▣ 08장: 커널 타이머 관리

8.1 커널 타이머(저해상도 타이머)의 주요 개념

___8.1.1 HZ란?

___8.1.2 Soft IRQ의 타이머 서비스란?

___8.1.3 Soft IRQ 타이머(TIMER_SOFTIRQ) 서비스와 동적 타이머란?

___8.1.4 커널이 실행 시각을 관리하는 방식을 왜 잘 알아야 할까?

___8.1.5 커널 타이머 용어 정리

8.2 jiffies란?

___8.2.1 jiffies 소개

___8.2.2 jiffies와 jiffies_64 변수

___8.2.3 jiffies 값은 누가 언제 증가시킬까?

___8.2.4 msecs_to_jiffies() 함수란?

8.3 커널에서 시간을 흐름을 제어하는 방법

___8.3.1 time_after()/time_before() 매크로 함수

___8.3.2 time_after()/time_before() 함수의 사용 예

8.4 동적 타이머 초기화

___8.4.1 동적 타이머의 전체 흐름

___8.4.2 동적 타이머 자료구조

___8.4.3 동적 타이머 초기화 함수

8.5 동적 타이머 등록

___8.5.1 동적 타이머의 등록

___8.5.2 동적 타이머 등록 과정의 주요 함수

___8.5.3 동적 타이머 등록 과정에서 호출하는 함수 분석

8.6 동적 타이머는 누가 언제 실행할까?

___8.6.1 Soft IRQ 타이머 서비스에서 동적 타이머를 실행하는 과정

___8.6.2 Soft IRQ 타이머 서비스의 1~2단계 분석

___8.6.3 Soft IRQ 타이머 서비스에서 등록된 동적 타이머를 체크하는 단계의 코드 분석

___8.6.4 Soft IRQ 타이머 서비스 핸들러에서 등록된 동적 타이머를 실행하는 단계의 코드 분석

8.7 라즈베리 파이에서의 동적 타이머 실습 및 로그 분석

___8.7.1 ftrace의 동적 타이머 디버깅 이벤트 소개

___8.7.2 라즈베리 파이에서의 동적 타이머 등록 및 실행 과정을 ftrace로 확인하기

8.8 정리



▣ 09장: 커널 동기화

9.1 커널 동기화의 주요 개념

___9.1.1 임계 영역과 레이스 컨디션

___9.1.2 레이스 컨디션은 왜 발생할까?

___9.1.3 레이스 컨디션 관련 커널 패치

9.2 레이스 컨디션 발생 실습

___9.2.1 유저 프로세스에서 시스템 콜을 호출할 때 발생하는 레이스 컨디션

___9.2.2 커널 프로세스의 레이스 컨디션

___9.2.3 인터럽트 발생으로 인한 레이스 컨디션 발생

9.3 커널 동기화 기법

___9.3.1 스핀락과 뮤텍스 기법

___9.3.2 스핀락과 뮤텍스 기법의 차이점

9.4 스핀락

___9.4.1 스핀락의 특징

___9.4.2 스핀락 자료구조

___9.4.3 스핀락 사용 예제

___9.4.4 스핀락 처리 흐름

___9.4.5 spin_lock() 함수의 인라인 어셈블리 코드 분석

___9.4.6 spin_lock() 함수의 어셈블리 코드 분석

___9.4.7 spin_unlock() 함수 분석

___9.4.8 스핀락 플러그인 함수: spin_lock_irq()/spin_unlock_irq()

___9.4.9 스핀락 플러그인 함수: spin_lock_irqsave()/spin_unlock_irqrestore()

9.5 뮤텍스란?

___9.5.1 뮤텍스의 기본 개념

___9.5.2 뮤텍스의 fastpath 동작

___9.5.3 뮤텍스 slowpath: mutex_lock() 함수 분석

___9.5.4 뮤텍스 slowpath: mutex_unlock() 함수 분석

9.6 커널 동기화 디버깅

___9.6.1 스핀락

___9.6.2 뮤텍스 디버깅

9.8 정리



▣ 10장: 프로세스 스케줄링

10.1 스케줄링의 주요 개념

___10.1.1 스케줄링이란?

___10.1.2 선점 스케줄링과 비선점 스케줄링이란?

___10.1.3 컨텍스트 스위칭이란?

___10.1.4 스케줄링 정책이란?

___10.1.5 스케줄러 클래스란?

___10.1.6 런큐란?

___10.1.7 우선순위(nice)란?

10.2 프로세스 상태 관리

___10.2.1 프로세스 상태

___10.2.2. 프로세스 상태 변화

___10.2.3 어떤 함수가 프로세스 상태를 바꿀까?

___10.2.4 프로세스 상태를 ftrace로 확인하기

10.3 스케줄러 클래스

___10.3.1 스케줄러 클래스 자료구조

___10.3.2 5가지 스케줄러 클래스란?

___10.3.3 프로세스는 스케줄러 클래스를 어떻게 등록할까?

___10.3.4 프로세스는 스케줄러 클래스로 스케줄러의 세부 함수를 어떻게 호출할까?

10.4 런큐

___10.4.1 런큐 자료구조(rq) 소개

___10.4.2 runqueues 변수

___10.4.3 런큐에 접근하는 함수

___10.4.4 런큐 자료구조

10.5 CFS 스케줄러

___10.5.1 CFS 스케줄러의 주요 개념

___10.5.2 CFS 스케줄러 알고리즘

___10.5.3 CFS 관련 세부 함수 분석

___10.5.4 vruntime을 ftrace로 확인하는 실습

10.6 선점 스케줄링

___10.6.1 선점 스케줄링이란?

___10.6.2 선점 스케줄링 진입점은 어디일까?

___10.6.3 선점 스케줄링의 발생 시점을 아는 것은 왜 중요할까?

___10.6.4 선점 스케줄링의 진입점: 커널 모드 중 인터럽트 발생

___10.6.5 선점 스케줄링 진입점: 유저 프로세스 실행 중 인터럽트 발생

___10.6.6 선점 스케줄링 진입점: 유저 프로세스가 시스템 콜 처리를 마무리한 후

___10.6.7 선점 스케줄링 비활성화/활성화 함수 preempt_disable()/preempt_enable() 소개

10.7 프로세스는 어떻게 깨울까?

___10.7.1. 프로세스를 깨운다는 것은 무엇을 의미할까?

___10.7.2 프로세스를 깨울 때 호출하는 함수

___10.7.3 깨우는 프로세스를 런큐에 삽입하는 동작

10.8 스케줄링의 핵심 schedule() 함수

___10.8.1 schedule() 함수 분석

___10.8.2 schedule() 함수의 동작 정리

10.9 컨텍스트 스위칭

___10.9.1 컨텍스트 스위칭이란?

___10.9.2 컨텍스트 스위칭 관련 자료구조

___10.9.3 컨텍스트 스위칭의 세부 코드 분석

___10.9.4 ftrace를 이용한 컨텍스트 스위칭 동작 확인

___10.9.5 컨텍스트 스위칭 디버깅

10.10 스케줄링 디버깅

___10.10.1 ftrace: sched_switch와 sched_wakeup 이벤트 소개

___10.10.2 ftrace: 스케줄링과 프로세스를 깨울 때의 콜 스택 파악

___10.10.3 프로세스를 깨울 때의 콜 스택 분석

10.11 정리



▣ 11장: 시스템 콜

11.1 시스템 콜의 주요 개념

___11.1.1 시스템 콜이란?

___11.1.2 시스템 콜의 전체 흐름과 계층

___11.1.3 시스템 콜의 특징

___11.1.4 ARM 프로세서 관점의 시스템 콜 처리

___11.1.5 시스템 콜 테이블이란?

11.2 유저 공간에서 시스템 콜은 어떻게 발생할까?

___11.2.1 GNU C 라이브러리의 실행 흐름

___11.2.2 유저 공간에서 시스템 콜이 발생할 때의 어셈블리 코드 분석

11.3 커널 모드에서 시스템 콜을 어떻게 실행할까?

___11.3.1 소프트웨어 인터럽트 벡터 vector_swi는 어떻게 실행될까?

___11.3.2 소프트웨어 인터럽트 벡터 vector_swi 코드 분석

___11.3.3 커널 공간에서 시스템 콜 테이블 확인

11.4 시스템 콜 핸들러는 어떻게 동작할까?

___11.4.1 시스템 콜 종류별 시스템 콜 핸들러의 동작

___11.4.2 매개변수 점검

11.5 시스템 콜의 실행을 완료한 후에는 무슨 일을 할까?

___11.5.1 ret_fast_syscall 레이블의 복귀 과정

___11.5.2 ret_fast_syscall 레이블의 전체 실행 흐름

___11.5.3 시그널 전달 및 스케줄링 실행 조건 점검

___11.5.4 유저 공간으로 복귀

11.6 시스템 콜 관련 함수

___11.6.1 SYSCALL_DEFINEx 매크로 분석

___11.6.2 전처리 코드에서 시스템 콜 핸들러 확인

11.7 시스템 콜 디버깅

___11.7.1 ftrace 시스템 콜 이벤트

___11.7.2 ftrace 시스템 콜 핸들러의 콜 스택 확인

___11.7.3 strace를 이용한 시스템 콜 디버깅

___11.7.4 strace와 ftrace를 이용한 시스템 콜 디버깅

11.8 정리



▣ 12장: 시그널

12.1 시그널이란?

___12.1.1 유저 프로세스 입장에서 시그널이란?

___12.1.2 시그널 번호와 동작 방식

___12.1.3 시그널을 받으면 프로세스는 어떻게 동작할까?

___12.1.4 커널에서 시그널은 어떻게 처리할까?

___12.1.5 커널이 시그널을 처리하는 동작을 왜 잘 알아야 할까?

12.2 시그널 설정은 어떻게 할까?

___12.2.1 유저 공간에서의 시그널 설정

___12.2.2 커널 공간에서의 시그널 설정

___12.2.3 시그널 관련 시스템 호출 함수는 무엇일까?

12.3 커널 공간의 시그널 설정 함수 분석

___12.3.1 유저 공간에서 sigaction() 함수를 호출했을 때의 커널 실행 흐름

___12.3.2 유저 공간에서 pause() 함수 호출 시의 커널 실행 흐름 파악

12.4 시그널 생성 과정의 함수 분석

___12.4.1 유저 프로세스의 kill() 함수 실행

___12.4.2 유저 프로세스의 tgkill() 함수 실행

___12.4.3 커널은 언제 시그널을 생성할까?

___12.4.4 __send_signal() 함수 분석

___12.4.5 complete_signal() 함수 분석

12.5 프로세스는 언제 시그널을 받을까?

___12.5.1 ret_fast_syscall 레이블 분석

___12.5.2 인터럽트 핸들링 후 __irq_usr 레이블 코드 분석

12.6 시그널 전달과 처리는 어떻게 할까?

___12.6.1 do_work_pending()/do_signal() 함수 분석

___12.6.2 get_signal() 함수 분석

___12.6.3 handle_signal() 함수와 시그널 핸들러 호출 코드 분석

12.7 시그널 제어 suspend() 제어를 위한 분석

___12.7.1 유저 공간의 suspend() 함수

___12.7.2 커널 공간의 sys_rt_sigsuspend() 함수 분석

12.8 시그널에 대한 ftrace 디버깅

___12.8.1 ftrace의 시그널 이벤트 소개

___12.8.2 ftrace를 이용한 시그널의 기본 동작 로그 분석

___12.8.3 ftrace의 시그널 핸들러 동작 로그 분석

12.9 정리



▣ 13장: 가상 파일 시스템

13.1 가상 파일 시스템 소개

___13.1.1 가상 파일 시스템이란?

___13.1.2 가상 파일 시스템의 공통 모델

___13.1.3 함수 오퍼레이션

___13.1.4 유저 프로세스 입장에서 파일 처리

___13.1.5 파일 시스템별 파일 함수 오퍼레이션의 처리 과정

13.2 파일 객체

___13.2.1 file 구조체 분석

___13.2.2 파일 객체의 함수 오퍼레이션

13.3 파일 객체의 함수 오퍼레이션 동작 방식

___13.3.1 파일을 오픈할 때의 open 함수 오퍼레이션

___13.3.2 파일을 쓸 때의 write 함수 오퍼레이션

___13.3.3 파일을 읽을 때의 read 함수 오퍼레이션

___13.3.4 파일 포인터의 위치를 갱신할 때의 lseek 함수 오퍼레이션

___13.3.5 파일을 닫을 때의 close 함수 오퍼레이션

13.4 프로세스는 파일 객체 자료구조를 어떻게 관리할까?

___13.4.1 파일 객체의 파일 디스크립터 테이블 등록

___13.4.2 파일 디스크립터로 파일 객체를 로딩

___13.4.3 파일 디스크립터 해제

13.5 슈퍼블록 객체

___13.5.1 슈퍼블록 객체

___13.5.2 super_block 구조체 분석

___13.5.3 슈퍼블록 함수 오퍼레이션

___13.5.4 슈퍼블록의 함수 오퍼레이션 관련 시스템 콜

___13.5.5 슈퍼블록 정보를 statfs 시스템 콜로 읽는 과정

13.6 아이노드 객체

___13.6.1 inode 구조체 분석

___13.6.2 아이노드 함수 오퍼레이션

___13.6.3 파일 속성을 읽는 stat 시스템 콜의 처리 과정

13.7 덴트리 객체

___13.7.1 덴트리 객체 소개

___13.7.2 dentry 구조체 분석

13.8 가상 파일 시스템 디버깅

___13.8.1 파일 객체의 함수 오퍼레이션 확인

___13.8.2 슈퍼블록 객체의 함수 오퍼레이션 확인

___13.8.3 아이노드 객체의 함수 오퍼레이션 확인

13.9 정리



▣ 14장: 메모리 관리

14.1 가상 메모리 기법의 주요 개념

___14.1.1 가상 메모리의 주요 개념

___14.1.2 가상 메모리와 가상주소

___14.1.3 페이징에서 메모리 주소를 계산하는 방법

___14.1.4 페이지 프레임 번호와 페이지 디스크립터

___14.1.5 페이지 테이블이란?

14.2 가상주소를 물리주소로 어떻게 변환할까?

___14.2.1 가상주소 변환 과정의 전체 구조

___14.2.2 가상주소를 물리주소로 변환하는 단계

___14.2.3 페이지 테이블 관련 용어

___14.2.4 페이지 테이블의 종류

___14.2.5 가상주소를 물리주소로 변환하는 세부 원리

___14.2.6 가상주소를 물리주소로 직접 변환

14.3 메모리 존

___14.3.1 메모리 존의 종류와 개념

___14.3.2 메모리 존 자료구조 분석

___14.3.3 /proc/zoneinfo로 존 자료구조 확인하기

14.4 커널 동적 메모리 할당

___14.4.1 동적 메모리와 정적 메모리 할당

___14.4.2 kmalloc() 함수를 쓰는 이유

___14.4.3 kmalloc() 함수

___14.4.4 GFP(Get Free Page) 플래그

___14.4.5 kmalloc() 함수를 호출할 때의 주의 사항

14.5 슬랩 메모리 할당자와 kmalloc 슬랩 캐시 분석

___14.5.1 슬랩의 주요 개념

___14.5.2 kmalloc 슬랩 캐시

___14.5.3 kmalloc 슬랩 캐시 자료구조

___14.5.4 kmalloc 캐시 슬럽 오브젝트를 할당하는 커널 함수 분석

___14.5.5 슬럽 오브젝트를 해제하는 kfree() 함수 분석

14.6 디버깅으로 슬럽 오브젝트 할당과 가상주소 변환 방식 익히기

___14.6.1 ftrace를 이용한 메모리 할당 해제 확인

___14.6.2 가상주소를 물리주소로 변환하는 과정 확인

___14.6.3 kmalloc() 함수로 메모리 할당 후 슬랩 캐시 종류 확인

14.7 정리



▣ 부록A: GCC 지시어

A.1 __init과 __section()

A.2 inline

A.3 noinline

A.4 __noreturn

A.5 unused

A.6 __builtin_return_address() 함수

A.7 container_of



▣ 부록B: 리눅스 커널을 접하는 방법

B.1 블로그에 공부한 내용을 올리기

B.2 리눅스 사이트에서 답신 달기

B.3 커널 스터디 클럽

B.4 리눅스 커널 메일링 리스트 구독하기



▣ 부록C: 리눅스 커널 프로젝트에 기여하기

C.1 리눅스 커널 오픈소스 프로젝트 소개

__C.1.1 용어

__C.1.2 패치 반영 과정

C.2 설정 방법

__C.2.1 리눅스 배포판 소개

__C.2.2 git과 mutt 프로그램 설정

__C.2.3 리눅스 커널 소스코드 내려받기

__C.2.4 리눅스 커널의 git 정보

C.3 패치 코드를 작성한 후 이메일로 보내기

__C.3.1 패치 코드를 작성하기 전 커널 코드 분석

__C.3.2 커밋과 커밋 메시지 작성

__C.3.3 패치 코딩 룰 체크

__C.3.4 패치를 보낼 메일 수신자 확인

__C.3.5 mutt 프로그램으로 패치 전송

C.4 패치 코드 리뷰 과정과 업스트림(병합) 확인

C.5 리눅스 커널 오픈소스 프로젝트로 얻는 지식

__C.5.1 코드 리뷰

__C.5.2 Git 사용법

__C.5.3 개발자 간의 의사소통과 개발 문화

김동현 LG전자에서 11년째 임베디드 리눅스 BSP 엔지니어로 일하고 있다. 주로 리눅스 커널 드라이버를 안정화(Kernel Stability Troubleshooting)하거나 보드를 브링업하는 과제에 참여했다. 로우 레이어 소프트웨어(부트로더, 리눅스 커널 드라이버)의 다양한 문제를 해결할 수 있는 디버깅 방법에 관심이 많으며 실무 지식을 블로그를 통해 다른 개발자와 공유하는 것을 즐긴다.



- 블로그: http://rousalome.egloos.com/