디버깅을 통해 배우는 리눅스 커널의 구조와 원리 1권

▣ 01장: 리눅스 소개와 전망
1.1 리눅스와 리눅스 커널은 왜 배워야 할까?
__1.1.1 리눅스는 왜 배워야 할까?
__1.1.2 리눅스 커널은 왜 배워야 할까?
1.2 리눅스의 전망
__1.2.1 운영체제란 무엇인가?
__1.2.2 우리는 어떤 운영체제를 쓰고 있나?
1.3 리눅스의 역사
__1.3.1 유닉스의 탄생
__1.3.2 1991년: 리누스 토발즈의 등장
__1.3.3 리눅스가 인기 있는 이유는 무엇일까?
1.4 리눅스는 어디에 쓰일까?
__1.4.1 안드로이드
__1.4.2 자동차(AutoMotive)
__1.4.3 사물인터넷(IoT: Internet of Things) 디바이스
1.5 임베디드 리눅스 개발 단체
__1.5.1 리눅스 커널 커뮤니티
__1.5.2 CPU 벤더
__1.5.3 SoC 벤더
__1.5.4 보드 벤더 및 OEM
1.6 임베디드 리눅스 개발을 잘 하려면 무엇을 알아야 할까?
__1.6.1 디바이스 드라이버
__1.6.2 리눅스 커널
__1.6.3 CPU 아키텍처
__1.6.4 빌드 스크립트와 Git
1.7 라즈베리 파이와 리눅스 커널
__1.7.1 라즈베리 파이 실습 보드
__1.7.2 리눅스 커널 버전
__1.7.3 라즈비안 버전
__1.7.4 ARM 아키텍처
1.8 정리

▣ 02장: 라즈베리 파이 설정
2.1 라즈베리 파이란?
2.2 라즈베리 파이 설정
__2.2.1 라즈베리 파이 실습을 위한 준비물
__2.2.2 라즈베리 파이 설치
__2.2.3 라즈베리 파이 기본 설정
2.3 라즈베리 파이 커널 빌드
__2.3.1 라즈비안 버전과 커널 소스 버전
__2.3.2 라즈비안 커널 소스코드 내려받기
__2.3.3 라즈비안 리눅스 커널 빌드
__2.3.4 라즈비안 리눅스 커널 설치
__2.3.5 전처리 코드 생성
__2.3.6 리눅스 커널 소스의 구조
2.4 objdump 바이너리 유틸리티
2.5 라즈베리 파이 사용 시 주의사항
2.6 정리

▣ 03장: 커널 디버깅과 코드 학습
3.1 디버깅이란?
__3.1.1 디버깅은 문제 해결 능력의 지름길
__3.1.2 디버깅과 코드 학습 능력
3.2 printk
3.3 dump_stack() 함수
3.4 ftrace
__3.4.1 ftrace란?
__3.4.2 ftrace는 어떻게 설정할까?
__3.4.3 ftrace 메시지는 어떻게 분석할까?
__3.4.4 ftrace 로그는 어떻게 추출할까?
__3.4.5 ftrace는 커널 코드 분석의 안내자
3.5 임베디드 디버거의 전설 TRACE32
3.6 커널 디버깅용 Debugfs 드라이버 코드
3.7 정리

▣ 04장: 프로세스
4.1 프로세스 소개
__4.1.1 프로세스란?
__4.1.2 태스크란?
__4.1.3 스레드란?
4.2 프로세스 확인하기
__4.2.1 ps 명령어로 프로세스 목록 확인
__4.2.2 ftrace에서 프로세스 확인하기
4.3 프로세스는 어떻게 생성할까?
__4.3.1 _do_fork() 함수 소개
__4.3.2 유저 레벨 프로세스를 생성할 때 _do_fork() 함수의 처리 흐름
__4.3.3 커널 프로세스 생성 시 _do_fork() 함수의 흐름
4.4 유저 레벨 프로세스 실행 실습
__4.4.1 기본 유저 레벨 프로세스 실행 실습 및 ftrace 로그 분석
__4.4.2 exit() 함수로 프로세스가 종료되는 과정 및 ftrace 로그 분석
4.5 커널 스레드
__4.5.1 커널 스레드란?
__4.5.2 커널 스레드의 종류
__4.5.3 커널 스레드는 어떻게 생성할까?
4.6 커널 내부 프로세스의 생성 과정
__4.6.1 _do_fork() 함수
__4.6.2 copy_process() 함수 분석
__4.6.3 wake_up_new_task() 함수 분석
4.7 프로세스의 종료 과정 분석
__4.7.1 프로세스 종료 흐름 파악
__4.7.2 do_exit() 함수 분석
__4.7.3 do_task_dead() 함수 분석
__4.7.4 do_task_dead() 함수를 호출하고 난 후의 동작
4.8 태스크 디스크립터(task_struct 구조체)
__4.8.1 프로세스를 식별하는 필드
__4.8.2 프로세스 상태 저장
__4.8.3 프로세스 간의 관계
__4.8.4 프로세스 연결 리스트
__4.8.5 프로세스 실행 시각 정보
4.9 스레드 정보: thread_info 구조체
__4.9.1 thread_info 구조체란?
__4.9.2 thread_info 구조체 분석
__4.9.3 thread_info 구조체의 주소 위치는 어디일까?
__4.9.4 컨텍스트 정보 상세 분석
__4.9.5 cpu 필드에 대한 상세 분석
__4.9.6 thread_info 구조체 초기화 코드 분석
4.10 프로세스의 태스크 디스크립터에 접근하는 매크로 함수
__4.10.1 current 매크로란?
__4.10.2 current_thread_info() 매크로 함수 분석
4.11 프로세스 디버깅
__4.11.1 glibc의 fork() 함수를 gdb로 디버깅하기
__4.11.2 리눅스 유틸리티 프로그램을 이용한 실행 추적
4.12 정리

