Day01内容阅读

本章任务汇总：

  • 使用二进制编辑器写入启动扇区（直接写入机器码，不敲，直接复制了）
  • 使用汇编语言编写启动扇区
  • 熟悉bochs调试环境，学会配置文件的编写
  • 熟悉VM虚拟机上安装自己的操作系统
  • 看懂书中的汇编代码的基本结构

最终效果：

image.png
image.png

myos.nas汇编代码：

  1. ; hello-os
  2. ; TAB=4
  4. ; RESB指令会有个空间未初始化的告警，索性全换成times指令了
  6. ; FAT32软盘格式化代码，不用记，找相关文档看格式就行，这里是直接复制随书文件的，注释也是直接照抄的，后面明白了再说
  8.         DB        0xeb, 0x4e, 0x90
  9.         DB        "hxbos   "        ; 启动扇区名称，8字节
  10.         DW        512                ; 单个扇区的大小
  11.         DB        1                ; 簇的大小，必须为1个扇区
  12.         DW        1                ; FAT文件的起始位置（一般从第一个扇区的第一个字节开始）
  13.         DB        2                ; FAT的个数，2
  14.         DW        224                ; 根目录的大小，一般设置为224项
  15.         DW        2880            ; 磁盘的大小，必须为2880扇区
  16.         DB        0xf0            ; 磁盘的种类
  17.         DW        9                ; FAT的长度，必须是9扇区
  18.         DW        18                ; 1个磁道几个扇区，必须为18
  19.         DW        2                ; 磁头数必须为2
  20.         DD        0                ; 不使用分区，必须为0
  21.         DD        2880            ; 重写一次磁盘大小
  22.         DB        0,0,0x29        ; 意义不明，固定
  23.         DD        0xffffffff        ; （可能是卷标号码）
  24.         DB        "HXB-OS     "    ; 磁盘的名称（11字节），不足加空格
  25.         DB        "FAT12   "        ; 磁盘格式名称，不足加空格
  26.         ;RESB    18                ; reserve byte,预留18字节
  27.         times   18 db 0x00
  29. ; 程序主体
  31.         DB        0xb8, 0x00, 0x00, 0x8e, 0xd0, 0xbc, 0x00, 0x7c
  32.         DB        0x8e, 0xd8, 0x8e, 0xc0, 0xbe, 0x74, 0x7c, 0x8a
  33.         DB        0x04, 0x83, 0xc6, 0x01, 0x3c, 0x00, 0x74, 0x09
  34.         DB        0xb4, 0x0e, 0xbb, 0x0f, 0x00, 0xcd, 0x10, 0xeb
  35.         DB        0xee, 0xf4, 0xeb, 0xfd
  37. ; 信息显示部分
  39.         DB        0x0a, 0x0a        ; 2个换行
  40.         DB        "hello, world"
  41.         DB        0x0a            ; 换行
  42.         DB        0
  44.         ;RESB    0x1fe-($-$$)            ; 填写0x00,直到0x001fe, 书上的那个写法我用的nasm编译器报错，这个写法是于渊那本书上用的
  45.         times 0x1fe-($-$$) db 0x00
  47.         DB        0x55, 0xaa      ; 启动扇区标识
  49. ; 启动区之外的部分
  51.         DB        0xf0, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00
  52.         ;RESB    4600
  53.         times   4600    db  0x00
  54.         DB        0xf0, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00
  55.         ;RESB    1469432
  56.     times   1469432 db 0x00

此部分汇编代码主要有一下几个部分

  • 启动扇区
    • fat32软盘格式化代码
    • 主程序部分，实际上就是通过中断实现一个显示字符的操作
    • 显示的信息数据部分，以及填充0到扇区末尾
  • 启动扇区外的部分，有几个地方写了几个特殊的机器码，其他地方填0，到1.44MB大小

总结：

  1. 这一章中，先是直接通过二进制编辑器往文件中写入二进制机器码，完成一个包含了启动扇区的简单操作系统编写。
  2. 接着通过汇编代码简单说明了上面那些机器码都是干什么的。
  3. 启动扇区，机器开机后一个个的读取扇区，当读取到的扇区是启动扇区（512字节的最后两字节是55AA），那么从当前扇区开始执行。
  4. IPL,initial program loader,启动程序加载器，存放在启动扇区中，负责加载操作系统程序(操作系统很大，就一个启动扇区肯定放不了，所以需要通过加载器去加载在某个地方的操作系统程序)。
  5. FAT,一种文件格式。

Day02

