拼一个自己的操作系统 SnailOS 0.03的实现

拼一个自己的操作系统SnailOS0.03源代码-Linux文档类资源-CSDN下载

操作系统SnailOS学习拼一个自己的操作系统-Linux文档类资源-CSDN下载

SnailOS0.00-SnailOS0.00-其它文档类资源-CSDN下载

读取fat32文件系统的文件。

在真正的讲fat32文件系统读取文件的内容前，让我们先把几个bmp文件复制到我们的虚拟硬盘上。并且创建了hello.txt的文本文件。

看到了吧，都是大美女吧！继续写下去是不是好有兴致。

时至今日，fat32文件系统已经被ntfs、ext?等其他文件系统甩了多少条街都说不好了。但有一点确定的是最近还有很多U盘用的是该文件系统。其实，仔细想来也没有什么特殊的原因，主要就是该文件系统还是非常好用的。但我们选择fat32文件系统的唯一目的就是它相对来说还是比较简单的。也就是能用比较少的代码就完成我们的目标。其实，我们的目标更是简单和直接，就是读取文件内容，然后做一些简单的操作，比如我们可以输出文本文件的内容，我们可以在屏幕上显示图片等等。

现在的问题就转化为，如何用上一章的硬盘驱动程序，把某个lba28扇区的内容读取到内存中供我们使用这么简单了。网上关于fat32文件系统的文章可以用多如牛毛来形容，其详解每个都有独到之处，所以笔者根本就不想拷贝那些信息在这里班门弄斧。我们的思路是通过二进制文件查看器，从目录项检索开始，逐步高清，该如何读取文件内容。首先让我们用UE打开temp.vhd的硬盘镜像文件。然后我们来一波骚操作，逐步摸清fat32的底数。下面的图中我们看到了一片16进制的数据（中间），左边是该数据对应的16进制地址，右边是数据对应的ascii码值。这是硬盘的开头，粗估一下应该是主引导扇区。因此我们要找到一个存在于512字节的标记也就是0xaa55，这样就比较确定了。那么我们往下看看哪个纯蓝色的部分正好是我们要找的地方。可是我们的目的可不是看这个让人迷糊的引导扇区，我是要找到我们的文件内容所在的扇区。因此按照fat32文件系统的安排，我们知道文件的目录项中含有该内容，同时目录项中也还有文件名称。干脆我们在此处搜索文件名看看能不能一眼就找到目录项，从而访问到文件内容。

说干就干，在下图大家看到了吧，一眼熟呀，可不是一个文件名我们熟悉，上一节我们拷贝的文件都在这里排队呢？这不是天上直接就掉下个林妹妹吗。同时看到下图我们用纯蓝色圈出的部分，在目录项中它是文件开始的簇号低16位，也就是0x30df，而往前4个字节处的0x0000处是簇号的高16位。而我们要的是文件的起始扇区，计算方法就是网上查到的

起始扇区= 根目录起始扇区 + （起始簇号 - 2）* 8

而我们现在缺少的是根目录起始扇区数。仔细一想这个并不难啊，我们稍微往前看看不就是根目录的起始扇区了吗。也就是说，我们的根目录根部没有几个文件吗。

看下面的图，不出所料的话，这就是根目录开始的位置。而这里是字节数，我们要转化为扇区数才能算计算出来了。用0x303000除以512就应该是扇区数吧。让我们来掰着手指头算一下好了。这个结果是0x1818，现在套入那个公式，0x1818 + (0x30df - 2) * 8 = 0x1f900;

接下来就是要查找文件了。看下图一打眼，是不是文件内容。我搜索的是Snail OS!...因此不是在文件开头，文件开头是一堆空格了。看看左边的地址，0x33e0000，这个是字节的，所以要除以512得出我们文件的起始扇区数。正是前面推算出的0x1f900这个数。至此查找一个简单txt文件的就大功告成了。

不过那个根目录起始扇区数可是我们手工蒙出来的，也就是说只可意授不可言传。这样可不行呀。

我们这里也就不兜圈子了，按照fat32的规定，根目录起始扇区在两个fat表之后，而两个fat表的起始扇区是通过bpb起始扇区加上bpb后的保留扇区数的到的。而这些信息除了bpb的起始扇区在mbr中获得外，其他的都在bpb中。因此我们现在要返回到mbr中得到bpb起始扇区数。然后通过bpb得到根目录起始扇区。bpb起始扇区在mbr分区表结构中的lba_start中，分区表在mbr第446字节处，也就是0x1be处，也就是lba_start在mbr的0x1c7处。

观察mbr的下图，纯蓝色的部分就是bpb起始扇区数，为0x800，乘以512（0x200）转化成字节数就是0x100000(1M)处。

看到下图大家就明白了吧，这么简单就找到了bpb，而我们所需要的所有信息都在这里了。对了这是通过转到地址0x100000处得到的。接下来大家就没什么疑问了吧，通过访问bpb中的关键数据，我们就能一步一步的最终访问文件内容了。

下面我们就给出完整的代码，相信大家学了这么久，对这些代码不会有什么问题了。

【fs.h】

// fs.h 作者：至强 创建时间：2022年12月

#ifndef __FS_H

#define __FS_H

struct partition_table_item {

unsigned char flags, head_start, sec_start, chs_start;

unsigned char fs_type, head_end, sec_end, chs_end;

unsigned int lba_start, sec_cnt;

}__attribute__((packed));

struct boot_sector {

unsigned char code_area[446];

struct partition_table_item parts[4];

unsigned short magic;

}__attribute__((packed));

struct bios_parameter_block {

unsigned char bpb_head[11];

unsigned short bytes_per_sector;

unsigned char sectors_per_cluster;

unsigned short reserved_sector;

unsigned char number_of_fat;

unsigned short root_entries;

unsigned short small_sector;

unsigned char media_descriptor;

unsigned short sectors_per_fat_16;

unsigned short sectors_per_track;

unsigned short number_of_head;

unsigned int hidden_sector;

unsigned int large_sector;

unsigned int sectors_per_fat_32;

unsigned short extended_flag;

unsigned short file_system_version;

unsigned int root_cluster_number;

unsigned short file_system_information_sector_number;

unsigned short backup_boot_sector;

unsigned char reserved[12];

unsigned char physical_drive_number;

unsigned char reserved_byte;

unsigned char extended_boot_signature;

unsigned int volume_serial_number;

unsigned char volume_label[11];

unsigned char system_id[8];

}__attribute__((packed));

