[리눅스 시스템 프로그래밍] wait() 시스템 콜

자식 프로세스가 종료될 때 완전히 사라진다면, 부모 프로세스가 참고할 수 있는 정보들이 남지 않는다. 따라서 유닉스의 초기 설계자들은 자식 프로세스가 부모에 앞서 죽으면, 커널이 자식 프로세스를 특수한 프로세스 상태로 들어가게 만들어야 한다고 결정했다. 이런 상태에 있는 프로세스를 좀비라고 한다. 유용할지도 모르는 자료를 포함하는 몇 가지 기본적인 커널자료 구조처럼 프로세스를 지탱하는 최소 뼈대만 보존한다. 부모가 자신의 상태를 조사하도록 이런 특수한 프로세스 상태에 있는 자식 프로세스는 부모 프로세스를 기다린다(이런 자식 프로세스를 좀비 프로세스라고 부른다). 부모가 종료된 자식에 대해 보존된 정보를 획득한 다음에야 공식적으로 자식 프로세스가 종료되고 좀비에서 벗어나게 된다.

위의 프로세스 상태 전이 표에서 우측 상단에서 EXIT_ZOMBIE를 볼 수 있다.

리눅스 커널은 종료된 자식에 대한 정보를 얻기 위한 몇 가지 인터페이스를 제공한다. POSIX에 정의된 가장 단순한 인터페이스로  wait()가 있다.

#include <sys/types.h>

#include <sys/wait.h>

pid_t wait (int *status);

wait()를 호출하면 종료된 자식의 pid를 반환하며, 오류가 발생하면 -1을 반환한다. 자식 프로세스가 종료되지 않았다면 호출은 자식이 종료될 때까지 차단된다. 자식 프로세스가 이미 종료되었으면 호출은 즉시 반환된다. 따라서 SIGCHLD를 받고나서 자식 프로세스가 사망했다는 소식을 접한 다음에 wait()를 호출할 경우 차단(blocking) 없이 즉시 반환된다.

* SIGCHLD - 프로세스가 종료될 때 커널은 SIGCHLD 시그널을 부모에게 보낸다.

오류가 발생하면 다음 두 가지 errno 값 중 하나로 설정된다.

ECHILD 호출한 프로세스에 자식 프로세스가 존재하지 않는다.

EINTR 대기 중에 시그널을 받았으며, 조기에 호출이 반환된다.

NULL이 아닌 status 포인터는 자식에 대한 추가 정보를 포함한다. POSIX는 status에서 확인을 원하는 비트만 정의하도록 구현을 허용하므로, 표준은 이런 매개 변수를 해석하기 위해 매크로 군을 제공한다.

#include <sys/wait.h>

int WIFXITED (status); /* 프로세스가 정상적으로 종료되면 참을 반환. 즉 프로세스가 _exit를 호출한 경우 */

int WIFSIGNALED (status); /* 시그널이 프로세스 종료를 초래했을 경우 참을 반환 */

int WIFSTOPPED (status); /* 프로세스가 중단되거나 */

int WIFCONTINUED (status); /* 진행을 재개할 경우 참을 반환 */

int WEXITSTATUS (status); /* WIFXITED가 참을 반환하면 _exit()로 넘긴 값을 하위 8비트에 담아서 제공 */

int WTERMSIG (status); /* WIFSIGNALED가 참을 반환하면 종료를 초래한 시그널 번호를 반환 */

int WSTOPSIG (status); /* WIFSTOPPED가 참을 반환하면 프로세스를 멈춘 시그널 번호를 제공 */

int WCOREDUMP (status); /* 프로세스가 시그널을 받아서 코어 파일을 만들어낼 경우 참을 반환 */

0이 아닌 값은 참이다.

코어덤프에 대한 내용

http://ko.wikipedia.org/wiki/%EC%BD%94%EC%96%B4_%EB%8D%A4%ED%94%84

자식에게 어떤 일이 일어났는지 파악하기 위해 wait()를 사용하는 예제 프로그램을 살펴보자.

                                                                                                                                  

#include <unistd.h>

#include <stdio.h>

#include <sys/types.h>

#include <sys/wait.h>

int main (void)

