(38)

38페이지의 13번째 줄 

세 매개 1수의 의미는
-> 세 매개변수의 의미는
으로 수정합니다. 

(2장 64페이지 표2-3 아래)

커널은 __KERNEL 매크로에 의해 만들어진 값을
-->
커널은 __KERNEL_CS 매크로에 의해 만들어진 값을 

((68))

각 프로세스마다 220개의 엔트리를 포함하는~ 내용을

각 프로세스마다  2^20으로 수정함.

(68)

각 프로세스마다 220개의 엔트리를 포함하는

 => 

각 프로세스마다 2^20 개의 엔트리를 포함하는 

(73 페이지 맨 아래 단락, 첫 번째 항목)

램 64GB를 개별 페이지 프레임 224개로 나누고,
-->
램 64GB를 개별 페이지 프레임 2^24개로 나누고, 

(3쇄 74페이지 첫째줄)

'32바이트(25)의 배수로'를

'32바이트(2^5)의 배수로'로 수정함.

(81페이지 3번째 줄)

LARGE_PAGE_SIZE는 PMD_SIZE(2PMD_SHIFT)와 동일하다.
-->
LARGE_PAGE_SIZE는 PMD_SIZE(2^PMD_SHIFT)와 동일하다.

(81페이지 PUD_SHIFT 설명)

PUD_SIZE 매크로는 전역 디렉토리의 엔트리..
-->
PUD_SIZE 매크로는 상위 디렉토리의 엔트리..


PUD_MASK 매크로는 오프셋과 테이블, 중간 디렉토리 및 상위 디렉토리 필드를 모두 마스크한다.
-->
PUD_MASK 매크로는 오프셋과 테이블, 중간 디렉토리 필드를 모두 마스크한다.

(81페이지 PGDIR_SHIFT 설명)

PGDIR_MASK 매크로는 오프셋과 테이블, 중간 디렉토리 필드를 모두 마스크한다.
-->
PGDIR_MASK 매크로는 오프셋과 테이블, 중간 디렉토리 및 상위 디렉토리 필드를 모두 마스크한다.

(81페이지 중간)

PTRS_PER_PTE, PTRS_PER_PMD, PTRS_PER_PGD
-->
PTRS_PER_PTE, PTRS_PER_PMD, PTRS_PER_PUD, PTRS_PER_PGD

((p 81) 페이지 테이블 다루기 두번째줄)

PAE 기능을 사용할 때 32비트의 데이터 타입이고, 사용하지 않을 때는 64비트의 데이터 타입이다.

32 => 64
64 => 32

((81페이지 중간))

PTRS_PER_PVD를 PTRS_PER_PUD로 수정함.

(82페이지 중간)

pte_bad()라는 매크로는 없는데, ...
-->
pte_bad라는 매크로는 없는데, ...

(84페이지 표 2-7 pmd_offset 설명)

페이지 중간 디렉토리에서 addr 에 해당하는 엔트리의...
-->
페이지 중간 디렉토리에서 addr에 해당하는 엔트리의...

(84페이지 표 2-7 pte_offset_map 설명)

pte_offset_ map_nested과 pte_unmap_nested는...
-->
pte_offset_map_nested와 pte_unmap_nested는...

(85페이지 표 2-8 pte_alloc_kernel 설명)

페이지 중간 디렉토리에서 주소 addr에 해당하는 엔트리 pmd NULL이면
-->
페이지 중간 디렉토리에서 주소 addr에 해당하는 엔트리 pmd가 NULL이면

(86페이지 맨 아래 문단 첫번째 줄)

나중에 커널은 setup_memory_region() 함수를 실행하는데,
-->
나중에 커널은 machine_specific_memory_setup() 함수를 실행하는데,

((87페이지, 표 2-10 내 두번째 줄])

가장 사용하기 좋은 페이지 프레임 번호
->
마지막 페이지 프레임의 번호

(88페이지 그림 2-13)

[그림 2-13] 리눅스 2.6에서 처음 512개(2MB)의 페이지 프레임
->
[그림 2-13] 리눅스 2.6에서 처음 768개(3MB)의 페이지 프레임

(93페이지 첫번째 줄)

zap_low_mapping 함수를 호출하여
-->
zap_low_mappings 함수를 호출하여

(15번째 줄)

X_PAGE_OFFSET(3G)으로 매핑한다
->
X-PAGE_OFFSET(3G)으로 매핑한다

(첫 번째 문단 끝에서 두번째 줄)

결론적으로 컴파일러는 0xffffe000-(3<<PAGE_SHIFT)값을 계산해서
-->
결론적으로 컴파일러는 0xfffff000-(3<<PAGE_SHIFT)값을 계산해서

(100 페이지 맨 아래 줄)

스레드 그룹에 대해서는 이  장의 후반부에서 상세히 다룬다.
->
스레드 그룹에 대해서는 이 장의 후반부에서 상세히 다룬다.

((p 105,106) 현재 프로세스를 구별하기)

p 105 => 사실상 thread_info......
p 106 두번째줄=> 한편 thread_info.....

thread_info => thread_union

((p 112) 첫번째 단락)

PID가 2,890과 29,384....

2,890 => 199

(112 페이지, 그림 3-5)

PID hash table 왼쪽의 숫자에서
1466 -> 1465

오른쪽 상자에서
PID 199 -> PID 2890 

(116 페이지 대기큐 처리 밑 5번째 줄)

init_waitqueue_head(q, p) 함수는...
-->
init_waitqueue_entry(q, p) 함수는...

(세 번째 문단 두 번째 줄)

예를 들어, wait_event_(wq, condition) 매크로는 
-->
예를 들어, wait_event(wq, condition) 매크로는 

(119 페이지 5번째 단락)

wake_up_locked 매크로는 ... 는 것을 제외하고는 wak_up과 비슷하다.
-->
wake_up_locked 매크로는 ... 는 것을 제외하고는 wake_up과 비슷하다.

(120 페이지 두번째 문단)

자원 제한은 프로세스 시그널 디스크립터의 current->signal → rlim 필드에 저장된다.
-->
자원 제한은 프로세스 시그널 디스크립터의 current->signal->rlim 필드에 저장된다.

(switch_to 매크로 아래 첫번째 문단)

이 매크로는 커널에서 가장 의존적인 하드웨어 
-->
이 매크로는 커널에서 가장 하드웨어 의존적인 

(128 - 129 페이지 8번 항목)

io_bitmap 필드
-->
io_bitmap_base 필드

(두 번째 문단)

TSS의 io_bitmap 필드는 TSS 내에서 비트맵이 저장된 위치 값을 가지고 있다. 0x8000과 0x9000이 TSS 범위를 벗어나면 사용자 모드 프로세스가 입출력 포트를 접근할 때마다 "일반 보호" 예외가 발생할 것이다.
-->
TSS의 io_bitmap_base 필드는 TSS 내에서 비트맵이 저장된 위치 값을 가지고 있어야 한다. 0x8000과 0x9000값은 TSS의 범위를 벗어나기 때문에 사용자 모드 프로세스가 입출력 포트를 접근할 때마다 "일반 보호" 예외가 발생할 것이다.

(다섯 번째 문단)

_switch_to()가 수행되는 동안 eax 값은 보존되어야 한다.
-->
__switch_to()가 수행되는 동안 eax 값은 보존되어야 한다.

(중간 제목)

FUP 레지스터 로딩하기
-->
FPU 레지스터 로딩하기

(ptid 항목)

새 경량 프로세스의 PID가 저장된 부모 프로세스의 사용자 모드 변수의 주소를 지정한다.
-->
새 경량 프로세스의 PID를 저장할 부모 프로세스의 사용자 모드 변수의 주소를 지정한다.

