1. O documento discute os processos no Linux, incluindo como o kernel gerencia processos de forma eficiente e o conceito de multitarefa que permite a execução de vários programas ao mesmo tempo. 2. São descritos alguns comandos importantes para gerenciar processos no Linux, como ps, pstree, top e kill, e seus usos para listar e controlar processos em execução. 3. Processos no Linux possuem atributos como PID, ID do usuário, diretório de trabalho e variáveis de ambiente, e o documento explica a hier

1. 1 Sistemas Operacionais Luiz Arthur
Tarefas como verificar os processos que estão executando, mudar a prioridade
de execução e terminar os processos são exigidas para qualquer administrador
Linux.
O Kernel do Linux tem uma capacidade excelente para trabalhar com processos
sem intervenção do usuário. Mas às vezes é preciso que o root intervenha e
termine um processo que esteja comportando-se de forma egoísta e exaurindo
os recursos da máquina.
Este controle de processos é especialmente importante porque o Linux é um
sistema multitarefa, multiusuário e multiprocessado.
O conceito de multitarefa significa que o Linux é capaz de executar diversos
programas e serviços ao mesmo tempo de forma preemptiva.
Se tivermos apenas um processador central no computador com Linux, o sistema
fará o escalonamento (rodízio) dos processos de forma tão eficiente que o usuário
terá a impressão de que ele pode executar mais de um programa ao mesmo
tempo.
E o Linux ainda possui a capacidade de gerenciar os processos de forma eficaz
com o multiprocessamento real quando temos mais de um processador central
envolvido.

2. 2 Sistemas Operacionais Luiz Arthur
Quando o computador com o Linux é ligado, o sistema imediatamente procura no
setor de boot do disco rígido o gerenciador de boot (LILO ou GRUB). Eles são
responsáveis pela carga do Kernel na memória.
Após a carga do Kernel, este inicia um processo especial chamado init. Este
processo é o pai de todos os processos e responsável pelo restante da carga de
boot do Linux.
Depois da carga do boot, o init chama outro programa especial chamado getty,
que é responsável pela autenticação do usuários e por iniciar o processo
de shell.
É importante que você entenda que cada programa é pelo menos um processo e
que cada processo possui atributos, como:
●Process ID (PID) ou identificação do processo: Cada processo possui um número
de identificação única. O primeiro processo init sempre terá o PID 1 e para o
restante dos processos este número é incrementado à medida que novos
processos são executados.
User ID e Group ID (ID do usuário e ID do grupo): Os processo precisam ser
executados com os privilégios de uma conta de usuário e grupo associado a
eles. Isto é importante porque assim o sistema pode determinar e gerenciar o
acesso ao recursos.

3. 3 Sistemas Operacionais Luiz Arthur
●Processo Pai: No Linux nenhum processo é executado de forma independente
dos outros. Todos os processos no sistema, com exceção do init, possuem um
processo pai, que é responsável pela sua execução.
●Parent ID (ID do processo pai): Este atributo grava o PID do processo pai. Caso o
processo pai termine sua execução antes do processo filho, o processo filho é
“apadrinhado” pelo init, ganhando o Parent ID igual a 1.
●Variáveis de ambiente: Cada processo herda do processo pai algumas variáveis
de ambiente que simplesmente guardam alguns valores que pode ou não ser
importantes para o processo em execução. É possível que durante sua execução
um processo altere, incremente ou apague uma variável de ambiente.
●Diretório de trabalho: Os processos também são associados a um diretório de
trabalho, onde podem fazer leitura e escrita de 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.
Sinais
Cada processo no Linux fica à escuta de sinais. Estes sinais são utilizados pelo
Kernel, por outros processos ou pelo usuário para avisar a um
determinado processo sobre algum evento em particular. Sinais pode ser
visto como uma interrupção de software.

4. 4 Sistemas Operacionais Luiz Arthur
Quando um sinal é enviado para um processo, ele toma uma determinada ação
dependendo do valor que este sinal carrega.
Cada sinal tem nome exclusivo e um valor numérico. Tal como:
Sinal HUP, valor 1: Hang-Up ou desligamento. Este sinal é utilizado
automaticamente quando o usuário desconecta de uma sessão ou fecha um
terminal. Ele também é utilizado por processos servidores para invocar a
releitura do arquivo de configuração (para atualização das configurações do
servidor).
Sinal INIT, valor 2: Interrompe o processo. Ele é enviado automaticamente
quando um processo é abortado com as teclas ctrl-c.
Sinal KILL, valor 9: Termina o processo incondicionalmente de forma rápida e
drástica. Este tipo de sinal pode deixar arquivos abertos e bases de dados
corrompidas. Deve ser utilizado caso o processo pare de responder ou em uma
emergência.
Sinal TERM, valor 15: Termina o processo de forma elegante, possibilitando que
ele feche arquivos e execute suas rotinas de fim de execução.
Sinal TSTP, valor 18: Termina a execução para continuar depois. Este sinal é
enviado automaticamente quando utilizamos as teclas ctrl-z. É utilizado para
colocar um processo em segundo plano.