{

int status;

pid_t pid;

if (!fork ())         // 호출 성공하면 자식 프로세스는 0을 반환

return 1;            // 자식 프로세스 종료

pid = wait (&status); // status를 설정

if (pid == -1)

perror ("wait");

printf ("pid=%d\n", pid);

if (WIFEXITED (status))

printf ("Normal termination with exit status=%d\n", 

WEXITSTATUS (status));

if (WIFSIGNALED (status))

printf ("Killed by signal=%d%s\n",

WTERMSIG (status),

WCOREDUMP (status) ? " (dumped core)" : "");

if (WIFSTOPPED (status))

printf ("Stopped by signal=%d\n",

WSTOPSIG (status));

if (WIFCONTINUED (status))

printf ("Continued\n");

return 0;

}

                                                                                                                                  

이 프로그램은 자식 프로세스를 fork해서 바로 종료한다. 그리고 나서 부모 프로세스는 wait() 시스템 호출을 수행해서 자식 프로세스 상태를 파악한다. 프로세스는 자식 프로세스 pid와 그것이 어떻게 죽었는지를 출력한다. 이 경우 자식 프로세스는 main()에서 반환되는 방법으로 종료되었기 때문에 다음과 유사한 결과를 얻는다.

                                                                                                                                  

$ ./wait

pid=8520

Normal termination with exit status=1
                                                                                                                                  

프로그래머가 return을 사용하는 대신에 SIGABRT 시그널을 자신에게 보내는 abort()를 호출했을 경우 다음과 유사한 결과를 얻는다.

                                                                                                                                  

$ ./wait

pid=8678

Killed by signal=6
                                                                                                                                  

abort()는 <stdlib.h>에 정의되어 있다.

예제 코드를 다음과 같이 바꾼다.

if (!fork ())

        abort ();

출처 : 리눅스 시스템 프로그래밍, 로버트 러브 지음, 박재호 옮김, 한빛미디어 2009년 펴냄, ISBN: 978-89-7914-679-0 93569

[리눅스 시스템 프로그래밍] 프로세스 종료 (Terminating a Process)

#include <stdlib.h>

void exit (int status);

exit() 호출은 몇 가지 종료 단계를 수행한 다음에 커널에게 프로세스를 종료하라고 지시한다.

status 매개 변수는 프로세스 종료 상태를 지정하기 위해 사용한다.

프로세스를 종료하기에 앞서, C 라이브러리는 다음 종료 단계를 순서대로 수행한다.

1. atexit()나 on_exit()로 등록된 함수를 등록 순서의 역순으로 호출한다.

2. 모든 표준 입출력 스트림을 강제로 비운다.

3. tmpfile() 함수로 만든 임시 파일을 삭제한다.

이런 단계를 거쳐 사용자 영역에서 프로세스가 수행해야 하는 모든 작업을 마쳤다면, exit()는 시스템 콜인 _exit()를 불러 커널이 프로세스 종료 과정에 필요한 나머지 작업을 수행하게 한다.

#include <unistd.h>

void_exit (int status);

어플리케이션에서 _exit()를 직접 호출할 수 있지만, 이런 방식은 거의 의미가 없다. 대다수 어플리케이션은 stdout 스트림을 강제로 쓰는 작업(flushing)과 같이(위의 작업 2.) exit가 제공하는 정리 기능 몇 가지를 요구하기 때문이다.

프로그램을 끝내는 전통적인(classic) 방법은 명시적인 시스템 콜이 아니라 단순히 프로그램 '끝까지 진행하는' 방법이다.  C 프로그램에서는 main() 함수가 반환될 때 이런 일이 일어난다. 하지만 '끝까지 진행하는' 방법에서도 여전히 시스템 콜을 부른다. 컴파일러는 독자적인 종료 코드 다음에 암묵적으로 _exit()를 넣어버린다. exit()나 main() 반환값을 사용해서 종료 상태를 명시적으로 반환하도록 프로그램을 작성하는 관례는 바람직하다. 셸은 종료값을 확인해서 명령이 성공했는지 실패했는지를 파악한다. eixt(0)이거나 main() 반환값이 0이면 성공을 나타낸다.

또한 기본 동작이 프로세스 종료를 의미하는 시그널을 받을 경우 프로세스는 종료한다. (SIGTERM, SIGKILL 같은 시그널)

#include <stdlib.h>

int atexit (void (*function)(void));

atexit() 라이브러리 호출은 프로세스 종료 과정에서 수행할 함수를 등록하기 위해 쓰인다.

