ကိုယ္ပိုင္ ကြန္ျပဴတာ Boot Loader ဘယ္လို Develop လုပ္မလဲ
Brighter Myanmar က တင္တဲ့ ပို႔စ္ေတြမွာ သာမာန္ထက္ ပိုပီး စိတ္၀င္ စားစရာေကာင္းတဲ့ Data Processing နဲ႔ Hardware Components ေတြ အေၾကာင္း ပါပါတယ္၊ အခုေရးမယ့္ ကြန္ျပဴတာ Bootloader Development က High-level နဲ႔ low-level ေပါင္းပီး Bootloader Develop လုပ္မယ့္ Project အေၾကာင္းပါ၊ ပံုမွန္ေတာ့ Desktop Application တို႔ Phone Application တို႔ တည္ေဆာက္ ဖို႔ အတြက္ Hight-level programming ေတြျဖစ္တဲ့ C, C++ နဲ႔ ဖုန္း application အတြက္ Java ကို အသံုးျပဳၾကပါတယ္၊ ဒါေပမယ့္ လိုအပ္လို႔ low-level Programming နဲ႔ ပတ္သတ္တဲ့ System ၀င္တင္တဲ့ အလုပ္မ်ိဳး ကို လုပ္လာရပီဆိုရင္ low-level programming ျဖစ္တဲ့ Assembly ကိုသံုးရပါလိမ့္မယ္၊ ဒီပို႔စ္ မွာ ကြန္ျပဴတာ စဖြင့္တာနဲ႔ ဘယ္လို အဆင့္ဆင့္အလုပ္လုပ္သြားလဲ နဲ႔ System တစ္ခုလံုး ဘယ္လို ၀န္တင္လဲ ဆိုတာကိုေျပာသြားမယ္၊ ပီးေတာ့ ကြန္ျပဴတာ System Booting ရဲ့ ပထမဆံုး အစိတ္အပိုင္း ျဖစ္တဲ့ ကိုယ္ပိုင္ boot loader တစ္ခု ဘယ္လို Develop လုပ္မလဲ ဆိုတာ ကို Project တစ္ခု အေနနဲ႔ ရွင္းသြားမယ္။
Bootloader ဆိုတာဘာလဲ
ပထမဆံုးေျပာခ်င္တာကေတာ့ ဒီပို႔စ္မွာေရးမယ့္ Bootloader က အရင္ေရးခဲ့ဖူးတဲ့ Android Bootloader မဟုတ္ဘူးဆိုတာပဲ၊ ခု ေျပာမယ့္ Bootloader က ကြန္ျပဴတာ Bootlaoder ပါ၊
Bootloader က ကြန္ျပဴတာ Hard drive ရဲ့ ပထမဆံုး အစိတ္အပိုင္းမွာ တည္ရွိတယ္၊ အဲ့ဒီ့ bootloader အစိတ္အပိုင္းကပဲ ကြန္ျပဴတာေတြ boot စလုပ္တယ္၊ BIOS (Basic Input Output) က ကြန္ျပဴတာ Power စဖြင့္တာနဲ႔ ကြန္ျပဴတာ ရဲ့ Hard drive ပထမဆံုး အစိတ္အပိုင္းမွာ ရွိတဲ့ ကုတ္ေတြကို စဖတ္ပါ တယ္၊ အဲ့ဒီ့ ပထမဆံုး အစိတ္အပိုင္းကို Master Boot Record လို႔ေခၚပါတယ္၊
လက္ေတြ႔လုပ္မယ္
ကိုယ္ပိုင္ Bootloader တစ္ခု တည္ေဆာက္ဖို႔ အတြက္ လိုအပ္တဲ့ ကြန္ျပဴတာ ဘာသာရပ္နဲ႔ အသံုးျပဳမယ့္ IDE ေတြ အေၾကာင္းကိုေျပာမယ္၊ ွSystem Boot အတြက္ လိုအပ္တဲ့ အခ်က္အလက္ေတြ ကိုလဲ ထည့္ေျပာ သြားမယ္၊
Bootloader တစ္ခု တည္ေဆာက္ဖို႔ ဘယ္လို ကြန္ျပဴတာ ဘာသာရပ္ေတြ တတ္ထားရမလဲ
ကြန္ျပဴတာ Power စဖြင့္တာနဲ႔ interrupts လို႔ေခၚတဲ့ BIOS function က စတင္အလုပ္လုပ္ပါမယ္၊ BIOS function ျဖစ္တဲ့ Interrupts ရဲ့ အဓီက အလုပ္ကေတာ့ ကြန္ျပဴတာကို ထိန္ခ်ဳပ္မယ့္ Hardware ေတြကို စတင္ အသက္သြင္း ေမာင္းႏွင္ျခင္းပါ၊ ဒီေတာ့ စဥ္းစားရတာ လြယ္တယ္၊ အျခား ဘယ္ Program မွ အလုပ္ လုပ္ခြင့္မရခင္ interrupts က အလုပ္ စလုပ္မယ္ဆိုေတာ့ အဲ့ဒီ့ interrupts function ကို ေရးမယ့္ ကုတ္က C နဲ႔ C++ မျဖစ္ႏိုင္ေတာ့ဘူး၊ ဘာလို႔လဲဆိုေတာ့ C နဲ႔ C++ က Compiler ေတြလို တယ္၊ အဲ့ဒီ့လိုပဲ mid-level ဘာသာရပ္ျဖစ္တဲ့ Java က လဲ JVM ရွိမွ အလုပ္လုပ္မွာျဖစ္လို႔ သံုးလို႔မရ ဘူးေလ၊ ဒီေတာ့ Hardware ေတြကို တိုက္ရိုက္ အလုပ္ခိုင္းႏိုင္မယ့္ low-level ဘာသာရပ္ျဖစ္တဲ့ Assambly ကိုပဲ သံုးဖို႔ရွိေတာ့တာေပါ့၊ ဒါ့ေၾကာင့္ ကိုယ္ပိုင္ Bootlaoder Develop လုပ္လိုတဲ့ သူအတြက္ Assambly ဘာသာရပ္ကို အသင့္အသင့္ေတာ့ တတ္ထားဖို႔လိုအပ္ပါတယ္၊ ဒါေပမယ့္ အသဲ အသန္ ကၽြမ္းက်င္ဖို႔ ေတာ့လဲ မလိုလွပါဘူး၊ အေၾကာင္းက Brighter Myanmar ရဲ့ Bootloader Project မွာ High-level ဘာသာရပ္နဲ႔ တည္ေဆာက္ထားတဲ့ ကုတ္ေတြကို low-level နဲ႔ အမိန္႔ေပး အလုပ္လုပ္ခိုင္းတဲ့ "mixed-code" နည္းပညာကိုသံုးသြားမွာမို႔႔ပါ၊ ဒီလို "mixed-code" နည္းပညာကို အသံုးျပဳျခင္းဟာ Bootloader Develop လုပ္ျခင္းကို ပိုမိုေခ်ာေမြ႔ေစမွာျဖစ္ပါတယ္၊ ခုအဓီက သံုးသြားမွာက Hight-level ဘာသာရပ္ျဖစ္တဲ့ C++ ကို အဓိက သံုးမယ္၊ C ကို ကၽြမ္းက်င္ထားရင္ ခု သံုးမယ့္ C++ ကို ေလ့လာရ တာ လြယ္ပါတယ္၊ ဒါေပမယ့္ ေရးထားတဲ့ ကုတ္ေတြရဲ့ လုပ္ေဆာင္ႏိုင္စြမ္း အဆင့္ျမင့္ဖို႔အတြက္ေတာ့ C++ က ပိုပီး အဆင္ေျပပါတယ္၊ Java နဲ႔ C# ကေတာ့ Virtual Machine ေတြၾကားခံပီး Compile လုပ္ရတဲ့အတြက္ processor insturctions လုပ္မယ့္ ဒီ Project အတြက္ လံုး၀ကို သံုးမရပါဘူး (Java အတြက္ ၾကားခံ compiler က Java Virtual Machine ျဖစ္ပီး C# အတြက္ေတာ့ .NET ျဖစ္ပါတယ္)၊ ဒီေတာ့ C++ နဲ႔ Assambler ကို သံုးသြားၾကမယ္၊
ဘယ္လိုု compiler အမ်ိဳးအစား သံုုးသြားမလဲ
ကၽြန္ေတာ္တို႔က mixed-code နည္းကိုသံုးသြားမွာ ဆိုေတာ့ ဘာသာရပ္ႏွစ္ခုကို ေရာမယ္ေပါ့၊ ဘာသာ ရပ္ႏွစ္ခုဆိုေတာ့ compiler ႏွစ္ခုလိုပီ၊ ပီးေတာ့ .obj ဖိုင္ေတြအျဖစ္ object ဖိုင္ေတြကို ခ်ိတ္ဆက္ေပးမယ့္ linker လဲလိုတယ္၊
processor function ေတြမွာ mode ႏွစ္မ်ိဳးရွိတယ္၊ real mode နဲ႔ protected mode တို႔ပါ၊ real mode က 16-bit ျဖစ္ပီး ကန္႔သတ္ခ်က္ တစ္ခ်ိဳ႕ရွိပါတယ္၊ Protected mode ကေတာ့ 32-bit ျဖစ္ပီး Operation System ေတြအလုပ္လုပ္ရာမွာ အျပည့္ အ၀ ေထာက္ပံ့ေပးထားပါတယ္၊ processor ေတြ စတင္အလုပ္လုပ္တဲ့ အခါ မွာ 16 bit mode နဲ႔ လုပ္ပါတယ္၊ ဒီေတာ့ 16-bit mode အတြက္ အလုပ္ လုပ္ႏုိင္မယ့္ Program တစ္ခုကိုတည္ေဆာက္ပီး အလုပ္လုပ္မယ့္ ဖိုင္ေတြ Run ေပးရမယ္၊ Assembler ဖိုင္ေတြကို compile လုပ္ပီး ခ်ိတ္ဆက္ေပးဖို႔ compiler တစ္ခုနဲ႔ linker တစ္ခုလိုမယ္၊ modern compilers ေတြကေတာ့ 32-bit applications ေတြမွာသာလွ်င္ အလုပ္လုပ္တဲ့ အတြက္ 16-bit mode အတြက္သံုးလို႔မရဘူး၊ C++ အတြက္ Compiler ကေတာ့ Microsoft Virsual Studio 1.52 ကိုသံုးသြား မယ္၊ ေအာက္က Compiler စာရင္းကို ၾကည့္ပါ၊
ML 6.15 – Assembler compiler by Microsoft for 16-bit mode;
LINK 5.16 – the linker that can create .com files for 16-bit mode;
CL – С, С++ compiler for 16-bit mode.
အျခား Compiler အမ်ိဳး အစားေတြကိုလဲ အသံုးျပဳႏိုင္ပါတယ္၊
DMC – free compile for Assembler, C, C++ for 16 and 32-bit mode by Digital Mars;
LINK – free linker for DMC compiler;
ေနာက္ထပ္ ေရြးခ်ယ္ႏိုင္တဲ့ Compilers ေတြလဲ ရွိပါေသးတယ္၊
BCC 3.5 – С, С++ compiler that can create files for 16-bit mode;
TASM - Assembler compiler for 16-bit mode;
TLINK – linker that can create .com files for 16-bit mode.
ေအာက္မွာ ပါ၀င္တဲ့ ကုတ္ေတြ အားလံုးကို Microsoft က Compiler ကို သံုးပီး တည္ေဆာက္ ထားတာပါ၊
System ေတြ ဘယ္လို Boot လုပ္သလဲ
ဒီ Project နဲ႔ ပက္သက္ပီး အဓိက နားလည္ထားရမယ့္ System Booting အေၾကာင္းကို အက်ည္းခ်ဳပ္ ေျပာပါမယ္၊ အထက္က ပံုကိုေတာ့ ေသခ်ာၾကည့္ထားပါ၊ RAM ရဲ့ Address 0000:7C00 ကိုစပီး control ကို ပို႔ေပးတာနဲ႔ MBR (Master Boot Record) က Operation System boot ကို စတင္ေခၚပါတယ္၊ (MBR- Master Boot Record ရဲ့ အဆင့္ဆင့္ အလုပ္လုပ္ပံုနဲ႔ တည္ေဆာက္ပံုကို အျခား ပို႔စ္ တစ္ခု အေနနဲ႔ ရွင္းျပေပးပါမယ္)၊
ကုတ္ အစီအစဥ္
ေနာက္တစ္ပိုက္ေရာက္ရင္ low-level programming သံုးပီး ကုတ္စေရးမယ္၊ ခုေတာ့ တဆင့္စီ လုပ္ သြားမယ့္ Plan ကိုရွင္းျပမယ္၊ ခုတည္ေဆာက္သြားမယ့္ Bootloader က ေအာက္က အလုပ္ေတြ အားလံုးကို လုပ္ႏိုင္စြမ္းရွိမယ္၊
Memory ရဲ့ 0000:7C00 address ကို မွန္ကန္စြာ ၀န္တင္ႏိုင္ရမယ္၊
high-level language နဲ႔ Develop လုပ္ထားတဲ့ BootMain Function ကို ေခၚႏိုင္ရမယ္၊
Hello World ဆိုတဲ့ စာလံုးကို low-level သံုး message တစ္ခု အေနနဲ႔ ေဖာ္ျပႏိုင္ရမယ္၊
Program architecture
ပထမဆံုး High-level ဘာသာရပ္ေတြ နဲ႔ အလုပ္မလုပ္ႏိုင္ခင္ StartPoint အလုပ္(entity) ကို Assamby ဘာသာသီးသန္႔ သံုးပီး Develop လုပ္မယ္၊ StartPoint အလုပ္(entity) က ဘယ္ Compiler ကိုသံုးမလဲ ဆိုတာကို ေရႊးခ်ယ္ေပးရမယ့္ တာ၀န္ရယ္ disk ကို ဖတ္ပီးသြားရင္ Memory ရဲ့ ဘယ္ address မွာ ၀န္တင္ ရမယ္ဆိုတာကို ညြန္းမယ့္ အလုပ္ ရယ္ processor ေတြရဲ့ register လုပ္မူကို မွန္ေအာင္ လုပ္ရမယ့္ အလုပ္ရယ္ High-level ဘာသာရပ္နဲ႔ ေရးထားတဲ့ BootMain ကို ဘယ္လို ထိန္းခ်ဳပ္မူေတြ လွမ္းပိုရ ရမယ္ဆိုတဲ့ အလုပ္ေတြကိုလုပ္ရမယ္၊
BootMain ကေတာ့ Program တစ္ခုလံုးရဲ့ အလုပ္လုပ္ေဆာင္မူေတြအားလံုးကို ေရးထားတဲ့ အစိတ္ အပိုင္းျဖစ္မယ္၊ CDisplay နဲ႔ CString Classes ေတြက screen ေပၚမွာ message ေတြကိုေဖာ္ျပမယ့္ အစိတ္အပိုင္းကိုတာ၀န္ယူရမယ္၊ CD display Class uက အလုပ္လုပ္တဲ့ အခါမွာ CStringclass ကို ေခၚသံုးသြားမယ္၊ ဒီပို႔စ္မွာေတာ့ Microsoft Visual Studio 2005 (သို႔) 2008 တို႔ ကိုသံုးပီးလုပ္ သြား တယ္၊
အရင္ဆံုး အဓိက အလုပ္ကိုလုပ္မယ့္ Makefile Project တစ္ခုကို တည္ေဆာက္လိုက္ပါ၊
Screen ေပၚမွာ message ကိုေဖာ္ျပမွာ ျဖစ္တဲ့အတြက္ အရင္ဆံုး Screen ကို ရွင္းထားရပါမယ္၊ ဒီ့အတြက္ BIOS interrupt ကိုသံုးသြားမယ္၊ BIOS မွာ Video adapter, keyboard, disk system တို႔လို ကြန္ျပဴတာ Hardware ေတြနဲ႔ တြဲပီး အလုပ္လုပ္ဖို႔ အတြက္ interrupts ေတြ ရွိပါတယ္၊ interrupt တစ္ခုစီမွာ ေအာက္ပါပံုစံ တည္ေဆာက္ပံုေတြ ပါပါတယ္၊
int [number_of_interrupt];
number_of_interrupt က inturrupt နံပါတ္ေတြကို ညြန္းပါတယ္၊ interrupt တစ္ခုစီအတြက္ သက္ဆိုင္ရာ Parameters ေတြရွိပါတယ္၊ အဲ့ဒီ့ parameters ေတြကို interrupt ကို ေခၚမသံုးခင္ ျဖည့္ထားရပါမယ္၊
"ah" processor register က လက္ရွိအသံုးျပဳေနတဲ့ interrupt ရဲ့ function ေတြရဲ့ အလုပ္တာ၀န္ပါ၊ အျခား registers ေတြကေတာ့ current operation အတြက္ အျခား parameters ေတြကိုညြန္းပါတယ္၊ ခု "int 10h" interrupt က Assembler မွာ ဘယ္လို အလုပ္လုပ္သလဲ ဆိုတာကိုၾကည့္ပါမယ္၊ ဗြီဒီယို mode နဲ႔ Screen ကို ရွင္းႏိုင္တဲ့ 00 function ကိုသံုးၾကည့္မယ္၊
mov al, 02h ; (graphical mode ကို 80x25 ခ်ိန္ရန္)
mov ah, 00h ; (video mode ကို ေျပာင္းတဲ့ function)
int 10h ; (interruption ကိုစေခၚပီ)
ခု Application မွာ သံုးမယ့္ interrupts နဲ႔ functions ေတြကို ျပင္ဆင္သြားမယ္၊
int 10h, function 00h; (video mode ကိုေျပာင္းပီး Screen သန္ရရွင္းေရးလုပ္တယ္)၊
int 10h, function 01h – (cursor မွတ္တယ္)၊
int 10h, function 13h – (Screen ေပၚမွာ စာသားေဖာ္ျပတယ္)၊
Mixed code
C++ compiler က Assembler ကို Buildin အျဖစ္ ေထာက္ပံ့ေပးထားတဲ့ အတြက္ High-level ဘာသာ နဲ႔ ကုတ္ေရးေနတဲ့ အခါ low-level ကိုလဲ သံုးသြားႏိုင္ပါတယ္၊ ဒီလို high-level မွာသံုးတဲ့ Assembler ကုတ္ ညြန္ၾကားခ်က္ေတြကို asm insertions လို႔လဲေခၚပါတယ္၊ သူတို႔မွာ _asm ဆိုတဲ့ keyword ေတြကို တြန္႔ကြင္းထဲမွာ ကုတ္အစိတ္အပိုင္းေတြ အေနနဲ႔ ထည့္ထားရပါတယ္၊ key word ေတြ စတင္တဲ့အခါ _asm ဆိုပီး ေရးသားပီး စတင္ရပါတယ္၊ ေအာက္က ဥပမာကိုၾကည့္ပါ၊
{ ; ကုတ္ စတင္မွဴ
… ; ကုတ္မ်ား
} ; ကုတ္ အဆံုး
mixed code တြဲသံုး လက္ေတြ႔ သိသြားေအာင္ အထက္က Screen သန္႔ရွင္းေရးလုပ္တဲ့ Assembler ကုတ္နဲ႔ C++ ကုတ္တို႔ကို တြဲသံုးၾကည့္ပါမယ္၊ ဒီ့အတြက္ အရင္ဆံုး return type "void" သံုးပီး ClearScreen() function ကိုတည္ေဆာက္ပါ၊ ပီးရင္ _asm ဆိုပီး Assembler ကုတ္စေရးပါ၊ အထက္က ေျပာခဲ့တဲ့ အတိုင္း တြန္႔ကြင္းထဲမွာ ေရးပါ၊
void ClearScreen()
{
__asm
{
mov al, 02h ;
mov ah, 00h ;
int 10h ;
}
CString ထည့္သြင္းျခင္း
CString class ကို စာသား တန္ဖိုးေတြနဲ႔ တြဲပီး အလုပ္လုပ္လို႔ရေအာင္ ဒီဇိုင္းစင္ထားတယ္၊ string ေတြ ကို parameter အျဖစ္ ညြန္းႏိုင္ပီး သေကၤသေတြကို စာသားတန္ဖိုး အေနနဲ႔ return လုပ္ေပးႏိုင္တဲ့ pointer ပါတဲ့ Strlen() method ကို include လုပ္ထားဖို႔ လိုမယ္၊
// CString.h ; CString ရဲ့ Header ဖိုင္ကို ထည့္တယ္၊
#ifndef __CSTRING__ //CSTRING ကို ------########## လုပ္တယ္၊
#define __CSTRING__ //CSTRING ကို Define လုပ္တယ္၊
#include "Types.h" //Types header ဖိုင္ကို Include လုပ္တယ္၊
class CString // CString class တည္ေဆာက္တယ္၊
{ public: // access modifier ကို public ထားတယ္၊
static byte Strlen( //တျခား class ကေခၚသံုးႏိုင္ေအာင္ static ထားတယ္ return ေပးမွာက byte code ေတြျဖစ္ျလို႔ byte သံုးတယ္။ Method က Strlen;
const char far* inStrSource //const သံုးပီး charater datatype နဲ႔ pointer ျဖစ္တဲ့ inStrSource တည္ေဆာက္တယ္၊
);
};
#endif // __CSTRING__
// CString.cpp // C++ ဖိုင္တည္ေဆာက္တယ္၊
#include "CString.h" // CString ရဲ့ Header ဖိုင္ကို Include လုပ္တယ္၊
byte CString::Strlen( //byte CString ဆိုပီး Strlen consturctor တည္ေဆာက္တယ္၊
const char far* inStrSource //
)
{
byte lenghtOfString = 0; // String အေရအတြက္ varaible တည္ေဆာက္
while(*inStrSource++ != '\0') //instrSource ကို looping လုပ္၊
{
++lenghtOfString; //တန္ဖိုးက စတင္မွတ္ကေန စေပါင္း
}
return lenghtOfString;// String စာလံုးအေရးအတြက္ကို return လုပ္ေပး၊
}
CDisplay ထည့္သြင္းျခင္း
CDisplay Class က Screen မွာ စာသားေဖာ္ျပဖို႔ အတြက္ ဒီဇိုင္းေဖာ္ဖို႔ပါ၊ CDisplay Class မွာ Method သံုးခုပါမယ္၊
TextOut() // TextOut Method က Screen ေပၚမွာ စာသားေတြ ေဖာ္ျပမယ္၊
ShowCursor() – //ShowCursor() Method က Screen ေပၚမွာ ရွိမယ့္ cursor ရဲ့ show, hide ကို ဖမ္းမယ္၊
ClearScreen() – // ClearScreen() က Video mode ကိုေျပာင္းပီး Screen ကို ရွင္းမယ္၊
// CDisplay.h CDisplay ရဲ့ header ဖိုင္၊
#ifndef __CDISPLAY__
#define __CDISPLAY__
// အေရာင္နာမည္ေတြ ေခၚမျပေတာ့ဘူး ၊ ေဘးက ေတာ့ Assembler ဘာသာရပ္ရဲ့ အေရာင္ တန္ဖိုး သတ္မွတ္မူပါ၊
#define BLACK 0x0
#define BLUE 0x1
#define GREEN 0x2
#define CYAN 0x3
#define RED 0x4
#define MAGENTA 0x5
#define BROWN 0x6
#define GREY 0x7
#define DARK_GREY 0x8
#define LIGHT_BLUE 0x9
#define LIGHT_GREEN 0xA
#define LIGHT_CYAN 0xB
#define LIGHT_RED 0xC
#define LIGHT_MAGENTA 0xD
#define LIGHT_BROWN 0xE
ေနာက္ရက္ဆက္ရန္
ဒီပိုုစ့္ကိုု pdf ဖိုုင္ အျဖစ္ ေဒါင္းလုုဒ္လုုပ္လိုုပါက ေအာက္ပါ လင့္တြင္း ေဒါင္းလုုပ္ရယူႏုုိင္ပါသည္
ref;BrighterMyanmar
brightermyanmar@gmail.com
--------------------------------------
ကိုမ်ဳိး(lwanmapyay.blogspot.com) လြမ္းမေျပ သုတရပ္၀န္း | Facebook
ကိုမ်ဳိး(lwanmapyay.blogspot.com) လြမ္းမေျပ သုတရပ္၀န္း | Facebook