Changeset b808660 in mainline for kernel/arch/ia32/src/pm.c

Timestamp:

2010-07-08T20:03:52Z (15 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

bee2d4c

Parents:

9097982f

Message:

Do not align ia32 int handlers on any pre-defined power-of-two boundary but
rather define each one as a separate procedure with its own global label. The
label is used to populate the IDT and it also helps to maintain consistency
between C and assembly.

The old way was very error-prone because one did not get a warning when a
handler exceeded the size limit given by the alignment, which usually resulted
in very weird crashes.

In principle, the old way was also rather wasteful as the handler had to be
aligned on a power-of-two address. With the int handler size around 160 bytes,
the bytes 160 - 255 in each handler were simply wasted. In practice, however,
the image.iso size did not change (I'd expect it to drop by around 8K).

The old way did not detect a mistmatch between the C code idea of how many IDT
entries there are and the assembly language code idea of the same thing. It was
possible to initialize an IDT entry to point to some garbage and nobody would
notice until the int occurred.

The new method was a bit tiresome to write as there was a lot of copy'n'paste.
But since it was a one-time effort, I lumped it. If you know of a way to write a
for-loop in C preprocessor or use GAS assmebler macros in a sensible way, I will
gladly use your improvement.

File:

• kernel/arch/ia32/src/pm.c (modified) (1 diff)

kernel/arch/ia32/src/pm.c

@@ -139 +139 @@
                         d->access |= DPL_USER;
                 }
-                
-                idt_setoffset(d, ((uintptr_t) interrupt_handlers) +
-                    i * interrupt_handler_size);
         }
-}
-
+
+        d = &idt[0];
+        idt_setoffset(d++, (uintptr_t) &int_0);
+        idt_setoffset(d++, (uintptr_t) &int_1);
+        idt_setoffset(d++, (uintptr_t) &int_2);
+        idt_setoffset(d++, (uintptr_t) &int_3);
+        idt_setoffset(d++, (uintptr_t) &int_4);
+        idt_setoffset(d++, (uintptr_t) &int_5);
+        idt_setoffset(d++, (uintptr_t) &int_6);
+        idt_setoffset(d++, (uintptr_t) &int_7);
+        idt_setoffset(d++, (uintptr_t) &int_8);
+        idt_setoffset(d++, (uintptr_t) &int_9);
+        idt_setoffset(d++, (uintptr_t) &int_10);
+        idt_setoffset(d++, (uintptr_t) &int_11);
+        idt_setoffset(d++, (uintptr_t) &int_12);
+        idt_setoffset(d++, (uintptr_t) &int_13);
+        idt_setoffset(d++, (uintptr_t) &int_14);
+        idt_setoffset(d++, (uintptr_t) &int_15);
+        idt_setoffset(d++, (uintptr_t) &int_16);
+        idt_setoffset(d++, (uintptr_t) &int_17);
+        idt_setoffset(d++, (uintptr_t) &int_18);
+        idt_setoffset(d++, (uintptr_t) &int_19);
+        idt_setoffset(d++, (uintptr_t) &int_20);
+        idt_setoffset(d++, (uintptr_t) &int_21);
+        idt_setoffset(d++, (uintptr_t) &int_22);
+        idt_setoffset(d++, (uintptr_t) &int_23);
+        idt_setoffset(d++, (uintptr_t) &int_24);
+        idt_setoffset(d++, (uintptr_t) &int_25);
+        idt_setoffset(d++, (uintptr_t) &int_26);
+        idt_setoffset(d++, (uintptr_t) &int_27);
+        idt_setoffset(d++, (uintptr_t) &int_28);
+        idt_setoffset(d++, (uintptr_t) &int_29);
+        idt_setoffset(d++, (uintptr_t) &int_30);
+        idt_setoffset(d++, (uintptr_t) &int_31);
+        idt_setoffset(d++, (uintptr_t) &int_32);
+        idt_setoffset(d++, (uintptr_t) &int_33);
+        idt_setoffset(d++, (uintptr_t) &int_34);
+        idt_setoffset(d++, (uintptr_t) &int_35);
+        idt_setoffset(d++, (uintptr_t) &int_36);
+        idt_setoffset(d++, (uintptr_t) &int_37);
+        idt_setoffset(d++, (uintptr_t) &int_38);
+        idt_setoffset(d++, (uintptr_t) &int_39);
+        idt_setoffset(d++, (uintptr_t) &int_40);
+        idt_setoffset(d++, (uintptr_t) &int_41);
+        idt_setoffset(d++, (uintptr_t) &int_42);
+        idt_setoffset(d++, (uintptr_t) &int_43);
+        idt_setoffset(d++, (uintptr_t) &int_44);
+        idt_setoffset(d++, (uintptr_t) &int_45);
+        idt_setoffset(d++, (uintptr_t) &int_46);
+        idt_setoffset(d++, (uintptr_t) &int_47);
+        idt_setoffset(d++, (uintptr_t) &int_48);
+        idt_setoffset(d++, (uintptr_t) &int_49);
+        idt_setoffset(d++, (uintptr_t) &int_50);
+        idt_setoffset(d++, (uintptr_t) &int_51);
+        idt_setoffset(d++, (uintptr_t) &int_52);
+        idt_setoffset(d++, (uintptr_t) &int_53);
+        idt_setoffset(d++, (uintptr_t) &int_54);
+        idt_setoffset(d++, (uintptr_t) &int_55);
+        idt_setoffset(d++, (uintptr_t) &int_56);
+        idt_setoffset(d++, (uintptr_t) &int_57);
+        idt_setoffset(d++, (uintptr_t) &int_58);
+        idt_setoffset(d++, (uintptr_t) &int_59);
+        idt_setoffset(d++, (uintptr_t) &int_60);
+        idt_setoffset(d++, (uintptr_t) &int_61);
+        idt_setoffset(d++, (uintptr_t) &int_62);
+        idt_setoffset(d++, (uintptr_t) &int_63);
+}
 
 /* Clean IOPL(12,13) and NT(14) flags in EFLAGS register */