FreeBSD 11.0-RC1 – نخستین دیدار

امروز بعد از مدتها به وبسایت محبوب و معروف دیستروواچ سر زدم و دیدم که یکی از سیستم عامل های محبوبم یعنی FreeBSD یک نسخه نامزد انتشار منتشر کرده!

خب با خوشحالی تمام دانلودش کردم.

اولین چیزی که در FreeBSD 11 برام جالب شد، این بود که توی نصاب خیلی ریز شده بودن و سوال پرسیده بودن، یعنی عمده پیکربندی رو جزئی از نصاب کردن که این خودش یک پوئن مثبت در نوع خودش محسوب میشه. و یک پیشرفت خیلی بزرگ، چون عمده کاربران FreeBSD مدیران سیستم ها هستند، پس این تیپ پیکربندی هنگام نصب بدرد میخوره.

خب، بعد نصب، تصمیم گرفتم اول pkg رو راه بندازم. بعد nano رو نصب کردم (ادیتور محبوب من در CLI ! یه چیز تنبل پسند و عالی!) ، بعدش تصمیم گرفتم دسکتاپ رو راه اندازی کنم. دیدم توی هندبوک، به gnome3 اشاره شده، اونجا بود که فهمیدم احتمالا گنوم شل دوست داشتنیمون هم اومده به FreeBSD . پس gnome3 رو نصب کردم و این خطوط رو به rc.conf افزودم :

کد   
dbus_enable="YES"
hald_enable="YES"
 
#Running GNOME and GDM services
 
gdm_enable="YES"
gnome_enable="YES"

و بعد از یک ریبوت، چشممون به جمال گنوم شل با 3D Acceleration روشن شد :

و این عکس هم به جهت تایید اصالت سیستم عامل :

در مورد این دسکتاپ، که خب یک دسکتاپ مدرن محسوب میشه و تا مدتها در FreeBSD پیداش نبود، میشه گفت که با اضافه شدنش بدون مشکل به سیستم عامل، میتونه به پیشرفت این سیستم عامل در حوزه دسکتاپ کمک کنه. البته، در کل 11 نرم تر از ۹ و ۱۰ بود که قبل تر تست کرده بودم و حتی به عنوان سیستم عامل اصلی ازشون استفاده میکردم.

موفق باشید 🙂

Share

نوشتن اسمبلی ۳۲ بیت

در گذشته، پست هایی که در مورد اسمبلی قرار دادم، همه در مورد اسمبلی ۱۶ بیت بودن اما حالا میخوایم بریم سراغ اسمبلی ۳۲ بیت. خب فرق ۱۶ با ۳۲ بیت در چیه؟!

اولین نکته، سایز ثبات هاست! در ۱۶ بیت در هر ثبات میتونستیم حداکثر یک مقدار ۴ رقمی هگزادسیمال ذخیره کنیم ولی در ۳۲ بیت این مقدار به ۸ رقم میرسه! حالا خیلی مسائل دیگه مثل دیتاباس و کنترل باس و … که بماند (چون اینجا داریم برنامه نویسی میکنیم و بیشتر با ثبات ها کار داریم).

اینجا، قضیه یه فرقای کوچولویی داره، مثلا اسمبلر nasm قراره استفاده بشه (گرچه قبلا در ساخت اون سیستم عامل کوچک ازش استفاده کردیم) و همچنین وقفه ها و system call هایی که استفاده میکنیم شماره و مقدارشون و مکانشون متفاوته.

بیاید این برنامه رو در نظر بگیریم :

کد   
section .text
	global_start
 
_start:
	mov edx, len
	mov ecx, msg
	mov eax, 0x04
	int 0x80
 
	mov eax, 0x01
	int 0x80
 
section .data
	msg db 'Hello, World!', 0xa
	len equ $ - msg

 

خب در بخش اول، تابعی که نیاز داریم فراخوانی کنیم رو تعریف کردیم. بعدش اومدیم start رو نوشتیم. حالا بیاید این بخش رو بررسی کنیم :

کد   
mov edx, len
mov ecx, msg
mov eax, 0x04
int 0x80

اینجا، مقدار طول رشته ای که خواستیم چاپ کنیم رو توی EDX یا رجیستر داده قرار دادیم. بعدش اومدیم پیامی که میخوایم چاپ بشه رو قرار دادیم درو نECX .

بعدش سیستم کال ۴ یا sys_write رو توی eax قرار دادیم و وقفه ۸۰ رو صدا زدیم. حالا وقفه ۸۰ با مقدار ۴ که توی eax ذخیره شده، میگرده دنبال رشته ای که توی ecx هست و بعدش چاپش میکنه.

حالا بخش دوم کد سگمنت رو بررسی میکنیم :

کد   
mov eax, 0x01
int 0x80

اینجا هم مقدار ۰۱ یا sys_exit رو وارد eax کردیم، تا برنامه پس از اجرا، خارج شه. بعد از این هم باز وقفه ۸۰ رو صدا زدیم.

بخش دیتا هم، مثل همه برنامه های قبلی، تمام داده های مورد نیاز رو با Directive ها تعریف کردیم که بتونیم به راحتی توی کد سگمنت ازشون استفاده کنیم و چون قبلا توضیح داده شده، دیگه دوباره کاری نمی کنم. فقط این پست رو نوشتم تا فرقهای اسمبلی ۳۲ و ۱۶ بیت رو ببینیم. که درآینده بسطش خواهم داد به ۶۴ بیت.

امیدوارم که این پست، بدردتون خورده باشه.

موفق و موید باشید!

Share

زبان ماشین، رمزگشای دستور العمل

در پست های گذشته بسیار بسیار در مورد زبان ماشین و اسمبلی بحث کردیم، اما این بار میخوایم بررسی کنیم که یک دستور، چطور کار میکنه. برای این کار، ما از ساده ترین دستورات استفاده میکنیم. قبل از اون، باید ببینیم که چه اتفاقی میفته که دستورات ما، شناسایی میشن! پس میایم و دستوراتمون رو بررسی میکنیم.

یک دستور در ماشین چطور خونده میشه؟

این خیلی مهمه که بدونیم یک دستور به چه شکلی خونده میشه. بسیار خوب، دستور زیر رو در نظر بگیرید :

کد   
MOV AX, 0

 

این دستور ماشین کد به این شکل داره :

کد   
B8 0000

 

که البته این ماشین کد، یک ماشین کد هگزادسیمال هست. اون چهار صفری که داریم که مقداری هست که خواستیم توی AX قرار بدیم و باهاش کاری نداریم، ولی B8 ما ، همون دستوریه که لازمه رمزگشایی شه و به صورت دو دویی به این شکل در میاد :

کد   
1011 1000

 

