perkamon - en to fr translation catalogue (125 entries)

note: type: TH
en: 2012-10-18
fr: 18 octobre 2012

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: create_module - create a loadable module entry
fr: create_module - Créer une entrée de module chargeable

note: type: Plain text
en: B<Note>: This system call is present only in kernels before Linux 2.6.
fr: B<Remarque> : cet appel système n'est présent dans Linux qu'avant le noyau 2.6.

note: type: Plain text
en: B<create_module>()  attempts to create a loadable module entry and reserve the kernel memory that will be needed to hold the module.  This system call requires privilege.
fr: B<create_module>()  essaye de créer une entrée de module chargeable et réserve la mémoire noyau qui est nécessaire pour maintenir le module. Cet appel système nécessite des privilèges.

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

note: type: Plain text
en: On success, returns the kernel address at which the module will reside.  On error, -1 is returned and I<errno> is set appropriately.
fr: S'il réussit, il renvoie l'adresse noyau où le module résidera. S'il échoue, il renvoie -1 et remplit I<errno> en conséquence.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: A module by that name already exists.
fr: Un module du même nom existe déjà.

note: type: Plain text
en: I<name> is outside the program's accessible address space.
fr: I<name> est en dehors de l'espace d'adressage du programme.

note: type: Plain text
en: The requested size is too small even for the module header information.
fr: La taille demandée est trop petite, même pour les informations de l'en-tête du module.

note: type: Plain text
en: The kernel could not allocate a contiguous block of memory large enough for the module.
fr: Le noyau ne peut pas allouer un bloc contigu de mémoire suffisamment grand pour le module.

note: type: Plain text
en: B<create_module>()  is not supported in this version of the kernel (e.g., the kernel is version 2.6 or later).
fr: B<create_module>() n'est pas pris en charge par cette version du noyau (par exemple un noyau en version 2.6 ou au-delà).

note: type: Plain text
en: The caller was not privileged (did not have the B<CAP_SYS_MODULE> capability).
fr: L'appelant n'est pas privilégié (n'a pas la capacité B<CAP_SYS_MODULE>).

note: Removed in Linux 2.5.48 type: Plain text
en: This system call is present on Linux only up until kernel 2.4; it was removed in Linux 2.6.
fr: Cet appel système n'est présent dans Linux que jusqu'au noyau\ 2.4\ ; il a été supprimé dans Linux\ 2.6.

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

note: type: Plain text
en: B<create_module>()  is Linux-specific.
fr: B<create_module>()  est spécifique à Linux.

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

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

note: type: TH
en: 2012-11-08
fr: 8 novembre 2012

note: type: Plain text
en: delete_module - unload a kernel module
fr: delete_module - Décharger un module de noyau

note: type: Plain text
en: I<Note>: There is no glibc wrapper for this system call; see NOTES.
fr: I<Remarque> : il n'existe pas de fonction glibc autour de cet appel système ; consultez B<NOTES>.

note: type: Plain text
en: The B<delete_module>()  system call attempts to remove the unused loadable module entry identified by I<name>.  If the module has an I<exit> function, then that function is executed before unloading the module.  The I<flags> argument is used to modify the behavior of the system call, as described below.  This system call requires privilege.
fr: L'appel système B<delete_module>() essaye de supprimer une entrée de module chargeable inutilisée identifiée par I<name>. Si le module à une fonction I<exit>, alors cette fonction est exécutée avant de décharger le module. L'argument I<flags> est utilisé pour modifier le comportement de l'appel système, conformément à la description ci-dessous. Cet appel système nécessite des droits.

note: type: Plain text
en: Module removal is attempted according to the following rules:
fr: La suppression de module est essayée d'après les règles suivantes.

note: type: Plain text
en: If there are other loaded modules that depend on (i.e., refer to symbols defined in) this module, then the call fails.
fr: Si d'autres modules chargés dépendent de (c'est-à-dire font référence aux symboles définis dans) ce module, alors l'appel échoue.