(첫 번째 문단)

이 함수는 다음과 같은 단계를 수행한다.
-->
이 함수는 다음과 같은 매개 변수를 받는다. 

(reg 항목)

사용자 모드에서 커널 모드로 전환할 때 커널 모드 스택에 저장될 범용 레지스터 값의 포인터이다.
-->
사용자 모드에서 커널 모드로 전환할 때 커널 모드 스택에 저장"된" 범용 레지스터 값의 포인터이다.

(do_fork 함수 2번 과정)

값이 0이 아니므로 부모 프로세스가 다른 프로세스에 의해 추적되고 있으면 do_fork() 함수는 디버거가 부모 프로세스의 CLONE_PTRACE 플래그와 상관없이 자식 프로세스를 추적하기 원하는지 확인한다.
-->
값이 0이 아니라면 부모 프로세스가 다른 프로세스에 의해 추적되고 있으므로 do_fork() 함수는 부모 프로세스가 CLONE_PTRACE 플래그를 지정했는지와 상관없이 디버거가 자식 프로세스를 추적하기 원하는지 확인한다.

(3.c 과정)

그리고 TI 지역 변수에 메모리 영역 주소를 저장한다.
-->
그리고 ti 지역 변수에 메모리 영역 주소를 저장한다.

(4번 과정)

...에 저장된 값이 사용자가 소유한 프로세스들의 현재 값 이하인지를 확인하고,
-->
...에 저장된 값이 사용자가 현재 소유한 프로세스들의 개수보다 작은지를 확인하고, 

((3장프로세스, 139페이지))

139페이지의 

8번의 a항목을 

큰 커널 락카운트(Lock Counter) task->did_exec

에서  큰 커널 락카운트(Lock Counter) task->lock_depth로 수정함.

(3장프로세스, 139페이지)

a. 큰 커널 락카운트(Lock Counter) task->did_exec

=>

a. 큰 커널 락카운트(Lock Counter) task->lock_depth

(3번째 문단 5번째 줄)

최근의 마더보드는 칩의 양쪽 기능을 모두 가지고 있다.
-->
최근의 마더보드는 두 가지 타입의 칩을 모두 가지고 있다. 

(156페이지 (19번 항목))

"SIMD 부동 소수점 예외" (중단)
을 "SIMD 부동 소수점 예외" (폴트)로 수정함.

(12번 항목)

"스택 세그먼트(Stack Segment)" (폴트)
-->
"스택 세그먼트 폴트(Stack Segment Fault)" (폴트)

(맨 아래 주석)

... 저장할 수 없을 때에도 예외를 발생시킨다
-->
... 저장할 수 없을 때에도 이 예외를 발생시킨다

(19번 항목)

"SIMD 부동 소수점" (중단)
-->
"SIMD 부동 소수점 예외" (폴트)

(표 4-1)

12번.
스택 세그먼트 --> 스택 세그먼트 폴트

19번
SIMD 부동 소수점 --> SIMD 부동 소수점 예외 

(3번째 문단)

기본 선형 주소와 범위(최대 길이)가 들어간다.
-->
기본 물리 주소와 범위(최대 길이)가 들어간다.

(158 페이지)

테스크 게이트
-->
태스크 게이트

(162-163 페이지)

162, 밑에서 세 번째 문단
인텔은 테스크와
-> 
인텔은 태스크와

163p. 세 번째 항목
테스크 게이트
-> 
태스크 게이트

(163 페이지 4번째 문단)

대부분의 예외 핸들러를 테스크 게이트를 통해 실행한다.
-->
이중 폴트 예외 핸들러를 태스크 게이트를 통해 실행한다. 

(206 페이지 커널 선점 아래 첫번째 항목)

하지만 커널 모드에서 동작중인 프로세스가 프로세스 전환을 유도하는 비동기적 사건(예를 들어 우 선순위가 높은 프로세스를 깨우는 인터럽트 핸들러)에 반응하는 방식은 비선점형 커널과는 다르다.
-->
하지만 커널 모드에서 동작 중인 프로세스가 프로세스 전환을 유도하는 비동기적 사건(예를 들어 우선순위가 높은 프로세스를 깨우는 인터럽트 핸들러)에 반응하는 방식은 선점형 커널과 비선점형 커널에서 다르다.

(207 페이지 표 5-1 바로 위)

[표 5-1]에 열거된 몇 가지 간단한 매크로는 필드에서 선점 카운트를 처리한다.
-->
[표 5-1]에 열거된 몇 가지 간단한 매크로는 preempt_count 필드에서 선점 카운트를 처리한다. 

(208 페이지 맨 아래)

많은 CPU가 같은 시각에 커널 코드를 수행하거나
-->
많은 CPU가 동시에 커널 코드를 수행할 수 있기 때문에 

(CPU당 변수 아래 3번째 문단)

만 이것은 두 CPU 이상에 걸쳐있는 자료가 논리적으로 나뉘어 질수 있는 특별한 경우에만 CPU당 변수가 사용될 수 있음을 의미한다.
-->
하지만 이것은 데이터를 시스템 상의 각 CPU 마다 논리적으로 분리할 수 있는 특별한 경우에만 CPU당 변수가 사용될 수 있음을 의미한다. 

(210 페이지 CPU당 변수 아래 4번째 문단)

그래서 CPU당 배열에 동시에 접근하는 것은 캐시라인 스누핑이나 무효값을 초래하는데, 이것은 시스템 능률을 떨어뜨린다.
-->
그래서 CPU당 배열에 동시에 접근하는 것은 시스템 능률을 떨어뜨릴 수 있는 캐시라인 스누핑이나 무효화를 초래하지 않는다.

(원자적인 연산 아래 2번째 문단)

먼저 두 CPU는 동일한 메모리 위치를 읽으려고 시도하면
-->
먼저 두 CPU가 동일한 메모리 위치를 읽으려고 시도하면

(원자적인 연산 아래 2번째 문단)

다음으로 두 CPU 모두 똑같은 값을 해당 메모리 위치에 사용한다.
-->
다음으로 두 CPU 모두 똑같은 값을 해당 메모리 위치에 기록하려고 한다.

(214 페이지 맨 아래 문단)

스택의 맨 위에 있는 메모리 위치에 0을 추가한다.
-->
스택의 맨 위에 있는 메모리 위치의 값에 0을 더한다. 

(표 5-7 제목)

스핀 락 함수
-->
스핀 락 매크로 

(216쪽 (표 5-7 제목))

표 5-7의 제목을 

'스핀 락 함수'에서 '스핀 락 매크로'로 수정함

(2번째 줄)

스핀락
-->
스핀 락 

(1번 항목)

preempt_disable() 함수를 호출한다.
-->
preempt_disable() 매크로를 호출한다. 

(217 페이지 4번 항목)

preempt_enable() 함수를 호출한다.
-->
preempt_enable() 매크로를 호출한다. 

(6번 항목)

cpu_relax() 매크로는 정지 어셈블리어 명령어로 바뀐다.
-->
cpu_relax() 매크로는 pause 어셈블리어 명령어로 바뀐다.

===========================

정지 명령어는 80x86 프로세서의 이전 모델과 호환을 유지한다.
-->
pause 명령어는 80x86 프로세서의 이전 모델과 호환을 유지한다. 

(주석 3))

대부분의 경우(스핀 락이 자유롭다)
-->
대부분의 경우(스핀 락이 열려 있다) 

(2번째 문단 2번째 줄)

