--- np2/i386c/ia32/exception.c 2004/02/04 13:24:35 1.7 +++ np2/i386c/ia32/exception.c 2012/01/08 11:36:06 1.35 @@ -1,5 +1,3 @@ -/* $Id: exception.c,v 1.7 2004/02/04 13:24:35 monaka Exp $ */ - /* * Copyright (c) 2003 NONAKA Kimihiro * All rights reserved. @@ -12,8 +10,6 @@ * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * 3. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES @@ -65,110 +61,114 @@ static const int dftable[4][4] = { { 1, 1, 1, 1, }, }; -void +void CPUCALL exception(int num, int error_code) { +#if defined(DEBUG) + extern int cpu_debug_rep_cont; + extern CPU_REGS cpu_debug_rep_regs; +#endif int errorp = 0; __ASSERT((unsigned int)num < EXCEPTION_NUM); +#if 0 + iptrace_out(); + debugwriteseg("execption.bin", &CPU_CS_DESC, CPU_PREV_EIP & 0xffff0000, 0x10000); +#endif + + VERBOSE(("exception: -------------------------------------------------------------- start")); VERBOSE(("exception: %s, error_code = %x at %04x:%08x", exception_str[num], error_code, CPU_CS, CPU_PREV_EIP)); - VERBOSE(("exception:------------------------------------------------")); VERBOSE(("%s", cpu_reg2str())); - VERBOSE(("exception:------------------------------------------------")); + VERBOSE(("code: %dbit(%dbit), address: %dbit(%dbit)", CPU_INST_OP32 ? 32 : 16, CPU_STATSAVE.cpu_inst_default.op_32 ? 32 : 16, CPU_INST_AS32 ? 32 : 16, CPU_STATSAVE.cpu_inst_default.as_32 ? 32 : 16)); +#if defined(DEBUG) + if (cpu_debug_rep_cont) { + VERBOSE(("rep: original regs: ecx=%08x, esi=%08x, edi=%08x", cpu_debug_rep_regs.reg[CPU_ECX_INDEX].d, cpu_debug_rep_regs.reg[CPU_ESI_INDEX].d, cpu_debug_rep_regs.reg[CPU_EDI_INDEX].d)); + } + VERBOSE(("%s", cpu_disasm2str(CPU_PREV_EIP))); +#endif - CPU_STAT_NERROR++; - if ((CPU_STAT_NERROR >= 3) - || (CPU_STAT_NERROR == 2 && CPU_STAT_PREV_EXCEPTION == DF_EXCEPTION)) { + CPU_STAT_EXCEPTION_COUNTER_INC(); + if ((CPU_STAT_EXCEPTION_COUNTER >= 3) + || (CPU_STAT_EXCEPTION_COUNTER == 2 && CPU_STAT_PREV_EXCEPTION == DF_EXCEPTION)) { /* Triple fault */ ia32_panic("exception: catch triple fault!"); } switch (num) { - case DE_EXCEPTION: /* (F) ¥¹¥µ¡¦¥£¡¦ò£¥· */ - case BR_EXCEPTION: /* (F) BOUND ¡¢¥Û¥Í¥Þ¡¼¥Þ¥¦¡¼ */ - case UD_EXCEPTION: /* (F) ¥Õ¥ª¥¯ù饧¡¦¥ì¡¦¥¦¡£¥·¡¦¥Î */ - case NM_EXCEPTION: /* (F) ¡¦¥Ì¡¦¥ß¡¦¡¢¡¦¥±¥µ¥Í¥Ø¥à¥Î¥ä¥¤¥È (FPU ¡¢¥ã¥Õ¥ª¡¢¡¢) */ + case DE_EXCEPTION: /* (F) ñù¡¢î°Î太å㥥å㥷 */ + case DB_EXCEPTION: /* (F/T) åã®å¥ðåã¦å¤² */ + case BR_EXCEPTION: /* (F) BOUND åá¥ççÖ´ê¦*/ + case UD_EXCEPTION: /* (F) ̵¸ú¥ª¥Ú¥³¡¼¥É */ + case NM_EXCEPTION: /* (F) ¥Ç¥Ð¥¤¥¹»ÈÍÑÉÔ²Ä (FPU ¤¬Ìµ¤¤) */ + case MF_EXCEPTION: /* (F) ÉâÆ°¾®¿ôÅÀ¥¨¥é¡¼ */ CPU_EIP = CPU_PREV_EIP; + if (CPU_STATSAVE.cpu_stat.backout_sp) + CPU_ESP = CPU_PREV_ESP; /*FALLTHROUGH*/ - case DB_EXCEPTION: /* (F/T) ¥Ç¥Ð¥Ã¥° */ - case NMI_EXCEPTION: /* (I) NMI ³ä¤ê¹þ¤ß */ - case BP_EXCEPTION: /* (T) ¥Ö¥ì¡¼¥¯¥Ý¥¤¥ó¥È */ - case OF_EXCEPTION: /* (T) ¥ª¡¼¥Ð¡¼¥Õ¥í¡¼ */ + case NMI_EXCEPTION: /* (I) NMI ³ä¤ê¹þ¤ß */ + case BP_EXCEPTION: /* (T) ¥Ö¥ì¡¼¥¯¥Ý¥¤¥ó¥È */ + case OF_EXCEPTION: /* (T) ¥ª¡¼¥Ð¡¼¥Õ¥í¡¼ */ errorp = 0; break; - case DF_EXCEPTION: /* (A) ¡¦¥¿¡¦¥è¡¦ö§¥æ¡¦¥¥¡¦ö§¥Í (errcode: 0) */ + case DF_EXCEPTION: /* (A) åãc«ã©ã (errcode: 0) */ errorp = 1; error_code = 0; break; -#if CPU_FAMILY >= 4 - case AC_EXCEPTION: /* (F) ¥¢¥é¥¤¥ó¥á¥ó¥È¥Á¥§¥Ã¥¯ (errcode: 0) */ + case AC_EXCEPTION: /* (F) åâ¡Öå㥥åâ¡¢å㥦åã¡£å㥦åã°å¥áå⥡åã¦å¤± (errcode: 0) */ error_code = 0; /*FALLTHROUGH*/ -#endif - case TS_EXCEPTION: /* (F) ¥Õ¥ª¥¯TSS (errcode) */ - case NP_EXCEPTION: /* (F) ¡¦¥µ¡¦¡¼¡¦â§ó¥ÈÉÔº(errcode) */ - case SS_EXCEPTION: /* (F) ¥¹¥¿¥Ã¥¯¥»¥°¥á¥ó¥È¥Õ¥©¥ë¥È (errcode) */ - case GP_EXCEPTION: /* (F) °ìÈÌÊݸîÎã³° (errcode) */ - case PF_EXCEPTION: /* (F) ¥Ú¡¼¥¸¥Õ¥©¥ë¥È (errcode) */ + case TS_EXCEPTION: /* (F) ̵¸ú TSS (errcode) */ + case NP_EXCEPTION: /* (F) ¥»¥°¥á¥ó¥ÈÉＧ (errcode) */ + case SS_EXCEPTION: /* (F) ¥¹¥¿¥Ã¥¯¥»¥°¥á¥ó¥È¥Õ¥©¥ë¥È (errcode) */ + case GP_EXCEPTION: /* (F) °ìÈÌÊݸîÎã³° (errcode) */ + case PF_EXCEPTION: /* (F) ¥Ú¡¼¥¸¥Õ¥©¥ë¥È (errcode) */ CPU_EIP = CPU_PREV_EIP; + if (CPU_STATSAVE.cpu_stat.backout_sp) + CPU_ESP = CPU_PREV_ESP; errorp = 1; break; - case MF_EXCEPTION: /* (F) ÉâÆ°¾®¿ôÅÀ¥¨¥é¡¼ */ - CPU_EIP = CPU_PREV_EIP; - errorp = 0; - break; - -#if CPU_FAMILY >= 5 - case MC_EXCEPTION: /* (A) ¥Þ¥·¥ó¥Á¥§¥Ã¥¯ */ - CPU_EIP = CPU_PREV_EIP; - errorp = 0; - break; -#endif - -#if CPU_FAMILY >= 6 - case XF_EXCEPTION: /* (F) ¥¹¥È¥ê¡¼¥ß¥ó¥° SIMD ³Èĥ̿Îá */ - CPU_EIP = CPU_PREV_EIP; - errorp = 0; - break; -#endif - default: ia32_panic("exception: unknown exception (%d)", num); break; } - if (CPU_STAT_NERROR >= 2) { + if (CPU_STAT_EXCEPTION_COUNTER >= 2) { if (dftable[exctype[CPU_STAT_PREV_EXCEPTION]][exctype[num]]) { num = DF_EXCEPTION; + errorp = 1; + error_code = 0; } } CPU_STAT_PREV_EXCEPTION = num; - INTERRUPT(num, FALSE, errorp, error_code); + VERBOSE(("exception: ---------------------------------------------------------------- end")); + + interrupt(num, INTR_TYPE_EXTINTR, errorp, error_code); + CPU_STAT_EXCEPTION_COUNTER_CLEAR(); siglongjmp(exec_1step_jmpbuf, 1); } /* - * ¥³¡¼¥ë¡¦¥²¡¼¥È¡¦¥Ç¥£¥¹¥¯¥ê¥×¥¿ + * å⥦å㥷å㥩å㥵å⥤å㥷åã°å¦½åã®å¤¥å⥱åâ¥Ãå㥧åãÎå¤Á * * 31 16 15 14 13 12 8 7 5 4 0 * +------------------------------------+--+-----+----------+-----+---------+ - * | ¡¦¥§¡¦¥æ¡¦¥µ¡¦¥Æ¡¦¥Í 31..16 | P| DPL | 0 D 1 0 0|0 0 0|¡¦¥©¡¦¥ò¡¦ó¥| 4 + * | ¥ª¥Õ¥»¥Ã¥È 31..16 | P| DPL | 0 D 1 0 0|0 0 0|¥«¥¦¥ó¥È | 4 * +------------------------------------+--+-----+----------+-----+---------+ * 31 16 15 0 * +------------------------------------+-----------------------------------+ - * | ¥»¥°¥á¥ó¥È¡¦¥»¥ì¥¯¥¿ | ¥ª¥Õ¥»¥Ã¥È 15..0 | 0 + * | å⥵å⡼åã¡£å㥦åã°å¦½å⥵åã¥ãåâ¥Ãå⥽ | å⥧åãÊ夽åã¦å¥è 15..0 | 0 * +------------------------------------+-----------------------------------+ */ /* - * ¥¦è¦ô»¡¬¡¦¥Ì¡¦¡×¡¦¥±¡¦¥Ã¡¦ô§¥é¡¦¥½ + * é饤åâ´ê¥»¥·å᥽åã®å¤¥å⥱åâ¥Ãå㥧åãÎå¤Á *-- - * ¡¦¥½¡¦¥±¡¦¥Ã¡£¥ò¡¦¥¤¡£¥·¡¦¥Í + * å⥽å⥱åâ¥Ãå㥵å⥤å㥷å㊠* * 31 16 15 14 13 12 8 7 0 * +------------------------------------+--+-----+----------+---------------+ @@ -176,64 +176,68 @@ exception(int num, int error_code) * +------------------------------------+--+-----+----------+---------------+ * 31 16 15 0 * +------------------------------------+-----------------------------------+ - * | TSS ¥»¥°¥á¥ó¥È¡¦¥»¥ì¥¯¥¿ | Reserved | 0 + * | TSS å⥵å⡼åã¡£å㥦åã°å¦½å⥵åã¥ãåâ¥Ãå⥽ | Reserved | 0 * +------------------------------------+-----------------------------------+ *-- - * ¥¦è¦ô»+ * ³ä¤ê¹þ¤ß¡¦¥²¡¼¥È * * 31 16 15 14 13 12 8 7 5 4 0 * +------------------------------------+--+-----+----------+-----+---------+ - * | ¡¦¥§¡¦¥æ¡¦¥µ¡¦¥Æ¡¦¥Í 31..16 | P| DPL | 0 D 1 1 0|0 0 0|Reserved | 4 + * | å⥧åãÊ夽åã¦å¥è 31..16 | P| DPL | 0 D 1 1 0|0 0 0|Reserved | 4 * +------------------------------------+--+-----+----------+-----+---------+ * 31 16 15 0 * +------------------------------------+-----------------------------------+ - * | ¡¦¥µ¡¦¡¼¡¦â§ó¥È¡¦¥»¥ì¥¯¥ | ¥ª¥Õ¥»¥Ã¥È 15..0 | 0 + * | å⥵å⡼åã¡£å㥦åã°å¦½å⥵åã¥ãåâ¥Ãå⥽ | å⥧åãÊ夽åã¦å¥è 15..0 | 0 * +------------------------------------+-----------------------------------+ *-- - * ¡¦¥Í¡¦ò§¥Æ¡¦¥é¡£¥ò¡¦¥¤¡£¥·¡¦¥Í + * åã°å¦«åã¦å¥÷å㥵å⥤å㥷å㊠* * 31 16 15 14 13 12 8 7 5 4 0 * +------------------------------------+--+-----+----------+-----+---------+ - * | ¥ª¥Õ¥»¥Ã¥È 31..16 | P| DPL | 0 D 1 1 1|0 0 0|Reserved | 4 + * | å⥧åãÊ夽åã¦å¥è 31..16 | P| DPL | 0 D 1 1 1|0 0 0|Reserved | 4 * +------------------------------------+--+-----+----------+-----+---------+ * 31 16 15 0 * +------------------------------------+-----------------------------------+ - * | ¡¦¥µ¡¦¡¼¡¦â§ü§¥Í¡£¥ò¡¦¥µ¡¦ø§¥Ã¡¦¥½ | ¡¦¥§¡¦¥æ¡¦¥µ¡¦¥Æ¡¦¥Í 15..0 | 0 + * | å⥵å⡼åã¡£å㥦åã°å¦½å⥵åã¥ãåâ¥Ãå⥽ | å⥧åãÊ夽åã¦å¥è 15..0 | 0 * +------------------------------------+-----------------------------------+ *-- - * DPL : ¡¦¥Ì¡¦¡×¡¦¥±¡¦¥Ã¡¦ô§¥é¡¦¥½¥Ë¥Æ¥¯¡Ö¡¦ø§¥ë¡¦- * ¥ª¥Õ¥»¥Ã¥È : ¥×¥í¥·¡¼¥¸¥ã¡¦¥¨¥ó¥È¥ê¡¦¥Ý¥¤¥ó¥È¤Þ¤Ç¤Î¥ª¥Õ¥»¥Ã¥È - * P : ¥»¥°¥á¥ó¥È¸ºß¥Õ¥é¥° - * ¥»¥ì¥¯¥¿ : ¥Ç¥£¥¹¥Æ¥£¥Í¡¼¥·¥ç¥ó¡¦¥³¡¼¥É¡¦¥»¥°¥á¥ó¥È¤Î¥»¥°¥á¥ó¥È¡¦¥»¥ì¥¯¥¿ - * D : ¥²¡¼¥È¤Î¥µ¥¤¥º¡¥0 = 16 bit, 1 = 32 bit + * DPL : ¥Ç¥£¥¹¥¯¥ê¥×¥¿Æø¢¥ì¥Ù¥ë + * ¥ª¥Õ¥»¥Ã¥È : ¥×¥í¥·¡¼¥¸¥ã¡¦¥¨¥ó¥È¥ê¡¦¥Ý¥¤¥ó¥È¤Þ¤Ç¤Î¥ª¥Õ¥»¥Ã¥È + * P : ¥»¥°¥á¥ó¥È¸ºß¥Õ¥é¥° + * ¥»¥ì¥¯¥¿ : ¥Ç¥£¥¹¥Æ¥£¥Í¡¼¥·¥ç¥ó¡¦¥³¡¼¥É¡¦¥»¥°¥á¥ó¥È¤Î¥»¥°¥á¥ó¥È¡¦¥»¥ì¥¯¥¿ + * D : ¥²¡¼¥È¤Î¥µ¥¤¥º¡¥0 = 16 bit, 1 = 32 bit */ -static void interrupt_task(descriptor_t *gdp, int softintp, int errorp, int error_code); -static void interrupt_intr_or_trap(descriptor_t *gdp, int softintp, int errorp, int error_code); +static void CPUCALL interrupt_task_gate(const descriptor_t *gsdp, int intrtype, int errorp, int error_code); +static void CPUCALL interrupt_intr_or_trap(const descriptor_t *gsdp, int intrtype, int errorp, int error_code); -void -interrupt(int num, int softintp, int errorp, int error_code) +void CPUCALL +interrupt(int num, int intrtype, int errorp, int error_code) { - descriptor_t gd; - DWORD idt_idx; - DWORD new_ip; - WORD new_cs; + descriptor_t gsd; + UINT idt_idx; + UINT32 new_ip; + UINT16 new_cs; + int exc_errcode; - VERBOSE(("interrupt: num = 0x%02x, softintp = %s, errorp = %s, error_code = %02x", num, softintp ? "on" : "off", errorp ? "on" : "off", error_code)); + VERBOSE(("interrupt: num = 0x%02x, intrtype = %s, errorp = %s, error_code = %08x", num, intrtype ? "on" : "off", errorp ? "on" : "off", error_code)); + + CPU_SET_PREV_ESP(); if (!CPU_STAT_PM) { /* real mode */ + CPU_WORKCLOCK(20); + idt_idx = num * 4; if (idt_idx + 3 > CPU_IDTR_LIMIT) { VERBOSE(("interrupt: real-mode IDTR limit check failure (idx = 0x%04x, limit = 0x%08x", idt_idx, CPU_IDTR_LIMIT)); - EXCEPTION(GP_EXCEPTION, num * 4 | 2); + EXCEPTION(GP_EXCEPTION, idt_idx + 2); } - if (!softintp) { - BYTE op = cpu_codefetch(CPU_IP); - if (op == 0xf4) { /* hlt */ - CPU_EIP++; - } + if ((intrtype == INTR_TYPE_EXTINTR) && CPU_STAT_HLT) { + VERBOSE(("interrupt: reset HTL in real mode")); + CPU_EIP++; + CPU_STAT_HLT = 0; } REGPUSH0(REAL_FLAGREG); @@ -243,34 +247,47 @@ interrupt(int num, int softintp, int err CPU_EFLAG &= ~(T_FLAG | I_FLAG | AC_FLAG | RF_FLAG); CPU_TRAP = 0; - new_ip = cpu_memoryread_w(CPU_IDTR_BASE + num * 4); - new_cs = cpu_memoryread_w(CPU_IDTR_BASE + num * 4 + 2); - CPU_SET_SEGREG(CPU_CS_INDEX, new_cs); - SET_EIP(new_ip); - CPU_WORKCLOCK(20); + new_ip = cpu_memoryread_w(CPU_IDTR_BASE + idt_idx); + new_cs = cpu_memoryread_w(CPU_IDTR_BASE + idt_idx + 2); + LOAD_SEGREG(CPU_CS_INDEX, new_cs); + CPU_EIP = new_ip; } else { /* protected mode */ + CPU_WORKCLOCK(200); - /* VM86 && IOPL < 3 && interrupt cause == INTn */ - if (CPU_STAT_VM86 && (CPU_STAT_IOPL < CPU_IOPL3) && (softintp == -1)) { - VERBOSE(("interrupt: VM86 && IOPL < 3 && INTn")); - EXCEPTION(GP_EXCEPTION, 0); + VERBOSE(("interrupt: -------------------------------------------------------------- start")); + VERBOSE(("interrupt: old EIP = %04x:%08x, ESP = %04x:%08x", CPU_CS, CPU_EIP, CPU_SS, CPU_ESP)); + +#if defined(DEBUG) + if (num == 0x80) { + /* Linux, FreeBSD, NetBSD, OpenBSD system call */ + VERBOSE(("interrupt: syscall# = %d\n%s", CPU_EAX, cpu_reg2str())); } +#endif idt_idx = num * 8; + exc_errcode = idt_idx + 2; + if (intrtype == INTR_TYPE_EXTINTR) + exc_errcode++; + if (idt_idx + 7 > CPU_IDTR_LIMIT) { VERBOSE(("interrupt: IDTR limit check failure (idx = 0x%04x, limit = 0x%08x", idt_idx, CPU_IDTR_LIMIT)); - EXCEPTION(GP_EXCEPTION, num * 8 | 2 | !softintp); + EXCEPTION(GP_EXCEPTION, exc_errcode); } - memset(&gd, 0, sizeof(gd)); - CPU_SET_GATEDESC(&gd, CPU_IDTR_BASE + idt_idx, CPU_MODE_SUPERVISER); - if (!gd.valid || !gd.p) { + /* load a gate descriptor from interrupt descriptor table */ + memset(&gsd, 0, sizeof(gsd)); + load_descriptor(&gsd, CPU_IDTR_BASE + idt_idx); + if (!SEG_IS_VALID(&gsd)) { VERBOSE(("interrupt: gate descripter is invalid.")); - EXCEPTION(GP_EXCEPTION, num * 8 | 2 | !softintp); + EXCEPTION(GP_EXCEPTION, exc_errcode); + } + if (!SEG_IS_SYSTEM(&gsd)) { + VERBOSE(("interrupt: gate descriptor is not system segment.")); + EXCEPTION(GP_EXCEPTION, exc_errcode); } - switch (gd.type) { + switch (gsd.type) { case CPU_SYSDESC_TYPE_TASK: case CPU_SYSDESC_TYPE_INTR_16: case CPU_SYSDESC_TYPE_INTR_32: @@ -279,49 +296,62 @@ interrupt(int num, int softintp, int err break; default: - VERBOSE(("interrupt: invalid gate type (%d)", gd.type)); - EXCEPTION(GP_EXCEPTION, num * 8 | 2 | !softintp); + VERBOSE(("interrupt: invalid gate type (%d)", gsd.type)); + EXCEPTION(GP_EXCEPTION, exc_errcode); break; } - /* 5.10.1.1. Îã³°¡¿³ä¤ê¹þ¤ß¥Ï¥ó¥É¥é¡¦¥×¥í¥·¡¼¥¸¥ã¤ÎÊݸî */ - if (softintp && (gd.dpl < CPU_STAT_CPL)) { - VERBOSE(("interrupt: softintp && DPL(%d) < CPL(%d)", gd.dpl, CPU_STAT_CPL)); - EXCEPTION(GP_EXCEPTION, num * 8 | 2); + /* 5.10.1.1. 価¿³ä¤ê¹þ¤ß¥Ï¥ó¥É¥é¡¦¥×¥í¥·¡¼¥¸¥ã¤ÎÊݸî */ + if ((intrtype != INTR_TYPE_EXTINTR) && (gsd.dpl < CPU_STAT_CPL)) { + VERBOSE(("interrupt: intrtype(%d) && DPL(%d) < CPL(%d)", intrtype, gsd.dpl, CPU_STAT_CPL)); + EXCEPTION(GP_EXCEPTION, exc_errcode); } - switch (gd.type) { + if (!SEG_IS_PRESENT(&gsd)) { + VERBOSE(("interrupt: gate descriptor is not present.")); + EXCEPTION(NP_EXCEPTION, exc_errcode); + } + + if ((intrtype == INTR_TYPE_EXTINTR) && CPU_STAT_HLT) { + VERBOSE(("interrupt: reset HTL in protected mode")); + CPU_EIP++; + CPU_STAT_HLT = 0; + } + + switch (gsd.type) { case CPU_SYSDESC_TYPE_TASK: - interrupt_task(&gd, softintp, errorp, error_code); + interrupt_task_gate(&gsd, intrtype, errorp, error_code); break; case CPU_SYSDESC_TYPE_INTR_16: case CPU_SYSDESC_TYPE_INTR_32: case CPU_SYSDESC_TYPE_TRAP_16: case CPU_SYSDESC_TYPE_TRAP_32: - interrupt_intr_or_trap(&gd, softintp, errorp, error_code); + interrupt_intr_or_trap(&gsd, intrtype, errorp, error_code); break; default: - EXCEPTION(GP_EXCEPTION, num * 8 | 2 | !softintp); + EXCEPTION(GP_EXCEPTION, exc_errcode); break; } + + VERBOSE(("interrupt: ---------------------------------------------------------------- end")); } + + CPU_CLEAR_PREV_ESP(); } -static void -interrupt_task(descriptor_t *gdp, int softintp, int errorp, int error_code) +static void CPUCALL +interrupt_task_gate(const descriptor_t *gsdp, int intrtype, int errorp, int error_code) { selector_t task_sel; int rv; VERBOSE(("interrupt: TASK-GATE")); - (void)softintp; - - rv = parse_selector_sv(&task_sel, gdp->u.gate.selector); - if (rv < 0 || task_sel.ldt) { - VERBOSE(("interrupt: parse_selector (selector = %04x, rv = %d, %cDT)", gdp->u.gate.selector, rv, task_sel.ldt ? 'L' : 'G')); + rv = parse_selector(&task_sel, gsdp->u.gate.selector); + if (rv < 0 || task_sel.ldt || !SEG_IS_SYSTEM(&task_sel.desc)) { + VERBOSE(("interrupt: parse_selector (selector = %04x, rv = %d, %cDT, type = %s)", gsdp->u.gate.selector, rv, task_sel.ldt ? 'L' : 'G', task_sel.desc.s ? "code/data" : "system")); EXCEPTION(TS_EXCEPTION, task_sel.idx); } @@ -349,182 +379,188 @@ interrupt_task(descriptor_t *gdp, int so task_switch(&task_sel, TASK_SWITCH_INTR); + CPU_SET_PREV_ESP(); + if (errorp) { XPUSH0(error_code); } + + /* out of range */ + if (CPU_EIP > CPU_STAT_CS_LIMIT) { + VERBOSE(("interrupt: new_ip is out of range. new_ip = %08x, limit = %08x", CPU_EIP, CPU_STAT_CS_LIMIT)); + EXCEPTION(GP_EXCEPTION, 0); + } } -static void -interrupt_intr_or_trap(descriptor_t *gdp, int softintp, int errorp, int error_code) +static void CPUCALL +interrupt_intr_or_trap(const descriptor_t *gsdp, int intrtype, int errorp, int error_code) { - selector_t intr_sel, ss_sel; - DWORD old_flags = REAL_EFLAGREG; - DWORD flags = REAL_EFLAGREG; - DWORD mask = 0; - DWORD stacksize; - DWORD new_ip, new_sp; - DWORD old_ip, old_sp; - WORD old_cs, old_ss, new_ss; + selector_t cs_sel, ss_sel; + UINT stacksize; + UINT32 old_flags; + UINT32 new_flags; + UINT32 mask; + UINT32 sp; + UINT32 new_ip, new_sp; + UINT32 old_ip, old_sp; + UINT16 old_cs, old_ss, new_ss; + int exc_errcode; int rv; - VERBOSE(("interrupt: old EIP = %04x:%08x, ESP = %04x:%08x", CPU_CS, CPU_PREV_EIP, CPU_SS, CPU_ESP)); - - new_ip = gdp->u.gate.offset; + new_ip = gsdp->u.gate.offset; old_ss = CPU_SS; old_cs = CPU_CS; old_ip = CPU_EIP; old_sp = CPU_ESP; + old_flags = REAL_EFLAGREG; + new_flags = REAL_EFLAGREG & ~(T_FLAG|RF_FLAG|NT_FLAG|VM_FLAG); + mask = T_FLAG|RF_FLAG|NT_FLAG|VM_FLAG; - switch (gdp->type) { + switch (gsdp->type) { case CPU_SYSDESC_TYPE_INTR_16: - old_ip &= 0xffff; - old_sp &= 0xffff; - /*FALLTHROUGH*/ case CPU_SYSDESC_TYPE_INTR_32: VERBOSE(("interrupt: INTERRUPT-GATE")); - flags &= ~I_FLAG; + new_flags &= ~I_FLAG; mask |= I_FLAG; break; case CPU_SYSDESC_TYPE_TRAP_16: - old_ip &= 0xffff; - old_sp &= 0xffff; - /*FALLTHROUGH*/ case CPU_SYSDESC_TYPE_TRAP_32: VERBOSE(("interrupt: TRAP-GATE")); break; + + default: + ia32_panic("interrupt: gate descriptor type is invalid (type = %d)", gsdp->type); + break; } - flags &= ~(T_FLAG|RF_FLAG|NT_FLAG|VM_FLAG); - mask |= T_FLAG|RF_FLAG|NT_FLAG|VM_FLAG; - rv = parse_selector_sv(&intr_sel, gdp->u.gate.selector); + exc_errcode = gsdp->u.gate.selector & ~3; + if (intrtype == INTR_TYPE_EXTINTR) + exc_errcode++; + + rv = parse_selector(&cs_sel, gsdp->u.gate.selector); if (rv < 0) { - VERBOSE(("interrupt: parse_selector (selector = %04x, rv = %d)", gdp->u.gate.selector, rv)); - EXCEPTION(GP_EXCEPTION, intr_sel.idx | !softintp); + VERBOSE(("interrupt: parse_selector (selector = %04x, rv = %d)", gsdp->u.gate.selector, rv)); + EXCEPTION(GP_EXCEPTION, exc_errcode); } /* check segment type */ - if (!intr_sel.desc.s) { + if (SEG_IS_SYSTEM(&cs_sel.desc)) { VERBOSE(("interrupt: code segment is system segment")); - EXCEPTION(GP_EXCEPTION, intr_sel.idx | !softintp); + EXCEPTION(GP_EXCEPTION, exc_errcode); } - if (!intr_sel.desc.u.seg.c) { + if (SEG_IS_DATA(&cs_sel.desc)) { VERBOSE(("interrupt: code segment is data segment")); - EXCEPTION(GP_EXCEPTION, intr_sel.idx | !softintp); + EXCEPTION(GP_EXCEPTION, exc_errcode); } /* check privilege level */ - if (intr_sel.desc.dpl > CPU_STAT_CPL) { - VERBOSE(("interrupt: DPL(%d) > CPL(%d)", intr_sel.desc.dpl, CPU_STAT_CPL)); - EXCEPTION(GP_EXCEPTION, intr_sel.idx | !softintp); + if (cs_sel.desc.dpl > CPU_STAT_CPL) { + VERBOSE(("interrupt: DPL(%d) > CPL(%d)", cs_sel.desc.dpl, CPU_STAT_CPL)); + EXCEPTION(GP_EXCEPTION, exc_errcode); } /* not present */ - if (selector_is_not_present(&intr_sel)) { + if (selector_is_not_present(&cs_sel)) { VERBOSE(("interrupt: selector is not present")); - EXCEPTION(NP_EXCEPTION, intr_sel.idx | !softintp); + EXCEPTION(NP_EXCEPTION, exc_errcode); } - if (!intr_sel.desc.u.seg.ec - && (intr_sel.desc.dpl < CPU_STAT_CPL)) { + if (!SEG_IS_CONFORMING_CODE(&cs_sel.desc) && (cs_sel.desc.dpl < CPU_STAT_CPL)) { + stacksize = errorp ? 12 : 10; if (!CPU_STAT_VM86) { VERBOSE(("interrupt: INTER-PRIVILEGE-LEVEL-INTERRUPT")); - stacksize = errorp ? 12 : 10; } else { /* VM86 */ - if (intr_sel.desc.dpl != 0) { + VERBOSE(("interrupt: INTERRUPT-FROM-VIRTUAL-8086-MODE")); + if (cs_sel.desc.dpl != 0) { /* 16.3.1.1 */ - VERBOSE(("interrupt: DPL[CS](%d) != 0", intr_sel.desc.dpl)); - EXCEPTION(GP_EXCEPTION, intr_sel.idx); + VERBOSE(("interrupt: DPL[CS](%d) != 0", cs_sel.desc.dpl)); + EXCEPTION(GP_EXCEPTION, exc_errcode); } - VERBOSE(("interrupt: INTERRUPT-FROM-VIRTUAL-8086-MODE")); - stacksize = errorp ? 20 : 18; + stacksize += 8; } - switch (gdp->type) { - case CPU_SYSDESC_TYPE_INTR_32: - case CPU_SYSDESC_TYPE_TRAP_32: + if (gsdp->type & CPU_SYSDESC_TYPE_32BIT) { stacksize *= 2; - break; } - get_stack_from_tss(intr_sel.desc.dpl, &new_ss, &new_sp); + /* get stack pointer from TSS */ + get_stack_pointer_from_tss(cs_sel.desc.dpl, &new_ss, &new_sp); + + /* parse stack segment descriptor */ + rv = parse_selector(&ss_sel, new_ss); + + /* update exception error code */ + exc_errcode = ss_sel.idx; + if (intrtype == INTR_TYPE_EXTINTR) + exc_errcode++; - rv = parse_selector_sv(&ss_sel, new_ss); if (rv < 0) { VERBOSE(("interrupt: parse_selector (selector = %04x, rv = %d)", new_ss, rv)); - EXCEPTION(TS_EXCEPTION, ss_sel.idx | !softintp); + EXCEPTION(TS_EXCEPTION, exc_errcode); } /* check privilege level */ - if (ss_sel.rpl != intr_sel.desc.dpl) { - VERBOSE(("interrupt: RPL[SS](%d) != DPL[CS](%d)", ss_sel.rpl, intr_sel.desc.dpl)); - EXCEPTION(TS_EXCEPTION, ss_sel.idx | !softintp); + if (ss_sel.rpl != cs_sel.desc.dpl) { + VERBOSE(("interrupt: selector RPL[SS](%d) != DPL[CS](%d)", ss_sel.rpl, cs_sel.desc.dpl)); + EXCEPTION(TS_EXCEPTION, exc_errcode); } - if (ss_sel.desc.dpl != intr_sel.desc.dpl) { - VERBOSE(("interrupt: DPL[SS](%d) != DPL[CS](%d)", ss_sel.desc.dpl, intr_sel.desc.dpl)); - EXCEPTION(TS_EXCEPTION, ss_sel.idx | !softintp); + if (ss_sel.desc.dpl != cs_sel.desc.dpl) { + VERBOSE(("interrupt: descriptor DPL[SS](%d) != DPL[CS](%d)", ss_sel.desc.dpl, cs_sel.desc.dpl)); + EXCEPTION(TS_EXCEPTION, exc_errcode); } - /* check segment type */ - if (!ss_sel.desc.s) { + /* stack segment must be writable data segment. */ + if (SEG_IS_SYSTEM(&ss_sel.desc)) { VERBOSE(("interrupt: stack segment is system segment")); - EXCEPTION(TS_EXCEPTION, ss_sel.idx | !softintp); + EXCEPTION(TS_EXCEPTION, exc_errcode); } - if (ss_sel.desc.u.seg.c) { + if (SEG_IS_CODE(&ss_sel.desc)) { VERBOSE(("interrupt: stack segment is code segment")); - EXCEPTION(TS_EXCEPTION, ss_sel.idx | !softintp); + EXCEPTION(TS_EXCEPTION, exc_errcode); } - if (!ss_sel.desc.u.seg.wr) { + if (!SEG_IS_WRITABLE_DATA(&ss_sel.desc)) { VERBOSE(("interrupt: stack segment is read-only data segment")); - EXCEPTION(TS_EXCEPTION, ss_sel.idx | !softintp); + EXCEPTION(TS_EXCEPTION, exc_errcode); } /* not present */ if (selector_is_not_present(&ss_sel)) { VERBOSE(("interrupt: selector is not present")); - EXCEPTION(SS_EXCEPTION, ss_sel.idx | !softintp); + EXCEPTION(SS_EXCEPTION, exc_errcode); } /* check stack room size */ - CHECK_STACK_PUSH(&ss_sel.desc, new_sp, stacksize); + cpu_stack_push_check(ss_sel.idx, &ss_sel.desc, new_sp, stacksize); /* out of range */ - if (new_ip > intr_sel.desc.u.seg.limit) { - VERBOSE(("interrupt: new_ip is out of range. new_ip = %08x, limit = %08x", new_ip, intr_sel.desc.u.seg.limit)); + if (new_ip > cs_sel.desc.u.seg.limit) { + VERBOSE(("interrupt: new_ip is out of range. new_ip = %08x, limit = %08x", new_ip, cs_sel.desc.u.seg.limit)); EXCEPTION(GP_EXCEPTION, 0); } - load_ss(ss_sel.selector, &ss_sel.desc, intr_sel.desc.dpl); + load_ss(ss_sel.selector, &ss_sel.desc, cs_sel.desc.dpl); CPU_ESP = new_sp; - load_cs(intr_sel.selector, &intr_sel.desc, intr_sel.desc.dpl); - SET_EIP(new_ip); + load_cs(cs_sel.selector, &cs_sel.desc, cs_sel.desc.dpl); + CPU_EIP = new_ip; - if (CPU_STAT_VM86) { - switch (gdp->type) { - case CPU_SYSDESC_TYPE_INTR_32: - case CPU_SYSDESC_TYPE_TRAP_32: + if (gsdp->type & CPU_SYSDESC_TYPE_32BIT) { + if (CPU_STAT_VM86) { PUSH0_32(CPU_GS); PUSH0_32(CPU_FS); PUSH0_32(CPU_DS); PUSH0_32(CPU_ES); - break; - case CPU_SYSDESC_TYPE_INTR_16: - case CPU_SYSDESC_TYPE_TRAP_16: - ia32_panic("interrupt: 16bit gate"); - break; + LOAD_SEGREG(CPU_GS_INDEX, 0); + CPU_STAT_SREG(CPU_GS_INDEX).valid = 0; + LOAD_SEGREG(CPU_FS_INDEX, 0); + CPU_STAT_SREG(CPU_FS_INDEX).valid = 0; + LOAD_SEGREG(CPU_DS_INDEX, 0); + CPU_STAT_SREG(CPU_DS_INDEX).valid = 0; + LOAD_SEGREG(CPU_ES_INDEX, 0); + CPU_STAT_SREG(CPU_ES_INDEX).valid = 0; } - - CPU_SET_SEGREG(CPU_GS_INDEX, 0); - CPU_SET_SEGREG(CPU_FS_INDEX, 0); - CPU_SET_SEGREG(CPU_DS_INDEX, 0); - CPU_SET_SEGREG(CPU_ES_INDEX, 0); - } - - switch (gdp->type) { - case CPU_SYSDESC_TYPE_INTR_32: - case CPU_SYSDESC_TYPE_TRAP_32: PUSH0_32(old_ss); PUSH0_32(old_sp); PUSH0_32(old_flags); @@ -533,10 +569,10 @@ interrupt_intr_or_trap(descriptor_t *gdp if (errorp) { PUSH0_32(error_code); } - break; - - case CPU_SYSDESC_TYPE_INTR_16: - case CPU_SYSDESC_TYPE_TRAP_16: + } else { + if (CPU_STAT_VM86) { + ia32_panic("interrupt: 16bit gate && VM86"); + } PUSH0_16(old_ss); PUSH0_16(old_sp); PUSH0_16(old_flags); @@ -545,69 +581,58 @@ interrupt_intr_or_trap(descriptor_t *gdp if (errorp) { PUSH0_16(error_code); } - break; } - - set_eflags(flags, mask); } else { if (CPU_STAT_VM86) { VERBOSE(("interrupt: VM86")); - EXCEPTION(GP_EXCEPTION, intr_sel.idx); + EXCEPTION(GP_EXCEPTION, exc_errcode); } - if (!intr_sel.desc.u.seg.ec && (intr_sel.desc.dpl != CPU_STAT_CPL)) { - VERBOSE(("interrupt: NON-CONFORMING-CODE-SEGMENT(%s) and DPL[CS](%d) != CPL", intr_sel.desc.u.seg.ec ? "false" : "true", intr_sel.desc.dpl, CPU_STAT_CPL)); - EXCEPTION(GP_EXCEPTION, intr_sel.idx); + if (!SEG_IS_CONFORMING_CODE(&cs_sel.desc) && (cs_sel.desc.dpl != CPU_STAT_CPL)) { + VERBOSE(("interrupt: %sCONFORMING-CODE-SEGMENT(%d) && DPL[CS](%d) != CPL", SEG_IS_CONFORMING_CODE(&cs_sel.desc) ? "" : "NON-", cs_sel.desc.dpl, CPU_STAT_CPL)); + EXCEPTION(GP_EXCEPTION, exc_errcode); } - VERBOSE(("interrupt: INTRA-PRIVILEGE-LEVEL-INTERRUPT")); - if (CPU_STAT_SS32) { - new_sp = CPU_ESP; - } else { - new_sp = CPU_SP; - } + VERBOSE(("interrupt: INTRA-PRIVILEGE-LEVEL-INTERRUPT")); stacksize = errorp ? 8 : 6; - switch (gdp->type) { - case CPU_SYSDESC_TYPE_INTR_32: - case CPU_SYSDESC_TYPE_TRAP_32: + if (gsdp->type & CPU_SYSDESC_TYPE_32BIT) { stacksize *= 2; - break; } - CHECK_STACK_PUSH(&CPU_STAT_SREG(CPU_SS_INDEX), new_sp, stacksize); + + /* check stack room size */ + if (CPU_STAT_SS32) { + sp = CPU_ESP; + } else { + sp = CPU_SP; + } + SS_PUSH_CHECK(sp, stacksize); /* out of range */ - if (new_ip > intr_sel.desc.u.seg.limit) { - VERBOSE(("interrupt: new_ip is out of range. new_ip = %08x, limit = %08x", new_ip, intr_sel.desc.u.seg.limit)); + if (new_ip > cs_sel.desc.u.seg.limit) { + VERBOSE(("interrupt: new_ip is out of range. new_ip = %08x, limit = %08x", new_ip, cs_sel.desc.u.seg.limit)); EXCEPTION(GP_EXCEPTION, 0); } - switch (gdp->type) { - case CPU_SYSDESC_TYPE_INTR_32: - case CPU_SYSDESC_TYPE_TRAP_32: - PUSH0_32(REAL_EFLAGREG); - PUSH0_32(CPU_CS); - PUSH0_32(CPU_EIP); + load_cs(cs_sel.selector, &cs_sel.desc, CPU_STAT_CPL); + CPU_EIP = new_ip; + + if (gsdp->type & CPU_SYSDESC_TYPE_32BIT) { + PUSH0_32(old_flags); + PUSH0_32(old_cs); + PUSH0_32(old_ip); if (errorp) { PUSH0_32(error_code); } - break; - - case CPU_SYSDESC_TYPE_INTR_16: - case CPU_SYSDESC_TYPE_TRAP_16: - PUSH0_16(REAL_FLAGREG); - PUSH0_16(CPU_CS); - PUSH0_16(CPU_IP); + } else { + PUSH0_16(old_flags); + PUSH0_16(old_cs); + PUSH0_16(old_ip); if (errorp) { PUSH0_16(error_code); } - break; } - - load_cs(intr_sel.selector, &intr_sel.desc, CPU_STAT_CPL); - SET_EIP(new_ip); - - set_eflags(flags, mask); } + set_eflags(new_flags, mask); - VERBOSE(("interrupt: new EIP = %04x:%08x, new ESP = %04x:%08x", CPU_CS, CPU_EIP, CPU_SS, CPU_ESP)); + VERBOSE(("interrupt: new EIP = %04x:%08x, ESP = %04x:%08x", CPU_CS, CPU_EIP, CPU_SS, CPU_ESP)); }