本章任务汇总

  • 将上一节中的程序完全转为汇编程序，搞懂启动扇区都做了什么
  • 制作引导扇区，真正的引导程序下一章编写，这里只需要分离出来即可
  • 小工具编写1：实现一个程序，创建一个指定大小的文件
  • 小工具编写2：实现一个程序，实现将启动扇区的内容拷贝到软盘镜像的第一个扇区。（工具编写看个人，建议直接通过带参数命令行的方式运行，方便后边直接在Makefile中调用执行
  • ）
  • 弄明白核心程序代码，也就是那个调用中断显示字符的那段
  • make的使用，使用Makefile编写：软盘文件生成，引导程序生成，引导扇区写入到软盘镜像，加载配置文件运行bochs虚拟机

笔记

这一章的内容其实并不多，就是对前面一个章节章节的启动区启动扇区代码的主要代码进行一个解释（这个主要代码其实就是一个调用中断往显存中写入几个字符），然后就是简单的讲解了一些MakeFile的使用。

  1. 启动扇区核心代码解释

下面是昨天的那个汇编程序，不同的是将中间的直接写机器码的部分换成了汇编程序。
这部分换掉了而已
image.png
完整地汇编程序是下面这个，核心程序就是个中断调用，不熟悉去看一下汇编书籍就行（比如王爽的《汇编语言》）：

  1. ; hello-os
  2. ; TAB=4
  4. ; RESB指令会有个空间未初始化的告警，索性全换成times指令了
  6. ; FAT32软盘格式化代码，不用记，找相关文档看格式就行，这里是直接复制随书文件的，注释也是直接照抄的，后面明白了再说
  7.         ORG        0x7c00
  9.         JMP        entry
  11.         DB        0x90
  12.         DB        "hxbos   "        ; 启动扇区名称，8字节
  13.         DW        512                ; 单个扇区的大小
  14.         DB        1                ; 簇的大小，必须为1个扇区
  15.         DW        1                ; FAT文件的起始位置（一般从第一个扇区的第一个字节开始）
  16.         DB        2                ; FAT的个数，2
  17.         DW        224                ; 根目录的大小，一般设置为224项
  18.         DW        2880            ; 磁盘的大小，必须为2880扇区
  19.         DB        0xf0            ; 磁盘的种类
  20.         DW        9                ; FAT的长度，必须是9扇区
  21.         DW        18                ; 1个磁道几个扇区，必须为18
  22.         DW        2                ; 磁头数必须为2
  23.         DD        0                ; 不使用分区，必须为0
  24.         DD        2880            ; 重写一次磁盘大小
  25.         DB        0,0,0x29        ; 意义不明，固定
  26.         DD        0xffffffff        ; （可能是卷标号码）
  27.         DB        "HXB-OS     "    ; 磁盘的名称（11字节），不足加空格
  28.         DB        "FAT12   "        ; 磁盘格式名称(8字节)，不足加空格
  29.         ;RESB    18                ; reserve byte,预留18字节
  30.         times   18 db 0x00
  32. ; 程序主体
  34. entry:
  35.         MOV        AX,0            ; 初始化寄存器
  36.         MOV        SS,AX
  37.         MOV        SP,0x7c00        ; 为什么是从这个地址开始，由内存分布决定
  38.         MOV        DS,AX
  39.         MOV        ES,AX
  41.         MOV        SI,msg
  43. putloop:
  44.         MOV        AL,[SI]            ; [SI]地址中的值存放到AL中，AL显示的字符
  45.         ADD        SI,1            ; 地址加1
  46.         CMP        AL,0            ; 没有字符则退出
  47.         JE        fin    
  48.         MOV        AH,0x0e            ; 调用中断，显示字符         
  49.         ;MOV    BX,1            ; BX = 0x000F, BL = 0F, 前景色,至于为什么这个中断调用设置的字符颜色无效，现在我也不明白，后面会清楚的
  50.         mov     BX, 000ch
  51.         INT        0x10            ; int 0x10中断
  52.         JMP        putloop
  53. fin:
  54.         HLT                        ; CPU停止，等待指令
  55.         JMP        fin                ; 死循环
  57. ; 信息显示部分
  58. msg:
  59.         DB        0x0a, 0x0a        ; 2个换行
  60.         DB        "hello, hxbos"
  61.         DB        0x0a            ; 换行
  62.         DB        0
  64.         ;RESB    0x1fe-($-$$)            ; 填写0x00,直到0x001fe, 书上的那个写法我用的nasm编译器报错，这个写法是于渊那本书上用的
  65.         times 0x1fe-($-$$) db 0x00
  67.         DB        0x55, 0xaa      ; 启动扇区标识
  1. 工具编写1：生成镜像文件工具。