خب ما یک «دیکدر» (که یک مدار متشکل از n ورودی و دو به توان n خروجی هست) داریم، که این اعداد رو به ترتیب روشن و خاموش میکنه، و به این شکله که ما به  دستور میرسیم. در واقع مدارات مربوط به دستور رو خواهیم داشت.

بسیار خوب، حالا که میدونیم چه چیزی باعث میشه که ما بتونیم زبان ماشین رو درک کنیم، بیایم بررسی کنیم که :

زبان ماشین از چند بخش تشکیل شده؟

زبان ماشین، اول به صورت اسمبلی نوشته میشه که به زبون انسان خیلی خیلی نزدیکه. یعنی هرکس کمی انگلیسی بدونه میدونه که کلمه ای مثل ADD یعنی جمع کردن. اما، حالا مشکلی که هست اینه که وقتی «اسمبلی» به «آبجکت کد» یا همون کد هگزادسیمال تبدیل میشه رو هرکسی نمیتونه بخونه. پس راه حل چیه؟

اول باید ببینیم که یک خط آبجکت کد از چیا تشکیل میشه! بیاید این مثال رو در نظر بگیریم باز :

کد   
MOV AX, 0 ;B8 0000

 

خب اینجا من آبجکت کد رو به صورت کامنت در آوردم. دو بخش داریم، یکیش چهارتا صفر، که بهش عملوند یا Operand میگیم و دیگری «کد عملیات» یا Operation Code هست. مثلا برای انتقال به AX همیشه از B8 استفاده میشه. چرا؟ چون اینتل اینطور خواسته 😀 . بعد از این، این کد هگزادسیمال به یک کد باینری تبدیل میشه که CPU میتونه اون رو برای ما اجرا کنه.

از کجا آبجکت کد رو بخونیم؟

همه اسمبلر های موجود میتونن فایلی تولید کنن که آبجکت کد، سمبلهای به کار رفته و … رو شامل شه، و در اسمبلر MASM این فایل با پسوند LST ساخته میشه. شما میتونید با باز کردن این فایل با یک ویرایشگر متنی و خوندنش، ببینید که هر دستوری چه کدی رو داره.

یک برنامه نمونه

خب، من یک برنامه اسمبلی خیلی ساده نوشتم که اجرا کردنش هیچ خروجی ای نداره (:D ) ولی خب آبجکت کد ها تولید شده و اسمبل بدون مشکل صورت گرفته. این برنامه با آبجکت کدهاش به صورت کامنت به این شکله (بررسی دستور MOV در ۱۲ حالت مختلف) :

کد   
.MODEL SMALL
.8086
.STACK 
.DATA
.CODE
MOV AX, 0 ;B8 0000
MOV BX, 0 ;BB 0000
MOV CX, 0 ;B9 0000
MOV DX, 0 ;BA 0000
MOV AH, 0 ;B4 00
MOV BH, 0 ;B7 00
MOV CH, 0 ;B5 00
MOV DH, 0 ;B6 00
MOV AL, 0 ;B0 00
MOV BL, 0 ;B3 00
MOV CL, 0 ;B1 00
MOV DL, 0 ;B2 00
END

برای جلوگیری از ابهام هم مقداری که توی رجیسترها ریخته شده صفر هست، به این شکل کد ماشین بسیار ساده تر شده.

تا پست های بعدی، و اسمبلی بیشتر، موفق و موید و آزاد و شاد باشید! 🙂

Share

توسعه سیستم عامل – طراحی IDT, IRQ و ISR

اگر یادتون باشه، مدتهای پیش، یک سری مقاله نوشتم، که آخرین مقاله این بود. توی حدود چهار تا مقاله، بررسی کردیم چطور میتونیم یه سیستم عامل ساده و ۱۶ بیتی بنویسیم. اونقدری نگذشت که تصمیم گرفتم برنامه نویسی رو به C تعمیم بدم و سپس NanOS رو بعنوان نسخه اولیه نوشتم، تجربه جالبی بود چون یه درایور ساده کارت گرافیک و کیبرد داشت و چند تا پیام میتونست نشون کاربر بده. اونقدری نگذشت که یه تجمعی به اسم «بنیاد نانو» درست کردیم که NanOS رو توضیح بدیم. NanOS الان سه تا چیزی رو داره که خیلی جالبن : IDT, IRQ  و ISR .

برای این که ببینیم اینها چی به چین، اگر توی داس اسمبلی نوشته باشید، احتمالا برای چاپ رشته و کرکتر و خوندنشون این عدد و این عملگر رو دیدید :

کد   
int 21h

خب همونطور که توی مقالات قبلی هم گفتم، int اینجا به معنای «عدد صحیح» نیست، بلکه به معنای «وقفه» است. وقفه های سخت افزاری و نرم افزاری که تا الان استفاده کردیم چه کار میکردن؟ عملکرد پردازنده رو متوقف میکنن و میگن که یه کار جدید انجام بده (به ساده ترین زبان ممکن!). خیلی راحت بگم فرض کنید توی یک کلاس دارید درس میدید (عمل جاری) ، یک نفر در میزنه و شما کار درس دادن رو متوقف میکنید و اینجاست که وقفه اجرا میشه (عمل جدید). خب IDT چیه؟ IDT مخفف Interrupt Descriptor Table ــه که به معنای «جدول توضیح وقفه ها» ست. این جدول، یک ساختمان داده‌ست که توش توضیح میدیم پردازنده چه جوابی باید به وقفه هایی که بهش وارد میشه بده. در این بین یه IRQ یا Interrupt Request داریم که درخواست دهنده وقفه هاست. درخواست دهنده وقفه، توی خود پردازنده وجود داره، و ما برای استفاده ازش باید براش کد بزنیم. کار IRQ چیه؟ این که نسبت به وقفه ها واکنش نشون بده و سیگنال های مربوطه رو بفرسته. سپس، با استفاده از هندل کننده وقفه ها جواب وقفه ها رو بسنجه، یا برنامه ای رو متوقف کنه و به برنامه جدید اجازه اجرا بده.

خب، در نهایت باید Interrupt Service Routine یا ISR داشته باشیم. ISR کارش کلا اینه که بیاد و چک کنه که وقفه درست انجام شده یا نه، بعدش، بیاد و یک مقدار منطقی به ما بده، که بفهمیم وقفه درست انجام شده یا نه.

بعنوان یک جمع بندی نهایی، میشه گفت که ما اول باید بگیم چه وقفه هایی داریم و هرکدوم چه میکنه (IDT) ، بعد همه اینا رو با یک قطعه خاص تست کنیم (IRQ) و نهایتا با یک نرم افزار از درست کار کردن وقفه هامون مطمئن شیم (ISR). کاربرد این قضیه چیه؟ فرض کنیم سیستم عامل تا حدی پیشرفت کرد و تونست برنامه اجرا کنه، با استفاده از جدول و هندل کننده های وقفه ها، میتونیم برای سیستم عامل خودمون یه اسمبلر طراحی کنیم، کامپایلر ها رو روش بیاریم و برنامه هایی که دسترسی سطح پایین میخواند رو اجرا کنیم.

