Betriebssysteme KU - Einführungstutorium

Booting SWEB Running SWEB Hilfe 

Betriebssysteme KU - Einführungstutorium 

SWEB-Tutoren 

irc://irc.at.euirc.net/bs


Teamwork 

Arbeitsaufteilung? 

Zeiteinteilung? 

Codeeinteilung? 

Kommunikation!


Kommunikation 

Kommunikation mit dem Team 

Gruppentreffen 

Email 

Chat 

Kommunikation mit anderen 

Newsgroup: tu-graz.lv.bs.sweb 

Helpline: bs-helpline-2013@iaik.tugraz.at 

IRC- Channel: irc://irc.at.euirc.net/bs


1 Booting SWEB 

2 Running SWEB 

3 Hilfe


Booting 

Grub, boot.s, Paging, call startup (main.cpp:77) 

main.cpp:182 ff. 

char const * user_progs [ ] = { 

"/ user_progs / helloworld . sweb " , 

0 

} ; 

Scheduler : : instance()−>addNewThread ( 

new MountMinixAndStartUserProgramsThread ( 

new FileSystemInfo (* root_fs_info ) , user_progs ) 

) ; 

// [ . . . ] 

ArchInterrupts : : enableInterrupts ( ) ; 

Scheduler : : instance()−>yield ( ) ;


MountMinix 

ist ein Kernel Thread (läuft nur im Kernel-space) 

mounted die Minix Partition 

lädt die User-Programme und startet diese 

wartet bis das letzte Programm terminiert und ... 

... unmounted die Partition dann wieder.


UserProcess 

von Thread abgeleitet 

führt Code eines executables aus 

hat einen virtuellen Adressraum (Loader) 

im Userspace


Loader 

setzt Adressraum für UserProcess auf 

lädt den Executable Code (ELF32-Format) 

Constructor: lädt nur den Dateiheader 

der eigentliche Code wird on demand geladen 

Loader.cpp:351 ff. 

void Loader::loadOnePageSafeButSlow ( uint32 virtual address );


Timer-Interrupt 

Interrupts werden in den InterruptUtils behandelt. Beispiele: 

Timer / Clock Interrupt (IRQ0) 

Tritt immer nach Ablauf einer definierten Zeitspanne auf. 

InterruptUtils::irqHandler_0() 

. . . 

heart_beat_value = ( heart_beat_value + 1) % 4 ; 

Scheduler : : instance()−>incTicks ( ) ; 

uint32 ret = Scheduler : : instance()−>schedule ( ) ; 

switch ( ret ) 

