Ladda ner, konfigurera, kompilera och installera Linuxkärnan steg för steg

Kompilera kärnan av Linux Det är en av de uppgifter som skiljer den nyfikne användaren från den som vill att fördjupa sig i operativsystemetDet är inte obligatoriskt för att använda GNU/Linux dagligen, men det är ett bra sätt att bättre förstå hur din maskin fungerar, få ut det mesta av hårdvaran och finjustera systemet efter din smak.

I den här guiden får du steg för steg se hur Ladda ner, konfigurera, kompilera och installera en Linux-kärna från grunden. Vi kommer att gå igenom Debian-baserade distributioner (Debian, Ubuntu, Mint och derivator), såväl som allmänna koncept som är tillämpliga på andra familjer som Fedora eller CentOS. Vi kommer också att utforska varför du kanske vill göra detta, vilka verktyg du behöver, hur du återanvänder din nuvarande kärnkonfiguration, hur du justerar alternativ för Docker eller specifik hårdvara och hur du återställer om något går fel.

Varför du kanske är intresserad av att kompilera din egen kärna

Innan du rör vid något är det viktigt att vara tydlig med vad du vill: Att kompilera kärnan är inte alltid nödvändigtMen det finns flera övertygande skäl att göra det.

• prestanda och effektivitetAtt ta bort drivrutiner och funktioner som du aldrig använder kan göra att systemet startar snabbare, använder mindre RAM och minskar latensen under vissa arbetsbelastningar.
• säkerhetAtt inaktivera funktioner eller moduler som du inte behöver minskar attackytan. En mer minimalistisk kärna är i många sammanhang en säkrare kärna.
• Stöd för specifik hårdvaraIbland inkluderar din distribution ännu inte den drivrutin du behöver, eller så är den inaktiverad; genom att kompilera din egen kärna kan du aktivera support för din hårdvara (nätverkskort, RAID, enheter av lagring ovanligt, etc.).
• SpecialfunktionerDu kanske vill prova en ny schemaläggare, specifika funktioner för virtualisering, Docker, containrar, BPF, io_uring eller andra avancerade funktioner som inte är aktiverade som standard.
• Lärande och experimenterandeAtt kompilera kärnan är ett mycket enkelt sätt att Lär dig hur ett GNU/Linux-system är organiserat internt, hur hårdvaran initieras och hur modulerna är integrerade.

Men för en hemanvändare som bara vill slå på datorn, surfa på internet och inte mycket annat, Att kompilera kärnan för hand är som att använda en kanon för att döda flugor.Det är en lång och känslig process, och det är normalt att äta lite mat längs vägen. kärnan panik Innan du finjusterar det. Om du gillar att mixtra, kör på; om inte, är det bäst att hålla sig till de officiella paketen för din distribution.

Vad är egentligen Linuxkärnan?

Linuxkärnan är systemets centrala komponent: programvaran som sitter mellan hårdvaran och resten av programmenDen ansvarar för att hantera minne, processer, filsystem, in-/utmatningsenheter, nätverk, säkerhet och mycket mer.

Linux startade 1991 som ett personligt projekt av Linus Torvalds att skapa en fri kärna. Sedan dess har den vuxit enormt: idag pratar vi om tiotals miljoner rader kod, underhållna av tusentals utvecklare under licensen GPLv2Systemet vi vanligtvis kallar "Linux" är egentligen en kombination av Linuxkärna + GNU-verktyg och andra komponenter som sätter ihop distributionen.

När du kompilerar en anpassad kärna genererar du en binärfil (vanligtvis /boot/vmlinuz-version) plus en uppsättning moduler i /lib/moduler/version, åtföljd av filer som t.ex. System.karta, The config med den använda konfigurationen och den initiala startavbildningen (initrd eller initramfs).

Grundläggande verktyg som behövs för att kompilera kärnan

För att kompilera en Linuxkärna från källkod behöver du en komplett utvecklingsmiljö. På Debian-, Ubuntu- och Mint-system innebär detta vanligtvis att installera build-essential och ett antal ytterligare bibliotek och verktyg.

Många klassiska guider rekommenderar uppsättningar som följande (Du kan anpassa dem efter din layout.):

• Minimal uppsättning i Debian/Ubuntu för en relativt modern kärna:sudo apt-get install build-essential libncurses-dev bison flex libssl-dev libelf-dev libudev-dev libpci-dev libiberty-dev dkms openssl bc autoconf
• Debians paketeringsmiljö för att bygga kernel .deb-paket: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 och derivatorTillvägagångssättet ändras något, men idén förblir densamma: installera en uppsättning utvecklingsverktyg och bibliotek för konfigurationsgränssnitt (text och grafik). Till exempel används följande ofta kommandon av stilen:

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

Utan dessa beroenden kommer kompileringen att misslyckas ganska snabbt, så det är Det är viktigt att ha miljön redo innan källkoden laddas ner.

Var man kan ladda ner källkoden för Linuxkärnan

Den officiella källan för att få tag på kärnkoden är kernel.orgDärifrån kan du välja mellan standardversioner, stabila versioner och LTS-versioner (Long Term Support). Varje version har sin egen mapp och en länk till en tarball komprimido.

Några exempel på descargas som ofta ses Handledningarna är:

• Stabil kärna 6.6 för senaste testning:
  wget https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.6.tar.xz
• Kärna 6.0.11 (v6.x-grenen):
  wget https://mirrors.edge.kernel.org/pub/linux/kernel/v6.x/linux-6.0.11.tar.xz
• Kärna 5.10.13 (v5.x-grenen):
  wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.10.13.tar.xz

Du kan också ladda ner typsnitten från arkiv för din distributionI Debian/Ubuntu finns till exempel paketet Linux-källa:

sudo apt-get install linux-source

Detta lämnar en fil av typen linux-source-xxxtar.bz2 en / Usr / srcsom du kan dekomprimera på ett liknande sätt som kernel.org-tarballen.

Förbered källkodsträdet och diskutrymmet

När du har laddat ner kärnans tarball måste du extrahera den till en plats där du har tillräckligt med utrymme och skrivbehörigheterDu är inte tvungen att använda /usr/src, även om det är en klassiker. Du kan till exempel skapa en katalog som ~/Nedladdningar/mina-kärnor.

Tänk på att källträdet kan finnas kvar när det är okomprimerat 1,5 GBoch under kompileringen hoppar saker lätt över 7 GBSå lämna gott om utrymme för fel.

några typiska exempel på dekompression ljud:

• 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

Efter uppackning kommer du att ha en katalog som liknar linux-6.6 o linux-5.10.13Du kan skapa en generisk symbolisk länk som heter linux för att undvika att bli galen med rutten:

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

Det är inte obligatoriskt att lägga in källorna / Usr / src, även om många guider gör det av tradition. Kompileringen och installationen kommer att fungera på samma sätt om du gör det i din användarmapp.förutsatt att du har plats och lämpliga tillstånd.

Återanvänd den aktuella kärnkonfigurationen

Att konfigurera en kärna från grunden, alternativ för alternativ, är en oändlig uppgift även för mycket erfarna personer. Den vanliga praxisen är återanvänd kärnkonfigurationen du redan använder som utgångspunkt.

För att göra detta är det först nödvändigt att veta vilken kärna har du laddat? just nu:

uname -r

Resultatet blir något i stil med 6.1.0-13-amd64 o 4.19.0-6-amd64Med den informationen kan du kopiera den aktuella konfigurationen från /känga till katalogen för de nyligen dekomprimerade källorna:

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

Den filen .config Detta kommer att vara den som kärnbyggsystemet använder som bas. I nyare versioner, när du kör konfigurationsverktygen, kommer du bara att bli ombedd att ange alternativ som inte fanns i din tidigare kärnavilket sparar enormt mycket tid.

Hur man justerar inställningarna till den faktiska hårdvaran

Förutom att återanvända den aktuella .config-filen kan du finjustera den ytterligare med hjälp av verktygen som finns i själva kärnträdet. Ett särskilt användbart verktyg är gör localmodconfig, som försöker generera en konfiguration anpassad till de moduler du har laddat just då.

Inom källkatalogen kör du helt enkelt:

make localmodconfig

Det här kommandot inspekterar de aktiva modulerna och Det inaktiverar många saker som ditt system inte använder.Detta är idealiskt om du konfigurerar en kärna för den specifika maskinen. Om du tänker kompilera en generisk kärna för andra maskiner eller servrar måste du noggrant granska den efteråt för att säkerställa att du inte utelämnar hårdvara som inte finns på systemet där du kompilerar.

Kärnkonfigurationslägen: text- och grafiska miljöer

Kärnkonfiguration kan göras på flera sätt. Alla dessa sätt slutar med att generera eller modifiera filen. .configMen upplevelsen är väldigt olika beroende på läge:

• skapa konfigurationEtt rent textbaserat frågeformulär, fråga för fråga. Idag anses det vara praktiskt endast för mycket specifika fall; det är långsam, tråkig och lätt att göra misstag.
• Gör menuconfigTextbaserat menygränssnitt (ncurses), mycket vanligt på servrar eller när man inte har en grafisk miljö. Man navigerar med piltangenter, tabb och mellanslag.
• skapa xconfigEtt Qt-baserat grafiskt gränssnitt, bekvämt för musanvändning. Perfekt när man arbetar från ett komplett skrivbord.
• skapa gconfigGTK-baserat grafiskt gränssnitt, utformat för GNOME-liknande miljöer.

I praktiken, Gör menuconfig Det är stjärnan i nästan varje guide eftersom den fungerar i nästan alla sammanhang. Med utgångspunkt i din kopierade .config-fil behöver du bara:

make menuconfig

Du kommer att se en huvudmeny med kategorier som "Processortyp och funktioner", "Enhetsdrivrutiner", "Filsystem", "Nätverksstöd", "Virtualisering" etc. Inom var och en av dem kommer du att kunna aktivera, avaktivera eller markera som modul De olika alternativen. Normalt sett:

• [*] Det betyder "inbyggd".
• [M] Det indikerar "den är kompilerad som en laddningsbar modul".
• [] Den är "avaktiverad".

Tanken är att integrera i kärnan det som krävs för att starta systemet (till exempel stöd för rotdiskar), och använda moduler för mindre kritiska funktioner eller funktioner som inte alltid användsså att huvudkärnan är lättare.

Varje menyalternativ har vanligtvis ett alternativ för att Hjälp Detta förklarar exakt vad den gör och ger ibland en standardrekommendation. Om du är osäker på något specifikt är det bäst att hålla dig till det rekommenderade värdet eller det som redan var aktiverat i den tidigare konfigurationen.

Användbara inställningar: filsystem, virtualisering och Docker

En viktig del av kärnans anpassning är att välja väl Vilka filsystem, containermekanismer och nätverksalternativ? Du kommer att behöva det. Om du till exempel planerar att använda partitioner NTFS När du skriver måste du aktivera motsvarande stöd (vanligtvis i "Filsystem → DOS/FAT/EXFAT/NT-filsystem").

Om du planerar att arbeta med virtualisering eller containrar finns det block med alternativ som är viktiga att granska. För Docker och Docker Swarm finns det till exempel ett antal funktioner för namnrymder, cgroups och nätverk som måste vara aktiv:

• c-grupphierarki.
• CONFIG_NAMESPACES, CONFIG_NET_NS, CONFIG_PID_NS, CONFIG_IPC_NS, CONFIG_UTS_NS.
• CONFIG_CGROUPS och underalternativ som t.ex. CONFIG_CGROUP_CPUACCT, CONFIG_CGROUP_DEVICE, CONFIG_CGROUP_FREEZER, CONFIG_CGROUP_SCHED, CONFIG_CPUSETS, CONFIG_MEMCG.
• Viktigt stöd (CONFIG_KEYS).
• Nätverksalternativ som t.ex. 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öd för POSIX-köer (CONFIG_POSIX_MQUEUE).
• Alternativ som CONFIG_IPVLAN för vissa nätverkskonfigurationer som används av Docker.

Mycket av denna funktionalitet kan kompileras som en modul utan problem, men Det är lämpligt att granska Docker-dokumentationen eller använda testskript.Det finns verktyg som t.ex. check-config.sh som analyserar kärnans .config-fil och berättar vad som saknas för fullständig containerkompatibilitet.

Den grundläggande mekaniken skulle vara:

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

Utdata visar vilka alternativ som är OK, vilka som saknas eller vilka som är felkonfigurerade. Om du hittar något kritiskt inaktiverat kan du köra det igen. Gör menuconfig o skapa xconfig, korrigera det, spara och upprepa verifieringen.

Intressanta förbättringar i de senaste kärnversionerna

Förutom anpassning kompilerar många nya versioner av kärnan för att Dra nytta av prestandaförbättringar och nya funktioner vilket fortfarande kommer att ta lite tid att nå paketen i din distribution.

Till exempel i rama 6.6 Förbättringar har nämnts såsom:

• Märkbar prestandaökning i EXT4, med ökningar på upp till 34 % vid vissa samtidiga skrivbelastningar.
• Förbättringar i GPU-stöd NVIDIA med hjälp av den kostnadsfria drivrutinen Nouveau, förbereder marken för NVK (Vulkan) föraren.
• Alternativ för konfigurera aspekter av BIOS från HP-utrustning direkt från Linux.
• Inställningar för klusterschemaläggning för hybridprocessorer Intel (Alder Lake, Raptor Lake och senare).
• Optimering av direkt asynkron I/O med io_uring, med prestandaökningar på cirka 37 % i vissa tester.
• En ny uppgiftsplanerare, EEVDF (Tidigast möjliga virtuella deadline först), vilket förbättrar CPU-allokeringen mellan processer.

Allt detta kommer "direkt ur lådan" i moderna versioner, men det kan ta tid för din distribution att paketera eller aktivera det, vilket är anledningen till att många tar till manuellt kompilera en nyare kärna.

Kompilera kärnan: make, moduler och kompileringstrådar

När du har konfigurationen som du vill ha den är det dags att sätta processorn igång. Det är här kommandona kommer in i bilden. göra Klassisk kärnkompilering. Kompileringen kan ta allt från några minuter till över en timme, beroende på hårdvaran och hur många moduler du genererar.

I huvudsak grundläggande flöde I Debian/Ubuntu (eller andra distributioner) är det vanligtvis:

• Kompilera kärnan (huvudavbildningen):
  make -j$(nproc)
  Eller, om du vill att den bara ska använda en kärna:
  make
• Kompilera och installera modulerna:
  sudo make modules_install

Alternativet -j$(nproc) Den anger att make ska använda så många parallella processer som din processor har kärnor, vilket sparar mycket tid på moderna maskiner. Om du ser fel under kompileringen måste du kontrollera dem vid den punkt där de misslyckas; de kan bero på saknade beroenden, motstridiga konfigurationer eller specifika buggar i den kärnversionen.

Några mer avancerade recept använder Debian-verktyget märke-kpkg och paketet kärnpaket att paketera kärnan i .deb-filer. Detta låter dig sedan installera och avinstallera den anpassade kärnan som om den bara vore ett annat paket, med något i stil med:

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

I det scenariot är det också vanligt att man stöter på fel relaterade till kärncertifikatMånga guider löser specifika problem genom att inaktivera betrodda nycklar i .config-filen med en rad som denna:

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

Installera den nyligen kompilerade kärnan och uppdatera bootloadern

Om du inte använder .deb-paketering och kör "uten omkull" med standardverktygen för kärnträdet, Installationen sker direkt från källkatalogenDen vanligaste sekvensen efter kompilering är:

• Installera modulerna (om du inte redan har gjort det):
  sudo make modules_install
• Installera kärnan:
  sudo make install

Kärnans eget skriptsystem kommer att kopiera binärfilen bzBild genereras till /boot, tillsammans med System.map och konfigurationsfilen. I Debian/Ubuntu utlöses skript vanligtvis i /etc/kernel/postinst.d som genererar initramfs och uppdatera boothanteraren (GRUB) automatiskt.

Ändå skadar det aldrig att uttryckligen utföra:

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

Med detta Du ser till att den initiala startavbildningen har återskapats korrekt. för den nya kärnversionen, och att GRUB tar hänsyn till det i sin meny. I andra distributioner, såsom vissa baserade på Red Hat, kan den användas mkinitrd o dracut istället för update-initramfs, men målet är detsamma: skapa en initrd/initramfs-avbildning som är lämplig för den nya kärnan.

Initrd/initramfs roll och potentiella problem

Initrd eller initramfs är en filsystemavbildning som laddas in i minnet mycket tidigt i startprocessenDen innehåller de minsta drivrutiner som krävs för att montera själva rotfilsystemet (till exempel stöd för SATA- eller NVMe-kontrollern där din /-partition finns).

Om din initrd genereras felaktigt eller inte innehåller de nödvändiga modulerna, kommer kärnan att starta men inte kunna monteras. / och du kommer att sluta med en kärnan panik klagar över att han inte kan hitta rot filsystem. Detta är ett typiskt fel när kritiska kärnalternativ är inaktiverade eller initramfs glöms bort efter att versioner har bytts.

I Debian/Ubuntu är referenskommandot idag uppdatering-initramfs:

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

Parameter -c skapar en ny bild, och -k indikerar den exakta kärnversionen. I äldre distributioner (eller med andra verktyg) användes den mkinitrd med liknande syntax:

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

