সরাসরি পর্বে যান
পর্ব ২০ · ৮৫-এর মধ্যে · মডিউল ৩

8086-এর interrupt — vector table, INT আর ISR

8086 Interrupts — Vector Table, INT and ISR

Taught in Bangla, this lesson explains the 8086's 256 interrupt types and the vector table at 00000H–003FFH, what the CPU pushes and clears on entry, and how IRET returns. Programs assembled with NASM and run on Unicorn show the stack on entry, a divide error, single stepping, breakpoint and overflow types, and a price service installed as INT 60h through INT 21h functions 35h and 25h. Ending an ISR with RET is shown to fail, and INTR, NMI and priority are covered.

এই পর্বে যা শিখবেন

  • যেকোনো type-এর vector table-এর ঠিকানা আর handler-এর physical address হাতে বের করা
  • Interrupt-এ ঢোকা আর IRET-এ ফেরার সময় stack-এর প্রতিটি byte ধাপে ধাপে বলা
  • Type 0 থেকে 4 আলাদা করে চেনা, আর divide error কখন আর কেন ঘটে তা দেখানো
  • INTR আর NMI-র পার্থক্য, IF-এর ভূমিকা আর অগ্রাধিকারের ক্রম বোঝা
  • DOS-এর সেবা দিয়ে নিজের ISR বসানো, আর ISR লেখার নিয়ম মেনে চলা

১ · 8086 কেন থামে — তিন রকম interrupt

পর্ব ১৩-এ আপনি 8085-এর interrupt দেখেছেন: পাঁচটি pin, প্রতিটির ঠিকানা chip-এর ভেতরে বাঁধা (TRAP মানেই 0024H). 8086 এই ব্যবস্থা পুরো বদলে দিল। এখানে প্রতিটি interrupt-এর একটি নম্বর থাকে, যার নাম type, 0 থেকে 255 পর্যন্ত। আর handler কোথায় আছে, তা chip জানে না; জানে মেমরির একটি টেবিল, যা program নিজে লিখতে পারে। ফলে একই chip-এ ২৫৬টি আলাদা ISR রাখা যায়, আর যেকোনোটি চলার সময় বদলানো যায়।

উপমা — হাসপাতালের জরুরি নম্বরের খাতা: একটি বড় হাসপাতালের রিসেপশনে একটি খাতা আছে, যার পাতায় পাতায় নম্বর লেখা: “৩ নম্বর ঘণ্টা বাজলে ডা. করিম, ৪ নম্বরে নার্স রুমা।” কোন ঘণ্টা বাজল শুনে রিসেপশনিস্ট খাতা খোলেন, নাম দেখেন, ডাকেন। ডাক্তার বদলালে শুধু খাতার পাতা বদলায়, ঘণ্টার তার নয়। 8086-এ ঘণ্টার নম্বরই type, খাতাটি interrupt vector table, আর খাতার নামটি handler-এর CS:IP.

Interrupt আসে তিন জায়গা থেকে। প্রথমত, বাইরের pin: NMI আর INTR, যন্ত্র বা circuit যখন CPU-র মনোযোগ চায়। দ্বিতীয়ত, program-এর নিজের নির্দেশ: INT n, এক byte-এর INT 3 আর INTO; এদের বলে software interrupt. তৃতীয়ত, CPU নিজে কোনো অবস্থা দেখে: ভাগ অসম্ভব হলে type 0, আর TF = 1 থাকলে প্রতিটি নির্দেশের পরে type 1. শেষ দলটিকে আধুনিক ভাষায় exception বলে। তিন দলেরই পরের পথ একই: type নম্বর, টেবিল, ISR আর IRET.

Typeনামকে ঘটায়IVT-র ঘর
0Divide errorDIV/IDIV-এ ভাজক 0, বা ভাগফল register-এ আঁটে না00000H
1Single stepTF = 1 থাকলে প্রতিটি নির্দেশের পরে00004H
2NMINMI pin-এ 0 থেকে 1 হওয়া (rising edge)00008H
3Breakpointএক byte-এর INT 3 (CC)0000CH
4OverflowINTO, যদি OF = 100010H
5–31Intel-এর সংরক্ষিতপরের chip-এর জন্য রাখা00014H–0007FH
32–255ব্যবহারকারীরINT n বা INTR-এ যন্ত্রের দেওয়া type00080H–003FFH

লেখার নিয়ম আগের পর্বগুলোর মতো: hex Intel-এর ধরনে, শেষে H (00084H, 0FFFEH), আর segment:offset 1000H:0118H ধাঁচে; কোডের ভেতরে NASM-এর ছোট হাতের h. Physical address = segment × 10H + offset, যা পর্ব ১৪-এ; stack-এর PUSH/POP আর SS:SP-ও সেখানে। Interrupt আর exception-এর সাধারণ তত্ত্ব, CPU-র নকশার দিক থেকে, Computer Architecture পর্ব ৩৮-এ; এই পর্ব 8086-এর হাতে-কলমে দিকটি দেখাবে।

পর্ব ১৩-এর সঙ্গে পাশাপাশি রাখলে পার্থক্যগুলো এক নজরে ধরা পড়ে। 8085-এর বিস্তারিত সেখানেই; এখানে শুধু তুলনা:

বিষয়8085 (পর্ব ১৩)8086
Handler-এর ঠিকানাchip-এ বাঁধা (TRAP 0024H, RST 7.5 003CH …)RAM-এর টেবিল থেকে, type × 4
উৎসের সংখ্যাপাঁচটি pin আর আটটি RST n২৫৬টি type
বন্ধ করা যায় নাTRAPNMI (type 2)
সাধারণ বন্ধ-খোলাDI/EI, আর SIM-এ আলাদা maskCLI/STI (IF); আলাদা mask বাইরের 8259-এ
Stack-এ যা যায়শুধু PCFLAGS, CS, IP
ফেরাRETIRET
INTR-এ যন্ত্র যা দেয়একটি নির্দেশ (সাধারণত RST n)শুধু type নম্বরের একটি byte

ইতিহাসের পাতা থেকে: 8086 আসে ১৯৭৮ সালে, আর Intel-এর manual শুরু থেকেই type 0–4-এর কাজ বেঁধে দিয়ে 5–31 নিজের জন্য সংরক্ষিত বলে। ১৯৮১ সালের IBM PC (8088) সেই নিষেধ পুরো মানেনি: BIOS-এর print screen বসল type 5-এ, আর 8259 interrupt controller-এর আটটি hardware line বসল type 08H–0FH-এ। পরে MS-DOS তার সব সেবা দিল INT 21h দিয়ে। এই পছন্দগুলোর দাম কী হয়েছিল, তা ভাবনার প্রশ্ন ৪-এ।

এই পর্বের প্রতিটি register, stack আর মেমরির মান এসেছে reference lab-এর run8086.py থেকে: NASM 3.02-এ assemble করা আসল machine code, Unicorn-এর ১৬ বিট real mode-এ চালানো। দুটি নিয়ম এখানে বিশেষ জরুরি। Spec decision 14: শুরুতে vector table-এর প্রতিটি ঘর lab-এর একটি ছোট DOS stub দেখায় (type n → F000H:(n × 4)); অন্য কোনো মান বসালে CPU আসল 8086-এর মতো FLAGS, CS, IP রেখে IF আর TF শূন্য করে টেবিল ধরে লাফ দেয়। Spec decision 15: Unicorn 386-ধাঁচের core, তাই divide error-এ ফেরার ঠিকানা আসল 8086-এর চেয়ে আলাদা; অংশ ৪-এ তা সত্যিই দেখবেন।

২ · Interrupt vector table — মেমরির প্রথম 1 KB

8086 interrupt vector table (IVT) রাখে physical address 00000H থেকে 003FFH-এ: ২৫৬টি ঘর, প্রতিটি ৪ byte, মোট 1024 byte. Type n-এর ঘর শুরু হয় n × 4-এ। ঘরের প্রথম দুই byte নতুন IP, পরের দুই byte নতুন CS, দুটিই little-endian (নিচু byte আগে)। এই দুই word-কে একসঙ্গে বলে interrupt vector. টেবিলটি সাধারণ RAM-এ, তাই যেকোনো program একটি MOV দিয়েই vector বদলাতে পারে। এটি সুবিধা, আবার বিপদও।

ছবি ২০.১ — 8086-এর interrupt vector table আর একটি ঘরের ভেতর

ওপরে টেবিল, ওপর থেকে নিচে ঠিকানা বাড়ে; নীল = Intel-এর নির্দিষ্ট type; ধূসর = সংরক্ষিত; সবুজ = ব্যবহারকারীর; নিচে type 60H-এর ৪ byte

Interrupt vector table আর type 60H-এর ঘর IVT · 00000H–003FFH 00000H 0 · divide error 00004H 1 · single step 00008H 2 · NMI 0000CH 3 · breakpoint 00010H 4 · overflow (INTO) 00014H–0007FH 5–31 · Intel-এর সংরক্ষিত 00084H 21H · DOS … 32–255 · ব্যবহারকারীর 00180H 60H · বাজারঘরের দাম 003FCH FFH · শেষ ঘর type 60H-এর ৪ byte 00180H 18 IP নিচু 00181H 01 IP উঁচু 00182H 00 CS নিচু 00183H 10 CS উঁচু IP = 0118H · CS = 1000H 1000H × 10H + 0118H = 10118H · ISR: push bx
ছবি ২০.১ — টেবিলটি মাপ অনুযায়ী আঁকা নয়। Type 60H-এর ঘরের চারটি byte সত্যিকারের run থেকে নেওয়া (--mem 0000:0180,4 ছেপেছে 18 01 00 10). প্রথম word IP, দ্বিতীয় word CS: উল্টো পড়লে ঠিকানা সম্পূর্ণ ভুল হবে।

নিচের ছোট Python program টেবিলের ঠিকানা আর ঘরের byte থেকে handler-এর physical address হিসাব করে। Byte-গুলো তিনটি আসল run থেকে নেওয়া: type 0 আর 60H-এর মান এই পর্বের program বসানোর পরের, আর type 21H-এর মান lab-এর DOS stub-এর।

# 8086-এর interrupt vector table: type n-এর ঘর 0000H:(n × 4)
# প্রতিটি ঘরে ৪ byte: IP (নিচু word) তারপর CS, little-endian
ivt = {0x00: bytes([0x23, 0x01, 0x00, 0x10]),   # div86.asm বসানোর পরে
       0x21: bytes([0x84, 0x00, 0x00, 0xF0]),   # lab-এর DOS stub
       0x60: bytes([0x18, 0x01, 0x00, 0x10])}   # stack86.asm বসানোর পরে

def entry(n):
    off = n * 4                       # type × 4
    return off, off + 3               # ৪ byte-এর পরিসর

for n in (0, 1, 2, 3, 4, 0x21, 0x60, 0xFF):
    lo, hi = entry(n)
    print(f"type {n:02X}H: IVT {lo:05X}H-{hi:05X}H", end="")
    if n in ivt:
        b = ivt[n]
        ip = b[0] | b[1] << 8
        cs = b[2] | b[3] << 8
        phys = (cs << 4) + ip
        print(f"  bytes {b.hex(' ').upper()} -> {cs:04X}H:{ip:04X}H = {phys:05X}H")
    else:
        print()
print(f"পুরো টেবিল: 256 × 4 = {256 * 4} byte = 00000H-{256 * 4 - 1:05X}H")

আসল আউটপুট (ব্রাউজারের Python):

type 00H: IVT 00000H-00003H  bytes 23 01 00 10 -> 1000H:0123H = 10123H
type 01H: IVT 00004H-00007H
type 02H: IVT 00008H-0000BH
type 03H: IVT 0000CH-0000FH
type 04H: IVT 00010H-00013H
type 21H: IVT 00084H-00087H  bytes 84 00 00 F0 -> F000H:0084H = F0084H
type 60H: IVT 00180H-00183H  bytes 18 01 00 10 -> 1000H:0118H = 10118H
type FFH: IVT 003FCH-003FFH
পুরো টেবিল: 256 × 4 = 1024 byte = 00000H-003FFH

দুটি জিনিস লক্ষ করুন। প্রথমত, IVT-র segment সবসময় 0000H, তাই type × 4 সরাসরি physical address; পরীক্ষায় “type 21H-এর vector কোথায়” প্রশ্নের উত্তর 00084H. দ্বিতীয়ত, ঘরের byte পড়ার সময় little-endian মানতে হয়: 18 01 মানে 0118H, 1801H নয়। Lab-এর stub-এর ঘর 84 00 00 F0 বলে handler F0084H-এ, যেখানে lab একটি IRET byte রেখেছে আর DOS-এর কাজটি Python নিজে করে (Spec decision 14).

হিসাব
নির্দেশ
কাজ
মান
কে ধরে
  1. Type আসে নির্দেশ থেকে। int 21h-এর machine code CD 21: প্রথম byte বলে “INT”, দ্বিতীয় byte type নম্বর 21H. INTR-এর বেলায় এই নম্বর দেয় বাইরের যন্ত্র (অংশ ৬)।
  2. Type × 4. প্রতিটি ঘর ৪ byte, তাই 21H × 4 = 84H. IVT-র segment 0000H, তাই physical address 00084H; কোনো segment যোগের ঝামেলা নেই।
  3. চারটি byte পড়া। সত্যিকারের run-এ (--mem 0000:0084,4) এই ঘরে 84 00 00 F0. প্রথম word IP = 0084H, দ্বিতীয় word CS = F000H.
  4. Handler-এর ঠিকানা। F000H × 10H + 0084H = F0084H. Lab-এ সেখানে একটি IRET byte; DOS-এর আসল কাজ (অক্ষর ছাপা, vector বসানো) Python-এর stub করে (Spec decision 14).
  5. নিজের vector. Program 00180H-এ নিজের ISR-এর ঠিকানা লিখেছে। 60H × 4 = 180H, আর run-এর পরে সেখানে 18 01 00 10.
  6. ISR খুঁজে পাওয়া। IP = 0118H, CS = 1000H, তাই 10000H + 0118H = 10118H. Trace বলে সেখানে ISR-এর প্রথম নির্দেশ push bx: হিসাব আর run মিলেছে।

৩ · ঢোকা আর ফেরা — stack-এ FLAGS, CS, IP

Intel-এর 8086 manual-এ interrupt নেওয়ার ধাপগুলো এই ক্রমে: (১) FLAGS stack-এ রাখা; (২) IF আর TF শূন্য করা; (৩) CS stack-এ রাখা; (৪) IP stack-এ রাখা, যা পরের নির্দেশের offset; (৫) type × 4 থেকে নতুন IP আর type × 4 + 2 থেকে নতুন CS পড়া। প্রতিটি রাখায় SP দুই কমে, তাই মোট ছয় byte. 8085-এর RST শুধু PC রাখত (পর্ব ১২); 8086 পুরো CS:IP আর FLAGS রাখে, কারণ ISR অন্য segment-এ থাকতে পারে, আর ISR-এর হিসাব flag বদলে দেয়।

ফেরার নির্দেশ IRET ঠিক উল্টো কাজ করে: stack থেকে IP, তারপর CS, তারপর FLAGS তোলে। FLAGS ফেরার সঙ্গে IF-ও আগের মানে ফেরে, তাই interrupt আবার চালু হয়ে যায়, আলাদা STI লাগে না। IF আর TF কেন শূন্য করা হয়? IF = 0 যাতে ISR-এর প্রথম নির্দেশের আগেই আরেকটি INTR ঢুকে না পড়ে; TF = 0 যাতে debugger-এর single step ISR-এর ভেতরে না চলে।

এবার সত্যিই দেখা যাক। নিচের program বাজারঘরের smart scale-এর জন্য একটি “দাম-সেবা” বসায়: AX-এ net ওজন (g) দিয়ে int 60h ডাকলে AX-এ দাম পয়সায় ফেরে, README-এর সূত্রে: দাম = (net_g × 6550 + 500) / 1000. ISR-এর ভেতরের MUL/DIV-এর register-এর নিয়ম পর্ব ১৬-এ।

; stack86.asm - INT 60h entry and IRET: what goes on the stack
        org 100h
        xor ax, ax
        mov es, ax              ; ES = 0000h: the IVT
        cli
        mov word [es:60h*4], isr60
        mov [es:60h*4+2], cs    ; vector 60h = 1000h:isr60
        sti
        mov ax, 1250            ; net weight, g
        int 60h                 ; -> AX = price, paisa
        hlt

isr60:  push bx
        push dx
        mov bx, 6550            ; rate, paisa/kg
        mul bx                  ; DX:AX = g x 6550
        add ax, 500
        adc dx, 0               ; + 500 for rounding
        mov bx, 1000
        div bx                  ; AX = paisa
        pop dx
        pop bx
        iret

সত্যিকারের run (run8086.py, NASM 3.02, Unicorn 2.1.4; trace-এর লাইন ছোট করতে শুধু AX, SP, IP আর flag রাখা হয়েছে, বাকি কলাম বাদ; শুরুর ছয়টি লাইন আর ISR-এর মাঝের চারটি লাইনও বাদ):

$ python -B run8086.py stack86.asm --trace --regs --mem 0000:0180,4 --mem 1000:FFF8,6
1000:0112 mov ax,0x4e2       AX=04E2 SP=FFFE IP=0115 --I--Z-P-
1000:0115 int byte 0x60      AX=04E2 SP=FFFE IP=0117 --I--Z-P-
---- INT 60h -> vector 1000:0118 (FLAGS, CS, IP pushed)
1000:0118 push bx            AX=04E2 SP=FFF6 IP=0119 -----Z-P-
1000:0119 push dx            AX=04E2 SP=FFF4 IP=011A -----Z-P-
1000:011D mul bx             AX=EE6C SP=FFF4 IP=011F O---S--PC
1000:0128 div bx             AX=1FFC SP=FFF4 IP=012A ---------
1000:012A pop dx             AX=1FFC SP=FFF6 IP=012B ---------
1000:012B pop bx             AX=1FFC SP=FFF8 IP=012C ---------
1000:012C iret               AX=1FFC SP=FFFE IP=0117 --I--Z-P-
----
AX=1FFC BX=0000 CX=0000 DX=0000 SI=0000 DI=0000 BP=0000 SP=FFFE CS=1000 DS=1000 ES=0000 SS=1000 IP=0117 --I--Z-P-
0000:0180  18 01 00 10
1000:FFF8  17 01 00 10 46 02
[exit code 0 via HLT, 20 instructions]

AX = 1FFCH = 8188 পয়সা = 81.88 টাকা, README-এর মানের সঙ্গে হুবহু মিল। আর শেষের মেমরি-ছাপ 1000:FFF8 17 01 00 10 46 02 হলো interrupt-এর রেখে যাওয়া তিনটি word: IP = 0117H, CS = 1000H, FLAGS = 0246H. POP আর IRET শুধু SP সরায়, byte মোছে না, তাই run শেষেও সেগুলো পড়া গেছে। একটি সূক্ষ্মতা: runner আগে তিনটি word রাখে, তারপর IF আর TF শূন্য করে; Intel-এর ক্রমে IF আর TF শূন্য হয় FLAGS রাখার ঠিক পরে। দুই পথেই stack-এ একই byte পড়ে, কারণ FLAGS রাখা হয় শূন্য করার আগের মানে। আর আসল 8086-এ FLAGS-এর বিট ১২–১৫ সবসময় 1, তাই সেখানে stack-এ 0246H নয়, F246H দেখা যেত (Spec decision 15).

0115int 60h—(FLAGS রাখা)—(IF, TF = 0)—(CS রাখা)—(IP রাখা)0118push bx0119push dx … div bx012Apop dx, pop bx012Ciret
CPU আর stack
CS:IP
SP
FLAGS · IF
AX
FFF8H–FFFDH
  1. শুরু। CPU int 60h পড়ছে (0115H, দুই byte). SP = FFFEH, FLAGS = 0246H: IF, ZF, PF আর সবসময় 1 থাকা বিট ১। Stack-এর এই অংশ এখনো শূন্য।
  2. FLAGS রাখা। SP দুই কমে FFFCH, আর 1FFFCH-এ লেখা হলো 46 02: 0246H, নিচু byte আগে। এই কপিতে IF = 1 রয়ে গেল, ফেরার সময় সেটিই ফিরবে।
  3. IF আর TF শূন্য। FLAGS = 0246H − 0200H = 0046H. এখন INTR pin-এর অনুরোধ অপেক্ষা করবে। Trace-এ ISR-এর প্রথম লাইনের ছাপে তাই আর “I” নেই।
  4. CS রাখা। SP = FFFAH, সেখানে 00 10 = 1000H. Far ফেরার জন্য segment-ও লাগে, কারণ vector যেকোনো segment-এ নিয়ে যেতে পারে।
  5. IP রাখা। SP = FFF8H, সেখানে 17 01 = 0117H: int 60h-এর পরের নির্দেশ (hlt)-এর offset, int-এর নিজের নয়। মোট ছয় byte, SP ছয় কমেছে।
  6. টেবিল থেকে লাফ। 00180H থেকে IP = 0118H, 00182H থেকে CS = 1000H. CPU এখন ISR-এর push bx-এ। Trace-এর ---- INT 60h -> vector 1000:0118 লাইনটি এই মুহূর্ত।
  7. ISR-এর কাজ। BX আর DX রাখায় SP = FFF4H. 1250 × 6550 = 8187500, +500 = 8188000, ÷ 1000 = 8188 = 1FFCH. ISR-এর হিসাবে flag বদলেছে (trace-এ div-এর পরে সব flag শূন্য, তাই 0002H), কিন্তু আসল FLAGS stack-এ নিরাপদ।
  8. Register ফেরত। pop dx, pop bx: SP আবার FFF8H, ঠিক যেখানে CPU IP রেখেছিল। এখন stack-এর মাথায় IP, CS, FLAGS সাজানো; IRET-এর জন্য তৈরি।
  9. IRET. IP = 0117H, CS = 1000H, FLAGS = 0246H, SP = FFFEH. IF আবার 1, কোনো STI ছাড়াই। AX-এ 1FFCH: দাম 81.88 টাকা। Stack-এর byte মোছা হয়নি, শুধু SP সরেছে।

এবার একই ঢোকা আর ফেরা একটি ছোট মডেলে দেখুন, আর সঙ্গে একটি ভুলও: ISR-এর শেষে কেউ যদি IRET-এর বদলে near RET লেখেন। মডেলের শুরুর মান stack86-এর run থেকে নেওয়া।

# INT n-এ ঢোকা আর IRET (বা ভুল করে RET)-এর মডেল, stack86.asm-এর মান দিয়ে
mem = {}
def push(cpu, w):
    cpu["SP"] = (cpu["SP"] - 2) & 0xFFFF
    a = (cpu["SS"] << 4) + cpu["SP"]
    mem[a], mem[a + 1] = w & 0xFF, w >> 8
def pop(cpu):
    a = (cpu["SS"] << 4) + cpu["SP"]
    cpu["SP"] = (cpu["SP"] + 2) & 0xFFFF
    return mem[a] | mem[a + 1] << 8
def show(t, cpu):
    st = " ".join(f"{mem.get((cpu['SS'] << 4) + a, 0):02X}" for a in range(0xFFF8, 0xFFFE))
    print(f"{t:12} CS:IP={cpu['CS']:04X}:{cpu['IP']:04X} SP={cpu['SP']:04X}"
          f" FLAGS={cpu['FLAGS']:04X} IF={cpu['FLAGS'] >> 9 & 1}  FFF8: {st}")
def interrupt(cpu, vec_cs, vec_ip):
    push(cpu, cpu["FLAGS"])
    cpu["FLAGS"] &= ~0x0300          # IF = 0, TF = 0
    push(cpu, cpu["CS"]); push(cpu, cpu["IP"])
    cpu["CS"], cpu["IP"] = vec_cs, vec_ip
def iret(cpu):
    cpu["IP"] = pop(cpu); cpu["CS"] = pop(cpu); cpu["FLAGS"] = pop(cpu)
def ret(cpu):                         # near RET: শুধু IP
    cpu["IP"] = pop(cpu)

for name, leave in (("IRET", iret), ("RET (ভুল)", ret)):
    mem.clear()
    cpu = dict(CS=0x1000, IP=0x0117, SS=0x1000, SP=0xFFFE, FLAGS=0x0246)
    print("---", name)
    show("INT 60h-এর আগে", cpu)
    interrupt(cpu, 0x1000, 0x0118)
    show("ISR-এ ঢুকে", cpu)
    leave(cpu)
    show("ফেরার পরে", cpu)

আসল আউটপুট (ব্রাউজারের Python):

--- IRET
INT 60h-এর আগে CS:IP=1000:0117 SP=FFFE FLAGS=0246 IF=1  FFF8: 00 00 00 00 00 00
ISR-এ ঢুকে   CS:IP=1000:0118 SP=FFF8 FLAGS=0046 IF=0  FFF8: 17 01 00 10 46 02
ফেরার পরে    CS:IP=1000:0117 SP=FFFE FLAGS=0246 IF=1  FFF8: 17 01 00 10 46 02
--- RET (ভুল)
INT 60h-এর আগে CS:IP=1000:0117 SP=FFFE FLAGS=0246 IF=1  FFF8: 00 00 00 00 00 00
ISR-এ ঢুকে   CS:IP=1000:0118 SP=FFF8 FLAGS=0046 IF=0  FFF8: 17 01 00 10 46 02
ফেরার পরে    CS:IP=1000:0117 SP=FFFA FLAGS=0046 IF=0  FFF8: 17 01 00 10 46 02

মডেলের “ISR-এ ঢুকে” লাইনের stack-এর ছয় byte আসল run-এর 17 01 00 10 46 02-এর সঙ্গে মেলে। ভুল সংস্করণে ফেরার ঠিকানা ঠিক মনে হয় (0117H), কিন্তু দুটি ক্ষতি লুকিয়ে আছে: SP = FFFAH, অর্থাৎ stack-এ CS আর FLAGS-এর চার byte আটকে রইল; আর IF = 0, তাই এরপর আর কোনো INTR নেওয়া হবে না। আসল run-এ এর পরিণতি অনুশীলন ২-এ দেখবেন।

সময়ের হিসাব Intel-এর টেবিলের বিষয়, কোর্সের lab clock মাপে না (Spec decision 16). Intel-এর 8086 manual-এর নির্দেশ-সময়ের টেবিলে INT n-এর জন্য 51 clock আর IRET-এর জন্য 24 clock লেখা; 5 MHz-এ (1 clock = 0.2 µs) তা মোটামুটি 10.2 µs আর 4.8 µs. এগুলো datasheet-এর মান, মাপা নয়; আর ISR-এর নিজের নির্দেশের সময় এর সঙ্গে যোগ হয়।

৪ · Type 0 থেকে 4 — CPU-র নিজের পাঁচটি ঘণ্টা

Type 0: divide error

Divide error দুই কারণে হয়, আর পরীক্ষায় দ্বিতীয়টিই বেশি ভুল হয়। প্রথম কারণ ভাজক শূন্য। দ্বিতীয় কারণ, ভাগফল গন্তব্য register-এ আঁটে না: DIV BL-এ AX ÷ BL-এর ভাগফল যায় AL-এ, তাই ২৫৫-এর বেশি হলে ভুল; DIV BX-এ DX:AX ÷ BX-এর ভাগফল AX-এ, ৬৫৫৩৫-এর বেশি হলে ভুল। দুই ক্ষেত্রেই নির্দেশ শেষ হয় না, register বদলায় না, আর CPU type 0 নেয়। বাজারঘরে একটি সহজ উদাহরণ: 8188 পয়সাকে ১০ দিয়ে ভাগ করতে DIV BL লিখলে ভাগফল 818 হয়, যা ৮ বিটে আঁটে না।

; div86.asm - a quotient too big for AL raises type 0
        org 100h
        xor ax, ax
        mov es, ax
        cli
        mov word [es:0], div_err
        mov [es:2], cs          ; vector 0 = 1000h:div_err
        sti
        mov word [resume], done
        mov ax, 8188            ; price, paisa
        mov bl, 10
        div bl                  ; 818 > 255 -> type 0
done:   mov ax, [errors]
        hlt

div_err:
        inc word [cs:errors]
        add sp, 6               ; drop IP, CS, FLAGS
        sti
        jmp [cs:resume]         ; continue at a safe place
resume: dw 0
errors: dw 0

সত্যিকারের run (প্রথম আটটি লাইন বাদ; কলাম ছোট করা):

$ python -B run8086.py div86.asm --trace --regs --mem 0000:0000,4 --mem 1000:FFF8,6
1000:011B mov bl,0xa         AX=1FFC BX=000A SP=FFFE IP=011D --I--Z-P-
1000:011D div bl             AX=1FFC BX=000A SP=FFFE IP=011D --I--Z-P-
---- INT 00h -> vector 1000:0123 (FLAGS, CS, IP pushed)
1000:0123 inc word [cs:0x133] AX=1FFC BX=000A SP=FFF8 IP=0128 ---------
1000:0128 add sp,0x6         AX=1FFC BX=000A SP=FFFE IP=012B ----S----
1000:012B sti                AX=1FFC BX=000A SP=FFFE IP=012C --I-S----
1000:012C jmp word near [cs:0x131] AX=1FFC BX=000A SP=FFFE IP=011F --I-S----
1000:011F mov ax,[0x133]     AX=0001 BX=000A SP=FFFE IP=0122 --I-S----
----
AX=0001 BX=000A CX=0000 DX=0000 SI=0000 DI=0000 BP=0000 SP=FFFE CS=1000 DS=1000 ES=0000 SS=1000 IP=0122 --I-S----
0000:0000  23 01 00 10
1000:FFF8  1D 01 00 10 46 02
[exit code 0 via HLT, 16 instructions]
0118mov ax,8188011Bmov bl,10011Ddiv bl—(type 0 নেওয়া)0123inc word [cs:errors]0128add sp,6012Bsti; jmp [cs:resume]011Fmov ax,[errors]
এই ধাপে
AX · BL
IP · SP
IF
stack-এ IP
errors
  1. ভাগের প্রস্তুতি। AX = 8188 = 1FFCH পয়সা, BL = 10 = 0AH. resume-এ আগেই লেখা হয়েছে done-এর ঠিকানা: ভুল হলে কোথায় ফিরতে হবে।
  2. ভাগ অসম্ভব। 8188 ÷ 10 = 818, ভাগশেষ 8. কিন্তু 818 = 0332H, AL-এ সর্বোচ্চ FFH. নির্দেশ শেষ হয় না: AX এখনো 1FFCH, কিছুই বদলায়নি।
  3. Type 0 নেওয়া। FLAGS, CS, IP stack-এ, SP = FFF8H, IF = 0. রাখা IP এখানে 011DH, div-এর নিজের ঠিকানা, কারণ Unicorn 386-ধাঁচের; আসল 8086 রাখত পরের নির্দেশ 011FH (Spec decision 15).
  4. Handler-এ। IVT-র 00000H-এ 23 01 00 10, তাই 1000H:0123H. Handler ভুলের সংখ্যা এক বাড়ায়: errors = 1.
  5. Stack পরিষ্কার। IRET নয়, add sp,6: রাখা তিনটি word ফেলে দেওয়া। Byte-গুলো মেমরিতে থেকে যায়, তাই run শেষের ছাপে 1D 01 00 10 46 02 পড়া গেছে।
  6. নিরাপদ জায়গায় লাফ। sti দিয়ে interrupt আবার চালু, তারপর jmp [cs:resume] নিয়ে যায় 011FH-এ (done). এই পথ 8086 আর lab দুটিতেই একই ফল দেয়।
  7. ফল। AX = errors = 0001H. Program জানে একবার ভাগ ব্যর্থ হয়েছে, আর ভুল দামের বদলে একটি গোনা যায় এমন ত্রুটি পেয়েছে।

Handler কেন IRET দিয়ে ফেরে না? আসল 8086-এ IRET ভুল ভাগের পরের নির্দেশে নিয়ে যেত, আর program ভুল AL নিয়েই চলত। 80286 আর পরের chip-এ (আর এই lab-এ) IRET একই DIV-এ ফিরে আবার ভুল ঘটাত, অবিরাম। দুই আচরণেই নিরাপদ থাকার উপায় হলো জেনে-বুঝে একটি নির্দিষ্ট জায়গায় ফেরা, ঠিক এই handler যা করে। Reference lab-এর নিজের উদাহরণ int_vector.asm-ও একই কৌশলে ৭ ÷ ০ ধরে আর ছাপে divide error caught. সঙ্গে একটি lab-এর সীমা: একই run-এ দ্বিতীয় divide error পরীক্ষা করে দেখা গেছে, runner সেটিকে type 0 না দেখিয়ে INT 08h হিসেবে থামে; তাই এই পর্বের প্রতিটি program-এ একটিই ভাগের ভুল রাখা হয়েছে।

Type 1: single step

FLAGS-এর TF (trap flag, বিট ৮) 1 হলে CPU প্রতিটি নির্দেশের পরে type 1 নেয়। Debugger এভাবেই এক নির্দেশ করে চালায়: type 1-এর handler register দেখায়, তারপর IRET দিয়ে পরের নির্দেশে পাঠায়। TF বদলানোর সরাসরি নির্দেশ নেই, তাই কৌশলটি হলো PUSHF, stack-এর কপিতে বিট ৮ বদলানো, POPF. Lab-এ এমন একটি program (tf86.asm: তিনটি mov bx, তারপর একই কৌশলে TF বন্ধ) চালালে type 1-এর handler ৮ বার চলেছে: POPF যে নির্দেশে TF চালু করল তার পরে নয়, পরের mov bx,1-এর পর থেকে শুরু, আর TF বন্ধ করা POPF-এর পরে শেষ। Handler-এর ভেতরে কোনো step হয়নি, কারণ ঢোকার সময় TF শূন্য হয়: trace-এর ISR-লাইনগুলোতে “T” নেই। এই পর্যবেক্ষণগুলো Unicorn-এর 386-ধাঁচের core-এর (Spec decision 15); Intel-এর 8086 manual-ও একই নিয়ম বলে, তবে সূক্ষ্ম ধারের ঘটনা আসল chip-এ যাচাই করা হয়নি।

$ python -B run8086.py tf86.asm --regs
----
AX=0008 BX=0003 CX=0000 DX=0000 SI=0000 DI=0000 BP=0000 SP=FFFE CS=1000 DS=1000 ES=0000 SS=1000 IP=012A --I--Z-P-
[exit code 0 via HLT, 35 instructions]
এই নির্দেশ শেষ হওয়ার পরে
নির্দেশ
TF
type 1?
steps
BX · AX
  1. TF চালু, কিন্তু এখনই নয়। pushf, pop ax, or ax,0100h, push ax, popf: AX = 0346H, বিট ৮ = 1. Trace-এর ছাপে “T” এল, তবু এই popf-এর পরে type 1 হয়নি।
  2. প্রথম step. mov bx,1 শেষ হতেই type 1: FLAGS, CS, IP stack-এ, SP = FFF8H. Handler steps এক বাড়ায়। ISR-এর ভেতরে TF = 0, তাই handler নিজে step হয় না।
  3. ফেরা। iret রাখা FLAGS ফিরিয়ে আনে, তাতে TF = 1. এই iret-এর পরে নতুন type 1 নেই, কারণ নির্দেশটি শুরুর সময় TF ছিল 0.
  4. দ্বিতীয় step. mov bx,2-এর পরে আবার type 1; steps = 2. Debugger হলে এখানে register দেখিয়ে ব্যবহারকারীর চাপের অপেক্ষা করত।
  5. তৃতীয় step. mov bx,3: steps = 3, BX = 0003H.
  6. TF বন্ধের প্রস্তুতি। pushf, pop ax, and ax,0FEFFh, push ax: চারটি নির্দেশ, চারটি type 1. steps = 7, AX = 0246H (বিট ৮ শূন্য)।
  7. শেষ step. TF বন্ধ করা popf-এর পরেও একবার type 1, কারণ নির্দেশটি শুরুর সময় TF = 1 ছিল। steps = 8.
  8. স্বাভাবিক চলা। mov ax,[steps]-এর পরে কিছু নেই। AX = 0008H, run-এর শেষের ছাপের সঙ্গে হুবহু।

Type 2, 3 আর 4: NMI, breakpoint আর overflow

Type 2 আসে NMI pin থেকে, যা অংশ ৬-এ। Type 3 হলো breakpoint: INT 3-এর একটি এক byte-এর রূপ আছে, CC, যা অন্য সব INT n-এর (CD nn) চেয়ে এক byte ছোট। Debugger কোনো নির্দেশের প্রথম byte সরিয়ে CC বসায়; এক byte বলে সবচেয়ে ছোট নির্দেশেও তা আঁটে, পাশের নির্দেশ নষ্ট হয় না। Type 4 আসে INTO (CE) থেকে, কিন্তু শুধু OF = 1 হলে; না হলে INTO কিছুই করে না। Signed হিসাবের পরে এক byte-এ overflow ধরার উপায় এটি।

$ python -B run8086.py types86.asm --trace --regs      (বাছাই করা লাইন)
1000:011E  CC        int3              ---- INT 03h -> vector 1000:012F
1000:011F  CD03      int byte 0x3      ---- INT 03h -> vector 1000:012F
1000:0123  0432      add al,0x32       AX=0096   (100 + 50: OF = 1)
1000:0125  CE        into              ---- INT 04h -> vector 1000:0136
1000:0128  0414      add al,0x14       AX=001E   (10 + 20: OF = 0)
1000:012A  CE        into              (কিছু হয়নি)
AX=0102 ...  [exit code 0 via HLT, 24 instructions]

এখানে লাইনগুলো trace থেকে বেছে, পাশাপাশি সাজিয়ে দেখানো (কোনো মান বদলানো হয়নি)। Type 3-এর handler প্রতিবার গুনতিতে 1 যোগ করে, type 4-এর handler 100H. শেষে AX = 0102H: দুবার type 3 (CC আর CD 03 একই ঘরে যায়), একবার type 4. দ্বিতীয় INTO-এ OF = 0, তাই কিছু ঘটেনি।

৫ · DOS আর BIOS-এর সেবা — নিজের ISR বসানোর ভদ্র উপায়

IBM PC-তে INT n-এর সবচেয়ে বড় ব্যবহার ছিল সেবা চাওয়া, আজকের system call-এর মতো। BIOS ROM-এ রাখা সেবা: INT 10h পর্দা, INT 13h ডিস্ক, INT 16h কি-বোর্ড, INT 1Ah সময়। MS-DOS প্রায় সব সেবা দিত INT 21h দিয়ে, AH-এ সেবার নম্বর রেখে; AH = 09h দিয়ে লেখা ছাপার পুরো program পর্ব ১৭-এ। কোর্সের lab-এর stub এর ছোট একটি অংশ দেয় (Spec decision 14): AH = 01h, 02h, 09h, 25h, 35h, 4Ch, আর INT 20h, INT 10h/0Eh. সুবিধাটি হলো, সেবা কোথায় থাকে তা program-কে জানতে হয় না; নম্বর জানলেই চলে, আর DOS-এর নতুন সংস্করণ handler সরালেও পুরোনো program চলে।

ডাককাজকোর্সের lab-এ?
INT 10h, AH = 0EhBIOS: AL-এর অক্ষর পর্দায় (teletype)আছে
INT 16h, AH = 00hBIOS: একটি key-র অপেক্ষা; AL-এ ASCII, AH-এ scan codeনেই
INT 1Ah, AH = 00hBIOS: চালু হওয়ার পর থেকে timer-এর tick সংখ্যা, CX:DX-এনেই
INT 21h, AH = 01h / 02h / 09hDOS: একটি অক্ষর পড়া / DL ছাপা / $-শেষ লেখা ছাপাআছে
INT 21h, AH = 25h / 35hDOS: AL-এর vector বসানো (DS:DX) / পড়া (ES:BX)আছে
INT 21h, AH = 4Ch; INT 20hDOS: program শেষ (AL-এ exit code) / শেষআছে

নিজের ISR বসানোর দুটি পথ। সরাসরি পথ, যা stack86 আর div86-এ দেখলেন: ES = 0000H রেখে IVT-তে দুটি word লেখা, আর তার চারপাশে CLI/STI. কেন? দুটি word লেখার মাঝখানে যদি সেই type-এর interrupt আসে, CPU নতুন IP আর পুরোনো CS মিলিয়ে একটি অর্থহীন ঠিকানায় লাফ দেবে। ভদ্র পথ হলো DOS-কে দিয়ে করানো: INT 21h AH = 35h দিয়ে পুরোনো vector ES:BX-এ পড়ে রাখা, AH = 25h দিয়ে DS:DX-এর নতুন ঠিকানা বসানো, আর program শেষের আগে পুরোনোটি ফিরিয়ে দেওয়া। এতে অন্য program-এর বসানো vector নষ্ট হয় না।

; price86.asm - a bazarghar "price service" on INT 60h, installed with DOS 35h/25h
        org 100h
        mov ax, 3560h
        int 21h                 ; ES:BX = old vector 60h
        mov [old60], bx
        mov [old60+2], es
        mov ax, 2560h
        mov dx, isr60           ; DS:DX = new handler
        int 21h
        mov si, weights
        mov cx, 3
next:   mov ax, [si]            ; net weight, g
        int 60h                 ; AX = price, paisa
        call print_u16
        call newline
        add si, 2
        loop next
        push ds
        mov ax, 2560h           ; put the old vector back
        lds dx, [old60]         ; DS:DX = F000h:0180h
        int 21h
        pop ds
        mov ax, 4C00h
        int 21h
; isr60: stack86.asm-এর মতো হুবহু (push bx ... iret)
weights: dw 150, 1250, 500
old60:  dw 0, 0
%include "print_u16.inc"

সত্যিকারের run (ISR-এর ১১ লাইন stack86.asm-এর মতোই, জায়গা বাঁচাতে এখানে দেখানো হয়নি; print_u16.inc reference lab-এর দশমিক ছাপার routine):

$ python -B run8086.py price86.asm --regs --mem 0000:0180,4 --mem 0000:0084,4
983
8188
3275
----
AX=4C00 BX=0180 CX=0000 DX=0180 SI=0155 DI=0000 BP=0000 SP=FFFE CS=1000 DS=1000 ES=F000 SS=1000 IP=013A --I----P-
0000:0180  80 01 00 F0
0000:0084  84 00 00 F0
[exit code 0 via INT 21h/4Ch, 251 instructions]

তিনটি দাম README-এর সঙ্গে মেলে: 150 g → 983 পয়সা = 9.83 টাকা, 1250 g → 81.88 টাকা, 500 g → 32.75 টাকা. আর শেষের 0000:0180 80 01 00 F0 প্রমাণ করে, program যাওয়ার আগে vector 60H-কে stub-এর আসল মান F000H:0180H-এ ফিরিয়ে দিয়েছে। MASM-ধাঁচের বইয়ে একই কাজ MOV DX, OFFSET ISR60 আর ISR60 PROC FAR … IRET … ISR60 ENDP দিয়ে লেখা থাকে; NASM-এ শুধু label লিখলেই offset বোঝায়।

৬ · INTR আর NMI — pin থেকে আসা interrupt আর অগ্রাধিকার

8086-এর দুটি interrupt pin. INTR (pin 18) সাধারণ যন্ত্রের জন্য, level-triggered: যন্ত্র লাইনটি উঁচু ধরে রাখে যতক্ষণ না সেবা পায়। CPU প্রতিটি নির্দেশের শেষে লাইনটি দেখে, আর শুধু IF = 1 হলে নেয়; CLI আর STI তাই শুধু INTR-কে আটকায় বা খোলে। INTR নিলে CPU পরপর দুটি interrupt acknowledge bus cycle চালায়, INTA̅ (minimum mode-এ pin 24) নামিয়ে; দ্বিতীয়টিতে যন্ত্র data bus-এর D7–D0-এ type নম্বরের একটি byte রাখে। IBM PC-তে এই byte দিত 8259 interrupt controller, যা পর্ব ২৬ (8259 PIC)-এ। 8085-এর মতো যন্ত্রকে পুরো নির্দেশ দিতে হয় না, শুধু নম্বর।

NMI (pin 17) হলো non-maskable interrupt: edge-triggered, 0 থেকে 1 হওয়ার মুহূর্তটি ধরে, IF যা-ই থাকুক নেওয়া হয়, আর type সবসময় 2, কোনো acknowledge cycle ছাড়াই। এটি রাখা হয় এমন ঘটনার জন্য যা কোনোভাবেই অপেক্ষা করতে পারে না: বিদ্যুৎ চলে যাচ্ছে, মেমরির ত্রুটি ধরা পড়েছে। বাজারঘরের মতো দোকানে load-shedding-এর আগে UPS-এর সংকেত NMI-তে দিলে firmware শেষ বিক্রির হিসাব রেখে দিতে পারে, যদি হাতে যথেষ্ট সময় থাকে। Lab-এর runner-এ কোনো pin নেই, তাই INTR আর NMI এখানে চালানো যায় না; অংশটি Intel-এর manual থেকে, আর নিচের মডেল শুধু নিয়মটি দেখায়।

হিসাবের উদাহরণ — একটি INTR-এর পুরো পথ

পরীক্ষায় প্রায়ই এভাবে আসে: “একটি 8086 system-এ 8259 timer-এর অনুরোধে type 08H দেয়। IVT-র সংশ্লিষ্ট ঘরে 40 01 00 20 লেখা। Interrupt-এর আগে SS = 3000H, SP = 0100H. ISR কোথায়, আর stack-এর মাথা কোথায় যাবে?” ধাপগুলো:

  1. যন্ত্র INTR উঁচু করে। চলতি নির্দেশ শেষ হয়, IF = 1, তাই CPU অনুরোধ নেয়।
  2. দুটি INTA̅ cycle; দ্বিতীয়টিতে 8259 data bus-এ রাখে 08H.
  3. FLAGS, CS, IP stack-এ: SP = 0100H − 6 = 00FAH, physical address 30000H + 00FAH = 300FAH. IF = TF = 0.
  4. IVT-র ঘর: 08H × 4 = 20H, অর্থাৎ 00020H–00023H. 40 01 → IP = 0140H, 00 20 → CS = 2000H.
  5. ISR = 2000H × 10H + 0140H = 20140H.
  6. ISR register রাখে, কাজ করে, 8259-কে EOI দেয়, register ফেরত দেয়, IRET; SP আবার 0100H.

এই হিসাবের প্রতিটি সংখ্যা Python-এ (seg << 4) + off সূত্রে মিলিয়ে দেখা (0x20140, 0x300fa). Byte-গুলো কাল্পনিক উদাহরণ, কোনো বাস্তব BIOS-এর ঠিকানা নয়।

অগ্রাধিকারউৎসIF = 0 হলে?
সবচেয়ে উঁচুনির্দেশের ভেতরের: divide error, INT n, INTOতবু ঘটে
দ্বিতীয়NMI (type 2)তবু নেওয়া হয়
তৃতীয়INTR (যন্ত্রের দেওয়া type)অপেক্ষা করে
সবচেয়ে নিচুSingle step (type 1, TF = 1)IF-এর ওপর নির্ভর করে না, TF-এর ওপর করে
# একটি নির্দেশ শেষ হলে 8086 কোন অনুরোধটি এখনই নেয় (Intel-এর অগ্রাধিকার)
ORDER = ["internal", "NMI", "INTR", "single-step"]   # উঁচু থেকে নিচু

def decide(pending, IF, TF):
    now, wait = None, []
    for src in ORDER:
        if src not in pending:
            continue
        ok = (src != "INTR" or IF) and (src != "single-step" or TF)
        if ok and now is None:
            now = src
        else:
            wait.append(src)
    return now, wait

cases = [({"INTR"}, 1, 0), ({"INTR"}, 0, 0), ({"NMI", "INTR"}, 0, 0),
         ({"internal", "NMI", "INTR"}, 1, 0), ({"INTR", "single-step"}, 1, 1)]
for pending, IF, TF in cases:
    now, wait = decide(pending, IF, TF)
    p = ", ".join(s for s in ORDER if s in pending)
    print(f"IF={IF} TF={TF} | অনুরোধ: {p}")
    print(f"   এখন নেয়: {now or 'কিছু না'} | বাকি: {', '.join(wait) or '—'}")

আসল আউটপুট (ব্রাউজারের Python):

IF=1 TF=0 | অনুরোধ: INTR
   এখন নেয়: INTR | বাকি: —
IF=0 TF=0 | অনুরোধ: INTR
   এখন নেয়: কিছু না | বাকি: INTR
IF=0 TF=0 | অনুরোধ: NMI, INTR
   এখন নেয়: NMI | বাকি: INTR
IF=1 TF=0 | অনুরোধ: internal, NMI, INTR
   এখন নেয়: internal | বাকি: NMI, INTR
IF=1 TF=1 | অনুরোধ: INTR, single-step
   এখন নেয়: INTR | বাকি: single-step

দ্বিতীয় আর তৃতীয় লাইন-জোড়া IF-এর আসল ভূমিকা দেখায়: IF = 0 হলে INTR অপেক্ষা করে, কিন্তু NMI ঢোকে। চতুর্থ ঘটনায় ভাগের ভুলটি আগে নেওয়া হয়, আর ঢোকার সময় IF = 0 হয় বলে INTR অপেক্ষাতেই থাকে যতক্ষণ না handler STI দেয় বা IRET করে; NMI-র জন্য সেই বাধা নেই। মডেলটি একটি নির্দেশের সীমায় কোন অনুরোধ “এখন” নেওয়া হবে শুধু তা বলে; পরপর কয়েকটি এলে ISR-গুলো ঠিক কোন ক্রমে চলবে, তা Intel-এর manual-এ বিস্তারিত।

আরেকটি নিয়ম, যা stack-এর নিরাপত্তার জন্য: MOV বা POP দিয়ে কোনো segment register বদলানোর ঠিক পরের নির্দেশ পর্যন্ত 8086 interrupt নেয় না। তাই mov ss, ax আর তার পরের mov sp, … পাশাপাশি লিখলে মাঝখানে কোনো interrupt অর্ধেক-বদলানো SS:SP-এ ছয় byte লিখে ফেলতে পারে না।

৭ · ISR লেখার নিয়ম — ছোট, পরিষ্কার, সব ফেরত

8086-এর ISR লেখার নিয়মগুলো পরে Cortex-M-এর firmware-এও প্রায় হুবহু ফিরে আসবে (পর্ব ৪৩: Interrupt আর ISR নকশা)। এখানে আট-দশ লাইনের ISR-এই নিয়মগুলো মানতে হয়:

  • যা ছোঁবেন তা রাখুন: ISR যে register বদলায়, শুরুতে PUSH, শেষে উল্টো ক্রমে POP. Hardware interrupt যেকোনো দুই নির্দেশের মাঝে আসে; মূল program জানেও না যে কিছু ঘটেছে। Software সেবায় (যেমন INT 60h) ফলের register (AX) ব্যতিক্রম, কারণ সেটিই চুক্তি।
  • শেষে IRET, RET নয়: RET শুধু IP তোলে; CS আর FLAGS stack-এ পড়ে থাকে, আর IF শূন্যই থাকে।
  • ছোট রাখুন: ISR চলার সময় IF = 0, অন্য সব INTR অপেক্ষায়। লম্বা কাজ, যেমন দশমিকে ছাপা বা ডিস্কে লেখা, মূল program-এর জন্য রাখুন; ISR শুধু একটি flag বা buffer-এ data রাখুক। এতে অন্য যন্ত্রের interrupt latency কম থাকে।
  • জেনে-বুঝে STI: ISR-এর ভেতরে STI দিলে বেশি জরুরি যন্ত্র ISR-কে থামাতে পারে (nested interrupt). তখন stack-এর গভীরতা বাড়ে, আর ISR-কে reentrant হতে হয়, অর্থাৎ একই সঙ্গে দুবার চললেও ঠিক থাকতে হয়; stack frame আর reentrancy-র মূল কথা পর্ব ১৮-এ।
  • 8259 থাকলে EOI: Hardware ISR-এর শেষে 8259-কে “শেষ হলো” (EOI) জানাতে হয়, না হলে একই বা নিচু অগ্রাধিকারের পরের interrupt আর আসে না। বিস্তারিত পর্ব ২৬-এ।
  • ভাগ করা data সাবধানে: মূল program যদি দুই নির্দেশে একটি ৩২ বিটের গুনতি পড়ে, আর মাঝখানে ISR সেটি বদলায়, ফল অর্ধেক পুরোনো, অর্ধেক নতুন। সমাধান: পড়ার সময় CLI/STI, ঠিক যেমন vector লেখার সময়।

সাবধান: DOS-এর বেশিরভাগ সেবা reentrant নয়, তাই hardware ISR-এর ভেতর থেকে INT 21h ডাকা পুরোনো PC-তে রহস্যময় ঝুলে-যাওয়ার পরিচিত কারণ ছিল। এই পর্বের INT 60h-এর ISR-এ কোনো DOS ডাক নেই, শুধু হিসাব; reference lab-এর int_vector.asm software interrupt বলে নিজের ISR থেকে ছাপতে পারে, কারণ সেখানে কিছু অপ্রত্যাশিতভাবে থামে না।

আরও গভীরে: MOV SS-এর পরে এক নির্দেশ interrupt আটকে রাখার নিয়মটি নিয়ে বহুল প্রচলিত একটি ইতিহাস আছে: বিভিন্ন সূত্রের বর্ণনায় প্রথম দিকের কিছু 8088 chip-এ এই সুরক্ষা ঠিকমতো কাজ করত না, তাই পুরোনো কোডে CLI … MOV SS … MOV SP … STI লেখার অভ্যাস তৈরি হয়, পরে chip ঠিক করা হয়। আরও একটি সূক্ষ্মতা Intel-এর manual-এ: একাধিক prefix-সহ REP string নির্দেশ (পর্ব ১৯; যেমন segment override + REP) interrupt-এ থামলে 8086 ফেরার সময় শুধু শেষ prefix মনে রাখে। 80286 থেকে real mode-এর IVT-কেও আর 00000H-এ বাঁধা রাখতে হয় না: IDTR register টেবিলের শুরু বলে দেয়, যেমন Cortex-M-এ VTOR (পর্ব ৩০)।

পরীক্ষা ও ইন্টারভিউতে: “Type 21H-এর vector কোথায়?” → 21H × 4 = 00084H–00087H. “IVT-র মাপ?” → ২৫৬ × ৪ = 1 KB, 00000H–003FFH. “Interrupt নিলে stack-এ কী যায়?” → FLAGS, CS, IP (এই ক্রমে), SP ছয় কমে, IF আর TF = 0. “IRET আর RET-এর পার্থক্য?” → IRET তিনটি word তোলে, FLAGS-সহ; RET শুধু IP (far RET হলে IP আর CS). “Divide error কখন?” → ভাজক 0, বা ভাগফল AL/AX-এ আঁটে না; type 0. “IF কোনটিকে আটকায়?” → শুধু INTR; NMI, INT n আর exception নয়।

৮ · AI-এর যুগে 8086-এর interrupt যাচাই

8086-এর interrupt নিয়ে AI assistant-এর উত্তর প্রায়ই প্রায়-ঠিক হয়, আর ভুলগুলো ঠিক সেই জায়গায়, যেখানে পরীক্ষক নম্বর কাটেন: ক্রম, byte-এর ক্রম আর chip-এর প্রজন্ম।

AI প্রায়ই যা করেকীভাবে ধরবেন
Vector-এর ঘরে আগে CS, পরে IP বলেRun-এ --mem 0000:0180,4: 18 01 00 10, আগে IP
Stack-এ রাখার ক্রম উল্টো বলে (IP আগে)Run-এর পরে --mem 1000:FFF8,6: নিচের ঠিকানায় IP, ওপরে FLAGS
8085-এর TRAP, RST 7.5 বা SIM/RIM 8086-এ ঢুকিয়ে দেয়Intel-এর 8086 manual-এর pin আর নির্দেশের তালিকা; NASM-এ cpu 8086 দিয়ে assemble
“IF = 0 হলে কোনো interrupt আসে না” বলেIF শুধু INTR আটকায়; NMI, INT n, divide error আসে
Divide error-এ ফেরার ঠিকানা নিয়ে 8086 আর 80286+ মিশিয়ে ফেলে8086: পরের নির্দেশ; 80286 থেকে আর lab-এ: DIV নিজে (Spec decision 15)
Clock সংখ্যা উৎস ছাড়া বলে, বা lab-এর run-কে সময়ের মাপ বলেIntel-এর টেবিল মেলানো; lab clock মাপে না (Spec decision 16)
ISR-এ register না রেখে, বা RET দিয়ে শেষ করা কোড দেয়Runner-এ চালিয়ে SP আর IF দেখা: ফেরার পরে SP = FFFEH আর “I” থাকা চাই

AI-কে কাজে লাগাতে প্রসঙ্গ আর যাচাইয়ের শর্ত শুরুতেই দিন:

আমি Intel 8086 (8085, 80286 বা 386 নয়) শিখছি, NASM syntax-এ, .COM program (org 100h), DOS INT 21h দিয়ে। ১. INT 60h-এর জন্য একটি ISR লিখে দাও যা AX-এ গ্রাম পেয়ে AX-এ দাম (পয়সা) ফেরায়: (g × 6550 + 500) / 1000. যে register বদলাবে তা PUSH/POP করবে, শেষে IRET. ২. ISR-টি DOS-এর AH=35h দিয়ে পুরোনো vector রেখে AH=25h দিয়ে বসাও, আর শেষে পুরোনোটি ফিরিয়ে দাও। ৩. INT 60h নেওয়ার মুহূর্তে SP = FFFEH হলে stack-এর কোন ঠিকানায় কোন word যায়, ছক করে দেখাও। IF আর TF কী হয়? ৪. কোনো clock সংখ্যা দিলে Intel-এর 8086 manual-এর টেবিল থেকে দাও, না জানলে বলো "নিশ্চিত নই"। 8085 বা 386-এর কোনো নির্দেশ আনবে না।

AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট

ভাবনার প্রশ্ন

প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।

প্র ০১8085 যেখানে প্রতিটি interrupt-এর ঠিকানা chip-এর ভেতরে বেঁধে দিয়েছিল, 8086 কেন টেবিলটি সাধারণ RAM-এ রাখল? এই নমনীয়তার লাভ আর বিপদ কী ছিল?

8085-এর স্থির ঠিকানা (TRAP 0024H, RST 7.5 003CH) সরল, কিন্তু দুটি সমস্যা ছিল। প্রথমত, ঠিকানাগুলো মেমরির নিচের দিকে, যেখানে সাধারণত ROM থাকে; ISR বদলাতে হলে ROM বদলাতে হতো, বা সেখানে একটি JMP রেখে RAM-এর কোনো জায়গায় লাফানোর কৌশল লাগত। দ্বিতীয়ত, ঘর ছিল মাত্র কয়েকটি, তাই অনেক যন্ত্র একই ঘর ভাগ করত, আর ISR-কে নিজেই খুঁজতে হতো কে ডেকেছে। 8086 এই দুটিকেই একসঙ্গে সমাধান করল: ২৫৬টি নম্বর, আর প্রতিটির জন্য একটি ৪ byte-এর ঠিকানা, মেমরির একেবারে শুরুতে, যেখানে RAM রাখাই স্বাভাবিক।

লাভ ছিল বিশাল। একই BIOS ROM-এর সঙ্গে বিভিন্ন program নিজের handler বসাতে পারত; DOS তার সব সেবা একটি নম্বরে (21H) দিতে পারল; আর মূল handler-এর আগে নিজের handler বসিয়ে, কাজ সেরে পুরোনোটিকে ডেকে দেওয়া (chaining) সম্ভব হলো। DOS যুগের TSR program, যেমন কি-বোর্ডের shortcut-এ খুলে যাওয়া ক্যালকুলেটর বা বাংলা লেখার utility, ঠিক এভাবেই কাজ করত। এই পর্বের price86-ও সেই ভদ্র নিয়মে পুরোনো vector রেখে আবার ফিরিয়ে দেয়।

বিপদও ঠিক এই নমনীয়তা থেকে। Real mode-এ কোনো সুরক্ষা নেই: যেকোনো program একটি MOV দিয়ে যেকোনো vector বদলাতে পারে। একটি ভুল pointer যদি 00000H–003FFH-এ লেখে, পরের interrupt-এ CPU অচেনা জায়গায় লাফ দেয়, আর কারণ খুঁজে পাওয়া কঠিন। DOS যুগের ক্ষতিকর program-ও ডিস্ক আর DOS-এর vector দখল করে নিজেকে ছড়াত; তার প্রতিরোধে পরে এল protected mode, যেখানে টেবিল বদলানো privileged কাজ, আর আধুনিক OS ব্যবহারকারীর program-কে সেখানে হাতই দিতে দেয় না।

Cortex-M একটি মাঝামাঝি পথ নিয়েছে: vector table সাধারণত থাকে flash-এর শুরুতে, আর VTOR register দিয়ে চাইলে RAM-এ সরানো যায়, তবে privileged কোড থেকেই। পর্ব ৩০-এ তা দেখবেন।

মূল উপলব্ধি: RAM-এ টেবিল রাখা interrupt-কে বদলানো যায় এমন চুক্তি বানাল, যা DOS আর TSR-এর জগৎ সম্ভব করেছে; কিন্তু সুরক্ষা ছাড়া সেই নমনীয়তা ভুল আর অপব্যবহারের দরজাও খুলে দেয়।

প্র ০২Divide error-এ 8086 পরের নির্দেশের ঠিকানা রাখে, অথচ 80286 আর পরের chip রাখে ভুল ঘটানো DIV-এর নিজের ঠিকানা। Intel কেন বদলাল, আর handler লেখকের জন্য এর অর্থ কী?

8086-এর কাছে divide error ছিল একটি সাধারণ interrupt: নির্দেশ ব্যর্থ, CPU পরের নির্দেশের ঠিকানা রেখে type 0-এ যায়, যেন ভাগের পরে কেউ INT 0 ডেকেছে। Handler চাইলে IRET দিয়ে পরের নির্দেশে ফিরতে পারে, তবে তখন AL বা AX-এ যা আছে তা ভাগের ফল নয়, ভাগের আগের মান। অর্থাৎ program ভুল সংখ্যা নিয়েই চলবে, যদি না handler নিজে ফলের register-এ কোনো নির্দিষ্ট মান বসায়।

80286-এ Intel protected mode আনল, আর তার সঙ্গে exception-এর একটি পরিষ্কার শ্রেণিবিভাগ। “Fault” ধরনের exception-এ CPU ভুল ঘটানো নির্দেশের ঠিকানাই রাখে, আর এমন অবস্থায় রাখে যেন নির্দেশটি শুরুই হয়নি। উদ্দেশ্য: handler সমস্যা মেটাতে পারলে নির্দেশটি আবার চালানো যাবে। Virtual memory-র page fault বা segment not present-এর মতো ঘটনায় এটি অপরিহার্য: OS ডিস্ক থেকে পাতা এনে নির্দেশটি আবার চালায়, আর program জানতেও পারে না। Divide error-কেও fault শ্রেণিতে রাখা হলো, যাতে সব fault একই নিয়ম মানে। এই কোর্সের lab-এর Unicorn সেই পরের প্রজন্মের আচরণ দেখায়: div86-এর run-এ stack-এ 011DH, যেখানে আসল 8086 রাখত 011FH (Spec decision 15).

Handler লেখকের জন্য শিক্ষা হলো, ফেরার ঠিকানার ওপর অন্ধ ভরসা না করা। 8086-এর জন্য লেখা একটি handler যদি IRET করে, 80286-এ তা একই DIV-এ ফিরে আবার ভুল ঘটাবে, অবিরাম। দুই প্রজন্মেই নিরাপদ পথ হলো জানা কোনো জায়গায় ফেরা (div86-এর resume কৌশল), বা ভুলটি ঘটার আগেই ভাজক পরীক্ষা করা। বাজারঘরের firmware-এর ক্ষেত্রে দ্বিতীয়টিই ভালো: ওজন শূন্য হলে দর-প্রতি-কেজির ভাগই করবেন না।

আধুনিক উচ্চস্তরের ভাষাতেও এই পার্থক্যের ছাপ আছে: Linux-এ x86-এর divide error প্রোগ্রামে SIGFPE হয়ে পৌঁছায়, আর C-তে শূন্য দিয়ে integer ভাগ undefined behavior. Cortex-M-এ আবার শূন্য দিয়ে ভাগ ডিফল্টে কোনো exception তোলে না, ফল 0 দেয়, যদি না একটি নির্দিষ্ট বিট চালু করা হয় (পর্ব ৩০-এর বিষয়)।

মূল উপলব্ধি: ফেরার ঠিকানা কোথায়, সেটি একটি নকশার সিদ্ধান্ত: 8086 “ভুলের পরে চলা” বেছেছিল, পরের প্রজন্ম “ঠিক করে আবার চালানো”; ভালো handler দুটির কোনোটির ওপর অন্ধভাবে নির্ভর করে না।

প্র ০৩NMI-কে কেন বন্ধ করা যায় না, আর তবু বাস্তব কম্পিউটারে NMI বন্ধ করার উপায় কেন রাখা হয়েছিল? এমবেডেড যন্ত্রে NMI কোন কাজে লাগে?

কিছু ঘটনা অপেক্ষা করতে পারে না। বিদ্যুৎ চলে যাওয়ার সংকেত এলে supply-র capacitor-এ হয়তো কয়েক millisecond-এর শক্তি বাকি; সেই সময়ে জরুরি data রেখে দিতে হবে। Program যদি সেই মুহূর্তে CLI দিয়ে একটি লম্বা কাজ করছিল, আর সংকেতটি INTR-এ আসত, তা অপেক্ষা করত আর সময় ফুরিয়ে যেত। তাই 8086 একটি pin রাখল যা IF মানে না: NMI, type 2, rising edge-এ ধরা। Edge-triggered হওয়ায় একটি ঘটনা একবারই গোনা হয়, লাইন উঁচু থাকলেও বারবার নয়।

IBM PC-তে NMI ব্যবহার হতো মূলত মেমরির parity error জানাতে: RAM-এর একটি বিট নষ্ট হলে আর হিসাব চালিয়ে যাওয়া বিপজ্জনক, তাই CPU যা-ই করুক, থামিয়ে বার্তা দেখানো হতো। আবার প্রচলিত বর্ণনা অনুযায়ী PC-র board-এ NMI লাইনকে বাইরে থেকে আটকানোর একটি বিটও ছিল (PC/AT ধাঁচের যন্ত্রে port 70H-এর বিট ৭ বলে উল্লেখ পাওয়া যায়)। পরস্পরবিরোধী মনে হলেও কারণটি বাস্তব: চালু হওয়ার সময়, যখন vector table-এ এখনো কিছু লেখা হয়নি, একটি NMI এলে CPU আবর্জনা ঠিকানায় লাফাত। তাই chip-এর নিয়মে NMI অবাধ্য, কিন্তু board-এর নকশায় বুট শেষ হওয়া পর্যন্ত তাকে আটকানোর ব্যবস্থা।

এমবেডেড যন্ত্রে NMI-র ভূমিকা একই রকম জরুরি কাজের জন্য: brown-out বা বিদ্যুৎ-বিভ্রাটের আগাম সংকেত, clock ব্যর্থ হওয়া, বা নিরাপত্তার কোনো watchdog. Cortex-M-এ NMI-র অগ্রাধিকার স্থির −2, শুধু reset (−3) তার ওপরে, আর এটি কোনো mask দিয়ে বন্ধ হয় না। বাজারঘরের cold-storage monitor-এর কথা ভাবুন: supply যাচ্ছে, এমন সংকেতে NMI-র handler শেষ তাপমাত্রা আর alarm-এর অবস্থা flash-এ লিখে রাখলে, ফিরে আসার পরে বোঝা যাবে বিদ্যুৎহীন সময়ে ঘর কতটা গরম হয়েছিল।

তবে NMI-র handler লেখা কঠিন। এটি যেকোনো মুহূর্তে আসে, এমনকি অন্য ISR-এর মাঝখানে বা ভাগ করা data-র অর্ধেক-লেখা অবস্থায়, তাই সেখানে lock নেওয়া বা জটিল কাজ করা বিপজ্জনক। ভালো নকশায় NMI handler খুব ছোট: কয়েকটি মান রাখে, একটি flag দেয়, আর বাকিটা পরে স্বাভাবিক কোড করে।

মূল উপলব্ধি: NMI জরুরি ঘটনার জন্য এমন পথ, যা কোনো software ভুলে বন্ধ হয় না; তবু বুটের মতো নাজুক সময়ে board-স্তরে আটকানো আর handler-কে অতি ছোট রাখা বাস্তব নকশার অংশ।

প্র ০৪Intel type 5–31 সংরক্ষিত বলেছিল, IBM PC তবু সেগুলো ব্যবহার করল। পরের chip-এ এর ফল কী হলো, আর এমবেডেড নকশায় এর শিক্ষা কী?

১৯৮১ সালের IBM PC-র নকশাকারেরা কয়েকটি সংরক্ষিত নম্বর কাজে লাগালেন: type 5 হলো print screen, আর 8259 interrupt controller-এর আটটি hardware line (timer, কি-বোর্ড, ডিস্ক ইত্যাদি) বসল type 08H থেকে 0FH-এ। 8088-এ এসব নম্বর Intel নিজে ব্যবহার করত না, তাই তখন কোনো সংঘাত ছিল না। সমস্যা দেখা দিল যখন Intel তাদের সংরক্ষিত জায়গা সত্যিই কাজে লাগাল।

80186/80188-এ type 5 হলো BOUND নির্দেশের exception, আর 80286-এ type 8 থেকে কয়েকটি নম্বর নানা exception-এর জন্য, যেমন double fault (8) আর general protection (0DH). ফলে একটি PC-তে একই type নম্বর দুটি সম্পূর্ণ আলাদা কারণে আসতে পারত: hardware timer-এর tick, নাকি CPU-র নিজের গুরুতর exception? Handler-কে নানা কৌশলে বুঝতে হতো কোনটি। Protected mode-এর OS-গুলো তাই 8259-কে নতুন করে program করে hardware line-গুলোকে 20H-এর ওপরের নম্বরে সরিয়ে নেয়; Linux সহ অনেক OS ঠিক এটিই করে। Real mode-এর BIOS-এর জগতে কিন্তু পুরোনো ব্যবস্থাই রয়ে গেল, সামঞ্জস্যের জন্য।

শিক্ষাটি এমবেডেড কাজে সরাসরি খাটে। Datasheet যখন বলে “reserved, write 0” বা “এই বিট ব্যবহার করবেন না”, সেটি ভবিষ্যতের প্রতিশ্রুতি: পরের সংস্করণের chip সেখানে কিছু রাখতে পারে। আজ কাজ করছে বলে সংরক্ষিত বিট বা ঠিকানা ব্যবহার করলে পরের chip-এ অদ্ভুত ত্রুটি আসে, যা খুঁজে পাওয়া কঠিন। Microcontroller-এর register-এ read-modify-write করার সময় সংরক্ষিত বিট অক্ষত রাখার নিয়মও (পর্ব ৩৫-এর বিষয়) একই কারণে।

আরেকটি শিক্ষা হলো সামঞ্জস্যের দাম। IBM-এর একটি সুবিধাজনক সিদ্ধান্ত চার দশক ধরে PC-র firmware আর OS-কে বয়ে বেড়াতে হয়েছে। বাজারঘরের device-এর firmware-ও একবার মাঠে গেলে তার MQTT topic, payload-এর গঠন আর vector-এর বিন্যাস বদলানো কঠিন হয়ে যায়।

মূল উপলব্ধি: “Reserved” মানে “ভবিষ্যতের জন্য রাখা”; তা ব্যবহার করলে আজ সুবিধা, কাল সংঘাত, আর একবার ছড়িয়ে পড়লে সেই সংঘাত বহু বছর সামঞ্জস্যের বোঝা হয়ে থাকে।

প্র ০৫INT 21h-এর মতো software interrupt দিয়ে OS-এর সেবা চাওয়া কেন জনপ্রিয় হলো, আর আধুনিক CPU আর microcontroller এই ধারণাকে কীভাবে বদলেছে?

একটি program-কে DOS-এর ফাইল খোলার কোড ডাকতে হলে সেই কোড কোথায় আছে জানতে হতো, যদি সাধারণ CALL ব্যবহার করা হতো। কিন্তু DOS-এর প্রতিটি সংস্করণে কোড সরে যায়, আর মেমরিতে DOS কোথায় বসবে তা যন্ত্রভেদে আলাদা। INT 21h এই সমস্যার পরিষ্কার সমাধান: program শুধু একটি নম্বর জানে, ঠিকানা জানে vector table, আর DOS চালু হওয়ার সময় নিজের ঠিকানা সেখানে লিখে দেয়। নির্দেশটি মাত্র দুই byte, FLAGS-ও রক্ষা হয়, আর AH-এ সেবার নম্বর দিয়ে একটি প্রবেশপথে শত শত সেবা দেওয়া যায়।

এটিই Operating Systems পর্ব ০৫-এর system call-এর আদি রূপ। পার্থক্য হলো, real mode-এ কোনো privilege নেই: INT 21h ডাকা আর DOS-এর কোডে সরাসরি লাফানোর মধ্যে সুরক্ষার কোনো পার্থক্য নেই। Protected mode-এ software interrupt একটি দরজা হয়ে উঠল: ব্যবহারকারীর program কম অধিকারে চলে, আর INT 80h-এর মতো নির্দিষ্ট পথ দিয়েই kernel-এর বেশি অধিকারে ঢুকতে পারে। পরে গতির জন্য x86-এ আলাদা নির্দেশ এল (SYSENTER, SYSCALL), কারণ সাধারণ interrupt-এর পথ টেবিল পড়া আর অনেক যাচাইয়ের জন্য ধীর।

Cortex-M-এ একই ধারণার নাম SVC (supervisor call): একটি নির্দেশ, যার ভেতরে একটি ছোট নম্বর, যা একটি exception তুলে privileged handler-এ নিয়ে যায়। RTOS প্রায়ই এভাবে task থেকে kernel-এর সেবা দেয় (পর্ব ৩০-এর exception-এর তালিকায় এর জায়গা)। এই পর্বের বাজারঘরের INT 60h দাম-সেবাও এই ধাঁচের একটি ছোট API: যে program দাম চায়, তাকে দরের সংখ্যা বা হিসাবের সূত্র জানতে হয় না। দর বদলালে শুধু ISR বদলায়।

তবে software interrupt সস্তা নয়। Intel-এর টেবিলে INT n 51 clock, যেখানে একটি near CALL অনেক কম; ছোট কাজের জন্য প্রতিবার interrupt-এর পথে যাওয়া অপচয়। তাই সেবার প্রবেশপথ আর ঘন ঘন ডাকা ছোট হিসাব আলাদা রাখাই ভালো নকশা।

মূল উপলব্ধি: Software interrupt সেবাকে ঠিকানা থেকে আলাদা করে একটি নম্বরের চুক্তিতে বেঁধেছিল; protected mode সেই চুক্তিকে সুরক্ষার দরজা বানাল, আর Cortex-M-এর SVC আজও একই ধারণা বয়ে চলে।

অনুশীলন

প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি program-এর উত্তর কোর্সের 8086 runner-এ চালিয়ে যাচাই করা।

  1. নকশা ও বাস্তবায়ন — cold room-এর সীমা-সেবা: একটি INT 61h ISR লিখুন, যা AX-এ তাপমাত্রা × 100 (signed; 850 মানে 8.50 °C) পেয়ে AL-এ ফেরায় 1 (8.00 °C-এর ওপরে, high alarm), 2 (0.00 °C-এর নিচে, low alarm) বা 0 (ঠিক আছে)। DOS-এর AH = 25h দিয়ে বসান, তারপর 850, −50 আর 500 দিয়ে পরীক্ষা করে ফলের অঙ্ক ছাপুন। (Hysteresis আর পরপর তিনটি পড়ার নিয়ম এখানে বাদ।)
            org 100h
            mov ax, 2561h
            mov dx, isr61
            int 21h                 ; vector 61h = DS:DX
            mov si, temps
            mov cx, 3
    next:   mov ax, [si]
            int 61h
            mov dl, al
            add dl, '0'
            mov ah, 02h
            int 21h                 ; print 0, 1 or 2
            add si, 2
            loop next
            mov ax, 4C00h
            int 21h
    isr61:  cmp ax, 800             ; above 8.00 C?
            jg .high
            cmp ax, 0               ; below 0.00 C?
            jl .low
            mov al, 0
            iret
    .high:  mov al, 1
            iret
    .low:   mov al, 2
            iret
    temps:  dw 850, -50, 500

    সত্যিকারের run ছাপে 120, আর [exit code 0 via INT 21h/4Ch, 47 instructions]. সীমা দুটি README-এর: high alarm 8.00 °C-এর ওপরে, low alarm 0.00 °C-এর নিচে। তুলনায় JG/JL (signed) লাগবে, কারণ −50 = FFCEH; unsigned JA দিলে −50-কে 65486 ধরে “high” বলত। ISR কোনো register রাখেনি, কারণ শুধু AL বদলায়, আর সেটিই চুক্তির ফল; তুলনা flag বদলায়, কিন্তু IRET ডাকার আগের FLAGS ফিরিয়ে দেয়। নকশার একটি প্রশ্ন: ফল AL-এ না দিয়ে CF-এ দিলে কী হতো? IRET FLAGS stack থেকে ফেরত আনে, তাই CF-এর ফল মুছে যেত।

  2. ভুল খুঁজুন — ISR-এর শেষ লাইন: একজন stack86-এর ISR-এর শেষে iret-এর বদলে ret লিখলেন, আর মূল program-এ int 60h-এর পরে দামটি মেমরিতে রেখে, একটি বার্তা ছাপিয়ে, শেষে .COM-এর নিয়মে ret দিয়ে বেরোতে চাইলেন। Assemble ঠিকঠাক হলো। চালালে কী হবে, আর কেন?

    সত্যিকারের run-এর শেষ লাইন: error: CPU exception: Invalid instruction (UC_ERR_INSN_INVALID) at 0000:0043. কারণ ধাপে ধাপে: int 60h ছয় byte রাখে (SP = FFF8H). ISR-এর ret শুধু IP = 0117H তোলে, তাই মূল program ঠিক জায়গায় ফেরে আর দামও ঠিক (AX = 1FFCH); কিন্তু SP = FFFAH আর IF = 0, trace-এ flag-এর ছাপ ---------. শেষে মূল program-এর ret stack-এর মাথা থেকে যা তোলে তা DOS-এর রাখা 0000H নয়, interrupt-এর রেখে যাওয়া CS = 1000H. CPU তাই 1000H:1000H-এ লাফ দেয়, যেখানে শুধু শূন্য byte; trace-এ সেখান থেকে 0000 byte-এর নির্দেশ একের পর এক চলে, আর শেষে 0000:0043-এ অবৈধ নির্দেশে run থামে। ঠিক রূপ: ISR-এর শেষে iret. শিক্ষা: ভুলটি ঘটে এক জায়গায়, ধরা পড়ে সম্পূর্ণ অন্য জায়গায়।

  3. হিসাব — টেবিল থেকে stack: (ক) Type 1CH-এর vector IVT-র কোন চার byte-এ? (খ) সেখানে 34 12 00 F0 থাকলে handler-এর physical address কত? (গ) 2000H:0050H-এ রাখা দুই byte-এর INT 1CH চলার মুহূর্তে SS = 3000H, SP = 0100H, FLAGS = 0202H. ঢোকার পরে SP কত, আর 300FAH থেকে ছয় byte কী?

    (ক) 1CH × 4 = 70H, তাই 00070H–00073H. (খ) IP = 1234H, CS = F000H, তাই F0000H + 1234H = F1234H. (গ) তিনটি word রাখা হয়, SP = 0100H − 6 = 00FAH; physical address 30000H + 00FAH = 300FAH. ক্রম: আগে FLAGS (300FEH-এ), তারপর CS (300FCH-এ), শেষে IP (300FAH-এ)। IP হলো পরের নির্দেশ, 0050H + 2 = 0052H. তাই 300FAH থেকে: 52 00 00 20 02 02. ঢোকার পরে FLAGS = 0002H (IF আর TF শূন্য)। হিসাবটি এই পর্বের entry.py-র push নিয়মে Python-এ চালিয়ে মেলানো: 0xfa 0x300fa 52 00 00 20 02 02.

  4. আগে বলুন, তারপর চালান — চারটি interrupt নির্দেশ: Type 3-এর handler একটি word গুনতিতে 1 যোগ করে, type 4-এর handler 100H যোগ করে, দুটিই IRET দিয়ে ফেরে, আর গুনতি শুরুতে 0. তারপর চলে: int3, int 3, mov al,100, add al,50, into, mov al,10, add al,20, into. শেষে গুনতি কত?

    দুটি type 3: int3 (এক byte CC) আর int 3 (দুই byte CD 03) একই vector-এ যায়, গুনতি 2. 100 + 50 = 150, signed ৮ বিটে আঁটে না (সীমা 127), তাই OF = 1, প্রথম into type 4 নেয়: +100H. 10 + 20 = 30, OF = 0, দ্বিতীয় into কিছু করে না। মোট 0102H. সত্যিকারের run (types86.asm): AX=0102, [exit code 0 via HLT, 24 instructions]; trace-এ INT 03h দুবার আর INT 04h একবার।

নিজেকে যাচাই করুন

ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।

ক্রম8086-এ INT 60h চলার পরে CPU-র কাজগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. নির্দেশ থেকে type নম্বর 60H পাওয়া
  2. FLAGS stack-এ রাখা
  3. IF আর TF শূন্য করা
  4. CS stack-এ রাখা
  5. পরের নির্দেশের IP stack-এ রাখা
  6. 00180H থেকে নতুন IP আর 00182H থেকে নতুন CS পড়া

8086-এ type 21H-এর interrupt vector কোন physical address থেকে শুরু হয়?

  • 00021H
  • 00042H
  • 00084H
  • 00210H

8086-এ SS = 1000H, SP = FFFEH অবস্থায় একটি INT 60h নেওয়া হলো। ISR-এর প্রথম নির্দেশ চলার আগে SP কত?

  • FFFCH
  • FFFAH
  • 10004H
  • FFF8H

8086-এর IVT-র 00180H থেকে চারটি byte 18 01 00 10. Type 60H-এর handler কোন physical address-এ?

  • 18010H
  • 10118H
  • 11801H
  • 00118H

8086-এ IF = 0 থাকলে নিচের কোনটি CPU নেবে না, অপেক্ষায় রাখবে?

  • INTR pin-এর অনুরোধ
  • NMI pin-এর অনুরোধ
  • INT 21h নির্দেশ
  • শূন্য দিয়ে DIV

8086-এ AX = 1FFCH (8188) আর BL = 0AH (10). DIV BL চালালে কী হয়?

  • AL = 32H, AH = 08H, স্বাভাবিকভাবে শেষ
  • Type 4 (overflow) interrupt
  • Type 0 (divide error) interrupt
  • AX = 0332H, DX = 0008H

8086-এর debugger একটি এক byte-এর নির্দেশের জায়গায় breakpoint বসাতে চায়, পাশের নির্দেশ না ছুঁয়ে। কোন byte বসাবে?

  • CD 03
  • CC
  • CE
  • CF

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:

মনে রাখুন

  1. IVT: 00000H–003FFH, ২৫৬ × ৪ byte; type n-এর ঘর n × 4; ঘরে আগে IP, পরে CS, দুটিই little-endian.
  2. ঢোকা: FLAGS, (IF = TF = 0), CS, IP stack-এ; SP ছয় কমে; তারপর টেবিল থেকে নতুন CS:IP. IRET IP, CS, FLAGS তোলে।
  3. Type 0–4: divide error, single step, NMI, breakpoint (CC), overflow (INTO); 5–31 Intel-এর সংরক্ষিত।
  4. Pin: INTR level, IF মানে, দুটি INTA cycle-এ যন্ত্র type দেয়; NMI edge, IF মানে না, type 2. অগ্রাধিকার: ভেতরের > NMI > INTR > single step.
  5. ISR: register রাখুন, ছোট রাখুন, শেষে IRET; vector লেখায় CLI/STI বা DOS-এর 25h, আর পুরোনোটি ফেরত।

পরের পর্বে: পর্ব ২১ (8086-এর minimum আর maximum mode, bus cycle আর 8088). এই পর্বের INTA cycle আর NMI pin কোন bus সংকেতের সঙ্গে চলে, T1–T4-এ কী ঘটে, আর 8088 কেন একই কাজে দুটি bus cycle নেয়।

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ

এই পর্বটি শেয়ার করুন:
এই পর্বে ভুল পেয়েছেন? জানান