3.8. Processos e Daemons
Anterior | Capítulo 3. Fundamentos do FreeBSD | Próxima

## 3.8. Processos e Daemons

O FreeBSD é um sistema operacional multitarefa. Cada programa em execução a qualquer momento é chamado de processo. Todo comando em execução inicia pelo menos um novo processo e há vários processos de sistema que são executados pelo FreeBSD.

Cada processo é identificado exclusivamente por um número chamado ID do processo (PID). Semelhante aos arquivos, cada processo tem um proprietário e um grupo, e as permissões de proprietário e grupo são usadas para determinar quais arquivos e dispositivos o processo pode abrir. A maioria dos processos também possui um processo pai que os iniciou. Por exemplo, o shell é um processo e qualquer comando iniciado no shell é um processo que tem o shell como seu processo pai. A exceção é um processo especial chamado init(8) que é sempre o primeiro processo a rodar na inicialização e que sempre possui um PID de `1`.

Alguns programas não são projetados para serem executados com a entrada contínua do usuário e desconectam do terminal na primeira oportunidade. Por exemplo, um servidor da Web responde a solicitações da Web, em vez de entradas do usuário. Servidores de email são outro exemplo desse tipo de aplicativo. Esses tipos de programas são conhecidos como daemons. O termo daemon vem da mitologia grega e representa uma entidade que não é boa nem má, e que invisivelmente realiza tarefas úteis. É por isso que o mascote do BSD é o daemon de aparência alegre com tênis e um tridente.

Existe uma convenção para nomear programas que normalmente são executados como daemons com um “d” à direita. Por exemplo, BIND é o Berkeley Internet Name Domain, mas o programa real que é executado é `named`. O programa do servidor da web Apache é o `httpd` e o daemon de spooling da impressora de linha é o `lpd`. Esta é apenas uma convenção de nomenclatura. Por exemplo, o daemon de correio principal para o aplicativo Sendmail é o `sendmail` e não `maild`.

### 3.8.1. Visualizando Processos

Para ver os processos em execução no sistema, use o ps(1) ou o top(1). Para exibir uma lista estática dos processos em execução no momento, seus PIDs, quanta memória eles estão usando e o comando com o qual eles foram iniciados, use o ps(1). Para exibir todos os processos em execução e atualizar a exibição a cada poucos segundos para ver interativamente o que o computador está fazendo, use o top(1).

Por padrão, o ps(1) mostra apenas os comandos que estão em execução e que são de propriedade do usuário. Por exemplo:

    % ps
     PID TT  STAT    TIME COMMAND
    8203  0  Ss   0:00.59 /bin/csh
    8895  0  R+   0:00.00 ps

A saída do ps(1) é organizada em várias colunas. A coluna `PID` exibe o ID do processo. Os PIDs são atribuídos a partir de 1, vão até 99999, e depois retornam ao início. No entanto, um PID não é reatribuído se já estiver em uso. A coluna `TT` mostra o tty em que o programa está sendo executado e `STAT` mostra o estado do programa. `TIME` é a quantidade de tempo que o programa foi executado na CPU. Normalmente, esse não é o tempo decorrido desde que o programa foi iniciado, pois a maioria dos programas gasta muito tempo esperando que as coisas aconteçam antes que precisem gastar tempo na CPU. Finalmente, `COMMAND` é o comando que foi usado para iniciar o programa.

Várias opções diferentes estão disponíveis para alterar as informações exibidas. Um dos conjuntos mais úteis é `auxww`, onde `a` exibe informações sobre todos os processos em execução de todos os usuários, `u` exibe o nome de usuário e o uso de memória do proprietário do processo, `x` exibe informações sobre os processos do daemon e `ww` faz com que o ps(1) exiba a linha de comando completa para cada processo, em vez de truncá-la para caber na tela quando é muito longa.

