You are on page 1of 22

Eddy Nakamura

O que IPC? Tipos de IPC Pipes Vantagens Funcionamento FIFOs Mensagens Alteraes no kernel

IPC uma abreviao para Interprocess Communication (Comunicao entre Processos). Denota um conjunto de chamadas de sistema que permite que um processo do modo usurio possa: Sincronizar-se com outros processos Enviar mensagens para outros processos ou receber mensagens deles Compartilhar um pedao da memria com outros processos

Pipes e FIFOs Mensagens System V IPC (Uso de Semforos) POSIX Messages Memria Compartilhada

O mecanismo de Pipes prov um meio de comunicao halfduplex entre processos. Os dados s trafegam em um sentido de cada vez. Toda informao escrita por um processo redirecionada a outro para leitura. Uso de Pipes: $ proc1 | proc2 O procedimento acima cria os 2 processos (proc1 e proc2) conectados por um pipe. Dessa forma, a sada de proc1 redirecionada entrada de proc2.

Sem o uso de pipes: $ proc1 > temp $ proc2 < temp Pipes no escrevem em disco, o que torna seu uso muito mais eficiente. Pipes podem ser considerados arquivos abertos sem terem uma imagem atribuda no sistema de arquivos. Sem pipes teramos de esperar o processo 1 terminar para depois utilizar os dados no processo 2.

$ proc1 | proc2 1. A chamada de sistema pipe() feita, retornando 2 file descriptors (um para leitura e outro para escrita). Supor file descriptor 3 para leitura e 4 para escrita. 2. A chamada de sistema fork() feita 2 vezes. 3. A chamada de sistema close() feita para liberar cada file descriptor.

Primeiro processo filho 1. Chama dup2(4, 1), que faz com que o file descriptor 4 seja copiado para o 1. Ou seja, o file descriptor 1 agora o canal de escrita do pipe. 2. Chama close() para liberar os file descriptor 3 e 4. 3. Chama execve() para executar o primeiro processo, que escreve sua sada no file descriptor 1 (sada padro), ou seja, escreve no pipe.

Segundo processo filho 1. Chama dup2(3, 0), que faz com que o file descriptor 3 seja copiado para o 0. Ou seja, o file descriptor 0 agora o canal de leitura do pipe. 2. Chama close() para liberar os files descriptor 3 e 4. 3. Chama execve() para executar o segundo processo (proc2), que usa como entrada o file descriptor 0 (entrada padro), ou seja, l o pipe.

Type
struct wait_queue * unsigned int unsigned int struct pipe_buffer[16] struct page * unsigned int unsigned int unsigned int unsigned int unsigned int unsigned int struct fasync_struct * struct fasync_struct *

Field
wait nrbufs curbuf bufs tmp_page start readers writers waiting_writers r_counter w_counter fasync_readers fasync_writers

Description
Pipe/FIFO queue Number of buffers containg data to be read Index of first buffer containg data to be read Array of pipes buffer descriptors Pointer to a cached paged frame Read position in current pipe buffer Flag for (or number of) reading processes Flag for (or number of) writing processes Number of writing processes sleeping in the wait queue Like readers, but used when waiting for a process that reads from the FIFO Like writers, but used when waiting for a process that writes into the FIFO Used for asynchronous I/O notification via signals Used for asynchronous I/O notification via signals

Type struct page *

Field page

Description Address of the descriptor of the page frame for the pipe buffer

unsigned int
unsigned int struct pipe_buf_operations *

offset
len ops

Current position of the significant data inside the page frame


Length of the significant data in the pipe buffer Address of a table of methods relative to the pipe buffer (NULL if the pipe buffer is empty)

Para ler do pipe o processo faz chamada de sistema read() Nota-se que a operao de leitura pode ser assncrona: neste caso, termina logo que todos os bytes disponveis forem copiados para o espao de endereo do usurio.

At least one writing process Bloking read Pipe size p p=0 Sleeping writer Copy n bytes and return n, waiting for data when the pipe buffer is empty No sleeping writer Wait for some data, copy it, and return its size Return EAGAIN Nonbloking read

No writing process

Return 0

0<p<n pn

Copy p bytes and return p : 0 bytes are left in the pipe buffer Copy n bytes and return n: p-n bytes are left in the pipe buffer

p o tamanho do pipe e n, a quantidade de bytes requesitados

Para escrever no pipe o processo faz a chamada de sistema write() Foi padronizado que qualquer operao de escrita de um nmero pequeno de bytes deve ser feita atomicamente. Quo pequeno? 4096 bytes Se dois ou mais processos quiserem gravar no pipe menos que 4096 bytes, cada um ter de terminar sua gravao sem ser interrompido por outro processo.

At least one reading process Available buffer space u u < n 4096 Bloking write Wait until n-u bytes are freed, copy n bytes, and return n Copy n bytes (waiting when necessary) and return n Copy n bytes and return n Nonblocking write Release EAGAIN No reading process Send SIGPIPE signal and return EPIPE

n > 4096

If u > 0, copy u bytes and return u; return EAGAIN

un

u o espao livre no buffer e n, o nmero de bytes a serem gravados

Podem ser usados por vrios processos Utilizam inodes na rvore de diretrios do sistema Acessados pelas funes open(), read(), write() e close() Acesso controlado pelo VFS (Virtual File System)

Inodes aparecem na rvore de diretrios do sistema ao invs de pertencerem ao sistema de arquivos pipefs FIFOs formam um canal de comunicao bidirecional Mtodos read() e write() = pipe_read() e pipe_write()

Processos podem se comunicar atravs do uso de mensagens. Mensagens IPC so armazenadas em uma fila quando so escritas, e ficam nela aguardando que outro processo as leia, saindo ento da fila. As mensagens consistem de um cabealho de tamanho fixo e um texto de tamanho varivel. Para enviar usa-se o comando msgsnd e para receber msgrcv.

Tentativa de implementar um pipe full-duplex (com a idia bsica contida no prprio livro).

arch/i386/kernel/syscall_table.S .long sys_pipe_fd arch/include/asm-i386/unistd.h #define __NR_pipe_fd include/linux/syscalls.h asmlinkage int sys_pipe_fd(int __user *, int __user*); fs/pipe.c int sys_pipe_fd(int __user *filedes1, int __user *filedes2) implementao

Understanding the Linux Kernel, Daniel P. Bovet; Marco Cesati. O'Reilly Media, Inc. Terceira Edio http://users.actcom.co.il/~choo/lupg/tutorials/multiprocess/multi-process.html#preface http://www.linuxhq.com/guides/LPG/node1.html http://tldp.org/LDP/tlk/ipc/ipc.html

You might also like