موفق باشید 🙂

Share

ساخت کراس کامپایلر GCC

اگر لینوکسی باشید (یا حداقل با یکی از سیستم عاملهای خانواده *NIX کار کرده باشید) ، به احتمال خیلی زیاد GCC رو میشناسید. GCC که مخفف GNU Compiler Collection هست یک کامپایلر بزرگ، یا بهتر بگیم یه مجموعه از کامپایلرهاست که توسط پروژه گنو ارائه شده. این کامپایلر به صورت پیشفرض روی تمام توزیع های لینوکس هست (چون چیزیه که عمده ابزارهای لینوکس باهاش کامپایل شدند) و احتمالا روزهای اولی که خواستید توی لینوکس کد C بزنید با این کامپایلر بوده و البته کلی هم فحش دادید بهش 😀 . اگر کمی پیش بریم و برسیم به کسایی که تجربه ساخت LFS رو داشتن، اونها هم احتمالا با کامپایل کردن GCC مواجه شدن. شاید نفس گیر ترین بخش ماجرا در LFS همین GCC باشه ، چون هم طولانیه و هم کلی کانفیگ داره! . اما خب کراس کامپایلر قضیش یکم متفاوته.

من چند وقتیه (خیلی وقته!) درگیر ساخت یک سیستم عاملم و کلی هم برای خودم تحقیق کردم و داکیومنت خوندم و حتی داکیومنت هام رو بازنشر دادم. اما مشکل اینجاست که سیستم عامل قبلیمون کاملا با اسمبلی بود ولی این یکی رو میخوایم با C پیاده سازی کنیم. به نظرتون چی میشه؟ هیچی نمیشه! فقط نیاز داریم تا به جای این که صرفا از NASM استفاده کنیم، جناب GCC که برای خودش غولیه رو هم بازی بدیم. اما اگر سیستممون ۶۴ بیتی باشه چطور؟ اصلا اگر سیستم عامل مقصدمون برای پردازنده ای مثل ARM نوشته شده باشه چی؟ برای این که بتونیم نتیجه و خروجی درست و حسابی بگیریم، نیاز داریم تا کراس کامپایلر داشته باشیم. (برای دونستن اهمیت کراس کامپایلر این لینک رو بخونید).

خب GCC برای کامپایل شدن به Binutils نیاز داره. همچنین قبل از کامپایل Binutils برای معماری مورد نظرمون، باید این کتابخونه ها رو نصب کنیم :

کد   
sudo apt-get install libgmp3-dev libmpfr-dev libmpc-dev texinfo

خب، حالا که این کتابخونه ها رو نصب کردیم میریم که محیط ساخت و ساز (ممکنه درست نباشه ولی باحال ترین معادل ممکن برای Build Environment بود!) رو فراهم کنیم. من میخوام gcc من، برای i686-elf کار کنه. همچنین نمیخوام خیلی پر و بال بدم به ماجرا و نصب رو راحت و با کاربر خودم انجام بدم، پس این کد ها رو وارد ترمینال میکنم تا توی همون پوشه خونگی، gcc مورد نظرمون قرار بگیره!

کد   
export PREFIX="$HOME/opt/cross"
# فراموش نکنید این پوشه رو خودتون باید بسازید 🙂
export TARGET=i686-elf
export PATH="$PREFIX/bin:$PATH"

خب، حالا باید binutils رو از اینجا و gcc رو هم از اینجا دانلود کنید، و سورس ها رو درون پوشه ای به اسم src قرار بدید (پوشه src داخل پوشه خونگی شما قرار داره!). بسیار خوب! توی پوشه src پوشه ای بسازید به اسم build-binutils و سپس سورس binutils رو از حالت فشرده خارج کنید. حالا وارد پوشه build-binutils بشید (هیچی رو وارد این پوشه نکنید!) و سپس تایپ کنید :

کد   
../binutils-*/configure --prefix="$PREFIX" \
--target=$TARGET \
--with-sysroot --disable-nls --disable-werror

بعد از زدن این دستور، اسکریپت configure براتون Makefile درست میکنه. من از نسخه ۲.۲۵ استفاده کردم و واقعا بی مشکل بود، شما هم بهتره از همین نسخه استفاده کنید. حالا که Makefile برامون تولید شده کافیه به ترتیب make و سپس make install رو تایپ کنیم تا binutils مون نصب شه. حالا نوبتی هم باشه نوبت gcc دوست داشتنیه!

خب پوشه build-gcc هم بسازیم و بریم داخلش! حالا باید از فایل configure دوباره برای ساختن Makefile استفاده کنیم!

کد   
../gcc-*/configure --prefix="$PREFIX" \
--target="$TARGET" \
--disable-nls \
--enable-languages=c,c++ \
--without-headers

بعد از انجام این مرحله، باید یکی یکی دستورات زیر رو بزنیم :

کد   
make all-gcc
make all-target-libgcc
make install-gcc
make install-target-libgcc

تا gcc برامون نصب شه! الان با فراخوانی دستوری مثل i686-elf-gcc ، میتونیم به gcc ساخته شدمون دسترسی پیدا کنیم!

امیدوارم که این مطلب مفید واقع شده باشه، موفق باشید 🙂

Share

نوشتن یک سیستم عامل ساده – قسمت آخر

بهرحال، هر شروعی یک پایانی داره و اینجاس که ما به پایان خودمون نزدیک میشیم! پایان قشنگ و دوست داشتنی، وقتی می بینیم دست رنجمون در طول چند هفته (بسته به مهارت برنامه نویسی و حوصله و زمانی که صرف این کار کردید) ، تبدیل شده به یه چیز «تقریبا» قابل استفاده، دوست داشتنی تر هم میشه! بسیار خب کد اسمبلی که نوشتیم و کامل شده به این شکله :

کد   
org 0x7c00
bits 16
 
mov ax, 0
mov ds, ax
mov es, ax
mov ss, ax
mov sp, 0x7c00
 
mov si, welcome 
call print_string 
 
mov si, about
call print_string
 
mov si, newline
call print_string
 
