Universitatea POLITEHNICA Bucuresti

Facultatea de Electronica, Telecomunicatii si Tehnologia Informatiei

MICROKERNEL

Petrescu Theodor Eduard

Susanu Cristian-Daniel

Grupa 433A

CUPRINSMonolithic Kernel.................................................................................................3

Microkernel...........................................................................................................3

Microkernel vs Monolithic kernel......................................................................4

Sisteme bazate pe microkernel..............................................................................5

Mach:..................................................................................................................6

Probleme de performanță................................................................................6

L4:......................................................................................................................7

Funcționalitate.................................................................................................7

seL4 (se bazează pe diferite versiuni ale L4):...................................................8

Arhitectura Microkernel........................................................................................9

Performața microkernel....................................................................................10

Nano-Nucleul KeyKOS.......................................................................................11

Fundamente arhitecturale.................................................................................11

Nucleu fara stare...............................................................................................11

Stocare pe un singur nivel................................................................................12

Capabilitati.......................................................................................................13

Obiecte Fundamentale KeyKOS.........................................................................15

Dispozitive.......................................................................................................15

Pagini................................................................................................................15

Noduri..............................................................................................................15

Metri.................................................................................................................16

Domenii............................................................................................................16

Bibliografie..........................................................................................................17

Microkernel

Kernelul este o parte parte importantă a sistemului de operare, care consistă din 2 părți:

-spațiul kernel (modul privilegiat)

-spațiul user (modul user-ului),

și asigură minimul de servicii ale sistemului de operare: spațiere de adrese, comunicare între procese, managementul thread-urilor, identificatori unici.

Modul privilegiat este modul de procesare care conține codul și îi permite accesul direct la toate componentele hardware și memoria din sistem.

Modul user e modul de procesare în care aplicațiile rulează.

Proprietăți ale kernel-ului:-orice apel al sistemului se termină

-nu există excepții

-fără probleme aritmetice fără rezultat (ex: împărțirea la 0)

-fără referințe la pointeri nuli

-fără pierderi de memorie

-evitarea supraîncărcării buffer-ului

-structuri de date bine formate

-înșiruire bine structurată

-două obiecte nu au voie să se suprapună în memorie

Există două concepte diferite de kernel-uri:

-monolithic kernel

-microkernel

Monolithic Kernel

Rulează orice proces de bază al sistemului ca managementul proceselor sau a memoriei, întrerupe manipularea și comunicațiile cu porturile I/O, cu fișierele de sistem in spațiul kernel.

Exemple: Unix, Linux.

Prezintă 3 dezavantaje:

-spațiul kernel este prea mare

-lipsa posibilității de extindere

-mentenanță grea

Repararea bug-urilor sau adăugarea de noi update-uri înseamnă recompilarea întregului kernel. Pentru a trece de aceste limitări de extindere și mentenanță, ideea de microkernel a apărut la sfârșitul anilor 1980.

Microkernel

Kernel-ul este despărțit în procese separate denumite servere. Unele servere rulează în spațiul kernel, altele rulează în spațiul user-ului. Toate serverele sunt separate și ruleaza pe spații diferite de adresă. Comunicațiile între microkernel se fac prin pasare de mesaje. Serverele comunică prin InterProcess Communication (IPC).

Serverele invocă „servicii” de la celelalte prin trimiterea de mesaje. Avantajul constă în faptul că dacă un server „pică” celelalte servere continuă să funcționeze eficient.

Exemple: Mac OS, Windows NT.

Avantaje microkernel:-o interfață microkernel „curată” impune o structură modulară a sistemului

-serverele pot folosi mecanisme date de microkernel ca orice alt program

-astfel, defecțiunile de server sunt izolate ca orice altă defecțiune de program

-sistemul e mult mai flexibil; diferite strategii și API-uri, implementate de diferite servere coexist în sistem

Microkernel vs Monolithic kernel

Kernel-ul monolithic are un design simplu. Acesta folosește un singur proces, mare, ce rulează într-un singur spațiu de adresă. Este un fișier binar static. Toate serviciile kernel există și sunt executate în acest spațiu de adresă.

Pe de altă parte, microkernel-ul este „spart” în procese separate, numite servere. O parte din aceste servere rulează în spațiul de adrese kernel, o altă parte rulează în spațiul user-ului. Comunicarea între ele se realizează prin pasare de mesaje. Serverele comunica prin IPC (Inter-Process Communication).

