Latest Products

kjoldijghm rfyihstogh kduyti9wr8 uiogyh iuetiogy

Assembly වලින් Boot Loader එකක් ලියමු -Part 2

පෙර ලිපියෙන් අපි කතා කලා Floppy image එකක් සාදාගන්නා ආකරය ගැන.මේ ලිපියෙන් අපි ඉතුරු පියවරවල් ගැන කතා කරමු.

NASM භාවිතයෙන් Boot Loader Program එකක් ලියමු

Myfirst.asm

------------------------------------------------------------------------------------------------

BITS 16

start:

mov ax, 07C0h ; Set up 4K stack space after this bootloader

add ax, 288 ; (4096 + 512) / 16 bytes per paragraph

mov ss, ax

mov sp, 4096

mov ax, 07C0h ; Set data segment to where we're loaded

mov ds, ax

mov si, text_string ; Put string position into SI

call print_string ; Call our string-printing routine

jmp $ ; Jump here - infinite loop!

text_string db 'This is my cool new OS!', 0

print_string: ; Routine: output string in SI to screen

mov ah, 0Eh ; int 10h 'print char' function

.repeat:

lodsb ; Get character from string

cmp al, 0

je .done ; If char is zero, end of string

int 10h ; Otherwise, print it

jmp .repeat

.done:

ret

times 510-($-$$) db 0 ; Pad remainder of boot sector with 0s

dw 0xAA55 ; The standard PC boot signature

-------------------------------------------------------------------------------------------------

මෙහි අඩංගු NASM Instructions ගැන පස්සෙ පැහැදිලි කිරීමකට යන්නම්. ඊට පෙර අපි මේ Myfirst.asm කියන අපේ පලමුවෙනි සරල Boot Loader Program එක Save කරගෙන Floppy image එකකට Write කරල Booting වැඩේ සිද්ධවෙන නොවෙන බව බලාගමුකො.

හරි, ඔන්න ඔය විදිහට Assembly file එකත් ලියගත්තා කියමුකො.දැන් තියෙන්නෙ ඒක Compile කරගන්නයි.මෙතනදි Compile කරන විදහ සාමාන්‍ය NASM code එකක් Compile කරන්වාට වඩා වෙනස් මොකද කියනවානම් අපිට අවශ්‍ය Output File Format එක මෙතනදි විශෙෂ එකක් නිසා. මම දැන් ඔය විශෙෂ Output file format එක ගැන පොඩ්ඩක් කියන්නම්. BootLoader එකක් කියන්නේ කෙලින්ම BIOS එක හරහා Processor එකට විධාන නිකුත් කරන Program එකක්. ඒ කියන්නේ මෙතැනදි අතරමැදියෙක් විදිහට OS එක වැඩකරන්නැහැ (තාම OS එක Load කරලත් නැතුව මොන අතරමැදියොද හික් හික් : D ) .ඒක නිසා මෙතනදි අතරමැදි interface එක විදිහට වැඩ කරන්නේ ස්ර්‍ජුවම BIOS එකයි. BIOS එකත් එක්ක ගනුදෙනු කරද්දි Commands දෙන්න වෙන්නෙ කෙලින්ම Machine Language එකෙන් හෙවත් Binary format (o1o1o1o1o1o1....) එකෙනුයි.ඔන්න ඔය හේතුව නිස තමයි අපිට අර මම කලින් කියපු විශෙෂ file format එක හෙවත් Binary format එකෙන් Boot Loader Program එකේ instructions දෙන්න වෙන්නේ.අපි ලියපු NASM Program එක Binary Format file එකක් විදිහට compile කරන්නේ මෙන්න මෙහෙමයි.

nasm -f bin -o Myfirst.bin Myfirst.asm

පේනව ඇති -f කියලා comiling option format එක දීලා තියෙන්නෙ "bin" කියලා බව.ඒ කියන්නෙ Output file එක Binary format එකට තියෙන්න ඔනි කියනෙකයි. කොහොමින් කොහොම හරි ඔන්න ඔය විදිහට Comple කරගත්තහම අපේ පුංචි Boot Loader Program එක ලැහැස්තියි. දැන් තියෙන්නෙ මේක Floppy image file එකට Write කරනෙක හෙවත් 3 වෙනි පියවරයි.

Boot Loader Program එක Floppy image එකට write කර Boot-able Floppy image එකක් හදා ගමු

