livro-lpic-1-profjuliano_pagenumber

Prévia do material em texto

Bem-vindo! 
Bom dia, boa tarde e boa noite!
Se você ainda não me conhece, sou o professor Juliano Ramos. Tenho dedicado um grande tempo da minha
vida aos estudos de Linux e servidores. Sou professor por amor. Para mim não é trabalho, ou qualquer outra
definição. Acredito que é por isto, que sempre procuro fazer o diferencial e minhas aulas.
Este livro aborda a prova 101 e/ou LX-103 da Comptia Linux+.
 
Fazer o nosso curso 
Este livro é a base do nosso curso. Se você deseja assistir nossas aulas e aprender muito mais. Acesse:
www.certificacoes.net.br
Possuimos diversas opções de treinamento como preparatórios para certificações e cursos de servidores.
Qualquer dúvida, só me encaminhar um e-mail: profjulianoramos@gmail.com
 
 
Autor: Prof. Juliano Ramos | profjulianoramos@gmail.com
Certificado Comptia Linux, Linux Professional Institute, Red Hat, SUSE, PMI, Microsoft e Cisco. Professor, aluno
e hacker/geek em sua melhor definição. Apaixonado pelo movimento Open Source desde sua revolução ao
modelo de Software Livre em meados de 1998.
 
Licença de uso 
Este livro não pode ser comercializado. Ele foi criado para ser usado como apostila de apoio pela empresa
Certificações NET.BR em cursos ministrados pelo Prof. Juliano Ramos. Todos os direitos deste livro pertencem
a empresa referida e ao autor.
1
af://n16
af://n21
http://www.certificacoes.net.br/
mailto:profjulianoramos@gmail.com
mailto:profjulianoramos@gmail.com
af://n31
Você pode: Ler este livro e compartilhá-lo. Mas não pode, alterar seu conteúdo ou comercializá-lo de nenhum
modo.
 
 
Sumário 
Bem-vindo!
Fazer o nosso curso
Licença de uso
Sumário
Preparatório LTC1, LPIC1 e Comptia Linux+
LPIC - Linux Professional Institute Certificate
LPIC1
CompTIA - Computing Technology Industry Association
Linux+ - CompTIA POWERED BY LPI
Sobre o curso
Ame o pinguim
Virtualbox
Distribuições Linux
Distribuição leve
Comandos GNU e UNIX - Tópico 103
103.1 - Como trabalhar na linha de comando.
Como saber qual Shell estou utilizando?
O que é um comando?
Como o SHELL sabe localizar um comando externo?
Quando o comando não está no PATH?
Variáveis de ambiente - Local e Global
Ver todas as variáveis
Ver apenas as variáveis globais
Como remover uma variável
Variáveis pré-definidas
PWD
Comandos de modo sequencial
Navegar pelos comandos - histórico
Limpar arquivo de histórico
Pesquisar um comando que já digitei
Auto-completar do Bash
Obter ajuda
Informaçãoes do sistema
Apelidos de comandos
Tópico 103.2 - Arquivos de texto
Cabeçalho do arquivo
Rodapé do arquivo
Paginação da saída de texto
Ver a quantidade de linhas, caracteres e palavras de um arquivo
Ordenar um arquivo
Ver entradas únicas em um arquivo
Trocando tabs por espaços
Trocar espaços por tab
Exibir texto em formato octal e outros
2
af://n36
Combinar arquivos através de um indice
Dividir um arquivo
Apagar e Substituir caracteres
Formatar uma saída de texto
Preparar um arquivo para impressão
Recortar partes de um texto
A ferramenta poderosa sed
Gerenciamento de arquivos - Tópico 103.3
Copia de arquivos
Copiando diretórios
Mover e renomear um arquivo
Criando arquivo de texto vazio
Remover arquivos e diretórios
Remover diretório vazio
Criar um diretório
Procurar arquivos e diretórios
Agrupando arquivos
Compactando arquivos
Usando somente o tar
Usando o cpio
Copiar uma partição inteira
Redirecionamento de entrada e saída - Tópico103.4
Redirecionamento do erro
Um erro comum de redirecionamento
Visualizando a saída e criando um arquivo
Saída de um comando como entrada para outro comando
Iprimindo o resultado de um comando
Exercícios
103.1 - Linha de comando
103.2 - Filtros de texto
103.3 - Gerenciamento básico de arquivos
103.4 - Fluxos, pipes e redirecionamentos.
Gerenciamento de processos - Tópico 103.5
Comando ps
Comando pstree
Ver os PID dos processos
Comando top
Comandos para monitorar, parar e matar processos
Comando killall
Comando pkill
Comando para gerenciar os processos
Controle de tarefas
Exercício do tópico 103.5
Modificar prioridade de processos
Pesquisar arquivos de texto com expressões regulares - Tópico 103.7
Comando grep
Comando egrep
Tabelas de exemplos:
Exercício:
Edição básica de arquivos usando o VI - 103.8
Editor de texto VIM
Editor de texto vim
Como interpretar atalhos e comandos
3
Os modos do VIM
Abrindo caminhos dentro de um arquivo
Abrindo arquivo em uma linha específica
Alternando entre arquivos
Movimentando-se sobre o texto
Inserindo texto
Deletando texto
Copiar e colar
Recortar e colar
Substituição
Buscando texto dentro do arquivo
Arquitetura do sistema - Tópico 101
Identificar e configurar os dispositivos de Hardware - tópico 101.1
IRQ - Sinais de interrupção
Endereços de I/O - Entrada e saída
Endereços DMA
Barramentos
As partições virtuais
Dispositivos de armazenamento
Arquitetura do kernel Linux
Trabalhando com módulos
Quais módulos estão disponíveis?
Compilando um kernel
Tópico 101.2 - O Boot do sistema
Alterando os Runlevels, Shutdown e Reboot - Tópico 101.3
SystemD
Comandos do systemD
Iniciar, parar e reiniciar serviços
Comandos de shutdown e restart
Tópico 102
Quais as vantagens de um particionamento?
Sistemas de particionamento
Arquivo de swap
LVM - Logical Volume Manager
Comandos essenciais
102.2 - Configuração de boot loader
Principais arquivos de configuração
Criando uma entrada para o Windows
Trocar a senha de root - Grub
102.3 - Bibliotecas compartilhadas
Comandos básicos
Incluir uma biblioteca
102.4 - Gerenciamento de pacotes Debian
O comando dpkg
Comandos do apt
O comando apt-get
Atualizando o sistema operacional
Buscando um pacote
Instalando e removendo um pacote
Apenas fazer o download do pacote
Comando dpkg-reconfigure
Comando dselect
Comando aptitude
4
O aplicativo alien
102.5 - Gerenciador de pacote RPM
Tópico 104 - Dispositivos, sistemas de arquivos Linux e FHS
104.1 - Criando partições e sistemas de arquivos
104.2 - Mantendo a integridade do sistema de arquivo
Comandos de análise de sistema de arquivo
Comando dumpe2fs
Partições xfs
Setar informações da partição
104.3 - Controle de montagem e desmontagem de partições
Criando e montando a partição
Fstab
auto
ro e rw
auto e noauto
user e nouser
exec e noexec
sync e async
defaults
Exemplos de linhas no fstab
104.4 - Gerenciando cotas de discos.
104.5 - Gerenciando permissões e propriedades do arquivo
Permissão Literal
Permissão octal
Permissões Especiais
Comando chown, chgrp
Tópico 104.6 - Criando e alterando Links Hard e Soft - in
Link simbólico
104.7 - Localização de arquivos no linux
Comandos de busca de arquivos
Comando locate
Comando whereis
Comando which
Comando type
Agradecimento
 
Preparatório LTC1, LPIC1 e Comptia Linux+ 
LPIC-1 101-400 e 102-400
Comptia Linux+ LX0-103 e Lx0-104
 
LPIC - Linux Professional Institute Certificate 
A LPI tem um conjunto de certificações independentes de distribuições.
5
af://n39
af://n43
 
A Linux Essentials não é pré-requisito para nenhuma certificação.
LPIC1 
1. Voltada para Administadores de sistemas Linux
2. O profissional deve ser capaz de realizar tarefas de manutenção, instalação e configuração em qualquer
sistema linux, via linha de comando.
3. 2 provas: LPI 101-400 e 102-400. Cada uma com 60 questões e 1:30 de prova.
 
Para você receber a certificação LPIC1 é necessário ser aprovado nas 2 provas.
CompTIA - Computing Technology Industry Association 
1. Uma das maiores empresas Certificadoras da Área de TI
2. Também promove treinamentos, palestras e pesquisas em diversas áreas.
Linux+ - CompTIA POWERED BY LPI 
1. prova desenvolvida pela LPI
2. Exatamente o mesmo programa da LPIC-1
3. 2 provas: LX0-103 e LX0-104
4. Com a certificação CompTIA Linux+ você recebe também a LPIC-1
A mesma prova da LPIC.
 
Sobre o curso 
O Curso é baseado no programa da LPIC-1
Método: Explicação > Demonstração > Prática
Pré-requisito: Virtualização - Virtualbox
6
af://n48
af://n58
af://n65
af://n77
 
Ame o pinguim 
 
Faz parte do processo de aprendizado destruir o sistema :-), então, use sempre umamáquina virtual.
Uma máquina virtual é um software que simula um computador físico.
Virtualbox 
Referência:
https://www.virtualbox.org/
O Virtualbox é multi-plataforma (Windows, Linux , Mac, Solaris)
Distribuições Linux 
As certificações da LPI e da CompTIA não são focadas em nenhuma distribuição específica, dessa forma você
pode estudar e praticar em qualquer distribuição Linux.
Nas próximas aulas eu mostro como instalar a distribuição Xubuntu, essa escolha foi apenas por esta ser
uma distribuição simples de ser utilizada e bem leve, mais do que o suficiente para nossos objetivos neste
curso.
Mas você pode utilizar a distribuição que preferir, Debian, Ubuntu, Fedora, CentOS, etc. As diferenças serão
mínimas e quando ocorrerem eu informo durante a aula.
7
af://n82
af://n87
https://www.virtualbox.org/
af://n91
Distribuição leve 
Como a certificação de linux é independente de distribuição e vamos focar somente na linha de comando,
usaremos uma distribuição bem leve que roda sobre Debian - chamada Bunsenlabs.
https://www.bunsenlabs.org/
Download do arquivo ISO (imagem de CD/DVD e até mesmo de uma partição ou disco).
Comandos GNU e UNIX - Tópico 103 
Trabalhar na linha de comando (4)
Aplicando filtros a textos e arquivos (3)
Gerenciamento básico de arquivos (4)
Fluxo, PIPES e redirecionamentos (4)
Criar, modificar e encerrar processos (4)
Pesquisar arquivos de texto com expressões regulares (2)
Edição básica de arquivos usando o VI (3)
 
