20:08 < Jaffe> ok, staale
20:08 < Jaffe> paging
20:08 < staale> Yeah
20:09 < Jaffe> ok, rekner med du vet hva et segment
20:09 < Jaffe> er
20:09 < staale> Jeje
20:09 < Jaffe> good, for ikke tenk på segmenter nå :P
20:09 < staale> Minne "reservert" for et "program" liksom?
20:09 < staale> "Heh"
20:09 < staale> :p
20:09 < Jaffe> ikke et segment nei
20:10 < staale> Hva er et segment da?
20:10 < Jaffe> et segment er et definert område i minnet
20:10 < Jaffe> vi _kan_ bruke segmentering for å skille programmer fra hverandre
20:10 < Jaffe> men det få OS som gjør det
20:10 < staale> Som begrenser hva et program har tilgang til av minnet?
20:10 < staale> Ja, for å skille programmer fra hverandre slik at de ikke 
                overskriver hverandre f.eks.
20:10 < staale> Ved buffer overflows..
20:10 < Jaffe> neinei
20:10 < staale> :/
20:10 < Jaffe> vi skal kke bruke segmentering til det
20:11 < Jaffe> vi kan
20:11 < staale> Åkey
20:11 < Jaffe> hvis vi vil skille oss fra 99% av OS-ene
20:11 < Jaffe> :P
20:11 < staale> Uh, aha :p
20:11 < Jaffe> jeg rekner med det er en grunn til at alle bruker paging
20:11 < Jaffe> så vi har bare fire segmenter i os-et (så langt hvertfall): 
               kernel code og data, og user code og data
20:11 < Jaffe> altså kernel space og user space
20:12 < staale> Jepps
20:12 < Jaffe> hvis vi skulle brukt segmentmekanismen slik intel sikkert mente 
               den skulle brukes, gjør vi slik du sier
20:12 < Jaffe> og gir hvert program et eget segment
20:12 < staale> Har ikke Linux det?
20:12 < Jaffe> nei
20:12 < staale> SIGSEGV-fault da?
20:13 < Jaffe> det er når et program prøver å skrive i minnet til kernelen
20:13 < Jaffe> kernel space
20:13 < staale> Åh
20:13 < staale> Så i praksis så er det mulig at jeg lager et program som 
                skriver over minnet til f.eks. Firefox?
20:13 < Jaffe> nei, for det er der paging kommer inn
20:14 < staale> Ah
20:14 < Jaffe> en page er en blokk i minnet på 4KB
20:14 < staale> Åkey
20:14 < Jaffe> den blokken kalles en page frame
20:15 < staale> Ah, "grab next frame"-opplegg når jeg disassembler et program i 
                GDB :p
20:15 < Jaffe> adressen til 1024 slike pages kan lagres i en struktur som 
               kalles page table
20:15 < Jaffe> staale, sikkert ... skal ikke uttale meg :P
20:15 < staale> :P
20:15 < staale> Er en page table det meste som kan "lagres"?
20:15 < Jaffe> nei
20:16 < Jaffe> page table har altså 1024 pekere (spesielle pekere medi kke bare 
               adressen)
20:16 < staale> Åkey..
20:16 < Jaffe> hver entry i arrayet har adressen til page-framen til den pagen 
               den representerer, i tillegg til noen flagg
20:17 < Jaffe> hvis du rekner litt, finner du ut at en page table da strekker 
               seg over 4MB
20:17 < staale> Jepps
20:17 < staale> 1024 * 4kb aktig
20:17 < Jaffe> videre er det en omrent lik struktur, kalt page directory
20:18 < Jaffe> den har igjen 1024 entries som peker til hver sin page table
20:18 < Jaffe> da har du hele adresseområdet dekket
20:18 < Jaffe> (0 - 4GB)
20:18 < staale> Nettopp, ja
20:18 < Jaffe> (1024 * 1024 * 4096)
20:18 < staale> Mhm
20:19 < Jaffe> pekeren til page directoryen, ligger i CR3-registeret til CPU-en
20:19 < Jaffe> her kommer det som kanskje er litt tricky
20:20 < Jaffe> posisjonen til hver entry i page directoryen og page table, 
               avgjør den fysiske/reelle adressen