mainloop:
 mov si, prompt
 call print_string
 
 mov di, buffer
 call get_string
 
 mov si, buffer
 cmp byte [si], 0
 je mainloop
 
 mov si, buffer
 mov di, cmd_reboot
 call strcmp
 jc .reboot
 
 mov si, buffer
 mov di, cmd_about
 call strcmp
 jc .about
 
 mov si, buffer
 mov di, cmd_help
 call strcmp
 jc .help
 
 mov si, badcommand
 call print_string
 jmp mainloop
 
 .reboot:
  int 0x19
  jmp mainloop
 
 .about:
 mov si, msg_about
 call print_string
 jmp mainloop
 
 .help:
 mov si, msg_help
 call print_string
 jmp mainloop
 
 
welcome db  'Welcome to my OS', 0x0d, 0x0a, 0
about db  'Written in 16-bit real mode', 0x0d, 0x0a, 0
buffer times 64 db 0
prompt db '>> ', 0
newline db ' ', 0x0d, 0x0a, 0
badcommand db 'Bad command entered', 0x0d, 0x0a, 0
cmd_reboot db 'reboot',0
cmd_about db 'about', 0
msg_about db 'This is a 16 bit operating system, works in real mode and written in assembly language', 0x0d, 0x0a, 0
cmd_help db 'help', 0
msg_help db 'Commands are : about, help and reboot', 0x0d, 0x0a, 0
 
 
 
print_string:
 lodsb
 or al, al
 jz .done 
 
 mov ah, 0x0e
 int 0x10
 
  jmp print_string
 
 
 .done:
   ret
 
get_string:
 xor cl, cl
 .loop:
   mov ah, 0
   int 0x16
 
   cmp al, 0x08
   je .backspace
 
   cmp al, 0x0D
   je .done
 
   cmp cl, 0x3F
   je .loop
 
   mov ah, 0x0e
   int 0x10
 
   stosb
   inc cl
   jmp .loop
 
   .backspace:
    cmp cl, 0
    je .loop
 
    dec di
    mov byte [di], 0
    dec cl
 
    mov ah, 0x0e
    mov al, 0x08
    int 0x10
 
    mov al, ' '
    int 0x10
 
    mov al, 0x08
    int 0x10
 
    jmp .loop
 
    .done:
      mov al,0
      stosb
 
      mov ah, 0x0e
      mov al, 0x0d
      int 0x10
      mov al, 0x0a
      int 0x10
 
      ret
 
strcmp:
 .loop:
  mov al, [si]
  mov bl, [di]
  cmp al, bl
  jne .notequal
 
  cmp al, 0
  je .done
 
  inc di
  inc si
 
  jmp .loop
 
  .notequal:
   clc
   ret
  .done:
    stc
    ret
 
times 510-($-$$) db 0
dw 0xaa55

 

همونطور که می بینید چن قسمت جدید شروع شده ، مثلا تابع strcmp رو ساختیم، چن تا دستور و پیام تعریف کردیم و زیر تابع های reboot و about و help رو هم تعریف کردیم. خب اول یه توضیح کوچیک : دستورات باید حتما معرفی بشن. چرا؟ چون تابع strcmp ورودی کاربر رو با یه سری اطلاعات از پیش تعیین شده میاد مقایسه میکنه و در صورت برابری با مقدار وارد شده، اون دستوری که در برنامه تعریف شده رو اجرا میکنه. پس بخشی که چندین db پشت هم تعریف شده رو جدی بگیرید! بسیار خوب، یکی از توابع خوب و زیبامون تابع strcmp هست. این تابع چیه؟ ما یه دستوری در اسمبلی داریم به اسم cmp که کارش مقایسه است. حالا برای این که ببینیم دو تا رشته با هم برابرن اومدیم strcmp نوشتیم. در واقع مخفف string compare هست. خب این تابع در کد ما به این شکله :

کد   
strcmp:
 .loop:
  mov al, [si]
  mov bl, [di]
  cmp al, bl
  jne .notequal
 
  cmp al, 0
  je .done
 
  inc di
  inc si
 
  jmp .loop
 
  .notequal:
   clc
   ret
  .done:
    stc
    ret

این تابع ، میاد اول یک بایت از si رو میریزه توی ۸ بیت پایینی AX . بعدش یک بایت از di رو میریزه توی هشت بیت پایینی BX . بعد با cmp مقایسه‌ش میکنه، در صورتی که برابر نبودن، میره سراغ notequal که توضیح داده میشه، و اگر برابر باشن، هشت بیت پایین AX چک میشه و اگر خالی بود میره done. در غیر این صورت یک کرکتر میره جلو (با دستور inc یک خونه به جلو حرکت میکنه). بعد میرسیم به بخش دوست داشتنی notequal ، توی این بخش اول Carry Flag که یک بیت از رجیستر Flag در پردازنده ماست، خالی میشه و تابع تموم میشه. در قسمت done هم این بیت پر میشه و تابع تموم میشه! دیدید؟ بسیار ساده تر از چیزی بود که فکرش رو میکردید! حالا بریم کارکرد دستورات رو بررسی کنیم :

کد   
mov si, buffer
 mov di, cmd_about
 call strcmp
 jc .about

خب این بخش برای همه دستورات یکیه، چی کار میکنه؟ خط اول buffer (رشته ای که کاربر وارد کرده) و خط دوم دستور (دستوری که توی اون بخش توسط db تعریف کردیم) وارد رجیستر های SI و BI میشن. بعد تابع strcmp میاد این دو رشته رو با هم مقایسه میکنه. اگر شرط درست باشه، به زیرتابع مورد نظر میریم. در غیر این صورت، زیرتابع badcommand که در قسمت سه و نیم معرفی شد، فراخوانی میشه. حالا بیایم ساختار about رو بررسی کنیم (توجه کنید about ساختارش با help یکیه پس یکیشون کافیه که بررسی شه) :

کد   
.about:
 mov si, msg_about
 call print_string
 jmp mainloop

خب تا حدود زیادی مثل badcommand عمل میکنه (تقریبا همونه با این تفاوت که یه شرط لازم داره برای اجرا شدن) ، اول رشته مورد نظرمون میره توی SI ، بعد print_string صدا زده میشه، و بعد میریم به حلقه اصلی و منتظر میمونیم تا کاربر دستور بعدی رو بده.

این زیرتابع ها، مشابهن. فقط تابع reboot یکم ممکنه اذیتتون کنه، ولی خب اون رو هم اینجا توضیح میدیم :

کد   
.reboot:
  int 0x19
  jmp mainloop

خب طبیعیه که jmp کارش پرش به حلقه اصلیه و برای این میذاریمش که اگر reboot رو کاربر نزنه ، چی بشه؟ هیچ اتفاقی نیفته و سیستم عامل کوچولومون همچنان منتظر باشه کاربر بهش دستور بده. اما وقفه ۱۹ هگزادسیمال یا 0x19 (که بعضی جاها ممکنه 19h هم نوشته شه) ، چیه؟ این وقفه یکی از وقفه های بایوسه که کارش ریبوت کردن (راه اندازی مجدد) سیستم عاملمونه.

