\documentclass [a4paper]{article}
\usepackage{german,graphicx}
\usepackage{lineno}
\author{David Vajda, nach Andrew S. Tanenbaum}
\title{Minix 1}
\begin{document}
\linenumbers
Wichtige NR's
\begin{verbatim}
NR_REGS
NR_SEGS
NR_TASKS
NR_PROCS
NR_PROCS
NR_HOLES
\end{verbatim}

Wichtige Strukturen

\begin{verbatim}
struct mem_map {
    vir_clicks mem_vir;
    phys_clicks mem_phys;
    vir_clicks mem_len;
};
\end{verbatim}


\begin{verbatim}
EXTERN struct proc {
    int p_reg [NR_REGS];
    ...
    struct mem_map [NR_SEGS];
    ...
} proc [NR_TASKS + NR_PROCS];
\end{verbatim}

\begin{verbatim}
PRIVATE struct hole {
    phys_clicks h_base;
    phys_clicks h_len;
    struct hole *h_next;
} hole [NR_HOLES];
\end{verbatim}

\begin{verbatim}
        typedef     unsigned        vir_bytes;
        typedef     unsigned        vir_clicks;
        typedef     long            phys_bytes;
        typedef     unsigned        phys_clicks;
        typedef     int             signed_clicks;
\end{verbatim}

Wichtig
\begin{enumerate}
\item Kernel
\item Memory Manager
\item File System, Dateisystem
\end{enumerate}

\begin{verbatim}
kernel
mm
fs
\end{verbatim}


\begin{verbatim}
h
kernel
mm
fs
\end{verbatim}

\begin{verbatim}
h
    h/const.h
    h/callnr.h
    h/com.h
    h/error.h
    h/sgtty.h
    h/signal.h
    h/stat.h
    h/type.h
kernel
    kernel/const.h
    kernel/glo.h
    kernel/proc.h
    kernel/type.h
    kernel/main.c
    kernel/mpx88.s
    kernel/klib88.s
    kernel/proc.c
    kernel/memory.c
    kernel/floppy.c
    kernel/clock.c
    kernel/tty.c
    kernel/system.c
mm
    mm/const.h
    mm/glo.h
    mm/mproc.h
    mm/param.h
    mm/type.h
    mm/main.c
    mm/forkexit.c
    mm/exec.c
    mm/break.c
    mm/signal.c
    mm/getset.c
    mm/alloc.c

fs
\end{verbatim}

\begin{verbatim}
h
    h/const.h
    h/callnr.h
    h/com.h
    h/error.h
    h/sgtty.h
        Datenstrukturen fuer IOCTL
            struct sggtyb {...}
            struct tchars {...}
    h/signal.h
        NR_SIGS
        N_SIGS
        SIGHUP
        SIGINT
        SIGQUIT
        SIGILL
        SIGTRAP
        SIGIOT
        SIGEMT
        ...
        SIGKILL
        ...
        SIGPIPE
        SIGSYS
        SIGALARM
        SIGTERM
    h/stat.h
    h/type.h
        typedef     unsigned        vir_bytes;
        typedef     unsigned        vir_clicks;
        typedef     long            phys_bytes;
        typedef     unsigned        phys_clicks;
        typedef     int             signed_clicks;
kernel
    kernel/const.h
        NR_REGS
        ES_REG
        DS_REG
        CS_REG
        SS_REG
        Interrupt Vektoren: DIVIDE_VECTOR, CLOCK_VECTOR, KEYBOARD_VECTOR, FLOPPY_VECTOR
        PIC 8259A
    kernel/glo.h
    kernel/proc.h
    kernel/type.h
    kernel/main.c
        main ()
        unexpected_int ()
        trap ()
        div_trap ()
        panic ()
        set_vec (vec_nr, addr, base_click)
    kernel/mpx88.s
        MINIX
        s_call
        tty_int
        lpr_int
        disk_int
        wini_int
        clock_int
        suprise
        trp
        divide
        save
        restart
        idle
        data
    kernel/klib88.s
        phys_copy
        cp_mess
        port_out
        port_in
        lock
        unlock
        restore
        build_sig
        csv
        cret
        get_chrome
        dma_read
        vid_copy
        get_byte
        reboot
        wreboot
    kernel/proc.c
        sys_call
        interrupt
        ready
        unready
        sched
        mini_send
        pick_proc
    kernel/memory.c
        mem_task
        do_mem
        do_setup
    kernel/floopy.c
        floppy_task
        do_rdwt
        dma_setup
        start_motor
        stop_motor
        seek
        transfer
        fdc_results
        fdc_out
        recalibrate
        reset
        clock_mess
        send_mess
    kernel/clock.c
        clock_task
        do_setalarm
        do_get_time
        do_set_time
        do_clock_tick
        accounting
        init_clock
    kernel/tty.c
        tty_task // Hauptroutine
        do_charint
        in_char
        make_break
        echo
        chuck
        do_read
        rd_chars
        finish
        do_write
        do_ioctl
        do_cancel
        tty_reply
        sigchar
        keyboard
        console
        out_char
        scroll_screen
        flush
        move_to
        escape
        set_6845
        beep
        tty_init
        putc
        func_key
    kernel/system.c
        sys_task
        do_fork
        do_newmap
        do_exec
        do_xit
        do_getsp
        do_times
        do_abort
        do_sig
        do_copy
        cause_sig
        inform
        umap
mm
    mm/const.h
    mm/glo.h
    mm/mproc.h
    mm/param.h
    mm/type.h
    mm/main.c
        main
        get_work
        reply
        mm_init
        do_brk2
        set_map
    mm/forkexit.c
        do_fork
        do_mm_exit
        mm_exit
        do_wait
        cleanup
    mm/exec.c
        do_exec
        read_header
        new_mem
        patch_ptr
        load_seg
    mm/break.c
        do_brk
        adjust
        size_ok
        stack_fault
    mm/signal.c
        do_signal
        do_kill
        do_ksig
        check_sig
        sig_proc
        do_alarm
        set_alarm
        do_pause
        unpause
        dump_core
    mm/getset.c
        do_getset
    mm/alloc.c
        alloc_mem
        free_mem
        del_slot
        merge
        max_hole
        mem_init
fs
\end{verbatim}





\section{h/const.h}
\begin{verbatim}
h/const.h

#define     EXTERN          extern
#define     PRIVATE         static
#define     PUBLIC
#define     FORWARD
#define     TRUE            1
#define     FALSE           0
...
#define     BLOCK_SIZE      1024
#define     SUPER_USER      (uid) 0
#define     MAJOR           8
#define     MINOR           0
#define     NR_TASKS        8
#define     NR_PROCS        16
#define     NR_SEGS         3
#define     T               0
#define     D               1
#define     S               2
\end{verbatim}

Wichtig
\begin{enumerate}
\item Text
\item Data
\item Stack
\end{enumerate}
Wichtig! Code = Text

Wichtig:

\begin{enumerate}
\item Text \verb"T"
\item Data \verb"D"
\item Stack \verb"S"
\end{enumerate}

Wichtig:

\begin{enumerate}
\item Text \verb"T, 0"
\item Data \verb"D, 1"
\item Stack \verb"S, 2"
\end{enumerate}

Wichtig:
\begin{enumerate}
\item \verb"NR_TASKS"
\item \verb"NR_PROCS"
\item \verb"NR_SEGS"
\end{enumerate}

So, achtung aufgepasst!

\begin{verbatim}
struct proc {


} proc [NR_TASKS + NR_PROCS]
\end{verbatim}

\begin{enumerate}
\item Anzahl der Prozesse
\item Anzahl der Tasks
\end{enumerate}

