Lab 2 Operativsystem IS1350

Lab 2 Operativsystem IS1350 2014 1 Introduktion 1.1 Förberedelser Läs igenom labhäftet. Gör uppgifterna i förväg, använd labtiden till att ställa frågor om du kört fast. Läs igenom tipsen om kärnakompilering på http://bobcares.com/blog?p= 162 1.2 Checklista Dator eller VM med Linux (eller motsvarig) OS Följande paket behövs för att kunna kompilera en kärna: gcc, make, binutils. Mer beror på linux distribution. 1.3 Mål Efter laborationen ska du kunna: Installera en operativsystemskärna i Linux. Förklara vad som krävs för att få en kärna att fungera. Beskriva hårdvaran som används i datorn och anvånda informationen för att optimera kärnan. 1

Kompilera en egen kärna och beskriva stegen som behôvs. Kompilera en kärnamodul och beskriva processen. 1.4 Sammanfattning Denna labb syftar till att studera en operativsystemskärna samt programmering i kärnaläge (kernel mode). Vi kommer att bekanta oss med källkodsträdet till Linuxkärnan samt processen för att kompilera en kärna. Vi kommer även att testa att skapa en egen kärnamodul (drivrutin). Labben skall utföras gruppvis på en pc-server körandes Linux. Vissa delar för högre betyg utförs individuellt, vissa gruppvis. 1.5 Redovisning Redovisning kommer att ske gruppvis för betyget godkänt. För högre betyg måste du dessutom redovisa uppgifterna för högre betyg individuellt. (Det är ok att göra uppgifterna i grupp). 1.6 Linuxdistributioner Du kan köra valfri Linuxdistribution. Skrivbordsmiljö behövs inte, men du kan installera något om du vill ha den. Följande lista visar exempel distributioner. Ubuntu http://www.ubuntu.com/ Desktop eller Server SuSE http://www.opensuse.org Fedora http://fedoraproject.org/ Debian http://www.debian.org/ Mint http://www.linuxmint.com/ Arch http://www.archlinux.org/ OBS! Bara för advancerad användare. Gentoo http://www.gentoo.org/ OBS! Bara för mer advancerad användare ;) Om kan eller vilja inte installera Linux på din laptop, du kan installera VMware Player (eller VMware Fusion på OS X) istället och installera Linux på VM:en. 2

OBS! Själva kompilerandet av kärnan tar ganska lång tid. Planera därför din tid så att du kan göra andra skaer medan själva kompileringen pågår. 2 Uppgifter 2.1 Kompilera Linux-kärnan 2.1.1 Bakgrund Kärnan i Linux har till uppgift att hantera processer och minne och vara ett abstraktionslager mot hårdvaran. För att stödja olika typer av hårdvara läggs drivrutinerna i moduler. Dessa kan laddas in/laddas ur vid behov. När en Linuxdistributör gör en livecd med Linux behöver kärnan drivrutiner för alla tänkbara kombinationer av hårdvara. Eftersom bara de nödvändiga modulerna laddas in kan storleken på kärnan hållas nere. Detta var framför allt viktigt förr i tiden när datorer startades på disketter. Idag är det av betydelse när linux ska köras i t.ex. mobiltelefoner. En linuxkärna kan kompileras från källkod av vem som helst. Det som behövs är en kompilator, till exempel gcc, programmet make, GNU:s programpaket binutils, källkoden till kärnan och gott om tålamod. Att kompilera en kärna tar tid och det kan krävas flera försök innan kärnan fungerar som tänkt. Innan kärnan kompileras behöver den konfigureras. I Linux görs det med hjälp av make-kommandot. Aktuell konfiguration sparas i roten av källkodsträdet under namnet. config. Konfigureringen görs med hjälp av kommandot make. Instruktionerna till make finns lagrade i filen Makefile i roten källkodsträdet. Med parametrar till make kan du välja om du vill konfigurera i text-läge, text-läge med grafik eller i X11-läge. I den här laborationen utgår vi från att du kompilerar i text-läge med grafik. Konfigurationen för en 3.12.x Gentoo kärna, t.ex., är indelad i följande grupper. Gentoo Linux Speciella Gentoo funktioner 64-bit kernel Växeln för i386 eller x86-64 Loadable module support Stöd för laddningsbara moduler Processor type and features Optimeringar av kärnan för olika processorer 3

