લિનુસ ટોરવાલ્ડ્સનું અનુકરણ: શરૂઆતથી તમારી operatingપરેટિંગ સિસ્ટમ બનાવો (I)

સૌ પ્રથમ, ટિપ્પણી કરો કે આ મારો પ્રથમ લેખ છે અને મને આશા છે કે તમને તે બધા ગમશે.

આ શ્રેણીમાં આપણે અનુકરણ કરવા જઈ રહ્યા છીએ લીનસ ટોરવાલ્ડ્સ, આપણે 0 થી આપણી systemપરેટિંગ સિસ્ટમ બનાવીશું. આ પ્રથમ એપિસોડમાં આપણે બૂટ જોવાના છીએ અને આપણે આપણી કર્નલમાંથી સ્ક્રીન પર એક ટેક્સ્ટ મૂકીશું.

મારા કિસ્સામાં operatingપરેટિંગ સિસ્ટમ કહેવામાં આવે છે NextDivel. Decisionપરેટિંગ સિસ્ટમનો વિચાર કરતાની સાથે જ આપણે પહેલા નિર્ણય લેવો જોઈએ કે બૂટલોડર શું હશે?

અહીં ઘણા બધા પ્રકારો છે, અને આપણે એક જાતે બનાવી શકીએ છીએ; જો કે આ ટ્યુટોરીયલમાં હું ઉપયોગ કરીશ ગ્રુબ, કારણ કે મોટાભાગના તેના વિશે વધુ કે ઓછામાં કંઇક જાણે છે. અમે એક ફોલ્ડર બનાવીએ છીએ જે આપણી operatingપરેટિંગ સિસ્ટમનું મૂળ હશે અને ત્યાં અમે / બૂટ / ગ્રબ ફોલ્ડર બનાવીએ છીએ

mkdir nextroot && cd nextroot

mkdir -p boot/grub

ત્યાં આપણે નીચે પ્રમાણે grub.cfg ફાઇલ બનાવીએ છીએ:

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


આ ફાઇલમાં આપણે જોયું છે કે કેવી રીતે ગ્રુબ અમારી કર્નલ, આ કિસ્સામાં /next/START.ELF માં લોડ કરશે. હવે આપણે આપણી કર્નલ બનાવવી જ જોઇએ.

આ માટે અમને જરૂર પડશે જીસીસી y જીએએસ (પ્રોજેક્ટ એસેમ્બલર જીએનયુ, સામાન્ય રીતે જીસીસી સાથે આવે છે). તેથી આપણે કર્નલ બનાવવા જઈ રહ્યા છીએ.

આપણે પહેલા કર્નલ.એએસએમ નામની ફાઇલ બનાવીએ છીએ. આ ફાઇલમાં અમારી કર્નલનો પ્રારંભિક બિંદુ હશે અને તે મલ્ટિબૂટને પણ વ્યાખ્યાયિત કરશે (કેટલાક બૂટલોડરોની સુવિધા જેમ કે ગ્રુબ). કર્નલ.આસ્મની સામગ્રી આ હશે:

.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

મલ્ટિબૂટથી સંબંધિત દરેક વસ્તુ ફક્ત સ્પષ્ટીકરણને અનુસરવા માટે છે કંઇ વધુ નહીં. બધું શરૂઆતમાં શરૂ થશે, તે મલ્ટિબૂટ_એન્ટ્રીને ક willલ કરશે, આપણે મલ્ટિબૂટ હેડરને પ્રથમ 4 કેમાં વ્યાખ્યાયિત કરીશું અને અમે તેને (મોવલ સાથે) મૂકીશું.

પછીથી આપણે નેક્સ્ટકર્નલ_માઈન કહીએ છીએ જે આપણું કર્નલ સી ફંક્શન છે. લૂપમાં આપણે કમ્પ્યુટરને રોકવા માટે અટકીએ છીએ. આ આ સાથે સંકલન કરે છે:

as -o kernel.o -c kernel.asm

હવે અમે સીમાં પ્રોગ્રામિંગ દાખલ કરવા જઈ રહ્યા છીએ તમને લાગે છે કે હવે બધું કેકનો ટુકડો છે, અમે એક મૂકીએ છીએ printf en મુખ્ય અને તે છે, અમે તે પૂર્ણ કર્યું છે.

વેલ ના, થી printf y મુખ્ય તે કાર્ય કરે છે જે theપરેટિંગ સિસ્ટમ દ્વારા નિર્ધારિત કરવામાં આવે છે, પરંતુ અમે તેને બનાવી રહ્યા છીએ! આપણે ફક્ત એવા કાર્યોનો ઉપયોગ કરી શકીએ છીએ જે આપણે આપણી જાતને વ્યાખ્યાયિત કરીએ છીએ.

પછીના પ્રકરણોમાં હું આપણી પોતાની સી લાઇબ્રેરી (ગ્લિબીસી, બાયોનિક, ન્યુલિબસી) કેવી રીતે મૂકવું તે વિશે વાત કરીશ, પરંતુ સમય સમય પર. અમે વાત કરી છે કે અમે ટેક્સ્ટને સ્ક્રીન પર મૂકવા માંગીએ છીએ, આપણે તે કેવી રીતે કરીએ છીએ તે સારી રીતે જોશું.

ત્યાં બે વિકલ્પો છે, એકને ક callલ કરવો BIOS અને બીજું સીધી સ્ક્રીન મેમરીનું સંચાલન કરવું છે. અમે પછીનું કામ કરીશું કારણ કે તે સીથી સ્પષ્ટ છે અને જ્યારે આપણે સુરક્ષિત મોડમાં પ્રવેશ કરીએ છીએ ત્યારે તે આપણને તે કરવાની પણ મંજૂરી આપશે.

અમે નીચેની સામગ્રી સાથે નેક્સ્ટર્નલ_મેઇન.સી. નામની ફાઇલ બનાવીએ છીએ:

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

જો તમે તેને હજી સુધી બનાવ્યું છે, તો તમે હમણાં તમારી નવી operatingપરેટિંગ સિસ્ટમ અજમાવવા માગો છો, પરંતુ અમે હજી સુધી પૂર્ણ કર્યું નથી. અમને એક નાની ફાઇલની જરૂર છે જે કમ્પાઇલરને કહે છે કે ફાઇલમાં દરેક વિભાગ ક્યાં મૂકવો. આ કડી સ્ક્રિપ્ટ સાથે કરવામાં આવે છે. અમે 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 = .;
}


આ સાથે આપણે દરેક વિભાગની સ્થિતિ અને પ્રવેશ બિંદુ વ્યાખ્યાયિત કરીએ છીએ, શરૂ કરો, કે જે આપણે કર્નલ.એએસએમમાં ​​વ્યાખ્યાયિત કર્યું છે. હવે આપણે આ બધા ઉશ્કેરાટને એક કરી શકીએ:

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

હવે આપણે આપણા ફોલ્ડરની અંદર START.ELF ની / આગળની નકલ કરીએ છીએ જે આપણી operatingપરેટિંગ સિસ્ટમના મૂળનું અનુકરણ કરે છે. અમે કન્સોલ સાથે અમારી નવી operatingપરેટિંગ સિસ્ટમના રૂટ ફોલ્ડર પર જઈએ છીએ અને ચકાસીએ છીએ કે ત્યાં બે ફાઇલો છે: એક /boot/grub/grub.cfg અને બીજી /next/START.ELF.

અમે ઉપલા ડિરેક્ટરીમાં જઈએ છીએ અને GRUB તરીકે ઓળખાતી ISO રચના યુટિલિટીને ક callલ કરીએ છીએ ગ્રબ- mkrescue

grub-mkrescue -o nextdivel.iso nextroot

એકવાર આપણે આ કરી લીધા પછી અમારી પાસે એક હશે ISO. આ આઇએસઓ કમ્પ્યુટર પર ખોલી શકાય છે x86 (64 બિટ્સ પણ) અને વર્ચુઅલ મશીનો. તેની ચકાસણી કરવા માટે, હું વાપરવા જઈ રહ્યો છું QEMU. અમે બોલાવીએ છીએ QEMU આદેશ વાક્યમાંથી:

qemu-system-i386 nextdivel.iso

શરૂ કરશે સીબીઆઈઓએસ અને પછીથી આપણી પાસે હશે ગ્રુબ. પછી જો બધું બરાબર હોય તો આપણે આપણું વાક્ય જોશું.
તમે વિચારશો કે આ મુશ્કેલ છે, હું જવાબ આપું છું, હા તે છે.

ખરેખર operatingપરેટિંગ સિસ્ટમ બનાવવી મુશ્કેલ છે અને આ અહીં કંઈપણ ઉપયોગી કરતું નથી. ભવિષ્યના પ્રકરણોમાં આપણે જોઈશું કે સ્ક્રીન પર રંગોને કેવી રીતે હેન્ડલ કરવું, મેમરીને રિઝર્વ કરવું અને જો હું કરી શકું તો, કીબોર્ડમાંથી ડેટા કેવી રીતે મેળવી શકું.

જો કોઈ અહીં બધું ક copyપિ કરવા માંગતા નથી, તો મારી પાસે રિપોઝિટરી છે GitHub moreપરેટિંગ સિસ્ટમ સાથે (વધુ વિસ્તૃત) NextDivel. જો તમારે કમ્પાઇલ કરવું હોય તો NextDivel તમારી પાસે હમણાં જ ગિટ અને કmaમક છે:

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


જો તમને operatingપરેટિંગ સિસ્ટમ બનાવવાની સમય અને ઇચ્છા હોય તો હું તમને નેક્સ્ટડેવલ પર સહયોગ કરવા પ્રોત્સાહિત કરું છું. કદાચ લિનક્સથી પણ શ્રેષ્ઠ ... સમય કહેશે.