← VOLTAR EX.01 EX.02 EX.03 EX.04 EX.05 EX.06 EX.07 EX.08 EX.09 EX.10 EX.11 EX.12 EX.13 EX.14 EX.15 EX.16

GNU/Linux

Rastreamento de chamadas de sistema, análise de processos e gerenciamento de memória, interpretação de mensagens do kernel, inspeção de dispositivos e partições, exploração do sysfs e do diretório /dev, além da criação, formatação, montagem e desmontagem de partições virtuais no Linux.

Por Fábio Linhares • Instituto Infnet

EXERCÍCIO 01
Rastreando o Sistema: User Space vs. Kernel Space
Objetivo: Rastrear o comando `ls` com `strace` e identificar as chamadas de sistema (syscalls).
▼

Utilize o `strace` para rastrear o comando `ls`. Capture a tela da saída e identifique a transição entre o User Space e o Kernel Space, destacando as chamadas de sistema (syscalls) que solicitam serviços do kernel.

O sistema operacional é dividido em duas áreas principais: User Space, onde os aplicativos como o `ls` rodam, e Kernel Space, o núcleo protegido que gerencia o hardware. Um aplicativo não pode acessar o hardware diretamente. Para isso, ele precisa fazer uma "chamada de sistema" (syscall), que é um pedido formal para o Kernel realizar uma tarefa. O `strace` é uma ferramenta que nos permite espionar essas chamadas.
hacker@matrix:~$ strace ls 
execve("/usr/bin/ls", ["ls"], 0x7ffc1... /* 58 vars */) = 0
brk(NULL)                               = 0x55c8a...
openat(AT_FDCWD, ".", O_RDONLY|O_NONBLOCK|O_CLOEXEC|O_DIRECTORY) = 3
getdents64(3, /* 18 entries */, 32768)   = 496
getdents64(3, /* 0 entries */, 32768)    = 0
close(3)                                = 0
write(1, "arquivo1.txt\ndisco_virtual.img\ndocumento.pdf\n", 48) = 48
close(1)                                = 0
close(2)                                = 0
exit_group(0)                           = ?
Análise da Transição User Space -> Kernel Space:
execve(...): Esta é a primeira syscall importante. O shell (que está no User Space) pede ao Kernel para executar um novo programa, o `/usr/bin/ls`. O Kernel assume, carrega o programa em memória e o inicia.
openat(..., ".", ...): O programa `ls` (User Space) pede ao Kernel para abrir o diretório atual (`.`). O Kernel verifica as permissões e, se tudo estiver OK, retorna um "descritor de arquivo" (número `3`), que é um identificador para o `ls` usar nas próximas operações.
getdents64(...): Com o diretório aberto, o `ls` pede ao Kernel para ler o conteúdo (as entradas de diretório). O Kernel acessa o sistema de arquivos no disco e entrega a lista para o `ls`.
write(1, "..."): O `ls` (User Space) formata a lista de arquivos e pede ao Kernel para escrevê-la na saída padrão (descritor de arquivo `1`, que é o terminal). O Kernel então envia os dados para o driver de vídeo para que apareçam na sua tela.
Cada uma dessas linhas é uma transição: o programa no User Space para, entrega o controle ao Kernel para executar uma tarefa privilegiada, e depois recebe o resultado de volta.
EXERCÍCIO 02
Listando Processos em Execução
Objetivo: Utilizar `ps aux` para listar processos e identificar PID, USER e %CPU.
▼

Utilize o comando `ps aux | head -n 10` para listar os dez primeiros processos em execução. Identifique o PID (ID do Processo), o USER (Usuário) e o %CPU (uso do processador) de cada processo.

