《30天自制操作系统》学习笔记（七）

已于 2024-01-18 17:44:22 修改
阅读量613 收藏 6
点赞数 9
文章标签： 学习 笔记
于 2024-01-18 15:08:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/katerdaisy/article/details/135674840
版权

先体验一下编译仿真方法：

30天自制操作系统光盘代码在下面链接，但是没有编译仿真工具：
https://gitee.com/zhanfei3000/30dayMakeOS

仿真工具在下面链接：
https://gitee.com/909854136/nask-code-ide

这是一个集成的编译仿真工具，只需要把上面仿真工具的文件夹：
\nask-code-ide-master\crtools
在这里插入图片描述
复制到源码文件加下，并改名为z_tools就可以按照书中的方法编译仿真了：
\30dayMakeOS-master\z_tools
z_tools如下：
在这里插入图片描述
在代码30dayMakeOS-master\01_day目录下执行下面编译仿真指令就可以看到仿真出的操作系统了。
在这里插入图片描述
在这里插入图片描述
后面章节源码写了 makefile就简单了，只要输入make就可以编辑了 然后再输入make run就可以仿真了

标题一、代码执行顺序（前内容六天的内容）

ipl10.nas–>asmhead.nas–>boopack.c

标题二、代码阅读

1.ipl10.nas（将软盘内容拷贝到内存中）

; haribote-ipl
; TAB=4
; 读取软盘内容到内存中，然后跳转到0xc200开始执行，就是asmhead.nas文件
CYLS	EQU		10				; CYLS=10 读取是10个柱面

		ORG		0x7c00			; 指明程序装载地址

; 以下这段是FAT12格式软盘专用代码  0x7c00--0x7dff 
		JMP        entry
        DB        0x90
        DB        "HARIBOTE"         ; 启动区的名字可以是任意的，但必须是8字节
        DW        512                ; 每个扇区(sector)的大小必须为512字节
        DB        1                  ; 簇(cluster)的大小必须为1个扇区
        DW        1                  ; FAT的起始位置(一般从第一个扇区开始)
        DB        2                  ; FAT的个数(必须为2)
        DW        224                ; 根目录的大小(一般设为244项)
        DW        2880               ; 该磁盘的的大小(必须为2880扇区)
        DB        0xf0               ; 磁盘的种类(必须为0xfd)
        DW        9                  ; FAT的长度(必须为9扇区)
        DW        18                 ; 一个磁道(track)有几个扇区(必须为18)
        DW        2                  ; 磁头数(必须为2)
        DD        0                  ; 不使用分区(必须为0)
        DD        2880               ; 重写一次磁盘大小
        DB        0,0,0x29           ; 意义不明，固定
        DD        0xffffffff         ; (可能是)卷标号码
        DB        "HARIBOTEOS "      ; 磁盘名称(11字节)
        DB        "FAT12   "         ; 磁盘格式名称(8字节)
        RESB    18                   ; 先腾出18字节

; 程序核心

entry:
		MOV		AX,0			; AX=0 初始化寄存器
		MOV		SS,AX			; SS=AX=0
		MOV		SP,0x7c00		; SP=0x7c00
		MOV		DS,AX			; DS=AX=0

