Disques et partitions

Show code cell source

Hide code cell source

import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
import matplotlib.gridspec as gridspec
import numpy as np
import seaborn as sns
import pandas as pd

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.1)

Anatomie d’un disque

Un disque dur (HDD) ou un SSD se compose de blocs adressables individuellement. Comprendre leur organisation est indispensable pour partitionner correctement et tirer parti des optimisations modernes.

Terminologie physique et logique

Secteur physique : unité minimale de lecture/écriture sur le support. Historiquement 512 octets (secteurs « 512n »). Les disques modernes utilisent des secteurs physiques de 4096 octets (« 4Kn » ou Advanced Format 4K), mais peuvent émuler des secteurs de 512 octets pour la compatibilité (« 512e »).

Secteur logique : unité exposée par le disque au système d’exploitation. Souvent 512 octets même sur un disque 4Kn (émulation).

LBA — Logical Block Addressing : mode d’adressage universel depuis les années 1990. Chaque secteur logique est identifié par un entier à partir de 0. L’adressage CHS (Cylinder/Head/Sector) est obsolète mais reste présent dans la table MBR pour la compatibilité BIOS.

Bloc de système de fichiers : multiple du secteur logique, choisi au formatage. En ext4, la taille par défaut est 4096 octets.

Alignement 4K

Un disque Advanced Format possède des secteurs physiques de 4096 octets mais expose des secteurs logiques de 512 octets. Si une partition commence sur un LBA qui n’est pas multiple de 8 (8 × 512 = 4096), chaque écriture d’un bloc de 4 Ko chevauche deux secteurs physiques, doublant les opérations d’effacement/réécriture.

parted et les outils modernes alignent automatiquement sur des multiples de 1 Mio (2048 secteurs × 512 = 1 Mio), ce qui garantit l’alignement 4K tout en restant compatible avec tous les sous-systèmes RAID et Flash.

# Vérifier l'alignement optimal d'un disque
cat /sys/block/sda/queue/optimal_io_size
cat /sys/block/sda/queue/minimum_io_size
cat /sys/block/sda/alignment_offset

Cylindres : héritage CHS

Le modèle CHS découpait le disque en cylindres (ensemble de pistes de même rayon sur toutes les têtes), têtes (surfaces magnétiques) et secteurs (divisions angulaires d’une piste). L’adressage CHS est limité à 8,4 Go. L’adressage LBA 28-bit l’étend à 137 Go, et LBA 48-bit à 128 Pio — largement suffisant pour les technologies actuelles.

---

Schémas de partitionnement

MBR — Master Boot Record

Le MBR occupe les 512 premiers octets du disque (secteur LBA 0) :

• octets 0–445 : code de démarrage (bootstrapper)

• octets 446–509 : table de partition (4 × 16 octets)

• octets 510–511 : signature 0x55AA

Chaque entrée de 16 octets encode : statut de boot, CHS début/fin (obsolète), LBA de début, nombre de secteurs. Avec des LBA 32-bit, la limite absolue est 2 Tio (2³² × 512 octets).

Limitations du MBR :

• 4 partitions primaires maximum

• Contournement : une partition étendue contenant des partitions logiques (table chaînée dans les EBR — Extended Boot Records)

• Pas de redondance : corruption du secteur 0 = perte de la table

• Pas de GUID, pas de somme de contrôle

GPT — GUID Partition Table

Le GPT (défini par la spécification UEFI) répartit ses métadonnées sur plusieurs secteurs :

• LBA 0 : MBR de protection (type 0xEE) — pour que les outils MBR anciens ne voient pas le disque comme vide

• LBA 1 : en-tête GPT primaire (92 octets, CRC32 de l’en-tête et des entrées)

• LBA 2–33 : 128 entrées de partitions × 128 octets = 16 384 octets

• LBA –33 à –2 : copie de sauvegarde des entrées

• LBA –1 : copie de sauvegarde de l’en-tête GPT

Chaque entrée de partition stocke : GUID de type, GUID d’instance unique, LBA de début/fin, attributs, nom Unicode 36 caractères.

Capacité maximale : avec LBA 64-bit → 2⁶⁴ secteurs × 512 octets ≈ 9,4 Zio.