تبریکات فراوان! شما الان یک سیستم عامل زیبا و کوچولو نوشتید، که سه تا دستور داره و اگر دستوری غیر از اینا بهش بدید، بهتون ارور میده. در واقع شما کاری رو پیش بردید که توسعه دهنده ها سالیان پیش انجام میدادن تا کامپیوترها بیشتر و بیشتر کاربرپسند بشن! و از این جهت شدیدا باید خوشحال باشید، چرا؟ چون کارهایی رو دوباره کردید که احتمال خیلی زیاد توی شرکتهای بزرگ کامپیوتری انجام میشده! و همچنین تشکرات فراوان بابت این که مطالب من رو خوندید و براش وقت گذاشتید. بزودی سری جدیدی از این مقالات شروع میشه که سیستم عامل کوچولومون رو میبریم توی مود حفاظت شده ( Protected Mode ) که یک مود ۳۲ بیتی هست و احتمال خیلی زیاد از بوت لودر GRUB برای بوت کردنش استفاده خواهیم کرد!

موفق باشید 🙂

Share

نوشتن یک سیستم عامل ساده – قسمت سه و نیم

این قسمت، حقیقتا ارزش این که به قسمت چهارم تبدیل بشه رو نداره. برای همین تصمیم گرفتم اسمش رو بذارم سه و نیم! توی قسمت قبلی prompt نوشتیم که دستورات رو از کاربر میخوند اما هیچ جوابی نمیداد. توی این قسمت قصدم اینه که صرفا یک ارور رو روی صفحه نمایش بدم. به این شکل :

error

بسیار خوب! در قسمتی که چندین db داشتیم برای تعریف دو پیام اول و بعد شکل prompt و بعدش بافر، این رو وارد کنید :

کد   
badcommand db 'Bad command entered', 0x0d, 0x0a, 0

و بعد قبل از اتمام mainloop یعنی قبل از آخرین پرشمون، این کد رو اضافه کنید :

کد   
mov si, badcommand
call print_string

خب بعد از اسمبل کردن، خواهید دید که هر کامندی (مثل فاصله، کرکتر های الکی و …) که وارد کنید این ارور به شما نمایش داده میشه! و دلیلش اینه که هنوز دستوری به سیستم عاملمون اضافه نشده. در قسمت های بعدی دستورات مورد نیازمون رو هم به سیستم عامل کوچولومون اضافه میکنیم!

ضمیمه : ساخت فایل ISO قابل بوت از سیستم عامل

از اونجایی که میدونستم این سوال ممکنه پیش بیاد که چطور باید این فایل رو به ISO تبدیل کنیم و بوتش کنیم، در این بخش توضیح میدم. اولا که img و حتی bin قابل بوت شدن هستن (اگر مجازی سازتون میذاره که floppy controller اضافه کنید) ولی خب اگر دلتون میخواد ISO درست کنید ، اول فایل bin که اسمبلر داده بهتون رو به img تبدیل کنید :

کد   
dd if=my16bitos.bin of=my16bitos.img

بعد یه فولدر به اسم cdiso بسازید و فایل img رو ببرید داخلش و بعد این دستور رو بزنید (برنامه genisoimage رو نصب کنید حتما!):

کد   
mkisofs -o my16bitos.iso -b my16bitos.img -no-emul-boot cdiso/

بعدش میتونید فایل ISO رو بدید به یه مجازی ساز مثل VirtualBox یا QEMU یا VMWare .

موفق باشید!

Share

نوشتن یک سیستم عامل ساده – قسمت سوم

در دو مقاله قبلی سعی کردیم یک سیستم عامل ساده بسازیم که توی مد حقیقی ۱۶ بیت کار میکنه و دو تا رشته هم نشونمون میده. بسیار خوب، اگر با سیستم عامل هایی مثل DOS کار کرده باشید قطعا با محیط متنی آشنایید. اگر هم مثل من لینوکسی باشید احتمالا بخش بزرگی از کارهاتون رو توی محیط ترمینال انجام میدید. حتی در ویندوز هم بعضی وقتا نیاز شدیدی به CMD یا همون Command Prompt پیدا میکنیم. پس نیاز داریم که یک محیطی بسازیم که دستورات رو از کاربر بگیره و بهشون پاسخ بده. ما در این قسمت، میایم و دستورات رو از کاربر میگیریم. در قسمت های بعدی دستورات مورد نظرمون رو هم اضافه میکنیم.

بعد از نوشتن prompt و قابلیت خوندن ورودی از کاربر، در واقع به این شکل میشه کدمون:

کد   
org 0x7c00
bits 16
 
mov ax, 0
mov ds, ax
mov es, ax
mov ss, ax
mov sp, 0x7c00
 
mov si, welcome 
call print_string 
 
mov si, about
call print_string
 
mov si, newline
call print_string
 
mainloop:
 mov si, prompt
 call print_string
 
 mov di, buffer
 call get_string
 
 mov si, buffer
 cmp byte [si], 0
 je mainloop
 
 jmp mainloop
 
welcome db  'Welcome to my OS', 0x0d, 0x0a, 0
about db  'Written in 16-bit real mode', 0x0d, 0x0a, 0
buffer times 64 db 0
prompt db '>> ', 0
newline db ' ', 0x0d, 0x0a, 0
 
print_string:
 lodsb
 or al, al
 jz .done 
 
 mov ah, 0x0e
 int 0x10
 
  jmp print_string
 
 
 .done:
   ret
 
get_string:
 xor cl, cl
 .loop:
   mov ah, 0
   int 0x16
 
   cmp al, 0x08
   je .backspace
 
   cmp al, 0x0D
   je .done
 
   cmp cl, 0x3F
   je .loop
 
   mov ah, 0x0e
   int 0x10
 
   stosb
   inc cl
   jmp .loop
 
   .backspace:
    cmp cl, 0
    je .loop
 
    dec di
    mov byte [di], 0
    dec cl
 
    mov ah, 0x0e
    mov al, 0x08
    int 0x10
 
    mov al, ' '
    int 0x10
 
    mov al, 0x08
    int 0x10
 
    jmp .loop
 
    .done:
      mov al,0
      stosb
 
      mov ah, 0x0e
      mov al, 0x0d
      int 0x10
      mov al, 0x0a
      int 0x10
 
      ret
 
times 510-($-$$) db 0
dw 0xaa55

تفاوتش با قبلی چیه؟ درسته یک تابع بلند و بالای get_string اضافه شده، متغیر buffer هم تعریف شده. یک حلقه اصلی هم به اسم mainloop تعریف کردیم. بیایم ببینیم این همه بخش، چه کارایی میکنن؟

