C: IPC

IPC(Inter-Process Cmmuniciation)는 프로세스들 사이에 데이터를 주고받는 행위, 그에 대한 방법 또는 경로를 의미한다.

 

pipe의 종류

pipe vs named pipe

 pipe는 위의 그림과 같이 프로세스에 따라 write, read를 할 수 있다. 또한 관련된 프로세스가 사용하는 pipe와 관련 없는 프로세스 간에도 사용 가능한 named pipe로 나뉜다.

 

pipe

int process_pipe(pid_t pid, int *pipe_p, char *buf)
{
    int status;
    
    if (pid == 0) {
    	/* child process */
        close(pipe_p[1]);
        read(pipe_p[0], buf, sizeof(buf));
        printf("%d get msg %s\n", pid, buf);
        close(pipe_p[0]);
        return 0;
    } else if (pid > 0) {
    	/* parent process */
        close(pipe_p[0]);
        strncpy(buf, "input some data...", sizeof(buf) - 1);
        printf("%d send msg %s\n", pid, buf);
        write(pipe_p[1], buf, strlen(buf));
        close(pipe_p[1]);
        pid = wait(&status);
        return 0;
    }
    
    return -1;
}

•  pipe 디스크립터 0번은 read, 1번은 write이다.
• 위의 예시는 부모 프로세의 경우 write를 하고, 자식 프로세스는 read를 한다.
• 연관된 프로세스, 즉 pipe 디스크립터를 알고 있는 프로세스 끼리 상호 간의 정보를 교환할 수 있다.

 

named pipe

#define FILENAME	"./test"

static int reader()
{
    int fd;
    char buf[128];
    
    unlink(FILENAME);
    
    fd = open(FILENAME, O_RDONLY);
    
    if (fd < 0) {
    	perror("open()");
        return -1;
    }
    
    read(fd, buf, sizeof(buf));
    close(fd);
    
    return 0;
}

static int writer()
{
    int fd;
    char buf[128];
    
    unlink(FILENMAE);
    
    if (mkfifo(FILENAME, 0644)) {
    	perror("mkfifo()");
        return -1;
    }
    
    fd = open(FILENAME, O_WRONLY);
    
    if (fd < 0) {
    	perror("open()");
        return -1;
    }
    
    strcpy(buf, "test write", sizeof(buf));
    write(fd, buf, strlen(buf));
    close(fd);
    
    return 0;
}

named pipe는 파일에 접근 가능한 경우, 프로세스 간의 정보를 공유할 수 있다. 주의할 점은 open에 O_NONBLOCK flag를 설정하지 않으면, 양방향(read/write)으로 열릴 때 blocking 된다는 점이다.

 

Message Queue

메시지 큐는 위 표와 같이 SysV와 POSIX 방식으로 나뉜다.

• POSIX 방식은 File I/O 기반으로 동작하므로, I/O Multiplexing이 가능하다.
• SysV는 메시지 타입을 구분하므로, 하나의 write와 다수의 reader로 사용 가능하다.
• pipe와 달리 byte stream이 아닌 메시지 단위로 처리 된다.
• FIFO로 처리되며, MQ에 접근 가능하다면 연관이 없는 프로세스도 사용 가능하다.

 

#define MQ_NAME "/test_mq"
// MQ 이름은 /로 시작하여야 함.
#define BUF_SIZE 8192
 
static int init_mq()
{
    mqd_t mqd;
    struct mq_attr attr;
 
    mqd = mq_open(MQ_NAME, O_RDWR | O_CREAT, 0644, NULL);
 
    if (mqd == -1) {
        perror("mq_open()");
        return -1;
    }
 
    memset(&attr, 0, sizeof(attr));
    if (mq_getattr(mqd, &attr) == -1) {
        close(mqd);
        return -1;
    }
 
    return mqd;
}
 
static int sender()
{
    int mqd = init_mq();
    char buf[BUF_SIZE];
 
    if (mqd == -1) {
        perror("init_mq()");
        return -1;
    }
 
    memset(buf, 0, sizeof(buf));
    sprintf(buf, sizeof(buf), "TEST...");
 
    if (mq_send(mqd, buf, sizeof(buf), 0) == -1) {
        perror("sender()");
        return -1;
    }
 
    return 0;
}
 
static int receiver()
{
    int mqd;
    char buf[BUF_SIZE];
 
    mqd = init_mq();
     
    if(mqd == -1) {
        perror("init_mq()");
        return -1;
    }
 
    memset(buf, 0, sizeof(buf));
     
    if (mq_receive(mqd, buf, sizeof(buf), NULL) == -1) {
        perror("receiver()");
        return -1;
    }
 
    printf("recv msg %s\n", buf);
 
    return 0;
}

