本篇对应书籍第十三章的内容

本篇内容介绍了硬盘分区表的结构和存放，以及编写了简易版本的硬盘驱动程序

本篇难点：

• 要有耐心去看硬盘IO操作是如何封装的

硬盘及分区表

之前的那个虚拟磁盘用来装系统内核了，为了图省事，再整一块虚拟硬盘来用

创建从盘&获取安装的磁盘数

通过bximage创建一个80M的硬盘，得到硬盘参数：

  ata0-master: type=disk, path="hd80M.img", mode=flat

将master改成slave，填入bochsrc.disk

启动Bochs，查看内存0x475，获取当前安装的硬盘数：

BIOS 检查的时候，会把安装的硬盘数写入内存 0x475 的位置

到此，硬盘创建好安装完毕了

创建硬盘分区表

文件系统 = 数据结构 + 算法，所以说，文件系统也是软件，管理对象是文件，管辖范围是分区

关于柱面、扇区、磁道、磁头、盘面等知识之前讲过了，这里就不回顾了

硬盘容量 = 每磁道扇区数x柱面数x512字节x磁头数

分区表位于 MBR 中，只有64字节大小，每一个分区表项都占有16字节，所以最多有4个分区

为了支持任意数量分区，发明了扩展分区，通过id属性值判断分区类型

分区表中共 4个分区，哪个做扩展分区都可以，扩展分区是可选的，但最多只有1个，其余的都是主分区。在过去没有扩展分区时，这 4 个分区都是主分区；为了兼容 4 个主分区的情况，扩展分区中的第 1 个逻辑分区的编号从 5 开始。

使用fdisk进行分区：

随便分一分，一个主分区，一个扩展分区，扩展分区随便分了4份，类型都是0x66

磁盘分区表浅析

磁盘分区表，Disk Partition Table，由多个元信息组成的表，每个表项对应一个分区，主要记录各分区的起始扇区地址、大小界限等

最初的磁盘分区表位于 MBR 引导扇区中（MBR 扇区由三部分组成：主引导记录MBR、磁盘分区表DPT、结束魔数55AA）

在硬盘中，最开始的扇区是 MBR 扇区，接着是多个空闲扇区，然后才是具体的分区，中间这个空闲扇区是由分区工具决定的，一般分区的起始地址都是柱面的整数倍，对于不够1个柱面的剩余空间不再使用

以前的磁盘分区表默认支持 4 个主分区，但是需要的分区多了，就发明了扩展分区，从这4个主分区选一个出来作为主扩展分区来使用，主扩展分区可以划分为多个子扩展分区，每个子扩展分区在逻辑上相当于硬盘

扩展分区采用链式结构，将所有子扩展分区表串在一起，分区表也采用这种结构，表项分两部分：

• 描述逻辑分区的信息
• 描述下一个子扩展分区的地址

每个逻辑分区最开始的扇区，EBR扩展引导扇区，用于存储子扩展分区的分区表，逻辑结构和MBR扇区一样

MBR 和 EBR 的第一个表项都指向一个分区的起始，起始地址是扇区地址，该逻辑分区最开始的扇区，OBR，操作系统引导扇区，第二个分区表项指向下一个子扩展分区的 EBR

分区表项结构如图所示：

这一块需要解析img文件到十六进制进行查看学习，这里不方便操作，就先跳过了，具体需要的时候再回过头来了解

编写硬盘驱动程序

驱动程序是对硬件接口操作的封装，来简化这些接口的使用

硬盘初始化

硬盘的中断信号挂在 8259A 从片 IRQ15 的位置，要使用该位置，需要把主片的 IRQ2 也打开

kernel/interrupt.c

	//打开主片上的 IR0 也就是目前只接受时钟产生的中断
	outb (PIC_M_DATA, 0xf8);
	outb (PIC_S_DATA, 0xbf);

lib/kernel/stdio-kernel.c

为了图输出方便，封装一个内核的printf就是printk函数

#include "stdio-kernel.h"
#include "print.h"
#include "stdio.h"
#include "console.h"
#include "global.h"

#define va_start(args, first_fix) args = (va_list)&first_fix
#define va_end(args) args = NULL

// 供内核使用的格式化输出函数
void printk(const char* format, ...) {
    va_list args;
    va_start(args, format);
    char buf[1024] = {0};
    vsprintf(buf, format, args);
    va_end(args);
    console_put_str(buf);
}

