أساسيات الحاسب والبرمجة الأدلة التقنية

دعم المعالج للأجهزة الافتراضية: VT-x وAMD-V من الداخل

نكتب مشرفاً صغيراً على KVM يشغل ضيفاً من 63 بايت، ونعد مرات الخروج VM Exit ونقيس كلفتها لنفهم ما يفعله VT-x وEPT داخل المعالج.

دعم المعالج للأجهزة الافتراضية: VT-x وAMD-V من الداخل

إذا قمت بتثبيت Docker Desktop أو WSL2 أو برنامج أجهزة افتراضية على جهازك فغالباً مررت بهذه الخطوة: رسالة تطلب منك تفعيل خيار اسمه «Intel Virtualization Technology» أو «SVM Mode» من إعدادات BIOS، ثم إعادة التشغيل، ثم تفتح مدير المهام فتجد في صفحة المعالج سطراً يقول «Virtualization: Enabled». وبعدها يعمل كل شيء، ويعمل Linux كامل داخل Windows بسرعة قريبة من سرعة الجهاز نفسه. ولكن ما الذي فعله هذا الخيار فعلاً؟ هل هو مجرد إذن من الشركة المصنعة، أم أن داخل المعالج دوائر كاملة كانت نائمة ثم استيقظت؟ ولماذا يقول Windows في نفس الجهاز إن «دعم المحاكاة الافتراضية في البرنامج الثابت» غير مفعل مع أن الأجهزة الافتراضية تعمل أمامك؟

في مقال المحاكاة الافتراضية من Hypervisor إلى KVM شرحنا الفكرة العامة: المشرف Hypervisor، وطريقة الاعتراض والمحاكاة Trap and Emulate، والفرق بين النوع الأول والثاني، وقسنا نفس الجهاز الافتراضي مع KVM ودونه فكان الفرق عشرات الأضعاف. أما هنا فسوف ننزل طبقة أعمق إلى المعالج نفسه: ما الذي أضافته Intel وAMD إلى العتاد، وكيف يدخل المعالج إلى الضيف ويخرج منه، وكم يكلف هذا الخروج بالنانوثانية، وسوف نقيس ذلك بمشرف صغير نكتبه بأنفسنا في نحو مئة سطر من لغة C فوق واجهة KVM. وسوف نناقش في هذا المقال ما يلي:

  • لماذا كانت معمارية x86 صعبة على المحاكاة الافتراضية، وكيف تحايلت عليها VMware وXen قبل أن يساعدهما العتاد.
  • ما الذي أضافته تقنيتا VT-x من Intel وAMD-V من AMD: عالمان داخل المعالج اسمهما VMX root وVMX non-root، وبنية التحكم VMCS، والدخول VM Entry والخروج VM Exit.
  • مختبر حقيقي: نقرأ أعلام المعالج ونسأل التعليمة cpuid عن المشرف الذي نعمل تحته، ثم نبني مشرفاً صغيراً على KVM يشغل ضيفاً من 63 بايت، ونعد مرات الخروج وأسبابها ونقيس زمنها.
  • ترجمة الذاكرة على مرحلتين EPT وNPT، وكيف رأينا في المختبر 255 خروجاً في المرة الأولى ثم لا شيء في المرة الثانية.
  • الأجهزة الطرفية: لماذا يحتاج الضيف virtio، ومتى يحتاج IOMMU مثل VT-d.
  • WSL2 وHyper-V مثالاً حقيقياً: لماذا يعمل Windows نفسه ضيفاً على جهازك، وما معنى المحاكاة المتداخلة Nested Virtualization وكم تكلف.
  • حوادث أمنية حقيقية في هذه الطبقة، وأخطاء شائعة، وجدول قرار، وقائمة تحقق قبل أن تعتمد على الأجهزة الافتراضية في عملك.

وهذا المقال ضمن مقالات المعالجات، ويفترض أنك تعرف ما هي مجموعة التعليمات ISA وما الفرق بين فضاء النواة وفضاء المستخدم، فإن لم تكن قرأت عنهما فهذه المقالات تكمل الصورة:

دليلمعمارية المعالج ISA: لماذا لا يعمل برنامج x86 على ARM؟نترجم نفس برنامج C لثلاث معماريات ونقرأ تعليماته سطراً سطراً، لنفهم ما الذي يجعل الملف التنفيذي يعمل على معالج ويرفضه معالج آخر.دليلقصة x86: من Intel 8086 إلى x86-64 الذي صممته AMDكيف وصلت معمارية معالج 16 بت من 1978 إلى أغلب سيرفرات اليوم، ولماذا ما زال معالجك يقلع كأنه 8086، مع قطاع إقلاع يصعد الأوضاع الثلاثة أمامك.دليلالمحاكاة Emulation والترجمة الثنائية: QEMU وRosetta 2نفتح محاكي QEMU ونرى كيف تتحول تعليمات ARM إلى تعليمات x86 ونقيس كلفة كل خطوة، ثم نقارن ذلك بما تفعله Rosetta 2 وWindows Prism.

لماذا كانت x86 صعبة على المحاكاة الافتراضية؟

الفكرة التي يقوم عليها أي مشرف بسيطة: شغل كود الضيف مباشرة على المعالج الحقيقي، فهو أسرع بكثير من ترجمته أو محاكاته، ولكن اجعل الضيف يعمل بصلاحيات أقل من صلاحيات المشرف، بحيث إذا حاول تنفيذ تعليمة خطيرة، مثل تغيير جدول الصفحات أو إيقاف المقاطعات Interrupts أو الكتابة إلى منفذ جهاز، يرفضها المعالج ويرسل خطأ Trap إلى المشرف، فيقوم المشرف بتنفيذ ما أراده الضيف على نسخته الافتراضية من الجهاز ثم يعيده. وقد شرحنا هذه الطريقة في مقال المحاكاة الافتراضية، والمهم هنا شرط واحد فيها: يجب أن يكون كل شيء حساس في المعالج مسبباً لهذا الخطأ عندما ينفذ بصلاحيات منخفضة.

وهذا الشرط له اسم في علوم الحاسب: في عام 1974 نشر Gerald Popek وRobert Goldberg ورقة تقول إن المعمارية تكون قابلة للمحاكاة الافتراضية بهذه الطريقة إذا كانت كل تعليمة حساسة Sensitive Instruction، أي تعليمة تقرأ حالة الجهاز أو تغيرها، هي أيضاً تعليمة مميزة Privileged Instruction، أي تسبب Trap إذا نفذت خارج أعلى مستوى صلاحيات. ومعالجات x86 لم تحقق هذا الشرط، وفي عام 2000 أحصت ورقة Robin وIrvine في مؤتمر USENIX Security سبع عشرة تعليمة في معالج Pentium حساسة ولكنها لا تسبب أي خطأ عندما ينفذها برنامج عادي.

لنأخذ مثالاً واحداً حتى تتضح المشكلة: التعليمة POPF تقرأ من الـ Stack قيمة وتضعها في مسجل الأعلام، ومن هذه الأعلام علم المقاطعات IF. فإذا نفذتها نواة نظام تشغيل في Ring 0 تغير العلم فعلاً، أما إذا نفذتها في مستوى أقل فإن المعالج يتجاهل تغيير IF بصمت دون أي خطأ. والآن تخيل نواة ضيف أنزلها المشرف إلى Ring 1 حتى يحمي نفسه منها، وتريد أن توقف المقاطعات قبل أن تعدل جدولاً مهماً: سوف تنفذ POPF، ولن يحدث شيء، ولن يعرف المشرف بذلك، وسوف تكمل النواة عملها وهي تظن أن المقاطعات متوقفة. وتعليمات مثل SGDT وSMSW تكشف للضيف قيماً حقيقية من المعالج يفترض أن يراها مختلفة، فيعرف أنه ليس في Ring 0 الذي يظنه.

الحل الأول: ترجمة الكود أثناء التشغيل Binary Translation

في أواخر التسعينيات قدمت VMware حلاً عملياً: يعمل كود المستخدم في الضيف مباشرة على المعالج لأنه لا يحتوي تعليمات حساسة تهم المشرف، أما كود نواة الضيف فيمر قبل تشغيله على مترجم يقرؤه على شكل كتل صغيرة، ويستبدل كل تعليمة حساسة باستدعاء إلى المشرف، ويحفظ الكتلة المترجمة في ذاكرة مؤقتة حتى لا يترجمها مرة أخرى. وهذه هي نفس فكرة الترجمة الثنائية التي يستعملها QEMU في وضع TCG، ولكن على نطاق أضيق لأن المعمارية هي نفسها. والحل نجح وبنيت عليه صناعة كاملة، ولكنه معقد جداً، فالمترجم يجب أن يفهم كل حالة غريبة في x86، ويجب أن يتعامل مع كود يعدل نفسه، ومع قفزات إلى منتصف كتلة مترجمة.

الحل الثاني: تعديل الضيف نفسه Paravirtualization

وفي عام 2003 نشر فريق من جامعة Cambridge ورقة Xen and the Art of Virtualization بفكرة أخرى: لماذا نخدع الضيف أصلاً؟ لنعدل نواة الضيف بحيث تعرف أنها تعمل فوق مشرف، فبدلاً من تنفيذ التعليمة الحساسة تستدعي المشرف مباشرة باستدعاء خاص اسمه Hypercall، يشبه استدعاء النظام System Call الذي يستعمله البرنامج ليطلب شيئاً من النواة. وكانت النتيجة أداء ممتازاً، ولكن بشرط أن تملك كود نواة الضيف وتستطيع تعديله، وهذا ممكن مع Linux وغير ممكن مع Windows في ذلك الوقت. ولاحظ أن هذه الفكرة لم تمت مع وصول الدعم العتادي، وإنما انتقلت إلى الأجهزة الطرفية، فأجهزة virtio التي سوف نصل إليها بعد قليل هي Paravirtualization للأقراص والشبكة.