{ 

case 0 : 

ArchInterrupts : : EndOfInterrupt ( 0 ) ; 

arch_switchThreadKernelToKernelPageDirChange ( ) ; 

case 1 : 

ArchInterrupts : : EndOfInterrupt ( 0 ) ; 

arch_switchThreadToUserPageDirChange ( ) ; 

. . .


Page Fault Handler 

Zugriff auf eine Speicherstelle, die nicht aufgelöst werden kann → 

PageFault. Muss richtig behandelt werden: 

Code aus binary nachladen 

Prozess wegen Speicherzugriffsverletzung terminieren 

...




3 Hilfe


Scheduler 

hält Liste mit allen Threads 

führt schedule() immer bei irq 0 aus, nächster freier Thread 

kommt dran 

yield() → irq 65 → schedule() 

Methoden zum verwalten von Threads 

Scheduler : : addThread ( Thread * thread ) ; 

beinhaltet den IdleThread, löscht tote Threads


Prozessstart 

Prozessobjekt erstellen 

Stack und ArchThreadInfo für User- und Kernelspace wird 

reserviert 

Loader läd executable 

Im ELF-Header im executable steht die Einsprungadresse 

Instruction Pointer für den Userspace wird auf diese Adresse 

gesetzt 

switch_to_userspace_ = 1


Prozessausführung 

Wenn der Scheduler den Prozess (bzw. Thread) an die Reihe 

nimmt: 

Überprüfe switch_to_userspace_ (Beim Prozessstart immer 1) 

Lade entsprechende Registerwerte aus ArchThreadInfo 

Damit ist der EIP gleich der Einsprungadresse 

CPU führt den sich dort befindenden Code aus


Einsprungspunkt: arch/x86/userspace/start.s 

arch/x86/userspace/start.s:1-9 

BITS 32 

extern 

extern 

main 

__syscall 

global _start 

_start : 

; we dont touch parameters on stack 

call main


Ausführung von helloworld 

userspace/tests/helloworld.c 

# include 

int main ( ) 

{ 

puts ( " hello , world " ) ; 

return 0 ; 

} 

Handelsübliches Hello World Programm 

Brian Kernigham, 1974



userspace/libc/printf.c:510 

int puts ( const char * output_string ) 

{ 

. . . 

characters_written = write ( STDOUT_FILENO , 

( void *) output_string , 

string_length ) ; 

. . . 

} 

Library Funktion 

Sanity Check des Arguments 

Aufruf des Systemcalls write



userspace/libc/write.c:61 

size_t write ( int file_descriptor , const void * buffer , 

size_t count ) 

{ 

return __syscall ( sc_write , file_descriptor , ( long ) buffer , 

count , 0x00 , 0 x00 ) ; 

} 

Library Teil des Syscalls 

Ruft Low-Level Teil __syscall auf



arch/x86/userspace/start.s:7 

__syscall : 

; s e t u p s t a c k 

... 

; ok , we have to s a v e ALL r e g i s t e r s we a r e now g o i n g to 

; o v e r w r i t e f o r our s y s c a l l 

... 

int 0 x80 ; 

... 

ret 

Kopiert Argumente in Register (eax, ebx, ...) 

Erzeugt CPU-Interrupt 0x80 (= 128 10 ) 

→ Wechsel in Kernelspace


Userspace/Kernelspace 

Im Source 

Userspace: userspace/ 

Kernelspace: common/, arch/ 

Scheduler, UserProcess, etc. 

In der Ausführung: Unterschiedliche Contexte 

CPU-Register (eax, ...) 

Stack (esp, ebp) 

Memory (Page Directory, cr3) 

Kernel und Userspace teilen sich Memorylayout 

Aber: unterschiedliche Zugriffsrechte 

ThreadInfosUserspaceThread, ThreadInfosKernelThread 

(in arch/common/include/ArchThreads.h)


Definition von Syscalls 

arch/x86/source/arch_interrupts.s 

Einsprungspunkt im Kernel 

Speichern des (User-) Contexts 

Ruft syscallHandler (Low-Level) auf 

arch/x86/source/InterruptUtils.cpp:673 

extern "C" void syscallHandler ( ) 

{ 

currentThread−>user_arch_thread_info_−>eax = 

Syscall : : syscallException ( currentThread−> 

user_arch_thread_info_−>eax , . . . ) ; 

. . . 

}


Syscalls im Kernel 

common/source/kernel/Syscall.cpp:19 

uint32 Syscall : : syscallException ( uint32 syscall_number , 

uint32 arg1 , . . . 

{ 

. . . 

switch ( syscall_number ) 

{ 

. . . 

case sc_write : 

return_value = write ( arg1 , arg2 , arg3 ) ; 

break ; 

. . . 

} 

return return_value ; 

} 

High-Level 

Dispatch für alle Syscalls


Definition von Syscalls 

TODO: 

1 Neue Syscall Nummer in 

common/include/kernel/syscall-definition.h eintragen 

2 Syscall Library Funktion schreiben 

3 Syscall Handler in Syscall::syscallException hinzufügen


Syscall::write 

common/source/kernel/Syscall.cpp:58 

// s a n i t y c h e c k s 

if ( ( buffer >= 2U *1024 U *1024 U *1024 U ) | | 

( buffer+size > 2U *1024 U *1024 U *1024 U ) ) 

{ 

return −1U ; 

} 

if ( fd == fd_stdout ) // s t d o u t 

{ 

debug ( SYSCALL , " Syscall :: write : %B\n" , ( char *) buffer , size ) ; 

kprint_buffer ( ( char *) buffer , size ) ; 

} 

return size ;


debug( uint32 flag, const char *fmt, ...) 

schreibt auf die Commandline in der qemu ausgeführt wird 

in common/include/console/debug.h sind die flags. 

const uint32 SYSCALL = 0 x00080008 | OUTPUT_ENABLED ; 

Für neue Bereiche, neue Flags erstellen. 

in common/source/console/kprintf.cpp:422 kann man 

die Tags sowie deren Farbe einstellen 

Für keine Farbausgabe NO_COLOR definieren.


kprint_buffer, kprintf und Co 

kprint_buffer, kprintf, schreibt un-/formatted auf das 

Sweb-Terminal 

kprintd_buffer, kprintfd geht un-/formatted auf die 

Debug-Console 

Für Debug Ausgaben besser debug verwenden!


Prozessterminierung 

userspace/tests/helloworld.c 

# include 

int main ( ) 

{ 


return 0 ; 

} 

Was macht return 0 oder Funktionsende? Nichts 

besonderes...


Prozessterminierung (2) 

arch/x86/userspace/start.s:9 ff. 

call main 

push 0 x00 

push 0 x00 

push 0 x00 

push 0 x00 

push eax ; eax i s t h e r e t u r n v a l u e from main 

push 0 x01 ; s y s c a l l code f o r e x i t == 1 

call __syscall 

Was passiert wenn __syscall returniert? 

Was macht __syscall mit 0x1 und eax?



common/source/kernel/Syscall.cpp (Fragmente bzgl. exit) 

uint32 Syscall : : syscallException ( uint32 syscall_number , . . . 

{ 

. . . 

case sc_exit : 

exit ( arg1 ) ; 

break ; 

. . . 

} 

void Syscall : : exit ( uint32 exit_code ) 

{ 

currentThread−>kill ( ) ; 

}



common/source/kernel/Thread.cpp:89 ff. 

void Thread : : kill ( ) 

{ 

switch_to_userspace_ = false ; 

state_=ToBeDestroyed ; 

if ( currentThread == this ) 

{ 

ArchInterrupts : : enableInterrupts ( ) ; 

Scheduler : : instance()−>yield ( ) ; 

} 

}



Scheduler ruft delete auf, wenn Status ToBeDestroyed 

UserProcess/Thread Destruktor 

UserProcess : : ˜ UserProcess ( ) { 

if ( fd_ > 0) { vfs_syscall . close ( fd_ ) ; } 

process_registry_−>processExit ( ) ; 

} 

Thread : : ˜ Thread ( ) { 

if ( loader_ ) { loader_−>cleanupUserspaceAddressSpace ( ) ; } 

delete loader_ ; 

ArchThreads : : cleanupThreadInfos ( 

user_arch_thread_info_ ) ; 

ArchThreads : : cleanupThreadInfos ( 

kernel_arch_thread_info_ ) ; 

if ( fs_info_ ) { delete fs_info_ ; } 

}




3 Hilfe


SWEBWiki 

https://swebwiki.student.iaik.tugraz.at/ 

Viele Tutorials und Infos zu SWEB 

Wird laufend erweitert


Live Programming 

Live Programming am 15.10. (Dienstag) 

Gut evaluiert, scheint also sinnvoll zu sein 

Wir implementieren einen Syscall 

Aufzeichnung


Prozessstart 

Prozessobjekt erstellen 

Stack und ArchThreadInfo für User- und Kernelspace wird 

reserviert 

Loader läd executable 

Im ELF-Header im executable steht die Einsprungadresse 

Instruction Pointer für den Userspace wird auf diese Adresse 

gesetzt 

switch_to_userspace_ = 1


Prozessausführung 

Wenn der Scheduler den Prozess (bzw. Thread) an die Reihe 

nimmt: 

Überprüfe switch_to_userspace_ (Beim Prozessstart immer 1) 

Lade entsprechende Registerwerte aus ArchThreadInfo 

Damit ist der EIP gleich der Einsprungadresse 

CPU führt den sich dort befindenden Code aus


Einsprungspunkt: start.s 

BITS 32 

extern 

extern 

main 

__syscall 

global _start 

_start : 

; we dont touch parameters on stack 

call main


C-Programm: helloworld.c 

helloworld.c 

# include 

int main ( ) 

{ 


return 0 ; 

} 

Wie funktioniert puts?


Fragen?

Betriebssysteme KU - Einführungstutorium

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?