Mouse Location Always Zero

[Octacone]

When I disable load protected mode function (assembly code) my OS doesn't crash any more.
Here is my code:
//note: gdt_flush gets called from when I initialize my GDT

Code: Select all

global _gdt_flush 
extern _gp    
_gdt_flush:
    lgdt [_gp]
    mov ax, 0x10
    mov ds, ax
    mov es, ax
    mov fs, ax
    mov gs, ax
    mov ss, ax
    jmp 0x08:flushblank

flushblank:
    ret

main:
    cli 
    xor ax, ax
    mov ds, ax
    mov es, ax
    mov ax, 0x9000
    mov ss, ax
    mov sp, 0xFFFF
    sti

    call_gdt_flush

    cli
    mov eax, cr0
    or al, 1
    mov cr0, eax

    jmp 08h: Stage3User


BITS 32
Stage3User:
    mov ax, 0x10
    mov ds, ax
    mov ss, ax
    mov es, ax
    mov esp, 90000h

I think that this code is a bit broken. When I call "main" from my start function then I get infinite restart loop.

[Mikumiku747]

If you keep getting restarts, I'm pretty sure that means you're triple faulting, which definitely means that something isn't getting set up correctly. (You mentioned that you see your UI for a split second and then it restarts, which means that your kernel is probably getting loaded and doing something to cause the triple fault, or so I'd think.) The reason you don't get restarts in real mode is (if I had to make an informed guess) is that in protected mode, you're getting some kind of General Protection Exception, because when your interrupt gets called, something isn't set up correctly, and the CPU jumps to some memory which it shouldn't be accessing, causing a restart.)

It would be a good idea to place a breakpoint just before you enable interrupts (either with gdb/bochs magic breakpoint) and check that your IDT, GDT (because the IDT uses selectors from the GDT) and the interrupt controllers themselves are set up correctly. I'll mostly just be reiterating points from the article on the wiki for troubleshooting interrupts.

For example, make sure the address in the IDT is actually the correct structure (you might want to try using a memory viewer like the x command in gdb or bochs, and make sure everything lines up perfectly, because your debugger will just show you the C structs you used if you did it that way, and they could be the wrong size because the compiler doesn't always pack structs as tightly as you expect).

Make sure that your GDT has valid values (I'm assuming you made your own GDT and loaded it already, because the one provided by your bootloader is only there to get your kernel going, and you should load your own soon after boot).

You should check the PICs also have the values that you expect them to, namely, they are remapped and have the appropriate masks set. Most emulators have some kind of info command to show you the status of hardware, for bochs, I think it's "info device 'pic'" (there are quotes around pic) and for qemu it's just "info pic". Make sure that the masks are set correctly (there are mask bytes in the pic which decide which hardware interrupts will signal the CPU, and which interrupt vector to use), if they're not, you'll get an interrupt from the timer pretty quickly, and if you haven't written an IDT entry or handler for it, that will end badly. Also make sure that they have been programmed to respond to the correct interrupt vectors, by default, the pics will signal interrupts 0 to 15, but unfortunately, the CPU has reserved interrupts 0 to 31 for exceptions, which means you need to tell the PIC controller to send different interrupt numbers instead.

Once you've checked all those things (you can use the wiki for more information on what all of those things should be set to for your system) or you're having trouble understanding what things are supposed to be set to, come back and let us know whether interrupts are still making your system restart. Although I'm not really an expert, I just thought I'd tell you about the pitfalls I had when I was setting up interrupts.

[Octacone]

If you keep getting restarts, I'm pretty sure that means you're triple faulting, which definitely means that something isn't getting set up correctly. (You mentioned that you see your UI for a split second and then it restarts, which means that your kernel is probably getting loaded and doing something to cause the triple fault, or so I'd think.) The reason you don't get restarts in real mode is (if I had to make an informed guess) is that in protected mode, you're getting some kind of General Protection Exception, because when your interrupt gets called, something isn't set up correctly, and the CPU jumps to some memory which it shouldn't be accessing, causing a restart.)

It would be a good idea to place a breakpoint just before you enable interrupts (either with gdb/bochs magic breakpoint) and check that your IDT, GDT (because the IDT uses selectors from the GDT) and the interrupt controllers themselves are set up correctly. I'll mostly just be reiterating points from the article on the wiki for troubleshooting interrupts.

For example, make sure the address in the IDT is actually the correct structure (you might want to try using a memory viewer like the x command in gdb or bochs, and make sure everything lines up perfectly, because your debugger will just show you the C structs you used if you did it that way, and they could be the wrong size because the compiler doesn't always pack structs as tightly as you expect).

Make sure that your GDT has valid values (I'm assuming you made your own GDT and loaded it already, because the one provided by your bootloader is only there to get your kernel going, and you should load your own soon after boot).

You should check the PICs also have the values that you expect them to, namely, they are remapped and have the appropriate masks set. Most emulators have some kind of info command to show you the status of hardware, for bochs, I think it's "info device 'pic'" (there are quotes around pic) and for qemu it's just "info pic". Make sure that the masks are set correctly (there are mask bytes in the pic which decide which hardware interrupts will signal the CPU, and which interrupt vector to use), if they're not, you'll get an interrupt from the timer pretty quickly, and if you haven't written an IDT entry or handler for it, that will end badly. Also make sure that they have been programmed to respond to the correct interrupt vectors, by default, the pics will signal interrupts 0 to 15, but unfortunately, the CPU has reserved interrupts 0 to 31 for exceptions, which means you need to tell the PIC controller to send different interrupt numbers instead.

Once you've checked all those things (you can use the wiki for more information on what all of those things should be set to for your system) or you're having trouble understanding what things are supposed to be set to, come back and let us know whether interrupts are still making your system restart. Although I'm not really an expert, I just thought I'd tell you about the pitfalls I had when I was setting up interrupts.

Yeah, I know triple fault, when CPU fails and tries to fix itself. Let just assume that my protected mode code is alright. I don't have any IRQ masks set up, my custom GDT is set up. I enabled Bochs debug tool, it shows something PIT related: http://pastebin.com/LqDz8DXi I did not write any IDT handlers for different types of exceptions, how to do that? Haven't seen a sample code yet. I remapped my PICs. I never thought that interrupts would be this big of a deal. Thanks for replying.

[Combuster]

Let just assume

I refuse!

Assumption is the mother of all ....

[Octacone]

Let just assume

I refuse!

Assumption is the mother of all ....

[Octacone]

Does any of you pro guys know what this is?

Code: Select all

(0).[240238624] [0x0000000000110196] 0010:0000000000110196 (unk. ctxt): mov ss, ax                ; 8ed0
Next at t=240238625
(0) [0x0000000000110196] 0010:0000000000110196 (unk. ctxt): mov ss, ax                ; 8ed0
<bochs:2> exit
(0).[240238625] [0x0000000000110196] 0010:0000000000110196 (unk. ctxt): mov ss, ax                ; 8ed0

I messed around with triple fault settings in Bochs and got that output after my OS crashed.

[iansjack]

Most likely the value in ax that you are moving into ss is not a valid index into the GDT. What is the value of ax at this point?

[Octacone]

Most likely the value in ax that you are moving into ss is not a valid index into the GDT. What is the value of ax at this point?

To be honest, I don't know what is its value at the moment. I used mov ss, ax in three different places.
Ax is all over my assembly code.

[iansjack]

Most likely the value in ax that you are moving into ss is not a valid index into the GDT. What is the value of ax at this point?

To be honest, I don't know what is its value at the moment.

Aren't you interested in finding out?

[Octacone]

Most likely the value in ax that you are moving into ss is not a valid index into the GDT. What is the value of ax at this point?

To be honest, I don't know what is its value at the moment.

Aren't you interested in finding out?

That is my current life goal, I just don't know how to accomplish it.

[Combuster]

You could at least have read the manual and figure out what commands to give to the debugger to give you that answer. You must've been close as I'm pretty sure it wasn't a fairy that told you what "c" does.

[Octacone]

You could at least have read the manual and figure out what commands to give to the debugger to give you that answer. You must've been close as I'm pretty sure it wasn't a fairy that told you what "c" does.

C = when you want to continue debugging.
I can not really find anything related to ax. Google doesn't want to help.

[sebihepp]

I can not really find anything related to ax. Google doesn't want to help.

Okay, did you notice the register dump in Bochs when an error occurs? Just read the value of AX there. (Most probably called EAX or RAX - just use the lowest 16 Bits of the value)
If it was a breakpoint, then RTFM how to show the content of the registers. In your case it would be "reg" or "regs".

By the way: You need to setup routines for every Interrupt that get's probably called. You write a function that will be called and you write the Adress of the function to the right place in your IDT.

A very dirty trick would be masking every Interrupt, except for Mouse. But I really recommend first get Interrupts working, before using devices that generate interrupts. (like you mouse)

[iansjack]

That is my current life goal, I just don't know how to accomplish it.

Read section 8.13.5. of the Bochs user manual. Better still, read the whole manual. Get to know the tools you are using before doing anything else. That way you will accomplish at least one of your life goals.

[Octacone]

This is interesting right:

Code: Select all

<bochs:2> info gdt
Global Descriptor Table (base=0x0000000000008280, limit=39):
GDT[0x00]=??? descriptor hi=0x00000000, lo=0x00000000
GDT[0x01]=Code segment, base=0x00000000, limit=0xffffffff, Execute/Read, Non-Conforming, Accessed, 32-bit
GDT[0x02]=Data segment, base=0x00000000, limit=0xffffffff, Read/Write, Accessed
GDT[0x03]=Code segment, base=0x00000000, limit=0x0000ffff, Execute/Read, Conforming, Accessed, 16-bit
GDT[0x04]=Data segment, base=0x00000000, limit=0x0000ffff, Read/Write, Accessed
You can list individual entries with 'info gdt [NUM]' or groups with 'info gdt [NUM] [NUM]'
<bochs:3> info idt
Interrupt Descriptor Table (base=0x0000000000000000, limit=0):
You can list individual entries with 'info idt [NUM]' or groups with 'info idt [NUM] [NUM]'

Sometimes when I mess around I can get this:

Code: Select all

<bochs:3> info idt
Interrupt Descriptor Table (base=0x0000000000000000, limit=1023):
IDT[0x00]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x01]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x02]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x03]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x04]=32-Bit TSS (Available) at 0xf087f000, length 0x0fea5
IDT[0x05]=32-Bit TSS (Available) at 0xf0dff000, length 0x0e9df
IDT[0x06]=32-Bit TSS (Available) at 0xf0dff000, length 0x0e9df
IDT[0x07]=32-Bit TSS (Available) at 0xf0dff000, length 0x0ef57
IDT[0x08]=Code segment, base=0xf04dc000, limit=0x00000151, Execute-Only, Non-Conforming, 16-bit
IDT[0x09]=16-Bit TSS (Busy) at 0xf0fef000, length 0x0f841
IDT[0x0a]=Code segment, base=0xf059f000, limit=0x0000e739, Execute-Only, Non-Conforming, 16-bit
IDT[0x0b]=32-Bit Trap Gate target=0xf000:0xf000e82e, DPL=3
IDT[0x0c]=16-Bit Interrupt Gate target=0xf000:0xf0009695, DPL=3
IDT[0x0d]=Code segment, base=0xf053f000, limit=0x0000fe6e, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x0e]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x0f]=Data segment, base=0xc07ff000, limit=0x0000efde, Read/Write, Accessed
IDT[0x10]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x11]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x12]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x13]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x14]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x15]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x16]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x17]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x18]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x19]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x1a]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x1b]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x1c]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x1d]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x1e]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x1f]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x20]=??? descriptor hi=0x9fc0003d, lo=0xf000ec59
IDT[0x21]=Task Gate target=0xf000:0xc000ff53, DPL=1
IDT[0x22]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x23]=Code segment, base=0xf0539fc0, limit=0x0000004d, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x24]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x25]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x26]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x27]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x28]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x29]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x2a]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x2b]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x2c]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x2d]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x2e]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x2f]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x30]=??? descriptor hi=0x00000000, lo=0x00000000
IDT[0x31]=??? descriptor hi=0x00000000, lo=0x00000000
IDT[0x32]=??? descriptor hi=0x00000000, lo=0x00000000
IDT[0x33]=??? descriptor hi=0x00000000, lo=0x00000000
IDT[0x34]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x35]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x36]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x37]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x38]=32-Bit TSS (Available) at 0xf0d6f000, length 0x0fe93
IDT[0x39]=32-Bit TSS (Available) at 0xf0e5f000, length 0x0e9e5
IDT[0x3a]=LDT 
IDT[0x3b]=32-Bit TSS (Available) at 0xf0e5f000, length 0x09a5a
IDT[0x3c]=??? descriptor hi=0x00000000, lo=0xf000ff53
IDT[0x3d]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x3e]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x3f]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x40]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x41]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x42]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x43]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x44]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x45]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x46]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x47]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x48]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x49]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x4a]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x4b]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x4c]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x4d]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x4e]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x4f]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x50]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x51]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x52]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x53]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x54]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x55]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x56]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x57]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x58]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x59]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x5a]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x5b]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x5c]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x5d]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x5e]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x5f]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x60]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x61]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x62]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x63]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x64]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x65]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x66]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x67]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x68]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x69]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x6a]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x6b]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x6c]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x6d]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x6e]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x6f]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x70]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x71]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x72]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x73]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x74]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x75]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x76]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x77]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x78]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x79]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x7a]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x7b]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x7c]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x7d]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x7e]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
IDT[0x7f]=Code segment, base=0xf053f000, limit=0x0000ff53, Execute/Read, Conforming, Accessed, 16-bit
You can list individual entries with 'info idt [NUM]' or groups with 'info idt [NUM] [NUM]'