Buildroot - del 1. Allmän information, montering av ett minimalt system, konfiguration via menyn

Inledning

I den här artikelserien vill jag titta på byggsystemet för buildrootdistribution och dela med mig av min erfarenhet av att anpassa det. Det kommer att finnas praktisk erfarenhet av att skapa ett litet OS med ett grafiskt gränssnitt och minimal funktionalitet.

Först och främst bör du inte blanda ihop byggsystemet och distributionen. Buildroot kan bygga ett system från en uppsättning paket som erbjuds till det. Buildroot är byggt på makefiler och har därför enorma anpassningsmöjligheter. Ersätta ett paket med en annan version, lägg till ditt eget paket, ändra reglerna för att bygga ett paket, anpassa filsystemet efter installation av alla paket? buildroot kan göra allt detta.

I Ryssland används buildroot, men enligt mig finns det lite ryskspråkig information för nybörjare.

Målet med arbetet är att sätta ihop ett distributionskit med livenedladdning, icewm-gränssnitt och webbläsare. Målplattformen är virtualbox.

Varför bygga en egen distribution? Ofta behövs begränsad funktionalitet med begränsade resurser. Ännu oftare inom automation behöver du skapa firmware. Att anpassa en allmän distribution genom att rensa ut onödiga paket och förvandla den till firmware är mer arbetskrävande än att bygga en ny distribution. Att använda Gentoo har också sina begränsningar.

Buildroot-systemet är mycket kraftfullt, men det kommer inte att göra något för dig. Det kan bara aktivera och automatisera monteringsprocessen.

Alternativa byggsystem (yocto, öppet byggsystem och andra) beaktas eller jämförs inte.

Var får man tag i det och hur man börjar

Projektets hemsida - buildroot.org. Här kan du ladda ner den aktuella versionen och läsa manualen. Där kan du kontakta communityn, det finns en buggspårare, e-postlistor och en irc-kanal.

Buildroot använder defconfigs för målkortet för build. Defconfig är en konfigurationsfil som endast lagrar alternativ som inte har standardvärden. Det är han som bestämmer vad som ska samlas in och hur. I det här fallet kan du separat konfigurera konfigurationerna för busybox, linux-kernel, uglibc, u-boot och barebox bootloaders, men alla kommer att kopplas till målkortet.
Efter att ha packat upp det nedladdade arkivet eller klonat från git får vi en byggrot som är färdig att använda. Du kan läsa mer om katalogstrukturen i manualen; jag ska berätta om de viktigaste:

ombord — en katalog med filer som är specifika för varje kort. Dessa kan vara skript för att skapa systembilder (iso, sdcart, cpio och andra), en överlagringskatalog, kärnkonfiguration, etc.
configs — själva defconfig för brädet. Defconfig är en ofullständig kortkonfiguration. Den lagrar endast parametrar som skiljer sig från standardinställningarna
dl — katalog med nedladdade källkoder/filer för montering
output/mål — det sammansatta filsystemet för det resulterande operativsystemet. Därefter skapas bilder från den för nedladdning/installation
output/värd - värdverktyg för montering
produktion/bygga - monterade paket

Sammansättningen konfigureras via KConfig. Samma system används för att bygga Linux-kärnan. Lista över de vanligaste kommandona (kör i buildroot-katalogen):

• make menuconfig - anropa byggkonfigurationen. Du kan också använda det grafiska gränssnittet (gör nconfig, gör xconfig, gör gconfig)
• gör linux-menuconfig - anropa kärnkonfigurationen.
• gör rent - rengör byggresultaten (allt lagrat i utdata)
• göra - bygga ett system. Detta sätter inte ihop redan monterade processer.
• make defconfig_name - ändra konfigurationen till en specifik defconfig
• make list-defconfigs - visa en lista med defconfigs
• skapa källa - ladda bara ner installationsfilerna, utan att bygga.
• göra hjälp - lista möjliga kommandon

Viktiga anteckningar och användbara tips

Buildroot bygger inte om paket som redan har byggts! Därför kan en situation uppstå där en fullständig återmontering krävs.

Du kan bygga om ett separat paket med kommandot gör paketnamn-rebuild. Till exempel kan du bygga om Linux-kärnan:

make linux-rebuild

Buildroot lagrar tillståndet för alla paket genom att skapa .stamp-filer i katalogen output/build/$packagename:

Därför kan du bygga om root-fs och bilder utan att bygga om paket:

rm output/build/host-gcc-final-*/.stamp_host_installed;rm -rf output/target;find output/ -name ".stamp_target_installed" |xargs rm -rf ; make

Användbara variabler

buildroot har en uppsättning variabler för enkel konfiguration

• $TOPDIR - buildroot-katalog
• $BASEDIR - OUTPUT-katalog
• $HOST_DIR, $STAGING_DIR, $TARGET_DIR — värd fs, iscensättande fs, mål fs byggkataloger.
• $BUILD_DIR - katalog med uppackade och byggda paket

Visualisering

buildroot har en visualiseringsfunktion. Du kan bygga ett beroendediagram, en byggtidsgraf och en graf över paketstorlekar i det slutliga systemet. Resultaten är i form av pdf-filer (du kan välja mellan svn,png) i katalogen output/graph.

Exempel på visualiseringskommandon:

• make graph-depends bygga ett beroendeträd
• make <pkg>-graph-depends bygga ett beroendeträd för ett specifikt paket
• BR2_GRAPH_OUT=png make graph-build rita byggtid med PNG-utgång
• make graph-size plot paketstorlek

Användbara skript

Det finns en underkatalog i buildrootkatalogen utils med användbara skript. Det finns till exempel ett skript som kontrollerar att paketbeskrivningarna är korrekta. Detta kan vara användbart när du lägger till dina egna paket (jag gör det senare). Filen utils/readme.txt innehåller en beskrivning av dessa skript.

Låt oss bygga en aktiefördelning

Det är viktigt att komma ihåg att alla operationer utförs på uppdrag av en vanlig användare, inte root.
Alla kommandon körs i buildroten. Byggrotspaketet innehåller redan en uppsättning konfigurationer för många vanliga kort och virtualisering.

Låt oss titta på listan över konfigurationer:

Växla till qemu_x86_64_defconfig-konfigurationen

make qemu_x86_64_defconfig

Och vi startar monteringen

make

Bygget slutförs framgångsrikt, titta på resultaten:

Buildroot har sammanställt bilder som du kan köra i Qemu och verifiera att de fungerar.

qemu-system-x86_64 -kernel output/images/bzImage -hda    output/images/rootfs.ext2 -append "root=/dev/sda rw" -s -S

Resultatet är ett system som körs i qemu:

Skapa din egen styrelsekonfiguration

Lägga till styrelsefiler

Låt oss titta på listan över konfigurationer:

I listan ser vi pc_x86_64_efi_defconfig. Vi kommer att skapa vårt eget kort genom att kopiera det från konfigurationen:

cp configs/pc_x86_64_bios_defconfig configs/my_x86_board_defconfig

Låt oss omedelbart skapa en styrelsekatalog för att lagra våra skript, rootfs-overlay och andra nödvändiga filer:

mkdir board/my_x86_board

Byt till denna defconfig:

make my_x86_board_defconfig

Så nu motsvarar build-konfigurationen (lagrad i .config i roten av buildroot-katalogen) den gamla x86-64 (bios)-startmålmaskinen.

Låt oss kopiera linux-kärnkonfigurationen (användbart senare):

cp board/pc/linux.config board/my_x86_board/

Ställa in byggparametrar via KConfig

Låt oss starta installationen:

make menuconfig 

KConfig-fönstret öppnas. Det är möjligt att konfigurera med ett grafiskt gränssnitt (make nconfig, make xconfig, make gconfig):

Vi går in i det första avsnittet Målalternativ. Här kan du välja den målarkitektur för vilken bygget ska utföras.

Byggalternativ - det finns olika bygginställningar här. Du kan ange kataloger med källkoder, antalet byggtrådar, speglar för nedladdning av källkoder och andra inställningar. Låt oss lämna inställningarna som standard.

Verktygskedja – själva byggverktygen konfigureras här. Läs mer om honom.

Verktygskedja - typ av verktygskedja som används. Detta kan vara en verktygskedja inbyggd i buildroot eller en extern (du kan ange katalogen med den redan byggda eller webbadressen för nedladdning). Det finns ytterligare alternativ för olika arkitekturer. Till exempel, för arm kan du helt enkelt välja Linaro-versionen av den externa verktygskedjan.

