ಎಮ್ಯುಲೇಟಿಂಗ್ ಲಿನಸ್ ಟೊರ್ವಾಲ್ಡ್ಸ್: 0 (ವಿ) ನಿಂದ ನಿಮ್ಮ ಸ್ವಂತ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ರಚಿಸಿ

ಈ ಐದನೇ ಕಂತಿನಲ್ಲಿ ನಾವು ಸಿದ್ಧಾಂತ ಮತ್ತು ಬಳಕೆಯಲ್ಲಿರುವ ಜಿಡಿಟಿಗೆ ಹೋಲುವ ಕೋಷ್ಟಕವನ್ನು ನೋಡುತ್ತೇವೆ, ನಾವು ಐಡಿಟಿಯನ್ನು ಉಲ್ಲೇಖಿಸುತ್ತೇವೆ. ಐಡಿಟಿ ಎಂದರೆ ವಿವರಣೆ ಕೋಷ್ಟಕವನ್ನು ಅಡ್ಡಿಪಡಿಸುತ್ತದೆ y ಎನ್ನುವುದು ಸಂಭವಿಸುವ ಅಡೆತಡೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಬಳಸುವ ಟೇಬಲ್ ಆಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಯಾರಾದರೂ 0 ರಿಂದ ವಿಭಾಗವನ್ನು ಮಾಡುತ್ತಾರೆ, ಸಂಸ್ಕರಣೆಯ ಉಸ್ತುವಾರಿ ಕಾರ್ಯವನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ. ಈ ಕಾರ್ಯಗಳು ಐಎಸ್ಆರ್ (ಸೇವಾ ದಿನಚರಿಗಳನ್ನು ಅಡ್ಡಿಪಡಿಸಿ). ಆದ್ದರಿಂದ ನಾವು IDT ಅನ್ನು ರಚಿಸೋಣ ಮತ್ತು ಕೆಲವು ISR ಅನ್ನು ಸೇರಿಸೋಣ.

ಮೊದಲು ನಾವು IDT ಗೆ ಅನುಗುಣವಾದ ರಚನೆಗಳನ್ನು ಘೋಷಿಸಲಿದ್ದೇವೆ:

struct Entry{
uint16_t base_low;
uint16_t sel;
uint8_t always0;
uint8_t flags;
uint16_t base_high;
} __attribute__((packed));
struct Ptr{
uint16_t limit;
uint32_t base;
} __attribute__((packed));


ನೀವು ಅದನ್ನು ಜಿಡಿಟಿಯೊಂದಿಗೆ ಹೋಲಿಸಿದರೆ ನೋಡಬಹುದಾದಂತೆ, ಪಿಟಿಆರ್ ರಚನೆಯು ಒಂದೇ ಆಗಿರುತ್ತದೆ ಮತ್ತು ಪ್ರವೇಶವು ಸಾಕಷ್ಟು ಹೋಲುತ್ತದೆ. ಆದ್ದರಿಂದ ಎಂಟ್ರಿ (ಸೆಟ್‌ಗೇಟ್) ಮತ್ತು ಸ್ಥಾಪಿಸುವ (ಸ್ಥಾಪನೆ) ಕಾರ್ಯಗಳು ಬಹಳ ಹೋಲುತ್ತವೆ.

void ND::IDT::SetGate(uint8_t num,uint32_t base,uint16_t sel, uint8_t flags)
{
idt[num].base_low=(base & 0xFFFF);
idt[num].base_high=(base >> 16) & 0xFFFF;
idt[num].sel=sel;
idt[num].always0=0;
idt[num].flags=flags;
}


ಸ್ಥಾಪಿಸಿ:

idtptr.limit=(sizeof(struct ND::IDT::Entry)*256)-1;
idtptr.base=(uint32_t)&idt;
ND::Memory::Set(&idt,0,sizeof(struct ND::IDT::Entry)*256);
ND::IDT::Flush();

ನಾವು ನೋಡಿದರೆ, ಇನ್ಸ್ಟಾಲ್ ಕಾರ್ಯವು ಇತರ ಪೋಸ್ಟ್ನಲ್ಲಿ ನಾವು ಘೋಷಿಸಿದ ND :: ಮೆಮೊರಿ :: ಸೆಟ್ ಕಾರ್ಯವನ್ನು ಬಳಸುತ್ತದೆ ಎಂದು ನೋಡುತ್ತೇವೆ. ಸೆಟ್‌ಗೇಟ್‌ಗೆ ನಾವು ಇನ್ನೂ ಯಾವುದೇ ಕರೆಗಳನ್ನು ಮಾಡದಿರುವುದು ಹೇಗೆ ಎಂದು ನಾವು ನೋಡಬಹುದು ಮತ್ತು ನಾವು ND :: IDT :: ಫ್ಲಶ್ ಎಂದು ಕರೆಯುತ್ತೇವೆ, ಈ ಕಾರ್ಯಕ್ಕಾಗಿ ನಾವು ಮತ್ತೆ asm ಬಾಷ್ಪಶೀಲ ಹೇಳಿಕೆಯನ್ನು ಬಳಸುತ್ತೇವೆ:

asm volatile("lidtl (idtptr)");


ಎಲ್ಲವೂ ಸರಿಯಾಗಿ ನಡೆದರೆ ಮತ್ತು ನಾವು ಸೌಂದರ್ಯದ ವ್ಯವಸ್ಥೆಯನ್ನು ಮಾಡಿದರೆ ಅದು ಹೀಗಿರಬೇಕು:

ಸರಿ, ಈಗ ನಾವು ಐಡಿಟಿಯನ್ನು ಅಡಚಣೆಗಳಿಂದ ತುಂಬಲು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ. ಇಲ್ಲಿ ನಾನು ಒಂದನ್ನು ಮಾತ್ರ ರಚಿಸಲಿದ್ದೇನೆ ಆದರೆ ಉಳಿದವು ಒಂದೇ ಆಗಿರುತ್ತದೆ. ನಾನು ಶೂನ್ಯ ವಿರಾಮದ ಮೂಲಕ ವಿಭಜನೆಯನ್ನು ಮಾಡಲಿದ್ದೇನೆ. ಗಣಿತದಲ್ಲಿ ನಿಮಗೆ ತಿಳಿದಿರುವಂತೆ, ಒಂದು ಸಂಖ್ಯೆಯನ್ನು 0 ರಿಂದ ಭಾಗಿಸಲಾಗುವುದಿಲ್ಲ. ಇದು ಪ್ರೊಸೆಸರ್‌ನಲ್ಲಿ ಸಂಭವಿಸಿದಲ್ಲಿ, ಅದನ್ನು ಮುಂದುವರಿಸಲು ಸಾಧ್ಯವಾಗದ ಕಾರಣ ಒಂದು ವಿನಾಯಿತಿ ಉತ್ಪತ್ತಿಯಾಗುತ್ತದೆ. IDT ಯಲ್ಲಿ ಪಟ್ಟಿಯಲ್ಲಿನ ಮೊದಲ ಅಡಚಣೆ (0) ಈ ಈವೆಂಟ್‌ಗೆ ಅನುರೂಪವಾಗಿದೆ.

IDT ಯ ಸ್ಥಾಪನೆ ಕಾರ್ಯದೊಳಗಿನ ಮೆಮೊರಿ ಸೆಟ್ಟಿಂಗ್ ಮತ್ತು ಫ್ಲಶ್ ನಡುವೆ ನಾವು ಇದನ್ನು ಸೇರಿಸುತ್ತೇವೆ:

ND::IDT::SetGate(0,(unsigned)ND::ISR::ISR1,0x08,0x8E);

ಕಾಲ್ಬ್ಯಾಕ್ ಕಾರ್ಯವು ಎನ್ಡಿ :: ಐಎಸ್ಆರ್ :: ಐಎಸ್ಆರ್ 1 ಆಗಿರುತ್ತದೆ, ಆದರೆ ಇದು ಎಎಸ್ಎಂ ಅನ್ನು ನಾವು ಬಳಸಲೇಬೇಕು:

void ND::ISR::ISR1()
{
asm volatile(
"cli \n"
"pushl 0 \n"
"pushl 0 \n"
"jmp ND_ISR_Common \n"
);
}


ನಾವು ND_ISR_Common ಅನ್ನು C ಭಾಷೆಯಲ್ಲಿ ಒಂದು ಕಾರ್ಯವೆಂದು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ. ಫೈಲ್‌ಗಳನ್ನು ಉಳಿಸಲು ಮತ್ತು ಓದಲು ಸುಧಾರಿಸಲು ನಾವು ಬಾಹ್ಯ "C" ಅನ್ನು ಬಳಸಬಹುದು}}:

extern "C"
void ND_ISR_Common()
{
asm volatile(
"pusha \n"
"push %ds \n"
"push %es \n"
"push %fs \n"
"push %gs \n"
"movw $0x10, %ax \n"
"movw %ax, %ds \n"
"movw %ax, %es \n"
"movw %ax, %fs \n"
"movw %ax, %gs \n"
"movl %esp, %eax \n"
"push %eax \n"
"movl $ND_ISR_Handler, %eax \n"
"call *%eax \n"
"popl %eax \n"
"popl %ds \n"
"popl %es \n"
"popl %fs \n"
"popl %gs \n"
"popa \n"
"addl 8, %esp \n"
"iret \n"
);
}


