लिनुस टोरवाल्ड्स का अनुकरण करना: स्क्रैच (I) से अपना ऑपरेटिंग सिस्टम बनाना

सबसे पहले, टिप्पणी करें कि यह मेरा पहला लेख है और मुझे आशा है कि आप सभी को यह पसंद आएगा।

इस श्रृंखला में हम अनुकरण करने जा रहे हैं लीनुस Torvalds, हम 0. से अपना ऑपरेटिंग सिस्टम बनाने जा रहे हैं। इस पहले एपिसोड में हम बूट देखने जा रहे हैं और हम अपने कर्नेल से स्क्रीन पर एक टेक्स्ट डालेंगे।

मेरे मामले में ऑपरेटिंग सिस्टम कहा जाता है अगलाडिवेल। पहला निर्णय जो हमें ऑपरेटिंग सिस्टम पर विचार करते ही करना चाहिए, बूटलोडर क्या है?

यहाँ कई प्रकार हैं, और हम स्वयं भी बना सकते हैं; हालाँकि इस ट्यूटोरियल में मैं उपयोग करने जा रहा हूँ GRUB, क्योंकि अधिकांश उसके बारे में कम या ज्यादा जानते हैं। हम एक फ़ोल्डर बनाते हैं जो हमारे ऑपरेटिंग सिस्टम का मूल होगा और वहां हम / बूट / ग्रब फ़ोल्डर बनाते हैं

mkdir nextroot && cd nextroot

mkdir -p boot/grub

हम निम्नानुसार grub.cfg फ़ाइल बनाते हैं:

menuentry "NextDivel" {
echo "Booting NextDivel"
multiboot /next/START.ELF
boot
}


इस फाइल में हमने देखा है कि कैसे GRUB हमारे कर्नेल को इस मामले में /next/START.ELF में लोड करेगा। अब हमें अपना कर्नेल बनाना चाहिए।

इसके लिए हमें आवश्यकता होगी जीसीसी y गैस (परियोजना के कोडांतरक जीएनयू, आमतौर पर gcc के साथ आता है)। तो हम कर्नेल बनाने जा रहे हैं।

हम सबसे पहले एक फाइल बनाते हैं, जिसे कर्नेल कहा जाता है। इस फ़ाइल में हमारे कर्नेल के शुरुआती बिंदु होंगे और मल्टीबूट (कुछ बूटलोडर्स की एक विशेषता जैसे) को भी परिभाषित करेगा GRUB) है। Kernel.asm की सामग्री होगी:

.text
.globl start
start:
jmp multiboot_entry
.align 4
multiboot_header:
.long 0x1BADB002
.long 0x00000003
.long -(0x1BADB002+0x00000003)
multiboot_entry:
movl $(stack + 0x4000), %esp
call NextKernel_Main
loop: hlt
jmp loop
.section ".bss"
.comm stack,0x4000

मल्टीबूट से संबंधित सब कुछ बस विनिर्देशन का पालन करना है और कुछ नहीं। सब कुछ शुरू में शुरू होगा, इसे मल्टीबूट_एंट्री कहेंगे, हमने मल्टीबूट हेडर को पहले 4k में परिभाषित किया है और हम इसे (movl के साथ) डालेंगे।

बाद में हम नेक्स्टबर्न_मैन कहते हैं जो हमारा कर्नेल सी फ़ंक्शन है। लूप में हम कंप्यूटर को रोकने के लिए रुक जाते हैं। इसके साथ संकलित है:

as -o kernel.o -c kernel.asm

अब हम सी में प्रोग्रामिंग दर्ज करने जा रहे हैं। आप सोचेंगे कि अब सब कुछ केक का एक टुकड़ा है, हम एक डालते हैं printf en मुख्य और यह बात है, हमने यह किया है।

खैर नहीं, तब से printf y मुख्य वे कार्य हैं जो ऑपरेटिंग सिस्टम द्वारा परिभाषित किए गए हैं, लेकिन हम उन्हें बना रहे हैं! हम केवल उन कार्यों का उपयोग कर सकते हैं जिन्हें हम स्वयं परिभाषित करते हैं।

बाद के अध्यायों में मैं अपनी खुद की सी लाइब्रेरी (ग्लिबैक, बायोनिक, न्यूलिबिक) को कैसे रखा जाए, इस बारे में बात करूंगा। हमने बात की है कि हम टेक्स्ट को स्क्रीन पर रखना चाहते हैं, अच्छी तरह से हम देखेंगे कि हम इसे कैसे करते हैं।

दो विकल्प हैं, एक को कॉल करना है BIOS और दूसरा स्क्रीन मेमोरी को सीधे प्रबंधित करना है। हम बाद को करने जा रहे हैं क्योंकि यह सी से स्पष्ट है और यह हमें संरक्षित मोड में प्रवेश करने पर भी करने की अनुमति देगा।

हम निम्नलिखित सामग्री के साथ NextKernel_Main.c नामक एक फाइल बनाते हैं:

int NextKernel_Main()
{
char *str = "NextDivel says Hello World", *ch;
unsigned short *vidmem = (unsigned short*) 0xb8000;
unsigned i;
for (ch = str, i = 0; *ch; ch++, i++)
vidmem[i] = (unsigned char) *ch | 0x0700;
return 0;
}

इससे हम सीधे मेमोरी में हेरफेर करते हैं वीजीए और चरित्र द्वारा चरित्र हम इसे लिख रहे हैं। हम stdlib को अक्षम करके संकलित करते हैं:
gcc -o NextKernel_Main.o -c NextKernel_Main.c -nostdlib -fPIC -ffreestanding

यदि आपने इसे अभी तक बना लिया है, तो आप अपने ब्रांड-नए ऑपरेटिंग सिस्टम को आजमाना चाहेंगे, लेकिन हम अभी तक काम नहीं कर रहे हैं। हमें एक छोटी फ़ाइल की आवश्यकता है जो कंपाइलर को बताए कि फ़ाइल में प्रत्येक सेक्शन को कहाँ छोड़ना है। यह एक लिंकर स्क्रिप्ट के साथ किया जाता है। हम लिंक बनाते हैं।

ENTRY(start)
SECTIONS
{
. = 0x00100000;
.multiboot_header :
{
*(.multiboot_header)
}
.text :
{
code = .; _code = .; __code = .;
*(.text)
. = ALIGN(4096);
}
.data :
{
data = .; _data = .; __data = .;
*(.data)
*(.rodata)
. = ALIGN(4096);
}
.bss :
{
bss = .; _bss = .; __bss = .;
*(.bss)
. = ALIGN(4096);
}
end = .; _end = .; __end = .;
}


इसके साथ हम प्रत्येक खंड की स्थिति और प्रवेश बिंदु को परिभाषित करते हैं, शुरू करते हैं, जिसे हमने kernel.asm में परिभाषित किया है। अब हम इस सभी मनगढ़ंत घटना को एकजुट कर सकते हैं:

gcc -o START.ELF kernel.o NextKernel_Main.o -Tlink.ld -nostdlib -fPIC -ffreestanding -lgcc

अब हम अपने फोल्डर के अंदर START.ELF / को कॉपी करते हैं जो हमारे ऑपरेटिंग सिस्टम के रूट को सिमुलेट करता है। हम कंसोल के साथ अपने नए ऑपरेटिंग सिस्टम के रूट फ़ोल्डर में जाते हैं और सत्यापित करते हैं कि दो फाइलें हैं: एक /boot/grub/grub.cfg और दूसरा /next/START.ELF।

हम ऊपरी निर्देशिका में जाते हैं और GRUB नामक आईएसओ निर्माण उपयोगिता कहते हैं ग्रब-मर्क्रेस्क्यू

grub-mkrescue -o nextdivel.iso nextroot

एक बार जब हम यह कर लेते हैं तो हमारे पास ए आईएसओ। यह आईएसओ कंप्यूटर पर खोला जा सकता है x86 (64 बिट भी) और वर्चुअल मशीन। इसका परीक्षण करने के लिए, मैं उपयोग करने जा रहा हूं QEMU। हम फोन करते हैं QEMU कमांड लाइन से:

qemu-system-i386 nextdivel.iso

शुरू होगा सीबीआईओएस और बाद में हमारे पास होगा GRUB। बाद में अगर सब कुछ सही रहा तो हम अपना मुहावरा देखेंगे।
आप सोचेंगे कि यह मुश्किल है, मैं आपको जवाब देता हूं, हां यह है।

वास्तव में एक ऑपरेटिंग सिस्टम बनाना मुश्किल है और यह कि यह यहाँ कुछ भी उपयोगी नहीं है। भविष्य के अध्यायों में हम देखेंगे कि स्क्रीन पर रंगों को कैसे संभालना है, मेमोरी को आरक्षित करना है और यदि मैं कर सकता हूं, तो कीबोर्ड से डेटा कैसे प्राप्त करें।

अगर कोई यहाँ सब कुछ कॉपी नहीं करना चाहता है, तो मेरे पास एक रिपॉजिटरी है GitHub (अधिक विस्तृत) ऑपरेटिंग सिस्टम के साथ अगलाडिवेल। अगर आप संकलन करना चाहते हैं अगलाडिवेल आपको बस गिट और सेमीकिट करना होगा:

git clone https://github.com/AdrianArroyoCalle/next-divel
cd next-divel
mkdir build && cd build
cmake ..
make
make DESTDIR=next install
chmod +x iso.sh
./iso.sh
qemu-system-i386 nextdivel.iso


यदि आप एक ऑपरेटिंग सिस्टम बनाने के लिए समय और इच्छा रखते हैं तो मैं आपको NextDivel पर सहयोग करने के लिए प्रोत्साहित करता हूं। शायद लिनक्स से भी बेहतर ... समय बताएगा।