0
跪求操作系统课程设计一份
; boot.asm: ANOS fat12 软盘启动代码; Larry Li, 2005.2.25
; 2005.3.19
; 整理注释
PosBuf equ 0700h
StackTop equ 07BF0h
BootStart equ 07C00h
;下盯孙面是内核的加载地址
SegKernel equ 0100h
RootBufEnd equ 02h
DataStart equ 04h
CursorPos equ 10h
; BOOT 会被 BIOS 载入到 00007C00h 处
org 7C00h
; 代码段
segment .text
; 16 位代码
bits 16
; start: 首先是跳过必须的 FAT 信息表执行后面的程序
Start:
jmp short Main
; 补一个衫则迟字节的空指令
nop
; FAT12 信息
; 只是文件系统的描述信息
OEMName db 'ANOSDISK'
; 扇区大小（字节），应为 512
BytesPerSector dw 512
; 簇的扇区数，应为 2 的幂，FAT12 为 1
SectsPerCluster db 1
; 保留扇区，FAT12/16 应为 1
ReservedSectors dw 1
; FAT 结构数目，一般为 2
NumberOfFats db 2
; 根目录项目数，FAT12 为 224
MaxRootEntries dw 224
; 扇区总数，1.44M 软盘为 2880
TotalSectors dw 2880
; 设备类型，1.44M 软盘为 F0h
MediaDescriptor db 0f0h
; FAT 占用扇区数，9
SectorsPerFat dw 9
; 磁道扇区数，18
SectorsPerTrack dw 18
; 磁头数，2
NumberOfHeads dw 2
; 隐藏扇区，默认为 0
HiddenSectors dd 0
; FAT32 使用，0
TotalSectorsBig dd 0
;; 下面的内容为 FAT12/16 所有，和 FAT32 不同
; MS-DOS 使用，0
BootDrive db 0
; Windows NT 使用，0
Reserved db 0
; 附加的可启动标志，29h
ExtendSig db 029h
; 卷标序列号，00000000h
SerialNumber dd 00000000h
; 卷标，11 字节，或李必须用空格( 20h )补齐
VolumeLabel db 'ANOS FLOPPY'
; 文件系统标志，
FileSystem db 'FAT12 '
; Main: BOOT 主程序
Main:
; 初始化运行环境
xor ax,ax
mov ss,ax
mov bp,BootStart
mov sp,StackTop
push ss
pop ds
; LoadRootDirSector: 读取 FAT12 根目录项目扇区
LoadRootDirSector:
push ss
pop es
; 计算 ROOT 启始逻辑扇区
mov al,[BYTE bp+NumberOfFats]
; FAT 表数目
mul WORD [BYTE bp+SectorsPerFat]
; 乘上一个 FAT 表占用的扇区数
add ax,WORD [BYTE bp+HiddenSectors]
; 加上隐藏的扇区数
add ax,WORD [BYTE bp+ReservedSectors]
; 加上保留的扇区数
push ax
mov WORD [BYTE bp-DataStart],ax
; AX ROOT 项目的启始逻辑扇区, 保存
; 计算 ROOT 扇区数
mov ax,20h
mov cx,WORD [BYTE bp+MaxRootEntries]
mul cx
mov bx,WORD [BYTE bp+BytesPerSector]
add ax,bx
dec ax
div bx
mov cx,ax
; CX ROOT 扇区大小
add WORD [BYTE bp-DataStart],ax
; 更新数据区启始逻辑扇区
mul bx
; AX ROOT 总扇区字节大小
mov bx,PosBuf
; BX 缓存启始地址
add ax,bx
; AX 缓存尾地址
mov WORD [BYTE bp-RootBufEnd],ax
; 保存尾地址
pop ax
; 取出 ROOT 项目启始逻辑扇区
call ReadSectors
mov si,bx
; [ES:SI] 根目录内容
; SearchRootDirSector: 在根目录项目中搜索内核文件
SearchRootDirSector:
; [ES:SI] 为当前目录项
; 其头 11 个字节为文件名称
cmp [es:di],ch
; 如果目录项的第一个字节是0，这就是最后一个目录项
jz NotFound
push si
; 保存 SI rep cmpsb 时 SI 会改变
mov cx,11
; 比较前 11 个字节
mov di,FileName
; [DS:DI] 要载入的内核名称
rep cmpsb
; 比较 [ES:SI] [DS:DI]
pop si
; 恢复 [ES:SI] 为当前查对的目录项
je FoundKernel
add si,32
; [ES:SI] 指向下一个目录项
; 每个目录项 32 字节
cmp si,WORD [BYTE bp-RootBufEnd]
; 是否到根目录项目尾
jb SearchRootDirSector
; NotFound: 没有发现内核的处理
NotFound:
mov si,msgNotFound
call PutChars
jmp ReBoot
; FoundKernel: 发现内核后处理
FoundKernel:
; [ES:SI] 内核文件目录项
mov ax,[si+01ah]
push ax
; 内核文件启始簇(低)地址
; 目录项偏移 26(1ah) 为文件项目启始簇低地址
; 偏移 20(14h) 为高地址
; 由 FAT12 只是 12 位簇地址, 低地址 16 位足以
xor dx,dx
mov es,dx
mov ax,WORD [BYTE bp+ReservedSectors]
; DX:AX 第一个 FAT 表的启始逻辑扇区
mov bx,PosBuf
; [ES:BX] 读盘缓存
mov cx,WORD [BYTE bp+SectorsPerFat]
; CX FAT 表扇区数
call ReadSectors
pusha
mov si,msgLoadKernel
call PutChars
popa
mov ax,SegKernel
mov es,ax
xor bx,bx
; [ES:BX] 读盘缓存, 内核载入地址
pop ax
push ax
; 文件的第一个簇
; LoadKernel: 载入内核
LoadKernel:
; AX 当前簇
call ReadCluster
pop ax
; 取当前簇
add bx,0200h
; [ES:BX] 缓存地址增加 512 字节(1 个扇区)
; 下面开始查 FAT12 表项目
; 所以对于簇 n 其项目位于 n / 2 * 3 处
; n / 2 * 3 = n / 2 + n
; n 为偶, 在低 12 位
; n 为奇, 在高 12 位
mov di,ax
; BP DI 文件簇 n
shr di,01h
; DI n / 2
pushf
; 保存标志位, 供以后奇偶处理
add di,ax
; DI n / 2 + n
add di,PosBuf
; DI 加上 FAT12 表的启始地址
mov ax,[di]
; AX 一个 FAT12 组, 两个簇号
popf
; 根据 n / 2 奇偶判定
jc ShiftRight4
and ax,0fffh
; 取低 12 位
jmp IsTheEnd
ShiftRight4:
mov cl,4
shr ax,cl
; 高 12 位, 所以右移 4 位
IsTheEnd:
cmp ax,0ff8h
; 比较, ff8h - fffh 表示簇链末尾
jae ExecKernel
; 载入完毕, 跳转到内核地址
push ax
; 复制下一簇号
jmp LoadKernel
; ExecKernel: 运行内核
ExecKernel:
pusha
mov si,msgLoadKernelOK
call PutChars
popa
mov ah,3
xor bh,bh
int 10h
mov WORD [BYTE bp-CursorPos],dx
; 将当前光标位置写入 7df0h 7df1h
;
push word SegKernel
push word 00h
; 入栈供返回指令跳转
retf
; BadDisk: 显示错误启动信息，然后重启
BadDisk:
mov si,msgDiskError
call PutChars
; ReBoot: 重启
ReBoot:
mov si,msgAnyKey
call PutChars
xor ax,ax
int 16h
; 等待键盘按键
int 19h
; 重启
; ReadCluster: 读磁盘文件簇
; 读数据簇 AX 到 [ES:BX]
; CarryFlag == 1 错误
ReadCluster:
; 显示一个 .
push ax
mov ax,0e2eh
int 10h
pop ax
dec ax
dec ax
; 修正, 簇号 - 2
add ax, WORD [BYTE bp-DataStart]
; AX 数据的启始逻辑扇区
xor dx,dx
mov cx,01h
; ReadSectors: 读磁盘扇区
; 读 CX 个逻辑扇区(地址 DX:AX)到 [ES:BX]
; CarryFlag == 1 错误
ReadSectors:
pusha
push cx ; 保存读取扇区数
; 首先要将 DX:AX 逻辑扇区号转换为[驱动器号][磁头号][磁道号][扇区号]
; 根据：磁盘总扇区 = 磁道数 * 磁头数 * 扇区数
; 逻辑扇区 = (磁道号 * 磁头数 + 磁头号) * 扇区数 + 扇区号 - 1
; （注意：实际在磁道的扇区号是从 1 开始计数的，其他号从 0 开始）
; 那么：扇区号 = 逻辑扇区 % 磁道的扇区数 + 1
; 同样：含磁头计算的磁道号 = 逻辑扇区 / 磁道的扇区数
; 除掉磁头数，就是：磁道号 = 含磁头计算的磁道号 / 磁头数
; 所以：磁头号 = 含磁头计算的磁道号 % 磁头数
xchg ax,cx ; AX <=> CX
xchg ax,dx ; AX <=> DX
; AX:CX 逻辑扇区
xor dx,dx ; DX 清零
div WORD [BYTE bp+SectorsPerTrack] ; 除高位
; 计算得含磁头计算的磁道号的高位
xchg ax,cx ; 临时保存到 CX
; 此时余数 DX 与 AX 组成新数继续低位除
div WORD [BYTE bp+SectorsPerTrack] ; 除低位
; 余数 DX 为 0 开的扇区号
inc dx ; 修正为 1 开
xchg cx,dx ; CX <=> DX
; CX 为扇区号
; DX:AX 为含磁头计算的磁道号
div WORD [BYTE bp+NumberOfHeads] ; 继续除
; AX 为磁道号
; DX(DL) 为磁头号
mov dh,dl
; DH 磁头号
mov dl,[BYTE bp+BootDrive]
; DL 驱动器号
mov ch,al
; CX bit 8-15(CH) 磁道低 8 位
ror ah,2
; CX bit 6-7(AH bit 6-7) 磁道高 2 位
or cl,ah
; CX bit 0-5 扇区
pop ax
; AL 操作扇区数目
mov ah,02h
; AH 02h 读磁盘扇区
int 13h
; BIOS 13h 调用
; int 13h BIOS 功能
; 参数
; AH = 0x02 读磁盘扇区到内存
; AL 需要读出的扇区数量
; CH 磁道(柱面)号的低 8 位
; CL 开始扇区(0-5位)，磁道号高 2 位(6-7)
; DH 磁头号
; DL 驱动器号
; ES:BX 指向数据缓存
; 返回
; 出错置 CF 标志位
; AH 状态 = 0x01
; AL 读取的扇区数
jc BadDisk
popa
ret
; PutChars: 打印字符串
; 入口参数 si
PutChars:
lodsb
or al,al
jz short Done
mov ah,0eh
mov bx,07h
int 10h
jmp short PutChars
Done:
retn
TheEnd:
db 0
msgLoadKernel db 'Loading ANOS',0
msgLoadKernelOK db 'OK!',0Dh,0Ah,0
msgNotFound db 'Cannot found ANOS kernel!',0Dh,0Ah,0
msgDiskError db 'Disk Error!',0Dh,0Ah,0
msgAnyKey db 'Press any key to reboot...',0Dh,0Ah,0
; 将 BOOT 映象对齐到 512 个字节
times 496-($-$$) db 0
FileName db 'ANOS SYS',0,0
BootPartition:
db 0
; 启动标志
BootSignature dw 0AA55h ; BootSector signature
华中科技大学软件工程课程设置
主干学科：马克思主义枯巧理论、大学外语、高等数学、大学物理、物理实验、线性代数、概率论与数理统计、程序设计语言、数据结构、离散数学、操作系统、编译技术、软件工程概论、统一建模语言、软件体系结构、软件需求、软件项目管理该专业除了学习公共基础课外，还将系统学习离散数学、数据结构、算法分析、面向对象程序设计、现代操作系统、数据库原理与实现技术、编译原理、软件工程、软件项目管理、计算机安全等课程，根据学生的兴趣还可以选修一些其它选修课。
实践环节：毕业实习、课程设计、计算机工程实践、生产实习、毕业设计(论文)。
软件工程专业是2002年国家教育部新增专业，随着计算机应用领域的不断扩大及中国经济建设的不断发展，软件工程专没行键业将成为一个新的热门专业。软件工程专业以计算机科学与技术学科为基础，强调软件开发的工程性，使学生在掌握计算机科学与技术方面知识和技能的基础上熟练掌握从事软件需求分析、软件设计、软件测试、软件维护和软件项目管理等工作所必需的基础知识、基本方法和基本技能，突出对学带毁生专业知识和专业技能的培养，培养能够从事软件开发、测试、维护和软件项目管理的高级专门人才。
操作系统课程设计
最近没什么写日记，想写，但是对于感情方面的写多了没意思，变得庸俗。于是，我决定来一个科学的日志。下面就写写我在操作系统那门课中的一个实验：银行家算法。自从学了java，在我对游戏和网络情有独钟的基础上，我抛弃了c语言，因此，这个实验我是用java来编写的。线程我没学，所以就简单地写几个输入，然后得出结果。银行家算法大家懂吗？我想，我们学院的都应该懂的。简单地来讲，就是假设系统有n种资源，每种资源有m个数量。又假设有k个进程。如果某进程要取得一些资源则系统首先测试是否满足资源请求要求，如果满足，则尝试分配，接着就判断分配后系统有没有发生死锁，有，就还原，没有就继续。如果某进程要求进入内存，则系统要判断所有进程的请求资源数有没有超过可用资源，有则不许建立，没有就可以建立该进程。
花了几个小时（其实大概一个小时就能搞定，不过可能困的原因，有两个错误没有看出来。我在此要提醒大家，编写程序的格式非常重要，不然检查错误是在很难。），终于写完程序和报告。下面就贴上我的代码吧。
/*
* 操作系统实验：
* 《银行家算法》本程序参考课本的例子，资源种数为3.如果要求更多可作相应更改。
*/
/**
*
* @author Kevin 华南农业大学
*/
//银行家算法，此为Banker类。
import java.util.ArrayList;
import java.util.Random;
public class Banker {
static int[] available = {10,5,7}; //各个资源可用的数量。
static ArrayList processM = new ArrayList(); //线性表，里面装的是进程。
public static void main(String[] args){ //主函数，调试用。
Process p1 = new Process(7,5,3);
Process p2 = new Process(3,2,2);
Process p3 = new Process(9,0,2);
Process p4 = new Process(2,2,2);
Process p5 = new Process(4,3,3);
processM.add(p1);
processM.add(p2);
processM.add(p3);
processM.add(p4);
processM.add(p5);
while(!p1.isOK() || !p2.isOK() || !p3.isOK() || !p4.isOK() || !p5.isOK()){ //进程都还有没满足的就继续申请。
p1 = (Process)processM.get(0);
p2 = (Process)processM.get(1);
p3 = (Process)processM.get(2);
p4 = (Process)processM.get(3);
p5 = (Process)processM.get(4);
if(!p1.isOK())
allocation(p1.request(),p1,0); //申请资源，以下同。
if(!p2.isOK())
allocation(p2.request(),p2,1);
if(!p3.isOK())
allocation(p3.request(),p3,2);
if(!p4.isOK())
allocation(p4.request(),p4,3);
if(!p5.isOK())
allocation(p5.request(),p5,4);
}
}
public static boolean allocation(int[] rq ,Process process,int n){ //进程请求分配函数，
if(process.have[0] + rq[0] > process.claim[0] || process.have[1] + rq[1] > process.claim[1] || process.have[2] + rq[2] > process.claim[2]){
System.out.println("申请失败。"+ (n+1)); //如果请求的资源比最大需求大，则申请失败。
return false;
}
else{
if(rq[0] > available[0] || rq[0] > available[0] || rq[0] > available[0]){
//如果要求的资源暂时不够，则先挂起。
}
else{
process.have[0] = process.have[0] + rq[0];
process.have[1] = process.have[1] + rq[1];
process.have[2] = process.have[2] + rq[2];
available[0] = available[0]-rq[0];
available[1] = available[1]-rq[1];
available[2] = available[2]-rq[2];
processM.add(n, process);
processM.remove(n+1);
}
if(safe()){ //如果安全，则分配成功。
System.out.println("申请成功。"+"进程"+ (n+1)+"已获得资源分别为："+ process.have[0]+" "+process.have[1]+" "+process.have[2]);
return true;
//如果安全，那资源被该进程利用。
}
else{
process.have[0] = process.have[0] - rq[0];
process.have[1] = process.have[1] - rq[1];
process.have[2] = process.have[2] - rq[2];
available[0] = available[0]+ rq[0];
available[1] = available[1]+ rq[1];
available[2] = available[2]+ rq[2];
processM.add(n, process);
processM.remove(n+1);
System.out.println("申请失败。" + (n+1)); //不安全，则申请失败.
return false;
//如果不安全，则还原，并且挂起该进程。
}
}
}
public static boolean safe(){ //判断分配后是否安全。
ArrayList rest = new ArrayList(processM);
Process test ;
int num = rest.size();
int found = num*num;
while(found > 0 && !rest.isEmpty()){
test = (Process)rest.remove(0);
if(test.claim[0] - test.have[0] <= available[0] && test.claim[1] - test.have[1] <= available[1] && test.claim[2] - test.have[2] <= available[2] ){
available[0] = available[0] + test.have[0];
available[1] = available[1] + test.have[1];
available[2] = available[2] + test.have[2];
}
else {
rest.add(test);
}
found--;
}
if(rest.isEmpty()){
return true;
}
else
return false;
}
}
class Process{ //此类为进程类，描述的是一个进程。
int[] claim =new int[3]; //这个进程需要的资源数。
int[] have = new int[3];
public Process(int n1,int n2,int n3){ //初始化进程
claim[0] = n1;
claim[1] = n2;
claim[2] = n3;
have[0] = 0;
have[1] = 0;
have[2] = 0;
}
public boolean isOK(){ //判断这个进程得到满足没有。
if(have[0] == claim[0] && have[1] == claim[1] && have[2] == claim[2]){
return true;
}
else return false;
}
public int[] request(){ //这个函数随机生成3个数，作为某个进程的请求。
Random random = new Random(); //实例化随机对象。
int[] num = new int[3];
num[0] = random.nextInt(10);
System.out.println(num[0]);
num[1] = random.nextInt(10);
System.out.println(num[1]);
num[2] = random.nextInt(10);
System.out.println(num[2]);
return num;
}
}
