Senaste linux-kärnan. Bygger kärnan i Ubuntu. Steg-för-steg-instruktion. Var man laddar ner Linux-kärnan
Jag har länge velat skriva en artikel om hur man bygger Linux-kärnan. Och nu har detta ögonblick kommit.
Egentligen, varför bygga en kärna om distributionen ger en perfekt användbar kärna?
Till exempel, för att använda de senaste drivrutinerna och lösningarna i den nya kärnan, när endast den gamla grenen är tillgänglig från distributionen. Också till exempel att anpassa den för din hårdvara och påskynda arbetet lite. Jag gjorde 3.11 för mig själv, eftersom den innehåller en uppsättning patchar som förbättrar arbetet med ATI-grafikkort, och jag är ägare till ett av dem.
Det har skrivits en hel del artiklar om montering av kärnan, så jag går inte in på detaljer, utan skriver bara hur jag monterar kärnan för mig själv.
Först och främst måste du hämta arkivet med källkoderna för den önskade versionen av Linux-kärnan.
På webbplatsen https://www.kernel.org/ kan du ladda ner önskad version. Jag kommer att beskriva bygg- och installationsprocessen med version 3.11.0 som exempel.
Det är tillrådligt att bygga kärnan i en katalog speciellt skapad för detta ändamål under en oprivilegierad användare. Jag kompilerar i en mapp ~src/linux/linux-version
Innan du kompilerar bör du se till att alla beroenden som krävs för att bygga är installerade och att det finns cirka 3 GB ledigt utrymme i kompileringskatalogen.
Här är en lista över paket som ska kompileras framgångsrikt (för Debian/Ubuntu):
gcc, göra- Nödvändiga monterings- och länkverktyg. Helst en av de senaste tillgängliga gcc-versionerna.
libncurses5-dev- behövs för att menuconfig ska fungera
ccache- gör att du kan påskynda återmonteringen
Om du vill använda den grafiska kärnkonfiguratorn bör du även installera paket för QT-utveckling, till exempel libqt4-dev, g++, pkg-config.
Lzop, lz4c- om du är intresserad av alternativa kärn- och initramfs-komprimeringsmekanismer.
Den aktuella katalogen antas vara katalogen för den uppackade kärnan.
Efter att byggmiljön har förberetts måste kärnkonfigurationen genereras. Den aktuella konfigurationen kan ses så här:
Cat /boot/config-`uname -r`
Zcat /proc/config.gz
I princip kan du använda den aktuella konfigurationen genom att redigera den i något av konfigurationsprogrammen. Kopiera den till katalogen där arkivet med kärnan packas upp och byt namn på det till .config
cp /boot/config-`uname -r` .config
Jag gillar xconfig, jag tycker att det är det mest bekväma.
Gör xconfig
Tidigare kopierade laddas automatiskt .config, som fungerar som vår bas för konfigurationen. Det finns många tips för att sätta upp kärnan, jag rekommenderar bara att välja din processorversion, inaktivera hårdvarudrivrutiner som inte finns där, du kan även välja ytterligare moduler, som zram och komprimeringsalgoritmen, jag valde lz4 som snabbast.
När du har sparat konfigurationen kan du börja kompilera.
Om du är för lat för att konfigurera kärnan manuellt är det möjligt att automatiskt konfigurera med hjälp av information om laddade moduler: make localmodconfig
Nu är det andra huvudsteget att kompilera kärnan och modulerna. Utförs i ett kommando:
Gör -j4 CC="ccache gcc" bzImage-moduler
Var -j4 motsvarar antalet processorkärnor i din konfiguration.
Kompileringen tar inte lång tid om hårdvaran är tillräckligt kraftfull och distributionskärnan inte används. På min bärbara dator med en AMD Phenom P820-processor och sex gigabyte RAM tar kompileringen ungefär en halvtimme.
Det sista steget är att installera kärnan och modulerna.
Sudo sed -i.bak "s/MODULES=most/MODULES=dep/" /etc/initramfs-tools/initramfs.conf
Detta är nödvändigt för att minska storleken på initrd-filen genom att endast inkludera de moduler som krävs för att ladda.
Installationen kan också göras med ett kommando:
sudo gör modules_install installera
Eller installera allt manuellt. Moduler först
sudo gör modules_install
Sedan kärnan
Version=`awk "NR<=3 {printf "%s.",$NF}" < Makefile | sed "s/\.$//"`
så här får vi kärnversionen från Makefilen
sudo cp arch/`uname -m`/boot/bzImage /boot/vmlinuz-$version sudo cp .config /boot/config-$version sudo cp System.map /boot/System.map-$version sudo update-initramfs - c -k $version sudo update-grub
Slutligen bifogar jag ett skript för att automatisera processen.
Under konfigurationen av konfigurationen kan han ställa ett par frågor, för att svara som standard behöver du bara trycka på Enter.
Glad sammanställning.
Varför skulle någon vilja kompilera en ny kärna? Det är ofta inte nödvändigt eftersom standardkärnan som levereras med Debian hanterar de flesta konfigurationer. Dessutom erbjuder Debian ofta flera alternativa kärnor. Så du kanske vill kontrollera först om det finns ett alternativt kärnavbildningspaket som bättre motsvarar din hårdvara. Det kan dock vara användbart att kompilera en ny kärna för att:
Var inte rädd för att försöka kompilera kärnan. Det är roligt och lönsamt.
För att kompilera en kärna på Debians sätt behöver du några paket: , och några andra som förmodligen redan är installerade (se för hela listan).
Den här metoden kommer att göra en .deb av din kärnkälla, och, om du har icke-standardiserade moduler, göra en synkroniserad beroende .deb av dessa också. Det är ett bättre sätt att hantera kärnavbildningar; kommer att hålla kärnan, System.map och en logg över den aktiva konfigurationsfilen för bygget.
Observera att du inte gör det ha att kompilera din kärna på "Debian-sätt"; men vi tycker att det är säkrare och enklare att använda paketeringssystemet för att hantera din kärna. Faktum är att du kan hämta dina kärnkällor direkt från Linus istället för , men ändå använda kompileringsmetoden.
Observera att du hittar fullständig dokumentation om hur du använder under . Det här avsnittet innehåller bara en kort handledning.
Härefter kommer vi att anta att du har fria händer över din maskin och kommer att extrahera din kärnkälla till någonstans i din hemkatalog. Vi antar också att din kärnversion är 3.16. Se till att du är i katalogen där du vill packa upp kärnkällorna, extrahera dem med och byt till den katalog som kommer att ha skapats.
Nu kan du konfigurera din kärna. Kör om X11 är installerad, konfigurerad och körs; kör annars (du måste installeras). Ta dig tid att läsa onlinehjälpen och välj noga. När du är osäker är det vanligtvis bättre att inkludera enhetsdrivrutinen (mjukvaran som hanterar kringutrustning, såsom Ethernet-kort, SCSI-kontroller och så vidare) du är osäker på. Var försiktig: andra alternativ, som inte är relaterade till en specifik hårdvara, bör lämnas på standardvärdet om du inte förstår dem. Glöm inte att välja "Kernel modul loader" i "Loadable modul support" (det är inte valt som standard). Om den inte ingår kommer din Debian-installation att få problem.
Rengör källträdet och återställ parametrarna. För att göra det, gör.
Kompilera nu kärnan: . Versionsnumret för "1.0" kan ändras efter behag; detta är bara ett versionsnummer som du kommer att använda för att spåra dina kärnbyggen. På samma sätt kan du sätta vilket ord du vill i stället för "anpassat" (t.ex. ett värdnamn). Kärnkompilering kan ta ganska lång tid, beroende på din maskins kraft.
När kompileringen är klar kan du installera din anpassade kärna som vilket paket som helst. Som rot, gör . Delen är en valfri underarkitektur, beroende på vilka kärnalternativ du ställer in. kommer att installera kärnan, tillsammans med några andra trevliga stödfiler. Till exempel kommer programmet att installeras korrekt (användbart för felsökning av kärnproblem) och kommer att installeras med din nuvarande konfigurationsuppsättning. Ditt nya kärnpaket är också smart nog att automatiskt uppdatera din starthanterare för att använda den nya kärnan. Om du har skapat ett modulpaket måste du installera det paketet också.
Det är dags att starta om systemet: läs noggrant alla varningar som steget ovan kan ha orsakat, sedan .
För mer information om Debians kärnor och kärnkompilering, se Debian Linux Kernel Handbook. För mer information om , läs den fina dokumentationen i .
Om du kommer ihåg, för inte så länge sedan lärde vi oss hur man bygger FreeBSD-kärnan från källkod. Frågan är, varför inte lära sig att göra samma sak med Linux-kärnan? Anledningarna till att bygga Linux-kärnan från källkod är i allmänhet desamma - att få den senaste versionen av kärnan, brådskande applicera säkerhetskorrigeringar, optimera för specifika uppgifter och specifik hårdvara, såväl som önskan att delta i kärnans utveckling, även i rollen som QA.
Viktig! Att följa instruktionerna i det här inlägget kan leda till att dina data går förlorade. Gör säkerhetskopior och kom ihåg att du gör allt på egen risk och risk. Allt som beskrivs nedan har testats på Ubuntu 14.04 LTS. Men på andra versioner av Ubuntu, såväl som andra Linux-distributioner, bör skillnaderna vara minimala.
Konfigurera starthanteraren
Redigera /etc/default/grub så här:
GRUB_DEFAULT=0
#GRUB_HIDDEN_TIMEOUT=10
#GRUB_HIDDEN_TIMEOUT_QUIET=sant
GRUB_TIMEOUT=10
GRUB_DISTRIBUTOR=`lsb_release -i-s2>/dev/null ||echo Debian`
GRUB_CMDLINE_LINUX_DEFAULT="tyst plask"
GRUB_CMDLINE_LINUX=""
Efter redigering säger vi:
sudo update-grub
Som ett resultat, innan systemet startar, kommer du att uppmanas i 10 sekunder att välja kärnan som du vill starta upp med. Mycket praktiskt om du trasslat till med din kärnkonfiguration och vill starta med en tidigare version!
Installera beroenden
Vi kommer att behöva åtminstone följande paket:
sudoapt-get installgitgccmakebc fakeroot dpkg-dev\
libncurses5-dev libssl-dev
På många system kommer alla dock redan att finnas.
Få källan
wget https://www.kernel.org/pub/linux/kernel/v4.x/linux-4.6.4.tar.xz
tar-xz-xvf linux-4.6.4.tar.xz
cd linux-4.6.4
Eller, om du vill ha det allra senaste, kan du hämta källan direkt från Git:
# Spegel: https://github.com/torvalds/linux
git clone'git://git.kernel.org/pub/scm/linux/kernel/git/'\
'torvalds/linux.git'
cd linux
Att döma av det faktum att jag inte kunde hitta v4.6.4-taggen i Git, så görs Linux-kärnutgåvor uteslutande i form av komprimerade tar-arkiv.
Om du istället för en vaniljkärna skulle vilja bygga en kärna med patchar från Canonical:
git-klon git://kernel.ubuntu.com/ubuntu/ubuntu-trusty.git
cd ubuntu-trusty
git tag|mindre
git checkout Ubuntu-lts-4.4.0-31.50_14.04.1
Av min egen erfarenhet, om du använder Ubuntu, kan du säkert använda vaniljkärnan. Det är osannolikt att du kommer att ha några problem med det.
Notera: Intressant nog, av de befintliga relativt populära Linux-distributionerna, verkar bara Gentoo, Slackware och Arch Linux använda en kärna utan sina egna patchar.
Hur som helst, nu har du källkoden.
Kompilera och installera kärnan
Välj de alternativ som kärnan ska byggas med:
Om det behövs, ändra inställningarna, klicka på Spara och sedan på Avsluta. Som ett resultat kommer en fil som innehåller de parametrar vi valt att skapas.
På uppdatering kärna (använder du redan någon form av kärna ändå?) Det är bekvämt att ta konfigurationen för den nuvarande kärnan och ställa in de nya alternativen till deras standardvärden:
zcat/proc/config.gz > ./.config
gör olddefconfig
Till sist samlar vi in:
make-j4 bindeb-pkg LOCALVERSION=-custom
Kärnan är monterad under ganska lång tid. På min bärbara dator tog monteringen 1 timme och 15 minuter. Dock från denna tid handla om Resten går åt till att bygga ett gigantiskt kärnpaket med felsökningssymboler.
Manuell konstruktion och konfiguration av Linux-kärnan
Sammansättningen av detta paket kan inaktiveras genom att kommentera parametern CONFIG_DEBUG_INFO i konfigurationen. Tänk bara på att det här paketet krävs av SystemTap och andra användbara verktyg.
Förutom själva kärnan kan du också samla in dokumentation:
# det finns också `make pdfdocs` och andra, se `make help`
göra htmldocs
chromium-browser Documentation/DocBook/index.html
Efter avslutad montering dotterföretag katalog ser vi något som:
linux-firmware-image-4.4.13-custom_4.4.13-custom-1_amd64.deb
linux-headers-4.4.13-custom_4.4.13-custom-1_amd64.deb
linux-image-4.4.13-custom_4.4.13-custom-1_amd64.deb
linux-image-4.4.13-custom-dbg_4.4.13-custom-1_amd64.deb
linux-libc-dev_4.4.13-custom-1_amd64.deb
Vi lägger alla deb-paket utom dbg-versionen av kärnan med de vanliga och startar om. Efter omstart tittar vi på resultatet av kommandot. Vi ser till att vi verkligen startade med den nya kärnan. Om något är fel med den nya kärnan väljer vi i bootloadern helt enkelt den som systemet startades med tidigare. Efter att ha startat upp med den gamla kärnan tar vi snabbt bort paketen för den nya kärnan, och voila - systemet återgick till sitt tidigare tillstånd.
Dessutom, efter att ha laddat en ny kärna, kan du köra tester på den:
sudomake kselftest
sudomake kselftest-clean
Grattis, du vet nu hur man bygger Linux-kärnan!
Slutsats
Material på Linux-kärnan:s interna delar:
- KernelNewbies.org, en sida för nybörjare till Linux-kärnan med sin egen e-postlista, IRC-kanal, forum, wiki och mer;
- LKML.org, en webbplats för bekväm läsning av e-postlistan för Linux-kärnutvecklare via en webbläsare. Var försiktig, det förstör ofta formateringen av bokstäver! I denna mening är e-postlistarkivet på marc.info mycket bättre;
- Linux Cross Reference, en webbplats för bekväm läsning av Linux-kärnkod via en webbläsare;
- Boken Linux Kernel Development, 3rd Edition är den senaste boken om Linux-kärnan på engelska (2010, kernel 2.6.x), det finns en översättning till ryska;
- Boken Linux-Treiber entwickeln, 4th Edition är nyare (2015, kärna 4.x), men är skriven på tyska och har ingen översättning;
- Den kostnadsfria Linux Insides-boken av Alexander Kuleshov a.k.a @0xAX ser ut att vara den mest tillgängliga och uppdaterade, men håller för närvarande på att skrivas;
- Ibland kan du hitta något användbart i Linux Kernel HTML Documentation, den officiella dokumentationen från Linux-kärnans källor;
- Exempel på boken Linux Device Drivers, 3rd Edition, som försöker hålla sig uppdaterad, plus källor för den 4:e upplagan, som för närvarande skrivs;
Bygger du kärnan från källkod, och i så fall varför? 🙂
Tillägg: Du kanske också är intresserad av artikeln The Scandalous Truth About Debugging Kernel Code på Linux.
Taggar: Linux, Ring0.
Kompilera Linux-kärnan
Hur bygger man en linuxkärna? Bygga Linux-kärnanSå, om du fortfarande behöver ha din egen kärna, låt oss börja kompilera!
Om du redan har en X-server (hemdator) installerad kan du gå till webbplatsen i din favoritwebbläsare och ladda ner den önskade versionen i ett tar.gz (gzip-komprimerat) arkiv. Om du arbetar i konsolen (till exempel har du inte installerat X-servern ännu eller håller på att konfigurera servern) kan du använda en textwebbläsare (till exempel elinks). Du kan också använda standard wget-nedladdningshanteraren:
Kärnkonfiguration.
Kompilering.
|
maj 2017
mars 2017
april 2016
mars 2016
Oktober 2013
september 2013
Maj 2013
mars 2013
november 2012
juli 2012
juni 2012
april 2012
mars 2012
februari 2012
april 2011
mars 2011
februari 2011
januari 2011
december 2010
november 2010
oktober 2010
september 2010
augusti 2010
juli 2010
juni 2010
maj 2010
april 2010
mars 2010
Slumpmässig:
Stellarium virtuellt planetarium: en översikt över nya funktioner
BOINC: datorer för vetenskap
Gambas: Grundläggande utveckling på linux
SSH 2.0 seriella diagram
Linuxnow.ru: Planer för framtiden
Får du plötsligt slut på ledigt diskutrymme? Kanske ligger problemet i loggarna.
Kollegor: alla
Linux för alla
Våra banners: 
Ställ in banner
Linux-kärnkonfiguration
Kontrollerar källkodspaket
Omkompilering av en kärna kräver dess källor.
Blogg om systemadministration. Artiklar om Linux, Windows, NetApp-lagring och virtualisering.
Red Hat placerar kärnkällorna i ett enda rpm-paket, men är inte installerat som standard. Namnet på detta paket:
kernel-source-2.4.2-2.1386.rpm
Förutom källkoden, för att kompilera om kärnan, behöver du en kompilator som består av två komponenter:
göra nytta;
kompilatorn för själva C-språket är gcc eller egcs.
Att skapa en säkerhetskopia av den aktuella kärnan utförs i tre steg:
1. Skapa en säkerhetskopia av kärnkällorna, vilket gör att du kan återställa den om konfigurationen är skadad.
2. Skapa en säkerhetskopia av själva kärnan som ett känt arbetssätt för att starta systemet.
3. Skapande av en ny post för operativsystemets loader, som kan användas för att starta från kärnans backup.
Att skapa en källsäkerhetskopia görs genom att kopiera kärnans källkatalog till disken. Återställning görs genom att kopiera i motsatt riktning.
När kärnan kompileras om skrivs den gamla kärnan till en fil med filtillägget .old. Denna kopia av kärnan kan dock ännu inte användas för att starta upp systemet. Detta förklarar behovet av att utföra ovanstående operationer.
Operativsystemladdaren av LILO-typ, som vanligtvis används för att starta upp Linux, konfigureras genom att länka till en kärnfil i rotfilsystemet.
Efter att ha säkerhetskopierat kärnan måste du lägga till ytterligare en post i filen /etc/lilo.conf för att du ska kunna starta Linux med den gamla kärnan:
öppna filen /etc/lilo. conf i en textredigerare
skapa en kopia av hela partitionen;
ändra två positioner i kopian:
ersätt kärnfilens namn med namnet på dess säkerhetskopia (tillsammans med tillägget);
ersätt partitionsetiketten med något som linux. original (original Linux) eller linux-föregående (gammal Linux).
linjer som börjar med initrd bör ersättas med lämpliga reservdelar, såsom initrd-2 .4.2-2. ursprung. img;
skriv ändringar till /etc/lilo. konf.
skriv in kommandot /sbin/lilo för att ange en ny post i starthanteraren. När du kör kommandot lilo, visas etiketterna för bilderna som matats in i operativsystemets starthanterare på skärmen.
Nästa gång systemet startas om, kommer det nya kärn-ID:t att visas i LILO-starthanterarens verktygstips.
Konfigurera en ny kärna
Konfiguration avgör vilka funktioner som ska inkluderas i kärnan, vilka som inte ska inkluderas, och så vidare. Du kan välja mellan att konfigurera en gammal kärna och att installera/konfigurera en ny. Om du till exempel använder Red Hat Linux 7.1 kan du konfigurera om en befintlig 2.4.2-kärna med nya alternativ. Du kan också ladda ner och installera den nya 2.4.4-kärnan. Även om konfigurationsdetaljerna är olika i de två fallen, är de använda verktygen och själva konfigurationsmetoden desamma.
Linux har tre separata konfigurationsverktyg, alla med sina egna egenskaper.
Ett verktyg med ett kommandoradsgränssnitt. Användaren svarar konsekvent på frågor om de funktioner som måste inkluderas i kärnan. Det här verktyget är användbart för de som vet hur man arbetar med kärnan, och för de som har konfigurationsskript för det här verktyget.
Verktyg med textlägesmeny. Flernivåmenyn i detta verktyg låter dig ställa in och installera om kärnparametrar i valfri ordning.
GUI-verktyg. Detta är det mest attraktiva verktyget, men det körs bara på det grafiska X Window System.
De listade verktygen skapar samma konfigurationsfil som används av make-verktyget vid kompilering av hela eller partiella kärnor.
Kärnalternativ
När du tittar på parametrar i något konfigurationsprogram (kommandorad, textbaserat eller grafiskt gränssnitt) är det nödvändigt att vara tydlig med hur dessa parametrar påverkar driften av kärnan.
Identifieringen av parametrar i varje program är olika, men i alla tre presenteras samma uppsättning av dem. Parametrarna är indelade i två huvudgrupper:
modul;
icke-modulär.
Om programblocket som motsvarar denna parameter inte laddas som en kärnmodul kan det vara en av två saker:
[*] en integrerad del av kärnan;
En integrerad del av kärnan.
Tecknen inom hakparenteser (tillsammans med parenteser) motsvarar alternativetiketter i menyn för konfigurationsprogram (förutom kommandoradsverktyget).
För modulära parametrar finns det tre alternativ för inställning (enligt deras representation i menyn för konfigurationsverktyg):
<>ingår inte i kärnan och skapas inte som en modul som kan laddas senare:
<*>ingår i kärnan, så det finns inget behov av att ladda den senare som en modul:
<М>Ingår som en modul, men inte som en del av kärnan. Ett block kan installeras eller tas bort från kärnan när som helst.
Ibland kan värdet på en parameter inte ändras förrän en annan parameter har ställts in. Till exempel kan du installera stöd för en specifik SCSI-enhet först efter att du har aktiverat stöd för dessa enheter i allmänhet.
När de nödvändiga verktygen (make-verktyget och gcc-kompilatorn) och källtexter är installerade på systemet, kan du köra ett av konfigurationsverktygen och börja konfigurera kärnan.
GUI-konfigurator
Start av konfigurationsverktyget med ett grafiskt gränssnitt utförs i följande sekvens.
Starta ett X Windows-system (med valfri grafisk miljö och skrivbord).
Öppna ett terminalemulatorfönster (kommandoradsfönster).
Som med lanseringen av det tidigare verktyget kommer flera meddelanden om kompileringen av verktyget att blinka på skärmen, och efter några minuter öppnas huvudfönstret.
Ris. 8. Kärnkonfigurationsverktyg med ett grafiskt gränssnitt: menyknappar för att ställa in parametervärden
Det grafiska verktyget skiljer sig inte så mycket från verktyget menuconf ig. Här är alternativen också kategoriserade; genom att klicka på en viss kategori öppnas en dialogruta med en lista med alternativ, som vart och ett kan ställas in på ett värde som avgör om motsvarande verktyg ska användas som en del av kärnan, som en laddningsbar modul eller inte alls.
En sådan dialogruta visas i fig.
Ris. 9. Dialogrutor som denna anger kärnkonfigurationsalternativ
2.4.2-kärnan i Red Hat Linux stöder som standard den symmetriska flerprocessorarkitekturen. Du måste ställa in motsvarande alternativ på n om din dator bara har en processor.
Till höger om varje alternativ finns en hjälpknapp.
En stor fördel med det grafiska konfigurationsverktyget (särskilt för förstagångskärnkonfiguratorer) är att menyn visar beroenden mellan olika alternativ. Till exempel, i avsnittet Blockera enheter kan du inte installera RAID-stöd inbyggt i kärnan förrän alternativet Stöd för flera enhetsdrivrutiner är aktiverat.
Om i menuconfig-verktyget parametrarnas beroende av varandra visas genom indragningen av parameternamn i menyn, är det helt enkelt omöjligt att ställa in otillåtna kombinationer av parametrar i det grafiska verktyget. Att arbeta med det grafiska verktyget hjälper till att förstå beroenden mellan olika moduler.
I slutet av huvudmenyn för det grafiska verktyget finns kommandon som liknar motsvarande verktygskommandon från textlägesmenyn.
Spara och avsluta (Avsluta med att spara). Skapar en kärnkonfigurationsfil och stänger av verktyget.
Avsluta utan att spara. Stänger av verktyget utan att skapa en kärnkonfigurationsfil.
Utan att skapa en kärnkonfigurationsfil med ett av de listade verktygen är det inte möjligt att kompilera om kärnan.
Ladda konfiguration från fil. Laddar den tidigare skapade konfigurationsfilen.
Lagra konfiguration till fil. Skriva konfigurationsdata till en fil med det angivna namnet (för vidare användning eller överföring till en kollega). Detta påverkar inte behovet av att köra kommandot Save and Exit, som skapar en konfigurationsfil för att kompilera om kärnan.
Kompilera och köra en ny kärna
När konfigurationen är klar måste du leta efter en ny konfigurationsfil (.config) som finns i katalogen /usr/src/linux-2 .4.2 (beroende på versionsnumret). Om .config-konfigurationsfilen finns på plats kan du använda kommandot make för att kompilera om kärnan.
Normalt tar omkompilering av kärnor från 15 minuter till flera timmar. Det beror på processorns hastighet, mängden RAM och ett antal andra faktorer, så det är bekvämt att kombinera alla kommandon som angavs under kompileringen till ett, separerat med semikolon, så att de exekveras sekventiellt.
Startar omkompileringsprocessen
Kommandona nedan är designade för att skapa en ny kärna genom att kompilera om alla dess moduler och skriva dem till lämpliga systemkataloger. (Där kommer de att vara tillgängliga för kärnkommandon.)
För att kompilera om systemet kommer följande kommandon att anges.
# gör dep; göra rent; göra bzlmage; göra moduler; göra modules_install
Varje make-kommando kan anges separat, efter att det föregående har slutförts.
Efter att ha angett dessa kommandon kommer rader att blinka på skärmen som beskriver katalogerna som nås av make-programmet, lanseringen av gcc-kompilatorn. för att kompilera olika källfiler och länka olika block. Vart och ett av dessa kommandon kommer att ta flera minuter att slutföra.
Du kan nu skapa en startdiskett för den nya kärnan med kommandot
Innan du utför detta kommando måste du sätta in en formaterad diskett i enheten. Den färdiga startskivan måste testas. Starta om datorn utan att ta bort disketten från enheten.
Efter att ha kört kärnkompileringskommandona och återgått till kommandoraden skapas en ny kärna. För att starta upp ett system med en ny kärna måste det flyttas till standardkatalogen från vilket det kommer att köras. Detta görs genom att ange kommandot
# cf /usr/src/linux-2.4.2/arch/i386/boot/bzlmage /boot/vmlinuz-2.4.2-2
Slutligen, för att uppdatera startkartan, kör kommandot lilo:
Du kan ange ett versionsnummer i namnet på kärnavbildningen som ska kopieras. Det är viktigt att namnet på den här filen matchar namnet som anges i filen /etc/lilo.conf.
Testar en ny kärna
Efter att ha flyttat den nya kärnfilen till standardkatalogen (specificerad i lilo.conf-filen), kan systemet startas om med denna kärna.
Omedelbart efter omstarten, kontrollera funktionen för de nya verktygen för vilka omkompileringen startades. Du kan göra följande.
Jämförelse av volymerna för gamla och nya kärnor. Du bör kontrollera mängden minne som upptas av operativsystemet genom att utfärda kommandot ledigt.
Montering av ett filsystem eller försök att komma åt en enhet utan att ladda en kärnmodul för att stödja den (om stöd för den enheten är inbyggt i kärnan).
Använda nätverksresurser (som IP-alias) som inte fanns i den gamla kärnan.
Det kan vara nödvändigt att kontrollera tidsstämpeln för den aktuella kärnfilen. För att göra detta, ange kommandot uname. Detta låter dig se till att systemet för närvarande körs med den omkompilerade kärnan. Tidsstämpeln och datumet för kärnan måste matcha tiden då den kompilerades om.
Om svaret från kommandot uname indikerar att systemet inte startades med den nya kärnan, titta in i LILO bootloader. Kontrollera om namnet på den startbara kärnan är korrekt i filen /etc/lilo.conf.
VISA MER:
Kompilera och installera Linux-kärnan från Source i Debian
Material från Bryansk Linux Users Group och www.rm.pp.ru
Varje distribution har sin egen kärnbyggespecifikation, och den här artikeln fokuserar på exakt hur man gör detta i Debian Etch. Det avslöjar också frågan om hur man applicerar den eller den korrigeringen på kärnan när det är nödvändigt att stödja viss funktionalitet eller ny hårdvara i ditt system. Artikeln är främst avsedd för mer avancerade användare och det finns inga garantier för att denna metod kommer att fungera som den ska och alla beskrivna åtgärder och ansvar faller på dig.
- Notera
- Metod ett. Bygga in kärnan i .deb-paket
- Applicera plåster
- Kärnkonfiguration
- Kompilerar kärnan
- Installerar en ny kärna
- Metod två. "traditionellt" sätt
- Problem
- Länkar
Notera
Två metoder för att bygga kärnan kommer att beskrivas. Byggvarianten av .deb-paketen som kan installeras på ditt eller ett annat system kommer att beskrivas först.
Den andra metoden är det så kallade "traditionella" sättet.
Metod ett. Bygga in kärnan i .deb-paket
Installerar de nödvändiga paketen för att kompilera kärnan
Låt oss först uppdatera paketlistorna:
# apt-get update
Installera paketen vi behöver:
# apt-get install kernel-package libncurses5-dev fakeroot wget bzip2 build-essential
Laddar ner kärnkällorna
Gå till katalogen /usr/src, gå till www.kernel.org och välj önskad kärnversion. I det här fallet kommer versionen linux-2.6.23.1.tar.bz2 att övervägas. Laddar ner:
# cd /usr/src # wget http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.23.1.tar.bz2
Packa upp källorna och skapa en symbolisk länk:
# tar xjf linux-2.6.23.1.tar.bz2 # rm linux (ta bort föregående symbollänk) # ln -s linux-2.6.23.1 linux # cd /usr/src/linux
Applicera plåster
Valfritt och gör inte detta i onödan!
Ibland krävs drivrutiner eller funktioner som inte stöds i den aktuella kärnan, såsom virtualiseringsteknik eller andra detaljer som inte finns i den aktuella versionen. Detta korrigeras i alla fall genom att applicera så kallade plåster (om några).
Så låt oss säga att du har laddat ner den nödvändiga patchen (låt oss kalla den patch.bz2 till exempel) till /usr/src. Applicera den nedladdade patchen på våra källor (du bör fortfarande vara i katalogen /usr/src/linux):
# bzip2 -dc /usr/src/patch.bz2 | patch -p1 --dry-run # bzip2 -dc /usr/src/patch.bz2 | patch-p1
Det första kommandot är bara ett test och inga ändringar kommer att tillämpas på källorna. Om inga fel returnerades efter det första kommandot, kan du köra det andra kommandot för att applicera patchen. Utför inte i något fall det andra kommandot om fel har utfärdats efter det första!
På så sätt kan du applicera patchar på kärnkällor. Till exempel finns det vissa funktioner som bara är tillgängliga i 2.6.23.8-kärnan, och källorna innehöll inte den nödvändiga funktionaliteten, men patch-2.6.23.8.bz2 släpptes. Du kan applicera den här patchen till 2.6.23 kärnkällor, men inte 2.6.23.1 eller 2.6.23.3, etc. Du kan läsa mer om detta på:
Prefix (prepatches) - motsvarande alfa-releaser; patchar måste appliceras på källor för en fullständig tidigare version med en 3-siffrig version (till exempel kan patch 2.6.12-rc4 appliceras på källor för version 2.6.11, men inte på version 2.6.11.10.)
Det betyder att om vi vill bygga 2.6.23.8-kärnan måste vi ladda ner källorna för version 2.6.23 (http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6. 23.tar.gz) tillämpas på det andra sättet "traditionellt" sätt!
Applicera patch-2.6.23.8.bz2 på kärnan 2.6.23:
# cd /usr/src # wget http://www.kernel.org/pub/linux/kernel/v2.6/patch-2.6.22.8.bz2 # cd /usr/src/linux # bzip2 -dc /usr/ src/patch-2.6.23.8.bz2 | patch -p1 --dry-run # bzip2 -dc /usr/src/patch-2.6.23.8.bz2 | patch-p1
Kärnkonfiguration
Det är en bra idé att använda den befintliga konfigurationsfilen för den körande kärnan för den nya också. Därför kopierar vi den befintliga konfigurationen till /usr/src/linux:
# gör rent && gör mrproper # cp /boot/config-`uname -r` ./.config
# gör menuconfig
varefter den grafiska kärnans konfigurationsmeny kommer att laddas. Välj "Ladda en alternativ konfigurationsfil" i konfiguratormenyn och klicka på "OK". Gör sedan (om så krävs) de nödvändiga ändringarna av kärnkonfigurationen genom att navigera genom menyerna (information om kärnkonfigurationen finns på www.google.com ). När du är klar och trycker på "Avsluta", kommer frågan "Vill du spara din nya kärnkonfiguration?" att ställas, vi svarar jakande "Ja".
Bygga Linux-kärnan
Kompilerar kärnan
Att bygga kärnan görs med bara två kommandon:
# make-kpkg clean # fakeroot make-kpkg --initrd --append-to-version=-cybermind kernel_image kernel_headers
Efter --append-to-version= kan du skriva vilket namn du vill, men det måste börja med ett minustecken (-) och inte ha mellanslag.
Processen att kompilera och bygga .deb-paket kan ta ganska lång tid. Allt kommer att bero på konfigurationen av kärnan och kapaciteten hos din processor.
Lösa problemet med att skapa initrd.img
Nyligen dök en bugg upp i Debian, som består i att efter installation av paket med kärnor byggda på det sätt som beskrivs här, skapas inte filen /boot/initrd.img som motsvarar dem. För att fixa en redan installerad kärna måste du skapa initrd.img manuellt:
update-initramfs -c -k<полная-версия-ядра>
För att lösa problemet "för framtiden" - kommentera, som visas, den andra av raderna som citeras nedan i filen /etc/kernel/postinst.d/initramfs-tools:
# kernel-package skickar en extra arg; hacka för att inte köras under kärnpaketet #[ -z "$2" ] || avsluta 0
Installerar en ny kärna
När kärnbygget är klart kommer två .deb-paket att skapas i katalogen /usr/src:
# cd /usr/src # ls -l
linux-image-2.6.23.1-cybermind_2.6.23.1-cybermind-10.00.Custom_i386.deb - själva kärnan och linux-headers-2.6.23.1-cybermind_2.6.23.1-cybermind-10.00.Customers.b -3 head8 kerndes. behövs för att bygga andra moduler (till exempel när du bygger nVidia-drivrutinsmoduler). Installera dem:
# dpkg -i linux-image-2.6.23.1-cybermind_2.6.23.1-cybermind-10.00.Custom_i386.deb # dpkg -i linux-headers-2.6.23.1-cybermind_2.6.23.1-cybermind-10_deb.i.8Custom.i.
(Dessa paket kan nu installeras på ett annat system utan att behöva bygga dem igen.)
Allt, installationen är klar, bootloader-menyn, installationen av en ny RAM-disk och kärnan kommer att göras automatiskt. Det återstår bara att starta om:
Metod två. "traditionellt" sätt
Vi utför alla punkter som beskrivs ovan INNAN punkten "Kompilerar kärnan".
# gör alla # gör modules_install # gör installera
Som vanligt kan bygget ta lång tid, beroende på kärnans konfiguration och processorkapacitet.
Den största nackdelen med denna metod är att om du ofta uppdaterar kärnor, kommer efter ett tag ett stort antal av dem att samlas och du kommer att vilja ta bort oanvända. För att göra det enklare kan du bygga kärnan och andra filer som är installerade i systemet med kommandona "make modules_install" och "make install" till ett deb-paket (eller snarare två som börjar från kärnan 2.6.27) som det första metod, men vi kommer att använda här med kärnskript:
# gör alla # gör deb-pkg
Två .deb-filer kommer att visas i katalogen en nivå ovanför källkatalogen. Jag kompilerade kärnan i katalogen /usr/src/linux-2.6.27.10 och jag fick filer i katalogen /usr/src/
# linux-2.6.27.10_2.6.27.10-1_amd64.deb # linux-firmware-image_2.6.27.10-1_all.deb
Kärnan installeras med kommandot
# dpkg -i linux-2.6.27.10_2.6.27.10-1_amd64.deb
Gamla kärnor kan tas bort till exempel från synaptiska
Nästa steg
Kärnan är byggd och installerad, men nu måste du skapa en RAM-disk (utan vilken kärnan helt enkelt inte kommer att starta) och du behöver uppdatera GRUB-starthanteraren. För att göra detta, gör följande:
# depmod 2.6.23.1 # apt-get install yaird
Installera RAM-disken:
# mkinitrd.yaird -o /boot/initrd.img-2.6.23.1 2.6.23.1
Låt oss uppdatera bootloadern enkelt och smärtfritt:
Allt, starthanteraren och den nya kärnan är redo, det återstår bara att starta om:
Problem
Om din valda nya kärna inte startar efter en omstart, starta om och välj din tidigare kärna och du kan försöka göra hela processen igen för att bygga en fungerande kärna. I det här fallet, glöm inte att ta bort raderna i den icke-fungerande kärnan i /boot/grub/menu.lst.
Kompilera Linux-kärnanVarför kompilera kärnan själv överhuvudtaget? Det är också möjligt att aktivera stöd för mer än 4 gigabyte RAM utan att ändra systemets bitdjup. Så, om du fortfarande behöver ha din egen kärna, låt oss börja kompilera! Hämta kärnans källkod. Packar upp källkodsarkivet. Kärnkonfiguration. göra config - konsolläge för konfiguratorn. gör menuconfig - konsolläge som en lista.
make xconfig - grafiskt läge.
När du har gjort de nödvändiga ändringarna, spara inställningarna och avsluta konfiguratorn. Kompilering. Konfigurera och kompilera Linux-kärnanKärnan är installerad. För att få det att visas i grub(2)-listan, skriv (som root) KernelCheck - kompilering av kärnan utan att gå in i konsolen. |
maj 2017
mars 2017
april 2016
mars 2016
Oktober 2013
september 2013
Maj 2013
mars 2013
november 2012
juli 2012
juni 2012
april 2012
mars 2012
februari 2012
april 2011
mars 2011
februari 2011
januari 2011
december 2010
november 2010
oktober 2010
september 2010
augusti 2010
juli 2010
juni 2010
maj 2010
april 2010
mars 2010
Slumpmässig:
Aurorae: fönsterdekorationsmotor för KDE
Sbloggen kommer att skrivas om i .NET
Linuxnow.ru: Planer för framtiden
Bolgenos. Telecons motbevisning
GRUB 2 snabb återställning
Free Software Foundation och copyleft.
Kollegor: alla
Linux för alla
Våra banners:
Ställ in banner
Frågan är, varför inte lära sig att göra samma sak med Linux-kärnan? Anledningarna till att bygga Linux-kärnan från källkod är i allmänhet desamma - att få den senaste versionen av kärnan, brådskande applicera säkerhetskorrigeringar, optimera för specifika uppgifter och specifik hårdvara, såväl som önskan att delta i kärnans utveckling, även i rollen som QA.
Viktig! Att följa instruktionerna i det här inlägget kan leda till att dina data går förlorade. Gör säkerhetskopior och kom ihåg att du gör allt på egen risk och risk. Allt som beskrivs nedan har testats på Ubuntu 14.04 LTS. Men på andra versioner av Ubuntu, såväl som andra Linux-distributioner, bör skillnaderna vara minimala.
Konfigurera starthanteraren
Redigera /etc/default/grub så här:
GRUB_DEFAULT=0
#GRUB_HIDDEN_TIMEOUT=10
#GRUB_HIDDEN_TIMEOUT_QUIET=sant
GRUB_TIMEOUT=10
GRUB_DISTRIBUTOR =` lsb_release -i -s 2 > /dev/null || echo Debian`
GRUB_CMDLINE_LINUX_DEFAULT="tyst plask"
GRUB_CMDLINE_LINUX=""
Efter redigering säger vi:
sudo update-grub
Som ett resultat, innan systemet startar, kommer du att uppmanas i 10 sekunder att välja kärnan som du vill starta upp med. Mycket praktiskt om du trasslat till med din kärnkonfiguration och vill starta med en tidigare version!
Installera beroenden
Vi kommer att behöva åtminstone följande paket:
sudo apt-get install git gcc gör bc fakeroot dpkg-dev \
libncurses5-dev libssl-dev
På många system kommer alla dock redan att finnas.
Få källan
wget https:// www.kernel.org/ pub/ linux/ kernel/ v4.x/ linux-4.6.4.tar.xz
tar --xz -xvf linux-4.6.4.tar.xz
cd linux-4.6.4
Eller, om du vill ha det allra senaste, kan du hämta källan direkt från Git :
# Spegel: https://github.com/torvalds/linux
git klon "git://git.kernel.org/pub/scm/linux/kernel/git/"\
"torvalds/linux.git"
cd linux
Att döma av det faktum att jag inte kunde hitta v4.6.4-taggen i Git, så görs Linux-kärnutgåvor uteslutande i form av komprimerade tar-arkiv.
Om du istället för en vaniljkärna skulle vilja bygga en kärna med patchar från Canonical:
git-klon git://kernel.ubuntu.com/ubuntu/ubuntu-trusty.git
cd ubuntu-trusty
git tag | mindre
git checkout Ubuntu-lts-4.4.0-31.50_14.04.1
Av min egen erfarenhet, om du använder Ubuntu, kan du säkert använda vaniljkärnan. Det är osannolikt att du kommer att ha några problem med det.
Notera: Intressant nog, av de befintliga relativt populära Linux-distributionerna, verkar bara Gentoo, Slackware och Arch Linux använda en kärna utan sina egna patchar.
Hur som helst, nu har du källkoden.
Kompilera och installera kärnan
Välj de alternativ som kärnan ska byggas med:
gör menuconfig
Om det behövs, ändra inställningarna, klicka på Spara och sedan på Avsluta. Detta skapar en .config-fil som innehåller de alternativ vi valt.
På uppdatering kärna (använder du redan någon form av kärna ändå?) Det är bekvämt att ta konfigurationen för den nuvarande kärnan och ställa in de nya alternativen till deras standardvärden:
zcat /proc/config.gz > ./.config
gör olddefconfig
Till sist samlar vi in:
göra -j4 bindeb-pkg LOCALVERSION=-anpassad
Kärnan är monterad under ganska lång tid. På min bärbara dator tog monteringen 1 timme och 15 minuter. Dock från denna tid handla om Resten går åt till att bygga ett gigantiskt kärnpaket med felsökningssymboler. Sammansättningen av detta paket kan inaktiveras genom att kommentera parametern CONFIG_DEBUG_INFO i konfigurationen. Tänk bara på att det här paketet krävs av SystemTap och andra användbara verktyg.
Förutom själva kärnan kan du också samla in dokumentation:
# det finns också `make pdfdocs` och andra, se `make help`
göra htmldocs
chromium-browser Documentation/ DocBook/ index.html
Efter avslutad montering dotterföretag katalog ser vi något som:
linux-firmware-image-4.4.13-custom_4.4.13-custom-1_amd64.deb
linux-headers-4.4.13-custom_4.4.13-custom-1_amd64.deb
linux-image-4.4.13-custom_4.4.13-custom-1_amd64.deb
linux-image-4.4.13-custom-dbg_4.4.13-custom-1_amd64.deb
linux-libc-dev_4.4.13-custom-1_amd64.deb
Vi lägger alla deb-paket utom dbg-versionen av kärnan med det vanliga sudo dpkg -i och starta om. Efter omstart, titta på resultatet av kommandot uname-a. Vi ser till att vi verkligen startade med den nya kärnan. Om något är fel med den nya kärnan väljer vi i bootloadern helt enkelt den som systemet startades med tidigare. Efter att ha startat upp med den gamla kärnan tar vi snabbt bort paketen för den nya kärnan, och voila - systemet återgick till sitt tidigare tillstånd.
I mitten av mars, efter nästan två månaders utveckling och sju släppkandidater, introducerade Linus Torvalds en ny version av 4.5-kärnan. Förutom korrigeringar finns det verkligen många nya saker i releasen. Ändringarna påverkade alla delsystem - disk, minne, system- och nätverkstjänster, säkerhet och, naturligtvis, drivrutiner för nya enheter lades till. Låt oss försöka ta itu med några av de mest intressanta.
Om utgivningen
Kärnutgåvan 4.4 släpptes relativt nyligen, i början av januari 2016, men ett stort antal tillägg har samlats på den här korta tiden. Och även om Linus kallade den nya utgåvan "normal" kan man se att jämfört med version 4.4 har storleken på patchen vuxit med nästan en tredjedel – 70 MB mot 49 MB. Cirka 1528 personer deltog i utvecklingen, som gjorde cirka 13 tusen korrigeringar. I mer än 11 tusen filer lades 1 146 727 till, 854 589 rader kod togs bort. I 4.4 fanns det 714 106 respektive 471 010 linjer. Nästan hälften (45%) av alla ändringar är relaterade till drivrutiner, 17% påverkar koden för hårdvaruarkitekturer, 14% gäller nätverksstacken, 4% - filsystem och 3% påverkar interna kärndelsystem. De främsta bidragsgivarna var Doug Ledford från Red Hat, som gjorde det mesta av saneringsarbetet (7,7 %), Tomi Valkeinen från Texas Instruments, som arbetade med stöd för OMAP-underarkitekturen (5,3 %), tre utvecklare fokuserade på AMD-grafikdrivrutiner: Eric Huang - 3,3%, Alex Deucher - 2,4% och yanyang1 - 1,6%. Ledare för förändringsuppsättningar - Linus Walleij från Linaro, som genomförde många förändringar på låg nivå, inklusive till den GPIO han stöder (2,0 %), Arnd Bergmann, som gjorde mycket arbete för att stödja ARM (1,9 %) och Leo Kim, som arbetade på wilc1000-drivrutinen (1,7%). Liksom tidigare är många företag intresserade av utvecklingen av kärnan. Arbetet med version 4.5 stöddes av mer än 200 företag, inklusive Red Hat, Intel, AMD, Texas Instruments, Linaro, Linux Foundation, Samsung, IBM, Google. De flesta av dem utvecklar stöd för sina enheter och relaterade delsystem och verktyg, men till exempel gör Google traditionellt många förändringar i nätverksundersystemet Linux.Kärna och drivrutiner
Porteringen av komplex och dåligt underhållen kod skriven i assembler (x86/asm) till C fortsatte i 4.0. Kärnan kan nu byggas med alternativet -fsanitize=undefined. Själva parametern dök upp för två år sedan i GCC 4.9+ och aktiverar UBSan (Undefined Behavior Sanitizer) felsökningsläge, som upptäcker odefinierat beteende som är inneboende i C- och C++-språken: användning av icke-statiska variabler före initiering, division med noll, heltalsspill och så vidare. Kompilatorn antar vanligtvis att sådana operationer aldrig kommer att inträffa, och om de gör det kan resultatet bli vad som helst och beror på själva kompilatorn. Nu upptäcker kompilatorn sådana situationer, ger ett "runtime error:" (du kan inaktivera -fno-sanitize-recover) och fortsätter körningen. Som standard, i varje OS-sammansättning, laddas alla bibliotek till vissa adresser, vilket gör det enkelt att implementera en attack. För att öka säkerheten används ett antal tekniker, en av dem är en slumpmässig offset vid anrop av mmap (), implementerad i form av ASLR (Address Space Layout Randomization). ASLR-teknik dök upp i Linux för första gången 2005 i 2.6-kärnan och gav ut en 8-bitars offset för 32-bitars system (det vill säga 256 adressalternativ, men faktiskt färre), och för x64 - är offset redan 28-bitars. För x64 finns det ganska tillräckligt med alternativ, men för 32-bitarssystem, inklusive Android, räcker detta helt klart inte idag. Det finns redan kända exploits som kan plocka upp en adress. Som ett resultat av att leta efter en lösning på problemet har en patch skrivits som låter dig ställa in mer slumpmässighet för ASLR, via /proc/sys/vm/mmap_rnd_bits och /proc/sys/vm/mmap_rnd_compat_bits (på x64-system för x86-processer). För varje arkitektur specificeras minimi- och maxvärden, med hänsyn till det tillgängliga adressutrymmet. För x86 kan värdet variera från 8 till 16 bitar eller 28 till 32 (för x64-versionen). Standardalternativ kan ställas in när du bygger kärnan.
Konfigurering av ASLR i den nya kärnan Utökade möjligheter för DRM-drivrutinen för NVIDIA (Nouveau) och Intel-grafikkort (stöd för den framtida generationen Kaby Lake-chips), tillagt stöd för nya ljudkort, USB-kontroller och kryptoacceleratorer. Grafikkortstillverkarna Intel och NVIDIA har länge övergett användningen av UMS (Userspace Mode Setting) i sina drivrutiner för öppen källkod till förmån för KMS (Kernel Mode Setting), nu är det ATI Radeon-drivrutinen som tog bort UMS-lägeskoden. Sedan 3.9 var det möjligt att aktivera det med parametern DRM_RADEON_UMS eller genom att ställa in radeon.modeset=0 i GRUB. Nu återstår bara KMS (Kernel Mode Setting). Detta måste beaktas om du behöver använda äldre drivrutiner eller UMS-läge (UMS visar ibland bättre prestanda). Lade till experimentellt stöd för PowerPlay dynamisk energihanteringsteknik till AMDGPU-drivrutinen för att förbättra GPU-prestanda för Tonga och Fiji GPU:er och integrerade Carrizo och Stoney. I PowerPlay-läge startar GPU:n i lågeffektläge, men om belastningen på det grafiska delsystemet ökar ökar den automatiskt frekvensen. Som standard är PowerPlay inaktiverat; för att aktivera det, skicka parametern amdgpu.powerplay=1 till kärnan. Den nya versionen av Media Controller API utökar stödet för Video4Linux-enheter och låter dig använda multi andra delsystem som DVB, ALSA och IIO. Mycket har gjorts i KVM (Kernel-Based Virtual Machine) för att stödja s390-arkitekturen (nu kan den använda upp till 248 vCPUs), ARM/ARM64 och förbättra x86-prestanda i Hyper-V. Installera Kernel 4.5 i Ubuntu
Det enklaste sättet att bli bekant med den nya kärnan är att använda byggnaden från Ubuntu Kernel Team. Efter omfattande testning hamnar den nya kärnan i ppa:canonical-kernel-team/ppa , men detta brukar ta tid. $ wget -c http://kernel.ubuntu.com/~kernel-ppa/mainline/v4.5-wily/linux-headers-4.5.0-040500-generic_4.5.0-040500.201603140130_amd64.deb http://kernel .ubuntu.com/~kernel-ppa/mainline/v4.5-wily/linux-headers-4.5.0-040500_4.5.0-040500.201603140130_all.deb http://kernel.ubuntu.com/~kernel-ppa/mainline /v4.5-wily/linux-image-4.5.0-040500-generic_4.5.0-040500.201603140130_amd64.deb $ sudo dpkg -i linux*.deb Vi kan arbeta efter omstart.ARM-stöd
ARM-datorer används som miniservrar för vissa uppgifter eller som automationskontroller, vilket gör dem mycket populära och efterfrågade. Linux ARM-communityt har blivit ett av de mest aktiva under de senaste fem åren och har gjort ett enormt arbete för att stödja 32-bitars ARM-plattformar, som upptar en betydande marknadsandel, och detta arbete slutfördes i allmänhet genom lanseringen av 4.5 gren. Tidigare, för varje ARM-enhet, var det nödvändigt att bygga sin egen kärna, vilket gav stöd för endast vissa enheter. Men problemet är att enheterna blev mer komplexa, det blev möjligt att ändra konfigurationen och användarna själva på ARM-enheter ville använda vanliga distributioner utan onödiga gester. Men i slutändan hade vi flera hundra alternativ för att bygga kärnan, vilket gör det väldigt svårt att använda Linux. Som ett resultat av att rensa och omfaktorisera en stor mängd kod, blev det möjligt att inkludera ARMv6 och ARMv7 stödkod i kärnan, det vill säga nu kan vi bygga en universell kärna som kan boota på båda systemen. Här måste vi förmodligen komma ihåg den nyligen marknadsförda Device Tree-specifikationen, som uppstod som en del av utvecklingen av Open Firmware. Device Tree låter dig konfigurera hårdvara vid uppstart med hjälp av speciella dts-filer lagrade i /boot/dtbs och ändra inställningar utan att bygga om kärnan. Användningen av enhetsträdet blir obligatoriskt för alla nya ARM-utvecklingar och inte bara enheter. Allt detta tillsammans ger förtroende för att Linux-distributioner i framtiden säkert kan köras på vilken ARM-enhet som helst. Parallellt släppte Greg Kroah-Hartman från Linux Foundation en patch som implementerar en liknande funktion för tidiga versioner av kärnan. I arch/arm64 hittar vi koden som ger stöd för den nya 64-bitars ARM-arkitekturen (ARMv8). Lade till nya funktioner för alla populära ARM-arkitekturer - Allwinner, Amlogic, Samsung, Qualcomm och stöd för nya ARM-kort från olika utvecklare.Systemtjänster
För att komma åt UEFI (Unified Extensible Firmware Interface) firmwaredata i Linux, används ett speciellt efivars pseudo-filsystem (konfigurerbart av EFIVAR_FS), som är monterat i /sys/firmware/efi/efivars . I vissa implementeringar, när kommandot rm -rf /* kördes, raderades även innehållet i den här katalogen, vilket ledde till att den fasta programvaran förstördes. Företag - enhetsutvecklare anser inte att detta är en allvarlig nackdel, eftersom situationen naturligtvis inte är den vanligaste, och det är osannolikt att någon användare skulle tänka på att kontrollera detta. Ändå finns det ett problem, och virusskribenter kan verkligen dra nytta av denna möjlighet. Kernel 4.5 lägger nu till speciellt skydd till katalogen /sys/firmware/efi/efivars för att förhindra radering av filer inuti.Fortsatt tillgänglig endast för medlemmar
Alternativ 1. Gå med i "site"-gemenskapen för att läsa allt material på sajten
Medlemskap i communityn under den angivna perioden ger dig tillgång till ALLT hackermaterial, ökar din personliga kumulativa rabatt och låter dig samla ett professionellt Xakep-poängbetyg!
Kärna(Engelsk) kärna) är vad allt annat är uppbyggt kring. Det är vad som kallas Linux. Nu kallas ordet Linux i vardagen för operativsystemet som är byggt på det, även om det på ett bra sätt heter GNU/Linux (Linuxkärnan och programvaran från GNU-projektet, som har varit under utveckling i många decennier).
Ubuntu använder en kärna med ett stort antal patchar, av vilka några lägger till instabila och experimentella funktioner.
Varje version av Ubuntu har sin egen kärnversion. LTS-utgåvor sedan 10.04 har kunnat uppgradera kärnan till versioner som ingår i nyare utgåvor.
| Ubuntu version | Kärnversion |
|---|---|
| 4.10 | 2.6.9 |
| 5.04 | 2.6.11 |
| 5.10 | 2.6.13 |
| 6.06LTS | 2.6.15 |
| 6.10 | 2.6.18 |
| 7.04 | 2.6.19 |
| 7.10 | 2.6.20 |
| 8.04LTS | 2.6.24 |
| 8.10 | 2.6.27 |
| 9.04 | 2.6.28 |
| 9.10 | 2.6.31 |
| 10.04LTS | 2.6.32 |
| 10.10 | 2.6.35 |
| 11.04 | 2.6.38 |
| 11.10 | 3.0.4 |
| 12.04LTS | 3.2 |
| 12.10 | 3.5 |
| 13.04 | 3.8 |
| 13.10 | 3.11 |
| 14.04LTS | 3.13 |
| 14.10 | 3.16 |
| 15.04 | 3.19 |
gafflar
Versionsnumreringen för Ubuntu-kärnan och på kernel.org-webbplatsen stämmer inte överens, eftersom Canonical-utvecklare lägger till en mikroversion för att indikera de tillagda korrigeringarna. Till exempel skulle version 3.2.0-23 innebära att kärnan är baserad på 3.2-grenen, som har 23 patchar.
Följande typer av kärnor stöds i Ubuntu-förvaret:
generic-pae-kärnan tillåter ett 32-bitarssystem att använda upp till 64 GB totalt RAM-minne, vilket inte tilldelar mer än 4 GB för behoven för en viss process, medan en enkel generisk kärna fungerar med högst 4 GB RAM.
64-bitarskärnan tillåter adressering av upp till 1 TB minne som förbrukas av processer.
Om du behöver uppdatera kärnan till en nyare huvudversion (vanligtvis beror detta på att nya versioner lägger till stöd för ny hårdvara, eliminerar regressioner), kan du använda det officiellt stödda arkivet http://kernel.ubuntu.com/ ~kernel-ppa/mainline/ .
Kompilerar kärnan
Att bygga kärnan från källkod kräver viss kompetens och kunskap om hur operativsystemet fungerar.
Innan du börjar bygga kärnan måste du installera följande paket:
Byggnödvändigt fakeroot ncurses-dev libssl-dev
Alla ytterligare åtgärder måste utföras på uppdrag av superanvändaren:
sudo suHämta källkoden
Källkoden för kärnan som används av Ubuntu kan erhållas genom att installera linux-source-paketet:
apt-get installera linux-källaEfter installationen i katalogen /usr/src det kommer att finnas ett arkiv som heter linux-source-verify_kernels.tar.bz2.
Du kan också ladda ner arkivet med kärnans källkod från webbplatsen kernel.org.
När du laddar ner kärnan från kernel.org-webbplatsen måste du installera patchar på den
Konfiguration
Packa upp det resulterande arkivet och skapa en symbolisk länk till den resulterande katalogen för enkelhetens skull:
cd / usr/ src tar xjf ./ linux-source-3.2.0.tar.bz2 ln -s ./ linux-source-3.2.0 ./ linux cd ./ linuxFör att förenkla kärnkonfigurationsprocessen kan du kopiera inställningarna för den aktuella.