Mostrando postagens com marcador htop. Mostrar todas as postagens
Mostrando postagens com marcador htop. Mostrar todas as postagens

sexta-feira, 14 de setembro de 2012

Glances - Um Excelente Software de Monitoramento de Processos e Perfomance

screenshot
Olho em Seu Sistema!

Este é o lema principal do glances. Em uma tela só, números sobre processos, cpu, memória e outros parâmetros que são essenciais para um Sysadmin manter o monitoramento dos seus servidores ao alcance dos seus olhos.

Glances é um software de monitoramento CLI (Command Line Interface) baseado em Curses. Não espere gráficos, imagens e animações... É um software de monitoramento presencial. ;)

A página oficial é esta: http://nicolargo.github.com/glances/ e é mantido pelo  programador Nicolas Hennion. O Software é feito em Python

A Interface dele trás  dados imediatos sobre:
  • O uso do processador (por core, por processador);
  • Carga do Sistema 
  • Uso da Memória RAM;
  • Uso da Memória SWAP;
  • Quantidade de processos (ordenado por uso de CPU, Memória ...);
  • Uso das placas de rede;
  • Uso dos HDs e partições (Inputs e Outputs);
  • Uso de espaço das partições e dispositivos de armazenamento.

A Tela é simples, mas é atualizada a cada segundo e tem tudo que um Sysadmin precisa.

Veja este exemplo numa interface de 80x24 linhas (Uma tela típica de console)

screenshot


Outro exemplo ele em uma tela maior (wide) de 90x24.

screenshot

Note no exemplo da figura acima, que  ele gera alertas quando alguns limites são alcançados.

Dica:
Não espere gerenciar processos com o Glances, para isso use o HTOP que abordei neste tópico: http://www.dailson.blogspot.com.br/2012/05/gerenciamento-de-processos-no-linux.html

Instalação:

Pré-requesitos:
  • Python 2.6 ou superior;
  • Para Distribuições baseadas em Debian, o Pacote build-essential  (para instalação  via Pypi e setup.py);
  • Para Distribuições baseadas em Redhat/Fedora/CentOS, o Pacote Development Tool  (para instalação  via Pypi e setup.py);
  • python-dev (para instalação via Pypi);
  • python-setuptools (para instalação via setup.py);
  • python-psutil 0.4.1 ou superior;
  • python-jinja2 2.0 ou superior (opcional para exportar HTML );
Se você for instalar via apt-get ou yum não se preocupe, todas estas dependências são resolvidas automaticamente.

Método 1: Instalando em Distribuições Debian.

$ sudo apt-get install python-pip build-essential python-dev
$ sudo pip install glances

Método 2: Utilizando os repositório PPA no Ubuntu/Mint...

$ sudo add-apt-repository ppa:arnaud-hartmann/glances-stable
$ sudo apt-get update
$ sudo apt-get install glances



Método 3: Compilando através do código fonte

$ wget -O /tmp/glances-last.tgz https://github.com/nicolargo/glances/tarball/master
$ sudo apt-get install python-setuptools build-essential python-dev
$ cd /tmp
$ tar zxvf glances-last.tgz
$ cd nicolargo-glances-*
$ sudo python setup.py install



 Para executar, basta apenas digitar

$ glances

 Por padrão, o glances atualiza a tela a cada segundo, se quiser mudar o tempo, use o parâmetro -t

$ glances -t 5

O Status das Cores
É importante ressaltar aqui o que cada cor representa no glances
VERDE: Tudo Certo!
AZUL: Atenção ...
MAGENTA: Cuidado ...
VERMELHO: Estado Crítico!

Durante o uso do Glances, você pode utilizar algumas teclas de atalho para mudar o comportamento dele.
h --> exibe ajuda
c --> ordena os processos por consumo do processador
d --> habilita/desabilita a exibição do Status de I/O do Disco
f --> habilita/desabilita a exibição do Status de I/O dos arquivos
I --> habilita/desabilita os logs (alertas no fim da tela quando algum limite é alcançado).
n --> habilita/desabilita a exibição do Status de I/O das placas de rede
p --> ordena pelo nome dos processsos
q --> sai