struct dir_item {

char name[8], ext[3], attrib, empty, ticks;

unsigned short create_time, create_date, access_date;

unsigned short clust_no_h, modify_time, modify_date;

unsigned short clust_no_l;

unsigned int filesize;

};

struct fat32_krn_p {

int* fat1_p;

struct dir_item* root_dir_p;

unsigned int root_dir_start_sector;

};

void read_mbr_dbr(struct fat32_krn_p* fat32_p);

char* format_filename(const char* filename);

int find_file(struct fat32_krn_p* fat32_p, const char* filename);

void* file_read(const char* filename);

void hd_read_clust(struct fat32_krn_p* fat32_p, unsigned int start,

int mem_start);

#endif

【fs.c】

// fs.c 作者：至强 创建时间：2022年12月

#include "fs.h"

#include "memory.h"

#include "hd.h"

#include "string.h"

struct fat32_krn_p fat32_krn;

extern struct disk hds[2];

void read_mbr_dbr(struct fat32_krn_p* fat32_p) {

/*

为主引导扇区mbr分配内存，由于mbr仅有512字节，这里剩余的空间

实际是可以留作他用的。

*/

struct boot_sector* mbr = get_kernel_pages(1);

/*

用硬盘驱动把主引导扇区读入分配的内存中。

*/

hd_read_sub(&hds[0], 0, (void*)mbr, 1);

unsigned int dbr_lba_start;

/*

文件系统类型是fat32则bioa参数块的lba28模式其实扇区为主引导

扇区分区信息的lba_start成员。

*/

if(mbr->parts[0].fs_type == 0x0b) {

dbr_lba_start = mbr->parts[0].lba_start;

} else {

return;

}

/*

由于前面的mbr只使用的512字节，所以这里使用了接下来的512字节

作为bpb的内存地址，同样根据bpb在硬盘上的起始扇区，读取512字节

到内存中。

*/

struct bios_parameter_block* bpb = (struct bios_parameter_block* )

((unsigned int)mbr + 512);

hd_read_sub(&hds[0], dbr_lba_start, (void*)bpb, 1);

/*

得到fat32文件系统的几个重要信息，这个是每扇区的字节数，

这个数字估计是512。

*/

unsigned short bytes_per_sector = bpb->bytes_per_sector;

// printf_("^%x^", bytes_per_sector);

/*

这个是每簇扇区数，估计数值是8。也就是4096字节。

*/

unsigned char sectors_per_cluster = bpb->sectors_per_cluster;

// printf_("^%x^", sectors_per_cluster);

/*

bpb的保留扇区数，用于求解下面的fat表1的起始扇区。

*/

unsigned short reserved_sector = bpb->reserved_sector;

// printf_("^%x^", reserved_sector);

/*

这个是bpb的fat表的个数。此处的值应该是2。

*/

unsigned char number_of_fat = bpb->number_of_fat;

// printf_("^%x^", number_of_fat);

/*

每个fat表所占的扇区数。

*/

unsigned int sectors_per_fat_32 = bpb->sectors_per_fat_32;

// printf_("@%x@", sectors_per_fat_32);

/*

顺利地得到了fat表的起始扇区数。

*/

unsigned int fat_start_sector = dbr_lba_start +

reserved_sector;

// printf_("^%x^", fat_start_sector);

/*

我们的目标就在这里了，它将得到根目录的起始扇区数，也就是

fat表1的起始扇区数加上两个fat表的长度。

*/

unsigned int root_dir_start_sector = fat_start_sector +

sectors_per_fat_32 * number_of_fat;

// printf_("^%x^", root_dir_start_sector);

/*

根据fat表1的起始扇区数已经表的长度，将fat表1读入到内存中待用，

这个表将占用较大的内存。

*/

unsigned int* fat1_mem_start =

get_kernel_pages(up_pgs(sectors_per_fat_32 * bytes_per_sector));

hd_read_sub(&hds[0], fat_start_sector, (void*)fat1_mem_start,

sectors_per_fat_32);

// printf_("^%x^", fat1_mem_start);

/*

对于根目录我们这里仅仅读取了一页的内容，估计这样的情况对于我们

现在的系统也是足够用了。

*/

unsigned int* root_mem_start = get_kernel_pages(1);

hd_read_sub(&hds[0], root_dir_start_sector, (void*)root_mem_start, 8);

/*

将信息保存在全局结构中待用。

*/

fat32_p->fat1_p = (int*) fat1_mem_start;

fat32_p->root_dir_p = (struct dir_item*) root_mem_start;

fat32_p->root_dir_start_sector = root_dir_start_sector;

}

/*

这是简单的格式化fat32目录项中段格式文件名的函数，也就是尽量

正确的判断我们给出的文件名的正确性，然后存储到静态字符数组中

待用。这个函数肯定存在一些特殊的情况不能处理，因此，大家在根目录

中存储文件时，应该按照8+3的标准格式存储，否则就会有风险^_^。

*/

char* format_filename(const char* filename) {

int i = 0, j, k;

static char result[12];

char space = 0x20;

result[11] = 0;

if(strlen_(filename) > 11) {

return NULL;

}

for(j = 0; j < 11 && filename[j]; j++){

if(filename[j] == '.') {

i = 1;

}

}

if(i == 0) {

if(strlen_(filename) > 8) {

return NULL;

}

for(j = 0; j < 8 && filename[j]; j++) {

result[j] = filename[j] & 0xdf;

}

for(; j < 8 + 3; j++) {

result[j] = space;

}

return result;

} else {

if(filename[0] == '.') {

result[0] = '.';

if(filename[1] == '.') {

result[1] = '.';

for(j = 2; j < 8 + 3; j++) {

result[j] = space;

}

return result;

}

for(j = 1; j < 8 + 3; j++) {

result[j] = space;

}

return result;

}

}

for(j = 0; j < 8 && filename[j]; j++) {

result[j] = filename[j] & 0xdf;

if(filename[j] == '.') {

k = j + 1;

break;

}

}

for(; j < 8 + 3; j++) {

result[j] = space;

}

if(k < 11) {

for(j = 0; j < 3; j++) {

(result + 8)[j] = filename[k++] & 0xdf;

}

}

return result;

}

