q
Chamada de sistema fork:
2 Cria uma cópia idêntica ao processo pai, mas com outros PID e PPID. 2 Códigos de retorno:
2 Se Ok: retorna o PID do filho, no contexto do processo pai e 0 no contexto do filho. 2 Se não: retorna -1 no contexto do processo pai, não cria o filho e envia o código
de erro.
No Linux, processos não são gerados de forma espontânea, ou mesmo criados aleatoria- mente pelo kernel. Na verdade, novos processos são criados unicamente a partir de outros processos, por intermédio da chamada de sistema fork, que cria uma cópia exatamente igual à do processo que a executou. As principais diferenças ficam por conta do PID e do PPID. Após a execução da chamada fork, os processos pai (o criador) e filho (o criado) são tratados de maneira independente, como mostra a figura3.1, podendo criar novos processos e dar origem a uma árvore hierárquica de processos.
P1 P1
PID 10 PID 356
Fork
Um processo filho herda uma cópia de todos os descritores de arquivos mantidos pelo processo pai, compartilhando os respectivos arquivos. O Linux permite que os processos identifiquem-se como pai ou como filho e sigam linhas de execução diferentes, após o retorno da chamada fork. Para tal, no retorno da chamada fork, o Sistema Operacional retorna para o processo pai o PID do processo filho. Este, por sua vez, recebe do Sistema Operacional a penas o valor 0.
q
Chamada de sistema exec:
1 Altera o programa fonte que está em execução.
1 Inicializa os segmentos de dados e pilha para um estado inicial pré-definido.
Figura 3.1
Processos pai e filho.
Adm in is tr aç ão d e Si st em as L in ux
q
1 Inicializa os registradores do processador.
1 Algumas informações do processo são mantidas, como a lista de arquivos abertos. 1 Os vários tipos de chamadas exec permitem que os programas sejam iniciados com
diferentes opções.
Após um fork, o novo processo deverá fazer uso da chamada de sistema exec, para começar a execução de um novo programa. Existe, na realidade, uma família de chamadas de sistema do tipo exec. Todas as chamadas da família exec, no entanto, executam basicamente a mesma função: mudam o código que o processo está executando e reiniciam os segmentos de dados e a pilha para um estado inicial pré-definido. Quando uma das rotinas exec é chamada, o con- teúdo da memória do processo que a chamou, geralmente uma cópia herdada da memória do processo pai, é substituído pelo conteúdo (código e dados) do novo programa e, em seguida, sua execução é iniciada no processo. A figura 3.2 ilustra uma chamada exec.
P1
P2
PID 34
PID 34
exec
Na inicialização do Linux, o primeiro processo (PID=1) a ser executado é o init. Esse processo cria diversos processos filhos, que controlam a inicialização do sistema. Portanto, todos os processos em execução no sistema, com exceção de uns poucos criados diretamente pelo kernel, são descendentes do processo init. Ao final da inicialização do sistema, o init identi- fica os terminais conectados a esse e, por meio das chamadas fork e exec, cria um processo associado a cada terminal para controlar o acesso ao sistema. O processo que controla os terminais é o getty, que, quando recebe um pedido de conexão, ativa o programa login para fazer a verificação do nome do usuário e sua respectiva senha, armazenados no arquivo
/etc/shadow ou /etc/passwd, caso o esquema de shadow passwords não esteja habilitado.
Se as informações fornecidas pelo usuário estiverem corretas, um novo processo será criado para executar o interpretador de comandos do usuário, que fica aguardando por um comando. O esquema descrito anteriormente é mostrado na figura 3.3.
Figura 3.2
Chamada de sistema exec.
Ca pí tu lo 3 - P ro ce ss os getty init PID 424 init PID 1 login PID 424 PID 424 bash PID 424 grep bash PID 563 PID 563 Fork Fork exec exec exec exec
Multiprocessamento
q
Um usuário pode ter vários processos ativos: 1 Foreground:
2 #ps aux 1 Background:
2 #firefox & (associado a um terminal) 1 Daemon:
2 Squid (não associado a terminal)
Por ser um ambiente multiusuário e multitarefa, o Linux permite que vários usuários executem, simultaneamente, diversos processos independentes. Cada usuário pode ter vários processos ativos. Em um sistema de grande porte, podem existir milhares de processos em execução. Os processos com que o usuário interage diretamente estão associados a um terminal, sendo possível para esse processo ler ou escrever dados. Diz-se que esses processos estão sendo executados em primeiro plano ou em foreground. No entanto, existem processos que, apesar de poderem estar associados a terminais, não permitem a interação direta do usuário. Diz-se que esses processos estão sendo executados em segundo plano – ou em background. Muitos processos são executados em segundo plano, controlando alguma atividade ou fornecendo algum serviço. Geralmente, processos em segundo plano realizam operações de entrada e de saída em arquivo.
No entanto, pode existir apenas um processo executado em primeiro plano associado a um determinado terminal. Existe um tipo especial de processo que é executado em segundo plano, denominado daemon, que é geralmente ativado na inicialização do sistema e não possui um terminal associado. Daemons realizam operações de entrada e de saída em arquivo ou por meio da rede. O interpretador de comandos permite ao usuário executar processos em primeiro ou em segundo plano e também iniciar ou parar um determinado daemon a qualquer momento.
Quando o usuário executa um processo em primeiro plano, o interpretador de comandos somente libera o prompt após o término da execução do comando solicitado, uma vez que o processo poderá realizar operações de entrada e de saída no terminal.
Figura 3.3
Criação de processos.
Adm in is tr aç ão d e Si st em as L in ux
Porém, quando o usuário executa um processo em segundo plano, o interpretador de comandos imediatamente libera a linha de comando, permitindo que o usuário forneça novos comandos para serem executados.
Para executar um processo em segundo plano, o usuário precisa apenas acrescentar ao final do comando o caractere “&”. Por exemplo, para executar o navegador Firefox em segundo plano, deve ser digitado o seguinte comando:
#firefox &
Nesse caso, o Firefox será executado em segundo plano, e o interpretador de comandos ainda permitirá ao usuário fornecer novos comandos e executá-los de forma independente. A noção de processos executados em background e em foreground está diretamente rela- cionada aos terminais. Em ambientes gráficos de janelas, como o X-Window, os conceitos de processos em background e foreground ainda são válidos, porém seu entendimento não é tão simples. Para um processo trabalhar com janelas, ele se comunica diretamente com um processo gerenciador do ambiente gráfico, enviando mensagens de um protocolo de aplicação suportado pelo gerenciador.
No X-Window, o usuário pode executar uma janela emuladora de terminal usando o comando
xterm, que, por sua vez, executa um interpretador de comandos. O gerenciador do ambiente
gráfico define um terminal virtual para cada janela xterm. Assim, cada janela xterm comporta-se como um terminal, no qual podem ser executados processos em background ou em foreground, da mesma forma como foi explicado anteriormente.
Daemon
Daemons (Disk and execution monitor) são programas que gerenciam serviços que são executados em segundo plano. Os daemons não estão associados a nenhum terminal, e geralmente são iniciados durante o processo de inicialização do sistema. Por padrão, os nomes dos daemons terminam com a letra “d”. Por exemplo, o daemon que gerencia o serviço http é chamado de httpd. A maioria dos serviços de rede é gerenciada por daemons que ficam permanentemente em execução, aguardando por conexões. Os serviços podem ser gerenciados por um daemon, modo conhecido como standalone, ou através do inetd ou xinetd, que são daemons que gerenciam diversos serviços simultaneamente. Quando o inetd e o xinetd recebem uma requisição, eles a repassam para o daemon correspondente ao serviço solicitado.
Dessa forma, os daemons responsáveis pelo serviço gerenciado pelo inetd ou pelo xinetd só são executados quando recebem alguma requisição. Isso otimiza o uso de recursos do sistema e simplifica a implementação desses daemons, já que não precisam mais gerenciar os serviços correspondentes, deixando essa tarefa a cargo do inetd ou do xinetd.