테스트는 기호 플래그에 대해 실시한다.
-->
테스트는 부호 플래그에 대해 실시한다. 

(218 페이지 4번째 문단)

그리고 preempt_enable() 함수를 호출한다(커널 선점이 지원되지 않는다면 함수는 아무것도 하지 않는다).
-->
그리고 preempt_enable() 매크로를 호출한다(커널 선점이 지원되지 않는다면 매크로는 아무것도 하지 않는다). 

(맨아래 문단)

spin_lock() 함수와 같은 역할을 한다.
-->
spin_lock() 매크로와 같은 역할을 한다. 

(220 페이지 1번째 문단)

락 필드(읽기/쓰기 락 카운트)는 원자적인 작업에 의해 접근된다. 하지만 전체 함수는 카운트에 대해 원자적으로 동작하지 않는다. 예를 들어 if 문으로 카운터 값을 테스트 한 후 1을 반환하기 전에 카운트 값이 바뀔 수 있다.
-->
lock 필드(읽기/쓰기 락 카운터)는 원자적인 작업에 의해 접근된다. 하지만 전체 함수는 카운터에 대해 원자적으로 동작하지 않는다. 예를 들어 if 문으로 카운터 값을 테스트 한 후 1을 반환하기 전에 카운터 값이 바뀔 수 있다.

(1번째 문단)

사실 함수는 값을 줄이기 전에 카운터가 0이나 음수가 아니면 1을 반환한다.
-->
사실 함수는 값을 줄이기 전에 카운터가 0이 아니거나 음수인 경우에만 1을 반환한다. 

(마지막 줄)

이후 매크로는 preempt_enable() 함수를 호출한다.
-->
이후 매크로는 preempt_enable() 매크로를 호출한다. 

(220 (1번째 문단))

'사실 함수는 값을 줄이기 전에 카운터가 0이나 음수가 아니면 1을 반환한다.'를

'사실 함수는 갑을 줄이기 전에 카운터가 0이 아니거나 음수인 경우에만 1을 반환한다'
로 수정함.

(seqlocks 아래)

비슷한 쓰기 경로는 읽기 경로가 끝낼 때까지 기다려야 한다.
-->
마찬가지로 쓰기 경로는 읽기 경로가 끝날 때까지 기다려야 한다. 

(맨 아래 문단)

리눅스 2.6에서 소개된 Seqlocks는
-->
리눅스 2.6에 추가된 seqlock은 

(222 페이지 2번째 문단)

첫 번째 함수는 seqlock_t 자료 구조에서 스핀 락을 획득하고 순서 카운터를 1 감소시키며, 두 번째 함수는 순서 카운터를 1 증가시키고 스핀 락을 해지시킨다.
-->
첫 번째 함수는 seqlock_t 자료 구조에서 스핀 락을 획득하고 순서 카운터를 1 증가시키며, 두 번째 함수는 순서 카운터를 다시 1 증가시키고 스핀 락을 해지시킨다.

(3번째 문단 1번 항목)

포인터에 의해 동적으로 할당되고 참조되는 유일한 자료 구조는 RCU에 의해 보호될 수 있다.
-->
오직 동적으로 할당되고 포인터를 통해 참조하는 자료 구조 만이 RCU에 의해 보호될 수 있다. 

(2번째 문단 1번째 줄)

콜백 함수를 위한 CPU 리스트에 디스크립터를 추가한다.
-->
콜백 함수를 위한 CPU당 리스트에 디스크립터를 추가한다. 

(2번째 문단)

하지만 한 CPU에서 동작중인 프로세스들이 세마포어 자료 구조에서 다른 CPU를 위한 필드들을 수정하는 것을 막기 위해 __down() 함수는 대기 큐 스핀 락을 사용한다.
-->
하지만 __down() 함수는 semaphore 자료 구조의 다른 필드들을 보호하기 위해서도 대기 큐 스핀 락을 사용한다. 따라서 다른 CPU에서 실행 중인 어떤 프로세스도 이 필드들을 읽거나 변경할 수 없다. 

(2번째 문단)

__down() 함수는 끝까지 대기 큐 함수의 "_locked" 버전을 사용하는데
-->
이 때문에 __down() 함수는 대기 큐 함수의 "_locked" 버전을 사용하는데

(4번째 문단)

local_irq_save와 loca_irq_restore 매크로에 의해 각각 이루어진다.
-->
local_irq_save와 local_irq_restore 매크로에 의해 각각 이루어진다. 

(3번째 문단)

local_bh_disable 매크로는 지역 CPU의 소프트 IRQ에 1을 더하고, local_bh_enable 매크로는 1 뺀다.
-->
local_bh_disable 매크로는 지역 CPU의 소프트 IRQ 카운터에 1을 더하고, local_bh_enable 매크로는 1을 뺀다.

(5번째 문단 1번 항목)

하드 IRQ 카운터와 소프트 IRQ를 검사한다.
-->
하드 IRQ 카운터와 소프트 IRQ 카운터를 검사한다. 

(232 페이지 5번째 문단 2번 항목)

(이장 앞에 나온 "커널 선점" 참고)
-->
(이 장 앞에 나온 "커널 선점" 참고) 

(233 페이지 2번째 문단 2번째 항목)

(9장의 "시스템 콜 핸들러와 서비스 루틴" 참고)
-->
(10장의 "시스템 콜 핸들러와 서비스 루틴" 참고) 

(3번째 문단)

같은 CPU에서 실행중인 다른 프로세스가 세마포우를 획득하려고 시도할수 있다.
-->
같은 CPU에서 실행 중인 다른 프로세스가 세마포어를 획득하려고 시도할 수 있다.

(밑에서 2번째 문단)

대형 커널 락을 가진 프로세스가 선점 당할 때 임계 영역에서 코드를 수행하는 프로세스가 자발적으로 프로세스 전환을 하지 않기 때문에 schedule() 함수가 세마포어를 풀어준다.
-->
대형 커널 락을 가진 프로세스가 선점된다면 임계 영역에서 코드를 수행하는 프로세스가 자발적으로 프로세스 전환을 한 것이 아니기 때문에 schedule() 함수가 세마포어를 해지시켜서는 안 된다. 

(243 페이지 3번째 문단)

(뒤에 나오는 "time(), ftime(), gettimeofday() 시스템 콜과 지연 함수"을 참고)
-->
(뒤에 나오는 "time(), ftime(), gettimeofday() 시스템 콜과 지연 함수" 참고) 

(244 페이지 실시간 시계 4번째 문단)

'Clock' 유닉스 시스템 프로그램을 실행하여 
-->
'clock' 유닉스 시스템 프로그램을 실행하여

(4번째 문단)

PC에서 tick_sec는 999,848나노초로 초기화된다.
-->
PC에서 tick_nsec는 999,848나노초로 초기화된다. 

(주석 1)

나누기 연산으로 상위 비트를 날리는 것을 막기 위해
-->
정수 나누기 연산으로 유효 숫자를 잃어버리지 않기 위해 

(CPU 지역 타이머 2번째 문단)

한 번 또는 정기적으로 타이머를 발생시킬 수 있는 장치이다.
-->
한 번 또는 정기적으로 인터럽트를 발생시킬 수 있는 장치이다. 

(CPU 지역 타이머 3번째 문단 2번째 항목)

지역 API 타이머는
-->
지역 APIC 타이머는 

(CPU 지역 타이머 3번째 문단 3번째 항목)

그리고 1번 또는 2, 4, 8, 16, 32, 64, 128번 버스의 클록 시그널마다
-->
그리고 1, 2, 4, 8, 16, 32, 64, 128번째 버스 클록 시그널마다 

(247 페이지 고정밀 사건 타이머 1번째 문단)

고정밀 사건 타이머는 인텔과 마이크로소프트과
-->
고정밀 사건 타이머는 인텔과 마이크로소프트가 

(247 페이지 고정밀 사건 타이머 2번째 문단)

일치하면 하드웨어 인터럽트를 증가시킨다.
-->
일치하면 하드웨어 인터럽트를 발생시킨다. 

(고정밀 사건 타이머 3번째 문단)

매번 발생하는 인터럽트를 프로그램 할 수 있게 하고, HPET 레지스터를 지원하는 타이머의 인터럽트를 허용하거나 금지한다.
-->
한 번만 발생하는 인터럽트를 프로그램 할 수 있게 하고, 주기적인 인터럽트를 지원하는 타이머의 경우 주기적인 인터럽트를 허용하거나 금지할 수 있게 한다. 

(ACPI 전원 관리 타이머 2번째 문단)

운영체제나 BIOS가 주파수를 낮추거나 또는 배터리 전력을 아끼기 위해 전력 CPU의 전압을 동적으로 낮춘다면
-->
운영체제나 BIOS가 배터리 전력을 아끼기 위해 동적으로 CPU의 주파수 또는 전압을 낮춘다면

(맨 마지막 줄)

'지연' 칸을 지연 메소드가 사용하는 타이머를 나타낸다.
-->
'지연' 칸을 delay 메소드가 사용하는 타이머를 나타낸다. 

(아래에서 2번째 문단)

80x86 아키텍처에서 jiffies가 왜 64비트 unsigned long 정수로
-->
80x86 아키텍처에서 jiffies가 왜 64비트 unsigned long long 정수로 

(1.c 항목)

(이 장 뒤에 나올 "The setitimer()와 alarm() 시스템 콜" 참고)
-->
(이 장 뒤에 나올 "setitimer()와 alarm() 시스템 콜" 참고) 

(4번째 문단)

처음에는 현재 jiffies 값에 원하는 틱의 수를 더해서 필드를 계산하지만 필드 값은 바뀌지 않는다.
-->
이 필드는 현재 jiffies 값에 원하는 틱의 수를 더한 값으로 초기화되며 필드 값은 바뀌지 않는다.

(5번째 문단)

동적 타이머는 커널을 사용하고,
-->
동적 타이머는 커널에서 사용하고, 

(3.d.5 항목)

인수 t.data에 전달된 타이머 함수 t.function을 수행한다.
-->
인수 t.data를 전달하여 타이머 함수 t.function을 수행한다. 

(아래에서 3번째 문단)

jiffies와 timer_jiffies는 항상 같기 때문에
-->
jiffies와 timer_jiffies는 보통 같기 때문에 

(3.b 항목)

인덱스는 base->timer_jiffies 값의 적당한 비트들을 결정한다.
-->
인덱스는 base->timer_jiffies 값의 적당한 비트들을 통해 결정된다. 

(SCHED_OTHER 항목)

SCHED_OTHER
-->
SCHED_NORMAL 

(280 페이지 공식 (1))

(140-정적우선순위)x20if정적우선순위<120
(140-정적우선순위)x5 if정적우선순위>=120
-->
(140 - 정적 우선순위) x 20  if 정적 우선순위 <  120
(140 - 정적 우선순위) x 5   if 정적 우선순위 >= 120

(3번째 문단)

[표 7-2]는 정적인 우선순위, 기본 타임 퀀텀 값, 최고 정적인 우선순위를 가진 전통 프로세스의 해당 나이스 값, 정적 우선순위 기정치(Default), 최저 정적우선순위들을 보여준다.
-->
[표 7-2]는 정적인 우선순위와 기본 타임 퀀텀 값 및 최고 정적 우선순위, 기본 정적 우선순위, 최저 정적우선순위를 가지는 일반 프로세스에 대한 나이스 값을 보여준다.

(공식 2)

동적 우선순위=max(100, min(정적인 우선순위-보너스+5,139))
-->
동적 우선순위 = max(100, min(정적 우선순위 - 보너스 + 5, 139))

(맨 아래 문단)

공식에서 (정적인 우선순위)/4-28은 '상호 작용 델타(Interactive Delta)'라고 불린다.
-->
공식에서 (정적 우선순위)/4 - 28은 '상호 작용 증분(Interactive Delta)'라고 불린다.

(마지막 문단)

반대로 최적 정적인 우선순위(139)를 가진 프로세스는 보너스 값이 상호 작용 델타 6에 도달하기 위하여 11보다 항상 작기 때문에 상호 작용적이라고 여겨지지 않는다.
-->
반대로 최적 정적인 우선순위(139)를 가진 프로세스는 상호 작용 증분 6에 도달하려면 보너스 값이 11이 되어야 하는데 보너스 값은 항상 10 이하이므로 상호 작용적이라고 여겨지지 않는다.

(282 페이지 활성 프로세스 설명)

실행 가능한 프로세스들은 자신의 타임 퀀텀을 쓰지 않아도 실행될 수 있다.
-->
실행 가능한 프로세스들은 자신의 타임 퀀텀을 다 쓰지 않았으므로 실행될 수 있다.

(표 7-4 curr 필드 설명)

현재 실행 가능한 프로세스의 디스크립터 주소
-->
현재 실행 중인 프로세스의 디스크립터 주소 

(표 7-4 migration_queue 필드 설명)

실행 큐에서 제거될 프로세스의 migration_queue 리스트
-->
실행 큐에서 제거될 프로세스의 리스트 

(그림 7-1)

동작중, 만료된, 배열[0], 배열[1]
-->
active, expired, arrays[0], arrays[1]

(3번 항목)

아니면 프로세스는 타임 퀀텀을 모두 소비한 것이다. 하지만 대체되지는 않고 재 스케줄링을 위해
-->
아니면 프로세스는 타임 퀀텀을 모두 소비했지만 아직 대체되지 않은 것이다. 이 경우 재 스케줄링을 위해 

(2.f 항목)

이미 만료된 프로세의 
-->
이미 만료된 프로세스의 

(290 페이지 첫번째 문단)

TIMESLICE_GRANULARITY 매크로는 시스템 내 CPU의 수만큼의 값을 반환하며 그 값들은 현재 프로세스의 보너스에 비례하는 상수이다.
-->
TIMESLICE_GRANULARITY 매크로는 시스템 내 CPU의 수에 현재 프로세스의 보너스에 비례하는 상수를 곱한 값을 반환한다. 

(290 페이지 1번 항목)

CPU의 논리적인 수는 p->thread_info->cpu 필드에 저장된다.
-->
해당 CPU의 논리적인 번호는 p->thread_info->cpu 필드에 저장된다. 

(3번 항목)

p->array 필드가 NULL이면,
-->
p->array 필드가 NULL이 아니면, 

(2번째 문단)

이러한 과정이 수행된 후 함수는 깨어난 프로세스를 실행할 CPU에서 확인하고, 해당 CPU의 실행 큐 rq에 프로세스를 추가한다.
-->
이 단계까지 수행하고나면 함수는 깨어난 프로세스를 실행할 CPU와 프로세스를 추가할 (해당 CPU의) 실행 큐 rq를 찾은 것이다. 

(1 ~ 5번 항목)

* 시작 번호가 1이 아니라 5가 되어야 합니다.  

(3번 항목)

프로세스가 커널 스레드인지,
-->
프로세스가 커널 스레드가 아닌지, 

(4번 항목)

