Mantrix Edition Red Serveur - Operating System Projet

Merkii

Waw sa change totalement de la première interface au niveau couleurs (principalement^^).
J'ai hâte!

Vous verrez d ici quelques semaines ou mois :p je suis ouvert à toute propositions de modifications

Deux nouvelles images aujourd'hui et des news :

L'interface LightUp a été mise à jour et aborde (avec des bugs pour l'heure...) une gestion de 2 bureaux virtuels (avec un code donné par "TooDesk" : le programme portera donc ce nom).
Sinon voici les ajouts (total de 93 Heures déjà !) :

- Les fonds d'écrans sont toujours en mode IVP et s'incorpore tout seul dans l'IUG.
- Le Gestionnaire d'utilisateurs permet désormais de créer des utilisateurs selon son élévation (niveau de sécurité de compte) : les utilisateurs simples ne peuvent pas créer de nouveaux utilisateurs. Les modérateurs peuvent en créer avec un maximum d'élévation 2 (modérateur). Les administrateurs peuvent tout faire. Un Modérateur ne pourra pas supprimer ou modifier un compte plus haut niveau sécurité que lui (ordre : 0<1<2<3).
- Mantrix détecte si vous êtes connectés à internet, si oui vous pourrez voir les infos TCP/IP. Sinon non il vous proposera une réparation (non disponible encore).
- Mantrix, pour la première fois (en parallèle aux autres*) va incorporer un Kernel VB d'ici 1 an (le temps de la refonte du Kernel pour l'adapter à Mantrix...et on sera 9 à bosser desuus...le plus dur sera les Pilotes/Drivers et surtout les bases réseaux (TCP:IP pure)).
- Mantrix incorporera aussi (en cours) "Script Creator" avec des commandes de programmation unique (DcpXC+) qui vous permettra de toucher, assez facilement, à l'interface graphique en elle-même de Mantrix (réservé quand même aux initiés).
- Mantrix affiche désormais l'heure en temps réel (Timer - minuteur en français - rélié à la Pile Système, à l'aide d'un petit code sympa (merci VB Forum !)).


Améliorations de l'effet des images (HD) et incrémentation des images (icônes) simple dans le menu de Mantrix, déjà pour faire mieux et pour que ça soit plus clair. Les images utilisés sont libre mais vienne de Linux (on les a prises car justement elle sont libres ).

Voilà je suis ouvert à tous commentaires (sauf sur mes fautes d'orthographes qui je le rappel seront corrigés à l'avenir...)

Bon long week-end !

Nouveauté depuis aujourd'hui le cryptage des mots de passe est fonctionnel.

Coool!
C'est déjà plus sécurisé alors!

Oui enfin mdr

