Linux internals Brian Ward pdf ladda ner. Linux interner. Hur laddas Linuxkärnan?

Lämna en kommentar 6,950

Vi har gett ut en bok av Brian Ward, som redan har blivit en bästsäljare i väst. Den beskriver alla krångligheterna med att arbeta med operativsystemet Linux, systemadministration och djupgående mekanismer som ger Linux-funktionalitet på låg nivå. På sidorna i denna publikation får du grundläggande kunskaper om att arbeta med Linux-kärnan och principerna för korrekt drift av datornätverk. Boken berör också frågorna om programmering av skalskript och hantering av C-språket, tar upp ämnen som informationssäkerhet, virtualisering och andra oersättliga saker.

Vem borde läsa boken

Intresset för utformningen av operativsystemet Linux kan orsakas av olika anledningar. Informationstekniker och Linux-programutvecklare hittar i den här boken praktiskt taget allt de behöver veta för att få ut det mesta av operativsystemet. Forskare och studenter, som ofta måste skräddarsy systemet för sig själva, hittar här praktiska förklaringar till varför saker och ting fungerar som de gör. Det finns också "underhållare" - användare som gillar att spendera tid vid datorn för skojs skull, för vinst, eller både och. Vill du veta varför vissa saker fungerar och andra inte? Undrar du vad som händer om du ändrar något? Då är du en av "underhållarna".

De nödvändiga förutsättningarna

Du behöver inte vara programmerare för att läsa den här boken. Du behöver bara grundläggande datoranvändarkunskaper: du måste navigera i det grafiska gränssnittet (när du installerar och konfigurerar systemgränssnittet), samt ha en förståelse för filer och kataloger (mappar). Du bör också vara beredd att söka i ditt system och online för ytterligare dokumentation. Som nämnts ovan är det viktigaste din vilja och önskan att utforska din dator.

Hur man läser en bok

När det kommer till tekniska ämnen är det ingen lätt uppgift att förmedla all nödvändig kunskap. Å ena sidan fastnar läsaren i onödiga detaljer och har svårt att greppa essensen, eftersom det mänskliga sinnet helt enkelt inte kan bearbeta ett stort antal nya begrepp samtidigt. Å andra sidan leder bristen på detaljer till att läsaren bara får en vag uppfattning om ämnet och inte är redo att tillgodogöra sig ytterligare material.

I den här boken har författaren förenklat presentationen och strukturerat materialet. I de flesta kapitel presenteras först viktig information som behövs för det fortsatta arbetet. När du läser kapitlet kommer du att stöta på ytterligare material i det. Behöver du omedelbart förstå dessa uppgifter? I de flesta fall tror författaren inte. Om dina ögon börjar bli glamorösa över mängden detaljer relaterade till materialet du just lärt dig, tveka inte att gå vidare till nästa kapitel eller ta en paus. Andra viktiga saker väntar dig.

Hur är denna bok organiserad?

Boken börjar med en översikt över Linux-systemet och ger sedan en serie praktiska övningar med de verktyg du behöver för att komma igång med systemet. Därefter kommer du att utforska varje del av systemet i detalj, från hårdvaruhantering till nätverkskonfiguration, enligt den normala ordningen i vilken systemet startar. Slutligen kommer du att få en förståelse för några av detaljerna i ett fungerande system, lära dig några viktiga färdigheter och bli bekant med de verktyg som programmerare använder.

De flesta av de tidiga kapitlen (förutom kapitel 2) fokuserar mycket på Linux-kärnan, men när du går igenom boken kommer du också att arbeta i ditt användarutrymme. Om du inte förstår vad författaren pratar om nu, oroa dig inte, förklaringar kommer att ges i kapitel 1. Materialet presenteras, när det är möjligt, utan hänvisning till någon systemdistribution. Det skulle vara tråkigt att beskriva alla varianter av systemet, så Ward försökte prata om de två huvudfamiljerna av distributioner: Debian (inklusive Ubuntu) och RHEL/Fedora/CentOS. Tonvikten ligger på server- och arbetsstationsversioner. Inbäddade system som Android och OpenWRT finns också representerade, men du får lära dig skillnaderna mellan dessa plattformar.

Vad är nytt i den andra upplagan

Den första utgåvan av den här boken handlade huvudsakligen om användarsidan av att arbeta på ett Linux-system. Huvudfokus låg på utformningen av dess delar och hur man får dem att fungera. På den tiden var många delar av systemet svåra att installera och konfigurera korrekt.

Tack vare mjukvaruutvecklarnas och Linux-distributionsskaparnas hårda arbete har detta förändrats. Ward reviderade den första utgåvans material för uppdateringar, ägnade särskild uppmärksamhet åt systemets startprocess och hur det hanterar hårdvara, och tog bort föråldrat material (som en detaljerad förklaring av utskriftsprocessen) för att utöka diskussionen om Linux-kärnans roll i varje distribution. Du interagerar förmodligen med kärnan mycket oftare än du inser, och författaren har specifikt noterat de tillfällen då detta händer.

Ward ordnade också om bokens presentation för att passa moderna läsares intressen och behov. Det enda som inte har förändrats är längden på boken.

