Linux-startprocessen är stegen genom vilka Linux- baserade operativsystem görs redo . Denna process liknar på många sätt uppstart av BSD och andra Unix -liknande system som den kommer från.
När datorn startar sker en seriell överföring av kontroll från datorns systemfirmware ( BIOS eller UEFI ) till starthanteraren och från den till kärnan . Kärnan startar sedan schemaläggaren (för multitasking) och kör init- programmet (som ställer in användarmiljön och möjliggör användarinteraktion och inloggning), varefter kärnan går inaktiv tills den tar emot ett externt anrop.
Huvudsakliga nedladdningssteg:
När en avstängning inträffar anropas init för att avsluta program på användarnivå på ett kontrollerat sätt, även enligt skript. Efter det stängs init , och kärnan utför sin egen avstängning.
Vid uppstart via BIOS: Bootloader-faserna varierar beroende på plattform. Eftersom de tidiga startstegen är oberoende av operativsystemet, startar startprocessen vanligtvis så här:
Från och med nu fortsätter nedladdningen. Den första fasen laddar resten av loaderkoden, som vanligtvis frågar vilket operativsystem (eller sessionstyp) användaren vill köra. Bootloader-koden genereras från en konfigurationsfil /etc/lilo.conf (для LILO)som definierar de tillgängliga systemen. Den här filen innehåller särskilt information om startpartitionen och kärnans plats för vart och ett av dessa system, såväl som ytterligare startalternativ, om några. Som ett resultat av valet laddas lämplig kärna in i RAM , det minsta initiala filsystemet konfigureras från bildfilen ( initrd ), och sedan, tillsammans med lämpliga parametrar, överförs kontrollen till det nya operativsystemet.
LILO och GRUB har vissa skillnader: [1]
Vid uppstart via UEFI: I UEFI startar starthanteraren omedelbart i skyddat läge (32-bitars eller 64-bitars) och i själva verket laddas alla faser av starthanteraren på en gång (med hänsyn till uppstart från servicepartitionen finns det inget behov av för att bootloadern ska dela upp sig själv i separata faser och placera dem på olika platser ). Annars skiljer sig inte processen för att ladda och initiera kärnan från BIOS-versionen.
BIOS:
GRUB stöder både direkt- och kedjestart, såväl som LBA, ext2 och "en sann kommandoorienterad, pre-op-miljö på x86-maskiner." Den har tre gränssnitt: urvalsmeny, inställningsredigerare och kommandokonsol. [fyra]
UEFI:
LILO är äldre än GRUB och nästan identisk i drift, förutom att den inte innehåller något kommandoradsgränssnitt. Därför måste alla ändringar göras i dess inställningar och skrivas till MBR, varefter systemet startas om. Således kan en felaktig konfiguration göra disken ostartbar utan användning av en separat startenhet ( diskett , etc.) som innehåller ett program för att rätta till felet. [3] Dessutom känner inte LILO igen filsystem; istället lagras bildfilsadresserna direkt i MBR, [3] och BIOS används för att komma åt dem direkt.
Ett annat sätt att starta Linux är från DOS eller Windows 9x , där Linux-kärnan helt kommer att ersätta den körande kopian av operativsystemet. Detta kan vara användbart om hårdvaran måste inkluderas i programvaran, och motsvarande program finns endast för DOS, och inte för Linux, eftersom det är tillverkarens proprietära programvara och en affärshemlighet. Denna startmetod är inte särskilt relevant, eftersom Linux har drivrutiner för många hårdvaruenheter, även om den har varit ganska användbar tidigare.
Ett annat exempel är när Linux finns på en lagringsenhet som inte är designad för att startas från BIOS: DOS eller Windows kan ladda lämpliga drivrutiner för att kringgå denna BIOS-begränsning och sedan starta Linux därifrån.
Linux-kärnan hanterar viktiga funktioner som minneshantering , uppgiftshanterare , I/O , kommunikation mellan processer och övergripande systemhantering. Nedladdningen sker i två steg: först laddas kärnan (i form av en komprimerad bildfil) in i RAM och packas upp, sedan konfigureras sådana grundläggande funktioner som grundläggande minneshantering. Kontrollen överförs sedan för sista gången till kärnans huvudstartprocess. När kärnan är fullt funktionsduglig (dvs laddad och exekverad sin kod), hittar och startar den init-processen, som oberoende ställer in användarutrymmet och processer som krävs för att användarmiljön ska fungera och den slutliga inloggningen till systemet. Själva kärnan går in i viloläge och är redo för samtal från andra processer.
Kärnan startas vanligtvis som en bildfil komprimerad till zImage- eller bzImage- format med zlib . Den innehåller ett huvudprogram som utför minimal hårdvaruinstallation, packar upp hela bilden till högt minne och monterar RAM-disken om den finns. [5] Därefter kör den kärnstarten via ./arch/x86/boot/headoch process startup_32()(för x86-familjens processorer).
Kärnans startfunktion (även kallad swapper eller process 0 ) organiserar minneshantering ( sidtabeller och minnessökning), bestämmer typen av processor och ytterligare funktioner (som närvaron av en matematisk samprocessor ) och växlar sedan till arkitekturoberoende funktionalitet av Linux-kärnan genom att anropa start_kernel().
start_kernel()utför många initieringsuppgifter. Den ställer in avbrottshanterare ( IRQ ), ställer sedan in minne, startar init-processen (den första användarlägesprocessen) och startar sedan den inaktiva uppgiften genom att anropa cpu_idle(). Observera att kärnans startprocess också monterar den initiala RAM-disken ("initrd") som tidigare laddades som ett temporärt rotfilsystem under uppstartsfasen. Detta gör att drivrutinsmoduler kan laddas utan att förlita sig på andra fysiska enheter och drivrutiner, och att hålla kärnans storlek liten. Rotfilsystemet ersätts därefter med ett anrop pivot_root()som avmonterar det temporära filsystemet och ersätter det med det riktiga rotfilsystemet så snart det senare blir tillgängligt. Minnet som används av det tillfälliga systemet frigörs sedan.
Sålunda initierar kärnan enheter, monterar filsystemet som specificerats av bootloadern i skrivskyddat läge och startar init ( /sbin/init)-processen, som är designad som den första processen som startas av systemet (med process-ID PID = 1). [1] Motsvarande meddelanden visas av kärnan (när filsystemet monteras) och init (när processen med samma namn startas). Kärnan kan också köra en initrd för att hantera inställningar och initiera enheter innan rotfilsystemet monteras. [ett]
Enligt Red Hat kan detaljerna i startprocessen i detta skede sammanfattas enligt följande: [2]
När kärnan startar, initieras och konfigurerar den omedelbart datorns minne och konfigurerar olika hårdvaror som är anslutna till systemet, inklusive alla processorer, I/O-undersystem och lagringsenheter. Den letar sedan efter den komprimerade initrd-bilden på en förutbestämd plats i minnet, dekomprimerar den, monterar den och laddar alla nödvändiga drivrutiner. Den initierar sedan virtuella enheter som är associerade med filsystemet, såsom LVM eller mjukvaru- RAID - arrayer, innan den avmonterar den inre skivavbilden och återtar eventuellt minne som tidigare upptagits av bilden. Kärnan skapar sedan en rotenhet, monterar den skrivskyddade rotpartitionen och frigör eventuellt oanvänt minne. Vid det här laget är kärnan laddad i minnet och är i drift. Men eftersom det inte finns några användarprogram för att ge meningsfull input till systemet, finns det lite som kan göras med det.
Nu när avbrott är aktiverade kan avsändaren ta över den övergripande kontrollen av systemet för att möjliggöra förebyggande multitasking, och initprocessen lämnas för att fortsätta ladda användarmiljön i användarutrymmet.
Init är föräldern till alla processer. Dess huvudsakliga uppgift är att skapa skriptade processer från en /etc/inittab. Den här filen innehåller vanligtvis poster som talar om för init att skapa getty för varje rad som användare kan logga in på. Den styr också offlineprocesserna som krävs av alla system. En runlevel är en programmatisk konfiguration av ett system som tillåter endast en given grupp av processer att existera. Processerna som skapas av init vid var och en av dessa körnivåer definieras i /etc/inittab. [6]
I huvudsak organiserar och underhåller init allt användarutrymme , vilket också inkluderar kontroll och montering av filsystem, start av nödvändiga användartjänster och byte till användarutrymme när systemet har startat upp. Det liknar Unix- och BSD -initieringsprocesserna som det kom ifrån, men i vissa fall har det ändrats eller omdesignats. På ett typiskt Linux-system har init en parameter som kallas runlevel , som tar värden från 1 till 6 och bestämmer vilka delsystem som ska aktiveras. Varje körnivå har sina egna skript som styr de olika processerna som är involverade i att ställa in eller ta bort den körnivån, och det är dessa skript som anses nödvändiga för uppstartsprocessen. Init-skript lagras vanligtvis i kataloger med namn som /etc/rc…. Huvudnivåns konfigurationsfil för init är /etc/inittab. [7]
Under systemstart kontrollerar den om standardnivån beskrivs i /etc/inittab, och om inte, begär den den via systemkonsolen. Den fortsätter sedan med att exekvera alla relevanta startskript för den nivån, inklusive att ladda moduler, kontrollera integriteten för filsystemet (som var monterat skrivskyddat), montera om det läs-skriva och konfigurera nätverket. [ett]
I synnerhet, enligt Red Hat , följer initprocessen detta mönster: [2]
Efter att det har skapat alla givna processer går init in i viloläge och väntar på en av tre händelser:
Detta hänvisar till UNIX System V - stil init - programmet . Andra init-program kan bete sig annorlunda.