protect.c~

来自「参照MINIX3写的操作系统 用GCC+NASM+BOCHS开发」· C~ 代码 · 共 178 行

#include "protect.h"

PUBLIC t_32 Seg2Phys(t_16 seg)
{
	DESCRIPTOR *pDesc=&gdt[seg>>3];
	return (pDesc->BaseHigh<<24)|
		   (pDesc->BaseMiddle<<16) |
		   (pDesc->BaseLow);
}

PUBLIC void Delay(int Time)
{
	int i,j,k;
	for(k=0;k<Time;k++)
		for(i=0;i<=10000;i++)
			for(j=0;j<=1000;j++)
			{}

}

void SetDescriptor(DESCRIPTOR *pDesc,t_32 Base,t_32 Limit,t_16 Attribute)
{
	pDesc->LimitLow =Limit&0x0ffff;
	pDesc->BaseLow  =Base&0xffff;
	pDesc->BaseMiddle=(Base>>16)&0x0ff;
	pDesc->Attribute1=Attribute&0xff;
	pDesc-> LimitH_Attr2=((Limit>>16)&0x0f)|(Attribute>>8)&0xf0;
	pDesc->BaseHigh=(Base>>24)&0x0ff;
}


PUBLIC void ClockHandler(int Irq)
//时钟中断处理程序
{
	if(ReEnter!=0)
	{
		printk("chongru");
	}

	
	  pCurrentProc->Priority--;
	  if(ReadyProc->Priority== -1000)
		  return;
	  else
		  Scheduler();


	
}

PUBLIC void SetIrqHandler(int Irq,IrqFuction Handler)
{
	DisableIrq(Irq);
	IrqTable[Irq]=Handler;
}

PUBLIC t_32 _SystemCall(t32 a,t32 b,t32 c,t32 d)
{
	switch(a)
	{
	case 1:sysGetChar();
	default:break;
	}
}

PUBLIC void ExceptionHandler(int Vector,int ErrorCode,int eip,int cs,int eflags)
{
	int i;
	char ErrorTable[20][50];
	strcpy(ErrorTable[0],"#DE Divide Error");	
	strcpy(ErrorTable[1],"#DB RESERVED");
	strcpy(ErrorTable[2],"- NMI Interrupt");	
	strcpy(ErrorTable[3],"#DB RESERVED");
	strcpy(ErrorTable[4],"#OF Overflow");	
	strcpy(ErrorTable[5],"#BP BOUND Range Exceeded");
	strcpy(ErrorTable[6],"#UD Invalid Opcode");	
	strcpy(ErrorTable[7],"#NM Device Not Available");
	strcpy(ErrorTable[8],"#DF Double Fault");	
	strcpy(ErrorTable[9],"Coprocessor Segment Overrun");
	strcpy(ErrorTable[10],"#TS Invalid TSS");	
	strcpy(ErrorTable[11],"#NP Segment Not Present");
	strcpy(ErrorTable[12],"#SS Stack Segment Fault");	
	strcpy(ErrorTable[13],"#GP General Protection");
	strcpy(ErrorTable[14],"#PF Page Fault");	
	strcpy(ErrorTable[15],"- (Intel reserved. Do notuse)");
	strcpy(ErrorTable[16],"#MF X87 FPU Floating-Point Error (Math Fault)");	
	strcpy(ErrorTable[17],"#AC Alignment Check");
	strcpy(ErrorTable[18],"#MC Machine Check");	
	strcpy(ErrorTable[19],"#XF SIMD Floating-Point Exception");
	Disp_pos=0;
	for(i=0;i<80*5;i++)
	{
		printk(" ");
	}
	printk("%s ,ErrrorCode %x , eip %x cs %x eflags %x", ErrorTable[Vector],ErrorCode,eip,cs,eflags);
}

PUBLIC void SetIDT(unsigned char Vector,t_8 DescType,FuctionPoint Handler,unsigned char Privilege)
{
	GATE *ISRGate      = &idt[Vector];
	t_32  Base         = (t_32)Handler;
	ISRGate->OffsetL   = Base&0xffff;
	ISRGate->Selector  = SELECTOR_KERNEL_CS;
	ISRGate->Dcount    = 0;
	ISRGate->Attribute = DescType| (Privilege<<5);
	ISRGate->OffsetH   = (Base>>16)&0xffff;
}