As colunas exibidas pelo Glances são:

  • VIRT: Memória virtual em bytes
  • REST: Total residente em memória em bytes
  • CPU%: % de CPU utilizada
  • MEM%: % de MEM utilizada
  • PID: Identificador do Processo
  • USER: Usuário dono do Processo
  • NI: Prioridade do processo.
  • S: Status do processo:
    • R - Running
    • D - Sleeping (não pode ser interrompido)
    • S - Sleeping (pode ser interrompido)
    • T - Traced ou Stopped
    • Z - Zombie
    • IO Read and Write
    • TIME+: Uso total da CPU em tempo
    • NAME: Nome do processo
Fonte:
 http://nicolargo.github.com/glances/

Este software foi uma dica de Luciano Domingues, da Suporte Informática.

quarta-feira, 16 de maio de 2012

Gerenciamento de Processos no Linux


Segue o resumo de comandos e conceitos vistos em Sala de Aula.
Este é um material de apoio aos meus alunos que tem todo embasamento durante as aulas presenciais.

Você pode fazer o exercício desta aula no seguinte link:
http://dailson.blogspot.com.br/2012/10/exercicio-da-aula-9-gerenciamento-de.html

As respostas deste exercício estão no seguinte link:
http://www.dailson.blogspot.com.br/2012/10/exercicio-da-aula-9-gerenciamento-de.html

Você pode encontrar todos os resumos de aula no link abaixo:
http://www.dailson.com.br/2009/05/indice-mini-tutoriais-usados-em-aula.html

Comunicação entre processos:
O Linux possui diversas formas de realizar comunicação entre processos, também conhecido com IPC. Estas formas de comunicação se referem a processos em execução na mesma máquina, o que não inclui sockets ou RPC (são para comunicação entre máquinas distintas).

Dentre as técnicas de comunicação entre processos fornecidas pelo Linux, convém citar:

a) por memória compartilhada: através de diretivas shm* pode-se disponibilizar uma área de memória comum à vários processos. Simples: quando um processo quer enviar dados ao outro, põe na memória.

b) pipes: um método muito interessante onde se cria um canal bidirecional na tabela de descritores, como se fosse arquivo, mas não é (e não tem I/O). Quando você faz um ls -la | sort está usando pipe!

c) sinais: quando um processo quer sinalizar algo a outro processo. Ao contrário das demais nesta não se envia dados mas apenas um valor numérico.

Existem outras formas de comunicação como semáforos, fila de mensagens e até mesmo morte de filho, que é considerada uma comunicação. Se você digitar ipcs na linha de comando irá ver os canais de comunicação atualmente em uso (não sinais).
Texto retirado do Artigo: http://www.vivaolinux.com.br/artigo/Sinais-em-Linux/?pagina=1

Comandos:
Listar os processos do terminal
# ps

Listar os processos de todos os terminais
# ps -a
# ps a (exibe os processos mais detalhes)

LIstar os processos dos usuários
# ps -u
# ps -au

Lista todos os processos do Sistema
# ps -A
# ps -ef
# ps -eF
# ps -ely
# ps ax
# ps aux (exibe uma coluna com o nome do usuário que iniciou o  processo)

Exibe todos os processos em forma de árvore
# pstree
# ps -ejH
# ps axfj
Obs: teste os vários parâmetros do comando pstree:
-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.


Exibe informações sobre Threads
# ps -eLf
# ps axms

Exibe informações de segurança dos processos
# ps -eo euser,ruser,suser,fuser,f,comm,label
# ps axZ
# ps -eM

Exibe todos os processos que estão sendo executados com permissões de root (real e com ID)
#  ps -U root -u root u

Especificando as colunas para visualização:
Exemplos:
Apenas o Numero do processo e o comando que o gerou
# ps ao PID,COMMAND

Apenas o numero do processo, o comando que gerou o pid, o uso da CPU e da memória
# ps ao pid,%cpu,%mem,command

Outros exemplos tirados do manual do ps:
# ps -eo pid,tid,class,rtprio,ni,pri,psr,pcpu,stat,wchan:14,comm
# ps axo stat,euid,ruid,tty,tpgid,sess,pgrp,ppid,pid,pcpu,comm
# ps -eo pid,tt,user,fname,tmout,f,wchan

