sistemas operacionais - gnu/linux gerenciando processos

Sistemas Operacionais Luiz Arthur1

Tarefas como verificar os processos que estão executando, mudar a prioridadede execução e terminar os processos são exigidas para qualquer administrador Linux.

O Kernel do Linux tem uma capacidade excelente para trabalhar com processos sem intervenção do usuário. Mas às vezes é preciso que o root intervenha e termine um processo que esteja comportando-se de forma egoísta e exaurindo os recursos da máquina.

Este controle de processos é especialmente importante porque o Linux é um sistema multitarefa, multiusuário e multiprocessado.

O conceito de multitarefa significa que o Linux é capaz de executar diversos programas e serviços ao mesmo tempo de forma preemptiva.

Se tivermos apenas um processador central no computador com Linux, o sistema fará o escalonamento (rodízio) dos processos de forma tão eficiente que o usuário terá a impressão de que ele pode executar mais de um programa ao mesmo tempo.

E o Linux ainda possui a capacidade de gerenciar os processos de forma eficaz com o multiprocessamento real quando temos mais de um processador central envolvido.


Quando o computador com o Linux é ligado, o sistema imediatamente procura no setor de boot do disco rígido o gerenciador de boot (LILO ou GRUB). Eles são responsáveis pela carga do Kernel na memória.

Após a carga do Kernel, este inicia um processo especial chamado init. Este processo é o pai de todos os processos e responsável pelo restante da carga de boot do Linux.

Depois da carga do boot, o init chama outro programa especial chamado getty, que é responsável pela autenticação do usuários e por iniciar o processo de shell.

É importante que você entenda que cada programa é pelo menos um processo e que cada processo possui atributos, como:

●Process ID (PID) ou identificação do processo: Cada processo possui um número de identificação única. O primeiro processo init sempre terá o PID 1 e para o restante dos processos este número é incrementado à medida que novos processos são executados.

User ID e Group ID (ID do usuário e ID do grupo): Os processo precisam ser executados com os privilégios de uma conta de usuário e grupo associado a eles. Isto é importante porque assim o sistema pode determinar e gerenciar o acesso ao recursos.


●Processo Pai: No Linux nenhum processo é executado de forma independente dos outros. Todos os processos no sistema, com exceção do init, possuem um processo pai, que é responsável pela sua execução.

●Parent ID (ID do processo pai): Este atributo grava o PID do processo pai. Caso o processo pai termine sua execução antes do processo filho, o processo filho é “apadrinhado” pelo init, ganhando o Parent ID igual a 1.

●Variáveis de ambiente: Cada processo herda do processo pai algumas variáveis de ambiente que simplesmente guardam alguns valores que pode ou não ser importantes para o processo em execução. É possível que durante sua execução um processo altere, incremente ou apague uma variável de ambiente.

●Diretório de trabalho: Os processos também são associados a um diretório de trabalho, onde podem fazer leitura e escrita de disco.

●Temporizadores: O Kernel mantém registros da hora em que os processos são criados bem como o tempo de CPU que eles consomem durante a sua execução.

Sinais

Cada processo no Linux fica à escuta de sinais. Estes sinais são utilizados pelo Kernel, por outros processos ou pelo usuário para avisar a um determinado processo sobre algum evento em particular. Sinais pode ser visto como uma interrupção de software.


Quando um sinal é enviado para um processo, ele toma uma determinada ação dependendo do valor que este sinal carrega.

Cada sinal tem nome exclusivo e um valor numérico. Tal como:

Sinal HUP, valor 1: Hang-Up ou desligamento. Este sinal é utilizado automaticamente quando o usuário desconecta de uma sessão ou fecha um terminal. Ele também é utilizado por processos servidores para invocar a releitura do arquivo de configuração (para atualização das configurações do servidor).

Sinal INIT, valor 2: Interrompe o processo. Ele é enviado automaticamente quando um processo é abortado com as teclas ctrl-c.