A saída do top(1) é semelhante a abaixo:

    % top
    last pid:  9609;  load averages:  0.56,  0.45,  0.36              up 0+00:20:03  10:21:46
    107 processes: 2 running, 104 sleeping, 1 zombie
    CPU:  6.2% user,  0.1% nice,  8.2% system,  0.4% interrupt, 85.1% idle
    Mem: 541M Active, 450M Inact, 1333M Wired, 4064K Cache, 1498M Free
    ARC: 992M Total, 377M MFU, 589M MRU, 250K Anon, 5280K Header, 21M Other
    Swap: 2048M Total, 2048M Free

      PID USERNAME    THR PRI NICE   SIZE    RES STATE   C   TIME   WCPU COMMAND
      557 root          1 -21  r31   136M 42296K select  0   2:20  9.96% Xorg
     8198 dru           2  52    0   449M 82736K select  3   0:08  5.96% kdeinit4
     8311 dru          27  30    0  1150M   187M uwait   1   1:37  0.98% firefox
      431 root          1  20    0 14268K  1728K select  0   0:06  0.98% moused
     9551 dru           1  21    0 16600K  2660K CPU3    3   0:01  0.98% top
     2357 dru           4  37    0   718M   141M select  0   0:21  0.00% kdeinit4
     8705 dru           4  35    0   480M    98M select  2   0:20  0.00% kdeinit4
     8076 dru           6  20    0   552M   113M uwait   0   0:12  0.00% soffice.bin
     2623 root          1  30   10 12088K  1636K select  3   0:09  0.00% powerd
     2338 dru           1  20    0   440M 84532K select  1   0:06  0.00% kwin
     1427 dru           5  22    0   605M 86412K select  1   0:05  0.00% kdeinit4

A saída é dividida em duas seções. O cabeçalho (as primeiras cinco ou seis linhas) mostra o PID do último processo executado, as médias de carga do sistema (que são uma medida de quão ocupado o sistema está), o tempo de atividade do sistema desde a última reinicialização) e a hora atual. As outras informações no cabeçalho se relacionam com quantos processos estão sendo executados, quanta memória e swap estão em uso ​​e quanto tempo o sistema está gastando em diferentes estados da CPU. Se o módulo do sistema de arquivos ZFS foi carregado, uma linha `ARC` indica a quantidade de dados que foram lidos do cache de memória, e não do disco.

Abaixo do cabeçalho há uma série de colunas contendo informações semelhantes à saída do ps(1), como o PID, nome de usuário, quantidade de tempo de CPU e o comando que iniciou o processo. Por padrão, o top(1) também exibe a quantidade de espaço de memória ocupada pelo processo. Isso é dividido em duas colunas: uma para o tamanho total e outra para o tamanho do residente. O tamanho total é a quantidade de memória que o aplicativo precisa e o tamanho de residente é o quanto ele está realmente usando agora.

O top(1) atualiza automaticamente a exibição a cada dois segundos. Um intervalo diferente pode ser especificado com `-s`.

### 3.8.2. Matando Processos

Uma maneira de se comunicar com qualquer processo ou daemon em execução é enviar um sinal usando o kill(1). Existem vários sinais diferentes; alguns têm um significado específico, enquanto outros são descritos na documentação do comando. Um usuário só pode enviar um sinal para um processo que seja seu. Enviar um sinal para o processo de outra pessoa resultará em um erro de permissão negada. A exceção é o usuário `root`, que pode enviar sinais para os processos de qualquer pessoa.

O sistema operacional também pode enviar um sinal para um processo. Se um aplicativo estiver mal escrito e tentar acessar a memória que não deveria, o FreeBSD enviará ao processo o sinal de “Segmentation Violation” (`SIGSEGV`). Se uma aplicação foi escrita para usar a chamada de sistema alarm(3) para ser alertada após um período de tempo, será enviado o sinal “Alarm” (`SIGALRM`).

