[프로세스와 스레드 다중 처리] 프로세스 간 통신 (IPC) with 파일 디스크립터 기반 (PIPE, FIFO)

<서영진 님의 사물인터넷을 위한 리눅스 프로그래밍 with 라즈베리파이 서적을 참고해서 작성하였습니다 :-)>

 

⭐ IPC (Inter-Process Communication)

프로세스 간 통신을 위한 기법

 

☑️ 파일 시스템

프로세스 간에 버퍼 용도의 사용할 수 있는 파일을 생성하고, 다수의 프로세스가 한 파일을 경유하는 방법으로 파일에 입출력 작업을 수행해서 서로 데이터를 공유할 수 있다

 

운영체제에 따라 쓰기 용도로는 하나의 프로세스만 파일을 열 수 있기 때문에, 어떤 프로세스가 파일을 이용하고 있는지 확인하는 절차가 필요하다

파일 시스템은 입출력 다중화 시 문제 해결이 어렵다

파일 입출력 시 빈번한 시스템 호출이 발생한다

 

구분	내용
파일 디스크립터 기반의 IPC	파이프와 FIFO(단반향), 소켓(양방향)
유닉스 시스템의 V의 IPC	메시지 큐, 세마포어, 공유 메모리
POSIX의 IPC	메시지 큐, 네임드 세마포어, mmap(공유 메모리)

파이프는 부모 프로세스와 자식 프로세스 사이에서만 통신이 가능

FIFO, 소켓, 메시지 큐, 공유 메모리는 서로 관계없는 프로세스 사이에서 통신이 가능함

 

☑️ 파이프 (pipe)

유닉스의 프로세스 간의 단방향 통신 메커니즘

ps aux | more

 

통신을 위한 파일 버퍼는 커널 내에 존재하는 버퍼로서 보통 4KB 이상의 크기를 가지고 있다

파이프는 단방향이라 쌍방향 통신을 위해서 2개의 파이프가 필요하다

 

pipe() 함수로 파이프를 생산하며, 2개의 파일 디스크립터에 대한 배열을 인자로 사용한다

파이프는 부모 프로세스와 자식 프로세스 사이의 통신을 위해 사용되는데, 자식 프로세스의 파일 디스크립터 상속으로 IPC 채널의 조인 문제를 해결할 수 있다

부모 프로세스에서 파이프를 생성하고 fork() 수행 시 파일 디스크립터 상속 메커니즘에 의해서 자식 프로세스에게도 같은 파이프를 상속할 수 있다

부모 프로세스와 자식 프로세스에서는 파이프의 방향을 결정한 후 필요 없는 파일 디스크립터를 닫고 나머지 파일 디스크립터로 통신한다

---

pipe() 함수를 이용해 파이프를 먼저 생성한 후 fork() 함수를 이용해서 자식 프로세스를 생성한다
자식 프로세스에서 부모 프로세스로 현재 시간에 대한 메시지를 보낸다
자식 프로세스에서는 읽기를 위한 파일 디스크립터를 pfd[0] 로 설정한 후 이를 닫았고,
부모 프로세스에서는 쓰기를 위한 파일 디스크립터로 pfd[1] 로 설정한 후 닫았다

자식 프로세스의 pfd[1] 을 통해서 메시지를 보내면 부모 프로세스의 pfd[0] 을 통해서 메시지를 받을 수 있다

ls 나 data 명령어의 출력 결과는 표준 출력 (stdout) 통해서 출력된다
표준 출력으로 출력되는 내용을 프로그램 내에서 입력으로 사용하기 위해서는 표준 출력을 다른 파일 디스크립터로 돌리고
이 파일 디스크립터를 사용하면 된다 (유닉스에서 dup, dup2() 함수를 제공함)

date 명령어를 수행하면 표준 출력으로 출력되는 내용이 자식 프로세스의 파일 디스크립터 pfd[1] 으로 들어가서 파이프를 통해서
부모 프로세스의 파일 디스크립터 pfd[0] 에 전달된다
파일 디스크립터 pfd[0] 을 읽으면 자식 프로세스에서 보낸 메시지를 읽을 수 있다
파이프의 통신을 위한 작업이 완료되면 해당 파일 디스크립터를 닫아주면 된다