Show code cell source

Hide code cell source

fig, axes = plt.subplots(1, 2, figsize=(13, 7))
sns.set_theme(style="whitegrid", palette="muted", font_scale=1.1)

# --- MBR ---
ax = axes[0]
ax.set_xlim(0, 4)
ax.set_ylim(0, 1)
ax.set_title("Structure MBR (512 octets)", fontweight="bold", pad=12)
ax.axis("off")

mbr_blocks = [
    (0.0, 0.05, "#c0392b", "Bootstrap\n(446 o)"),
    (0.05, 0.25, "#e67e22", "Entrée 1\n(16 o)"),
    (0.25, 0.45, "#e67e22", "Entrée 2\n(16 o)"),
    (0.45, 0.65, "#e67e22", "Entrée 3\n(16 o)"),
    (0.65, 0.85, "#e67e22", "Entrée 4\n(16 o)"),
    (0.85, 1.00, "#2ecc71", "Sig\n(2 o)"),
]
for (x0, x1, color, label) in mbr_blocks:
    rect = mpatches.FancyBboxPatch((x0 * 4, 0.3), (x1 - x0) * 4, 0.4,
                                    boxstyle="round,pad=0.01", fc=color, ec="white", lw=1.5)
    ax.add_patch(rect)
    ax.text((x0 + x1) / 2 * 4, 0.5, label,
            ha="center", va="center", fontsize=7.5, color="white", fontweight="bold")

ax.text(2, 0.05, "4 partitions primaires max · 2 Tio max · Pas de redondance",
        ha="center", va="bottom", fontsize=8, color="#555555", style="italic")

# --- GPT ---
ax2 = axes[1]
ax2.set_xlim(0, 4)
ax2.set_ylim(0, 1)
ax2.set_title("Structure GPT (secteurs LBA)", fontweight="bold", pad=12)
ax2.axis("off")

gpt_blocks = [
    (0.00, 0.06, "#7f8c8d", "MBR\nprotection"),
    (0.06, 0.12, "#2980b9", "En-tête\nGPT primaire"),
    (0.12, 0.30, "#3498db", "128 entrées\nde partitions"),
    (0.30, 0.70, "#ecf0f1", "Données\ndes partitions"),
    (0.70, 0.88, "#95a5a6", "128 entrées\n(backup)"),
    (0.88, 1.00, "#2c3e50", "En-tête\nGPT backup"),
]
for (x0, x1, color, label) in gpt_blocks:
    rect = mpatches.FancyBboxPatch((x0 * 4, 0.3), (x1 - x0) * 4, 0.4,
                                    boxstyle="round,pad=0.01", fc=color, ec="white", lw=1.5)
    ax2.add_patch(rect)
    fc = "white" if color not in ("#ecf0f1",) else "#333"
    ax2.text((x0 + x1) / 2 * 4, 0.5, label,
             ha="center", va="center", fontsize=7.5, color=fc, fontweight="bold")

ax2.text(2, 0.05, "128 partitions · 9,4 Zio max · CRC32 · Sauvegarde automatique",
         ha="center", va="bottom", fontsize=8, color="#555555", style="italic")

plt.suptitle("Comparaison MBR vs GPT", fontsize=13, fontweight="bold", y=1.01)
plt.tight_layout()
plt.show()

---

Les périphériques bloc sous Linux

Nommage des disques

Linux expose les disques sous /dev/ en tant que périphériques bloc :

Type	Nommage	Exemple
SATA/SCSI (noyau)	/dev/sdX	/dev/sda, /dev/sdb
NVMe	/dev/nvmeXnYpZ	/dev/nvme0n1p1
Virtio (KVM/QEMU)	/dev/vdX	/dev/vda
eMMC	/dev/mmcblkXpY	/dev/mmcblk0p1
Loop	/dev/loopX	/dev/loop0

La lettre (ou le numéro) du disque est assignée par udev à la détection, dans l’ordre de découverte. Elle peut changer entre deux reboots si l’ordre de détection varie. Les UUID et labels sont préférables dans /etc/fstab.

Commandes d’inspection

lsblk : liste les périphériques bloc et leur hiérarchie.