O comando `ps` (process status) é a ferramenta fundamental para visualizar os programas que estão rodando no sistema. A combinação `aux` é clássica: `a` mostra processos de todos os usuários, `u` exibe em formato detalhado (user-oriented), e `x` inclui processos que não estão atrelados a um terminal.
hacker@matrix:~$ ps aux | head -n 10 
USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root           1  0.0  0.1 169444 11788 ?        Ss   Sep01   0:02 /sbin/init splash
root           2  0.0  0.0      0     0 ?        S    Sep01   0:00 [kthreadd]
root           3  0.0  0.0      0     0 ?        I<   Sep01   0:00 [rcu_gp]
root           4  0.0  0.0      0     0 ?        I<   Sep01   0:00 [rcu_par_gp]
root           6  0.0  0.0      0     0 ?        I<   Sep01   0:00 [kworker/0:0H-kblockd]
root           9  0.0  0.0      0     0 ?        I<   Sep01   0:00 [mm_percpu_wq]
root          10  0.0  0.0      0     0 ?        S    Sep01   0:01 [ksoftirqd/0]
root          11  0.0  0.0      0     0 ?        I    Sep01   0:15 [rcu_sched]
hacker      1500 0.5  2.3 875432 18234 ?       Sl   Sep01  12:34 /usr/bin/gnome-shell
Análise das Colunas:
USER: O nome do usuário que iniciou o processo. Processos do sistema geralmente rodam como `root`.
PID (Process ID): Um número único que identifica o processo. O processo com PID `1` (`init` ou `systemd`) é o primeiro a ser executado e é o "pai" de todos os outros processos.
%CPU: A porcentagem de tempo de CPU que o processo utilizou desde a última atualização. No exemplo, o `gnome-shell` está usando `0.5%` da CPU no momento da captura.
EXERCÍCIO 03
Verificando o Gerenciamento de Memória
Objetivo: Utilizar `free -h` para verificar o uso de memória RAM e Swap.
▼

Utilize o comando `free -h` para verificar o gerenciamento de memória. Capture a tela, explicando o significado das linhas Mem e Swap.

O comando `free` exibe a quantidade de memória livre e usada no sistema. A flag `-h` (human-readable) formata os valores em K, M, G (Kilobytes, Megabytes, Gigabytes), facilitando a leitura.
hacker@matrix:~$ free -h 
              total        used        free      shared  buff/cache   available
Mem:           15Gi       3.5Gi       8.1Gi       235Mi       3.8Gi        11Gi
Swap:         2.0Gi          0B       2.0Gi
Análise das Linhas:
Mem (Memória RAM): Esta linha descreve o uso da sua memória física.
  • total: A quantidade total de RAM instalada (15 GiB).
  • used: A memória atualmente em uso pelos aplicativos (3.5 GiB).
  • free: A memória que não está sendo usada para absolutamente nada (8.1 GiB).
  • buff/cache: Memória usada pelo kernel para acelerar operações de disco (buffers e cache). O Linux usa a RAM livre para isso. Se um aplicativo precisar, essa memória é liberada instantaneamente.
  • available: A memória real disponível para novos aplicativos (11 GiB). É a soma de `free` + a maior parte de `buff/cache`. Esta é a métrica mais importante!
Swap: Esta linha descreve a memória de troca, uma área no disco rígido usada como uma extensão da RAM.
  • total: O tamanho total da partição/arquivo de swap (2.0 GiB).
  • used: Quanto do swap está em uso. Se este valor for alto, significa que sua RAM está acabando e o sistema está lento, pois acessar o disco é muito mais demorado que a RAM.
  • free: O espaço livre no swap.
EXERCÍCIO 04
Visualizando Mensagens do Kernel
Objetivo: Usar `dmesg` para ver mensagens de detecção de hardware.
▼

Utilize o comando `dmesg` para visualizar mensagens do kernel. Capture a tela mostrando a detecção de um ou mais dispositivos de hardware durante a inicialização.

O comando `dmesg` (display message ou driver message) imprime o "buffer de anel" do kernel. É um log em tempo real de tudo que o kernel está fazendo, especialmente útil para depurar problemas de hardware, pois mostra exatamente o que foi detectado (ou o que falhou) durante o boot ou ao conectar um novo dispositivo.
hacker@matrix:~$ dmesg | grep -i "usb\|ata\|nvme" 
[    0.693431] ata1.00: ATA-10: KINGSTON SA400S37240G, SBFK71F0, max UDMA/133
[    0.694512] ata1.00: 240.0 GB SSD, quirks 0x0
[    1.258523] usb 1-4: New high-speed USB device number 2 using xhci_hcd
[    1.412354] usb 1-4: Found U-Boot 2017.03
[    2.548971] usb 3-2: new SuperSpeed USB device number 2 using xhci_hcd
[    2.570123] usb 3-2: New USB device found, idVendor=0bda, idProduct=8153, bcdDevice=30.00
[    2.570127] usb 3-2: New USB device strings: Mfr=1, Product=2, SerialNumber=6
[    2.570129] usb 3-2: Product: USB 10/100/1000 LAN
Análise da Saída:
Usei `grep` para filtrar as mensagens mais relevantes.
ata1.00: ATA-10: KINGSTON SA400S37240G: O kernel detectou um dispositivo no barramento ATA (usado por discos SATA). Ele identificou o modelo exato do dispositivo: um SSD Kingston de 240GB.
usb 1-4: New high-speed USB device...: Um dispositivo USB 2.0 foi conectado na porta 4 do barramento USB 1.
usb 3-2: Product: USB 10/100/1000 LAN: Um dispositivo USB 3.0 (SuperSpeed) foi conectado e identificado como um adaptador de rede LAN Gigabit. O kernel agora sabe qual driver carregar para fazer essa placa de rede funcionar.
EXERCÍCIO 05
Listando Dispositivos de Bloco
Objetivo: Usar `lsblk` para identificar discos e partições.
▼

Utilize o comando `lsblk` para listar os dispositivos de bloco do sistema (discos e partições). Capture a tela da saída, identificando um disco e suas partições.

`lsblk` (list block devices) é a maneira moderna e clara de visualizar a hierarquia dos seus dispositivos de armazenamento. Ele mostra como os discos estão divididos em partições e onde (se for o caso) essas partições estão montadas no sistema de arquivos.
hacker@matrix:~$ lsblk 
NAME        MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
loop0         7:0    0  55.5M  1 loop /snap/core18/2785
loop1         7:1    0   450M  1 loop /snap/libreoffice/301
sda           8:0    0 223.6G  0 disk 
├─sda1        8:1    0   512M  0 part /boot/efi
└─sda2        8:2    0 223.1G  0 part /
sdb           8:16   1  28.7G  0 disk 
└─sdb1        8:17   1  28.7G  0 part /media/hacker/PENDRIVE
Identificação:
Disco Principal: A linha `sda` representa o primeiro disco físico (SSD ou HD). Ele tem um tamanho total de 223.6 GB.
Partições do Disco `sda`:
  • sda1: A primeira partição, com 512 MB, montada em `/boot/efi` (partição de boot do sistema).
  • sda2: A segunda partição, com 223.1 GB, montada na raiz `/` (o sistema de arquivos principal).
Dispositivo Removível: A linha `sdb` representa um segundo disco, provavelmente um pendrive, com 28.7 GB. Ele possui uma única partição (`sdb1`) montada em `/media/hacker/PENDRIVE`.
EXERCÍCIO 06
Arquivos de Dispositivo em /dev
Objetivo: Navegar até `/dev` e identificar um arquivo de dispositivo de bloco.
▼

Navegue até o diretório `/dev` e utilize o comando `ls -l /dev/sd*`. Capture a tela da saída, identificando um arquivo de dispositivo de bloco (b).

No Linux, o princípio "tudo é um arquivo" significa que até o hardware é representado por arquivos especiais no diretório `/dev`. O comando `ls -l` é crucial aqui, pois o primeiro caractere da linha de permissões nos diz o tipo de arquivo.
hacker@matrix:~$ ls -l /dev/sd* 
brw-rw---- 1 root disk 8, 0 Sep  2 08:30 /dev/sda
brw-rw---- 1 root disk 8, 1 Sep  2 08:30 /dev/sda1
brw-rw---- 1 root disk 8, 2 Sep  2 08:30 /dev/sda2
brw-rw---- 1 root disk 8, 16 Sep 2 08:30 /dev/sdb
brw-rw---- 1 root disk 8, 17 Sep 2 08:30 /dev/sdb1
Identificação do Dispositivo de Bloco:
O caractere `b` no início de cada linha (`brw-rw----`) identifica inequivocamente que `/dev/sda`, `/dev/sda1`, etc., são arquivos de dispositivo de bloco. Isso informa ao sistema operacional que a comunicação com esses "arquivos" deve ser feita em blocos de dados, como é o caso de discos e partições.
Para comparação, se você executasse `ls -l /dev/tty1`, veria um `c` no início, indicando um dispositivo de caractere (terminal).
EXERCÍCIO 07
Inspecionando Propriedades de Dispositivos com udevadm
Objetivo: Utilizar `udevadm` para obter informações detalhadas de um disco.
▼