Exibir processos e prioridade do processo (Coluna NI)
# ps l
# ps -l
# ps -Al
# ps -el

Significado das Principais colunas do comando TOP:
    USER - Nome do usuário dono do processo.
    UID - Número de identificação do usuário dono do processo.
    PID - Número de identificação do processo.
    PPID - Número de identificação do processo pai de cada tarefa.
    PRI - Número de prioridade da tarefa. (Números altos são prioridades baixas).
    NI - Valor preciso da prioridade da tarefa.
    %CPU - O consumo de processamento do processo.
    %MEM - O consumo de memória do processo.
    SIZE - Tamanho do código da tarefa em kilobytes.
    RSS - Soma total da memória física usada pelo processo, em kilobytes.
    WCHAN - Endereço ou nome da função do kernel da tarefa que está atualmente suspensa.
    STAT - Estado do processo: S - Suspenso, R - em Execução, T - Interrompido, Z - Terminado, etc.
    TTY - Terminal onde são executados os processos.
    TIME - Tempo total da CPU usado pelo processo desde que foi iniciado.
    COMMAND - Nome do comando do processo.


Entendendo os Sinais:
Sinais são usados quando se deseja enviar uma mensagem para um processo, mas esta mensagem não é um texto, mas sim um código cujo significado é pré determinado. Antes de mais nada, para dar o melhor exemplo possível, quando se executa um kill 7000 está se enviando para o processo 7000 o sinal de código 15 que significa algo como "Caro processo, queria gentilmente terminar a sua execução".
Como o sinal 15 significa terminar, o processo irá terminar a sua execução. Como todos já devem saber, se o "gentil" processo recusar-se a terminar, posso forçar com um kill -9 7000, onde envio para ele o sinal 9 que significa algo como: "Morra!" (uma vez disse em um curso que com sinal 15 eu dou a arma para o processo esperando que ele aperte o gatilho, depois de escrever o seu testamento, fechar suas finanças etc. Com o -9 é um tiro na testa sem aviso).


Principais Sinais:
Sinal 1: Significa reinício do programa. Este sinal é chamado de SIGHUP.

Sinal 2: Sinal chamado de SIGINT. Causa uma interrupção no programa. Falando em termos práticos, é um sinal 2 que o programa recebe quando se pressiona Control+C.

Sinal 15: esta é a solicitação de morte, chamada de SIGTERM. Ao receber um sinal 15 o processo deveria preparar-se para terminar, fazendo "seus últimos pedidos" e ele mesmo encerrando normalmente sua execução.

Sinal 9: SIGKILL. Este é a morte indefensável. Não pode ser mascarado, ou seja, o programador não consegue substituir a rotina de tratamento do Sistema Operacional que simplesmente tira o processo da fila de prontos. Deve ser usado em último caso, pois um sinal 15 é mais elegante por dar a chance ao processo de se preparar para sua morte.

Sinal 20: SIGTSTOP. Este sinal de STOP faz com que o processo interrompa a sua execução. Veja, ele não termina, apenas interrompe.

Sinal 18: SIGCONT. Este sinal de CONTINUAR, faz com que o processo que foi interrompido pelo Sinal 20, continue seu processamento.

Fonte: http://www.vivaolinux.com.br/artigo/Sinais-em-Linux/?pagina=2


Enviando Sinais para os Processos:
Vamos utilizar dois comandos. O KILL e o KILLALL.
A diferença entre estes dois comandos é que o KILL envia sinais para os números dos processos e o KILLALL envia para nomes.

Exemplo:
Abro o vim em um terminal. E suponho que ele está travado. Quero enviar um sinal para este processo. Com o comando KILL precisariamos de dois passos:

1º Vou para outro terminal e executo o comando ps a
2º Anoto o PID do VIM
3º kill -15 o número do PID do vim.
   Exemplo: kill -15 4567

Usando o KILLALL, iríamos para outro terminal e fariamos apenas:
# killall -15 vim
Obs: Porém se tiver mais programas vim abertos, todos receberão o mesmo sinal.

