Wstęp

Witamy kolejnej części kursu pt. "Jak zostać Billem Gatesem". Ups, to nie ten tekst :) W poprzedniej części dowiedziałeś się dość dużo o programowaniu OS-ów. Teraz przyszła kolej na trudniejsze rzeczy, czyli praktykę. Napisaliśmy także najprostsze jądro systemu, które tylko wyświetla napis "Hello World !!!" w lewym górnym rogu ekranu. Większość kursów niestety kończyła się na tym, ale mój kurs będzie lepszy i opiszę więcej rzeczy :)

Najpierw zajmiemy się rozszerzeniem naszego kernela o obsługę przerwań. Tym razem nie będzie o obsłudze wyjątków. Będzie o tym w 3 części, ponieważ będzie ona stosunkowo krótka, więc postanowiłem przesunąć ten temat, aby ta część była krótsza.

Dodajemy obsługę przerwań

Jak już wspomniałem w pierwszej części, adresy przerwań są zapisane w IDT. IDT należy załadować instrukcją lidt. Do naszego kodu wstawiamy następujące linijki: lidt [idt_descr] zaraz po instrukcji lgdt. Na końcu pliku dopisujemy: idt_descr: dw 256*8-1 dd idt

GLOBAL idt idt: times 256 dd 0,0

Jak na razie to nasz kod startowy załaduje do rejestru IDTR położenie naszej tablicy. Na razie nie możemy wywołać żadnych przerwań, ponieważ procesor by się zresetował. Teraz wypadałoby stworzyć sobie jakieś procedury do "grzebania" w IDT. Na początek może jakiś plik nagłówkowy (intr.h):

#ifndef __INTR_H #define __INTR_H

typedef struct desc_struct { long a,b; } desc_table;

extern desc_table gdt,idt;

void set_intr_gate(int n,void * addr); void set_trap_gate(int n,void * addr); void set_system_gate(int n,void * addr);

#endif

W powyższym pliku mamy zadeklarowany typ desc_struct jako jeden deskryptor oraz desc_table jako tablicę deskryptorów. W kodzie C mamy dostęp do tablic gdt oraz idt, ponieważ w pliku start.asm zadeklarowaliśmy je jako etykiety globalne (czyli można uzyskać adres do nich poza plikiem). Teraz stwórzmy sobie procedury do ustawiania wpisów w IDT. Będzie to plik intr.c:

#include "intr.h"

#define _set_gate(gate_addr,type,dpl,addr) \ __asm__("movw %%dx,%%ax\n\t" \ "movw %0,%%dx\n\t" \ "movl %%eax,%1\n\t" \ "movl %%edx,%2\n\t" \ ::"i"((short)(0x8000+(dpl<<13)+(type<<8))), \ "o"(*((char *)(gate_addr))), \ "o"(*(4+(char *)(gate_addr))), \ "d"((char *)(addr)),"a"(0x00080000))

void set_intr_gate(int n,void * addr) { _set_gate(&idt[n],14,0,addr);

void set_trap_gate(int n,void * addr) { _set_gate(&idt[n],15,0,addr);

void set_system_gate(int n,void * addr) { _set_gate(&idt[n],15,3,addr);

Funkcja set_intr_gate ustawia adres do "normalnego" przerwania, czyli bez dostępnego kodu błędu. set_trap_gate ustawia adres do "pułapki", czyli przerwania z kodem błędu (kod błędu po wywołaniu przerwania jest dostępny w [esp]). Funkcja set_system_gate przyda nam się w przyszłości, ponieważ zostanie użyta do ustawienia przerwania, za pomocą którego programy użytkownika będą się komunikować z kernelem (tzw. system calls). I właściwie obsługę przerwań mamy już dodaną. Jeszcze jedna rzecz do wyjaśnienia: zastosowałem tu tzw. assembler AT&T. Jest on bardzo wygodny w użyciu do zastosowania go w kodzie C. Dla początkującego programisty może się on wydawać dziwny, bo np. w assemblerze Intela to: mov eax,ebx mov ebx,[esp+4] mov ecx,[ebx+edx*4] inc dword [licznik] mov edi,licznik w assemblerze AT&T wygląda następująco: movl %ebx,%eax movl 4(%esp),%ebx movl (%ebx,%edx,4),%ecx incl licznik movl $licznik,%edi

Asembler AT&T powinien być opisany w dokumentacji do assemblera as (info as). Plik intr.c kompilujemy poleceniem:

gcc intr.c -c -o intr.o -m32 -O2 -fomit-frame-pointer

Przy następnych kompilacjach plików w C będziemy używać opcji kompilatora w postaci:

gcc -c plik.c -o plik.o -O2 -fomit-frame-pointer -m32 -nostdinc -fno-builtin

Można też sobie napisać skrypt Makefile, który miałby postać:

.SUFFIXES: .asm; OUTFILE = kernel.bin OBJS = start.o main.o intr.o CFLAGS = -O2 -fomit-frame-pointer -nostdinc -fno-builtin -m32

$(OUTFILE): $(OBJS) ld -Tkernel.ld -o $(OUTFILE) $(OBJS)

.asm.o: nasm $*.asm -f elf32 -o $*.o

Resztę kompilujemy poleceniami (jeśli nie zrobiliśmy pliku dla make) jak zostało to opisane pod koniec pierwszej części. Potem wszystko linkujemy: ld -Tkernel.ld -o kernel.bin start.o main.o intr.o

Na razie się nic nie zmieniło, tylko plik wynikowy powiększył się o kilkaset bajtów. Później napiszemy prostą procedurę obsługi przerwania.

Piszemy obsługę ekranu

Pisanie obsługi ekranu jest bardzo proste. Istnieją 2 rodzaje obsługi kart graficznych: Hercules i VGA. Herculesa już dzisaj nikt nie używa. Wspomnę tylko, że procedury obsługi różnią się tylko adresem pamięci karty graficznej i portem do obsługi położenia kursora. Pamięć tekstu karty VGA jest zlokalizowana pod adresem liniowym 0xB8000. Uważam, że w naszym OSie nie warto pisać obsługi karty Hercules, ponieważ każdy dzisiaj ma kartę kompatybilną z VGA. Najpierw napiszmy sobie procedury do robienia operacji na portach. Plik io.h:

#ifndef __IO_H #define __IO_H

static inline void outportb(unsigned short port,unsigned char val)

__asm__("outb %%al,%%dx"::"a"(val),"d"(port));

static inline unsigned char inportb(unsigned short port) { unsigned char __ret; __asm__("inb %%dx,%%al":"=a"(__ret):"d"(port)); return __ret;

#endif

Te instrukcje posłużą nam do wysyłania danych do portów karty VGA, aby ta zmieniła położenie kursora. Kursor można przesunąć poniższą procedurą:

void przesun_kursor(int x,int y) { int temp; temp=(y*80+x); outportb(0x3D4+0,14); outportb(0x3D4+1,temp>>8); outportb(0x3D4+0,15); outportb(0x3D4+1,temp);

Tutaj przyjmujemy, że ekran tekstowy ma wymiary 80x25. Teraz piszemy właściwy program obsługi ekranu. Plik cons.c:

#include"io.h"

#define __wmemcpy(dst,src,count) \ { \ int d0,d1,d2; \ __asm__ __volatile__("cld;rep;movsw":"=&S"(d0),"=&D"(d1),"=& c" (d2):"0"(src),"1"(dst),"2"(count):"memory"); \

#define __wmemset(dst,val,count) \ { \ int d0,d1; \ __asm__ __volatile__("cld;rep;stosw":"=&D"(d0),"=&c"(d1):"0" (dst),"a"(val),"1"(count):"memory"); \

typedef struct { unsigned long esc,attrib,csr_x,csr_y,esc1,esc2,esc3; unsigned short * fb_adr; } console_t;

static console_t * _curr_vc; static console_t cons;

static unsigned short *_vga_fb_adr; static unsigned _crtc_io_adr, _vc_width, _vc_height; static int _num_vcs=1;

static void scroll(console_t *con) { unsigned short *fb_adr; unsigned blank, temp; blank = 0x20 | ((unsigned)con->attrib fb_adr; if(con->csr_y >= _vc_height) { temp = con->csr_y - _vc_height + 1; __wmemcpy(fb_adr, fb_adr + temp * _vc_width,(_vc_height - temp) * _vc_width); __wmemset(fb_adr + (_vc_height - temp) * _vc_width,blank, _vc_width); con->csr_y = _vc_height - 1;

static void set_attrib(console_t *con, unsigned att) { static const unsigned ansi_to_vga[] = { 0 , 4, 2, 14, 1, 5, 3, 7

unsigned new_att; new_att = con->attrib; if(att == 0) new_att &= ~0x08; else if(att == 1) new_att |= 0x08; else if(att >= 30 && att = 40 && att attrib = new_att;

static void move_csr(void) { unsigned temp; temp = (_curr_vc->csr_y * _vc_width + _curr_vc->csr_x) + (_curr_vc->fb_adr - _vga_fb_adr); outportb(_crtc_io_adr + 0, 14); outportb(_crtc_io_adr + 1, temp >> 8); outportb(_crtc_io_adr + 0, 15); outportb(_crtc_io_adr + 1, temp);

#define isdigit(c) ((c)>='0' && (c)= _num_vcs) return; _curr_vc = cons + which_vc; i = _curr_vc->fb_adr - _vga_fb_adr; outportb(_crtc_io_adr + 0, 12); outportb(_crtc_io_adr + 1, i >> 8); outportb(_crtc_io_adr + 0, 13); outportb(_crtc_io_adr + 1, i); move_csr();

static void putch_help(console_t *con, unsigned c) { unsigned short *fb_adr; unsigned att; att = (unsigned)con->attrib fb_adr; /* maszyna stanów do obsługi sekwencji escape */ if(con->esc == 1) { if(c == '[')

con->esc++; con->esc1 = 0; return;

/* inaczej idź do końca: zeruj esc i wypisz c */ } /* ESC[ */ else if(con->esc == 2) { if(isdigit(c))

con->esc1 = con->esc1 * 10 + c - '0'; return; } else if(c == ';')

con->esc++; con->esc2 = 0; return; } /* ESC[2J -- wyczyść ekran */ else if(c == 'J')

if(con->esc1 == 2)

__wmemset(fb_adr, (' ' | att)&0xffff, _vc_height * _vc_width); con->csr_x = con->csr_y = 0;

/* ESC[num1m -- ustaw atrybut num1 */ else if(c == 'm') set_attrib(con, con->esc1); con->esc = 0; return; } /* ESC[num1; */ else if(con->esc == 3) { if(isdigit(c))

con->esc2 = con->esc2 * 10 + c - '0'; return;

else if(c == ';')

con->esc++; /* ESC[num1;num2; */ con->esc3 = 0; return;

else if(c == 'H')

if(con->esc2 csr_x = con->esc2; if(con->esc1 csr_y = con->esc1;

else if(c == 'm')

set_attrib(con, con->esc1); set_attrib(con, con->esc2);

con->esc = 0; return; } else if(con->esc == 4) { if(isdigit(c))

con->esc3 = con->esc3 * 10 + c - '0'; return; } else if(c == 'm')

set_attrib(con, con->esc1); set_attrib(con, con->esc2); set_attrib(con, con->esc3);

con->esc = 0; return; } con->esc = 0; if(c == 0x1B) { con->esc = 1; return; } if(c == 0x08) { if(con->csr_x != 0) con->csr_x--; } else if(c == 0x09) con->csr_x = (con->csr_x + 8) & ~(8 - 1); else if(c == '\r') con->csr_x = 0; else if(c == '\n') { con->csr_x = 0; con->csr_y++; } else if(c >= ' ') { unsigned short *where; where = fb_adr + (con->csr_y * _vc_width + con->csr_x); *where = (c | att); con->csr_x++; } if(con->csr_x >= _vc_width) { con->csr_x = 0; con->csr_y++; } scroll(con); if(_curr_vc == con) move_csr();

void putch(char c) { putch_help(_curr_vc,c);

void puts(char * s) { for(;s && *s;s++) putch(*s);

void init_video(void) { _vga_fb_adr=(unsigned short *)0xb8000; _crtc_io_adr=0x3D4; _vc_width=80; _vc_height=25; cons.attrib=1; cons.fb_adr=_vga_fb_adr; _curr_vc=&cons; puts("\x1B[33;44m\x1B[2J");

Teraz mamy gotową procedurę obsługi ekranu. Zastosowana tu implementacja tylko częściowo wykorzystuje standard ANSI. Rozkazy ANSI składają się z ciągów sekwencji ESC. Są one dokładnie takie same jak te używane przez sterownik ANSI.SYS (kto używał DOSa, to powinien go pamiętać). UWAGA: Wszystko w tym rozdziale jest prawdziwe tylko i wyłącznie dla karty VGA i kompatybilnej. Na karcie Hercules inne są tylko adresy pamięci video, porty I/O oraz informacje o kolorze są opisane w inny sposób (Hercules jest kartą monochromatyczną). Na początek wypadałoby opisać, w jaki sposób tekst jest umieszczony w pamięci video.

Każdy znak zapisany jest w postaci jednego słowa (16-bit). Dolna połowa (bity 0-7) jest to po prostu kod znaku ASCII (można także zmieniać znaki zapisane w generatorze znaków karty graficznej, ale o tym kiedy indziej). W górnej połowie słowa (bity 8-15) jest zapisany kolor znaku. W jednobajtowym kolorze znaku zapisane są kolor tła znaku oraz kolor znaku.

Bity koloru znaku:

bity opis

b7 migotanie b6:b4 kolor tła (0-7) b3:b0 kolor znaku (0-15)

Wartości kolorów powinny się już kojarzyć programiście z Turbo Pascalem i stałymi opisującymi kolor ;). Są one dokładnie takie same jak w TP.

0 - czarny 1 - niebieski 2 - zielony 3 - cyan 4 - czerwony 5 - magenta 6 - brązowy 7 - biały 8 - ciemno-szary 9 - jasny niebieski 10 - jasny zielony 11 - jasny cyan 12 - różowy 13 - jasny magenta 14 - żółty 15 - jasny biały

Teraz opiszę tutaj kilka sekwencji ANSI escape: esc[nA - przesuwa kursor n wierszy w górę esc[nB - przesuwa kursor n wierszy w dół esc[nC - przesuwa kursor n wierszy w prawo esc[nD - przesuwa kursor n wierszy w lewo esc[y;xH - przesuwa kursor na pozycję (x,y). Górny lewy róg ekranu to (1,1) esc[2J - czyści ekran i umieszcza kursor w (1,1) esc[K - czyści linię od pozycji kursora do końca linii esc[y;xf - to samo co H esc[s - zapamiętuje pozycję kursora na wewnętrznym stosie esc[u - odczytuje pozycję kursora zapisaną przez esc[s i przesuwa go tam esc[im esc[i;jm esc[i;j;km - ustawienie atrybutów znaków i,j,k - atrybuty: 0 - wyłącza wszystkie atrybuty 1 - włącza pogrubienie