linux0.01内核trap.c文件分析

该程序主要定义和实现了asm.s中所引用的各个硬件异常中断处理程序

*******************************************************

注意函数str(i)：

定义在sched.h： #define str(n) \ __asm__("str %%ax\n\t" \ "subl %2,%%eax\n\t" \ "shrl $4,%%eax" \ :"=a" (n) \ :"a" (0),"i" (FIRST_TSS_ENTRY<<3))

*******************************************************

#include
#include
#include
#include
#include
#include
#include

取给定段以及偏移处的一个字节
输出寄存器eax,输入寄存器eax,内存地址addr
#define get_seg_byte(seg,addr) ({ \
register char __res; \
__asm__("push %%fs;mov %%ax,%%fs;movb %%fs:%2,%%al;pop %%fs" \
 :"=a" (__res):"0" (seg),"m" (*(addr))); \
__res;})

取给定段以及偏移处的一个4字节
#define get_seg_long(seg,addr) ({ \
register unsigned long __res; \
__asm__("push %%fs;mov %%ax,%%fs;movl %%fs:%2,%%eax;pop %%fs" \
 :"=a" (__res):"0" (seg),"m" (*(addr))); \
__res;})

取fs寄存器的值
#define _fs() ({ \
register unsigned short __res; \
__asm__("mov %%fs,%%ax":"=a" (__res):); \
__res;})

函数声明，之后会一一定义。
int do_exit(long code);

void page_exception(void);

void divide_error(void);
void debug(void);
void nmi(void);
void int3(void);
void overflow(void);
void bounds(void);
void invalid_op(void);
void device_not_available(void);
void double_fault(void);
void coprocessor_segment_overrun(void);
void invalid_TSS(void);
void segment_not_present(void);
void stack_segment(void);
void general_protection(void);
void page_fault(void);
void coprocessor_error(void);
void reserved(void);
void parallel_interrupt(void);
void irq13(void);

打印寄存器，代码段，数据段的信息
static void die(char * str,long esp_ptr,long nr)
{ 
 取 堆栈段堆栈指针寄存器的值
 long * esp = (long *) esp_ptr;

 int i;
 
 nr是错误码，nr&0xffff保证错误码是2个字节
 打印错误信息str和错误码
 printk("%s: %04x\n\r",str,nr&0xffff);

 esp[0]: eip寄存器
 esp[1]: cs寄存器
 esp[2]: eflags寄存器
 esp[3]: 原esp寄存器
 esp[4]: 原ss寄存器
 打印执行中断处理程序之前的各个寄存器的值
 printk("EIP:\t%04x:%p\nEFLAGS:\t%p\nESP:\t%04x:%p\n",
  esp[1],esp[0],esp[2],esp[4],esp[3]);
 
 打 印fs寄存器的值
 printk("fs: %04x\n",_fs());

 0x17: 表示局部描述附表中，特权级为3，索引值为2的段选择符，即数据段。
 打印描述符中段限长值和中断描述符表的段基地址
 printk("base: %p, limit: %p\n",get_base(current->ldt[1]),get_limit(0x17));

 如果原来的堆栈段和局部描述符的数据段一样，打印从该
 栈开始位置处的前16个字节。
 if (esp[4] == 0x17) {
  printk("Stack: ");
  for (i=0;i<4;i++)
   printk("%p ",get_seg_long(0x17,i+(long *)esp[3]));
  printk("\n");
 }
 
 取当前任务号。
 str(i); //（str——“save task register”）
 打印进程id和当前的任务号
 printk("Pid: %d, process nr: %d\n\r",current->pid,0xffff & i);

 打印代码段前10个字节
 for(i=0;i<10;i++)
  printk("%02x ",0xff & get_seg_byte(esp[1],(i+(char *)esp[0])));
 printk("\n\r");
 do_exit(11);  /* play segment exception */
}

实现各个中断处理程序
void do_double_fault(long esp, long error_code)
{
 die("double fault",esp,error_code);
}

void do_general_protection(long esp, long error_code)
{
 die("general protection",esp,error_code);
}

void do_divide_error(long esp, long error_code)
{
 die("divide error",esp,error_code);
}

实现debug中断处理，打印中断处理程序开始执行之前需要入栈
保存的寄存器的值
void do_int3(long * esp, long error_code,
  long fs,long es,long ds,
  long ebp,long esi,long edi,
  long edx,long ecx,long ebx,long eax)
{
 int tr;

 __asm__("str %%ax":"=a" (tr):"0" (0));
 printk("eax\t\tebx\t\tecx\t\tedx\n\r%8x\t%8x\t%8x\t%8x\n\r",
  eax,ebx,ecx,edx);
 printk("esi\t\tedi\t\tebp\t\tesp\n\r%8x\t%8x\t%8x\t%8x\n\r",
  esi,edi,ebp,(long) esp);
 printk("\n\rds\tes\tfs\ttr\n\r%4x\t%4x\t%4x\t%4x\n\r",
  ds,es,fs,tr);
 printk("EIP: %8x   CS: %4x  EFLAGS: %8x\n\r",esp[0],esp[1],esp[2]);
}

void do_nmi(long esp, long error_code)
{
 die("nmi",esp,error_code);
}

void do_debug(long esp, long error_code)
{
 die("debug",esp,error_code);
}

void do_overflow(long esp, long error_code)
{
 die("overflow",esp,error_code);
}

void do_bounds(long esp, long error_code)
{
 die("bounds",esp,error_code);
}

void do_invalid_op(long esp, long error_code)
{
 die("invalid operand",esp,error_code);
}

void do_device_not_available(long esp, long error_code)
{
 die("device not available",esp,error_code);
}

void do_coprocessor_segment_overrun(long esp, long error_code)
{
 die("coprocessor segment overrun",esp,error_code);
}

void do_invalid_TSS(long esp,long error_code)
{
 die("invalid TSS",esp,error_code);
}

void do_segment_not_present(long esp,long error_code)
{
 die("segment not present",esp,error_code);
}

void do_stack_segment(long esp,long error_code)
{
 die("stack segment",esp,error_code);
}

void do_coprocessor_error(long esp, long error_code)
{
 if (last_task_used_math != current)
  return;
 die("coprocessor error",esp,error_code);
}

void do_reserved(long esp, long error_code)
{
 die("reserved (15,17-47) error",esp,error_code);
}

设置中断描述符表：
从以下代码中可以看到，设置陷阱门和系统门唯一的区别是
描述符特权级不同，陷阱门是0，系统门是3.
#define set_trap_gate(n,addr) \
 _set_gate(&idt[n],15,0,addr)

#define set_system_gate(n,addr) \
 _set_gate(&idt[n],15,3,addr)
初 始化中断处理程序，在main.c调用

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);
 开 启8259a中断
 outb_p(inb_p(0x21)&0xfb,0x21);
 outb(inb_p(0xA1)&0xdf,0xA1);

 set_trap_gate(39,¶llel_interrupt);
}