操作系统真象还原:编写硬盘驱动程序

news2024/7/6 21:33:13

第13章-编写硬盘驱动程序

这是一个网站有所有小节的代码实现,同时也包含了Bochs等文件

13.1 硬盘及分区表

13.1.1 创建从盘及获取安装的磁盘数

要实现文件系统,必须先有个磁盘介质,虽然咱们己经有个虚拟磁盘 hd60M.img,但它只充当了启动盘的作用,仅用来存储内核,是个没有文件系统的裸盘( raw disk)

如同我们之前第一章创建主盘时一样,在bochs目录下:

创建磁盘

bin/bximage

然后在输入框依次输入以下,输入一个,按一次回车

1

hd

flat

80

hd80M.img

接下来,我们在bochsrc.disk文件中,写入

ata0-slave: type=disk, path="hd80M.img", mode=flat,cylinders=162,heads=16,spt=63
这样,bochs虚拟机启动时,就会识别这个磁盘并且自动挂载。

xp:用来查看物理地址处的值,eg:xp/b 0x475查看0x475处一个字节的值。这个0x475处存储的是主机上安装的硬盘数量。下面是成功安装了两个硬盘:
在这里插入图片描述

13.1.2 创建磁盘分区表

**文件系统是运行在操作系统中的软件模块,是操作系统提供的一套管理磁盘文件读写的方法和数据组织、存储形式,**因此,文件系统=数据结构+算法,哈哈,所以它是程序。它的管理对象是文件,管辖范围是分区,因此它建立在分区的基础上,每个分区都可以有不同的文件系统。咱们刚创建了磁盘而己,磁盘还是裸盘,即传说中的 raw disk,本节的任务是把刚创建的磁盘 hd80M.img 分区。

