pipe 동작방식
pipe
Linux pipe는 kernel이 관리하는 buffer를 통해 read end와 write end 사이에 단방향 byte-stream 통신을 제공하는 IPC 기능이다.
writer user buffer
│
│ write(pipefd[1], ...)
▼
kernel pipe
│
│ read(pipefd[0], ...)
▼
reader user buffer
- 데이터는 write end 에서 read end로만 흐른다.
- 여러 프로세스가 endpoint FD를 공유하면 IPC에 사용할 수 있다.
- 커널 내부에 유한한 크기의 버퍼를 갖고 이 버퍼를 통해 데이터를 공유한다.
read()/write()는 user buffer와 kernel pipe page 사이에서 데이터를 복사한다.- fork 등으로 FD가 복사되면 하나의 pipe로 양방향 통신도 가능하겠지만, 간섭이 생길 수 밖에 없는 구조이기에 일반적으로는 pipe를 두개 만들거나
socketpair()를 사용한다.
FD Table
하나의 프로세스 안에서는 fd 를 관리하는 FD table이 있고, fd->(struct file*) 로 연결하기 때문에 같은 fd 값을 통해서 동일한 파일에 접근할 수 있게된다.
read(fd, ...)
│
▼
current task_struct
└─ files ──> struct files_struct
└─ fdt ──> struct fdtable
└─ fd[fd] ──> struct file
├─ f_mode = FMODE_READ
├─ f_op = &pipeanon_fops
├─ private_data = pipe_inode_info
└─ f_inode = pipefs inode
fdtable 구조체 안에는 struct file*와 연결된 fd 배열, fd 관리에 필요한 bitmap 들이 포함된다.
struct fdtable {
unsigned int max_fds;
struct file __rcu **fd; // struct file* fd[]
unsigned long *close_on_exec; // 각 FD의 O_CLOEXEC 값 bitmap
unsigned long *open_fds; // 할당된 FD 번호 bitmap
unsigned long *full_fds_bits;
struct rcu_head rcu;
};
struct file {
fmode_t f_mode; // 읽기용인지 쓰기용인지 표시
unsigned int f_flags; // O_NONBLOCK 같은 상태 flag
const struct file_operations *f_op; // read, write 등의 함수 table
void *private_data; // 파일 종류별 kernel 내부 상태
struct inode *f_inode; // 연결된 inode
loff_t f_pos; // 일반 파일의 현재 offset
file_ref_t f_ref; // dup(), fork() 의 reference count
/* ... */
}
struct file*가 가리키는 실제 구조체는 커널 메모리에 저장되어 있다.
일반적으로 프로세스에서 open() 함수로 파일을 열면 별도의 struct file 구조체가 생성되고 동일한 inode를 가리키게 되지만, 프로세스가 fork() 되거나 dup(), SCM_RIGHTS 로 FD를 공유할 때는 이 테이블 안에있는 포인터가 복사되어 동일한 커널 구조체를 가리키게된다.
fdtable->fd[]
index value
──────────────────────────────
0 struct file* stdin
1 struct file* stdout
2 struct file* stderr
3 struct file* pipe read
4 struct file* pipe write
5 NULL
사용법
pipe() 또는 pipe2()를 호출하면 파라미터로 전달한 배열에 두 개의 파일 디스크립터가 저장되고 read()/write() 함수로 통신이 가능하다.
#include <unistd.h>
int pipe(int pipefd[2]); // flags=0
int pipe2(int pipefd[2], int flags); // O_CLOEXEC, O_NONBLOCK, O_DIRECT
// pipefd[0] = read end
// pipefd[1] = write end
pipe 함수로는 anonymous pipe 가 생성되는데 접근할 수 있는 이름이 없기 때문에 통신할 프로세스들이 파일 디스크립터를 공유해야한다.
fork()이전에 pipe를 생성해서 FD를 상속받도록 한다.SCM_RIGHTS로 endpoint FD 를 전달한다.
mkfifo 로 named pipe도 있지만 파일시스템에 경로 형태로 pipe를 공유할 수 있는 것을 제외하고 동작 방식은 같다.
#include <stdio.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>
int main(void)
{
int pipefd[2];
const char message[] = "Hello from parent";
if (pipe(pipefd) == -1)
return 1;
pid_t pid = fork();
if (pid == -1)
return 1;
if (pid == 0) {
char buffer[128] = {0};
close(pipefd[1]); // 자식은 write end를 사용하지 않아서 바로 닫음
ssize_t length = read(pipefd[0], buffer, sizeof(buffer) - 1);
if (length > 0) {
buffer[length] = '\0';
printf("child received: %s\n", buffer);
}
close(pipefd[0]);
return 0;
}
close(pipefd[0]); // 부모는 read end를 사용하지 않아서 바로 닫음
if (write(pipefd[1], message, sizeof(message) - 1) == -1)
return 1;
close(pipefd[1]);
waitpid(pid, NULL, 0);
return 0;
}
- 출력: “child received: Hello from parent”
pipe의 구조
유저영역에서는 pipefd 두개가 만들어지면서 kernel 내부에서는 두개의 struct file 구조체가 생성된다.
두 struct file 의 private_data 에서는 하나의 pipe_inode_info를 가리키게 되면서 같은 pipe 상태를 공유한다.
user memory/
┌────────────────────────────┐
│ pipefd[0] = read FD │
│ pipefd[1] = write FD │
└─────────────┬──────────────┘
│ process-local integer indexes
▼
kernel memory/
current->files->fdt->fd[]
├─ fd[read_fd] ──> struct file A
│ ├─ f_mode: READ | STREAM
│ ├─ f_op: pipeanon_fops
│ ├─ private_data ─────────────────┐
│ └─ f_inode ─────────────────┐ │
│ │ │
└─ fd[write_fd] ─> struct file B │ │ // same pipe_inode_info
├─ f_mode: WRITE | STREAM │ │
├─ f_op: pipeanon_fops │ │
├─ private_data ────────────┼────┘
└─ f_inode ─────────────────┘ // same inode
│
▼
struct inode
└─ i_pipe ───────┐
│
┌──────────────────────────────────────┘
▼
struct pipe_inode_info
├─ mutex
├─ rd_wait / wr_wait
├─ head / tail
├─ max_usage / ring_size
├─ readers / writers / files
├─ tmp_page[2]
└─ bufs ──> struct pipe_buffer[] ring
하나의 pipe_buffer는 하나의 페이지(4096B)를 버퍼로 사용하고 그 페이지 안에서 얼마나 읽었는지에 대한 정보가 저장된다.
struct pipe_inode_info {
unsigned int head;
unsigned int tail;
unsigned int max_usage;
unsigned int ring_size;
struct pipe_buffer *bufs; // -> pipe_buffer[] ring
};
struct pipe_buffer {
struct page *page; // 데이터가 있는 page
unsigned int offset; // page 내부 시작 위치
unsigned int len; // 유효한 데이터 길이
const struct pipe_buf_operations *ops; // page 관리 방법
unsigned int flags;
unsigned long private;
};
offset 0부터 시작하면서 read/write 와 같은 API를 사용해서 버퍼를 읽거나 쓰면 이 페이지를 통해 fd가 공유하게 되는것이다.
파이프를 통해 데이터를 쓸때마다 len이 늘어나게 되고, 읽을때마다 offset이 늘어나면서 len이 줄어든다.
만약 page가 가득 차면 새로운 페이지를 만들어서 ring에 연결하기도 하고, 0번 인덱스에 있는 페이지를 재사용하기도 한다.
pipe_buffer[] bufs
┌──────────────────┬──────────────────┬──────────────────┐
│ pipe_buffer[0] │ pipe_buffer[1] │ pipe_buffer[2] │
│ page/offset/len │ page/offset/len │ page/offset/len │
└──────────────────┴──────────────────┴──────────────────┘
Comments