IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

Maestro : un noyau et un système d'exploitation en Rust compatible avec Linux
Qui se veut léger pour être utilisable dans la vie de tous les jours

Le , par Jade Emy

61PARTAGES

10  0 
Maestro, un noyau et un système d'exploitation de type Unix écrit à partir de zéro en Rust. Son objectif est que Maestro soit "léger et suffisamment compatible avec Linux pour être utilisable dans la vie de tous les jours."

Introduction
Grâce à l'internet, je peux apprendre comment fonctionnent la plupart des choses qui m'intéressent. Cependant, une chose est restée longtemps un mystère pour moi : les ordinateurs.

Les ordinateurs sont parmi les outils les plus complexes que l'humanité ait jamais construits. Ce sont des merveilles d'ingénierie que nous tenons pour acquises parce que nous les utilisons dans notre vie quotidienne.

J'aime me plonger dans la complexité et j'aime apprendre par la pratique. De plus, je passe beaucoup de temps sur l'ordinateur. Ne serait-ce pas génial d'avoir un système que je connaîtrais de A à Z et que je pourrais personnaliser autant que je le souhaite pour qu'il corresponde à mes attentes ?

C'est pourquoi j'ai décidé de créer Maestro. Un système d'exploitation de type Unix qui se veut léger et suffisamment compatible avec Linux pour être utilisable dans la vie de tous les jours.
Un peu d'histoire

Le premier commit du noyau date du 22 décembre 2018, à 3:18 du matin (le meilleur moment pour écrire du code, bien sûr). Il s'agissait à l'origine d'un projet scolaire.

Il a d'abord été implémenté en utilisant le langage C et a continué à l'être pendant environ un an et demi, jusqu'à ce que la base de code devienne trop difficile à garder propre.

À ce moment-là, il a décidé de passer à Rust (son premier projet dans ce langage), qui présentait plusieurs avantages :

  • Reprendre le projet depuis le début, en utilisant les leçons tirées des erreurs précédentes
  • Être un peu plus innovant que d'écrire un noyau Linux en C. Après tout, il suffit d'utiliser Linux à ce moment-là.
  • Utiliser la sécurité du langage Rust pour surmonter certaines difficultés de la programmation du noyau. L'utilisation du système de typage de Rust permet de transférer une partie de la responsabilité de la sécurité de la mémoire du programmeur au compilateur.

Dans le développement du noyau, le débogage est très difficile pour plusieurs raisons :

  • La documentation est souvent difficile à trouver, et les implémentations BIOS peuvent être défectueuses (plus souvent qu'on ne le pense).
  • Au démarrage, le noyau a un accès total à la mémoire et est autorisé à écrire là où il ne devrait pas (son propre code, par exemple).
  • Le dépannage des fuites de mémoire n'est pas facile. Des outils tels que valgrind ne peuvent pas être utilisés
  • gdb peut être utilisé avec QEMU et VMWare, mais le noyau peut avoir un comportement différent lorsqu'il est exécuté sur un émulateur ou une machine virtuelle différents. En outre, ces émulateurs peuvent ne pas prendre en charge gdb (par exemple VirtualBox).
  • Certaines fonctionnalités du support de gdb dans QEMU ou VMWare sont manquantes (comme Record and Replay) et gdb peut même parfois se planter.

Tous ces problèmes sont autant de raisons d'utiliser un langage à mémoire sûre, afin de les éviter autant que possible.

Globalement, l'utilisation de Rust dans le noyau a permis la mise en place de nombreuses protections. Et c'est peut-être, la meilleure décision prise pour ce projet.


L'état actuel du projet

Maestro est un noyau monolithique, ne supportant pour l'instant que l'architecture x86 (en 32 bits).

À l'heure où ces lignes sont écrites, 135 des 437 appels système de Linux (environ 31 %) sont plus ou moins implémentés. Le projet compte 48 800 lignes de code réparties dans 615 fichiers (tous dépôts confondus, comptés à l'aide de la commande cloc).

Le système d'exploitation comporte actuellement les composants suivants, outre le noyau :

  • Solfège : un système de démarrage et un gestionnaire de démons (similaire à systemd, mais plus léger)
  • maestro-utils : commandes utilitaires du système
  • blimp : un gestionnaire de paquets
  • Et d'autres composants disponibles sur github