懂点c语言就能写，简单的文件IO，往文件中写0填充到指定大小即可。
下面是示例程序：

  1. #include <iostream>
  2. #include <cstring>
  3. #include <fstream>      // std::ifstream
  4. #include <cstdio> 
  6. const long long int DEFAULT_LEN = 1440*1024;
  8. using namespace std;
  10. char option[200];
  12. struct Config{
  13.     char ofile[200];        // 输出文件名 
  14.     long long len = DEFAULT_LEN;            // 生成的文件长度 
  15. };
  17. typedef struct Config Config;
  19. Config globalConfig;
  21. /**
  22. 相关知识点： 
  23. 1. 软盘有2个面，80个磁道，18个扇区，每区512B
  24.     软盘的大小最早是这么算出来的
  25.     80*12*512*2=1440*512*2=1440*1024（这样简称为1.44M)
  27. 2. 根据前面两章节的阅读，发现启动扇区之外部分也写入了几个特殊的机器码，由于现在还不明白这几个机器码是干嘛用的，就直接启动扇区之外全部填0吧 
  28. */
  30. /**
  31.     字符串转longlong 
  32. */
  33. long long int stoi(char *str){
  34.     long long res = 0;
  35.     int i = 0;
  36.     while(str[i]){
  37.         res = res * 10 + (str[i] - '0');
  38.         i++;
  39.     }
  40.     return res;
  41. } 
  43. void printUsage(){
  44.     printf("mkimage -of 【要生成的空镜像文件名】 -len 【生成的空镜像文件大小】\n");
  45. }
  48. /**
  49.     cnt, 参数个数 
  50.     argvs[0], 路径
  51.     args[1...n] , 具体输入参数 
  52. */
  53. int parseArgs(int cnt, char **argvs){
  54.     for(int i = 1; i < cnt; i++){
  55.         if(argvs[i][0] == '-'){
  56.             memset(option, 0, sizeof(option));
  57.             sprintf(option, "%s", &argvs[i][1]); 
  58.             if(strcmp(option, "of") == 0){
  59.             }else if(strcmp(option, "len") == 0){
  60.             }else{
  61.                 printf("不合法的参数\n");
  62.                 printUsage();
  63.                 return -1;    
  64.             }
  65.         }else{
  66.             printf("option = %s, vallue = %s\n", option, argvs[i]); 
  67.             if(strcmp(option, "of") == 0){
  68.                 sprintf(globalConfig.ofile, "%s", argvs[i]);
  69.             }else if(strcmp(option, "len") == 0){
  70.                 globalConfig.len = stoi(argvs[i]);
  71.             }else{
  72.                 printf("不合法的参数\n");
  73.                 printUsage();
  74.                 return -1;
  75.             }
  76.         }
  77.     }
  79.     return 0;
  80. }
  82. void showConfig(){
  83.     printf("\n =========== 当前配置的参数：==================\n");
  84.     printf("输出文件名：%s\n", globalConfig.ofile);
  85.     printf("长度 %lld字节\n", globalConfig.len);
  86. }
  88. void cWriteFileWithZero(){
  89.     char *buf = new char[globalConfig.len];
  90.     FILE *ofp;
  91.     ofp = fopen(globalConfig.ofile, "wb");
  92.     char output[512]; 
  93.     long long cur = 0, block = 1024 * 100, res, len = 0;
  94.     while(cur < globalConfig.len){
  95.         block = min(block, globalConfig.len - cur);
  96.         res = fwrite(buf, sizeof(char), block, ofp);
  97.         cur += block;
  98.         // 光标回退
  99.         for(int i = 0; i < len; i++){
  100.             printf("\b");
  101.         } 
  102.         memset(output, 0, sizeof(output));
  103.         sprintf(output, "write: %lld byte, current write: %lld byte, progress = %.2f%c", block, cur,  cur * 1.0 / globalConfig.len * 100, '%');
  104.         len = strlen(output);
  105.         printf("%s", output);
  107.     }
  108.     fclose(ofp);
  109.     delete buf;
  110. }
  112. int main(int argv, char **argvs){
  113.     parseArgs(argv, argvs);
  115.     showConfig();
  117.     cWriteFileWithZero();
  119.     printf("\n镜像生成完毕, 文件大小：%lld字节\n", globalConfig.len);
  120.     return 0;
  121. } 
  123. /**
  124. ./dd.exe -if boot.bin -of 
  126. */
  1. 工具编写2：将引导扇区写入到软盘文件中

