Quelle est la différence entre l’espace kernel et l’espace utilisateur?

Quelle est la différence entre l’espace kernel et l’espace utilisateur? Est-ce que l’espace kernel, les threads du kernel, les processus du kernel et la stack du kernel ont la même signification? Aussi, pourquoi avons-nous besoin de cette différenciation?

    La réponse vraiment simplifiée est que le kernel s’exécute dans l’espace du kernel et que les programmes normaux s’exécutent dans l’espace utilisateur. L’espace utilisateur est essentiellement une forme de sand-boxing – il restreint les programmes utilisateur afin qu’ils ne puissent pas gâcher la mémoire (et d’autres ressources) appartenant à d’autres programmes ou au kernel du système d’exploitation. Cela limite (mais n’élimine généralement pas complètement) leur capacité à faire de mauvaises choses, comme un crash de la machine.

    Le kernel est le kernel du système d’exploitation. Il a normalement un access complet à toute la mémoire et au matériel de la machine (et à tout le rest sur la machine). Pour que la machine rest aussi stable que possible, vous ne devez normalement exécuter que le code le plus fiable et le mieux testé en mode kernel / espace kernel.

    La stack est juste une autre partie de la mémoire, donc naturellement, elle est séparée avec le rest de la mémoire.

    La mémoire vive (RAM) peut être logiquement divisée en deux régions distinctes, à savoir: l’espace kernel et l’espace utilisateur ( les adresses physiques de la mémoire vive ne sont pas divisées en réalité par les seules adresses virtuelles , toutes mises en œuvre par la MMU ).

    Le kernel s’exécute dans la partie de la mémoire qui y a droit. Cette partie de la mémoire ne peut pas être accédée directement par les processus des utilisateurs normaux, tandis que le kernel peut accéder à toutes les parties de la mémoire. Pour accéder à certaines parties du kernel, les processus utilisateurs doivent utiliser les appels système prédéfinis, c’est-à-dire open , read , write etc. De même, les fonctions de la bibliothèque C comme printf appellent l’appel système.

    Les appels système agissent comme une interface entre les processus utilisateur et les processus du kernel. Les droits d’access sont placés sur l’espace du kernel afin d’empêcher les utilisateurs de manipuler le kernel, sans le savoir.

    Ainsi, lorsqu’un appel système se produit, une interruption logicielle est envoyée au kernel. L’UC peut transférer le contrôle temporairement à la routine de gestionnaire d’interruption associée. Le processus du kernel qui a été interrompu par l’interruption reprend après que la routine du gestionnaire d’interruption ait terminé son travail.

    L’espace kernel et l’espace virtuel sont des concepts de mémoire virtuelle …. cela ne signifie pas que Ram (votre mémoire actuelle) est divisé en kernel et espace utilisateur. Chaque processus reçoit une mémoire virtuelle divisée en kernel et espace utilisateur.

    En disant “La mémoire vive (RAM) peut être divisée en deux régions distinctes, à savoir: l’espace kernel et l’espace utilisateur.” est faux.

    & en ce qui concerne “espace kernel vs espace utilisateur”

    Lorsqu’un processus est créé et que sa mémoire virtuelle est divisée en espace utilisateur et en espace kernel, où la zone d’espace utilisateur contient des données, du code, de la stack, du tas et de l’espace kernel, des éléments tels que la table de pages du processus , structures de données du kernel et code du kernel, etc. Pour exécuter le code d’espace du kernel, le contrôle doit passer en mode kernel (en utilisant l’interruption logicielle 0x80 pour les appels système) et la stack du kernel est partagée entre tous les processus en cours dans le kernel.

    L’espace kernel et l’espace utilisateur sont la séparation des fonctions du système d’exploitation privilégiées et des applications utilisateur restreintes. La séparation est nécessaire pour empêcher les applications utilisateur de saccager votre ordinateur. Ce serait une mauvaise chose si un ancien programme utilisateur pouvait commencer à écrire des données aléatoires sur votre disque dur ou à lire de la mémoire depuis l’espace mémoire d’un autre programme utilisateur.

    Les programmes d’espace utilisateur ne peuvent pas accéder directement aux ressources du système, de sorte que le kernel du système d’exploitation gère l’access au nom du programme. Les programmes d’espace utilisateur effectuent généralement de telles requêtes du système d’exploitation via des appels système.

    Les threads du kernel, les processus, la stack ne signifient pas la même chose. Ce sont des constructions analogues pour l’espace kernel en tant que contreparties dans l’espace utilisateur.

    Chaque processus a sa propre mémoire virtuelle de 4 Go qui correspond à la mémoire physique via des tables de pages. La mémoire virtuelle est principalement divisée en deux parties: 3 Go pour l’utilisation du processus et 1 Go pour l’utilisation du kernel. La plupart des variables que vous créez se trouvent dans la première partie de l’espace d’adressage. Cette partie est appelée espace utilisateur. La dernière partie est l’endroit où le kernel réside et est commun à tous les processus. Cela s’appelle l’espace du kernel et la majeure partie de cet espace est mappée aux emplacements de départ de la mémoire physique où l’image du kernel est chargée au démarrage.

    Les anneaux de CPU sont la distinction la plus claire

    En mode x86 protégé, le processeur est toujours dans l’un des 4 anneaux. Le kernel Linux n’utilise que 0 et 3:

    • 0 pour le kernel
    • 3 pour les utilisateurs

    C’est la définition la plus dure et la plus rapide du kernel par rapport à l’utilisateur.

    Pourquoi Linux n’utilise pas les anneaux 1 et 2: CPU Privilege Rings: Pourquoi les anneaux 1 et 2 ne sont-ils pas utilisés?

    Comment l’anneau actuel est-il déterminé?

    L’anneau actuel est sélectionné par une combinaison de:

    • tableau descripteur global: une table en mémoire des entrées GDT, et chaque entrée a un champ Privl qui code l’anneau.

      L’instruction LGDT définit l’adresse sur la table de descripteurs actuelle.

      Voir aussi: http://wiki.osdev.org/Global_Descriptor_Table

    • le segment enregistre CS, DS, etc., qui pointe vers l’index d’une entrée dans le GDT.

      Par exemple, CS = 0 signifie que la première entrée du GDT est actuellement active pour le code en cours d’exécution.

    Que peut faire chaque anneau?

    La puce du processeur est construite physiquement pour que:

    • l’anneau 0 peut faire n’importe quoi

    • l’anneau 3 ne peut pas exécuter plusieurs instructions et écrire sur plusieurs registres, notamment:

      • ne peut pas changer sa propre bague! Sinon, il pourrait se mettre à sonner 0 et les sonneries seraient inutiles.

        En d’autres termes, vous ne pouvez pas modifier le descripteur de segment en cours, qui détermine l’anneau en cours.

      • ne peut pas modifier les tables de pages: comment fonctionne la pagination x86?

        En d’autres termes, impossible de modifier le registre CR3, et la pagination elle-même empêche la modification des tables de pages.

        Cela empêche un processus de voir la mémoire des autres processus pour des raisons de sécurité / facilité de programmation.

      • ne peut pas enregistrer les gestionnaires d’interruption. Ceux-ci sont configurés en écrivant dans des emplacements de mémoire, ce qui est également empêché par la pagination.

        Les gestionnaires s’exécutent dans l’anneau 0 et briseraient le modèle de sécurité.

        En d’autres termes, ne pouvez pas utiliser les instructions LGDT et LIDT.

      • ne peut pas faire des instructions IO comme in et out , et donc avoir des access matériels arbitraires.

        Sinon, par exemple, les permissions de fichiers seraient inutiles si un programme pouvait directement lire à partir du disque.

        Plus précisément grâce à Michael Petch : il est effectivement possible que le système d’exploitation autorise les instructions IO sur le ring 3, ce qui est en fait contrôlé par le segment d’état Task .

        Ce qui n’est pas possible, c’est que la bague 3 se donne la permission de le faire si elle ne l’avait pas au départ.

        Linux l’interdit toujours. Voir aussi: Pourquoi Linux n’utilise-t-il pas le changement de contexte matériel via le TSS?

    Comment les programmes et les systèmes d’exploitation font-ils la transition entre les anneaux?

    • quand le CPU est allumé, il lance le programme initial dans le ring 0 (et bien, mais c’est une bonne approximation). Vous pouvez penser que ce programme initial est le kernel (mais c’est normalement un chargeur de démarrage qui appelle le kernel toujours dans l’anneau 0).

    • Lorsqu’un processus utilisateur souhaite que le kernel fasse quelque chose comme écrire dans un fichier, il utilise une instruction qui génère une interruption telle que int 0x80 pour signaler au kernel.

      Lorsque cela se produit, le processeur appelle et interrompt le gestionnaire de rappel que le kernel a enregistré au démarrage.

      Ce gestionnaire s’exécute dans l’anneau 0, qui décide si le kernel autorisera cette action, effectuera l’action et redémarrera le programme utilisateur dans l’anneau 3.

    • lorsque l’appel système exec est utilisé (ou lorsque le kernel démarre /init ), le kernel prépare les registres et la mémoire du nouveau processus utilisateur, puis passe au point d’entrée et bascule le processeur sur l’anneau 3

    • Si le programme essaie de faire quelque chose de méchant comme écrire dans un registre ou une adresse mémoire interdite (à cause de la pagination), le CPU appelle également un gestionnaire de rappel du kernel dans la sonnerie 0.

      Mais comme l’utilisateur était méchant, le kernel risquait de tuer le processus cette fois-ci ou de lui donner un avertissement avec un signal.

    • Lorsque le kernel démarre, il configure une horloge matérielle avec une fréquence fixe, ce qui génère des interruptions périodiquement.

      Cette horloge matérielle génère des interruptions qui exécutent l’anneau 0 et lui permettent de planifier les processus utilisateur à activer.

      De cette manière, la planification peut se produire même si les processus ne font aucun appel système.

    Quel est l’intérêt d’avoir plusieurs anneaux?

    La séparation du kernel et de l’espace utilisateur présente deux avantages majeurs:

    • il est plus facile de faire des programmes car vous êtes plus certain que l’on n’interférera pas avec l’autre. Par exemple, un processus utilisateur ne doit pas se soucier d’écraser la mémoire d’un autre programme à cause de la pagination, ni de mettre le matériel dans un état invalide pour un autre processus.
    • c’est plus sécurisé. Par exemple, les permissions de fichiers et la séparation de mémoire pourraient empêcher une application de piratage de lire vos données bancaires. Cela suppose, bien sûr, que vous fassiez confiance au kernel.

    Comment jouer avec ça?

    J’ai créé une configuration sans système d’exploitation qui devrait être un bon moyen de manipuler les anneaux directement: https://github.com/cirosantilli/x86-bare-metal-examples

    Je n’ai malheureusement pas eu la patience de faire un exemple d’espace utilisateur, mais je suis allé jusqu’à la configuration de la pagination, donc la zone des utilisateurs devrait être faisable. J’aimerais voir une demande de tirage.

    Alternativement, les modules du kernel Linux s’exécutent dans ring 0, vous pouvez donc les utiliser pour tester des opérations privilégiées, par exemple lire les registres de contrôle: Comment accéder aux registres de contrôle cr0, cr2, cr3 d’un programme? Obtenir une erreur de segmentation

    Voici une configuration pratique de QEMU + Buildroot pour l’essayer sans tuer votre hôte.

    L’inconvénient des modules du kernel est que d’autres kthreads sont en cours d’exécution et pourraient interférer avec vos expériences. Mais en théorie, vous pouvez reprendre tous les gestionnaires d’interruption avec votre module kernel et posséder le système, ce qui serait un projet intéressant.

    Anneaux négatifs

    Bien que les anneaux négatifs ne soient pas réellement référencés dans le manuel Intel, il existe en réalité des modes CPU qui ont des capacités supplémentaires par rapport à l’anneau 0 lui-même, et conviennent donc parfaitement au nom de “l’anneau négatif”.

    Un exemple est le mode hyperviseur utilisé dans la virtualisation.

    Pour plus de détails, voir: https://security.stackexchange.com/questions/129098/what-is-protection-ring-1

    BRAS

    Dans ARM, les anneaux s’appellent plutôt des niveaux d’exception, mais les idées principales restnt les mêmes.

    Il existe 4 niveaux d’exception dans ARMv8, couramment utilisés comme:

    • EL0: Userland

    • EL1: kernel

    • EL2: hyperviseurs , par exemple Xen .

      Un hyperviseur est un système d’exploitation, un système d’exploitation pour l’utilisateur.

      Par exemple, Xen vous permet d’exécuter plusieurs systèmes d’exploitation tels que Linux ou Windows sur le même système en même temps, et d’isoler les systèmes d’exploitation pour la sécurité et la facilité de débogage, comme Linux pour les programmes utilisateur.

      Les hyperviseurs sont un élément clé de l’infrastructure cloud actuelle: ils permettent à plusieurs serveurs de fonctionner sur un seul matériel, ce qui permet de toujours utiliser le matériel à 100% et d’économiser beaucoup d’argent.

      AWS, par exemple, a utilisé Xen jusqu’en 2017 lorsque son passage à KVM a fait la une .

    • EL3: encore un autre niveau. Exemple TODO.

    Le modèle de référence de l’architecture ARMv8 DDI 0487C.a – Chapitre D1 – Le modèle de programmeur de niveau système AArch64 – La figure D1-1 illustre cela de manière magnifique:

    entrer la description de l'image ici

    Notez que ARM, peut-être en raison du recul, a une meilleure convention de nommage pour les niveaux de privilèges que x86, sans avoir besoin de niveaux négatifs: 0 étant le plus faible et 3 le plus élevé. Les niveaux supérieurs ont tendance à être créés plus souvent que les niveaux inférieurs.

    La taille maximale de l’espace d’adressage dépend de la longueur du registre d’adresses sur le processeur.

    Sur les systèmes dotés de registres d’adresses 32 bits, la taille maximale de l’espace d’adressage est de 2 32 octets ou de 4 Gio. De même, sur les systèmes 64 bits, 2 64 octets peuvent être adressés.

    Cet espace adresse est appelé mémoire virtuelle ou espace d’adressage virtuel . Il n’est pas réellement lié à la taille de la RAM physique.

    Sur les plates-formes Linux, l’espace d’adressage virtuel est divisé en espace kernel et en espace utilisateur.

    Une constante spécifique à l’architecture, appelée limite de taille de tâche , ou TASK_SIZE , indique la position du fractionnement:

    • la plage d’adresses allant de 0 à TASK_SIZE -1 est atsortingbuée à l’espace utilisateur;

    • le rest de TASK_SIZE jusqu’à 2 32 -1 (ou 2 64 -1) est atsortingbué à l’espace kernel.

    Sur un système 32 bits particulier, par exemple, 3 Gio pourraient être occupés pour l’espace utilisateur et 1 Gio pour l’espace kernel.

    Chaque application / programme dans un système d’exploitation de type Unix est un processus; chacun d’eux a un identifiant unique appelé Identificateur de processus (ou simplement ID de processus , c’est-à-dire PID). Linux fournit deux mécanismes pour créer un processus: 1. l’appel système fork() , ou 2. l’appel exec() .

    Un thread de kernel est un processus léger et également un programme en cours d’exécution. Un seul processus peut être composé de plusieurs threads partageant les mêmes données et ressources, mais empruntant des chemins différents dans le code du programme. Linux fournit un appel système clone() pour générer des threads.

    Les exemples d’utilisation des threads du kernel sont: la synchronisation des données de la RAM, aidant le planificateur à répartir les processus entre les processeurs, etc.

    En bref: le kernel tourne dans Kernel Space, l’espace du kernel a un access complet à toute la mémoire et aux ressources, vous pouvez dire que la mémoire se divise en deux parties, une partie pour le kernel et L’espace ne peut pas accéder directement à l’espace kernel, il demande donc au kernel d’utiliser les ressources. par syscall (appel système prédéfini dans glibc)

    il y a une déclaration qui simplifie les différents ” L’espace utilisateur est juste une charge de test pour le kernel ” …

    Pour être très clair: l’architecture du processeur permet au processeur de fonctionner en deux modes, le mode kernel et le mode utilisateur , l’instruction matérielle permettant de passer d’un mode à l’autre.

    la mémoire peut être marquée comme faisant partie de l’espace utilisateur ou de l’espace kernel.

    Lorsque le processeur fonctionne en mode utilisateur, le processeur ne peut accéder qu’à la mémoire de l’espace utilisateur, alors que cpu tente d’accéder à la mémoire dans l’espace du kernel, le processeur peut accéder directement au processeur. à la fois de l’espace kernel et de l’espace utilisateur …

    L’espace kernel signifie qu’un espace mémoire ne peut être touché que par le kernel. Sur Linux 32 bits, c’est 1G (de 0xC0000000 à 0xffffffff comme adresse de mémoire virtuelle). Chaque processus créé par le kernel est aussi un thread de kernel. Donc, pour un processus, il y a deux stacks: une stack dans l’espace utilisateur pour ce processus et une autre dans le kernel espace pour le thread du kernel.

    la stack du kernel occupait 2 pages (8k sous linux 32bits), incluait une task_struct (environ 1k) et la stack réelle (environ 7k). Ce dernier est utilisé pour stocker certaines variables automatiques ou parameters d’appel de fonction ou adresse de fonction dans les fonctions du kernel. Voici le code (Processor.h (linux \ include \ asm-i386)):

     #define THREAD_SIZE (2*PAGE_SIZE) #define alloc_task_struct() ((struct task_struct *) __get_free_pages(GFP_KERNEL,1)) #define free_task_struct(p) free_pages((unsigned long) (p), 1) 

    __get_free_pages (GFP_KERNEL, 1)) signifie allouer de la mémoire en tant que 2 ^ 1 = 2 pages.

    Mais la stack de processus est une autre chose, son adresse est juste en dessous de 0xC0000000 (linux 32 bits), la taille de celui-ci peut être beaucoup plus grande, utilisée pour les appels de la fonction d’espace utilisateur.

    Alors, voici une question venue pour l’appel système, elle s’exécute dans l’espace kernel mais a été appelée par processus dans l’espace utilisateur, comment ça marche? Linux va-t-il placer ses parameters et son adresse de fonction dans la stack du kernel ou la stack de processus? La solution de Linux: tous les appels système sont déclenchés par l’interruption du logiciel INT 0x80. Défini dans entry.S (linux \ arch \ i386 \ kernel), voici quelques lignes par exemple:

     ENTRY(sys_call_table) .long SYMBOL_NAME(sys_ni_syscall) /* 0 - old "setup()" system call*/ .long SYMBOL_NAME(sys_exit) .long SYMBOL_NAME(sys_fork) .long SYMBOL_NAME(sys_read) .long SYMBOL_NAME(sys_write) .long SYMBOL_NAME(sys_open) /* 5 */ .long SYMBOL_NAME(sys_close) 

    Par Sunil Yadav, sur Quora:

    Le kernel Linux fait référence à tout ce qui fonctionne en mode kernel et se compose de plusieurs couches distinctes. Dans la couche inférieure, le kernel interagit avec le matériel via le HAL. Au niveau intermédiaire, le kernel UNIX est divisé en 4 zones distinctes. La première des quatre zones traite les dispositifs de caractères, les ATS bruts et cuits et la manipulation des terminaux. Le second domaine traite les pilotes de périphériques réseau, les protocoles de routage et les sockets. Le troisième domaine traite les pilotes de périphérique de disque, les caches de page et de mémoire tampon, le système de fichiers, la mémoire virtuelle, la dénomination et le mappage de fichiers. La quasortingème et dernière zone traite la répartition des processus, la planification, la création et la terminaison, ainsi que la gestion des signaux. Surtout, nous avons la couche supérieure du kernel qui inclut les appels système, les interruptions et les interruptions. Ce niveau sert d’interface à chacune des fonctions de niveau inférieur. Un programmeur utilise les différents appels et interruptions du système pour interagir avec les fonctionnalités du système d’exploitation.

    L’espace court du kernel IN est la partie de la mémoire où s’exécute le kernel Linux (espace virtuel supérieur de 1 Go en cas de Linux) et l’espace utilisateur est la partie de la mémoire exécutée par l’utilisateur (3 Go de mémoire virtuelle inférieure en Linux). veux en savoir plus le voir le lien ci-dessous 🙂

    http://learnlinuxconcepts.blogspot.in/2014/02/kernel-space-and-user-space.html

    Essayer de donner une explication très simplifiée

    La mémoire virtuelle est divisée en espace kernel et espace utilisateur. L’espace kernel est la zone de mémoire virtuelle où les processus du kernel s’exécutent et où l’espace utilisateur est la zone de mémoire virtuelle sur laquelle les processus utilisateur seront exécutés.

    Cette division est requirejse pour les protections d’access à la mémoire.

    Chaque fois qu’un chargeur de démarrage démarre un kernel après l’avoir chargé dans un emplacement RAM, (sur un contrôleur basé sur ARM en général), il doit s’assurer que le contrôleur est en mode superviseur avec les FIQ et les IRQ désactivés.

    La bonne réponse est la suivante: il n’ya pas d’espace kernel ni d’espace utilisateur. Le jeu d’instructions du processeur dispose d’permissions spéciales pour définir des éléments destructeurs, tels que la racine de la table des pages, ou pour accéder à la mémoire du périphérique matériel, etc.

    Le code du kernel a les privilèges les plus élevés et le code utilisateur le plus bas. Cela empêche le code utilisateur de bloquer le système, de modifier d’autres programmes, etc.

    Généralement, le code du kernel est conservé sous une carte mémoire différente de celle du code utilisateur (tout comme les espaces utilisateur sont conservés dans des cartes mémoire différentes les unes des autres). C’est de là que viennent les termes “espace kernel” et “espace utilisateur”. Mais ce n’est pas une règle ssortingcte. Par exemple, comme le x86 nécessite indirectement que ses gestionnaires d’interruptions / traps soient mappés à tout moment, une partie (ou certains systèmes d’exploitation) du kernel doit être mappée dans l’espace utilisateur. Encore une fois, cela ne signifie pas qu’un tel code a des privilèges d’utilisateur.

    Pourquoi la division kernel / utilisateur est-elle nécessaire? Certains concepteurs sont en désaccord avec le fait que cela est en fait nécessaire. L’architecture du micro-kernel repose sur l’idée que les sections de code privilégiées les plus élevées doivent être aussi petites que possible, toutes les opérations significatives étant effectuées dans le code privilégié par l’utilisateur. Vous devriez étudier pourquoi cela pourrait être une bonne idée, ce n’est pas un concept simple (et est célèbre pour ses avantages et ses inconvénients).

    L’espace kernel et l’espace utilisateur sont des espaces logiques.

    La plupart des processeurs modernes sont conçus pour fonctionner en mode privilégié différent. Les machines x86 peuvent fonctionner dans 4 modes privilégiés différents. entrer la description de l'image ici

    Et une instruction machine particulière peut être exécutée dans / au-dessus d’un mode privilégié particulier.

    En raison de cette conception, vous accordez une protection système ou un sand-boxing à l’environnement d’exécution.

    Le kernel est un morceau de code qui gère votre matériel et fournit une abstraction du système. Il doit donc avoir access à toutes les instructions de la machine. Et c’est le logiciel le plus fiable. Je devrais donc être exécuté avec le plus grand privilège. Et le niveau de sonnerie 0 est le mode le plus privilégié. Ainsi, le niveau de sonnerie 0 est également appelé en mode kernel .

    L’application utilisateur est un logiciel fourni par un fournisseur tiers et vous ne pouvez pas lui faire entièrement confiance. Quelqu’un avec une intention malveillante peut écrire un code pour faire planter votre système s’il avait un access complet à toutes les instructions de la machine. Donc, l’application doit être fournie avec un access à un ensemble limité d’instructions. Et le niveau de sonnerie 3 est le mode le moins privilégié. Donc, toute votre application s’exécute dans ce mode. Par conséquent, le niveau de sonnerie 3 est également appelé mode utilisateur .

    Note: Je ne reçois pas les niveaux de sonnerie 1 et 2. Ce sont essentiellement des modes avec des privilèges intermédiaires. Le code du pilote de périphérique peut donc être exécuté avec ce privilège. AFAIK, Linux utilise uniquement les niveaux de sonnerie 0 et 3 pour l’exécution du code du kernel et l’application utilisateur respectivement.

    Ainsi, toute opération en mode kernel peut être considérée comme un espace kernel. Et toute opération en mode utilisateur peut être considérée comme un espace utilisateur.

    Sous Linux, il y a deux espaces, le premier est l’espace utilisateur et un autre, l’espace kernal. L’espace utilisateur se compose uniquement de l’application utilisateur que vous souhaitez exécuter. en tant que service kernal, il y a la gestion des processus, la gestion des fichiers, la gestion des signaux, la gestion de la mémoire, la gestion des threads et de nombreux services y sont présents. Si vous exécutez l’application depuis l’espace utilisateur, cette application interagit uniquement avec le service kernal. et ce service est en interaction avec le pilote de périphérique qui est présent entre le matériel et kernal. Le principal avantage de la séparation de l’espace kernal et de l’espace utilisateur est que nous pouvons obtenir une sécurité par virus.bcaz de toutes les applications utilisateur présentes dans l’espace utilisateur et que le service est présent dans l’espace kernal. C’est pourquoi linux n’affecte pas le virus.