\begin{enumerate}
\item Im Speichermanager
\begin{enumerate}
\item \verb"NR_PROCS" - Im Speichermanager, nur Prozesse
\end{enumerate}
\item Im Kernel
\begin{enumerate}
\item \verb"NR_TASKS" - im Kernel, Tasks
\item \verb"NR_PROCS" - Kernel, Prozesse
\end{enumerate}
\end{enumerate}

Dinge mit \verb"NR"
\begin{enumerate}
\item \verb"NR_TASKS"
\item \verb"NR_PROCS"
\item \verb"NR_SEGS"
\end{enumerate}

Dinge mit \verb"NR" zur Struktur
\begin{enumerate}
\item \verb"(NR_TASKS. proc)"
\item \verb"(NR_PROCS, proc)"
\item \verb"(NR_SEGS, mem_map"
\end{enumerate}

Wichtig
\begin{enumerate}
\item \verb"mem" - speicher
\item \verb"map" - karte
\end{enumerate}

Wichtig
\begin{enumerate}
\item \verb"NR_SEGS"
\item \verb"T"
\item \verb"D"
\item \verb"S"
\end{enumerate}


Wichtig
\begin{enumerate}
\item \verb"NR_SEGS, 3", maximal grenze
\item \verb"T, 0", erstes Element
\item \verb"D, 1", zweites Element
\item \verb"S, 2", drittes Element
\end{enumerate}

\section{h/callnr.h}

Wichtig

\begin{verbatim}
h/callnr.h ^= die wichtigsten Systemaufrufe
\end{verbatim}
Alle lernen
\begin{verbatim}
#define         NCALLS          69
#define         EXIT            1
#define         FORK            2
#define         READ            3
#define         WRITE           4
#define         OPEN            5
#define         CLOSE           6
#define         WAIT            7
#define         CREAT           8
...
\end{verbatim}

Die wichtigsten Systemaufrufe. Wichtig

\begin{verbatim}
NCALLS ^= Anzahl der Systemaufrufe
\end{verbatim}
\begin{enumerate}
\item \verb"exit ()"
\item \verb"fork ()"
\item \verb"read  ()"
\item \verb"write ()"
\item \verb"open ()"
\item \verb"close ()"
\item \verb"create ()"
\end{enumerate}

Daneben gibt es, einfach lernen, egal, wie

\begin{verbatim}
exit
fork
read
write
open
close
wait
create
link
unlink
chdir
time
mknod
chmod
chown
brk
stat
lseek
getpid
mount
umount
setuid
getuid
stime
alarm
fstat
pause
utime
access
sync
kill
dup
pipe
times
setgid
getgid
signal
ioctl
exec
umask
chroot
\end{verbatim}
\section{h/com.h}
Wichtig, Definitionen f"ur Systemaufrufe

Botschaften
\begin{verbatim}
SEND            1   /* Code fuer Botschaften verschicken */
RECEIVE         2   /* Code fuer Botschaften empfangen */
BOTH            3   /* Code fuer SEND + RECIEVE */
ANY
\end{verbatim}

Wichtig

Botschaften
\begin{verbatim}
HARDWARE
SYSTASK
CLOCK
MEM
FLOPPY
WINCHESTER
TTY
PRINTER
\end{verbatim}


Wichtig: Botschaften, darin gibt es entsprechende Parameter - Achtung, koennte man meinen. Das sind Botschaften,
\begin{enumerate}
\item Fuer jedes Ger"at eine Botschaft
\begin{enumerate}
\item Hardware
\item Systemaufrufe
\item Uhr
\item Arbeitsspeicher, \verb"MEM"
\item Floppy Disk
\item Festplatte
\item TTY
\item Drucker
\end{enumerate}
\item f"ur alle diese gibt es Botschaften
\item Das sind keine Paramter, sondern Botschaften an das Ger"at
\item Bei der Festplatte gibt es: \verb"DISK_READ", \verb"DISK_WRITE". Botschaft an das Ger"at: Lesen, schreiben
\end{enumerate}
\begin{verbatim}
HARDWARE
SYSTASK
    /* zum Beispiel */
    SYS_FORK
    SYS_EXEC
    SYS_COPY
    SYS_TIMES