Sinal KILL, valor 9: Termina o processo incondicionalmente de forma rápida e drástica. Este tipo de sinal pode deixar arquivos abertos e bases de dados corrompidas. Deve ser utilizado caso o processo pare de responder ou em uma emergência.

Sinal TERM, valor 15: Termina o processo de forma elegante, possibilitando que ele feche arquivos e execute suas rotinas de fim de execução.

Sinal TSTP, valor 18: Termina a execução para continuar depois. Este sinal é enviado automaticamente quando utilizamos as teclas ctrl-z. É utilizado para colocar um processo em segundo plano.


O Linux possui mais de 30 sinais definidos. A maioria utilizada pelo Kernel e alguns pelos usuários. O entendimento de sinais é importante para que possamos interagir com os processos em execução.

Controle de Processos

Como outros sistemas operacionais completos, o Linux possibilita que coloquemos processos em segundo plano de execução (background). Para que um processo execute em segundo plano, é preciso que ele não espere por nenhuma ação do usuário, como por exemplo esperar por um sub-comando. Neste estado o processo se comunicará com o usuário através dos sinais.

Basicamente para colocar qualquer processo em segundo plano de execução, basta adicionar o caractere “&” no final da linha de comando que executará o processo:

$ find / -name *.conf > lista_arquivos_configuracao.txt &

O comando find será executado em segundo plano e sua saída será direcionada para o arquivo lista_arquivos_configuracao.txt

A execução em Primeiro Plano (foreground). É quando você deve esperar o término da execução de um programa para executar um novo comando. Somente é mostrado o aviso de comando após o término de execução do comando/programa.


Prioridade de Execução

O Kernel do Linux possui como uma de suas atividades críticas o escalonador de processos. Este escalonador é um algoritmo especial que coloca em fila todos os processos em execução e decide qual processo irá ser executado e durante quanto tempo.

O escalonador é o que permite que o computador possa executar mais de um processo em concorrência, dividindo a CPU em fatias de tempo de execução. A implementação do escalonador é tão importante que ela é o que realmente faz a diferença nos sistemas operacionais modernos.

O Linux permite que o usuário interfira na prioridade de execução dos processos liberando mais ou menos tempo de CPU. A lista de prioridade pode ser vista com o comando ps -lax na coluna PRI. Quando maior for o número da PRIoridade, mais tempo de CPU o processo tem e mais importante ele é. Quanto menor o número, menos tempo de CPU e menor importância.


Path

Path é o caminho de procura dos arquivos/comandos executáveis.

O path (caminho) é armazenado na variável de ambiente PATH. Você pode ver o conteúdo desta variável com o comando: echo $PATH

Por exemplo, o caminho /usr/local/bin:/usr/bin:/bin:/usr/bin/X11 significa que se você digitar o comando ls, o interpretador de comandos iniciará a procura do programa ls no diretório /usr/local/bin, caso não encontre o arquivo no diretório /usr/local/bin ele inicia a procura em /usr/bin, até que encontre o arquivo procurado.

Caso o interpretador de comandos chegue até o último diretório do path e não encontre o arquivo/comando digitado, é mostrada a seguinte mensagem:

bash: ls: command not found (comando não encontrado).

O caminho de diretórios vem configurado na instalação do Linux, mas pode ser alterado no arquivo /etc/profile. Caso deseje alterar o caminho para todos os usuários, este arquivo é o melhor lugar, pois ele é lido por todos os usuários no momento do login.


Caso um arquivo/comando não esteja localizado em nenhum dos diretórios do path, você deve executa-lo usando um ./ na frente do comando, ou passando o caminho (diretório) inteiro no prompt de comando. Se deseja alterar o path para um único usuário, modifique o arquivo .bash_profile em seu diretório de usuário (home).

Executando programas em seqüência

Os comandos podem ser executados em seqüência (um após o término do outro) se os separarmos com ";". Por exemplo: echo primeiro;echo segundo;echo terceiro