Serverele invocă servici unul de la celălalt prin trimiterea de mesaje. Această separare are avantajul că dacă un server „pică” celelalte pot funcționa fără probleme.

Sisteme bazate pe microkernel

Prima generație: Mach (1985-1994)

-înlocuiește tehnica pipeline cu IPC

-stabilitate îmbunătățită

-performațe slabe

A doua generație: L3 & L4 (1990-2001)

-îmbunătățiri mari la nivelul performanței IPC

-scris în asamblor, portabilitate scăzută

-kernel foarte mic: mai multe funții mutate in spațiul utilizatorului

A treia generație: seL4, Coyotos, Nova (2000-prezent)

-indepența de platformă

-verificare, securitate, multiple procesoare, etc.

Mach:-IPC asincron

-thread-uri

-programarea funcțiilor

-managementul memoriei

-permisiuni pentru accesul la resurse

-drivere pentru device-uri (toate celelalte funcții sunt implementate în afara kernel-ului)

-marimea API-ului Mach 3: 140 de funcții

Probleme de performanță:

-permisiuni pentru accesul resurselor la apelurile sistemului (mașinile cu un singur utilizator nu au nevoie de așa ceva)

-probleme de performanță ( un kernel trandițional trebuie să fie intreruptibil1

astfel încât programele ce rulează pe diferite procesoare să apeleze kernelul în același timp. În teorie Mach era intreruptibil deoarece avea timp de răspuns rapid și putea rezolva cereri pe rând, însă folosirea IPC-ului pentru toate sarcinile crea serioase probleme de performanță. Un studiu din 1997 arăta că un server bazat pe Mach 3.0 era cu 50% mai încet decât UNIX-ul nativ.

-altă problemă a fost folosirea unei soluții pentru a permite programatorilor de a avea contact direct cu paginatorul pentru a evita pierderea unor părți din cod de către paginator. Această soluție se adăuga problemelor deja existente de performanță

L4:-minimalitate ( un concept este tolerat în microkernel doar dacă, atunci când este mutat în exterior ar preveni implementarea funcționalității sistemului. Principiu inventat și descris de Brinch Hansen.)

-design construit de la 0

-primitive rapide

Funcționalitate:

-thread-uri (unitate de execuție, identificat prin ID, alcătuit din: pointer de instrucțiune, stivă, registre și fanioane)

-programare procese (implementate de kernel, bazate pe priorități)

-management-ul memoriei (toate funcțiile sunt implementate în afara kernel-ului)

-spațiu de adresă: 1.map/unmap ( share-uire/revocare pagină cu alt spațiu de adresă

2.permisiune (furnizarea paginii către alt spațiu de adresă)

3.flush (posesorul spațiului de adresă poate îndepărta orice pagină a sa)

-marimea API-ului L4: 7 funcții

Principiul minimalității: un concept e acceptat în interiorul microkernel-ului dacă mutarea lui în afară (permiterea implementărilor concurente), previne implementarea funcționalității sistemului.

Fred Brooks despre integritatea conceptuală în cartea sa „The Mythical Man Month”:

UNIX: totul este un fișier

Mach: IPC generalizează totul

L4: poate fi pus în afara kernel-ului?

seL4 (se bazează pe diferite versiuni ale L4):

-design orientat spre securitate (izolare puternică, control de acces bazat pe abilitate)

-resursele hardware se supun politicii definite de utilizator

-creat pentru verificare formală

Probleme nerezolvate în L4 original:

-L4 a rezolvat problema performaței „dar a lăsat numeroase probleme de securitate nerezolvate” – Hartig et al., SOSP 97

-probleme vizate de seL4:

a) abordare ad-hoc în privința protecției și managementul resurselor

b)covertirea canalelor

c)încapsulare insuficientă

d)atacuri în DoS

e)limitări în performață și flexibilitate

Cum rezolvă seL4 problemele prin design?

Izolarea: managementul memoriei e o responsabilitate la nivel de utilizator, kernel-ul nu alocă memorie, obiectele kernel-ului controlate de servere în mod user.

Performanța: managementul memoriei este integral alocat ierarhic, suportă un design ierarhic de sistem, activat de controlul de acces bazat pe abilități.

Timp real: model de design consisteță în creștere, tranziții rapide între stări substanțiale, operații restartabile cu garanția progresului.

Verificare: nu există concurență în kernel, întreruperile nu sunt activate în kernel, design multikernel grupat pentru procesoare multi-nucleu.

Arhitectura Microkernel