CLOCK
    SET_ALARM
    CLOCK_TIME
    GET_TIME
    SET_TIME
    REAL_TIME
MEM
    RAM_DEV             /dev/ram
    MEM_DEV             /dev/mem
    KMEM_DEV            /dev/kmem
    NULL_DEV            /dev/null
FLOPPY
WINCHESTER
    DISKINT
    DISK_READ
    DISK_WRITE
    DISK_IOCTL
TTY/PRINTER
    ...
    TTY_READ
    TTY_WRITE
    TTY_IOCTL
\end{verbatim}

\section{h/error.h}
Lauter Fehler
\begin{verbatim}
NERROR
OK
..
EIO
ENOMEM
ENODEV
...

\end{verbatim}
\section{h/type.h}
\begin{verbatim}
        typedef     unsigned        vir_bytes;
        typedef     unsigned        vir_clicks;
        typedef     long            phys_bytes;
        typedef     unsigned        phys_clicks;
        typedef     int             signed_clicks;
\end{verbatim}

Lerne zu unterscheiden
\begin{enumerate}
\item Bytes
\item Clicks
\end{enumerate}

Lerne zu unterscheiden
\begin{enumerate}
\item Virtuell
\item Physikalisch
\end{enumerate}

\begin{enumerate}
\item Virtuelle Bytes
\item Virtuelle Clicks
\item Physikalische Bytes
\item Physikalische Clicks
\end{enumerate}
\begin{verbatim}
struct mem_map {
    vir_clicks mem_vir;
    phys_clicks mem_phys;
    vir_clicks mem_len;
};
\end{verbatim}
\begin{enumerate}
\item Anfang
\item L"ange
\end{enumerate}

Lerne zu unterscheiden
\begin{enumerate}
\item Anfang
\item Ende
\item Laenge
\end{enumerate}


Wichtig:
\begin{enumerate}
\item Anfang
\item L"ange
\end{enumerate}

wichtig:
\begin{enumerate}
\item Angabe in Clicks nicht in Bytes
\item Anfang:
\begin{enumerate}
\item Virtuell
\item Physikalisch
\end{enumerate}
\item Laenge: Virtuell
\end{enumerate}
\section{kernel/const.h}
\begin{enumerate}
\item Register
\item Interrupt-Vektoren
\item \verb"8259A"
\end{enumerate}

\begin{enumerate}
\item Register
\begin{enumerate}
\item "Ubersicht
\begin{enumerate}
\item \verb"ax"     1
\item \verb"bx"     2
\item \verb"dx"     3
\item \verb"cx"     4
\item \verb"si"     5
\item \verb"di"     5
\item \verb"sp"     7
\item \verb"bp"     8
\item \verb"es"
\item \verb"ss"     9
\item \verb"ds"     10
\item \verb"cs"     11
\item \verb"ip"
\end{enumerate}
\item Definitionen
\begin{enumerate}
\item Anzahl
\item Code
\item Daten
\item Stack
\end{enumerate}
\end{enumerate}
\item Interrupt-Vektoren
\begin{enumerate}
\item Geteilt durch 0
\item Uhr
\item Keyboard
\item XT-Wini
\item Floppy
\item Printer
\item Systemaufrufe
\item AT-Wini
\end{enumerate}
\item \verb"8259A"
\begin{enumerate}
\item IO-Port: \verb"0x20", I/O-Port Interrupt Controller \verb"0xA0", I/O-Port zweiter Interrupt Controller
\item Maske, 1. und 2.
\end{enumerate}
\end{enumerate}

