Quelle est la différence entre l'espace noyau et l'espace utilisateur? L'espace noyau, les threads du noyau, les processus du noyau et la pile du noyau signifient-ils la même chose? Aussi, pourquoi avons-nous besoin de cette différenciation?
Réponses:
La réponse vraiment simplifiée est que le noyau fonctionne dans l'espace noyau et que les programmes normaux s'exécutent dans l'espace utilisateur. L'espace utilisateur est essentiellement une forme de bac à sable - il restreint les programmes utilisateur afin qu'ils ne puissent pas jouer avec la mémoire (et d'autres ressources) appartenant à d'autres programmes ou au noyau du système d'exploitation. Cela limite (mais n'élimine généralement pas entièrement) leur capacité à faire de mauvaises choses comme faire planter la machine.
Le noyau est le cœur du système d'exploitation. Il a normalement un accès complet à toute la mémoire et au matériel de la machine (et à tout le reste de la machine). Pour garder la machine aussi stable que possible, vous voulez normalement que seul le code le plus fiable et le mieux testé s'exécute en mode noyau / espace noyau.
La pile n'est qu'une autre partie de la mémoire, elle est donc naturellement séparée avec le reste de la mémoire.
La mémoire vive (RAM) peut être logiquement divisée en deux régions distinctes à savoir - l'espace du noyau et l'espace utilisateur ( les adresses physiques de la RAM ne sont pas réellement divisées uniquement les adresses virtuelles , tout cela mis en œuvre par la MMU ).
Le noyau tourne dans la partie de la mémoire qui y a droit. Cette partie de la mémoire n'est pas accessible directement par les processus des utilisateurs normaux, tandis que le noyau peut accéder à toutes les parties de la mémoire. Pour accéder à une partie du noyau, les processus utilisateur doivent utiliser les appels système prédéfini à savoir open, read, writeetc. De plus, les Cfonctions de la bibliothèque comme printfappel l'appel du système writeà son tour.
Les appels système agissent comme une interface entre les processus utilisateur et les processus du noyau. Les droits d'accès sont placés sur l'espace noyau afin d'empêcher les utilisateurs de déranger le noyau, sans le savoir.
Ainsi, lorsqu'un appel système se produit, une interruption logicielle est envoyée au noyau. L'UC peut transférer temporairement le contrôle au sous-programme de gestion d'interruption associé. Le processus du noyau qui a été interrompu par l'interruption reprend une fois que la routine du gestionnaire d'interruption a terminé son travail.
L'espace noyau et l'espace virtuel sont des concepts de mémoire virtuelle ... cela ne signifie pas que Ram (votre mémoire réelle) est divisé en espace noyau et utilisateur. Chaque processus reçoit une mémoire virtuelle qui est divisée en noyau et espace utilisateur.
Ainsi en disant "La mémoire vive (RAM) peut être divisée en deux régions distinctes à savoir - l'espace noyau et l'espace utilisateur." est faux.
& concernant la chose "espace noyau vs espace utilisateur"
Lorsqu'un processus est créé et que sa mémoire virtuelle est divisée en espace utilisateur et en espace noyau, où la région de l'espace utilisateur contient des données, du code, une pile, un tas du processus et l'espace noyau contient des éléments tels que la table des pages du processus , les structures de données du noyau et le code du noyau, etc. Pour exécuter le code de l'espace du noyau, le contrôle doit passer en mode noyau (en utilisant l'interruption logicielle 0x80 pour les appels système) et la pile du noyau est essentiellement partagée entre tous les processus en cours d'exécution dans l'espace du noyau.
Les anneaux de processeur sont la distinction la plus claire
En mode protégé x86, le CPU est toujours dans l'un des 4 anneaux. Le noyau Linux n'utilise que 0 et 3:
C'est la définition la plus dure et la plus rapide de kernel vs userland.
Pourquoi Linux n'utilise pas les anneaux 1 et 2: Anneaux de privilèges CPU: Pourquoi les anneaux 1 et 2 ne sont pas utilisés?
Comment la sonnerie actuelle est-elle déterminée?
La sonnerie actuelle est sélectionnée par une combinaison de:
table de descripteur global: une table en mémoire des entrées GDT, et chaque entrée a un champ Privlqui 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
les registres de segments CS, DS, etc., qui pointent vers l'index d'une entrée dans le GDT.
Par exemple, CS = 0signifie 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 CPU est physiquement construite de sorte que:
la sonnerie 0 peut tout faire
ring 3 ne peut pas exécuter plusieurs instructions et écrire dans plusieurs registres, notamment:
ne peut pas changer sa propre bague! Sinon, il pourrait se mettre à la sonnerie 0 et les sonneries seraient inutiles.
En d'autres termes, impossible de modifier le descripteur de segment actuel , qui détermine la sonnerie actuelle.
impossible de modifier les tables de pages: comment fonctionne la pagination x86?
En d'autres termes, ne peut pas 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 d'autres processus pour des raisons de sécurité / facilité de programmation.
impossible d'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 peut pas utiliser les instructions LGDT et LIDT.
ne peut pas faire des instructions IO comme inet out, et donc avoir des accès matériels arbitraires.
Sinon, par exemple, les autorisations sur les fichiers seraient inutiles si un programme pouvait lire directement à partir du disque.
Plus précisément grâce à Michael Petch : il est en fait possible pour l'OS d'autoriser les instructions IO sur l'anneau 3, ceci est en fait contrôlé par le segment d'état de la tâche .
Ce qui n'est pas possible, c'est que l'anneau 3 se donne la permission de le faire s'il ne l'avait pas en premier lieu.
Linux le refuse 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?
lorsque le processeur est allumé, il commence à exécuter le programme initial dans l'anneau 0 (en quelque sorte, mais c'est une bonne approximation). Vous pouvez penser que ce programme initial est le noyau (mais c'est normalement un bootloader qui appelle ensuite le noyau toujours dans l'anneau 0 ).
quand un processus utilisateur veut que le noyau fasse quelque chose pour lui comme écrire dans un fichier, il utilise une instruction qui génère une interruption telle que int 0x80ousyscall pour signaler le noyau. x86-64 Linux syscall bonjour exemple:
.data
hello_world:
.ascii "hello world\n"
hello_world_len = . - hello_world
.text
.global _start
_start:
/* write */
mov $1, %rax
mov $1, %rdi
mov $hello_world, %rsi
mov $hello_world_len, %rdx
syscall
/* exit */
mov $60, %rax
mov $0, %rdi
syscall
compilez et exécutez:
as -o hello_world.o hello_world.S
ld -o hello_world.out hello_world.o
./hello_world.out
Lorsque cela se produit, le CPU appelle un gestionnaire de rappel d'interruption que le noyau a enregistré au moment du démarrage. Voici un exemple concret de baremetal qui enregistre un gestionnaire et l'utilise .
Ce gestionnaire s'exécute dans l'anneau 0, qui décide si le noyau autorisera cette action, exécutera l'action et redémarrera le programme userland dans l'anneau 3. x86_64
lorsque l' execappel système est utilisé (ou lorsque le noyau démarrera/init ), le noyau prépare les registres et la mémoire du nouveau processus userland, puis il saute au point d'entrée et fait passer le CPU en sonnerie 3
Si le programme essaie de faire quelque chose de vilain comme écrire dans un registre ou une adresse mémoire interdits (à cause de la pagination), le CPU appelle également un gestionnaire de rappel du noyau dans l'anneau 0.
Mais comme le userland était vilain, le noyau pourrait tuer le processus cette fois, ou lui donner un avertissement avec un signal.
Lorsque le noyau démarre, il configure une horloge matérielle avec une fréquence fixe, qui génère périodiquement des interruptions.
Cette horloge matérielle génère des interruptions qui exécutent l'anneau 0 et lui permettent de planifier les processus utilisateur à réveiller.
De cette façon, la planification peut se produire même si les processus n'effectuent aucun appel système.
Quel est l'intérêt d'avoir plusieurs anneaux?
Il y a deux avantages majeurs à séparer le noyau et le userland:
Comment jouer avec?
J'ai créé une configuration bare metal qui devrait être un bon moyen de manipuler directement les anneaux: https://github.com/cirosantilli/x86-bare-metal-examples
Je n'ai malheureusement pas eu la patience de créer un exemple de userland, mais je suis allé aussi loin que la configuration de la pagination, donc userland devrait être faisable. J'adorerais voir une demande de tirage.
Alternativement, les modules du noyau Linux fonctionnent dans l'anneau 0, vous pouvez donc les utiliser pour essayer 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 depuis un programme? Obtenir une erreur de segmentation
Voici une configuration QEMU + Buildroot pratique pour l'essayer sans tuer votre hôte.
L'inconvénient des modules du noyau 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 prendre en charge tous les gestionnaires d'interruptions avec votre module de noyau et posséder le système, ce serait en fait 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 d'Intel, il existe en fait des modes CPU qui ont d'autres capacités que l'anneau 0 lui-même, et sont donc un bon choix pour le nom «anneau négatif».
Un exemple est le mode hyperviseur utilisé dans la virtualisation.
Pour plus de détails, voir:
BRAS
Dans ARM, les anneaux sont appelés niveaux d'exception à la place, mais les idées principales restent les mêmes.
Il existe 4 niveaux d'exception dans ARMv8, couramment utilisés comme:
EL0: userland
EL1: noyau ("superviseur" dans la terminologie ARM).
Saisie avec l' svcinstruction (SuperVisor Call), précédemment connue sous le nom de swi before unified assembly , qui est l'instruction utilisée pour effectuer des appels système Linux. Exemple Hello world ARMv8:
bonjour.
.text
.global _start
_start:
/* write */
mov x0, 1
ldr x1, =msg
ldr x2, =len
mov x8, 64
svc 0
/* exit */
mov x0, 0
mov x8, 93
svc 0
msg:
.ascii "hello syscall v8\n"
len = . - msg
Testez-le avec QEMU sur Ubuntu 16.04:
sudo apt-get install qemu-user gcc-arm-linux-gnueabihf
arm-linux-gnueabihf-as -o hello.o hello.S
arm-linux-gnueabihf-ld -o hello hello.o
qemu-arm hello
Voici un exemple concret de baremetal qui enregistre un gestionnaire SVC et effectue un appel SVC .
EL2: hyperviseurs , par exemple Xen .
Entré avec l' hvcinstruction (HyperVisor Call).
Un hyperviseur est à un OS, ce qu'un OS est à un userland.
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 il isole les systèmes d'exploitation les uns des autres pour la sécurité et la facilité de débogage, tout comme Linux le fait pour les programmes utilisateur.
Les hyperviseurs sont un élément clé de l'infrastructure cloud d'aujourd'hui: ils permettent à plusieurs serveurs de fonctionner sur un seul matériel, en maintenant l'utilisation du matériel toujours proche de 100% et en économisant beaucoup d'argent.
AWS, par exemple, a utilisé Xen jusqu'en 2017, date à laquelle son passage au KVM a fait l'actualité .
EL3: encore un autre niveau. Exemple TODO.
Entré avec l' smcinstruction (Appel en mode sécurisé)
Le modèle de référence d'architecture ARMv8 DDI 0487C.a - Chapitre D1 - Le modèle du programmeur de niveau système AArch64 - La figure D1-1 illustre cela magnifiquement:
La situation ARM a un peu changé avec l'avènement des extensions d'hôte de virtualisation ARMv8.1 (VHE) . Cette extension permet au noyau de fonctionner efficacement dans EL2:
VHE a été créé parce que les solutions de virtualisation dans le noyau Linux telles que KVM ont gagné du terrain par rapport à Xen (voir par exemple le passage d'AWS au KVM mentionné ci-dessus), parce que la plupart des clients n'ont besoin que de machines virtuelles Linux, et comme vous pouvez l'imaginer, être tous dans un seul projet, KVM est plus simple et potentiellement plus efficace que Xen. Alors maintenant, le noyau Linux hôte joue le rôle d'hyperviseur dans ces cas.
Notez comment ARM, peut-être en raison de l'avantage du recul, a une meilleure convention de dénomination pour les niveaux de privilège que x86, sans avoir besoin de niveaux négatifs: 0 étant le plus bas et 3 le plus élevé. Les niveaux supérieurs ont tendance à être créés plus souvent que les niveaux inférieurs.
Le EL actuel peut être interrogé avec l' MRSinstruction: quel est le mode d'exécution actuel / niveau d'exception, etc.?
ARM n'exige pas que tous les niveaux d'exception soient présents pour permettre des implémentations qui n'ont pas besoin de la fonction pour enregistrer la zone de puce. ARMv8 "Niveaux d'exception" dit:
Une implémentation peut ne pas inclure tous les niveaux d'exception. Toutes les implémentations doivent inclure EL0 et EL1. EL2 et EL3 sont facultatifs.
QEMU par exemple par défaut sur EL1, mais EL2 et EL3 peuvent être activés avec les options de ligne de commande: qemu-system-aarch64 entrant el1 lors de l'émulation de la mise sous tension de a53
Extraits de code testés sur Ubuntu 18.10.
L'espace noyau et l'espace utilisateur sont la séparation des fonctions du système d'exploitation privilégié 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 la mémoire à partir de l'espace mémoire d'un autre programme utilisateur.
Les programmes de l'espace utilisateur ne peuvent pas accéder directement aux ressources système, l'accès est donc géré au nom du programme par le noyau du système d'exploitation. Les programmes de l'espace utilisateur font généralement de telles demandes au système d'exploitation via des appels système.
Les threads du noyau, les processus, la pile ne signifient pas la même chose. Ce sont des constructions analogues pour l'espace noyau comme leurs homologues 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 noyau. La plupart des variables que vous créez se trouvent dans la première partie de l'espace d'adressage. Cette partie s'appelle l'espace utilisateur. La dernière partie est l'endroit où réside le noyau et est commune à tous les processus. C'est ce qu'on appelle l'espace noyau et la majeure partie de cet espace est mappée aux emplacements de départ de la mémoire physique où l'image du noyau est chargée au démarrage.
La taille maximale de l'espace d'adressage dépend de la longueur du registre d'adresses sur la CPU.
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, soit 4 Gio. De même, sur les systèmes 64 bits, 2 64 octets peuvent être adressés.
Cet espace d'adressage est appelé mémoire virtuelle ou espace d'adressage virtuel . Ce n'est pas réellement lié à la taille physique de la RAM.
Sur les plates-formes Linux, l'espace d'adressage virtuel est divisé en espace noyau et espace utilisateur.
Une constante spécifique à l'architecture appelée limite de taille de tâche , ou TASK_SIZE, marque la position où le fractionnement se produit:
la plage d'adresses de 0 à TASK_SIZE-1 est allouée à l'espace utilisateur;
le reste de TASK_SIZEjusqu'à 2 32 -1 (ou 2 64 -1) est alloué à l'espace noyau.
Sur un système 32 bits particulier, par exemple, 3 Gio peuvent être occupés pour l'espace utilisateur et 1 Gio pour l'espace noyau.
Chaque application / programme dans un système d'exploitation de type Unix est un processus; chacun d'eux a un identifiant unique appelé Process Identifier (ou simplement Process ID , c'est-à-dire PID). Linux fournit deux mécanismes pour créer un processus: 1. l' fork()appel système, ou 2. leexec() appel.
Un thread du noyau est un processus léger et également un programme en cours d'exécution. Un même processus peut être constitué de plusieurs threads partageant les mêmes données et ressources mais empruntant des chemins différents à travers le code du programme. Linux fournit un clone()appel système pour générer des threads.
Des exemples d'utilisations des threads du noyau sont: la synchronisation des données de la RAM, l'aide à l'ordonnanceur pour répartir les processus entre les CPU, etc.
En bref: le noyau fonctionne dans l'espace du noyau, l'espace du noyau a un accès complet à toute la mémoire et aux ressources, vous pouvez dire que la mémoire se divise en deux parties, une partie pour le noyau et une partie pour le processus de l'utilisateur, (espace utilisateur) exécute les programmes normaux, l'utilisateur l'espace ne peut pas accéder directement à l'espace noyau, il demande donc au noyau d'utiliser les ressources. par syscall (appel système prédéfini dans la glibc)
il y a une déclaration qui simplifie les différents " L'espace utilisateur est juste une charge de test pour le noyau " ...
Pour être très clair: l'architecture du processeur permet au CPU de fonctionner en deux modes, le mode noyau et le mode utilisateur , l'instruction Hardware permet 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 noyau.
Lorsque le processeur fonctionne en mode utilisateur, le processeur ne peut accéder qu'à la mémoire qui se trouve dans l'espace utilisateur, tandis que le processeur tente d'accéder à la mémoire dans l'espace noyau, le résultat est une "exception matérielle", lorsque le processeur fonctionne en mode noyau, le processeur peut accéder directement à la fois à l'espace noyau et à l'espace utilisateur ...
L'espace noyau signifie qu'un espace mémoire ne peut être touché que par le noyau. Sur Linux 32 bits, c'est 1G (de 0xC0000000 à 0xffffffff comme adresse de mémoire virtuelle) .Chaque processus créé par le noyau est également un thread du noyau, donc pour un processus, il y a deux piles: une pile dans l'espace utilisateur pour ce processus et une autre dans le noyau espace pour le thread du noyau.
la pile du noyau occupait 2 pages (8k sous Linux 32 bits), incluait une task_struct (environ 1k) et la pile réelle (environ 7k). Ce dernier est utilisé pour stocker certaines variables automatiques ou paramètres d'appel de fonction ou adresse de fonction dans les fonctions du noyau. 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 comme 2 ^ 1 = 2 pages.
Mais la pile de processus est une autre chose, son adresse est juste en dessous de 0xC0000000 (Linux 32 bits), sa taille peut être bien plus grande, utilisée pour les appels de fonction de l'espace utilisateur.
Voici donc une question pour un appel système, il fonctionne dans l'espace noyau mais a été appelé par processus dans l'espace utilisateur, comment ça marche? Linux mettra-t-il ses paramètres et son adresse de fonction dans la pile du noyau ou dans la pile de processus? Solution Linux: tous les appels système sont déclenchés par une interruption logicielle INT 0x80. Défini dans l'entrée 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)
Le noyau Linux fait référence à tout ce qui fonctionne en mode noyau et est composé de plusieurs couches distinctes. Au niveau de la couche la plus basse, le noyau interagit avec le matériel via la HAL. Au niveau intermédiaire, le noyau UNIX est divisé en 4 zones distinctes. Le premier des quatre domaines traite les dispositifs de caractères, les ATS crus et cuits et la manipulation des terminaux. La deuxième zone gère les pilotes de périphériques réseau, les protocoles de routage et les sockets. La troisième zone gère les pilotes de périphériques de disque, les caches de pages et de tampons, le système de fichiers, la mémoire virtuelle, la dénomination et le mappage de fichiers. La quatrième et dernière zone gère la répartition, la planification, la création et la terminaison des processus ainsi que la gestion des signaux. Au-dessus de tout cela, nous avons la couche supérieure du noyau qui comprend 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 système pour interagir avec les fonctionnalités du système d'exploitation.
EN espace noyau court est la partie de la mémoire où le noyau Linux s'exécute (1 Go d'espace virtuel supérieur dans le cas de Linux) et l'espace utilisateur est la partie de la mémoire où l'application utilisateur s'exécute (3 Go inférieurs de mémoire virtuelle dans le cas de Linux. Si vous voulez en savoir plus, consultez 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 noyau et en espace utilisateur. L'espace noyau est la zone de mémoire virtuelle où les processus du noyau s'exécuteront et l'espace utilisateur est cette zone de mémoire virtuelle où les processus utilisateur seront exécutés.
Cette division est requise pour les protections d'accès à la mémoire.
Chaque fois qu'un chargeur de démarrage démarre un noyau après l'avoir chargé dans un emplacement de la RAM, (sur un contrôleur basé sur ARM généralement), il doit s'assurer que le contrôleur est en mode superviseur avec les FIQ et IRQ désactivés.
L'espace noyau et l'espace utilisateur sont des espaces logiques.
La plupart des processeurs modernes sont conçus pour fonctionner dans différents modes privilégiés. Les machines x86 peuvent fonctionner dans 4 modes privilégiés différents.
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 offrez une protection du système ou un sandboxing l'environnement d'exécution.
Le noyau est un morceau de code qui gère votre matériel et fournit une abstraction du système. Il doit donc avoir accès à toutes les instructions de la machine. Et c'est le logiciel le plus fiable. Je devrais donc être exécuté avec le privilège le plus élevé. Et le niveau de sonnerie 0 est le mode le plus privilégié. Ainsi, le niveau de sonnerie 0 est également appelé mode noyau .
Les applications utilisateur sont des logiciels qui proviennent de tout fournisseur tiers et vous ne pouvez pas leur faire entièrement confiance. Quelqu'un avec une intention malveillante peut écrire un code pour planter votre système s'il avait un accès complet à toutes les instructions de la machine. L'application doit donc avoir accès à un ensemble limité d'instructions. Et Ring Level 3 est le mode le moins privilégié. Donc, toutes vos applications fonctionnent dans ce mode. Par conséquent, le niveau de sonnerie 3 est également appelé mode utilisateur .
Remarque: je n'obtiens pas les niveaux de sonnerie 1 et 2. Ce sont essentiellement des modes avec un privilège intermédiaire. Il se peut donc que le code du pilote de périphérique soit exécuté avec ce privilège. AFAIK, Linux utilise uniquement les Ring Level 0 et 3 pour l'exécution du code du noyau et l'application utilisateur respectivement.
Ainsi, toute opération se produisant en mode noyau peut être considérée comme un espace noyau. Et toute opération se déroulant en mode utilisateur peut être considérée comme un espace utilisateur.
La bonne réponse est: il n'y a pas d'espace de noyau et d'espace utilisateur. Le jeu d'instructions du processeur dispose d'autorisations spéciales pour définir des éléments destructeurs tels que la racine de la mappe de table de page, ou accéder à la mémoire du périphérique matériel, etc.
Le code du noyau a les privilèges de niveau le plus élevé et le code utilisateur le plus bas. Cela empêche le code utilisateur de planter le système, de modifier d'autres programmes, etc.
En général, le code du noyau 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 noyau» et «espace utilisateur». Mais ce n'est pas une règle absolue. Par exemple, étant donné que le x86 nécessite indirectement que ses gestionnaires d'interruptions / interruptions soient mappés à tout moment, une partie (ou certains systèmes d'exploitation tous) du noyau 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 noyau / utilisateur est-elle nécessaire? Certains concepteurs ne sont pas d'accord sur le fait que cela soit en fait nécessaire. L'architecture du micro-noyau est basée sur l'idée que les sections de code les plus privilégiées doivent être aussi petites que possible, toutes les opérations importantes étant effectuées dans le code privilégié de l'utilisateur. Vous auriez besoin d'étudier pourquoi cela pourrait être une bonne idée, ce n'est pas un concept simple (et il est célèbre pour ses avantages et ses inconvénients).
La mémoire est divisée en deux zones distinctes:
Les processus exécutés sous l'espace utilisateur n'ont accès qu'à une partie limitée de la mémoire, alors que le noyau a accès à toute la mémoire. Les processus exécutés dans l'espace utilisateur n'ont pas non plus accès à l'espace noyau. Les processus de l'espace utilisateur ne peuvent accéder qu'à une petite partie du noyau via une interface exposée par le noyau - le système appelle.Si un processus effectue un appel système, une interruption logicielle est envoyée au noyau, qui envoie alors le gestionnaire d'interruption approprié et continue son travail une fois que le gestionnaire a terminé.
Sous Linux, il y a deux espaces: le premier est l'espace utilisateur et un autre est l'espace noyau. L'espace utilisateur se compose uniquement de l'application utilisateur que vous souhaitez exécuter. en tant que service noyau, 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 tant de services y sont présents. si vous exécutez l'application à partir de l'espace utilisateur, cette application interagit uniquement avec le service kernal. et ce service interagit avec le pilote de périphérique qui est présent entre le matériel et le noyau. le principal avantage de la séparation de l'espace noyau et de l'espace utilisateur est que nous pouvons obtenir une sécurité par le virus.bcaz de toutes les applications utilisateur présentes dans l'espace utilisateur, et le service est présent dans l'espace noyau. c'est pourquoi linux n'affecte pas le virus.