ما الذي أضافته VT-x وAMD-V إلى المعالج؟

في عامي 2005 و2006 وصلت إلى المعالجات تقنية Intel VT-x ثم تقنية AMD-V، والفكرة في الاثنتين واحدة: بدلاً من أن نطرد الضيف من Ring 0 ونحاول اكتشاف تعليماته الحساسة بأنفسنا، نضيف إلى المعالج بعداً جديداً كاملاً للصلاحيات. فيصبح في المعالج عالمان، يسمى الأول في كتيبات Intel وضع VMX root وفيه يعمل المشرف، ويسمى الثاني VMX non-root وفيه يعمل الضيف، ولكل عالم مستوياته الأربعة Ring 0 حتى Ring 3. وبالتالي تعمل نواة الضيف في Ring 0 كما صممت دون أي تعديل، وبرامجه في Ring 3، ولكن كل ذلك داخل العالم الثاني. والصورة التالية تبين الفرق:

رسم من لوحين: على اليسار مستويات الصلاحيات قبل الدعم العتادي، برامج الضيف في Ring 3 ونواة الضيف منزلة إلى Ring 1 والمشرف وحده في Ring 0، مع سهم أحمر لتعليمة حساسة يجب أن يكتشفها المشرف وصندوق يذكر 17 تعليمة لا تسبب Trap. على اليمين عالمان: عالم الضيف VMX non-root فيه Ring 3 للبرامج وRing 0 لنواة الضيف دون تعديل، وتحته عالم المشرف VMX root فيه QEMU أو برنامجنا في Ring 3 وKVM في Ring 0، وبينهما سهم أحمر VM Exit وسهم أخضر VM Entry
قبل الدعم العتادي كان الضيف يطرد من Ring 0، ومع VT-x وAMD-V يأخذ عالماً كاملاً له

وفي الصورة أعلاه لاحظ التالي:

  • في العالم الثاني يرى الضيف كل شيء كما لو كان على جهاز حقيقي، ولكن المعالج نفسه يعرف أنه في وضع non-root، ولذلك يستطيع أن يقرر عند تعليمات وأحداث معينة أن يتوقف ويعود إلى المشرف.
  • الانتقال من الضيف إلى المشرف اسمه الخروج VM Exit، والعودة اسمها الدخول VM Entry، وكلاهما يقوم به المعالج بنفسه بحفظ حالة كاملة واستعادة أخرى، وليس بتعليمة قفز عادية في الكود.
  • المشكلة التي ناقشناها مع POPF اختفت، فنواة الضيف في Ring 0 حقيقي داخل عالمها، وتغيير علم المقاطعات يعمل كما تتوقع، والمشرف يختار عن طريق إعدادات معينة هل يريد أن يعرف بذلك أم لا.

وقد يتساءل البعض: إذا كانت الفكرة واحدة فلماذا اسمان؟ والإجابة أن كل شركة صممت تعليماتها وأسماءها بنفسها، فالمشرف المكتوب لإحداهما لا يعمل على الأخرى دون طبقة خاصة بها، ولذلك تجد في KVM وحدتين منفصلتين هما kvm_intel وkvm_amd. والجدول التالي يضع الأسماء جنباً إلى جنب:

المفهومIntel VT-xAMD-V (SVM)
علم الدعم في /proc/cpuinfovmxsvm
تشغيل الوضعVMXONعلم EFER.SVME
بنية التحكم بالضيفVMCSVMCB
الدخول إلى الضيفVMLAUNCH ثم VMRESUMEVMRUN
الخروج إلى المشرفVM Exit#VMEXIT
ترجمة الذاكرة على مرحلتينEPTNPT (تسميه AMD أيضاً RVI)
عزل الأجهزة الطرفية IOMMUVT-dAMD-Vi

وبقية المقال تستعمل أسماء Intel لأن جهاز المختبر من Intel، والفكرة نفسها تنطبق على AMD.

بنية VMCS والخروج VM Exit: كيف يقرر المعالج متى يتوقف؟

لكل معالج افتراضي vCPU في الضيف منطقة في الذاكرة اسمها VMCS، اختصاراً لـ Virtual Machine Control Structure، وهي التي تجعل الدخول والخروج ممكناً. وحسب كتيبات Intel للمطورين تنقسم هذه البنية إلى أجزاء واضحة: جزء لحالة الضيف Guest State فيه مسجلاته ومسجلات التحكم مثل CR3 وعنوان التعليمة التالية RIP، وجزء لحالة المضيف Host State يقول للمعالج أين يذهب وبأي حالة عندما يخرج، وجزء لإعدادات التحكم Controls يحدد فيه المشرف ما الذي يسبب خروجاً، وجزء أخير لمعلومات الخروج Exit Information يكتب فيه المعالج سبب آخر خروج وتفاصيله.

وإعدادات التحكم هي أهم ما في الأمر، لأنها تجعل الاعتراض اختيارياً ودقيقاً: يستطيع المشرف مثلاً أن يقول «أخرجني عند كل وصول لمنفذ إدخال وإخراج» أو «فقط عند هذه المنافذ»، و«أخرجني عند تعليمة HLT» أو «اتركها للضيف». وهناك تعليمات تسبب خروجاً دائماً مهما كانت الإعدادات، ومنها CPUID، والسبب أن المشرف يجب أن يتحكم فيما يراه الضيف عن المعالج، فهو قد يخفي عنه بعض الميزات حتى يستطيع نقله إلى سيرفر آخر بمعالج أقدم مثلاً. ولذلك اخترنا CPUID في المختبر: نعرف مسبقاً أنها سوف تخرج في كل مرة.

والصورة التالية تبين الحلقة التي يدور فيها كل مشرف مبني على KVM، سواءً كان QEMU أو البرنامج الصغير الذي سوف نكتبه:

رسم من ثلاث طبقات أفقية: فضاء المستخدم في الأعلى فيه برنامج المراقبة الذي يستدعي ioctl KVM_RUN، والنواة في الوسط فيها KVM يجهز ال VMCS ويدخل بالتعليمة VMLAUNCH أو VMRESUME، والضيف في الأسفل يعمل مباشرة على المعالج. سهم أحمر رقم 3 من الضيف إلى صندوق المعالج يحفظ حالة الضيف مع سبب الخروج CPUID، ثم سهم 4 إلى KVM يعالج الخروج، وسهم أخضر 5 يعيد الضيف للعمل، وسهم أحمر 6 يصعد إلى فضاء المستخدم عندما يكون الخروج KVM_EXIT_IO، وصندوق جانبي يشرح أقسام VMCS الخمسة
حلقة KVM_RUN: الخروج القصير يعالج في النواة، والطويل يعود إلى برنامج المستخدم

وفي الصورة أعلاه لاحظ أن هناك نوعين من الخروج: نوع يعالجه KVM داخل النواة ثم يدخل الضيف مباشرة، مثل CPUID وخطأ ترجمة الذاكرة، ونوع لا يعرف KVM ماذا يفعل به لأنه يخص جهازاً يقلده برنامج المستخدم، مثل الكتابة إلى منفذ لبطاقة شبكة يحاكيها QEMU، فيعود الاستدعاء KVM_RUN إلى البرنامج ومعه السبب في بنية مشتركة اسمها kvm_run، فيعالجه البرنامج ثم يستدعي KVM_RUN مرة أخرى. وهذا التقسيم هو سبب وجود KVM في النواة وQEMU في فضاء المستخدم معاً، وسوف نرى بعد قليل أن الفرق بينهما في الزمن كبير.

المختبر Lab: نكتب مشرفاً صغيراً على KVM

الآن سوف نقوم بالتجربة بأنفسنا. والفكرة أن KVM ليس برنامجاً تشغله وإنما واجهة في نواة Linux، يفتحها أي برنامج عن طريق الملف /dev/kvm ويطلب منها بأوامر ioctl أن تنشئ جهازاً افتراضياً وذاكرة ومعالجاً افتراضياً ثم تشغله، وهذا بالضبط ما يفعله QEMU، وتوثيق واجهة KVM في النواة يشرح كل أمر منها، وقد كتب LWN مقالاً معروفاً عن استعمالها بأقل كود ممكن. وسوف نشغل كل شيء داخل Container من debian:trixie-slim على Docker Desktop، والملفات كلها موجودة في مجلد lab مع المقال.

ماذا يقول المعالج عن نفسه؟ cpuinfo وcpuid

قبل أن نكتب أي كود نتأكد أن المعالج يدعم VT-x وأن KVM موجود. وهذا ملف Docker الذي نبني منه بيئة المختبر، وفيه المترجم gcc وأداة cpuid التي تقرأ معلومات المعالج وتشرحها:

# cs3-vt: gcc for the tiny VMM, cpuid to read the CPU feature bits
FROM debian:trixie-slim
RUN apt-get update && apt-get install -y --no-install-recommends gcc libc6-dev binutils make cpuid \
 && rm -rf /var/lib/apt/lists/*
WORKDIR /lab

ثم السكربت الذي يقرأ الأعلام والإعدادات:

#!/bin/sh
# cpu-flags.sh: what this (virtual) CPU says about virtualization
echo "== kernel and CPU"; uname -r; grep -m1 'model name' /proc/cpuinfo
echo "== flags related to virtualization"
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -xE 'vmx|svm|hypervisor|ept|vpid|ept_ad|tpr_shadow|vnmi|flexpriority|unrestricted_guest' | tr '\n' ' '; echo
grep -m1 '^vmx flags' /proc/cpuinfo
echo "== KVM device and module parameters"
ls -l /dev/kvm
for p in nested ept unrestricted_guest enable_shadow_vmcs; do printf '%s=%s\n' $p "$(cat /sys/module/kvm_intel/parameters/$p 2>/dev/null)"; done
echo "== IOMMU"; ls /sys/class/iommu/ 2>/dev/null | head; [ -z "$(ls /sys/class/iommu/ 2>/dev/null)" ] && echo "no IOMMU visible in this VM"
echo "== cpuid leaf 1: VMX and hypervisor bits"
cpuid -1 -l 1 | grep -iE 'VMX: virtual machine extensions|hypervisor guest status'
echo "== cpuid leaf 0x40000000: who is the hypervisor?"
cpuid -1 -r -l 0x40000000
cpuid -1 -l 0x40000000 | grep -i 'hypervisor_id'

ونبني ال Image ونشغل السكربت في Container له صلاحيات كاملة، لأن قراءة بعض الملفات تحتاجها كما سوف نرى:

docker build -t cs3-vt:1 .
docker run --rm --privileged -v "$PWD:/lab" cs3-vt:1 sh cpu-flags.sh

والمخرج سوف يكون كما يلي:

== kernel and CPU
5.15.167.4-microsoft-standard-WSL2
model name	: Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz
== flags related to virtualization
vmx hypervisor tpr_shadow vnmi ept vpid ept_ad 
vmx flags	: vnmi invvpid ept_x_only ept_ad ept_1gb tsc_offset vtpr ept vpid unrestricted_guest ept_mode_based_exec
== KVM device and module parameters
crw------- 1 root root 10, 232 Nov 16 19:29 /dev/kvm
nested=Y
ept=Y
unrestricted_guest=Y
enable_shadow_vmcs=N
== IOMMU
no IOMMU visible in this VM
== cpuid leaf 1: VMX and hypervisor bits
      VMX: virtual machine extensions         = true
      hypervisor guest status                 = true
== cpuid leaf 0x40000000: who is the hypervisor?
CPU:
   0x40000000 0x00: eax=0x4000000b ebx=0x7263694d ecx=0x666f736f edx=0x76482074
   hypervisor_id (0x40000000) = "Microsoft Hv"

وفي المخرج أعلاه لاحظ التالي:

  • النواة microsoft-standard-WSL2: نحن لسنا على جهاز حقيقي، وإنما داخل VM يشغلها Docker Desktop عن طريق WSL2، وهذا مهم لكل ما بعده.
  • العلم vmx: المعالج الذي يراه Linux يدعم VT-x، ولو كان المعالج من AMD لرأيت svm مكانه. وإذا لم تجد أياً منهما على سيرفر حقيقي فغالباً الخيار مغلق في BIOS.
  • العلم hypervisor: هذا العلم يقول إن نظام التشغيل نفسه يعمل تحت مشرف، فالمعالج الذي نراه افتراضي، وهو مع ذلك يعرض علم vmx، أي أن المشرف الأعلى يسمح لنا بتشغيل أجهزة افتراضية داخل جهازنا الافتراضي.
  • سطر vmx flags: قائمة الميزات الثانوية التي يدعمها VT-x هنا، ومنها ept لترجمة الذاكرة على مرحلتين، وvpid لوسم سجلات ال TLB حتى لا تمسح عند كل دخول وخروج، وept_1gb للصفحات الكبيرة، وunrestricted_guest الذي يسمح للضيف أن يعمل في الوضع الحقيقي 16 بت مباشرة، وسوف نحتاجه لأن ضيفنا يبدأ في هذا الوضع، وept_mode_based_exec الذي سوف نعود إليه عند الحديث عن Windows.
  • الملف /dev/kvm: موجود، ومالكه root، وهو كل ما يحتاجه أي برنامج ليستعمل KVM.
  • nested=Y: المحاكاة المتداخلة مفعلة في وحدة kvm_intel، أي أن KVM نفسه يستطيع أن يسمح لضيوفه بتشغيل ضيوف.
  • لا يوجد IOMMU: لا يرى هذا ال VM أي وحدة IOMMU، وهذا متوقع داخل VM، وسوف نرى أن الجهاز الحقيقي نفسه لا يستعملها.
  • التعليمة cpuid مع الورقة 0x40000000: عندما يكون علم hypervisor مرفوعاً يحجز المعالج أرقام هذه الورقة وما بعدها للمشرف، والمسجلات ebx وecx وedx فيها نص من 12 حرفاً، وإذا قرأت القيم السداسية عشرية حرفاً حرفاً بترتيب البايتات الصحيح سوف تجد «Microsoft Hv». فالمشرف الحقيقي الذي يحمل كل هذا هو Hyper-V، كما يوثق ذلك توثيق Hyper-V للمطورين.

ماذا يقول Windows على نفس الجهاز؟

والآن نسأل Windows نفسه بسكربت PowerShell صغير:

# windows-check.ps1: what Windows reports about virtualization on this machine
(systeminfo | Select-String 'Hyper-V Requirements').Line
Get-CimInstance Win32_ComputerSystem | Select-Object HypervisorPresent | Format-List
Get-CimInstance Win32_Processor | Select-Object Name, VirtualizationFirmwareEnabled, VMMonitorModeExtensions, SecondLevelAddressTranslationExtensions | Format-List
Get-CimInstance -ClassName Win32_DeviceGuard -Namespace root\Microsoft\Windows\DeviceGuard |
    Select-Object AvailableSecurityProperties, VirtualizationBasedSecurityStatus, SecurityServicesRunning | Format-List

والمخرج سوف يكون كما يلي:

Hyper-V Requirements:          A hypervisor has been detected. Features required for Hyper-V will not be displayed.
HypervisorPresent : True
Name                                    : Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz
VirtualizationFirmwareEnabled           : False
VMMonitorModeExtensions                 : False
SecondLevelAddressTranslationExtensions : False
AvailableSecurityProperties       : {1, 2, 7}
VirtualizationBasedSecurityStatus : 2
SecurityServicesRunning           : {2}

وهنا المفاجأة التي ذكرناها في بداية المقال: المعالج يقول إن VirtualizationFirmwareEnabled وVMMonitorModeExtensions وSecondLevelAddressTranslationExtensions كلها False، مع أن VT-x وEPT يعملان أمامنا داخل Docker. والسبب في السطر الأول: «A hypervisor has been detected»، فعندما يعمل Hyper-V يصبح Windows نفسه ضيفاً مميزاً فوقه يسمى قسم الجذر Root Partition، ويرى معالجاً تقدمه له Hyper-V، ولذلك لا تعكس هذه الخصائص حقيقة العتاد، وsysteminfo نفسه يقول إنه لن يعرض متطلبات Hyper-V لهذا السبب. أما السطر HypervisorPresent : True فهو الجواب الصحيح.

والقسم الأخير من صنف Win32_DeviceGuard، وقيمه مشروحة في صفحة Microsoft عن سلامة الذاكرة: القيمة 1 تعني أن دعم المشرف متاح، و2 أن Secure Boot متاح، و7 أن MBEC متاح، والقيمة 2 في VirtualizationBasedSecurityStatus تعني أن الأمان المبني على المحاكاة VBS مفعل ويعمل، والقيمة 2 في SecurityServicesRunning تعني أن سلامة الذاكرة HVCI تعمل. ولاحظ القيمة الغائبة: لا توجد القيمة 3، أي أن حماية DMA غير متاحة، لأن IOMMU غير مستعمل في هذه اللوحة الأم، وسوف نعود إلى هذه النقطة عند الحديث عن الأجهزة.

كود الضيف: 63 بايت في الوضع الحقيقي

نريد ضيفاً بسيطاً جداً لا يحتاج نظام تشغيل ولا BIOS، فكل معالج x86 يبدأ بعد التشغيل في الوضع الحقيقي Real Mode بعناوين 16 بت، وفيه نستطيع أن نكتب بضعة أسطر Assembly تعمل مباشرة. والكود التالي فيه أربعة اختبارات، يختار المشرف أحدها بوضع رقمه في المسجل AX، وعدد التكرار في المسجل EDI:

# Guest code for vmm.c: 16-bit real mode, loaded at guest physical address 0x1000.
# The VMM puts the test number in AX and the repeat count in EDI before it starts the vCPU.
        .code16
        .globl _start
_start:
        cmp     $1, %ax
        je      alu
        cmp     $2, %ax
        je      do_cpuid
        cmp     $3, %ax
        je      do_io
        cmp     $4, %ax
        je      do_mem
        hlt

alu:                            # 1: plain arithmetic, nothing the CPU must stop for
        dec     %edi
        jnz     alu
        hlt

do_cpuid:                       # 2: CPUID always causes a VM exit under VT-x
        xor     %eax, %eax
        cpuid
        dec     %edi
        jnz     do_cpuid
        hlt

do_io:                          # 3: OUT to port 0x10, handled by our program in user space
        mov     $0x10, %dx
1:      out     %al, %dx
        dec     %edi
        jnz     1b
        hlt

do_mem:                         # 4: write one byte in every 4 KiB page from 0x2000 up to 1 MiB
        mov     $0x0200, %bx
2:      mov     %bx, %es
        movb    $1, %es:0
        add     $0x0100, %bx
        jnz     2b
        hlt

وفي الكود أعلاه لاحظ التالي:

  • الاختبار الأول alu: حلقة تنقص عداداً وتقفز، ولا يوجد فيها أي شيء يجبر المعالج على الخروج، فهي مقياس لسرعة الضيف عندما يعمل وحده.
  • الاختبار الثاني cpuid: نفس الحلقة ومعها CPUID، أي خروج مضمون في كل دورة يعالجه KVM داخل النواة.
  • الاختبار الثالث io: كتابة بايت إلى المنفذ 0x10، وهو منفذ لا يعرفه KVM، فيعود في كل مرة إلى برنامجنا في فضاء المستخدم، وهذا يشبه ما يحدث عندما يكلم الضيف جهازاً يحاكيه QEMU.
  • الاختبار الرابع mem: يكتب بايتاً في بداية كل صفحة من 4 KiB من العنوان 0x2000 حتى نهاية أول 1 MiB، أي 254 صفحة، عن طريق تغيير المسجل ES الذي يضرب في 16، فزيادته بمقدار 0x100 تعني التقدم 4096 بايت.

وبعد التجميع بالأمر as --32 ثم استخراج الكود بالأمر objcopy يصبح الضيف كله 63 بايت، وهذا هو بعد فكه:

    1000:	83 f8 01             	cmp    $0x1,%ax
    1003:	74 10                	je     0x1015
    1005:	83 f8 02             	cmp    $0x2,%ax
    1008:	74 10                	je     0x101a
    100a:	83 f8 03             	cmp    $0x3,%ax
    100d:	74 15                	je     0x1024
    100f:	83 f8 04             	cmp    $0x4,%ax
    1012:	74 19                	je     0x102d
    1014:	f4                   	hlt
    1015:	66 4f                	dec    %edi
    1017:	75 fc                	jne    0x1015
    1019:	f4                   	hlt
    101a:	66 31 c0             	xor    %eax,%eax
    101d:	0f a2                	cpuid
    101f:	66 4f                	dec    %edi
    1021:	75 f7                	jne    0x101a
    1023:	f4                   	hlt
    1024:	ba 10 00             	mov    $0x10,%dx
    1027:	ee                   	out    %al,(%dx)
    1028:	66 4f                	dec    %edi
    102a:	75 fb                	jne    0x1027
    102c:	f4                   	hlt
    102d:	bb 00 02             	mov    $0x200,%bx
    1030:	8e c3                	mov    %bx,%es
    1032:	26 c6 06 00 00 01    	movb   $0x1,%es:0x0
    1038:	81 c3 00 01          	add    $0x100,%bx
    103c:	75 f2                	jne    0x1030
    103e:	f4                   	hlt

لاحظ البادئة 66 قبل dec %edi: في الوضع 16 بت تحتاج كل عملية على مسجل 32 بت هذه البادئة، وقد شرحنا تفاصيل ترميز تعليمات x86 في مقالات المعماريات.

المشرف: برنامج vmm.c

وهذا هو المشرف كاملاً، وهو برنامج عادي يعمل في فضاء المستخدم:

// vmm.c: the smallest useful virtual machine monitor on the Linux KVM API.
// One vCPU in 16-bit real mode, 1 MiB of guest RAM, the guest code from guest.bin at 0x1000.
//   ./vmm <test> <count>      test: 1=alu 2=cpuid 3=io 4=mem (mem runs twice and ignores count)
#include <dirent.h>
#include <fcntl.h>
#include <linux/kvm.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <time.h>
#include <unistd.h>

#define MEM_SIZE (1 << 20)
static int vmfd;
static char statdir[300];

// The per-VM folder is named <pid>-<fd> with the pid as the kernel sees it, which differs from getpid() inside a
// container, so we remember the folders that exist before KVM_CREATE_VM and pick the new one after it.
static char seen[64][256]; static int nseen;
static void scan(int remember) {
    DIR *d = opendir("/sys/kernel/debug/kvm"); struct dirent *e;
    if (!d) return;
    while ((e = readdir(d))) {
        if (!strchr(e->d_name, '-')) continue;
        int old = 0; for (int i = 0; i < nseen; i++) if (!strcmp(seen[i], e->d_name)) old = 1;
        if (remember && nseen < 64) snprintf(seen[nseen++], 256, "%s", e->d_name);
        else if (!remember && !old) snprintf(statdir, sizeof statdir, "/sys/kernel/debug/kvm/%s", e->d_name);
    }
    closedir(d);
}

static void die(const char *m) { perror(m); exit(1); }
static double now(void) { struct timespec t; clock_gettime(CLOCK_MONOTONIC, &t); return t.tv_sec + t.tv_nsec / 1e9; }

// Per-VM counters that KVM keeps in debugfs: /sys/kernel/debug/kvm/<pid>-<vmfd>/<name>
static long kvm_stat(const char *name) {
    char p[400]; snprintf(p, sizeof p, "%s/%s", statdir, name);
    FILE *f = fopen(p, "r"); long v = -1;
    if (f) { if (fscanf(f, "%ld", &v) != 1) v = -1; fclose(f); }
    return v;
}

int main(int argc, char **argv) {
    if (argc < 3) { fprintf(stderr, "usage: %s <1-4> <count>\n", argv[0]); return 2; }
    int test = atoi(argv[1]); long count = atol(argv[2]);

    int kvm = open("/dev/kvm", O_RDWR | O_CLOEXEC);
    if (kvm < 0) die("open /dev/kvm");
    printf("KVM API version: %d\n", ioctl(kvm, KVM_GET_API_VERSION, 0));

    scan(1);
    vmfd = ioctl(kvm, KVM_CREATE_VM, 0);
    if (vmfd < 0) die("KVM_CREATE_VM");
    scan(0);
    printf("KVM counters for this VM: %s\n", statdir);

    // Guest RAM is ordinary memory of this process; KVM maps it into the guest at physical address 0
    uint8_t *mem = mmap(NULL, MEM_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
    if (mem == MAP_FAILED) die("mmap");
    struct kvm_userspace_memory_region region = { .slot = 0, .guest_phys_addr = 0, .memory_size = MEM_SIZE, .userspace_addr = (uint64_t)mem };
    if (ioctl(vmfd, KVM_SET_USER_MEMORY_REGION, &region) < 0) die("KVM_SET_USER_MEMORY_REGION");

    FILE *g = fopen("guest.bin", "rb"); if (!g) die("guest.bin");
    size_t n = fread(mem + 0x1000, 1, 4096, g); fclose(g);
    printf("guest code: %zu bytes at 0x1000\n", n);

    int vcpu = ioctl(vmfd, KVM_CREATE_VCPU, 0);
    if (vcpu < 0) die("KVM_CREATE_VCPU");
    int runsz = ioctl(kvm, KVM_GET_VCPU_MMAP_SIZE, 0);
    struct kvm_run *run = mmap(NULL, runsz, PROT_READ | PROT_WRITE, MAP_SHARED, vcpu, 0);
    if (run == MAP_FAILED) die("mmap kvm_run");

    int passes = (test == 4) ? 2 : 1;
    for (int pass = 1; pass <= passes; pass++) {
        struct kvm_sregs sregs; ioctl(vcpu, KVM_GET_SREGS, &sregs);
        sregs.cs.base = 0; sregs.cs.selector = 0;
        if (ioctl(vcpu, KVM_SET_SREGS, &sregs) < 0) die("KVM_SET_SREGS");
        struct kvm_regs regs = { .rip = 0x1000, .rax = test, .rdi = count, .rflags = 0x2 };
        if (ioctl(vcpu, KVM_SET_REGS, &regs) < 0) die("KVM_SET_REGS");

        long e0 = kvm_stat("exits"), io0 = kvm_stat("io_exits"), h0 = kvm_stat("halt_exits"), pf0 = kvm_stat("pf_fixed");
        long user_io = 0, user_exits = 0;
        double t0 = now();
        for (;;) {
            if (ioctl(vcpu, KVM_RUN, 0) < 0) die("KVM_RUN");
            user_exits++;
            if (run->exit_reason == KVM_EXIT_IO) { user_io++; continue; }
            if (run->exit_reason == KVM_EXIT_HLT) break;
            fprintf(stderr, "unexpected exit_reason %d\n", run->exit_reason); return 1;
        }
        double t = now() - t0;
        long e = kvm_stat("exits") - e0, io = kvm_stat("io_exits") - io0, h = kvm_stat("halt_exits") - h0, pf = kvm_stat("pf_fixed") - pf0;
        static const char *names[] = { "", "alu", "cpuid", "io", "mem" };
        printf("test=%s pass=%d count=%ld time=%.3f s", names[test], pass, test == 4 ? 254 : count, t);
        if (test != 4) printf(" per_iteration=%.1f ns", t * 1e9 / count);
        printf("\n  returned to user space: %ld (KVM_EXIT_IO %ld)\n", user_exits, user_io);
        printf("  KVM counters: exits=%ld io_exits=%ld halt_exits=%ld pf_fixed=%ld\n", e, io, h, pf);
    }
    return 0;
}

وفي الكود أعلاه لاحظ التالي:

  • ثلاثة مستويات من الملفات: نفتح /dev/kvm فنحصل على ملف لـ KVM نفسه، ومنه نطلب KVM_CREATE_VM فنحصل على ملف للجهاز الافتراضي، ومنه نطلب KVM_CREATE_VCPU فنحصل على ملف للمعالج الافتراضي، وكل أمر بعد ذلك يذهب إلى الملف المناسب.
  • ذاكرة الضيف ذاكرة عادية: نحجز 1 MiB بالدالة mmap كما يفعل أي برنامج، ثم نقول لـ KVM بالأمر KVM_SET_USER_MEMORY_REGION إن هذه الذاكرة تظهر للضيف على أنها ذاكرة فعلية تبدأ من العنوان 0، ولذلك نستطيع نسخ كود الضيف إليها بسطر fread عادي.
  • البنية kvm_run: نربطها بالدالة mmap على ملف المعالج الافتراضي، فهي مشتركة بين النواة وبرنامجنا، وفيها يكتب KVM سبب كل عودة إلينا.
  • المسجلات: نجعل RIP يشير إلى 0x1000 حيث وضعنا الكود، ونضع رقم الاختبار في RAX والعدد في RDI، وهذا كل ما يحتاجه الضيف ليبدأ.
  • الحلقة: نستدعي KVM_RUN، فإذا عاد بسبب KVM_EXIT_IO نتجاهل الكتابة ونعيد التشغيل، وإذا عاد بسبب KVM_EXIT_HLT فالضيف انتهى. ولاحظ أن البرنامج لا يرى أبداً خروج CPUID لأن KVM يعالجه داخل النواة.
  • العدادات: يحتفظ KVM لكل جهاز افتراضي بعدادات في نظام الملفات debugfs، مثل عدد مرات الخروج exits والخروج بسبب المنافذ io_exits وعدد أخطاء الصفحات التي أصلحها pf_fixed، فنقرؤها قبل التشغيل وبعده ونطبع الفرق.

وبقية الملفات هي Makefile لبناء الضيف والمشرف، والبرنامج cpuid-cost.c الذي يقيس زمن CPUID داخل ال Container نفسه دون ضيف، والسكربت run.sh الذي يشغل كل الاختبارات بالترتيب:

#!/bin/sh
# run.sh: everything the article shows, in order. Needs a privileged container with /dev/kvm.
set -e
make -s
echo "load average: $(cat /proc/loadavg)"
mount -t debugfs none /sys/kernel/debug 2>/dev/null || true
echo "== 1. alu";   ./vmm 1 10000000
echo "== 2. cpuid"; ./vmm 2 1000000
echo "== 3. io";    ./vmm 3 1000000
echo "== 4. mem";   ./vmm 4 0
echo "== cpuid in this container (no nested guest)"; ./cpuid-cost 1000000
echo "== exit reasons"
sh exit-reasons.sh 2 20000
sh exit-reasons.sh 3 20000
sh exit-reasons.sh 4 0
docker run --rm --privileged -v "$PWD:/lab" cs3-vt:1 sh run.sh

النتائج سطراً سطراً Results

والمخرج سوف يكون كما يلي، وهذا الجزء الأول منه:

load average: 3.87 4.93 5.51 3/587 13
== 1. alu
KVM API version: 12
KVM counters for this VM: /sys/kernel/debug/kvm/1041897-4
guest code: 63 bytes at 0x1000
test=alu pass=1 count=10000000 time=0.010 s per_iteration=1.0 ns
  returned to user space: 1 (KVM_EXIT_IO 0)
  KVM counters: exits=3 io_exits=0 halt_exits=1 pf_fixed=1
== 2. cpuid
KVM API version: 12
KVM counters for this VM: /sys/kernel/debug/kvm/1041899-4
guest code: 63 bytes at 0x1000
test=cpuid pass=1 count=1000000 time=9.192 s per_iteration=9191.6 ns
  returned to user space: 1 (KVM_EXIT_IO 0)
  KVM counters: exits=1000454 io_exits=0 halt_exits=1 pf_fixed=1
== 3. io
KVM API version: 12
KVM counters for this VM: /sys/kernel/debug/kvm/1042040-4
guest code: 63 bytes at 0x1000
test=io pass=1 count=1000000 time=11.617 s per_iteration=11617.0 ns
  returned to user space: 1000001 (KVM_EXIT_IO 1000000)
  KVM counters: exits=1000444 io_exits=1000000 halt_exits=1 pf_fixed=1
== 4. mem
KVM API version: 12
KVM counters for this VM: /sys/kernel/debug/kvm/1042143-4
guest code: 63 bytes at 0x1000
test=mem pass=1 count=254 time=0.003 s
  returned to user space: 1 (KVM_EXIT_IO 0)
  KVM counters: exits=256 io_exits=0 halt_exits=1 pf_fixed=255
test=mem pass=2 count=254 time=0.000 s
  returned to user space: 1 (KVM_EXIT_IO 0)
  KVM counters: exits=1 io_exits=0 halt_exits=1 pf_fixed=0
== cpuid in this container (no nested guest)
cpuid: 731.8 ns each, add: 0.43 ns each (n=1000000, sink=23000000)

وفي المخرج أعلاه لاحظ التالي:

  • KVM API version: 12: رقم ثابت منذ سنوات، والتوثيق يطلب من أي برنامج أن يتأكد منه قبل أن يكمل.
  • اختبار alu: عشرة ملايين دورة في 0.010 ثانية، أي نحو 1 نانوثانية للدورة، ومعها ثلاث مرات خروج فقط في كل التشغيل، منها خروج HLT في النهاية. فالضيف عندما لا يطلب شيئاً حساساً يعمل بسرعة المعالج الحقيقي تقريباً، وهذا بالضبط ما وعدت به VT-x.
  • اختبار cpuid: مليون دورة أخذت 9.2 ثانية، أي 9.2 ميكروثانية للدورة الواحدة، وعداد KVM يقول 1000454 خروجاً، أي مليون خروج لـ CPUID ونحو 450 خروجاً آخر سببها مقاطعات خارجية من المؤقت ومن الأجهزة. ولاحظ أن برنامجنا لم يستقبل منها إلا عودة واحدة في النهاية، فكلها عولجت داخل النواة.
  • اختبار io: هنا عاد KVM_RUN إلى برنامجنا 1000001 مرة، مليون مرة بسبب المنفذ ومرة للنهاية، والعداد io_exits يساوي مليوناً تماماً، والزمن 11.6 ميكروثانية للدورة، أي أغلى من CPUID لأن كل خروج يضيف انتقالاً من النواة إلى فضاء المستخدم ثم العودة.
  • اختبار mem: في المرة الأولى 256 خروجاً منها 255 خطأ صفحة أصلحه KVM، 254 صفحة كتبنا فيها وصفحة الكود نفسها، وفي المرة الثانية لم يحدث أي خطأ صفحة وخروج واحد فقط هو HLT. وسوف نشرح السبب في جزء EPT.
  • السطر الأخير: CPUID داخل ال Container نفسه، دون ضيفنا، أخذ 732 نانوثانية، مقابل أقل من نصف نانوثانية لتعليمة جمع. وهذا رقم مهم سوف نعود إليه، فالتعليمة هنا أيضاً تخرج، لأن ال Container نفسه داخل VM.

والجزء الثاني من المخرج يجيب عن سؤال مهم: كيف نعرف أن الخروج سببه CPUID فعلاً وليس شيئاً آخر؟ نواة Linux فيها نقطة تتبع Tracepoint اسمها kvm:kvm_exit تكتب سطراً عند كل خروج مع سببه، والسكربت exit-reasons.sh يشغلها حول تشغيل قصير من 20000 دورة ثم يعد الأسباب:

#!/bin/sh
# exit-reasons.sh <test> <count>: run vmm with the kvm:kvm_exit tracepoint on, then count the exit reasons
T=/sys/kernel/debug/tracing
echo 0 > $T/tracing_on; echo > $T/trace; echo 8192 > $T/buffer_size_kb
echo 1 > $T/events/kvm/kvm_exit/enable
echo 1 > $T/tracing_on
./vmm "$1" "$2" > /dev/null
echo 0 > $T/tracing_on
echo 0 > $T/events/kvm/kvm_exit/enable
echo "sample line:"; grep ' vmm-' $T/trace | grep -m1 kvm_exit | sed 's/^ *//'
echo "exit reasons for test $1 ($2):"
grep ' vmm-' $T/trace | grep -o 'reason [A-Z_]*' | sort | uniq -c | sort -rn
echo > $T/trace
== exit reasons
sample line:
vmm-1042166 [000] d.... 165573.709362: kvm_exit: vcpu 0 reason EPT_VIOLATION rip 0x1000 info1 0x0000000000000784 info2 0x0000000000000000 intr_info 0x00000000 error_code 0x00000000
exit reasons for test 2 (20000):
  20000 reason CPUID
      5 reason EXTERNAL_INTERRUPT
      1 reason HLT
      1 reason EPT_VIOLATION
