Técnicas Avançadas de Programação

Transcrição

1 Sumário Técnicas Avançadas de Programação Prof. João Marcos M. da Silva Departamento de Engenharia de Telecomunicações Escola de Engenharia Universidade Federal Fluminense Agosto de 2011 Prof. João Marcos Meirelles da Silva Aula 02 pg. 1/33

2 Sumário Sumário 1 2 Prof. João Marcos Meirelles da Silva Aula 02 pg. 2/33

3 Sumário Sumário 1 2 Prof. João Marcos Meirelles da Silva Aula 02 pg. 2/33

4 Sumário 1 2 Prof. João Marcos Meirelles da Silva Aula 02 pg. 3/33

5 Sobre os processos Os processos são programas carregados na memória do computador e podem ser classificados como pesados ou leves. Processos Pesados Os processos pesados são os programas tradicionais, possuindo um conjunto de operações iniciais básicas que começam a sua execução. Estas operações iniciais são o que chamamos de thread. A função void main de um programa escrito em C é uma thread inicial. Prof. João Marcos Meirelles da Silva Aula 02 pg. 4/33

6 Sobre os processos Atenção É importante entender que cada programa é, ao menos, um processo e que cada processo possui uma série de atributos: PID PPID UID e GID etc... Prof. João Marcos Meirelles da Silva Aula 02 pg. 5/33

7 Atributos de um processo PID O Process Identification é um número de identificação único. O primeiro processo chama-se init e recebe o PID de número 1; PPID Nenhum processo é executado de forma independente dos outros. Todos os processos no sistema, com exceção do init, possuem um processo pai. O atributo Parent Process ID armazena o PID do processo pai. UID e GID O User ID e o Group ID auxiliam para que os processos sejam executados conforme os privilégios de uma conta de usuário e o seu grupo associado. Prof. João Marcos Meirelles da Silva Aula 02 pg. 6/33

8 Atributos de um processo Variáveis de ambiente Cada processo herda do processo pai algumas variáveis de ambiente que guardam alguns valores que podem ser utilizados pelo processo em execução; Diretório de trabalho Os processos também são associados a um diretório de trabalho, onde podem fazer a leitura e a gravação em disco.=; Temporizadores O Kernel mantém registros da hora em que os processos são criados, bem como o tempo de CPU que eles consomem durante a sua execução. Prof. João Marcos Meirelles da Silva Aula 02 pg. 7/33

9 Atributos de um processo Além de um estado de execução (ready, wait e exec), um processo ocupa uma área de memória formada basicamente por 3 partes: Figure: Estrutura de um processo. Prof. João Marcos Meirelles da Silva Aula 02 pg. 8/33

10 Atributos de um processo Text Segment O segmento de código contém as instruções de máquina geradas na compilação do programa; User Data Segment O segmento de dados de usuário contém as variáveis utilizadas pelo programa; System Data Segment O segmento de dados do sistema contém os valores dos registradores da CPU quando não estiver sendo executado por algum motivo. Atenção! Como as instruções são separadas dos dados, é possível compartilhar o mesmo código entre vários programas em execução. Prof. João Marcos Meirelles da Silva Aula 02 pg. 9/33

11 Atributos de um processo Um mesmo programa pode ser ativado mais de uma vez, dando origem a vários processos. Nesse caso, o segmento de código é compartilhado entre eles, conforme mostrado na Figura abaixo: Figure: Compartilhamento do segmento de código entre processos. Prof. João Marcos Meirelles da Silva Aula 02 pg. 10/33

12 Atributos de um processo Importante Todos os processos que existam ao mesmo tempo são concorrentes. Eles podem funcionar completamente independentes uns dos outros, ou ocasionalmente necessitar de sincronização e cooperação. Se certas operações podem ser logicamente executadas em paralelo, temos os chamados processos paralelos. Prof. João Marcos Meirelles da Silva Aula 02 pg. 11/33

13 Racing Conditions Racing Conditions Suponha que 3 processos compartilham o acesso a variável A. Dois deles fazem operações de modificação e um imprime o valor da variável. Processo 1 A = A + 5; Processo 2 A = A + 1; Processo 3 Imprimir A; Prof. João Marcos Meirelles da Silva Aula 02 pg. 12/33

14 Sumário 1 2 Prof. João Marcos Meirelles da Silva Aula 02 pg. 13/33

15 Identificando um processo O identificador de cada processo PID é fornecido pelo Sistema Operacional. A linguagem C tem diferentes primitivas que permitem conhecer este número. Essas primitivas estão declaradas no cabeçalho unistd.h. pid_t getpid() A função getpid() retorna o número do processo em execução; pid_t getppid() A função getppid() retorna o número do processo pai que criou o processo em execução. pid_t getpgrp() Esta função retorna o GID do processo. Prof. João Marcos Meirelles da Silva Aula 02 pg. 14/33

16 Exemplo 1: #include <stdio.h> #include <unistd.h> int main(){ printf( Eu sou o processo \%d. Meu pai é o \%d. O ID do grupo de processo é o \%d.\n, getpid(),getppid(),getpgrp()); exit(0); Para compilar, salve como meupid.c : #gcc meupid.c -o meupid #./meupid Prof. João Marcos Meirelles da Silva Aula 02 pg. 15/33

17 Sumário 1 2 Prof. João Marcos Meirelles da Silva Aula 02 pg. 15/33

18 A primitiva EXEC A primitiva exec é representada pelas funções: execl() execle() execlp() execv() execve() execvp() Cada uma das funções desta família trocam a imagem do processo em execução pela imagem de outro processo. Prof. João Marcos Meirelles da Silva Aula 02 pg. 16/33

19 A primitiva EXEC O arquivo que será chamado por estas funções precisa ser um arquivo binário ou script para ser interpretado por um outro processo; O arquivo precisa ter permissões de execução; Essas funções não retornam nenhum valor que indique seu sucesso uma vez que o processo em execução é inteiramente trocado pelo processo novo; No caso de falha, as funções retornam o valor -1. Essas funções estão declaradas em unistd.h. Prof. João Marcos Meirelles da Silva Aula 02 pg. 17/33

20 A primitiva EXEC Atenção! Um script, para ser interpretado no Linux, precisa iniciar com a indicação de qual programa será usado para a sua interpretação. Para fazer isso, sua primeira linha deve começar com: #!/caminho/programa Prof. João Marcos Meirelles da Silva Aula 02 pg. 18/33

21 int execv(const char *arquivo, char const *argv[ ]) Exemplo 2: #include <stdio.h> #include <unistd.h> int main{ char *cmd[] = {"cat", "/etc/passwd", (char *) 0; printf("vou chamar o programa cat para ler o conteúdo de /etc/passwd.\n"); execv("/bin/cat", cmd); printf("esta mensagem não será impressa.\n"); exit(0); Prof. João Marcos Meirelles da Silva Aula 02 pg. 19/33

22 A primitiva SYSTEM A primitiva system() executa um programa especificado com parâmetro e retorna ao processo original quando este termina. O processo original não é substituído, mas congelado. A primitiva system() recebe apenas um único valor, onde o comando e seus parâmetros devem ser passados como uma única variável string. Esta função retorna -1 em caso de erro. Se for bem sucedida, a função retorna o código de saída do programa chamado. Este código poderá ser lido através da macro WEXITSTATUS(status). Prof. João Marcos Meirelles da Silva Aula 02 pg. 19/33

23 int system(const char *string) Exemplo 3: #include <stdio.h> #include <unistd.h> int main{ printf("vou chamar o programa cat para ler o conteúdo de /etc/issue.\n"); system("/bin/cat /etc/issue"); printf("esta mensagem será impressa.\n"); exit(0); Prof. João Marcos Meirelles da Silva Aula 02 pg. 20/33

24 As primitivas FORK e WAIT As primitivas fork() e wait() foram as primeiras para especificar concorrência. O fork() inicia um novo processo que compartilha o espaço de endereçamento do processo pai (criador). Ambos os processos, pai e filho, continuam a execução em paralelo. Esta função retorna um valor que pode ser utilizado no controle de execução. Prof. João Marcos Meirelles da Silva Aula 02 pg. 20/33

25 As primitivas FORK e WAIT Características do fork() em Unix/Linux: Ele duplica o processo que executa a chamada e os dois executam o mesmo código; Cada processo tem o seu próprio espaço de endereçamento, com cópia de todas as variáveis, que são independentes em relação às variáveis do outro processo; Ambos executam a instrução seguinte à chamada de sistema; O retorno da chamada fork() para o processo pai contém a identificação do PID do processo filho recém criado; Prof. João Marcos Meirelles da Silva Aula 02 pg. 21/33

26 As primitivas FORK e WAIT O retorno da chamada fork() para o processo filho é zero; Pode-se selecionar o trecho de código que será executado pelos processo com instrução condicional if ; A sincronização entre os processos pai e filho é feita com a primitiva wait(), que bloqueia o processo que a executa até que um processo filho termine. Prof. João Marcos Meirelles da Silva Aula 02 pg. 22/33

