RaptOS

3. static & extern

Sun, 16 Nov 2008 02:39:15 +0900

3. static & extern

3.1 static

static(정적)함수는 소스 코드에서 은폐성을 높이기 위해 매우 중요한 요소이지만, 널리 알려져

있지 않은 단어라고 할 수 있다.

만약 2. 선언에 있는 소스코드 중에서 init.c의 코드의 정의를

static void init(){...}

와 같이 static을 붙이면 어떻게 될까? 그렇다 함수의 선언 및 정의에 static을 붙일 경우에는

해당 함수의 접근은 해당 파일내로 제한하게 된다. inic.c에 static을 붙이고 컴파일을 할 경우에는
해당 함수가 정의되지 않았다는 메시지와 함께 에러가 발생하게 된다.

다시 말하면, 함수를 static으로 정의하면 그 파일 내에서만 통용되는 완전한 지역(local)함수로 취급

할 수 있으며, 아래와 같은 이점이 있다.

다른 파일과 함수명의 충돌이 있을지 걱정하지 않아도 된다.
다른 파일에서는 그 함수를 호출하지 않는 것이 보장된다.

3.2 extern

아래와 같은 함수가 있으면,

int Test(int i)
{
return i;
}

함수 Test는 외부에 공개 되어있으며 다른 파일에서의 접근이 허용이 된다는 의미가 된다.

즉 외부함수 또는 전역함수라는 말이 된다.

만약 다른 소스파일에서 Test함수를 호출하려고 할때, 해당 파일 내에서는 함수 Test함수의 인자와

반환형식을 알고 있어야되는데 이때 extern을 붙여주면 된다.

extern int Test(int i);
또는
int Test(int i); // extern 생략 가능

함수의 경우에는 default로 전역함수가 되므로 extern은 생략해도 된다.

3.3 변수에 대한 static & extern

변수의 경우에도 함수와 마찬가지로 파일 외부로 공개 유무에 따라서 static 또는 extern을 사용한다.

하지만 여기에는 함수에서 사용할때와는 조금 차이가 있으니 확인하도록 하자.

아래와 같이 함수내에서 static을 사용했을 경우에는 범위는 함수안에서만 유효범위가 된다. 함수 외부

에서의 접근은 거부 된다.

void Test()
{
static int test_value = 0;
int test = 1;
}

이외의 static이 붙은 변수와 함수내의 지역변수와의 차이점은 C언어 기본서를 참고하기 바란다.

함수외부에서 선언된 static변수의 경우는 해당 파일내로 접근 범위가 제한이 되며, 외부에서의 접근을

할 수 없다.

static int test = 1;
int GetValue()
{
return test;
}

void SetValue(int value)
{
test = value;
}

외부에서 접근이 제한되므로 Get/Set함수를 통해서 해당 변수를 제어하도록 하자.

변수의 경우도 extern을 선언함으로써 다른 파일에서 정의된 변수의 형식을 컴파일러에게 알려줄 수 있다.

extern int test;

int main()
{
printf("Value: %d\n", test);
return 0;
}

위와 같이 extern을 붙여 주어서 외부에 선언된 변수가 있다는 것을 알릴수 있다. 하지만 해당 변수에

static형일 경우에는 해당 변수를 발견할 수 없다는 메시지와 함께 에러가 발생하게 된다.

아래는 변수 공개의 예제 코드이다.

<test.c>

int test = 1;

<main.c>

#include <stdio.h>

extern int test;
int main(void)
{
printf("Test Value: %d\n", test);
return 0;
}

3.4 참고

변수
- static: 변수 정의(파일 외부에 공개하지 않음)
- 없음: 변수 정의(파일 외부에 공개함)
- extern: 변수 선언(정의는 없음)
함수 정의
- static: 파일 외부에 공개하지 않음
- 없음: 파일 외부에 공개함
- extern: 파일 외부에 공개함
함수의 원형 선언
- static: 공개하지 않는 함수의 원형 선언(같은 파일내에)
- 없음: 공개하는 함수의 원형 선언
- extern: 공개하는 함수의 원형 선언