sample line:
vmm-1042177 [000] d.... 165574.402327: kvm_exit: vcpu 0 reason EPT_VIOLATION rip 0x1000 info1 0x0000000000000784 info2 0x0000000000000000 intr_info 0x00000000 error_code 0x00000000
exit reasons for test 3 (20000):
  20000 reason IO_INSTRUCTION
      9 reason EXTERNAL_INTERRUPT
      1 reason HLT
      1 reason EPT_VIOLATION
sample line:
vmm-1042188 [005] d.... 165575.309604: kvm_exit: vcpu 0 reason EPT_VIOLATION rip 0x1000 info1 0x0000000000000784 info2 0x0000000000000000 intr_info 0x00000000 error_code 0x00000000
exit reasons for test 4 (0):
    255 reason EPT_VIOLATION
      2 reason HLT

وفي المخرج أعلاه لاحظ التالي:

  • سطر العينة فيه اسم البرنامج vmm ورقم المعالج الافتراضي وسبب الخروج EPT_VIOLATION وعنوان التعليمة rip 0x1000، أي أن أول ما فعله الضيف عند أول تعليمة هو خطأ في ترجمة صفحة الكود نفسها، لأن KVM لم يربطها بعد بذاكرة حقيقية.
  • في الاختبار الثاني 20000 خروج بسبب CPUID بالضبط، وفي الثالث 20000 بسبب IO_INSTRUCTION، وهذه الأسماء هي أسماء أسباب الخروج في كتيبات Intel.
  • EXTERNAL_INTERRUPT خروج لم يطلبه الضيف: جاءت مقاطعة للمعالج الحقيقي من المؤقت أو من جهاز، والمقاطعات ملك للمضيف، فيخرج الضيف حتى يعالجها المضيف.
  • في الاختبار الرابع 255 خروجاً بسبب EPT_VIOLATION، وهو نفس الرقم الذي قرأناه من العداد pf_fixed، أي أن الطريقتين متفقتان.

مشكلة حقيقية: العدادات كلها صفر

في أول تشغيل للبرنامج كانت كل العدادات صفراً مع أن الأزمنة تقول بوضوح إن مليون خروج قد حدث. والسبب أن KVM ينشئ لكل جهاز افتراضي مجلداً في /sys/kernel/debug/kvm اسمه رقم العملية Process ID ثم رقم الملف، مثل 1041897-4، وكانت النسخة الأولى من البرنامج تبني اسم المجلد من getpid(). ولكن داخل ال Container يرى البرنامج رقم عملية مختلفاً عن الرقم الذي تراه النواة، لأن ال Container له فضاء أسماء خاص بالعمليات PID Namespace، وحتى مع الخيار --pid=host بقي الرقم مختلفاً، لأن Docker Desktop نفسه يشغل المحرك داخل فضاء أسماء خاص به داخل ال VM. والدالة التي تقرأ ملفاً غير موجود كانت تعيد -1 قبل التشغيل وبعده، فيكون الفرق صفراً دون أي رسالة خطأ.

والحل الذي تراه في الكود هو الدالة scan: تقرأ أسماء المجلدات قبل إنشاء الجهاز الافتراضي، ثم بعده، والمجلد الجديد هو مجلدنا. والدرس العام هنا أن الأرقام التي تأتي من داخل Container عن العمليات لا تطابق بالضرورة الأرقام التي تراها النواة، وأن أداة القياس التي تفشل بصمت أخطر من أداة تتوقف برسالة خطأ، فاطبع دائماً المسار الذي تقرأ منه كما يفعل البرنامج الآن في سطر KVM counters for this VM.

