# Memorias ROM (HDD, SSD e NVME)

### 🧠 Conceito Fundamental

A **Memória ROM (Read-Only Memory)** é um tipo de armazenamento não-volátil projetado para:

* **Armazenamento permanente** de dados/firmware
* **Inicialização do sistema** (bootstrapping)
* **Controle de hardware** de baixo nível

```mermaid
graph TD
    A[ROM] --> B[Firmware BIOS/UEFI]
    A --> C[Microcódigo CPU]
    A --> D[Tabelas de Calibração]
```

### ⚙️ Arquitetura Física

#### **Tecnologias de Fabricação**

| Tipo       | Tecnologia     | Regravável? | Aplicação Típica         |
| ---------- | -------------- | ----------- | ------------------------ |
| MROM       | Máscara        | Não         | Consoles antigos         |
| PROM       | Fusíveis       | Uma vez     | Protótipos               |
| EPROM      | Floating Gate  | UV erase    | Equip. industrial        |
| EEPROM     | Túnel Quântico | Elétrico    | Configurações de sistema |
| Flash NOR  | NAND改良         | Setores     | Firmware                 |
| Flash NAND | Blocos         | Blocos      | SSDs, USBs               |

**Célula ROM Clássica:**

```plaintext
Matriz de Diodos:
   Vcc
    │
    ├───┤  (Diodo) → Bit '1'
    │
    └───┐       → Bit '0' (Sem conexão)
        │
       GND
```

### 🔌 Funcionamento Elétrico

{% stepper %}
{% step %}

#### **Operação de Leitura**

1. Ativa linha de endereço (word line)
2. Detecta corrente nas colunas (bit lines)
3. Amplificador de sentido (sense amp) converte para lógica
   {% endstep %}

{% step %}

#### **Exemplo de Conexão**

```c
// Pseudocódigo de leitura ROM
byte read_rom(uint16_t address) {
    activate_wordline(address >> 8);
    byte data = read_bitlines(address & 0xFF);
    return decode_byte(data);
}
```

{% endstep %}
{% endstepper %}

### ⚡ Comparativo RAM vs ROM

| Característica    | RAM         | ROM            |
| ----------------- | ----------- | -------------- |
| **Volatilidade**  | Volátil     | Não-volátil    |
| **Velocidade**    | 10-100ns    | 50-200ns       |
| **Endurance**     | ∞           | 1e3-1e6 ciclos |
| **Custo por bit** | Alto        | Baixo          |
| **Complexidade**  | 1T1C (DRAM) | 1T (ROM Mask)  |
| **Consumo**       | Ativo/Alto  | Standby/Mínimo |

### 🔧 Aplicações Críticas

{% stepper %}
{% step %}

#### **Bootloader**

```plaintext
CPU Reset → Leitura da ROM → Carrega estágio 1 do boot
```

{% endstep %}

{% step %}

#### **Tabelas de Calibração**

```c
// Exemplo em sistemas embarcados
const uint16_t CALIB_TABLE[] PROGMEM = {0x1A3F, 0x2B4C...};
```

{% endstep %}

{% step %}

#### **Microcódigo**

```plaintext
Opcode CPU → Tradução ROM → Microinstruções
```

{% endstep %}
{% endstepper %}

### 🛠️ Tecnologias Modernas

#### **eFuse (One-Time Programmable)**

```mermaid
graph LR
    A[Polissilício] --> B[Eletromigração] --> C[Estado Programado]
```

#### **FRAM (Ferroelectric RAM)**

* Combina não-volatilidade com performance similar a RAM
* Princípio: Polarização de cristais ferroelétricos

**Equação de Histerese:**

```plaintext
P = f(E): 
   P↑ (Remanência positiva) → Bit '1'
   P↓ (Remanência negativa) → Bit '0'
```

### ⚠️ Considerações de Projeto

{% stepper %}
{% step %}

#### **Tempo de Retenção**