Du nouveau
A présent chaque fenêtre disposera d'une animation (dont j'en ferait la démo + le code source public bien sûr) à sa fermeture.
De plus l'écran de verrouillage d'une session utilisateur est enfin terminé ainsi que le Gestionnaire d'utilisateurs.
Toutes les failles de sécurité ont été corrigés.
Par contre toujours pas de version démo de la beta possible (le site web http://algostepmantrix.sitew.fr) n'est pas encore mise à jour !
Petite aperçu (transparence) de l'écran :

Je précise, comme j'ai déjà eu la remarque, que les programmes lancés en cours seront masqués
Donc personne ne peut voir ce qu'il y a en cours.
Si ça plaît pas à l'avenir j'enleverrai la transparence

Perso, sa me dérangerais pas la transparence, sa donne un côté stylé

J'ai enlevé la transparence finalement

Okay

Je mettrai à jour le site prochainement
On va bientôt commencé a créer les nouvelles bases du kernel. On hésite entre reprendre une base linux juste pour le kernel ou refaire tt de zéro et perdre 1 ou 2 an(s)...

Mantrix Beta avance lentement mais bien

Dès qu'on aura terminé 2 ou 3 choses essentiels on postera une petite vidéo de l'OS Virtuel ET l'OS Natif (on le refait en parallèle en C# et C++) :

La version VB.NET de Mantrix ERS servira donc d'OS Virtuel sur-windows
La version C# servira à essayer de la lié à la base du noyau Windows NT (transformation complète de l'OS et des élements le reliant)
La version C++ servira d'OS Natif. Cependant les mêmes pilotes et drivers que Microsoft seront utilisés (plus simple à adapté) on vient juste de trouver l'astuce manquante :p

La vidéo de démonstration essayera ces 3 versions

Pour ceux qui désire faire un OS bootable en VB.NET sachez que c'est physiquement impossible.
Vous pouvez (comme Mantrix) acheté cependant "VB to C++ Converter" pour 119$

Ensuite vous modifier (il faut si connaître un minimum) le code C++ et vous tiliser soit un Kernel linux ou Windows NT (copie légal car NT est payant) ou d'autres Kernel libre.

Si vous souhaitez tout connaître d'un Kernel NT type Windows : télécharger WinObj (gratuit et légal) qui "décompile" le Kernel NT de Microsoft et vous permet de voir absolument tout (mémoire, packets IRP_%, les codes d'actions de Windows (exemple : PowerSystemWorking.S0, PowerSystemShutdown.S5, PowerSystemHibernate.S4, etc) ainsi que les révisions et pilotes/drivers utiles au micro-noyau

C'est sur ce principe "libre" que Mantrix va tourner dans l'avenir

Bonjour,

Pour ceux qui continue de suivre le projet voici le projet du nouveau Kernel (Noyau) qui sera utilisé pour Mantrix (inclus le MBR listing, la couche matérielle et la configuration du boot).
Ce noyau aura pour but de rendre l'OS Mantrix bootable et indépendant mais en utilisant les bases de Windows Pour cela deux versions du noyau seront créées : Kernel Mandrev VIT et Kernel Mandrev NAT (VIT = Virtuel : passant par une interface graphique) / (NAT = Natif : sous forme de console, comme un noyau Linux (même principe)).
Le secret du noyau (qui sera développer en Assembleur et C++) est le suivant :
EDIT : ATTENTION ce qui suis, sans connaissance, peut vous donner le mal de crâne Par contre ceux qui désire savoir comment on va créer le noyau (Kernel) Mandrev pour Mantrix vous serez pas déçus !

Nom du Noyau (Kernel) : Mandrev (AlgoStep Company)
Le noyau sera découpé en 2 parties distinctes mais reliés l'une à l'autre :
- La couche matérielle (CMI = Couche Matérielle Interface)
- La configuration du Boot et Hardware (CBH = Configuration Boot Hardware)

Partie CMI :

- Lien Symbolique (vers la partie "CBH" et vers le MBR contenant 510bits (MBR + Part) + 2bits (55AAh) + support à 4 partitions (1FEh) )
- Driver basique (tout les drivers de bases : DISPLAY ; PROCESS ; KEYBOARD ; MOUSE ; BUS ; USB ; CDROM ; HAL ; DMA ; TIME)
- Titre de partition et classement interne (Listes des partitions et applications de la première comme étant la source (C:\))

Partie CHB :

- Lien Symbolique (vers la partie "CMI") + Lecture et lien d'action vers "boot.ini" qui sera copié à l'installation dans "C:" (premier disque maître, première partition)
- Driver avancé (les autres drivers optionnels déployés que si nécessaires à l'OS : AUDIO ; INTERCO ; EXEMTX (compatibilité *.exe) ; VIDEO ; PRINTER)
- Service (Liaison avec l'OS X donc "boot.ini")
- Event (Événements matériels importants et stockages des résultats dans des variables TRES importantes pour le noyau : %SYSTEMROOT%, etc)
- Session : (Les 5 différents codes de session noyau : MandrevKrnl.Enroute(S0) ; MandrevKrnl.Arret(S3) ; MandrevKrnl.Veille(S2) ; MandrevKrnl.Veilleprolongee(S1) ; MandrevKrnl.Nonspecifie ) Vous remarquerez que les codes sont en Français C'est voulu
- Key (Clé des services, aléatoires à chaque nouveau démarrage de la session Noyau : ELLE NE CHANGE PAS car ce sont ces codes, contenus dans des variables mémoires (type "MEMORY_%keyX%") qui feront le lien avec l'accès mémoire de l'OS !! Extrêmement important.
- Job (Actions des processus : juste un listing des valeurs (1/0/True/False/Unspecified/Transverse)
- Mutex (Appartient à la base à Windows : liens internes au noyau appartenant à certains logiciels (partie OS) qui s'inscrivent ici s'ils doivent se lancer au démarrage du noyau (et non de l'OS) et également le stockage de certains paramètres confidentiels ou d'utilisation à distance : en exemple : si on développe un logiciel pour prendre à distance un PC sous l'OS Mantrix, le Mutex (fichier Mutant) monté ici permettra d'être opérationnel dès que le noyau se lance et atteint le Mutex lié : on pourra donc utiliser le "Bureau à distance" de Mantrix bien avant son propre démarrage !)


Problèmes possibles lorsque le Noyau sera prêt publiquement :

- Si MBR incorrect : Partition Table Invalid : voir "BootMagic" de Microsoft ou du service de déploiement...
- Si pas de partition appelé "C:" : pas de création possible...
- Si les Drivers (type Microsoft ) fournis avec Mandrev Kernel ne corresponde pas au PC vous aurez des problèmes : simplement car Mandrev Kernel ne pourra pas faire de mise à jour...
- Y'a plein de soucis possibles qui j’espère seront un jour résolus

Pour une vue 2D simple :


Pour bien comprendre les liens :
Version programmeur : PA1<=>PA2(+PA3)<=>PA4(+PA3)<=>PA5<=>PA4<=>PA2<=>PA3<=>SI1(+SI3)<=>SI2
Version utilisateur : Hardware, lien vers HAL/DMA + Services de boot et vérification d’existence = retour à l'envoyeur + Gestion de la mémoire virtuelle (oui désolé !! faute d'orthographe sur l'image !) + Intervention du Micro Kernel Mandrev (qui contient tout les drivers, etc : en gros le traducteur d’événements) = lien vers HAL de nouveau puis Services + "boot.ini" == Si/Alors/Sinon (Si "boot.ini" contient "%code de démarrage de l'OS Mantrix" alors "démarrage de l'OS ; donc de l'écran d'accueil" = Processus d'arrière plan (Lien Symbolique + Services) : les services restent visibles pour un compte Administrateur et permette de gérer une toute petite partie du noyau ouvert

Le boot quand à lui est basé sur celui de Windows de Microsoft. Si non existant (pas de Windows) alors le Kernel Mandrev utilisera CD-Shell pour parvenir à ses fins.

Voilà pour finir avec ce roman (dur d'expliquer un noyau ! Il nous manque encore des centaines d'infos et surtout on fait surement fausse route avec des codes...) je vous annonce que, même s'il sortira bien plus tard que l'OS Mantrix, le noyau sera GRATUIT et son code source sera LIBRE (uniquement quand une version stable sera dispo - à l'inverse du code source de Mantrix qui, dès la Beta, pourra être modifier et améliorer par n'importe qui !

Merci d'avoir lu jusqu'au bout...


Si vous repérez une erreur dans le projet Kernel Mandrev contactez moi

Merci !

bon euh... ...bon courage pour la suite

[EDIT] posté une fois de trop...

Merci !
J’espère réussir (je sais presque comment faire de zéro mais... c'est très dur - surement le plus dur truc en programmation - et je deteste le langage machine )

EDIT : de toute façon je pense qu'il faudra être minimum 20 programmeurs (on est 9 à présent pour Mantrix ERS) pour pouvoir développé juste la base du noyau Mandrev en moins d'un an...

C'est officiel ! Mantrix reposera sur les API Win32 de Windows pour faire fonctionner la pluspart des applications Windows lorsque celui-ci sera natif et va utiliser un peut du noyau NT 5.2 de Microsoft


ATTENDEZ S'IL VOUS PLAIT xD Lisez bien tout vous comprenderez tout de Mantrix et en plus vous découvrirez des trucs Certes c'est long mais un peut de courage que diable !


Comment ?
- En se servant d'un procéder reservé au étudiant Microsoft : le CRK (Windows Operating Systems Internals Curriculum Ressource Kit) et le WRK (Windows Research Kernel) qui déploie le code source complet du noyau Windows librement (NT 5.2 - Equivalent de Windows XP x64).

Pourquoi ?
- Car en se servant des bases légal fournis notre OS, Mantrix ERS, pourra fonctionner sur tout ordinateur qui a déjà un Windows d'installé, quel qu'il soit : le principe de fonctionnement est :
1). Utilisation des bases du noyau NT natif de votre Windows installé
2). Modification du boot (Kernel et Hal modifié)
3). Modification du Shell Registery (pour pointer sur Mantrix et non Explorer)
4). Mantrix prend le dessus ; l'interface graphique de Windows n'existe plus : et ceci sur 2 partitions différentes !

Oui mais combien de temps de développement ?
- Aujourd'hui (depuis aujourd'hui d'ailleurs) nous disposont enfin de la source complète de base (Terminal Interface) du Noyau NT 5.2 Comme il est LIBRE pour TOUS (chercher WRK et CRK ) nous pourrons tous y mettre notre petite graine pour que Mantrix ERS, qui sera reconçu en C++ Natif (pas C++ Assembleur .NET !), fonctionne comme un véritable OS Et en réutilisant certaines bases :
A). La base de l'explorateur de fichier mais dans un contenus express et différent
B). La base de la gestion de tout ce qui est mémoire/processeur de Windows de Microsoft
Le principe étant qu'on puisse installé tout logiciel potentiels *.exe de Microsoft et le support DLL de ceux-ci ! De plus et exceptionnelement on fournira le code de celui-ci dans le but de compiler vous même votre propre HAL et WRK si gentillement proposé par Microsoft
Donc prévoyer entre 1 an et 2 ans avant que Mantrix puisse fonctionner NATIVEMENT grâce au base du noyau NT 5.2 de Microsoft
Je sais : c'est long...mais c'est comme ça Si on voulais tout refaire de zéro...il nous aurez fallu entre 5 et 20 ans

Ce qui fait en fin de compte :

30% Noyau NT 5.2 Microsoft
20% Noyau Mandrev (notre propre noyau base C++)
45% Interface graphique Mantrix ERS
5% Interfaces Windows pour gestion DLL/EXE et divers programmes liés à la mémoire

Cependant le noyau NT 5.2 sera reconçu : on l'améliorera pour qu'aucun crash n'a lieux. Quand à sa fonctionnalité première : le support disque : le FAT32 et NTFS seront supportés...jusqu'à 8Go de mémoire. Intel et AMD supporté. USB supporté. CD-ROM/DVD-ROM supportés et enfin toutes les bases et surtout les certaines mises à jour de Microsoft pourront être faite (materiel) !

Pour ceux qui veulent aidez sachez que prochainement le site web http://www.algostepmantrix.sitew.fr sera effacer et un nouveau viendra le remplacer (d'ici la fin Juin) : vous y trouverez un dépôt fraîchement fait et propre dans lequel vous pourrez télécharger :

- Mantrix ERS x86/x64 version virtuel (VB.NET)
OU
- Mantrix ERS x86/x64 version NATIVE (en cours de conception VB.NET, C/C++ et Assembleur) : avec le Noyau Mandrev et bien sûr le noyau NT 5.2 Microsoft

Ce futur site (reservé déjà) contiendra une méthode LIBRE de transfert des fichiers FTP (dans un sens, l'envoi uniquement) : à chaque fois que vous aidez Mantrix à progresser (graphiquement ou son noyau) vous pourrez renvoyer les sources et elles seront testés et notés dans un ordre de recherche bien particulières.

Et bien sûr : TOUT CELA SERA GRATUIT !

Pourquoi gratuit un tel projet ???
- Déjà car je ne dirais qu'une chose : Vive les logiciels libres ! Ensuite parcequ'il est interdit de revendre un noyau NT 5.2 de Microsoft refait ! Enfin parceque je ne vois pas l'interêt de payer pour un OS !! Et grâce à l'Open Source vous pourrez apporter votre aide au projet
Le seul truc payant c'est l'interface graphique (Mantrix ERS en gros) : mais à payer uniquement si vous souhaitez le modifier pour en prendre possession : en gros vous souhaitez développé VOTRE propre OS ; dans ce cas il vous faudra acheter une licence pour vous autoriser à modifier Mantrix ERS comme bon vous semble et même à le vendre (uniquement en interface graphique). Mais le noyau reste gratuit.

Prix de Mantrix ERS si on veut le transformer pour nous à notre guise et le revendre ?
- Comme je l'ai dit si vous souhaitez juste améliorer et participer au développement de Mantrix ERS c'est gratuit
- Si vous désirez le prendre pour le modifier (changer son nom, vous l'approprier, etc) son prix est estimé à l'heure actuelle à 200 euros.
Son prix sera donc fixer à 149 euros pour l'instant. Non négociable. Il se peut que le prix baisse ou grimpe dans l'avenir suivant l'avancement du projet.

Et Mantrix ERS Beta alors ? L'alpha était plutôt moche et amateur !!
- L'interface graphique, comparé à l'alpha, est 95% différente !! Le cryptage, gestion des fichiers, types de présentation, applis externes, bref absolument tout change : tout à été "refait" en gardant juste les bases : Mantrix ERS Beta est donc moins lourd (pour l'heure 15Mo au lieu de 30Mo pour l'IUG) et ne prend que 300Mo maximum de mémoire (au lieu de jusqu'à 800Mo de mémoire pour l'alpha).
Nos critères deviennent professionnel et donc l'interface reste simple mais la plus pro possible.

Si vous avez le moindre commentaire ou question n'hésitez pas.
La Beta sera dispo dans 2 mois et 8 jours à l'heure ou je vous parle mais vous aurez une "demo" (instable non terminé et qui sert pour le test) en version compilé dans quelques semaines et bien sûr je compte bien faire également une vidéo pour vous montrer Mantrix ERS Beta virtuel et natif avant la publication libre Je ne sais pas si Mantrix ERS fonctionnera bien un jour mais même si tout s'effondre (ce que je n'éspere pas !) quelqu'un un jour reprendra le projet et continuera

Merci encore à ceux qui suivent le projet et qui patiente...patiente... bref merci !
Merci à Etienne Baudoux pour son aide et ses conseilles et à Microsoft Student et aux membres de l'ENI pour l'aide.

C'était Blackorion pour AlgoStep Company

Deuxième message de la journée
Désolé de flooder mais je présente toutes les modifications de la Beta

Mantrix ERS Beta va pouvoir supporter les packages de langue !
Après beaucoup de problème nous avons enfin réussi et la procédure est toute simple ! Suivez le guide :

D'abord petit rappel : Mantrix se base sur des scripts libre dans un format reconnu par Mantrix : VAR, MSX, TVAR, M, XM, MTX, etc
Aujourd'hui on rajoute les PXT

Imaginez : vous êtes anglais et vous venez de télécharger Mantrix Edition Red Serveur, créer par nous des Français.
Vous aimeriez disposez de l'OS en anglais... Vous allez sur le site officiel de notre société (dans le futur lol) et vous télécharger le package langue nommé "patch-??" (?? = le code de langue ! Très important !)
Avant d'installer le package voyons Mantrix :

Mantrix dans sa langue naturel ce présente avec un fichier de script nommé "lang.m" (\System\etc\) qui contient la valeur "fr" : quel que soit sa valeur, si elle n'est pas reconnu à l'avance, Mantrix laissera l'OS en Français :

Voici ce que sa donne dans l'OS (au niveau de l'écran de connexion) :


A présent on reviens dans "\System\etc\lang.m" et on modifie "fr" par une valeur reconnu par mantrix : ici pour l'instant c'est l'anglais : donc à la place de "fr" on met "us" :

Et on place le package qui se nomme "patch-us" (sous forme d'un dossier) dans : "\System\etc\lang\patch-us" :

Dans ce dossier il y a des centaines de fichiers nommé "0_0_000001.pxt" (avec la limite de 9_9_999999.pxt se qui fait 80 millions de possibilités !! )
Chacun de ces fichiers comportent une traduction qui sera VERIFIER et LU par l'OS avant chaque action et tout cela en quelques millièmes de secondes : et l'OS remplacera le texte par le nouveau !

Voici ce que donne un fichier de langue ouvert (tout simple) :


Et c'est là que tout se passe On lance l'OS Mantrix ERS et....


Et voilà ! l'OS est traduit !
Pas d'inquiétude : pour l'exemple on a fait nos scripts uniquement sur le login utilisateur (Simple-User et non Multi-Users, qui lui viendra plus tard).
De plus le moindre soucis de traduction pourra être fait simplement via Windows et son bloc-notes
Les traductions les plus officiels seront tenu sur le site d'AlgoStep Company.

D'ailleurs à la sortie de la Beta (même la demo) vous pourrez si vous le souhaitez commencer les traductions (en tout cas celle qui seront possibles)
En nous aidant vous permettrez à d'autres utilisateurs d'autres pays de pouvoir utiliser Mantrix
Quand au code source et à l'installateur de package il sera distribué librement SANS aucune restriction pour que tous vous puissiez reprendre l'idée !

Merci à Jeremy pour l'aide au niveau du Shell

Mantrix supporte aujourd'hui (18/05/13) depuis 21H30 jusqu'à 8 langues différentes !
Tout est automatique, prêt installés et traduit (fautes de traductions possibles qu'on corrigera ensemble - avec ceux qui sont intéressés bien sur )
Les modif's de traductions peuvent se faire hors-OS avec un simple bloc-notes en passant !

Mantrix ERS Beta supportera 8 langues : Français (par défaut et intégré à l'OS), Anglais, Allemand, Espagnol, Italien, Portugais, Albanais et Gallois.

Voici un aperçu du Gestionnaire de langue, développé avec l'aide de Maxime (alias belfegor) pour notre OS du très bon boulot, simple mais efficace :


Aperçu du Login-User avec le panel de configuration des langues Un simple clique et on redémarre sous la langue souhaitez !


Aperçu, ci-dessus, du menu traduit en anglais avec le panel de configuration des langues de Mantrix.


Aperçu complet du core de l'OS (\System\etc\) où son entreposer les patchs de langues et les scripts de configuration

Principe de fonctionnement :

Si le script \System\etc\lang.m est égale à "us" (exemple) ............ alors on cherche si le dossier "patch-us" (lié au script) est existant dans \System\etc\lang\. Si il existe on lit, à chaque ouverture de fenêtre dans l'OS, le texte contenus dans des centaines de scripts (format PXT) qui s'appellent "0_0_000001.pxt" par exemple. Si le fichier de traduction spécifique au décors de l'OS (label texte, etc) n'existe pas celui-ci reprend son origine : la langue Française.
Cela s'applique SIMPLEMENT à autant de langue qu'on souhaite
C'est pour ça qu'il suffit de mettre n'importe quel langue, changer le panel de configuration des langues (pour en ajouter de nouvelles) ; liés le code (de deux lettres) à l'OS et s'il le reconnaît vous n'avez plus qu'a traduire le contenus de tout les scripts disponibles dans le dossier "patch-**" et l'OS Mantrix est traduit !
ATTENTION : Sécurité forte : il vous sera impossible de changer certaines valeurs (nom de l'OS, les infos des développeurs, etc).

Voilà Qu'en pensez vous ?
PS : j'ai remarqué que plus personne ne parle sur ce sujet ' Heu...Hésitez pas à donner votre point de vue merci !

Nouvelle du jour

Non
seulement Mantrix ERS (Beta) sera fournis en libre échange AVEC son
code source mais vous disposerez (après mainte réflexion) du code source
du Kernel Mandrev + NT 5.2 x86/x64 C++ pour pouvoir tester l'OS
nativement (pour les développeurs) :

La source du projet Mantrix ERS, et je rassure tout le monde, ne s'arrêtera pas pour 5 raisons :

- Mantrix ERS est un projet professionnel et déclaré, qui sera édité ; donc protégé.
- Mantrix ERS fonctionne virtuellement mais fonctionnera aussi un jour nativement.
-
Nous seront les seuls à oser mettre en ligne le code source complet de
notre OS + le Kernel (Le seul Kernel dispo librement est Linux : nous on vous offre les bases de celui de Windows NT 5.2** couplé à notre propre Kernel : Mandrev)
-
Mantrix ERS est à présent financer par un groupe scolaire d'étude
informatique (ENI Rennes/Nantes) ce qui fait environ (restant) 900 euros
pour concevoir l'OS ou rachetez des bases dont nous ne connaissons pas
le secret
- Nous avons à présent 9 développeurs qui feront tout
pour parvenir à créer une version stable et ensemble (ceux du forum qui
seront intéressés) pourront apporter leurs petites touches perso avant
d'en proposés l’amélioration qui, après test, sera accepté et deviendra
un belle OS (enfin on l’espère )

Merci à ceux qui nous suivent la Beta arrivera dans 2 mois certes... mais vous pourrez enfin travailler dessus autant de temps que vous le souhaitez
! Et si vous développez un programme Interne ou Externe propre à
Mantrix ERS chacun pourra toucher 30 euros par logiciel créer !

** Kernel
NT 5.2 est la propriété de Microsoft : il est GRATUIT (nous l'avons eu
exceptionnellement car nous travaillons en Informatique dans une école
lié à Microsoft) : donc si on vous la partage elle devra :

- NE JAMAIS ÊTRE VENDU
- TOUJOURS REDONNER GRATUITEMENT (logique)
- NE JAMAIS ENLEVER "Microsoft" du Copyright
- NE PAS S'EN APPROPRIER LES BASES SANS CITES Microsoft

Microsoft
n'a jamais donné sont codes sources librement car il s'agit de code
Commercial. Alors ne faite pas la bourde d'en profitez illégalement !
Merci de respecter notre cher Microsoft, que vous soyez Microsoftien ou
Linuxien

Le Kernel Mandrev est écrit en C# puis a été réécrit en C++ Natif, compatible .NET, il y a quelques semaines (très léger car refait de zéro : moins de 500 lignes de codes).
Le Kernel NT 5.2 est en C++ Natif (500.000 lignes de codes) : c'est le même noyau (le seul de libre aussi) que Windows XP x64 Edition
: c'est grâce à ce noyau que Mantrix ERS va gérer également les API
Win32 : donc pourra ouvrir les fichiers exécutables (.exe) de Windows à
la base
Mantrix
ERS est écrit en VB.NET avec SZ2012 Ed. Pro. et sera réécrit
exceptionnelement en C++ le moment venu (mais vous n'aurez plus
d'actualité ici car ce forum est réservés au logiciels développés avec
SZ2011/2012 ou 4.0) - Mantrix ERS Alpha fesait 13000 lignes de codes...
La Beta plus légèrte et améliorer en fera entre 10000 et 40000... J'en
ai honnetement aucunes idées pour l'instant

Pour
l'heure ce n'est pas encore fait donc Mantrix ERS reste virtuel en
VB.NET mais vous trouverez aussi les sources du noyau NT 5.2 et
MandrevKernel 1.1.

Et ceux qui ce dise "Oh :O ! Le code source de Windows !!" voici un extrait pour vous faire patienter ( ) :

Code:


/*++

Copyright (c) Microsoft Corporation. All rights reserved.


Module Name:

    initos.c

Abstract:

    Main source file of the NTOS system initialization subcomponent.

--*/

#include "ntos.h"
#include "ntimage.h"
#include <zwapi.h>
#include <ntdddisk.h>
#include <kddll.h>
#include <setupblk.h>
#include <fsrtl.h>

#include "stdlib.h"
#include "stdio.h"
#include <string.h>

#include <inbv.h>

UNICODE_STRING NtSystemRoot;

NTSTATUS
RtlFormatBuffer2 (
    PCHAR  Buffer,
    size_t  BufferLen,
    PCHAR  FormatString,
    PVOID  Param0,
    PVOID  Param1
    );

VOID
ExpInitializeExecutive(
    IN ULONG Number,
    IN PLOADER_PARAMETER_BLOCK LoaderBlock
    );

NTKERNELAPI
BOOLEAN
ExpRefreshTimeZoneInformation(
    IN PLARGE_INTEGER CurrentUniversalTime
    );

NTSTATUS
CreateSystemRootLink(
    IN PLOADER_PARAMETER_BLOCK LoaderBlock
    );

static USHORT
NameToOrdinal (
    IN PSZ NameOfEntryPoint,
    IN ULONG_PTR DllBase,
    IN ULONG NumberOfNames,
    IN PULONG NameTableBase,
    IN PUSHORT NameOrdinalTableBase
    );

NTSTATUS
LookupEntryPoint (
    IN PVOID DllBase,
    IN PSZ NameOfEntryPoint,
    OUT PVOID *AddressOfEntryPoint
    );

PFN_COUNT
ExBurnMemory(
    IN PLOADER_PARAMETER_BLOCK LoaderBlock,
    IN PFN_COUNT NumberOfPagesToBurn,
    IN TYPE_OF_MEMORY MemoryTypeForRemovedPages,
    IN PMEMORY_ALLOCATION_DESCRIPTOR NewMemoryDescriptor OPTIONAL
    );

BOOLEAN
ExpIsLoaderValid(
    IN PLOADER_PARAMETER_BLOCK LoaderBlock
    );

VOID
FinalizeBootLogo(VOID);

VOID
DisplayBootBitmap (
    IN BOOLEAN DisplayOnScreen
    );

NTSTATUS
RtlInitializeStackTraceDataBase (
    IN PVOID CommitBase,
    IN SIZE_T CommitSize,
    IN SIZE_T ReserveSize
    );


#if defined(_X86_)

VOID
KiInitializeInterruptTimers(
    VOID
    );

#endif

VOID
Phase1InitializationDiscard (
    IN PVOID Context
    );

VOID
CmpInitSystemVersion(
    IN ULONG stage,
    IN PVOID param
    );

VOID
HeadlessInit(
    IN PLOADER_PARAMETER_BLOCK LoaderBlock
    );

//
// The INIT section is not pageable during initialization, so these
// functions can be in INIT rather than in .text.
//

#pragma alloc_text(INIT, ExpInitializeExecutive)
#pragma alloc_text(PAGE, Phase1Initialization)
#pragma alloc_text(INIT, Phase1InitializationDiscard)
#pragma alloc_text(INIT, CreateSystemRootLink)

#if !defined(_AMD64_)

#pragma alloc_text(INIT,LookupEntryPoint)
#pragma alloc_text(INIT,NameToOrdinal)

#endif

//
// Define global static data used during initialization.
//

ULONG NtGlobalFlag;
extern UCHAR CmProcessorMismatch;

ULONG InitializationPhase;

extern ULONG KiServiceLimit;
extern PMESSAGE_RESOURCE_DATA  KiBugCodeMessages;
extern ULONG KdpTimeSlipPending;
extern BOOLEAN KdBreakAfterSymbolLoad;

extern PVOID BBTBuffer;
extern MEMORY_ALLOCATION_DESCRIPTOR BBTMemoryDescriptor;

extern BOOLEAN InbvBootDriverInstalled;

WCHAR NtInitialUserProcessBuffer[128] = L"\\SystemRoot\\System32\\smss.exe";
ULONG NtInitialUserProcessBufferLength =
    sizeof(NtInitialUserProcessBuffer) - sizeof(WCHAR);
ULONG NtInitialUserProcessBufferType = REG_SZ;


typedef struct _EXLOCK {
    KSPIN_LOCK SpinLock;
    KIRQL Irql;
} EXLOCK, *PEXLOCK;

#ifdef ALLOC_PRAGMA
NTSTATUS
ExpInitializeLockRoutine(
    PEXLOCK Lock
    );
#pragma alloc_text(INIT,ExpInitializeLockRoutine)
#endif

BOOLEAN
ExpOkayToLockRoutine(
    IN PEXLOCK Lock
    )
{
    return TRUE;
}

NTSTATUS
ExpInitializeLockRoutine(
    PEXLOCK Lock
    )
{
    KeInitializeSpinLock(&Lock->SpinLock);
    return STATUS_SUCCESS;
}

NTSTATUS
ExpAcquireLockRoutine(
    PEXLOCK Lock
    )
{
    ExAcquireSpinLock(&Lock->SpinLock,&Lock->Irql);
    return STATUS_SUCCESS;
}

NTSTATUS
ExpReleaseLockRoutine(
    PEXLOCK Lock
    )
{
    ExReleaseSpinLock(&Lock->SpinLock,Lock->Irql);
    return STATUS_SUCCESS;
}

extern BOOLEAN InitIsWinPEMode;
extern ULONG InitWinPEModeType;

#ifdef ALLOC_DATA_PRAGMA
#pragma data_seg("INITDATA")
#endif

ULONG PoolHitTag;
extern ULONG InitNlsTableSize;
extern PVOID InitNlsTableBase;

volatile BOOLEAN InitForceInline = FALSE;
NLSTABLEINFO InitTableInfo;
PFN_COUNT BBTPagesToReserve;

#ifdef ALLOC_DATA_PRAGMA
#pragma data_seg()
#endif


VOID
ExpInitializeExecutive(
    IN ULONG Number,
    IN PLOADER_PARAMETER_BLOCK LoaderBlock
    )

/*++

Routine Description:

    This routine is called from the kernel initialization routine during
    bootstrap to initialize the executive and all of its subcomponents.
    Each subcomponent is potentially called twice to perform Phase 0, and
    then Phase 1 initialization. During Phase 0 initialization, the only
    activity that may be performed is the initialization of subcomponent
    specific data. Phase 0 initialization is performed in the context of
    the kernel start up routine with interrupts disabled. During Phase 1
    initialization, the system is fully operational and subcomponents may
    do any initialization that is necessary.

Arguments:

    Number - Supplies the processor number currently initializing.

    LoaderBlock - Supplies a pointer to a loader parameter block.

Return Value:

    None.

--*/

{
    PFN_COUNT PagesToBurn;
    PCHAR Options;
    PCHAR MemoryOption;
    NTSTATUS Status;
    PKLDR_DATA_TABLE_ENTRY DataTableEntry;
    PLIST_ENTRY NextEntry;
    ANSI_STRING AnsiString;
    STRING NameString;
    CHAR Buffer[ 256 ];
    BOOLEAN BufferSizeOk;
    ULONG ImageCount;
    ULONG i;
    ULONG_PTR ResourceIdPath[3];
    PIMAGE_RESOURCE_DATA_ENTRY ResourceDataEntry;
    PMESSAGE_RESOURCE_DATA  MessageData;
    PLIST_ENTRY NextMd;
    PMEMORY_ALLOCATION_DESCRIPTOR MemoryDescriptor;

    if (!ExpIsLoaderValid(LoaderBlock)) {

        KeBugCheckEx(MISMATCHED_HAL,
                    3,
                    LoaderBlock->Extension->Size,
                    LoaderBlock->Extension->MajorVersion,
                    LoaderBlock->Extension->MinorVersion
                    );
    }

    //
    // Initialize PRCB pool lookaside pointers.
    //

#if !defined(_AMD64_)

    ExInitPoolLookasidePointers();

#endif

    if (Number == 0) {
        extern BOOLEAN ExpInTextModeSetup;

        //
        // Determine whether this is textmode setup and whether this is a
        // remote boot client.
        //

        ExpInTextModeSetup = FALSE;
        IoRemoteBootClient = FALSE;

        if (LoaderBlock->SetupLoaderBlock != NULL) {

            if ((LoaderBlock->SetupLoaderBlock->Flags & SETUPBLK_FLAGS_IS_TEXTMODE) != 0) {
                ExpInTextModeSetup = TRUE;
            }

            if ((LoaderBlock->SetupLoaderBlock->Flags & SETUPBLK_FLAGS_IS_REMOTE_BOOT) != 0) {
                IoRemoteBootClient = TRUE;
                ASSERT( _memicmp( LoaderBlock->ArcBootDeviceName, "net(0)", 6 ) == 0 );
            }
        }

#if defined(REMOTE_BOOT)
        SharedUserData->SystemFlags = 0;
        if (IoRemoteBootClient) {
            SharedUserData->SystemFlags |= SYSTEM_FLAG_REMOTE_BOOT_CLIENT;
        }
#endif // defined(REMOTE_BOOT)

        //
        // Indicate that we are in phase 0.
        //

        InitializationPhase = 0L;

        Options = LoaderBlock->LoadOptions;

        if (Options != NULL) {

            //
            // If in BBT mode, remove the requested amount of memory from the
            // loader block and use it for BBT purposes instead.
            //

            _strupr(Options);

            MemoryOption = strstr(Options, "PERFMEM");

            if (MemoryOption != NULL) {
                MemoryOption = strstr (MemoryOption,"=");
                if (MemoryOption != NULL) {
                    PagesToBurn = (PFN_COUNT) atol (MemoryOption + 1);

                    //
                    // Convert MB to pages.
                    //

                    PagesToBurn *= ((1024 * 1024) / PAGE_SIZE);

                    if (PagesToBurn != 0) {

                        PERFINFO_INIT_TRACEFLAGS(Options, MemoryOption);

                        BBTPagesToReserve = ExBurnMemory (LoaderBlock,
                                                          PagesToBurn,
                                                          LoaderBBTMemory,
                                                          &BBTMemoryDescriptor);
                    }
                }
            }

            //
            // Burn memory - consume the amount of memory
            // specified in the OS Load Options.  This is used
            // for testing reduced memory configurations.
            //

            MemoryOption = strstr(Options, "BURNMEMORY");

            if (MemoryOption != NULL) {
                MemoryOption = strstr(MemoryOption,"=");
                if (MemoryOption != NULL ) {

                    PagesToBurn = (PFN_COUNT) atol (MemoryOption + 1);

                    //
                    // Convert MB to pages.
                    //

                    PagesToBurn *= ((1024 * 1024) / PAGE_SIZE);

                    if (PagesToBurn != 0) {
                        ExBurnMemory (LoaderBlock,
                                      PagesToBurn,
                                      LoaderBad,
                                      NULL);
                    }
                }
            }
        }

        //
        // Initialize the translation tables using the loader
        // loaded tables.
        //

        InitNlsTableBase = LoaderBlock->NlsData->AnsiCodePageData;
        InitAnsiCodePageDataOffset = 0;
     
 InitOemCodePageDataOffset =
(ULONG)((PUCHAR)LoaderBlock->NlsData->OemCodePageData -
(PUCHAR)LoaderBlock->NlsData->AnsiCodePageData);
       
InitUnicodeCaseTableDataOffset =
(ULONG)((PUCHAR)LoaderBlock->NlsData->UnicodeCaseTableData -
(PUCHAR)LoaderBlock->NlsData->AnsiCodePageData);

        RtlInitNlsTables(
            (PVOID)((PUCHAR)InitNlsTableBase+InitAnsiCodePageDataOffset),
            (PVOID)((PUCHAR)InitNlsTableBase+InitOemCodePageDataOffset),
            (PVOID)((PUCHAR)InitNlsTableBase+InitUnicodeCaseTableDataOffset),
            &InitTableInfo
            );

        RtlResetRtlTranslations(&InitTableInfo);

        //
        // Initialize the Hardware Architecture Layer (HAL).
        //

        if (HalInitSystem(InitializationPhase, LoaderBlock) == FALSE) {
            KeBugCheck(HAL_INITIALIZATION_FAILED);
        }

#if defined(_APIC_TPR_)

        HalpIRQLToTPR = LoaderBlock->Extension->HalpIRQLToTPR;
        HalpVectorToIRQL = LoaderBlock->Extension->HalpVectorToIRQL;

#endif

        //
        // Enable interrupts now that the HAL has initialized.
        //

#if defined(_X86_)

        _enable();

#endif

        //
        // Set the interrupt time forward so the Win32 tick count will wrap
        // within one hour to make rollover errors show up in fewer than 49.7
        // days.
        //

#if DBG

        KeAdjustInterruptTime((LONGLONG)(MAXULONG - (60 * 60 * 1000)) * 10 * 1000);

#endif

        SharedUserData->CryptoExponent = 0;

#if DBG
        NtGlobalFlag |= FLG_ENABLE_CLOSE_EXCEPTIONS |
                        FLG_ENABLE_KDEBUG_SYMBOL_LOAD;
#endif

        Status = RtlFormatBuffer2( Buffer,
                                  sizeof(Buffer),
                                  "C:%s",
                                  LoaderBlock->NtBootPathName,
                                  0
                                );
        if (! NT_SUCCESS(Status)) {
            KeBugCheck(SESSION3_INITIALIZATION_FAILED);
        }
        RtlInitString( &AnsiString, Buffer );
        Buffer[ --AnsiString.Length ] = '\0';
        NtSystemRoot.Buffer = SharedUserData->NtSystemRoot;
        NtSystemRoot.MaximumLength = sizeof( SharedUserData->NtSystemRoot );
        NtSystemRoot.Length = 0;
        Status = RtlAnsiStringToUnicodeString( &NtSystemRoot,
                                              &AnsiString,
                                              FALSE
                                            );
        if (!NT_SUCCESS( Status )) {
            KeBugCheck(SESSION3_INITIALIZATION_FAILED);
            }

        //
        // Find the address of BugCheck message block resource and put it
        // in KiBugCodeMessages.
        //
        // WARNING: This code assumes that the KLDR_DATA_TABLE_ENTRY for
        // ntoskrnl.exe is always the first in the loaded module list.
        //

        DataTableEntry = CONTAINING_RECORD(LoaderBlock->LoadOrderListHead.Flink,
                                          KLDR_DATA_TABLE_ENTRY,
                                          InLoadOrderLinks);

        ResourceIdPath[0] = 11;
        ResourceIdPath[1] = 1;
        ResourceIdPath[2] = 0;

        Status = LdrFindResource_U (DataTableEntry->DllBase,
                                    ResourceIdPath,
                                    3,
                                    (VOID *) &ResourceDataEntry);

        if (NT_SUCCESS(Status)) {

            Status = LdrAccessResource (DataTableEntry->DllBase,
                                        ResourceDataEntry,
                                        &MessageData,
                                        NULL);

            if (NT_SUCCESS(Status)) {
                KiBugCodeMessages = MessageData;
            }
        }

#if !defined(NT_UP)

        //
        // Verify that the kernel and HAL images are suitable for MP systems.
        //
        // N.B. Loading of kernel and HAL symbols now occurs in kdinit.
        //

        ImageCount = 0;
        NextEntry = LoaderBlock->LoadOrderListHead.Flink;
        while ((NextEntry != &LoaderBlock->LoadOrderListHead) && (ImageCount < 2)) {
            DataTableEntry = CONTAINING_RECORD(NextEntry,
                                              KLDR_DATA_TABLE_ENTRY,
                                              InLoadOrderLinks);
            ImageCount += 1;
            if ( !MmVerifyImageIsOkForMpUse(DataTableEntry->DllBase) ) {
                KeBugCheckEx(UP_DRIVER_ON_MP_SYSTEM,
                            (ULONG_PTR)DataTableEntry->DllBase,
                            0,
                            0,
                            0);

            }

            NextEntry = NextEntry->Flink;

        }

#endif // !defined(NT_UP)

        CmpInitSystemVersion(0, LoaderBlock);

        //
        // Initialize the ExResource package.
        //

        if (!ExInitSystem()) {
            KeBugCheck(PHASE0_INITIALIZATION_FAILED);
        }

        //
        // Get multinode configuration (if any).
        //

        KeNumaInitialize();

        //
        // Initialize memory management and the memory allocation pools.
        //

        if (MmInitSystem (0, LoaderBlock) == FALSE) {
            KeBugCheck(PHASE0_INITIALIZATION_FAILED);
        }

        //
        // Scan the loaded module list and load the driver image symbols.
        //

        ImageCount = 0;
        NextEntry = LoaderBlock->LoadOrderListHead.Flink;
        while (NextEntry != &LoaderBlock->LoadOrderListHead) {

            BufferSizeOk = TRUE;

            if (ImageCount >= 2) {
                ULONG Count;
                WCHAR *Filename;
                ULONG Length;

                //
                // Get the address of the data table entry for the next component.
                //

                DataTableEntry = CONTAINING_RECORD(NextEntry,
                                                  KLDR_DATA_TABLE_ENTRY,
                                                  InLoadOrderLinks);

                //
                // Load the symbols via the kernel debugger
                // for the next component.
                //
                if (DataTableEntry->FullDllName.Buffer[0] == L'\') {
                    //
                    // Correct fullname already available
                    //
                    Filename = DataTableEntry->FullDllName.Buffer;
                    Length = DataTableEntry->FullDllName.Length / sizeof(WCHAR);
                    if (sizeof(Buffer) < Length + sizeof(ANSI_NULL)) {
                        //
                        // DllName too long.
                        //
                        BufferSizeOk = FALSE;
                    } else {
                        Count = 0;
                        do {
                            Buffer[Count++] = (CHAR)*Filename++;
                        } while (Count < Length);

                        Buffer[Count] = 0;
                    }
                } else {
                    //
                    // Assume drivers
                    //
                    if (sizeof(Buffer) < 18 + NtSystemRoot.Length / sizeof(WCHAR) - 2
                                            + DataTableEntry->BaseDllName.Length / sizeof(WCHAR)
                                            + sizeof(ANSI_NULL)) {
                        //
                        // ignore the driver entry, it must have been corrupt.
                        //
                        BufferSizeOk = FALSE;

                    } else {
                        Status = RtlFormatBuffer2 (Buffer,
                                                    sizeof(Buffer),
                                                    "%ws\\System32\\Drivers\\%wZ",
                                                    &SharedUserData->NtSystemRoot[2],
                                                    &DataTableEntry->BaseDllName);
                        if (! NT_SUCCESS(Status)) {
                            KeBugCheck(PHASE0_INITIALIZATION_FAILED);
                        }
                    }
                }
                if (BufferSizeOk) {
                    RtlInitString (&NameString, Buffer );
                    DbgLoadImageSymbols (&NameString,
                                        DataTableEntry->DllBase,
                                        (ULONG)-1);

#if !defined(NT_UP)
                    if (!MmVerifyImageIsOkForMpUse(DataTableEntry->DllBase)) {
                        KeBugCheckEx(UP_DRIVER_ON_MP_SYSTEM,(ULONG_PTR)DataTableEntry->DllBase,0,0,0);
                    }
#endif // NT_UP
                }

            }
            ImageCount += 1;
            NextEntry = NextEntry->Flink;
        }

        //
        // If break after symbol load is specified, then break into the
        // debugger.
        //

        if (KdBreakAfterSymbolLoad != FALSE) {
            DbgBreakPointWithStatus(DBG_STATUS_CONTROL_C);
        }


        //
        // Turn on the headless terminal now, if we are of a sufficiently
        // new vintage of loader
        //
        if (LoaderBlock->Extension->Size >= sizeof (LOADER_PARAMETER_EXTENSION)) {
            HeadlessInit(LoaderBlock);
        }


        //
        // These fields are supported for legacy 3rd party 32-bit software
        // only.  New code should call NtQueryInformationSystem() to get them.
        //

#if defined(_WIN64)

        SharedUserData->Reserved1 = 0x7ffeffff; // 2gb HighestUserAddress
        SharedUserData->Reserved3 = 0x80000000; // 2gb SystemRangeStart

#else

        //
        // Set the highest user address and the start of the system range in
        // the shared memory block.
        //
        // N.B. This is not a constant value if the target system is an x86
        //      with 3gb of user virtual address space.
        //

        SharedUserData->Reserved1 = (ULONG)MM_HIGHEST_USER_ADDRESS;
        SharedUserData->Reserved3 = (ULONG)MmSystemRangeStart;

#endif

        //
        // Snapshot the NLS tables into paged pool and then
        // reset the translation tables.
        //
        // Walk through the memory descriptors and size the NLS data.
        //

        NextMd = LoaderBlock->MemoryDescriptorListHead.Flink;

        while (NextMd != &LoaderBlock->MemoryDescriptorListHead) {

            MemoryDescriptor = CONTAINING_RECORD(NextMd,
                                                MEMORY_ALLOCATION_DESCRIPTOR,
                                                ListEntry);

            if (MemoryDescriptor->MemoryType == LoaderNlsData) {
                InitNlsTableSize += MemoryDescriptor->PageCount*PAGE_SIZE;
            }

            NextMd = MemoryDescriptor->ListEntry.Flink;
        }

        InitNlsTableBase = ExAllocatePoolWithTag (NonPagedPool,
                                                  InitNlsTableSize,
                                                  ' slN');

        if (InitNlsTableBase == NULL) {
            KeBugCheck(PHASE0_INITIALIZATION_FAILED);
        }

        //
        // Copy the NLS data into the dynamic buffer so that we can
        // free the buffers allocated by the loader. The loader guarantees
        // contiguous buffers and the base of all the tables is the ANSI
        // code page data.
        //

        RtlCopyMemory (InitNlsTableBase,
                      LoaderBlock->NlsData->AnsiCodePageData,
                      InitNlsTableSize);

        RtlInitNlsTables ((PVOID)((PUCHAR)InitNlsTableBase+InitAnsiCodePageDataOffset),
            (PVOID)((PUCHAR)InitNlsTableBase+InitOemCodePageDataOffset),
            (PVOID)((PUCHAR)InitNlsTableBase+InitUnicodeCaseTableDataOffset),
            &InitTableInfo);

        RtlResetRtlTranslations (&InitTableInfo);

        CmpInitSystemVersion(1, NULL);

        if (NtGlobalFlag & FLG_KERNEL_STACK_TRACE_DB) {

            PVOID StackTraceDataBase;
            ULONG StackTraceDataBaseLength;
            NTSTATUS Status;

            StackTraceDataBaseLength =  512 * 1024;
            switch ( MmQuerySystemSize() ) {
                case MmMediumSystem :
                    StackTraceDataBaseLength = 1024 * 1024;
                    break;

                case MmLargeSystem :
                    StackTraceDataBaseLength = 2048 * 1024;
                    break;
            }

            StackTraceDataBase = ExAllocatePoolWithTag( NonPagedPool,
                                        StackTraceDataBaseLength,
                                        'catS');

            if (StackTraceDataBase != NULL) {

                KdPrint(( "INIT: Kernel mode stack back trace enabled "
                          "with %u KB buffer.\n", StackTraceDataBaseLength / 1024 ));

                Status = RtlInitializeStackTraceDataBase (StackTraceDataBase,
                                                          StackTraceDataBaseLength,
                                                          StackTraceDataBaseLength);
            } else {
                Status = STATUS_NO_MEMORY;
            }

            if (!NT_SUCCESS( Status )) {
                KdPrint(( "INIT: Unable to initialize stack trace data base - Status == %lx\n", Status ));
            }
        }

        if (NtGlobalFlag & FLG_ENABLE_EXCEPTION_LOGGING) {
            RtlInitializeExceptionLog(MAX_EXCEPTION_LOG);
        }

        ExInitializeHandleTablePackage();

#if DBG
        //
        // Allocate and zero the system service count table.
        //

        KeServiceDescriptorTable[0].Count =
                    (PULONG)ExAllocatePoolWithTag(NonPagedPool,
                                          KiServiceLimit * sizeof(ULONG),
                                          'llac');
        KeServiceDescriptorTableShadow[0].Count = KeServiceDescriptorTable[0].Count;
        if (KeServiceDescriptorTable[0].Count != NULL ) {
            RtlZeroMemory((PVOID)KeServiceDescriptorTable[0].Count,
                          KiServiceLimit * sizeof(ULONG));
        }
#endif

        if (!ObInitSystem()) {
            KeBugCheck(OBJECT_INITIALIZATION_FAILED);
        }

        if (!SeInitSystem()) {
            KeBugCheck(SECURITY_INITIALIZATION_FAILED);
        }

        if (PsInitSystem(0, LoaderBlock) == FALSE) {
            KeBugCheck(PROCESS_INITIALIZATION_FAILED);
        }

        if (!PpInitSystem()) {
            KeBugCheck(PP0_INITIALIZATION_FAILED);
        }

        //
        // Initialize debug system.
        //

        DbgkInitialize ();

        //
        // Compute the tick count multiplier that is used for computing the
        // windows millisecond tick count and copy the resultant value to
        // the memory that is shared between user and kernel mode.
        //

        ExpTickCountMultiplier = ExComputeTickCountMultiplier(KeMaximumIncrement);
        SharedUserData->TickCountMultiplier = ExpTickCountMultiplier;

        //
        // Set the base os version into shared memory
        //

        SharedUserData->NtMajorVersion = NtMajorVersion;
        SharedUserData->NtMinorVersion = NtMinorVersion;

        //
        // Set the supported image number range used to determine by the
        // loader if a particular image can be executed on the host system.
        // Eventually this will need to be dynamically computed. Also set
        // the architecture specific feature bits.
        //

#if defined(_AMD64_)

        SharedUserData->ImageNumberLow = IMAGE_FILE_MACHINE_AMD64;
        SharedUserData->ImageNumberHigh = IMAGE_FILE_MACHINE_AMD64;

#elif defined(_X86_)

        SharedUserData->ImageNumberLow = IMAGE_FILE_MACHINE_I386;
        SharedUserData->ImageNumberHigh = IMAGE_FILE_MACHINE_I386;

#else

#error "no target architecture"

#endif

    }
    else {

        //
        // Initialize the Hardware Architecture Layer (HAL).
        //

        if (HalInitSystem(InitializationPhase, LoaderBlock) == FALSE) {
            KeBugCheck(HAL_INITIALIZATION_FAILED);
        }
    }

    return;
}

/*++

Routine Description:

    This routine is a paged stub that calls a discardable routine to do
    the real work.  This is because Mm reuses the discardable routine's
    (INIT) memory after phase 1 completes, but must keep this routine
    around so that the stack walker can obtain correct prologues/epilogues.

Arguments:

    Context - Supplies the loader block.

Return Value:

    None.

--*/

VOID
Phase1Initialization (
    IN PVOID Context
    )

{
    Phase1InitializationDiscard (Context);
    MmZeroPageThread();
    return;
}

VOID
Phase1InitializationDiscard (
    IN PVOID Context
    )

{
    PLOADER_PARAMETER_BLOCK LoaderBlock;
    PETHREAD Thread;
    PKPRCB Prcb;
    KPRIORITY Priority;
    NTSTATUS Status;
    UNICODE_STRING SessionManager;
    PRTL_USER_PROCESS_PARAMETERS ProcessParameters;
    PVOID Address;
    SIZE_T Size;
    LARGE_INTEGER UniversalTime;
    LARGE_INTEGER CmosTime;
    LARGE_INTEGER OldTime;
    TIME_FIELDS TimeFields;
    UNICODE_STRING EnvString, NullString, UnicodeSystemDriveString;
    PWSTR Src, Dst;
    BOOLEAN ResetActiveTimeBias;
    HANDLE NlsSection;
    LARGE_INTEGER SectionSize;
    LARGE_INTEGER SectionOffset;
    PVOID SectionBase;
    PVOID ViewBase;
    ULONG CacheViewSize;
    SIZE_T CapturedViewSize;
    ULONG SavedViewSize;
    LONG BootTimeZoneBias;
    PKLDR_DATA_TABLE_ENTRY DataTableEntry;
#ifndef NT_UP
    PMESSAGE_RESOURCE_ENTRY MessageEntry1;
#endif
    PCHAR MPKernelString;
    PCHAR Options;
    PCHAR YearOverrideOption;
    LONG  CurrentYear = 0;
    BOOLEAN NOGUIBOOT;
    BOOLEAN SOS;
    PVOID Environment;

    PRTL_USER_PROCESS_INFORMATION ProcessInformation;
   
    ProcessInformation = ExAllocatePoolWithTag(NonPagedPool,
                                        sizeof(*ProcessInformation),
                                        'tinI');

    if (ProcessInformation == NULL) {
        KeBugCheckEx(PHASE1_INITIALIZATION_FAILED,
                    STATUS_NO_MEMORY,
                    8,
                    0,
                    0);
    }

    //
    // The following is a dummy reference section to inline functions that
    // need to have a reference forced. This code is never executed, but the
    // compiler can never assume it isn't.
    //
    // N.B. The control variable is always false.
    //

    if (InitForceInline == TRUE) {
        KGUARDED_MUTEX Mutex;
        extern ULONG volatile *VpPoolHitTag;

        KeTryToAcquireGuardedMutex(&Mutex);
        KeEnterGuardedRegion();
        KeLeaveGuardedRegion();
        KeAreApcsDisabled();
        KeRaiseIrqlToDpcLevel();
        VpPoolHitTag = &PoolHitTag;
    }

    //
    // Set the phase number and raise the priority of current thread to
    // a high priority so it will not be preempted during initialization.
    //

    ResetActiveTimeBias = FALSE;
    InitializationPhase = 1;
    Thread = PsGetCurrentThread();
    Priority = KeSetPriorityThread( &Thread->Tcb,MAXIMUM_PRIORITY - 1 );

    LoaderBlock = (PLOADER_PARAMETER_BLOCK)Context;

    //
    // Put Phase 1 initialization calls here.
    //

    if (HalInitSystem(InitializationPhase, LoaderBlock) == FALSE) {
        KeBugCheck(HAL1_INITIALIZATION_FAILED);
    }

    //
    // Allow the boot video driver to behave differently based on the
    // OsLoadOptions.
    //

    Options = LoaderBlock->LoadOptions ? _strupr(LoaderBlock->LoadOptions) : NULL;

    if (Options) {
        NOGUIBOOT = (BOOLEAN)(strstr(Options, "NOGUIBOOT") != NULL);
    } else {
        NOGUIBOOT = FALSE;
    }

    InbvEnableBootDriver((BOOLEAN)!NOGUIBOOT);

    //
    // There is now enough functionality for the system Boot Video
    // Driver to run.
    //

    InbvDriverInitialize(LoaderBlock, 18);

    if (NOGUIBOOT) {

        //
        // If the user specified the noguiboot switch we don't want to
        // use the bootvid driver, so release display ownership.
        //

        InbvNotifyDisplayOwnershipLost(NULL);
    }

    if (Options) {
        SOS = (BOOLEAN)(strstr(Options, "SOS") != NULL);
    } else {
        SOS = FALSE;
    }

    if (NOGUIBOOT) {
        InbvEnableDisplayString(FALSE);
    } else {
        InbvEnableDisplayString(SOS);
        DisplayBootBitmap(SOS);
    }
(...................)


Oula sa fait déjà beaucoup de ligne de code!
Sinon petite question: d'où te viens le nom ''Mandrev''?

(Code source (extrait) de NT Kernel 5.2 Microsoft Windows en ligne )

Nom inventé mais découpé :

Mandrev vient de : "Man" pour Mantrix ; "Drev" en respect d'un ami qu'on appel le "Docteur Ev" : un délire étudient entre nous mdr mais c'est lui (son vrai nom est Jérôme) qui à trouver l'astuce du Kernel en C# (enfin pour Mantrix du moins ') Mais sa se pronconce bien << MANDRAIVE >>