atexit() 호출이 성공하면 인수로 넘어온 함수를 정상적인 프로세스 종료 과정 중에 수행하도록 등록한다. 다시 말해, exit() 수행이나 main()에서 반환되어 프로세스가 종료될 때, 등록된 함수가 수행된다. 프로세스가 exec 계열 함수를 수행하면 등록된 함수 목록이 깨끗하게 초기화된다. 프로세스가 시그널을 받고 종료하면 등록된 함수는 호출되지 않는다.

함수는 매개 변수를 받지 않으며, 반환값도 없다. 서식(prototype)은 다음과 같다.

void my_function (void);

함수는 등록 역순으로 수행된다. 다시 말해, 함수는 LIFO 방식으로 스택에 저장된다. 등록된 함수는 exit()를 호출해서는 안 된다. exit()를 호출할 경우 무한 재귀 호출(an endless recursion)이 일어난다.

간단한 예제

                                                                                                                                  

                                                                                                                                  

atexit()와 같은 동작을 하는 on_exit() 함수도 있지만 최신 솔라리스 버전에서는 더 이상 이 함수를 지원하지 않으므로 표준을 따르는 atexit() 함수를 대신 사용해야 한다.

그라데이션

잠이 안와서 결국 일곱시까지 깨있네요... 그래도 오랜만에 이런 멋진 장면도 보네요.

[리눅스 시스템 프로그래밍] fork() ,exec 시스템 콜의 의미(Meaning of fork() and exec system call)

리눅스 커널 공부를 1년 전 쯤에 했다.  fork(), exec 함수군에 대해서 읽어 봤지만 이건 당최 무슨 소리인지 알 수가 없었다. 요즘「리눅스 시스템 프로그래밍(로버트러브 저)」을 읽으니까 이 함수들이 어떤 역할을 하는지 대충 알 것 같다.

시스템 프로그래밍(여기서 의미하는 것은 시스템 콜)을 먼저 공부하고 커널 공부를 했더라면... 하는 생각이 든다. 커널을 공부하기 위해서는 시스템 콜을 어느정도 알고있어야 된다고 생각한다.

1. fork() 시스템 콜은 현재 프로세스와 동일한 이미지로 동작하는 새로운 프로세스를 만든다.
(A new process running the same image as the current one can be created via the fork()
system call)
2. exec 함수군(execl(), execlp(), execle(), execv(), execvp(), execve())을 호출하면 path가 가리키는 프로그램을 메모리에 올리는 방법으로 현재 프로세스 이미지를 새로운 프로세스 이미지로 대체한다.
(A call to execl() replaces the current process image with a new one by loading into
memory the program pointed at by path)

"쓰기 후 복사(COW:copy-on-write)는 fork의 경우 더욱 큰 장점을 제공한다. fork 다음에 exec가 뒤따를 확률이 아주 높으므로 부모 주소 공간을 자식 주소 공간으로 복사하는 행위는 종종 완전한 시간 낭비다. 자식이 즉시 새로운 바이너리 이미지를 실행한다면 이전 주소 공간은 완전히 제거된다. COW는 이런 경우를 위해 최적화를 수행한다."

(Copy-on-write has yet a bigger benefit in the case of forking. Because a large percentage of forks are followed by an exec, copying the parent’s address space into the child’s address space is often a complete waste of time: if the child summarily executes a new binary image, its previous address space is wiped out. Copy-on-write optimizes for this case.)

다음은 fork 다음에 exec가 뒤따르는 코드이다.
(code that fork is followed by an exec)

_________________________________________________________________________________

1  pid_t pid;
2  
3  pid = fork();
4  if (pid == -1)
5   perror ("fork");
6  
7  /* 자식 프로세스 */ /* child process */
8  if (!pid) {
9   const char *args[] = { "windlass", NULL };
10 int ret;
11
12    ret = execv ("/bin/windlass", args);
13 if (ret == -1) {
14 perror ("execv");
15 exit (EXIT_FAILURE);
16 }
17 }
_________________________________________________________________________________

자식 프로세스에서는 fork() 호출이 성공하면 0을 반환한다. 부모 프로세스에서 fork()는 자식 프로세스의 pid를 돌려준다. line 8에서 pid가 0인 것을 검사하고 자식 프로세스의 코드를 실행하는데 자식 프로세스는 0을 반환하기 때문이다.
새로운 자식을 얻었다는 사실을 제외하고는 부모 프로세스는 변함없이 계속해서 돌아간다.  execv()호출은 자식이 /bin/windlass 프로그램을 실행하도록 변경한다.