Power management and ACPI options Strömsparfunktioner enligt ACPI och APM Bus options (PCI etc.) Stöd för olika busstyper som t.ex. PCI, PCI-X och PCMCIA Executable file formats / Emulations Format för körbara filer, endast ELF är intressant för normala Linuxdistributioner Networking support Stöd för olika typer av nätverk (stöd för hårdvara finns under Device Drivers), t.ex. trådlösa nät Device Drivers Drivrutiner för hårdvara, t.ex. IDE, SCSI, USB, nätverk Firmware Drivers Stöd för att använda BIOS för olika funktioner Filesystems Drivrutiner för olika filsystemformat, t.ex. EXT3, EXT4 och VFAT Kernal hacking Inställningar för avlusning av kärnan Security options Inställningar för säkerhet som t.ex. SE-Linux Cryptographic API Kryptografiska algoritmer Virtualization Stöd för hosting av gästoperativsystem Library routines CRC-algoritmer För prestandaoptimering är avsnitten Processor type and features och Kernel hacking av störst betydelse. Eftersom det kan finnas flera drivrutiner som är olika bra anpassade för samma hårdvara kan det också löna sig att ta reda på vilka drivrutiner som används av kärnan. Storleken på kärnan avgörs framförallt av valen under avsnitten Networking och Device Drivers. 2.1.2 Uppgift Kataloger Du behöver två kataloger, vi refererar till de som <BUILD> och <SRC>. Du kan skapa de i din hemkatalog om du vill, t.ex. <BUILD>=~/lab2/build och <SRC>=~/lab2/vanilla linux. I katalogen <SRC> ska du spara källkoden till kärnan och i <BUILD>-katalogen hamnar de kompilerade filerna för den nya kärnan. 4

Hämta och installera källkoden Linux källkoden distribueras från http:// www.kernel.org/. Vi kan också hämta den från Sunets ftp-akriv som speglar källkoden: ftp://ftp.sunet.se/pub/linux/kernels. Dessutom många Linuxdistributioner har egen versioner av vanilla -kärnan som kan hämta med distributionens pakethanterare. 1. Tag reda på versionsnumret för din linuxkärna med följande kommando: uname r 2. Lad ner en nyare kärna. Du kan göra det med kommandot wget <url>, t.ex. 3. Packa upp kärnan i <SRC> med tar xfvj linux <version>.tar.bz2 directory <SRC> eller tar zxvf linux <version>.tar.gz directory <SRC>. 4. Skapa en länk till källkodskatalogen så du slipper ange versionsnr när du jobbar med källkoden: ln -s <SRC>/linux-<version> <SRC>/linux Konvertera den gamla konfigurationen När det redan finns en gammal konfiguration så behöver du inte gå igenom hela konfigurationsprocessen och svara på alla frågor. Det räcker med att uppdatera kärnans konfiguration med de ändringar som gjorts mellan den nya och den gamla versionen. Först måste du finna din gamla konfiguration. T.ex. på Ubuntu finns det i /boot/config <din gamla kärna version> och på Gentoo under /usr/src/linux/. config. Kopiera den gamla konfigurationen till <SRC>/linux/.config och byt katalog där. Kompilera kärnan När du börjar kompilera kommer den gamla config-filen att anpassas till den nya kärnan. Du återanvänder då de gamla inställningarna och konfigurerar bara de nya inställningarna som inte fanns med i den gamla kärnan. (Håll ned enter så går det snabbare att svara på frågorna). Kompilera kärnan och modulerna med kommandot 1 make O=<BUILD> Datorer med flera processorer/kärnor eller hyperthreading kan kompilera snabbare om du lägger till växeln j # till kommandot make (byt ut # mot antalet kärnor/cpu:er). Det gäller dock inte om du använder VMware Player som är förinställd på att använda bara en processor. 5

