Capítulo 11 Gerenciando Pacotes e Processos Conteúdo

Prévia do material em texto

Capítulo 11 - Gerenciando Pacotes e Processos
11.1 Introdução
Um sistema Linux típico possui milhares de arquivos. O Padrão de hierarquia do sistema de arquivos (discutido em detalhes em um capítulo posterior) fornece uma diretriz para distribuições sobre como organizar esses arquivos. Neste capítulo, você verá como os sistemas de gerenciamento de pacotes de software podem fornecer informações sobre a localização dos arquivos pertencentes a um pacote.
O kernel do Linux é o núcleo do sistema operacional GNU/Linux. Este capítulo irá discutir o papel do kernel do Linux e como ele fornece informações sobre o sistema nos sistemas de arquivos /proc e /sys pseudo sistema de arquivos.
Você verá como cada comando que você executa faz com que um processo seja executado e como você pode visualizar os processos em execução com o comando ps. Você também verá a discussão de como o sistema registra ou registra mensagens dos processos em segundo plano chamados daemons.
Finalmente, você verá como visualizar o buffer do anel do kernel para ver as mensagens que ele contém com o comando dmesg.
11.2 Gerenciamento de Pacotes
O gerenciamento de pacotes é um sistema pelo qual o software pode ser instalado, atualizado, consultado ou removido de um sistema de arquivos. No Linux, existem muitos sistemas diferentes de gerenciamento de pacotes de software, mas os dois mais populares são aqueles do Debian e do Red Hat.
11.2.1 Gerenciamento de pacotes Debian
A distribuição Debian e seus derivados, como Ubuntu e Mint, usam o sistema de gerenciamento de pacotes Debian. No coração do gerenciamento de pacotes de distribuição derivados da Debian estão os pacotes de software que são distribuídos como arquivos que terminam em ".deb".
A ferramenta de nível mais baixo para gerenciar esses arquivos é o comando dpkg. Este comando pode ser complicado para usuários iniciantes do Linux, de modo que o Advanced Package Tool, apt-get, um programa de front-end para a ferramenta dpkg torna o gerenciamento de pacotes ainda mais fácil. Existem outras ferramentas de linha de comando que servem como front-ends para dpkg, como aptitude, bem como front-ends GUI como synaptic e software-center (mostrado abaixo).
11.2.1.1 Debian - Adicionando Pacotes
Os repositórios Debian contêm mais de 65.000 pacotes diferentes de software. Para obter uma lista atualizada desses repositórios da Internet, você pode executar o comando sudo apt-get update.
Para procurar palavras-chave dentro desses pacotes, você pode usar o comando de palavras-chave de pesquisa sudo apt-cache.
Depois de encontrar o pacote que deseja instalar, você pode instalá-lo com o comando sudo apt-get install package.
Importante: para executar esses comandos, seu sistema precisará acessar a Internet. O comando apt-cache procura os repositórios na Internet para esses programas de software.
11.2.1.2 Debian - Pacotes de atualização
Se você deseja atualizar um pacote individual, execute o comando para instalar esse pacote: sudo apt-get install package
Se uma versão mais antiga do pacote já estiver instalada, ela será atualizada. Caso contrário, uma nova instalação ocorreria.
Se você quiser atualizar todos os pacotes possíveis, então você executaria o comando sudo apt-get upgrade.
Os usuários que fizerem login com uma interface gráfica podem ter uma mensagem na caixa de notificação do update-manager, indicando que as atualizações estão disponíveis, conforme mostrado abaixo:
11.2.1.3 Debian - Removendo pacotes
Tenha em atenção que remover um pacote de software pode resultar na remoção de outros pacotes. Devido às dependências entre pacotes, se você remover um pacote, todos os pacotes que precisam ou dependerão desse pacote também serão removidos.
Se você quiser remover todos os arquivos de um pacote de software, exceto os arquivos de configuração, você pode executar o comando sudo apt-get remove package.
Se você quiser remover todos os arquivos de um pacote de software, incluindo os arquivos de configuração, você pode executar o comando sudo apt-get --purge remove package.
Você pode querer manter os arquivos de configuração no caso em que você planeja reinstalar o pacote de software mais tarde.
11.2.1.4 Debian - Consultando Pacotes
Existem vários tipos diferentes de consultas que os administradores precisam usar. Para obter uma lista de todos os pacotes que estão atualmente instalados no sistema, execute o comando dpkg -l.
Para listar os arquivos que compõem um pacote específico, você pode executar o comando dpkg –L package
Para consultar um pacote para obter informações, ou seu estado, use o comando dpkg –s package.
Para determinar se um arquivo específico foi colocado no sistema de arquivos como resultado da instalação de um pacote, use o comando dpkg -S /path/to/file. Se o arquivo fazia parte de um pacote, o nome do pacote poderia ser fornecido. Por exemplo:
sysadmin@localhost:~$ dpkg -S /usr/bin/who
coreutils: /usr/bin/who
O exemplo anterior mostra o arquivo /usr/bin/who faz parte do pacote coreutils.
11.2.2 RPM Package Management
O Linux Standards Base, que é um projeto da Fundação Linux, é projetado para especificar (através de um consenso) um conjunto de padrões que aumentam a compatibilidade entre sistemas Linux compatíveis. De acordo com a Base de Padrões do Linux, o sistema de gerenciamento de pacotes padrão é RPM.
O RPM faz uso de um arquivo .rpm para cada pacote de software. Este sistema é o que as distribuições derivadas do Red Hat (como Red Hat, CentOS e Fedora) usam para gerenciar o software. Além disso, várias outras distribuições que não são derivadas do Red Hat (como SUSE, OpenSUSE e Mandriva) também usam RPM.
Nota: os comandos RPM não estão disponíveis no ambiente da máquina virtual deste curso.
Como o sistema Debian, os sistemas RPM Package Management rastreiam dependências entre pacotes. As dependências de rastreamento garantem que quando você instala um pacote, o sistema também instalará todos os pacotes necessários para que esse pacote funcione corretamente. As dependências também garantem que as atualizações e remoções de software sejam executadas corretamente.
A ferramenta back-end mais comumente usada para RPM Package Management é o comando rpm. Enquanto o comando rpm pode instalar, atualizar, consultar e remover pacotes, as ferramentas de linha de comando como yum e up2date automatizam o processo de resolução de problemas de dependência.
Além disso, existem ferramentas front-end baseadas em GUI, como o yumex e o gpk-application (mostrado abaixo) que também facilitam o gerenciamento de pacotes RPM.
Você deve notar que os muitos dos seguintes comandos exigirão privilégios de root. A regra de ouro é que se um comando afeta o estado de um pacote, você precisará ter acesso administrativo. Em outras palavras, um usuário regular pode realizar uma consulta ou uma pesquisa, mas para adicionar, atualizar ou remover um pacote exige que o comando seja executado como usuário root.
11.2.2.1 RPM - Adicionando Pacotes
Para procurar por um pacote dos repositórios configurados, execute o comando yum search keyword .
Para instalar um pacote, juntamente com suas dependências, execute o comando yum install package .
Os comandos RPM não estão disponíveis no ambiente da máquina virtual deste curso.
11.2.2.2 RPM - Atualizando Pacotes
Se você quiser atualizar um pacote de software individual, você pode executar o comando yum update package .
Se quiser atualizar todos os pacotes, você pode executar o comando yum update.
Se as atualizações estiverem disponíveis e o usuário estiver usando a GUI, o gpk-update-viewer poderá mostrar uma mensagem na área de notificação da tela indicando que as atualizações estão disponíveis.
Os comandos RPM não estão disponíveis no ambiente da máquina virtual deste curso.
11.2.2.3 RPM - Removendo Pacotes
Como é o caso de qualquer sistema de gerenciamento de pacotes que rastreie dependências, se você deseja remover um pacote, então poderá acabar removendo mais de um, devido às dependências. A maneira mais fácil deresolver automaticamente os problemas de dependência é usar um comando yum:
yum remove package
Enquanto você pode remover pacotes de software com o comando rpm, ele não removerá pacotes de dependência automaticamente.
Os comandos RPM não estão disponíveis no ambiente da máquina virtual deste curso.
11.2.2.4 RPM - Consultando Pacotes
O gerenciamento de pacotes do Red Hat é semelhante ao gerenciamento de pacotes do Debian quando se trata de realizar consultas. É melhor usar a ferramenta back-end, rpm, em vez da ferramenta front-end, yum. Enquanto as ferramentas front-end podem executar algumas dessas consultas, o desempenho sofre porque esses comandos geralmente se conectam a vários repositórios em toda a rede ao executar qualquer comando. O comando rpm executa suas consultas conectando-se a um banco de dados que é local para a máquina e não se conecta através da rede a qualquer repositório.
Os comandos RPM não estão disponíveis no ambiente da máquina virtual deste curso.
Para obter uma lista de todos os pacotes que estão atualmente instalados no sistema, execute o comando rpm -qa.
Para listar os arquivos que compõem um pacote específico, execute o comando rpm -ql package.
Para consultar um pacote para obter informações, ou seu estado, execute o comando rpm –qi package.
Para determinar se um arquivo específico foi colocado no sistema de arquivos como resultado da instalação de um pacote, execute o comando rpm -qf /path/to/file.
11.3 Kernel Linux
Quando a maioria das pessoas se refere ao Linux, eles realmente se referem ao GNU/Linux, que define o sistema operacional. A parte Gnu's Not Unix (GNU) desta combinação é fornecida por um projeto Free Software Foundation. O GNU é o que fornece os equivalentes de fonte aberta de muitos comandos UNIX comuns, a maior parte dos comandos essenciais da linha de comando. A parte do Linux desta combinação é o kernel do Linux, que é o núcleo do sistema operacional. O kernel é carregado no momento da inicialização e permanece carregado para gerenciar todos os aspectos do sistema em execução.
A implementação do kernel do Linux inclui muitos subsistemas que fazem parte do kernel em si e outros que podem ser carregados de maneira modular quando necessário. Algumas das principais funções do kernel do Linux incluem uma interface de chamada do sistema, gerenciamento de processos, gerenciamento de memória, sistema de arquivos virtual, rede e drivers de dispositivo.
Em poucas palavras, o kernel aceita comandos do usuário e gerencia os processos que realizam esses comandos, dando-lhes acesso a dispositivos como memória, discos, interfaces de rede, teclados, mouses, monitores e muito mais.
O kernel fornece acesso a informações sobre a execução de processos através de um sistema de arquivos pseudo visível no diretório /proc. Os dispositivos de hardware são disponibilizados através de arquivos especiais no diretório /dev, enquanto as informações sobre esses dispositivos podem ser encontradas em outro sistema de arquivos pseudo sob o diretório /sys.
O diretório /proc não contém apenas informações sobre a execução de processos, como o nome sugeriria (processo), mas também contém informações sobre o hardware do sistema e a configuração atual do kernel. Veja um exemplo de saída abaixo:
Tenha em mente que as informações exibidas nos exemplos abaixo serão diferentes do que você pode ver no ambiente da máquina virtual deste curso.
O resultado da execução de ls /proc mostra mais de cem diretórios numerados. Há um diretório numerado para cada processo em execução no sistema, onde o nome do diretório corresponde ao PID (ID do processo) para o processo em execução.
Como o processo /sbin/init é sempre o primeiro processo, ele possui um PID de 1 e as informações sobre o processo /sbin/init podem ser encontradas no diretório /proc/1. Como você verá mais adiante neste capítulo, existem vários comandos que permitem visualizar informações sobre a execução de processos, portanto raramente é necessário que os usuários tenham que visualizar os arquivos para cada processo em execução diretamente.
Você também pode ver que há uma série de arquivos regulares do diretório /proc, como /proc/cmdline, /proc/meminfo e /proc/modules. Esses arquivos fornecem informações sobre o kernel em execução:
O arquivo /proc/cmdline pode ser importante porque ele contém todas as informações que foram passadas quando o kernel foi iniciado.
O arquivo /proc/meminfo contém informações sobre o uso da memória pelo kernel.
O arquivo /proc/modules contém uma lista de módulos atualmente carregados no kernel para adicionar funcionalidades extras.
Novamente, raramente é necessário visualizar esses arquivos diretamente, pois outros comandos oferecem uma saída mais "amigável" e uma maneira alternativa de visualizar essas informações.
Enquanto a maioria dos "arquivos" embaixo do diretório /proc não pode ser modificado, mesmo pelo usuário root, os "arquivos" embaixo do diretório /proc/sys podem ser alterados pelo usuário root. A modificação desses arquivos alterará o comportamento do kernel do Linux.
A modificação direta desses arquivos causa apenas alterações temporárias no kernel. Para tornar as alterações permanentes, as entradas podem ser adicionadas ao arquivo /etc/sysctl.conf.
Por exemplo, o diretório /proc/sys/net/ipv4 contém um arquivo chamado icmp_echo_ignore_all. Se esse arquivo contiver um zero 0, como normalmente faz, o sistema responderá às solicitações icmp. Se esse arquivo contiver um 1, o sistema não responderá às solicitações de icmp:
[user@localhost ~]$ su -
Password: 
[root@localhost ~]# cat /proc/sys/net/ipv4/icmp_echo_ignore_all 
0
[root@localhost ~]# ping -c1 localhost
PING localhost.localdomain (127.0.0.1) 56(84) bytes of data.
64 bytes from localhost.localdomain (127.0.0.1): icmp_seq=1 ttl=64 time=0.026 ms
--- localhost.localdomain ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.026/0.026/0.026/0.000 ms
[root@localhost ~]# echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_all
[root@localhost ~]# ping -c1 localhost
PING localhost.localdomain (127.0.0.1) 56(84) bytes of data.
--- localhost.localdomain ping statistics ---
1 packets transmitted, 0 received, 100% packet loss, time 10000ms
11.4 Hierarquia de processos
Quando o kernel termina de carregar durante o procedimento de inicialização, ele inicia o processo /sbin/init e atribui-lhe um ID de Processo (PID) de 1. Esse processo inicia outros processos do sistema e cada processo é atribuído a um PID em ordem sequencial.
À medida que o processo /sbin/init inicia outros processos, eles podem, por sua vez, iniciar processos, que podem iniciar outros processos de uma vez por outro. Quando um processo inicia outro processo, o processo que executa o início é chamado de processo pai e o processo iniciado é chamado de processo filho. Ao visualizar os processos, o PID principal será rotulado PPID.
Quando o sistema estiver executando por um longo período de tempo, ele alcançará o valor máximo de PID, que pode ser visualizado e configurado através do arquivo /proc/sys/kernel/pid_max. Uma vez que o maior PID tenha sido usado, o sistema irá "rolar" e retomar atribuindo valores PID que estão disponíveis na parte inferior do intervalo.
Os gráficos abaixo fornecem um exemplo e explicação do comando pstree. A saída variará dos resultados que você verá se você inserir o comando no ambiente da máquina virtual deste curso.
Você pode "mapear" processos em uma árvore genealógica de acoplamentos pai e filho. Se quiser ver esta árvore, o comando pstree irá exibi-la:
Se você examinasse o relacionamento dos processos pai e filho, usando a saída do comando anterior, você poderia considerar isso como o seguinte:
11.5 Comando ps (Process)
Outra maneira de ver os processos é com o comando ps. Por padrão, o comando ps só mostrará os processos atuais em execução no shell atual. Ironicamente, você verá ps em execução quando quiser ver o que mais está executando no shell atual:
sysadmin@localhost:~$ps 
 PID TTY TIME CMD 
 6054 ? 00:00:00 bash 
 6070 ? 00:00:01 xeyes
 6090 ? 00:00:01 firefox
 6146 ? 00:00:00 ps