< 참고: 쉽게 배우는 C프로그래밍 테크닉(p51) >

참고. 대기상태(Sleeping)

Wed, 12 Nov 2008 01:54:32 +0900

Sleeping

A thread can also tell the system that it does not want to be schedulable for a certain amount of time. This is accomplished by calling Sleep:

VOID Sleep(DWORD dwMilliseconds);

This function causes the thread to suspend itself until dwMilliseconds have elapsed. There are a few important things to notice about Sleep:

Calling Sleep allows the thread to voluntarily give up the remainder of its time slice.
The system makes the thread not schedulable for approximately the number of milliseconds specified. That's right—if you tell the system you want to sleep for 100 milliseconds, you will sleep approximately that long but possibly several seconds or minutes more. Remember that Windows is not a real-time operating system. Your thread will probably wake up at the right time, but whether it does depends on what else is going on in the system.
You can call Sleep and pass INFINITE for the dwMilliseconds parameter. This tells the system to never schedule the thread. This is not a useful thing to do. It is much better to have the thread exit and to recover its stack and kernel object.
You can pass 0 to Sleep. This tells the system that the calling thread relinquishes the remainder of its time slice and forces the system to schedule another thread. However, the system can reschedule the thread that just called Sleep. This will happen if there are no more schedulable threads at the same priority.

Enum Process

Thu, 06 Nov 2008 01:38:08 +0900

Enum Process

현재 실행되고 있는 Process에 대한 정보를 얻어오는 코드이다. 작업관리자에서 보여지는 Process List들은 performance registry

데이터를 이용해서 얻어온다고하는데 이 방법은 조금 까다로운(??)면이 있다고 한다.

다음 코드는 이와 유사한 기능을 하는 코드이다.(psapi.h 헤더파일을 포함시키기 위해서는 Link Tab에 Psapi.lib를 추가해야된다.)

코드를 실행을 시켜보면 <unknown>이라고 표시되는 프로세스가 있는데 이것은 유저레벨에서는 접근이 불가능하기 때문.

#include <windows.h>
#include <stdio.h>
#include <tchar.h>
#include "psapi.h"
void PrintProcessNameAndID( DWORD processID )
{
    TCHAR szProcessName[MAX_PATH] = TEXT("<unknown>");

    // Get a handle to the process.
    HANDLE hProcess = OpenProcess( PROCESS_QUERY_INFORMATION |
                                   PROCESS_VM_READ,
                                   FALSE, processID );

    // Get the process name.
    if (NULL != hProcess )
    {
        HMODULE hMod;
        DWORD cbNeeded;

        if ( EnumProcessModules( hProcess, &hMod, sizeof(hMod),
                                 &cbNeeded) )
        {
            GetModuleBaseName( hProcess, hMod, szProcessName,
                               sizeof(szProcessName)/sizeof(TCHAR) );
        }
    }

    // Print the process name and identifier.
    _tprintf( TEXT("%s (PID: %u)\n"), szProcessName, processID );

    CloseHandle( hProcess );
}
void main( )
{
    // Get the list of process identifiers.
    DWORD aProcesses[1024], cbNeeded, cProcesses;
    unsigned int i;

    if ( !EnumProcesses( aProcesses, sizeof(aProcesses), &cbNeeded ) )
        return;

    // Calculate how many process identifiers were returned.
    cProcesses = cbNeeded / sizeof(DWORD);

    // Print the name and process identifier for each process.
    for ( i = 0; i < cProcesses; i++ )
        PrintProcessNameAndID( aProcesses[i] );
}

Slice Code

Thu, 06 Nov 2008 01:30:13 +0900

2. 선언

Tue, 21 Oct 2008 22:52:46 +0900

2. 선언