În kernel trebuie să existe doar funcțiile esențiale ale nucleului sistemului de operare, iar serviciile/aplicațiile mai puțin importante construite în microkernel și executate în modul utilizator. Multe servicii care, în mod tradițional, făceau parte din OS sunt acum subsisteme externe ce interacționează cu kernel-ul și între ele. Acestea includ drivere ale dispozitivelor, fișiere de sistem, manager de memorie virtuală, sistem de securitate.

Microkernel-ul funcționează ca un schimb de mesaje. Validează mesajele, le transimte componentelor și acordă accesul la partea hardware. De asemenea, previne trecerii mesajelor dacă schimbul nu a fost aprobat.

Beneficiile organizării microkernel:

-interfața utilizatorului – serviciile la nivelul kernelului și serviciile la nivelul utilizatorului au o interfață uniforma pentru procese ce utilizează serviciile lor prin mesaje

-extensabilitate – noi servicii pot fi adăugate

-flexibilitate – serviciile pot fi îndepărtate sau modificate

-portabilitate – tot, sau aproape tot nucleul codului specific procesorului se află în microkernel, astfel încât modificările necesare pentru a porta sistemul pe un nou procesor sunt mai puține și aranjate în grupuri logice

-fiabilitate – kernel-urile mai mici fac ca implementarea lor sa fie mai fiabilă

-suport distributiv pe mai multe mașini – un proces poate trimite mesaj fără să știe pe ce mașină se află serviciul vizat. Părți din mesaj pot fi pe altă mașină.

-sistem de operare orientat pe obiecte – o abordare obiect-orientată face designul microkernel-ului să fie mai disciplinată prin folosirea de componente. Componentele sunt obiecte cu interfețe bine definite care pot fi inter-conectate pentru a forma software-ul. Interacțiuniile între componente se fac cu ajutorul interfeței componentelor.

Performața microkernel

Un potențial dezavantaj al microkernel-ului este performanța acestuia. Durează mai mult să creeze și să trimită un mesaj prin microkernel, să accepte și să răspundă decât un singur apel la serviciu. O soluție la această problemă este mărirea microkernel-ului: mărește performața dar afectează beneficiile acestuia în materie de interfață minimală, flexibilitate și fiabilitate.

Altă abordare este micșorarea microkernel-ului care aduce îmbunătățiri înspre performanță dar și flexibilitate și fiabilitate.

Nano-Nucleul KeyKOS

Nano-nucleul KeyKOS este un sistem de operare orientat pe obiecte, bazat pe capabilitati care a fost utilizat inca din 1983. Implementarea sa originala a fost motivata de nevoia de a asigura securitate, stabilitate si disponibilitate 24/24 pentru aplicatiile serverelor Tymnet. Cerintele includeau abilitatea de a rula multiple instantieri ale mai multor sisteme de operare pe un singur sistem hardware.

Nano-nucleul este constituit din aproximativ 20000 de linii de cod C, incluzand capabilitatile, punct de revenire si suport pentru memoria virtuala. Nano-nucleul poate rula pe mai putin de 100KB de memorie.

KeyKOS este caracterizat de un mic set de primitive, puternice si foarte bine optimizate, care ii permit sa atinga performante comparabile cu macro-nucleul pe care il inlocuieste. Obiectele sunt invocate exclusiv prin capabilitati protejate, care asigura un nivel ridicat de securitate si intervale intre defectiuni de pana la un an. Mesajele dintre agenti pot contine atat capabilitati cat si informatie. Punctele de revenire salvate la intervale acordabile asigura o copie de rezerva a starii intregului sistem, timpii de restart ai sistemului fiind mai mici de 30 de secunde. La restart, toate procesele sunt restaurate la starea in care au fost salvate in momentul crearii punctului de revenire, incluzand registrele si memoria virtuala.

Fundamente arhitecturale

KeyKOS este bazat pe 3 concepte arhitecturale, care sunt nefamiliare majoritatii comunitatii UNIX: un nucleu fara stare, stocare pe un singur nivel si capabilitati. Experienta indica faptul ca intelegerea unui model cu stocare pe un nivel necesita o schimbare fundamentala a perspectivei pentru dezvoltatorii obisnuiti cu arhitecturi mai putin fiabile. Asadar, pare adecvat sa se prezinte mai intai aceste concepte ca o baza pe care sa se construiasca balanta descrierii arhitecturale KeyKOS.

Nucleu fara stare

