Skip to main content

101.1 Identificar e configurar Hardware



BIOS - Basic Input/Output System​

Quando ligamos o computador, antes do Sistema Operacional inicializar, entramos na fase do POST (Power-on Self-Test) onde os dispositivos físicos do computador devem ser testados e configurados para garantir que tudo esteja funcionando (memória, cpu, mouse, teclado, data/hora e outras configurações gerais), até meados dos anos 2000 isso era feito no que conhecemos como BIOS (Basic Input / Output System). A partir do final da primeira década dos anos 2000, as máquinas baseadas na arquitetura x86 começaram a substituir o BIOS por uma nova implementação chamada UEFI (Unified Extensible Firmware Interface), que possui recursos mais sofisticados para identificação, teste, configuração e atualizações de firmware, ambos cumprem o mesmo propósito básico.



IRQ - Interrupt Request​

É um sinal enviado do dispositivo conectado para a CPU, pedindo urgência na solicitação. Por exemplo, quando o modem precisa executar um processo, ele envia uma solicitação de interrupção para a CPU informando a CPU que o processo precisa continuar e então a CPU interrompe seu trabalho atual para permitir que o modem execute seu processo, é bem similar ao time slice, só que, ao invés de serem processos lógicos em boa parte do tempo, quem faz isso são dispositivos conectados ao computador.

Computadores compatíveis com IBM vão até o IRQ 15 e são priorizados no computador de acordo com a importância do dispositivo. Hoje, a maioria dos usuários não precisa se preocupar com as configurações de IRQ porque todos os dispositivos agora são plug and play, o que significa que são configurados automaticamente.


Tabela com alguns IRQs (principais para a prova):

Número de IRQPeriférico
1Teclado
3Porta serial 2 (RS-232)
4Porta serial 1 (RS-232)
14IDE Primária
15IDE Secundária

Nós podemos ver isso em /proc/interrupts, segue um exemplo:

$ cat /proc/interrupts 
    CPU0  CPU1  CPU2  CPU3  CPU4  CPU5       
0:  35    0     0     0     0     0     IR-IO-APIC    2-edge      timer
7:  0     0     0     0     0     0     IR-IO-APIC    7-fasteoi   pinctrl_amd
8:  1     0     0     0     0     0     IR-IO-APIC    8-edge      rtc0
9:  0     0     0     0     0     0     IR-IO-APIC    9-fasteoi   acpi
25: 0     0     0     0     0     0      PCI-MSI 4096-edge      AMD-Vi

# Aqui pode ver que o sinal 0 foi enviado para a 1° cpu 35 vezes,
# o sinal 8 foi enviado 1 vez.


Endereços de Entrada e Saída I/O​

As portas de entrada e saída são endereços de memória reservados no microprocessador para os dispositivos realizarem entrada e saída de informações.

Estes endereços de memória são utilizados para troca de dados entre o processador e os dispositivos de forma simplificada.

Os dispositivos podem usar mais de uma porta de entrada/saída ou uma faixa de endereços. Por exemplo, uma placa de som padrão usa as portas 0x220, 0x330 e 0x388.

Cada dispositivo possui um endereço de porta única que não podem ser compartilhados entre outros dispositivos.

Os endereços de E/S em uso no sistema podem ser visualizados com o comando:

# Rode com sudo para ter acesso aos endereços!
$ sudo cat /proc/ioports
0000-0cf7 : PCI Bus 0000:00
  0000-001f : dma1
  0020-0021 : pic1
  0040-0043 : timer0
  0050-0053 : timer1
  0060-0060 : keyboard
  0064-0064 : keyboard
  0070-0071 : rtc0
  0080-008f : dma page reg
  00a0-00a1 : pic2
  00c0-00df : dma2
  00f0-00ff : fpu
  0170-0177 : 0000:00:01.1
    0170-0177 : ata_piix
  01f0-01f7 : 0000:00:01.1
    01f0-01f7 : ata_piix
  0376-0376 : 0000:00:01.1
    0376-0376 : ata_piix
  03f6-03f6 : 0000:00:01.1
    03f6-03f6 : ata_piix
  03f8-03ff : serial
  0510-051b : QEMU0002:00
    0510-051b : fw_cfg_io
  0600-063f : 0000:00:01.3
    0600-0603 : ACPI PM1a_EVT_BLK
    0604-0605 : ACPI PM1a_CNT_BLK
    0608-060b : ACPI PM_TMR
  0700-070f : 0000:00:01.3
    0700-0708 : piix4_smbus
0cf8-0cff : PCI conf1
0d00-ffff : PCI Bus 0000:00
  afe0-afe3 : ACPI GPE0_BLK
  c000-c07f : 0000:00:03.0
  c080-c0bf : 0000:00:04.0
  c0c0-c0df : 0000:00:01.2
    c0c0-c0df : uhci_hcd
  c0e0-c0ff : 0000:00:05.0
  c100-c10f : 0000:00:01.1
    c100-c10f : ata_piix


Acesso Direto a Memória - Direct Memory Addressing (DMA)​

A DMA é usada para permitir a transferência de dados entre dispositivos e a memória sem a intervenção do processador. Este acesso é feito através de canais (channels). A maioria dos computadores tem dois controladores de DMA. O primeiro controla os canais 0, 1, 2, 3 e o segundo os canais 4, 5, 6, 7, totalizando 8 canais, dessa forma a transferencia de dados é bem maior.

Os canais de DMA em uso no sistema podem ser visualizados com o comando:

$ cat /proc/dma
 4: cascade

O DMA não é usado por todos os dispositivos.



Partições Virtuais​

Não possui dados de arquivos ou diretórios, e sim informações do sistema no momento atual de seu funcionamento. Toda vez que o sistema é ligado, essas partições são montadas, as partições são:

  • /proc Informações dos processos ativos e recursos de hardware;

  • /sys Informações sobre dispositivos de hardware (sysfs), para dispositivos de rede, as informações ficam em /sys/class/net/, para bluetooth ficam em /sys/class/bluetooth.

  • /dev Referências aos dispositivos do sistema, inclusive de armazenamento (udev). Ele controla os dispositivos que são inseridos no computador, atualizando as informações de /dev, tudo por meio do sistema reconhecido como udev. 

    ## Para reparar uma maquina, as vezes temos que montar esses sistemas
    ## quando a máquina não inicializa por sí só, ex: o sistema não inicia,
    ## podemos montar o hd do Linux, entrar com 'chroot' e então montar essas
    ## partições virtuais.

    # Para montar um /proc, usamos o comando abaixo:
    sudo mount -t proc none /proc

    # Para montar o /sys (sysfs), use o comando abaixo:
    sudo mount -t sysfs none /sys

    # Para montar o /dev (udev), use o comando abaixo:
    sudo mount -t devtmpfs -o bind /dev /dev

  • udev Device Manager, ele que monta os dispositivos e referência eles no /dev. Quando colocamos um dispositivo USB, HD, DVD entre outros, é o udev que faz o mapeamento.

  • dbus(atual)/hald(antigo) Rersponsável pela comunicação entre processos. Informa aos processos a situação dos dispositivos de hardware.