/*

整合上面的文件，从而在目录相中找到正确的文件。

*/

int find_file(struct fat32_krn_p* fat32_p, const char* filename) {

struct dir_item* root_dir_start = fat32_p->root_dir_p;

unsigned int file_start_clust;

unsigned int filesize;

unsigned int root_dir_start_sector = fat32_p->root_dir_start_sector;

char file[12] = {0};

strcpy_(file, format_filename(filename));

int k = 0;

int j;

/*

这个就是遍历目录项从而找到我们想要的文件。

*/

while((root_dir_start[k].name[0] != 0)) {

if(root_dir_start[k].name[0] == 0xe5) {

k++;

continue;

}

char f1 = 1, f2 = 1;

for(j = 0; j < 8; j++) {

if(root_dir_start[k].name[j] != file[j]) {

f1 = 0;

}

}

for(j = 0; j < 3; j++) {

if(root_dir_start[k].ext[j] != (file + 8)[j]) {

f2 = 0;

}

}

if(f1 && f2) {

file_start_clust = ((unsigned int)root_dir_start[k].clust_no_h <<

16)+ (unsigned int)root_dir_start[k].clust_no_l;

filesize = root_dir_start[k].filesize;

// printf_("*** %s %d %d %x %x ***", file, k + 1,

// filesize, file_start_clust, root_dir_start_sector);

return k;

} else {

// printf_("\n not found %s 第%d个文件", file, k + 1);

}

k++;

}

return -1;

}

/*

按簇来读取文件内容。每个簇有8个扇区，因此循环就是8次。

*/

void hd_read_clust(struct fat32_krn_p* fat32_p, unsigned int start, int mem_start) {

int i;

unsigned int data_start = fat32_p->root_dir_start_sector;

for(i = 0; i < 8; i++) {

/*

起始扇区的计算公式一个难以理解的东西，它是用根目录的起始扇区数

加上（起始簇数减去二）* 8来得到的，这个玩意简直太烧脑了，反正笔者也

不想弄明白了，只要记住公式就好了。

*/

hd_read_sub(&hds[0], data_start + (start - 2) * 8 + i,

(void*)mem_start + i * 512, 1);

}

}

/*

进一步整合就可以按文件名称读取相应的文件了。

*/

void* file_read(const char* filename) {

struct fat32_krn_p* fat32_p = &fat32_krn;

int index = find_file(fat32_p, filename);

if(index == -1) {

return NULL;

}

struct dir_item* root_dir_start = fat32_p->root_dir_p;

unsigned int* fat1_p = fat32_p->fat1_p;

unsigned int start_clust;

unsigned int filesize;

filesize = root_dir_start[index].filesize;

unsigned int root_dir_start_sector = fat32_p->root_dir_start_sector;

char* filep = get_kernel_pages(up_pgs(filesize));

char* fp = filep;

/*

起始簇数在根目录项中分两部分存储，因此要拼接出来。

*/

start_clust = ((unsigned int)root_dir_start[index].clust_no_h <<

16)+ (unsigned int)root_dir_start[index].clust_no_l;

/*

如果文件仅占用一个簇就够用了。我们就读取该簇就可以了。

*/

while(start_clust != 0x0fffffff) {

if(filesize <= 4096) {

hd_read_clust(fat32_p, start_clust, (int)filep);

return fp;

}

/*

如果文件大于一个簇则也要先把第一个簇的内容读入内存。

*/

hd_read_clust(fat32_p, start_clust, (int)filep);

filep += 4096;

filesize -= 4096;

/*

下一个簇的算法又是一个烧脑的玩意，居然在fat表中用上一个簇

下标得到的，笔者对于为什么会是这样也是不想弄懂了，只要记住公式

就好。

*/

start_clust = fat1_p[start_clust];

// printf_(" %x ", start_clust);

// printf_("|");

}

/*

到此便可返回得到文件内容的内存地址。

*/

return fp;

}

笔者在实验的过程中，发现仅仅使用二元信号量，对于一个资源多个线程共享的情况会很别扭，所以增加了一个多值信号量的操作。下面是它的代码。

【 semaphore.h】

// semaphore.h 作者：至强 创建时间：2022年12月

#ifndef _SEMAPHORE_H

#define _SEMAPHORE_H

/*

这是多值信号量的实现，通过多值信号量可以控制同一资源的多次

访问。也就是一种其他的同步关系。

*/

struct event {

void* msgptr;

int count;

unsigned int type;

struct double_linked_list waiters;

};

void event_init(struct event* event_, void* msg, int cnt, int type);

void event_array_init(struct event* event_array_);

struct event* get_event(struct event* event_array_);

void sema_pend(struct event* pevent);

void sema_post(struct event* pevent);

#endif

【 semaphore.c】

// semaphore.c 作者：至强 创建时间：2022年12月

#include "global.h"

#include "intr.h"

#include "thread.h"

#include "semaphore.h"

#include "memory.h"

struct event event_array[256];

struct event* pevent_;

/*

我们这里是按照事件来定义信号量结构的，所以这里是初始化事件。

*/

void event_init(struct event* event_, void* msg, int cnt, int type) {

unsigned int old_status = intr_disable();

event_->msgptr = msg;

event_->count = cnt;

event_->type = type;

double_linked_list_init(&event_->waiters);

set_intr_status(old_status);

}

/*

初始化最多256个信号量。

*/

void event_array_init(struct event* event_array_) {

int i;

for(i = 0; i < 256; i++) {

event_init(&event_array_[i], NULL, 0, -1);

}

}

/*

它实际上是获得一个信号量。

*/

struct event* get_event(struct event* event_array_) {

int i;

unsigned int old_status = intr_disable();

for(i = 0; i < 256; i++) {

if(event_array[i].type == -1) {

break;

}

}

set_intr_status(old_status);

return &event_array_[i];

}