磁盘的物理结构:

  1. 盘片:类似光盘中的一个圆盘,上面布满了磁性介质。
  2. 扇区:扇区是硬盘读写的基本单位,它在磁道上均匀分布,与磁头和磁道不同,扇区从 1 开始编号扇区的大小字节数=256 × N. N为自然数,通常取2,因此扇区的大小为512字节
  3. 磁道:盘片上的一个个同心圈就是磁道,它是扇区的载体,每一个磁道由外向里从 0 开始编号
  4. 磁头:就是磁头,哈哈,可以粗略理解为磁带中的磁头一个盘片分为上下两个面,各面都有一个磁头,因此一个盘片包括两个磁头,磁头号就表示盘面,平时所说的盘面号就是磁头号
  5. 柱面:这些由不同盘面上的编号相同的磁道(这些编号相同的同心圆大小一致)从上到下所组成的圆柱体的回转面就称为柱面,因此柱面的大小等于盘面数(磁头数〉乘以每磁道扇区数。
  6. 分区:是由多个编号连续的柱面组成的,因此分区在物理上的表现是由某段范围内的所有柱面组成的通心环,并不是像“饼图”那种逻辑表示,当然若整个硬盘只有 1 个分区,那这个分区就是个所有柱面组成的圆柱体 。 分区不能跨柱面,也就是同一个柱面不能包含两个分区,一个柱面只属于一个分区,分区的起始和终止都落在完整的柱面上,并不会出现多个分区共享同一柱面的情况,这就是所谓的“分区粒度”

在这里插入图片描述

  • 硬盘容量=单片容量 x 磁头数;
  • 单片容量=每磁道扇区数 x 磁道数 x 512;

磁道数又等于柱面数:硬盘容量=每磁道扇区数 x 柱面数 x 512 x 磁头数;

下面是hd80M.img的分区布局图:

在这里插入图片描述

13.2 编写硬盘驱动程序

13.2.1 硬盘初始化

硬件是实实在在的东西,要想在软件中管理它们,只能从逻辑上抓住这些硬件的特性,将它们抽象成一些数据结构,然后这些数据结构便代表了硬件,用这些数据结构来组织硬件的信息及状态,在逻辑上硬件就是这数据结构。硬盘也是“实在”的东东,为了管理它们还是得将它们抽象成某些数据结构,这就是本节的任务之一。

硬盘上有两个 ata 通道,也称为 IDE 通道。第 1 个 ata 通道上的两个硬盘(主和从)的中断信号挂在 8259A 从片的 IRQ14 上,第 2 个 ata 通道接在 8259A 从片的 IRQ15 上,该 ata 通道上可支持两个硬盘 。 来自 8259A从片的中断是由 8259A 主片帮忙向处理器传达的, 8259A 从片是级联在 8259A 主片的 IRQ2 接口的,因此为了让处理器也响应来自 8259A 从片的中断,屏蔽中断寄存器必须也把 IRQ2 打开.

由于我们的两个磁盘都是挂在了IDE通道0上,而IDE通道0又是挂在了IRQ14线上,所以我们只需要再打开这条线的中断信号就行

/* 初始化可编程中断控制器8259A */
static void pic_init(void) {

   /* 初始化主片 */
   outb (PIC_M_CTRL, 0x11);   // ICW1: 边沿触发,级联8259, 需要ICW4.
   outb (PIC_M_DATA, 0x20);   // ICW2: 起始中断向量号为0x20,也就是IR[0-7] 为 0x20 ~ 0x27.
   outb (PIC_M_DATA, 0x04);   // ICW3: IR2接从片. 
   outb (PIC_M_DATA, 0x01);   // ICW4: 8086模式, 正常EOI

   /* 初始化从片 */
   outb (PIC_S_CTRL, 0x11);	// ICW1: 边沿触发,级联8259, 需要ICW4.
   outb (PIC_S_DATA, 0x28);	// ICW2: 起始中断向量号为0x28,也就是IR[8-15] 为 0x28 ~ 0x2F.
   outb (PIC_S_DATA, 0x02);	// ICW3: 设置从片连接到主片的IR2引脚
   outb (PIC_S_DATA, 0x01);	// ICW4: 8086模式, 正常EOI

 
   outb (PIC_M_DATA, 0xf8);    //IRQ2用于级联从片,必须打开,否则无法响应从片上的中断主片上打开的中断有IRQ0的时钟,IRQ1的键盘和级联从片的IRQ2,其它全部关闭
   outb (PIC_S_DATA, 0xbf);    //打开从片上的IRQ14,此引脚接收硬盘控制器的中断 

   put_str("   pic_init done\n");
}

在以前,我们内核态下进行打印一直用的console_put_xxx之类的函数,这很不方便,因为我们经常打印信息需要调用console_put_int, console_put_str, console_put_ch这三个函数配合使用。所以我们先来实现一个类似于用户态函数printf的内核态函数printk

/*
 * @Author: Adward-DYX 1654783946@qq.com
 * @Date: 2024-04-28 17:33:08
 * @LastEditors: Adward-DYX 1654783946@qq.com
 * @LastEditTime: 2024-05-06 12:59:59
 * @FilePath: /OS/chapter13/13.2/kernel/stdio-kernel.c
 * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
 */
#include "stdio-kernel.h"
#include "console.h"
#include "stdint.h"
#include "global.h"
#include "stdio.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);
}

创建硬盘相关的数据结构:

/*
 * @Author: Adward-DYX 1654783946@qq.com
 * @Date: 2024-04-28 17:37:39
 * @LastEditors: Adward-DYX 1654783946@qq.com
 * @LastEditTime: 2024-05-06 13:18:20
 * @FilePath: /OS/chapter13/13.2/device/ide.h
 * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
 */
#ifndef __DEVICE_IDE_H
#define __DEVICE_IDE_H

#include "stdint.h"
#include "list.h"
#include "bitmap.h"
#include "global.h"
#include "thread.h"
#include "sync.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; //i结点位图
    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通道*/
//port_base咱们这里只处理两个通道的主板,每个通道的
//端口范围是不一样的,通道1(Primary通道)的命令块寄存器端口范围是 Ox1FO~Ox1F7,控制块寄存器
//端口是 0x3F6,通道 2 ( Secondary 通道〉命令块寄存器端口范围是 Ox170~Ox177 ,控制块寄存器端口是0x376 
//通道 l 的端口可以以 0x1F0 为基数,其命令块寄存器端口在此基数上分别加上 0~ 7 就可以了,
//控制块寄存器端口在此基数上加上 0x206,同理,通道 2 的基数就是 0xl70 
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]; //一个通道上连接两个硬盘,一主一从
};