示例程序：

  1. #include <iostream>
  2. #include <string>
  3. #include <cstring>
  4. #include <fstream>      // std::ifstream
  6. #include <cstdio> 
  8. using namespace std;
  10. char option[200];
  12. struct Config{
  13.     char ifile[200];        // 输入文件名 
  14.     char ofile[200];        // 输出文件名 
  15.     long long int iStartPos;        // 输入文件开始位置偏移 
  16.     long long int oStartPos;        // 输出文件开始位置偏移 
  17.     long long int ifSize;            // 输入文件拷贝多少到输出文件 
  18. };
  20. typedef struct Config Config;
  22. Config globalConfig;
  24. /**
  25.     字符串转longlong 
  27. */
  28. long long int stoi(char *str){
  29.     long long res = 0;
  30.     int i = 0;
  31.     while(str[i]){
  32.         res = res * 10 + (str[i] - '0');
  33.         i++;
  34.     }
  35.     return res;
  36. } 
  38. /**
  39.     cnt, 参数个数 
  40.     argvs[0], 路径
  41.     args[1...n] , 具体输入参数 
  43.     example: dd.exe -if boot.bin -of boot.img -len 512 
  44. */
  45. int parseArgs(int cnt, char **argvs){
  46.     for(int i = 1; i < cnt; i++){
  47.         if(argvs[i][0] == '-'){
  48.             memset(option, 0, sizeof(option));
  49.             sprintf(option, "%s", &argvs[i][1]); 
  50.             if(strcmp(option, "if") == 0){
  51.             }else if(strcmp(option, "of") == 0){
  52.             }else if(strcmp(option, "ioffset") == 0){
  53.             }else if(strcmp(option, "ooffset") == 0){
  54.             }else if(strcmp(option, "len") == 0){
  55.             }else{
  56.                 printf("不合法的参数\n");
  57.                 return -1;    
  58.             }
  59.         }else{
  60.             printf("option = %s, vallue = %s\n", option, argvs[i]);
  61.             if(strcmp(option, "if") == 0){
  62.                 sprintf(globalConfig.ifile, "%s", argvs[i]);
  63.             }else if(strcmp(option, "of") == 0){
  64.                 sprintf(globalConfig.ofile, "%s", argvs[i]);
  65.             }else if(strcmp(option, "ioffset") == 0){
  66.                 globalConfig.iStartPos = stoi(argvs[i]);                
  67.             }else if(strcmp(option, "ooffset") == 0){
  68.                 globalConfig.oStartPos = stoi(argvs[i]);
  69.             }else if(strcmp(option, "len") == 0){
  70.                 globalConfig.ifSize = stoi(argvs[i]);
  71.             }else{
  72.                 return -1;
  73.             }
  74.         }
  75.     }
  77.     return 0;
  78. }
  80. void showConfig(){
  81.     printf("\n =========== 当前配置的参数：==================\n");
  82.     printf("输入文件名：%s\n", globalConfig.ifile);
  83.     printf("输出文件名：%s\n", globalConfig.ofile);
  84.     printf("输入文件开始位置偏移 %lld\n", globalConfig.iStartPos);
  85.     printf("输出文件开始位置偏移 %lld\n", globalConfig.oStartPos);
  86.     printf("输入文件拷贝多少到输出文件 %lld字节\n", globalConfig.ifSize);
  87. }
  89. void cWriteFile(){
  90.     char *buf = new char[globalConfig.ifSize];
  91.     FILE *ifp, *ofp;
  92.     ifp = fopen(globalConfig.ifile, "rb");
  93.     ofp = fopen(globalConfig.ofile, "rb+");
  94.     if(ofp == NULL || ifp == NULL){
  95.         printf("error\n");
  96.         exit(-1);
  97.     } 
  98.     fseek(ofp, globalConfig.oStartPos, SEEK_SET);
  99.     fseek(ifp, globalConfig.iStartPos, SEEK_SET);
  100.     long long cur = 0, block = 512;
  101.     while(cur < globalConfig.ifSize){
  102.         block = min(block, globalConfig.ifSize - cur);
  103.         int res = fread(buf, sizeof(char), block, ifp);
  104.         cout<<"read = "<<res<<endl; 
  105.         res = fwrite(buf, sizeof(char), block, ofp);
  106.         cout<<"write = "<<res<<endl;
  107.         cur += block;
  108.     }
  110.     fclose(ifp);
  111.     fclose(ofp);
  112.     delete buf;
  113. }
  115. int main(int argv, char **argvs){
  116.     parseArgs(argv, argvs);
  118.     showConfig();
  120.     cWriteFile();
  122.     printf("程序写入完毕\n");
  123.     return 0;
  124. } 
  126. /**
  127. ./dd.exe -if boot.bin -of 
  129. */
  1. Makefile编写，编译、运行等合到一块。

总结