当前位置： 首页 > article >正文

30天开发操作系统 第 20 天 -- API

article 2025/2/18 16:54:02

前言

大家早上好，今天我们继续努力哦。 昨天我们已经实现了应用程序的运行, 今天我们来实现由应用程序对操作系统功能的调用(即API, 也叫系统调用)。
为什么这样的功能称为“系统调用”(system call)呢？因为它是由应用程序来调用(操作)系统中的功能来完成某种操作, 这个名字很直白吧。
“API” 这个名字就稍微复杂些，是“application program interface" 的缩写, 即“应用程序(与系统之间的）接口”的意思。请大家把这两个名字记住哦，考试题目中会有的哦.……开玩笑啦，这些其实用不着记啦。 有记这些单词的工夫，还不如多享受一下制作操作系统的乐趣呢。
这值得纪念的第一次，我们就来做个在命令行窗口中显示字符的API吧。BIOS中也有这个功能哦，如果忘了的话请重新看看第二天的内容。怎么样，找到了吧？无论什么样的操作系统， 都会有功能类似的API，这可以说是必需的。

一、程序整理

现在这程序是怎么回事！下面来改造一下我们操作系统, 让它可以使用API吧…
尤其是console task,简直太不像样了。看着如此混乱的程序代码，真是提不起任何干劲来进行改造, 我们还是先把程序整理一下吧。
由于只是改变了程序的写法,并没有改变程序处理的内容，因此这里就不讲解了。 从249行改到了85行的console_task, 哦耶！

console.c
void console_task(struct SHEET *sheet, unsigned int memtotal)
{
	struct TIMER *timer;
	struct TASK *task = task_now();
	struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
	int i, fifobuf[128], *fat = (int *) memman_alloc_4k(memman, 4 * 2880);
	struct CONSOLE cons;
	char cmdline[30];
	cons.sht = sheet;
	cons.cur_x =  8;
	cons.cur_y = 28;
	cons.cur_c = -1;

	fifo32_init(&task->fifo, 128, fifobuf, task);
	timer = timer_alloc();
	timer_init(timer, &task->fifo, 1);
	timer_settime(timer, 50);
	file_readfat(fat, (unsigned char *) (ADR_DISKIMG + 0x000200));

	/* 显示提示符 */
	cons_putchar(&cons, '>', 1);

	for (;;) {
		io_cli();
		if (fifo32_status(&task->fifo) == 0) {
			task_sleep(task);
			io_sti();
		} else {
			i = fifo32_get(&task->fifo);
			io_sti();
			if (i <= 1) { /* 光标用定时器 */
				if (i != 0) {
					timer_init(timer, &task->fifo, 0); /* 下次置 0 */
					if (cons.cur_c >= 0) {
						cons.cur_c = COL8_FFFFFF;
					}
				} else {
					timer_init(timer, &task->fifo, 1); /* 下次值 1 */
					if (cons.cur_c >= 0) {
						cons.cur_c = COL8_000000;
					}
				}
				timer_settime(timer, 50);
			}
			if (i == 2) {	/* 光标ON */
				cons.cur_c = COL8_FFFFFF;
			}
			if (i == 3) {	/* 光标 OFF */
				boxfill8(sheet->buf, sheet->bxsize, COL8_000000, cons.cur_x, cons.cur_y, cons.cur_x + 7, cons.cur_y + 15);
				cons.cur_c = -1;
			}
			if (256 <= i && i <= 511) { /* 键盘数据（通过任务A） */
				if (i == 8 + 256) {
					/* 退格键 */
					if (cons.cur_x > 16) {
						/* 用空格擦除光标后将光标前移一位 */
						cons_putchar(&cons, ' ', 0);
						cons.cur_x -= 8;
					}
				} else if (i == 10 + 256) {
					/* Enter */
					/* 将光标用空格擦除后换行 */
					cons_putchar(&cons, ' ', 0);
					cmdline[cons.cur_x / 8 - 2] = 0;
					cons_newline(&cons);
					cons_runcmd(cmdline, &cons, fat, memtotal);	/* 运行命令 */
					/* 显示提示符 */
					cons_putchar(&cons, '>', 1);
				} else {
					/* 一般字符 */
					if (cons.cur_x < 240) {
						/* 显示一个字将之后将光标后移一位 */
						cmdline[cons.cur_x / 8 - 2] = i - 256;
						cons_putchar(&cons, i - 256, 1);
					}
				}
			}
			/* 重新显示光标 */
			if (cons.cur_c >= 0) {
				boxfill8(sheet->buf, sheet->bxsize, cons.cur_c, cons.cur_x, cons.cur_y, cons.cur_x + 7, cons.cur_y + 15);
			}
			sheet_refresh(sheet, cons.cur_x, cons.cur_y, cons.cur_x + 8, cons.cur_y + 16);
		}
	}
}

void cons_putchar(struct CONSOLE *cons, int chr, char move)
{
	char s[2];
	s[0] = chr;
	s[1] = 0;
	if (s[0] == 0x09) {	/* 制表符 */
		for (;;) {
			putfonts8_asc_sht(cons->sht, cons->cur_x, cons->cur_y, COL8_FFFFFF, COL8_000000, " ", 1);
			cons->cur_x += 8;
			if (cons->cur_x == 8 + 240) {
				cons_newline(cons);
			}
			if (((cons->cur_x - 8) & 0x1f) == 0) {
				break;	/* 被32整除则break */
			}
		}
	} else if (s[0] == 0x0a) {	/* 换行 */
		cons_newline(cons);
	} else if (s[0] == 0x0d) {	/* 回车 */
		/* 先不做操作 */
	} else {	/* 一般字符 */
		putfonts8_asc_sht(cons->sht, cons->cur_x, cons->cur_y, COL8_FFFFFF, COL8_000000, s, 1);
		if (move != 0) {
			/* move为0时光标不后移 */
			cons->cur_x += 8;
			if (cons->cur_x == 8 + 240) {
				cons_newline(cons);
			}
		}
	}
	return;
}

void cons_newline(struct CONSOLE *cons)
{
	int x, y;
	struct SHEET *sheet = cons->sht;
	if (cons->cur_y < 28 + 112) {
		cons->cur_y += 16; /* 到下一行 */
	} else {
		/* 滚动 */
		for (y = 28; y < 28 + 112; y++) {
			for (x = 8; x < 8 + 240; x++) {
				sheet->buf[x + y * sheet->bxsize] = sheet->buf[x + (y + 16) * sheet->bxsize];
			}
		}
		for (y = 28 + 112; y < 28 + 128; y++) {
			for (x = 8; x < 8 + 240; x++) {
				sheet->buf[x + y * sheet->bxsize] = COL8_000000;
			}
		}
		sheet_refresh(sheet, 8, 28, 8 + 240, 28 + 128);
	}
	cons->cur_x = 8;
	return;
}

void cons_runcmd(char *cmdline, struct CONSOLE *cons, int *fat, unsigned int memtotal)
{
	if (strcmp(cmdline, "mem") == 0) {
		cmd_mem(cons, memtotal);
	} else if (strcmp(cmdline, "cls") == 0) {
		cmd_cls(cons);
	} else if (strcmp(cmdline, "dir") == 0) {
		cmd_dir(cons);
	} else if (strncmp(cmdline, "type ", 5) == 0) {
		cmd_type(cons, fat, cmdline);
	} else if (strcmp(cmdline, "hlt") == 0) {
		cmd_hlt(cons, fat);
	} else if (cmdline[0] != 0) {
		/*不是命令，也不是空行*/
		putfonts8_asc_sht(cons->sht, 8, cons->cur_y, COL8_FFFFFF, COL8_000000, "Bad command.", 12);
		cons_newline(cons);
		cons_newline(cons);
	}
	return;
}

void cmd_mem(struct CONSOLE *cons, unsigned int memtotal)
{
	struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
	char s[30];
	sprintf(s, "total   %dMB", memtotal / (1024 * 1024));
	putfonts8_asc_sht(cons->sht, 8, cons->cur_y, COL8_FFFFFF, COL8_000000, s, 30);
	cons_newline(cons);
	sprintf(s, "free %dKB", memman_total(memman) / 1024);
	putfonts8_asc_sht(cons->sht, 8, cons->cur_y, COL8_FFFFFF, COL8_000000, s, 30);
	cons_newline(cons);
	cons_newline(cons);
	return;
}

void cmd_cls(struct CONSOLE *cons)
{
	int x, y;
	struct SHEET *sheet = cons->sht;
	for (y = 28; y < 28 + 128; y++) {
		for (x = 8; x < 8 + 240; x++) {
			sheet->buf[x + y * sheet->bxsize] = COL8_000000;
		}
	}
	sheet_refresh(sheet, 8, 28, 8 + 240, 28 + 128);
	cons->cur_y = 28;
	return;
}

void cmd_dir(struct CONSOLE *cons)
{
	struct FILEINFO *finfo = (struct FILEINFO *) (ADR_DISKIMG + 0x002600);
	int i, j;
	char s[30];
	for (i = 0; i < 224; i++) {
		if (finfo[i].name[0] == 0x00) {
			break;
		}
		if (finfo[i].name[0] != 0xe5) {
			if ((finfo[i].type & 0x18) == 0) {
				sprintf(s, "filename.ext   %7d", finfo[i].size);
				for (j = 0; j < 8; j++) {
					s[j] = finfo[i].name[j];
				}
				s[ 9] = finfo[i].ext[0];
				s[10] = finfo[i].ext[1];
				s[11] = finfo[i].ext[2];
				putfonts8_asc_sht(cons->sht, 8, cons->cur_y, COL8_FFFFFF, COL8_000000, s, 30);
				cons_newline(cons);
			}
		}
	}
	cons_newline(cons);
	return;
}

void cmd_type(struct CONSOLE *cons, int *fat, char *cmdline)
{
	struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
	struct FILEINFO *finfo = file_search(cmdline + 5, (struct FILEINFO *) (ADR_DISKIMG + 0x002600), 224);
	char *p;
	int i;
	if (finfo != 0) {
		/* 找到文件的情况 */
		p = (char *) memman_alloc_4k(memman, finfo->size);
		file_loadfile(finfo->clustno, finfo->size, p, fat, (char *) (ADR_DISKIMG + 0x003e00));
		for (i = 0; i < finfo->size; i++) {
			cons_putchar(cons, p[i], 1);
		}
		memman_free_4k(memman, (int) p, finfo->size);
	} else {
		/* 没有找到文件的情况 */
		putfonts8_asc_sht(cons->sht, 8, cons->cur_y, COL8_FFFFFF, COL8_000000, "File not found.", 15);
		cons_newline(cons);
	}
	cons_newline(cons);
	return;
}