创建并初始化

#include "stdint.h"
#include "global.h"
#include "ide.h"
#include "debug.h"
#include "sync.h"
#include "stdio.h"
#include "stdio-kernel.h"
#include "interrupt.h"
#include "memory.h"
#include "debug.h"

/* 定义硬盘各寄存器的端口号,见书p126 */
#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寄存器的一些关键位,见书p128 */
#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        //指定为LBA寻址方式
#define BIT_DEV_DEV	0x10        //指定主盘或从盘,DEV位为1表示从盘,为0表示主盘

/* 一些硬盘操作的指令 */
#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(void){
    printk("ide_init start\n");
    uint8_t hd_cnt = *((uint8_t*)(0x475));  //获取硬盘的数量
    printk("   ide_init hd_cnt:%d\n",hd_cnt);
    ASSERT(hd_cnt > 0);
    list_init(&partition_list);
    channel_cnt = DIV_ROUND_UP(hd_cnt,2);   //一个 ide 通道上有两个硬盘,根据硬盘数量反推有几个 ide 通道
    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;  //从片8259A上倒数第二个中断引脚 硬盘,也就是ide0通道的中断向量号 , 0x20为起始中断号
                break;
            case 1:
                channel->port_base = 0x170; //ide1通道的起始端口号是0x170
                channel->irq_no = 0x20+15;  //从片上最后一个中断引脚,我们用来相应ide1通道上的硬盘中断
                break;
        }
        channel->expecting_intr = false;    //未向硬盘写入指令时不期待硬盘的中断
        lock_init(&channel->lock);

        /*初始化为0,目的是向硬盘控制器请求数据后,硬盘驱动sema_down此信号量会阻塞线程,直到硬盘完成后通过发中断,由中断处理程序将此信号量sema_up,唤醒线程*/
        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");
}

在物理地址0x475存储着主机上安装的硬盘数量,它是由BIOS检测并写入的。

13.2.2 实现thread_yied和idle线程

thread_yield 定义在也read.c 中,它的功能是主动把 CPU 使用权让出来,它与thread_block 的区别是thread_yield 执行后任务的状态是 TASK_READY,即让出 CPU 后,它会被加入到就绪队列中,下次还能继续被调度器调度执行,而 thread_block 执行后任务的状态是 TASK_BLOCKD,需要被唤醒后才能加入到就绪队列 , 所以下次执行还不知道是什么时候 。

硬盘是一个相对于CPU来说及其低速的设备,所以,当硬盘在进行需要长时间才能完成的工作时(比如写入数据),我们最好能让驱动程序把CPU让给其他任务。所以,我们来实现一个thread_yield函数,就是用于把CPU让出来。实质就是将调用者重新放入就绪队列队尾。

修改thread.c

/* 主动让出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);
}

thread_yield中有个关中断的操作,会不会导致切换后由于关闭中断,而不响应时钟中断导致一直运行在切换后的进程/线程中呢?其实并不会,我们讨论两种情况,一种是进程/线程第一次上机运行,一种是进程/线程之前已经运行过,但由于时间片到期而换下过处理器。对于前者,我们进程/线程第一次上机运行都会经过kernel_thread这个线程启动器,而这个里面是有开中断的代码的。对于后者,当切换回进程/线程时,它们执行kernel.S中的中断退出代码jmp intr_exit,这里面有一条指令iretd会打开中断,让处理器能够继续响应中断代理发送来的中断信号。

接下来我们实现一个idle线程,用于在就绪队列为空时运行。需要注意一点:我们之前没有idle线程,我们的系统没有出现书上说的由于就绪队列为空然后被ASSERT(!list_empty(&thread_ready_list);悬停的情况,是因为我们的主线程(简单理解,就是main函数里面的while(1))会一直被不断加入就绪队列,所以就绪队列并不存在为空的时候。

修改thread.c

struct task_struct* idle_thread;    // idle线程

/* 系统空闲时运行的线程 */
static void idle(void* arg UNUSED) {
   while(1) {
      thread_block(TASK_BLOCKED);     
      //执行hlt时必须要保证目前处在开中断的情况下,hlt是停止处理器将进入暂停状态,直到发生硬件中断
      asm volatile ("sti; hlt" : : : "memory");
   }
}