O número é o "peso", que nada mais é a quantidade questões que vão estar na prova.
103.1 - Como trabalhar na linha de comando. 
A LPIC deseja que você saiba o básico de linha de comando. O Shell é a interface entre o kernel (linux) e o
usuário e também é um ambiente de programação.
Temos vários tipos de SHELL como : Ksh, SH, Dash, FISH entre outros.
Usaremos o BASH que é o cobrado na LPIC.
Como saber qual Shell estou utilizando? 
O comando echo mostra na tela o resultado digitado:
Podemos visualizar o conteúdo de uma variável:
Neste caso, verificamos que estamos usando o /bin/bash
Se você não estiver executando o bash como padrão, é só chamar o bash:
O que é um comando? 
# echo "Linux Ubuntu"
Linux Ubuntu
# echo $SHELL
/bin/bash
# bash
8
af://n95
https://www.bunsenlabs.org/
af://n99
af://n117
af://n121
af://n129
Um comando pode ser um programa externo (Instalado no linux) ou um comando interno (do próprio shell).
Para saber se é um comando interno ou externo, usamos o comando type, exemplo:
Outro exemplo:
Neste caso ele mostra o caminho, dizendo que não é um comando interno do shell. As vezes pode-se
observar a saída: clear is hashed que significa que o comando é externo mas está em cache.
 
Como o SHELL sabe localizar um comando externo? 
Existe uma variável do SHELL que guarda o caminho dos executáveis, esta variável, chama-se PATH.
Quando o comando não está no PATH? 
Neste caso teremos que referênciar o caminho do comando. O comando pwd mostra o nosso diretório atual,
exemplo:
O Linux tem uma estrutura hierárquica de arquivos que começa no /(barra). Podemos navegar por estes
diretórios através do comando cd, exemplo:
Outro comando importante é o ls que irá listar os arquivos do diretório:
Ao executar o seu comando que é externo e não está no diretório PATH, você executa-o com o ponto barra,
que significa - este diretório, exemplo:
Digamos que você não esteja no diretório do programa, mas deseja executá-lo, neste caso você deve digitar o
caminho completo do programa:
Variáveis de ambiente - Local e Global 
# type echo
# type tar
tar is /bin/tar
# echo $PATH
# pwd
# cd /home/aluno
# ls
#./meuprograma.sh
# /home/aluno/script/programa.sh
9
af://n136
af://n139
af://n150
Assim que você inicia o SHELL várias variáveis de ambiente são carregadas. Veja como declarar uma variável
no SHELL:
Para ver o seu valor:
Esta variável é local, só esta disponível neste SHELL. Para que os processos possam visualizar está variavel e
novas seções, eu preciso usar o comando export, exemplo:
Ao executarmos o comando export tornamos a variável Global, de modo que poderá ter acesso em novas
seções. Podemos já criar a variável como global:
Ver todas as variáveis 
O comando set me permite visualizar todas as variáveis, porém como é muitas o melhor é páginar, ou seja,
visualizar por página a saída do comando:
Ver apenas as variáveis globais 
O comando env visualiza apenas as variáveis externas, ou seja, somente o que foi exportado.
O env permite alterar o valor de uma variavel somente para uma execução. Para exemplificar, crie com seu
editor simples o seguinte arquivo:
#/bin/bash 
echo $LINUX 
Salve como programa.sh e feche este arquivo. Daremos permissão para ele ser um executável (veremos isto
mais a frente):
# chmod +x programa.sh 
Declare a variável LINUX com o export:
# export LINUX="Eu amo" 
# NOME_VARIAVEL=valor
# echo $NOME_VARIAVEL
# export NOME_VARIAVEL
# export LINUX="Eu amo"
# set |less
# env |less
10
af://n159
af://n162
Rode o programa:
# ./programa 
Eu amo 
O resultado é "Eu amo", agora vamos mudar o valor da variável, somente na execução deste programa:
# env LINUX="Muito bom" ./programa.sh 
Muito bom 
Veja que o resultado somente nesta execução foi "Muito bom", mas o valor da variável LINUX continua sendo
"Eu amo".
Como remover uma variável 
O comando é unset e o nome da variável:
# unset LINUX 
Variáveis pré-definidas 
É importante conhecermos algumas variáveis que podem ser cobradas no exame. Podemos verificar algumas
usando:
# set |less 
HISTFILE
Esta variável mostra onde está o arquivo do histórico de comandos
HISTSIZE
Quantidade de linhas máximas do arquivo
HOME
Mostra o home (diretório do usuário) do usuário local
PWD 
Armazena o diretório local
SHELL
Mostra o Shell Atual
Hostname
O nome da máquina
TERM
Interface que logamos - Xterm: Interface gráfica | tty : ambiente texto
PS1
11
af://n176
af://n179
af://n188
Armazena as informações do prompt
 
Comandos de modo sequencial 
Podemos digitar vários comandos ao mesmo tempo em sequência, exemplo:
# clear; date; ls 
No exemplo acima ele irá rodar os três comandos, independente se todos eles forem sucesso.
Outra forma é:
# ls /tmp/qualquercoisa.txt && echo $SHELL 
O segundo comando só é executado se o primeiro tiver sucesso. Como não temos o arquivo
qualquercoisa.txt o segundo comando não será executado.
Outra forma é:
# ls /tmp/qualquercoisa.txt || echo $SHELL 
Neste caso o segundo comando só é executado comando o primeiro dá erro.
Navegar pelos comandos - histórico 
Com a seta para cima e para baixo, você navega pelos comandos digitados. Você pode verificar o histórico de
comandos usando:
# history 
Para executar o último comando:
# !! 
Outro comando importante :
# !19 
Neste caso ele vai executar o comando que está na linha 19 da saída do comando history
Limpar arquivo de histórico 
history -C 
Os comandos do history fica armazenado em arquivo do usuário. Podemos verificar com:
12
af://n199
af://n209
af://n217
juliano@DarthVader:~$ set |grep HISTFILE 
HISTFILE=/home/juliano/.bash_history 
HISTFILESIZE=2000 
juliano@DarthVader:~$ cat /home/juliano/.bash_history 
 
 
Observe que eu digitei set |grep HISTFILE neste caso o grep vai filtrar a saida do comando set. O resultado
foi: HISTFILE=/home/juliano/.bash_history
Posso verificar o conteúdo deste arquivo, executando:
# cat /home/juliano/.bash_history 
No linux, arquivos que se iniciam com . (ponto) são ocultos. Este arquivo é salvo sempre que a seção é
fechada. Cada usuário visualiza apenas o seu .bash_history, já o usuário Administrador - Root, visualiza o
histórico de todos os usuários.
Pesquisar um comando que já digitei 
Para realizar uma pesquisa pelo history você pode usar a teclas de atalho: +
Auto-completar do Bash 
Podemos usar a tecla para auto-completar, quando você começa a digitar um comando e digita duas vezes,
ele te mostra comandos que começam com a string que você está digitando:
juliano@DarthVader:~$ls 
ls lsb_release lshw lslocks lsof lspgpot 
lsattr lscpu lsinitramfs lslogins lspci lsusb 
lsblk lsdiff lsipc lsmod lspcmcia 
Também funciona para arquivos:
juliano@DarthVader:~$ cd / 
bin/ etc/ lib64/ opt/ sbin/ tmp/ 
boot/ home/ lost+found/ proc/ snap/ usr/ 
cdrom/ lib/ media/ root/ srv/ var/ 
dev/ lib32/ mnt/ run/ sys/ 
Obter ajuda 
Praticamente todos os comandos tem um manual de referência acessados pelo comando man exemplo:
# man ls 
Alguns arquivos de configuração também possuem páginas de manual. Quando o comando é interno do
bash, você deve visualizar no :
13
af://n225
af://n227
af://n232
# man bash 
Exemplo o comando cd. O man é uma ferramenta muito importante para o Administrador de sistemas Linux
e para candidatos aos exames de certificação.
Outro comando de ajuda é o info que é uma espécie de man reduzido. Uma opção interessante é a opção
info -k que permite pesquisar por um determinado conteúdo, exemplo:
juliano@DarthVader:~$ man -k "system information" 
dumpe2fs (8) - dump ext2/ext3/ext4 filesystem information 
uname (1) - print system information 
 
Outras opções são whatis e apropos :
juliano@DarthVader:~$ whatis tar 
tar (1) - The GNU version of the tar archiving utility 
O coamando whatis retorna informações sobre um determinado comando e o apropos retorna o comando
definido pela sua opção:
apropos information 
Funciona semelhante ao info -k
Informaçãoes do sistema 
Podemos usar o comando uname para obter informações do sistema, exemplo:
# uname --help 
Mostra as informações que podemos obter com este comando, digitando parâmetros. Exemplo:
# uname -r 
Mostra o kernel atual. Já uname -a mostra todas as informações.
Apelidos de comandos 
Podemos criar apelidos para comandos. Visualiza alguns já existentes:
14
af://n245
af://n251
juliano@DarthVader:~$ alias 
alias alert='notify-send --urgency=low -i "$([ $? = 0 ] && echo terminal || echo error)" 
"$(history|tail -n1|sed -e '\''s/^\s*[0-9]\+\s*//;s/[;&|]\s*alert$//'\'')"' 
alias egrep='egrep --color=auto' 
alias fgrep='fgrep --color=auto' 
alias grep='grep --color=auto' 
alias l='ls -CF' 
alias la='ls -A' 
alias ll='ls -alF' 
alias ls='ls --color=auto' 
 
No meu caso, quando digito ls na verdade, ele vai executar: ls --color=auto isto está definido em um arquivo
que é lido durante o boot do sistema, que veremos mais a frente. Para criar o nosso atalho, usamos:
# alias lt='ls /tmp' 
Agora sempre que digitarmos o comando que criei chamado lt ele vai executar o comando: ls /tmp. Por
enquanto isto se perde quando fecharmos a seção, mas a frente vamos aprender a colocar na inicialização do
sistema.
Tópico 103.2 - Arquivos de texto 
O comando cat lê um arquivo de texto. Por exemplo:
# cat /etc/passwd 
O comando pega o arquivo e redireciona para a saída padrão (tela). Podemos ver as linhas numeradas:
# cat -n /etc/passwd 
Ver linhas numeradas ignorando as linhas vazias:
# cat -b /etc/passwd 
Você pode ver todas as opções:
# cat --help 
O comando tac inverte a saída, mostrando o resultado de baixo para cima - inverso ao cat.
Cabeçalho do arquivo 
Usamos o comando: head, exemplo:
# head /etc/passwd 
15
af://n257
af://n267
Ele mostra as 10 primeiras linhas. Se desejamos verificar por exemplo, apenas as 2 primeiras linhas, usamos:
# head -n2 /etc/passwd 
Rodapé do arquivo 
Usamos o camando: tail que é o oposto do Head.
# tail /etc/passwd 
Mostra as 10 últimas linhas. Se precisamos das 2 últimas:
# tail -n2 /etc/passwd 
Outro comando interessante do tail é a opção -f, que mantém o arquivo aberto esperando mais informações,
excelente para logs. Exemplo:
# tail -f /var/log/auth.log 
Este arquivo mantém informações de login, abra outro terminal ou tty e faça login, você verá que
automaticamente o tail mostrou.
Paginação da saída de texto 
Temos o comando less e o more, a LPIC cobra apenas o less. Este comando permite navegar pelo arquivo:
# less /etc/passwd 
Com seta para baixo ou cima, navegamos linha a linha. Se apertamos ele pula para a próxima página.
Podemos fazer busca na saída usando barra (/) exemplo: /juliano ele vai procurar na saída do comando a
palavra juliano, se tiver mais de uma, usamos n de next, para voltar + .
Usamos muito o less com o pipe (|). O pipe pega a saída do primeiro comando e usa como entrada para o
segundo comando. Exemplo:
# cat /etc/passwd |less 
Ele pega a saída do comando cat e vai fazer a sua paginação.
Ver a quantidade de linhas, caracteres e palavras de um arquivo 
Usamos para isto o comando wc exemplo:
juliano@DarthVader:~$ wc /etc/passwd 
 40 70 2252 /etc/passwd 
Sendo no meu caso: 40 linhas, 70 palavras e 2252 caracteres. Ver somente linhas:
16
af://n272
af://n280
af://n287
# wc -l /etc/passwd 
Ver somente caracteres:
# wc -c /etc/passwd 
Ver somante palavras:
# wc -w /etc/passwd 
Podemos usar o comando nl ele é semelhante ao cat -b, ele numera as linhas sem considerar as linhas em
branco:
# nl /etc/passwd 
Ordenar um arquivo 
O comando sort vai ordenar os arquivos (odem alfabética). Exemplo:
# sort /etc/passwd 
Para ordenar de modo reverso, você usa:
# sort -r /etc/passwd 
Para ordenar pelo segundo campo, usamos:
# sort -k2 /etc/passwd 
Ver entradas únicas em um arquivo 
Digamos que você tenha um arquivo com nomes repetidos, exemplo:
juliano 
juliano 
maria 
joaquim 
juliano 
O comando vai retornar apenas: juliano, maria, joaquim, exemplo:
# uniq alunos.txt 
Para mostrar quantos nomes estão duplicados, posso usar:
17
af://n298
af://n305
# uniq -c alunos.txt 
3 juliano 
1 maria 
1 joaquim 
1 
Mostrou a frente as vezes que tenho aquele nome e a linha em branco (1). É muito útil usarmos o sort para
ordenar junto com o uniq, exemplo:
# sort alunos.txt | uniq -c 
Trocando tabs por espaços 
Usamos o comando expand para mudar tabulação para espaço, ele considera um tab como 8 espaços.
Sintaxe:
# expand arquivo.txt 
Cada vez que ele encontrar um tab ele troca por 8 espaços. Mas este troca é só para imprimir na tela, mas ele
não altera o arquivo.
 
Trocar espaços por tab 
O comando unexpand verifica 8 espaços e transforma em um tab.
# unexpand arquivo.txt 
Porém, ele por padrão só olha os espaços do começo da linha, mas você pode verificar em tudo, usando:
# unexpand -a arquivo.txt 
Se você desejar, por exemplo, que a cada 2 espaços ele transforme em um tab, use:
# unexpand -t 2 arquivo.txt 
Exibir texto em formato octal e outros 
O comando od mostra um arquivo em octal, mas ele permite outros formatos, verifique:
# od --help 
Combinar arquivos através de um indice 
Crie um arquivo com o seguinte conteúdo:
1 Maria
2 Joao
18
af://n314
af://n319
af://n326
af://n329
3 Lucas
Salve como alunos.txt. Agora crie outro arquivo com o seguinte conteúdo:
1 10
2 5
3 3.8
Salve como notas.txt. Execute agora:
# join alunos.txt notas.txt 
1 juliano 10 
2 maria 5 
3 lucas 3.8 
Lembre-se que os índices devem ser iguais e as linhas devem estar na mesma ordem. Um comando
semelhantes é o paste, mas ele não se preocupa com indices. Ele simplesmente junta os arquivos.
Dividir um arquivo 
Se você tem um arquivo longo, você pode dividir com o comando split exemplo:
split -l3 /etc/passwd 
Ele cria arquivos semelhantes a : xaa, xab e etc... Cada arquivo agora terá 3 linhas.
Apagar e Substituir caracteres 
O comando tr é usado para substituir caracteres, mas ele deve ser usado com pipe. Exemplo:
# cat /etc/passwd | tr a-z A-Z 
Ele altera todas as letras de minúscula para maiúscula. Exemplo 2:
# cat /etc/passwd | tr ei EI 
Transforma somente (ei) minúsculo para (EI) maiúsculo. Exemplo 3:
# cat /etc/passwd | tr juliano Grubelilo 
Altera juliano para grubelilo. Para excluir um caractere use a opção -d exemplo:
# cat /etc/passwd| tr -d juliano 
Formatar uma saída de texto 
Quando temos linhas muito longas em um texto, podemos reduzir a quantidade de caracteres usando o
comando fmt que por padrão usa 75 caracteres. Você pode definir o tamanho, usando:
19
af://n341
af://n345
af://n354
# fmt -w 20 /etc/passwd 
Vai mostrar 20 caracteres por linha do arquivo /etc/passwd
Preparar um arquivo para impressão 
O comando pr vai preparar o arquivo para impressão, colocando data e cabeçalho. Exemplo:
# pr texto.txt 
Se você desejar, pode colocar informações no cabeçalho, exemplo:
# pr -h "Curso prof. Juliano Ramos - FAFICA" arquivo.txt 
Recortar partes de um texto 
Quero que ele me mostre os primeiros 3 caracteres:
# cut -c1,2,3 texto.txt 
Quero que ele mostre os primeiros 5 caracteres (usando range):
# cut -c1-5 texto.txt 
A ferramenta poderosa sed 
Usado para substituir, deletar conteúdo de um texto e para expressões regulares que veremos a frente.
Exemplo:
# sed 's/ramos/oliveira/' alunos.txt 
Sempre que encontrar a palavra: ramos ele substitui por oliveira. Desta forma de uso ele só substitui a
primeira ocorrência de cada linha. Para substituir tudo é preciso usar:
# sed 's/ramos/oliveira/g' alunos.txt 
Para deletar uma linha usamos:
# sed '3,5 d'alunos.txt 
Apagamos da linha 3 a linha 5. Podemos definir que sempre que aparecer a palavra juliano, ele apagar a
linha.
# sed '/juliano/d'alunos.txt 
Gerenciamento de arquivos - Tópico 103.3 
20
af://n358
af://n363
af://n368
af://n377
A estrutura de diretórios do linux começa pela raíz que é uma barra (/) semelhante ao C:\ do Windows. Para
navegar pelos diretórios usamos o comando cd exemplo: cd /tmp.
Para voltar um diretório usamos:
# cd .. 
Para voltar 2 níveis de diretórios:
# cd ../../ 
Para ir direto para o diretório home do seu usuário:
# cd ~ 
Para listarmos os arquivos de um diretório usamos o comando ls, com a opção -a, podemos verificar arquivos
ocultos:
# ls -a 
Arquivos ocultos começam com . (ponto). Outra opção comum é -l, que mostra uma lista detalhada, podemos
usar em conjunto com o -a para um melhor resultado:
21
# ls -la 
Outra opção interessante é usar o -h para ver os valores em kbyte, mbyte e etc...
# ls -lha 
Para ir listando todos os subdiretórios de um diretório, podemos usar o -R de recursivo:
# ls -R /etc/ 
Para listar somente arquivos que tenha a extensão .txt usamos o caractere curinga asterisco. Exemplo:
# ls *.txt 
Digamos que você tenha uma lista com varios arquivos chamados: aula1, aula2, aula3 e etc... Você pode
definir quais listar usando:
# ls -l aula[123] 
Para mostrar todos e menos o aula1,aula2 e aula3, uso:
# ls -l aula[!123] 
Para ver do 10 ao 20:
# ls -l aula[10-20] 
Fazer uma sequencia específica:
# ls -l aula{10,20,30} 
Copia de arquivos 
O comando cp permite que você copie arquivos, exemplo:
# cp origem destino 
Exemplo 2 :
# cp /etc/passwd /tmp 
Ver detalhes da cópia, usamos:
# cp -v /etc/passwd /tmp 
Para perguntar se deseja sobrescrever um arquivo, use o hábito sempre de usar: -i , exemplo:
22
af://n404
# cp -i /etc/passwd /tmp 
Caso já tenha o arquivo ele te pergunta se deseja ou não sobrescrever o arquivo, por padrão, ou seja, sem a
opção -i, ele sobrescreve sempre.
Copiando diretórios 
O cp não copia por padrão diretórios, mas podemos resolver isto usando a opção de recursividade:
# cp -r diretorio /tmp/ 
Mover e renomear um arquivo 
Usamos o comando mv para mover um arquivo e também para renomeá-lo, exemplo:
# mv diretorio /tmp 
# mv arquivo /tmp 
# mv arquivo arquivo2 
Observe que não usamos -r (recursivo) no mv para diretórios.
Criando arquivo de texto vazio 
Usamos o comando touch para criar um arquivo vazio, exemplo:
# touch arquivo.txt 
Também podemos alterar a data e hora de alteração de um arquivo. Se você usar ls -l arquivo.txt vai poder
visualizar a hora de modificação do arquivo. Para mudar a data do último acesso:
# touch -a arquivo.txt 
Para alterar a data da ultima modificação:
# touch -m arquivo.txt 
Podemos definir uma data qualquer, exemplo:
# touch -t 201701011000 arquivo.txt 
Alterei para Ano 2017, Mês 01, Dia 01, hora 10:00 tempos anteriores só mostra o ano, ignorando a hora.
Remover arquivos e diretórios 
O comando é o rm exemplo:
# rm arquivo 
23
af://n414
af://n417
af://n421
af://n431
Remove o arquivo sem perguntar, se você quer que ele pergunte, use:
# rm -i arquivo 
Para remover diretório, usamos a recursividade:
# rm -r diretório 
Remover diretório vazio 
Para remover diretório vazio, pode-se usar o comando rmdir na prática, acabamos sempre usando o rm.
Criar um diretório 
Usamos para a criação de um diretório o comando: mkdir exemplo:
# mkdir diretorio 
Se você desejar criar um diretório com outro diretório use -p ou --parents que tem mesmo efeito.
# mkdir -p diretorio/diretorio2/diretorio3 
Procurar arquivos e diretórios 
Para procurarmos arquivos e diretórios usamos o comando:
# find /home -name aula1.txt 
No comando acima ele vai procurar o arquivo1.txt dentro do diretório /home. Para vermos todos que
começam com aula, usamos:
# find /home -name aula* 
Para restringir por um usuário específico:
# find /home -user juliano -name aula1 
Agora só vai procurar arquivo1 do usuário juliano. Para procurarmos arquivos por data de modificação:
find ./ -ctime -1 
Neste caso, estou procurando a partir do meu diretório atual (./) arquivos modificados no último dia.
Agrupando arquivos 
O tar cria um arquivo de backup. Para criar vamos usar:
# tar cpvf backup.tar /tmp 
24
af://n438
af://n440
af://n445
af://n455
Usamos:
c Criar o arquivo
p Manter as permissões dos arquivos
v Modo verbose - Ver detalhes
f Apontar o arquivo (sempre será utilizado)
 
Neste caso, não estamos compactando, ou seja, diminuindo o tamanho, estamos apenas agrupando.
Compactando arquivos 
Para iniciar, vamos começar com o gzip, usando aquele arquivo que agrupamos:
# gzip backup.tar 
Observe que ele gera um novo arquivo chamado: backup.tar.gz que significa que esta compactado. Para
descompactar usamos:
# gunzip backup.tar.gz 
Ele remove o backup e volta ao original backup.tar. Se você deseja criar o compactado e manter o original,
use:
# gzip -k backup.tar 
Temos outro algoritmo de compactação chamado bzip2 neste caso usamos:
# bzip2 -k backup.tar 
Ele vai criar o arquivo backup.tar.bz2. Para descompactar:
# bunzip backup.tar.bz2 
Outro algoritmo que podemos usar é o XZ, para compactar:
# xz backup.tar 
Para descompactar:
# unxz backup.tar.xz 
Podemos usar também para decompactar a opção -d : gzip -d, bzip2 -d, xz -d. Vale lembrar que eles
compactam qualquer arquivo e não somente arquivos .tar como no exemplo.
Usando somente o tar 
25
af://n465
af://n481
É possível usar o comando tar para criar arquivos compactados e descompactar. Por exemplo, para criar já
compactado em gzip:
# tar zcvpf backup.tar.tgz /tmp 
Para já criar compactado em bzip2:
# tar jcvpf backup.tar.tbz /tmp 
Para xz usamos:
# tar Jcvpf backup.txz /tmp 
Para verificar como foi compactado determinado arquivo (caso não tenha extensão) use o comando file
exemplo:
# file nome_do_arquivo 
Para descompactar qualquer um deles só altere c para x e a letra do formato que está compactado, exemplo:
# tar zxvf backup.tar.tgz 
Usando o cpio 
O cpio é semelhante ao tar, porém, ele necessita de uma lista de arquivos como entrada. Por padrão usamos
ele com o comando find, exemplo:
# find /tmp | cpio -o > backup.cpio 
Neste caso estamos criando o backup do diretório /tmp com o nome backup.cpio. Para desagrupar, usamos:
# cpio -i < backup.cpio 
Copiar uma partição inteira 
O comando dd permite uma copia bit a bit de uma partição ou até mesmo de um disco inteiro. Você pode
verificar as partições que você tem no sistema com o comando:
# df -h 
Para fazer uma cópia exata de um disco, use:
# dd if=/dev/sda of=/dev/sdb 
No exemplo acima criamos uma cópia exata de um disco para outro. Isto é importante, por exemplo, no casode um backup de servidor. Se você quiser fazer uma imagem (.iso) de um disco (DVD, Blu Ray) utilize o
comando:
26
af://n492
af://n497
# dd if=/dev/sr0 of=imagem.iso 
Partindo do pré-suposto que seu drive de dvd esteja em /dev/sr0.
Redirecionamento de entrada e saída -
Tópico103.4
 
No linux temos uma entrada padrão, identificada como STDIN (0) - Teclado, uma saída padrão STDOUT(1) -
sua tela e uma saída de erro STDERR (2) também sua tela.
Quando você desejar redirecionar a saída padrão use o sinal de maior ( > ). Exemplo:
# ls -l /tmp > saida.out 
No exemplo acima, ao invés do resultado do comando ls ser a tela do computador, estamos enviando esta
saída para um arquivo, chamado: saida.out. Se você usar o cat ou o less neste arquivo, perceberá que o
conteúdo da listagem está no arquivo.
# cat saida.out 
Quando você utiliza o maior (>) ele sobrescreve o arquivo que existir. Por exemplo:
# df -h > saida.out 
Ele vai reescrever o arquivo saida.out colocando o resultado do comando df -h. Para adicionar conteúdo e
não reescrever, use ( >> ), exemplo:
# ls /tmp >> saida.out 
Redirecionamento do erro 
Por exemplo, se você listar um arquivo que não existe, o resultado sai na saida padrão STDIN1:
# ls /tmp/arquivo-inexistente 
ls: não é possível acessar /tmp/arquivo-inexistente: Arquivo ou diretório não encontrado 
Veja que posso referênciar a saída padrão com > exemplo:
# ls /tmp/arquivo-inexistente > saida_ls 
ls: não é possível acessar /tmp/arquivo-inexistente: Arquivo ou diretório não encontrado 
Para redirecionar para a saída de erro STDERR2, usamos:
# ls /tmp/arquivo-inexistente 2> saida_ls 
Agora temos um arquivo chamado saida_ls com a informação do erro.
27
af://n505
af://n515
# cat saida_ls 
Digamos que você queira fazer duas saídas, uma para o padrão STDIN1 e outra para erro STDERR2. Como
exemplo, vou usar 2 arquivos, um que exista no diretório e outro não.
#touch /tmp/existo 
ls -l /tmp/{existo,nao-existo} > saida-ls.out 2> saida-ls-erro.out 
Temos 2 arquivos agora, um com erro e o outro com a saída:
tux@giovanna /tmp> cat saida-ls.out 
-rw-r--r-- 1 tux tux 15 Ago 30 18:25 /tmp/existo 
 
tux@giovanna /tmp> cat saida-ls-erro.out 
ls: não é possível acessar /tmp/nao-existo: Arquivo ou diretório não encontrado 
 
Se eu desejar redirecionar a saída padrão e a saída de erro ao mesmo arquivo:
ls -l /tmp/{existo,nao-existo} > saida-ls.out 2>&1 
Um erro comum de redirecionamento 
Digamos que você tenha um aquivo chamado texto.txt com duas linhas, exemplo:
Olá Mundo 
Sou o Tux 
Você deseja colocar os números das linhas a frente e resolver usar o comando nl exemplo:
tux@giovanna /tmp> nl texto.txt 
 1 ola mundo 
 2 sou o tux 
Agora você decide reeditar este arquivo com a saída do comando nl, muitos alunos, fazem:
# nl texto.txt > texto.txt 
Pode parecer que está certo, mas tente visualizar o conteúdo do arquivo texto.txt e ficará surpreso, ele está
vazio. Isto por que o Shell vai criar o arquivo e como ele já existe ele apaga o atual.
Diga: Encaminhe a saída alterada para um arquivo com um nome diferente. Exemplo:
# nl texto.txt > texto.tmp 
# mv texto.tmp texto.txt 
Visualizando a saída e criando um arquivo 
28
af://n530
af://n540
O comando tee permite que eu visualize a saída do comando e ao mesmo tempo crie um novo arquivo com
esta informação. Sua sintaxe:
# ls -l /tmp | tee novo_arquivo.tmp 
Veja que você teve a saída do comando, mas também terá um arquivo chamado novo_arquivo.tmp com esta
informação.
Saída de um comando como entrada para outro comando 
Para pegarmos a saída de um comando e usarmos como argumento para outro comando, usamos o
comando xargs. Exemplo prático:
# find /etc -name "passwd" | xargs ls -l
No exemplo acima, ele pega o resuldado da busca de arquivos (passwd) dentro de /etc e usa como
argumento para o comando ls -l.
Iprimindo o resultado de um comando 
Podemos imprimir o resultado de um comando usando crase, exemplo:
# echo "A versão do kernel é: " `uname -r` 
Outro modo é:
# echo "A versão do kernel é:" $(uname -r) 
 
Exercícios 
Que tal uma pausa para estudar um pouco sobre o que já abordamos? Faça os exercícios abaixo.
 
103.1 - Linha de comando 
1) Encontre as seguintes informações:
Caminho completo de seu .bashrc
O release do kernel instalado
Diretórios que estão no PATH
Hostname da máquina
 
2) Crie e exporte uma variável chamada LINUX com o valor: Eu amo!
3) Crie um comando que escreva na tela: Eu uso Linux e <utilize a variável LINUX>
 
29
af://n544
af://n548
af://n554
af://n557
103.2 - Filtros de texto 
1) Gere um comando que mostre as linhas do arquivo /etc/passwd excluindo-se as linhas que contenham a
palavra "daemon".
 
103.3 - Gerenciamento básico de arquivos 
1) Crie a seguinte estrutura de diretórios dentro do seu diretório home:
/curso/comptialinux/profjulianoramos - Com apenas um comando.
2) Copie o diretório criado (profjulianoramos) para /tmp mantendo as permissões.
3) Compacte a estrutura de arquivos criada na questão 1 em tar.gz dentro do diretório /tmp
4) Compacte a estrurura de arquivos criada na questão 1 em tar.bz2 dentro do diretório /tmp
 
103.4 - Fluxos, pipes e redirecionamentos. 
1) Gere um arquivo de saída com nome saida.out, conteúdo o resultado de ls -l no diretório /etc somente
dos arquivos que contenham a string config.
2) Explique os redirecionadores:
> arquivo: 
< arquivo: 
>> arquivo: 
2> arquivo: 
>arquivo 2>&1: 
Gerenciamento de processos - Tópico 103.5 
Todo programa e script que você inicia no linux, você está iniciando um processo. Todo processo tem um
número de identificação chamado de PID - Process Identifier. Além do PID temos o PPID - Parent Process ID
que é o processo pai dentro de uma hierarquia de processos. Exemplo: Se você abre o bash e depois chama
uma aplicação como o firefox, o processo PPID será o bash. O primeiro processo do linux é o init e o PID dele
é 1.
Comando ps 
O comando ps é usado para mostrar os processos da máquina. O comando ps tem diversas opções,
usaremos as que possivelmente vão estar no exame.
Ao executarmos apenas ps vamos visualizar apenas os processos do nosso usuário em nosso terminal.
# ps 
Para ver mais detalhes usamos a opção -u de usuário:
30
af://n572
af://n575
af://n581
af://n585
af://n587
# ps -u 
Agora podemos visualizar além do PID, algumas informações como uso da CPU e da memória que este
processo esta consumindo. Outra opção muito utilizada é o -x que mostra processos que não foram iniciados
diretamente em nosso terminal.
# ps -ux | less 
Para visualizar todos os processos incluindo processos de outros usuário, usamos -a exemplo>:
# ps -aux | less 
Para ver em formato de árvore hierárquica de processos, podemos usar a opção -f exemplo:
# ps -auxf | less 
Para ver a prioridade do processo, podemos usar a opção -l exemplo:
# ps -alx | less 
Usamos muito o comando ps com o pipe para filtrar uma saída, exemplo:
# ps -aux | grep vlc 
Comando pstree 
O comando pstree mostra os processos em formato de árvore hierárquica.
# pstree 
Uma opção interessante é o -p que mostra os números do PID:
# pstree -p 
Observe que o pstree mostra que o PID 1 é o systemD. O init era o sistema antigo de inicialização que hoje
aponta para o systemD. Então de fato o processo 1 é o SystemD. Mas em uma questão no exame sobre qual
seria o processo 1, seria INIT (por padrão).
Ver os PID dos processos 
Podemos usar o comando pgrep para encontrar o PID de um processo, exemplo:
# pgrep bash 
Para ver processo de um usuário específico, utilize:
31
af://n603
af://n609
Sinal Código Uso
SIGHUP 1
Termina ou reinicia um processo. Utilizado também para que os arquivos de
configuração de um programa sejam relidos.
SIGINT 2 Interrompe a execução do processo. Relacionado ao ctrl+c
SIGQUIT 3 Termina um processo e normalmente gera um arquivo dump
SIGKILL 9 Finaliza um processo de maneira imediata e condicional
SIGTERM 15 O sinal solicita que o processo se finalize. Sinal padrãodo comando Kill.
SIGSTP 20
Interrompe um processo permitindo que ele possa ser retomado. Relacionado
a ctrl+z
SIGCONT 18 Continua a execução de um processo pausado (pelo sinal 20 por exemplo.)
# pgrep bash -u usuario 
 
Comando top 
O comando top é um dos principais comandos para monitorar o desempenho da máquina. Ao digitar o
comando top sem nenhum parâmetro, você terá uma tela interativa, com diversas informações sobre o
equipamento, que inclui: Número de processos, uso de CPU, Memória entre outros.
Dentro do comando top se você digitar: shift + M irá visualizar os processos que estão consumindo mais
memória.
Para ordenar por uso de CPU: shift + U
Para mostrar processos apenas de um usuário, digite u e o nome do usuário na caixa de dialogo. Vazio, para
todos.
Para visualizar a saída do top sem usar tela interativa, use:
# top -b 
Isto é útil para criação de log. Mas vale lembrar que o ps faz isto muito bem.
Comandos para monitorar, parar e matar processos 
Antes de tudo, segue uma tabela sobre sinais de processos, será útil a seguir:
Os processos monitoram os sinais enviados pelo kernel ou pelo usuário. Estes sinais fazem o processo ter
alguma ação. O comando é kill mas ele não é só usado somente para matar processos como muitos
pensam. Se você usar kill -l vai visualizar uma lista de todos os processos que são aceitos no linux. Mas na
tabela acima, eu menciono os mais utilizados.
O primeiro passo é saber o PID do processo, exemplo:
32
af://n615
af://n623
Com o número do processo, você pode finalizá-lo:
O kill sem nenhum parâmetro, usa o sinal -15 (SIGTERM). Para descrever o sinal, você pode usar o paramêtro -
s exemplo:
Outra forma é usando o número:
A forma mais comum de utilização é com o número do sinal.
Comando killall 
O comando killall mata os processos baseado nos nomes do processos e não no seu número de PID.
Exemplo:
# killall firefox 
Vai matar todos os processos com nome firefox.
Obs: Os processos possuem permissões, apenas o root pode matar os processos de qualquer usuário. Um
usuário comum não pode matar o processo de outro usuário comum.
Comando pkill 
O pkill permite que você faça um filtro em processos pelo nome e pelo nome do usuário. Exemplo: Digamos
que você está no servidor como root e tem 4 usuários rodando o processo firefox, para matar este processo
apenas do usuáro juliano, você iria executar:
# pkill -9 firefox -u juliano 
Comando para gerenciar os processos 
O comando uptime mostra a quanto tempo a máquina está em funcionamento. Outro comando que
também sai no top é o free que mostra a quantidade de memória disponível. Usamos a opção -m para ver
em (KB,MB ou GB).
O used engana as vezes muitos usuários. Na verdade o seu valor é a quantidade de memória alocada para o
Linux e não necessáriamente que ela está em uso. Agora, fique atento a memória swap, pois quando ela está
em uso é por que a memória RAM já chegou ao seu máximo.
O screen é uma ferramenta para trabalharmos em várias abas. Muito útil quando estamos trabalhando em
sessão remota como ssh. Funcionamento básico:
#ps aux | grep nome-do-processo
# kill PID
# kill -s SIGKILL PID
# kill -9 PID
33
af://n668
af://n673
af://n676
# screen 
# <ctrl> + <c> 
# <ctrl> + <n> 
Ao abrir o screen você cria uma nova aba com ctrl+c e visualiza as existentes com ctrl+n. Para iniciar uma
nova aba já com um comando, execute:
# screen nome_do_comando 
# screen top 
Controle de tarefas 
Quando iniciamos um processo no terminal, o processo fica preso no comando, exemplo:
# firefox 
Você abre o firefox mas seu terminal não pode mais ser utilizado até o firefox ser fechado, chamamos isto de
processo em foreground. Para executar um processo, liberando nosso terminal, usamos o que se chama
processo em background, neste caso, basta colocar um & comercial ao final do comando:
Ao executar este comando, ele mostra o ID do Job e o PID do processo. No exemplo acima, número do Job [1]
e o PID 55335. O comando jobs mostra os processos em background:
Outra forma de colocar um processo em background é abrir uma aplicação e depois digitar: +
Quando você executa isto, ele fica em stopped ou seja, o processo não foi finalizado, mas não está
funcionando. Se você digitar bg ele pega o último processo e coloca em background, liberando assim o
funcionamento do processo. Se você desejar colocar o processo em foreground você usa o comando fg. Você
pode especificar o processo colocando o número, exemplo:
Podemos evitar alguns sinais, menos o sigkill (-9). Para não permitir por exemplo o SIGHUP(1), podemos usar
o comando:
Isto é útil por exemplo: Se tivessemos executado o comando acima remotamente, ao fechar a seção, não
seria fechado o firefox.
Exercício do tópico 103.5 
# firefox &
[1] 55335
# jobs -l
# bg 2
# fg 2
# nohup firefox &
34
af://n683
af://n696
1) Preencha as informações abaixo:
1. Total de memória RAM utilizada (em MB)
2. Quantidade de processos em execução
3. PID dos 3 últimos processos
 
2) Execute um processo em foreground, faça stopped depois coloque ele para ser executado em background.
Coloque de volta o processo em foreground e por outro terminal, finalize este processo com SIGKILL.
Modificar prioridade de processos 
Quando você executar o comando top observe a coluna NI ela mostra o valor da prioridade de um processo.
Quanto menor o valor da prioridade maior é a quantidade de recurso para o processo.
Os valores são:
-20...........................................+19
O valor negativo é igual a mais prioridade, o positivo menor prioridade. Somente o usuário root pode
aumentar a prioridade do processo. O usuário comum pode diminuir a prioridade dos seus processos, mas
não pode aumentá-la.
Vamos abrir o firefox com uma prioridade 15:
# nice -n 15 firefox & 
Quando executar o comando top você pode verificar a prioridade na coluna NI (nice). Ou executando:
# ps -la | grep firefox 
Para alterar o valor da prioridade de um processo em execução:
# renice -n -8 PID 
Alterar todas as prioridades de um usuário:
# renice -u juliano -n 5 
Pesquisar arquivos de texto com expressões
regulares - Tópico 103.7
 
Expressões regulares é um assunto muito intenso, existem cursos e livros apenas para isto. Vamos nos
concentrar apenas no conteúdo do exame Comptia Linux+.
O que é uma REGEX ou Regular Expression ? A expressão regular é um conjunto de caracteres que define um
padrão de texto.
Comando grep 
35
af://n707
af://n720
af://n723
O comando grep vai encontrar blocos de texto com uma string especificada, por exemplo:
# grep juliano /etc/passwd 
Lembrando que é case sensitive ou seja, tem diferença entre minusculas e maiúscula. A opção -c vai contar
quantas ocorrências encontramos no arquivo:
# grep -c juliano /etc/passwd 
Digamos que você queira procurar em diversos arquivos quantas vezes a palavra é repetida, poderia usar:
# grep -c juliano * 
Outra opção é -i que vai ignorar o case sensitive.
# grep -i JULIANO /etc/passwd 
A opção -r é recursiva, ou seja, ele procura nos diretórios atuais e também dentro dos subdiretórios:
# grep -r juliano /etc/* 
No exemplo acima, ele procura "juliano" dentro dos diretórios e subdiretórios /etc. Para expressões regulares
mais avançadas, usamos grep -E ou egrep. Que veremos a seguir com mais detalhes.
A opção -v vai excluir uma determinada palavra na busca, exemplo:
# grep -v juliano /etc/passwd 
Podemos usar com outras opções, por exemplo:
# grep -vi JULIANO /etc/passwd 
Neste caso, ele vai excluir JULIANO mas excluindo o case sensitive.
Comando egrep 
Vamos trabalhar com expressões usando o egrep. Usaremos a expressão entre aspas "". Vejamos um
exemplo:
# egrep "b[aei]g" arquivo.txt 
No exemplo acima estamos procurando palavras como bag,beg,big dentro do arquivo.txt. Podemos também
usar uma sequência:
# egrep "b[a-u]g" arquivo.txt 
36
af://n740
No exemplo acima, ele vai mostrar palavras de A a U (aeiou). Podemos definir também, o começo da linha e o
seu fim:
# egrep "^Linux" arquivo.txt 
Sempremostrará a palavra Linux que estiver no começo do arquivo (^). Para exibir as palavras do final, use:
# egrep "Linux$" arquivo.txt 
No começo fica (^) circunflexo, no final ($) dólar.
Exemplo prático:
Para ver todas as linhas com comentários:
# egrep "^#" arquivo.txt 
Para ver todas as linhas sem os comentários:
# egrep -v "^#" arquivo.txt 
Outro exemplo:
# egrep "b[a-i]g*" arquivo.txt 
baseado no debian 
bag 
beg 
big 
O * após, informa que tanto faz se o caracter g apareça ou não, o conteúdo deve ser exibido. Observe no
retorno que (baseado no linux) apareceu, isto por que tem (bas) da palavra baseado, mesmo que não tenha
g.
Agora, vamos especificar um pouco mais:
# egrep "b[a-i]g*e" arquivo.txt 
bigger 
bege 
Estou especificando que após quantos g forem, deve aparecer a letra e , outra opção é o + que define que o
caractere anterior apareça pelo menos uma vez, exemplo:
# egrep "b[a-i]g+" arquivo.txt 
bag 
beg 
big 
Neste caso a palavra "baseado" não apareceu, já que não tem a letra g.
37
Expressão Regular Descrição Exemplo
^ Indica o começa da linha. ^linux
$ Indica o final da linha linux$
Outra opção é o ?, ele define que irá aparecer ocorrência ou com nenhum ou com apenas 1 vez o caractere g
exemplo:
# egrep "b[a-i]g?" arquivo.txt 
baseado no debian 
bag 
beg 
bege 
big 
bigger 
Observe que ele mostra "bigger" mas por que ele mostra a linha inteira. Para entender melhor faça:
# egrep "b[a-i]g?e" arquivo.txt 
bege 
Neste caso somente a palavra bege apareceu, mesmo eu tendo bigger. O ponto (.) é usado para definir a
quantidade de caracteres após o g que estamos usando no exemplo:
# egrep "b[a-i]g..." 
bigger 
beginner 
No exemplo acima, estou definindo que quero 3 caracteres depois do g - por isto os três pontos.
Exemplo 2:
# egrep "O.Linux" arquivo.txt 
O Linux 
Vale lembrar que o espaço equivale a 1 caractere. Outra opção:
# egrep "O.*Linux" arquivo.txt 
O Sistema Operacional Linux 
O Linux 
O Concorrente do Windows é o Linux 
Neste caso (.*) ele vai mostrar tudo entro o (O e Linux ).
Tabelas de exemplos: 
Conjunto de caracteres e repetições
38
af://n775
Expressão
Regular
Descrição Exemplo
[abc]
Conjunto de caractere único. Determina qualquer caractere
dentre os pertencentes a lista.
[Ll]inux = Linux, linux
[a-z] ou [0-
9]
Range de caractere único. Determina qualquer caractere
dentros os pertencentes ao range.
Versão[5-7] = Versão5,
Versão6,Versão7
[^abc] Negação do que está na lista.
Versão[ ^ 0-7 ] =
versao8,versao9
. Indica qualquer caractere único ca.o = caso,caio,ca9o
* Nenhuma ou várias ocorrências do caractere anterior.
bola*= bol, bola,
bolaaaaa
+ Uma ou várias ocorrências do caractere anterior bola*=bola, bolaaaaa
? Nenhuma ou apenas uma ocorrência do caractere anterior bola? = bol, bola
Exercício: 
1) Gere um comando que exiba na tela todas as linhas do arquivo /etc/passwd que terminem com "nologin".
 
2) Crie um comando que liste todos os arquivos dentro do diretório /etc/ que contenham a palavra "snd" em
seu conteúdo, não nome de arquivo, a pesquisa deve incluir também subdiretórios.
 
Edição básica de arquivos usando o VI - 103.8 
O VI que vamos trabalhar é uma versão melhorada chamada VIM, no exame os comandos são relativos a ele,
você pode verificar executando:
# vi --version 
Caso não tenha o vim instalado:
# apt-get install vim 
Editor de texto VIM 
Praticamente quase toda a configuração de um sistema GNU/Linux é realizada através da edição direta de
arquivos de configuração em modo-texto. São diversas aplicações que podemos utilizar para editar estas
arquivos, no entanto, como nosso foco é também se preparar para as certificações de linux, utilizaremos o
editor VIM.
Para definirmos no Debian qual será o nosso aplicativo de texto padrão, usamos o comando:
39
af://n823
af://n828
af://n833
# update-alternatives --config editor 
 
Editor de texto vim 
O VI é o editor básico do GNU/Linux, e está disponível em grande parte das distribuições de GNU/Linux. Hoje
em dia, as distribuições usam uma versão mais completa e com mais recursos do que o VI que é o VIM = VI
IMproved.
Para instalar o VIM no debian, utilize o comando:
# apt-get install vim 
 
Para abrir o VIM digite :
# vim 
 
Quando aberto, você poderá chamar a ajuda do vim, digitando:
:help 
 
Ou, simplesmente:
:h 
 
Como interpretar atalhos e comandos 
A tecla é representada na maioria dos manuais e no help do VIM pelo caractere ^ circunflexo, ou seja, o atalho
para < control > + , aparecerá assim:
^L 
 
Vou criar como exemplo um arquivo vazio e abrir o mesmo com o VIM:
# touch arquivo.txt 
# vim arquivo.txt 
 
Como estamos iniciando os nossos estudos com o editor VIM, é comum cometermos erros na edição de um
texto. Para recarregar este arquivo que está sendo editado, sem as alterações, execute:
40
af://n837
af://n847
< esc > Para sair do modo de edição 
:e! Recarrega o arquivo sem as alterações 
 
Você também, pode optar em fechar este arquivo, sem salvar suas modificações:
< esc > Para sair do modo de edição 
:q! Sai do arquivo sem editá-lo 
 
Os modos do VIM 
O VIM trabalha com três modos de operação. Vamos supor que temos o arquivo de nome texto.txt, podemos
abrir ele usando o comando:
$ vim texto.txt 
 
Ele abre no modo de visualização. Quando pressionamos a tecla < i > ou < insert > ele abre o modo de
Inserção. Quando você pressiona a tecla < esc > ele volta para o modo de comandos. Neste modo, você
digita um comando colocando dois pontos a frente, exemplo:
:help 
 
Para acessar o modo de visualização novamente, pressione a tecla < v > .
Entendendo melhor:
O modo de inserção é onde você passa o tempo digitando o texto.
O modo de comandos é onde você vai formatar o texto (deletar, copiar e colar, replace e etc).
O modo visual é onde você faz seleção de grandes blocos de texto.
Abrindo caminhos dentro de um arquivo 
Caso esteja visualizando um arquivo no vim e este arquivo tenha alguma linha de referência a outro arquivo
dentro do sistema, você pode abrir esta referência, parando sobre a linha do arquivo, digitando < esc > e
depois as teclas:
< ctrl > + < w > + < f > 
 
Exemplo:
Considere que está lendo um arquivo e encontra no meio dele a linha:
O arquivo /etc/passwd contém dados dos usuário. 
 
41
af://n856
af://n866
Use a tecla < esc > deixe o cursor sobre a referência /etc/passwd pressione as teclas: < ctrl > + < w > + < f > , o
VIM abrirá na parte superior este arquivo, para fechar, utilize:
< esc > 
:q 
 
Abrindo arquivo em uma linha específica 
Imagina a seguinte situação, você abre um arquivo de configuração como o do proxy squid3 que tem mais de
7.000 mil linhas e precisa encontrar um determinado comando. Para não ficar um bom tempo navegando
sobre o arquivo, utilize:
$ grep -n "palavra" arquivo 
 
Após a execução do comando acima, será exibido no terminal todas as linhas com o termo pesquisado:
$ grep -n "juliano" /etc/passwd 
27:juliano:x:1000:1000:Juliano Ramos,,,:/home/juliano:/bin/bash 
 
Agora que temos o número da linha, no caso do comando acima que executei, linha "27", podemos abrir este
arquivo, executando:
$ vim +27 /etc/passwd 
 
Deste modo, já abrimos o arquivo /etc/passwd com o vim direto na linha 27.
Alternando entre arquivos 
Imagine, que você está digitando um script de backup e não alguns parâmetros de configuração que estão
em outro arquivo. Para não precisar fechar o editor, execute o comando abaixo:
:e /caminho/arquivo 
 
Este comando vai permitir que você abra novos arquivos no VIM sem fechar o editor. Quando estamos
editando mais de um arquivo, usamos as teclas : <ctrl > + <6> para alternar entre eles.
Movimentando-se sobre o texto 
Estando no modo de visualização do editor "VIM". o melhor modo de se movimentar pelo texto é com as
teclas: h,j,k e l. Pode-se pensar que pelas teclas direcionais é mais fácil, elas funcionam de fato, mas depois
de um tempo usando as letras irá perceber que elas estão maispróximas de outras letras que são comandos.
Vejamos abaixo, as teclas e suas funções:
42
af://n874
af://n882
af://n886
< h > Esquerda 
< j > Baixo 
< k > Cima 
< l > Direita 
 
Agora, vamos aprender algumas outras opções, notando que são case sensitive (tem diferença maiúscula e
minúscula.)
< G > Vai para o final do arquivo 
< gg > Volta ao topo 
< e > Para mover ao final de uma palavra 
< ge > Para mover ao final de uma palavra voltando ao cursor 
< w > Para mover até o começo da próxima palavra 
< b > Para mover até o começo de uma palavra voltando ao cursor 
< f [caractere] > Para mover ao próximo caractere específico 
< 0 > Para mover ao começo da linha 
< $ > Para mover ao final de uma linha 
< } > Para pular ao final de um parágrafo 
< ctrl > + < G > Para saber sua posição no arquivo 
[numero da linha ] + < G > Para seguir para a linha especificada 
 
O vim mantem um histórico de alterações. Para movimentar-se entre as alterações, use:
< g > + < ; > Segue para a última alteração 
< g > + < , > Segue para a próxima da lista 
 
Inserindo texto 
Para sairmos do modo de visualização do VIM e começarmos a inserir nosso texto, usamos as seguintes
teclas:
< i > Entra no modo de inserção no local onde o cursor se 
encontra 
< I > Entra no modo de inserção no começo da linha 
< a > Entra no modo de inserção na frente de onde o cursor se 
encontra 
< A > Entra no modo de inserção no final da linha 
< o > Adiciona uma linha acima e entra em modo de inserção 
< ESC > Volta ao modo normal/comando 
< v > Entra no modo VISUAL 
 
Deletando texto 
Estando no modo de visualização, podemos usar as teclas:
43
af://n893
af://n896
< x > Deleta o caractere onde o cursor estiver 
< X > Deleta o caracter atrás do cursor 
< d > + < w > Deleta a partir do cursor até o começo da próxima 
palavra 
< d > + < $ > Deleta o cursor até o final da linha 
< d > + < d > Deleta a linha inteira 
< C > Deleta de onde o cursor estiver até o final da linha 
< c > + < e > Deleta do cursor até o final da palavra 
 
Copiar e colar 
< y > Copia a palavra 
< y > + < y > Copia a linha inteira 
< p > Cola 
 
O melhor modo de se copiar algo no VIM é navegando até a linha ou palavra que se deseja, entrando no
modo visual (tecla v) e selecionando a linha com as teclas de movimentação. Após selecionar, use a tecla < y >
para copiar, saia do modo de visualização < esc > movimente-se até o local de colar e pressione < p >.
Recortar e colar 
Para recortar e colar, use algum comando de exclusão (x, dd, dw ou d$), movimente-se até o local onde
deseja colar e use a tecla < p >.
O último texto/palavra que você deletou será inserido após o cursor.
Substituição 
Um recurso muito útil em qualquer editor de texto é a substituição de palavras. No VIM podemos usar, isto é
realizado no modo de comandos. Caso esteja no modo de visualização ou inserção, pressione a tecla < esc > e
depois < : > dois pontos, o comando abaixo fica a frente.
s/antiga/nova Substitui a ocorrência de antiga para nova na mesma 
linha 
% s/antiga/nova Sustitui em todo o arquivo 
% s/antiga/nova/gc Sustitui em todo o arquivo, mas solicita confirmação 
em cada 
 ocorrência. 
 
Buscando texto dentro do arquivo 
Para buscar texto dentro do vim, usamos no modo de comandos, sempre a frente do dois pontos (:) os
comandos abaixo:
/termo-a-ser-pesquisado Pesquisa para baixo do arquivo 
?/termo Pesquisa para cima do arquivo 
// Busca o último termo pesquisado 
 
44
af://n899
af://n902
af://n905
af://n908
Ao entrar no modo de busca, o VIM deixa a /palavra pesquisada na barra inferior, então, podemos usar:
< n > Para a próxima ocorrência 
< N > Para a ocorrência anterior 
 
 
Arquitetura do sistema - Tópico 101 
Na seção anterior, abordarmos os conteúdos mais básicos do linux. Nesta seção, abordaremos os
disposisitivos de hardware, boot do sistema e alteração do modo de inicialização do sistema.
Identificar e configurar os dispositivos de Hardware - tópico 101.1 
A LPI não pergunta só comandos e sim conteúdo relevante ao dia a dia de um administrador de sistemas.
Processo básico de boot:
EFI e UEFI hoje são um padrão de BIOS, no entanto, para fins da LPI saiba apenas que BIOS é o sistema básico
de entrada e saída.
IRQ - Sinais de interrupção 
45
af://n914
af://n916
af://n920
Em aulas de Hardware você já deve ter ouvido falar do IRQ, na prática, usamos pouco, mas na LPI ainda pode
acontecer alguma pergunta sobre. Não precisa decorar a lista, mas dê uma atenção aos IRQs principais. Para
visualizar o mapeamente do IRQ dentro do linux:
# cat /proc/interrupts 
Endereços de I/O - Entrada e saída 
Em um sistema operacional, temos uma lista de endereços na memória que é utilizada para a comunicação
entre a CPU e os demais dispositivos de Hardware. No linux, visualizamos:
# cat /proc/ioports 
Não se faz necessário decorar endereços desta lista.
Endereços DMA 
DMA é um modo de o dispositivo de hardware falar direto com a memória (Direct Memory Addressing). Não
são todos os dispositivos que possuem, para listar o DMA do linux, usamos:
# cat /proc/dma 
Barramentos 
Barramento é a interface de hardware que você conecta seus dispositivos na placa mãe.
46
af://n924
af://n928
af://n931
Os principais barramentos que são cobrados no exame: PCI e USB. Podemos visualizar o que está conectado
no barramento PCI, com o comando:
# lspci 
Para maiores detalhes utilize o código do dispositivo obtido com o comando acima e execute:
# lspci -s 00:01.1 -v 
Para barramento USB:
# lsusb 
Para detalhes:
# lsusb -s 001:001 -v 
Usamos o BUS e o DEVICE.
As partições virtuais 
As partições virtuais, são partições dinâmicas, elas não contém dados de arquivos e sim, informações que
acontecem em tempo real. São elas:
/proc 
/sys 
/dev 
/proc contém, informações dos processos ativos e recursos de hardware
/sys contém, informações sobre dispositivos de hardware (sysfs)
/dev Referências aos disposisitivos dos sistema, inclusive de armazenamento (udev)
47
af://n943
 
udev Device manager
dbus Comunicação entre processos, informa aos processos a situação dos dispositivos de hardware.
 
No linux, tudo é um arquivo ou um processo. Um dispositivo de armazenamento por exemplo, pode ser
/dev/sda1 que por sua vez é o caminho para o acesso físico. O udev é um processo de device manager, ou
seja, ele que monta e referencia os dispositivos em /dev.
O dbus/hald é responsável pela comunicação entre os processos do linux e entre outras funções, ele
informa, quando um novo hardware é adicionado ele é quem espalha esta informação aos processos.
Coldplug e Hotplug: Alguns dispositivos só podem ser trocados com a máquina desligada, exemplo:
Memória (apesar que alguns mainframes permite esta troca em hotplug), neste caso chamamos de coldplug.
Quando você adiciona um HD externo USB por exemplo, sem precisar desligar a máquina, chamamos de
hotplug.
Quando executamos o comando df -a visualizamos além das nossas partições, estas partições virtuais:
# df -a 
Arquivos importantes do /proc para o exame de certificação:
/proc/interrupts -- Informação de irq 
/proc/dma -- Informação de dma 
/proc/ioports -- Informação de entrada e saída 
/proc/meminfo -- Informação de memória 
/proc/cpuinfo -- Informação de CPU 
Dispositivos de armazenamento 
PATA - Também chamado IDE é uma tecnologia paralela (Parallel Advanced Technology Attachment). IDE é
referência à interface de conexão. Descrição deste sistema:
 
1. Sistema Master/slave, 2 discos por cabo.
2. /dev/hda ou sda master
3. /dev/hdb ou sdb slave
4. /dev/hdc ou sdcmaster
5. /dev/hdd ou sddslave
Um drive de CD / DVD, conectado a um IDE, também será referenciado comohdx. Após o PATA temos o SATA
- Serial Advanced Technology Attachment, sua descrição:
1. 1 disco por cabo.
2. Mais rápido que o pata.
3. Mapeados no linux como:
48
af://n960
1. /dev/sda --Primeiro disco
2. /dev/sda -- Segundo disco
 
Discos SCSI - Small Computer System Interface
tipos:
8 bits (permite 7 dispositivos + 1 controlador)
16 bits (permite 15 dispositivos + 1 controlador)
 
SCSI_ID
Canal - Identificados de cada adaptador
ID - Identificador de cada dispositivo
LUN - Número lógico da unidade
 
Mapeados no linux como:
/dev/sda -- Primeiro disco
/dev/sdb -- Segundo disco
/dev/sdc -- Terceiro disco
 
# /proc/scsi/scsi 
Mais utilizado é o padrão SATA.
Outros dispositivos:
/dev/fd0 -- Disquete / floppy disk
/dev/scd0 -- SCSI Cd-Rom
/dev/sr0 -- SCSI DVD
/dev/cdrom -- Normalmente criado como um link para o device do cdrom
/dev/dvd -- Normalente criado como um link para o device do dvd
 