note: type: Plain text
en: Otherwise, if the reference count for the module (i.e., the number of processes currently using the module)  is zero, then the module is immediately unloaded.
fr: Sinon, si le nombre de références pour ce module (c'est-à-dire le nombre de processus utilisant actuellement ce module) est nul, alors le module est immédiatement déchargé.

note: O_TRUNC == KMOD_REMOVE_FORCE in kmod library O_NONBLOCK == KMOD_REMOVE_NOWAIT in kmod library type: Plain text
en: If a module has a nonzero reference count, then the behavior depends on the bits set in I<flags>.  In normal usage (see NOTES), the B<O_NONBLOCK> flag is always specified, and the B<O_TRUNC> flag may additionally be specified.
fr: Si un module a un nombre de références non nul, alors le comportement dépend des bits définis dans I<flags>. En utilisation normale (consultez B<NOTES>), l'attribut B<O_NONBLOCK> est toujours indiqué, et l'attribut B<O_TRUNC> pourrait être aussi indiqué.

note: type: Plain text
en: The various combinations for I<flags> have the following effect:
fr: Les diverses combinaisons de I<flags> ont les effets suivants.

note: type: Plain text
en: The call returns immediately, with an error.
fr: L'appel se termine immédiatement, avec une erreur.

note: type: Plain text
en: The module is unloaded immediately, regardless of whether it has a nonzero reference count.
fr: Le module est déchargé immédiatement, quelque soit le nombre de références.

note: type: Plain text
en: If I<flags> does not specify B<O_NONBLOCK>, the following steps occur:
fr: Si I<flags> n'indique pas B<O_NONBLOCK>, les étapes suivantes se succèdent :

note: type: Plain text
en: The module is marked so that no new references are permitted.
fr: le module est marqué de telle sorte qu'aucune nouvelle référence est permise ;

note: type: Plain text
en: If the module's reference count is nonzero, the caller is placed in an uninterruptible sleep state (B<TASK_UNINTERRUPTIBLE>)  until the reference count is zero, at which point the call unblocks.
fr: si le nombre de références du module est non nul, l'appelant est placé en état de sommeil non interruptible (B<TASK_UNINTERRUPTIBLE>) jusqu'à ce que le nombre de références soit nul, à ce moment l'appel est débloqué ;

note: type: Plain text
en: The module is unloaded in the usual way.
fr: le module est déchargé normalement

note: type: Plain text
en: The B<O_TRUNC> flag has one further effect on the rules described above.  By default, if a module has an I<init> function but no I<exit> function, then an attempt to remove the module will fail.  However, if B<O_TRUNC> was specified, this requirement is bypassed.
fr: L'attribut B<O_TRUNC> a un effet supplémentaire sur les réglés décrites précédemment. Par défaut, si un module a une fonction I<init> mais pas de fonction I<exit>, essayer de supprimer ce module échouera. Cependant, si B<O_TRUNC> a été indiqué, cette condition est contournée.

note: type: Plain text
en: Using the B<O_TRUNC> flag is dangerous! If the kernel was not built with B<CONFIG_MODULE_FORCE_UNLOAD>, this flag is silently ignored.  (Normally, B<CONFIG_MODULE_FORCE_UNLOAD> is enabled.)  Using this flag taints the kernel (TAINT_FORCED_RMMOD).
fr: Utiliser l'attribut B<O_TRUNC> est dangereux. Si le noyau n'a pas été construit avec B<CONFIG_MODULE_FORCE_UNLOAD>, cet attribut est ignoré silencieusement (normalement, B<CONFIG_MODULE_FORCE_UNLOAD> est activé). Utiliser cet attribut corrompt le noyau (TAINT_FORCED_RMMOD).

note: type: Plain text
en: On success, zero is returned.  On error, -1 is returned and I<errno> is set appropriately.
fr: S'il réussit, cet appel système renvoie 0. S'il échoue, il renvoie -1 et définit I<errno> en conséquence.

note: type: Plain text
en: The module is not "live" (i.e., it is still being initialized or is already marked for removal); or, the module has an I<init> function but has no I<exit> function, and B<O_TRUNC> was not specified in I<flags>.
fr: Le module n'est pas « actif » (c'est-à-dire qu'il est encore en cours d'initialisation ou déjà marqué pour la suppression), ou le module a une fonction I<init> mais pas de fonction I<exit>, et B<O_TRUNC> n'a pas été indiqué dans I<flags>.

note: type: Plain text
en: I<name> refers to a location outside the process's accessible address space.
fr: I<name> fait référence à un emplacement en dehors de l'espace d'adressage accessible du processus.

note: type: Plain text
en: No module by that name exists.
fr: Il n'existe aucun module de ce nom.

note: type: Plain text
en: The caller was not privileged (did not have the B<CAP_SYS_MODULE> capability), or module unloading is disabled (see I</proc/sys/kernel/modules_disabled> in B<proc>(5)).
fr: L'appelant n'avait pas les droits (n'avait pas la capacité B<CAP_SYS_MODULE>), ou le déchargement de module est désactivé (consultez I</proc/sys/kernel/modules_disabled> dans B<proc>(5)).

note: type: Plain text
en: Other modules depend on this module; or, B<O_NONBLOCK> was specified in I<flags>, but the reference count of this module is nonzero and B<O_TRUNC> was not specified in I<flags>.
fr: D'autres modules dépendent de ce module, ou B<O_NONBLOCK> a été indiqué dans I<flags>, mais le nombre de références est non nul et B<O_TRUNC> n'a pas été indiqué dans I<flags>.

note: type: Plain text
en: B<delete_module>()  is Linux-specific.
fr: B<delete_module>()  est spécifique à Linux.

note: type: Plain text
en: Glibc does not provide a wrapper for this system call; call it using B<syscall>(2).
fr: La glibc ne fournit pas de fonction autour de cet appel système ; utilisez B<syscall>(2) pour l'appeler.

note: type: Plain text
en: The uninterruptible sleep that may occur if B<O_NONBLOCK> is omitted from I<flags> is considered undesirable, because the sleeping process is left in an unkillable state.  As at Linux 3.7, specifying B<O_NONBLOCK> is optional, but in future kernels it is likely to become mandatory.
fr: Le sommeil non interruptible qui peut arriver si B<O_NONBLOCK> est omis de I<flags> est considéré indésirable, parce que le processus dormant est laissé dans un état non tuable. Avec Linux 3.7, indiquer B<O_NONBLOCK> est facultatif, mais à l'avenir, ce sera probablement obligatoire.

note: type: SS
en: Linux 2.4 and earlier
fr: Linux 2.4 et antérieurs

note: type: Plain text
en: In Linux 2.4 and earlier, the system call took only one argument:
fr: Dans Linux 2.4 et antérieurs, l'appel système ne prend qu'un argument :

note: type: Plain text
en: If I<name> is NULL, all unused modules marked auto-clean are removed.
fr: Si I<name> est NULL, tous les modules non utilisés marqués à nettoyer automatiquement sont supprimés.

note: type: Plain text
en: Some further details of differences in the behavior of B<delete_module>()  in Linux 2.4 and earlier are I<not> currently explained in this manual page.
fr: De plus amples précisions sur les différences de comportement de B<delete_module>() dans Linux 2.4 et antérieurs ne sont actuellement I<pas> expliquées dans cette page de manuel.

note: type: Plain text
en: get_kernel_syms - retrieve exported kernel and module symbols
fr: get_kernel_syms - Obtenir les symboles exportés du noyau et des modules

note: type: Plain text
en: If I<table> is NULL, B<get_kernel_syms>()  returns the number of symbols available for query.  Otherwise it fills in a table of structures:
fr: Si I<table> est NULL, B<get_kernel_syms>()  renvoie le nombre de symboles disponibles. Autrement, il remplit une table de structures\ :

note: type: Plain text
en: The symbols are interspersed with magic symbols of the form B<#>I<module-name> with the kernel having an empty name.  The value associated with a symbol of this form is the address at which the module is loaded.
fr: Les symboles sont dispersés avec des symboles magiques de la forme B<#>I<module-name>B<,> le noyau ayant un nom vide. La valeur associée à un symbole de cette forme est l'adresse à laquelle le module a été chargé.

note: type: Plain text
en: The symbols exported from each module follow their magic module tag and the modules are returned in the reverse of the order in which they were loaded.
fr: Les symboles exportés par chaque module suivent leur étiquette module magique et les modules sont renvoyés dans l'ordre inverse duquel ils ont été chargés.

note: type: Plain text
en: On success, returns the number of symbols copied to I<table>.  On error, -1 is returned and I<errno> is set appropriately.
fr: En cas de réussite, renvoie le nombre de symboles copiés dans I<table>. En cas d'échec, -1 est renvoyé et I<errno> est rempli en conséquence.

note: type: Plain text
en: There is only one possible error return:
fr: Il n'y a qu'une seule erreur de retour possible\ :

note: type: Plain text
en: B<get_kernel_syms>()  is not supported in this version of the kernel.
fr: B<get_kernel_syms>()  n'est pas pris en charge par cette version du noyau.

note: type: Plain text
en: B<get_kernel_syms>()  is Linux-specific.
fr: B<get_kernel_syms>()  est spécifique à Linux.

note: type: SH
en: BUGS
fr: BOGUES

note: type: Plain text
en: There is no way to indicate the size of the buffer allocated for I<table>.  If symbols have been added to the kernel since the program queried for the symbol table size, memory will be corrupted.
fr: Il n'y a pas moyen d'indiquer la taille du tampon alloué à I<table>. Si des symboles ont été ajoutés au noyau depuis que le programme s'est enquis de la taille de la table des symboles, la mémoire sera corrompue.

note: type: Plain text
en: The length of exported symbol names is limited to 59 characters.
fr: La longueur des noms de symboles exportés est limitée à 59 caractères.

note: type: Plain text
en: Because of these limitations, this system call is deprecated in favor of B<query_module>(2)  (which is itself nowadays deprecated in favor of other interfaces described on its manual page).
fr: À cause de ces limitations, cet appel système est déprécié au profit de B<query_module>(2)  (qui est lui-même aujourd'hui déprécié au profit d'autres interfaces qui sont décrites dans leurs pages de manuel).

note: type: TH
en: 2013-01-07
fr: 7 janvier 2013

note: type: Plain text
en: init_module, finit_module - load a kernel module
fr: init_module, finit_module - Charger un module de noyau

note: type: Plain text
en: I<Note>: There are no glibc wrappers for these system calls; see NOTES.
fr: I<Remarque> : il n'existe pas de fonctions glibc autour de ces appels système ; consultez B<NOTES>.

note: type: Plain text
en: B<init_module>()  loads an ELF image into kernel space, performs any necessary symbol relocations, initializes module parameters to values provided by the caller, and then runs the module's I<init> function.  This system call requires privilege.
fr: B<init_module>() charge une image ELF dans l'espace du noyau, réalise toutes les réallocations de symboles nécessaires, initialise les paramètres du module aux valeurs fournies par l'appelant et exécute ensuite la fonction I<init> du module. Cet appel système nécessite des droits.

note: type: Plain text
en: The I<module_image> argument points to a buffer containing the binary image to be loaded; I<len> specifies the size of that buffer.  The module image should be a valid ELF image, built for the running kernel.
fr: L'argument I<module_image> pointe vers un tampon contenant l'image binaire à charger ; I<len> indique la taille du tampon. L'image du module devrait être une image ELF valable, construite pour le noyau en fonctionnement.

note: type: Plain text
en: The I<param_values> argument is a string containing space-delimited specifications of the values for module parameters (defined inside the module using B<module_param>()  and B<module_param_array>()).  The kernel parses this string and initializes the specified parameters.  Each of the parameter specifications has the form:
fr: L'argument I<param_values> est une chaîne contenant une liste de valeurs, séparées par des espaces, de paramètres du module (définis dans le module en utilisant B<module_param>() et B<module_param_array>()). Le noyau analyse cette chaîne et initialise les paramètres indiqués. Toutes les spécifications de paramètres sont de la forme :

note: type: Plain text
en: I<name>[B<=>I<value>[B<,>I<value>...]]
fr: I<nom>[B<=>I<valeur>[B<,>I<valeur>...]]

note: type: Plain text
en: The parameter I<name> is one of those defined within the module using I<module_param>()  (see the Linux kernel source file I<include/linux/moduleparam.h>).  The parameter I<value> is optional in the case of I<bool> and I<invbool> parameters.  Values for array parameters are specified as a comma-separated list.
fr: Le paramètre I<nom> est un de ceux définis dans le module en utilisant I<module_param>() (consultez le fichier I<include/linux/moduleparam.h> dans les sources du noyau Linux). Le paramètre I<valeur> est facultatif pour les paramètres de type I<bool> et I<invbool>. Les valeurs des paramètres de tableau sont indiqués en liste, séparés par des virgules.

note: commit 34e1169d996ab148490c01b65b4ee371cf8ffba2 https://lwn.net/Articles/519010/ type: Plain text
en: The B<finit_module>()  system call is like B<init_module>(), but reads the module to be loaded from the file descriptor I<fd>.  It is useful when the authenticity of a kernel module can be determined from its location in the filesystem; in cases where that is possible, the overhead of using cryptographically signed modules to determine the authenticity of a module can be avoided.  The I<param_values> argument is as for B<init_module>().
fr: L'appel système B<finit_module>() est comme B<init_module>(), mais lit le module à charger à partir du descripteur de fichier I<fd>. Il est utile quand l'authenticité d'un module du noyau peut être déterminée par son emplacement sur le système de fichiers. Dans les cas où c'est possible, la complication induite par la vérification cryptographique de modules signés pour déterminer leur authenticité peut être évitée. L'argument I<param_values> est comme pour B<init_module>().

note: commit 2f3238aebedb243804f58d62d57244edec4149b2 type: Plain text
en: The I<flags> argument modifies the operation of B<finit_module>().  It is a bit mask value created by ORing together zero or more of the following flags:
fr: L'argument I<flags> modifie l'opération de B<finit_module>(). C'est un masque OU bit à bit de zéro ou plusieurs des attributs suivants.

note: type: Plain text
en: Ignore symbol version hashes.
fr: Ignorer les hachages de version de symbole.

note: type: Plain text
en: Ignore kernel version magic.
fr: Ignorer la version magique du noyau.

note: http://www.tldp.org/HOWTO/Module-HOWTO/basekerncompat.html is dated, but informative type: Plain text
en: There are some safety checks built into a module to ensure that it matches the kernel against which it is loaded.  These checks are recorded when the module is built and verified when the module is loaded.  First, the module records a "vermagic" string containing the kernel version number and prominent features (such as the CPU type).  Second, if the module was built with the B<CONFIG_MODVERSIONS> configuration option enabled, a version hash is recorded for each symbol the module uses.  This hash is based on the types of the arguments and return value for the function named by the symbol.  In this case, the kernel version number within the "vermagic" string is ignored, as the symbol version hashes are assumed to be sufficiently reliable.
fr: Certaines vérifications de sécurité sont construites dans un module pour s'assurer qu'il correspond au noyau sur lequel il est chargé. Ces vérifications sont enregistrées quand le module est construit et utilisées quand le module est chargé. D'abord, le module enregistre une chaîne « vermagic » contenant le numéro de version du noyau et les fonctionnalités principales (comme le type de microprocesseur). Ensuite, si le module a été construit avec l'option de configuration B<CONFIG_MODVERSIONS> activée, un hachage de version est enregistré pour chaque symbole que le module utilise. Ce hachage est basé sur les types de l'argument et la valeur de retour pour la fonction nommée par le symbole. Dans ce cas, le numéro de version du noyau dans la chaîne « vermagic » est ignoré, car les hachages de version de symbole sont supposés être suffisamment fiables.

note: type: Plain text
en: Using the B<MODULE_INIT_IGNORE_VERMAGIC> flag indicates that the "vermagic" string is to be ignored, and the B<MODULE_INIT_IGNORE_MODVERSIONS> flag indicates that the symbol version hashes are to be ignored.  If the kernel is built to permit forced loading (i.e., configured with B<CONFIG_MODULE_FORCE_LOAD>), then loading will continue, otherwise it will fail with B<ENOEXEC> as expected for malformed modules.
fr: L'utilisation de l'attribut B<MODULE_INIT_IGNORE_VERMAGIC> indique que la chaîne « vermagic » est à ignorer, et l'attribut B<MODULE_INIT_IGNORE_MODVERSIONS> indique que les hachages de version de symbole sont à ignorer. Si le noyau est construit pour permettre le chargement forcé (c'est-à-dire configuré avec B<CONFIG_MODULE_FORCE_LOAD>), alors le chargement continuera, sinon il échouera avec B<ENOEXEC> comme attendu pour les modules malformés.

