INTRO

Index

NOM
DESCRIPTION
EXEMPLE
1. Exemple d'exécution
NOTES
CONFORMITÉ
FICHIERS
VOIR AUSSI
TRADUCTION

NOM

intro, _syscall - Introduction à la section des appels système

DESCRIPTION

Ce chapitre décrit les appels système de Linux. Pour avoir une liste des 164 appels système disponibles dans Linux 2.0, voyez la page syscalls(2).

Appel Direct

Dans la plupart des cas, il n'est pas nécessaire d'invoquer un appel système directement, mais il arrive parfois que la bibliothèque C standard n'implémente pas une fonction pourtant utile. Dans ce cas, le programmeur doit invoquer l'appel système à la main, soit en utilisant l'une des macros _syscall, soit syscall(). Cette dernière technique est décrite dans syscall(2). La présente page décrit les macros _syscall, et comporte quelques notes pour choisir quand utiliser l'une ou l'autre de ces méthodes.

Synopsis

#include <linux/unistd.h>
Une macro _syscall
L'appel système désiré

Setup

La chose la plus importante à connaître concernant un appel système est son prototype. Vous devez connaître le nombre d'arguments, leurs types, et le type de retour de la fonction. Il y a 6 macros simplifiant l'appel effectif au système. Elles ont la forme :

_syscallX(type,name,type1,arg1,type2,arg2,...)

: avec X dans l'intervalle 0-5, correspondant au nombre d'arguments de l'appel système.
type est le type de la valeur renvoyée par l'appel système.
name est le nom de l'appel système.
typeN est le type du Nième argument.
argN est le nom du Nième argument.

Ces macros créent une fonction appelée name avec les arguments spécifiés. Une fois inclus le _syscall() dans le fichier source, on effectue l'appel système avec name.

EXEMPLE


#include <stdio.h>
#include <errno.h>
#include <linux/unistd.h>       /* les macros _syscallX */
#include <linux/kernel.h>       /* pour struct sysinfo  */

_syscall1(int, sysinfo, struct sysinfo *, info);

/*
 * Note : Si vous copiez directement depuis le source nroff
 * de cette page, n'oubliez pas d'enlever les barres obliques
 * inverses supplémentaires dans les printf.
 */

int main(void)
{
        struct sysinfo s_info;
        int error;

        error = sysinfo(&s_info);
        printf("code d'erreur = %drsn", error);
        printf("Uptime = %ldsrsnCharge: 1 min %lu / 5 min %lu / 15 min %lursn"
                "RAM : totale %lu / libre %lu / partagée %lursn"
                "Mémoire dans tampons = %lursnSwap : total %lu / libre %lursn"
                "Nombre de processus = %drsn",
                s_info.uptime, s_info.loads[0],
                s_info.loads[1], s_info.loads[2],
                s_info.totalram, s_info.freeram,
                s_info.sharedram, s_info.bufferram,
                s_info.totalswap, s_info.freeswap,
                s_info.procs);
        return(0);
}

Exemple d'exécution

code d'erreur = 0
uptime = 502034s
Charge: 1 min 13376 / 5 min 5504 / 15 min 1152
RAM: totale 15343616 / libre 827392 / partagée 8237056
Mémoire dans tampons = 5066752
Swap: total 27881472 / libre 24698880
Nombre de processus = 40

NOTES

Les macros _syscall() ne créent pas de prototype. Il faut le fournir vous-même, en particulier en C++.
Les appels système ne renvoient pas nécessairement des code d'erreurs tous positifs ou négatifs. Vous devez lire les sources pour vérifier le retour en erreur. Généralement, ce sont des codes d'erreur négatifs, par exemple -EPERM. Les macros _syscall() renverront le résultat r de l'appel système quand r est positif ou nul, mais renverront -1 sinon, en positionnant errno à -r quand r est négatif. Pour les codes d'erreur, voir errno(3).
Certains appels système, comme mmap(), nécessitent plus de cinq arguments. Ceci est géré en plaçant les arguments sur la pile et en passant un pointeur sur le bloc d'arguments.
Lorsqu'un appel système est défini, les types d'arguments DOIVENT être passés par valeur ou par référence (pour les structures).
La méthode préférable pour invoquer des appels système que la glibc ne connaît pas encore est d'utiliser syscall(2). Cependant, cette méthode ne peut être utilisée que lorsque la bibliothèque C gère syscall(2) (comme glibc), et si l'en-tête <sys/syscall.h> contient la définition nécessaire de SYS_foo. Dans le cas contraire, l'utilisation d'une macro _syscall est nécessaire.
Certaines architectures, par exemple ia64, ne fournissent pas de macros _syscall. Sur ces architectures, on doit passer par syscall(2).

CONFORMITÉ

Des abréviations indiquent les variantes d'Unix, ou les normes dont les appels système sont conformes à la description donnée dans ces pages de manuel. Consultez standards(7).

FICHIERS

/usr/include/linux/unistd.h

VOIR AUSSI

syscall(2), errno(3), feature_test_macros(7), standards(7)

TRADUCTION

Cette page de manuel a été traduite et mise à jour par Christophe Blaess <http://www.blaess.fr/christophe/> entre 1996 et 2003, puis par Alain Portal <aportal AT univ-montp2 DOT fr> jusqu'en 2006.
La traduction de cette page de manuel est basée sur les traductions disponibles sur http://manpagesfr.free.fr/, mais est gérée par l'équipe francophone de traduction de Debian au travers de la liste de discussion debian-l10n-french.
Veuillez signaler toute erreur de traduction par un rapport de bogue sur le paquet manpages-fr.
Vous pouvez toujours avoir accès à la version anglaise de ce document en utilisant la commande « man -L C <section> <page_de_man> ».

Création : octobre 2007