O decizie timpurie in modelul KeyKOS a fost sa nu se pastreze nicio stare critica in nucleu. Toate starile nano-nucleului sunt deduse din informatia care persista din restartarile sistemului si defectiunile de putere. Din motive de eficienta, nano-nucleul face reformatarea informatiei de stare in memoria privata. Toata memoria private este pur si simplu o memorie cache a starii persistente, si poate fi reciclata oricand. Cand informatia eliminata e necesara

iar, este reconstruita din informatia din noduri si pagini (care sunt descrise mai jos).

Ca o consecinta, nano-nucleul nu face nicio alocare dinamica a memoriei nucleului. Acest lucru are mai multe implicatii:

Nucleul este mai rapid, din moment ce nu se ruleaza niciodata vreun cod complicat pentru alocarea memoriei.

Nucleul nu ramane niciodata fara spatiu. Nu exista o memorie a nanonucleului (precum cozile de mesaje) care sa

trebuiasca sa fie parte a punctului de revenire.

Absenta alocarii dinamice inseamna ca nu poate exista nicio interactie intre strategiile de alocare dinamica, care reprezinta sursa predominanta pentru puncte moarte si probleme de consecventa in majoritatea sistemelor de operare.

Sistemul , in afara nano-nucleului, este complet descris de continutul nodurilor si paginilor, care este persistent. Aceasta stare include fisiere, programe, variabile de program, numaratoare de instructiuni, stari I/O, si orice alta informatie necesara restartarii sistemului.

In plus, abilitatea de a recupera toate datele din timpul rularii nucleului din starea punctului de revenire inseamna ca o intrerupere a puterii nu perturba programele ce ruleaza. De obicei, sistemul pierde doar ultimele cateva secunde din datele introduse de la tastatura. La UNIFORUM ’90, Key Logic a cerut scoaterea din priza a sistemului. In mai putin de 30 de secunde de restabilire a puterii, sistemul a reluat procesarea completa cu toate ferestrele si starile care au fost afisate inainte. Nu se cunoaste nici o alta implementare UNIX actuala cu aceasta trasatura.

Stocare pe un singur nivel

KeyKOS prezinta un model de stocare pe un singur nivel persistent. Pentru aplicatia KeyKOS, toate datele stau intr-o memorie virtuala persistenta. Numai nanokernel-ul este constient de diferenta dintre memoria principala si paginile discului. Punctele de revenire periodice, ale intregului sistem, garanteaza persistenta tuturor datelor sistemului. Persistenta se extinde si dupa oprirea sistemului sau caderea de tensiune. Mai multe sisteme IBM 4341 au functionat mai mult de 3 ani, cu caderi de tensiune, fara a avea vreo intrerupere logica a serviciului.

Ca si paginile de memorie, aplicatiile KeyKOS sunt persistente. O aplicatie continua sa se execute pana este distrusa in mod explicit. Pentru aplicatie, perioada de oprire este vizibila doar ca un salt inexplicabil in valoarea ceasului real, sau deloc. Drept rezultat, problemele uzuale care insotesc pornirea si oprirea sistematica nu se pun aplicatiilor KeyKOS. Majoritatea sistemelor de

operare implementeaza un model tranzitoriu al programelor; persistenta este exceptia mai degraba decat regula. Un sistem de operare emulator client poate oferi aplicatii tranzitorii prin dezmembrarea proceselor sale cand aceastea se termina.Modelul stocarii pe un singur nivel permite simplificari vaste in design-ul sistemului KeyKOS. Printre intrebarile la care nanokernel-ul nu trebuie sa raspunda sunt:

Cum procedeaza sistemul cand ramane fara spatiu de schimb? (Foloseste puncte de revenire)

Cum manevreaza nucleul distrugerea unui process? (Nu o face.) Cum este retinuta starea nucleului la restartari? (Nucleul nu contine stari

care necesita retinerea acestora.)Fiecare din aceste domenii este o sursa de complexitate semnificativa in alte sisteme, si o sursa consecventa de probleme de fiabilitate.

Capabilitati

KeyKOS este un sistem bazat pe capabilitati. Pe scurt, KeyKOS face referire la capabilitati ca fiind chei. La fiecare obiect din sistem se face referire exclusiv prin una sau mai multe chei associate. Entitatile KeyKOS cer serviciile altor entitati trimitandu-le mesaje printr-o cheie. Mesajele de apel includ o cheie de intoarcere construita in nucleu care poate fi folosita de receptor pentru a raspunde. Mesajele sunt schimbate cel mai uzual intr-o modalitate asemanatoare cu RPC.

