pKVM वेंडर मॉड्यूल लागू करना

इस पेज पर, सुरक्षित कर्नल पर आधारित वर्चुअल मशीन (पीकेवीएम) वेंडर मॉड्यूल को लागू करने का तरीका बताया गया है.

Android 16-6.12 और इसके बाद के वर्शन के लिए, इन चरणों को पूरा करने के बाद, आपके पास इस तरह का डायरेक्ट्री ट्री होना चाहिए:

BUILD.bazel
el1.c
hyp/
    BUILD.bazel
    el2.c

पूरे उदाहरण के लिए, डीडीके की मदद से pKVM मॉड्यूल बनाना लेख पढ़ें.

android15-6.6 और इससे पहले के वर्शन के लिए:

Makefile
el1.c
hyp/
    Makefile
    el2.c

1. EL2 हाइपरवाइज़र कोड (el2.c) जोड़ें. कम से कम, इस कोड में एक init फ़ंक्शन होना चाहिए, जो pkvm_module_ops स्ट्रक्चर का रेफ़रंस स्वीकार करता हो:

   #include <asm/kvm_pkvm_module.h>
   
   int pkvm_driver_hyp_init(const struct pkvm_module_ops *ops)
   {
     /* Init the EL2 code */
   
     return 0;
   }
   

   pKVM वेंडर मॉड्यूल एपीआई एक स्ट्रक्चर है. इसमें pKVM हाइपरवाइज़र को कॉल करने के लिए इस्तेमाल किए जाने वाले कॉलबैक शामिल होते हैं. यह स्ट्रक्ट, GKI इंटरफ़ेस के लिए बने ABI के नियमों का पालन करता है.

2. हाइपरवाइज़र कोड बनाने के लिए, hyp/Makefile बनाएं:

   hyp-obj-y := el2.o
   include $(srctree)/arch/arm64/kvm/hyp/nvhe/Makefile.module
   

3. EL1 कर्नल कोड (el1.c) जोड़ें. इस कोड के init सेक्शन में, pkvm_load_el2 module को कॉल करना ज़रूरी है, ताकि पहले चरण से EL2 हाइपरवाइज़र कोड लोड किया जा सके.

   #include <linux/init.h>
   #include <linux/module.h>
   #include <linux/kernel.h>
   #include <asm/kvm_pkvm_module.h>
   
   int __kvm_nvhe_pkvm_driver_hyp_init(const struct pkvm_module_ops *ops);
   
   static int __init pkvm_driver_init(void)
   {
       unsigned long token;
   
       return pkvm_load_el2_module(__kvm_nvhe_pkvm_driver_hyp_init, &token);
   }
   module_init(pkvm_driver_init);
   

4. आखिर में, बिल्ड के नियम बनाएं.

   Android 16-6.12 और इसके बाद के वर्शन के लिए, EL2 के लिए ddk_library() और EL1 के लिए ddk_module() बनाने के लिए, डीडीके की मदद से pKVM मॉड्यूल बनाएं लेख पढ़ें.

   android15-6.6 और इससे पहले के वर्शन के लिए, EL1 और EL2 कोड को एक साथ जोड़ने के लिए, रूट मेकफ़ाइल बनाएं:

   ifneq ($(KERNELRELEASE),)
   clean-files := hyp/hyp.lds hyp/hyp-reloc.S
   
   obj-m := pkvm_module.o
   pkvm_module-y := el1.o hyp/kvm_nvhe.o
   
   $(PWD)/hyp/kvm_nvhe.o: FORCE
            $(Q)$(MAKE) $(build)=$(obj)/hyp $(obj)/hyp/kvm_nvhe.o
   else
   all:
           make -C $(KDIR) M=$(PWD) modules
   clean:
           make -C $(KDIR) M=$(PWD) clean
   endif
   

pKVM मॉड्यूल लोड करना

GKI वेंडर मॉड्यूल की तरह ही, pKVM वेंडर मॉड्यूल को modprobe का इस्तेमाल करके लोड किया जा सकता है. हालांकि, सुरक्षा की वजहों से, डिप्रिविलेजिंग से पहले लोडिंग होनी चाहिए. pKVM मॉड्यूल लोड करने के लिए, आपको यह पक्का करना होगा कि आपके मॉड्यूल, रूट फ़ाइल सिस्टम (initramfs) में शामिल हों. साथ ही, आपको अपने कर्नल कमांड-लाइन में यह जोड़ना होगा:

kvm-arm.protected_modules=mod1,mod2,mod3,...

initramfs में सेव किए गए pKVM वेंडर मॉड्यूल, initramfs के सिग्नेचर और सुरक्षा को इनहेरिट करते हैं.

अगर pKVM वेंडर मॉड्यूल में से कोई एक मॉड्यूल लोड नहीं होता है, तो सिस्टम को असुरक्षित माना जाता है. साथ ही, सुरक्षित वर्चुअल मशीन को शुरू नहीं किया जा सकेगा.

EL1 (कर्नेल मॉड्यूल) से EL2 (हाइपरवाइज़र) फ़ंक्शन को कॉल करना

हाइपरवाइज़र कॉल (एचवीसी) एक ऐसा निर्देश होता है जिसकी मदद से कर्नल, हाइपरवाइज़र को कॉल कर सकता है. pKVM वेंडर मॉड्यूल के लॉन्च होने के बाद, एचवीसी का इस्तेमाल करके, EL1 (कर्नेल मॉड्यूल) से EL2 (हाइपरवाइज़र मॉड्यूल) पर किसी फ़ंक्शन को कॉल किया जा सकता है:

1. EL2 कोड (el2.c) में, EL2 हैंडलर का एलान करें:

Android-14

  void pkvm_driver_hyp_hvc(struct kvm_cpu_context *ctx)
  {
    /* Handle the call */

    cpu_reg(ctx, 1) = 0;
  }

Android-15

  void pkvm_driver_hyp_hvc(struct user_pt_regs *regs)
  {
    /* Handle the call */

    regs->regs[0] = SMCCC_RET_SUCCESS;
    regs->regs[1] = 0;
  }

1. अपने EL1 कोड (el1.c) में, pKVM वेंडर मॉड्यूल में EL2 हैंडलर रजिस्टर करें:

   int __kvm_nvhe_pkvm_driver_hyp_init(const struct pkvm_module_ops *ops);
   void __kvm_nvhe_pkvm_driver_hyp_hvc(struct kvm_cpu_context *ctx); // Android14
   void __kvm_nvhe_pkvm_driver_hyp_hvc(struct user_pt_regs *regs);   // Android15
   
   static int hvc_number;
   
   static int __init pkvm_driver_init(void)
   {
     long token;
     int ret;
   
     ret = pkvm_load_el2_module(__kvm_nvhe_pkvm_driver_hyp_init,token);
     if (ret)
       return ret;
   
     ret = pkvm_register_el2_mod_call(__kvm_nvhe_pkvm_driver_hyp_hvc, token)
     if (ret < 0)
       return ret;
   
     hvc_number = ret;
   
     return 0;
   }
   module_init(pkvm_driver_init);
   

2. अपने EL1 कोड (el1.c) में, एचवीसी को कॉल करें:

   pkvm_el2_mod_call(hvc_number);