POSIX MQ를 사용하는 방식을 간단히 구현하면 위와 같다.

• MQ 관리에 관련된 함수는 mq_open, mq_close, mq_unlink가 있다.
• 송수신을 위해서는 mq_send, mq_receive를 사용한다.
• 이 외에 mq_setarr, mq_getarr, mq_notify가 있다.
• mq_open, mq_send, mq_receive를 사용하기 위해서는 struct mq_attr을 매개변수로 사용한다.
• 만약 MQ에 내용이 없는데 receive를 하게 되면 blocking 된다.
• 사용되는 MQ는 `/dev/mqueue`의 하위 디렉토리에 생성된다.

 

Socket

 도메인을 통해 소켓을 구분하며, 3가지로 정의할 수 있다.

1. Unix Domain Socket
   • Host-only socket
   • file path를 address로 사용한다.
2. IPv4 Socket
3. IPv6 Socket

 

Socket type

  Socket의 타입은 2가지로 구분된다.

• Stream
  • 양방향으로 연결(Connect-Orient)되어야 한다.
  • 전송 단위는 byte stream이다.
  • TCP의 특성을 가진다고 생각하면 된다.
  • 그림 상에서 보면 Socket 생성 후, 연결 과정이 필요하다.
• Datagram
  • 상호 연결(Connectionless)되지 않아도 된다.
  • 전송 단위는 Message이다.
  • UDP의 특성을 가진다고 생각하면 된다.
  • 그림 상에서 보면, Socket 생성 후, 별도의 연결 과정이 필요 없다.

 

Server side

// Socket(Stream) Server Side
#define SOCK_PATH "test"
 
int receiver(int sock, void *buf, size_t buflen, int flag)
{
    int ret;
    int cur_read = 0;
 
    while (cur_read < buflen) {
        ret = recv(sock, (char *)buf + cur_read, buflen, flag);
 
        if (ret == -1) {
            return ret;
        }
 
        cur_read += ret;
    }
 
    return 0;
}
 
static int server()
{
    int sock;
    int peer;
    int ret;
    struct sockaddr_un addr;
    char buf[1024];
 
    sock = socket(AF_UNIX, SOCK_STREAM, 0);
 
    if (sock == -1) {
        perror("socket()");
        return -1;
    }
 
    /* addr init */
    memset(&addr, 0, sizeof(addr));
    addr.sun_familiy = AF_UNIX;
    strncpy(addr.sun_path, SOCK_PATH, sizeof(addr.sun_path) - 1);
 
    if bind(sock, (struct sockaddr *)&addr, sizeof(struct sockaddr_un) == -1) {
        perror("bind()");
        goto err;
    }
 
    listen(sock, 3);
 
    peer = accept(sock, NULL, NULL);
    if (peer < 0) {
        perror("accept()");
        goto err;
    }
 
    ret = receiver(peer, buf, sizeof(buf), 0);
 
    if (ret == -1) {
        perror("recv()");
        goto err;
    }
 
    printf("from to client %s\n", buf);
 
    close(sock);
     
    return 0;
 
err:
    close(sock);
    return -1;
}

 

Host side

// Socket(Stream) Client Side
#define SOCKET_PATH "test"
 
int sender(int sock, void *buf, size_t buflen, int flag)
{
    int ret;
    int cur_write = 0;
     
    while (cur_write < buflen) {
        ret = send(sock, (char *)buf + cur_write, buflen, flag);
 
        if (ret == -1) {
            return ret;
        }
 
        cur_write += ret;
    }  
 
    return 0;
 
}
 
static int client()
{
    int sock;
    int ret;
    char buf[64];
    struct sockaddr_un addr;
 
    sock = socket(AF_UNIX, SOCK_STREAM, 0);
    if (sock < 0) {
        perror("socket()");
        return -1;
    }  
 
    /* addr init */
    memset(&addr, 0, sizeof(addr));
    addr.sun_family = AF_UNIX;
    strncpy(addr.sun_path, SOCK_PATH, sizeof(addr.sun_path) - 1);
 
    if (connect(sock, (struct sockaddr *)&addr, sizeof(struct sockaddr_un)) == -1) {
        perror("connect()");
        goto err;
    }  
 
    memset(buf, 0, sizeof(buf));
    sprintf(buf, sizeof(buf), "Send TEST..");
    ret = sender(sock, buf, sizeof(buf), 0);
 
    if (ret < 0) {
        perror("send()");
        goto err;
    }  
 
    close(sock);
 
    return 0;
 
err:
    close(sock);
    return -1;
}

 

Shared Memory