Författaren ville ge dig den information du behöver för att snabbt komma igång. De kommer att ta lite ansträngning att bemästra, men Ward tänker inte göra dig till en "tyngdlyftare" så att du kan övervinna den här boken. När du väl förstår de viktiga punkterna som beskrivs här blir det lätt för dig att hitta detaljerna och förstå dem.

Författaren har tagit bort några historiska detaljer som fanns i den första upplagan, främst för att fokusera din uppmärksamhet. Om du är intresserad av Linux-systemet och dess förhållande till Unix-systemets historia, se Peter H. Salus bok The Daemon, the Gnu, and the Penguin (Reed Media Services, 2008) - den berättar hur vi använde oss av programvara.

Mer information om boken finns på

Boken du håller i dina händer har redan blivit en bästsäljare i väst. Den beskriver alla krångligheterna med att arbeta med operativsystemet Linux, systemadministration och djupgående mekanismer som ger Linux-funktionalitet på låg nivå. På sidorna i denna bok får du grundläggande kunskaper om att arbeta med Linux-kärnan och principerna för korrekt drift av datornätverk. Boken berör också frågorna om programmering av skalskript och hantering av C-språket, tar upp ämnen som informationssäkerhet, virtualisering och andra oersättliga saker.

Nivåer och lager av abstraktion i operativsystemet Linux

Att använda abstraktioner för att bryta ner datorsystem i komponenter gör dem lättare att förstå, men det gör ingen nytta om det inte finns någon struktur. Vi kommer att ordna komponenterna i lager eller nivåer. Ett lager, eller lager, är ett sätt att klassificera (eller gruppera) komponenter efter deras plats mellan användaren och hårdvaran. Webbläsare, spel etc. finns på det översta lagret; på det nedre lagret ser vi datorns minne: nollor och ettor. Operativsystemet upptar det största antalet lager mellan dessa två.

Operativsystemet Linux har tre huvudnivåer. Hårdvaran är placerad vid basen. De inkluderar minne och en eller flera centralprocessorer (CPU) som utför beräkningar och förfrågningar om att läsa från och skriva till minnet. Enheter som hårddiskar och nätverksgränssnitt betraktas också som hårdvara.

Nivån ovan är kärnan, som är kärnan i operativsystemet. Kärnan är ett program som finns i datorns minne och ger instruktioner till centralprocessorn. Kärnan hanterar hårdvaran och fungerar i första hand som ett gränssnitt mellan hårdvaran och alla program som körs.

Processer – som kör program som hanteras av kärnan – utgör tillsammans den översta nivån i systemet, kallat användarutrymme. En mer exakt term än "process" är "användarprocess", oavsett om användaren interagerar med den processen direkt. Till exempel körs alla webbservrar som användarprocesser.

Det finns en viktig skillnad mellan hur kärnprocesser och användarprocesser startas: kärnan körs i kärnläge, medan användarprocesser körs i användarläge. Kod som körs i kärnläge har obegränsad tillgång till processorn och RAM. Detta är en kraftfull fördel, men det kan vara farligt eftersom det tillåter kärnprocesser att enkelt störa hela systemet. Området som endast är tillgängligt för kärnan kallas kärnutrymme.

Användarläge, i jämförelse, har endast en begränsad (vanligtvis liten) mängd minne tillgängligt och endast processorsäkra instruktioner är tillåtna. Användarutrymme hänvisar till områden med RAM som kan nås av användarprocesser. Om en process misslyckas kommer konsekvenserna att begränsas och kärnan kan rensa upp den. Det betyder att om till exempel din webbläsare kraschar, kommer de vetenskapliga beräkningarna du har kört i bakgrunden i några dagar inte att störas.

Teoretiskt sett är en okontrollerad användarprocess inte kapabel att orsaka betydande skada på systemet. Det beror verkligen på vad du anser vara en "avsevärd skada" och de speciella privilegierna för processen, eftersom vissa processer tillåts göra mer än andra. Kan en användarprocess till exempel förstöra data på en hårddisk fullständigt? Om du konfigurerar behörigheterna på rätt sätt, kan det, och det kommer att vara extremt farligt för dig. Det finns skyddsåtgärder på plats för att förhindra detta, och de flesta processer kommer helt enkelt inte att tillåtas orsaka förödelse på detta sätt.

Grundläggande kommandon och katalogstruktur

Det här kapitlet är en referens till kommandona och verktygen i Unix-operativsystemet. Du känner förmodligen redan till de flesta av dessa kommandon, men för att ge dig lite självförtroende, speciellt när det kommer till katalogstruktur. Här är lite introduktionsmaterial som jag kommer att referera till genom hela boken.

Varför pratar vi om Unix-kommandon? Handlar inte den här boken om hur Linux fungerar? Ja, naturligtvis, om detta, men själva kärnan i Linux är Unix-systemet.

Du kommer att se ordet Unix oftare än Linux här, eftersom det du lär dig omedelbart kan tillämpas på Solaris, BSD och andra Unix-relaterade system. Jag har försökt undvika att täcka för många Linux-specifika användargränssnittstillägg, inte bara för att ge dig en solid grund för att använda andra system, utan också för att sådana tillägg är ganska instabila. Du kommer att kunna anpassa dig till nya Linux-utgåvor snabbare om du kan de grundläggande kommandona.

Hur laddas Linuxkärnan?

Nu vet du om den fysiska och logiska strukturen i ett Linux-system, vad kärnan är och hur man arbetar med processer. Du kommer att få information om hur kärnan startar eller startar, med andra ord hur kärnan flyttas in i minnet fram till den punkt där den första användarprocessen startar. Ett förenklat diagram över laddningsprocessen ser ut så här.

Systemets BIOS eller startfirmware laddar och kör systemets starthanterare.
Systemets starthanterare lokaliserar kärnavbildningen på disken, laddar den i minnet och kör den.
Kärnan initierar enheter och deras drivrutiner.
Kärnan monterar rotfilsystemet.
Kärnan kör kommandot init med process ID1. Denna punkt är början på användarutrymme.
Kommandot init startar resten av systemprocesserna.
Vid något tillfälle startar kommandot init en process som låter dig logga in på systemet. Detta händer vanligtvis i slutet eller strax innan systemet startar.

Steg ett till fyra täcks här, med fokus på kärnan och systemstartladdare. Kapitel 6 fortsätter historien om att ladda användarutrymme.

Att kunna identifiera varje steg i startprocessen kommer att vara ovärderligt när du ska felsöka startproblem, och kommer också att hjälpa dig att förstå systemet som helhet. Men standardstartläget i många versioner av Linux gör ofta några av de tidiga stegen svåra (om inte omöjliga) att identifiera, och du kommer förmodligen bara att kunna titta på dem när de är klara, efter att du har loggat i.

Introduktion till C Code Compiler Software

De flesta offentligt tillgängliga programvarupaket från tredje part för Unix kommer i källkod som du kan bygga och installera. En anledning till detta är att det finns så många olika versioner och arkitekturer av Unix (och själva Linux) att det skulle vara svårt att skapa binära paket för alla möjliga plattformskombinationer. En annan viktig anledning är att den breda distributionen av källkod i Unix-communityt uppmuntrar användare att fixa buggar i programvaran och introducera nya funktioner, vilket ger en mening åt termen "öppen källkod".

Nästan allt du ser på ett Linux-system kan erhållas som källkod, från kärnan och C-biblioteket till webbläsare. Det är till och med möjligt att uppdatera och utöka systemet som helhet genom att (om)installera delar av systemet från källkoden. Du bör dock förmodligen inte uppgradera din dator genom att installera allt från källan om du inte gillar processen eller har någon annan anledning.

Linux ger vanligtvis enkla sätt att uppdatera kritiska delar av systemet, såsom kommandon i /bin-katalogen, och en extremt viktig egenskap hos systemen är att de vanligtvis fixar säkerhetsproblem mycket snabbt. Förvänta dig dock inte att din version ger allt du behöver utan din input. Här är några anledningar till varför du kan behöva installera vissa paket själv:

att styra konfigurationsparametrar;
för att installera programvaran där du behöver den. Du kan till och med installera flera olika versioner av samma paket;
för att styra vilken version du installerar. Systemdistributioner har inte alltid den senaste versionen av alla paket, särskilt de som är relaterade till ytterligare programvara (som Python-bibliotek);
för att bättre förstå hur paketet fungerar.

Webbservrar och applikationer

Linux är ett populärt system för webbservrar, och den regerande monarken bland Linux-applikationsservrar är Apache HTTP Server (vanligen kallad Apache). En annan webbserver du ofta kommer att höra talas om är Tomcat (också ett projekt av Apache-utvecklarna); det ger stöd för Java-applikationer.

Webbservrar själva gör inte mycket: de kan lagra filer, och det är ungefär det. Det slutliga målet för de flesta webbservrar, som Apache, är att tillhandahålla en plattform för att köra webbapplikationer. Till exempel är Wikipedia-projektet byggt på MediaWiki-paketet, som du kan använda för att organisera ditt eget wiki-projekt. Innehållshanteringssystem som WordPress och Drupal låter dig skapa dina egna bloggar och multimediawebbplatser. Alla dessa applikationer är baserade på programmeringsspråk som fungerar särskilt bra på Linux. Exempelvis är MediaWiki, WordPress och Drupal-system skrivna i PHP.

Byggstenarna som utgör webbapplikationer är mycket modulära, så det är enkelt att lägga till dina egna tillägg och bygga applikationer med ramverk som Django, Flask och Rails, som tillhandahåller faciliteter för vanliga webbramverk och funktioner, som att använda mallar, multi- användarhantering och databasstöd.

Ladda ner från gratis fillagring

Lös captcha för att komma åt länkarna!

Aktuell sida: 1 (boken har totalt 30 sidor) [tillgänglig läsning: 17 sidor]

Brian Ward

Linux interns

Översättare S. Chernikov

Teknisk redaktör N. Grinchik

Litterär redaktör O. Andrievich

Konstnärer A. Bartsevich, V. Shimkevich

Korrekturläsare T. Kuryanovich, E. Pavlovich

Layout A. Bartsevich

Brian Ward

Linux interner. – St Petersburg: Peter, 2015.

ISBN 978-5-496-01952-1

Alla rättigheter förbehållna. Ingen del av denna bok får reproduceras i någon form utan skriftligt tillstånd från upphovsrättsinnehavarna.

Förord

Jag skrev den här boken med tron att för att vara framgångsrik och effektiv måste du förstå hur din datormjukvara fungerar och fungerar.

