# LKN Chapitre 9. Recettes de configuration du noyau

{{INLINETOC}}

_*Source: [[https://www.linuxtopia.org/online_books/linux_kernel/kernel_configuration/ch09.html|Linux Kernel in a Nutshell: 9 Kernel Configuration Recipes]]*_

Le chapitre 8 a enseigné la mécanique de la personalisation du noyau; ce chapitre présente tous les types de changements les plus courants que l'on doit apporter au noyau, avec des instructions spécifiques sur la façon de le faire.

# Disques

Le noyau Linux prend en charge un large éventail de types de disques différents. Cette section montre comment configurer le noyau pour qu'il prenne en charge la plupart des types de contrôleurs de disque les plus courants.

## stockage USB

Pour utiliser un périphérique de stockage USB (communément appelé périphérique "flash" USB ou lecteur de disque USB externe), le support USB doit d'abord fonctionner correctement. 

Un périphérique de stockage USB peut être identifié à l'aide du programme **lsusb**. Si la séquence de commandes suivante produit les résultats affichés, un périphérique de stockage USB est présent sur le système:

```
/usr/sbin/lsusb -v | grep Storage

      bInterfaceClass         8 Mass Storage
```

Activer comme suit.

  * Un périphérique de stockage USB est en réalité un périphérique USB SCSI qui communique via une connexion USB. Pour cette raison, le sous-système SCSI doit être activé:

```
Device Drivers
    SCSI Device Support
        [*] SCSI Device Support
```

  * Toujours dans le système SCSI, le "support de disque SCSI" doit être activé pour que le périphérique soit correctement monté:

```
Device Drivers
	SCSI Device Support
		[*] SCSI disk support
```

  * Activer la prise en charge du stockage USB:

```
Device Drivers
	USB Support
	[M] USB Mass Storage support
```

Un certain nombre de périphériques de stockage USB spécifiques sont répertoriés en tant qu'éléments de configuration distincts, car ils ne respectent pas les spécifications USB standard et nécessitent un code spécial. Pour utiliser l'un de ces appareils, il faut en activer la prise en charge.

## Disques IDE

Les disques IDE sont le type le plus courant de disques PC. Le périphérique qui leur permet de fonctionner correctement est un contrôleur de disque IDE. Pour déterminer si l'on dispose d'un contrôleur de disque IDE sur le système, utiliser la commande **lspci** de la manière suivante: (( Presque toutes les distributions placent le programme lspci dans le répertoire /usr/sbin /, mais certaines le placent dans d'autres emplacements. Pour savoir où il se trouve, utiliser: which lspci))

```
/usr/sbin/lspci | grep IDE

00:1f.1 IDE interface: Intel Corporation 82801EB/ER (ICH5/ICH5R) IDE Controller (rev 02)
00:1f.2 IDE interface: Intel Corporation 82801EB (ICH5) SATA Controller (rev 02)
```

<WRAP info>la réponse à cette commande ne sera probablement pas identique; ce qui est important, c'est que la commande affiche un contrôleur IDE (le premier périphérique dans l'exemple précédent.) Si on ne trouve que des contrôleurs SATA, se reporter à la section intitulée «Serial ATA (SATA)».</WRAP>

Activer la prise en charge PCI pour le noyau:

```
Bus options (PCI, PCMCIA, EISA, MCA, ISA)
    [*] PCI Support
```

Activer le sous-système IDE et la prise en charge IDE:

```
Device Drivers
    [*] ATA/ATAPI/MFM/RLL support
    [*]   Enhanced IDE/MFM/RLL disk/cdrom/tape/floppy support
```

Dans le système ATA, le type spécifique de contrôleur IDE doit être activé pour qu'il fonctionne correctement. Pour fournir une bonne sauvegarde au cas où on choisirait le mauvais type, sélectionner le contrôleur IDE "générique":

```
Pilotes de périphérique
    Prise en charge ATA/ATAPI/MFM/RLL
        [*] prise en charge du chipset IDE générique/par défaut
```

Activer les différents contrôleurs PCI IDE:

```
Pilotes de périphérique
    Prise en charge ATA/ATAPI/MFM/RLL
        [*] Prise en charge du chipset PCI IDE
```

Cela ouvre un long sous-menu des différents types de contrôleurs IDE. Sélectionner le bon en fonction du nom du périphérique trouvé à l'étape **lspci**.

## Serial ATA (SATA)

SATA est un type de contrôleur de disque qui succède au contrôleur de disque IDE. Pour déterminer si on dispose d'un contrôleur de disque SATA sur le système, exécuter la commande suivante:

```
/usr/sbin/lspci | grep SATA

00:1f.2 IDE interface: Intel Corporation 82801EB (ICH5) SATA Controller (rev 02)
```

<WRAP info>La réponse à cette sommande ne sera probablement pas identique; ce qui est important, c'est que la commande affiche certains périphériques SATA.</WRAP>

Les disques SATA utilisent une bibliothèque de noyau appelée **libata** qui gère la plupart des fonctionnalités spécifiques à SATA. Cette bibliothèque utilise la couche SCSI pour communiquer avec la couche bloc, de sorte que de nombreuses options de noyau différentes doivent être activées pour que les disques SATA fonctionnent correctement. Activer la prise en charge PCI pour le noyau:

```
Bus options (PCI, PCMCIA, EISA, MCA, ISA)
	[*] PCI Support
```

Activer le sous-système SCSI:

```
Device Drivers
	SCSI Device Support
		[*] SCSI Device Support
```

Toujours dans le système SCSI, l'option "Prise en charge des disques SCSI" doit être activée pour que le périphérique soit correctement monté:

```
Device Drivers
	SCSI Device Support
		[*] SCSI disk support
```

Les options SATA se trouvent dans la section "Pilotes de bas niveau SCSI":

```
Device Drivers
	SCSI Device Support
		SCSI low-level drivers
			[*] Serial ATA (SATA) support
```

Dans cette section, activer le type de contrôleur SATA spécifique. Regarder la sortie de la commande **lspci** mentionnée précédemment pour une liste des types de contrôleurs SATA présents sur le système. Par exemple, la plupart des cartes mères d'Intel nécessitent le pilote PIIX/ICH SATA (comme le montre l'exemple précédent).

```
Device Drivers
	SCSI Device Support
		SCSI low-level drivers
			[*] Serial ATA (SATA) support
			[*]   Intel PIIX/ICH SATA support
```

## Graveur de CD-ROM

Graver un CD-ROM est très simple sous Linux. Si le noyau peut support lecture à partir d'un CD-ROM, il peut également prendre en charge la gravure d'un CD-ROM. Il existe deux façons d'activer la prise en charge des CD-ROM sous Linux, une pour les lecteurs IDE et une pour les lecteurs SCSI et SATA.

### Lecteurs de CD-ROM IDE

Les lecteurs de CD-ROM IDE sont contrôlés par le même contrôleur IDE que les lecteurs de disque IDE principaux. Il faut s'assurer que le contrôleur IDE est correctement pris en charge comme décrit dans la section intitulée «Disques IDE». S'il est correctement pris en charge, alors un seul autre élément de configuration doit être sélectionné:

```
Device Drivers
    [*] ATA/ATAPI/MFM/RLL support
    [*]   Enhanced IDE/MFM/RLL disk/cdrom/tape/floppy support
    [M]     Include IDE/ATAPI CDROM support
```

### Lecteurs de CD-ROM SCSI et SATA

Les lecteurs de CD-ROM SATA et SCSI sont contrôlés par le même contrôleur que les lecteurs de disque principaux. Il faut s'assurer que le contrôleur SATA ou SCSI est correctement pris en charge comme décrit dans la section intitulée «Serial ATA (SATA)».

Pour prendre en charge les lecteurs de CD-ROM SATA ou SCSI, le pilote de CD-ROM SCSI doit être activé:

```
Device Drivers
	SCSI Device Support
		[*] SCSI CDROM suppor
```

Une fois cette option activée, le lecteur de CD-ROM SATA ou SCSI devrait fonctionner correctement.

# Devices

Linux prend en charge une vaste gamme de différents types de périphériques (plus que tout autre système d'exploitation n'a jamais eu). Cette section montre comment activer certains des types les plus courants.

## USB

Linux prend en charge différents types de périphériques USB. Pour activer la prise en charge USB, il faut d'abord activer la prise en charge d'un contrôleur USB, qui pilote la connexion USB sur la machine.

Pour déterminer si l'appareil possède un contrôleur USB et de quel type il s'agit, exécuter la commande suivante:

```

/usr/sbin/lspci | grep USB

00:1d.0 USB Controller: Intel Corporation 82801EB/ER (ICH5/ICH5R) USB UHCI Controller #1 (rev 02)
00:1d.1 USB Controller: Intel Corporation 82801EB/ER (ICH5/ICH5R) USB UHCI Controller #2 (rev 02)
00:1d.2 USB Controller: Intel Corporation 82801EB/ER (ICH5/ICH5R) USB UHCI Controller #3 (rev 02)
00:1d.3 USB Controller: Intel Corporation 82801EB/ER (ICH5/ICH5R) USB UHCI Controller #4 (rev 02)
00:1d.7 USB Controller: Intel Corporation 82801EB/ER (ICH5/ICH5R) USB2 EHCI Controller (rev 02)
```

<WRAP info>la réponse à cette commande ne sera probablement pas identique; ce qui est important, c'est que la commande affiche certains contrôleurs USB.</WRAP>

Activer la prise en charge PCI pour le noyau:

```
Bus options (PCI, PCMCIA, EISA, MCA, ISA)
	[*] PCI Support
```

Activer la prise en charge USB pour le noyau:

```
Device Drivers
	USB Support
		[M] Support for Host-side USB
```

Activer les contrôleurs hôtes USB spécifiques pour la machine (il est plus sûr de tous les activer lorsqu'on ne connait pas lesquels on a):

```
Device Drivers
	USB Support
	---   USB Host Controller Drivers
	[M]   EHCI HCD (USB 2.0) support
	[M]   OHCI HCD support
	[M]   UHCI HCD (most Intel and VIA) support
```

Les périphériques USB individuels ont également besoin que leurs pilotes soient activés. Une grande majorité d'entre eux se trouvent sous la section principale du pilote USB:

```
Device Drivers
	USB Support
```

Mais certains appareils, tels que la vidéo USB et le DVB et le son, sont répertoriés dans d'autres sections contrôlant ces types d'appareils. Par exemple, le pilote audio USB se trouve dans le menu Son:

```
Device drivers
	Sound
		[*] Sound card support
			[*] Advanced Linux Sound Architecture
				USB Devices
					[M] USB Audio/MIDI driver
```

Pour activer la prise en charge de périphériques de stockage USB (flash USB), regardez maintenant la section intitulée «Stockage USB».

## IEEE 1394 (FireWire)

IEEE 1394 est communément connu sous le nom de FireWire, le nom par lequel Apple Computer l'a annoncé. IEEE 1394 est un bus haute vitesse qui connecte des périphériques externes, tout comme le fait l'USB.

Pour déterminer sil'ordinateur possède un contrôleur FireWire et de quel type il s'agit, exécuter la commande suivante:

```
/usr/sbin/lspci | grep FireWire

06:0c.0 FireWire (IEEE 1394): Texas Instruments TSB43AB22/A IEEE-1394a-2000 Controller (PHY/Link)
06:0d.2 FireWire (IEEE 1394): Creative Labs SB Audigy FireWire Port (rev 04)
```

<WRAP info>la réponse à cette commande ne sera probablement pas identique; ce qui est important, c'est que la commande affiche certains contrôleurs FireWire.</WRAP>

Activer la prise en charge PCI pour le noyau:

```
Bus options (PCI, PCMCIA, EISA, MCA, ISA)
	[*] PCI Support
```

Activer la prise en charge IEEE 1394 pour le noyau:

```
Device Drivers
	IEEE 1394 (FireWire) support
		[*] IEEE 1394 (FireWire) support
```

Activer le type spécifique de contrôleur hôte Firewire dont vous disposez:

```
Device Drivers
	IEEE 1394 (FireWire) support
		[*] IEEE 1394 (FireWire) support
		---   Device Drivers
		[M]   Texas Instruments PCILynx support
		[M]   OHCI-1394 support
```

Enfin, activer le type spécifique de périphériques Firewire:

```
Device Drivers
	IEEE 1394 (FireWire) support
		[*] IEEE 1394 (FireWire) support
		---   Protocol Drivers
		[M]   OHCI-1394 Video support
		[M]   SBP-2 support (Harddisks etc.)
		[ ]     Enable Phys DMA support for SBP2 (Debug)
		[M]   Ethernet over 1394
		[M]   OHCI-DV I/O support
		[M]   Raw IEEE1394 I/O support
```

## PCI hotplug

Les systèmes de connexion à chaud PCI deviennent de plus en plus populaires avec l'utilisation de la carte **ExpressCard** et des stations d'accueil pour ordinateur portable.

Pour déterminer si l'appareil possède un contrôleur **ExpressCard**, examiner le matériel pour voir si une carte **ExpressCard** peut y être branchée.

Activer la prise en charge PCI pour le noyau:

```
Bus options (PCI, PCMCIA, EISA, MCA, ISA)
	[*] PCI Support
```

Activer la prise en charge PCI Hotplug pour le noyau:

```
Bus options (PCI, PCMCIA, EISA, MCA, ISA)
	[*] PCI Support
	PCI Hotplug Support
		[M] Support for PCI Hotplug (EXPERIMENTAL)
```

Il existe une large gamme de différents types de contrôleurs PCI Hotplug. Pour la plupart des ordinateurs portables et pour la prise en charge ExpressCard, activer le contrôleur ACPI:

```
Bus options (PCI, PCMCIA, EISA, MCA, ISA)
	[*] PCI Support
	PCI Hotplug Support
		[M] Support for PCI Hotplug (EXPERIMENTAL)
		[M]   ACPI PCI Hotplug driver
```

ainsi que le contrôleur PCI Express:

```
Bus options (PCI, PCMCIA, EISA, MCA, ISA)
	[*] PCI Support
	[*] PCI Express Support
	[M]   PCI Express Hotplug driver
```

## PCMCIA / CardBus

La prise en charge des périphériques PCMCIA et CardBus est présente dans presque tous les ordinateurs portables fabriqués. Cependant, les ordinateurs portables plus récents passent au format ExpressCard (voir la recette PCI Hotplug dans la section intitulée «PCI hotplug»).

Pour déterminer si la machine possède un contrôleur PCMCIA, examiner le matériel pour voir si une carte PCMCIA peut y être branchée.

Activer la prise en charge PCI pour le noyau:

```
Bus options (PCI, PCMCIA, EISA, MCA, ISA)
	[*] PCI Support
```

Activez la prise en charge PCCARD pour le noyau:

```
Bus options (PCI, PCMCIA, EISA, MCA, ISA)
	PCCARD (PCMCIA/CardBus) support
		[M] PCCard (PCMCIA/CardBus) support
```

Activer la prise en charge PCMCIA et CardBus pour couvrir la plus large gamme d'appareils:

```
Bus options (PCI, PCMCIA, EISA, MCA, ISA)
	PCCARD (PCMCIA/CardBus) support
		[M] PCCard (PCMCIA/CardBus) support
		[M]   16-bit PCMCIA support
		[*]   32-bit CardBus support
```

Activer le type de pont de carte pour votre ordinateur portable. Le plus commun est le contrôleur "yenta-like":

```
Bus options (PCI, PCMCIA, EISA, MCA, ISA)
	PCCARD (PCMCIA/CardBus) support
		[M] PCCard (PCMCIA/CardBus) support
		[M]   CardBus yenta-compatible bridge support
		[ ]   Cirrus PD6729 compatible bridge support
		[ ]   i82092 compatible bridge support
		[ ]   i82365 compatible bridge support
		[ ]   Databook TCIC host bridge support
```

## Son (ALSA)

ALSA (Advanced Linux Sound Architecture) est le système audio actuel pour le noyau Linux. Un système audio antérieur (OSS) a été déconseillé et presque tous les pilotes plus anciens ont été supprimés de l'arborescence des sources du noyau.

Pour déterminer le type de contrôleur de son présent sur l'ordinateur et son type, exécuter la commande suivante:

```
/usr/sbin/lspci | grep -i audio

00:1f.5 Multimedia audio controller: Intel Corporation 82801EB/ER (ICH5/ICH5R) AC'97 Audio Controller (rev 02)
06:0d.0 Multimedia audio controller: Creative Labs SB Audigy (rev 04)
```

<WRAP info>la réponse à cette commande ne sera probablement pas identique; ce qui est important, c'est que la commande affiche certains contrôleurs audio.</WRAP>

Activer la prise en charge du son de base:

```
Device Drivers
    Sound
        [M] Sound Card Support
```

Activer ALSA:

```
Device Drivers
    Sound
        [M] Sound Card Support
            [M] Advanced Linux Sound Architecture
```

Il existe un certain nombre d'options ALSA de base différentes, telles que la prise en charge de l'ancien protocole audio OSS. Lorsqu'on a des applications plus anciennes, i al faut activer les options associées:

```
Device Drivers
    Sound
        [M] Sound Card Support
            [M] Advanced Linux Sound Architecture
            [M]   OSS Mixer API
            [M]   OSS PCM (digital audio) API
            [ ]     OSS PCM (digital audio) API - Include plugin system
```

Activer le type spécifique de périphérique audio. Les cartes son PCI sont sous le sous-menu PCI:

```
Device Drivers
    Sound
        [M] Sound Card Support
            [M] Advanced Linux Sound Architecture
                PCI Devices
```

# CPU

Pour que le noyau Linux s'exécute le plus rapidement possible pour un type de processeur et un type de matériel spécifiques, on peut définir quelques options pour obtenir les dernières performances du matériel. Cette section présente certaines des différentes options spécifiques au processeur que l'on peut régler pour un processeur.

## Types de processeur

Une large gamme d'options de processeur spécifiques sont disponibles pour être modifiées dans le noyau Linux. Le plus important spécifie le type exact de CPU pour lequel on va utilisé ce noyau. Pour déterminer le type de processeur que l'on utilise, exécuter la commande suivante:

```
cat /proc/cpuinfo  | grep "model name"

model name      : Intel(R) Xeon(TM) CPU 3.20GHz
```

<WRAP info>la réponse à cette commande ne sera probablement pas identique; l'important est que la commande affiche le nom du modèle du processeur présent sur le système.</WRAP>

Sélectionner le type de sous-architecture du processeur:

```
Processor type and features
    Subarchitecture Type
        (X) PC-compatible
        ( ) AMD Elan
        ( ) Voyager (NCR)
        ( ) NUMAQ (IBM/Sequent)
        ( ) Summit/EXA (IBM x440)
        ( ) Support for other sub-arch SMP systems with more than 8 CPUs
        ( ) SGI 320/540 (Visual Workstation)
        ( ) Generic architecture (Summit, bigsmp, ES7000, default)
        ( ) Support for Unisys ES7000 IA32 series
```

Ce n'est que si l'appareil fait partie des autres types de la liste précédente qu'il faudra sélectionner autre chose que l'option compatible PC. Cependant, si on souhaite créer un seul noyau qui s'exécutera sur tous les types de machines affichés, sélectionner l'option Architecture générique. Certaines des options ci-dessus peuvent ne pas être présentes lorsqu'on n'a pas également sélectionné l'option **Symmetric multi-processing support**.

Sélectionner le type de famille de processeurs. L'option **PC-compatible** doit être sélectionnée parmi les options précédentes pour que ce sous-menu soit affiché:

```
Processor type and features
    Processor family
        ( ) 386
        ( ) 486
        ( ) 586/K5/5x86/6x86/6x86MX
        ( ) Pentium-Classic
        ( ) Pentium-MMX
        ( ) Pentium-Pro
        ( ) Pentium-II/Celeron(pre-Coppermine)
        ( ) Pentium-III/Celeron(Coppermine)/Pentium-III Xeon
        ( ) Pentium M
        (X) Pentium-4/Celeron(P4-based)/Pentium-4 M/Xeon
        ( ) K6/K6-II/K6-III
        ( ) Athlon/Duron/K7
        ( ) Opteron/Athlon64/Hammer/K8
        ( ) Crusoe
        ( ) Efficeon
        ( ) Winchip-C6
        ( ) Winchip-2
        ( ) Winchip-2A/Winchip-3
        ( ) GeodeGX1
        ( ) Geode GX/LX
        ( ) CyrixIII/VIA-C3
        ( ) VIA C3-2 (Nehemiah)
        ( ) Generic x86 support
```

Pour plus de détails sur cet élément de configuration, se reporter à M386 pour une description complète de la façon de choisir le type de processeur approprié en fonction du processeur dont on dispose et de la gamme de machines sur lesquelles on souhaite que le noyau s'exécute.

## SMP

Si le système contient plus d'un processeur, ou un processeur hyperthreadé ou double cœur, il faut sélectionner l'option multiprocesseur pour le noyau Linux afin de tirer parti des processeurs supplémentaires. À moins de le faire, on gaspillera les autres processeurs en ne les utilisant pas du tout.

Activer le multiprocessing:

```
Processor type and features
    [*] Symmetric multi-processing support
```

## Preemption

Les systèmes fonctionnant en tant que serveurs ont des exigences de charge de travail très différentes de celles utilisées comme bureau pour les applications vidéo et audio. Le noyau permet différents modes de "préemption" afin de gérer ces différentes charges de travail. La préemption est la capacité du noyau à s'interrompre pendant qu'il fait autre chose, afin de travailler sur quelque chose avec une priorité plus élevée, comme la mise à jour d'un programme audio ou vidéo.

Pour passer à un autre modèle de préemption, utiliser ce menu:

```
Processor type and features
    Preemption Model
        (X) No Forced Preemption (Server)
		( ) Voluntary Kernel Preemption (Desktop)
		( ) Preemptible Kernel (Low-Latency Desktop)
```

Si on souhaite rendre le noyau encore plus réactif aux tâches de priorité plus élevée que ne le permet l'option de préemption générale, on peut également autoriser des interruptions à l'un des principaux verrous internes du noyau:

```
Processor type and features
    [*] Preempt The Big Kernel Lock
```

Cette option ne peut être sélectionnée que si on a déjà sélectionné les options **Preemptible Kernel** ou **Symmetric multi-processing**.

## Suspend

Le noyau Linux a la capacité de se suspendre au disque, ce qui permet de déconnecter l'alimentation, puis à un moment ultérieur, de redémarrer et de reprendre exactement où la machine était lorsqu'elle a été suspendue. Cette fonctionnalité est très utile sur les ordinateurs portables fonctionnant sous Linux.

Activer ceci en sélectionnant:

```
Power management options (ACPI, APM)
    [*] Software Suspend
```

Le noyau doit savoir où enregistrer l'image du noyau suspendu, puis plus tard la reprendre. Cet emplacement est généralement une partition d'échange de noyau sur le disque. Pour spécifier de quelle partition il s'agit:

```
Power management options (ACPI, APM)
    (/dev/hda3) Default resume partition
```

<WRAP info>Il faut spécifier la bonne partition pour suspendre la machine et ne pas utiliser une partition utilisée par le système pour les données. Le nom de partition approprié peut être trouvé en exécutant la commande suivante:\\ \\ `/sbin/swapon -s | grep dev | cut -f 1 -d ' '`\\ `/dev/hda3`\\ \\ Utiliser la sortie de la commande précédente dans cette option de configuration du noyau et sur la ligne de démarrage du noyau où elle spécifie d'où le noyau doit reprendre. Une fois la machine suspendue, pour la reprendre correctement, passer l'argument `resume=/dev/swappartition` à la ligne de commande du noyau pour qu'il utilise l'image appropriée. Si on ne souhaite pas restaurer l'image suspendue, utiliser l'argument de ligne de commande du noyau `noresume`.</WRAP>

## Mise à l'échelle de la fréquence du processeur

La plupart des processeurs modernes peuvent ralentir l'horloge interne du processeur pour économiser l'énergie et la durée de vie de la batterie. Linux prend en charge cette capacité et offre une variété de «gouverneurs» de puissance. Différents gouverneurs implémentent différentes heuristiques afin de déterminer comment faire varier la vitesse du processeur en fonction de la charge du système et d'autres variables.

Activer la fonctionnalité de mise à l'échelle de fréquence de base:

```
Power management options (ACPI, APM)
    [*] CPU Frequency scaling
```

Sélectionner les différents types de régulateurs de fréquence que l'on souhaite utiliser:

```
Power management options (ACPI, APM)
    [*] CPU Frequency scaling
    [*]   'performance' governor
    [*]   'powersave' governor
    [*]   'userspace' governor for userspace frequency scaling
    [*]   'ondemand' cpufreq policy governor
    [*]   'conservative' cpufreq governor
```

Pour plus d'informations sur ce que font les différents gouverneurs, voir "CPU\_FREQ".

Sélectionner le gouverneur par défaut que l'on souhaite faire fonctionner lorsque la machine boot:

```
Power management options (ACPI, APM)
    [*] CPU Frequency scaling
          Default CPUFreq governor (performance)
```

Sélectionner le type de processeur spécifique sur la machine. Pour plus de détails sur la façon de déterminer le type de processeur de la machine, consultrz la section intitulée «Types de processeur».

```
Power management options (ACPI, APM)
    [*] CPU Frequency scaling
    ---   CPUFreq processor drivers
    [ ]   ACPI Processor P-States driver
    [ ]   AMD Mobile K6-2/K6-3 PowerNow!
    [ ]   AMD Mobile Athlon/Duron PowerNow!
    [ ]   AMD Opteron/Athlon64 PowerNow!
    [ ]   Cyrix MediaGX/NatSemi Geode Suspend Modulation
    [*]   Intel Enhanced SpeedStep
    [*]     Use ACPI tables to decode valid frequency/voltage pairs
    [*]     Built-in tables for Banias CPUs
    [ ]   Intel Speedstep on ICH-M chipsets (ioport interface)
    [ ]   Intel SpeedStep on 440BX/ZX/MX chipsets (SMI interface)
    [ ]   Intel Pentium 4 clock modulation
    [ ]   nVidia nForce2 FSB changing
    [ ]   Transmeta LongRun
```

## Différents modèles de mémoire

Linux sur du matériel Intel 32 bits peut accéder jusqu'à 64 gigaoctets de mémoire, mais l'espace d'adressage du processeur 32 bits n'est que de 4 gigaoctets. Pour contourner cette limitation, Linux peut mapper la mémoire supplémentaire dans une autre zone, puis y basculer lorsque d'autres tâches en ont besoin. Mais si la machine a une plus petite quantité de mémoire, il est plus facile pour Linux de ne pas avoir à se soucier de gérer les plus grandes zones, il est donc avantageux de dire au noyau la quantité de mémoire que l'on souhaite qu'il prenne en charge. Pour une description plus détaillée de cette option, consulter NOHIGHMEM.

Linux prend en charge trois modèles de mémoire différents pour les processeurs Intel 32 bits, selon la mémoire disponible:

  * Moins de 1 gigaoctet de mémoire physique
  * Entre 1 et 4 gigaoctets de mémoire physique.
  * Plus de 4 gigaoctets de mémoire physique.

Pour sélectionner la quantité de mémoire:

```
Processor type and features
    High Memory Support
        (X) off
        ( ) 4GB
        ( ) 64GB
```

## ACPI

Sur presque tous les systèmes modernes basés sur Intel, **ACPI** est requis pour que la machine fonctionne correctement. **ACPI** est une norme qui permet au BIOS de l'ordinateur de fonctionner avec le système d'exploitation afin d'accéder au matériel de manière indirecte, dans l'espoir de gérer une large gamme d'appareils avec relativement peu de code spécifique à chaque système d'exploitation. **ACPI** fournit également une fonction pour aider à suspendre et reprendre une machine et contrôler la vitesse du processeur et des ventilateurs. Si vous avez un ordinateur portable, il est recommandé d'activer cette option.

Pour activer **ACPI**:

```
Power management options (ACPI, APM)
    ACPI (Advanced Configuration and Power Interface) Support
        [*] ACPI Support
```

Il existe une large gamme de différents "pilotes" ACPI qui contrôlent différents types de périphériques ACPI. Il faut activer ceux spécifiques qui sont sur la machine:

```
Power management options (ACPI, APM)
    ACPI (Advanced Configuration and Power Interface) Support
        [*] ACPI Support
        [*]   AC Adapter
        [*]   Battery
        [*]   Button
        [*]   Video
        [*]   Generic Hotkey (EXPERIMENTAL)
        [*]   Fan
        [*]   Processor
        [*]     Thermal Zone
        [ ]   ASUS/Medion Laptop Extras
        [ ]   IBM ThinkPad Laptop Extras
        [ ]   Toshiba Laptop Extras
```

# Networking

Aujourd'hui, la mise en réseau est requise pour presque toutes les machines et Linux prend en charge presque toutes les options de mise en réseau disponibles. Ici, nous allons montrer seulement quelques-uns de la grande variété qui sont présents.

Pour toutes les options de mise en réseau, y compris les différents pilotes, l'option de configuration réseau principale doit être activée:

```
Networking
    [*] Networking support
```

L'option TCP / IP doit également être sélectionnée pour que la machine puisse parler à d'autres machines sur Internet:

```
Networking
    [*] Networking support
          Networking options
              [*] TCP/IP networking
```

## Netfilter

La partie **Netfilter** du noyau Linux est un cadre pour filtrer et manipuler tous les paquets réseau qui transitent par la machine. Il est couramment utilisé si on souhaite activer un pare-feu sur la machine pour le protéger des différents systèmes sur Internet, ou pour utiliser la machine en tant que proxy pour d'autres machines du réseau.

Pour activer l'option **Netfilter** principale:

```
Networking
    [*] Networking support
          Networking options
              [*] Network packet filtering (replaces ipchains
```

Il est recommandé d'activer l'interface Netlink Netfilter et la prise en charge Xtables lors de l'utilisation de Netlink:

```
Networking
    [*] Networking support
          Networking options
              [*] Network packet filtering (replaces ipchains)
                    Core Netfilter Configuration
                        [*] Netfilter netlink interface
                        [*] Netfilter Xtables support (required for ip_tables)
```

Les différents protocoles que vous souhaitez filtrer doivent également être sélectionnés:

```
Networking
    [*] Networking support
          Networking options
              [*] Network packet filtering (replaces ipchains)
                    IP: Netfilter Configuration
                        [M] Connection tracking (required for masq/NAT)
                        [ ]   Connection tracking flow accounting
                        [ ]   Connection mark tracking support
                        [ ]   Connection tracking events (EXPERIMENTAL)
                        [ ]   SCTP protocol connection tracking support (EXPERIMENTAL)
                        [M]   FTP protocol support
                        [ ]   IRC protocol support
                        [ ]   NetBIOS name service protocol support (EXPERIMENTAL)
                        [M]   TFTP protocol support
                        [ ]   Amanda backup protocol support
                        [ ]   PPTP protocol support
                        [ ]   H.323 protocol support (EXPERIMENTAL)
```

## Pilotes réseau

Linux prend en charge un large éventail de périphériques réseau différents. Le plus courant est un périphérique réseau PCI, dans lequel un câble Ethernet peut être branché. Pour déterminer si vous avez un périphérique réseau PCI sur le système et de quel type il s'agit, exécutez la commande suivante:

```
/usr/sbin/lspci | grep Ethernet

03:0c.0 Ethernet controller: D-Link System Inc RTL8139 Ethernet (rev 10)
03:0e.0 Ethernet controller: Intel Corporation 82545GM Gigabit Ethernet Controller (rev 04)
```

<WRAP info>la réponse à cette commande ne sera probablement pas identique; ce qui est important, c'est que la commande affiche certains périphériques Ethernet PCI.</WRAP>

Activer la prise en charge PCI pour le noyau:

```
Bus options (PCI, PCMCIA, EISA, MCA, ISA)
    [*] PCI Support
```

Activer la prise en charge de base des périphériques réseau:

```
Device Drivers
    Network device support
        [*] Network device support
```

Il faut ensuite trouver les pilotes de périphérique spécifiques au matériel. L'endroit le plus courant pour trouver des périphériques Ethernet pour du matériel moderne est dans la section **1000 Mbit** de la sélection du pilote:

```
Device Drivers
    Network device support
        [*] Network device support
            Ethernet (1000 Mbit)
```

Certains appareils Ethernet plus anciens se trouvent dans la section **10 or 100 Mbit**:

```
Device Drivers
    Network device support
        [*] Network device support
            Ethernet (10 or 100Mbit)
```

Parcourir ces sections pour trouver le pilote approprié pour les périphériques spécifiques.

## IrDA

**IrDA** est un protocole infrarouge utilisé par un certain nombre d'ordinateurs portables et de PDA pour communiquer sur de très courtes distances. Il est répandu sur le matériel plus ancien, avec un matériel plus récent utilisant Bluetooth pour communiquer à la place, voir la section intitulée «Bluetooth» pour configurer Bluetooth.

**IrDA** est un protocole réseau, il peut donc être trouvé dans le menu principal de **Networking**:

```
Networking
    [*] Networking support
    [*]   IrDA (infrared) subsystem support
```

Plusieurs protocoles **IrDA** différents peuvent être sélectionnés, selon le type d'appareil avec lequel on souhaite communiquer et le programme utilisé pour effectuer la communication:

```
Networking
    [*] Networking support
        --- IrDA (infrared) subsystem support
        ---   IrDA protocols
        [*]   IrLAN protocol (NEW)
        [*]   IrCOMM protocol (NEW)
        [*]   Ultra (connectionless) protocol (NEW)
```

Il existe un large éventail de différents types de périphériques IrDA, certains série, certains PCI et d'autres basés sur USB. Pour sélectionner le type spécifique d'appareil IrDA, il faut le choisir dans le sous-menu du pilote pour IrDA:

```
Networking
    [*] Networking support
        --- IrDA (infrared) subsystem support
              Infrared-port device drivers
              --- SIR device drivers
              [ ] IrTTY (uses Linux serial driver)
              --- Dongle support
              --- Old SIR device drivers
              --- Old Serial dongle support
              --- FIR device drivers
              [ ] IrDA USB dongles
              [ ] SigmaTel STIr4200 bridge (EXPERIMENTAL)
              [ ] NSC PC87108/PC87338
              [ ] Winbond W83977AF (IR)
              [ ] Toshiba Type-O IR Port
              [ ] SMSC IrCC (EXPERIMENTAL)
              [ ] ALi M5123 FIR (EXPERIMENTAL)
              [ ] VLSI 82C147 SIR/MIR/FIR (EXPERIMENTAL)
              [ ] VIA VT8231/VT1211 SIR/MIR/FIR

```

## Bluetooth

**Bluetooth** est une technologie sans fil qui a été créée pour remplacer IrDA pour parler entre les appareils sur une très courte distance. Il s'agit d'une technologie sans fil à courte portée qui a été conçue en remplacement des câbles et fonctionne dans un rayon de 10 mètres et est couramment utilisée dans les téléphones mobiles.

Le **Bluetooth** est un protocole réseau, il peut donc être trouvé dans le menu principal **Networking**:

```
Networking
    [*] Networking support
    [*]   Bluetooth subsystem support
```

Il existe deux principales sélections de protocole pour Bluetooth. Les deux doivent être activés pour fonctionner avec tous les types d'appareils Bluetooth:

```
Networking
    [*] Networking support
        --- Bluetooth subsystem support
        [*]   L2CAP protocol support
        [*]   SCO links support
```

Il existe relativement peu de pilotes de périphériques Bluetooth individuels disponibles, car presque tous ces périphériques suivent les spécifications Bluetooth détaillant le fonctionnement des périphériques. Les pilotes indiqués dans la liste suivante doivent être sélectionnés pour que Bluetooth fonctionne avec l'appareil:

```
Networking
    [*] Networking support
        --- Bluetooth subsystem support
            Bluetooth device drivers
                [M] HCI USB driver
                [*]   SCO (voice) support
                [ ] HCI UART driver
                [M] HCI BCM203x USB driver
                [M] HCI BPA10x USB driver
                [ ] HCI BlueFRITZ! USB driver
                [ ] HCI DTL1 (PC Card) driver
                [ ] HCI BT3C (PC Card) driver
                [ ] HCI BlueCard (PC Card) driver
                [ ] HCI UART (PC Card) device driver
                [ ] HCI VHCI (Virtual HCI device) driver
```

## Sans fil

La mise en réseau sans fil (wireless) est très populaire, presque tous les ordinateurs portables modernes ont un périphérique réseau sans fil intégré. Linux prend en charge une large gamme de pilotes sans fil, et d'autres sont ajoutés chaque semaine. Pour déterminer si on a un périphérique sans fil PCI sur le système et de quel type il s'agit, exécuter la commande suivante:

```
/usr/sbin/lspci | grep -i wireless

06:05.0 Network controller: Intel Corporation PRO/Wireless 2915ABG MiniPCI Adapter (rev 05)
```

<WRAP info>la réponse à cette commande ne sera probablement pas identique; ce qui est important, c'est que la commande affiche certains périphériques sans fil PCI.</WRAP>

Pour activer la prise en charge sans fil sous Linux, l'option de configuration réseau IEEE 802.11 doit être activée (802.11 est le numéro de la spécification sans fil que tous ces périphériques suivent.)

```
Networking
    [*] Networking support
    [*]   Generic IEEE 802.11 Networking Stack
```

Activer également les différentes options du protocole 802.11 et l'option "Software MAC" pour fournir une prise en charge complète de tous les différents types de périphériques sans fil sous Linux:

```
Networking
    [*] Networking support
    [*]   Generic IEEE 802.11 Networking Stack
    [*]     IEEE 802.11 WEP encryption (802.1x)
    [M]     IEEE 802.11i CCMP support
    [M]     IEEE 802.11i TKIP encryption
    [M]     Software MAC add-on to the IEEE 802.11 networking stack
```

La prise en charge des différents types de périphériques réseau sans fil PCI se trouve dans la section Pilote réseau de la configuration:

```
Device Drivers
    Network device support
        Wireless LAN (non-hamradio)
            [*] Wireless LAN drivers (non-hamradio) & Wireless Extensions
            [*]   Wireless Extension API over RtNetlink
```

Il existe une large gamme de pilotes PCI différents dans cette section. Sélectionner le bon en fonction de l'appareil.

Les pilotes de périphérique réseau sans fil USB se trouvent dans une section différente de la configuration:

```
Device Drivers
    USB Support
        USB Network Adapters
```

# Systèmes de fichiers

Linux prend en charge un large éventail de types de systèmes de fichiers traditionnels et un certain nombre de types de systèmes de fichiers différents (gestionnaires de volumes, systèmes de fichiers en cluster, etc.). Les types de systèmes de fichiers traditionnels (normaux ou journalisés) peuvent être sélectionnés dans le menu principal de configuration du système de fichiers:

```
File systems
    [*] Second extended fs support
    [*] Ext3 journalling file system support
    [ ] Reiserfs support
    [ ] JFS filesystem support
    [ ] XFS filesystem support
```

Cette section montrera quelques-uns des types de systèmes de fichiers non traditionnels pris en charge par Linux, et comment les activer.

## RAID

**RAID** offre la possibilité de combiner de nombreux disques afin qu'ils ressemblent à un disque logique. Cela peut aider à fournir des moyens d'assurer la redondance ou la vitesse en répartissant les données sur différents plateaux de disques. Linux prend en charge le RAID matériel et logiciel. Le RAID matériel est géré par le contrôleur de disque, sans aucune aide du noyau.

Le **RAID** logiciel est contrôlé par le noyau et peut être sélectionné comme option de génération:

```
Device Drivers
    Multi-device support (RAID and LVM)
        [*] Multiple devices driver support (RAID and LVM)
        [*]   RAID support
```

Il existe de nombreux types de configurations RAID. Au moins un doit être sélectionné pour que **RAID** fonctionne correctement:

```
Device Drivers
    Multi-device support (RAID and LVM)
        [*] Multiple devices driver support (RAID and LVM)
        [*]   RAID support
        [*]     Linear (append) mode
        [*]     RAID-0 (striping) mode
        [*]     RAID-1 (mirroring) mode
        [*]     RAID-10 (mirrored striping) mode (EXPERIMENTAL)
        [*]     RAID-4/RAID-5 mode
        [*]     RAID-6 mode
```

## Gestionnaire de volumes logiques et mappeur de périphériques (LVM)

Tout comme le RAID, **LVM** (Logical Volume Manager) permet à l'utilisateur de combiner différents périphériques de bloc pour ressembler à un périphérique logique. Cependant, il ne fonctionne pas au niveau d'un périphérique comme RAID, mais via un mécanisme de mappage de blocs et de secteurs. Il permet à différentes parties de différents disques d'être combinées ensemble pour ressembler à un grand périphérique bloc pour l'utilisateur. Pour ce faire, le noyau utilise quelque chose appelé **Device Mapper** (DM).

Pour activer la prise en charge de Device Mapper dans le noyau:

```
Device Drivers
    Multi-device support (RAID and LVM)
        [*] Multiple devices driver support (RAID and LVM)
        [*]   Device mapper support
```

Il existe un certain nombre de modules d'assistance qui fonctionnent avec Device Mapper pour fournir des fonctionnalités supplémentaires. Il faut les activer si on veut crypter less devices, ou autoriser la fonctionnalité snapshot:

```
Device Drivers
    Multi-device support (RAID and LVM)
        [*] Multiple devices driver support (RAID and LVM)
        [*]   Device mapper support
        [*]     Crypt target support
        [*]     Snapshot target (EXPERIMENTAL)
        [*]     Mirror target (EXPERIMENTAL)
        [*]     Zero target (EXPERIMENTAL)
        [*]     Multipath target (EXPERIMENTAL)
```

## Partage de fichiers avec Windows

**Samba** est un programme qui permet aux utilisateurs Linux d'accéder nativement aux machines Windows sur le réseau, offrant un moyen de partager des disques et des périphériques de manière transparente. Il permet également à Linux de fonctionner comme un serveur Windows, permettant aux clients Windows de s'y connecter en pensant qu'il s'agit d'une véritable machine Windows.

Deux systèmes de fichiers différents qui permettent à une machine Linux de se connecter à une machine Windows: le système de fichiers **SMB** et le système de fichiers **CIFS**. Pour pouvoir se connecter à d'anciennes machines Windows for Workgroups ou Windows 95 ou 98, sélectionner le système de fichiers **SMB**:

```
File systems
    Network File Systems
        [*] SMB file system support (to mount Windows shares etc.)
```

Pour la possibilité de se connecter à des machines Windows plus récentes, le système de fichiers **CIFS** est recommandé à la place:

```
File systems
    Network File Systems
        [*] CIFS support
```

## OCFS2

**OCFS2** est un système de fichiers en cluster d'Oracle qui fonctionne à la fois pour les grandes installations réseau et les petits systèmes locaux. Ce système de fichiers est recommandé lors de l'utilisation de grandes bases de données, telles qu'Oracle ou DB2, car il peut être déplacé au fil du temps vers différents disques de sauvegarde sur le réseau assez facilement car davantage de stockage est nécessaire.

Pour activer le système de fichiers:

```
File systems
    [*] OCFS2 file system support
```

# Sécurité

Le noyau Linux prend en charge différents modèles de sécurité en fournissant des hooks et en permettant d'intégrer un choix de modèle. Pour le moment, seuls quelques modèles sont livrés avec l'arborescence source du noyau par défaut, mais les développeurs de nouveaux modèles travaillent à être mieux acceptés.

## Capacités Linux par défaut

Le type standard de modèle de sécurité pour Linux est le modèle de **capacity**. Il faut toujours sélectionner cette option, sauf si on veut vraiment exécuter un noyau non sécurisé pour une raison quelconque.

Pour l'activer:

```
Security options
    [*] Enable different security models
    [*]   Default Linux Capabilities
```

## SELinux

Un modèle de sécurité très populaire est appelé **SELinux**. Ce modèle est pris en charge par un certain nombre de distributions Linux différentes.

**SELinux** nécessite que l'option de mise en réseau soit activée. Voir la section intitulée «Networking» pour l'activer.

**SELinux** nécessite également que l'**audit** soit activé dans la configuration du noyau. Pour faire ça:

```
General setup
    [*] Auditing support
```
	
De plus, l'option de sécurité réseau doit être activée:

```
Security options
    [*] Enable different security models
    [*]   Socket and Networking Security Hooks
```

Il est maintenant possible de sélectionner l'option **SELinux**:

```
Security options
    [*] Enable different security models
    [*] NSA SELinux Support
```

Il existe également un certain nombre d'options **SELinux** individuelles que l'on peut activer. Consulter l'aide pour les différents éléments individuels pour plus de descriptions sur ce qu'ils font.

```
Security options
    [*] Enable different security models
    [*] NSA SELinux Support
    [ ]   NSA SELinux boot parameter
    [ ]   NSA SELinux runtime disable
    [*]   NSA SELinux Development Support
    [*]   NSA SELinux AVC Statistics
    (1)   NSA SELinux checkreqprot default value
```

# Débogage du noyau

Un large éventail d'options différentes du noyau peut aider à déboguer ce qui se passe dans le noyau. Voici une liste de quelques-uns des plus courants qui peuvent être utiles pour découvrir de nouvelles choses sur le fonctionnement du noyau, ou aider à trouver des problèmes potentiels dans le code source du noyau actuel.

## Horodatage du journal du noyau

Le noyau génère une large gamme de messages dans son fichier journal. Ces messages peuvent être vus en consultant le fichier journal du système (généralement situé dans `/var/log/messages`) ou en exécutant la commande **dmesg**.

Parfois, il est utile de voir exactement quand ces messages ont été créés. **dmesg**, cependant, ne met pas d'horodatage sur les événements qu'il affiche, et la résolution temporelle de `/var/log/messages` n'est qu'à la seconde près. On peut configurer le noyau pour attribuer à chaque message un horodatage précis jusqu'à la plus petite valeur de temps du noyau mesurable (généralement dans la plage de microsecondes).

Pour activer les options d'horodatage sur les messages du noyau:

```
Kernel hacking
    [*] Show timing information on printks
```

## Clés Magic SysRq

La touche [[linux:linux-system-key|SysRq]] du clavier peut être utilisée pour contrôler le noyau de différentes manières pendant que le noyau est en cours d'exécution ou après un plantage.

Pour activer cette option:

```
Kernel hacking
    [*] Magic SysRq key
```

Pour une description complète des différentes actions pouvant être déclenchées par cette option, consulter le fichier Documentation `/sysrq.txt` dans l'arborescence des sources du noyau.

## Système de fichiers de débogage

Un système de fichiers basé sur la RAM peut être utilisé pour produire un grand nombre d'informations de débogage différentes. Ce système de fichiers est appelé **debugfs** et peut être activé par:

```
Kernel hacking
    [*] Debug filesystem
```

Après avoir activé cette option et démarré le noyau reconstruit, il crée le répertoire `/sys/kernel/debug` comme emplacement pour l'utilisateur pour monter le système de fichiers **debugfs** manuellement:

```
mount -t debugfs none /sys/kernel/debug
```

ou faire monter automatiquement le système de fichiers au démarrage en ajoutant la ligne suivante au fichier `/etc/fstab`:

```
debugfs /sys/kernel/debug debugfs 0 0
```

Après avoir monté **debugfs**, un grand nombre de répertoires et fichiers différents apparaîtront dans le répertoire `/sys/kernel/debug/`. Ils sont tous virtuels et générés dynamiquement par le noyau, comme les fichiers dans **procfs** ou **sysfs**. Les fichiers peuvent être utilisés pour aider au débogage de différents sous-systèmes du noyau, ou tout simplement pour voir ce qui se passe avec le système pendant son fonctionnement.

## Débogage général du noyau

Voici une gamme d'autres bonnes options de configuration du noyau que l'on peut activer si on souhaite aider les développeurs du noyau à déboguer différents problèmes, ou tout simplement en savoir plus sur le fonctionnement du noyau en consultant les messages que ces options affichent. 

<WRAP info>Si on active presque toutes ces options, le noyau ralentira un peu, donc si on remarque une baisse des performances, il faudra peut-être désactiver les options.</WRAP>

```
Kernel hacking
    [*] Kernel debugging
    [*]   Detect Soft Lockups
    [ ]   Collect scheduler statistics
    [*]   Debug slab memory allocations
    [*]     Memory leak debugging
    [*]   Mutex debugging, deadlock detection
    [*]   Spinlock debugging
    [*]   Sleep-inside-spinlock checking
    [ ]   kobject debugging
    [ ]   Highmem debugging
    [ ]   Compile the kernel with debug info
```