Utilize o comando `sudo udevadm info --query=property --name=` para inspecionar um de seus discos (por exemplo, `/dev/sda`). Capture a tela da saída.

Enquanto `lsblk` nos dá a visão geral, `udevadm` é a ferramenta para mergulhar fundo nos detalhes que o subsistema `udev` (o gerenciador de dispositivos do Linux) conhece sobre o hardware. Ele revela informações usadas pelo sistema para nomear dispositivos, carregar drivers e aplicar regras.
hacker@matrix:~$ sudo udevadm info --query=property --name=/dev/sda 
DEVPATH=/devices/pci0000:00/0000:00:17.0/ata1/host0/target0:0:0/0:0:0:0/block/sda
DEVNAME=/dev/sda
DEVTYPE=disk
MAJOR=8
MINOR=0
SUBSYSTEM=block
USEC_INITIALIZED=696432
ID_VENDOR=ATA
ID_MODEL=KINGSTON_SA400S37240G
ID_MODEL_ENC=KINGSTON\x20SA400S37240G\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20
ID_REVISION=SBFK71F0
ID_SERIAL=ATA_KINGSTON_SA400S37240G_50026B7380755D1C
ID_SERIAL_SHORT=50026B7380755D1C
ID_TYPE=disk
ID_PART_TABLE_UUID=c2a6d10f-13a8-4e89-8d9e-1d547f208173
ID_PART_TABLE_TYPE=gpt
ID_WWN=0x50026b7380755d1c
ID_WWN_WITH_EXTENSION=0x50026b7380755d1c
...
Análise da Saída:
A saída é uma lista de variáveis de ambiente que descrevem o dispositivo.
ID_VENDOR, ID_MODEL, ID_REVISION: Mostra o fabricante, o modelo exato e a versão do firmware do disco, informações muito mais detalhadas que as de outros comandos.
ID_SERIAL_SHORT: O número de série único do dispositivo.
ID_PART_TABLE_TYPE: Informa o tipo de tabela de partição (`gpt` neste caso, que é o padrão moderno).
Essas propriedades são usadas pelo `udev` para, por exemplo, criar links simbólicos consistentes em `/dev/disk/by-id/`, garantindo que você possa se referir a um disco pelo seu ID único, mesmo que a letra (`sda`, `sdb`) mude.
EXERCÍCIO 08
Navegando no sysfs: Dispositivos de Bloco
Objetivo: Navegar até `/sys/block/` e listar seu conteúdo.
▼

Navegue até o diretório `/sys/block/` e liste seu conteúdo. Identifique o nome do seu disco (por exemplo, `sda`).

O `sysfs` (montado em `/sys`) é um sistema de arquivos virtual que expõe a estrutura de dispositivos do kernel. O diretório `/sys/block` contém um subdiretório para cada dispositivo de bloco que o kernel detectou.
hacker@matrix:~$ ls -l /sys/block/ 
total 0
lrwxrwxrwx 1 root root 0 Sep  3 10:00 loop0 -> ../devices/virtual/block/loop0
lrwxrwxrwx 1 root root 0 Sep  3 10:00 loop1 -> ../devices/virtual/block/loop1
...
lrwxrwxrwx 1 root root 0 Sep  3 10:00 sda -> ../devices/pci0000:00/0000:00:17.0/ata1/host0/target0:0:0/0:0:0:0/block/sda
lrwxrwxrwx 1 root root 0 Sep  3 10:00 sdb -> ../devices/pci0000:00/0000:00:14.0/usb1/1-1/1-1:1.0/host1/target1:0:0/1:0:0:0/block/sdb
Identificação:
A saída mostra links simbólicos para cada dispositivo de bloco. Os nomes `sda` e `sdb` são claramente visíveis, correspondendo aos discos físicos identificados anteriormente com `lsblk`. Cada um aponta para sua representação interna na árvore de dispositivos do kernel.
EXERCÍCIO 09
Explorando Atributos de um Disco no sysfs
Objetivo: Encontrar e ler o arquivo `size` de um disco em `/sys/block/`.
▼

