قسمت اول
مدت زیادی بود که یک سؤال ذهنم را درگیر کرده بود:
داخل یک پردازنده چه اتفاقی دراه رخ میده و کدهایی که ما مینویسیم چطور در پایینترین سطح اجرا میشوند؟
البته از قبل میدونستم کدهایی که با زبانهای سطح بالا مثل Java، Python، Kotlin و ... مینویسیم، در نهایت باید به زبان قابل فهم برای پردازنده تبدیل میشه.
برای مثال در زبان Java، کدی که مینویسیم ابتدا توسط Compiler به Bytecode تبدیل و سپس توسط Java Virtual Machine (JVM) اجرا شده و در نهایت به دستورهای قابل فهم برای پردازنده تبدیل میشوند.
یعنی پشت اجرای سادهترین برنامهها، پردازنده در کسری از ثانیه به طرز وحشتانکی میلیاردها عملیات روی صفر و یکها انجام میدهد.
واقعاً شگفتانگیزه!
همین کنجکاوی باعث شد خودم را به چالش بکشم و وارد دنیای جدیدی شوم؛ دنیایی که خیلی پایینتر از زبانهایی مثل Java و Python قرار دارد.
اولین کاری که کردم این بود که سراغ منابع مختلف رفتم. مثل همیشه اولین مقصد هم یوتوب بود.
اولین ویدیویی که با عنوان:
How to build an Operating System from scratch
پیدا کردم را با هیجان زیاد پلی کردم.
همون ابتدای کار فمیدم هیچی میتوجه نمیشم و با احترام کامل ویدیو رو قطع کردم 😄
خب متوجه شدم برای ساخت یک سیستمعامل از صفر، هنوز مسیر زیادی دارم و بهتره از مفاهیم پایهتر شروع کنم.
شروع کردم به مطالعه مقالهها، مشاهده ویدیوهای آموزشی و بررسی منابع مختلف تا اینکه فهمیدم بسیاری از آموزشهای مربوط به معماری کامپیوتر و سیستمعامل، از معماریهای سادهتر و قدیمیتر مثل x86 8086 شروع میشوند.
خبر خوب این بود که قرار نبود میلیونها صفر و یک را دستی داخل یک فایل متنی بنویسم تا یک برنامه ساده بسازم.
اما خبر نهچندان خوب این بود که باید Assembly یاد میگرفتم 😄
ابتدا شروع کردم به جمعآوری اطلاعات درباره پردازنده Intel 8086.
Intel 8086 یک پردازنده 16 بیتی بود که در سال 1978 توسط شرکت Intel معرفی شد و یکی از مهمترین پردازندههای خانواده x86 به حساب میآید.
برای یادگیری این معماری، ابزارهای آموزشی مثل emu8086 برای ویندوز وجود دارند که به ما اجازه میدهند کد Assembly بنویسیم، آن را اجرا کنیم و Registerها و Flagهای پردازنده را مرحلهبهمرحله مشاهده کنیم.
واقعا برام موضوع جالبی بود
فکر کن بتونی ببینی پردازنده دقیقاً چه دستورهایی را اجرا میکنه، مقدار Registerها چگونه تغییر میده و وضعیت CPU در هر لحظه چیه!
اما ...
من اصلاً نمیدونستم Register چیه، Flag چیه، Memory Addressing یعنی چه و این چیه اون چیه؟؟؟!!!
برای همین چند روز زمان گذاشتم تا ابتدا معماری x86 را بهتر درک کنم.
البته باید اعتراف کنم، برای کسی که تازه از دنیای:
print("hello world")
وارد دنیای پردازنده شده، دیدن ساختار داخلی CPU کمی ترسناکه 😄

