Processos no Linux

Saber o que está sendo executado na máquina é essencial para entender o funcionamento. Este tutorial traz uma introdução sobre os processos e threads no Linux: como listá-los, finalizá-los, interpretá-los.

Cada programa executado, desde a inicialização do sistema, é definido com o que chamamos de processo. Cada um desses processos recebe um número de identificação próprio, chamado PID (Process ID). Além do PID, cada processo tem um conjunto de informações como: nome do comando, uso da memória, usuário e grupo que o executou, entre outros.

As informações de todos os processos do sistema ficam armazenadas no pseudo-diretório /proc. Dentro deste diretório, cada sub-diretório numérico contém as informações do processo com o número PID correspondente. É deste lugar que os comandos relacionados aos processos retiram suas informações.

ps – Listar processos

Sintaxe: $ ps [opções]

Lista os processos em execução, apresentando o PID e outras informações sobre o processo, como o comando executado (CMD) e estado atual do processo (STAT).

Exemplo:

$ ps auxUSER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMANDroot         1  0.0  0.0   1932   704 ?        Ss   Aug29   0:02 init [2]root         2  0.0  0.0      0     0 ?        S<   Aug29   0:00 [kthreadd]root         3  0.0  0.0      0     0 ?        S<   Aug29   0:00 [migration/0]root         4  0.0  0.0      0     0 ?        S<   Aug29   0:06 [ksoftirqd/0]...corte...daemon    2998  0.0  0.0   1868   432 ?        Ss   Aug29   0:00 /usr/sbin/atdroot      3017  0.0  0.0   3272   928 ?        Ss   Aug29   0:00 /usr/sbin/cronroot      3074  0.0  0.0   2972   644 ?        Ss   Aug29   0:00 /usr/bin/kdmroot      3077  1.7 18.5 390652 384220 tty7    SLs+ Aug29  39:30 /usr/bin/X -br...corte...root      3092  0.0  0.0   1608   508 tty1     Ss+  Aug29   0:00 /sbin/gettyroot      3093  0.0  0.0   1608   508 tty2     Ss+  Aug29   0:00 /sbin/gettyroot      3094  0.0  0.0   1608   504 tty3     Ss+  Aug29   0:00 /sbin/gettyroot      3095  0.0  0.0   1608   504 tty4     Ss+  Aug29   0:00 /sbin/gettyroot      3096  0.0  0.0   1608   504 tty5     Ss+  Aug29   0:00 /sbin/gettyroot      3097  0.0  0.0   1608   508 tty6     Ss+  Aug29   0:00 /sbin/gettyeitch  9403  4.5  0.1   5900  3364 tty1     S    23:50   0:00 -basheitch  9416  2.0  0.1   5304  2388 tty1     S+   23:50   0:00 vi testando

O parâmetro aux faz com que o comando ps mostre todos os processos do sistema, associado aos seus respectivos usuários e de forma detalhada. Nesta forma detalhada, podemos ver vários “campos” especificados na primeira linha. Eles são:

USER Usuário que iniciou o processo (dono).

PID Número único do processo.

%CPU Utilização da CPU em porcentagem.

%MEM Utilização da memória física do sistema em porcentagem.

VSZMemória virtual utilizada pelo processo, inclui a memória física e utilizada por bibliotecas compartilhadas.

RSSMemória física utilizada pelo processo. Inclui memória utilizada por bibliotecas compartilhadas.

TTYTerminal ao qual o processo pertence. Quando não há um terminal controlando (como no caso dos processos do sistema, kernel e processos do servidor gráfico) aparecerá o sinal de interrogação.

STAT Estado atual do processo (mais detalhes depois).

STARTA hora em que o processo foi iniciado. Caso a hora seja do dia anterior, é representado pelo dia e mês.

TIMETempo cumulativo de CPU, ou seja, por quanto tempo o processo utilizou a CPU.

COMMAND

O comando executado e todos seus argumentos. Caso o tamanho do comando seja maior do que a linha do terminal, ele ignora o resto (não passa para a próxima linha). Para mostrar todo o argumento, utilize o parâmetro w para ajustar o comprimento.

Em relação ao estado do processo, uma letra estará representando um destes estados:

DDescansando enquanto espera por outra ação (geralmente E/S), sem possibilidade de interrupção.

R Executando (Running).

SDescansando enquanto espera por outra ação (esperando algum evento ser completado), com possibilidade de interrupção.

T Parado, suspendido. Talvez pelo gerenciamento de tarefas da shell (CTRL+Z).

Z Zumbi. SINISTRO! O processo foi terminado mas não foi removido por quem o chamou.

