Bli en Linux-Guru!

Publicerad 2002-07-22

Obs! Den här artikeln hänvisar till en gammal version av Linux From Scratch, därför är många av länkarna felaktiga. Vi har ambitionen att komma med en uppdaterad version av den här artikeln, men vet f.n. inte när det blir av.

Troligen det bästa sättet att lära sig hur ett Linux-system är uppbyggt är att göra ett själv... Det är i alla fall bakgrunden till den här artikeln. Jag kommer att gå igenom hur du plockar hem, bygger upp, och pusslar ihop ett komplett Linux-baserat operativsystem på din dator.

Räkna med att den här processen tar flera timmar att genomföra, och när du är klar kommer du att ha ett system som är långt mindre komplett än vilken standarddistribution som helst (som du dessutom kan installera på mindre än en halvtimme)... Vad du däremot kommer att ha är:

• Ett minimalt, fullt fungerande, system som bara innehåller precis de program och tjänster som du behöver
• Kunskap om varenda program, varenda fil och varenda inställning som finns i systemet
• En Linux-kärna som du själv kompilerat, anpassat efter din dator och dina behov
• Och kanske det viktigaste: Nya kunskaper och erfarenheter om hur ett Linux-system är uppbyggt som det är svårt att få på något annat sätt!

Linux From Scratch

Den här artikeln ska ses som en introduktion i ämnet. De utförliga beskrivningarna över hur varje steg går till finns istället på hemsidan för Linux From Scratch (LFS). Ibland kallas LFS för en Linuxdistribution, men det finns inte många likheter med "riktiga" distributioner som Red Hat, Mandrake, Debian eller andra. LFS är snarare en uppsättning dokument som beskriver just hur du skapar ditt eget Linux-system från grunden. Den här artikeln beskriver alltså hur det går till att göra sitt eget Linux-system med hjälp av Linux From Scratch, och är baserad på version 3.3 av LFS-boken.

(Alla länkar till LFS-boken kommer att öppnas i ett eget browser-fönster, till skillnad från andra länkar på den här sidan. Det är ingen dum idé att ha boken uppe parallellt med den här artikeln – speciellt senare, då jag kommer att hänvisa till boken hela tiden.)

Förkunskaper

Jag förutsätter i den här artikeln att du har använt Linux (eller någon annan Unix-variant) och att du är väl förtrogen med enkla filhanteringskommandon som ls, cd, pwd, cp, mv, cat och så vidare. Det är också bra om du förstår hur filrättigheter hanteras i Linux och om du är medveten om skillnaden mellan användaren "root" och vanliga användare.

För att installera ett Linux From Scratch-system krävs det att du har en befintlig Linux-installation på den datorn som du bygger upp LFS-systemet i. Jag kommer att beskriva en enkel Red Hat-installation nedan, men det kan vara i princip vilken Linuxdistribution som helst, om du redan har en klar. Jag förutsätter dock att du använder bash som kommando-skal. (Detta är standardskalet i de flesta distributioner, så det gör du antagligen också.)

Kommandon du kommer att använda

När vi bygger ihop och installerar systemet senare kommer vi att använda ett fåtal kommandon som du kanske inte stött på förut, så jag tänkte beskriva dem lite innan. Är du systemadministratör eller avancerad användare känner du säkert till även dessa kommandon sedan tidigare och kan då hoppa direkt till nästa avsnitt (installation av Red Hat 7.3). De kommandon jag beskriver är ncftpget, tar, &&, configure, make, patch, sed, cfdisk, mkfs, mount och lilo.

Om du vill ha mer detaljerad information än den jag ger här använder du som vanligt man-kommandot i din Linux-installation. Den informationen finns förstås också på nätet, men var vaksam på att det är möjligt att informationen på nätet kan beskriva en annan version (eller till och med en annan variant) av programmet du vill veta mer om.

ncftpget

ncftpget är helt enkelt ett program som underlättar hämtningen av de programpaket som du ska bygga senare. Vilket ftp-klientprogram kan förstås användas, men med ncftpget kan du med ett enda kommando använda dig av anonym FTP och tanka hem en specifik fil.

Du kan ge en komplett FTP-URL som parameter, vilket innebär att du snabbt (genom att kopiera URLen från en browser eller från Linux From Scratch-boken) kan plocka hem det programpaket du vill. Den här kommandoraden tar hem en tar-fil med alla programpaket som behövs för att installera LFS (filen är stor, så det är bäst du väntar med att köra den här raden till senare):

ncftpget ftp://ftp.se.linuxfromscratch.org/lfs/lfs-packages/3.3/lfs-packages-3.3.tar

ncftpget finns säkert i de flesta Linuxdistributioner, och åtminstone i Red Hat 7.3. Men, som sagt, vilket FTP-klientprogram som helst kan förstås användas för att hämta programpaketen.

tar

Programpaketen du hämtar hem består av en mängd programkodsfiler, textfiler och dokumentation. Dessa hanterar du med programmet tar.

tar är ett viktigt program med många finesser, men som utför en enkel uppgift: slå ihop flera filer och kataloger till en fil – ett arkiv. Som standard komprimeras inte arkivfilen och har ett filnamn som slutar på .tar, men oftast är filerna komprimerade med antingen gzip (och har då antingen filändelsen .tar.gz eller .tgz) eller med bzip2 (och slutar då med .tar.bz2).

