Fundamentos de Gerenciamento de Processos no Linux

Objetivo

Aprenda os fundamentos do gerenciamento de processos no Linux

Sistema operacional e versões de software

• Sistema operacional: - Todas as distribuições Linux

Requisitos

• Alguns programas mencionados neste tutorial exigem acesso à raiz

Dificuldade

FÁCIL

Convenções

• # - requer que os comandos Linux sejam executados com privilégios de raiz também
  diretamente como usuário root ou por uso de sudo comando
• $ - Requer que os comandos do Linux sejam executados como um usuário não privilegiado regular

Introdução

Uma das principais atividades de um administrador do sistema é o de monitorar e interagir com os processos em execução em uma máquina. Neste tutorial, você será apresentado ao uso de algumas ferramentas fundamentais que o ajudarão a realizar essa tarefa vital.

O comando ps

PS é um dos programas fundamentais usados ​​no monitoramento de processos: basicamente fornece um instantâneo dos processos em execução em uma máquina no momento em que você invoca o comando. Vamos ver em ação: primeiro tentaremos executá -lo sem nenhuma opção:

$ ps pid tty time cmd 24424 pts/0 00:00:00 bash 24468 pts/0 00:00:00 ps 

Como você pode ver na saída acima, apenas dois processos são mostrados: Bash com um PID (ID do processo) 24424 e ps por si mesmo com o PID 24468. Isso ocorre porque, quando invocado sem nenhuma opção, o ps O comando mostra processos associados ao Uid do usuário que lançou o comando e o terminal do qual é invocado.

Como superar esta limitação? Usando o -a opção que podemos fazer ps para nos mostrar todos os processos, com exceção do líderes de sessão e os processos não associados a um terminal.

Um líder de sessão é um processo que tem um PID que é o mesmo do Sid (ID da sessão) da sessão da qual é (o primeiro) membro. Quando um processo é criado, é feito parte da mesma sessão de seu processo pai: uma vez que, por convenção, o ID da sessão é o mesmo do PID de seu primeiro membro, chamamos esse processo de líder da sessão. Vamos tentar correr ps com o -a opção e verifique sua saída:

$ PS -A PID TTY TEMPO CMD 12466 TTY1 00:00:00 Gnome-Session-B 12480 TTY1 00:00:17 Gnome-Shell 12879 TTY1 00:00:00 XWayland 12954 Tty1 00:00:00 GSD 12955 TTY1 00:00:00 GSD-WACOM 12957 TTY1 00:00:00 GSD-XSETTINGS 12961 TTY1 00:00:00 GSD-A11Y-KEYBOA 12962 TTY1 00:00:00 GSD-A11Y-Settin 12965 tty1 00:00:00:00 -ClipBoard 12966 TTY1 00:00:03 GSD-CORA 12967 TTY1 00:00:00 GSD-DATETIME 12970 TTY1 00:00:00 GSD-HOUSHEEPIN 12971 TTY1 00:00:00 GSD-STECHOLA 12972 TTTY 12971 -Media-Keys 12973 TTY1 00:00:00 GSD-MOUSE 12976 TTY1 00:00:00 GSD Orientação […] 

A saída do programa foi truncada, mas você pode ver facilmente que agora inclui processos que pertencem a diferentes terminais e usuários. A saída nos mostra informações sobre PID Na primeira coluna, Tty no segundo, TEMPO qual é o tempo cumulativo que a CPU passou no processo e Cmd qual é o comando que iniciou o processo.

Para ter uma saída ainda mais rica, podemos adicionar o -você e -x Opções: o primeiro diz ps Para fazer uma seleção por ID do usuário, Enquanto este último instrui o programa a incluir também processos não associados a um terminal, como Daemons:

$ ps -aux usuário pid %cpu %mem vsz rss tty stat start time comando root 1 0.0 0.2 223932 8708 ? SS Jul20 0:04/usr/lib/Systemd/Systemd-Switched-Root-System-DeSerialize 25 Raiz 2 0.0 0.0 0 0 ? S Jul20 0:00 [Kthreadd] Raiz 4 0.0 0.0 0 0 ? S< Jul20 0:00 [kworker/0:0H] root 6 0.0 0.0 0 0 ? S< Jul20 0:00 [mm_percpu_wq] root 7 0.0 0.0 0 0 ? S Jul20 0:00 [ksoftirqd/0] root 8 0.0 0.0 0 0 ? S Jul20 0:07 [rcu_sched] root 9 0.0 0.0 0 0 ? S Jul20 0:00 [rcu_bh] root 10 0.0 0.0 0 0 ? S Jul20 0:04 [rcuos/0] root 11 0.0 0.0 0 0 ? S Jul20 0:00 [rcuob/0] root 12 0.0 0.0 0 0 ? S Jul20 0:00 [migration/0] root 13 0.0 0.0 0 0 ? S Jul20 0:00 [watchdog/0] root 14 0.0 0.0 0 0 ? S Jul20 0:00 [cpuhp/0] root 15 0.0 0.0 0 0 ? S Jul20 0:00 [cpuhp/1] root 16 0.0 0.0 0 0 ? S Jul20 0:00 [watchdog/1] root 17 0.0 0.0 0 0 ? S Jul20 0:00 [migration/1] root 18 0.0 0.0 0 0 ? S Jul20 0:00 [ksoftirqd/1] root 20 0.0 0.0 0 0 ? S< Jul20 0:00 [kworker/1:0H] root 21 0.0 0.0 0 0 ? S Jul20 0:02 [rcuos/1] root 22 0.0 0.0 0 0 ? S Jul20 0:00 [rcuob/1] root 23 0.0 0.0 0 0 ? S Jul20 0:00 [cpuhp/2] root 24 0.0 0.0 0 0 ? S Jul20 0:00 [watchdog/2] root 25 0.0 0.0 0 0 ? S Jul20 0:00 [migration/2] root 26 0.0 0.0 0 0 ? S Jul20 0:00 [ksoftirqd/2] root 28 0.0 0.0 0 0 ? S< Jul20 0:00 [kworker/2:0H] [… ] egdoc 13128 0.0 0.1 74736 5388 ? Ss Jul20 0:00 /usr/lib/systemd/systemd --user egdoc 13133 0.0 0.0 106184 420 ? S Jul20 0:00 (sd-pam) egdoc 13143 0.0 0.1 218328 3612 ? Sl Jul20 0:00 /usr/bin/gnome-keyring-daemon --daemonize --login [… ] 

Você pode ver que muitas informações novas foram adicionadas. A primeira nova coluna da saída é %CPU: Isso mostra a utilização da CPU do processo, expressa como uma porcentagem. Uma porcentagem também é usada para a próxima coluna, %Mem, que mostra a memória física na máquina usada pelo processo. Vsz é o tamanho da memória virtual do processo expresso em Kib.

O ESTADO A coluna usa um código para expressar o estado do processo. Não vamos descrever todos os estados possíveis aqui, mas apenas explique os que aparecem na saída acima (você pode ter uma visão geral completa consultando a manpágina do PS).

Vamos examinar o primeiro processo na saída: é PID 1, Portanto, é o primeiro processo lançado pelo kernel. Isso faz sentido, podemos ver que é Systemd, O sistema Init Linux relativamente novo, agora adotado por quase todas as distribuições. Primeiro de tudo, temos um S o que indica que o processo está no estado de sono interrompível o que significa que está ocioso e acordará assim que receber uma entrada. O s, Em vez disso, nos diz que o processo é um líder da sessão.

Outro símbolo, não aparecendo no primeiro cru, mas em alguns dos outros processos descrições é < o que indica que o processo tem alta prioridade e, portanto, um baixo legal valor (veremos o que é um bom valor na seção relevante deste tutorial). Um eu no ESTADO coluna, indica que o processo é multi-thread e um + sinal, que está no grupo de processo em primeiro plano.

Finalmente, na última coluna, temos o COMEÇAR coluna, mostrando a hora em que o comando começou.

Outra boa opção que podemos passar para o ps comando, é -o, qual é a versão curta de --formatar. Esta opção permite modificar a saída pelo uso de espaços reservados, especificando quais colunas mostrar. Por exemplo, executando:

$ ps -ax -o%u%p%n%c

Vai nos dar o DO UTILIZADOR coluna primeiro (%u), seguido pelo PID do processo (%p), pelo Ni coluna (%n), que indica o legal nível, e finalmente pelo COMANDO coluna (%c):

Usuário PID NI REATE DE COMANDO 1 0 Systemd Raiz 2 0 Raiz KTHRADD 4 -20 KWORKER/0: 0H ROOT 6 -20 MM_PERCPU_WQ ROOT 7 0 KSOFTIRQD/0 RAOT 8 0 RCU_SCHED ROOT 9 0 RCU_BH RAOT 10 0 RCUOS/0 RAOTE 11 0 RCUOB /0 raiz 12 - migração/0 raiz 13 - cão de guarda/0 raiz 14 0 cpuhp/0 raiz 15 0 cpuhp/1 raiz 16 - cão de guarda/1 raiz 17 - migração/1 raiz 18 0 ksoftirqd/1 raiz 20 -20 kworker/ 1: 0h Raiz 21 0 rcuos/1 raiz 22 0 rcuob/1 raiz 23 0 cpuhp/2 raiz 24 - cão de guarda/2 raiz 25 - migração/2 raiz 26 0 ksoftirqd/2 

Usando 'top' para interagir dinamicamente com os processos

Enquanto ps nos dá um instantâneo estático de processos e suas informações no momento em que você as executa, principal Nos fornece uma visão dinâmica dos processos, atualizados em um intervalo de tempo especificado que podemos especificar ambos ao iniciar o programa e interativamente (o padrão é de 3 segundos).