Operativsystemet Linux är bra för att lära sig eftersom det mesta av systemkonfigurationen lagras i enkla filer som är ganska lätta att läsa. Du måste bara ta reda på vad varje del är ansvarig för och sedan sätta ihop allt. Detta är vad den här boken är tillägnad.

Vill du veta varför vissa saker fungerar och andra inte? Undrar du vad som händer om du ändrar något? Då är du en av "underhållarna".

De nödvändiga förutsättningarna

I den här boken har jag förenklat presentationen och strukturerat materialet. I de flesta kapitel presenteras först viktig information som behövs för det fortsatta arbetet. När du läser kapitlet kommer du att stöta på ytterligare material i det. Behöver du omedelbart förstå dessa uppgifter? I de flesta fall tror jag inte. Om dina ögon börjar blixtra över mängden detaljer relaterade till materialet du just lärt dig, tveka inte att gå vidare till nästa kapitel eller ta en paus. Andra viktiga saker väntar dig.

Praktiskt tillvägagångssätt

För att arbeta behöver du en dator med operativsystemet Linux. Du kanske föredrar en virtuell installation – jag använde VirtualBox för att testa det mesta av materialet i den här boken. Du måste ha superuser (root) åtkomst, även om du bör använda ett standardanvändarkonto för det mesta. Du kommer främst att arbeta på kommandoraden, terminalfönstret eller fjärrsessionen. Om du inte har arbetat i den här miljön ofta, är det okej, du kommer att lära dig mer om det i kapitel 2.

Vanligtvis ser kommandona ut så här:

Skriv in text som är markerad i fetstil; Svarstexten som maskinen kommer att producera visas med normalt teckensnitt. $-symbolen är en uppmaning till en användare med ett vanligt konto. Om du ser #-symbolen vid prompten bör du använda superanvändarkontot (mer om detta i kapitel 2).

Hur är denna bok organiserad?

Materialet presenteras när det är möjligt utan hänvisning till någon systemdistribution. Det skulle vara tråkigt att beskriva alla systemvarianter, så jag försökte prata om de två huvudfamiljerna av distributioner: Debian (inklusive Ubuntu) och RHEL/Fedora/CentOS. Tonvikten ligger på server- och arbetsstationsversioner. Inbäddade system som Android och OpenWRT finns också representerade, men du får lära dig skillnaderna mellan dessa plattformar.

Vad är nytt i den andra upplagan

Tack vare mjukvaruutvecklarnas och Linux-distributionsskaparnas hårda arbete har detta förändrats. Jag har granskat den första utgåvans material för uppdateringar, ägnat särskild uppmärksamhet åt systemets startprocess och hur det hanterar hårdvara, och tagit bort föråldrat material (som en detaljerad förklaring av utskriftsprocessen) för att utöka diskussionen om Linux:s roll kärnan i varje distribution. Du interagerar förmodligen med kärnan oftare än du inser, och jag har specifikt noterat de tillfällen då detta händer.

Jag har också gjort om bokens presentation för att passa dagens läsares intressen och behov. Det enda som inte har förändrats är längden på boken.

Jag ville ge dig den information du behöver för att snabbt komma igång. De kommer att ta lite ansträngning att bemästra, men jag tänker inte göra dig till en "tyngdlyftare" så att du kan övervinna den här boken. När du väl förstår de viktiga punkterna som beskrivs här blir det lätt för dig att hitta detaljerna och förstå dem.

Jag har tagit bort några historiska detaljer som fanns i den första upplagan, främst för att fokusera din uppmärksamhet. Om du är intresserad av Linux-systemet och dess förhållande till Unix-systemets historia, kolla in boken av Peter H. Salus Demonen, Gnuen och Pingvinen(Reed Media Services, 2008) – Den talar om hur mjukvaran vi använder har utvecklats.

En anteckning om terminologi

För närvarande pågår en debatt om namnen på vissa delar av operativsystem. Även namnet på Linux-systemet är inblandat - ska det heta Linux eller GNU/Linux (för att spegla användningen av vissa delar av GNU-projektet)? I boken försökte jag använda de vanligaste och minst krångliga namnen som möjligt.

Erkännanden

Jag tackar alla som hjälpt mig att arbeta med den första upplagan. Dessa är James Duncan, Douglas N. Arnold, Bill Fenner, Ken Hornstein, Scott Dickson, Dan Ehrlich, Felix Lee Felix Lee, Scott Schwartz, Gregory P. Smith, Dan Sully, Karol Jurado och Gina Steele. För den här upplagan tackar jag särskilt Jordi Gutiérrez Hermoso för hans utmärkta tekniska recension; hans förslag och förtydliganden är ovärderliga. Tack också till Dominique Poulain och Donald Karon för deras snabba svar i de tidiga stadierna av arbetet, och till Hsinju Hsieh, som tålmodigt arbetade med mig för att revidera den här boken.

Jag vill också tacka min utvecklingsredaktör, Bill Pollock, och produktionsredaktör, Laurel Chun. Serena Yang, Alison Law och alla på No Starch Press har, som alltid, gjort ett fantastiskt jobb med att producera denna nya upplaga av boken.

Från förlaget