/proc​

Aqui vamos ver alguma informações que temos no /proc.

  • /proc/cmdline

    Aqui podemos ver o que o bootloader passou para o Kernel no momento da inicialização.

    $ cat /proc/cmdline 
    BOOT_IMAGE=/boot/vmlinuz-5.4.0-66-generic root=UUID=d702b8a5-6d9c-4313-96dd-1c59c8b1239b ro quiet splash

  • /proc/filesystems

    São os tipos de filesystems que podem ser usados no sistema.

    $ cat /proc/filesystems 
    nodev   sysfs
    nodev   tmpfs
    nodev   bdev
    nodev   proc
    nodev   cgroup
    nodev   cgroup2
    nodev   cpuset
    nodev   devtmpfs
    nodev   configfs
    nodev   debugfs
    nodev   tracefs
    nodev   securityfs
    nodev   sockfs
    nodev   bpf
    nodev   pipefs
    nodev   ramfs
    nodev   hugetlbfs
    nodev   devpts
            ext3
            ext2
            ext4
            squashfs
            vfat
    nodev   ecryptfs
            fuseblk
    nodev   fuse
    nodev   fusectl
    nodev   efivarfs
    nodev   mqueue
    nodev   resctrl
    nodev   pstore
            btrfs
    nodev   autofs
    nodev   rpc_pipefs
    nodev   nfsd
    nodev   binfmt_misc

  • /proc/mounts

    Mostra partições e filesystems que estão montadas.

    $ cat /proc/mounts 
    sysfs /sys sysfs rw,nosuid,nodev,noexec,relatime 0 0

    proc /proc proc rw,nosuid,nodev,noexec,relatime 0 0

    udev /dev devtmpfs rw,nosuid,noexec,relatime,size=8115784k,nr_inodes=2028946,mode=755 0 0

    devpts /dev/pts devpts rw,nosuid,noexec,relatime,gid=5,mode=620,ptmxmode=000 0 0

    tmpfs /run tmpfs rw,nosuid,nodev,noexec,relatime,size=1638980k,mode=755 0 0
    /dev/sdc4 / ext4 rw,relatime,errors=remount-ro 0 0

    securityfs /sys/kernel/security securityfs rw,nosuid,nodev,noexec,relatime 0 0

    tmpfs /dev/shm tmpfs rw,nosuid,nodev 0 0

    tmpfs /run/lock tmpfs rw,nosuid,nodev,noexec,relatime,size=5120k 0 0

    tmpfs /sys/fs/cgroup tmpfs ro,nosuid,nodev,noexec,mode=755 0 0

    cgroup2 /sys/fs/cgroup/unified cgroup2 rw,nosuid,nodev,noexec,relatime,nsdelegate 0 0

    cgroup /sys/fs/cgroup/systemd cgroup rw,nosuid,nodev,noexec,relatime,xattr,name=systemd 0 0

    pstore /sys/fs/pstore pstore rw,nosuid,nodev,noexec,relatime 0 0

    efivarfs /sys/firmware/efi/efivars efivarfs rw,nosuid,nodev,noexec,relatime 0 0

    none /sys/fs/bpf bpf rw,nosuid,nodev,noexec,relatime,mode=700 0 0

    cgroup /sys/fs/cgroup/blkio cgroup rw,nosuid,nodev,noexec,relatime,blkio 0 0

    cgroup /sys/fs/cgroup/cpuset cgroup rw,nosuid,nodev,noexec,relatime,cpuset 0 0

    cgroup /sys/fs/cgroup/rdma cgroup rw,nosuid,nodev,noexec,relatime,rdma 0 0

    cgroup /sys/fs/cgroup/net_cls,net_prio cgroup rw,nosuid,nodev,noexec,relatime,net_cls,net_prio 0 0

    cgroup /sys/fs/cgroup/hugetlb cgroup rw,nosuid,nodev,noexec,relatime,hugetlb 0 0

    cgroup /sys/fs/cgroup/pids cgroup rw,nosuid,nodev,noexec,relatime,pids 0 0

    cgroup /sys/fs/cgroup/perf_event cgroup rw,nosuid,nodev,noexec,relatime,perf_event 0 0

    cgroup /sys/fs/cgroup/freezer cgroup rw,nosuid,nodev,noexec,relatime,freezer 0 0

    cgroup /sys/fs/cgroup/cpu,cpuacct cgroup rw,nosuid,nodev,noexec,relatime,cpu,cpuacct 0 0

    cgroup /sys/fs/cgroup/devices cgroup rw,nosuid,nodev,noexec,relatime,devices 0 0

    cgroup /sys/fs/cgroup/memory cgroup rw,nosuid,nodev,noexec,relatime,memory 0 0

    systemd-1 /proc/sys/fs/binfmt_misc autofs rw,relatime,fd=28,pgrp=1,timeout=0,minproto=5,maxproto=5,direct,pipe_ino=23988 0 0

    mqueue /dev/mqueue mqueue rw,nosuid,nodev,noexec,relatime 0 0

    tracefs /sys/kernel/tracing tracefs rw,nosuid,nodev,noexec,relatime 0 0

    debugfs /sys/kernel/debug debugfs rw,nosuid,nodev,noexec,relatime 0 0

    hugetlbfs /dev/hugepages hugetlbfs rw,relatime,pagesize=2M 0 0

    sunrpc /run/rpc_pipefs rpc_pipefs rw,relatime 0 0

    nfsd /proc/fs/nfsd nfsd rw,relatime 0 0

    configfs /sys/kernel/config configfs rw,nosuid,nodev,noexec,relatime 0 0

    fusectl /sys/fs/fuse/connections fusectl rw,nosuid,nodev,noexec,relatime 0 0

    /dev/sdd2 /vm_storage ext4 rw,relatime 0 0

    /dev/sdc1 /boot/efi vfat 
    rw,relatime,fmask=0077,dmask=0077,codepage=437,iocharset=iso8859-1,shortname=mixed,errors=remount-ro 0 0

    /dev/sdc3 /home ext4 rw,relatime 0 0

    /dev/sdd1 /home/bruno/Downloads ext4 rw,relatime 0 0

    binfmt_misc /proc/sys/fs/binfmt_misc binfmt_misc rw,nosuid,nodev,noexec,relatime 0 0

    tmpfs /run/user/1000 tmpfs 

    rw,nosuid,nodev,relatime,size=1638980k,mode=700,uid=1000,gid=1000 0 0

    gvfsd-fuse /run/user/1000/gvfs fuse.gvfsd-fuse 
    rw,nosuid,nodev,relatime,user_id=1000,group_id=1000 0 0

    /dev/sda1 /media/bruno/Dados fuseblk rw,nosuid,nodev,relatime,user_id=0,group_id=0,default_permissions,allow_other,blksize=4096 0 0

    bitwarden.AppImage /tmp/.mount_bitwarbJIDr7 fuse.bitwarden.AppImage ro,nosuid,nodev,relatime,user_id=1000,group_id=1000 0 0


UDEV​

O udev é o gerenciador de dispositivos do kernel Linux. Ele é responsável por detectar, nomear e configurar dispositivos dinamicamente, à medida que são conectados ou desconectados do sistema. Em sistemas modernos baseados no SystemD, o daemon é executado como systemd-udevd, pois está integrado ao próprio gerenciador de serviços.


O funcionamento do udev é baseado no conceito de hotplug, ou seja, ele reage a eventos de hardware em tempo real. Sempre que você conecta um dispositivo, como um pendrive, disco rígido, teclado, mouse ou qualquer periférico, o udev intercepta esse evento (chamado de uevent) e executa regras definidas para tratar aquele dispositivo. Essas regras determinam, por exemplo, permissões, nomes simbólicos, associação a grupos, execução de scripts e muito mais.


Após o tratamento do evento, o udev cria dinamicamente um arquivo de dispositivo em /dev/, permitindo que o kernel e os programas do espaço de usuário interajam com o hardware recém-detectado.


O comando utilizado para interagir com o sistema udev é o udevadm (não é cobrado na LPIC-1). Ele permite monitorar eventos em tempo real (udevadm monitor), testar regras, solicitar recarregamento de regras, consultar informações de dispositivos, entre outras funções.


Por exemplo, para acompanhar os eventos do udev em tempo real:

sudo udevadm monitor

Esse comando exibe tanto os uevents do kernel quanto os events do udev enviados e processados à medida que os dispositivos são conectados ou removidos.


As regras do udev controlam o comportamento de cada tipo de dispositivo e são escritas em arquivos .rules. O sistema armazena as regras padrão em /lib/udev/rules.d/.


Essas regras são fornecidas por pacotes e atualizações do sistema. Para criar ou sobrescrever regras personalizadas, você deve usar o diretório /etc/udev/rules.d/.


As regras nesse diretório têm prioridade sobre as do sistema e permitem configurar o comportamento de dispositivos específicos de acordo com seus atributos (como ID do fabricante, tipo de barramento, nome, etc.).


O udev opera sobre um sistema de arquivos especial chamado devtmpfs, que é montado em /dev. Esse tipo de filesystem é mantido em memória (RAM) (semelhante ao tmpfs) o que significa que os arquivos de dispositivo não são persistentes, eles são criados dinamicamente na inicialização do sistema e removidos ao desligar a máquina. Por isso, mesmo que vejamos os dispositivos em /dev, eles não existem fisicamente no disco, mas são gerenciados em tempo real pelo udev.



Módulos do Kernel​

Em /proc/modules podemos ver os modulos do Kernel que estão carregados no sistema, essa informação é usada pelo comando lsmod.



Barramento​

Dispositivo onde você conecta os dispositivos de hardware na placa mãe, os abordados na LPI são PCI - Peripheral Component Interconnect, visto com o comando lspci e USB: Universal Serial Bus, visto com comando lsusb.



LSPCI​

O comando lspci mostra os dispositivos que estão conectados no barramento PCI.

Opções:

-v      Verbose (-vv ou -vvv para mais verbose)
-s      Mostrar apenas dispositivos no domínio especificado
        
        <Dominio ou Barramento>:<Dispositivo>.<Função>
        
        Os domínios são numerados de 0 a ffff, barramento (0 a ff), 
        dispositivo (0 a 1f) e função (0 a 7).

Vamos ver um exemplo do comando funcionando:

$ lspci 
00:00.0 Host bridge: Intel Corporation 440FX - 82441FX PMC [Natoma] (rev 02)
00:01.0 ISA bridge: Intel Corporation 82371SB PIIX3 ISA [Natoma/Triton II]
00:01.1 IDE interface: Intel Corporation 82371SB PIIX3 IDE [Natoma/Triton II]
00:01.2 USB controller: Intel Corporation 82371SB PIIX3 USB [Natoma/Triton II] (rev 01)
00:01.3 Bridge: Intel Corporation 82371AB/EB/MB PIIX4 ACPI (rev 03)
00:02.0 VGA compatible controller: Cirrus Logic GD 5446
00:03.0 SCSI storage controller: Red Hat, Inc. Virtio block device
00:04.0 Unclassified device [00ff]: Red Hat, Inc. Virtio memory balloon
00:05.0 Ethernet controller: Red Hat, Inc. Virtio network device


LSUSB​

O comando lsusb mostra os dispositivos que estão conectados no barramento USB.

Aqui não temos um digito para representar uma "função", apenas o barramento e o dispositivo.


Opções:

-v      Verbose (-vv ou -vvv para mais verbose)
-s      Mostrar apenas dispositivos no barramento especificado
-t      Exibe a saída em forma de árvore.
-d      Mostra todo o dispositivo integrado no mesmo ID

Exemplo:

# Exibindo tudo:
$ lsusb 
Bus 006 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
Bus 005 Device 003: ID 04d9:fc30 Holtek Semiconductor, Inc. USB Gaming Mouse
Bus 005 Device 002: ID 0951:16e5 Kingston Technology HyperX Alloy Origins
Bus 005 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 004 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
Bus 003 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 002 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
Bus 001 Device 002: ID 174c:55aa ASMedia Technology Inc. Name: ASM1051E SATA 6Gb/s bridge, ASM1053E SATA 6Gb/s bridge, ASM1153 SATA 3Gb/s bridge, ASM1153E SATA 6Gb/s bridge
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

# Filtrando com -s:
$ lsusb -s 005:001
Bus 005 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