پردازنده 8086 از بخشهای مختلفی تشکیل شده است، اما برای شروع میتوانیم مهمترین بخشها را بررسی کنیم.
Execution Unit (EU)
واحد اجرا مسئول تفسیر و اجرای دستورهاست.
این بخش شامل قسمتهایی مثل:
ALU (Arithmetic Logic Unit) برای انجام عملیات محاسباتی و منطقی
Registerهای عمومی
Register مربوط به Flagها
Bus Interface Unit (BIU)
واحد ارتباط با باس مسئول ارتباط CPU با حافظه و دریافت دستورها از RAM .
این بخش شامل:
Segment Registerها
Instruction Pointer (IP)
منطق تولید آدرس حافظه
Registers
Registerها حافظههای بسیار کوچک و بسیار سریع داخل CPU اند و نزدیک به خود پردازنده اند.
پردازنده برای انجام عملیاتهایی مثل محاسبات، انتقال داده و اجرای دستورها، نمیتواند همیشه مستقیماً با RAM کار کند؛ چون سرعت RAM کمتر از سرعت CPU است.
به همین دلیل CPU از Registerها به عنوان یک فضای کاری بسیار بسیار سریع استفاده میکنه تا دادههایی که بیشتر به آنها نیاز دارد، نزدیک به واحد پردازش قرار بگیرند.
در برنامهنویسی سطح پایین (Low-Level Programming)، Registerها یکی از مهمترین ابزارهای ارتباط مستقیم با CPU هستند.
بعضی Registerها برای نگهداری داده، بعضی برای آدرسدهی حافظه، بعضی برای مدیریت Stack و بعضی برای کنترل روند اجرای برنامه استفاده میشوند.
در واقع ما قرار است با همین خانههای کوچک داخل CPU، اجرای برنامه را مرحلهبهمرحله کنترل کنیم.
بعد از اینکه یک دید کلی نسبت به معماری پردازنده پیدا کردم، به خودم گفتم:
«تا وقتی دست به کد نشوم، این مفاهیم را واقعاً درک نمیکنم.»
برای همین تصمیم گرفتم اولین برنامه Assembly خودم را بنویسم.
ابتدا سراغ emu8086 رفتم، اما خیلی با محیطش ارتباط نگرفتم و ترجیح دادم از ویرایشگر محبوب خودم یعنی Vim استفاده کنم.
برای آمادهسازی محیط توسعه، ابزارهای مورد نیاز رو توی لینوکس نصب کردم:
Ubuntu / Debian: - sudo apt update - sudo apt install nasm qemu-system-x86 gdb binutils Fedora: - sudo dnf install nasm qemu-system-x86 gdb binutils برای اطمینان از نصب : - nasm -version - qemu-system-i386 --version - gdb --version
Windows - choco install nasm qemu gdb برای اطمینان از نصب : nasm -version qemu-system-i386 --version gdb --version
ابزارهای اصلی که استفاده کردم:
NASM برای تبدیل Assembly به فایل Binary
QEMU برای اجرای Bootloader در محیط شبیهسازیشده
GDB برای Debug کردن CPU و بررسی Registerها
Binutils برای بررسی فایلهای Binary
حالا که یک آشنایی اولیه با CPU و معماری 8086 پیدا کرده بودم، وقت آن رسیده بود بفهمم وقتی یک سیستم روشن میشود دقیقاً چه اتفاقی میافتد.
چطور کامپیوتری که هنوز هیچ برنامهای اجرا نکرده، میتواند اولین کد را اجرا کند؟
اینجا بود که با مفهوم Boot Process آشنا شدم.
به زبان ساده، Bootloader یک برنامه کوچک است و در اولین مراحل روشن شدن سیستم اجرا میشود و وظیفه دارد سیستم را برای اجرای مراحل بعدی آماده کند.
در سیستمعاملهای واقعی، Bootloader معمولاً وظیفه دارد Kernel را از حافظه ذخیرهسازی پیدا کرده و آن را داخل RAM بارگذاری کند.
اما برای شروع یادگیری، تصمیم گرفتم یک Bootloader بسیار ساده بنویسم که فقط یک کار انجام دهد:
نمایش یک کاراکتر روی صفحه نمایش.
شاید ساده به نظر برسد، اما همین کار ساده یعنی من دارم اولین کدی را اجرا میکنم که قبل از وجود هر سیستمعاملی، مستقیماً توسط CPU اجرا میشود.
به صورت خلاصه روند Boot شدن یک سیستم مبتنی بر BIOS به این شکل است:
Power On | ↓ CPU Reset | ↓ BIOS starts executing | ↓ POST (Power-On Self Test) | ↓ Find Boot Device | ↓ Load Bootloader into RAM | ↓ Jump to Bootloader Code | ↓ Bootloader executes
حالا کمی دقیقتر این مراحل را بررسی کنیم.
وقتی دکمه Power را فشار میدیم، CPU از حالت Reset خارج میشه و اجرای اولین دستورهای خود را آغاز میکند.
در سیستمهای قدیمی مبتنی بر BIOS، کنترل اولیه به Firmware سیستم منتقل میشود.
BIOS مخفف:
Basic Input/Output System
است و وظیفه دارد سختافزارهای اصلی سیستم را بررسی و آماده کند.
در این مرحله تستی به نام:
POST (Power-On Self Test)
انجام میشود که مواردی مثل:
RAM Keyboard Display Storage Devices
را بررسی میکند.
بعد از موفقیت POST، BIOS طبق ترتیب Boot مشخصشده دنبال یک دستگاه قابل بوت میگردد.
برای مثال:
Hard Drive USB CD/DVD
در سیستمهای BIOS سنتی، BIOS اولین سکتور دستگاه Bootable را بررسی میکند.
این سکتور باید دارای یک امضای مخصوص در دو بایت آخر خود باشد:
0x55AA
که به آن:
Boot Signature
گفته میشود.
اگر این امضا وجود داشته باشد، BIOS متوجه میشود که این سکتور شامل کد قابل اجرا برای Boot است.
سپس این 512 بایت را به آدرس مشخصی از حافظه RAM منتقل میکند:
0x7C00
و کنترل اجرای برنامه را به CPU میسپارد.
از این لحظه به بعد، کدی که ما نوشتهایم شروع به اجرا میکند.
بعد از اینکه مفهوم Boot Process را فهمیدم، وقت آن بود که اولین کد خودم را بنویسم.
هدف خیلی ساده بود:
فقط نمایش حرف: N
روی صفحه.
کد:
[bits 16] org 0x7c00 mov ah, 0x0e mov al, 'N' int 0x10 times 510 - ($ - $$) db 0 dw 0xAA55
این Bootloader ساده در حالت:
16-bit Real Mode
اجرا میشود.
[bits 16]
به Assembler میگوید که کد ما برای پردازنده 16 بیتی نوشته شده است.
org 0x7c00
به Assembler اعلام میکند که این کد قرار است در آدرس 0x7C00 در حافظه اجرا شود.
این همان آدرسی است که BIOS معمولاً Boot Sector را در آن قرار میدهد.
mov ah, 0x0e mov al, 'N'
در این قسمت مقدارهای مورد نیاز را داخل Registerهای CPU قرار میدهیم.
برای درک سادهتر، میتوان آن را شبیه مقداردهی متغیرها در زبانهای سطح بالا تصور کرد:
int value = 0x0e;
اما تفاوت مهم اینه که در Assembly ما با متغیرهای ساختهشده توسط Compiler کار نمیکنیم، بلکه مستقیماً Registerهای واقعی داخل CPU را کنترل میکنیم.
در اینجا:
مقدار 0x0E داخل Register مربوط به AH قرار میگیرد.
کاراکتر N داخل Register مربوط به AL قرار میگیرد.
مقدار 0x0E یک Service Number برای BIOS است که مشخص میکند قصد داریم یک کاراکتر را در حالت Teletype Mode نمایش دهیم.
int 0x10
این دستور یک:
BIOS Video Interrupt
را فراخوانی میکند.
کنترل به سرویسهای ویدیویی BIOS منتقل میشود تا عملیات نمایش کاراکتر انجام شود.
یک Boot Sector باید دقیقاً 512 بایت باشد.
برای همین:
times 510 - ($ - $$) db 0
فضای باقیمانده فایل را با صفر پر میکند تا بوت لودری که نوشتیم دقیقا 512 بایت باشد.
و در پایان:
dw 0xAA55
امضای Boot را قرار میدهد تا BIOS بتواند این سکتور را به عنوان Bootloader معتبر شناسایی کند به بهش مجیک نامبر هم میگن تا تایید شود این یک بوت لودر است.
بعد از نوشتن کد، فایل را با نام:
boot.asm
ذخیره کردم.
سپس با استفاده از NASM آن را به فایل Binary تبدیل کردم:
nasm -f bin boot.asm -o boot.bin
و برای اجرا از QEMU استفاده کردم:
qemu-system-i386 -fda boot.bin یا از دستوری qemu-system-x86_64 -fda boot.bin
و نتیجه؟

یک حرف ساده روی صفحه ظاهر شد:
N
اما برای من این فقط یک کارکار نبود.
این اولین باری بود که کدی که خودم نوشته بودم، بدون وجود سیستمعامل و بدون هیچ Runtime یا Framework، مستقیماً توسط CPU اجرا میشد.
همین لحظه بود که فهمیدم چرا دنیای Low-Level Programming اینقدر جذاب است.
در پایینترین سطح، دیگر خبری از لایههای آماده نیست.
اینجا شما، CPU، حافظه و چند دستور ساده Assembly هستید.
این تجربه فقط یک شروع کوچک بود.
با نوشتن همین Bootloader ساده، علاقه من به دنیای Low-Level Programming بیشتر شد و تصمیم گرفتم مسیر یادگیری را ادامه بدهم.
لینک اولین بوت لودر من در گیت هاب : https://github.com/Nebez-Berzency/simple-bootloader