device/ide.h

这里定义硬盘相关的数据结构，分区结构，硬盘结构，ata通道结构，都是之后操作要用到的，用到的时候再具体介绍功能

#ifndef __DEVICE_IDE_H
#define __DEVICE_IDE_H
#include "stdint.h"
#include "sync.h"
#include "bitmap.h"

// 分区结构
struct partition {
    uint32_t start_lba;         // 起始扇区
    uint32_t sec_cnt;           // 扇区数
    struct disk* my_disk;       // 分区所属的硬盘
    struct list_elem part_tag;  // 用于队列中的标记
    char name[8];               // 分区名称
    struct super_block* sb;     // 本分区的超级块
    struct bitmap block_bitmap; // 块位图
    struct bitmap inode_bitmap; // inode 位图
    struct list open_inodes;    // 本分区打开的 i 结点队列
};

// 硬盘结构
struct disk {
    char name[8]; // 本硬盘的名称
    struct ide_channel* my_channel; // 此块硬盘归属于哪个 ide 通道
    uint8_t dev_no;                 // 本硬盘是主 0, 还是从 1
    struct partition prim_parts[4]; // 主分区顶多是 4 个
    struct partition logic_parts[8]; // 逻辑分区数量无限, 本内核支持 8 个
};

// ata 通道结构
struct ide_channel {
    char name[8];               // 本 ata 通道名称
    uint16_t port_base;         // 本通道的起始端口号
    uint8_t irq_no;             // 本通道所用的中断号
    struct lock lock;           // 通道锁
    bool expecting_intr;        // 表示等待硬盘的中断
    struct semaphore disk_done; // 用于阻塞、唤醒驱动程序
    struct disk devices[2];     // 一个通道上连接两个硬盘, 一主一从
};
#endif

device/ide.c

使用宏保存基础的内容，通过ide_init函数做一些基础工作：

#include "ide.h"
#include "sync.h"
#include "io.h"
#include "stdio.h"
#include "stdio-kernel.h"
#include "interrupt.h"
#include "memory.h"
#include "debug.h"
#include "console.h"
#include "timer.h"
#include "string.h"
#include "list.h"

// 定义硬盘各寄存器的端口号
#define reg_data(channel)	 (channel->port_base + 0)
#define reg_error(channel)	 (channel->port_base + 1)
#define reg_sect_cnt(channel)	 (channel->port_base + 2)
#define reg_lba_l(channel)	 (channel->port_base + 3)
#define reg_lba_m(channel)	 (channel->port_base + 4)
#define reg_lba_h(channel)	 (channel->port_base + 5)
#define reg_dev(channel)	 (channel->port_base + 6)
#define reg_status(channel)	 (channel->port_base + 7)
#define reg_cmd(channel)	 (reg_status(channel))
#define reg_alt_status(channel)  (channel->port_base + 0x206)
#define reg_ctl(channel)	 reg_alt_status(channel)

// reg_alt_status寄存器的一些关键位
#define BIT_STAT_BSY	 0x80	      // 硬盘忙
#define BIT_STAT_DRDY	 0x40	      // 驱动器准备好	 
#define BIT_STAT_DRQ	 0x8	      // 数据传输准备好了

// device寄存器的一些关键位
#define BIT_DEV_MBS	0xa0	    // 第7位和第5位固定为1
#define BIT_DEV_LBA	0x40
#define BIT_DEV_DEV	0x10

// 一些硬盘操作的指令
#define CMD_IDENTIFY	   0xec	    // identify指令
#define CMD_READ_SECTOR	   0x20     // 读扇区指令
#define CMD_WRITE_SECTOR   0x30	    // 写扇区指令

// 定义可读写的最大扇区数,调试用的
#define max_lba ((80*1024*1024/512) - 1)	// 只支持80MB硬盘

uint8_t channel_cnt;	   // 按硬盘数计算的通道数
struct ide_channel channels[2];	 // 有两个ide通道