▣ 05장: 인터럽트
5.1 인터럽트 소개
__5.1.1 인터럽트란?
__5.1.2 리눅스 커널 인터럽트의 주요 개념
__5.1.3 인터럽트를 잘 알아야 하는 이유
__5.1.4 리눅스 커널에서의 인터럽트 처리 흐름
5.2 인터럽트 컨텍스트
__5.2.1 인터럽트 컨텍스트란?
__5.2.2 ftrace와 커널 로그로 인터럽트 컨텍스트 확인해보기
__5.2.3 in_interrupt() 함수란?
__5.2.4 인터럽트 컨텍스트에서 스케줄링을 하면 어떻게 될까?
5.3 인터럽트 핸들러는 언제 호출될까?
__5.3.1 인터럽트 벡터 분석
__5.3.2. 인터럽트 벡터에서 스택 푸시 확인
__5.3.3. 인터럽트 핸들러의 호출 흐름 분석
5.4 인터럽트 핸들러는 어떻게 등록할까?
__5.4.1 인터럽트 핸들러의 등록 과정 분석
__5.4.2 인터럽트 핸들러의 초기화 과정 디버깅
__5.4.3 인터럽트 핸들러 등록 시 플래그 설정
5.5 인터럽트 디스크립터
__5.5.1 인터럽트 디스크립터란?
__5.5.2 인터럽트 발생 횟수는 어떻게 저장할까?
5.6 인터럽트는 언제 비활성화해야 할까?
5.7 인터럽트 디버깅
__5.7.1 /proc/interrupts
__5.7.2 ftrace 인터럽트 이벤트
__5.7.3 ftrace로 인터럽트 핸들러 함수 파악하기
5.8 정리