بین بخش های اضافه شده، mainloop بخش ساده تریه. پس اول میریم اون رو بررسی کنیم :

کد   
mainloop:
 mov si, prompt
 call print_string
 
 mov di, buffer
 call get_string
 
 mov si, buffer
 cmp byte [si], 0
 je mainloop
 
 jmp mainloop

در بخش اول، یک اسم برای حلقه اصلی گذاشتیم. سپس متغیر prompt رو توی Source Index فرستادیم و تابع print_string رو صدا زدیم. مثل نوشتن اون چیزایی که قبلا نمایش دادیم (پیام خوشامد گویی و این حرفا!). بعدش هم buffer که الان ۶۴ تا صفره رو داخل Destination Index قرار دادیم و تابع get_string رو صدا زدیم. این تابع، در واقع داره یه چیزی رو از ورودی میخونه (چطوری؟ الان بررسیش میکنیم!) . بعد بافر رو به si میفرستیم و بایت به بایت رو با صفر مقایسه میکنیم. اگر همه بایت ها صفر بود(یعنی دستور خالی بود) ، بر میگردیم سر خونه اول. در آخر هم یک پرش میکنیم به حلقه اصلی. چه دستوری وارد شده باشه، چه نشده باشه! حالا بیایم ببینیم تابع get_string مون چطوری کار میکنه؟

کد   
get_string:
 xor cl, cl
 .loop:
   mov ah, 0
   int 0x16
 
   cmp al, 0x08
   je .backspace
 
   cmp al, 0x0D
   je .done
 
   cmp cl, 0x3F
   je .loop
 
   mov ah, 0x0e
   int 0x10
 
   stosb
   inc cl
   jmp .loop
 
   .backspace:
    cmp cl, 0
    je .loop
 
    dec di
    mov byte [di], 0
    dec cl
 
    mov ah, 0x0e
    mov al, 0x08
    int 0x10
 
    mov al, ' '
    int 0x10
 
    mov al, 0x08
    int 0x10
 
    jmp .loop
 
    .done:
      mov al,0
      stosb
 
      mov ah, 0x0e
      mov al, 0x0d
      int 0x10
      mov al, 0x0a
      int 0x10
 
      ret

خب اولین کاری که کردیم انجام یه xor روی cl بوده. در واقع هشت بیت پایینی CX رو با خودش XOR کردیم. این یک کلک مرسوم هست برای تولید عدد صفر، مواقعی که نمیخوایم رجیسترهامون صفر شن. بعدش یک حلقه تعریف کردیم. توی این حلقه، اومدیم چه کردیم؟ عدد صفر رو توی AH قرار دادیم سپس از وقفه ۱۶ هگزادسیمال استفاده کردیم. این وقفه منتظر میمونه تا یک کلید فشرده شه. بعدش عدد هگزادسیمال 08 رو وارد AL کردیم. این چی کار میکنه؟ این چک میکنه کلید backspace فشرده شده یا نه. سپس در صورت برابری، میره به زیرتابع backspace که تعریف کردیم. بعدش هم با قرار دادن 0D در AL چک میشه که آیا Enter فشرده شده یا نه؟ و اگر درست باشه، میره به زیرتابع done که باز هم تعریف شده و مشاهده میکنید. بعد اومدیم محتوای CL رو با 3F مقایسه کردیم ، این دستور چک میکنه آیا ۶۳ کرکتر وارد شده؟ و سپس فقط به Enter و Back Space اجازه میده که کار انجام بدن. در واقع نمیتونید کلید دیگری رو فشار بدید. بعدش هم 0E رو داخل AH گذاشتیم و از همون وقفه معروف بایوس استفاده کردیم. این پروسه به شما اجازه میده هر وقت کلیدی رو فشردید، بدون درنگ کرکتر مورد نظرتون رو روی صفحه مشاهده کنید. حالا نوبتی هم باشه، نوبت زیرتابع هایی هست که داریم. اولیش، backspace هست که به این شکله :

کد   
.backspace:
    cmp cl, 0
    je .loop
 
    dec di
    mov byte [di], 0
    dec cl
 
    mov ah, 0x0e
    mov al, 0x08
    int 0x10
 
    mov al, ' '
    int 0x10
 
    mov al, 0x08
    int 0x10
 
    jmp .loop

این زیرتابع، اول میاد CL رو با صفر مقایسه میکنه. اگر برابر بود میره دوباره توی حلقه اصلی زیرتابع که تعریف کردیم. اگر نبود DI رو یک واحد کم میکنه، بعد کرکتر رو پاک میکنه و همچنین یکی از CL کم میکنه، چرا؟ چون طول رشته ما توی CL ذخیره شده. بعد میایم عدد 0x0e رو وارد AH میکنیم (این تابع مربوط به چاپ کرکتر ها و رشته ها توی وقفه 0x10 بایوس هست) ، بعد 08 رو وارد AL میکنیم که پروسه فشرده شدن backspace رو کنترل میکنه بعد هم وقفه 0x10 رو اجرا میکنیم. بعدش میایم یک کرکتر خالی میریزیم توی AL و بعد باز وقفه اجرا میشه و بعدش هم کرکتر خالی رو پاک میکنیم. در آخر هم به Loop برمیگردیم. حالا بریم ببینیم done اینجا چیکار میکنه؟

کد   
.done:
      mov al,0
      stosb
 
      mov ah, 0x0e
      mov al, 0x0d
      int 0x10
      mov al, 0x0a
      int 0x10
 
      ret

حقیقتا این تابع برای اینه که وقتی یک رشته وارد کردیم و enter رو زدیم عمل کنه حالا ببینیم چطور کار میکنه؟ اول عدد صفر رو میذاریم داخل AL که نقش NULL terminator رو داره. بعدش دستور stosb رو میزنیم که رشته رو ذخیره میکنه. بعدش هم 0E رو وارد AH میکنیم (همون تابع معروف 😀 ) و بعدش 0D رو در AL میذاریم (اتمام رشته) و کارمون رو با وقفه تموم میکنیم. بعدش با قرار دادن 0x0a و اجرای وقفه معروف، میریم خط بعدی. ret هم که تابعمون رو تموم میکنه!

حالا میتونید با خیال راحت با سیستم عامل ۱۶ بیتی خودتون بازی کنید! برای این که ببینید چه اتفاقاتی پشت پرده داره میفته، میتونید ویدئوی من رو ببینید که سیستم عامل رو اسمبل کردم و در ویرچوال باکس اجراش کردم 🙂

توی ویدئو می بینید که با ورود نوشته ها، دستوری اجرا نمیشه. ولی در آینده چند تا دستور ساده برای سیستم عامل سادمون خواهیم نوشت.

موفق باشید 🙂

Share

