os/kernel/cpu/i386/isr.c

/**
 * \file 
*/
#include "../../kernel.h"
#include "../../tasking.h"
#include "../../vga_err.h"
#include "../../address_spaces.h"
#include "../halt.h"
#include "../isr.h"
#include "../paging.h"
#include "../serial.h"
#include "gdt.h"
#include "idt.h"
#include "isr.h"
#include "interrupt.h"
#include <cpu/ports.h>
#include <stdint.h>
#include <string.h>
#include <sys/syscalls.h>
#include <sys/types.h>

void irq_handler(registers_t* r);
static isr_t irq_handlers[16]; //!< Handlers for the PIC interrupts

void isr_install() {
    idt_set_gate(0,(uint32_t)isr0);
    idt_set_gate(1,(uint32_t)isr1);
    idt_set_gate(2,(uint32_t)isr2);
    idt_set_gate(3,(uint32_t)isr3);
    idt_set_gate(4,(uint32_t)isr4);
    idt_set_gate(5,(uint32_t)isr5);
    idt_set_gate(6,(uint32_t)isr6);
    idt_set_gate(7,(uint32_t)isr7);
    idt_set_gate(8,(uint32_t)isr8);
    idt_set_gate(9,(uint32_t)isr9);
    idt_set_gate(10,(uint32_t)isr10);
    idt_set_gate(11,(uint32_t)isr11);
    idt_set_gate(12,(uint32_t)isr12);
    idt_set_gate(13,(uint32_t)isr13);
    idt_set_gate(14,(uint32_t)isr14);
    idt_set_gate(15,(uint32_t)isr15);
    idt_set_gate(16,(uint32_t)isr16);
    idt_set_gate(17,(uint32_t)isr17);
    idt_set_gate(18,(uint32_t)isr18);
    idt_set_gate(19,(uint32_t)isr19);
    idt_set_gate(20,(uint32_t)isr20);
    idt_set_gate(21,(uint32_t)isr21);
    idt_set_gate(22,(uint32_t)isr22);
    idt_set_gate(23,(uint32_t)isr23);
    idt_set_gate(24,(uint32_t)isr24);
    idt_set_gate(25,(uint32_t)isr25);
    idt_set_gate(26,(uint32_t)isr26);
    idt_set_gate(27,(uint32_t)isr27);
    idt_set_gate(28,(uint32_t)isr28);
    idt_set_gate(29,(uint32_t)isr29);
    idt_set_gate(30,(uint32_t)isr30);
    idt_set_gate(31,(uint32_t)isr31);
    idt_set_gate(80,(uint32_t)isr80);
    // Remap the PIC
    port_byte_out(0x20,0x11);
    port_byte_out(0xA0,0x11);
    port_byte_out(0x21,0x20);
    port_byte_out(0xA1,0x28);
    port_byte_out(0x21,0x04);
    port_byte_out(0xA1,0x02);
    port_byte_out(0x21,0x01);
    port_byte_out(0xA1,0x01);
    port_byte_out(0x21,0x0);
    port_byte_out(0xA1,0x0);

    // Install the IRQs
    idt_set_gate(32,(uint32_t)irq0);
    idt_set_gate(33,(uint32_t)irq1);
    idt_set_gate(34,(uint32_t)irq2);
    idt_set_gate(35,(uint32_t)irq3);
    idt_set_gate(36,(uint32_t)irq4);
    idt_set_gate(37,(uint32_t)irq5);
    idt_set_gate(38,(uint32_t)irq6);
    idt_set_gate(39,(uint32_t)irq7);
    idt_set_gate(40,(uint32_t)irq8);
    idt_set_gate(41,(uint32_t)irq9);
    idt_set_gate(42,(uint32_t)irq10);
    idt_set_gate(43,(uint32_t)irq11);
    idt_set_gate(44,(uint32_t)irq12);
    idt_set_gate(45,(uint32_t)irq13);
    idt_set_gate(46,(uint32_t)irq14);
    idt_set_gate(47,(uint32_t)irq15);

    load_idt();
    
    asm volatile("sti");
}



//! List of messages for each exception
__attribute__((unused)) static char *exception_messages[] = {
    "Division By Zero",
    "Debug",
    "Non Maskable Interrupt",
    "Breakpoint",
    "Into Detected Overflow",
    "Out of Bounds",
    "Invalid Opcode",
    "No Coprocessor",

    "Double Fault",
    "Coprocessor Segment Overrun",
    "Bad TSS",
    "Segment Not Present",
    "Stack Fault",
    "General Protection Fault",
    "Page Fault",
    "Unknown Interrupt",

    "Coprocessor Fault",
    "Alignment Check",
    "Machine Check",
    "Reserved",
    "Reserved",
    "Reserved",
    "Reserved",
    "Reserved",

    "Reserved",
    "Reserved",
    "Reserved",
    "Reserved",
    "Reserved",
    "Reserved",
    "Reserved",
    "Reserved"
};