Para os exemplos abaixo, vamos supor que estamos enviando sinais para o processo 4567 - backup.sh

Reiniciando o processo
# kill -SIGHUP 4567
# kill -1 4567

Interrompendo o programa
# kill -SIGINT 4567
# kill -2 4567

Encerrando um programa (educadamente)
# kill -SIGTERM 4567
# kill -15 4567

Matando um processo (LUNGA MODE=ON)
#  kill -SIGKILL 4567
# kill -9 4567

Parando (congelando) um processo na memória
# kill -SIGSTOP 4567
# kill -20 4567

Retomando o processo (congelado no tópico anterior)
# kill -SIGCONT 4567
# kill -18 4567

Primeiro Plano (FOREGROUND) e Segundo Plano (BACKGROUND)
Você sabia que no mesmo terminal posso iniciar vários processos e deixá-lo em background. Ainda tenho a opção de deixá-lo parado ou executando.

Para termos um bom exemplo de programas executando em segundo plano, vamos criar um pequeno script que terá a função apenas de contar de 1 até infinito.

Passos para escrever o script:
vim conta.sh
#!/bin/bash
while :  ;
do
   let i++
done

Pressione a tecla ESC e digite :x

Tornando o script executável
# chmod +x conta.sh

Executando o script:
# ./conta.sh

Parece que ele não está fazendo nada, mas ele está contando de 1 até infinito. Para cancelar o programa, basta digitar CTRL+C
OBs: CTRL+C é o mesmo que kill -SIGINT ou kill -2

Iniciando um processo.
Vamos colocar em segundo plano os programas vim /etc/services, nano, man ls, cat /etc/services | more,

# vim /etc/services
Pressione CTRL+Z
O processo vai para segundo plano.

# man ls
Pressione CTRL+Z
O processo vai para segundo plano.

# cat /etc/services | less
Pressione CTRL+Z
O processo vai para segundo plano.

# cat /etc/services | more
Pressione CTRL+Z
O processo vai para segundo plano.

E por ultimo vamos chamar o nosso programa, o conta.sh
# ./conta.sh

Exibindo os processos que estão em segundo plano (background):
# jobs
Se você seguiu meus exemplos acima, você terá esta lista:

[1]   Stopped                 vim /etc/services
[2]   Stopped                 man ls
[3]   Stopped                 cat /etc/services | less
[4]-  Stopped                 cat /etc/services | more
[5]+  Stopped                 ./conta.sh

Ativando programas que estão em Segundo Plano
Na listagem acima, o processo conta.sh é um programa que está com o status Stopped. Mas sabemos que este programa tem a função de contar. Para ativar este programa você tem duas

maneiras possíveis:
A primeira é mandar o sinal SIGCONT para ele. A outra, bem mais fácil é fazer o seguite:
# bg 5

Ao executar o comando jobs, veja como ficou nossa lista:
[1]   Stopped                 vim /etc/services
[2]   Stopped                 man ls
[3]   Stopped                 cat /etc/services | less
[4]-  Stopped                 cat /etc/services | more
[5]+  Running                 ./conta.sh &

Note que agora o conta.sh status Running (executando) e apareceu um novo símbolo ao lado do nome do programa: &

O Símbolo & avisa que o programa está sendo executado em segundo plano.

Se você desejar parar novamente o conta.sh, basta digitar:
# killall -SIGSTOP conta.sh

Mais uma vez, vamos ver como ficou através do comando jobs
[1]   Stopped                 vim /etc/services
[2]   Stopped                 man ls
[3]   Stopped                 cat /etc/services | less
[4]-  Stopped                 cat /etc/services | more
[5]+  Running                 ./conta.sh &

Outra maneira de ativá-lo novamnete é enviando um sinal através do comando KILL
# killall -SIGCONT conta.sh

Trazendo para primeiro plano (foreground) programas que estão em segundo plano (background).