5. 5 Sistemas Operacionais Luiz Arthur
O Linux possui mais de 30 sinais definidos. A maioria utilizada pelo Kernel e
alguns pelos usuários. O entendimento de sinais é importante para que possamos
interagir com os processos em execução.
Controle de Processos
Como outros sistemas operacionais completos, o Linux possibilita que
coloquemos processos em segundo plano de execução (background). Para que
um processo execute em segundo plano, é preciso que ele não espere por
nenhuma ação do usuário, como por exemplo esperar por um sub-comando.
Neste estado o processo se comunicará com o usuário através dos sinais.
Basicamente para colocar qualquer processo em segundo plano de execução,
basta adicionar o caractere “&” no final da linha de comando que executará o
processo:
$ find / -name *.conf > lista_arquivos_configuracao.txt &
O comando find será executado em segundo plano e sua saída será direcionada
para o arquivo lista_arquivos_configuracao.txt
A execução em Primeiro Plano (foreground). É quando você deve esperar o
término da execução de um programa para executar um novo comando. Somente
é mostrado o aviso de comando após o término de execução do
comando/programa.

6. 6 Sistemas Operacionais Luiz Arthur
Prioridade de Execução
O Kernel do Linux possui como uma de suas atividades críticas o escalonador de
processos. Este escalonador é um algoritmo especial que coloca em fila todos os
processos em execução e decide qual processo irá ser executado e durante
quanto tempo.
O escalonador é o que permite que o computador possa executar mais de
um processo em concorrência, dividindo a CPU em fatias de tempo de
execução. A implementação do escalonador é tão importante que ela é o que
realmente faz a diferença nos sistemas operacionais modernos.
O Linux permite que o usuário interfira na prioridade de execução dos processos
liberando mais ou menos tempo de CPU. A lista de prioridade pode ser vista com
o comando ps -lax na coluna PRI. Quando maior for o número da PRIoridade,
mais tempo de CPU o processo tem e mais importante ele é. Quanto menor o
número, menos tempo de CPU e menor importância.

7. 7 Sistemas Operacionais Luiz Arthur
Path
Path é o caminho de procura dos arquivos/comandos executáveis.
O path (caminho) é armazenado na variável de ambiente PATH. Você pode ver o
conteúdo desta variável com o comando: echo $PATH
Por exemplo, o caminho /usr/local/bin:/usr/bin:/bin:/usr/bin/X11 significa
que se você digitar o comando ls, o interpretador de comandos iniciará a procura
do programa ls no diretório /usr/local/bin, caso não encontre o arquivo no
diretório /usr/local/bin ele inicia a procura em /usr/bin, até que encontre o
arquivo procurado.
Caso o interpretador de comandos chegue até o último diretório do path e não
encontre o arquivo/comando digitado, é mostrada a seguinte mensagem:
bash: ls: command not found (comando não encontrado).
O caminho de diretórios vem configurado na instalação do Linux, mas pode ser
alterado no arquivo /etc/profile. Caso deseje alterar o caminho para todos os
usuários, este arquivo é o melhor lugar, pois ele é lido por todos os usuários no
momento do login.

8. 8 Sistemas Operacionais Luiz Arthur
Caso um arquivo/comando não esteja localizado em nenhum dos diretórios do
path, você deve executa-lo usando um ./ na frente do comando, ou passando o
caminho (diretório) inteiro no prompt de comando.
Se deseja alterar o path para um único usuário, modifique o arquivo
.bash_profile em seu diretório de usuário (home).
Executando programas em seqüência
Os comandos podem ser executados em seqüência (um após o término do outro)
se os separarmos com ";". Por exemplo: echo primeiro;echo segundo;echo
terceiro
Também é possível executar um comando em seqüência com a condição AND, ou
seja, o próximo comando só vai ser executado se o anterior for executado de
forma correta. Isto é possível utilizando && entre os comandos. Por exemplo: echo
primeiro && eco segundo && echo terceiro.
Desta forma o sistema irá executar o primeiro echo, passara para o segundo, mas
este segundo foi digitado errado “eco” e desta forma não será executado e assim
o próximo comando echo também não será executado. Isto é muito útil em
scripts.