/**
 * Handler for non-PIC interrupts
 * \param r The saved state of the CPU
*/
void isr_handler(registers_t* r) {
  if (r->int_no!=80 && r->int_no!=14) {
    serial_write_string(exception_messages[r->int_no]);
  }
  switch (r->int_no) {
    case 14: {
      serial_write_string("PAGE FAULT\n");
      void* addr;
      asm("movl %%cr2,%0": "=r"(addr));
      // serial_write_string("In PID ");
      char str[11];
      // int_to_ascii(getPID(),str);
      // serial_write_string(str);
      serial_write_string(" and address ");
      str[0]='\0';
      hex_to_ascii(r->eip,str);
      serial_write_string(str);
      if (r->err_code==0) {
        serial_write_string(", kernel process tried to read a non-present page entry at address ");
      } else if (r->err_code==1) {
        serial_write_string(", kernel process tried to read a page and caused a protection fault at address ");
      } else if (r->err_code==2) {
        serial_write_string(", kernel process tried to write to a non-present page entry at address ");
      } else if (r->err_code==3) {
        serial_write_string(", kernel process tried to write a page and caused a protection fault at address ");
      } else if (r->err_code==4) {
        serial_write_string(", user process tried to read a non-present page entry at address ");
      } else if (r->err_code==5) {
        serial_write_string(", user process tried to read a page and caused a protection fault at address ");
      } else if (r->err_code==6) {
        serial_write_string(", user process tried to write to a non-present page entry at address ");
      } else if (r->err_code==7) {
        serial_write_string(", user process tried to write a page and caused a protection fault at address ");
      }
      str[0]='\0';
      hex_to_ascii((unsigned int)addr,str);
      serial_write_string(str);
      serial_write_string(".");
      serial_write_string(" Stack is at ");
      str[0]='\0';
      hex_to_ascii(r->useresp,str);
      serial_write_string(str);
      serial_write_string(".\n");
      // if ((r->err_code&1)==0) {
      //   // int dir_entry=(addr&0xFFC00000)>>22;
      //   // int table_entry=(addr&0x3FF000)>12;
      //   // if (dir_entry_present(dir_entry)) {
      //   //   set_table_entry(dir_entry,table_entry,((dir_entry*1024)+table_entry)*0x1000,1,1,1);
      //   //   for(int page=0;page<1024;page++) {
      //   //     asm volatile("invlpg (%0)"::"r"(((dir_entry*1024)+page)*0x1000):"memory");
      //   //   }
      //   // } else {
      //   //   for(int page=0;page<1024;page++) {
      //   //     set_table_entry(dir_entry,page,0x0,1,1,0);
      //   //   }
      //   //   set_table_entry(dir_entry,table_entry,((dir_entry*1024)+table_entry)*0x1000,1,1,1);
      //   //   set_directory_entry(dir_entry,dir_entry,1,1,1);
      //   // }
      //   // return;
      // }
      halt();
      break;
    case 80:
      switch (r->eax) {
      case SYSCALL_CREATEPROC:
        tasking_create_task((void*)r->ebx,(void*)r->ecx,0,r->edx,(void*)r->esi,r->edx,(void*)r->edi,0);
        break;
      case SYSCALL_YIELD:
        tasking_yield();
        break;
      case SYSCALL_BLOCK:
        tasking_block(r->ebx);
        break;
      case SYSCALL_UNBLOCK:
        tasking_unblock(r->ebx,r->ecx);
        break;
      case SYSCALL_EXIT:
        tasking_exit((uint8_t)r->ebx);
        break;
      case SYSCALL_GET_ERRNO_ADDR:
        r->ebx=(uint32_t)tasking_get_errno_address();
        break;
      case SYSCALL_GET_PID:
        r->ebx=(pid_t)tasking_get_PID();
        break;
      case SYSCALL_ALLOC_MEM:
        if ((void*)r->ecx==NULL) {
          r->ebx=(uint32_t)alloc_pages(r->ebx);
        } else {
          alloc_pages_virt(r->ebx,(void*)r->ecx);
        }
        break;
      case SYSCALL_PRIV_MAP_PAGES:
        if (tasking_is_privleged()) {
          r->ebx=0;
          return;
        }
        void* virt_addr=find_free_pages(r->ecx);
        map_pages(virt_addr,(void*)r->ebx,r->ecx,1,1);
        r->ebx=(uint32_t)virt_addr;
        break;
      case SYSCALL_NEW_ADDR_SPACE:
        r->ebx=(uint32_t)paging_new_address_space();
        break;
      case SYSCALL_ADDR_SPACES_COPY_DATA:
        serial_printf("address_spaces_copy_data(0x%x,0x%x,0x%x,0x%x);\n",(void*)r->ebx,(void*)r->ecx,r->edx,(void*)r->esi);
        if ((void*)r->esi!=NULL) {
          address_spaces_copy_data((void*)r->ebx,(void*)r->ecx,r->edx,(void*)r->esi);
        } else {
          r->ebx=(uint32_t)address_spaces_put_data((void*)r->ebx,(void*)r->ecx,r->edx);
        }
        break;
      case SYSCALL_SERIAL_PRINT:
        serial_write_string((char*)r->ebx);
        break;
      case SYSCALL_GET_INITRD_SZ:
        serial_printf("Initrd size is %d bytes\n",initrd_sz);
        r->ebx=initrd_sz;
        break;
      case SYSCALL_COPY_INITRD:
        serial_printf("Copying initrd\n");
        memcpy((char*)r->ebx,initrd,initrd_sz);
        break;
      case SYSCALL_NEW_THREAD: {
        uint32_t tid=tasking_new_thread((void*)r->ebx,tasking_get_PID(),1,(void*)r->edx);
        if ((uint32_t*)r->ecx!=NULL) {
          *((uint32_t*)r->ecx)=tid;
        }
      }
      break;
      default:
        break;
      } 
      break;
    }
  }
}


void isr_register_handler(int n,isr_t handler) {
    if (n>16) {
      return;
    }
    irq_handlers[n] = handler;
}

/**
 * Handler for PIC interrupts
 * \param r The saved state of the CPU
*/
void irq_handler(registers_t* r) {
    /* After every interrupt we need to send an EOI to the PICs
     * or they will not send another interrupt again */
    if (r->int_no >= 40) port_byte_out(0xA0,0x20); /* slave */
    port_byte_out(0x20,0x20); /* master */
    /* Handle the interrupt in a more modular way */
    if (irq_handlers[r->int_no-32] != NULL) {
        isr_t handler = irq_handlers[r->int_no];
        handler(r);
    }
}