// 파이프를 생성해서 자식 프로세스와 부모 프로세스 사이에서 간단히 메시지를 전달하는 프로그램
#include <stdio.h> 		/* printf( ) 함수를 위해 사용 */
#include <unistd.h>
#include <sys/wait.h> 		/* waitpid() 함수를 위해 사용 */

int main(int argc, char **argv)
{
    pid_t pid;
    int pfd[2];
    char line[BUFSIZ]; 		/* <stdio.h> 파일에 정의된 버퍼 크기로 설정 */
    int status;

    if(pipe(pfd) < 0) { 	/* pipe( ) 함수를 이용해서 파이프 생성 */
        perror("pipe()");
        return -1;
    }

    if((pid = fork()) < 0) { 	/* fork( ) 함수를 이용해서 프로세스 생성 */
        perror("fork()");
        return -1;
    } else if(pid == 0) { 	/* 자식 프로세스인 경우의 처리 */
        close(pfd[0]); 		/* 읽기를 위한 파일 디스크립터 닫기 */
        dup2(pfd[1], 1); 	/* 쓰기를 위한 파일 디스크립터를 표준 출력(1)으로 변경 */
        execl("/bin/date", "date", 0); 		/* date 명령어 수행 */
        close(pfd[1]); 		/* 쓰기를 위한 파일 디스크립터 닫기 */
        _exit(127);
    } else { 			/* 부모 프로세스인 경우의 처리 */
        close(pfd[1]); 		/* 쓰기를 위한 파일 디스크립터 닫기 */
        if(read(pfd[0], line, BUFSIZ) < 0) { 	/* 파일 디스크립터로부터 데이터 읽기 */
            perror("read()");
            return -1;
        }
        printf("%s", line); 	/* 파일 디스크립터로부터 읽은 내용을 화면에 표시 */
        close(pfd[0]); 		/* 읽기를 위한 파일 디스크립터 닫기 */
        waitpid(pid, &status, 0); 		/* 자식 프로세스의 종료를 기다리기 */
    }

    return 0;
}

/*
pipe() 함수를 이용해 파이프를 먼저 생성한 후 fork() 함수를 이용해서 자식 프로세스를 생성한다
자식 프로세스에서 부모 프로세스로 현재 시간에 대한 메시지를 보낸다
자식 프로세스에서는 읽기를 위한 파일 디스크립터를 pfd[0] 로 설정한 후 이를 닫았고,
부모 프로세스에서는 쓰기를 위한 파일 디스크립터로 pfd[1] 로 설정한 후 닫았다

자식 프로세스의 pfd[1] 을 통해서 메시지를 보내면 부모 프로세스의 pfd[0] 을 통해서 메시지를 받을 수 있다

ls 나 data 명령어의 출력 결과는 표준 출력 (stdout) 통해서 출력된다
표준 출력으로 출력되는 내용을 프로그램 내에서 입력으로 사용하기 위해서는 표준 출력을 다른 파일 디스크립터로 돌리고
이 파일 디스크립터를 사용하면 된다 (유닉스에서 dup, dup2() 함수를 제공함)

date 명령어를 수행하면 표준 출력으로 출력되는 내용이 자식 프로세스의 파일 디스크립터 pfd[1] 으로 들어가서 파이프를 통해서
부모 프로세스의 파일 디스크립터 pfd[0] 에 전달된다
파일 디스크립터 pfd[0] 을 읽으면 자식 프로세스에서 보낸 메시지를 읽을 수 있다
파이프의 통신을 위한 작업이 완료되면 해당 파일 디스크립터를 닫아주면 된다

@gani0325 ➜ /workspaces/IoT_Linux_RaspberryPi/Process_Signal (main) $ gcc -o pipe pipe.c
@gani0325 ➜ /workspaces/IoT_Linux_RaspberryPi/Process_Signal (main) $ ./pipe
*/