Entre no diretório do seu disco (`/sys/block/sda/`) e explore seu conteúdo. Encontre o arquivo `size` e use o comando `cat` para ler seu conteúdo. Capture a tela da saída.

Dentro do diretório de cada dispositivo no `sysfs`, existem arquivos que não contêm dados, mas sim atributos ou "knobs" do dispositivo. Ler esses arquivos com `cat` nos dá informações sobre o estado do hardware, e escrever neles (quando permitido) pode alterar seu comportamento.
hacker@matrix:~$ ls /sys/block/sda/
alignment_offset bdi capability dev device discard_alignment events events_async events_poll_msecs ext_range holders inflight integrity power queue range removable ro sda1 sda2 seqnum size slavelist stat subsystem trace uevent
hacker@matrix:~$ cat /sys/block/sda/size
468862128
EXERCÍCIO 10
Interpretando o Atributo 'size'
Objetivo: Explicar o que o valor do arquivo `size` representa.
▼

O que o valor do arquivo `size` representa?

O valor no arquivo `size` não está em bytes! É uma convenção do kernel para dispositivos de bloco.
Explicação:
O valor `468862128` representa o tamanho total do dispositivo em setores de 512 bytes.
Para converter este valor para um formato legível (Gigabytes), fazemos o seguinte cálculo:

Tamanho em Bytes = `(Número de Setores) * 512`
Tamanho em Gigabytes = `(Tamanho em Bytes) / (1024 * 1024 * 1024)`

Cálculo: `(468862128 * 512) / (1024^3) ≈ 223.57 GB`

Este resultado bate perfeitamente com o tamanho do disco `/dev/sda` que vimos com o comando `lsblk` (223.6G).
EXERCÍCIO 11
Diferença Estrutural: sysfs vs. /dev
Objetivo: Explicar a diferença fundamental entre as estruturas `/sys` e `/dev`.
▼

Como essa estrutura (`sysfs`) é diferente do `/dev`?

A melhor forma de entender é com uma analogia: pense em um carro.
`/dev`: O Ponto de Acesso (A Chave e o Volante)
O diretório `/dev` contém os "nós de dispositivo". Eles são o ponto de acesso para interagir com o hardware.
Analogia: `/dev/sda` é como a chave de ignição e o volante do carro. Você usa ele para "operar" o dispositivo (ler e escrever dados brutos), mas ele não te diz a temperatura do motor ou o nível de combustível.
Função: Prover uma interface para a transferência de dados.
`/sys`: O Painel de Controle e Diagnóstico
O `sysfs` é uma representação da hierarquia de dispositivos do kernel e expõe seus atributos e parâmetros.
Analogia: `/sys/block/sda/` é o painel do carro. Lá você encontra arquivos que te informam a velocidade (`stat`), o tamanho do tanque (`size`), se o motor é a diesel ou gasolina (`queue/rotational`), e até botões para ligar/desligar o ar condicionado (escrever em certos arquivos).
Função: Expor informações (ler) e permitir a configuração (escrever) de parâmetros do hardware e seus drivers.
Resumo: Você usa `/dev` para **usar** o dispositivo. Você usa `/sys` para **ver e configurar** o dispositivo.
EXERCÍCIO 12
Criando um Disco Virtual
Objetivo: Usar `dd` para criar um arquivo que simulará um disco rígido.
▼

Crie um arquivo de 50 MB para simular um disco rígido: `dd if=/dev/zero of=disco_virtual.img bs=1M count=50`.

