Paggaya sa Linus Torvalds: Lumikha ng iyong sariling operating system mula sa simula (IV)

Maligayang pagdating pabalik sa seryeng ito ng mga post na pinamagatang "Emulate Linus Torvalds". Ngayon makikita natin ang GDT. Una dapat nating makita kung ano ang GDT. Ayon sa Wikipedia:

Ang Talaan ng Pandaigdigang Deskriptor or GDT ay isang istraktura ng data na ginamit ng Intel x86-proseso ng pamilya na nagsisimula sa 80286 upang tukuyin ang mga katangian ng iba't ibang mga lugar ng memorya na ginamit sa panahon ng pagpapatupad ng programa, kasama ang base address, ang laki at mga pribilehiyo sa pag-access tulad ng pagiging maisagawa at kakayahang magsulat.

Ang nagsalin ay magiging isang Global Descriptor Table, isang istraktura ng data na ginamit sa mga prosesor ng Intel x86 mula noong 80286 upang tukuyin ang mga katangian ng iba't ibang mga lugar ng memorya na ginamit sa pagpapatupad ng programa.

Sa madaling salita, kung gumagamit kami ng isang Intel x86 processor, dapat naming tukuyin ang isang GDT para sa wastong paggamit ng memorya. Hindi kami gagawa ng maraming komplikasyon at tutukuyin namin ang 3 mga entry sa talahanayan:

  • Isang entry na NULL, kinakailangan para sa lahat ng mga talahanayan.
  • Isang tiket para sa seksyon data, gagamitin namin ang maximum, na sa 32 bits ay 4 GB.
  • Isang tiket para sa seksyon code, gagamitin namin ang maximum, na sa 32 bits ay 4 GB.

Tulad ng nakikita mo, ang data at code ay gagamit ng parehong puwang. Ok, ngayon ipapatupad namin ito. Para sa mga ito gagamitin namin ang dalawang mga istraktura, ang una ay sisingilin ng naglalaman ng isang pointer sa totoong data ng aming GDT. At ang pangalawa ay magiging isang array kasama ang mga entry ng GDT. Tukuyin muna natin ang mga ito

struct Entry{
uint16_t limit_low;
uint16_t base_low;
uint8_t base_middle;
uint8_t access;
uint8_t granularity;
uint8_t base_high;
} __attribute__((packed));
struct Ptr{
uint16_t limit;
uint32_t base;
} __attribute__((packed));

Maaaring napansin mo ang isang usisero __attribut __ ((naka-pack)) sa dulo ng mga istraktura. Sinasabi nito sa GCC na huwag i-optimize ang mga istraktura dahil ang nais namin ay ipasa ang data tulad ng sa processor. Ngayon ay gagawa kami ng isang pag-andar upang mai-install ang GDT. Bago namin ideklara ang mga istraktura, ngayon ay sisimulan natin ang mga ito.

struct ND::GDT::Entry gdt[3];
struct ND::GDT::Ptr gp;
void ND::GDT::Install()
{
gp.limit=(sizeof(struct ND::GDT::Entry)*3)-1;
gp.base=(uint32_t)&gdt;
}

Sa gayon makakagawa kami upang maitayo ang pointer na pupunta sa aming 3-input table.

Kung nag-ipon ka ng paggamit ng 64 bits malamang na mabigo ito rito. Ito ay dahil ang mga payo sa mga 64-bit na sistema ay malinaw na 64-bit at gumagamit kami ng mga 32-bit na uri dito. Ang paggamit ng pagpipiliang -m32 ay maaaring makatulong sa ngayon
Ngayon tinutukoy namin ang isang karaniwang pag-andar upang ilagay ang data sa mga input

void ND::GDT::SetGate(int num, uint32_t base, uint32_t limit, uint8_t access,uint8_t gran)
{
gdt[num].base_low=(base & 0xFFFF);
gdt[num].base_middle=(base >> 16) & 0xFF;
gdt[num].base_high=(base >> 24) & 0xFF;
gdt[num].limit_low=(limit & 0xFFFF);
gdt[num].granularity=(limit >> 16) & 0x0F;
gdt[num].granularity |= (gran & 0xF0);
gdt[num].access=access;
}

At tinawag namin ito ng 3 beses mula sa pag-install na function