sleep_time는 프로세스의 평균 수면 시간에 더해질 것이므로(과정 6 참고) 현재 평균 수면 시간이 작을수록 빨리 일어날 것이다.
-->
sleep_time은 프로세스의 평균 수면 시간에 더해질 것이므로(과정 6 참고) 현재 평균 수면 시간이 작을수록 그 값은 급속히 커질 것이다. 

(5번째 문단)

다음 지역 변수는
-->
next 지역 변수는 

(2번째 문단)

후자의 경우 단지 그 시간의 한 인자를 더한다.
-->
후자의 경우 단지 그 시간 중 일부 만을 더한다. 

(4번째 문단)

mm 필드는 프로세스가 소요한 메모리 디스크립터를 가리킨다.
-->
mm 필드는 프로세스가 소유한 메모리 디스크립터를 가리킨다. 

(4번째 문단)

switch_to 매크로는 호출 바로 뒤에 있는 context_switch()와 schedule() 함수의 next 프로세스에 의해 곧 수행되는 것이 아니라 스케줄러가 prev를 선택하였을 때 수행된다.
-->
context_switch()와 schedule() 함수의 내용 중 switch_to 매크로 호출 이후의 명령들은 next 프로세스가 바로 실행하는 것이 아니라 나중에 스케줄러가 다시 prev 프로세스를 실행하도록 선택하였을 때 수행된다. 

(케줄링 도메인 아래 2번째 문단)

각 그룹은 스케쥴링
-->
각 그룹은 스케줄링

(305 (7번 항목))

305 페이지의 

7번 항목 

'move_task() 함수가'를 'move_tasks() 함수가'로 수정함

(305 (마지막 문단))

305페이지의 마지막 줄 

'이 플래그가 NEWLY_IDLE로 설정될 수 없다'를
'이 플래그가 NEWLY_IDLE로 설정될 수 있다'로 수정함

(5번 항목)

두 번째 스핀 락 busiest->lock spin lock을 획득한다.
-->
두 번째 스핀 락 busiest->lock을 획득한다.

(5번 항목)

this_rq->lock이 먼저 해제되고 CPU 인덱스를 증가시키는 것에 의해 2개의 락이 획득된다.
-->
this_rq->lock을 먼저 해제하고 CPU 인덱스 순서에 따라 2개의 락을 획득한다. 

(7번 항목)

move_task() 함수가
-->
move_tasks() 함수가

(마지막 문단)

이 플래그가 NEWLY_IDLE로 설정될 수 없다.
-->
이 플래그가 NEWLY_IDLE로 설정될 수 있다. 

(1번째 문단)

함수는 다음과 같은 경우들에 1을 반환한다.
-->
함수는 다음과 같은 경우를 모두 만족할 때 1을 반환한다.  
 

(4번째 문단)

sys_sched_getaffinity() 시스템 콜은
-->
sys_sched_getaffinity() 시스템 콜 서비스 루틴은


 * 아래 문단의 sys_sched_setaffinity()에도 동일하게 적용 

(5번째 문단)

프로세스가 실행 큐 rq1에서 실행 큐 r2로 이동해야 할 때는
-->
프로세스가 실행 큐 rq1에서 실행 큐 rq2로 이동해야 할 때는 

(표 8-1 private 필드 설명)

페이지가 사용하지 않는 것이라면 필드는 버디 시스템을 사용한다
-->
페이지가 사용하지 않는 것이라면 필드는 버디 시스템에서 사용된다 

(마지막 문단)

pgdate_list 변수는
-->
pgdat_list 변수는 

(표 8-3 node_present_pages 필드 설명)

(페이지 프레임 내)
-->
(페이지 프레임 단위)

(마지막 문단)

예를 들어 페이지 프레임 선형 주소의 마지막 1GB에 직접 매핑 되었다면, 그리고 ISA DMA를 위해 사용되지 않을 예정이라면
-->
예를 들어 페이지 프레임이 선형 주소의 마지막 1GB에 직접 매핑 되어야하고 ISA DMA를 위해 사용되지 않을 예정이라면

(3번째 문단)

따라서 커널은 __local_bh_disable을 여러 번 겹쳐서 호출할 수 있다.
-->
따라서 커널은 local_bh_disable을 여러 번 겹쳐서 호출할 수 있다. 

(상단 kmap() 함수 코드)

void * kmap(struct page * page)
{
    if (!PageHighMem(page))
    return page_address(page);
    return kmap_high(page);
}
-->
void * kmap(struct page * page)
{
    if (!PageHighMem(page))
        return page_address(page);
    return kmap_high(page);
}

(상단 map_new_virtual() 함수 코드)

    if (!pkmap_count[last_pkmap_nr]) }
    unsigned long vaddr = PKMAP_BASE +
                   (last_pkmap_nr << PAGE_SHIFT);
        set_pte(&(pkmap_page_table[last_pkmap_nr]),
              mk_pte(page, __pgprot(0x63)));
    pkmap_count[last_pkmap_nr] = 1;
    set_page_address(page, (void *) vaddr);
    return vaddr;
    }
-->
    if (!pkmap_count[last_pkmap_nr]) }
        unsigned long vaddr = PKMAP_BASE +
                   (last_pkmap_nr << PAGE_SHIFT);
        set_pte(&(pkmap_page_table[last_pkmap_nr]),
                mk_pte(page, __pgprot(0x63)));
        pkmap_count[last_pkmap_nr] = 1;
        set_page_address(page, (void *) vaddr);
        return vaddr;
    }

(마지막 문단)

리스트의 머리뿐만 아니라 free_area 배열의 k번째 요소도 2^k 페이지들의 여유 블록의 수를 나타내는 nr_free 필드를 갖는다.
-->
free_area 배열의 k번째 요소는 (여유 블록) 리스트의 머리 뿐만 아니라, 2^k 페이지들의 여유 블록의 수를 나타내는 nr_free 필드도 포함한다. 

(329 페이지 1번째 문단)

나머지 768개 중 처음 512개를 512-페이지-프레임 블록 리스트에, 남은 페이지 프레임 256개를 여유 256-페이지 프레임 블록의 리스트에 넣는다.
-->
나머지 768개 중 마지막 512개를 여유 512-페이지-프레임 블록 리스트에, 남은 페이지 프레임 256개를 여유 256-페이지 프레임 블록 리스트에 넣는다.

(첫 번째 문단)

마침내 2^k 여유 페이지 블록 내 첫 번째 페이지의 디스크립터인 private 필드는 블록의 지수, 즉 숫자 k를 저장한다.
-->
마지막으로 2^k 여유 페이지 블록 내 첫 번째 페이지 디스크립터의 private 필드는 블록의 지수, 즉 숫자 k를 저장한다. 

(첫 번째 문단)

필드 덕에 페이지 블록이 해지될 때 커널은 블록의 버디(Buddy, 바로 옆 블록)도 해지되어야 하는지를 판단하고, 해지되어야 한다면 두 블록을 한 개의 2^k+1 페이지 블록으로 합친다.
-->
이 필드 덕에 페이지 블록이 해지될 때 커널은 블록의 버디(Buddy, 바로 옆 블록)도 여유 블록인지 판단할 수 있고, 여유 블록이라면 두 블록을 한 개의 2^k+1 페이지 블록으로 합친다.  
 

(마지막 문단)

뒷부분의 2^h 페이지 프레임을 할당하고 앞부분의 2^k-2^h 페이지 프레임을 h부터 k 사이의 인덱스에 있는 free_area 리스트에 할당한다.
-->
앞부분의 2^h 페이지 프레임을 할당하고 뒷부분의 2^k-2^h 페이지 프레임을 h부터 k 사이의 인덱스에 있는 free_area 리스트에 할당한다.

(블록 해지 첫번째 문단)