හරි යාලුවනේ. ඔන්න දැන් ගාව අපේ වැඩේට අවශ්ය ප්‍රධාන File දෙකම තියෙනවා. දැන් තියෙන්නෙ අපේ පුංචි Boot Loader Program එක අපි කලින් හදාගත්තු Floppy image file එකට Write කරන්නයි.ඒ සදහාත් මම භාවිතා කරන්න බලපොරොත්තු වෙන්නෙත් මම අර කලින් කියපු "ප්‍රසිද්ධ" "dd" Command එකම තමයි.මෙන්න ඒකේ Command Syntax එක.

dd status=noxfer conv=notrunc if=Myfirst.bin of=floppy.flp

මෙතනදි input file එක Myfirst.bin වෙනව වගේම Output file එක වෙන්නෙ Floppy image file එකයි. මේ command එකේ කලින්ට වඩා නොතිබු option දෙකක් තියෙනවා දැකගන්න පුලුවන්. ඒ ගැන පොඩි විස්තරයක් කරන්නම්.

status:

මෙම option එකෙන් "noxfer" කියල දුන්නොත් වෙන්නේ, dd command එක Run කලාට පස්සෙ දෙනවා Status Line එකක් 3 වෙනි Output line එක විදිහට.ඔන්න ඕක ප්‍රින්ට් නොවෙන්න නම් ඔය option එක දෙන්න ඔනි.ඕනිනම් ඔය option එක නැතුව Run කරලම බලන්නකෝ.

conv:

මෙම option එකෙන් "notrunc" කියල දුන්නොත් වෙන්නේ input file එකේ තියෙන Content, Output file එකට Copy කිරීමේදී Output file එකෙන් අවශ්ය ඉඩ ප්‍රමානය විතරක් අරගෙන Replace කරලා file එකේ ඉතුරු කොටසේ ඇති දත්ත එහෙම්ම තියෙන්න ඉඩ අරිනවා.

හරි ඔන්න එහෙනම් අපි දැන් "Bootable Floppy image" එකකුත් හදාගත්තා.දැන් ඊලග අවසාන පියවරට යන්න තමයි අපේ සූදානම...

Qemu emulator ය Install කිරීම සහ එය භාවිතයෙන් Floppy image ය Virtual PC එකක Boot කිරීම

Qemu කියන්නේ Processor Emulator එකක් වගේම Virtualizer එකක් විදිහට ක්‍රියකරන්න පුලුවන් OpenSource Software Package එකක්. සරල භාෂාවෙන් කිව්වොත් අපි භාවිතා කරන Virtual Box,VMWare යනාදියත් ඔන්න ඔය කියන ඝනයේ එව්වා තමයි නමුත් Qemu පස්සෙ කිව්ව එව්වට වඩා පොඩ්ඩක් Complex දේවල්වල්ට භාවිතා කරන එකක් (වැඩිවිස්තර මෙතැනින්).

හරි දැන් අපි කතා කරගෙන ආපු මාතෘකාවට බහිමුකෝ.අපි දැන් හදාගත්තු Floppy image එක බූට් කරල බලන්න එපැයි අපේ Boot Loader එක වැඩද නැද්ද කියල බලන්න.ඕක කරන්න පුලුවන් මෙන්න මෙහෙම.අපි ඇත්තම PC එකක් බූට් නොකර qemu භාවිතා කරල Virtual PC එකක් Emulate කරගෙන ඒ V-PC එක Floppy image එක භාවිතා කරලා බූට් කරල බලමු.

මේ සදහා මුලින්ම අපේ Linux මෙහෙයුම් පද්ධතියෙ qemu install කරගත යුතුයි. ඒ සදහා පහත විධානය භාවිතා කරන්න.

sudo apt-get install build-essential qemu nasm

(nasm දැනටමත් තිබේ නම් අවසාන කොටස අනවශ්‍යයි (nasm part of the code) )

Install වීම සම්පූර්න වුවිට දැන් ඉතුරුව ඇත්තේ අපි අපේ පුංචි Boot Loader එක Run කරලා බලන සතුටු දායකම අවස්තාවයි : ඩී.

පහත Command එක Run කිරීම තුලින් අපේ Boot Loader floppy image file එක qemu වල ඇති Virtual PC එකකින් Run කරගැනීමේ හැකියාව ලැබේ

sudo qemu -fda floppy.flp

ඔබට ජය!!!!!

Assembly වලින් Boot Loader ලියන හැටි ගැන වැඩි විස්තර ඊලග ලිපියෙන් (Details of NASM Code too)

Assembly වලින් Boot Loader එකක් ලියමු -Part 1