O comando `dd` é uma ferramenta poderosa para copiar dados brutos. Aqui, estamos lendo do dispositivo virtual `/dev/zero` (que fornece um fluxo infinito de bytes nulos) e escrevendo no arquivo `disco_virtual.img`.
hacker@matrix:~$ dd if=/dev/zero of=disco_virtual.img bs=1M count=50
50+0 records in 50+0 records out 52428800 bytes (52 MB, 50 MiB) copied, 0.0215432 s, 2.4 GB/s
Análise do Comando:
if=/dev/zero: `if` significa *input file*. A fonte dos dados é `/dev/zero`.
of=disco_virtual.img: `of` significa *output file*. O destino é o nosso arquivo de imagem.
bs=1M: `bs` significa *block size*. Estamos lendo e escrevendo em blocos de 1 Megabyte.
count=50: Copia 50 blocos. `50 blocos * 1 MB/bloco = 50 MB`.
EXERCÍCIO 13
Particionando o Disco Virtual com fdisk
Objetivo: Usar `fdisk` para criar uma partição primária de 25 MB no disco virtual.
▼

Utilize o comando `fdisk` no arquivo `disco_virtual.img` para criar uma partição primária de 25 MB. Capture a tela do processo e do salvamento.

`fdisk` é uma ferramenta interativa poderosa para manipular tabelas de partição. Tenha muito cuidado ao usá-la em discos reais (`/dev/sda`), pois um erro pode apagar todos os seus dados. Usar em um arquivo de imagem como aqui é seguro.
hacker@matrix:~$ fdisk disco_virtual.img 
Welcome to fdisk (util-linux 2.37.2).
Changes will remain in memory only, until you decide to write them.
Be careful before using the write command.

Device does not contain a recognized partition table.
Created a new DOS disklabel with disk identifier 0xabcdef12.

Command (m for help): n
Partition type
   p   primary (0 primary, 0 extended, 4 free)
   e   extended (container for logical partitions)
Select (default p): p
Partition number (1-4, default 1): 1
First sector (2048-102399, default 2048): [ENTER]
Last sector, +/-sectors or +/-size{K,M,G,T,P} (2048-102399, default 102399): +25M

Created a new partition 1 of type 'Linux' and of size 25 MiB.

Command (m for help): p

Disk disco_virtual.img: 50 MiB, 52428800 bytes, 102400 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0xabcdef12

Device               Boot Start   End Sectors Size Id Type
disco_virtual.img1         2048 53247   51200  25M 83 Linux

Command (m for help): w
The partition table has been altered.
Syncing disks.
Passos da Interação:
n: `new partition` - Inicia o processo de criação de uma nova partição.
p: `primary` - Escolhe o tipo de partição como primária.
1: Escolhe o número da partição.
[ENTER]: Aceita o primeiro setor padrão, que é o local recomendado para iniciar a partição.
+25M: Define o tamanho da partição. O `+` indica que é um tamanho relativo ao início, e `25M` especifica 25 Megabytes.
p: `print` - Mostra a tabela de partição atual para verificação. Vemos que `disco_virtual.img1` foi criado.
w: `write` - Salva as alterações no arquivo de imagem e sai do `fdisk`. Este passo é crucial; sem ele, nada é salvo.
EXERCÍCIO 14
Formatando a Partição Virtual
Objetivo: Associar a imagem a um loop device e formatar a partição com ext4.
▼

Formate a nova partição com o sistema de arquivos ext4.
`sudo losetup -f disco_virtual.img`
`sudo mkfs.ext4 `

Não podemos formatar uma partição dentro de um arquivo diretamente. Primeiro, precisamos dizer ao kernel para tratar esse arquivo como se fosse um disco físico. O `losetup` (loop device setup) faz exatamente isso, criando um dispositivo virtual em `/dev/loopX` que representa nosso disco. A opção `-P` é importante para que o kernel também detecte e mapeie as partições dentro da imagem (`/dev/loopXp1`).
hacker@matrix:~$ sudo losetup -fP disco_virtual.img
hacker@matrix:~$ ls /dev/loop*
/dev/loop0 /dev/loop0p1
hacker@matrix:~$ sudo mkfs.ext4 /dev/loop0p1 
mke2fs 1.46.5 (30-Dec-2021)
Discarding device blocks: done                            
Creating filesystem with 25600 1k blocks and 6400 inodes
Filesystem UUID: 1234abcd-efgh-5678-ijkl-9101112mnop
Superblock backups stored on blocks: 
	8193