sysadmin@localhost:~$
Semelhante ao comando pstree, se você executar ps com a opção --forest, então mostrará linhas que indicam o relacionamento pai e filho:
sysadmin@localhost:~$ ps --forest 
 PID TTY TIME CMD 
 6054 ? 00:00:00 bash 
 6090 ? 00:00:02 \_ firefox 
 6180 ? 00:00:00 \_ dash
 6181 ? 00:00:00 \_ xeyes
 6188 ? 00:00:00 \_ ps
sysadmin@localhost:~$
Para poder visualizar todos os processos no sistema, você pode executar o comando ps aux ou o comando ps -ef:
sysadmin@localhost:~$ ps aux | head 
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND 
root 1 0.0 0.0 17872 2892 ? Ss 08:06 0:00 /sbin?? /ini
syslog 17 0.0 0.0 175744 2768 ? Sl 08:06 0:00 /usr/sbin/rsyslogd -c5 
root 21 0.0 0.0 19124 2092 ? Ss 08:06 0:00 /usr/sbin/cron
root 23 0.0 0.0 50048 3460 ? Ss 08:06 0:00 /usr/sbin/sshd
bind 39 0.0 0.0 385988 19888 ? Ssl 08:06 0:00 /usr/sbin/named -u bind 
root 48 0.0 0.0 54464 2680 ? S 08:06 0:00 /bin/login -f
sysadmin 60 0.0 0.0 18088 3260 ? S 08:06 0:00 -bash 
sysadmin 122 0.0 0.0 15288 2164 ? R+ 16:26 0:00 ps aux 
sysadmin 123 0.0 0.0 18088 496 ? D+ 16:26 0:00 -bash 
sysadmin@localhost:~$ ps -ef | head 
UID PID PPID C STIME TTY TIME CMD 
root 1 0 0 08:06 ? 00:00:00 /sbin?? /init 
syslog 17 1 0 08:06 ? 00:00:00 /usr/sbin/rsyslogd -c5 
root 21 1 0 08:06 ? 00:00:00 /usr/sbin/cron 
root 23 1 0 08:06 ? 00:00:00 /usr/sbin/sshd 
bind 39 1 0 08:06 ? 00:00:00 /usr/sbin/named -u bind 
root 48 1 0 08:06 ? 00:00:00 /bin/login -f 
sysadmin 60 48 0 08:06 ? 00:00:00 -bash 
sysadmin 124 60 0 16:46 ? 00:00:00 ps -ef 
sysadmin 125 60 0 16:46 ? 00:00:00 head 
sysadmin@localhost:~$
A saída de todos os processos em execução em um sistema pode ser irresistível. No exemplo fornecido, a saída do comando ps foi filtrada pelo comando principal, portanto, apenas os dez primeiros processos foram mostrados. Se você não filtrar a saída do comando ps, é provável que você tenha que percorrer centenas de processos para encontrar o que pode interessar você.
Uma maneira comum de executar o comando ps é usar o comando grep para filtrar as linhas de exibição de saída que combinam uma palavra-chave, como o nome do processo. Por exemplo, se você quisesse visualizar as informações sobre o processo do Firefox, você pode executar um comando como:
sysadmin@localhost:~$ ps -e | grep firefox
 6090 pts/0 00:00:07 firefox