소스 코드를 여러 파일로 분할할 때 컴파일이 원할하게 진행이 되려면, 자신과 관련된 함수의 인자,

반환값 같은 속성을 서로서로 미리 알고 있어야 된다. 이러한 정보들을 알리기 위해 쓰는 것이

함수원형 선언이다.

2.1 함수의 암시적 선언

< main.c >

#include <stdlib.c>
int main()
{
init();
ende(); /* 오타 */
return 0;
}

< init.c >

#include <stdio.h>
void init()
{
printf("Init Function\n");
}

< end.c >

#include <stdio.h>
void end()
{
printf("End Function\n");
}

위의 파일들이 있다고 가정해 보자. 각각의 파일들은 컴파일은 잘 수행이 된다. 하지만 목적파일인

main.o, init.o, end.o를 링크할 경우에는 에러가 발생하게 된다. 문제는 바로 main.c에 있는

ende();

코드 때문에 에러가 나게 된다. 그런데 왜 main.c를 컴파일을 할때는 에러가 발생하지 않는 것일까?

그것은 컴파일 과정을 좀더 자세히 살펴보면 해답을 찾을 수가 있는데, 여기서 바로 함수의 암시적 선언/명시적 선언의

용어가 나오게 된다. 명시적 선언은 뒤에 알아보도록 하고 우선은 암시적 선언에 대해서 알아보도록 하자.

이제 잠시 컴파일러가 되어서 main.c를 컴파일을 해보자. main.c의 파일을 첫 줄에서부터 컴파일을 하면서 main.c파일에는

정의 되어있지 않은 init함수와 ende함수를 호출하는 것을 찾게 된다. 이곳에서 컴파일러는 이전 컴파일 과정까지

init, ende함수에 대한 정보가 없으면, int형을 반환하는 것으로 가정을 하고 컴파일 작업을 계속하게 된다.

실제로도 C언어에서는 반환값이 정의 되어있지 않은 함수 또는 함수의 존재를 알 수 없을 경우 int형을 반환하는 것으로

간주된다고 정해져 있다고 한다. 이것을 바로 함수의 암시적 선언 이라고 한다.

이렇게 init.c 와 end.c 파일도 에러없이 컴파일이 진행이 되게 되고. 이후 링크 과정에서 함수들의 정보를 기록해 놓아 둔것과

실제 정의된 함수를 찾아서 해당 함수가 없을 경우에는 에러가 발생하게 되는 것이다.

컴파일&링크과정에서의 함수명에 대한 에러내용은 실제로는 링크과정에서 발생이 된것 이라고 볼수가 있다.

2.2 함수의 명시적 선언

앞에서 함수의 암시적 선언을 알아 보았으니, 이제 함수의 명시적 선언에 대해서 알아보도록 하자.

함수의 호출이전에 함수의 정의 부분이 있는 경우에는 함수가 명시적으로 선언된 경우라고 할 수 있다.

#include <stdio.h>
int init(){};

int main()
{
init();
return 0;
}

하지만 아래의 경우도 함수가 명시적으로 선언이 되었다고 할수 있을까?

#include <stdio.h>
int main()
{
init();
return 0;
}
int init(){};

위의 경우에는 명시적으로 선언이 되었다고는 할 수 없다. 그 이유는 컴파일러는 컴파일을 수행할 때 앞에서부터 순서대로

처리하게 되는데 이렇게 될 경우에는 init함수를 암시적으로 선언을 하게 된 후 init함수의 정의 부분을 만나게 되는데 이렇게

되면 앞쪽의 암시적 선언과 형식이 일치하지 않다는 경고메시지를 확인하게 된다.

함수의 명시적인 선언을 할 경우에는 전달인자 및 리턴 값의 체크도 가능하니 이점 알아두도록 하자.

이것을 고려하여 함수는 명시적 선언을 하도록 하여, 오류를 줄이도록 하자.

Device Driver

Thu, 16 Oct 2008 14:45:16 +0900

Device Drivers and File System Drivers Defined