Men det enda vi ska använda tar till i den här artikeln är att packa upp de programpaket vi har laddat hem, så att vi kan bygga och installera dem. Det finns alltså tre fall: icke komprimerade arkivfiler, filer komprimerade med gzip, och filer komprimerade med bzip2.

Okomprimerade arkivfiler packas upp med kommandot:

tar xvf filename.tar

De tre parametrarna xvf betyder:

• x – extract files, plocka ut filer och kataloger från arkivfilen
• v – verbose, visa mer information än normalt, vilket här innebär att namnen på alla filer som plockas ut skrivs ut på skärmen
• f – filename, anger att nästa argument till tar är namnet på arkivfilen

tar klarar av att själv packa upp filer som är komprimerade med gzip, om du anger den extra parametern z, så här:

tar xvzf filename.tgz

Vad gäller filer som är komprimerade med bzip2 så finns det vissa versioner av tar som är utökade med att klara av den typen av komprimering. Då kan du använda parametern j på samma sätt som med gzip-varianten:

tar xvjf filename.tar.bz2

Om du inte har en variant av tar som kan hantera bzip2-komprimering måste du först dekomprimera arkivfilen innan du kan plocka ut innehållet. Det kan göras på en rad, på det här sättet:

bzcat filename.tar.bz2 | tar xv

Det senare sättet fungerar alltid, så om du är osäker på om din version av tar klarar av bzip2-komprimering så kan du alltid använda den. Vi kommer senare att bygga en version av tar till vårt Linux-system där du kan välja om du vill lägga till den funktionen (med hjälp av en patch-fil) eller inte.

Kommandot &&

De allra flesta programpaketen byggs och installeras så här (eller snarlikt detta):

./configure &&
make &&
make install

Jag beskriver configure och make nedan. Titta istället på slutet av raderna, där tecknen && avslutar alla rader, utom den sista. Detta säger till bash att inte köra nästa kommando, om det aktuella kommandot avslutas med ett felmeddelande. Det kan vi använda till att kopiera och klistra in flera kommandon samtidigt, från den här artikeln eller från Linux From Scratch-boken, utan att riskera att det händer något oförutsett om ett kommando skulle misslyckas.

Prova till exempel att kopiera följande rader, och klistra in dem i ett terminalfönster (som kör bash):

cd &&
mkdir newtestdir &&
echo "Created a new directory"

Första gången du gör det skapas en ny katalog i din hemkatalog, och meddelandet på sista raden skrivs ut. Gör nu exakt samma sak igen. Eftersom katalogen redan är skapad misslyckas kommandot mkdir, vilket medför att bash inte kommer att utföra nästa kommando, och meddelandet skrivs alltså inte ut. (Du kan ta bort katalogen nu, genom att skriva rm newtestdir .)

configure

De allra flesta programpaketen har en körbar fil i sig, som heter configure, och som ska köras innan programpaketet byggs. Det här skriptprogrammet är genererat av ett annat program (autoconf, men det behöver du inte använda själv) för att utföra en mängd olika kontroller av ditt system, till exempel:

• vilka versioner av olika bibliotek som finns installerade på ditt system,
• vilket operativsystem som körs (autoconf kan användas för att göra portabla program),
• vilken version av Linux-kärnan som körs, och
• om andra programpaket, som det här paketet är beroende av, är installerade.

När skriptet körs och har undersökt ditt system genererar det en fil, Makefile, som styr exakt hur programmet ska byggas. Den använder vi sedan med programmet make.

configure kan också anropas med parametrar för att ändra vissa inställningar. En vanlig sådan parameter vid installation av ett LFS-system är parametern --prefix, som används för specificera var programmet ska installeras så småningom. De flesta paketen installerar sig under /usr/local/ som standard, medan vi vill installera programmen direkt under /usr/. Därför ser ett vanligt anrop till configure ut så här:

./configure --prefix=/usr

Att vi är noga med att anropa configure med en explicit sökväg (dvs med "./" innan) beror på att vi vill vara säkra på att vi kör skriptet i den aktuella katalogen (som hör till programpaketet), och inte något annat program som råkar ligga i PATH-sökvägen.

make

Programpaketen som utgör ett LFS-system består till största delen av programkod som måste kompileras. Ett enda program eller bibliotek kan byggas upp av hundratals eller till och med tusentals programkodsfiler (som i vårt fall oftast innehåller program skrivna i C eller C++). För att göra själva kompileringen och länkningen till det slutgiltiga programmet eller biblioteket behöver du bara ett kommando: make!

När du kör make söker programmet i aktuell katalog efter en fil med namnet Makefile (som i sin tur ofta är genererad av configure). Makefile innehåller instruktioner till make om vilka filer som ska kompileras och hur det ska gå till. Det innehåller dessutom information om beroenden mellan filer, så att inte allt behöver byggas om ifall en liten förändring görs.

Du kan också skicka med en parameter till make som anger vilken target som make ska bygga. Detta används ofta även till att utföra andra uppgifter relaterade till byggandet, till exempel används ofta en target med namnet "install" för att låta make kopiera de färdiga programmen till rätt ställe i systemet.

patch