/*

用于等待信号量，也就是说当信号量的值为0时，说明期待的事件

并未发生，这是线程需要阻塞自己，并进入等待队列。直到事件发生

后，完成事件的线程通过累加信号量唤醒线程。

*/

void sema_pend(struct event* pevent) {

struct task* cur;

unsigned int old_status = intr_disable();

if(pevent->count == 0) {

cur = running_thread();

double_linked_list_append(&pevent->waiters, &cur->general_tag);

cur->status = WAITING;

schedule();

set_intr_status(old_status);

} else {

pevent->count--;

set_intr_status(old_status);

}

}

/*

当一个事件完成后，完成该事件的线程会发送1个或者若干个信号，

（仅仅是对信号量的值进行累加）来唤醒在信号量的等待队列中

阻塞的线程。

*/

void sema_post(struct event* pevent) {

struct list_node* waiter;

unsigned int old_status = intr_disable();

if(!double_linked_list_is_empty(&pevent->waiters)) {

waiter = double_linked_list_pop(&pevent->waiters);

struct task* next = node2entry(struct task, general_tag, waiter);

thread_ready_list = &ready_list[next->level];

double_linked_list_append(thread_ready_list, waiter);

set_intr_status(old_status);

} else {

pevent->count++;

set_intr_status(old_status);

}

}

【kernel.c】

// kernel.c 创建者：至强 创建时间：2022年8月

#include "global.h"

#include "x.h"

#include "string.h"

#include "gdt_idt_init.h"

#include "memory.h"

#include "intr.h"

#include "debug.h"

#include "thread.h"

#include "ring_queue.h"

#include "screen.h"

#include "queue.h"

#include "mouse.h"

#include "timer.h"

#include "sheet.h"

#include "tss.h"

#include "process.h"

#include "syscall.h"

#include "hd.h"

#include "fs.h"

#include "semaphore.h"

unsigned long long limit;

void create_clock(int x, int y);

struct queue ins_queue;

void k_thread_a(void* arg);

void k_thread_b(void* arg);

void k_thread_c(void* arg);

void idle(void* arg);

void ua(void);

void ub(void);

void uc(void);

void instructions_switch(struct buf* e);

unsigned int mouse_bin[16 * 16];

unsigned int mouse_before[16 * 16];

extern void test();

extern unsigned int zzz;

struct fat32_krn_p fat32_krn;

struct semaphore fs_sema;

extern struct event event_array[256];

extern struct event* pevent_;

unsigned int* desktop;