27 int fork(void) Exemplo 4: #include <stdio.h> #include <unistd.h> int main{ int id; id = fork(); if(id!=0) { printf("eu sou o pai e espero pelo meu filho %d.\n", id); wait(0); printf("meu filho acabou de terminar...vou terminar também!\n"); else { printf("eu sou o filho %d e espero 10 segundos.\n", getpid()); sleep(10); printf("já esperei e vou embora...\n"); Prof. João Marcos Meirelles da Silva Aula 02 pg. 22/33

28 Exemplo 5: #include <stdio.h> #include <unistd.h> int main{ int pid; printf("meu PID é %d. Vou criar um processo filho.\n", getpid()); pid = fork(); if(pid ==0) { printf("\t\tprocesso filho criado com PID = %d.\n", getpid()); printf("vou ficar executando indefinidamente.\n"); for(;;); else { sleep(5); printf("o processo pai termina e deixa o filho órfão.\n"); printf("veja se o processo filho continua rodando com o comando\n"); printf("ps\n"); exit(0); Prof. João Marcos Meirelles da Silva Aula 02 pg. 23/33

29 As primitivas FORK e WAIT Herança entre Pai e Filho Os processos filhos herdam uma duplicata de todos os descritores dos arquivos abertos do processo pai. Se o processo filho movimenta o ponteiro dentro de um arquivo, o processo pai irá fazer a próxima movimentação na nova posição. Prof. João Marcos Meirelles da Silva Aula 02 pg. 23/33

30 Exemplo 6: #include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <unistd.h> int main{ int pid, fd; char *pidnum, c; int i, r; printf("meu PID é %d.\n", getpid()); printf("vou gravar meu número de PID no arquivo meupid.\n"); if((fd=open("meupid",o_creat O_RDWR O_TRUNC,S_IRWXU))==-1) { printf("não consegui criar o arquivo meupid.\n"); exit(-1); sprintf(pidnum, "%d surpresa", getpid()); if(write(fd,pidnum,15)==-1) { printf("não consegui escrever no arquivo."); Prof. João Marcos Meirelles da Silva Aula 02 pg. 23/33

