# Traduit par Olivier GUERRIER pour kernelFR [ http://www.traduc.org/kernelfr/ ] config USERMODE bool default y # XXX: does UM have a mmu/swap? config MMU bool default y #en: mainmenu "Linux/Usermode Kernel Configuration" mainmenu "Configuration du noyau pour Linux/Usermode" config ISA bool config SBUS bool config PCI bool config UID16 bool default y config RWSEM_GENERIC_SPINLOCK bool default y #en: menu "UML-specific options" menu "Options spécifiques UML" config MODE_TT #en: bool "Tracing thread support" bool "Support du mode TT (suivi de tâches)" default y #en: help #en: This option controls whether tracing thread support is compiled #en: into UML. Normally, this should be set to Y. If you intend to #en: use only skas mode (and the host has the skas patch applied to it), #en: then it is OK to say N here. help Cette option active le mode de suivi de tâches (TT/tracing thread) dans UML. La réponse usuelle est Y. Si vous avez l'intention de n'utiliser que le mode SKAS (et que le patch SKAS a bien été appliqué au noyau du système hôte), alors il est acceptable de répondre N. config STATIC_LINK #en: bool "Force a static link" bool "Forcer une compilation statique" default n depends on !MODE_TT #en: help #en: If CONFIG_MODE_TT is disabled, then this option gives you the ability #en: to force a static link of UML. Normally, if only skas mode is built #en: in to UML, it will be linked as a shared binary. This is inconvenient #en: for use in a chroot jail. So, if you intend to run UML inside a #en: chroot, and you disable CONFIG_MODE_TT, you probably want to say Y #en: here. help Si CONFIG_MODE_TT est désactivé, cette option vous donne la possibilité de compiler UML en liant les librairies de façon statiques. Si seul le mode SKAS est inclus dans le noyau UML, les librairies sont partagées par défaut, ce qui n'est pas pratique pour une utilisation dans un chroot. Si vous prévoyez d'utiliser UML dans un chroot, et que vous avez désactivé CONFIG_MODE_TT, alors vous répondrez probablement Y ici. config MODE_SKAS #en: bool "Separate Kernel Address Space support" bool "Support du mode SKAS (Espace Mémoire Noyau Séparé)" default y #en: help #en: This option controls whether skas (separate kernel address space) #en: support is compiled in. If you have applied the skas patch to the #en: host, then you certainly want to say Y here (and consider saying N #en: to CONFIG_MODE_TT). Otherwise, it is safe to say Y. Disabling this #ndt: --------------------------------------------------^-------------------- #ndt: il y a vraisemblablement une erreur dans la version anglaise ici. #ndt: ----------------------------------------------------------------------- #en: option will shrink the UML binary slightly. help Cette option active le mode d'espace mémoire noyau séparé (SKAS/separate kernel adress space). Si vous avez appliqué la rustine SKAS au noyau su système hôte, vous voudrez certainement dire Y ici (et peut-être dire N à CONFIG_MODE_TT. Autrement vous pouvez dire N. Désactiver cette option reduira sensiblement la taille de l'exécutable. config NET #en: bool "Networking support" bool "Support du réseau" source "fs/Kconfig.binfmt" config HOSTFS #en: tristate "Host filesystem" tristate "Système de fichiers de l'hôte" #en: help #en: While the User-Mode Linux port uses its own root file system for #en: booting and normal file access, this module lets the UML user #en: access files stored on the host. It does not require any #en: network connection between the Host and UML. An example use of #en: this might be: #en: #en: mount none /tmp/fromhost -t hostfs -o /tmp/umlshare #en: #en: where /tmp/fromhost is an empty directory inside UML and #en: /tmp/umlshare is a directory on the host with files the UML user #en: wishes to access. #en: #en: For more information, see #en: . #en: #en: If you'd like to be able to work with files stored on the host, #en: say Y or M here; otherwise say N. help Tandis que la machine UML utilise son propre système de fichiers pour le démarrage et pour ses accès fichiers classiques, ce module autorise l'utilisateur de la machine UML à accéder au système de fichiers de l'hôte. Il n'y a pas besoin d'une connexion réseau entre la machine UML et l'hôte. Un exemple d'utilisation pourrait être: mount none /tmp/acces_hote -t hostfs -o /tmp/partage_uml où /tmp/acces_hote est un dossier vide dans la machine UML, et /tmp/partage_uml un dossier dans la machine hôte qui contient les fichiers auxquels l'utilisateur de la machine UML souhaite accèder. Pour plus d'informations, visitez . Si vous souhaitez pouvoir accèder à des fichiers stockés sur le système hôte, sélectionnez Y; sinon sélectionnez N. config MCONSOLE #en: bool "Management console" bool "Console de gestion" #en: help #en: The user mode linux management console is a low-level interface to #en: the kernel, somewhat like the i386 SysRq interface. Since there is #en: a full-blown operating system running under every user mode linux #en: instance, there is much greater flexibility possible than with the #en: SysRq mechanism. #en: #en: If you answer 'Y' to this option, to use this feature, you need the #en: mconsole client (called uml_mconsole) which is present in CVS in #en: 2.4.5-9um and later (path /tools/mconsole), and is also in the #en: distribution RPM package in 2.4.6 and later. #en: #en: It is safe to say 'Y' here. help La console de gestion UML est une interface de bas niveau vers le noyau, un peu comme l'interface i386 SysRq. Mais comme il y a un vrai système d'exploitation derrière chaque instance UML, la flexibilité est plus grande que celle proposée par le mécanisme SysRq. Si vous répondez Y à cette option, vous aurez besoin du client mconsole (appelé uml_mconsole) pour pouvoir l'exploiter. Ce client est disponible dans le CVS à partir de 2.4.5-9um (dossier /tools/mconsole). Il se trouve aussi dans les paquets RPM à partir de 2.4.6. Il n'y a aucun risque à sélectionner Y. config MAGIC_SYSRQ #en: bool "Magic SysRq key" bool "Touche SysRq magique" depends on MCONSOLE config HOST_2G_2G #en: bool "2G/2G host address space split" bool "Séparation de l'espace mémoire de l'hôte en 2G/2G" config UML_SMP #en: bool "Symmetric multi-processing support" bool "Support du mode multiprocesseur (SMP)" #en: help #en: This option enables UML SMP support. UML implements virtual SMP by #en: allowing as many processes to run simultaneously on the host as #en: there are virtual processors configured. Obviously, if the host is #en: a uniprocessor, those processes will timeshare, but, inside UML, #en: will appear to be running simultaneously. If the host is a #en: multiprocessor, then UML processes may run simultaneously, depending #en: on the host scheduler. #en: CONFIG_SMP will be set to whatever this option is set to. #en: It is safe to leave this unchanged. help Cette option active le support du mode multiprocesseur SMP pour les machines UML. La virtualisation du SMP est obtenu par la machine UML en demandant à l'hôte d'exécuter simultanément autant de tâches qu'il y a de processeurs déclarés. Evidemment, si la machine hôte est monoprocesseur ces tâches vont partager le temps CPU, mais à l'intérieur de la machine UML elles auront une simultanéïté apparente. Si l'hôte est multiprocesseur il est possible que les tâches de la machine UML s'exécutent simultanément, en fonction des choix de l'ordonnanceur de la machine hôte. CONFIG_SMP sera modifié en fonction du choix fait ici. Il est conseillé de ne pas modifier cette option. config SMP bool default UML_SMP config nR_CPUS #en: int "Maximum number of CPUs (2-32)" int "Nombre maximum de processeurs (2-32)" depends on SMP default "32" config NEST_LEVEL #en: int "Nesting level" int "Niveau d'imbrication" default "0" #en: help #en: This is set to the number of layers of UMLs that this UML will be run #en: in. Normally, this is zero, meaning that it will run directly on the #en: host. Setting it to one will build a UML that can run inside a UML #en: that is running on the host. Generally, if you intend this UML to run #en: inside another UML, set CONFIG_NEST_LEVEL to one more than the host #en: UML. #en: #en: Note that if the hosting UML has its CONFIG_KERNEL_HALF_GIGS set to #en: greater than one, then the guest UML should have its CONFIG_NEST_LEVEL #en: set to the host's CONFIG_NEST_LEVEL + CONFIG_KERNEL_HALF_GIGS. #en: Only change this if you are running nested UMLs. help Ceci est le niveau d'imbrication de machines UML dans lequel ce noyau va être exécuté. Normalement, ce niveau est zéro, ce qui signifie que la machine UML sera exécutée directement par le système hôte. Si vous souhaitez que cette machine UML puisse être exécutée à l'intérieur d'une autre machine UML, il faut que la valeur de CONFIG_NEST_LEVEL soit incrémenté de 1 par rapport à la valeur du CONFIG_NEST_LEVEL défini dans la machine UML hôte. Notez que si la machine UML hôte a le paramètre CONFIG_KERNEL_HALF_GIGS positionné sur une valeur supérieure à un, alors la machine UML invitée doit avoir son paramètre CONFIG_NEST_LEVEL égal à la somme des valeurs de l'hôte CONFIG_NEST_LEVEL + CONFIG_KERNEL_HALF_GIGS. Ne modifiez ce paramètre que si vous utilisez des machines UML imbriquées. config KERNEL_HALF_GIGS #en: int "Kernel address space size (in .5G units)" int "Espace d'adressage du noyau (en unités de .5G)" default "1" #en: help #en: This determines the amount of address space that UML will allocate for #en: its own, measured in half Gigabyte units. The default is 1. #en: Change this only if you need to boot UML with an unusually large amount #en: of physical memory. help Ceci détermine la taille de l'espace d'adressage que la machine UML va allouer pour ses besoins internes, par unité de 0.5 Gigaoctets. La valeur par défaut est 1. Ne modifier ceci que si vous avez besoin de démarrer la machine UML avec une mémoire physique exceptionnellement grande. config HIGHMEM #en: bool "Highmem support" bool "Support de la mémoire haute" config KERNEL_STACK_ORDER #en: int "Kernel stack size order" int "Ordre de grandeur de la pile d'exécution du noyau" default 2 #en: help #en: this option determines the size of UML kernel stacks. They will #en: be 1 << order pages. The default is OK unless you're running Valgrind #en: on UML, in which case, set this to 3. help Cette option détermine la taille de la pile d'exécution du noyau UML. La taille sera de ( 1 << ordre_de_grandeur ) pages. La valeur par défaut est correcte, sauf si vous utilisez Valgrind à l'intérieur des machines UML. Dans ce cas fixez l'ordre de grandeur à 3. endmenu source "init/Kconfig" source "drivers/base/Kconfig" source "arch/um/Kconfig_char" source "arch/um/Kconfig_block" config NETDEVICES bool default NET source "arch/um/Kconfig_net" source "net/Kconfig" source "fs/Kconfig" source "security/Kconfig" source "crypto/Kconfig" source "lib/Kconfig" #en: menu "SCSI support" menu "Support SCSI" config SCSI #en: tristate "SCSI support" tristate "Support SCSI" # This gives us free_dma, which scsi.c wants. config GENERIC_ISA_DMA bool depends on SCSI default y source "arch/um/Kconfig_scsi" endmenu source "drivers/md/Kconfig" source "drivers/mtd/Kconfig" #en: menu "Kernel hacking" menu "Options avancées du noyau" config DEBUG_SLAB #en: bool "Debug memory allocations" bool "Débugguer les allocations mémoires" config DEBUG_SPINLOCK #en: bool "Debug spinlocks usage" bool "Débugguer les exclusions mutuelles (spinlocks)" config DEBUG_INFO #en: bool "Enable kernel debugging symbols" bool "Activer les informations de débuggage" #en: help #en: When this is enabled, the User-Mode Linux binary will include #en: debugging symbols. This enlarges the binary by a few megabytes, #en: but aids in tracking down kernel problems in UML. It is required #en: if you intend to do any kernel development. #en: #en: If you're truly short on disk space or don't expect to report any #en: bugs back to the UML developers, say N, otherwise say Y. help Si cette option est activée, l'exécutable UML contiendra les informations de débuggage. Cela alourdit la taille du fichier de quelques mégaoctets, mais aide à résoudre les problèmes de noyau dans la machine UML. Cette option est indispensable si vous avez l'intention de faire du dévellopement au niveau du noyau. config FRAME_POINTER bool default y if DEBUG_INFO config PT_PROXY #en: bool "Enable ptrace proxy" bool "Activer le proxy ptrace" depends on XTERM_CHAN && DEBUG_INFO config GPROF #en: bool "Enable gprof support" bool "Activer le support gprof" depends on DEBUG_INFO #en: help #en: This allows profiling of a User-Mode Linux kernel with the gprof #en: utility. #en: #en: See for more #en: details. #en: #en: If you're involved in UML kernel development and want to use gprof, #en: say Y. If you're unsure, say N. help Cette option permet de récupérer dans l'utilitaire gprof les informations relatives à l'audit du noyau UML. Consultez pour plus de détails. Si vous êtes impliqué dans le dévelopement du noyau UML et que vous souhaitez utiliser gprof, selectionnez Y. Si vous avez un doute sélectionnez N. config GCOV #en: bool "Enable gcov support" bool "Activer le support gcov" depends on DEBUG_INFO #en: help #en: This option allows developers to retrieve coverage data from a UML #en: session. #en: #en: See for more #en: details. #en: #en: If you're involved in UML kernel development and want to use gcov, #en: say Y. If you're unsure, say N. help Cette option permet de récupérer dans l'utilitaire gcov les données en provenance d'une session UML. Consultez pour plus de détails. Si vous êtes impliqué dans le dévelopement du noyau UML et que vous souhaitez utiliser gcov, selectionnez Y. Si vous avez un doute sélectionnez N. endmenu