इमुलेटिंग लिनस टोरवाल्ड्स: स्क्रॅचपासून आपली स्वतःची ऑपरेटिंग सिस्टम तयार करा (आय)

सर्व प्रथम, टिप्पणी द्या की हा माझा पहिला लेख आहे आणि मला आशा आहे की आपणा सर्वांना हे आवडेल.

या मालिकेत आपण अनुकरण करणार आहोत लिनस टोरवाल्ड्स0 पासून आपण आपली ऑपरेटिंग सिस्टम बनवणार आहोत. या पहिल्या भागात आपण बूट पाहणार आहोत आणि आम्ही कर्नलमधून स्क्रीनवर एक मजकूर ठेवू.

माझ्या बाबतीत ऑपरेटिंग सिस्टम म्हणतात नेक्स्टडिव्हल. ऑपरेटिंग सिस्टमचा विचार करताच आपण घेतलेला पहिला निर्णय म्हणजे बूटलोडर काय होणार आहे?

येथे अनेक रूपे आहेत आणि आपण स्वतः एक तयार करू शकतो; या ट्यूटोरियल मध्ये मी वापरणार आहे ग्रब, कारण बहुतेक त्याच्याबद्दल कमी-अधिक प्रमाणात माहित असतात. आम्ही एक फोल्डर तयार करतो जो आपल्या ऑपरेटिंग सिस्टमचे मूळ असेल आणि तेथे आम्ही / बूट / ग्रब फोल्डर तयार करतो

mkdir nextroot && cd nextroot

mkdir -p boot/grub

तेथे आम्ही खालीलप्रमाणे grub.cfg फाईल तयार करतो.

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


या फाईलमधे आपण कसे ते पाहिले आहे ग्रब या प्रकरणात /next/START.ELF मध्ये आमचे कर्नल लोड करेल. आता आपण आपले कर्नल तयार केले पाहिजे.

यासाठी आम्हाला आवश्यक असेल जीसीसी y जीएएस (प्रकल्प संयोजक GNU, सहसा जीसीसीसह येतो). तर आपण कर्नल तयार करणार आहोत.

प्रथम आपण 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

मल्टीबूटशी संबंधित सर्व काही केवळ तपशिलाचे अनुसरण करणे म्हणजे आणखी काहीही नाही. सर्व काही सुरूवात होईल, त्याला मल्टीबूट_एन्ट्री कॉल होईल, आम्ही पहिल्या 4 के मध्ये मल्टीबूट हेडर परिभाषित केले आहे आणि आम्ही ते (मूवलसह) ठेवू.

नंतर आम्ही नेक्स्टकर्नेल_मॅनला कॉल करू जे आमचे कर्नल सी फंक्शन आहे. लूपमध्ये आम्ही संगणक थांबविण्यासाठी थांबलो. हे यासह संकलित करते:

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;
}

याद्वारे आपण स्मृतीत थेट फेरफार करतो VGA आणि चारित्र्यानुसार आम्ही ते लिहित आहोत. आम्ही 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 = .;
}


याद्वारे आपण प्रत्येक विभाग आणि एंट्री पॉईंटची स्थिती परिभाषित करू. सुरूवात करा, की आपण कर्नल.एस्.एम. मध्ये परिभाषित केले आहे. आता आम्ही या सर्व कंकोचेशन एकत्र करू शकतो:

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

grub-mkrescue -o nextdivel.iso nextroot

एकदा आम्ही हे केल्यावर आमच्याकडे एक असेल ISO. हे आयएसओ संगणकावर उघडले जाऊ शकते x86 (64 बिट्स देखील) आणि व्हर्च्युअल मशीन्स. त्याची चाचणी घेण्यासाठी, मी वापरणार आहे QEMU. आम्ही कॉल करतो QEMU कमांड लाइन मधून:

qemu-system-i386 nextdivel.iso

सुरू होईल सीबीआयओएस आणि नंतर आपल्याकडे असेल ग्रब. नंतर जर सर्व काही ठीक असेल तर आपण आपला वाक्यांश पाहू.
आपण विचार कराल की हे अवघड आहे, मी उत्तर देतो, होय ते आहे.

खरोखर ऑपरेटिंग सिस्टम तयार करणे अवघड आहे आणि ही येथे काहीही उपयुक्त नाही. भविष्यातील अध्यायात आपण स्क्रीनवर रंग कसे हाताळायचे, मेमरी रिझर्व्ह करायची असल्यास आणि कीबोर्ड वरून डेटा कसा मिळवायचा ते पाहू.

जर एखाद्यास येथे सर्वकाही कॉपी करायचे नसेल तर माझ्याकडे एक रेपॉजिटरी आहे 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


ऑपरेटिंग सिस्टम तयार करण्याची वेळ आणि इच्छा असल्यास मी नेक्स्टडिव्हलवर सहयोग करण्यास प्रोत्साहित करतो. कदाचित लिनक्सपेक्षाही श्रेष्ठ ... वेळ सांगेल.