void cmd_hlt(struct CONSOLE *cons, int *fat)
{
	struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
	struct FILEINFO *finfo = file_search("HLT.HRB", (struct FILEINFO *) (ADR_DISKIMG + 0x002600), 224);
	struct SEGMENT_DESCRIPTOR *gdt = (struct SEGMENT_DESCRIPTOR *) ADR_GDT;
	char *p;
	if (finfo != 0) {
		/* 找到文件的情况 */
		p = (char *) memman_alloc_4k(memman, finfo->size);
		file_loadfile(finfo->clustno, finfo->size, p, fat, (char *) (ADR_DISKIMG + 0x003e00));
		set_segmdesc(gdt + 1003, finfo->size - 1, (int) p, AR_CODE32_ER);
		farjmp(0, 1003 * 8);
		memman_free_4k(memman, (int) p, finfo->size);
	} else {
		/* 没有找到文件的情况 */
		putfonts8_asc_sht(cons->sht, 8, cons->cur_y, COL8_FFFFFF, COL8_000000, "File not found.", 15);
		cons_newline(cons);
	}
	cons_newline(cons);
	return;
}

file.c
struct FILEINFO *file_search(char *name, struct FILEINFO *finfo, int max)
{
	int i, j;
	char s[12];
	for (j = 0; j < 11; j++) {
		s[j] = ' ';
	}
	j = 0;
	for (i = 0; name[i] != 0; i++) {
		if (j >= 11) { return 0; /* 没有找到 */ }
		if (name[i] == '.' && j <= 8) {
			j = 8;
		} else {
			s[j] = name[i];
			if ('a' <= s[j] && s[j] <= 'z') {
				/* 蒋小写字母转换为大写字母 */
				s[j] -= 0x20;
			} 
			j++;
		}
	}
	for (i = 0; i < max; ) {
		if (finfo[i].name[0] == 0x00) {
			break;
		}
		if ((finfo[i].type & 0x18) == 0) {
			for (j = 0; j < 11; j++) {
				if (finfo[i].name[j] != s[j]) {
					goto next;
				}
			}
			return finfo + i; /* 找到文件 */
		}
next:
		i++;
	}
	return 0; /* 没有找到 */
}

嗯嗯，比之前的代码易读多了。你看，只要想把代码写得清爽些就一定能做到的，连笔者都 做到了嘛(笑)。这个例子说明，如果持续增加新的功能，一个函数的代码就会变得很长，像这 样定期整理一下还是很有帮助的。 好了，我们来“make run”，输人一些命令试试看。和之前运行的情况一样，很好。

二、显示单个字符的API

现在我们要开始做显示单个字符的API了哦。 说起来其实也不是很难, 只要应用程序能用某 种方法调用cons putchar就可以了。
首先我们做一个测试用的应用程序, 将要显示的字符编码存人AL寄存器, 然后调用操作系统的函数, 字符就显示出来了。

[BITS 32]
	MOV AL,'A’
	CALL (cons_putchar的地址)
fin:
	HLT
	JMP fin

就是这个样子。CALL是一个用来调用丽数的指令。在C语言中，goto和函数调用的处理方式 完全不同，不过在汇编语言中，CALL指令和JMP指令其实差不多是一码事，它们的区别仅仅在 当执行CALL指令时，为了能够在接下来执行RET指令时正确返回，会先将要返回的目标地 于, 址PUSH到栈中。
关于CALL指令这里想再讲一下。有人可能会想，直接写CALLcons putchar不就好了吗?然 而，hlt.nas这个应用程序在汇编时并不包含操作系统本身的代码，因此汇编器无法得知要调用的 函数地址，汇编就会出错。要解决这个问题，必须人工查好地址后直接写到代码中。在对haribote.sys进行make的时候, 通过一定的方法我们可以查出cons putchar的地址， 没有问题, 那S 么我们就来查一下地址… 且慢!

这样做有个问题, 因为cons_putchar是用C语言写的函数, 即便我们将字符编码存入寄存器 函数也无法接收, 因此我们必须在CALL之前将文字编码推入栈才行, 但这样做也太麻烦了。
没办法，我们只好用汇编语言写一个用来将寄 存器的值推入栈的函数了。这个函数不是应用 程序的一部分, 而是写在操作系统的代码中, 因此我们要改写的是naskfunc.nas。 另一方面, 在 应用程序中, 我们CALL的地址不再是cons_putchar, 而是变成了新写的 asm cons_putchar：

_asm_cons_putchar:
		PUSH	1
		AND		EAX,0xff	; 将AH和EAX的高位置0，将EAX置为已存入字符编码的状态
		PUSH	EAX
		PUSH	(cons的地址)
		CALL	_cons_putchar
		ADD		ESP,12		; 丢弃栈中数据
		RET

PUSH的特点是后进先出，因此这个程序的顺序没问题。（这个12，是因为我们push了三次4个字节（32位），运行时栈的增长是从高地址向低地址，大家还记得吧😄）
栈传递（Stack Passing）：

调用函数最常见的方法是将参数依次压入堆栈。调用函数后，函数通过堆栈访问这些参数。

push arg3
push arg2
push arg1
call function_name
add esp, 12 ; 清理堆栈（假设3个参数，每个4字节）
大家按照这个理解

