Fonctions système

Liste des fonctions système

    Le tableau ci-dessous contient la liste des 190 fonctions système mises à la disposition par le noyau Linux (à partir du fichier /usr/include/asm/unistd.h).
 
Nom Code Catégorie Nom Code Catégorie
A     P    
acct 51   pause 29  
access 124   personality 136  
adjtimex 137   pipe 42  
afs_syscall 137   poll 168  
alarm 27   prctl 172  
B     pread 180  
bdflush 134   prof 44  
break 17   profil 98  
brk 45   ptrace 26  
C     putpmsg 189  
capget 184   pwrite 181  
capset 185   Q    
chdir 12   query_module 167  
chmod 15   quotactl 131  
chown 182   R    
chroot 61   read 3  
clone 120   readdir 89  
close 6   readlink 85  
creat 8   readv 145  
create_module 127   reboot 88  
D     rename 38  
delete_module 129   rmdir 40  
dmlockall 152   rt_sigreturn 173  
dup  41   rt_sigaction 174  
dup2 63   rt_sigprocmask 175  
E     rt_sigpending 176  
execve 11   rt_sigtimedwait 177  
exit 1   rt_sigqueueinfo 178  
F     rt_sigsuspend 179  
fchdir 133   S    
fchmod 94   sched_getparam 155  
fchown 95   sched_getscheduler 157  
fcntl 55   sched_setparam  154  
fdatasync 148   sched_setscheduler 156  
flock 143   sched_rr_get_interval 161  
fork 2   sched_yield 158  
fstat 108   select 82  
ftruncate 93   sendfile 187  
fstatfs 100   setdomainname 121  
fsync 118   setfsgid 139  
ftime 35   setfsuid 138  
G     setgid 46  
get_kernel_syms 130   setgroups 81  
get_priority_max  159   sethostname 74  
get_priority_min 160   setitimer 104  
getdents 141   setpgid 57  
getegid 50   setpriority 97  
geteuid 49   setregid 71  
getcwd 183   setresgid 170  
getgid 47   setresuid 164  
getgroups 80   setrlimit 75  
getpgrp 65   setsid 66  
getitimer 105   settimeofday 79  
getpgid 132   setuid 23  
getpid 20   sgetmask 68  
getppid 188   sigaction 67  
getpriority 64   sigaltstack 186  
getresgid 171   signal 48  
getresuid 165   sigpending 73  
getrlimit 76   sigprocmask 126  
getuid 24   sigreturn 119  
getrusage 77   sigsuspend 72  
getsid 147   socketcall 102  
gettimeofday 78   ssetmask 69  
gtty 32   stat 106  
I     statfs 9  
idle 112   stime 25  
init_module 128   stty 31  
ioctl 54   swapon 87  
ioperm 101   swapoff 115  
iopl 110   symlink 83  
ipc 117   sync 36  
K     sysctl 149  
kill 37   sysfs 135  
L     sysinfo 116  
lchown 16   syslog 103  
link 9   T    
llseek 140   time 13  
lock 53   times 43  
lseek 19   truncate 92  
lstat 107   U    
M     ulimit 58  
mkdir 39   umask 60  
mknod 14   umount 22  
mlock 150   umount2 52  
mmap 90   uname 122  
modify_ldt 123   unlink 10  
mount 21   uselib 86  
mprotect 125   ustat 62  
mpx 56   utime 30  
mremap 163   V    
munmap 91   vfork 190  
msync 144   vhangup 111  
munlock 151   vm86 166  
munlockall 153   vm86old 113  
N     W    
nanosleep 162   wait4 114  
newselect 142   waitpid 7  
nfsservctl 169   write 4  
nice 34   writev 146  
O          
oldfstat 28        
oldlstat 84        
oldolduname 59        
oldstat 18        
olduname 109        
open 5        

     Une liste beaucoup plus longue peut être obtenue grâce à la commande xman en choisissant la section 2 (System Calls), mais il s'agit seulement d'un manuel, pas forcément à jour, et rien ne prouve que toutes ces fonctions soient réellement implémentées. Il est en revanche très probable que les 190 fonctions de la table ci-dessus existent réellement, car leur appel peut être directement généré grâce à la fonction syscall() : voir ci-dessous.

Appel direct

    Bien qu'un peu plus difficile, et moins portable, que l'appel par l'intermédiaire des fonctions de la bibliothèque C,  l'appel direct à une fonction du noyau est possible grâce à la macro _syscallX() présente dans le fichier /usr/include/asm/unistd.h. Malgré une apparente difficulté à la lecture, son utilisation est simple : il suffit de lui passer tous les éléments qui composent l'appel de la fonction standard :     La macro génère une fonction inline qui contient une ligne de code assembleur (l'appel de la fonction du noyau) et renvoie le résultat. Les numéros des fonctions sont les suivants :
 
#ifndef _ASM_I386_UNISTD_H_
#define _ASM_I386_UNISTD_H_

/* This file contains the system call numbers. */

#define __NR_exit                 1
#define __NR_fork                 2
#define __NR_read                 3
#define __NR_write                4
...
#define __NR_vfork              190

#endif /* _ASM_I386_UNISTD_H_  */

    En pratique, au lieu de passer le nombre de paramètres, il y a une macro _syscallX() pour chaque nombre de paramètres de 0 à 5 : _syscall0(), ..., _syscall5(), plus une macro pour renvoyer le résultat après l'avoir normalisé dans l'intervalle [-1..-122]. Par exemple :
 
...
#define _syscall0(type,name) \
type name(void) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \
        : "=a" (__res) \
        : "0" (__NR_##name [1] )); \
__syscall_return(type,__res); \
}

#define _syscall1(type,name,type1,arg1) \
type name(type1 arg1) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \
        : "=a" (__res) \
        : "0" (__NR_##name),"b" ((long)(arg1))); \
__syscall_return(type,__res); \
}
...

    Dans un programme, la ligne suivante :
 
_syscall1 (int, sysinfo, struct sysinfo *, info);

génère le code source :
 
int sysinfo (struct sysinfo * info)
{
    long res;
    __asm__ volatile ("int $0x80" : "=a" (res) : "0" (116 [2] ),
                      "b"    ((long)( info)));

    if ((unsigned long)(res) >= (unsigned long)(-125))
    {
        errno = -(res);
        res = -1;
    }
    return (int) (res);
}

qui peut être utilisée comme n'importe quelle fonction dans un programme :
 
struct sysinfo UneInfo;

int Result = sysinfo (&UneInfo);

    Quelle que soit la façon d'appeler la fonction système, il faut retenir de ce mécanisme au minimum deux points :


[1]  l'opérateur ## du préprocesseur C concatène les deux chaînes à sa gauche et à sa droite.
[2]  #define __NR_sysinfo       116