Prática de Sistemas Operacionais

# Informações da CPU (incluindo flags de virtualização)
grep -m 1 "flags" /proc/cpuinfo

# Informações completas da CPU
lscpu
          
# flags específicas de virtualização
lscpu | grep Flags

# Versão do kernel e arquitetura (com data de compilação)
uname -a

# Informações completas do sistema (hardware, kernel, SO)
hostnamectl

# Detalhes específicos da distribuição
cat /etc/os-release

📌 Inspeção completa de hardware com lshw

O comando lshw fornece uma visão detalhada de todos os componentes de hardware do sistema, incluindo CPU, memória, discos, rede e dispositivos conectados.

# Instalar (se necessário)
sudo apt install lshw

# Visão completa (pode ser longa)
sudo lshw

# Resumo mais simples
sudo lshw -short

# Filtrar apenas memória
sudo lshw -class memory

# Filtrar apenas rede
sudo lshw -class network

O lshw também pode mostrar informações como velocidade da RAM, modelo exato da placa-mãe e interfaces de rede — dados que nem sempre aparecem em outros comandos.

history
!10   # executa comando 10

# Visão geral amigável de memória (total, usada, swap)
free -h

# Estatísticas de memória virtual em tempo real (5 amostras)
# si = swap in, so = swap out - se altos, sistema está sofrendo
vmstat 1 5

# Dados brutos da memória (demonstra que "tudo é arquivo")
cat /proc/meminfo | head -20

          # Monitoramento interativo (tecla 1 = núcleos, M = ordenar por memória)
top

top -p [PID]          
        

# Lista completa com hierarquia em formato árvore (mostra pais/filhos)
ps auxf

# Visualizador interativo (aperte H para ver threads)
htop

# Tempo de atividade e carga média (1, 5 e 15 minutos)
uptime

# Explorando o /proc - metadados de um processo específico
# Substitua [PID] pelo número do processo (ex: PID do navegador)
cat /proc/[PID]/status | grep -E "Name|Pid|PPid|Threads|VmSize"

# Executar com baixa prioridade
nice -n 10 sleep 100

# Alterar prioridade de um processo
renice 5 -p [PID]

# Mensagens do buffer do kernel (detecção de hardware, erros de driver)
dmesg -T | tail -n 30

# Monitorar mensagens do kernel em tempo real
sudo dmesg -wT

# Logs do systemd com contexto (formato legível)
journalctl -xe | head -30

# Logs dos últimos boots
journalctl -b -1 | tail -30

# Topologia de discos e partições em árvore (visualização inicial)
lsblk

# Espaço usado em disco e pontos de montagem
df -h

# Consumo de inodes          
df -i

# Dispositivos PCI (placas de vídeo, rede, som, etc)
lspci | head -20

# Dispositivos USB conectados (mouse, pendrive, teclado)
lsusb

# Versão mais detalhada do lsblk
lsblk -f

# Tamanho de diretórios
du -h --max-depth=1

# Top diretórios mais pesados
du -h --max-depth=1 | sort -hr | head -10

# Ver processos criados
ps aux | grep hello

echo "print('Olá, Mundo do Python!')" > hello.py
python3 hello.py

cat <<EOF > hello.c
#include 
int main() {
    printf("Olá, Mundo do C!\n");
    return 0;
}
EOF

gcc hello.c -o hello
./hello

echo 'echo "Olá do Bash!"' > hello.sh
chmod +x hello.sh
./hello.sh

echo 'print "Olá do Perl!\n";' > hello.pl
perl hello.pl

# Instalar (se necessário)
sudo apt install strace

# Executar um programa simples com rastreamento
strace ls

# Executar seu programa Python com strace
strace python3 hello.py

# Filtrar apenas chamadas de arquivo
strace -e trace=open,read,write ls

# Salvar saída em arquivo (mais organizado)
strace -o log.txt ls

# Onde está o executável
which python3

# Tipo do comando (binário, alias, builtin)
type ls

# Listar todas as variáveis
printenv

# Ver valor de uma variável específica
echo $PATH

# Definir variável para a sessão atual
export MINHA_VAR="valor"

# Definir variável permanentemente (via .bashrc)
echo 'export MINHA_VAR="valor"' >> ~/.bashrc && source ~/.bashrc

# Executar comando com variável temporária única
VAR=teste python3 hello.py

time python3 hello.py

sudo apt install zenity

# Janela de informação simples
zenity --info --text="Olá, esta é uma janela gerada pelo Terminal!" --title="Aula de SO"

