Last ned, konfigurer, kompiler og installer Linux-kjernen trinn for trinn

Å kompilere Linux- kjernen er en av de oppgavene som skiller den nysgjerrige brukeren fra den som ønsker å fordype seg i operativsystemet . Det er ikke obligatorisk for å bruke GNU/Linux daglig, men det er en fin måte å bedre forstå hvordan maskinen din fungerer, få mest mulig ut av maskinvaren din og finjustere systemet etter din smak.

I denne veiledningen ser du trinn for trinn hvordan du laster ned, konfigurerer, kompilerer og installerer en Linux-kjerne fra bunnen av på Debian-baserte distribusjoner (Debian, Ubuntu, Mint og derivater), samt generelle konsepter du kan bruke på andre familier som Fedora eller CentOS. Vi vil også dekke hvorfor du kanskje vil gjøre dette, hvilke verktøy du trenger, hvordan du gjenbruker din nåværende kjernekonfigurasjon, hvordan du justerer alternativer for Docker eller spesifikk maskinvare, og hvordan du tilbakestiller hvis noe går galt.

Hvorfor du kanskje er interessert i å kompilere din egen kjerne

Før du berører noe som helst, er det viktig å være klar over målene dine: det er ikke alltid nødvendig å kompilere kjernen , men det er flere overbevisende grunner til å gjøre det.

• ytelse og effektivitetÅ fjerne drivere og funksjoner du aldri bruker kan gjøre at systemet starter opp raskere, bruke mindre RAM og redusere ventetid under visse arbeidsbelastninger.
• SikkerhetÅ deaktivere funksjoner eller moduler du ikke trenger reduserer angrepsflaten. En mer minimalistisk kjerne er i mange sammenhenger en sikrere kjerne.
• Støtte for spesifikk maskinvareNoen ganger inkluderer ikke distribusjonen din driveren du trenger ennå, eller den er deaktivert. Ved å kompilere din egen kjerne kan du aktiver støtte for maskinvaren din (nettverkskort, RAID, enheter av lagring uvanlig, osv.).
• Spesielle funksjonerDu kan prøve en ny oppgaveplanlegger, spesifikke funksjoner for virtualisering, Docker, containere, BPF, io_uring eller andre avanserte funksjoner som ikke er aktivert som standard.
• Læring og eksperimenteringÅ kompilere kjernen er en veldig enkel måte å Lær hvordan et GNU/Linux-system er organisert internt, hvordan maskinvaren initialiseres og hvordan modulene er integrert.

For en hjemmebruker som bare vil slå på datamaskinen, surfe på nettet og lite annet, er det imidlertid overkill å kompilere kjernen for hånd . Det er en lang og delikat prosess, og det er normalt å oppleve kjernepanikk før man får den til å fungere ordentlig. Hvis du liker å fikle, så kjør på. Hvis ikke, er det best å holde seg til de offisielle pakkene fra distribusjonen din.

Hva er egentlig Linux-kjernen?

Linux-kjernen er kjernekomponenten i systemet: programvaren som ligger mellom maskinvaren og resten av programmene . Den administrerer minne, prosesser, filsystemer, input/output-enheter, nettverk, sikkerhet og mye mer.

Linux startet i 1991 som et personlig prosjekt av Linus Torvalds for å lage en fri kjerne. Siden den gang har det vokst enormt: i dag snakker vi om titalls millioner kodelinjer, vedlikeholdt av tusenvis av utviklere under GPLv2- lisensen . Systemet vi vanligvis kaller "Linux" er faktisk en kombinasjon av Linux-kjernen, GNU-verktøy og andre komponenter som utgjør distribusjonen.

Når du kompilerer en tilpasset kjerne, genererer du en binærfil (vanligvis /boot/vmlinuz-version ) pluss et sett med moduler i /lib/modules/version , ledsaget av filer som System.map , konfigurasjonen med den brukte konfigurasjonen og det første oppstartsbildet ( initrd eller initramfs ).

Grunnleggende verktøy som trengs for å kompilere kjernen

For å kompilere en Linux-kjerne fra kildekoden trenger du et komplett utviklingsmiljø. På Debian-, Ubuntu- og Mint-systemer innebærer dette vanligvis å installere build-essential og en rekke tilleggsbiblioteker og verktøy.

Mange klassiske guider anbefaler sett som disse ( du kan tilpasse dem i henhold til oppsettet ditt ):

• Minimalt sett i Debian/Ubuntu for en relativt moderne kjerne:sudo apt-get install build-essential libncurses-dev bison flex libssl-dev libelf-dev libudev-dev libpci-dev libiberty-dev dkms openssl bc autoconf
• Debian-pakkemiljø for å bygge kernel .deb-pakker:sudo apt install autoconf automake autotools-dev bison build-essential dh-make debhelper debmake devscripts dpkg fakeroot file gfortran git gnupg fp-compiler lintian patch pbuilder perl quilt xutils-dev

I Fedora, CentOS og derivater endres tilnærmingen noe, men ideen er den samme: installer et sett med utviklingsverktøy og biblioteker for konfigurasjonsgrensesnitt (tekst og grafikk). For eksempel brukes kommandoer som følgende ofte:

su -c 'yum groupinstall "Development Tools"'
su -c 'yum install ncurses-devel qt-devel unifdef'

Uten disse avhengighetene vil kompileringen mislykkes ganske snart, så det er avgjørende å gjøre miljøet klart før du laster ned kildekoden.

Hvor kan man laste ned kildekoden til Linux-kjernen

Den offisielle kilden for å få tak i kjernekoden er kernel.org . Derfra kan du velge mellom hovedversjoner, stabile versjoner og LTS-versjoner (long term support). Hver versjon har sin egen mappe og en lenke til en komprimert tarball .

Noen eksempler på nedlastinger som ofte sees i veiledninger er:

• Stabil kjerne 6.6 for nylig testing:
  wget https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.6.tar.xz
• Kjerne 6.0.11 (v6.x-grenen):
  wget https://mirrors.edge.kernel.org/pub/linux/kernel/v6.x/linux-6.0.11.tar.xz
• Kjerne 5.10.13 (v5.x-grenen):
  wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.10.13.tar.xz

Du kan også laste ned kildekoden fra distribusjonens repositorier . For eksempel, i Debian/Ubuntu finnes linux-source- pakken :

sudo apt-get install linux-source

Dette etterlater en fil som linux-source-xxxtar.bz2 i /usr/src , som du kan dekomprimere på en lignende måte som kernel.org-tarballen.

Klargjør kildetreet og diskplassen

Når du har lastet ned kjerne-tarballen, må du pakke den ut til en plassering med tilstrekkelig plass og skriverettigheter . Du trenger ikke å bruke /usr/src, selv om det er et vanlig valg. Du kan for eksempel opprette en katalog som ~/Downloads/my-kernels.

Husk at kildetreet kan være rundt 1,5 GB stort når det er ukomprimert , og under kompilering hopper det lett over 7 GB , så reserver god margin.

Noen typiske eksempler på dekompresjon er:

• Med tar.xz:
  tar avxf linux-6.6.tar.xz
• Med tar.bz2:
  tar jxvf linux-2.6.36.tar.bz2 -C /usr/src
• Med tar.gz:
  tar zxvf linux-x.x.x.x.tar.gz -C /usr/src

Etter utpakking vil du ha en katalog som linux-6.6 eller linux-5.10.13 . Du kan opprette en generisk symbolsk lenke kalt linux for å unngå å bli forvirret med stiene:

cd /usr/src
sudo ln -s linux-6.0.11 linux

Det er ikke obligatorisk å plassere kildekoden i /usr/src , selv om mange guider gjør det av tradisjon. Kompilering og installasjon vil fungere like bra hvis du gjør det i brukermappen din , forutsatt at du har nok plass og nødvendige tillatelser.

Bruk gjeldende kjernekonfigurasjon på nytt

Å konfigurere en kjerne fra bunnen av, alternativ for alternativ, er en endeløs oppgave selv for svært erfarne brukere. Vanlig praksis er å gjenbruke konfigurasjonen av kjernen du allerede bruker som utgangspunkt.

For å gjøre dette, er det først nødvendig å vite hvilken kjerne du har lastet inn:

uname -r

Resultatet vil være noe sånt som 6.1.0-13-amd64 eller 4.19.0-6-amd64 . Med den informasjonen kan du kopiere gjeldende konfigurasjon fra /boot til katalogen for de nylig utpakkede kildekodene:

cd linux-6.6
cp /boot/config-$(uname -r) .config

Den .config- filen vil være den kjernebyggesystemet bruker som base. I nyere versjoner, når du kjører konfigurasjonsverktøyene, vil du bare bli spurt om alternativer som ikke fantes i den forrige kjernen , noe som sparer deg mye tid.

Slik justerer du innstillingene til den faktiske maskinvaren

I tillegg til å gjenbruke den nåværende .config-filen, kan du ytterligere forbedre konfigurasjonen din ved å bruke verktøyene som finnes i selve kjernetreet. Et spesielt nyttig verktøy er `make localmodconfig` , som prøver å generere en konfigurasjon som er skreddersydd til modulene du har lastet inn.

I kildekatalogen kjører du ganske enkelt:

make localmodconfig

Denne kommandoen inspiserer aktive moduler og deaktiverer mange ting systemet ditt ikke bruker . Den er ideell hvis du konfigurerer en kjerne for den spesifikke maskinen. Hvis du har tenkt å kompilere en generisk kjerne for andre maskiner eller servere, må du nøye gjennomgå den etterpå for å sikre at du ikke utelater maskinvare som ikke finnes på systemet der du kompilerer.

Kjernekonfigurasjonsmoduser: tekst- og grafiske miljøer

Kjernekonfigurasjon kan gjøres på flere måter. Alle ender opp med å generere eller endre .config- filen , men opplevelsen er veldig forskjellig avhengig av metoden:

• lag konfigurasjonEt rent tekstbasert spørreskjema, spørsmål for spørsmål. I dag anses det kun som praktisk i svært spesifikke tilfeller; det er treg, kjedelig og lett å gjøre feil.
• Lage menuconfigTekstbasert menygrensesnitt (ncurses), veldig vanlig på servere eller når du ikke har et grafisk miljø. Du navigerer med piltastene, tabulatortasten og mellomromstasten.
• lag xconfigEt Qt-basert grafisk grensesnitt, komfortabelt for musebruk. Ideelt når man jobber fra et fullt skrivebord.
• lag gconfigGTK-basert grafisk grensesnitt, designet for GNOME-lignende miljøer.

I praksis er `make menuconfig` stjernen i nesten alle guider fordi den fungerer i nesten alle kontekster. Med utgangspunkt i den kopierte `.config`-filen trenger du ganske enkelt å:

make menuconfig

Du vil se en hovedmeny med kategorier som «Prosessortype og funksjoner», «Enhetsdrivere», «Filsystemer», «Nettverksstøtte», «Virtualisering» osv. Innenfor hver kategori kan du aktivere, deaktivere eller merke de forskjellige alternativene som moduler. Vanligvis:

• [*] Det betyr «innebygd».
• [M] Det indikerer at «den er kompilert som en lastbar modul».
• [] Den er «deaktivert».

Tanken er å integrere det som er nødvendig for å starte systemet i kjernen (for eksempel støtte for rotdisk), og bruke moduler for mindre kritiske eller ikke alltid brukte funksjoner , slik at hovedkjernen blir lettere.

Hvert menyelement har vanligvis et hjelpealternativ som forklarer nøyaktig hva det gjør, og noen ganger gir det en standardanbefaling. Hvis du er usikker på noe veldig spesifikt, er det best å holde seg til den anbefalte verdien eller den som allerede var aktivert i forrige konfigurasjon.

Nyttige innstillinger: filsystemer, virtualisering og Docker

En viktig del av tilpasning av kjernen er å velge riktige filsystemer, containermekanismer og nettverksalternativer . Hvis du for eksempel planlegger å bruke skrivbare NTFS- partisjoner , må du aktivere den tilsvarende støtten (vanligvis funnet under "Filsystemer → DOS/FAT/EXFAT/NT-filsystemer").

Hvis du planlegger å jobbe med virtualisering eller containere, finnes det visse sett med alternativer som er viktige å gjennomgå. For Docker og Docker Swarm er det for eksempel flere navnerom, c-gruppe og nettverksfunksjoner som må aktiveres:

• cgruppehierarki.
• CONFIG_NAMESPACES, CONFIG_NET_NS, CONFIG_PID_NS, CONFIG_IPC_NS, CONFIG_UTS_NS.
• CONFIG_CGROUPS og underalternativer som CONFIG_CGROUP_CPUACCT, CONFIG_CGROUP_DEVICE, CONFIG_CGROUP_FREEZER, CONFIG_CGROUP_SCHED, CONFIG_CPUSETS, CONFIG_MEMCG.
• Nøkkelstøtte (CONFIG_KEYS).
• Nettverksalternativer som CONFIG_VETH, CONFIG_BRIDGE, CONFIG_BRIDGE_NETFILTER, CONFIG_NF_NAT_IPV4, CONFIG_IP_NF_FILTER, CONFIG_IP_NF_TARGET_MASQUERADE, CONFIG_NETFILTER_XT_MATCH_ADDRTYPE, CONFIG_NETFILTER_XT_MATCH_CONNTRACK, CONFIG_NETFILTER_XT_MATCH_IPVS, CONFIG_IP_NF_NAT, CONFIG_NF_NAT, CONFIG_NF_NAT_NEEDED.
• Støtte for POSIX-kø (CONFIG_POSIX_MQUEUE).
• Alternativer som CONFIG_IPVLAN for visse nettverkskonfigurasjoner som brukes av Docker.

Mye av denne funksjonaliteten kan kompileres som en modul uten problemer, men det anbefales å se gjennom Docker-dokumentasjonen eller bruke testskript . Verktøy som check-config.sh analyserer kjernens .config-fil og forteller deg hva som mangler for full containerkompatibilitet.

Den grunnleggende mekanikken ville være:

chmod +x check-config.sh
./check-config.sh .config

Utdataene vil vise deg hvilke alternativer som er OK, hvilke som mangler eller hvilke som er feilkonfigurert. Hvis du finner noe kritisk deaktivert, kan du kjøre `make menuconfig` eller `make xconfig` på nytt , rette det, lagre og gjenta bekreftelsen.

Interessante forbedringer i nyere kjerneversjoner

I tillegg til tilpasning, kompilerer mange nye kjerneversjoner for å dra nytte av ytelsesforbedringer og nye funksjoner som fortsatt vil ta tid å nå distribusjonspakkene deres.

For eksempel, i gren 6.6 , er forbedringer som følgende nevnt:

• Merkbar ytelsesøkning i EXT4, med økninger på opptil 34 % i visse samtidige skriveinnlastinger.
• Forbedringer i GPU-støtte NVIDIA bruker den gratis driveren Nouveau, og forbereder grunnen for NVK (Vulkan)-sjåføren.
• Alternativer for konfigurere aspekter av BIOS fra HP-utstyr direkte fra Linux.
• Innstillinger for klyngeplanlegging for hybridprosessorer Intel (Alder Lake, Raptor Lake og senere).
• Optimalisering av direkte asynkron I/O med io_uring, med ytelsesøkninger på rundt 37 % i visse tester.
• En ny oppgaveplanlegger, EEVDF (tidligste kvalifiserte virtuelle frist først), noe som forbedrer CPU-allokering mellom prosesser.

Alt dette kommer "rett ut av esken" i moderne versjoner, men det kan ta tid å pakke eller aktivere distribusjonen din, og det er derfor mange tyr til å kompilere en nyere kjerne manuelt.

Kompilering av kjernen: make, moduler og kompileringstråder

Når du har konfigurasjonen du ønsker, er det på tide å sette CPU-en i arbeid. Det er her de klassiske kernel -make -kommandoene kommer inn i bildet. Kompilering kan ta alt fra flere minutter til over en time, avhengig av maskinvaren og hvor mange moduler du genererer.

I hovedsak er den grunnleggende arbeidsflyten i Debian/Ubuntu (eller andre distribusjoner) vanligvis:

• Kompiler kjernen (hovedbilde):
  make -j$(nproc)
  Eller, hvis du vil at den bare skal bruke én kjerne:
  make
• Kompiler og installer modulene:
  sudo make modules_install

