perkamon - en to fr translation catalogue (78 entries)

note: type: TH
en: 2019-03-06
fr: 6 mars 2019

note: type: TH
en: Linux Programmer's Manual
fr: Manuel du programmeur Linux

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: mallopt - set memory allocation parameters
fr: mallopt - Définir les paramètres d'allocation de mémoire

note: type: Plain text
en: The B<mallopt>()  function adjusts parameters that control the behavior of the memory-allocation functions (see B<malloc>(3)).  The I<param> argument specifies the parameter to be modified, and I<value> specifies the new value for that parameter.
fr: La fonction B<mallopt>() ajuste les paramètres qui contrôlent le comportement des fonctions liées à l'allocation de mémoire (voir B<malloc>(3)). Le paramètre I<param> indique le paramètre à modifier, et I<value> indique la nouvelle valeur pour ce paramètre.

note: type: Plain text
en: The following values can be specified for I<param>:
fr: Les valeurs suivantes peuvent être assignées à I<param> :

note: type: Plain text
en: Setting this parameter controls how glibc responds when various kinds of programming errors are detected (e.g., freeing the same pointer twice).  The 3 least significant bits (2, 1, and 0) of the value assigned to this parameter determine the glibc behavior, as follows:
fr: Ce paramètre contrôle le comportement de la glibc lorsque des erreurs de programmation sont détectées (par exemple, lors qu'un pointeur est libéré plusieurs fois). Les 3 bits de poids faible (bits 2, 1 et 0) de cette valeur ont les significations suivantes :

note: type: TP
en: Bit 0
fr: Bit 0

note: type: Plain text
en: If this bit is set, then print a one-line message on I<stderr> that provides details about the error.  The message starts with the string "***\ glibc detected\ ***", followed by the program name, the name of the memory-allocation function in which the error was detected, a brief description of the error, and the memory address where the error was detected.
fr: Lorsque ce bit est positionné, un message d'une ligne détaillant l'erreur est affiché sur I<stderr>. Le message commence par la chaîne "***\ glibc detected\ ***", suivi par le nom du programme, le nom de la fonction de l'allocation mémoire qui a détecté l'erreur, une brève description de l'erreur, puis l'adresse mémoire à laquelle l'erreur a été détectée.

note: type: TP
en: Bit 1
fr: Bit 1

note: type: Plain text
en: If this bit is set, then, after printing any error message specified by bit 0, the program is terminated by calling B<abort>(3).  In glibc versions since 2.4, if bit 0 is also set, then, between printing the error message and aborting, the program also prints a stack trace in the manner of B<backtrace>(3), and prints the process's memory mapping in the style of I</proc/[pid]/maps> (see B<proc>(5)).
fr: Lorsque ce bit est positionné, après avoir affiché un message d'erreur configuré par le bit 0, le programme est terminé en appelant B<abort>(3). Depuis la version 2.4 de la glibc, si le bit 0 est également positionné, alors le programme affiche également — entre l'affichage d'un message d'erreur et l'abandon du programme — l'état de la pile à la manière de B<backtrace>(3) et les projections en mémoire du processus à la manière de I</proc/[pid]/maps> (voir B<proc>(5)).

note: type: TP
en: Bit 2 (since glibc 2.4)
fr: Bit 2 (depuis la glibc 2.4)

note: type: Plain text
en: This bit has an effect only if bit 0 is also set.  If this bit is set, then the one-line message describing the error is simplified to contain just the name of the function where the error was detected and the brief description of the error.
fr: Ce bit a un effet uniquement si le bit 0 est également positionné. Lorsqu'il est positionné, alors le message d'erreur d'une ligne décrivant l'erreur est simplifié et contient uniquement le nom de la fonction où l'erreur a été détectée ainsi qu'une brève description de l'erreur.

note: type: Plain text
en: The remaining bits in I<value> are ignored.
fr: Les autres bits de I<value> sont ignorés.

note: type: Plain text
en: Combining the above details, the following numeric values are meaningful for B<M_CHECK_ACTION>:
fr: La combinaison des bits décrits ci-dessus permet de configurer B<M_CHECK_ACTION> avec les valeurs suivantes :

note: type: Plain text
en: Ignore error conditions; continue execution (with undefined results).
fr: Ignore les erreurs et continue l'exécution (sans résultats définis).

note: type: Plain text
en: Print a detailed error message and continue execution.
fr: Affiche un message d'erreur détaillé et continue l'exécution.

note: type: Plain text
en: Abort the program.
fr: Interrompt le programme.

note: type: Plain text
en: Print detailed error message, stack trace, and memory mappings, and abort the program.
fr: Affiche un message d'erreur détaillé, l'état de la pile et des projections en mémoire, puis interrompt le programme.

note: type: Plain text
en: Print a simple error message and continue execution.
fr: Affiche un message d'erreur simple et continue l'exécution.

note: type: Plain text
en: Print simple error message, stack trace, and memory mappings, and abort the program.
fr: Affiche un message d'erreur simple, l'état de la pile et des projections en mémoire, puis interrompt le programme.

note: type: Plain text
en: Since glibc 2.3.4, the default value for the B<M_CHECK_ACTION> parameter is 3.  In glibc version 2.3.3 and earlier, the default value is 1.
fr: Depuis la version 2.3.4 de la glibc, B<M_CHECK_ACTION> a pour valeur par défaut 3 (1 jusqu'à la version 2.3.3).

note: type: Plain text
en: Using a nonzero B<M_CHECK_ACTION> value can be useful because otherwise a crash may happen much later, and the true cause of the problem is then very hard to track down.
fr: Il est recommandé d'utiliser une valeur B<M_CHECK_ACTION> non nulle, car sinon l'arrêt impromptu du programme risque d'être différé, ce qui rend très difficile de retrouver l'origine du problème.

note: The following text adapted from comments in the glibc source: type: Plain text
en: This parameter specifies the maximum number of allocation requests that may be simultaneously serviced using B<mmap>(2).  This parameter exists because some systems have a limited number of internal tables for use by B<mmap>(2), and using more than a few of them may degrade performance.
fr: Ce paramètre indique le nombre maximum de requêtes d'allocation qui peuvent être servies simultanément avec B<mmap>(2). Il permet de préserver les performances de certains systèmes qui ont un nombre limité de tables internes à disposition de B<mmap>(2).

note: type: Plain text
en: For allocations greater than or equal to the limit specified (in bytes) by B<M_MMAP_THRESHOLD> that can't be satisfied from the free list, the memory-allocation functions employ B<mmap>(2)  instead of increasing the program break using B<sbrk>(2).
fr: Lorsqu'une requête d'allocation supérieure ou égale au seuil B<M_MMAP_THRESHOLD> (en octets) ne peut être satisfaite depuis la liste de blocs libres, les fonctions d'allocation de mémoire utilisent B<mmap>(2) plutôt que d'augmenter la taille du segment de données avec B<sbrk>(2).

note: type: Plain text
en: Allocating memory using B<mmap>(2)  has the significant advantage that the allocated memory blocks can always be independently released back to the system.  (By contrast, the heap can be trimmed only if memory is freed at the top end.)  On the other hand, there are some disadvantages to the use of B<mmap>(2): deallocated space is not placed on the free list for reuse by later allocations; memory may be wasted because B<mmap>(2)  allocations must be page-aligned; and the kernel must perform the expensive task of zeroing out memory allocated via B<mmap>(2).  Balancing these factors leads to a default setting of 128*1024 for the B<M_MMAP_THRESHOLD> parameter.
fr: Allouer la mémoire avec B<mmap>(2) permet toujours aux blocs de mémoire alloués d'être rendus de manière indépendante au système. Cela représente un avantage significatif comparé au tas qui ne peut être désalloué que si la mémoire est libérée par le haut. D'autre part, il y a certains inconvénients à utiliser B<mmap>(2) : l'espace désalloué n'est pas considéré comme libéré l'empêchant d'être réutilisé pour de futures allocations ; de la mémoire peut être gaspillée car les allocations via B<mmap>(2) doivent être alignées sur une taille de page ; et le noyau doit effectuer la tâche coûteuse de remise à zéro de la mémoire allouée par B<mmap>(2). Trouver un compromis entre ces effets mène à une valeur du paramètre B<M_MMAP_THRESHOLD> par défaut à 128*1024.

note: type: Plain text
en: The lower limit for this parameter is 0.  The upper limit is B<DEFAULT_MMAP_THRESHOLD_MAX>: 512*1024 on 32-bit systems or I<4*1024*1024*sizeof(long)> on 64-bit systems.
fr: La limite basse de ce paramètre est 0. La limite haute est B<DEFAULT_MMAP_THRESHOLD_MAX> : c'est-à-dire 512*1024 sur les systèmes 32 bits ou I<4*1024*1024*sizeof(long)> sur les systèmes 64 bits.

note: type: Plain text
en: I<Note:> Nowadays, glibc uses a dynamic mmap threshold by default.  The initial value of the threshold is 128*1024, but when blocks larger than the current threshold and less than or equal to B<DEFAULT_MMAP_THRESHOLD_MAX> are freed, the threshold is adjusted upward to the size of the freed block.  When dynamic mmap thresholding is in effect, the threshold for trimming the heap is also dynamically adjusted to be twice the dynamic mmap threshold.  Dynamic adjustment of the mmap threshold is disabled if any of the B<M_TRIM_THRESHOLD>, B<M_TOP_PAD>, B<M_MMAP_THRESHOLD>, or B<M_MMAP_MAX> parameters is set.
fr: I<Note :> de nos jours, la glibc configure ce seuil dynamiquement. La valeur initiale est 128*1024, mais lorsque sont libérés des blocs de taille supérieure au seuil mais inférieure ou égale à B<DEFAULT_MMAP_THRESHOLD_MAX>, le seuil est ajusté à la taille du bloc libéré. Quand le mécanisme de seuil dynamique est activé, le seuil de désallocation du tas est également configuré dynamiquement à deux fois le seuil mmap. L'ajustement dynamique du seuil mmap est désactivé dès lors qu'un des paramètres B<M_TRIM_THRESHOLD>, B<M_TOP_PAD>, B<M_MMAP_THRESHOLD>, ou B<M_MMAP_MAX> est configuré.

note: type: TP
en: B<M_MXFAST> (since glibc 2.3)
fr: B<M_MXFAST> (depuis glibc 2.3)

note: type: TP
en: B<M_PERTURB> (since glibc 2.4)
fr: B<M_PERTURB> (depuis glibc 2.4)

note: type: Plain text
en: If this parameter is set to a nonzero value, then bytes of allocated memory (other than allocations via B<calloc>(3))  are initialized to the complement of the value in the least significant byte of I<value>, and when allocated memory is released using B<free>(3), the freed bytes are set to the least significant byte of I<value>.  This can be useful for detecting errors where programs incorrectly rely on allocated memory being initialized to zero, or reuse values in memory that has already been freed.
fr: Si ce paramètre est configuré à une valeur non nulle, tous les octets de mémoire allouée (autrement qu'avec B<calloc>(3)) sont initialisés au complément de la valeur de l'octet le moins significatif de I<value>. Lorsque la mémoire allouée est libérée avec B<free>(3), les octets libérés prennent tous la valeur de l'octet le moins significatif de I<value>. Cette fonctionnalité permet de détecter des erreurs lorsque les programmes supposent que la mémoire allouée a été initialisée à zéro, ou réutilisent des valeurs depuis une zone mémoire précédemment libérée.

note: type: Plain text
en: This parameter defines the amount of padding to employ when calling B<sbrk>(2)  to modify the program break.  (The measurement unit for this parameter is bytes.)  This parameter has an effect in the following circumstances:
fr: Ce paramètre définit la quantité en octets de bourrage à utiliser lors de l'appel à B<sbrk>(2) pour modifier la taille du segment de données. Ce paramètre a un effet dans les circonstances suivantes\ :

note: type: Plain text
en: When the program break is increased, then B<M_TOP_PAD> bytes are added to the B<sbrk>(2)  request.
fr: Lorsque la taille du segment de données est augmentée, B<M_TOP_PAD> octets sont ajoutés à la requête B<sbrk>(2).

note: type: Plain text
en: When the heap is trimmed as a consequence of calling B<free>(3)  (see the discussion of B<M_TRIM_THRESHOLD>)  this much free space is preserved at the top of the heap.
fr: Lorsque le tas est désalloué suite à l'appel B<free>(3) (voir B<M_TRIM_THRESHOLD>), cet espace supplémentaire est préservé en haut du tas.

note: type: Plain text
en: In either case, the amount of padding is always rounded to a system page boundary.
fr: Dans tous les cas, la quantité de bourrage est toujours arrondie à la taille d'une page système.

note: type: Plain text
en: Modifying B<M_TOP_PAD> is a trade-off between increasing the number of system calls (when the parameter is set low)  and wasting unused memory at the top of the heap (when the parameter is set high).
fr: La valeur B<M_TOP_PAD> résulte d'un compromis entre l'augmentation du nombre d'appels système (avec une valeur faible) et le gaspillage de mémoire inutilisée en haut du tas (avec une valeur élevée).

note: DEFAULT_TOP_PAD in glibc source type: Plain text
en: The default value for this parameter is 128*1024.
fr: La valeur par défaut de ce paramètre est 128*1024.

note: type: Plain text
en: When the amount of contiguous free memory at the top of the heap grows sufficiently large, B<free>(3)  employs B<sbrk>(2)  to release this memory back to the system.  (This can be useful in programs that continue to execute for a long period after freeing a significant amount of memory.)  The B<M_TRIM_THRESHOLD> parameter specifies the minimum size (in bytes) that this block of memory must reach before B<sbrk>(2)  is used to trim the heap.
fr: Lorsque la quantité de mémoire libre et contigüe en haut du tas dépasse ce seuil, B<free>(3) utilise B<sbrk>(2) pour rendre cette mémoire au système d'exploitation. (Cela peut être utile pour les programmes qui sont exécutés encore longtemps après avoir libéré une quantité importante de mémoire.)

note: type: Plain text
en: The default value for this parameter is 128*1024.  Setting B<M_TRIM_THRESHOLD> to -1 disables trimming completely.
fr: La valeur par défaut de ce paramètre est 128*1024, en octets. Une valeur de -1 désactive complètement la désallocation.

note: type: Plain text
en: Modifying B<M_TRIM_THRESHOLD> is a trade-off between increasing the number of system calls (when the parameter is set low)  and wasting unused memory at the top of the heap (when the parameter is set high).
fr: La valeur B<M_TRIM_THRESHOLD> résulte d'un compromis entre l'augmentation du nombre d'appels système (avec une valeur faible) et le gaspillage de mémoire inutilisée en haut du tas (avec une valeur élevée).

note: type: SS
en: Environment variables
fr: Variables d'environnement

note: type: Plain text
en: A number of environment variables can be defined to modify some of the same parameters as are controlled by B<mallopt>().  Using these variables has the advantage that the source code of the program need not be changed.  To be effective, these variables must be defined before the first call to a memory-allocation function.  (If the same parameters are adjusted via B<mallopt>(), then the B<mallopt>()  settings take precedence.)  For security reasons, these variables are ignored in set-user-ID and set-group-ID programs.
fr: Un certain nombre des paramètres de B<mallopt>() peuvent être modifiés à travers de variables d'environnement. Ces variables ont l'avantage de ne pas nécessiter la modification du code source du programme. Pour être prises en compte, ces variables doivent être définies avant le premier appel à une fonction d'allocation mémoire. Les paramètres passés par la fonction B<mallopt>() sont prioritaires devant ceux issus des variables d'environnement. Pour des raisons de sécurité, ces variables sont ignorées dans le cas de programmes I<setuid> ou I<setgid>.

note: On glibc 2.12/x86, a simple malloc()+free() loop is about 70% slower when MALLOC_CHECK_ was set. type: Plain text
en: This environment variable controls the same parameter as B<mallopt>()  B<M_CHECK_ACTION>.  If this variable is set to a nonzero value, then a special implementation of the memory-allocation functions is used.  (This is accomplished using the B<malloc_hook>(3)  feature.)  This implementation performs additional error checking, but is slower than the standard set of memory-allocation functions.  (This implementation does not detect all possible errors; memory leaks can still occur.)
fr: Cette variable d'environnement contrôle le même paramètre que B<M_CHECK_ACTION> de B<mallopt>(). Si elle est configurée à une valeur non nulle, une mise en œuvre spécifique des fonctions d'allocation mémoire est utilisée, grâce à la fonctionnalité B<malloc_hook>(3). Cette mise en œuvre effectue des vérifications d'erreurs supplémentaires, au prix d'un ralentissement par rapport au jeu standard de fonctions d'allocation mémoire. Cependant, elle ne détecte pas toutes les erreurs possibles : des fuites mémoires peuvent encore se produire.

note: type: Plain text
en: The value assigned to this environment variable should be a single digit, whose meaning is as described for B<M_CHECK_ACTION>.  Any characters beyond the initial digit are ignored.
fr: La valeur de cette variable d'environnement doit être un seul chiffre, dont le sens est comme décrit pour B<M_CHECK_ACTION>. Tout caractère au-delà du premier chiffre est ignoré.

note: type: Plain text
en: For security reasons, the effect of B<MALLOC_CHECK_> is disabled by default for set-user-ID and set-group-ID programs.  However, if the file I</etc/suid-debug> exists (the content of the file is irrelevant), then B<MALLOC_CHECK_> also has an effect for set-user-ID and set-group-ID programs.
fr: Pour des raisons de sécurité, B<MALLOC_CHECK_> est ignoré par défaut dans le cas de programmes I<setuid> ou I<setgid>. Cependant, si le fichier I</etc/suid-debug> existe (peu importe son contenu), alors la valeur de B<MALLOC_CHECK_> est prise en compte pour les programmes I<setuid> ou I<setgid>.

note: type: Plain text
en: Controls the same parameter as B<mallopt>()  B<M_MMAP_MAX>.
fr: Contrôle le même paramètre que B<M_MMAP_MAX> de B<mallopt>().

note: type: Plain text
en: Controls the same parameter as B<mallopt>()  B<M_MMAP_THRESHOLD>.
fr: Contrôle le même paramètre que B<M_MMAP_THRESHOLD> de B<mallopt>().

note: type: Plain text
en: Controls the same parameter as B<mallopt>()  B<M_PERTURB>.
fr: Contrôle le même paramètre que B<M_PERTURB> de B<mallopt>().

note: type: Plain text
en: Controls the same parameter as B<mallopt>()  B<M_TRIM_THRESHOLD>.
fr: Contrôle le même paramètre que B<M_TRIM_THRESHOLD> de B<mallopt>().

note: type: Plain text
en: Controls the same parameter as B<mallopt>()  B<M_TOP_PAD>.
fr: Contrôle le même paramètre que B<M_TOP_PAD> de B<mallopt>().

note: type: SH
en: RETURN VALUE
fr: VALEUR DE RETOUR

note: type: Plain text
en: On success, B<mallopt>()  returns 1.  On error, it returns 0.
fr: En cas de succès, B<mallopt>() renvoie 1. En cas d'erreur, il renvoie 0.

note: type: SH
en: ERRORS
fr: ERREURS

note: .SH VERSIONS Available already in glibc 2.0, possibly earlier type: Plain text
en: On error, I<errno> is I<not> set.
fr: En cas d'erreur, I<errno> n'est pas positionné.

note: type: SH
en: CONFORMING TO
fr: CONFORMITÉ

note: .SH NOTES type: Plain text
en: This function is not specified by POSIX or the C standards.  A similar function exists on many System V derivatives, but the range of values for I<param> varies across systems.  The SVID defined options B<M_MXFAST>, B<M_NLBLKS>, B<M_GRAIN>, and B<M_KEEP>, but only the first of these is implemented in glibc.
fr: Cette fonction n'est pas spécifiée par les standards POSIX ou C. Une fonction similaire existe sur de nombreux dérivés de « System V », mais les valeurs permises de I<param> varient d'un système à l'autre. SVID définit les options B<M_MXFAST>, B<M_NLBLKS>, B<M_GRAIN>, and B<M_KEEP>, mais seule la première d'entre elles est disponible dans la glibc.

note: type: SH
en: BUGS
fr: BOGUES

note: type: Plain text
en: Specifying an invalid value for I<param> does not generate an error.
fr: Indiquer une valeur invalide pour I<param> ne génère pas d'erreur.

note: FIXME . This looks buggy: setting the M_MXFAST limit rounds up:    (s + SIZE_SZ) & ~MALLOC_ALIGN_MASK) malloc requests are rounded up: (req) + SIZE_SZ + MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK http://sources.redhat.com/bugzilla/show_bug.cgi?id=12129 type: Plain text
en: A calculation error within the glibc implementation means that a call of the form:
fr: Une erreur de calcul dans la mise en œuvre glibc implique qu'un appel de la forme suivante :

note: Bins are multiples of 2 * sizeof(size_t) + sizeof(size_t) type: Plain text
en: does not result in fastbins being employed for all allocations of size up to I<n>.  To ensure desired results, I<n> should be rounded up to the next multiple greater than or equal to I<(2k+1)*sizeof(size_t)>, where I<k> is an integer.
fr: n'active pas les « fastbins » pour toutes les allocations d'une taille jusqu'à I<n>. Pour obtenir l'effet attendu, I<n> doit être arrondi à un multiple supérieur ou égal à I<(2k+1)*sizeof(size_t)>, où I<k> est un entier.

note: FIXME . http://sources.redhat.com/bugzilla/show_bug.cgi?id=12140 type: Plain text
en: If B<mallopt>()  is used to set B<M_PERTURB>, then, as expected, the bytes of allocated memory are initialized to the complement of the byte in I<value>, and when that memory is freed, the bytes of the region are initialized to the byte specified in I<value>.  However, there is an off-by-I<sizeof(size_t)> error in the implementation: instead of initializing precisely the block of memory being freed by the call I<free(p)>, the block starting at I<p+sizeof(size_t)> is initialized.
fr: Si B<mallopt>() est utilisé pour configurer B<M_PERTURB>, tous les octets de mémoire alloués sont initialisés au complément de I<value>, puis lorsque la mémoire est libérée les octets sont initialisés à I<value>. Cependant, une erreur de I<sizeof(size_t)> est présente dans le code mis en œuvre : au lieu d'initialiser précisément le bloc de mémoire libéré par l'appel I<free(p)>, c'est bloc démarrant à I<p+sizeof(size_t)> qui est initialisé.

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: The program below demonstrates the use of B<M_CHECK_ACTION>.  If the program is supplied with an (integer) command-line argument, then that argument is used to set the B<M_CHECK_ACTION> parameter.  The program then allocates a block of memory, and frees it twice (an error).
fr: Le programme ci-dessous illustre l'utilisation de B<M_CHECK_ACTION>. Si le programme est appelé avec un paramètre (entier), alors celui-ci est utilisé pour B<M_CHECK_ACTION>. Le programme alloue un bloc de mémoire, puis le libère deux fois, ce qui constitue une erreur.

note: type: Plain text
en: The following shell session shows what happens when we run this program under glibc, with the default value for B<M_CHECK_ACTION>:
fr: L'exemple de session ci-dessous montre ce qu'il se passe lorsqu'un programme est exécuté avec la glibc et la valeur par défaut de B<M_CHECK_ACTION> :

note: type: Plain text
en: $ B<./a.out>
    main(): returned from first free() call
    *** glibc detected *** ./a.out: double free or corruption (top): 0x09d30008 ***
    ======= Backtrace: =========
    /lib/libc.so.6(+0x6c501)[0x523501]
    /lib/libc.so.6(+0x6dd70)[0x524d70]
    /lib/libc.so.6(cfree+0x6d)[0x527e5d]
    \&./a.out[0x80485db]
    /lib/libc.so.6(__libc_start_main+0xe7)[0x4cdce7]
    \&./a.out[0x8048471]
    ======= Memory map: ========
    001e4000-001fe000 r-xp 00000000 08:06 1083555    /lib/libgcc_s.so.1
    001fe000-001ff000 r--p 00019000 08:06 1083555    /lib/libgcc_s.so.1
    [some lines omitted]
    b7814000-b7817000 rw-p 00000000 00:00 0
    bff53000-bff74000 rw-p 00000000 00:00 0          [stack]
    Aborted (core dumped)
fr: $ B<./a.out>
    main(): fin du premier appel free()
    *** glibc detected *** ./a.out: double free or corruption (top): 0x09d30008 ***
    ======= Backtrace: =========
    /lib/libc.so.6(+0x6c501)[0x523501]
    /lib/libc.so.6(+0x6dd70)[0x524d70]
    /lib/libc.so.6(cfree+0x6d)[0x527e5d]
    \&./a.out[0x80485db]
    /lib/libc.so.6(__libc_start_main+0xe7)[0x4cdce7]
    \&./a.out[0x8048471]
    ======= Memory map: ========
    001e4000-001fe000 r-xp 00000000 08:06 1083555    /lib/libgcc_s.so.1
    001fe000-001ff000 r--p 00019000 08:06 1083555    /lib/libgcc_s.so.1
    [some lines omitted]
    b7814000-b7817000 rw-p 00000000 00:00 0
    bff53000-bff74000 rw-p 00000000 00:00 0          [stack]
    Abandon

note: type: Plain text
en: The following runs show the results when employing other values for B<M_CHECK_ACTION>:
fr: L'exemple suivant montre les cas d'autres valeurs de B<M_CHECK_ACTION>:

note: type: Plain text
en: $ B<./a.out 1>             # Diagnose error and continue
    main(): returned from first free() call
    *** glibc detected *** ./a.out: double free or corruption (top): 0x09cbe008 ***
    main(): returned from second free() call
    $ B<./a.out 2>             # Abort without error message
    main(): returned from first free() call
    Aborted (core dumped)
    $ B<./a.out 0>             # Ignore error and continue
    main(): returned from first free() call
    main(): returned from second free() call
fr: $ B<./a.out 1>             # Diagnostique l'erreur et continue
    main(): fin du premier appel free()
    *** glibc detected *** ./a.out: double free or corruption (top): 0x09cbe008 ***
    main(): fin du second appel free()
    $ B<./a.out 2>             # Interrompt le programme sans message d'erreur
    main(): fin du premier appel free()
    Abandon
    $ B<./a.out 0>             # Ignore l'erreur et continue
    main(): fin du premier appel free()
    main(): fin du second appel free()

note: type: Plain text
en: The next run shows how to set the same parameter using the B<MALLOC_CHECK_> environment variable:
fr: L'exemple suivant montre comment configurer le même paramètre avec la variable d'environnement B<MALLOC_CHECK_> :

note: type: Plain text
en: $ B<MALLOC_CHECK_=1 ./a.out>
    main(): returned from first free() call
    *** glibc detected *** ./a.out: free(): invalid pointer: 0x092c2008 ***
    main(): returned from second free() call
fr: $ B<MALLOC_CHECK_=1 ./a.out>
    main(): fin du premier appel free()
    *** glibc detected *** ./a.out: free(): invalid pointer: 0x092c2008 ***
    main(): fin du second appel free()

note: type: SS
en: Program source
fr: Source du programme

note: type: Plain text
en:     if (argc E<gt> 1) {
            if (mallopt(M_CHECK_ACTION, atoi(argv[1])) != 1) {
                fprintf(stderr, "mallopt() failed");
                exit(EXIT_FAILURE);
            }
        }
fr:     if (argc E<gt> 1) {
            if (mallopt(M_CHECK_ACTION, atoi(argv[1])) != 1) {
                fprintf(stderr, "échec de mallopt()");
                exit(EXIT_FAILURE);
            }
        }

note: type: Plain text
en:     p = malloc(1000);
        if (p == NULL) {
            fprintf(stderr, "malloc() failed");
            exit(EXIT_FAILURE);
        }
fr:     p = malloc(1000);
        if (p == NULL) {
            fprintf(stderr, "échec de malloc()");
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     free(p);
        printf("main(): returned from first free() call\en");
fr:     free(p);
        printf("main(): fin du premier appel free()\en");

note: type: Plain text
en:     free(p);
        printf("main(): returned from second free() call\en");
fr:     free(p);
        printf("main(): fin du second appel free()\en");

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

note: type: Plain text
en: This page is part of release 5.03 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 5.03 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man-pages/.

note: type: Plain text
en: This page is part of release 5.02 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 5.02 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man-pages/.

note: type: Plain text
en: This page is part of release 5.01 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 5.01 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man-pages/.
