IMPLEMENTAÇÃO DE PROCESSOS
Alan Ruani
Lucas Temperly
Orion Guimarães
PROCESSOS
 Uma
instância em execução de um programa é
chamada de processo;
 Quando se tem duas instâncias de um mesmo
programa, existem então dois processos em
execução de um mesmo programa;
 Programação avançada frequentemente usa
escalonamento cooperativo, possibilitando
realizar mais de uma tarefa, utilização de
programas já existentes, entre outros;
PROCESSOS
 Composição
de um processo;
 Muitas das System Calls utilizadas na
implementação de processos estão na
biblioteca <unistd.h> ou na <sys/types.h>;
 Todo programa usa um ou mais processos;
ID’S DE PROCESSO
 Cada
processo em um sistema Linux é
identificado por um único ID de 16-bits, dado
pelo sistema sequencialmente a cada
criação de processo;
 Todo processo tem um processo parente,
exceto o processo init, que é o processo
inicial;
 Um PID(Process Identifier) é um número de
identificação que o sistema dá a cada
processo;
 Não deve ter um PID para dois ou mais
processos ao mesmo tempo;
ID’S DE PROCESSO
 Os
sistemas baseados em Unix precisam
que um processo existente se duplique para
ser atribuída uma nova tarefa a esta cópia;
 Um PPID(Parent Process Identifier) é o ID
do processo pai;
 GETPID() -> retorna o ID de um processo
que está em execução;
 GETPPID() -> retorna o ID do processo pai
deste processo em execução;
EXEMPLO DE CÓDIGO
Imprimindo o ID de processos:
#include <stdio.h>
#include <unistd.h>
Int main()
{
printf(“O ID do processo é %d”, (int)getpid());
printf(“O ID do processo pai é %d”, (int)getppid());
return 0;
}

SINAIS DE PROCESSO
 Meios
para que os processos possam se
comunicar e para que o sistema possa
interferir em seu funcionamento;
 Alguns exemplos de sinais:
 STOP - esse sinal tem a função de
interromper a execução de um processo e
só reativá-lo após o recebimento do sinal
CONT;
 CONT - esse sinal tem a função de instruir
a execução de um processo após este ter
sido interrompido;
SINAIS DE PROCESSO
 TERM
- esse sinal tem a função de terminar
completamente o processo, ou seja, este
deixa de existir após a finalização;
 ILL - esse sinal informa erros de instrução
ilegal, por exemplo, quando ocorre divisão
por zero;
 KILL - esse sinal tem a função de "matar"
um processo e é usado em momentos de
criticidade.
ESTADOS DOS PROCESSOS
 Quando
um processo é criado, ele não
necessariamente é executado;
 Existem vários estados em que um
processo pode se encontrar;
 O sistema Linux trabalha com estes
estados:
 Executável: o processo pode ser
executado imediatamente;
ESTADOS DOS PROCESSOS
 Dormente:
o processo precisa aguardar
alguma coisa para ser executado. Só
depois dessa "coisa" acontecer é que ele
passa para o estado executável;
 Zumbi: o processo é considerado "morto",
mas, por alguma razão, ainda existe;
 Parado: o processo está "congelado", ou
seja, não pode ser executado.
CRIAÇÃO DE PROCESSOS
 Existem
dois tipos principais de criação de
processos:
Usando System:
Quando se usa o system, executa-se um
comando diretamente do Shell, isto se o
mesmo se encontra no Shell, para ser
utilizado em um programa.
CRIAÇÃO DE PROCESSOS
 usando
a chamada system:
#include <stdlib.h>
int main ()
{
int return_value;
return_value = system (“ls -l /”);
return return_value;
}
 O programa executa o comando ls que se
encontra no diretório raiz dentro do Shell.
CRIAÇÃO DE PROCESSOS – FORK()
CRIAÇÃO DE PROCESSOS – FORK()
 Os
Processos são criados através do uso
de uma função interna do Kernel chamada
fork;
 A função fork duplica o processo atual
dentro do sistema operacional;
 O processo que faz achamada a função fork
é chamado de pai;
 O novo processo criado pelo processo pai é
chamado de filho;
 Todas as áreas do processo são duplicados
dentro do sistema operacional (Código,
Dados, Pilha, Memória Dinâmica).
SINTAXE:
PROCESSO ZUMBI
 Um
processo pode se terminar quando seu pai
não está a sua espera. Neste caso, o processo
filho vai se tornar um processo denominado
zumbi (zombie).
 Ele é neste caso identificado pelo nome
<defunct> ou <zombie> ao lado do nome do
processo.
 Seus segmentos de instruções e dados do
usuário e do sistema são automaticamente
suprimidos com sua morte, mas ele vai
continuar ocupando a tabela de processo do
kernel.
 Quando seu fim é esperado, ele simplesmente