# Usando o -s e o -v:
$ lsusb -s 005:001 -v
Bus 005 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Couldn't open device, some information will be missing
Device Descriptor:
  bLength                18
  bDescriptorType         1
  bcdUSB               2.00
  bDeviceClass            9 Hub
  bDeviceSubClass         0 
  bDeviceProtocol         1 Single TT
  bMaxPacketSize0        64
  idVendor           0x1d6b Linux Foundation
  idProduct          0x0002 2.0 root hub
  bcdDevice            5.04
  iManufacturer           3 
  iProduct                2 
  iSerial                 1 
  bNumConfigurations      1
  Configuration Descriptor:
    bLength                 9
    bDescriptorType         2
    wTotalLength       0x0019
    bNumInterfaces          1
    bConfigurationValue     1
    iConfiguration          0 
    bmAttributes         0xe0
      Self Powered
      Remote Wakeup
    MaxPower                0mA
    Interface Descriptor:
      bLength                 9
      bDescriptorType         4
      bInterfaceNumber        0
      bAlternateSetting       0
      bNumEndpoints           1
      bInterfaceClass         9 Hub
      bInterfaceSubClass      0 
      bInterfaceProtocol      0 Full speed (or root) hub
      iInterface              0 
      Endpoint Descriptor:
        bLength                 7
        bDescriptorType         5
        bEndpointAddress     0x81  EP 1 IN
        bmAttributes            3
          Transfer Type            Interrupt
          Synch Type               None
          Usage Type               Data
        wMaxPacketSize     0x0004  1x 4 bytes
        bInterval              12

# Verificando os Bus e Dev pertencentes ao mesmo ID:
$ lsusb -d 1d6b:0002
Bus 005 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 003 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub


LSHW​

Lista informações de hardwares físicos e virtuais do sistema.

$ lshw | head 
WARNING: you should run this program as super-user.
chiredean                   
    description: Computer
    width: 64 bits
    capabilities: smp vsyscall32
  *-core
       description: Motherboard
       physical id: 0
     *-memory
          description: System memory
          physical id: 0


LSCPU​

Exibe informações sobre a/as CPU(s) da máquina, essas informações são retiradas de /proc/cpuinfo.

$ lscpu 
Architecture:                    x86_64
CPU op-mode(s):                  32-bit, 64-bit
Byte Order:                      Little Endian
Address sizes:                   43 bits physical, 48 bits virtual
CPU(s):                          6
On-line CPU(s) list:             0-5
Thread(s) per core:              1
Core(s) per socket:              6
Socket(s):                       1
NUMA node(s):                    1
Vendor ID:                       AuthenticAMD
CPU family:                      23
Model:                           113
Model name:                      AMD Ryzen 5 3500X 6-Core Processor
Stepping:                        0
Frequency boost:                 enabled
CPU MHz:                         2149.997
CPU max MHz:                     3600,0000
CPU min MHz:                     2200,0000
BogoMIPS:                        7186.62
Virtualization:                  AMD-V
L1d cache:                       192 KiB
L1i cache:                       192 KiB
L2 cache:                        3 MiB
L3 cache:                        32 MiB
NUMA node0 CPU(s):               0-5
Vulnerability Itlb multihit:     Not affected
Vulnerability L1tf:              Not affected
Vulnerability Mds:               Not affected
Vulnerability Meltdown:          Not affected
Vulnerability Spec store bypass: Mitigation; Speculative Store Bypass disabled via prctl and seccomp
Vulnerability Spectre v1:        Mitigation; usercopy/swapgs barriers and __user pointer sanitization
Vulnerability Spectre v2:        Mitigation; Full AMD retpoline, IBPB conditional, STIBP disabled, RSB filling
Vulnerability Srbds:             Not affected
Vulnerability Tsx async abort:   Not affected
Flags:                           fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx mmxext fxsr_opt pdpe1gb rdtscp lm constant_tsc rep_good nopl nonstop_tsc cpuid extd_apicid ap
                                 erfmperf pni pclmulqdq monitor ssse3 fma cx16 sse4_1 sse4_2 movbe popcnt aes xsave avx f16c rdrand lahf_lm cmp_legacy svm extapic cr8_legacy abm sse4a misalignsse 3dnowprefetch osvw ibs skinit wdt tce topo
                                 ext perfctr_core perfctr_nb bpext perfctr_llc mwaitx cpb cat_l3 cdp_l3 hw_pstate sme ssbd mba sev ibpb stibp vmmcall fsgsbase bmi1 avx2 smep bmi2 cqm rdt_a rdseed adx smap clflushopt clwb sha_ni xsaveopt x
                                 savec xgetbv1 xsaves cqm_llc cqm_occup_llc cqm_mbm_total cqm_mbm_local clzero irperf xsaveerptr wbnoinvd arat npt lbrv svm_lock nrip_save tsc_scale vmcb_clean flushbyasid decodeassists pausefilter pfthresh
                                 old avic v_vmsave_vmload vgif umip rdpid overflow_recov succor smca


LSMEM​

Exibe informações sobre a memória, essas informações são encontradas em /proc/meminfo.

$ lsmem 
RANGE                                  SIZE  STATE REMOVABLE  BLOCK
0x0000000000000000-0x00000000dfffffff  3,5G online       yes   0-27
0x0000000100000000-0x000000041fffffff 12,5G online       yes 32-131

Memory block size:       128M
Total online memory:      16G
Total offline memory:      0B


Coldplug x Hotplug​

Dispositivos coldplug (plugagem fria) são dispositvos que necessitam que a máquina esteja desligada para que o sistema possa reconhecer o dispositivo.

Ex: PS/2, Controladoras IDE, PCI, ISA entre outros.

Dispositivos hotplug (plugagem quente) são dispositivos que podem ser plugados com a máquina ligada e já são reconhecidos pelo sistema.

Ex: Sata, USB entre outros.



IDE, PATA, SATA e SCSI​

(P)ATA - Parallel Advanced Technology Attachment​

Também conhecido como IDE; é uma referência à interface de conexão desses dispositivos. No Linux esses dispositivos são mapeados como hda, hdb, hdc..., mas hoje em dia é mapeado como sdX, porque não importa qual conexão seja, o Linux mapeia tudo como se fosse um dispositivo SCSI.

Possuem um sistemas de Master e Slave atráves de uso de jumpers no próprio HD, com uma capacidade de 2 HD por cabo, ele usa cabo conhecido como Flat (IDE Flat), esse cabo possui uma limitação de apenas 3 entrada fêmeas (existem outras variações como uma entrada macho e uma fêmea, mas o máximo de entradas são 3, contendo 3 entradas fêmeas), onde uma entrada se faz na placa mãe, e duas ficam para um HD master e um Slave.

Um driver de CD/DVD IDE também é referênciado como hdX, mapeado hoje em dia mais como sr0.



SATA - Serial Advanced Technology Attachment​

Sucessor do ATA/PATA, nesse novo padrão, podemos fazer a troca do disco em hot-swap (funciona com hotplug, então trocar o dispositivo com a maquina ligada é chamado de hot-swap).

Aqui só podemos ter 1 disco por cabo, é muito mais rápido que o ATA e seu reconhecimento é sda, sdb, sdc..., mesmo tendo seu mapeamento como scsi, seu mapeamento original já é no formato de discos scsi.



SCSI - Small Computer System Interface​

Permite a transferência de dados em altas velocidades.