ඔන්න ආයෙත් අපිට Assembly වලින් සෙල්ලම් දාන්න අවස්ථාවක් ඇවිල්ලා යාලුවනේ . ඔක්කොටම කලින් Computer එකක Booting Process එක අමතක නම් මෙන්න මේ Link ඒක හෝ වෙන text එකක් මුලින් Refer කරනව නම් වඩාත් සුදුසුයි කියලා මම හිතනවා. හරි දැන් එහෙනම් අපි මාතෘකාවට Enter වෙමුකෝ.

අපේම කියලා Boot Loader එකකින් Computer එක Boot කරල බැලීම ප්‍රධාන පියවර 4 කින් දක්වන්න පුලුවන්

1) Floppy image එකක් හදමු

2) Nasm භාවිතයෙන් Boot Loader file එකක් ලිවීම

3) Boot Loader file එක Floppy image එකට write කර Bootable Floppy image හදා ගැනීම

4) Qemu නමැති Emulator ය install කිරීම සහා එය භාවිතයෙන් Floppy image ය Virtual PC එකක Boot කිරීම

Unix command භාවිතයෙන් floppy image එකක් හදමු

මුලින්ම අපි බලමු මොකද්ද මේ "Image file" කියන්නෙ කියලා. කිසියම් Storage Device එකක හෝ Media එකක (ex: CD/Floppy drive/Hard Drive/DVD/BD) ව්‍යුහ අකෘතිය ( Structure ) සහ එහි අඩංගු Contents සහිත Single file එකක් තමයි image file එකක් කියල කියන්නේ.

ඉතාම සරලව image file එකක් නිර්මාණය කරන කතන්දරෙ කියනවනම් මෙන්න මෙහෙමයි. "dd" (disk dump)කියල තියෙනව ප්‍රසිද්ද UNIX COMMAND එකක්.ඔන්න ඔය Command එකෙන් පුලුවන් File එකක Contents තව File එකකට Write කරන්න වගේම එහෙම කරද්දි විවිධ සෙල්ලම් දාන්න. මේ ලිපියෙන් මම Image File writing හෙවත් Floppy image එකක් නිර්මාණය කරන්න බලපොරොත්තු වෙන්නේ ඔන්න ඔය කියන "dd" Command එකෙන් තමා. මෙතනදි සදහන් කරන්න ඔනි තවත් වැදගත් කාරණයක් තමයි Floppy image එකක් කියල කියන්නෙත් තවත් එක File ජාතියක් විතරමයි කියන එක. ඒක නිසා තමයි අපිට මේ "dd" Command එක භාවිතා කරන්න පුලුවන් වෙලා තියෙන්නෙ අපේ අවශ්‍යතාව ඉටු කරගන්න.

ඉතින් අපි වැල්වටාරම් කියවන්නැතුව කෙලින්ම Command Syntax එකට බහිමුකෝ.

# dd if=/dev/zero of=floppy.flp bs=512 count=2880

dd :
මෙම Command එකෙන් files copy කරන්න පුළුවන්.
if :
මෙම Option එකෙන් Standard input එකක් වෙනුවට read කරන්න input file එකක් දෙන්න පුළුවන්.
of :
මෙම Option එකෙන් Standard output එකක් වෙනුවට write කරන්න output file එකක් දෙන්න පුළුවන්.

bs :
මෙම Option එකෙන් dd Command එක ‍files Read/Write කරන Block size එක bytes වලින් define
කරනවා.

count :
මෙම Option එකෙන් input file එකෙන් copy කරන blocks ගණන තීරණය කරනවා.

එමනිසා output file size එක මෙහෙම ගණනය කරන්න පුළුවන්.

512 x 2880 = 1,474,560 bytes

1,474,560/(1024 x 1024 ) = 1.4 Mb (Approximately)

1.4 Mb කියන්නෙ Normal Floppy Disc එකක default storage size එක කියලා අපි දන්නවනේ.

** dev/zero කියන්නෙ Unix-like OS වල එන විශේෂ file වර්ගයක්.කිසියම් Data Storage එකක් initialize

කරනකොට මෙය ඇතිතාක් Null characters ලබා දීම සිදු කරනවා

** floopy.flp කියලා ".flp" extension එක සහිත file එක තමා අපේ floppy image file එක වෙන්නේ.

ඔන්න දැන් අපේ Floppy image file එක නම් ලැහැස්තියි.නමුත් අපි ගාව තියෙන්නේ Unformatted Version එකක Floppy image එකක්. දැන් තියෙන්නේ ඒක Format කරගන්නයි අපිට අවශ්ය File System එකකට.මම මෙතනදි ඒ සදහා ext2 file system

