Vraag Inhoud voor Linux Operating Systems Class


Ik zal TA worden voor een klasse besturingssystemen dit komende semester. De labs zullen specifiek omgaan met de Linux Kernel.

  1. Welke concepten / componenten van de Linux-kernel zijn volgens u de belangrijkste in de klas?
  2. Wat wou je dat er in je studies zat dat werd weggelaten?

Alle suggesties met betrekking tot de Linux-kernel of het algehele ontwerp van besturingssystemen zouden zeer op prijs worden gesteld.


34
2018-06-15 14:50


oorsprong


antwoorden:


Mijn lijst:

  1. Wat de zorgen van een besturingssysteem zijn: Abstractie en uitbreiding van de fysieke machine en resource management.
  2. Hoe de bouwproces werkt dat wil zeggen, hoe architectuurspecifiek / machine-codemateriaal is geïmplanteerd
  3. Hoe systeem oproepen werk en hoe modules kunnen koppelen
  4. Geheugen management / Virtueel geheugen / paging en de rest
  5. Hoe processen worden geboren, leven en sterven in POSIX en andere systemen
  6. userpace versus kerneldraden en wat het verschil is tussen proces / threads
  7. Waarom het monolithisch kernelontwerp groeit moeizaam en wat zijn de alternatieven
  8. Planning (en enkele van de alternatieve / domeinspecifieke planners)
  9. IO, Driver ontwikkeling en hoe ze dynamisch worden geladen
  10. De vroege stadia van opstarten en wat de kernel doet om de omgeving in te stellen
  11. Problemen met klokken, mmu-less systemen, enz
  12. ... ik zou door kunnen gaan ...
  13. Ik was bijna vergeten IPC en Unix 'alles is een ontwerpbeslissing van een bestand
  14. POSIX, waarom het bestaat, waarom het niet zou moeten

Laat ze uiteindelijk doorgaan de moderne besturingssystemen van tanenbaum en doe ook casestudies over een aantal andere kernels zoals de microkernel-setup van Mach / Hurd en misschien wat gedistribueerde en exokernel-dingen.

Geef ook een brede kijk op Linux, neem ik mee

Voor degenen die super nerd zijn, de geschiedenis van besturingssystemen en waarom ze zijn zoals ze zijn.


21
2018-06-15 14:55



De laag Virtual File System is een absolute must voor elke klasse Linux Operating System.

Ik nam een ​​vergelijkbare klas op de universiteit. Het meest frustrerende maar tegelijk behulpzame project was het schrijven van een klein bestandssysteem voor het Linux-besturingssysteem. Om dit te laten werken duurt ~ 2-3 weken voor een groep van 4 personen en leer je echt de ins en outs van de kernel.


13
2018-06-15 15:05



Ik heb onlangs een klasse besturingssystemen gevolgd en vond de projecten uitdagend, maar essentieel om de concepten in de klas te begrijpen. De projecten waren ook leuk, omdat ze ons daarbij betrokken waren eigenlijk werken met de Linux-broncode (versie 2.6.12 of daaromtrent).

Hier is een lijst met een aantal redelijk goede projecten / concepten waarvan ik denk dat ze in elke klasse van besturingssystemen moeten worden behandeld:

  • Het verschil tussen gebruikersruimte en kernelruimte
  • Proces management (d.w.z fork(), exec(), enz.)
  • Schrijf een kleine schaal die kennis van aantoont fork() en exec()
  • Hoe systeemaanroepen werken, d.w.z. hoe schakelen we van gebruiker- naar-kernelmodus
  • Voeg een eenvoudige systeemaanroep toe aan de Linux-kernel en schrijf een testtoepassing die de systeemaanroep oproept om aan te tonen dat deze werkt.
  • Synchronisatie in en uit de kernel
  • Implementeer synchronisatieprimitieven in gebruikersruimte
  • Begrijp hoe synchronisatieprimitieven in de kernelruimte werken
  • Begrijp hoe synchronisatieprimitieven verschillen tussen single-CPU-architecturen en SMP
  • Voeg een eenvoudige systeemaanroep toe aan de Linux-kernel die kennis aantoont van het gebruik van synchronisatieprimitieven in de Linux-kernel (dwz iets dat bijvoorbeeld de taaklijstvergrendeling moet verwerven, enz., Maar maak er ook iets van waar u kmalloc moet hebben, wat kan niet worden gedaan terwijl je een slot vasthoudt (behalve als je GFP_ATOMIC gebruikt, maar dat zou eigenlijk niet moeten gebeuren))
  • Planningsalgoritmen en hoe planning plaatsvindt in de Linux-kernel
  • Wijzig de Linux-taakplanner door uw eigen planningsbeleid toe te voegen
  • Wat is paging? Hoe werkt het? Waarom pagingen we? Hoe werkt het in de Linux-kernel?
  • Voeg een systeem aanroep toe aan de Linux-kernel die, gegeven een adres, zal vertellen of dat adres aanwezig is of dat het is uitgewisseld (of een andere opdracht met betrekking tot paging).
  • Bestandssystemen - wat zijn ze? Waarom bestaan ​​ze? Hoe werken ze in de Linux-kernel?
  • Schijfplanningalgoritmen - waarom bestaan ​​ze? Wat zijn ze?
  • Voeg een VFS toe aan de Linux-kernel