/* 实现任务调度 */
void schedule() {
   ASSERT(intr_get_status() == INTR_OFF);
   struct task_struct* cur = running_thread(); 
   if (cur->status == TASK_RUNNING) { // 若此线程只是cpu时间片到了,将其加入到就绪队列尾
      ASSERT(!elem_find(&thread_ready_list, &cur->general_tag));
      list_append(&thread_ready_list, &cur->general_tag);
      cur->ticks = cur->priority;     // 重新将当前线程的ticks再重置为其priority;
      cur->status = TASK_READY;
   } 
   else { 
      /* 若此线程需要某事件发生后才能继续上cpu运行,
      不需要将其加入队列,因为当前线程不在就绪队列中。*/
   }

      /* 如果就绪队列中没有可运行的任务,就唤醒idle */
   if (list_empty(&thread_ready_list)) {
      thread_unblock(idle_thread);
   }

   ASSERT(!list_empty(&thread_ready_list));
   thread_tag = NULL;	  // thread_tag清空
/* 将thread_ready_list队列中的第一个就绪线程弹出,准备将其调度上cpu. */
   thread_tag = list_pop(&thread_ready_list);   
   struct task_struct* next = elem2entry(struct task_struct, general_tag, thread_tag);
   next->status = TASK_RUNNING;
   process_activate(next); //激活任务页表
   switch_to(cur, next);   
}


/* 初始化线程环境 */
void thread_init(void) {
   put_str("thread_init start\n");
   list_init(&thread_ready_list);
   list_init(&thread_all_list);
   lock_init(&pid_lock);
/* 将当前main函数创建为线程 */
   make_main_thread();
      /* 创建idle线程 */
   idle_thread = thread_start("idle", 10, idle, NULL);
   put_str("thread_init done\n");
}

13.2.3 实现简单的休眠函数

硬盘和 CPU 是相互独立的个体,它们各自并行执行,但由于硬盘是低速设备,其在处理请求时往往消耗很长的时间(不过手册上说最慢的情况也能在 31 秒之内完成),为避免浪费 CPU 资源,在等待硬盘操作的过程中最好把 CPU 主动让出来,让 CPU 去执行其他任务,为实现这种“明智”的行为,我们在 timer.c中定义休眠函数,当然这只是简易版,精度不是很高,能达到目的就可以了

之前我们实现的thread_yield是将当前任务加入就绪队列队尾,仅仅是把CPU让出来一次。我们来实现一个定时让出CPU的函数,也就是让一个任务在固定时间内都不执行。

修改timer.c

#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   1秒= 1000毫秒 */
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); 
}
13.2.4 完善硬盘驱动程序

在这里插入图片描述

现在,我们来实现驱动程序的主体部分,也就是实际与硬盘打交道的函数,实质就是将一系列寄存器操作进行封装

/*
 * @Author: Adward-DYX 1654783946@qq.com
 * @Date: 2024-04-29 09:54:07
 * @LastEditors: Adward-DYX 1654783946@qq.com
 * @LastEditTime: 2024-05-06 13:17:42
 * @FilePath: /OS/chapter13/13.2/device/ide.c
 * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
 */
#include "ide.h"
#include "stdint.h"
#include "global.h"
#include "list.h"
#include "bitmap.h"
#include "debug.h"
#include "stdio.h"
#include "thread.h"
#include "sync.h"
#include "io.h"
#include "timer.h"
#include "string.h"
#include "stdio-kernel.h"


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

/*reg_alt_status寄存器的一些关键位*/
#define BIT_ALT_STAT_BSY    0x80    //硬盘忙
#define BIT_ALT_STAT_DRDY   0x40    //驱动器准备好了
#define BIT_ALT_STAT_DRQ    0x8    //数据传输准备好了
#define BIT_ALT_STAT_ERR    0x1    //有错误发生

