void idt_init()
{
memset(&idt_entries, 0, sizeof(idt_entries));
set_trap_gate( 0, isr0);
set_trap_gate( 1, isr1);
set_intr_gate( 2, isr2);
set_system_gate( 3, isr3);
set_system_gate( 4, isr4);
set_system_gate( 5, isr5);
set_intr_gate( 6, isr6 );
set_intr_gate( 7, isr7 );
set_intr_gate( 8, isr8 );
set_intr_gate( 9, isr9 );
set_intr_gate(10, isr10);
set_intr_gate(11, isr11);
set_intr_gate(12, isr12);
set_intr_gate(13, isr13);
set_intr_gate(14, isr14);
set_intr_gate(15, isr15);
set_intr_gate(16, isr16);
set_intr_gate(17, isr17);
set_intr_gate(18, isr18);
set_intr_gate(19, isr19);
set_intr_gate(32, isr32); // irq0
set_intr_gate(33, isr33);
set_intr_gate(34, isr34);
set_intr_gate(35, isr35);
set_intr_gate(36, isr36);
set_intr_gate(37, isr37);
set_intr_gate(38, isr38);
set_intr_gate(39, isr39);
set_intr_gate(40, isr40);
set_intr_gate(41, isr41);
set_intr_gate(42, isr42);
set_intr_gate(43, isr43);
set_intr_gate(44, isr44);
set_intr_gate(45, isr45);
set_intr_gate(46, isr46);
set_intr_gate(47, isr47);
idt_ptr.limit = sizeof(idt_entries) -1;
idt_ptr.base = (u64)idt_entries;
idt_flush(&idt_ptr);
}
void hd_init(void)
{
blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
set_trap_gate(0x2E,&hd_interrupt);
outb_p(inb_p(0x21)&0xfb,0x21);
outb(inb_p(0xA1)&0xbf,0xA1);
}
void hd_init(void)
{
blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
set_trap_gate(0x2E,&hd_interrupt);
outb_p(inb_p(0x21)&0xfb,0x21);
outb(inb_p(0xA1)&0xbf,0xA1);
timer_table[HD_TIMER].fn = hd_times_out;
}
void kernel_init(void)
{
/* call ioinit to initialize io package/possibly kernel_init */
ioinit();
/* call trap gate with correct parameters to initialize trap */
set_trap_gate(0x80, &syscall);
/* call main, ref to suggested steps in hw2 eventually ustart */
ustart();
return;
}
void hd_init(void)
{
int i;
for (i=0 ; i<NR_REQUEST ; i++) {
request[i].hd = -1;
request[i].next = NULL;
}
for (i=0 ; i<NR_HD ; i++) {
hd[i*5].start_sect = 0;
hd[i*5].nr_sects = hd_info[i].head*
hd_info[i].sect*hd_info[i].cyl;
}
set_trap_gate(0x2E,&hd_interrupt);
outb_p(inb_p(0x21)&0xfb,0x21);
outb(inb_p(0xA1)&0xbf,0xA1);
}
/// Initialize signal traps: register signals with handlers
void trap_init(void)
{
int i;
set_trap_gate(0,÷_error);
set_trap_gate(1,&debug);
set_trap_gate(2,&nmi);
set_system_gate(3,&int3); /* int3-5 can be called from all */
set_system_gate(4,&overflow);
set_system_gate(5,&bounds);
set_trap_gate(6,&invalid_op);
set_trap_gate(7,&device_not_available);
set_trap_gate(8,&double_fault);
set_trap_gate(9,&coprocessor_segment_overrun);
set_trap_gate(10,&invalid_TSS);
set_trap_gate(11,&segment_not_present);
set_trap_gate(12,&stack_segment);
set_trap_gate(13,&general_protection);
set_trap_gate(14,&page_fault);
set_trap_gate(15,&reserved);
set_trap_gate(16,&coprocessor_error);
for (i=17;i<48;i++)
set_trap_gate(i,&reserved);
set_trap_gate(45,&irq13);
outb_p(inb_p(0x21)&0xfb,0x21); // FIXME: what is this line doing?
outb(inb_p(0xA1)&0xdf,0xA1); // FIXME: what is this line doing?
set_trap_gate(39,¶llel_interrupt);
}
/* Check if MAGIC is valid and print the Multiboot information structure
pointed by ADDR. */
void
entry (unsigned long magic, unsigned long addr)
{
multiboot_info_t *mbi;
/* Clear the screen. */
clear();
uint32_t filestart;
/* Am I booted by a Multiboot-compliant boot loader? */
if (magic != MULTIBOOT_BOOTLOADER_MAGIC)
{
printf ("Invalid magic number: 0x%#x\n", (unsigned) magic);
return;
}
/* Set MBI to the address of the Multiboot information structure. */
mbi = (multiboot_info_t *) addr;
/* Print out the flags. */
printf ("flags = 0x%#x\n", (unsigned) mbi->flags);
/* Are mem_* valid? */
if (CHECK_FLAG (mbi->flags, 0))
printf ("mem_lower = %uKB, mem_upper = %uKB\n",
(unsigned) mbi->mem_lower, (unsigned) mbi->mem_upper);
/* Is boot_device valid? */
if (CHECK_FLAG (mbi->flags, 1))
printf ("boot_device = 0x%#x\n", (unsigned) mbi->boot_device);
/* Is the command line passed? */
if (CHECK_FLAG (mbi->flags, 2))
printf ("cmdline = %s\n", (char *) mbi->cmdline);
if (CHECK_FLAG (mbi->flags, 3)) {
int mod_count = 0;
int i;
module_t* mod = (module_t*)mbi->mods_addr;
while(mod_count < mbi->mods_count) {
printf("Module %d loaded at address: 0x%#x\n", mod_count, (unsigned int)mod->mod_start);
filestart = mod->mod_start;
printf("Module %d ends at address: 0x%#x\n", mod_count, (unsigned int)mod->mod_end);
printf("First few bytes of module:\n");
for(i = 0; i<16; i++) {
printf("0x%x ", *((char*)(mod->mod_start+i)));
}
printf("\n");
mod_count++;
}
}
/* Bits 4 and 5 are mutually exclusive! */
if (CHECK_FLAG (mbi->flags, 4) && CHECK_FLAG (mbi->flags, 5))
{
printf ("Both bits 4 and 5 are set.\n");
return;
}
/* Is the section header table of ELF valid? */
if (CHECK_FLAG (mbi->flags, 5))
{
elf_section_header_table_t *elf_sec = &(mbi->elf_sec);
printf ("elf_sec: num = %u, size = 0x%#x,"
" addr = 0x%#x, shndx = 0x%#x\n",
(unsigned) elf_sec->num, (unsigned) elf_sec->size,
(unsigned) elf_sec->addr, (unsigned) elf_sec->shndx);
}
/* Are mmap_* valid? */
if (CHECK_FLAG (mbi->flags, 6))
{
memory_map_t *mmap;
printf ("mmap_addr = 0x%#x, mmap_length = 0x%x\n",
(unsigned) mbi->mmap_addr, (unsigned) mbi->mmap_length);
for (mmap = (memory_map_t *) mbi->mmap_addr;
(unsigned long) mmap < mbi->mmap_addr + mbi->mmap_length;
mmap = (memory_map_t *) ((unsigned long) mmap
+ mmap->size + sizeof (mmap->size)))
printf (" size = 0x%x, base_addr = 0x%#x%#x\n"
" type = 0x%x, length = 0x%#x%#x\n",
(unsigned) mmap->size,
(unsigned) mmap->base_addr_high,
(unsigned) mmap->base_addr_low,
(unsigned) mmap->type,
(unsigned) mmap->length_high,
(unsigned) mmap->length_low);
}
/* Construct an LDT entry in the GDT */
{
seg_desc_t the_ldt_desc;
the_ldt_desc.granularity = 0;
the_ldt_desc.opsize = 1;
the_ldt_desc.reserved = 0;
the_ldt_desc.avail = 0;
the_ldt_desc.present = 1;
the_ldt_desc.dpl = 0x0;
the_ldt_desc.sys = 0;
the_ldt_desc.type = 0x2;
SET_LDT_PARAMS(the_ldt_desc, &ldt, ldt_size);
ldt_desc_ptr = the_ldt_desc;
lldt(KERNEL_LDT);
}
/* Construct a TSS entry in the GDT */
{
seg_desc_t the_tss_desc;
the_tss_desc.granularity = 0;
the_tss_desc.opsize = 0;
the_tss_desc.reserved = 0;
the_tss_desc.avail = 0;
the_tss_desc.seg_lim_19_16 = TSS_SIZE & 0x000F0000;
the_tss_desc.present = 1;
the_tss_desc.dpl = 0x0;
the_tss_desc.sys = 0;
the_tss_desc.type = 0x9;
the_tss_desc.seg_lim_15_00 = TSS_SIZE & 0x0000FFFF;
SET_TSS_PARAMS(the_tss_desc, &tss, tss_size);
tss_desc_ptr = the_tss_desc;
tss.ldt_segment_selector = KERNEL_LDT;
tss.ss0 = KERNEL_DS;
tss.esp0 = 0x800000;
ltr(KERNEL_TSS);
}
//Initialization of IDE
{
printf("Initilization of Idt table...");
set_trap_gate(0,divide_error);
set_trap_gate(1,debug);
set_intr_gate(2,nmi);
set_system_intr_gate(3,int3);
set_system_gate(4,overflow);
set_system_gate(5,bounds);
set_trap_gate(6,invalid_op);
set_trap_gate(7,device_not_available);
set_task_gate(8,31);
set_trap_gate(9,coprocessor_segment_overrun);
set_trap_gate(10,invalid_TSS);
set_trap_gate(11,segment_not_present);
set_trap_gate(12,stack_segment);
set_trap_gate(13,general_protection);
set_trap_gate(14,page_fault);//intr
set_trap_gate(16,coprocessor_error);
set_trap_gate(17,alignment_check);
set_trap_gate(18,machine_check);
set_trap_gate(19,simd_coprocessor_error);
set_system_gate(128,system_call);
set_intr_gate(32,irq0); //intr
set_intr_gate(33,irq1); //intr
set_intr_gate(34,0); //intr
set_intr_gate(40,irq8); //intr
//set_intr_gate(44,irq12); //intr
lidt(idt_desc_ptr);
printf("ok!\n");
}
// Init the PIC
i8259_init();
//Enable interrupts
enable_irq(1);
enable_irq(2);
open_rtc();
enable_irq(8);
enable_irq(12);
uint8_t file =0x00;
//Enable paging
printf("Enabling paging...\n");
paging();
printf("ok!\n");
//Restore interrupts
sti();
//Mounting file system
printf("Mounting filesystem...\n");
open_terminal(&file);
setstart(filestart);
printf("ok!\n");
//clear();
//Executing first program shell
uint8_t cmd[10]={"shell "};
#if debug_by_showing_dentries
test_dentries();
while(1);
#endif
test_system_call((int32_t)cmd, NULL, 0, 2);
asm volatile(".1: hlt; jmp .1;");
}
// 下面是异常(陷阱)中断程序初始化子程序。设置它们的中断调用门(中断向量),
// set_trap_gate()与set_system_gate()都使用了中断描述符表IDT中的陷阱门(Trap Gate),
// 它们之间的主要区别在于前者设置的特权级为0，后者是3。因此断点陷阱中断int13、溢出中断
// overflow和边界出错中断bounds可以由任何程序产生。
// 这两个函数均是嵌入式汇编宏程序(include/asm/system.h 36 39)
void trap_init(void)
{
int i;
set_trap_gate(0,÷_error); // 设置除操作出错的中断向量值。以下雷同。
set_trap_gate(1,&debug);
set_trap_gate(2,&nmi);
set_system_gate(3,&int3); /* int3-5 can be called from all */
set_system_gate(4,&overflow); /* int3-5 可以被所有程序执行 */
set_system_gate(5,&bounds);
set_trap_gate(6,&invalid_op);
set_trap_gate(7,&device_not_available);
set_trap_gate(8,&double_fault);
set_trap_gate(9,&coprocessor_segment_overrun);
set_trap_gate(10,&invalid_TSS);
set_trap_gate(11,&segment_not_present);
set_trap_gate(12,&stack_segment);
set_trap_gate(13,&general_protection);
set_trap_gate(14,&page_fault);
set_trap_gate(15,&reserved);
set_trap_gate(16,&coprocessor_error);
// 下面把int17-47 的陷阱门先均设置为reserved，以后各硬件初始化时会重新设置自己的陷阱门。
for (i=17;i<48;i++)
set_trap_gate(i,&reserved);
// 设置协处理器中断0x2d(45)陷阱门描述符，并允许其产生中断请求。设置并行口中断描述符。
set_trap_gate(45,&irq13);
outb_p(inb_p(0x21)&0xfb,0x21); // 允许8259A主芯片的IRQ2中断请求
outb(inb_p(0xA1)&0xdf,0xA1); // 允许8259A从芯片的IRQ13中断请求
set_trap_gate(39,¶llel_interrupt); // 设置并行口1的中断0x27陷阱门描述符
}
void init_trap()
{
int i;
init_8259A();
//soft interrupt
set_trap_gate(INT_VECTOR_DIVIDE,divide_error);
set_trap_gate(INT_VECTOR_DEBUG, single_step_exception);
set_trap_gate(INT_VECTOR_NMI, nmi);
set_system_gate(INT_VECTOR_BREAKPOINT, breakpoint_exception);
set_system_gate(INT_VECTOR_OVERFLOW, overflow);
set_system_gate(INT_VECTOR_BOUNDS, bounds_check);
set_trap_gate(INT_VECTOR_INVAL_OP, inval_opcode);
set_trap_gate(INT_VECTOR_COPROC_NOT, copr_not_available);
set_trap_gate(INT_VECTOR_DOUBLE_FAULT, double_fault);
set_trap_gate(INT_VECTOR_COPROC_SEG, copr_seg_overrun);
set_trap_gate(INT_VECTOR_INVAL_TSS, inval_tss);
set_trap_gate(INT_VECTOR_SEG_NOT, segment_not_present);
set_trap_gate(INT_VECTOR_STACK_FAULT, stack_exception);
set_trap_gate(INT_VECTOR_PROTECTION, general_protection);
set_trap_gate(INT_VECTOR_PAGE_FAULT, page_fault);
set_trap_gate(INT_VECTOR_COPROC_ERR, copr_error);
// hard interrupt IRQ0-IRQ15
set_intr_gate(INT_VECTOR_IRQ0 + 0, clock_intr); //clock interrupt
set_intr_gate(INT_VECTOR_IRQ0 + 1, kb_intr); //keyboard interrupt
set_intr_gate(INT_VECTOR_IRQ0 + 2, hwint02);
set_intr_gate(INT_VECTOR_IRQ0 + 3, hwint03);
set_intr_gate(INT_VECTOR_IRQ0 + 4, hwint04);
set_intr_gate(INT_VECTOR_IRQ0 + 5, hwint05);
set_intr_gate(INT_VECTOR_IRQ0 + 6, hwint06);
set_intr_gate(INT_VECTOR_IRQ0 + 7, hwint07);
set_intr_gate(INT_VECTOR_IRQ8 + 0, hwint08);
set_intr_gate(INT_VECTOR_IRQ8 + 1, hwint09);
set_intr_gate(INT_VECTOR_IRQ8 + 2, hwint10);
set_intr_gate(INT_VECTOR_IRQ8 + 3, hwint11);
set_intr_gate(INT_VECTOR_IRQ8 + 4, hwint12);
set_intr_gate(INT_VECTOR_IRQ8 + 5, hwint13);
set_intr_gate(INT_VECTOR_IRQ8 + 6, hd_intr);//hard disk interrupt
set_intr_gate(INT_VECTOR_IRQ8 + 7, hwint15);
//init 80 interrupt
set_syscall_gate(INT_VECTOR_SYS_CALL, sys_call);
memset((char *)&tss, 0, sizeof(tss));
tss.ss0 = SELECTOR_KERNEL_DS;
//¿¿TSS
init_descriptor(&gdt[INDEX_TSS],
vir2phys(seg2phys(SELECTOR_KERNEL_DS), &tss),
sizeof(tss) - 1,
DA_386TSS);
tss.iobase = sizeof(tss);
PROCESS* p_proc = proc_table;
t16 selector_ldt = INDEX_LDT_FIRST << 3;
//¿¿GDT¿¿¿¿¿¿¿LDT
for(i=0;i<NR_SYSTEM_PROCS + NR_USER_PROCS;i++)
{
init_descriptor(&gdt[selector_ldt>>3],
vir2phys(seg2phys(SELECTOR_KERNEL_DS), proc_table[i].ldts),
LDT_SIZE * sizeof(DESCRIPTOR) - 1,
DA_LDT);
p_proc++;
selector_ldt += 1 << 3;
}
}
void trap_init(void)
{
// set_trap_gate 特权级为0
// set_system_gate 特权级为3
set_trap_gate(0, ÷_error);
set_trap_gate(1, &debug);
set_trap_gate(2, &nmi);
set_system_gate(3, &int3);
set_system_gate(4, &overflow);
set_system_gate(5, &bounds);
set_trap_gate(6, &invalid_op);
set_trap_gate(7, &device_not_available);
set_trap_gate(8, &double_fault);
set_trap_gate(9, &coprocessor_segment_overrun);
set_trap_gate(10, &invalid_TSS);
set_trap_gate(11, &segment_not_present);
set_trap_gate(12, &stack_segment);
set_trap_gate(13, &general_protection);
// set_trap_gate(14, &page_fault);
set_trap_gate(15, &reserved);
set_trap_gate(16, &coprocessor_error);
set_trap_gate(17, &alignment_check);
//int 15, 17-47 的陷阱门预先设置为reserved
for (int i = 18; i < 48; ++i)
{
set_trap_gate(i, &reserved);
}
set_trap_gate(45, &irq13);
outb_p( inb_p(0x21) & 0xfb, 0x21);
outb( inb_p(0xA1) & 0xdf, 0xA1);
set_trap_gate(39, ¶llel_interrupt);
}
void trap_init(void) {
int i;
set_trap_gate(0,÷_error); /* divide by zero */
set_trap_gate(1,&debug); /* single step debugging */
set_trap_gate(2,&nmi); /* non maskable interruption */
set_system_gate(3,&int3); /* int3-5 can be called from all */
set_system_gate(4,&overflow); /* overflow error */
set_system_gate(5,&bounds); /* boundary checking error */
set_trap_gate(6,&invalid_op); /* Invalid operation */
set_trap_gate(7,&device_not_available);
set_trap_gate(8,&double_fault);
set_trap_gate(9,&coprocessor_segment_overrun);
set_trap_gate(10,&invalid_TSS);
set_trap_gate(11,&segment_not_present);
set_trap_gate(12,&stack_segment); /* stack error */
set_trap_gate(13,&general_protection);
set_trap_gate(14,&page_fault);
set_trap_gate(15,&reserved);
set_trap_gate(16,&coprocessor_error);
//Set the remaining gate to reserved
for (i=17;i<48;i++)
set_trap_gate(i,&reserved);
set_trap_gate(45,&irq13); // coprocessor
outb_p(inb_p(0x21)&0xfb,0x21); // Allow IRQ3 interruption request
outb(inb_p(0xA1)&0xdf,0xA1);
set_trap_gate(39,¶llel_interrupt);
}
/*
* OK, finally we got our last thing to do. You are right, that's it,
* initialing the floppy. As you know, initialization is always easy,
* just set the interrupt handler and mask off the bit of corresponding
* interrupt.
*/
void floppy_init(void)
{
set_trap_gate(0x26, floppy_interrupt);
outb(inb_p(0x21)&~0x40,0x21);
}
/* Initialize the IDT table */
void idt_init()
{
/* Initialize Exception Gates */
set_trap_gate(0, ÷_error_wrapper);
set_trap_gate(1, &debug);
set_trap_gate(2, &nmi);
set_system_gate(3, &int3);
set_system_gate(4, &overflow);
set_system_gate(5, &bounds);
set_trap_gate(6, &invalid_op);
set_trap_gate(7, &device_not_available);
set_trap_gate(8, &double_fault);
set_trap_gate(9, &coprocessor_segment_overrun);
set_trap_gate(10, &invalid_TSS);
set_trap_gate(11, &segment_not_present);
set_trap_gate(12, &stack_segment);
set_trap_gate(13, &general_protection);
set_trap_gate(14, &page_fault_wrapper);
set_trap_gate(16, &coprocessor_error);
set_trap_gate(17, &alignment_check);
/* Initialize Interrupt Gates */
// refer to student-notes.pdf P29
set_intr_gate(0x20, &PIT_wrapper);
set_intr_gate(0x21, &keyboard_wrapper); // Initialize keyboard entry
set_intr_gate(0x28, &rtc_wrapper); // Initialize the RTC entry
/* Initialize system call gates*/
set_system_gate(0x80, &syscall_linkage);
}