A Windows driver can support a device or a file system:

Device driver

            A device driver is a set of software code that must integrate into the operating system. To complete this integration, you must write a set of handler routines in your driver that process calls from the
            operating system. These routines can be simple function calls, but many of them implement the processing of I/O request packets (IRPs), which facilitate communication between drivers and the
            operating system.

A device driver provides I/O services for an underlying device. For example, all of the following are considered device drivers: the IEEE 1394 bus driver, a video class driver that manages streaming input data for a variety of video devices, a video miniclass driver that communicates with the class driver to support a specific video device, and a filter driver that filters the streaming data. Some device drivers — particularly those for audio, video, and print devices — run in user mode, but most run in kernel mode.

File system driver

A file system driver handles I/O independent of any underlying physical device. File system drivers include drivers for the system-supplied NTFS and file allocation table (FAT) file systems. On the NT-based operating system, file system drivers are kernel-mode drivers. File system filter drivers provide additional capabilities above a standard file system driver, typically by implementing such value-added services as virus screening.

Although the support is not visible to the writer of a file system driver, every file system driver ultimately depends on support from one or more underlying peripheral devices. File system drivers might also rely on support from one or more Plug and Play (PnP) hardware bus drivers.

출처: Windows Driver Development Kit Document

참고. Process State

Fri, 10 Oct 2008 23:59:42 +0900

1. Process State

In a multitasking computer system, processes may occupy a variety of states. These distinct states may not actually be recognized as such by the operating system kernel, however they are a useful abstraction for the understanding of processes.

The various process states, displayed in a state diagram, with arrows indicating possible transitions between states - as can be seen, some processes are stored in main memory, and some are stored in secondary (virtual) memory.

[edit] Primary process states

The following typical process states are possible on computer systems of all kinds. In most of these states, processes are "stored" on main memory.

[edit] Created

(Also called new.) When a process is first created, it occupies the "created" or "new" state. In this state, the process awaits admission to the "ready" state. This admission will be approved or delayed by a long-term, or admission, scheduler. Typically in most desktop computer systems, this admission will be approved automatically, however for real time operating systems this admission may be delayed. In a real time system, admitting too many processes to the "ready" state may lead to oversaturation and overcontention for the systems resources, leading to an inability to meet process deadlines.

[edit] Ready

(Also called waiting or runnable.) A "ready" or "waiting" process has been loaded into main memory and is awaiting execution on a CPU (to be context switched onto the CPU by the dispatcher, or short-term scheduler). There may be many "ready" processes at any one point of the systems execution - for example, in a one processor system, only one process can be executing at any one time, and all other "concurrently executing" processes will be waiting for execution.

[edit] Running

(Also called active or executing.) A "running", "executing" or "active" process is a process which is currently executing on a CPU. From this state the process may exceed its allocated time slice and be context switched out and back to "ready" by the operating system, it may indicate that it has finished and be terminated or it may block on some needed resource (such as an input / output resource) and be moved to a "blocked" state.

[edit] Blocked

(Also called sleeping.) Should a process "block" on a resource (such as a file, a semaphore or a device), it will be removed from the CPU (as a blocked process cannot continue execution) and will be in the blocked state. The process will remain "blocked" until its resource becomes available, which can unfortunately lead to deadlock. From the blocked state, the operating system may notify the process of the availability of the resource it is blocking on (the operating system itself may be alerted to the resource availability by an interrupt). Once the operating system is aware that a process is no longer blocking, the process is again "ready" and can from there be dispatched to its "running" state, and from there the process may make use of its newly available resource.

[edit] Terminated

A process may be terminated, either from the "running" state by completing its execution or by explicitly being killed. In either of these cases, the process moves to the "terminated" state. If a process is not removed from memory after entering this state, this state may also be called zombie.

[edit] Additional process states

Two additional states are available for processes in systems that support virtual memory. In both of these states, processes are "stored" on secondary memory (typically a hard disk).