pipe, MQ, Socket은 데이터를 전달하여 프로세스 간의 정보를 주고받는 형식이다. 이와 달리 SHM은 프로세스 간 메모리 영역을 공유하여 데이터를 주고받는다.

 

file mapping

#define FILE_NAME "test"
 
static int prosumer()
{
    int fd;
    int *maped;
    int i;
     
    fd = open(FILE_NAME, O_RDWR | O_CREATE, 0644);
     
    if (fd == -1) {
        perror("open()");
        return -1;
    }
     
    // 파일을 생성하여야 하므로 fruncate를 호출.
    if (ftruncate(fd, 4096) == -1) {
        perror("fruncate()");
        goto err;
    }
     
    maped = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
     
    if (maped == MAP_FAILED) {
        perror("mmap()");
        goto err;
    }
     
    for (i = 0; i < 100; i++) {
        maped[i] = i + 1;
    }
     
    munmap(maped, 4096);
    close(fd);
    
    return 0;
err:
    close(fd);
    return -1;
}

#define FILE_NAME "test"
 
static int consumer()
{
    int fd;
    int maped;
    int i;
     
    fd = open(FILE_NAME, O_RDWR);
     
    if (fd == -1) {
        perror("open()");
        return -1;
    }
     
    maped = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
     
    if (maped == MAP_FAILED) {
        perror("mmap()");
        close(fd);
        return -1;
    }
     
   for (i = 0; i < 100; i++) {
        printf("%d\n", maped[i]);
    }
     
    munmap(maped, 4096);
    close(fd);
}

 위의 코드는 mmap을 통해 동일한 파일을 2개의 프로세스의 메모리 공간에 할당하는 것이다.

• prosumer
  • 파일을 생성하여야 하므로, open 후 ftruncate를 호출한다.
  • mmap에 성공하면, 값을 기록하여 다른 프로세스에서 사용할 수 있도록 한다.
• consumer
  • 파일 생성이 필요 없고, open을 통해 접근하면 된다.
  • mmap에 성공하면, 값을 읽어 온다.
• mmap을 통해 메모리를 할당하는 경우, munmap을 통해 할당 해제해주어야 한다.

 

SysV SHM

 둘 이상의 프로세스가 특정한 메모리 영역을 공유하는 것을 말한다. 메모리 영역에 동시에 접근하는 경우, 데이터의 일관성이 보장되지 않을 수 있으므로 동기화가 필요하다.

(아래의 코드들은 별도의 동기화 과정이 필요 없는 코드이다.)

 

#define SHMKEY "test"
 
static int prosumer()
{
    int fd;
    key_t key;
    int *maped;
    int i;
 
    key = ftok(SHMKEY, SHMKEY_PROJID);
 
    if (key == -1) {
        perror("ftok()");
        return -1;
    }
 
    shm_id = shmget(key, 4096, IPC_CREAT | 0644);
     
    if (shm_id == -1)
    {
        perror("shmget()");
        return -1;
    }
 
    maped = shmat(shm_id, NULL, 0);
    if (maped == (void *)-1) {
        perror("shmat()");
        return -1;
    }
 
    for (i = 0; i < 100; i++) {
        maped[i] = i + 1;
    }
 
    shmdt(maped);
     
    return 0;
}

#define SHMKEY "test"
 
static int prosumer()
{
    int fd;
    key_t key;
    int *maped;
    int i;
 
    key = ftok(SHMKEY, SHMKEY_PROJID);
 
    if (key == -1) {
        perror("ftok()");
        return -1;
    }
 
    shm_id = shmget(key, 4096, IPC_CREAT | 0644);
     
    if (shm_id == -1)
    {
        perror("shmget()");
        return -1;
    }
 
    maped = shmat(shm_id, NULL, 0);
    if (maped == (void *)-1) {
        perror("shmat()");
        return -1;
    }
 
    for (i = 0; i < 100; i++) {
        maped[i] = i + 1;
    }
 
    shmdt(maped);
     
    return 0;
}

 위와 같이 키를 통해, 동일한 메모리 영역에 접근하여 특정 프로세스에 정보를 쓰거나, 읽을 수 있다.

• File mapping과 달리 키를 생성하고 키를 기반으로 SHM을 attach 한다.
• 사용이 끝나면 SHM을 detatch 한다.

 

POSIX SHM

 POSIX SHM의 경우, File mapping과 코드가 유사하다.

• Prosumer의 경우, `fd = shm_open("/test", O_RDWR | O_CREATE, 0644)`로 변경하면 된다.
• Consumer의 경우, `fd = shm_open("/test", O_RDWR)`로 변경하면 된다.
• 위와 같이 코드를 작성하면, SHM이 생성되는 위치는 `/dev/shm/test`가 된다.