20:20 < Jaffe> nenienneienei
20:20 < Jaffe> den virtuelle
20:20 < staale> Heh, åkey
20:21 < staale> Neesten som et koordinat-system
20:21 < Jaffe> heh
20:21 < staale> 3,4 f.eks.
20:21 < staale> :p
20:22 < Jaffe> men altså
20:22 < Jaffe> videre
20:24 < Jaffe> pagen pagedirectory[3], page table [9]  vil da ha virtuell 
               adresse 3 * 9 * 4096 = 110592 = 0x1B000
20:24 < Jaffe> men den _fysiske_ adressen, ligger lagret i page table entryen!
20:24 < Jaffe> den er det vi som lagrer der når vi allokerer/setter 
               opp/whatever en page
20:25 < Jaffe> verstehst du?
20:26 < Jaffe> så for å finne den reelle/fysiske adressen til en virtuell 
               adresse, gjør CPU-en noe slikt:
20:27 < Jaffe> slår opp i page dir og finner rett page table -> slår opp i page 
               table og finner page -> henter pagens adresse
20:28 < staale> Åkey..
20:28 < staale> Men bare sånn av ren nyskjerrighet. Hva skjer hvis man har mer 
                enn 4GB ram?
20:28 < staale> Evt. hva er det som ikke skjer? :p
20:28 < Jaffe> vel, dette er 32-bits paging
20:29 < Jaffe> som har vært i x86 siden 386 i 1985
20:29 < Jaffe> men med pentium-prosessoren utvidet intel adressområdet til 64GB
20:29 < Jaffe> (36-bits)
20:29 < Jaffe> dette ordnet de ved å introdusere en ny paging-type
20:30 < Jaffe> den skipper page directory, og har bare en stor page-table 
20:30 < staale> Åkey
20:31 < Jaffe> men jeg tror vi holder oss med den "vanlige"
20:31 < Jaffe> hvis ingen protesterer?
20:32 < Jaffe> eller, hvis å støtte eldre prosessorer enn pentium ikke er noe 
               sterkt ønske, kan vi vel egentlig bruke den 36-bits-metoden
20:32 < GeirGrusom> *lagre på et trygt sted*
20:32 -!- GeirGrusom [n=HanTuffe@40.80-203-55.nextgentel.com] has left 
          #dvorient []
20:32 < staale> Jeg har ingen protester :p
20:32 < staale> På hverken av delene forsåvidt
20:33 < Jaffe> men du ser hvordan paging kan gjøre at programmer tror de har 
               hele adressområdet for seg selv?
20:33 < Jaffe> hvis hvert program har en egen page directory
20:34 < Jaffe> da vil det jo automatisk ha et eget virtuelt adresseområde fra 0 
20:35 < Jaffe> så i multitaskingsmekanismen (når den tid kommer), vil vi 
               sannsynligvis laste CR3 med page directoryen til neste task når 
               det byttes task
20:36 < Jaffe> hvertfall såvidt jeg kan se, om jeg ikke har gått glipp av noe 
               kritisk da
20:36 -!- Chills [n=coderapo@21.80-203-59.nextgentel.com] has joined #dvorient
20:37 < Chills> Her går det unna .D?
20:37 < Jaffe> jau, du gikk nettopp glipp av en lang page-forklaring
20:37 < staale> Jaffe: Da blir det også umulig å skrive over andre "frames"
20:37 < staale> Fordi de ikke finnes
20:37 < staale> For programmene ihvertfall :p
20:37 < Chills> :P
20:37 < Chills> faen
20:37 < Chills> copy past :P
20:38 < Chills> eller ligg ut en logg på diskusjon.no :P
20:38 < staale> Ikke faen -- søren
20:38 < staale> Faen er umodent og groteskt
20:38 < Chills> cpy past?
20:39 < staale> Nevah!
20:39 < Chills> hahahaha
20:39 < Jaffe> ja, staale, akkurat
20:39 < Jaffe> det er kernelens jobb å sørge for at hvert program får pages som 
               ikke allerede er i bruk
20:39 < Jaffe> eller blokker i minnet da
20:40 < Jaffe> men om man vil at to programmer skal dele noe, kan man sette en 
               page i begge programmene til samme fysiske område
20:40 < Chills> mutex?
20:41 < Jaffe> ja, noe sånt
20:41 < Jaffe> kan vel kalle det det
20:41 < Chills> hehe bra! Glad du står for kernel delen da ^^
20:41 < Jaffe> :P
20:42 < Chills> Det er gale nok å lære å bruke et mutex, lage selve greia o.O 
                uff