Top não apenas nos mostra uma representação dinâmica dos processos de execução: podemos interagir com eles e com o próprio programa, pelo uso de algumas chaves. Por exemplo, pressionando B Permite alternar o uso de caracteres ousados, d Permite inserir um valor para alterar o tempo de atraso, k Permite enviar um sinal para um processo solicitando seu PID e para o sinal código, com Sigterm sendo o padrão.

Mude a prioridade dos processos com Nice e Renice

Como já vimos antes, cada processo tem um prioridade atribuído a ele, o que indica quanto o processo precisa esperar que outros processos sejam gratuitos antes de poder acessá -los. Essa prioridade pode ser especificada com um valor que está em um intervalo de -20 para 19. Quanto menor o valor, a maior a prioridade do processo. Isso pode parecer contra-intuitivo no começo, mas veja da seguinte maneira: quanto melhor o processo é para outros processos, mais eles o superarão no acesso aos recursos.

Mas como podemos definir a prioridade de um processo? Podemos usar o legal programa para realizar a tarefa. Digamos que você deseja executar um script com o menor valor de prioridade possível: você prefácio da seguinte maneira:

$ nice -n 19 ./roteiro.sh

Você também pode alterar a prioridade de um programa que já está sendo executado pelo uso de Renice Saber é PID:

# Renice -N 15 pid

Onde PID é o ID do processo do programa. Lembre -se de que o Renice O comando deve ser executado com permissões raiz.

Envie sinais para processos com os comandos de Kill and Killall

Podemos usar o comando Kill para enviar um sinal a um processo que pertence a nós ou a todos os processos se tivermos permissões de raiz. Os vários sinais que podemos enviar são identificados por um número: podemos ver facilmente essas correspondências executando o comando de matar com o -eu opção:

$ kill -l 1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP 6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR2 13) Sigpipe 14) Sigalrm 15) ) SIGSTKFLT 17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP 21) SIGTTIN 22) SIGTOU 23) SIGURG 24) SIGXCPU 25) Sigxfsz 26) Sigvtalrm 27) SigProf 28) Sigwinch 29) 35) sigrtmin+1 36) sigrtmin+2 37) sigrtmin+3 38) sigrtmin+4 39) sigrtmin+5 40) sigrtmin+6 41) sigrtmin+7 42) sigrtmin+8 43) sigrtmin+9 44) 45) sigrtmin+11 46) sigrtmin+12 47) sigrtmin+13 48) sigrtmin+14 49) sigrtmin+15 50) sigrtmax-14 51) sigrmax-13 52) sigrtmax-12) sigrtmax-11 54) 55) SIGRTMAX-9 56) SIGRTMAX-8 57) SIGRTMAX-7 58) SIGRTMAX-6 59) SIGRTMAX-5 60) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-2 63) 

Se nenhuma opção for passada para o matar comando, por padrão, ele enviará um Sigterm sinalize para o processo especificado, ao qual o último poderia reagir de várias maneiras: pode parar imediatamente, tentar fazer alguma limpeza antes de parar ou simplesmente ignorar o sinal.

Para especificar o sinal a ser enviado usando a matança, executamos o comando seguido de um traço e o número do sinal a ser enviado. Por exemplo para executar um Sigkill sinalizamos que devemos executar:

Mate -9 pid

O Sigkill sinal, ao contrário Sigterm não pode ser capturado pelo processo, que não pode reagir: apenas será encerrado imediatamente.

Outro sinal que você costuma ver é Sigint que é o sinal enviado na interrupção do teclado (CTRL-C). Ele também tenta encerrar o processo de uma maneira graciosa e pode ser ignorada pelo processo. Sigstop e Sigcont irá suspender e retomar respectivamente a execução de um processo: o primeiro, como Sigkill não pode ser pego ou ignorado. Para uma lista completa e descrição dos sinais, você pode consultar o manual para sinal (7) correndo:

Man 7 Signal

O Mate todos o programa tem o mesmo objetivo de matar, e como matar, envia um Sigterm sinal quando nenhum outro é especificado (desta vez com o --sinal opção), mas em vez de referenciar um processo por seu PID, Ele fará isso pelo nome do comando, matando efetivamente todos os processos executados sob o mesmo.

Tutoriais do Linux relacionados:

• Coisas para instalar no Ubuntu 20.04
• Coisas para fazer depois de instalar o Ubuntu 20.04 fossa focal linux
• Melhor ferramenta de monitoramento do sistema para Linux
• Ubuntu 20.04 Monitoramento do sistema com widgets conky
• Uma introdução à automação, ferramentas e técnicas do Linux
• Arquivos de configuração do Linux: os 30 primeiros mais importantes
• Otimização de desempenho do Linux: ferramentas e técnicas
• Ubuntu 22.04 Monitoramento do sistema com widgets conky
• Linux pode obter vírus? Explorando a vulnerabilidade do Linux…
• Download do Linux