Alternativet `-j$(nproc)` forteller `make` at det skal bruke så mange parallelle prosesser som CPU-en din har kjerner, noe som sparer mye tid på moderne maskiner. Hvis du ser feil under kompilering, må du sjekke dem på det punktet der de feiler. De kan skyldes manglende avhengigheter, motstridende konfigurasjoner eller spesifikke feil i den kjerneversjonen.

I noen mer avanserte oppskrifter brukes Debian-verktøyet make-kpkg og kernel-package -pakken til å pakke kjernen inn i .deb-filer. Dette lar deg deretter installere og avinstallere den tilpassede kjernen som om den bare var en annen pakke, med noe sånt som:

fakeroot make-kpkg --initrd --append-to-version=-custom kernel_image kernel_headers
cd /usr/src
sudo dpkg -i *.deb

I så fall er det også vanlig å støte på feil relatert til kjernesertifikater . Mange guider løser spesifikke problemer ved å deaktivere klarerte nøkler i .config-filen med en linje som:

sed -i '/CONFIG_SYSTEM_TRUSTED_KEYS/s/^/#/g' .config

Installer den nylig kompilerte kjernen og oppdater oppstartslasteren

Hvis du ikke bruker .deb-pakking og går "bare-core" med standard kjernetreverktøy, gjøres installasjonen direkte fra kildekatalogen . Den vanligste sekvensen etter kompilering er:

• Installer modulene (hvis du ikke allerede har gjort det):
  sudo make modules_install
• Installer kjernen:
  sudo make install

Kjernens eget skriptsystem vil kopiere den genererte bzImage- binærfilen til /boot, sammen med System.map og konfigurasjonsfilen. På Debian/Ubuntu kjøres skript i /etc/kernel/postinst.d vanligvis for å generere initramfs og automatisk oppdatere oppstartslasteren (GRUB).

Likevel skader det aldri å eksplisitt utføre:

sudo update-initramfs -u
sudo update-grub
sudo update-grub2

Dette sikrer at det første oppstartsbildet er riktig generert for den nye kjerneversjonen, og at GRUB gjenkjenner det i menyen sin. I andre distribusjoner, som noen basert på Red Hat, kan du bruke `mkinitrd` eller `dracut` i stedet for `update-initramfs`, men målet er det samme: å lage et passende initrd/initramfs-bilde for den nye kjernen.

Rollen til initrd/initramfs og potensielle problemer

Initrd eller initramfs er et filsystembilde som lastes inn i minnet veldig tidlig i oppstartsprosessen . Det inneholder minimumsdriverne som er nødvendige for å montere det faktiske rotfilsystemet (for eksempel støtte for SATA- eller NVMe-kontrolleren der /-partisjonen din befinner seg).

Hvis initrd-filen din er feil generert eller ikke inneholder de nødvendige modulene, vil kjernen starte opp, men ikke kunne monteres / og du vil ende opp med en kjernepanikk som klager over at den ikke finner rotfilsystemet . Dette er en typisk feil når kritiske kjernealternativer er deaktivert eller initramfs glemmes etter en versjonsendring.

I Debian/Ubuntu er referansekommandoen i dag update-initramfs :

sudo update-initramfs -c -k x.x.x

Parameteren -c oppretter et nytt image, og -k spesifiserer den nøyaktige kjerneversjonen. Eldre distribusjoner (eller de som bruker andre verktøy) brukte mkinitrd med en lignende syntaks:

cd /boot
mkinitrd -o initrd.img-2.6.36 2.6.36

Uansett, hvis du ser feil relatert til /lib/modules eller rotmonteringen etter at du har installert den tilpassede kjernen, bør du først sjekke initramfs/initrd og GRUB-konfigurasjonen før du rører noe annet.

Bekreft at den nye kjernen fungerer som den skal

Når alt er installert og oppstartsbehandleren er oppdatert, er det på tide å starte systemet på nytt for å teste. Under oppstart bør du følge med på GRUB- og kjerneoppstartsmeldingene for eventuelle feil relatert til ukjente moduler, filsystemer eller enheter.

Når du er inne i systemet, kan du sjekke hvilken kjerneversjon du bruker med:

uname -a