这段程序的问题在于 “cons的地址" 到底是多少。应用程序是不知道这个地址的, 唔,那么只能让操作系统把这个地址事先保存在内存中的某个地方 用程序来指定地址难以实现。哪里比较好呢?对了, 就保存在BOOTINFO之前的0x0fec这个地址吧。
现在操作系统这边的工作已经完成了，因此我们先来“ make”一下, 注意这里不是"make run"。因为应用程序还没有准备好呢，所以我们先make。
make完成后, 除了haribote.sys之外, 还会生成一个叫bootpack.map的文件 首然 之前我们一直忽略这个文件的, 不过这次它要派上用场了。
这是一个文本文件，用文本编辑器打开：其中应该可以找到这样一行:
0x00000BE3 ：_asm_cons putchar
这就是 _asm_cons putchar 的地址了，我们将地址填在应用程序中:

_asm_cons_putchar:
		PUSH	1
		AND		EAX,0xff	; 将AH和EAX的高位置0，将EAX置为已存入字符编码的状态
		PUSH	EAX
		PUSH	(cons的地址)
		CALL	_cons_putchar
		ADD		ESP,12		; 丢弃栈中数据
		RET

void console_task(struct SHEET *sheet, unsigned int memtotal)
{
	...
	char cmdline[30];
	cons.sht = sheet;
	cons.cur_x =  8;
	cons.cur_y = 28;
	cons.cur_c = -1;
	*((int *) 0x0fec) = (int) &cons; /*这里!*/
	...
}

现在操作系统这边的工作已经完成了，因此我们先来“ make”一下, 注意这里不是"make run"。因为应用程序还没有准备好呢，所以我们先make。
make完成后, 除了haribote.sys之外, 还会生成一个叫bootpack.map的文件 首然 之前我们一直忽略这个文件的, 不过这次它要派上用场了。
这是一个文本文件，用文本编辑器打开：其中应该可以找到这样一行:
0x00000BE3 ：_asm_cons putchar
这就是 _asm_cons putchar 的地址了，我们将地址填在应用程序中:

[BITS 32]
		MOV		AL,'A'
		CALL    0xbe3
fin:
		HLT
		JMP		fin

然后再进行汇编就可以了，很简单吧。

说起来, 我们写的这些代码里面, 哪个部分是API呢？“MOVE AL, A’”和“CALL 0xbe3” ，就是API了，因为API就是由应用程序来使用操作系统所提供的服务。当然，我们这个是否达到“服务” 的程度就另当别论了。
现在我们的应用程序也已经完成了, “make run”嘿！然后在命令行窗口里面运行 “hlt" 就可以了。
啊! qemu.exe出错关闭了！看来我们遇了一个不得了的大bug。 在真机环境下无法预料会造成什么后果, 因此请大家不要尝试。下面我们来解决这个bug。

像这样会造成模拟器出错关闭的bug, 果然只有在开发操作系统时才能碰到。 如果不用模拟器进行开发的话，不经意间产生的bug有时可能会造成电脑损坏、硬盘被格式化等严重问题, 也许好几天都无法恢复过来。 开发操作系统就是这么刺激。如果通过这次的bug, 大家能够瞥见这种刺激的冰山一角，那么这个bug也算是有点用的吧(苦笑)。

不过，光扯刺激啦什么的也无济于事, 我们还得仔细寻找原因。哦，原来如此，找到了！
原因其实很简单。应用程序对API执行CALL的时候，千万不能忘记加上段号。因此我们不能使用普通的CALL，应用程序所在的段为 “1003 * 8", 而操作系统所在的段为“2*8”，而应该使用far-CALL。
far-CALL实际上和far-JMP一样，只要同时指定段和偏移量即可。

[BITS 32]
		MOV		AL,'A'
		CALL    2*8:0xbe3
fin:
		HLT
		JMP		fin

好，完工了，这样bug应该就解决了, 我们来试试看。 make run然后运行“hlt"。还是不行。这次虽然没有出错关闭，但qemu.exe停止响应了。
这个问题是由于_asm_cons_putchar的RET指令所造成的。普通的RET指令是用于普通的 CALL 的返回，而不能用于far-CALL的返回，既然我们用了far-CALL，就必须相应地使用far-RET, 也就是RETF指令。因此我们将程序修改一下。

asm_cons_putchar:
(中略)
RETF ;这里!

好啦, 这次应该没问题了吧。
在这里插入图片描述

3.结束应用程序

照现在这个样子，应用程序结束之后会执行HLT，我们就无法在命令行窗口中继续输入命令 了，这多无聊啊。如果应用程序结束后不执行HLT，而是能返回操作系统就好了。
怎样才能实现这样的设想呢?没错，只要将应用程序中的HLT改成RET， 就可以返回了。相应地，操作系统这边也需要用CALL来代替JMP启动应用程序才对。虽说是CALL，不过因为要调用的程序位于不同的段, 所以实际上应该使用far-CALL, 因此应用程序那边也应该使用RETF。 我们的方针已经明确了。

C语言中没有用来执行far-CALL的命令，我们来创建一个farcall函数，这个函数和farjmp大同小异。

_farcall:		; void farcall(int eip, int cs);
		CALL	FAR	[ESP+4]				; eip, cs
		RET

我们还要把hlt命令的处理改为调用farcall。

void cmd_hlt(struct CONSOLE *cons, int *fat)
{	...
	if (finfo != 0) {
		...
		farcall(0, 1003 * 8); /* 这里 */
		} else {
		
		}
		...
}

