3장. 리눅스커널 디버깅
디버깅이란
ftrace
임베디드 디버거의 전설 Trace32
편하게 커널 코드를 수정할 수 있는 디버깅용 Debugfs 드라이버 코드 소개
4장. 프로세스 관리
4.11 프로세스 디버깅
4.11.1 glibc fork 함수 gdb 디버깅
4.11.2 유저 프로그램 실행 추적
5장 인터럽트 핸들링
6장. 인터럽트 후반부 처리
6.9 Soft IRQ 서비스는 누가 언제 처리하나?
6.13 Soft IRQ 디버깅
6.13.1 ftrace Soft IRQ 이벤트 분석 방법
6.13.2 /proc/softirqs로 Soft IRQ 서비스 실행 횟수 확인
7장. 커널 타이머관리
8장. 워크큐
#Reference 워크큐
워크큐 소개
워크큐 종류 알아보기
워크란
워크를 워크큐에 어떻게 큐잉할까?
워크를 큐잉할 때 호출하는 워크큐 커널 함수 분석
워커 쓰레드란
워크큐 실습 및 디버깅
ftrace로 워크큐 동작 확인
인터럽트 후반부로 워크큐 추가 실습 및 로그 분석
Trace32로 워크큐 자료 구조 디버깅하기
딜레이 워크 소개
딜레이 워크는 누가 언제 호출할까?
라즈베리파이 딜레이 워크 실습 및 로그 확인
9장 커널 동기화 소개
10장 커널 동기화 기법
11장 시스템 콜
12장. 시그널
시그널
시그널이란
시그널 설정은 어떻게 할까
sys_pause() 함수 분석
시그널 생성 과정 함수 분석
유저 프로세스 kill() 함수 실행
유저 프로세스 tgkill()함수 실행
커널은 언제 시그널 생성할까?
__send_signal() 함수 분석
시그널 전달 진입점
ret_fast_syscall 레이블 분석
인터럽트 벡터
시그널 전달과 처리는 어떻게 할까?
get_signal() 함수 분석
handle_signal() 함수 분석
시그널 제어 함수 분석
suspend() 함수
시그널 ftrace 디버깅
ftrace 시그널 기본 동작 로그 분석
ftrace 시그널 핸들러 동작 로그 분석
13장 프로세스 스케줄링
스케줄링 소개
프로세스 상태 관리
프로세스 상태 소개
프로세스 상태 변화
어떤 함수가 프로세스 상태를 변경할까?
TASK_RUNNING(실행 대기)
TASK_RUNNING(CPU 실행)
TASK_INTERRUPTIBLE 상태 변경
TASK_UNINTERRUPTIBLE 상태 변경
프로세스 상태 ftrace로 확인하기
스케줄링 클래스
스케줄링 클래스 자료구조 소개
5가지 스케줄러 클래스란 무엇일까?
프로세스는 스케줄러 클래스를 어떻게 등록할까?
프로세스는 스케줄링 클래스로 스케줄러 세부 함수를 어떻게 호출할까?
런큐
런큐 자료구조 struct rq 소개
runqueues 변수에 대해서
런큐에 접근하는 함수 소개
런큐 자료구조 확인하기
비동기적인 Preemption(선점)
선점 스케줄링(Preemptive Scheduling)이란 무엇일까?
선점 스케줄링 진입점은 어디인가?
선점 스케줄링 발생 시점을 아는 것은 왜 중요할까?
커널 모드 중 인터럽트 발생으로 선점 스케줄링 실행
유저 프로세스 실행 중 인터럽트 발생으로 선점 스케줄링
시스템 콜 실행이 끝난 후 선점 스케줄링
비동기적 선점을 지연하는 방법: preempt_disable()/preempt_enable()
프로세스는 어떻게 깨울까?
프로세스를 깨운다는 것을 무엇을 의미할까?
프로세스를 깨울 때 호출하는 함수
프로세스를 런큐에 Enqueue하는 흐름
스케줄링 핵심 schedule() 함수 분석
컨택스트 스위칭
컨택스트 스위칭이란 무엇인가?
컨택스트 스위칭 자료구조는 무엇일까?
스케줄링 디버깅
ftrace: sched_switch와 sched_wakeup 이벤트 소개
sched_switch/sched_wakeup 이벤트 출력 함수 코드 분석
스케줄링과 프로세스를 깨울 때 콜스택 파악
비선점 스케줄링 콜스택 파악
스케줄링 프로파일링
14장 가상 파일시스템
15장 메모리 관리
==========================================================
<Final Progress>
1.1 리눅스의 역사
1.2 운영체제 점유율
1.3 리눅스가 인기가 있는 이유는 무엇인가
1.4 리눅스는 어디에 쓸까
1.5 리눅스 개발 단체
1.6 리눅스 커널은 왜 알아야 할까
1.7 리눅스 커널의 구조
1.8 정리
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.4 라즈베리파이에서 objdump 바이너리 유틸리티 써보기
2.5 정리
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.5 임베디드 디버거 전설 Trace32
3.6 정리
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 부모 자식 프로세스 생성 실습 및 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 태스크 디스크립터(struct task_struct)
4.8.1 프로세스를 식별하는 필드
4.8.2 프로세스 상태 저장
4.8.3 프로세스 간 관계
4.8.4 프로세스 연결 리스트
4.9 스레드 정보: struct thread_info
4.9.1 struct thread_info 구조체 소개
4.9.2 struct thread_info 구조체 분석하기
4.9.3 struct thread_info 구조체 주소 위치는 어디일까?
4.9.4 컨택스트 정보 상세 분석
4.9.5 int cpu 필드 상세분석
4.9.6 struct thread_info 초기화 코드 분석
4.10 프로세스 태스크 디스크립터 접근 매크로 함수
4.10.1 current_thread_info() 매크로 함수 분석하기
4.10.2 current 매크로란
4.11 프로세스 디버깅
4.11.1 glibc fork() 함수를 gdb으로 디버깅하기
4.11.2 유저 프로그램 실행 추적
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 정리
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 스레드(threaded 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.5 Soft IRQ 소개
6.5.1 Soft IRQ는 왜 알아야 할까?
6.5.2 Soft IRQ 서비스란
6.5.3 Soft IRQ 전체 흐름도 소개
6.5.4 후반부 기법으로 Soft IRQ는 언제 쓸까?
6.6 Soft IRQ 서비스
6.6.1 Soft IRQ 서비스 알아보기
6.6.2 Soft IRQ 서비스 핸들러는 언제 등록할까?
6.6.3 라즈베리파이에서 Soft IRQ 서비스 핸들러 등록 파악
6.7 Soft IRQ 서비스는 언제 요청하나?
6.7.1 Soft IRQ 서비스 요청 전체 흐름도
6.7.2 raise_softirq() 함수 분석
6.7.3 irq_stat 전역 변수 분석
6.7.4 Soft IRQ 서비스를 요청했는지는 누가 어떻게 점검할까?
6.8 Soft IRQ 서비스는 누가 언제 처리하나?
6.8.1 Soft IRQ 서비스 실행 진입점는 어디일까?
6.8.2 Soft IRQ 서비스 요청 점검
6.8.3 Soft IRQ 서비스 실행
6.8.4 ksoftirqd 스레드 깨우기
6.9 ksoftirqd 스레드
6.9.1 ksoftirqd 스레드란
6.9.2 ksoftirqd 스레드는 언제 깨울까?
6.9.3 ksoftirqd 핸들 run_softirqd() 함수 분석
6.10 Soft IRQ 컨택스트에 대해서
6.10.1 Soft IRQ 컨택스트 시작점은 어디인가?(83~84)
6.10.2 Soft IRQ 컨택스트는 언제 시작할까?
6.10.3 Soft IRQ 컨택스트 확인방법
6.11 태스크릿
6.11.1 태스크릿은 무엇일까?
6.11.2 태스크릿 자료구조 알아보기
6.11.3 태스크릿은 어떻게 등록할까?
6.11.4 태스크릿 전체 실행 흐름 파악하기
6.11.5 태스크릿 실행 요청은 어떻게 할까?
6.11.6 태스크릿은 언제 실행할까?
6.12 Soft IRQ 디버깅
6.12.1 ftrace Soft IRQ 이벤트 소개
6.12.2 /proc/softirqs로 Soft IRQ 서비스 실행 횟수 확인
6.13 정리
7.1 워크큐 소개
7.1.1 워크큐 주요 개념 알아보기
7.1.2 워크큐의 특징은 무엇인가
7.1.3 워크큐를 다른 인터럽트 후반부 기법과 비교해보기
7.1.4 워크큐를 잘 알아야 하는 이유
7.2 워크큐 종류 알아보기
7.2.1 alloc_workqueue() 함수 분석하기
7.2.2 7가지 워크큐를 알아보기
7.3 워크란
7.3.1 struct 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_on() 함수에서 호출하는 워크큐 내부 함수 분석하기
7.5 워크는 누가 언제 실행하나?
7.5.1 워크 실행의 출발점인 worker_thread() 함수 분석
7.5.2 process_one_work() 함수 분석
7.6. 워커 스레드란
7.6.1 워커와 워커 스레드란
7.6.2 워커 자료구조인 struct 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 정리
8.1 커널 타이머 관리 주요 개념 소개
8.1.1 HZ란 무엇인가
8.1.2 Soft IRQ TIMER_SOFTIRQ 서비스
8.1.3 커널 타이머와 동적 타이머란 무엇인가
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 동적 타이머 자료구조 struct list 소개
8.4.3 동적 타이머 초기화 함수 소개
8.5 동적 타이머 등록하기
8.5.1 동적 타이머 등록 전체 흐름 소개
8.5.2 동적 타이머 등록 과정 주요 함수 분석
8.5.3 동적 타이머 등록 과정 세부 커널 타이머 함수 분석
8.6 동적 타이머는 누가 언제 실행하나?
8.6.1 커널 타이머 실행 전체 흐름도 알아보기
8.6.2 커널 타이머 실행 시작 단계 코드 분석
8.6.3 Soft IRQ 타이머 서비스 실행 시작 단계 코드 분석
8.6.4 등록된 동적 타이머 실행 단계 코드 분석
8.7 라즈베리파이 커널 타이머 실습 및 로그 분석
8.7.1 ftrace 동적 타이머 디버깅 이벤트 소개
8.8 정리
9.1 커널 동기화 기본 개념 소개
9.1.1 임계영역(Critical Section)과 레이스 컨디션이란(2~4)
9.1.2 레이스 컨디션은 왜 발생할까?(4~6)
9.1.3 레이스 컨디션 커널 패치 (6~11)
9.2 레이스 발생 동작 확인
9.2.1 유저 프로세스 시스템 콜 호출 시 레이스 컨디션(11~21)
9.2.2 커널 프로세스 레이스 컨디션(22~30)
9.2.3 인터럽트 발생으로 레이스 컨디션 발생(30~41)
9.3 커널 동기화 기법 소개
9.3.1 스핀락과 뮤텍스 기법 소개(41~43)
9.3.2 스핀락과 뮤텍스 기법 차이점 알아보기(43~45)
9.4. 스핀락
9.4.0 스핀락의 특징은 무엇인가(45~47)
9.4.1 스핀락 자료구조 알아보기(47~50)
9.4.2 스핀락 처리 흐름도 알아보기(50~53)
9.4.3 spin_lock() 함수 인라인 어셈블리 코드 분석(53~60)
9.4.4 spin_lock() 함수 어셈블리 코드 분석(60~65)
9.4.5 spin_unlock() 함수 분석(65~67)
9.4.6 스핀락 플러그인 함수: spin_lock_irq()/spin_unlock_irq() (67~72)
9.4.7 스핀락 플러그인 함수:
spin_lock_irqsave()/spin_unlock_irqrestore(72~77)
9.5 뮤텍스란
9.5.1 뮤텍스의 기본 개념 소개하기(77~80)
9.5.2 뮤텍스 fastpath 동작(81~83)
9.5.3 뮤텍스 slowpath: mutex_lock() 함수 분석(83~88)
9.5.4 뮤텍스 slowpath: mutex_unlock() 함수 분석(88~92)
9.6 커널 동기화 디버깅
9.6.1 스핀락(92~98)
9.6.2 뮤텍스 디버깅(98~105)
9.7 정리
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.3 스케줄러 클래스
10.3.1 스케줄링 클래스 자료구조 소개
10.3.2 5가지 스케줄러 클래스란 무엇일까?
10.3.3 프로세스는 스케줄러 클래스를 어떻게 등록할까?
10.3.4 프로세스는 스케줄링 클래스로 스케줄러 세부 함수를 어떻게 호출할까?
10.4 런큐
10.4.1 런큐 자료구조 struct 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.3.1 타임 슬라이스 관리
10.5.3.2 vruntime 관리 세부 함수 분석
10.5.4 vruntime을 ftrace로 확인하는 실습 따라해보기
10.6 선점 스케줄링(Preemptive Scheduling)
10.6.1 선점 스케줄링(Preemptive Scheduling)이란 무엇일까?
10.6.2 선점 스케줄링 진입점은 어디인가?
10.6.3 선점 스케줄링 발생 시점을 아는 것은 왜 중요할까?
10.6.4 선점 스케줄링 진입점: 커널 모드 중 인터럽트 발생
10.6.5 선점 스케줄링: 유저 프로세스 실행 중 인터럽트가 발생
10.6.6 선점 스케줄링 진입점: 유저 프로세스가 시스템 콜 처리를 마무리한 후
10.6.7 선점 스케줄링 지연 함수 preempt_enable()/preempt_disable() 소개
10.7 프로세스는 어떻게 깨울까?
10.7.1. 프로세스를 깨운다는 것은 무엇을 의미할까?
10.7.2 프로세스를 깨울 때 호출하는 함수
10.7.3 깨우는 프로세스를 런큐에 Enqueue 동작
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.10.3.1 CPU에 부하를 주는 테스트
10.10.3.2 CPU에 부하를 주지 않는 테스트
10.11. 정리
11.1 시스템 콜 주요 개념 소개
11.1.1 시스템 콜 소개 2-3
11.1.2 시스템 콜 세부 전체 흐름도와 계층 4-5
11.1.3 시스템 콜의 특징 알아보기 5-6
11.1.4 ARM 프로세서 관점 시스템 콜 처리 6-10
11.1.5 시스템 콜 테이블이란 10-12
11.2 유저 공간에서 시스템 콜은 어떻게 발생할까
11.2.1 GNU C 라이브러리 실행 흐름 13-14
11.2.2 유저 공간 시스템 콜 발생 어셈블리 코드 분석 14-17
11.3 커널 모드에서 시스템 콜을 어떻게 실행할까?
11.3.1 소프트웨어 인터럽트 벡터 vector_swi 는 어떻게 실행될까? 18-19
11.3.2 소프트웨어 인터럽트 벡터 vector_swi 코드 분석 19-26
11.3.3 커널 공간에서 시스템 콜 테이블 확인하기 27-29
11.4 시스템 콜 핸들러는 어떤 동작을 할까?
11.4.1 시스템 콜 종류별 시스템 콜 핸들러 동작 29-29
11.4.2 매개 변수 점검 30-34
11.5 시스템 콜 실행 완료 후 무슨 일을 할까?
11.5.1 ret_fast_syscall 레이블 복귀 과정 알아보기 35-35
11.5.2 ret_fast_syscall 레이블 전체 흐름도 36-36
11.5.3 시그널 전달 및 스케줄링 실행 조건 점검 37-40
11.5.4 유저 공간으로 복귀 40-41
11.6. 시스템 콜 관련 함수 41
11.6.1 SYSCALL_DEFINEx 매크로 분석 41-43
11.6.2 전처리 코드에서 시스템 콜 핸들러 확인하기 43-44
11.7 시스템 콜 디버깅 44
11.7.1 ftrace 시스템 콜 이벤트 소개하기 44-48
11.7.2 ftrace 시스템 콜 핸들러 콜 스택 확인해보기 48-51
11.7.3 strace로 시스템콜 디버깅하기 51-55
11.7.4 strace와 ftrace를 함께 시스템 콜 디버깅하기 55-57
12.1 시그널이란
12.1.1 유저 프로세스 입장에서 시그널이란
12.1.2 시그널 번호와 동작 알아보기
12.1.3 시그널을 받으면 프로세스는 어떻게 동작할까?
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.3 커널은 언제 시그널 생성할까?
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 시그널 핸들러 동작 로그 분석
13.1 가상 파일시스템 소개
13.1.1 가상 파일 시스템이란
13.1.2 가상 파일시스템 공통 모델
13.1.3 함수 오퍼레이션
13.1.4 유저 프로세스 입장에서 파일 처리
13.1.5 파일시스템별 파일 함수 오퍼레이션 처리 과정
13.2 파일 객체
13.2.1 struc 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 struct super_block 구조체 분석
13.5.3 슈퍼 블록 함수 오퍼레이션
13.5.4 슈퍼 블록 파일 오퍼레이션 관련 시스템 콜
13.5.5 슈퍼블록 정보를 statfs 시스템 콜로 읽는 과정
13.6 아이노드 객체
13.6.1 struct inode 구조체 분석
13.6.2 아이노드 함수 오퍼레이션
13.6.3 파일 속성을 읽는 stat 시스템 콜 처리 과정 분석하기
13.7 덴트리 객체
13.7.1 덴트리 객체 소개
13.7.2 struct dentry 구조체 분석
13.8 가상 파일시스템 디버깅
13.8.1 파일 객체 함수 오퍼레이션 확인하기
13.8.2 슈퍼블록 객체 함수 오퍼레이션 확인하기
13.8.3 아이노드 객체 함수 오퍼레이션 확인하기
13.9 정리
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.1 메모리 존(Zone) 종류와 개념 소개
14.3.2 메모리 존 자료구조 struct zone 분석하기
14.4.1 동적 메모리와 정적 메모리 할당 소개
14.4.2 kmalloc() 함수를 쓰는 이유
14.4.3 kmalloc() 함수 소개
14.4.4 gfp 플래그 소개
14.4.5 kmalloc() 함수를 호출할 때 주의 사항
14.5.1 슬랩(Slab) 메모리의 주요 개념
14.5.2 kmalloc-size 슬랩 캐시 알아보기
14.5.3 슬럽 할당 세부 함수 분석하기
14.6 디버깅
14.6.1 ftrace로 메모리 할당 해제 확인하기
14.6.2 가상주소를 물리주소로 변환하는 과정 확인하기
14.6.3 kmalloc() 함수로 메모리 할당 후 슬럽 종류 확인하기
14.7 정리
최근 덧글