லினஸ் டொர்வால்ட்ஸைப் பின்பற்றுதல்: புதிதாக (I) இருந்து உங்கள் சொந்த இயக்க முறைமையை உருவாக்கவும்

முதலில், இது எனது முதல் கட்டுரை என்றும் நீங்கள் அனைவரும் விரும்புவீர்கள் என்று நம்புகிறேன் என்றும் கருத்து தெரிவிக்கவும்.

இந்த தொடரில் நாம் பின்பற்றப் போகிறோம் லினஸ் டோர்வால்ட்ஸ், எங்கள் இயக்க முறைமையை 0 இலிருந்து உருவாக்கப் போகிறோம். இந்த முதல் எபிசோடில் நாம் துவக்கத்தைப் பார்க்கப் போகிறோம், எங்கள் கர்னலில் இருந்து ஒரு உரையை திரையில் வைப்போம்.

என் விஷயத்தில் இயக்க முறைமை அழைக்கப்படுகிறது NextDivel. இயக்க முறைமையைக் கருத்தில் கொண்டவுடன் நாம் எடுக்க வேண்டிய முதல் முடிவு, துவக்க ஏற்றி என்னவாக இருக்கும்?

இங்கே பல வகைகள் உள்ளன, மேலும் ஒன்றை நாமே உருவாக்க முடியும்; இருப்பினும் இந்த டுடோரியலில் நான் பயன்படுத்தப் போகிறேன் GRUB ஐ, ஏனென்றால் பெரும்பாலானவர்கள் அவரைப் பற்றி அதிகமாகவோ அல்லது குறைவாகவோ அறிந்திருக்கிறார்கள். எங்கள் இயக்க முறைமையின் மூலமாக இருக்கும் ஒரு கோப்புறையை நாங்கள் உருவாக்குகிறோம், அங்கு / boot / 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 உடன் வருகிறது). எனவே நாம் கர்னலை உருவாக்கப் போகிறோம்.