最后我们还要改写一下应用程序hlt.nas, 把HLT换成RETF就可以了。

[BITS 32]
		MOV		AL,'A'
		CALL    2*8:0xbe3
		RETF

完工了哦。好, 我们来 make run 然后运行“hlt”。貌似是有bug (今天我们碰了好几个钉子了嘛)。 qemu.exe又停止响应了, 明白了。由于我们改写了操作系统的代码, 怎么回事呢?导致asm_cons_putchar的地址 发生了变化。重新查看bootpack.map，我们发现地址变成了这样:
0x0000BE8 : asm_cons putchar
因此, 我们把应用程序的地址修改一下：

[BITS 32]
		MOV		AL,'A'
		CALL    2*8:0xbe8
		RETF

'make run", “hlt"，怎么样？好了！成功了!
在这里插入图片描述

趁热打铁, 我们再来个新的尝试: hello” 显示

貌似用循环比较好呢?算了，实在太麻烦(笑)。我们运行一下试试看， 结果如下。
在这里插入图片描述

话说回来，现在这个应用程序已经和当初“hlt"这个名字完全对不上号了， 看来我们得赶快给它改改名字了哦。

4.不随操作系统版本而改变的API

所以说我们又要改写console.c。等等，如果修改了操作系统的代码，岂不是asm_cons_ putchar的地址也会像上次那样发生变化？难道说每次我们修改操作系统的代码，都得把应用程序的代码也改一遍?这也太麻烦了。

虽说确实有的操作系统版本一改变，应用程序 也得重新编译,不过还有些系统即便版本改变，应用程序也照样可以运行，大家觉得哪种更好呢?

把这个搞定之后， 我们再考虑命名的事。
解决这个问题的方法其实有很多，这里先为大家介绍其中一种。
CPU中有个专门用来注册函数的地方，也许大家一下子想不起来，其实是中断处理 程序。在前面我们曾经做过“当发生IRQ-1的时候调用这个函数”这样的设置, 大家还记得吗? 这是在IDT中设置的。
而CPU用于通知异常状态的中断最多也只有32种，这些都在CPU规格说 反正IRQ只有0～15, 明书中有明确记载。 不过，IDT中却最多可以设置256个函数，因此还剩下很多没有使用的项。
我们的操作系统从这些项里面借用一个的话, CPU应该也不会有什么意见的吧。所以我们就从IDT中找一个空闲的项来用一下。好，我们就选0x40号(其实0x30~0xff都是空闲的，只要在这个范围内任意一个都可以)，并将_asm_ cons_putchar注册在这里。

void init_gdtidt(void)
{
   ...
   set_gatedesc(idt + 0x20, (int) asm_inthandler20, 2 * 8, AR_INTGATE32);
   set_gatedesc(idt + 0x21, (int) asm_inthandler21, 2 * 8, AR_INTGATE32);
   set_gatedesc(idt + 0x27, (int) asm_inthandler27, 2 * 8, AR_INTGATE32);
   set_gatedesc(idt + 0x2c, (int) asm_inthandler2c, 2 * 8, AR_INTGATE32);
   set_gatedesc(idt + 0x40, (int) asm_cons_putchar, 2 * 8, AR_INTGATE32);

   return;
}

我们只要用INT 0x40来代原来的CALL 2*8:0xbd1就可以调用_asm_ cons_putchar了。这样一来，很方便吧?我们来修改一下应用程序吧。

[BITS 32]
		MOV		AL,'h'
		INT		0x40
		MOV		AL,'e'
		INT		0x40
		MOV		AL,'l'
		INT		0x40
		MOV		AL,'l'
		INT		0x40
		MOV		AL,'o'
		INT		0x40
		RETF

于是程序变成了这个样子。看到这里，直觉敏锐的你也许已经发现了“跟调用BIOS的时候差不多嘛….” 虽然INT号不同，但通过INT方式调用这一点的确是非常类似。说起来， 没错，MS-DOS的API采用的也是这种INT方式。
另外，使用INT指令来调用的时候会被视作中断来处理, 需要使用 IRETD指令，用RETF是无法返回的, 我们还要改写_asm_ cons_putchar。

_asm_cons_putchar:
		STI
		PUSH	1
		AND		EAX,0xff	; 将AH和EAX的高位置0，将EAX置为已存入字待编码的状态
		PUSH	EAX
		PUSH	DWORD [0x0fec]	; 读取内存并PUSH该值
		CALL	_cons_putchar
		ADD		ESP,12		; 丢弃栈中的数据
		IRETD	;这里！

用INT调用时，对于CPU来说相当于执行了中 断处理程序，因此在调用的同时CPU会自动执 但我们只是用它来代替CALL使用，这种做法就显得画蛇添足了。 行CLI指令来禁止中断请求。 我们可不想看到“API处理时键盘无法输入”这样的情况, 因此需要在开头添加一条STI指令。
对于这种问题，一般来说可以通过在注册到IDT时修改设置来禁止CPU擅自执行CLI, 其实, 最近貌似懒到家了，得反省一下。 不过这个有点麻烦, 还是算了吧(笑)。

make run → 结果如下：

你看，用这种方法还能把应用程序缩小。这是因为far-CALL指令需要7个字节而INT指令只需要2个字节的缘故。 这次修改还真是一箭双雕呢。
在这里插入图片描述

5.应用程序自由命名