[edit] Swapped out and waiting

(Also called suspended and waiting.) In systems that support virtual memory, a process may be swapped out, that is removed from main memory and placed in virtual memory by the mid-term scheduler. From here the process may be swapped back into the waiting state.

[edit] Swapped out and blocked

(Also called suspended and blocked.) Processes that are blocked may also be swapped out. In this event the process is both swapped out and blocked, and may be swapped back in again under the same circumstances as a swapped out and waiting process (although in this case, the process will move to the blocked state, and may still be waiting for a resource to become available).

[edit] References

Stallings, William (2005). Operating Systems: internals and design principles (5th edition). Prentice Hall. ISBN 0-13-127837-1.

Particularly chapter 3, section 3.2, "process states", including figure 3.9 "process state transition with suspend states"

Retrieved from "http://en.wikipedia.org/wiki/Process_states"

5. 매크로 함수

Fri, 10 Oct 2008 19:48:38 +0900

5. 매크로 함수

#define과 같이 선행처리기를 이용해서 간단한 함수 같은 것들은 아래와 같은 형식으로 코드를

작성 할 경우가 있다.

#include<stdio.h>
...
#define #define MAX(a, b) ( (a) > (b) ? (a) : (b) )
...

C++에서는 위의 형식보다는 inline함수를 이용하면 되지만, 만약 C/C++에서 위 코드를 사용할

경우 조금은 문제점이 생긴다. 아래의 코드를 살펴 보도록 하자.

#include<stdio.h>
#define #define MAX(a, b) ( (a) > (b) ? (a) : (b) )
int main(int argc, char** argv)
{
int a = 5, b = 0;
printf("%d %d\n", a, MAX(++a, b));
return 0;
}

위의 코드를 보고 출력결과를 예상해 보도록 하자. 코드를 작성하는 입장에서는 a변수가 한번만 증가

하는 것을 생각하고 했지만, 출력을 해보면 알 수 있듯이 a값은 7이 나오게 된다.

즉 보통 증감연산자를 사용하지 않고 매크로함수를 사용할 경우에는 무리 없이 사용해도 되지만, 위와

같은 경우에는 의도한 것과는 다른 결과가 나올 수 있기 때문에 주의하도록 하자.

참고. windbg 설치 및 vmware를 통한 디버그 환경 구축

Mon, 06 Oct 2008 20:52:44 +0900

Windbg 설치 및 설정

이곳에서는 vmware상에 설치가 되어있는 WindowsXP Operating System에 대한 디버깅을 가능하게 해주는

Windbg 설치 및 vmware 설정 방법을 설명한다.

Windgb 다운로드

Windbg는 마이크로소프트 홈페이지에서 다운로드를 할 수 있다. 아래의 링크로 이동해서 최신버전의 Windbg

를 다운받도록 하자.

http://www.microsoft.com/whdc/devtools/debugging/installx86.mspx

추가적으로 해당 Symbol을 Link해주어야 하는데 Windbg상에서 Web을 통해서도 가능하나 다운로드해서 설정을

하도록 하겠다. 아래의 링크로 가면 Windows 버전(서비스팩 버전포함)에 따른 각각의 다운로드 링크를 제공하니

디버깅할 Target OS의 버전을 확인 후 다운로드해 설치하도록 하자. 설치할때는 기본적으로 C:\WINDOWS\Symbol

경로에 설치가 되며, 이후 Windbg 설치 후 위의 경로로 설정을 해주면 된다. 다른 경로로 설정을 해주어도 되지만

그렇게 할 경우 Windbg 심볼경로 설정을 위해서 해당 위치를 기억을 해두도록 하자.

http://www.microsoft.com/whdc/DevTools/Debugging/symbolpkg.mspx

위 두가지를 모두 다운로드 했으면 각각을 설치하도록 하자.

vmware 설정

Windbg를 통해서 디버깅을 하려면 우선 vmware에 설치된 Windows OS의 boot.ini 파일을 조금 수정을 해주어야 된다.

