En informatique, un appel système est une manière programmatique par laquelle un programme informatique demande un service au noyau du système d'exploitation sur lequel il est exécuté. Un appel système est un moyen pour les programmes de interagir avec le système d'exploitation . Un programme informatique effectue un appel système lorsqu’il adresse une requête au noyau du système d’exploitation. Appel système fournit les services du système d'exploitation aux programmes utilisateur via l'Application Program Interface (API). Il fournit une interface entre un processus et un système d'exploitation pour permettre aux processus au niveau utilisateur de demander des services au système d'exploitation. Les appels système sont les seuls points d'entrée dans le noyau système. Tous les programmes nécessitant des ressources doivent utiliser des appels système.
Un programme utilisateur peut interagir avec le système d'exploitation à l'aide d'un appel système. Un certain nombre de services sont demandés par le programme et le système d'exploitation répond en lançant un certain nombre d'appels système pour répondre à la demande. Un appel système peut être écrit dans des langages de haut niveau comme C ou Pascal ou en langage assembleur. Si un langage de haut niveau est utilisé, le système d'exploitation peut appeler directement des appels système, qui sont des fonctions prédéfinies.
Un appel système est un mécanisme utilisé par les programmes pour demander des services au système opérateur (OS). En termes plus simples, il s'agit d'un moyen pour un programme d'interagir avec le système sous-jacent, par exemple en accédant à des ressources matérielles ou en effectuant des opérations privilégiées.
Un appel système est initié par le programme exécutant une instruction spécifique, qui déclenche un basculement vers noyau mode, permettant au programme de demander un service au système d’exploitation. Le système d'exploitation traite ensuite la demande, effectue les opérations nécessaires et renvoie le résultat au programme.
Les appels système sont essentiels au bon fonctionnement d'un système d'exploitation, car ils fournissent aux programmes un moyen standardisé d'accéder aux ressources du système. Sans appels système, chaque programme devrait implémenter ses propres méthodes pour accéder au matériel et aux services système, ce qui entraînerait un comportement incohérent et sujet aux erreurs.
Services fournis par les appels système
- Création et gestion de processus
- Gestion de la mémoire principale
- Gestion de l'accès aux fichiers, des répertoires et du système de fichiers
- Gestion des appareils (E/S)
- protection
- Réseautage, etc.
- Contrôle de processus: terminer, abandonner, créer, terminer, allouer et libérer de la mémoire.
- Gestion de fichiers: créer, ouvrir, fermer, supprimer, lire des fichiers, etc.
- Gestion d'appareils
- Gestion des informations
- Communication
Caractéristiques des appels système
- Interface: Les appels système fournissent une interface bien définie entre les programmes utilisateur et le système d'exploitation. Les programmes effectuent des requêtes en appelant des fonctions spécifiques, et le système d'exploitation répond en exécutant le service demandé et en renvoyant un résultat.
- Protection: Les appels système sont utilisés pour accéder à des opérations privilégiées qui ne sont pas disponibles pour les programmes utilisateur normaux. Le système d'exploitation utilise ce privilège pour protéger le système contre tout accès malveillant ou non autorisé.
- Mode noyau : Lorsqu'un appel système est effectué, le programme passe temporairement du mode utilisateur au mode noyau. En mode noyau, le programme a accès à toutes les ressources système, y compris le matériel, la mémoire et d'autres processus.
- Changement de contexte : Un appel système nécessite un changement de contexte, qui implique de sauvegarder l'état du processus en cours et de passer en mode noyau pour exécuter le service demandé. Cela peut introduire une surcharge, ce qui peut avoir un impact sur les performances du système.
- La gestion des erreurs: Les appels système peuvent renvoyer des codes d'erreur pour indiquer des problèmes avec le service demandé. Les programmes doivent rechercher ces erreurs et les gérer de manière appropriée.
- Synchronisation: Les appels système peuvent être utilisés pour synchroniser l'accès aux ressources partagées, telles que les fichiers ou les connexions réseau. Le système d'exploitation fournit des mécanismes de synchronisation, tels que des verrous ou des sémaphores, pour garantir que plusieurs programmes peuvent accéder à ces ressources en toute sécurité.
Avantages des appels système
- Accès aux ressources matérielles : Les appels système permettent aux programmes d'accéder à des ressources matérielles telles que des lecteurs de disque, des imprimantes et des périphériques réseau.
- Gestion de la mémoire: Les appels système permettent aux programmes d'allouer et de libérer de la mémoire, ainsi que d'accéder aux périphériques matériels mappés en mémoire.
- La gestion des processus: Les appels système permettent aux programmes de créer et de terminer des processus, ainsi que de gérer la communication inter-processus.
- Sécurité: Les appels système permettent aux programmes d'accéder à des ressources privilégiées, telles que la possibilité de modifier les paramètres système ou d'effectuer des opérations nécessitant des autorisations administratives.
- Standardisation: Les appels système fournissent une interface standardisée permettant aux programmes d'interagir avec le système d'exploitation, garantissant ainsi la cohérence et la compatibilité entre les différentes plates-formes matérielles et versions du système d'exploitation.
Comment fonctionne l’appel système ?
Voici l'explication détaillée étape par étape du fonctionnement des appels système :
- L'utilisateur a besoin de ressources spéciales : Parfois, les programmes doivent effectuer des tâches spéciales qui ne peuvent pas être effectuées sans l'autorisation du système d'exploitation, comme lire un fichier, écrire dans un fichier, obtenir des informations du matériel ou demander un espace en mémoire.
- Le programme fait une demande d'appel système : Il existe des instructions spéciales prédéfinies pour faire une demande au système d'exploitation. Ces instructions ne sont rien d’autre qu’un simple appel système. Le programme utilise ces appels système dans son code lorsque cela est nécessaire.
- Le système d'exploitation voit l'appel système : Lorsque le système d'exploitation voit l'appel système, il reconnaît que le programme a besoin d'aide à ce moment-là, il arrête donc temporairement l'exécution du programme et donne tout le contrôle à une partie spéciale de lui-même appelée « Kernel ». Désormais, « Kernel » résout le besoin du programme.
- Le système d'exploitation effectue les opérations : Le système d’exploitation effectue maintenant l’opération demandée par le programme. Exemple : lecture du contenu d'un fichier etc.
- Le système d'exploitation redonne le contrôle au programme : Après avoir effectué l'opération spéciale, le système d'exploitation redonne le contrôle au programme pour une exécution ultérieure du programme.
Exemples d'appel système sous Windows et Unix
Les appels système pour Windows et Unix se présentent sous de nombreuses formes différentes. Ceux-ci sont répertoriés dans le tableau ci-dessous comme suit :
| Processus | les fenêtres | Unix |
|---|---|---|
| Contrôle de processus | CréerProcess() Processus de sortie() Attendre un seul objet() | Fourchette() Sortie() Attendez() |
| Manipulation de fichiers | Créer un fichier() LireFichier() ÉcrireFichier() | Ouvrir() Lire() Écrire() Fermer() |
| Gestion d'appareils | DéfinirConsoleMode() LireConsole() ÉcrireConsole() | Ioctl() Lire() Écrire() |
| Gestion des informations | ObtenirCurrentProcessID() Régler la minuterie() caractères d'échappement Java Dormir() | Getpid() Alarme() Dormir() |
| Communication | Créer un tuyau() CreateFileMapping() MapViewOfFile() | Tuyau() Shmget() Mmap() |
| protection | SetFileSecurity() InitializeSecurityDescriptor() SetSecurityDescriptorgroup() | Chmod() démasquer() Chown() |
ouvrir(): L'accès à un fichier sur un système de fichiers est possible avec l'appel système open(). Il fournit les ressources de fichier dont il a besoin et un handle que le processus peut utiliser. Un fichier peut être ouvert par plusieurs processus simultanément ou par un seul processus. Tout est basé sur la structure et le système de fichiers.
lire(): Les données d'un fichier sur le système de fichiers sont récupérées à l'aide de celui-ci. En général, il accepte trois arguments :
- Description d'un fichier.
- Un tampon pour le stockage des données lues.
- Combien d'octets doivent être lus dans le fichier
Avant la lecture, le fichier à lire peut être identifié par son descripteur de fichier et ouvert à l'aide de la fonction open().
attendez(): Dans certains systèmes, un processus peut devoir attendre jusqu'à ce qu'un autre processus ait fini de s'exécuter avant de continuer. Lorsqu'un processus parent crée un processus enfant, l'exécution du processus parent est interrompue jusqu'à ce que le processus enfant soit terminé. Le processus parent est arrêté à l'aide de l'appel système wait(). Le processus parent reprend le contrôle une fois que le processus enfant a terminé son exécution.
écrire(): Les données d'un tampon utilisateur sont écrites en l'utilisant sur un périphérique comme un fichier. Un programme peut produire des données d'une manière en utilisant ceci appel système . en général, il y a trois arguments :
- Description d'un fichier.
- Une référence au tampon où les données sont stockées.
- La quantité de données qui seront écrites à partir du tampon en octets.
fourchette(): L'appel système fork() est utilisé par les processus pour créer des copies d'eux-mêmes. C'est l'une des méthodes les plus fréquemment utilisées dans les systèmes d'exploitation pour créer des processus. Lorsqu'un processus parent crée un processus enfant, l'exécution du processus parent est suspendue jusqu'à ce que le processus enfant soit terminé. Le processus parent reprend le contrôle une fois que le processus enfant a terminé son exécution.
sortie(): Un appel système appelé exit() est utilisé pour terminer un programme. Dans les environnements comportant plusieurs threads, cet appel indique que l'exécution du thread est terminée. Après avoir utilisé la fonction système exit(), le système d'exploitation récupère les ressources utilisées par le processus.
tableau de codes c de chaînes
Méthodes pour transmettre des paramètres au système d'exploitation
Si un appel système se produit, nous devons transmettre le paramètre à la partie Kernal du système d'exploitation.
Par exemple, regardez le donné ouvrir() appel système :
C
//function call example> #include> int> open(>const> char> *pathname,>int> flags, mode_t mode);> |
>
>
Ici chemin d'accès , drapeaux et mode_t sont les paramètres.
Il est donc à noter que :
- Nous ne pouvons pas transmettre les paramètres directement comme dans un appel de fonction ordinaire.
- En mode Kernal, il existe une manière différente d'effectuer un appel de fonction.
Nous ne pouvons donc pas l'exécuter dans l'espace d'adressage normal que le processus avait déjà créé et nous ne pouvons donc pas placer les paramètres en haut de la pile car ils ne sont pas disponibles pour le noyau du système d'exploitation pour le traitement. nous devons donc adopter d'autres méthodes pour transmettre les paramètres au noyau du système d'exploitation.
Nous pouvons y parvenir,
- Passer des paramètres dans les registres
- L'adresse du bloc est passée en paramètre dans un registre.
- Les paramètres sont poussés dans une pile.
Discutons de chaque point en détail :
1. Passage des paramètres dans les registres.
- C'est la méthode la plus simple parmi les trois
- Ici, nous transmettons directement les paramètres aux registres.
- Mais ce sera limité lorsque le nombre de paramètres est supérieur au nombre de registres.
- Voici le code du programme C :
C
// Passing parameters in registers.> #include> #include> int> main()> {> >const> char>* pathname =>'example.txt'>;> >int> flags = O_RDONLY;> >mode_t mode = 0644;> >int> fd = open(pathname, flags, mode);> >// in function call open(), we passed the parameters pathanme,flags,mode to the kernal directly> >if> (fd == -1) {> >perror>(>'Error opening file'>);> >return> 1;> >}> >// File operations here...> >close(fd);> >return> 0;> }> |
>
>
2.L'adresse du bloc est passée en paramètre
- Il peut être appliqué lorsque le nombre de paramètres est supérieur au nombre de registres.
- Les paramètres sont stockés dans des blocs ou dans un tableau.
- L'adresse du bloc est transmise à un registre en tant que paramètre.
- Le plus couramment utilisé sous Linux et Solaris.
- Voici le code du programme C :
C
//Address of the block is passed as parameters> #include> #include> int> main() {> >const> char> *pathname =>'example.txt'>;> >int> flags = O_RDONLY;> >mode_t mode = 0644;> >int> params[3];> >// Block of data(parameters) in array> >params[0] = (>int>)pathname;> >params[1] = flags;> >params[2] = mode;> >int> fd = syscall(SYS_open, params);> >// system call> >if> (fd == -1) {> >perror>(>'Error opening file'>);> >return> 1;> >}> >// File operations here...> >close(fd);> >return> 0;> }> |
>
>
3.Les paramètres sont poussés dans une pile
- Dans cette méthode, les paramètres peuvent être insérés à l'aide du programme et extraits à l'aide du système d'exploitation.
- Ainsi, le Kernal peut facilement accéder aux données en récupérant les informations du haut de la pile.
- Voici le code du programme C
C
//parameters are pushed into the stack> #include> #include> #include> int> main() {> >const> char> *pathname =>'example.txt'>;> >int> flags = O_RDONLY;> >mode_t mode = 0644;> >int> fd;> >asm>volatile>(> >'mov %1, %%rdi
'> >'mov %2, %%rsi
'> >'mov %3, %%rdx
'> >'mov , %%rax
'> >'syscall'> >:>'=a'> (fd)> >:>'r'> (pathname),>'r'> (flags),>'r'> (mode)> >:>'%rdi'>,>'%rsi'>,>'%rdx'> >);> >if> (fd == -1) {> >perror>(>'Error opening file'>);> >return> 1;> >}> >// File operations here...> >close(fd);> >return> 0;> }> |
différence entre un gigaoctet et un mégaoctet
>
>
Question fréquemment posée
Q.1 : Comment fonctionne un appel système ?
Répondre:
Lorsqu'un programme exécute un appel système, il passe du mode utilisateur au mode noyau, qui est un mode privilégié plus élevé. La transition est généralement initiée en invoquant une fonction spécifique ou en interrompant une instruction fournie par le langage de programmation ou le système d'exploitation.
Une fois en mode noyau, l'appel système est géré par le système d'exploitation. Le noyau effectue l'opération demandée au nom du programme et renvoie le résultat. Ensuite, le contrôle est rendu au programme de niveau utilisateur, qui poursuit son exécution.
Q.2 : Pourquoi les appels système sont-ils nécessaires ?
Répondre:
Les appels système sont nécessaires pour plusieurs raisons :
Accès à des opérations privilégiées : De nombreuses opérations, telles que la gestion des périphériques matériels ou la modification des configurations système, nécessitent des privilèges plus élevés qui ne sont accessibles que via des appels système.
La gestion des ressources: Les appels système fournissent une interface standardisée pour allouer et gérer les ressources système telles que la mémoire, les fichiers et les appareils, garantissant un accès équitable et contrôlé par différents processus.
Abstraction: Les appels système résument les complexités sous-jacentes du système d'exploitation, permettant aux développeurs d'applications d'interagir avec le système de manière supérieure et indépendante de la plate-forme.
Sécurité et protection : Les appels système appliquent des politiques de contrôle d'accès et de sécurité, empêchant tout accès non autorisé aux ressources sensibles et protégeant l'intégrité du système.