# Janela de entrada de texto com captura da resposta
NOME=$(zenity --entry --text="Digite seu nome:")
echo "O aluno digitou: $NOME"

# Interfaces e IPs
ip addr show

# Teste de conectividade e latência
ping -c 4 google.com
          
# Tabela de roteamento
ip route

# Conexões ativas + portas + processos
ss -tunlp

# Latência + rota combinada
mtr -c 5 google.com

# Portas em LISTEN
ss -tuln | grep LISTEN

# Fazer requisição web
curl https://example.com

# Ver apenas cabeçalhos
curl -I https://google.com

# Logs de autenticação (tente sudo errado em outro terminal)
sudo tail -f /var/log/auth.log    # ou sudo journalctl -f

# I/O de disco (Ctrl+C para sair)
iostat -xz 1 5

# Mensagens do kernel em tempo real
sudo dmesg -wT

# MONITORAMENTO COM WATCH - atualiza a cada 2 segundos
watch -n 2 'ps auxf | head -20'           # Processos (top 20)
watch -n 2 'ps auxf --sort=-%cpu | head -10'   # Processos ordenados por CPU (top 10)
watch -n 1 free -h                        # Memória em tempo real
watch -n 2 'df -h | grep -E "Filesystem|/$"' # Espaço em disco da partição raiz        

# Serviços com falha
systemctl --failed

# Serviços rodando (primeiros 15)
systemctl list-units --type=service --state=running | head -15