Uma outra forma de ver os processos, agora organizados por árvore:

$ ps axjf

top – Lista processos em tempo real

Sintaxe: $ top [opções]

Mostra ao usuário os processos ativos no sistema da mesma forma que o ps, mas em tempo real e em uma certa ordem. Por padrão, o top mostra nas primeiras linhas os processos que mais gastam processamento (em porcentagem).

Ao executar o top sem argumentos, sua taxa de atualização na tela é de 3 em 3 segundos. Para mudar para, por exemplo, 1 segundo:

$ top -d 1

Uma vez dentro do programa, a tecla h mostra a ajuda. Uma das opções úteis é a tecla f que permite especificar a ordem das linhas de acordo com os campos (mais utilização de cpu, memória, maior número UID de usuário, entre outros).

pstree – Mostra processos em forma de árvore hierárquica

Sintaxe: $ pstree [opções]

Mostra de forma simples e utilizando caracteres ASCII uma árvore hierarquica dos processos do sistema.

Sinais de Processos

Todo processo, além da entrada padrão que pode ser controlada dentro do programa, também pode receber o que chamamos de “sinal”. Este sinal é o modo que o sistema operacional tem para lidar com o processo. Um sinal pode dizer ao programa para terminar, ou outro sinal pode simplesmente terminar o programa sem dizer nada. Apertar um CTRL+C (Interrupção) no terminal é um sinal que o sistema manda para o programa atual.

Para saber a lista de sinais, digite:

$ man 7 signal

Quem faz uma aplicação pode programar para que quando um sinal for recebido pelo processo, o programa se comporte de uma certa maneira. O sinal SIGTERM (15) por exemplo, é chamado quando o programa é finalizado normalmente. Já o sinal SIGINT (2) é chamado quando o usuário aperta o CTRL+C e o programa tem que lidar com essa interrupção.

Os únicos sinais que são forçados pelo kernel são os sinais SIGKILL (9) e SIGSTOP (19). Neste caso, não importa o que o programador tentou fazer, vai ser executada as funções dos sinais nos processos.

Os sinais mais importantes são: SIGHUP (1), SIGINT (2), SIGKILL (9), SIGSEGV (11), SIGTERM (15) e SIGSTOP (19).

O SIGHUP (1) é geralmente utilizado pelos programas para recarregar seus arquivos de configuração. Um exemplo de programa que utiliza o SIGHUP para este fim é o inetd/xinetd.

O SIGINT (2) é recebido quando o usuário aperta a combinação de teclas CTRL+C. A grande maioria dos programas utiliza esse sinal para indicar uma interrupção do programa, para parar o que estiver fazendo e continuar com outra ação (ou finalizar o programa).

O SIGKILL (9) é o sinal que mata o processo. Não importa o que o processo esteja fazendo ou se ele é importante, o kernel irá forçar a sua finalização imediatamente. Este sinal não pode ser bloqueado ou rejeitado pelo programa.

O SIGSEGV (11) é um sinal recebido quando há alguma falha na alocação de memória. Também conhecido como “Segmentation Fault”, ele geralmente indica um problema no programa ou na pior das hipóteses problemas na memória física do computador.

O SIGTERM (15) é recebido pelos programas dizendo-os para finalizar de forma normal. É equivalente a fechar uma janela em um ambiente gráfico.

O SIGSTOP (19) é o sinal que suspende os programas, ou “os deixam imóveis” para poder manipulá-los como no uso do CTRL+Z na shell, ou então quando se está executando um trace em um programa.

kill, killall – Envia um sinal ao processo

Sintaxe: $ kill [-SINAL] <PID>

Sintaxe: $ killall [-SINAL] <nome do processo>

Apesar do nome, o comando kill não mata um processo e sim apenas manda um sinal para ele. Mas como já sabemos, há um sinal onde o kernel literalmente mata o processo. Para obter uma lista dos sinais suportados pelo sistema através do comando kill, digite:

$ kill -l

Para o comando kill, precisamos primeiro identificar o seu número PID, para depois mandar o sinal.

Por exemplo, temos um processo executando (vim) e queremos que ele seja morto (SIGKILL) sem aviso prévio:

$ ps aux

 USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND

...corte...

eitch    2315  0.1  0.6   9364  3544 pts/1    S+   12:46   0:02 vim arquivo

Uma vez obtido o PID do processo:

$ kill -9 2315

Então o processo 2315 será morto sem piedade através do sinal SIGKILL.