C-biblioteket – val av biblioteket C. Driften av hela systemet beror på detta. Vanligtvis används glibc, som stöder alla möjliga funktioner. Men det kan vara för stort för ett inbäddat system, så uglibc eller musl väljs ofta. Vi kommer att välja glibc (detta kommer att krävas senare för att använda systemd).

Kernel Headers och Custom Kernel Headers-serien – måste matcha versionen av kärnan som kommer att finnas i det sammansatta systemet. För kärnrubriker kan du också ange sökvägen till tarball- eller git-förrådet.

GCC COMPILER VERSIONS – välj kompilatorversionen som ska användas för att bygga
Aktivera C++-stöd – välj att bygga med stöd för C++-bibliotek i systemet. Detta kommer att vara användbart för oss i framtiden.

Ytterligare gcc-alternativ – du kan ställa in ytterligare kompilatoralternativ. Vi behöver det inte just nu.

Systemkonfiguration låter dig ställa in framtida parametrar för det skapade systemet:

De flesta av punkterna framgår av titeln. Låt oss vara uppmärksamma på följande punkter:
Sökväg till användartabellerna - tabell med användare som ska skapas (https://buildroot.org/downloads/manual/manual.html#makeuser-syntax).

Exempelfil. Användaranvändaren kommer att skapas med lösenordet admin, automatiskt gid/uid, /bin/sh-skal, standardgruppanvändare, gruppmedlemsrot, kommentar Foo-användare

[alexey@alexey-pc buildroot ]$ cat board/my_x86_board/users.txt 
user -1 user -1 =admin /home/user /bin/sh root Foo user

Överlagringskataloger för rotfilsystem - katalog överlagd ovanpå de sammansatta target-fs. Lägger till nya filer och ersätter befintliga.

Anpassade skript som ska köras innan filsystemsbilder skapas - Skript som körs omedelbart innan filsystemet vikas till bilder. Låt oss lämna skriptet tomt för tillfället.

Låt oss gå till kärnsektionen

Kärninställningar ställs in här. Själva kärnan konfigureras via make linux-menuconfig.
Du kan ställa in kärnversionen på olika sätt: välj bland de som erbjuds, ange versionen manuellt, ange ett arkiv eller en färdig tarball.

Kärnkonfiguration — sökväg till kärnans konfiguration. Du kan välja standardkonfigurationen för den valda arkitekturen eller defocnfig från Linux. Linux-källan innehåller en uppsättning defconfigs för olika målsystem. Du kan hitta den du behöver genom att titta direkt på källorna här. Till exempel, för en beagle ben svart tavla kan du välj config.

Avsnittet Målpaket låter dig välja vilka paket som ska installeras på systemet som byggs. Låt oss lämna det oförändrat tills vidare. Vi kommer att lägga till våra paket till denna lista senare.
Filsystembilder - en lista över filsystembilder som kommer att samlas in. Lägg till en iso-bild

Bootloaders - urval av bootloaders att samla in. Låt oss välja isolinix

Konfigurera Systemd

Systemd håller på att bli en av grundpelarna i Linux, tillsammans med kärnan och glibc. Därför flyttade jag dess inställning till ett separat objekt.

Konfigureras via make menuconfig, sedan Target packages → System tools → systemd. Här kan du ange vilka systemd tjänster som ska installeras och startas när systemet startar.

Sparar systemkonfiguration

Vi sparar den här konfigurationen via KConfig.

Spara sedan vår defconfig:

make savedefconfig

Linux Kernel Configuration

Linux-kärnkonfigurationen anropas med följande kommando:

make linux-menuconfig

Låt oss lägga till stöd för Virtualbox-grafikkortet

Låt oss lägga till stöd för Virtualbox Guest-integrering

Spara och avsluta. VIKTIG: konfigurationen kommer att sparas i output/build/linux-$version/config, men inte i board/my_x86_board/linux.config

Därför måste du manuellt kopiera konfigurationen till en lagringsplats:

cp output/build/linux-4.19.25/.config board/my_x86_board/linux.config

Därefter kommer vi att utföra en fullständig återmontering av hela systemet. buildroot bygger inte om det som redan har byggts, du måste manuellt ange paket för ombyggnad. För att inte slösa tid och nerver är det lättare att bygga om ett litet system helt):

make clean;make

När bygget är klart, starta VirtualBox (testat på version 5.2 och 6.0) och starta från CD:n. Systemparametrar:

Kör från den monterade iso:en:

Lista över använt material

1. Buildroot manual

Källa: will.com