Installera kärnan Nu är det dags att installera kärnan. Det görs i flera steg. Först ska du kopiera kärnan, dess konfiguration och System.map till katalogen /boot. Du behöver också kopiera alla moduler du kompilerat och kanske skapa en initrd. Den senare är en zip-fil som ska innehålla de moduler som kärnan behöver för att kunna läsa från hårddisken vid uppstart, t.ex. drivrutinen för hårddiskkontrollern. Med en statiskt länkad kärna där alla drivrutiner är inbakade i kärnan behövs ingen initrd. Till sist behöver du lägga till din nya kärnan i menyn som visas när Linux startar. 1. Installera vmlinuz, System.map och moduler 1 sudo make O=<BUILD> i n s t a l l 2 sudo make O=<BUILD> m o d u l e s _ i n s t a l l 2. Skapa och installera initrd (om nödvändig) 1 sudo update i n i t r a m f s c k <din nya kärna version > 3. Uppdatera startmenyn Grub Om du har grub version < 2.x eller grub-legacy 1 sudo rm / boot / grub /menu. l s t 2 sudo update grub Grub2 Ibland kommandot kan kallas grub2 mkconfig istället. 1 grub mkconfig o / boot / grub / grub. c f g Lilo Tillägg din nya kärna i /etc/ lilo.conf och kör kommandot lilo för att skriva den nya konfiguration till hårddisken. OBS! Behåll alltid minst en alternativa kärna som du vet fungera i bootmenyn. Testa kärnan Nu återstår bara att starta om datorn och testa att den nya kärnan fungerar. Om den inte gör det får du backa tillbaka till början av labbinstruktionen och försöka igen. 1. Starta om datorn, t.ex. med sudo reboot 2. Du kan behöva välja din kärna i menyn som visas när datorn startar. Kanske måste du tryck på ESC när texten med grub kommer upp i början. 3. Använd versionsnumret på den nya kärnan för att identifiera vilken rad du ska starta med. 6

4. Eftersom du loggar in igen, kontrollera kärnans versionsnumret med uname r. 2.2 Skriva ut meddelanden från kärnan 2.2.1 Introduktion I den här uppgiften ska du ändra i kärnan för att få den att skriva ut ett meddelande vid uppstart, det blir ett hello world! exempel för linuxkärnor. Utskrifter från kärnan kan göras med en funktion som heter printk(). Den motsvarar printf från standardbiblioteken i C. 2.2.2 Uppgift Din utskrift kan du lägga till i filen init /main.c. Det betyder att meddelandet kommer att skrivas ut vid initieringen av kärnan. Leta reda på anropet av funktionen calibrate_delay(). Det kan se ut så här i källkoden: 1 i f ( late_time_init ) 2 late_time_init ( ) ; 3 c a l i b r a t e _ d e l a y ( ) ; 4 pidmap_init ( ) ; Lägg till koden för printk utskriften på raden efter anropet av calibrate_delay(). 1 p r i n t k (? H e l l o I am a k e r n e l hacker! \ n?) ; Spara filen och kompilera om kärnan (Du vet hur du gör nu eller hur?) och installera den. Det kan vara svårt att hinna med att se utskriften så du kan starta på den nya kärnan och köra följande kommando när du loggat in: 1 dmesg grep i h e l l o Kommandot dmesg listar alla utskrifter från kärnan, grep visar bara de meddelanden som innehåller hello och i flaggan gör att grep inte skiljer på stora eller små bokstäver. Kan du använda printf för att skriva ut hello world från kärnan? 7