기존의 boot.ini 파일에서 [operating systems]항목을 수정해주면 된다. 해당 항목을 다음과 같이 수정해주도록 하자.

만약을 위해서 기존의 boot.ini 파일은 백업~해주는 센스~

[boot loader]
timeout=30
default=multi(0)disk(0)rdisk(0)partition(1)\WINDOWS
[operating systems]
multi(0)disk(0)rdisk(0)partition(1)\WINDOWS="Microsoft Windows XP Professional Debug" /debugport=com1 /baudrate = 115200

설정 후 vmware [VM] - [Setting]으로 이동해서 아래의 항목을 추가하도록 하자. 표시가된 부분이 설정을 해야 할

부분이다.

Windbg 설정

Windgb 바로가기 아이콘에서 [속성] - [바로가기] Tab으로 이동 후 [대상] 항목을 아래와 같이 변경을 해주도록 하자

알겠지만 port의 경로를 보면 vmware에서 Use named pipe의 경로와 동일하다는 것을 알 수 있다.

Symbol Link

설치 및 설정을 모두 끝낸 후 vmware를 시작한 후 Windbg를 동작시키게 되면 연결이 되는 것을 확인할 수 있다.

이후 Windgb [File] - [Symbolic File Path]에서 해당 이전에 설치한 Symbol의 경로를 설정해주도록 하자.

설정후 [Debug] - [Break]를 하면 vmware상에서 Windows는 정지가 되고 Windbg에서 Symbol들이 로딩이 되는

것을 확인 할 수 있다.

이제 Driver 코드에서 커널 디버그 함수인 DbgPrint함수를 삽입하고 드라이버 코드를 로딩하면 해당 위치에서 Windbg상에

디버그 메시지가 출력이 되는 것을 확인을 할 수 있다.

참고. 커널 모드 드라이버 수동 설치

Mon, 06 Oct 2008 17:41:40 +0900

커널 모드 드라이버 수동으로 설치하기

다음은 Non-WDM 드라이버의 경우에서 드라이버가 로드되기 전에 준비해야 할 사항을 설명한 것이다.

작성한 드라이버 코드를 컴파일하면 *.sys 드라이버 파일이 생성이 된다. 이 드라이버 파일을 설치(수동)하려면 다음 단계가

필요하다.

해당 드라이버 파일을 Windows 디렉토리에 복사 (\Windows\System32\Drivers)
Non-WDM 드라이버의 경우 드라이버가 로드되기 전에 적절한 항목을 기록해야된다. 아래의 내용을 입력후 *.reg 파일로 저장

REGEDIT4
[HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\드라이버명] //.sys 확장자를 뺀 이름
Start"=dword:3
"Type"=dword:1
"ErrorControl"=dword:1
"DisplayName"="[NAME]" //Computer Management Console에 보여지는 이름

위의 형식으로 입력을 하면 되며 각각의 항목의 내용은 다음과 같으며, 각각의 값은 DWORD Type으로 기술되어야 한다.

Start : 드라이버가 로딩이 되는 시점 (부팅 or 동적)
Type : 드라이버의 일반적인 형태 (Kernel Mode or File System)
ErrorControl : 에러 보고 방법

위의 사항을 적용 후 컴퓨터를 재부팅하면 적용이 되는 것을 확인 할 수 있다.

참고. Protected-Mode Memory Management

Sat, 04 Oct 2008 02:48:32 +0900

Protected-Mode Memory Management

여기서는 Intel 64 / IA-32 구조에서 Protected Mode 상에서의 Memory 관리에 대한 방법(세그멘테이션,

페이징)에 대해서 알아보도록 한다.

Memory Management

IA-32 아키텍쳐에서 메모리 관리 방법은 아래의 두가지로 나누어 볼 수 있으며, Protected Mode에서

Segmentation을 필수적으로 사용을 해야되며, Paging에 대해서는 선택적으로 사용이 가능하다.