Como usuário root, você pode estar mais preocupado com os processos de outro usuário, do que com seus próprios processos. Devido aos vários estilos de opções que o comando ps suporta, existem diferentes maneiras de visualizar os processos de um usuário individual. Usando a opção UNIX tradicional, para visualizar os processos do usuário sysadmin, execute o seguinte comando:
[root@localhost ~]# ps -u username
Ou use o estilo BSD de opções e execute:
[root@localhost ~]# ps u U username
11.6 Comando top
O comando ps fornece um "instantâneo" dos processos em execução no instante em que o comando é executado, o comando top que atualizará regularmente a saída dos processos em execução. O comando top é executado da seguinte maneira:
sysadmin@localhost:~$ top
Por padrão, a saída do comando top é classificada pela % do tempo de CPU que cada processo está atualmente usando, com os valores mais altos listados primeiro. Isso significa que os processos que são " CPU hogs" estão listados primeiro:
top - 16:58:13 up 26 days, 19:15, 1 user, load average: 0.60, 0.74, 0.60 
Tasks: 8 total, 1 running, 7 sleeping, 0 stopped, 0 zombie 
Cpu(s): 6.0%us, 2.5%sy, 0.0%ni, 90.2%id, 0.0%wa, 1.1%hi, 0.2%si, 0.0%st 
Mem: 32953528k total, 28126272k used, 4827256k free, 4136k buffers 
Swap: 0k total, 0k used, 0k free, 22941192k cached 
 
 PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 
 1 root 20 0 17872 2892 2640 S 0 0.0 0:00.02 init 
 17 syslog 20 0 171m 2768 2392 S 0 0.0 0:00.20 rsyslogd 
 21 root 20 0 19124 2092 1884 S 0 0.0 0:00.02 cron 
 23 root 20 0 50048 3460 2852 S 0 0.0 0:00.00 sshd 
 39 bind 20 0 376m 19m 6100 S 0 0.1 0:00.12 named 
 48 root 20 0 54464 2680 2268 S 0 0.0 0:00.00 login 
 60 sysadmin 20 0 18088 3260 2764 S 0 0.0 0:00.01 bash 
 127 sysadmin 20 0 17216 2308 2072 R 0 0.0 0:00.01 top