2.3 Kärnmoduler Kärnan i Linux är modulärt uppbyggd, vilket innebär att drivrutiner och extra funktionalitet läggs i separata binärer. I den här uppgiften ska du skriva en egen modul. Modulen ska räkna antalet avbrott som sker på nätverkskortet och skriva ut dessa. Skelettet för en modul kan se ut så här: 1 #i n c l u d e <l i n u x /module. h> 2 #i n c l u d e <l i n u x / i n i t. h> 3 Listing 1: mymodule.c 4 s t a t i c i n t init mymodule_init ( void ) { 5 p r i n t k ( "My module worked! \ n " ) ; 6 r eturn 0 ; 7 } 8 9 s t a t i c void exit mymodule_exit ( void ) { 10 p r i n t k ( " Unloading my module. \ n " ) ; 11 r eturn ; 12 } 13 14 module_ init ( mymodule_init ) ; 15 module_ exit ( mymodule_exit ) ; 16 MODULE_LICENSE( "GPL" ) ; För att den här laborationen ska fungera måste du ha konfigurerat din kärna att stödja laddningsbara moduler, Lodable module support". 1. Byt katalog till <SRC>/linux/drivers/misc 2. Kopiera texten ovan till en fil med namnet mymodule.c 3. Öppna filen Makefile och lägg till följande rad i slutet av filen 1 obj m += mymodule. o 4. Kompilera din modul. Du behöver inte kompilera om hela kärnan eftersom din modul kan laddas in i kärnen dynamiskt. Skriv in följande på kommandoraden. ($PWD är en bash variabel som innehåller innevarande katalogen.) 1 make O=<BUILD> C <SRC>/ l i n u x SUBDIRS=$PWD modules 5. Nu kan du dynamisk ladda in din modul och se om den fungerar. Det gör du med följande kommandot. 8

1 sudo insmod mymodule. ko 6. Använd dmesg för att se om din modul fungerade. Vilken utskrift ska du få om det fungerar? 7. Ladda ur din modul från kärnan med kommandot 1 sudo rmmod mymodule 2.3.1 En riktig modul Nu ska du göra en modul som räknar antalet avbrott som nätverkskortet genererar och skriver in det i kärnaloggen. Först lägger vi till en include fil högst upp i modulfilen: 1 #i n c l u d e <l i n u x / i n t e r r u p t. h> Nu kommer den svåra delen, att lista ut vilka avbrott som används av nätverkskortet i din dator. Skriv på kommandoraden 1 cat / proc / i n t e r r u p t s Första kolumnen listar vilket avbrottsnummer andra kolumnen antalet avbrott och den tredje vilken enhet som är kopplad till avbrottet. I din nya modul ska du lägga till stöd för parametrar. Parametrar anger du tillsammans med insmod kommandot: 1 sudo insmod mymodule. ko {param1=value param2=value... } Kommandot ovan är rätt meningslöst om du inte skriver lite kod som kan använda parametrarna. Vi ska ta avbrottsnummer och enhetsnamn som parametrar. 1 #d e f i n e BUFLEN 10 2 s t a t i c i n t i r q ; 3 s t a t i c char i n t e r f a c e [BUFLEN] 4 module_param_string ( i n t e r f a c e, i n t e r f a c e, BUFLEN, 0) ; 5 MODULE_PARM_DESC( i n t e r f a c e, "A network i n t e r f a c e " ) ; 6 module_param ( irq, int, 0) ; 7 MODULE_PARM_DESC( irq, " The IRQ o f the network i n t e r f a c e " ) ; 9