PUBLIC void InitIrq()
{
	int i;	
	printk("/////////////Init IRQ!////////////\n");
	//初始化8259A
	OutByte(INT_M_CTL,0x11);
	OutByte(INT_S_CTL,0x11);
	OutByte(INT_M_CTLMASK,INT_VECTOR_IRQ0);
	OutByte(INT_S_CTLMASK,INT_VECTOR_IRQ8);
	OutByte(INT_M_CTLMASK,0x4);
	OutByte(INT_S_CTLMASK,0x2);
	OutByte(INT_M_CTLMASK,0x1);
	OutByte(INT_S_CTLMASK,0x1);
	OutByte(INT_M_CTLMASK,0xff);
	OutByte(INT_S_CTLMASK,0xff);
    //暂时先把所有的中断处理程序设成SpuriousIrq	
	for(i=0;i<NR_IRQ;i++)
			IrqTable[i]=SpuriousIrq;
    //设置异常
	SetIDT(INT_VECTOR_DIVIDE,			DA_386IGate,DivideError,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_DEBUG,			DA_386IGate, SingleStepException,PRIVILEGE_KRNL); 
    	SetIDT(INT_VECTOR_NMI,				DA_386IGate, Nmi,PRIVILEGE_KRNL);	
	SetIDT(INT_VECTOR_BREAKPOINT,		DA_386IGate,BreakPointException,PRIVILEGE_USER);
	SetIDT(INT_VECTOR_OVERFLOW,		DA_386IGate,OverFlow,PRIVILEGE_USER);
	SetIDT(INT_VECTOR_BOUNDS,			DA_386IGate,BoundsCheck,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_INVAL_OP,		DA_386IGate,InvalidOpcode,PRIVILEGE_KRNL);	
	SetIDT(INT_VECTOR_COPROC_NOT,	DA_386IGate,CoprNotAvailable,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_DOUBLE_FAULT,	DA_386IGate,DoubleFault,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_COPROC_SEG,	DA_386IGate,CoprSegOverrun,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_INVAL_TSS,		DA_386IGate,InvalidTss,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_SEG_NOT,		DA_386IGate,SegmentNotPresent,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_STACK_FAULT,	DA_386IGate, StackException,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_PROTECTION,		DA_386IGate,GeneralException,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_PAGE_FAULT,	DA_386IGate,PageFault,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_COPROC_ERR,	DA_386IGate, CoprError,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_IRQ0+0,			DA_386IGate,Hwint00,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_IRQ0+1,			DA_386IGate,Hwint01,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_IRQ0+2,			DA_386IGate,Hwint02,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_IRQ0+3,			DA_386IGate,Hwint03,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_IRQ0+4,			DA_386IGate,Hwint04,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_IRQ0+5,			DA_386IGate,Hwint05,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_IRQ0+6,			DA_386IGate,Hwint06,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_IRQ0+8,			DA_386IGate,Hwint07,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_IRQ8+0,			DA_386IGate,Hwint08,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_IRQ8+1,			DA_386IGate,Hwint09,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_IRQ8+2,			DA_386IGate,Hwint10,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_IRQ8+3,			DA_386IGate,Hwint11,PRIVILEGE_KRNL);	
	SetIDT(INT_VECTOR_IRQ8+4,			DA_386IGate,Hwint12,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_IRQ8+5,			DA_386IGate,Hwint13,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_IRQ8+6,			DA_386IGate,Hwint14,PRIVILEGE_KRNL);
	SetIDT(INT_VECTOR_IRQ8+7,			DA_386IGate,Hwint15,PRIVILEGE_KRNL);
	SetIDT(0x90, 						DA_386IGate,Hwint90,PRIVILEGE_TASK);
	SetIDT(0x70,							DA_386IGate,Hwint70,PRIVILEGE_USER);
	/* 填充 GDT 中 TSS 这个描述符 */
	MemorySet(&tss, 0, sizeof(tss));
	tss.ss0= SELECTOR_KERNEL_DS;
	SetDescriptor(&gdt[INDEX_TSS],
			vir2phys(Seg2Phys(SELECTOR_KERNEL_DS), &tss),
			sizeof(tss) - 1,
			DA_386TSS);
	tss.IoBase	= sizeof(tss);	/* 没有I/O许可位图 */	
}

PUBLIC void SpuriousIrq(int Irq)
{
	DisplayString("Irq");
	DisplayInt(Irq);
	DisplayString("\n");
}