Existe uma extensa lista de comandos que podem ser executados no programa de execução:
	Comandos
	Significado
	h or ?
	Ajuda
	l
	Alterar estatísticas de carga
	t
	Alterar estatísticas de tempo
	m
	Alternar estatísticas de uso de memória
	<
	Mover coluna ordenada para a esquerda
	>
	Mover coluna ordenada para a direita
	F
	Escolher campo classificado
	R
	Alterar direção de classificação
	P
	Ordenar por % da CPU
	M
	Ordenar por % de memória usada
	k
	Mate um processo (ou envie um sinal)
	r
	Prioridade renice de um processo
Uma das vantagens do comando top é que ele pode ser deixado em execução para permanecer no "topo" dos processos para fins de monitoramento. Se um processo começar a dominar, ou "fugir" com o sistema, ele aparecerá, por padrão, no topo da lista apresentada pelo comando top. Um administrador que está executando o comando top pode então tomar uma das duas ações:
- Terminar o processo "fugir": pressionar a tecla k enquanto o comando top está em execução solicitará ao usuário que forneça o PID e, em seguida, um número de sinal. O envio do sinal padrão solicitará o encerramento do processo, mas o envio do número de sinal 9, o sinal KILL, forçará o processo a encerrar.
- Ajuste a prioridade do processo: pressionando a tecla r enquanto o comando top está em execução irá solicitar ao usuário que o processo seja reiniciado e, em seguida, um valor agradável. Os valores de niceness podem variar de -20 a 19 e afetar a prioridade. Somente o usuário raiz pode usar um niceness que é um número inferior ao da atualidade, ou um valor niceness negativo, o que faz com que o processo seja executado com uma maior prioridade. Qualquer usuário pode fornecer um valor niceness que seja maior do que o valor atual de niceness, o que fará com que o processo seja executado com uma prioridade baixa.
Outra vantagem do comando top é que ele é capaz de lhe dar uma representação geral de quão ocupado o sistema atualmente e a tendência ao longo do tempo. As médias de carga mostradas na primeira linha de saída do comando top indicam a ocupação do sistema durante o último, cinco e quinze minutos. Esta informação também pode ser visualizada executando o comandouptime ou diretamente exibindo o conteúdo do arquivo /proc/loadavg:
sysadmin@localhost:~$ cat /proc/loadavg
0.12 0.46 0.25 1/254 3052
Os três primeiros números neste arquivo indicam a média de carga nos últimos intervalos de cinco e quinze minutos. O quarto valor é uma fração que mostra o número de processos que atualmente executam o código na CPU 1 e o número total de processos 254. O quinto valor é o último valor PID que executou o código na CPU.
O número reportado como uma média de carga é proporcional ao número de núcleos de CPU que são capazes de executar processos. Em um processador central único, um valor de um significaria que o sistema está totalmente carregado. Em uma CPU de quatro núcleos, um valor de um significaria que o sistema é apenas 1/4 ou 25% carregado.
Outro motivo pelo qual os administradores gostam de manter o comando superior em execução é a capacidade de monitorar o uso da memória em tempo real. Tanto o topo como o comando livre exibem estatísticas sobre como a memória geral está sendo usada.
O comando superior também tem a capacidade de mostrar a porcentagem de memória usada por cada processo, de modo que um processo que esteja consumindo uma quantidade excessiva de memória pode ser identificado rapidamente.
11.7 Comando free
Executar o comando free sem nenhuma opção fornece um instantâneo da memória usada nesse momento.
Se você quiser monitorar o uso da memória ao longo do tempo com o comando free, então você pode executá-lo com a opção -s e especificar esse número de segundos. Por exemplo, a execução de free -s 10 atualizaria a saída a cada dez segundos.
Para facilitar a interpretação do que o comando free é a saída das opções -m ou -g pode ser útil para mostrar a saída em megabytes ou gigabytes, respectivamente. Sem essas opções, a saída é exibida em bytes:
sysadmin@localhost:~$ free 
 total used free shared buffers cached 