Skicka dina kommentarer, förslag och frågor via e-post [e-postskyddad](Peter förlag, datorupplaga).

Vi vill gärna höra din åsikt!

På förlagets hemsida http://www.piter.com hittar du detaljerad information om våra böcker.

1. Den stora bilden

Vid en första anblick är ett modernt operativsystem, som Linux, ganska komplext och består av ett stort antal delar som samtidigt fungerar och interagerar med varandra. En webbserver kan alltså kommunicera med en databasserver, som i sin tur använder ett delat bibliotek som används av många andra program. Hur fungerar det hela?

Du kan mest effektivt förstå strukturen av operativsystemet med hjälp av abstraktionerär ett snyggt sätt att säga att du ignorerar de flesta detaljerna. Till exempel, när du kör bil behöver du vanligtvis inte tänka på detaljer som monteringsbultarna som håller motorn inne i bilen eller personerna som asfalterar vägen och håller den i gott skick. Om du åker i en bil som passagerare är allt du behöver veta vad bilen är designad för att göra (den tar dig någonstans) och några grundläggande regler för att använda den (hur man hanterar dörren och säkerhetsbältet).

Om du kör bil behöver du veta mer. Du måste bekanta dig med kontrollerna (som ratten och gaspedalen) och vad du ska göra i händelse av ett fel.

Anta att bilen rör sig ryckigt. Du kan dela upp abstraktionen av "en bil som kör på vägen" i tre delar: bilen, vägen och din körstil. Detta kommer att hjälpa till att fastställa orsaken. Om vägen är gropig behöver du inte skylla på bilen eller dig själv. Istället kan du försöka ta reda på varför vägen försämrades, eller, om vägen är ny, varför dess byggare gjorde ett så fruktansvärt jobb.

Mjukvaruutvecklare använder abstraktion som ett verktyg när de skapar operativsystem och applikationer. Det finns många termer för abstraherade områden av datorprogramvara, inklusive delsystem, modul Och plastpåse. Men vi kommer att använda termen i detta kapitel komponent för det är enkelt. När utvecklare skapar en mjukvarukomponent bryr sig vanligtvis inte så mycket om den interna strukturen hos andra komponenter, men de måste tänka på vilka komponenter de kan använda och hur de kan använda dem.

Det här kapitlet ger en allmän översikt över komponenterna som utgör ett Linux-system. Även om var och en av dem har en otrolig mängd tekniska detaljer relaterade till den interna strukturen, kommer vi inte att uppmärksamma dem och fokusera på vad dessa komponenter gör i förhållande till systemet som helhet.

1.1. Nivåer och lager av abstraktion i operativsystemet Linux

Att använda abstraktioner för att bryta ner datorsystem i komponenter gör dem lättare att förstå, men det gör ingen nytta om det inte finns någon struktur. Vi kommer att ordna komponenterna i lager eller nivåer. Lager, eller nivå,är ett sätt att klassificera (eller gruppera) komponenter efter deras plats mellan användaren och hårdvaran. Webbläsare, spel etc. finns på det översta lagret; på det nedre lagret ser vi datorns minne: nollor och ettor. Operativsystemet upptar det största antalet lager mellan dessa två.

Det finns tre huvudnivåer i operativsystemet Linux. I fig. Figur 1.1 visar nivåerna, samt några av komponenterna inom var och en av dem. Vid basen finns hårdvara. De inkluderar minne och en eller flera centralprocessorer (CPU) som utför beräkningar och förfrågningar om att läsa från och skriva till minnet. Enheter som hårddiskar och nätverksgränssnitt betraktas också som hårdvara.

Nivån ovanför ligger kärna, som är kärnan i operativsystemet. Kärnan är ett program som finns i datorns minne och ger instruktioner till centralprocessorn. Kärnan hanterar hårdvaran och fungerar i första hand som ett gränssnitt mellan hårdvaran och alla program som körs.

Processer – som kör program som hanteras av kärnan – utgör tillsammans översta nivån i systemet, kallad användarutrymme.

Notera

En mer exakt term än "process" är "användarprocess", oavsett om användaren interagerar med den processen direkt. Till exempel körs alla webbservrar som användarprocesser.

Det finns en viktig skillnad mellan hur kärnprocesser och användarprocesser startas: kärnan startas i kärnläge, och användarprocesser - in användarläge. Kod som körs i kärnläge har obegränsad tillgång till processorn och RAM. Detta är en kraftfull fördel, men det kan vara farligt eftersom det tillåter kärnprocesser att enkelt störa hela systemet. Området som endast är tillgängligt för kärnan anropas kärnutrymme.

I användarläge, som jämförelse, är endast en begränsad (vanligtvis liten) mängd minne tillgängligt och endast processorsäkra instruktioner är tillåtna. Användarutrymmeär områden av RAM som kan nås av användarprocesser. Om en process misslyckas kommer konsekvenserna att begränsas och kärnan kommer att kunna rensa upp den. Det betyder att om till exempel din webbläsare kraschar, kommer de vetenskapliga beräkningarna du har kört i bakgrunden i några dagar inte att störas.

Ris. 1.1. Generell struktur för operativsystemet Linux

1.2. Hårdvara: RAM

