xv6-riscv/notes/next-move.md

Que pourrions-nous faire de nos dix doigts ?
Une fois qu'on voudra se lancer dans du code, après avoir lu le livre (en entier ou pas) ou vu les vidéos, quelles sont nos possibilités ?

# Idées pour la suite

1. Se contenter de xv6 pour apprendre le dév bas niveau et s'arrêter là.
   Éventuellement jouer à faire quelques optimisations, ajouter des syscalls, etc.
   Cette option permet d'apprendre sans trop forcer.

2. Contribuer à un projet existant, utilisé au-delà de l'aspect pédagogique.
   Cette option peut être complémentaire à une autre.
   C'est l'option qui est la plus sociale, notre travail est directement utile à d'autres.

   L'étude de ces systèmes est intéressante peu importe ce qu'on décide de faire par ailleurs.
   On plonge occasionnellement dans leur code et on apprend.
   Par exemple, Plan9 est conceptuellement le système le plus intéressant et doit être étudié.

3. Tenter de conquérir le monde.

# Contribution à un projet existant

L'idée serait de ne pas développer tout un OS, mais seulement contribuer à un projet.
Soit de niche : Minix, DuskOS (c'est du Forth), Plan9, Fuchsia, L4, etc.
Soit un poil plus utilisé : un BSD, un OS embarqué type Zephyr, Linux, etc.

Que faire avec ces systèmes ? Des pistes :

- Minix : ajouter des parties manquantes pour le rendre plus proche des fonctionnalités d'un OS moderne.
  Il manque actuellement quelques fonctionnalités assez majeures.
  Exemple : pas de multicœur, USB incomplet (de mémoire), etc.

- Sur OpenBSD :

  - Une sortie audio HDMI.
  - Du bluetooth.
  - Un système de fichiers avec un journal (type HAMMER2).
    Si j'en crois des gens sur reddit, c'est un gros travail à cause du VFS qui est un peu simpliste pour un FS sophistiqué.

- Plan9 et Minix : améliorer la prise en charge du matériel.

- Linux : pledge et unveil.

# Conquête du monde (en toute humilité)

Cette dernière option implique de développer un OS qui n'a encore jamais été fait, pour se lancer un défi.
Ma proposition serait de faire un OS à micro-noyau en Scheme.

Intéressant, divertissant et on obtient instantanément une aura de fou, mais le projet est bien plus complexe que le reste.
On en apprendra beaucoup tout en ayant un OS qui pourrait intéresser des gens.

Concernant les fonctionnalités qui m'intéressent bien :

- Une architecture à micro-noyau qui permette :

  - L'écriture de pilotes en mode utilisateur.
    Ça se fait déjà sur certains systèmes (comme Fuchsia), donc ce n'est pas insurmontable.

  - La mise à jour en live du système, sans redémarrage.
    Comme avec Minix par exemple, sauf que si on a un REPL à base de Scheme en espace noyau… le niveau de gloire augmente.

- Un développement unifié de tout le système façon BSD.
  C'est le contraire du développement chaotique côté Linux où tous les programmes sont écrits différemment.

- Reprendre masse de concepts de Plan9.
  En particulier, voir le concept de « tout est fichier » et comment cela s'intègre pour des actions complexes sur des périphériques.
  De même, le protocole 9P ou encore la gestion du partage de ressources (namespace) des processus méritent de l'attention.

- Reprendre quelques concepts de DuskOS.
  En particulier, DuskOS implémente HAL, une couche d'abstration pour générer des instructions binaires.
  Cette abstraction fournit une API pour que des compilateurs puissent s'y greffer et ne pas eux-même gérer la dernière étape de compilation.
  Le développeur principal a fait un compilateur C et Scheme avec cette abstraction.
  Cette factorisation de la dernière étape des compilateurs rend le code plus concis.

- Une couche de compatibilité avec BSD (voire Linux) pour porter des outils et en faire beaucoup plus rapidement un système utilisable « pour de vrai ».

- Avoir le code noyau en Scheme.
  (Ou du Forth, sans doute avec DuskOS car c'est déjà là et activement développé.)

  (Le Scheme peut arriver après une première implémentation en C.)

  Le Scheme est très intéressant de par sa simplicité (S-expressions) et son extensibilité (macros).
  Le langage peut évoluer en DSL pour au final se débarasser entièrement de tout autre langage dans les sources.

  Prenons un exemple.
  Il est possible d'écrire un programme qui génère du C ou de l'assembleur.
  /!\ Je ne parle pas de compiler un programme, mais d'écrire un programme qui écrit du C ou de l'assembleur.
  Un exemple proche de ce dont je parle est LCC, une sorte de Lisp pour écrire du C :
    https://github.com/saman-pasha/LCC
  Notre version pourrait écrire soit du C pour profiter des optimisations des compilateurs C, soit de l'assembleur pour éviter toute dépendance au C.
  Les macros Scheme permettraient de créer un DSL pour générer à la fois du C et des instructions au linker, par exemple.

  Avantages :

  - Code plus simple qu'en C (ou assembleur).
    Certains pièges du C sont évités.
    Pas besoin de jouer avec le préprocesseur C et sa syntaxe inélégante.

  - Le code noyau profite entièrement de l'environnement du langage hôte.
    On pourrait ajouter des vérifications de type si on le souhaite.

  - Performances optimales, le code noyau en Scheme n'est qu'une surcouche à l'assembleur.
    Le noyau ne continent que le code dont il a besoin.

  - Ce principe pourrait être réutilisé dans du code beaucoup plus complexe, comme les pilotes des périphériques.

  Un interpréteur pourra éventuellement être implémenté dans un second temps.
  L'idée serait d'améliorer le système en direct pendant qu'il tourne.

  - L'interpréteur sera également un compilateur pour être performant.
    L'implémentation peut fortement s'inspirer de Forth pour ajouter de nouvelles fonctions à la volée.

  - Cet interpréteur n'implémentera que ce qui est nécessaire pour un noyau, inutile de dégainer R7RS.
    Un noyau n'a pas besoin d'optimisations poussées.
    De même, le ramasse-miettes peut être simpliste, un micro-noyau effectue peu d'actions.

Il faut reprendre les bonnes idées.
Il faut lire le code des systèmes actuels pour apprendre et s'inspirer.

# Liens qui pourraient s'avérer importants pour la suite

- Running Scheme On Bare Metal (Experience Report):
  https://doc.lagout.org/programmation/Lisp/Scheme/An%20Introduction%20to%20Scheme%20and%20its%20Implementation.pdf

- Un papier qui indique comment faire des micro-noyaux rapides :
  https://ipads.se.sjtu.edu.cn/_media/publications/skybridge-eurosys19.pdf

  L'idée générale est de limiter au maximum les changements de contexte.
  Cela se fait sans mal sur x86 grâce à des instructions spécialisées, à voir si on peut l'adapter sur RISC-V.

- Introduction à x86 par les gens qui font ffmpeg :
  https://github.com/FFmpeg/asm-lessons

# NOTES EN VRAC SUR FUCHSIA

Le noyau Zircon (de Fuchsia, OS de Google), en quelques mots :

- Reprend quelques concepts de Plan9, par exemple le fait qu'un processus enfant n'a pas accès à tout par défaut, seulement à ce que le parent lui donne.
  Un processus est nommé « composant » dans la terminologie de Fuchsia, car le concept s'éloigne un peu de celui de processus.
  Un processus dans le monde d'Unix est fortement corrélé à l'utilisateur qui le lance, et l'utilisateur est le centre de l'attention en ce qui concerne la sécurité.
  Si un utilisateur a les droits sur un répertoire, la totalité des processus qu'il lance peuvent accéder au contenu du répertoire.
  Dans Fuchsia, les processus ont eux-mêmes des droits particuliers (« capabilities ») et reçoivent un sous-ensemble des droits de l'utilisateur.

  NOTE : à mon faible niveau de connaissances sur Plan9, ça ressemble quand même fortement à ce que fait Google dans Fuchsia.
         Plan9 ne se complexifie pas la vie autant que Fuchsia puisque pour Plan9 tout est fichier.
         Plan9 conserve donc la palme de l'OS le plus simple (et de très loin).

- Tout n'est pas « fichiers » mais plutôt « handles » c-à-d un objet qui représente ce qu'on peut faire avec.
  En gros, ça va plus loin que simplement ouvrir/fermer/lire/écrire.
  D'un point de vue de l'utilisateur, c'est bien entendu une petite complexité supplémentaire.

- Utilise un mécanisme d'IPC où tous les messages ont une signature précise.
  On définit finement la structure des messages que les processus s'échangent.
  Le langage pour décrire ces messages IPC s'appelle FIDL.
  Cela remplace une partie des appels système assez classiques qu'on connaît sous Unix par des échanges de messages structurés (par de simples tableaux d'octets).

- Vidéo youtube qui présente certains aspects de Fuchsia :
  "An IPC Language For The Whole Operating System" by Ian McKellar (Strange Loop 2022)
  https://www.youtube.com/watch?v=ApHpmA1k73k

  NOTE : dans les commentaires, un gars qui a visiblement bossé sur L4 dit qu'il est content que finalement quelqu'un ait regardé la doc de L4.
         L4 qui, je suppose, implique également des capabilities, handles, FIDL, etc.
         En gros, Fuchsia n'a rien inventé.