\begin{verbatim}
#define     NR_REGS             11
#define     ES_REG              7
#define     DS_REG              8
#define     CS_REG              9
#define     SS_REG              10
\end{verbatim}
Interrupt Vektoren
\begin{verbatim}
#define     DIVIDE_VECTOR       0
#define     CLOCK_VECTOR        8
#define     KEYBOARD_VECTOR     9
#define     XT_WINI_VECTOR      13
#define     FLOPPY_VECTOR       14
#define     PRINTER_VECTOR      15
#define     SYS_VECTOR          32
#define     ATA_WINI_VECTOR     118
\end{verbatim}
8259A
\begin{verbatim}
#define     INT_CTL             0x20        /* I/O-Port fuer Interrupt Controller */
#define     INT_CTLMASK         0x21        /* Bits auf diesem Port setzen verbietet Interrupts */
#define     INT2_CTL            0xA0
#define     INT2_MASK           0xA1
...
\end{verbatim}
\section{kernel/glo.h}
\section{kernel/proc.h}
\begin{verbatim}
EXTERN struct proc {

} proc [NR_TASKS + NR_PROCS];

NR_TASKS!
NR_PROCS!

struct proc !
\end{verbatim}

\begin{verbatim}
EXTERN struct proc {
    int p_...
} proc [NR_TASKS + NR_PROCS];
\end{verbatim}


\begin{verbatim}
EXTERN struct proc {
    int p_...1
    int p_...2
    int p_...3
} proc [NR_TASKS + NR_PROCS];
\end{verbatim}

\begin{verbatim}
EXTERN struct proc {
    int p_reg [NR_REGS];
    ...
    struct mem_map [NR_SEGS];
    ...
} proc [NR_TASKS + NR_PROCS];

NR_REGS !
NR_TASKS !
NR_PROCS !
NR_SEGS !
\end{verbatim}

\begin{enumerate}
\item \verb"NR_REGS"
\item \verb"NR_TASKS"
\item \verb"NR_PROCS"
\item \verb"NR_SEGS"
\end{enumerate}

OK

\begin{verbatim}
EXTERN struct proc {
    int p_reg [NR_REGS];
    ...
    struct mem_map [NR_SEGS];
    int p_pid;
    ...
} proc [NR_TASKS + NR_PROCS];
\end{verbatim}

\begin{enumerate}
\item Register
\item Speicherabbild
\item Prozess ID
\end{enumerate}

\begin{verbatim}
EXTERN struct proc {
    int p_reg [NR_REGS];
    int *p_sp;                          /* Stack pointer */
    struct pc_psw p_pcpsw;              /* pc und psw bei Interrupt gesichert */
    int p_flags;                        /* P_SLOT, ... nicht flags */
    struct mem_map [NR_SEGS];
    int *p_splimit;                     /* Niedrigster wert fuer den Stack */
    int p_pid;

    real_time user_time;
    real_time sys_time;
    real_time child_utime;
    real_time child_stime;
    real_time p_alarm;

    struct proc *p_callreq;             /* Anfang der Liste aller Prozesse die senden wollen */
    struct proc *p_sendlink;
    message *p_messbuf;                 /* Zeiger auf Puffer fuer die Botschaft */
    int p_getfrom;

    struct proc *p_nextready;
    int p_pending;
} proc [NR_TASKS + NR_PROCS];
\end{verbatim}

\section{kernel/type.h}
\begin{verbatim}
struct pc_psw {
    int (*pc)();
    phys_clicks cs;
    unsigned psw;           /* Programm status word */
};
\end{verbatim}

\section{kernel/main.c}
\begin{verbatim}
main ()
unexpected_int ()
trap ()
div_trap ()
panic ()
set_vec (vec_nr, addr, base_click)
\end{verbatim}
\section{kernel/mpx88.s}
\begin{verbatim}
    kernel/mpx88.s
        MINIX
        s_call
        tty_int
        lpr_int
        disk_int
        wini_int
        clock_int
        suprise
        trp
        divide
        save
        restart
        idle
        data
\end{verbatim}
\begin{enumerate}
\item TTY
\item Disk : Floppy-Disk
\item Winchester: Hard Drive
\item Clock
\item LPR - Drucker \\\\
\item Systemaufrufe \\\\
\item idle : nichts zu tun
\end{enumerate}
Beispiele:
\begin{verbatim}
_tty_int:
    call save
    call _keyboard
    jmp _restart
