C'est quoi un OS,
vraiment ?

Prerequis

• Comprehension basique de Linux
  • Shell
• Programmation en C

Hello o/

L'Architecture Generale d'un OS

Imaginez un OS (Operating System) comme une grande ville. Les system calls (comme write(2) et ptrace(2)) sont les routes principales qui permettent aux utilisateurs d'interagir avec le systeme. Ces appels sont les portes d'entree vers les fonctionnalites du kernel.

Le Kernel : Le Programme Privilegie

Le kernel est le programme qui s'execute en premier sur votre machine. Il a tous les droits, accedant directement au hardware. Son binaire se trouve dans /vmlinuz ou /boot/vmlinuz.

Lors du demarrage, le kernel initialise le systeme et cree le premier processus : sur UNIX, c'est init, sur Linux, c'est systemd. Voici un petit extrait de code pour illustrer un syscall simple :

#include <unistd.h>

int main() {
    const char *msg = "Hello, OS!\n";
    write(1, msg, 13); // 1 est le file descriptor pour stdout
    return 0;
}

Gestion de la Memoire : Les Adresses Virtuelles

L'OS gere la memoire avec des adresses virtuelles. Pensez-y comme une bibliotheque ou chaque livre (processus) a sa propre etagere (espace virtuel). Le MMU (Memory Management Unit) et la TLB (Translation Lookaside Buffer) sont les bibliothecaires qui traduisent les demandes d'un livre en une adresse physique.

La gestion de la memoire se divise en deux : pagination et segmentation. La pagination decoupe la memoire en blocs, reduisant la fragmentation externe, tandis que la segmentation isole des parties d'un processus en segments distincts.

  Processus A           Processus B
  ┌─────────────┐        ┌─────────────┐
  │ addr virtuelle│       │ addr virtuelle│
  │  0x0000_1000 │       │  0x0000_1000 │
  └──────┬──────┘        └──────┬──────┘
         │                      │
         │    MMU + TLB          │
         │  (traduction)         │
         ▼                      ▼
  ┌──────────────────────────────────────┐
  │         MEMOIRE PHYSIQUE (RAM)       │
  │  0x1A00_0000   │   0x2B00_0000       │
  │  (frame A)     │   (frame B)         │
  └──────────────────────────────────────┘

Securite et Privileges : Espace Kernel et Espace Utilisateur

L'espace kernel et l'espace utilisateur sont separes. L'utilisateur n'a acces a la memoire kernel que par des syscalls. Le kernel a tous les droits, tandis que l'utilisateur doit se contenter de permissions limitees. Par exemple, une fonction simple comme printf passe par write(2) :

#include <stdio.h>

int main() {
    printf("Hello, Kernel!\n"); // Appel indirect a write(2)
    return 0;
}

  ┌──────────────────────────────────────────┐
  │           ESPACE UTILISATEUR            │
  │   programme C   printf()   libc         │
  │                    │                    │
  │                syscall (write)          │
  └────────────────────┼─────────────────── ┘
                       │  (transition ring3 -> ring0)
  ┌────────────────────▼─────────────────── ┐
  │              ESPACE KERNEL               │
  │   sys_write   │   drivers   │   MM       │
  │                                          │
  │          acces direct hardware           │
  └──────────────────────────────────────────┘

Types de Kernels : Monolithique, Micro, Hybride

Voici les types principaux de kernels :

Modules Systeme : Chargement a Chaud

Le concept de modules systeme vient de Mach. Chaque couche / fonction / driver de l'OS est ecrit independamment, comme des briques dans un mur. Les modules Linux sont des file objects qui peuvent etre lies dynamiquement au runtime, que ce soit pendant le boot ou sur demande.

Pour charger un module a la volee :

sudo modprobe nom_du_module

Pour lister les modules actuellement charges :

lsmod

  ┌──────────────────────────────────────────┐
  │          KERNEL MONOLITHIQUE (Linux)     │
  │                                          │
  │  ┌──────────┐  ┌──────────┐  ┌────────┐ │
  │  │ module   │  │ module   │  │ module │ │  <- charges dynamiquement
  │  │ reseau   │  │ fs ext4  │  │ USB    │ │     (modprobe / rmmod)
  │  └──────────┘  └──────────┘  └────────┘ │
  │                                          │
  │  noyau de base (scheduler, MM, syscalls) │
  └──────────────────────────────────────────┘

Conclusion

Voila, vous avez maintenant un apercu de l'architecture d'un OS. Les prochains articles iront plus loin sur la securite et la technique.

Merci pour votre lecture !