5
2018-06-17 14:34



Nou, ik heb zojuist mijn OS-cursus dit semester afgerond, dus ik dacht dat ik het zou zeggen.

Ik was nogal overstuur dat we niet echt met het eigenlijke besturingssysteem speelden, maar gewoon met systeemprogrammering. Ik zou aanraden om de labs op iets te laten staan ​​dat in het besturingssysteem zelf zit, en dat is wat het klinkt als wat je wilt doen.

Een laboratorium dat ik leuk vond en nuttig vond, was echter het schrijven van onze eigen malloc / gratis routines. Het was moeilijk, maar ook heel vermakelijk.

Misschien ook betrekking hebben op het laden van programma's in het geheugen en / of het instellen van de geheugenbeheerder (zoals paging).


4
2018-06-15 14:56



Voor labo's is een ding dat cool kan zijn, om hen echte code te laten zien en erover te discussiëren, vragen te stellen over wat ze denken dat dingen op die manier zijn gedaan en niet een andere, etc.

Als ik weer op de universiteit zou zijn, zou ik zeker meer diepgaande lessen waarderen over synchronisatieprimitieven, concurrency, enzovoort ... dat zijn moeilijke zaken die moeilijker te benaderen zijn zonder de juiste begeleiding. Ik herinner me dat ik ging naar een toespraak van Paul "Rusty" Russell over spinlocks en andere synchronisatieprimitieven die absoluut rad was, misschien kon je het in youtube vinden en wat ideeën lenen.


4
2018-06-15 15:12



Een ander goed onderwerp (of mogelijk oefening voor de studenten) zou virtualisatie zijn. Vooral de 'lguest' van Rusty Russel, die is ontworpen als een eenvoudige introductie tot wat nodig is om een ​​besturingssysteem te virtualiseren. De documenten zijn ook goed te lezen.


4
2018-06-16 11:23



Ik heb in de lente net een klas genomen die perfect bij je beschrijving past (OS Design met linux). Ik was er eigenlijk heel erg mee gefrustreerd omdat ik het gevoel had dat de leraar te nauw was gericht op de projecten in plaats van een breder begrip te geven. Ons laatste project draaide bijvoorbeeld rond futexen. Mijn partner en ik hebben nauwelijks geleerd wat ze waren, lieten het werken (een beetje) en hebben het toen ingeleverd. Ik kwam weg met geen enkele algemene kennis over iets dat echt van dat project afkomstig was. Ik wou dat een van de projecten was om een ​​eenvoudige apparaatstuurprogramma te schrijven of iets dergelijks.

Met andere woorden, ik denk dat het goed is om ervoor te zorgen dat er een goed breed overzicht wordt gepresenteerd, met zo veel details als u zich kunt veroorloven, maar uiteindelijk breed. Ik voelde me alsof mijn leraar deze kleine gebieden nitpicked en ons daar intensief op heeft laten focussen, terwijl ik uiteindelijk NIET wegkwam met het grote algemene begrip van de innerlijke werking van Linux.

Een ander ding dat ik zou willen opmerken is veel waarom ik geen kennis van de klas vasthield, gebrek aan organisatie. Onderwerpen kwamen elke week uit het niets en er was geen routekaart. Geef het materiaal een logische flow. Geestelijke organisatie is de sleutel tot het behouden van de kennis.


4
2018-06-17 14:02



Het netwerksubsysteem is ook best interessant. Je zou een pakket kunnen volgen als het van de socket-systeemoproep naar de draad gaat en andersom.

Leuke opdrachten kunnen zijn:

  • maak een state-complete firewall met behulp van netfilter
  • maak een HTTP-load balancer
  • ontwerp en implementeer een eenvoudig tunnelingprotocol

2
2018-06-15 15:12



Geheugen toegewezen I / O en de 1g / 3g vs 2g / 2g verdeling tussen kernel-adresruimte en gebruikersadresseerbare ruimte in 32-bits besturingssystemen.

Beperkingen van 32-bits architectuur op de harde schijf en wat dit betekent voor het ontwerpen van bestandssystemen.

Eigenlijk gewoon alle voor- en nadelen van naar 64 bit gaan, wat het betekent en waarom, evenals de geschiedenis en waarom zijn er nog niet.


1