I vilket fall som helst, om du efter att ha installerat din anpassade kärna ser fel relaterade till /lib/modules eller till att montera roten, Kontrollera först initramfs/initrd och GRUB-konfigurationen. innan du rör vid något annat.

Kontrollera att den nya kärnan fungerar korrekt

Med allt installerat och starthanteraren uppdaterad är det dags att starta om systemet för att testa det. Under uppstarten, övervaka GRUB- och kernel-startmeddelanden ifall fel uppstår från moduler, filsystem eller enheter som inte känns igen.

När du väl är inne i systemet kan du kontrollera vilken kärnversion du använder med:

uname -a

Utdata bör återspegla nykompilerad versionDärifrån handlar det om att testa dina vanliga tjänster: webbserver, databaser, hamnarbetare, virtuella maskinerskrivbordsprogram, etc. Om allt fungerar korrekt kan du lämna den kärnan som huvudkärna och behålla äldre versioner som säkerhetskopior.

Hur man återgår till en tidigare kärna och avinstallerar den nya

Om något går fel (vilket kan hända, särskilt de första gångerna), är det viktiga att Få inte panikSå länge din GRUB listar andra fungerande kärnor kan du återställa systemet utan alltför stora problem.

Processen typisk skulle:

1. Starta om systemet.
2. På GRUB-skärmen, navigera med pilarna och ange typavsnittet "Avancerade alternativ för…".
3. Välj en äldre kernelversion som du vet fungerade bra.
4. Starta med den kärnan och, när du är inne, fortsätt med att radera den problematiska kärnan.

Om du installerade kärnan manuellt, utan .deb-paket, innebär borttagningen vanligtvis radera motsvarande filer i /boot och /lib/modulesTill exempel, för att ta bort en 6.6.0 kan du göra:

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

Och sedan radera dess moduler:

cd /lib/modules
sudo rm -rf 6.6.0

När du är klar, uppdatera GRUB så att den inte längre erbjuder den kärnan i menyn och starta om:

sudo update-grub
sudo update-grub2
sudo reboot

Om du installerade kärnan paketerad som .deb är det renare. Använd det som vilket annat paket som helst Använd apt eller dpkg för att avinstallera det, så att systemets tillstånd hålls bättre under kontroll.

Anteckningar för andra distributioner: Fedora, CentOS och andra

Även om den här guiden fokuserar starkt på Debian/Ubuntu/Mint, är den allmänna logiken liknande i Red Hat-baserade distributioner som Fedora eller CentOS. Vilka ändringar är det pakethanteringsverktyg, några beroendenamn och hur man kommer åt starthanteraren.

I Fedora/CentOS, till exempel, kan ett grundläggande arbetsflöde för att kompilera en kärna från kernel.org vara:

• Installera utvecklingsverktygen:
  su -c 'yum groupinstall "Development Tools"'
su -c 'yum install ncurses-devel qt-devel unifdef'
• Ladda ner en stabil version (som 2.6.36 i de klassiska exemplen):
  cd /tmp
wget http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.36.tar.bz2
• Packa upp och förbered källkodsträdet:
  mkdir /usr/src/linux
tar -xjvf linux-2.6.36.tar.bz2 -C /usr/src/linux
cd /usr/src/linux
• Konfigurera kärnan med menuconfig, xconfig eller gconfig.
• Kompilera och installera:
  make
make modules
make modules_install
make install

Sedan måste du granska och redigera /boot/grub/grub.conf (eller motsvarande fil, beroende på om du använder GRUB Legacy, GRUB2, etc.) för att lägga till en post för den nya kärnan med motsvarande initrd, var noga med sökvägarna till root = och referenser till logiska volymer om du använder LVM.

Att kompilera, konfigurera och installera en anpassad Linuxkärna är en långdragen men otroligt lärorik process: den tvingar dig att förstå vilka moduler du behöver starta, vilka alternativ som är viktiga för dina tjänster (som Docker eller virtualisering), hur initramfs och GRUB är integrerade i startprocessen och hur du alltid har ett reservalternativ för att återgå till en tidigare kärna om något går fel. Om du tar dig tid att granska varje avsnitt, intelligent återanvänder din nuvarande kärnkonfiguration och vänjer dig vid att testa ändringar gradvis, kan du få ett verkligt kraftfullt system. mer optimerad, skräddarsydd för din hårdvara och i linje med dina verkliga behov än den som tillhandahålls av de generiska kärnorna i de flesta distributioner.