Ceea ce deosebeste KeyKOS de alte micro-nuclee este dependenta totala de capabilitati, fara niciun alt mecanism. Nu exista alte mecanisme care maresc complexitatea ideilor sau implementarii. Detinerea unei chei implica autoritatea de a trimite mesaje entitatii sau de a pasa cheia unei terte. Daca A nu are o cheie pentru B, atunci A nu poate comunica cu B. Aplicatiile pot duplica cheile pe care le detin, dar crearea cheilor este o operatie privilegiata. Bitii care identifica obiectul numit de o cheie sunt accesibili doar pentru nano-nucleu.Prin utilizarea capabilitatilor si pasarea mesajelor, programele KeyKOS ating aceleasi avantaje ale incapsularii ca si design-urile obiect-orientate. Incapsularea este fortata de sistemul de operare, si este disponibila in orice limbaj de programare. Securitatea completa a acestui mecanism de ascundere a informatiei este cea care face posibil sprijinul utilizatorilor reciproc suspiciosi.

Un concept fundamental in KeyKOS este ca un program trebuie sa asculte de “principiul celui mai mic privilegiu”. In acest scop, design-ul KeyKOS nu ofera obiectelor nicio autoritate intrinseca, si se bazeaza total pe cheile lor sa exercite autoritatea pe care o au. Folosind aceste facilitate, sistemul este impartit

convenabil in module mici, fiecare structurat astfel incat sa aiba privilegiul minim dar sufficient pentru operatiile sale.

Entitatile pot fi mentionate de catre mai multe chei distincte. Acest lucru ii permite unei entitati care comunica cu mai multi clienti sa ofere diferite drepturi de acces acestora. Fiecare cheie are un camp de 8 biti asociat care poate fi folosit de destinatar sa distinga intre clienti. Cand entitatea da o cheie, poate seta acest camp la o valoare cunoscuta. Deoarece toate mesajele primite de entitate includ valoarea celor 8 biti continuta in cheie, mecanismul poate fi folosit sa imparta clientii in clase de servicii sau niveluri de privilegiu prin atribuirea fiecarei clase a unei chei diferite.

Folosind un model bazat pe capabilitati, ofera simplificari semnificante in nano-nucleu. Printre intrebarile la care nano-nucleul nu trebuie sa raspunda sunt:

Trebuie ca utilizatorul sa detina autoritatea pentru a realiza o operatie? (Da, daca detii cheia, poti trimite mesajul)

Cum aloc destula memorie din nucleu pentru a realiza identificarea numelui unui obiect(name resolution) pe un nume de lungime variabila?(Nucleul nu lucreaza cu nume, ci numai cu chei)

Unde este inserat numele unui fisier intr-un document?(Nano-nucleul nu lucreaza cu nume de fisiere sau foldere)

Pentru ca nano-nucleul nu are nici un mecanism de numire in afara de capabilitati, numirea entitatilor este intrinsec descentralizata. Ca urmare, extinderea KeyKOS pe multiprocesoare este simpla.

Aplicatiile KeyKOS nu-si pot da seama daca ruleaza pe un uniprocesor sau pe un multiprocesor.

Obiecte Fundamentale KeyKOS

Nucleul KeyKOS suporta 6 tipuri de obiecte fundamentale: Dispozitive, Pagini, Noduri, Segmente, Domenii si Metri.

Dispozitive

Nano-nucleul implementeaza drivere hardware de nivel scazut in codul privilegiat. Driverul modului supraveghetor realizeaza incapsularea mesajelor si manipularea registrelor hardware. Exceptand cazurile cand performanta obliga altfel, aplicatiile KeyKOS implementeaza driverele reale ale dispozitivelor.

Pagini

Cel mai simplu obiect KeyKOS este pagina. Marimea paginii depinde de baza hardware si arhitectura de stocare, dar in toate implementarile actuale este de 4KB. Fiecare pagina are una sau mai multe locatii persistente pe unele dispozitive disk, cunoscute ca locatie principala. Sistemul KeyKOS administreaza un numar fix de pagini care sunt alocate cand sistemul este initializat pentru prima data. Acest numar poate creste prin atasarea unui dispozitiv de stocare in masa sistemului.

O pagina este desemnata de una sau mai multe chei de pagina. Paginile respecta 2 tipuri de mesaje de baza: citeste si scrie. Cand un mesaj este trimis catre o pagina care nu este in memorie, pagina este gresita transparent din memoria de suport, astfel incat operatia sa poata fi executata.

