操作系统 采用哪些同步机制 避免公平竞争审查工作机制条件

君,已阅读到文档的结尾了呢~~
华南理工大学操作系统期末考试卷考点整理
扫扫二维码,随身浏览文档
手机或平板扫扫即可继续访问
华南理工大学操作系统期末考试卷考点整理
举报该文档为侵权文档。
举报该文档含有违规或不良信息。
反馈该文档无法正常浏览。
举报该文档为重复文档。
推荐理由:
将文档分享至:
分享完整地址
文档地址:
粘贴到BBS或博客
flash地址:
支持嵌入FLASH地址的网站使用
html代码:
&embed src='/DocinViewer--144.swf' width='100%' height='600' type=application/x-shockwave-flash ALLOWFULLSCREEN='true' ALLOWSCRIPTACCESS='always'&&/embed&
450px*300px480px*400px650px*490px
支持嵌入HTML代码的网站使用
您的内容已经提交成功
您所提交的内容需要审核后才能发布,请您等待!
3秒自动关闭窗口过计算下一个CPU区间的近似长度,能选择具有最短预测CPU区间的进程来运行。 最短剩余时间优先P141 SJF算法可能是抢占也可能是非抢占的,当一个新进程到达就绪队列而以前的进程正在执行时,就需要选择。与当前运行的进程相比,新的进程可能有一个更短的CPU区间。抢占SJF算法可抢占当前运行的进程,而非抢占式SJF算法会允许当前运行的进程先完成其CPU区间。以此抢占SJF调度称为最短剩余时间优先调度 优先级:无穷阻塞,饥饿. 优先级:SJF算法可作为通用优先级调度算法,每个进程都会关联一个优先级,具有最高优先级的进程会分配到CPU。具有相同优先级的进程按FCFS顺序调度。SJF算法属于简单优先级算法,其优先级为下一个CPU区间的倒数。CPU区间越大优先级越小,反之亦然。
无穷阻塞,饥饿:可以运行但是缺乏CPU的进程可以认为是阻塞或者饥饿 RR(轮转法):是基于优先级吗?是不是可抢占 所谓RR算法就是系统将所有就绪进程按FIFO规则排列,按一定时间间隔把处理机制分配给列队中的进程,这样,列队中的所用进程都获得了一个时间片的处理机而运行。所以是基于优先级切可抢占的。 多队列调度 将就绪队列分成多个独立队列,根据进程的性质,如内存的大小、进程的优先级、进程类型,一个进程被永久地分配到一个队列。每个队列有自己的调度算法。 多队列反馈调度. 允许进程在队列之间移动。主要思想史根据不同CPU区间的特点以区分进程。如果进程使用过多CPU时间,那么它会被转移到更低优先级的队列。这种方案将I/O约束和交互进程留在更高级优先队列,在较低优先级队列中等待时间过长的进程会被转移到更高优先级队列,这种形式的老化阻止饥饿的发生。 (a)基于的原则(b) 做甘特图(c)计算平均等待时间等.
(7)线程竞争范围? 调度程序选择具有最高优先级的可运行的线程来运行,用户级线程优先级由程序员给定,并且不被线程 库调节。 (8)linux系统的调度程序 是抢占式的。。。。。。P157 Linux系统的调度程序是抢占的、基于优先级的算法,具有两个独立的优先级范围。 第6章 (1)生产消费 消费问题,解释P87所使用的方法,为什么会出现竞争的问题?解释在职P166-167
生产者进程生产生信息以供消费者进程消费,采用共享内存是解决生产消费问题方法的一种。为了允许生产者进程和消费者进程并发执行,必须要有一个缓冲来被生产者填充并被消费者所使用。 共享缓冲是通过循环数组和两个逻辑指指针来实现的:in out.变量in指向缓冲中下一个空位;out指向缓冲中的第一个满位。当in==out时,缓冲为空-消费者必须等待;当(in+1)%buffer_size==out时,缓冲为满-生产者必须等待。 (生产者进程有一个局部变量nextProduced以存储产生的新项。消费者进程有一个局部变量nextConsumed以存储所要使用的新项。)
竞争条件:允许两个进程并发操作变量counter。像这样即多个进程并发访问和操作同一数据且执行结果与访问发生的特定顺序有关。为避免竞争条件,需要确保一段时间内只有一个进程能操作变量counter,要求一定形式的进程同步。 (2)在同步机制中,什么是临界区,进入区,退出区。临界区的三个必要条件是什么?P168 临界区:假设某个系统拥有N各进程{P0,P1,P2,P3...Pn-1}。每个进程有一个代码段称为临界区。 进入区:每个进程必须请求允许进入其临界区。实现这一请求的代码段称为进入区。 退出区:临界区之后就是退出区。
}while(true) 临界区的三个必要条件:互斥,前进,有限等待 (3)抢占式内核会产生竞争,非抢占式内核会产生吗?linux 2.4和2.6内核是抢占式的还是非抢占式的? 非抢占式内核数据结构从根本上不会导致竞争条件,因为某个时刻只有一个进程处于内核模式。2.4是非抢占内核,2.6及2.6以后均为抢占的。 (4)解释pterson算法(P169代码)是如何满足临界区的三个必要条件(上课笔记) do{
flag[i]=TRUE;
//若该值=true,则进程Pi想要进入临界区
while(flag[j]&&turn==j);
//允许进程Pj在临界区内执行
flag[i]=FLASE;
剩余区 }while(TURE);
1、互斥成立 只有当flag[j]==false or turn==i时进程Pi才能进入临界区,如果2个进程同时在临界区执行,那么flag[0]==flag[1]==true.这2点意味着P0和P1不可能同时执行它们的while语句,因为turn的值只能为0或者1,只要Pj在临界区内,flag[j]==true,turn==j就同时成立。 2、前进要求,有限等待要求满足 当flag[j]==true,turn==j时,Pi就陷入while语句循环,Pi被阻止进入临界区。如果Pj不准备进入临界区那么flag[j]==false,Pi能进入临界区。进程Pi执行while语句时并不改变变量turn的值,所以当flag[j]==false时Pi会进入临界区(前进),且Pi最多在Pj进入临界区一次后就能进入(有限等待) (5)看懂P171 图6.5,图6.7算法.
(6)P172算法是如何满足临界区的三个必要条件(上课笔记) (7)信号量的概念。计数信号量,二进信号量,互斥锁,自旋锁、读写锁,忙等待。 信号量:是个整数变量,除了初始化外,它只能通过两个标准原子操作wait()和signal()来访问. 操作系统区分计数信号量和二进制信号量。计数信号量的值域不受限制,二进制信号量的值只能是0或者1。有的系统,将二进制信号量称为互斥锁,因为他们可以提供互斥。 (8)linux系统在单CPU,多CPU时对自旋锁的处理P190. Linux提供自旋锁和信号量,以进行内核加锁。对于单处理器,内核不适用自旋锁,而是禁止内核抢占。自旋锁在同一时刻只能被最多一个内核任务持有,所以一个时刻只有一个线程允许存在于临界区中。这点很好地满足了对称多处理机器需要的锁定服务。在单处理器上,自旋锁仅仅当作一个设置内核抢占的开关。
第七章 (1)结合书上P176页,写出一个死锁发生的示例。
p1 wait(S);
wait(Q); wait(Q);
... signal(S);
signal(Q); signal(Q);
signal(Q); 假设p0执行wait(S),接着执行wait(Q)。当p0执行wait(Q)时,它必须等待,直到p1执行signal(Q)。类似当p1执行wait(S),它必须等待,直到p0执行signal(S)。由于这两个操作都不能执行,那么p0p1就死锁了。 (2)死锁的4个必要条件是什么,并简要说明。 在多道程序环境下,多个进程可能竞争一定数量的资源。某个进程申请资源,如果这时资源不可用,那么该进程进入等待状态。如果所申请的资源被其他进程占有,那么该等待的进程可能再也无法改变其状态。这种情况称为死锁。新手园地& & & 硬件问题Linux系统管理Linux网络问题Linux环境编程Linux桌面系统国产LinuxBSD& & & BSD文档中心AIX& & & 新手入门& & & AIX文档中心& & & 资源下载& & & Power高级应用& & & IBM存储AS400Solaris& & & Solaris文档中心HP-UX& & & HP文档中心SCO UNIX& & & SCO文档中心互操作专区IRIXTru64 UNIXMac OS X门户网站运维集群和高可用服务器应用监控和防护虚拟化技术架构设计行业应用和管理服务器及硬件技术& & & 服务器资源下载云计算& & & 云计算文档中心& & & 云计算业界& & & 云计算资源下载存储备份& & & 存储文档中心& & & 存储业界& & & 存储资源下载& & & Symantec技术交流区安全技术网络技术& & & 网络技术文档中心C/C++& & & GUI编程& & & Functional编程内核源码& & & 内核问题移动开发& & & 移动开发技术资料ShellPerlJava& & & Java文档中心PHP& & & php文档中心Python& & & Python文档中心RubyCPU与编译器嵌入式开发驱动开发Web开发VoIP开发技术MySQL& & & MySQL文档中心SybaseOraclePostgreSQLDB2Informix数据仓库与数据挖掘NoSQL技术IT业界新闻与评论IT职业生涯& & & 猎头招聘IT图书与评论& & & CU技术图书大系& & & Linux书友会二手交易下载共享Linux文档专区IT培训与认证& & & 培训交流& & & 认证培训清茶斋投资理财运动地带快乐数码摄影& & & 摄影器材& & & 摄影比赛专区IT爱车族旅游天下站务交流版主会议室博客SNS站务交流区CU活动专区& & & Power活动专区& & & 拍卖交流区频道交流区
论坛徽章:0
& & 当PC启动时,Intel系列的CPU首先进入的是实模式,并开始执行位于地址0xFFFF0处的代码,也就是ROM-BIOS起始位置的代码。BIOS先进行一系列的系统自检,然后初始化位于地址0的中断向量表。最后BIOS将启动盘的第一个扇区装入到0x7C00,并开始执行此处的代码.这就是对内核初始化过程的一个最简单的描述。
& & 最初,Linux核心的最开始部分是用8086汇编语言编写的。当开始运行时,核心将自己装入到绝对地址0x90000,再将其后的2k字节装入到地址0x90200处,最后将核心的其余部分装入到0x10000。
& & 当系统装入时,会显示Loading...信息。装入完成后,控制转向另一个实模式下的汇编语言代码boot/Setup.S。Setup部分首先设置一些系统的硬件设备,然后将核心从0x10000处移至0x1000处。这时系统转入保护模式,开始执行位于0x1000处的代码。
& & 接下来是内核的解压缩。0x1000处的代码来自于文件Boot/head.S,它用来初始化寄存器和调用decompress_kernel( )程序。decompress_kernel( )程序由Boot/inflate.c, Boot/unzip.c 和Boot/misc.c组成。解压缩后的数据被装入到了0x100000处,这也是Linux不能在内存小于2M的环境下运行的主要原因。
& & 解压后的代码在0x1010000处开始执行,紧接着所有的32位的设置都将完成: IDT、GDT和LDT将被装入,处理器初始化完毕,设置好内存页面,最终调用start_kernel过程。这大概是整个内核中最为复杂的部分。
[系统开始运行]
& & Linux kernel 最早的C代码从汇编标记startup_32开始执行
|startup_32:
& &|start_kernel
& && &|lock_kernel
& && &|trap_init
& && &|init_IRQ
& && &|sched_init
& && &|softirq_init
& && &|time_init
& && &|console_init
& && &|#ifdef CONFIG_MODULES
& && && &|init_modules
& && &|#endif
& && &|kmem_cache_init
& && &|sti
& && &|calibrate_delay
& && &|mem_init
& && &|kmem_cache_sizes_init
& && &|pgtable_cache_init
& && &|fork_init
& && &|proc_caches_init
& && &|vfs_caches_init
& && &|buffer_init
& && &|page_cache_init
& && &|signals_init
& && &|#ifdef CONFIG_PROC_FS
& && &&&|proc_root_init
& && &|#endif
& && &|#if defined(CONFIG_SYSVIPC)
& && && &|ipc_init
& && &|#endif
& && &|check_bugs
& && &|smp_init
& && &|rest_init
& && && &|kernel_thread
& && && &|unlock_kernel
& && && &|cpu_idle
·startup_32 [arch/i386/kernel/head.S]
·start_kernel [init/main.c]
·lock_kernel [include/asm/smplock.h]
·trap_init [arch/i386/kernel/traps.c]
·init_IRQ [arch/i386/kernel/i8259.c]
·sched_init [kernel/sched.c]
·softirq_init [kernel/softirq.c]
·time_init [arch/i386/kernel/time.c]
·console_init [drivers/char/tty_io.c]
·init_modules [kernel/module.c]
·kmem_cache_init [mm/slab.c]
·sti [include/asm/system.h]
·calibrate_delay [init/main.c]
·mem_init [arch/i386/mm/init.c]
·kmem_cache_sizes_init [mm/slab.c]
·pgtable_cache_init [arch/i386/mm/init.c]
·fork_init [kernel/fork.c]
·proc_caches_init
·vfs_caches_init [fs/dcache.c]
·buffer_init [fs/buffer.c]
·page_cache_init [mm/filemap.c]
·signals_init [kernel/signal.c]
·proc_root_init [fs/proc/root.c]
·ipc_init [ipc/util.c]
·check_bugs [include/asm/bugs.h]
·smp_init [init/main.c]
·rest_init
·kernel_thread [arch/i386/kernel/process.c]
·unlock_kernel [include/asm/smplock.h]
·cpu_idle [arch/i386/kernel/process.c]
& & start_kernel( )程序用于初始化系统内核的各个部分,包括:
& & *设置内存边界,调用paging_init( )初始化内存页面。
& & *初始化陷阱,中断通道和调度。
& & *对命令行进行语法分析。
& & *初始化设备驱动程序和磁盘缓冲区。
& & *校对延迟循环。
最后的function'rest_init' 作了以下工作:
& &·开辟内核线程'init'
& &·调用unlock_kernel
& &·建立内核运行的cpu_idle环, 如果没有调度,就一直死循环
实际上start_kernel永远不能终止.它会无穷地循环执行cpu_idle.
& & 最后,系统核心转向move_to_user_mode( ),以便创建初始化进程(init)。此后,进程0开始进入无限循环。
& & 初始化进程开始执行/etc/init、/bin/init 或/sbin /init中的一个之后,系统内核就不再对程序进行直接控制了。之后系统内核的作用主要是给进程提供系统调用,以及提供异步中断事件的处理。多任务机制已经建立起来,并开始处理多个用户的登录和fork( )创建的进程。
& & init是第一个进程,或者说内核线程
& &|lock_kernel
& &|do_basic_setup
& && &|mtrr_init
& && &|sysctl_init
& && &|pci_init
& && &|sock_init
& && &|start_context_thread
& && &|do_init_calls
& && && &|(*call())-&; kswapd_init
& &|prepare_namespace
& &|free_initmem
& &|unlock_kernel
& &|execve
--------------------------------------------------------------------------------
系统引导:
涉及的文件
./arch/$ARCH/boot/bootsect.s
./arch/$ARCH/boot/setup.s
bootsect.S
 这个程序是linux kernel的第一个程序,包括了linux自己的bootstrap程序,
