ساخت یک کامپیوتر ۴ بیتی ساده با استفاده از مدارات منطقی

یک زمانی، حتی فکر کردن به این که بتونیم با چندتا مدار ساده یک کامپیوتر (حتی ۴ بیتی) هم داشته باشیم، احمقانه و ناممکن به نظر میرسید. چرا که هزینه شبیه سازی خیلی از مدارها و تستشون بسیار بالا بود. اما توی این دوره، شما با خوندن چند تا داکیومنت و نصب چند نرم افزار ساده، میتونید کامپیوتر خودتون رو بسازید. بسیار خوب، منبع این پست ، این مقالست که یک ویدئوی خوب هم داره. توی این مقاله به جای استفاده مستقیم از مدارات منطقی، اومدن و از ترانزیستور استفاده کردن، اما باز هم استفاده از ترانزیستور منطقی به نظر نمیرسه، چرا که مدارهای منطقی کوچک ترن و فهمشون هم راحت تره.

مدارهای منطقی چی هستن؟

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

برای پردازنده کوچکمون چی نیازه؟

اول از همه، نیاز داریم که یک مدار Adder بسازیم. مدارهای Adder معمولا از چند تا Full Adder یک بیتی تشکیل میشن، و هر فول ادر یک بیتی هم از دو تا Half-adder .

برای ساخت Half-adder کافیه که یک بار ورودی A رو NOT کنیم و با B اون رو AND کنیم، سپس B رو NOT کنیم و با A اون رو AND کنیم. آخر هم نتیجه دو تا AND رو با هم OR کنیم. برای بدست آوردن رقم نقلی هم کافیه که A و B رو مستقیما با هم AND کنیم.half-adder2

مدار Half Adder نهاییمون به این شکل میشه. اما استفاده مدوام از NOT و AND و OR باعث سخت شدن توسعه ماشین میشه، پس از مجموعه ای که برای ساخت Half Adder استفاده کردیم میتونیم صرف نظر کنیم و از مدار XOR استفاده کنیم. البته همچنان برای رقم نقلیمون به AND نیاز خواهیم داشت.

بسیار خوب، برای Full Adder نیاز داریم که از پیش تعیین کنیم رقم نقلی ای وجود داره؟ یا نه! و برای این کار غیر از A و B یک ورودی به اسم Carry In یا «رقم نقلی ورودی» خواهیم داشت. و سپس، رقم نقلی ورودی رو باید به عنوان ورودی به یک Half-Adder دیگه بدیم. سپس، نتیجه AND شدن A و B رو با نتیجه AND شدن اولین Half-Adder و Carry In رو با هم OR کنیم تا رقم نقلی کلی بدست بیاد. پس مدار ما به این شکل خواهد شد :

full adderخب، این دو مدار رو الان ساختیم. قدم بعدی، ساختن کامپیوترمونه!

برای ساختن یک Adder چهار بیتی، باید به این شکل فول ادر ها رو کنار هم بچینیم :

Slide11همونطور که دیدید، این روش چیدن Adder ها پشت هم، مدل Ripple Carry نامیده میشه. خب، این کامپیوتر کوچک، میتونه اعداد ۰ تا ۱۶ (در دنیای بدون علامت و با در نظر گرفتن رقم نقلی) و -۱۶ تا ۱۵ (در دنیای علامت دار و بدون در نظر گرفتن رقم نقلی) رو به ما نمایش بده. با خاموش و روشن کردن به موقع مدارها عملیات جمع و تفریق رو میتونید انجام بدید.

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

4-bit computer simulation

برای شبیه سازی چه نرم افزاری نیازه؟

من برای کشیدن نقشه Half Adder و Full Adder از تخته وایت برد اتاقم (بله! تخته وایت برد توی اتاقا الزامیه!) و نرم افزار Logisim (موجود در مخازن اوبونتو) استفاده کردم. برای شبیه سازی کلی ماشین هم از Logic.ly که آزمایشگاه آنلاین داره استفاده کردم. البته هر نرم افزار دیگه ای میتونه بهتون در شبیه سازی کمک کنه. حتی میتونید با VHDL هم بنویسیدش و تستش کنید!

امیدوارم که این پست هم براتون مفید واقع شده باشه!

موفق باشید.

FacebookTwitterGoogle+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). کاربرد این قضیه چیه؟ فرض کنیم سیستم عامل تا حدی پیشرفت کرد و تونست برنامه اجرا کنه، با استفاده از جدول و هندل کننده های وقفه ها، میتونیم برای سیستم عامل خودمون یه اسمبلر طراحی کنیم، کامپایلر ها رو روش بیاریم و برنامه هایی که دسترسی سطح پایین میخواند رو اجرا کنیم.

موفق باشید :)

FacebookTwitterGoogle+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 ساخته شدمون دسترسی پیدا کنیم!

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

FacebookTwitterGoogle+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 برای بوت کردنش استفاده خواهیم کرد!

موفق باشید :)

FacebookTwitterGoogle+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 .

موفق باشید!

FacebookTwitterGoogle+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 هم که تابعمون رو تموم میکنه!

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

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

موفق باشید :)

FacebookTwitterGoogle+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 خواهید بود. تبریک میگم! این اولین تلاش شما برای ساخت یک سیستم عامله! در قسمت بعدی این سیستم عامل رو کامل تر میکنیم تا بتونه یه سری اطلاعات رو از کاربر بخونه و جواب بده.

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

FacebookTwitterGoogle+Share

استفاده از اسمبلر MASM روی لینوکس

اگر شما هم هم رشته من باشید و زبان ماشین برداشته باشید، به احتمال بسیار بسیار بالا استاد این درس، کدهایی بهتون میده که با MASM اسمبل میشن، و طبیعتا شما ناراحت خواهید شد که چرا این اسمبلر نسخه لینوکسی نداره و … 😀 . و جالبه بدونید راهی که توی این پست به شما ارائه میکنم، نه تنها برای لینوکس و سیستم عاملهای غیر از ویندوز، بلکه روی ویندوز ۶۴ بیتی هم باید اجرا بشه.

اولین چیزی که نیاز دارید، این هست که یک ایمولاتور برای شبیه سازی محیط سیستم عامل قدیمی DOS تهیه کنید. برای ویندوز و لینوکس و BSD ها و … ، نرم افزاری ارائه شده به اسم DOSBox که محیط داس رو شبیه سازی میکنه. توی اوبونتو/دبین با این دستور نصب میشه :

کد   
sudo apt-get install dosbox

سپس، شما نیاز به دانلود اسمبلر MASM دارید که میتونید از اینجا دانلودش کنید.

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

کد   
mount f ~/masm
f:

دستور mount پوشه ای که آدرسش را به عنوان ورودی دریافت کرده را درون یک درایو مجازی به نام F سوار میکند و با دستور بعدی، به آن درایو مجازی میرویم. (توجه کنید که پوشه MASM در پوشه خانگی قرار داده شده است. چنانچه در آدرس دیگری قرار داده اید باید مسیر را عوض کنید)

حالا میتوانید با اجرای MASM.EXE یا ML.EXE ، کدی که به زبان اسمبلی نوشته اید را اسمبل کنید.

موفق باشید :)

 

FacebookTwitterGoogle+Share