Arquitetura do kernel Linux 
Ao instalar o Debian ou outra distribuição Linux, estamos utilizando o kernel que foi compilado pelos
desenvolvedores da distribuição. Este kernel padrão, deve ser capaz de rodar em praticamente qualquer PC e
dar suporte a diversos tipos de recursos que o usuário pretenda utilizar, como sistemas de arquivos,suporte
a usb, suporte a diferentes tipos de protocolos de rede entre outros. O desenvolvedor compila um kernel
49
af://n1014
básico, com poucas funcionalidades e cria pedaços de código com funções específicas que podem ser
adicionados a este kernel, estes pedaços de código são chamados de módulos.
Quando o sistema é carregado, este kernel básico é colocado na memória e passa a controlar a máquina.
Digamos que você possui uma partição com o sistema de arquivos NTFS que não está no kernel básico
padrão. Durante a inicialização do sistema, o kernel básico vai procurar se o módulo que dá suporte para este
tipo de sistema de arquivos está disponível. Se este módulo for encontrado, ele será carregado expandido
assim as funcionalidades do kernel.
Trabalhando com módulos 
O desenvolvimento de uma nova funcionalidade para o kernel linux pode ser implementada diretamente no
kernel ou compilada como um módulo. De modo geral, a escolha tende a ser a compilação como módulo.
Isso significa que o Kernel só vai ativar o módulo caso seja necessário, esta opção otimiza o sistema tornando
o kernel do linux muito dinâmico.
Exemplo prático:
Digamos que você esteja usando uma impressora USB, neste momento o módulo para ela funcionar está
ativo no sistema. Depois de um tempo, você para de usar esta impressora por qualquer motivo, neste caso o
módulo de suporte a impressora não é mais necessário e você pode desabilitá-lo.
Ao executar o comando lsmod você pode visualizar quais módulos estão carregados atualmente na
memória:
# lsmod 
Module Size Used by 
fuse 98304 3 
pci_stub 16384 1 
vboxpci 24576 0 
vboxnetadp 28672 0 
vboxnetflt 28672 0 
vboxdrv 454656 3 vboxnetadp,vboxnetflt,vboxpci 
xfrm_user 36864 2 
xfrm4_tunnel 16384 0 
tunnel4 16384 1 xfrm4_tunnel 
ipcomp 16384 0 
xfrm_ipcomp 16384 1 ipcomp 
esp4 20480 0 
ah4 20480 0 
af_key 36864 0 
xfrm_algo 16384 5 xfrm_user,esp4,ah4,af_key,xfrm_ipcomp 
snd_usb_audio 180224 2 
uvcvideo 90112 0 
snd_usbmidi_lib 28672 1 snd_usb_audio 
snd_rawmidi 32768 1 snd_usbmidi_lib 
videobuf2_vmalloc 16384 1 uvcvideo 
videobuf2_memops 16384 1 videobuf2_vmalloc 
videobuf2_v4l2 24576 1 uvcvideo 
videobuf2_core 40960 2 uvcvideo,videobuf2_v4l2 
wl 6365184 0 
videodev 176128 3 uvcvideo,videobuf2_core,videobuf2_v4l2 
media 40960 2 uvcvideo,videodev 
50
af://n1017
snd_seq_device 16384 1 snd_rawmidi 
arc4 16384 2 
Cortei a saída acima, por que o meu kernel tem muitos módulos ativos. Estes módulos ativos são diferentes
de máquina para máquina, por causa que possuimos hardware e configurações diferentes. Durante a
instalação do Debian, o sistema verifica seu equipamento e define quais módulos vão estar ou não ativos no
seu sistema.
Os módulos possuem dependências, você pode saber a quantidade de dependências por módulos na coluna
used na saída do comando lsmod a coluna size mostra o tamanho do módulo em bytes. Um módulo só pode
ser removido se o número de dependências for zero.
Os módulos são carregados através do comando insmod. Se o módulo B depende do A, este deve ser
carregado antes. Digamos que na coluna used do módulo A agora esteja mostrando 1, referente ao módulo B
que você carregou. Não será possível remover o módulo A, neste caso, você deve remover sua dependência B
primeiro e só depois removê-lo.
A seguir vamos observar quais são os procedimentos para carregar o módulo vfat que dá suporte ao sistema
de arquivos FAT32, muito comum em pendrivers formatados no Microsoft Windows e depois veremos como é
o procedimento para sua remoção.
O primeiro passo é verificar se o módulo em questão, já não está ativo no sistema, para isto executamos:
# lsmod | grep vfat 
Caso não obtenha nenhum retorno, significa, que o seu módulo não está ativo. Se tiver um retorno como:
vfat 20480 0 
fat 69632 1 vfat 
Significa que o seu módulo está ativo e funcionando. Para ativar um módulo, usamos a sintaxe:
# modprobe nome_do_modulo 
Neste caso:
# modprobe vfat 
Para remover o módulo:
# rmmod vfat 
Para saber informações sobre um módulo e ver suas dependências, utilize o comando modinfo, exemplo:
51
# modinfo vfat 
filename: /lib/modules/4.9.0-deepin9-amd64/kernel/fs/fat/vfat.ko 
author: Gordon Chaffee 
description: VFAT filesystem support 
license: GPL 
alias: fs-vfat 
depends: fat 
intree: Y 
vermagic: 4.9.0-deepin9-amd64 SMP preempt mod_unload modversions 
Observe na saída acima, que a dependência para o vfat chama-se fat. Ao ativar o vfat vamos obter
novamente informação sobre ele:
# lsmod | grep vfat 
vfat 20480 0 
fat 69632 1 vfat 
Observe que fat tem na saída da coluna used o número 1. Tentaremos remover ele:
# rmmod fat 
rmmod: ERROR: Module fat is in use by: vfat 
Veja que foi impossível remover, já que ele está sendo usado por vfat. Então vamos remover o vfat primeiro:
# rmmod vfat 
O modo vfat foi removido com sucesso, mas ainda temos a dependência fat que precisa ser removida:
# rmmod fat 
Para remover de modo automático um módulo e suas dependência, podemos usar o comando modprobe -r
exemplo:
# modprobe -r vfat 
O bom neste caso é que além de remover o vfat ele também remove o fat sua dependência.
Quais módulos estão disponíveis? 
Para saber quais módulos estão disponíveis no seu sistema, acesse o diretório: /lib/modules/versao-do-
kernel/kernel no meu caso:
# cd /lib/modules/4.9.0-debian-amd64/kernel/ 
O meu kernel chama-se (4.9.0-debian-amd64) o seu provavelmente terá um nome diferente, já que este
Kernel que estou utilizando não é o padrão do Debian. Dentro deste diretório, você vai encontrar alguns
subdiretórios como:
52
af://n1050
arch crypto drivers fs lib mm net security sound virt 
Dentro de cada um deles você encontra os módulos. Observe o diretório fs - file system ele é o diretório que
contém módulos sobre sistema de arquivos, dentro deste diretório,você pode visualizar todos os diretórios
dos módulos disponíveis de fs:
# cd /lib/modules/4.9.0-debian-amd64/kernel/fs 
# ls 
9p befs ceph dlm ext4 fuse jbd2 minix 
nilfs2 overlayfs reiserfs udf 
adfs bfs cifs ecryptfs f2fs gfs2 jffs2 ncpfs nls 
pstore romfsufs 
affs binfmt_misc.ko coda efivarfs fat hfs jfs nfs ntfs 
qnx4 squashfs xfs 
afs btrfs configfs efs freevxfs hfsplus lockd nfs_common ocfs2 
qnx6 sysv 
autofs4 cachefiles crypto exofs fscache isofs mbcache.ko nfsd omfs 
quota ubifs 
No meu caso eu tenho diversos módulos de sistemas de arquivo, dentro do diretório do módulo de sua
escolha, você obtêm o nome do módulo, exemplo:
# cd /lib/modules/4.9.0-debian-amd64/kernel/fs/fat 
# ls 
# fat.ko msdos.ko vfat.ko 
Obseve que dentro do diretório /lib/modules/4.9.0-debian-amd64/kernel/fs/fat/ obtive o nome dos
módulos disponíveis vfat, msdos, fat.
Compilando um kernel 
As vezes algumas funcionalidades que necessitamos só estão disponíveis em uma versão mais nova do
kernel, por exemplo:
Recentemente eu comprei um controle de xbox para jogar alguns games no linux. Mas descobri através de
busca na internet, que o módulo para ativar este joystick só estava disponível na versão mais nova do kernel,
para isto, fui obrigado a compilar um kernel novo e não mais utilizar o padrão, oferecido pela distribuição. O
processo a seguir de compilação, serve para qualquer versão de kernel que desejar instalar.
O primeiro passo que realizei para compilar meu kernel novo, foi instalar as aplicações necessárias para o
processo de compilação:
# apt-get install build-essential libncurses5-dev 
O segundo passo foi fazer download do kernel no site oficial:
http://www.kernel.org
A versão escolhida foi a última estável no momento da edição do livro: 4.12, segue o link:
https://cdn.kernel.org/pub/linux/kernel/v4.x/linux-4.12.7.tar.xz
53
af://n1060
http://www.kernel.org/
https://cdn.kernel.org/pub/linux/kernel/v4.x/linux-4.12.7.tar.xz
O terceiro passo é descompactar o Kernel que realizei download dentro do diretório /usr/src:
# tar -xvf linux-4.12.7.tar.xz -C /usr/src 
Após descompactar o quarto passo foi acessar o diretório e criar um link (atalho) para o diretório
descompactado linux-4.12.7:
# cd /usr/src 
# ln -s linux-4.12.7 linux 
Observe acima que criei um atalho chamado linux que aponta para linux-4.12.7, agora vamos acessar o
diretório linux e executar o comando para acessar o menu de configuração do kernel menuconfig:
# cd linux 
# make menuconfig 
Nesta janela de opções, você pode ativar novas funcionalidades para o kernel, por padrão, vamos apenas
salvar (save). Isto vai gerar um arquivo .config necessário para o resto do processo. Nesta quinta etapa,
devemos gerar a imagem do kernel propriamente dita, com o comando:
# make bzImage 
Este processo demora um bom tempo, tenha paciência. No meu caso demorou umas três horas. O sexto
passo foi compilar os módulos, com o comando:
# make modules 
Esta também é uma longa etapa, deu tempo de ver uns três episódios de "The Big Bang Theory". Agora o
sétimo passo é instalar os módulos no kernel novo:
# make modules_install 
Em seguida, vamos instalar o kernel:
# make install 
Como oitavo passo, vamos acessar o diretório /boot e gerar a imagem inicial do kernel intrd (de initial ram
disk).
# mkinitramfs -o initrd.img-4.12.7 4.12.7 
E para finalizar, execute o comando:
# update-grub 
Este comando irá criar a opção de inicialização do seu novo kernel.
54
af://n1088
Tópico 101.2 - O Boot do sistema 
Basicamente o processo de boot do linux acontece na seguinte ordem:
BIOS --> MBR --> Bootloader (GRUB/lilo) --> Kernel --> Init
O boot loader que é o aplicativo de gestão de arranque de boot do linux, fica na MBR que o primeiro setor de
um disco:
O gerenciador de boot tem a função de carregar o sistema operacional na memória. Atualmente, o boot
loader padrão é o GRUB2 (Grand Unified Bootloader). O initrd/initramfs é um filesystem temporário que
carrega informações essenciais na memória RAM, como módulos para alguns dispositivos.
 
O INIT é o processo de ID 1 sendo o pai de todos os outros processos. Principais INITs utilizados:
SystemV (SYSV) - init original
systemd
upstart
 
Uma forma de você visualizar o log de boot é usando o comando dmesg:
# dmesg 
 
Alterando os Runlevels, Shutdown e Reboot -
Tópico 101.3
 
55
af://n1088
af://n1107
A LPI menciona que devemos conhecer o SystemV e o Systemd. O SystemV trabalha com o conceito de
Runlevel que são níveis de execução do sistema. Cada Runlevel inicia o linux de uma maneira, vejamos uma
tabela sobre cada um deles:
 
No systemV temos um arquivo chamado /etc/inittab que é usado para se configurar o Runlevel padrão
(default), exemplo deste arquivo (com comentários):
#--------------------------------------------------------------------------------------------
-------------------# 
# Entendimento dos níveis de execução no arquivo /etc/inittab # 
#--------------------------------------------------------------------------------------------
-------------------# 
#<identificação> : <Nível de EXecução> : <Ação> : <Processo> # 
#--------------------------------------------------------------------------------------------
-------------------# 
# Identificação: É a identifcação do nível de execução # 
# Nível de Execução: Os níveis válidos de 0 á 6 # 
# Ação: É ação que será feita caso o nível seja ligado (executado) # 
# Processo: Processo gerado pela execução do nível de execução # 
#--------------------------------------------------------------------------------------------
-------------------# 
 
#--------------------------------------------------------------------------------------------
-------------------# 
# Descrição do que cada nível de execução faz quando executado e de como colocar 
# 
# scripts e serviços na inicialização do sistema. OBS: a descrição dos runlevels foi 
customizao # 
#--------------------------------------------------------------------------------------------
-------------------# 
# Os serviços ou scripts de inicialização devem ser colocados no diretório /etc/init.d 
# 
# para ser incluso em algum nível de execução. # 
#--------------------------------------------------------------------------------------------
-------------------# 
# <Níveis de execução> <Diretório> <Descrição do que é feito quando executado> 
56
# 
#--------------------------------------------------------------------------------------------
-------------------# 
# 0 /etc/rc0.d/ modo de desligamento. para todos os serviços e desliga a máquina # 
#--------------------------------------------------------------------------------------------
-------------------# 
# Modo de manutenção (single user). usado em casos criticos. # 
# 1 /etc/rc1.d como por exemplo recuperar senha do root ou dá manutenção no sistema. 
# 
# Apenas o usuário root pode executar nesse nível # 
#--------------------------------------------------------------------------------------------
-------------------# 
# S /etc/rcS.d/ Carrega os serviços essenciais para o sistema, modo similiar ao "1". 
# 
#--------------------------------------------------------------------------------------------
-------------------# 
# Modo multiusuário, usado para rodar o sistema básico sem serviços rede, # 
# 2 /etc/rc2.d e roda em modo texto. uso para fazer update do sistema # 
# ou atualizações em massa. # 
#--------------------------------------------------------------------------------------------
-------------------# 
# 3 /etc/rc3.d/ Modo multiusuário, roda em modo texto com serviços de rede 
disponiveis. # 
# como samba, ssh e etc. # 
#--------------------------------------------------------------------------------------------