Aplicatiile care efectueaza alocarea dinamica a spatiului de memorie, detin o cheie catre o banca de spatiu. Bancile de spatiu sunt utilizate pentru a administra alocarea resurselor de disk. Sistemul are o banca de spatiu principala care detine cheile tuturor paginilor si nodurilor sistemului. Una din operatiile suportate de bancile de spatiu sunt crearea sub-bancilor, care sunt sub-banci ale bancii principale. Bancile de spatiu sunt un tip de domeniu.

Noduri

Un nod este o colectie de chei. Toate cheile dintr-un sistem se regasesc intr-un nod. O cheie nod da drepturi de acces asupra unui nod si poate fi folosita pentru a insera sau a scoate chei din nod. Ca si paginile, nodurile pot fi obtinute din bancile de spatiu. In toate implementarile KeyKOS, un nod contine exact 16 chei.

Nodurile sunt criticale pentru integritatea sistemului. Sistemul KeyKOS depinde vital de integritatea datelor din continutul nodurilor. Ca urmare, toate nodurile sunt replicate in 2 sau mai multe locatii in memoria suport (backing store).

Un segment este o colectie de pagini sau de alte segmente. Segmentele sunt folosite ca spatii de adrese, dar deasemeni subsumeaza functiile fisierelor intr-un sistem de operare conventional. Segmentele pot fi combinate pentru a forma segmente mai mari. Segmentele pot fi risipite; nu descriu neaparat un spatiu continuu de adrese.

Nodurile sunt “lipiciul” care tine segmentele impreuna. KeyKOS implementeaza segmentele ca un arbore de noduri cu paginile ca frunzele acestuia. Pentru ca nodurile si paginile sunt persistente, asa sunt si segmentele. Sistemul nu are nevoie de puncte de revenire pentru

Metri

Metrii controleaza alocarea resurselor CPU. O cheie metru ofera detinatorului dreptul de a executa pentru o unitate de timp detinuta de metru. Nucleul KeyKOS mentine un metru primar care reprezinta timpul din prezent pana la sfarsitul timpului. Ca si bancile de spatiu, metrii pot fi subdivizati in submetri. Fiecare proces care ruleaza, detine o cheie metru care ii permite procesului sa ruleze pentru un anumit timp.

Procesele KeyKOS pot fi prevenite. Detinand o cheie catre un metru care furnizeaza 3 secunde din timpul CPU-ului, nu garanteaza ca procesul v-a rula 3 secunde incontinuu. In actuala implementare a KeyKOS, taierea timpului este intarita de permiterea unui proces de a rula un minim din timpul acordat acestuia sau o unitate felie de timp. Politicile de planificare pot fi implementate in exteriorul nucleului.

Domenii

Domeniile efectueaza serviciile de executie a programelor. A fost un obiectiv de proiectare ca arhitectura accesibila utilizatorului sa nu fie restrictionata. O consecita este aceea ca KeyKOS suporta masini virtuale. Domeniile modeleaza tot ce tine de starea neprivilegiata a arhitecturii de baza, incluzand setul de registre generale, setul de registre pointer, registrele de stare, arhitectura setului de instructiuni, etc. Un domeniu interpreteaza un program conform arhitecturii hardware din modul utilizator. Domeniile sunt specifice masinii, desi am considerat implementarea domeniilor care realizeaza emularea arhitecturilor.

Bibliografie

1. http://en.wikipedia.org/wiki/L4_microkernel_family#L4 2. http://en.wikipedia.org/wiki/Mach_(kernel) 3. http://wiki.osdev.org/Microkernel 4. https://www.princeton.edu/~achaney/tmve/wiki100k/docs/

Microkernel.html5. https://www.gnu.org/software/hurd/microkernel.html 6. The nucleus of a multiprogramming system – Brinch Hansen7. The performance of microkernel-based systems Hermann Hartig, Michael

Hohmuth8. KeyKOS Architecture, Key Logic, 1988.9. Henry M. Levy, Capability Based Computer Systems, Digital Press, 1984.10. Norman Hardy, "The Keykos Architecture," Operating Systems Review,

September, 1985.11. http://www.cis.upenn.edu/~KeyKOS/Key370/Key370.html12.http://www.cis.upenn.edu/~KeyKOS/agorics/KeyKos/Concepts/

Chapter2.html13.http://www.cis.upenn.edu/~KeyKOS/agorics/KeyKos/Concepts/

Chapter3.html