How to patch 0x1c interrupt handler in protected mode

john_crichton · 04-02-2007, 11:13 AM

As a part of a larger project I need to patch the timer interrupt so it switches to my handler. The main language is c but some parts are done in assembly. The architecture is x86 32-bit. The solution should be as portable between opereating systems as possible. I am trying to do it in assembly (nasm).
I tried to do it with _sidt_ and then trying to point the 0x1c vector to my routine but it doesn't work. Here is the code:

Code:

CPU 386

segment .bss
idt:		resb 6

segment .text
; variables
extern		idtp, idtl, old_segment, old_offset
; functions
extern		setIVT, checkIDT, intRoutine
global		setIVTasm
setIVTasm:
			cli	
			push eax
	
			;call setIVT
			
			xor eax, eax 
			sidt [idt]
			
			;store IDTP to idtp
			mov eax, [idt + 2]
			mov [idtp], eax
			;store IDT Limit to idtl
			mov eax, [idt]
			mov [idtl], eax			
			
			; save old int handler
			xor eax, eax
			; save old segment
			mov ax, [idtp + 2]
			mov [old_segment], ax
			; save old offset low word
			mov ax, [idtp]
			mov [old_offset], ax
			; save old offset high word
			mov ax, [idtp + 6]
			mov [old_offset + 2], ax
			

			call checkIDT
			
			; set new int handler
			xor eax, eax
			; set new segment
			mov ax, cs
			mov [idtp + 2], ax
			; set new offset low word
			mov ax, [intRoutineAsm]
			mov [idtp], ax
			; set new offset high word
			mov ax, [intRoutineAsm + 2]
			mov [idtp + 6], ax 
			
			pop eax
			sti
			ret

Does anyone have an idea how this might work?

sundialsvcs · 04-04-2007, 07:53 PM

In any modern operating-system .. Linux, Windows, OS/X, whatever .. you don't have direct access to interrupts, vectors and so-forth.

You do have various kinds of asynchronous notifications, timers, and so-forth. In the Unix-variant systems, these are called signals, and the specific signal you're interested in here is named SIGALARM.

(By the way, this is the same mechanism Unix/Linux uses to handle other things, like program errors or your decision to kill a program. All of these result in a signal being issued.)

Forget about the hardware: you can't control it; can't touch it. You're not allowed, and with very good reason! But you can ask the operating-system to send a signal to your process, say, approximately so-many times a second. Then you define a handler routine to service the signal. When the signal arrives, your program will be diverted to the handler routine, asynchronously.

All of this signal-handling occurs comfortably within the context of your own process.

You do not get "precision intervals." You do not get guaranteed latency.

Standard libraries in various languages all provide for some analog of this facility and it can be expected to be portable across any operating-system without source-code changes.

john_crichton · 04-05-2007, 04:59 AM

Thank you. This answers a lot of my questions. Thank you again.