/*device寄存器的一些关键位*/
#define BIT_DEV_MBS 0xa0        //第7位和第5位固定位1
#define BIT_DEV_LBA 0x40        //指定为LBA寻址方式
#define BIT_DEV_DEV 0x10        //主盘还是从盘 现在为1是从盘,为0表示主盘

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

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

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


/*选择读写的硬盘*/
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); //如果 sec_cnt 为 0 ,贝Jj表示写入 256 个扇区

    /*写入lba地址,即扇区号*/
    outb(reg_lba_l(channel),lba);   //lba 地址的低8位,不用单独取出低8位,outb 函数中的汇编指令 outb %b0,%w1会只用al
    outb(reg_lba_m(channel),lba>>8); //lba地址的8-15位
    outb(reg_lba_h(channel),lba>>16); //lba地址的16-23位

    /*因为 lba 地址的第 24 ~27 位要存储在 device 寄存器的0-3 位,无法单独写入这 4 位,所以在此处把 device 寄存器再重新写入一次*/
    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){
        /*因为 sec_cnt 是自位变量,由主调函数将其赋值时,若为 256 则将最高位的 1 丢掉变为 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){
        /*因为 sec_cnt 是自位变量,由主调函数将其赋值时,若为 256 则将最高位的 1 丢掉变为 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_ALT_STAT_BSY))
            return (inb(reg_status(channel))&BIT_ALT_STAT_DRQ);
        else    
            mtime_sleep(10);        //睡眠10毫秒
    }
    return false;
}

/*硬盘读取 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);    //准备开始读取数据

        /*******************  阻塞自己的时机  ****************************
         * 在硬盘已经开始工作(开始在内部读数据或写数据)后才能阻塞自己,
         * 现在硬盘已经开始忙了,将自己阻塞,等待硬盘完成读操作后通过中断处理程序唤醒自己
        */
       /*硬盘完成操作后会发中断信号,后面介绍的硬盘中断处理程序 intr_hd_handler 会在该通道上执行“ sema_up(&channel->disk_done)”,从而唤醒当前的驱动程序*/
        sema_down(&hd->my_channel->disk_done);

        /*4 检查硬盘转改是否可读*/
        /*醒来后开始执行下面的代码*/
        if(!busy_wait(hd)){ //若失败
            char error[64];
            sprintf(error,"%s read sector %d failed!!!!!!",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!!!!!!",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);
    /*不必担心此中断是否对应的是这一次的 expecting_intr,每次读写硬盘时会申请锁,从而保证了同步一致性*/
    if(channel->expecting_intr){
        channel->expecting_intr = false;
        sema_up(&channel->disk_done);

        /*读取状态寄存器使硬盘控制器认为此次的中断已被处理,从而硬盘可以继续执行新的读写*/
        inb(reg_status(channel));
    }
}


/*硬盘数据结构初始化*/
void ide_init(void){
    printk("ide_init start\n");
    uint8_t hd_cnt = *((uint8_t*)(0x475));  //获取硬盘的数量
    printk("   ide_init hd_cnt:%d\n",hd_cnt);
    ASSERT(hd_cnt > 0);
    list_init(&partition_list);
    channel_cnt = DIV_ROUND_UP(hd_cnt,2);   //一个 ide 通道上有两个硬盘,根据硬盘数量反推有几个 ide 通道
    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;  //从片8259A上倒数第二个中断引脚 硬盘,也就是ide0通道的中断向量号 , 0x20为起始中断号
                break;
            case 1:
                channel->port_base = 0x170; //ide1通道的起始端口号是0x170
                channel->irq_no = 0x20+15;  //从片上最后一个中断引脚,我们用来相应ide1通道上的硬盘中断
                break;
        }
        channel->expecting_intr = false;    //未向硬盘写入指令时不期待硬盘的中断
        lock_init(&channel->lock);

        /*初始化为0,目的是向硬盘控制器请求数据后,硬盘驱动sema_down此信号量会阻塞线程,直到硬盘完成后通过发中断,由中断处理程序将此信号量sema_up,唤醒线程*/
        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");
}

select_disk接受一个参数,硬盘指针hd,功能是选择待操作的硬盘是主盘或从盘 。原理是利用device寄存器中的 dev 位,该位为 0 表示是通道中的主盘,为 1 表示是通道的从盘。最后通过 outb 函数将变量 reg_device 写入硬盘所在通道的device 寄存器,这样就完成了主盘或从盘的选择。

select_sector接受3个参数,硬盘指针hd、扇区起始地址lba、扇区数sec_cnt,功能是向硬盘控制器写入起始扇区地址及要读写的扇区数 。

cmd_out:向通道channel发命令cmd,即写入操作命令(读或者写)

read_from_sector:硬盘读入sec_cnt个扇区的数据到buf

write2sector:将buf中的sec_cnt扇区的数据写入硬盘

busy_wait :通过BIT_ALT_STAT_BSY 判断 status 寄存器的 BSY 位是否为 1 ,如果为 1 ,则表示硬盘繁,这时候就调用 mtime_sleep(10)去休眠 10 毫秒。如果 BSY 位为 0 则表示硬盘不忙,接着在再次读取status寄存器,返回其 DRQ 位的值, DRQ 位为 1 表示硬盘己经准备好数据了。

对于读硬盘来说,驱动程序阻塞自己是在硬盘开始读扇区之后,对于写硬盘来说,驱动程序阻塞自己是在硬盘开始写扇区之后。总之,阻塞的时机一定是在硬盘开始真正忙活之后的那段“漫长”的时间里

13.2.5 获取硬盘信息,扫描分区表

本节该是检验它们的时候了,咱们用两件工作来验证,一是向硬盘发 identify 命令获取硬盘的信息,二是扫描分区表。

在这里插入图片描述

Linux中所有的设备都在/dev/目录下,硬盘命名规则是[x]d[y][n],其中只有字母 d 是固定的,其他带中括号的字符都是多选值,下面从左到右介绍各个字符。

x:表示硬盘分类,硬盘有两大类, IDE 磁盘和 SCSI 磁盘。h代表 IDE 磁盘, s代表 SCSI 磁盘,故 x取值为h和s.

d:表示disk,即磁盘

y:表示设备号,更多操作以区分第几个设备,取值范围是小写字符,其中a是第1个硬盘,b是第2个硬盘依此类推。

n:表示分区号。也就是一个硬盘上的第几个分区。分区以数字 1开始,依次类推。

咱们这里统一用 SCSI 硬盘的命名规则来命名虚拟硬盘hd60M.img 和 hd80M且恕。其中 hd60M.img 为 sda, hd80M.img 为 sdb o hd60M.img 是裸盘,没有文件系统和分区,因此咱们只处理 hd80M.img,将其上的主分区占据 sdb【1 ~4】,逻辑分区占据 sdb【5~】。

修改ide.c

/*用于记录总扩展分区的起始 lba ,初始为 O, partition_scan 时以此为标记*/
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];    //分区表中有四项,供六十四字节
    uint16_t signature; //启动扇区的结束标志是 Ox55,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);
}