lsblk -o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINT,UUID
# NAME        SIZE TYPE FSTYPE  MOUNTPOINT  UUID
# sda         500G disk
# ├─sda1      512M part vfat    /boot/efi   A1B2-C3D4
# ├─sda2        2G part swap    [SWAP]      1234abcd-...
# └─sda3    497.5G part ext4    /           5678efgh-...
# nvme0n1     1.8T disk
# └─nvme0n1p1 1.8T part xfs    /data       9abc0123-...

blkid : affiche les UUID, labels et types de systèmes de fichiers.

blkid /dev/sda1
# /dev/sda1: UUID="A1B2-C3D4" TYPE="vfat" PARTUUID="00000001-01"

lsblk --json : sortie JSON, utile pour les scripts.

Visualisation : partitions simulées

Show code cell source

Hide code cell source

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.1)

# Table de partitions simulée pour un disque de 500 Go
partitions = pd.DataFrame({
    "Partition":  ["/dev/sda1", "/dev/sda2", "/dev/sda3", "/dev/sda4", "Libre"],
    "Début (Go)": [0,     0.5,   2.5,  252.5, 452.5],
    "Taille (Go)":[0.5,   2.0,  250.0, 200.0,  47.5],
    "Type":       ["EFI System", "Linux swap", "ext4 /", "xfs /home", "Non alloué"],
    "Couleur":    ["#f39c12", "#95a5a6", "#2980b9", "#27ae60", "#ecf0f1"],
})

fig, ax = plt.subplots(figsize=(12, 3))
ax.set_xlim(0, 500)
ax.set_ylim(0, 1)
ax.set_xlabel("Position sur le disque (Go)")
ax.set_title("/dev/sda — 500 Go — Table GPT simulée", fontweight="bold")
ax.set_yticks([])

for _, row in partitions.iterrows():
    rect = mpatches.FancyBboxPatch(
        (row["Début (Go)"], 0.15), row["Taille (Go)"], 0.7,
        boxstyle="round,pad=0.5", fc=row["Couleur"], ec="white", lw=2
    )
    ax.add_patch(rect)
    if row["Taille (Go)"] > 10:
        ax.text(
            row["Début (Go)"] + row["Taille (Go)"] / 2, 0.5,
            f"{row['Partition']}\n{row['Type']}\n{row['Taille (Go)']} Go",
            ha="center", va="center", fontsize=8, fontweight="bold",
            color="#222" if row["Couleur"] in ("#ecf0f1", "#95a5a6") else "white"
        )
    else:
        ax.text(
            row["Début (Go)"] + row["Taille (Go)"] / 2, 1.02,
            f"{row['Partition']}\n{row['Taille (Go)']} Go",
            ha="center", va="bottom", fontsize=7, color="#555"
        )

plt.tight_layout()
plt.show()

---

Partitionnement avec fdisk et gdisk

fdisk — disques MBR et GPT (mode interactif)

fdisk est l’outil classique, maintenant capable de gérer GPT depuis util-linux 2.25.

# Lancer fdisk sur un disque vierge
sudo fdisk /dev/sdb

# Dialogue interactif simulé :
# Welcome to fdisk (util-linux 2.38.1).
# Device does not contain a recognized partition table.
# Created a new DOS (MBR) disklabel.
#
# Command (m for help): g          ← créer une table GPT
# Created a new GPT disklabel.
#
# Command (m for help): n          ← nouvelle partition
# Partition number (1-128, default 1): 1
# First sector (2048-..., default 2048): [Entrée]
# Last sector ...: +512M            ← EFI System 512 Mio
#
# Created a new partition 1 of type 'Linux filesystem'.
# Partition #1 contains a vfat signature.
#
# Command (m for help): t          ← changer le type
# Selected partition 1
# Partition type or alias (type L to list all): 1   ← EFI System
#
# Command (m for help): n
# Partition number (2-128, default 2): 2
# First sector (default): [Entrée]
# Last sector ...: +2G
#
# Command (m for help): t
# Partition type or alias: 19       ← Linux swap
#
# Command (m for help): n
# Partition number (3-128, default 3): 3
# First sector (default): [Entrée]
# Last sector ...: [Entrée]         ← reste du disque
#
# Command (m for help): w          ← écrire et quitter
# The partition table has been altered.
# Calling ioctl() to re-read partition table.
# Syncing disks.