ماذا يحدث إذا لم يصل /dev/kvm؟ What If

نشغل نفس البرنامج دون --privileged ودون أي خيار آخر:

docker run --rm -v "$PWD:/lab" cs3-vt:1 ./vmm 2 1000
open /dev/kvm: No such file or directory

الملف غير موجود داخل ال Container أصلاً، لأن Docker لا يمرر أجهزة المضيف إلا إذا طلبت ذلك. وهذا نفس الخطأ الذي سوف تراه في QEMU أو أي أداة أخرى بصيغة مختلفة، وهو أول ما تتأكد منه إذا كان جهازك الافتراضي بطيئاً بشكل غريب، فبعض الأدوات تتراجع بصمت إلى المحاكاة البرمجية الكاملة كما رأينا في مقال المحاكاة الافتراضية. والآن نمرر الجهاز وحده دون صلاحيات كاملة:

docker run --rm --device /dev/kvm -v "$PWD:/lab" cs3-vt:1 ./vmm 2 100000
KVM API version: 12
KVM counters for this VM: 
guest code: 63 bytes at 0x1000
test=cpuid pass=1 count=100000 time=1.202 s per_iteration=12016.4 ns
  returned to user space: 1 (KVM_EXIT_IO 0)
  KVM counters: exits=0 io_exits=0 halt_exits=0 pf_fixed=0

والنتيجة مهمة: الجهاز الافتراضي عمل بشكل كامل، فتشغيل KVM لا يحتاج إلا الوصول إلى /dev/kvm، أما العدادات فكلها صفر ومسارها فارغ، لأن ربط debugfs يحتاج صلاحيات كاملة. ولذلك لا تقم بتشغيل Containers الأجهزة الافتراضية بالخيار --privileged في الإنتاج، والسبب أن هذا الخيار يعطي ال Container تقريباً كل صلاحيات المضيف، ويكفي --device /dev/kvm، واترك --privileged لتجربة قياس مثل هذه على جهاز تجارب.

كم يكلف الخروج VM Exit؟

الصورة التالية تضع الأرقام الأربعة على مقياس لوغاريتمي، لأن الفرق بين أصغرها وأكبرها أكثر من عشرة آلاف ضعف:

رسم أعمدة أفقية بمقياس لوغاريتمي من 0.1 نانوثانية إلى 100 ميكروثانية: الحساب العادي داخل الضيف 1.0 نانوثانية باللون الأخضر، وCPUID داخل ال Container تحت Hyper-V نحو 732 نانوثانية بالأزرق، وCPUID داخل ضيفنا 9.2 ميكروثانية بالبرتقالي، والكتابة إلى منفذ داخل ضيفنا 11.6 ميكروثانية بالأحمر
زمن التكرار الواحد في كل اختبار، من تشغيل واحد على جهاز المختبر

وقبل أن نفسر الأرقام يجب أن نكون صادقين بشأن دقتها: جهاز المختبر مشترك، وكانت عليه أعمال أخرى في نفس الوقت، ومتوسط الضغط Load Average في بداية التشغيل كان قريباً من 4 على 8 خيوط. وفي تشغيلات أخرى على نفس الجهاز تراوح زمن CPUID داخل ضيفنا بين 4.2 و9.9 ميكروثانية، وزمن المنفذ بين 8.7 و22.7 ميكروثانية، وزمن CPUID داخل ال Container بين 540 و1228 نانوثانية. فالترتيب ثابت في كل التشغيلات، والأرقام نفسها تتغير بضعفين أو أكثر حسب ما يحدث على الجهاز، وهذا بحد ذاته درس: لا تقس أداء الأجهزة الافتراضية مرة واحدة على جهاز مشغول ثم تبني عليها قراراً.

والآن ماذا تقول الأرقام؟ أولاً، الضيف يعمل بسرعة المعالج الحقيقي ما دام لا يخرج، فدورة الحساب أخذت نحو نانوثانية. ثانياً، الخروج نفسه هو الكلفة، فكل CPUID في ضيفنا كلف آلاف النانوثانيات، أي عشرات الآلاف من دورات الساعة، وهذا يعني أن مشرفاً يخرج مئة ألف مرة في الثانية يضيع جزءاً ملحوظاً من وقت المعالج في الدخول والخروج وحدهما. ثالثاً، الخروج الذي يصل إلى فضاء المستخدم أغلى من الذي يعالج في النواة، ولذلك نقلت أنظمة الإنتاج الأجهزة الأكثر استعمالاً من QEMU إلى داخل النواة، مثل وحدات vhost-net للشبكة.

ولكن هل 9 ميكروثانية رقم طبيعي لخروج واحد؟ لا، وهو أكبر بكثير مما تراه على سيرفر حقيقي يعمل عليه KVM مباشرة، والسبب في الرقم الأزرق: حتى CPUID داخل ال Container، دون أي ضيف، أخذ 732 نانوثانية، لأن ال Container نفسه داخل VM تحت Hyper-V، فكل CPUID فيه خروج إلى Hyper-V. وضيفنا ليس ضيفاً واحداً، وإنما ضيف داخل ضيف، وهذا موضوع الجزء التالي.

المحاكاة المتداخلة Nested Virtualization: ضيف داخل ضيف

الصورة التالية تبين ما يحدث فعلاً على جهاز المختبر:

رسم طبقات: في الأسفل المعالج الحقيقي Intel Core i7-7700K مع VT-x وEPT وMBEC، فوقه Hyper-V في الطبقة L0 وهو المشرف الحقيقي الوحيد في VMX root، فوقه قسمان: Windows 11 نفسه كقسم جذر، وVM خدمات WSL2 في الطبقة L1 فيها Container cs3-vt وKVM في نواة Linux 5.15، وفي الأعلى ضيفنا الصغير في الطبقة L2، مع سهم أحمر يبين أن الخروج من L2 يصل أولاً إلى L0 ثم إلى KVM في L1
جهاز المختبر من الداخل: Hyper-V هو المشرف الحقيقي، وKVM نفسه يعمل داخل ضيف

عندما تفعل WSL2 أو Docker Desktop أو Windows Sandbox أو ميزة سلامة الذاكرة على Windows يعمل Hyper-V تحت كل شيء، ويصبح Windows الذي تراه أمامك ضيفاً مميزاً يملك الوصول إلى الأجهزة، وتعمل نواة Linux الخاصة بـ WSL2 في VM خفيفة كما تشرح صفحة المقارنة بين WSL1 وWSL2. والمعالج الحقيقي لا يملك إلا عالماً واحداً للمشرف، يجلس فيه Hyper-V وحده، ولذلك عندما يعمل KVM داخل ال VM ويظن أنه ينفذ VMLAUNCH فهو في الحقيقة ينفذ تعليمة تسبب خروجاً إلى Hyper-V، فيقوم Hyper-V بتشغيل ضيفنا نيابة عنه، ببناء VMCS حقيقية من ال VMCS التي جهزها KVM، كما تشرح صفحة Microsoft عن المحاكاة المتداخلة وتوثيق KVM لنفس الفكرة.

وبالتالي كل خروج من ضيفنا في L2 يمر بهذا الطريق: يخرج المعالج إلى Hyper-V في L0، فيعرف Hyper-V أن الخروج يخص ضيفاً يديره KVM، فيدخل KVM في L1 ويقدم له الخروج كأنه جاء من عتاد حقيقي، فيعالجه KVM، ثم يحاول الدخول إلى الضيف بتعليمة تخرج بدورها إلى Hyper-V، فيدخل Hyper-V الضيف من جديد. فالخروج الواحد في L2 أصبح عدة دخول وخروج حقيقية، وهذا ما رأيناه في الأرقام. ولاحظ السطر enable_shadow_vmcs=N في مخرج المختبر: ميزة Shadow VMCS تسمح لمشرف في L1 بقراءة وكتابة ال VMCS دون خروج في كل مرة، وهي غير متاحة هنا، فكل قراءة يقوم بها KVM لحقل في ال VMCS هي خروج آخر إلى Hyper-V.

هل يعني هذا أن المحاكاة المتداخلة غير مفيدة؟ لا، فهي مناسبة جداً لما صممت له: تجربة Proxmox أو KVM داخل VM، ومختبرات التعليم، وبيئات CI التي تبني Images لأجهزة افتراضية، وأدوات مثل Docker Desktop التي تحتاج KVM أحياناً داخل VM. ولكنها غير مناسبة إطلاقاً لتشغيل أجهزة إنتاج كثيرة الخروج، مثل سيرفر قاعدة بيانات بقرص محاكى، داخل VM على سحابة، وإذا احتجت ذلك فاطلب من مزود السحابة سيرفراً فعلياً Bare Metal.

لماذا يهم Windows نفسه أن يكون فوق مشرف؟ VBS وMBEC