note: type: Plain text
en: On success, these system calls return 0.  On error, -1 is returned and I<errno> is set appropriately.
fr: Ces appels système renvoient 0 en cas de succès, ou -1 en cas d'échec, auquel cas I<errno> contient le code d'erreur.

note: type: TP
en: B<EBADMSG> (since Linux 3.7)
fr: B<EBADMSG> (depuis Linux 3.7)

note: type: Plain text
en: Module signature is misformatted.
fr: La signature du module est mal formatée.

note: type: Plain text
en: Timeout while trying to resolve a symbol reference by this module.
fr: Délai dépassé en essayant de résoudre une référence de symbole par ce module.

note: type: Plain text
en: An address argument referred to a location that is outside the process's accessible address space.
fr: Un argument d'adresse faisait référence à un emplacement en dehors de l'espace d'adressage accessible du processus.

note: type: TP
en: B<ENOKEY> (since Linux 3.7)
fr: B<ENOKEY> (depuis Linux 3.7

note: commit 48ba2462ace6072741fd8d0058207d630ce93bf1 commit 1d0059f3a468825b5fc5405c636a2f6e02707ffa commit 106a4ee258d14818467829bf0e12aeae14c16cd7 type: Plain text
en: Module signature is invalid or the kernel does not have a key for this module.  This error is returned only if the kernel was configured with B<CONFIG_MODULE_SIG_FORCE>; if the kernel was not configured with this option, then an invalid or unsigned module simply taints the kernel.
fr: La signature du module est incorrecte ou le noyau n'a pas de clef pour ce module. Cette erreur n'est renvoyée que si le noyau a été configuré avec B<CONFIG_MODULE_SIG_FORCE>. Si le noyau n'a pas été configuré avec cette option, alors un module incorrect ou non signé corrompt simplement le noyau.

note: type: Plain text
en: Out of memory.
fr: Mémoire épuisée.

note: type: Plain text
en: The caller was not privileged (did not have the B<CAP_SYS_MODULE> capability), or module loading is disabled (see I</proc/sys/kernel/modules_disabled> in B<proc>(5)).
fr: L'appelant n'avait pas les droits (n'avait pas la capacité B<CAP_SYS_MODULE>), ou le chargement de module est désactivé (consultez I</proc/sys/kernel/modules_disabled> dans B<proc>(5)).

note: type: Plain text
en: The following errors may additionally occur for B<init_module>():
fr: Les erreurs supplémentaires suivantes peuvent survenir pour B<init_module>().

note: type: Plain text
en: A module with this name is already loaded.
fr: Un module de ce nom est déjà chargé.

note: .TP .BR EINVAL " (Linux 2.4 and earlier)" Some .I image slot is filled in incorrectly, .I image\->name does not correspond to the original module name, some .I image\->deps entry does not correspond to a loaded module, or some other similar inconsistency. type: Plain text
en: I<param_values> is invalid, or some part of the ELF image in I<module_image> contains inconsistencies.
fr: I<param_values> est incorrect, ou certaines parties de l'image ELF de I<module_image> contient des incohérences.

note: type: Plain text
en: The binary image supplied in I<module_image> is not an ELF image, or is an ELF image that is invalid or for a different architecture.
fr: L'image binaire fournie dans I<module_image> n'est pas une image ELF, ou est une image ELF incorrecte ou pour une autre architecture.

note: type: Plain text
en: The following errors may additionally occur for B<finit_module>():
fr: Les erreurs supplémentaires suivantes peuvent survenir pour B<finit_module>().

note: type: Plain text
en: The file referred to by I<fd> is not opened for reading.
fr: Le fichier indiqué par I<fd> n'est pas ouvert en lecture.

note: type: Plain text
en: The file referred to by I<fd> is too large.
fr: Le fichier indiqué par I<fd> est trop gros.

note: type: Plain text
en: I<flags> is invalid.
fr: I<flags> n'est pas correct.

note: type: Plain text
en: I<fd> does not refer to an open file.
fr: I<fd> ne fait pas référence à un fichier ouvert.

note: type: Plain text
en: In addition to the above errors, if the module's I<init> function is executed and returns an error, then B<init_module>()  or B<finit_module>()  fails and I<errno> is set to the value returned by the I<init> function.
fr: En plus des erreurs précédentes, si la fonction I<init> du module est exécutée et renvoie une erreur, alors B<init_module>() ou B<finit_module>() échoue et I<errno> est définie à la valeur renvoyée par la fonction I<init>.

note: type: Plain text
en: B<finit_module>()  is available since Linux 3.8.
fr: B<finit_module>() est disponible depuis Linux 3.8.

note: type: Plain text
en: B<init_module>()  and B<finit_module>()  are Linux-specific.
fr: B<init_module>() et B<finit_module>() sont spécifiques à Linux.

note: type: Plain text
en: Glibc does not provide a wrapper for these system calls; call them using B<syscall>(2).
fr: La glibc ne fournit pas de fonction autour de ces appels système ; utilisez B<syscall>(2) pour les appeler.

note: type: Plain text
en: Information about currently loaded modules can be found in I</proc/modules> and in the file trees under the per-module subdirectories under I</sys/module>.
fr: Des renseignements concernant les modules chargés sont disponibles dans I</proc/modules> et dans les arborescences de fichiers des sous-répertoires par module sous I</sys/module>.

note: type: Plain text
en: See the Linux kernel source file I<include/linux/module.h> for some useful background information.
fr: Consultez le fichier I<include/linux/module.h> dans les sources du noyau Linux pour obtenir des renseignements de fond utiles.

note: type: Plain text
en: In Linux 2.4 and earlier, the B<init_module>()  system call was rather different:
fr: Dans Linux 2.4 et antérieurs, l'appel système B<init_module>() était assez différent :

note: type: Plain text
en: (User-space applications can detect which version of B<init_module>()  is available by calling B<query_module>(); the latter call fails with the error B<ENOSYS> on Linux 2.6 and later.)
fr: (les applications en espace utilisateur peuvent détecter la versions de B<init_module>() disponible en appelant B<query_module>() ; ce dernier appel échoue avec l'erreur B<ENOSYS> à partir de Linux 2.6)

note: type: Plain text
en: The older version of the system call loads the relocated module image pointed to by I<image> into kernel space and runs the module's I<init> function.  The caller is responsible for providing the relocated image (since Linux 2.6, the B<init_module>()  system call does the relocation).
fr: L'ancienne version de l'appel système charge l'image de module réallouée pointée par I<image> dans l'espace du noyau et exécute la fonction I<init> du module. L'appelant doit fournir l'image réallouée (depuis Linux 2.6, l'appel système B<init_module>() s'occupe de la réallocation).

note: type: Plain text
en: The module image begins with a module structure and is followed by code and data as appropriate.  Since Linux 2.2, the module structure is defined as follows:
fr: L'image du module commence avec une structure module suivie par du code et des données appropriés. Depuis Linux 2.2, la structure module est définie comme suit\ :

note: type: Plain text
en: All of the pointer fields, with the exception of I<next> and I<refs>, are expected to point within the module body and be initialized as appropriate for kernel space, that is, relocated with the rest of the module.
fr: On s'attend à ce que tous les champs pointeurs, à l'exception de I<next> et I<refs>, pointent vers l'intérieur du corps du module et qu'ils puissent être initialisés de manière appropriée pour l'espace noyau, c'est-à-dire relogés avec le reste du module.

note: type: TH
en: 2013-01-27
fr: 27 janvier 2013

note: type: Plain text
en: query_module - query the kernel for various bits pertaining to modules
fr: query_module - Interroger le noyau sur diverses choses relatives aux modules

note: type: Plain text
en: B<query_module>()  requests information from the kernel about loadable modules.  The returned information is placed in the buffer pointed to by I<buf>.  The caller must specify the size of I<buf> in I<bufsize>.  The precise nature and format of the returned information depend on the operation specified by I<which>.  Some operations require I<name> to identify a currently loaded module, some allow I<name> to be NULL, indicating the kernel proper.
fr: B<query_module>()  demande au noyau des informations sur les modules chargeables. L'information renvoyée est placée dans un tampon pointé par I<buf>. L'appelant doit indiquer la taille de I<buf> dans I<bufsize>. La nature précise et le format de l'information retournée dépendent de l'opération qui a été spécifiée dans I<which>. Certaines opérations nécessitent un I<name> pour identifier un module actuellement chargé, d'autres permettent que I<name> soit NULL, indiquant le noyau.

note: type: Plain text
en: The following values can be specified for I<which>:
fr: I<which> peut prendre les valeurs suivantes\ :

note: type: Plain text
en: Returns success, if the kernel supports B<query_module>().  Used to probe for availability of the system call.
fr: Retourner avec succès si le noyau prend en charge B<query_module>(). Utilisé pour tester la disponibilité de l'appel système.

note: ret is set on ENOSPC type: Plain text
en: Returns the names of all loaded modules.  The returned buffer consists of a sequence of null-terminated strings; I<ret> is set to the number of modules.
fr: Renvoyer les noms de tous les modules chargés. Le tampon renvoyé consiste en une séquence de chaînes de caractères terminées par un octet nul\ ; I<ret> prend la valeur du nombre de modules.

note: ret is set on ENOSPC type: Plain text
en: Returns the names of all modules used by the indicated module.  The returned buffer consists of a sequence of null-terminated strings; I<ret> is set to the number of modules.
fr: Renvoyer le nom de tous les modules utilisés par le module indiqué. Le tampon renvoyé consiste en une séquence de chaînes de caractères terminées par un octet nul\ ; I<ret> prend la valeur du nombre de modules.

note: ret is set on ENOSPC type: Plain text
en: Returns the names of all modules using the indicated module.  This is the inverse of B<QM_DEPS>.  The returned buffer consists of a sequence of null-terminated strings; I<ret> is set to the number of modules.
fr: Renvoyer le nom de tous les modules utilisant le module indiqué. C'est l'inverse de B<QM_DEPS>. Le tampon renvoyé consiste en une séquence de chaînes de caractères terminées par un octet nul\ ; I<ret> prend la valeur du nombre de modules.

note: ret is set on ENOSPC type: Plain text
en: Returns the symbols and values exported by the kernel or the indicated module.  The returned buffer is an array of structures of the following form
fr: Renvoyer les symboles et valeurs exportés par le noyau ou le module indiqué. Le tampon renvoyé est un tableau de structures de la forme suivante\ :

note: type: Plain text
en: followed by null-terminated strings.  The value of I<name> is the character offset of the string relative to the start of I<buf>; I<ret> is set to the number of symbols.
fr: suivi par des chaînes de caractères terminées par un octet nul. La valeur de I<name> est le décalage en caractère de la chaîne relativement au début de I<buf>\ ; I<ret> prend la valeur du nombre de modules.

note: type: Plain text
en: Returns miscellaneous information about the indicated module.  The output buffer format is:
fr: Renvoyer diverses informations sur le module indiqué. Le format du tampon de sortie est de la forme\ :

note: type: Plain text
en: where I<address> is the kernel address at which the module resides, I<size> is the size of the module in bytes, and I<flags> is a mask of B<MOD_RUNNING>, B<MOD_AUTOCLEAN>, and so on, that indicates the current status of the module (see the Linux kernel source file I<include/linux/module.h>).  I<ret> is set to the size of the I<module_info> structure.
fr: où I<address> est l'adresse noyau où se trouve le module, I<size> est la taille en octets du module et I<flags> un masque de B<MOD_RUNNING>, B<MOD_AUTOCLEAN>, etc., qui indique l'état actuel du module (consultez le fichier I<include/linux/module.h> dans les sources du noyau Linux). I<ret> prend la valeur de la taille de la structure I<module_info>.

note: type: Plain text
en: At least one of I<name>, I<buf>, or I<ret> was outside the program's accessible address space.
fr: Au moins une adresse parmi I<name>, I<buf> ou I<ret> est en dehors de l'espace d'adressage accessible du programme.

note: Not permitted with QM_DEPS, QM_REFS, or QM_INFO. type: Plain text
en: Invalid I<which>; or I<name> is NULL (indicating "the kernel"), but this is not permitted with the specified value of I<which>.
fr: I<which> est invalide ou I<name> est NULL (indiquant le noyau) mais ce n'est pas permis avec la valeur de I<which>.

note: type: Plain text
en: No module by that I<name> exists.
fr: Aucun module du nom I<name> n'existe.

note: type: Plain text
en: The buffer size provided was too small.  I<ret> is set to the minimum size needed.
fr: La taille du tampon fournie est trop petite\ ; I<ret> prend la valeur de la taille minimum nécessaire.

note: type: Plain text
en: B<query_module>()  is not supported in this version of the kernel (e.g., the kernel is version 2.6 or later).
fr: B<query_module>() n'est pas pris en charge par cette version du noyau (par exemple un noyau en version 2.6 ou au-delà).

note: type: Plain text
en: B<query_module>()  is Linux-specific.
fr: B<query_module>()  est spécifique à Linux.

note: type: Plain text
en: Some of the information that was formerly available via B<query_module>()  can be obtained from I</proc/modules>, I</proc/kallsyms>, and the files under the directory I</sys/module>.
fr: Certaines renseignements, qui étaient auparavant disponibles avec B<query_module>(), peuvent être obtenues dans I</proc/modules>, I</proc/kallsyms> et les fichiers du répertoire I</sys/modules>.

note: type: Plain text
en: Glibc does not provide a wrapper for this system call; in the unlikely event that you need to use it on an old kernel, use B<syscall>(2).
fr: La glibc ne fournit pas de fonction autour de cet appel système ; dans l'éventualité où vous devriez quand même l'utiliser sur un ancien noyau, utilisez B<syscall>(2).