Segmentation
- 하나의 processor에서 동작하는 하나 이상의 Program에서 각 Program이 다른 Program에게 간섭을
  
  받지 않도록 보호된다.
Paging
- Program의 실행 영역에서 demand-paged, virtual-memory system에 대한 구현 방법을 제공
- 각 Task의 isolation을 보장

Segmentation

Segmentation은 processor의 메모리 주소 지정 공간(선형주소)을 Segment라는 보호되는 작은 주소공간

으로 나누는 것을 말하며, Program의 code, data, stack 영역 또는 System Data(TSS, LDT)를 보호 할 수

있게 해준다.

만약 Processor에서 하나 이상의 Program(또는 Task)가 동작이 되고 있다면, 각각의 Program은 자신의

Segment 집합을 할당을 받게 되며, 이 Segment 영역은 다른 Program으로 부터 이 해당 영역이 조작

되는 것을 processor로 부터 보호 받게된다.

System에서의 모든 Segment들은 processor의 선형 주소공간(linear address space)에 포함이 되며,
각 Segment에서 byte 위치는 논리주소(logical address)형식으로로 제공이 된다.

논리주소(logical address)는 세그먼트를 식별할 수 있게 하는 세그먼트 셀렉터와 오프셋으로 이루어지며,

세그먼트의 속성을 나타내는 세그먼트 디스크립터의 내용과 오프셋을 통해서 구할 수 있다.

각각의 세그먼트들은 세그먼트 디스크립터를 가지며 이곳에는 세그먼트의 크기, 접근권한, Segment Type

위치 등이 기술이 되어있다.

주소지정에 대한 것은 아래의 그림과 03 Protected 주소 지정 을 참고하자.

Paging

페이징이란 프로그램 중 자주 사용되지 않는 부분의 작업 메모리를 주기억장치인 메모리로부터 보조기억장치인
하드디스크로 옮기는 방식을 통해, 활용 가능한 메모리 공간을 증가시키기 위한 기법 중 하나이다. 이때, 한번에
옮겨지는 메모리 용량 단위를 페이지라 부른다.

메모리 관리장치는 메모리 접근 요청들을 감시하고, 또한 각 주소를 페이지 번호와 페이지 내의 오프셋으로 분할한다.
메모리 관리장치는 페이지 표에 있는 페이지 번호를 확인하는데, 페이지 표에는 해당 페이지가 메모리에서 디스크로
옮겨졌는지 또는 메모리에 아직 존재하는지에 관한 정보들이 표시되어 있다.

만약 메모리에 존재하는 페이지에 대해 접근하려는 시도가 있는 경우라면, 가상의 주소가 실제 주소로 번역된 후 접근이
즉시 허용된다. 그러나 요청된 페이지가 이미 디스크로 옮겨진 상태라면, 먼저 메모리에 현존하는 다른 페이지를 디스크로
옮겨서 빈 공간을 만들어야만 한다.
그다음 디스크의 스왑 공간 상에 있던 해당 페이지가 주기억장치인 메모리로 읽혀 들여진다. 이때 그 페이지가 이제는 주기억
장치 내에 존재한다는 표시와 함께 메모리 상의 물리적인 주소 등 페이지 표의 정보도 함께 갱신된다.

메모리 관리장치는 주기억장치로 불려 들어온 이후에 내용이 수정된 페이지가 어떤 페이지인지에 관한 정보 기록도 유지한다.
만약 수정이 된 적이 없고 디스크로 복사할 필요가 없는 페이지는 즉시 재사용될 수 있다.

스와핑이 여러 개의 프로세스들이 동시에 실행될 수 있게 해주는 것임에 반하여, 페이징은 모든 작업들을 수행하기 위해 필요한
메모리 소요량의 합이 메모리의 실제 크기를 넘어서더라도 작업이 가능하도록 해준다.
< 원문: http://www.terms.co.kr/paging.htm >