ভার্চুয়ালাইজেশন তত্ত্ব — Popek-Goldberg থিওরেম ও Trap-and-Emulate

এই simulator-টা kernel-and-user-space লেসনের privilege-check যন্ত্রের সরাসরি সম্প্রসারণ — শুধু এবার privilege check ব্যর্থ হলে (trap) সেটা ধরার জন্য একটা VMM বসানো হয়েছে, আর প্রশ্নটা হলো: guest যা ভাবছে ঘটেছে, আর VMM যা ট্র্যাক করছে ঘটেছে — এই দুইটা কখন আলাদা হয়ে যায়।

# trap_and_emulate_sim.py
# Popek-Goldberg trap-and-emulate — একটা toy CPU-তে "sensitive but not
# privileged" instruction (POPF-এর মতো) trap-and-emulate-কে কীভাবে নীরবে
# ভাঙে তার concrete simulation।

class Trap(Exception):
    """CPU privilege check ব্যর্থ হলে এই exception-ই আসল 'trap'।"""
    def __init__(self, opcode, operand):
        self.opcode = opcode
        self.operand = operand


class TinyCPU:
    """
    privilege: 0 = kernel (সব instruction অবাধে চলে), 1 = user
    privileged_set-এ যা আছে শুধু তা-ই user mode-এ trap করে — POPF
    ইচ্ছাকৃতভাবে privileged_set-এর বাইরে রাখা যাবে (x86-এর বাস্তব আচরণ)।
    """
    def __init__(self, privileged_set):
        self.privilege = 0
        self.if_flag = 0          # real, hardware-owned interrupt-enable bit
        self.privileged_set = privileged_set

    def execute(self, opcode, operand):
        if opcode in self.privileged_set and self.privilege != 0:
            raise Trap(opcode, operand)          # সত্যিকারের hardware trap
        # trap না হলে — user mode-এও — instruction "সফলভাবে" চলে (fault নেই)
        if opcode in ("STI", "CLI"):
            self.if_flag = operand
        elif opcode == "POPF":
            if self.privilege == 0:
                self.if_flag = operand           # kernel mode: সত্যিকারের POPF ঠিকঠাক লেখে
            # else: user mode-এ IF-write silently DROP — কোনো fault, কোনো সংকেত নেই


def run_native(program):
    """Baseline — guest kernel সরাসরি real hardware-এ, kernel privilege-এ
    চলছে (VMM নেই)। এটাই 'সঠিক' ground truth আচরণ।"""
    cpu = TinyCPU(privileged_set={"STI", "CLI"})
    trace = []
    for opcode, operand in program:
        cpu.execute(opcode, operand)
        trace.append((opcode, cpu.if_flag))
    return trace


def run_under_vmm(program, privileged_set):
    """
    Guest kernel-কে VMM privilege=1 (deprivileged/user mode)-এ চালায় —
    trap-and-emulate কৌশল। privileged_set-এ থাকা instruction user mode-এ
    trap করলে VMM-এর trap handler emulate করে তার নিজস্ব 'virtual' IF
    (vmm_if) ঠিকভাবে বসায় — সেই vmm_if-ই আসল interrupt delivery নিয়ন্ত্রণ
    করে। যেই instruction privileged_set-এর বাইরে অথচ sensitive (আমাদের
    POPF), সেটা trap-ই করে না — VMM কখনো জানতেই পারে না instruction-টা
    ঘটেছে।

    guest_believes_if সবসময়ই instruction-এর operand — কারণ guest-এর
    দৃষ্টিকোণ থেকে trap-and-emulate transparent হওয়ার কথা: trap হোক বা
    silent no-op হোক, guest কোনো fault দেখে না, তাই ধরে নেয় IF এখন তার
    intended মান।
    """
    cpu = TinyCPU(privileged_set=privileged_set)
    cpu.privilege = 1                     # guest kernel deprivileged
    vmm_if = 0                            # VMM-tracked virtual IF
    trace = []
    for opcode, operand in program:
        try:
            cpu.execute(opcode, operand)
            trapped = False
        except Trap as t:
            trapped = True
            # --- VMM trap handler: guest-এর হয়ে emulate করে ---
            vmm_if = t.operand
            cpu.privilege = 1              # emulate শেষে guest আবার user mode-এ ফেরে
        guest_believes_if = operand        # guest-এর mental model — fault দেখেনি, তাই সফল ধরে নেয়
        trace.append((opcode, trapped, guest_believes_if, vmm_if))
    return trace


PROGRAM = [
    ("STI",  1),   # ইন্টারাপ্ট চালু করো
    ("CLI",  0),   # একটা critical section-এ ঢোকার আগে বন্ধ করো
    ("POPF", 1),   # আগের save করা flags ফেরত আনো (তখন IF=1 ছিল) — বেরিয়ে আসার সময়
]

def show(rows, header):
    print(header)
    print(f"{'opcode':<7}{'trapped?':<10}{'guest ভাবছে IF=':<18}{'VMM-tracked IF=':<18}{'ফলাফল'}")
    for opcode, trapped, guest_if, vmm_if in rows:
        verdict = "MATCH" if guest_if == vmm_if else "MISMATCH  <-- Popek-Goldberg ভঙ্গ!"
        print(f"{opcode:<7}{str(trapped):<10}{guest_if:<18}{vmm_if:<18}{verdict}")
    print()

print("== ধাপ ১: native ground truth (guest সরাসরি kernel privilege-এ, VMM নেই) ==")
for opcode, if_after in run_native(PROGRAM):
    print(f"  {opcode:<5} -> real if_flag = {if_after}")
print()

show(
    run_under_vmm(PROGRAM, {"STI", "CLI"}),
    "== ধাপ ২: ISA-A (বাস্তব x86-এর মতো) — privileged_set = {STI, CLI}; POPF privileged নয় ==",
)

show(
    run_under_vmm(PROGRAM, {"STI", "CLI", "POPF"}),
    "== ধাপ ৩: ISA-B (কাল্পনিক 'পরিষ্কার' ISA) — privileged_set = {STI, CLI, POPF} ==",
)

প্রকৃত output (এই স্ক্রিপ্টটা হাতে চালিয়ে যাচাই করা হয়েছে, হুবহু এটাই আসবে):

== ধাপ ১: native ground truth (guest সরাসরি kernel privilege-এ, VMM নেই) ==
  STI   -> real if_flag = 1
  CLI   -> real if_flag = 0
  POPF  -> real if_flag = 1

== ধাপ ২: ISA-A (বাস্তব x86-এর মতো) — privileged_set = {STI, CLI}; POPF privileged নয় ==
opcode trapped?  guest ভাবছে IF=   VMM-tracked IF=   ফলাফল
STI    True      1                 1                 MATCH
CLI    True      0                 0                 MATCH
POPF   False     1                 0                 MISMATCH  <-- Popek-Goldberg ভঙ্গ!

== ধাপ ৩: ISA-B (কাল্পনিক 'পরিষ্কার' ISA) — privileged_set = {STI, CLI, POPF} ==
opcode trapped?  guest ভাবছে IF=   VMM-tracked IF=   ফলাফল
STI    True      1                 1                 MATCH
CLI    True      0                 0                 MATCH
POPF   True      1                 1                 MATCH

তিনটা পর্যবেক্ষণ, খুব সাবধানে পড়ুন:

১. ধাপ ১ (native) দেখাচ্ছে “সঠিক” আচরণ কী হওয়ার কথা — শেষ পর্যন্ত if_flag = 1, কারণ guest নিজে সরাসরি kernel-এ চলছে, কোনো middle-man নেই।

২. ধাপ ২ (ISA-A)-তে STI আর CLI দুইটাই trap করে, VMM ঠিকভাবে emulate করে — MATCH। কিন্তু POPF trap করে না (privileged_set-এর বাইরে) — guest ভাবছে IF এখন 1 (instruction fault করেনি), কিন্তু VMM-এর tracked vmm_if এখনও 0 (CLI-এর পর যা বসেছিল, POPF সেটা কখনো ছুঁতেই পারেনি VMM-এর দৃষ্টিতে) — MISMATCH। এই একটা লাইনই পুরো থিওরেমের ব্যর্থতা-শর্তের প্রমাণ, সংখ্যায়।

৩. ধাপ ৩ (ISA-B)-তে শুধু একটা জিনিস বদলেছে — POPF-কেও privileged_set-এ ঢুকিয়ে দেওয়া হয়েছে (একটা কাল্পনিক, “পরিষ্কার” ISA যেখানে sensitive ⊆ privileged সত্যিই সত্য)। ফলাফল: তিনটা ধাপেই MATCH — trap-and-emulate নিখুঁতভাবে কাজ করে। এই একটামাত্র পরিবর্তনই — একটা instruction-কে privileged বানানো — পুরো architecture-কে “ভাঙা” থেকে “classically virtualizable”-এ নিয়ে গেছে। এটাই থিওরেমের practical অর্থ: এটা কোনো abstract গণিত না, একটা পরীক্ষাযোগ্য, ইঞ্জিনিয়ারিং-স্তরের শর্ত।

নিজে বাড়ান: SGDT-এর মতো একটা read-only sensitive instruction যোগ করুন যা if_flag না বদলে বরং একটা কাল্পনিক mem_layout variable পড়ে — দেখুন read-sensitivity একই প্যাটার্নে কীভাবে তথ্য-ফাঁস (leak) তৈরি করে, state-mismatch না হলেও।