Ferramentas que auxiliam na monitoração de processos

Em dois posts, comentei sobre os comandos ps, kill, fg, bg, nice, renice…

Nesse post, quero falar rapidamente sobre outros comandos que podem ser uma mão na roda para o administrador de sistemas quando precisa controlar os processos no sistema!

✔ pstree

Exibe os processos em forma de árvore. Assim, fica mais facil para visualizar o ‘pai’ de cada processo.

Sem opções, o comando pstree exibe a árvore somente com os nomes dos processos. Para ver a arvore de processos com pid, utilize a opção -p.

Experimente os comandos abaixo:

# pstree

# pstree -p

✔ top

O comando top exibe os processos em tempo real. O top é uma ferramenta de mil e uma utilidades; além de exibir os processos, top também permite mudar a prioridade e enviar sinais para os processos.

# top

Para sair do top, pressione <Q>.

Ahn, e no top, para enviar sinais para o processo ou então mudar a prioridade, é necessário saber o PID do processo!

Vamos ver um exemplo onde vamos mudar a prioridade do processo cron e depois enviar sinal de término para esse processo. Por partes, como faria Jack:

1) Localizar o PID do processo:

# pgrep cron

2400

2) Executar o comando top:

# top

Dentro do top, podemos teclar ‘r’ sem aspas para mudar a prioridade do cron; vai aparecer a seguinte frase:

PID to renice:

Dai, informamos o PID, e ele solicita o valor da prioridade; podemos colocar 5.

Como o top atualiza a lista de processos em tempo real, e, por padrão ele mostra somente quem está consumindo mais CPU e memória, pode ser que o cron não apareça na lista… então, para conferir se a prioridade que setamos está correta, basta sair do top e utilizar o comando ps:

# ps lax | grep cron
1     0  2400     1  24   5   3380   752 –      SNs  ?          0:00 /usr/sbin/cron

3) Agora, vamos enviar sinal de término; caso tenha saído do top, execute-o novamente; se não, basta teclar ‘k’ sem aspas; será solicitado o PID do processo, e, em seguida o sinal que você deseja enviar; no nosso caso, vamos enviar o sinal 15, que é o padrão.

O top tem mais opções, para conhece-las:

# man top

Aproveitando, existe uma interface mais bonita para o comando top… é o comando htop; ele é colorido e mais simples para visualizar uso de CPU, memória e etc. Para utilizar, basta teclar:

# htop

✔ pidof

O comando pidof, assim como o comando pgrep, localiza o ID de um processo. A diferença entre esses dois comandos, é que o pidof somente localiza o PID do processo através do nome; já o comando pgrep, além de localizar o PID pelo nome, também localiza por outros atributos, como usuário, por exemplo.

Exemplo do comando pidof:

# pidof cron
2775

Exemplo do comando pgrep:

# pgrep -u root ssh
1954
2516
2661

No exemplo acima, localizamos todos os processos ssh cujo dono é o root.

Para saber mais sobre o pidof e o pgrep:

# man pidof

# man pgrep

pkill

O comando pkill, é uma ferramenta da família pgrep. Ele tem a mesma função que o comando kill, porém pode enviar sinais para um processo utilizando o nome do processo e outros atributos.

Assim como no comando kill, o pkill envia o sinal 15 por padrão.

Exemplo:

# pkill -HUP syslogd

Acima, estamos enviando o sinal HUP (reload) para o processo syslogd.

Para conhecer mais sobre o comando pkill:

# man pkill

✔ killall

Finaliza processos por nome. Por exemplo, finalizar todos processos bash:

# kilall -9 bash

O comando killall também pode ser interativo; isto é, antes de matar o processo, ele pergunta! Para isso, basta utilizar o comando com a opçao -i.

Exemplo:

# killall -9 bash -i
Kill bash(3178) ? (y/N)

Para conhecer outras opções do comando killall, consulte o man:

# man killall

✔ nohup

Executa um comando ignorando os sinais de interrupção. Se executado em segundo plano, o processo continuará rodando mesmo depois que o usuário efetuar o logout.

Exemplo:

# nohup ls -lR / > diretorios.txt &

Para saber mais sobre o comando nohup:

# man nohup

✔ free
O comando free exibe a quantidade de memória livre e usada no sistema. Para usar:

# free
total       used       free     shared    buffers     cached
Mem:        257080      66364     190716          0      13268      37492
-/+ buffers/cache:      15604     241476
Swap:       257000          0     257000

Quando usado sem parâmetros, o valor exibido é em kbytes; para exibir em megas, basta utilizar a opção -m:

# free -m
total       used       free     shared    buffers     cached
Mem:           251         64        186          0         12         36
-/+ buffers/cache:         15        235
Swap:          250          0        250