එකට format එක සිදු කිරීමට පහත Command එක භාවිතා කරනවා.

# mke2fs floppy.flp

..............................................................................
කතාව මතු සම්බන්ධයි. ඉතිරි කොටස ඊළග කොටසත් ඉක්මන්ට ලියන්නම්. Part 2 සමගින් Boot Loader.... :)

Process එකක ව්‍යුහය 2

කලින් ලිපියෙන් කියපු විදියට program එකක් පරිගණකය තුළ execute වෙන්න අපි හැම දෙයක්ම එකින් එක පරිගණකයට දෙන්න ඕනි. පරිගණකය තුල program එකක් execute වීමේදී සිදුවෙන්නෙ program counter(pc) එකේ තියෙන memory address එකෙන් කියවෙන memory location එකේ තියෙන instruction එක ක්‍රියාත්මක කරන එක විතරයි. පරිගණකය විසින් කරල දිය යුතු හැම දෙයක්ම අපි instructions විදියට දෙන්න ඕනි වෙනවා. මෙම කරුණ ඉතා හොදින් තේරුම් ගැනීම ගොඩක් වැදගත් වෙනවා. කලින් ලිපියෙදි අපි භාවිතා කරපු උදාහරණයම සලකල බලමු.

int main() {

    int a = 10;
    int b = 5;
    int c = add(a,b);
    return 0;
   
}

int add(int x, int y) {

    int z = x+y;
    return z;
   
}

මෙය memory එක තුල විහිදෙන්නේ පහත ආකාරයට යැයි සලකමු.

සාමාන්‍යයෙන් මෙම program execute වෙද්දි main method එක ඇතුලෙ යම් තැනකදි add method එක call කරන්න වෙනවා. එනම් එතෙක් වෙලා program counter(pc) එක main method එකේ තියෙන instruction address තිබිල add method එක call කරාම add method එක පටන් ගන්න තැන memory address එක pc එකට copy කරගන්න ඕනි. එතකොට add method එක run වෙන්න පටන් ගන්නවා.


මේ විදියට program එක run උනාට පස්සෙ ගැටලුවක් එනවා. add method එක run වෙලා ඉවර උනාම නැවත main එකේ add method එක call කරපු තැන ඉදන් ඉදිරියට run වෙන්න ඕනි. ඒත් කලින් කියපු විදියට පරිගණකය run කරන්නෙ අපි කියන විදියට පමණක් නිසා add method එක run කරල ඉවර උනාම නැවත main method එක ඇතුලෙ run වෙන්න ඕනි තැන දැනගන්නෙ කොහොමද???

add method එක run උනාට පස්සෙ මේක දැනගන්න විදියක් නෑ. මොකද විවිධ අවස්ථා වලදි add method එක විවිධ තැන් වලින් call කරන්න පුලුවන්. එම නිසා add method එක ඇතුලෙදි නැවත යන්න ඕනි තැන දැනගන්න විදියක් නැහැ. මෙතනදි කරන්නෙ main method එකෙන් එද්දිම නැවත එන්න ඕනි memory address එක සටහන් කරගන්න එක. add method එක ඉවර උනාට පස්සෙ සටහන් කර ගත් තැන තියෙන memory address එක pc එකට copy කර ගන්නවා. එතකොට ගැටලුව විසදෙනවා.

මෙලෙස සටහන් කරන තැනට memory එකේ නිශ්චිත තැනක් භාවිතා කරොත් method එකක් ඇතුලෙ තව method එකක් යොදද්දි ගැටලු එනවා. මොකද main method එකයි add method එකයි කොටස් දෙකක් නිසා main method එකෙන් සටහන් කරන තැන add method එකෙන් නැවත අරගන්න නම් සටහන් කරන තැන පොදු එකගතාවක් තියෙන්න ඕනි. ඒත් method එකක් ඇතුලෙ තව method එකක් යොදද්දි මේ method දෙකටම එකම තැන භාවිතා කරන්න බැරි නිසා. ඒ වගේම recursion වලදි මේ ක්‍රමය කොහොමවත් භාවිතා කරන්න බැරි වෙනවා. එම නිසා නිශ්චිත memory location එකක මෙම දත්තය සටහන් කරන්න බැහැ. මේ සදහා stack එකක් භාවිතා කරනවා.


මේ ආකාරයට තමයි method එකක් call වෙන්නෙ.