* Flash NOR: \~20 anos a 85°C
* Decremento por efeito de temperatura (Arrhenius)
  {% endstep %}

{% step %}

#### **Radiação**

* ROMs mask são imunes a SEU (Single Event Upsets)
* Requerimentos para espaço: ECC adicional
  {% endstep %}

{% step %}

#### **Segurança**

```plaintext
ROM → Raiz de Confiança → Secure Boot Chain
```

{% endstep %}
{% endstepper %}

### 🔍 Ferramentas de Análise

**Leitura Física:**

```bash
# Extração direta de chip ROM (Linux)
flashrom -p linux_spi:dev=/dev/spidev0.0 -r firmware.rom
```

**Análise de Conteúdo:**

```bash
strings firmware.rom | grep -i "version"
hexdump -C firmware.rom | head -50
```

## Particionamento de Disco e Sistemas de Arquivos

#### **Hierarquia de Armazenamento**

```mermaid
graph TD
    A[Disco Físico] --> B[Partições]
    B --> C[Volume Lógico]
    C --> D[Sistema de Arquivos]
    D --> E[Metadados]
    E --> F[Dados do Usuário]
```

### ⚙️ Particionamento de Disco

#### **Tabelas de Partição**

| Tipo                 | MBR (Master Boot Record)       | GPT (GUID Partition Table)          |
| -------------------- | ------------------------------ | ----------------------------------- |
| **Limite Partições** | 4 primárias (estendida para +) | 128 partições (Windows)             |
| **Tamanho Máximo**   | 2TB                            | 9.4ZB (2^64 setores)                |
| **Resiliência**      | Cópia única no setor 0         | Cópias primária e secundária        |
| **Boot**             | Código bootstrap no setor 0    | UEFI com ESP (EFI System Partition) |

**Estrutura MBR:**

```plaintext
Offset 0x000: Bootstrap Code (446 bytes)
Offset 0x1BE: Partition Entry 1 (16 bytes)
...
Offset 0x1FE: Signature (55 AA)
```

**Estrutura GPT:**

```plaintext
Header GPT (LBA 1): CRC32, GUID disco, Entradas partição
Partition Entries (LBA 2-33): 128 entradas de 128 bytes
Backup Header (Último LBA): Cópia de segurança
```

### 📂 Sistemas de Arquivos

#### **Comparativo entre Sistemas**

| Sistema          | FAT32     | NTFS        | ext4      | APFS          |
| ---------------- | --------- | ----------- | --------- | ------------- |
| **Tamanho Máx.** | 2TB (vol) | 256TB (vol) | 1EB (vol) | 8EB (vol)     |
| **Arquivo Máx.** | 4GB       | 16EB        | 16TB      | 8EB           |
| **Journaling**   | Não       | Sim         | Sim       | Copy-on-Write |
| **Permissões**   | Básico    | ACLs        | POSIX     | ACLs/Herança  |

### 🔍 Estruturas Internas

#### **Exemplo FAT32**

```mermaid
graph TB
    A[Boot Sector] --> B[FAT1]
    A --> C[FAT2 Backup]
    A --> D[Root Directory]
    D --> E[Cluster Chain]
```

**Cálculo de Cluster:**

```c
uint32_t cluster_to_lba(uint32_t cluster) {
    return reserved_sectors + (fat_count * sectors_per_fat) + 
           ((cluster - 2) * sectors_per_cluster);
}
```

#### **Exemplo ext4**

```plaintext
Superbloco → Descritores de Grupo → Tabela inodes → Bitmap de blocos
            ↳ Journal (jbd2) → Transações de metadados
```

**Estrutura inode:**

```c
struct ext4_inode {
    uint16_t i_mode;    // Permissões/tipo
    uint16_t i_uid;     // Dono
    uint32_t i_size;    // Tamanho bytes
    uint32_t i_atime;   // Access time
    uint32_t i_block[15]; // Ponteiros diretos/indiretos
    // ... + outros campos
};
```

### ⚡ Operações Críticas

