原创 实现一个最简单的嵌入式操作系统(一)

实现一个什么都不能做的嵌入式操作系统

1.首先确定CPU，在这里为了简单，就选用嵌入式的CPU，比如ARM系列，之所以用RISC（简单指令集）类型的CPU，其方便之处是没有实模式与保护模式之分，采用线性的统一寻址，也就是不需要进行段页式内存管理，还有就是芯片内部集成了一些常用外设控制器，比如以太网卡，串口等等，不需要像在PC机的主板上那么多外设芯片
2.确定要实现的模块和功能，为了简单，只实现多任务调度（但有限制，比如最多不超过10），实现中断处理（不支持中断优先级），不进行动态SHELL交互，不实现动态模块加载，不实现fork之类的动态进程派生和加载（也就是说要想在你的操作系统上加入用户程序，只能静态编译进内核中；不支持文件系统，不支持网络，不支持PCI，USB，磁盘等外设（除了支持串口，呵呵，串口最简单嘛），不支持虚拟内存管理（也就是说多任务中的每个进程都可以访问到任何地址，这样做的话，一个程序
死了，那么这个操作系统也就玩完了）
3.确定要使用的编译器，这里采用GCC，文件采用ELF格式，当然，最终的文件就是BIN格式，GCC和LINUX有着紧密的联系，自己的操作系统，需要C库支持和系统调用支持，所以需要自己去裁剪C库，自己去实现系统调用
4.实现步骤：首先是CPU选型，交叉编译环境的建立，然后就是写BOOTLOADER，写操作系统

 
 