void kernel_main(unsigned int magic, unsigned int addr) {

multiboot2_magic = magic;

multiboot2_addr = addr;

pos = 0;

int i, j;

// unsigned int* video = get_video_addr(magic, addr);

unsigned int* video = (unsigned int*)0xe0000000;

screen_init();

info_area_cls();

/*

fill_rectangle(video, 1024, 50, 50, 40, 40, 0x00ff0000);

fill_circle(video, 1024, 200, 200, 80, 0x00ffff00);

draw_line(video, 1024, 0, 0, 1023, 767, 0x00ffffff);

draw_circle(video, 1024, 200, 200, 100, 0x0000ffff);

draw_box(video, 1024, 40, 40, 20, 100, 0x0000ff00);

struct point a, b, c;

a.x = 300;

a.y = 300;

b.x = 200;

b.y = 400;

c.x = 500;

c.y = 450;

draw_triangle(video, 1024, &a, &b, &c, 0x000000ff);

a.x = 600;

a.y = 300;

b.x = 500;

b.y = 400;

c.x = 800;

c.y = 450;

fill_triangle(video, 1024, &a, &b, &c, 0x00bcbcbc);

char pic[16][16] =

{

{'*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*'},

{'*','*','*','*','*','*','*','*','#','*','*','*','*','*','*','*'},

{'*','*','*','*','*','*','*','*','#','*','*','*','*','*','*','*'},

{'*','*','*','*','*','*','*','*','#','*','*','*','*','*','*','*'},

{'*','*','#','#','#','#','#','#','#','#','#','#','#','#','#','*'},

{'*','*','#','*','*','*','*','*','#','*','*','*','*','*','#','*'},

{'*','*','#','*','*','*','*','*','#','*','*','*','*','*','#','*'},

{'*','*','#','*','*','*','*','*','#','*','*','*','*','*','#','*'},

{'*','*','#','*','*','*','*','*','#','*','*','*','*','*','#','*'},

{'*','*','#','#','#','#','#','#','#','#','#','#','#','#','#','*'},

{'*','*','#','*','*','*','*','*','#','*','*','*','*','*','#','*'},

{'*','*','*','*','*','*','*','*','#','*','*','*','*','*','*','*'},

{'*','*','*','*','*','*','*','*','#','*','*','*','*','*','*','*'},

{'*','*','*','*','*','*','*','*','#','*','*','*','*','*','*','*'},

{'*','*','*','*','*','*','*','*','#','*','*','*','*','*','*','*'},

{'*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*'},

};

unsigned int pic_data[16][16];

for(j = 0; j < 16; j++) {

for(i = 0; i < 16; i++) {

if(pic[j][i] == '#') {

pic_data[j][i] = 0x000000ff;

}

if(pic[j][i] == '*') {

pic_data[j][i] = 0x0000ff00;

}

}

}

for(j = 0; j < 16; j++) {

for(i = 0; i < 16; i++) {

draw_point(video + 1024 * (128 + 16 + 16),

1024, i + 512, j, pic_data[j][i]);

}

}

char font_A[16] = {

0x00, 0x18, 0x18, 0x18, 0x18, 0x24, 0x24, 0x24,

0x24, 0x7e, 0x42, 0x42, 0x42, 0xe7, 0x00, 0x00

};

extern char font_A_;

make_ascii(video + 1024 * 128, 1024, 0, 0, 0x000000ff, (char*)&font_A_);

make_ascii(video + 1024 * (128 + 16), 1024, 0, 0, 0x0000ff00, font_A);

printf_("%s %d %x %b", "I love you SnailOS...!", 0x8, 8, 8);

*/

init();

sema_init(&fs_sema, 0);

event_array_init(event_array);

pevent_ = get_event(event_array);

event_init(pevent_, NULL, 0, 0);

/*

extern struct tss tss, tss1;

第1任务（主函数）的任务状态段只需要初始化页目录表，这

主要可能是因为处理器在保存进程的上文时不更新cr3。如果

不返回到主任务，甚至不用对它的任务状态段进行任何处理，

当然也可以没有。

// tss.eip = 0;

// tss.ss = tss.ds = tss.es = 0;

// tss.esp = 0;

tss.cr3 = 0x8000;

// tss.eflags = 0;

// tss.ss0 = 0;

// tss.esp0 = 0;

// tss.cs = 0;

// tss.ldt = 0;

*/

/*

简单的初始化第2个任务的任务状态段。

*/

/*

tss1.eip = (unsigned int)_0x70_handler;

tss1.ss = tss1.ds = tss1.es = 5 * 8 + 3;

tss1.esp = 0xa000;

tss1.cr3 = 0x8000;

tss1.eflags = 0x202;

tss1.ss0 = 2 * 8;

tss1.esp0 = 0x8000;

tss1.cs = 4 * 8 + 3;

tss1.ldt = 0;

// asm volatile ("jmp $6 * 8, $10000");

// asm volatile ("call $6 * 8, $0xabcd");

// asm volatile ("jmp $7 * 8, $10000");

// asm volatile ("call $7 * 8, $0xabcd");

// asm volatile ("cli;int $0x70");

asm volatile("pushl $5 * 8 + 3;\

pushl $5 * 8 + 3;\

pushfl;\

movl $0x202, (%esp);\

popfl;\

movl $6 * 8 , %eax;\

ltr %ax;\

popl %es;\

popl %ds;\

pushl $5 * 8 + 3;\

pushl $0xa000;\

pushfl;\

pushl $4 * 8 + 3;\

pushl $__0x70_handler;\

iret");

printf_("\n@@@task sucessful return!!!!!!");

while(1);

*/

// printf_("%x %x\n", pde_ptr(0x2000000), pte_ptr(0x2000000));

// 虚拟地址的页目录表项写入物理地址0x2000000 + 0x07，也就

// 是页表的首地址在0x2000000处。

// *((unsigned int*)pde_ptr(0x2000000)) = 0x2000000 + 0x07;

// 页表项的物理地址也写入0x2000000 + 0x07，也就是最终该

// 虚拟地址映射到物理地址一样的地方。

// *((unsigned int*)pte_ptr(0x2000000)) = 0x2000000 + 0x07;

// *((unsigned int*)pte_ptr(0x2000000)) = 0x2001000 + 0x07;

// 由于该地址已经映射了实际的物理内存，所以访问时不会出现

// 任何问题。需要注意的是，由于这里是页表第一项（从0开始）

// 是映射关系，所以如果把第一项也清零了，也会出现宕机的情况。

// 所以我们从第二项开始清零。

// for(i = 1; i < 1024; i++) {

// ((unsigned int*)0x2000000)[i] = 0;

// }

/*

当第一项清零的情况下，如果不加入此句是不会宕机的。是不是

非常的奇怪。这是因为只有执行了下面一句，处理器才按照内存

中实际的页表建立映射关系。不要忘了处理器还有自己的缓存。

下面的汇编语句是不是觉得有些怪怪的，是啊，他是AT&T的格式

格式的非扩展的嵌入式汇编语句，主要是函数调用得到形式要

切换到汇编文件中。注意了大伙， AT&T格式的汇编，源操作数和

目标操作数的顺序是相反的。

*/

// asm("mov %cr3, %eax;mov %eax, %cr3");

// printf_("\n%x %x\n", ((unsigned int*)0x2000000)[0],

// ((unsigned int*)0x2000000)[1]);

// i /= 0;

// asm("ud2");

// asm volatile ("movl $0xffffffff, %ebx;\

movl $0x0, %edx;\

movl $0xffffffff, %eax;\

mul %ebx;");

// asm volatile ("into");

// asm("int3");

// limit = 0xaaaa00000000;

// asm volatile("movl $0xaaaa, %eax;bound %eax, (_limit)");

// printf_("\n @@@@@@ NEW START! @@@@@@\n");

// asm volatile("movl $0xaaab, %eax;bound %eax, (_limit)");

/*

向主从芯片的数据端口写入数据，0xfb的二进制形式是11111011b，

也就是通过将第2位（从0计算）复位（清零），使向量0x22能够接收

中断，从而开启从芯片的所有中断。0xfe的二进制形式是11111110b，

正是从芯片的0x28向量对应的中断，该中断便是实时时钟中断。

*/

// out(0x21, 0xfb);

// out(0xa1, 0xfe);

struct bmp_buf_info bbi;

save_bmp((char*)&zzz, &bbi);

unsigned int* v = (unsigned int*)(0xe0000000 + 1024 * 128 * 4);

put_bmp_buf(v, 1024, 20, 20, &bbi);

/*

将表盘在这里描画。从而成为桌面图层的一部分。

*/

dial(930, 90);

/*

下面是鼠标位置坐标和鼠标控制结构。并对位置坐标进行了初始化。

*/

int mx = 200, my = 300;

struct mouse_dec mdec;

/*

把鼠标的缓冲区用我们预制的图形写好，以备图层管理函数使用。

*/

make_mouse_pointer(mouse_bin, 0x003098df);

// make_mouse_before(mouse_before, 0x003098df);

/*

在原始的没有图层的桌面上写了一串文字。

*/

put_gb2312_buf(video, 1024, 480, 400 - 16, 0x00d9d919,

"蜗牛");

put_gb2312_buf(video, 1024, 400, 400, 0x00d9d919,

"该不该搁下重重的壳");

put_gb2312_buf(video, 1024, 400, 416, 0x00d9d919,

"寻找到底哪里有蓝天");

put_gb2312_buf(video, 1024, 400, 432, 0x00d9d919,

"随着轻轻的风轻轻的飘");

put_gb2312_buf(video, 1024, 400, 448, 0x00d9d919,

"历经的伤都不感觉疼");

put_gb2312_buf(video, 1024, 400, 464, 0x00d9d919,

"我要一步一步往上爬");

put_gb2312_buf(video, 1024, 400, 480, 0x00d9d919,

"等待阳光静静看着它的脸");

put_gb2312_buf(video, 1024, 400, 496, 0x00d9d919,

"小小的天有大大的梦想");

put_gb2312_buf(video, 1024, 400, 512, 0x00d9d919,

"重重的壳裹着轻轻的仰望");

put_gb2312_buf(video, 1024, 400, 528, 0x00d9d919,

"我要一步一步往上爬");

put_gb2312_buf(video, 1024, 400, 544, 0x00d9d919,

"在最高点乘着叶片往前飞");

put_gb2312_buf(video, 1024, 400, 560, 0x00d9d919,

"小小的天留过的泪和汗");

put_gb2312_buf(video, 1024, 400, 576, 0x00d9d919,

"总有一天我有属于我的天");

/*

分别是桌面、鼠标、窗口0、窗口1的图层指针。

*/

struct SHEET* sht_back, * sht_mouse, *sht_win, *sht_win1;

/*

桌面图层缓冲区分配内存。

*/

void* buf_back = get_kernel_pages(up_pgs(1024 * (768 - 128) * 4));

desktop = buf_back;

/*

复制桌面当前内容当图层缓冲区，成为图层的一部分后，这些

东西上面图层将不能擦除。

*/

memcpy_((void*)buf_back, (void*)(video + 1024 * 128), 1024 *

(768 - 128) * 4);

/*

不通过拷贝直接往桌面图层中画一个黄色的实心圆形。

*/

// fill_circle(buf_back, 1024, 800, 300, 80, 0x00ffff00);

/*

分别是窗口0、窗口1的图层缓冲区内存分配、即颜色填充，同时画蛇添足

地往窗口中画了些图形、写了些文字。

*/

int* buf_win = get_kernel_pages(up_pgs(500 * 300 * sizeof(int)));

int* buf_win1 = get_kernel_pages(up_pgs(300 * 250 * sizeof(int)));

for(i = 0; i < 500 * 300; i++) {

buf_win[i] = 0x00cccccc;

}

for(i = 0; i < 300 * 250; i++) {

buf_win1[i] = 0x00cccccc;

}

fill_rectangle(buf_win1, 300, 180, 10, 80, 80, 0x00ff0000);

struct point a, b, c;

a.x = 80 + 200;

a.y = 5;

b.x = 20 + 200;

b.y = 200;

c.x = 150 + 200;

c.y = 210;

fill_triangle(buf_win, 500, &a, &b, &c, 0x00ffffff);

put_str_buf(buf_win, 500, 80, 80, 0x00ff0000,

"Hello, SnailOS. Good luck!...");

/*

下面是初始化、分配图层结构、设置图层基本信息、移动图层到

适当位置以及重置图层高度。

*/

shtctl = shtctl_init(video + 1024 * 128, 1024, 768 - 128);

sht_back = sheet_alloc(shtctl);

sht_mouse = sheet_alloc(shtctl);

sht_win = sheet_alloc(shtctl);

sht_win1 = sheet_alloc(shtctl);

sheet_setbuf(sht_back, buf_back, 1024, 768 - 128, -1);

sheet_setbuf(sht_mouse, mouse_bin, 16, 16, 0x003098df);

sheet_setbuf(sht_win, buf_win, 500, 300, -1);

sheet_setbuf(sht_win1, buf_win1, 300, 250, -1);

sheet_slide(sht_back, 0, 0);

sheet_slide(sht_win, 80, 200);

sheet_slide(sht_mouse, 300, 300);

sheet_slide(sht_win1, 2, 2);

sheet_updown(sht_back, 0);

sheet_updown(sht_mouse, 3);

sheet_updown(sht_win, 1);

sheet_updown(sht_win1, 2);

/*

这些变量将用于鼠标对图层的操作。

*/

int x, y, mmx = -1, mmy = -1;

struct SHEET* sht = NULL;

/*

既定定时器的设置。

*/

timer_set(t_m, 100, &main_thread->r, 0);

timer_set(t_m, 100, &main_thread->r, 1);

enable_extern_intr(0x28);

enable_extern_intr(0x20);

enable_extern_intr(0x21);

enable_extern_intr(0x2c);

enable_extern_intr(0x2e);

// out(0x21, 0xf8);

// out(0xa1, 0xae);

intr_enable();

thread_start("k_thread_a", 2, k_thread_a, " argA ", 1);

thread_start("k_thread_b", 2, k_thread_b, " argB ", 1);

thread_start("k_thread_c", 3, k_thread_c, " argC ", 1);

/*

创建空闲线程，把空闲线程放在运行级别的最低级上，则当除了主线程

之外没有其他线程或者进程运行时，空闲线程粉墨登场，从而避免了由于

主线程睡眠而造成的无进程运行的调试异常。

*/

thread_start("Idle", 1, idle, "idle ", 7);

/*

创建3个用户级进程，它们都运行在1的运行级上，且优先级为2（优先级

的设置归init_thread函数管）。

*/

process_execute(ua, "UA", 1);

process_execute(ub, "UB", 1);

process_execute(uc, "Uc", 1);

unsigned int keymap[0x80] = {

0,0,'1','2','3','4','5','6','7','8','9','0','-','=',0,0,

'q','w','e','r','t','y','u','i','o','p','[',']',0,0,'a','s',

'd','f','g','h','j','k','l',';','\'','`',0,'\\','z','x','c','v',

'b','n','m',',','.','/',0,'*',0,' ',0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0

};

while(1) {

asm("cli");

/*

遍历各个线程的循环缓冲区，统一向其中发送整数0。从而使

每个线程的缓冲区都有数据，让线程的循环中显示信息的条件

成立。

*/

struct list_node* n;

struct task* t;

/*

这里我们也要改变一下，因为已经不是遍历一个队列，所以要

做个大循环来对每个就绪队列遍历。

*/

for(i = 0; i < 8; i++) {

thread_ready_list = &ready_list[i];

if(!double_linked_list_is_empty(thread_ready_list)) {

n = thread_ready_list->head.next;

while(n != &thread_ready_list->tail) {

struct task* t =

node2entry(struct task, general_tag, n);

ring_queue_in(&t->r, 0);

n = n->next;

}

}

}

sheet_refresh(sht_back, 700, 0, 1020, 300);

/*

如果ins_queue指令缓冲区为空，则不做任何操作。否则赋值指令

及其参数，并执行该指令。注意指令是用整数表示的。

*/

/*

当且仅当两个缓冲区都为空时才直接恢复中断。

*/

if(is_empty(&ins_queue) && ring_queue_is_empty(&running_thread()->r)) {

thread_block(BLOCKED);

asm("sti;hlt");

} else {

struct buf e;

e = ins_queue.buffer[queue_out(&ins_queue)];

/*

这里我们要消费掉鼠标和键盘中断发向缓冲区的数据。

*/

int d = ring_queue_out(&main_thread->r);

asm("sti");

instructions_switch(&e);

/*

打印缓冲区元素的数目，因为一直往缓冲区中填入数据，没有人读出，所以

缓冲区空间逐步减小，知道填满。

*/

/*

if(ring_queue_is_full(&running_thread()->r)) {

printf_("...%d...", running_thread()->r.free);

} else {

printf_("___%d___", running_thread()->r.free);

}

*/

/*

用于测试定时器的部分，当既定的时刻（滴答数）到来时，经由时钟

中断处理程序删除这个定时器，并向主线程发送数据0，这里接收到数据后，

就重新添加一个定时器，拟发送的数据为1，当次定时器到期时，时钟中断

处理程序也删除它，同时发送数据0。因此，形成定时循环显示文字的效果。

*/

if(d == 0) {

put_gb2312_buf(video, 1024, 200, 300, 0x00ff0000,

"我爱你蜗牛操作系统！");

timer_set(t_m, 100, &main_thread->r, 1);

}

if(d == 1) {

put_gb2312_buf(video, 1024, 200, 300, 0x000000ff,

"我爱你蜗牛操作系统！");

timer_set(t_m, 100, &main_thread->r, 0);

}

/*

这里我们键盘中断处理程序发送过来的数据，由于在原始数据的基础

上加上了0x100，所以这里要恢复原貌。

*/

if((d >= 0x100) && (d < 0x100 + 0x100)) {

if((d - 0x100) & 0x80) {

} else {

/*

！！！请特别的注意这里，它将printf_函数改为了内核专用的kprintf_

函数。这只要是因为主线程暂时不能使用互斥机制，因该函数的唤醒，不

依赖于互斥机制，而是由中断和循环缓冲区异步唤醒的。大家可以尝试一下，

当改为互斥机制的printf_函数时，系统会宕机。

*/

kprintf_("%c", keymap[(d - 0x100) & 0x7f]);

}

}

/*

这里我们鼠标中断处理程序发送过来的数据。

*/

if((d >= 0x100 + 0x100) && (d < 0x100 + 0x100 + 0x100)) {

if(mouse_decode(&mdec, d - 0x100 - 0x100)) {

/*

在鼠标未动之前，把鼠标指针消隐。

*/

// draw_mouse_before(video + 1024 * 128,

// mx, my, 16, 16, mouse_before);

/*

鼠标数据中的横向和纵向数据其实是相对与当前的增减数据。

*/

mx += mdec.x;

my += mdec.y;

/*

对数据在画面的范围进行判断。也就是横轴和纵轴的极值。

*/

if(mx < 0) {

mx = 0;

}

if(my < 0) {

my = 0;

}

if(mx > 1024 - 1) {

mx = 1024 - 1;

}

if(my > 768 - 1 - 128) {

my = 768 - 1 - 128;

}

/*

移动后，根据新的坐标位置重新描画鼠标指针。

*/

sheet_slide(sht_mouse, mx, my);

int btn = mdec.btn;

/*

这里是鼠标左键的处理。

*/

if(btn & 1) {

/*

mmx和mmy是窗口被移动前的坐标信息，它同时也表示窗口是否

是移动状态。窗口被移动的最高前提条件时，鼠标左键被按下，

而是否按在了窗口上，需要在从高往低遍历图层，只有当窗口位于鼠标

坐标范围内且不是透明色，才把窗口置为次顶层。显然mmx<0是

未被移动的状态，窗口也只有这两种状态。这时便可以通过mmx、

mmy记住窗口未移动前的位置。因为已经左击了窗口，所以窗口

位置升高到鼠标的下层（次顶层）。当未处于移动状态时，仅仅

点击了鼠标左键，则窗口位置提升后，退出循环。

*/

if(mmx < 0) {

for(j = shtctl->top - 1; j > 0; j--) {

sht = shtctl->sheets[j];

x = mx - sht->vx0;

y = my - sht->vy0;

if(0 <= x && x < sht->bxsize &&

0 <= y && y < sht->bysize)

{

if(sht->buf[y * sht->bxsize + x]

!= sht->col_inv) {

sheet_updown(sht, shtctl->top - 1);

mmx = mx;

mmy = my;

}

break;

}

}

/*

仅仅是mmx和mmy大于0并不能引起窗口的移动，只有在按下鼠标后，鼠标位置

的值发生变化了，才可能移动窗口图层。它们的差值加上图层在画面中的初始

位置作为移动窗口图层函数的参数。同时，在鼠标未按下时置图层移动标志为

-1，即不会移动。

*/

} else {

x = mx - mmx;

y = my - mmy;

sheet_slide(sht, sht->vx0 + x, sht->vy0 + y);

mmx = mx;

mmy = my;

}

} else {

mmx = -1;

}

if(btn & 2) {

/*

这里是鼠标右键的处理，现在未作任何处理。

*/

}

if(btn & 4) {

/*

这里是鼠标中键的处理，现在未作任何处理。

*/

}

}

}

}

}

}