Av all datorhårdvara Baggeär kanske det viktigaste. I sin mest råa form är RAM bara ett stort lager av strängar av ettor och nollor. Varje nolla eller etta kallas bit. Det är här den körande kärnan och processerna finns - de är bara stora samlingar av bitar. All in- och utdata från kringutrustning passerar genom RAM också i form av uppsättningar av bitar. CPU:n arbetar helt enkelt på minnet: den läser instruktioner och data från den och skriver sedan tillbaka data till minnet.

Du kommer ofta att stöta på termen "stat", som kommer att hänvisa till minne, processer, kärna och andra delar av ett datorsystem. Strängt taget är ett tillstånd vilket ordnat arrangemang av bitar som helst. Till exempel, om det finns fyra bitar i minnet, representerar sekvenserna 0110, 0001 och 1011 tre olika tillstånd.

När man tänker på att en process lätt kan bestå av miljontals bitar av minne är det ofta lättare att använda abstrakta termer när man talar om tillstånd. Istället för att beskriva ett tillstånd med hjälp av bitar pratar man om vad som hände eller händer för tillfället. Till exempel kan du säga "den här processen väntar på inmatning" eller "processen utför det andra steget av sin startprocedure."

NOTERA

Eftersom tillstånd vanligtvis beskrivs med hjälp av abstrakta begrepp snarare än faktiska bitar, används termen "bild" för att hänvisa till varje fysiskt arrangemang av bitar.

1.3. Kärna

Nästan allt kärnan gör involverar RAM. En av kärnans jobb är att distribuera minne i flera undersektioner, varefter kärnan hela tiden måste hålla information om tillståndet för dessa undersektioner i ordning. Varje process använder ett minnesområde som tilldelats den, och kärnan måste se till att processer håller sig till sina områden.

Kärnan ansvarar för att hantera uppgifter i fyra huvudområden i systemet.

Processer. Kärnan ansvarar för vilka processer som tillåts åtkomst till den centrala processorn.

Minne. Kärnan behöver hålla reda på tillståndet för allt minne: vilken del som för närvarande är allokerad till vissa processer, vad som kan tilldelas för delning mellan processer och vilken del som är ledig.

Drivrutiner för enheter. Kärnan fungerar som ett gränssnitt mellan hårdvara (som en hårddisk) och processer. Vanligtvis utförs hårdvaruhantering av kärnan.

SystemsamtalOchStöd. Processer använder vanligtvis systemanrop för att kommunicera med kärnan.

Vi kommer nu att titta kort på vart och ett av dessa områden.

NOTERA

För mer information om hur kärnan fungerar, se Operating System Concepts, 9:e upplagan, av Abraham Silberschatz, Peter B. Galvin och Greg Gagne (Wiley, 2012) och Modern Operating Systems, 4:e upplagan av Andrew S. Tanenbaum och Herbert. Bos (Prentice Hall, 2014).

1.3.1. Processledning

Processledning beskriver start, stopp, återupptagande och avslutning av processer. Koncepten bakom att starta och stoppa processer är ganska enkla. Det är lite svårare att beskriva hur en process använder processorn under normal drift.

I alla moderna operativsystem fungerar flera processer "samtidigt". Du kan till exempel starta en webbläsare på din dator och öppna ett kalkylblad samtidigt. Men saker och ting är inte som de verkar: processerna som är ansvariga för dessa ansökningar startar vanligtvis inte Vnoggrannhet vid en tidpunkt.

Tänk på ett system med en central processor. Flera processer kan använda det, men vid varje given tidpunkt kan bara en process faktiskt använda processorn. I praktiken använder varje process processorn under en liten bråkdel av en sekund och pausar sedan; efter det använder en annan process processorn under en liten bråkdel av en sekund; sedan kommer turen till den tredje processen etc. Åtgärden där en process överför kontrollen över processorn till en annan process kallas kontextbyte.

Varje tidsperiod - kvantum av tid– ger processen tillräckligt med tid för att utföra betydande beräkningar (och naturligtvis slutför processen ofta sin nuvarande uppgift inom ett kvantum). Eftersom tidssegment är så små uppfattar en person dem inte och det verkar för honom som om flera processer körs samtidigt i systemet (denna möjlighet är känd som "göra flera saker samtidigt").

Kärnan är ansvarig för kontextväxling. För att förstå hur detta fungerar, föreställ dig en situation där en process körs i användarläge, men dess tidsperiod håller på att ta slut. Det här är vad som händer.

1. Processorn (riktig hårdvara) avbryter den aktuella processen med hjälp av en intern timer, växlar till kärnläge och återställer kontrollen till den.

2. Kärnan registrerar det aktuella tillståndet för processorn och minnet, vilket kommer att behövas för att återuppta den just avbrutna processen.

3. Kärnan utför alla uppgifter som kan ha dykt upp under föregående tidssegment (till exempel datainsamling eller I/O-operationer).

4. Kärnan är nu redo att starta en annan process. Den analyserar listan över processer som är redo att köras och väljer en av dem.

5. Kärnan förbereder minnet för den nya processen och förbereder sedan processorn.

6. Kärnan talar om för processorn hur länge tidsdelen för den nya processen kommer att pågå.

7. Kärnan sätter processorn i användarläge och överför kontrollen till processorn.

Kontextbyte svarar på en viktig fråga: När körs kärnan? Svaret är: kärnan fungerar mellan tidssegment som allokeras för processer när en kontextväxling inträffar.