Existem 2 tipos de SCSI, são eles:

  • 8 bits É possível conectarmos 7 dispositivos num único barramento, sendo 1 controladora e 7 dispositivos.
  • 16 bits É possível conectarmos 15 dispositivos num único barramento, sendo 1 controladora e 15 dispositivos.

Dispositivos scsi possuem um ID com 3 números: Canal, ID do dispositivo e Lun, podemos ver isso com os comandos lsscsi, scsi_info ou cat /proc/scsi/scsi.

  • Canal

    Identificador de cada adaptador;

  • ID Identificador de cada dispositivo;

  • Lun Número lógico da Unidade.

Seu mapeamento é igual o SATA e as informações ficam em /proc/scsi/scsi.



Outros dispositivos​

Disquete (Floppy Disk) = /dev/fd0.

SCSI CD-Rom = /dev/scd0

SCSI DVD = /dev/sr0

/dev/dvd = Link para o device do dvd;

/dev/cdrom = Link para o device do cdrom.


Podemos consultar os discos que foram attach no sistema olhando os logs, mais em especifico o dmesg.



Módulos no Linux​

Para que o sistema operacional funcione corretamente, o kernel precisa reconhecer o hardware conectado à máquina e ser capaz de interagir com ele. A forma tradicional de garantir isso seria recompilar o kernel com suporte ao novo hardware, o que pode ser trabalhoso e demorado.


Para facilitar esse processo, o Linux adota o conceito de modularidade, permitindo que muitos drivers e funcionalidades sejam compilados como módulos separados. Isso permite que o sistema carregue dinamicamente apenas os módulos necessários, sem a necessidade de recompilar todo o kernel para cada alteração.


Vale destacar que nem todos os recursos podem ser modularizados. Alguns módulos são compilados diretamente no kernel (internos) e não podem ser removidos ou carregados dinamicamente. Outros podem ser compilados como módulos externos, que podem ser inseridos ou removidos em tempo de execução.


Os módulos do kernel ficam no diretório /lib/modules/, esse diretório contém subpastas organizadas por versão do kernel. Cada versão possui seus próprios módulos. Os arquivos de módulo têm a extensão .ko (Kernel Object).


Para ver os módulos carregados no sistemas, podemos olhar dentro do diretório /proc/modules, o comando lsmod olha dentro desse diretório para montar a saída que ele nos fornece.


Os módulos do Kernel sempre ficam no Kernel que está ativo, para verificar isso, digite o comando ls /lib/modules/$(uname -r)/kernel/.


Nós podemos criar aliases para os módulos do kernel, basta inserir o apelido dentro /etc/modprobe.d/, como por exemplo no arquivo /etc/modprobe.d/alias.conf.


# /etc/modprobe.d/alias.conf
alias placa_wifi_driver iwlwifi
alias som onboard snd_hda_intel

Assim, ao rodar o modprobe, o sistema carregará o módulo iwlwifi.

modprobe placa_wifi_driver


Módulos Internos e Externos​

Existem dois tipos de módulos no sistema: os conhecidos como Built-In (compilados diretamente no kernel) e os módulos externos (carregáveis dinamicamente). No exemplo abaixo, mostro como identificá-los, os módulos com valor m são externos, enquanto os com valor y são Built-In.

## Testes feito em VM!

# Verificando um módulo externo:
$ grep -i qxl /boot/config-5.4.0-65-generic 
CONFIG_DRM_QXL=m

# Verificando um módulo Built-In:
$ grep -i ext4 /boot/config-5.4.0-65-generic 
CONFIG_EXT4_FS=y
CONFIG_EXT4_USE_FOR_EXT2=y
CONFIG_EXT4_FS_POSIX_ACL=y
CONFIG_EXT4_FS_SECURITY=y

Outra forma de identificar é com o comando modinfo. Se o campo filename mostrar (builtin), o módulo é interno (Built-In). Se mostrar um caminho no filesystem, é um módulo externo.

$ modinfo ext4 | grep filename
name:           ext4
filename:       (builtin)

# Verificando um módulo externo:
$ modinfo btrfs | grep filename
filename:       /lib/modules/5.4.0-65-generic/kernel/fs/btrfs/btrfs.ko

Como mencionado anteriormente, não podemos manipular (carregar ou remover) módulos Built-In.

# Tentando remover o módulo ext4:
$ sudo modprobe -r ext4
modprobe: FATAL: Module ext4 is builtin.

# Tentando remover o módulo ehci-hcd:
$ sudo modprobe -r ehci-hcd
modprobe: FATAL: Module ehci_hcd is builtin.

# Outra forma de verificar módulos buit-in é olhando o arquivo abaixo:
$ grep -i ext4 /lib/modules/$(uname -r)/modules.builtin
kernel/fs/ext4/ext4.ko

# De um cat nesse arquivo para mais detalhe:
$ cat /lib/modules/$(uname -r)/modules.builtin


LSMOD​

Mostra os módulos ativos do sistema, também visto no arquivo /proc/modules.

  • A coluna Module Aqui temos o nome do módulo;


  • A coluna Size

    Aqui temos o tamanho do módulo em bytes;


  • A coluna Used by mostra se o módulo foi iniciado por outro módulo.

    Aqui temos um número indicando quantas instâncias do módulo temos em uso, valores igual a 0 indica que o módulo está ativo mas não está em uso, valor igual a -1 indica algum tipo de problema. O(s) nome(s) depois do número exibe o módulo(s) que está usando este módulo ou que dependem desse módulo.

    $ lsmod | sed -n '1p; /nvidia/p'
    Module                  Size  Used by
    nvidia_uvm           1011712  0
    nvidia_drm             49152  8
    nvidia_modeset       1183744  16 nvidia_drm
    nvidia              19742720  713 nvidia_uvm,nvidia_modeset
    drm_kms_helper        184320  1 nvidia_drm
    drm                   491520  11 drm_kms_helper,nvidia_drm
    i2c_nvidia_gpu         16384  0

    # nvidia_uvm = Não está sendo usado
    # nvidia_drm = Possui 8 instâncias ativa (não tem nenhum módulo dependendo dele)
    # nvidia_modeset = Possui 16 instâncias ativa (Depende de nvidia_drm)
    # nvidia = Possui 713 instâncias ativa (Depende de nvidia_uvm,nvidia_modeset)
    # drm_kms_helper = Possui 1 instância ativa (Depende de nvidia_drm)
    # drm = Possui 11 instância ativa (Depende de drm_kms_helper,nvidia_drm)
    # i2c_nvidia_gpu = Não está sendo usado


Nós podemos colocar módulos para iniciarem junto do sistema, para isso eles podem ser inseridos dentro de /etc/modules, ou podemos criar um arquivo com esses módulos em /etc/modules-load.d/, também podemos colocar em /etc/modprobe.d/, podemos colocar esses módulos também em /lib/modprobe.d/, dentro dele temos arquivos de blacklist onde podemos negar a ativação de um determinado módulo, impedindo que ele seja carregado no sistema, é recomendado sempre usar diretórios dentro de /etc/ para que não sejam sobrescritos por nenhuma atualização.