Avbrottshanterare När det sker ett hårdvaruavbrott med ett visst nummer så kommer avbrottshanterarna som registrerat sig för att lyssna på avbrottet att anropas av kärnan. 1 i n t request_irq ( unsigned i n t irq, 2 void ( handler ) ( int, void, s t r u c t pt_reqs ), 3 unsigned long i r q f l a g s, 4 const char devname, 5 void dev_id ) ; Funktionen request_irq() lägger till din modul till listan på funktioner som ska anropas när det sker ett avbrott. Vilket avbrott vi vill lyssna på anges som en parameter till request_irq(). Övriga parametrar är en pekare till din funktion som ska anropas av kärnan när det sker ett avbrott, en flagga, namnet på enheten och ett id som identifierar vår avbrottshanterare. Du kan skriva in följande kod för din avbrottshanterare. 1 s t a t i c i n t init mymodule_init ( void ) { 2 i f ( r e q u e s t _ i r q ( irq, &myinterrupt, IRQF_SHARED, i n t e r f a c e, & i r q ) ) { 3 p r i n t k (KERN_ERR " mymodule : cannot r e g i s t e r IRQ %d\n ", i r q ) ; 4 r eturn EIO ; 5 } 6 p r i n t k ( " Request on IRQ %d succeeded \n ", i r q ) ; 7 r eturn 0 ; 8 } Nu ska du lägga till en funktion som avregistrerar din modul från listan av avbrottshanterare. Avregistrering sker genom att anropa free_irq som tar två parametrar, avbrottsnummer och id:et på din avbrottshanterare. Du kan lägga till följande kod i funktionen mymodule_exit(): 1 f r e e _ i r q ( irq, &i r q ) ; 2 p r i n t k ( " Freeing IRQ %d\n ", i r q ) ; Eftersom flera olika enheter kan dela på samma avbrott skulle vi egentligen behöva titta på registren för att avgöra om det var nätverkskortet som genererade avbrottet. I en riktig modul skulle vi göra detta och om avbrottet var avsett för en annan enhet skulle vi skicka vidare avbrottet till nästa hanterare, annars meddela kärnan att avbrottet är hanterat och inte ska skickas vidare. Eftersom din modul inte hanterar enheter, bara räknar avbrott, måste vi skicka vidare alla anrop till 10

nästa hanterare I kedjan. Det gör vi genom att låta vår avbrottshanterare returnera värdet IRQ_NONE. Din avbrottshanterare ska räkna antalet avbrott och det kan den göra med följande kod. 1 s t a t i c i n t mycount = 0 ; 2 s t a t i c i r q r e t u r n _ t myinterrupt ( i n t irq, void dev_id, s t r u c t pt_regs r e g s ) { 3 i f ( mycount < 10) { 4 p r i n t k ( " I n t e r r u p t! \ n " ) ; 5 mycount++; 6 } 7 r eturn IRQ_NONE; 8 } Vid redovisningen ska du kunna förklara vad koden ovan gör! Nu är din modul klar. Kompilera din modul enligt tidigare instruktion och ladda in den i kärnan tillsammans med parametrar för modulnamn och avbrottsnummer: 1 sudo insmod mymodule. ko i n t e r f a c e=eth0 i r q=9 Ditt nätverkskort kanske inte har namnet eth0 och irq 9. Du behöver inte ens använda nätverkskortet, du kan använda valfri enhet som genererar avbrott med jämna mellanrum, t.ex. hårddisken. Vilka namn enheterna har och vilka irq- nummer de använder kan du ta reda på med: 1 cat / proc / i n t e r r u p t s Använd dmesg för att kontrollera att din avbrottsräknare fungerar. Du kan generera lite nätverkstrafik med ping ifall det behövs. Glöm inte att ladda ur modulen. Vilket meddelande skrivs i dmesg när din modul laddas ur? Kan du med cat /proc/interrupts se om din avbrottsrutin är laddad? 11

