Provided by: manpages-fr_3.32d0.2p4-1_all bug

NOM

       pthreads - Threads POSIX

DESCRIPTION

       POSIX.1  décrit  une  série  d'interfaces  (fonctions et fichiers d'en‐
       têtes) pour la programmation multithread,  couramment  appelée  threads
       POSIX,  ou  pthreads.  Un  unique  processus  peut  contenir  plusieurs
       threads, qui exécutent tous le même programme. Ces threads partagent la
       même mémoire globale (segments de données et tas), mais chaque thread a
       sa propre pile (variables automatiques).

       POSIX.1 requiert aussi que les threads  partagent  une  série  d'autres
       attributs (ces attributs sont par processus, plutôt que par thread) :

       -  identifiant de processus (PID)

       -  identifiant de processus père (PPID)

       -  identifiant  de groupe de processus (PGID) et identifiant de session
          (SID)

       -  terminal de contrôle

       -  identifiants d'utilisateur et de groupe

       -  descripteurs de fichier ouverts

       -  verrouillages d'enregistrements (consultez fcntl(2))

       -  gestion de signaux

       -  masque de création de fichier (umask(2))

       -  répertoire de travail (chdir(2)) et répertoire racine (chroot(2))

       -  temporisations d'intervalle (setitimer(2)) et  temporisations  POSIX
          (timer_create(2))

       -  valeur de politesse (setpriority(2))

       -  limites de ressources (setrlimit(2))

       -  mesures  de  consommation  de  temps CPU (times(2)) et de ressources
          (getrusage(2))

       En plus de la pile, POSIX.1 indique que plusieurs autres attributs sont
       distincts pour chaque thread, dont les suivants :

       -  identifiant de thread (le type de donnée pthread_t)

       -  masque de signaux (pthread_sigmask(3))

       -  la variable errno

       -  pile spécifique de signal (sigaltstack(2))

       -  politique      et      priorité      d'ordonnancement     temps-réel
          (sched_setscheduler(2) et sched_setparam(2))

       Les caractéristiques  spécifiques  à  Linux  suivantes  sont  également
       distinctes pour chaque thread :

       -  capacités (consultez capabilities(7))

       -  affinité CPU (sched_setaffinity(2))

   Valeurs de retour des fonctions pthreads
       La  plupart  des  fonctions pthreads renvoient 0 en cas de succès et un
       numéro d'erreur en cas d'échec. Notez que  les  fonctions  pthreads  ne
       positionnent pas errno. Pour chacune des fonctions pthreads qui peuvent
       produire une erreur, POSIX.1-2001 spécifie que la fonction ne peut  pas
       échouer avec l'erreur EINTR.

   Identifiants de thread
       Chacun  des  threads  d'un  processus a un unique identifiant de thread
       (stocké  dans  le  type  pthread_t).  Cet  identifiant  est  renvoyé  à
       l'appelant  de  pthread_create(3)  et un thread peut obtenir son propre
       identifiant de thread en utilisant pthread_self(3). Les identifiants de
       thread   n'ont   la  garantie  d'être  uniques  qu'à  l'intérieur  d'un
       processus. Un identifiant de thread peut  être  réutilisé  après  qu'un
       thread  qui s'est terminé a été rejoint ou qu'un thread détaché se soit
       terminé. Pour toutes les fonctions  qui  acceptent  un  identifiant  de
       thread en paramètre, cet identifiant de thread se réfère par définition
       à un thread du même processus que l'appelant.

   Fonctions sûres du point de vue des threads
       Une fonction sûre du point de vue des threads est une fonction qui peut
       être  appelée  en  toute  sûreté (c'est-à-dire qu'elle renverra le même
       résultat d'où qu'elle soit  appelée)  par  plusieurs  threads  en  même
       temps.

       POSIX.1-2001 et POSIX.1-2008 exigent que toutes les fonctions indiquées
       dans la norme soient sûres du point de vue  des  threads,  excepté  les
       fonctions suivantes :

           asctime()
           basename()
           catgets()
           crypt()
           ctermid() avec un paramètre non NULL
           ctime()
           dbm_clearerr()
           dbm_close()
           dbm_delete()
           dbm_error()
           dbm_fetch()
           dbm_firstkey()
           dbm_nextkey()
           dbm_open()
           dbm_store()
           dirname()
           dlerror()
           drand48()
           ecvt() [POSIX.1-2001 uniquement (fonction supprimée dans POSIX.1-2008)]
           encrypt()
           endgrent()
           endpwent()
           endutxent()
           fcvt() [POSIX.1-2001 uniquement (fonction supprimée dans POSIX.1-2008)]
           ftw()
           gcvt() [POSIX.1-2001 uniquement (fonction supprimée dans POSIX.1-2008)]
           getc_unlocked()
           getchar_unlocked()
           getdate()
           getenv()
           getgrent()
           getgrgid()
           getgrnam()
           gethostbyaddr() [POSIX.1-2001 uniquement (fonction supprimée dans POSIX.1-2008)]
           gethostbyname() [POSIX.1-2001 uniquement (fonction supprimée dans POSIX.1-2008)]
           gethostent()
           getlogin()
           getnetbyaddr()
           getnetbyname()
           getnetent()
           getopt()
           getprotobyname()
           getprotobynumber()
           getprotoent()
           getpwent()
           getpwnam()
           getpwuid()
           getservbyname()
           getservbyport()
           getservent()
           getutxent()
           getutxid()
           getutxline()
           gmtime()
           hcreate()
           hdestroy()
           hsearch()
           inet_ntoa()
           l64a()
           lgamma()
           lgammaf()
           lgammal()
           localeconv()
           localtime()
           lrand48()
           mrand48()
           nftw()
           nl_langinfo()
           ptsname()
           putc_unlocked()
           putchar_unlocked()
           putenv()
           pututxline()
           rand()
           readdir()
           setenv()
           setgrent()
           setkey()
           setpwent()
           setutxent()
           strerror()
           strsignal() [Ajoutée dans POSIX.1-2008]
           strtok()
           system() [Ajoutée dans POSIX.1-2008]
           tmpnam() avec un paramètre non NULL
           ttyname()
           unsetenv()
           wcrtomb() si son dernier paramètre est NULL
           wcsrtombs() si son dernier paramètre est NULL
           wcstombs()
           wctomb()

   Fonctions pour annulations sûres asynchrones
       Une  fonction pour annulations sûres asynchrones peut être appelée sans
       risque  dans  une  application  où  l'état  d'annulation   est   activé
       (consultez pthread_setcancelstate(3)).

       POSIX.1-2001 et POSIX.1-2008 exigent que seules les fonctions suivantes
       soient pour annulations sûres asynchrones :

           pthread_cancel()
           pthread_setcancelstate()
           pthread_setcanceltype()

   Points d'annulation
       POSIX.1 spécifie que certaines fonctions doivent, et  certaines  autres
       fonctions  peuvent,  être  des  points  d'annulation.  Si un thread est
       annulable, que son type  d'annulation  est  retardé  (« deferred »)  et
       qu'une  demande  d'annulation  est  en  cours  pour ce thread, alors le
       thread est annulé quand il  appelle  une  fonction  qui  est  un  point
       d'annulation.

       POSIX.1-2001  et/ou  POSIX.1-2008  exigent  que les fonctions suivantes
       soient des points d'annulation :

           accept()
           aio_suspend()
           clock_nanosleep()
           close()
           connect()
           creat()
           fcntl() F_SETLKW
           fdatasync()
           fsync()
           getmsg()
           getpmsg()
           lockf() F_LOCK
           mq_receive()
           mq_send()
           mq_timedreceive()
           mq_timedsend()
           msgrcv()
           msgsnd()
           msync()
           nanosleep()
           open()
           openat() [Ajoutée dans POSIX.1-2008]
           pause()
           poll()
           pread()
           pselect()
           pthread_cond_timedwait()
           pthread_cond_wait()
           pthread_join()
           pthread_testcancel()
           putmsg()
           putpmsg()
           pwrite()
           read()
           readv()
           recv()
           recvfrom()
           recvmsg()
           select()
           sem_timedwait()
           sem_wait()
           send()
           sendmsg()
           sendto()
           sigpause() [POSIX.1-2001 uniquement (dans la liste des fonctions pouvant être un point d'annulation dans POSIX.1-2008)]
           sigsuspend()
           sigtimedwait()
           sigwait()
           sigwaitinfo()
           sleep()
           system()
           tcdrain()
           usleep() [POSIX.1-2001 uniquement (fonction supprimée dans POSIX.1-2008)]
           wait()
           waitid()
           waitpid()
           write()
           writev()

       POSIX.1-2001 et/ou POSIX.1-2008 indiquent que les  fonctions  suivantes
       peuvent être des points d'annulation :

           access()
           asctime()
           asctime_r()
           catclose()
           catgets()
           catopen()
           chmod() [Added in POSIX.1-2008]
           chown() [Added in POSIX.1-2008]
           closedir()
           closelog()
           ctermid()
           ctime()
           ctime_r()
           dbm_close()
           dbm_delete()
           dbm_fetch()
           dbm_nextkey()
           dbm_open()
           dbm_store()
           dlclose()
           dlopen()
           dprintf() [Added in POSIX.1-2008]
           endgrent()
           endhostent()
           endnetent()
           endprotoent()
           endpwent()
           endservent()
           endutxent()
           faccessat() [Added in POSIX.1-2008]
           fchmod() [Added in POSIX.1-2008]
           fchmodat() [Added in POSIX.1-2008]
           fchown() [Added in POSIX.1-2008]
           fchownat() [Added in POSIX.1-2008]
           fclose()
           fcntl() (for any value of cmd argument)
           fflush()
           fgetc()
           fgetpos()
           fgets()
           fgetwc()
           fgetws()
           fmtmsg()
           fopen()
           fpathconf()
           fprintf()
           fputc()
           fputs()
           fputwc()
           fputws()
           fread()
           freopen()
           fscanf()
           fseek()
           fseeko()
           fsetpos()
           fstat()
           fstatat() [Added in POSIX.1-2008]
           ftell()
           ftello()
           ftw()
           futimens() [Added in POSIX.1-2008]
           fwprintf()
           fwrite()
           fwscanf()
           getaddrinfo()
           getc()
           getc_unlocked()
           getchar()
           getchar_unlocked()
           getcwd()
           getdate()
           getdelim() [Added in POSIX.1-2008]
           getgrent()
           getgrgid()
           getgrgid_r()
           getgrnam()
           getgrnam_r()
           gethostbyaddr() [SUSv3 only (function removed in POSIX.1-2008)]
           gethostbyname() [SUSv3 only (function removed in POSIX.1-2008)]
           gethostent()
           gethostid()
           gethostname()
           getline() [Added in POSIX.1-2008]
           getlogin()
           getlogin_r()
           getnameinfo()
           getnetbyaddr()
           getnetbyname()
           getnetent()
           getopt() (if opterr is nonzero)
           getprotobyname()
           getprotobynumber()
           getprotoent()
           getpwent()
           getpwnam()
           getpwnam_r()
           getpwuid()
           getpwuid_r()
           gets()
           getservbyname()
           getservbyport()
           getservent()
           getutxent()
           getutxid()
           getutxline()
           getwc()
           getwchar()
           getwd() [SUSv3 only (function removed in POSIX.1-2008)]
           glob()
           iconv_close()
           iconv_open()
           ioctl()
           link()
           linkat() [Added in POSIX.1-2008]
           lio_listio() [Added in POSIX.1-2008]
           localtime()
           localtime_r()
           lockf() [Added in POSIX.1-2008]
           lseek()
           lstat()
           mkdir() [Added in POSIX.1-2008]
           mkdirat() [Added in POSIX.1-2008]
           mkdtemp() [Added in POSIX.1-2008]
           mkfifo() [Added in POSIX.1-2008]
           mkfifoat() [Added in POSIX.1-2008]
           mknod() [Added in POSIX.1-2008]
           mknodat() [Added in POSIX.1-2008]
           mkstemp()
           mktime()
           nftw()
           opendir()
           openlog()
           pathconf()
           pclose()
           perror()
           popen()
           posix_fadvise()
           posix_fallocate()
           posix_madvise()
           posix_openpt()
           posix_spawn()
           posix_spawnp()
           posix_trace_clear()
           posix_trace_close()
           posix_trace_create()
           posix_trace_create_withlog()
           posix_trace_eventtypelist_getnext_id()
           posix_trace_eventtypelist_rewind()
           posix_trace_flush()
           posix_trace_get_attr()
           posix_trace_get_filter()
           posix_trace_get_status()
           posix_trace_getnext_event()
           posix_trace_open()
           posix_trace_rewind()
           posix_trace_set_filter()
           posix_trace_shutdown()
           posix_trace_timedgetnext_event()
           posix_typed_mem_open()
           printf()
           psiginfo() [Added in POSIX.1-2008]
           psignal() [Added in POSIX.1-2008]
           pthread_rwlock_rdlock()
           pthread_rwlock_timedrdlock()
           pthread_rwlock_timedwrlock()
           pthread_rwlock_wrlock()
           putc()
           putc_unlocked()
           putchar()
           putchar_unlocked()
           puts()
           pututxline()
           putwc()
           putwchar()
           readdir()
           readdir_r()
           readlink() [Added in POSIX.1-2008]
           readlinkat() [Added in POSIX.1-2008]
           remove()
           rename()
           renameat() [Added in POSIX.1-2008]
           rewind()
           rewinddir()
           scandir() [Added in POSIX.1-2008]
           scanf()
           seekdir()
           semop()
           setgrent()
           sethostent()
           setnetent()
           setprotoent()
           setpwent()
           setservent()
           setutxent()
           sigpause() [Added in POSIX.1-2008]
           stat()
           strerror()
           strerror_r()
           strftime()
           symlink()
           symlinkat() [Added in POSIX.1-2008]
           sync()
           syslog()
           tmpfile()
           tmpnam()
           ttyname()
           ttyname_r()
           tzset()
           ungetc()
           ungetwc()
           unlink()
           unlinkat() [Added in POSIX.1-2008]
           utime() [Added in POSIX.1-2008]
           utimensat() [Added in POSIX.1-2008]
           utimes() [Added in POSIX.1-2008]
           vdprintf() [Added in POSIX.1-2008]
           vfprintf()
           vfwprintf()
           vprintf()
           vwprintf()
           wcsftime()
           wordexp()
           wprintf()
           wscanf()

       Une  implémentation  peut  également  indiquer  d'autres  fonctions non
       spécifiées dans la  norme  comme  étant  des  points  d'annulation.  En
       particulier,  une  implémentation  marquera probablement toute fonction
       non standard qui peut bloquer comme étant un point  d'annulation  (ceci
       inclus la plupart des fonctions qui peuvent toucher des fichiers).

   Compiler sous Linux
       Sous  Linux,  les  programmes  utilisant  l'API  pthreads  doivent être
       compilés avec cc -pthread.

   Implémentations des threads POSIX sous Linux
       Deux implémentations différentes des threads ont été  fournies  par  la
       bibliothèque C de GNU sous Linux :

       LinuxThreads
              Il s'agit de l'implémentation des Pthreads originelle. Depuis la
              glibc 2.4, cette implémentation n'est plus prise en charge.

       NPTL (Native POSIX Threads Library)
              Il s'agit de l'implémentation moderne des Pthreads. Par  rapport
              à LinuxThreads, NPTL se conforme mieux aux exigences de la norme
              POSIX.1, et une meilleure performance lors de la  création  d'un
              grand   nombre   de  threads.  NPTL  est  disponible  depuis  la
              glibc 2.3.2, et nécessite des fonctionnalités présentes dans  le
              noyau Linux 2.6.

       Ces  deux  implémentation  sont  dit  de type 1:1, ce qui veut dire que
       chaque thread correspond à une entité d'ordonnancement  du  noyau.  Les
       deux  implémentations utilisent l'appel système clone(2) de Linux. Dans
       NPTL, les primitives de synchronisation de threads  (mutexes,  jonction
       de  thread,  etc.)  sont  implémentées avec l'appel système futex(2) de
       Linux.

   LinuxThreads
       Les  fonctionnalités  importantes  de  cette  implémentation  sont  les
       suivantes :

       -  En  plus  du  thread principal (initial) et des threads créés par le
          programme avec pthread_create(3), l'implémentation crée un thread de
          gestion.  Ce thread s'occupe de la création et de la terminaison des
          threads. Des problèmes peuvent survenir si  ce  thread  est  tué  de
          façon imprévue.

       -  Les  signaux  sont  utilisés  en  interne par l'implémentation. Sous
          Linux 2.2 et suivants, les trois premiers  signaux  temps-réel  sont
          utilisés  (voir  aussi  signal(7)).  Sous  les  noyaux plus anciens,
          LinuxThreads utilise SIGUSR1 et SIGUSR2.  Les  applications  doivent
          éviter d'utiliser les signaux utilisés par l'implémentation.

       -  Les  threads  ne  partagent  pas  leur identifiant de processus. (En
          fait, les threads LinuxThreads sont implémentés comme des  processus
          partageant  plus  d'informations  qu'à  l'habitude,  mais  pas  leur
          identifiant de processus.) Les threads LinuxThreads  (y  compris  le
          thread de gestion) sont visibles comme des processus différents avec
          ps(1).

       L'implémentation LinuxThreads s'écarte de la spécification POSIX.1  par
       plusieurs aspects, dont les suivants :

       -  Les  appels  à  getpid(2) renvoient une valeur distincte dans chaque
          thread.

       -  Les appels à getppid(2)  dans  les  threads  autres  que  le  thread
          principal   renvoient   l'identifiant  de  processus  du  thread  de
          gestion ; getppid(2) dans  ces  threads  devrait  renvoyer  la  même
          valeur que dans le thread principal.

       -  Lorsqu'un  thread  crée  un  nouveau  processus  fils  avec fork(2),
          n'importe quel thread devrait pouvoir utiliser wait(2) pour attendre
          la  terminaison  de  ce  fils. Cependant, l'implémentation ne permet
          qu'au thread ayant créé le fils d'appeler wait(2) pour l'attendre.

       -  Lorsqu'un thread appelle execve(2), tous  les  autres  threads  sont
          terminés  (comme  le  prescrit  POSIX.1).  Cependant,  le  processus
          résultant a le même PID que le thread ayant  appelé  execve(2) :  il
          devrait avoir le même PID que le thread principal.

       -  Les  threads ne partagent pas leurs identifiants d'utilisateur et de
          groupe. Ceci peut  causer  des  complications  pour  les  programmes
          setuid  et  provoquer des erreurs dans les fonctions pthreads si une
          application change d'identifiant avec seteuid(2) et consorts.

       -  Les threads ne partagent pas l'identifiant de session et  de  groupe
          de processus.

       -  Les  threads  ne  partagent  pas les verrouillages d'enregistrements
          créés avec fcntl(2).

       -  L'information renvoyée par times(2) et getrusage(2) est  par  thread
          au lieu d'être par processus.

       -  Les  threads  ne  partagent  pas  les valeurs « undo » de sémaphores
          (voir semop(2)).

       -  Les threads ne partagent pas les temporisations d'intervalles.

       -  Les threads ne partagent pas leur valeur de politesse.

       -  POSIX.1 distingue les notions de signal envoyé au processus dans son
          ensemble,  et  de  signal envoyé à un thread individuellement. Selon
          POSIX.1, un signal envoyé au processus (par  exemple  avec  kill(2))
          sera  géré par un thread choisi arbitrairement au sein du processus.
          LinuxThreads ne permet pas d'envoyer un signal  au  processus,  mais
          seulement à un thread spécifique.

       -  Les  threads  ont  des  paramètres  de  pile  spécifique  de  signal
          distincts. Cependant, les paramètres de pile spécifique d'un nouveau
          thread sont copiés à partir du thread qui l'a créé, ce qui veut dire
          que les threads partagent initialement une même pile  spécifique  de
          signaux. (Un nouveau thread devrait démarrer sans pile spécifique de
          signaux. Si deux threads gèrent un signal sur leur  pile  spécifique
          au même moment, des échecs imprévisibles du programme risquent de se
          produire.)

   NPTL
       Avec NPTL, tous les threads d'un processus sont  placés  dans  le  même
       groupe de threads. Tous les membres d'un groupe de threads partagent le
       même PID. NPTL n'utilise pas de thread  de  gestion.  NPTL  utilise  en
       interne  les  deux premiers signaux temps‐réel (voir aussi signal(7)) ;
       ces signaux ne peuvent pas être utilisés dans les applications.

       NPTL a encore au moins une non conformité à POSIX.1 :

       -  Les threads ne partagent pas leur valeur de politesse.

       Certaines  non  conformités  n'apparaissent  qu'avec  des  noyaux  plus
       anciens :

       -  L'information  renvoyée  par times(2) et getrusage(2) est par thread
          au lieu d'être globale au processus (corrigé dans le noyau 2.6.9).

       -  Les threads ne partagent pas les limites de ressources (corrigé dans
          le noyau 2.6.10).

       -  Les  threads  ne  partagent  pas  les  temporisations  d'intervalles
          (corrigé dans le noyau 2.6.12).

       -  Seul le thread  principal  est  autorisé  à  démarrer  une  nouvelle
          session avec setsid(2) (corrigé dans le noyau 2.6.16).

       -  Seul  le  thread principal est autorisé à rendre le processus leader
          de  son  groupe  de  processus  avec  setpgid(2)  (corrigé  dans  le
          noyau 2.6.16).

       -  Les  threads  ont  des  paramètres  de  pile  spécifique  de signaux
          distincts. Cependant, les paramètres de pile spécifique d'un nouveau
          thread  sont  copiés sur ceux du thread qui l'a créé, et les threads
          partagent donc initialement leur pile spécifique de signaux (corrigé
          dans le noyau 2.6.16).

       Veuillez noter les points suivants à propos de l'implémentation NPTL :

       -  Si  la  limite  souple  de taille de pile (voir dans setrlimit(2) la
          description de RLIMIT_STACK)  est  différente  de  unlimited,  cette
          valeur  détermine  la  taille  de  pile par défaut pour les nouveaux
          threads. Pour avoir un effet, cette limite doit être fixée avant  le
          démarrage  du programme, par exemple en utilisant la commande ulimit
          -s du shell (limit stacksize dans csh).

   Déterminer l'implémentation des threads utilisée
       Depuis glibc 2.3.2, la commande  getconf(1)  peut  être  utilisée  pour
       déterminer l'implémentation de threads du système, par exemple :

           bash$ getconf GNU_LIBPTHREAD_VERSION
           NPTL 2.3.4

       Avec  des  versions  plus  anciennes de la glibc, une commande comme la
       suivante devrait être suffisante pour  déterminer  l'implémentation  de
       threads par défaut :

           bash$ $( ldd /bin/ls | grep libc.so | awk '{print $3}' ) | \
                           egrep -i 'threads|nptl'
                   Native POSIX Threads Library by Ulrich Drepper et al

   Choisir l'implémentation des threads : LD_ASSUME_KERNEL
       Sur  les  systèmes avec une glibc fournissant à la fois LinuxThreads et
       NPTL (i.e. glibc 2.3.x), la variable  d'environnement  LD_ASSUME_KERNEL
       peut être utilisée pour écraser le choix par défaut d'implémentation de
       threads fait par l'éditeur de liens dynamique. Cette variable indique à
       l'éditeur  de liens dynamique qu'il doit faire comme s'il était exécuté
       avec une version particulière du noyau. En  indiquant  une  version  du
       noyau  ne  fournissant pas les fonctionnalités nécessitées par NPTL, on
       peut forcer l'utilisation de LinuxThreads. (La raison la plus  probable
       pour  cela  est  d'exécuter  une  application  (boguée) qui dépend d'un
       comportement de LinuxThreads non  conforme  à  la  spécification.)  Par
       exemple :

           bash$ $( LD_ASSUME_KERNEL=2.2.5 ldd /bin/ls | grep libc.so | \
                           awk '{print $3}' ) | egrep -i 'threads|ntpl'
                   linuxthreads-0.10 by Xavier Leroy

VOIR AUSSI

       clone(2), futex(2), gettid(2), proc(5), futex(7), sigevent(7),
       signal(7),
       et diverses pages de manuel Pthreads, par exemple :
       pthread_attr_init(3), pthread_atfork(3), pthread_cancel(3),
       pthread_cleanup_push(3), pthread_cond_signal(3), pthread_cond_wait(3),
       pthread_create(3), pthread_detach(3), pthread_equal(3),
       pthread_exit(3), pthread_key_create(3), pthread_kill(3),
       pthread_mutex_lock(3), pthread_mutex_unlock(3), pthread_once(3),
       pthread_setcancelstate(3), pthread_setcanceltype(3),
       pthread_setspecific(3), pthread_sigmask(3), pthread_sigqueue(3) et
       pthread_testcancel(3)

COLOPHON

       Cette page fait partie de la publication 3.32 du projet man-pages
       Linux. Une description du projet et des instructions pour signaler des
       anomalies peuvent être trouvées à l'adresse
       <URL:http://www.kernel.org/doc/man-pages/>.

TRADUCTION

       Depuis 2010, cette traduction est maintenue à l'aide de l'outil po4a
       <URL:http://po4a.alioth.debian.org/> par l'équipe de traduction
       francophone au sein du projet perkamon
       <URL:http://perkamon.alioth.debian.org/>.

       Christophe Blaess <URL:http://www.blaess.fr/christophe/> (1996-2003),
       Alain Portal <URL:http://manpagesfr.free.fr/> (2003-2006). Julien
       Cristau et l'équipe francophone de traduction de Debian (2006-2009).

       Veuillez signaler toute erreur de traduction en écrivant à
       <debian-l10n-french@lists.debian.org> ou 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> ».