Jusqu'à présent, les logiciels tiers suivants ont été testés et fonctionnent sur le système d'exploitation :

  • musl (bibliothèque standard C)
  • bash
  • Quelques commandes GNU coreutils telles que ls, cat, mkdir, rm, rmdir, uname, whoami, etc...
  • neofetch (une version patchée, puisque le neofetch original ne connaît pas ce système d'exploitation)


Quelles sont les prochaines étapes ?

Le nettoyage de la base de code et l'optimisation des performances sont en cours. Comme le système d'exploitation a commencé comme un projet d'école, son développeur a dû prendre des raccourcis pour le terminer à temps. Mais il est maintenant temps de rembourser la dette technique accumulée.

Quelques fuites de mémoire traînent également et doivent être corrigées. L'optimisation des performances fera probablement l'objet d'articles de blog.

Le prochain pas en avant sera de faire fonctionner pleinement le gestionnaire de paquets sur le système d'exploitation. Pour ce faire, certaines fonctionnalités sont nécessaires :

  • La prise en charge des réseaux, qui est actuellement en cours de développement. Elle fera probablement l'objet de nombreux articles
  • Le support des bibliothèques partagées. Cela ne fonctionne pas actuellement car cela nécessite de mapper des fichiers directement en mémoire, ce qui n'est pas actuellement supporté par l'implémentation de l'appel système mmap sur le kernel.

Après cela, on pourrait installer (sans douleur) et tester des programmes tels que les compilateurs (gcc/g++, clang, rustc), make, Git, Vim, etc... Et ensuite développer le noyau tout en l'utilisant !

Le développement du noyau suit en grande partie une procédure simple :

  • 1 : Exécuter un programme sur le noyau et voir s'il fonctionne correctement
  • 2 : S'il ne fonctionne pas, alors :
    • 3 : Exécuter le programme en imprimant les appels système et rechercher le premier appel système qui pose problème (non implémenté ou bogué).
    • 4 : Implémentez ou corrigez l'appel système en question.
    • 5 : Passez à l'étape 1

  • 6 : Sinon : Bravo !

Plus il y a de programmes fonctionnant correctement sur le noyau, plus celui-ci devient stable et complet !

Testez-le vous-même !

Avertissement : Il est important de noter que le système d'exploitation est encore à un stade de développement très précoce et qu'il est très instable. Je déconseille d'essayer de l'installer sur une machine contenant des données importantes.

Jusqu'à présent, il a été testé principalement sur QEMU, VMWare et VirtualBox.
Il y a deux façons d'installer le système d'exploitation :


L'ISO fournit un programme d'installation pour le système d'exploitation. On peut l'utiliser sur QEMU, VMWare ou VirtualBox par exemple.

Vous devez exécuter l'ISO avec suffisamment de mémoire vive (1 Go devrait être plus que suffisant).

Une telle quantité de mémoire est nécessaire parce que les paquets à installer sont stockés dans la RAM (sur l'initramsfs) au lieu du disque. C'est actuellement la meilleure méthode, car le système d'exploitation n'est pas encore capable de lire lui-même sur une clé USB ou un CD-ROM ; il s'appuie donc sur le chargeur de démarrage pour ce faire.
Source : Maestro - Introduction

Et vous ?

Quel est votre avis sur le sujet ?

Voir aussi :

Rust dans le noyau Linux: un projet prometteur, mais pas sans complications. La communauté dresse un bilan lors de l'édition 2023 du Kernel Maintainers Summit

Microsoft travaille à réécrire le code du kernel de Windows responsable de la gestion des fenêtres en langage Rust, considéré comme candidat idéal à l'abandon des langages C et C++

Rust peut faciliter l'arrivée de nouveaux contributeurs dans les projets open source tout en réduisant les vulnérabilités. Sans eux, le projet finira par devenir inactif, d'après un sujet de recherche

Une erreur dans cette actualité ? Signalez-nous-la !

Avatar de prisme60
Membre régulier https://www.developpez.com
Le 12/01/2024 à 15:03
J'ai vu cette actualité dans le Week in Rust de cette semaine https://this-week-in-rust.org/blog/2024/01/10/this-week-in-rust-529/, mais comme le développeur le dit lui même, ce n'est pas encore fini, et que comme c'était un projet scolaire, il a du prendre quelques raccourcis pour finir à temps et présenter son travail.

En tout cas, on ne peut que constater que le Rust permet une gestion plus facile sur les gros projets (refactoring moins compliqué et plus sécurisé).
3  0