# Comando lsmod (exibindo módulos ativos)
$ lsmod | head -13
Module                  Size  Used by
xt_CHECKSUM            16384  1
xt_MASQUERADE          20480  3
ip6table_mangle        16384  1
ip6table_nat           16384  1
iptable_mangle         16384  1
iptable_nat            16384  1
nf_nat                 40960  3 ip6table_nat,iptable_nat,xt_MASQUERADE
nf_tables             139264  0
nfnetlink              16384  1 nf_tables
ip6table_filter        16384  1
ip6_tables             32768  3 ip6table_filter,ip6table_nat,ip6table_mangle
bridge                176128  0

# Mostrando /proc/modules
$ head -13 /proc/modules 
xt_CHECKSUM 16384 1 - Live 0x0000000000000000
xt_MASQUERADE 20480 3 - Live 0x0000000000000000
ip6table_mangle 16384 1 - Live 0x0000000000000000
ip6table_nat 16384 1 - Live 0x0000000000000000
iptable_mangle 16384 1 - Live 0x0000000000000000
iptable_nat 16384 1 - Live 0x0000000000000000
nf_nat 40960 3 xt_MASQUERADE,ip6table_nat,iptable_nat, Live 0x0000000000000000
nf_tables 139264 0 - Live 0x0000000000000000
nfnetlink 16384 1 nf_tables, Live 0x0000000000000000
ip6table_filter 16384 1 - Live 0x0000000000000000
ip6_tables 32768 3 ip6table_mangle,ip6table_nat,ip6table_filter, Live 0x0000000000000000
bridge 176128 0 - Live 0x0000000000000000
stp 16384 1 bridge, Live 0x0000000000000000

Exemplo de módulos carregados e bloqueados:

# Exibindo módulos que não vão ser ativos:
$ cat /lib/modprobe.d/nvidia-graphics-drivers.conf 
blacklist nouveau
blacklist lbm-nouveau
alias nouveau off
alias lbm-nouveau off


MODINFO​

O comando modinfo trás informações do módulo consultado, estando ativo ou não,

  • description Indica para que esse módulo serve.


  • depends Indica as dependências desse módulo.


  • filename Indica o caminho completo para o módulo.


Opções:

-n      Mostra o caminho do módulo;

Exemplo:

$ modinfo iptable_filter
filename:       /lib/modules/5.4.0-67-generic/kernel/net/ipv4/netfilter/iptable_filter.ko
description:    iptables filter table
author:         Netfilter Core Team <coreteam@netfilter.org>
license:        GPL
srcversion:     4B536AA51E969CB07EDA8CC
depends:        x_tables,ip_tables
retpoline:      Y
intree:         Y
name:           iptable_filter
vermagic:       5.4.0-67-generic SMP mod_unload modversions 
sig_id:         PKCS#7
signer:         Build time autogenerated kernel key
sig_key:        7D:B4:3C:1B:8E:DD:54:5C:82:E1:48:2D:FE:D6:F9:84:C9:CE:9E:EE
sig_hashalgo:   sha512
signature:      35:57:EF:8C:49:90:02:9E:D9:2D:B9:E2:7B:ED:3F:66:AF:AB:43:BD:
        EE:2A:C2:D6:4C:76:85:9E:53:92:17:B7:8B:55:F3:41:57:47:A0:FA:
        B7:F0:4B:D9:39:D7:51:11:89:04:89:21:E5:19:82:F6:FC:1E:06:E2:
        BA:6B:78:DF:06:E6:A7:09:F9:7B:83:0E:06:F3:D1:C0:CB:B9:C0:6E:
        64:74:54:F2:1F:DD:73:74:B2:0E:7A:CA:1A:DA:E5:43:ED:47:0C:C5:
        AC:45:65:3F:C7:FC:C8:4E:06:6F:75:7F:BB:60:E4:6B:E9:B7:B8:23:
        83:25:E5:CE:A0:F1:FB:7E:5C:FB:91:C3:FB:3C:EF:8E:DE:DE:83:C1:
        8E:D7:D9:02:B1:FF:35:E0:8A:36:2B:70:9E:60:12:0B:48:C7:9B:9D:
        08:C7:A9:CC:99:1C:A7:BF:5B:B2:75:21:00:B7:E0:93:0E:93:68:DE:
        3E:C9:93:57:7B:F4:6A:3D:16:E0:F6:45:54:08:5A:B5:5A:A7:45:ED:
        A7:35:E3:EF:AD:5D:FD:94:00:BB:F6:34:11:AC:2B:13:49:C2:00:88:
        5F:07:80:2B:CE:39:E7:DF:FB:55:C8:7A:BD:D0:5F:B0:E3:7C:1E:81:
        30:78:0A:BF:A9:83:57:03:71:BD:45:E7:59:32:2F:E7:BB:79:4F:C0:
        3E:35:86:4C:66:FE:B8:76:1F:D5:3A:2B:A8:B8:95:43:1F:7D:03:39:
        F1:43:4C:0D:65:07:47:B3:B5:78:09:73:69:74:EA:72:58:7A:46:BA:
        AE:7C:F4:9F:43:52:C1:8D:C1:D9:66:84:F4:EC:69:5F:8D:A0:1B:6D:
        00:93:F3:3B:F8:86:93:80:4E:1B:C2:87:CF:5B:32:A9:33:6F:21:5A:
        55:F7:3F:B7:5F:B6:EE:60:C8:91:B3:18:89:B4:0F:C2:1B:70:38:04:
        16:DE:8D:99:FA:4F:F1:54:72:86:B9:CE:DD:DF:82:17:90:34:CB:45:
        2E:28:5C:20:9A:EF:0F:63:10:BA:5A:40:DC:54:09:28:5B:CE:C3:85:
        B9:1F:41:D3:F0:B7:A8:5F:83:3D:D5:39:7C:F5:4F:73:70:0E:49:20:
        BC:3D:57:91:39:4A:14:B3:7D:25:F7:F5:E8:90:8B:D5:76:C2:3F:34:
        31:E6:ED:56:1E:6E:D0:05:CA:7C:70:FE:BD:E9:12:62:8B:6F:69:EB:
        72:DC:D9:75:FE:00:B7:2F:41:ED:E3:8C:3A:02:20:1F:21:F4:1F:66:
        C8:96:D3:46:B5:AC:5A:7A:78:AD:47:51:42:25:0F:FE:A8:04:AB:47:
        0A:AA:7D:12:85:E1:FD:39:C1:BD:E0:C8
parm:           forward:bool