gdisk — GPT uniquement

gdisk est l’équivalent GPT-natif de fdisk. Son interface est identique, mais il refuse de créer des tables MBR.

sudo gdisk /dev/sdc
# GPT fdisk (gdisk) version 1.0.9
#
# Partition table scan:
#   MBR: not present
#   BSD: not present
#   APM: not present
#   GPT: not present
#
# Creating new GPT entries in memory.
#
# Command (? for help): o          ← créer une table GPT vierge
# This option deletes all partitions and creates a new protective MBR.
# Proceed? (Y/N): Y
#
# Command (? for help): n
# Partition number (1-128): 1
# First sector: [Entrée]
# Last sector: +100G
# Hex code or GUID (L to show codes, Enter = 8300): 8300   ← Linux filesystem
#
# Command (? for help): p          ← afficher la table
# Disk /dev/sdc: ...
# Number  Start (sector)  End (sector)  Size     Code  Name
#    1         2048       209717247     100.0 GiB 8300  Linux filesystem
#
# Command (? for help): w
# Final checks complete. About to write GPT data. THIS WILL OVERWRITE EXISTING PARTITIONS!!
# Do you want to proceed? (Y/N): Y
# OK; writing new GUID partition table (GPT) to /dev/sdc.

Astuce : rescanner sans reboot

Après une modification de table de partitions, informez le noyau sans redémarrer : sudo partprobe /dev/sdb ou sudo udevadm trigger

---

Partitionnement avec parted

parted est l’outil non-interactif de référence, particulièrement adapté aux scripts d’automatisation.

Syntaxe non-interactive

# Créer une table GPT
sudo parted -s /dev/sdd mklabel gpt

# Créer la partition EFI (1 Mio → 513 Mio — alignement optimal)
sudo parted -s /dev/sdd mkpart primary fat32 1MiB 513MiB
sudo parted -s /dev/sdd set 1 esp on

# Créer la partition swap
sudo parted -s /dev/sdd mkpart primary linux-swap 513MiB 2561MiB

# Créer la partition racine
sudo parted -s /dev/sdd mkpart primary ext4 2561MiB 100%

# Vérifier l'alignement
sudo parted -s /dev/sdd align-check optimal 1
# 1 aligned

# Afficher la table
sudo parted -s /dev/sdd print
# Model: ...
# Disk /dev/sdd: 500GB
# Partition Table: gpt
# Disk Flags:
#
# Number  Start    End     Size     File system     Name     Flags
#  1      1049kB   538MB   537MB    fat32           primary  boot, esp
#  2      538MB    2685MB  2147MB   linux-swap(v1)  primary  swap
#  3      2685MB   500GB   497GB    ext4            primary

Script de partitionnement automatisé

#!/usr/bin/env bash
# Partitionner /dev/sde selon un profil serveur
set -euo pipefail

DISK="/dev/sde"

parted -s "$DISK" mklabel gpt
parted -s "$DISK" mkpart ESP fat32   1MiB   513MiB
parted -s "$DISK" set 1 esp on
parted -s "$DISK" mkpart swap linux-swap 513MiB 4609MiB
parted -s "$DISK" mkpart root ext4 4609MiB 100%

mkfs.fat -F32 -n EFI "${DISK}1"
mkswap -L swap "${DISK}2"
mkfs.ext4 -L root "${DISK}3"

echo "Partitionnement terminé."

Commandes destructrices

parted, fdisk, mkfs et mkswap modifient de façon irréversible la structure du disque. Toujours vérifier le nom du périphérique cible avec lsblk avant exécution. Une confusion /dev/sda / /dev/sdb peut effacer le système en production.

---

Swap

Le swap est un espace disque utilisé par le noyau pour déplacer des pages mémoire inactives. Il peut prendre la forme d’une partition dédiée ou d’un fichier.

Partition swap

# Initialiser une partition comme swap
sudo mkswap -L swap /dev/sda2
# Setting up swapspace version 1, size = 2 GiB (2147479552 bytes)
# LABEL=swap, UUID=abcd1234-...

# Activer le swap
sudo swapon /dev/sda2

# Désactiver
sudo swapoff /dev/sda2

Fichier swap

# Créer un fichier swap de 4 Go
sudo dd if=/dev/zero of=/swapfile bs=1M count=4096 status=progress
# 4096+0 records in
# 4096+0 records out
# 4294967296 bytes (4.3 GB, 4.0 GiB) copied

sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

Priorités swap

Lorsque plusieurs espaces swap coexistent, le noyau utilise en priorité ceux avec la valeur la plus haute (pri=). Utile pour préférer un SSD rapide.

# Activer avec une priorité
sudo swapon -p 10 /dev/sda2       # priorité haute
sudo swapon -p 1  /swapfile       # priorité basse (débordement)

# État actuel
swapon --show
# NAME       TYPE  SIZE  USED PRIO
# /dev/sda2  partition 2G  0B    10
# /swapfile  file      4G  0B     1

Paramètre vm.swappiness

# Lire la valeur courante (0–100, défaut 60)
cat /proc/sys/vm/swappiness

# Réduire la tendance à swapper (serveur avec beaucoup de RAM)
sudo sysctl vm.swappiness=10

# Persistance dans /etc/sysctl.d/
echo "vm.swappiness=10" | sudo tee /etc/sysctl.d/99-swap.conf

---

Informations sur les disques

smartctl — surveillance SMART

SMART (Self-Monitoring, Analysis and Reporting Technology) est intégré dans tous les disques modernes. Il expose des attributs de santé permettant de prédire les pannes imminentes.

# Test court (2 minutes)
sudo smartctl -t short /dev/sda

# Résultats du test
sudo smartctl -a /dev/sda
# SMART overall-health self-assessment test result: PASSED
# ...
# ID# ATTRIBUTE_NAME          FLAG  VALUE WORST THRESH TYPE
#   5 Reallocated_Sector_Ct   0x33   100   100     5  Pre-fail
#   9 Power_On_Hours          0x32    98    98     0  Old_age
# 187 Reported_Uncorrect      0x32   100   100     0  Old_age    0
# 197 Current_Pending_Sector  0x32   100   100     0  Old_age    0
# 198 Offline_Uncorrectable   0x30   100   100     0  Old_age    0

Les attributs critiques à surveiller : Reallocated_Sector_Ct (secteurs réalloués), Current_Pending_Sector (secteurs instables), Offline_Uncorrectable. Une valeur non nulle est un signal d’alarme.

# NVMe : interface dédiée
sudo smartctl -a /dev/nvme0
# NVMe Log Namespace id 1 (current)
# Critical Warning:          0x00
# Temperature:               38 Celsius
# Available Spare:           100%
# Percentage Used:           0%
# Data Units Read:           1,234,567
# Data Units Written:        987,654

hdparm — paramètres ATA

# Vitesse de lecture séquentielle (benchmark simple)
sudo hdparm -tT /dev/sda
#  Timing cached reads:    12345 MB in  2.00 seconds = 6172 MB/sec
#  Timing buffered disk reads: 456 MB in  3.02 seconds = 151 MB/sec

# Informations sur le disque
sudo hdparm -I /dev/sda | grep -E "Model|Serial|Speed|capacity"

lshw -class disk

sudo lshw -class disk
#   *-disk
#        description: ATA Disk
#        product: Samsung SSD 870
#        vendor: Samsung
#        logical name: /dev/sda
#        size: 500GiB (536GB)
#        capabilities: partitioned partitioned:gpt

Détection avec lsblk — sortie structurée

Show code cell source

Hide code cell source

import json
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
import seaborn as sns

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.1)

# Simulation de la sortie de lsblk --json
lsblk_data = {
    "blockdevices": [
        {"name": "sda", "size": "500G", "type": "disk", "children": [
            {"name": "sda1", "size": "512M", "type": "part", "fstype": "vfat",    "mountpoint": "/boot/efi"},
            {"name": "sda2", "size": "2G",   "type": "part", "fstype": "swap",    "mountpoint": "[SWAP]"},
            {"name": "sda3", "size": "497.5G","type": "part", "fstype": "ext4",   "mountpoint": "/"},
        ]},
        {"name": "nvme0n1", "size": "1.8T", "type": "disk", "children": [
            {"name": "nvme0n1p1", "size": "1.8T", "type": "part", "fstype": "xfs", "mountpoint": "/data"},
        ]},
        {"name": "sdb", "size": "2T", "type": "disk", "children": []},
    ]
}