قد يتساءل البعض: لماذا يشغل Windows نفسه فوق Hyper-V حتى لو لم تطلب جهازاً افتراضياً؟ والإجابة هي الأمان المبني على المحاكاة VBS: يستعمل Windows المشرف ليصنع منطقة ذاكرة معزولة لا تستطيع النواة نفسها الوصول إليها، ويضع فيها فحص توقيع الكود الذي يعمل في النواة، فإذا اخترق أحد نواة Windows لا يستطيع أن يجعل صفحة ذاكرة قابلة للتنفيذ دون موافقة هذه المنطقة، لأن صلاحيات التنفيذ تحددها جداول EPT التي يملكها Hyper-V وليس جداول النواة. وصفحة Microsoft التي ذكرناها تقول إن هذه الميزة تعمل أفضل على معالجات Intel من جيل Kaby Lake وما بعده لوجود ميزة MBEC، وهي اختصار Mode-Based Execution Control، التي تسمح بأن تختلف صلاحية التنفيذ في EPT بين كود النواة وكود المستخدم. ومعالج المختبر من جيل Kaby Lake، ولذلك ظهرت القيمة 7 في مخرج Windows، وظهر العلم ept_mode_based_exec في مخرج Linux، وهما نفس الميزة يراها نظامان مختلفان.

الذاكرة: EPT وNPT من الداخل

في مقال الذاكرة الافتراضية وجداول الصفحات شرحنا كيف يترجم المعالج كل عنوان يستعمله البرنامج إلى عنوان فعلي في RAM عن طريق جداول الصفحات Page Tables التي تديرها النواة. والمشكلة في الأجهزة الافتراضية أن نواة الضيف تدير جداولها أيضاً وتظن أن العناوين الفعلية التي تكتبها فيها عناوين حقيقية، وهي ليست كذلك، فالذاكرة التي يظنها الضيف ذاكرته الفعلية هي في الحقيقة ذاكرة عادية حجزها برنامج المراقبة بالدالة mmap كما رأينا في الكود. والصورة التالية تبين الحل:

رسم لترجمة العنوان على مرحلتين: صندوق Guest Virtual لعنوان يراه برنامج الضيف، يتجه بسهم برتقالي عبر جداول صفحات الضيف إلى Guest Physical، ثم بسهم أخضر عبر جداول EPT التي يديرها KVM إلى Host Physical. تحتهما صندوق يشرح جداول الظل قبل EPT، وفي الأسفل شبكتان من 254 مربعاً: الأولى حمراء للمرة الأولى مع 255 خروجاً بسبب EPT_VIOLATION في 3 ms، والثانية خضراء للمرة الثانية دون أي خروج
عنوان الضيف يترجم مرتين، وKVM يملأ جداول EPT عند أول لمس لكل صفحة

قبل EPT كان على المشرف أن يبني جداول ظل Shadow Page Tables تترجم عنوان الضيف الافتراضي إلى العنوان الحقيقي مباشرة، ويعطيها للمعالج بدلاً من جداول الضيف، ولكي تبقى صحيحة يجب أن يعترض كل تعديل يقوم به الضيف على جداوله، وكل تبديل لـ CR3 عند تبديل العمليات، وهذا مصدر خروج لا يتوقف في أي نظام فيه عمليات كثيرة، وتوثيق وحدة MMU في KVM ما زال يشرح هذا الأسلوب لأنه يستعمل عندما لا يتوفر EPT. ومع EPT عند Intel، وNPT عند AMD، يمشي المعالج نفسه على جدولين: جداول الضيف يديرها الضيف كما يريد دون أي خروج، وجداول EPT يديرها KVM، ويشير إليها حقل في ال VMCS، ولا يراها الضيف أبداً.

وهذا ما رأيناه في الاختبار الرابع: عندما بدأ الضيف كانت جداول EPT فارغة، فعند أول كتابة في كل صفحة لم يجد المعالج ترجمة لها في EPT، فخرج بسبب EPT_VIOLATION ومعه العنوان المطلوب، فوجد KVM أن هذا العنوان يقع في منطقة الذاكرة التي سجلناها، فأضاف الترجمة وأعاد الضيف، ولذلك العداد اسمه pf_fixed. وفي المرة الثانية كانت الترجمات موجودة، فمر الضيف على 254 صفحة دون أي خروج. وهذه الطريقة الكسولة هي التي تجعل جهازاً افتراضياً بذاكرة 64 GB يبدأ خلال ثوان قليلة: لا يحجز KVM ذاكرة حقيقية لصفحة لم يلمسها الضيف بعد.

وللمرحلتين ثمن: عندما لا يجد المعالج الترجمة في ال TLB يجب أن يمشي على جداول الضيف، وكل عنوان في جداول الضيف هو عنوان ضيف فعلي يحتاج بدوره ترجمة عبر EPT، فمع أربعة مستويات في كل جدول يصل عدد قراءات الذاكرة في أسوأ حالة إلى 24 قراءة بدلاً من 4. ولذلك تهم أشياء صغيرة في الإعدادات: الصفحات الكبيرة Huge Pages التي تقلل عدد المستويات، والعلم ept_1gb الذي رأيناه، والعلم vpid الذي يوسم سجلات ال TLB برقم الضيف حتى لا يمسحها المعالج عند كل دخول وخروج.

الأجهزة: virtio وIOMMU مثل VT-d

الاختبار الثالث في المختبر يشبه ما يحدث مع جهاز محاكى بالكامل: كل كتابة إلى مسجل في الجهاز خروج يصل إلى فضاء المستخدم. وبطاقة شبكة حقيقية مثل Intel e1000 يحتاج تعريفها إلى عدة قراءات وكتابات لكل حزمة، فإذا حاكاها QEMU مسجلاً بمسجل فكل حزمة تكلف عدة خروج، ومع عشرات الآلاف من الحزم في الثانية يصبح الخروج هو كل العمل. والصورة التالية تبين الطرق الثلاث المستعملة اليوم:

ثلاثة أعمدة: على اليمين جهاز محاكى بالكامل فيه تعريف الضيف يكتب في مسجل وأربعة أسهم حمراء إلى KVM ثم QEMU يقلد الجهاز ثم الجهاز الحقيقي، مع ملاحظة خروج لكل قراءة أو كتابة. في الوسط virtio فيه تعريف virtio وحلقة مشتركة Virtqueue فيها خمس خانات ممتلئة وسهم أحمر واحد إلى vhost أو QEMU، مع ملاحظة إشعار واحد Kick لعدة طلبات. على اليسار التمرير المباشر فيه التعريف الأصلي للجهاز وسهم أخضر مباشر إلى الجهاز الحقيقي يمر عبر IOMMU يترجم عناوين DMA
كلما قل الخروج لكل طلب زاد الأداء، وزادت الحاجة إلى دعم من العتاد

والحل الأول هو virtio، وقد شرحناه باختصار في مقال المحاكاة الافتراضية: جهاز لا يقلد أي بطاقة حقيقية، وإنما صمم ليعرف أنه داخل VM، فيضع الضيف طلباته في حلقة مشتركة في الذاكرة اسمها Virtqueue، ثم يرسل إشعاراً واحداً يسمى Kick لعدة طلبات معاً، والمواصفة منشورة كاملة في موقع OASIS. فالفكرة هي نفسها فكرة Xen في 2003، ولكنها طبقت على الأجهزة فقط.

والحل الثاني هو التمرير المباشر Passthrough: تعطي الضيف بطاقة حقيقية، بطاقة شبكة أو GPU، فيكلمها بتعريفها الأصلي دون أي مشرف في الطريق. ولكن هنا مشكلة أمنية كبيرة: الأجهزة تكتب في الذاكرة مباشرة عن طريق DMA، والضيف هو الذي يعطي البطاقة العناوين، وهو يعطيها عناوين يظنها فعلية، فإذا لم يترجمها أحد فسوف تكتب البطاقة في ذاكرة المضيف أو ضيف آخر. وهذا عمل وحدة IOMMU، واسمها عند Intel تقنية VT-d وعند AMD تقنية AMD-Vi، فهي تفعل للأجهزة ما تفعله EPT للمعالج: تترجم كل عنوان DMA وتمنع الجهاز من الوصول إلى أي ذاكرة خارج ضيفه، وعلى Linux تستعمل هذه الميزة عن طريق VFIO. ولذلك إذا أردت تمرير GPU إلى VM على Proxmox فأول شرط أن يكون VT-d مفعلاً في BIOS وأن تراه النواة.

وتذكر أن IOMMU يحمي المضيف أيضاً دون أي أجهزة افتراضية، فـ Windows يستعمله لحماية DMA من أجهزة Thunderbolt التي توصل من الخارج كما تشرح صفحة Microsoft عن حماية DMA. وفي جهاز المختبر لم تظهر القيمة 3 في AvailableSecurityProperties، أي أن هذه الحماية غير متاحة، فإذا كانت عندك أجهزة تعمل بـ Thunderbolt أو تريد تمرير أجهزة فهذا أول ما تفحصه.

عندما تفشل هذه الطبقة: حوادث حقيقية

كل ما سبق يقوم على وعد واحد: الضيف لا يرى إلا ما يعطيه المشرف. وعندما يفشل هذا الوعد تكون النتيجة خطيرة، لأن السيرفر الواحد في السحابة يحمل ضيوفاً لعملاء مختلفين.

💡
في مايو 2015 نشرت ثغرة اسمها VENOM برقم CVE-2015-3456 في محاكي متحكم الأقراص المرنة Floppy Disk Controller داخل QEMU، وهو جهاز قديم كان يضاف افتراضياً إلى كثير من الأجهزة الافتراضية حتى لو لم يستعمله أحد. والخطأ كان تجاوزاً لحدود ذاكرة مؤقتة يستطيع الضيف أن يستغله ليشغل كوداً داخل عملية QEMU على المضيف، أي أن يخرج من الضيف. والدرس هنا أن كل جهاز محاكى هو كود في فضاء المستخدم يتلقى مدخلات من الضيف، ولذلك أزل من أجهزتك الافتراضية كل جهاز لا تحتاجه، واستعمل virtio بدلاً من الأجهزة القديمة.
💡
في أغسطس 2018 أعلنت ثغرة L1 Terminal Fault في معالجات Intel، ومنها نسخة برقم CVE-2018-3646 تخص الأجهزة الافتراضية: كان ضيف يستطيع أن يقرأ عن طريق التنفيذ التخميني بيانات موجودة في ذاكرة L1 للنواة، حتى لو كانت تخص المضيف أو ضيفاً آخر يعمل على نفس النواة. وتوثيق النواة يشرح أن أحد الحلول هو مسح L1 قبل كل دخول إلى ضيف، وعدم تشغيل ضيفين مختلفين على خيطين في نفس النواة. ولاحظ أن عداد l1d_flush الذي رأيناه في مجلد KVM في المختبر هو عداد هذا الحل نفسه، فهو ما زال يعمل على كل جهاز تأثر بالثغرة.

ولهذا السبب بنت السحابات الكبيرة مشرفات أصغر ونقلت الأجهزة خارج المعالج، مثل نظام AWS Nitro الذي يضع الشبكة والتخزين في بطاقات خاصة ويترك على السيرفر مشرفاً خفيفاً، فكلما قل الكود الذي يتلقى مدخلات من الضيف قلت فرص الخروج منه.

أخطاء شائعة Common Mistakes

  1. الحكم على دعم VT-x من شاشة Windows: إذا كان Hyper-V يعمل فإن VirtualizationFirmwareEnabled سوف يظهر False حتى لو كان الدعم يعمل، فاقرأ HypervisorPresent ومدير المهام، أو اقرأ العلم vmx أو svm من Linux.
  2. تشغيل VM دون KVM دون أن تعرف: بعض الأدوات تتراجع إلى المحاكاة البرمجية الكاملة عندما لا تجد /dev/kvm، والنتيجة جهاز يعمل ولكن أبطأ بعشرات الأضعاف، فتأكد من الملف ومن صلاحياته قبل أن تبحث عن السبب في مكان آخر.
  3. استعمال --privileged لتشغيل QEMU داخل Container: يكفي --device /dev/kvm كما رأينا، والصلاحيات الكاملة تفتح لل Container كل أجهزة المضيف.
  4. اختيار أجهزة محاكاة قديمة مثل IDE وe1000 لسيرفر Linux: كل وصول لمسجل فيها خروج، والأفضل دائماً virtio للقرص والشبكة ما دام الضيف يدعمه، وكل توزيعات Linux الحديثة تدعمه.
  5. بناء بيئة إنتاج على المحاكاة المتداخلة: رأينا أن الخروج في L2 أغلى بكثير، فهي مناسبة للتجربة والتعليم وCI، وليست لسيرفرات قواعد البيانات.
  6. قياس الأداء مرة واحدة على جهاز مشترك: أرقامنا نفسها تغيرت بضعفين بين تشغيل وآخر، فكرر القياس واكتب متوسط الضغط معه.
  7. تمرير GPU أو بطاقة شبكة دون IOMMU: غالباً لن يعمل، وإذا عمل بطريقة ما فقد فتحت للضيف الطريق إلى ذاكرة المضيف كلها.
  8. ترك أجهزة لا يحتاجها الضيف: القرص المرن ومنافذ تسلسلية وبطاقات صوت في سيرفر لا صوت فيه، وكل واحد منها كود إضافي يمكن أن تكون فيه ثغرة كما حدث في VENOM.

قبل أن تعتمد على الأجهزة الافتراضية: قائمة تحقق Checklist

ما تفحصهكيفلماذا
دعم VT-x أو AMD-Vgrep -E -c 'vmx|svm' /proc/cpuinfoدونه لا يوجد KVM، ويصبح كل شيء محاكاة برمجية
EPT أو NPTسطر vmx flags أو lscpuدونه يعود المشرف إلى جداول الظل وخروج كثير
وصول KVMls -l /dev/kvm ثم virt-host-validateأول سبب لبطء غير مفهوم
هل أنت داخل VM أصلاً؟العلم hypervisor وورقة cpuid 0x40000000المحاكاة المتداخلة أبطأ، فاعرف أين تعمل
IOMMU قبل التمريرls /sys/class/iommu أو رسائل DMAR في سجل النواةشرط للتمرير الآمن لأي جهاز
نوع الأجهزة في الضيفإعدادات الجهاز الافتراضيvirtio للقرص والشبكة، وإزالة ما لا يلزم
تحديثات الثغراتgrep . /sys/devices/system/cpu/vulnerabilities/*ثغرات مثل L1TF تعالج في النواة وفي البرنامج الثابت للمعالج

وإذا كنت ستبني هذه الطبقة على سيرفر Linux فقد شرحنا التثبيت والإدارة خطوة خطوة في دليل KVM مع libvirt، وفي دليل أول VM في Proxmox إذا أردت واجهة جاهزة.

تدريب عملي

  • شغل cpu-flags.sh على سيرفرك أو على جهازك، وقارن سطر vmx flags بما رأيته هنا، وابحث هل يظهر العلم hypervisor، فإذا ظهر فاقرأ ورقة cpuid 0x40000000 لتعرف من هو المشرف الذي يعمل تحتك، وقد تجد «KVMKVMKVM» على سحابة أو «VMwareVMware» في شركتك.
  • في vmm.c اجعل الذاكرة تحجز بالعلم MAP_POPULATE، وأعد الاختبار الرابع، وتوقع قبل التشغيل: هل سوف يختفي خروج EPT_VIOLATION في المرة الأولى أم يبقى؟ ولماذا؟
  • أضف إلى guest.S اختباراً خامساً يقرأ من المنفذ بالتعليمة in بدلاً من الكتابة، واجعل vmm.c يعيد للضيف قيمة ثابتة في run->io، ثم قس الزمن.

الخلاصة

وصلنا لنهاية الموضوع، وأهم ما فيه:

  • معمارية x86 لم تكن قابلة للمحاكاة الافتراضية بطريقة الاعتراض البسيطة، لأن فيها تعليمات حساسة لا تسبب خطأ، فتحايلت VMware بترجمة الكود، وXen بتعديل الضيف.
  • VT-x وAMD-V أضافتا عالماً ثانياً كاملاً داخل المعالج، فتعمل نواة الضيف في Ring 0 دون تعديل، ويخرج المعالج إلى المشرف عند ما يحدده المشرف في ال VMCS أو ال VMCB.
  • الضيف يعمل بسرعة المعالج الحقيقي ما دام لا يخرج، والخروج هو الكلفة: قسنا نحو نانوثانية لدورة حساب مقابل آلاف النانوثانيات لكل خروج، والخروج إلى فضاء المستخدم أغلى من الخروج الذي يعالج في النواة.
  • EPT وNPT تتركان جداول الضيف للضيف، ويملأ KVM جداوله عند أول لمس لكل صفحة، فرأينا 255 خروجاً في المرة الأولى ولا شيء في الثانية.
  • virtio يقلل الخروج للأجهزة بجمع الطلبات، والتمرير المباشر يلغيه، ولكنه يحتاج IOMMU مثل VT-d حتى لا يصل الجهاز إلى ذاكرة غير ذاكرة ضيفه.
  • على Windows مع WSL2 أو Docker Desktop يعمل Hyper-V تحت كل شيء، ويصبح Windows ضيفاً مميزاً، وأي KVM داخل WSL2 هو محاكاة متداخلة أغلى بكثير في الخروج.

وفي مقالات المعالجات القادمة بإذن الله نخرج من المعالج إلى وحدات أخرى في نفس الجهاز، فنرى لماذا لا يكفي CPU للذكاء الاصطناعي، ثم كيف تصنع الشريحة نفسها:

دليلGPU وNPU وTPU: لماذا لا يكفي CPU للذكاء الاصطناعي؟نضرب نفس المصفوفات على المعالج وعلى المعالج الرسومي المدمج ونقيس الحساب وسرعة الذاكرة، لنفهم ما الذي يجعل GPU وNPU وTPU أسرع ومتى لا تفيد.دليلكيف تصنع الرقاقة؟ من الرمل إلى المعالج والنانومترنتتبع الشريحة من الرمل إلى الغلاف مروراً بأجهزة EUV، ونحسب بسكربت صغير كم شريحة تخرج من الرقاقة وكم منها يعمل ولماذا تغلو الشرائح الكبيرة.دليلالمحاكاة Emulation والترجمة الثنائية: QEMU وRosetta 2نفتح محاكي QEMU ونرى كيف تتحول تعليمات ARM إلى تعليمات x86 ونقيس كلفة كل خطوة، ثم نقارن ذلك بما تفعله Rosetta 2 وWindows Prism.دليلCISC أم RISC: ما الفرق الحقيقي بين x86 وARM وRISC-V؟نقيس حجم الكود وعدد التعليمات المنفذة لنفس البرامج على x86-64 وARM64 وRISC-V، ونرى ما بقي من نقاش CISC وRISC وما لم يعد صحيحاً.دليلمعمارية المعالج ISA: لماذا لا يعمل برنامج x86 على ARM؟نترجم نفس برنامج C لثلاث معماريات ونقرأ تعليماته سطراً سطراً، لنفهم ما الذي يجعل الملف التنفيذي يعمل على معالج ويرفضه معالج آخر.

سجل التحديثات Changelog

  • 16 نوفمبر 2026: كتابة المقال وتنفيذ المختبر على Windows 11 مع معالج Intel Core i7-7700K وDocker Desktop (نواة WSL2 5.15، Hyper-V، KVM متداخل): قراءة الأعلام بالأداة cpuid 20250316، وبناء مشرف صغير بلغة C على واجهة KVM بـ gcc 14.2 وbinutils 2.44 في Container من debian:trixie-slim، وعد مرات الخروج من debugfs ومن نقطة التتبع kvm:kvm_exit.
نشرة عرب رووت | ArabRoot

معرفة تستحق مكاناً في بريدك.

مقالات مختارة وأدوات مفيدة وأفكار لمشروعك القادم، في رسالة واحدة كل أسبوع.

يمكنك إلغاء الاشتراك متى شئت. الخصوصية

تم استلام طلبك. افتح بريدك واضغط رابط التأكيد لإتمام الاشتراك.