2.4 Högre Betyg 2.4.1 Slimmad kärna En stor del av processen att kompilera en egen Linux-kärna är att konfigurera vilka moduler man behöver. De centrala delarna i Linux-kärnan som till exempel schemaläggaren eller minneshanteringen går inte att välja till eller bort. Däremot kan man välja exakt vilken hårdvara man vill ha stöd för. I standardkonfigurationen som följer med Ubuntu server är de flesta valen i kärnakonfigurationen aktiva. Eftersom det innebär att mer kod måste kompileras så tar det lång tid för datorn att kompilera ihop kärnan. Därför bör du optimera din kärna så lång som möjligt. Power Management APM är en gammal standard för strömsparfunktioner som ersatts av ACPI. Nyare datorer har ACPI så du kan välja bort APM. Bus options Nyare datorer använder sig av PCI och PCI Express-bussarna. Har du en bärbar dator har den även en PCCard-buss (eller Expresscard). Du kan välja bort ISA, MCA, NatSemi och support för PCI Hotplug. Executable file formats / Emulations format kan du välja bort. Numera används bara ELF, övriga Networking Behåll trådbaserat nätverk (de flesta inställningarna under Networking options). Om du har en bärbar dator behåller du även trådlöst nätverk, Wireless. Övriga alternativ kan du välja bort. Observera att du inte kan välja bort trådlöst nätverk innan du har kryssat bort Wireless LAN under rubriken Device Drivers/Network device support. Device Drivers De flesta alternativen under rubriken handlar om drivrutiner för hårdvaran i datorn. Följande alternativ kan väljas bort: Memory Technology Device (MTD) support Parallell port support 12

Misc Devices IEEE1394 (Firewire) support* I2O device support Macintosh device drivers ISDN support Telephony support I2C support SPI support Dallas 1-wire support (Välj bort Hardware Monitoring support först) Power supply class support* Hardware Monitoring support Watchdog Timer Support Sonics Silicon Backplane (Välj bort Multifunction device drivers först)* Multifunction device drivers* Multimedia devices* Sound* MMC/SD card support InfiniBand support EDAC error detection and reporting Real Time Clock Userspace I/O drivers Firmware Drivers Här kan du välja bort allt File systems De vanligaste filsystemen för Linux är listade direkt under rubriken, dessa ska du behålla. I underrubrikerna behåller du valen under Pseudo filesystems, Partition Types och Native language support. Övriga alternativ kan du välja bort. Kernel hacking Här kan du behålla standardvalen 13

Security options Välj bort bort NSA SELinux Support Cryptographic API Välj bort Hardware crypto devices Virtualization Välj bort hela rubriken Library routines Behåll standardvalen Din uppgift är att med hjälp av konfigurationsverktyget göra en slimmad kärna där mycket onödig tagits bort. Vidare skall viktig hårdvara länkas in statiskt i stället för som moduler. Syftet skall vara att bekanta sig med processen och inte åstadkomma en perfekt slimmad kärna. Denna uppgift kan utföras gruppvis men ska redovisas individuellt. 2.4.2 /proc Många Unixvarianter har ett speciellt filsystem som ligger monterat under /proc. Detta filsystem sparas inte på disk utan är ett virtuellt filsystem i kärnan. Filerna som finns här innehåller t.ex. information om processerna i systemet, avbrottshantering, temperatur på moderkortet m.m. Vissa filer kan man skriva till för att i realtid ändra kärnans beteende. Exempel på saker man kan förändra är TCP/IPinställningar, paketväxling och SysRq. Du skall modifiera den kärnamodul som du skrev i uppgift 2.3. Den skall inte längre skriva ut meddelande till konsolen varje gång det kommer ett avbrott. Istället skall den fortsätta att räkna upp räknaren tills modulen laddas ur. Vidare skall du registrera en skrivskyddad-fil någonstans i /proc-filsystemet. När du gör cat på din fil under /proc så skall värdet i räknaren skrivas ut. Här hittar du information om procfs: http://www.compsoc.man.ac.uk/~moz/ kernelnewbies/documents/kdoc/procfs-guide/lkprocfsguide.html Här hittar du kodexempel och allmän information: http://www.freescale.com/ files/32bit/doc/app_note/an2744.pdf Tips: Funktionen du behöver använda för att skapa en fil i /proc heter create_proc_read_entry();. 14

OBS! Om du använder kernel 3.9 eller nyare: API:t för proc_fs har förändrats och funktionen create_proc_read_entry(); är deprecated nu. Nya funktionen kallas proc_create(). Du kan hitta information om nya API:t på: https://www.linux.com/learn/linux-training/37985-the-kernel-newbie-corner-kerneldebugging-using-proc-qsequenceq-files-part-1. 15