목차 일부

▣ 08장: 커널 타이머 관리
8.1 커널 타이머(저해상도 타이머)의 주요 개념 
___8.1.1 HZ란? 
 ___8.1.2 Soft IRQ의 타이머 서비스란? 
 ___8.1.3 Soft IRQ 타이머(TIMER_SOFTIRQ) 서비스와 동적 타이머란? 
 ___8.1.4 커널이 실행 시각을 관리하는 방식을 왜 잘 알아야 할까? 
 ___8....

더보기

목차 전체

▣ 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 개발자 간의 의사소통과 개발 문화

더보기 닫기