cat <<EOF > so_web.html
<!DOCTYPE html>
<html lang="pt-br">
<head>
  <meta charset="UTF-8">
  <title>DEE355 - Hello Web</title>
  <style>
    body {
      background: #0d1117;
      color: #58a6ff;
      font-family: sans-serif;
      display: flex;
      justify-content: center;
      align-items: center;
      height: 100vh;
      margin: 0;
      text-align: center;
    }
    .card {
      border: 3px solid #79c0ff;
      padding: 3rem;
      border-radius: 15px;
      background: #161b22;
      max-width: 600px;
    }
    button {
      background: #58a6ff;
      color: #0d1117;
      border: none;
      padding: 1rem 2rem;
      font-size: 1.5rem;
      border-radius: 8px;
      cursor: pointer;
      margin-top: 1.5rem;
    }
    button:hover { background: #79c0ff; }
  </style>
</head>
<body>
  <div class="card">
    <h1>Olá do Linux!</h1>
    <p>Gerado via Bash - DEE355</p>
    <button onclick="document.querySelector('h1').innerText = 'JS rodando!'; alert('Evento JS!')">
      Clique para testar
    </button>
  </div>
</body>
</html>
EOF

# Servidor local (acesse http://localhost:8000/so_web.html)
python3 -m http.server 8000

# Criar um processo em background (roda por 300 segundos)
sleep 300 &

# Listar jobs em background
jobs

# Ver PID do processo criado
ps aux | grep sleep

# Enviar sinal de término (SIGTERM)
kill [PID]

# Criar novamente o processo
sleep 300 &

# Forçar encerramento imediato (SIGKILL)
kill -9 [PID]

# Listar sinais disponíveis
kill -l

# Listar processos e threads
ps -eLf | head -20

# Visualizar threads de um processo específico
ps -T -p [PID]

# Monitor interativo mostrando threads
top -H

# No htop pressione:
# H  → mostrar threads
# F5 → visualização em árvore

cat < threads.py
import threading
import time

def tarefa(id):
    for i in range(3):
        print(f"Thread {id} executando...")
        time.sleep(1)

threads = []

for i in range(5):
    t = threading.Thread(target=tarefa, args=(i,))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print("Todas as threads terminaram.")
EOF

python3 threads.py

ps -eLf | grep python

free -h
vmstat 1 5
cat /proc/meminfo | grep -E "Mem|Swap|Cache"

# Descobrir apenas o UUID de uma partição específica
lsblk -dno UUID /dev/sda1

# Ver qual sistema de arquivos está montado em cada pasta
findmnt

# Identificar o sistema de arquivos de cada partição
lsblk -f

          #extrair UUID
          lsblk -dno UUID /dev/sda3
          
# Ver detalhes do sistema de arquivos
sudo blkid

📌 14.X Montagem automática com /etc/fstab

O arquivo /etc/fstab define quais sistemas de arquivos serão montados automaticamente durante a inicialização do sistema.

# Visualizar o fstab
cat /etc/fstab

# Testar montagens sem reiniciar
sudo mount -a

📄 Estrutura do fstab

UUID=xxxx-xxxx   /mnt/dados   ext4   defaults   0   2

• UUID — identificador único do disco
• Ponto de montagem — diretório onde será montado
• Sistema de arquivos — ext4, xfs, ntfs, etc
• Opções — permissões e comportamento
• dump — backup (geralmente 0)
• fsck — ordem de verificação no boot

📌 Exemplo prático

# Criar diretório de montagem
sudo mkdir /mnt/teste

# Identificar UUID do disco
sudo blkid

# Editar fstab
sudo nano /etc/fstab

UUID=abcd-1234   /mnt/teste   ext4   defaults   0   2

Após salvar, execute:

sudo mount -a

Se não houver erro, a configuração está correta.

# Instalar o mdadm (se necessário)
sudo apt install mdadm

# Verificar discos disponíveis
lsblk

# Criar um RAID 1 (espelhamento) com dois discos
sudo mdadm --create /dev/md0 --level=1 --raid-devices=2 /dev/sdb1 /dev/sdc1

# Verificar o status do array
cat /proc/mdstat

# Ver detalhes do array
sudo mdadm --detail /dev/md0

# Criar sistema de arquivos no array RAID
sudo mkfs.ext4 /dev/md0

# Montar o array
sudo mount /dev/md0 /mnt/raid

# Simular falha de um disco
sudo mdadm --manage /dev/md0 --fail /dev/sdb1

# Remover disco com falha
sudo mdadm --manage /dev/md0 --remove /dev/sdb1

# Adicionar um novo disco ao array
sudo mdadm --manage /dev/md0 --add /dev/sdd1

# Parar um array RAID
sudo mdadm --stop /dev/md0

# Montar array após reinicialização
sudo mdadm --assemble --scan

# Verificar status de todos os arrays
cat /proc/mdstat

# Ver detalhes completos de um array específico
sudo mdadm --detail /dev/md0

# Verificar discos com falhas ou problemas
sudo mdadm --detail /dev/md0 | grep -E "failed|spare"

# Verificar uso de disco e partições
lsblk -o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINT

# Verificar logs relacionados a RAID
sudo journalctl | grep mdadm

# Monitorar reconstrução em tempo real
watch -n 1 'cat /proc/mdstat'

# 1. Verifique se há arrays RAID configurados no sistema
cat /proc/mdstat

# 2. Liste todos os discos e partições
lsblk -o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINT

# 3. Se houver um array, veja seus detalhes
sudo mdadm --detail /dev/md0  # substitua md0 pelo nome do array

# 4. (Opcional - requer discos extras) Simule a criação de um RAID 1
# ATENÇÃO: Use discos de teste, não partições importantes!

# Listar arquivos com permissões
ls -l

# Exemplo de saída:
# -rw-r--r-- 1 aluno alunos 1024 Jan 15 10:30 arquivo.txt
# drwxr-x--- 2 aluno alunos 4096 Jan 15 10:30 pasta/

# Explicação do primeiro campo:
# [tipo][owner perms][group perms][others perms]
# - = arquivo comum | d = diretório | l = link simbólico
# rwx = leitura, escrita, execução
# r-x = leitura e execução (sem escrita)
# r-- = apenas leitura

# Ver permissões em formato octal (numérico)
stat -c "%a %n" arquivo.txt

# Ver apenas as permissões de um arquivo
ls -l arquivo.txt | awk '{print $1}'

# NOTAÇÃO SIMBÓLICA
# Dar permissão de execução para o dono
chmod u+x arquivo.sh

# Remover permissão de escrita do grupo
chmod g-w documento.txt

# Dar permissão total para dono, leitura/execução para grupo, nenhuma para outros
chmod u=rwx,g=rx,o=--- script.py

# Adicionar permissão de escrita para todos
chmod a+w arquivo.txt

# NOTAÇÃO OCTAL (NUMÉRICA)
# 4 = read, 2 = write, 1 = execute
# 7 = 4+2+1 (rwx), 6 = 4+2 (rw-), 5 = 4+1 (r-x), 4 = r--, 0 = ---

chmod 755 script.sh      # dono: rwx, grupo: r-x, outros: r-x
chmod 644 arquivo.txt    # dono: rw-, grupo: r--, outros: r--
chmod 600 senhas.txt     # dono: rw-, grupo: ---, outros: ---
chmod 700 pasta_privada  # apenas dono tem acesso total

# Modo recursivo (aplica a diretórios e subdiretórios)
chmod -R 755 pasta/

# Alterar o dono do arquivo
sudo chown maria arquivo.txt

# Alterar o grupo do arquivo
sudo chgrp desenvolvedores projeto/

# Alterar dono e grupo simultaneamente
sudo chown maria:desenvolvedores projeto/

# Alterar recursivamente
sudo chown -R maria:desenvolvedores pasta_projeto/

# Verificar alterações
ls -l pasta_projeto/

# Verificar bits especiais (letra minúscula = ativo, maiúscula = inativo)
ls -l /usr/bin/passwd
# -rwsr-xr-x 1 root root → 's' no lugar do 'x' indica SUID ativo

ls -ld /tmp
# drwxrwxrwt → 't' no lugar do 'x' indica Sticky Bit ativo

# Aplicar SUID em um script (apenas para binários, não scripts shell)
sudo chmod u+s /usr/local/bin/meu_programa

# Aplicar SGID em diretório
sudo chmod g+s /compartilhado

# Aplicar Sticky Bit
sudo chmod +t /compartilhado_temp

# Instalar suporte a ACL (se necessário)
sudo apt install acl

# Verificar ACLs atuais
getfacl arquivo.txt

# Definir ACL para um usuário específico
setfacl -m u:joao:rwx pasta/

# Definir ACL para um grupo específico
setfacl -m g:desenvolvedores:rx documento.txt

# Remover ACL de um usuário
setfacl -x u:joao pasta/

# Remover todas as ACLs
setfacl -b pasta/

# Copiar ACLs de um arquivo para outro
getfacl arquivo1.txt | setfacl --set-file=- arquivo2.txt

# Verificar se partição suporta ACL (opção acl no mount)
mount | grep acl

# Arquivos de autenticação
cat /etc/passwd      # Informações básicas dos usuários (UID, shell, home)
cat /etc/shadow      # Senhas criptografadas (apenas root pode ler)
cat /etc/group       # Grupos do sistema
cat /etc/sudoers     # Quem pode usar sudo (editar com visudo!)

# Gerenciar usuários
sudo useradd -m -s /bin/bash joao      # Criar usuário com home e shell
sudo passwd joao                        # Definir senha
sudo usermod -aG sudo joao              # Adicionar ao grupo sudo
sudo userdel -r joao                    # Remover usuário e seu home

# Gerenciar grupos
sudo groupadd desenvolvedores
sudo usermod -aG desenvolvedores maria
groups maria                             # Ver grupos do usuário
sudo groupdel desenvolvedores

# Informações do usuário atual
whoami                                   # Nome do usuário
id                                       # UID, GID e grupos
id joao                                  # Informações de outro usuário

# Verificar privilégios sudo do usuário atual
sudo -l

# Executar comando como root
sudo comando

# Executar comando como outro usuário
sudo -u maria comando

# Abrir shell como root (cuidado!)
sudo -i

# Editar o arquivo sudoers (NUNCA editar diretamente!)
sudo visudo

# Exemplo de linha no /etc/sudoers:
# joao ALL=(ALL:ALL) ALL                    # joao pode tudo com sudo
# maria ALL=(ALL) /usr/bin/apt, /usr/bin/systemctl  # apenas comandos específicos
# %desenvolvedores ALL=(ALL) NOPASSWD: ALL   # grupo sem pedir senha

# 1. Crie um arquivo e visualize suas permissões
touch teste.txt
ls -l teste.txt

# 2. Altere as permissões para que apenas o dono possa ler e escrever
chmod 600 teste.txt

# 3. Crie um diretório compartilhado com SGID
mkdir /tmp/compartilhado
sudo chown :desenvolvedores /tmp/compartilhado
sudo chmod 2770 /tmp/compartilhado
ls -ld /tmp/compartilhado

# 4. Adicione um usuário de teste
sudo useradd -m testuser
sudo passwd testuser

# 5. Verifique as informações do novo usuário
id testuser
ls -la /home/testuser

# 6. Configure uma ACL para permitir acesso a outro usuário
setfacl -m u:testuser:rx teste.txt
getfacl teste.txt

# 7. (Opcional) Remova o usuário de teste
sudo userdel -r testuser

# Ver de onde vêm os programas — lista de repositórios
cat /etc/apt/sources.list
ls /etc/apt/sources.list.d/

# Atualizar a lista de pacotes disponíveis (não instala nada)
sudo apt update

# Ver quantos pacotes estão disponíveis
apt list 2>/dev/null | wc -l

# Buscar um pacote pelo nome ou descrição
apt search htop
apt search "monitor de sistema"

# Ver detalhes de um pacote (versão, tamanho, dependências)
apt show htop
apt show firefox

# Instalar um pacote
sudo apt install htop

# Remover pacote (mantém arquivos de configuração)
sudo apt remove htop

# Remover pacote + configurações
sudo apt purge htop

# Atualizar todos os pacotes do sistema
sudo apt upgrade

# Remover pacotes órfãos (dependências que não são mais necessárias)
sudo apt autoremove

# Ver histórico de instalações
cat /var/log/apt/history.log | head -40

# Listar todos os pacotes instalados
dpkg -l | head -20

# Contar quantos pacotes estão instalados
dpkg -l | grep "^ii" | wc -l

# Ver arquivos instalados por um pacote específico
dpkg -L bash

# Descobrir a qual pacote um arquivo pertence
dpkg -S /usr/bin/python3
dpkg -S /bin/ls

# Ver informações de um pacote instalado
dpkg -s firefox

# Instalar um .deb baixado manualmente
# sudo dpkg -i nome_do_pacote.deb

# Ver pacotes com problemas
dpkg -l | grep -E "^(rc|iF|iU)"

# Instalar ferramentas de compilação (gcc, make, etc.)
sudo apt install build-essential

# Fluxo clássico de compilação a partir do fonte:

# 1. Baixar o código fonte (exemplo com o htop)
wget https://github.com/htop-dev/htop/releases/download/3.3.0/htop-3.3.0.tar.xz

# 2. Extrair o arquivo
tar -xf htop-3.3.0.tar.xz
cd htop-3.3.0/

# 3. Verificar dependências e configurar para o sistema atual
#    (gera o Makefile adaptado ao ambiente)
./configure

# 4. Compilar (usa todos os núcleos disponíveis com -j)
make -j$(nproc)

# 5. Instalar no sistema
sudo make install

# 6. Verificar onde foi instalado
which htop

# Alternativa moderna: cmake (usado por projetos mais novos)
# cmake -B build && cmake --build build && sudo cmake --install build

# FLATPAK
sudo apt install flatpak                        # instalar suporte
flatpak remote-add --if-not-exists flathub \
    https://dl.flathub.org/repo/flathub.flatpakrepo
flatpak install flathub org.videolan.VLC        # instalar app
flatpak list                                    # listar instalados
flatpak update                                  # atualizar tudo

# SNAP
snap list                                       # listar snaps instalados
sudo snap install vlc                           # instalar
sudo snap remove vlc                            # remover
snap info vlc                                   # detalhes do pacote

# APPIMAGE
wget https://exemplo.com/app.AppImage           # baixar
chmod +x app.AppImage                           # tornar executável
./app.AppImage                                  # executar diretamente

# Ver qual formato um programa foi instalado
which firefox
dpkg -S $(which firefox) 2>/dev/null || echo "Pode ser snap/flatpak"
snap list | grep firefox
flatpak list | grep firefox

# Listar todos os módulos carregados no kernel
lsmod

# Mostrar módulos com mais detalhes (tamanho, uso, dependências)
lsmod | head -20

#módulos de vídeo
lsmod | grep video

# Ver informações detalhadas de um módulo específico
modinfo snd_hda_intel    # exemplo: driver de áudio
modinfo vboxsf           # exemplo: VirtualBox Shared Folders

# Carregar um módulo manualmente
sudo modprobe usb_storage

# Remover um módulo (se não estiver em uso)
sudo modprobe -r usb_storage

# Inserir módulo diretamente (menos recomendado)
# sudo insmod /caminho/do/modulo.ko

# Ver quais módulos estão disponíveis no sistema
find /lib/modules/$(uname -r) -type f -name "*.ko" | wc -l

# Ver os parâmetros com que o kernel atual foi inicializado
cat /proc/cmdline

# Exemplo de saída típica:
# BOOT_IMAGE=/vmlinuz-6.5.0-35-generic root=/dev/sda3 ro quiet splash vt.handoff=7

# Versão completa do kernel em execução
uname -a

# Ver a versão do kernel e diretório de módulos
uname -r

# Listar todos os módulos disponíveis para esta versão do kernel
ls /lib/modules/$(uname -r)/

# Ver configurações com que o kernel foi compilado
cat /boot/config-$(uname -r) | grep -E "CONFIG_MODULE|CONFIG_DEBUG" | head -15