_lpr_int:
    call save
    call _pr_char
    jmp _restart
...

_disk_int:
    call save
    mov _int_mess+2, *DISKINT
    mov ax, #int_mess
    push ax
    mov ax, *FLOPPY
    push ax
    call _interrupt
    jmp _start

_wini_int:
    ...
    mov ax, *WINI
    ...
\end{verbatim}

\begin{enumerate}
\item Unterste Ebene der Minix-kernels
\item Prozess und Botschaftsverwaltung wird abgewickelt
\item dazu in \verb"proc.c"\\\\
\item Prozess
\item Botschaft
\end{enumerate}

\section{kernel/klib88.s}

Wichtig:
\begin{enumerate}
\item Assembler-Hilfsroutinen
\item Zum Beispiel:
\begin{enumerate}
\item \verb"port_in"
\item \verb"port_out"
\end{enumerate}
\end{enumerate}
\begin{verbatim}
    kernel/klib88.s
        phys_copy       // kopiert Daten innerhalb des Speichers
        cp_mess         // kopiert Botschaften von der Quelle zum ziel
        port_out
        port_in
        lock            // interrupts verbieten
        unlock          // interrupts zulassen
        restore
        build_sig
        csv
        cret
        get_chrome      // liefert 0 bei Monochrom Bildschirm, 1 bei Farbbildschirm
        dma_read
        vid_copy        // Diese Routine nimmt einen String von Zeichen und schreibt ihn auf den Schirm
        get_byte        // Holt Byte irgendwo aus dem Speicher
        reboot
        wreboot
\end{verbatim}
\section{kernel/proc.c}
\begin{enumerate}
\item Prozessabarbeitung
\item Botschaftsabarbeitung
\end{enumerate}

Wichtig:
\begin{enumerate}
\item \verb"ready": Prozess in Warteschlange
\item \verb"unready": Prozess aus Warteschlange entfernen
\item \verb"sched": Prozess zu lange gerechnet
\end{enumerate}

\begin{verbatim}
sys_call
interrupt
ready
unready
sched
mini_send
pick_proc
\end{verbatim}



\section{kernel/memory.c}
\begin{verbatim}
Treiber fuer vier wichtige Geraedateien
    /dev/null - null Device = Daten Senke
    /dev/mem  - ganzer Speicher
    /dev/kmem - vom kernel belegter Speicher
    /dev/ram  - RAM-Disk
\end{verbatim}

\begin{enumerate}
\item Daten Senke \verb"/dev/null"
\item Ganzer Speicher \verb"/dev/mem"
\item Speicher, Kernel \verb"/dev/kmem"
\item RAM-Disk \verb"/dev/ram"\\\
\item Treiber
\item Treiber, fuer alles, was im RAM als Ger"at angesprochen wird, wie bei Floppy
\end{enumerate}

\begin{verbatim}
mem_task
do_mem
do_setup
\end{verbatim}

\section{kernel/floppy.c}
\begin{enumerate}
\item Treiber f"ur Floppy-Disk-Controller
\item NEC PD765-Chip
\end{enumerate}

\begin{verbatim}
IO-Ports:
DOR
FDC_STATUS
FDC_DATA
FDC_RATE
DMA_ADDR

Statusregister:
ST0
ST1
ST2
ST_CYL
ST_HEAD
ST_SEC
ST_PCN


Kommandobytes:
FDC_SEEK
FDC_READ
FDC_WRITE
FDC_RECALLIBRATE

Parameter
SECTOR_SIZE 512
HC_SIZE
NR_HEADS

\end{verbatim}

Zum Beispiel
\begin{enumerate}
\item Bits fuer Motorsteuerung: \verb"DOR", \verb"0x3f2"
\item Status register des Floppy-Disk-Controllers, \verb"FDC_STATUS", \verb"0x3f4"
\item Datenregister des Floppy Disk Controllers: \verb"FDC_DATA", \verb"0x3f5"
\item Register fuer Transferrate: \verb"FDC_RATE"
\item Ports fuer die unteren 16 Bit der DMA-Addresse \verb"DMA_ADDR"
\item Status Register 0 : \verb"ST0"
\item Status Register 1 : \verb"ST1"
\item Status Register 2 : \verb"ST2"
\item Status Register 3 : \verb"ST3"
\item Hier meldet der Controller Zylinder: \verb"ST_CYL"
\item Hier meldet der Controller Koepfe: \verb"ST_HEAD"
\item Hier meldet der Controller Sektoren: \verb"ST_SEC"
\item Hier meldet der Controller aktuellen Zylinder: \verb"ST_PCN"
\end{enumerate}

\begin{enumerate}
\item I/O-Ports
\item Statusregsiter
\item Felder in I/O-Ports
\item Kommandobytes
\item Parameter, wie Sektorgroesse, \dots
\item Fehlernummern: Positionierung \verb"ERR_SEEK"
\end{enumerate}

\begin{verbatim}
    floppy_task // Hauptprogramm des Treibers
    do_rdwt // Anforderung auf Platte zu lesen oder schreiben
    dma_setup
    start_motor
    stop_motor
    seek
    transfer
    fdc_results
    fdc_out
    recalibrate
    reset
    clock_mess
    send_mess
\end{verbatim}

\section{kernel/clock.c}
\begin{verbatim}
    clock_task
    do_setalarm
    do_get_time
    do_set_time
    do_clock_tick
    accounting
    init_clock
\end{verbatim}

\section{kernel/tty.c}

\begin{verbatim}
    tty_task // Hauptroutine
    do_charint
    in_char
    make_break
    echo
    chuck
    do_read
    rd_chars
    finish
    do_write
    do_ioctl
    do_cancel
    tty_reply
    sigchar
    keyboard
    console
    out_char
    scroll_screen
    flush
    move_to
    escape
    set_6845
    beep
    tty_init
    putc
    func_key
\end{verbatim}

\section{kernel/system.c}
\begin{enumerate}
\item Zwischenstueck sowohl zwischen Filesystem und kernel
\item als auch zwischen Speicherverwaltung und Kernel
\end{enumerate}

\begin{verbatim}
SYS_FORK
SYS_NEWMAP
SYS_EXEC
SYS_XIT
SYS_GETSP
SYS_TIMES
SYS_ABORT
SYS_SIG
SYS_COPY
\end{verbatim}

\begin{verbatim}
sys_task
do_fork
do_newmap
do_exec
do_xit
do_getsp
do_times
do_abort
do_sig
do_copy
cause_sig
inform
umap
\end{verbatim}


\section{mm}
\subsection{mm/const.h}
\subsection{mm/glo.h}
\subsection{mm/mproc.h}
\begin{verbatim}
EXTERN struct mproc {

} mproc [NR_PROCS];
\end{verbatim}


\begin{verbatim}
EXTERN struct mproc {
    int mp_...
    int mp_...
    int mp_...
} mproc [NR_PROCS];
\end{verbatim}


\begin{verbatim}
EXTERN struct mproc {
    struct mem_map mp_seg [NR_SEGS];
    ...

} mproc [NR_PROCS];
\end{verbatim}


\begin{verbatim}
EXTERN struct mproc {
    struct mem_map mp_seg [NR_SEGS];
    char mp_exitstatus;
    char mp_sigstatus;
    int mp_pid;
    int mp_parent;
    int mp_procgrp;

    uid mp_realuid;
    uid mp_effuid;
    gid mp_realgid;
    gid mp_effgid;

    unshort mp_ignore;
    unshort mp_catch;
    int (*mp_func) ();
    unsigned mp_flags;
} mproc [NR_PROCS];
\end{verbatim}

\begin{enumerate}
\item \verb"mp_seg"
\item \verb"mp_exitstatus"
\item \verb"mp_sigstatus"
\item \verb"mp_pid"
\item \verb"mp_parent"
\item \verb"mp_procgrp"

\item \verb"mp_realuid"
\item \verb"mp_effuid"
\item \verb"mp_realgid"
\item \verb"mp_effgid"

\item \verb"mp_ignore"
\item \verb"mp_catch"
\item \verb"int (*mp_func) ()"
\item \verb"mp_flags"
\end{enumerate}

\subsection{mm/param.h}
\subsection{mm/type.h}
\subsection{mm/main.c}
\begin{verbatim}
main
get_work
reply
mm_init
do_brk2
set_map
\end{verbatim}
\subsection{mm/forkexit.c}
\begin{verbatim}
do_fork
do_mm_exit
mm_exit
do_wait
cleanup
\end{verbatim}
\subsection{mm/exec.c}
\begin{verbatim}
do_exec
read_header
new_mem
patch_ptr
load_seg
\end{verbatim}
\subsection{mm/break.c}
\begin{verbatim}
do_brk
adjust
size_ok
stack_fault
\end{verbatim}
\subsection{mm/signal.c}
\begin{verbatim}
do_signal
do_kill
do_ksig
check_sig
sig_proc
do_alarm
set_alarm
do_pause
unpause
dump_core
\end{verbatim}
\subsection{mm/getset.c}
\begin{verbatim}
do_getset
\end{verbatim}
\subsection{mm/alloc.c}
\begin{verbatim}
alloc_mem
free_mem
del_slot
merge
max_hole
mem_init
\end{verbatim}

\begin{verbatim}
PRIVATE struct hole {
    phys_clicks h_base;
    phys_clicks h_len;
    struct hole *h_next;
} hole [NR_HOLES];
\end{verbatim}

Ein Loch besteht aus einem
\begin{enumerate}
\item Anfang, Basis
\item L"ange
\item N"achster Eintrag in der Freispeicherliste
\end{enumerate}

Es gibt eine Liste mit
\begin{enumerate}
\item Zeiger auf L"ocher, Liste
\item Zeiger auf unbenutzte Tabelleneintr"age, \verb"free_slots"
\end{enumerate}


\begin{verbatim}
PRIVATE struct hole {
    phys_clicks h_base;
    phys_clicks h_len;
    struct hole *h_next;
} hole [NR_HOLES];

PRIVATE struct hole *hole_head;
PRIVATE struct hole *free_slots;

PUBLIC phys_clicks alloc_mem (phys_clicks clicks) {
    register struct hole *hp, *prev_ptr;
    phys_clicks old_base;


    hp = hole_head;
    while (hp != NIL_HOLE) {
        if (hp -> h_len >= clicks) {
            old_base = hp->h_base;
            hp->h_base += clicks;
            hp->h_len -= clicks;

            if (hp->h_len != 0)
                return old_base;
            del_slot (prev_ptr, hp);
            return old_base;
        }
        prev_ptr = hp;
        hp = hp->h_next;
    }
}

del_slot (struct hole *prev_ptr, struct hole *hp) {
    if (hp == hole_head)
        hole_head = hp->h_next;
    else
        prev_ptr->h_next = hp->h_next;
    hp->h_next = free_slots;
    free_slots = hp;
}

\end{verbatim}


Alle funktionen des Speichers
\begin{verbatim}
        main
        get_work
        reply
        mm_init
        do_brk2
        set_map

        do_fork
        do_mm_exit
        mm_exit
        do_wait
        cleanup

        do_exec
        read_header
        new_mem
        patch_ptr
        load_seg

        do_brk
        adjust
        size_ok
        stack_fault

        do_signal
        do_kill
        do_ksig
        check_sig
        sig_proc
        do_alarm
        set_alarm
        do_pause
        unpause
        dump_core

        do_getset

        alloc_mem
        free_mem
        del_slot
        merge
        max_hole
        mem_init
\end{verbatim}


\end{document}