Também é possível executar um comando em seqüência com a condição AND, ou seja, o próximo comando só vai ser executado se o anterior for executado de forma correta. Isto é possível utilizando && entre os comandos. Por exemplo: echo primeiro && eco segundo && echo terceiro.

Desta forma o sistema irá executar o primeiro echo, passara para o segundo, mas este segundo foi digitado errado “eco” e desta forma não será executado e assim o próximo comando echo também não será executado. Isto é muito útil em scripts.


Veremos agora alguns comandos básicos para gerência de processos:

ps

O comando ps gera uma lista com todos os processos em execução e seus atributos.

Algumas vezes é útil ver quais processos estão sendo executados no computador. O comando ps faz isto, e também nos mostra qual usuário executou o programa, hora que o processo foi iniciado, etc. ps [opções]

Onde: -a Mostra os processos criados por você e de outros usuários do sistema. -x Mostra processos que não são controlados pelo terminal.

-u Mostra o nome de usuário que iniciou o processo e hora em que o processo foi iniciado.

-m Mostra a memória ocupada por cada processo em execução.

-f Mostra a árvore de execução de comandos (comandos que são chamados por outros comandos).


-e Mostra variáveis de ambiente no momento da inicialização do processo.

-w Mostra a continuação da linha atual na próxima linha ao invés de cortar o restante que não couber na tela.

--sort:[coluna] Organiza a saída do comando ps de acordo com a coluna escolhida. Você pode usar as colunas pid, utime, ppid, rss, size, user, priority.

Pode ser especificada uma listagem em ordem inversa especificando --sort:[-coluna].

As opções acima podem ser combinadas para resultar em uma listagem mais completa.

Você também pode usar pipes "|" para filtrar a saída do comando ps.

Ao contrário de outros comandos, o comando ps não precisa do hífen "-" para especificar os comandos. Isto porque ele não utiliza opções longas e não usa parâmetros.

Exemplos: ps, ps aux, ps ax|grep inetd, ps auxf, ps auxw.


pstree

O comando pstree irá mostrar a árvore de processos desde o init até o último processo em execução. É similar ao ps -auxf. Ele é útil para o entendimento da hierarquia dos processos no Linux.

pstree [opções] [pid]

Onde:

pid Número do processo que terá sua árvore listada. Se omitido, lista todos os processos.

Opções:

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


top

Mostra os programas em execução ativos, parados, tempo usado na CPU, detalhes sobre o uso da memória RAM, Swap, disponibilidade para execução de programas no sistema, etc. top é um programa que continua em execução mostrando continuamente os processos que estão rodando em seu computador e os recursos utilizados por eles. Para sair do top, pressione a tecla q.

O comando top mostra os processos em execução como o ps, mas atualizando a tela. Este recurso é útil para monitorar como um ou mais processos agem no sistema. Este comando também ordena os processos que utilizam mais CPU no topo da tela. top [opções]

Onde: -d [tempo] Atualiza a tela após o [tempo] (em segundos). -s Diz ao top para ser executado em modo seguro. -i Inicia o top ignorando o tempo de processos zumbis. -c Mostra a linha de comando ao invés do nome do programa.


A ajuda sobre o top pode ser obtida dentro do programa pressionando a tecla hou pela página de manual ($man top).

Abaixo algumas teclas úteis:

espaço - Atualiza imediatamente a tela.

CTRL+L - Apaga e atualiza a tela.

h - Mostra a tela de ajuda do programa. É mostrado todas as teclas que podem ser usadas com o top.

i - Ignora o tempo ocioso de processos zumbis.

q - Sai do programa.

k - Finaliza um processo - semelhante ao comando kill. Você será perguntado pelo número de identificação do processo (PID). Este comando não estará disponível caso esteja usando o top com a opção -s.

n - Muda o número de linhas mostradas na tela. Se 0 for especificado, será usada toda a tela para listagem de processos.


kill