/*扫描硬盘 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表示是第一次读取引导块,页就是主引导记录所在的扇区

                /*记录下扩展分区的起始lba地址,后面所有扩展分区地址都相对于此*/
                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);   //0,1,2,3
            }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)    // 只支持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);

    /*在此处 return false与函数本身功能无关,只是为了让主调函数 list_traversal 继续向下遍历元素*/
    return false;  
}

swap_pairs_bytes:用来处理identify命令的返回信息,硬盘参数信息是以字为单位的,包括偏移、长度的单位都是字,在这16位的字中,相邻字符的位置是互换的,所以通过此函数来做转换。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1886344.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

理解MySQL存储引擎:掌握数据存储与管理

在工作或学习过程中&#xff0c;作为一名数据库管理员或开发者&#xff0c;我们常常需处理大量数据&#xff0c;同时确保数据的可靠性与高效性。MySQL作为最受欢迎的开源数据库之一&#xff0c;其强大的性能和灵活性广为人知。而在MySQL背后的存储引擎则起到了至关重要的作用。…

深度学习项目GPU开发环境安装

注安装环境&#xff1a;ubuntu22.04, cuda 11.7, cudnn8.9 1.安装nvidia驱动 看可安装的Nvidia驱动版本&#xff1a;执行 ubuntu-drivers devices 安装合适版本的Nvidia驱动&#xff1a; sudo apt-get install nvidia-driver-515 注意&#xff1a;合适的版本需要尝试&#x…