På ett system med flera processorer är saker och ting lite mer komplicerade, eftersom kärnan inte behöver sluta kontrollera den aktuella processorn för att tillåta någon process att köras på en annan processor. Och ändå, för att få ut det mesta av alla tillgängliga processorer, gör kärnan fortfarande detta (och kan använda vissa knep för att få ytterligare processortid).

1.3.2. Minneshantering

Eftersom kärnan måste hantera minne under kontextväxlingar är den utrustad med denna komplexa funktion. Driften av kärnan är komplex eftersom följande villkor måste beaktas:

Kärnan måste ha ett eget minnesområde som inte kan nås av användarprocesser;

Varje användarprocess behöver sitt eget minnesområde;

Någon användarprocess får inte ha tillgång till minne som är allokerat till en annan process;

Användarprocesser kan dela minne;

En del minne för användarprocesser kan vara skrivskyddat;

Systemet kan använda mer minne än vad som är tillgängligt genom att använda diskutrymme som en extra enhet.

Kärnan har en hjälpare. Moderna processorer innehåller minneshanteringsmodul(MMU), som aktiverar en minnesåtkomstkrets som kallas "virtuellt minne". När virtuellt minne används, kommer en process inte åt minnet direkt från sin fysiska plats i hårdvaran. Istället konfigurerar kärnan varje process som om den hade kontroll över hela maskinen. När en process kommer åt minnet, fångar MMU:n förfrågan och använder en minnesadresskarta för att översätta minnesplatsen som lärts från processen till en fysisk minnesplats på datorn. Men kärnan måste fortfarande initiera, kontinuerligt underhålla och modifiera denna adresskarta. Till exempel, under en kontextväxling måste kärnan ändra kartan efter den avgående processen och förbereda den för den kommande.

Notera

Implementeringen av en minnesadresskarta kallas en sidtabell.

Du kommer att lära dig hur du övervakar minnesprestanda i kapitel 8.

1.3.3. Enhetsdrivrutiner och hantering

Kärnans jobb med avseende på enheter är ganska enkelt. Vanligtvis är enheter endast tillgängliga i kärnläge, eftersom felaktig åtkomst (till exempel när en användarprocess försöker stänga av strömmen) kan få datorn att krascha. Ett annat problem är att olika enheter sällan har samma mjukvarugränssnitt, även om de utför samma uppgift: till exempel två olika nätverkskort. Av denna anledning är drivrutiner traditionellt en del av kärnan och strävar efter att tillhandahålla ett enhetligt gränssnitt till användarprocesser för att göra mjukvaruutvecklarnas arbete enklare.

1.3.4. Systemsamtal och support

Det finns andra typer av kärnfunktioner tillgängliga för användarprocesser. Till exempel, systemsamtal utföra speciella uppgifter som en användarprocess inte kan utföra väl eller alls på egen hand. Alltså involverar alla åtgärder relaterade till att öppna, läsa och skriva filer systemanrop.

Två systemanrop, fork() och exec(), är viktiga för att förstå hur processer startas:

Gaffel(). När en process anropar fork(), skapar kärnan en nästan identisk kopia av processen;

Exec(). När en process anropar exec( program), kör kärnan programmet program, som ersätter den nuvarande processen.

Med undantag för initprocessen (kapitel 6), Allt användarprocesser på ett Linux-system startar som ett resultat av ett fork()-anrop, och i de flesta fall görs ett exec()-anrop för att starta ett nytt program snarare än en kopia av en befintlig process. Ett enkelt exempel är alla program som du kör från kommandoraden, till exempel kommandot ls som visar innehållet i en katalog. När du anger kommandot ls i ett terminalfönster, anropar skalet som körs inuti terminalfönstret fork() för att skapa en kopia av skalet, och sedan anropar den nya kopian av skalet exec(ls) för att köra kommandot ls. I fig. Figur 1.2 visar sekvensen av processer och systemanrop för att köra program som ls.

Ris. 1.2. Startar en ny process

NOTERA

Systemanrop betecknas vanligtvis med parenteser. I exemplet som visas i fig. 1.2 måste en process som begär att kärnan ska skapa en annan process utfärda systemanropet fork(). Denna beteckning kommer från hur anrop skrivs i programmeringsspråket C. Du behöver inte kunna C för att förstå den här boken. Kom bara ihåg att ett systemanrop är en interaktion mellan en process och kärnan. Dessutom förenklar den här boken vissa grupper av systemsamtal. Exec()-anropet betecknar till exempel en hel familj av systemanrop som utför en liknande uppgift men skiljer sig i sin mjukvaruimplementering.

Kärnan stöder också användarprocesser vars funktioner skiljer sig från traditionella systemanrop. De mest kända av dem är pseudoenheter. Ur användarprocessernas synvinkel ser pseudoenheter ut som vanliga enheter, men de implementeras helt i mjukvara. Faktum är att de formellt inte borde finnas i kärnan, men de finns fortfarande i den av praktiska skäl. Till exempel skulle en enhet som genererar slumptal (/dev/random) vara svår att implementera med den nödvändiga graden av säkerhet med hjälp av en användarprocess.

notera