De posse da lista de processos que estão em segundo plano, basta você digitar o comando fg e número do programa nesta lista e você terá o programa de volta em primeiro plano.
Observe a lista do comando jobs:
[1]   Stopped                 vim /etc/services
[2]   Stopped                 man ls
[3]   Stopped                 cat /etc/services | less
[4]-  Stopped                 cat /etc/services | more
[5]+  Running                 ./conta.sh &


# fg 1 (trará o vim /etc/services para primeiro plano)
Para voltar para background digite mais uma vez CTRL+Z.

Emita o comando jobs mais uma vez:
# jobs

Veja o resultado da lista:
[1]+  Stopped                 vim /etc/services
[2]   Stopped                 man ls
[3]   Stopped                 cat /etc/services | less
[4]   Stopped                 cat /etc/services | more
[5]-  Stopped                 ./conta.sh

Notou que agora o sinal de + saiu da posição 5 e foi para a posição 1? E o sinal de menos da posição 4 para a posição 5?
Estes sinais demonstram os dois últimos programas que foram colocados em backgroud. Caso você digite fg sem parametros, o programa que virá para primeiro plano é o que tem o

sinal + e o próximo da fila que era o - torna-se + e assim por diante.

Colocando programas em segundo plano diretamente na linha de comando.
# ./conta.sh &
O Uso do & já coloca o programa em segundo plano em execução.
Repita este comando várias vezes, e veja um resultado semelhante a este:

[1]+  Stopped                 vim /etc/services
[2]   Stopped                 man ls
[3]   Stopped                 cat /etc/services | less
[4]   Stopped                 cat /etc/services | more
[5]-  Stopped                 ./conta.sh
[6]   Running                 ./conta.sh &
[7]   Running                 ./conta.sh &
[8]   Running                 ./conta.sh &
[9]   Running                 ./conta.sh &
[10]   Running                 ./conta.sh &
[11]   Running                 ./conta.sh &

Obs: Toda vez que você chama um programa já em segundo plano, o Shell exibe na linha abaixo o número do processo no qual ele está submetido.

[dailson@server tmp]$ ./conta.sh &
[11] 12642

Outra observação importante é que quando executamos um programa em segundo plano e ele acaba sua execução o Shell avisa emitindo uma mensagem na própria linha de comando.
Teste você mesmo. Execute o comando que atualiza o banco de dados do comando locate.
# updatedb &
[12] 12649

Fique pressionando enter algumas vezes. Em determinado momento o Shell emite a seguinte mensagem:
Done [12] 12649
Informando que o processo já foi concluido.

Prioridade de Processos no Linux
Os processos no Linux (no espaço do usuário) vão de -20 a +19.
A prioridade padrão de qualquer processo iniciado pelo usuário é 0.
Numeros negativos, indicam maior prioridade e numeros positivos, prioridades baixas.

Para visualizar a prioridade dos processos do sistema, utilize o seguinte comando:

# ps al

O Resultado é parecido com este:
F   UID   PID  PPID PRI  NI   VSZ  RSS WCHAN  STAT TTY        TIME COMMAND
4     0  3988     1  17   0  3016  400 ?      Ss+  tty1       0:00 /sbin/mingetty tty1
4     0  3989     1  16   0  2708  400 ?      Ss+  tty2       0:00 /sbin/mingetty tty2
4     0  3990     1  17   0  2156  400 ?      Ss+  tty3       0:00 /sbin/mingetty tty3
4     0  3991     1  17   0  2204  400 ?      Ss+  tty4       0:00 /sbin/mingetty tty4
4     0  3992     1  17   0  2044  400 ?      Ss+  tty5       0:00 /sbin/mingetty tty5
4     0  3993     1  16   0  2884  400 ?      Ss+  tty6       0:00 /sbin/mingetty tty6
0   525 16849 21405  17   0  3724  636 -      R+   pts/0      0:00 ps al
0   525 21405 21404  15   0  6168 1472 wait   Ss   pts/0      0:00 -bash

Ou se preferir, você pode filtrar com o comando que aprendemos na aula de ps:
# ps ao pid,ni,command (assim só aparece o pid, a coluna NICE e o comando que gerou).


Observe a coluna: NI. Ela tem os valores que falamos.
Note que todo processo iniciado pelo usuário tem prioridade 0.
Vamos ver agora a listagem completo com os processos do sitema.