// 硬盘数据结构初始化
void ide_init() {
    printk("ide_init start\n");
    uint8_t hd_cnt = *((uint8_t*)(0x475)); // 获取硬盘的数量
    ASSERT(hd_cnt > 0);
    // 一个 ide 通道上有两个硬盘, 根据硬盘数量反推有几个ide通道
    channel_cnt = DIV_ROUND_UP(hd_cnt, 2); 
    struct ide_channel* channel;
    uint8_t channel_no = 0//, dev_no = 0;

    // 处理每个通道上的硬盘
    while (channel_no < channel_cnt) {
        channel = &channels[channel_no];
        sprintf(channel->name, "ide%d", channel_no);

        // 为每个ide通道初始化端口基址及中断向量
        switch (channel_no) {
        case 0:
            channel->port_base = 0x1f0; // ide0 通道的起始端口号是 0x1f0
            channel->irq_no = 0x20 + 14; // ide0 通道的中断向量号
            break;
        case 1:
            channel->port_base = 0x170; // ide1 通道的起始端口号是 0x170
            channel->irq_no = 0x20 + 15; // ide1 通道的中断向量号
            break;
        }

        channel->expecting_intr = false; // 未向硬盘写入指令时不期待硬盘的中断
        lock_init(&channel->lock);

        sema_init(&channel->disk_done, 0);

        channel_no++; // 下一个 channel
    }
    // 打印所有分区信息
    printk("ide_init done\n");
}

到这里初始化工作就完毕了

实现 thread_yield 和 idle 线程

这里需要完成一些基础构件才能继续进行

thread_yield 的功能是主动把 CPU 使用权让出来，执行后任务状态变为 READY 然后立即重新加入就绪队列等待调度执行

thread/thread.c

struct task_struct* idle_thread;        // idle 线程
...
// 系统空闲时运行的线程
static void idle(void* arg UNUSED) {
    while (1) {
        thread_block(TASK_BLOCKED);
        // 执行 hlt 时必须要保证目前处在开中断的情况下
        asm volatile ("sti; hlt" : : : "memory");
    }
}
...
// 实现线程调度
void schedule(void) {
...
    // 如果就绪队列中没有可运行的任务, 就唤醒 idle
    if (list_empty(&thread_ready_list)) {
        thread_unblock(idle_thread);
    }
...
}

// 主动让出 cpu, 换其它线程运行
void thread_yield(void) {
    struct task_struct* cur = running_thread();
    enum intr_status old_status = intr_disable();
    ASSERT(!elem_find(&thread_ready_list, &cur->general_tag));
    list_append(&thread_ready_list, &cur->general_tag);
    cur->status = TASK_READY;
    schedule();
    intr_set_status(old_status);
}
// 初始化线程环境
void thread_init(void) {
...
    // 将当前 main 函数创建为线程
    make_main_thread();
    idle_thread = thread_start("idle", 10, idle, NULL);
...
}

这里做了两件事：创建的thread_yield函数，和创建空闲线程idle

thread_yield的工作有三步：

1. 将自己加入就绪队列
2. 状态设置为READY
3. 调用 schedule 进行任务调度

因为前两步必须是原子操作，所以要先关中断

为了以防线程都执行完了，导致没有任务可调度而挂起，这里创建了一个idle线程，当就绪队列中没有任务了，就会执行该线程，该线程的功能是内联汇编hlt来让CPU真正意义上的挂起，不再执行指令，直到有中断产生，CPU再继续执行指令

实现简单的休眠函数

在等待硬盘操作的过程中，最好把CPU让出来，为了实现等待，需要定义一个休眠函数，这里实现一个简易版的休眠功能：

device/timer.c

#define IRQ0_FREQUENCY	   100

#define mil_seconds_per_intr (1000 / IRQ0_FREQUENCY)

// 以 tick 为单位的 sleep, 任何时间形式的 sleep 会转换此 ticks 形式
static void ticks_to_sleep(uint32_t sleep_ticks) {
   uint32_t start_tick = ticks;
   // 若间隔的 ticks 数不够便让出 cpu
   while (ticks - start_tick < sleep_ticks) {
      thread_yield();
   }
}

// 以毫秒为单位的 sleep
void mtime_sleep(uint32_t m_seconds) {
   uint32_t sleep_ticks = DIV_ROUND_UP(m_seconds, mil_seconds_per_intr);
   ASSERT(sleep_ticks > 0);
   ticks_to_sleep(sleep_ticks);
}

mil_seconds_per_intr 是每毫秒发生中断的次数，中断频率已经被设置为每秒钟100次，所以每10毫秒发生1次中断

ticks_to_sleep 函数以中断为单位来进行等待，等到过了一定中断数之后才开始执行

mtime_sleep 函数是上一个函数的封装，以毫秒数来进行等待，把毫秒数换算成要等待的周期数，然后再调用上一个函数进行

完善硬盘驱动程序上

基础部分已经准备完毕，接下来看硬盘的中断处理函数部分：

device/ide.c

// 选择读写的硬盘
static void select_disk(struct disk* hd) {
    uint8_t reg_device = BIT_DEV_MBS | BIT_DEV_LBA;
    if (hd->dev_no == 1) { // 若是从盘就置 DEV 位为 1
        reg_device |= BIT_DEV_DEV;
    }
    outb(reg_dev(hd->my_channel), reg_device);
}

// 向硬盘控制器写入起始扇区地址及要读写的扇区数
static void select_sector(struct disk* hd, uint32_t lba, uint8_t sec_cnt) {
    ASSERT(lba <= max_lba);
    struct ide_channel* channel = hd->my_channel;

    // 写入要读写的扇区数
    outb(reg_sect_cnt(channel), sec_cnt);
    // 写入扇区号
    outb(reg_lba_l(channel), lba);
    outb(reg_lba_m(channel), lba >> 8);
    outb(reg_lba_h(channel), lba >> 16);
    outb(reg_dev(channel), BIT_DEV_MBS | BIT_DEV_LBA | (hd->dev_no == 1 ? BIT_DEV_DEV : 0) | lba >> 24);
}

// 向通道 channel 发命令 cmd
static void cmd_out(struct ide_channel* channel, uint8_t cmd) {
    // 只要向硬盘发出了命令便将此标记置为 true
    // 硬盘中断处理程序需要根据它来判断
    channel->expecting_intr = true;
    outb(reg_cmd(channel), cmd);
}

// 硬盘读入 sec_cnt 个扇区的数据到 buf
static void read_from_sector(struct disk* hd, void* buf, uint8_t sec_cnt) {
    uint32_t size_in_byte;
    if (sec_cnt == 0) {
        size_in_byte = 256 * 512;
    } else {
        size_in_byte = sec_cnt * 512;
    }
    insw(reg_data(hd->my_channel), buf, size_in_byte / 2);
}

// 将 buf 中 sec_cnt 扇区的数据写入硬盘
static void write2sector(struct disk* hd, void* buf, uint8_t sec_cnt) {
    uint32_t size_in_byte;
    if (sec_cnt == 0) {
        size_in_byte = 256 * 512;
    } else {
        size_in_byte = sec_cnt * 512;
    }
    outsw(reg_data(hd->my_channel), buf, size_in_byte / 2);
}

// 等待 30 秒
static bool busy_wait(struct disk* hd) {
    struct ide_channel* channel = hd->my_channel;
    uint16_t time_limit = 30 * 1000; // 可以等待 30000 毫秒
    while (time_limit -= 10 >= 0) {
        if (!(inb(reg_status(channel)) & BIT_STAT_BSY)) {
            return (inb(reg_status(channel)) & BIT_STAT_DRQ);
        } else {
            mtime_sleep(10); // 睡眠 10 毫秒
        }
    }
    return false;
}

这里是几个功能函数：

• select_disk 函数：选择待操作的硬盘是主盘还是从盘

  利用 device 寄存器中的 dev 位，0表示主盘，1表示从盘

• select_sector 函数：向硬盘控制器写入起始扇区地址及要读写的扇区数

• read_from_sector 函数：硬盘读入 sec_cnt 个扇区的数据到 buf

• write2sector 函数：将 buf 中 sec_cnt 扇区的数据写入硬盘

• busy_wait 函数：等待 30 秒

完善硬盘驱动程序下

下半部分：

device/ide.c

// 从硬盘读取 sec_cnt 个扇区到 buf
void ide_read(struct disk* hd, uint32_t lba, void* buf, uint32_t sec_cnt) {
    ASSERT(lba <= max_lba);
    ASSERT(sec_cnt > 0);
    lock_acquire(&hd->my_channel->lock);

    // 1. 先选择操作的硬盘
    select_disk(hd);

    uint32_t secs_op; // 每次操作的扇区数
    uint32_t secs_done = 0; // 已完成的扇区数
    while (secs_done < sec_cnt) {
        if ((secs_done + 256) <= sec_cnt) {
            secs_op = 256;
        } else {
            secs_op = sec_cnt - secs_done;
        }
        // 2. 写入待读入的扇区数和起始扇区号
        select_sector(hd, lba+secs_done, secs_op);
        // 3. 执行的命令写入 reg_cmd 寄存器
        cmd_out(hd->my_channel, CMD_READ_SECTOR); // 准备开始读数据
        // 阻塞自己
        sema_down(&hd->my_channel->disk_done);
        // 4. 检测硬盘状态是否可读
        if (!busy_wait(hd)) { // 若失败
            char error[64];
            sprintf(error, "%s read sector %d failed!!!!!\n", hd->name, lba);
            PANIC(error);
        }
        // 5. 把数据从硬盘的缓冲区中读出
        read_from_sector(hd, (void*)((uint32_t)buf+secs_done*512), secs_op);
        secs_done += secs_op;
    }
    lock_release(&hd->my_channel->lock);
}