gcc -o pipe pipe.c
./pipe

 

☑️ FIFO

파이프와 유사한 단방향 통신

FIFO 파일을 사용해서 IPC 채널의 조인 문제를 해결한다 ( = 네임드 파이프 Named Pipe )

 

FIFO 사용하기 위해서는 채널 역할을 하는 FIFO 파일을 생성하는데, 이 파일은 데이터 전송에서 사용되는 것이 아니라 프로세스 간 채널을 확립하기 위해서만 사용된다

서버 프로세스나 클라이언트 프로세스는 각자 동일한 FIFO 파일을 열고, 얻은 파일 디스크립터를 이용해서 통신한다

 

mkfifo() 함수를 이용해서 FIFO 파일을 생성하고, open() 함수 호출 후 반환되는 파일 디스크립터를 이용해서 read() 나 write() 함수로 통신을 수행하면 된다 

// FIFO 사용하기 위한 Server
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h> 			/* read(), close(), unlink() 등의 시스템 콜을 위한 헤더 파일 */
#include <sys/stat.h>

#define FIFOFILE "fifo"

int main(int argc, char **argv)
{
    int n, fd;
    char buf[BUFSIZ];
    unlink(FIFOFILE); 			/* 기존의 FIFO 파일을 삭제한다. */

    if(mkfifo(FIFOFILE, 0666) < 0) { 	/* 새로운 FIFO 파일을 생성한다. */
        perror("mkfifo()");
        return -1;
    }

    if((fd = open(FIFOFILE, O_RDONLY)) < 0) { 		/* FIFO를 연다. */
        perror("open()");
        return -1;
    }

    while((n = read(fd, buf, sizeof(buf))) > 0) 	/* FIFO로부터 데이터를 받아온다. */
        printf("%s", buf); 		/* 읽어온 데이터를 화면에 출력한다. */

    close(fd);

    return 0;
}

/*
FIFO 서버는 FIFO 통신을 위한 파일을 생성하고 FIFO 파일을 연 후, 클라이언트에서 데이터가 오면 읽어서 화면에 출력한다
FIFO 서버는 백그라운드 모드로 실행한 후 FIFO 클라이언트를 실행한다
FIFO 클라이언트에서 입력해서 보낸 내용이 서버를 통해서 화면에 표시된다
Ctrl+C 눌러서 클라이언트 실행을 종료하면 FIFO 가 깨지기 때문에 서버도 종료된다

@gani0325 ➜ /workspaces/IoT_Linux_RaspberryPi/Process_Signal (main) $ gcc -o fifo_server fifo_server.c 
@gani0325 ➜ /workspaces/IoT_Linux_RaspberryPi/Process_Signal (main) $ ./fifo_server &
*/

// FIFO 사용하기 위한 Client
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

#define FIFOFILE "fifo"

int main(int argc, char **argv)
{
    int n, fd;
    char buf[BUFSIZ];

    if((fd = open(FIFOFILE, O_WRONLY)) < 0) { 		/* FIFO를 연다. */
        perror("open()");
        return -1;
    }

    while ((n = read(0, buf, sizeof(buf))) > 0) 	/* 키보드로부터 데이터를 입력받는다 */
        write(fd, buf, n); 				/* FIFO로 데이터를 보낸다. */

    close(fd);

    return 0;
}

/*
FIFO 파일을 연 후 키보드로부터 데이터를 읽어서 서버에게로 해당 데이터를 출력한다

@gani0325 ➜ /workspaces/IoT_Linux_RaspberryPi/Process_Signal (main) $ gcc -o fifo_client fifo_client.c 
@gani0325 ➜ /workspaces/IoT_Linux_RaspberryPi/Process_Signal (main) $ ./fifo_client
*/

gcc -o fifo_server fifo_server.c
./fifo_server &

gcc -o fifo_client fifo_client.c
./fifo_client
-> message enter