9. 9 Sistemas Operacionais Luiz Arthur
Veremos agora alguns comandos básicos para gerência de processos:
ps
O comando ps gera uma lista com todos os processos em execução e seus
atributos.
Algumas vezes é útil ver quais processos estão sendo executados no computador.
O comando ps faz isto, e também nos mostra qual usuário executou o programa,
hora que o processo foi iniciado, etc.
ps [opções]
Onde:
-a Mostra os processos criados por você e de outros usuários do sistema.
-x Mostra processos que não são controlados pelo terminal.
-u Mostra o nome de usuário que iniciou o processo e hora em que o processo
foi iniciado.
-m Mostra a memória ocupada por cada processo em execução.
-f Mostra a árvore de execução de comandos (comandos que são chamados por
outros comandos).

10. 10 Sistemas Operacionais Luiz Arthur
-e Mostra variáveis de ambiente no momento da inicialização do processo.
-w Mostra a continuação da linha atual na próxima linha ao invés de cortar o
restante que não couber na tela.
--sort:[coluna] Organiza a saída do comando ps de acordo com a coluna
escolhida. Você pode usar as colunas pid, utime, ppid, rss, size, user,
priority.
Pode ser especificada uma listagem em ordem inversa especificando --sort:[-
coluna].
As opções acima podem ser combinadas para resultar em uma listagem mais
completa.
Você também pode usar pipes "|" para filtrar a saída do comando ps.
Ao contrário de outros comandos, o comando ps não precisa do hífen "-" para
especificar os comandos. Isto porque ele não utiliza opções longas e não usa
parâmetros.
Exemplos: ps, ps aux, ps ax|grep inetd, ps auxf, ps auxw.

11. 11 Sistemas Operacionais Luiz Arthur
pstree
O comando pstree irá mostrar a árvore de processos desde o init até o último
processo em execução. É similar ao ps -auxf. Ele é útil para o entendimento da
hierarquia dos processos no Linux.
pstree [opções] [pid]
Onde:
pid Número do processo que terá sua árvore listada. Se omitido, lista todos
os processos.
Opções:
-a Mostra opções passadas na linha de comando.
-c Mostra toda a estrutura (inclusive sub-processos do processo pai).
-G Usa caracteres gráficos no desenho da árvore de processos.
-h Destaca o processo atual e seus antecessores.
-H [pid] Destaca o processo especificado.
-l Não faz quebra de linha
-n Classifica pelo número PID ao invés do nome.
-p Mostra o número PID entre parênteses após o nome do processo.
-u Mostra também o dono do processo.
-U Usa o conjunto de caracteres Unicode para o desenho da árvore.

12. 12 Sistemas Operacionais Luiz Arthur
top
Mostra os programas em execução ativos, parados, tempo usado na CPU,
detalhes sobre o uso da memória RAM, Swap, disponibilidade para execução de
programas no sistema, etc.
top é um programa que continua em execução mostrando continuamente os
processos que estão rodando em seu computador e os recursos utilizados por
eles. Para sair do top, pressione a tecla q.
O comando top mostra os processos em execução como o ps, mas atualizando a
tela. Este recurso é útil para monitorar como um ou mais processos agem no
sistema. Este comando também ordena os processos que utilizam mais CPU no
topo da tela.
top [opções]
Onde:
-d [tempo] Atualiza a tela após o [tempo] (em segundos).
-s Diz ao top para ser executado em modo seguro.
-i Inicia o top ignorando o tempo de processos zumbis.
-c Mostra a linha de comando ao invés do nome do programa.

13. 13 Sistemas Operacionais Luiz Arthur
A ajuda sobre o top pode ser obtida dentro do programa pressionando a tecla h
ou pela página de manual ($man top).
Abaixo algumas teclas úteis:
espaço - Atualiza imediatamente a tela.
CTRL+L - Apaga e atualiza a tela.
h - Mostra a tela de ajuda do programa. É mostrado todas as teclas que
podem ser usadas com o top.
i - Ignora o tempo ocioso de processos zumbis.
q - Sai do programa.
k - Finaliza um processo - semelhante ao comando kill. Você será
perguntado pelo número de identificação do processo (PID). Este
comando não estará disponível caso esteja usando o top com a opção
-s.
n - Muda o número de linhas mostradas na tela. Se 0 for especificado,
será usada toda a tela para listagem de processos.