# Vendo o caminho do módulo:
$ modinfo -n iptable_filter
/lib/modules/5.4.0-65-generic/kernel/net/ipv4/netfilter/iptable_filter.ko


RMMOD​

Esse comando é usado para desativar um módulo. Ao indicar o módulo, devemos omitir a extensão .ko,

e sempre tente usar o comando modprobe -r (vamos ver mais a frente) ele desativa também as dependências do módulo.

# Agora podemos remover o módulo. Esse módulo está disponível em VM.
$ sudo rmmod psmouse


INSMOD​

Ativa um módulo, mas precisa informar o caminho completo do módulo, também recomendado usar o modprobe, pois ele trata as dependências.

Exemplo:

# Antes de usarmos o insmod precisamos saber o cominho completo do módulo, então
# rode o comando modinfo.
$ modinfo psmouse
filename:       /lib/modules/5.4.0-65-generic/kernel/drivers/input/mouse/psmouse.ko
license:        GPL
description:    PS/2 mouse driver
author:         Vojtech Pavlik <vojtech@suse.cz>
srcversion:     C633869C427E59DB4FB8369
alias:          serio:ty05pr*id*ex*
alias:          serio:ty01pr*id*ex*
depends:        
retpoline:      Y
intree:         Y
name:           psmouse
vermagic:       5.4.0-65-generic SMP mod_unload 
sig_id:         PKCS#7
signer:         Build time autogenerated kernel key
sig_key:        44:6A:A8:96:83:1E:3C:56:C1:0F:55:7B:7B:95:7A:1F:F9:6B:72:D6
sig_hashalgo:   sha512
signature:      08:1F:6C:B9:21:24:6A:AA:82:29:87:CF:26:64:6F:D1:F1:2E:84:97:
        71:FD:31:A5:69:63:01:58:37:04:99:42:93:34:13:AA:A5:0F:7B:9C:
        30:A5:82:FE:E2:E7:45:5D:04:68:D2:BE:94:6B:C6:27:56:42:39:36:
        FD:5F:76:4F:63:77:EE:18:A1:23:60:40:C0:4B:D0:18:4D:C4:70:6D:
        9F:6F:68:C5:78:A7:7A:56:33:0F:3C:95:C8:58:82:51:99:C0:87:08:
        F3:FC:38:26:3D:59:FA:31:58:74:8E:0B:A1:1C:E9:DA:62:86:AA:1E:
        CA:E3:C7:FA:0B:09:FD:03:55:09:5E:F7:B1:DA:63:3D:D8:94:3A:3E:
        C7:EF:0B:97:74:C9:B4:B7:29:99:3A:FF:B1:0B:1D:6F:45:4E:03:F9:
        56:BE:7B:9D:EC:8F:B6:7C:59:1A:42:2A:27:21:63:D5:7A:E7:40:6F:
        11:10:76:D2:F9:FC:A0:60:EB:E7:5C:96:EF:57:4D:BD:60:4E:2D:0C:
        24:A9:54:52:E9:CF:B7:6F:64:26:2B:12:87:7F:BC:AB:83:AD:38:55:
        F9:37:9D:85:09:51:2C:7A:41:6B:96:F8:D5:63:A7:DE:98:1C:91:C7:
        FF:E3:94:02:06:3C:CB:EA:87:5C:F1:4F:0A:4C:17:F6:0D:DE:AE:49:
        D4:2B:1B:A4:AD:1F:F7:98:1A:8D:3C:88:23:D6:2C:C2:D6:1F:72:03:
        C2:50:AD:6E:45:F6:30:90:36:6B:1A:48:7F:32:97:35:D4:A1:A4:CE:
        08:B0:93:28:7F:58:B6:00:A5:6B:7C:95:16:AB:09:F4:CA:9C:0B:A0:
        B3:97:65:C9:B8:17:6D:0E:C4:D5:F8:1F:72:15:9B:63:39:43:47:DF:
        B4:DA:8B:79:CB:A6:EF:34:B0:06:45:77:40:93:34:A1:11:48:8B:49:
        50:07:8B:43:60:AE:E6:99:DD:AD:CB:BA:DF:F0:4E:A3:E6:4B:87:4D:
        FD:5E:6F:99:0A:70:3D:9F:32:6D:60:DE:7A:55:09:30:D6:06:2A:40:
        E5:7F:DB:21:9E:1F:F4:A9:0D:05:2F:4D:E5:35:B1:96:EB:C2:D9:ED:
        B1:97:00:F2:ED:EF:6A:FB:51:F8:1D:BB:46:65:F8:EE:86:9D:25:31:
        96:07:73:BC:50:3A:16:D6:6F:DB:D2:AF:87:A6:4F:2C:E7:2F:AA:AA:
        A7:53:DB:7E:F2:B9:7E:A1:3D:CD:D9:9B:71:48:D0:67:D7:82:A1:74:
        21:83:C4:44:BB:5B:5B:37:ED:D6:72:AA:51:32:D5:E2:B7:E3:93:0A:
        1C:3A:B8:0E:14:87:D3:74:45:A0:AC:A0
parm:           elantech_smbus:Use a secondary bus for the Elantech device. (int)
parm:           synaptics_intertouch:Use a secondary bus for the Synaptics device. (int)
parm:           proto:Highest protocol extension to probe (bare, imps, exps, any). Useful for KVM switches. (proto_abbrev)
parm:           resolution:Resolution, in dpi. (uint)
parm:           rate:Report rate, in reports per second. (uint)
parm:           smartscroll:Logitech Smartscroll autorepeat, 1 = enabled (default), 0 = disabled. (bool)
parm:           a4tech_workaround:A4Tech second scroll wheel workaround, 1 = enabled, 0 = disabled (default). (bool)
parm:           resetafter:Reset device after so many bad packets (0 = never). (uint)
parm:           resync_time:How long can mouse stay idle before forcing resync (in seconds, 0 = never). (uint)

# Ativando o módulo psmouse:
$ sudo insmod /lib/modules/5.4.0-65-generic/kernel/drivers/input/mouse/psmouse.ko


MODPROBE​

O comando modprobe é usado para carregar ou remover módulos do kernel, resolvendo automaticamente todas as suas dependências. Diferente do insmod, que exige o caminho completo do módulo e não lida com dependências, o modprobe busca o módulo pelo nome e se encarrega de carregar também os módulos auxiliares necessários.


Quando você executa modprobe <módulo>, o sistema procura o módulo correspondente dentro de /lib/modules/$(uname -r)/, analisa as dependências definidas no arquivo modules.dep (gerado pelo depmod) e insere todos os módulos na ordem correta.


Para remover um módulo, o comando modprobe -r faz o processo inverso, ele tenta remover o módulo solicitado e suas dependências, desde que nenhum deles esteja em uso.


Principais opções:

# Carrega o módulo:
modprobe <nome_do_módulo>