31 exit(-1); printf("já escrevi o número. Fechando o arquivo.\n"); close(fd); printf("vou abrir o arquivo novamente para leitura.\n"); if((fd=fopen("meupid", O_RDONLY,S_IRWXU))==-1) { printf("não foi possível abrir o arquivo.\n"); exit(-1); printf("vou criar um processo filho agora.\n"); pid = fork(); if(pid ==-1) { perror("não foi possível criar um processo filho.\n"); exit(-1); else if (pid == 0) { printf("\t\tsou o processo filho. Meu PID = %d.\n", getpid()); printf("\t\tvou ler o arquivo que já estava aberto pelo processo pai antes.\n") printf("\t\tda minha criação e que eu herdei.\n"); for(i=1; i<= 5; i++) { Prof. João Marcos Meirelles da Silva Aula 02 pg. 23/33

32 if(read(fd,&c,1)==-1) { printf("não consegui ler o arquivo..."); exit(-1); printf("o número que foi lido no arquivo é %c.\n", c); printf("\t\tfechando o arquivo e terminando minha execução...\n"); close(fd); exit(1); else /* aqui começam as instruções do processo pai. */ { wait(); printf("o processo filho criado tinha o PID número %d.\n", pid); printf("vou ler o arquivo meupid.\n"); while((r=read(fd,&c,1))!= 0) { if(r == -1) { printf("impossível ler o arquivo."); exit(-1); printf("consegui ler => %c\n", c); Prof. João Marcos Meirelles da Silva Aula 02 pg. 23/33

33 printf("meu filho leu o número do PID no arquivo e mexeu no meu ponteiro.\n"); printf("terminando minha executando.\n"); close(fd); exit(0); Prof. João Marcos Meirelles da Silva Aula 02 pg. 24/33

34 As primitivas FORK e WAIT A primitiva wait() tem como objetivo suspender a execução do processo pai até que o processo filho termine a sua execução. Esta instrução é especialmente útil, principalmente para evitar magentaracing conditions. Outra primitiva da mesma classe á a waitpid(). Ela suspende a execução de um determinado processo até que o processo filho, especificado pelo PID informado, tenha terminado. Estas primitivas retornam o valor do PID do processo que foi terminado. Casso ocorra algo inesperado, irão retornar o valor -1. Elas estão declaradas no cabeçalho wait.h. Prof. João Marcos Meirelles da Silva Aula 02 pg. 24/33

35 As primitivas FORK e WAIT A função waitpid() precisa receber como argumento um número de PID de um processo filho ou os seguintes valores predeterminados: <-1 Um valor menor que -1 diz à função waitpid() para suspender o processamento e esperar o término de qualquer processo filho cujo valor de seu GID seja igual ao número absoluto do valor passado; -1 Diz à função para suspender o processamento até que qualquer processo filho termine. Este é o comportamento padrão; Prof. João Marcos Meirelles da Silva Aula 02 pg. 25/33

36 As primitivas FORK e WAIT 0 Diz à função para suspender o processamento até que um processo filho com o mesmo GID do processo pai termine; >0 Diz à função para suspender o processamento até que o processo filho identificado pelo PID informado esteja terminado. Prof. João Marcos Meirelles da Silva Aula 02 pg. 26/33

37 pid_t wait(int *status) e pid_t waitpid(pid_t pid, int *status, int options) Exemplo 7: #include <signal.h> #include <stdio.h> #include <unistd.h> #include <sys/types.h> #include <sys/wait.h> int main{ int pid; printf("\nmeu PID é %d e meu GID é %d. Irei criar um processo filho.\n", getpid(), getpgrp()); if(fork() == 0) /* Instruções do processo filho. */ { printf("\t\tprocesso filho criado. Meu PID é %d e meu GID é %d.\n", getpid(), getpgrp()); sleep(4); printf("vou sair com código 7.\n\n"); exit(7); else /* Instruções do processo pai. */ Prof. João Marcos Meirelles da Silva Aula 02 pg. 26/33

38 { int ret1, status1; printf("sou o processo pai. Estou esperando o processo filho.\n"); ret1 = wait(&status1); printf("o processo filho que terminou foi o de de PID = %d.\n", ret1); printf("ele terminou com o parâmetro de exit() = %d.\n", (status1>>8)); exit(0); Prof. João Marcos Meirelles da Silva Aula 02 pg. 27/33

39 As primitivas EXIT, ABORT e KILL As primitivas que implementam o término de processos podem ser de dois tipos: exit() Termina o processo normalmente e seus recursos são liberados pelo sistema operacional; abort(pid), kill(pid) São utilizados pelo processo pai para terminar forçadamente os processos filhos. Prof. João Marcos Meirelles da Silva Aula 02 pg. 27/33

40 As primitivas EXIT, ABORT e KILL Processos Zombie É possível que um determinado processo filho termine por algum motivo inesperado, se torne um processo zombie (ou defunct). Os processos zombie não podem ser terminados com o comando kill, porque eles já não existem mais. É preciso terminar o processo pai. Prof. João Marcos Meirelles da Silva Aula 02 pg. 28/33

41 Exemplo 8: Processo zombie (zombie.c) #include <signal.h> #include <stdio.h> #include <unistd.h> int main{ int pid; printf("meu PID é %d e vou criar um processo filho.\n", getpid()); pid = fork(); if(pid == 0) /* Aqui começam as instruções do processo filho. */ { printf("\t\tmeu PID é %d e fui criado por %d.\n", getpid(), getppid()); printf("\t\tverifique os processos em execução com o comando ps.\n"); sleep(10); printf("processo filho terminado normalmente.\n"); exit(0); else /* Aqui começam as instruções do processo pai. */ { for(;;); Prof. João Marcos Meirelles da Silva Aula 02 pg. 29/33

42 As primitivas EXIT, ABORT e KILL Para compilar e executar o programa, digite: #gcc zombie.c -o zombie #./zombie & Para finalizar o processo zombie, digite: #killall zombie Prof. João Marcos Meirelles da Silva Aula 02 pg. 29/33

43 Sumário Atributos de Processos 1 2 Atributos de Processos Prof. João Marcos Meirelles da Silva Aula 02 pg. 30/33

44 Exercício 1: Atributos de Processos Em uma máquina Linux, abra um terminal e digite o comando top. Verifique quais as informações (colunas) são exibidas e tente identificar algumas delas. O que você encontrou? Prof. João Marcos Meirelles da Silva Aula 02 pg. 31/33

45 Sumário Atributos de Processos 1 2 Atributos de Processos Prof. João Marcos Meirelles da Silva Aula 02 pg. 32/33

46 Exercício 2: Atributos de Processos Abra um terminal em uma máquina Linux e digite: #pstree -c -p Descreva o que você está vendo. Prof. João Marcos Meirelles da Silva Aula 02 pg. 33/33