Ibland har det släppts små buggfixar eller förbättringar efter programpaketet, utan att en ny version av programpaketet kommit ut. Dessa förändringar levereras då i patch-filer. Dessa filer innehåller en beskrivning av vilka programkodsrader som ska bytas ut, tas bort eller läggas till i befintliga programkodsfiler. Med hjälp av programmet patch kan du snabbt och enkelt uppdatera programkoden innan du bygger programmet.

Oftast används patch så här:

patch -p1 patchfilename

Parametern -p1 ser till att filnamnen som finns i patch-filen kommer att behandlas som om de var relativa sökvägar från aktuell katalog, vilket oftast är det man vill. I alla fall är det så vi kommer att använda patch på programpaket i LFS.

sed

Programmet sed (Stream EDitor) tar helt enkelt en ström av indata (till exempel från en textfil), utför en enkel transformation, som att byta ut varje förekomst av en sträng mot en annan, och skickar resultatet till en ström av utdata.

I alla sin enkelhet kan sed kombineras med andra kommandon för att lösa rätt komplicerade problem, men i den här artikeln kommer sed bara att användas som ett "fattigmans-patch".

Så här kan du till exempel använda sed för att byta ut alla förekomster av textsträngen "Copyright 2001" mot strängen "Copyright 2002" i filen header.h i aktuell katalog:

cp header.h header.h.backup &&
sed 's/Copyright 2001/Copyright 2002/' < header.h.backup > header.h

cfdisk

För att partitionera en hårddisk, dvs skapa utrymme för ditt LFS-system eller andra operativsystem, används programmet cfdisk (vilket är en lite mer användarvänlig variant av fdisk). Starta programmet med den enhet som motsvarar den hårddisk som du vill hantera som parameter. Om du till exempel vill skapa nya (eller ta bort befintliga) partitioner på den andra hårddisken, skriver du:

cfdisk /dev/hdb

Programmet är sedan meny-styrt. Skriv h för att få upp mer hjälp, och q för att avsluta cfdisk utan att göra några förändringar.

mkfs

När du har partitionerat hårddisken (med cfdisk eller liknande program) måste du skapa ett filsystem på partitionen för att kunna spara filer på den. Det är det som kallas för att "formattera" hårddisken i andra operativsystem.

Linux kan arbeta med flera olika filsystem, och med mkfs kan du själv välja vilket filsystem du vill skapa på din LFS-partition. Men om du vill välja den säkra vägen bör du välja Linux standardfilsystem, ext2 (eller möjligen den nyare, journalförande, varianten av ext2: ext3).

Programmet mkfs är egentligen bara ett tunt skal som anropar olika program beroende på vilken typ av filsystem du vill skapa. Kommandoraden nedan säger åt mkfs att ett filsystem av typen ext2 ska skapas på /dev/hda2 (den andra partitionen på den första hårddisken).

mkfs -t ext2 /dev/hda2

För att göra detta delegerar mkfs till programmet mkfs.ext2 som vet hur man skapar det önskade filsystemet (ext2).

mount

Hårddiskar och partitioner representeras i Linux av filer under /dev-katalogen. Den första hårddisken heter /dev/hda, den andra /dev/hdb och så vidare. (SCSI-diskar heter istället /dev/sda, /dev/sdb och så vidare.) Partitioner på hårddiskarna representeras med siffror. Den första partitionen på den första hårddisken heter /dev/hda1, den andra partitionen på samma hårddisk heter /dev/hda2 och så vidare.

För att du ska kunna använda hårddiskarna i ditt filsystem så kopplas specifika partitioner till kataloger i katalogträdet i ditt filsystem med kommandot mount. Anta till exempel att du har tänkt spara en mängd stora videofiler och köper en ny hårddisk att ha dem på. Du bestämmer då att sökvägen till filerna ska vara /var/video och vill alltså koppla den nya stora hårddisken till den katalogen. Om du bara hade en hårddisk i datorn tidigare (/dev/hda) och formatterar den nya hårddisken med en enda stor partition, så får den partitionen namnet /dev/hdb1. För att koppla hårddisken till önskad sökväg skapar du först en ny (tom) katalog som heter /var/video och använder sedan mount för att koppla ihop de två:

mkdir /var/video
mount /dev/hdb1 /var/video

För att minimera risken för fel på filsystemen så ska den här kopplingen tas bort när enheten inte längre används. Det är förstås mest relevant för enheter som kan bytas under drift, men kopplingen även till fasta hårddiskar ska tas bort innan datorn stängs av. Det görs med kommandot umount, som tar sökvägen till motsvarande katalog som parameter:

umount /var/video

Kommandot mount används oftast för temporära kopplingar. I vårt exempel ovan hade vi nog velat att katalogen /var/video alltid skulle kopplas mot den nya hårddisken när datorn startas upp. Det kan du ange i konfigurationsfilen /etc/fstab. Här anges vilka kopplingar mellan hårddiskpartitioner och kataloger som skapas när datorn startas och tas bort när datorn stängs av på ett kontrollerat sätt. Om du har ett Linux-system tillgängligt kan du se i den filen vilka hårddiskar som är permanent kopplade till vilka kataloger.

En konvention i Linux-världen är att enheter man vill använda temporärt kopplas till kataloger under /mnt. Flera Linuxdistributioner har redan skapat tomma kataloger där som kan användas för att koppla vanliga utbytbara enheter, som /mnt/floppy och /mnt/cdrom.