但是在说明这个程序前,必须先说明一般IBM PC开机时的动作(此处的开机是指
&打开PC的电源&quot:
  一般PC在电源一开时,是由内存中地址FFFF:0000开始执行(这个地址一定
在ROM BIOS中,ROM BIOS一般是在FEOOOh到FFFFFh中),而此处的内容则是一个
jump指令,jump到另一个位於ROM BIOS中的位置,开始执行一系列的动作,包
括了检查RAM,keyboard,显示器,软硬磁盘等等,这些动作是由系统测试代码
(system test code)来执行的,随着制作BIOS厂商的不同而会有些许差异,但都
是大同小异,读者可自行观察自家机器开机时,萤幕上所显示的检查讯息。
  紧接着系统测试码之后,控制权会转移给ROM中的启动程序
(ROM bootstrap routine),这个程序会将磁盘上的第零轨第零扇区读入
内存中(这就是一般所谓的boot sector,如果你曾接触过电脑病
毒,就大概听过它的大名),至於被读到内存的哪里呢? --绝对
位置07C0:0000(即07C00h处),这是IBM系列PC的特性。而位在linux开机
磁盘的boot sector上的正是linux的bootsect程序,也就是说,bootsect是
第一个被读入内存中并执行的程序。现在,我们可以开始来
看看到底bootsect做了什么。
 首先,bootsect将它&自己&从被ROM BIOS载入的绝对地址0x7C00处搬到
0x90000处,然后利用一个jmpi(jump indirectly)的指令,跳到新位置的
jmpi的下一行去执行,
 接着,将其他segment registers包括DS,ES,SS都指向0x9000这个位置,
与CS看齐。另外将SP及DX指向一任意位移地址( offset ),这个地址等一下
会用来存放磁盘参数表(disk para- meter table )
 接着利用BIOS中断服务int 13h的第0号功能,重置磁盘控制器,使得刚才
的设定发挥功能。
 完成重置磁盘控制器之后,bootsect就从磁盘上读入紧邻着bootsect的setup
程序,也就是setup.S,此读入动作是利用BIOS中断服务int 13h的第2号功能。
setup的image将会读入至程序所指定的内存绝对地址0x90200处,也就是在内存
中紧邻着bootsect 所在的位置。待setup的image读入内存后,利用BIOS中断服
务int 13h的第8号功能读取目前磁盘的参数。
 再来,就要读入真正linux的kernel了,也就是你可以在linux的根目录下看
到的&vmlinuz& 。在读入前,将会先呼叫BIOS中断服务int 10h 的第3号功能,
读取游标位置,之后再呼叫BIOS 中断服务int 10h的第13h号功能,在萤幕上输
出字串&Loading&,这个字串在boot linux时都会首先被看到,相信大家应该觉
得很眼熟吧。
 接下来做的事是检查root device,之后就仿照一开始的方法,利用indirect
jump 跳至刚刚已读入的setup部份
&&setup.S完成在实模式下版本检查,并将硬盘,鼠标,内存参数写入到 INITSEG
中,并负责进入保护模式。
&&操作系统的初始化。
--------------------------------------------------------------------------------
bootsect.S
1.将自己移动到0x0处,为内核调入留出地址空间;
2.建立运行环境(ss=ds=es=cs=0x9000, sp=0x4000-12),保证起动程序运行;
3.BIOS初始化0x1E号中断为软盘参数表,将它取来保存备用;
4.将setup读到0x0处;
5.测试软盘参数一个磁道有多少个扇区(也没有什么好办法,只能试试36, 18, 15, 9对不对了);
6.打印“Loading”;
7.读入内核到0x(如果是bzImage, 则将每个64K移动到0x100000处,在实模式下,只能调用0x15号中断了,这段代码无法放在bootsect中所以只能放在setup中,幸好此时setup已经读入了);
8.到setup去吧
发发信人: seis (矛), 信区: Linux
标&&题: Linux操作系统内核引导程序详细剖析
发信站: BBS 水木清华站 (Fri Feb&&2 14:12:43 2001)
! bootsect.s (c)
Linus Torvalds 版权所有
! Drew Eckhardt修改过
! Bruce Evans (bde)修改过
! bootsect.s 被bios-启动子程序加载至0x7c00 (31k)处,并将自己
! 移到了地址0x9k)处,并跳转至那里。
! bde - 不能盲目地跳转,有些系统可能只有512k的低
! 内存。使用中断0x12来获得(系统的)最高内存、等。
! 它然后使用BIOS中断将setup直接加载到自己的后面(0x9k),
! 并将系统加载到地址0x10000处。
! 注意! 目前的内核系统最大长度限制为(8*)(508k)字节长,即使是在
! 将来这也是没有问题的。我想让它保持简单明了。这样508k的最大内核长度应该
! 是足够了,尤其是这里没有象minix中一样包含缓冲区高速缓冲(而且尤其是现在
! 内核是压缩的
! 加载程序已经做的尽量地简单了,所以持续的读出错将导致死循环。只能手工重启。
! 只要可能,通过一次取得整个磁道,加载过程可以做的很快的。
#include /* 为取得CONFIG_ROOT_RDONLY参数 */
!! config.h中(即autoconf.h中)没有CONFIG_ROOT_RDONLY定义!!!?
SETUPSECS = 4 ! 默认的setup程序扇区数(setup-sectors)的默认值;
BOOTSEG = 0x7C0 ! bootsect的原始地址;
INITSEG = DEF_INITSEG ! 将bootsect程序移到这个段处(0x9000) - 避开;
SETUPSEG = DEF_SETUPSEG ! 设置程序(setup)从这里开始(0x9020);
SYSSEG = DEF_SYSSEG ! 系统加载至0x)(64k)段处;
SYSSIZE = DEF_SYSSIZE ! 系统的大小(0x7F00): 要加载的16字节为一节的数;
!! 以上4个DEF_参数定义在boot.h中:
!! DEF_INITSEG 0x9000
!! DEF_SYSSEG 0x1000
!! DEF_SETUPSEG 0x9020
!! DEF_SYSSIZE 0x7F00 (=k)*16=508k
! ROOT_DEV & SWAP_DEV 现在是由&build&中编制的;
ROOT_DEV = 0
SWAP_DEV = 0
#ifndef SVGA_MODE
#define SVGA_MODE ASK_VGA
#ifndef RAMDISK
#define RAMDISK 0
#ifndef CONFIG_ROOT_RDONLY
#define CONFIG_ROOT_RDONLY 1
! ld86 需要一个入口标识符,这和通常的一样;
.globl _main
#if 0 /* 调试程序的异常分支,除非BIOS古怪(比如老的HP机)否则是无害的 */
mov ax,#BOOTSEG !! 将ds段寄存器置为0x7C0;
mov ax,#INITSEG !! 将es段寄存器置为0x9000;
mov cx,#256 !! 将cx计数器置为256(要移动256个字, 512字节);
sub si,si !! 源地址 ds:si=0x07C0:0x0000;
sub di,di !! 目的地址es:di=0x0;
cld !! 清方向标志;
rep !! 将这段程序从0x7C0:0(31k)移至0xk)处;
movsw !! 共256个字(512字节)(0x200长);
jmpi go,INITSEG !! 间接跳转至移动后的本程序go处;
! ax和es现在已经含有INITSEG的值(0x9000);
go: mov di,#0x4000-12 ! 0x4000(16k)是&;=bootsect + setup 的长度 +
! + 堆栈的长度 的任意的值;
! 12 是磁盘参数块的大小 es:di=0xk-12;
! bde - 将0xff00改成了0x4000以从0x6400处使用调试程序(bde)。如果
! 我们检测过最高内存的话就不用担心这事了,还有,我的BIOS可以被配置为将wini驱动
! 放在内存高端而不是放在向量表中。老式的堆栈区可能会搞乱驱动表;
mov ds,ax ! 置ds数据段为0x9000;
mov ss,ax ! 置堆栈段为0x9000;
mov sp,di ! 置堆栈指针INITSEG:0x4000-12处;
* 许多BIOS的默认磁盘参数表将不能
* 进行扇区数大于在表中指定
* 的最大扇区数( - 在某些情况下
* 这意味着是7个扇区)后面的多扇区的读操作。
* 由于单个扇区的读操作是很慢的而且当然是没问题的,
* 我们必须在RAM中(为第一个磁盘)创建新的参数表。
* 我们将把最大扇区数设置为36 - 我们在一个ED 2.88驱动器上所能
* 遇到的最大值。
* 此值太高是没有任何害处的,但是低的话就会有问题了。
* 段寄存器是这样的: ds=es=ss=cs - INITSEG,(=0X9000)
* fs = 0, gs没有用到。
! 上面执行重复操作(rep)以后,cx为0;
mov fs,cx !! 置fs段寄存器=0;
mov bx,#0x78 ! fs:bx是磁盘参数表的地址;
lds si,(bx) ! ds:si是源地址;
!! 将fs:bx地址所指的指针值放入ds:si中;
mov cl,#6 ! 拷贝12个字节到0x0-12开始处;
push di !! 指针0x0-12处;
pop di !! di仍指向0x0-12处(参数表开始处);
pop si !! ds =&; si=INITSEG(=0X9000);
movb 4(di),*36 ! 修正扇区计数值;
mov (bx),di !! 修改fs:bx(处磁盘参数表的地址为0x0-12;
mov 2(bx),es
! 将setup程序所在的扇区(setup-sectors)直接加载到boot块的后面。!! 0x90200开始处
! 注意,es已经设置好了。
! 同样经过rep循环后cx为0
load_setup:
xor ah,ah ! 复位软驱(FDC);
xor dx,dx ! 驱动器0, 磁头0;
mov cl,#0x02 ! 从扇区2开始,磁道0;
mov bx,#0x0200 ! 置数据缓冲区地址=es:bx=0x;
! 在INITSEG段中,即0x90200处;
mov ah,#0x02 ! 要调用功能号2(读操作);
mov al,setup_sects ! 要读入的扇区数SETUPSECS=4;
! (假释所有数据都在磁头0、磁道0);
int 0x13 ! 读操作;
jnc ok_load_setup ! ok则继续;
push ax ! 否则显示出错信息。保存ah的值(功能号2);
call print_nl !! 打印换行;
mov bp,sp !! bp将作为调用print_hex的参数;
call print_hex !! 打印bp所指的数据;
jmp load_setup !! 重试!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!!INT 13 - DISK - READ SECTOR(S) INTO MEMORY
!! AH = 02h
!! AL = number of sectors to read (must be nonzero)
!! CH = low eight bits of cylinder number
!! CL = sector number 1-63 (bits 0-5)
!! high two bits of cylinder (bits 6-7, hard disk only)
!! DH = head number
!! DL = drive number (bit 7 set for hard disk)
!! ES:BX -&; data buffer
!! Return: CF set on error
!! if AH = 11h (corrected ECC error), AL = burst length
!! CF clear if successful
!! AH = status (see #00234)
!! AL = number of sectors transferred (only valid if CF set for some
!! BIOSes)
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
ok_load_setup:
! 取得磁盘驱动器参数,特别是每磁道扇区数(nr of sectors/track);
! bde - Phoenix BIOS手册中提到功能0x08只对硬盘起作用。
! 但它对于我的一个BIOS(1987 Award)不起作用。
! 不检查错误码是致命的错误。
mov ah,#0x08 ! AH=8用于取得驱动器参数;
!!!!!!!!!!!!!!!!!!!!!!!!!!!
!! INT 13 - DISK - GET DRIVE PARAMETERS (PC,XT286,CONV,PS,ESDI,SCSI)
!! AH = 08h
!! DL = drive (bit 7 set for hard disk)
!!Return: CF set on error
!! AH = status (07h) (see #00234)
!! CF clear if successful
!! AH = 00h
!! AL = 00h on at least some BIOSes
!! BL = drive type (AT/PS2 floppies only) (see #00242)
!! CH = low eight bits of maximum cylinder number
!! CL = maximum sector number (bits 5-0)
!! high two bits of maximum cylinder number (bits 7-6)
!! DH = maximum head number
!! DL = number of drives
!! ESI -&; drive parameter table (floppies only)
!!!!!!!!!!!!!!!!!!!!!!!!!!!!
! 好象没有BIOS调用可取得扇区数。如果扇区36可以读就推测是36个扇区,
! 如果扇区18可读就推测是18个扇区,如果扇区15可读就推测是15个扇区,
! 否则推测是9. [36, 18, 15, 9]
mov si,#disksizes ! ds:si-&;要测试扇区数大小的表;
probe_loop:
lodsb !! ds:si所指的字节 =&;al, si=si+1;
cbw ! 扩展为字(word);
mov sectors, ax ! 第一个值是36,最后一个是9;
cmp si,#disksizes+4
jae got_sectors ! 如果所有测试都失败了,就试9;
xchg ax,cx ! cx = 磁道和扇区(第一次是36=0x0024);
xor dx,dx ! 驱动器0,磁头0;
xor bl,bl !! 设置缓冲区es:bx = 0xa00(578.5k);
mov bh,setup_sects !! setup_sects = 4 (共2k);
shl bh,#1 ! setup后面的地址(es=cs);
mov ax,#0x0201 ! 功能2(读),1个扇区;
jc probe_loop ! 如果不对,就试用下一个值;
got_sectors:
mov ax,#INITSEG
mov es,ax ! es = 0x9000;
! 打印一些无用的信息(换行后,显示Loading)
mov ah,#0x03 ! 读光标位置;
mov bx,#0x0007 ! 页0,属性7 (normal);
mov bp,#msg1
mov ax,#0x1301 ! 写字符串,移动光标;
! ok, 我们已经显示出了信息,现在
! 我们要加载系统了(到0x10000处)(64k处)
mov ax,#SYSSEG
mov es,ax ! es=0x01000的段;
call read_it !! 读system,es为输入参数;
call kill_motor !! 关闭驱动器马达;
call print_nl !! 打印回车换行;
! 这以后,我们来检查要使用哪个根设备(root-device)。如果已指定了设备(!=0)
! 则不做任何事而使用给定的设备。否则的话,使用/dev/fd0H)或/dev/PS0
! 或者是/dev/at0 (2,之一,这取决于我们假设我们知道的扇区数而定。
!! |__ ps0?? (x,y)--表示主、次设备号?
mov ax,root_dev
jne root_defined
mov bx,sectors !! sectors = 每磁道扇区数;
mov ax,#0x0208 ! /dev/ps0 - 1.2Mb;
cmp bx,#15
je root_defined
mov al,#0x1c ! /dev/PS0 - 1.44Mb !! 0x1C = 28;
cmp bx,#18
je root_defined
mov al,0x20 ! /dev/fd0H2880 - 2.88Mb;
cmp bx,#36
je root_defined
mov al,#0 ! /dev/fd0 -
root_defined:
mov root_dev,ax !! 其中保存由设备的主、次设备号;
! 这以后(所有程序都加载了),我们就跳转至
! 被直接加载到boot块后面的setup程序去:
jmpi 0,SETUPSEG !! 跳转到0x(setup程序的开始位置);
! 这段程序将系统(system)加载到0x10000(64k)处,
! 注意不要跨越64kb边界。我们试图以最快的速度
! 来加载,只要可能就整个磁道一起读入。
! 输入(in): es - 开始地址段(通常是0x1000)
sread: .word 0 ! 当前磁道已读的扇区数;
head: .word 0 ! 当前磁头;
track: .word 0 ! 当前磁道;
mov al,setup_sects
mov sread,al !! 当前sread=5;
mov ax,es !! es=0x1000;
test ax,#0x0fff !! (ax AND 0x0fff, if ax=0x1000 then zero-flag=1 );
die: jne die ! es 必须在64kB的边界;
xor bx,bx ! bx 是段内的开始地址;
#ifdef __BIG_KERNEL__
#define CALL_HIGHLOAD_KLUDGE .word 0x1eff, 0x220 ! 调用 far * bootsect_kludge
! 注意: as86不能汇编这;
CALL_HIGHLOAD_KLUDGE ! 这是在setup.S中的程序;
sub ax,#SYSSEG ! 当前es段值减system加载时的启始段值(0x1000);
cmp ax,syssize ! 我们是否已经都加载了?(ax=0x7f00 ?);
jbe ok1_read !! if ax &= syssize then 继续读;
ret !! 全都加载完了,返回!
mov ax,sectors !! sectors=每磁道扇区数;
sub ax,sread !! 减去当前磁道已读扇区数,al=当前磁道未读的扇区数(ah=0);
shl cx,#9 !! 乘512,cx = 当前磁道未读的字节数;
add cx,bx !! 加上段内偏移值,es:bx为当前读入的数据缓冲区地址;
jnc ok2_read !! 如果没有超过64K则继续读;
je ok2_read !! 如果正好64K也继续读;
call read_track !! es:bx -&;缓冲区,al=要读的扇区数,也即当前磁道未读的扇区数;
mov cx,ax !! ax仍为调用read_track之前的值,即为读入的扇区数;
add ax,sread !! ax = 当前磁道已读的扇区数;
cmp ax,sectors !! 已经读完当前磁道上的扇区了吗?
jne ok3_read !! 没有,则跳转;
sub ax,head !! 当前是磁头1吗?
jne ok4_read !! 不是(是磁头0)则跳转(此时ax=1);
inc track !! 当前是磁头1,则读下一磁道(当前磁道加1);
mov head,ax !! 保存当前磁头号;
xor ax,ax !! 本磁道已读扇区数清零;
mov sread,ax !! 存本磁道已读扇区数;
shl cx,#9 !! 刚才一次读操作读入的扇区数 * 512;
add bx,cx !! 调整数据缓冲区的起始指针;
jnc rp_read !! 如果该指针没有超过64K的段内最大偏移量,则跳转继续读操作;
mov ax,es !! 如果超过了,则将段地址加0x1000(下一个64K段);
add ah,#0x10
xor bx,bx !! 缓冲区地址段内偏移量置零;
jmp rp_read !! 继续读操作;
read_track:
pusha !! 将寄存器ax,cx,dx,bx,sp,bp,si,di压入堆栈;
mov ax,#0xe2e ! loading... message 2e = . !! 显示一个.
mov dx,track !! track = 当前磁道;
mov cx,sread
inc cx !! cl = 扇区号,要读的起始扇区;
mov ch,dl !! ch = 磁道号的低8位;
mov dx,head !!
mov dh,dl !! dh = 当前磁头号;
and dx,#0x0100 !! dl = 驱动器号(0);
mov ah,#2 !! 功能2(读),es:bx指向读数据缓冲区;
push dx ! 为出错转储保存寄存器的值到堆栈上;
jc bad_rt !! 如果出错,则跳转;
add sp, #8 !! 清(放弃)堆栈上刚推入的4个寄存器值;
bad_rt: push ax ! 保存出错码;
call print_all ! ah = error, al = read;
add sp,#10
jmp read_track
* print_all是用于调试的。
* 它将打印出所有寄存器的值。所作的假设是
* 从一个子程序中调用的,并有如下所示的堆栈帧结构
* ret &- sp
print_all:
mov cx,#5 ! 出错码 + 4个寄存器
print_loop:
push cx ! 保存剩余的计数值
call print_nl ! 为了增强阅读性,打印换行
cmp cl, #5
jae no_reg ! 看看是否需要寄存器的名称
mov ax,#0xe05 + A - l
add bp,#2 ! 下一个寄存器
call print_hex ! 打印值
loop print_loop
print_nl: !! 打印回车换行。
mov ax,#0xe0d ! CR
mov al,#0xa ! LF
* print_hex是用于调试目的的,打印出
* ss:bp所指向的十六进制数。
* !! 例如,十六进制数是0x4321时,则al分别等于4,3,2,1调用中断打印出来 4321
print_hex:
mov cx, #4 ! 4个十六进制数字
mov dx, (bp) ! 将(bp)所指的值放入dx中
print_digit:
rol dx, #4 ! 循环以使低4比特用上 !! 取dx的高4比特移到低4比特处。
mov ax, #0xe0f ! ah = 请求的功能值,al = 半字节(4个比特)掩码。
and al, dl !! 取dl的低4比特值。
add al, #0x90 ! 将al转换为ASCII十六进制码(4个指令)
daa !! 十进制调整
adc al, #0x40 !! (adc dest, src ==&; dest := dest + src + c )
loop print_digit
* 这个过程(子程序)关闭软驱的马达,这样
* 我们进入内核后它的状态就是已知的,以后也就
* 不用担心它了。
kill_motor:
mov dx,#0x3f2
.word 0 !! 当前每磁道扇区数。(36||18||15||9)
disksizes: !! 每磁道扇区数表
.byte 36, 18, 15, 9
.byte 13, 10
.ascii &Loading&
.org 497 !! 从boot程序的二进制文件的497字节开始
setup_sects:
.byte SETUPSECS
root_flags:
.word CONFIG_ROOT_RDONLY
.word SYSSIZE
.word SWAP_DEV
.word RAMDISK
.word SVGA_MODE
.word ROOT_DEV
boot_flag: !! 分区启动标志
.word 0xAA55
--------------------------------------------------------------------------------
1、按规定得有个头,所以一开始是惯用的JMP;
2、头里边内容很丰富,具体用法走着瞧;
3、自我检测,不知道有什么用,防伪造?防篡改?
4、如果装载程序不对,只好死掉!以下终于走入正题;
5、获取内存容量(使用了三种办法,其中的E820和E801看不明白,int 15倒是老朋友了--应该是上个世纪80年代末认识的了,真佩服十年过去了,情意依旧,不过遇上一些不守规矩的BIOS,不知道还行不行);
6、将键盘重复键的重复率设为最大,灵敏一点?
7、检测硬盘,不懂,放这里干什么?
8、检测MCA总线(不要问我这是什么);
9、检测PS/2鼠标,用int 11,只是不知道为何放这里;
10、检测电源管理BIOS;唉,书到用时方恨少,不懂的太多了,真不好意思;不过也没有关系, 不懂的就别去动它就行了;以下要进入内核了;
11、 在进入保护模式之前,可以调用一个你提供的试模式下的过程,让你最后在看她一眼,当然你要是不提供,那就有个默认的,无非是塞住耳朵闭上眼睛禁止任何中断,包括著名的NMI ;
12、设置保护模式起动后的例程地址, 你可以写自己的例程,但不是代替而是把它加在setup提供的例程的前面(显示一个小鸭子?);
13、如果内核是zImage, 将它移动到0x10000处;
14、如果自己不在0x90000处,则移动到0x90000处;
15、建立idt, gdt表;
16、启动A20;
17、屏住呼吸,屏闭所有中断;
18、启动!movw $1, % lmsw % 好已经进入保护模式下,马上进行局部调整;
19、jmpi 0x100000, __KERNEL_CS,终于进入内核;
A summary of the setup.S code 。The slight differences in the operation of setup.S due to a big kernel is documented here. When the switch to 32 bit protected mode begins the code32_start address is defined as 0x100000 (when loaded) here.
code32_start:
#ifndef __BIG_KERNEL__
.long 0x1000
.long 0x100000
After setting the keyboard repeat rate to a maximum, calling video.S, storing the video parameters, checking for the hard disks, PS/2 mouse, and APM BIOS the preparation for real mode switch begins.
The interrupts are disabled. Since the loader changed the code32_start address, the code32 varable is updated. This would be used for the jmpi instruction when the setup.S finally jumps to compressed/head.S. In case of a big kernel this is loacted at 0x100000.
mov eax, code32_start !modified above by the loader
mov code32,eax
!code32 contains the correct address to branch to after setup.S finishes After the above code there is a slight difference in the ways the big and small kernels are dealt. In case of a small kernel the kernel is moved down to segment address 0x100, but a big kernel is not moved. Before decompression, the big kernel stays at 0x100000. The following is the code that does thischeck.test byte ptr loadflags,
#LOADED_HIGH
jz do_move0 ! a normal low loaded zImage is moved
jmp end_move ! skip move
The interrupt and global descriptors are initialized:
lidt idt_48 ! load idt wit 0,0
lgdt gdt_48 ! load gdt with whatever appropriate
After enabling A20 and reprogramming the interrupts, it is ready to set the PE bit:
jmp flush_instr
flush_instr:
xor bx.bx !flag to indicate a boot
! Manual, mixing of 16-bit and 32 bit code
db 0x166,0xea !prefix jmpi-opcode
code32: dd ox1000 !this has been reset in caes of a big kernel, to 0x100000
dw __KERNEL_CS
Finally it prepares the opcode for jumping to compressed/head.S which in the big kernel is at 0x100000. The compressed kernel would start at 0x1000 in case of a small kernel.
compressed/head.S
When setup.S relinquishes control to compressed/head.S at beginning of the compressed kernmel at 0x100000. It checks to see if A20 is really enabled otherwise it loops forever.
Itinitializes eflags, and clears BSS (Block Start by Symbol) creating reserved space for uninitialized static or global variables. Finally it reserves place for the moveparams structure (defined in misc.c) and pushes the current stack pointer on the stack and calls the C function decompress_kernel which takes a struct moveparams * as an argument
subl $16,%esp
pushl %esp
call SYMBOL_NAME(decompress_kernel)
Te C function decompress_kernel returns the variable high_loaded which is set to 1 in the function setup_output_buffer_if_we_run_high, which is called in decompressed_kernel if a big kernel was loaded.
When decompressed_kernel returns, it jumps to 3f which moves the move routine.
movl $move_routine_start,%esi ! puts the offset of the start of the source in the source index register
mov $0x1000,?? ! the destination index now contains 0x1000, thus after move, the move routine starts at 0x1000
movl $move_routine_end,??
sub %esi,?? ! ecx register now contains the number of bytes to be moved
! (number of bytes between the labels move_routine_start and move_routine_end)
movsb ! moves the bytes from ds:si to es:di, in each loop it increments si and di, and decrements cx
! the movs instruction moves till ecx is zero
Thus the movsb instruction moves the bytes of the move routine between the labels move_routine_start and move_routine_end. At the end the entire move routine labeled move_routine_start is at 0x1000. The movsb instruction moves bytes from ds:si to es:si.
At the start of the head.S code es,ds,fs,gs were all intialized to __KERNEL_DS, which is defined in /usr/src/linux/include/asm/segment.h as 0x18. This is the offset from the goobal descriptor table gdtwhich was setup in setup.S. The 24th byte is the start of the data segment descriptor, which has the base address = 0. Thus the moe routine is moved and
starts at offset 0x1000 from __KERNEL_DS, the kernel data segment base (which is 0).
The salient features of what is done by the decompress_kernel is discussed in the next section but it is worth noting that the when the decompressed_kernel function is invoked, space was created at the top of the stack to contain the information about the decompressed kernel. The decompressed kernel if big may be in the high buffer and in the low buffer. After the decompressed_kernel function returns, the decompressed kernel has to be moved so that we
have a contiguous decompressed kernel starting from address 0x100000. To move the decompressed kernel, the important parameters needed are the start addresses of the high buffer and low buffer, and the number of bytes in the high and low buffers. This is at the top of the stack when decompressed_kernel returns (the top of the stack was passed as an argument : struct moveparams*, and in the function the fileds of the moveparams struture was adjusted toreflect the state of the decompression.)
/* in compressed/misc.c */
struct moveparams {
uch *low_buffer_ ! start address of the low buffer
! number of bytes in the low buffer after decompression is doneuch *high_buffer_ ! start address of the high buffer
! number of bytes in the high buffer aftre decompression is done
Thus when the decompressed_kernel returns, the relevant bytes are popped in the respective registers as shown below. After preparing these registers the decompressed kernel is ready to be moved and the control jumps to the moved move routine at __KERNEL_CS:0x1000. The code for setting the appropriate registers is given below:
popl %esi ! discard the address, has the return value (high_load) most probably
popl %esi ! low_buffer_start
popl ?? ! lcount
popl ?? ! high_buffer_count
popl ?? ! hcount
movl %0x100000,??
cli ! disable interrutps when the decompressed kernel is being moved
ljmp $(__KERNEL_CS), $0x1000 ! jump to the move routine which was moved to low memory, 0x1000
The move_routine_start basically has two parts, first it moves the part of the decompressed kernel in the low buffer, then it moves (if required) the high buffer contents. It should be noted that the ecx has been intialized to the number of bytes in the low end buffer, and the destination index register di has been intialized to 0x100000.
move_routine_start:
rep ! repeat, it stops repeating when ecx == 0
movsb ! the movsb instruction repeats till ecx is 0. In each loop byte is transferred from ds:esi to es:edi! In each loop the edi and the esi are incremented and ecx is decremented
! when the low end buffer has been moved the value of di is not changed and the next pasrt of the code! uses it to transfer the bytes from the high buffer
movl ??,%esi ! esi now has the offset corresponding to the start of the high&&buffer
movl ??,?? ! ecx is now intialized to the number of bytes in the high buffer
movsb ! moves all the bytes in the high buffer, and doesn’t move at all if hcount was zero (if it was determined, in! close_output_buffer_if_we_run_high that the high buffer need not be moveddown )
xorl ??,??
mov $0x90000, %esp ! stack pointer is adjusted, most probably to be used by the kernel in the intialization
ljmp $(__KERNEL_CS), $0x100000 ! jump to __KERNEL_CS:0X100000, where the kernel code starts
move_routine_end:At the end of the this the control goes to the kernel code segment.
Linux Assembly code taken from&&head.S and setup.S
Comment code added by us
--------------------------------------------------------------------------------
& & 因为setup.S最后的为一条转跳指令,跳到内核第一条指令并开始执行。指令中指向的是内存中的绝对地址,我们无法依此判断转跳到了head.S。但是我们可以通过Makefile简单的确定head.S位于内核的前端。
在arch/i386 的 Makefile 中定义了
& && &&&HEAD := arch/i386/kernel/head.o
而在linux总的Makefile中由这样的语句
& & include arch/$(ARCH)/Makefile
说明HEAD定义在该文件中有效
& & 然后由如下语句:
vmlinux: $(CONFIGURATION) init/main.o init/version.o linuxsubdirs
$(LD) $(LINKFLAGS) $(HEAD) init/main.o init/version.o \
&&$(ARCHIVES) \
&&$(FILESYSTEMS) \
&&$(DRIVERS) \
&&$(LIBS) -o vmlinux
$(NM) vmlinux | grep -v '\(compiled\)\|\(\.o$$\)\|\( a \)' | sort &; System.map
从这个依赖关系我们可以获得大量的信息
1&;$(HEAD)即head.o的确第一个被连接到核心中
2&;所有内核中支持的文件系统全部编译到$(FILESYSTEMS)即fs/filesystems.a中
&&所有内核中支持的网络协议全部编译到net.a中
&&所有内核中支持的SCSI驱动全部编译到scsi.a中
&&...................
&&原来内核也不过是一堆库文件和目标文件的集合罢了,有兴趣对内核减肥的同学,
&&可以好好比较一下看究竟是那个部分占用了空间。
3&;System.map中包含了所有的内核输出的函数,我们在编写内核模块的时候
&&可以调用的系统函数大概就这些了。
好了,消除了心中的疑问,我们可以仔细分析head.s了。
Head.S分析
1 首先将ds,es,fs,gs指向系统数据段KERNEL_DS
&&KERNEL_DS 在asm/segment.h中定义,表示全局描述符表中
&&中的第三项。
&&注意:该此时生效的全局描述符表并不是在head.s中定义的
& && &&&而仍然是在setup.S中定义的。
2 数据段全部清空。
3 setup_idt为一段子程序,将中断向量表全部指向ignore_int函数
&&该函数打印出:unknown interrupt
&&当然这样的中断处理函数什么也干不了。
4 察看数据线A20是否有效,否则循环等待。
&&地址线A20是x86的历史遗留问题,决定是否能访问1M以上内存。
5 拷贝启动参数到0x5000页的前半页,而将setup.s取出的bios参数
&&放到后半页。
6 检查CPU类型
&&@#$#%$^*@^?(^%#$%!#!@?谁知道干了什么?
7 初始化页表,只初始化最初几页。
&&1&;将swapper_pg_dir(0x2000)和pg0(0x3000)清空
& & swapper_pg_dir作为整个系统的页目录
&&2&;将pg0作为第一个页表,将其地址赋到swapper_pg_dir的第一个32
& & 位字中。
&&3&;同时将该页表项也赋给swapper_pg_dir的第3072个入口,表示虚拟地址
& & 0xc0000000也指向pg0。
&&4&;将pg0这个页表填满指向内存前4M
&&5&;进入分页方式
& & 注意:以前虽然在在保护模式但没有启用分页。
& & --------------------
& & |&&swapper_pg_dir&&|& && & -----------
& & |& && && && && && &|-------| pg0& &&&|----------内存前4M
& & |& && && && && && &|& && & -----------
& & |& && && && && && &|
& & --------------------
8 装入新的gdt和ldt表。
9 刷新段寄存器ds,es,fs,gs
10 使用系统堆栈,即预留的0x6000页面
11 执行start_kernel函数,这个函数是第一个C编制的
& &函数,内核又有了一个新的开始。
--------------------------------------------------------------------------------
compressed/misc.c
compressed/misc.c
The differences in decompressing big and small kernels.
http://www.vuse.vanderbilt.edu/~knopfdg/documentation/hw3_part3.htm
The function decompressed_kernel is invoked from head.S and a parameter to the top of the stack is passed to store the results of the decompression namely, the start addresses of the high and the low buffers which contain the decompressed kernel and the numebr of bytes in each buffer (hcount and lcount).
int decompress_kernel(struct moveparams *mv)
if (SCREEN_INFO.orig_video_mode == 7) {
vidmem = (char *) 0xb0000;
vidport = 0x3b4;
vidmem = (char *) 0xb8000;
vidport = 0x3d4;
lines = SCREEN_INFO.orig_video_
cols = SCREEN_INFO.orig_video_
if (free_mem_ptr & 0x100000) setup_normal_output_buffer(); // Call if smallkernel
else setup_output_buffer_if_we_run_high(mv); // Call if big kernel
makecrc();
puts(&Uncompressing Linux... "
puts(&Ok, booting the kernel.\n"
if (high_loaded) close_output_buffer_if_we_run_high(mv);
return high_
The first place where a distinction is made is when the buffers are to be setup for the decmpression routine gunzip(). Free_mem_ptr, is loaded with the value of the address of the extern variabe end. The variable end marks the end of the compressed kernel. If the free_mem-ptr is less than the 0x100000,then a high buffer has to be setup. Thus the function setup_output_buffer_if_we_run_high is called and the pointer to the top of the moveparams structure is passed so that when the buffers are setup, the start addresses fields are updated in moveparams structure. It is also checked to see if the high buffer needs to be moved down after decompression and this is reflected by the hcount which is 0 if we need not move the high buffer down.
void setup_output_buffer_if_we_run_high(struct moveparams *mv)
high_buffer_start = (uch *)(((ulg)&end) HEAP_SIZE);
//the high buffer start address is at the end HEAP_SIZE
#ifdef STANDARD_MEMORY_BIOS_CALL
if (EXT_MEM_K & (3*1024)) error(&Less than 4MB of memory.\n"
if ((ALT_MEM_K &; EXT_MEM_K ? ALT_MEM_K : EXT_MEM_K) & (3*1024)) error(&Less
than 4MB of memory.\n"
mv-&;low_buffer_start = output_data = (char *)LOW_BUFFER_START;
//the low buffer start address is at 0x2000 and it extends till 0x90000.
high_loaded = 1; //high_loaded is set to 1, this is returned by decompressed_kernel
free_mem_end_ptr = (long)high_buffer_
// free_mem_end_ptr points to the same address as te high_buffer_start
// the code below finds out if the high buffer needs to be moved after decompression
// if the size if the low buffer is &; the size of the compressed kernel and the HEAP_SIZE
// then the high_buffer_start has to be shifted up so that when the decompression starts it doesn’t
// overwrite the compressed kernel data. Thus when the high_buffer_start islow then it is shifted
// up to exactly match the end of the compressed kernel and the HEAP_SIZE. The hcount filed is
// is set to 0 as the high buffer need not be moved down. Otherwise if the high_buffer_start is too
// high then the hcount is non zero and while closing the buffers the appropriate number of bytes
// in the high buffer is asigned to the filed hcount. Since the start address of the high buffer is
// known the bytes could be moved down
if ( (0x100000 LOW_BUFFER_SIZE) &; ((ulg)high_buffer_start)) {
high_buffer_start = (uch *)(0x100000 LOW_BUFFER_SIZE);
mv-&;hcount = 0; /* say: we need not to move high_buffer */
else mv-&;hcount = -1;
mv-&;high_buffer_start = high_buffer_
// finally the high_buffer_start field is set to the varaible high_buffer_start
After the buffers are set gunzip() is invoked which decompresses the kernel Upon return, bytes_out has the number of bytes in the decompressed kernel.Finally close_output_buffer_if_we_run_high is invoked if high_loaded is non zero:
void close_output_buffer_if_we_run_high(struct moveparams *mv)
mv-&;lcount = bytes_
// if the all of decompressed kernel is in low buffer, lcount = bytes_out
if (bytes_out &; LOW_BUFFER_SIZE) {
// if there is a part of the decompressed kernel in the high buffer, the lcount filed is set to
// the size of the low buffer and the hcount field contains the rest of the bytes
mv-&;lcount = LOW_BUFFER_SIZE;
if (mv-&;hcount) mv-&;hcount = bytes_out - LOW_BUFFER_SIZE;
// if the hcount field is non zero (made in setup_output_buffer_if_we_run_high)
// then the high buffer has to be moved doen and the number of bytes in the high buffer is
// in hcount
else mv-&;hcount = 0; // all the data is in the high buffer
Thus at the end of the the decompressed_kernel function the top of the stack has the addresses of the buffers and their sizes which is popped and the appropriate registers set for the move routine to move the entire kernel. After the move by the move_routine the kernel resides at 0x100000. If a small kernel is being decompressed then the setup_normal_output_buffer() is invoked from decompressed_kernel, which just initializes output_data to 0x100000 where the decompressed kernel would lie. The variable high_load is still 0 as setup_output_buffer_if_we_run_high() is not invoked. Decompression is done starting at address 0x100000. As high_load is 0, when decompressed_kernel returns in head.S, a zero is there in the eax. Thus the control jumps directly to 0x100000. Since the decompressed kernel lies there directly and the move routine need not be called.
Linux code taken from misc.c
Comment code added by us
--------------------------------------------------------------------------------
1) Linux的初始内核映象以gzip压缩文件的格式存放在zImage或bzImage之中, 内核的自举代码将它解压到1M内存开始处. 在内核初始化时, 如果加载了压缩的initrd映象, 内核会将它解压到内存盘中, 这两处解压过程都使用了lib/inflate.c文件.
2) inflate.c是从gzip源程序中分离出来的, 包含了一些对全局数据的直接引用, 在使用时需要直接嵌入到代码中. gzip压缩文件时总是在前32K字节的范围内寻找重复的字符串进行编码, 在解压时需要一个至少为32K字节的解压缓冲区, 它定义为window[WSIZE].inflate.c使用get_byte()读取输入文件, 它被定义成宏来提高效率. 输入缓冲区指针必须定义为inptr, inflate.c中对之有减量操作. inflate.c调用flush_window()来输出window缓冲区中的解压出的字节串, 每次输出长度用outcnt变量表示. 在flush_window()中, 还必须对输出字节串计算CRC并且刷新crc变量.&&在调用gunzip()开始解压之前, 调用makecrc()初始化CRC计算表. 最后gunzip()返回0表示解压成功.
3) zImage或bzImage由16位引导代码和32位内核自解压映象两个部分组成. 对于zImage, 内核自解压映象被加载到物理地址0x1000, 内核被解压到1M的部位. 对于bzImage, 内核自解压映象被加载到1M开始的地方, 内核被解压为两个片段, 一个起始于物理地址0x00,另一个起始于高端解压映象之后, 离1M开始处不小于低端片段最大长度的区域. 解压完成后,这两个片段被合并到1M的起始位置.
解压根内存盘映象文件的代码
--------------------------
; drivers/block/rd.c
#ifdef BUILD_CRAMDISK
* gzip declarations
#define OF(args)&&args& && &&&; 用于函数原型声明的宏
#ifndef memzero
#define memzero(s, n)& &&&memset ((s), 0, (n))
typedef unsigned char&&& && &&&定义inflate.c所使用的3种数据类型
typedef unsigned long&&
#define INBUFSIZ 4096& && && && && & 用户输入缓冲区尺寸
#define WSIZE 0x8000& & /* window size--must be a power of two, and */
& && && && && && && && && && && & /*&&at least 32K for zip's deflate method */
static uch *& && &&&用户输入缓冲区,与inflate.c无关
static uch *& && &&&解压窗口
st&&/* valid bytes in inbuf */
s& &/* index of next byte to be processed in inbuf */
st&&/* bytes in output buffer */
static int exit_
static long bytes_& && &&&总解压输出长度,与inflate.c无关
static struct file *crd_infp, *crd_
#define get_byte()&&(inptr
/* Diagnostic functions (stubbed out) */ 一些调试宏
#define Assert(cond,msg)
#define Trace(x)
#define Tracev(x)
#define Tracevv(x)
#define Tracec(c,x)
#define Tracecv(c,x)
#define STATIC static
static int&&fill_inbuf(void);
static void flush_window(void);
static void *malloc(int size);
static void free(void *where);
static void error(char *m);
static void gzip_mark(void **);
static void gzip_release(void **);
#include &../../lib/inflate.c&
static void __init *malloc(int size)
& && &&&return kmalloc(size, GFP_KERNEL);
static void __init free(void *where)
& && &&&kfree(where);
static void __init gzip_mark(void **ptr)
& && &&&; 读取用户一个标记
static void __init gzip_release(void **ptr)
& && &&&; 归还用户标记
/* ===========================================================================
* Fill the input buffer. This is called only when the buffer is empty
* and at least one byte is really needed.
static int __init fill_inbuf(void) 填充输入缓冲区
& && &&&if (exit_code) return -1;
& && &&&insize = crd_infp-&;f_op-&;read(crd_infp, inbuf, INBUFSIZ,
& && &&&if (insize == 0) return -1;
& && &&&inptr = 1;
& && &&&return inbuf[0];
/* ===========================================================================
* Write the output window window[0..outcnt-1] and update crc and bytes_out.
* (Used for the decompressed data only.)
static void __init flush_window(void) 输出window缓冲区中outcnt个字节串
& & ulg c =& && && &/* temporary variable */
& & uch *in,
& & crd_outfp-&;f_op-&;write(crd_outfp, window, outcnt,
& & for (n = 0; n& && && && & ch = *in++;
& && && && &c = crc_32_tab[((int)c ^ ch)&&0xff] ^ (c &;&; ; 计算输出串的CRC
& & bytes_out += (ulg) 刷新总字节数
& & outcnt = 0;
static void __init error(char *x) 解压出错调用的函数
& && &&&printk(KERN_ERR &%s&, x);
& && &&&exit_code = 1;
static int __init
crd_load(struct file * fp, struct file *outfp)
& && &&&insize = 0;& && && && && & /* valid bytes in inbuf */
& && &&&inptr = 0;& && && && && & /* index of next byte to be processed in inbuf */
& && &&&outcnt = 0;& && && && && & /* bytes in output buffer */
& && &&&exit_code = 0;
& && &&&bytes_out = 0;
& && &&&crc = (ulg)0xffffffffL; /* shift register contents */
& && &&&crd_infp =
& && &&&crd_outfp =
& && &&&inbuf = kmalloc(INBUFSIZ, GFP_KERNEL);
& && &&&if (inbuf == 0) {
& && && && && & printk(KERN_ERR &RAMDISK: Couldn't allocate gzip buffer\n"
& && && && && & return -1;
& && &&&window = kmalloc(WSIZE, GFP_KERNEL);
& && &&&if (window == 0) {
& && && && && & printk(KERN_ERR &RAMDISK: Couldn't allocate gzip window\n"
& && && && && & kfree(inbuf);
& && && && && & return -1;
& && &&&makecrc();
& && &&&result = gunzip();
& && &&&kfree(inbuf);
& && &&&kfree(window);
#endif&&/* BUILD_CRAMDISK */
32位内核自解压代码
------------------
; arch/i386/boot/compressed/head.S
#include ·
& && &&&.globl startup_32& && &&&对于zImage该入口地址为0x1000; 对于bzImage为0x101000
startup_32:
& && &&&cld
& && &&&cli
& && &&&movl $(__KERNEL_DS),%eax
& && &&&movl %eax,%ds
& && &&&movl %eax,%es
& && &&&movl %eax,%fs
& && &&&movl %eax,%gs
& && &&&lss SYMBOL_NAME(stack_start),%esp& && &&&# 自解压代码的堆栈为misc.c中定义的16K字节的数组
& && &&&xorl %eax,%eax
1:& && &&&incl %eax& && && && && & # check that A20 really IS enabled
& && &&&movl %eax,0x000000& && &&&# loop forever if it isn't
& && &&&cmpl %eax,0x100000
& && &&&je 1b
* Initialize eflags.&&Some BIOS's leave bits like NT set.&&This would
* confuse the debugger if this code is traced.
* XXX - best to initialize before switching to protected mode.
& && &&&pushl $0
& && &&&popfl
* Clear BSS& && &&&清除解压程序的BSS段
& && &&&xorl %eax,%eax
& && &&&movl $ SYMBOL_NAME(_edata),%edi
& && &&&movl $ SYMBOL_NAME(_end),%ecx
& && &&&subl %edi,%ecx
& && &&&cld
& && &&&rep
& && &&&stosb
* Do the decompression, and jump to the new kernel..
& && &&&subl $16,%esp& && &&&# place for structure on the stack
& && &&&movl %esp,%eax
& && &&&pushl %esi& && &&&# real mode pointer as second arg
& && &&&pushl %eax& && &&&# address of structure as first arg
& && &&&call SYMBOL_NAME(decompress_kernel)
& && &&&orl&&%eax,%eax& && &&&# 如果返回非零,则表示为内核解压为低端和高端的两个片断
& && &&&jnz&&3f
& && &&&popl %esi& && &&&# discard address
& && &&&popl %esi& && &&&# real mode pointer
& && &&&xorl %ebx,%ebx
& && &&&ljmp $(__KERNEL_CS), $0x100000& && &&&# 运行start_kernel
* We come here, if we were loaded high.
* We need to move the move-in-place routine down to 0x1000
* and then start it with the buffer addresses in registers,
* which we got from the stack.
& && &&&movl $move_routine_start,%esi
& && &&&movl $0x1000,%edi
& && &&&movl $move_routine_end,%ecx
& && &&&subl %esi,%ecx
& && &&&addl $3,%ecx
& && &&&shrl $2,%ecx& && &&&# 按字取整
& && &&&cld
& && &&&rep
& && &&&movsl& && &&&# 将内核片断合并代码复制到0x1000区域, 内核的片段起始为0x2000
& && &&&popl %esi& && &&&# discard the address
& && &&&popl %ebx& && &&&# real mode pointer
& && &&&popl %esi& && &&&# low_buffer_start&&内核低端片段的起始地址
& && &&&popl %ecx& && &&&# lcount& && && && && && &内核低端片段的字节数量
& && &&&popl %edx& && &&&# high_buffer_start 内核高端片段的起始地址
& && &&&popl %eax& && &&&# hcount& && && && && && &内核高端片段的字节数量
& && &&&movl $0x100000,%edi& && && && && && &内核合并的起始地址
& && &&&cli& && && && && & # make sure we don't get interrupted
& && &&&ljmp $(__KERNEL_CS), $0x1000 # and jump to the move routine
* Routine (template) for moving the decompressed kernel in place,
* if we were high loaded. This _must_ PIC-code !
move_routine_start:
& && &&&movl %ecx,%ebp
& && &&&shrl $2,%ecx
& && &&&rep
& && &&&movsl& && && && && && && && &# 按字拷贝第1个片段
& && &&&movl %ebp,%ecx
& && &&&andl $3,%ecx
& && &&&rep
& && &&&movsb& && && && && && && && &# 传送不完全字
& && &&&movl %edx,%esi
& && &&&movl %eax,%ecx& && &&&# NOTE: rep movsb won't move if %ecx == 0
& && &&&addl $3,%ecx
& && &&&shrl $2,%ecx& && &&&# 按字对齐
& && &&&rep
& && &&&movsl& && && && && && && && &# 按字拷贝第2个片段
& && &&&movl %ebx,%esi& && &&&# Restore setup pointer
& && &&&xorl %ebx,%ebx
& && &&&ljmp $(__KERNEL_CS), $0x100000& && &&&# 运行start_kernel
move_routine_end:
; arch/i386/boot/compressed/misc.c
* gzip declarations
#define OF(args)&&args
#define STATIC static
#undef memset
#undef memcpy
#define memzero(s, n)& &&&memset ((s), 0, (n))
ypedef unsigned char&&
typedef unsigned long&&
#define WSIZE 0x8000& && && && && & /* Window size must be at least 32k, */
& && && && && && && && && && &&&/* and a power of two */
static uch *& && && && & /* input buffer */
static uch window[WSIZE];& & /* Sliding window buffer */
static unsigned insize = 0;&&/* valid bytes in inbuf */
static unsigned inptr = 0;& &/* index of next byte to be processed in inbuf */
static unsigned outcnt = 0;&&/* bytes in output buffer */
/* gzip flag byte */
#define ASCII_FLAG& &0x01 /* bit 0 set: file probably ASCII text */
#define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */
#define EXTRA_FIELD&&0x04 /* bit 2 set: extra field present */
#define ORIG_NAME& & 0x08 /* bit 3 set: original file name present */
#define COMMENT& && &0x10 /* bit 4 set: file comment present */
#define ENCRYPTED& & 0x20 /* bit 5 set: file is encrypted */
#define RESERVED& &&&0xC0 /* bit 6,7:& &reserved */
#define get_byte()&&(inptr
/* Diagnostic functions */
#ifdef DEBUG
#&&define Assert(cond,msg) {if(!(cond)) error(msg);}
#&&define Trace(x) fprintf x
#&&define Tracev(x) {if (verbose)}
#&&define Tracevv(x) {if (verbose&;1)}
#&&define Tracec(c,x) {if (verbose&&(c))}
#&&define Tracecv(c,x) {if (verbose&;1&&(c))}
#&&define Assert(cond,msg)
#&&define Trace(x)
#&&define Tracev(x)
#&&define Tracevv(x)
#&&define Tracec(c,x)
#&&define Tracecv(c,x)
static int&&fill_inbuf(void);
static void flush_window(void);
static void error(char *m);
static void gzip_mark(void **);
static void gzip_release(void **);
* This is set up by the setup-routine at boot-time
static unsigned char *real_ /* Pointer to real-mode data */
#define EXT_MEM_K& &(*(unsigned short *)(real_mode + 0x2))
#ifndef STANDARD_MEMORY_BIOS_CALL
#define ALT_MEM_K& &(*(unsigned long *)(real_mode + 0x1e0))
#define SCREEN_INFO (*(struct screen_info *)(real_mode+0))
extern char input_data[];
extern int input_
static long bytes_out = 0;
static uch *output_
static unsigned long output_ptr = 0;
static void *malloc(int size);
static void free(void *where);
static void error(char *m);
static void gzip_mark(void **);
static void gzip_release(void **);
static void puts(const char *);
static long free_mem_ptr = (long)
static long free_mem_end_
#define INPLACE_MOVE_ROUTINE&&0x1000& && &&&内核片段合并代码的运行地址
#define LOW_BUFFER_START& && &0x2000& && &&&内核低端解压片段的起始地址
#define LOW_BUFFER_MAX& && & 0x90000& && &&&内核低端解压片段的终止地址
#define HEAP_SIZE& && && && & 0x3000& && &&&为解压低码保留的堆的尺寸,堆起始于BSS的结束
static unsigned int low_buffer_end, low_buffer_
static int high_loaded =0;
static uch *high_buffer_start /* = (uch *)(((ulg) + HEAP_SIZE)*/;
static char *vidmem = (char *)0xb8000;
static int lines,
#include &../../../../lib/inflate.c&
static void *malloc(int size)
& && &&&void *p;
& && &&&if (size& && && &if (free_mem_ptr
& && &&&free_mem_ptr = (free_mem_ptr + 3)&&~3;& && &&&/* Align */
& && &&&p = (void *)free_mem_
& && &&&free_mem_ptr +=
& && &&&if (free_mem_ptr &;= free_mem_end_ptr)
& && && && && & error(&\nOut of memory\n"
static void free(void *where)
{& && &&&/* Don't care */
static void gzip_mark(void **ptr)
& && &&&*ptr = (void *) free_mem_
static void gzip_release(void **ptr)
& && &&&free_mem_ptr = (long) *
static void scroll(void)
& && &&&memcpy ( vidmem, vidmem + cols * 2, ( lines - 1 ) * cols * 2 );
& && &&&for ( i = ( lines - 1 ) * cols * 2; i& && && && && &&&vidmem[ i ] = ' ';
static void puts(const char *s)
& && &&&int x,y,
& && &&&x = SCREEN_INFO.orig_x;
& && &&&y = SCREEN_INFO.orig_y;
& && &&&while ( ( c = *s++ ) != '\0' ) {
& && && && && & if ( c == '\n' ) {
& && && && && && && && &x = 0;
& && && && && && && && &if ( ++y &;= lines ) {
& && && && && && && && && && &&&scroll();
& && && && && && && && && && &&&y--;
& && && && && && && && &}
& && && && && & } else {
& && && && && && && && &vidmem [ ( x + cols * y ) * 2 ] =
& && && && && && && && &if ( ++x &;= cols ) {
& && && && && && && && && && &&&x = 0;
& && && && && && && && && && &&&if ( ++y &;= lines ) {
& && && && && && && && && && && && && & scroll();
& && && && && && && && && && && && && & y--;
& && && && && && && && && && &&&}
& && && && && && && && &}
& && && && && & }
& && &&&SCREEN_INFO.orig_x =
& && &&&SCREEN_INFO.orig_y =
& && &&&pos = (x + cols * y) * 2;& && &&&/* Update cursor position */
& && &&&outb_p(14, vidport);
& && &&&outb_p(0xff&&(pos &;&; 9), vidport+1);
& && &&&outb_p(15, vidport);
& && &&&outb_p(0xff&&(pos &;&; 1), vidport+1);
void* memset(void* s, int c, size_t n)
& && &&&char *ss = (char*)s;
& && &&&for (i=0;i& && &&&
void* memcpy(void* __dest, __const void* __src,
& && && && && && && && && & size_t __n)
& && &&&char *d = (char *)__dest, *s = (char *)__
& && &&&for (i=0;i& && &&&return __
/* ===========================================================================
* Fill the input buffer. This is called only when the buffer is empty
* and at least one byte is really needed.
static int fill_inbuf(void)
& && &&&if (insize != 0) {
& && && && && & error(&ran out of input data\n"
& && &&&inbuf = input_
& && &&&insize = input_
& && &&&inptr = 1;
& && &&&return inbuf[0];
/* ===========================================================================
* Write the output window window[0..outcnt-1] and update crc and bytes_out.
* (Used for the decompressed data only.)
static void flush_window_low(void)
& & ulg c =& && && &/* temporary variable */
& & uch *in, *out,
& & for (n = 0; n& && && && & ch = *out++ = *in++;
& && && && &c = crc_32_tab[((int)c ^ ch)&&0xff] ^ (c &;&; ;
& & bytes_out += (ulg)
& & output_ptr += (ulg)
& & outcnt = 0;
static void flush_window_high(void)
& & ulg c =& && && &/* temporary variable */
& & uch *in,&&
& & for (n = 0; n& && && &ch = *output_data++ = *in++;
& && &&&if ((ulg)output_data == low_buffer_end) output_data=high_buffer_
& && &&&c = crc_32_tab[((int)c ^ ch)&&0xff] ^ (c &;&; ;
& & bytes_out += (ulg)
& & outcnt = 0;
static void flush_window(void)
& && &&&if (high_loaded) flush_window_high();
& && &&&else flush_window_low();
static void error(char *x)
& && &&&puts(&\n\n"
& && &&&puts(x);
& && &&&puts(&\n\n -- System halted&);
& && &&&while(1);& && &&&/* Halt */
#define STACK_SIZE (4096)
long user_stack [STACK_SIZE];
& && &&&long *
& && &&&} stack_start = {&&user_stack [STACK_SIZE] , __KERNEL_DS };
void setup_normal_output_buffer(void) 对于zImage, 直接解压到1M
#ifdef STANDARD_MEMORY_BIOS_CALL
& && &&&if (EXT_MEM_K #else
& && &&&if ((ALT_MEM_K &; EXT_MEM_K ? ALT_MEM_K : EXT_MEM_K) #endif
& && &&&output_data = (char *)0x100000; /* Points to 1M */
& && &&&free_mem_end_ptr = (long)real_
struct moveparams {
& && &&&uch *low_buffer_&&
& && &&&uch *high_buffer_
void setup_output_buffer_if_we_run_high(struct moveparams *mv)
& && &&&high_buffer_start = (uch *)(((ulg) + HEAP_SIZE); 内核高端片段的最小起始地址
#ifdef STANDARD_MEMORY_BIOS_CALL
& && &&&if (EXT_MEM_K #else
& && &&&if ((ALT_MEM_K &; EXT_MEM_K ? ALT_MEM_K : EXT_MEM_K) #endif
& && &&&mv-&;low_buffer_start = output_data = (char *)LOW_BUFFER_START;
& && &&&low_buffer_end = ((unsigned int)real_mode &; LOW_BUFFER_MAX
& && && & ? LOW_BUFFER_MAX : (unsigned int)real_mode)&&~0
& && &&&low_buffer_size = low_buffer_end - LOW_BUFFER_START;
& && &&&high_loaded = 1;
& && &&&free_mem_end_ptr = (long)high_buffer_
& && &&&if ( (0x100000 + low_buffer_size) &; ((ulg)high_buffer_start)) {
& && && && && & ; 如果高端片段的最小起始地址小于它实际应加载的地址,则将它置为实际地址,
& && && && && & ; 这样高端片段就无需再次移动了,否则它要向前移动
& && && && && & high_buffer_start = (uch *)(0x100000 + low_buffer_size);
& && && && && & mv-&;hcount = 0; /* say: we need not to move high_buffer */
& && &&&else mv-&;hcount = -1; 待定
mv-&;high_buffer_start = high_buffer_
void close_output_buffer_if_we_run_high(struct moveparams *mv)
& && &&&if (bytes_out &; low_buffer_size) {
& && && && && & mv-&;lcount = low_buffer_
& && && && && & if (mv-&;hcount)
& && && && && && && && &mv-&;hcount = bytes_out - low_buffer_ 求出高端片段的字节数
& && &&&} else { 如果解压后内核只有低端的一个片段
& && && && && & mv-&;lcount = bytes_
& && && && && & mv-&;hcount = 0;
int decompress_kernel(struct moveparams *mv, void *rmode)
& && &&&real_mode =
& && &&&if (SCREEN_INFO.orig_video_mode == 7) {
& && && && && & vidmem = (char *) 0xb0000;
& && && && && & vidport = 0x3b4;
& && &&&} else {
& && && && && & vidmem = (char *) 0xb8000;
& && && && && & vidport = 0x3d4;
& && &&&lines = SCREEN_INFO.orig_video_
& && &&&cols = SCREEN_INFO.orig_video_
& && &&&if (free_mem_ptr& && && &else setup_output_buffer_if_we_run_high(mv);
& && &&&makecrc();
& && &&&puts(&Uncompressing Linux... &);
& && &&&gunzip();
& && &&&puts(&Ok, booting the kernel.\n&);
& && &&&if (high_loaded) close_output_buffer_if_we_run_high(mv);
& && &&&return high_
Edited by lucian_yao on 04/28/01 01:36 PM.
--------------------------------------------------------------------------------
用网卡从并口启动(I386)
标题& &用网络卡从并口上启动Linux(I386) [re: raoxianhong]
作者 raoxianhong (journeyman)
时间 10/07/01 12:31 PM
“十一”假期,哪儿也不去,做个程序博各位一笑。
=============================================
1、到底想干什么
& &了解Linux的启动过程,制作一个自己的Linux启动程序,可以增加对Linux的了解,还能学习PC机的启动机制,增进对计算机结构的了解,增强对Linux内核学习的信心。也可以在某些专用产品中使用(比如专用的服务器)。为此,我尝试在原来代码的基础上修改制作了一个用网络卡从并口上启动Linux的程序,以博一笑,其中有许多问题值得研究。
2、Linux对启动程序的要求
& &Linux(bzImage Kernel)对启动程序的要求比较简单,你只要能够建立一个启动头(setup.S),给出一些信息,然后将kernel/usr/src/linux/arch/i386/boot/compressed/bvmlinux.out)调到绝对地址0xM地址处),如果有initrd,则将它调到内存高端(离0x100000越远越好,比如如果initrd小于4M,就可以将它调到地址0xB00000,即12M处,相信现在已经很少有少于16M内存的机器了),然后执行一些初始化操作,跳到内核处就行了。
& &当然,说起来容易做起来还有点麻烦,以下分几个问题解释。
3、PC机开机流程--启动程序放在何处
& &PC机加电后,进入实模式,先进行自检,然后初始化各个总线扩展设备(ISA, EISA,PCI,AGP),
全部初始化做完后,从当前启动设备中读一个块(512字节)到07C0:0000处,将控制转到该处。
& &了解这个过程,我们可以决定将启动程序放在何处:
& && &1)放在启动设备的MBR(主启动记录中),比如磁盘的启动扇区。这是一般的启动方式。
& && &2)放在总线扩展设备的扩展rom中,比如网卡的boot rom就行,这里制作的启动程序就是放在网卡中,可以支持16K字节。
& && &3)哪位高手能够修改ROMBIOS,让BIOS在做完初始化后不要马上从启动设备读数据,而是调用一段外面加入的程序(2K字节就够了,当然也必须与修改后的BIOS一起烧在BIOS ROM中),就可以从BIOS启动!
& && &4)先启动一个操作系统,再在此操作系统中写启动程序(比如lodlin16就是从DOS中启动Linux,好象中软提供了一个从Windows下启动Linux的启动程序)。
4、操作系统放在何处
& &操作系统(一般内核在500K-1M之间,加上应用程序可以控制在2M以内,当然都经过压缩了)的数据选择余地就大了,可以从软盘、硬盘、CDROM、网络、磁带机、并口(软件狗上烧个内核和应用程序?)、串口(外接你的设备)、USB设备(?)、PCI扩展卡、IC卡等等上面来读;各位还有什么意见,提醒提醒。有位老兄说实在不行可以用键盘启动,每次启动时把内核敲进去,还有int 16h支持呢,做起来也不难,应该是最节省的方案了。
& &反正一个原则是,在启动程序中能够从该设备上读就行了,这里最简单的就是并口了,简单的端口操作,不需要任何驱动程序支持,不需要BIOS支持,比磁盘还简单(磁盘一般使用int 13h,主要是计算柱面啊、磁头啊、磁道啊、扇区啊好麻烦,幸好有现成的源代码,可以学习学习)。
& &好了,我们挑个简单的方案,将启动代码(bootsect.S+setup.S)放到网络卡的boot rom中,内核数据和应用数据放到另外一台计算机上,用并口提供。下面谈谈几个相关的问题。
5、将数据移动到绝对地址处
& &第一个问题,我们得到数据,因为是在实模式下,所以一般是放在1M地址空间内,怎样将它移动到指定的地方去,在setup.S 的源代码中,使用了int 15h(87h号功能)。这里将该段代码稍加改动,做了些假设,列到下面,流程是:
& && &&&if (%cs:move_es==0)/*由于使用前move_es初始化为0,因此这是第一次调用,此时es:bx是要移动的数据
& && && && && && && && && && &&&存放处bx=0,es低四为位为零表示es:bx在64K边界上,fs的低8位指定目的地地址,
& && && && && && && && && && &&&也以64K字节为单位,用不着那么精确,以简化操作*/
& && && && && & 将es右移四位,得到64K单位的8位地址(这样一来,最多只能将数据移动到16M以下了),作为源数据
& && && && && & 描述符中24位地址的高8位,低16位为零。
& && && && && & 将fs的低8位作为目的地的描述符中24位地址的高8位,同样,它的低16位为零。
& && && && && & 将es存放在move_es中,es自然不会是零,因此以后再调用该例程时就进行正常的移动操作了。
& && && && && & ax清零返回。
& && &&&else
& && && && && & if (bx==0)/*bx为零,表示数据已经满64K了,应该进行实际的移动*/
& && && && && & {
& && && && && && && && &调用int15h 87h号功能,进行实际的数据移动(64K, 0x8000个16字节块)。
& && && && && && && && &目的地址(24位)高8位增一,往后走64K
& && && && && && && && &ax = 1
& && && && && && && && &
& && && && && & }
& && && && && & else
& && && && && & {
& && && && && && && && &ax = 0;
& && && && && && && && &
& && && && && & }
# we will move %cx bytes from es:bx to %fs(64Kbytes per unit)
# when we first call movetohigh(%cs:move_es is zero),
# the es:bx and %edx is valid
# we configure the param first
# follow calls will move data actually
# %ax return 0 if no data really moved, and return 1 if there is data
# really to be moved
movetohigh:
& && &&&cmpw& && &&&$0, %cs:move_es
& && &&&jnz& && &&&move_second
& && &&&# at this point , es:bx(bx = 0) is the source address
& && &&&# %edx is the destination address
& && &&&movb& && &&&$0x20, %cs:type_of_loader
& && &&&movw& && &&&%es, %ax
& && &&&shrw& && &&&$4, %ax
& && &&&movb& && &&&%ah, %cs:move_src_base+2
& && &&&movw& && &&&%fs, %ax
& && &&&movb& && &&&%al, %cs:move_dst_base+2
& && &&&movw& && &&&%es, %ax
& && &&&movw& && &&&%ax, %cs:move_es
& && &&&xorw& && &&&%ax, %ax
& && &&&ret& && && && && && && && && && && && && & # nothing else to do for now
move_second:
& && &&&xorw& && &&&%ax, %ax
& && &&&testw& && &&&%bx, %bx
& && &&&jne& && &&&move_ex
& && &&&pushw& && &&&%ds
& && &&&pushw& && &&&%cx
& && &&&pushw& && &&&%si
& && &&&pushw& && &&&%bx
& && &&&movw& && &&&$0x8000, %cx& && && && && && && && &# full 64K, INT15 moves words
& && &&&pushw& && &&&%cs
& && &&&popw& && &&&%es
& && &&&leaw& && &&&%cs:move_gdt, %si
& && &&&movw& && &&&$0x8700, %ax
& && &&&int& && &&&$0x15
& && &&&jc& && &&&move_panic& && && && && && && && &# this, if INT15 fails
& && &&&movw& && &&&%cs:move_es, %es& && && && && & # we reset %es to always point
& && &&&incb& && &&&%cs:move_dst_base+2& && && && && & # to 0x10000
& && &&&popw& && &&&%bx
& && &&&popw& && &&&%si
& && &&&popw& && &&&%cx
& && &&&popw& && &&&%ds
& && &&&movw& && &&&$1, %ax
& && &&&ret
& && &&&.word& && &&&0, 0, 0, 0
& && &&&.word& && &&&0, 0, 0, 0
& && &&&.word& && &&&0xffff
move_src_base:
& && &&&.byte& && &&&0x00, 0x00, 0x01& && && && && & # base = 0x010000

我要回帖

更多关于 英语竞争机制 的文章

 

随机推荐