/*

选择要执行的指令，这里只是随意安排的，目前仅仅是画实心矩形、

实心圆以及空心圆。

*/

void instructions_switch(struct buf* e) {

switch(e->instruction) {

case 0:

fill_rectangle((unsigned int*)e->argv[0], e->argv[1], e->argv[2],

e->argv[3], e->argv[4], e->argv[5], e->argv[6]);

break;

case 1:

fill_circle((unsigned int*)e->argv[0], e->argv[1], e->argv[2],

e->argv[3], e->argv[4], e->argv[5]);

break;

case 5:

draw_circle((unsigned int*)e->argv[0], e->argv[1], e->argv[2],

e->argv[3], e->argv[4], e->argv[5]);

break;

default:

break;

}

}

extern unsigned int ticks;

void init(void) {

ticks = 0;

/*

全局描述符表的初始化。

*/

gdt_init();

/*

分页机制的初始化。

*/

page_init();

/*

中断描述符表的初始化。

*/

idt_init();

/*

可编程中断控制器的初始化。

*/

i8259_init();

/*

实时时钟的初始化。

*/

rtc_init();

/*

发生频率的初始化。

*/

i8253_init();

/*

内存管理模块的初始化。

*/

mem_init();

thread_init();

screen_init_();

/*

一定要初始化指令队列。

*/

queue_init(&ins_queue);

keyboard_init();

mouse_init();

timer_man_init();

tss_init();

syscall_init();

hd_init();

}