Tekniskt sett är en användarprocess som kommer åt en pseudoenhet fortfarande tvungen att göra ett systemanrop för att öppna den enheten. Processer kan alltså inte helt undvika systemanrop.

1.4. Användarutrymme

Området med RAM som kärnan allokerar för användarprocesser kallas användarutrymme. Eftersom en process bara är ett tillstånd (eller en bild) i minnet, kommer användarutrymmet också åt minnet för hela samlingen av pågående processer. Du kan också stöta på termen "användarland", som används istället för användarutrymme.

Det mesta av den verkliga handlingen i ett Linux-system sker i användarutrymmet. Även om alla processer är desamma ur kärnans synvinkel, utför de olika uppgifter för användarna. Systemkomponenter som representerar användarprocesser är organiserade i en elementär struktur - ett servicelager (eller lager). I fig. Figur 1.3 visar en ungefärlig uppsättning komponenter som är sammankopplade och interagerar med Linux-systemet. Enkla tjänster finns på den nedre nivån (närmast kärnan), hjälpprogram finns i mitten och applikationer som användaren arbetar med finns överst. Figur 1.3 är ett extremt förenklat diagram eftersom endast sex komponenter visas, men du kan märka att de översta komponenterna är närmast användaren (användargränssnittet och webbläsaren); mellanskiktskomponenter har en e-postserver som använder en webbläsare; Det finns flera små komponenter i botten.

Den lägre nivån består vanligtvis av små komponenter som utför enkla uppgifter. Mellanskiktet innehåller större komponenter som e-posttjänsten, skrivarservern och databasen. Komponenter på toppnivå utför komplexa uppgifter som ofta styrs direkt av användaren. Om en komponent vill använda en annan, är den andra komponenten antingen på samma servicenivå eller lägre.

Figur 1.3 visar endast i grova drag layouten för användarutrymmet. I verkligheten finns det inga regler i användarutrymmet. Till exempel registrerar de flesta applikationer och tjänster diagnostiska meddelanden som anropas tidningar. De flesta program använder standardtjänsten syslog för att logga meddelanden, men vissa väljer att göra loggningen själva.

Ris. 1.3. Typer av processer och interaktioner

Dessutom kan vissa användarutrymmeskomponenter vara svåra att kategorisera. Komponenter på serversidan, såsom en webbserver eller en databasserver, kan betraktas som applikationer på mycket hög nivå eftersom de utför ganska komplexa uppgifter. Sådana applikationer kan placeras överst i figuren. 1.3. Samtidigt kan användarapplikationer vara beroende av serverapplikationer för att utföra uppgifter som de inte kan hantera på egen hand. I det här fallet bör serverkomponenterna placeras på mellannivån.

1.5. Användare

Linux-kärnan stöder det traditionella konceptet med en Unix-systemanvändare. Användareär en enhet som kan köra processer och egna filer. Associerad med användare Användarnamn. Till exempel kan systemet ha en användare som heter billyjoe. Men kärnan fungerar inte med användarnamn, istället identifierar den användaren med en enkel siffra användar ID(Kapitel 7 talar om hur ID mappar till användarnamn).

Brian Wards bok, som redan har blivit en bästsäljare i väst. Den beskriver alla krångligheterna med att arbeta med Linux OS, systemadministration och djupgående mekanismer som ger Linux-funktionalitet på låg nivå. På sidorna i manualen får du grundläggande kunskaper om att arbeta med Linux-kärnan och principerna för korrekt drift av datornätverk, inte bara baserade på Open-source-lösningar. Boken berör också frågor om manusprogrammering och hantering av C-språket, tar upp ämnen som informationssäkerhet, virtualisering och andra oersättliga saker.
Vem borde läsa boken:
Intresset för utformningen av operativsystemet Linux kan orsakas av olika anledningar. Informationstekniker och Linux-programutvecklare hittar i den här boken praktiskt taget allt de behöver veta för att få ut det mesta av operativsystemet. Forskare och studenter, som ofta måste skräddarsy systemet för sig själva, hittar här praktiska förklaringar till varför saker och ting fungerar som de gör. Det finns också "underhållare" - användare som gillar att spendera tid vid datorn för skojs skull, för vinst, eller både och. Vill du veta varför vissa saker fungerar och andra inte? Undrar du vad som händer om du ändrar något? Då är du en av "underhållarna".
De nödvändiga villkoren:
Du behöver inte vara programmerare för att läsa den här boken. Endast grundläggande PC-användarkunskaper krävs: du måste navigera i det grafiska gränssnittet (när du installerar och konfigurerar systemgränssnittet), samt ha en förståelse för filer och kataloger (mappar). Du bör också vara beredd att söka på Internet efter ytterligare dokumentation. Huvudsaken är din vilja och önskan att utforska din dator.

Titel: Linux Internals
Författare: Brian Ward
Förläggare: Peter
År: 2016
Format: PDF, FB2, EPUB
ryska språket
Sidor: 384
Storlek: 12,9 MB

Linux Internals / Brian Ward / 2016. Ladda ner gratis utan registrering

2016-07-24T17:16:55+00:00 administrationAdministrering Litteraturguider Linux, administration, säkerhet, Brian Ward, böcker, litteratur, manualer, systemadministration, skript, kommandoreferenser

[e-postskyddad] Handledning för administratör LINUX