C用戶庫里面的printf具有高度可伸縮性，也很容易理解，相比之下C＋＋中的IO運算符就比較難了。為了在屏幕上顯示字符串或數據，我們現在需要實現類似C庫中的printf，顯示字符在B8000開始的顯存處。我并不像完全實現printf的所有功能，因為skelix內核只需要顯示字符串，十進制和十六進制或二進制，正整數，字符就行了，并且需要支持可變參數。其他更高級的功能我們不會用到。
這里有一種方法來實現，我們直到象func(int arg1, int arg2, int arg3)這樣一個函數被調用時，它匯編后的指令應該如下（所有從左向右入棧的編譯器應該從地球上徹底消失）：
pushl arg3
pushl arg2
pushl arg1
call func
我們看到，參數從右向左一個個入棧，參數越多，入棧越深。如果是可變參數那我們怎么知道有多少個參數呢？答案是printf格式化字符串中參數判斷：有多少個%X，就有多少個參數要解析。在32位模式下，所有小于4字節的參數都被當作4字節處理。例如一個char型參數，入棧時就是int型了，所以在解析參數時務必保證正確。
我們這樣設計kprintf參數：kprintf(color,
format string, arguments...)
第一個參數定義輸出的前景/背景顏色。我們定義了很多宏來解析棧，如果你熟悉C語言應該很容易理解它們。
03/kprintf.c
#define args_list char
* // 這個宏用例轉換棧空間為字符串指針
#define _arg_stack_size(type)
(((sizeof(type)-1)/sizeof(int)+1)*sizeof(int))
// 這個宏四舍五入參數大小為4字節的倍數
#define args_start(ap, fmt) do { \
ap = (char *)((unsigned int)&fmt + _arg_stack_size(&fmt));
\
} while (0)
//
參數將從格式化字符串后面開始解析，即fmt就是棧頂，上面這個宏就是取參數的首地址
#define args_end(ap) //
到現在為止，什么也不做
#define args_next(ap, type) (((type *)(ap+=_arg_stack_size(type)))[-1])
//
取‘當前’參數地址，然后設置指針為下一個參數地址，曖昧的函數名！
03/kprintf.c
static char buf[1024] =
{-1}; // 注意沒有鎖保護，引用該變量的函數不可重入！
static int ptr = -1;
下面兩個函數解析值為指定的進制數：
static void
parse_num(unsigned int value, unsigned int base)
{ // 可以打印小于等于10進制的數
unsigned int n = value / base;
int r = value % base;
if (r < 0) {
r += base;
--n;
}
if (value >= base)
parse_num(n, base);
buf[ptr++] = (r+'0');
}
static
void //
打印16進制數
parse_hex(unsigned int value) {
int i = 8;
while (i-- > 0) {
buf[ptr++] =
"0123456789abcdef"[(value>>(i*4))&0xf];
}
}
現在我們來看一下 kprintf這個函數，它支持的格式：%s,
%c, %x, %d, %%
void
kprintf(enum KP_LEVEL kl, const char *fmt, ...) {
int i = 0;
char *s;
/* must be the same size as enum KP_LEVEL */
struct KPC_STRUCT {
COLOUR fg;
COLOUR bg;
} KPL[] = {
{BRIGHT_WHITE, BLACK},
{YELLOW, RED},
};
enum KP_LEVEL {KPL_DUMP, KPL_PANIC} 定義在 include/kprintf.h, 它表示兩種輸出方案, KPL_DUMP 使用黑色背景白色前景顯示字符，KPL_PANIC 使用黃色前景和紅色背景。顏色常量定義在 include/scr.h,
后面會介紹到.
args_list args;
args_start(args, fmt);
ptr = 0;
for (; fmt[i]; ++i) {
if ((fmt[i]!='%') &&
(fmt[i]!='\\')) {
buf[ptr++] = fmt[i];
continue;
} else if (fmt[i] == '\\') {
/* \a \b \t \n \v \f
\r \\ */
switch (fmt[++i]) {
case 'a': buf[ptr++] =
'\a'; break;
case 'b': buf[ptr++] =
'\b'; break;
case 't': buf[ptr++] =
'\t'; break;
case 'n': buf[ptr++] =
'\n'; break;
case 'r': buf[ptr++] =
'\r'; break;
case '\\':buf[ptr++] =
'\\'; break;
}
continue;
}
/* 下面是支持的打印格式 */
switch (fmt[++i]) {
case 's':
s = (char
*)args_next(args, char *);
while (*s)
buf[ptr++] = *s++;
break;
case 'c':
buf[ptr++] =
(char)args_next(args, int);
break;
case 'x':
parse_hex((unsigned
long)args_next(args, unsigned long));
break;
case 'd':
parse_num((unsigned
long)args_next(args, unsigned long), 10);
break;
case '%':
buf[ptr++] = '%';
break;
default:
buf[ptr++] = fmt[i];
break;
}
}
buf[ptr] = '\0';
args_end(args);
for (i=0; i<ptr; ++i)
print_c(buf[i],
KPL[kl].fg,
KPL[kl].bg); /*
print_c() 是下層的顯示函數，本文后面會有講解 */
}
由于是內核程序，我們無法使用C用戶庫。所以一下memcpy，memset，memcpy函數需要自己實現，但是需要注意的是在BSD系統中，即便使用了-nostdlib，編譯器仍然會產生System V中相關的memcpy等代碼，具體情況我也不是很清除。這些函數的效率當然無法和linux內核中的內嵌匯編相比！我們暫時這樣實現它們吧。
03/libcc.c
/* 下面函數對重疊區域也進行了處理
*/
void
bcopy(const void *src, void *dest, unsigned int n) {
const char *s = (const char *)src;
char *d = (char *)dest;
if (s <= d)
for (; n>0; --n)
d[n-1] = s[n-1];
else
for (; n>0; --n)
*d++ = *s++;
}
void
bzero(void *dest, unsigned int n) {
memset(dest, 0, n);
}
void *
memcpy(void *dest, const void *src, unsigned int n) {
bcopy(src, dest, n);
return dest;
}
void *
memset(void *dest, int c, unsigned int n) {
char *d = (char *)dest;
for (; n>0; --n)
*d++ = (char)c;
return dest;
}
int
memcmp(const void *s1, const void *s2, unsigned int n) {
const char *s3 = (const char *)s1;
const char *s4 = (const char *)s2;
for (; n>0; --n) {
if (*s3 > *s4)
return 1;
else if (*s3 < *s4)
return -1;
++s3;
++s4;
}
return 0;
}
int
strcmp(const char *s1, const char *s2) {
while (*s1 && *s2) {
int r = *s1++ - *s2++;
if (r)
return r;
}
if (*s1 == *s2)
return 0
else
return (*s1)?1:-1;
}
char *
strcpy(char *dest, const char *src) {
char *p = dest;
while ( (*dest++ = *src++))
;
*dest = 0;
return p;
}
unsigned int
strlen(const char *s) {
unsigned int n = 0;
while (*s++)
++n;
return n;
}
print_c函數
直接操作顯存區域一點也不方便，所以我們需要一個顯示模塊。這個就是我們的‘顯卡驅動’了，是不是不敢相信驅動是這么簡單的事情？我們先來看一下一些常量定義：
03/include/scr.h
#define MAX_LINES
25 //
bios默認設置屏幕為 80x25大小，彩色字符模式
#define MAX_COLUMNS 80
#define TAB_WIDTH
8
// 必須是：2^n
#define VIDEO_RAM
0xb8000 // 顯存地址
我們曾簡要提到過這個地址，在字符模式下，適配器使用0xB8000-0xBF000作為視頻內存。通常我們處于80x25大小屏幕，有16種顏色。由于一個屏幕只需要80x25x2個字節，即4k，所以該視頻內存可以分為多個頁。我們使用所有的頁，但是當前只能有一個頁面可見。為了顯示一個字符，將用到2個字節，一個字節是字符值，另一個字節是字符屬性（即顏色）。屬性字節定義如下：
To display a single character, two bytes are being used
which called the character byte and the attribute byte. The character byte
contains the value of the character. The attribute byte is defined like this:
|
Bit 7
|
閃爍
|
|
Bits 6-4
|
背景色
|
|
Bit 3
|
明亮模式
|
|
Bit3 2-0
|
前景色
|
#define LINE_RAM (MAX_COLUMNS*2)
#define PAGE_RAM (MAX_LINE*MAX_COLUMNS)
#define BLANK_CHAR (' ')
#define BLANK_ATTR (0x70)
/* 白色前景，黑色背景 */
#define CHAR_OFF(x,y)
(LINE_RAM*(y)+2*(x)) /* 計算給定坐標x，y的偏移地址（相對0xB8000） */
Calculates the offset of a given ordinary x, y from 0xB8000
typedef enum COLOUR_TAG
{ /*
顏色表 */
BLACK, BLUE, GREEN, CYAN, RED, MAGENTA, BROWN, WHITE,
GRAY, LIGHT_BLUE, LIGHT_GREEN, LIGHT_CYAN,
LIGHT_RED, LIGHT_MAGENTA, YELLOW, BRIGHT_WHITE
} COLOUR;
坐標系如下：
___________________\
| （0，0） /
|
\|/
03/scr.c
static int csr_x = 0;
static int csr_y = 0;
由于我們只用到了一個視頻頁，所以上面兩個變量就可以存儲坐標了。關于多頁顯示可以在網絡上查找相關資料。
static void
scroll(int lines) { 向上滾動屏幕多少行，就是一些內存復寫。
short *p = (short *)(VIDEO_RAM+CHAR_OFF(MAX_COLUMNS-1,
MAX_LINES-1));
int i = MAX_COLUMNS-1;
memcpy((void *)VIDEO_RAM, (void
*)(VIDEO_RAM+LINE_RAM*lines),
LINE_RAM*(MAX_LINES-lines));
for (; i>=0;
--i) // 說明這個for循環有問題，覺得應該改成下面這樣：
// for (i = i * lines;
i>=0; --i)
*p-- =
(short)((BLANK_ATTR<<4)|BLANK_CHAR);
}
下面函數設置光標可能會引發競態條件，但是print_c只準備在內核中使用，所以沒有關中斷。它可能會引起一些bug，但是我沒有找到。譯注：全局變量沒有鎖保護在設計上就是一種錯誤。這里的代碼保護確實是沒有做！讀者應用到自己的內核時要小心了。
void
set_cursor(int x, int y) {
csr_x = x;
csr_y = y;
outb(0x0e,
0x3d4);
設置光標高8位的準備工作
outb(((csr_x+csr_y*MAX_COLUMNS)>>8)&0xff,
0x3d5); 設置光標高8位
outb(0x0f,
0x3d4);
設置光標低8位的準備工作
outb(((csr_x+csr_y*MAX_COLUMNS))&0xff,
0x3d5); 設置光標低8位
}
void
get_cursor(int *x, int *y) {
*x = csr_x;
*y = csr_y;
}
void
print_c(char c, COLOUR fg, COLOUR bg) {
// 用這個函數來顯示一個具體的字符到屏幕，我們可以把它看作‘顯卡驅動’
char *p;
char attr;
p = (char *)VIDEO_RAM+CHAR_OFF(csr_x,
csr_y); // 取光標位置
attr =
(char)(bg<<4|fg);
// 屬性
switch (c) {
case '\r':
csr_x = 0;
break;
case '\n':
for (; csr_x<MAX_COLUMNS; ++csr_x) {
*p++ = BLANK_CHAR;
*p++ = attr;
}
break;
case '\t':
c =
csr_x+TAB_WIDTH-(csr_x&(TAB_WIDTH-1));
c = c<MAX_COLUMNS?c:MAX_COLUMNS;
for (; csr_x<c; ++csr_x) {
*p++ = BLANK_CHAR;
*p++ = attr;
}
break;
case '\b':
if ((! csr_x) && (! csr_y))
return;
if (! csr_x) {
csr_x = MAX_COLUMNS -
1;
--csr_y;
} else
--csr_x;
((short *)p)[-1] = (short)((BLANK_ATTR<<4)|BLANK_CHAR);
break;
default:
*p++ = c;
*p++ = attr;
++csr_x;
break;
}
if (csr_x >= MAX_COLUMNS) {
csr_x = 0;
if (csr_y < MAX_LINES-1)
++csr_y;
else
scroll(1);
}
set_cursor(csr_x,
csr_y); // 設置光標位置
}
函數比較簡單，沒有分析的必要了，大家自己琢磨吧。