type_colors = {
    "disk": "#2c3e50",
    "part": "#3498db",
    "vfat": "#f39c12",
    "swap": "#95a5a6",
    "ext4": "#27ae60",
    "xfs":  "#8e44ad",
}

fig, ax = plt.subplots(figsize=(10, 5))
ax.axis("off")
ax.set_title("Arbre lsblk simulé — périphériques bloc", fontweight="bold", pad=12)

y = 0.95
dy = 0.10

for dev in lsblk_data["blockdevices"]:
    color = type_colors.get(dev["type"], "#7f8c8d")
    ax.text(0.02, y, f"■ {dev['name']}  [{dev['size']}]  {dev['type']}",
            transform=ax.transAxes, fontsize=10, fontweight="bold",
            color=color, va="top", family="monospace")
    y -= dy
    for part in dev.get("children", []):
        fstype = part.get("fstype", "—")
        mount  = part.get("mountpoint") or "—"
        pcolor = type_colors.get(fstype, "#3498db")
        ax.text(0.08, y,
                f"└─ {part['name']}  [{part['size']}]  {fstype:<8}  {mount}",
                transform=ax.transAxes, fontsize=9,
                color=pcolor, va="top", family="monospace")
        y -= dy * 0.85

plt.tight_layout()
plt.show()

Partitions montées en temps réel

import psutil
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.1)

parts = psutil.disk_partitions(all=False)
rows = []
for p in parts:
    try:
        usage = psutil.disk_usage(p.mountpoint)
        rows.append({
            "Périphérique": p.device,
            "Point de montage": p.mountpoint,
            "FS": p.fstype,
            "Total (Go)": round(usage.total / 1e9, 1),
            "Utilisé (Go)": round(usage.used / 1e9, 1),
            "Libre (Go)": round(usage.free / 1e9, 1),
            "Utilisation (%)": usage.percent,
        })
    except PermissionError:
        pass

df = pd.DataFrame(rows)
print(df.to_string(index=False))

Périphérique                 Point de montage      FS  Total (Go)  Utilisé (Go)  Libre (Go)  Utilisation (%)
   /dev/sda3                                /    ext4        67.2          43.2        20.6             67.7
   /dev/sda4                            /home    ext4       118.2         104.7         7.5             93.3
   /dev/sda5                      /media/data    ext4        56.0          45.8         7.3             86.2
   /dev/sda1                        /boot/efi    vfat         0.5           0.0         0.5              2.2
   /dev/sdb1 /media/loc/Debian 13.2.0 amd64 n iso9660         0.8           0.8         0.0            100.0

---

Résumé

Ce chapitre couvre la chaîne complète : de la physique du disque (LBA, alignement 4K) aux outils de partitionnement (fdisk, gdisk, parted) et d’inspection (lsblk, blkid, smartctl).

Points essentiels à retenir :

• MBR : 4 partitions, 2 Tio max, pas de redondance. GPT : 128 partitions, 9,4 Zio, CRC32 et sauvegarde.

• Toujours aligner les partitions sur des multiples de 1 Mio pour les disques Advanced Format.

• parted -s est privilégié pour les scripts ; fdisk/gdisk pour l’usage interactif.

• Préférer les UUID aux noms de périphériques dans /etc/fstab — le nom peut changer au reboot.

• smartctl permet une surveillance proactive : un compteur Reallocated_Sector_Ct non nul justifie un remplacement planifié.

• Le swap peut coexister en partition et en fichier, avec des priorités distinctes contrôlées par swapon -p.

Pour aller plus loin

Le chapitre suivant traite des systèmes de fichiers (ext4, XFS, Btrfs) qui occupent les partitions créées ici. LVM (chapitre 7) et RAID logiciel (chapitre 8) s’appuient sur ces mêmes périphériques bloc pour apporter flexibilité et redondance.