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😛.

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😀.

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á!

1 Response to “Gerenciando processos no Linux”


  1. 1 kaka 29/04/2009 às 5:45 PM

    como calcular o tamanho da memoria real usada por um processo?


Deixe uma resposta

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s




Follow Nix on WordPress.com
janeiro 2009
S T Q Q S S D
« dez   mar »
 1234
567891011
12131415161718
19202122232425
262728293031  

Flickr Photos

Morning Silence

Mais fotos

%d blogueiros gostam disto: