trabalho linux
TRANSCRIPT
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’.