14. 14 Sistemas Operacionais Luiz Arthur
kill
Permite enviar um sinal a um comando/programa. Caso seja usado sem
parâmetros, o kill enviará um sinal de término (TERM-15) ao processo sendo
executado, de forma que o processo seja executado de forma elegante. O kill é
usado geralmente para terminar a execução de processos identificados
pelo PID.
kill [opções] [sinal] [número]
Onde:
número É o número de identificação do processo obtido com o comando ps.
Também pode ser o número após o sinal de % obtido pelo comando jobs para
matar uma tarefa interrompida.
Sinal Sinal que será enviado ao processo. Se omitido usa -15 como padrão.
opções
-9 Envia um sinal de destruição ao processo ou programa. Ele é
terminado imediatamente sem chances de salvar os dados ou apagar os arquivos
temporários criados por ele.
Você precisa ser o dono do processo ou o usuário root para termina-lo ou destruí-
lo. Você pode verificar se o processo foi finalizado através do comando ps.

15. 15 Sistemas Operacionais Luiz Arthur
Por exemplo:
Procurando um programa chamado sshd (usado para acesso a maquinas
remotas):
#ps ax | grep sshd
4916 pts/2 S+ 0:00 grep sshd
Caso queiramos que tal programa re-leia o arquivo de configuração podemos
executar o comando kill com o sinal HUP.
#kill -HUP 4916
Porém se for necessário terminar o programa de forma brusca, por exemplo caso
ele esteja consumindo muitos recursos do seu computador, podemos enviar um
sinal -9, tal como:
#kill -9 4916

16. 16 Sistemas Operacionais Luiz Arthur
killall
O comando killall envia sinais para os processos e recebe como parâmetro não
o PID do processo, mas seu nome. Ele é usado geralmente para terminar a
execução de processos que possuem diversos filhos executando
concorrentemente.
killall [opções] [sinal] [processo]
Onde:
processo Nome do processo que deseja finalizar
sinal Sinal que será enviado ao processo (pode ser obtido usando a opção
-i). Indicado com a opção (-s).
Opções:
-i Pede confirmação sobre a finalização do processo.
-l Lista o nome de todos os sinais conhecidos.
-q Ignora a existência do processo.
-v Retorna se o sinal foi enviado com sucesso ao processo.
-w Finaliza a execução do killall somente após finalizar todos os processos.
Por exemplo:
#killall -s 9 sshd

17. 17 Sistemas Operacionais Luiz Arthur
É importante entender a diferença entre o kill e killall. O primeiro envia sinais
para um ou mais processos identificados pelo PID. O segundo envia sinais para todos
os processos na fila de execução que possuem um determinado nome.
Os sinais enviados pelo kill e pelo killall podem ser passados pelo nome ou pelo
número inteiro correspondente.
É possível, dentro de uma hierarquia de processos, que um determinado processo
filho termine por algum motivo inesperado, e o processo pai se torne um processo
zoombie ou defunto (defunct). Os processos zoombie não podem ser terminados com
o comando kill, porque eles já não existem mais.
Isso acontece porque cada processo criado recebe um lugar na tabela de processos do
Kernel. Quando ele termina, seu lugar na tabela do Kernel recebe o resultado da sua
execução. O resultado da execução é retido a tabela até alguém consultá-lo quando,
então, é removido da tabela.
O estado do processo é chamado de Zumbi quando o mesmo termina e seu resultado
ainda não foi retirado da tabela do Kernel.
Outra possibilidade especial é quando um processo qualquer que criou novos
processos filhos que executam debaixo de sua hierarquia termine inesperadamente.
Neste caso, os processos filhos perdem o seu processo pai e são adotados pelo
processo init (PID 1) que é o pai de todos os processos.
Estas duas situações descritas não são normais e podem ser ocasionadas por bugs nos
programas.

18. 18 Sistemas Operacionais Luiz Arthur
Interrompendo a execução de um processo
Para cancelar a execução de algum processo rodando em primeiro plano, basta
pressionar as teclas CTRL+C. A execução do programa será cancelada e será
mostrado o aviso de comando. Você também pode usar o comando kill.
Parando momentaneamente a execução de um processo
Para parar a execução de um processo rodando em primeiro plano, basta
pressionar as teclas CTRL+Z. O programa em execução será pausado e será
mostrado o número de seu job e o aviso de comando.
Para retornar a execução de um comando pausado, use fg ou bg (abordados a
seguir).
O programa permanece na memória no ponto de processamento em que parou
quando ele é interrompido. Você pode usar outros comandos ou rodar outros
programas enquanto o programa atual está interrompido.

19. 19 Sistemas Operacionais Luiz Arthur
jobs
O comando jobs mostra os processos que estão parados ou rodando em segundo
plano.
Processos em segundo plano são iniciados usando o símbolo "&" no final da linha
de comando ou através do comando bg.
jobs
O número de identificação de cada processo parado ou em segundo plano (job), é
usado com os comandos fg, e bg. Um processo interrompido pode ser finalizado
usando-se o comando kill %[num], onde [num] é o número do processo obtido
pelo comando jobs.
Então, o comando jobs lista os processos que estão em execução em segundo
plano. Se um número da tarefa é fornecida, o comando retornará as informações
pertinentes somente à tarefa em questão. O número da tarefa é fornecido quando
o processo é colocado em segundo plano. A opção -l pode exibir os PIDS do
programa.
Por exemplo:
#jobs -l
[2]- 5019 Stopped slocate -u
[3]+ 5020 Stopped find / -iname linux

20. 20 Sistemas Operacionais Luiz Arthur
fg
Permite fazer um programa rodando em segundo plano ou parado, rodar em
primeiro plano. Você deve usar o comando jobs para pegar o número do
processo rodando em segundo plano ou interrompida, este número será passado
ao comando fg para ativa-lo em primeiro plano.
fg [número]
Onde número é o número obtido através do comando jobs.
Caso seja usado sem parâmetros, o fg utilizará o último programa interrompido
(o maior número obtido com o comando jobs).
Exemplo: #fg 1
bg
Permite fazer um programa rodando em primeiro plano ou parado, rodar em
segundo plano. Para fazer um programa em primeiro plano rodar em segundo, é
necessário primeiro interromper a execução do comando com CTRL+ Z, será
mostrado o número da tarefa interrompida, use este número com o comando bg
para iniciar a execução do comando em segundo plano.
bg [número]
Onde: número número do programa obtido com o pressionamento das teclas
CTRL+Z ou através do comando jobs.

21. 21 Sistemas Operacionais Luiz Arthur
nice
O comando nice ajusta o tempo disponível de CPU de um processo para mais ou
para menos prioridade
nice [opções] [comando/programa]
Onde:
comando/programa Comando/programa que terá sua prioridade ajustada.
Opções:
-n [numero] Configura a prioridade que o programa será executado. Se
um programa for executado com maior prioridade, ele usará mais recursos do
sistema para seu processamento, caso tenha uma prioridade baixa, ele permitirá
que outros programas tenham preferência. A prioridade de execução de um
programa/comando pode ser ajustada de -19 (a mais alta) até 19 (a mais baixa).
Exemplo: nice -n -19 find / -name apropos
No inglês “nice” quer dizer “legal”. Se o ajuste de prioridade para um processo
for um número positivo, quer dizer que ele está sendo mais legal com os outros
programas diminuindo a sua prioridade. Se o ajuste for um número negativo,
quer dizer que o programa está sendo menos legal, aumentando a sua prioridade
de execução e sobrando menos tempo de CPU para os outros programas

22. 22 Sistemas Operacionais Luiz Arthur
Se não for passado nenhum valor de ajuste, o comando nice ajustará a prioridade
para +10, diminuindo o tempo de execução do processo.
$nice slocate -u &
recine
O comando renice ajusta a prioridade de execução de processos que já estão
rodando.
Por padrão, o comando renice recebe como parâmetro o PID de um determinado
processo.
O ajuste de prioridade é um número inteiro que vai do -20 (maior prioridade) até
o +20 (executar qualquer coisa antes deste processo).
As opções mais usuais são:
-p Recebe o PID par alterar a sua prioridade.
-u Recebe um nome de usuário par alterar a prioridade de todos os processos
deste usuário em execução.
-g Recebe um nome de um grupo para alterar a prioridade de todos os
processos pertencentes a este grupo.

23. 23 Sistemas Operacionais Luiz Arthur
Exemplo:
#renice -1 987 -u daemon root -p 32
Neste exemplo, o processo de número PID 987, PID 32 e todos os processos de
que os usuários daemon e root são donos vão ter mais prioridade.
Os usuários comuns podem alterar a prioridade dos processos de que eles são
donos. Somente o usuário root pode alterar a prioridade de qualquer processo.

24. 24 Sistemas Operacionais Luiz Arthur
fim