__free_pages_ok() 함수는
-->
__free_pages_bulk() 함수는 

(블록 해지 3번째 문단)

__rmqueue() 함수는
-->
이 함수는 

(CPU별 페이지 프레임 캐시 첫번째 문단)

이 장 뒤에 나오는 것처럼 커널은 자주 한 묶음의 페이지 프레임을 요청하고 해지시킨다.
-->
이 장 뒤에 나오는 것처럼 커널은 자주 하나의 페이지 프레임을 요청하고 해지시킨다. 

(CPU별 페이지 프레임 캐시 첫번째 문단)

각 CPU별 캐시는 지역 CPU가 발생시키는 한 번의 메모리 요청으로 미리 할당된 여러 페이지 프레임을 포함한다.
-->
각 CPU별 캐시는 지역 CPU가 발생시키는 한 페이지 크기의 요청을 처리하기 위해 미리 할당된 여러 페이지 프레임을 포함한다. 

(2번째 문단)

한 묶음의 페이지 프레임 요청을 처리하기 위해
-->
한 페이지 프레임 요청을 처리하기 위해 

(4번 과정)

PF_MEMDIE 플래그가 설정된다)
-->
TIF_MEMDIE 플래그가 설정된다)

(4번 과정)

메모리 부족에 대비한 페이지 예약을 채울 수 있는 유일한 경우이다.
-->
메모리 부족에 대비한 페이지 예약분을 사용할 수 있는 유일한 경우이다. 

(4번 과정)

이런 경우 메모리 요청을 한 커널 제어 경로는 결국 페이지 프레임들을 해지시키는 노력을 함으로써 요청했던 것을 얻어야 한다.
-->
사실, 이런 경우 메모리 요청을 한 커널 제어 경로는 최종적으로 페이지 프레임들을 해지시키려고 하는 중이므로, 가능하다면 요청한 것을 얻을 수 있어야 한다. 

(5번 과정)

_gfp_mask의 _GFP_WAIT 플래그가 설정되지 않았으면
-->
gfp_mask의 __GFP_WAIT 플래그가 설정되지 않았으면 

(10번 과정)

__GFP_NORETRY 플래그가 0이고 메모리 할당이 붙어있는 8개의 페이지 프레임을 요구하거나
-->
__GFP_NORETRY 플래그가 설정되지 않고 메모리 할당이 8개 이하의 연속된 페이지 프레임을 요구하거나

(외부 슬랩 디스크립터 설명)

슬랩 외부에 cache_sizes가 가리키는
-->
슬랩 외부에 malloc_sizes가 가리키는

(3번째 문단 마지막 줄)

cache_sizes 테이블을 사용한다.
-->
malloc_sizes 테이블을 사용한다. 

(아래에서 3번째 문단)

슬랩 캐시는 SLAB_RECLAIM_ACCOUNT 플래그 설정으로 만들어지므로
-->
슬랩 캐시를 만들 때 SLAB_RECLAIM_ACCOUNT 플래그를 설정했다면 

(2번째 문단)

reclaim_slab 필드는 해지된 페이지만이 페이지 프레임 해지 알고리즘에 의해 사용되도록
-->
reclaim_slab 필드는 방금 해지한 페이지들을 페이지 프레임 해지 알고리즘이 알 수 있도록 

(5번째 문단)

이런 일이 일어나면 슬랩 할당자는 kmem_cache_grow()을 호출하여
-->
이런 일이 일어나면 슬랩 할당자는 cache_grow()를 호출하여 

(5번째 문단)

alloc_slabmgnt()을 호출해서 새로운 슬랩 디스크립터를 받는다.
-->
alloc_slabmgmt()를 호출해서 새로운 슬랩 디스크립터를 받는다.

(마지막 문단)

그래서 cache_ grow() 함수는
-->
그래서 cache_grow() 함수는 

(주석 8))

lru 필드는 또한 페이지 프레임 해지 알고리즘을 사용한다.
-->
lru 필드는 페이지 프레임 해지 알고리즘에서도 사용된다. 

(3번째 문단)

마지막으로 cache_ grow() 함수는
-->
마지막으로 cache_grow() 함수는 

(캐시에서 슬랩 해지하기 첫 번째 항목)

"(다음 절 "캐시에서 슬랩 해지하기" 참고)" 부분을 삭제

(아래에서 3번째 문단)

그렇지 않으면 객체 크기를 L1_CACHE_BYTES의 배수로 반올림 한다.
-->
그렇지 않으면 객체 크기를 L1_CACHE_BYTES의 약수로 반올림 한다. 

(주석 10))

kmem_cache_alloc()를 구현하는 __kmem_cache_alloc() 함수를
-->
kmem_cache_alloc()를 구현하는 __cache_alloc() 함수를 

(메모리 풀 2번째 문단)

메모리 풀은 앞에 나온 "예약 페이지 프레임 품"에서 설명한
-->
메모리 풀은 앞에 나온 "예약된 페이지 프레임 풀"에서 설명한

(그림 8-7)

연속적인 커널 매핑
-->
영구 커널 매핑 

(1번째 문단)

alloc_page() 함수는 영역의 각 nr_pages 마다 한 번씩 반복해서 호출되며
-->
alloc_page() 함수는 영역의 nr_pages 만큼 반복해서 호출되며 

(2번 과정)

페이지 디스크립터 배열 area->pages array을 검색하고
-->
페이지 디스크립터 배열 area->pages를 검색하고 

(366 페이지 아래에서 2번째 문단)

이렇게 해도 커널은 마스터 커널 페이지 전역 디렉토리를 뿌리로 하는 페이지 상위 디렉토리, 페이지 중간 디렉토리, 페이지 테이블을 재사용하지 않기 때문에 상관이 없다.
-->
이렇게 해도 커널은 마스터 커널 페이지 전역 디렉토리 아래의 페이지 상위 디렉토리, 페이지 중간 디렉토리, 페이지 테이블을 회수하지 않기 때문에 상관이 없다.

(1번째 문단)

kmem_cache _alloc()나
-->
kmem_cache_alloc()이나 

(3번째 문단)

커널 함수가 동적 메모리를 요청하려면 반드시 정당한 이유가 있어야 하고, 이러한 요청을 더는 뒤로 미룰 수 없어야 한다.
-->
커널 함수가 동적 메모리를 요청한다면 반드시 정당한 이유가 있는 것이고, 이러한 요청을 더는 뒤로 미룰 수 없다. 

(표 9-2 mm_rb 필드 타입)

struct rb_root_t
-->
struct rb_root 

(표 9-3 vm_mm 필드 타입)

struct mm_start *
-->
struct mm_struct * 

(표 9-3 vm_rb 필드 타입)

struct rb_node_t
-->
struct rb_node 

(메모리 지역 자료 구조 2번째 문단)

하지만 시스템 관리자는 /proc/vm/max_map_count 파일을
-->
하지만 시스템 관리자는 /proc/sys/vm/max_map_count 파일을 

(4번째 문단)

모든 메모리 구역 객체는 rb_node_t 타입의 vm_rb 필드에
-->
모든 메모리 구역 객체는 rb_node 타입의 vm_rb 필드에 

(5번째 문단)

커널이 PAE를 지원하도록 컴파일 되었다면
-->
커널이 PAE를 지원하지 않도록 컴파일 되었다면 

(7번째 문단)

반대로 커널이 PAE를 지원하지 않고 CPU가 NX 플래그를 가진다면
-->
반대로 커널이 PAE를 지원하고 CPU가 NX 플래그를 가진다면 

(2번째 문단)