desaparece ao fim de sua execução.
SINTAXE
FUNÇÃO EXEC
 Estas
funções substituem a imagem de um
processo por outra imagem de acordo com
os argumentos especificados. Com o fork
podemos criar novos processos e com as
funções exec podemos executar novos
programas ( estas funções não criam um
novo processo para executar o programa,
em vez disso substituem a imagem do
processo pelo programa que se vai
executar).
FUNCIONAMENTO DAS FUNÇÕES EXEC
Verifica as permissões de execução do comando;
 Verifica se o tamanho do código e segmento de
dados do comando é menor que o do processo em
questão ( de modo a garantir que o novo comando
não é carregado e o código do processo é
sobreposto);
 Liberta memória antiga e aloca novo bloco de
memória;
 Modifica mapa de memória;
 Actualiza entrada da tabela;
 Informa o scheduler que o processo está pronto
para ser executado.

TERMINADO UM PROCESSO
 Cada
processo em execução geralmente é
finalizado em poucos segundos, mas algum
processo que está em background, ou sem
um devido controle pode ter problemas e
você precise destruir este processo;
 Usa-se então o comando KILL, que “mata”
o processo

Kill [-sinal] ID de processo (PID)
EXEMPLO DO USO DO KILL
ps
PID TT STAT TIME COMMAND
9408 p9 S
0:00 ue temp2.xdh
9450 pa S
0:01 -Tcsh (Tcsh)
9501 pa T
0:00 less csh.1
9503 pa R
0:00 ps
kill 9501
TERMINAÇÃO DE PROCESSOS
Um processo pode terminar por várias causas, sendo
elas:

decisão do próprio processo, executando a
chamada ao sistema apropriada (direta ou
indiretamente, p.ex. por retorno de main());

erro causado pelo processo, normalmente
devido a um bug, p.ex. divisão por zero ou
acesso a uma região de memória que não lhe foi
atribuída;

decisão de outro processo, executando a
chamada ao sistema apropriada (kill em
POSIX);

decisão do SO (falta de recursos).Note-se
que um processo pode terminar
voluntariamente quando detecta um erro,
p.ex. um compilador não pode compilar
um ficheiro que não existe.
FUNÇÃO EXIT
 fecha
todos os ficheiros
 libera diretório corrente
 libera regiões de memória
 atualiza ficheiro com registro da utilização do
processador, memória e I/O
 envia signal death of child ao processo pai (por
omissão é ignorado)
 registo proc / task mantém-se no estado zumbi:
 permite ao processo pai encontrar informação
sobre o filho quando executa wait.
CHAMADAS AO SISTEMA
#include <unistd.h>
void exit(int status)
void _exit(int status)
pid_t getpid()
pid_t getppid()
_exit() termina o processo que a invoca;
exit() é uma função da biblioteca C (deve usar-se com #include
<stdlib.h>):
invoca as funções registadas usando at_exit();
invoca a chamada ao sistema _exit().
Após retornar de main(), um processo invoca exit().
getpid() retorna o pid do processo que o invoca.
getppid() retorna o pid do processo pai.
FUNÇÃO WAIT
 procura
filho zombie.
 pid
do filho e estado do exit são retornados
através do wait.
 liberta
a estrutura proc do filho se não há
filho zumbi, pai fica bloqueado.
FUNÇÃO WAITPID()
 Assim
como a função wait, o processo pai
aguarda o fim do processo filho;
 Mas com a função waitpid(), o pai pode
esperar a finalização de um processo filho
tendo este especificado pelo seu id, isto é,
pelo seu PID.
SINCRONIZAÇÃO COM WAIT()
#include <sys/types.h>
#include <sys/wait.h>
pid_t wait(int *status)
pid_t waitpid(pid_t pid, int *status, int options);
Suspende a execução do processo até um
processo filho terminar (wait()) ou o processo filho
especificado em pid termina (waitpid());
Status permite obter informação adicional sobre
o processo que terminou. Nomeadamente, o
argumento com que invocou a função exit().
Options controla o modo de funcionamento de
waitpid().
EXEMPLO:
...
int status;
pid_t pid;
...
if( (pid = wait(&status)) != -1 ) {
if( WIFEXITED(status) != 0 ) {
printf(‘‘Process %d exited with status %d\n’’,
pid, WEXITSTATUS(status));
} else {
printf(‘‘Process %d exited abnormally\n’’, pid);
}
}
REFERÊNCIAS
S02_AP_02.2_26.03.2015__Advanced_Linux_Prog
ramming-ch03-processes.pdf
 http://linux.die.net/man/2/waitpid
 http://unixhelp.ed.ac.uk/shell/jobz5.html
 S02_AP_02.1_26.03.2015__Processos_Linux.pdf