نوشتن یک سیستم عامل ساده – قسمت دوم

در مقاله قبلی، در مورد نمایش یک حرف روی مانیتور صحبت شد. اما یک حرف کافی نیست. حتی نمیشه به صورت حرف به حرف کلمات و جملات رو نشون داد چون واقعا کار سختیه. ما میخوایم یک پیغام (مثل Hello World) رو موقع بوت شدن سیستم عاملمون شاهد باشیم. پس باید چه کنیم؟ یک راه حل اینه که از یک ویژگی ای در زبان مورد نظر (اینجا اسمبلی) استفاده کنیم که بتونه یک رشته رو چاپ کنه. طبیعتا اسمبلی به طور پیشفرض دستوری مثل cout نداره و ما مجبوریم که خودمون اون رو به cout بیاریم. در این قسمت از مقالات «نوشتن یک سیستم عامل ساده» به این میپردازیم که چطور سیستم عامل ۱۶ بیتی ما، یک یا چند جمله رو نشونمون بده! در این قسمت علاوه بر رجیستر AX از سایر رجیستر ها هم استفاده خواهیم کرد. ممکنه بپرسید چرا؟ جواب سوالتون رو توی متن میگیرید!

خب فایل my16bitos.asm رو باز کنید. کل محتواش رو پاک کنید و این رو جایگزینش کنید :

کد   
org 0x7c00
bits 16
 
mov ax, 0
mov ds, ax
mov es, ax
mov ss, ax
mov sp, 0x7c00
 
mov si, welcome 
call print_string 
 
mov si, about
call print_string
 
welcome db  'Welcome to my OS', 0x0d, 0x0a, 0
about db  'Written in 16-bit real mode', 0x0d, 0x0a, 0
 
print_string:
 lodsb
 or al, al
 jz .done 
 
 mov ah, 0x0e
 int 0x10
 
  jmp print_string
 
 
 .done:
   ret
 
times 510-($-$$) db 0
dw 0xaa55

دیدید ؟ کد خیلی طولانی تر شده نسبت به قبل. طبیعیه چون که ما یه تابع تعریف کردیم و از یه سری چیزای جدید هم استفاده کردیم. خب آماده اید؟ میریم که بخش به بخش سیستم عامل کوچولوی خودمون رو بررسی کنیم!

کد   
org 0x7c00
bits 16

این قسمت، برای اینه که اولا ، اسمبلر آدرس ها رو بفهمه، ثانیا بفهمه که کد چند بیتیه. در آینده کد ما ۳۲ بیت خواهد شد و این بخش هم تغییر خواهد کرد. ولی فعلا تا آموزشهای بعدی همین برنامه رو داریم.

کد   
mov ax, 0
mov ds, ax
mov es, ax
mov ss, ax
mov sp, 0x7c00

این قسمت از کدمون هم مقدار صفر رو توی رجیستر AX میذاره و سپس اون رو به Data Segment, Extra Segment و Stack Segment منتقل میکنه (توجه کنید مستقیما نمیتونیم مقداری رو درون این رجیستر ها بذاریم. پس اول مقدار رو میذاریم توی AX سپس با MOV یکی یکی منتقل میکنیم). در آخر هم مقدار 7C00 هگزا دسیمال رو توی Stack Pointer قرار میدیم (استک از این آدرس شروع میکنه و میاد پایین).  این بخش داره مقدمات اجرای سیستم عامل ما رو فراهم میکنه.

بعد از اونا میرسیم به این بخش :

کد   
mov si, welcome 
call print_string 
 
mov si, about
call print_string
 
welcome db  'Welcome to my OS', 0x0d, 0x0a, 0
about db  'Written in 16-bit real mode', 0x0d, 0x0a, 0

این قسمت تقریبا ساده ترین قسمت برنامست. اومدیم welcome و about که دو رشته هستند رو ریختیم توی Source Index و سپس تابع print_string که کارش چاپ رشته هست هم صدا زدیم. با دستور db هم گفتیم که چه رشته هایی رو مد نظر داریم که چاپ شن. اون اعداد هگزاسیمال بعد از متغیر ها هم معادل New Line هستند (مثلا مقدار n در دستورات بک اسلش در C ).

بعد از این جنگولک بازیا ( 😀 ) میرسیم به کار اصلیمون یعنی نوشتن تابع print_string . این تابع نسبتا سادس ولی خب نیاز به توضیح داره چون دستوراتی رو استفاده کردیم که توی مطلب قبلی نبودن :

کد   
print_string:
 lodsb
 or al, al
 jz .done 
 
 mov ah, 0x0e
 int 0x10
 
  jmp print_string
 
 
 .done:
   ret

خب اول اومدیم اسم تابع رو گذاشتیم print_string (شما میتونید هرچیزی دلتون میخواد بذارید، مثلا دوستی ممکنه بذاره cout که براش ملموس تره و …). بیایم ببینیم خط به خط تابع چه میکنه؟

اون lodsb یک بایت رو از SI میخونه ، بعد رجیستر AL با خودش از نظر منطقی OR میشه. در نهایت اگر نتیجه صفر شد میره به done که done هم همونطور که می بینید داره return میکنه و از تابع خارج میشه. اگر جواب صفر نشه، مقدار 0e هگزا دسیمال وارد AH میشه و سپس وقفه 10 هگزادسیمال که یکی از وقفه های بایوس هست اجرا میشه. در واقع 0e یکی از تابع های وقفه مورد نظر ماست. بعد از اون پرش رخ میده به print_string. در واقع ما یک حلقه نوشتیم که به تعداد کرکتر های رشتمون، تکرار میشه و رشته رو تکرار میکنه.

در نهایت هم باید به اسمبلر بفهمونیم که برناممون یک Boot Sector عه پس طبیعتا از این قطعه کد استفاده میکنیم که در مطلب قبلی توضیحش دادم :

کد   
times 510-($-$$) db 0
dw 0xaa55

خب الان یک سیستم عاملی داریم که میتونه یک رشته چاپ کنه. ولی هنوز نمیتونه چیزی رو از کاربر بگیره و بخونه. این مورد میره برای آموزش های بعدی. فعلا بیاید این کد رو توی ویرچوال باکس اجرا کنیم! برای اجرای این سیستم عامل کد های زیر رو به ترتیب توی ترمینال اجرا کنید :

کد   
nasm -f bin -o my16bitos.bin my16bitos.asm
dd if=my16bitos.bin of=my16bitos.img

بعد یک ماشین مجازی توی ویرچوال باکس ایجاد کنید، یک Floppy Controller بسازید و اولویت بوت رو بهش بدید. سپس img رو بدید به فلاپی کنترلر و سپس ماشین رو روشن کنید. باید چنین صحنه ای رو مشاهده کنید :

 