전형적으로 실행 파일의 text, data, and bss 세그먼트 등이 있다
-->
전형적으로 실행 파일의 text, data, bss 세그먼트 등이 있다 

(1번째 문단)

__vm_unlink() 함수는
-->
__vma_unlink() 함수는 

(마지막 줄)

(15장 참고)
-->
(16장 참고) 

(첫 줄)

기본 플래그인 mm->dev_flags에서
-->
기본 플래그인 mm->def_flags에서 

(6번 과정)

마지막 검사는 security_vm_enough_Memory() 함수가 수행한다.
-->
마지막 검사는 security_vm_enough_memory() 함수가 수행한다. 

(13번 과정)

make_pages_present() 함수는 make_pages_present() 함수를 호출한다.
-->
make_pages_present() 함수는 get_user_pages() 함수를 호출한다. 

(11.d 과정)

메모리 구역이 익명이면 mm->anon_vma의 선두에 있는
-->
메모리 구역이 익명이면 vma->anon_vma가 가리키는 

(코드)

if (regs->eflags & 0x00000200)
-->
if (regs->eflags & 0x00020200) 

(2번째 문단 (코드))

    if (!(error_code & 0x101))
-->
    if (!(error_code & 5))

(아래에서 2번째 문단)

handle_mm_fault()가 0을 반환하면 프로세스에 VM_FAULT_SIGBUS, SIGBUS 시그널을 보낸다.
-->
handle_mm_fault()가 VM_FAULT_SIGBUS를 반환하면 프로세스에 SIGBUS 시그널을 보낸다. 

(중간 코드)

out_of_Memory:
-->
out_of_memory: 

(3번째 문단)

15장에 있는 "메모리 매핑의 요구 페이징"과
-->
16장에 있는 "메모리 매핑에 대한 요구 페이징"과 

(코드)