// 将 buf 中 sec_cnt 扇区数据写入硬盘
void ide_write(struct disk* hd, uint32_t lba, void* buf, uint32_t sec_cnt) {
    ASSERT(lba <= max_lba);
    ASSERT(sec_cnt > 0);
    lock_acquire(&hd->my_channel->lock);

    // 1. 先选择操作的硬盘
    select_disk(hd);

    uint32_t secs_op; // 每次操作的扇区数
    uint32_t secs_done = 0; // 已完成的扇区数
    while (secs_done < sec_cnt) {
        if ((secs_done + 256) <= sec_cnt) {
            secs_op = 256;
        } else {
            secs_op = sec_cnt - secs_done;
        }
        // 2. 写入待写入的扇区数和起始扇区号
        select_sector(hd, lba+secs_done, secs_op);
        // 3. 执行的命令写入 reg_cmd 寄存器
        cmd_out(hd->my_channel, CMD_WRITE_SECTOR);
        // 4. 检测硬盘状态是否可读
        if (!busy_wait(hd)) { // 若失败
            char error[64];
            sprintf(error, "%s write sector %d failed!!!!!\n", hd->name, lba);
            PANIC(error);
        }
        // 5. 将数据写入硬盘
        write2sector(hd, (void*)((uint32_t)buf+secs_done*512), secs_op);
        // 在硬盘响应期间阻塞自己
        sema_down(&hd->my_channel->disk_done);
        secs_done += secs_op;
    } 
    // 醒来后开始释放锁
    lock_release(&hd->my_channel->lock);
}

// 硬盘中断处理程序
void intr_hd_handler(uint8_t irq_no) {
    ASSERT(irq_no == 0x2e || irq_no == 0x2f);
    uint8_t ch_no = irq_no - 0x2e;			//获取通道号
    struct ide_channel* channel = &channels[ch_no];
    ASSERT(channel->irq_no == irq_no);
    if (channel->expecting_intr) {
        channel->expecting_intr = false;
        sema_up(&channel->disk_done);
        inb(reg_status(channel));
    }
}
// 硬盘数据结构初始化
void ide_init() {
...

        sema_init(&channel->disk_done, 0);
        register_handler(channel->irq_no, intr_hd_handler);

        channel_no++; // 下一个 channel

这里是对上半部分那几个函数的封装，以及中断处理程序

硬盘中断仅在发出请求之后，硬盘处理完成之后进行触发，中断处理程序就是还原通道的信号量，以便下一个程序继续使用硬盘

通过读取status寄存器，可以清掉硬盘的中断

获取硬盘信息

这里只处理hd80M.img，主分区分别占据sdb1~4，逻辑分区占据sdb5~n

device/ide.c

// 用于记录总扩展分区的起始 lba, 初始为 0
int32_t ext_lba_base = 0;

// 用于记录硬盘主分区和逻辑分区的下标
uint8_t p_no = 0, l_no = 0;

// 分区队列
struct list partition_list;

// 构建一个 16 字节大小的结构体, 用来存分区表项
struct partition_table_entry {
    uint8_t  bootable;		 // 是否可引导	
    uint8_t  start_head;     // 起始磁头号
    uint8_t  start_sec;		 // 起始扇区号
    uint8_t  start_chs;		 // 起始柱面号
    uint8_t  fs_type;		 // 分区类型
    uint8_t  end_head;		 // 结束磁头号
    uint8_t  end_sec;		 // 结束扇区号
    uint8_t  end_chs;		 // 结束柱面号
/*  更需要关注的是下面这两项 */
    uint32_t start_lba;		 // 本分区起始扇区的lba地址
    uint32_t sec_cnt;		 // 本分区的扇区数目
} __attribute__ ((packed)); // 保证此结构是 16 字节大小

// 引导扇区, mbr 或 ebr 所在的扇区
struct boot_sector {
    uint8_t other[446]; // 引导代码
    struct partition_table_entry partition_table[4]; // 分区表中有 4 项, 共 64 字节
    uint16_t signature; // 启动扇区的结束标志是 0x55, 0xaa
} __attribute__ ((packed));

...;


// 将 dst 中 len 个相邻字节交换位置后存入 buf
static void swap_pairs_bytes(const char* dst, char* buf, uint32_t len) {
    uint8_t idx;
    for (idx = 0; idx < len; idx += 2) {
        // buf 中存储 dst 中两相邻元素交换位置后的字符串
        buf[idx+1] = *dst++;
        buf[idx] = *dst++;
    }
    buf[idx] = '\0';
}

// 获得硬盘参数信息
static void identify_disk(struct disk* hd) {
    char id_info[512];
    select_disk(hd);
    cmd_out(hd->my_channel, CMD_IDENTIFY);
    // 向硬盘发送指令后阻塞自己
    sema_down(&hd->my_channel->disk_done);

    // 醒来后开始执行下面的代码
    if (!busy_wait(hd)) { // 若失败
        char error[64];
        sprintf(error, "%s identify failed!!!!!", hd->name);
        PANIC(error);
    }
    read_from_sector(hd, id_info, 1);

    char buf[64];
    uint8_t sn_start = 10 * 2, sn_len = 20, md_start = 27 * 2, md_len = 40;
    swap_pairs_bytes(&id_info[sn_start], buf, sn_len);
    printk("    disk %s info:\n     SN: %s\n", hd->name, buf);
    memset(buf, 0, sizeof(buf));
    swap_pairs_bytes(&id_info[md_start], buf, md_len);
    printk("    MODULE: %s\n", buf);
    uint32_t sectors = *(uint32_t*)&id_info[60 * 2];
    printk("    SECTORS: %d\n", sectors);
    printk("    CAPACITY: %dMB\n", sectors*512/1024/1024);
}

这里通过定义一些数据结构，获取到硬盘中的分区表，读取分区表中的内容，进行输出，从而得到硬盘信息

扫描分区表

device/ide.c

// 扫描硬盘 hd 中地址为 ext_lba 的扇区中的所有分区
static void partition_scan(struct disk* hd, uint32_t ext_lba) {
    struct boot_sector* bs = sys_malloc(sizeof(struct boot_sector));
    ide_read(hd, ext_lba, bs, 1);
    uint8_t part_idx = 0;
    struct partition_table_entry* p = bs->partition_table;    

    // 表里分区表 4 个分区表项
    while (part_idx++ < 4) {
        if (p->fs_type == 0x5) { // 若为扩展分区
            if (ext_lba_base != 0) {
                // 子扩展分区的 start_lba 是相对于主引导扇区中的总扩展分区地址
                partition_scan(hd, p->start_lba+ext_lba_base);
            } else { // ext_lba_base 为 0 表示是第一次读取引导块, 也就是主引导记录所在的扇区
                ext_lba_base = p->start_lba;
                partition_scan(hd, p->start_lba);
            }
        } else if (p->fs_type != 0) { // 若是有效的分区类型
            if (ext_lba == 0) { // 此时全是主分区
                hd->prim_parts[p_no].start_lba = ext_lba + p->start_lba;
                hd->prim_parts[p_no].sec_cnt = p->sec_cnt;
                hd->prim_parts[p_no].my_disk = hd;
                list_append(&partition_list, &hd->prim_parts[p_no].part_tag);
                sprintf(hd->prim_parts[p_no].name, "%s%d", hd->name, p_no+1);
                p_no++;
                ASSERT(p_no < 4);
            } else {
                hd->logic_parts[l_no].start_lba = ext_lba + p->start_lba;
                hd->logic_parts[l_no].sec_cnt = p->sec_cnt;
                hd->logic_parts[l_no].my_disk = hd;
                list_append(&partition_list, &hd->logic_parts[l_no].part_tag);
                sprintf(hd->logic_parts[l_no].name, "%s%d", hd->name, l_no+5); // 逻辑分区数字是从 5 开始, 主分区是 1~4
                l_no++;
                if (l_no >= 8)
                    return;
            }
        }
        p++;
    }
    sys_free(bs);
}

// 打印分区信息
static bool partition_info(struct list_elem* pelem, int arg UNUSED) {
    struct partition* part = elem2entry(struct partition, part_tag, pelem);
    printk("    %s start_lba:0x%x, sec_cnt:0x%x\n", part->name, part->start_lba, part->sec_cnt);
    // 返回 false 与函数本身功能无关
    // 只是为了让主调函数 list_traversal 继续向下遍历元素
    return false;
}

// 硬盘数据结构初始化
void ide_init() {
    printk("ide_init start\n");
    uint8_t hd_cnt = *((uint8_t*)(0x475)); // 获取硬盘的数量
    ASSERT(hd_cnt > 0);
    //list_init(&partition_list);
    // 一个 ide 通道上有两个硬盘, 根据硬盘数量反推有几个ide通道
    channel_cnt = DIV_ROUND_UP(hd_cnt, 2); 
    struct ide_channel* channel;
    uint8_t channel_no = 0//, dev_no = 0;

    // 处理每个通道上的硬盘
    while (channel_no < channel_cnt) {
        channel = &channels[channel_no];
        sprintf(channel->name, "ide%d", channel_no);

        // 为每个ide通道初始化端口基址及中断向量
        switch (channel_no) {
        case 0:
            channel->port_base = 0x1f0; // ide0 通道的起始端口号是 0x1f0
            channel->irq_no = 0x20 + 14; // ide0 通道的中断向量号
            break;
        case 1:
            channel->port_base = 0x170; // ide1 通道的起始端口号是 0x170
            channel->irq_no = 0x20 + 15; // ide1 通道的中断向量号
            break;
        }

        channel->expecting_intr = false; // 未向硬盘写入指令时不期待硬盘的中断
        lock_init(&channel->lock);

        sema_init(&channel->disk_done, 0);

        register_handler(channel->irq_no, intr_hd_handler);

        // 分别获取两个硬盘的参数及分区信息
        while (dev_no < 2) {
            struct disk* hd = &channel->devices[dev_no];
            hd->my_channel = channel;
            hd->dev_no = dev_no;
            sprintf(hd->name, "sd%c", 'a'+channel_no*2+dev_no);
            identify_disk(hd); // 获取硬盘参数
            if (dev_no != 0) { // 内核本身的裸硬盘(hd60M.img)不处理
                partition_scan(hd, 0); // 扫描该硬盘上的分区
            }
            p_no = 0, l_no = 0;
            dev_no++;
        }
        dev_no = 0;

        channel_no++; // 下一个 channel
    }
    printk("\n  all partition info\n");
    // 打印所有分区信息
    list_traversal(&partition_list, partition_info, (int)NULL);
    printk("ide_init done\n");
}

局部变量保存在栈中，当局部变量很大的时候，栈空间可能不够用导致栈溢出，这里分区表扫描函数 partition_scan 使用了 sys_malloc 进行内存申请堆空间进行存放，通过递归获取指定硬盘中的每一个分区表，将分区表信息存储在参数中给定的hd指针里

运行 Bochs

编译，运行：

获取到了硬盘的信息

本篇总结

本篇内容介绍了硬盘分区表的存放方式，存放内容等，介绍了扩展分区是怎么扩展的

本篇内容带着实现了一套简易的硬盘驱动程序，驱动就是对底层重复操作的一个函数封装，这里封装了对硬盘的读写操作，获取硬盘信息操作和扫描分区表操作

在这期间，我们改进了内核里的一个问题，就是当任务全部都执行完毕后，没有任务执行而报错的问题，通过创建idle线程，在空闲时启动，通过内联汇编执行hlt命令让CPU真正意义上的挂起，不再执行指令，等出现中断的时候，再进行恢复

本篇还封装了一个内核版本的printf：printk 函数，方便打印字符串用

这一篇内容我学的怪烦的，感觉很没劲，全篇都在对硬盘IO进行各种封装，然后获取硬盘信息，操作硬盘，本篇的重点在于硬盘驱动程序，所以懒惰的我就直接copy代码来感受驱动程序的编写流程啦

驱动程序的编写是通过层层封装来实现的，先封装最基本的IO操作，然后根据IO操作封装出功能函数，成为驱动程序

无聊的内容到此就要结束了，真不错

参考资料

• 《操作系统真象还原》Chapter 13
• csdn博主swings_ss分享的配套代码：https://github.com/zhangwenxiao/os-core