Permite enviar um sinal a um comando/programa. Caso seja usado sem parâmetros, o kill enviará um sinal de término (TERM-15) ao processo sendo executado, de forma que o processo seja executado de forma elegante. O kill é usado geralmente para terminar a execução de processos identificados pelo PID. kill [opções] [sinal] [número]

Onde: número É o número de identificação do processo obtido com o comando ps. Também pode ser o número após o sinal de % obtido pelo comando jobs para matar uma tarefa interrompida.

Sinal Sinal que será enviado ao processo. Se omitido usa -15 como padrão. opções-9 Envia um sinal de destruição ao processo ou programa. Ele é terminado imediatamente sem chances de salvar os dados ou apagar os arquivos temporários criados por ele. Você precisa ser o dono do processo ou o usuário root para termina-lo ou destruí-lo. Você pode verificar se o processo foi finalizado através do comando ps.


Por exemplo:

Procurando um programa chamado sshd (usado para acesso a maquinas remotas):

#ps ax | grep sshd

4916 pts/2 S+ 0:00 grep sshd

Caso queiramos que tal programa re-leia o arquivo de configuração podemos executar o comando kill com o sinal HUP.

#kill -HUP 4916

Porém se for necessário terminar o programa de forma brusca, por exemplo caso ele esteja consumindo muitos recursos do seu computador, podemos enviar um sinal -9, tal como:

#kill -9 4916


killall

O comando killall envia sinais para os processos e recebe como parâmetro não o PID do processo, mas seu nome. Ele é usado geralmente para terminar a execução de processos que possuem diversos filhos executando concorrentemente.

killall [opções] [sinal] [processo]

Onde:

processo Nome do processo que deseja finalizar sinal Sinal que será enviado ao processo (pode ser obtido usando a opção -i). Indicado com a opção (-s).

Opções:-i Pede confirmação sobre a finalização do processo. -l Lista o nome de todos os sinais conhecidos. -q Ignora a existência do processo. -v Retorna se o sinal foi enviado com sucesso ao processo. -w Finaliza a execução do killall somente após finalizar todos os processos.

Por exemplo:#killall -s 9 sshd


É importante entender a diferença entre o kill e killall. O primeiro envia sinais para um ou mais processos identificados pelo PID. O segundo envia sinais para todos os processos na fila de execução que possuem um determinado nome.

Os sinais enviados pelo kill e pelo killall podem ser passados pelo nome ou pelo número inteiro correspondente.

É possível, dentro de uma hierarquia de processos, que um determinado processo filho termine por algum motivo inesperado, e o processo pai se torne um processo zoombie ou defunto (defunct). Os processos zoombie não podem ser terminados com o comando kill, porque eles já não existem mais.

Isso acontece porque cada processo criado recebe um lugar na tabela de processos do Kernel. Quando ele termina, seu lugar na tabela do Kernel recebe o resultado da sua execução. O resultado da execução é retido a tabela até alguém consultá-lo quando, então, é removido da tabela.

O estado do processo é chamado de Zumbi quando o mesmo termina e seu resultado ainda não foi retirado da tabela do Kernel.

Outra possibilidade especial é quando um processo qualquer que criou novos processos filhos que executam debaixo de sua hierarquia termine inesperadamente. Neste caso, os processos filhos perdem o seu processo pai e são adotados pelo processo init (PID 1) que é o pai de todos os processos.

Estas duas situações descritas não são normais e podem ser ocasionadas por bugs nos programas.


Interrompendo a execução de um processo

Para cancelar a execução de algum processo rodando em primeiro plano, basta pressionar as teclas CTRL+C. A execução do programa será cancelada e será mostrado o aviso de comando. Você também pode usar o comando kill.

Parando momentaneamente a execução de um processo

Para parar a execução de um processo rodando em primeiro plano, basta pressionar as teclas CTRL+Z. O programa em execução será pausado e será mostrado o número de seu job e o aviso de comando.

Para retornar a execução de um comando pausado, use fg ou bg (abordados a seguir).

O programa permanece na memória no ponto de processamento em que parou quando ele é interrompido. Você pode usar outros comandos ou rodar outros programas enquanto o programa atual está interrompido.


