自制操作系统（2）软盘读写
作者：互联网
软盘读写
使用Java代码模拟出Floppy软盘：
package org.dreamtech;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
public class Floppy {
// 由于有两个盘面，于是有两个磁头
enum MAGNETIC_HEAD {
MAGNETIC_HEAD_0, MAGETIC_HEAD_1
};
// 每一个盘面有80个柱面
private int CYLINDER_COUNT = 80;
// 每一个柱面有18个扇区
private int SECTORS_COUNT = 18;
// 每一个扇区大小512字节
public int SECTOR_SIZE = 512;
// 默认设置第一个磁头
private MAGNETIC_HEAD magneticHead = MAGNETIC_HEAD.MAGNETIC_HEAD_0;
// 当前读取到的柱面
private int currentCylinder = 0;
// 当前读取到的扇区
private int currentSector = 0;
// 软盘可以定义成key为Integer，value为List<List<byte[]>>的HashMap
// Integer是两个盘面的表示
// byte[]表示一个扇区存储的内容
// List<byte[]>表示一个柱面存储的内容
// List<List<byte[]>>表示一个盘面所有的柱面存储的内容
private HashMap<Integer, ArrayList<ArrayList<byte[]>>> floppy = new HashMap<Integer, ArrayList<ArrayList<byte[]>>>();
public Floppy() {
initFloppy();
}
private void initFloppy() {
// 一个磁盘有两个盘面
floppy.put(MAGNETIC_HEAD.MAGNETIC_HEAD_0.ordinal(), initFloppyDisk());
floppy.put(MAGNETIC_HEAD.MAGETIC_HEAD_1.ordinal(), initFloppyDisk());
}
private ArrayList<ArrayList<byte[]>> initFloppyDisk() {
// 磁盘的一个面
ArrayList<ArrayList<byte[]>> floppyDisk = new ArrayList<ArrayList<byte[]>>();
// 一个磁盘面有80个柱面
for (int i = 0; i < CYLINDER_COUNT; i++) {
floppyDisk.add(initCylinder());
}
return floppyDisk;
}
private ArrayList<byte[]> initCylinder() {
// 一个柱面有18个扇区
ArrayList<byte[]> cylinder = new ArrayList<byte[]>();
for (int i = 0; i < SECTORS_COUNT; i++) {
// 每个扇区先申请512字节的好内存
byte[] sector = new byte[SECTOR_SIZE];
cylinder.add(sector);
}
return cylinder;
}
// 设置读的盘面
public void setMagneticHead(MAGNETIC_HEAD head) {
magneticHead = head;
}
// 设置读的柱面
public void setCylinder(int cylinder) {
if (cylinder < 0) {
this.currentCylinder = 0;
} else if (cylinder >= 80) {
this.currentCylinder = 79;
} else {
this.currentCylinder = cylinder;
}
}
// 设置读的扇区
public void setSector(int sector) {
if (sector < 0) {
this.currentSector = 0;
} else if (sector > 18) {
this.currentSector = 18 - 1;
} else {
this.currentSector = sector - 1;
}
}
// 读磁盘的方法需要设置盘面柱面和扇区号
public byte[] readFloppy(MAGNETIC_HEAD head, int cylinderNum, int sectorNum) {
setMagneticHead(head);
setCylinder(cylinderNum);
setSector(sectorNum);
ArrayList<ArrayList<byte[]>> disk = floppy.get(this.magneticHead.ordinal());
ArrayList<byte[]> cylinder = disk.get(this.currentCylinder);
byte[] sector = cylinder.get(this.currentSector);
return sector;
}
// 写磁盘的方法需要设置盘面柱面和扇区号以及数据
public void writeFloppy(MAGNETIC_HEAD head, int cylinderNum, int sectorNum, byte[] buf) {
setMagneticHead(head);
setCylinder(cylinderNum);
setSector(sectorNum);
ArrayList<ArrayList<byte[]>> disk = floppy.get(this.magneticHead.ordinal());
ArrayList<byte[]> cylinder = disk.get(this.currentCylinder);
byte[] buffer = cylinder.get(this.currentSector);
System.arraycopy(buf, 0, buffer, 0, buf.length);
}
public void makeFloppy(String fileName) {
DataOutputStream out = null;
try {
// 虚拟软盘是存粹的二进制文件，它的逻辑结构如下：
// 前512*18 字节的内容对应盘面0，柱面0的所有扇区内容
// 接着的512*18字节的内容对应盘面1，柱面0的所有扇区内容
// 再接着的512*18字节的内容对应盘面0，柱面1所有扇区内容
// 再接着512*18字节的内容对应盘面1，柱面1所有扇区内容
// 以此类推
// 简单理解就是柱面一正一反来写
// 计算得出最终一个磁盘可以写1440KB的数据
out = new DataOutputStream(new FileOutputStream(fileName));
for (int cylinder = 0; cylinder < CYLINDER_COUNT; cylinder++) {
for (int head = 0; head <= MAGNETIC_HEAD.MAGETIC_HEAD_1.ordinal(); head++) {
for (int sector = 1; sector <= SECTORS_COUNT; sector++) {
byte[] buf = readFloppy(MAGNETIC_HEAD.values()[head], cylinder, sector);
out.write(buf);
}
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
将上节课的汇编代码编译后的二进制文件写入软盘：
package org.dreamtech;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class OperatingSystem {
private Floppy floppyDisk = new Floppy();
private void writeFileToFloppy(String fileName) {
File file = new File(fileName);
InputStream in = null;
try {
in = new FileInputStream(file);
byte[] buf = new byte[512];
// Intel的CPU规定必须在第511-512字节写入0x55aa
buf[510] = (byte) 0x55;
buf[511] = (byte) 0xaa;
if (in.read(buf) != -1) {
// 将内核写入到磁盘第0面第0柱面第1个扇区
floppyDisk.writeFloppy(Floppy.MAGNETIC_HEAD.MAGNETIC_HEAD_0, 0, 1, buf);
}
} catch (IOException e) {
e.printStackTrace();
return;
} finally {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public OperatingSystem(String s) {
writeFileToFloppy(s);
}
public void makeFllopy() {
floppyDisk.makeFloppy("system.img");
}
public static void main(String[] args) {
OperatingSystem op = new OperatingSystem("boot.bat");
op.makeFllopy();
}
}
生成的system.img被成功加载并启动
使用Java实现软盘读写并不是正确的方案，下面采用汇编来实现：
org 0x7c00
entry:
mov ax, 0
mov ss, ax
mov ds, ax
mov es, ax
mov si, msg
readFloppy:
mov CH, 1 ;CH用来存储柱面号
mov DH, 0 ;DH用来存储磁头号
mov CL, 2 ;CL用来存储扇区号
mov BX, msg ;ES:BX数据存储缓冲区，是INT 0x13中断需要的参数
;BX寄存器里面保存的是msg的地址
mov AH, 0x02 ;AH=2表示要做的是读盘操作
mov AL, 1 ;AL表示要连续读取几个扇区
mov DL, 0 ;驱动器编号（一般我们只有一个软盘驱动器，所以写死为0）
INT 0x13 ;调用BIOS中断实现磁盘读取功能
;效果是是将读取到的数据写入msg地址
jc error ;如果读盘出现错误，就执行error处的代码
;如果BIOS调用出错，FLAGS寄存器的CF位会置1，同时把错误代码写入AH
;如果BIOS调用没错，FLAGS寄存器的CF位会置0
;所以这里类似if(FLAGS.CF==1){error();}
putloop:
mov al, [si]
add si, 1
cmp al, 0
je fin
mov ah, 0x0e
mov bx, 15
int 0x10
jmp putloop
fin:
HLT
jmp fin
error:
mov si, errmsg
jmp putloop
msg:
RESB 64 ;申请64字节的地址（从当前的地址开始空出64字节）
errmsg:
DB "error"
进行编译：nasm -o boot.bat boot_readstring_from_sector.asm
修改Java代码并执行：
public void makeFllopy() {
String s = "This is a text from cylinder 1 and sector 2";
floppyDisk.writeFloppy(Floppy.MAGNETIC_HEAD.MAGNETIC_HEAD_0, 1, 2, s.getBytes());
floppyDisk.makeFloppy("system.img");
}
加载到虚拟机，成功打印代码中的这段话
标签：HEAD,操作系统,int,读写,扇区,cylinder,mov,柱面,软盘 来源： https://www.cnblogs.com/xuyiqing/p/13961422.html