Para saber mais sobre o comando free:

# man free

✔ vmstat

O comando vmstat exibe a estatística do uso da memória virtual (swap):

# vmstat -S M

Acima, teremos um relatório do uso da memória virtual em megabytes (opção. Sem essa opção, o relatório será exibido em kbytes (padrão).

Uma outra opção legal do vmstat, é o relatório do uso do disco. Para isso, basta executar o comando com a opção -d:

# vmstat -d

O vmstat tem mais opções, para conhece-las:

# man vmstat

Bem, é isso aí pessoal! Até o próximo post! 😀

Anúncios

Gerenciando processos no Linux

Processo é definido como porções de programas ou programa inteiro em funcionamento na memória do computador.

Mais especificadamente, do ponto de vista do sistema operacional é a estrutura responsável pela manutenção de todas as informações necessárias à execução de um programa.

De uma forma mais simples, tudo que estiver em execução na máquina é um processo, ou seja, o VI aberto é um processo, e até mesmo o shell onde você está logado no momento é um processo. Eu até costumo dizer que eu sou um processo :P.

Os processos são independentes, e cada processo individual possui uma identificação chamada PID (Process IDentification – identificação do processo). O PID é único e não pode ser repetido até uma nova reinicialização.

No diretório /proc, para cada processo em execução existe um subdiretório. Os nomes dos subdiretórios são os PIDs desse processos; os arquivos cmdline, environ e status dentro desses subdiretórios contém informações detalhadas sobre a execução desses processos:

cmdline – O que foi digitado para iniciar o processo (pode também ter sido iniciado através de um programa ou pelo kernel).

environ – Variáveis de Ambiente existentes no momento da execução do processo.

status – Dados sobre a execução do Processo (PID, status da execução do programa, memória consumida, memória executável, UID, GID, etc).

Antes de falar sobre os comandos que usamos para controlar os processos, vou falar sobre a sequência de execução de um processo.

Quando um processo está sendo executado, passa por várias fases:

Ready (Pronto)

Running (Executando)

Waiting (Aguardando)

Logo que um processo é iniciado, está no estado ready e fica aguardando sua fatia de tempo (slice time) de CPU para ser executado (running).

No estado running, o processo está efetivamente na CPU e ficará lá até sua fatia de tempo se esgotar, voltando assim, ao estado ready.

Existem momentos em que um processo precisa aguardar o os resultado de outros processos (leitura, escrita, chamadas de sistema, etc).

Quando o processo tenta efetuar alguma operação de entrada e saída, ele pode ser bloqueado se o periférico que ele está tentando acessar estiver ocupado e passar ao estado de waiting (espera), até ser liberado novamente (ready).

Processos

Classificando os processos

Quando estão em execução, os processos podem ser classificados em foreground e background.

Foreground – processos em foreground estão rodando em primeiro plano, ou seja, o comando é executado e prende o terminal. Nada poderá ser feito no terminal até que o processo termine.

Background – processos em background estão rodando em segundo plano, ou seja, não tem interação com o usuário, não exibem a execução no monitor e não prendem o terminal (permitem que o usuário inicialize outros processos).

Monitorando processos

Para obtermos informações sobre os processos, podemos verificar o diretório /proc; mas o comando ps é a principal ferramenta para monitoramento de processos. Podemos usá-lo para exibir o PID, o UID, a prioridade e o terminal de controle de processos.

Resumindo, o comando ps consulta o /proc, e lista as informações dos processos, só que de uma forma mais simples para que nós possamos entender.

Podemos obter uma visão geral dos processos em execução com o comando ps aux:

# ps aux

Onde:

a – all – todos os processos

u – processos dos usuários

x – processos internos que não são gerados por usuários que estejam usando o terminal

Quando digitamos o comando acima, vimos que a saída do comando ps aux é em colunas:

USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root      1966  0.0  0.4   4932  1092 ?        Ss   08:55   0:00 /usr/sbin/sshd
root      1999  0.0  0.2   1576   528 tty2     Ss+  08:55   0:00 /sbin/getty 38400 tty2
root      2000  0.0  0.2   1572   528 tty3     Ss+  08:55   0:00 /sbin/getty 38400 tty3

Falando sobre as colunas:

✔ USER – Nome do usuário proprietário do processo

✔ PID – Código de identificação do processo

✔ %CPU – Porcentagem de recursos de que o processo está usando

✔ % MEM – Porcentagem de memória real que o processo está usando

✔ VSZ – Tamanho virtual do processo

✔ TTY – Identificador do terminal onde o processo está rodando

✔ RSS – Número de páginas na memória

✔ STAT – Estado atual do processo:

R – Running – Executando

S – Sleep – Dormindo; aqui, o processo está aguardando algum recurso, ou um processo se encerrar para continuar a ser executado

D – Died – Morto

Z – Zumbi – processo que deu erro e está tentando se destruir (ui! esse me lembra a volta dos mortos-vivos… =/)

T – Stopped – Parado ou interrompido

Os estados dos processos não mudam; porém, existe uma coisa chamada variação de um processo, que são as siglas que ficam ao lado do estado do processo! São elas:

< – Prioridade maior que a padrão

N – Prioridade menor que a padrão

+ – Processo em foreground

s – Processo líder de sessão (processo principal)

L – Indica que algumas páginas estão bloqueadas no kernel

✔ START – Horário em que o processo foi iniciado

✔ TIME – Tempo de CPU que o processo consumiu

✔ COMMAND – Nome do comando e seus argumentos

Agora que já sabemos como monitorar os processos, vou falar um pouco sobre os sinais que podemos enviar aos processos.

Sinais, nada mais são do que solicitações de interrupções em nível de processo. Por exemplo, quando você está executando um processo em linha de comando e tecla CTRL+C, está enviando um sinal de interrupção para o processo.

Alguns sinais que podem ser enviados aos processos são KILL, INT, TERM, HUP e QUIT.

HUP – utilizado para reiniciar um processo; geralmente usado por daemons, relê o arquivo de configuração e ajusta-se às alterações sem a necessidade de reinicialização.

INT – é um sinal enviado pelo terminal quando teclamos CTRL+C, e encerra a operação atual.

QUIT – é similar ao TERM, exceto pelo fato de gerar core dump (imagem da memória de um processo que pode ser usado para depuração).

KILL – é uma solicitação de destruição do processo (hum, isso parece grave!). Esse sinal não pode ser bloqueado ou ignorado; isto é, ele começou a destruir o processo… ele nem liga se você quer que ele pare com a destruição ou não!

TERM – é uma solicitação para terminar completamente a execução. Espera-se que o processo limpe seu estado e saia.

Ahn, os sinais acima, também são representados por números:

HUP = 1

INT = 2

QUIT = 3

KILL = 9

TERM = 15

O comando kill é utilizado para enviar sinais aos processos; pode enviar qualquer sinal, porém como padrão envia um

TERM. O comando kill pode ser usado por usuários comuns em seus próprios processos ou pelo superusuário em qualquer processo. Sua sintaxe é:

kill -SINAL PID

Onde:

-SINAL – a interrupção que será enviada ao processo; pode utilizar o nome do sinal ou o seu número

PID – Número de identificação do processo

Os sinais que mais utilizados são o -9 (KILL) e o 15 (TERM).

O -15, como já comentado anteriormente, é o sinal padrão e a forma educada de pedir para um processo parar. Mas as vezes isso não funciona, pois se o processo estiver trabalhando, não vai se encerrar…

Então, entra em ação o -9, que é o sinal matador, que não pergunta nem se o processo está sendo usado e já chuta ele da lista!

Bom, vamos ver um exemplo do comando kill. Mas antes, um comando que ajuda muito quando listagem do comando ps está longa, é o pgrep. É uma mistura do comando ps com o grep :D.

Exemplo, quero achar o PID do processo cron. Posso fazer assim:

# ps aux | grep cron
root      2633  1.0  0.2   3380   752 ?        Ss   20:01   0:00 /usr/sbin/cron

Ou então, assim:

# pgrep cron
2633

Bem, checamos que o processo está rodando, então vamos usar o kill; primeiro fazendo um teste com o -15:

# kill -15 2633

Depois, vamos ver se o cron aparece na lista:

# pgrep cron

Vejam que não aparece mais na lista! Isso quer dizer que o processo foi terminado!

Vamos ver novamente outro exemplo… agora com o processo do bash:

# pgrep bash
2425

Vamos usar o -15 de novo:

# kill -15 2425

Checando…

# pgrep bash
2425

Ui! Usamos o -15 e necas… o processo continua lá!

Vejam que usei o -15… e ele não mata pois tá te falando que ele está sendo usado!

Ou seja, se o processo está sendo usado, ele não é fechado com o -15, então terá que usar o -9:

# kill -9 2425

E ai, voces verão que volta para a tela de login novamente! (Adoro isso :P).

Só relembrando que 2425 é o número do PID que apareceu no pgrep.

Ah, existem mais sinais no Linux… para conhecer todos os sinais, consulte o man!

# man 7 signal

Bem, por enquanto é só, pessoal! No próximo post, vou comentar sobre os comandos que permitem deixar o processo rodando em primeiro e segundo plano, além de falar sobre os comandos que mudam a prioridade dos processos!

Até lá!