<?xml version="1.0"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="ko">
	<id>https://wiki.ldmsys.net/api.php?action=feedcontributions&amp;feedformat=atom&amp;user=%EA%B4%80%EB%A6%AC%EC%9E%90</id>
	<title>~ldmsys - 사용자 기여 [ko]</title>
	<link rel="self" type="application/atom+xml" href="https://wiki.ldmsys.net/api.php?action=feedcontributions&amp;feedformat=atom&amp;user=%EA%B4%80%EB%A6%AC%EC%9E%90"/>
	<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/wiki/%ED%8A%B9%EC%88%98:%EA%B8%B0%EC%97%AC/%EA%B4%80%EB%A6%AC%EC%9E%90"/>
	<updated>2026-11-16T20:45:11Z</updated>
	<subtitle>사용자 기여</subtitle>
	<generator>MediaWiki 1.46.2</generator>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%ED%82%A5%EC%8A%A4%ED%83%80%ED%8A%B8_%EA%B0%80%EC%9D%B4%EB%93%9C/Windows_%EB%93%9C%EB%9D%BC%EC%9D%B4%EB%B2%84_%EC%8B%9C%EC%9E%91%ED%95%98%EA%B8%B0&amp;diff=718</id>
		<title>킥스타트 가이드/Windows 드라이버 시작하기</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%ED%82%A5%EC%8A%A4%ED%83%80%ED%8A%B8_%EA%B0%80%EC%9D%B4%EB%93%9C/Windows_%EB%93%9C%EB%9D%BC%EC%9D%B4%EB%B2%84_%EC%8B%9C%EC%9E%91%ED%95%98%EA%B8%B0&amp;diff=718"/>
		<updated>2026-11-16T08:53:54Z</updated>

		<summary type="html">&lt;p&gt;관리자: 전체 문장 정리: 반복 설명·반박형 문장·볼드 강조 제거, 실습 순서와 복구 절차 유지&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;[[킥스타트 가이드]]로 돌아가기&lt;br /&gt;
&lt;br /&gt;
WDK로 간단한 커널 드라이버를 빌드하고 Windows 11 x64 VM에서 로드·언로드한다. 예제는 WDM(Windows Driver Model) 프로젝트로 만든 수동 시작 비PnP 드라이버다.&lt;br /&gt;
&lt;br /&gt;
빌드는 Windows 호스트나 VM에서 진행할 수 있다. 아래 부팅 설정과 로드 작업은 테스트 VM에서 수행한다.&lt;br /&gt;
&lt;br /&gt;
== WDK 설치 ==&lt;br /&gt;
&lt;br /&gt;
2026년 11월 15일 Microsoft가 안내하는 조합은 Visual Studio 2026 + WDK 28000.2526이다. Visual Studio 2022를 사용한다면 [https://learn.microsoft.com/en-us/windows-hardware/drivers/other-wdk-downloads WDK 26100.6584]를 설치한다.&amp;lt;ref name=&amp;quot;wdk&amp;quot;&amp;gt;[https://learn.microsoft.com/en-us/windows-hardware/drivers/download-the-wdk Microsoft Learn, Download the Windows Driver Kit (WDK)]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
# [https://visualstudio.microsoft.com/ Visual Studio Installer]에서 ‘C++를 사용한 데스크톱 개발’ 워크로드를 선택한다.&lt;br /&gt;
# ‘개별 구성 요소’에 Windows Driver Kit 확장과 해당 도구 집합의 Spectre 완화 라이브러리를 추가한다. C++·ATL·MFC의 x64/x86 및 ARM64/ARM64EC 구성 요소는 [https://learn.microsoft.com/en-us/windows-hardware/drivers/download-the-wdk WDK 설치 문서]의 목록을 따른다.&lt;br /&gt;
# 같은 문서의 다운로드 링크로 Windows SDK, WDK 순서로 설치한다. SDK와 WDK는 빌드 번호가 일치해야 한다. 최신 조합은 28000 계열이다.&lt;br /&gt;
# Visual Studio를 다시 실행한다.&lt;br /&gt;
&lt;br /&gt;
새 프로젝트에서 드라이버 템플릿이 검색되지 않으면 Visual Studio Installer의 ‘수정 → 개별 구성 요소 → Windows Driver Kit’를 확인한다.&lt;br /&gt;
&lt;br /&gt;
== 프로젝트와 코드 ==&lt;br /&gt;
&lt;br /&gt;
# ‘새 프로젝트 만들기 → Empty WDM Driver’를 선택하고 이름을 &amp;lt;code&amp;gt;HelloDriver&amp;lt;/code&amp;gt;로 지정한다.&lt;br /&gt;
# 구성을 Debug, 플랫폼을 x64로 선택한다.&lt;br /&gt;
# 소스 파일 &amp;lt;code&amp;gt;Driver.c&amp;lt;/code&amp;gt;를 추가하고 다음 코드를 작성한다.&amp;lt;ref name=&amp;quot;wdm-project&amp;quot;&amp;gt;[https://learn.microsoft.com/en-us/windows-hardware/drivers/develop/creating-a-new-driver Microsoft Learn, Creating a New Driver]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
#include &amp;lt;ntddk.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
DRIVER_INITIALIZE DriverEntry;&lt;br /&gt;
DRIVER_UNLOAD HelloUnload;&lt;br /&gt;
&lt;br /&gt;
VOID HelloUnload(PDRIVER_OBJECT DriverObject)&lt;br /&gt;
{&lt;br /&gt;
    UNREFERENCED_PARAMETER(DriverObject);&lt;br /&gt;
    DbgPrintEx(DPFLTR_IHVDRIVER_ID, DPFLTR_INFO_LEVEL,&lt;br /&gt;
               &amp;quot;HelloDriver: unloaded\n&amp;quot;);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject,&lt;br /&gt;
                     PUNICODE_STRING RegistryPath)&lt;br /&gt;
{&lt;br /&gt;
    UNREFERENCED_PARAMETER(RegistryPath);&lt;br /&gt;
    DriverObject-&amp;gt;DriverUnload = HelloUnload;&lt;br /&gt;
&lt;br /&gt;
    DbgPrintEx(DPFLTR_IHVDRIVER_ID, DPFLTR_INFO_LEVEL,&lt;br /&gt;
               &amp;quot;HelloDriver: loaded\n&amp;quot;);&lt;br /&gt;
    return STATUS_SUCCESS;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
로드 시 호출되는 &amp;lt;code&amp;gt;DriverEntry&amp;lt;/code&amp;gt;에서 언로드 함수 &amp;lt;code&amp;gt;HelloUnload&amp;lt;/code&amp;gt;를 등록한다. &amp;lt;code&amp;gt;STATUS_SUCCESS&amp;lt;/code&amp;gt;는 초기화 성공을 나타낸다.&amp;lt;ref name=&amp;quot;entry&amp;quot;&amp;gt;[https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/nc-wdm-driver_initialize Microsoft Learn, DRIVER_INITIALIZE callback function]&amp;lt;/ref&amp;gt; 두 함수의 &amp;lt;code&amp;gt;DbgPrintEx&amp;lt;/code&amp;gt; 출력은 WinDbg 같은 커널 디버거에서 볼 수 있다.&amp;lt;ref name=&amp;quot;dbgprint&amp;quot;&amp;gt;[https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/nf-wdm-dbgprintex Microsoft Learn, DbgPrintEx function]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 빌드 ==&lt;br /&gt;
&lt;br /&gt;
# 프로젝트 속성의 ‘Driver Signing → Sign Mode’를 Off로 설정한다.&amp;lt;ref name=&amp;quot;sign-properties&amp;quot;&amp;gt;[https://learn.microsoft.com/en-us/windows-hardware/drivers/develop/driver-signing-properties Microsoft Learn, Driver Signing Properties]&amp;lt;/ref&amp;gt;&lt;br /&gt;
# 프로젝트를 빌드하고 출력 창에서 &amp;lt;code&amp;gt;HelloDriver.sys&amp;lt;/code&amp;gt;의 경로를 확인한다. 기본 출력 위치는 보통 &amp;lt;code&amp;gt;x64\Debug&amp;lt;/code&amp;gt; 아래다.&lt;br /&gt;
# 파일을 VM의 &amp;lt;code&amp;gt;C:\Drivers\HelloDriver\HelloDriver.sys&amp;lt;/code&amp;gt;로 복사한다. 디버깅용 &amp;lt;code&amp;gt;HelloDriver.pdb&amp;lt;/code&amp;gt;도 같은 빌드의 파일을 보관한다.&lt;br /&gt;
&lt;br /&gt;
이 예제는 서비스로 직접 등록하므로 INF 패키지가 필요 없다. 빈 프로젝트에 포함된 미완성 INF 때문에 패키징 오류가 나면 해당 INF를 프로젝트에서 제외하고 .sys 프로젝트를 빌드한다.&lt;br /&gt;
&lt;br /&gt;
== VM 부팅 설정 ==&lt;br /&gt;
&lt;br /&gt;
서명하지 않은 .sys를 실행하기 위해 드라이버 서명 적용(Driver Signature Enforcement)을 한 부팅 세션 동안 해제한다. &amp;lt;code&amp;gt;verifier.exe&amp;lt;/code&amp;gt;로 설정하는 Driver Verifier는 드라이버 동작을 검사하는 별도 도구다.&amp;lt;ref name=&amp;quot;verifier&amp;quot;&amp;gt;[https://learn.microsoft.com/en-us/windows-hardware/drivers/devtest/driver-verifier Microsoft Learn, Driver Verifier]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== 준비 ===&lt;br /&gt;
&lt;br /&gt;
* 변경 전 VM 스냅샷을 만든다.&lt;br /&gt;
* BitLocker나 장치 암호화를 사용한다면 복구 키를 준비한다. 부팅 설정 변경 후 요구될 수 있다.&lt;br /&gt;
* 게스트의 ‘Windows 보안 → 장치 보안 → 코어 격리 세부 정보’에서 메모리 무결성(HVCI)이 켜져 있으면 기존 상태를 기록하고 끈 뒤 재부팅한다. HVCI는 미서명 커널 코드의 실행을 제한한다.&amp;lt;ref name=&amp;quot;hvci&amp;quot;&amp;gt;[https://learn.microsoft.com/en-us/windows/security/hardware-security/enable-virtualization-based-protection-of-code-integrity Microsoft Learn, Enable memory integrity]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== 서명 적용 해제 ===&lt;br /&gt;
&lt;br /&gt;
# VM의 시작 메뉴에서 Shift 키를 누른 채 ‘다시 시작’을 선택한다.&lt;br /&gt;
# ‘문제 해결 → 고급 옵션 → 시작 설정 → 다시 시작’으로 이동한다.&lt;br /&gt;
# ‘7 또는 F7: 드라이버 서명 적용 사용 안 함’을 선택하고 로그인한다.&amp;lt;ref name=&amp;quot;startup&amp;quot;&amp;gt;[https://support.microsoft.com/en-au/windows/experience/startup-boot/windows-startup-settings Microsoft Support, Windows Startup Settings]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이 설정은 다음 재부팅까지 유효하다.&amp;lt;ref name=&amp;quot;unsigned&amp;quot;&amp;gt;[https://learn.microsoft.com/en-us/windows-hardware/drivers/install/installing-an-unsigned-driver-during-development-and-test Microsoft Learn, Installing an Unsigned Driver during Development and Test]&amp;lt;/ref&amp;gt; Secure Boot가 설정 변경을 막는 경우에는 VM을 종료한 뒤 VM 펌웨어 설정에서 해제하고 원래 값을 기록한다. 조직 정책으로 변경이 제한된 환경에서는 별도 실습 VM을 사용한다.&lt;br /&gt;
&lt;br /&gt;
== OSR Driver Loader ==&lt;br /&gt;
&lt;br /&gt;
OSR Driver Loader는 비PnP 드라이버를 서비스로 등록하고 시작·중지하는 도구다.&amp;lt;ref name=&amp;quot;osr-nonpnp&amp;quot;&amp;gt;[https://community.osr.com/t/osrloader-and-loading-of-filterdrivers/40002 OSR, OSRLoader and loading of FilterDrivers]&amp;lt;/ref&amp;gt; OSR Online이 2026년 5월 콘텐츠 제공을 종료하면서 기존 공식 다운로드도 중단됐다.&amp;lt;ref name=&amp;quot;osr-retired&amp;quot;&amp;gt;[https://osronline.com/article.cfm/?article=157 OSR Online, Gone!], 2026-11-15 확인.&amp;lt;/ref&amp;gt; 기존 배포본이 있다면 아래 절차를 따르고, 없다면 다음 절의 Windows 내장 &amp;lt;code&amp;gt;sc.exe&amp;lt;/code&amp;gt;를 사용한다.&lt;br /&gt;
&lt;br /&gt;
# VM에서 OSR Driver Loader를 관리자 권한으로 실행한다.&lt;br /&gt;
# 파일 경로를 &amp;lt;code&amp;gt;C:\Drivers\HelloDriver\HelloDriver.sys&amp;lt;/code&amp;gt;로 지정한다.&lt;br /&gt;
# 시작 유형을 Demand(수동 시작)로 선택한다.&lt;br /&gt;
# Register Service로 등록하고 Start Service로 로드한다.&lt;br /&gt;
# 다음 절의 &amp;lt;code&amp;gt;sc.exe query&amp;lt;/code&amp;gt;로 상태를 확인한다. 서비스 이름이 다르면 &amp;lt;code&amp;gt;HelloDriver&amp;lt;/code&amp;gt;를 실제 등록된 이름으로 바꾼다.&lt;br /&gt;
# 종료할 때는 Stop Service, Unregister Service 순서로 실행한다.&lt;br /&gt;
&lt;br /&gt;
== sc.exe ==&lt;br /&gt;
&lt;br /&gt;
관리자 권한 명령 프롬프트에서 다음을 실행한다. OSRLoader로 이미 등록했다면 첫 줄은 생략한다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
sc.exe create HelloDriver type= kernel start= demand binPath= &amp;quot;C:\Drivers\HelloDriver\HelloDriver.sys&amp;quot;&lt;br /&gt;
sc.exe start HelloDriver&lt;br /&gt;
sc.exe query HelloDriver&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;type= kernel&amp;lt;/code&amp;gt;은 커널 드라이버, &amp;lt;code&amp;gt;start= demand&amp;lt;/code&amp;gt;는 수동 시작을 지정한다. 옵션의 등호 뒤에는 공백이 필요하다.&amp;lt;ref name=&amp;quot;sc-create&amp;quot;&amp;gt;[https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/sc-create Microsoft Learn, sc.exe create]&amp;lt;/ref&amp;gt; PowerShell에서도 &amp;lt;code&amp;gt;sc.exe&amp;lt;/code&amp;gt;로 실행한다.&lt;br /&gt;
&lt;br /&gt;
로드 성공 시 조회 결과는 다음 형태다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
SERVICE_NAME: HelloDriver&lt;br /&gt;
        TYPE               : 1  KERNEL_DRIVER&lt;br /&gt;
        STATE              : 4  RUNNING&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
언로드한 뒤 등록을 제거한다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
sc.exe stop HelloDriver&lt;br /&gt;
sc.exe query HelloDriver&lt;br /&gt;
sc.exe delete HelloDriver&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
중지 후 상태는 &amp;lt;code&amp;gt;1 STOPPED&amp;lt;/code&amp;gt;다. 새 빌드를 시험할 때는 중지 → .sys 교체 → 시작 순서로 진행한다.&lt;br /&gt;
&lt;br /&gt;
== 오류 확인 ==&lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
! 증상 !! 확인할 항목&lt;br /&gt;
|-&lt;br /&gt;
| 액세스 거부 || 로더나 명령 프롬프트의 관리자 권한&lt;br /&gt;
|-&lt;br /&gt;
| 파일을 찾을 수 없음 || 게스트의 .sys 경로와 &amp;lt;code&amp;gt;sc.exe qc HelloDriver&amp;lt;/code&amp;gt;의 BINARY_PATH_NAME&lt;br /&gt;
|-&lt;br /&gt;
| 오류 193 || 게스트와 드라이버의 아키텍처가 모두 x64인지 확인&lt;br /&gt;
|-&lt;br /&gt;
| 오류 577, 서명 확인 실패 || F7로 부팅했는지, 이후 재부팅했는지, HVCI 및 코드 무결성 정책 상태&lt;br /&gt;
|-&lt;br /&gt;
| 서비스가 이미 존재함 || &amp;lt;code&amp;gt;sc.exe qc HelloDriver&amp;lt;/code&amp;gt;로 기존 등록 경로 확인&lt;br /&gt;
|-&lt;br /&gt;
| 시작 실패, 블루스크린 || 시스템 로그, CodeIntegrity/Operational 로그, 덤프의 오류 코드&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
== 반복 개발용 테스트 서명 ==&lt;br /&gt;
&lt;br /&gt;
반복해서 로드할 때는 테스트 서명을 사용할 수 있다. 프로젝트의 ‘Driver Signing → Sign Mode’를 Test Sign으로 바꾸고 빌드한다. Test Certificate가 비어 있으면 Visual Studio가 프로젝트용 인증서를 생성한다.&amp;lt;ref name=&amp;quot;sign-properties&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
필요한 테스트 인증서를 게스트에 배포한 뒤 관리자 명령 프롬프트에서 다음을 실행하고 재부팅한다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
bcdedit /set TESTSIGNING ON&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
테스트 모드에서도 드라이버 이미지의 서명이 필요하다. HVCI를 사용하는 경우 코드도 HVCI와 호환돼야 한다. Secure Boot가 명령 실행을 막으면 VM 펌웨어에서 해제한다.&amp;lt;ref name=&amp;quot;testsigning&amp;quot;&amp;gt;[https://learn.microsoft.com/en-us/windows-hardware/drivers/install/the-testsigning-boot-configuration-option Microsoft Learn, The TESTSIGNING Boot Configuration Option]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 실습 종료 ==&lt;br /&gt;
&lt;br /&gt;
드라이버를 중지하고 등록을 제거한 뒤 재부팅한다. F7로 해제한 서명 적용은 재부팅 시 복구된다. 테스트 모드를 켰다면 먼저 다음을 실행한다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
bcdedit /set TESTSIGNING OFF&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
변경했던 메모리 무결성과 VM Secure Boot를 원래 상태로 되돌리고 필요한 재부팅을 마친다. 부팅에 문제가 있으면 실습 전 스냅샷으로 복원한다.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%ED%8B%80:%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8_%EB%91%98%EB%9F%AC%EB%B3%B4%EA%B8%B0&amp;diff=717</id>
		<title>틀:운영체제 기본 둘러보기</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%ED%8B%80:%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8_%EB%91%98%EB%9F%AC%EB%B3%B4%EA%B8%B0&amp;diff=717"/>
		<updated>2026-11-15T06:11:50Z</updated>

		<summary type="html">&lt;p&gt;관리자: 둘러보기 링크 구분자를 ASCII 쉼표로 통일&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&amp;lt;div class=&amp;quot;os-basics-browse&amp;quot; role=&amp;quot;navigation&amp;quot; aria-label=&amp;quot;운영체제 기본 둘러보기&amp;quot; style=&amp;quot;border:1px solid #a2a9b1;margin:1.2em 0;overflow-wrap:anywhere;&amp;quot;&amp;gt;&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align:center;font-weight:bold;padding:0.65em;background:rgba(127,127,127,0.1);&amp;quot;&amp;gt;[[운영체제 기본|운영체제 기본 둘러보기]]&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;div style=&amp;quot;display:flex;flex-wrap:wrap;border-top:1px solid #a2a9b1;&amp;quot;&amp;gt;&lt;br /&gt;
&amp;lt;div style=&amp;quot;flex:0 1 5em;font-weight:bold;padding:0.55em 0.8em;&amp;quot;&amp;gt;[[운영체제 기본#총론|총론]]&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;div style=&amp;quot;flex:1 1 22em;min-width:0;padding:0.55em 0.8em;&amp;quot;&amp;gt;[[운영체제 기본/서문|서문]], [[운영체제 기본/추상화|추상화]], [[운영체제 기본/보호|보호와 시스템 콜]], [[운영체제 기본/장치 제어와 입출력|장치 제어와 입출력]], [[운영체제 기본/프로세스와 스레드|프로세스와 스레드]], [[운영체제 기본/동시성|동시성]], [[운영체제 기본/가상 메모리|가상 메모리]], [[운영체제 기본/파일과 입출력|파일과 입출력]], [[운영체제 기본/프로세스 간 통신|프로세스 간 통신]]&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;div style=&amp;quot;display:flex;flex-wrap:wrap;border-top:1px solid #a2a9b1;&amp;quot;&amp;gt;&lt;br /&gt;
&amp;lt;div style=&amp;quot;flex:0 1 5em;font-weight:bold;padding:0.55em 0.8em;&amp;quot;&amp;gt;[[운영체제 기본#각론: Linux 구현 읽기|각론]]&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;div style=&amp;quot;flex:1 1 22em;min-width:0;padding:0.55em 0.8em;&amp;quot;&amp;gt;&lt;br /&gt;
&amp;lt;div style=&amp;quot;margin:0.2em 0;&amp;quot;&amp;gt;&#039;&#039;&#039;[[운영체제 기본/Linux/x86-64/BIOS 부팅|x86-64 BIOS 부팅]]&#039;&#039;&#039; ([[운영체제 기본/Linux/x86-64/BIOS 부팅/GRUB의 커널 적재와 제어권 전달|GRUB의 커널 적재와 제어권 전달]], [[운영체제 기본/Linux/x86-64/BIOS 부팅/진입 규약과 압축 해제|진입 규약과 압축 해제]], [[운영체제 기본/Linux/x86-64/BIOS 부팅/GDT와 LDT 초기화|GDT와 LDT 초기화]], [[운영체제 기본/Linux/x86-64/BIOS 부팅/커널 초기화|커널 초기화]], [[운영체제 기본/Linux/x86-64/BIOS 부팅/PID 1 생성|PID 1 생성]], [[운영체제 기본/Linux/x86-64/BIOS 부팅/루트 파일시스템과 init 선택|루트 파일시스템과 init 선택]])&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;div style=&amp;quot;margin:0.2em 0;&amp;quot;&amp;gt;&#039;&#039;&#039;[[운영체제 기본/Linux/ELF 로딩|ELF 로딩]]&#039;&#039;&#039; ([[운영체제 기본/Linux/ELF 로딩/execve와 실행 이미지 교체|execve와 실행 이미지 교체]], [[운영체제 기본/Linux/ELF 로딩/ELF 세그먼트와 주소 공간|ELF 세그먼트와 주소 공간]], [[운영체제 기본/Linux/ELF 로딩/초기 스택과 사용자 모드 진입|초기 스택과 사용자 모드 진입]])&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;div style=&amp;quot;margin:0.2em 0;&amp;quot;&amp;gt;&#039;&#039;&#039;[[운영체제 기본/Linux/파일 시스템 콜|파일 시스템 콜]]&#039;&#039;&#039; ([[운영체제 기본/Linux/파일 시스템 콜/시스템 콜과 파일 디스크립터|시스템 콜과 파일 디스크립터]], [[운영체제 기본/Linux/파일 시스템 콜/openat과 경로 탐색|openat과 경로 탐색]], [[운영체제 기본/Linux/파일 시스템 콜/read와 write|read와 write]], [[운영체제 기본/Linux/파일 시스템 콜/파일 오프셋과 열린 파일의 수명|파일 오프셋과 열린 파일의 수명]])&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;div style=&amp;quot;margin:0.2em 0;&amp;quot;&amp;gt;&#039;&#039;&#039;[[운영체제 기본/Linux/메모리 매핑|메모리 매핑 (mmap)]]&#039;&#039;&#039; ([[운영체제 기본/Linux/메모리 매핑/mmap과 주소 공간|mmap과 주소 공간]], [[운영체제 기본/Linux/메모리 매핑/페이지 폴트 처리|페이지 폴트 처리]], [[운영체제 기본/Linux/메모리 매핑/익명 메모리 매핑|익명 메모리 매핑]], [[운영체제 기본/Linux/메모리 매핑/파일 매핑과 COW|파일 매핑과 COW]], [[운영체제 기본/Linux/메모리 매핑/MMIO 장치 매핑|MMIO 장치 매핑]])&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;div style=&amp;quot;margin:0.2em 0;&amp;quot;&amp;gt;&#039;&#039;&#039;[[운영체제 기본/Linux/x86-64/i8042 키보드 입력|i8042 키보드 입력]]&#039;&#039;&#039; ([[운영체제 기본/Linux/x86-64/i8042 키보드 입력/IRQ 진입과 디스패치|IRQ 진입과 디스패치]], [[운영체제 기본/Linux/x86-64/i8042 키보드 입력/i8042와 입력 이벤트|i8042와 입력 이벤트]], [[운영체제 기본/Linux/x86-64/i8042 키보드 입력/evdev의 이벤트 전달과 대기 해제|evdev의 이벤트 전달과 대기 해제]], [[운영체제 기본/Linux/x86-64/i8042 키보드 입력/콘솔과 터미널 입력|콘솔과 터미널 입력]])&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;div style=&amp;quot;margin:0.2em 0;&amp;quot;&amp;gt;&#039;&#039;&#039;[[운영체제 기본/Linux/파일시스템|파일시스템]]&#039;&#039;&#039; ([[운영체제 기본/Linux/파일시스템/VFS와 파일 객체|VFS와 파일 객체]], [[운영체제 기본/Linux/파일시스템/ext4의 파일 읽기|ext4의 파일 읽기]], [[운영체제 기본/Linux/파일시스템/procfs의 파일 읽기|procfs의 파일 읽기]], [[운영체제 기본/Linux/파일시스템/페이지 캐시|페이지 캐시]])&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;div style=&amp;quot;margin:0.2em 0;&amp;quot;&amp;gt;&#039;&#039;&#039;[[운영체제 기본/Linux/RCU|RCU]]&#039;&#039;&#039; ([[운영체제 기본/Linux/RCU/포인터 공개와 읽기 구간|포인터 공개와 읽기 구간]], [[운영체제 기본/Linux/RCU/갱신과 메모리 회수|갱신과 메모리 회수]], [[운영체제 기본/Linux/RCU/Tree RCU와 유예 기간|Tree RCU와 유예 기간]])&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&amp;lt;noinclude&amp;gt;&lt;br /&gt;
[[운영체제 기본]]의 문서를 총론과 각론으로 나눈 둘러보기 틀이다.&lt;br /&gt;
&lt;br /&gt;
== 사용법 ==&lt;br /&gt;
&amp;lt;pre&amp;gt;{{운영체제 기본 둘러보기}}&amp;lt;/pre&amp;gt;&lt;br /&gt;
&amp;lt;/noinclude&amp;gt;&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/%EC%9E%A5%EC%B9%98_%EC%A0%9C%EC%96%B4%EC%99%80_%EC%9E%85%EC%B6%9C%EB%A0%A5&amp;diff=716</id>
		<title>운영체제 기본/장치 제어와 입출력</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/%EC%9E%A5%EC%B9%98_%EC%A0%9C%EC%96%B4%EC%99%80_%EC%9E%85%EC%B6%9C%EB%A0%A5&amp;diff=716"/>
		<updated>2026-11-15T06:11:36Z</updated>

		<summary type="html">&lt;p&gt;관리자: 제목 문장부호 변경 전 앵커를 유지해 기존 링크 호환&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/보호|보호와 시스템 콜]]&lt;br /&gt;
|목차=[[운영체제 기본#총론|총론 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/프로세스와 스레드|프로세스와 스레드]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
소프트웨어는 장치에 제어 명령을 전달하고 데이터를 옮긴 뒤, 사건이나 작업 완료를 확인한다. 장치 레지스터 접근, DMA, 인터럽트는 각각 이 과정의 다른 부분을 담당한다. DMA로 데이터를 전송하면서 완료는 인터럽트로 통지받을 수도 있고, 같은 DMA 전송의 완료를 폴링으로 확인할 수도 있다.&lt;br /&gt;
&lt;br /&gt;
== 장치 제어와 데이터 전송 ==&lt;br /&gt;
=== 레지스터를 통한 장치 제어 ===&lt;br /&gt;
&lt;br /&gt;
장치는 소프트웨어가 읽거나 쓸 수 있는 레지스터를 제공한다. 제어 레지스터에는 시작이나 중지 명령을 쓰고, 상태 레지스터에서는 준비 상태나 오류를 확인한다. 데이터 레지스터를 통해 실제 데이터를 주고받는 장치도 있다. 드라이버(Device Driver)는 장치별 제어 규약에 맞춰 레지스터를 조작하는 소프트웨어로, 운영체제의 요청을 실제 장치 동작으로 연결한다.&lt;br /&gt;
&lt;br /&gt;
메모리 매핑 입출력인 MMIO(Memory-Mapped Input/Output)는 CPU의 주소 공간 일부를 장치 접근에 사용한다. 포트 입출력은 일반 메모리와 구별되는 포트 주소 공간을 사용하며, x86에서는 별도의 입출력 명령으로 접근한다. 두 방식은 레지스터에 접근하는 방법의 차이다. 데이터 전송을 CPU가 담당할지 다른 하드웨어에 맡길지와는 별개의 구분이다.&amp;lt;ref name=&amp;quot;device-io&amp;quot;&amp;gt;Linux Kernel Documentation, [https://docs.kernel.org/driver-api/device-io.html Bus-Independent Device Accesses].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
장치 레지스터는 읽기가 상태를 바꾸거나 쓰기가 동작을 시작할 수 있다. 따라서 일반 변수처럼 접근을 생략하거나 순서를 바꿔도 된다고 가정할 수 없다. 쓰기 명령의 실행이 끝났더라도 실제 장치에 쓰기가 도착했는지는 별도로 판단해야 하는 하드웨어도 있다.&amp;lt;ref name=&amp;quot;device-io&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== DMA와 버퍼의 소유권 ===&lt;br /&gt;
&lt;br /&gt;
CPU가 데이터 레지스터를 읽어 메모리에 저장하는 방식에서는 CPU 명령 실행이 데이터 이동을 담당한다. i8042 입력에서 CPU가 컨트롤러의 데이터 레지스터를 읽는 것도 이쪽에 해당한다. 인터럽트는 이 레지스터를 읽을 시점을 알려 준다.&lt;br /&gt;
&lt;br /&gt;
직접 메모리 접근인 DMA(Direct Memory Access)에서는 장치 자체의 전송 엔진이나 별도의 DMA 컨트롤러가 메모리 접근을 수행한다. CPU가 전송되는 데이터마다 읽기와 쓰기 명령을 실행할 필요는 없다. 주변장치 대신 별도 컨트롤러가 전송하는 구조도 있고, 장치가 직접 버스 접근을 시작하는 버스 마스터 구조도 있다.&amp;lt;ref name=&amp;quot;dma-engine&amp;quot;&amp;gt;Linux Kernel Documentation, [https://docs.kernel.org/driver-api/dmaengine/client.html DMA Engine API Guide].&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;dma-map&amp;quot;&amp;gt;Linux Kernel Documentation, [https://docs.kernel.org/core-api/dma-api-howto.html Dynamic DMA mapping Guide].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
DMA에서도 드라이버는 버퍼를 준비하고 장치가 사용할 주소와 길이와 방향을 설정하며 전송을 제출한다. 전송 중인 버퍼를 덮어쓰거나 해제하면 데이터가 손상될 수 있으므로, CPU와 장치가 언제 데이터를 변경해도 되는지 소유권 규약이 필요하다. 버퍼와 주소 매핑은 전송이 끝날 때까지 유효해야 하며, 완료와 필요한 동기화를 확인한 뒤 재사용한다.&amp;lt;ref name=&amp;quot;dma-engine&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
네트워크 수신과 저장장치 블록 전송에서 DMA를 널리 사용한다. 완료 상태는 폴링이나 인터럽트로 확인할 수 있다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;span id=&amp;quot;DMA의_주소_변환·일관성·전송_비용&amp;quot;&amp;gt;&amp;lt;/span&amp;gt;&lt;br /&gt;
=== DMA의 주소 변환, 일관성, 전송 비용 ===&lt;br /&gt;
CPU의 가상 주소, CPU의 물리 주소, 장치의 DMA 주소는 구별해야 한다. 단순한 시스템에서는 DMA 주소와 물리 주소가 같지만 일반적으로 이를 가정할 수 없다. 입출력 메모리 관리 장치인 IOMMU(Input-Output Memory Management Unit)는 운영체제가 설정한 매핑에 따라 장치의 DMA 주소를 물리 메모리 주소로 바꾸는 하드웨어다. 운영체제는 장치가 접근할 영역을 설정하고, IOMMU는 DMA 접근에 그 설정을 적용한다. CPU가 실행하는 명령의 주소를 검사하는 MMU와 달리 장치의 메모리 접근을 중재한다. 모든 시스템에 IOMMU가 있는 것은 아니다.&amp;lt;ref name=&amp;quot;dma-map&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
CPU 캐시와 장치가 보는 메모리 사이에는 동기화가 필요할 수 있다. 하드웨어가 캐시 일관성을 제공하더라도 접근 순서까지 자동으로 보장하지는 않는다. 전송 요청을 기록한 디스크립터에서 주소와 길이보다 유효 표시가 먼저 보이면 장치가 미완성 작업을 실행할 수 있다. 메모리 배리어(Memory Barrier)는 컴파일러와 CPU가 메모리 접근을 재배치할 수 있는 범위를 제한하는 수단이다. 드라이버는 장치와 메모리의 특성에 맞는 배리어를 사용하여 이런 공개 순서를 보장한다.&amp;lt;ref name=&amp;quot;dma-map&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
DMA는 CPU의 반복적인 복사를 줄이지만 설정과 완료 처리, 주소 매핑, 캐시 동기화 비용이 든다. 장치는 버스와 메모리 대역폭을 소비하고 다른 작업과 경합한다. 임시 버퍼 때문에 추가 복사가 필요할 수도 있다. 버퍼 부족과 요청을 모으는 정책은 대기 시간에도 영향을 준다. 작은 전송은 CPU가 직접 처리하는 편이 단순할 수 있으며, DMA 사용 여부는 처리량뿐 아니라 지연과 자원 사용까지 고려해야 한다.&lt;br /&gt;
&lt;br /&gt;
== 사건 통지와 인터럽트 ==&lt;br /&gt;
&lt;br /&gt;
=== 비동기 사건과 인터럽트 ===&lt;br /&gt;
키보드 입력, 네트워크 패킷 도착, 저장장치의 입출력 완료는 실행 중인 프로그램의 명령 순서와 독립적으로 발생한다. 하드웨어 인터럽트는 사건을 CPU에 알리고 운영체제가 처리할 기회를 만드는 통지 수단이다. 키보드의 입력 바이트를 읽거나 패킷을 처리하는 일, 완료된 요청을 확인하는 일은 통지를 받은 뒤 각 처리기가 수행한다. 타이머 인터럽트는 실행 중인 작업의 협조 없이 CPU를 회수하는 선점에도 쓰인다.&lt;br /&gt;
&lt;br /&gt;
폴링은 장치 상태를 반복해서 확인한다. 자주 확인하면 응답은 빨라지지만 사건이 없을 때도 CPU 시간을 쓰고, 확인 간격을 늘리면 처리가 늦어진다. 인터럽트는 이런 반복 확인을 줄일 수 있으나 사건이 빈번하면 진입, 복귀 비용이 커진다. 인터럽트로 처리를 시작한 뒤 폴링으로 여러 결과를 묶어 처리하는 설계도 사용한다.&amp;lt;ref name=&amp;quot;interrupt-polling&amp;quot;&amp;gt;[https://docs.kernel.org/networking/napi.html Linux 커널 문서: NAPI], 인터럽트와 폴링의 결합.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== 인터럽트와 동기적 예외 ===&lt;br /&gt;
장치 인터럽트는 비동기적 사건인 반면, [[운영체제 기본/보호#보호 위반과 예외|메모리 접근 예외]]는 현재 명령의 실행과 연결된다. 시스템 콜(System Call)도 프로그램이 정해진 진입 명령으로 요청하는 동기적 사건이다. 트랩이라는 용어의 범위는 아키텍처마다 다르며, RISC-V에서는 인터럽트와 예외에 따른 제어 이전을 모두 트랩이라고 부른다.&amp;lt;ref name=&amp;quot;riscv-terms&amp;quot;&amp;gt;[https://docs.riscv.org/reference/isa/v20240411/unpriv/intro.html#_exceptions_traps_and_interrupts RISC-V Instruction Set Manual: Exceptions, Traps, and Interrupts].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== 처리 진입점과 IDT ===&lt;br /&gt;
[[운영체제 기본/보호#보호 위반과 예외|보호]]에서 본 예외와 장치 인터럽트는 발생 원인이 다르지만, 사건의 종류에 맞는 처리 코드로 실행을 넘겨야 한다. 이를 사건 번호인 벡터(vector)와 처리 진입점의 대응 관계로 생각할 수 있다.&lt;br /&gt;
&lt;br /&gt;
x86-64의 전통적인 처리 방식에서는 운영체제가 인터럽트 서술자 테이블(Interrupt Descriptor Table, IDT)을 초기화하고 CPU에 그 위치를 등록한다. CPU는 예외나 인터럽트의 벡터를 인덱스로 사용해 IDT 항목을 선택한다. 예를 들어 #PF는 14번, #GP는 13번 항목을 선택하여 해당 게이트가 가리키는 커널 진입 코드로 넘어간다. 각 항목은 처리 코드의 주소와 커널 진입에 필요한 속성을 담은 게이트(gate)다. 여기에는 대상 코드 영역, 스택 선택 정보, 게이트 유형과 접근 제한 등이 포함된다.&amp;lt;ref name=&amp;quot;intel-idt&amp;quot;&amp;gt;Intel, [https://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-developer-vol-3a-part-1-manual.pdf Intel 64 and IA-32 Architectures Software Developer&#039;s Manual, Volume 3A], 2016년 9월, 6.10~6.14절 및 5.8.8절.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
페이지 매핑 부재, 권한 위반 -&amp;gt; #PF(14) -&amp;gt; IDT[14] -&amp;gt; 커널의 페이지 폴트 진입 코드&lt;br /&gt;
일반 보호 예외     -&amp;gt; #GP(13) -&amp;gt; IDT[13] -&amp;gt; 커널의 일반 보호 예외 진입 코드&lt;br /&gt;
장치의 인터럽트    -&amp;gt; 벡터 v  -&amp;gt; IDT[v]  -&amp;gt; 커널의 인터럽트 진입 코드&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
게이트의 서술자 특권 수준(Descriptor Privilege Level, DPL)은 &amp;lt;code&amp;gt;INT n&amp;lt;/code&amp;gt; 같은 소프트웨어 명령으로 그 진입점을 호출할 수 있는지를 제한한다. 하드웨어 인터럽트나 CPU가 검출한 예외에는 이 게이트 DPL 검사를 적용하지 않는다.&amp;lt;ref name=&amp;quot;intel-idt&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
페이지 폴트는 아직 준비되지 않은 정상 주소의 첫 접근에서도 발생할 수 있다. CPU는 현재 매핑으로 접근을 마칠 수 없음을 알릴 뿐이며, 커널이 매핑을 준비할지 오류로 처리할지 결정한다.&lt;br /&gt;
&lt;br /&gt;
진입할 때 CPU가 복귀에 필요한 일부 상태를 저장하고, 운영체제의 진입 코드가 필요한 상태를 추가로 보존한다. 처리가 끝나면 소프트웨어가 상태를 복원하고 &amp;lt;code&amp;gt;IRETQ&amp;lt;/code&amp;gt; 같은 복귀 명령으로 실행을 이어 간다. 스케줄러가 다른 프로세스를 선택하면 컨텍스트 스위치(Context Switch)를 거쳐 실행 대상을 바꾼다.&amp;lt;ref name=&amp;quot;intel-idt&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
구체적인 x86 진입 코드는 [[운영체제 기본/Linux/x86-64/i8042 키보드 입력/IRQ 진입과 디스패치#IDT와 C 진입점|키보드 IRQ 각론]]으로 이어진다. 다른 아키텍처의 진입 구조는 다를 수 있다. x86-64에서도 &amp;lt;code&amp;gt;SYSCALL&amp;lt;/code&amp;gt;은 IDT 대신 별도로 설정된 진입 주소를 사용한다.&amp;lt;ref name=&amp;quot;intel-idt&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== 진입, 상태 보존, 복귀 ===&lt;br /&gt;
CPU는 인터럽트를 받아들일 때 복귀 위치와 이전 실행 권한 등 필요한 최소 상태를 보존하고 설정된 처리기 진입점으로 이동한다. 진입 코드는 나머지 레지스터와 처리기에 필요한 스택을 준비한다. 하드웨어와 소프트웨어가 맡는 범위는 아키텍처마다 다르다. 사용자 코드 실행 중이었다면 커널 처리를 위한 권한 전환도 이루어지며, 진입점과 권한을 함께 통제해 보호 경계를 유지한다.&amp;lt;ref name=&amp;quot;xv6-entry&amp;quot;&amp;gt;Cox 외, [https://pdos.csail.mit.edu/6.1810/2025/xv6/book-riscv-rev5.pdf xv6], 2025, 4.1, 4.2절.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
원래 실행을 재개할 때는 저장 상태를 복원하고 복귀 절차를 거친다.&lt;br /&gt;
&lt;br /&gt;
=== 입출력 완료와 깨우기 ===&lt;br /&gt;
입출력을 기다리는 스레드는 대기 상태로 두고 다른 작업에 CPU를 줄 수 있다. 장치가 완료 인터럽트를 보내면 드라이버가 요청의 결과를 확인하고 해당 요청을 기다리던 스레드를 깨운다. 깨어난 스레드는 실행 가능 상태가 되어 스케줄러의 선택을 기다린다.&amp;lt;ref name=&amp;quot;xv6-io&amp;quot;&amp;gt;Cox 외, [https://pdos.csail.mit.edu/6.1810/2025/xv6/book-riscv-rev5.pdf xv6], 6.1, 9.1절.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
입출력 대기 -&amp;gt; 완료 통지 -&amp;gt; 결과 확인과 깨우기&lt;br /&gt;
           -&amp;gt; 실행 가능 상태 -&amp;gt; 스케줄러 선택 -&amp;gt; 실행 재개&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
장치 인터럽트는 다른 작업이 실행 중일 때도 도착한다. 따라서 인터럽트에서 복귀하는 대상과 방금 깨어난 스레드가 같다고 볼 수 없다. DMA 전송이라면 완료 확인 뒤 버퍼를 사용할 수 있는 상태로 동기화하는 일도 필요하다.&lt;br /&gt;
&lt;br /&gt;
=== 타이머 인터럽트와 선점 ===&lt;br /&gt;
시스템 콜마다 실행 중인 작업을 양보시킨다고 가정하자. 다음 C 반복문에는 시스템 콜 자체가 없다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
while (1) {&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
시스템 콜을 유일한 양보 지점으로 삼았다면 커널은 다음 양보 지점을 기다려도 제어권을 돌려받지 못한다. 일반적인 선점형 시분할은 사용자 코드와 독립적으로 만료를 알리는 타이머를 사용한다. 커널이 통지 시각을 설정하면 반복문이 계속되어도 인터럽트로 다시 제어권을 얻을 수 있다.&amp;lt;ref name=&amp;quot;riscv-timer&amp;quot;&amp;gt;[https://docs.riscv.org/reference/isa/v20260120/priv/machine.html RISC-V Instruction Set Manual: Machine-Level ISA], 타이머와 인터럽트 레지스터.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
타이머 통지는 시간 계산과 선점 판단의 기회다. 다른 실행 가능 작업이 없거나 현재 작업을 유지할 이유가 있으면 그대로 복귀한다. 또한 인터럽트 진입을 잠시 막는 것과 스레드 선점을 미루는 것은 다른 제약이며, 안전한 시점까지 컨텍스트 스위치가 지연될 수 있다.&amp;lt;ref name=&amp;quot;preempt-safe&amp;quot;&amp;gt;[https://docs.kernel.org/locking/preempt-locking.html Linux 커널 문서: Proper Locking Under a Preemptible Kernel].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== 통지 빈도와 처리 비용 ===&lt;br /&gt;
인터럽트 통지나 컨텍스트 스위치를 자주 하면 응답 기회는 늘지만 처리기, 스케줄러 실행과 캐시 교란 비용도 늘 수 있다. 여러 사건을 묶으면 처리량은 좋아질 수 있지만 먼저 도착한 사건은 기다려야 한다. 처리량과 개별 요청의 지연 시간을 함께 고려해야 한다.&amp;lt;ref name=&amp;quot;switch-cache&amp;quot;&amp;gt;Mogul, Borg, [https://decdoc.itsx.net/WRL/WRL-TN-16.pdf The Effect of Context Switches on Cache Performance], 1990.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
원샷 타이머는 다음 필요한 시각에 한 번 울리도록 재설정할 수 있다. 틱리스 설계는 이를 활용해 불필요한 주기적 통지를 줄이면서 필요한 시점에 선점할 기회를 얻는다.&amp;lt;ref name=&amp;quot;dynamic-ticks&amp;quot;&amp;gt;[https://docs.kernel.org/timers/highres.html High resolution timers and dynamic ticks], [https://docs.kernel.org/timers/no_hz.html NO_HZ].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 실시간 제어와 RTOS ==&lt;br /&gt;
장치 제어에서는 결과뿐 아니라 도착 시점도 중요하다. 실시간 운영체제(RTOS: Real-Time Operating System)는 평균 처리량보다 응답 시간의 상한과 예측 가능성을 우선한다. 인터럽트를 막은 구간, 처리기 실행, 스케줄링과 잠금 대기뿐 아니라 버스 경쟁과 DMA 완료 대기도 실제 출력의 마감시간에 영향을 준다. 마감시간을 지킬 수 있는지 판단하려면 주어진 작업량과 하드웨어 조건에서 최악의 실행 시간과 대기 시간을 검토해야 한다.&amp;lt;ref name=&amp;quot;qnx-rtos-latency&amp;quot;&amp;gt;[https://qnx.com/developers/docs/7.1/com.qnx.doc.neutrino.sys_arch/topic/kernel_Scheduling_latency.html QNX Neutrino 7.1: Scheduling latency], 인터럽트 지연과 스케줄링 지연의 구분.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 관련 문서 ==&lt;br /&gt;
* [[운영체제 기본/파일과 입출력]]: 장치 위에서 제공하는 파일, 버퍼링, 영속성.&lt;br /&gt;
* [[운영체제 기본/Linux/x86-64/i8042 키보드 입력]]: i8042의 IRQ부터 입력 이벤트와 프로세스 깨우기까지.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/보호|보호와 시스템 콜]]&lt;br /&gt;
|목차=[[운영체제 기본#총론|총론 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/프로세스와 스레드|프로세스와 스레드]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/BIOS_%EB%B6%80%ED%8C%85/GDT%EC%99%80_LDT_%EC%B4%88%EA%B8%B0%ED%99%94&amp;diff=715</id>
		<title>운영체제 기본/Linux/x86-64/BIOS 부팅/GDT와 LDT 초기화</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/BIOS_%EB%B6%80%ED%8C%85/GDT%EC%99%80_LDT_%EC%B4%88%EA%B8%B0%ED%99%94&amp;diff=715"/>
		<updated>2026-11-15T06:11:17Z</updated>

		<summary type="html">&lt;p&gt;관리자: 문체 정리: 남은 가운뎃점과 조사 중복 수정&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/진입 규약과 압축 해제|진입 규약과 압축 해제]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/x86-64/BIOS 부팅|BIOS 부팅 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/커널 초기화|커널 초기화]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
BIOS에서 출발해 GRUB의 &amp;lt;code&amp;gt;linux&amp;lt;/code&amp;gt; 명령으로 Linux v6.12 x86-64 bzImage를 부팅하는 경로에서는, GRUB이 32비트 보호 모드의 실행 환경을 만들어 압축 해제기의 &amp;lt;code&amp;gt;startup_32&amp;lt;/code&amp;gt;에 제어를 넘긴다. 이 시점에는 GRUB가 준비한 임시 GDT를 사용한다. Linux는 실행 모드의 전환, 압축 해제기의 이동, 커널 가상 주소로의 전환, CPU별 자료구조의 설치에 맞추어 GDTR을 여러 번 갱신한다. GRUB이 준비하는 초기 CPU 상태는 [[운영체제 기본/Linux/x86-64/BIOS 부팅/GRUB의 커널 적재와 제어권 전달|GRUB의 커널 적재와 제어권 전달]]에서 이어진다.&amp;lt;ref name=&amp;quot;gdt-boot&amp;quot;&amp;gt;[https://docs.kernel.org/6.12/arch/x86/boot.html Linux v6.12, The Linux/x86 Boot Protocol], 32-bit Boot Protocol.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 디스크립터와 선택자, 테이블 레지스터 ==&lt;br /&gt;
&lt;br /&gt;
디스크립터(descriptor)는 CPU가 세그먼트의 성질을 판단할 때 읽는 메모리상의 항목이다. 코드인지 데이터인지, 어느 특권 수준에서 접근할 수 있는지, 코드가 32비트인지 64비트인지 등을 담는다. GDT(Global Descriptor Table)는 그 항목들을 배열로 모은 것이다. GDT의 global은 LDT(Local Descriptor Table)와 대비되는 이름이며, CPU마다 별도의 GDT를 사용할 수 있다.&lt;br /&gt;
&lt;br /&gt;
선택자(selector)는 디스크립터를 선택하는 16비트 값이다. 상위 13비트는 인덱스, TI 비트는 GDT 또는 LDT의 선택, 하위 2비트는 요청 특권 수준인 RPL(Requested Privilege Level)이다. 예를 들어 x86-64 Linux의 &amp;lt;code&amp;gt;__KERNEL_CS&amp;lt;/code&amp;gt;는 GDT 인덱스 2를 가리키는 &amp;lt;code&amp;gt;0x10&amp;lt;/code&amp;gt;이다. 실행 모드는 선택한 디스크립터의 속성에 따라 정해진다.&amp;lt;ref name=&amp;quot;gdt-intel&amp;quot;&amp;gt;[https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html Intel 64 and IA-32 Architectures Software Developer&#039;s Manual], Volume 3A, System Architecture Overview, Protected-Mode Memory Management, Task Management. GDTR, LDTR, TR, 세그먼트 선택자와 IA-32e 모드의 테이블을 설명한다.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;gdt-segment&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/include/asm/segment.h?h=v6.12 Linux v6.12, arch/x86/include/asm/segment.h].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
! 항목 !! 무엇을 가리키는가 !! 적재 명령의 의미&lt;br /&gt;
|-&lt;br /&gt;
| GDTR || GDT의 선형 주소와 한계값 || &amp;lt;code&amp;gt;lgdt&amp;lt;/code&amp;gt;는 메모리의 base와 limit 묶음을 읽는다. 테이블 자체를 새로 생성하지 않는다.&lt;br /&gt;
|-&lt;br /&gt;
| CS, DS 등 || 코드 및 데이터 디스크립터의 선택자와 내부에 캐시된 속성 || 세그먼트 레지스터를 적재하면 해당 항목의 속성을 다시 읽는다. CS를 바꾸려면 far jump/return 같은 제어 이동이 필요하다.&lt;br /&gt;
|-&lt;br /&gt;
| LDTR || GDT 안의 LDT 디스크립터가 지정한 LDT || &amp;lt;code&amp;gt;lldt&amp;lt;/code&amp;gt;의 피연산자는 선택자다. null 선택자를 적재하면 사용할 LDT가 없는 상태가 된다.&lt;br /&gt;
|-&lt;br /&gt;
| TR(Task Register) || GDT 안의 TSS 디스크립터가 지정한 TSS || &amp;lt;code&amp;gt;ltr&amp;lt;/code&amp;gt;도 선택자를 받는다. TSS(Task State Segment)는 스택 정보 등을 담는 구조체다.&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;lgdt&amp;lt;/code&amp;gt;만 실행한다고 현재 CS의 내부 속성이 새 GDT의 내용으로 즉시 바뀌지 않는다. 이 때문에 아래 코드에서는 GDT를 바꾼 뒤 데이터 세그먼트를 다시 적재하고, far return으로 CS도 다시 적재한다.&amp;lt;ref name=&amp;quot;gdt-intel&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 부트로더와 압축 해제기의 GDT ==&lt;br /&gt;
32비트 부트 프로토콜은 진입 시 페이징이 꺼진 보호 모드, 비활성화된 인터럽트, GDT의 적절한 32비트 코드 및 데이터 세그먼트를 요구한다. CS는 &amp;lt;code&amp;gt;__BOOT_CS=0x10&amp;lt;/code&amp;gt;, DS, ES, SS는 &amp;lt;code&amp;gt;__BOOT_DS=0x18&amp;lt;/code&amp;gt;이며, 세그먼트는 base 0의 평탄한 주소 공간을 제공한다. &amp;lt;code&amp;gt;%esi&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;boot_params&amp;lt;/code&amp;gt;를 가리킨다. GRUB는 이 상태로 Linux에 제어권을 넘긴다.&amp;lt;ref name=&amp;quot;gdt-boot&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;gdt-segment&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
압축 해제기의 &amp;lt;code&amp;gt;arch/x86/boot/compressed/head_64.S:startup_32&amp;lt;/code&amp;gt;는 먼저 실제 적재 주소를 계산한다. 그 주소를 이용해 자체 &amp;lt;code&amp;gt;gdt&amp;lt;/code&amp;gt;의 base를 고친 뒤 &amp;lt;code&amp;gt;lgdt&amp;lt;/code&amp;gt;를 실행한다. 이 GDT에는 32비트 커널 코드, 64비트 커널 코드, 데이터, 부트용 TSS 디스크립터가 들어 있다.&amp;lt;ref name=&amp;quot;gdt-compressed&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/boot/compressed/head_64.S?h=v6.12 Linux v6.12, arch/x86/boot/compressed/head_64.S], startup_32, startup_64, gdt, gdt64.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
다음은 이 교체를 보여 주는 원본의 일부다. &amp;lt;code&amp;gt;rva()&amp;lt;/code&amp;gt;는 압축 해제기 시작점에 대한 상대 위치를 나타내며, 이 구간에서 &amp;lt;code&amp;gt;%ebp&amp;lt;/code&amp;gt;는 실제 적재 위치를 반영한다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
/* arch/x86/boot/compressed/head_64.S:startup_32 */&lt;br /&gt;
leal    rva(gdt)(%ebp), %eax&lt;br /&gt;
movl    %eax, 2(%eax)&lt;br /&gt;
lgdt    (%eax)&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이어서 &amp;lt;code&amp;gt;__BOOT_DS&amp;lt;/code&amp;gt;를 DS, ES, FS, GS, SS에 넣고, 스택을 준비한다. &amp;lt;code&amp;gt;__KERNEL32_CS&amp;lt;/code&amp;gt;와 다음 명령의 주소를 스택에 쌓은 뒤 &amp;lt;code&amp;gt;lretl&amp;lt;/code&amp;gt;로 CS를 새 GDT의 32비트 코드 항목으로 바꾼다. 같은 선택자라도 GDT 교체 전후에 디스크립터의 속성이 달라질 수 있으므로 CS를 다시 적재한다.&amp;lt;ref name=&amp;quot;gdt-compressed&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 64비트 모드 전환과 GDT ==&lt;br /&gt;
압축 해제기는 PAE를 켜고 초기 페이지 테이블을 준비해 CR3에 넣으며, EFER의 LME 비트를 설정한다. 이어서 다음과 같이 LDTR을 비우고 부트용 TSS 선택자를 TR에 적재한다.&amp;lt;ref name=&amp;quot;gdt-compressed&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
/* arch/x86/boot/compressed/head_64.S:startup_32 */&lt;br /&gt;
xorl    %eax, %eax&lt;br /&gt;
lldt    %ax&lt;br /&gt;
movl    $__BOOT_TSS, %eax&lt;br /&gt;
ltr     %ax&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
여기서 &amp;lt;code&amp;gt;lldt %ax&amp;lt;/code&amp;gt;는 0인 선택자를 넣어 LDT를 사용하지 않도록 한다. 부트용 TSS 역시 나중에 CPU별 예외 스택을 담을 정상 운영용 TSS와 구분해야 한다.&lt;br /&gt;
&lt;br /&gt;
그 다음 &amp;lt;code&amp;gt;__KERNEL_CS&amp;lt;/code&amp;gt;와 압축 해제기의 &amp;lt;code&amp;gt;startup_64&amp;lt;/code&amp;gt; 주소를 스택에 놓고 CR0.PG를 켠다. 이때 페이징과 long mode가 활성화되어도 기존 CS의 속성은 여전히 32비트 코드이므로, 마지막 &amp;lt;code&amp;gt;lret&amp;lt;/code&amp;gt;로 CS.L=1인 항목을 선택해야 64비트 명령 실행으로 넘어간다. 페이지 테이블은 주소 변환을 준비하고, 코드 디스크립터는 어느 실행 모드의 코드를 실행할지 결정한다.&amp;lt;ref name=&amp;quot;gdt-compressed&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;gdt-intel&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
GRUB handoff          startup_32                  startup_64&lt;br /&gt;
------------------    ------------------------    ---------------------&lt;br /&gt;
32-bit protected      load decompressor GDT       execute 64-bit code&lt;br /&gt;
paging off        --&amp;gt; reload DS/ES/SS and CS   --&amp;gt; reload GDT and CS&lt;br /&gt;
GRUB GDT              clear LDTR, load boot TR    relocate decompressor&lt;br /&gt;
                      enable PAE, LME, paging     repoint GDTR&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
압축 해제기의 &amp;lt;code&amp;gt;startup_64&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;gdt64&amp;lt;/code&amp;gt;를 이용해 GDTR을 다시 적재하고 &amp;lt;code&amp;gt;lretq&amp;lt;/code&amp;gt;로 CS를 확인한다. 여기서 &amp;lt;code&amp;gt;gdt64&amp;lt;/code&amp;gt;는 같은 &amp;lt;code&amp;gt;gdt&amp;lt;/code&amp;gt;를 가리킬 64비트 base를 담는 GDTR 적재용 구조다. 이후 압축 해제기를 다른 위치로 복사하면 GDTR도 복사된 GDT를 가리키도록 다시 바꾼다. 이전 위치의 GDT가 복사나 압축 해제 과정에서 덮일 수 있기 때문이다. 이 단계에서는 실행 모드와 메모리 위치가 바뀔 때마다 &amp;lt;code&amp;gt;lgdt&amp;lt;/code&amp;gt;를 실행한다.&amp;lt;ref name=&amp;quot;gdt-compressed&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 커널의 CPU별 GDT 설치 ==&lt;br /&gt;
압축 해제기가 넘기는 다음 &amp;lt;code&amp;gt;startup_64&amp;lt;/code&amp;gt;는 다른 파일의 다른 진입점이다. &amp;lt;code&amp;gt;arch/x86/kernel/head_64.S:startup_64&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;startup_64_setup_gdt_idt()&amp;lt;/code&amp;gt;를 호출한다. 이 함수는 초기 CPU용 &amp;lt;code&amp;gt;gdt_page.gdt&amp;lt;/code&amp;gt;를 현재 접근 가능한 주소로 가리키는 GDTR 값을 만들고 &amp;lt;code&amp;gt;native_load_gdt()&amp;lt;/code&amp;gt;로 적재한다. 이어 DS, SS, ES를 &amp;lt;code&amp;gt;__KERNEL_DS&amp;lt;/code&amp;gt;로 다시 적재한다.&amp;lt;ref name=&amp;quot;gdt-head&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/kernel/head_64.S?h=v6.12 Linux v6.12, arch/x86/kernel/head_64.S], startup_64와 .Lsetup_gdt.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;gdt-headc&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/kernel/head64.c?h=v6.12 Linux v6.12, arch/x86/kernel/head64.c], startup_64_setup_gdt_idt().&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
본체의 공통 초기 경로에 있는 &amp;lt;code&amp;gt;.Lsetup_gdt&amp;lt;/code&amp;gt;에서는 &amp;lt;code&amp;gt;gdt_page&amp;lt;/code&amp;gt;와 CPU별 오프셋으로 GDT 주소를 구해 다시 &amp;lt;code&amp;gt;lgdt&amp;lt;/code&amp;gt;한다. 이제 GDTR도 커널 주소 공간에서 계속 접근할 수 있는 주소를 가리켜야 한다. 초기에 접근 가능하던 낮은 주소에 GDT가 남아 있다면, 그 매핑을 제거한 뒤에는 새로운 디스크립터를 읽을 수 없기 때문이다.&amp;lt;ref name=&amp;quot;gdt-head&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;gdt_page&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;arch/x86/kernel/cpu/common.c&amp;lt;/code&amp;gt;에서 &amp;lt;code&amp;gt;DEFINE_PER_CPU_PAGE_ALIGNED&amp;lt;/code&amp;gt;로 선언된다. 32비트와 64비트 커널 코드와 사용자 코드, 커널 및 사용자 데이터 항목 등은 정적 초기값을 가진다. 초기 부트 CPU용 영역에서 시작하고, &amp;lt;code&amp;gt;start_kernel()&amp;lt;/code&amp;gt;의 &amp;lt;code&amp;gt;setup_per_cpu_areas()&amp;lt;/code&amp;gt; 단계에서 정규 CPU별 영역을 준비한 뒤 부트 CPU도 &amp;lt;code&amp;gt;switch_gdt_and_percpu_base()&amp;lt;/code&amp;gt;로 그 영역으로 옮겨 간다.&amp;lt;ref name=&amp;quot;gdt-common&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/kernel/cpu/common.c?h=v6.12 Linux v6.12, arch/x86/kernel/cpu/common.c], gdt_page, cpu_init_exception_handling(), cpu_init(), load_fixmap_gdt().&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;gdt-percpu&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/kernel/setup_percpu.c?h=v6.12 Linux v6.12, arch/x86/kernel/setup_percpu.c], setup_per_cpu_areas().&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이 순서 이후 &amp;lt;code&amp;gt;trap_init()&amp;lt;/code&amp;gt;이 CPU entry area와 정상 운영용 TSS를 준비한다. 다음 도식은 부트 CPU의 관계를 요약한다. 전체 커널 초기화 순서는 [[운영체제 기본/Linux/x86-64/BIOS 부팅/커널 초기화|커널 초기화]]에서 이어진다.&amp;lt;ref name=&amp;quot;gdt-main&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/init/main.c?h=v6.12 Linux v6.12, init/main.c], start_kernel().&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;gdt-traps&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/kernel/traps.c?h=v6.12 Linux v6.12, arch/x86/kernel/traps.c], trap_init().&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
Native kernel startup_64&lt;br /&gt;
  |&lt;br /&gt;
  +--&amp;gt; startup_64_setup_gdt_idt()   initial kernel GDT&lt;br /&gt;
  +--&amp;gt; .Lsetup_gdt                 kernel-address GDT&lt;br /&gt;
  |&lt;br /&gt;
start_kernel()&lt;br /&gt;
  |&lt;br /&gt;
  +--&amp;gt; setup_per_cpu_areas()       permanent per-CPU storage&lt;br /&gt;
  |      +--&amp;gt; switch_gdt_and_percpu_base()&lt;br /&gt;
  |&lt;br /&gt;
  +--&amp;gt; trap_init()&lt;br /&gt;
         +--&amp;gt; setup_cpu_entry_areas()&lt;br /&gt;
         +--&amp;gt; cpu_init_exception_handling(true)&lt;br /&gt;
         |      +--&amp;gt; set_tss_desc()&lt;br /&gt;
         |      +--&amp;gt; load_TR_desc()             LTR&lt;br /&gt;
         +--&amp;gt; cpu_init()&lt;br /&gt;
                +--&amp;gt; load_mm_ldt(&amp;amp;init_mm)      null LDTR&lt;br /&gt;
                +--&amp;gt; load_fixmap_gdt(cpu)       LGDT&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 정상 운영용 TSS와 LDT 초기화 ==&lt;br /&gt;
=== TSS와 예외 진입 상태 ===&lt;br /&gt;
64비트 Linux는 소프트웨어로 태스크를 전환하고, TSS는 스택 정보를 제공하는 데 사용한다. [[운영체제 기본/장치 제어와 입출력#처리 진입점과 IDT|IDT를 통한 처리 진입]]에서 TSS는 특권 전환용 스택과 IST(Interrupt Stack Table) 정보를 제공한다. 예를 들어 이중 오류나 NMI를 현재 실행 중인 코드의 불안정한 스택과 분리된 스택으로 받는 데 쓰인다. 이는 [[운영체제 기본/보호|보호]]에서 다루는 안전한 커널 진입의 구체적인 장치다.&amp;lt;ref name=&amp;quot;gdt-intel&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;gdt-common&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
v6.12에서는 &amp;lt;code&amp;gt;trap_init()&amp;lt;/code&amp;gt;가 먼저 &amp;lt;code&amp;gt;setup_cpu_entry_areas()&amp;lt;/code&amp;gt;를 부른다. 이어 &amp;lt;code&amp;gt;cpu_init_exception_handling(true)&amp;lt;/code&amp;gt;가 CPU별 &amp;lt;code&amp;gt;cpu_tss_rw&amp;lt;/code&amp;gt;의 IST 및 I/O 비트맵 상태를 준비하고, &amp;lt;code&amp;gt;set_tss_desc()&amp;lt;/code&amp;gt;로 GDT의 TSS 디스크립터를 설정한다. 마지막으로 &amp;lt;code&amp;gt;load_TR_desc()&amp;lt;/code&amp;gt;가 실제 &amp;lt;code&amp;gt;ltr&amp;lt;/code&amp;gt;를 수행한다. 즉 TSS 메모리 준비, GDT에 주소 기록, TR 적재의 세 단계다.&amp;lt;ref name=&amp;quot;gdt-traps&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;gdt-common&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;gdt-desc&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/include/asm/desc.h?h=v6.12 Linux v6.12, arch/x86/include/asm/desc.h], native_load_gdt(), native_load_tr_desc(), native_set_ldt(), clear_LDT().&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
그 뒤의 &amp;lt;code&amp;gt;cpu_init()&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;load_sp0()&amp;lt;/code&amp;gt;로 진입 스택을 지정하고, 마지막에 &amp;lt;code&amp;gt;load_fixmap_gdt(cpu)&amp;lt;/code&amp;gt;를 통해 CPU별 GDT의 읽기 전용 매핑을 GDTR에 적재한다. 쓰기용 원본과 CPU가 읽는 매핑은 같은 테이블에 서로 다른 주소와 권한으로 접근한다.&amp;lt;ref name=&amp;quot;gdt-common&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;gdt-desc&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;gdt-cea&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/mm/cpu_entry_area.c?h=v6.12 Linux v6.12, arch/x86/mm/cpu_entry_area.c], setup_cpu_entry_area().&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== 기본 부팅의 LDT 비활성화 ===&lt;br /&gt;
기본 부팅의 &amp;lt;code&amp;gt;init_mm&amp;lt;/code&amp;gt;에는 사용자 LDT가 없으므로, &amp;lt;code&amp;gt;cpu_init()&amp;lt;/code&amp;gt;의 &amp;lt;code&amp;gt;load_mm_ldt(&amp;amp;init_mm)&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;clear_LDT()&amp;lt;/code&amp;gt; 경로로 가고, 최종적으로 0 선택자를 &amp;lt;code&amp;gt;lldt&amp;lt;/code&amp;gt;한다. 앞서 압축 해제기에서 LDTR을 비운 것과 일관되게, 사용하지 않는 상태를 명시적으로 만든다.&amp;lt;ref name=&amp;quot;gdt-common&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;gdt-ldt&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/kernel/ldt.c?h=v6.12 Linux v6.12, arch/x86/kernel/ldt.c], load_mm_ldt(), switch_ldt(), modify_ldt 시스템 콜.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;gdt-desc&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이후 &amp;lt;code&amp;gt;CONFIG_MODIFY_LDT_SYSCALL&amp;lt;/code&amp;gt;이 활성화되어 있고 사용자 프로그램이 &amp;lt;code&amp;gt;modify_ldt()&amp;lt;/code&amp;gt;를 요청하면, 해당 &amp;lt;code&amp;gt;mm&amp;lt;/code&amp;gt;의 &amp;lt;code&amp;gt;mm-&amp;gt;context.ldt&amp;lt;/code&amp;gt;에 실제 LDT가 생길 수 있다. 그때는 GDT의 LDT 디스크립터에 테이블의 주소와 크기를 기록하고, 그 항목의 선택자를 LDTR에 적재한다. 이 경로는 호환성 등의 목적으로 LDT가 필요한 사용자 실행 문맥을 설정한다.&amp;lt;ref name=&amp;quot;gdt-ldt&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;gdt-desc&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;gdt-mmucontext&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/include/asm/mmu_context.h?h=v6.12 Linux v6.12, arch/x86/include/asm/mmu_context.h], CONFIG_MODIFY_LDT_SYSCALL과 load_mm_ldt().&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== long mode의 GDT 역할 ==&lt;br /&gt;
64비트 코드의 일반적인 주소 계산에서는 CS, DS, ES, SS의 base가 0으로 취급되고 전통적인 세그먼트 limit 검사도 대부분 적용되지 않는다. 프로세스별 주소 공간과 페이지 단위 접근 제어의 중심은 페이지 테이블이다. GDT는 코드의 실행 모드와 특권 수준, 사용자 모드 복귀 시 선택자 검사, TSS와 LDT 같은 시스템 디스크립터에 계속 사용된다. FS와 GS의 base도 별도 의미를 유지한다. 주소 변환 자체는 [[운영체제 기본/가상 메모리|가상 메모리]], 특권 수준, 진입과 복귀는 [[운영체제 기본/보호|보호]]와 구분해 읽는다.&amp;lt;ref name=&amp;quot;gdt-intel&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;gdt-common&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;references/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/진입 규약과 압축 해제|진입 규약과 압축 해제]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/x86-64/BIOS 부팅|BIOS 부팅 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/커널 초기화|커널 초기화]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/BIOS_%EB%B6%80%ED%8C%85/PID_1_%EC%83%9D%EC%84%B1&amp;diff=714</id>
		<title>운영체제 기본/Linux/x86-64/BIOS 부팅/PID 1 생성</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/BIOS_%EB%B6%80%ED%8C%85/PID_1_%EC%83%9D%EC%84%B1&amp;diff=714"/>
		<updated>2026-11-15T06:10:25Z</updated>

		<summary type="html">&lt;p&gt;관리자: 기존 절 링크 호환성을 위한 앵커 보존&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/커널 초기화|커널 초기화]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/x86-64/BIOS 부팅|BIOS 부팅 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/루트 파일시스템과 init 선택|루트 파일시스템과 init 선택]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
Linux v6.12에서 [[운영체제 기본/Linux/x86-64/BIOS 부팅/커널 초기화#커널 스택과 CPU 상태 설정|부트 태스크]]는 &amp;lt;code&amp;gt;rest_init()&amp;lt;/code&amp;gt;에 도달하면 PID 1과 &amp;lt;code&amp;gt;kthreadd&amp;lt;/code&amp;gt;를 만든다. PID 1은 커널의 나머지 초기화를 맡고, 기존 부트 태스크인 PID 0은 idle 태스크로 남는다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;span id=&amp;quot;PID_0·PID_1·kthreadd의_역할&amp;quot;&amp;gt;&amp;lt;/span&amp;gt;&lt;br /&gt;
== PID 0, PID 1, kthreadd의 역할 ==&lt;br /&gt;
&amp;lt;code&amp;gt;rest_init()&amp;lt;/code&amp;gt;은 먼저 &amp;lt;code&amp;gt;user_mode_thread(kernel_init, NULL, CLONE_FS)&amp;lt;/code&amp;gt;를 호출해 PID 1을 만든다. 이어 &amp;lt;code&amp;gt;kernel_thread()&amp;lt;/code&amp;gt;로 &amp;lt;code&amp;gt;kthreadd&amp;lt;/code&amp;gt;(PID 2)를 만든다. 기존 부트 태스크는 스케줄러를 거쳐 &amp;lt;code&amp;gt;cpu_startup_entry()&amp;lt;/code&amp;gt;의 idle 경로로 진행한다.&amp;lt;ref name=&amp;quot;main&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/init/main.c?h=v6.12 v6.12 init/main.c], rest_init.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
새 PID 1 태스크는 별도의 실행 문맥에서 &amp;lt;code&amp;gt;kernel_init()&amp;lt;/code&amp;gt;을 실행한다. 실행 상태와 자원의 구분은 [[운영체제 기본/프로세스와 스레드|프로세스와 스레드]]에서 설명한다. 이후 어떤 태스크가 CPU를 사용할지는 스케줄링에 따라 달라진다. 기존 PID 0은 idle 태스크로 계속 존재한다.&amp;lt;ref name=&amp;quot;fork&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/kernel/fork.c?h=v6.12 v6.12 kernel/fork.c], user_mode_thread, kernel_thread, kernel_clone.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
PID 0: start_kernel -&amp;gt; rest_init -----------------&amp;gt; idle&lt;br /&gt;
                         |&lt;br /&gt;
                         +-- create PID 1 -&amp;gt; kernel_init&lt;br /&gt;
                         |&lt;br /&gt;
                         +-- create PID 2 -&amp;gt; kthreadd&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== user_mode_thread와 kernel_init ==&lt;br /&gt;
&amp;lt;code&amp;gt;user_mode_thread()&amp;lt;/code&amp;gt;는 시작 함수와 인자를 &amp;lt;code&amp;gt;kernel_clone_args&amp;lt;/code&amp;gt;에 담아 &amp;lt;code&amp;gt;kernel_clone()&amp;lt;/code&amp;gt;에 넘긴다. 이 경우 시작 함수는 커널 내부 함수인 &amp;lt;code&amp;gt;kernel_init()&amp;lt;/code&amp;gt;이다.&amp;lt;ref name=&amp;quot;fork&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;kernel_thread()&amp;lt;/code&amp;gt;와의 차이는 &amp;lt;code&amp;gt;kthread&amp;lt;/code&amp;gt; 속성을 설정하지 않는다는 점이다. 계속 커널 스레드로 남을 태스크와 나중에 사용자 실행 이미지를 갖게 될 태스크의 생성 방식이 구별된다. 실제로 &amp;lt;code&amp;gt;kernel_execve()&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;PF_KTHREAD&amp;lt;/code&amp;gt;가 설정된 태스크의 호출을 거부한다. PID 1은 처음에 커널 코드를 실행하지만 &amp;lt;code&amp;gt;PF_KTHREAD&amp;lt;/code&amp;gt;가 설정되지 않아 이후 exec를 수행할 수 있다.&amp;lt;ref name=&amp;quot;fork&amp;quot;/&amp;gt;&amp;lt;ref&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/exec.c?h=v6.12 v6.12 fs/exec.c], kernel_execve.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
사용자 프로그램을 실행할 태스크 역시 커널에 진입해 커널 코드를 실행할 수 있다. PID 1은 아직 첫 사용자 실행 이미지를 얻기 전이다. 보호 경계 자체는 [[운영체제 기본/보호|보호]]를 참고한다.&lt;br /&gt;
&lt;br /&gt;
== kthreadd 생성과 PID 1의 대기 ==&lt;br /&gt;
PID 1이라는 번호를 얻도록 init을 먼저 생성하지만, init이 진행하며 사용할 커널 스레드 생성 기반인 &amp;lt;code&amp;gt;kthreadd&amp;lt;/code&amp;gt;는 그다음 만들어진다. 태스크 생성 순서와 실행 순서는 다를 수 있으므로 두 태스크 사이에 동기화가 필요하다.&amp;lt;ref name=&amp;quot;main&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이 의존 관계를 표현하는 것이 &amp;lt;code&amp;gt;kthreadd_done&amp;lt;/code&amp;gt; completion이다. completion은 한쪽이 작업 완료를 알리고 다른 쪽이 그 사건을 기다리는 동기화 수단이다. 조건을 기다리는 작업과 깨우기의 관계는 [[운영체제 기본/동시성|동시성]]과 연결된다. &amp;lt;code&amp;gt;kernel_init()&amp;lt;/code&amp;gt;은 시작하자마자 기다리고, &amp;lt;code&amp;gt;rest_init()&amp;lt;/code&amp;gt;은 kthreadd 준비 후 완료를 알린다.&amp;lt;ref name=&amp;quot;main&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== PID 1의 커널 초기화와 initcall ==&lt;br /&gt;
대기가 끝나면 &amp;lt;code&amp;gt;kernel_init_freeable()&amp;lt;/code&amp;gt;이 SMP와 나머지 초기화를 진행한다. 여기에는 &amp;lt;code&amp;gt;do_basic_setup()&amp;lt;/code&amp;gt;을 통한 initcall 실행도 포함된다.&amp;lt;ref name=&amp;quot;main&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
initcall은 부팅 중 실행할 초기화 함수를 정해진 단계에 등록하는 방식이다. 소스의 각 부분이 등록한 함수들을 초기화 경로가 순회하며 실행하므로, &amp;lt;code&amp;gt;start_kernel()&amp;lt;/code&amp;gt; 안에 모든 드라이버의 함수 이름이 직접 나열될 필요는 없다. 예를 들어 rootfs에 initramfs를 푸는 &amp;lt;code&amp;gt;populate_rootfs()&amp;lt;/code&amp;gt;도 &amp;lt;code&amp;gt;rootfs_initcall&amp;lt;/code&amp;gt;로 등록되어 있다.&amp;lt;ref name=&amp;quot;main&amp;quot;/&amp;gt;&amp;lt;ref&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/init/initramfs.c?h=v6.12 v6.12 init/initramfs.c], populate_rootfs 및 rootfs_initcall 등록.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;kernel_init_freeable()&amp;lt;/code&amp;gt;에서 돌아온 뒤에도 비동기 초기화의 완료를 기다린다. 그래야 아직 실행 중인 초기화 코드가 있는데 그 코드를 담은 메모리를 먼저 해제하는 일이 없다. 이후 초기화용 메모리를 정리하고, 다음 장에서 다룰 init 선택과 exec로 진행한다.&amp;lt;ref name=&amp;quot;main&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/커널 초기화|커널 초기화]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/x86-64/BIOS 부팅|BIOS 부팅 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/루트 파일시스템과 init 선택|루트 파일시스템과 init 선택]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/%ED%94%84%EB%A1%9C%EC%84%B8%EC%8A%A4_%EA%B0%84_%ED%86%B5%EC%8B%A0&amp;diff=713</id>
		<title>운영체제 기본/프로세스 간 통신</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/%ED%94%84%EB%A1%9C%EC%84%B8%EC%8A%A4_%EA%B0%84_%ED%86%B5%EC%8B%A0&amp;diff=713"/>
		<updated>2026-11-15T06:10:23Z</updated>

		<summary type="html">&lt;p&gt;관리자: 강조와 특수문자, 상투적 대조를 정리하고 IPC 설명을 간결하게 수정&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/파일과 입출력|파일과 입출력]]&lt;br /&gt;
|목차=[[운영체제 기본#총론|총론 목차]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
프로세스마다 주소 공간을 나누면 한 프로그램의 잘못된 쓰기가 다른 프로그램의 사적인 메모리로 곧바로 번지는 일을 막을 수 있다. 하지만 이미지 편집기와 별도 변환 작업처럼 함께 일하는 프로그램들은 요청과 결과를 주고받아야 한다. 프로세스 간 통신 (Interprocess Communication, IPC)은 이 경계를 유지하면서 데이터와 사건을 교환하는 수단이다.&lt;br /&gt;
&lt;br /&gt;
== 통신 경계와 데이터 전달 ==&lt;br /&gt;
프로세스 A의 포인터 값만 B에게 보내서는 같은 객체를 읽을 수 없다. [[운영체제 기본/가상 메모리#주소 변환과 메모리 보호|각 주소 공간의 매핑]]이 다르므로 같은 주소가 다른 물리 페이지를 가리키거나, B에게는 유효하지 않을 수 있다. 데이터를 별도 통신 경로로 전달하거나, 두 프로세스가 접근할 수 있는 공유 영역을 명시적으로 만들어야 한다.&lt;br /&gt;
&lt;br /&gt;
이미지 변환 요청에는 세 가지 정보가 필요하다. 처리할 이미지 데이터, 어떤 변환을 원하는지 나타내는 요청, 그리고 작업이 끝났다는 통지다. 이들을 한 메시지에 담을 수도 있고, 큰 이미지 데이터는 공유 메모리에 두고 작은 요청과 완료 통지만 따로 전달할 수도 있다. 각 데이터의 저장 위치와 접근 순서를 정해야 한다.&lt;br /&gt;
&lt;br /&gt;
== 파이프와 메시지 ==&lt;br /&gt;
파이프 (Pipe)는 한쪽에서 쓴 바이트를 다른 쪽이 읽는 통신 통로다. Unix 계열의 일반적인 파이프는 읽기 끝과 쓰기 끝을 파일 디스크립터로 제공한다. 프로그램은 [[운영체제 기본/파일과 입출력#파일 이름, 객체, 열린 상태의 수명|열린 대상의 핸들]]과 읽기, 쓰기 연산으로 접근한다.&amp;lt;ref name=&amp;quot;pipe&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man7/pipe.7.html Linux man-pages: pipe(7)], 파이프의 입출력과 바이트 스트림.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
프로세스 A                       프로세스 B&lt;br /&gt;
요청 바이트 -&amp;gt; write -&amp;gt; [파이프 버퍼] -&amp;gt; read -&amp;gt; 요청 해석&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
파이프는 바이트 스트림이므로 한 번 쓴 범위가 한 번 읽은 범위와 일치하지 않는다. 예를 들어 A가 요청 두 개를 연이어 쓰면 B가 한 번에 둘을 읽거나, 요청 하나를 여러 번에 나누어 읽을 수 있다. 길이 필드나 구분자처럼 요청의 끝을 알아낼 규칙이 필요하다. 이 문제는 [[운영체제 기본/파일과 입출력#부분 입출력과 오류 처리|부분 입출력]]과 연결된다.&lt;br /&gt;
&lt;br /&gt;
반면 메시지 큐 (Message Queue)는 메시지 단위를 유지해 송수신한다. 수신자는 바이트 흐름에서 경계를 다시 찾는 대신 메시지를 받아 처리한다. 큐가 메시지를 고르는 순서는 구현의 규칙에 달려 있다. 예를 들어 POSIX 메시지 큐는 우선순위를 사용할 수 있다. 메시지 크기와 개수에는 한도가 있다.&amp;lt;ref name=&amp;quot;mq&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man7/mq_overview.7.html Linux man-pages: mq_overview(7)], 메시지 단위 송수신과 우선순위.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
소켓 (Socket)도 통신의 양 끝을 표현하는 수단이다. 같은 시스템의 프로세스 사이에서 사용할 수 있고, 네트워크를 통한 통신에도 사용된다. 스트림 소켓은 바이트 흐름을, 데이터그램 소켓은 메시지 단위를 제공한다.&amp;lt;ref name=&amp;quot;socket&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man2/socket.2.html Linux man-pages: socket(2)], 통신 도메인과 소켓 유형.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 대기와 흐름 제어 ==&lt;br /&gt;
수신할 데이터가 없으면 읽는 쪽은 조건이 바뀔 때까지 기다릴 수 있다. 반대로 보내는 쪽이 너무 빠르면 유한한 버퍼가 가득 찬다. 이때 송신을 기다리게 하거나, 비블로킹 요청에 지금은 진행할 수 없다는 결과를 돌려줄 수 있다. 이러한 역압 (Backpressure)은 느린 수신자 때문에 대기열과 메모리가 무한히 늘어나는 것을 막는다.&amp;lt;ref name=&amp;quot;pipe&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
기다리는 실행 흐름을 재우고, 데이터나 빈 공간이 생겼을 때 다시 실행 가능하게 할 수 있다. [[운영체제 기본/프로세스와 스레드#입출력 대기와 깨우기|깨어난 실행 흐름]]이 CPU를 사용할 시점은 스케줄러가 정한다.&lt;br /&gt;
&lt;br /&gt;
통신 상대의 종료도 규약에 포함해야 한다. 파이프의 모든 쓰기 끝이 닫히면 남은 데이터를 읽은 뒤 읽기 끝에서 EOF를 관찰한다. 읽기 끝이 모두 닫힌 파이프에 쓰면 Unix 계열에서는 &amp;lt;code&amp;gt;SIGPIPE&amp;lt;/code&amp;gt; 시그널이 발생할 수 있다.&amp;lt;ref name=&amp;quot;pipe&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 시그널과 사건 통지 ==&lt;br /&gt;
시그널 (Signal)은 프로세스나 스레드에 사건을 알리는 운영체제의 통지 수단이다. 다른 프로세스의 종료 요청, 자식 프로세스의 상태 변화, 실행 중 발생한 오류 등이 원인이 된다. Unix 계열의 &amp;lt;code&amp;gt;SIGTERM&amp;lt;/code&amp;gt;은 종료 요청, &amp;lt;code&amp;gt;SIGCHLD&amp;lt;/code&amp;gt;는 자식 상태 변화, &amp;lt;code&amp;gt;SIGSEGV&amp;lt;/code&amp;gt;는 잘못된 메모리 접근을 알리는 대표적인 예다.&amp;lt;ref name=&amp;quot;signal&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man7/signal.7.html Linux man-pages: signal(7)], 시그널의 생성, 전달, 처리.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[운영체제 기본/보호#보호 위반과 예외|하드웨어 예외]]는 CPU가 커널로 제어를 넘기는 사건이고, 시그널은 운영체제가 프로그램에 통지하는 수단이다. 메모리 접근 예외를 커널이 복구하지 못하면 시그널로 이어질 수 있지만, 커널이 페이지를 준비하고 명령을 다시 실행하면 오류 시그널 없이 진행할 수도 있다.&lt;br /&gt;
&lt;br /&gt;
시그널의 발생과 전달은 구분된다. 전달을 잠시 차단한 시그널은 보류 (Pending) 상태로 남을 수 있다. Linux에서는 커널이 사용자 실행으로 돌아가는 경로 등에서 전달 가능한 시그널을 확인하고, 등록된 처리 방식에 따라 동작한다. 사용자 핸들러는 해당 스레드의 사용자 모드 코드로 실행된다.&amp;lt;ref name=&amp;quot;signal&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
* 기본 동작: 시그널 종류에 정해진 종료, 정지, 계속, 무시 등의 동작을 따른다.&lt;br /&gt;
* 무시: 해당 시그널을 처리하지 않도록 지정한다. 전달을 미루는 차단과는 다르다.&lt;br /&gt;
* 핸들러: 프로그램이 등록한 함수로 사건을 처리한다. &amp;lt;code&amp;gt;SIGKILL&amp;lt;/code&amp;gt;과 &amp;lt;code&amp;gt;SIGSTOP&amp;lt;/code&amp;gt;은 핸들러를 등록하거나 차단, 무시할 수 없다.&lt;br /&gt;
&lt;br /&gt;
핸들러는 기존 코드의 실행 중간에 들어올 수 있다. 그 코드가 &amp;lt;code&amp;gt;printf&amp;lt;/code&amp;gt; 같은 함수의 내부 상태를 갱신하던 중이었다면, 핸들러에서 같은 함수를 다시 부르는 것이 안전하지 않을 수 있다. 핸들러에서는 비동기 시그널 안전 (Async-Signal-Safe) 조건을 만족하는 작업만 짧게 수행하고, 나머지 처리는 일반 실행 경로로 넘기는 방식이 필요하다.&amp;lt;ref name=&amp;quot;signal-safety&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man7/signal-safety.7.html Linux man-pages: signal-safety(7)], 핸들러의 재진입과 안전한 함수.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
시그널은 대량 데이터 전송보다 사건 통지에 적합하다. 특히 Linux의 표준 시그널 (Standard Signal)은 같은 종류가 보류된 동안 여러 번 발생해도 그 횟수를 일반 메시지 큐처럼 모두 보관하지 않는다. 완료 통지를 받으면 실제 상태나 대기열에서 처리할 결과를 확인해야 한다.&amp;lt;ref name=&amp;quot;signal&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 공유 메모리와 동기화 ==&lt;br /&gt;
큰 이미지를 매번 통신 버퍼에 복사하면 데이터 양에 비례한 비용이 생긴다. 공유 메모리 (Shared Memory)는 서로 다른 주소 공간이 같은 물리 페이지를 가리키게 하여, 참여자들이 그 영역을 직접 읽고 쓰게 한다. 매핑을 마련한 뒤에는 데이터 접근마다 송수신 시스템 콜과 커널 버퍼를 거치는 복사를 반복할 필요가 없다. 최초 매핑, 페이지 폴트, 캐시 일관성과 동기화에는 비용이 든다.&amp;lt;ref name=&amp;quot;shm&amp;quot;&amp;gt;Michael Kerrisk, [https://www.man7.org/training/download/lusp_pshm_slides.pdf POSIX Shared Memory], 공유 매핑과 세마포어를 이용한 동기화.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
프로세스 A의 주소 공간        공유 물리 페이지        프로세스 B의 주소 공간&lt;br /&gt;
가상 주소 0x400000 ---------&amp;gt; [ 이미지 데이터 ] &amp;lt;--------- 가상 주소 0x900000&lt;br /&gt;
                                같은 내용&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
두 프로세스의 가상 주소가 같을 필요는 없다. 따라서 공유 영역 안의 객체를 서로 참조할 때에도 한 프로세스의 포인터 값을 그대로 저장하기보다, 공유 영역 시작에서의 오프셋처럼 양쪽이 해석할 수 있는 표현이 필요하다. 파일, 익명 메모리를 공유 매핑하는 구체적인 방법은 [[운영체제 기본/Linux/메모리 매핑|Linux의 메모리 매핑]]에서 다룬다.&lt;br /&gt;
&lt;br /&gt;
공유 데이터의 읽기와 쓰기에는 동기화가 필요하다. A가 이미지의 절반만 바꿨는데 B가 읽으면 이전 내용과 새 내용이 섞일 수 있다. 같은 카운터를 동시에 증가시키면 [[운영체제 기본/동시성#공유 상태의 불변식과 레이스 컨디션|레이스 컨디션]]도 생긴다. 프로세스 사이에서 동작하도록 마련한 [[운영체제 기본/동시성#뮤텍스와 임계 구역|뮤텍스]], [[운영체제 기본/동시성#세마포어와 자원 수량|세마포어]]나 적절한 원자 연산 규약이 필요하다. 세마포어 (Semaphore)는 사용 가능한 자원이나 사건의 수를 관리하며, 그 수가 부족한 작업은 기다리게 할 수 있는 동기화 수단이다.&amp;lt;ref name=&amp;quot;shm&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이미지 슬롯 하나를 교환한다면 다음처럼 데이터 소유권과 알림을 연결할 수 있다. 두 세마포어는 프로세스 간 공유용으로 구성하고, &amp;lt;code&amp;gt;empty&amp;lt;/code&amp;gt;를 1, &amp;lt;code&amp;gt;ready&amp;lt;/code&amp;gt;를 0으로 시작한다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
생산자 A                         소비자 B&lt;br /&gt;
empty 대기                       ready 대기&lt;br /&gt;
공유 슬롯에 이미지 전체 기록       공유 슬롯의 이미지 처리&lt;br /&gt;
ready 알림                       empty 알림&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
A는 B가 읽는 동안 슬롯을 덮어쓰지 않고, B는 A가 완성한 뒤에만 읽는다. 이 동기화 규약은 슬롯의 사용 가능 상태와 메모리 접근 순서를 함께 연결한다. 참여자가 도중에 종료되면 기다림이 영원히 이어질 수 있으므로, 상대의 실패와 공유 객체의 수명도 설계해야 한다.&lt;br /&gt;
&lt;br /&gt;
쓰기 시 복사 (COW)와 쓰기 가능한 공유 메모리도 구분한다. COW는 쓰기 시 독립된 내용을 유지하려는 방식이고, IPC용 공유 메모리는 상대에게 변경이 보이도록 같은 내용을 공유하는 방식이다. [[운영체제 기본/가상 메모리#페이지 공유와 쓰기 시 복사|물리 페이지를 공유하는 이유]]가 다르다.&lt;br /&gt;
&lt;br /&gt;
== 통신 방식의 선택 ==&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
! 방식 !! 전달하는 것 !! 주된 설계 문제&lt;br /&gt;
|-&lt;br /&gt;
| 시그널 || 사건 통지 || 처리 시점과 핸들러 안전성, 통지와 실제 상태의 구분&lt;br /&gt;
|-&lt;br /&gt;
| 파이프, 스트림 || 순서 있는 바이트 흐름 || 메시지 경계, 부분 입출력, 버퍼와 역압&lt;br /&gt;
|-&lt;br /&gt;
| 메시지 큐 || 경계를 가진 메시지 || 크기, 개수 한도, 순서와 대기 규칙&lt;br /&gt;
|-&lt;br /&gt;
| 공유 메모리 || 같은 저장 영역 || 동기화, 소유권, 수명과 상대의 실패&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
작은 요청과 응답은 메시지로 전달하면 경계를 명확히 하기 쉽다. 큰 데이터를 반복해서 주고받는 경우에는 공유 메모리로 복사를 줄일 수 있지만 동기화 책임이 커진다. 큰 데이터는 공유 메모리에 두고, 제어 요청과 완료는 별도 통로로 주고받는 혼합 설계도 가능하다. 데이터 크기, 전달 빈도, 기다림과 장애 처리의 복잡도를 비교해 통신 방식을 선택한다.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/파일과 입출력|파일과 입출력]]&lt;br /&gt;
|목차=[[운영체제 기본#총론|총론 목차]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/ELF_%EB%A1%9C%EB%94%A9/%EC%B4%88%EA%B8%B0_%EC%8A%A4%ED%83%9D%EA%B3%BC_%EC%82%AC%EC%9A%A9%EC%9E%90_%EB%AA%A8%EB%93%9C_%EC%A7%84%EC%9E%85&amp;diff=712</id>
		<title>운영체제 기본/Linux/ELF 로딩/초기 스택과 사용자 모드 진입</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/ELF_%EB%A1%9C%EB%94%A9/%EC%B4%88%EA%B8%B0_%EC%8A%A4%ED%83%9D%EA%B3%BC_%EC%82%AC%EC%9A%A9%EC%9E%90_%EB%AA%A8%EB%93%9C_%EC%A7%84%EC%9E%85&amp;diff=712"/>
		<updated>2026-11-15T06:10:10Z</updated>

		<summary type="html">&lt;p&gt;관리자: 문체 정리: 강조와 반복 대조, 인용과 특수문자 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/ELF 로딩/ELF 세그먼트와 주소 공간|ELF 세그먼트와 주소 공간]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/ELF 로딩|ELF 로딩 목차]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
[[운영체제 기본/Linux/ELF 로딩/ELF 세그먼트와 주소 공간|ELF 세그먼트와 주소 공간]]에서는 실행 파일의 코드, 데이터와 BSS를 프로세스의 가상 주소 공간에 배치했다. 다음으로 프로그램에 전달할 인자와 스택을 만들고, 실행을 시작할 주소를 CPU의 복귀 상태에 기록한다.&lt;br /&gt;
&lt;br /&gt;
여기서도 정적 링크된 &amp;lt;code&amp;gt;ET_EXEC&amp;lt;/code&amp;gt;를 먼저 설명한다. 앞의 예처럼 코드가 &amp;lt;code&amp;gt;0x401000&amp;lt;/code&amp;gt;에 배치되고 ELF 헤더의 &amp;lt;code&amp;gt;e_entry&amp;lt;/code&amp;gt;도 &amp;lt;code&amp;gt;0x401000&amp;lt;/code&amp;gt;이라면, 이 주소가 새 프로그램의 첫 실행 주소이다. 기준 구현은 Linux v6.12의 x86-64와 RISC-V RV64이다. 실행 파일의 명령어와 대상 아키텍처 정보는 각각의 CPU에 맞아야 한다.&lt;br /&gt;
&lt;br /&gt;
== 초기 스택의 인자와 환경 변수 ==&lt;br /&gt;
&amp;lt;code&amp;gt;execve(path, argv, envp)&amp;lt;/code&amp;gt;에서 &amp;lt;code&amp;gt;argv&amp;lt;/code&amp;gt;는 인자 문자열들의 배열이고, &amp;lt;code&amp;gt;envp&amp;lt;/code&amp;gt;는 환경 변수 문자열들의 배열이다. 예를 들어 실행할 프로그램이 두 개의 인자를 받는다면, 새 프로그램은 인자 개수와 각 문자열의 주소를 알아야 한다.&lt;br /&gt;
&lt;br /&gt;
호출 당시의 포인터는 이전 프로그램의 주소 공간을 가리킨다. exec는 그 주소 공간을 새 이미지로 교체하므로 포인터 값만 그대로 넘길 수 없다. 커널은 exec 준비 과정에서 문자열을 새 실행을 위한 메모리에 복사하고, 새 사용자 스택의 위치를 정한다. 이어 ELF 로더의 &amp;lt;code&amp;gt;create_elf_tables()&amp;lt;/code&amp;gt;가 복사된 문자열을 가리키는 새 포인터 배열을 작성한다.&amp;lt;ref name=&amp;quot;exec&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/exec.c?h=v6.12 Linux v6.12, fs/exec.c], &amp;lt;code&amp;gt;copy_strings()&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;setup_arg_pages()&amp;lt;/code&amp;gt;.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;elf&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/binfmt_elf.c?h=v6.12 Linux v6.12, fs/binfmt_elf.c], &amp;lt;code&amp;gt;create_elf_tables()&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;load_elf_binary()&amp;lt;/code&amp;gt;.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
두 아키텍처의 네이티브 64비트 초기 사용자 스택은 낮은 주소부터 &amp;lt;code&amp;gt;argc&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;argv&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;envp&amp;lt;/code&amp;gt;, 보조 벡터 순서로 읽을 수 있다. 각 포인터 배열은 NULL로 끝난다. 다음 그림은 실제 주소가 증가하는 방향을 아래쪽으로 표시한 개념도이다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
Lower addresses&lt;br /&gt;
initial SP  --&amp;gt; +-------------------------------+&lt;br /&gt;
                | argc                          |&lt;br /&gt;
                | argv[0]                       |&lt;br /&gt;
                | argv[1]                       |&lt;br /&gt;
                | ...                           |&lt;br /&gt;
                | NULL                          |&lt;br /&gt;
                | envp[0]                       |&lt;br /&gt;
                | envp[1]                       |&lt;br /&gt;
                | ...                           |&lt;br /&gt;
                | NULL                          |&lt;br /&gt;
                | Auxiliary vector: type, value |&lt;br /&gt;
                | ...                           |&lt;br /&gt;
                | AT_NULL, 0                    |&lt;br /&gt;
                | Padding / other startup data  |&lt;br /&gt;
                | Argument/environment strings  |&lt;br /&gt;
                +-------------------------------+&lt;br /&gt;
Higher addresses&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
배열에는 문자열을 가리키는 새 사용자 주소가 들어간다. 커널은 스택 정렬도 맞춘다. 보조 벡터(auxv)는 페이지 크기처럼 시작 코드가 필요로 하는 실행 환경 정보를 전달하는 항목들의 목록이다.&lt;br /&gt;
&lt;br /&gt;
이 스택은 사용자 프로그램이 사용할 스택이다. 커널이 현재 ELF 로딩 함수를 실행하는 데 쓰는 커널 스택과는 다르다. 커널은 새 스택의 위치를 보관했다가 사용자 모드로 나갈 때 x86-64의 RSP 또는 RV64의 sp에 적용한다.&lt;br /&gt;
&lt;br /&gt;
== 사용자 모드 진입: x86-64와 RISC-V ==&lt;br /&gt;
&lt;br /&gt;
ELF 세그먼트를 매핑하고 초기 사용자 스택을 만드는 큰 흐름은 공통이다. 마지막에 CPU가 어떤 주소, 스택, 권한으로 실행을 시작할지 준비하는 방법은 아키텍처마다 다르다. 여기서는 Linux v6.12, 정적 링크된 &amp;lt;code&amp;gt;ET_EXEC&amp;lt;/code&amp;gt;를 기준으로 x86-64의 기본 복귀 경로와 RISC-V RV64의 S-mode 커널에서 U-mode로 나가는 경로를 비교한다.&lt;br /&gt;
&lt;br /&gt;
ELF 로더는 마지막에 &amp;lt;code&amp;gt;START_THREAD(..., elf_entry, bprm-&amp;gt;p)&amp;lt;/code&amp;gt;를 호출한다. RV64에서는 공통 헤더의 기본 매크로가 이를 &amp;lt;code&amp;gt;start_thread(regs, elf_entry, start_stack)&amp;lt;/code&amp;gt;로 연결한다. 진입 주소는 이 예의 &amp;lt;code&amp;gt;e_entry&amp;lt;/code&amp;gt;이며, 스택 주소는 인자와 환경 변수가 준비된 새 사용자 스택이다.&amp;lt;ref&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/binfmt_elf.c?h=v6.12 Linux v6.12, fs/binfmt_elf.c], &amp;lt;code&amp;gt;load_elf_binary()&amp;lt;/code&amp;gt;; [https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/linux/elf.h?h=v6.12 include/linux/elf.h], &amp;lt;code&amp;gt;START_THREAD&amp;lt;/code&amp;gt;.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== 사용자 복귀 상태 설정 ===&lt;br /&gt;
두 아키텍처 모두 &amp;lt;code&amp;gt;start_thread()&amp;lt;/code&amp;gt;에서 현재 태스크의 커널 스택에 있는 &amp;lt;code&amp;gt;pt_regs&amp;lt;/code&amp;gt;에 나중에 복원할 사용자 상태를 기록한다.&lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
! 준비할 상태 !! x86-64 !! RISC-V RV64&lt;br /&gt;
|-&lt;br /&gt;
| 첫 명령어 주소 || &amp;lt;code&amp;gt;regs-&amp;gt;ip&amp;lt;/code&amp;gt;: 나중의 RIP || &amp;lt;code&amp;gt;regs-&amp;gt;epc&amp;lt;/code&amp;gt;: 나중에 sepc에 쓸 값&lt;br /&gt;
|-&lt;br /&gt;
| 초기 사용자 스택 || &amp;lt;code&amp;gt;regs-&amp;gt;sp&amp;lt;/code&amp;gt;: 나중의 RSP || &amp;lt;code&amp;gt;regs-&amp;gt;sp&amp;lt;/code&amp;gt;: 나중의 sp(x2)&lt;br /&gt;
|-&lt;br /&gt;
| 사용자 권한으로 복귀 || 사용자 CS와 SS 선택자 || 저장된 status의 SPP=0&lt;br /&gt;
|-&lt;br /&gt;
| 실행 상태 || 저장된 flags || 저장된 status의 SPIE=1&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
x86-64의 &amp;lt;code&amp;gt;start_thread_common()&amp;lt;/code&amp;gt;은 새 명령어와 스택 주소, 사용자 선택자, 초기 플래그를 설정한다. RV64의 &amp;lt;code&amp;gt;start_thread()&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;epc&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;sp&amp;lt;/code&amp;gt;를 기록하고, &amp;lt;code&amp;gt;status&amp;lt;/code&amp;gt;를 &amp;lt;code&amp;gt;SR_PIE&amp;lt;/code&amp;gt;에서 시작해 구성한다. 여기서 &amp;lt;code&amp;gt;SR_PIE&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;SR_SPIE&amp;lt;/code&amp;gt;를 뜻하며, 복귀 권한을 나타내는 &amp;lt;code&amp;gt;SPP&amp;lt;/code&amp;gt;는 0이다.&amp;lt;ref&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/kernel/process_64.c?h=v6.12 Linux v6.12, arch/x86/kernel/process_64.c], &amp;lt;code&amp;gt;start_thread_common()&amp;lt;/code&amp;gt;; [https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/riscv/kernel/process.c?h=v6.12 arch/riscv/kernel/process.c], &amp;lt;code&amp;gt;start_thread()&amp;lt;/code&amp;gt;; [https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/riscv/include/asm/csr.h?h=v6.12 arch/riscv/include/asm/csr.h].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;regs-&amp;gt;epc&amp;lt;/code&amp;gt;는 메모리 속 필드이고 &amp;lt;code&amp;gt;sepc&amp;lt;/code&amp;gt;는 CPU의 제어 및 상태 레지스터(CSR)이다. 이 시점의 CPU는 여전히 커널 코드를 실행하며 커널 스택을 사용한다.&lt;br /&gt;
&lt;br /&gt;
=== 복귀 코드의 CPU 상태 복원 ===&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
                 ELF mappings + initial user stack&lt;br /&gt;
                                |&lt;br /&gt;
                       saved state: pt_regs&lt;br /&gt;
                                |&lt;br /&gt;
             +------------------+------------------+&lt;br /&gt;
             |                                     |&lt;br /&gt;
          x86-64                              RISC-V RV64&lt;br /&gt;
     ip, sp, cs, ss, flags                  epc, sp, status&lt;br /&gt;
             |                                     |&lt;br /&gt;
     user-return assembly                   ret_from_exception&lt;br /&gt;
             |                              epc    -&amp;gt; sepc&lt;br /&gt;
     IRETQ return frame                     status -&amp;gt; sstatus&lt;br /&gt;
             |                              sp     -&amp;gt; x2&lt;br /&gt;
           IRETQ                                   |&lt;br /&gt;
             |                                    SRET&lt;br /&gt;
             |                                     |&lt;br /&gt;
    RIP=e_entry, CPL=3                    PC=e_entry, U-mode&lt;br /&gt;
    RSP=new user stack                    sp=new user stack&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
RISC-V의 &amp;lt;code&amp;gt;ret_from_exception&amp;lt;/code&amp;gt;은 저장된 &amp;lt;code&amp;gt;status&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;epc&amp;lt;/code&amp;gt;를 각각 &amp;lt;code&amp;gt;sstatus&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;sepc&amp;lt;/code&amp;gt;에 쓰고 일반 레지스터와 사용자 &amp;lt;code&amp;gt;sp&amp;lt;/code&amp;gt;를 복원한 뒤 &amp;lt;code&amp;gt;sret&amp;lt;/code&amp;gt;를 실행한다. &amp;lt;code&amp;gt;sret&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;SPP=0&amp;lt;/code&amp;gt;에 따라 U-mode로 전환하고 &amp;lt;code&amp;gt;sepc&amp;lt;/code&amp;gt;의 주소에서 실행을 시작한다. 이때 SIE는 SPIE 값으로 갱신된다. 스택 포인터는 &amp;lt;code&amp;gt;sret&amp;lt;/code&amp;gt;에 앞선 어셈블리 명령에서 복원한다.&amp;lt;ref name=&amp;quot;rv-return&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/riscv/kernel/entry.S?h=v6.12 Linux v6.12, arch/riscv/kernel/entry.S], &amp;lt;code&amp;gt;ret_from_exception&amp;lt;/code&amp;gt;.&amp;lt;/ref&amp;gt;&amp;lt;ref&amp;gt;[https://docs.riscv.org/reference/isa/v20260120/priv/supervisor.html RISC-V Supervisor-Level ISA], &amp;lt;code&amp;gt;sstatus&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;sepc&amp;lt;/code&amp;gt;, SRET.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
x86-64에서는 복귀 어셈블리가 저장된 상태를 복원하고, RIP, CS, RFLAGS, RSP, SS로 이루어진 복귀 프레임을 &amp;lt;code&amp;gt;iretq&amp;lt;/code&amp;gt;가 적용하여 CPL 3의 사용자 코드로 나간다. 일반 시스템 콜에는 SYSRET 복귀도 있지만, 여기의 exec가 준비한 새 레지스터 상태는 그 경로의 조건을 만족하지 않아 IRET 경로로 간다.&amp;lt;ref&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/include/asm/elf.h?h=v6.12 Linux v6.12, arch/x86/include/asm/elf.h], &amp;lt;code&amp;gt;elf_common_init()&amp;lt;/code&amp;gt;; [https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/entry/common.c?h=v6.12 arch/x86/entry/common.c], &amp;lt;code&amp;gt;do_syscall_64()&amp;lt;/code&amp;gt;; [https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/entry/entry_64.S?h=v6.12 arch/x86/entry/entry_64.S], 사용자 복귀 경로와 &amp;lt;code&amp;gt;iretq&amp;lt;/code&amp;gt;.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
두 경우 모두 새로 준비한 복귀 상태가 이전 프로그램의 상태를 대체한다. 따라서 exec 성공 뒤에는 새 프로그램의 진입 주소에서 실행을 시작한다.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== 새 프로그램의 진입점 ==&lt;br /&gt;
일반적인 exec는 이전 사용자 프로그램이 시스템 콜(System Call)로 커널에 들어오면서 시작된다. 성공한 뒤 커널이 사용자 모드로 나갈 때는, 새로 설정한 진입 주소와 스택을 사용한다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
Old user program: execve(...)&lt;br /&gt;
                |&lt;br /&gt;
                v&lt;br /&gt;
Kernel: select ELF handler&lt;br /&gt;
        map code, data and BSS&lt;br /&gt;
        build initial user stack&lt;br /&gt;
        set entry = e_entry, stack = new stack&lt;br /&gt;
                |&lt;br /&gt;
                v&lt;br /&gt;
User-return path: restore prepared state&lt;br /&gt;
                |&lt;br /&gt;
                v&lt;br /&gt;
New user program: first instruction at e_entry&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
커널 내부의 exec 처리 함수가 성공을 반환한 뒤에는 현재 태스크가 새 실행 이미지를 실행한다. PID는 유지되며 이전 프로그램의 &amp;lt;code&amp;gt;execve()&amp;lt;/code&amp;gt; 호출 지점으로 돌아가지 않는다.&lt;br /&gt;
&lt;br /&gt;
첫 명령어를 가져올 때 해당 코드 페이지가 아직 연결되지 않았다면 페이지 폴트가 발생할 수 있다. 커널이 페이지를 준비한 뒤 같은 명령어 접근을 재개하므로, 이것도 정상적인 시작 과정의 일부이다. 자세한 내용은 [[운영체제 기본/Linux/메모리 매핑/페이지 폴트 처리|페이지 폴트 처리]]로 이어진다.&lt;br /&gt;
&lt;br /&gt;
일반적인 C 프로그램의 &amp;lt;code&amp;gt;e_entry&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;_start&amp;lt;/code&amp;gt; 같은 런타임 시작 코드를 가리킨다. 이 코드는 스택의 인자 정보를 읽고 실행 환경을 준비한 뒤 &amp;lt;code&amp;gt;main()&amp;lt;/code&amp;gt;을 호출한다. ELF는 시작 함수의 이름을 규정하지 않으며, 커널은 기록된 진입 주소를 사용한다.&lt;br /&gt;
&lt;br /&gt;
== 동적 링킹과 인터프리터 진입 ==&lt;br /&gt;
이제 기본 흐름에 동적 링커를 추가할 수 있다. ELF에 &amp;lt;code&amp;gt;PT_INTERP&amp;lt;/code&amp;gt;가 있으면 이 항목은 사용자 공간 동적 링커의 경로를 지정한다. 커널은 주 실행 파일에 더해 동적 링커도 매핑하고, 첫 실행 주소를 동적 링커의 진입 주소로 준비한다.&amp;lt;ref name=&amp;quot;elf&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
동적 링커는 사용자 모드에서 필요한 공유 라이브러리를 준비하고 주소 연결 작업을 수행한 뒤 주 프로그램의 시작 코드로 제어를 넘긴다.&amp;lt;ref&amp;gt;[https://man7.org/linux/man-pages/man8/ld.so.8.html Linux man-pages, ld.so(8)].&amp;lt;/ref&amp;gt; 주 프로그램의 진입 주소는 초기 스택의 보조 벡터 &amp;lt;code&amp;gt;AT_ENTRY&amp;lt;/code&amp;gt;로 전달되므로, 동적 링커의 첫 실행 주소와 구별할 수 있다.&lt;br /&gt;
&lt;br /&gt;
인터프리터 없는 정적 실행은 커널에서 주 프로그램 시작 코드로 이어진다. 일반적인 동적 실행은 그 사이에 동적 링커를 거친다. 어느 쪽이든 커널이 매핑과 스택을 준비하고 사용자 레지스터를 설정한다는 골격은 같다.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/ELF 로딩/ELF 세그먼트와 주소 공간|ELF 세그먼트와 주소 공간]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/ELF 로딩|ELF 로딩 목차]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/%ED%8C%8C%EC%9D%BC%EA%B3%BC_%EC%9E%85%EC%B6%9C%EB%A0%A5&amp;diff=711</id>
		<title>운영체제 기본/파일과 입출력</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/%ED%8C%8C%EC%9D%BC%EA%B3%BC_%EC%9E%85%EC%B6%9C%EB%A0%A5&amp;diff=711"/>
		<updated>2026-11-15T06:09:52Z</updated>

		<summary type="html">&lt;p&gt;관리자: 불필요한 강조와 반복 부정 대조를 정리하고 파일 객체 설명을 직접적으로 수정&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/가상 메모리|가상 메모리]]&lt;br /&gt;
|목차=[[운영체제 기본#총론|총론 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/프로세스 간 통신|프로세스 간 통신]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
메모리의 데이터는 프로세스가 종료되거나 전원이 꺼진 뒤에도 필요한 경우가 많다. 파일 시스템은 데이터를 지속적으로 보관하고 다시 찾을 수 있게 하며, 입출력 계층은 속도와 동작 방식이 다른 장치 사이에서 데이터를 전달한다. 이때 프로그램이 사용하는 이름, 현재 접근 중인 대상, 실제 저장장치의 상태를 하나로 취급하면 동시 접근과 장애를 다루기 어렵다.&lt;br /&gt;
&lt;br /&gt;
== 파일 데이터와 메타데이터 ==&lt;br /&gt;
프로그램이 저장장치의 어느 구역에 데이터가 있는지 직접 관리한다면, 파일이 커지거나 다른 프로그램이 공간을 사용했을 때 배치를 함께 조정해야 한다. 파일 시스템은 저장 공간의 할당과 회수를 맡고, 프로그램에는 이름으로 찾을 수 있는 파일을 제공한다. 일반 파일의 데이터는 본문의 바이트이고, 메타데이터는 크기, 종류, 소유자와 접근 권한, 접근, 수정 시각처럼 파일을 관리하는 정보다. 내용을 저장장치의 어디에서 찾을지 나타내는 블록 매핑도 메타데이터에 속한다. Unix 계열에서는 inode가 이러한 파일별 정보를 담거나 관련 구조를 가리킨다. 이름과 달리 inode 번호는 해당 파일시스템 안에서 파일을 식별한다.&amp;lt;ref name=&amp;quot;fs-inode&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man7/inode.7.html Linux man-pages: inode(7)].&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;fs-block-map&amp;quot;&amp;gt;[https://docs.kernel.org/filesystems/ext4/ifork.html Linux kernel documentation: The Contents of inode.i_block], Extent Tree.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
파일의 소유자와 접근 권한은 운영체제가 파일 접근 요청을 판단하기 위해 관리하는 정보다. 파일을 열거나 경로를 탐색할 때 커널의 파일시스템 코드가 요청한 연산과 이 정보를 확인한다. CPU의 메모리 보호는 이 판단을 수행하는 커널 코드와 관리 정보를 사용자 프로그램이 직접 훼손하지 못하도록 뒷받침한다.&amp;lt;ref name=&amp;quot;fs-inode&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
일반 파일을 바이트의 나열로 제공하면 프로그램은 저장장치의 세부 구조에 맞춰 매번 코드를 바꾸지 않아도 된다. Unix는 파일뿐 아니라 파이프와 터미널에도 읽기와 쓰기라는 공통 인터페이스를 제공한다. 덕분에 출력 대상을 바꾸어 프로그램을 조합하기 쉽다. 일반 파일은 위치를 바꾸어 읽을 수 있지만 파이프는 그렇게 할 수 없으며, 바이트 스트림의 데이터에 붙일 레코드 구조는 프로그램이 정해야 한다. &amp;lt;ref name=&amp;quot;source-1&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man2/read.2.html Linux man-pages: read(2)].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 디렉터리와 경로 탐색 ==&lt;br /&gt;
디렉터리는 이름을 파일 식별자에 연결하는 항목들의 모음이다. Unix 계열의 ext4에서는 각 항목이 이름과 inode 번호를 연결한다. 디렉터리 자체도 inode를 가지며, 본문에는 이 연결 정보를 저장한다.&amp;lt;ref name=&amp;quot;fs-directory&amp;quot;&amp;gt;[https://docs.kernel.org/filesystems/ext4/directory.html Linux kernel documentation: Directory Entries].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
경로 &amp;lt;code&amp;gt;/home/ldmsys/a.txt&amp;lt;/code&amp;gt;는 탐색할 이름의 순서를 나타낸다. 프로세스의 루트 디렉터리에서 &amp;lt;code&amp;gt;home&amp;lt;/code&amp;gt;을 찾고, 그 안에서 &amp;lt;code&amp;gt;ldmsys&amp;lt;/code&amp;gt;, 다시 그 안에서 &amp;lt;code&amp;gt;a.txt&amp;lt;/code&amp;gt;를 찾아 대상 inode에 도달한다. 중간 디렉터리에 탐색 권한이 없으면 마지막 파일의 읽기 권한만으로 접근할 수 없다.&amp;lt;ref name=&amp;quot;fs-path&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man7/path_resolution.7.html Linux man-pages: path_resolution(7)].&amp;lt;/ref&amp;gt; 같은 파일시스템에서 여러 디렉터리 항목이 같은 inode를 가리키는 관계가 하드 링크다. 여러 이름으로 같은 본문에 접근한다.&amp;lt;ref name=&amp;quot;fs-inode&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;span id=&amp;quot;파일_이름·객체·열린_상태의_수명&amp;quot;&amp;gt;&amp;lt;/span&amp;gt;&lt;br /&gt;
== 파일 이름, 객체, 열린 상태의 수명 ==&lt;br /&gt;
파일을 열 때 운영체제는 경로로 찾은 객체를 계속 참조할 수 있는 핸들을 돌려준다. 이후 입출력마다 처음 경로를 다시 검색할 필요는 없다. Unix의 파일 디스크립터가 그 예다. 핸들이 가리키는 열린 상태에는 읽고 쓰는 현재 위치 등이 들어 있다. 같은 파일을 따로 열면 위치를 독립적으로 유지할 수 있고, 열린 상태를 공유하는 핸들은 위치도 함께 사용한다. 파일 내용의 공유와 읽기 위치의 공유는 다른 선택이다. &amp;lt;ref name=&amp;quot;source-2&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man2/open.2.html Linux man-pages: open(2)].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이 분리는 이름이 바뀌어도 진행 중인 작업을 유지하게 한다. 이름 하나를 삭제하는 것은 해당 디렉터리 항목을 제거하는 일이며, 다른 하드 링크가 남아 있으면 그 이름으로 파일에 접근할 수 있다. Unix에서 로그 파일의 마지막 이름을 삭제해도 프로세스가 파일을 열어 두었다면 계속 쓸 수 있다. 같은 이름으로 새 파일을 만들어도 기존 핸들이 새 파일로 옮겨 가지는 않는다. 이름이 사라진 시점과 저장 공간을 회수할 수 있는 시점이 달라지는 대신, 경로의 변경 때문에 이미 연 대상이 갑자기 바뀌지 않는다. &amp;lt;ref name=&amp;quot;source-3&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man2/unlink.2.html Linux man-pages: unlink(2)].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 파일 오프셋과 블록 매핑 ==&lt;br /&gt;
바이트 오프셋은 파일 시작에서 몇 바이트 떨어졌는지를 나타낸다. 블록 기반 파일시스템은 이를 파일 내부의 논리 블록 번호와 블록 안의 위치로 나누고, 블록 매핑으로 장치상의 물리 블록을 찾는다. 예를 들어 블록이 4 KiB라면 오프셋 5000은 논리 블록 1의 블록 내 오프셋 904다. 예를 들어 논리 블록 1이 물리 블록 900에 대응할 수 있다. 여기서 물리 블록은 장치에 요청하는 주소이며, SSD 내부의 셀 배치는 장치가 별도로 관리한다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
/home/ldmsys/a.txt&lt;br /&gt;
  -&amp;gt; / 의 home 항목 -&amp;gt; home의 ldmsys 항목&lt;br /&gt;
  -&amp;gt; ldmsys의 a.txt 항목&lt;br /&gt;
  -&amp;gt; 파일 inode: 크기, 권한, 블록 매핑 등&lt;br /&gt;
  -&amp;gt; 읽을 오프셋 5000 -&amp;gt; 논리 블록 1 + 블록 내 위치 904&lt;br /&gt;
  -&amp;gt; 블록 매핑 -&amp;gt; 물리 블록 900의 해당 데이터&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
extent는 연속된 논리 블록 구간을 연속된 물리 블록 구간에 대응시키는 표현이다. 시작 위치와 길이로 여러 블록을 묶어 기록한다. 연속 구간이 길면 블록별 주소를 나열하는 것보다 매핑 정보를 줄일 수 있지만, 파일이 흩어질수록 필요한 구간 수가 늘어난다.&amp;lt;ref name=&amp;quot;fs-block-map&amp;quot;/&amp;gt; 반대로 희소 파일의 hole은 파일 크기 안에 있지만 데이터 블록을 할당하지 않은 구간이며, 읽으면 값이 0인 바이트들로 채워진다. 따라서 파일의 크기와 실제 할당된 저장 공간은 다를 수 있다.&amp;lt;ref name=&amp;quot;fs-hole&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man2/lseek.2.html Linux man-pages: lseek(2)], DESCRIPTION.&amp;lt;/ref&amp;gt; 위 흐름은 이름에서 데이터 위치로 이어지는 관계다. 필요한 내용이 캐시에 있다면 실제 장치 읽기는 생략할 수 있다.&lt;br /&gt;
&lt;br /&gt;
== 버퍼링과 비동기 입출력 ==&lt;br /&gt;
프로그램이 작은 입출력 요청을 하나씩 보내고 완료를 기다리면 그 스레드의 다음 작업이 지연된다. 기다리는 동안 다른 스레드는 CPU를 사용할 수 있다. 버퍼는 속도가 다른 두 쪽 사이에서 데이터를 잠시 보관한다. 작은 쓰기를 모아 보내면 요청 횟수를 줄이고, 읽은 내용을 캐시에 남기면 같은 데이터를 다시 가져오는 비용을 줄인다. 대신 버퍼가 RAM을 차지하며, 모아서 보내기를 기다리는 동안 개별 데이터의 전달은 늦어질 수 있다.&lt;br /&gt;
&lt;br /&gt;
비동기 입출력은 요청과 완료 확인을 분리해, 장치가 일하는 동안 프로그램이 다른 일을 하게 한다. 버퍼링과 함께 사용할 수도 있다. 비동기로 실행한 작업도 완료 결과를 확인해야 하며, 완료 전까지 사용 중인 버퍼의 수명을 보장해야 한다. 동시에 너무 많은 요청을 쌓으면 대기열과 메모리 사용량이 늘어난다. 읽기 캐시 역시 원본이 다른 경로로 바뀔 수 있다면 갱신을 어떻게 알아낼지 정해야 한다. &amp;lt;ref name=&amp;quot;source-4&amp;quot;&amp;gt;[https://docs.kernel.org/admin-guide/mm/concepts.html 커널 문서: 페이지 캐시].&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;source-5&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man7/aio.7.html Linux man-pages: 비동기 입출력].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 부분 입출력과 오류 처리 ==&lt;br /&gt;
읽기는 파일 끝에 도달하거나 현재 도착한 데이터가 적으면 요청보다 적은 바이트를 돌려줄 수 있다. 쓰기도 공간 부족이나 실행 중단 등의 이유로 일부만 끝날 수 있다. 따라서 반환된 양은 실제로 어디까지 진행했는지를 나타내는 정보다. 남은 부분을 재시도하려면 이미 처리한 위치를 보존해야 한다. 처음부터 다시 보내면 중복된 데이터가 생길 수 있다.&lt;br /&gt;
&lt;br /&gt;
양수를 반환한 부분 완료, 입력의 끝, 오류는 각각 다르게 처리해야 한다. 특히 바이트 스트림에서는 송신 측이 한 번에 쓴 범위와 수신 측이 한 번에 읽는 범위가 일치하지 않는다. 메시지의 길이나 구분자는 상위 프로토콜이 정해야 한다. 또한 버퍼에 쓰기를 받아들인 뒤 실제 저장 과정에서 오류가 드러날 수 있다. &amp;lt;ref name=&amp;quot;source-6&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man2/write.2.html Linux man-pages: write(2)].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 변경의 가시성과 내구성 ==&lt;br /&gt;
버퍼드 쓰기의 성공은 데이터가 운영체제의 캐시에 전달되었다는 뜻일 수 있다. 다른 읽기에서 변경을 관찰하는 것과 전원 장애 후에도 변경이 남는 것은 별개다. 내구성이 필요하면 데이터를 저장장치까지 반영하는 동기화 절차와 그 실패를 처리해야 한다. 매번 동기화하면 대기 비용이 커지고, 여러 변경을 묶으면 비용을 나누는 대신 마지막 묶음이 보장되기까지의 시간이 길어진다.&lt;br /&gt;
&lt;br /&gt;
이름 변경의 원자성도 내구성과 구별한다. 같은 파일 시스템에서 완성한 새 파일로 기존 이름을 원자적으로 교체하면, 새로 여는 쪽이 교체 도중의 빈 이름을 보는 문제를 피할 수 있다. 이미 열린 참조는 이전 객체를 유지한다. 장애 후에도 변경을 유지하려면 파일 내용과 그 이름을 담은 디렉터리를 각각 영속화해야 한다. Linux에서는 파일과 디렉터리에 각각 동기화 작업을 요청한다. 여러 파일의 변경을 하나로 묶으려면 별도의 트랜잭션 처리가 필요하다. &amp;lt;ref name=&amp;quot;source-7&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man2/rename.2.html Linux man-pages: rename(2)].&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;source-8&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man2/fsync.2.html fsync(2)].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 관련 각론 ==&lt;br /&gt;
* [[운영체제 기본/Linux/파일시스템|Linux의 파일시스템]]: 파일시스템 구현 문서의 목차.&lt;br /&gt;
* [[운영체제 기본/Linux/파일시스템/VFS와 파일 객체|VFS와 파일 객체]]: 디렉터리 탐색, inode, 열린 파일 상태를 Linux 객체와 연산으로 연결.&lt;br /&gt;
* [[운영체제 기본/Linux/파일시스템/ext4의 파일 읽기|ext4의 파일 읽기]]: extent 매핑과 장치 읽기로 파일의 데이터를 공급하는 과정.&lt;br /&gt;
* [[운영체제 기본/Linux/파일시스템/페이지 캐시|페이지 캐시]]: 파일 내용의 재사용과 데이터 준비 상태 관리.&lt;br /&gt;
* [[운영체제 기본/Linux/메모리 매핑/파일 매핑과 COW|mmap을 통한 파일 읽기]]: 주소 영역 등록, 첫 메모리 접근, 파일 폴트와 PTE 설치.&lt;br /&gt;
* [[운영체제 기본/Linux/파일 시스템 콜|Linux의 파일 시스템 콜]]: 파일 열기, 읽기, 쓰기와 파일 위치, 수명 관리가 Linux 내부 구현으로 이어지는 과정.&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/가상 메모리|가상 메모리]]&lt;br /&gt;
|목차=[[운영체제 기본#총론|총론 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/프로세스 간 통신|프로세스 간 통신]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/RCU/Tree_RCU%EC%99%80_%EC%9C%A0%EC%98%88_%EA%B8%B0%EA%B0%84&amp;diff=710</id>
		<title>운영체제 기본/Linux/RCU/Tree RCU와 유예 기간</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/RCU/Tree_RCU%EC%99%80_%EC%9C%A0%EC%98%88_%EA%B8%B0%EA%B0%84&amp;diff=710"/>
		<updated>2026-11-15T06:09:47Z</updated>

		<summary type="html">&lt;p&gt;관리자: 반복 대조 및 강조 표현 정리, ASCII 도표 통일&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=&amp;lt;- 이전 문서&amp;lt;br&amp;gt;[[운영체제 기본/Linux/RCU/갱신과 메모리 회수|갱신과 메모리 회수]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/RCU|RCU 목차]]&lt;br /&gt;
|다음=마지막 문서&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
Tree RCU는 태스크와 CPU별로 상태를 기록하고 트리에서 유예 기간의 완료를 모은다. 독자에게 가벼운 경로를 제공하는 대가로 갱신, 회수 측의 상태 추적이 복잡해진다. Linux v6.12의 &amp;lt;code&amp;gt;CONFIG_PREEMPT_RCU=y&amp;lt;/code&amp;gt;, 다중 CPU, 일반 유예 기간을 기준으로 내부 연결을 살펴본다.&lt;br /&gt;
&lt;br /&gt;
== 읽기 구간의 태스크별 기록 ==&lt;br /&gt;
&amp;lt;code&amp;gt;rcu_read_lock()&amp;lt;/code&amp;gt; 아래의 &amp;lt;code&amp;gt;__rcu_read_lock()&amp;lt;/code&amp;gt;은 현재 태스크의 &amp;lt;code&amp;gt;rcu_read_lock_nesting&amp;lt;/code&amp;gt;을 증가시킨다. 대응하는 unlock은 감소시키고, 가장 바깥 읽기 구간이 끝났을 때 미뤄둔 특별 처리가 있으면 &amp;lt;code&amp;gt;rcu_read_unlock_special()&amp;lt;/code&amp;gt;을 실행한다. 태스크별 기록을 사용하여 읽기 측의 전역 원자 연산 비용을 줄인다.&amp;lt;ref name=&amp;quot;plugin&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/kernel/rcu/tree_plugin.h?h=v6.12 Linux v6.12, kernel/rcu/tree_plugin.h], __rcu_read_lock, __rcu_read_unlock, rcu_note_context_switch와 rcu_read_unlock_special.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
태스크의 읽기 구간&lt;br /&gt;
  read_lock       nesting 0 -&amp;gt; 1&lt;br /&gt;
    read_lock     nesting 1 -&amp;gt; 2&lt;br /&gt;
    read_unlock   nesting 2 -&amp;gt; 1&lt;br /&gt;
  read_unlock     nesting 1 -&amp;gt; 0 : 바깥 구간 종료&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
읽기 도중 태스크가 선점되면 CPU는 다른 일을 시작해도 그 태스크는 이전 객체의 포인터를 가지고 있다. &amp;lt;code&amp;gt;rcu_note_context_switch()&amp;lt;/code&amp;gt;는 선점된 독자를 해당 &amp;lt;code&amp;gt;rcu_node&amp;lt;/code&amp;gt;의 &amp;lt;code&amp;gt;blkd_tasks&amp;lt;/code&amp;gt; 목록으로 연결한다. 현재 유예 기간을 막는 독자는 &amp;lt;code&amp;gt;gp_tasks&amp;lt;/code&amp;gt; 등으로 추적하며, 태스크가 다시 실행되어 바깥 읽기 구간을 끝내야 이 조건을 해소할 수 있다.&amp;lt;ref name=&amp;quot;plugin&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이 기록 덕분에 읽기 구간 전체에서 선점을 금지하지 않아도 수명을 지킬 수 있다. &amp;lt;code&amp;gt;CONFIG_PREEMPT_RCU=n&amp;lt;/code&amp;gt;에서는 읽기 구간과 선점 제어의 관계가 다르므로 위 태스크 목록 경로를 그대로 적용하지 않는다.&lt;br /&gt;
&lt;br /&gt;
== CPU별 상태와 집계 트리 ==&lt;br /&gt;
&amp;lt;code&amp;gt;struct rcu_data&amp;lt;/code&amp;gt;는 CPU별 상태와 콜백 목록을 보관한다. &amp;lt;code&amp;gt;struct rcu_node&amp;lt;/code&amp;gt;는 여러 CPU 또는 하위 노드의 진행 상태를 묶고, &amp;lt;code&amp;gt;rcu_state&amp;lt;/code&amp;gt;는 유예 기간의 순서와 전체 트리를 관리한다.&amp;lt;ref name=&amp;quot;data&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/kernel/rcu/tree.h?h=v6.12 Linux v6.12, kernel/rcu/tree.h], rcu_data, rcu_node, rcu_state.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
                      rcu_state&lt;br /&gt;
                   유예 기간 순서&lt;br /&gt;
                          |&lt;br /&gt;
                  루트 rcu_node&lt;br /&gt;
                  /            \&lt;br /&gt;
             rcu_node          rcu_node&lt;br /&gt;
             /     \          /     \&lt;br /&gt;
           CPU 0  CPU 1      CPU 2  CPU 3&lt;br /&gt;
           rcu_data 각각: CPU 진행 상태 + 콜백 목록&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
정지 상태(Quiescent State)는 여기서 추적하는 이전 RCU 읽기를 CPU가 계속 수행하고 있지 않음을 보고할 수 있는 상태다. 문맥에 맞는 컨텍스트 스위치나 idle, 사용자 모드 상태의 관찰 등이 이 판단에 쓰인다. 선점된 독자가 다른 곳에 남아 있을 수 있으므로 CPU의 보고와 앞 절의 태스크 목록을 함께 확인한다.&lt;br /&gt;
&lt;br /&gt;
각 노드의 &amp;lt;code&amp;gt;qsmask&amp;lt;/code&amp;gt;는 이번 유예 기간에 아직 보고를 기다리는 CPU 또는 하위 노드를 비트로 나타낸다. &amp;lt;code&amp;gt;rcu_report_qs_rnp()&amp;lt;/code&amp;gt;는 보고된 비트를 지우고, 그 노드의 비트가 모두 지워졌으며 해당 유예 기간을 막는 선점 독자도 없을 때 상위 노드로 완료를 전달한다. 마지막 보고만 위로 올라가므로 모든 CPU가 매번 루트의 락에 몰리지 않는다.&amp;lt;ref name=&amp;quot;tree&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/kernel/rcu/tree.c?h=v6.12 Linux v6.12, kernel/rcu/tree.c], rcu_gp_init, rcu_gp_kthread, rcu_report_qs_rnp, rcu_gp_cleanup, rcu_do_batch.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 유예 기간의 시작과 완료 ==&lt;br /&gt;
&amp;lt;code&amp;gt;rcu_gp_kthread()&amp;lt;/code&amp;gt;는 유예 기간을 관리하는 커널 스레드다. 회수 요청이 들어오면 필요한 유예 기간을 시작하고, &amp;lt;code&amp;gt;rcu_gp_init()&amp;lt;/code&amp;gt;에서 순서와 노드별 대기 상태를 준비한다. 이후 CPU 보고와 선점 독자의 종료가 모여 완료 조건을 만족하면 &amp;lt;code&amp;gt;rcu_gp_cleanup()&amp;lt;/code&amp;gt;이 완료 상태를 각 노드에 전파한다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
회수 요청&lt;br /&gt;
   v&lt;br /&gt;
필요한 유예 기간 순서 결정&lt;br /&gt;
   v&lt;br /&gt;
CPU별 정지 상태 보고 --- 선점된 기존 독자의 읽기 종료&lt;br /&gt;
   +------------+-----------------+&lt;br /&gt;
                v&lt;br /&gt;
       rcu_node 트리에서 완료 집계&lt;br /&gt;
                v&lt;br /&gt;
          유예 기간 완료 기록&lt;br /&gt;
                v&lt;br /&gt;
     해당 기간을 기다린 콜백 실행 가능&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;gp_seq&amp;lt;/code&amp;gt;는 단순한 시각 대신 유예 기간의 진행 순서를 표시한다. 회수 요청이 어느 완료 시점 이후 안전한지를 구분해야, 요청보다 앞서 시작되어 충분한 보장을 주지 못하는 기간을 잘못 사용하지 않는다. 여러 요청은 같은 유예 기간을 함께 기다릴 수 있다. 각 객체의 참조를 세는 대신 기존 읽기 구간들이 지나갔음을 묶어서 확인하는 방식이다.&lt;br /&gt;
&lt;br /&gt;
CPU가 오래 보고하지 않으면 RCU는 상태를 다시 관찰하거나 스케줄링을 촉진하는 등 진행을 요구한다. 종료하지 않는 독자가 있으면 유예 기간이 지연되고, 콜백과 메모리 회수도 밀린다.&amp;lt;ref name=&amp;quot;tree&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 콜백 대기열과 실행 ==&lt;br /&gt;
&amp;lt;code&amp;gt;call_rcu()&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;__call_rcu_common()&amp;lt;/code&amp;gt;으로 이어져 &amp;lt;code&amp;gt;rcu_head&amp;lt;/code&amp;gt;에 콜백을 기록하고 CPU별 콜백 경로에 넣는다. 기본 비오프로딩 경로에서 콜백은 &amp;lt;code&amp;gt;rcu_data&amp;lt;/code&amp;gt;의 &amp;lt;code&amp;gt;rcu_segcblist&amp;lt;/code&amp;gt;에 연결된다. 이 목록은 실행 가능한 콜백과 유예 기간을 기다리는 콜백을 구분한다. &amp;lt;code&amp;gt;rcu_accelerate_cbs()&amp;lt;/code&amp;gt;는 필요한 기간과 연결하고, 완료가 관찰되면 &amp;lt;code&amp;gt;rcu_advance_cbs()&amp;lt;/code&amp;gt;가 실행 가능한 부분을 앞으로 진행시킨다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;rcu_core()&amp;lt;/code&amp;gt; 경로의 &amp;lt;code&amp;gt;rcu_do_batch()&amp;lt;/code&amp;gt;가 준비된 콜백들을 꺼내 실행한다. 유예 기간이 완료되면 콜백을 안전하게 실행할 수 있고, 실제 실행은 콜백 처리 경로가 담당한다. 콜백 오프로딩이나 지연 회수 설정은 실행 주체와 시점을 바꿀 수 있지만, 안전한 유예 기간 이후라는 조건은 유지한다.&amp;lt;ref name=&amp;quot;tree&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;synchronize_rcu()&amp;lt;/code&amp;gt;는 같은 완료 보장을 동기적으로 기다리는 인터페이스다. v6.12의 일반 경로 &amp;lt;code&amp;gt;synchronize_rcu_normal()&amp;lt;/code&amp;gt;에는 유예 기간 완료 요청을 등록하고 completion을 기다리는 경로와 &amp;lt;code&amp;gt;wait_rcu_gp(call_rcu_hurry)&amp;lt;/code&amp;gt; 경로가 있다. 두 경로 모두 호출자가 돌아왔을 때 기존 읽기 구간이 끝났음을 보장한다.&amp;lt;ref name=&amp;quot;tree&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 비용과 적용 범위 ==&lt;br /&gt;
Tree RCU가 줄이는 것은 읽는 쪽의 공유 락 경쟁이다. 쓰기 측의 직렬화, 새 객체 복사, 유예 기간 추적, 이전 객체를 보관하는 메모리 비용은 남는다. 읽기가 많고 일정 시간 이전 버전을 관찰해도 되는 구조에 특히 잘 맞는다. 쓰기가 잦거나 읽기 구간이 길면 회수 지연이 커지므로 뮤텍스 방식과 비용을 비교해야 한다.&lt;br /&gt;
&lt;br /&gt;
x86-64와 RISC-V RV64에서 이 트리와 태스크 추적의 의미는 같다. 아키텍처별 원자 연산, 장벽이 그 아래의 순서를 구현한다. 사용자 공간 RCU는 별도의 라이브러리와 실행 환경을 사용한다.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=&amp;lt;- 이전 문서&amp;lt;br&amp;gt;[[운영체제 기본/Linux/RCU/갱신과 메모리 회수|갱신과 메모리 회수]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/RCU|RCU 목차]]&lt;br /&gt;
|다음=마지막 문서&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/ELF_%EB%A1%9C%EB%94%A9/ELF_%EC%84%B8%EA%B7%B8%EB%A8%BC%ED%8A%B8%EC%99%80_%EC%A3%BC%EC%86%8C_%EA%B3%B5%EA%B0%84&amp;diff=709</id>
		<title>운영체제 기본/Linux/ELF 로딩/ELF 세그먼트와 주소 공간</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/ELF_%EB%A1%9C%EB%94%A9/ELF_%EC%84%B8%EA%B7%B8%EB%A8%BC%ED%8A%B8%EC%99%80_%EC%A3%BC%EC%86%8C_%EA%B3%B5%EA%B0%84&amp;diff=709"/>
		<updated>2026-11-15T06:09:33Z</updated>

		<summary type="html">&lt;p&gt;관리자: 문체 정리: 강조와 반복 대조, 특수문자 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/ELF 로딩/execve와 실행 이미지 교체|execve와 실행 이미지 교체]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/ELF 로딩|ELF 로딩 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/ELF 로딩/초기 스택과 사용자 모드 진입|초기 스택과 사용자 모드 진입]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
실행 파일은 디스크에 저장된 바이트이고, CPU는 메모리 주소를 통해 명령어를 읽는다. ELF 로더의 역할은 실행 파일의 내용을 프로세스의 가상 주소 공간에 연결하여 실행할 준비를 만드는 것이다. 이를 위해 파일의 각 구간을 사용할 가상 주소를 정한다.&lt;br /&gt;
&lt;br /&gt;
여기서는 먼저 정적 링크된 &amp;lt;code&amp;gt;ET_EXEC&amp;lt;/code&amp;gt; 실행 파일을 기준으로 설명한다. &amp;lt;code&amp;gt;ET_EXEC&amp;lt;/code&amp;gt;는 ELF 파일의 종류이고, 아래에서 다루는 &amp;lt;code&amp;gt;PT_LOAD&amp;lt;/code&amp;gt;는 그 파일 안의 프로그램 헤더 종류이다. 기준 구현은 Linux v6.12 x86-64이다.&lt;br /&gt;
&lt;br /&gt;
== ELF 헤더와 배치 정보 ==&lt;br /&gt;
ELF 파일의 맨 앞에는 ELF 헤더가 있다. 커널의 &amp;lt;code&amp;gt;load_elf_binary()&amp;lt;/code&amp;gt;는 이 파일이 지원하는 ELF 형식과 아키텍처인지 확인하고, 헤더가 가리키는 프로그램 헤더 테이블을 읽는다. ELF 헤더의 &amp;lt;code&amp;gt;e_entry&amp;lt;/code&amp;gt;는 실행을 시작할 주소이며, &amp;lt;code&amp;gt;e_phoff&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;e_phnum&amp;lt;/code&amp;gt;은 프로그램 헤더 테이블의 파일 위치와 항목 수를 알려 준다.&amp;lt;ref name=&amp;quot;elf&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/binfmt_elf.c?h=v6.12 Linux v6.12, fs/binfmt_elf.c], &amp;lt;code&amp;gt;load_elf_binary()&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;load_elf_phdrs()&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;elf_map()&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;elf_load()&amp;lt;/code&amp;gt;.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
프로그램 헤더 중 &amp;lt;code&amp;gt;PT_LOAD&amp;lt;/code&amp;gt;는 메모리에 배치할 구간을 나타낸다. 실행 파일은 보통 코드, 읽기 전용 데이터, 쓰기 가능한 데이터처럼 성질이 다른 구간을 여러 &amp;lt;code&amp;gt;PT_LOAD&amp;lt;/code&amp;gt;로 나눈다. 커널은 각 항목을 읽어 해당 구간을 가상 주소 공간에 배치한다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
ELF file (static ET_EXEC)&lt;br /&gt;
+----------------------------------------+&lt;br /&gt;
| ELF header                             |&lt;br /&gt;
|   e_entry = 0x401000                   |&lt;br /&gt;
|   e_phoff: offset of program headers   |&lt;br /&gt;
+----------------------------------------+&lt;br /&gt;
| Program headers                        |&lt;br /&gt;
|   PT_LOAD R-X                          |&lt;br /&gt;
|     offset=0x1000, vaddr=0x401000      |&lt;br /&gt;
|     filesz=0x1000, memsz=0x1000        |&lt;br /&gt;
|   PT_LOAD RW-                          |&lt;br /&gt;
|     offset=0x2000, vaddr=0x402000      |&lt;br /&gt;
|     filesz=0x0800, memsz=0x2000        |&lt;br /&gt;
+----------------------------------------+&lt;br /&gt;
| ...                                    |&lt;br /&gt;
| 0x1000: code bytes                     |&lt;br /&gt;
| ...                                    |&lt;br /&gt;
| 0x2000: initialized data bytes         |&lt;br /&gt;
| 0x2800: end of initialized data        |&lt;br /&gt;
+----------------------------------------+&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이때 섹션과 세그먼트를 구분해야 한다. &amp;lt;code&amp;gt;.text&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;.data&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;.bss&amp;lt;/code&amp;gt; 같은 섹션은 컴파일과 링크 과정에서 사용하는 구분이다. 실행 시 커널이 배치의 기준으로 사용하는 것은 프로그램 헤더의 세그먼트이다. 하나의 세그먼트에 여러 섹션이 포함될 수도 있다.&lt;br /&gt;
&lt;br /&gt;
== PT_LOAD와 세그먼트 매핑 ==&lt;br /&gt;
&amp;lt;code&amp;gt;PT_LOAD&amp;lt;/code&amp;gt;의 핵심 필드는 다음과 같다.&lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
! 필드 !! 의미&lt;br /&gt;
|-&lt;br /&gt;
| &amp;lt;code&amp;gt;p_offset&amp;lt;/code&amp;gt; || 데이터가 시작하는 파일 오프셋&lt;br /&gt;
|-&lt;br /&gt;
| &amp;lt;code&amp;gt;p_vaddr&amp;lt;/code&amp;gt; || 데이터를 배치할 가상 주소&lt;br /&gt;
|-&lt;br /&gt;
| &amp;lt;code&amp;gt;p_filesz&amp;lt;/code&amp;gt; || 파일에 저장된 데이터의 크기&lt;br /&gt;
|-&lt;br /&gt;
| &amp;lt;code&amp;gt;p_memsz&amp;lt;/code&amp;gt; || 메모리에서 필요한 전체 크기&lt;br /&gt;
|-&lt;br /&gt;
| &amp;lt;code&amp;gt;p_flags&amp;lt;/code&amp;gt; || 읽기, 쓰기, 실행 권한&lt;br /&gt;
|-&lt;br /&gt;
| &amp;lt;code&amp;gt;p_align&amp;lt;/code&amp;gt; || 파일 위치와 가상 주소의 정렬 조건&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
지금의 &amp;lt;code&amp;gt;ET_EXEC&amp;lt;/code&amp;gt; 예에서는 파일의 &amp;lt;code&amp;gt;p_offset&amp;lt;/code&amp;gt;부터 &amp;lt;code&amp;gt;p_filesz&amp;lt;/code&amp;gt;바이트가 가상 주소 &amp;lt;code&amp;gt;p_vaddr&amp;lt;/code&amp;gt;부터 보이도록 배치한다. &amp;lt;code&amp;gt;p_memsz&amp;lt;/code&amp;gt;가 더 크면 그 차이만큼은 0으로 시작하는 메모리가 필요하다.&lt;br /&gt;
&lt;br /&gt;
위 그림의 실행 파일을 페이지 크기 &amp;lt;code&amp;gt;0x1000&amp;lt;/code&amp;gt;인 주소 공간에 배치하면 다음과 같다. 코드 세그먼트는 파일과 메모리의 크기가 같고, 데이터 세그먼트는 메모리에서 더 큰 공간을 요구한다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
File offset                     Virtual address&lt;br /&gt;
0x1000 +------------------+     0x401000 +------------------+&lt;br /&gt;
       | Code, 0x1000     | ----------&amp;gt; | Code, R-X        |&lt;br /&gt;
0x2000 +------------------+     0x402000 +------------------+&lt;br /&gt;
       | Data, 0x0800     | ----------&amp;gt; | Data, RW-        |&lt;br /&gt;
0x2800 +------------------+     0x402800 +------------------+&lt;br /&gt;
                                       | Zero-filled BSS  |&lt;br /&gt;
                               0x404000 +------------------+&lt;br /&gt;
&lt;br /&gt;
Entry: 0x401000&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
코드는 가상 주소 &amp;lt;code&amp;gt;0x401000&amp;lt;/code&amp;gt;부터 &amp;lt;code&amp;gt;0x402000&amp;lt;/code&amp;gt; 직전까지 대응된다. 초기값이 있는 데이터는 &amp;lt;code&amp;gt;0x402000&amp;lt;/code&amp;gt;부터 &amp;lt;code&amp;gt;0x402800&amp;lt;/code&amp;gt; 직전까지이고, 그 뒤 &amp;lt;code&amp;gt;0x404000&amp;lt;/code&amp;gt; 직전까지는 0으로 시작해야 한다. 파일 오프셋은 파일 안의 위치이고, 가상 주소는 프로그램이 사용하는 주소이며, 둘 중 어느 것도 물리 메모리 주소를 뜻하지 않는다.&lt;br /&gt;
&lt;br /&gt;
실제 메모리 매핑은 페이지 단위이므로 시작과 끝을 페이지 경계에 맞춰 처리한다. 파일 오프셋과 가상 주소의 페이지 내 위치가 맞아야 같은 바이트가 올바르게 대응된다. Linux의 &amp;lt;code&amp;gt;elf_map()&amp;lt;/code&amp;gt;은 이 정렬을 반영해 &amp;lt;code&amp;gt;vm_mmap()&amp;lt;/code&amp;gt;으로 파일 매핑을 만든다.&amp;lt;ref name=&amp;quot;elf&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== BSS의 0 초기화 ==&lt;br /&gt;
초기값이 0인 전역 및 정적 변수에 필요한 공간을 파일에 모두 0으로 저장할 필요는 없다. &amp;lt;code&amp;gt;p_memsz&amp;lt;/code&amp;gt;를 &amp;lt;code&amp;gt;p_filesz&amp;lt;/code&amp;gt;보다 크게 두면 커널은 추가 구간을 0으로 준비한다. 흔히 BSS라고 부르는 부분이며, 커널은 이 두 크기의 차이를 사용해 영역을 준비한다.&lt;br /&gt;
&lt;br /&gt;
앞의 예에서 파일 데이터의 끝인 &amp;lt;code&amp;gt;0x402800&amp;lt;/code&amp;gt;은 페이지 중간에 있다. 그래서 영 초기화는 두 부분으로 나뉜다.&lt;br /&gt;
&lt;br /&gt;
* &amp;lt;code&amp;gt;0x402800&amp;lt;/code&amp;gt;부터 다음 페이지 경계인 &amp;lt;code&amp;gt;0x403000&amp;lt;/code&amp;gt;까지는 이미 파일 매핑에 포함된 마지막 페이지의 나머지이다. &amp;lt;code&amp;gt;padzero()&amp;lt;/code&amp;gt;로 이 부분을 지워, 파일의 뒤따르는 바이트가 초기값으로 보이지 않게 한다.&lt;br /&gt;
* &amp;lt;code&amp;gt;0x403000&amp;lt;/code&amp;gt;부터 &amp;lt;code&amp;gt;0x404000&amp;lt;/code&amp;gt; 직전까지는 파일에 연결할 내용이 없는 익명 메모리로 만든다. &amp;lt;code&amp;gt;elf_load()&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;vm_brk_flags()&amp;lt;/code&amp;gt;를 이용하며, 마지막 페이지는 세그먼트 끝을 포함하도록 확보한다.&amp;lt;ref name=&amp;quot;elf&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
파일 데이터가 끝난 페이지의 일부는 직접 0으로 만들고, 나머지는 0으로 시작하는 익명 메모리의 성질을 이용한다. 물리 페이지는 필요에 따라 나중에 할당할 수 있다.&lt;br /&gt;
&lt;br /&gt;
== 접근 권한과 실제 페이지 준비 ==&lt;br /&gt;
&lt;br /&gt;
커널은 &amp;lt;code&amp;gt;p_flags&amp;lt;/code&amp;gt;의 &amp;lt;code&amp;gt;PF_R&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;PF_W&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;PF_X&amp;lt;/code&amp;gt;를 읽기, 쓰기, 실행에 해당하는 매핑 속성으로 바꾼다. 일반적으로 코드는 읽기와 실행, 수정할 데이터는 읽기와 쓰기로 배치한다. 이 속성은 페이지 테이블의 접근 제어로 이어지며, 허용되지 않은 접근은 보호 위반으로 처리된다. 이는 [[운영체제 기본/보호|보호]]와 [[운영체제 기본/가상 메모리|가상 메모리]]에서 설명한 원리가 실행 파일에 적용되는 사례이다.&lt;br /&gt;
&lt;br /&gt;
ELF의 파일 매핑은 사적 매핑인 &amp;lt;code&amp;gt;MAP_PRIVATE&amp;lt;/code&amp;gt;를 사용한다. 프로세스가 데이터 값을 바꾸더라도 디스크의 실행 파일을 수정하지 않으며, 필요하면 해당 프로세스만의 페이지 사본을 만든다.&lt;br /&gt;
&lt;br /&gt;
매핑은 주소 구간과 파일의 대응 관계를 정한다. 실제 페이지는 필요할 때 준비할 수 있다. 처음 명령어를 가져오거나 데이터를 읽을 때 아직 페이지가 연결되지 않았다면 페이지 폴트가 발생하고, 커널이 파일 페이지를 찾아 페이지 테이블을 채운 뒤 접근을 재개한다. 페이지 캐시에 내용이 있으면 저장 장치에서 다시 읽지 않아도 된다.&lt;br /&gt;
&lt;br /&gt;
헤더 읽기나 마지막 페이지의 영 초기화처럼 로딩 중 실제 접근이 일어나는 부분도 있다. 자세한 경로는 [[운영체제 기본/Linux/메모리 매핑/파일 매핑과 COW#읽기 폴트와 페이지 캐시|파일 매핑의 읽기 폴트]]에서 다룬다.&lt;br /&gt;
&lt;br /&gt;
이제 실행 파일의 코드와 데이터를 사용할 주소 공간이 준비되었다. 다음은 [[운영체제 기본/Linux/ELF 로딩/초기 스택과 사용자 모드 진입|초기 스택과 사용자 모드 진입]]에서 인자와 스택을 만들고 CPU가 실행을 시작할 상태를 준비하는 과정이다.&lt;br /&gt;
&lt;br /&gt;
== load_bias와 적재 주소 ==&lt;br /&gt;
지금까지는 &amp;lt;code&amp;gt;ET_EXEC&amp;lt;/code&amp;gt;의 지정된 가상 주소를 그대로 사용하는 경우를 설명했다. &amp;lt;code&amp;gt;ET_DYN&amp;lt;/code&amp;gt; 형식은 실행 시 다른 기준 주소에 배치할 수 있으며, 이때 세그먼트 주소와 진입 주소에 공통으로 더하는 값이 &amp;lt;code&amp;gt;load_bias&amp;lt;/code&amp;gt;이다. 실행할 때마다 배치 주소를 달리하는 ASLR에도 이 방식이 사용된다.&lt;br /&gt;
&lt;br /&gt;
이 추가 처리가 있어도 기본 원리는 같다. 배치 주소를 정하고, &amp;lt;code&amp;gt;PT_LOAD&amp;lt;/code&amp;gt;에 따라 파일과 영 초기화 영역을 연결한 뒤, 초기 스택과 진입 상태를 준비한다. 동적 링커가 필요한 프로그램의 시작은 다음 절의 기본 실행 흐름을 설명한 뒤 살펴본다.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/ELF 로딩/execve와 실행 이미지 교체|execve와 실행 이미지 교체]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/ELF 로딩|ELF 로딩 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/ELF 로딩/초기 스택과 사용자 모드 진입|초기 스택과 사용자 모드 진입]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/RCU/%EA%B0%B1%EC%8B%A0%EA%B3%BC_%EB%A9%94%EB%AA%A8%EB%A6%AC_%ED%9A%8C%EC%88%98&amp;diff=708</id>
		<title>운영체제 기본/Linux/RCU/갱신과 메모리 회수</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/RCU/%EA%B0%B1%EC%8B%A0%EA%B3%BC_%EB%A9%94%EB%AA%A8%EB%A6%AC_%ED%9A%8C%EC%88%98&amp;diff=708"/>
		<updated>2026-11-15T06:09:25Z</updated>

		<summary type="html">&lt;p&gt;관리자: 반복적인 부정 대조와 불필요한 강조 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=&amp;lt;- 이전 문서&amp;lt;br&amp;gt;[[운영체제 기본/Linux/RCU/포인터 공개와 읽기 구간|포인터 공개와 읽기 구간]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/RCU|RCU 목차]]&lt;br /&gt;
|다음=다음 문서 -&amp;gt;&amp;lt;br&amp;gt;[[운영체제 기본/Linux/RCU/Tree RCU와 유예 기간|Tree RCU와 유예 기간]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
RCU 갱신은 새 객체를 공개하는 일과 이전 객체를 해제하는 일을 분리한다. 공유 포인터에서 이전 객체를 떼어낸 뒤에도 기존 독자는 그 주소를 사용하고 있을 수 있다.&lt;br /&gt;
&lt;br /&gt;
== 유예 기간 ==&lt;br /&gt;
유예 기간(Grace Period)은 회수에 앞서 기존 RCU 읽기 구간들이 끝났음을 확인하는 기간이다. &amp;lt;code&amp;gt;synchronize_rcu()&amp;lt;/code&amp;gt;는 호출 전에 시작된 읽기 구간들이 끝나기를 기다린다. 유예 기간은 이 기존 읽기 구간들을 기준으로 판단한다.&amp;lt;ref name=&amp;quot;tree&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/kernel/rcu/tree.c?h=v6.12 Linux v6.12, kernel/rcu/tree.c], synchronize_rcu, synchronize_rcu_normal, call_rcu.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
시간   갱신자                 독자 A                 독자 B&lt;br /&gt;
  1                           lock; A 주소 획득&lt;br /&gt;
  2    B 초기화&lt;br /&gt;
  3    공유 포인터를 B로 교체&lt;br /&gt;
  4    synchronize_rcu 시작   A를 계속 읽음&lt;br /&gt;
  5                                                   lock; B 주소 획득&lt;br /&gt;
  6                           unlock&lt;br /&gt;
  7    유예 기간 완료 가능                           B를 계속 읽음&lt;br /&gt;
  8    A 해제&lt;br /&gt;
  9                                                   unlock&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
독자 A는 이전 객체를 읽었으므로 끝날 때까지 기다려야 한다. 교체 뒤 새 읽기 구간을 시작해 B를 얻은 독자 B는 A의 회수를 막을 이유가 없다. 구현에 따라 실제 대기는 더 길어질 수 있다. 객체를 찾을 수 있는 공유 경로에서 먼저 제거한 뒤 유예 기간을 기다려야 한다.&lt;br /&gt;
&lt;br /&gt;
== 동기식 회수 ==&lt;br /&gt;
앞 장의 설정 객체를 새 값으로 바꾸는 함수다. 읽기 함수는 &amp;lt;code&amp;gt;read_limit()&amp;lt;/code&amp;gt;을 그대로 사용한다. 초기 포인터가 NULL이어도 동작한다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
int replace_limit(int value)&lt;br /&gt;
{&lt;br /&gt;
    struct config *new, *old;&lt;br /&gt;
&lt;br /&gt;
    new = kmalloc(sizeof(*new), GFP_KERNEL);&lt;br /&gt;
    if (new == NULL)&lt;br /&gt;
        return -ENOMEM;&lt;br /&gt;
    new-&amp;gt;limit = value;&lt;br /&gt;
&lt;br /&gt;
    mutex_lock(&amp;amp;update_lock);&lt;br /&gt;
    old = rcu_dereference_protected(current_config,&lt;br /&gt;
                                  lockdep_is_held(&amp;amp;update_lock));&lt;br /&gt;
    rcu_assign_pointer(current_config, new);&lt;br /&gt;
    mutex_unlock(&amp;amp;update_lock);&lt;br /&gt;
&lt;br /&gt;
    if (old != NULL) {&lt;br /&gt;
        synchronize_rcu();&lt;br /&gt;
        kfree(old);&lt;br /&gt;
    }&lt;br /&gt;
    return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
갱신자용 뮤텍스는 이전 포인터를 얻고 새 포인터로 교체하는 구간을 직렬화한다. &amp;lt;code&amp;gt;rcu_dereference_protected()&amp;lt;/code&amp;gt;는 이처럼 다른 락으로 보호되는 갱신 측 접근을 표현한다. 이 예제에서는 각 갱신자가 자신이 떼어낸 객체 하나만 회수하며, 독자는 공개 뒤 불변인 필드만 읽는다. 따라서 유예 기간을 기다리는 동안까지 갱신자용 뮤텍스를 잡을 필요가 없다.&lt;br /&gt;
&lt;br /&gt;
뮤텍스는 갱신자들 사이의 충돌을 막고, RCU는 독자가 가진 이전 포인터의 수명을 지킨다. 새 객체를 공개하자마자 &amp;lt;code&amp;gt;kfree(old)&amp;lt;/code&amp;gt;를 하면 시간선의 독자 A가 해제된 메모리를 읽는다.&lt;br /&gt;
&lt;br /&gt;
== 콜백을 이용한 비동기 회수 ==&lt;br /&gt;
갱신자가 직접 기다리지 않아도 되도록, &amp;lt;code&amp;gt;call_rcu()&amp;lt;/code&amp;gt;는 유예 기간이 지난 뒤 실행할 콜백을 등록한다. 객체 안의 &amp;lt;code&amp;gt;struct rcu_head&amp;lt;/code&amp;gt;는 대기 중인 콜백의 연결 정보다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
static void free_config(struct rcu_head *head)&lt;br /&gt;
{&lt;br /&gt;
    struct config *old = container_of(head, struct config, rcu);&lt;br /&gt;
    kfree(old);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
/* 포인터 교체와 update_lock 해제 뒤 */&lt;br /&gt;
if (old != NULL)&lt;br /&gt;
    call_rcu(&amp;amp;old-&amp;gt;rcu, free_config);&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이 부분은 앞 예제의 &amp;lt;code&amp;gt;synchronize_rcu(); kfree(old);&amp;lt;/code&amp;gt;를 대신한다. 두 회수 방식을 같은 객체에 함께 적용하지 않는다. &amp;lt;code&amp;gt;call_rcu()&amp;lt;/code&amp;gt;는 반환했어도 콜백이 아직 실행되지 않았을 수 있으므로, 등록한 객체나 &amp;lt;code&amp;gt;rcu_head&amp;lt;/code&amp;gt;를 즉시 다시 쓰면 안 된다. 일반 RCU 콜백에는 잠드는 연산을 넣지 않는다. 단순 객체 해제에는 &amp;lt;code&amp;gt;kfree_rcu()&amp;lt;/code&amp;gt; 계열도 사용할 수 있다.&amp;lt;ref name=&amp;quot;tree&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
비동기 회수는 갱신자를 기다리게 하지 않는 대신 회수 대기 객체를 쌓을 수 있다. 갱신이 빠르거나 독자가 오래 읽기 구간에 남으면 메모리 사용량과 회수 지연이 증가한다. 유예 기간은 기존 읽기의 종료 여부에 따라 정해진다.&lt;br /&gt;
&lt;br /&gt;
== 사용 조건과 실패 사례 ==&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
! 잘못된 사용 !! 문제가 생기는 이유&lt;br /&gt;
|-&lt;br /&gt;
| 객체를 공개하기 전에 필드 초기화를 끝내지 않음 || 독자가 준비되지 않은 값을 읽을 수 있음&lt;br /&gt;
|-&lt;br /&gt;
| 포인터만 바꾸고 이전 객체를 즉시 해제 || 이미 이전 포인터를 얻은 독자가 남아 있음&lt;br /&gt;
|-&lt;br /&gt;
| 읽기 구간을 나간 뒤 포인터 역참조 || 이후 수명 보장이 끝남&lt;br /&gt;
|-&lt;br /&gt;
| 갱신자 동기화 없이 여러 변경을 수행 || RCU는 갱신자 상호배제를 제공하지 않음&lt;br /&gt;
|-&lt;br /&gt;
| 공개된 객체의 여러 필드를 제자리 변경 || 객체 생존과 필드 묶음의 일관성은 별개임&lt;br /&gt;
|-&lt;br /&gt;
| 독자가 필요한 락을 잡은 채 유예 기간 대기 || 독자는 락을 기다리고 갱신자는 독자의 종료를 기다릴 수 있음&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
모듈을 내리는 등 콜백 코드 자체를 없앨 때는, 유예 기간뿐 아니라 등록했던 콜백의 실행 완료도 구분해야 한다. &amp;lt;code&amp;gt;synchronize_rcu()&amp;lt;/code&amp;gt;가 모든 이전 &amp;lt;code&amp;gt;call_rcu()&amp;lt;/code&amp;gt; 콜백의 실행 완료를 보장하지는 않는다. 더 이상 새 콜백을 등록하지 못하게 정리한 뒤, 필요한 경우 &amp;lt;code&amp;gt;rcu_barrier()&amp;lt;/code&amp;gt;로 이미 등록된 콜백의 완료를 기다린다.&amp;lt;ref name=&amp;quot;barrier&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/Documentation/RCU/rcubarrier.rst?h=v6.12 Linux v6.12, Documentation/RCU/rcubarrier.rst], 모듈 해제와 rcu_barrier.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=&amp;lt;- 이전 문서&amp;lt;br&amp;gt;[[운영체제 기본/Linux/RCU/포인터 공개와 읽기 구간|포인터 공개와 읽기 구간]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/RCU|RCU 목차]]&lt;br /&gt;
|다음=다음 문서 -&amp;gt;&amp;lt;br&amp;gt;[[운영체제 기본/Linux/RCU/Tree RCU와 유예 기간|Tree RCU와 유예 기간]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/RCU/%ED%8F%AC%EC%9D%B8%ED%84%B0_%EA%B3%B5%EA%B0%9C%EC%99%80_%EC%9D%BD%EA%B8%B0_%EA%B5%AC%EA%B0%84&amp;diff=707</id>
		<title>운영체제 기본/Linux/RCU/포인터 공개와 읽기 구간</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/RCU/%ED%8F%AC%EC%9D%B8%ED%84%B0_%EA%B3%B5%EA%B0%9C%EC%99%80_%EC%9D%BD%EA%B8%B0_%EA%B5%AC%EA%B0%84&amp;diff=707"/>
		<updated>2026-11-15T06:09:06Z</updated>

		<summary type="html">&lt;p&gt;관리자: 과도한 대조와 강조 표현 정리, 문자 기호 통일&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=첫 문서&lt;br /&gt;
|목차=[[운영체제 기본/Linux/RCU|RCU 목차]]&lt;br /&gt;
|다음=다음 문서 -&amp;gt;&amp;lt;br&amp;gt;[[운영체제 기본/Linux/RCU/갱신과 메모리 회수|갱신과 메모리 회수]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
RCU에서는 객체 공개와 수명 관리가 필요하다. 독자가 새 객체의 주소를 얻었을 때 초기화된 내용을 볼 수 있어야 하고, 이미 얻은 객체는 읽기가 끝날 때까지 살아 있어야 한다. 포인터 공개와 읽기 구간은 이 두 조건을 함께 구성한다.&lt;br /&gt;
&lt;br /&gt;
== 읽기 중심 자료구조 ==&lt;br /&gt;
설정 객체 하나를 여러 CPU에서 자주 읽고, 설정 변경은 드물게 수행한다고 하자. 뮤텍스로 읽기와 쓰기를 모두 감싸면 올바르게 만들 수 있지만, 모든 읽기가 같은 락의 상태를 갱신한다. RCU에서는 독자가 갱신자용 뮤텍스를 획득하지 않는다. 갱신자는 새 객체를 만든 뒤 공유 포인터를 바꾸고, 이전 객체의 회수는 미룬다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
공개 전                       공개 후&lt;br /&gt;
current_config --&amp;gt; 객체 A     current_config --&amp;gt; 객체 B&lt;br /&gt;
                   값 10                       값 20&lt;br /&gt;
                               기존 독자 --&amp;gt; 객체 A&lt;br /&gt;
                                             값 10&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이 방식은 기존 독자가 A를 계속 읽어도 되는 자료구조에 적용한다. 모든 독자가 즉시 최신 값을 보아야 하거나 여러 객체의 변경을 한 번에 관찰해야 한다면, 그 조건을 만족시키는 별도 설계가 필요하다. 이 예제는 공개한 객체의 필드를 이후에 수정하지 않고 새 객체로 교체한다.&lt;br /&gt;
&lt;br /&gt;
== 객체 초기화와 포인터 공개 ==&lt;br /&gt;
다음 자료구조에서 &amp;lt;code&amp;gt;current_config&amp;lt;/code&amp;gt;가 RCU로 보호되는 공유 포인터이고, &amp;lt;code&amp;gt;update_lock&amp;lt;/code&amp;gt;은 갱신자끼리 경쟁하지 않게 하는 뮤텍스다. &amp;lt;code&amp;gt;struct rcu_head&amp;lt;/code&amp;gt;는 나중에 회수 콜백을 등록할 때 사용한다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
struct config {&lt;br /&gt;
    int limit;&lt;br /&gt;
    struct rcu_head rcu;&lt;br /&gt;
};&lt;br /&gt;
&lt;br /&gt;
static struct config __rcu *current_config;&lt;br /&gt;
static DEFINE_MUTEX(update_lock);&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
갱신자는 새 객체의 필드를 먼저 채운 뒤 &amp;lt;code&amp;gt;rcu_assign_pointer(current_config, new)&amp;lt;/code&amp;gt;로 주소를 공개한다. 단순히 C 포인터를 대입하는 것으로 끝내지 않는 이유는 컴파일러와 CPU의 메모리 접근 순서까지 맞춰야 하기 때문이다. v6.12의 &amp;lt;code&amp;gt;rcu_assign_pointer()&amp;lt;/code&amp;gt;는 일반적인 비NULL 포인터 공개에서 &amp;lt;code&amp;gt;smp_store_release()&amp;lt;/code&amp;gt;를 사용한다. 초기화가 공개보다 뒤로 관찰되는 것을 막는 공개 연산이다.&amp;lt;ref name=&amp;quot;rcupdate&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/linux/rcupdate.h?h=v6.12 Linux v6.12, include/linux/rcupdate.h], rcu_assign_pointer, rcu_dereference와 읽기 구간 API.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
독자는 &amp;lt;code&amp;gt;rcu_dereference()&amp;lt;/code&amp;gt;로 공유 포인터를 가져와 그 포인터를 통해 필드를 읽는다. 이 연산은 컴파일러의 부적절한 재읽기, 재배치와 필요한 메모리 순서를 다룬다. RCU 포인터를 통한 주소 의존성을 보존하는 것이 이 API 사용 규칙의 일부다.&amp;lt;ref name=&amp;quot;dereference&amp;quot;&amp;gt;[https://docs.kernel.org/6.12/RCU/rcu_dereference.html Linux v6.12 RCU 문서, rcu_dereference의 포인터와 의존성 규칙].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 읽기 구간과 객체 수명 ==&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
int read_limit(void)&lt;br /&gt;
{&lt;br /&gt;
    struct config *p;&lt;br /&gt;
    int value = 0;&lt;br /&gt;
&lt;br /&gt;
    rcu_read_lock();&lt;br /&gt;
    p = rcu_dereference(current_config);&lt;br /&gt;
    if (p != NULL)&lt;br /&gt;
        value = p-&amp;gt;limit;&lt;br /&gt;
    rcu_read_unlock();&lt;br /&gt;
    return value;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;rcu_read_lock()&amp;lt;/code&amp;gt;과 &amp;lt;code&amp;gt;rcu_read_unlock()&amp;lt;/code&amp;gt; 사이가 RCU 읽기 구간(Read-side Critical Section)이다. 독자가 RCU 규칙에 따라 객체를 사용하는 구간을 표시하고, 갱신자는 회수 전에 그 구간의 종료를 확인한다.&lt;br /&gt;
&lt;br /&gt;
포인터를 얻는 것부터 마지막 역참조까지 모두 읽기 구간 안에 있어야 한다. 위 함수는 정수 값을 복사해서 반환하므로 구간을 나간 뒤에도 그 값을 사용할 수 있다. 반면 &amp;lt;code&amp;gt;p&amp;lt;/code&amp;gt; 자체를 반환하고 구간 밖에서 &amp;lt;code&amp;gt;p-&amp;gt;limit&amp;lt;/code&amp;gt;을 읽으면, 그 사이 객체가 해제될 수 있다. 구간 밖으로 객체를 가져가려면 참조 카운트 등 별도의 수명 보장 절차가 필요하다.&lt;br /&gt;
&lt;br /&gt;
읽기 구간은 객체의 수명과 공개 순서를 보장하는 프로토콜이다. 기존 객체의 필드를 제자리에서 변경한다면 여러 필드의 일관성은 별도로 보장해야 한다. 또한 여러 갱신자가 서로의 변경을 덮어쓰는 문제는 &amp;lt;code&amp;gt;update_lock&amp;lt;/code&amp;gt; 같은 별도 동기화로 해결한다.&amp;lt;ref name=&amp;quot;requirements&amp;quot;&amp;gt;[https://docs.kernel.org/6.12/RCU/Design/Requirements/Requirements.html Linux v6.12 RCU 요구사항], 유예 기간, 공개 보장과 보장하지 않는 조건.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 읽기 구간의 선점과 대기 ==&lt;br /&gt;
이 장의 &amp;lt;code&amp;gt;CONFIG_PREEMPT_RCU=y&amp;lt;/code&amp;gt;에서는 읽기 구간의 태스크도 CPU에서 선점될 수 있다. 커널은 읽기 중 선점된 태스크를 별도로 추적한다.&lt;br /&gt;
&lt;br /&gt;
일반 RCU 읽기 구간에서는 I/O 대기나 잠드는 뮤텍스 획득처럼 명시적으로 블록하는 연산을 넣지 않는다. 특히 같은 구간 안에서 &amp;lt;code&amp;gt;synchronize_rcu()&amp;lt;/code&amp;gt;를 호출하면 자신이 끝나기를 기다리는 관계가 생긴다. 잠드는 독자가 필요한 용도에는 별도 API인 SRCU 등을 검토한다. PREEMPT_RT에는 일부 락 처리에 한정된 예외가 있다.&amp;lt;ref name=&amp;quot;rcupdate&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 아키텍처와 공통 API ==&lt;br /&gt;
x86-64와 RISC-V RV64 모두 같은 RCU API와 Tree RCU 알고리즘을 사용한다. 차이는 공개, 읽기 순서를 구현하는 아키텍처별 장벽과 메모리 모델에 있다. 특정 장벽 명령이 필요 없는 x86-64 경로에서도 RCU API를 사용해야 한다. API가 컴파일러 제약과 아키텍처별 메모리 순서를 함께 처리한다.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=첫 문서&lt;br /&gt;
|목차=[[운영체제 기본/Linux/RCU|RCU 목차]]&lt;br /&gt;
|다음=다음 문서 -&amp;gt;&amp;lt;br&amp;gt;[[운영체제 기본/Linux/RCU/갱신과 메모리 회수|갱신과 메모리 회수]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/%EA%B0%80%EC%83%81_%EB%A9%94%EB%AA%A8%EB%A6%AC&amp;diff=706</id>
		<title>운영체제 기본/가상 메모리</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/%EA%B0%80%EC%83%81_%EB%A9%94%EB%AA%A8%EB%A6%AC&amp;diff=706"/>
		<updated>2026-11-15T06:09:05Z</updated>

		<summary type="html">&lt;p&gt;관리자: 강조와 특수문자, 반복 대조를 정리하고 주소 변환 설명을 간결하게 수정&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/동시성|동시성]]&lt;br /&gt;
|목차=[[운영체제 기본#총론|총론 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/파일과 입출력|파일과 입출력]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
프로그램은 배열과 포인터를 연속된 주소로 다루지만, 실제 RAM은 여러 프로그램이 나누어 쓰는 유한한 자원이다. 프로그램마다 필요한 크기도, 실행되는 시간도 다르다. 가상 메모리는 프로그램이 사용하는 주소와 실제 저장 위치 사이에 변환 계층을 두어 배치, 보호, 공유를 함께 다루는 설계다. 여기서는 주소 변환 하드웨어가 있는 시스템의 페이지 기반 방식을 설명한다.&lt;br /&gt;
&lt;br /&gt;
== 주소 변환과 메모리 보호 ==&lt;br /&gt;
프로그램이 물리 주소를 직접 사용한다면 실행 위치가 바뀔 때 주소를 조정해야 한다. 잘못 계산한 포인터가 다른 프로그램의 데이터를 덮어쓰는 문제도 막아야 한다.&lt;br /&gt;
&lt;br /&gt;
가상 메모리는 각 프로세스에 독립적인 주소 공간을 제공한다. 같은 주소 값이라도 어느 주소 공간에서 사용되는지에 따라 다른 물리 메모리를 가리킨다. 프로그램은 자기 주소를 유지하고, 운영체제는 그 주소에 연결할 물리 메모리를 선택한다. 접근 권한도 이 연결에 포함하므로 읽기 전용 영역에 대한 쓰기나 허용되지 않은 주소의 접근을 하드웨어가 가려낼 수 있다.&lt;br /&gt;
&lt;br /&gt;
가상 주소에 시작 위치만 더하는 방식은 프로그램을 다른 위치에 놓을 수 있게 하지만, 프로그램 전체를 담을 연속된 물리 공간은 여전히 필요하다.&lt;br /&gt;
&lt;br /&gt;
== 연속 할당과 외부 단편화 ==&lt;br /&gt;
연속 할당 (Contiguous Allocation)은 하나의 영역을 물리 메모리에서도 이어진 구간에 배치하는 방식이다. 프로그램마다 필요한 크기와 종료 시점이 다르므로, 할당과 해제를 반복하면 사용 중인 영역 사이에 빈 구간이 생긴다. 예를 들어 다음과 같이 4 KiB짜리 빈 구간 두 개가 다른 프로그램의 영역을 사이에 두고 있다고 하자.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
물리 메모리: 낮은 주소 -&amp;gt; 높은 주소&lt;br /&gt;
+------------+------------+------------+------------+&lt;br /&gt;
|  A in use  | free 4 KiB |  B in use  | free 4 KiB |&lt;br /&gt;
+------------+------------+------------+------------+&lt;br /&gt;
&lt;br /&gt;
빈 공간 합계: 8 KiB&lt;br /&gt;
새 연속 영역 요청: 6 KiB&lt;br /&gt;
가장 큰 빈 구간: 4 KiB -&amp;gt; 배치 불가&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
전체 빈 공간은 충분하지만 하나로 이어져 있지 않아 요청을 만족하지 못하는 현상이 외부 단편화 (External Fragmentation)다. 낭비가 이미 할당한 영역의 바깥, 즉 영역 사이에서 발생한다. 같은 이유로 배열을 늘리려 해도 바로 뒤를 다른 영역이 차지하고 있으면 제자리에서 확장할 수 없다.&amp;lt;ref name=&amp;quot;fragmentation-cornell&amp;quot;&amp;gt;[https://www.cs.cornell.edu/courses/cs4410/2015su/lectures/lec13-paging.html Cornell CS 4410: Managing physical memory], 연속 배치와 외부 단편화.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
사용 중인 내용을 옮겨 빈 구간을 합치는 메모리 압축 (Compaction)도 가능하지만, 데이터 이동과 주소 변환 정보 갱신에 비용이 든다. 페이징은 큰 영역 전체를 연속해서 배치해야 한다는 조건을 바꾼다.&lt;br /&gt;
&lt;br /&gt;
== 페이지와 프레임 ==&lt;br /&gt;
페이징 (Paging)은 가상 주소 공간을 일정한 크기의 페이지 (Page)로 나누고, 물리 메모리도 같은 크기의 프레임 (Frame)으로 나누어 관리하는 방식이다. 프레임은 물리 페이지 또는 페이지 프레임이라고도 한다. 페이지 크기를 4 KiB로 잡으면, 가상 주소의 각 4 KiB 구간을 사용할 수 있는 물리 프레임 하나에 연결할 수 있다.&amp;lt;ref name=&amp;quot;paging-xv6&amp;quot;&amp;gt;[https://mit-pdos.github.io/xv6-riscv-book/mem.html MIT xv6: Page tables], 페이지 단위 주소 변환과 페이지 테이블.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
프로그램의 페이지 순서와 물리 프레임의 순서는 같을 필요가 없다. 가상 주소에서 연속된 두 페이지를 서로 떨어진 프레임에 놓아도, 각각의 연결을 통해 접근하면 프로그램은 연속된 주소를 그대로 사용한다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
프로그램의 연속된 8 KiB         물리 메모리의 서로 떨어진 프레임&lt;br /&gt;
&lt;br /&gt;
가상 페이지 0 ---------------&amp;gt; 프레임 2: 페이지 0의 내용&lt;br /&gt;
가상 페이지 1 ---------------&amp;gt; 프레임 9: 페이지 1의 내용&lt;br /&gt;
&lt;br /&gt;
페이지 0의 마지막 바이트 다음은 가상 페이지 1의 첫 바이트다.&lt;br /&gt;
물리 프레임 2와 9 사이에는 다른 데이터가 있어도 된다.&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
앞의 6 KiB 요청도 4 KiB 페이지 두 개로 나누면 흩어진 빈 프레임 두 개에 배치할 수 있다. 같은 크기의 프레임을 하나씩 확보하는 데에는 영역 전체를 담을 큰 연속 구간이 필요하지 않다. 대신 마지막 페이지에는 사용하지 않는 공간이 남는다.&lt;br /&gt;
&lt;br /&gt;
== 페이지 테이블과 주소 변환 ==&lt;br /&gt;
어느 페이지가 어느 프레임에 있는지는 페이지 테이블 (Page Table)에 기록한다. 페이지 테이블 항목인 PTE (Page Table Entry)에는 대응하는 물리 프레임과 읽기, 쓰기, 실행 등의 접근 권한, 유효한 매핑인지 판단할 정보가 들어간다. 운영체제가 실행 중인 프로그램의 메모리 접근마다 끼어들어 주소와 권한을 소프트웨어로 검사하면 비용이 지나치게 커진다. 이를 돕는 하드웨어가 [[운영체제 기본/보호#실행 권한, 주소, 자원의 경계|메모리 관리 장치 (MMU)]]다. 운영체제가 페이지 테이블에 연결 관계와 권한을 설정하면 MMU가 각 메모리 접근의 주소 변환과 권한 검사를 수행한다. 정상적인 메모리 접근은 이 과정에서 커널을 호출하지 않고 처리된다.&amp;lt;ref name=&amp;quot;paging-xv6&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
가상 주소는 가상 페이지 번호 (Virtual Page Number, VPN)와 페이지 내부 오프셋 (Offset)으로 나뉜다. 페이지 번호로 대응하는 프레임을 찾은 뒤 그 프레임의 시작 주소에 오프셋을 더한다. 변환되는 것은 페이지 번호이며, 페이지 안의 위치는 그대로 유지된다.&lt;br /&gt;
&lt;br /&gt;
예를 들어 페이지가 4 KiB라면 가상 주소 (Virtual Address, VA) &amp;lt;code&amp;gt;0x1234&amp;lt;/code&amp;gt;는 가상 페이지 번호 1과 페이지 내부 오프셋 &amp;lt;code&amp;gt;0x234&amp;lt;/code&amp;gt;로 나뉜다. 페이지 1을 물리 프레임 9에 연결했다면 물리 주소 (Physical Address, PA)는 &amp;lt;code&amp;gt;0x9234&amp;lt;/code&amp;gt;가 된다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
VA 0x1234 = [ page 1  | offset 0x234 ]&lt;br /&gt;
                 |           |&lt;br /&gt;
             page table      |&lt;br /&gt;
                 v           v&lt;br /&gt;
PA 0x9234 = [ frame 9 | offset 0x234 ]&lt;br /&gt;
&lt;br /&gt;
물리 주소: 9 * 0x1000 + 0x234 = 0x9234&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
페이지 테이블의 구체적인 단계와 비트 배치는 아키텍처마다 다르다. x86-64와 RISC-V RV64에서도 사용하는 주소 변환 방식에 차이가 있지만, 페이지 번호를 변환하고 오프셋을 유지한다는 원리는 같다. 현재 매핑으로 접근을 처리할 수 없으면 페이지 폴트가 발생하며, 커널은 뒤에서 설명할 [[#페이지 폴트의 처리|주소 공간의 규칙]]에 따라 처리한다.&lt;br /&gt;
&lt;br /&gt;
== 내부 단편화 ==&lt;br /&gt;
6 KiB를 저장하려고 4 KiB 프레임 두 개를 전용으로 할당하면 실제 확보한 공간은 8 KiB다. 두 번째 프레임에서 사용하지 않는 2 KiB는 다른 주소 공간에 독립적인 프레임으로 내줄 수 없다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
첫 프레임 (4 KiB): [ 사용 4 KiB             ]&lt;br /&gt;
둘째 프레임 (4 KiB): [ 사용 2 KiB | 여유 2 KiB ]&lt;br /&gt;
&lt;br /&gt;
총 8 KiB 확보 -&amp;gt; 6 KiB 사용 + 2 KiB 내부 단편화&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이처럼 할당한 단위의 내부에서 사용하지 않는 공간이 생기는 현상을 내부 단편화 (Internal Fragmentation)라고 한다. 외부 단편화는 빈 구간이 흩어져 요청을 배치하지 못하는 문제이고, 내부 단편화는 배치한 뒤 할당 단위 안에 여유가 남는 문제다. 프로그램 내부의 메모리 할당기는 한 페이지에 여러 작은 객체를 넣어 공간을 활용할 수 있다. 이때도 운영체제는 페이지 단위로 매핑과 접근 권한을 관리한다.&amp;lt;ref name=&amp;quot;fragmentation-stanford&amp;quot;&amp;gt;[https://web.stanford.edu/class/archive/cs/cs111/cs111.1244/spring22/lectures/ins_vm/index.html Stanford CS 111: Virtual Memory], 페이지 단위 할당과 내부 단편화.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
페이징을 사용하는 시스템에서도 큰 페이지나 장치의 요구 때문에 여러 프레임이 물리적으로 연속되어야 하는 경우에는 외부 단편화가 다시 문제가 된다. 일반적인 페이지 배치에서는 각 페이지를 서로 떨어진 프레임에 놓을 수 있다.&amp;lt;ref name=&amp;quot;source-1&amp;quot;&amp;gt;[https://docs.kernel.org/admin-guide/mm/concepts.html Linux 커널 문서: Concepts overview], 주소 변환, 페이지 크기와 메모리 압축.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 페이징과 주소 변환 비용 ==&lt;br /&gt;
페이지별 연결을 기록하려면 페이지 테이블 자체도 메모리를 차지한다. 모든 가상 페이지에 항목 하나를 미리 두는 단순한 표는 주소 공간이 클수록 비대해진다. 다단계 페이지 테이블은 표를 여러 단계로 나누어 사용하지 않는 주소 구간의 하위 표를 생략할 수 있게 한다. 대신 필요한 항목을 찾을 때 여러 단계의 조회가 발생할 수 있다.&amp;lt;ref name=&amp;quot;page-table-cost&amp;quot;&amp;gt;[https://www.cs.cornell.edu/courses/cs4410/2018su/lectures/lec12-paging.html Cornell CS 4410: Managing the page table], 페이지 테이블 크기와 다단계 구조.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
CPU는 최근 변환 결과를 TLB (Translation Lookaside Buffer, 주소 변환 캐시)에 보관해 조회 비용을 줄인다. TLB 미스가 발생하면 페이지 테이블에서 변환 정보를 다시 찾는다. 유효한 매핑이 있으면 그 결과를 사용하고, 매핑이나 권한으로 접근을 처리할 수 없으면 페이지 폴트가 발생한다.&amp;lt;ref name=&amp;quot;source-1&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
페이지를 크게 하면 같은 범위를 더 적은 페이지 테이블 항목과 TLB 항목으로 표현할 수 있다. 반면 일부만 쓰는 페이지의 내부 단편화가 커질 수 있고, 그 페이지를 뒷받침할 연속된 물리 영역을 확보하기도 어려워진다. 작은 페이지는 배치와 보호를 더 세밀하게 하는 대신 관리할 항목 수를 늘린다. 페이지 크기는 메모리 활용과 주소 변환 비용 사이의 절충이다.&amp;lt;ref name=&amp;quot;source-1&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 요구 페이징과 지연 할당 ==&lt;br /&gt;
프로그램이 확보한 주소 범위를 항상 전부 사용하는 것은 아니다. 실행 파일에도 이번 실행에서는 읽지 않을 코드가 있고, 큰 배열에서도 일부만 접근할 수 있다. 처음부터 모든 내용을 RAM에 준비하는 대신 실제 접근할 때 페이지를 마련하면 사용하지 않는 부분의 비용을 피할 수 있다. 최근 사용한 데이터나 그 주변을 다시 사용하는 지역성이 높을수록 적은 RAM으로 많은 작업을 처리하기 유리하다.&lt;br /&gt;
&lt;br /&gt;
이 지연 할당을 가능하게 하는 것이 페이지 폴트다. 아직 준비하지 않은 페이지에 실제로 접근할 때 커널이 개입해 필요한 메모리를 마련한다.&lt;br /&gt;
&lt;br /&gt;
이 설계는 초기 준비 비용과 메모리 사용량을 줄이는 대신 실제 접근 시점에 지연을 발생시킨다. 접근 시간이 일정해야 하는 작업에서는 이 변동 자체가 문제가 된다. 여러 작업이 반복해서 쓰는 페이지들의 집합이 RAM을 넘으면, 내보낸 페이지를 곧바로 다시 가져오는 일이 이어져 실제 계산보다 교체에 시간을 쓰게 된다. &amp;lt;ref name=&amp;quot;source-2&amp;quot;&amp;gt;[https://docs.freebsd.org/en/books/arch-handbook/vm/ FreeBSD Architecture Handbook: 가상 메모리].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 페이지 폴트의 처리 ==&lt;br /&gt;
[[운영체제 기본/보호#보호 위반과 예외|보호]]에서 본 페이지 폴트는 CPU가 현재의 매핑과 권한으로 메모리 접근을 완료하지 못했다는 통지다. x86에서는 #PF 벡터로 [[운영체제 기본/장치 제어와 입출력#처리 진입점과 IDT|IDT에 등록된 커널 진입 코드]]를 실행한다. 이 시점에는 프로그램을 종료할지 아직 결정되지 않았다.&lt;br /&gt;
&lt;br /&gt;
운영체제는 주소 공간의 관리 정보에 허용된 범위와 접근 방식, 파일 같은 원본을 기록한다. 유효한 주소 범위를 먼저 제공하고 물리 페이지의 준비를 미뤄 두었다면, 접근 시점의 폴트 처리에서 페이지를 마련할 수 있다.&amp;lt;ref name=&amp;quot;fault-handling&amp;quot;&amp;gt;[https://docs.kernel.org/mm/page_tables.html Linux 커널 문서: Page Tables], Page Faults.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
처리기는 문제가 된 주소와 읽기, 쓰기 등의 접근 종류를 확인하고 다음과 같이 분기한다.&lt;br /&gt;
&lt;br /&gt;
# 허용되지 않은 주소이거나 해당 연산의 권한이 없다면 접근 위반으로 처리한다. 사용자 프로그램에 오류를 통지하며, 처리되지 않은 오류는 통상 프로세스 종료로 이어진다.&lt;br /&gt;
# 허용된 영역인데 페이지를 아직 마련하지 않았다면 메모리를 할당하고 필요한 내용을 준비한다. 0으로 초기화된 메모리를 제공할 수도 있고 파일에서 읽어야 할 수도 있다.&lt;br /&gt;
# 논리적으로는 쓰기가 허용되지만 [[#페이지 공유와 쓰기 시 복사|쓰기 시 복사]]를 위해 현재 페이지를 읽기 전용으로 공유 중이었다면, 필요에 따라 복사본을 마련하고 매핑을 바꾼다.&lt;br /&gt;
# 필요한 매핑과 권한을 갱신한 뒤, 폴트를 일으킨 명령을 다시 실행할 수 있는 상태로 복귀한다.&amp;lt;ref name=&amp;quot;fault-handling&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
메모리 접근 -&amp;gt; 페이지 폴트 -&amp;gt; 커널이 주소 공간의 규칙 확인&lt;br /&gt;
                            |&lt;br /&gt;
                            +-&amp;gt; 허용된 접근: 페이지 준비, 매핑 갱신 -&amp;gt; 명령 재실행&lt;br /&gt;
                            |&lt;br /&gt;
                            +-&amp;gt; 허용되지 않은 접근: 오류 통지 -&amp;gt; 통상 종료&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
필요한 데이터를 저장장치에서 가져와야 한다면 처리 중인 스레드가 입출력 완료를 기다릴 수 있다. 그동안 다른 스레드가 CPU를 사용하고, 완료 통지와 깨우기를 거쳐 실행이 재개된다. 이 부분은 [[운영체제 기본/장치 제어와 입출력#입출력 완료와 깨우기|입출력 완료와 깨우기]]로 연결된다.&lt;br /&gt;
&lt;br /&gt;
== 페이지 공유와 쓰기 시 복사 ==&lt;br /&gt;
독립된 주소 공간도 같은 물리 페이지를 가리킬 수 있다. 변경하지 않는 코드나 데이터를 공유하면 중복 저장을 줄인다. [[운영체제 기본/프로세스 간 통신#공유 메모리와 동기화|쓰기 가능한 공유 데이터]]는 복사를 줄이는 대신 참여자 사이의 동기화를 요구한다. 운영체제가 매핑과 접근 권한을 설정하고 하드웨어가 이를 검사하더라도, 공유 데이터의 갱신 순서는 별도의 동기화 규약으로 정해야 한다.&lt;br /&gt;
&lt;br /&gt;
쓰기 시 복사(Copy-on-Write, COW)에서는 운영체제가 처음에는 같은 물리 페이지를 읽기 전용으로 연결한다. 프로그램이 쓰려고 하면 하드웨어가 페이지 폴트를 일으키고, 커널이 이 접근을 COW 대상으로 확인한다. 다른 주소 공간과 내용을 분리해야 하면 커널이 페이지를 복사하고 쓰는 쪽의 매핑을 복사본으로 바꾼다. 더 이상 공유하지 않는 페이지라면 복사 없이 쓰기를 허용할 수도 있다.&amp;lt;ref name=&amp;quot;cow-hardware-software&amp;quot;&amp;gt;[https://pdos.csail.mit.edu/6.1810/2025/labs/cow.html MIT PDOS, Copy-on-Write Fork for xv6], 읽기 전용 매핑과 CPU 폴트, 커널의 복사, 매핑 갱신.&amp;lt;/ref&amp;gt; 결국 변경하지 않을 데이터까지 미리 복사하는 비용을 피하지만, 첫 쓰기에 폴트와 복사가 발생하고 수정 범위가 넓으면 실제 메모리 사용도 늘어난다. &amp;lt;ref name=&amp;quot;source-3&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man2/fork.2.html Linux man-pages: fork(2)].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 유한한 RAM과 매핑의 수명 ==&lt;br /&gt;
RAM이 부족하면 다시 읽을 수 있는 깨끗한 파일 페이지는 버릴 수 있다. 변경한 데이터는 보존할 곳이 필요하다. 파일에 반영하거나 스왑 같은 보조 저장소로 옮기는 데에는 입출력 시간이 든다. 스왑은 이 선택지 가운데 하나이며, 스왑이 없어도 주소 변환과 보호, 공유는 유효하다. 실제 데이터의 저장 용량과 접근 시간은 RAM과 보조 저장소의 용량 및 성능에 영향을 받는다.&lt;br /&gt;
&lt;br /&gt;
주소의 의미는 매핑이 유지되는 동안에만 성립한다. 매핑을 제거한 뒤 같은 주소를 재사용하면 남아 있는 포인터 값이 같아도 대상은 달라진다. 매핑을 유지할지, 같은 내용을 공유할지, 쓰기를 허용할지는 운영체제가 따로 관리하는 조건이다. 파일의 내용을 메모리에 연결하는 경우에도 이 구분이 필요하다. 파일을 여는 동작과 매핑의 수명 관계는 [[운영체제 기본/파일과 입출력|파일과 입출력]]의 열린 상태를 이해한 뒤 [[운영체제 기본/Linux/메모리 매핑/파일 매핑과 COW|파일 매핑과 COW]]에서 살펴볼 수 있다. &amp;lt;ref name=&amp;quot;source-4&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man2/mmap.2.html Linux man-pages: mmap(2)].&amp;lt;/ref&amp;gt;&lt;br /&gt;
== 관련 각론 ==&lt;br /&gt;
* [[운영체제 기본/Linux/ELF 로딩/ELF 세그먼트와 주소 공간|ELF 세그먼트와 주소 공간]]: 실행 파일의 코드, 데이터를 파일 매핑과 익명 메모리로 구성하는 과정.&lt;br /&gt;
* [[운영체제 기본/Linux/메모리 매핑|Linux의 메모리 매핑]]: VMA와 페이지 폴트, 익명 메모리의 지연 할당, 파일 매핑과 COW, MMIO 매핑.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/동시성|동시성]]&lt;br /&gt;
|목차=[[운영체제 기본#총론|총론 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/파일과 입출력|파일과 입출력]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/ELF_%EB%A1%9C%EB%94%A9/execve%EC%99%80_%EC%8B%A4%ED%96%89_%EC%9D%B4%EB%AF%B8%EC%A7%80_%EA%B5%90%EC%B2%B4&amp;diff=705</id>
		<title>운영체제 기본/Linux/ELF 로딩/execve와 실행 이미지 교체</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/ELF_%EB%A1%9C%EB%94%A9/execve%EC%99%80_%EC%8B%A4%ED%96%89_%EC%9D%B4%EB%AF%B8%EC%A7%80_%EA%B5%90%EC%B2%B4&amp;diff=705"/>
		<updated>2026-11-15T06:09:04Z</updated>

		<summary type="html">&lt;p&gt;관리자: 문체 정리: 반복 대조와 과도한 강조, 인용 표현 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|목차=[[운영체제 기본/Linux/ELF 로딩|ELF 로딩 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/ELF 로딩/ELF 세그먼트와 주소 공간|ELF 세그먼트와 주소 공간]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
이 절은 Linux v6.12의 x86-64를 기준으로, 실행 파일을 받은 커널이 기존 프로그램을 새 프로그램으로 바꾸는 흐름을 설명한다. 먼저 동적 링커가 필요 없는 정적 링크된 &amp;lt;code&amp;gt;ET_EXEC&amp;lt;/code&amp;gt; 실행 파일을 대상으로 삼는다. &lt;br /&gt;
&lt;br /&gt;
== execve와 실행 이미지 교체 ==&lt;br /&gt;
&amp;lt;code&amp;gt;execve()&amp;lt;/code&amp;gt;는 호출한 프로세스의 실행 이미지를 교체하는 시스템 콜(System Call)이다. PID는 유지된다. 예를 들어 셸은 먼저 자식 프로세스를 만든 다음, 그 자식에서 &amp;lt;code&amp;gt;execve()&amp;lt;/code&amp;gt;를 호출하여 실행할 프로그램을 바꿀 수 있다. 프로세스 생성과 프로그램 로딩은 서로 다른 작업이다.&amp;lt;ref name=&amp;quot;man&amp;quot;&amp;gt;Linux man-pages, [https://man7.org/linux/man-pages/man2/execve.2.html execve(2)]. 실행 이미지 교체와 프로세스 속성.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
실행 이미지에는 코드뿐 아니라 데이터, 스택과 같은 사용자 주소 공간의 내용과 실행을 시작할 위치도 포함된다. &amp;lt;code&amp;gt;execve()&amp;lt;/code&amp;gt;에 성공하면 기존 프로그램의 코드와 스택으로 돌아가지 않고 새 프로그램을 실행한다. 같은 프로세스가 새 프로그램을 실행하는 것이다. 프로세스 생성과 실행의 관계는 [[운영체제 기본/프로세스와 스레드|프로세스와 스레드]]를 참고한다.&lt;br /&gt;
&lt;br /&gt;
== 실행 파일 열기와 인수 준비 ==&lt;br /&gt;
사용자 프로그램은 &amp;lt;code&amp;gt;execve(path, argv, envp)&amp;lt;/code&amp;gt;로 실행 파일의 경로, 인수 문자열 배열, 환경 문자열 배열을 전달한다. 커널은 먼저 사용자 공간의 경로명을 가져온 뒤 공통 실행 준비 함수인 &amp;lt;code&amp;gt;do_execveat_common()&amp;lt;/code&amp;gt;으로 들어간다. 함수 이름에 &amp;lt;code&amp;gt;at&amp;lt;/code&amp;gt;가 붙은 이유는 실행 대상을 지정하는 또 다른 시스템 콜인 &amp;lt;code&amp;gt;execveat()&amp;lt;/code&amp;gt;와 준비 경로를 공유하기 때문이다. 여기서는 일반적인 &amp;lt;code&amp;gt;execve()&amp;lt;/code&amp;gt;의 흐름만 따라간다.&amp;lt;ref name=&amp;quot;exec&amp;quot;&amp;gt;Linux v6.12, [https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/exec.c?h=v6.12 fs/exec.c]. 실행 요청의 준비, 형식 탐색과 이미지 교체.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
execve&lt;br /&gt;
  -&amp;gt; do_execve&lt;br /&gt;
     -&amp;gt; do_execveat_common&lt;br /&gt;
        -&amp;gt; alloc_bprm&lt;br /&gt;
           -&amp;gt; do_open_execat -&amp;gt; do_filp_open&lt;br /&gt;
           -&amp;gt; bprm_mm_init&lt;br /&gt;
        -&amp;gt; copy argument and environment strings&lt;br /&gt;
        -&amp;gt; bprm_execve&lt;br /&gt;
           -&amp;gt; exec_binprm&lt;br /&gt;
              -&amp;gt; search_binary_handler&lt;br /&gt;
                 -&amp;gt; load_elf_binary&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;alloc_bprm()&amp;lt;/code&amp;gt;은 실행 파일을 열고, 이번 실행 요청의 준비 상태를 담을 &amp;lt;code&amp;gt;linux_binprm&amp;lt;/code&amp;gt; 객체를 만든다. 파일을 여는 내부 경로는 &amp;lt;code&amp;gt;do_open_execat()&amp;lt;/code&amp;gt;에서 &amp;lt;code&amp;gt;do_filp_open()&amp;lt;/code&amp;gt;으로 이어진다. VFS가 경로를 탐색하여 파일을 열면 커널은 그 결과인 &amp;lt;code&amp;gt;struct file&amp;lt;/code&amp;gt;을 보관한다. 이후 로더는 열린 파일 객체를 통해 실행 파일을 읽는다. 이름과 열린 파일 객체의 차이는 [[운영체제 기본/Linux/파일시스템/VFS와 파일 객체|VFS와 파일 객체]]에서 설명한다.&amp;lt;ref name=&amp;quot;exec&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;linux_binprm&amp;lt;/code&amp;gt;은 열린 파일, 새 주소 공간, 인수 문자열을 쌓을 위치 등 로딩 중에 필요한 상태를 묶어 둔 객체다. &amp;lt;code&amp;gt;bprm_mm_init()&amp;lt;/code&amp;gt;은 새 주소 공간을 나타내는 &amp;lt;code&amp;gt;mm_struct&amp;lt;/code&amp;gt;와 임시 스택 영역을 준비한다. 이때는 아직 현재 프로세스의 주소 공간을 바꾸지 않는다.&amp;lt;ref name=&amp;quot;exec&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
커널은 인수와 환경 문자열의 크기를 확인하고 새 스택에 사용할 공간으로 문자열을 복사한다. 기존 주소 공간을 나중에 버리더라도 새 프로그램에 전달할 입력은 남아 있어야 하기 때문이다. 최종 사용자 스택의 배열과 값은 ELF 로더가 실행 이미지에 맞춰 마무리한다.&lt;br /&gt;
&lt;br /&gt;
== binfmt와 ELF 로더 선택 ==&lt;br /&gt;
커널은 열린 파일의 앞부분을 읽고, 등록된 실행 형식 핸들러가 이를 해석할 수 있는지 확인한다. 이 실행 형식 처리 체계를 &amp;lt;code&amp;gt;binfmt&amp;lt;/code&amp;gt;라고 한다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;bprm_execve()&amp;lt;/code&amp;gt;에서 &amp;lt;code&amp;gt;exec_binprm()&amp;lt;/code&amp;gt;을 거쳐 호출되는 &amp;lt;code&amp;gt;search_binary_handler()&amp;lt;/code&amp;gt;는 먼저 &amp;lt;code&amp;gt;prepare_binprm()&amp;lt;/code&amp;gt;으로 파일의 앞부분을 &amp;lt;code&amp;gt;bprm-&amp;gt;buf&amp;lt;/code&amp;gt;에 읽는다. v6.12에서 이 버퍼의 크기는 256바이트다. 이 버퍼는 실행 파일의 형식을 판별하는 데 사용한다.&amp;lt;ref name=&amp;quot;exec&amp;quot; /&amp;gt;&amp;lt;ref&amp;gt;Linux v6.12, [https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/binfmts.h?h=v6.12 include/uapi/linux/binfmts.h]. &amp;lt;code&amp;gt;BINPRM_BUF_SIZE&amp;lt;/code&amp;gt;.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
그 다음 등록된 핸들러의 &amp;lt;code&amp;gt;load_binary()&amp;lt;/code&amp;gt;를 호출한다. 아직 이미지 교체를 확정하지 않은 핸들러가 &amp;lt;code&amp;gt;-ENOEXEC&amp;lt;/code&amp;gt;를 반환하면 다음 핸들러를 시도한다. ELF 핸들러의 이 함수는 &amp;lt;code&amp;gt;load_elf_binary()&amp;lt;/code&amp;gt;다. ELF 매직과 실행 파일 형식, 대상 아키텍처 등을 확인한 뒤 실제 ELF 로딩을 진행한다.&amp;lt;ref name=&amp;quot;elf&amp;quot;&amp;gt;Linux v6.12, [https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/binfmt_elf.c?h=v6.12 fs/binfmt_elf.c]. &amp;lt;code&amp;gt;load_elf_binary()&amp;lt;/code&amp;gt;와 ELF 핸들러 등록.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이렇게 공통 준비와 형식별 처리를 나누면 파일 열기와 인수 복사는 공통 경로가 맡고, 파일 구간별 메모리 배치는 해당 형식을 아는 로더가 맡을 수 있다. ELF 로더는 프로그램 헤더를 추가로 읽어 메모리에 배치할 구간을 알아낸다. 이 구간의 해석이 다음 절의 주제다.&lt;br /&gt;
&lt;br /&gt;
== 기존 주소 공간 해제와 이미지 교체 ==&lt;br /&gt;
지금까지는 기존 프로그램의 주소 공간을 유지하면서 파일을 열고, 인수를 복사하고, ELF 헤더를 검사했다. 준비 중 파일을 찾지 못하거나 형식을 처리할 수 없으면 기존 프로그램으로 돌아가 오류를 보고할 수 있다. 가능한 오류를 먼저 확인해야 실행할 수도 없는 파일 때문에 현재 프로그램을 잃지 않는다.&lt;br /&gt;
&lt;br /&gt;
ELF 로더가 교체를 진행하기로 하면 &amp;lt;code&amp;gt;begin_new_exec()&amp;lt;/code&amp;gt;를 호출한다. 이 함수 안에서 &amp;lt;code&amp;gt;point_of_no_return&amp;lt;/code&amp;gt;을 설정한 뒤 기존 실행 상태를 정리하고, &amp;lt;code&amp;gt;exec_mmap()&amp;lt;/code&amp;gt;으로 준비한 새 주소 공간을 현재 프로세스에 설치한다. 여러 스레드가 있었다면 이 과정에서 실행을 요청한 스레드만 남는다. 이후 ELF 로더가 새 주소 공간에 프로그램의 각 구간과 스택을 구성한다.&amp;lt;ref name=&amp;quot;exec&amp;quot; /&amp;gt;&amp;lt;ref name=&amp;quot;elf&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
old user image&lt;br /&gt;
  |&lt;br /&gt;
  | open file, copy inputs, inspect ELF&lt;br /&gt;
  | ordinary failure can return to old image&lt;br /&gt;
  v&lt;br /&gt;
begin_new_exec&lt;br /&gt;
  point_of_no_return&lt;br /&gt;
  clean up old execution state&lt;br /&gt;
  exec_mmap(new_mm)&lt;br /&gt;
  |&lt;br /&gt;
  v&lt;br /&gt;
new address space&lt;br /&gt;
  map ELF segments&lt;br /&gt;
  build initial stack&lt;br /&gt;
  set initial user registers&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
주소 공간 교체는 현재 프로세스가 사용할 가상 주소 공간과 매핑 관계를 새 것으로 바꾸는 작업이다. 파일 내용은 이후 매핑된 페이지에 접근할 때 필요에 따라 읽어 들일 수 있다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;point_of_no_return&amp;lt;/code&amp;gt;은 실제 주소 공간 교체보다 먼저 설정된다. 이미 다른 스레드와 실행 상태를 정리하기 시작했다면 단순히 이전 코드로 돌아갈 수 없기 때문이다. 이 경계를 넘은 뒤 로딩에 실패하면 커널은 기존 프로그램으로 정상 복귀하지 않고 프로세스를 종료시킨다.&amp;lt;ref name=&amp;quot;exec&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 새 프로그램의 시작 ==&lt;br /&gt;
&lt;br /&gt;
로딩이 끝나면 ELF 로더는 새 프로그램의 진입 주소와 초기 스택 주소를 사용자 레지스터 상태에 설정한다. 커널 내부 함수들은 반환할 수 있지만, 사용자 모드로 나갈 때 실행할 위치는 이미 바뀌었다. 사용자 모드에서는 새 프로그램의 시작 코드가 실행되므로, 성공한 &amp;lt;code&amp;gt;execve()&amp;lt;/code&amp;gt;는 이전 호출 지점으로 반환하지 않는다.&amp;lt;ref name=&amp;quot;elf&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이제 실행 파일은 열렸고 ELF 로더도 선택되었다. 다음 [[운영체제 기본/Linux/ELF 로딩/ELF 세그먼트와 주소 공간|ELF 세그먼트와 주소 공간]]에서는 로더가 프로그램 헤더를 읽어 코드와 데이터를 가상 주소 공간에 배치하는 방법을 살펴본다.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|목차=[[운영체제 기본/Linux/ELF 로딩|ELF 로딩 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/ELF 로딩/ELF 세그먼트와 주소 공간|ELF 세그먼트와 주소 공간]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%ED%8C%8C%EC%9D%BC%EC%8B%9C%EC%8A%A4%ED%85%9C/%ED%8E%98%EC%9D%B4%EC%A7%80_%EC%BA%90%EC%8B%9C&amp;diff=704</id>
		<title>운영체제 기본/Linux/파일시스템/페이지 캐시</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%ED%8C%8C%EC%9D%BC%EC%8B%9C%EC%8A%A4%ED%85%9C/%ED%8E%98%EC%9D%B4%EC%A7%80_%EC%BA%90%EC%8B%9C&amp;diff=704"/>
		<updated>2026-11-15T06:08:42Z</updated>

		<summary type="html">&lt;p&gt;관리자: 불필요한 볼드와 반복 대조 정리, 정확성 조건 유지&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=&amp;lt;- 이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/파일시스템/procfs의 파일 읽기|procfs의 파일 읽기]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/파일시스템|파일시스템 목차]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
기준은 Linux v6.12의 일반적인 버퍼드 읽기와 파일 기반 읽기 전용 매핑이다. [[운영체제 기본/Linux/파일 시스템 콜/read와 write|파일 읽기]]와 [[운영체제 기본/Linux/메모리 매핑/파일 매핑과 COW|파일 메모리 매핑]]은 사용자에게 데이터를 전달하는 방식이 다르지만, 파일 내용을 준비하는 과정에서는 같은 캐시를 이용할 수 있다. &amp;lt;code&amp;gt;O_DIRECT&amp;lt;/code&amp;gt;와 DAX처럼 이 경로를 우회하는 경우는 여기서 다루지 않는다.&amp;lt;ref name=&amp;quot;pc-overview&amp;quot;&amp;gt;[https://docs.kernel.org/6.12/mm/page_cache.html Linux 6.12 documentation, Page Cache].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 페이지 캐시의 역할과 비용 ==&lt;br /&gt;
저장장치의 파일을 읽을 때마다 같은 블록에 I/O를 요청하면 이미 읽었던 내용에도 다시 장치 접근 비용을 지불한다. 페이지 캐시는 파일 내용의 일부를 RAM에 보관하여 다음 접근에서 재사용하게 한다. 파일의 필요한 부분을 준비하고, 메모리가 부족하면 다시 확보할 수 있는 캐시를 회수한다.&lt;br /&gt;
&lt;br /&gt;
먼저 읽은 프로세스가 채운 내용을 나중에 다른 프로세스가 읽거나 mmap으로 접근할 때도 재사용할 수 있다. 파일시스템은 파일의 논리적 위치에 해당하는 내용을 제공하고, 공통 메모리 관리 코드는 그 내용을 캐시에 유지하고 찾는 역할을 맡는다.&amp;lt;ref name=&amp;quot;pc-filemap&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/mm/filemap.c?h=v6.12 Linux v6.12, mm/filemap.c], filemap_get_pages(), filemap_read(), filemap_fault(), filemap_map_pages().&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 파일 오프셋과 캐시 인덱스 ==&lt;br /&gt;
일반 파일의 &amp;lt;code&amp;gt;inode-&amp;gt;i_mapping&amp;lt;/code&amp;gt;은 &amp;lt;code&amp;gt;struct address_space&amp;lt;/code&amp;gt;를 가리킨다. 이 객체는 파일의 backing과 페이지 캐시를 관리한다. &amp;lt;code&amp;gt;host&amp;lt;/code&amp;gt;는 inode를, &amp;lt;code&amp;gt;i_pages&amp;lt;/code&amp;gt;는 인덱스로 캐시 항목을 찾는 XArray 자료구조를, &amp;lt;code&amp;gt;a_ops&amp;lt;/code&amp;gt;는 내용을 준비하는 파일시스템 연산표를 연결한다. 열린 파일에서도 &amp;lt;code&amp;gt;file-&amp;gt;f_mapping&amp;lt;/code&amp;gt;으로 이 객체에 접근한다.&amp;lt;ref name=&amp;quot;pc-fs-h&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/linux/fs.h?h=v6.12 Linux v6.12, include/linux/fs.h], struct address_space, struct address_space_operations, struct inode, struct file.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
캐시를 찾는 기준은 개념적으로 mapping과 파일 내부의 페이지 인덱스의 조합이다. 바이트 오프셋을 기본 페이지 크기로 나눈 값이 인덱스가 되고, 나머지는 그 페이지 안의 위치가 된다. 같은 파일 오프셋을 서로 다른 가상 주소에 mmap하더라도 이 캐시 식별 기준은 바뀌지 않는다. 반대로 다른 파일의 같은 오프셋은 mapping이 다르므로 같은 항목이 아니다.&lt;br /&gt;
&lt;br /&gt;
v6.12 코드에서는 캐시 관리 단위로 &amp;lt;code&amp;gt;folio&amp;lt;/code&amp;gt;가 자주 등장한다. folio는 하나 이상의 기본 페이지를 함께 관리하는 단위다. 인덱스의 단위는 기본 페이지다. 큰 folio는 여러 연속 인덱스를 포함할 수 있으며, 요청한 위치가 그 범위 안에 있는지 확인한다.&amp;lt;ref name=&amp;quot;pc-filemap&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== read의 복사와 mmap의 매핑 ==&lt;br /&gt;
buffered read 경로의 &amp;lt;code&amp;gt;filemap_read()&amp;lt;/code&amp;gt;는 먼저 요청 범위의 캐시 내용을 준비하고, &amp;lt;code&amp;gt;copy_folio_to_iter()&amp;lt;/code&amp;gt;로 필요한 바이트를 사용자 버퍼에 복사한다. 사용자 버퍼는 파일 캐시와 별개의 메모리다. 이 복사가 있기 때문에 프로그램은 일반적인 &amp;lt;code&amp;gt;read()&amp;lt;/code&amp;gt; 뒤에 자기 버퍼의 내용을 사용한다.&amp;lt;ref name=&amp;quot;pc-filemap&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
읽기 전용 mmap은 파일 내용에 접근할 가상 주소 범위를 마련한다. 아직 페이지 테이블 연결이 없는 주소에 접근하면 fault 처리가 필요하다. &amp;lt;code&amp;gt;filemap_fault()&amp;lt;/code&amp;gt;는 해당 파일 위치의 캐시 페이지를 확보하여 상위 fault 처리에 넘기고, 그 처리가 프로세스 페이지 테이블에 연결한다. &amp;lt;code&amp;gt;filemap_map_pages()&amp;lt;/code&amp;gt;는 이미 준비된 주변 캐시 페이지들도 함께 매핑하여 뒤이은 fault를 줄일 수 있다. 매핑이 갖춰진 뒤에는 페이지 테이블을 통해 파일 데이터에 접근한다.&amp;lt;ref name=&amp;quot;pc-filemap&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
                  파일의 address_space&lt;br /&gt;
                (mapping, 파일 페이지 인덱스)&lt;br /&gt;
                           |&lt;br /&gt;
                    페이지 캐시 folio&lt;br /&gt;
                     /           \&lt;br /&gt;
          filemap_read()        mmap fault 처리&lt;br /&gt;
               |               /            \&lt;br /&gt;
         바이트를 복사       프로세스 A PTE   프로세스 B PTE&lt;br /&gt;
               |               \            /&lt;br /&gt;
          사용자 버퍼          같은 캐시 페이지 참조&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
여러 프로세스가 같은 파일 내용을 매핑하면 파일 데이터 페이지를 공유할 수 있다. 가상 주소와 PTE는 프로세스마다 독립적이다. 따라서 다른 프로세스가 이미 파일을 읽어 두었어도 현재 프로세스에 PTE가 없다면 fault는 발생할 수 있다.&lt;br /&gt;
&lt;br /&gt;
== 캐시 항목과 데이터 준비 상태 ==&lt;br /&gt;
조회한 folio의 내용이 준비되어 있으면 요청 범위의 데이터를 바로 사용할 수 있다. 하지만 캐시에 항목이 있어도 다른 실행 흐름이 I/O를 진행 중일 수 있다. 커널은 folio의 잠금과 데이터 유효 상태를 확인하고, 필요한 경우 완료를 기다리거나 읽기를 수행한다.&amp;lt;ref name=&amp;quot;pc-filemap&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
캐시 miss라면 공간을 마련하고 파일시스템에 내용 준비를 요청한다. 순차 접근에서는 readahead로 앞으로 필요할 범위도 미리 준비하여 다음 요청이 기다릴 가능성을 줄인다. 따라서 한 번의 사용자 읽기가 한 번의 장치 요청과 일대일로 대응하지는 않는다. 준비 과정에 오류가 나면 정상 데이터로 취급하지 않으며, read는 이미 복사한 바이트가 있는지에 따라 부분 성공이나 오류를 반환하고, mmap fault의 읽기 실패는 SIGBUS로 이어질 수 있다.&amp;lt;ref name=&amp;quot;pc-filemap&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
캐시 miss를 처리할 때도 데이터 블록 읽기를 생략할 수 있다. 예를 들어 sparse 파일의 hole은 저장된 데이터 블록을 읽는 대신 해당 범위를 0으로 채워 제공할 수 있다. 이것을 알아내는 데 필요한 메타데이터 접근과 파일 데이터 블록 읽기는 구분해야 한다.&amp;lt;ref name=&amp;quot;pc-ext4-readpage&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/ext4/readpage.c?h=v6.12 Linux v6.12, fs/ext4/readpage.c], ext4_mpage_readpages(), hole 처리와 folio_zero_segment().&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 파일시스템의 데이터 적재 ==&lt;br /&gt;
공통 페이지 캐시 코드는 &amp;lt;code&amp;gt;mapping-&amp;gt;a_ops-&amp;gt;read_folio&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;readahead&amp;lt;/code&amp;gt; 같은 연산을 통해 파일시스템에 요청한다. ext4의 연산표는 이를 &amp;lt;code&amp;gt;ext4_read_folio()&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;ext4_readahead()&amp;lt;/code&amp;gt;에 연결하며, 일반적인 블록 저장 파일에서는 &amp;lt;code&amp;gt;ext4_mpage_readpages()&amp;lt;/code&amp;gt;로 이어진다. 파일 오프셋을 저장장치의 블록과 연결하는 구체적인 과정은 [[운영체제 기본/Linux/파일시스템/ext4의 파일 읽기#파일 논리 블록과 장치 블록의 매핑|ext4의 블록 매핑]]에서 다룬다.&amp;lt;ref name=&amp;quot;pc-ext4-inode&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/ext4/inode.c?h=v6.12 Linux v6.12, fs/ext4/inode.c], ext4_aops, ext4_read_folio(), ext4_readahead().&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
페이지 캐시의 변경 내용을 저장장치에 영속화하려면 쓰기 반영이 필요하다. 쓰기 완료와 &amp;lt;code&amp;gt;fsync()&amp;lt;/code&amp;gt;의 구분은 [[운영체제 기본/파일과 입출력]]을 참고한다.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=&amp;lt;- 이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/파일시스템/procfs의 파일 읽기|procfs의 파일 읽기]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/파일시스템|파일시스템 목차]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/%EB%8F%99%EC%8B%9C%EC%84%B1&amp;diff=703</id>
		<title>운영체제 기본/동시성</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/%EB%8F%99%EC%8B%9C%EC%84%B1&amp;diff=703"/>
		<updated>2026-11-15T06:08:37Z</updated>

		<summary type="html">&lt;p&gt;관리자: 과도한 강조와 반복 대조를 정리하고 동기화 규약 설명을 간결하게 수정&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/프로세스와 스레드|프로세스와 스레드]]&lt;br /&gt;
|목차=[[운영체제 기본#총론|총론 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/가상 메모리|가상 메모리]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
== 동시성과 병렬성 ==&lt;br /&gt;
동시성(Concurrency)은 여러 작업의 진행 기간이 겹치는 성질이다. 병렬성(Parallelism)은 여러 작업이 실제로 같은 순간에 실행되는 성질이다. CPU 코어가 하나여도 스케줄러가 작업을 번갈아 실행하면 동시성이 생긴다. 코어가 여러 개면 병렬 실행도 가능하지만, 코어 수가 동시성 문제의 유무를 결정하지는 않는다. 작업 하나가 공유 상태를 바꾸다 멈춘 사이 다른 작업이 그 상태에 접근하는 것만으로 문제가 생긴다.&lt;br /&gt;
&lt;br /&gt;
[[운영체제 기본/프로세스와 스레드|스레드]]가 주소 공간을 공유하면 데이터를 복사하거나 전달하는 비용을 줄일 수 있다. 대신 누가 언제 읽고 쓰는지 합의해야 한다. 서로 다른 프로세스도 [[운영체제 기본/프로세스 간 통신#공유 메모리와 동기화|공유 메모리]]를 사용하면 같은 문제를 만난다. 공유를 없애고 메시지로 소유권을 넘기면 조정 범위는 줄지만, 전달 비용과 대기열 관리가 생긴다. 공유 범위를 정할 때는 데이터 전달 비용과 동기화 비용을 함께 고려해야 한다.&lt;br /&gt;
&lt;br /&gt;
== 공유 상태의 불변식과 레이스 컨디션 ==&lt;br /&gt;
재고가 한 개 남았고 두 주문을 처리한다고 하자.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
남은_수량 = 재고_읽기()&lt;br /&gt;
if 남은_수량 &amp;gt; 0:&lt;br /&gt;
    재고_쓰기(남은_수량 - 1)&lt;br /&gt;
    주문_승인()&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
A가 1을 읽은 뒤 B도 1을 읽을 수 있다. 이어 A와 B가 각각 0을 쓰고 주문을 승인하면 최종 재고는 0인데 승인된 주문은 두 개다. 각 읽기와 쓰기가 따로는 정확해도 전체 연산은 잘못된다. 이처럼 작업 간 실행 순서에 따라 결과가 잘못되는 문제가 레이스 컨디션(Race Condition)이다. 단계가 서로 끼어드는 실행 순서를 인터리빙(Interleaving)이라고 한다. 한 코어에서 실행을 번갈아도 가능한 순서다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
time | A                  | B                  | stock / approved&lt;br /&gt;
-----+--------------------+--------------------+-----------------&lt;br /&gt;
1    | read -&amp;gt; 1          |                    | 1 / 0&lt;br /&gt;
2    |                    | read -&amp;gt; 1          | 1 / 0&lt;br /&gt;
3    | write 0            |                    | 0 / 0&lt;br /&gt;
4    | approve            |                    | 0 / 1&lt;br /&gt;
5    |                    | write 0            | 0 / 1&lt;br /&gt;
6    |                    | approve            | 0 / 2  ERROR&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
지켜야 할 불변식(Invariant)은 &#039;승인된 주문 수와 남은 재고의 합은 최초 재고와 같다&#039;는 관계다. 여기서는 취소와 입고가 없다고 가정한다. 재고 확인부터 차감과 승인 기록까지 다른 주문 처리와 겹치지 않게 묶어야 한다. 이렇게 보호해야 하는 구간이 임계 구역(Critical Section)이다. 모든 명령 사이에 불변식이 성립할 필요는 없지만, 다른 작업에 상태를 넘겨주는 경계에서는 복구되어 있어야 한다.&lt;br /&gt;
&lt;br /&gt;
== 뮤텍스와 임계 구역 ==&lt;br /&gt;
재고 확인부터 주문 승인까지 하나의 작업으로 묶으려면, 다른 스레드가 그 구간에 동시에 들어오지 못하게 해야 한다. 상호 배제 (Mutual Exclusion)는 한 번에 하나의 스레드만 임계 구역을 실행하게 하는 성질이다. 이를 제공하는 락(Lock)의 한 종류가 뮤텍스 (Mutex)다. 뮤텍스는 잠겨 있지 않거나, 어떤 스레드가 획득해 소유하고 있는 상태다. 스레드는 들어가기 전에 뮤텍스를 획득하고, 작업을 끝내면 자신이 소유한 뮤텍스를 해제한다. 다른 스레드가 이미 소유하고 있다면 기다려야 한다.&amp;lt;ref name=&amp;quot;mutex-ownership&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man3/pthread_mutex_lock.3p.html POSIX pthread_mutex_lock()], 획득한 스레드의 소유권과 해제 규칙.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
lock(재고_뮤텍스)&lt;br /&gt;
if 재고 &amp;gt; 0:&lt;br /&gt;
    재고 = 재고 - 1&lt;br /&gt;
    주문_승인()&lt;br /&gt;
unlock(재고_뮤텍스)&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
A가 뮤텍스를 가진 동안 B는 같은 뮤텍스를 획득하지 못하므로, A의 재고 확인과 차감 사이에 B가 끼어들지 못한다. A가 해제한 뒤 B가 들어오면 이미 줄어든 재고를 확인한다. 다만 재고를 다루는 모든 경로가 같은 규칙을 따라야 한다. 락을 거치지 않고 접근하는 코드는 데이터를 훼손할 수 있다.&lt;br /&gt;
&lt;br /&gt;
뮤텍스의 소유자는 임계 구역을 빠져나오며 직접 해제해야 한다. 구현은 원자 연산과 운영체제의 대기 처리를 조합하며, 경합 없는 획득은 사용자 공간에서 처리할 수 있다.&amp;lt;ref name=&amp;quot;mutex-futex&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man7/futex.7.html Linux man-pages: futex(7)], 사용자 공간의 빠른 경로와 커널 대기 지원.&amp;lt;/ref&amp;gt; 구간을 크게 묶으면 규칙은 단순해지는 대신 동시에 진행할 수 있는 작업이 줄어든다.&lt;br /&gt;
&lt;br /&gt;
== 세마포어와 자원 수량 ==&lt;br /&gt;
사용 가능한 작업 버퍼가 세 개라면 한 번에 하나만 허용하는 뮤텍스로 버퍼 사용 전체를 감쌀 필요는 없다. 서로 다른 버퍼를 쓰는 세 작업은 함께 진행할 수 있어야 한다. 세마포어 (Semaphore)는 사용할 수 있는 자원이나 누적된 통지의 수를 정수로 나타내고, 그 수를 소비하거나 추가하면서 실행을 조정하는 도구다. 0 이상의 값을 가지는 카운팅 세마포어(Counting Semaphore)는 여러 개의 사용권을 표현한다.&amp;lt;ref name=&amp;quot;sem-definition&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man7/sem_overview.7.html Linux man-pages: sem_overview(7)], 세마포어의 값과 두 기본 연산.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
기본 연산은 wait와 post다. wait는 값이 양수일 때 확인과 감소를 원자적으로 수행하고 사용권 하나를 얻는다. 값이 0이면 사용권이 생길 때까지 기다린다. post는 값을 하나 늘려 사용권을 추가하며, 기다리는 작업이 있으면 진행할 기회를 준다. 서로 다른 두 작업이 마지막 사용권 하나를 동시에 가져가서는 안 되므로, 단순한 일반 변수의 확인과 감소를 따로 실행해서는 구현할 수 없다.&amp;lt;ref name=&amp;quot;sem-wait&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man3/sem_wait.3.html Linux man-pages: sem_wait(3)].&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;sem-post&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man3/sem_post.3.html Linux man-pages: sem_post(3)].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
초기 사용권: 3&lt;br /&gt;
A: wait -&amp;gt; 2, 버퍼 사용 시작&lt;br /&gt;
B: wait -&amp;gt; 1, 버퍼 사용 시작&lt;br /&gt;
C: wait -&amp;gt; 0, 버퍼 사용 시작&lt;br /&gt;
D: wait -&amp;gt; 대기&lt;br /&gt;
B: 버퍼 반환, post -&amp;gt; D가 사용권을 얻고 진행 가능&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
세마포어는 사용권의 수를 조정할 뿐, 어떤 버퍼를 누가 사용할지까지 정하지는 않는다. 빈 버퍼 목록을 여러 작업이 함께 수정한다면 그 목록에는 별도의 뮤텍스 같은 동기화가 필요하다. 사용권 하나를 얻고 버퍼를 사용한 뒤 하나를 돌려주는 규칙도 프로그램이 지켜야 한다. 반환을 빠뜨리면 사용할 수 있는 수가 계속 줄고, 중복 반환하면 실제 버퍼보다 많은 작업을 허용하게 된다.&lt;br /&gt;
&lt;br /&gt;
세마포어에는 뮤텍스와 같은 소유자 개념이 없다. 초기값을 0으로 두고 생산자가 작업을 완성할 때 post하면, 소비자는 wait로 완료된 작업 하나를 기다릴 수 있다. 통지가 먼저 도착하면 수량으로 남으므로 이후 wait가 이를 소비한다. 이 용도에서는 post한 작업과 wait하는 작업이 다른 것이 자연스럽다. 뮤텍스는 임계 구역의 배타적 소유를, 세마포어는 수량과 작업 사이의 순서를 표현한다.&lt;br /&gt;
&lt;br /&gt;
값을 0과 1로만 유지하는 이진 세마포어 (Binary Semaphore)도 상호 배제에 사용할 수 있지만, 소유권과 해제 규약까지 뮤텍스와 같아지지는 않는다. 무엇을 하나로 세는지, 언제 소비하고 돌려줄지를 일관되게 정해야 한다.&lt;br /&gt;
&lt;br /&gt;
== 대기열을 이용한 내부 구현 ==&lt;br /&gt;
뮤텍스와 세마포어의 상태도 여러 스레드가 함께 읽고 바꾼다. 따라서 내부의 소유자, 수량, 대기열을 갱신하는 짧은 구간에는 별도의 원자적 보호가 필요하다. 아래의 &amp;lt;code&amp;gt;guard&amp;lt;/code&amp;gt;는 CAS 같은 원자 연산으로 획득하는 짧은 스핀락이다. 사용자가 뮤텍스로 보호하는 긴 작업 동안에는 guard를 보유하지 않는다. guard의 원자적 획득과 메모리 순서는 뒤의 [[#원자 연산을 이용한 락 구현|원자 연산을 이용한 락 구현]]에서 설명한다.&lt;br /&gt;
&lt;br /&gt;
대기에는 대기열에 자신을 등록하는 일과 CPU를 놓고 잠드는 일을 연결하는 규약이 필요하다. 등록 후 guard를 먼저 풀고 나중에 아무 조건 없이 잠들면, 그 사이 다른 스레드가 보낸 깨우기를 놓칠 수 있다. 여기서 &amp;lt;code&amp;gt;park_and_unlock(guard)&amp;lt;/code&amp;gt;는 guard를 보유한 상태에서 대기를 확정하고 guard를 해제하는 일을 깨우기와 조정한다. 상대가 guard를 얻은 뒤 &amp;lt;code&amp;gt;wake&amp;lt;/code&amp;gt;를 실행했다면, 대기자는 그 통지를 잃고 뒤늦게 잠들지 않는다. &amp;lt;code&amp;gt;wake&amp;lt;/code&amp;gt;는 대기자를 실행 가능하게 만들고 스케줄러가 실행 시점을 정한다. 이 대기 연산은 해당 스레드에게 소유권이나 사용권이 전달되었을 때 복귀하며, 깨우기 이전의 상태 변경을 복귀한 스레드가 관찰할 수 있도록 메모리 순서도 연결한다.&amp;lt;ref name=&amp;quot;wait-implementation&amp;quot;&amp;gt;[https://mit-pdos.github.io/xv6-riscv-book/sleep.html MIT xv6: Sleep and Wakeup], Sleep and wakeup의 lost wakeup 방지와 락 규약.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== 뮤텍스의 소유권 전달 ===&lt;br /&gt;
뮤텍스는 소유자 &amp;lt;code&amp;gt;owner&amp;lt;/code&amp;gt;와 대기열 &amp;lt;code&amp;gt;waiters&amp;lt;/code&amp;gt;를 가진다. 비어 있을 때 획득한 스레드는 자신을 소유자로 기록한다. 이미 사용 중이면 대기열에 들어가 잠든다. 해제할 때 대기자가 있으면 소유권을 그 스레드에게 직접 넘기고 깨운다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
Mutex:&lt;br /&gt;
    owner = 없음&lt;br /&gt;
    waiters = 빈 대기열&lt;br /&gt;
    guard = 스핀락&lt;br /&gt;
&lt;br /&gt;
mutex_lock(m):&lt;br /&gt;
    lock(m.guard)&lt;br /&gt;
    if m.owner == 없음:&lt;br /&gt;
        m.owner = 현재_스레드&lt;br /&gt;
        unlock(m.guard)&lt;br /&gt;
        return&lt;br /&gt;
&lt;br /&gt;
    m.waiters.push_back(현재_스레드)&lt;br /&gt;
    park_and_unlock(m.guard)&lt;br /&gt;
    // 깨어났다면 해제자가 소유권을 이미 넘겼다.&lt;br /&gt;
&lt;br /&gt;
mutex_unlock(m):&lt;br /&gt;
    lock(m.guard)&lt;br /&gt;
    if m.owner != 현재_스레드:&lt;br /&gt;
        unlock(m.guard)&lt;br /&gt;
        잘못된_해제_오류&lt;br /&gt;
        return&lt;br /&gt;
&lt;br /&gt;
    if m.waiters.empty():&lt;br /&gt;
        m.owner = 없음&lt;br /&gt;
    else:&lt;br /&gt;
        next = m.waiters.pop_front()&lt;br /&gt;
        m.owner = next&lt;br /&gt;
        wake(next)&lt;br /&gt;
    unlock(m.guard)&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
순서  A                         B                         owner / 대기열&lt;br /&gt;
 1    lock 성공                                           A / []&lt;br /&gt;
 2                              lock 시도 -&amp;gt; 대기          A / [B]&lt;br /&gt;
 3    unlock: 소유권을 B로                                 B / []&lt;br /&gt;
 4    wake(B)                   실행 가능                  B / []&lt;br /&gt;
 5                              스케줄러가 B 선택         B / []&lt;br /&gt;
 6                              lock에서 복귀, 작업       B / []&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
A가 해제하면서 B를 깨운 뒤에도 B가 바로 실행된다는 보장은 없다. 그러나 소유자는 이미 B로 기록되어 있으므로, 그 사이 들어온 C가 뮤텍스를 빼앗지 못한다. B는 실행 기회를 받으면 획득 호출에서 돌아와 임계 구역에 들어간다. 대기자가 없을 때만 owner를 비워 다음 호출자가 곧바로 획득하게 한다. 이 방식은 소유권 전달이 분명한 대신, 선택된 B가 실행될 때까지 다른 스레드가 기다릴 수 있다.&lt;br /&gt;
&lt;br /&gt;
=== 세마포어의 수량과 사용권 전달 ===&lt;br /&gt;
세마포어에는 소유자 대신 아직 예약되지 않은 사용권의 수인 &amp;lt;code&amp;gt;count&amp;lt;/code&amp;gt;가 있다. wait는 남은 사용권을 하나 소비하거나 대기열에 들어간다. post는 대기자가 없다면 count를 늘리고, 대기자가 있다면 새 사용권을 그 대기자에게 직접 넘긴다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
Semaphore(initial):&lt;br /&gt;
    count = initial&lt;br /&gt;
    waiters = 빈 대기열&lt;br /&gt;
    guard = 스핀락&lt;br /&gt;
&lt;br /&gt;
semaphore_wait(s):&lt;br /&gt;
    lock(s.guard)&lt;br /&gt;
    if s.count &amp;gt; 0:&lt;br /&gt;
        s.count = s.count - 1&lt;br /&gt;
        unlock(s.guard)&lt;br /&gt;
        return&lt;br /&gt;
&lt;br /&gt;
    s.waiters.push_back(현재_스레드)&lt;br /&gt;
    park_and_unlock(s.guard)&lt;br /&gt;
    // 깨어났다면 post가 사용권 하나를 이미 넘겼다.&lt;br /&gt;
&lt;br /&gt;
semaphore_post(s):&lt;br /&gt;
    lock(s.guard)&lt;br /&gt;
    if s.waiters.empty():&lt;br /&gt;
        s.count = s.count + 1&lt;br /&gt;
    else:&lt;br /&gt;
        next = s.waiters.pop_front()&lt;br /&gt;
        wake(next)  // 사용권 하나를 next에게 예약한다.&lt;br /&gt;
    unlock(s.guard)&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
순서  A                         B                         count / 대기열&lt;br /&gt;
초기                                                      1 / []&lt;br /&gt;
 1    wait: 사용권 획득                                    0 / []&lt;br /&gt;
 2                              wait -&amp;gt; 대기               0 / [B]&lt;br /&gt;
 3    post: B에 사용권 전달                                0 / []&lt;br /&gt;
 4    wake(B)                   실행 가능                  0 / []&lt;br /&gt;
 5                              실행 재개, 사용권 사용    0 / []&lt;br /&gt;
 6                              post: 사용권 반환         1 / []&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
대기자를 깨우는 분기에서는 count를 늘리지 않는다. 사용권을 대기자에게 넘긴 뒤에도 count를 올려 두면, 다른 스레드가 같은 사용권을 다시 가져갈 수 있기 때문이다. 대기자가 획득 호출에서 돌아올 때 count를 다시 줄이지 않는 이유도 같다. 이미 자신에게 예약된 사용권을 받은 것이다. 이 구현에서 count는 현재 누구에게도 예약되지 않은 사용권의 수다.&lt;br /&gt;
&lt;br /&gt;
뮤텍스와 세마포어 모두 원자 연산으로 내부 상태를 안전하게 바꾸고, 기다리는 실행 흐름을 운영체제의 대기, 깨우기와 연결한다. 하드웨어는 guard의 원자적 갱신을 지원하지만, 소유권, 수량의 의미와 대기열 관리, 다음 실행 대상의 선택은 소프트웨어가 구현한다.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== 락의 상호 배제와 메모리 순서 ==&lt;br /&gt;
락에는 메모리의 가시성과 순서를 연결하는 역할도 있다. 올바른 동기화 규약 아래에서 락을 해제하기 전의 변경은 같은 락을 이어서 획득한 작업에 전달된다. 단순히 실행 시간이 앞섰다는 사실만으로는 이런 관계가 생기지 않는다. 컴파일러와 하드웨어가 허용하는 재배치를 고려한 동기화가 필요하다. 서로 다른 스레드가 같은 메모리 위치에 접근하고 한쪽 이상이 쓰기일 때, 적어도 하나가 비원자적이며 동기화로 순서가 정해지지 않으면 데이터 레이스(Data Race)가 된다. C에서 데이터 레이스는 정의되지 않은 동작을 일으킨다. 반면 앞의 재고 예시처럼 개별 읽기와 쓰기를 원자적으로 만들더라도, 확인과 갱신을 따로 수행하면 전체 결과가 잘못될 수 있다. &amp;lt;ref name=&amp;quot;source-1&amp;quot;&amp;gt;[https://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf C11 위원회 초안 N1570, 5.1.2.4].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
원자 연산(Atomic Operation)인 증가나 비교 후 교환(CAS)은 하나의 연산이 중간에 쪼개져 관찰되는 문제를 해결한다. 그러나 재고 차감과 승인 기록을 각각 원자적으로 바꿔도 두 필드의 관계가 저절로 보호되지는 않는다. 원자성의 범위와 불변식의 범위가 다르기 때문이다. 여러 값을 하나의 상태로 묶거나 별도의 프로토콜을 설계할 수 있지만, 그 정확성과 실패 시 재시도 비용까지 부담해야 한다.&lt;br /&gt;
&lt;br /&gt;
== 원자 연산을 이용한 락 구현 ==&lt;br /&gt;
공유 RAM에 놓인 락 변수의 0을 비어 있음, 1을 사용 중이라고 하자. 이 변수는 원자 연산이 요구하는 크기와 정렬 조건을 만족해야 한다. CAS(Compare-and-Swap, 비교 후 교환)는 현재 값이 0일 때만 1로 바꾸는 일을 하나의 원자적 연산으로 수행하고, 성공 여부를 반환한다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
while not compare_exchange_acquire(&amp;amp;lock, 0, 1):&lt;br /&gt;
    재시도&lt;br /&gt;
재고 확인부터 차감과 승인까지 수행  // 임계 구역&lt;br /&gt;
store_release(&amp;amp;lock, 0)&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
time | A                        | B                       &lt;br /&gt;
-----+--------------------------+-------------------------&lt;br /&gt;
1    | CAS(0,1): success        |&lt;br /&gt;
2    |                          | CAS(0,1): fail&lt;br /&gt;
3    | stock=0; approve         | retry&lt;br /&gt;
4    | release: lock=0          |&lt;br /&gt;
5    |                          | CAS(0,1): success&lt;br /&gt;
6    |                          | stock=0; reject; unlock&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
* x86-64: 공유 메모리 대상의 &amp;lt;code&amp;gt;LOCK CMPXCHG&amp;lt;/code&amp;gt;로 CAS를 구현할 수 있다. &amp;lt;code&amp;gt;LOCK&amp;lt;/code&amp;gt; 접두사는 다중 프로세서에서 원자성을 보장한다.&amp;lt;ref name=&amp;quot;concurrency-intel-cmpxchg&amp;quot;&amp;gt;[https://cdrdv2.intel.com/v1/dl/getContent/671199 Intel SDM Volume 2A], &amp;quot;CMPXCHG: Compare and Exchange&amp;quot;.&amp;lt;/ref&amp;gt;&lt;br /&gt;
* RISC-V RV64: A 확장의 &amp;lt;code&amp;gt;LR/SC&amp;lt;/code&amp;gt;로 값을 읽어 비교한 뒤 조건부 저장하고, 저장 실패 시 재시도하여 CAS를 구성할 수 있다. &amp;lt;code&amp;gt;SC&amp;lt;/code&amp;gt;는 다른 작업의 값 변경이 없어도 실패할 수 있다. 다른 방법인 &amp;lt;code&amp;gt;AMOSWAP.W.AQ&amp;lt;/code&amp;gt;는 1을 무조건 교환하여 이전 값이 0인 작업만 진입시키는 test-and-set 방식이다.&amp;lt;ref name=&amp;quot;concurrency-riscv-a&amp;quot;&amp;gt;[https://docs.riscv.org/reference/isa/unpriv/a-st-ext.html RISC-V Unprivileged ISA, A Extension], LR/SC, AMO 및 상호 배제 예제.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
acquire/release는 앞 소유자의 변경을 다음 소유자가 관찰하도록 순서를 연결하며, 컴파일러와 하드웨어 양쪽에서 보장되어야 한다. RISC-V에서는 &amp;lt;code&amp;gt;aq&amp;lt;/code&amp;gt;/&amp;lt;code&amp;gt;rl&amp;lt;/code&amp;gt; 또는 필요한 &amp;lt;code&amp;gt;FENCE&amp;lt;/code&amp;gt;로 순서를 구현한다.&amp;lt;ref name=&amp;quot;concurrency-riscv-a&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이 스핀락(Spinlock)은 대기 중에도 CPU를 쓰고, 반복적인 원자적 갱신은 캐시 일관성 트래픽을 늘릴 수 있으며, 획득 순서의 공정성을 보장하지 않는다. 이 비용은 아래의 [[#대기 방식과 비용|대기 방식]]과 [[#데드락(Deadlock)|진행 보장]] 문제로 이어진다.&lt;br /&gt;
&lt;br /&gt;
== 대기 방식과 비용 ==&lt;br /&gt;
스핀락도 상호 배제를 위한 락이지만 기다리는 동안 CPU에서 획득을 반복 시도한다. 뮤텍스, 세마포어가 무엇을 조정하는지와, 구현이 스핀하거나 대기 스레드를 재우는지는 구별해야 한다.&lt;br /&gt;
&lt;br /&gt;
락을 얻지 못했을 때 스핀 방식은 실행을 계속하며 획득 가능 여부를 확인한다. 아주 짧은 기다림이라면 잠들고 다시 실행되는 비용을 피할 수 있다. 반면 대기가 길면 유용한 일을 하지 못하면서 CPU 시간과 전력을 소비한다. 락 소유자가 실행되지 못하는 상황에서는 기다리는 쪽이 바쁘게 실행되어도 해제 시점을 앞당기지 못한다. &amp;lt;ref name=&amp;quot;source-2&amp;quot;&amp;gt;[https://docs.oracle.com/cd/E19253-01/816-5137/ggecq/index.html Oracle: Using Spin Locks].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
블로킹(Blocking) 방식은 기다리는 작업을 재우고 CPU를 다른 작업에 내준다. 대신 대기 등록, 깨우기, 다시 스케줄되는 과정이 필요하다. 선택할 때는 예상 대기 시간과 실행 여건을 비교해야 한다. 실제 뮤텍스는 짧게 스핀한 뒤 블로킹하는 전략을 섞을 수도 있다.&lt;br /&gt;
&lt;br /&gt;
락 하나로 큰 구조를 보호하면 규칙이 단순하지만 서로 무관한 작업도 줄을 선다. 락을 세분화하면 병렬 처리 여지는 커지지만 획득 횟수와 관리할 관계도 늘어난다. 임계 구역 안에 오래 걸리는 작업을 넣으면 대기가 늘고, 밖으로 옮기면 그 사이 상태가 바뀌지 않는지 다시 확인해야 한다. 락 범위를 줄이는 최적화는 불변식의 보호 범위를 보존할 때만 의미가 있다.&lt;br /&gt;
&lt;br /&gt;
== 데드락(Deadlock) ==&lt;br /&gt;
&lt;br /&gt;
데드락은 작업들이 서로가 제공해야 할 자원이나 사건을 기다려 더 이상 진행하지 못하는 상태다. 여기서는 스레드가 뮤텍스를 보유한 채 다른 뮤텍스를 기다리는 경우를 살펴본다. 락으로 임계 구역을 보호해 데이터 레이스를 없앴더라도, 락을 획득하는 순서가 잘못되면 데드락이 생길 수 있다. 즉, 공유 데이터의 안전성과 작업의 진행 가능성은 따로 확인해야 한다.&lt;br /&gt;
&lt;br /&gt;
=== 두 스레드와 두 뮤텍스 ===&lt;br /&gt;
&lt;br /&gt;
재고를 보호하는 &amp;lt;code&amp;gt;inventory_lock&amp;lt;/code&amp;gt;과 주문을 보호하는 &amp;lt;code&amp;gt;order_lock&amp;lt;/code&amp;gt;이 있다고 하자. 스레드 A는 재고 락부터, 스레드 B는 주문 락부터 획득하며, 둘 다 두 락을 확보한 다음 처리하고 해제한다. 다음은 데드락이 발생하는 실행 순서다.&amp;lt;ref name=&amp;quot;oracle-lock-hierarchy&amp;quot;&amp;gt;Oracle, [https://docs.oracle.com/cd/E19120-01/open.solaris/816-5137/6mba5vq13/index.html Examples of Using Lock Hierarchies], &#039;&#039;Multithreaded Programming Guide&#039;&#039;.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
Time   Thread A                       Thread B&lt;br /&gt;
 t1    acquire(inventory_lock)&lt;br /&gt;
 t2                                   acquire(order_lock)&lt;br /&gt;
 t3    acquire(order_lock) -&amp;gt; WAIT&lt;br /&gt;
 t4                                   acquire(inventory_lock) -&amp;gt; WAIT&lt;br /&gt;
 t5    cannot reach unlock            cannot reach unlock&lt;br /&gt;
&lt;br /&gt;
Wait-for graph:&lt;br /&gt;
       waits for order_lock&lt;br /&gt;
  A ----------------------------&amp;gt; B&lt;br /&gt;
  ^                               |&lt;br /&gt;
  |_______________________________|&lt;br /&gt;
       waits for inventory_lock&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
화살표는 기다리는 스레드에서 필요한 락의 소유자로 향한다. A가 진행하려면 B가 주문 락을 해제해야 하지만, B도 A가 재고 락을 해제해야 진행할 수 있다. 두 스레드 모두 해제 코드에 도달하지 못한다. 다른 순서로 실행하면 문제가 드러나지 않을 수 있지만, 한 번 이 상태가 되면 단순히 오래 기다리거나 CPU 실행 순서를 바꾸는 것으로 풀리지 않는다. 스케줄러는 CPU를 배분할 뿐, 보유 중인 뮤텍스를 안전하게 대신 해제해 주지 않는다. 일반적인 블로킹 뮤텍스 획득은 다른 소유자가 락을 해제할 때까지 기다린다.&amp;lt;ref name=&amp;quot;oracle-mutex&amp;quot;&amp;gt;Oracle, [https://docs.oracle.com/cd/E19253-01/816-5137/sync-110/index.html Using Mutual Exclusion Locks], &#039;&#039;Multithreaded Programming Guide&#039;&#039;.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== 데드락의 네 가지 필요조건 ===&lt;br /&gt;
&lt;br /&gt;
자원을 획득하고 반납하는 모델에서 데드락이 발생하려면 다음 네 조건이 함께 성립해야 한다. 이를 코프먼 조건(Coffman Conditions)이라고 한다.&amp;lt;ref name=&amp;quot;illinois-deadlock&amp;quot;&amp;gt;University of Illinois, [https://cs341.cs.illinois.edu/coursebook/Deadlock Deadlock], CS 341 Coursebook, &amp;quot;Resource Allocation Graphs&amp;quot;, &amp;quot;Coffman Conditions&amp;quot;.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
# 상호 배제(Mutual Exclusion): 해당 자원을 한 번에 하나의 작업만 사용할 수 있다. 예제의 각 뮤텍스는 소유자가 하나다.&lt;br /&gt;
# 점유 대기(Hold and Wait): 자원을 이미 보유한 상태로 다른 자원을 기다린다. A와 B 모두 첫 번째 락을 놓지 않고 두 번째 락을 기다린다.&lt;br /&gt;
# 비선점(No Preemption): 다른 작업이 보유한 자원을 강제로 회수하지 못한다. 여기서 비선점은 뮤텍스 등 보유 자원의 강제 회수를 금지한다는 뜻이다.&lt;br /&gt;
# 순환 대기(Circular Wait): 각 작업이 다음 작업이 보유한 자원을 기다리고, 그 연결이 다시 처음으로 돌아온다. 예제에서는 A -&amp;gt; B -&amp;gt; A다.&lt;br /&gt;
&lt;br /&gt;
어느 하나라도 성립하지 않도록 설계하면 이 모델의 데드락을 예방할 수 있다. 위 예제처럼 각 자원이 하나뿐인 뮤텍스 모델에서 실제 대기 고리가 생기면 데드락이다. &amp;lt;ref name=&amp;quot;illinois-deadlock&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== 예방과 다른 진행 실패의 구별 ===&lt;br /&gt;
&lt;br /&gt;
가장 직접적인 예방책은 락 획득 순서를 통일하는 것이다. 모든 경로에서 재고 락 다음 주문 락을 획득하게 하면, 주문 락을 보유한 채 재고 락을 기다리는 역방향 연결이 생기지 않아 순환 대기가 끊어진다. 락이 늘어나면 전체 순서를 정하고 중첩 획득 때 이를 지킨다. 보유한 락보다 뒤 순서의 락만 요청하게 하면 처음 락으로 되돌아오는 요청 고리를 만들 수 없다. 일부 함수만 순서를 지켜서는 부족하며, 호출되는 함수가 내부에서 획득하는 락도 포함해야 한다.&amp;lt;ref name=&amp;quot;oracle-lock-hierarchy&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
순서를 지키기 어려운 경우에는 두 번째 락을 &amp;lt;code&amp;gt;try_lock&amp;lt;/code&amp;gt;으로 시도하고, 실패하면 이미 획득한 락을 해제한 뒤 다시 시도할 수 있다. 재시도 과정에서는 부분적으로 수행한 작업을 안전하게 취소하거나 상태를 다시 검사해야 하며, 반복 획득과 해제에도 비용이 든다.&amp;lt;ref name=&amp;quot;oracle-lock-hierarchy&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
서로 양보하고 다시 시도하는 동작만 반복해 작업을 끝내지 못하면 라이브락(Livelock)이다. 다른 스레드들은 진행하지만 특정 스레드만 계속 자원을 얻지 못하면 기아(Starvation)다. 데드락은 대기 의존성이 풀리지 않는 문제, 라이브락은 동작은 계속하지만 유효한 진전이 없는 문제, 기아는 특정 작업의 진전이 계속 배제되는 문제라는 차이가 있다.&amp;lt;ref name=&amp;quot;oracle-starvelive&amp;quot;&amp;gt;Oracle, [https://docs.oracle.com/javase/tutorial/essential/concurrency/starvelive.html Starvation and Livelock], &#039;&#039;The Java Tutorials&#039;&#039;.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 조건 변수와 상태 변화 대기 ==&lt;br /&gt;
재고가 들어올 때까지 기다리는 주문은 또 다른 문제다. 락을 잡은 채 기다리면 입고 작업도 재고를 바꾸지 못한다. 조건 변수(Condition Variable)는 락 해제와 대기 진입을 연결하고, 깨어난 뒤 락을 다시 획득하도록 한다. 조건을 확인한 직후 입고 알림이 지나가고 그다음 잠드는 &#039;놓친 깨우기&#039;를 피하려면, 조건 확인과 상태 변경도 같은 뮤텍스 규약으로 묶어야 한다.&lt;br /&gt;
&lt;br /&gt;
세마포어는 사용권이나 통지의 수를 저장하지만, 조건 변수의 알림은 나중을 위해 누적되지 않는다. 조건 변수와 함께 쓰는 실제 조건은 재고 수처럼 뮤텍스로 보호하는 별도의 상태에 있으며, 깨어난 작업은 이를 다시 검사한다.&amp;lt;ref name=&amp;quot;cond-notification&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man3/pthread_cond_broadcast.3p.html POSIX pthread_cond_broadcast()], 대기자가 없을 때의 알림.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
대기 코드는 &#039;재고가 없는 동안 기다린다&#039;라는 while 구조여야 한다. 깨어나도 다른 주문이 재고를 먼저 가져갈 수 있고, 알림 없이 깨어나는 스퓨리어스 웨이크업(Spurious Wakeup)도 가능하다. 알림을 받은 작업은 조건을 다시 검사한다. &amp;lt;ref name=&amp;quot;source-4&amp;quot;&amp;gt;[https://docs.oracle.com/cd/E88353_01/html/E37843/pthread-cond-wait-3c.html Oracle: pthread_cond_wait].&amp;lt;/ref&amp;gt;&lt;br /&gt;
== 읽기 중심의 동기화와 RCU ==&lt;br /&gt;
읽기는 매우 잦지만 갱신은 드문 자료구조에서는 독자가 매번 같은 락을 다투는 비용도 커질 수 있다. Linux에서 사용하는 RCU(Read-Copy Update)는 읽기 쪽의 부담을 줄이기 위한 동기화 방식이다. 갱신자는 새 상태를 공개하거나 이전 객체를 자료구조에서 떼어 낼 수 있지만, 이미 그 객체를 보고 있던 독자가 남아 있다면 바로 메모리를 해제해서는 안 된다. RCU는 자료구조의 변경과 이전 객체의 메모리 회수 시점을 분리하여 이 수명 문제를 다룬다.&amp;lt;ref name=&amp;quot;rcu-overview&amp;quot;&amp;gt;[https://docs.kernel.org/RCU/whatisRCU.html Linux kernel documentation: What is RCU?], 제거와 회수의 분리.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
갱신자 사이의 충돌, 독자가 관찰할 수 있는 상태, 객체를 참조해도 되는 기간에는 별도의 규칙이 필요하다. 구체적인 읽기 구간과 공개, 회수 절차는 [[운영체제 기본/Linux/RCU|Linux의 RCU]] 각론에서 다룬다.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/프로세스와 스레드|프로세스와 스레드]]&lt;br /&gt;
|목차=[[운영체제 기본#총론|총론 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/가상 메모리|가상 메모리]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%EB%A9%94%EB%AA%A8%EB%A6%AC_%EB%A7%A4%ED%95%91/MMIO_%EC%9E%A5%EC%B9%98_%EB%A7%A4%ED%95%91&amp;diff=702</id>
		<title>운영체제 기본/Linux/메모리 매핑/MMIO 장치 매핑</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%EB%A9%94%EB%AA%A8%EB%A6%AC_%EB%A7%A4%ED%95%91/MMIO_%EC%9E%A5%EC%B9%98_%EB%A7%A4%ED%95%91&amp;diff=702"/>
		<updated>2026-11-15T06:08:37Z</updated>

		<summary type="html">&lt;p&gt;관리자: 문체 정리: 과도한 강조와 대조, 비표준 문자 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br&amp;gt;[[운영체제 기본/Linux/메모리 매핑/파일 매핑과 COW|파일 매핑과 COW]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/메모리 매핑|메모리 매핑 목차]]&lt;br /&gt;
|다음=마지막 문서&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
메모리 매핑 입출력(Memory-Mapped I/O, MMIO)은 CPU의 주소 공간에 장치 레지스터나 장치 메모리를 배치하고 load/store로 접근하는 방식이다. 장치 드라이버는 허용한 MMIO 구간을 사용자 프로세스에 &amp;lt;code&amp;gt;mmap()&amp;lt;/code&amp;gt;으로 공개할 수 있다. 페이지 테이블은 사용자 주소를 장치 레지스터나 장치 메모리의 물리 주소로 변환한다.&lt;br /&gt;
&lt;br /&gt;
Linux v6.12의 UIO(Userspace I/O)에서 &amp;lt;code&amp;gt;UIO_MEM_PHYS&amp;lt;/code&amp;gt;로 MMIO 자원을 공개하는 기본 경로를 예로 든다. 여기서는 &amp;lt;code&amp;gt;MAP_SHARED&amp;lt;/code&amp;gt;로 장치 자원을 직접 접근하는 경우를 다룬다. 장치 파일의 매핑은 드라이버마다 다르며, 모든 &amp;lt;code&amp;gt;/dev&amp;lt;/code&amp;gt; 파일의 매핑이 MMIO인 것은 아니다.&lt;br /&gt;
&lt;br /&gt;
== 사용자 주소와 장치 주소 ==&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
사용자 프로세스의 가상 주소&lt;br /&gt;
  -&amp;gt; 사용자 페이지 테이블&lt;br /&gt;
  -&amp;gt; 드라이버가 허용한 장치 물리 주소&lt;br /&gt;
  -&amp;gt; 버스와 장치의 레지스터 또는 메모리&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
CPU가 값을 읽거나 쓰는 형식은 메모리 접근이지만, 장치에서는 읽기가 상태를 지우거나 쓰기가 동작을 시작할 수도 있다. 따라서 RAM에 데이터를 저장하는 것처럼 무조건 복사하거나, 임의의 폭으로 접근할 수 없다. 장치가 정한 레지스터 폭, 정렬, 엔디언과 읽기 및 쓰기 순서를 따라야 한다. 기본 개념은 [[운영체제 기본/장치 제어와 입출력|장치 제어와 입출력]]과 연결된다.&lt;br /&gt;
&lt;br /&gt;
드라이버가 내부적으로 사용하는 &amp;lt;code&amp;gt;ioremap()&amp;lt;/code&amp;gt;과도 구별한다. &amp;lt;code&amp;gt;ioremap()&amp;lt;/code&amp;gt;은 커널에서 사용할 I/O 주소 매핑을 만드는 인터페이스이고, 여기서는 사용자 프로세스의 VMA와 페이지 테이블을 설정하는 &amp;lt;code&amp;gt;mmap()&amp;lt;/code&amp;gt; 콜백을 다룬다.&amp;lt;ref name=&amp;quot;iomap&amp;quot;&amp;gt;[https://docs.kernel.org/driver-api/device-io.html Linux Kernel Documentation, Bus-Independent Device Accesses], ioremap과 I/O 접근 규칙.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== UIO의 매핑 선택과 범위 검사 ==&lt;br /&gt;
UIO 장치는 &amp;lt;code&amp;gt;/dev/uio0&amp;lt;/code&amp;gt; 같은 장치 파일을 제공한다. 한 장치에 여러 매핑 영역이 있으면, UIO의 &amp;lt;code&amp;gt;mmap()&amp;lt;/code&amp;gt; 오프셋은 &amp;lt;code&amp;gt;영역 번호 * 페이지 크기&amp;lt;/code&amp;gt;다. 예를 들어 영역 0은 오프셋 0, 영역 1은 오프셋 한 페이지를 사용한다. UIO는 이 오프셋으로 등록된 영역을 선택한다.&amp;lt;ref name=&amp;quot;uio-doc&amp;quot;&amp;gt;[https://docs.kernel.org/driver-api/uio-howto.html Linux Kernel Documentation, The Userspace I/O HOWTO], UIO의 mmap과 map 영역 선택.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
mmap(장치 fd, offset = map 번호 * PAGE_SIZE)&lt;br /&gt;
  -&amp;gt; 공통 mmap 설정&lt;br /&gt;
  -&amp;gt; file-&amp;amp;gt;f_op-&amp;amp;gt;mmap = uio_mmap&lt;br /&gt;
  -&amp;gt; vm_pgoff로 등록된 map 선택&lt;br /&gt;
  -&amp;gt; 영역 크기와 요청 범위 검사&lt;br /&gt;
  -&amp;gt; UIO_MEM_PHYS -&amp;gt; uio_mmap_physical&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;uio_mmap()&amp;lt;/code&amp;gt;은 등록된 영역 번호가 유효한지와 요청한 페이지 수를 검사한다. 드라이버가 자체 &amp;lt;code&amp;gt;info-&amp;amp;gt;mmap&amp;lt;/code&amp;gt; 콜백을 제공하면 그쪽으로 넘기고, 그렇지 않으면 등록된 메모리 유형에 따라 처리한다. 여기서 따라가는 기본 물리 매핑은 &amp;lt;code&amp;gt;uio_mmap_physical()&amp;lt;/code&amp;gt;이다.&amp;lt;ref name=&amp;quot;uio&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/uio/uio.c?h=v6.12 Linux v6.12, drivers/uio/uio.c], uio_mmap, uio_find_mem_index, uio_mmap_physical.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이 함수는 물리 시작 주소의 페이지 정렬과 요청 길이를 다시 검사한다. 매핑은 커널 드라이버가 등록한 자원 안에서만 구성된다. 장치 파일 접근 권한과 드라이버의 범위 검사가 사용자 프로세스에 공개되는 범위를 제한한다.&amp;lt;ref name=&amp;quot;uio&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== PFN 매핑과 PTE 설치 ==&lt;br /&gt;
물리 페이지 프레임 번호(PFN, Page Frame Number)는 물리 주소에서 페이지 내부 오프셋을 제외한 번호다. UIO 기본 물리 매핑은 등록된 물리 시작 주소를 &amp;lt;code&amp;gt;PAGE_SHIFT&amp;lt;/code&amp;gt;만큼 이동해 시작 PFN을 구하고, &amp;lt;code&amp;gt;remap_pfn_range()&amp;lt;/code&amp;gt;에 사용자 주소, 크기, 페이지 속성과 함께 넘긴다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
uio_mmap_physical&lt;br /&gt;
  -&amp;gt; vm_page_prot = pgprot_noncached(vm_page_prot)&lt;br /&gt;
  -&amp;gt; remap_pfn_range(vma, vm_start, 물리 시작 PFN, 길이, vm_page_prot)&lt;br /&gt;
  -&amp;gt; 사용자 PTE를 장치 PFN에 연결&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;remap_pfn_range()&amp;lt;/code&amp;gt;의 내부 경로는 VMA에 &amp;lt;code&amp;gt;VM_IO&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;VM_PFNMAP&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;VM_DONTEXPAND&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;VM_DONTDUMP&amp;lt;/code&amp;gt;를 설정하고 PFN을 가리키는 특수 PTE를 설치한다. 일반 RAM 페이지의 &amp;lt;code&amp;gt;struct page&amp;lt;/code&amp;gt;를 페이지 캐시에서 가져오는 경로와 구분되며, 이 예에서는 매핑을 만드는 중에 PTE가 설치된다.&amp;lt;ref name=&amp;quot;uio&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;remap&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/mm/memory.c?h=v6.12 Linux v6.12, mm/memory.c], remap_pfn_range, remap_pfn_range_internal, remap_pte_range.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
일반 파일의 private COW처럼 장치 레지스터의 사본을 RAM에 만들어 쓰게 하면 장치에 명령이 전달되지 않는다. MMIO 매핑은 드라이버가 허용하는 공유 방식과 접근 규약에 맞춰 사용해야 한다. 파일 장에서 설명한 private 사본, page cache, writeback 모델을 MMIO에 그대로 적용하지 않는다.&lt;br /&gt;
&lt;br /&gt;
== 아키텍처별 메모리 속성 ==&lt;br /&gt;
MMIO의 페이지 테이블에는 읽기 및 쓰기 권한뿐 아니라 적절한 메모리 속성도 필요하다. 장치 레지스터를 일반 RAM처럼 캐시하면 실제 장치 접근과 다른 결과를 만들 수 있다. UIO의 기본 &amp;lt;code&amp;gt;UIO_MEM_PHYS&amp;lt;/code&amp;gt; 경로는 &amp;lt;code&amp;gt;pgprot_noncached()&amp;lt;/code&amp;gt;를 사용하지만, 이 함수의 하드웨어 표현은 아키텍처에 따라 다르다.&lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
! 아키텍처 !! Linux v6.12의 처리&lt;br /&gt;
|-&lt;br /&gt;
| x86-64 || pgprot_noncached()가 UC-에 해당하는 캐시 속성을 적용한다. PFN 매핑 과정에서 기존 메모리 유형과의 호환성도 검토한다.&lt;br /&gt;
|-&lt;br /&gt;
| RISC-V RV64 || pgprot_noncached()가 I/O용 속성을 선택한다. Svpbmt를 사용하는 경우 PTE의 PBMT 필드로 I/O 유형을 표현하며, 실제 사용 가능한 표현은 CPU 확장과 플랫폼에 달려 있다.&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
x86-64의 캐시 속성 비트를 RISC-V에 그대로 옮길 수 없으며, 모든 RV64 시스템에서 Svpbmt를 사용하는 것도 아니다. 공통 드라이버는 아키텍처 도우미를 호출하고, 하드웨어와 플랫폼에 맞는 속성 처리는 그 아래에서 맡는다.&amp;lt;ref name=&amp;quot;x86-prot&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/include/asm/pgtable.h?h=v6.12 Linux v6.12, arch/x86/include/asm/pgtable.h], pgprot_noncached.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;rv-prot&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/riscv/include/asm/pgtable.h?h=v6.12 Linux v6.12, arch/riscv/include/asm/pgtable.h], pgprot_noncached.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;rv-pbmt&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/riscv/include/asm/pgtable-64.h?h=v6.12 Linux v6.12, arch/riscv/include/asm/pgtable-64.h], PBMT와 대안 선택.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
캐시 속성만으로 장치 접근 순서와 완료 조건까지 모두 해결되지는 않는다. &amp;lt;code&amp;gt;volatile&amp;lt;/code&amp;gt;도 컴파일러의 접근 처리에 관여할 뿐, 장치에 필요한 메모리 장벽이나 접근 완료 확인을 모두 대신하지 않는다. 실제 접근은 장치와 플랫폼의 사용자 공간 인터페이스가 정한 규칙을 따라야 한다.&amp;lt;ref name=&amp;quot;iomap&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 장치 매핑과 일반 메모리의 경계 ==&lt;br /&gt;
UIO 자체도 메모리 유형을 나누어 처리한다. &amp;lt;code&amp;gt;UIO_MEM_DMA_COHERENT&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;dma_mmap_coherent()&amp;lt;/code&amp;gt;를 사용하고, RAM을 공개하는 유형에는 다른 처리 경로가 있다. 장치와 데이터를 주고받는 DMA 버퍼가 물리적으로 RAM에 있는 경우와, 장치 레지스터를 MMIO로 접근하는 경우를 구별해야 한다.&amp;lt;ref name=&amp;quot;uio&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
어떤 드라이버는 접근 시 폴트 처리기에서 PFN을 넣기도 한다. 따라서 이 장의 매핑 시점 PTE 설치는 UIO 기본 물리 매핑의 구체적인 경로이며, 모든 장치 드라이버에 대한 규칙은 아니다. VMA는 장치 드라이버의 정책과 연결되며, 그 정책이 사용자 주소의 실제 대상을 정한다.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br&amp;gt;[[운영체제 기본/Linux/메모리 매핑/파일 매핑과 COW|파일 매핑과 COW]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/메모리 매핑|메모리 매핑 목차]]&lt;br /&gt;
|다음=마지막 문서&lt;br /&gt;
}}&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/BIOS_%EB%B6%80%ED%8C%85/%EB%A3%A8%ED%8A%B8_%ED%8C%8C%EC%9D%BC%EC%8B%9C%EC%8A%A4%ED%85%9C%EA%B3%BC_init_%EC%84%A0%ED%83%9D&amp;diff=701</id>
		<title>운영체제 기본/Linux/x86-64/BIOS 부팅/루트 파일시스템과 init 선택</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/BIOS_%EB%B6%80%ED%8C%85/%EB%A3%A8%ED%8A%B8_%ED%8C%8C%EC%9D%BC%EC%8B%9C%EC%8A%A4%ED%85%9C%EA%B3%BC_init_%EC%84%A0%ED%83%9D&amp;diff=701"/>
		<updated>2026-11-15T06:08:35Z</updated>

		<summary type="html">&lt;p&gt;관리자: 문체 정리: 불필요한 부정 대조와 특수문자 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/PID 1 생성|PID 1 생성]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/x86-64/BIOS 부팅|BIOS 부팅 목차]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
Linux v6.12의 PID 1은 초기 루트 파일시스템을 준비하고 &amp;lt;code&amp;gt;kernel_init()&amp;lt;/code&amp;gt;에서 실행할 init 파일을 고른다. initramfs의 &amp;lt;code&amp;gt;/init&amp;lt;/code&amp;gt;을 사용할지, 루트 장치를 마운트한 뒤 다른 경로를 찾을지는 이 단계에서 결정된다.&lt;br /&gt;
&lt;br /&gt;
== init 실행을 위한 루트 파일시스템 준비 ==&lt;br /&gt;
실행 파일을 열려면 경로 탐색을 시작할 루트 파일시스템이 필요하다. VFS는 루트에서 각 디렉터리 이름을 해석해 inode를 찾고 파일 연산에 연결한다. 경로와 마운트, 열린 파일 객체의 관계는 [[운영체제 기본/Linux/파일시스템/VFS와 파일 객체#경로 탐색과 파일 객체|VFS와 파일 객체]]를 참고한다. 초기에는 rootfs가 있고, initramfs 아카이브의 파일들이 여기에 풀린다. &amp;lt;code&amp;gt;init/initramfs.c&amp;lt;/code&amp;gt;의 &amp;lt;code&amp;gt;populate_rootfs()&amp;lt;/code&amp;gt;는 비동기 작업을 등록하며, 그 작업이 내장 아카이브와 조건에 따라 외부 이미지를 푼다. &amp;lt;code&amp;gt;wait_for_initramfs()&amp;lt;/code&amp;gt;는 이 작업이 끝나기 전에 init 파일에 접근하는 일을 막는다.&amp;lt;ref name=&amp;quot;ramfs&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/init/initramfs.c?h=v6.12 v6.12 init/initramfs.c], populate_rootfs, do_populate_rootfs, wait_for_initramfs.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
초기 rootfs의 실행 후보(기본 &amp;lt;code&amp;gt;/init&amp;lt;/code&amp;gt;)가 실행 접근 사전 검사를 통과하면 루트 장치를 찾고 마운트하는 처리를 초기 사용자 공간에 맡기는 경로로 간다. 이 검사에 실패하면 커널의 &amp;lt;code&amp;gt;prepare_namespace()&amp;lt;/code&amp;gt; 경로가 장치 탐색을 기다리고 루트 장치를 해석해 마운트한다. 어느 경로를 택했는지에 따라 이후 실행 파일을 찾는 루트도 달라진다.&amp;lt;ref name=&amp;quot;main&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/init/main.c?h=v6.12 v6.12 init/main.c], kernel_init_freeable, kernel_init.&amp;lt;/ref&amp;gt;&amp;lt;ref&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/init/do_mounts.c?h=v6.12 v6.12 init/do_mounts.c], prepare_namespace.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== rdinit=와 init=의 적용 단계 ==&lt;br /&gt;
초기 rootfs의 실행 후보는 기본적으로 &amp;lt;code&amp;gt;/init&amp;lt;/code&amp;gt;이며 &amp;lt;code&amp;gt;rdinit=&amp;lt;/code&amp;gt;으로 바꾼다. &amp;lt;code&amp;gt;kernel_init_freeable()&amp;lt;/code&amp;gt;은 이 경로를 &amp;lt;code&amp;gt;init_eaccess()&amp;lt;/code&amp;gt;로 사전 검사한다. 검사에 실패하면 초기 후보를 해제하고 &amp;lt;code&amp;gt;prepare_namespace()&amp;lt;/code&amp;gt;를 호출한다.&amp;lt;ref name=&amp;quot;main&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
그 뒤 &amp;lt;code&amp;gt;kernel_init()&amp;lt;/code&amp;gt;은 다음 순서로 실행 후보를 선택한다.&amp;lt;ref name=&amp;quot;main&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
남아 있는 초기 후보(/init 또는 rdinit=) 실행&lt;br /&gt;
  성공 -&amp;gt; 사용자 실행 이미지 준비 완료&lt;br /&gt;
  실패 -&amp;gt; 다음 선택 단계&lt;br /&gt;
&lt;br /&gt;
init=가 지정되었으면 실행&lt;br /&gt;
  성공 -&amp;gt; 사용자 실행 이미지 준비 완료&lt;br /&gt;
  실패 -&amp;gt; panic&lt;br /&gt;
&lt;br /&gt;
CONFIG_DEFAULT_INIT가 비어 있지 않으면 실행 시도&lt;br /&gt;
/sbin/init -&amp;gt; /etc/init -&amp;gt; /bin/init -&amp;gt; /bin/sh 순서로 시도&lt;br /&gt;
모두 실패 -&amp;gt; panic&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;init=&amp;lt;/code&amp;gt;를 지정해도 초기 후보가 먼저 성공하면 그 경로가 선택된다. 또한 초기 후보가 사전 검사를 통과했지만 실제 exec에서 실패한 경우에는 &amp;lt;code&amp;gt;prepare_namespace()&amp;lt;/code&amp;gt;를 다시 호출하지 않는다. 이때 다음 실행 후보도 기존 루트에서 찾는다.&amp;lt;ref name=&amp;quot;main&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== init 실행과 공통 exec 경로 ==&lt;br /&gt;
부팅 중 PID 1은 아직 사용자 프로그램을 실행한 적이 없으므로, 사용자 코드가 &amp;lt;code&amp;gt;execve()&amp;lt;/code&amp;gt; 시스템 콜을 호출하는 방식으로 첫 프로그램을 시작할 수 없다. 커널의 &amp;lt;code&amp;gt;kernel_init()&amp;lt;/code&amp;gt;에서 &amp;lt;code&amp;gt;run_init_process()&amp;lt;/code&amp;gt;가 선택한 경로와 인자, 환경을 &amp;lt;code&amp;gt;kernel_execve()&amp;lt;/code&amp;gt;에 전달한다.&amp;lt;ref name=&amp;quot;main&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;kernel_execve()&amp;lt;/code&amp;gt;는 커널에 있는 인수 문자열을 복사한다는 차이가 있지만, &amp;lt;code&amp;gt;bprm_execve()&amp;lt;/code&amp;gt;에서 일반 실행 경로와 합쳐져 같은 binfmt 핸들러와 ELF 로더를 사용한다. 파일 형식 판별, ELF 세그먼트 매핑, 초기 스택과 사용자 레지스터 준비의 공통 원리는 [[운영체제 기본/Linux/ELF 로딩|Linux의 ELF 로딩]]에서 설명한다.&amp;lt;ref name=&amp;quot;exec&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/exec.c?h=v6.12 Linux v6.12, fs/exec.c], &amp;lt;code&amp;gt;kernel_execve()&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;bprm_execve()&amp;lt;/code&amp;gt;.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
PID 1은 그대로 유지되고 실행 이미지가 준비된다. 앞서 [[운영체제 기본/Linux/x86-64/BIOS 부팅/PID 1 생성|PID 1 생성]]에서 만든 태스크가 이제 첫 사용자 프로그램을 실행할 주소 공간과 스택, 레지스터 상태를 갖게 되는 것이다.&lt;br /&gt;
&lt;br /&gt;
== PID 1의 첫 사용자 모드 진입 ==&lt;br /&gt;
일반 &amp;lt;code&amp;gt;execve()&amp;lt;/code&amp;gt;는 시스템 콜의 사용자 복귀 경로로 나가지만, PID 1의 첫 실행은 초기 태스크의 커널 시작 함수가 반환하는 경로에서 사용자 모드로 나간다. 성공하면 &amp;lt;code&amp;gt;kernel_execve()&amp;lt;/code&amp;gt;에서 돌아온 &amp;lt;code&amp;gt;kernel_init()&amp;lt;/code&amp;gt;가 반환한다. x86-64에서는 이 시작 함수를 호출했던 &amp;lt;code&amp;gt;ret_from_fork()&amp;lt;/code&amp;gt;가 사용자 복귀 준비를 수행하고, 이어 &amp;lt;code&amp;gt;ret_from_fork_asm&amp;lt;/code&amp;gt;의 어셈블리 복귀 경로가 로더가 준비한 레지스터 상태를 복원한다. &amp;lt;code&amp;gt;iretq&amp;lt;/code&amp;gt;로 사용자 권한과 진입 주소, 스택을 적용하면 비로소 첫 사용자 명령어를 실행한다.&amp;lt;ref name=&amp;quot;x86-fork&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/kernel/process.c?h=v6.12 Linux v6.12, arch/x86/kernel/process.c], &amp;lt;code&amp;gt;ret_from_fork()&amp;lt;/code&amp;gt;.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;x86-entry&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/entry/entry_64.S?h=v6.12 Linux v6.12, arch/x86/entry/entry_64.S], &amp;lt;code&amp;gt;ret_from_fork_asm&amp;lt;/code&amp;gt;, 사용자 모드 복귀 경로.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
비교하면, RISC-V RV64의 첫 사용자 진입에서는 어셈블리 &amp;lt;code&amp;gt;ret_from_fork&amp;lt;/code&amp;gt;가 &amp;lt;code&amp;gt;kernel_init()&amp;lt;/code&amp;gt;을 호출하고, 반환 뒤 &amp;lt;code&amp;gt;syscall_exit_to_user_mode()&amp;lt;/code&amp;gt;를 거쳐 &amp;lt;code&amp;gt;ret_from_exception&amp;lt;/code&amp;gt;으로 이어진다. 저장된 상태를 복원한 뒤 &amp;lt;code&amp;gt;sret&amp;lt;/code&amp;gt;로 사용자 모드에 진입한다. 이는 x86 BIOS 부팅 경로와 구별되는 RV64의 사용자 진입 방식이다.&amp;lt;ref name=&amp;quot;rv-return&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/riscv/kernel/entry.S?h=v6.12 Linux v6.12, arch/riscv/kernel/entry.S], &amp;lt;code&amp;gt;ret_from_fork&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;ret_from_exception&amp;lt;/code&amp;gt;.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
커널은 새 실행 이미지와 사용자 상태를 준비한 뒤, 실행 파일의 진입점에서 사용자 모드 실행을 시작한다. 두 아키텍처의 레지스터 준비와 복귀 명령의 공통 비교는 [[운영체제 기본/Linux/ELF 로딩/초기 스택과 사용자 모드 진입#사용자 모드 진입: x86-64와 RISC-V|초기 스택과 사용자 모드 진입]]에서 다룬다.&lt;br /&gt;
&lt;br /&gt;
initramfs의 &amp;lt;code&amp;gt;/init&amp;lt;/code&amp;gt;이 실제 루트를 준비한 뒤 다른 init으로 exec하는 것은 이후 사용자 공간의 처리다. 이후 init의 실행 여부와 경로는 &amp;lt;code&amp;gt;/init&amp;lt;/code&amp;gt;의 동작에 달려 있다.&amp;lt;ref&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/Documentation/filesystems/ramfs-rootfs-initramfs.rst?h=v6.12 Linux v6.12, ramfs-rootfs-initramfs.rst], What is initramfs? 절.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/PID 1 생성|PID 1 생성]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/x86-64/BIOS 부팅|BIOS 부팅 목차]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%ED%8C%8C%EC%9D%BC%EC%8B%9C%EC%8A%A4%ED%85%9C/procfs%EC%9D%98_%ED%8C%8C%EC%9D%BC_%EC%9D%BD%EA%B8%B0&amp;diff=700</id>
		<title>운영체제 기본/Linux/파일시스템/procfs의 파일 읽기</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%ED%8C%8C%EC%9D%BC%EC%8B%9C%EC%8A%A4%ED%85%9C/procfs%EC%9D%98_%ED%8C%8C%EC%9D%BC_%EC%9D%BD%EA%B8%B0&amp;diff=700"/>
		<updated>2026-11-15T06:08:17Z</updated>

		<summary type="html">&lt;p&gt;관리자: 과도한 강조와 인용 표현, 반복적인 부정 대조 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=&amp;lt;- 이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/파일시스템/ext4의 파일 읽기|ext4의 파일 읽기]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/파일시스템|파일시스템 목차]]&lt;br /&gt;
|다음=다음 문서 -&amp;gt;&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/파일시스템/페이지 캐시|페이지 캐시]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
Linux v6.12의 &amp;lt;code&amp;gt;/proc/uptime&amp;lt;/code&amp;gt;은 커널 상태를 문자열로 만들어 돌려준다. ext4의 저장된 파일과 같은 &amp;lt;code&amp;gt;read()&amp;lt;/code&amp;gt; 인터페이스를 사용하지만, 내용을 제공하는 함수는 다르다.&lt;br /&gt;
&lt;br /&gt;
== 같은 파일 객체, 다른 연산 구현 ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;/proc&amp;lt;/code&amp;gt;에 procfs가 마운트되어 있다면 경로 탐색은 그 마운트를 통해 procfs의 이름 공간으로 들어간다. &amp;lt;code&amp;gt;uptime&amp;lt;/code&amp;gt;도 inode로 표현되며, 열면 열린 파일을 나타내는 &amp;lt;code&amp;gt;struct file&amp;lt;/code&amp;gt;과 파일 디스크립터를 얻는다. [[운영체제 기본/Linux/파일 시스템 콜/read와 write|파일 읽기]]에서 본 것처럼 프로그램은 파일 디스크립터, 받을 버퍼, 읽을 길이를 &amp;lt;code&amp;gt;read()&amp;lt;/code&amp;gt;에 전달한다.&lt;br /&gt;
&lt;br /&gt;
달라지는 지점은 파일 객체에 연결된 연산이다. procfs에는 VFS가 호출하는 &amp;lt;code&amp;gt;struct file_operations&amp;lt;/code&amp;gt;와 개별 항목이 제공하는 &amp;lt;code&amp;gt;struct proc_ops&amp;lt;/code&amp;gt;가 따로 있다. 전자는 VFS 쪽 입구이며, 그 래퍼 함수가 후자의 콜백으로 요청을 넘긴다.&amp;lt;ref name=&amp;quot;proc-inode&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/proc/inode.c?h=v6.12 Linux v6.12 fs/proc/inode.c], proc_get_inode, proc_iter_file_ops, proc_reg_open, proc_reg_read_iter.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== uptime 항목과 읽기 함수 등록 ==&lt;br /&gt;
초기화 함수 &amp;lt;code&amp;gt;proc_uptime_init()&amp;lt;/code&amp;gt;은 다음 호출로 항목과 출력 함수를 등록한다.&amp;lt;ref name=&amp;quot;uptime&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/proc/uptime.c?h=v6.12 Linux v6.12 fs/proc/uptime.c], proc_uptime_init, uptime_proc_show.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
pde = proc_create_single(&amp;quot;uptime&amp;quot;, 0, NULL, uptime_proc_show);&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;proc_create_single()&amp;lt;/code&amp;gt;은 &amp;lt;code&amp;gt;proc_create_single_data()&amp;lt;/code&amp;gt;로 이어진다. 이 함수는 &amp;lt;code&amp;gt;single_show&amp;lt;/code&amp;gt;에 출력 함수 포인터를 저장하고 &amp;lt;code&amp;gt;proc_ops&amp;lt;/code&amp;gt;에는 &amp;lt;code&amp;gt;proc_single_ops&amp;lt;/code&amp;gt;를 연결한다. 그 테이블에서 이 예제의 핵심은 다음 두 항목이다.&amp;lt;ref name=&amp;quot;proc-header&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/linux/proc_fs.h?h=v6.12 Linux v6.12 include/linux/proc_fs.h], proc_create_single.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;proc-generic&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/proc/generic.c?h=v6.12 Linux v6.12 fs/proc/generic.c], proc_create_single_data, proc_single_ops, proc_single_open.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
.proc_open      = proc_single_open,&lt;br /&gt;
.proc_read_iter = seq_read_iter,&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
여기에는 &amp;lt;code&amp;gt;proc_read_iter&amp;lt;/code&amp;gt;가 있으므로 &amp;lt;code&amp;gt;proc_get_inode()&amp;lt;/code&amp;gt;은 &amp;lt;code&amp;gt;inode-&amp;gt;i_fop&amp;lt;/code&amp;gt;에 &amp;lt;code&amp;gt;proc_iter_file_ops&amp;lt;/code&amp;gt;를 선택한다. 열기 과정에서는 &amp;lt;code&amp;gt;proc_reg_open()&amp;lt;/code&amp;gt;이 &amp;lt;code&amp;gt;proc_single_open()&amp;lt;/code&amp;gt;으로 넘기고, 이어지는 &amp;lt;code&amp;gt;single_open()&amp;lt;/code&amp;gt;이 가변 길이의 출력과 읽기 위치를 관리하는 &amp;lt;code&amp;gt;seq_file&amp;lt;/code&amp;gt; 상태와 출력 콜백을 준비한다. 열린 파일의 &amp;lt;code&amp;gt;private_data&amp;lt;/code&amp;gt;는 이 읽기 상태를 가리킨다.&amp;lt;ref name=&amp;quot;proc-inode&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;proc-generic&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;seq-source&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/seq_file.c?h=v6.12 Linux v6.12 fs/seq_file.c], seq_open, single_open, seq_read_iter.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 커널 상태의 문자열 변환 ==&lt;br /&gt;
이 파일에서 일반적인 동기식 &amp;lt;code&amp;gt;read()&amp;lt;/code&amp;gt;의 핵심 호출 경로는 다음과 같다. &amp;lt;code&amp;gt;vfs_read()&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;.read&amp;lt;/code&amp;gt; 대신 &amp;lt;code&amp;gt;.read_iter&amp;lt;/code&amp;gt;가 있는 경우 &amp;lt;code&amp;gt;new_sync_read()&amp;lt;/code&amp;gt;를 통해 호출 형태를 맞춘다.&amp;lt;ref name=&amp;quot;read-write&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/read_write.c?h=v6.12 Linux v6.12 fs/read_write.c], vfs_read, new_sync_read.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
read()&lt;br /&gt;
  -&amp;gt; vfs_read()&lt;br /&gt;
  -&amp;gt; new_sync_read()&lt;br /&gt;
  -&amp;gt; proc_reg_read_iter()&lt;br /&gt;
  -&amp;gt; seq_read_iter()&lt;br /&gt;
       -&amp;gt; 출력이 필요하면 uptime_proc_show()&lt;br /&gt;
       -&amp;gt; 버퍼의 바이트를 사용자 버퍼로 전달&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;uptime_proc_show()&amp;lt;/code&amp;gt;는 CPU별 유휴 시간을 합산하고, &amp;lt;code&amp;gt;ktime_get_boottime_ts64()&amp;lt;/code&amp;gt;로 부팅 이후 시간을 얻는다. 부팅 시간에는 &amp;lt;code&amp;gt;timens_add_boottime()&amp;lt;/code&amp;gt;으로 시간 이름 공간의 보정도 적용한다. 그런 다음 &amp;lt;code&amp;gt;seq_printf()&amp;lt;/code&amp;gt;로 두 값을 소수점 아래 두 자리의 문자열로 만든다. 프로그램은 이 함수가 커널 상태를 읽어 생성한 바이트를 받는다. 두 번째 값은 CPU별 유휴 시간의 합이므로 첫 번째 값보다 클 수도 있다.&amp;lt;ref name=&amp;quot;uptime&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== seq_file의 읽기 위치와 버퍼 ==&lt;br /&gt;
한 번에 몇 바이트만 요청하는 프로그램도 이 파일을 읽을 수 있어야 한다. &amp;lt;code&amp;gt;seq_read_iter()&amp;lt;/code&amp;gt;는 내부 버퍼에 생성한 출력을 담고, 요청한 범위만 복사하며, 남은 바이트와 읽기 위치를 관리한다. 짧게 나누어 읽을 때는 남은 출력을 재사용할 수 있다. 읽기 위치를 되돌리거나 출력을 다시 구성하면 출력 함수를 다시 호출할 수 있다.&amp;lt;ref name=&amp;quot;seq-source&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;seq-doc&amp;quot;&amp;gt;[https://docs.kernel.org/6.12/filesystems/seq_file.html Linux v6.12 문서 The seq_file Interface].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이 예제는 출력 콜백과 &amp;lt;code&amp;gt;seq_file&amp;lt;/code&amp;gt; 버퍼로 데이터를 제공한다. procfs의 자료원과 읽기 구현은 항목마다 다르다. &amp;lt;code&amp;gt;uptime_proc_show()&amp;lt;/code&amp;gt;는 여러 CPU의 통계와 시간을 순서대로 읽으므로 각 값의 관측 시점에 차이가 있을 수 있다.&amp;lt;ref name=&amp;quot;uptime&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;seq-source&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
ext4와 procfs는 이름, inode, 열린 파일, 읽기 요청이라는 공통 인터페이스를 사용한다. 각 파일에 연결된 구현이 저장된 내용을 읽거나 커널 상태에서 데이터를 생성한다.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=&amp;lt;- 이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/파일시스템/ext4의 파일 읽기|ext4의 파일 읽기]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/파일시스템|파일시스템 목차]]&lt;br /&gt;
|다음=다음 문서 -&amp;gt;&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/파일시스템/페이지 캐시|페이지 캐시]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%EB%A9%94%EB%AA%A8%EB%A6%AC_%EB%A7%A4%ED%95%91/%ED%8C%8C%EC%9D%BC_%EB%A7%A4%ED%95%91%EA%B3%BC_COW&amp;diff=699</id>
		<title>운영체제 기본/Linux/메모리 매핑/파일 매핑과 COW</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%EB%A9%94%EB%AA%A8%EB%A6%AC_%EB%A7%A4%ED%95%91/%ED%8C%8C%EC%9D%BC_%EB%A7%A4%ED%95%91%EA%B3%BC_COW&amp;diff=699"/>
		<updated>2026-11-15T06:08:14Z</updated>

		<summary type="html">&lt;p&gt;관리자: 문체 정리: 과도한 강조와 반복 설명, 비표준 문자 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br&amp;gt;[[운영체제 기본/Linux/메모리 매핑/익명 메모리 매핑|익명 메모리 매핑]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/메모리 매핑|메모리 매핑 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br&amp;gt;[[운영체제 기본/Linux/메모리 매핑/MMIO 장치 매핑|MMIO 장치 매핑]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
파일 매핑(File-backed Mapping)은 파일의 범위를 프로세스의 가상 주소에 연결한다. 일반 ext4 파일의 buffered 경로를 기준으로, 읽을 때 페이지 캐시가 어떻게 연결되는지부터 살펴본다. 이어서 같은 파일의 쓰기가 &amp;lt;code&amp;gt;MAP_PRIVATE&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;MAP_SHARED&amp;lt;/code&amp;gt;에서 어떻게 달라지는지 비교한다. 기준은 Linux v6.12다.&lt;br /&gt;
&lt;br /&gt;
== 파일 매핑과 첫 접근 ==&lt;br /&gt;
다음 코드는 미리 존재하는 비어 있지 않은 파일 &amp;lt;code&amp;gt;/home/ldmsys/a.txt&amp;lt;/code&amp;gt;의 첫 바이트를 읽는다. 실행 중 다른 프로세스가 파일을 줄이거나 바꾸지 않는다고 가정한다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
#include &amp;amp;lt;fcntl.h&amp;amp;gt;&lt;br /&gt;
#include &amp;amp;lt;stdio.h&amp;amp;gt;&lt;br /&gt;
#include &amp;amp;lt;sys/mman.h&amp;amp;gt;&lt;br /&gt;
#include &amp;amp;lt;unistd.h&amp;amp;gt;&lt;br /&gt;
&lt;br /&gt;
int main(void) {&lt;br /&gt;
    int fd = open(&amp;quot;/home/ldmsys/a.txt&amp;quot;, O_RDONLY);&lt;br /&gt;
    if (fd == -1) return 1;&lt;br /&gt;
    void *p = mmap(NULL, 1, PROT_READ, MAP_PRIVATE, fd, 0);&lt;br /&gt;
    close(fd);&lt;br /&gt;
    if (p == MAP_FAILED) return 1;&lt;br /&gt;
    printf(&amp;quot;%u\n&amp;quot;, (unsigned)((const unsigned char *)p)[0]);&lt;br /&gt;
    return munmap(p, 1) == -1;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;mmap()&amp;lt;/code&amp;gt;은 주소를 반환하고, 실제 바이트 읽기는 &amp;lt;code&amp;gt;((const unsigned char *)p)[0]&amp;lt;/code&amp;gt;에서 발생한다. 그 사이 fd를 닫아도 매핑이 파일 객체의 참조를 유지하므로 접근할 수 있다. 길이 1은 요청한 바이트 범위이며, 커널은 매핑을 페이지 단위로 관리한다.&lt;br /&gt;
&lt;br /&gt;
== ext4의 폴트 처리기 ==&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
mmap -&amp;gt; ksys_mmap_pgoff -&amp;gt; vm_mmap_pgoff -&amp;gt; do_mmap&lt;br /&gt;
  -&amp;gt; mmap_region -&amp;gt; __mmap_region -&amp;gt; mmap_file -&amp;gt; call_mmap&lt;br /&gt;
  -&amp;gt; file-&amp;amp;gt;f_op-&amp;amp;gt;mmap -&amp;gt; ext4_file_mmap&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;ext4_file_mmap()&amp;lt;/code&amp;gt;은 DAX가 아닌 경로에서 VMA의 &amp;lt;code&amp;gt;vm_ops&amp;lt;/code&amp;gt;를 &amp;lt;code&amp;gt;ext4_file_vm_ops&amp;lt;/code&amp;gt;로 정한다. 이 표의 &amp;lt;code&amp;gt;.fault&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;filemap_fault&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;.map_pages&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;filemap_map_pages&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;.page_mkwrite&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;ext4_page_mkwrite&amp;lt;/code&amp;gt;다. 파일 전체를 즉시 읽는 대신, 이후 읽기와 쓰기를 처리할 함수를 등록한다.&amp;lt;ref name=&amp;quot;ext4&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/ext4/file.c?h=v6.12 Linux v6.12, fs/ext4/file.c], ext4_file_operations, ext4_file_mmap, ext4_file_vm_ops.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 읽기 폴트와 페이지 캐시 ==&lt;br /&gt;
PTE가 없는 주소를 읽으면 [[운영체제 기본/Linux/메모리 매핑/페이지 폴트 처리|공통 페이지 폴트 경로]]를 지나 다음 분기로 들어간다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
handle_mm_fault -&amp;gt; __handle_mm_fault -&amp;gt; handle_pte_fault&lt;br /&gt;
  -&amp;gt; do_pte_missing -&amp;gt; do_fault -&amp;gt; do_read_fault&lt;br /&gt;
  -&amp;gt; __do_fault -&amp;gt; filemap_fault&lt;br /&gt;
  -&amp;gt; 파일 페이지 준비 -&amp;gt; finish_fault -&amp;gt; PTE 설치&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;filemap_fault()&amp;lt;/code&amp;gt;는 해당 파일 오프셋의 페이지를 [[운영체제 기본/Linux/파일시스템/페이지 캐시|페이지 캐시]]에서 찾고, 필요하면 파일시스템을 통해 데이터를 읽는다. 입출력을 기다리는 동안 태스크가 잠들거나, 잠금을 놓았다가 처리를 재시도할 수 있다. 페이지가 준비되면 &amp;lt;code&amp;gt;finish_fault()&amp;lt;/code&amp;gt;가 PTE를 연결하고, 사용자 모드의 load가 다시 실행된다.&amp;lt;ref name=&amp;quot;filemap&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/mm/filemap.c?h=v6.12 Linux v6.12, mm/filemap.c], filemap_fault와 filemap_map_pages.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;memory&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/mm/memory.c?h=v6.12 Linux v6.12, mm/memory.c], do_read_fault, do_cow_fault, do_shared_fault, do_wp_page, finish_fault.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
페이지가 이미 준비되어 있다면 &amp;lt;code&amp;gt;do_fault_around()&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;filemap_map_pages()&amp;lt;/code&amp;gt;가 주변 페이지까지 연결할 수 있다. 그 경로에서 해결되면 &amp;lt;code&amp;gt;filemap_fault()&amp;lt;/code&amp;gt;를 호출하지 않는다. 캐시와 주변 페이지 연결 덕분에 저장장치 읽기나 개별 페이지 폴트를 줄일 수 있다.&amp;lt;ref name=&amp;quot;filemap&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;memory&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== MAP_PRIVATE와 쓰기 시 복사 ==&lt;br /&gt;
앞의 코드는 &amp;lt;code&amp;gt;PROT_READ&amp;lt;/code&amp;gt;만 요청했으므로 쓰기는 허용되지 않는다. COW를 보려면 &amp;lt;code&amp;gt;PROT_READ | PROT_WRITE&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;MAP_PRIVATE&amp;lt;/code&amp;gt;로 매핑한다. 읽기 가능한 일반 파일을 private writable로 매핑하는 것은 파일 자체에 쓰는 것과 다르며, Linux는 이 경우 fd가 반드시 쓰기용으로 열려 있을 것을 요구하지 않는다. 반면 shared writable 매핑은 파일의 쓰기 권한도 필요하다.&amp;lt;ref name=&amp;quot;mmap&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/mm/mmap.c?h=v6.12 Linux v6.12, mm/mmap.c], do_mmap의 MAP_PRIVATE, MAP_SHARED 및 파일 접근 모드 검사.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
private 매핑도 읽기만 할 때는 파일의 페이지 캐시 페이지를 다른 매핑과 함께 사용할 수 있다. 처음부터 파일 전체 사본을 만들지 않는다. 대신 쓰기를 허용한 VMA라도 원본 파일 페이지를 가리키는 PTE에는 바로 쓰기 권한을 주지 않는다. 그 상태에서 store가 실행되면 보호 폴트가 발생한다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
읽기 단계&lt;br /&gt;
  프로세스 A의 private PTE -- R --+&lt;br /&gt;
                                +- 파일의 페이지 캐시&lt;br /&gt;
  프로세스 B의 매핑        -------+&lt;br /&gt;
&lt;br /&gt;
A의 private 쓰기 후&lt;br /&gt;
  프로세스 A의 PTE -- RW -- 익명 사본 [A의 변경]&lt;br /&gt;
  프로세스 B의 매핑 ------- 파일의 페이지 캐시 [원본]&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
커널은 원본 페이지의 내용을 익명 페이지로 복사하고, 쓰기를 요청한 프로세스의 PTE를 새 페이지로 바꾼다. 재시도한 store는 이 사본을 바꾸며 파일의 페이지 캐시는 바꾸지 않는다. VMA는 여전히 파일에 연결되어 있어도, 그 안의 수정된 페이지는 익명 페이지일 수 있다. COW는 실제로 쓰는 페이지 단위로 진행된다.&amp;lt;ref name=&amp;quot;memory&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== 최초 쓰기와 쓰기 보호 폴트 ===&lt;br /&gt;
읽기 전에 처음부터 쓰는 경우와, 이미 읽기용 PTE가 있는 경우는 진입 함수가 다르다.&lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
! 쓰기 직전 상태 !! 주요 처리 경로 !! 결과&lt;br /&gt;
|-&lt;br /&gt;
| PTE가 아직 없음 || do_fault -&amp;gt; do_cow_fault -&amp;gt; 파일 fault 처리기 -&amp;gt; finish_fault || 파일 내용을 얻어 익명 사본을 만들고 PTE 설치&lt;br /&gt;
|-&lt;br /&gt;
| 파일 페이지의 읽기 전용 PTE가 있음 || do_wp_page -&amp;gt; wp_page_copy || 기존 파일 페이지에서 익명 사본을 만들고 PTE 교체&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
이미 private 익명 사본을 갖고 있고 그 PTE가 쓰기 가능하면, 이후 쓰기는 폴트 없이 진행한다. 그 사본도 &amp;lt;code&amp;gt;fork()&amp;lt;/code&amp;gt; 뒤에는 [[운영체제 기본/Linux/메모리 매핑/익명 메모리 매핑#fork와 쓰기 시 복사|익명 페이지의 COW]] 대상이 될 수 있다.&amp;lt;ref name=&amp;quot;memory&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;MAP_PRIVATE&amp;lt;/code&amp;gt;는 파일의 일관된 스냅샷을 보장하는 기능은 아니다. 매핑 뒤 다른 경로에서 파일이 변경되었을 때 아직 private 사본으로 갈라지지 않은 부분에서 무엇이 보일지에 의존해서는 안 된다. 이 매핑을 통한 private 쓰기는 원래 파일에 반영되지 않는다.&amp;lt;ref name=&amp;quot;man-mmap&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man2/mmap.2.html Linux man-pages, mmap(2)], MAP_PRIVATE와 MAP_SHARED.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== MAP_SHARED와 변경 반영 ==&lt;br /&gt;
&amp;lt;code&amp;gt;MAP_SHARED&amp;lt;/code&amp;gt;에서 허용된 쓰기는 같은 파일 데이터를 공유하는 쪽에 적용된다.&lt;br /&gt;
&lt;br /&gt;
PTE가 없는 첫 쓰기는 &amp;lt;code&amp;gt;do_shared_fault()&amp;lt;/code&amp;gt;로 들어간다. 파일 페이지를 확보하고, 파일시스템의 &amp;lt;code&amp;gt;page_mkwrite&amp;lt;/code&amp;gt; 콜백이 있으면 쓰기 준비를 요청한다. ext4에서는 &amp;lt;code&amp;gt;ext4_page_mkwrite()&amp;lt;/code&amp;gt;가 필요한 블록과 파일 상태를 준비한다. 이어 PTE와 dirty 상태를 다루어, 변경된 페이지를 나중에 저장장치에 기록할 수 있게 한다. 이미 읽기 전용 PTE가 있는 shared 쓰기는 &amp;lt;code&amp;gt;do_wp_page()&amp;lt;/code&amp;gt;의 shared 경로로 이어진다.&amp;lt;ref name=&amp;quot;memory&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;ext4&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;ext4-mkwrite&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/ext4/inode.c?h=v6.12 Linux v6.12, fs/ext4/inode.c], ext4_page_mkwrite.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
메모리에서 변경이 보이는 시점과 디스크에 기록이 끝나는 시점은 다르다. dirty 페이지는 writeback 대상이며, 프로그램이 기록 완료를 명시적으로 기다려야 하면 &amp;lt;code&amp;gt;msync(..., MS_SYNC)&amp;lt;/code&amp;gt; 등의 인터페이스와 오류 처리를 사용한다. &amp;lt;code&amp;gt;MAP_SHARED&amp;lt;/code&amp;gt; 자체는 여러 실행 흐름의 동기화나 원자성을 보장하지 않는다.&amp;lt;ref name=&amp;quot;man-mmap&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;msync&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man2/msync.2.html Linux man-pages, msync(2)], MS_SYNC.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 범위와 비용 ==&lt;br /&gt;
일반 파일의 시작 오프셋은 페이지 크기에 맞춰야 한다. 주소가 VMA 안에 있더라도 파일이 잘려 해당 페이지가 파일 끝 밖으로 나가면 &amp;lt;code&amp;gt;SIGBUS&amp;lt;/code&amp;gt;가 발생할 수 있다.&amp;lt;ref name=&amp;quot;filemap&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
buffered &amp;lt;code&amp;gt;read()&amp;lt;/code&amp;gt;는 페이지 캐시의 데이터를 사용자 버퍼로 복사한다. 파일 &amp;lt;code&amp;gt;mmap()&amp;lt;/code&amp;gt;은 그 페이지를 사용자 주소에 연결해 load/store로 접근하게 한다. 읽기 복사를 피할 수 있지만 폴트와 페이지 테이블 관리 비용이 들고, private 쓰기에는 COW 비용이 추가된다. 따라서 데이터 크기와 접근 패턴에 따라 유불리가 달라진다.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br&amp;gt;[[운영체제 기본/Linux/메모리 매핑/익명 메모리 매핑|익명 메모리 매핑]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/메모리 매핑|메모리 매핑 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br&amp;gt;[[운영체제 기본/Linux/메모리 매핑/MMIO 장치 매핑|MMIO 장치 매핑]]&lt;br /&gt;
}}&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/BIOS_%EB%B6%80%ED%8C%85/PID_1_%EC%83%9D%EC%84%B1&amp;diff=698</id>
		<title>운영체제 기본/Linux/x86-64/BIOS 부팅/PID 1 생성</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/BIOS_%EB%B6%80%ED%8C%85/PID_1_%EC%83%9D%EC%84%B1&amp;diff=698"/>
		<updated>2026-11-15T06:08:13Z</updated>

		<summary type="html">&lt;p&gt;관리자: 문체 정리: 반복 대조와 강조, 특수문자 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/커널 초기화|커널 초기화]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/x86-64/BIOS 부팅|BIOS 부팅 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/루트 파일시스템과 init 선택|루트 파일시스템과 init 선택]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
Linux v6.12에서 [[운영체제 기본/Linux/x86-64/BIOS 부팅/커널 초기화#커널 스택과 CPU 상태 설정|부트 태스크]]는 &amp;lt;code&amp;gt;rest_init()&amp;lt;/code&amp;gt;에 도달하면 PID 1과 &amp;lt;code&amp;gt;kthreadd&amp;lt;/code&amp;gt;를 만든다. PID 1은 커널의 나머지 초기화를 맡고, 기존 부트 태스크인 PID 0은 idle 태스크로 남는다.&lt;br /&gt;
&lt;br /&gt;
== PID 0, PID 1, kthreadd의 역할 ==&lt;br /&gt;
&amp;lt;code&amp;gt;rest_init()&amp;lt;/code&amp;gt;은 먼저 &amp;lt;code&amp;gt;user_mode_thread(kernel_init, NULL, CLONE_FS)&amp;lt;/code&amp;gt;를 호출해 PID 1을 만든다. 이어 &amp;lt;code&amp;gt;kernel_thread()&amp;lt;/code&amp;gt;로 &amp;lt;code&amp;gt;kthreadd&amp;lt;/code&amp;gt;(PID 2)를 만든다. 기존 부트 태스크는 스케줄러를 거쳐 &amp;lt;code&amp;gt;cpu_startup_entry()&amp;lt;/code&amp;gt;의 idle 경로로 진행한다.&amp;lt;ref name=&amp;quot;main&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/init/main.c?h=v6.12 v6.12 init/main.c], rest_init.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
새 PID 1 태스크는 별도의 실행 문맥에서 &amp;lt;code&amp;gt;kernel_init()&amp;lt;/code&amp;gt;을 실행한다. 실행 상태와 자원의 구분은 [[운영체제 기본/프로세스와 스레드|프로세스와 스레드]]에서 설명한다. 이후 어떤 태스크가 CPU를 사용할지는 스케줄링에 따라 달라진다. 기존 PID 0은 idle 태스크로 계속 존재한다.&amp;lt;ref name=&amp;quot;fork&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/kernel/fork.c?h=v6.12 v6.12 kernel/fork.c], user_mode_thread, kernel_thread, kernel_clone.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
PID 0: start_kernel -&amp;gt; rest_init -----------------&amp;gt; idle&lt;br /&gt;
                         |&lt;br /&gt;
                         +-- create PID 1 -&amp;gt; kernel_init&lt;br /&gt;
                         |&lt;br /&gt;
                         +-- create PID 2 -&amp;gt; kthreadd&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== user_mode_thread와 kernel_init ==&lt;br /&gt;
&amp;lt;code&amp;gt;user_mode_thread()&amp;lt;/code&amp;gt;는 시작 함수와 인자를 &amp;lt;code&amp;gt;kernel_clone_args&amp;lt;/code&amp;gt;에 담아 &amp;lt;code&amp;gt;kernel_clone()&amp;lt;/code&amp;gt;에 넘긴다. 이 경우 시작 함수는 커널 내부 함수인 &amp;lt;code&amp;gt;kernel_init()&amp;lt;/code&amp;gt;이다.&amp;lt;ref name=&amp;quot;fork&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;kernel_thread()&amp;lt;/code&amp;gt;와의 차이는 &amp;lt;code&amp;gt;kthread&amp;lt;/code&amp;gt; 속성을 설정하지 않는다는 점이다. 계속 커널 스레드로 남을 태스크와 나중에 사용자 실행 이미지를 갖게 될 태스크의 생성 방식이 구별된다. 실제로 &amp;lt;code&amp;gt;kernel_execve()&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;PF_KTHREAD&amp;lt;/code&amp;gt;가 설정된 태스크의 호출을 거부한다. PID 1은 처음에 커널 코드를 실행하지만 &amp;lt;code&amp;gt;PF_KTHREAD&amp;lt;/code&amp;gt;가 설정되지 않아 이후 exec를 수행할 수 있다.&amp;lt;ref name=&amp;quot;fork&amp;quot;/&amp;gt;&amp;lt;ref&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/exec.c?h=v6.12 v6.12 fs/exec.c], kernel_execve.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
사용자 프로그램을 실행할 태스크 역시 커널에 진입해 커널 코드를 실행할 수 있다. PID 1은 아직 첫 사용자 실행 이미지를 얻기 전이다. 보호 경계 자체는 [[운영체제 기본/보호|보호]]를 참고한다.&lt;br /&gt;
&lt;br /&gt;
== kthreadd 생성과 PID 1의 대기 ==&lt;br /&gt;
PID 1이라는 번호를 얻도록 init을 먼저 생성하지만, init이 진행하며 사용할 커널 스레드 생성 기반인 &amp;lt;code&amp;gt;kthreadd&amp;lt;/code&amp;gt;는 그다음 만들어진다. 태스크 생성 순서와 실행 순서는 다를 수 있으므로 두 태스크 사이에 동기화가 필요하다.&amp;lt;ref name=&amp;quot;main&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이 의존 관계를 표현하는 것이 &amp;lt;code&amp;gt;kthreadd_done&amp;lt;/code&amp;gt; completion이다. completion은 한쪽이 작업 완료를 알리고 다른 쪽이 그 사건을 기다리는 동기화 수단이다. 조건을 기다리는 작업과 깨우기의 관계는 [[운영체제 기본/동시성|동시성]]과 연결된다. &amp;lt;code&amp;gt;kernel_init()&amp;lt;/code&amp;gt;은 시작하자마자 기다리고, &amp;lt;code&amp;gt;rest_init()&amp;lt;/code&amp;gt;은 kthreadd 준비 후 완료를 알린다.&amp;lt;ref name=&amp;quot;main&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== PID 1의 커널 초기화와 initcall ==&lt;br /&gt;
대기가 끝나면 &amp;lt;code&amp;gt;kernel_init_freeable()&amp;lt;/code&amp;gt;이 SMP와 나머지 초기화를 진행한다. 여기에는 &amp;lt;code&amp;gt;do_basic_setup()&amp;lt;/code&amp;gt;을 통한 initcall 실행도 포함된다.&amp;lt;ref name=&amp;quot;main&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
initcall은 부팅 중 실행할 초기화 함수를 정해진 단계에 등록하는 방식이다. 소스의 각 부분이 등록한 함수들을 초기화 경로가 순회하며 실행하므로, &amp;lt;code&amp;gt;start_kernel()&amp;lt;/code&amp;gt; 안에 모든 드라이버의 함수 이름이 직접 나열될 필요는 없다. 예를 들어 rootfs에 initramfs를 푸는 &amp;lt;code&amp;gt;populate_rootfs()&amp;lt;/code&amp;gt;도 &amp;lt;code&amp;gt;rootfs_initcall&amp;lt;/code&amp;gt;로 등록되어 있다.&amp;lt;ref name=&amp;quot;main&amp;quot;/&amp;gt;&amp;lt;ref&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/init/initramfs.c?h=v6.12 v6.12 init/initramfs.c], populate_rootfs 및 rootfs_initcall 등록.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;kernel_init_freeable()&amp;lt;/code&amp;gt;에서 돌아온 뒤에도 비동기 초기화의 완료를 기다린다. 그래야 아직 실행 중인 초기화 코드가 있는데 그 코드를 담은 메모리를 먼저 해제하는 일이 없다. 이후 초기화용 메모리를 정리하고, 다음 장에서 다룰 init 선택과 exec로 진행한다.&amp;lt;ref name=&amp;quot;main&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/커널 초기화|커널 초기화]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/x86-64/BIOS 부팅|BIOS 부팅 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/루트 파일시스템과 init 선택|루트 파일시스템과 init 선택]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%EB%A9%94%EB%AA%A8%EB%A6%AC_%EB%A7%A4%ED%95%91/%EC%9D%B5%EB%AA%85_%EB%A9%94%EB%AA%A8%EB%A6%AC_%EB%A7%A4%ED%95%91&amp;diff=697</id>
		<title>운영체제 기본/Linux/메모리 매핑/익명 메모리 매핑</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%EB%A9%94%EB%AA%A8%EB%A6%AC_%EB%A7%A4%ED%95%91/%EC%9D%B5%EB%AA%85_%EB%A9%94%EB%AA%A8%EB%A6%AC_%EB%A7%A4%ED%95%91&amp;diff=697"/>
		<updated>2026-11-15T06:07:53Z</updated>

		<summary type="html">&lt;p&gt;관리자: 문체 정리: 반복 대조와 비표준 문자 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br&amp;gt;[[운영체제 기본/Linux/메모리 매핑/페이지 폴트 처리|페이지 폴트 처리]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/메모리 매핑|메모리 매핑 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br&amp;gt;[[운영체제 기본/Linux/메모리 매핑/파일 매핑과 COW|파일 매핑과 COW]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
익명 매핑(Anonymous Mapping)은 사용자 파일의 내용을 가져오는 대신, 프로그램이 사용할 메모리 구간을 만든다. Linux v6.12의 &amp;lt;code&amp;gt;MAP_PRIVATE | MAP_ANONYMOUS&amp;lt;/code&amp;gt;를 먼저 살펴본다. 새 구간은 0으로 초기화된 것처럼 보이지만, 그 길이만큼의 물리 RAM을 &amp;lt;code&amp;gt;mmap()&amp;lt;/code&amp;gt; 시점에 모두 할당하는 것은 아니다.&lt;br /&gt;
&lt;br /&gt;
== 익명 매핑과 지연 할당 ==&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
#include &amp;amp;lt;stdio.h&amp;amp;gt;&lt;br /&gt;
#include &amp;amp;lt;sys/mman.h&amp;amp;gt;&lt;br /&gt;
#include &amp;amp;lt;unistd.h&amp;amp;gt;&lt;br /&gt;
&lt;br /&gt;
int main(void) {&lt;br /&gt;
    long n = sysconf(_SC_PAGESIZE);&lt;br /&gt;
    if (n &amp;amp;lt;= 0) return 1;&lt;br /&gt;
    unsigned char *p = mmap(NULL, (size_t)n, PROT_READ | PROT_WRITE,&lt;br /&gt;
                            MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);&lt;br /&gt;
    if (p == MAP_FAILED) return 1;&lt;br /&gt;
    printf(&amp;quot;%u\n&amp;quot;, (unsigned)p[0]);&lt;br /&gt;
    p[0] = 65;&lt;br /&gt;
    printf(&amp;quot;%u\n&amp;quot;, (unsigned)p[0]);&lt;br /&gt;
    return munmap(p, (size_t)n) == -1;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
출력은 0과 65다. 파일 디스크립터는 -1, 오프셋은 0이며, &amp;lt;code&amp;gt;MAP_ANONYMOUS&amp;lt;/code&amp;gt;가 파일을 사용하지 않는 매핑임을 나타낸다. 여기서는 작은 새 매핑의 기본 페이지 경로를 따라간다. 큰 페이지, 미리 페이지를 채우는 옵션, 사용자 공간 폴트 처리기는 사용하지 않는다.&lt;br /&gt;
&lt;br /&gt;
공통 설정 경로의 &amp;lt;code&amp;gt;__mmap_region()&amp;lt;/code&amp;gt;은 이 구간에 &amp;lt;code&amp;gt;vma_set_anonymous()&amp;lt;/code&amp;gt;를 적용한다. VMA는 읽기와 쓰기를 허용하지만, 처음에는 해당 주소의 PTE가 없을 수 있다. 이처럼 주소 공간의 확보와 물리 페이지의 준비를 분리하면, 프로그램이 예약만 하고 쓰지 않는 구간에 RAM을 낭비하지 않을 수 있다.&amp;lt;ref name=&amp;quot;mmap&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/mm/mmap.c?h=v6.12 Linux v6.12, mm/mmap.c], __mmap_region의 익명 매핑 분기.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 첫 읽기와 0 페이지 ==&lt;br /&gt;
첫 읽기에서 PTE가 없으면 앞 장의 아키텍처별 페이지 폴트 진입을 거쳐 다음 공통 경로로 들어온다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
읽기 -&amp;gt; 페이지 폴트 -&amp;gt; handle_mm_fault&lt;br /&gt;
  -&amp;gt; handle_pte_fault -&amp;gt; do_pte_missing -&amp;gt; do_anonymous_page&lt;br /&gt;
  -&amp;gt; 읽기 전용 0 페이지를 가리키는 PTE&lt;br /&gt;
  -&amp;gt; 같은 읽기 명령 재시도 -&amp;gt; 0&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;do_anonymous_page()&amp;lt;/code&amp;gt;는 쓰기 폴트가 아니고 해당 주소 공간에서 0 페이지를 허용하면, 이미 0으로 채워진 공용 페이지를 읽기 전용으로 연결한다. 여러 주소가 같은 0 페이지를 읽어도 관찰하는 값이 모두 0이므로 문제가 없다. 이때 각 주소를 위해 전용 데이터 페이지를 하나씩 만들 필요가 없다.&amp;lt;ref name=&amp;quot;memory&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/mm/memory.c?h=v6.12 Linux v6.12, mm/memory.c], do_anonymous_page, do_wp_page, wp_page_copy.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
VMA: 읽기/쓰기 허용&lt;br /&gt;
&lt;br /&gt;
가상 페이지 A -- 읽기 전용 PTE --+&lt;br /&gt;
                               +- 공용 0 페이지&lt;br /&gt;
가상 페이지 B -- 읽기 전용 PTE --+&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
VMA가 쓰기를 허용해도 PTE는 읽기 전용이다. CPU가 직접 공용 0 페이지를 바꾸지 못하게 하고, 실제 쓰기를 커널이 한 번 받아 처리하기 위해서다. 주소 범위의 정책과 현재 페이지 테이블의 권한이 다른 이유가 여기서 드러난다.&lt;br /&gt;
&lt;br /&gt;
== 첫 쓰기와 전용 페이지 ==&lt;br /&gt;
0 페이지를 읽은 뒤 &amp;lt;code&amp;gt;p[0] = 65&amp;lt;/code&amp;gt;를 실행하면, CPU는 읽기 전용 PTE에 대한 쓰기로 페이지 폴트를 일으킨다. VMA는 쓰기를 허용하므로 커널은 잘못된 접근으로 종료하지 않고, 그 주소에 전용 익명 페이지를 마련한다. &amp;lt;code&amp;gt;do_wp_page()&amp;lt;/code&amp;gt;에서 &amp;lt;code&amp;gt;wp_page_copy()&amp;lt;/code&amp;gt;로 이어지는 경로는 원본이 0 페이지인 경우 0으로 채운 새 페이지를 사용할 수 있다. 새 PTE를 쓰기 가능하게 연결한 뒤 같은 store를 재시도하면 65가 저장된다.&amp;lt;ref name=&amp;quot;memory&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
쓰기 전: p -- 읽기 전용 -- 공용 0 페이지&lt;br /&gt;
쓰기 후: p -- 읽기/쓰기 -- 전용 익명 페이지 [65, 0, 0, ...]&lt;br /&gt;
                           공용 0 페이지는 그대로 유지&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
처음부터 읽지 않고 쓰면 경로가 조금 다르다. PTE가 없는 쓰기 폴트는 &amp;lt;code&amp;gt;do_anonymous_page()&amp;lt;/code&amp;gt; 안에서 전용 페이지를 할당하고 초기화한다. 0 페이지를 먼저 연결했다가 다시 폴트를 일으킬 필요는 없다. 어느 경우든 새로 쓰는 바이트 외의 내용은 0으로 보여야 한다.&amp;lt;ref name=&amp;quot;memory&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== fork와 쓰기 시 복사 ==&lt;br /&gt;
&amp;lt;code&amp;gt;fork()&amp;lt;/code&amp;gt; 뒤 부모와 자식은 서로 독립된 주소 공간을 갖는다. 그러나 이미 준비된 private 익명 페이지를 처음부터 전부 복사할 필요는 없다. Linux는 COW(Copy-on-Write, 쓰기 시 복사)를 적용할 페이지의 부모와 자식의 PTE를 읽기 전용으로 만들고, 당장은 같은 물리 페이지를 가리키게 할 수 있다.&amp;lt;ref name=&amp;quot;fork&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/kernel/fork.c?h=v6.12 Linux v6.12, kernel/fork.c], dup_mmap과 copy_page_range 호출.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;copy&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/mm/memory.c?h=v6.12 Linux v6.12, mm/memory.c], copy_page_range, copy_present_ptes, __copy_present_ptes, do_wp_page.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
fork 직후                          자식의 쓰기 후&lt;br /&gt;
부모 PTE -- R --+                 부모 PTE -- R  -- 원래 페이지&lt;br /&gt;
                +- 원래 페이지&lt;br /&gt;
자식 PTE -- R --+                 자식 PTE -- RW -- 복사한 페이지&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
자식이 쓰면 보호 폴트가 발생한다. 커널은 VMA가 허용한 private 쓰기임을 확인하고, 원본 내용을 새 익명 페이지에 복사한 뒤 자식의 PTE만 교체한다. 부모는 원래 내용을 계속 본다. 이후 더는 다른 매핑과 공유하지 않아 페이지를 독점적으로 재사용할 수 있는 경우에는, 복사 없이 쓰기 권한을 회복하는 경로도 있다. COW는 독립된 내용을 보장하는 데 필요한 시점까지 복사를 미루는 방식이다.&amp;lt;ref name=&amp;quot;memory&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
복사를 미루면 &amp;lt;code&amp;gt;fork()&amp;lt;/code&amp;gt; 직후 &amp;lt;code&amp;gt;execve()&amp;lt;/code&amp;gt;로 주소 공간을 바꾸는 자식이나, 대부분 읽기만 하는 프로세스에 유리하다. 대신 첫 쓰기의 폴트, 필요한 페이지 복사, PTE 갱신 비용이 생긴다. 두 프로세스가 나중에 모두 쓰면 결국 각각의 물리 페이지가 필요하다.&lt;br /&gt;
&lt;br /&gt;
== 공유 익명 매핑 ==&lt;br /&gt;
&amp;lt;code&amp;gt;MAP_SHARED | MAP_ANONYMOUS&amp;lt;/code&amp;gt;는 이름 있는 사용자 파일 없이 공유할 메모리 구간을 만든다. 예를 들어 매핑을 만든 뒤 &amp;lt;code&amp;gt;fork()&amp;lt;/code&amp;gt;한 부모와 자식은 같은 구간의 변경을 공유한다.&lt;br /&gt;
&lt;br /&gt;
Linux는 이 경우 &amp;lt;code&amp;gt;shmem_zero_setup()&amp;lt;/code&amp;gt;으로 내부 shmem 객체를 연결한다. 공유 익명 매핑은 이 객체의 폴트 처리 경로를 사용한다. 앞 절의 공용 0 페이지와 private COW 설명은 private anonymous 경로에 해당한다.&amp;lt;ref name=&amp;quot;mmap&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;shmem&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/mm/shmem.c?h=v6.12 Linux v6.12, mm/shmem.c], shmem_zero_setup과 shmem_fault.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
스레드나 프로세스 사이의 실행 순서는 별도로 동기화해야 한다. 읽기와 쓰기를 조정하는 락과 원자 연산 등은 [[운영체제 기본/동시성|동시성]]에서 다룬다.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br&amp;gt;[[운영체제 기본/Linux/메모리 매핑/페이지 폴트 처리|페이지 폴트 처리]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/메모리 매핑|메모리 매핑 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br&amp;gt;[[운영체제 기본/Linux/메모리 매핑/파일 매핑과 COW|파일 매핑과 COW]]&lt;br /&gt;
}}&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%ED%8C%8C%EC%9D%BC%EC%8B%9C%EC%8A%A4%ED%85%9C/ext4%EC%9D%98_%ED%8C%8C%EC%9D%BC_%EC%9D%BD%EA%B8%B0&amp;diff=696</id>
		<title>운영체제 기본/Linux/파일시스템/ext4의 파일 읽기</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%ED%8C%8C%EC%9D%BC%EC%8B%9C%EC%8A%A4%ED%85%9C/ext4%EC%9D%98_%ED%8C%8C%EC%9D%BC_%EC%9D%BD%EA%B8%B0&amp;diff=696"/>
		<updated>2026-11-15T06:07:48Z</updated>

		<summary type="html">&lt;p&gt;관리자: 반복 대조와 과도한 주의 표현 정리, ASCII 흐름도 통일&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=&amp;lt;- 이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/파일시스템/VFS와 파일 객체|VFS와 파일 객체]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/파일시스템|파일시스템 목차]]&lt;br /&gt;
|다음=다음 문서 -&amp;gt;&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/파일시스템/procfs의 파일 읽기|procfs의 파일 읽기]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
Linux v6.12의 ext4 버퍼드 읽기는 공통 페이지 캐시를 사용한다. 파일 데이터를 장치에서 가져와야 하면 ext4의 블록 매핑 경로로 연결된다. 먼저 디스크의 메타데이터와 디렉터리 구조를 살펴보고, 파일을 연 뒤의 버퍼드 읽기 경로를 따라간다. DAX 파일과 &amp;lt;code&amp;gt;O_DIRECT&amp;lt;/code&amp;gt; 읽기는 다른 경로로 분기하므로 여기서 설명하는 페이지 캐시 경로와 구별해야 한다.&lt;br /&gt;
&lt;br /&gt;
이름과 inode, 논리 블록과 물리 블록의 구분은 [[운영체제 기본/파일과 입출력|파일과 입출력]]에서 이어진다.&lt;br /&gt;
&lt;br /&gt;
== ext4의 메타데이터와 데이터 위치 ==&lt;br /&gt;
&lt;br /&gt;
ext4는 저장 공간을 블록 그룹으로 나눈다. superblock은 블록 크기, 그룹당 inode 수, 지원 기능처럼 파일시스템 전체를 해석하는 정보를 담는다. 각 그룹의 group descriptor는 해당 그룹의 블록 비트맵, inode 비트맵, inode 테이블이 어디에 있는지 기록한다. 비트맵은 할당 상태를 표시하고, inode 테이블은 파일과 디렉터리의 inode 레코드를 저장한다.&amp;lt;ref name=&amp;quot;ext4-layout-doc&amp;quot;&amp;gt;[https://docs.kernel.org/6.12/filesystems/ext4/overview.html Linux v6.12 ext4 문서, High Level Design] 및 [https://docs.kernel.org/6.12/filesystems/ext4/blockgroup.html Block Group Layout].&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;ext4-layout-source&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/ext4/ext4.h?h=v6.12 Linux v6.12 fs/ext4/ext4.h]의 ext4_group_desc, ext4_dir_entry_2.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
[ superblock: block size, inodes per group, features ]&lt;br /&gt;
                         |&lt;br /&gt;
                         v&lt;br /&gt;
             [ group descriptor table ]&lt;br /&gt;
                         |&lt;br /&gt;
                [ descriptor for g ]&lt;br /&gt;
                 /       |        \&lt;br /&gt;
                v        v         v&lt;br /&gt;
       [ block bitmap ]  |   [ inode table ]&lt;br /&gt;
                         v          |&lt;br /&gt;
                 [ inode bitmap ]   | block mapping&lt;br /&gt;
                                    v&lt;br /&gt;
                         [ directory / file blocks ]&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이 그림은 메타데이터 사이의 참조 관계를 나타낸다. &amp;lt;code&amp;gt;flex_bg&amp;lt;/code&amp;gt;가 활성화되면 여러 그룹의 비트맵과 inode 테이블을 함께 배치할 수 있다. inode 테이블의 위치는 group descriptor의 주소 필드로 찾는다. &amp;lt;ref name=&amp;quot;ext4-layout-doc&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;ext4-layout-source&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
inode 번호도 블록 주소와 다르다. inode 번호가 &amp;lt;code&amp;gt;n&amp;lt;/code&amp;gt;이면 그룹 번호는 &amp;lt;code&amp;gt;(n - 1) / s_inodes_per_group&amp;lt;/code&amp;gt;의 정수 몫이고, 그룹 내 inode 슬롯 번호는 그 나머지다. 해당 그룹의 inode 테이블 시작 위치와 inode 레코드 크기인 &amp;lt;code&amp;gt;s_inode_size&amp;lt;/code&amp;gt;를 이용하면 디스크의 레코드를 찾을 수 있다. &amp;lt;ref name=&amp;quot;ext4-inode-layout-doc&amp;quot;&amp;gt;[https://docs.kernel.org/6.12/filesystems/ext4/inodes.html Linux v6.12 ext4 문서, Index Nodes].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== /home/ldmsys 경로와 inode 탐색 ==&lt;br /&gt;
디렉터리도 inode와 내용을 가진 파일이다. 그 내용은 이름과 inode 번호를 연결하는 디렉터리 엔트리다. 다음은 &amp;lt;code&amp;gt;/home/ldmsys/a.txt&amp;lt;/code&amp;gt;를 찾는 관계다. 모두 같은 ext4 파일시스템 안에 있고 심볼릭 링크가 없는 경우를 가정한다. 실제 조회에서는 VFS의 이름 캐시를 활용하여 장치 읽기를 줄일 수 있다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
/                  directory: &amp;quot;home&amp;quot;   -&amp;gt; inode of /home&lt;br /&gt;
/home              directory: &amp;quot;ldmsys&amp;quot; -&amp;gt; inode D&lt;br /&gt;
                                           |&lt;br /&gt;
                                           v&lt;br /&gt;
                                [ inode D: /home/ldmsys ]&lt;br /&gt;
                                           |&lt;br /&gt;
                                  directory block mapping&lt;br /&gt;
                                           |&lt;br /&gt;
                                           v&lt;br /&gt;
                           [ directory data block ]&lt;br /&gt;
                             &amp;quot;.&amp;quot;     -&amp;gt; D&lt;br /&gt;
                             &amp;quot;..&amp;quot;    -&amp;gt; inode of /home&lt;br /&gt;
                             &amp;quot;a.txt&amp;quot; -&amp;gt; F ----------------+&lt;br /&gt;
                                                        |&lt;br /&gt;
                                                        v&lt;br /&gt;
                                              [ inode F: a.txt ]&lt;br /&gt;
                                              size, mode, owner&lt;br /&gt;
                                                        |&lt;br /&gt;
                                              i_block: extents&lt;br /&gt;
                                              or extent tree&lt;br /&gt;
                                                        |&lt;br /&gt;
                                              logical -&amp;gt; physical&lt;br /&gt;
                                                        |&lt;br /&gt;
                                                        v&lt;br /&gt;
                                              [ file data blocks ]&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
여기서 D와 F는 설명용 inode 번호다. 엔트리의 inode 번호로 파일 inode를 찾고, 그 inode의 블록 매핑을 따라 파일 내용을 찾는다. extent를 사용하는 일반적인 외부 블록 저장 형태를 그렸으며, 작은 데이터를 inode 내부에 보관하는 inline data는 다른 형태다.&amp;lt;ref name=&amp;quot;ext4-directory-doc&amp;quot;&amp;gt;[https://docs.kernel.org/6.12/filesystems/ext4/directory.html Linux v6.12 ext4 문서, Directory Entries].&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;ext4-metadata-ifork-doc&amp;quot;&amp;gt;[https://docs.kernel.org/6.12/filesystems/ext4/ifork.html Linux v6.12 ext4 문서, The Contents of inode.i_block].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;filetype&amp;lt;/code&amp;gt; 기능을 사용하는 보통의 디렉터리 엔트리는 &amp;lt;code&amp;gt;ext4_dir_entry_2&amp;lt;/code&amp;gt; 형식이다. 고정 헤더 뒤에 실제 이름 바이트가 오며, 다음 엔트리의 위치는 &amp;lt;code&amp;gt;rec_len&amp;lt;/code&amp;gt;으로 계산한다.&amp;lt;ref name=&amp;quot;ext4-directory-doc&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;ext4-layout-source&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
One directory entry (offsets in bytes)&lt;br /&gt;
&lt;br /&gt;
+0           +4        +6        +7         +8&lt;br /&gt;
|            |         |         |          |&lt;br /&gt;
v            v         v         v          v&lt;br /&gt;
+------------+---------+---------+----------+-----------+---------+&lt;br /&gt;
| inode      | rec_len | name_len| file_type| name      | padding |&lt;br /&gt;
| 4 bytes    | 2 bytes | 1 byte  | 1 byte   |           | / slack |&lt;br /&gt;
+------------+---------+---------+----------+-----------+---------+&lt;br /&gt;
|&amp;lt;------------------------- rec_len ----------------------------&amp;gt;|&lt;br /&gt;
                                                                next&lt;br /&gt;
&lt;br /&gt;
&amp;quot;a.txt&amp;quot;: inode=F, rec_len=16, name_len=5, file_type=1&lt;br /&gt;
&lt;br /&gt;
[ header: 8 bytes ][ a . t x t ][ padding: 3 bytes ] -&amp;gt; next entry&lt;br /&gt;
&lt;br /&gt;
Directory leaf block:&lt;br /&gt;
[ entry ][ entry ][ entry ... ][ final entry + slack ][ tail* ]&lt;br /&gt;
  +------&amp;gt; +------&amp;gt;              rec_len&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
그림의 &amp;lt;code&amp;gt;tail*&amp;lt;/code&amp;gt;은 메타데이터 체크섬을 사용할 때 리프 블록 끝에 붙는 체크섬 꼬리 레코드다. &amp;lt;code&amp;gt;name_len&amp;lt;/code&amp;gt;은 파일 이름의 바이트 수다. 이름 뒤의 널 문자는 요구하지 않는다. &amp;lt;code&amp;gt;rec_len&amp;lt;/code&amp;gt;은 헤더, 이름, 정렬 패딩과 추가 여유 공간을 포함하는 레코드 길이로 4바이트 단위다. 따라서 같은 이름이라도 &amp;lt;code&amp;gt;rec_len&amp;lt;/code&amp;gt;은 더 클 수 있고, 위의 16은 가능한 짧은 예일 뿐이다. 엔트리는 블록 경계를 넘지 않는다. &amp;lt;code&amp;gt;file_type = 1&amp;lt;/code&amp;gt;은 일반 파일, &amp;lt;code&amp;gt;2&amp;lt;/code&amp;gt;는 디렉터리를 나타낸다.&amp;lt;ref name=&amp;quot;ext4-directory-doc&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
큰 디렉터리는 이름의 해시로 탐색 범위를 좁히는 htree 인덱스를 사용할 수 있다. 이 경우 모든 블록을 위와 같은 단순 엔트리 배열로 해석하지 않으며, 인덱스를 통해 도착한 리프 블록에서 실제 이름과 inode 번호를 확인한다. 어느 방식이든 이름 조회가 파일 inode로 연결된 뒤에는 이 문서의 읽기 경로를 따라 파일 내용에 접근한다.&amp;lt;ref name=&amp;quot;ext4-directory-doc&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== VFS와 ext4 읽기 경로 ==&lt;br /&gt;
ext4는 블록 장치에 파일의 내용과 메타데이터를 저장하는 파일시스템이다. inode는 파일의 크기, 종류와 데이터 위치를 관리하는 파일별 객체다. 경로를 찾아 파일을 여는 과정이 끝나면, VFS의 열린 파일 객체인 &amp;lt;code&amp;gt;struct file&amp;lt;/code&amp;gt;이 해당 inode와 파일 연산을 가리킨다. 파일 디스크립터가 이 객체로 이어지는 과정은 [[운영체제 기본/Linux/파일시스템/VFS와 파일 객체|VFS와 파일 객체]]에서 다룬다.&lt;br /&gt;
&lt;br /&gt;
ext4 일반 파일의 &amp;lt;code&amp;gt;ext4_file_operations&amp;lt;/code&amp;gt;에는 다음 읽기 함수가 등록되어 있다.&amp;lt;ref name=&amp;quot;ext4-file&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/ext4/file.c?h=v6.12 Linux v6.12 fs/ext4/file.c]의 ext4_file_operations, ext4_file_read_iter, ext4_file_mmap, ext4_file_vm_ops.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
.read_iter = ext4_file_read_iter,&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;ext4_file_read_iter()&amp;lt;/code&amp;gt;는 DAX와 직접 입출력 분기를 제외한 읽기를 &amp;lt;code&amp;gt;generic_file_read_iter()&amp;lt;/code&amp;gt;에 맡긴다. 이 함수는 공통 버퍼드 읽기 함수인 &amp;lt;code&amp;gt;filemap_read()&amp;lt;/code&amp;gt;로 이어진다. 파일시스템별 진입점과 실제 데이터 입출력 사이에 공통 페이지 캐시 계층이 있는 구조다.&amp;lt;ref name=&amp;quot;ext4-file&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;ext4-filemap&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/mm/filemap.c?h=v6.12 Linux v6.12 mm/filemap.c]의 generic_file_read_iter, filemap_read, filemap_get_pages, filemap_fault.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 페이지 캐시 조회와 데이터 적재 ==&lt;br /&gt;
페이지 캐시는 파일 내용의 일부를 메모리에 보관한다. &amp;lt;code&amp;gt;filemap_read()&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;file-&amp;gt;f_mapping&amp;lt;/code&amp;gt;으로 접근하는 캐시에서 읽을 범위를 확보한다. 요청한 내용이 이미 준비되어 있으면 해당 데이터를 사용자 버퍼로 복사하며, 그 데이터를 얻기 위한 장치 읽기는 필요하지 않다. 캐시를 관리하는 메모리 단위인 folio의 상태와 검색 방식은 [[운영체제 기본/Linux/파일시스템/페이지 캐시|페이지 캐시]]에서 설명한다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;filemap_get_pages()&amp;lt;/code&amp;gt;는 먼저 동기 선행 읽기를 시도할 수 있다. 선행 읽기인 readahead는 요청 범위와 이어질 것으로 예상되는 범위를 미리 읽는 동작이다. 이미 캐시에 있지만 읽기 작업이 진행 중이라면 완료를 기다릴 수도 있다. 필요한 데이터가 여전히 준비되지 않은 경우에는 단일 folio 읽기 경로를 사용한다. 캐시 적중 중에도 선행 읽기 표시를 만나면 뒤쪽 범위에 대한 추가 읽기를 시작할 수 있다.&amp;lt;ref name=&amp;quot;ext4-filemap&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
공통 계층은 inode의 캐시 매핑에 연결된 &amp;lt;code&amp;gt;address_space_operations&amp;lt;/code&amp;gt;, 즉 &amp;lt;code&amp;gt;a_ops&amp;lt;/code&amp;gt;를 통해 ext4에 데이터 공급을 요청한다. ext4는 &amp;lt;code&amp;gt;read_folio&amp;lt;/code&amp;gt;에 &amp;lt;code&amp;gt;ext4_read_folio()&amp;lt;/code&amp;gt;를, &amp;lt;code&amp;gt;readahead&amp;lt;/code&amp;gt;에 &amp;lt;code&amp;gt;ext4_readahead()&amp;lt;/code&amp;gt;를 등록한다. 일반적인 외부 데이터 블록의 읽기에서는 두 함수 모두 &amp;lt;code&amp;gt;ext4_mpage_readpages()&amp;lt;/code&amp;gt;로 이어진다. 작은 파일의 내용을 inode 안에 담는 inline data는 별도 처리되므로 이 블록 읽기 흐름을 그대로 적용하지 않는다.&amp;lt;ref name=&amp;quot;ext4-inode&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/ext4/inode.c?h=v6.12 Linux v6.12 fs/ext4/inode.c]의 ext4_read_folio, ext4_readahead, address_space_operations 정의, ext4_map_blocks.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 파일 논리 블록과 장치 블록의 매핑 ==&lt;br /&gt;
ext4는 파일 안의 논리 블록 번호를 장치상의 물리 블록 번호로 변환해야 한다. extent는 연속된 논리 블록 구간과 그에 대응하는 연속된 물리 블록 구간을 묶어 표현하는 매핑이다. 블록마다 주소를 하나씩 기록하는 대신 구간 단위로 위치를 나타낸다. extent를 사용하는 파일에서는 이 정보가 extent 트리로 관리된다.&amp;lt;ref name=&amp;quot;ext4-extents&amp;quot;&amp;gt;[https://docs.kernel.org/6.12/filesystems/ext4/ifork.html Linux v6.12 ext4 문서, The Contents of inode.i_block]의 Extent Tree.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;ext4_mpage_readpages()&amp;lt;/code&amp;gt;는 이미 얻은 매핑을 재사용하거나 &amp;lt;code&amp;gt;ext4_map_blocks(NULL, inode, &amp;amp;amp;map, 0)&amp;lt;/code&amp;gt;을 호출해 읽을 블록의 위치를 조회한다. 이 호출은 블록을 할당하지 않고 기존 매핑을 조회한다. 조회에는 메모리에 보관된 매핑 정보를 활용할 수 있다.&amp;lt;ref name=&amp;quot;ext4-inode&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
read()&lt;br /&gt;
  -&amp;gt; VFS -&amp;gt; ext4_file_read_iter()&lt;br /&gt;
  -&amp;gt; generic_file_read_iter() -&amp;gt; filemap_read()&lt;br /&gt;
      +- 준비된 캐시 데이터 -&amp;gt; 사용자 버퍼로 복사&lt;br /&gt;
      +- 데이터 준비 필요&lt;br /&gt;
          -&amp;gt; a_ops의 readahead 또는 read_folio&lt;br /&gt;
          -&amp;gt; ext4_readahead() 또는 ext4_read_folio()&lt;br /&gt;
          -&amp;gt; ext4_mpage_readpages()&lt;br /&gt;
          -&amp;gt; ext4_map_blocks()로 위치 조회 또는 기존 매핑 재사용&lt;br /&gt;
          -&amp;gt; bio 구성 -&amp;gt; submit_bio() -&amp;gt; 블록 계층 -&amp;gt; 저장 장치&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
bio는 읽을 장치 위치와 데이터를 받을 메모리 범위를 묶는 블록 입출력 요청이다. ext4는 가능한 연속 구간을 묶어 &amp;lt;code&amp;gt;submit_bio()&amp;lt;/code&amp;gt;로 제출한다. 반면 hole은 파일의 논리 범위에 실제 데이터 블록이 없는 구간이므로 0으로 채운다. 전부 hole인 folio는 데이터 블록을 읽지 않고 완료될 수 있다. 블록 배치가 이 경로에서 묶기 어려운 경우에는 &amp;lt;code&amp;gt;block_read_full_folio()&amp;lt;/code&amp;gt;로 내려가는 보조 경로도 있다.&amp;lt;ref name=&amp;quot;ext4-readpage&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/ext4/readpage.c?h=v6.12 Linux v6.12 fs/ext4/readpage.c]의 ext4_mpage_readpages, mpage_end_io, __read_end_io.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 읽기 완료와 mmap의 연결 ==&lt;br /&gt;
&lt;br /&gt;
장치 읽기가 끝나면 bio의 완료 함수인 &amp;lt;code&amp;gt;mpage_end_io()&amp;lt;/code&amp;gt;가 실행된다. 필요한 후처리가 없다면 &amp;lt;code&amp;gt;__read_end_io()&amp;lt;/code&amp;gt;가 곧바로 &amp;lt;code&amp;gt;folio_end_read()&amp;lt;/code&amp;gt;를 호출해 성공 여부를 반영하고 대기자를 깨운다. 캐시의 데이터는 읽기와 필요한 후처리가 성공적으로 끝난 뒤 사용할 수 있다.&amp;lt;ref name=&amp;quot;ext4-readpage&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
준비된 데이터는 &amp;lt;code&amp;gt;filemap_read()&amp;lt;/code&amp;gt;의 &amp;lt;code&amp;gt;copy_folio_to_iter()&amp;lt;/code&amp;gt;를 통해 읽기 대상 버퍼로 복사된다. 공통 계층은 읽은 만큼 위치를 진행시키고 바이트 수를 반환한다. EOF에서는 요청량보다 적게 읽거나 0을 반환할 수 있으며, 장치 오류가 있으면 정상 데이터처럼 취급하지 않는다.&amp;lt;ref name=&amp;quot;ext4-filemap&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
일반 ext4 파일을 &amp;lt;code&amp;gt;mmap()&amp;lt;/code&amp;gt;으로 읽을 때도 같은 파일의 페이지 캐시를 이용한다. 다만 사용자 버퍼로 복사하는 대신 페이지 폴트를 처리하며 파일 데이터를 프로세스의 주소 공간에 매핑한다. ext4는 매핑 연산에 &amp;lt;code&amp;gt;ext4_file_mmap()&amp;lt;/code&amp;gt;을 등록하며, 비 DAX 경로에서 &amp;lt;code&amp;gt;ext4_file_vm_ops&amp;lt;/code&amp;gt;를 설치한다. 이 연산표의 &amp;lt;code&amp;gt;.fault = filemap_fault&amp;lt;/code&amp;gt;가 공통 캐시 폴트 처리로 연결된다. &amp;lt;code&amp;gt;read()&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;mmap()&amp;lt;/code&amp;gt;의 진입점은 달라도 파일 내용의 캐시는 공유한다.&amp;lt;ref name=&amp;quot;ext4-file&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=&amp;lt;- 이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/파일시스템/VFS와 파일 객체|VFS와 파일 객체]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/파일시스템|파일시스템 목차]]&lt;br /&gt;
|다음=다음 문서 -&amp;gt;&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/파일시스템/procfs의 파일 읽기|procfs의 파일 읽기]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/BIOS_%EB%B6%80%ED%8C%85/%EC%BB%A4%EB%84%90_%EC%B4%88%EA%B8%B0%ED%99%94&amp;diff=695</id>
		<title>운영체제 기본/Linux/x86-64/BIOS 부팅/커널 초기화</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/BIOS_%EB%B6%80%ED%8C%85/%EC%BB%A4%EB%84%90_%EC%B4%88%EA%B8%B0%ED%99%94&amp;diff=695"/>
		<updated>2026-11-15T06:07:42Z</updated>

		<summary type="html">&lt;p&gt;관리자: 문체 정리: 반복 대조와 강조, 특수문자 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/GDT와 LDT 초기화|GDT와 LDT 초기화]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/x86-64/BIOS 부팅|BIOS 부팅 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/PID 1 생성|PID 1 생성]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
압축 해제기가 커널 본체로 분기했을 때 CPU는 이미 64비트 모드에서 페이징을 사용한다. 그러나 그때의 스택, 주소 공간, 예외 처리기는 압축 해제를 위한 임시 환경이다. 본체는 자신의 실행 기반을 세운 뒤, 메모리 관리, 스케줄러, 인터럽트, VFS처럼 다른 기능의 전제가 되는 하위 시스템을 순서대로 준비한다. 이 장은 Linux v6.12, BIOS로 부팅한 x86-64 부트 CPU가 &amp;lt;code&amp;gt;arch/x86/kernel/head_64.S:startup_64&amp;lt;/code&amp;gt;에서 &amp;lt;code&amp;gt;rest_init()&amp;lt;/code&amp;gt;까지 진행하는 경로를 다룬다.&lt;br /&gt;
&lt;br /&gt;
== 커널 본체의 실행 환경 ==&lt;br /&gt;
본체 진입 시 &amp;lt;code&amp;gt;RSI&amp;lt;/code&amp;gt;에는 부트 정보의 물리 주소가 있다. &amp;lt;code&amp;gt;startup_64&amp;lt;/code&amp;gt;는 이를 &amp;lt;code&amp;gt;R15&amp;lt;/code&amp;gt;에 보존하고, 본체의 초기 커널 스택을 사용하도록 &amp;lt;code&amp;gt;RSP&amp;lt;/code&amp;gt;를 바꾼다. C 함수 호출과 반환에는 스택이 필요하므로, 압축 해제기가 사용하던 스택을 그대로 계속 쓰지 않고 본체의 스택으로 옮기는 것이다. 이어 &amp;lt;code&amp;gt;startup_64_setup_gdt_idt()&amp;lt;/code&amp;gt;로 초기 GDT와 IDT를 준비하고 CPU 상태를 확인한다.&amp;lt;ref name=&amp;quot;head&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/kernel/head_64.S?h=v6.12 Linux v6.12, arch/x86/kernel/head_64.S], startup_64, common_startup_64, initial_code.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이때 준비하는 것은 초기 코드에 필요한 GDT와 IDT다. IDT는 CPU 예외나 인터럽트가 발생했을 때 어느 처리 코드로 들어갈지를 지정한다. 아직 일반적인 인터럽트 처리 환경이 완성되지 않았으므로, 본체는 이 단계에서 사용할 수 있는 초기 예외 처리 경로부터 마련한다.&amp;lt;ref name=&amp;quot;headc&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/kernel/head64.c?h=v6.12 Linux v6.12, arch/x86/kernel/head64.c], __startup_64, x86_64_start_kernel, x86_64_start_reservations 및 bringup IDT 주석.&amp;lt;/ref&amp;gt; 디스크립터의 교체 과정은 [[운영체제 기본/Linux/x86-64/BIOS 부팅/GDT와 LDT 초기화|GDT와 LDT 초기화]], IDT가 진입점을 선택하는 원리는 [[운영체제 기본/장치 제어와 입출력#처리 진입점과 IDT|장치 제어와 입출력]]에서 연결해 볼 수 있다.&lt;br /&gt;
&lt;br /&gt;
== 물리 적재 위치와 가상 주소 매핑 ==&lt;br /&gt;
압축 해제기는 커널을 사용할 수 있는 물리 메모리에 배치했다. 반면 커널 심볼은 링크 시점의 가상 주소를 갖는다. 본체의 초기 페이지 테이블도 빌드 시점의 배치를 전제로 만들어져 있으므로, 실제 적재 위치가 달라졌다면 그대로 사용할 수 없다. &amp;lt;code&amp;gt;__startup_64(physaddr, boot_params)&amp;lt;/code&amp;gt;는 실제 물리 위치와 링크 시점 기준의 차이인 &amp;lt;code&amp;gt;load_delta&amp;lt;/code&amp;gt;를 구하고, 초기 페이지 테이블에 들어 있는 물리 주소들을 보정한다.&amp;lt;ref name=&amp;quot;headc&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
여기에는 두 종류의 매핑이 함께 필요하다. 하나는 앞으로 사용할 높은 커널 가상 주소를 실제 본체의 물리 메모리에 연결하는 매핑이고, 다른 하나는 페이지 테이블을 교체하는 순간에도 현재 명령어를 계속 실행하기 위한 identity mapping이다. &amp;lt;code&amp;gt;CR3&amp;lt;/code&amp;gt;를 바꾸었다고 현재 RIP가 자동으로 높은 커널 주소로 이동하지 않기 때문이다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
before CR3 switch:&lt;br /&gt;
  current RIP (identity address) -&amp;gt; kernel physical memory&lt;br /&gt;
&lt;br /&gt;
after CR3 switch:&lt;br /&gt;
  current RIP (identity address) -&amp;gt; same physical memory&lt;br /&gt;
  high kernel virtual address   -&amp;gt; same physical memory&lt;br /&gt;
&lt;br /&gt;
jump to common_startup_64:&lt;br /&gt;
  RIP now uses the high kernel virtual address&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;__startup_64()&amp;lt;/code&amp;gt;가 반환하면 어셈블리는 본체의 &amp;lt;code&amp;gt;early_top_pgt&amp;lt;/code&amp;gt;를 가리키는 값을 &amp;lt;code&amp;gt;CR3&amp;lt;/code&amp;gt;에 적재하고, 높은 커널 가상 주소의 &amp;lt;code&amp;gt;common_startup_64&amp;lt;/code&amp;gt;로 분기한다. 보정 대상과 전환용 매핑을 한꺼번에 준비한 뒤 주소 공간을 바꾸는 순서다. 이후에는 전환에만 필요했던 저위 identity mapping을 제거할 수 있다.&amp;lt;ref name=&amp;quot;head&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;headc&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이 과정에서는 같은 커널 실행 흐름을 유지하면서 주소 표현을 바꾼다. 페이지 테이블, 물리 주소, 가상 주소의 관계는 [[운영체제 기본/가상 메모리|가상 메모리]]에서 설명하는 원리와 같다. 여기서는 메모리 관리 코드 자체가 실행될 첫 주소 공간을 만든다.&lt;br /&gt;
&lt;br /&gt;
== 커널 스택과 CPU 상태 설정 ==&lt;br /&gt;
Linux에서 태스크(task)는 스케줄러가 실행을 관리하는 단위다. 사용자 프로그램의 스레드 하나가 태스크 하나에 대응하며, 같은 프로세스의 여러 태스크는 주소 공간과 열린 파일 등을 공유할 수 있다. 커널은 태스크마다 &amp;lt;code&amp;gt;task_struct&amp;lt;/code&amp;gt;를 두어 실행 및 대기 상태와 스케줄링 정보, 스택과 주소 공간 등 필요한 자원을 가리키는 정보를 관리한다. 실행 흐름과 공유 자원의 구분은 [[운영체제 기본/프로세스와 스레드|프로세스와 스레드]]에서 설명한다.&amp;lt;ref name=&amp;quot;task&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/linux/sched.h?h=v6.12 Linux v6.12, include/linux/sched.h], task_struct의 상태 및 스케줄링 정보, stack, mm, files 및 thread.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
사용자 프로그램이 없는 부팅 초기에도 태스크는 있다. 부트 CPU의 실행 흐름은 정적으로 준비된 &amp;lt;code&amp;gt;init_task&amp;lt;/code&amp;gt;와 초기 커널 스택을 사용한다. &amp;lt;code&amp;gt;init_task&amp;lt;/code&amp;gt;는 자신의 사용자 주소 공간 없이 시작하며, 뒤에서 다룰 PID 1과는 별개다. 이 부트 태스크가 &amp;lt;code&amp;gt;rest_init()&amp;lt;/code&amp;gt;에서 새 태스크들을 만든 뒤 idle 태스크로 남는 과정은 [[운영체제 기본/Linux/x86-64/BIOS 부팅/PID 1 생성|PID 1 생성]]에서 이어진다.&amp;lt;ref name=&amp;quot;init-task&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/init/init_task.c?h=v6.12 Linux v6.12, init/init_task.c], init_task의 정적 초기화와 mm, active_mm, stack.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;main&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;common_startup_64&amp;lt;/code&amp;gt;에서는 부트 CPU의 현재 태스크를 기준으로 스택을 설정하고, 커널 가상 주소에서 사용할 GDT와 CPU별 데이터 접근 환경을 준비한다. 초기 스택은 &amp;lt;code&amp;gt;init_task&amp;lt;/code&amp;gt; 실행 흐름과 연결된다. 아직 사용자 프로그램은 없지만, 커널은 현재 태스크와 스택이라는 기본 관계를 갖춘 상태로 다음 초기화에 들어간다.&amp;lt;ref name=&amp;quot;head&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
끝에서는 &amp;lt;code&amp;gt;initial_code&amp;lt;/code&amp;gt;가 가리키는 함수를 호출한다. 부트 CPU에서 그 초기값은 &amp;lt;code&amp;gt;x86_64_start_kernel&amp;lt;/code&amp;gt;이다. 앞서 &amp;lt;code&amp;gt;__startup_64()&amp;lt;/code&amp;gt; 등의 C 함수를 거쳤고, 이 지점에서는 커널 가상 주소와 본체 스택을 사용해 다음 초기화 단계로 넘어간다.&lt;br /&gt;
&lt;br /&gt;
== x86 초기화와 공통 커널 진입 ==&lt;br /&gt;
&amp;lt;code&amp;gt;x86_64_start_kernel()&amp;lt;/code&amp;gt;은 &amp;lt;code&amp;gt;reset_early_page_tables()&amp;lt;/code&amp;gt;로 전환용 identity mapping을 제거하고, &amp;lt;code&amp;gt;clear_bss()&amp;lt;/code&amp;gt;로 본체 BSS와 초기 brk 영역을 0으로 만든다. 압축 해제기가 비운 BSS는 압축 해제기의 전역변수 영역이었고, 지금 비우는 것은 본체의 영역이다.&amp;lt;ref name=&amp;quot;headc&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
그 뒤 초기 예외 처리기를 준비하고 &amp;lt;code&amp;gt;copy_bootdata()&amp;lt;/code&amp;gt;로 로더가 남긴 부트 정보와 명령행을 본체의 저장 공간으로 복사한다. 커널이 정보를 받아들인 뒤에는 로더의 원래 저장 영역을 영구적인 소유물처럼 붙잡고 있을 필요가 없다. 물리 주소로 받은 정보에 접근할 때는 커널의 주소 변환 규칙에 맞게 주소를 바꾼다. 초기 페이지 폴트 처리에서는 필요한 매핑을 만들어 접근을 이어갈 수 있도록 준비되어 있다.&amp;lt;ref name=&amp;quot;headc&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
kernel/head_64.S:startup_64&lt;br /&gt;
  -&amp;gt; __startup_64()&lt;br /&gt;
  -&amp;gt; load CR3, jump to common_startup_64&lt;br /&gt;
  -&amp;gt; call initial_code&lt;br /&gt;
       x86_64_start_kernel()&lt;br /&gt;
         -&amp;gt; reset_early_page_tables()&lt;br /&gt;
         -&amp;gt; clear_bss()&lt;br /&gt;
         -&amp;gt; copy_bootdata()&lt;br /&gt;
         -&amp;gt; x86_64_start_reservations()&lt;br /&gt;
              -&amp;gt; start_kernel()&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;x86_64_start_reservations()&amp;lt;/code&amp;gt;는 필요한 부트 정보가 확보되었는지 확인하고 플랫폼별 초기 처리를 거쳐 공통 코드인 &amp;lt;code&amp;gt;start_kernel()&amp;lt;/code&amp;gt;을 호출한다. 인자 이름 &amp;lt;code&amp;gt;real_mode_data&amp;lt;/code&amp;gt;는 부트 정보를 가리키는 역사적 이름이다. 현재 CPU는 64비트 모드다.&lt;br /&gt;
&lt;br /&gt;
== 초기 메모리 관리 ==&lt;br /&gt;
&amp;lt;code&amp;gt;start_kernel()&amp;lt;/code&amp;gt;은 뒤의 기능이 앞 단계의 결과를 사용할 수 있는 순서로 초기화한다. 먼저 &amp;lt;code&amp;gt;setup_arch()&amp;lt;/code&amp;gt;로 x86의 부트 정보와 메모리 배치 등을 처리하고, per-CPU 영역과 명령행 처리를 진행한다. 이때 마스커블 인터럽트는 여전히 꺼져 있다.&amp;lt;ref name=&amp;quot;main&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/init/main.c?h=v6.12 Linux v6.12, init/main.c], start_kernel, rest_init, kernel_init_freeable.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
초기 부팅에서는 아직 일반 페이지 할당자와 slab 할당자가 모두 준비되지 않았다. 할당자 자체의 자료구조를 준비할 메모리는 별도의 초기 할당 경로로 확보한다. &amp;lt;code&amp;gt;start_kernel()&amp;lt;/code&amp;gt;은 큰 초기 할당을 사용하는 로그 버퍼와 &amp;lt;code&amp;gt;vfs_caches_init_early()&amp;lt;/code&amp;gt;를 먼저 처리한 뒤 &amp;lt;code&amp;gt;mm_core_init()&amp;lt;/code&amp;gt;으로 핵심 메모리 관리 초기화를 진행한다. 소스의 주석도 이 큰 초기 할당들이 페이지 할당자 초기화보다 앞서야 함을 명시한다.&amp;lt;ref name=&amp;quot;main&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
초기 페이지 테이블은 CPU가 코드와 데이터에 접근하게 만든다. 메모리 관리 초기화는 어떤 물리 페이지를 사용할 수 있는지, 누가 어떤 메모리를 소유하는지, 커널 자료구조를 어떤 할당 경로로 제공할지를 갖추는 일이다. &amp;lt;code&amp;gt;kmalloc()&amp;lt;/code&amp;gt;도 관련 할당자의 초기화가 끝난 뒤에 사용할 수 있다.&lt;br /&gt;
&lt;br /&gt;
== 스케줄러와 인터럽트 초기화 순서 ==&lt;br /&gt;
메모리 관리 기반 다음에는 &amp;lt;code&amp;gt;sched_init()&amp;lt;/code&amp;gt;으로 스케줄러를 준비한다. 타이머 인터럽트가 실행 시간을 계산하거나 재스케줄링을 요구하기 전에, 현재 태스크와 실행 큐를 관리할 수 있어야 하기 때문이다. 추가 CPU 준비와 전체 토폴로지 구성은 뒤의 SMP 초기화에서 이어진다.&amp;lt;ref name=&amp;quot;main&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
setup_arch()&lt;br /&gt;
  -&amp;gt; early allocations&lt;br /&gt;
  -&amp;gt; mm_core_init()&lt;br /&gt;
  -&amp;gt; sched_init()&lt;br /&gt;
  -&amp;gt; early_irq_init(), init_IRQ()&lt;br /&gt;
  -&amp;gt; tick / timers / softirq / timekeeping&lt;br /&gt;
  -&amp;gt; local_irq_enable()&lt;br /&gt;
  -&amp;gt; task and VFS infrastructure&lt;br /&gt;
  -&amp;gt; rest_init()&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이어서 IRQ 관리 자료구조와 인터럽트 진입 경로, tick, 타이머, softirq, 시간 계측 기반을 준비한다. 그런 다음에야 &amp;lt;code&amp;gt;local_irq_enable()&amp;lt;/code&amp;gt;로 부트 CPU의 마스커블 인터럽트를 허용한다. 초기 예외를 받을 수 있는 상태와 외부 장치의 인터럽트를 정상 처리할 수 있는 상태를 구별해야 한다. &amp;lt;code&amp;gt;cli&amp;lt;/code&amp;gt; 상태에서도 CPU 예외는 발생할 수 있으므로 앞 단계부터 초기 IDT와 예외 처리가 필요하다.&amp;lt;ref name=&amp;quot;main&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;headc&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
실행 큐와 스케줄링 기반을 준비한 뒤에는 PID 1을 만들고 실행시킨다. 실행 주체와 컨텍스트 스위치의 의미는 [[운영체제 기본/프로세스와 스레드|프로세스와 스레드]]와 연결된다.&lt;br /&gt;
&lt;br /&gt;
== VFS 초기화와 루트 파일시스템 준비 ==&lt;br /&gt;
인터럽트를 허용한 뒤에도 태스크와 파일 시스템에 필요한 기반을 계속 초기화한다. &amp;lt;code&amp;gt;fork_init()&amp;lt;/code&amp;gt;과 &amp;lt;code&amp;gt;proc_caches_init()&amp;lt;/code&amp;gt; 등으로 태스크 생성에 필요한 기반을 갖추고, &amp;lt;code&amp;gt;vfs_caches_init()&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;pagecache_init()&amp;lt;/code&amp;gt; 등으로 경로 탐색과 파일 객체를 다루는 공통 계층을 준비한다. VFS 초기화는 사용할 수 있는 메모리 관리 수준에 따라 &amp;lt;code&amp;gt;vfs_caches_init_early()&amp;lt;/code&amp;gt;와 이 단계로 나뉜다.&amp;lt;ref name=&amp;quot;main&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
VFS는 파일시스템 구현들을 다루는 공통 구조와 인터페이스다. 경로, inode, 열린 파일 객체가 연결되는 방식은 [[운영체제 기본/Linux/파일시스템/VFS와 파일 객체|VFS와 파일 객체]]에서 설명한다. 어떤 파일 시스템을 루트로 사용할지, initramfs 내용을 어떻게 사용할지, 어느 사용자 프로그램을 처음 실행할지는 그 다음 단계에서 결정되고 실행된다.&lt;br /&gt;
&lt;br /&gt;
== 부트 태스크와 태스크 생성 ==&lt;br /&gt;
마지막에 &amp;lt;code&amp;gt;start_kernel()&amp;lt;/code&amp;gt;은 &amp;lt;code&amp;gt;rest_init()&amp;lt;/code&amp;gt;으로 넘어간다. 여기서 PID 1이 될 실행 흐름과 &amp;lt;code&amp;gt;kthreadd&amp;lt;/code&amp;gt;를 만들고, 원래의 부트 실행 흐름은 부트 CPU의 idle 태스크로 정착한다. PID 1의 커널 실행 문맥에서 추가 CPU, initcall, 장치와 파일 시스템 관련 나머지 초기화가 이어진다.&amp;lt;ref name=&amp;quot;main&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
먼저 태스크를 만들고 스케줄링할 최소 기반을 마련한 뒤, 그 태스크가 나머지 부팅 작업을 수행한다. 다음 장의 [[운영체제 기본/Linux/x86-64/BIOS 부팅/PID 1 생성|PID 1 생성]]은 이 경계를 출발점으로 삼는다.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/GDT와 LDT 초기화|GDT와 LDT 초기화]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/x86-64/BIOS 부팅|BIOS 부팅 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/PID 1 생성|PID 1 생성]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%EB%A9%94%EB%AA%A8%EB%A6%AC_%EB%A7%A4%ED%95%91/%ED%8E%98%EC%9D%B4%EC%A7%80_%ED%8F%B4%ED%8A%B8_%EC%B2%98%EB%A6%AC&amp;diff=694</id>
		<title>운영체제 기본/Linux/메모리 매핑/페이지 폴트 처리</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%EB%A9%94%EB%AA%A8%EB%A6%AC_%EB%A7%A4%ED%95%91/%ED%8E%98%EC%9D%B4%EC%A7%80_%ED%8F%B4%ED%8A%B8_%EC%B2%98%EB%A6%AC&amp;diff=694"/>
		<updated>2026-11-15T06:07:31Z</updated>

		<summary type="html">&lt;p&gt;관리자: 문체 정리: 과도한 강조와 반복 대조, 장식 문자 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br&amp;gt;[[운영체제 기본/Linux/메모리 매핑/mmap과 주소 공간|mmap과 주소 공간]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/메모리 매핑|메모리 매핑 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br&amp;gt;[[운영체제 기본/Linux/메모리 매핑/익명 메모리 매핑|익명 메모리 매핑]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;mmap()&amp;lt;/code&amp;gt;으로 만든 VMA는 주소 구간의 의미와 권한을 정한다. 그 주소의 PTE가 아직 없거나 접근에 필요한 권한이 부족하면 CPU가 페이지 폴트(Page Fault)를 발생시킨다. 정상적인 지연 할당과 쓰기 시 복사(Copy-on-Write, COW)도 이 예외를 이용한다.&lt;br /&gt;
&lt;br /&gt;
Linux v6.12의 기본 페이지 경로를 기준으로, CPU 예외 진입과 공통 메모리 관리 코드의 연결을 살펴본다. 실제 페이지를 마련하는 방법은 익명 메모리와 파일 매핑 장에서 이어진다.&lt;br /&gt;
&lt;br /&gt;
== CPU 예외와 VMA 검사 ==&lt;br /&gt;
두 CPU 모두 필요한 주소 변환이 없으면 동기 예외를 일으킨다. 커널은 폴트 주소와 접근 종류를 알아내고, VMA가 그 접근을 허용하는지 검사한 뒤 공통 함수 &amp;lt;code&amp;gt;handle_mm_fault()&amp;lt;/code&amp;gt;에 복구를 요청한다. 예외 진입 경로와 정보의 표현은 아키텍처별이고, VMA와 페이지 테이블을 다루는 핵심 경로는 공통이다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
load bytes[i]&lt;br /&gt;
  |&lt;br /&gt;
  +-- x86-64: #PF -&amp;gt; IDT -&amp;gt; exc_page_fault&lt;br /&gt;
  |             -&amp;gt; handle_page_fault -&amp;gt; do_user_addr_fault&lt;br /&gt;
  |&lt;br /&gt;
  +-- RV64: page fault -&amp;gt; handle_exception&lt;br /&gt;
                 -&amp;gt; do_page_fault -&amp;gt; handle_page_fault&lt;br /&gt;
  |&lt;br /&gt;
  v&lt;br /&gt;
VMA lookup + access check&lt;br /&gt;
  |&lt;br /&gt;
  v&lt;br /&gt;
handle_mm_fault -&amp;gt; 대상별 처리 -&amp;gt; PTE 설정 -&amp;gt; 명령 재시도&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이 예외는 현재 실행한 load에서 동기적으로 발생한다. 두 소스 트리에 &amp;lt;code&amp;gt;handle_page_fault&amp;lt;/code&amp;gt;라는 같은 이름이 등장하지만 서로 다른 아키텍처별 함수다.&lt;br /&gt;
&lt;br /&gt;
=== x86-64: #PF, CR2, 오류 코드 ===&lt;br /&gt;
&lt;br /&gt;
사용 가능한 변환이 없으면 x86-64 CPU는 페이지 폴트 예외 &amp;lt;code&amp;gt;#PF&amp;lt;/code&amp;gt;를 발생시킨다. 예외 벡터는 14이고 폴트 주소는 &amp;lt;code&amp;gt;CR2&amp;lt;/code&amp;gt;에 남는다. CPU가 전달한 오류 코드는 페이지가 존재하지 않는 경우와 보호 위반, 읽기와 쓰기, 사용자 모드 접근 등의 정보를 구별한다. 아직 연결되지 않은 주소의 읽기와, 읽기 전용 PTE에 대한 쓰기는 오류 코드에서 구별된다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
load bytes[i]&lt;br /&gt;
  -&amp;gt; #PF, vector 14, CR2 = 폴트 주소, 오류 코드&lt;br /&gt;
  -&amp;gt; IDT -&amp;gt; asm_exc_page_fault&lt;br /&gt;
  -&amp;gt; exc_page_fault&lt;br /&gt;
  -&amp;gt; handle_page_fault&lt;br /&gt;
  -&amp;gt; do_user_addr_fault&lt;br /&gt;
  -&amp;gt; handle_mm_fault&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
v6.12의 [[운영체제 기본/장치 제어와 입출력#처리 진입점과 IDT|IDT]]는 해당 예외를 &amp;lt;code&amp;gt;asm_exc_page_fault&amp;lt;/code&amp;gt;로 연결한다. C 쪽 &amp;lt;code&amp;gt;exc_page_fault&amp;lt;/code&amp;gt;는 이 진입 경로에서 CR2를 읽고 &amp;lt;code&amp;gt;handle_page_fault()&amp;lt;/code&amp;gt;를 호출한다. 사용자 주소 처리는 &amp;lt;code&amp;gt;do_user_addr_fault()&amp;lt;/code&amp;gt;로 이어진다.&amp;lt;ref name=&amp;quot;idt&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/kernel/idt.c?h=v6.12 Linux v6.12 arch/x86/kernel/idt.c], 페이지 폴트 IDT 항목.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;x86fault&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/mm/fault.c?h=v6.12 Linux v6.12 arch/x86/mm/fault.c], exc_page_fault, handle_page_fault, do_user_addr_fault와 오류 코드 검사.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== RISC-V RV64: scause, stval, sepc ===&lt;br /&gt;
&lt;br /&gt;
RISC-V에서는 &amp;lt;code&amp;gt;stvec&amp;lt;/code&amp;gt;가 지정하는 트랩 진입점으로 제어가 넘어간다. S-mode 커널의 트랩 진입에서 &amp;lt;code&amp;gt;scause&amp;lt;/code&amp;gt;는 원인을, &amp;lt;code&amp;gt;stval&amp;lt;/code&amp;gt;은 페이지 폴트 주소를, &amp;lt;code&amp;gt;sepc&amp;lt;/code&amp;gt;는 중단된 명령의 주소를 제공한다. 페이지 폴트 원인 번호는 명령어 가져오기 12, load 13, store/AMO 15로 나뉜다. 따라서 읽기 접근은 원인 13인 load page fault다. 원인 번호의 형식은 x86의 페이지 폴트 오류 코드 비트와 다르다.&amp;lt;ref name=&amp;quot;rv-csr&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/riscv/include/asm/csr.h?h=v6.12 Linux v6.12 arch/riscv/include/asm/csr.h], EXC_*_PAGE_FAULT, CSR_SCAUSE, CSR_STVAL, CSR_SEPC와 S-mode 별칭.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
load bytes[i]&lt;br /&gt;
  -&amp;gt; load page fault: scause = 13, stval = 폴트 주소, sepc = load 주소&lt;br /&gt;
  -&amp;gt; handle_exception&lt;br /&gt;
  -&amp;gt; excp_vect_table의 load page fault 항목&lt;br /&gt;
  -&amp;gt; do_page_fault                [arch/riscv/kernel/traps.c]&lt;br /&gt;
  -&amp;gt; handle_page_fault            [arch/riscv/mm/fault.c]&lt;br /&gt;
  -&amp;gt; handle_mm_fault              [mm/memory.c]&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;handle_exception&amp;lt;/code&amp;gt;은 트랩 레지스터 값을 &amp;lt;code&amp;gt;pt_regs&amp;lt;/code&amp;gt;의 &amp;lt;code&amp;gt;cause&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;badaddr&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;epc&amp;lt;/code&amp;gt; 등에 저장한다. 예외 표가 선택하는 &amp;lt;code&amp;gt;do_page_fault()&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;handle_page_fault()&amp;lt;/code&amp;gt;를 부른다. 이 함수는 저장된 원인과 주소를 사용하고, &amp;lt;code&amp;gt;access_error()&amp;lt;/code&amp;gt;에서 VMA의 읽기, 쓰기, 실행 조건을 확인한다.&amp;lt;ref name=&amp;quot;rv-entry&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/riscv/kernel/entry.S?h=v6.12 Linux v6.12 arch/riscv/kernel/entry.S], handle_exception, excp_vect_table, ret_from_exception.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;rv-traps&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/riscv/kernel/traps.c?h=v6.12 Linux v6.12 arch/riscv/kernel/traps.c], do_page_fault.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;rv-fault&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/riscv/mm/fault.c?h=v6.12 Linux v6.12 arch/riscv/mm/fault.c], handle_page_fault, access_error.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== VMA 검사와 공통 폴트 처리 ===&lt;br /&gt;
두 아키텍처의 처리 함수 모두 폴트 주소를 포함하는 VMA를 찾아 권한을 검사한다. 매핑이 없거나 허용되지 않은 접근이면 정상적인 폴트 복구 대신 신호 처리로 이어질 수 있다. VMA가 허용한 접근이라면 &amp;lt;code&amp;gt;handle_mm_fault()&amp;lt;/code&amp;gt;로 진행한다.&amp;lt;ref name=&amp;quot;x86fault&amp;quot; /&amp;gt;&amp;lt;ref name=&amp;quot;rv-fault&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 공통 폴트 처리와 분기 ==&lt;br /&gt;
CPU는 페이지 테이블로 주소를 변환하고, 커널은 예외를 받은 뒤 VMA를 확인한다. 따라서 VMA가 쓰기를 허용해도 PTE는 일시적으로 읽기 전용일 수 있다. 쓰기 시점에 COW를 수행하려고 의도적으로 남겨 둔 차이다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
handle_mm_fault -&amp;gt; __handle_mm_fault -&amp;gt; handle_pte_fault&lt;br /&gt;
  |&lt;br /&gt;
  +-- PTE 없음 -&amp;gt; do_pte_missing&lt;br /&gt;
  |      +-- private anonymous -&amp;gt; do_anonymous_page&lt;br /&gt;
  |      +-- 파일 등의 처리기 -&amp;gt; do_fault&lt;br /&gt;
  |&lt;br /&gt;
  +-- 읽기 전용 PTE에 쓰기 -&amp;gt; do_wp_page&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;do_pte_missing()&amp;lt;/code&amp;gt;은 private anonymous VMA와 파일 등의 처리기를 사용하는 VMA를 나눈다. &amp;lt;code&amp;gt;do_fault()&amp;lt;/code&amp;gt;는 읽기, private 쓰기, shared 쓰기를 각각 &amp;lt;code&amp;gt;do_read_fault()&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;do_cow_fault()&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;do_shared_fault()&amp;lt;/code&amp;gt;로 나눈다. 각 분기는 VMA가 허용한 접근에 필요한 페이지와 권한을 준비한다.&amp;lt;ref name=&amp;quot;memory&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/mm/memory.c?h=v6.12 Linux v6.12, mm/memory.c], do_pte_missing, do_anonymous_page, do_fault, do_wp_page, wp_page_copy.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
앞으로 [[운영체제 기본/Linux/메모리 매핑/익명 메모리 매핑|익명 매핑]]에서는 0으로 보이는 메모리를 마련하고, [[운영체제 기본/Linux/메모리 매핑/파일 매핑과 COW|파일 매핑]]에서는 파일 페이지를 가져오거나 사본을 만든다. [[운영체제 기본/Linux/메모리 매핑/MMIO 장치 매핑|MMIO 매핑]]은 드라이버가 매핑 시점에 장치 PTE를 설치할 수 있으므로, 모든 매핑이 이 지연 할당 순서를 거치는 것은 아니다.&lt;br /&gt;
&lt;br /&gt;
필요한 입출력이나 메모리를 기다리는 동안 현재 태스크가 잠들 수 있다. 그동안 CPU는 다른 태스크를 실행할 수 있다. 커널이 필요한 페이지를 준비하고 페이지 테이블 잠금 아래 PTE를 설치하면, 예외에서 돌아온 CPU가 중단한 명령을 다시 실행한다. 파일 데이터가 이미 준비되어 있거나 주변 페이지를 함께 연결하는 최적화가 적용되면 더 짧은 경로로 끝날 수도 있다.&lt;br /&gt;
&lt;br /&gt;
== PTE 설정과 접근 재시도 ==&lt;br /&gt;
PTE의 하드웨어 비트 형식은 아키텍처마다 다르다. x86-64는 present 비트와 읽기/쓰기, 사용자 접근 등의 속성을 사용하고, RISC-V는 V(valid), R, W, X, U 등의 비트로 유효성과 접근 조건을 표현한다. 페이지 테이블 단계와 실제 엔트리 조작은 아키텍처별 구현에 맡긴다. PTE를 설정하면 해당 프로세스의 가상 주소가 준비된 페이지를 허용된 권한으로 가리킨다.&amp;lt;ref name=&amp;quot;x86-pte&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/include/asm/pgtable_types.h?h=v6.12 Linux v6.12 arch/x86/include/asm/pgtable_types.h], 페이지 테이블 속성 비트.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;rv-pte&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/riscv/include/asm/pgtable-bits.h?h=v6.12 Linux v6.12 arch/riscv/include/asm/pgtable-bits.h], _PAGE_PRESENT, _PAGE_READ, _PAGE_WRITE, _PAGE_EXEC, _PAGE_USER.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
RISC-V의 정상적인 페이지 폴트 복구는 시스템 콜의 &amp;lt;code&amp;gt;ecall&amp;lt;/code&amp;gt;처럼 &amp;lt;code&amp;gt;epc&amp;lt;/code&amp;gt;를 다음 명령으로 증가시키지 않는다. 저장된 fault 명령 위치로 복귀해 같은 load를 다시 수행한다. x86-64도 성공한 페이지 폴트 처리 뒤에는 중단된 load를 다시 실행한다. 레지스터 복원과 사용자 모드 복귀 방식은 [[운영체제 기본/Linux/ELF 로딩/초기 스택과 사용자 모드 진입#사용자 모드 진입: x86-64와 RISC-V|두 아키텍처의 사용자 모드 진입]]에서 다룬다. 커널 안에서 잠금이나 입출력 때문에 폴트 처리를 재시도하는 일과, 사용자 모드로 돌아가 CPU 명령을 다시 실행하는 일은 구별한다.&amp;lt;ref name=&amp;quot;rv-traps&amp;quot; /&amp;gt;&amp;lt;ref name=&amp;quot;rv-entry&amp;quot; /&amp;gt;&amp;lt;ref name=&amp;quot;rv-fault&amp;quot; /&amp;gt;&amp;lt;ref name=&amp;quot;x86fault&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br&amp;gt;[[운영체제 기본/Linux/메모리 매핑/mmap과 주소 공간|mmap과 주소 공간]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/메모리 매핑|메모리 매핑 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br&amp;gt;[[운영체제 기본/Linux/메모리 매핑/익명 메모리 매핑|익명 메모리 매핑]]&lt;br /&gt;
}}&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%ED%8C%8C%EC%9D%BC%EC%8B%9C%EC%8A%A4%ED%85%9C/VFS%EC%99%80_%ED%8C%8C%EC%9D%BC_%EA%B0%9D%EC%B2%B4&amp;diff=693</id>
		<title>운영체제 기본/Linux/파일시스템/VFS와 파일 객체</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%ED%8C%8C%EC%9D%BC%EC%8B%9C%EC%8A%A4%ED%85%9C/VFS%EC%99%80_%ED%8C%8C%EC%9D%BC_%EA%B0%9D%EC%B2%B4&amp;diff=693"/>
		<updated>2026-11-15T06:07:23Z</updated>

		<summary type="html">&lt;p&gt;관리자: 반복적인 대조 문장을 직접 설명으로 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|목차=[[운영체제 기본/Linux/파일시스템|파일시스템 목차]]&lt;br /&gt;
|다음=다음 문서 -&amp;gt;&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/파일시스템/ext4의 파일 읽기|ext4의 파일 읽기]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
기준은 Linux v6.12다. [[운영체제 기본/Linux/파일 시스템 콜/read와 write|read() 시스템 콜 경로]]는 VFS의 파일 객체와 연산 인터페이스를 통해 실제 파일시스템 구현으로 연결된다.&lt;br /&gt;
&lt;br /&gt;
== 공통 인터페이스와 구현의 분리 ==&lt;br /&gt;
&lt;br /&gt;
프로그램은 ext4의 일반 파일도, &amp;lt;code&amp;gt;/proc/uptime&amp;lt;/code&amp;gt;도 경로로 열고 반환된 파일 디스크립터로 읽는다. 그러나 앞의 파일은 저장된 내용을 읽는 대상이고, 뒤의 파일은 부팅 이후 경과 시간과 CPU 유휴 시간을 텍스트로 보여 주는 대상이다. 같은 시스템 콜(System Call)을 사용하더라도 데이터는 각 파일시스템의 구현에 따라 제공된다.&lt;br /&gt;
&lt;br /&gt;
VFS(Virtual File System)는 파일시스템마다 별도의 시스템 콜을 만들지 않고도 이들을 함께 사용할 수 있게 하는 커널 계층이다. 공통 객체와 연산 인터페이스를 정의하고, 실제 대상에 맞는 파일시스템 구현을 호출한다. VFS는 이름으로 대상을 찾고 그 대상의 연산으로 연결하는 공통 경로를 제공한다.&amp;lt;ref name=&amp;quot;vfs-overview&amp;quot;&amp;gt;[https://docs.kernel.org/filesystems/vfs.html Linux kernel documentation, Overview of the Linux Virtual File System], Introduction, Directory Entry Cache, The File Object.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 경로 탐색과 파일 객체 ==&lt;br /&gt;
&amp;lt;code&amp;gt;/home/ldmsys/a.txt&amp;lt;/code&amp;gt;를 열려면 커널은 경로의 구성 요소를 차례로 해석해야 한다. 이때 &amp;lt;code&amp;gt;dentry&amp;lt;/code&amp;gt;는 부모 디렉터리 아래의 이름과 대상을 연결하는 메모리 객체다. 이미 캐시된 연결을 사용할 수 없다면 해당 디렉터리의 &amp;lt;code&amp;gt;inode-&amp;gt;i_op-&amp;gt;lookup()&amp;lt;/code&amp;gt; 같은 파일시스템 연산으로 대상을 확인한다. 찾아낸 &amp;lt;code&amp;gt;inode&amp;lt;/code&amp;gt;는 파일의 종류, 권한 등과 연산 정보를 담는 객체이며, 파일 이름 자체와는 구분된다. 여러 이름이 같은 inode를 가리킬 수도 있다.&amp;lt;ref name=&amp;quot;vfs-overview&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;vfs-namei&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/namei.c?h=v6.12 Linux v6.12, fs/namei.c], lookup_fast(), __lookup_slow(), step_into(), handle_mounts().&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
경로 탐색에는 dentry와 마운트 정보가 필요하다. 예를 들어 &amp;lt;code&amp;gt;/proc&amp;lt;/code&amp;gt;에 procfs가 마운트되어 있으면 그 지점을 지나면서 탐색 대상 파일시스템이 바뀐다. 그래서 커널의 &amp;lt;code&amp;gt;struct path&amp;lt;/code&amp;gt;는 마운트와 dentry를 함께 가리킨다. &amp;lt;code&amp;gt;super_block&amp;lt;/code&amp;gt;은 이 과정에서 만나는 파일시스템 인스턴스의 공통 상태를 나타내며, inode도 자신이 속한 super_block을 참조한다. 이렇게 서로 다른 디스크와 파일시스템이 하나의 경로 공간에 연결된다.&amp;lt;ref name=&amp;quot;vfs-namei&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;vfs-fs-h&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/linux/fs.h?h=v6.12 Linux v6.12, include/linux/fs.h], struct inode, struct file, struct super_block.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== open과 열린 파일 상태 ==&lt;br /&gt;
&amp;lt;code&amp;gt;open()&amp;lt;/code&amp;gt; 과정에서 마련하는 &amp;lt;code&amp;gt;struct file&amp;lt;/code&amp;gt;은 파일 자체를 나타내는 inode와 달리, 그 파일을 열어 둔 상태를 나타낸다. 여기에는 경로인 &amp;lt;code&amp;gt;f_path&amp;lt;/code&amp;gt;, 현재 위치인 &amp;lt;code&amp;gt;f_pos&amp;lt;/code&amp;gt;, 상태 플래그인 &amp;lt;code&amp;gt;f_flags&amp;lt;/code&amp;gt;, 사용할 연산표인 &amp;lt;code&amp;gt;f_op&amp;lt;/code&amp;gt; 등이 연결된다. 같은 파일을 별도로 열면 inode는 같더라도 열린 상태와 읽기 위치는 따로 유지할 수 있다.&amp;lt;ref name=&amp;quot;vfs-fs-h&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
일반적인 열기 경로에서 &amp;lt;code&amp;gt;do_dentry_open()&amp;lt;/code&amp;gt;은 다음과 같이 inode에 등록된 연산표를 가져온다. 이어서 해당 연산표의 &amp;lt;code&amp;gt;open&amp;lt;/code&amp;gt; 콜백이 있으면 호출하여 구현별 준비를 수행한다.&amp;lt;ref name=&amp;quot;vfs-open&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/open.c?h=v6.12 Linux v6.12, fs/open.c], do_dentry_open(), do_sys_openat2().&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
f-&amp;gt;f_op = fops_get(inode-&amp;gt;i_fop);&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
열기에 성공하면 &amp;lt;code&amp;gt;fd_install()&amp;lt;/code&amp;gt;이 프로세스의 파일 디스크립터 테이블에 이 file을 연결한다. 프로그램에 반환되는 정수 fd는 이 테이블에서 열린 파일을 찾는 번호다. 이후 읽을 때마다 최초의 경로 문자열을 다시 해석하지 않고, 이미 연결된 file을 통해 대상과 연산을 찾는다.&amp;lt;ref name=&amp;quot;vfs-open&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== read와 파일시스템별 구현 ==&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
경로 탐색: 이름 + 마운트 -&amp;gt; dentry -&amp;gt; inode&lt;br /&gt;
열기 이후: fd -&amp;gt; fdtable -&amp;gt; struct file -&amp;gt; f_op -&amp;gt; 읽기 구현&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;read()&amp;lt;/code&amp;gt;의 커널 경로는 fd로 file을 얻고 &amp;lt;code&amp;gt;vfs_read()&amp;lt;/code&amp;gt;에 전달한다. 이 함수는 읽기 가능 여부와 요청 범위 등을 검사한 다음 &amp;lt;code&amp;gt;file-&amp;gt;f_op-&amp;gt;read&amp;lt;/code&amp;gt;가 있으면 호출한다. 그렇지 않고 &amp;lt;code&amp;gt;read_iter&amp;lt;/code&amp;gt;가 있으면 &amp;lt;code&amp;gt;new_sync_read()&amp;lt;/code&amp;gt;가 버퍼를 iterator 형태로 준비하여 그 콜백을 호출한다. 각 파일시스템은 이 콜백에 자신의 읽기 구현을 등록한다.&amp;lt;ref name=&amp;quot;vfs-read&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/read_write.c?h=v6.12 Linux v6.12, fs/read_write.c], ksys_read(), vfs_read(), new_sync_read().&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
ext4 일반 파일은 &amp;lt;code&amp;gt;ext4_file_operations.read_iter&amp;lt;/code&amp;gt;에 &amp;lt;code&amp;gt;ext4_file_read_iter()&amp;lt;/code&amp;gt;를 등록한다. 보통의 버퍼드 읽기는 여기서 &amp;lt;code&amp;gt;generic_file_read_iter()&amp;lt;/code&amp;gt;로 이어진다. 반면 &amp;lt;code&amp;gt;/proc/uptime&amp;lt;/code&amp;gt;의 inode에는 &amp;lt;code&amp;gt;proc_iter_file_ops&amp;lt;/code&amp;gt;가 연결된다. 그 &amp;lt;code&amp;gt;read_iter&amp;lt;/code&amp;gt; 콜백인 &amp;lt;code&amp;gt;proc_reg_read_iter()&amp;lt;/code&amp;gt;는 엔트리의 &amp;lt;code&amp;gt;proc_ops.proc_read_iter&amp;lt;/code&amp;gt;에 등록된 &amp;lt;code&amp;gt;seq_read_iter()&amp;lt;/code&amp;gt;로 이어진다. 이 읽기는 디스크 내용을 가져오는 대신, 등록된 &amp;lt;code&amp;gt;uptime_proc_show()&amp;lt;/code&amp;gt;를 통해 커널 상태를 텍스트로 만든다.&amp;lt;ref name=&amp;quot;vfs-ext4&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/ext4/file.c?h=v6.12 Linux v6.12, fs/ext4/file.c], ext4_file_operations, ext4_file_read_iter().&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;vfs-proc&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/proc/inode.c?h=v6.12 Linux v6.12, fs/proc/inode.c], proc_get_inode(), proc_iter_file_ops, proc_reg_read_iter(); [https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/proc/generic.c?h=v6.12 fs/proc/generic.c], proc_single_ops, proc_create_single_data(); [https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/proc/uptime.c?h=v6.12 fs/proc/uptime.c], proc_uptime_init(), uptime_proc_show().&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
VFS는 파일 객체를 찾고 연산을 호출하는 공통 인터페이스를 제공한다. 디스크 접근 여부와 데이터 생성 방식은 그 뒤의 구현이 결정한다. 페이지 캐시 사용 여부도 구현에 따라 다르다. ext4 내부에서도 버퍼드 읽기, 직접 I/O, DAX 경로가 나뉜다.&amp;lt;ref name=&amp;quot;vfs-ext4&amp;quot;/&amp;gt; 구체적인 흐름은 [[운영체제 기본/Linux/파일시스템/ext4의 파일 읽기|ext4의 파일 읽기]], [[운영체제 기본/Linux/파일시스템/procfs의 파일 읽기|procfs의 파일 읽기]], [[운영체제 기본/Linux/파일시스템/페이지 캐시|페이지 캐시]]에서 이어서 살펴본다.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|목차=[[운영체제 기본/Linux/파일시스템|파일시스템 목차]]&lt;br /&gt;
|다음=다음 문서 -&amp;gt;&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/파일시스템/ext4의 파일 읽기|ext4의 파일 읽기]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%EB%A9%94%EB%AA%A8%EB%A6%AC_%EB%A7%A4%ED%95%91/mmap%EA%B3%BC_%EC%A3%BC%EC%86%8C_%EA%B3%B5%EA%B0%84&amp;diff=692</id>
		<title>운영체제 기본/Linux/메모리 매핑/mmap과 주소 공간</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%EB%A9%94%EB%AA%A8%EB%A6%AC_%EB%A7%A4%ED%95%91/mmap%EA%B3%BC_%EC%A3%BC%EC%86%8C_%EA%B3%B5%EA%B0%84&amp;diff=692"/>
		<updated>2026-11-15T06:07:07Z</updated>

		<summary type="html">&lt;p&gt;관리자: 문체 정리: 과도한 강조와 대조, 비표준 문자 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=처음 문서&lt;br /&gt;
|목차=[[운영체제 기본/Linux/메모리 매핑|메모리 매핑 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br&amp;gt;[[운영체제 기본/Linux/메모리 매핑/페이지 폴트 처리|페이지 폴트 처리]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;mmap()&amp;lt;/code&amp;gt;은 호출한 프로세스에 가상 주소 구간을 설정한다. 이 주소를 읽거나 쓸 때 접근할 대상과 방식을 정하는 인터페이스다. Linux v6.12의 MMU를 사용하는 네이티브 x86-64와 RISC-V RV64를 기준으로 한다.&lt;br /&gt;
&lt;br /&gt;
== mmap 인자와 매핑 대상 ==&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
void *p = mmap(addr, length, prot, flags, fd, offset);&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;addr&amp;lt;/code&amp;gt;가 NULL이면 커널이 주소를 선택한다. &amp;lt;code&amp;gt;length&amp;lt;/code&amp;gt;는 매핑할 길이이고, &amp;lt;code&amp;gt;prot&amp;lt;/code&amp;gt;은 읽기, 쓰기, 실행 등 허용할 접근을 지정한다. &amp;lt;code&amp;gt;flags&amp;lt;/code&amp;gt;는 공유 여부와 익명 매핑 여부 등을 정한다. 반환값은 이 프로세스가 접근할 가상 주소이며, 실패하면 &amp;lt;code&amp;gt;MAP_FAILED&amp;lt;/code&amp;gt;다.&lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
! 대상 !! 대표 인자 !! 주소가 가리킬 대상&lt;br /&gt;
|-&lt;br /&gt;
| 익명 메모리 || MAP_PRIVATE &amp;amp;#124; MAP_ANONYMOUS, fd = -1, offset = 0 || 처음에는 0으로 보이며, 쓰기에 필요한 RAM을 마련하는 영역&lt;br /&gt;
|-&lt;br /&gt;
| 일반 파일 || MAP_PRIVATE 또는 MAP_SHARED, 열린 파일의 fd || 파일 오프셋에 대응하는 데이터&lt;br /&gt;
|-&lt;br /&gt;
| MMIO 장치 || 드라이버가 허용한 flags와 장치 fd || 드라이버가 공개한 장치의 물리 주소 영역&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;MAP_PRIVATE&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;MAP_SHARED&amp;lt;/code&amp;gt;는 읽기 및 쓰기 권한과 별개다. &amp;lt;code&amp;gt;PROT_WRITE&amp;lt;/code&amp;gt;는 쓰기를 허용할지를 정하고, private/shared는 허용된 쓰기의 결과를 어떻게 취급할지 정한다. 일반 파일의 private 쓰기는 그 프로세스의 사본에 적용되며, shared 쓰기는 공유하는 파일 데이터에 적용된다. 익명 매핑과 장치 매핑의 구체적인 동작은 뒤 장에서 구분한다.&lt;br /&gt;
&lt;br /&gt;
== VMA와 페이지 테이블 ==&lt;br /&gt;
VMA(Virtual Memory Area)는 연속된 가상 주소 범위의 정책을 담는 커널 자료구조다. 시작 주소와 끝 주소, 접근 권한, 공유 여부, 연결된 파일과 처리 함수 등을 기록한다. 반면 페이지 테이블 엔트리(PTE)는 CPU가 개별 가상 페이지를 실제 대상으로 변환하는 데 쓰는 항목이다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
프로세스의 가상 주소 구간&lt;br /&gt;
  VMA: 이 구간의 의미, 권한, 대상, 처리 방법&lt;br /&gt;
    |&lt;br /&gt;
    +-- PTE 없음: 접근하면 페이지 폴트로 준비&lt;br /&gt;
    +-- PTE 있음: 지정된 RAM 또는 장치 주소로 변환&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
익명 메모리나 일반 파일의 보통 매핑에서는 &amp;lt;code&amp;gt;mmap()&amp;lt;/code&amp;gt;이 VMA를 설정하고, 실제 페이지 준비와 PTE 설치는 접근할 때로 미룬다. 따라서 &amp;lt;code&amp;gt;mmap()&amp;lt;/code&amp;gt; 성공이 모든 RAM 할당이나 파일 읽기의 완료를 뜻하지 않는다. 장치 드라이버는 매핑을 만드는 중에 PTE를 직접 설치할 수도 있다. 미리 페이지를 채우는 옵션이나 큰 페이지의 세부 경로 대신, 이후 장에서는 기본 페이지 단위의 일반적인 경로를 따라간다.&lt;br /&gt;
&lt;br /&gt;
== mmap 시스템 콜과 주소 공간 ==&lt;br /&gt;
&amp;lt;code&amp;gt;mmap()&amp;lt;/code&amp;gt;의 인자와 사용자 인터페이스는 두 아키텍처에서 같다. 그러나 사용자 공간에서 커널로 넘어가는 명령, 인자 레지스터, 커널 진입 코드는 다르다. 아키텍처별 진입 경로를 살펴본 뒤 공통 메모리 관리 코드로 이어 간다. 여기서 설명하는 시스템 콜 ABI는 일반 C 함수 호출 규약과 구별한다.&lt;br /&gt;
&lt;br /&gt;
=== x86-64: syscall과 x86 mmap 진입점 ===&lt;br /&gt;
&lt;br /&gt;
네이티브 x86-64 ABI는 &amp;lt;code&amp;gt;syscall&amp;lt;/code&amp;gt; 명령을 사용한다. 시스템 콜 번호는 &amp;lt;code&amp;gt;rax&amp;lt;/code&amp;gt;에, 여섯 인자 &amp;lt;code&amp;gt;addr, len, prot, flags, fd, offset&amp;lt;/code&amp;gt;은 순서대로 &amp;lt;code&amp;gt;rdi, rsi, rdx, r10, r8, r9&amp;lt;/code&amp;gt;에 놓인다. &amp;lt;code&amp;gt;mmap&amp;lt;/code&amp;gt; 번호는 9다. 이 진입은 [[운영체제 기본/Linux/메모리 매핑/페이지 폴트 처리|페이지 폴트]]처럼 IDT를 통하는 경로가 아니다.&amp;lt;ref name=&amp;quot;mmap-x86-entry&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/entry/entry_64.S?h=v6.12 Linux v6.12, arch/x86/entry/entry_64.S: entry_SYSCALL_64와 ABI 주석].&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;mmap-x86-table&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/entry/syscalls/syscall_64.tbl?h=v6.12 Linux v6.12, arch/x86/entry/syscalls/syscall_64.tbl: mmap].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
시스템 콜 디스패치를 거쳐 &amp;lt;code&amp;gt;arch/x86/kernel/sys_x86_64.c&amp;lt;/code&amp;gt;의 &amp;lt;code&amp;gt;SYSCALL_DEFINE6(mmap, ...)&amp;lt;/code&amp;gt; 본문에 도달한다. 이 코드는 바이트 단위 오프셋의 페이지 정렬을 검사하고, &amp;lt;code&amp;gt;off &amp;amp;gt;&amp;amp;gt; PAGE_SHIFT&amp;lt;/code&amp;gt;로 페이지 단위 오프셋을 만들어 &amp;lt;code&amp;gt;ksys_mmap_pgoff()&amp;lt;/code&amp;gt;를 호출한다.&amp;lt;ref name=&amp;quot;mmap-x86&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/kernel/sys_x86_64.c?h=v6.12 Linux v6.12, arch/x86/kernel/sys_x86_64.c: SYSCALL_DEFINE6(mmap)].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== RISC-V RV64: ecall과 RISC-V mmap 진입점 ===&lt;br /&gt;
&lt;br /&gt;
RV64의 네이티브 ABI는 &amp;lt;code&amp;gt;ecall&amp;lt;/code&amp;gt; 명령을 사용한다. 시스템 콜 번호는 &amp;lt;code&amp;gt;a7&amp;lt;/code&amp;gt;에, 같은 여섯 인자는 &amp;lt;code&amp;gt;a0&amp;lt;/code&amp;gt;부터 &amp;lt;code&amp;gt;a5&amp;lt;/code&amp;gt;에 놓인다. &amp;lt;code&amp;gt;ecall&amp;lt;/code&amp;gt;은 사용자 모드의 환경 호출 예외를 일으킨다. CPU는 &amp;lt;code&amp;gt;stvec&amp;lt;/code&amp;gt;에 등록된 트랩 진입점으로 이동하며, Linux의 &amp;lt;code&amp;gt;handle_exception&amp;lt;/code&amp;gt;과 예외 분기 표를 거쳐 &amp;lt;code&amp;gt;do_trap_ecall_u()&amp;lt;/code&amp;gt;로 전달된다. 이 함수는 &amp;lt;code&amp;gt;regs-&amp;amp;gt;a7&amp;lt;/code&amp;gt;의 번호로 시스템 콜을 분기한다. &amp;lt;code&amp;gt;ecall&amp;lt;/code&amp;gt; 다음 명령으로 돌아가도록 저장된 &amp;lt;code&amp;gt;epc&amp;lt;/code&amp;gt;를 4 증가시키는 것도 여기서 한다.&amp;lt;ref name=&amp;quot;mmap-rv-entry&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/riscv/kernel/entry.S?h=v6.12 Linux v6.12, arch/riscv/kernel/entry.S: handle_exception, excp_vect_table].&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;mmap-rv-traps&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/riscv/kernel/traps.c?h=v6.12 Linux v6.12, arch/riscv/kernel/traps.c: do_trap_ecall_u].&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;mmap-rv-abi&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/riscv/include/asm/syscall.h?h=v6.12 Linux v6.12, arch/riscv/include/asm/syscall.h: syscall_get_arguments].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
RV64의 &amp;lt;code&amp;gt;SYSCALL_DEFINE6(mmap, ...)&amp;lt;/code&amp;gt;은 &amp;lt;code&amp;gt;riscv_sys_mmap(..., offset, 0)&amp;lt;/code&amp;gt;을 호출한다. 이 도우미도 바이트 단위 오프셋의 정렬을 검사하고 페이지 단위로 바꾸어 &amp;lt;code&amp;gt;ksys_mmap_pgoff()&amp;lt;/code&amp;gt;에 전달한다. 오프셋은 이 경계에서 한 번 페이지 단위로 바뀐다.&amp;lt;ref name=&amp;quot;mmap-rv&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/riscv/kernel/sys_riscv.c?h=v6.12 Linux v6.12, arch/riscv/kernel/sys_riscv.c: mmap, riscv_sys_mmap, mmap2].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== 공통 경로와 대상별 연결 ===&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
mmap&lt;br /&gt;
  +-- x86-64: syscall -&amp;gt; entry_SYSCALL_64 -&amp;gt; x86 mmap&lt;br /&gt;
  +-- RV64: ecall -&amp;gt; handle_exception -&amp;gt; do_trap_ecall_u&lt;br /&gt;
                                  -&amp;gt; RV64 mmap -&amp;gt; riscv_sys_mmap&lt;br /&gt;
  |&lt;br /&gt;
  v&lt;br /&gt;
ksys_mmap_pgoff -&amp;gt; vm_mmap_pgoff -&amp;gt; do_mmap&lt;br /&gt;
  -&amp;gt; mmap_region -&amp;gt; __mmap_region&lt;br /&gt;
       +-- private anonymous: 익명 VMA 설정&lt;br /&gt;
       +-- 일반 파일: 파일시스템의 mmap 콜백&lt;br /&gt;
       +-- 장치 파일: 장치 드라이버의 mmap 콜백&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;ksys_mmap_pgoff()&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;MAP_ANONYMOUS&amp;lt;/code&amp;gt;가 아니면 &amp;lt;code&amp;gt;fget()&amp;lt;/code&amp;gt;으로 fd를 열린 &amp;lt;code&amp;gt;struct file&amp;lt;/code&amp;gt; 객체에 연결한다. 익명 매핑은 사용자 파일을 찾지 않는다. &amp;lt;code&amp;gt;vm_mmap_pgoff()&amp;lt;/code&amp;gt;가 주소 공간의 쓰기 잠금을 잡고, &amp;lt;code&amp;gt;do_mmap()&amp;lt;/code&amp;gt;은 길이와 오프셋, 접근 조건을 검사하며 사용할 주소를 구한다.&amp;lt;ref name=&amp;quot;mmap&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/mm/mmap.c?h=v6.12 Linux v6.12, mm/mmap.c], ksys_mmap_pgoff, do_mmap, __mmap_region.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;util&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/mm/util.c?h=v6.12 Linux v6.12, mm/util.c], vm_mmap_pgoff.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;__mmap_region()&amp;lt;/code&amp;gt;은 VMA를 구성하고 대상별 처리를 연결한다. private anonymous 매핑에는 &amp;lt;code&amp;gt;vma_set_anonymous()&amp;lt;/code&amp;gt;를 사용한다. 파일이 있으면 &amp;lt;code&amp;gt;mmap_file()&amp;lt;/code&amp;gt;과 &amp;lt;code&amp;gt;call_mmap()&amp;lt;/code&amp;gt;을 통해 &amp;lt;code&amp;gt;file-&amp;amp;gt;f_op-&amp;amp;gt;mmap&amp;lt;/code&amp;gt;을 호출한다. 같은 파일 연산 표라도 일반 파일에서는 파일시스템의 함수, 장치 파일에서는 그 장치 드라이버의 함수로 이어진다. 데이터 공급 방식은 매핑 대상의 구현에 따라 달라진다.&amp;lt;ref name=&amp;quot;mmap&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;internal&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/mm/internal.h?h=v6.12 Linux v6.12, mm/internal.h], mmap_file.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;fs&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/linux/fs.h?h=v6.12 Linux v6.12, include/linux/fs.h], call_mmap.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
파일 매핑의 &amp;lt;code&amp;gt;vm_pgoff&amp;lt;/code&amp;gt;는 VMA 시작점에 대응하는 페이지 단위 파일 오프셋이다. 일반 파일에서는 구간 안 주소의 파일 위치가 다음처럼 정해진다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
파일 위치 = (vm_pgoff * PAGE_SIZE) + (접근 주소 - vm_start)&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
장치 파일의 오프셋 의미는 드라이버의 인터페이스에 달려 있다. 예를 들어 MMIO 장의 UIO는 오프셋을 장치의 매핑 영역 번호를 고르는 데 사용한다. 또한 인접한 호환 VMA와 합칠 수 있으므로 &amp;lt;code&amp;gt;mmap()&amp;lt;/code&amp;gt; 호출 하나가 항상 VMA 하나로 남는 것은 아니다.&amp;lt;ref name=&amp;quot;mmap&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 매핑의 수명 ==&lt;br /&gt;
파일 매핑은 파일 객체에 대한 참조를 보유한다. 매핑 성공 뒤 fd를 &amp;lt;code&amp;gt;close()&amp;lt;/code&amp;gt;하더라도 매핑은 남는다. &amp;lt;code&amp;gt;munmap()&amp;lt;/code&amp;gt;은 주소 구간의 매핑을 해제하는 별도 작업이다. 해제한 포인터를 다시 사용하면 안 되며, 같은 주소가 나중에 재사용될 수 있으므로 잘못된 접근이 항상 신호로 드러나지도 않는다.&amp;lt;ref name=&amp;quot;mmap&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
주소 구간을 확보했다고 해서 이후 모든 접근의 성공이 보장되지는 않는다. 익명 페이지를 준비할 메모리가 부족할 수 있고, 매핑한 파일이 줄어들 수도 있으며, 장치에는 장치별 수명 조건이 있다. 다음 장에서는 유효한 접근을 CPU 예외와 커널이 어떻게 구별하고 완성하는지 살펴본다.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=처음 문서&lt;br /&gt;
|목차=[[운영체제 기본/Linux/메모리 매핑|메모리 매핑 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br&amp;gt;[[운영체제 기본/Linux/메모리 매핑/페이지 폴트 처리|페이지 폴트 처리]]&lt;br /&gt;
}}&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/i8042_%ED%82%A4%EB%B3%B4%EB%93%9C_%EC%9E%85%EB%A0%A5/%EC%BD%98%EC%86%94%EA%B3%BC_%ED%84%B0%EB%AF%B8%EB%84%90_%EC%9E%85%EB%A0%A5&amp;diff=691</id>
		<title>운영체제 기본/Linux/x86-64/i8042 키보드 입력/콘솔과 터미널 입력</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/i8042_%ED%82%A4%EB%B3%B4%EB%93%9C_%EC%9E%85%EB%A0%A5/%EC%BD%98%EC%86%94%EA%B3%BC_%ED%84%B0%EB%AF%B8%EB%84%90_%EC%9E%85%EB%A0%A5&amp;diff=691"/>
		<updated>2026-11-15T06:07:01Z</updated>

		<summary type="html">&lt;p&gt;관리자: 반복적인 부정 대조와 문장 부호 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=&amp;lt;- 이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/i8042 키보드 입력/evdev의 이벤트 전달과 대기 해제|evdev의 이벤트 전달과 대기 해제]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/x86-64/i8042 키보드 입력|i8042 키보드 입력 목차]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
Linux v6.12의 가상 콘솔에서는 input core에 연결된 별도의 &amp;lt;code&amp;gt;kbd_handler&amp;lt;/code&amp;gt;가 키 이벤트를 문자로 해석한다. 여기서는 활성 텍스트 콘솔의 키보드 모드가 &amp;lt;code&amp;gt;VC_UNICODE&amp;lt;/code&amp;gt;이고, TTY가 기본 N_TTY line discipline(에코, 행 편집, 읽기 완료 조건을 처리하는 계층)과 canonical(행 단위 입력) 모드를 사용하며, CR을 무시하지 않고 줄바꿈으로 변환하는 설정(&amp;lt;code&amp;gt;ICRNL&amp;lt;/code&amp;gt; 켜짐)인 경우를 가정한다. GUI 터미널, raw 모드 프로그램, 리디렉션된 표준 입력에는 이 가정을 그대로 적용할 수 없다.&lt;br /&gt;
&lt;br /&gt;
== 키 코드와 문자 바이트 변환 ==&lt;br /&gt;
&amp;lt;code&amp;gt;kbd_handler&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;.event = kbd_event&amp;lt;/code&amp;gt;를 등록한다. input core의 &amp;lt;code&amp;gt;input_handle_events_default()&amp;lt;/code&amp;gt;가 이벤트 묶음을 하나씩 이 callback에 전달한다. input core에서 evdev와 콘솔 handler로 전달 경로가 나뉜다.&amp;lt;ref name=&amp;quot;input-console-v612&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/input/input.c?h=v6.12 Linux v6.12 drivers/input/input.c: input_handle_events_default(), input_register_handle()]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;kbd_event()&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;kbd_event_lock&amp;lt;/code&amp;gt; 아래에서 &amp;lt;code&amp;gt;EV_KEY&amp;lt;/code&amp;gt;를 &amp;lt;code&amp;gt;kbd_keycode()&amp;lt;/code&amp;gt;에 넘긴다. 이 함수는 활성 콘솔을 선택하고 눌린 키 상태, Shift 상태, 잠금 상태와 &amp;lt;code&amp;gt;key_maps&amp;lt;/code&amp;gt;를 이용하여 keysym을 결정한다. 문자 종류에 따라 &amp;lt;code&amp;gt;k_self()&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;k_unicode()&amp;lt;/code&amp;gt; 등으로 분기하며, Unicode 모드에서는 &amp;lt;code&amp;gt;to_utf8()&amp;lt;/code&amp;gt;가 UTF-8 바이트를 생성한다. Shift나 키맵에 따라 결과가 달라지고, 키 해제는 일반 문자 입력으로 추가되지 않는다.&amp;lt;ref name=&amp;quot;keyboard-v612&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/tty/vt/keyboard.c?h=v6.12 Linux v6.12 drivers/tty/vt/keyboard.c: kbd_handler, kbd_event(), kbd_keycode(), k_unicode(), to_utf8(), fn_enter()]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== IRQ 문맥과 line discipline 사이의 버퍼 ==&lt;br /&gt;
&lt;br /&gt;
문자 바이트를 넣는 &amp;lt;code&amp;gt;put_queue()&amp;lt;/code&amp;gt;의 실제 본문은 짧다.&amp;lt;ref name=&amp;quot;keyboard-v612&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
tty_insert_flip_char(&amp;amp;vc-&amp;gt;port, ch, 0);&lt;br /&gt;
tty_flip_buffer_push(&amp;amp;vc-&amp;gt;port);&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
여기서 flip buffer는 드라이버의 입력을 TTY 처리 계층으로 넘기는 중간 버퍼다. &amp;lt;code&amp;gt;tty_flip_buffer_push()&amp;lt;/code&amp;gt;는 commit 위치를 공개하고 다음 작업을 예약한다.&amp;lt;ref name=&amp;quot;tty-buffer-v612&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/tty/tty_buffer.c?h=v6.12 Linux v6.12 drivers/tty/tty_buffer.c: tty_flip_buffer_push(), flush_to_ldisc(), tty_ldisc_receive_buf()]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
tty_flip_buffer_commit(buf-&amp;gt;tail);&lt;br /&gt;
queue_work(system_unbound_wq, &amp;amp;buf-&amp;gt;work);&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
예약된 work의 함수는 &amp;lt;code&amp;gt;flush_to_ldisc()&amp;lt;/code&amp;gt;다. 따라서 이 i8042 경로에서 IRQ 쪽의 문자 적재와 작업 대기열(workqueue)을 실행하는 커널 worker 스레드의 입력 처리는 다른 실행 문맥이다. worker는 버퍼 mutex로 소비를 직렬화한다. 기본 port callback인 &amp;lt;code&amp;gt;tty_port_default_receive_buf()&amp;lt;/code&amp;gt;를 거쳐 &amp;lt;code&amp;gt;tty_ldisc_receive_buf()&amp;lt;/code&amp;gt;가 line discipline의 &amp;lt;code&amp;gt;receive_buf2&amp;lt;/code&amp;gt;를 호출한다. N_TTY에서는 &amp;lt;code&amp;gt;n_tty_receive_buf2()&amp;lt;/code&amp;gt;가 &amp;lt;code&amp;gt;n_tty_receive_buf_common()&amp;lt;/code&amp;gt;으로 연결된다.&amp;lt;ref name=&amp;quot;tty-buffer-v612&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;tty-port-v612&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/tty/tty_port.c?h=v6.12 Linux v6.12 drivers/tty/tty_port.c: tty_port_default_receive_buf()]&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;ntty-v612&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/tty/n_tty.c?h=v6.12 Linux v6.12 drivers/tty/n_tty.c: n_tty_receive_buf_common(), n_tty_receive_char_special(), n_tty_receive_char_canon(), n_tty_receive_handle_newline(), n_tty_read()]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 정규 모드의 줄 입력과 read 완료 ==&lt;br /&gt;
canonical 모드에서는 줄 경계가 완성되어야 읽기를 진행할 수 있다. 예를 들어 프로그램이 충분한 크기의 버퍼로 blocking read를 호출한 뒤 사용자가 &amp;lt;code&amp;gt;a&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;b&amp;lt;/code&amp;gt;를 입력해도, 문자는 N_TTY의 read buffer에 쌓이지만 아직 줄 경계는 공개되지 않는다. 입력된 문자는 read가 반환하기 전에도 화면에 echo로 표시될 수 있다.&lt;br /&gt;
&lt;br /&gt;
Enter의 콘솔 처리 함수 &amp;lt;code&amp;gt;fn_enter()&amp;lt;/code&amp;gt;는 우선 &amp;lt;code&amp;gt;&#039;\r&#039;&amp;lt;/code&amp;gt;를 넣는다. 여기서 가정한 설정에서는 &amp;lt;code&amp;gt;n_tty_receive_char_special()&amp;lt;/code&amp;gt;이 &amp;lt;code&amp;gt;ICRNL&amp;lt;/code&amp;gt;에 따라 이를 &amp;lt;code&amp;gt;&#039;\n&#039;&amp;lt;/code&amp;gt;으로 바꾼다. &amp;lt;code&amp;gt;n_tty_receive_char_canon()&amp;lt;/code&amp;gt;은 newline을 만나 &amp;lt;code&amp;gt;n_tty_receive_handle_newline()&amp;lt;/code&amp;gt;을 호출한다. 이 함수는 줄 경계 비트를 기록하고 &amp;lt;code&amp;gt;canon_head&amp;lt;/code&amp;gt;를 공개한 뒤 &amp;lt;code&amp;gt;wake_up_interruptible_poll(&amp;amp;tty-&amp;gt;read_wait, ...)&amp;lt;/code&amp;gt;로 독자를 깨운다.&amp;lt;ref name=&amp;quot;keyboard-v612&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;ntty-v612&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Backspace 입력으로 키맵이 만든 바이트가 TTY의 &amp;lt;code&amp;gt;ERASE_CHAR&amp;lt;/code&amp;gt;와 일치하면 &amp;lt;code&amp;gt;eraser()&amp;lt;/code&amp;gt;가 아직 확정되지 않은 줄을 편집한다. 따라서 &amp;lt;code&amp;gt;a&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;b&amp;lt;/code&amp;gt;, Backspace, Enter를 입력하면 이 조건에서 읽는 내용은 &amp;lt;code&amp;gt;a\n&amp;lt;/code&amp;gt;이다. EOF, 별도 EOL 문자, termios 설정은 다른 완료 조건을 만들 수 있다.&amp;lt;ref name=&amp;quot;ntty-v612&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 깨어난 프로세스와 GUI 터미널 ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;n_tty_read()&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;tty-&amp;gt;read_wait&amp;lt;/code&amp;gt;에 대기 항목을 넣고, 입력이 부족하면 &amp;lt;code&amp;gt;wait_woken(..., TASK_INTERRUPTIBLE, ...)&amp;lt;/code&amp;gt;으로 기다린다. 깨어난 태스크는 스케줄된 뒤 canonical buffer를 읽는다. v6.12에서는 먼저 커널 버퍼로 데이터를 반환하고, 바깥의 &amp;lt;code&amp;gt;iterate_tty_read()&amp;lt;/code&amp;gt;가 &amp;lt;code&amp;gt;copy_to_iter()&amp;lt;/code&amp;gt;로 사용자 쪽에 복사한다.&amp;lt;ref name=&amp;quot;ntty-v612&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;tty-io-v612&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/tty/tty_io.c?h=v6.12 Linux v6.12 drivers/tty/tty_io.c: tty_read(), iterate_tty_read()]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
GUI 터미널에서는 보통 evdev 입력을 받은 compositor 또는 디스플레이 서버와 사용자 공간 입력 처리를 거쳐 터미널 에뮬레이터가 PTY master에 바이트를 쓴다. 커널의 &amp;lt;code&amp;gt;pty_write()&amp;lt;/code&amp;gt;는 연결된 상대 TTY의 flip buffer로 데이터를 넣는다. 이쪽도 N_TTY를 사용할 수 있지만 앞부분의 콘솔 키맵 경로와는 다르다. 표준 입력이 파일이나 파이프에 연결되어 있으면 &amp;lt;code&amp;gt;read(0, ...)&amp;lt;/code&amp;gt;는 해당 객체의 읽기 경로를 따른다.&amp;lt;ref name=&amp;quot;pty-v612&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/tty/pty.c?h=v6.12 Linux v6.12 drivers/tty/pty.c: pty_write()]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=&amp;lt;- 이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/i8042 키보드 입력/evdev의 이벤트 전달과 대기 해제|evdev의 이벤트 전달과 대기 해제]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/x86-64/i8042 키보드 입력|i8042 키보드 입력 목차]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/BIOS_%EB%B6%80%ED%8C%85/GDT%EC%99%80_LDT_%EC%B4%88%EA%B8%B0%ED%99%94&amp;diff=690</id>
		<title>운영체제 기본/Linux/x86-64/BIOS 부팅/GDT와 LDT 초기화</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/BIOS_%EB%B6%80%ED%8C%85/GDT%EC%99%80_LDT_%EC%B4%88%EA%B8%B0%ED%99%94&amp;diff=690"/>
		<updated>2026-11-15T06:06:54Z</updated>

		<summary type="html">&lt;p&gt;관리자: 문체 정리: 과도한 강조, 반복 대조와 특수문자 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/진입 규약과 압축 해제|진입 규약과 압축 해제]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/x86-64/BIOS 부팅|BIOS 부팅 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/커널 초기화|커널 초기화]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
BIOS에서 출발해 GRUB의 &amp;lt;code&amp;gt;linux&amp;lt;/code&amp;gt; 명령으로 Linux v6.12 x86-64 bzImage를 부팅하는 경로에서는, GRUB이 32비트 보호 모드의 실행 환경을 만들어 압축 해제기의 &amp;lt;code&amp;gt;startup_32&amp;lt;/code&amp;gt;에 제어를 넘긴다. 이 시점에는 GRUB가 준비한 임시 GDT를 사용한다. Linux는 실행 모드의 전환, 압축 해제기의 이동, 커널 가상 주소로의 전환, CPU별 자료구조의 설치에 맞추어 GDTR을 여러 번 갱신한다. GRUB이 준비하는 초기 CPU 상태는 [[운영체제 기본/Linux/x86-64/BIOS 부팅/GRUB의 커널 적재와 제어권 전달|GRUB의 커널 적재와 제어권 전달]]에서 이어진다.&amp;lt;ref name=&amp;quot;gdt-boot&amp;quot;&amp;gt;[https://docs.kernel.org/6.12/arch/x86/boot.html Linux v6.12, The Linux/x86 Boot Protocol], 32-bit Boot Protocol.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 디스크립터와 선택자, 테이블 레지스터 ==&lt;br /&gt;
&lt;br /&gt;
디스크립터(descriptor)는 CPU가 세그먼트의 성질을 판단할 때 읽는 메모리상의 항목이다. 코드인지 데이터인지, 어느 특권 수준에서 접근할 수 있는지, 코드가 32비트인지 64비트인지 등을 담는다. GDT(Global Descriptor Table)는 그 항목들을 배열로 모은 것이다. GDT의 global은 LDT(Local Descriptor Table)와 대비되는 이름이며, CPU마다 별도의 GDT를 사용할 수 있다.&lt;br /&gt;
&lt;br /&gt;
선택자(selector)는 디스크립터를 선택하는 16비트 값이다. 상위 13비트는 인덱스, TI 비트는 GDT 또는 LDT의 선택, 하위 2비트는 요청 특권 수준인 RPL(Requested Privilege Level)이다. 예를 들어 x86-64 Linux의 &amp;lt;code&amp;gt;__KERNEL_CS&amp;lt;/code&amp;gt;는 GDT 인덱스 2를 가리키는 &amp;lt;code&amp;gt;0x10&amp;lt;/code&amp;gt;이다. 실행 모드는 선택한 디스크립터의 속성에 따라 정해진다.&amp;lt;ref name=&amp;quot;gdt-intel&amp;quot;&amp;gt;[https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html Intel 64 and IA-32 Architectures Software Developer&#039;s Manual], Volume 3A, System Architecture Overview, Protected-Mode Memory Management, Task Management. GDTR, LDTR, TR, 세그먼트 선택자와 IA-32e 모드의 테이블을 설명한다.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;gdt-segment&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/include/asm/segment.h?h=v6.12 Linux v6.12, arch/x86/include/asm/segment.h].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
! 항목 !! 무엇을 가리키는가 !! 적재 명령의 의미&lt;br /&gt;
|-&lt;br /&gt;
| GDTR || GDT의 선형 주소와 한계값 || &amp;lt;code&amp;gt;lgdt&amp;lt;/code&amp;gt;는 메모리의 base와 limit 묶음을 읽는다. 테이블 자체를 새로 생성하지 않는다.&lt;br /&gt;
|-&lt;br /&gt;
| CS, DS 등 || 코드 및 데이터 디스크립터의 선택자와 내부에 캐시된 속성 || 세그먼트 레지스터를 적재하면 해당 항목의 속성을 다시 읽는다. CS를 바꾸려면 far jump/return 같은 제어 이동이 필요하다.&lt;br /&gt;
|-&lt;br /&gt;
| LDTR || GDT 안의 LDT 디스크립터가 지정한 LDT || &amp;lt;code&amp;gt;lldt&amp;lt;/code&amp;gt;의 피연산자는 선택자다. null 선택자를 적재하면 사용할 LDT가 없는 상태가 된다.&lt;br /&gt;
|-&lt;br /&gt;
| TR(Task Register) || GDT 안의 TSS 디스크립터가 지정한 TSS || &amp;lt;code&amp;gt;ltr&amp;lt;/code&amp;gt;도 선택자를 받는다. TSS(Task State Segment)는 스택 정보 등을 담는 구조체다.&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;lgdt&amp;lt;/code&amp;gt;만 실행한다고 현재 CS의 내부 속성이 새 GDT의 내용으로 즉시 바뀌지 않는다. 이 때문에 아래 코드에서는 GDT를 바꾼 뒤 데이터 세그먼트를 다시 적재하고, far return으로 CS도 다시 적재한다.&amp;lt;ref name=&amp;quot;gdt-intel&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 부트로더와 압축 해제기의 GDT ==&lt;br /&gt;
32비트 부트 프로토콜은 진입 시 페이징이 꺼진 보호 모드, 비활성화된 인터럽트, GDT의 적절한 32비트 코드 및 데이터 세그먼트를 요구한다. CS는 &amp;lt;code&amp;gt;__BOOT_CS=0x10&amp;lt;/code&amp;gt;, DS, ES, SS는 &amp;lt;code&amp;gt;__BOOT_DS=0x18&amp;lt;/code&amp;gt;이며, 세그먼트는 base 0의 평탄한 주소 공간을 제공한다. &amp;lt;code&amp;gt;%esi&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;boot_params&amp;lt;/code&amp;gt;를 가리킨다. GRUB는 이 상태로 Linux에 제어권을 넘긴다.&amp;lt;ref name=&amp;quot;gdt-boot&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;gdt-segment&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
압축 해제기의 &amp;lt;code&amp;gt;arch/x86/boot/compressed/head_64.S:startup_32&amp;lt;/code&amp;gt;는 먼저 실제 적재 주소를 계산한다. 그 주소를 이용해 자체 &amp;lt;code&amp;gt;gdt&amp;lt;/code&amp;gt;의 base를 고친 뒤 &amp;lt;code&amp;gt;lgdt&amp;lt;/code&amp;gt;를 실행한다. 이 GDT에는 32비트 커널 코드, 64비트 커널 코드, 데이터, 부트용 TSS 디스크립터가 들어 있다.&amp;lt;ref name=&amp;quot;gdt-compressed&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/boot/compressed/head_64.S?h=v6.12 Linux v6.12, arch/x86/boot/compressed/head_64.S], startup_32, startup_64, gdt, gdt64.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
다음은 이 교체를 보여 주는 원본의 일부다. &amp;lt;code&amp;gt;rva()&amp;lt;/code&amp;gt;는 압축 해제기 시작점에 대한 상대 위치를 나타내며, 이 구간에서 &amp;lt;code&amp;gt;%ebp&amp;lt;/code&amp;gt;는 실제 적재 위치를 반영한다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
/* arch/x86/boot/compressed/head_64.S:startup_32 */&lt;br /&gt;
leal    rva(gdt)(%ebp), %eax&lt;br /&gt;
movl    %eax, 2(%eax)&lt;br /&gt;
lgdt    (%eax)&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이어서 &amp;lt;code&amp;gt;__BOOT_DS&amp;lt;/code&amp;gt;를 DS, ES, FS, GS, SS에 넣고, 스택을 준비한다. &amp;lt;code&amp;gt;__KERNEL32_CS&amp;lt;/code&amp;gt;와 다음 명령의 주소를 스택에 쌓은 뒤 &amp;lt;code&amp;gt;lretl&amp;lt;/code&amp;gt;로 CS를 새 GDT의 32비트 코드 항목으로 바꾼다. 같은 선택자라도 GDT 교체 전후에 디스크립터의 속성이 달라질 수 있으므로 CS를 다시 적재한다.&amp;lt;ref name=&amp;quot;gdt-compressed&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 64비트 모드 전환과 GDT ==&lt;br /&gt;
압축 해제기는 PAE를 켜고 초기 페이지 테이블을 준비해 CR3에 넣으며, EFER의 LME 비트를 설정한다. 이어서 다음과 같이 LDTR을 비우고 부트용 TSS 선택자를 TR에 적재한다.&amp;lt;ref name=&amp;quot;gdt-compressed&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
/* arch/x86/boot/compressed/head_64.S:startup_32 */&lt;br /&gt;
xorl    %eax, %eax&lt;br /&gt;
lldt    %ax&lt;br /&gt;
movl    $__BOOT_TSS, %eax&lt;br /&gt;
ltr     %ax&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
여기서 &amp;lt;code&amp;gt;lldt %ax&amp;lt;/code&amp;gt;는 0인 선택자를 넣어 LDT를 사용하지 않도록 한다. 부트용 TSS 역시 나중에 CPU별 예외 스택을 담을 정상 운영용 TSS와 구분해야 한다.&lt;br /&gt;
&lt;br /&gt;
그 다음 &amp;lt;code&amp;gt;__KERNEL_CS&amp;lt;/code&amp;gt;와 압축 해제기의 &amp;lt;code&amp;gt;startup_64&amp;lt;/code&amp;gt; 주소를 스택에 놓고 CR0.PG를 켠다. 이때 페이징과 long mode가 활성화되어도 기존 CS의 속성은 여전히 32비트 코드이므로, 마지막 &amp;lt;code&amp;gt;lret&amp;lt;/code&amp;gt;로 CS.L=1인 항목을 선택해야 64비트 명령 실행으로 넘어간다. 페이지 테이블은 주소 변환을 준비하고, 코드 디스크립터는 어느 실행 모드의 코드를 실행할지 결정한다.&amp;lt;ref name=&amp;quot;gdt-compressed&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;gdt-intel&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
GRUB handoff          startup_32                  startup_64&lt;br /&gt;
------------------    ------------------------    ---------------------&lt;br /&gt;
32-bit protected      load decompressor GDT       execute 64-bit code&lt;br /&gt;
paging off        --&amp;gt; reload DS/ES/SS and CS   --&amp;gt; reload GDT and CS&lt;br /&gt;
GRUB GDT              clear LDTR, load boot TR    relocate decompressor&lt;br /&gt;
                      enable PAE, LME, paging     repoint GDTR&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
압축 해제기의 &amp;lt;code&amp;gt;startup_64&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;gdt64&amp;lt;/code&amp;gt;를 이용해 GDTR을 다시 적재하고 &amp;lt;code&amp;gt;lretq&amp;lt;/code&amp;gt;로 CS를 확인한다. 여기서 &amp;lt;code&amp;gt;gdt64&amp;lt;/code&amp;gt;는 같은 &amp;lt;code&amp;gt;gdt&amp;lt;/code&amp;gt;를 가리킬 64비트 base를 담는 GDTR 적재용 구조다. 이후 압축 해제기를 다른 위치로 복사하면 GDTR도 복사된 GDT를 가리키도록 다시 바꾼다. 이전 위치의 GDT가 복사나 압축 해제 과정에서 덮일 수 있기 때문이다. 이 단계에서는 실행 모드와 메모리 위치가 바뀔 때마다 &amp;lt;code&amp;gt;lgdt&amp;lt;/code&amp;gt;를 실행한다.&amp;lt;ref name=&amp;quot;gdt-compressed&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 커널의 CPU별 GDT 설치 ==&lt;br /&gt;
압축 해제기가 넘기는 다음 &amp;lt;code&amp;gt;startup_64&amp;lt;/code&amp;gt;는 다른 파일의 다른 진입점이다. &amp;lt;code&amp;gt;arch/x86/kernel/head_64.S:startup_64&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;startup_64_setup_gdt_idt()&amp;lt;/code&amp;gt;를 호출한다. 이 함수는 초기 CPU용 &amp;lt;code&amp;gt;gdt_page.gdt&amp;lt;/code&amp;gt;를 현재 접근 가능한 주소로 가리키는 GDTR 값을 만들고 &amp;lt;code&amp;gt;native_load_gdt()&amp;lt;/code&amp;gt;로 적재한다. 이어 DS, SS, ES를 &amp;lt;code&amp;gt;__KERNEL_DS&amp;lt;/code&amp;gt;로 다시 적재한다.&amp;lt;ref name=&amp;quot;gdt-head&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/kernel/head_64.S?h=v6.12 Linux v6.12, arch/x86/kernel/head_64.S], startup_64와 .Lsetup_gdt.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;gdt-headc&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/kernel/head64.c?h=v6.12 Linux v6.12, arch/x86/kernel/head64.c], startup_64_setup_gdt_idt().&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
본체의 공통 초기 경로에 있는 &amp;lt;code&amp;gt;.Lsetup_gdt&amp;lt;/code&amp;gt;에서는 &amp;lt;code&amp;gt;gdt_page&amp;lt;/code&amp;gt;와 CPU별 오프셋으로 GDT 주소를 구해 다시 &amp;lt;code&amp;gt;lgdt&amp;lt;/code&amp;gt;한다. 이제 GDTR도 커널 주소 공간에서 계속 접근할 수 있는 주소를 가리켜야 한다. 초기에 접근 가능하던 낮은 주소에 GDT가 남아 있다면, 그 매핑을 제거한 뒤에는 새로운 디스크립터를 읽을 수 없기 때문이다.&amp;lt;ref name=&amp;quot;gdt-head&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;gdt_page&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;arch/x86/kernel/cpu/common.c&amp;lt;/code&amp;gt;에서 &amp;lt;code&amp;gt;DEFINE_PER_CPU_PAGE_ALIGNED&amp;lt;/code&amp;gt;로 선언된다. 32비트와 64비트 커널 코드와 사용자 코드, 커널 및 사용자 데이터 항목 등은 정적 초기값을 가진다. 초기 부트 CPU용 영역에서 시작하고, &amp;lt;code&amp;gt;start_kernel()&amp;lt;/code&amp;gt;의 &amp;lt;code&amp;gt;setup_per_cpu_areas()&amp;lt;/code&amp;gt; 단계에서 정규 CPU별 영역을 준비한 뒤 부트 CPU도 &amp;lt;code&amp;gt;switch_gdt_and_percpu_base()&amp;lt;/code&amp;gt;로 그 영역으로 옮겨 간다.&amp;lt;ref name=&amp;quot;gdt-common&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/kernel/cpu/common.c?h=v6.12 Linux v6.12, arch/x86/kernel/cpu/common.c], gdt_page, cpu_init_exception_handling(), cpu_init(), load_fixmap_gdt().&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;gdt-percpu&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/kernel/setup_percpu.c?h=v6.12 Linux v6.12, arch/x86/kernel/setup_percpu.c], setup_per_cpu_areas().&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이 순서 이후 &amp;lt;code&amp;gt;trap_init()&amp;lt;/code&amp;gt;이 CPU entry area와 정상 운영용 TSS를 준비한다. 다음 도식은 부트 CPU의 관계를 요약한다. 전체 커널 초기화 순서는 [[운영체제 기본/Linux/x86-64/BIOS 부팅/커널 초기화|커널 초기화]]에서 이어진다.&amp;lt;ref name=&amp;quot;gdt-main&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/init/main.c?h=v6.12 Linux v6.12, init/main.c], start_kernel().&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;gdt-traps&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/kernel/traps.c?h=v6.12 Linux v6.12, arch/x86/kernel/traps.c], trap_init().&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
Native kernel startup_64&lt;br /&gt;
  |&lt;br /&gt;
  +--&amp;gt; startup_64_setup_gdt_idt()   initial kernel GDT&lt;br /&gt;
  +--&amp;gt; .Lsetup_gdt                 kernel-address GDT&lt;br /&gt;
  |&lt;br /&gt;
start_kernel()&lt;br /&gt;
  |&lt;br /&gt;
  +--&amp;gt; setup_per_cpu_areas()       permanent per-CPU storage&lt;br /&gt;
  |      +--&amp;gt; switch_gdt_and_percpu_base()&lt;br /&gt;
  |&lt;br /&gt;
  +--&amp;gt; trap_init()&lt;br /&gt;
         +--&amp;gt; setup_cpu_entry_areas()&lt;br /&gt;
         +--&amp;gt; cpu_init_exception_handling(true)&lt;br /&gt;
         |      +--&amp;gt; set_tss_desc()&lt;br /&gt;
         |      +--&amp;gt; load_TR_desc()             LTR&lt;br /&gt;
         +--&amp;gt; cpu_init()&lt;br /&gt;
                +--&amp;gt; load_mm_ldt(&amp;amp;init_mm)      null LDTR&lt;br /&gt;
                +--&amp;gt; load_fixmap_gdt(cpu)       LGDT&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 정상 운영용 TSS와 LDT 초기화 ==&lt;br /&gt;
=== TSS와 예외 진입 상태 ===&lt;br /&gt;
64비트 Linux는 소프트웨어로 태스크를 전환하고, TSS는 스택 정보를 제공하는 데 사용한다. [[운영체제 기본/장치 제어와 입출력#처리 진입점과 IDT|IDT를 통한 처리 진입]]에서 TSS는 특권 전환용 스택과 IST(Interrupt Stack Table) 정보를 제공한다. 예를 들어 이중 오류나 NMI를 현재 실행 중인 코드의 불안정한 스택과 분리된 스택으로 받는 데 쓰인다. 이는 [[운영체제 기본/보호|보호]]에서 다루는 안전한 커널 진입의 구체적인 장치다.&amp;lt;ref name=&amp;quot;gdt-intel&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;gdt-common&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
v6.12에서는 &amp;lt;code&amp;gt;trap_init()&amp;lt;/code&amp;gt;가 먼저 &amp;lt;code&amp;gt;setup_cpu_entry_areas()&amp;lt;/code&amp;gt;를 부른다. 이어 &amp;lt;code&amp;gt;cpu_init_exception_handling(true)&amp;lt;/code&amp;gt;가 CPU별 &amp;lt;code&amp;gt;cpu_tss_rw&amp;lt;/code&amp;gt;의 IST 및 I/O 비트맵 상태를 준비하고, &amp;lt;code&amp;gt;set_tss_desc()&amp;lt;/code&amp;gt;로 GDT의 TSS 디스크립터를 설정한다. 마지막으로 &amp;lt;code&amp;gt;load_TR_desc()&amp;lt;/code&amp;gt;가 실제 &amp;lt;code&amp;gt;ltr&amp;lt;/code&amp;gt;를 수행한다. 즉 TSS 메모리 준비, GDT에 주소 기록, TR 적재의 세 단계다.&amp;lt;ref name=&amp;quot;gdt-traps&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;gdt-common&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;gdt-desc&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/include/asm/desc.h?h=v6.12 Linux v6.12, arch/x86/include/asm/desc.h], native_load_gdt(), native_load_tr_desc(), native_set_ldt(), clear_LDT().&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
그 뒤의 &amp;lt;code&amp;gt;cpu_init()&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;load_sp0()&amp;lt;/code&amp;gt;로 진입 스택을 지정하고, 마지막에 &amp;lt;code&amp;gt;load_fixmap_gdt(cpu)&amp;lt;/code&amp;gt;를 통해 CPU별 GDT의 읽기 전용 매핑을 GDTR에 적재한다. 쓰기용 원본과 CPU가 읽는 매핑은 같은 테이블에 서로 다른 주소와 권한으로 접근한다.&amp;lt;ref name=&amp;quot;gdt-common&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;gdt-desc&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;gdt-cea&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/mm/cpu_entry_area.c?h=v6.12 Linux v6.12, arch/x86/mm/cpu_entry_area.c], setup_cpu_entry_area().&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== 기본 부팅의 LDT 비활성화 ===&lt;br /&gt;
기본 부팅의 &amp;lt;code&amp;gt;init_mm&amp;lt;/code&amp;gt;에는 사용자 LDT가 없으므로, &amp;lt;code&amp;gt;cpu_init()&amp;lt;/code&amp;gt;의 &amp;lt;code&amp;gt;load_mm_ldt(&amp;amp;init_mm)&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;clear_LDT()&amp;lt;/code&amp;gt; 경로로 가고, 최종적으로 0 선택자를 &amp;lt;code&amp;gt;lldt&amp;lt;/code&amp;gt;한다. 앞서 압축 해제기에서 LDTR을 비운 것과 일관되게, 사용하지 않는 상태를 명시적으로 만든다.&amp;lt;ref name=&amp;quot;gdt-common&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;gdt-ldt&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/kernel/ldt.c?h=v6.12 Linux v6.12, arch/x86/kernel/ldt.c], load_mm_ldt(), switch_ldt(), modify_ldt 시스템 콜.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;gdt-desc&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이후 &amp;lt;code&amp;gt;CONFIG_MODIFY_LDT_SYSCALL&amp;lt;/code&amp;gt;이 활성화되어 있고 사용자 프로그램이 &amp;lt;code&amp;gt;modify_ldt()&amp;lt;/code&amp;gt;를 요청하면, 해당 &amp;lt;code&amp;gt;mm&amp;lt;/code&amp;gt;의 &amp;lt;code&amp;gt;mm-&amp;gt;context.ldt&amp;lt;/code&amp;gt;에 실제 LDT가 생길 수 있다. 그때는 GDT의 LDT 디스크립터에 테이블의 주소와 크기를 기록하고, 그 항목의 선택자를 LDTR에 적재한다. 이 경로는 호환성 등의 목적으로 LDT가 필요한 사용자 실행 문맥을 설정한다.&amp;lt;ref name=&amp;quot;gdt-ldt&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;gdt-desc&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;gdt-mmucontext&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/include/asm/mmu_context.h?h=v6.12 Linux v6.12, arch/x86/include/asm/mmu_context.h], CONFIG_MODIFY_LDT_SYSCALL과 load_mm_ldt().&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== long mode의 GDT 역할 ==&lt;br /&gt;
64비트 코드의 일반적인 주소 계산에서는 CS·DS, ES, SS의 base가 0으로 취급되고 전통적인 세그먼트 limit 검사도 대부분 적용되지 않는다. 프로세스별 주소 공간과 페이지 단위 접근 제어의 중심은 페이지 테이블이다. GDT는 코드의 실행 모드와 특권 수준, 사용자 모드 복귀 시 선택자 검사, TSS와 LDT 같은 시스템 디스크립터에 계속 사용된다. FS와 GS의 base도 별도 의미를 유지한다. 주소 변환 자체는 [[운영체제 기본/가상 메모리|가상 메모리]], 특권 수준과 진입과 복귀는 [[운영체제 기본/보호|보호]]와 구분해 읽는다.&amp;lt;ref name=&amp;quot;gdt-intel&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;gdt-common&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;references/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/진입 규약과 압축 해제|진입 규약과 압축 해제]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/x86-64/BIOS 부팅|BIOS 부팅 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/커널 초기화|커널 초기화]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/i8042_%ED%82%A4%EB%B3%B4%EB%93%9C_%EC%9E%85%EB%A0%A5/evdev%EC%9D%98_%EC%9D%B4%EB%B2%A4%ED%8A%B8_%EC%A0%84%EB%8B%AC%EA%B3%BC_%EB%8C%80%EA%B8%B0_%ED%95%B4%EC%A0%9C&amp;diff=689</id>
		<title>운영체제 기본/Linux/x86-64/i8042 키보드 입력/evdev의 이벤트 전달과 대기 해제</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/i8042_%ED%82%A4%EB%B3%B4%EB%93%9C_%EC%9E%85%EB%A0%A5/evdev%EC%9D%98_%EC%9D%B4%EB%B2%A4%ED%8A%B8_%EC%A0%84%EB%8B%AC%EA%B3%BC_%EB%8C%80%EA%B8%B0_%ED%95%B4%EC%A0%9C&amp;diff=689"/>
		<updated>2026-11-15T06:06:40Z</updated>

		<summary type="html">&lt;p&gt;관리자: 반복 대조와 불필요한 강조 설명 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=&amp;lt;- 이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/i8042 키보드 입력/i8042와 입력 이벤트|i8042와 입력 이벤트]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/x86-64/i8042 키보드 입력|i8042 키보드 입력 목차]]&lt;br /&gt;
|다음=다음 문서 -&amp;gt;&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/i8042 키보드 입력/콘솔과 터미널 입력|콘솔과 터미널 입력]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
Linux v6.12에서 input core까지 도착한 키 입력을 사용자 프로그램에 전달하는 과정을 살펴본다. 커널 내부의 이벤트를 열린 장치 파일의 버퍼에 넣고, 기다리던 태스크를 실행 가능하게 만들고, 그 태스크가 다시 실행될 때 사용자 메모리로 복사해야 한다. 이 장에서는 프로그램이 권한을 갖고 &amp;lt;code&amp;gt;/dev/input/eventN&amp;lt;/code&amp;gt;을 열어 blocking &amp;lt;code&amp;gt;read()&amp;lt;/code&amp;gt;를 호출한 경우를 다룬다.&lt;br /&gt;
&lt;br /&gt;
== input core와 evdev 클라이언트 ==&lt;br /&gt;
&amp;lt;code&amp;gt;input_pass_values()&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;dev-&amp;gt;event_lock&amp;lt;/code&amp;gt;을 잡고 로컬 인터럽트가 비활성화된 상태에서 호출된다. 연결된 열린 input handle의 &amp;lt;code&amp;gt;handle_events&amp;lt;/code&amp;gt;를 호출하며, 독점 grab이 있으면 그 handle만 선택한다. v6.12의 &amp;lt;code&amp;gt;input_register_handle()&amp;lt;/code&amp;gt;은 handler 형태에 따라 이 함수 포인터를 설정한다. evdev처럼 &amp;lt;code&amp;gt;.events&amp;lt;/code&amp;gt;를 제공하는 handler는 묶음 이벤트를 직접 받는다.&amp;lt;ref name=&amp;quot;input-v612&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/input/input.c?h=v6.12 Linux v6.12 drivers/input/input.c: input_pass_values(), input_register_handle()]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;evdev_events()&amp;lt;/code&amp;gt;는 RCU(Read-Copy Update)로 보호되는 클라이언트 목록을 순회하여 &amp;lt;code&amp;gt;evdev_pass_values()&amp;lt;/code&amp;gt;를 호출한다. 여기서 RCU는 목록을 읽는 동안 다른 CPU에서 제거한 객체가 너무 일찍 해제되지 않도록 하는 동기화 수단이다. 각각의 열린 파일에는 별도의 &amp;lt;code&amp;gt;evdev_client&amp;lt;/code&amp;gt;와 원형 버퍼가 있다. 보통 여러 독자는 각각 이벤트 사본을 받으므로 한 독자의 읽기가 다른 독자의 이벤트를 소비하지 않는다. 다만 evdev의 독점 grab과 클라이언트별 이벤트 필터는 전달 대상을 바꿀 수 있다. 생산자는 &amp;lt;code&amp;gt;buffer_lock&amp;lt;/code&amp;gt; 아래에서 시간, type, code, value를 갖는 &amp;lt;code&amp;gt;input_event&amp;lt;/code&amp;gt;를 기록한다.&amp;lt;ref name=&amp;quot;evdev-v612&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/input/evdev.c?h=v6.12 Linux v6.12 drivers/input/evdev.c: evdev_events(), evdev_pass_values(), __pass_event(), evdev_read(), evdev_poll()]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 패킷의 완료와 대기 큐 ==&lt;br /&gt;
&lt;br /&gt;
원형 버퍼의 &amp;lt;code&amp;gt;head&amp;lt;/code&amp;gt;는 기록 위치이고 &amp;lt;code&amp;gt;tail&amp;lt;/code&amp;gt;은 소비 위치다. &amp;lt;code&amp;gt;packet_head&amp;lt;/code&amp;gt;는 완성된 패킷의 끝을 나타낸다. 다음 실제 코드는 &amp;lt;code&amp;gt;__pass_event()&amp;lt;/code&amp;gt;의 일부다.&amp;lt;ref name=&amp;quot;evdev-v612&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
if (event-&amp;gt;type == EV_SYN &amp;amp;&amp;amp; event-&amp;gt;code == SYN_REPORT) {&lt;br /&gt;
	client-&amp;gt;packet_head = client-&amp;gt;head;&lt;br /&gt;
	kill_fasync(&amp;amp;client-&amp;gt;fasync, SIGIO, POLL_IN);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
읽기 가능성은 완성된 패킷이 있는지, 즉 &amp;lt;code&amp;gt;packet_head != tail&amp;lt;/code&amp;gt;인지로 판정한다. &amp;lt;code&amp;gt;evdev_pass_values()&amp;lt;/code&amp;gt;는 비어 있지 않은 &amp;lt;code&amp;gt;SYN_REPORT&amp;lt;/code&amp;gt;를 처리하면 버퍼 잠금을 푼 다음 &amp;lt;code&amp;gt;wake_up_interruptible_poll(&amp;amp;client-&amp;gt;wait, ...)&amp;lt;/code&amp;gt;을 호출한다. 이것이 패킷 경계를 독자에게 공개하는 지점이다. 입력이 소비보다 빨라 버퍼가 넘치면 &amp;lt;code&amp;gt;SYN_DROPPED&amp;lt;/code&amp;gt;가 남으므로, 사용자 프로그램은 이를 확인하여 이벤트 손실을 처리해야 한다.&amp;lt;ref name=&amp;quot;evdev-v612&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 대기 중인 read의 재개 ==&lt;br /&gt;
&amp;lt;code&amp;gt;evdev_read()&amp;lt;/code&amp;gt;는 완성된 이벤트가 없으면 다음 조건으로 기다린다. 장치 제거와 접근 철회 역시 대기 종료 조건에 포함된다.&amp;lt;ref name=&amp;quot;evdev-v612&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
error = wait_event_interruptible(client-&amp;gt;wait,&lt;br /&gt;
		client-&amp;gt;packet_head != client-&amp;gt;tail ||&lt;br /&gt;
		!evdev-&amp;gt;exist || client-&amp;gt;revoked);&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
정상적인 blocking read에서 태스크는 이 조건을 기다리며 잠들 수 있다. IRQ 쪽의 깨우기는 그 태스크를 실행 가능한 상태로 돌려놓는다. 이후 스케줄러가 태스크를 선택하면 원래의 시스템 콜(System Call) 문맥에서 조건을 다시 확인하고 읽기를 계속한다. 신호가 도착한 경우에는 정상 입력 반환 대신 중단 관련 오류 경로를 밟을 수도 있다.&lt;br /&gt;
&lt;br /&gt;
소비자는 &amp;lt;code&amp;gt;evdev_fetch_next_event()&amp;lt;/code&amp;gt;에서 &amp;lt;code&amp;gt;spin_lock_irq()&amp;lt;/code&amp;gt;로 같은 버퍼를 보호하고 이벤트 하나를 커널 임시 변수로 꺼낸다. 잠금을 해제한 뒤 &amp;lt;code&amp;gt;input_event_to_user()&amp;lt;/code&amp;gt;를 호출한다. 이 helper 내부의 &amp;lt;code&amp;gt;copy_to_user()&amp;lt;/code&amp;gt;가 사용자 버퍼에 실제 데이터를 옮긴다. 반환값은 복사한 바이트 수이며, ABI 호환 처리는 helper가 담당한다.&amp;lt;ref name=&amp;quot;compat-v612&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/input/input-compat.c?h=v6.12 Linux v6.12 drivers/input/input-compat.c: input_event_to_user()]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 사용자 공간의 입력 이벤트 ==&lt;br /&gt;
이 read는 &amp;lt;code&amp;gt;EV_KEY / KEY_A / 1&amp;lt;/code&amp;gt; 같은 구조화된 이벤트를 반환한다. Shift, 키보드 배열, 입력기 등을 해석하여 문자를 만드는 책임은 별도의 계층에 있다. &amp;lt;code&amp;gt;O_NONBLOCK&amp;lt;/code&amp;gt;이면 준비된 패킷이 없을 때 잠들지 않고 &amp;lt;code&amp;gt;-EAGAIN&amp;lt;/code&amp;gt;을 반환한다. &amp;lt;code&amp;gt;poll()&amp;lt;/code&amp;gt; 계열은 &amp;lt;code&amp;gt;evdev_poll()&amp;lt;/code&amp;gt;에서 같은 &amp;lt;code&amp;gt;client-&amp;gt;wait&amp;lt;/code&amp;gt;에 관심을 등록하고 같은 패킷 조건을 검사한다.&amp;lt;ref name=&amp;quot;evdev-v612&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=&amp;lt;- 이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/i8042 키보드 입력/i8042와 입력 이벤트|i8042와 입력 이벤트]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/x86-64/i8042 키보드 입력|i8042 키보드 입력 목차]]&lt;br /&gt;
|다음=다음 문서 -&amp;gt;&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/i8042 키보드 입력/콘솔과 터미널 입력|콘솔과 터미널 입력]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%ED%8C%8C%EC%9D%BC_%EC%8B%9C%EC%8A%A4%ED%85%9C_%EC%BD%9C/%ED%8C%8C%EC%9D%BC_%EC%98%A4%ED%94%84%EC%85%8B%EA%B3%BC_%EC%97%B4%EB%A6%B0_%ED%8C%8C%EC%9D%BC%EC%9D%98_%EC%88%98%EB%AA%85&amp;diff=688</id>
		<title>운영체제 기본/Linux/파일 시스템 콜/파일 오프셋과 열린 파일의 수명</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%ED%8C%8C%EC%9D%BC_%EC%8B%9C%EC%8A%A4%ED%85%9C_%EC%BD%9C/%ED%8C%8C%EC%9D%BC_%EC%98%A4%ED%94%84%EC%85%8B%EA%B3%BC_%EC%97%B4%EB%A6%B0_%ED%8C%8C%EC%9D%BC%EC%9D%98_%EC%88%98%EB%AA%85&amp;diff=688"/>
		<updated>2026-11-15T06:06:34Z</updated>

		<summary type="html">&lt;p&gt;관리자: 문체 정리: 반복 강조와 비표준 문자 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/파일 시스템 콜/read와 write|read와 write]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/파일 시스템 콜|파일 시스템 콜 목차]]&lt;br /&gt;
|다음=마지막 문서&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
파일 위치는 열린 파일 객체에 저장된다. 이 구분은 &amp;lt;code&amp;gt;lseek()&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;pread()&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;pwrite()&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;dup()&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;close()&amp;lt;/code&amp;gt;의 동작을 함께 설명한다. 기준은 Linux v6.12다.&lt;br /&gt;
&lt;br /&gt;
== 파일 위치의 변경 ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;lseek(fd, offset, whence)&amp;lt;/code&amp;gt;는 열린 파일의 다음 입출력 위치를 바꾸고 새 위치를 반환한다. &amp;lt;code&amp;gt;ksys_lseek()&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;fdget_pos()&amp;lt;/code&amp;gt;로 파일을 얻고, &amp;lt;code&amp;gt;vfs_llseek()&amp;lt;/code&amp;gt;에서 탐색 가능 여부를 확인한 뒤 &amp;lt;code&amp;gt;f_op-&amp;gt;llseek&amp;lt;/code&amp;gt;를 호출한다. 일반 파일은 &amp;lt;code&amp;gt;SEEK_SET&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;SEEK_CUR&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;SEEK_END&amp;lt;/code&amp;gt;를 통해 시작점, 현재 위치, 끝을 기준으로 위치를 정할 수 있다. 파이프 같은 탐색 불가능한 대상은 &amp;lt;code&amp;gt;ESPIPE&amp;lt;/code&amp;gt;로 실패한다.&amp;lt;ref name=&amp;quot;rw&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/read_write.c?h=v6.12 Linux v6.12 fs/read_write.c], ksys_lseek, vfs_llseek, ksys_pread64, ksys_pwrite64.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
위치를 바꾸는 것만으로 데이터를 읽거나 파일을 늘리는 것은 아니다. 파일 끝을 넘는 위치로 이동한 뒤 실제로 쓰면 파일 크기가 늘어날 수 있고, 그 사이에 쓰지 않은 구간은 hole로 표현될 수 있다. 논리적 파일 범위와 실제 블록 할당의 구분은 [[운영체제 기본/파일과 입출력|파일과 입출력]]에서 다룬다.&lt;br /&gt;
&lt;br /&gt;
== 명시적 위치의 입출력 ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;pread(fd, buf, count, offset)&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;pwrite(fd, buf, count, offset)&amp;lt;/code&amp;gt;는 호출 인자로 위치를 전달한다. &amp;lt;code&amp;gt;ksys_pread64()&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;ksys_pwrite64()&amp;lt;/code&amp;gt;도 &amp;lt;code&amp;gt;vfs_read()&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;vfs_write()&amp;lt;/code&amp;gt;를 사용하지만, 전달받은 위치를 지역 변수로 넘긴다. 공유 위치인 &amp;lt;code&amp;gt;file-&amp;gt;f_pos&amp;lt;/code&amp;gt;는 갱신하지 않는다.&amp;lt;ref name=&amp;quot;rw&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
f_pos = 10&lt;br /&gt;
pread(fd, buf, 4, 0) -&amp;gt; 파일의 0~3번째 바이트, f_pos는 10 유지&lt;br /&gt;
read(fd, buf, 4)     -&amp;gt; 파일의 10번째부터 읽기, f_pos 진행&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이 방식은 여러 스레드가 서로 다른 구간을 다룰 때 &amp;lt;code&amp;gt;lseek()&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;read()&amp;lt;/code&amp;gt; 두 호출 사이의 위치 변경 경쟁을 피한다. 파일 내용 자체에 대한 동시 읽기와 쓰기까지 원자적으로 만드는 것은 아니다. Linux의 &amp;lt;code&amp;gt;O_APPEND&amp;lt;/code&amp;gt; 파일에서는 &amp;lt;code&amp;gt;pwrite()&amp;lt;/code&amp;gt;도 지정 위치 대신 끝에 쓸 수 있으므로, 지정 위치 쓰기 예제는 &amp;lt;code&amp;gt;O_APPEND&amp;lt;/code&amp;gt; 없이 연 파일을 기준으로 한다.&amp;lt;ref name=&amp;quot;man-pread&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man2/pread.2.html Linux man-pages, pread(2)].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 파일 디스크립터 복제와 위치 공유 ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;dup(fd)&amp;lt;/code&amp;gt;는 새로운 fd 슬롯에 같은 &amp;lt;code&amp;gt;struct file&amp;lt;/code&amp;gt;의 참조를 설치한다. 따라서 두 fd는 위치와 파일 상태 플래그를 공유한다. 일반적인 &amp;lt;code&amp;gt;fork()&amp;lt;/code&amp;gt; 뒤 부모와 자식의 대응 fd도 같은 열린 파일 객체를 참조한다. 반면 같은 경로를 별도로 두 번 열면 각각의 파일 위치를 가진다.&amp;lt;ref name=&amp;quot;file&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/file.c?h=v6.12 Linux v6.12 fs/file.c], dup, fget_raw, fd_install, dup_fd, fdget_pos.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
fd 3 ----+                         fd 3 -&amp;gt; struct file A (f_pos = 0)&lt;br /&gt;
         +-&amp;gt; struct file (f_pos)                |&lt;br /&gt;
fd 4 ----+                                  같은 inode&lt;br /&gt;
  dup(3)                                       |&lt;br /&gt;
                                   fd 4 -&amp;gt; struct file B (f_pos = 0)&lt;br /&gt;
                                     같은 경로를 별도로 openat&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
파일에 &amp;lt;code&amp;gt;ABCDE&amp;lt;/code&amp;gt;가 있고 fd 3을 복제해 fd 4를 얻었다면, fd 3에서 한 바이트를 읽은 뒤 fd 4에서 한 바이트를 읽으면 각각 &amp;lt;code&amp;gt;A&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;B&amp;lt;/code&amp;gt;를 얻는다. &amp;lt;code&amp;gt;fdget_pos()&amp;lt;/code&amp;gt;는 필요한 경우 파일 위치 락을 잡아 개별 입출력의 위치 갱신을 조정한다. 그러나 여러 시스템 콜을 묶은 작업 전체를 자동으로 하나의 임계구역으로 만들어 주지는 않는다.&amp;lt;ref name=&amp;quot;file&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 닫기와 마지막 참조 ==&lt;br /&gt;
&lt;br /&gt;
Linux v6.12의 &amp;lt;code&amp;gt;close&amp;lt;/code&amp;gt; 시스템 콜은 먼저 &amp;lt;code&amp;gt;file_close_fd()&amp;lt;/code&amp;gt;로 슬롯을 비우고 fd 번호를 다시 사용할 수 있게 한다. 이어 &amp;lt;code&amp;gt;filp_flush()&amp;lt;/code&amp;gt;로 닫기 처리를 수행하고, &amp;lt;code&amp;gt;__fput_sync()&amp;lt;/code&amp;gt;로 열린 파일에 대한 참조를 내려놓는다. 마지막 참조라면 &amp;lt;code&amp;gt;__fput()&amp;lt;/code&amp;gt;이 &amp;lt;code&amp;gt;f_op-&amp;gt;release&amp;lt;/code&amp;gt; 등의 최종 정리를 수행한다.&amp;lt;ref name=&amp;quot;open&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/open.c?h=v6.12 Linux v6.12 fs/open.c], close, filp_flush.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;table&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/file_table.c?h=v6.12 Linux v6.12 fs/file_table.c], __fput_sync, __fput.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
close(3)&lt;br /&gt;
  -&amp;gt; fd[3] = NULL, 번호 재사용 가능&lt;br /&gt;
  -&amp;gt; 닫기 처리와 참조 감소&lt;br /&gt;
       +- 다른 참조 있음: struct file 유지&lt;br /&gt;
       +- 마지막 참조: release 등 최종 정리&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
복제한 fd가 남아 있거나 진행 중인 입출력이나 메모리 매핑이 참조를 보유하면 객체가 즉시 사라지지 않는다. 예를 들어 파일을 매핑한 뒤 원래 fd를 닫아도 매핑은 유지되며, &amp;lt;code&amp;gt;munmap()&amp;lt;/code&amp;gt;은 별개의 주소 공간 해제다. 자세한 과정은 [[운영체제 기본/Linux/메모리 매핑|Linux의 메모리 매핑]]에서 다룬다.&lt;br /&gt;
&lt;br /&gt;
fd 슬롯은 닫기 후반부보다 먼저 해제된다. 따라서 닫기에서 오류가 났다고 같은 번호로 &amp;lt;code&amp;gt;close()&amp;lt;/code&amp;gt;를 무작정 재시도하면, 다른 스레드가 그 번호로 새로 연 파일을 닫을 수 있다. &amp;lt;code&amp;gt;close()&amp;lt;/code&amp;gt;는 파일 이름을 디렉터리에서 제거하는 &amp;lt;code&amp;gt;unlink()&amp;lt;/code&amp;gt;와도 다른 연산이다.&amp;lt;ref name=&amp;quot;man-close&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man2/close.2.html Linux man-pages, close(2)].&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;open&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;file&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 쓰기 완료와 저장 동기화 ==&lt;br /&gt;
&lt;br /&gt;
일반적인 버퍼드 &amp;lt;code&amp;gt;write()&amp;lt;/code&amp;gt;의 성공, &amp;lt;code&amp;gt;close()&amp;lt;/code&amp;gt;의 성공, 저장 장치에 대한 동기화 완료는 서로 다른 조건이다. &amp;lt;code&amp;gt;fsync(fd)&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;do_fsync()&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;vfs_fsync()&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;vfs_fsync_range()&amp;lt;/code&amp;gt;를 거쳐 파일의 &amp;lt;code&amp;gt;f_op-&amp;gt;fsync&amp;lt;/code&amp;gt;를 호출한다. 파일 데이터와 필요한 메타데이터의 반영을 기다리며, 동기화 과정에서 발견된 오류도 호출자가 확인해야 한다.&amp;lt;ref name=&amp;quot;sync&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/sync.c?h=v6.12 Linux v6.12 fs/sync.c], do_fsync, vfs_fsync, vfs_fsync_range.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;fdatasync()&amp;lt;/code&amp;gt;도 데이터를 동기화하되, 메타데이터는 수정된 데이터를 다시 읽는 데 필요한 항목으로 한정한다. 새 파일 이름이나 이름 변경까지 장애 후 보존해야 한다면 관련 디렉터리의 동기화도 따로 고려해야 한다.&amp;lt;ref name=&amp;quot;man-fsync&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man2/fsync.2.html Linux man-pages, fsync(2)].&amp;lt;/ref&amp;gt; 페이지 캐시와 라이트백의 관계는 [[운영체제 기본/Linux/파일시스템/페이지 캐시|페이지 캐시]]에서 이어진다.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/파일 시스템 콜/read와 write|read와 write]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/파일 시스템 콜|파일 시스템 콜 목차]]&lt;br /&gt;
|다음=마지막 문서&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/%ED%94%84%EB%A1%9C%EC%84%B8%EC%8A%A4%EC%99%80_%EC%8A%A4%EB%A0%88%EB%93%9C&amp;diff=687</id>
		<title>운영체제 기본/프로세스와 스레드</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/%ED%94%84%EB%A1%9C%EC%84%B8%EC%8A%A4%EC%99%80_%EC%8A%A4%EB%A0%88%EB%93%9C&amp;diff=687"/>
		<updated>2026-11-15T06:06:25Z</updated>

		<summary type="html">&lt;p&gt;관리자: 과도한 강조와 중복 대조를 정리하고 도식을 ASCII로 통일&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/장치 제어와 입출력|장치 제어와 입출력]]&lt;br /&gt;
|목차=[[운영체제 기본#총론|총론 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/동시성|동시성]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
프로그램을 실행하려면 명령어뿐 아니라 데이터를 보관할 메모리, 현재 실행 위치, 열린 파일, CPU를 사용할 기회가 필요하다. 프로세스(Process)는 프로그램의 실행에 필요한 주소 공간과 자원을 묶는 단위이고, 스레드(Thread)는 그 안에서 명령을 순서대로 실행하는 흐름이다. 하나의 프로세스에는 하나 이상의 스레드가 있으며, 여러 스레드가 같은 실행 환경을 공유할 수 있다.&lt;br /&gt;
&lt;br /&gt;
== 프로그램과 프로세스 ==&lt;br /&gt;
디스크에 저장된 실행 파일은 코드와 초기 데이터를 담는다. 이 파일을 실행하면 운영체제는 메모리에 실행 환경을 마련하고, 파일을 읽거나 장치를 사용하는 데 필요한 상태를 관리한다. 실행 파일이 같더라도 실행할 때마다 별도의 프로세스가 만들어질 수 있다.&lt;br /&gt;
&lt;br /&gt;
같은 편집기를 두 번 실행하여 서로 다른 문서를 열었다고 하자. 두 프로세스는 같은 프로그램의 코드를 실행하지만, 편집 중인 내용과 열린 파일, 메모리 할당 상태는 따로 관리한다. 한쪽에서 바꾼 일반 변수의 값이 다른 쪽에 그대로 반영되지 않는다. 각 프로세스가 별도의 가상 주소 공간(Virtual Address Space)을 갖기 때문이다. 같은 숫자의 주소라도 서로 다른 메모리를 가리킬 수 있다.&amp;lt;ref name=&amp;quot;process-model&amp;quot;&amp;gt;[https://mit-pdos.github.io/xv6-riscv-book/first.html MIT PDOS, xv6: Operating system organization], 프로세스의 실행 환경과 격리.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
프로세스에는 주소 공간 외에도 열린 파일을 찾는 정보, 실행에 사용하는 각종 자원과 관리 정보가 있다. 운영체제는 이 묶음을 이용해 자원을 회수하고 다른 프로세스와 분리한다. 어떤 작업을 지금 CPU에서 실행할지는 그 프로세스에 속한 스레드의 상태를 보고 결정한다.&lt;br /&gt;
&lt;br /&gt;
== 스레드와 실행 상태 ==&lt;br /&gt;
스레드 하나로 실행되는 프로그램에서는 입력 처리, 계산, 결과 출력이 하나의 실행 흐름을 따라 이어진다. 함수를 호출하면 호출된 함수로 진행하고, 반환하면 호출한 위치로 돌아온다.&lt;br /&gt;
&lt;br /&gt;
CPU가 이 흐름을 멈췄다가 이어가려면 다음 명령의 위치와 계산 중이던 값, 함수 호출 관계를 알아야 한다. 이를 위해 스레드마다 다음과 같은 실행 문맥(Execution Context)을 관리한다.&amp;lt;ref name=&amp;quot;thread-context&amp;quot;&amp;gt;[https://learn.microsoft.com/en-us/windows/win32/procthread/about-processes-and-threads Microsoft Learn, About Processes and Threads], 프로세스 자원과 스레드 실행 문맥.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
* 프로그램 카운터(Program Counter, PC): 이어서 실행할 명령의 위치.&lt;br /&gt;
* 레지스터(Register): 연산 중인 값과 함수 인자 등 CPU의 실행 상태.&lt;br /&gt;
* 스택(Stack)과 스택 포인터(Stack Pointer, SP): 함수 호출과 반환, 호출별 지역 변수 등을 위한 메모리와 그 위치.&lt;br /&gt;
* 스케줄링 상태: 실행 중인지, 실행 가능한지, 입출력이나 다른 조건을 기다리는지에 관한 정보.&lt;br /&gt;
&lt;br /&gt;
실행 중인 스레드의 레지스터 값은 CPU에 있고, 다른 스레드를 실행할 때는 다시 복원할 수 있도록 보관한다. 스레드마다 PC와 스택이 있으므로 같은 함수를 실행하더라도 서로 다른 위치에 있을 수 있고, 함수 인자와 지역 변수의 값도 다를 수 있다.&lt;br /&gt;
&lt;br /&gt;
== 공유 자원과 스레드별 상태 ==&lt;br /&gt;
여러 스레드를 사용하는 프로세스는 실행 흐름을 여러 개 두되, 대부분의 실행 환경을 함께 사용한다. 같은 프로세스의 스레드는 코드, 전역 데이터, 힙을 포함하는 주소 공간을 공유한다. Unix 계열에서는 열린 파일을 찾는 파일 디스크립터 테이블도 공유하므로 한 스레드가 연 파일을 다른 스레드가 사용할 수 있다.&amp;lt;ref name=&amp;quot;source-3&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man7/pthreads.7.html pthreads(7)], 공유하는 프로세스 자원과 스레드별 상태.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
프로세스 P&lt;br /&gt;
+- 공유 주소 공간&lt;br /&gt;
|  +- 코드 ,  전역 데이터 ,  힙&lt;br /&gt;
|  +- 스레드 A의 스택&lt;br /&gt;
|  +- 스레드 B의 스택&lt;br /&gt;
+- 공유 파일 디스크립터 테이블&lt;br /&gt;
+- 스레드 A: PC ,  SP ,  레지스터 ,  실행/대기 상태&lt;br /&gt;
+- 스레드 B: PC ,  SP ,  레지스터 ,  실행/대기 상태&lt;br /&gt;
&lt;br /&gt;
프로세스 Q&lt;br /&gt;
+- 별도 주소 공간 ,  파일 디스크립터 테이블&lt;br /&gt;
+- 스레드 C: PC ,  SP ,  레지스터 ,  실행/대기 상태&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
A와 B는 각자의 스택을 쓰지만, 두 스택은 같은 주소 공간 안에 있다. 유효한 포인터가 있으면 다른 스레드의 스택에 놓인 객체에도 접근할 수 있으므로, 객체의 수명과 동기화를 지켜야 한다. 반면 별도 프로세스 Q의 사적인 메모리는 보통 P의 포인터만으로 접근할 수 없다. 프로세스 사이에 같은 메모리를 쓰려면 공유 매핑 등 별도의 연결이 필요하다.&lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
! 구분 !! 서로 다른 프로세스 !! 같은 프로세스의 여러 스레드&lt;br /&gt;
|-&lt;br /&gt;
| 주소 공간 || 기본적으로 분리 || 공유&lt;br /&gt;
|-&lt;br /&gt;
| 실행 위치와 레지스터 || 각 프로세스의 스레드마다 보유 || 스레드마다 보유&lt;br /&gt;
|-&lt;br /&gt;
| 함수 호출 스택 || 각 스레드가 별도로 사용 || 각 스레드가 별도로 사용하지만 주소 공간은 공유&lt;br /&gt;
|-&lt;br /&gt;
| 데이터 전달 || 통신이나 명시적 공유가 필요 || 같은 객체에 직접 접근 가능&lt;br /&gt;
|-&lt;br /&gt;
| 잘못된 메모리 쓰기의 영향 || 다른 프로세스의 사적 메모리와 격리 || 같은 주소 공간의 다른 스레드에 전파 가능&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
=== 스레드별 호출 스택 ===&lt;br /&gt;
각 스레드는 함수 호출의 진행 상태를 따로 유지한다. 스레드 A가 함수를 호출한 뒤 다른 함수를 실행하는 동안, 스레드 B는 같은 함수의 다른 호출을 실행하거나 먼저 반환할 수 있다. 각 흐름은 자신이 돌아갈 위치와 아직 끝나지 않은 호출의 데이터를 유지해야 한다.&lt;br /&gt;
&lt;br /&gt;
함수 호출에 필요한 메모리 묶음을 스택 프레임(Stack Frame)이라고 한다. 프레임에는 호출별 지역 데이터와 보존할 레지스터, 필요에 따라 반환 주소 등이 놓인다. 어떤 값은 레지스터에 남고 어떤 값은 스택에 저장되는지에 대한 구체적인 배치는 호출 규약과 컴파일러가 결정한다.&amp;lt;ref name=&amp;quot;stack-frame&amp;quot;&amp;gt;[https://riscv-non-isa.github.io/riscv-elf-psabi-doc/#_procedure_calling_convention RISC-V ELF psABI, Procedure Calling Convention], 스택 포인터와 호출별 레지스터 보존 규약.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
int double_value(int value)&lt;br /&gt;
{&lt;br /&gt;
    return value * 2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int calculate(int input)&lt;br /&gt;
{&lt;br /&gt;
    int partial = input + 1;&lt;br /&gt;
    int result = double_value(partial);&lt;br /&gt;
    return result + partial;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
A가 &amp;lt;code&amp;gt;calculate(10)&amp;lt;/code&amp;gt;, B가 &amp;lt;code&amp;gt;calculate(20)&amp;lt;/code&amp;gt;을 실행한다고 하자. A의 &amp;lt;code&amp;gt;partial&amp;lt;/code&amp;gt;은 11이고 B의 &amp;lt;code&amp;gt;partial&amp;lt;/code&amp;gt;은 21이다. 둘 다 &amp;lt;code&amp;gt;double_value()&amp;lt;/code&amp;gt;를 실행하는 순간에도, 함수가 끝난 뒤 각자의 &amp;lt;code&amp;gt;calculate()&amp;lt;/code&amp;gt; 호출로 돌아가 자신이 보관한 값을 사용해야 한다. 호출 관계를 스택 프레임으로 나타내면 다음과 같다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
공유하는 코드: calculate(), double_value()&lt;br /&gt;
&lt;br /&gt;
A의 호출 스택                  B의 호출 스택&lt;br /&gt;
+----------------------+      +----------------------+&lt;br /&gt;
| A caller             |      | B caller             |&lt;br /&gt;
+----------------------+      +----------------------+&lt;br /&gt;
| calculate(10)        |      | calculate(20)        |&lt;br /&gt;
| partial = 11         |      | partial = 21         |&lt;br /&gt;
+----------------------+      +----------------------+&lt;br /&gt;
| double_value(11)     |      | double_value(21)     |&lt;br /&gt;
| SP_A -&amp;gt; current frame|      | SP_B -&amp;gt; current frame|&lt;br /&gt;
| return to A          |      | return to B          |&lt;br /&gt;
+----------------------+      +----------------------+&lt;br /&gt;
       각자의 호출 순서에 따라 프레임을 만들고 제거&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
두 스레드가 같은 스택 저장 영역과 위치를 사용하면 B의 함수 호출이 아직 사용 중인 A의 프레임을 덮어쓸 수 있다. 지역 데이터나 복귀에 필요한 상태가 바뀌면 A는 계산을 올바르게 이어갈 수 없다. 두 SP도 서로 겹치지 않는 스택 영역을 가리켜야 한다. 독립적인 실행 흐름에는 독립적으로 보존되는 호출 스택과 SP가 필요하다.&amp;lt;ref name=&amp;quot;source-3&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이는 CPU가 하나일 때도 마찬가지다. A를 멈추고 B를 실행하는 동안에도 A의 미완료 호출들은 살아 있다. A의 PC와 레지스터를 복원할 때 그 호출 데이터도 그대로 남아 있어야 한다.&lt;br /&gt;
&lt;br /&gt;
== 단일 스레드와 다중 스레드 ==&lt;br /&gt;
문서 편집기가 입력을 처리하다가 오래 걸리는 검색 작업을 수행한다고 하자. 단일 스레드가 검색 루프를 실행하는 동안에는 같은 흐름에서 입력을 처리할 수 없다. 작업을 잘게 나누어 번갈아 처리하는 설계도 가능하지만, 입력 담당 스레드와 검색 담당 스레드를 나누면 각각의 진행 위치를 독립적으로 유지할 수 있다.&lt;br /&gt;
&lt;br /&gt;
새 스레드는 정해진 함수에서 실행을 시작하고, 기존 스레드는 자신의 실행을 계속한다. 새 스레드의 결과가 필요한 지점에서는 완료를 기다리거나 통지를 받아야 한다.&amp;lt;ref name=&amp;quot;thread-create&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man3/pthread_create.3.html pthread_create(3)], 새 스레드의 시작과 실행 순서.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
예를 들어 입력 스레드가 문서 내용을 수정하고 검색 스레드가 같은 내용을 읽는다면, 두 스레드가 무엇을 언제 볼지 정해야 한다. 락으로 접근을 조정하거나 검색용 사본을 만드는 방법이 있다. 실행 흐름을 나누는 편리함에는 공유 데이터 관리 비용이 따라온다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
단일 스레드: 입력 처리 -&amp;gt; 검색 작업 -&amp;gt; 다음 입력 처리&lt;br /&gt;
&lt;br /&gt;
다중 스레드: 입력 스레드 -&amp;gt; 입력 처리 -&amp;gt; 입력 처리 -&amp;gt; ...&lt;br /&gt;
             검색 스레드 -&amp;gt; 검색 작업 ----------&amp;gt; 완료 통지&lt;br /&gt;
                          (문서 데이터 공유에는 동기화 필요)&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
논리 CPU 하나에서는 두 스레드가 번갈아 진행하는 동시성(Concurrency)을 얻는다. 여러 논리 CPU에 배치되면 같은 시각에 실행하는 병렬성(Parallelism)도 얻을 수 있다. 스레드를 늘려도 CPU 수나 공유 락, 입출력 장치가 병목이면 처리량이 늘지 않을 수 있다.&lt;br /&gt;
&lt;br /&gt;
== 실행 파일과 실행 문맥 ==&lt;br /&gt;
실행 문맥을 새로 만드는 일과 실행할 프로그램을 바꾸는 일도 구분된다. Unix 계열에서는 프로세스를 생성하는 연산과 기존 프로세스의 실행 이미지를 교체하는 연산이 분리되어 있다. 생성과 실행을 나누면 새 프로그램을 시작하기 전에 입출력 연결이나 실행 환경을 구성할 수 있다. 대신 어떤 상태를 상속하고 어떤 상태를 초기화할지 명확한 규칙이 필요하다. &amp;lt;ref name=&amp;quot;source-1&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man2/fork.2.html fork(2)].&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;source-2&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man2/execve.2.html execve(2)].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 프로세스 격리와 통신 비용 ==&lt;br /&gt;
여러 요청을 처리하는 서버를 생각해 보자. 요청별 작업을 서로 다른 주소 공간에 두면 한 작업의 잘못된 메모리 쓰기가 다른 작업의 사적인 메모리를 직접 덮어쓰지 않는다. 요청 하나의 실패가 다른 요청으로 번지는 범위를 줄일 수 있다.&lt;br /&gt;
&lt;br /&gt;
대신 결과나 공통 데이터를 주고받을 [[운영체제 기본/프로세스 간 통신|통신 경로]]가 필요하다. 메시지에 담을 데이터 표현을 정해야 하고, 구현에 따라 복사와 직렬화, 커널 경계 통과 비용이 발생한다. 공유 메모리로 복사를 줄일 수 있지만, 그 영역에는 다시 접근 규칙과 동기화가 필요하다.&lt;br /&gt;
&lt;br /&gt;
같은 프로세스 안에서 스레드를 늘리면 주소 공간과 열린 파일 등을 공유하므로 포인터로 같은 객체를 다룰 수 있다. 연결과 전달이 간단해지는 대신, 잘못된 쓰기와 공유 상태의 오염도 다른 스레드에 영향을 준다.&lt;br /&gt;
&lt;br /&gt;
프로세스와 스레드를 선택할 때는 생성 비용, 공유할 데이터의 양, 장애를 격리할 범위, 통신 비용, 동기화 복잡도를 함께 고려해야 한다. 별도 프로세스도 같은 파일이나 공유 메모리를 변경한다면 경쟁 문제가 생긴다.&lt;br /&gt;
&lt;br /&gt;
== CPU 공유와 컨텍스트 스위치 ==&lt;br /&gt;
실행 가능한 흐름이 CPU보다 많으면 순서를 정해야 한다. 운영체제는 한 스레드의 문맥을 보관하고 다른 스레드의 문맥을 복원해 실행을 넘긴다. 이것이 컨텍스트 스위치(Context Switch)이다. 논리 CPU 하나에서는 여러 흐름이 번갈아 진행하고, 여러 논리 CPU에서는 병렬 실행도 가능하다.&lt;br /&gt;
&lt;br /&gt;
실행 중인 작업이 자발적으로 CPU를 내놓게 하는 방식은 전환 지점이 명확하다. 그러나 오래 실행하거나 양보하지 않는 작업이 다른 작업을 지연시킬 수 있다. 선점은 운영체제가 실행을 중단시켜 다른 작업에 기회를 주는 방식이다. 응답성과 공정성을 확보하는 데 유리하지만, 프로그램은 예상하지 못한 지점에서 실행 순서가 바뀔 수 있음을 전제로 해야 한다.&lt;br /&gt;
&lt;br /&gt;
일반적인 선점형 시분할에서는 [[운영체제 기본/장치 제어와 입출력#타이머 인터럽트와 선점|타이머 인터럽트]]가 실행 중인 작업의 협조 없이 CPU 제어권을 되찾을 기회를 만든다. 커널은 실행 가능한 작업과 현재 상태를 확인해 전환 여부를 결정한다.&lt;br /&gt;
&lt;br /&gt;
전환 간격을 짧게 하면 실행 가능한 다른 작업이 빨리 기회를 얻을 수 있다. 반면 문맥 저장, 복원 비용이 늘고, 캐시와 주소 변환 캐시를 다시 채우는 비용이 발생할 수 있다. 길게 실행시키면 이런 비용을 줄일 여지가 있지만 짧은 작업의 응답 시간이 길어질 수 있다.&lt;br /&gt;
&lt;br /&gt;
처리량, 응답 시간, 공정성, 마감 시간 준수는 서로 다른 목표다. 대화형 작업과 일괄 계산, 실시간 작업에 같은 선택이 최선일 수는 없다. &amp;lt;ref name=&amp;quot;source-4&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man7/sched.7.html sched(7)].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 입출력 대기와 깨우기 ==&lt;br /&gt;
네트워크 응답이 도착하지 않았거나 필요한 입출력이 끝나지 않았다면 CPU를 더 준다고 작업이 진행되지는 않는다. 이때 실행 흐름을 대기 상태로 두고, 진행할 수 있는 다른 작업에 CPU를 주는 편이 자원 사용에 유리하다.&lt;br /&gt;
&lt;br /&gt;
장치가 [[운영체제 기본/장치 제어와 입출력#입출력 완료와 깨우기|인터럽트로 완료를 통지]]하는 구성에서는 커널이 완료 상태를 확인하고 해당 요청을 기다리던 작업을 깨운다. 타이머 인터럽트가 선점 기회를 만드는 것과, 장치 인터럽트가 대기 조건의 변화를 알리는 것은 역할이 다르다. 장치의 상태를 폴링하여 완료를 알아내는 방식도 있다.&lt;br /&gt;
&lt;br /&gt;
상태 전이는 다음과 같다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
실행 가능 -- 선택 --&amp;gt; 실행 중&lt;br /&gt;
    ^                  |&lt;br /&gt;
    +---- 선점 --------+&lt;br /&gt;
                       | 입출력, 사건 대기&lt;br /&gt;
                       v&lt;br /&gt;
                     대기 중&lt;br /&gt;
                       | 입출력 완료 등&lt;br /&gt;
                       +--------&amp;gt; 실행 가능&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
깨우기는 대기 중인 작업을 실행 가능 상태로 바꾸는 일이다. 깨어난 작업의 실제 실행 시점은 스케줄러가 정한다. 따라서 작업의 완료 시간에는 계산 시간뿐 아니라 실행 기회를 기다리는 시간과 외부 조건을 기다리는 시간도 포함된다.&lt;br /&gt;
&lt;br /&gt;
대기를 사용하는 설계는 다른 작업에 CPU를 돌려줄 수 있지만, 멈추고 깨우는 처리와 스케줄링 비용이 있다. 아주 짧은 대기라면 잠시 상태를 반복 확인하는 편이 유리할 수도 있다. 이 선택과 공유 상태의 정확성 문제는 [[운영체제 기본/동시성|동시성]]에서 다룬다.&lt;br /&gt;
&lt;br /&gt;
== 관련 각론 ==&lt;br /&gt;
* [[운영체제 기본/Linux/ELF 로딩/execve와 실행 이미지 교체|execve와 실행 이미지 교체]]: 프로세스 생성과 구분되는 실행 이미지 교체, 유지되는 상태와 초기화되는 상태.&lt;br /&gt;
* [[운영체제 기본/Linux/x86-64/BIOS 부팅/PID 1 생성|PID 1 생성]]: 기존 부트 태스크와 새 실행 문맥이 갈라지는 과정.&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/장치 제어와 입출력|장치 제어와 입출력]]&lt;br /&gt;
|목차=[[운영체제 기본#총론|총론 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/동시성|동시성]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/BIOS_%EB%B6%80%ED%8C%85/%EC%A7%84%EC%9E%85_%EA%B7%9C%EC%95%BD%EA%B3%BC_%EC%95%95%EC%B6%95_%ED%95%B4%EC%A0%9C&amp;diff=686</id>
		<title>운영체제 기본/Linux/x86-64/BIOS 부팅/진입 규약과 압축 해제</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/BIOS_%EB%B6%80%ED%8C%85/%EC%A7%84%EC%9E%85_%EA%B7%9C%EC%95%BD%EA%B3%BC_%EC%95%95%EC%B6%95_%ED%95%B4%EC%A0%9C&amp;diff=686"/>
		<updated>2026-11-15T06:06:08Z</updated>

		<summary type="html">&lt;p&gt;관리자: 문체 정리: 강조, 반복 대조 표현과 특수문자 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/GRUB의 커널 적재와 제어권 전달|GRUB의 커널 적재와 제어권 전달]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/x86-64/BIOS 부팅|BIOS 부팅 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/GDT와 LDT 초기화|GDT와 LDT 초기화]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
BIOS 환경의 GRUB가 일반 &amp;lt;code&amp;gt;linux&amp;lt;/code&amp;gt; 명령으로 x86-64 bzImage를 부팅할 때, 커널에 넘겨주는 CPU는 아직 32비트 보호 모드다. Linux는 그 상태에서 자체 페이지 테이블을 만들고 64비트 모드로 전환한 다음, 압축된 커널 본체를 실행 가능한 이미지로 바꾼다. 이 장은 Linux v6.12의 32비트 부트 프로토콜 진입 경로를 따라간다. 이미지 적재와 인계 준비는 [[운영체제 기본/Linux/x86-64/BIOS 부팅/GRUB의 커널 적재와 제어권 전달|GRUB의 커널 적재와 제어권 전달]]에서 다룬다.&lt;br /&gt;
&lt;br /&gt;
== 커널 진입 조건 ==&lt;br /&gt;
이 경로의 진입점은 &amp;lt;code&amp;gt;arch/x86/boot/compressed/head_64.S:startup_32&amp;lt;/code&amp;gt;다. 파일 이름의 &amp;lt;code&amp;gt;64&amp;lt;/code&amp;gt;는 x86-64 커널용 소스임을 나타낸다. 이 심볼은 &amp;lt;code&amp;gt;.code32&amp;lt;/code&amp;gt; 구역에 있고, 부트 프로토콜이 정한 보호 모드 이미지의 오프셋 0에 놓인다. 이 위치는 bzImage 파일의 시작 및 &amp;lt;code&amp;gt;start_kernel()&amp;lt;/code&amp;gt;의 주소와 구별된다.&amp;lt;ref name=&amp;quot;compressed&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/boot/compressed/head_64.S?h=v6.12 Linux v6.12, arch/x86/boot/compressed/head_64.S], startup_32, startup_64, .Lrelocated.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
여기에 도착했을 때의 핵심 조건은 다음과 같다.&amp;lt;ref name=&amp;quot;protocol&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/Documentation/arch/x86/boot.rst?h=v6.12 Linux v6.12, Documentation/arch/x86/boot.rst], 32-bit Boot Protocol 및 init_size.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
* CPU는 보호 모드이고 페이징은 꺼져 있다. A20은 활성화되어 있다.&lt;br /&gt;
* 세그먼트는 규약에 맞는 평탄한 32비트 주소 공간을 제공한다. 따라서 이 구간에서는 선형 주소와 물리 주소의 수치가 같다.&lt;br /&gt;
* 마스커블 인터럽트는 비활성화되어 있다. 아직 로더의 인터럽트 처리 환경을 커널의 환경으로 간주할 수 없다.&lt;br /&gt;
* &amp;lt;code&amp;gt;ESI&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;struct boot_params&amp;lt;/code&amp;gt;의 물리 주소다. 명령행, 메모리 지도, initrd 위치와 크기 등의 정보는 이 구조체와 그 안의 포인터로 전달된다.&lt;br /&gt;
* 이 32비트 진입 경로에서 커널과 초기 실행 공간, initrd, 부트 정보, 명령행은 4 GiB 아래에 있어야 한다.&lt;br /&gt;
&lt;br /&gt;
Linux 진입 직후에는 메모리 할당자와 일반 커널 스택이 아직 준비되지 않았다. &amp;lt;code&amp;gt;startup_32&amp;lt;/code&amp;gt;는 먼저 &amp;lt;code&amp;gt;boot_params&amp;lt;/code&amp;gt;의 scratch 영역을 짧은 임시 스택으로 사용한다. &amp;lt;code&amp;gt;call&amp;lt;/code&amp;gt;이 저장한 실제 실행 주소를 &amp;lt;code&amp;gt;pop&amp;lt;/code&amp;gt;으로 얻고, 링크 시점 오프셋을 빼서 현재 이미지의 적재 기준 주소를 계산한다. 이 값이 있어야 아직 재배치되지 않은 코드가 자신의 GDT, 스택, 페이지 테이블을 찾을 수 있다.&amp;lt;ref name=&amp;quot;compressed&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이어서 자기 GDT를 적재하고 데이터 세그먼트와 부트 스택을 설정한다. GDT를 바꾼 뒤 CS도 새 테이블에 맞게 다시 적재한다. 단순히 &amp;lt;code&amp;gt;lgdt&amp;lt;/code&amp;gt;만 실행하면 이미 세그먼트 레지스터에 캐시된 속성까지 자동으로 바뀌지는 않기 때문이다. 구체적인 디스크립터와 LDT 처리는 [[운영체제 기본/Linux/x86-64/BIOS 부팅/GDT와 LDT 초기화|GDT와 LDT 초기화]]에서 설명한다.&lt;br /&gt;
&lt;br /&gt;
== 32비트 보호 모드와 64비트 모드 전환 ==&lt;br /&gt;
&amp;lt;code&amp;gt;verify_cpu()&amp;lt;/code&amp;gt;로 필요한 CPU 기능을 확인한 뒤, 커널은 롱 모드에 필요한 페이징을 준비한다. 롱 모드로 전환하려면 CPU 모드, 주소 변환 방식, 코드 세그먼트 속성을 서로 맞추어야 한다.&amp;lt;ref name=&amp;quot;compressed&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
startup_32&lt;br /&gt;
  CR4.PAE = 1&lt;br /&gt;
  build PML4 -&amp;gt; PDPT -&amp;gt; page directories&lt;br /&gt;
  CR3 = physical address of PML4&lt;br /&gt;
  EFER.LME = 1&lt;br /&gt;
  CR0.PG = 1              -&amp;gt; long mode active, compatibility mode&lt;br /&gt;
  far return to CS.L=1    -&amp;gt; 64-bit execution at startup_64&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
PAE(Physical Address Extension)는 롱 모드의 페이지 테이블을 사용하기 위해 필요한 CPU 설정이다. 먼저 &amp;lt;code&amp;gt;CR4.PAE&amp;lt;/code&amp;gt;를 설정한다. 다음으로 초기 4단계 페이지 테이블을 만들고 그 최상위 테이블의 물리 주소를 &amp;lt;code&amp;gt;CR3&amp;lt;/code&amp;gt;에 넣는다. 이 테이블은 2 MiB 대형 페이지 2,048개로 처음 4 GiB를 identity mapping한다. 즉, 같은 수치의 가상 주소가 같은 수치의 물리 주소를 가리킨다. 주소 변환과 페이지 테이블의 역할은 [[운영체제 기본/가상 메모리|가상 메모리]]에서 설명한다. 페이징을 켜는 순간에도 현재 실행 중인 명령어, 부트 스택, 입력 이미지와 부트 정보를 그대로 찾게 하려는 것이다. 이 작업용 주소 공간은 모드 전환과 압축 해제에 사용한다.&amp;lt;ref name=&amp;quot;compressed&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;EFER.LME&amp;lt;/code&amp;gt;는 롱 모드 사용을 허용한다. 이 비트를 설정하는 것만으로 즉시 64비트 명령어 해석이 시작되지는 않는다. 필요한 페이지 테이블과 PAE 설정이 준비된 상태에서 &amp;lt;code&amp;gt;CR0.PG&amp;lt;/code&amp;gt;를 켜면 롱 모드가 활성화되지만, 기존 CS는 여전히 32비트 코드 세그먼트이므로 우선 호환 모드에서 실행된다. 커널은 스택에 새 코드 셀렉터와 목적지 주소를 넣고 &amp;lt;code&amp;gt;lret&amp;lt;/code&amp;gt;을 실행한다. 이 far return이 &amp;lt;code&amp;gt;CS.L=1&amp;lt;/code&amp;gt;인 세그먼트와 &amp;lt;code&amp;gt;startup_64&amp;lt;/code&amp;gt;의 주소를 함께 적재하여 64비트 실행으로 넘어간다.&amp;lt;ref name=&amp;quot;compressed&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;startup_64&amp;lt;/code&amp;gt;는 압축 이미지 시작점에서 &amp;lt;code&amp;gt;0x200&amp;lt;/code&amp;gt; 떨어진 고정 위치에 있다. 이 경로에서는 Linux의 &amp;lt;code&amp;gt;startup_32&amp;lt;/code&amp;gt;가 모드 전환을 마친 뒤 이 위치로 이동한다.&amp;lt;ref name=&amp;quot;compressed&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 압축 해제기와 커널 본체 ==&lt;br /&gt;
소스에는 &amp;lt;code&amp;gt;startup_64&amp;lt;/code&amp;gt;가 두 군데 있다. 지금 실행하는 것은 &amp;lt;code&amp;gt;arch/x86/boot/compressed/head_64.S&amp;lt;/code&amp;gt;의 압축 해제기다. 압축이 끝난 뒤 실행할 것은 &amp;lt;code&amp;gt;arch/x86/kernel/head_64.S&amp;lt;/code&amp;gt;의 커널 본체다. 둘은 따로 링크되는 이미지에 속하며, 같은 이름을 공유할 뿐 서로 다른 진입점이다.&amp;lt;ref name=&amp;quot;compressed&amp;quot;/&amp;gt;&amp;lt;ref&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/kernel/head_64.S?h=v6.12 Linux v6.12, arch/x86/kernel/head_64.S], startup_64.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
GRUB&lt;br /&gt;
  -&amp;gt; compressed/startup_32      32-bit entry&lt;br /&gt;
  -&amp;gt; compressed/startup_64      64-bit decompressor&lt;br /&gt;
  -&amp;gt; extract_kernel()&lt;br /&gt;
  -&amp;gt; kernel/startup_64          decompressed kernel&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
압축 해제기는 최종 커널의 축소판 실행 환경을 별도로 갖는다. 자체 스택과 제한된 힙, 초기 예외 처리기, 페이지 테이블을 사용한다. &amp;lt;code&amp;gt;boot_params&amp;lt;/code&amp;gt; 주소는 C 함수 호출에도 살아남아야 하므로 &amp;lt;code&amp;gt;R15&amp;lt;/code&amp;gt;에 보관한다. 정상 커널의 메모리 할당자나 스케줄러는 아직 존재하지 않는다.&amp;lt;ref name=&amp;quot;compressed&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 압축 해제기의 재배치와 메모리 배치 ==&lt;br /&gt;
압축 입력보다 풀린 출력이 크다. 원래 적재 위치에서 곧바로 낮은 주소부터 출력하면 아직 읽지 않은 입력, 현재 실행 중인 해제기, 스택을 덮어쓸 수 있다. Linux는 부트 헤더의 &amp;lt;code&amp;gt;init_size&amp;lt;/code&amp;gt;로 확보한 초기 작업 공간의 뒤쪽에 압축 이미지를 옮긴 뒤 작업한다. 옮길 위치는 출력 기준 주소에 &amp;lt;code&amp;gt;init_size&amp;lt;/code&amp;gt;를 더하고 압축 이미지의 &amp;lt;code&amp;gt;_end&amp;lt;/code&amp;gt; 오프셋을 빼서 구한다. 이 여유 공간의 크기는 이미지 빌드 과정에서 압축 해제와 초기 실행에 필요한 크기를 고려해 계산된다.&amp;lt;ref name=&amp;quot;compressed&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;protocol&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
low address                                         high address&lt;br /&gt;
|------------------- workspace (init_size) ---------------------|&lt;br /&gt;
|---------------- kernel output ----------------|&lt;br /&gt;
                          |---- relocated compressed image ----|&lt;br /&gt;
                          ^                                    ^&lt;br /&gt;
                          relocation base              workspace end&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
출력 범위와 옮긴 압축 이미지의 전체 범위가 반드시 완전히 분리되는 것은 아니다. 입력을 소비하면서 출력이 커지는 과정까지 감안해 공간을 잡는 것이며, 아직 필요한 입력과 실행 중인 코드를 보존해야 한다.&lt;br /&gt;
&lt;br /&gt;
복사 자체도 겹침을 고려한다. &amp;lt;code&amp;gt;std; rep movsq; cld&amp;lt;/code&amp;gt;는 높은 주소에서 낮은 주소로 복사한다. 목적지가 더 높은 겹치는 영역일 때, 앞에서부터 복사하여 아직 읽지 않은 원본을 먼저 덮어쓰는 문제를 피하는 순서다. 복사 대상은 &amp;lt;code&amp;gt;startup_32&amp;lt;/code&amp;gt;부터 &amp;lt;code&amp;gt;_bss&amp;lt;/code&amp;gt; 전까지이고, BSS는 복사한 다음 새 위치에서 0으로 만든다. GDTR도 새 복사본의 GDT를 가리키도록 고친 후 &amp;lt;code&amp;gt;.Lrelocated&amp;lt;/code&amp;gt;의 새 주소로 분기한다.&amp;lt;ref name=&amp;quot;compressed&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
새 위치에서는 압축 해제기 BSS를 비우고 다음 단계의 예외 처리와 identity mapping을 준비한다. BSS 초기화는 C의 초기값 없는 전역 및 정적 변수가 0이라는 조건을 실제 메모리에 구현하는 과정이다. 뒤에서 커널 본체가 비울 BSS와는 별개다.&lt;br /&gt;
&lt;br /&gt;
== 압축 해제와 실행 이미지 구성 ==&lt;br /&gt;
Linux v6.12에서 어셈블리가 호출하는 함수는 &amp;lt;code&amp;gt;extract_kernel(boot_params, output)&amp;lt;/code&amp;gt;이다. 이 함수는 필요한 출력 공간과 배치 위치를 정하고, 정렬과 주소 범위를 검사한다. 배치 위치는 커널 구성과 부팅 옵션에 따라 달라질 수 있다. 필요한 공간은 압축 해제 결과의 크기뿐 아니라 본체의 BSS와 초기 작업 공간까지 수용해야 한다.&amp;lt;ref name=&amp;quot;misc&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/boot/compressed/misc.c?h=v6.12 Linux v6.12, arch/x86/boot/compressed/misc.c], extract_kernel, decompress_kernel, parse_elf, handle_relocations.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
extract_kernel(boot_params, output)&lt;br /&gt;
  -&amp;gt; decompress_kernel(output, virt_addr, error)&lt;br /&gt;
       -&amp;gt; __decompress(...)&lt;br /&gt;
       -&amp;gt; parse_elf(output)&lt;br /&gt;
       -&amp;gt; handle_relocations(output, output_len, virt_addr)&lt;br /&gt;
  -&amp;gt; return output + entry_offset&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;__decompress()&amp;lt;/code&amp;gt;는 압축된 바이트 스트림을 푼다. 그 결과는 ELF 형식의 파일 이미지다. ELF는 코드와 데이터가 파일의 어느 위치에 있고, 메모리 어디에 배치되어야 하며, 어느 주소에서 실행을 시작할지를 기록하는 실행 파일 형식이다. &amp;lt;code&amp;gt;parse_elf()&amp;lt;/code&amp;gt;는 이 정보를 읽어 메모리에 적재할 구간인 &amp;lt;code&amp;gt;PT_LOAD&amp;lt;/code&amp;gt;들을 실행 위치에 복사하고, 실행 시작 주소인 진입점의 오프셋을 구한다. 이어 필요한 구성에서 &amp;lt;code&amp;gt;handle_relocations()&amp;lt;/code&amp;gt;가 주소 참조를 실제 가상 배치에 맞게 보정한다. 압축 해제 후에도 ELF 구간 배치와 주소 재배치가 필요하다.&amp;lt;ref name=&amp;quot;misc&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
마지막 반환값은 완성된 본체의 진입 주소다. 압축 해제기는 &amp;lt;code&amp;gt;R15&amp;lt;/code&amp;gt;에 보존했던 부트 정보 주소를 &amp;lt;code&amp;gt;RSI&amp;lt;/code&amp;gt;로 되돌리고, 반환 주소가 들어 있는 &amp;lt;code&amp;gt;RAX&amp;lt;/code&amp;gt;로 간접 분기한다. 이제 CPU는 이미 64비트 모드와 페이징을 사용하는 상태로 커널 본체의 &amp;lt;code&amp;gt;startup_64&amp;lt;/code&amp;gt;에 들어간다. 이어서 임시 실행 환경을 커널 자신의 실행 환경으로 교체한다.&amp;lt;ref name=&amp;quot;compressed&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/GRUB의 커널 적재와 제어권 전달|GRUB의 커널 적재와 제어권 전달]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/x86-64/BIOS 부팅|BIOS 부팅 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/GDT와 LDT 초기화|GDT와 LDT 초기화]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%ED%8C%8C%EC%9D%BC_%EC%8B%9C%EC%8A%A4%ED%85%9C_%EC%BD%9C/read%EC%99%80_write&amp;diff=685</id>
		<title>운영체제 기본/Linux/파일 시스템 콜/read와 write</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%ED%8C%8C%EC%9D%BC_%EC%8B%9C%EC%8A%A4%ED%85%9C_%EC%BD%9C/read%EC%99%80_write&amp;diff=685"/>
		<updated>2026-11-15T06:06:08Z</updated>

		<summary type="html">&lt;p&gt;관리자: 문체 정리: 대조, 나열과 장식 문자 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/파일 시스템 콜/openat과 경로 탐색|openat과 경로 탐색]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/파일 시스템 콜|파일 시스템 콜 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/파일 시스템 콜/파일 오프셋과 열린 파일의 수명|파일 오프셋과 열린 파일의 수명]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
Linux v6.12의 &amp;lt;code&amp;gt;read()&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;write()&amp;lt;/code&amp;gt;는 fd에서 같은 열린 파일 객체를 찾고, VFS 검사를 거쳐 대상별 연산을 호출한다. 읽기는 데이터를 사용자 버퍼로 가져오고, 쓰기는 사용자 버퍼의 데이터를 대상에 전달한다. 먼저 일반 파일의 동기식 버퍼드 입출력을 기준으로 살펴본다.&lt;br /&gt;
&lt;br /&gt;
== 공통 파일 조회와 위치 처리 ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
read(fd, buf, count)                 write(fd, buf, count)&lt;br /&gt;
  -&amp;gt; ksys_read()                      -&amp;gt; ksys_write()&lt;br /&gt;
      fdget_pos(fd)                       fdget_pos(fd)&lt;br /&gt;
      현재 f_pos 확보                     현재 f_pos 확보&lt;br /&gt;
      vfs_read()                          vfs_write()&lt;br /&gt;
      성공한 위치를 f_pos에 반영           성공한 위치를 f_pos에 반영&lt;br /&gt;
      fdput_pos()                         fdput_pos()&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
두 함수는 일반 파일의 &amp;lt;code&amp;gt;f_pos&amp;lt;/code&amp;gt;를 지역 변수로 복사해 VFS 연산에 넘기고, 반환값이 음수가 아니면 갱신된 위치를 파일 객체에 기록한다. 위치가 없는 스트림은 &amp;lt;code&amp;gt;file_ppos()&amp;lt;/code&amp;gt;가 &amp;lt;code&amp;gt;NULL&amp;lt;/code&amp;gt;을 반환하므로 같은 위치 갱신 모델을 그대로 적용하지 않는다.&amp;lt;ref name=&amp;quot;rw&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/read_write.c?h=v6.12 Linux v6.12 fs/read_write.c], file_ppos, ksys_read, ksys_write, vfs_read, vfs_write, new_sync_read, new_sync_write.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;vfs_read()&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;vfs_write()&amp;lt;/code&amp;gt;는 열린 모드, 연산 지원 여부, 사용자 주소 범위와 요청 범위 등을 검사한다. 사용자 주소가 범위 검사를 통과해도 실제 복사 중에 페이지 폴트나 오류가 발생할 수 있다. 쓰기 쪽은 파일시스템의 쓰기 동결과 조정하기 위한 &amp;lt;code&amp;gt;file_start_write()&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;file_end_write()&amp;lt;/code&amp;gt; 처리도 한다.&amp;lt;ref name=&amp;quot;rw&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 읽기와 쓰기 연산의 선택 ==&lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
! 요청 !! 직접 콜백 !! iterator 콜백을 사용하는 경로&lt;br /&gt;
|-&lt;br /&gt;
| 읽기 || &amp;lt;code&amp;gt;f_op-&amp;gt;read&amp;lt;/code&amp;gt; || &amp;lt;code&amp;gt;new_sync_read()&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;f_op-&amp;gt;read_iter&amp;lt;/code&amp;gt;&lt;br /&gt;
|-&lt;br /&gt;
| 쓰기 || &amp;lt;code&amp;gt;f_op-&amp;gt;write&amp;lt;/code&amp;gt; || &amp;lt;code&amp;gt;new_sync_write()&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;f_op-&amp;gt;write_iter&amp;lt;/code&amp;gt;&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
VFS는 직접 콜백이 있으면 그것을 사용하고, 없으면 iterator 콜백을 선택한다. &amp;lt;code&amp;gt;new_sync_read()&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;new_sync_write()&amp;lt;/code&amp;gt;는 요청 상태인 &amp;lt;code&amp;gt;kiocb&amp;lt;/code&amp;gt;와 버퍼 범위를 나타내는 &amp;lt;code&amp;gt;iov_iter&amp;lt;/code&amp;gt;를 준비한다. 읽기의 버퍼는 데이터를 받을 목적지(&amp;lt;code&amp;gt;ITER_DEST&amp;lt;/code&amp;gt;), 쓰기의 버퍼는 데이터를 제공할 원본(&amp;lt;code&amp;gt;ITER_SOURCE&amp;lt;/code&amp;gt;)이다. 동기식 &amp;lt;code&amp;gt;read()&amp;lt;/code&amp;gt;도 내부에서는 &amp;lt;code&amp;gt;read_iter&amp;lt;/code&amp;gt;를 사용할 수 있다. iterator 콜백은 동기식과 비동기식 입출력 모두에서 사용된다.&amp;lt;ref name=&amp;quot;rw&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 일반 파일의 버퍼드 입출력 ==&lt;br /&gt;
&lt;br /&gt;
ext4의 일반 파일에는 &amp;lt;code&amp;gt;.read_iter = ext4_file_read_iter&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;.write_iter = ext4_file_write_iter&amp;lt;/code&amp;gt;가 연결된다. DAX와 직접 입출력이 아닌 기본 경로는 다음과 같다.&amp;lt;ref name=&amp;quot;ext4&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/ext4/file.c?h=v6.12 Linux v6.12 fs/ext4/file.c], ext4_file_operations, ext4_file_read_iter, ext4_file_write_iter, ext4_buffered_write_iter.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
읽기: ext4_file_read_iter()&lt;br /&gt;
        -&amp;gt; generic_file_read_iter() -&amp;gt; filemap_read()&lt;br /&gt;
        -&amp;gt; 페이지 캐시의 데이터를 사용자 버퍼로 복사&lt;br /&gt;
&lt;br /&gt;
쓰기: ext4_file_write_iter()&lt;br /&gt;
        -&amp;gt; ext4_buffered_write_iter() -&amp;gt; generic_perform_write()&lt;br /&gt;
        -&amp;gt; 사용자 버퍼에서 캐시로 복사하고 수정 상태 반영&lt;br /&gt;
        -&amp;gt; 필요한 동기화 또는 이후 라이트백(Writeback)&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
읽을 데이터가 캐시에 준비되어 있으면 장치 읽기 없이 복사할 수 있다. 준비되지 않았다면 파일시스템을 통해 데이터를 가져오며, 그동안 요청한 스레드가 기다릴 수 있다.&amp;lt;ref name=&amp;quot;filemap&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/mm/filemap.c?h=v6.12 Linux v6.12 mm/filemap.c], generic_file_read_iter, filemap_read, generic_perform_write.&amp;lt;/ref&amp;gt; 일반적인 버퍼드 쓰기는 메모리의 파일 데이터를 수정하고 라이트백으로 나중에 장치에 반영할 수 있으므로, 성공한 &amp;lt;code&amp;gt;write()&amp;lt;/code&amp;gt;가 곧 전원 손실에도 보존되는 저장 완료를 의미하지는 않는다. 동기식 쓰기 플래그와 &amp;lt;code&amp;gt;fsync()&amp;lt;/code&amp;gt;는 이 완료 조건에 관여한다. 자세한 캐시 흐름은 [[운영체제 기본/Linux/파일시스템/페이지 캐시|페이지 캐시]], ext4의 블록 읽기는 [[운영체제 기본/Linux/파일시스템/ext4의 파일 읽기|ext4의 파일 읽기]]에서 이어진다.&amp;lt;ref name=&amp;quot;ext4&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
procfs의 &amp;lt;code&amp;gt;/proc/uptime&amp;lt;/code&amp;gt;은 같은 VFS 읽기 인터페이스에서 커널 상태로 문자열을 만든다. 키보드 이벤트를 읽는 장치 파일은 이벤트가 올 때까지 기다릴 수 있다. 따라서 fd와 반환 형식은 공통이어도, 데이터의 출처와 대기 조건은 대상의 구현에 달려 있다. 각각 [[운영체제 기본/Linux/파일시스템/procfs의 파일 읽기|procfs의 파일 읽기]], [[운영체제 기본/Linux/x86-64/i8042 키보드 입력/evdev의 이벤트 전달과 대기 해제|evdev의 이벤트 전달과 대기 해제]]에서 비교할 수 있다.&lt;br /&gt;
&lt;br /&gt;
== 짧은 읽기와 짧은 쓰기 ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;count&amp;lt;/code&amp;gt;는 요청량이고 반환값은 실제 처리량이다. 파일 내용이 &amp;lt;code&amp;gt;ABCDE&amp;lt;/code&amp;gt;이고 위치가 0일 때 다음처럼 진행된다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
read(fd, buf, 3) -&amp;gt; 3, &amp;quot;ABC&amp;quot;, f_pos = 3&lt;br /&gt;
read(fd, buf, 3) -&amp;gt; 2, &amp;quot;DE&amp;quot;,  f_pos = 5&lt;br /&gt;
read(fd, buf, 3) -&amp;gt; 0, EOF,   f_pos = 5&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
요청량보다 작더라도 양수인 반환값은 실제 처리한 바이트 수를 뜻한다. 읽기는 파일 끝, 장치의 현재 데이터량 등으로 짧아질 수 있고, 쓰기도 자원 부족이나 신호 등의 조건에서 일부만 처리할 수 있다. 전체 버퍼를 보내려면 실제 반환량만큼 버퍼 포인터와 남은 길이를 진행시켜야 한다. 이미 처리된 바이트가 있는 상태에서는 그 처리량이 먼저 반환되고 오류가 다음 호출에서 드러날 수도 있다.&lt;br /&gt;
&lt;br /&gt;
반환값 &amp;lt;code&amp;gt;-1&amp;lt;/code&amp;gt;과 &amp;lt;code&amp;gt;errno&amp;lt;/code&amp;gt;는 라이브러리 수준의 실패 표시다. &amp;lt;code&amp;gt;EINTR&amp;lt;/code&amp;gt;을 재시도하는 경우에도 양수로 반환된 부분 처리량을 버려서는 안 된다. 전체 데이터를 처리하려면 반환값에 따라 여러 번 호출해야 할 수 있다.&amp;lt;ref name=&amp;quot;man-read&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man2/read.2.html Linux man-pages, read(2)].&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;man-write&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man2/write.2.html Linux man-pages, write(2)].&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;rw&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 파일 위치와 추가 쓰기 ==&lt;br /&gt;
&lt;br /&gt;
보통의 순차 쓰기는 현재 위치에서 시작해 실제 쓴 만큼 위치를 진행시킨다. &amp;lt;code&amp;gt;O_APPEND&amp;lt;/code&amp;gt;로 연 파일에서는 쓰기 위치를 파일 끝으로 정하는 처리가 쓰기 연산에 포함된다. 반면 &amp;lt;code&amp;gt;lseek(fd, 0, SEEK_END)&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;write()&amp;lt;/code&amp;gt;를 따로 호출하면 그 사이에 다른 쓰기가 끼어들 수 있다.&amp;lt;ref name=&amp;quot;man-write&amp;quot;/&amp;gt; 파일 위치를 공유하는 fd, 명시적 위치의 &amp;lt;code&amp;gt;pread()&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;pwrite()&amp;lt;/code&amp;gt;는 다음 [[운영체제 기본/Linux/파일 시스템 콜/파일 오프셋과 열린 파일의 수명|파일 오프셋과 열린 파일의 수명]]에서 다룬다.&lt;br /&gt;
&lt;br /&gt;
[[운영체제 기본/Linux/메모리 매핑/파일 매핑과 COW|파일 메모리 매핑]]은 &amp;lt;code&amp;gt;read()&amp;lt;/code&amp;gt;로 사용자 버퍼에 복사하는 대신 파일 페이지를 주소 공간에 연결한다. 공유 매핑과 사유 매핑은 쓰기 결과가 달라지므로 각각의 동작을 구분해야 한다.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/파일 시스템 콜/openat과 경로 탐색|openat과 경로 탐색]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/파일 시스템 콜|파일 시스템 콜 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/파일 시스템 콜/파일 오프셋과 열린 파일의 수명|파일 오프셋과 열린 파일의 수명]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/i8042_%ED%82%A4%EB%B3%B4%EB%93%9C_%EC%9E%85%EB%A0%A5/i8042%EC%99%80_%EC%9E%85%EB%A0%A5_%EC%9D%B4%EB%B2%A4%ED%8A%B8&amp;diff=684</id>
		<title>운영체제 기본/Linux/x86-64/i8042 키보드 입력/i8042와 입력 이벤트</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/i8042_%ED%82%A4%EB%B3%B4%EB%93%9C_%EC%9E%85%EB%A0%A5/i8042%EC%99%80_%EC%9E%85%EB%A0%A5_%EC%9D%B4%EB%B2%A4%ED%8A%B8&amp;diff=684"/>
		<updated>2026-11-15T06:06:07Z</updated>

		<summary type="html">&lt;p&gt;관리자: 반복적인 부정 대조와 강조 표현 정리, 기술 설명 유지&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=&amp;lt;- 이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/i8042 키보드 입력/IRQ 진입과 디스패치|IRQ 진입과 디스패치]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/x86-64/i8042 키보드 입력|i8042 키보드 입력 목차]]&lt;br /&gt;
|다음=다음 문서 -&amp;gt;&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/i8042 키보드 입력/evdev의 이벤트 전달과 대기 해제|evdev의 이벤트 전달과 대기 해제]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
기준은 Linux v6.12의 x86 PS/2 키보드다. &amp;lt;code&amp;gt;i8042_interrupt()&amp;lt;/code&amp;gt;가 읽은 바이트는 serio와 PS/2 계층을 거쳐 Linux 입력 이벤트로 변환된다. USB 키보드는 별도 경로를 사용한다.&lt;br /&gt;
&lt;br /&gt;
== IRQ 처리기와 키보드 드라이버의 연결 ==&lt;br /&gt;
&lt;br /&gt;
키를 누르기 전에 두 연결이 준비되어 있다. 먼저 &amp;lt;code&amp;gt;i8042_setup_kbd()&amp;lt;/code&amp;gt;가 &amp;lt;code&amp;gt;request_irq()&amp;lt;/code&amp;gt;로 &amp;lt;code&amp;gt;i8042_interrupt&amp;lt;/code&amp;gt;를 등록한다. 별도로 i8042의 키보드 포트가 serio 포트로 등록되고, 여기에 atkbd 드라이버가 결합한다. serio는 직렬 입력 포트와 그 바이트를 해석하는 장치 드라이버를 연결하는 커널 계층이다.&amp;lt;ref name=&amp;quot;i8042setup&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/input/serio/i8042.c?h=v6.12#n1496 Linux v6.12, drivers/input/serio/i8042.c, i8042_setup_kbd, i8042_register_ports, i8042_start]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;atkbd_connect()&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;serio_open(serio, drv)&amp;lt;/code&amp;gt;를 호출한다. 이때 serio 코어가 &amp;lt;code&amp;gt;serio-&amp;gt;drv&amp;lt;/code&amp;gt;를 설정한다. 이후 수신 바이트는 이 포인터의 &amp;lt;code&amp;gt;interrupt&amp;lt;/code&amp;gt; 콜백으로 전달된다. IRQ 처리기와 atkbd 드라이버는 serio 계층을 통해 연결된다.&amp;lt;ref name=&amp;quot;serio&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/input/serio/serio.c?h=v6.12#n967 Linux v6.12, drivers/input/serio/serio.c, serio_open, serio_set_drv, serio_interrupt]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 상태 레지스터와 수신 바이트 처리 ==&lt;br /&gt;
&amp;lt;code&amp;gt;i8042_interrupt()&amp;lt;/code&amp;gt;는 잠금을 잡고 상태 레지스터를 읽는다. &amp;lt;code&amp;gt;I8042_STR_OBF&amp;lt;/code&amp;gt;가 꺼져 있으면 읽을 데이터가 없으므로 &amp;lt;code&amp;gt;IRQ_NONE&amp;lt;/code&amp;gt;을 반환한다. 데이터가 있으면 데이터 레지스터에서 한 바이트를 읽는다. 일반 x86 구현에서는 각각 I/O 포트 &amp;lt;code&amp;gt;0x64&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;0x60&amp;lt;/code&amp;gt;을 읽는다.&amp;lt;ref name=&amp;quot;io&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/input/serio/i8042-acpipnpio.h?h=v6.12 Linux v6.12, drivers/input/serio/i8042-acpipnpio.h, i8042_read_status, i8042_read_data]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
비다중화 경로에서 &amp;lt;code&amp;gt;AUXDATA&amp;lt;/code&amp;gt; 상태 비트는 마우스 쪽 AUX 포트와 키보드 포트를 구분한다. 패리티 오류와 타임아웃은 &amp;lt;code&amp;gt;SERIO_PARITY&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;SERIO_TIMEOUT&amp;lt;/code&amp;gt; 플래그로 옮긴다. 타임아웃 무시 설정과 AUX 다중화에는 별도 분기가 있다. 수신 상태와 설정에 따라 처리 경로가 달라진다.&amp;lt;ref name=&amp;quot;i8042irq&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/input/serio/i8042.c?h=v6.12#n526 Linux v6.12, drivers/input/serio/i8042.c, i8042_interrupt]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
포트가 존재하고 필터가 바이트를 소비하지 않았으면, 컨트롤러 잠금을 푼 다음 아래 호출이 실행된다.&amp;lt;ref name=&amp;quot;i8042irq&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
if (likely(serio &amp;amp;&amp;amp; !filtered))&lt;br /&gt;
	serio_interrupt(serio, data, dfl);&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 스캔 코드와 Linux 키 코드 변환 ==&lt;br /&gt;
v6.12의 실제 연결은 &amp;lt;code&amp;gt;serio_interrupt -&amp;gt; ps2_interrupt -&amp;gt; atkbd_receive_byte&amp;lt;/code&amp;gt;이다. &amp;lt;code&amp;gt;atkbd_drv.interrupt&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;ps2_interrupt&amp;lt;/code&amp;gt;이며, &amp;lt;code&amp;gt;atkbd_connect()&amp;lt;/code&amp;gt;가 &amp;lt;code&amp;gt;ps2_init()&amp;lt;/code&amp;gt;에 수신 콜백들을 전달한다.&amp;lt;ref name=&amp;quot;atkbdconnect&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/input/keyboard/atkbd.c?h=v6.12#n1274 Linux v6.12, drivers/input/keyboard/atkbd.c, atkbd_connect, atkbd_drv]&amp;lt;/ref&amp;gt; PS/2 공통 계층은 사전 수신 처리 뒤 ACK 대기나 명령 응답을 먼저 처리하고, 일반 데이터만 수신 콜백에 넘긴다.&amp;lt;ref name=&amp;quot;libps2&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/input/serio/libps2.c?h=v6.12#n594 Linux v6.12, drivers/input/serio/libps2.c, ps2_interrupt]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;atkbd_receive_byte()&amp;lt;/code&amp;gt;는 스캔 코드 집합과 컨트롤러의 변환 모드에 맞춰 바이트를 해석한다. 변환 모드에서는 일반적인 해제 코드의 상위 비트를 분리하고, 비변환 경로에서는 &amp;lt;code&amp;gt;0xf0&amp;lt;/code&amp;gt; 해제 접두사를 기억한다. 확장 접두사도 상태로 보관하며, 여러 바이트를 모아 하나의 키 이벤트로 해석할 수 있다. 정규화한 코드는 &amp;lt;code&amp;gt;atkbd-&amp;gt;keycode[code]&amp;lt;/code&amp;gt;를 통해 Linux 키 코드가 된다.&amp;lt;ref name=&amp;quot;atkbdreceive&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/input/keyboard/atkbd.c?h=v6.12#n442 Linux v6.12, drivers/input/keyboard/atkbd.c, atkbd_receive_byte, atkbd_compat_scancode]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
일반 키 경로는 다음과 같이 보고한다.&amp;lt;ref name=&amp;quot;atkbdreceive&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
input_event(dev, EV_KEY, keycode, value);&lt;br /&gt;
input_sync(dev);&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;value&amp;lt;/code&amp;gt;는 누름 1, 해제 0, 반복 2를 구별한다. 하드웨어 반복과 소프트웨어 반복 설정에 따라 반복을 만드는 경로는 달라진다. &amp;lt;code&amp;gt;input_report_key()&amp;lt;/code&amp;gt;는 값을 참과 거짓으로 바꾸는 편의 함수다. 반복 값 2를 유지하려면 위와 같이 &amp;lt;code&amp;gt;input_event()&amp;lt;/code&amp;gt;를 호출한다.&amp;lt;ref name=&amp;quot;helpers&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/linux/input.h?h=v6.12#n432 Linux v6.12, include/linux/input.h, input_report_key, input_sync]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 입력 이벤트 묶음과 다음 수신자 ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;input_event()&amp;lt;/code&amp;gt;는 장치가 지원하는 이벤트 유형인지 검사하고 &amp;lt;code&amp;gt;event_lock&amp;lt;/code&amp;gt; 아래에서 처리한다. &amp;lt;code&amp;gt;EV_KEY&amp;lt;/code&amp;gt;는 지원하는 키인지 확인한 뒤 누름 상태의 변화가 있을 때 전달한다. 값 2인 반복은 상태를 뒤집지 않고 전달한다. &amp;lt;code&amp;gt;input_sync()&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;EV_SYN/SYN_REPORT&amp;lt;/code&amp;gt;를 보고하며, 코어는 이를 계기로 모아 둔 이벤트들을 핸들러에 전달한다. 단독 동기화 이벤트만 있는 빈 묶음은 전달하지 않는다.&amp;lt;ref name=&amp;quot;inputcore&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/input/input.c?h=v6.12#n207 Linux v6.12, drivers/input/input.c, input_get_disposition, input_event_dispose, input_event]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
보통 열린 입력 핸들들을 순회하지만 독점 획득과 필터가 전달 대상을 바꿀 수 있다.&amp;lt;ref name=&amp;quot;pass&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/input/input.c?h=v6.12#n110 Linux v6.12, drivers/input/input.c, input_pass_values]&amp;lt;/ref&amp;gt; 예를 들어 A 키를 눌렀다 놓으면 핵심 결과는 &amp;lt;code&amp;gt;EV_KEY / KEY_A / 1&amp;lt;/code&amp;gt;과 &amp;lt;code&amp;gt;EV_KEY / KEY_A / 0&amp;lt;/code&amp;gt;이며 각각 동기화 경계가 뒤따른다. 스캔 코드 보조 이벤트가 함께 포함될 수도 있다.&amp;lt;ref name=&amp;quot;atkbdreceive&amp;quot;/&amp;gt; 여기서는 &amp;lt;code&amp;gt;KEY_A&amp;lt;/code&amp;gt; 같은 키 코드와 상태를 전달한다. Shift도 별도의 키 이벤트다. 문자는 이후 키보드 배열, 수정 키, 입력기 조합을 통해 정해진다.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=&amp;lt;- 이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/i8042 키보드 입력/IRQ 진입과 디스패치|IRQ 진입과 디스패치]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/x86-64/i8042 키보드 입력|i8042 키보드 입력 목차]]&lt;br /&gt;
|다음=다음 문서 -&amp;gt;&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/i8042 키보드 입력/evdev의 이벤트 전달과 대기 해제|evdev의 이벤트 전달과 대기 해제]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/%EC%9E%A5%EC%B9%98_%EC%A0%9C%EC%96%B4%EC%99%80_%EC%9E%85%EC%B6%9C%EB%A0%A5&amp;diff=683</id>
		<title>운영체제 기본/장치 제어와 입출력</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/%EC%9E%A5%EC%B9%98_%EC%A0%9C%EC%96%B4%EC%99%80_%EC%9E%85%EC%B6%9C%EB%A0%A5&amp;diff=683"/>
		<updated>2026-11-15T06:05:50Z</updated>

		<summary type="html">&lt;p&gt;관리자: 중복 설명과 불필요한 강조, 상투적인 대조, 특수문자 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/보호|보호와 시스템 콜]]&lt;br /&gt;
|목차=[[운영체제 기본#총론|총론 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/프로세스와 스레드|프로세스와 스레드]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
소프트웨어는 장치에 제어 명령을 전달하고 데이터를 옮긴 뒤, 사건이나 작업 완료를 확인한다. 장치 레지스터 접근, DMA, 인터럽트는 각각 이 과정의 다른 부분을 담당한다. DMA로 데이터를 전송하면서 완료는 인터럽트로 통지받을 수도 있고, 같은 DMA 전송의 완료를 폴링으로 확인할 수도 있다.&lt;br /&gt;
&lt;br /&gt;
== 장치 제어와 데이터 전송 ==&lt;br /&gt;
=== 레지스터를 통한 장치 제어 ===&lt;br /&gt;
&lt;br /&gt;
장치는 소프트웨어가 읽거나 쓸 수 있는 레지스터를 제공한다. 제어 레지스터에는 시작이나 중지 명령을 쓰고, 상태 레지스터에서는 준비 상태나 오류를 확인한다. 데이터 레지스터를 통해 실제 데이터를 주고받는 장치도 있다. 드라이버(Device Driver)는 장치별 제어 규약에 맞춰 레지스터를 조작하는 소프트웨어로, 운영체제의 요청을 실제 장치 동작으로 연결한다.&lt;br /&gt;
&lt;br /&gt;
메모리 매핑 입출력인 MMIO(Memory-Mapped Input/Output)는 CPU의 주소 공간 일부를 장치 접근에 사용한다. 포트 입출력은 일반 메모리와 구별되는 포트 주소 공간을 사용하며, x86에서는 별도의 입출력 명령으로 접근한다. 두 방식은 레지스터에 접근하는 방법의 차이다. 데이터 전송을 CPU가 담당할지 다른 하드웨어에 맡길지와는 별개의 구분이다.&amp;lt;ref name=&amp;quot;device-io&amp;quot;&amp;gt;Linux Kernel Documentation, [https://docs.kernel.org/driver-api/device-io.html Bus-Independent Device Accesses].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
장치 레지스터는 읽기가 상태를 바꾸거나 쓰기가 동작을 시작할 수 있다. 따라서 일반 변수처럼 접근을 생략하거나 순서를 바꿔도 된다고 가정할 수 없다. 쓰기 명령의 실행이 끝났더라도 실제 장치에 쓰기가 도착했는지는 별도로 판단해야 하는 하드웨어도 있다.&amp;lt;ref name=&amp;quot;device-io&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== DMA와 버퍼의 소유권 ===&lt;br /&gt;
&lt;br /&gt;
CPU가 데이터 레지스터를 읽어 메모리에 저장하는 방식에서는 CPU 명령 실행이 데이터 이동을 담당한다. i8042 입력에서 CPU가 컨트롤러의 데이터 레지스터를 읽는 것도 이쪽에 해당한다. 인터럽트는 이 레지스터를 읽을 시점을 알려 준다.&lt;br /&gt;
&lt;br /&gt;
직접 메모리 접근인 DMA(Direct Memory Access)에서는 장치 자체의 전송 엔진이나 별도의 DMA 컨트롤러가 메모리 접근을 수행한다. CPU가 전송되는 데이터마다 읽기와 쓰기 명령을 실행할 필요는 없다. 주변장치 대신 별도 컨트롤러가 전송하는 구조도 있고, 장치가 직접 버스 접근을 시작하는 버스 마스터 구조도 있다.&amp;lt;ref name=&amp;quot;dma-engine&amp;quot;&amp;gt;Linux Kernel Documentation, [https://docs.kernel.org/driver-api/dmaengine/client.html DMA Engine API Guide].&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;dma-map&amp;quot;&amp;gt;Linux Kernel Documentation, [https://docs.kernel.org/core-api/dma-api-howto.html Dynamic DMA mapping Guide].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
DMA에서도 드라이버는 버퍼를 준비하고 장치가 사용할 주소와 길이와 방향을 설정하며 전송을 제출한다. 전송 중인 버퍼를 덮어쓰거나 해제하면 데이터가 손상될 수 있으므로, CPU와 장치가 언제 데이터를 변경해도 되는지 소유권 규약이 필요하다. 버퍼와 주소 매핑은 전송이 끝날 때까지 유효해야 하며, 완료와 필요한 동기화를 확인한 뒤 재사용한다.&amp;lt;ref name=&amp;quot;dma-engine&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
네트워크 수신과 저장장치 블록 전송에서 DMA를 널리 사용한다. 완료 상태는 폴링이나 인터럽트로 확인할 수 있다.&lt;br /&gt;
&lt;br /&gt;
=== DMA의 주소 변환, 일관성, 전송 비용 ===&lt;br /&gt;
CPU의 가상 주소, CPU의 물리 주소, 장치의 DMA 주소는 구별해야 한다. 단순한 시스템에서는 DMA 주소와 물리 주소가 같지만 일반적으로 이를 가정할 수 없다. 입출력 메모리 관리 장치인 IOMMU(Input-Output Memory Management Unit)는 운영체제가 설정한 매핑에 따라 장치의 DMA 주소를 물리 메모리 주소로 바꾸는 하드웨어다. 운영체제는 장치가 접근할 영역을 설정하고, IOMMU는 DMA 접근에 그 설정을 적용한다. CPU가 실행하는 명령의 주소를 검사하는 MMU와 달리 장치의 메모리 접근을 중재한다. 모든 시스템에 IOMMU가 있는 것은 아니다.&amp;lt;ref name=&amp;quot;dma-map&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
CPU 캐시와 장치가 보는 메모리 사이에는 동기화가 필요할 수 있다. 하드웨어가 캐시 일관성을 제공하더라도 접근 순서까지 자동으로 보장하지는 않는다. 전송 요청을 기록한 디스크립터에서 주소와 길이보다 유효 표시가 먼저 보이면 장치가 미완성 작업을 실행할 수 있다. 메모리 배리어(Memory Barrier)는 컴파일러와 CPU가 메모리 접근을 재배치할 수 있는 범위를 제한하는 수단이다. 드라이버는 장치와 메모리의 특성에 맞는 배리어를 사용하여 이런 공개 순서를 보장한다.&amp;lt;ref name=&amp;quot;dma-map&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
DMA는 CPU의 반복적인 복사를 줄이지만 설정과 완료 처리, 주소 매핑, 캐시 동기화 비용이 든다. 장치는 버스와 메모리 대역폭을 소비하고 다른 작업과 경합한다. 임시 버퍼 때문에 추가 복사가 필요할 수도 있다. 버퍼 부족과 요청을 모으는 정책은 대기 시간에도 영향을 준다. 작은 전송은 CPU가 직접 처리하는 편이 단순할 수 있으며, DMA 사용 여부는 처리량뿐 아니라 지연과 자원 사용까지 고려해야 한다.&lt;br /&gt;
&lt;br /&gt;
== 사건 통지와 인터럽트 ==&lt;br /&gt;
&lt;br /&gt;
=== 비동기 사건과 인터럽트 ===&lt;br /&gt;
키보드 입력, 네트워크 패킷 도착, 저장장치의 입출력 완료는 실행 중인 프로그램의 명령 순서와 독립적으로 발생한다. 하드웨어 인터럽트는 사건을 CPU에 알리고 운영체제가 처리할 기회를 만드는 통지 수단이다. 키보드의 입력 바이트를 읽거나 패킷을 처리하는 일, 완료된 요청을 확인하는 일은 통지를 받은 뒤 각 처리기가 수행한다. 타이머 인터럽트는 실행 중인 작업의 협조 없이 CPU를 회수하는 선점에도 쓰인다.&lt;br /&gt;
&lt;br /&gt;
폴링은 장치 상태를 반복해서 확인한다. 자주 확인하면 응답은 빨라지지만 사건이 없을 때도 CPU 시간을 쓰고, 확인 간격을 늘리면 처리가 늦어진다. 인터럽트는 이런 반복 확인을 줄일 수 있으나 사건이 빈번하면 진입, 복귀 비용이 커진다. 인터럽트로 처리를 시작한 뒤 폴링으로 여러 결과를 묶어 처리하는 설계도 사용한다.&amp;lt;ref name=&amp;quot;interrupt-polling&amp;quot;&amp;gt;[https://docs.kernel.org/networking/napi.html Linux 커널 문서: NAPI], 인터럽트와 폴링의 결합.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== 인터럽트와 동기적 예외 ===&lt;br /&gt;
장치 인터럽트는 비동기적 사건인 반면, [[운영체제 기본/보호#보호 위반과 예외|메모리 접근 예외]]는 현재 명령의 실행과 연결된다. 시스템 콜(System Call)도 프로그램이 정해진 진입 명령으로 요청하는 동기적 사건이다. 트랩이라는 용어의 범위는 아키텍처마다 다르며, RISC-V에서는 인터럽트와 예외에 따른 제어 이전을 모두 트랩이라고 부른다.&amp;lt;ref name=&amp;quot;riscv-terms&amp;quot;&amp;gt;[https://docs.riscv.org/reference/isa/v20240411/unpriv/intro.html#_exceptions_traps_and_interrupts RISC-V Instruction Set Manual: Exceptions, Traps, and Interrupts].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== 처리 진입점과 IDT ===&lt;br /&gt;
[[운영체제 기본/보호#보호 위반과 예외|보호]]에서 본 예외와 장치 인터럽트는 발생 원인이 다르지만, 사건의 종류에 맞는 처리 코드로 실행을 넘겨야 한다. 이를 사건 번호인 벡터(vector)와 처리 진입점의 대응 관계로 생각할 수 있다.&lt;br /&gt;
&lt;br /&gt;
x86-64의 전통적인 처리 방식에서는 운영체제가 인터럽트 서술자 테이블(Interrupt Descriptor Table, IDT)을 초기화하고 CPU에 그 위치를 등록한다. CPU는 예외나 인터럽트의 벡터를 인덱스로 사용해 IDT 항목을 선택한다. 예를 들어 #PF는 14번, #GP는 13번 항목을 선택하여 해당 게이트가 가리키는 커널 진입 코드로 넘어간다. 각 항목은 처리 코드의 주소와 커널 진입에 필요한 속성을 담은 게이트(gate)다. 여기에는 대상 코드 영역, 스택 선택 정보, 게이트 유형과 접근 제한 등이 포함된다.&amp;lt;ref name=&amp;quot;intel-idt&amp;quot;&amp;gt;Intel, [https://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-developer-vol-3a-part-1-manual.pdf Intel 64 and IA-32 Architectures Software Developer&#039;s Manual, Volume 3A], 2016년 9월, 6.10~6.14절 및 5.8.8절.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
페이지 매핑 부재, 권한 위반 -&amp;gt; #PF(14) -&amp;gt; IDT[14] -&amp;gt; 커널의 페이지 폴트 진입 코드&lt;br /&gt;
일반 보호 예외     -&amp;gt; #GP(13) -&amp;gt; IDT[13] -&amp;gt; 커널의 일반 보호 예외 진입 코드&lt;br /&gt;
장치의 인터럽트    -&amp;gt; 벡터 v  -&amp;gt; IDT[v]  -&amp;gt; 커널의 인터럽트 진입 코드&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
게이트의 서술자 특권 수준(Descriptor Privilege Level, DPL)은 &amp;lt;code&amp;gt;INT n&amp;lt;/code&amp;gt; 같은 소프트웨어 명령으로 그 진입점을 호출할 수 있는지를 제한한다. 하드웨어 인터럽트나 CPU가 검출한 예외에는 이 게이트 DPL 검사를 적용하지 않는다.&amp;lt;ref name=&amp;quot;intel-idt&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
페이지 폴트는 아직 준비되지 않은 정상 주소의 첫 접근에서도 발생할 수 있다. CPU는 현재 매핑으로 접근을 마칠 수 없음을 알릴 뿐이며, 커널이 매핑을 준비할지 오류로 처리할지 결정한다.&lt;br /&gt;
&lt;br /&gt;
진입할 때 CPU가 복귀에 필요한 일부 상태를 저장하고, 운영체제의 진입 코드가 필요한 상태를 추가로 보존한다. 처리가 끝나면 소프트웨어가 상태를 복원하고 &amp;lt;code&amp;gt;IRETQ&amp;lt;/code&amp;gt; 같은 복귀 명령으로 실행을 이어 간다. 스케줄러가 다른 프로세스를 선택하면 컨텍스트 스위치(Context Switch)를 거쳐 실행 대상을 바꾼다.&amp;lt;ref name=&amp;quot;intel-idt&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
구체적인 x86 진입 코드는 [[운영체제 기본/Linux/x86-64/i8042 키보드 입력/IRQ 진입과 디스패치#IDT와 C 진입점|키보드 IRQ 각론]]으로 이어진다. 다른 아키텍처의 진입 구조는 다를 수 있다. x86-64에서도 &amp;lt;code&amp;gt;SYSCALL&amp;lt;/code&amp;gt;은 IDT 대신 별도로 설정된 진입 주소를 사용한다.&amp;lt;ref name=&amp;quot;intel-idt&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== 진입, 상태 보존, 복귀 ===&lt;br /&gt;
CPU는 인터럽트를 받아들일 때 복귀 위치와 이전 실행 권한 등 필요한 최소 상태를 보존하고 설정된 처리기 진입점으로 이동한다. 진입 코드는 나머지 레지스터와 처리기에 필요한 스택을 준비한다. 하드웨어와 소프트웨어가 맡는 범위는 아키텍처마다 다르다. 사용자 코드 실행 중이었다면 커널 처리를 위한 권한 전환도 이루어지며, 진입점과 권한을 함께 통제해 보호 경계를 유지한다.&amp;lt;ref name=&amp;quot;xv6-entry&amp;quot;&amp;gt;Cox 외, [https://pdos.csail.mit.edu/6.1810/2025/xv6/book-riscv-rev5.pdf xv6], 2025, 4.1, 4.2절.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
원래 실행을 재개할 때는 저장 상태를 복원하고 복귀 절차를 거친다.&lt;br /&gt;
&lt;br /&gt;
=== 입출력 완료와 깨우기 ===&lt;br /&gt;
입출력을 기다리는 스레드는 대기 상태로 두고 다른 작업에 CPU를 줄 수 있다. 장치가 완료 인터럽트를 보내면 드라이버가 요청의 결과를 확인하고 해당 요청을 기다리던 스레드를 깨운다. 깨어난 스레드는 실행 가능 상태가 되어 스케줄러의 선택을 기다린다.&amp;lt;ref name=&amp;quot;xv6-io&amp;quot;&amp;gt;Cox 외, [https://pdos.csail.mit.edu/6.1810/2025/xv6/book-riscv-rev5.pdf xv6], 6.1, 9.1절.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
입출력 대기 -&amp;gt; 완료 통지 -&amp;gt; 결과 확인과 깨우기&lt;br /&gt;
           -&amp;gt; 실행 가능 상태 -&amp;gt; 스케줄러 선택 -&amp;gt; 실행 재개&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
장치 인터럽트는 다른 작업이 실행 중일 때도 도착한다. 따라서 인터럽트에서 복귀하는 대상과 방금 깨어난 스레드가 같다고 볼 수 없다. DMA 전송이라면 완료 확인 뒤 버퍼를 사용할 수 있는 상태로 동기화하는 일도 필요하다.&lt;br /&gt;
&lt;br /&gt;
=== 타이머 인터럽트와 선점 ===&lt;br /&gt;
시스템 콜마다 실행 중인 작업을 양보시킨다고 가정하자. 다음 C 반복문에는 시스템 콜 자체가 없다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
while (1) {&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
시스템 콜을 유일한 양보 지점으로 삼았다면 커널은 다음 양보 지점을 기다려도 제어권을 돌려받지 못한다. 일반적인 선점형 시분할은 사용자 코드와 독립적으로 만료를 알리는 타이머를 사용한다. 커널이 통지 시각을 설정하면 반복문이 계속되어도 인터럽트로 다시 제어권을 얻을 수 있다.&amp;lt;ref name=&amp;quot;riscv-timer&amp;quot;&amp;gt;[https://docs.riscv.org/reference/isa/v20260120/priv/machine.html RISC-V Instruction Set Manual: Machine-Level ISA], 타이머와 인터럽트 레지스터.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
타이머 통지는 시간 계산과 선점 판단의 기회다. 다른 실행 가능 작업이 없거나 현재 작업을 유지할 이유가 있으면 그대로 복귀한다. 또한 인터럽트 진입을 잠시 막는 것과 스레드 선점을 미루는 것은 다른 제약이며, 안전한 시점까지 컨텍스트 스위치가 지연될 수 있다.&amp;lt;ref name=&amp;quot;preempt-safe&amp;quot;&amp;gt;[https://docs.kernel.org/locking/preempt-locking.html Linux 커널 문서: Proper Locking Under a Preemptible Kernel].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== 통지 빈도와 처리 비용 ===&lt;br /&gt;
인터럽트 통지나 컨텍스트 스위치를 자주 하면 응답 기회는 늘지만 처리기, 스케줄러 실행과 캐시 교란 비용도 늘 수 있다. 여러 사건을 묶으면 처리량은 좋아질 수 있지만 먼저 도착한 사건은 기다려야 한다. 처리량과 개별 요청의 지연 시간을 함께 고려해야 한다.&amp;lt;ref name=&amp;quot;switch-cache&amp;quot;&amp;gt;Mogul, Borg, [https://decdoc.itsx.net/WRL/WRL-TN-16.pdf The Effect of Context Switches on Cache Performance], 1990.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
원샷 타이머는 다음 필요한 시각에 한 번 울리도록 재설정할 수 있다. 틱리스 설계는 이를 활용해 불필요한 주기적 통지를 줄이면서 필요한 시점에 선점할 기회를 얻는다.&amp;lt;ref name=&amp;quot;dynamic-ticks&amp;quot;&amp;gt;[https://docs.kernel.org/timers/highres.html High resolution timers and dynamic ticks], [https://docs.kernel.org/timers/no_hz.html NO_HZ].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 실시간 제어와 RTOS ==&lt;br /&gt;
장치 제어에서는 결과뿐 아니라 도착 시점도 중요하다. 실시간 운영체제(RTOS: Real-Time Operating System)는 평균 처리량보다 응답 시간의 상한과 예측 가능성을 우선한다. 인터럽트를 막은 구간, 처리기 실행, 스케줄링과 잠금 대기뿐 아니라 버스 경쟁과 DMA 완료 대기도 실제 출력의 마감시간에 영향을 준다. 마감시간을 지킬 수 있는지 판단하려면 주어진 작업량과 하드웨어 조건에서 최악의 실행 시간과 대기 시간을 검토해야 한다.&amp;lt;ref name=&amp;quot;qnx-rtos-latency&amp;quot;&amp;gt;[https://qnx.com/developers/docs/7.1/com.qnx.doc.neutrino.sys_arch/topic/kernel_Scheduling_latency.html QNX Neutrino 7.1: Scheduling latency], 인터럽트 지연과 스케줄링 지연의 구분.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 관련 문서 ==&lt;br /&gt;
* [[운영체제 기본/파일과 입출력]]: 장치 위에서 제공하는 파일, 버퍼링, 영속성.&lt;br /&gt;
* [[운영체제 기본/Linux/x86-64/i8042 키보드 입력]]: i8042의 IRQ부터 입력 이벤트와 프로세스 깨우기까지.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/보호|보호와 시스템 콜]]&lt;br /&gt;
|목차=[[운영체제 기본#총론|총론 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/프로세스와 스레드|프로세스와 스레드]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%ED%8C%8C%EC%9D%BC_%EC%8B%9C%EC%8A%A4%ED%85%9C_%EC%BD%9C/openat%EA%B3%BC_%EA%B2%BD%EB%A1%9C_%ED%83%90%EC%83%89&amp;diff=682</id>
		<title>운영체제 기본/Linux/파일 시스템 콜/openat과 경로 탐색</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%ED%8C%8C%EC%9D%BC_%EC%8B%9C%EC%8A%A4%ED%85%9C_%EC%BD%9C/openat%EA%B3%BC_%EA%B2%BD%EB%A1%9C_%ED%83%90%EC%83%89&amp;diff=682"/>
		<updated>2026-11-15T06:05:43Z</updated>

		<summary type="html">&lt;p&gt;관리자: 문체 정리: 반복 대조와 탐색 표기 다듬기&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/파일 시스템 콜/시스템 콜과 파일 디스크립터|시스템 콜과 파일 디스크립터]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/파일 시스템 콜|파일 시스템 콜 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/파일 시스템 콜/read와 write|read와 write]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;openat()&amp;lt;/code&amp;gt;은 파일 이름을 열린 파일 객체로 바꾸고, 그 객체를 가리키는 fd를 반환한다. Linux v6.12의 기존 일반 파일을 여는 경로를 먼저 살펴본다.&lt;br /&gt;
&lt;br /&gt;
== 경로의 시작점 ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
int fd = openat(AT_FDCWD, &amp;quot;/home/ldmsys/a.txt&amp;quot;, O_RDONLY);&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
절대 경로는 프로세스의 루트 디렉터리에서 시작하므로 위 호출의 &amp;lt;code&amp;gt;dirfd&amp;lt;/code&amp;gt;는 경로의 시작점을 바꾸지 않는다. 상대 경로라면 &amp;lt;code&amp;gt;AT_FDCWD&amp;lt;/code&amp;gt;는 현재 작업 디렉터리를, 디렉터리 fd는 그 열린 디렉터리를 기준으로 삼는다. 예를 들어 &amp;lt;code&amp;gt;/home/ldmsys&amp;lt;/code&amp;gt;를 연 디렉터리 fd에 상대 이름 &amp;lt;code&amp;gt;&amp;quot;a.txt&amp;quot;&amp;lt;/code&amp;gt;를 전달할 수 있다. 시작 디렉터리, 마운트와 경로 구성요소는 &amp;lt;code&amp;gt;path_init()&amp;lt;/code&amp;gt; 및 경로 탐색 함수에서 처리된다.&amp;lt;ref name=&amp;quot;namei&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/namei.c?h=v6.12 Linux v6.12 fs/namei.c], path_init, link_path_walk, open_last_lookups, do_open, path_openat, do_filp_open.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 파일 디스크립터의 예약과 설치 ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;openat&amp;lt;/code&amp;gt; 시스템 콜은 &amp;lt;code&amp;gt;do_sys_open()&amp;lt;/code&amp;gt;에서 인자를 정리한 뒤 &amp;lt;code&amp;gt;do_sys_openat2()&amp;lt;/code&amp;gt;로 이어진다. &amp;lt;code&amp;gt;openat&amp;lt;/code&amp;gt;과 &amp;lt;code&amp;gt;openat2&amp;lt;/code&amp;gt; 시스템 콜은 이 공통 열기 구현을 공유한다.&amp;lt;ref name=&amp;quot;open&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/open.c?h=v6.12 Linux v6.12 fs/open.c], do_sys_open, do_sys_openat2, openat, do_dentry_open.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
openat()&lt;br /&gt;
  -&amp;gt; do_sys_open()&lt;br /&gt;
  -&amp;gt; do_sys_openat2()&lt;br /&gt;
       build_open_flags()       플래그와 접근 모드 정리&lt;br /&gt;
       getname()                사용자 경로 문자열 확보&lt;br /&gt;
       get_unused_fd_flags()    빈 fd 슬롯 예약&lt;br /&gt;
       do_filp_open()           경로 탐색과 파일 열기&lt;br /&gt;
       fd_install()             fd -&amp;gt; struct file 연결 설치&lt;br /&gt;
  -&amp;gt; fd 반환&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
fd 예약과 파일 열기는 별개 단계다. &amp;lt;code&amp;gt;do_filp_open()&amp;lt;/code&amp;gt;이 실패하면 &amp;lt;code&amp;gt;put_unused_fd()&amp;lt;/code&amp;gt;로 예약을 돌려준다. 성공한 뒤에만 &amp;lt;code&amp;gt;fd_install()&amp;lt;/code&amp;gt;로 포인터를 설치하므로, 반환된 fd에는 준비된 열린 파일 객체가 연결된다. 일반적인 성공 경로에서는 사용 가능한 가장 낮은 fd를 얻는다.&amp;lt;ref name=&amp;quot;fd-install&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/file.c?h=v6.12 Linux v6.12 fs/file.c], alloc_fd, get_unused_fd_flags, put_unused_fd, fd_install.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 이름 탐색과 파일 열기 ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;do_filp_open()&amp;lt;/code&amp;gt;은 &amp;lt;code&amp;gt;path_openat()&amp;lt;/code&amp;gt;에서 열린 파일 객체를 할당하고 경로를 탐색한다. 기존 일반 파일에서는 &amp;lt;code&amp;gt;link_path_walk()&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;open_last_lookups()&amp;lt;/code&amp;gt;로 구성요소를 처리한 뒤, &amp;lt;code&amp;gt;do_open()&amp;lt;/code&amp;gt;에서 최종 대상과 접근 권한 등을 확인하고 &amp;lt;code&amp;gt;vfs_open()&amp;lt;/code&amp;gt;으로 넘긴다. 이름 탐색은 dentry 캐시를 사용할 수 있고, 필요한 경우 파일시스템의 조회 연산을 호출한다. 캐시에 필요한 정보가 있으면 디스크에서 다시 읽는 작업을 줄일 수 있다.&amp;lt;ref name=&amp;quot;namei&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
/home/ldmsys/a.txt&lt;br /&gt;
  -&amp;gt; 시작점과 마운트 결정&lt;br /&gt;
  -&amp;gt; home -&amp;gt; ldmsys -&amp;gt; a.txt 이름 탐색&lt;br /&gt;
  -&amp;gt; 대상 dentry / inode 확보&lt;br /&gt;
  -&amp;gt; 열기 권한과 플래그 검사&lt;br /&gt;
  -&amp;gt; struct file 준비&lt;br /&gt;
  -&amp;gt; fd 테이블에 설치&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;do_dentry_open()&amp;lt;/code&amp;gt;은 &amp;lt;code&amp;gt;f_inode&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;f_mapping&amp;lt;/code&amp;gt; 등을 연결하고 inode의 &amp;lt;code&amp;gt;i_fop&amp;lt;/code&amp;gt;에서 파일 연산표를 얻는다. 등록된 &amp;lt;code&amp;gt;.open&amp;lt;/code&amp;gt; 함수가 있으면 이를 호출해 파일시스템이나 드라이버의 추가 상태를 준비한다. 일반 ext4 파일과 procfs 파일이 같은 열기 인터페이스를 사용하면서 서로 다른 읽기 연산을 갖게 되는 연결 지점이다.&amp;lt;ref name=&amp;quot;open&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
디렉터리 엔트리에서 inode와 데이터 블록으로 이어지는 구체적인 ext4 구조는 [[운영체제 기본/Linux/파일시스템/ext4의 파일 읽기|ext4의 파일 읽기]]에 설명되어 있다. 경로 탐색이 끝난 뒤에는 fd가 열린 객체를 붙잡고 있으므로, 후속 읽기와 쓰기는 이름 대신 그 객체를 사용한다.&lt;br /&gt;
&lt;br /&gt;
== 생성과 열기 플래그 ==&lt;br /&gt;
&lt;br /&gt;
기존 파일을 읽기 전용으로 여는 경로에 플래그가 더해지면 열기 과정의 작업도 달라진다.&lt;br /&gt;
&lt;br /&gt;
* &amp;lt;code&amp;gt;O_CREAT&amp;lt;/code&amp;gt;: 마지막 이름이 없으면 파일 생성 경로로 이어진다. 생성 모드는 요청한 &amp;lt;code&amp;gt;mode&amp;lt;/code&amp;gt;와 umask, 적용되는 ACL 등의 규칙에 따라 결정된다.&lt;br /&gt;
* &amp;lt;code&amp;gt;O_EXCL | O_CREAT&amp;lt;/code&amp;gt;: 같은 이름이 이미 있으면 실패한다.&lt;br /&gt;
* &amp;lt;code&amp;gt;O_TRUNC&amp;lt;/code&amp;gt;: 일반 파일을 열면서 길이를 0으로 줄이며 쓰기 권한 검사를 요구한다. 보통 &amp;lt;code&amp;gt;O_WRONLY&amp;lt;/code&amp;gt; 또는 &amp;lt;code&amp;gt;O_RDWR&amp;lt;/code&amp;gt;와 함께 사용한다. 파일 내용이 변경되므로 사용에 주의해야 한다.&lt;br /&gt;
* &amp;lt;code&amp;gt;O_CLOEXEC&amp;lt;/code&amp;gt;: exec 시 이 fd가 닫히도록 fd 테이블의 close-on-exec 비트를 함께 설정한다. 파일의 읽기 및 쓰기 위치와는 별개의 디스크립터 속성이다.&lt;br /&gt;
&lt;br /&gt;
생성과 마지막 구성요소의 열기는 파일시스템의 &amp;lt;code&amp;gt;atomic_open&amp;lt;/code&amp;gt; 등으로 결합될 수도 있다. 기본 읽기 경로를 이해할 때는 이름 탐색, 열린 파일 준비, fd 설치의 역할을 구분하면 된다.&amp;lt;ref name=&amp;quot;namei&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;open&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;fd-install&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 오류와 반환값 ==&lt;br /&gt;
&lt;br /&gt;
대상이 없으면 &amp;lt;code&amp;gt;ENOENT&amp;lt;/code&amp;gt;, 권한이 부족하면 &amp;lt;code&amp;gt;EACCES&amp;lt;/code&amp;gt;, 프로세스가 더 이상 fd를 할당할 수 없으면 &amp;lt;code&amp;gt;EMFILE&amp;lt;/code&amp;gt; 같은 오류가 발생한다. 커널은 음수 오류 코드를 반환하며, 일반적인 C 라이브러리 래퍼는 이를 &amp;lt;code&amp;gt;-1&amp;lt;/code&amp;gt;과 &amp;lt;code&amp;gt;errno&amp;lt;/code&amp;gt;로 전달한다. 열기에 성공하지 못했다면 유효한 새 fd도 얻지 못한 것이다.&amp;lt;ref name=&amp;quot;man-open&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man2/open.2.html Linux man-pages, open(2)].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/파일 시스템 콜/시스템 콜과 파일 디스크립터|시스템 콜과 파일 디스크립터]]&lt;br /&gt;
|목차=[[운영체제 기본/Linux/파일 시스템 콜|파일 시스템 콜 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/파일 시스템 콜/read와 write|read와 write]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/i8042_%ED%82%A4%EB%B3%B4%EB%93%9C_%EC%9E%85%EB%A0%A5/IRQ_%EC%A7%84%EC%9E%85%EA%B3%BC_%EB%94%94%EC%8A%A4%ED%8C%A8%EC%B9%98&amp;diff=681</id>
		<title>운영체제 기본/Linux/x86-64/i8042 키보드 입력/IRQ 진입과 디스패치</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/i8042_%ED%82%A4%EB%B3%B4%EB%93%9C_%EC%9E%85%EB%A0%A5/IRQ_%EC%A7%84%EC%9E%85%EA%B3%BC_%EB%94%94%EC%8A%A4%ED%8C%A8%EC%B9%98&amp;diff=681"/>
		<updated>2026-11-15T06:05:42Z</updated>

		<summary type="html">&lt;p&gt;관리자: 과도한 강조, 반복적인 부정 대조와 문장 부호 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|목차=[[운영체제 기본/Linux/x86-64/i8042 키보드 입력|i8042 키보드 입력 목차]]&lt;br /&gt;
|다음=다음 문서 -&amp;gt;&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/i8042 키보드 입력/i8042와 입력 이벤트|i8042와 입력 이벤트]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
== IRQ 번호와 CPU 벡터 ==&lt;br /&gt;
&lt;br /&gt;
이 문서는 Linux v6.12의 x86-64에서 i8042 PS/2 키보드가 이미 초기화된 뒤 입력이 발생하는 경우를 다룬다. IDT를 통해 진입해 인터럽트 문맥에서 IRQ 처리기를 실행하는 경로를 따른다.&lt;br /&gt;
&lt;br /&gt;
키보드가 바이트를 보내면 i8042 컨트롤러는 출력 버퍼 상태와 인터럽트 요청으로 이를 알린다. 여기서 키보드의 IRQ 선, Linux IRQ 번호, CPU 인터럽트 벡터는 서로 다른 식별자다. 전통적인 PC 키보드 경로는 IRQ1이라고 부르지만, 드라이버가 사용하는 번호는 플랫폼에서 정해진 &amp;lt;code&amp;gt;I8042_KBD_IRQ&amp;lt;/code&amp;gt;다. x86의 해당 매크로는 변수 &amp;lt;code&amp;gt;i8042_kbd_irq&amp;lt;/code&amp;gt;를 참조하며 PNP 자원 정보도 반영한다. 실제 IRQ 번호는 해당 플랫폼의 자원 정보를 확인해야 한다.&amp;lt;ref name=&amp;quot;platform&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/input/serio/i8042-acpipnpio.h?h=v6.12 Linux v6.12 drivers/input/serio/i8042-acpipnpio.h의 I8042_KBD_IRQ와 PNP 자원 처리]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
인터럽트 컨트롤러 설정은 장치의 요청을 수신할 CPU와 벡터에 연결한다. PIC와 I/O APIC은 외부 장치의 인터럽트를 CPU에 전달하는 컨트롤러다. 어떤 컨트롤러와 라우팅을 사용하는지는 실제 부팅 구성에 달려 있다. 여기서는 등록된 키보드 IRQ가 해당 CPU의 유효한 벡터로 전달된 정상 경로를 따라간다. IRQ 번호와 CPU 벡터의 대응은 라우팅 설정에 따라 달라진다. 커널은 CPU별 &amp;lt;code&amp;gt;vector_irq&amp;lt;/code&amp;gt;에 벡터와 IRQ 디스크립터의 대응을 유지한다.&amp;lt;ref name=&amp;quot;vector&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/kernel/apic/vector.c?h=v6.12 Linux v6.12 arch/x86/kernel/apic/vector.c의 벡터 할당과 vector_irq]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== IDT와 C 진입점 ==&lt;br /&gt;
IDT(Interrupt Descriptor Table)는 인터럽트, 예외 벡터별로 진입 주소와 속성을 담은 테이블이다. CPU가 인터럽트를 받아들이면 벡터 번호로 IDT의 엔트리를 골라 제어를 옮긴다. 하드웨어가 복귀에 필요한 상태를 저장하고, 커널의 진입 어셈블리가 일반 레지스터 저장과 실행 환경 정리를 이어서 수행한다. &amp;lt;code&amp;gt;idt_setup_apic_and_irq_gates()&amp;lt;/code&amp;gt;는 장치 벡터에 &amp;lt;code&amp;gt;irq_entries_start&amp;lt;/code&amp;gt;의 대응 스텁을 연결한다.&amp;lt;ref name=&amp;quot;idt&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/kernel/idt.c?h=v6.12 Linux v6.12 arch/x86/kernel/idt.c의 idt_setup_apic_and_irq_gates]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
스텁에서 핵심적인 두 명령은 다음과 같다. &amp;lt;code&amp;gt;0x6a&amp;lt;/code&amp;gt;는 즉시값을 스택에 넣는 명령의 opcode다. 뒤의 &amp;lt;code&amp;gt;vector&amp;lt;/code&amp;gt;는 스택에 담을 CPU 인터럽트 벡터 번호다.&amp;lt;ref name=&amp;quot;idtentry&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/include/asm/idtentry.h?h=v6.12 Linux v6.12 arch/x86/include/asm/idtentry.h의 irq_entries_start와 DEFINE_IDTENTRY_IRQ]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
.byte 0x6a, vector&lt;br /&gt;
jmp asm_common_interrupt&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;asm_common_interrupt&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;idtentry_irq&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;idtentry&amp;lt;/code&amp;gt; 매크로로 만들어진다. 이어지는 &amp;lt;code&amp;gt;idtentry_body&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;error_entry&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;pt_regs&amp;lt;/code&amp;gt; 형태의 저장 상태를 마련하고, 이를 첫 번째 인자로, 벡터를 두 번째 인자로 &amp;lt;code&amp;gt;common_interrupt()&amp;lt;/code&amp;gt;에 전달한다. 벡터는 예외의 오류 코드가 놓이는 스택 자리를 재사용한다.&amp;lt;ref name=&amp;quot;entry64&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/entry/entry_64.S?h=v6.12 Linux v6.12 arch/x86/entry/entry_64.S의 idtentry_body, idtentry_irq, error_entry]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;DEFINE_IDTENTRY_IRQ&amp;lt;/code&amp;gt;가 만드는 C 래퍼는 &amp;lt;code&amp;gt;irqentry_enter()&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;run_irq_on_irqstack_cond()&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;irqentry_exit()&amp;lt;/code&amp;gt; 순서로 본체를 감싼다. 벡터를 8비트로 정리하는 처리도 여기에 있다. 조건부 IRQ 스택 경로는 &amp;lt;code&amp;gt;irq_enter_rcu()&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;irq_exit_rcu()&amp;lt;/code&amp;gt;로 hardirq 실행을 표시한다. 사용자 모드에서 들어왔거나 IRQ 스택을 이미 사용 중이면 무조건 다른 IRQ 스택으로 바꾸지는 않는다.&amp;lt;ref name=&amp;quot;idtentry&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;irqstack&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/include/asm/irq_stack.h?h=v6.12 Linux v6.12 arch/x86/include/asm/irq_stack.h의 call_on_irqstack_cond와 run_irq_on_irqstack_cond]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 벡터와 IRQ 디스크립터의 연결 ==&lt;br /&gt;
&amp;lt;code&amp;gt;common_interrupt()&amp;lt;/code&amp;gt; 본체는 현재 저장 레지스터를 연결한 뒤 &amp;lt;code&amp;gt;call_irq_handler()&amp;lt;/code&amp;gt;를 호출한다. 아래는 정상 디스크립터를 찾는 분기다.&amp;lt;ref name=&amp;quot;irqc&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/kernel/irq.c?h=v6.12 Linux v6.12 arch/x86/kernel/irq.c의 common_interrupt, call_irq_handler, handle_irq]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
desc = __this_cpu_read(vector_irq[vector]);&lt;br /&gt;
if (likely(!IS_ERR_OR_NULL(desc))) {&lt;br /&gt;
	handle_irq(desc, regs);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이 배열 조회가 CPU 벡터를 Linux의 &amp;lt;code&amp;gt;struct irq_desc&amp;lt;/code&amp;gt;로 연결한다. x86-64의 &amp;lt;code&amp;gt;handle_irq()&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;generic_handle_irq_desc()&amp;lt;/code&amp;gt;를 호출하고, 그 함수는 디스크립터에 설치된 flow handler를 실행한다.&amp;lt;ref name=&amp;quot;irqdesc&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/linux/irqdesc.h?h=v6.12 Linux v6.12 include/linux/irqdesc.h의 generic_handle_irq_desc]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
static inline void generic_handle_irq_desc(struct irq_desc *desc)&lt;br /&gt;
{&lt;br /&gt;
	desc-&amp;gt;handle_irq(desc);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
flow handler는 IRQ가 비활성화되었는지, 다른 처리가 진행 중인지, pending 상태가 있는지 등을 관리하며 컨트롤러 연산과 드라이버 호출을 조율한다. 예를 들어 edge로 설정된 I/O APIC 경로는 &amp;lt;code&amp;gt;handle_edge_irq()&amp;lt;/code&amp;gt;를 사용한다. 이 함수는 정상 처리에서 &amp;lt;code&amp;gt;irq_ack&amp;lt;/code&amp;gt;를 호출한 뒤 &amp;lt;code&amp;gt;handle_irq_event()&amp;lt;/code&amp;gt;로 넘어가고, 처리 중 pending이 생기면 조건에 따라 반복한다. 사용할 flow handler는 컨트롤러 구성에 따라 정해진다.&amp;lt;ref name=&amp;quot;flow&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/kernel/irq/chip.c?h=v6.12 Linux v6.12 kernel/irq/chip.c의 handle_edge_irq]&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;ioapic&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/kernel/apic/io_apic.c?h=v6.12 Linux v6.12 arch/x86/kernel/apic/io_apic.c의 mp_register_handler와 ioapic_chip]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== i8042 IRQ 처리기 호출 ==&lt;br /&gt;
앞선 초기화에서 &amp;lt;code&amp;gt;i8042_setup_kbd()&amp;lt;/code&amp;gt;는 다음 호출로 키보드 IRQ의 action을 등록했다. &amp;lt;code&amp;gt;IRQF_SHARED&amp;lt;/code&amp;gt;는 공유 가능한 등록이며, 같은 디스크립터에 다른 action이 있을 가능성을 허용한다.&amp;lt;ref name=&amp;quot;i8042&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/input/serio/i8042.c?h=v6.12 Linux v6.12 drivers/input/serio/i8042.c의 i8042_setup_kbd와 i8042_interrupt]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
error = request_irq(I8042_KBD_IRQ, i8042_interrupt, IRQF_SHARED,&lt;br /&gt;
		    &amp;quot;i8042&amp;quot;, i8042_platform_device);&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;handle_irq_event()&amp;lt;/code&amp;gt;는 pending을 지우고 진행 중 상태를 세운 다음 디스크립터 잠금을 풀어 action을 실행한다. &amp;lt;code&amp;gt;handle_irq_event_percpu()&amp;lt;/code&amp;gt;를 거친 &amp;lt;code&amp;gt;__handle_irq_event_percpu()&amp;lt;/code&amp;gt;는 action 목록을 돌며 다음 호출을 수행한다. 여기의 &amp;lt;code&amp;gt;irq&amp;lt;/code&amp;gt;는 Linux IRQ 번호인 &amp;lt;code&amp;gt;desc-&amp;gt;irq_data.irq&amp;lt;/code&amp;gt;다.&amp;lt;ref name=&amp;quot;actions&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/kernel/irq/handle.c?h=v6.12 Linux v6.12 kernel/irq/handle.c의 handle_irq_event와 __handle_irq_event_percpu]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
res = action-&amp;gt;handler(irq, action-&amp;gt;dev_id);&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
키보드 action에서는 이것이 &amp;lt;code&amp;gt;i8042_interrupt()&amp;lt;/code&amp;gt; 호출이다. 이 호출은 인터럽트 당시 실행 중이던 태스크를 중단한 hardirq 문맥에서 이루어진다. 키보드 독자는 다른 CPU에서 실행 중이거나 잠들어 있을 수도 있다. 이후 독자를 깨우더라도 실제 실행 재개는 스케줄링 문제다. IRQ 복귀 경로도 복귀 모드와 설정에 따라 재스케줄링 조건을 검사한다.&amp;lt;ref name=&amp;quot;exit&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/kernel/entry/common.c?h=v6.12 Linux v6.12 kernel/entry/common.c의 irqentry_exit와 irqentry_exit_cond_resched]&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
장치 버퍼를 읽는 일과 인터럽트 컨트롤러의 ACK 및 EOI도 구분해야 한다. 앞의 edge 경로에서는 컨트롤러 계층의 &amp;lt;code&amp;gt;irq_ack&amp;lt;/code&amp;gt;가 상위 APIC 처리로 이어질 수 있고, &amp;lt;code&amp;gt;apic_ack_irq()&amp;lt;/code&amp;gt;가 &amp;lt;code&amp;gt;apic_eoi()&amp;lt;/code&amp;gt;를 수행한다. EOI의 처리 시점과 담당 계층은 이 경로에 따라 정해진다. 다음 단계에서 i8042 드라이버는 컨트롤러에 도착한 입력 바이트를 읽는다.&amp;lt;ref name=&amp;quot;ioapic&amp;quot;/&amp;gt;&amp;lt;ref name=&amp;quot;vector&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|목차=[[운영체제 기본/Linux/x86-64/i8042 키보드 입력|i8042 키보드 입력 목차]]&lt;br /&gt;
|다음=다음 문서 -&amp;gt;&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/i8042 키보드 입력/i8042와 입력 이벤트|i8042와 입력 이벤트]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%ED%8C%8C%EC%9D%BC_%EC%8B%9C%EC%8A%A4%ED%85%9C_%EC%BD%9C/%EC%8B%9C%EC%8A%A4%ED%85%9C_%EC%BD%9C%EA%B3%BC_%ED%8C%8C%EC%9D%BC_%EB%94%94%EC%8A%A4%ED%81%AC%EB%A6%BD%ED%84%B0&amp;diff=680</id>
		<title>운영체제 기본/Linux/파일 시스템 콜/시스템 콜과 파일 디스크립터</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%ED%8C%8C%EC%9D%BC_%EC%8B%9C%EC%8A%A4%ED%85%9C_%EC%BD%9C/%EC%8B%9C%EC%8A%A4%ED%85%9C_%EC%BD%9C%EA%B3%BC_%ED%8C%8C%EC%9D%BC_%EB%94%94%EC%8A%A4%ED%81%AC%EB%A6%BD%ED%84%B0&amp;diff=680"/>
		<updated>2026-11-15T06:05:25Z</updated>

		<summary type="html">&lt;p&gt;관리자: 문체 정리: 나열, 대조 표현과 탐색 표기 다듬기&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=첫 문서&lt;br /&gt;
|목차=[[운영체제 기본/Linux/파일 시스템 콜|파일 시스템 콜 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/파일 시스템 콜/openat과 경로 탐색|openat과 경로 탐색]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
응용 프로그램은 파일을 열어 파일 디스크립터(File Descriptor, fd)를 얻고, 같은 fd로 읽기, 쓰기, 위치 변경, 닫기를 요청한다. Linux v6.12에서는 이 요청들이 파일 디스크립터 테이블과 열린 파일 객체를 공유한다. 각 시스템 콜은 공통 객체에서 필요한 연산을 선택한다.&lt;br /&gt;
&lt;br /&gt;
== 파일 접근의 수명 ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
openat(AT_FDCWD, &amp;quot;/home/ldmsys/a.txt&amp;quot;, O_RDWR)&lt;br /&gt;
  -&amp;gt; 경로 탐색과 열기 -&amp;gt; fd = 3&lt;br /&gt;
                           |&lt;br /&gt;
             +-------------+--------------+&lt;br /&gt;
             |             |              |&lt;br /&gt;
          read(3, ...)  write(3, ...)  lseek(3, ...)&lt;br /&gt;
             |             |              |&lt;br /&gt;
             +------ 같은 struct file ----+&lt;br /&gt;
                           |&lt;br /&gt;
                        close(3)&lt;br /&gt;
                           |&lt;br /&gt;
                  fd 테이블의 연결 해제&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;openat()&amp;lt;/code&amp;gt;은 이름으로 대상을 찾아 열린 파일 객체를 만든다. 그 뒤의 &amp;lt;code&amp;gt;read()&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;write()&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;lseek()&amp;lt;/code&amp;gt;는 fd로 이미 열린 객체를 찾으므로 매번 &amp;lt;code&amp;gt;/home/ldmsys/a.txt&amp;lt;/code&amp;gt;를 다시 탐색하지 않는다. &amp;lt;code&amp;gt;close()&amp;lt;/code&amp;gt;는 fd 테이블에서 그 연결을 끊는다. 열린 파일 객체를 참조하는 다른 fd나 메모리 매핑이 있으면 객체의 수명은 계속된다.&lt;br /&gt;
&lt;br /&gt;
== 아키텍처별 시스템 콜 진입 ==&lt;br /&gt;
&lt;br /&gt;
C 함수의 인자를 커널에 전달하는 규약은 아키텍처마다 다르다. 아래는 Linux의 일반적인 64비트 사용자 ABI다. 라이브러리 래퍼가 시스템 콜 번호와 인자를 준비하며, &amp;lt;code&amp;gt;open()&amp;lt;/code&amp;gt; 같은 라이브러리 함수가 내부적으로 &amp;lt;code&amp;gt;openat&amp;lt;/code&amp;gt; 시스템 콜을 사용할 수도 있다.&amp;lt;ref name=&amp;quot;man-open&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man2/open.2.html Linux man-pages, open(2)].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
! 항목 !! x86-64 !! RISC-V RV64&lt;br /&gt;
|-&lt;br /&gt;
| 진입 명령 || &amp;lt;code&amp;gt;syscall&amp;lt;/code&amp;gt; || &amp;lt;code&amp;gt;ecall&amp;lt;/code&amp;gt;&lt;br /&gt;
|-&lt;br /&gt;
| 시스템 콜 번호 || &amp;lt;code&amp;gt;rax&amp;lt;/code&amp;gt; || &amp;lt;code&amp;gt;a7&amp;lt;/code&amp;gt;&lt;br /&gt;
|-&lt;br /&gt;
| 인자 1~6 || &amp;lt;code&amp;gt;rdi, rsi, rdx, r10, r8, r9&amp;lt;/code&amp;gt; || &amp;lt;code&amp;gt;a0~a5&amp;lt;/code&amp;gt;&lt;br /&gt;
|-&lt;br /&gt;
| 반환값 || &amp;lt;code&amp;gt;rax&amp;lt;/code&amp;gt; || &amp;lt;code&amp;gt;a0&amp;lt;/code&amp;gt;&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
x86-64에서는 &amp;lt;code&amp;gt;entry_SYSCALL_64&amp;lt;/code&amp;gt;가 커널 스택과 레지스터 상태를 준비하고 &amp;lt;code&amp;gt;do_syscall_64()&amp;lt;/code&amp;gt;의 디스패치로 이어진다. RV64에서는 사용자 모드의 &amp;lt;code&amp;gt;ecall&amp;lt;/code&amp;gt; 트랩이 &amp;lt;code&amp;gt;handle_exception&amp;lt;/code&amp;gt;을 거쳐 &amp;lt;code&amp;gt;do_trap_ecall_u()&amp;lt;/code&amp;gt;로 전달된다. 이 함수는 저장된 &amp;lt;code&amp;gt;a7&amp;lt;/code&amp;gt;에서 번호를 읽고 다음 명령으로 돌아갈 수 있도록 저장된 PC를 진행시킨다. 아키텍처별 래퍼가 인자를 꺼낸 뒤에는 같은 &amp;lt;code&amp;gt;fs/open.c&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;fs/read_write.c&amp;lt;/code&amp;gt;의 공통 구현으로 연결된다.&amp;lt;ref name=&amp;quot;x86-entry&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/entry/entry_64.S?h=v6.12 Linux v6.12 arch/x86/entry/entry_64.S], entry_SYSCALL_64.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;x86-common&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/entry/common.c?h=v6.12 Linux v6.12 arch/x86/entry/common.c], do_syscall_64, do_syscall_x64.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;rv-entry&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/riscv/kernel/entry.S?h=v6.12 Linux v6.12 arch/riscv/kernel/entry.S], handle_exception.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;rv-traps&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/riscv/kernel/traps.c?h=v6.12 Linux v6.12 arch/riscv/kernel/traps.c], do_trap_ecall_u.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
시스템 콜 진입은 현재 스레드가 커널 코드를 실행하기 위한 권한 전환이다. 항상 다른 스레드로 컨텍스트 스위치하는 것은 아니다. 데이터가 준비되기를 기다려야 하면 현재 스레드가 잠들고 다른 스레드가 실행될 수 있다. 권한 전환과 스케줄링의 관계는 [[운영체제 기본/보호|보호와 시스템 콜]], [[운영체제 기본/프로세스와 스레드|프로세스와 스레드]]에서 이어진다.&lt;br /&gt;
&lt;br /&gt;
== 파일 디스크립터와 열린 파일 객체 ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
current&lt;br /&gt;
  -&amp;gt; files (struct files_struct)&lt;br /&gt;
       -&amp;gt; fdtable&lt;br /&gt;
            fd[3] ----&amp;gt; struct file&lt;br /&gt;
                          f_pos     현재 파일 위치&lt;br /&gt;
                          f_flags   열린 파일의 상태 플래그&lt;br /&gt;
                          f_path    경로와 마운트&lt;br /&gt;
                          f_inode   파일의 inode&lt;br /&gt;
                          f_op ----&amp;gt; struct file_operations&lt;br /&gt;
                                      read / read_iter&lt;br /&gt;
                                      write / write_iter&lt;br /&gt;
                                      llseek / fsync / release&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;current&amp;lt;/code&amp;gt;는 현재 태스크이고, &amp;lt;code&amp;gt;current-&amp;gt;files&amp;lt;/code&amp;gt;는 그 태스크가 사용하는 파일 디스크립터 테이블로 이어진다. fd는 이 테이블의 슬롯 번호다. 다른 테이블의 fd 3은 다른 파일을 가리킬 수 있다. &amp;lt;code&amp;gt;struct file&amp;lt;/code&amp;gt;은 파일을 한 번 연 상태를 나타내며, 파일의 메타데이터를 나타내는 inode와 구별된다. 같은 파일을 두 번 열면 대개 같은 inode를 가리키는 서로 다른 &amp;lt;code&amp;gt;struct file&amp;lt;/code&amp;gt;을 얻는다.&amp;lt;ref name=&amp;quot;fdtable&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/linux/fdtable.h?h=v6.12 Linux v6.12 include/linux/fdtable.h], files_struct, fdtable.&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;file-types&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/linux/fs.h?h=v6.12 Linux v6.12 include/linux/fs.h], file, file_operations.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
fd 조회에서는 단순히 포인터 배열을 읽는 것 외에도 다른 스레드의 닫기와 객체 수명을 고려해야 한다. &amp;lt;code&amp;gt;fdget()&amp;lt;/code&amp;gt;은 이런 조회와 참조 처리를 제공하고, &amp;lt;code&amp;gt;fdget_pos()&amp;lt;/code&amp;gt;는 공유된 파일 위치를 사용하는 연산에 필요한 &amp;lt;code&amp;gt;f_pos_lock&amp;lt;/code&amp;gt;도 잡는다. 사용을 마치면 각각 &amp;lt;code&amp;gt;fdput()&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;fdput_pos()&amp;lt;/code&amp;gt;로 대응한다.&amp;lt;ref name=&amp;quot;fd-lookup&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/file.c?h=v6.12 Linux v6.12 fs/file.c], __fget_light, fdget_pos, file_needs_f_pos_lock.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 공통 VFS와 대상별 연산 ==&lt;br /&gt;
&lt;br /&gt;
가상 파일시스템(Virtual File System, VFS)은 열린 파일과 연산의 공통 틀을 제공한다. &amp;lt;code&amp;gt;read()&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;vfs_read()&amp;lt;/code&amp;gt;를 거쳐 &amp;lt;code&amp;gt;f_op&amp;lt;/code&amp;gt;의 읽기 함수를 고르고, &amp;lt;code&amp;gt;write()&amp;lt;/code&amp;gt;도 &amp;lt;code&amp;gt;vfs_write()&amp;lt;/code&amp;gt;에서 쓰기 함수를 고른다. 이때 실제 구현은 ext4, procfs, 장치 드라이버 등에 따라 달라진다. inode, dentry, 마운트의 관계는 [[운영체제 기본/Linux/파일시스템/VFS와 파일 객체|VFS와 파일 객체]]에서 자세히 다룬다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;openat()&amp;lt;/code&amp;gt;은 아직 fd가 없으므로 경로 탐색에서 시작하고, &amp;lt;code&amp;gt;close()&amp;lt;/code&amp;gt;는 fd 테이블의 연결을 제거한다. 각 시스템 콜의 처리 경로에서 만들고 사용하는 &amp;lt;code&amp;gt;struct file&amp;lt;/code&amp;gt;이 파일 접근의 수명을 연결한다.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=첫 문서&lt;br /&gt;
|목차=[[운영체제 기본/Linux/파일 시스템 콜|파일 시스템 콜 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/파일 시스템 콜/openat과 경로 탐색|openat과 경로 탐색]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/BIOS_%EB%B6%80%ED%8C%85/GRUB%EC%9D%98_%EC%BB%A4%EB%84%90_%EC%A0%81%EC%9E%AC%EC%99%80_%EC%A0%9C%EC%96%B4%EA%B6%8C_%EC%A0%84%EB%8B%AC&amp;diff=679</id>
		<title>운영체제 기본/Linux/x86-64/BIOS 부팅/GRUB의 커널 적재와 제어권 전달</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/BIOS_%EB%B6%80%ED%8C%85/GRUB%EC%9D%98_%EC%BB%A4%EB%84%90_%EC%A0%81%EC%9E%AC%EC%99%80_%EC%A0%9C%EC%96%B4%EA%B6%8C_%EC%A0%84%EB%8B%AC&amp;diff=679"/>
		<updated>2026-11-15T06:05:18Z</updated>

		<summary type="html">&lt;p&gt;관리자: 문체 정리: 과도한 강조와 반복 대조 표현, 특수문자 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|목차=[[운영체제 기본/Linux/x86-64/BIOS 부팅|BIOS 부팅 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/진입 규약과 압축 해제|진입 규약과 압축 해제]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
BIOS 환경의 GRUB 2.12가 &amp;lt;code&amp;gt;linux&amp;lt;/code&amp;gt; 명령으로 Linux v6.12의 x86-64 bzImage를 부팅하는 경로를 다룬다. GRUB 메뉴에서 커널을 선택한 시점부터 시작한다.&lt;br /&gt;
&lt;br /&gt;
이 경로에서는 GRUB가 32비트 보호 모드로 x86-64 커널의 압축 해제 코드에 직접 진입하며, Linux의 16비트 setup 코드는 실행하지 않는다. GNU GRUB 매뉴얼도 일반 &amp;lt;code&amp;gt;linux&amp;lt;/code&amp;gt; 명령과 16비트 진입을 사용하는 &amp;lt;code&amp;gt;linux16&amp;lt;/code&amp;gt; 명령을 구별한다.&amp;lt;ref name=&amp;quot;grub-manual&amp;quot;&amp;gt;[https://www.gnu.org/software/grub/manual/grub/html_node/GNU_002fLinux.html GNU GRUB Manual, GNU/Linux]. 명령의 구분을 설명하는 공식 매뉴얼. 이 문서의 구현 분석은 현재 매뉴얼 버전이 아니라 GRUB 2.12 소스에 고정한다.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 전체 경로 ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
GRUB 2.12 (BIOS)&lt;br /&gt;
    |&lt;br /&gt;
    +-- linux  : read bzImage, prepare parameters&lt;br /&gt;
    +-- initrd : read initial RAM filesystem image&lt;br /&gt;
    +-- boot   : finalize memory map and handoff state&lt;br /&gt;
    |&lt;br /&gt;
    v&lt;br /&gt;
32-bit protected mode, paging off&lt;br /&gt;
    |&lt;br /&gt;
    v&lt;br /&gt;
arch/x86/boot/compressed/head_64.S&lt;br /&gt;
    startup_32&lt;br /&gt;
    |&lt;br /&gt;
    +-- replace GDT, set up early execution state&lt;br /&gt;
    +-- prepare transition to 64-bit mode&lt;br /&gt;
    |&lt;br /&gt;
    v&lt;br /&gt;
    startup_64&lt;br /&gt;
    |&lt;br /&gt;
    v&lt;br /&gt;
decompression and entry to the uncompressed kernel&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이 그림의 &amp;lt;code&amp;gt;startup_32&amp;lt;/code&amp;gt;와 &amp;lt;code&amp;gt;startup_64&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;arch/x86/boot/compressed/head_64.S&amp;lt;/code&amp;gt; 안의 기호이다. 압축이 풀린 커널 쪽 &amp;lt;code&amp;gt;arch/x86/kernel/head_64.S&amp;lt;/code&amp;gt;에도 &amp;lt;code&amp;gt;startup_64&amp;lt;/code&amp;gt;가 있으므로, 함수 이름만으로 부팅 위치를 판단하면 안 된다.&amp;lt;ref name=&amp;quot;compressed-head&amp;quot;&amp;gt;[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/x86/boot/compressed/head_64.S?h=v6.12 Linux v6.12, arch/x86/boot/compressed/head_64.S]. &amp;lt;code&amp;gt;startup_32&amp;lt;/code&amp;gt;의 진입 조건과 초기 GDT 교체를 확인할 수 있다.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== GRUB의 커널 파일 해석 ==&lt;br /&gt;
GRUB 메뉴의 항목은 대략 다음과 같은 명령으로 커널과 초기 RAM 파일 시스템 이미지를 지정한다. 경로와 &amp;lt;code&amp;gt;root=&amp;lt;/code&amp;gt; 값은 설치 환경에 따라 다르다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
linux  /boot/vmlinuz-6.12 root=UUID=... ro&lt;br /&gt;
initrd /boot/initramfs-6.12.img&lt;br /&gt;
boot&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
여기서 &amp;lt;code&amp;gt;linux&amp;lt;/code&amp;gt;는 파일을 불러오고 나중에 실행할 부팅 함수를 등록한다. &amp;lt;code&amp;gt;initrd&amp;lt;/code&amp;gt;로 추가 데이터를 읽은 뒤 &amp;lt;code&amp;gt;boot&amp;lt;/code&amp;gt;가 실제 인계를 수행한다. GRUB 2.12의 대응 구현은 &amp;lt;code&amp;gt;grub_cmd_linux()&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;grub_cmd_initrd()&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;grub_linux_boot()&amp;lt;/code&amp;gt;이다.&amp;lt;ref name=&amp;quot;grub-linux&amp;quot;&amp;gt;[https://git.savannah.gnu.org/cgit/grub.git/tree/grub-core/loader/i386/linux.c?h=grub-2.12 GNU GRUB 2.12, grub-core/loader/i386/linux.c]. 이 문서에서는 BIOS 빌드에 해당하는 분기만 추적한다.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
bzImage의 앞부분에는 부팅용 헤더와 setup 영역이 있고, 그 뒤에는 압축 해제 실행 코드와 압축된 커널을 포함하는 보호 모드 부분이 있다. GRUB는 먼저 헤더의 서명과 지원 규약을 검사하고, &amp;lt;code&amp;gt;setup_sects&amp;lt;/code&amp;gt;로 두 부분의 경계를 찾는다. 보호 모드 부분의 파일 오프셋은 &amp;lt;code&amp;gt;(setup_sects + 1) * 512&amp;lt;/code&amp;gt;이다. &amp;lt;code&amp;gt;setup_sects&amp;lt;/code&amp;gt;가 0이면 호환 규칙에 따라 4로 해석한다.&amp;lt;ref name=&amp;quot;boot-protocol&amp;quot;&amp;gt;[https://www.kernel.org/doc/html/v6.12/arch/x86/boot.html Linux v6.12, The Linux/x86 Boot Protocol]. 특히 Memory Layout, Loading The Rest of The Kernel, 32-bit Boot Protocol 절.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이 경로의 GRUB는 필요한 헤더 내용을 부팅 매개변수 구조체로 복사하고 보호 모드 부분을 적재한다. 이어서 32비트 진입점으로 직접 넘어간다. 이 과정에서는 &amp;lt;code&amp;gt;arch/x86/boot/header.S&amp;lt;/code&amp;gt;의 16비트 진입과 &amp;lt;code&amp;gt;arch/x86/boot/main.c&amp;lt;/code&amp;gt;를 거치지 않는다.&amp;lt;ref name=&amp;quot;grub-linux&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
GRUB는 헤더의 재배치 가능 여부, 정렬 조건, 선호 주소와 초기 실행 공간 크기를 읽어 메모리를 확보한다. 실제 선택한 위치에 맞춰 &amp;lt;code&amp;gt;code32_start&amp;lt;/code&amp;gt;도 조정한다. 여기까지는 압축된 이미지를 실행할 공간을 준비하는 단계이다. 압축 해제는 Linux가 수행한다.&amp;lt;ref name=&amp;quot;grub-linux&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;initrd&amp;lt;/code&amp;gt; 명령은 별도의 이미지를 메모리에 올리고 그 주소와 크기를 기록한다. 이름이 initrd여도 실제 내용은 initramfs일 수 있다. 부트로더 관점에서는 커널에 전달할 바이트 배열이며, 이를 해석하여 초기 루트 파일시스템으로 사용하는 일은 커널 쪽 일이다. 이 데이터가 &amp;lt;code&amp;gt;/init&amp;lt;/code&amp;gt; 파일로 이어지는 과정은 [[운영체제 기본/Linux/x86-64/BIOS 부팅/루트 파일시스템과 init 선택#init 실행을 위한 루트 파일시스템 준비|루트 파일시스템과 init 선택]]에서 다룬다.&lt;br /&gt;
&lt;br /&gt;
== boot_params와 부트 정보 전달 ==&lt;br /&gt;
GRUB는 커널 파일을 메모리에 적재하고, 커널이 그 메모리를 찾고 기계를 파악하는 데 필요한 정보도 함께 준비한다.&lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
! 전달 대상 !! GRUB 2.12에서 하는 일 !! 커널이 알아야 하는 이유&lt;br /&gt;
|-&lt;br /&gt;
| &amp;lt;code&amp;gt;boot_params&amp;lt;/code&amp;gt;&lt;br /&gt;
| 구조체를 0으로 초기화한 뒤 setup 헤더와 추가 정보를 채운다.&lt;br /&gt;
| 어느 부팅 규약과 환경에서 진입했는지 해석한다.&lt;br /&gt;
|-&lt;br /&gt;
| &amp;lt;code&amp;gt;cmd_line_ptr&amp;lt;/code&amp;gt;&lt;br /&gt;
| 커널 명령행 문자열을 별도 공간에 복사하고 주소를 기록한다.&lt;br /&gt;
| &amp;lt;code&amp;gt;root=&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;ro&amp;lt;/code&amp;gt; 등의 설정을 읽는다.&lt;br /&gt;
|-&lt;br /&gt;
| &amp;lt;code&amp;gt;ramdisk_image&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;ramdisk_size&amp;lt;/code&amp;gt;&lt;br /&gt;
| initrd 명령으로 적재한 이미지의 주소와 크기를 기록한다.&lt;br /&gt;
| 초기 RAM 파일 시스템 이미지의 위치를 찾는다.&lt;br /&gt;
|-&lt;br /&gt;
| 메모리 맵&lt;br /&gt;
| GRUB가 파악한 물리 메모리 구간을 부팅 정보에 옮긴다.&lt;br /&gt;
| 사용 가능한 RAM과 예약 구간을 구분한다.&lt;br /&gt;
|-&lt;br /&gt;
| 화면 정보&lt;br /&gt;
| 선택한 화면 상태를 부팅 정보에 반영한다.&lt;br /&gt;
| 커널의 초기 화면 출력을 준비한다.&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
GRUB 소스의 &amp;lt;code&amp;gt;linux_params&amp;lt;/code&amp;gt;는 준비 중인 정보이며, &amp;lt;code&amp;gt;grub_linux_boot()&amp;lt;/code&amp;gt;는 최종 배치할 공간을 확보하고 이를 복사한다. 같은 단계에서 명령행 주소와 메모리 맵도 마무리한다. &amp;lt;code&amp;gt;real_mode_target&amp;lt;/code&amp;gt;은 최종 부팅 정보가 놓일 주소를 가리키며, 마지막 분기는 &amp;lt;code&amp;gt;grub_relocator32_boot()&amp;lt;/code&amp;gt;이다.&amp;lt;ref name=&amp;quot;grub-linux&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 커널 인계 직전의 CPU 상태 ==&lt;br /&gt;
GDT의 디스크립터와 세그먼트 선택자가 주소 해석과 권한을 정하는 방식은 [[운영체제 기본/Linux/x86-64/BIOS 부팅/GDT와 LDT 초기화|GDT와 LDT 초기화]]에서 설명한다.&lt;br /&gt;
&lt;br /&gt;
부팅 규약은 데이터의 배치와 첫 명령을 실행할 CPU 상태를 정한다. 32비트 진입에 필요한 상태는 다음과 같다.&amp;lt;ref name=&amp;quot;boot-protocol&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
! 항목 !! 인계 시점의 조건&lt;br /&gt;
|-&lt;br /&gt;
| 실행 모드 || 32비트 보호 모드&lt;br /&gt;
|-&lt;br /&gt;
| 페이징 || 꺼짐&lt;br /&gt;
|-&lt;br /&gt;
| 인터럽트 || 비활성화&lt;br /&gt;
|-&lt;br /&gt;
| GDT || 코드 선택자 &amp;lt;code&amp;gt;0x10&amp;lt;/code&amp;gt;, 데이터 선택자 &amp;lt;code&amp;gt;0x18&amp;lt;/code&amp;gt;에 대응하는 평탄 세그먼트가 유효함&lt;br /&gt;
|-&lt;br /&gt;
| 세그먼트 레지스터 || &amp;lt;code&amp;gt;CS=0x10&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;DS=ES=SS=0x18&amp;lt;/code&amp;gt;&lt;br /&gt;
|-&lt;br /&gt;
| &amp;lt;code&amp;gt;ESI&amp;lt;/code&amp;gt; || &amp;lt;code&amp;gt;boot_params&amp;lt;/code&amp;gt;의 시작 주소&lt;br /&gt;
|-&lt;br /&gt;
| &amp;lt;code&amp;gt;EBP&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;EDI&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;EBX&amp;lt;/code&amp;gt; || 0&lt;br /&gt;
|-&lt;br /&gt;
| 실행 주소 || 적재된 보호 모드 부분의 32비트 진입점&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
이 조건을 실제로 만드는 GRUB 코드는 &amp;lt;code&amp;gt;grub-core/lib/i386/relocator32.S&amp;lt;/code&amp;gt;에 있다. 이 코드는 자신의 작은 GDT를 사용하고 데이터 세그먼트 레지스터를 설정한 뒤 준비된 레지스터 값을 복원한다. 마지막에는 코드 선택자 &amp;lt;code&amp;gt;0x10&amp;lt;/code&amp;gt;을 사용한 먼 점프로 커널 진입 주소에 도달한다. 이 임시 GDT는 커널이 첫 명령부터 부팅 규약에 맞는 주소 해석으로 실행되도록 한다.&amp;lt;ref name=&amp;quot;grub-relocator&amp;quot;&amp;gt;[https://git.savannah.gnu.org/cgit/grub.git/tree/grub-core/lib/i386/relocator32.S?h=grub-2.12 GNU GRUB 2.12, grub-core/lib/i386/relocator32.S]. 코드 및 데이터 디스크립터와 마지막 먼 점프를 확인할 수 있다.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;grub_linux_boot()&amp;lt;/code&amp;gt;는 &amp;lt;code&amp;gt;ESI&amp;lt;/code&amp;gt;뿐 아니라 &amp;lt;code&amp;gt;ESP&amp;lt;/code&amp;gt;에도 부팅 정보의 최종 주소를 넣는다. Linux의 &amp;lt;code&amp;gt;startup_32&amp;lt;/code&amp;gt;는 곧 &amp;lt;code&amp;gt;boot_params&amp;lt;/code&amp;gt; 안의 scratch 필드를 이용해 현재 적재 위치를 계산하고, 자신의 초기 부팅 스택을 설정한다.&amp;lt;ref name=&amp;quot;grub-linux&amp;quot; /&amp;gt;&amp;lt;ref name=&amp;quot;compressed-head&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== GRUB과 커널의 역할 분담 ==&lt;br /&gt;
GRUB가 진입점으로 점프하면 정상 부팅 흐름에서 제어권은 Linux로 넘어간다. 이후에는 GRUB의 함수를 호출하지 않지만, GRUB가 적재한 데이터는 계속 필요하다. 커널 이미지, 부팅 정보, 명령행, initrd는 커널이 읽어야 할 입력으로 남아 있다.&lt;br /&gt;
&lt;br /&gt;
Linux v6.12의 &amp;lt;code&amp;gt;compressed/head_64.S:startup_32&amp;lt;/code&amp;gt;는 방향 플래그와 인터럽트 상태를 정리하고 자신의 적재 위치를 계산한다. 이어서 자기 GDT를 &amp;lt;code&amp;gt;lgdt&amp;lt;/code&amp;gt;로 설치하고 세그먼트 레지스터와 스택을 다시 설정한다. 따라서 GRUB가 제공한 GDT와 Linux가 이후에 설치하는 GDT는 역할과 수명이 다르다. 전자는 진입 계약을 성립시키는 임시 기반이며, 후자는 Linux 자신의 실행을 준비하는 기반이다.&amp;lt;ref name=&amp;quot;compressed-head&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
64비트 모드 진입, 초기 페이지 테이블, 압축 해제와 최종 커널 진입이 이어진다. &amp;lt;code&amp;gt;start_kernel()&amp;lt;/code&amp;gt;은 그 뒤의 단계이다. 이후 과정은 다음 세 단계로 나뉜다.&lt;br /&gt;
&lt;br /&gt;
# GRUB에서 압축 해제 코드로: 이 문서에서 다룬 32비트 진입 계약.&lt;br /&gt;
# 압축 해제 코드 안에서 64비트 실행으로: 커널 자신의 초기 실행 환경 구성.&lt;br /&gt;
# 압축 해제 코드에서 압축이 풀린 커널로: 별도의 초기 어셈블리 진입과 C 초기화 준비.&lt;br /&gt;
&lt;br /&gt;
== linux와 linux16의 진입 경로 ==&lt;br /&gt;
BIOS용 GRUB에는 &amp;lt;code&amp;gt;linux16&amp;lt;/code&amp;gt;과 &amp;lt;code&amp;gt;initrd16&amp;lt;/code&amp;gt;도 있다. 이 경로는 Linux의 16비트 setup에 진입하며, setup이 BIOS 기반 초기 작업과 보호 모드 전환을 수행한다. 16비트 setup의 실행 여부는 BIOS 부팅 여부가 아니라 선택한 명령에 따라 달라진다.&amp;lt;ref name=&amp;quot;grub-manual&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
64비트 모드 전환과 압축 해제는 [[운영체제 기본/Linux/x86-64/BIOS 부팅/진입 규약과 압축 해제|다음 장]]으로 이어진다.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|목차=[[운영체제 기본/Linux/x86-64/BIOS 부팅|BIOS 부팅 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/Linux/x86-64/BIOS 부팅/진입 규약과 압축 해제|진입 규약과 압축 해제]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/%EB%B3%B4%ED%98%B8&amp;diff=678</id>
		<title>운영체제 기본/보호</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/%EB%B3%B4%ED%98%B8&amp;diff=678"/>
		<updated>2026-11-15T06:05:12Z</updated>

		<summary type="html">&lt;p&gt;관리자: 과도한 강조와 반복적인 부정 대조를 간결한 설명으로 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/추상화|추상화]]&lt;br /&gt;
|목차=[[운영체제 기본#총론|총론 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/장치 제어와 입출력|장치 제어와 입출력]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
== 프로그램 오류와 보호의 필요성 ==&lt;br /&gt;
메모리 보호가 없는 산업용 기기에서 계산기 프로그램과 GPIO 핀에 PWM 모터를 물려 제어를 하는 모터 제어 프로그램이 함께 실행된다고 생각해 보자. 기본적으로 계산기 프로그램은 계산 결과를 자신의 버퍼에 저장하는 역할을 하므로 모터를 제어할 이유가 하나도 없다. 그런데 계산기 프로그램이 취약하여 결과를 저장할 주소가 공격자에 의해 악의적으로 변조되어 버퍼의 주소가 아니라 GPIO 주소가 들어가면 무슨 일이 일어날까?&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
#define GPIO_OUT1_REG 0x3FF44010&lt;br /&gt;
&lt;br /&gt;
// Usage: add(1, 2, &amp;amp;buffer)&lt;br /&gt;
void add(uint32_t a, uint32_t b, volatile uint32_t *result)&lt;br /&gt;
{&lt;br /&gt;
    *result = a + b;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
정상 작동 시                   악의적으로 작동하는 경우&lt;br /&gt;
add(a, b, &amp;amp;buffer)             add(a, b, (volatile uint32_t *)GPIO_OUT1_REG)&lt;br /&gt;
        |                              |&lt;br /&gt;
        +---- 같은 *result = a + b ----+&lt;br /&gt;
        |                              |&lt;br /&gt;
  계산기의 결과 버퍼              PWM 제어 레지스터&lt;br /&gt;
        |                              |&lt;br /&gt;
   계산 결과 보관                 모터 구동 신호 변경?&lt;br /&gt;
                                       |&lt;br /&gt;
                                 예기치 않은 기계 동작??&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
계산값이 모터 제어값으로 쓰이면 기계가 예기치 못한 방식으로 움직이고, 경우에 따라 사람이 다치는 결과를 초래할 수도 있다. 정작 문제를 일으킨 계산기 프로그램은 모터 제어와는 원래 아무 관련이 없었는데도 말이다.&lt;br /&gt;
마찬가지로 잘못된 주소가 운영체제 코드가 있는 RAM이라면 시스템이 멈출 수도 있으며 다른 프로그램의 주소라면 그 프로그램의 동작이나 데이터를 변조할 수도 있다. 이런 문제를 막으려면 프로그램이 접근할 수 있는 영역을 그 프로그램이 본래 사용할 수 있는 영역으로 제한해야 한다. 이것이 보호가 필요한 이유다.&lt;br /&gt;
&lt;br /&gt;
== 실행 권한, 주소, 자원의 경계 ==&lt;br /&gt;
커널(Kernel)은 CPU, 메모리, 장치의 사용을 관리하고 프로그램의 요청을 처리하는 운영체제의 핵심 코드다. 커널 코드와 그 관리 정보도 메모리에 있으므로 일반 프로그램이 마음대로 수정하지 못하게 해야 한다.&lt;br /&gt;
&lt;br /&gt;
일반 프로그램의 명령은 CPU에서 직접 실행된다. 운영체제가 그 사이에 끼어들어 명령 하나, 메모리 접근 하나마다 소프트웨어로 권한을 검사하면 실행 비용이 지나치게 커진다. 운영체제는 허용 범위와 권한을 설정하고, CPU가 실행 중 그 규칙을 검사한다. 정상적인 연산은 직접 실행하고, 허용되지 않거나 추가 처리가 필요한 동작에서만 커널로 제어를 넘긴다.&amp;lt;ref name=&amp;quot;source-2&amp;quot;&amp;gt;[https://mit-pdos.github.io/xv6-riscv-book/first.html MIT xv6: Operating system organization], 사용자 모드, 커널 모드와 하드웨어 격리.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
CPU의 권한 모드 (Privilege Mode)는 일반 프로그램과 커널이 실행할 수 있는 명령 및 접근 가능한 제어 상태를 구분한다. x86-64에서는 보통 사용자 프로그램을 현재 특권 수준(Current Privilege Level, CPL) 3, 커널을 CPL 0에서 실행한다. RISC-V RV64의 일반적인 운영체제 구성에서는 사용자 프로그램이 U-mode, 커널이 S-mode를 사용한다. 이름과 단계는 다르지만, 사용자 코드가 시스템 전체의 규칙을 임의로 바꾸지 못하게 한다는 목적은 같다.&lt;br /&gt;
&lt;br /&gt;
메모리 접근에서는 MMU (Memory Management Unit, 메모리 관리 장치)가 운영체제를 돕는다. MMU는 가상 주소를 물리 주소로 바꾸고 접근 권한을 검사하는 하드웨어다. 어느 주소를 연결하고 읽기, 쓰기, 실행을 어디까지 허용할지는 운영체제가 주소 연결표인 페이지 테이블에 설정한다. MMU는 그 설정을 메모리 접근마다 적용한다. 허용 범위를 벗어난 주소를 계산해 접근하면 MMU의 검사에서 차단된다.&amp;lt;ref name=&amp;quot;page-protection&amp;quot;&amp;gt;[https://docs.kernel.org/mm/page_tables.html Linux 커널 문서: Page Tables], 주소 변환과 페이지 접근 권한.&amp;lt;/ref&amp;gt; 페이지 테이블과 변환 결과를 캐시하는 TLB는 [[운영체제 기본/가상 메모리#페이지 테이블과 주소 변환|가상 메모리]]에서 이어서 설명한다.&lt;br /&gt;
&lt;br /&gt;
검사에 쓰이는 설정도 보호해야 한다. 사용자 프로그램이 페이지 테이블을 바꾸거나 다른 페이지 테이블을 선택할 수 있다면 MMU가 적용하는 규칙 자체를 고칠 수 있기 때문이다. 페이지 테이블을 담은 메모리의 보호와, 주소 변환을 제어하는 레지스터의 접근 제한이 함께 필요하다.&amp;lt;ref name=&amp;quot;source-1&amp;quot;&amp;gt;[https://web.mit.edu/saltzer/www/publications/protection/Basic.html Jerome H. Saltzer, Michael D. Schroeder, The Protection of Information in Computer Systems (1975), I].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 특권 명령과 장치 접근 ==&lt;br /&gt;
특권 명령 (Privileged Instruction)은 CPU의 현재 권한에 따라 실행이 제한되는 명령이다. 사용자 프로그램이 CPU를 멈추거나 예외 처리와 메모리 보호에 필요한 제어 상태를 마음대로 바꾸면 다른 프로그램과 커널도 영향을 받는다. CPU는 이를 실행하기 전에 필요한 권한이 있는지 검사한다.&lt;br /&gt;
&lt;br /&gt;
* x86-64: CPU를 정지 상태로 만드는 &amp;lt;code&amp;gt;HLT&amp;lt;/code&amp;gt;를 CPL 3에서 실행하면 일반 보호 예외 &amp;lt;code&amp;gt;#GP&amp;lt;/code&amp;gt;가 발생한다. 명령 자체가 존재하지 않는 경우의 잘못된 명령 예외 &amp;lt;code&amp;gt;#UD&amp;lt;/code&amp;gt;와 구별된다.&amp;lt;ref name=&amp;quot;intel-hlt&amp;quot;&amp;gt;Intel, [https://cdrdv2-public.intel.com/812383/253666-sdm-vol-2a.pdf Intel 64 and IA-32 Architectures Software Developer&#039;s Manual, Volume 2A], HLT, Protected Mode Exceptions.&amp;lt;/ref&amp;gt;&lt;br /&gt;
* RISC-V RV64: U-mode 프로그램이 &amp;lt;code&amp;gt;mstatus&amp;lt;/code&amp;gt;처럼 더 높은 권한을 요구하는 제어, 상태 레지스터 (Control and Status Register, CSR)에 접근하면 불법 명령 예외 (Illegal Instruction Exception)가 발생한다. CSR마다 필요한 접근 권한이 정해져 있다.&amp;lt;ref name=&amp;quot;riscv-csr&amp;quot;&amp;gt;[https://docs.riscv.org/reference/isa/priv/priv-csrs.html RISC-V Privileged Architecture: Control and Status Registers], CSR 접근 권한과 불법 명령 예외.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
커널은 시스템 전체의 장치 사용을 조정한다. 응용 프로그램의 요청을 검증하고 허용된 동작을 장치에 수행한다. 커널과 드라이버는 요청한 값과 범위, 장치의 상태와 제어 순서, 다른 작업과의 충돌을 확인한다. 응용 프로그램은 정해진 요청 경로로 장치를 사용하며, 필요하면 운영체제가 지정한 일부 장치 영역에 직접 접근할 권한을 받을 수도 있다.&amp;lt;ref name=&amp;quot;source-2&amp;quot;/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
CPU는 명령과 주소의 접근 권한을 검사한다. 장치에 어떤 값을 어떤 순서로 쓸지는 커널과 드라이버가 판단하므로, 이 코드에 오류가 있으면 권한 검사만으로 잘못된 장치 조작을 막기 어렵다.&lt;br /&gt;
&lt;br /&gt;
장치에 직접 명령을 내리는 경로도 제한해야 한다. x86의 포트 입출력 &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;은 CPU가 I/O 권한 수준(I/O Privilege Level, IOPL)과 필요한 경우 태스크 상태 세그먼트(Task State Segment, TSS)에 연결된 포트별 허용 비트맵을 검사하며, 허용되지 않은 접근은 &amp;lt;code&amp;gt;#GP&amp;lt;/code&amp;gt;로 막는다. 운영체제는 이 설정으로 사용자 프로그램의 포트 접근을 허용하거나 제한할 수 있다.&amp;lt;ref name=&amp;quot;intel-exception&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
메모리 매핑 입출력 (Memory-Mapped I/O, MMIO)은 장치 레지스터를 주소로 접근한다. 운영체제가 사용자 주소 공간에 해당 장치 영역을 매핑하지 않거나 필요한 권한을 주지 않으면 일반 프로그램은 그 경로로 장치를 제어할 수 없다. 허용된 일부 영역만 매핑해 주는 구성도 가능하다. 포트 입출력과 MMIO의 차이는 [[운영체제 기본/장치 제어와 입출력|장치 제어와 입출력]], 구체적인 매핑은 [[운영체제 기본/Linux/메모리 매핑/MMIO 장치 매핑|MMIO 장치 매핑]]으로 이어진다.&lt;br /&gt;
&lt;br /&gt;
== 보호 위반과 예외 ==&lt;br /&gt;
CPU가 명령어를 실행하다가 별도의 처리가 필요한 조건을 발견하여 정해진 처리 코드로 제어를 넘기는 일을 예외 (Exception)라고 한다. 허용되지 않은 메모리 접근과 특권 명령 실행은 모두 실행 중인 명령에 따라 동기적으로 발생하는 예외의 원인이 될 수 있다. 장치가 현재 명령어와 무관하게 보내는 하드웨어 인터럽트와 구별된다.&amp;lt;ref name=&amp;quot;intel-exception&amp;quot;&amp;gt;Intel, [https://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-developer-vol-3a-part-1-manual.pdf Intel 64 and IA-32 Architectures Software Developer&#039;s Manual, Volume 3A], 예외 처리, 특권 수준 및 I/O 보호.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
x86에서 페이지 매핑이 없거나 페이지 접근 권한을 위반하면 페이지 폴트 (Page Fault, #PF)가 발생한다. 일반 데이터 접근의 주소 형태가 x86-64의 규칙에 맞지 않는 경우나 앞에서 본 &amp;lt;code&amp;gt;HLT&amp;lt;/code&amp;gt; 권한 위반은 일반 보호 예외 (General-Protection Exception, #GP)의 원인이 된다.&amp;lt;ref name=&amp;quot;intel-exception&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
x86에서는 CPU가 #PF의 벡터 14 또는 #GP의 벡터 13으로 인터럽트 서술자 테이블 (Interrupt Descriptor Table, IDT)의 게이트를 선택하고 커널 진입 코드로 제어를 넘긴다. RV64에서는 IDT 대신 트랩 벡터와 원인 레지스터를 사용한다. 사용자 프로그램의 트랩을 S-mode 커널이 받는 구성에서는 &amp;lt;code&amp;gt;stvec&amp;lt;/code&amp;gt;으로 진입하고 &amp;lt;code&amp;gt;scause&amp;lt;/code&amp;gt; 등에서 원인을 확인한다. 구체적인 진입 방식이 달라도, 하드웨어가 원인을 알리고 운영체제가 처리하는 경계는 같다.&amp;lt;ref name=&amp;quot;riscv-trap&amp;quot;&amp;gt;[https://docs.riscv.org/reference/isa/priv/supervisor.html RISC-V Privileged Architecture: Supervisor-Level ISA], stvec, scause와 예외 처리.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
운영체제: 권한 모드, 페이지 테이블, I/O 권한 설정&lt;br /&gt;
                         |&lt;br /&gt;
                         v&lt;br /&gt;
사용자 명령 실행 -&amp;gt; CPU/MMU가 설정된 권한 검사&lt;br /&gt;
                         |&lt;br /&gt;
             +-----------+-----------+&lt;br /&gt;
             |                       |&lt;br /&gt;
          허용된 동작             권한 위반 등&lt;br /&gt;
             |                       |&lt;br /&gt;
          직접 실행              예외 -&amp;gt; 커널 처리&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
예외를 받았다고 곧바로 프로그램을 종료하지는 않는다. 유효한 주소인데 필요한 페이지가 아직 준비되지 않았거나, 쓰기 시 복사 때문에 쓰기 권한을 잠시 막아 둔 경우에는 커널이 매핑을 고치고 명령을 다시 실행할 수 있다. 자세한 복구 과정은 [[운영체제 기본/가상 메모리#페이지 폴트의 처리|페이지 폴트의 처리]]에서 다룬다.&lt;br /&gt;
&lt;br /&gt;
반대로 허용되지 않은 사용자 접근을 복구할 수 없다면 운영체제는 프로그램에 오류를 통지한다. Linux에서는 잘못된 메모리 접근에 &amp;lt;code&amp;gt;SIGSEGV&amp;lt;/code&amp;gt; 같은 시그널 (Signal)을 보낼 수 있으며, 기본 처리에 따르면 프로세스가 종료된다. 운영체제의 예외 처리 코드가 아키텍처별 규칙에 따라 보낼 시그널을 정한다.&amp;lt;ref name=&amp;quot;signal-overview&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man7/signal.7.html Linux man-pages: signal(7)], signal dispositions 및 hardware exception에서 발생하는 시그널.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
시그널은 종료 요청이나 자식 프로세스의 상태 변화도 알린다. 발생, 전달, 처리와 다른 통신 방식의 관계는 [[운영체제 기본/프로세스 간 통신#시그널과 사건 통지|프로세스 간 통신]]에서 설명한다. IDT를 통한 진입과 복귀는 [[운영체제 기본/장치 제어와 입출력#처리 진입점과 IDT|장치 제어와 입출력의 IDT 절]]로 이어진다.&lt;br /&gt;
&lt;br /&gt;
== 시스템 콜과 요청 검증 ==&lt;br /&gt;
격리된 프로그램도 파일을 읽고 다른 프로그램과 통신해야 한다. 시스템 콜(System Call)은 프로그램이 정해진 진입점을 통해 커널에 작업을 요청하는 경로다. 하드웨어가 제어를 커널로 넘기면 커널 코드가 요청을 처리하고 결과를 돌려준다. 진입, 복귀 과정은 [[운영체제 기본/장치 제어와 입출력#진입, 상태 보존, 복귀|장치 제어와 입출력]]을 참조한다. 호출자는 요청할 작업과 인자를 고를 수 있지만 커널에서 실행할 임의의 명령을 지정할 수는 없다.&lt;br /&gt;
&lt;br /&gt;
예를 들어 데이터를 읽어 달라는 요청에는 결과를 저장할 사용자 주소와 최대 길이가 들어간다. 커널은 그 주소 범위가 사용자 공간에 속하고 요청한 방향으로 접근 가능한지 확인해야 한다. 주소와 길이를 합산할 때 정수 범위를 넘는 경우도 고려해야 한다. 호출자가 넘긴 숫자나 포인터를 신뢰하면 커널이 자신의 권한으로 금지된 접근을 대신 수행할 수 있다. &amp;lt;ref name=&amp;quot;source-3&amp;quot;&amp;gt;[https://mit-pdos.github.io/xv6-riscv-book/trap.html xv6: Traps and system calls].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
검사 시점과 사용 시점 사이의 변화도 문제다. 다른 스레드가 인자가 담긴 메모리를 바꿀 수 있다면, 검사한 내용과 실제 처리한 내용이 달라질 수 있다. 필요한 값을 커널의 관리 영역에 복사하거나, 대상의 수명을 유지하고 동기화하는 등 처리 과정 내내 가정이 유지되도록 만들어야 한다.&lt;br /&gt;
&lt;br /&gt;
== 격리와 협력의 비용 ==&lt;br /&gt;
경계를 넘을 때는 실행 상태를 보존하고 복원하며 인자와 권한을 확인하는 비용이 든다. 데이터를 복사해야 할 수도 있다. 요청을 바로 끝내면 같은 스레드가 사용자 모드로 돌아온다. 입출력 등을 기다려야 할 때는 컨텍스트 스위치(Context Switch)로 다른 스레드에 CPU를 넘길 수 있다.&lt;br /&gt;
&lt;br /&gt;
이미지 처리 기능을 별도 프로세스에 두면 그 기능의 잘못된 메모리 쓰기가 편집기의 메모리를 직접 훼손하는 일을 막을 수 있다. 대신 큰 이미지와 결과를 주고받는 통신 비용이 생긴다. [[운영체제 기본/프로세스 간 통신#공유 메모리와 동기화|공유 메모리]]로 복사를 줄이면 같은 영역에 대한 동기화와 접근 범위를 관리해야 한다. 경계를 나누는 단위와 데이터를 교환하는 방식은 함께 설계해야 한다.&lt;br /&gt;
&lt;br /&gt;
프로그램은 쓰기가 허용된 메모리 안에서도 계산과 [[운영체제 기본/동시성|동기화]]를 올바르게 수행해야 한다. 예를 들어 두 스레드가 같은 값을 동시에 갱신하면 접근 권한 위반 없이도 결과가 잘못될 수 있다.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/추상화|추상화]]&lt;br /&gt;
|목차=[[운영체제 기본#총론|총론 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/장치 제어와 입출력|장치 제어와 입출력]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/RCU&amp;diff=677</id>
		<title>운영체제 기본/Linux/RCU</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/RCU&amp;diff=677"/>
		<updated>2026-11-15T06:05:11Z</updated>

		<summary type="html">&lt;p&gt;관리자: 부자연스러운 문장과 구분 기호 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;[[운영체제 기본|운영체제 기본 목차]]&lt;br /&gt;
&lt;br /&gt;
RCU(Read-Copy Update)는 읽기가 많고 갱신이 드문 공유 자료구조에서 읽는 쪽의 동기화 부담을 줄이는 방법이다. 새 자료를 공개하는 시점과 이전 자료의 메모리를 회수하는 시점을 분리한다. 읽던 스레드는 이전 자료를 계속 사용할 수 있고, 갱신자는 그 읽기가 끝난 뒤에 이전 자료를 해제한다.&lt;br /&gt;
&lt;br /&gt;
Linux v6.12의 일반 RCU API와 Tree RCU를 다룬다. 내부 구현은 다중 CPU, &amp;lt;code&amp;gt;CONFIG_PREEMPT_RCU=y&amp;lt;/code&amp;gt;, 일반 유예 기간을 기준으로 한다. SRCU와 Tasks RCU, 신속 유예 기간은 여기서 다루지 않는다.&lt;br /&gt;
&lt;br /&gt;
== 관련 총론 ==&lt;br /&gt;
* [[운영체제 기본/동시성|동시성]]: 상호 배제, 메모리 순서와 RCU의 기본 목적.&lt;br /&gt;
* [[운영체제 기본/프로세스와 스레드|프로세스와 스레드]]: 실행 문맥과 선점, 컨텍스트 스위치.&lt;br /&gt;
&lt;br /&gt;
== 문서 순서 ==&lt;br /&gt;
# [[운영체제 기본/Linux/RCU/포인터 공개와 읽기 구간|포인터 공개와 읽기 구간]]: 자료를 초기화한 뒤 공개하고, 읽는 동안 수명을 보장하는 방법.&lt;br /&gt;
# [[운영체제 기본/Linux/RCU/갱신과 메모리 회수|갱신과 메모리 회수]]: 이전 자료를 분리한 뒤 유예 기간을 기다리는 이유와 동기 및 비동기 회수.&lt;br /&gt;
# [[운영체제 기본/Linux/RCU/Tree RCU와 유예 기간|Tree RCU와 유예 기간]]: 읽기 구간 추적, CPU별 상태와 트리, 콜백 실행 경로.&lt;br /&gt;
&lt;br /&gt;
갱신자 사이의 상호 배제와 공유 자료의 일관성 조건은 별도로 보장해야 한다.&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%ED%8C%8C%EC%9D%BC_%EC%8B%9C%EC%8A%A4%ED%85%9C_%EC%BD%9C&amp;diff=676</id>
		<title>운영체제 기본/Linux/파일 시스템 콜</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%ED%8C%8C%EC%9D%BC_%EC%8B%9C%EC%8A%A4%ED%85%9C_%EC%BD%9C&amp;diff=676"/>
		<updated>2026-11-15T06:05:09Z</updated>

		<summary type="html">&lt;p&gt;관리자: 문체 정리: 나열 표현 다듬기&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=&lt;br /&gt;
|목차=[[운영체제 기본|운영체제 기본 목차]]&lt;br /&gt;
|다음=&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
Linux v6.12의 파일 시스템 콜을 파일의 수명에 따라 살펴본다. 이름으로 파일을 열고, fd로 읽고 쓰며, 위치를 변경하고 닫는 과정은 VFS와 열린 파일 객체를 공유한다. 아키텍처별 진입은 x86-64와 RISC-V RV64로 비교한다.&lt;br /&gt;
&lt;br /&gt;
== 관련 총론 ==&lt;br /&gt;
* [[운영체제 기본/파일과 입출력|파일과 입출력]]: 경로, 열린 파일, 오프셋과 읽기 및 쓰기의 의미.&lt;br /&gt;
* [[운영체제 기본/보호|보호와 시스템 콜]]: 시스템 콜 진입과 사용자 인자 검증.&lt;br /&gt;
* [[운영체제 기본/프로세스와 스레드|프로세스와 스레드]]: 파일 디스크립터 테이블의 공유와 실행 상태.&lt;br /&gt;
&lt;br /&gt;
== 문서 구성 ==&lt;br /&gt;
# [[운영체제 기본/Linux/파일 시스템 콜/시스템 콜과 파일 디스크립터|시스템 콜과 파일 디스크립터]]: 사용자 ABI, fd 테이블, 열린 파일과 VFS의 공통 구조.&lt;br /&gt;
# [[운영체제 기본/Linux/파일 시스템 콜/openat과 경로 탐색|openat과 경로 탐색]]: 경로의 시작점, 이름 탐색, 파일 연산 연결과 fd 설치.&lt;br /&gt;
# [[운영체제 기본/Linux/파일 시스템 콜/read와 write|read와 write]]: 공통 검사와 대상별 콜백, 버퍼드 입출력, 부분 처리와 반환값.&lt;br /&gt;
# [[운영체제 기본/Linux/파일 시스템 콜/파일 오프셋과 열린 파일의 수명|파일 오프셋과 열린 파일의 수명]]: lseek, pread, pwrite, dup의 위치 공유, close와 fsync의 차이.&lt;br /&gt;
&lt;br /&gt;
[[운영체제 기본/Linux/파일시스템|Linux의 파일시스템]]은 VFS 객체, ext4, procfs와 페이지 캐시의 구현을, [[운영체제 기본/Linux/메모리 매핑|Linux의 메모리 매핑]]은 mmap으로 주소 공간을 구성하고 접근하는 경로를 다룬다.&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=&lt;br /&gt;
|목차=[[운영체제 기본|운영체제 기본 목차]]&lt;br /&gt;
|다음=&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%ED%8C%8C%EC%9D%BC%EC%8B%9C%EC%8A%A4%ED%85%9C&amp;diff=675</id>
		<title>운영체제 기본/Linux/파일시스템</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%ED%8C%8C%EC%9D%BC%EC%8B%9C%EC%8A%A4%ED%85%9C&amp;diff=675"/>
		<updated>2026-11-15T06:04:54Z</updated>

		<summary type="html">&lt;p&gt;관리자: 불필요한 굵은 글씨와 문장 내 구분 기호 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=&lt;br /&gt;
|목차=[[운영체제 기본|운영체제 기본 목차]]&lt;br /&gt;
|다음=&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
Linux는 서로 다른 파일시스템을 VFS의 공통 객체와 연산으로 연결한다. ext4의 저장된 파일, procfs가 만들어 내는 커널 상태, 일반 파일 읽기와 메모리 매핑이 사용하는 페이지 캐시를 나누어 살펴본다. 기준은 Linux v6.12다.&lt;br /&gt;
&lt;br /&gt;
== 관련 총론 ==&lt;br /&gt;
* [[운영체제 기본/파일과 입출력|파일과 입출력]]: 파일, 경로, 열린 상태와 저장장치 데이터의 관계.&lt;br /&gt;
* [[운영체제 기본/가상 메모리|가상 메모리]]: 파일 페이지의 매핑과 페이지 공유.&lt;br /&gt;
&lt;br /&gt;
== 문서 구성 ==&lt;br /&gt;
# [[운영체제 기본/Linux/파일시스템/VFS와 파일 객체|VFS와 파일 객체]]: 경로 탐색과 열린 파일이 실제 연산 구현으로 연결되는 과정.&lt;br /&gt;
# [[운영체제 기본/Linux/파일시스템/ext4의 파일 읽기|ext4의 파일 읽기]]: 공통 읽기 계층에서 ext4의 블록 매핑과 저장장치까지.&lt;br /&gt;
# [[운영체제 기본/Linux/파일시스템/procfs의 파일 읽기|procfs의 파일 읽기]]: /proc/uptime이 커널 상태에서 읽을 내용을 만드는 과정.&lt;br /&gt;
# [[운영체제 기본/Linux/파일시스템/페이지 캐시|페이지 캐시]]: read()와 파일 매핑이 공통 파일 데이터를 사용하는 관계.&lt;br /&gt;
&lt;br /&gt;
== 관련 각론 ==&lt;br /&gt;
* [[운영체제 기본/Linux/파일 시스템 콜/read와 write|read()를 통한 파일 읽기]]&lt;br /&gt;
* [[운영체제 기본/Linux/메모리 매핑/파일 매핑과 COW|mmap을 통한 파일 읽기]]&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=&lt;br /&gt;
|목차=[[운영체제 기본|운영체제 기본 목차]]&lt;br /&gt;
|다음=&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/i8042_%ED%82%A4%EB%B3%B4%EB%93%9C_%EC%9E%85%EB%A0%A5&amp;diff=674</id>
		<title>운영체제 기본/Linux/x86-64/i8042 키보드 입력</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/x86-64/i8042_%ED%82%A4%EB%B3%B4%EB%93%9C_%EC%9E%85%EB%A0%A5&amp;diff=674"/>
		<updated>2026-11-15T06:04:40Z</updated>

		<summary type="html">&lt;p&gt;관리자: 과도한 강조와 반복 설명 정리, 흐름도 기호를 ASCII로 통일&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=&lt;br /&gt;
|목차=[[운영체제 기본|운영체제 기본 목차]]&lt;br /&gt;
|다음=&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
Linux v6.12, x86-64, i8042에 연결된 PS/2 키보드를 기준으로 키 입력이 사용자 프로세스에 도착하는 경로를 추적한다. IRQ 진입은 일반적인 IDT 경로를 다루며, USB 키보드와 FRED 진입 경로는 구분한다.&lt;br /&gt;
&lt;br /&gt;
== 관련 총론 ==&lt;br /&gt;
* [[운영체제 기본/장치 제어와 입출력|장치 제어와 입출력]]: IRQ 통지와 처리 진입점, 장치 접근.&lt;br /&gt;
* [[운영체제 기본/프로세스와 스레드|프로세스와 스레드]]: 입력 대기와 깨우기, 실제 실행 시점의 구분.&lt;br /&gt;
* [[운영체제 기본/파일과 입출력|파일과 입출력]]: 파일 인터페이스를 통한 입력과 버퍼링.&lt;br /&gt;
&lt;br /&gt;
== 문서 구성 ==&lt;br /&gt;
# [[운영체제 기본/Linux/x86-64/i8042 키보드 입력/IRQ 진입과 디스패치|IRQ 진입과 디스패치]]: CPU가 인터럽트를 받아 등록된 장치 처리기를 실행하는 과정.&lt;br /&gt;
# [[운영체제 기본/Linux/x86-64/i8042 키보드 입력/i8042와 입력 이벤트|i8042와 입력 이벤트]]: 수신 바이트가 스캔 코드와 Linux 키 이벤트로 바뀌는 과정.&lt;br /&gt;
# [[운영체제 기본/Linux/x86-64/i8042 키보드 입력/evdev의 이벤트 전달과 대기 해제|evdev의 이벤트 전달과 대기 해제]]: 이벤트를 버퍼에 넣고 대기 중인 read를 깨우는 과정.&lt;br /&gt;
# [[운영체제 기본/Linux/x86-64/i8042 키보드 입력/콘솔과 터미널 입력|콘솔과 터미널 입력]]: 가상 콘솔에서 키 이벤트가 문자와 터미널 입력으로 바뀌는 경로.&lt;br /&gt;
&lt;br /&gt;
input 계층 이후에는 evdev와 가상 콘솔 경로로 나뉜다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
i8042 -&amp;gt; IRQ 처리 -&amp;gt; serio/PS2 -&amp;gt; atkbd -&amp;gt; input 계층&lt;br /&gt;
                                      |&lt;br /&gt;
                                      +-&amp;gt; evdev -&amp;gt; 입력 이벤트를 읽는 프로세스&lt;br /&gt;
                                      |&lt;br /&gt;
                                      +-&amp;gt; 콘솔 키보드 처리 -&amp;gt; tty -&amp;gt; 문자를 읽는 프로세스&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
키보드가 보낸 스캔 코드, Linux 키 코드, 문자 데이터는 서로 다르다. 또한 입력 도착, 대기 중인 작업의 깨우기, 스케줄러의 선택, 사용자 버퍼로의 복사는 각각 다른 단계다.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=&lt;br /&gt;
|목차=[[운영체제 기본|운영체제 기본 목차]]&lt;br /&gt;
|다음=&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/%EC%B6%94%EC%83%81%ED%99%94&amp;diff=673</id>
		<title>운영체제 기본/추상화</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/%EC%B6%94%EC%83%81%ED%99%94&amp;diff=673"/>
		<updated>2026-11-15T06:04:34Z</updated>

		<summary type="html">&lt;p&gt;관리자: 불필요한 강조와 대조 표현, 특수문자 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/서문|서문]]&lt;br /&gt;
|목차=[[운영체제 기본#총론|총론 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/보호|보호와 시스템 콜]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
== DOS의 하드웨어 의존성과 자원 공유 ==&lt;br /&gt;
DOS 게임에서는 사운드 카드와 [[운영체제 기본/장치 제어와 입출력#비동기 사건과 인터럽트|인터럽트 요청(IRQ)]] 번호와 직접 메모리 전송(DMA) 설정을 게임마다 맞춰야 했고, DOOM의 배포 문서도 설정 오류와 장치 간 충돌을 안내했다.&amp;lt;ref name=&amp;quot;source-1&amp;quot;&amp;gt;[https://www.doomclassic.com/doominfo.htm id Software, DOOM v1.8 README 원문 보존본].&amp;lt;/ref&amp;gt; 장치를 직접 제어하면 성능과 기능을 활용하기 쉬웠지만, 하드웨어 차이를 게임이 떠안아야 했다. DOS에도 파일 서비스와 BIOS 인터페이스는 있었으나, 일반적인 단독 실행 환경은 게임 둘의 CPU 시간과 메모리와 장치 사용을 독립적으로 관리하지 않았다. 실행 순서만 번갈아 바꿔도 한 게임이 다른 게임의 메모리나 화면과 장치 설정을 훼손할 수 있었다. 여러 프로그램을 안정적으로 함께 실행하려면 각자에게 실행 환경을 제공하고 실제 하드웨어의 공유를 중재해야 한다.&amp;lt;ref name=&amp;quot;source-2&amp;quot;&amp;gt;[https://msarchive.pcjs.org/mspl13/msdos/advdos/ Ray Duncan, Advanced MS-DOS Programming (1988)], 2, 6, 16장.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 자원과 공통 인터페이스 ==&lt;br /&gt;
운영체제가 관리하는 자원을 프로그램이 사용할 대상과 연산으로 나타내는 것이 추상화(Abstraction)다. 예를 들어 저장장치의 어느 영역을 차지할지 프로그램마다 직접 정하게 하면 같은 위치를 덮어쓸 수 있다. 운영체제가 이름과 내용을 가진 파일을 제공하고 실제 저장 위치를 관리하면, 프로그램은 파일을 읽고 쓰는 연산을 요청하고 운영체제는 실제 저장 위치와 입출력 처리를 관리할 수 있다. 장치가 달라져도 프로그램이 의존하는 연산의 의미는 유지할 수 있다.&amp;lt;ref name=&amp;quot;os-roles&amp;quot;&amp;gt;MIT PDOS, [https://mit-pdos.github.io/xv6-riscv-book/first.html xv6: Operating system organization], 2.1. 자원 공유, 격리, 상호작용과 물리 자원의 추상화.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
따라서 추상화는 복잡한 하드웨어를 편하게 사용하는 수단이면서, 운영체제가 자원을 조정할 지점이기도 하다. 프로그램이 사용할 대상과 연산을 정하고 실제 자원에 연결하는 책임을 운영체제가 맡는다. CPU의 실행, 메모리, 입출력에 이 원리를 적용하면 각 프로그램에 독립적인 실행 환경을 제공할 수 있다.&lt;br /&gt;
&lt;br /&gt;
== 프로세스의 실행 환경 ==&lt;br /&gt;
프로그램이 실행되려면 명령을 진행할 CPU, 데이터를 둘 메모리, 파일과 장치에 접근할 경로가 필요하다. 운영체제는 이들을 각각 추상화한 뒤 프로세스라는 실행 환경으로 묶는다. 프로그램은 물리 CPU의 배정과 RAM의 실제 배치를 직접 관리하는 대신 자기 실행 흐름과 주소 공간, 열린 자원을 사용한다.&amp;lt;ref name=&amp;quot;os-roles&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
프로세스: 프로그램에 제공하는 논리적인 머신&lt;br /&gt;
  |&lt;br /&gt;
  +-- 실행: 하나 이상의 스레드        &amp;lt;- CPU의 명령 실행&lt;br /&gt;
  +-- 메모리: 가상 주소 공간          &amp;lt;- RAM과 주소 변환&lt;br /&gt;
  +-- 입출력: 열린 객체에 대한 참조    &amp;lt;- 파일시스템과 장치&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[운영체제 기본/프로세스와 스레드|스레드]]는 CPU의 실행 흐름을 추상화한다. 실행 위치와 레지스터, 스택을 유지하므로 물리 CPU를 다른 스레드에 넘겼다가도 자기 작업을 이어갈 수 있다. [[운영체제 기본/가상 메모리|가상 주소 공간]]은 메모리를 추상화한다. 프로그램의 주소는 유지하면서 실제 RAM의 배치와 접근 권한을 따로 관리한다.&lt;br /&gt;
&lt;br /&gt;
[[운영체제 기본/파일과 입출력|파일과 입출력 객체]]는 디스크와 장치에 대한 접근을 추상화한다. 프로세스에는 열린 대상의 참조와 사용 상태가 연결된다. 여러 프로세스의 참조가 같은 파일이나 장치 객체를 가리킬 수도 있다.&amp;lt;ref name=&amp;quot;file-abstraction&amp;quot;&amp;gt;[https://mit-pdos.github.io/xv6-riscv-book/fs.html MIT PDOS, xv6: File system], 파일 계층과 열린 파일.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이 구성에서 프로세스는 자원과 보호 경계를 묶고, 스레드는 그 안에서 실행을 진행한다. 같은 프로세스의 스레드는 주소 공간과 열린 파일을 공유한다. 각 스레드의 스택도 그 주소 공간 안에 있으므로 다른 스레드가 접근할 수 있다.&amp;lt;ref name=&amp;quot;thread-sharing&amp;quot;&amp;gt;[https://man7.org/linux/man-pages/man7/pthreads.7.html pthreads(7)], 프로세스 안에서 공유하는 자원.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
이 실행 환경들은 CPU 시간과 RAM, 장치의 처리 능력을 나누어 쓴다. 운영체제는 컨텍스트 스위치(Context Switch), 주소 변환, 자원 참조 관리에 비용을 들여 이 환경을 유지한다. 별도 커널을 실행하거나 하드웨어 전체를 재현하는 가상 머신과도 구별된다.&lt;br /&gt;
&lt;br /&gt;
== 인터페이스와 간접 참조 ==&lt;br /&gt;
자원을 추상화하려면 사용할 대상, 허용된 연산, 연산의 결과를 정하고 내부 구현과 분리해야 한다. 파일 인터페이스라면 데이터를 읽는 방법뿐 아니라 실제로 읽은 양과 실패를 알리는 방법도 약속에 포함한다. 같은 연산을 호출한 프로그램이 기대할 수 있는 결과를 정하는 것이다.&lt;br /&gt;
&lt;br /&gt;
이를 만드는 대표적인 수단이 간접 참조다. 프로그램이 다루는 이름이나 번호를 실제 대상에 연결하는 정보를 운영체제가 관리한다. Unix 계열의 파일 디스크립터는 그 예다. 프로그램은 열린 대상을 나타내는 번호를 전달하고, 운영체제가 그 대상에 맞는 처리를 선택한다. 번호 자체에 장치의 물리적 위치를 담을 필요가 없다.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
프로그램: 열린 대상에 읽기 요청&lt;br /&gt;
                  |&lt;br /&gt;
운영체제: 대상 확인과 연산 선택&lt;br /&gt;
                  |&lt;br /&gt;
          +-------+-------+&lt;br /&gt;
          |               |&lt;br /&gt;
      파일의 내용     파이프의 데이터&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
간접 참조의 연결 정보와 처리 코드는 운영체제가 관리한다. 프로그램이 이 정보를 마음대로 덮어쓰거나 장치를 직접 제어하면 공통 인터페이스를 거치도록 만든 구조가 무너진다. 운영체제의 메모리와 CPU와 장치 제어 상태를 사용자 프로그램으로부터 분리하는 데에는 [[운영체제 기본/보호|하드웨어 보호]]의 도움이 필요하다. 파일 이름과 읽기와 쓰기 요청의 의미는 운영체제 소프트웨어가 해석하고, 하드웨어는 그 코드를 안전하게 실행할 경계를 제공한다.&lt;br /&gt;
&lt;br /&gt;
== 공통 인터페이스의 이점과 비용 ==&lt;br /&gt;
파일과 프로그램 사이의 바이트 전달 통로인 파이프에서 같은 읽기 연산을 제공하면, 입력을 처리하는 프로그램을 저장된 데이터와 다른 프로그램의 출력에 재사용할 수 있다. 대상에 따라 지원하는 연산은 다르다. 예를 들어 파이프는 저장된 파일처럼 읽기 위치를 바꿀 수 없다. 인터페이스는 공통점을 제공하면서 지원하지 않는 연산과 오류도 드러내야 한다. &amp;lt;ref name=&amp;quot;source-4&amp;quot;&amp;gt;[https://pubs.opengroup.org/onlinepubs/9799919799/functions/read.html POSIX read()].&amp;lt;/ref&amp;gt;&amp;lt;ref name=&amp;quot;source-5&amp;quot;&amp;gt;[https://pubs.opengroup.org/onlinepubs/9799919799/functions/lseek.html POSIX lseek()].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
공통 인터페이스에 없는 장치 고유 기능은 프로그램이 활용하기 어렵다. 요청을 해석하고 대상을 찾는 계층에는 실행 비용이 들며, 일률적인 버퍼링이 어떤 작업에는 유리하고 다른 작업에는 불필요할 수 있다. 반대로 중간 계층이 요청을 합치거나 데이터를 캐시하면 개별 프로그램이 직접 처리할 때보다 빨라질 수도 있다.&lt;br /&gt;
&lt;br /&gt;
특수 기능을 위한 별도 연산이나 우회 경로를 제공하면 선택의 폭은 넓어진다. 대신 프로그램이 알아야 할 조건이 늘고 하드웨어나 구현에 대한 의존성이 커진다. 인터페이스를 설계할 때는 단순함, 구현 교체의 자유, 성능 제어 사이에서 무엇을 보장할지 정해야 한다. &amp;lt;ref name=&amp;quot;source-6&amp;quot;&amp;gt;[https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/acrobat-17.pdf Butler W. Lampson, Hints for Computer System Design (1983)].&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 자원 배분의 메커니즘과 정책 ==&lt;br /&gt;
같은 인터페이스를 유지하면서도 자원 배분 방식은 달라질 수 있다. 스레드의 실행 상태를 저장하고 다른 스레드를 실행하는 수단은 메커니즘이다. 지금 누구에게 CPU를 주고 얼마나 실행시킬지는 정책이다. 주소를 물리 메모리에 연결하는 수단과, 메모리가 부족할 때 어떤 데이터를 남길지 정하는 기준도 구분할 수 있다.&lt;br /&gt;
&lt;br /&gt;
대화형 프로그램의 응답을 빠르게 하려고 실행 작업을 자주 바꾸면 전환 비용이 증가할 수 있다. 반대로 한 작업을 오래 실행하면 처리 효율은 좋아져도 다른 작업이 오래 기다릴 수 있다. 메커니즘과 정책을 분리하면 이런 목표가 바뀔 때 자원 접근 방식 전체를 다시 설계할 필요가 줄어든다. 정책이 선택할 수 있는 범위는 메커니즘이 제공하는 기능에 달려 있다.&lt;br /&gt;
&lt;br /&gt;
같은 파일 읽기라도 캐시 상태와 다른 작업의 부하에 따라 완료 시간은 달라진다. 인터페이스가 같아도 자원 배분 정책에 따라 성능은 달라질 수 있다.&lt;br /&gt;
&lt;br /&gt;
== 관련 문서 ==&lt;br /&gt;
* [[운영체제 기본/서문]]: 자원 관리자와 제어 프로그램으로서의 역할, 운영 자동화와 자원 공유의 배경.&lt;br /&gt;
* [[운영체제 기본/Linux/파일 시스템 콜|Linux의 파일 시스템 콜]]: 파일 디스크립터라는 인터페이스가 열기, 읽기, 쓰기, 닫기 구현으로 이어지는 과정.&lt;br /&gt;
* [[운영체제 기본/가상 메모리]]: 주소 변환과 실제 메모리 배분.&lt;br /&gt;
* [[운영체제 기본/프로세스와 스레드]]: 실행 상태와 CPU 공유.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=이전 문서&amp;lt;br /&amp;gt;[[운영체제 기본/서문|서문]]&lt;br /&gt;
|목차=[[운영체제 기본#총론|총론 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/보호|보호와 시스템 콜]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/%EC%84%9C%EB%AC%B8&amp;diff=672</id>
		<title>운영체제 기본/서문</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/%EC%84%9C%EB%AC%B8&amp;diff=672"/>
		<updated>2026-11-15T06:04:00Z</updated>

		<summary type="html">&lt;p&gt;관리자: 과도한 강조, 상투적인 대조와 부연, 특수문자 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|목차=[[운영체제 기본#총론|총론 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/추상화|추상화]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
음악을 들으면서 큰 파일을 복사하고, 문서 편집기에 글을 쓰고 있다고 하자. 복사는 한동안 계속되지만 그동안 음악이 끊기거나 입력한 글자가 한참 뒤에 나타나기를 바라지는 않는다. 세 프로그램은 모두 CPU와 메모리, 장치를 사용한다. 한 프로그램이 먼저 실행되었다는 이유로 이 자원을 끝까지 독차지하게 둘 수는 없다.&lt;br /&gt;
&lt;br /&gt;
운영체제(Operating System, OS)는 이런 프로그램들이 함께 실행될 환경을 마련한다. 누구에게 어떤 자원을 얼마나 줄지 결정한다는 점에서는 자원 관리자(Resource Allocator), 프로그램의 실행을 관리하고 잘못된 사용이 다른 작업까지 망가뜨리지 않도록 한다는 점에서는 제어 프로그램(Control Program)이다. 파일 복사를 계속 진행하면서 편집기에 실행 기회를 주는 일과, 오작동한 프로그램이 편집 중인 문서를 메모리에서 덮어쓰지 못하게 하는 일은 이 두 역할의 예다.&amp;lt;ref name=&amp;quot;os-definition&amp;quot;&amp;gt;Abraham Silberschatz, Peter B. Galvin, Greg Gagne, [https://os-book.com/OS9/slide-dir/PDF-dir/ch1.pdf Operating System Concepts, 9th Edition, Chapter 1: Introduction], 슬라이드 1.4-1.8. 운영체제의 목적, 자원 관리자와 제어 프로그램의 역할.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 자원 배분 ==&lt;br /&gt;
복사 프로그램이 저장장치에서 데이터를 읽어 오기를 기다리는 동안에는 CPU로 할 일이 없을 수 있다. 이때 CPU까지 함께 쉬게 할 필요는 없다. 운영체제는 실행할 준비가 된 편집기나 음악 재생기에 CPU를 배정할 수 있다. 나중에 복사 프로그램으로 돌아오려면 어느 명령까지 실행했는지, 어떤 값을 계산 중이었는지를 보관해야 한다. 그래서 실행 중인 프로그램의 자원과 상태를 묶는 프로세스, 그 안에서 명령을 실행하는 흐름인 스레드가 필요하다. [[운영체제 기본/프로세스와 스레드|프로세스와 스레드]]에서는 이 상태를 어떻게 나누고 실행을 어떻게 이어 가는지 다룬다.&lt;br /&gt;
&lt;br /&gt;
누구를 먼저 실행할지도 문제다. 복사를 빨리 끝내는 것만 목표로 삼으면 다른 작업의 반응이 늦어질 수 있고, 입력에 자주 반응하려면 하던 작업을 중단하고 다시 이어야 한다. 자원을 낭비하지 않는 효율, 특정 작업이 계속 밀리지 않게 하는 공정성, 요청에 빠르게 반응하는 응답성을 함께 고려해야 한다. 스케줄링은 이런 기준에 따라 실행 순서를 정하는 일이다. 작업의 성격과 시스템 부하에 따라 배분 방법도 달라진다.&lt;br /&gt;
&lt;br /&gt;
메모리는 시간을 나누는 것만으로 해결되지 않는다. 편집 중인 문서와 재생할 음악 데이터, 복사 중인 데이터가 함께 들어갈 공간이 필요하다. 프로그램을 열고 닫다 보면 빈 공간도 여기저기 흩어진다. 프로그램이 이런 물리적 배치를 직접 계산하게 하는 대신, 각 프로그램이 사용하는 주소와 실제 메모리 위치를 분리할 수 있다. [[운영체제 기본/가상 메모리|가상 메모리]]는 이 연결을 관리하며 배치, 보호, 공유를 다루는 방법이다. 프로그램에는 연속된 배열처럼 보여도 실제 RAM에서는 여러 조각에 나누어 둘 수 있다.&amp;lt;ref name=&amp;quot;memory-overview&amp;quot;&amp;gt;MIT PDOS, [https://mit-pdos.github.io/xv6-riscv-book/mem.html xv6: Page tables], 주소 공간과 물리 메모리의 연결.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 프로그램 실행의 제어 ==&lt;br /&gt;
복사 프로그램이 버그 때문에 끝없는 계산에 빠졌다고 하자. 그 프로그램이 스스로 CPU를 양보하기만 기다린다면 편집기에 실행 기회를 줄 수 없다. 운영체제가 다시 제어를 얻을 수단이 필요하다. 타이머가 일정 시간이 지났음을 알리는 인터럽트는 현재 실행 중인 코드에서 운영체제로 제어를 넘기는 계기가 된다. 저장장치도 데이터 전송이 끝났음을 인터럽트로 알릴 수 있다. 운영체제는 그 통지를 처리하고 기다리던 작업을 다시 실행할 수 있게 한다. [[운영체제 기본/장치 제어와 입출력|장치 제어와 입출력]]에서는 장치에 일을 시키고, 데이터를 옮기고, 완료를 확인하는 과정을 구분한다.&amp;lt;ref name=&amp;quot;interrupt-overview&amp;quot;&amp;gt;MIT PDOS, [https://mit-pdos.github.io/xv6-riscv-book/interrupt.html xv6: Interrupts and device drivers], 장치 완료 통지와 6.4 타이머 인터럽트.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
잘못된 포인터로 편집기의 메모리를 덮어쓰는 문제는 실행 순서를 바꾸는 것만으로 막을 수 없다. 운영체제는 프로그램마다 접근할 수 있는 메모리와 직접 실행할 수 있는 동작의 범위를 정한다. 다만 모든 메모리 접근을 운영체제 코드가 일일이 검사할 수는 없다. CPU의 권한 모드와 메모리 접근 검사 같은 하드웨어의 도움으로 그 경계를 강제한다. 이것이 [[운영체제 기본/보호|보호]]가 필요한 이유다. 복사할 내용을 고르는 일은 프로그램이 맡고, 운영체제는 그 프로그램의 접근 범위를 제한한다.&amp;lt;ref name=&amp;quot;os-roles&amp;quot;&amp;gt;MIT PDOS, [https://mit-pdos.github.io/xv6-riscv-book/first.html xv6: Operating system organization], 2.1. 자원 공유, 격리, 상호작용과 물리 자원의 추상화.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
반대로 프로그램끼리 협력해야 할 때도 있다. 한 프로그램이 압축을 풀고 다른 프로그램이 그 결과에서 문자열을 찾는다면, 서로의 메모리를 마음대로 읽게 하지 않고도 데이터를 전달할 길이 필요하다. 운영체제는 파이프처럼 데이터를 건네는 통로나, 명시적으로 함께 쓰는 메모리 영역을 제공한다. [[운영체제 기본/프로세스 간 통신|프로세스 간 통신]]은 격리를 유지하면서 필요한 교류를 가능하게 하는 방법을 다룬다.&amp;lt;ref name=&amp;quot;os-roles&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
공유를 허용하면 순서 문제도 생긴다. 음악 재생기에서 한 스레드가 재생할 데이터를 채우고 다른 스레드가 가져간다고 하자. 아직 다 채우지 않은 데이터를 읽거나, 재생이 끝나기 전에 같은 공간을 덮어쓰면 안 된다. 운영체제 내부의 작업 대기열도 여러 실행 흐름이 함께 수정할 수 있다. [[운영체제 기본/동시성|동시성]]에서 다루는 뮤텍스와 세마포어 같은 동기화 수단은 이러한 접근 순서를 맞추기 위해 필요하다. 프로그램도 공유 데이터에 접근할 때 이 동기화 규칙을 따라야 한다.&amp;lt;ref name=&amp;quot;locking-overview&amp;quot;&amp;gt;MIT PDOS, [https://mit-pdos.github.io/xv6-riscv-book/lock.html xv6: Locking], 공유 자료구조와 실행 순서에 따른 오류, 상호 배제.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 운영 자동화와 자원 공유 ==&lt;br /&gt;
오늘날에는 여러 프로그램을 함께 쓰는 일이 자연스럽지만, 초기 대형 컴퓨터에서는 프로그램 하나를 실행하는 일에도 사람의 손이 많이 갔다. 사용자가 예약한 시간에 제어 콘솔을 조작하고 프로그램과 데이터를 넣은 뒤 결과를 회수했다. 한 사람의 계산이 끝나도 다음 사람이 실행 준비를 마칠 때까지 기계는 기다렸다. 계산할 일은 밀려 있는데 비싼 컴퓨터가 쉬는 셈이다. 이 공백을 줄이기 위해 작업의 시작과 종료를 관리하는 모니터(Monitor)와 준비된 작업들을 차례로 실행하는 일괄 처리(Batch Processing)가 발전했다. GM-NAA I/O 같은 초기 시스템은 한 작업이 실패해도 진단 정보를 남기고 다음 작업으로 넘어가도록 실행을 자동화했다.&amp;lt;ref name=&amp;quot;os-origins&amp;quot;&amp;gt;Robert L. Patrick, [https://softwarepreservation.computerhistory.org/os/gm.html Operating Systems at Conception] (2008). GM-NAA I/O 설계 참여자의 초기 작업 운영과 일괄 처리에 대한 회고.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
작업을 자동으로 이어 붙여도 다른 기다림이 남았다. 실행 중인 프로그램이 저장장치에서 데이터를 받는 동안 CPU가 놀 수 있었다. 다중 프로그래밍(Multiprogramming)은 이때 다른 준비된 프로그램을 실행하는 방식으로 CPU 이용률을 높였다. 앞서 파일 복사가 입출력을 기다리는 동안 편집기를 실행하는 것과 같은 생각이다. 대신 여러 프로그램을 메모리에 함께 두고, 각자의 실행 상태와 배치를 관리해야 했다. 자원을 더 잘 활용하려는 요구가 프로세스 관리와 메모리 관리의 필요성으로 이어진 것이다.&amp;lt;ref name=&amp;quot;multiprogramming-origin&amp;quot;&amp;gt;Jerome H. Saltzer, John W. Gintell, [https://www.multicians.org/InstrumentationPaper.html The Instrumentation of Multics] (1970), &amp;quot;Special Instrumentation for Multiprogrammed Demand Paging&amp;quot;. 입출력 대기와 CPU 이용률, 여러 프로그램을 유지하는 메모리 비용.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
일괄 처리에서는 작업을 고치고 결과를 확인하는 데도 시간이 걸렸다. 프로그램을 제출한 뒤 결과를 받아서야 작은 오류를 발견했다면, 수정한 작업을 다시 제출하고 또 기다려야 했다. 시분할(Time Sharing)은 여러 사용자가 단말에서 명령을 내리고 응답을 받도록 CPU 시간을 나누었다. 한 사용자의 긴 계산이 끝나기 전에도 다른 사용자는 작업을 진행할 수 있었다. 초기 시분할 시스템인 CTSS(Compatible Time-Sharing System)는 기계의 처리량뿐 아니라 프로그램을 수정하고 결과를 확인하는 사람의 대기 시간을 줄이는 데도 목적을 두었다. 오늘날 스케줄링에서 처리량과 응답성을 함께 고려하는 이유와 맞닿아 있다.&amp;lt;ref name=&amp;quot;ctss-origins&amp;quot;&amp;gt;MIT Computation Center, [https://people.csail.mit.edu/saltzer/CTSS/CTSS-Documents/CTSS_ProgrammersGuide_1963.pdf The Compatible Time-Sharing System: A Programmer&#039;s Guide] (1963), 1장. 시분할의 동기와 감독 프로그램에 의한 실행 관리.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== 공통 서비스와 추상화 ==&lt;br /&gt;
문서 편집기에서 저장을 누를 때마다 프로그램이 저장장치의 빈 구역을 직접 찾아야 한다면 어떨까. 복사 프로그램도 같은 구역이 비어 있다고 판단하면 서로의 데이터를 덮어쓸 수 있다. 운영체제의 파일시스템은 저장 공간의 사용 상태를 관리하고, 프로그램에는 이름으로 찾고 읽고 쓸 수 있는 파일을 제공한다. 편집기는 문서 내용을 전달하고, 파일시스템은 그 내용을 어디에 보관하고 어떻게 다시 찾을지 관리한다. [[운영체제 기본/파일과 입출력|파일과 입출력]]은 이처럼 지속적으로 보관할 데이터와 장치 사이의 연결을 다룬다.&lt;br /&gt;
&lt;br /&gt;
이 공통 서비스는 프로그램을 작성하는 부담도 줄인다. 편집기는 저장 대상이 다른 장치로 바뀌었다고 해서 장치 제어 코드를 처음부터 다시 작성하지 않아도 된다. 파일을 열고 읽고 쓰는 인터페이스를 사용하고, 장치별 차이는 운영체제의 해당 계층이 처리한다. 실제 자원의 복잡한 동작을 프로그램이 사용할 대상과 연산으로 나타내는 것이 추상화다. 운영체제는 추상화를 통해 자원 배분과 실행 제어에 필요한 기능을 프로그램이 사용하기 쉬운 형태로 제공한다. 다음 장인 [[운영체제 기본/추상화|추상화]]에서는 DOS의 장치 설정 사례로 이 필요성을 더 구체적으로 살펴본다.&lt;br /&gt;
&lt;br /&gt;
이후의 총론은 여기서 만난 문제들을 하나씩 풀어 간다. 읽을 때는 무엇을 할지 정하는 정책과 그 결정을 실행하는 메커니즘도 구별할 필요가 있다. 편집기를 먼저 실행할지 정하는 기준은 정책이고, 복사 프로그램의 실행 상태를 보관한 뒤 편집기를 이어서 실행하는 수단은 메커니즘이다. 총론은 이런 문제와 설계상의 선택을 설명하고, Linux 각론은 실제 구현을 추적한다.&lt;br /&gt;
&lt;br /&gt;
== 관련 문서 ==&lt;br /&gt;
* [[운영체제 기본/추상화]]: 프로그램에 제공하는 대상과 연산, 실제 자원의 연결.&lt;br /&gt;
* [[운영체제 기본/보호]]: 운영체제가 정한 실행 경계를 강제하는 하드웨어의 도움.&lt;br /&gt;
* [[운영체제 기본/프로세스와 스레드]]: 실행 환경과 실행 흐름, CPU의 공유.&lt;br /&gt;
&lt;br /&gt;
== 참고 문헌 ==&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|목차=[[운영체제 기본#총론|총론 목차]]&lt;br /&gt;
|다음=다음 문서&amp;lt;br /&amp;gt;[[운영체제 기본/추상화|추상화]]&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%EB%A9%94%EB%AA%A8%EB%A6%AC_%EB%A7%A4%ED%95%91&amp;diff=671</id>
		<title>운영체제 기본/Linux/메모리 매핑</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%EB%A9%94%EB%AA%A8%EB%A6%AC_%EB%A7%A4%ED%95%91&amp;diff=671"/>
		<updated>2026-11-15T06:03:49Z</updated>

		<summary type="html">&lt;p&gt;관리자: 문체 정리: 불필요한 대조와 특수문자 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=&lt;br /&gt;
|목차=[[운영체제 기본|운영체제 기본 목차]]&lt;br /&gt;
|다음=&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;code&amp;gt;mmap()&amp;lt;/code&amp;gt;은 프로세스의 가상 주소 구간을 만들고, 그 구간의 접근을 무엇으로 뒷받침할지 정한다. 새로 마련할 익명 메모리와 파일의 페이지 캐시, 장치의 메모리 매핑 입출력(MMIO) 영역을 같은 주소 공간 안에 배치할 수 있다.&lt;br /&gt;
&lt;br /&gt;
Linux v6.12의 공통 매핑과 페이지 폴트 경로를 먼저 살펴보고, 각 매핑이 실제 접근을 처리하는 방식을 비교한다. 시스템 콜과 CPU 예외 진입은 x86-64와 RISC-V RV64를 함께 다룬다.&lt;br /&gt;
&lt;br /&gt;
== 관련 총론 ==&lt;br /&gt;
* [[운영체제 기본/가상 메모리|가상 메모리]]: 페이지 테이블, 페이지 폴트, 쓰기 시 복사.&lt;br /&gt;
* [[운영체제 기본/파일과 입출력|파일과 입출력]]: 파일 데이터의 버퍼링과 변경의 가시성.&lt;br /&gt;
* [[운영체제 기본/장치 제어와 입출력|장치 제어와 입출력]]: MMIO와 장치 레지스터 접근.&lt;br /&gt;
* [[운영체제 기본/프로세스 간 통신|프로세스 간 통신]]: 공유 매핑을 통한 데이터 교환과 동기화.&lt;br /&gt;
&lt;br /&gt;
== 문서 구성 ==&lt;br /&gt;
# [[운영체제 기본/Linux/메모리 매핑/mmap과 주소 공간|mmap과 주소 공간]]: 인자, VMA, 매핑 대상의 연결과 수명.&lt;br /&gt;
# [[운영체제 기본/Linux/메모리 매핑/페이지 폴트 처리|페이지 폴트 처리]]: CPU 예외, 접근 권한 검사, PTE 설치와 명령 재시도.&lt;br /&gt;
# [[운영체제 기본/Linux/메모리 매핑/익명 메모리 매핑|익명 메모리 매핑]]: 지연 할당, 0 페이지, fork 이후 COW.&lt;br /&gt;
# [[운영체제 기본/Linux/메모리 매핑/파일 매핑과 COW|파일 매핑과 COW]]: 파일 읽기, MAP_PRIVATE의 쓰기 시 복사, MAP_SHARED의 변경 반영.&lt;br /&gt;
# [[운영체제 기본/Linux/메모리 매핑/MMIO 장치 매핑|MMIO 장치 매핑]]: 장치 드라이버, 물리 주소 구간, 메모리 속성과 장치 접근.&lt;br /&gt;
&lt;br /&gt;
== 관련 각론 ==&lt;br /&gt;
* [[운영체제 기본/Linux/파일 시스템 콜|Linux의 파일 시스템 콜]]&lt;br /&gt;
* [[운영체제 기본/Linux/파일시스템/페이지 캐시|페이지 캐시]]&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=&lt;br /&gt;
|목차=[[운영체제 기본|운영체제 기본 목차]]&lt;br /&gt;
|다음=&lt;br /&gt;
}}&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8&amp;diff=670</id>
		<title>운영체제 기본</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8&amp;diff=670"/>
		<updated>2026-11-15T06:03:34Z</updated>

		<summary type="html">&lt;p&gt;관리자: 과도한 강조와 반복 표현, 특수문자 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;우리가 보통 &#039;&#039;&#039;운영체제&#039;&#039;&#039;라 하면 운영체제가 무엇을 하는지보다는 막연하게 컴퓨터를 켤 때 로드해야 하는 특이한 프로그램 정도로 여기는 경향이 있다.&lt;br /&gt;
&lt;br /&gt;
총론은 자원 공유와 보호, 자원을 효율적으로 사용하는 방법을 다룬다. 각론은 그 설계가 Linux에서 구현된 형태를 소스 코드로 추적한다. C의 함수 호출과 포인터, 기본적인 파일 입출력에 익숙한 독자를 대상으로 한다.&lt;br /&gt;
&lt;br /&gt;
== 총론 ==&lt;br /&gt;
# [[운영체제 기본/서문|서문]]: 운영체제의 등장 배경, 자원 관리자와 제어 프로그램의 역할.&lt;br /&gt;
# [[운영체제 기본/추상화|추상화]]: 프로그램에 보이는 인터페이스와 그 뒤에서 관리하는 자원.&lt;br /&gt;
# [[운영체제 기본/보호|보호와 시스템 콜]]: 사용자 공간과 커널 공간을 나누는 이유.&lt;br /&gt;
# [[운영체제 기본/장치 제어와 입출력|장치 제어와 입출력]]: 장치 명령, DMA와 인터럽트를 통한 입출력.&lt;br /&gt;
# [[운영체제 기본/프로세스와 스레드|프로세스와 스레드]]: 자원과 실행 문맥의 분리, 격리와 공유.&lt;br /&gt;
# [[운영체제 기본/동시성|동시성]]: 공유 상태의 정확성, 동기화 비용과 진행 보장.&lt;br /&gt;
# [[운영체제 기본/가상 메모리|가상 메모리]]: 주소 공간의 격리와 공유, 지연 할당의 이득과 비용.&lt;br /&gt;
# [[운영체제 기본/파일과 입출력|파일과 입출력]]: 이름과 열린 대상의 분리, 버퍼링과 영속성.&lt;br /&gt;
# [[운영체제 기본/프로세스 간 통신|프로세스 간 통신]]: 시그널과 데이터 전달, 공유 메모리와 동기화.&lt;br /&gt;
&lt;br /&gt;
== 각론: Linux 구현 읽기 ==&lt;br /&gt;
* [[운영체제 기본/Linux/x86-64/BIOS 부팅|x86-64 Linux의 BIOS 부팅]]: BIOS GRUB의 커널 인계부터 커널 초기화와 init 선택까지.&lt;br /&gt;
* [[운영체제 기본/Linux/ELF 로딩|Linux의 ELF 로딩]]: execve, binfmt와 ELF 매핑, 초기 스택과 사용자 모드 진입.&lt;br /&gt;
* [[운영체제 기본/Linux/파일 시스템 콜|Linux의 파일 시스템 콜]]: 파일 열기부터 읽기와 쓰기, 파일 위치와 열린 파일의 수명까지 이어지는 공통 경로.&lt;br /&gt;
* [[운영체제 기본/Linux/메모리 매핑|Linux의 메모리 매핑 (mmap)]]: 공통 주소 공간과 폴트 처리와 익명 메모리, 파일 COW, MMIO 장치 매핑.&lt;br /&gt;
* [[운영체제 기본/Linux/x86-64/i8042 키보드 입력|x86-64 Linux의 i8042 키보드 입력]]: i8042의 IRQ부터 입력 이벤트와 사용자 프로세스까지.&lt;br /&gt;
* [[운영체제 기본/Linux/파일시스템|Linux의 파일시스템]]: VFS, ext4와 procfs 구현과 공통 페이지 캐시.&lt;br /&gt;
&lt;br /&gt;
* [[운영체제 기본/Linux/RCU|Linux의 RCU]]: 포인터 공개, 읽기 구간, 유예 기간과 Tree RCU의 메모리 회수.&lt;br /&gt;
&lt;br /&gt;
각론의 코드는 Linux v6.12를 기준으로 한다.&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
	<entry>
		<id>https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%ED%8C%8C%EC%9D%BC_%EC%8B%9C%EC%8A%A4%ED%85%9C_%EC%BD%9C&amp;diff=669</id>
		<title>운영체제 기본/Linux/파일 시스템 콜</title>
		<link rel="alternate" type="text/html" href="https://wiki.ldmsys.net/index.php?title=%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C_%EA%B8%B0%EB%B3%B8/Linux/%ED%8C%8C%EC%9D%BC_%EC%8B%9C%EC%8A%A4%ED%85%9C_%EC%BD%9C&amp;diff=669"/>
		<updated>2026-11-15T06:03:31Z</updated>

		<summary type="html">&lt;p&gt;관리자: 문체 정리: 불필요한 강조와 특수문자 정리&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{이전 다음 문서&lt;br /&gt;
|이전=&lt;br /&gt;
|목차=[[운영체제 기본|운영체제 기본 목차]]&lt;br /&gt;
|다음=&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
Linux v6.12의 파일 시스템 콜을 파일의 수명에 따라 살펴본다. 이름으로 파일을 열고, fd로 읽고 쓰며, 위치를 변경하고 닫는 과정은 VFS와 열린 파일 객체를 공유한다. 아키텍처별 진입은 x86-64와 RISC-V RV64로 비교한다.&lt;br /&gt;
&lt;br /&gt;
== 관련 총론 ==&lt;br /&gt;
* [[운영체제 기본/파일과 입출력|파일과 입출력]]: 경로, 열린 파일, 오프셋과 읽기 및 쓰기의 의미.&lt;br /&gt;
* [[운영체제 기본/보호|보호와 시스템 콜]]: 시스템 콜 진입과 사용자 인자 검증.&lt;br /&gt;
* [[운영체제 기본/프로세스와 스레드|프로세스와 스레드]]: 파일 디스크립터 테이블의 공유와 실행 상태.&lt;br /&gt;
&lt;br /&gt;
== 문서 구성 ==&lt;br /&gt;
# [[운영체제 기본/Linux/파일 시스템 콜/시스템 콜과 파일 디스크립터|시스템 콜과 파일 디스크립터]]: 사용자 ABI, fd 테이블, 열린 파일과 VFS의 공통 구조.&lt;br /&gt;
# [[운영체제 기본/Linux/파일 시스템 콜/openat과 경로 탐색|openat과 경로 탐색]]: 경로의 시작점, 이름 탐색, 파일 연산 연결과 fd 설치.&lt;br /&gt;
# [[운영체제 기본/Linux/파일 시스템 콜/read와 write|read와 write]]: 공통 검사와 대상별 콜백, 버퍼드 입출력, 부분 처리와 반환값.&lt;br /&gt;
# [[운영체제 기본/Linux/파일 시스템 콜/파일 오프셋과 열린 파일의 수명|파일 오프셋과 열린 파일의 수명]]: lseek, pread, pwrite, dup의 위치 공유, close와 fsync의 차이.&lt;br /&gt;
&lt;br /&gt;
[[운영체제 기본/Linux/파일시스템|Linux의 파일시스템]]은 VFS 객체, ext4와 procfs와 페이지 캐시의 구현을, [[운영체제 기본/Linux/메모리 매핑|Linux의 메모리 매핑]]은 mmap으로 주소 공간을 구성하고 접근하는 경로를 다룬다.&lt;br /&gt;
&lt;br /&gt;
{{이전 다음 문서&lt;br /&gt;
|이전=&lt;br /&gt;
|목차=[[운영체제 기본|운영체제 기본 목차]]&lt;br /&gt;
|다음=&lt;br /&gt;
}}&lt;br /&gt;
&lt;br /&gt;
{{운영체제 기본 둘러보기}}&lt;/div&gt;</summary>
		<author><name>관리자</name></author>
	</entry>
</feed>