▣ 06장: 인터럽트 후반부 처리
6.1 인터럽트 후반부 기법이란?
__6.1.1 인터럽트 후반부 기법을 적용하는 이유
__6.1.2 인터럽트 컨텍스트에서 많은 일을 하면 어떻게 될까?
__6.1.3 Top Half/Bottom Half란?
__6.1.4 인터럽트 후반부 처리 기법의 종류
__6.1.5 어떤 인터럽트 후반부 처리 기법을 적용해야 할까?
6.2 IRQ 스레드(threaded IRQ)
__6.2.1 IRQ란?
__6.2.2 IRQ 스레드 확인
6.3 IRQ 스레드는 어떻게 생성할까?
__6.3.1 IRQ 스레드는 언제 생성할까?
__6.3.2 라즈베리 파이에서 IRQ 스레드 생성 과정 디버깅
6.4 IRQ 스레드는 누가 언제 실행할까?
__6.4.1 IRQ 스레드를 깨우는 코드 분석
__6.4.2 IRQ 스레드 핸들러인 irq_thread() 함수 분석
__6.4.3 IRQ 스레드의 전체 실행 흐름 정리
6.5 IRQ 스레드 디버깅 실습
__6.5.1 ftrace를 이용한 IRQ 스레드 동작 확인
__6.5.2 IRQ 스레드 생성 실습
__6.5.3 IRQ 스레드 처리 함수 실행 시각 측정
6.6 Soft IRQ 소개
__6.6.1 Soft IRQ 서비스란?
__6.6.2 Soft IRQ의 전체 흐름
__6.6.3 후반부 기법으로 Soft IRQ를 언제 쓸까?
__6.6.4 Soft IRQ는 왜 알아야 할까?
6.7 Soft IRQ 서비스
__6.7.1 Soft IRQ 서비스
__6.7.2 Soft IRQ 서비스 핸들러는 언제 등록할까?
__6.7.3 Soft IRQ 서비스 핸들러의 등록 과정 실습
6.8 Soft IRQ 서비스는 언제 요청할까?
__6.8.1 Soft IRQ 서비스 요청의 전체 흐름
__6.8.2 raise_softirq() 함수 분석
__6.8.3 irq_stat 전역변수 분석
__6.8.4 Soft IRQ 서비스를 요청했는지는 누가 어떻게 점검할까?
6.9 Soft IRQ 서비스는 누가 언제 처리할까?
__6.9.1 Soft IRQ 서비스 실행 진입점은 어디일까?
__6.9.2 Soft IRQ 서비스 요청 점검
__6.9.3 Soft IRQ 서비스 실행
__6.9.4 ksoftirqd 스레드 깨우기
6.10 ksoftirqd 스레드
__6.10.1 ksoftirqd 스레드란?
__6.10.2 ksoftirqd 스레드는 언제 깨울까?
__6.10.3 ksoftirqd 핸들러 run_ksoftirqd() 함수 분석
6.11 Soft IRQ 컨텍스트에 대해
__6.11.1 Soft IRQ 컨텍스트 시작점은 어디일까?
__6.11.2 Soft IRQ 컨텍스트는 언제 시작할까?
__6.11.3 Soft IRQ 컨텍스트 확인
6.12 태스크릿
__6.12.1 태스크릿이란?
__6.12.2 태스크릿 자료구조
__6.12.3 태스크릿은 어떻게 등록할까?
__6.12.4 태스크릿의 전체 실행 흐름 파악
__6.12.5 태스크릿 실행 요청은 어떻게 할까?
__6.12.6 태스크릿은 언제 실행할까?
6.13 Soft IRQ 디버깅
__6.13.1 ftrace의 Soft IRQ 이벤트 소개
__6.13.2 /proc/softirqs를 이용한 Soft IRQ 서비스 실행 횟수 확인
6.14 정리

▣ 07장: 워크큐
7.1 워크큐 소개
__7.1.1 워크큐의 주요 개념
__7.1.2 워크큐의 특징
__7.1.3 워크큐와 다른 인터럽트 후반부 기법과의 비교
__7.1.4 워크큐로 인터럽트 후반부 코드를 설계하는 과정
__7.1.5 워크큐를 잘 알아야 하는 이유
7.2 워크큐의 종류
__7.2.1 alloc_workqueue() 함수 분석
__7.2.2 7가지 워크큐
7.3 워크란?
__7.3.1 work_struct 구조체
__7.3.2 워크는 어떻게 초기화할까?
7.4 워크를 워크큐에 어떻게 큐잉할까?
__7.4.1 워크를 워크큐에 큐잉하는 예제 코드 살펴보기
__7.4.2 워크큐 전체 흐름도에서 워크를 워크큐에 큐잉하는 과정
__7.4.3 워크를 워크큐에 큐잉하는 인터페이스 함수 분석
__7.4.4 __queue_work() 함수 분석
__7.4.5 __queue_work() 함수에서 호출하는 워크큐 내부 함수 분석
7.5 워크는 누가 언제 실행하나?
__7.5.1 워크 실행의 출발점인 worker_thread() 함수 분석
__7.5.2 process_one_work() 함수 분석
7.6 워커 스레드란?
__7.6.1 워커와 워커 스레드
__7.6.2 worker 구조체
__7.6.3 워커 스레드는 누가 언제 만들까?
__7.6.4 워커 스레드를 생성하는 create_worker() 함수 분석
__7.6.5 create_worker() 함수에서 호출한 워크큐 커널 함수 분석
__7.6.6 worker_thread() 함수 분석
7.7 워크큐 실습 및 디버깅
__7.7.1 ftrace 워크큐 이벤트
__7.7.2 라즈베리 파이에서 ftrace를 이용한 워크큐 동작 확인
__7.7.3 인터럽트 후반부 처리 실습과 로그 분석
7.8 딜레이 워크
__7.8.1 딜레이 워크란?
__7.8.2 딜레이 워크의 전체 흐름
__7.8.3 딜레이 워크는 어떻게 초기화할까?
__7.8.4 딜레이 워크 실행의 시작점은 어디일까?
__7.8.5 딜레이 워크는 누가 언제 큐잉할까?
7.9 라즈베리 파이에서의 딜레이 워크 생성 실습
__7.9.1 패치 코드의 내용과 작성 방법
__7.9.2 ftrace 로그 설정
__7.9.3 ftrace 로그 분석
7.10 정리