perkamon - en to fr translation catalogue (34 entries)

note: type: TH
en: 2023-03-30
fr: 30 mars 2023

note: type: TH
en: Linux man-pages 6.05.01
fr: Pages du manuel de Linux 6.05.01

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: pthread_atfork - register fork handlers
fr: pthread_atfork — Enregistrer des gestionnaires d'appel à fork

note: type: SH
en: LIBRARY
fr: BIBLIOTHÈQUE

note: type: Plain text
en: POSIX threads library (I<libpthread>, I<-lpthread>)
fr: Bibliothèque de threads POSIX (I<libpthread>, I<-lpthread>)

note: type: Plain text
en: The B<pthread_atfork>()  function registers fork handlers that are to be executed when B<fork>(2)  is called by any thread in a process.  The handlers are executed in the context of the thread that calls B<fork>(2).
fr: Le fonction B<pthread_atfork>() enregistre les gestionnaires de fork qui doivent être exécutés quand B<fork>(2) est appelé par un des threads d'un processus. Les gestionnaires sont exécutés dans le contexte du thread qui appelle B<fork>(2).

note: type: Plain text
en: Three kinds of handler can be registered:
fr: Trois types de gestionnaires peuvent être enregistrés :

note: type: IP
en: \[bu]
fr: -

note: type: Plain text
en: I<prepare> specifies a handler that is executed in the parent process before B<fork>(2)  processing starts.
fr: I<prepare> spécifie un gestionnaire qui est exécuté dans le processus parent avant le début du traitement de B<fork>(2).

note: type: Plain text
en: I<parent> specifies a handler that is executed in the parent process after B<fork>(2)  processing completes.
fr: I<parent> spécifie un gestionnaire qui est exécuté dans le processus parent après l'achèvement du traitement de B<fork>(2).

note: type: Plain text
en: I<child> specifies a handler that is executed in the child process after B<fork>(2)  processing completes.
fr: I<child> spécifie un gestionnaire qui est exécuté dans le processus enfant après l'achèvement du traitement de B<fork>(2).

note: type: Plain text
en: Any of the three arguments may be NULL if no handler is needed in the corresponding phase of B<fork>(2)  processing.
fr: N'importe lequel des trois arguments peut être NULL si aucun gestionnaire n'est nécessaire dans la phase correspondante du traitement de B<fork>(2).

note: type: SH
en: RETURN VALUE
fr: VALEUR RENVOYÉE

note: type: Plain text
en: On success, B<pthread_atfork>()  returns zero.  On error, it returns an error number.  B<pthread_atfork>()  may be called multiple times by a process to register additional handlers.  The handlers for each phase are called in a specified order: the I<prepare> handlers are called in reverse order of registration; the I<parent> and I<child> handlers are called in the order of registration.
fr: B<pthread_atfork>() renvoie zéro en cas de succès. En cas d'erreur, elle renvoie un numéro d'erreur. B<pthread_atfork> peut être appelée plusieurs fois par un processus pour enregistrer des gestionnaires supplémentaires. Les gestionnaires de chaque phase sont appelés dans un ordre spécifié : les gestionnaires I<prepare> sont appelés en ordre inverse d'enregistrement, les gestionnaires I<parent> et I<child> sont appelés dans l'ordre d'enregistrement.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: Could not allocate memory to record the fork handler list entry.
fr: Impossible d'allouer assez de mémoire pour enregistrer l'entrée de liste de gestionnaires de fork.

note: type: SH
en: HISTORY
fr: HISTORIQUE

note: type: Plain text
en: When B<fork>(2)  is called in a multithreaded process, only the calling thread is duplicated in the child process.  The original intention of B<pthread_atfork>()  was to allow the child process to be returned to a consistent state.  For example, at the time of the call to B<fork>(2), other threads may have locked mutexes that are visible in the user-space memory duplicated in the child.  Such mutexes would never be unlocked, since the threads that placed the locks are not duplicated in the child.  The intent of B<pthread_atfork>()  was to provide a mechanism whereby the application (or a library)  could ensure that mutexes and other process and thread state would be restored to a consistent state.  In practice, this task is generally too difficult to be practicable.
fr: Quand B<fork>(2) est appelé dans processus multithreadé, seul le thread appelant est dupliqué dans le processus enfant. L'objectif originel de B<pthread_atfork>() était de permettre de renvoyer le processus enfant dans un état cohérent. Par exemple, au moment de l'appel de B<fork>(2), d'autres threads peuvent avoir verrouillé des mutex qui sont visibles dans la mémoirede l'espace utilisateur dupliquée dans l'enfant. Ce type de mutex ne devrait jamais être déverrouillé dans la mesure où les threads qui ont placé les verrous ne sont pas dupliqués dans l'enfant. L'intention de B<pthread_atfork>() était de fournir un mécanisme selon lequel l'application (ou une bibliothèque) pouvait assurer que les mutex et autres états de processus et de thread soient restaurés dans un état cohérent. En pratique, cette tâche est en général trop difficile pour être réalisable.

note: type: Plain text
en: After a B<fork>(2)  in a multithreaded process returns in the child, the child should call only async-signal-safe functions (see B<signal-safety>(7))  until such time as it calls B<execve>(2)  to execute a new program.
fr: Après qu'un B<fork>(2) dans un processus multithreadé retourne dans l'enfant, l'enfant peut seulement appeler des fonctions sûres du point de vue des signaux asynchrones (consultez B<signal-safety>(7)) jusqu'au moment où il appelle B<execve>(2) pour exécuter un nouveau programme.

note: type: Plain text
en: POSIX.1 specifies that B<pthread_atfork>()  shall not fail with the error B<EINTR>.
fr: POSIX.1 spécifie que B<pthread_atfork>() ne pourra échouer avec l'erreur B<EINTR>.

note: type: SH
en: SEE ALSO
fr: VOIR AUSSI

note: type: Plain text
en: pthread_atfork - register handlers to be called at fork(2) time
fr: pthread_atfork — Enregistrer des gestionnaires à invoquer lors de l'appel à fork(2)

note: type: Plain text
en: B<pthread_atfork> registers handler functions to be called just before and just after a new process is created with B<fork>(2). The I<prepare> handler will be called from the parent process, just before the new process is created. The I<parent> handler will be called from the parent process, just before B<fork>(2) returns. The I<child> handler will be called from the child process, just before B<fork>(2) returns.
fr: B<pthread_atfork>() enregistre les fonctions à appeler juste avant et juste après la création d'un nouveau processus par B<fork>(2). Le gestionnaire I<prepare> est appelé par le processus parent juste avant la création du nouveau processus. Le gestionnaire I<parent> est appelé par le processus parent juste avant que B<fork>(2) finisse. Le gestionnaire I<child> est appelé par le processus enfant juste avant la fin de l'appel B<fork>(2).

note: type: Plain text
en: One or several of the three handlers I<prepare>, I<parent> and I<child> can be given as B<NULL>, meaning that no handler needs to be called at the corresponding point.
fr: Un ou plusieurs des trois gestionnaires I<prepare>, I<parent> et I<child> peuvent être affectés comme B<NULL>, ce qui signifie qu'aucun gestionnaire ne sera appelé au moment correspondant.

note: type: Plain text
en: B<pthread_atfork> can be called several times to install several sets of handlers. At B<fork>(2) time, the I<prepare> handlers are called in LIFO order (last added with B<pthread_atfork>, first called before B<fork>), while the I<parent> and I<child> handlers are called in FIFO order (first added, first called).
fr: B<pthread_atfork> peut être appelée plusieurs fois pour enregistrer plusieurs ensembles de gestionnaires. Lors de l'appel à B<fork>(2), les gestionnaires I<prepare> sont appelés dans l'ordre LIFO (dernier ajouté avec B<pthread_atfork>, premier appelé avant B<fork>), alors que les gestionnaires I<parent> et I<child> sont appelés dans l'ordre FIFO (premier ajouté, premier appelé).

note: type: Plain text
en: To understand the purpose of B<pthread_atfork>, recall that B<fork>(2)  duplicates the whole memory space, including mutexes in their current locking state, but only the calling thread: other threads are not running in the child process.  The mutexes are not usable after the B<fork> and must be initialized with I<pthread_mutex_init> in the child process.  This is a limitation of the current implementation and might or might not be present in future versions.
fr: Pour comprendre l'objectif de B<pthread_atfork>(), rappelons que B<fork>(2) copie toute l'image mémoire du processus, y compris ses mutex dans leur état de blocage courant, mais seulement le thread appelant\ : les autres threads ne s'exécutent pas dans le processus enfant. Les mutex ne sont pas utilisables après le B<fork>() et doivent être initialisés avec I<pthread_mutex_init> dans le processus enfant. C'est une limitation de l'implémentation actuelle et peut être ou non présente dans les prochaines versions.

note: type: Plain text
en: B<pthread_atfork> returns 0 on success and a non-zero error code on error.
fr: B<pthread_atfork>() renvoie B<0> en cas de succès et un code d'erreur différent de zéro en cas d'erreur.

note: type: Plain text
en: insufficient memory available to register the handlers.
fr: Pas assez de mémoire disponible pour enregistrer les gestionnaires.

note: type: SH
en: AUTHOR
fr: AUTEUR

note: type: TH
en: Linux man-pages 6.05
fr: Pages du manuel de Linux 6.05

note: type: TH
en: 2023-02-05
fr: 5 février 2023

note: type: TH
en: Linux man-pages 6.03
fr: Pages du manuel de Linux 6.03

note: type: TH
en: Linux man-pages 6.04
fr: Pages du manuel de Linux 6.04