If (write_access) {
-->
if (write_access) { 

(2번째 코드 맨 아래)

kunmap_atomic(vto, KM_USER0);
-->
kunmap_atomic(vto, KM_USER1);

(3번째 문단)

자세한 설명은 16장을 참고하라.
-->
자세한 설명은 17장을 참고하라. 

(3번째 문단)

no_content 라벨이 가리키는
-->
no_context 라벨이 가리키는 

(10장. 417p. [그림10-1] 내부)

오른쪽 사각형의 '사용자 모드'를 '커널 모드'로 수정함.

("시스템 콜에서 빠져나오기" 첫번째 문단)

다음으로 시스템 콜 핸들러를 마치는 ret_from_sys_call()로 넘어간다(4장의 "ret_from_sys_call() 함수" 참고)

-->  삭제 

(아래에서 2번째 문단)

[표 4-15]에 열거된 TIF_POLLING_NRFLAG를 제외한
-->
[표 4-15]에 열거된 TIF_POLLING_NRFLAG와 TIF_MEMDIE를 제외한

(마지막 줄)

TIF_SYSCALL_TRACE 플래그가 설정되었다면 함수는 work_pending 라벨로 넘어간다.
-->
TIF_SYSCALL_TRACE 플래그가 설정되지 않았다면 함수는 work_pending 라벨로 넘어간다. 

("시스템 콜에서 빠져 나오기" 2번째 문단)

resume_userspace 또는 work_pending labels 라벨로 넘어간다
-->
resume_userspace 또는 work_pending 라벨로 넘어간다 

(중간 코드)

cmpl $-125, %eax
-->
cmpl $-129, %eax

(마지막 문단)

커널은(시그널을 수신한
-->
커널은 시그널을 수신한 

(아래에서 2번째 문단 2번째 항목)

대략 1밀초 간격으로 발생하는 타이머 인터럽트가 있으면
-->
대략 1밀리초 간격으로 발생하는 타이머 인터럽트마다 

(그림 11-1)

시그널 디스크립
-->
시그널 디스크립터 

(맨 아래 signal_pending(p) 설명)

이 함수는 프로세스 디스크립터의 sigpending 필드를 검사함으로써 간단하게 구현한다.
-->
이 함수는 프로세스의 TIF_SIGPENDING 플래그를 검사함으로써 간단하게 구현한다. 

(맨 위)

recalc_sigpending(t)과 reclac_sigpending()
-->
recalc_sigpending_tsk(t)와 reclac_sigpending() 

(450 페이지 1번 과정 첫번째 항목)

(t->ptrace의 PT_PTRACED 플래그를 지운다).
-->
(t->ptrace의 PT_PTRACED 플래그가 설정되지 않았다). 

(위 2번 과정)

(sigismember(&t->pending.signal,sig) returns 1).
-->
(sigismember(&t->pending.signal, sig)는 1을 반환한다). 

("send_signal() 함수" 첫번째 문단)

siginfo_t data 자료 구조의 주소 info
-->
siginfo_t 자료 구조의 주소 info 

("send_signal() 함수" 첫번째 문단)

(또는 특별한 코드인 경우 앞 절의 specific_send_sig_info()의 디스크립터를 참고),
-->
(또는 특별한 코드인 경우 앞 절의 specific_send_sig_info()의 설명을 참고), 

(454 페이지 8번 과정)

같은 값을 반환하는 동안에 종료한다.
-->
같은 값을 반환하며 종료한다. 

(3번째 문단)

현재 프로세스의 사용자 모드 스택으로 복사하는 방법을 해결한다.
-->
현재 프로세스의 사용자 모드 스택으로 복사하는 방법을 이용하여 해결한다. 

(표 11-11)

ERESTART_RESTARTBOLCKa
-->
ERESTART_RESTARTBLOCKa

(표 11-11)

ERESTARTHAND
-->
ERESTARTNOHAND 

(4번째 문단)

프로세스는 20 밀리 초 동안 수행을 중지하고 시그널이 10밀리 초 후에 발생하도록 nanosleep()을 호출한다고 가정하자.
-->
프로세스가 20 밀리 초 동안 수행을 중지하도록 nanosleep()을 호출하고나서 10 밀리 초 후에 시그널이 발생했다고 가정하자.

("시그널 동작 변경" 2번째 문단)

sigaction 타입 테이블 act이다.
-->
old_sigaction 타입 테이블 act이다. 

(2번째 항목)

rt_sigtimewait()
-->
rt_sigtimedwait() 

(표 12-4 f_maxcount 필드 설명)

(현재 231-1 로 설정된다)
-->
(현재 2^31-1 로 설정된다) 

(표 12-15 mnt 필드 타입)

struct vfs_mount *
-->
struct vfsmount *

(1.a 과정)

LAST_ROOT에 last_type 필드 값을 설정한다.
-->
last_type 필드를 LAST_ROOT로 설정한다. 

(g.3 과정)

nd->mnt filesystem의 루트 디렉토리이고
-->
nd->mnt 파일 시스템의 루트 디렉토리이고 

(h 과정)

d_hash dentry 메소드를 가진다면
-->
d_hash 디엔트리 메소드를 가진다면 

(j 과정)

real_lookup() 함수는 아이노드의 탐색 메소드를 수행하여
-->
real_lookup() 함수는 아이노드의 lookup 메소드를 수행하여 

(k 과정)

follow_ mount() 함수는
-->
follow_mount() 함수는 

(m 과정)

(next.dentry->d_inode가 탐색 메소드를 가진다)
-->
(next.dentry->d_inode가 lookup 메소드를 가진다) 

(n 과정)

nd->dentry를 next.dentry에, 그리고 nd->mnt를 next.mnt에 각각 설정하고
-->
nd->dentry를 next.dentry 값으로, 그리고 nd->mnt를 next.mnt 값으로 각각 설정하고 

(6번 과정)

이제 원래 경로명에서 마지막을 제외한 모든 구성 요소를 해석한다.
-->
이제 원래 경로명에서 마지막을 제외한 모든 구성 요소를 해석하였다. 

(17번 과정)

inode가 독자적인 탐색 메소드를 가지는지,
-->
inode가 독자적인 lookup 메소드를 가지는지, 

(4번 과정)

current->link_count와 current->total_link_count를
-->
current->link_count와 current->total_link_count와 nd->depth를 

(7번 과정)

__vfs_follow_ link() 함수를 호출한다.
-->
__vfs_follow_link() 함수를 호출한다. 

(9번 과정)

nd->depth 필드를 감소시킨다.
-->
current->link_count와 nd->depth 필드를 감소시킨다. 

(sys_read/write 1번 과정)

파일 객체의 주소 file을 얻고, 사용 카운터 file->f_count를 증가시킨다
-->
파일 객체의 주소 file을 얻는다 

("close() 시스템 콜" 2번 과정)

close_ on_exec 필드에서 삭제하여
-->
close_on_exec 필드에서 삭제하여 

(중간)

flock() 시그널 콜에 의한 방법으로...
fcntl() 시그널 콜에 의한 방법으로...
-->
flock() 시스템 콜에 의한 방법으로...
fcntl() 시스템 콜에 의한 방법으로... 

(아래에서 3번째 문단)

fcntl()과 the flock() 시스템 콜이
-->
fcntl()과 flock() 시스템 콜이 

(아래에서 2번째 문단)

모든 lock_file 자료 구조는...
lock_file 자료 구조의..
-->
모든 file_lock 자료 구조는...
file_lock 자료 구조의.. 

(2번째 문단)

 * 아래의 내용이 맨 뒤에 추가되어야 합니다.

fl_link 필드는 이 두 리스트 중 하나에 file_lock 자료 구조를 추가하기 위해 사용된다. 

("FL_LOCK 락" 제목 및 첫번째 문단)

FL_LOCK
-->
FL_FLOCK 

(6번 과정)

flock_ lock_file_wait() 함수를 호출하여
-->
flock_lock_file_wait() 함수를 호출하여 

(3번째 문단)

(F_GETBLK 명령인 경우)
-->
(F_GETLK 명령인 경우)

(2번째 문단)

커널은 '리소드(Resource)'을 사용하여
-->
커널은 '리소스(Resource)'를 사용하여 

(중간 "범용 입출력 인터페이스")

 * 앞 페이지의 "전용 입출력 인터페이스"와 마찬가지로 소제목으로 변경

(3번째 문단)

케이오브젝트 디렉토리는 'attributes'라는 정규 파일을 가진다.
-->
케이오브젝트 디렉토리는 속성이라고 부르는 정규 파일들을 가진다. 

(코드)

(foo_dev->intr= =1)
-->
(foo_dev->intr == 1)

(5번째 문단)

그리고 드라이버는 pci_map_single() 또는 the dma_map_single() 함수를 호출하여
-->
그리고 드라이버는 pci_map_single() 또는 dma_map_single() 함수를 호출하여 

(아래 6번 과정)

cdev 디스크립터의 open 필드의 내용으로
-->
cdev 디스크립터의 ops 필드의 내용으로 

(첫 번째 문단)

18장에서는 일부 전형적인 디스크 기반을 소개할 것이다.
-->
18장에서는 일부 전형적인 디스크 기반 파일 시스템을 소개할 것이다. 

(첫 번째 문단)

6개의 512 바이트 섹터로 이루어져 있다.
-->
6개의 512 바이트 섹터로 이루어져 있다고 생각한다. 

(표 14-1 bi_vcnt 필드 설명)

bio의 bio_vec 배열에서 세그먼트의 번호
-->
bio의 bio_vec 배열 내의 세그먼트의 수 

(표 14-1 bi_max_vecs 필드 설명)

bio의 bio_vecarray 내에서 세그먼트의 최대 허용 수
-->
bio의 bio_vec 배열 내에서 세그먼트의 최대 허용 수 

(578 페이지 아래에서 2번째 문단)

bios
-->
bio

 * 모두 2번 나옵니다. 

(마지막 문단)

(부팅 과정에서, 또는 제거할 매체가 드라이버에 삽입 되었을 때,
-->
(부팅 과정에서, 또는 제거 가능한 매체가 드라이브에 삽입 되었을 때,

(1번 과정)

bio->bi_sector가 블록 장치의 섹터 수를 초과하지 않으면
-->
bio->bi_sector가 블록 장치의 섹터 수를 초과하면 

(610 (표 15-1 private_lock 필드 설명))

표 15-1의 spinlock_k를 설명하는 줄의 

'일반적으로 private_list 리tm트를 관리할 때'
'일반적으로 private_list 리스트를 관리할 때'로 수정함.

(표 15-1 i_mmap_writable 필드 설명)

주소 공간 내 공유 메모리 매핑들의 번호
-->
주소 공간 내 공유 메모리 매핑들의 개수 

(표 15-1 private_lock 필드 설명)

일반적으로 private_list list를 관리할 때
-->
일반적으로 private_list 리스트를 관리할 때 

(표 15-2)

writepags
-->
writepages 

(3.a 과정)

radix_tree_preloadsd에 있는 이미 할당된 자료 구조에서 시도한다.
-->
radix_tree_preloads에 있는 이미 할당된 자료 구조에서 시도한다. 

(중간 4번 과정)

캐시 페이지의 the page->mapping->nrpages
-->
캐시 페이지의 page->mapping->nrpages 

(첫 번째 문단)

버퍼 헤드는 b_page 필드 내 버퍼 페이지 디스크립터의 주소를 저장한다.
-->
버퍼 헤드는 b_page 필드에 버퍼 페이지 디스크립터의 주소를 저장한다. 

(첫 번째 문단)

버퍼 헤드의 private 필드는
-->
버퍼 페이지의 (페이지 디스크립터의) private 필드는 

(4번 과정)

(다시 카운터는 find_or_create_page()를 증가시킨다)
-->
(다시 말하지만, 카운터는 find_or_create_page()에서 증가되었다) 

(마지막 문단)

블록 장치 디스크립터 주소 bdev 또는 논리 블록 번호 nr이
-->
블록 장치 디스크립터 주소 bdev와 논리 블록 번호 nr이 

(중간 3번 과정)

free_more_Memory() 함수를 호출하여
-->
free_more_memory() 함수를 호출하여 

(2번째 문단)

리눅스 2.6에서는 이 둘을 bdflush라는
-->
리눅스 2.6에서는 이 둘을 pdflush라는 

(중간 2번째 항목)

현재(마지막 초에) pdflush가 없다면
-->
지난 1초 동안 한가한 pdflush가 없었다면 

(위 3번째 항목)

free_more_Memory() 또는try_to_free_pagess() 함수를
-->
free_more_memory() 또는 try_to_free_pagess() 함수를 

(633 페이지 첫번째 문단)

디스크에 쓰여질 페이지의 최소수를 매개 변수로 받는다.
-->
디스크에 쓰여질 페이지의 최소수 nr_pages를 매개 변수로 받는다. 

(역자주)

bdflush 커널 스레드가
-->
pdflush 커널 스레드가 

(마지막 문단)

dirty_writeback_centisecs 수백 초 (...) 후에
-->
1/100초 단위인 dirty_writeback_centisecs (...) 후에 

(5번 과정)

dirty_writeback_centisecs 변수에 저장된 수백 초 후
-->
(1/100 초 단위인) dirty_writeback_centisecs 변수에 저장된 시간 후