# Remove o módulo:
modprobe -r <nome_do_módulo>

# Mostra os módulos que serão carregados como dependência:
modprobe --show-depends módulo

Exemplo:

# Removendo o módulo 'psmouse' (mouse PS/2):
$ sudo modprobe -r psmouse

# Carregando o módulo novamente:
$ sudo modprobe psmouse

# Verificando as dependências do módulo 'btrfs'
$ modprobe --show-depends btrfs
builtin crc32c_intel
builtin crc32c_generic
insmod /lib/modules/5.4.0-65-generic/kernel/lib/libcrc32c.ko 
insmod /lib/modules/5.4.0-65-generic/kernel/lib/raid6/raid6_pq.ko 
insmod /lib/modules/5.4.0-65-generic/kernel/lib/zstd/zstd_compress.ko 
insmod /lib/modules/5.4.0-65-generic/kernel/crypto/xor.ko 
insmod /lib/modules/5.4.0-65-generic/kernel/fs/btrfs/btrfs.ko


Carregar um módulo automaticamente no boot​

Se você quer que um módulo seja carregado automaticamente toda vez que o sistema iniciar, basta adicioná-lo ao arquivo:

/etc/modules

Cada linha representa o nome de um módulo a ser carregado. Exemplo:

psmouse
btrfs

Também é possível criar arquivos de configuração específicos dentro de:

/etc/modules-load.d/

Por exemplo:

echo psmouse > /etc/modules-load.d/psmouse.conf


Bloquear a execução de um módulo (blacklist)​

Para impedir que um módulo seja carregado automaticamente (por exemplo, se ele causa problemas ou não é necessário), você pode bloqueá-lo criando uma regra de blacklist. Edite (ou crie) um arquivo dentro de:

/etc/modprobe.d/

E adicione uma linha como:

blacklist <nome_do_módulo>

Por exemplo:

echo "blacklist psmouse" > /etc/modprobe.d/blacklist-psmouse.conf

Esse bloqueio impede que o módulo seja carregado automaticamente, mesmo que outro módulo dependa dele. Porém, ainda será possível carregá-lo manualmente com modprobe, a menos que você adicione uma regra mais forte como:

# /etc/modprobe.d/deny-psmouse.conf
install psmouse /bin/false

Isso substitui qualquer tentativa de carregamento do módulo por um comando falso, bloqueando completamente.



modprobe.d​

O diretório /etc/modprobe.d/ é o local onde ficam os arquivos de configuração dos módulos do kernel Linux. Esses arquivos permitem personalizar o comportamento do modprobe, a ferramenta usada para carregar e descarregar módulos de forma dinâmica, resolvendo dependências automaticamente.


Os módulos definidos nos arquivos de configuração em /etc/modprobe.d/ não são carregados automaticamente no boot apenas por estarem definidos ali.


O conteúdo desses arquivos define como o sistema deve lidar com os módulos: bloquear, passar parâmetros, criar aliases ou substituir comportamentos padrão.


Esses arquivos são todos lidos pelo modprobe no momento em que você tenta carregar ou remover um módulo, seja manualmente ou automaticamente (por exemplo, ao conectar um hardware que precisa de driver).


Cada arquivo .conf dentro do /etc/modprobe.d/ pode conter instruções como:

  • blacklist

    Impede que o módulo seja carregado automaticamente pelo kernel, mas não impede carregamento manual via modprobe.

    blacklist usb_storage

  • install

    Substitui o comportamento padrão do modprobe ao tentar carregar um módulo. Usado, por exemplo, para bloquear completamente o carregamento:

    install psmouse /bin/false

  • remove

    Define o que deve ser feito quando o módulo for removido com modprobe -r.

    remove usb_storage /bin/true

  • options

    Permite passar parâmetros específicos para um módulo no momento do carregamento.

    options iwlwifi power_save=1

  • alias

    Cria apelidos para módulos, permitindo que você os carregue usando nomes mais simples ou personalizados.

    alias placa_wifi_driver iwlwifi

O nome dos arquivos dentro de /etc/modprobe.d/ não precisa seguir um padrão rígido, mas é uma boa prática dar nomes descritivos com final .conf, como:

  • blacklist-som.conf
  • iwlwifi.conf
  • custom-modules.conf

Todos os arquivos .conf serão lidos e aplicados, independente do nome, desde que tenham sintaxe válida.


Além de /etc/modprobe.d/, o sistema também pode ler configurações de:

  • /run/modprobe.d/ (configurações temporárias)
  • /lib/modprobe.d/ (configurações padrão do sistema ou da distribuição)

As configurações em /etc/modprobe.d/ têm prioridade sobre as demais, pois são consideradas personalizações feitas pelo administrador.



DEPMOD​

O comando depmod é uma ferramenta fundamental para o gerenciamento de módulos do kernel Linux. Sua principal função é gerar os arquivos que descrevem as relações de dependência entre os módulos, ou seja, ele constrói um "mapa" que indica quais módulos precisam ser carregados antes de outros para que tudo funcione corretamente. O principal arquivo gerado por ele é o /lib/modules/$(uname -r)/modules.dep.


Esse arquivo modules.dep é utilizado pelas ferramentas do sistema (como o modprobe) para saber quais outros módulos devem ser carregados automaticamente junto com o módulo que você solicitou. Por exemplo, se um determinado driver depende de outro módulo, essa relação estará registrada nesse arquivo. Assim, ao tentar carregar o primeiro módulo, o sistema sabe que precisa carregar o segundo também, evitando falhas de execução.


Quando você compila ou instala um novo módulo manualmente, esse novo arquivo .ko (kernel object) é adicionado ao diretório de módulos da versão do kernel atual, mas o sistema ainda não sabe que ele existe nem quais dependências ele possui. O mesmo acontece se, por algum motivo, os arquivos de dependência forem corrompidos ou apagados. Nesse caso, o kernel tentará carregar um módulo sem saber do que ele depende, o que geralmente resulta em erro.


Para resolver isso, você deve rodar o comando depmod. Ele varre todo o conteúdo do diretório /lib/modules/$(uname -r)/, analisa os módulos disponíveis e recria o arquivo modules.dep e outros arquivos auxiliares, como modules.alias, modules.symbols, entre outros. Você pode executá-lo assim:

sudo depmod

Ou, se quiser acompanhar os detalhes do que está sendo feito:

sudo depmod -v

Depois de rodar o depmod, o sistema passa a reconhecer corretamente os módulos novos e suas dependências, permitindo que eles sejam carregados normalmente usando comandos como modprobe.


Portanto, sempre que você adicionar, remover ou recompilar um módulo manualmente, é importante executar o depmod. Sem isso, o kernel pode não conseguir usar o novo módulo, mesmo que ele esteja fisicamente presente no sistema.