ND::GDT::SetGate(0,0,0,0,0); /* NULL segmente entry */
ND::GDT::SetGate(1,0,0xFFFFFFFF,0x9A,0xCF); /* 4 GiB for Code Segment */
ND::GDT::SetGate(2,0,0xFFFFFFFF,0x92,0xCF); /* 4 GiB for Data segment */

Sa wakas dapat nating sabihin sa processor na mayroon kaming GDT, upang mai-load ito, at sa aming kaso kapag naglo-load ang kernel ng GRUB, patungan ang GRUB GDT. Upang mai-load ang GDT mayroong isang tagubilin sa asm na tinatawag na lgdt (o lgdtl depende sa syntax), gagamitin namin ito.

asm volatile("lgdtl (gp)");
asm volatile(
"movw $0x10, %ax \n"
"movw %ax, %ds \n"
"movw %ax, %es \n"
"movw %ax, %fs \n"
"movw %ax, %gs \n"
"movw %ax, %ss \n"
"ljmp $0x08, $next \n"
"next: \n"
);

Kaya kapag natapos na natin ito ang aming system ay magkakaroon na ng GDT. Sa susunod na kabanata makikita natin ang IDT, isang talahanayan na halos kapareho sa GDT ngunit may mga pagkakagambala. Naglagay ako ng ilang mga mensahe ng katayuan at kumpirmasyon sa GDT kaya ganito ang ganito ang NextDivel:

SusunodDivel-GDT


Ang nilalaman ng artikulo ay sumusunod sa aming mga prinsipyo ng etika ng editoryal. Upang mag-ulat ng isang pag-click sa error dito.

5 na puna, iwan mo na ang iyo

Iwanan ang iyong puna

Ang iyong email address ay hindi nai-publish.

*

*

  1. Responsable para sa data: Miguel Ángel Gatón
  2. Layunin ng data: Kontrolin ang SPAM, pamamahala ng komento.
  3. Legitimation: Ang iyong pahintulot
  4. Komunikasyon ng data: Ang data ay hindi maiparating sa mga third party maliban sa ligal na obligasyon.
  5. Imbakan ng data: Ang database na naka-host ng Occentus Networks (EU)
  6. Mga Karapatan: Sa anumang oras maaari mong limitahan, mabawi at tanggalin ang iyong impormasyon.

  1.   saeron dijo

    Marahil ang isang 64-bit na istraktura ay mas angkop para sa mga oras na ito, isang pagkaantala upang ipagpatuloy ang paggamit ng 8086.

    1.    AdrianArroyoStreet dijo

      Naghahanap ako ng impormasyon sa GDT sa x86_64 at sa palagay ko sumusunod ito sa lumang modelo na may isang espesyal na watawat. Ginagamit pa rin ang isang 32-bit na address. Ngayon hindi ko alam eksakto kung paano ito gawin nang tama. Ang ilang mga link:
      http://wiki.osdev.org/Entering_Long_Mode_Directly
      http://f.osdev.org/viewtopic.php?f=1&t=16275

  2.   geronimo dijo

    Una sa lahat, napakahusay ng iyong mga naiambag, ngunit sa palagay ko dapat ang pamagat
    "Emulate Richard Stallman" o kahit papaano naiisip ko ,,,
    Regards

    1.    abimaelmartell dijo

      Nilikha ni Linus ang kernel ng Linux, nilikha ni Stallman ang GNU na siyang mga tool at utos ng Unix.

      Naaangkop ang pamagat dahil lumilikha ka ng isang nucleus.

      Pagbati!

  3.   Mapula dijo

    Maraming salamat sa pagsagot sa lahat ng aking mga katanungan at maging matiyaga, bilang isang assembler alam ko lamang ang mga pangunahing kaalaman at bilang isang C halos wala, ngunit gusto ko ito ng marami, ngayon medyo nalilito ako sa GDT, tingnan natin kung intindihin

    Ang GDT ay magkakaroon ng pandaigdigang 'mga tagapaglarawan' na maaaring palaging ma-access ng anumang programa, at ang mga tagapaglaraw na ito ay tumuturo sa seksyon kung saan isasagawa ang (programa)? o kung hindi man.

bool (totoo)