LFS-systemet vi ska bygga kommer ju att ligga på en (eller flera) egna partitioner. (Se avsnittet om att skapa partitioner för LFS-systemet nedan.) Vi kommer att bygga upp katalogstrukturen manuellt och skapa filer i den. För att kunna göra detta skapar vi en katalog, /mnt/lfs, och arbetar sedan direkt i LFS-systemets katalogstruktur.

Det som skapas under /mnt/lfs kommer alltså att ligga direkt under roten på LFS-systemet när vi sedan bootar direkt mot det.

lilo

När du slår på strömbrytaren på din dator kontrollerar ditt BIOS från vilken hårddisk (eller annan lagringsenhet) som den ska starta upp systemet. Sedan läser den in bootsektorn, dvs de första 512 byten på hårddisken och kör det program (så kallad boot loader) som ligger där. Det programmet avgör vilket operativsystem som ska startas och från vilken hårddisk och partition som det ska laddas. Med hjälp av lilo kan du generera ett sådant program.

När du kör lilo läser programmet in en konfigurationsfil, /etc/lilo.conf, som innehåller information om vilka operativsystem du har på din dator, och var de ligger. Om du har angett flera operativsystem i konfigurationsfilen kan lilo låta dig välja vilket av dem som ska laddas när du startar datorn. Slutligen genererar alltså lilo en boot loader som den sparar i bootsektorn på din hårddisk. Observera alltså att det inte räcker med att ändra i filen /etc/lilo.conf om du vill ändra på datorns uppstartsbeteende, du måste också köra lilo för att generera en ny bootsektor!

Om du läser mer om lilo på webben kommer du säkert att stöta på ett påstående om att lilo har en begränsning som tvingar Linux-kärnan som lilo laddar att ligga på början av hårddisken (inom de första 1024 cylindrarna). Denna begränsning finns inte i nyare versioner av lilo (till exempel den version som kommer med Red Hat 7.3 eller den version som vi bygger i vårt LFS-system) så det kan du bortse ifrån.

Installera Red Hat

Linux From Scratch byggs och installeras från en befintlig Linux-installation. Om du redan har en sådan som är hyfsat aktuell kan du med största sannolikhet använda den. Tänk bara på att du kommer att behöva opartitionerat diskutrymme (några gigabyte räcker gott) som är dedikerat till ditt nya LFS-system. I så fall kan du gå direkt till nästa avsnitt (partitionering).

Vi kommer här att installera Red Hat 7.3. Det första du behöver är en uppsättning installations-CD-skivor. Om du inte redan har sådana finns det en beskrivning på Red Hats webbplats som beskriver hur du laddar hem ISO-filer som du kan bränna själv.

Eftersom syftet med att installera Red Hat, i det här fallet, är att ha en plattform för att bygga LFS så håller vi installationen så enkel som möjligt. Om du vill behålla din Red Hat-installation senare, för andra syften, bör du kanske göra vissa saker annorlunda (installera fler paket, ha en annan partitions-strategi, etc).

I det här fallet behöver du bara ha en standard "Workstation"-installation, vilket innebär att du kan välja standardvärden hela vägen. Det enda du behöver välja ytterligare är att ställa om till svenskt tangentbord (om det är det du använder) och ange vilken tidszon du befinner dig i (UTC+1 om du är i Sverige). När jag gjorde installationen kunde Red Hat identifiera all min hårdvara utom min bildskärm, men den kunde jag hitta bland listan av bildskärmar som Red Hat visade.

Något du måste tänka på är att lämna några gigabyte ledigt utrymme på hårddisken för ditt LFS-system! Därför kan du vara tvungen att ändra lite på de värden som installationsprogrammet föreslår för partitionsstorlekar. Enklast är kanske om du har en särskild hårddisk som du tänkt installera ditt LFS-system på, men det är absolut inte nödvändigt!

Det är också bra att kunna komma åt internet om du har möjlighet. Om du inte har det kan du förstås ladda hem all programvara och LFS-dokumentationen via en annan dator, bränna allt på CD, och installera från den. För att komma åt internet måste du ange fungerande nätverksinställningar (IP-adress, nätverksmask, default gateway, DNS, DHCP, etc), men det fungerar på precis samma sätt som om du installerar till exempel Microsoft Windows, så jag beskriver inte det närmare här.

Partitionera hårddisken för LFS

Att partitionera hårddisken för ett Linux-system kan vara en obegriplig konst om man inte förstår syftet bakom övningen... Egentligen är det inte svårt alls! Om du, som i vårt fall, bara ska experimentera och lära dig mer om Linux behöver du bara en enda partition som filsystemet kan ligga på. Du bör dessutom skapa ytterligare en partition som används för virtuellt minne (en swap-partition). Det finns också många tumregler för hur stor swap-partitionen ska vara, men sammantaget handlar det om mellan halva och dubbla storleken på ditt RAM-minne i datorn. Om du inte vill välja själv så sätt helt enkelt storleken på swap-partitionen till att vara lika stor som internminnet i datorn. När du bestämt hur stor swap-partitionen ska vara kan du helt enkelt använda resten av det lediga utrymmet till din LFS-installation.