【区块链+基础设施】银联云区块链服务 | FISCO BCOS应用案例

为了顺应区块链基础设施化的发展趋势&#xff0c;中国银联推出了银联云区块链服务——UPBaaS&#xff0c;为金融行业采用区块链 技术提出了解决方案&#xff0c;微众银行为平台提供 FISCO BCOS 区块链开源技术支持。通过银联云区块链服务&#xff0c;用户可 以用可视化的方式创…

ERROR: No matching distribution found for torch==2.0.1+cu117(比手动下载方便)

ERROR: No matching distribution found for torch2.0.1cu117 遇见这种报错可以把pip install -r requirements.txt修改为 pip install -r requirements.tx --extra-index-url https://download.pytorch.org/whl/cu117 -i https://pypi.tuna.tsinghua.edu.cn/simple或者直接…

ROS2仿真工具-gazebo

gazebo独立于ROS2&#xff0c;就像插件一样&#xff0c;需要安装。 1.安装 sudo apt install gazebo sudo apt install ros-humble-gazebo-* 2.运行测试demo gazebo /opt/ros/humble/share/gazebo_plugins/worlds/gazebo_ros_diff_drive_demo.world 查看所有话题 ros2 top…

vue3开发过程中遇到的一些问题记录

问题&#xff1a; vue3在使用 defineProps、defineEmits、defineExpose 时不需要import&#xff0c;但是 eslint会报错error defineProps is not defined no-undef 解决方法&#xff1a; 安装 vue-eslint-parser 插件&#xff0c;在 .eslintrc.js 文件中添加配置 parser: vue-e…

交叉编译tslib库和上机测试

目录 一、tslib 介绍 二、tslib 框架分析 三、交叉编译、测试 tslib 1.安装工具链 tslib &#xff08;1&#xff09;设置交叉编译工具链 &#xff08;2&#xff09;进入tslib目录 &#xff08;3&#xff09;安装工具链 &#xff08;4&#xff09;确定工具链中头文件、库…

高考志愿填报,AI搜索商业化的第一个金矿?

文&#xff1a;互联网江湖 作者&#xff1a;志刚 前几天高考放榜&#xff0c;很多朋友都在忙着给孩子或者亲戚家孩子报志愿&#xff0c;高考志愿咨询也火得一塌糊涂&#xff0c;张雪峰的志愿咨询产品也卖出了天价。 今年高考前夕&#xff0c;网红张雪峰旗下的“峰学蔚来”APP…

用Vue3和Plotly.js打造一个3D图在线展示

本文由ScriptEcho平台提供技术支持 项目地址&#xff1a;传送门 三维网格图的绘制 应用场景 三维网格图广泛应用于科学可视化、医学成像、工程设计等领域&#xff0c;用于展示复杂的数据结构和空间分布。 基本功能 本代码使用 Plotly.js 库创建了一个交互式三维网格图&am…

IDEA 好用的插件,必备的插件

1. GitToolBox 菜单栏显示git分支信息 2.MyBatisx 快速定位找到sql的xml文件 3.RestfulToolkit-fix 快速定位接口的插件 默认快捷键: CtrlAltN 4.EasyCamelQSM 字符串转驼峰 默认快捷键: Ctrl Alt Q 5.Maven Helper 检查maven冲突&#xff0c;图形化展示maven依赖的插…

非静压模型SWASH学习(8)——三维孤立波在锥形岛屿上的爬坡过程(Runup of solitary waves on a conical island)

