Jump to content
Do Zero Ao Um - ABRIREMOS INSCRIÇÕES AO VIVO! - LIVE Terça-feira 25/06 às 19h - mente.in/youtube ×
  • Construindo seu debugger - Parte 2: Forks

       (1 review)

    anderson_leite

    Olá! No artigo anterior falamos sobre Signals, que é de suma importância para a comunicação entre processos, mas para construir o nosso debugger precisamos muito mais do que apenas isso, precisamos de fato ter total controle sobre um dado processo e se possível controlar até o seu própio início.

    Neste artigo será explicado o que são forks e seu uso em desenvolvimento de aplicações em sistemas UNIX. Sem mais delongas, vamos prosseguir!!!?

    Resumidamente a syscall fork é usada para a duplicação e criação de um processo. Quando um dado processo chama a função fork(), é criada uma cópia idêntinca de seus dados. Note que apenas uma cópia é feita, o processo filho não compartilha o mesmo espaço de memória do pai.

    A syscall fork retorna um PID que é usado para indetificar em qual processos estamos e também dar acesso ao ID do processo filho. Caso o PID seja 0 estamos executando no filho, caso seja qualquer outro somos o processo pai, isso ocorre pois o pai precisa saber o PID do filho, mas o filho não necessariamente precisa saber o seu própio (da mesma maneira que o seu processo não sabe o própio PID ao menos que o mesmo peça).

    Algo interessante de se notar é que os Init System usados para subir e gerenciar serviços de sua máquina trabalham dessa mesma maneira, você pode checar sua árvore de processo usando comando pstree:

    $ pstree

    Dessa maneira você tem uma representação bem visual de como está dividida a sua estrutura de processos ?. Note que todos os processos são filhos do seu Init system (seja ele SystemV, Systemd, etc). Aconselho você explorar o comando pstree para uma visão bem mais detalhada do seu sistema! Outra abordagem é usar o própio comando ps:

    $ ps -ef

    Rode o comando acima (dependendo da quantidade de processos use um pipe para o less ?) e com ele teremos uma visão mais detalhada. A coluna PID representa o ID do processo em si e a coluna PPID representa o "Parent Process ID", que nada mais é que o ID do processo pai. Note que o PID 1 é o seu Init System e os seus processos rodam como filho dele!


    Vale notar que o processo Pai do própio init é o PID 0, que é conhecido como "swapper" ou "scheduler", que é o processo responsavel para realização de paging. Paging é o sistema de gerenciamento de memória que salva os dados da RAM em uma memória secundária (HD, SSD e etc) e recupera em formato de páginas (outros PID também são filhos do propio PID 0 como PID 2 que gerencia todas as threads que rodam em Kernel Land(KThread) etc).

     

    Programando Forks

    A syscall fork está na lib  <unistd.h> (Unix Standard library) e tem a seguinte construção:

    #include <sys/types.h>
    #include <unistd.h>
    
    
    pid_t fork(void);

    Precisamos incluir a lib <sys/types.h> para que seja possivel acessar o tipo pid_t. A função fork não espera nenhum parâmetro para a sua construção e o código abaixo demonstra o quão simples é cria um fork.

    #include <stdio.h>
    
    // Acesso a syscall
    #include <unistd.h>
    
    
    // Acesso ao tipo variavel pid_t
    #include <sys/types.h>
    
    
    int main(void)
    {
        int x;
    
        printf("Processo normal...\n");
        printf("Forking...\n");
        sleep(5);
        
        pid_t pid = fork();
        x = 40;
    
        if (pid == 0) {
            printf("Eu sou o processo filho meu PID: %d\n", pid);
        }
        
        else {    
            printf("Eu sou o processo pai de %d\n", pid);
        }
    
        
        sleep(5);
        return 0;
    }

    Compile o código acima da seguinte forma:

    $ gcc -o fork fork.c
    $ ./fork

    Note que o código se "divide" a partir da chamada fork e um if  é usado para saber se estamos executando no pai ou no filho, note também que o pai sabe o PID e o filho não.

    Para melhor visualização o código acima roda por 10 segundos (por conta da chamada ao sleep com esse tempo de espera). Abra um outro terminal e rode o comando:

    $ watch -n1 pstree

    O comando acima vai executar o pstree a cada 1 segundo, desta forma você verá o exato momento da criação do fork.


    Comunicando-se com o processo fork

    Agora imagine que um  processo precisa esperar o seu filho terminar algum trabalho e dependendo do seu sinal o processo pai realiza alguma ação. A comunicação entre o processo pai e o filho se da por signals. O pai pode saber exatamente o estado do seu processo filho usando a syscall wait e waitpid, ambas na lib <sys/wait.h>:

    #include <sys/types.h>
    #include <sys/wait.h>
    
    pid_t wait(int *status);
    
    pid_t waitpid(pid_t pid, int *status, int options);

    A syscall wait espera que ao menos 1 de seus processos filho troque de estado, já a waitpid espera por um processo específico. Como sabemos exatamente qual processo queremos rastrear iremos usar esta call ?:

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <unistd.h>
    
    
    
    int main(void) {
        
        printf("Spliting work...\n");
    
    
        pid_t pid = fork();
    
    
        if (!pid) {
            int a = 0;
            for(int i = 0; i < 100000000; i++ ) {
                a += i*2 + 10 *i;
            }
    
            return 9;
        }             
    
        int status;
        int signal;
        printf("Waiting child finish work...\n");
    
        waitpid(pid, &status, 0);
    
        
        if (WIFEXITED(status)) {
            signal = WEXITSTATUS(status);
            printf("Child exited, status = %s\n", strsignal(signal));
        }
            
        return 1;
    
    }

    Compile o código acima e execute:

    $ gcc -o work work.c
    $ ./work
    Spliting work...
    Waiting child finish work...
    Child exited, status = Killed

    Veja que após a chamada de fork nosso processo filho executa várias iterações e realiza um cálculo (um cálculo totalmente randômico) e após isso retorna 9. Este retorno em questão é apenas por motivos educativos (no artigo anterior falamos de sinais e como eles funcionam). O processo pai usa a syscall waitpid para esperar que qualquer signal seja enviada do pid especificado. Após receber um status é verificado se o fork saiu (WIFEXITED) e se sim, pegamos o signal enviado usando WEXITSTATUS(status da saída) e usamos a chamada strsignal(provida pela string.h) para recuperar uma versão em texto do signal. Nesse caso iremos recuperar o signal "KILLED", pois colocamos 9 apenas por razões educativas.

    Normalmente se tudo ocorreu bem colocamos 0 (inclusive é dessa maneira que sua shell avalia se o programa rodou certo).

    $./work && echo "Filho saiu com 0, tudo certo..."  || echo "Filho saiu com 1, algo errado..."

    No caso acima a nossa shell irá criar um fork do nosso work, executar o nosso programa (que por sua vez também executa um fork mas não entra em questão aqui) e se o signal retornado pelo fork for 0 ele imprime uma mensagem, caso contrario ele imprime uma mensagem de erro, dessa maneira você pode orquestrar um shell scripting usando o própio retorno do processo ?

    Tente mudar o retorno do fork acima e verifique seu status usando funções providas pela <sys/wait.h>. No exemplo acima usamos apenas a call WIFEXITED e WEXITSTATUS, mas existem várias outras.

    Forks são de extrema importância para criação e gerenciamento de processos e iremos usar forks para que seja possível executar o programa que queremos debugar, dessa maneira o software em questão vai ser filho do nosso debugger, o que nós da total controle sobre o mesmo.

    Comentarios são todos bem vindos e todos os códigos usados estão disponíveis no github! ?


    Links úteis:

        Process Control
        fork
        wait
        Process State
        Fork Bomb - Cuidado com isso


    Revisão: Leandro Fróes
    • Curtir 1

    User Feedback

    Join the conversation

    You can post now and register later. If you have an account, sign in now to post with your account.
    Note: Your post will require moderator approval before it will be visible.

    Guest

    • This will not be shown to other users.
    • Add a review...

      ×   Pasted as rich text.   Paste as plain text instead

        Only 75 emoji are allowed.

      ×   Your link has been automatically embedded.   Display as a link instead

      ×   Your previous content has been restored.   Clear editor

      ×   You cannot paste images directly. Upload or insert images from URL.



  • Similar Content

×
×
  • Create New...