unsigned int uav = 0, ubv = 0, ucv = 0;

void k_thread_a(void* arg) {

/*

每个线程都通过入队指令向指令队列中插入指令。当插入指令时，

为了防止竞争条件的发生，果断的关闭中断。

*/

struct buf e;

/*

通过临时变量，构造一个符合指令格式的完整指令。

*/

e.instruction = 0;

e.argc = 7;

e.t = running_thread();

e.argv[0] = 0xe0000000;

e.argv[1] = 1024;

e.argv[2] = 400;

e.argv[3] = 400;

e.argv[4] = 30;

e.argv[5] = 50;

e.argv[6] = 0x00ffff00;

// asm("cli");

// queue_in(&ins_queue, &e);

// asm("sti");

e.instruction = 0;

e.argc = 7;

e.t = running_thread();

e.argv[0] = 0xe0000000;

e.argv[1] = 1024;

e.argv[2] = 100;

e.argv[3] = 100;

e.argv[4] = 70;

e.argv[5] = 70;

e.argv[6] = 0x0000ff00;

// asm("cli");

// queue_in(&ins_queue, &e);

// asm("sti");

struct fat32_krn_p fat32_p;

read_mbr_dbr(&fat32_p);

fat32_krn = fat32_p;

unsigned int i;

for(i = 0; i < 0xffff; i++){

sema_post(pevent_);

}

char* s = file_read("hello.txt");

printf_("!!!%x %x %x!!!", fat32_krn.fat1_p, fat32_krn.root_dir_p,

fat32_krn.root_dir_start_sector);

printf_(s);

while(1) {

printf_(" THREAD A ");

mtime_sleep1(8000);

}

/*

*/

}

