API du noyau Linux

Nous passerons par l'interface de programmation d'application Linux, l'API. Linux Kernel fournit les appels système qui peuvent être utilisés pour effectuer la tâche via le noyau. Discutons des quelques appels système largement utilisés de Linux.

Description:

Linux Kernel fournit l'ensemble ou la liste des fonctions qui peuvent être utilisées par les programmes d'espace utilisateur pour utiliser les services du noyau Linux.

Le diagramme de blocs ressemble à ce qui suit:

Certains des quelques appels système largement utilisés sont ouverts, fermés, lis et écrivez. Ce sont des appels système de base fournis par le noyau Linux. Chaque tâche est effectuée via un fichier dans Linux. Ainsi, les opérations de base sur n'importe quel fichier peuvent être effectuées via Open, Fermer, lire et écrire.

Prenons un véritable exemple où nous voulons imprimer le «Hello World» sur la console série. Pour réaliser cette tâche via les appels système, nous devons ouvrir le fichier de périphérique pour console dans / dev. Une fois que nous avons localisé le fichier de périphérique pour Console ou UART, nous pouvons utiliser l'appel Open System pour ouvrir l'appareil.

Voici la syntaxe de l'appel du système ouvert:

int ou ouvert (const char * pathname, int draps);
int ou ouvert (const char * pathname, int int draps, mode_t mode);

De cette syntaxe, le premier argument est le chemin de fichier que nous voulons ouvrir. Dans notre cas, c'est le fichier de périphérique que nous avons localisé en tant qu'appareil console. Dans l'argument suivant, les drapeaux offrent à l'utilisateur une certaine flexibilité pour lire avec le fichier. Peu d'exemples des drapeaux sont o_creat, o_append, etc. Ces drapeaux ont des significations et un but spécifiques et la discussion est hors de portée de cette discussion. Pour plus de détails sur les drapeaux et les paramètres, veuillez consulter les pages du noyau.

Une fois le fichier ouvert avec succès, nous devons utiliser l'appel du système d'écriture pour envoyer le «Hello World» à l'appareil console. Le prototype de l'appel du système d'écriture est le suivant:

ssize_t write (int fd, const void * buf, size_t count);

Le premier paramètre de l'appel du système d'écriture est le FD qui est le descripteur de fichiers. Le «FD» nous est donné par l'appel du système ouvert. Après avoir ouvert le fichier avec succès, nous devons obtenir le descripteur de fichier. Cette FD est utilisée davantage pour écrire les données.

Le deuxième paramètre est l'adresse tampon des données à envoyer au périphérique de console. Dans notre cas, les données de test sont «Hello World».

Le dernier paramètre est le nombre total d'octets que l'utilisateur souhaite écrire sur l'appareil console. Dans notre cas, le nombre d'octets est la taille de «Hello World». Nous pouvons utiliser la taille de l'opérateur ou la fonction strlen pour obtenir le nombre d'octets. Nous devons être prudents en utilisant le strlen. Cette fonction ignore le caractère de terminateur de chaîne comme «\ 0». Ainsi, en lisant la chaîne, nous devons nous assurer que le caractère nul est géré correctement. Sinon, nous nous retrouverons avec le défaut de segmentation.

Maintenant, implémentons la partie du code de cet exemple. Tout d'abord, nous devons localiser la console série ou le périphérique UART. Dans la machine, ce que nous utilisons a le périphérique TTY en série AS / DEV / PTS / 0. Donc, comme discuté, nous devons d'abord ouvrir ce fichier. Nous devons également inclure le fichier plus dur qui fournit la déclaration d'appel du système ouvert.

Notre code pour ouvrir le fichier de périphérique ressemble à ce qui suit:

#inclure
fd = open ("/ dev / pts / 0", o_wronly);

Ensuite, lorsque nous voulons appeler l'appel du système d'écriture, nous utilisons la FD fournie par l'Open. Notre fonction d'appel à écrire ressemble à ce qui suit:

#inclure
char * data = «Hello world»;
Write (FD, données, strlen (data) +1);

L'extrait de code précédent écrit le «Hello World» à la console série que nous avons localisée et que nous voulons écrire.

Laissez-nous rassembler toutes les pièces:

#inclure
#inclure
#inclure
#inclure
#inclure
int main()

int fd; int rc;
char * data = «Hello world»;
fd = open ("/ dev / pts / 0", o_wronly);
if (fd<0)

printf («Fichier d'ouverture d'erreur:% D», FD);
sortie (-1);

rc = write (fd, data, strlen (data) +1);
if (rc<0)

printf («Error Writing Fichier:% D», RC);
sortie (-1);

Close (FD); // L'opération de fichier est effectuée, fermez le fichier.
retour 0;

La compilation du programme précédent est la même que la compilation des autres programmes C comme les suivants:

gcc test_write.C -o test_write.

Le test_write.C est le nom de fichier de notre code C.

Après la compilation, nous obtenons l'exécutable avec le nom de test_write.

Reportez-vous à l'instantané suivant:

Après avoir exécuté le binaire compilé et généré, nous avons la sortie suivante.

La sortie de notre programme est mise en évidence en lettres audacieuses. Ce qui suit est l'instantané pour référence:

Jusqu'à présent, nous avons vu un exemple où nous utilisons l'API Linux pour afficher la chaîne de test sur la console. Ceci est l'exemple simple. Il existe de nombreuses autres offres fournies par l'appel système. Peu des appels système fournis par Linux sont les suivants:

• lire: Lire à partir du fichier.
• écrire: Écriture dans le fichier.
• ouvrir: Ouvrir le fichier.
• fermer: Clôture du fichier.
• sondage: Sonder l'appareil pour le changement d'état.
• lseek: Recherche à un décalage particulier dans le fichier.
• mmap: Mappage de la mémoire virtuelle à la mémoire physique.
• BRK: Changer la taille du segment.
• IOCTL: Appareils de controle.
• accès: Accès pour obtenir les autorisations du fichier.
• tuyau: Se réfère à la création de tuyaux.

et beaucoup plus.

Ceci est l'énorme liste des fonctions fournies par Linux Kernel. Nous avons vu et discuté très peu. Reportez-vous à la source du noyau pour la liste complète des appels système fournis par le noyau.

Conclusion

Nous avons discuté des appels système qui est un moyen de demander au noyau d'effectuer les tâches des programmes d'espace utilisateur. Sans l'appel système, il ne sera pas possible pour les programmes d'espace utilisateur de faire la tâche par le noyau. Nous avons pris une tâche simple ou un exemple d'écriture des données de test, «Hello World», au périphérique série. Nous avons utilisé les API ouvertes, écrites et fermées du noyau pour terminer la tâche en main. Une chose la plus importante est de vérifier la valeur de retour des appels système. Le noyau fournit des valeurs de retour appropriées pour expliquer la raison en cas de défaillance de la fonction. L'utilisateur peut avoir l'idée sur la raison de l'échec en voyant les valeurs de retour de l'appel système. Les valeurs de retour ont une signification spécifique et sont bien actualisées dans la documentation du noyau.