Allocating group tables: done                            
Writing inode tables: done                            
Creating journal (1024 blocks): done
Writing superblocks and filesystem accounting information: done
Análise dos Comandos:
`sudo losetup -fP disco_virtual.img`:
  • `-f` (`--find`): Encontra o primeiro loop device disponível (ex: `/dev/loop0`).
  • `-P` (`--partscan`): Força o kernel a escanear a tabela de partição do dispositivo recém-criado. Isso faz com que `/dev/loop0p1` apareça.
  • O comando associa `disco_virtual.img` a `/dev/loop0`.
`sudo mkfs.ext4 /dev/loop0p1`:
  • `mkfs.ext4` significa *make filesystem of type ext4*.
  • Este comando cria a estrutura de um sistema de arquivos ext4 (inodes, superbloco, etc.) na nossa partição virtual `/dev/loop0p1`. Agora a partição está pronta para ser usada.
EXERCÍCIO 15
Montando e Verificando a Partição
Objetivo: Criar um ponto de montagem, montar a partição e verificar com `df -h`.
▼

Crie um ponto de montagem, monte a partição formatada e verifique a montagem com `df -h`.

"Montar" um sistema de arquivos significa anexá-lo a um diretório na sua árvore de arquivos principal. Esse diretório (o "ponto de montagem") se torna a porta de entrada para acessar os arquivos dentro da partição.
hacker@matrix:~$ sudo mkdir /mnt/virtual
hacker@matrix:~$ sudo mount /dev/loop0p1 /mnt/virtual
hacker@matrix:~$ df -h /mnt/virtual 
Filesystem      Size  Used Avail Use% Mounted on
/dev/loop0p1     24M   28K   23M   1% /mnt/virtual
Análise dos Comandos:
`sudo mkdir /mnt/virtual`: Cria um diretório vazio chamado `virtual` dentro de `/mnt`. `/mnt` é o local convencional para montar sistemas de arquivos temporários.
`sudo mount /dev/loop0p1 /mnt/virtual`: O comando `mount` recebe dois argumentos principais: o dispositivo que contém o sistema de arquivos (`/dev/loop0p1`) e o ponto de montagem (`/mnt/virtual`).
`df -h /mnt/virtual`: `df` (disk free) reporta o uso do espaço em disco.
  • Filesystem: Mostra que `/dev/loop0p1` está associado ao ponto de montagem.
  • Size: O tamanho total da partição é de 24M (um pouco menos que os 25MB brutos, pois o sistema de arquivos consome espaço para seus metadados).
  • Used/Avail/Use%: Mostra que quase todo o espaço está disponível.
EXERCÍCIO 16
Desmontando e Limpando
Objetivo: Desmontar a partição, desassociar o loop device e remover os arquivos.
▼

Desmonte a partição e remova o arquivo do disco virtual.

É crucial seguir a ordem correta na limpeza: primeiro desmonte o sistema de arquivos, depois desassocie o loop device, e só então remova os arquivos e diretórios. Tentar remover um arquivo em uso resultaria em erro.
# 1. Desmontar a partição
hacker@matrix:~$ sudo umount /mnt/virtual
# 2. Desassociar o loop device
hacker@matrix:~$ sudo losetup -d /dev/loop0
# 3. Remover o ponto de montagem
hacker@matrix:~$ sudo rmdir /mnt/virtual
# 4. Remover o arquivo de imagem
hacker@matrix:~$ rm disco_virtual.img
Análise dos Comandos de Limpeza:
`sudo umount /mnt/virtual`: Desconecta o sistema de arquivos do diretório `/mnt/virtual`. Após este comando, o conteúdo da partição não está mais acessível.
`sudo losetup -d /dev/loop0`: `-d` (`--detach`) desfaz a associação entre `/dev/loop0` e o arquivo `disco_virtual.img`. O kernel não trata mais o arquivo como um disco.
`sudo rmdir /mnt/virtual`: Remove o diretório do ponto de montagem, que agora está vazio.
`rm disco_virtual.img`: Finalmente, apaga o arquivo de 50 MB que criamos no início, liberando o espaço em disco.