现在我们的应用程序只能用hit这个名字,下面我们来让系统支持其他应用程序名，这次我们就用hello吧。 将console.c中的 “hlt” 改成“hello", 好啦, 这样我们就可以用hello这个应用程序 …··.!别生气别生气，开个玩笑而已(😆)。
好吧, 我们先来改写cons runcmd。

void cons_runcmd(char *cmdline, struct CONSOLE *cons, int *fat, unsigned int memtotal)
{
	if (strcmp(cmdline, "mem") == 0) {
		cmd_mem(cons, memtotal);
	} else if (strcmp(cmdline, "cls") == 0) {
		cmd_cls(cons);
	} else if (strcmp(cmdline, "dir") == 0) {
		cmd_dir(cons);
	} else if (strncmp(cmdline, "type ", 5) == 0) {
		cmd_type(cons, fat, cmdline);
	} else if (cmdline[0] != 0) {
		if (cmd_app(cons, fat, cmdline) == 0) {/*从此开始*/
			/*不是命令，不是应用程序，也不是空行*/
			putfonts8_asc_sht(cons->sht, 8, cons->cur_y, COL8_FFFFFF, COL8_000000, "Bad command.", 12);
			cons_newline(cons);
			cons_newline(cons);
		}
	}/*到此结束 */
	return;
}

总结一下修改的地方，首先是去掉了cmd_hlt, 并创建了新的cmd_app。
这个函数用来根据命令行的内容判断文件名,并运行相应的应用程序 ，如果找到文件则返回1，没有找到文件则返回0。 现在程序的工作过程是:当输入的命令不是me m、cls、dir、type其中之一时，则调用cmd_app, 如果返回0则作为错误处理。 这样应该能行。
我们在cmd_hlt的基础上稍作修改后得到cmd_app函数， 具体内容如下。

int cmd_app(struct CONSOLE *cons, int *fat, char *cmdline)
{
	struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
	struct FILEINFO *finfo;
	struct SEGMENT_DESCRIPTOR *gdt = (struct SEGMENT_DESCRIPTOR *) ADR_GDT;
	char name[18], *p;
	int i;

	/*根据命令行生成文件名*/
	for (i = 0; i < 13; i++) {
		if (cmdline[i] <= ' ') {
			break;
		}
		name[i] = cmdline[i];
	}
	name[i] = 0; /*暂且将文件名的后面置为0*/

	/* 寻找文件 */
	finfo = file_search(name, (struct FILEINFO *) (ADR_DISKIMG + 0x002600), 224);
	if (finfo == 0 && name[i - 1] != '.') {
		/*由于找不到文件，故在文件名后面加上“.hrb”后重新寻找*/
		name[i    ] = '.';
		name[i + 1] = 'H';
		name[i + 2] = 'R';
		name[i + 3] = 'B';
		name[i + 4] = 0;
		finfo = file_search(name, (struct FILEINFO *) (ADR_DISKIMG + 0x002600), 224);
	}

	if (finfo != 0) {
		/*找到文件的情况*/
		p = (char *) memman_alloc_4k(memman, finfo->size);
		file_loadfile(finfo->clustno, finfo->size, p, fat, (char *) (ADR_DISKIMG + 0x003e00));
		set_segmdesc(gdt + 1003, finfo->size - 1, (int) p, AR_CODE32_ER);
		farcall(0, 1003 * 8);
		memman_free_4k(memman, (int) p, finfo->size);
		cons_newline(cons);
		return 1;
	}
	/*没有找到文件的情况*/
	return 0;
}

我们在程序上动了一点脑筋，使得无论输入“hlt” 还是”“hlt.hrb” 都可以启动。因为在Windows命令行窗口中：不管加不加后面的 .exe都可以运行程序，所以我们就借鉴了这个设计。

差不多完工了，我们将hlt.nas改名为hello.nas, 然后汇编生成hello.hrb。 接下来 make run 用dir命令确认一下磁盘中的内容,再输入“hello”。 ha!出来了！成功了!
在这里插入图片描述

不错!我们再来输人“hlt”试一下,这个文件现在已经没有了, 会不会报错呢?另外, 嗯, 如果输入"hello.hrb” 能否正常运行呢?我们来试试看。
在这里插入图片描述

出现错误信息了, 加上扩展名的情况也可以，太完美了。

6.小心寄存器

hello.hrb的大小现在是21个字节，能不能再让它变小点呢?我们做了如下修改，用了一个循环。

[INSTRSET "i486p"]
[BITS 32]
		MOV		ECX,msg
putloop:
		MOV		AL,[CS:ECX]
		CMP		AL,0
		JE		fin
		INT		0x40
		ADD		ECX,1
		JMP		putloop
fin:
		RETF
msg:
		DB	"hello",0

改成这样后make一下，hello.hrb变成了26个字节，居然还大了5个字节，哎，好失望。不过， 这样改也有好处，即便以后要显示很长的字符符，程序也不会变得太大。
在这里插入图片描述

为啥只显示出一个呢? 再把hello.nas仔细检查一遍，也没发现什么不对劲的地方啊···
那问题肯定出在操作系统身上。 既然应用程序没问题, 不过，到底是哪里有问题呢？刚刚找到了点眉目，我们给_asm_cons_putchar添上2行代码，就是PUSHAD和POPAD。

_asm_cons_putchar:
		STI
		PUSHAD	; 这里!
		PUSH	1
		AND		EAX,0xff	; 
		PUSH	EAX
		PUSH	DWORD [0x0fec]	; 
		CALL	_cons_putchar
		ADD		ESP,12		; 
		POPAD	; 这里!
		IRETD

