Implémenter un module fournisseur pKVM

Cette page explique comment implémenter un module fournisseur de machine virtuelle basée sur un noyau (pKVM) protégé. Une fois ces étapes terminées, vous devez disposer d'une arborescence de répertoires semblable à celle-ci:

Makefile
el1.c
hyp/
    Makefile
    el2.c

  1. Ajoutez le code de l'hyperviseur EL2 (el2.c). Au minimum, ce code doit déclarer une fonction init acceptant une référence à la structure 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;
}

    L'API du module fournisseur pKVM est une structure qui encapsule les rappels hyperviseur pKVM. Ce struct suit les mêmes règles d'ABI que les interfaces GKI.

  2. Créez le hyp/Makefile pour compiler le code de l'hyperviseur:

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

  3. Ajoutez le code du noyau EL1 (el1.c). La section d'initialisation de ce code doit contenir un appel à pkvm_load_el2 module pour charger le code de l'hyperviseur EL2 de l'étape 1.

    #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. Enfin, créez le fichier racine makefile pour lier le code EL1 et le code 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

Charger un module pKVM

Comme pour les modules de fournisseurs GKI, les modules de fournisseurs pKVM peuvent être chargés à l'aide de modprobe. Toutefois, pour des raisons de sécurité, le chargement doit avoir lieu avant l'octroi de droits. Pour charger un module pKVM, vous devez vous assurer que vos modules sont inclus dans le système de fichiers racine (initramfs) et vous devez ajouter ce qui suit à votre de la ligne de commande du noyau:

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

Les modules de fournisseurs pKVM stockés dans initramfs héritent de la signature et de la protection de initramfs.

En cas d'échec du chargement de l'un des modules du fournisseur pKVM, le système est considéré comme non sécurisé et il sera impossible de démarrer une machine virtuelle protégée.

Appeler une fonction EL2 (hyperviseur) à partir d'EL2 (module kernel)

Un appel d'hyperviseur (HVC) est une instruction qui permet au noyau d'appeler l'hyperviseur. Avec l'introduction des modules de fournisseurs pKVM, un VVC peut être utilisé pour appeler une fonction à exécuter sur EL2 (dans le module de l'hyperviseur) à partir de EL1 (le module du noyau):

  1. Dans le code EL2 (el2.c), déclarez le gestionnaire EL2:

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

  cpu_reg(ctx, 1) = 0;
}

  2. Dans votre code EL1 (el1.c), enregistrez le gestionnaire EL2 dans votre fournisseur pKVM module:

    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);

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);

  3. Dans votre code EL1 (el1.c), appelez le code CVC:

    pkvm_el2_mod_call(hvc_number);