实现一个最简单的嵌入式操作系统(二）　　
如何实现BOOTLOADER

1.之所以要实现一个专用的BOOTLOADER，一是为了更好的移植和自身的升级，二是为了方便操作系统的调试，当然，你完全可以将这部分所要实现的与操作系统相关的功能集成到操作系统中去
2.确定一个简单的BOOTLOADER所要完成的功能：我们这里只需要完成两个主要功能，一是将操作系统加载到内存中去运行，二是将自己和操作系统内核固化到ROM存储区（这里的ROM可以是很多设备，比如嵌入式芯片中的FLASH，PC机上的软盘，U盘，硬盘等）

3.BOOTLOADER的编写：
第一步：要进行相关硬件的初使化，比如在at91rm9200这块嵌入式板子上（以后都使用这一款芯片，主要是我对这款芯片比较熟悉，嘿嘿），大概要做接下来的几方面的工作，其一：将CPU模式切换进系统模式，关闭系统中断，关闭看门狗，根据具体情况进行内存区域映射，初始化内存控制区，包括所使用的内存条的相关参数，刷新频率等，其二：设定系统运行频率，包括使用外部晶振，设置CPU频率，设置总线频率，设置外部设备所采用的频率等。其三：设置系统中断相关，包括定时器中断，是否使用FIQ中断，外部中断等，还有就是中断优先级设置，这里只实现两个优先级，只有时钟中断高一级，其它都一样，而中断向量初始化时都将这些中断向量指向0x18处，并关闭这里的所有中断，如果板子还接有诸如FLASH设备的话，还需要设置诸如FLASH相关操制寄存器，其四：需要关闭CACHE，到此为止，芯片相关内容就完成初始化了

第二步：中断向量表，ARM的中断与PC机芯片的中断向量表有一点差异，嵌入式设备为了简单，当发生中断时，由CPU直接跳入由0x0开始的一部分区域（ARM芯片自身决定了它中断时就会跳入0x0开始的一片区域内，具体跳到哪个地址是由中断的模式决定的，一般用到的就是复位中断，FIQ，IRQ中断，SWI中断，指令异常中断，数据异常中断，预取指令异常中断），而当CPU进入相应的由0x0开始的向量表中时，这就需要用户自己编程接管中断处理程序了，这就是需要用户自己编写中断向量表，中断向量表里存放的就是一些跳转指令，比如当CPU发生一个IRQ中断时，就会自动跳入到0x18处，这里就是用户自己编写的一个跳转指令，假如用户在此编写了一条跳转到0x20010000处的指令，那么这个地址就是一个总的IRQ中断处理入口，一个CPU可能有多个IRQ中断，在这个总的入口处如何区分不同的中断呢？就由用户编程来决定了，具体实现请参见以后相关部分，中断向量表的一般用一个vector.S文件，当然，如何命名那是你自己的喜爱，但有一点需要声明，那就是在链接时一定要将它定位在0x0处


第三步：设置堆栈，一般使用三个栈，一个是IRQ栈，一个是系统模式下的栈（系统模式下和用户模式共享寄存器和内存空间，这主要是为了简单），设置栈的目的主要是为了进行函数调用和局部变量的存放，不可能全用汇编，也不可能不用局部变量


第四步：将自己以后的代码段和数据段全部拷贝至内存，并将BSS段清零


第五步：进行串口的初始化（主要是为了与用户交互，进行与PC机的文件传输），FLASH的初始化这里在FLASH中存放BOOT和内核），FLASH驱动的编写（这里的驱动有别于平常所说的驱动，由于FLASH不像SDRAM，只要设定了相关控制器之后就可以直接读写指定地址的数据，对FLASH的写操作是一块一块数据进行，而不是一个字节一个字节地写，具体请查阅相关资料）
第六步：等待一定的秒数，来接收用户进行输入，如果在指定的秒数内用户未输入任何字符，那么
BOOT就开始在FLASH中的指定位置（可以由自己指定，这么做主要是为了简单）读取内核的所有数据到内存中（具体是内存中的什么位置由自己指定，也可以采用LINUX之类的做法，就是在内存的起始位置加上一个0x8000处），将跳转到内核的第一条代码处）；如果用户在指定的秒数内键入了字符（这主要是为了方便开发，如果开发定型之后完全可以不要这段代码），那么就在串口与用户进行交互，接受用户在串口输入的命令，比如用户要求下载文件在FLASH中指定的位置等，具体内容可参考U-BOOT之类的开源项目到这里为止，BOOT部分已完成，这个BOOT非常简单，仅仅只是将PC机上传下来的文件固化到FLASH中，然后再将FLASH中的操作系统内核部分加载进内存中，并将CPU的控制权交给操作系统，下一页开始讲解如何写一个最简单的操作系统，呵，到现在才开始切入正题呢！！！！

 
实现一个最简单的嵌入式操作系统(三）　　
如何实现一个最简单的操作系统

这里为了简单，就不考虑可移植性开求，不从BOOT部分来接收参数，也不对硬件进行检测，
也不需要进行DATA段，代码段的重定位。我只是读了LINUX内核相关部分，并未自己去实现
一个操作系统，所以我以下所说的只是概念性的东西：


1.接管系统的中断处理，由于BOOT部分的代码决定了那个中断向量表，从而决定了系统中断
之后进入的内存位置，但BOOT并不知道操作系统的中断处理函数位置所在啊，怎么办呢？
有几种方法，其一是：如果你的板子可以重映射地址，也就是可以将内存条所在的位置
重映射成0x0开始，那么在链接内核的时候，就将操作系统自己的中断向量表定位在0x0处
并且在BOOTLOADER引导结束时就完成映射操作，并让CPU跳转到0x0处执行；如果没有重映
射功能，我就不晓得怎么办了，不过我想到一个折衷的办法，就是在BOOTLOADER启动完成
时（也就是将CPU控制权交给操作系统内核时），重新改写FLASH的0x0区域，就是将操作
系统的内核的中断向量表写入FLASH区的0x0处，比如，当一个IRQ发生时，CPU决定了会
跳入0x18（假设这里FLASH占用地址总线0x0至0x0fffffff,内存占用0x20000000至0x2fffffff）
，而BOOTLOADER在最后将0x18处的代码修改成了0x20000000加上0x18的地址处的代码，而这个
地址就是内核的中断向量表中的相关跳转指令，就相当于跳转进了内核所关联的IRQ处理函数
的地址上去执行中断处理函数了，而这样的不好之处在于：当系统重新上电之后，BOOT的
中断向量表已经被修改，除非BOOT本身不使用中断，呵，在这样简单的系统中，BOOT是不
需要中断功能的

2.这里为了简单，所以没有使用分页内存管理，就不需要建立页表等操作，直接进行操作
系统的堆栈设置，同BOOT一样的设置过程一样，接着就进行BSS段清零操作，这里的BSS段
是指操作系统自身的BSS段，与BOOT的BSS段是同一个含义只是用在了不同的地方了，接着
就跳入了MAIN函数

3.为了最大可能的简单，采用静态建立任务结构数组，比如只建立十个任务，那么首先要
为这十个任务结构分配段内存，可以在堆上分配（这个分配的内存直到操作系统结束才会
被释放，当然也可以指定一片操作系统的其它地方都用不到的内存区域，不过这样写的话
就有点外行的味道了，而符务结构数组的指针却是全局变量，存放在BSS段或者DATA段），
由于在上一步中已经分配了一个系统堆栈，那么我们这十个任务就分享这总体的堆栈区域
这里的重点就是如果定义每个任务结构数组里面的结构，可以参照LINUX的相关部分设计

4.中断处理：在第一步中已经确定了CPU进行相关的几类型的中断跳转地址，而相同类型
的中断却只有一个入口地址，这里的中断处理就会完成以几个动作：
其一：入栈操作，包括所有寄存器入栈，至于这个栈，就是在第二步中所设置的IRQ栈，
其二：屏掉所有中断，呵，这里为了简单起见，所以在处理中断时不允许再次发生中断
其三：读取中断相关的寄存器，判别是发生了什么中断，以至于跳进相关的中断处理函
数中去执行（在这里只包括两种中断，一是时钟中断，另一个是SWI中断，也就是所谓
的系统调用时需要用到的）
其四：等待中断处理完成，然后就开启中断并出栈，恢复现场，将CPU控制权交给被中断
的代码处
注意：
其一：在MIAN中必须首先确定整个系统有哪些需要处理的中断，也就是有哪些中断处理
函数，然后才编写这里的中断处理函数
其二：本操作系统不处理虚拟内存，其至连CPU异常都不处理（一切都为了简单），一旦
发生异常，系统就死机

5.对TIMER的实现，首先确定时间片，为了让系统更稳定，而且我们不需要实时功能，尽
可能让时间片设置长一点，比如我们让一个任务运行20个时钟滴答数，然后应根据系统
频率来确定每个系统滴答所占用的毫秒，这里使用5毫秒让系统定时器中断一次，那么就
需要写时钟寄存器，具体参阅芯片资料，计算下来，一个任务最大可能连续运行100毫秒
，注意：我们的操作系统不支持内核抢占，同时只支持两级中断优先级，就是只有时钟
中断的优先级高一点，其它的优先级都低一级，但是在中断处理一节中却屏掉了这个功能
因为一进入中断处理，就禁止中断，所以不管其它中断优先级有多高都没有用的，这样做
优点是简单了，但不好之处显而易见，特别在相关中断处理函数如果进入了死循环，那么
整个系统就死了，而且时间片也变得不准确了，反正都不用实时，也不需要实时钟支持嘛
至于中断优先级设置请参阅芯片资料


6.进程调度的实现，也就是do_timer函数（时钟中断处理函数），有一个全局变量指针，
指向的就是当前任务结构数组（或者链表），当时钟中断时，就进入此函数中，首先判断
任务结构体中的时间片是否用完，如未用完，就减一，然后退出中断，让CPU继续运行当
前的任结构，若用完了时间片，就重置时间片，并重新寻找任何结构数组中的下一个等待
运行的任务，若找到了，就切换至新的任务，至于如何切换，请见下一页描述，如果未找
到就切换到IDLE任务（类似于LINUX，呵呵，所有的处理就是模仿LINUX，由于本人水平太
差，所就不能自创一招），注意：为了简单，所以没有实现任务优先级，也未实现任务
休眠等，也就是说只要静态地决定了有十个任务，这十个任务就按先后顺序一个一个执行
而且每个任务都不允许结束，就是说在每个进程中的最后一句代码都必须用死循环，不然
的话系统就跑飞了），还有一点，进程不支持信号，没有休眠与唤醒操作，这个CPU就是
不停地在运行，呵呵，反正CPU又不是人，所以不需要人权的哈！！！这种调度是不是简
单得不能再简单了？？？？？！！！！

7.串口不使用中断，这就是最大可能的降低难度，串口使用论询的方式来实现读写（当
然是阻塞的方式了哦，而且只有写，不允许读，因为读的时候需要涉及到采用中断方式，
因为轮询方式有个不好的地方，那就是正在读的时候，这里有可能当前进程的时间片用
完了，系统切换到另一个进程，这里你在PC机的串口输入的数据就丢弃了，唉，又是为
了简单嘛）

8，最后一步就是MIAN函数的最后一部分，将本进程当作IDLE进程（相当于修改任务结构
数组中的数据），开启中断，将当前进程加入一段死循环，以免它退出去。

9.编译你的BOOTLOADER，KERNEL，并烧写至FLASH，反复调试

10.至此将你的at91rm9200（或者是其它相类似的芯片）的串口接上PC机，打开超级终端，
打开板子电源，说不定你的操作系统就打印出了"hello,world"了！！！一个最简单的操作
系统就出来了

下一页是具体的功能模块实现

 
实现一个最简单的嵌入式操作系统(四）　　
任务结构数组（或链表）的实现

我们的任务结构就采用链表形式吧，但其长度是限定了的，头指针是一个全局指针变量（
指针变量是一个无符号整型指针，其指针本身所在的地址是在BSS段，但其指向的内容是分
配在堆上的一片内存），分配内核内存的函数就用kmalloc吧，kmalloc函数需要自己编写
呵，为了简单，这个函数只接受一个参数，就是所需分配大小，这个函数做得很简单，首先
有一个全局针指，它在初始化时指向了整个堆的起始位置，并且固定大小，就是所谓的内核
堆栈，在内核堆栈之后就是用户堆栈，由于总共有十个任务，当然不包括内核本身的任务，
所以整个堆栈就平均分成十一部分，注意：在所有任务初始化完成之后，还有一个步骤就是
将内核这个任务移到用户态，相当于要将自己的任务结构的堆栈指针修改一下就行了），
判断大小是否超出了内核堆的可分配范围，还有一点，需要维护内核堆和其它任务的堆，
需要进行分块，并且有一个全局的内存使用标识，就用数组吧，简单，0表示相应的内存
部分未占用，1就表示占用，对应的kfree就相当于把标志置0），
对于内存的维护，比较复杂，为了简单，就定为4K，并且不能进行大于四K的内存申请，因为
大于4K之后，由于没有虚拟地址的概念，就不能实现堆上的连续分配地址，当然在栈上分配
是可以大于4K的，栈是由编译器和CPU所决定了的

任务结构包括：
1.所剩的时间片
2.本任务所指向的代码段内存地址，这里也就是函数入口地址
3.本任务所指向的数据段地址，这里的数据段被包含进了整个内核中，所以并没有用，作为保留
4.本任务的函数体是否存在，也就是否会被调度
5.本任务所使用的栈指针
6.本任务所使用的堆指针
7.本任务的标识，用0代表是IDLE，1代表是其它进程
8.所有寄存器的值
9.当前PC值，初始化时被置成了函数入口地址

首先讲解一下任务数组结构的初始化：
将先定义一个全局指针，然后将此指针强制转换为一个任务结构指针，并通过kmalloc函在内核所
占用的堆（前而讲过内核的堆的起始就是整个堆的起始）上去分配十个任务结构所占的内存，这里
是绝不会超过4K的并且为这十个任务结构赋值，将第一个任务置为IDLE，时间片为20，代码段内存地址为main函数的的地址，数据段地址忽略，函数体存在，可以被调度，栈指针指向的位置根据以下来计算：
假定每个给每个任务可使用的堆栈设定为64K，而整个堆的起始位置是0x20030000,那么第一个堆指针所指向的就是0x20030000,栈就是0x20030000+64K的位置，第二个以后就以此类推
注意：在初始化任务结构之前，不允许系统使用堆，但可以使用栈，那么内核任务栈部分就分成了
两个，在未进行调度之前，栈就是上一页中第二步中所设的栈，那么上一页设置堆栈的时候就得注
意必须将堆栈空间设成十个64K再加上在本步骤使用以前的最大可能所需的栈空间


再讲解一下任务切换时所要做的事情：
进入整个中断处理入口时，会将所有寄存器推入IRQ栈之中，并把值拷贝到当前任务结构相应的字段当中，并取出被中断的进程的当前PC值存入当前任务结构中的相应字段中，接下就判别中断类型，以进入相应的中断处理函数，这里就会进入do_timer函数中，以下就是进入此函数之后的流程：
内核中还有一个全局指针，就是当前任务指针，它本身也是在系统BSS段中，它的定义如上一步中的那个全局指针一样，当由系统时钟中断之后，就取出这个全局指针，上一步初始化完成之后，还会把这个指针指向第一个任务结构所在位置，也就是0x20030000处，那么就取出这个任务结构中的时间片字段，判断其是否为0，若为0,就进行以下的操作：保存用户态下的栈指针至当前任务结构，保存堆指针，并将搜索一下可以被调度的任务结构，并将此任务结构赋给当前任务指针，置需要进行任务切换标识，此标识同样是一个全局变量，但它是被赋了初值，会放在整个系统的DATA段中，返回do_timer函数。若不为0，就进行以下操作：
将时间片减一，返回do_timer函数接下来判断任务切换标识，若为0，则进行以下操作：
不需要进行任务切换，所有寄存器出栈（这里的栈指的是IRQ栈），重新开启中断，切换到用户模式，加载当前任务结构中的当前PC值字段，以退出中断处理程序若此标识为1，则执行以下操作：
就需要进行任务切换，让所有寄存器出栈（这里的栈指的是IRQ栈），将当前任务结构中的所有寄
存器的值恢复到相应寄存器中，将用户态下的栈指针恢复至当前任务结构栈指针，将堆指针恢复至
当前任务结构堆指针，并把需要进行任务切换标识恢复为0，重新开启中断，切换到用户模式，任务切换是通过加载PC值来实现的，也就是通过加载当前任务结构中的当前PC值字段，以退出中断处理程序

系统调用的实现

本系统是完全可以不实现系统调用的，因为没有实现内核态和用户态的保护，完全可以不实现
自己的C库，所有的函数都像kmalloc之类的实现一样，在内核中直接写函数原型，但为了以后
扩展，还是说一下系统调用，这里以malloc系统调用来实现

首先说明还有一个堆指针（前面在kmalloc时有一个堆指针，不过那个堆指针是为内核任务，中
断处理所提供），这里这个堆指针是用于用户态的，它在系统初始化完成之前会赋上初值，其初
值就是第一个任务结构所使用的堆的起始位置，也就是在内核所使用的堆加上64K的位置
函数库中的malloc函数实现步骤如下：
1.首先检测申请大小是否超出了4K，若超出4K，就返回错误
2.进行系统调用（这里用_syscall1，并只传递一个参数（所需分配大小）
系统调用函数_syscall1的实现：
1.将寄存器压入堆栈（这里的栈指向就是当前任务的栈）
2.将系统调用号1放至R0，参数放入R1
3.发出SWI指令以产生SWI中断（就是所说的软中断，陷阱）
此时系统发生中断，会进入SWI中断处理入口，下面说一下SWI入口函数的实现
1.取出R0的值，判断其值，进入相应的分支处理代码段
2.在此进入_malloc处理代码段，取出R1的值，然后再得到前面所说的当前堆指针，并申请对应数
据块大小，置用于内存占用标识的相应字段，将当前堆指针放入R0,移动当前堆指针，改变当前任
务结构的堆指针，切换到用户态，返回SWI中断系统调用_syscall1的返回处理：
为了简单，在从内核态返回用户态时，不再进行任务的重新调度，所以上面的步骤就相对简单
1.当从SWI中断返回后，系统就运行在了用户态，此时取出R0的值，并赋值给需要申请内存的指针
2.在用户态弹出寄存器，返回到上一层函数
malloc函数的返回，此时malloc函数直接返回指针就行了，整个malloc的流程就结束了，其它的系
统调用同这个过程类似

到此为止，这个操作系统初步实现了，但好像什么事情都不能做，如果让它支持串口中断的话，或许可以做那么一点点事情，比如像单片机那样的功能，整个系统的难点就是中断处理和任务切换，在本例中，由于ARM不支持像0x86那样的CPU级的保护模式，所以进行任务切换的时候，就得自己通过加载PC值的方法来实现，呵，因为我想不到更好的办法，但这个办法有一个不好解决的地方，就是寄存器入栈和出栈的保护，在进入中断时，必须保护寄存器，但如果需要进行重新调度，就得从中断上下文切换到进程上下文中，如何从中断上下文切换到进程上下文呢？？我在这里所采用的方法很笨拙：
1.首先让寄存器入栈
2.让寄存器保存至当前任务结构数组，被中断掉的进程的PC值保存至任务结构
3.处理timer中断
4.如果进行任务切换，寻找下一个可调度的进程，然后把当前任务结构指下刚搜索到
的任务结构，让寄存器出栈，恢复当前任务结构里的值到寄存器，恢复堆栈指针，切换到用户态，通过加载当前任务结构的PC值来恢复被挂起的进程这里在中断上下文中使用了任务结构，这在LINUX上好像是不这样用的，中断上下文和进程上下文是两个不同的概念，中断上下文中不能访问进程上下文里的任务结构，我实在想不出有什么办法来实现进程调度了，所以请看到我这则文章的人提出好一点的方法