为什么要这么改我们待会儿再讲，先来试验一下。
在这里插入图片描述

果然是这个问题呀。 那为什么会想到加上PUSHAD和POPAD呢?因为推测这有可能是 INT 0x40之后ECX寄存器的值发生了变化所导致的，应该是_cons_putchar改动了ECX的值。因此，我们加上了PUSHAD和POPAD确保可以将全部寄存器的值还原，这样程序就能正常运行了。

7.用API显示字符串

能显示字符申的API远比只能显示单个字符的API要来的方便, 从实际的应用程序开发角度来说，因为一次显示一串字符的情况比一次只显示个字符的情况多得多。从其他操作系统的显示字符申的API来看，一般有两种方式:一种是显示一串字符，遇到字符编码0则结束；另一种是先指定好要显示的字串的长度再显示。我们到底要用哪一种呢？ 再三考虑之后，我们打算同时实现两种方式(笑)。

void cons_putstr0(struct CONSOLE *cons, char *s)
{
	for (; *s != 0; s++) {
		cons_putchar(cons, *s, 1);
	}
	return;
}

void cons_putstr1(struct CONSOLE *cons, char *s, int l)
{
	int i;
	for (i = 0; i < l; i++) {
		cons_putchar(cons, s[i], 1);
	}
	return;
}

哦，对了, 有了这个函数，就可以简化mem、 dir、type这几个命令的代码，趁着还没忘记, 赶紧改良一下。

void cons_runcmd(char *cmdline, struct CONSOLE *cons, int *fat, unsigned int memtotal)
{
	if (strcmp(cmdline, "mem") == 0) {
		cmd_mem(cons, memtotal);
	} else if (strcmp(cmdline, "cls") == 0) {
		cmd_cls(cons);
	} else if (strcmp(cmdline, "dir") == 0) {
		cmd_dir(cons);
	} else if (strncmp(cmdline, "type ", 5) == 0) {
		cmd_type(cons, fat, cmdline);
	} else if (cmdline[0] != 0) {
		if (cmd_app(cons, fat, cmdline) == 0) {
			/*不是命令，不是应用程序，也不是空行*/
			cons_putstr0(cons, "Bad command.\n\n");/* 这里 */
		}
	}
	return;
}

void cmd_mem(struct CONSOLE *cons, unsigned int memtotal)
{
	struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
	char s[60];/*从此开始*/
	sprintf(s, "total   %dMB\nfree %dKB\n\n", memtotal / (1024 * 1024), memman_total(memman) / 1024);
	cons_putstr0(cons, s);/*到此结束*/
	return;
}

void cmd_dir(struct CONSOLE *cons)
{
	struct FILEINFO *finfo = (struct FILEINFO *) (ADR_DISKIMG + 0x002600);
	int i, j;
	char s[30];
	for (i = 0; i < 224; i++) {
		if (finfo[i].name[0] == 0x00) {
			break;
		}
		if (finfo[i].name[0] != 0xe5) {
			if ((finfo[i].type & 0x18) == 0) {
				sprintf(s, "filename.ext   %7d\n", finfo[i].size);
				for (j = 0; j < 8; j++) {
					s[j] = finfo[i].name[j];
				}
				s[ 9] = finfo[i].ext[0];
				s[10] = finfo[i].ext[1];
				s[11] = finfo[i].ext[2];
				cons_putstr0(cons, s);/*这里!*/
			}
		}
	}
	cons_newline(cons);
	return;
}

void cmd_type(struct CONSOLE *cons, int *fat, char *cmdline)
{
	struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
	struct FILEINFO *finfo = file_search(cmdline + 5, (struct FILEINFO *) (ADR_DISKIMG + 0x002600), 224);
	char *p;
	if (finfo != 0) {
		p = (char *) memman_alloc_4k(memman, finfo->size);
		file_loadfile(finfo->clustno, finfo->size, p, fat, (char *) (ADR_DISKIMG + 0x003e00));
		cons_putstr1(cons, p, finfo->size);/*这里!*/
		memman_free_4k(memman, (int) p, finfo->size);
	} else {
		cons_putstr0(cons, "File not found.\n");/*这里!*/
	}
	cons_newline(cons);
	return;
}

代码缩减了12行，什么嘛!一开始就这样写不就好了吗?不过不管怎么说也算是个值得高兴 的事吧。
在上面字符串中我们使用了“\n” 这个新的符号, 这里来讲解一下。在C语言中, “\”这个 字符有特殊的含义，用来表示一些特殊字符。 这里出现的“\n” 代表换行符，即0x0a，也就是说用2个字符来表示1个字节的信息， 有点怪吧。此外还有 “\t”, 它代表制表符, 即0x09。顺便说一 下, 换行符“\n” 之所以用“n”，是因为它是“new line" 的缩写。

我们已经有了cons_putstr0 和 cons_putstr1，那么怎样把它们变成API呢？最简单的方法就是像显示单个字符的API那样, 分配INT0x41和INT0x42来调用这两个函数。 不过这样一来, 只能设置256个项目的IDT很快就会被用光。
既然如此，我们就借鉴BIOS的调用方式， 在寄存器中存人功能号, 使得只用1个INT就可以用来选择调用不同的函数。 在BIOS中, 存放功能号的寄存器一般是AH, 我们也可以照搬, 但这样最多只能设置256个API函数。而如果我们改用EDX来存放功能号, 就可以设置多达42亿个API函数。这样总不会不够用了吧。

功能号暂时按下面那样划分, 寄存器的用法也是随意设定的, 如果不喜欢的话尽管修改就好哦。

功能号1………….显示单个字符(AL=字符编码)
功能号2… 显示字符串0(EBX=字符串地址)
功能号3………显示字符串1(EBX=字符串地址，ECX=字符串长度)
接下来我们将_asm_cons_putchar改写成一个新的函数。

_asm_hrb_api:
		STI
		PUSHAD	; 用于保存寄存器值的PUSH
		PUSHAD	; 用于向hrb_api传值的PUSH
		CALL	_hrb_api
		ADD		ESP,32
		POPAD
		IRETD

这个函数非常短, 因为我们想尽量用C语言来编写API处理程序， 而且这样大家也更容易理解。
用C语言编写的API处理程序如下:

void hrb_api(int edi, int esi, int ebp, int esp, int ebx, int edx, int ecx, int eax)
{
	struct CONSOLE *cons = (struct CONSOLE *) *((int *) 0x0fec);
	if (edx == 1) {
		cons_putchar(cons, eax & 0xff, 1);
	} else if (edx == 2) {
		cons_putstr0(cons, (char *) ebx);
	} else if (edx == 3) {
		cons_putstr1(cons, (char *) ebx, ecx);
	}
	return;
}

嗯，还是挺好理解的吧。开头的寄存器顺序是按照PUSHAD的顺序写的,如果在_asm_hrb_api 中不用PUSHAD,而是个一个分别去PUSH的话，那当然可以按照自己喜欢的顺序来。
啊，对了对了，我们还得改一下IDT的设置，将INT 0x40改为调_asm_hrb_api。

void init_gdtidt(void)
{
	...
	set_gatedesc(idt + 0x20, (int) asm_inthandler20, 2 * 8, AR_INTGATE32);
	set_gatedesc(idt + 0x21, (int) asm_inthandler21, 2 * 8, AR_INTGATE32);
	set_gatedesc(idt + 0x27, (int) asm_inthandler27, 2 * 8, AR_INTGATE32);
	set_gatedesc(idt + 0x2c, (int) asm_inthandler2c, 2 * 8, AR_INTGATE32);
	set_gatedesc(idt + 0x40, (int) asm_hrb_api,      2 * 8, AR_INTGATE32);

	return;
}

这样改写之后, 现在的hello.nas就无法正常运行了, 因为我们需要往EDX里面存人1才能调用相应的API。虽说我们加上一条向EDX中存入1的指令就可以， 不过既然已经写好了cons_putstr0, 那就于脆用这个新的API写一个hello2.nas吧。

[INSTRSET "i486p"]
[BITS 32]
		MOV		EDX,2
		MOV		EBX,msg
		INT		0x40
		RETF
msg:
		DB	"hello",0

完工了, 好, 赶紧 运行 "hello2” 试试看。 make run
在这里插入图片描述

……貌似失败了，怎么回事昵？今天已经很累了， 脑子都不转了，我们还是明天再来找原因吧。总之，我们先将这个放在一边，在以前的hello.nas中加一条EDX= 1;试试看吧。

[INSTRSET "i486p"]
[BITS 32]
		MOV		ECX,msg
		MOV		EDX,1 ；这里！
putloop:
		MOV		AL,[CS:ECX]
		CMP		AL,0
		JE		fin
		INT		0x40
		ADD		ECX,1
		JMP		putloop
fin:
		RETF
msg:
		DB	"hello",0

在这里插入图片描述

成功了, 总算稍稍松了口气。 今天我们在最后的最后碰了个大钉子(就是hello2)，心情有点不爽， 不过已经困得不行了, 就先到这吧!大家明天见。

总结

今天我们在最后的最后碰了个大钉子(就是hello2)，心情有点不爽， 不过已经困得不行了, 就先到这吧!
祝大家元宵节快乐，团团圆圆，巳巳如意！
我们明天见！


http://www.kler.cn/a/546711.html

相关文章：

  • Java 实战：在图片指定位置贴二维码或条形码生成海报
  • Spring 框架数据库操作常见问题深度剖析与解决方案
  • 处理项目中存在多个版本的jsqlparser依赖
  • 【Python】如何在 Linux/Windows 系统中设置 PYTHONPATH 环境变量
  • Debian系发行版通用软件彻底卸载指南
  • 哈希：LeetCode49. 字母异位词分组 128.最长连续序列
  • 深度学习项目--基于RNN的阿尔茨海默病诊断研究(pytorch实现)
  • 【Elasticsearch】runtime_mappings搜索请求中定义运行时字段
  • 【MySQL】索引篇
  • 【深度学习模型分类】
  • Spring JDBC中SqlQuery的使用与实例解析
  • 牛客网-小美的加法（C++）
  • Go语言sync包使用指南
  • 机器学习 - 大数定律、可能近似正确学习理论
  • Next.js【详解】服务端组件 vs 客户端组件
  • 命令行更改Ouster OS1激光雷达静态IP
  • 家里装修想用投影仪，如何选择？装修中应该注意什么？
  • Box Loss：目标检测中精准框定的秘密武器
  • 常见的IP地址分配方式有几种：深入剖析与适用场景‌
  • Vue2/Vue3分别如何使用Watch