நாம் முதலில் kernel.asm என்ற கோப்பை உருவாக்குகிறோம். இந்த கோப்பு எங்கள் கர்னலின் தொடக்க புள்ளியைக் கொண்டிருக்கும், மேலும் மல்டிபூட்டையும் வரையறுக்கும் (சில துவக்க ஏற்றிகளின் அம்சம் 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

மல்டிபூட் தொடர்பான அனைத்தும் விவரக்குறிப்பைப் பின்பற்றுவதே தவிர வேறொன்றுமில்லை. எல்லாமே தொடக்கத்தில் தொடங்கும், அது மல்டிபூட்_என்ட்ரி என்று அழைக்கும், முதல் 4 கேவில் மல்டிபூட் தலைப்பை வரையறுத்துள்ளோம், அதை (மோவ்லுடன்) வைப்போம்.

பின்னர் நாம் நெக்ஸ்ட் கர்னல்_மெயின் என்று அழைக்கிறோம், இது எங்கள் கர்னல் சி செயல்பாடு. சுழற்சியில் கணினியை நிறுத்த நிறுத்துகிறோம். இது இதனுடன் தொகுக்கிறது:

as -o kernel.o -c kernel.asm

இப்போது நாம் சி இல் நிரலாக்கத்தில் நுழையப் போகிறோம். இப்போது எல்லாம் ஒரு கேக் துண்டு என்று நீங்கள் நினைப்பீர்கள், நாங்கள் ஒரு வைட்டமின் en முக்கிய அது தான், நாங்கள் செய்துள்ளோம்.

சரி இல்லை, என்பதால் வைட்டமின் y முக்கிய இவை இயக்க முறைமையால் வரையறுக்கப்பட்ட செயல்பாடுகள், ஆனால் நாங்கள் அவற்றை உருவாக்குகிறோம்! நாம் நம்மை வரையறுக்கும் செயல்பாடுகளை மட்டுமே பயன்படுத்த முடியும்.

எங்கள் சொந்த சி நூலகத்தை (glibc, bionic, newlibc) எப்படி வைப்பது என்பது பற்றி பின்னர் அத்தியாயங்களில் பேசுவேன், ஆனால் அவ்வப்போது. திரையில் உரையை வைக்க விரும்புகிறோம் என்று விவாதித்தோம், அதை எவ்வாறு செய்வது என்று பார்ப்போம்.

இரண்டு விருப்பங்கள் உள்ளன, ஒன்று அழைக்க வேண்டும் பயாஸ் மற்றொன்று திரை நினைவகத்தை நேரடியாக நிர்வகிப்பது. பிந்தையதைச் செய்யப் போகிறோம், ஏனெனில் இது C இலிருந்து தெளிவாக உள்ளது, மேலும் இது பாதுகாக்கப்பட்ட பயன்முறையில் நுழையும்போது அதைச் செய்ய அனுமதிக்கும்.

பின்வரும் உள்ளடக்கத்துடன் 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

நீங்கள் இதை இதுவரை செய்திருந்தால், உங்கள் புதிய இயக்க முறைமையை இப்போது முயற்சிக்க விரும்புவீர்கள், ஆனால் நாங்கள் இன்னும் முடிக்கவில்லை. ஒவ்வொரு பகுதியையும் விட்டு வெளியேற வேண்டிய கோப்பில் கம்பைலரிடம் சொல்லும் ஒரு சிறிய கோப்பு எங்களுக்குத் தேவை. இது ஒரு இணைப்பான் ஸ்கிரிப்ட் மூலம் செய்யப்படுகிறது. நாங்கள் link.ld ஐ உருவாக்குகிறோம்:

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 மற்றும் மற்றொரு / அடுத்த / START.ELF.

நாங்கள் மேல் கோப்பகத்திற்குச் சென்று GRUB உடன் ஒரு ஐஎஸ்ஓ உருவாக்கும் பயன்பாட்டை அழைக்கிறோம் grub-mkrescue

grub-mkrescue -o nextdivel.iso nextroot

இதைச் செய்தவுடன் நமக்கு ஒரு ஐஎஸ்ஓ. இந்த ஐஎஸ்ஓ கணினிகளில் திறக்கப்படலாம் x86 (64 பிட்கள் கூட) மற்றும் மெய்நிகர் இயந்திரங்கள். அதைச் சோதிக்க, நான் பயன்படுத்தப் போகிறேன் QEMU. நாங்கள் அழைக்கிறோம் QEMU கட்டளை வரியிலிருந்து:

qemu-system-i386 nextdivel.iso

தொடங்கும் சீபியோஸ் பின்னர் நாம் பெறுவோம் GRUB ஐ. பின்னர் எல்லாம் சரியாக இருந்தால் எங்கள் சொற்றொடரைப் பார்ப்போம்.
இது கடினம் என்று நீங்கள் நினைப்பீர்கள், நான் பதில் சொல்கிறேன், ஆம்.

உண்மையில் ஒரு இயக்க முறைமையை உருவாக்குவது கடினம், இது இங்கே பயனுள்ள எதையும் செய்யாது. எதிர்கால அத்தியாயங்களில் திரையில் வண்ணங்களை எவ்வாறு கையாள்வது, நினைவகத்தை ஒதுக்குவது மற்றும் என்னால் முடிந்தால், விசைப்பலகையிலிருந்து தரவை எவ்வாறு பெறுவது என்று பார்ப்போம்.

யாராவது இங்கே எல்லாவற்றையும் நகலெடுக்க விரும்பவில்லை என்றால், என்னிடம் ஒரு களஞ்சியம் உள்ளது மகிழ்ச்சியா (மேலும் விரிவாக) இயக்க முறைமையுடன் NextDivel. நீங்கள் தொகுக்க விரும்பினால் NextDivel நீங்கள் கிட் மற்றும் செம்கே வைத்திருக்க வேண்டும்:

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


ஒரு இயக்க முறைமையை உருவாக்க உங்களுக்கு நேரமும் விருப்பமும் இருந்தால், நெக்ஸ்ட்டிவலில் ஒத்துழைக்க நான் உங்களை ஊக்குவிக்கிறேன். ஒருவேளை லினக்ஸை விட உயர்ந்தது ... நேரம் சொல்லும்.