os

تبریک! شما تقریبا نصف بیشتر راه رو رفتید! در ادامه هم میرسیم به باقی ماجرا و نوشتن prompt و این چیزا!

موفق باشید 🙂

Share

نوشتن یک سیستم عامل ساده – قسمت اول

همونطور که در جریانید، مدتهای زیادی بود که من دنبال ساخت یک سیستم عامل بودم. خب ساخت سیستم عامل دانش بالایی میخواد. حداقلش اینه که باید بدونیم چی میخوایم! ولی اگر صرفا برای فان بخوایم چنین کاری کنیم، میتونیم یک سیستم عامل خیلی ساده بنویسیم و اگر احتمالا یه کامپیوتر قدیمی و داغون داریم، روی اون نصبش کنیم.

خب، بیاید اول ببینیم چی نیاز داریم؟ اول از همه نیاز داریم که اسمبلی بلد باشیم. احتمالا با گشتن توی اینترنت کلی جزوه و کتاب و آموزش اسمبلی پیدا میکنید، همچنین اگر درس زبان ماشین پاس کرده باشید خیلی راحتتره کارتون، چون ایده کلی رو دارید. و البته مهم تر از اون، اینه که لینوکس و برنامه نویسی هم بدونید. اگر هم لینوکس بلد نیستید سعی کنید یاد بگیرید چون یکی از بهترین محیط های این کار به حساب میاد و اگر توی فروم هایی مثل OSDev بچرخید خواهید دید که اکثر توسعه دهندگان از لینوکس استفاده کردند، حتی اونایی که با سی شارپ یا MASM کار رو انجام داده بودن 😀 . دلیل عمده استفادشون از لینوکس (یا هر چیز شبه یونیکسی) وجود ابزارهای خوب توسعه روی این دسته از سیستم عامل هاست. همچنین خیلی از ایده هایی که شما بهش فکر میکنید رو قبلا روی این سیستم عاملها آزمایش کردند و ساختند که یا آزادند و یا نمونه های آزاد دارند.

خیلی خوب، بذارید اول ببینیم چه چیزهایی باید نصب کنیم؟

  1. یک ادیتور متنی، که معمولا همراه سیستم عاملتون نصب میشه. من خودم از nano و gedit و atom استفاده میکنم، و توصیه میکنم شما هم یکی از این ادیتورهای ساده رو انتخاب کنید تا درگیر پیچیدگی های vim و … نشید.
  2. یک اسمبلر که من اینجا از nasm استفاده میکنم، و nasm توی مخازن اوبونتو و دبیان و … موجوده. اگر هم نبود هم باینری و هم سورسش موجوده.
  3. یک مجازی فوق العاده ساده هم نیاز داریم. در واقع مجازی سازی که برای راه انداختن و بوت کردن یه باینری ساده، اذیتمون نکنه. من از qemu استفاده میکنم. حالا شما میتونید از bochs یا VirtualBox یا هرچیز دیگری استفاده کنید  و انتخاب خودتونه.

خب طبیعتا ترمینال هم نیاز داریم که این وسط بتونیم کارامونو باهاش انجام بدیم 🙂

الان کافیه که با اراده قوی، یک فایل به اسم my16bitos.asm باز کنید و شروع کنید کد زدن. خب باید چی بنویسیم؟ یکی از نکات مهمی که اینجا هست اینه که ما نمیتونیم از روتین ها یا وقفه های سیستم عامل استفاده کنیم و نیاز داریم از بایوس استفاده کنیم! دقیقا چون بایوس MBR رو میخونه و از این داستانا که موقع بوت شدن داریم. پس کد ما چنین چیزی میشه :

کد   
MOV AH, 0x0e
MOV AL, 'A'
INT 0x10
JMP $
times 510-($-$$) db 0
DW 0xaa55

خب این شد کد ما. در واقع ما یک سیستم عامل (یا بهتر بگم بوت سکتور) ۱۶ بیتی نوشتیم. که البته این خیلی سادست و در قسمت بعدی پیچیده ترش خواهیم کرد. این سیستم عامل ۶ خطی (شاید به خاطر پیشرفت علوم کامپیوتر و اسمبلر ها و پردازنده ها، الان این کد شش خطه، و ممکن بوده زمانی یه مهندس کامپیوتر یا صرفا یک علاقمند به علوم رایانه رویاش نوشتن چنین چیزی بوده!)، وقتی بوت شه حرف A رو به ما نمایش میده. حالا با چه اتفاقاتی؟

خط اول که میگه عدد شانزده شانزدهی 0x0e رو در هشت بیت بالایی رجیستر AX قرار بده، یکی از روتین های بایوسه. در واقع بایوس میفهمه که بوت سکتور، این برنامه ست. خط دوم میگه کرکتر A رو در هشت بیت پایینی همون رجیستر قرار بده. در خط سوم ما یک وقفه (توجه کنید INT توی اسمبلی مخفف Interrupt یا «وقفه» است نه Integer .) ایجاد کردیم. وقفه 0x10 در بایوس برای نمایش کرکتر ها به کار میره (البته توی روتین 0x0e). در خط چهارم با استفاده از دستور پرش، برنامه رو تا ابد باز نگه داشتیم، که وقتی سیستم عامل بوت میشه همچنان روشن بمونه. یکی از سخت ترین خط ها از نظر درک، خط پنجمه. خط پنجم چی کار میکنه؟ ۵۱۰ بایت اول دیسک (این سیستم عامل میتونه از روی یک فلاپی یا هارد دیسک یا هر دیوایس دیگری بوت شه) رو با صفر پر میکنه و حالا چرا؟ چون ما میخوایم در دوبایت نهایی، عدد جادویی 0xaa55 رو قرار بدیم که بوت سیستم عامل بهش وابسته است.

بسیار خوب، تا اینجای کار فهمیدیم که این کد چی کار میکنه. حالا با nasm کد رو اسمبل میکنیم تا به یه فایل قابل بوت شدن برسیم :

کد   
nasm -f bin -o my16bitos.bin my16bitos.asm

اکنون در دایرکتوری جاریتون، باید فایل my16bitos.bin رو ببینید. کافیه تا با qemu اجراش کنید به این شکل :

کد   
qemu-system-i386 my16bitos.bin

پس از اجرای دستور و باز شدن پنجره مربوط به QEMU ، و نمایش اطلاعات مربوط به QEMU ، شاهد نمایش حرف A خواهید بود. تبریک میگم! این اولین تلاش شما برای ساخت یک سیستم عامله! در قسمت بعدی این سیستم عامل رو کامل تر میکنیم تا بتونه یه سری اطلاعات رو از کاربر بخونه و جواب بده.

پس تا مطلب بعدی خداحافظ!

Share