三维孤立波在锥形岛屿上的爬坡过程&#xff08;Runup of solitary waves on a conical island&#xff09; 算例简介模型配置网格及参数设置网格与地形初始条件与边界条件数值求解方法输出设置模拟时间 波浪&#xff08;孤立波&#xff09;入射边界的时间序列.bnd文件模拟结果注…

调试支付分回调下载平台证书

之前的原生代码放到webman里面&#xff0c;死活跑不通 没办法&#xff0c;只能用esayWeChat6.7 &#xff08;自行下载&#xff09; 它里面配置要用到平台证书 平台证书又要用到 composer require wechatpay/wechatpay 但是请求接口之前&#xff0c;你先要用到一个临时的平台…

[Python学习篇] Python函数

定义函数 语法&#xff1a;使用关键字 def def 函数名(参数): 代码1 代码2 ...... 调用函数 语法&#xff1a; 函数名(参数) 注意&#xff1a;不同的需求&#xff0c;参数可有可无。在Python中&#xff0c;函数必须先定义后使用 示例&#xff1a; # 定义函数 d…

边缘计算网关在现代工业企业中的作用-天拓四方

随着工业4.0时代的到来&#xff0c;数字化转型已经成为工业企业发展的必然趋势。在这一过程中&#xff0c;边缘计算网关以其独特的优势&#xff0c;正逐渐成为工业企业实现智能化、高效化运营的关键技术。 边缘计算网关是一种部署在网络边缘的设备&#xff0c;它集成了计算、存…

每日一题——Python实现PAT乙级1100 校庆(举一反三+思想解读+逐步优化)五千字好文

一个认为一切根源都是“自己不够强”的INTJ 个人主页&#xff1a;用哲学编程-CSDN博客专栏&#xff1a;每日一题——举一反三Python编程学习Python内置函数 Python-3.12.0文档解读 目录 我的写法 代码结构和逻辑 时间复杂度分析 空间复杂度分析 总结 我要更强 方法一…

RK3568驱动指南|第十五篇 I2C-第181章使用GPIO模拟I2C驱动

瑞芯微RK3568芯片是一款定位中高端的通用型SOC&#xff0c;采用22nm制程工艺&#xff0c;搭载一颗四核Cortex-A55处理器和Mali G52 2EE 图形处理器。RK3568 支持4K 解码和 1080P 编码&#xff0c;支持SATA/PCIE/USB3.0 外围接口。RK3568内置独立NPU&#xff0c;可用于轻量级人工…

一个能让渲染性能提高100倍的办法

GPU 光线追踪是当今的热门话题&#xff0c;所以让我们来谈谈它&#xff01;今天我们将光线追踪一个单个球体。 使用片段着色器。 是的&#xff0c;我知道。并不特别花哨。你可以在 Shadertoy 上搜索并获得数百个示例(https://www.shadertoy.com/results?querysphere)。甚至已…

速通RK3568开发板多网口网线直连测试

开源鸿蒙硬件方案领跑者 触觉智能 本文适用于在EVB3568开发板上进行多网口网线直连。触觉智能的EVB3568主板基于瑞芯微RK3568处理器&#xff0c;采用22nm先进工艺制程&#xff0c;四核A55 CPU&#xff0c;主频高达2.0GHz&#xff0c;支持高达8GB高速LPDDR4&#xff0c;1T算力N…

Linux miniconda 安装tensorflow-gpu遇到找不到GPU问题

背景&#xff1a; Linux Miniconda python3.9 安装步骤 1、 pip install tensorflow-gpu2.8.0 -i https://pypi.tuna.tsinghua.edu.cn/simple 2、报错如下&#xff1a; 更换镜像源&#xff0c;单独安装 pip install tf-estimator-nightly2.8.0.dev2021122109 -i https:/…

【C语言】typedef 关键字

在C语言中&#xff0c;typedef关键字用于给现有的数据类型起一个新的名字。它在提高代码可读性、简化复杂类型声明、增强可维护性方面非常有用。typedef通常用于定义结构体、指针、函数指针以及其他复杂类型。 基本用法 typedef int MyInt; MyInt x 10;在这个例子中&#xf…