; 读磁盘(从软盘中读数据装到内存中0x8200--0x83ff  

		MOV		AX,0x0820		; AX=0x0820 设置缓存区的段地址
		MOV		ES,AX			; ES=AX=0x0820 ES:BX就是缓存区的地址
		MOV		CH,0			; CH=0 CH表示柱面号
		MOV		DH,0			; DH=0 DH表示磁头号
		MOV		CL,2			; CL=2 CL表示扇区号
readloop:
		MOV		SI,0			; SI=0, 用于记录错误次数，实现试错功能（非必须功能）
retry:
		MOV		AH,0x02			; AH=0x02 13号中断所需参数，表示操作类型，0x02（读盘），0x03写盘，0x04校验，0x0c寻道
		MOV		AL,1			; AL=1 AL处理对象的扇区数，表示一次只能读取1个扇区
		MOV		BX,0			; BX=0 缓冲地址
		MOV		DL,0x00			; DL=0x00 DL表示驱动器号
		INT		0x13			; BIOS提供的服务，用于操作软盘
		JNC		next			; CF=0，跳转到next执行
		ADD		SI,1			; SI=SI+1，记录尝试的次数，实现试错功能（非必须功能）
		CMP		SI,5			; 
		JAE		error			; SI >= 5 跳转到error执行
		MOV		AH,0x00			; SI<5 AH=0x00 清空INT 0x13的错误码
		MOV		DL,0x00			; DL=0x00 设置驱动器号
		INT		0x13			; 
		JMP		retry			; 跳转到retry执行
next:
		MOV		AX,ES			; AX=ES
		ADD		AX,0x0020		; AX=AX+0x0020
		MOV		ES,AX			; ES=AX ES向后移动了一个扇区的大小
		ADD		CL,1			; CL=CL+1 扇区号加1
		CMP		CL,18			; 
		JBE		readloop		; CL <= 18 跳转到readloop执行
		MOV		CL,1			; CL > 18 CL=1 
		ADD		DH,1			; DH=1 准备读取磁头0的内容
		CMP		DH,2			; 
		JB		readloop		; DH < 2 跳转到readloop执行
		MOV		DH,0			; DH>=2 说明已读取完成
		ADD		CH,1			; CH=CH+1 准备读取下一个柱面
		CMP		CH,CYLS			; 
		JB		readloop		; CH < CYLS 跳转到readloop执行

; 磁盘内容装载内容的结束地址告诉haribote.sys

		MOV		[0x0ff0],CH		; [0x0ff0]=CH 将CYLS的值写入到内存地址0x0ff0中，可以参考asmhead.nas中对应的变量赋值
		JMP		0xc200			; 跳转到0xc200

error:
		MOV		SI,msg			;SI=msg 显示错误信息
putloop:
		MOV		AL,[SI]			; AL=[SI] 读取[SI]内存中的信息
		ADD		SI,1			; SI=SI+1
		CMP		AL,0			; 
		JE		fin				; AL==0, 错误信息显示完毕，跳转到fin
		MOV		AH,0x0e			; AH=0x0e 设置显示属性
		MOV		BX,15			; BX=15 设置显示属性
		INT		0x10			; 调用BIOS显示服务
		JMP		putloop			; 
fin:
		HLT						; 让CPU停止等待命令
		JMP		fin				; 
msg:
		DB		0x0a, 0x0a		; 
		DB		"load error"
		DB		0x0a			; 
		DB		0				; 

		RESB	0x7dfe-$		; 

		DB		0x55, 0xaa		; 按规定设置字节

2.asmhead.nas(完成一些不能用c语言实现的功能，因为编码问题，有一些乱码，大概能看明白)

; haribote-os boot asm
; TAB=4

[INSTRSET "i486p"]

VBEMODE	EQU		0x105			; 1024 x  768 x 8bit 彩色
; 显示模式
;	0x100 :  640 x  400 x 8bit 彩色
;	0x101 :  640 x  480 x 8bit 彩色
;	0x103 :  800 x  600 x 8bit 彩色
;	0x105 : 1024 x  768 x 8bit 彩色
;	0x107 : 1280 x 1024 x 8bit 彩色

BOTPAK	EQU		0x00280000		; 加载bootpack
DSKCAC	EQU		0x00100000		; 磁盘缓存的位置
DSKCAC0	EQU		0x00008000		; 磁盘缓存的位置（实模式）

; BOOT_INFO 相关
CYLS	EQU		0x0ff0			; 引导扇区设置
LEDS	EQU		0x0ff1
VMODE	EQU		0x0ff2			; 关于颜色的信息
SCRNX	EQU		0x0ff4			; 分辨率X
SCRNY	EQU		0x0ff6			; 分辨率Y
VRAM	EQU		0x0ff8			; 图像缓冲区的起始地址

		ORG		0xc200			;  这个的程序要被装载的内存地址

; 确认VBE是否存在

		MOV		AX,0x9000
		MOV		ES,AX
		MOV		DI,0
		MOV		AX,0x4f00
		INT		0x10
		CMP		AX,0x004f
		JNE		scrn320

; 检查VBE的版本

		MOV		AX,[ES:DI+4]
		CMP		AX,0x0200
		JB		scrn320			; if (AX < 0x0200) goto scrn320

; 取得画面模式信息

		MOV		CX,VBEMODE
		MOV		AX,0x4f01
		INT		0x10
		CMP		AX,0x004f
		JNE		scrn320

; 画面模式信息的确认
		CMP		BYTE [ES:DI+0x19],8		;颜色数必须为8
		JNE		scrn320
		CMP		BYTE [ES:DI+0x1b],4		;颜色的指定方法必须为4(4是调色板模式)
		JNE		scrn320
		MOV		AX,[ES:DI+0x00]				;模式属性bit7不是1就不能加上0x4000
		AND		AX,0x0080
		JZ		scrn320					; 模式属性的bit7是0，所以放弃

;	画面设置

		MOV		BX,VBEMODE+0x4000
		MOV		AX,0x4f02
		INT		0x10
		MOV		BYTE [VMODE],8	; 屏幕的模式（参考C语言的引用）
		MOV		AX,[ES:DI+0x12]
		MOV		[SCRNX],AX
		MOV		AX,[ES:DI+0x14]
		MOV		[SCRNY],AX
		MOV		EAX,[ES:DI+0x28] ;VRAM的地址
		MOV		[VRAM],EAX
		JMP		keystatus

scrn320:
		MOV		AL,0x13						; VGA图、320x200x8bit彩色
		MOV		AH,0x00
		INT		0x10
		MOV		BYTE [VMODE],8		; 记下画面模式（参考C语言）
		MOV		WORD [SCRNX],320
		MOV		WORD [SCRNY],200
		MOV		DWORD [VRAM],0x000a0000

;	通过 BIOS 获取指示灯状态

keystatus:
		MOV		AH,0x02
		INT		0x16 			; keyboard BIOS
		MOV		[LEDS],AL

;	PIC关闭一切中断
;	根据AT兼容机的规格，如果要初始化PIC，
;	必须在CLI之前进行，否则有时会挂起。
;	随后进行PIC的初始化。

		MOV		AL,0xff
		OUT		0x21,AL
		NOP						; 如果连续执行OUT指令，有些机种会无法正常运行
		OUT		0xa1,AL

		CLI						; 禁止CPU级别的中断

;	为了让CPU能够访问1MB以上的内存空间，设定A20GATE

		CALL	waitkbdout
		MOV		AL,0xd1
		OUT		0x64,AL
		CALL	waitkbdout
		MOV		AL,0xdf			; enable A20
		OUT		0x60,AL
		CALL	waitkbdout

;	切换到保护模式

[INSTRSET "i486p"]				; 说明使用486指令

		LGDT	[GDTR0]			; 设置临时GDT
		MOV		EAX,CR0
		AND		EAX,0x7fffffff	; 设bit31为0（禁用分页）
		OR		EAX,0x00000001	; bit0到1转换（保护模式过渡）
		MOV		CR0,EAX
		JMP		pipelineflush
pipelineflush:
		MOV		AX,1*8			;  可读写的段 32bit
		MOV		DS,AX
		MOV		ES,AX
		MOV		FS,AX
		MOV		GS,AX
		MOV		SS,AX

; bootpack传递

		MOV		ESI,bootpack	; 转送源
		MOV		EDI,BOTPAK		; 转送目标
		MOV		ECX,512*1024/4
		CALL	memcpy

; 磁盘数据最终转送到它本来的位置去
; 首先从启动扇区开始

		MOV		ESI,0x7c00		; 转送源
		MOV		EDI,DSKCAC		; 转送目标
		MOV		ECX,512/4
		CALL	memcpy

; 剩余的全部

		MOV		ESI,DSKCAC0+512	; 转送源
		MOV		EDI,DSKCAC+512	; 转送源目标
		MOV		ECX,0
		MOV		CL,BYTE [CYLS]
		IMUL	ECX,512*18*2/4	; 从柱面数变换为字节数/4
		SUB		ECX,512/4		; 减去 IPL 偏移量
		CALL	memcpy

; 必须由asmhead来完成的工作，至此全部完毕
; 以后就交由bootpack来完成

; bootpack启动

		MOV		EBX,BOTPAK
		MOV		ECX,[EBX+16]
		ADD		ECX,3			; ECX += 3;
		SHR		ECX,2			; ECX /= 4;
		JZ		skip			; 没有要转送的东西时
		MOV		ESI,[EBX+20]	; 转送源
		ADD		ESI,EBX
		MOV		EDI,[EBX+12]	; 转送目标
		CALL	memcpy
skip:
		MOV		ESP,[EBX+12]	; 堆栈的初始化
		JMP		DWORD 2*8:0x0000001b

waitkbdout:
		IN		 AL,0x64
		AND		 AL,0x02
		JNZ		waitkbdout	; AND的结果如果不是0，就跳到waitkbdout
		RET

memcpy:
		MOV		EAX,[ESI]
		ADD		ESI,4
		MOV		[EDI],EAX
		ADD		EDI,4
		SUB		ECX,1
		JNZ		memcpy			; 减法运算的结果如果不是0，就跳转到memcpy
		RET
; memcpy地址前缀大小

		ALIGNB	16
GDT0:
		RESB	8				; 初始值
		DW		0xffff,0x0000,0x9200,0x00cf	; 可以读写的段（segment）32bit
		DW		0xffff,0x0000,0x9a28,0x0047	; 可执行的文件的32bit寄存器（bootpack用）

		DW		0
GDTR0:
		DW		8*3-1
		DD		GDT0

		ALIGNB	16
bootpack:

3.bookpack.c(主函数文件，完成初始化等操作)

#include "bootpack.h"
#include <stdio.h>
 
//该结构体用于控制鼠标
struct MOUSE_DEC {
	unsigned char buf[3], phase;	
	int x, y, btn;		
};
 
extern struct FIFO8 keyfifo, mousefifo;	//外部变量，定义在fifo.c文件中
void enable_mouse(struct MOUSE_DEC *mdec);	//启动鼠标的函数
void init_keyboard(void);	//初始化键盘
int mouse_decode(struct MOUSE_DEC *mdec, unsigned char dat);	//处理鼠标信息
 
void HariMain(void)	//主函数
{
	struct BOOTINFO *binfo = (struct BOOTINFO *) ADR_BOOTINFO;	//启动信息数据结构
	char s[40], mcursor[256], keybuf[32], mousebuf[128];	
	int mx, my, i;
	struct MOUSE_DEC mdec;
 
	init_gdtidt();	//初始化gdt.idt
	init_pic();		//初始化pic
	io_sti(); 	//执行STI指令
	fifo8_init(&keyfifo, 32, keybuf);	//初始化键盘缓存区	
	fifo8_init(&mousefifo, 128, mousebuf);	//初始化鼠标缓存区
	io_out8(PIC0_IMR, 0xf9); //设置中断
	io_out8(PIC1_IMR, 0xef); //因为键盘中断是IRQ1，鼠标中断时IRQ12,所以需要打开主从电路上的对应管脚
 
	init_keyboard();	//初始化键盘
 
	init_palette();	//初始化调色板
	init_screen8(binfo->vram, binfo->scrnx, binfo->scrny);	//初始化屏幕，形成最初的窗口界面
	//获取画面中央的坐标
	mx = (binfo->scrnx - 16) / 2; 
	my = (binfo->scrny - 28 - 16) / 2;
	init_mouse_cursor8(mcursor, COL8_008484);	//鼠标光标的显示
	putblock8_8(binfo->vram, binfo->scrnx, 16, 16, mx, my, mcursor, 16);	
	sprintf(s, "(%3d, %3d)", mx, my);	//将鼠标位置转换成字符串
	putfonts8_asc(binfo->vram, binfo->scrnx, 0, 0, COL8_FFFFFF, s);	//显示字符串，这个函数的位置在哪里?
 
	enable_mouse(&mdec);	//启动鼠标
	for (;;) {	
		io_cli();	//关闭中断	
		//如果键盘缓冲区和鼠标缓冲区中都没有数据
		if (fifo8_status(&keyfifo) + fifo8_status(&mousefifo) == 0) {
			io_stihlt();	//打开中断并执行hlt命令
		} else {
			//如果键盘缓存区中有数据
			if (fifo8_status(&keyfifo) != 0) {
				i = fifo8_get(&keyfifo);	//从缓存区中读取数据(FIFO)
				sprintf(s, "%02X", i);	//将数据已字符串形式输出
				boxfill8(binfo->vram, binfo->scrnx, COL8_008484,  0, 16, 15, 31);
				putfonts8_asc(binfo->vram, binfo->scrnx, 0, 16, COL8_FFFFFF, s);	
			} else if (fifo8_status(&mousefifo) != 0) {	//如果鼠标缓存区中有函数(鼠标和键盘的数据是怎么存入到对应缓存区的?)
				i = fifo8_get(&mousefifo);		//从缓存区中读取数据
				io_sti();	//打开中断
				if (mouse_decode(&mdec, i) != 0) {	//对鼠标信息进行处理
					sprintf(s, "[lcr %4d %4d]", mdec.x, mdec.y);	
					if ((mdec.btn & 0x01) != 0) {	
						s[1] = 'L';
					}
					if ((mdec.btn & 0x02) != 0) {
						s[3] = 'R';
					}
					if ((mdec.btn & 0x04) != 0) {
						s[2] = 'C';
					}
					boxfill8(binfo->vram, binfo->scrnx, COL8_008484, 32, 16, 32 + 15 * 8 - 1, 31);
					putfonts8_asc(binfo->vram, binfo->scrnx, 32, 16, COL8_FFFFFF, s);
					boxfill8(binfo->vram, binfo->scrnx, COL8_008484, mx, my, mx + 15, my + 15); 
					mx += mdec.x;
					my += mdec.y;
					if (mx < 0) {
						mx = 0;
					}
					if (my < 0) {
						my = 0;
					}
					if (mx > binfo->scrnx - 16) {
						mx = binfo->scrnx - 16;
					}
					if (my > binfo->scrny - 16) {
						my = binfo->scrny - 16;
					}
					sprintf(s, "(%3d, %3d)", mx, my);
					boxfill8(binfo->vram, binfo->scrnx, COL8_008484, 0, 0, 79, 15);
					putfonts8_asc(binfo->vram, binfo->scrnx, 0, 0, COL8_FFFFFF, s);
					putblock8_8(binfo->vram, binfo->scrnx, 16, 16, mx, my, mcursor, 16); 
				}
			}
		}
	}
}
 
#define PORT_KEYDAT				0x0060
#define PORT_KEYSTA				0x0064
#define PORT_KEYCMD				0x0064
#define KEYSTA_SEND_NOTREADY	0x02
#define KEYCMD_WRITE_MODE		0x60
#define KBC_MODE				0x47
 
//功能:等待键盘控制电路准备完毕
//如果键盘控制电路可以接受CPU指令，CPU从设备号码0x0064处所读取的数据倒数第二位应该是0，否则就是一直循环等待
void wait_KBC_sendready(void)
{
	for (;;) {
		if ((io_in8(PORT_KEYSTA) & KEYSTA_SEND_NOTREADY) == 0) {	//判断第二位的情况
			break;
		}
	}
	return;
}
 
//功能:初始化键盘
void init_keyboard(void)
{
	wait_KBC_sendready();	
	io_out8(PORT_KEYCMD, KEYCMD_WRITE_MODE);
	wait_KBC_sendready();	
	io_out8(PORT_KEYDAT, KBC_MODE);	
	return;
}
 
#define KEYCMD_SENDTO_MOUSE		0xd4
#define MOUSECMD_ENABLE			0xf4
 
//功能:启用鼠标
void enable_mouse(struct MOUSE_DEC *mdec)
{
	wait_KBC_sendready();	
	io_out8(PORT_KEYCMD, KEYCMD_SENDTO_MOUSE);	
	wait_KBC_sendready();
	io_out8(PORT_KEYDAT, MOUSECMD_ENABLE);
	mdec->phase = 0;
	return;
}
 
//处理鼠标信息
int mouse_decode(struct MOUSE_DEC *mdec, unsigned char dat)
{
	if (mdec->phase == 0) {
		if (dat == 0xfa) {
			mdec->phase = 1;
		}
		return 0;
	}
	if (mdec->phase == 1) {
		if ((dat & 0xc8) == 0x08) {
			mdec->buf[0] = dat;
			mdec->phase = 2;
		}
		return 0;
	}
	if (mdec->phase == 2) {
		mdec->buf[1] = dat;
		mdec->phase = 3;
		return 0;
	}
	if (mdec->phase == 3) {
		mdec->buf[2] = dat;
		mdec->phase = 1;	 
		mdec->btn = mdec->buf[0] & 0x07;
		mdec->x = mdec->buf[1];
		mdec->y = mdec->buf[2];
		if ((mdec->buf[0] & 0x10) != 0) {
			mdec->x |= 0xffffff00;
		}
		if ((mdec->buf[0] & 0x20) != 0) {
			mdec->y |= 0xffffff00;
		}
		mdec->y = - mdec->y;
		return 1;
	}
	return -1; 
}

4.dsctbl.c（gdt和idt设置）

#include "bootpack.h"
//初始化gdt和idt
void init_gdtidt(void)
{
	struct SEGMENT_DESCRIPTOR *gdt = (struct SEGMENT_DESCRIPTOR *) ADR_GDT;	//提前设置好的GDT在内存中的地址
	struct GATE_DESCRIPTOR    *idt = (struct GATE_DESCRIPTOR    *) ADR_IDT;	//提前设置好的IDT在内存中的地址
	int i;
 
	for (i = 0; i <= LIMIT_GDT / 8; i++) {	//对所有的全局描述符进行初始化
		set_segmdesc(gdt + i, 0, 0, 0);	//先将所有的全局描述符设置为0
	}
	set_segmdesc(gdt + 1, 0xffffffff,   0x00000000, AR_DATA32_RW);	//设置第1号描述符，段基址为0，大小4gb，可读写32位段
	set_segmdesc(gdt + 2, LIMIT_BOTPAK, ADR_BOTPAK, AR_CODE32_ER);	//设置第2号描述符，段基址0x00280000，大小0x0007ffff，属性0x4092
	load_gdtr(LIMIT_GDT, ADR_GDT);	//载入gdtr到cpu中
 
	for (i = 0; i <= LIMIT_IDT / 8; i++) {	//对所有的idt描述符进行初始化
		set_gatedesc(idt + i, 0, 0, 0);	//先将所有的idt描述符设为0
	}
	load_idtr(LIMIT_IDT, ADR_IDT);	//载入idtr到cpu中
 
	set_gatedesc(idt + 0x21, (int) asm_inthandler21, 2 * 8, AR_INTGATE32);	//对idt描述符赋值，注意第二个变量，是偏移量
	set_gatedesc(idt + 0x27, (int) asm_inthandler27, 2 * 8, AR_INTGATE32);
	set_gatedesc(idt + 0x2c, (int) asm_inthandler2c, 2 * 8, AR_INTGATE32);
 
	return;
}
 
//功能:对段描述符赋值
//参数:段描述符地址，长度、基址、属性值
void set_segmdesc(struct SEGMENT_DESCRIPTOR *sd, unsigned int limit, int base, int ar)
{
	//判断段描述大小的计数单位
	if (limit > 0xfffff) {	//如果段界限超过了限制1MB
		ar |= 0x8000; /* G_bit = 1 */	//将G位设置为1，即大小以Kb为单位
		limit /= 0x1000;	//换算成KB
	}
	sd->limit_low    = limit & 0xffff;	//从低16位开始设置，即段界限的低16位
	sd->base_low     = base & 0xffff;	//接着设置16-31的16位数据，即基地址的低16位
	sd->base_mid     = (base >> 16) & 0xff;	//设置32-39的8位数据，即基地址的中间8位，将base右移16位，然后做与运算，取出中间8位
	sd->access_right = ar & 0xff;	//设置40-47位，即ar的第八位
	sd->limit_high   = ((limit >> 16) & 0x0f) | ((ar >> 8) & 0xf0);	//设置49-56位，limit_high比较特殊，其中四位是段界限，4位是段属性值
	sd->base_high    = (base >> 24) & 0xff;	//设置57-63位，即段基址的高8位
	return;
}
 
//功能:设置门描述符
//参数:门描述符地址，偏移、段选择符，属性值
void set_gatedesc(struct GATE_DESCRIPTOR *gd, int offset, int selector, int ar)
{
	gd->offset_low   = offset & 0xffff;	//设置0-15位，偏移地址的低16位
	gd->selector     = selector;	//设置16-31位，制度段选择子
	gd->dw_count     = (ar >> 8) & 0xff;	//设置32-39位，基本上全是0
	gd->access_right = ar & 0xff;	//设置40-47位，门描述符属性
	gd->offset_high  = (offset >> 16) & 0xffff;	//设置48-63Wie，偏移地址的高16位
	return;
}

5.graphic.c

//用于处理屏幕显示
 
#include "bootpack.h"
 
//初始化调色板
void init_palette(void)
{
	static unsigned char table_rgb[16 * 3] = {	//设置调色板变量,这里3个字符一组，组成了一个颜色，颜色应该是计算机中已经设定好的
		0x00, 0x00, 0x00,	
		0xff, 0x00, 0x00,	
		0x00, 0xff, 0x00,	
		0xff, 0xff, 0x00,	
		0x00, 0x00, 0xff,	
		0xff, 0x00, 0xff,	
		0x00, 0xff, 0xff,	
		0xff, 0xff, 0xff,	
		0xc6, 0xc6, 0xc6,	
		0x84, 0x00, 0x00,	
		0x00, 0x84, 0x00,	
		0x84, 0x84, 0x00,	
		0x00, 0x00, 0x84,	
		0x84, 0x00, 0x84,	
		0x00, 0x84, 0x84,	
		0x84, 0x84, 0x84	
	};
	set_palette(0, 15, table_rgb);	//设置调色板
	return;
 
}
 
//功能:设置调色板，将颜色和编号对上
void set_palette(int start, int end, unsigned char *rgb)
{
	int i, eflags;
	eflags = io_load_eflags();	//汇编语言函数
	io_cli(); //关闭中断					
	io_out8(0x03c8, start);	//写入端口
	for (i = start; i <= end; i++) {	//每三个一组合成一个rgb颜色
		io_out8(0x03c9, rgb[0] / 4);
		io_out8(0x03c9, rgb[1] / 4);
		io_out8(0x03c9, rgb[2] / 4);
		rgb += 3;
	}
	io_store_eflags(eflags);	//汇编语言函数
	return;
}
 
//功能:画一个窗口
//其中xsize表示窗口宽度，理论上应该等于x1-x0
void boxfill8(unsigned char *vram, int xsize, unsigned char c, int x0, int y0, int x1, int y1)
{
	int x, y;
	for (y = y0; y <= y1; y++) {
		for (x = x0; x <= x1; x++)
			vram[y * xsize + x] = c;	//显示出字符
	}
	return;
}
 
//初始化屏幕
void init_screen8(char *vram, int x, int y)
{
	boxfill8(vram, x, COL8_008484,  0,     0,      x -  1, y - 29);
	boxfill8(vram, x, COL8_C6C6C6,  0,     y - 28, x -  1, y - 28);
	boxfill8(vram, x, COL8_FFFFFF,  0,     y - 27, x -  1, y - 27);
	boxfill8(vram, x, COL8_C6C6C6,  0,     y - 26, x -  1, y -  1);
 
	boxfill8(vram, x, COL8_FFFFFF,  3,     y - 24, 59,     y - 24);
	boxfill8(vram, x, COL8_FFFFFF,  2,     y - 24,  2,     y -  4);
	boxfill8(vram, x, COL8_848484,  3,     y -  4, 59,     y -  4);
	boxfill8(vram, x, COL8_848484, 59,     y - 23, 59,     y -  5);
	boxfill8(vram, x, COL8_000000,  2,     y -  3, 59,     y -  3);
	boxfill8(vram, x, COL8_000000, 60,     y - 24, 60,     y -  3);
 
	boxfill8(vram, x, COL8_848484, x - 47, y - 24, x -  4, y - 24);
	boxfill8(vram, x, COL8_848484, x - 47, y - 23, x - 47, y -  4);
	boxfill8(vram, x, COL8_FFFFFF, x - 47, y -  3, x -  4, y -  3);
	boxfill8(vram, x, COL8_FFFFFF, x -  3, y - 24, x -  3, y -  3);
	return;
}
 
//显示字体
void putfont8(char *vram, int xsize, int x, int y, char c, char *font)
{
	int i;
	char *p, d /* data */;
	for (i = 0; i < 16; i++) {
		p = vram + (y + i) * xsize + x;	//显示版面的一行，此处应明白屏幕显示原理
		d = font[i];	//显示字体，按位显示
		if ((d & 0x80) != 0) { p[0] = c; }
		if ((d & 0x40) != 0) { p[1] = c; }
		if ((d & 0x20) != 0) { p[2] = c; }
		if ((d & 0x10) != 0) { p[3] = c; }
		if ((d & 0x08) != 0) { p[4] = c; }
		if ((d & 0x04) != 0) { p[5] = c; }
		if ((d & 0x02) != 0) { p[6] = c; }
		if ((d & 0x01) != 0) { p[7] = c; }
	}
	return;
}
 
void putfonts8_asc(char *vram, int xsize, int x, int y, char c, unsigned char *s)
{
	extern char hankaku[4096];
	for (; *s != 0x00; s++) {
		putfont8(vram, xsize, x, y, c, hankaku + *s * 16);
		x += 8;
	}
	return;
}
 
void init_mouse_cursor8(char *mouse, char bc)
{
	static char cursor[16][16] = {
		"**************..",
		"*OOOOOOOOOOO*...",
		"*OOOOOOOOOO*....",
		"*OOOOOOOOO*.....",
		"*OOOOOOOO*......",
		"*OOOOOOO*.......",
		"*OOOOOOO*.......",
		"*OOOOOOOO*......",
		"*OOOO**OOO*.....",
		"*OOO*..*OOO*....",
		"*OO*....*OOO*...",
		"*O*......*OOO*..",
		"**........*OOO*.",
		"*..........*OOO*",
		"............*OO*",
		".............***"
	};
	int x, y;
 
	for (y = 0; y < 16; y++) {
		for (x = 0; x < 16; x++) {
			if (cursor[y][x] == '*') {
				mouse[y * 16 + x] = COL8_000000;	//显示鼠标
			}
			if (cursor[y][x] == 'O') {
				mouse[y * 16 + x] = COL8_FFFFFF;
			}
			if (cursor[y][x] == '.') {
				mouse[y * 16 + x] = bc;
			}
		}
	}
	return;
}
 
//功能:显示背景
//vram和vxsize是关于vram的信息
//pxsize,pysize是想要显示的图形大小
//px0、py0制定图像在画面上的显示位置
//buf指定图形存放的地址
//bxsize指定每一行含有的像素数
void putblock8_8(char *vram, int vxsize, int pxsize,
	int pysize, int px0, int py0, char *buf, int bxsize)
{
	int x, y;
	for (y = 0; y < pysize; y++) {
		for (x = 0; x < pxsize; x++) {
			vram[(py0 + y) * vxsize + (px0 + x)] = buf[y * bxsize + x];
		}
	}
	return;
}

6.fifo.c

#include "bootpack.h"
 
#define FLAGS_OVERRUN		0x0001
 
//功能:初始化FIFO缓存区
//参数:缓存区结构体，大小，缓存区地址
void fifo8_init(struct FIFO8 *fifo, int size, unsigned char *buf)
{
	fifo->size = size;
	fifo->buf = buf;
	fifo->free = size; 
	fifo->flags = 0;
	fifo->p = 0; 
	fifo->q = 0;
	return;
}
 
//功能:向缓存区写入数据
int fifo8_put(struct FIFO8 *fifo, unsigned char data)
{
	if (fifo->free == 0) {	//如果缓存区大小等于零，代表缓存区已经被写满
		fifo->flags |= FLAGS_OVERRUN;	//将覆盖标志置1
		return -1;	//返回一个错误值
	}
	fifo->buf[fifo->p] = data;	//读取当前缓存区的第一个数据
	fifo->p++;	//将读取指针后移
	if (fifo->p == fifo->size) {	//如果已经读完缓存区
		fifo->p = 0;	//将读取指针指向第一个位置
	}
	fifo->free--;	//缓存区可用位置减1
	return 0;
}
 
//功能:从缓存区读取数据
int fifo8_get(struct FIFO8 *fifo)
{
	int data;
	if (fifo->free == fifo->size) {	//如果缓存区是空的，返回错误
		return -1;
	}
	data = fifo->buf[fifo->q];	//读取数据
	fifo->q++;	//读取指针后移
	if (fifo->q == fifo->size) {	//读到最后一个将读取指针指向第一个位置
		fifo->q = 0;
	}
	fifo->free++;	//可用区域加1 缓存区是循环写入的
	return data;
}
 
int fifo8_status(struct FIFO8 *fifo)	//判断缓存区的状态
{
	return fifo->size - fifo->free;
}

7. int.c

#include "bootpack.h"
#include <stdio.h>
 
//功能:中断初始化函数，初始化pic
void init_pic(void)
{
	io_out8(PIC0_IMR,  0xff  );	//主片禁止所有中断
	io_out8(PIC1_IMR,  0xff  ); //从片禁止所有中断
	//设置pic0，主片
	io_out8(PIC0_ICW1, 0x11  ); //边沿触发模式
	io_out8(PIC0_ICW2, 0x20  ); //IRQ0-7由INT20-27接收
	io_out8(PIC0_ICW3, 1 << 2); //PIC1由IRQ2接收
	io_out8(PIC0_ICW4, 0x01  );	//无缓冲区模式
	//设置pic1，从片
	io_out8(PIC1_ICW1, 0x11  );	//边沿触发模式
	io_out8(PIC1_ICW2, 0x28  );	//IRQ8-15由INT28-2f接收
	io_out8(PIC1_ICW3, 2     ); //PIC1由IRQ2连接
	io_out8(PIC1_ICW4, 0x01  );	//无缓冲区模式
 
	io_out8(PIC0_IMR,  0xfb  ); //11111011，PIC1以外的全部禁止
	io_out8(PIC1_IMR,  0xff  ); //11111111，禁止PIC1的所有中断
 
	return;
}
 
#define PORT_KEYDAT		0x0060
 
struct FIFO8 keyfifo;
//键盘中断处理，键盘是IRQ1,所以编写INT 0x21
//这里已经有了C语言编写的函数，为什么还要添加汇编语言的函数?
//是在汇编语言中调用该函数
void inthandler21(int *esp)
{
	unsigned char data;
	io_out8(PIC0_OCW2, 0x61);	
	data = io_in8(PORT_KEYDAT);	//读取数据
	fifo8_put(&keyfifo, data);	//将数据写入缓存区
	return;
}
 
struct FIFO8 mousefifo;
//功能:鼠标中断处理，编写INT 0x2c
void inthandler2c(int *esp)
{
	unsigned char data;
	io_out8(PIC1_OCW2, 0x64);	
	io_out8(PIC0_OCW2, 0x62);	
	data = io_in8(PORT_KEYDAT);	//读取数据
	fifo8_put(&mousefifo, data);	//将数据写入缓存区
	return;
}
 
void inthandler27(int *esp)								*/
{
	io_out8(PIC0_OCW2, 0x67); 
	return;
}

8. naskfunc.nas（汇编和c语言文件之间的桥梁）

; naskfunc
; TAB=4

[FORMAT "WCOFF"]				;
[INSTRSET "i486p"]				;
[BITS 32]						;
[FILE "naskfunc.nas"]			;
;定义外部符号，可以从文件外进行调用
		GLOBAL	_io_hlt, _io_cli, _io_sti, _io_stihlt
		GLOBAL	_io_in8,  _io_in16,  _io_in32
		GLOBAL	_io_out8, _io_out16, _io_out32
		GLOBAL	_io_load_eflags, _io_store_eflags
		GLOBAL	_load_gdtr, _load_idtr
		GLOBAL	_asm_inthandler21, _asm_inthandler27, _asm_inthandler2c
		EXTERN	_inthandler21, _inthandler27, _inthandler2c

[SECTION .text]

_io_hlt:	; void io_hlt(void);
		HLT
		RET

_io_cli:	; void io_cli(void);
		CLI
		RET

_io_sti:	; void io_sti(void);
		STI
		RET

_io_stihlt:	; void io_stihlt(void);
		STI
		HLT
		RET

_io_in8:	; int io_in8(int port); 从指定端口中读取数据
		MOV		EDX,[ESP+4]		; port，获取端口号
		MOV		EAX,0	;清空ax寄存器
		IN		AL,DX	;从DX指定的端口中读取数据到al
		RET

_io_in16:	; int io_in16(int port);
		MOV		EDX,[ESP+4]		; port
		MOV		EAX,0
		IN		AX,DX
		RET

_io_in32:	; int io_in32(int port);
		MOV		EDX,[ESP+4]		; port
		IN		EAX,DX
		RET

_io_out8:	; void io_out8(int port, int data);	向指定端口写入数据
		MOV		EDX,[ESP+4]		; port	获取端口号
		MOV		AL,[ESP+8]		; data	获取要写入的数据
		OUT		DX,AL	;将al中的数据写入到dx指定的端口中
		RET

_io_out16:	; void io_out16(int port, int data);
		MOV		EDX,[ESP+4]		; port
		MOV		EAX,[ESP+8]		; data
		OUT		DX,AX
		RET

_io_out32:	; void io_out32(int port, int data);
		MOV		EDX,[ESP+4]		; port
		MOV		EAX,[ESP+8]		; data
		OUT		DX,EAX
		RET

_io_load_eflags:	; int io_load_eflags(void);
		PUSHFD		; 将eflags寄存器压入栈中，入栈顺序是EAX,ECX,EDX,EBX,ESP,EBP,ESI,EDI
		POP		EAX	; 将edi的值弹出到eax中
		RET

_io_store_eflags:	; void io_store_eflags(int eflags);
		MOV		EAX,[ESP+4]
		PUSH	EAX
		POPFD		; 将栈中的寄存器值弹出到eflags寄存器中
		RET

_load_gdtr:		; void load_gdtr(int limit, int addr);加载GDTR	
		MOV		AX,[ESP+4]		; limit
		MOV		[ESP+6],AX
		LGDT	[ESP+6]
		RET

_load_idtr:		; void load_idtr(int limit, int addr); 记载IDTR,原理与加载GDTR相同
		MOV		AX,[ESP+4]		; limit
		MOV		[ESP+6],AX
		LIDT	[ESP+6]
		RET

;这个函数只是将寄存器的值保存在栈里，然后将DS和ES调整到与SS相等，再调用_inthandler21,返回后将所有寄存器的值再返回到原来的值，然后执行IRETD
;之所以如此小心翼翼地保护寄存器，原因在于，中断处理发生在函数处理途中，通过IREDT从中断处理后，寄存器就乱了
_asm_inthandler21:
		PUSH	ES
		PUSH	DS
		PUSHAD	;PUSHAD指令压入32位寄存器，其入栈顺序是:EAX,ECX,EDX,EBX,ESP,EBP,ESI,EDI .
		MOV		EAX,ESP	;eax=esp
		PUSH	EAX	压入eax的值，即esp
		MOV		AX,SS	
		MOV		DS,AX	;ds=ss
		MOV		ES,AX	;es=ss
		CALL	_inthandler21	;调用inthandler21函数，c语言编写
		POP		EAX	;弹出esp的值到eax中
		POPAD
		POP		DS	
		POP		ES
		IRETD

_asm_inthandler27:
		PUSH	ES
		PUSH	DS
		PUSHAD
		MOV		EAX,ESP
		PUSH	EAX
		MOV		AX,SS
		MOV		DS,AX
		MOV		ES,AX
		CALL	_inthandler27
		POP		EAX
		POPAD
		POP		DS
		POP		ES
		IRETD

_asm_inthandler2c:
		PUSH	ES
		PUSH	DS
		PUSHAD
		MOV		EAX,ESP
		PUSH	EAX
		MOV		AX,SS
		MOV		DS,AX
		MOV		ES,AX
		CALL	_inthandler2c
		POP		EAX
		POPAD
		POP		DS
		POP		ES
		IRETD

标题三、其它

根据书中的描述，整个项目的编译过程如图
在这里插入图片描述

最后，asmhead文件和bookpack文件会编译到一起，bookpack的内容就是从bootpack标号开始？

关于中断处理程序的调用

如果要让一个中断处理程序发挥作用，首先要将其注册到idt中，书中使用了函数set_gatedesc(idt+0x21,(int)asm_inthandler21,2*8,AR_INTGATE32)2

即将_asm_inthandler21注册为idt的第21号，如果发生中断了，cpu就会自动调用asm_inthandler21

2表示asm_inthandler属于那一个段，因低3位必须是0，所以写成2*8
（ps：一定要读源码）
————————————————
版权声明：本文为CSDN博主「qq_35041101」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_35041101/article/details/51866877

盼望孤独的二进制
关注
  • 9
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
《30天自制操作系统》学习笔记_day03
zhangkai9895的博客
03-31 398
前言：第三天的难度还是蛮大的，看了一上午理解了大概，还是好好记录，捋顺一下。 1.实现Ipl的程序装载 首先实现用ipl指示将程序（软盘内容，操作系统）装载到内存特定位置 在03_day的harrib00a中的ipl.nas添加内容的部分 可以看到用到了 BIOS INT 0x13中断，0x13号中断主要用来磁盘的读写，AH=0x02说明用来读盘。 具体软盘的结构可以查询学习。 AH=处理对象的...
《30天自制操作系统》学习笔记——第十四天
文行知的专栏
02-27 1268
来开始第14 天的内容吧。                                                                          今天一上来就要提高分辨率了，真是激动人心呀，提高之前：                                提高之后：                                   是不是一
30天操作系统光盘内容
05-19
30天制作操作系统光盘内容，内容完整、代码清晰、适合初学者
30天自制操作系统光盘_计算机自制操作系统：总序
weixin_39757122的博客
11-18 699
一、不忘初心电子计算机---是20世纪人类最伟大的发明之一。本人机械专业出身，但是最热爱的专业是电子，如果有机会再让我选择一次，我会毫不犹豫的选择读EE。由于缺乏电子行业所需的实验环境和实践机会，后来慢慢就把注意力转移到了计算机，因为只需要一台电脑就可大显身手了。没有机会当程序员，多年以来一直在自学，业余写点小代码，但却有一颗非要将问题弄懂的纠结心。记得90年代末上大学的时候刚开始接触计算机，对计...
30天自制操作系统光盘_8-bit Windows 八位机视窗操作系统（四）：科王/邦谷Wins98...
weixin_39806288的博客
11-25 344
1998年底到1999年年初，看到裕兴电脑VCD大卖的新天利和科王等厂商也加入了电脑VCD的战场之中，新天利以整合世嘉16位MD游戏脱颖而出，科王则是推出了融合“邦谷小PC”以及“步步高磁盘操作系统”的超级电脑VCD KW-SC2000机型。这款机型正面看就是一台普通的VCD：然而在机身的右侧，却拥有AT键盘接口、两个15针游戏手柄接口、标准的鼠标串口、以及3.5英寸软驱，机身背面还有一个标准24...
30天自制操作系统
Dreamapple的专栏
05-02 554
void set_palette(unsigned char *rgb){ int i, eflags; eflags = io_load_eflags(); io_cli(); io_out8(0x03c8, 0); for (i = 0; i <= 15; i++) { io_out8(0x03c9, rgb[0] / 4); io_out8(0x03c9, rgb[1] / 4); io_o
【操作系统】30天自制操作系统--(1)虚拟机加载最小操作系统
sinat_33408502的博客
04-07 2750
最近学习了川合秀石的《30天自制操作系统》，准备跟着书里面的介绍自己做一做，这边开个新帖用作记录。 自制操作系统首先要搭建环境，书中是用软盘作为系统的启动盘，现在哪里找软盘去，只能先用VMware虚拟机，虚出一个带软盘处理的环境进行测试。 一 准备工作 【1】《30天自制操作系统》的光盘资料：30天自制操作系统的光盘资源-其它文档类资源-CSDN下载 【2】VMware（版本不限，我这边用的是15的版本） 二 用VMware虚拟机搭建环境 【1】下载安装VMw...
《30 天自制操作系统》读书笔记.zip
10-16
《30天自制操作系统》是一本旨在引导读者亲手构建操作系统的学习指南。这本书通过实践的方式，帮助读者深入理解操作系统的原理和实现过程，从而提升对计算机系统本质的认知。 在阅读这本书的过程中，你可能会接触到...
《30天自制操作系统》学习笔记——第十五天
文行知的专栏
02-28 2527
十五天的内容开始啦！         本书的进度大概已经到一半，今天要开始讲一个非常重要同时也挺难的东西，那就是多任务！                                                              多任务我们都很清楚，但一步步实现多任务的过程实在不容易，请跟紧思路哦！        首先，我们考虑电脑是如何完成多任务这样的功能呢？对了，就是
30天自制操作系统学习笔记----day_five
lzh
10-31 849
一、实验主要内容 1.接受启动信息： 关键代码：      重点内容： （1）通过指针来获得显示画面模式，这样可以避免当画面模式改变时系统无法正常运行的问题。 2.试用结构体： 关键代码： 重点内容： 如何理解结构体：struct后面是结构体的名字同时也是这个结构体的首地址，结构体可以理解为一个文件柜，各个变量可以看做接口，需要使用的时候接上这个接口即可，通过结构体对...
《30天自制操作系统》学习笔记_day01
zhangkai9895的博客
03-30 260
《30天自制操作系统》学习笔记_day01 1.二进制编辑器查看操作系统源代码并编写 博主未采用书中推荐二进制编辑器，而是使用Notepad++和HexEditor插件。 参考：新版Notepad++加十六进制查看的插件HexEditor 000000：HELLOIPL启动区的名称可以是任意的字符串（8字节） 启动区： 软盘的第一个扇区为启动区，计算机读取软盘512个字节为一个扇区单位。软盘大小...
30天自制操作系统-startHaribote
zkj126521的博客
08-12 760
0.准备 书中这里将显示代码分到Haribote.nas。org 0xc400载入内存中。 对于每一个nasm生成的bin文件而言都是从0x0000000开始的，也就是说我们可以把bin文件载入到u盘的任意扇区，从上一个博客我们将30697的扇区载入到内存地址为0x8200中，所以我们把haribote.bin文件放到u盘的30698扇区，内存地址从0x8400开始，所以首先将haribote...
30天自制操作系统(day1)
最新发布
m0_61722509的博客
11-08 1812
30天自制操作系统第一天内容
30天自制操作系统——第一天到第二天
lanyi_ly的博客
10-17 1936
第一天 光盘地址用的这个：30天自制操作系统光盘 - 夕雨714 - 博客园 (cnblogs.com) Bz162下载地址：Bz - c.mos (vcraft.jp) 启动方式：D:\文档\学习科目\计算机基础\操作系统\操作系统实验\30dayMakeOS\1_day\tolset\helloos0 目录下打开!cons_nt.bat cmd中输入run 2C 逗号，20 空格，0A 换行 OS made by BUPT LanYi 4F 53 20 6D 61 64 65 20 62 79 2
30天自制操作系统——第二天
qq_43696276的博客
09-10 549
今天是该系列的第二天，继续昨天的开发，今天的任务主要有以下几项： 1、进一步的加工一下汇编程序（去除昨天的二进制代码） 2、对启动区进行制作 3、利用makefile简化bat文件数量
《30天自制操作系统》第1天
混沌的博客
12-21 4634
1.下载一个二进制编辑器(网上很多下载，google一下即可，也叫十六进制编辑器),他能直接对二进制数进行编辑。如果你对（某种处理器的）机器码非常熟悉的话，理论上可以用二进制编辑器完成（此处理器上的）任何软件的制作，小至一个计算器，大至一个编译器，操作系统(因为所有软件本质上都是CPU的机器指令和一些数据组成)。但是不同类型CPU的机器码是不一样的。当然，实际上用一个二进制编辑器编写一个windo
《30天自制操作系统》第6天
混沌的博客
01-06 1529
1.PIC 可编程中断控制器 PIC 连接8个中断信号，监视输入管脚的8个中断信号。主PIC：IRQ0-IRQ7（IRQ2连接到从PIC：IRQ8-IRQ15）。 中断发生后，CPU命令PIC发送2个字节的数据，格式是：0xcd  0xXX，CPU收到2个字节后把数据当做指令来执行。0xCd 就是INT的机器码，cd  10 就是INT 0x10，于是执行了中断程序。 2.每次访问内存时，将
《30天自制操作系统》从入门到放弃
热门推荐
wxkhturfun的博客
09-12 1万+
30天自制操作系统 01day 1.0写在前面的话 关于01day~03day，可以完全参考下述链接（下述内容部分也是来源此链接）： https://www.cnblogs.com/yucloud/category/1472969.html 1.1手打img 在下面这条链接中下载填制编辑软件 https://www.jb51.net/softs/601421.html#downintro2 （其实我不并推荐这种编辑器，使用vscode即可：https://www.cnblogs.com/baby123/p/
30天自制操作系统——第0天
qq_43696276的博客
08-18 1536
由于，最近一直在学以及使用了linux操作系统。我对于操作系统的底层运行，对于linux的内核产生了极其浓厚的兴趣。因此，产生了想要自写一个小操作系统来加深对于操作系统内核的理解。话不多说，从今天开始！！！在正式开始前，我们首先需要学会c与汇编（至少知道基础语法结构啥的），因为后续基本上是要使用到c与汇编为基础的代码的！！！！...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值