Provided by: manpages-fr_4.19.0-7_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(7))

       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
       Most pthreads functions return 0 on success, and an error number  on  failure.  The  error
       numbers  that can be returned have the same meaning as the error numbers returned in errno
       by conventional system calls and C library functions. Note that the pthreads functions  do
       not  set  errno. For each of the pthreads functions that can return an error, POSIX.1-2001
       specifies that the function can never fail with the error EINTR.

   Identifiants de thread
       Each of the threads in a process has a  unique  thread  identifier  (stored  in  the  type
       pthread_t).  This  identifier is returned to the caller of pthread_create(3), and a thread
       can obtain its own thread identifier using pthread_self(3).

       Thread IDs are guaranteed to be unique only within a process. (In all  pthreads  functions
       that  accept  a  thread ID as an argument, that ID by definition refers to a thread in the
       same process as the caller.)

       The system may reuse a thread ID after a terminated thread has been joined, or a  detached
       thread  has  terminated.  POSIX says: "If an application attempts to use a thread ID whose
       lifetime has ended, the behavior is undefined."

   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() if passed a non-NULL argument
           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 only (function removed in POSIX.1-2008)]
           encrypt()
           endgrent()
           endpwent()
           endutxent()
           fcvt() [POSIX.1-2001 only (function removed in POSIX.1-2008)]
           ftw()
           gcvt() [POSIX.1-2001 only (function removed in POSIX.1-2008)]
           getc_unlocked()
           getchar_unlocked()
           getdate()
           getenv()
           getgrent()
           getgrgid()
           getgrnam()
           gethostbyaddr() [POSIX.1-2001 only (function removed in
                            POSIX.1-2008)]
           gethostbyname() [POSIX.1-2001 only (function removed in
                            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() [Added in POSIX.1-2008]
           strtok()
           system() [Added in POSIX.1-2008]
           tmpnam() if passed a non-NULL argument
           ttyname()
           unsetenv()
           wcrtomb() if its final argument is NULL
           wcsrtombs() if its final argument is 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  specifies  that  certain  functions  must,  and  certain  other functions may, be
       cancelation points. If a thread is cancelable, its cancelability type is deferred,  and  a
       cancelation request is pending for the thread, then the thread is canceled when it calls a
       function that is a cancelation point.

       The following functions are required to  be  cancelation  points  by  POSIX.1-2001  and/or
       POSIX.1-2008:

           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()

       The  following  functions  may  be  cancelation  points  according  to POSIX.1-2001 and/or
       POSIX.1-2008:

           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() [POSIX.1-2001 only (function removed in
                            POSIX.1-2008)]
           gethostbyname() [POSIX.1-2001 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() [POSIX.1-2001 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()

       An implementation may  also  mark  other  functions  not  specified  in  the  standard  as
       cancelation  points.  In  particular,  an implementation is likely to mark any nonstandard
       function that may block as a cancelation point. (This includes  most  functions  that  can
       touch files.)

       It should be noted that even if an application is not using asynchronous cancelation, that
       calling a function from the above list from an asynchronous signal handler may  cause  the
       equivalent   of  asynchronous  cancelation.  The  underlying  user  code  may  not  expect
       asynchronous cancelation and the state of the user data may become inconsistent. Therefore
       signals should be used with caution when entering a region of deferred cancelation.

   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.

       •  When one thread creates a new child process using fork(2), any thread should be able to
          wait(2)   on the child. However, the implementation allows only the thread that created
          the child to wait(2)  on it.

       •  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
       With NPTL, all of the threads in a process are  placed  in  the  same  thread  group;  all
       members of a thread group share the same PID. NPTL does not employ a manager thread.

       NPTL  makes  internal use of the first two real-time signals; these signals cannot be used
       in applications. See nptl(7)  for further details.

       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 :

       •  The information returned by times(2)   and  getrusage(2)   is  per-thread  rather  than
          process-wide (fixed in Linux 2.6.9).

       •  Threads do not share resource limits (fixed in Linux 2.6.10).

       •  Threads do not share interval timers (fixed in Linux 2.6.12).

       •  Only  the  main  thread  is  permitted to start a new session using setsid(2) (fixed in
          Linux 2.6.16).

       •  Only the main thread is permitted to make the process into a process group leader using
          setpgid(2)  (fixed in Linux 2.6.16).

       •  Threads  have  distinct  alternate  signal  stack  settings.  However,  a  new thread's
          alternate signal stack settings are copied from the thread that created it, so that the
          threads initially share an alternate signal stack (fixed in Linux 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 définie
          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|nptl'
                   linuxthreads-0.10 by Xavier Leroy

VOIR AUSSI

       clone(2), fork(2), futex(2), gettid(2), proc(5), attributes(7), futex(7), nptl(7),
       sigevent(7), signal(7)

       Various Pthreads manual pages, for example: pthread_atfork(3), pthread_attr_init(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_mutexattr_destroy(3), pthread_mutexattr_init(3), pthread_once(3),
       pthread_spin_init(3), pthread_spin_lock(3), pthread_rwlockattr_setkind_np(3),
       pthread_setcancelstate(3), pthread_setcanceltype(3), pthread_setspecific(3),
       pthread_sigmask(3), pthread_sigqueue(3), and pthread_testcancel(3)

TRADUCTION

       La traduction française de cette page de manuel a été créée par Christophe Blaess
       <https://www.blaess.fr/christophe/>, Stéphan Rafin <stephan.rafin@laposte.net>, Thierry
       Vignaud <tvignaud@mandriva.com>, François Micaux, Alain Portal <aportal@univ-montp2.fr>,
       Jean-Philippe Guérard <fevrier@tigreraye.org>, Jean-Luc Coulon (f5ibh) <jean-
       luc.coulon@wanadoo.fr>, Julien Cristau <jcristau@debian.org>, Thomas Huriaux
       <thomas.huriaux@gmail.com>, Nicolas François <nicolas.francois@centraliens.net>, Florentin
       Duneau <fduneau@gmail.com>, Simon Paillard <simon.paillard@resel.enst-bretagne.fr>, Denis
       Barbier <barbier@debian.org>, David Prévot <david@tilapin.org> et Frédéric Hantrais
       <fhantrais@gmail.com>

       Cette traduction est une documentation libre ; veuillez vous reporter à la GNU General
       Public License version 3 ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ concernant les
       conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.

       Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un
       message à ⟨debian-l10n-french@lists.debian.org⟩.