ಎಎಸ್‌ಎಂನಲ್ಲಿನ ಈ ಕೋಡ್ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸ್ವಲ್ಪ ಕಷ್ಟವಾಗಬಹುದು ಆದರೆ ಇದಕ್ಕೆ ಕಾರಣ ನಾವು ಅಡ್ಡಿಪಡಿಸುವಿಕೆಯಿಂದ ಉತ್ಪತ್ತಿಯಾಗುವ ಡೇಟಾವನ್ನು ಪ್ರವೇಶಿಸಲು ಸಿ ಯಲ್ಲಿ ಒಂದು ರಚನೆಯನ್ನು ಘೋಷಿಸಲಿದ್ದೇವೆ. ನಿಸ್ಸಂಶಯವಾಗಿ, ನಿಮಗೆ ಅದು ಬೇಡವಾದರೆ, ನೀವು ಕರ್ನಲ್ ಪ್ಯಾನಿಕ್ ಅನ್ನು ND :: ISR :: ISR1 ಅಥವಾ ಅಂತಹ ಯಾವುದನ್ನಾದರೂ ಕರೆಯಬಹುದು. ರಚನೆಯು ಅಂತಹ ಆಕಾರವನ್ನು ಹೊಂದಿದೆ:

struct regs{
uint32_t ds;
uint32_t edi, esi, ebp, esp, ebx, edx, ecx, eax;
uint32_t int_no, err_code;
uint32_t eip, cs, eflags, useresp, ss;
};

ಮತ್ತು ಅಂತಿಮವಾಗಿ ನಾವು ND_ISR_Handler ಕಾರ್ಯವನ್ನು (ಸಿ ಲಿಂಕ್‌ನೊಂದಿಗೆ ಸಹ) ಮಾಡುತ್ತೇವೆ, ಇದರಲ್ಲಿ ನಾವು ದೋಷಗಳ ಪಟ್ಟಿಯಲ್ಲಿರುವ ಪ್ರಕಾರ ಕರ್ನಲ್ ಪ್ಯಾನಿಕ್ ಮತ್ತು ದೋಷದ ಸಣ್ಣ ವಿವರಣೆಯನ್ನು ತೋರಿಸುತ್ತೇವೆ.

extern "C"
void ND_ISR_Handler(struct regs *r)
{
if(r->int_no < 32) { ND::Panic::Show(exception_messages[r->int_no]);
for(;;);
}
}


ಒಳ್ಳೆಯದು ಮತ್ತು ಇದರೊಂದಿಗೆ ನಾವು ಈಗಾಗಲೇ ಈ ಅಡಚಣೆಯನ್ನು ನಿಭಾಯಿಸಲು ಸಮರ್ಥರಾಗಿದ್ದೇವೆ. ನಿಯತಾಂಕಗಳನ್ನು ಹಿಂತಿರುಗಿಸುವ ಕೆಲವು ಇವೆ ಮತ್ತು ಅದನ್ನು ಪಡೆಯಲು ನಾವು ರೆಗ್ ರಚನೆಯನ್ನು ಬಳಸುತ್ತೇವೆ ಎಂಬುದನ್ನು ಹೊರತುಪಡಿಸಿ ಉಳಿದ ಅಡೆತಡೆಗಳೊಂದಿಗೆ ಇದು ಹೋಲುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಇದು ನಿಜವಾಗಿಯೂ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆಯೇ ಎಂದು ನಮಗೆ ಹೇಗೆ ಗೊತ್ತು ಎಂದು ನಿಮಗೆ ಆಶ್ಚರ್ಯವಾಗಬಹುದು. ಇದು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆಯೇ ಎಂದು ಪರೀಕ್ಷಿಸಲು ನಾವು ND :: IDT :: ನಂತರ ಸ್ಥಾಪಿಸಿ () ನಂತರ ಸರಳ ರೇಖೆಯನ್ನು ಪರಿಚಯಿಸಲಿದ್ದೇವೆ.

int sum=10/0;

ನಾವು ಕಂಪೈಲ್ ಮಾಡಿದರೆ ಅದು ನಮಗೆ ಎಚ್ಚರಿಕೆ ನೀಡುತ್ತದೆ ಮತ್ತು ನಾವು ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ ನಮಗೆ ಉತ್ತಮ ಪರದೆಯಾಗುತ್ತದೆ:

ಮತ್ತು ಈ ಪೋಸ್ಟ್ ಕೊನೆಗೊಳ್ಳುವುದರೊಂದಿಗೆ, ಇದು ಅತ್ಯಂತ ವಿಸ್ತಾರವಾದ ಆದರೆ ಸಾಕಷ್ಟು ಕ್ರಿಯಾತ್ಮಕವಾಗಿದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ.