LECTURE 02:

INTERRUPT MECHANISM

2.1 INTERRUPT MECHANISM

Interrupt follow a follow a certain mechanism for their invocation just like near or far
procedures. To understand this mechanism we need to understand its differences with
procedure calls.
Difference between interrupt and procedure calls
Procedures or functions of sub-routines in various different languages are called by different
methods as can be seen in the examples.
• Call MyProc
• A= Addition(4,5);
• Printf(“hello world”);

The general concept for procedure call in most of the programming languages is that on
invocation of the procedure the parameter list and the return address (which is the value if IP
register in case of near or the value of CS and IP registers in case of far procedure) is pushed
Moreover in various programming languages whenever a procedure is called its address need
to be specified by some notation i.e. in C language the name of the procedure is specified to
call a procedure which effectively can be used as its address.
However in case of interrupts the a number is used to specify the interrupt number in the call
• Int 21h
• Int 10h
• Int3

@St. Paul’s University Mr. Pius Nyaaga 1

Fig 1 (Call to interrupt service routine and procedures/functions)

Main
Call proc1()
Call proc1()
Int 21h

Proc1()

Int 10h
Proc2()

Moreover when an interrupt is invoked three registers are pushed as the return address
i.e. the values of IP, CS and Flags in the described order which are restored on return. Also
no parameters are pushed onto the stack on invocation parameters can only be passed through
registers.

2.2 THE INTERRUPT VECTOR TABLE

The interrupt number specified in the interrupt call is used as an index into the
interrupt vector table. Interrupt vector table is a global table situated at the address
0000:0000H. The size of interrupt vector table is 1024 bytes or 1 KB. Each entry in the IVT
is sized 4 bytes hence 256 interrupt vectors are possible numbered (0-FFH). Each entry in the
table contains a far address of an interrupt handlers hence there is a maximum of 256
handlers however each handlers can have a number of services within itself. So the number
operations that can be performed by calling an interrupt service routine (ISR) is indefinite
depending upon the nature of the operating system. Each vector contains a far address of an
interrupt handler. The address of the vector and not the address of interrupt handler can be
easily calculated if the interrupt number is known. The segment address of the whole IVT is
0000H the offset address for a particular interrupt handler can be determined by multiplying
its number with 4 e.g. The offset address of the vector of INT 21H will be 21H * 4 = 84H and
the segment for all vectors is 0 hence its far address is 0000:0084H, (this is the far address of
the interrupt vector and not the interrupt service routine or interrupt handler). The vector in
@St. Paul’s University Mr. Pius Nyaaga 2
turn contains the address of the interrupt service routine which is an arbitrary value
depending upon the location of the ISR residing in memory.

Fig 2 (Interrupt Vector Table)

Interrupt Vector Table

INT0 0000:0000
INT1 0000:0004

INTFF 0000:03FFH
Moreover it is important to understand the meaning of the four bytes within the
interrupt vector. Each entry within the IVT contains a far address the first two bytes (lower
word) of which is the offset and the next two bytes (higher word) is the segment address.

INT 0 LO(0) 0000:0001

LO(1)
HI(0)
HI(1) 0000:0003
INT 1 0000:0004

0000:0007

Fig 3 (Far address within Interrupt vector)

@St. Paul’s University Mr. Pius Nyaaga 3

2.3 LOCATION OF ISRS (INTERRUPT SERVICE ROUTINES)
Generally there are three kind of ISR within a system depending upon the entity which
implements it
 BIOS (Basic I/O services) ISRs
 DOS ISRs
 ISRs provided by third party device drivers

When the system has booted up and the applications can be run all these kinds of ISRs
may be provided by the system. Those provided by the ROM-BIOS would be typically
resident at any location after the address F000:0000H because this the address within
memory from where the ROM-BIOS starts, the ISRs provided by DOS would be resident in
the DOS kernel (mainly IO.SYS and MSDOS.SYS loaded in memory) and the ISR provided
by third party device drivers will be resident in the memory occupied by the device drivers.

IO.SYS
Device Driver
Command. COM

USER PROGRAM

Rom Bios F000:0000

Fig 4 (ISRs in memory)

This fact can be practically analyzed by the DOS command mem/d which gives the
status of the memory and also points out which memory area occupied by which process as
shown in the text below. The information given by this command indicates the address
where IO.SYS and other device drivers have been loaded but the location of ROM BIOS is
not shown by this command.

@St. Paul’s University Mr. Pius Nyaaga 4

C:\>mem /d
Address Name Size Type
------- -------- ------ ------
000000 000400 Interrupt Vector
000400 000100 ROM Communication Area
000500 000200 DOS Communication Area
000700 IO 000370 System Data
CON System Device Driver
AUX System Device Driver
PRN System Device Driver
CLOCK$ System Device Driver
COM1 System Device Driver
LPT1 System Device Driver
LPT2 System Device Driver
LPT3 System Device Driver
COM2 System Device Driver
COM3 System Device Driver
COM4 System Device Driver

000A70 MSDOS 001610 System Data

002080 IO 002030 System Data
KBD 000CE0 System Program
HIMEM 0004E0 DEVICE=
XMSXXXX0 Installed Device Driver
000490 FILES=
000090 FCBS=
000120 LASTDRIVE=
0007D0 STACKS=
0040C0 COMMAND 000A20 Program
004AF0 MSDOS 000070 -- Free --
004B70 COMMAND 0006D0 Environment
005250 DOSX 0087A0 Program
00DA00 MEM 000610 Environment
00E020 MEM 0174E0 Program
@St. Paul’s University Mr. Pius Nyaaga 5
 025510 MSDOS 07AAD0 -- Free --
09FFF0 SYSTEM 02F000 System Program
0CF000 IO 003100 System Data
MOUSE 0030F0 System Program
0D2110 MSDOS 000600 -- Free --
0D2720 MSCDEXNT 0001D0 Program
0D2900 REDIR 000A70 Program
0D3380 DOSX 000080 Data
0D3410 MSDOS 00CBE0 -- Free --
655360 bytes total conventional memory
655360 bytes available to MS-DOS
597952 largest executable program sizes
1048576 bytes total contiguous extended memory
0 bytes available contiguous extended memory
941056 bytes available XMS memory
MS-DOS resident in High Memory Area

2.4 INTERRUPT INVOCATION

Although hardware and software interrupts are invoked differently i.e. hardware
interrupts are invoked by means of some hardware whereas software interrupts are invoked
by means of software instruction or statement but no matter how an interrupt has been
invoked processor follows a certain set steps after invocation of interrupts in exactly same
way in both the cases. These steps are listed as below
• Push Flags, CS, IP Registers, Clear Interrupt Flag
• Use (INT#)*4 as Offset and Zero as Segment
• This is the address of interrupt Vector and not the ISR
• Use lower two bytes of interrupt Vector as offset and move into IP
• Use the higher two bytes of Vector as Segment Address and move it into CS=0:
[offset+2]
• Branch to ISR and Perform I/O Operation
• Return to Point of Interruption by Popping the 6 bytes i.e. Flags CS, IP.

@St. Paul’s University Mr. Pius Nyaaga 6

This can be analyzed practically by the use of debug program, used to debug assembly
language code, by assembling and debugging INT instructions
C:\>debug
-d 0:84
0000:0080 7C 10 A7 00-4F 03 55 05 8A 03 55 05 |...O.U...U.
0000:0090 17 03 55 05 86 10 A7 00-90 10 A7 00 9A 10 A7 00 ..U.............
0000:00A0 B8 10 A7 00 54 02 70 00-F2 04 74 CC B8 10 A7 00 ....T.p...t.....
0000:00B0 B8 10 A7 00 B8 10 A7 00-40 01 21 04 50 09 AB D4 ........@.!.P...
0000:00C0 EA AE 10 A7 00 E8 00 F0-B8 10 A7 00 C4 23 02 C9 .............#..
0000:00D0 B8 10 A7 00 B8 10 A7 00-B8 10 A7 00 B8 10 A7 00 ................7
0000:00E0 B8 10 A7 00 B8 10 A7 00-B8 10 A7 00 B8 10 A7 00 ................
0000:00F0 B8 10 A7 00 B8 10 A7 00-B8 10 A7 00 B8 10 A7 00 ................
0000:0100 8A 04 10 02 ....
-a
0AF1:0100 int 21
0AF1:0102
-r
AX=0000 BX=0000 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000
DS=0AF1 ES=0AF1 SS=0AF1 CS=0AF1 IP=0100 NV UP EI PL NZ NA PO NC
0AF1:0100 CD21 INT 21
-t
AX=0000 BX=0000 CX=0000 DX=0000 SP=FFE8 BP=0000 SI=0000 DI=0000
DS=0AF1 ES=0AF1 SS=0AF1 CS=00A7 IP=107C NV UP DI PL NZ NA PO NC
00A7:107C 90 NOP
-d ss: ffe8
0AF1:FFE0 02 01 F1 0A 02 F2 00 00
0AF1:FFF0 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00
The dump at the address 0000:0084 H shows the value of the vector of the interrupt #
21H i.e. 21H * 4 = 84H. This address holds the value 107CH in lower word and 00A7H in
the higher word which indicates that the segment address of interrupt # 21 is 00A7H and the
offset address of this ISR is 107CH. Moreover the instruction INT 21H can be assembled
and executed in the debug program, on doing exactly so the instruction is traced through and
the result is monitored. It can be seen that on execution of this instruction the value of IP is
changed to 107CH and the value of CS is changed to 00A7H which cause the execution to
@St. Paul’s University Mr. Pius Nyaaga 7
branch to the Interrupt # 21H in memory and the previous values of flags, CS and IP registers
are temporarily saved onto the stack as the value of SP is reduced by 6 and the dump at the
location SS: SP will show these saved values as well.

2.5 PARAMETER PASSING INTO SOFTWARE INTERRUPTS

In case of procedures or function in various programming languages parameters are
passed through stack. Interrupts are also kind of function provided by the operating system
but they do not accept parameters by stack rather they need to pass parameters through
registers.

2.6 SOFTWARE INTERRUPTS INVOCATION

Now let’s see how various interrupts can be invoked by means of software statements.
First there should be way to pass parameters into a software interrupt before invoking the
interrupt; there are several methods for doing this. One of the methods is the use of pseudo
variables. A variable can be defined a space within the memory whose value can be changed
during the execution of a program but a pseudo variable acts very much like a variable as its
value can be changed anywhere in the program but is not a true variable as it is not stored in
memory. C programming language provides the use of pseudo variables to access various
registers within the processor. They are various registers like AX, BX, CX and DX within
the processor they can be directly accessed in a program by using their respective pseudo
variable by just attaching a “_” (underscore) before the register’s name e.g. _AX = 5; A =
_BX . After passing the appropriate parameters the interrupt can be directly invoked by
calling the geninterrupt () function. The interrupt number needs to be passed as parameter
into the geninterrupt () function.

2.6.1 Interrupt # 21H, Service # 09 description

Now let’s learn by means of an example how this can be accomplished. Before
invoking the interrupt the programmer needs to know how the interrupt behaves and what
parameters it requires. Let’s take the example of interrupt # 21H and service # 09 written as
21H/09H in short. It is used to print a string ending by a ‘$’ character and other parameters
describing the string are as below

@St. Paul’s University Mr. Pius Nyaaga 8

Inputs
AH = 0x09
DS = Segment Address of string
DX = Offset Address of string
Output
The ‘$’ terminated string at the address DS: DX is displayed
One thing is note worthy that the service # is placed in AH which is common with almost all
the interrupts and its service. Also this service is not returning any significant data, if some
service needs to return some data it too is received in registers depending upon the particular
interrupt.
Example:
#include<stdio.h>
#include<BIOS.H>
#include<DOS.H>
#include<conio.h>
char st [80] = {"Hello World$"};
void main ()
{
clrscr (); //to clear the screen contents
_DX = (unsigned int) st;
_AH = 0x09;
geninterrupt (0x21);
getch (); //waits for the user to press any key
}
this is a simple example in which the parameters of int 21H/09H are loaded and then int 21H
is invoked. DX and AH registers are accessed through pseudo variables and then geninterrupt
() is called to invoke the ISR. Also note that _DS is not loaded. This is the case as the string
to be loaded is of global scope and the C language compiler automatically loads the segment
address of the global data into the DS register.

2.6.2 Another Method for invoking software interrupts

This method makes use of a Union. This union is formed by two structures which correspond
to general purpose registers AX, BX, CX and DX. And also the half registers AH, AL, BH,
BL, CH, CL, DH, and DL. These structures are combined such that through this structure the

@St. Paul’s University Mr. Pius Nyaaga 9

field ax can be accessed to load a value and also its half components al and ah can be
accessed individually. The declaration of this structure goes as below. If this union is to be
used a programmer need not declare the following declaration rather declaration already
available through its header file “dos.h”
struct full
{
unsigned int ax;
unsigned int bx;
unsigned int cx;
unsigned int dx;
};
struct half
{
unsigned char al;
unsigned char ah;
unsigned char bl;
unsigned char bh;
unsigned char cl;
unsigned char ch;
unsigned char dl;
unsigned char dh;
};
typedef union tagREGS
{
struct full x;
struct half h;
} REGS;
This union can be used to signify any of the full or half general purpose register
shows if the field ax in x struct is to be accessed then accessing the fields al and ah in h will
also have the same effect as show in the example below.

@St. Paul’s University Mr. Pius Nyaaga 10

Example:
#include<DOS.H>
union REGS regs;
void main (void)
{
regs.h.al = 0x55;
regs.h.ah = 0x99;
printf (“%x”, regs.x.ax);
}
output:
9955

2.6.3 The int86 () function

The significance of this REGS union can only be understood after understanding the
int86 () function. The int86 () has three parameters. The first parameter is the interrupt
number to be invoked, the second parameter is the reference to a REGS type union which
contains the value of parameters that should be passed as inputs, and third parameter is a
reference to a REGS union which will contain the value of registers returned by this function.
All the required parameters for an ISR are placed in REGS type of union and its
reference is passed to an int86 () function. This function will put the value in this union into
the respective register and then invoke the interrupt. As the ISR returns it might leave some
meaningful value in the register (ISR will return values), these values can be retrieved from
the REGS union whose reference was passed into the function as the third parameter.
Example using interrupt # 21H service # 42H
To make it more meaningful we can again elaborate it by means of an example. Here
we make use of ISR 21H/42H which is used to move the file pointer. Its detail is as follows

Int # 21 Service # 42H

Inputs
AL = Move Technique
BX = File Handle
CX-DX = No of Bytes File to be moved
AH = Service # = 42H

@St. Paul’s University Mr. Pius Nyaaga 11

Output
DX-AX = No of Bytes File pointer actually moved.

BOF CP EOF

------------------------------ ----------------------------
-

This service is used to move the file pointer to a certain position relative to a certain
point. The value in AL specifies the point relative to which the pointer is moved. If the value
of AL = 0 then file pointer is moved relative to the BOF (begin of File) if AL=1 then it’s
moved relative to current position and if AL = 2 then its moved relative to the EOF (end of
file).
CX-DX specify the number of bytes to move a double word is needed to specify this value as
the size of file in DOS can be up to 2 GB. On return of the service DX-AX will contain the
number of bytes the file pointer is actually moved e.g. If the file pointer is moved relative to
the EOF zero bytes the DX-AX on return will contain the size of file if the file pointer was at
BOF before calling the service.

@St. Paul’s University Mr. Pius Nyaaga 12