# ps -axl | more

F   UID   PID  PPID PRI  NI   VSZ  RSS WCHAN  STAT TTY        TIME COMMAND
4     0     1     0  16   0  2512  548 ?      S    ?          0:00 init [3]
1     0     2     1 -100  -     0    0 migrat S    ?          0:03 [migration/0]
1     0     3     1  34  19     0    0 ksofti SN   ?          0:00 [ksoftirqd/0]
1     0     4     1 -100  -     0    0 migrat S    ?          0:02 [migration/1]
1     0     5     1  34  19     0    0 ksofti SN   ?          0:00 [ksoftirqd/1]
1     0     6     1 -100  -     0    0 migrat S    ?          0:02 [migration/2]
1     0     7     1  34  19     0    0 ksofti SN   ?          0:00 [ksoftirqd/2]
1     0     8     1 -100  -     0    0 migrat S    ?          0:02 [migration/3]
1     0     9     1  34  19     0    0 ksofti SN   ?          0:00 [ksoftirqd/3]
1     0    10     1   5 -10     0    0 worker S<   ?          0:00 [events/0]
1     0    11     1   5 -10     0    0 worker S<   ?          0:00 [events/1]
1     0    12     1   5 -10     0    0 worker S<   ?          0:00 [events/2]
1     0    13     1   5 -10     0    0 worker S<   ?          0:00 [events/3]
1     0    14     1   6 -10     0    0 worker S<   ?          0:00 [khelper]
1     0    15     1   5 -10     0    0 worker S<   ?          0:00 [kthread]
1     0    16    15  15 -10     0    0 worker S<   ?          0:00 [kacpid]
1     0    94    15   5 -10     0    0 worker S<   ?          0:00 [kblockd/0]
1     0    95    15   5 -10     0    0 worker S<   ?          0:00 [kblockd/1]
1     0    96    15   5 -10     0    0 worker S<   ?          0:00 [kblockd/2]
1     0    97    15   5 -10     0    0 worker S<   ?          0:00 [kblockd/3]


Note na coluna NI que existem processos com prioridades baixíssimas (19) e outros com prioridade -10.

Iniciando processos fora da prioridade Padrão

Vamos aprender a usar o comando nice

# nice -n prioridade processo

Exemplo: Vamos usar o nosso programa conta.sh como exemplo. Vamos iniciá-lo com a menor prioridade possível e já em segundo plano:

# nice -n +19 ./conta.sh &

Veja o resultado:
# ps -al
F S   UID   PID  PPID  C PRI  NI ADDR SZ WCHAN  TTY          TIME CMD
0 R   525 26483 21405 99  99  19 -  1234 -      pts/0    00:00:02 conta.sh
0 R   525 26484 21405  0  76   0 -   878 -      pts/0    00:00:00 ps

Agora vamos iniciá-lo com a prioridade -10
# nice -n -10 ./conta.sh &

Veja o resultado:
# ps -al
F S   UID   PID  PPID  C PRI  NI ADDR SZ WCHAN  TTY          TIME CMD
0 R   525 26483 21405 99  99 -10 -  1234 -      pts/0    00:00:02 conta.sh
0 R   525 26484 21405  0  76   0 -   878 -      pts/0    00:00:00 ps

Alterando a prioridade de um processo que já está em execução.

Desta vez vamos utilizar o comando renice.

# renice -n prioridade processo

Vamos usar o exemplo anterior. O conta.sh tem o pid 26483 e o processo tem prioridade -10.
Vamos mudar para -5 (lembre-se que o processo já está em execução)
# renice -5 -p 26483

Veja o resultado:
# ps -al
F S   UID   PID  PPID  C PRI  NI ADDR SZ WCHAN  TTY          TIME CMD
0 R   525 26483 21405 99  99  -5 -  1234 -      pts/0    00:00:02 conta.sh
0 R   525 26484 21405  0  76   0 -   878 -      pts/0    00:00:00 ps

Vamos mudar para 0
# renice 0 -p 26483