void k_thread_b(void* arg) {

struct buf e;

e.instruction = 0;

e.argc = 7;

e.t = running_thread();

e.argv[0] = 0xe0000000;

e.argv[1] = 1024;

e.argv[2] = 600;

e.argv[3] = 200;

e.argv[4] = 80;

e.argv[5] = 80;

e.argv[6] = 0x00ff0000;

// asm("cli");

// queue_in(&ins_queue, &e);

// asm("sti");

e.instruction = 5;

e.argc = 6;

e.t = running_thread();

e.argv[0] = 0xe0000000;

e.argv[1] = 1024;

e.argv[2] = 300;

e.argv[3] = 300;

e.argv[4] = 100;

e.argv[5] = 0x00ffffff;

// asm("cli");

// queue_in(&ins_queue, &e);

// asm("sti");

sema_pend(pevent_);

///*

char* s = file_read("y.bmp");

struct bmp_buf_info bbi;

save_bmp((char*)s, &bbi);

unsigned int* v = (unsigned int*)(0xe0000000 + 1024 * 128 * 4);

put_bmp_buf(v, 1024, 700, 300, &bbi);

while(1) {

printf_(" THREAD B ");

mtime_sleep1(9188);

}

/*

*/

}

void k_thread_c(void* arg) {

struct buf e;

e.instruction = 0;

e.argc = 7;

e.t = running_thread();

e.argv[0] = 0xe0000000;

e.argv[1] = 1024;

e.argv[2] = 600;

e.argv[3] = 200;

e.argv[4] = 50;

e.argv[5] = 100;

e.argv[6] = 0x00ff00ff;

// asm("cli");

// queue_in(&ins_queue, &e);

// asm("sti");

e.instruction = 1;

e.argc = 6;

e.t = running_thread();

e.argv[0] = 0xe0000000;

e.argv[1] = 1024;

e.argv[2] = 200;

e.argv[3] = 400;

e.argv[4] = 50;

e.argv[5] = 0x000f00f0;

// asm("cli");

// queue_in(&ins_queue, &e);

// asm("sti");

sema_pend(pevent_);

///*

char* s = file_read("l.bmp");

struct bmp_buf_info bbi;

save_bmp((char*)s, &bbi);

unsigned int* v = (unsigned int*)(0xe0000000 + 1024 * 128 * 4);

put_bmp_buf(v, 1024, 500, 320, &bbi);

while(1) {

printf_(" THREAD C ");

mtime_sleep1(10088);

}

/*

*/

}

/*

三个进程的实体，它们仅仅是玩了命的自增三个不同的全局

变量。显示变量的工作由内核进程来完成。

*/

void ua(void) {

while(1) {

// uav++;

/*

之所以这里没用，printf_打印变量信息，主要是因为它在几层

调用后含有特权指令，所以会出现一般保护异常。我们暂时选择

用全局变量在线程中显示。

*/

write(" PORCESS A");

msleep(8000);

}

}

void ub(void) {

while(1) {

write(" PORCESS B");

msleep(8000);

}

}

void uc(void) {

while(1) {

write(" PORCESS C");

msleep(8000);

}

}

void idle(void* arg) {

unsigned char* s = arg;

while(1) {

printf_(s);

__asm__ __volatile__ ("sti; hlt;");

}

}

同时在最后给大家一个完整kernel.c，从而可以看到系统实际运行的简单原貌。下图大家可以看到，真是美女如云啊，至此，我们Snail OS开发的第一阶段也就是这样了。拼一个自己的操作系统真是不容易啊！。

参考书目：

《操作系统真相还原》郑钢

《30天自制操作系统》川合秀实

《linux内核完全剖析》赵炯

《一个操作系统的实现》于渊