Dois sinais podem ser usados ​​para interromper um processo: `SIGTERM` e `SIGKILL`. `SIGTERM` é a maneira educada de eliminar um processo, pois o processo pode ler o sinal, fechar quaisquer arquivos de log que possam estar abertos e tentar terminar o que está fazendo antes de desligar. Em alguns casos, um processo pode ignorar `SIGTERM` se estiver no meio de alguma tarefa que não pode ser interrompida.

`SIGKILL` não pode ser ignorado por um processo. Enviar um `SIGKILL` para um processo geralmente interromperá esse processo de uma vez por todas. [1].

Outros sinais comumente usados ​​são `SIGHUP`, `SIGUSR1` e `SIGUSR2`. Como esses são sinais de finalidade geral, diferentes aplicativos responderão de maneira diferente.

Por exemplo, depois de alterar o arquivo de configuração de um servidor da Web, o servidor da Web precisa ser instruído a reler sua configuração. Reiniciar o `httpd` resultaria em um breve período de interrupção no servidor da web. Em vez disso, envie ao daemon o sinal `SIGHUP`. Esteja ciente de que diferentes daemons terão um comportamento diferente, então consulte a documentação do daemon para determinar se `SIGHUP` terá os resultados desejados.

Procedimento 3.1. Enviando um sinal para um processo

Este exemplo mostra como enviar um sinal para o inetd(8). O arquivo de configuração do inetd(8) é o `/etc/inetd.conf` e o inetd(8) irá reler este arquivo de configuração quando for enviado um `SIGHUP`.

1. Encontre o PID do processo para enviar o sinal usando pgrep(1). Neste exemplo, o PID do inetd(8) é 198:

       % pgrep -l inetd
       198  inetd -wW

2. Use o kill(1) para enviar o sinal. Como o inetd(8) é de propriedade do `root`, use o su(1) para se tornar `root` primeiro.

       % su
       Password:
       # /bin/kill -s HUP 198

   Como a maioria dos comandos UNIX®, o kill(1) não imprimirá nenhuma saída se for bem-sucedido. Se um sinal for enviado para um processo que não pertence ao usuário, a mensagem kill: `PID`: Operation not permitted será exibida. Errar o PID irá enviar o sinal para o processo errado, o que poderia ter resultados negativos, ou enviará o sinal para um PID que não esteja em uso no momento, resultando em o erro kill: `PID`: No such process.

   ### Por que usar o `/bin/kill`?:

   Muitos shells fornecem o `kill` como um comando interno, o que significa que o shell enviará o sinal diretamente, em vez de executar o `/bin/kill`. Esteja ciente de que diferentes shells possuem uma sintaxe diferente para especificar o nome do sinal a ser enviado. Em vez de tentar aprender todos eles, pode ser mais simples especificar explicitamente o uso do `/bin/kill`.

Ao enviar outros sinais, substitua `TERM` ou `KILL` pelo nome do sinal.

### Importante:

Matar um processo aleatório no sistema é uma má ideia. Em particular, o init(8), PID 1, é especial. Executar `/bin/kill -s KILL 1` é uma maneira rápida e não recomendada de desligar o sistema. Sempre verifique os argumentos do kill(1) antes de pressionar a tecla Enter.

[1] Existem algumas tarefas que não podem ser interrompidas. Por exemplo, se o processo estiver tentando ler de um arquivo que está em outro computador na rede e o outro estiver indisponível, o processo é considerado não “interrompível”. Eventualmente, o processo expirará, normalmente após dois minutos. Assim que esse tempo limite ocorrer, o processo será eliminado.

Anterior | Acima | Próxima
3.7. Montando e Desmontando Sistemas de Arquivos | Principal | 3.9. Shells

All FreeBSD documents are available for download at https://download.freebsd.org/ftp/doc/

Questions that are not answered by the documentation may be sent to <freebsd-questions@FreeBSD.org>.
Send questions about this document to <freebsd-doc@FreeBSD.org>.