Veja o resultado:
# ps -al
F S   UID   PID  PPID  C PRI  NI ADDR SZ WCHAN  TTY          TIME CMD
0 R   525 26483 21405 99  99   0 -  1234 -      pts/0    00:00:02 conta.sh
0 R   525 26484 21405  0  76   0 -   878 -      pts/0    00:00:00 ps

NOHUP

O nohup é um comando que faz com que os processos ignorem o sinal hangup (sinal 1 - interrupção).
Vamos executar um processo que não poderá ser finalizado, veja o exemplo:
# nohup ./conta.sh
nohup: appending output to `nohup.out'

Este recurso é utilizado como recurso de iniciar programas e fazer lougout. Com isso o programa fica rodando em background mesmo que o terminal (ou janela do ambiente gráfico)

seja encerrado. O Resultado do comando é direcionado para o arquivo nohup.out

Veja este exemplo:
# nohup vim
# killall -1 vi
# ps -aux | grep vi
root       988  0.6 11.0 22120 13152 ?       S    08:27   0:06 kghostview /mnt/w
root      1001 14.3  3.0  8500 3572 pts/3    RN   08:38   0:50 vi
root      1026  0.0  0.5  1724  668 pts/4    S    08:44   0:00 grep vi

Observe que o processo não foi finalizado, então agora vamos finalizá-lo:

Monitorando processos em Tempo Real

Para
monitorar processos em tempo real poderemos utilizar duas ferramentas: o top e o htop.
O comando top já vem por padrão nas distribuições linux.
Basta digitar:
# top
Este programa atualiza a tela a cada 5s. Se quiser uma monitoração segundo a segundo, digite:
# top -d 1

O Top também aceita comandos quando está em execução:
[Space]    Atualizar a tela imediatamente
[h]    Exibir uma tela de ajuda
[k]    Matar (kill) um processo. Você deverá indicar o ID do processo e o sinal a ser enviado para ele.
[n]    Alterar o número de processos exibidos. Você deverá indicar o número.
[u]    Ordenar por usuário.
[M]    Ordenar por uso da memória.
[P]    Ordenar por uso da CPU.


Dica:
Aplicações como o Apache, Mozilla e o Nautilus são thread-aware — são criados threads múltiplos para lidar com usuários múltiplos ou pedidos múltiplos, e cada thread recebe um

ID de processo. Por default, o ps e o top exibem somente o thread principal (inicial). Para visualizar todos os threads, use o comando ps -m ou pressione [Shift]-[H] no top.
Fonte: http://web.mit.edu/rhel-doc/3/rhel-sag-pt_br-3/ch-sysinfo.html

HTOP

Este programa não vem por padrão nas distribuições, mas é o melhor de todos! Usa cores, gráficos e teclas de atalhos bem mais fáceis do que o engessado TOP.

Digite:
# htop

Caso você não tenha este programa, instale na sua distribuição.
Debian e derivados:
# apt-get install htop

Redhat, Fedora, CentOS...
# yum install htop



Note que as barras já dão uma idéia melhor de poder de processamento, memória RAM e Swap.
Na parte inferior, tem as teclas de atalho (sempre teclas de função) que dão acesso rápido aos recursos:
F1 - Ajuda
F2 - Altera cores, graficos e personaliza o htop
F3 - Procura processos (ps aux | grep ...)
F4 - Inverte a ordem da ordenação escolhida no F6
F5 - Exibe os processos em forma de árvore (pstree)
F6 - Ordena a visualização do programa (Por consumo de cpu, memoria...)
F7 - Diminui a prioridade de um processo (renice -1)
F8 - Aumenta a prioridade de um processo (renice +1)
F9 - Envia sinais para os processos (kill e killall)
F10 - Sai do programa


Fontes:
http://www.guiafoca.org/cgs/guia/inic_interm/ch-run.html#s-run-controle
http://dainf.ct.utfpr.edu.br/~maziero/doku.php/unix:gestao_de_processos
http://web.mit.edu/rhel-doc/3/rhel-sag-pt_br-3/ch-sysinfo.html
http://www.vivaolinux.com.br/artigo/Criando-monitorando-e-terminando-processos?pagina=3