Neste exemplo anterior, tivemos que obter o PID do processo para enviar um sinal. Com o comando killall, podemos mandar um sinal para todos os programas que têm um certo nome no comando. Utilizando desta forma, não é preciso saber o PID, mas por outro lado se houver dois processos com o mesmo nome, o sinal será mandado para os dois.

Matando o mesmo processo do exemplo anterior, agora utilizando o comando killall:

$ killall vim

Comando Básico do Linux

Gerencia de Processos

1- ps – lista processos

2- top- – lista processos em tempo real

3- pstree- mostra processos em forma de arvore hierarquia

4- Kill e killal- envia um sinal ao processo (MATA)

5- Nice e renice- configura prioridades de CPU de um comando ou processo

6- Lsof-listar arquivos abertos por processos

# ps   # Visualiza os processos em execução

# ps -a   # Exibe processos de outros usuários também

# ps -u   # Exibe os processos detalhadamente inclusive com uso de memória

# ps -x   # Exibe os processos que não estão vinculados a terminais

# ps -ef   # Exibe todos os processos e mostra o PPID

# top   # Exibe os processos que utilizam CPU em tempo real

# top -d   # Exibe os processos que utilizam CPU em tempo real com atualização de 1 seg

# kill -9 (processo)   # Mata um processo

# kill -l   # Mostra as opções do comando kill 

Matar processos no Ubuntu

Neste post rápido vou mostrar como matar processos no Ubuntu.

No Windows, você pode usar o Gerenciador de Tarefas  (para abrir use

CTRL+SHIFT+ESC) para verificar qual processo está usando mais

memória/cpu e finalizá-lo. Entretanto, como fazer isso no Ubuntu?

Primeiro passo: Abra o terminal e digite o seguinte comando:

View Raw Code ?

1. ps -aux

Segundo passo: Verifique qual tipo de processo está consumindo

mais memória/cpu.

Na foto abaixo, você irá ver a lista dos processos ativos. Na primeira

coluna está o usuário que iniciou a tarefa. Na segunda coluna está

a identificação do processo, na terceira coluna e quarta coluna estão

respectivamente a indicação de uso da CPU e Memória.

Lista

dos processos ativos

Nas outras colunas estão outras informações relevantes como: hora de

início do processo, o comando que originou a tarefa, etc.

O que realmente nos interessa são a segunda, terceira e quarta coluna;

e em especial, a segunda coluna. Ela tem a informação do ID do

processo o qual iremos usar no terceiro passo.

Terceiro passo: Torne-se root (sudo su e depois sua senha) e use o

seguinte comando, após identificar a tarefa a ser exterminada.

View Raw Code ?

1. kill -8 (pid - ou o ID do processo a ser finalizado)

Pronto! Processo finalizado!

Duas formas de matar processos no Linux  - Pedro Mendes

Posted by Pedro Mendes on jul 12, 2010 in Dicas, Linux | 3 commentscomando top Como finalizer um processo no Linux dica dicas ubuntu matando pelo terminal

LOL, finalmente mais um dica rápida hein?! A última foi “[Dica Rápida] Corrigindo o erro no

WordPress: WP HTTP Error: name lookup timed out”, no dia 24 de junho.

Hoje vou dar uma dica, que principalmente o pessoal que está migrando agora para linux, vão adorar.

Que é Como finalizar um processo no Linux, no Windows basta pressionar CTRL + ALT + DEL para

abrir o gerenciador de processos e escolher o processo. No Linux tem duas maneiras, pelo monitor do

sistema e pelo terminal, veja como fazer abaixo:

Para Matar algum processo no linux pelo Monitor do Sistema, basta ir

emSistema>>Administração>>Monitor\ do\ Sistema\ e vai aparecer uma janela idêntica a esta abaixo,

onde mostra algumas informações sobre o computador:

Na Aba Processos, você poderá finalizar os processos e ainda olhar qual está consumindo mais Memória.

Para finalizar um processo basta clicar em qual você quer encerrar e depois clicar em“Terminar

processo”

Pelo terminal não é muito difícil, primeiramente basta conhecer o comando top e alguns detalhes dele.

Bom, a função do comando top é mostrar em tempo real as informações sobre o seu sistema. Também

mostra os processos em andamento e também os recursos do sistema, CPU, memória RAM, uso do

swap e o número de tarefas sendo executadas, que também podem ser vistas na aba “Recursos” e 

“Sistemas de arquivos” do Monitor do Sistema.

Veja os comandos interativos do comando top:

”k” - Finaliza, ou seja, “mata” um processo.

”m” - Ativa/Desativa a exibição de informações da memória.

”M” – Ordena os processos pelo uso da memória residente.

”N” - Ordena os processos pelos seus PIDs.

”P” - Ordena os processos pelo uso da CPU (este é o padrão).

”ESPAÇO” - Atualiza imediatamente a visualização do quadro de processos.

”h” - Exibe a ajuda dos comandos interativos do ”top”.

”q” - Abandona o comando ”top”.

Para terminar um processo no terminal, digite: “top”, pressione “k” e depois digite o PID e

pressione“Enter” duas vezes, veja a imagem abaixo:

Também é possível encerrar o processo pelo nome dele, digite “killall” e depois o nome do processo, por

exemplo, “chrome”.

Por Dentro do Processo de Inicialização do Linux

O processo de inicialização de um sistema Linux® consiste de diversos estágios. Mas quando se efetua boot em um desktop x86 padrão ou um destino do PowerPC fortemente embarcado®, muito de seu fluxo tem uma semelhança surpreendente. Este artigo abrange o processo de boot do Linux, desde a primeira autoinicialização até o início do primeiro aplicativo de espaço do usuário. Nesse artigo, serão vistos vários outros tópicos relacionados ao boot, como os loaders de boot, a descompactação de kernels, o disco RAM inicial e outros elementos de boot do Linux.

Antigamente, para autoinicializar um computador, era preciso alimentar uma fita de

papel que continha um programa de boot ou carregar manualmente um programa de

boot utilizando os controles de endereço do painel frontal/dados/controle. Os

computadores atuais são equipados com recursos que simplificam o processo de boot,

embora não necessariamente o deixem mais simples.

Vamos começar com uma visualização de alto nível de boot do Linux para que se

tenha uma visão geral. Em seguida, revisaremos o que ocorre separadamente em

cada uma das etapas. As referências de origem durante esse processo o ajudarão a

navegar pela árvore de kernel e a entender melhor esse processo

Visão Geral

A Figura 1 mostra uma visualização estratégica.

Figura 1. Visualização Estratégica do Processo de Inicialização do Linux

Quando um sistema efetua boot pela primeira vez, o processador executa um código

em um local conhecido. Em um Computador Pessoal (PC), esse local é o Sistema

Básico de Entrada/Saída (BIOS), que está armazenado na memória flash, na placa-

mãe. A Unidade Central de Processamento (CPU) em um sistema embarcado solicita

ao vetor de reconfiguração que inicie um programa em um endereço conhecido em

flash/ROM. Nos dois casos, o resultado é o mesmo. Como os PCs oferecem bastante

flexibilidade, o BIOS precisa determinar quais dispositivos são candidatos ao boot.

Examinaremos isso posteriormente com mais detalhes.

Quando um dispositivo de boot é encontrado, o loader de boot de primeiro estágio é

carregado na RAM e executado. Esse loader de boot tem menos de 512 bytes (um

único setor), e sua tarefa é carregar o loader de boot de segundo estágio.

Quando o loader de boot de segundo estágio está na RAM e em execução, uma tela

inicial é geralmente exibida e o Linux e o disco RAM inicial opcional (sistema de

arquivo raiz temporário) são carregados na memória. Quando as imagens são

carregadas, o loader de boot de segundo estágio passa o controle para a imagem do

kernel e o kernel é descompactado e inicializado. Neste estágio, o loader de boot de

segundo estágio verifica o hardware do sistema, enumera os dispositivos de hardware

anexados, monta o dispositivo raiz e, em seguida, carrega os módulos de kernel

necessários. Ao ser concluído, o primeiro programa de espaço de usuário (init) inicia e

a inicialização do sistema de alto nível é executada.

Em resumo, é assim que funciona o boot do Linux. Agora vamos prosseguir e explorar

alguns dos detalhes do processo de boot do Linux.

Comando para mostra processos e matar processos

Método

Antes de começar, vamos a algumas considerações. Utilizaremos dois comandos:

“ps -aux” e “kill -9″. O “ps -aux” te mostrará todos os processos abertos no sistema

incluindo os inicializados durante o boot. Já o “kill -9″ irá fechar na marra o

processo. Então, chega de falar e vamos agir. No terminal, dê o comando abaixo

para listar todos os processos.

$ ps -aux

Fazendo isso, aparecerá várias linhas. Na segunda coluna, há um número de PID

para cada processo. Anote o número PID do processo que você quer matar. No

exemplo, quero fechar o Firefox porque ele está com uma instabilidade. Seu

número PID é 2896. Feito isso, digito no terminal o comando para fechar o processo

número 2896, que é o Firefox.

$ kill -9 2896

Prontinho!! Firefox morto.

Atualização em 22/06/2010: Um comando melhor que o ‘ps -aux’ é o ‘ps -e’.