Du kan också använda samma swap-partition som du säkert redan skapat för din Red Hat-installation även till ditt LFS-system. Kom bara ihåg att om du senare bestämmer dig för att helt överge Red Hat-installationen så måste du behålla swap-partitionen (eller skapa en ny).

Om du söker efter rekommendationer för olika partitions-strategier kommer du säkert att hitta instruktioner om att en särskild partition ska användas för /boot-katalogen, där Linuxkärnan ligger. Det finns fortfarande anledningar till att skapa en sådan partition, men den viktigaste anledningen finns dock inte kvar längre: lilo hade tidigare en begränsning om var på hårddisken som Linuxkärnan kunde ligga, och det löste man enklast med en särskild partition för detta. Numera är den begränsningen borta.

Skapa först lämpliga partitioner med cfdisk, sedan bygger du upp ett filsystem på LFS-partitionen, med hjälp av mkfs.

När du partitionerat och formatterat (skapat filsystem på) partitionen som LFS-systemet ska ligga på, kommer du åt den genom att koppla den till ditt Red Hat-filsystem med mount. För att det ska vara enkelt att följa instruktionerna i LFS-boken väljer vi att koppla den till samma ställe i filsystemet, /mnt/lfs. Först skapar du katalogen dit LFS-partitionen ska kopplas:

mkdir /mnt/lfs

Sedan kopplar du partitionen till katalogen. Om vi antar att partitionen heter /dev/hdb1 (första partitionen på andra hårddisken) så ser kommandot ut så här:

mount /dev/hdb1 /mnt/lfs

Du är nu redo att börja bygga upp LFS-systemet! För att det ska vara lättare att följa LFS-boken skapar vi också en miljövariabel med namnet LFS som pekar ut "roten" till LFS-systemet, inkopplat i ditt Red Hat-system:

export LFS=/mnt/lfs

Variabeln LFS kommer att användas flera gånger när du installerar systemet, och betyder alltså "roten i filsystemet där LFS ska installeras". Observera att det kan vara farligt för ditt plattformssystem om du använder variabeln utan att ha definierat den. Om du till exempel inte gett LFS något värde, och kör kommandot:

echo "root:x:0:0:root:/root:/bin/bash" > $LFS/etc/passwd

så kommer din lösenordsfil i plattformssystemet att skrivas över! Om du är det minsta osäker på om LFS-variablen har ett värde (till exempel om du kör flera terminalfönster – variabler sätts inte automatiskt i alla fönster om du sätter den i ett av fönstren) bör du kontrollera det genom att köra kommandot:

echo $LFS

Om sökvägen /mnt/lfs skrivs ut är allt grönt.

Skapa katalogstrukturen

Nu börjar vi bygga upp strukturen på vårt LFS-system. Det första vi ska göra är att skapa alla de systemkataloger som ett Linux-system är uppbyggt av. Sedan ska vi hämta de programpaket vi behöver och bygga dem. Från och med nu kommer jag att hänvisa alltmer till LFS-boken, eftersom allt som behöver göras beskrivs där. Här kommer jag bara förklara övergripande vad ska ske, och ibland dyka in på någon detalj som inte beskrivs så noga i LFS-boken.

Nu när vi börjar arbeta med LFS-systemet är det ännu viktigare att vi inte av misstag förändrar saker i vårt plattformsystem (Red Hat, om du valt att följa mina instruktioner ovan). För att förhindra det skapar vi först en ny, "vanlig" användare i plattformsystemet, som vi arbetar från. På så sätt behöver vi inte köra som "root", och riskera att viktiga systemfiler förändras av misstag. Det här avsnittet beskriver hur du gör det.

När du skapat den nya användaren (lfs) och loggat in som den, är det dags att skapa systemkatalogerna. Kommandona du ska använda för att göra det finns i det här avsnittet. På den sidan finns också en länk till FHS (Filesystem Hierarchy Standard). Där kan du läsa mer om vad alla katalogerna har för syfte och vilka filer som förväntas finnas där.

Hämta programpaketen

Nu är det dags att hämta hem alla de programpaket som vi ska använda för att bygga ihop vårt LFS-system. Själva poängen med LFS är ju att vi, genom att bygga direkt från källkoden, kan få systemet precis som vi vill ha det. Men eftersom vi också vill ta tillfället i akt att lära oss hur ett Linux-system är uppbyggt och inte vill ha onödigt krångel med vilka versioner av programpaketen som fungerar med varandra, så väljer vi att använda precis de programpaket som beskrivs i LFS-boken version 3.3. När vi är klara med det systemet kan vi uppgradera programpaketen som vi vill.

Vi skulle kunna gå till alla de webbplatser som har hand om respektive programpaket och hämta hem dem var för sig, men LFS-projektet har varit vänliga nog att samla alla paket som används i boken på ett ställe. Du kan antingen hämta programpaketen var för sig, eller alla i en enda tar-fil. Vi väljer det senare (enkla) alternativet!

Lägg tar-filen i katalogen $LFS/usr/src/lfs, och packa upp den där. (Du har väl skapat LFS-variabeln?) Det kan du göra så här (filen som laddas ned är 85,21 megabyte stor, så det kan ta ett tag, beroende på hur snabb internetkoppling du har):

mkdir -p $LFS/usr/src/lfs &&
cd $LFS/usr/src/lfs &&
ncftpget ftp://ftp.linuxfromscratch.org/lfs/lfs-packages/3.3/lfs-packages-3.3.tar &&
tar xf lfs-packages-3.3.tar

I aktuell katalog har du nu, förutom den arkivfil du laddade hem, en komprimerad tar-fil för varje programpaket som utgör det kompletta LFS-systemet. Om allt gick bra kan du ta bort den stora arkivfilen nu – den kommer du inte att behöva längre:

rm -f lfs-packages-3.3.tar

De enskilda arkivfilerna för respektive programpaket ska du dock behålla ett tag. Vi ska nämligen kompilera de flesta paketen två gånger, först statiskt och sedan dynamiskt.

Bygg statiskt

Äntligen är det dags för oss att börja kompilera och bygga ihop programpaketen som är byggstenarna i vårt alldeles egna Linux-system! Jag hoppas du tycker att det känns spännande, för det är vad du kommer att göra de närmaste timmarna... :-)

De flesta programpaketen kommer vi som sagt att bygga två gånger, både statiskt och dynamiskt. Varför gör vi då detta? (Program som är byggda dynamiska använder så kallade shared libraries. Mer information om det kan du hitta på nätet.)

Naturligtvis vill vi att vårt slutgiltiga system så långt det är möjligt ska byggas upp av dynamiskt byggda program, eftersom det sparar resurser. Men problemet är att om vi bygger dynamiskt från vårt plattformsystem så kommer dess dynamiska bibliotek att användas. När vi senare byter miljö till vårt LFS-system så kommer inte de förväntade biblioteken att finnas där, och programmen kommer inte att fungera.

Därför måste vi först bygga de centrala programmen statiskt, så att de blir fristående fungerande exekverbara program, utan beroenden till resten av miljön. Då först kan vi gå in i vår LFS-miljö och därifrån bygga hela systemet dynamiskt.

Dags att bygga! Utgå från katalogen dit du sparade programpaketen som du hämtat, dvs $LFS/usr/src/lfs. Därifrån kommer proceduren för att bygga varje enskilt paket att se ut ungefär så här:

1. Packa upp arkivfilen som programpaketet ligger i (med kommandot tar). Alla arkivfilerna innehåller en katalog i sig, med samma namn som programpaketet. Denna katalog skapas när du packar upp paketet, och i den ligger alla filer.
2. Gå ned i katalogen som skapades
3. Bygg programmet enligt instruktioner från boken. Jag beskriver det mer nedan.
4. Gå tillbaka till $LFS/usr/src/lfs, och ta bort katalogen som du använt för att bygga programmet ifrån. Ta inte bort arkivfilen – den behöver du senare!
5. Gör samma sak med nästa programpaket tills alla paket är byggda

I princip går byggandet till genom att följande tre kommandon körs, från programpaketets källkodskatalog:

./configure &&
make &&
make install

Oftast så tillkommer det dock några små detaljer. Ibland måste till exempel programmet fixas till med patch eller sed, och ofta måste du ange vissa parametrar till make eller configure för att ändra vissa saker.

En återkommande sådan parameter i den här fasen av installationen är -static, eller någon variant därav. Det anger helt enkelt att vi ska bygga programmet statiskt. Standardvalet brukar annars vara att bygga dynamiskt.

Här nedan är en lista på alla programpaket som ska byggas i den här fasen. Länkarna går till respektive beskrivning i boken, där du ser exakt vilka steg som måste utföras för att fullfölja byggningen. Antingen skriver du av kommandona rad för rad, eller så kopierar du allt från boken till ett terminalfönster. Var dock noga med att du gör det till rätt terminalfönster, där du loggat in som lfs-användaren, och skapat LFS-variabeln.

Observera att varje sida innehåller, förutom de kommandon som behövs för att bygga paketen, information om exakt vilka programfiler som skapas, och oftast också vad de har för syfte. Eftersom hela den här övningen går ut på att vi ska lära oss mer om Linux så föreslår jag att du passar på att läsa igenom de korta beskrivningarna på varje sida, så att du vet vad det är du bygger!

Bygg statiskt

Nu ska vi "kliva in i" LFS-miljön för första gången. Det gör vi genom att sätta filsystemsroten (för den process som kör aktuellt skal) till $LFS. När det är gjort kommer de program och bibliotek vi just byggt att användas istället för de som hör till plattformsystemet.

Innan vi tar steget ska vi förbereda några saker. Först skapar vi en /etc/passwd-fil med användaren "root" definierad. Det är den enda vi behöver från början, sedan kan vi skapa fler användare som vanligt, från det färdiga LFS-systemet.

echo "root:x:0:0:root:/root:/bin/bash" > $LFS/etc/passwd

Sedan skapar vi en /etc/group-fil med de grupper vi vill ha definierade från start:

cat > $LFS/etc/group << "EOF"
root:x:0:
bin:x:1:
sys:x:2:
kmem:x:3:
tty:x:4:
tape:x:5:
daemon:x:6:
floppy:x:7:
disk:x:8:
lp:x:9:
dialout:x:10:
audio:x:11:
EOF

Nästa steg är att, med hjälp av mount, koppla upp "pseudofilsystemet" under /proc. Detta filsystem motsvarar inte filer på någon hårddisk, utan är ett "fil-liknande" gränssnitt mot Linux kärna. Mer information om /proc kan du läsa dig till här. Vi passar samtidigt på att sätta ägaren av /proc till "root". (Vi kommer att ändra ägare på resten av filstrukturen senare.)

chown root.root $LFS/proc &&
mount proc $LFS/proc -t proc

Slutligen skapar vi en fil, $LFS/root/.bash_profile, som sätter upp skal-miljön för användaren "root" i ditt LFS-system. Det enda vi gör är att skapa miljövariablerna PS och PATH, som kan vara bra att ha. Skapa filen så här (du kan kopiera och klistra in alla rader i ett terminalfönster.

cat > $LFS/root/.bash_profile << "EOF"
# Begin /root/.bash_profile

PS1='\u:\w\$ '
PATH=/bin:/usr/bin:/sbin:/usr/sbin

export PS1 PATH

# End /root/.bash_profile
EOF

Sätta rotkatalogen för aktuell process görs enkelt med chroot. Vi måste också ange ett kommando som ska köras, vilket vi anger som bash eftersom vi vill fortsätta jobba i den miljön. Vi skapar också en ny uppsättning miljövariabler (genom att först ta bort de gamla med parametern -i) som behövs i den nya miljön. Du måste vara superuser (användaren "root") för att kunna köra kommandot:

cd $LFS &&
chroot $LFS /usr/bin/env -i HOME=/root TERM=$TERM /bin/bash --login

När du bytt till LFS-miljön kommer $LFS-variabeln inte att fylla någon funktion längre, så vi väljer att inte skapa den igen. Den pekade ju ut LFS-trädet relativt plattformsmiljön, men nu när vi kört chroot är det bara den miljön vi har tillgång till.

Ok, nu när vi har gått in i LFS-miljön är det två saker kvar att göra innan vi kan gå vidare och bygga färdigt systemet. Först byter vi ägare på alla kataloger som vi skapade tidigare. Det är ju systemkataloger, som ska ägas av "root".

cd / &&
chown 0.0 . proc &&
chown -R 0.0 bin boot dev etc home lib mnt opt root sbin tmp usr var

Beroende på vilket filsystem du skapade med mkfs så kanske du också har en katalog som heter lost+found i roten. Ändra i så fall ägaren på den katalogen också:

chown 0.0 lost+found

Anledningen att vi anger användaren och gruppen numeriskt (0.0 istället för root.root) är att uppslagningen av användar-id inte fungerar på ditt LFS-system innan vi byggt glibc-paketet, och det gör vi inte förrän senare.

Det andra som ska göras är att skapa filen /etc/mtab som en länk från /proc/mounts. På så sätt är vi säker på att /etc/mtab alltid innehåller aktuell information, eftersom /proc/mounts skapas dynamiskt. (Det är egentligen ingen "riktig" fil, utan snarare ett gränssnitt mot Linux-kärnan, precis som alla andra "filer" under /proc.)

ln -s /proc/mounts /etc/mtab

Bygg dynamiskt och installera

Japp, nu är det dags att bygga igen, för andra (och sista!) gången. Proceduren är väldigt lik den vi gjorde när vi byggde statiskt, med skillnaden att nu kommer vi att bygga fler paket, och inte använda några -static-flaggor.

Här nedan är en lista på de paket vi ska bygga. Precis som förut bör du gå in på varje sida och följa instruktionerna. Passa på att lära dig mer om vad paketen du installerar har för funktion också!

Såja, det gick väl fort och lätt? Nej, det tar ett tag att bygga allting, men jag hoppas att du tagit tillfället i akt att lära dig en massa saker under tiden! Håll ut – nu är det inte mycket kvar!

Konfigurera systemet

Flera av de program som du nu installerat måste konfigureras på olika sätt. Vi måste till exempel ställa in vilket tangentbord vi vill använda och vilken tidszon vi befinner oss i. De konfigureringar som måste göras beskrivs på den här sidan i boken.

Sedan är det dags att beskriva hur systemet ska startas upp, dvs boot-processen. Denna har ett helt eget kapitel i LFS-boken, och du bör faktiskt läsa igenom hela det och följa instruktionerna där. Att förstå hur boot-processen går till på ett Linux-system är en av nyckelkunskaperna för att "få grepp om" systemet.

Bygg Linux-kärnan

Att bygga om kärnan i ett Linux-system är oftast det som känns mest "skrämmande" för Linux-nybörjare. Och visst går det att göra fel, och visst kan ett fel resultera i ett obrukbart operativsystem. Men det är ändå en relativt enkel och säker aktivitet, och det är utan tvekan något som du som aspirerande Linux-guru måste ha bra koll på hur det går till!

I korthet kan du läsa om hur det går till på den här sidan i LFS-boken. Det viktigaste kommandot är:

make menuconfig

Detta kommando startar ett litet menydrivet program som låter dig ange alla parametrar som behövs för hur Linux-kärnan ska byggas, på ett hierarkiskt sätt. Här anger du vilka "finesser" som ska byggas in i kärnan, och vilka optimeringar som ska göras. Följ bara de enkla instruktionerna i LFS-boken så kommer det nog att gå bra. Mer utförliga instruktioner hittar du också i The Linux Kernel HOWTO.

Sätt upp ett boot-bart system

Två steg kvar innan vi har vårt färdiga, boot-bara, LFS-system klart! Först ska vi skapa filen /etc/fstab. (Se beskrivningen av mount för mer information om vad /etc/fstab har för syfte.)

Följ instruktionerna i LFS-boken så har du snabbt en fungerande /etc/fstab. Glöm bara inte att redigera filen och ange de korrekta partitionerna som ditt LFS-system och din swap-partition använder, och vilket filsystem du valt tidigare.

Slutligen – som allra sista steg – ska vi skapa en bootsektor med hjälp av lilo, som gör att vi faktiskt kan starta datorn direkt in i vårt nya Linux-system. Beskrivningen i LFS-boken visar hur du sätter upp lilo så att du kan välja mellan att starta ditt LFS-system eller ditt Red Hat-system (eller vilket din plattformsystem nu råkar vara). Det är nog en bra idé att börja med den uppsättningen. När du sedan har testat att LFS-systemet fungerar bra kan du förstås välja att så småningom ta bort ditt plattformssystem helt och hållet.

Vi använder ju oss av lilo som bootloader i vårt system, men det är värt att nämna att ett alternativ till lilo finns – grub – som verkar vara bättre på många sätt. Mitt råd är ändå att börja sätta upp ett fungerande system med lilo och sedan ta en titt på om grub ger dig någon extra funktionalitet som du saknar.

Nu är ditt system klart! Dags att testa. Om du är osäker på hur du gör för att starta om din Linux-maskin hittar du instruktioner i LFS-boken. Men innan du gör det tycker jag att du ska ta en minut till att registrera dig som LFS-användare, så att de som ligger bakom Linux From Scratch får lite feed-back på att deras insats har gett något! Sen är det bara att starta om. Ha så skoj!

Avsteg från LFS-boken

I den här artikeln har jag visat hur du kan ta den enkla (om än tidsödande) vägen, genom att följa LFS-boken till punkt och pricka. Å andra sidan är ett hembyggt LFS-system en utmärkt miljö för experiment. Det har till exempel säkert kommit ut nya versioner av flera programpaket sedan den version av LFS-boken som vi använder (3.3) släpptes. Prova, om du vill, att använda dem istället. I ett Linux-system finns det dessutom nästan alltid flera olika programpaket som löser samma problem på olika sätt, till exempel olika kommandoskal, cron-program, olika filsystem och så vidare. Här finns oändliga möjligheter att experimentera. Men var beredd på att stöta på problem som kräver en del detektivarbete att lösa...

En enkel "variant" av LFS-bokens installation är att installera en annan texteditor än VIM. Själv föredrar jag, som så många andra, Emacs. (Det finns inget som hindrar att du installerar båda, förstås.) Trots att Emacs är ett stort och synnerligen avancerat program, är det väldigt enkelt att bygga och få att fungera, så det är ett bra program att börja med.

Webbplatsen www.linuxfromscratch.org har en avdelning, hints.linuxfromscratch.org, med extra tips till ditt LFS-system. Där hittar vi också ett tips om hur du bygger Emacs. Prova! Det är inte svårt.

Klart! Men sen, då?

Ok, nu har du ett komplett Linux-system som du byggt själv! I alla fall "komplett" i betydelsen att det är ett fullt fungerande system som står på egna ben. Men givetvis saknas det en massa saker som du tagit för givet när du installerar en "riktig" Linuxdistribution som Red Hat, Mandrake, Debian eller andra. Det mest uppenbara är kanske att du inte har något grafiskt gränssnitt, till exempel Gnome eller KDE. Inte heller finns det några serverprogram som Apache installerat. Men nu är allt det där upp till dig! Det är bara att ta hem källkoden och bygga!

Men att ta dessa fortsatta steg på egen hand kan förstås kännas lite tungt. Då råder jag dig att titta på Beyond Linux From Scratch, en "systersajt" till Linux From Scratch som innehåller just förslag på vilka vägar som är lämpliga att ta när LFS-systemet är färdigt. Även denna information är uppbyggd som en webbaserad bok, med ungefär samma stil som LFS-boken. Skillnaden är att här kan du mera "välja och vraka" vilka programpaket du vill installera – det beror ju på vad du vill ha din installation till.

Jag hoppas att du som följt den här artikeln fått känna tillfredsställelsen av att ha lyckats bygga ihop en egen fungerande Linuxdistribution, och dessutom lärt sig en massa om Linux-system i allmänhet på kuppen! Skicka gärna e-post och berätta hur det gick!

/Robert Burén

Länkar

• Webbplatsen som ligger till grund för den här artikeln:
  Linux From Scratch
• Tips till olika vägar att ta när LFS-systemet är uppe och snurrar:
  Beyond Linux From Scratch
• Arbete har påbörjats för att göra LFS till en "riktig" källkodsbaserad Linuxdistribution:
  Automated Linux From Scratch
• Så gott som alla program i ett Linux-baserat operativsystem kommer från GNU-projektet:
  GNU
• Den största kommersiella Linuxdistributionen, som vi använder som bas i artikeln:
  Red Hat
• Här hittar du mer information om de allra flesta Linuxdistributionerna som finns – och det är många:
  DistroWatch.com
• Ett litet tips: Nu när du har full kontroll på ditt Linux-system tycker jag att du ska se till att det följer standarden också:
  Linux Standard Base