jobs

O comando jobs mostra os processos que estão parados ou rodando em segundo plano.

Processos em segundo plano são iniciados usando o símbolo "&" no final da linha de comando ou através do comando bg. jobs

O número de identificação de cada processo parado ou em segundo plano (job), é usado com os comandos fg, e bg. Um processo interrompido pode ser finalizado usando-se o comando kill %[num], onde [num] é o número do processo obtido pelo comando jobs.

Então, o comando jobs lista os processos que estão em execução em segundo plano. Se um número da tarefa é fornecida, o comando retornará as informações pertinentes somente à tarefa em questão. O número da tarefa é fornecido quando o processo é colocado em segundo plano. A opção -l pode exibir os PIDS do programa.

Por exemplo:#jobs -l[2]- 5019 Stopped slocate -u[3]+ 5020 Stopped find / -iname linux


fgPermite fazer um programa rodando em segundo plano ou parado, rodar em primeiro plano. Você deve usar o comando jobs para pegar o número do processo rodando em segundo plano ou interrompida, este número será passado ao comando fg para ativa-lo em primeiro plano.

fg [número]

Onde número é o número obtido através do comando jobs.

Caso seja usado sem parâmetros, o fg utilizará o último programa interrompido (o maior número obtido com o comando jobs).

Exemplo: #fg 1

bgPermite fazer um programa rodando em primeiro plano ou parado, rodar em segundo plano. Para fazer um programa em primeiro plano rodar em segundo, é necessário primeiro interromper a execução do comando com CTRL+ Z, será mostrado o número da tarefa interrompida, use este número com o comando bgpara iniciar a execução do comando em segundo plano.

bg [número]

Onde: número número do programa obtido com o pressionamento das teclas CTRL+Z ou através do comando jobs.


nice

O comando nice ajusta o tempo disponível de CPU de um processo para mais ou para menos prioridade

nice [opções] [comando/programa]

Onde: comando/programa Comando/programa que terá sua prioridade ajustada.

Opções:

-n [numero] Configura a prioridade que o programa será executado. Se um programa for executado com maior prioridade, ele usará mais recursos do sistema para seu processamento, caso tenha uma prioridade baixa, ele permitirá que outros programas tenham preferência. A prioridade de execução de um programa/comando pode ser ajustada de -19 (a mais alta) até 19 (a mais baixa).

Exemplo: nice -n -19 find / -name apropos

No inglês “nice” quer dizer “legal”. Se o ajuste de prioridade para um processo for um número positivo, quer dizer que ele está sendo mais legal com os outros programas diminuindo a sua prioridade. Se o ajuste for um número negativo, quer dizer que o programa está sendo menos legal, aumentando a sua prioridade de execução e sobrando menos tempo de CPU para os outros programas


Se não for passado nenhum valor de ajuste, o comando nice ajustará a prioridade para +10, diminuindo o tempo de execução do processo.

$nice slocate -u &

recine

O comando renice ajusta a prioridade de execução de processos que já estão rodando.

Por padrão, o comando renice recebe como parâmetro o PID de um determinado processo.

O ajuste de prioridade é um número inteiro que vai do -20 (maior prioridade) até o +20 (executar qualquer coisa antes deste processo).

As opções mais usuais são:

-p Recebe o PID par alterar a sua prioridade.-u Recebe um nome de usuário par alterar a prioridade de todos os processos deste usuário em execução.-g Recebe um nome de um grupo para alterar a prioridade de todos os processos pertencentes a este grupo.


Exemplo:

#renice -1 987 -u daemon root -p 32

Neste exemplo, o processo de número PID 987, PID 32 e todos os processos de que os usuários daemon e root são donos vão ter mais prioridade.

Os usuários comuns podem alterar a prioridade dos processos de que eles são donos. Somente o usuário root pode alterar a prioridade de qualquer processo.


fim

sistemas operacionais - gnu/linux gerenciando processos

Documents