Atividade 04 – Fundamentos de Sistemas Operacionais

Nome: Leandro Istan

Exemplo 1:

Descrição: Nesse caso, quando compilado e executado, o código imprime apenas a

mensagem “Running with ps with execlp” (pois está antes da chamada de execlp) e
então executa o comando “ps -ax”. A mensagem “Done.” nunca será exibida na tela,
pois, o processo atual é substituído pelo comando “ps -ax” com a primitiva “execlp”,
que sobrescreve a mensagem “Done” com o comando “ps -ax”. Como pode ser
observado abaixo:
Exemplo 2:

Descrição: Nesse exemplo, após executar o “fork”, o processo pai cria então um
segundo processo, o filho. Dentro do “switch case”, os processos pai e filho são
executados, mostrando as mensagens com seus respectivos nomes e PIDs. O que
acontece ao fim da execução é que o processo filho, se torna um processo zumbi, o
motivo disso é que como o processo filho é executado 5 vezes e o processo pai somente
3, o processo pai sai do laço primeiro que o filho, sem obter o status de saída de seu
filho. Dessa forma, o processo filho não tem um “pai vivo” para coletar seu status de
saída, ficando no estado zumbi até que o SO finalize o processo e libere seus recursos,
por isso o terminal só devolve o cursor quando apertamos enter. Como podemos
observar abaixo:
Exemplo 3:

Descrição: Neste exemplo, inicia-se o main com algumas funções que ajudarão no
programa, como uma variável para número de bytes, um vetor de inteiros para criar o
pipe, uma string contendo os caracteres 123 e um vetor de char para armazenar os dados
lidos do pipe. Em seguida, o memset limpa o vetor ‘buffer’. Então, inicia-se o pipe, com
a verificação se o pipe foi criado com sucesso, no caso, se sim, a função “write” é usada
para escrever os dados que estão contidos na string “some_data” no descritor de escrita
do pipe(“file_pipes[1]”) e o número de bytes escritos é armazenado em
“data_processed” e então exibido na tela. Após, a função “read” é usada para ler os
dados do pipe utilizando o descritor de leitura do pipe(“file_pipes[0]”), os dados lidos
são armazenados no ‘buffer’ e o número de bytes são armazenado em “data_processed”
e então são exibidos juntamente com o conteúdo do buffer. De forma simples, este
programa cria um pipe, escreve a string 123 e lÇe os dados do pipe imprimindo-os na
tela, demonstrando então a comunicação entre processos usando pipes. Como pode ser
observado abaixo:
Exemplo 4:

Observação: Similar ao programa anterior, esse adiciona um “pid_t fork result” para que
possa ser feito a verificação se o processo é pai ou filho baseado no PID. Também é
adicionado uma verificação para ver se o ‘fork’ foi executado com sucesso. Após, em
caso de sim, é então verificado se o “fork_result” é igual a 0, nesse caso, tratando-se de
um processo filho, o filho então, de forma similar ao programa anterior, fica responsável
pela leitura de dados vinda do pipe, armazenando os dados lidos no buffer e o número
de bytes em “data_processed”, exibindo-os na tela juntamente com o conteúdo do
buffer. Em seguida, caso não se trate de um “fork_result” 0, sendo qualquer outro
número (comando else), trata-se de um processo pai, e nesse contexto, o pai é
responsável por escrever no pipe, utilizando seu descritor de escrita(file_pipes[1]) então
o pai escreve os dados da string “some_data”(123) para que possam ser lidos pelo filho
e também escreve o número de bytes em “data_processed” e então os imprime na tela.
Em resumo, este programa cria um pipe e cria um processo filho usando fork, onde o
processo filho lê os dados do pipe e o pai escreve dados no pipe, demonstrando assim a
comunicação bidirecional entre processos usando pipe.
Exemplo 5 e ‘6’:
Descrição: Este programa é bem similar ao anterior, mas nesse caso, a mudança está
dentro do que o processo filho vai executar, onde, depois da verificação se o processo é
filho, o programa utiliza a variável “sprintf” para converter o descritor de leitura
(file_pipes[0]) do filho em uma string e guarda-o em “buffer”, em seguida, usa-se a
variável execl para substituir o processo filho atual por um programa chamado “pipe4”,
passando então o “buffer(junto com o descritor de leitura)” para o “pipe4” como um
argumento da linha de comando, o processo filho então sai do bloco após a execução de
“execl”, sendo assim, o “pipe4” toma o seu lugar como leitor do pipe. Em resumo, o
filho original é encerrado e substituído pelo “pipe4”, mas o descritor de leitura do pipe
continua disponível para o novo processo. Dessa forma, o processo “pipe4” não mata o
processo filho original, mas assume seu lugar e continua usando o descritor de leitura
para realizar suas operações.
Exemplo 7:

Descrição: O código inicia declarando as variáveis, pid_t pid para guardar o valor do
pid, message como uma string para armazenar a mensagem a ser impressa, n para usar
no loop e exit_code para armazenar o código de saída. O código é bem similar a
anteriores, onde, usa-se o fork para criar o processo filho através do pai e assim usa-se o
switch case para que ambos funcionem “ao mesmo tempo”, mas, nesse caso, é fornecido
um código de exit (37), no filho, para que esse dado seja transmitido mais tarde para o
pai (que estará esperando), informando que o filho terminou as execuções, dessa forma,
os processos pai e filho executam um numero diferente de vezes, mas o código filho não
se torna zumbi, pois o pai está esperando o seu status de saída, utilizando do
“exit_code” e da função wait, utilizada mais a frente no código, dessa forma, no fim,
ambos os processos são terminados, devolvendo o cursor. Como visto abaixo:
Exemplo 8:

Descrição: No programa, é criado uma função chamada “ouch”, que quando chamada,
receberá o sinal SIGINT, essa função então exibe uma mensagem indicando que
recebeu o sinal e ela é responsável por tratar o sinal, redefinindo-o para o padrão com
SIG_DFL. Dentro do main, há então uma chamada de função, para tratar o sinal
SIGINT e logo após, é executado um laço infinito que imprime sempre “Hello World!”,
até que receba o sinal (CTRL+C), quando o sinal é ativado, ele chama a função que
então indica que recebeu o sinal e volta a imprimir o Hello World, até que seja chamado
novamente, encerrando o programa. Como no exemplo abaixo: