Chaining Interrupts

1. Chaining Interrupts

2. Short contents • What does chaining interrupts mean? • TSR programs • Chaining an interrupt example program • Reentrancy problems with DOS • Reentrancy problems with BIOS • The multiplex interrupt (INT 2Fh) • Installing and removing a TSR • Debugging TSRs • Difficulties in chaining interrupts in Windows

3. What does chaining interrupts mean? • MS-DOS places at memory address 0000:0000 the interrupt vector table (holds FAR address of each handler/ISR – Interrupt Service Routine) • Purpose of chaining interrupts: implementing missing functionalities from the OS, optimizing BIOS or DOS routines, altering OS behavior • Steps in chaining interrupts: • Writing the new ISR (the new handler); • Saving old handler’s (the original one) address; • Modifying handler’s address in the interrupt vector table; • Calling the new ISR; • Eventually, calling the old ISR; • Restoring the original handler;

4. Accessing the interrupt vector table directly: oldint77 dd ? ; space for storing old handler’s addr. … … mov es, 0 cli ; deactivate interrupts mov ax, word ptr es:[4*77h] mov word ptr cs:oldint77, ax mov ax, word ptr es:[4*77h+2] mov word ptr cs:[oldint77+2], ax sti ; reactivate interrupts Using DOS function no. 35h: oldint77 dd ? ; for storing old handler’s address … … mov ax, 3577h ; ES:BX –address of current handler int 21h mov word ptr cs:oldint77, bx mov word ptr cs:[oldint77+2], es Saving old handler’s address

5. Accessing the interrupt vector table directly : mov es, 0 cli mov word ptr es:[4*77h],offset Newhandler mov word ptr es:[4*77h+2],seg Newhandler sti Using DOS function no. 25h: push ds mov ax, 2577h mov dx, seg Newhandler mov ds, dx mov dx, offset Newhandler int 21h pop ds Modifying handler’s address in the interrupt vector table

6. Calling the original handler and returning from the ISR • Calling the old handler, then return in the new handler: pushf ; pushing flags on to the stack call dword ptr cs:oldint77 … iret ; popf + retf • Calling the old handler, then return in the application: jmp dword ptr cs:oldint77

7. Writing the new ISR • We can not count on (know) the value of any register except CS and IP • If we modify registers inside the ISR their values must be saved previously and then restored prior of returning from the ISR

8. TSR Programs (Terminate and Stay Resident) • MS-DOS programs are: • transient : free memory when they terminate execution • resident : does not return all memory back to DOS • TSRs are used for introducing multitasking functionality into a monotasking OS • Staying resident is done using DOS function no. 31h • TSRs have a transient section (executed once in the beginning) and a resident one (stays in memory after completion) • Active TSRs (activated by system generated hardware interrupts) • TSR-uri pasive (activated by an explicit call)

9. DOS memory map and TSRs (1) DOS memory map, no active application DOS memory map, one active application

10. DOS memory map and TSRs (2) DOS memory map with one resident application and one transient application DOS memory map, one resident application

11. Chaining an interrupt example program(1) handler: ;****New handler**** cmp ah,00h jnz CallOldHandler push ax push ds push dx mov ah,9h push cs pop ds lea dx,message int 21h ;uninstall new handler ;mov ax,2514h ;mov dx,word ptr Oldip ;mov ds,word ptr Oldcs pop dx pop ds pop ax iret CallOldHandler : jmp dword ptr Oldip assume cs:cod cod segment org 100h start: jmp install ;resident part message db “Parameters initialized for COM1 ! $" minstalled db “Handler already installed $" Oldip dw ? Oldcs dw ? signature db “exemplu rutina"

12. Chaining an interrupt example program(2) ; ds:si contains address of signature ; es:si contains address of signature from the old handler mov di,si cld mov cx,handler-signature repe cmpsb jne notinstalled mov ah,9h lea dx,minstalled int 21h ;ending program mov ax,4c01h int 21h install: ;check whether new ISR has already been installed mov ah,35h mov al,14h int 21h ;in es:bx we have the address of 14h ISR mov word ptr Oldip,bx mov word ptr Oldcs,es ;compare the addresses of old and new handler cmp bx,offset handler jne notinstalled ;compare signatures push cs pop ds lea si,signature

13. Chaining an interrupt example program(3) notinstalled: mov ah,25h mov al,14h push cs pop ds lea dx,handler int 21h mov ah,31h mov al,00h lea dx,install add dx,15 mov cl,4 shr dx,cl int 21h cod ends end start

14. Reentrancy problems with DOS • Happens when the current application calls a DOS function and during the execution of this DOS function an asynchronous event (e.g. timer interrupt, pressing a key) occurs which activates a TSR that at his turn calls DOS. • DOS is not reentrant: it does not allow several DOS calls to be active in the same time • May lead to system hang • In general, the problem does not occur for passive TSRs • InDOS flag on 1 byte(=0 if no DOS call is active, !=0 if a DOS call is in progress) + DOS function34h (GetInDosFlagAddress) • CritError flag– set when a DOS calls issues a critical error; error’s details are saved at a fix memory address which gets overwritten each time

15. Reentrancy problems with BIOS • Some BIOS interrupts are not reentrant, others are reentrant • BIOS doesn’t provide an InBIOS flag • For not reentrant BIOS interrupts one can implement a wrapper ISR to simulate the InBIOS flag: int17 proc far inc CS:InBIOS pushf call dword ptr CS:OldInt17 dec CS:InBIOS iret int17 endp

16. The multiplex interrupt(INT 2Fh) • When we install a passive TSR we have to choose an interrupt vector (number) to patch into: • We can randomly choose an interrupt vector from the interrupt vector table • We can choose an interrupt which implements specific functionality • We can choose the multiplex interrupt, 2Fh • The multiplex interrupt, 2Fh: reserved for providing a general mechanism for installing, testing the presence and communicating with a TSR

17. Installing and removing a TSR • To check at install time: • The handler is not already installed (using a signature) • The interrupt vector is free (reserved) • To do at uninstall time: • Stop all pending actions of this TSR • Restore all interrupt vectors to their former values • Return all reserved memory back to DOS [Last two tasks difficult to accomplish] • Exemplifying the aforementioned issues: “TSR Monitor Tastatura” example, section 6.8, pag. 229, the blue book

18. Debugging a TSR (1) • Compile and linkedit the TSR (possible with debug information included). • Load the TSR into TD and execute the transient part naturally. When this part is executed, the resident part would be installed into the RAM memory. • Set a breakpoint in the resident part (preferably in the beginning) with the F2 key (or from the Breakpoints menu). • Select option File | Resident from the menu in order to make TD resident. This is done in order to get the DOS prompter again. • Once we are back to DOS the resident part gets active. • When the program execution gets to the breakpoint, TD comes back showing the TSR in the respective point. Thus, debugging this code is then possible. (Coming back to TD from DOS is done by pressing CTRL-Break twice)

19. Debugging a TSR (2)

20. Debugging a TSR (3)

21. Debugging a TSR (4)

22. Debugging a TSR (5)

23. Debugging a TSR (6)

24. Debugging a TSR (7)

25. Difficulties in chaining interrupts in Windows • There are no systems running native MS-DOS any more • Windows OS emulates a virtual hardware architecture in which DOS is run • We can not chain interrupts that work with hardware equipment because this is virtual (e.g. int 13h for working with the disk, int 10h for working in graphical mode etc)