Utdataene skal gjenspeile den nylig kompilerte versjonen . Derfra handler det om å teste dine vanlige tjenester: webserver, databaser , Docker, virtuelle maskiner , skrivebordsapplikasjoner osv. Hvis alt fungerer som det skal, kan du beholde den kjernen som hovedkjernen og beholde eldre versjoner som sikkerhetskopier.

Slik går du tilbake til en tidligere kjerne og avinstallerer den nye

Hvis noe går galt (noe som kan skje, spesielt de første gangene), er det viktigste å ikke få panikk . Så lenge GRUB-en din har andre fungerende kjerner oppført, kan du gjenopprette systemet uten for mye problemer.

Den typiske prosessen ville være:

1. Start systemet på nytt.
2. På GRUB-skjermen, beveg deg med pilene og skriv inn typeseksjonen "Avanserte alternativer for…".
3. Velg en eldre kjerneversjon som du vet fungerte bra.
4. Start opp med den kjernen, og når du er inne, fortsett å slette den problematiske kjernen.

Hvis du installerte kjernen manuelt, uten .deb-pakker, innebærer fjerning vanligvis å slette de tilsvarende filene i /boot og /lib/modules . For eksempel, for å fjerne en 6.6.0-kjerne kan du gjøre:

cd /boot
sudo rm config-6.6.0 initrd.img-6.6.0 System.map-6.6.0 vmlinuz-6.6.0

Og slett deretter modulene:

cd /lib/modules
sudo rm -rf 6.6.0

Når du er ferdig, oppdater GRUB slik at den ikke lenger tilbyr den kjernen i menyen og start maskinen på nytt:

sudo update-grub
sudo update-grub2
sudo reboot

Hvis du installerte kjernen pakket som .deb, er det enklere å bruke den som en hvilken som helst annen pakke med apt eller dpkg for å avinstallere den, slik at systemtilstanden holdes bedre under kontroll.

Merknader for andre distribusjoner: Fedora, CentOS og andre

Selv om denne veiledningen fokuserer sterkt på Debian/Ubuntu/Mint, er den generelle logikken lik for Red Hat-baserte distribusjoner som Fedora eller CentOS. Hvilke endringer er pakkehåndteringsverktøyene, noen avhengighetsnavn og hvordan du får tilgang til oppstartsbehandleren.

I Fedora/CentOS kan for eksempel en grunnleggende arbeidsflyt for å kompilere en kjerne fra kernel.org være:

• Installer utviklingsverktøyene:
  su -c 'yum groupinstall "Development Tools"'
su -c 'yum install ncurses-devel qt-devel unifdef'
• Last ned en stabil versjon (som 2.6.36 i de klassiske eksemplene):
  cd /tmp
wget http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.36.tar.bz2
• Pakk ut og klargjør kildetreet:
  mkdir /usr/src/linux
tar -xjvf linux-2.6.36.tar.bz2 -C /usr/src/linux
cd /usr/src/linux
• Konfigurer kjernen ved hjelp av menuconfig, xconfig eller gconfig.
• Kompiler og installer:
  make
make modules
make modules_install
make install

Deretter må du se gjennom og redigere /boot/grub/grub.conf (eller tilsvarende fil, avhengig av om du bruker GRUB Legacy, GRUB2 osv.) for å legge til en oppføring for den nye kjernen med tilhørende initrd. Vær nøye med root= -stiene og referanser til logiske volumer hvis du bruker LVM.

Å kompilere, konfigurere og installere en tilpasset Linux-kjerne er en langvarig, men utrolig lærerik prosess: den tvinger deg til å forstå hvilke moduler du må starte opp, hvilke alternativer som er viktige for tjenestene dine (som Docker eller virtualisering), hvordan initramfs og GRUB er integrert i oppstartsprosessen, og hvordan du alltid har et reservealternativ for å gå tilbake til en tidligere kjerne hvis noe går galt. Hvis du tar deg tid til å gjennomgå hver seksjon, bruker din nåværende kjernekonfigurasjon på en intelligent måte, og blir vant til å teste endringer gradvis, kan du ende opp med å nyte et mer optimalisert system, skreddersydd for maskinvaren din og i tråd med dine faktiske behov, enn de generiske kjernene som tilbys av de fleste distribusjoner.