Mem: 32953528 26171772 6781756 0 4136 22660364 
-/+ buffers/cache: 3507272 29446256 
Swap: 0 0 0 
sysadmin@localhost:~$
Ao ler a saída do comando free:
A primeira linha é um cabeçalho descritivo.
A segunda linha denominada Mem: é a estatística da memória física do sistema.
A terceira linha representa a quantidade de memória física depois de ajustar esses valores, não tendo em conta qualquer memória que esteja sendo utilizada pelo kernel para buffers e caches. Tecnicamente, essa memória "usada" pode ser "recuperada" se necessário.
A quarta linha de saída refere-se a memória de troca, também conhecida como memória virtual. Este é espaço no disco rígido que é usado como memória física quando a quantidade de memória física fica baixa. Efetivamente, isso faz parecer que o sistema possui mais memória do que realmente, mas usar o espaço de troca também pode diminuir o sistema.
Se a quantidade de memória e troca disponível estiver muito baixa, o sistema começará a encerrar os processos automaticamente. Esta é uma das razões pelas quais é importante monitorar o uso da memória do sistema. Um administrador que percebe que o sistema está reduzido na memória livre pode usar top ou kill para terminar os processos de sua escolha, em vez de deixar o sistema escolher.
11.8 Arquivos de Log
À medida que o kernel e vários processos são executados no sistema, eles produzem resultados que descrevem como eles estão sendo executados. Parte dessa saída é exibida na janela do terminal onde o processo foi executado, mas alguns desses dados não são enviados para a tela, mas, em vez disso, são escritos em vários arquivos. Isso é chamado de "dados de log" ou "mensagens de log".
Esses arquivos de log são muito importantes por vários motivos; eles podem ser úteis em problemas de resolução de problemas e podem ser usados ​​para determinar se o acesso não autorizado foi ou não tentado.
Alguns processos são capazes de "registrar" seus próprios dados para esses arquivos, outros processos dependem de outro processo (um daemon) para lidar com esses arquivos de dados de log.
Esses daemons de registro podem variar de uma distribuição para outra. Por exemplo, em algumas distribuições, os daemons que são executados em segundo plano para executar o log são chamados de syslogd e klogd. Em outras distribuições, um único daemon, como rsyslogd em Red Hat e CentOs ou systemd-journald no Fedora, pode atender a essa função de registro.
Independentemente do nome do chamado processo daemon, os arquivos de log eles mesmos são quase sempre colocados na estrutura de diretório /var/log. Embora alguns dos nomes dos arquivos possam variar, aqui estão alguns dos arquivos mais comuns a serem encontrados neste diretório:
	Arquivo
	Conteúdo
	boot.log
	As mensagens geradas como serviços são iniciadas durante a inicialização do sistema.
	cron
	Mensagens geradas pelo crond daemon para trabalhos serem executados de forma recorrente.
	dmesg
	Mensagens geradas pelo kernel durante a inicialização do sistema.
	maillog
	Mensagens produzidas pelo daemon de correio para mensagens de e-mail enviadas ou recebidas
	messages
	Mensagens do kernel e outros processos que não pertencem a outro lugar. Às vezes, chamado syslog em vez de mensagens após o daemon que grava esse arquivo.
	secure
	Mensagens de processos que exigiram autorização ou autenticação (como o processo de login).
	Xorg.0.log
	Mensagens do servidor X Windows (GUI).
Os arquivos de log são girados, o que significa que arquivos de log mais antigos são renomeados e substituídos por arquivos de log mais recentes. Os nomes dos arquivos que aparecem na tabela acima podem ter um sufixo numérico ou de data adicionado a eles, por exemplo: secure.0 ou secure-20131103
Girar um arquivo de log geralmente ocorre em uma base agendada regularmente, por exemplo, uma vez por semana. Quando um arquivo de log é girado, o sistema para de escrever para o arquivo de log e adiciona um sufixo para ele. Em seguida, um novo arquivo com o nome original é criado e o processo de registro continua usando esse novo arquivo.
Com os daemons modernos, um sufixo de data é tipicamente usado. Assim, no final da semana que termina em 3 de novembro de 2013, o daemon de registro pode parar de escrever para /var/log/messages, renomear esse arquivo /var/log/messages-20131103 e, em seguida, começar a escrever para um novo arquivo /var/log/messages .
Embora a maioria dos arquivos de log contenha texto como seu conteúdo, que pode ser visto de forma segura com muitas ferramentas, outros arquivos, como os arquivos /var/log/btmp e /var/log/wtmp, contêm binário. Ao usar o comando file, você pode verificar o tipo de conteúdo do arquivo antes de visualizá-lo para se certificar de que é seguro de visualizar.
Para os arquivos que contêm dados binários, normalmente há comandos disponíveis que lerão os arquivos, interpretarão seus conteúdos e depois enviarão texto. Por exemplo, os comandos lastb e last podem ser usados ​​para visualizar os arquivos /var/log/btmp e /var/log/wtmp, respectivamente.
Por motivos de segurança, a maioria dos arquivos encontrados não são legíveis pelos usuários comuns, então certifique-se de executar comandos que interagem com esses arquivos com privilégios de root.
11.9 Comando dmesg
O arquivo /var/log/dmesg contém as mensagens do kernel que foram produzidas durante a inicialização do sistema. O arquivo /var/log/messages conterá as mensagens do kernel que são produzidas à medida que o sistema está sendo executado, mas essas mensagens serão misturadas com outras mensagens de daemons ou processos.
Embora o kernel não tenha seu próprio arquivo de log normalmente, um pode ser configurado para eles normalmente, modificando o arquivo /etc/syslog.conf ou /etc/rsyslog.conf. Além disso, o comando dmesg pode ser usado para ver o buffer do anel do kernel, que manterá um grande número de mensagensque são geradas pelo kernel.
Em um sistema ativo, ou em vários erros do kernel, a capacidade desse buffer pode ser excedida e algumas mensagens podem ser perdidas. O tamanho desse buffer é definido no momento em que o kernel é compilado, por isso não é trivial a alteração.
Executar o comando dmesg pode produzir até 512 kilobytes de texto, então é recomendável filtrar o comando com um pipe para outro comando, como less ou grep. Por exemplo, se você estivesse solucionando problemas com seu dispositivo USB, então, procurar o texto "USB" com o comando grep sendo insensível a maiúsculas e minúsculas pode ser útil:
sysadmin@localhost:~$ dmesg | grep -i usb 
usbcore: registered new interface driver usbfs
usbcore: registered new interface driver hub
usbcore: registered new device driver usb
ehci_hcd: USB 2.0 'Enhanced' Host Controller (EHCI) Driver
ohci_hcd: USB 1.1 'Open' Host Controller (OHCI) Driver
ohci_hcd 0000:00:06.0: new USB bus registered, assigned bus number 1
usb usb1: New USB device found, idVendor=1d6b, idProduct=0001
usb usb1: New USB device strings: Mfr=3, Product=2, SerialNumber=1