{% stepper %}
{% step %}

#### **Alocação de Arquivos (ext4)**

1. Consulta bitmap de blocos livres
2. Aloca blocos com política:
   * **Preallocation**: Extents contíguos
   * **Delayed Allocation**: Buffer no journal
3. Atualiza:
   * Bitmap
   * Tabela de extents no inode
   * Journal para atomicidade
     {% endstep %}

{% step %}

#### **Recuperação NTFS ($MFT)**

```python
def recover_mft_entry(disk, mft_offset):
    header = disk.read(mft_offset, 42)
    if header[0:4] != b"FILE":
        return None
    attr_offsets = parse_attributes(disk, mft_offset)
    for offset in attr_offsets:
        attr = disk.read(mft_offset + offset, 16)
        if attr[0:4] == b"DATA":
            return extract_data(attr)
```

{% endstep %}
{% endstepper %}

### 🛠️ Ferramentas de Baixo Nível

**Análise de Disco:**

```bash
xxd -s 0 -l 512 /dev/sda  # Ver MBR/GPT
gdisk -l /dev/nvme0n1     # Analisar GPT
```

**Reparo de Sistemas:**

```bash
fsck.ext4 -fy /dev/sda2   # Forçar verificação ext4
chkdsk C: /F /R           # Reparo NTFS (Windows)
```

**Monitoramento:**

```bash
iostat -x 1               # IOPS por partição
df -i                     # Inodes livres
```

### ⚠️ Tópicos Avançados

#### **Particionamento para Performance**

```plaintext
SSD NVMe Otimizado:
   /dev/nvme0n1p1: 1GB  ESP (FAT32)
   /dev/nvme0n1p2: 50GB / (ext4, discard)
   /dev/nvme0n1p3: 80%  /home (XFS, noatime)
   /dev/nvme0n1p4: Restante swap (prioridade)
```

#### **Sistemas Embutidos**

```plaintext
Flash NAND Layout:
   Bootloader → Kernel → SquashFS (RO) 
   → JFFS2 (RW) → OverlayFS
```

## Arquitetura Física e Natureza de Comportamento

#### **HDD - Disco Rígido Magnético**

```mermaid
graph TB
    subgraph HDD
        A[Platter] --> B[Superfície Magnética]
        B --> C[Trilhas]
        C --> D[Setores 512B/4KB]
        E[Atuador] --> F[Braço Mecânico]
        F --> G[Cabeça de Leitura/Gravação]
        H[Motor Spindle] --> A
    end
```

**Princípios Físicos:**

* **Gravação Perpendicular**: Bits alinhados verticalmente (desde 2005)
* **GMR (Giant Magnetoresistance)**: Cabeças de leitura com camadas ferromagnéticas
* **Zoned Bit Recording**: Setores externos contêm mais dados que internos

**Parâmetros Críticos:**

* **Tempo de Seek** = Tempo de aceleração do braço (1-10ms)
* **Latência Rotacional** = 60/RPM \* 0.5 (ex: 7200 RPM → 4.17ms)
* **Taxa de Transferência** = Densidade areal × velocidade linear

#### **SSD NVMe - Memória Flash**

```mermaid
graph LR
    subgraph SSD_NVMe
        A[Controlador] --> B[DRAM Buffer]
        A --> C[Processador ARM]
        A --> D[Interface PCIe]
        D --> E[Lanes PCIe x4]
        A --> F[Channel Interleave]
        F --> G[Chip NAND 1]
        F --> H[Chip NAND 2]
    end
```

**Hierarquia de Armazenamento Flash:**

1. **Plano** → 2. **Die** → 3. **Bloco (256-512 páginas)** → 4. **Página (4-16KB)**

### ⚙️ Engenharia de Controle

#### **HDD Controller**

```c
// Pseudocódigo de operação HDD
void read_sector(int LBA) {
    seek_to_cylinder(LBA / sectors_per_cylinder);
    wait_rotation(position);
    activate_head(LBA % heads);
    read_analog_signal();
    apply_PRML(Partial Response Maximum Likelihood);
    decode_ECC();
}
```

**Técnicas Avançadas:**

* **Shingled Magnetic Recording (SMR)**: Trilhas sobrepostas (aumenta densidade)
* **Helium Sealing**: Reduz turbulência para discos de alta capacidade

#### **NVMe Controller**

```python
# Arquitetura simplificada do controlador NVMe
class NVMeController:
    def __init__(self):
        self.cmd_queues = [SQ0..SQ63, CQ0..CQ63]  # Submission/Completion Queues
        self.ftl = FlashTranslationLayer()
        self.wear_leveling = DynamicWearLeveling()
    
    def process_cmd(self):
        while True:
            cmd = pcie.read(sq_tail)
            if cmd.op == READ:
                data = self.ftl.read(cmd.lba)
                pcie.dma(data, cmd.buffer_addr)
            elif cmd.op == WRITE:
                self.wear_leveling.remap(cmd.lba)
                self.ftl.program(cmd.data)
```

**Inovações:**

* **Multi-Actuator**: Paralelismo interno (ex: Seagate Mach.2)
* **ZNS (Zoned Namespaces)**: Alinhamento software/hardware

### 🔧 NAND Flash Deep Dive

**Física da Célula:**

```plaintext
Floating Gate Transistor:
   ┌─────────────┐
   │ Control Gate│
   ├─────────────┤
   │ Oxide Layer │
   ├─────────────┤
   │ Floating Gate│ ← Elétrons armazenados
   ├─────────────┤
   │ Substrate   │
   └─────────────┘
```

**Processo de Programação:**

{% stepper %}
{% step %}

1. Aplicar alta tensão (15-20V) ao Control Gate
   {% endstep %}

{% step %}
2\. Tunelamento Fowler-Nordheim injeta elétrons no Floating Gate
{% endstep %}

{% step %}
3\. Mudança no Vth (Threshold Voltage) representa bits
{% endstep %}
{% endstepper %}

**Desafios de Engenharia:**

* **Program Disturb**: Células adjacentes afetadas durante escrita
* **Read Retry**: Leitura adaptativa devido à deriva de Vth
* **XOR Recovery**: Paridade distribuída para tolerância a falhas

### 📊 Projeto Mecânico Comparado

| Componente            | HDD                         | SSD NVMe                  |
| --------------------- | --------------------------- | ------------------------- |
| **Precisão Mecânica** | 1nm (posicionamento cabeça) | N/A (sem partes móveis)   |
| **Consumo Energia**   | 6-9W (ativo)                | 3-5W (ativo)              |
| **Temperatura**       | 25-55°C (crítico >60°C)     | 0-70°C (throttling >80°C) |
| **MTTF**              | 500.000-1M horas            | 1.5-2M horas              |

### 🛠️ Ferramentas de Análise de Baixo Nível

**Para HDDs:**

```bash
hdparm --fibmap /dev/sda  # Mapeamento físico de LBAs
smartctl --all --attributes /dev/sda  # Parâmetros SMART
```

**Para SSDs NVMe:**

```bash
nvme id-ctrl /dev/nvme0 -H  # Mostra arquitetura do controlador
nvme get-feature /dev/nvme0 -f 0x2 -H  # Temperatura instantânea
```

**Simulador FTL (Python Conceitual):**

```python
class FTL:
    def __init__(self):
        self.l2p = {}  # Logical to Physical mapping
        self.blocks = [Block() for _ in range(1024)]  # 1024 blocks
    
    def write(self, lba, data):
        physical_block = self.wear_leveling.select_block()
        self.blocks[physical_block].program(data)
        self.l2p[lba] = physical_block
        self.gc() if self.need_garbage_collection() else None
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://0xmorte.gitbook.io/bibliadopentestbr/conceitos/arquitetura-de-hardware/memorias-rom-hdd-ssd-e-nvme.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.