arch/riscv: Keystone
Driver for the Keystone trusted execution environment.
Signed-off-by: Jarkko Sakkinen <jarkko.sakkinen@tuni.fi>
diff --git a/arch/riscv/Kconfig b/arch/riscv/Kconfig
index d607ab0..ae5d0a8 100644
--- a/arch/riscv/Kconfig
+++ b/arch/riscv/Kconfig
@@ -353,6 +353,17 @@
bool
select HAVE_MOD_ARCH_SPECIFIC
+config RISCV_KEYSTONE
+ bool "Keystone"
+ default n
+ depends on CMA
+ help
+ Keystone is a trusted execution environment hosted by Keystone security
+ monitor, which runs inside SBI. Keystone driver provides ioctl interface
+ for creating and running Keystone enclaves.
+
+ If you don't know what to do here, say N.
+
config SMP
bool "Symmetric Multi-Processing"
help
diff --git a/arch/riscv/include/uapi/asm/keystone.h b/arch/riscv/include/uapi/asm/keystone.h
new file mode 100644
index 0000000..f0f42f1
--- /dev/null
+++ b/arch/riscv/include/uapi/asm/keystone.h
@@ -0,0 +1,67 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+/*
+ * Copyright (c) 2018-2022 The Regents of the University of California (Regents).
+ * Copyright (c) 2023 Univrsity of Tampere.
+ *
+ * Authors:
+ * Dayeol Lee <dayeol@berkeley.edu>
+ * Evgeny Pobachienko <evgenyp@berkeley.edu>
+ * Jarkko Sakkinen <jarkko.sakkinen@tuni.fi>
+ */
+
+#ifndef UAPI_ASM_RISCV_KEYSTONE_H
+#define UAPI_ASM_RISCV_KEYSTONE_H
+
+#include <linux/types.h>
+#include <linux/ioctl.h>
+
+/* Same as TEE_IOC_MAGIC */
+#define KEYSTONE_IOC 0xA4
+
+#define KEYSTONE_IOC_CREATE_ENCLAVE _IOR(KEYSTONE_IOC, 0x00, struct keystone_enclave)
+#define KEYSTONE_IOC_DESTROY_ENCLAVE _IOW(KEYSTONE_IOC, 0x01, struct keystone_enclave)
+#define KEYSTONE_IOC_RUN_ENCLAVE _IOR(KEYSTONE_IOC, 0x04, struct keystone_run)
+#define KEYSTONE_IOC_RESUME_ENCLAVE _IOR(KEYSTONE_IOC, 0x05, struct keystone_run)
+#define KEYSTONE_IOC_FINALIZE_ENCLAVE _IOR(KEYSTONE_IOC, 0x06, struct keystone_enclave)
+#define KEYSTONE_IOC_UTM_INIT _IOR(KEYSTONE_IOC, 0x07, struct keystone_enclave)
+#define KEYSTONE_IOC_FINALIZE_LIBRARY_ENCLAVE _IOR(KEYSTONE_IOC, 0x09, struct keystone_enclave)
+#define KEYSTONE_IOC_DESTROY_LIBRARY_ENCLAVE _IOW(KEYSTONE_IOC, 0x0a, struct keystone_enclave)
+
+#define RT_NOEXEC 0
+#define USER_NOEXEC 1
+#define RT_FULL 2
+#define USER_FULL 3
+#define UTM_FULL 4
+
+struct runtime_params_t {
+ __u64 runtime_entry;
+ __u64 user_entry;
+ __u64 untrusted_ptr;
+ __u64 untrusted_size;
+};
+
+struct keystone_enclave {
+ __u64 eid;
+ __u64 min_pages;
+ __u64 runtime_vaddr;
+ __u64 user_vaddr;
+ __u64 pt_ptr;
+ __u64 utm_free_ptr;
+ __u64 epm_paddr;
+ __u64 utm_paddr;
+ __u64 runtime_paddr;
+ __u64 user_paddr;
+ __u64 free_paddr;
+ __u64 epm_size;
+ __u64 utm_size;
+ struct runtime_params_t params;
+ __u64 library_name;
+};
+
+struct keystone_run {
+ __u64 eid;
+ __u64 error;
+ __u64 value;
+};
+
+#endif /* UAPI_ASM_RISCV_KEYSTONE_H */
diff --git a/arch/riscv/kernel/Makefile b/arch/riscv/kernel/Makefile
index 95cf25d..f0d1df9 100644
--- a/arch/riscv/kernel/Makefile
+++ b/arch/riscv/kernel/Makefile
@@ -101,3 +101,5 @@
obj-$(CONFIG_64BIT) += pi/
obj-$(CONFIG_ACPI) += acpi.o
+
+obj-$(CONFIG_RISCV_KEYSTONE) += keystone/
diff --git a/arch/riscv/kernel/keystone/Makefile b/arch/riscv/kernel/keystone/Makefile
new file mode 100644
index 0000000..dc31f78
--- /dev/null
+++ b/arch/riscv/kernel/keystone/Makefile
@@ -0,0 +1 @@
+obj-y := keystone.o page.o ioctl.o enclave.o
diff --git a/arch/riscv/kernel/keystone/enclave.c b/arch/riscv/kernel/keystone/enclave.c
new file mode 100644
index 0000000..9b28e01
--- /dev/null
+++ b/arch/riscv/kernel/keystone/enclave.c
@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2018-2022 The Regents of the University of California (Regents).
+ * Copyright (c) 2023 Univrsity of Tampere.
+ *
+ * Authors:
+ * Dayeol Lee <dayeol@berkeley.edu>
+ * Evgeny Pobachienko <evgenyp@berkeley.edu>
+ * Jarkko Sakkinen <jarkko.sakkinen@tuni.fi>
+ */
+
+#include <linux/dma-mapping.h>
+#include "keystone.h"
+
+/* database for enclave ID's (EID's) of active enclaves: */
+DEFINE_IDR(idr_enclave);
+/* lock for idr_enclave: */
+DEFINE_MUTEX(idr_enclave_lock);
+
+#define ENCLAVE_IDR_MIN 0x1000
+#define ENCLAVE_IDR_MAX 0xffff
+
+void keystone_enclave_destroy(struct enclave *enclave)
+{
+ struct epm *epm;
+ struct utm *utm;
+
+ WARN_ON_ONCE(!enclave);
+
+ if (!enclave)
+ return;
+
+ epm = enclave->epm;
+ utm = enclave->utm;
+
+ if (epm) {
+#ifdef CONFIG_CMA
+ dma_free_coherent(keystone_dev.this_device, epm->size, epm->ptr, epm->pa);
+#else
+ free_pages(epm->ptr, epm->order);
+#endif
+ kfree(epm);
+ }
+
+ if (utm) {
+ if (utm->ptr)
+ free_pages((vaddr_t)utm->ptr, utm->order);
+
+ kfree(utm);
+ }
+
+ kfree(enclave);
+}
+
+struct enclave *keystone_enclave_create(unsigned long min_pages)
+{
+ struct enclave *enclave;
+
+ enclave = kzalloc(sizeof(*enclave), GFP_KERNEL);
+ if (!enclave)
+ return NULL;
+
+ enclave->eid = -1; /* invalid */
+ enclave->utm = NULL;
+ enclave->close_on_pexit = 1;
+ enclave->is_init = true;
+
+ enclave->epm = kzalloc(sizeof(*enclave->epm), GFP_KERNEL);
+ if (!enclave->epm)
+ goto err;
+
+ if (epm_init(enclave->epm, min_pages))
+ goto err;
+
+ return enclave;
+
+err:
+ keystone_enclave_destroy(enclave);
+ return NULL;
+}
+
+int keystone_alloc_eid(struct enclave *enclave)
+{
+ int ret;
+
+ mutex_lock(&idr_enclave_lock);
+ ret = idr_alloc(&idr_enclave, enclave, ENCLAVE_IDR_MIN, ENCLAVE_IDR_MAX, GFP_KERNEL);
+ mutex_unlock(&idr_enclave_lock);
+
+ return ret;
+}
+
+struct enclave *keystone_free_eid(unsigned int ueid)
+{
+ struct enclave *enclave;
+
+ mutex_lock(&idr_enclave_lock);
+ enclave = idr_remove(&idr_enclave, ueid);
+ mutex_unlock(&idr_enclave_lock);
+
+ return enclave;
+}
diff --git a/arch/riscv/kernel/keystone/ioctl.c b/arch/riscv/kernel/keystone/ioctl.c
new file mode 100644
index 0000000..9e5a727
--- /dev/null
+++ b/arch/riscv/kernel/keystone/ioctl.c
@@ -0,0 +1,342 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2018-2022 The Regents of the University of California (Regents).
+ * Copyright (c) 2023 Univrsity of Tampere.
+ *
+ * Authors:
+ * Dayeol Lee <dayeol@berkeley.edu>
+ * Evgeny Pobachienko <evgenyp@berkeley.edu>
+ * Jarkko Sakkinen <jarkko.sakkinen@tuni.fi>
+ */
+
+#include <linux/uaccess.h>
+#include <asm/sbi.h>
+#include <uapi/asm/keystone.h>
+#include "keystone.h"
+#include "sbi.h"
+
+static int keystone_ioc_create_enclave(struct file *filep, unsigned long arg)
+{
+ struct keystone_enclave *enclp = (struct keystone_enclave *)arg;
+ struct enclave *enclave;
+ struct epm *epm;
+ ssize_t ret;
+
+ enclave = keystone_enclave_create(enclp->min_pages);
+ if (!enclave)
+ return -ENOMEM;
+
+ ret = keystone_alloc_eid(enclave);
+ if (ret < 0) {
+ keystone_enclave_destroy(enclave);
+ return ret;
+ }
+
+ filep->private_data = enclave;
+
+ epm = enclave->epm;
+
+ enclp->eid = ret;
+ enclp->pt_ptr = __pa(epm->ptr);
+ enclp->epm_size = epm->size;
+
+ return 0;
+}
+
+static int keystone_ioc_finalize_enclave(struct file *filep, unsigned long arg)
+{
+ struct keystone_enclave *enclp = (struct keystone_enclave *)arg;
+ struct enclave *enclave = filep->private_data;
+ struct keystone_sbi_create args;
+ struct sbiret ret;
+ struct utm *utm;
+
+ if (!enclave)
+ return -EIO;
+
+ enclave->is_init = false;
+
+ /* PMP: */
+ args.epm_region.paddr = enclave->epm->pa;
+ args.epm_region.size = enclave->epm->size;
+
+ pr_debug("Enclave Private Memory (EPM): 0x%016llx - 0x%016llx\n",
+ args.epm_region.paddr,
+ args.epm_region.paddr + args.epm_region.size);
+
+ /* Untrusted memory: */
+ utm = enclave->utm;
+ if (utm) {
+ args.utm_region.paddr = __pa(utm->ptr);
+ args.utm_region.size = utm->size;
+
+ } else {
+ args.utm_region.paddr = 0;
+ args.utm_region.size = 0;
+ }
+
+ pr_debug("Untrusted memory (UTM): 0x%016llx - 0x%016llx\n",
+ args.utm_region.paddr,
+ args.utm_region.paddr + args.utm_region.size);
+
+ /* Physical addresses: */
+ args.runtime_paddr = enclp->runtime_paddr;
+ args.user_paddr = enclp->user_paddr;
+ args.free_paddr = enclp->free_paddr;
+
+ args.params = enclp->params;
+
+ ret = sbi_sm_call(SBI_SM_CREATE_ENCLAVE, (unsigned long)&args);
+ if (ret.error) {
+ pr_err("SBI_SM_CREATE_ENCLAVE error %ld\n", ret.error);
+ goto err;
+ }
+
+ enclave->eid = ret.value;
+ return 0;
+
+err:
+ keystone_enclave_destroy(enclave);
+ return -EIO;
+}
+
+static int keystone_ioc_run_enclave(struct file *filep, unsigned long data)
+{
+ struct keystone_run *arg = (struct keystone_run *)data;
+ struct enclave *enclave = filep->private_data;
+ struct sbiret ret;
+
+ if (!enclave)
+ return -EIO;
+
+ ret = sbi_sm_call(SBI_SM_RUN_ENCLAVE, enclave->eid);
+ arg->error = ret.error;
+ arg->value = ret.value;
+
+ return 0;
+}
+
+static int __keystone_ioc_destroy_enclave(struct enclave *enclave)
+{
+ struct sbiret ret;
+
+ ret = sbi_sm_call(SBI_SM_DESTROY_ENCLAVE, enclave->eid);
+ if (ret.error) {
+ pr_err("SBI_SM_DESTROY_ENCLAVE error %ld\n", ret.error);
+ return -EIO;
+ }
+
+ keystone_enclave_destroy(enclave);
+ keystone_free_eid(enclave->eid);
+
+ return 0;
+}
+
+/*
+ * Do not free up the software resources (physical memory regions and idr to be
+ * more specific) in the case of SBI failure because otherwise there would be a
+ * mismatch between the software and hardware states.
+ */
+static int keystone_ioc_destroy_enclave(struct file *filep, unsigned long arg)
+{
+ struct enclave *enclave = filep->private_data;
+ int ret;
+
+ if (!enclave) {
+ pr_debug("%s: enclave already destroyed\n", __func__);
+ return -EIO;
+ }
+
+ ret = __keystone_ioc_destroy_enclave(enclave);
+ if (ret)
+ return ret;
+
+ filep->private_data = NULL;
+ return 0;
+}
+
+static int keystone_ioc_resume_enclave(struct file *filep, unsigned long data)
+{
+ struct keystone_run *arg = (struct keystone_run *)data;
+ struct enclave *enclave = filep->private_data;
+ struct sbiret ret;
+
+ if (!enclave)
+ return -EIO;
+
+ ret = sbi_sm_call(SBI_SM_RESUME_ENCLAVE, enclave->eid);
+ arg->error = ret.error;
+ arg->value = ret.value;
+
+ return 0;
+}
+
+static int keystone_ioc_utm_init(struct file *filep, unsigned long arg)
+{
+ struct keystone_enclave *enclp = (struct keystone_enclave *)arg;
+ u64 untrusted_size = enclp->params.untrusted_size;
+ struct enclave *enclave = filep->private_data;
+ struct utm *utm;
+ int ret = 0;
+
+ if (!enclave)
+ return -EIO;
+
+ utm = kzalloc(sizeof(*utm), GFP_KERNEL);
+ if (!utm) {
+ ret = -ENOMEM;
+ return ret;
+ }
+
+ ret = utm_init(utm, PFN_UP(untrusted_size));
+ if (ret) {
+ pr_warn("utm_init() returned %d\n", ret);
+ kfree(utm);
+ return ret;
+ }
+
+ /* Prepare for mmap: */
+ enclave->utm = utm;
+ enclp->utm_free_ptr = __pa(utm->ptr);
+
+ return ret;
+}
+
+static int keystone_ioc_finalize_library_enclave(struct file *filep, unsigned long arg)
+{
+ struct keystone_enclave *enclp = (struct keystone_enclave *)arg;
+ struct enclave *enclave = filep->private_data;
+ struct keystone_sbi_create create_args;
+ struct sbiret ret;
+
+ if (!enclave)
+ return -EIO;
+
+ enclave->is_init = false;
+
+ create_args.epm_region.paddr = enclave->epm->pa;
+ create_args.epm_region.size = enclave->epm->size;
+ // Don't need untrusted memory for library enclaves:
+ create_args.utm_region.paddr = 0;
+ create_args.utm_region.size = 0;
+
+ if (strncpy_from_user(create_args.library_name,
+ (const char __user *)enclp->library_name,
+ NAME_MAX) < 0)
+ return -EFAULT;
+
+ ret = sbi_sm_call(SBI_SM_CREATE_LIBRARY_ENCLAVE, (unsigned long)&create_args);
+ if (ret.error) {
+ pr_err("SBI_SM_CREATE_LIBRARY_ENCLAVE error %ld\n", ret.error);
+ goto err;
+ }
+
+ enclave->eid = ret.value;
+ return 0;
+
+err:
+ keystone_enclave_destroy(enclave);
+ return -EIO;
+}
+
+/*
+ * Do not free up the software resources (physical memory regions and idr to be
+ * more specific) in the case of SBI failure because otherwise there would be a
+ * mismatch between the software and hardware states.
+ */
+static int keystone_ioc_destroy_library_enclave(struct file *filep, unsigned long arg)
+{
+ struct enclave *enclave = filep->private_data;
+ struct sbiret ret;
+
+ if (!enclave)
+ return -EIO;
+
+ ret = sbi_sm_call(SBI_SM_DESTROY_LIBRARY_ENCLAVE, enclave->eid);
+ if (ret.error) {
+ pr_err("SBI_SM_DESTROY_LIBRARY_ENCLAVE error %ld\n", ret.error);
+ return -EIO;
+ }
+
+ keystone_enclave_destroy(enclave);
+ filep->private_data = NULL;
+ return 0;
+}
+
+long keystone_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
+{
+ struct enclave *enclave = filep->private_data;
+ size_t ioc_size;
+ char data[512];
+ long ret;
+
+ if (!enclave)
+ return -EIO;
+
+ /* Mutually exclude concurrent threads: */
+ if (test_and_set_bit(true, &enclave->busy)) {
+ pr_info("%d busy\n", enclave->eid);
+ return -EBUSY;
+ }
+
+ ioc_size = _IOC_SIZE(cmd);
+ ioc_size = ioc_size > sizeof(data) ? sizeof(data) : ioc_size;
+
+ if (copy_from_user(data, (void __user *)arg, ioc_size)) {
+ ret = -EFAULT;
+ goto err;
+ }
+
+ switch (cmd) {
+ case KEYSTONE_IOC_CREATE_ENCLAVE:
+ ret = keystone_ioc_create_enclave(filep, (unsigned long)data);
+ break;
+ case KEYSTONE_IOC_FINALIZE_ENCLAVE:
+ ret = keystone_ioc_finalize_enclave(filep, (unsigned long)data);
+ break;
+ case KEYSTONE_IOC_DESTROY_ENCLAVE:
+ ret = keystone_ioc_destroy_enclave(filep, (unsigned long)data);
+ break;
+ case KEYSTONE_IOC_RUN_ENCLAVE:
+ ret = keystone_ioc_run_enclave(filep, (unsigned long)data);
+ break;
+ case KEYSTONE_IOC_RESUME_ENCLAVE:
+ ret = keystone_ioc_resume_enclave(filep, (unsigned long)data);
+ break;
+ case KEYSTONE_IOC_UTM_INIT:
+ ret = keystone_ioc_utm_init(filep, (unsigned long)data);
+ break;
+ case KEYSTONE_IOC_FINALIZE_LIBRARY_ENCLAVE:
+ ret = keystone_ioc_finalize_library_enclave(filep, (unsigned long)data);
+ break;
+ case KEYSTONE_IOC_DESTROY_LIBRARY_ENCLAVE:
+ ret = keystone_ioc_destroy_library_enclave(filep, (unsigned long)data);
+ break;
+ default:
+ ret = -ENOIOCTLCMD;
+ break;
+ }
+
+ /* Copy back only on success: */
+ if (!ret && copy_to_user((void __user *)arg, data, ioc_size))
+ ret = -EFAULT;
+
+err:
+ clear_bit(true, &enclave->busy);
+ return ret;
+}
+
+int keystone_release(struct inode *inode, struct file *file)
+{
+ struct enclave *enclave = file->private_data;
+
+ if (!enclave) {
+ pr_warn("%s: enclave was already destroyed\n", __func__);
+ return 0;
+ }
+
+ if (enclave->close_on_pexit)
+ return __keystone_ioc_destroy_enclave(enclave);
+
+ return 0;
+}
diff --git a/arch/riscv/kernel/keystone/keystone.c b/arch/riscv/kernel/keystone/keystone.c
new file mode 100644
index 0000000..11e407a0
--- /dev/null
+++ b/arch/riscv/kernel/keystone/keystone.c
@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2018-2022 The Regents of the University of California (Regents).
+ * Copyright (c) 2023 Univrsity of Tampere.
+ *
+ * Authors:
+ * Dayeol Lee <dayeol@berkeley.edu>
+ * Evgeny Pobachienko <evgenyp@berkeley.edu>
+ * Jarkko Sakkinen <jarkko.sakkinen@tuni.fi>
+ */
+
+#include <linux/dma-mapping.h>
+#include <linux/mm.h>
+#include <linux/file.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/miscdevice.h>
+#include <linux/anon_inodes.h>
+#include <uapi/asm/keystone.h>
+#include "keystone.h"
+#include "sbi.h"
+
+static const struct file_operations keystone_fops = {
+ .owner = THIS_MODULE,
+ .mmap = keystone_mmap,
+ .unlocked_ioctl = keystone_ioctl,
+ .release = keystone_release
+};
+
+struct miscdevice keystone_dev = {
+ .minor = MISC_DYNAMIC_MINOR,
+ .name = "keystone_enclave",
+ .fops = &keystone_fops,
+ .mode = 0666,
+};
+
+struct file *keystone_open(void)
+{
+ return anon_inode_getfile("[keystone]", &keystone_fops, NULL, O_RDWR);
+}
+EXPORT_SYMBOL_GPL(keystone_open);
+
+int keystone_mmap(struct file *filep, struct vm_area_struct *vma)
+{
+ struct enclave *enclave = filep->private_data;
+ unsigned long vsize, psize;
+ struct utm *utm;
+ struct epm *epm;
+ vaddr_t paddr;
+
+ if (!enclave)
+ return -EIO;
+
+ utm = enclave->utm;
+ epm = enclave->epm;
+ vsize = vma->vm_end - vma->vm_start;
+
+ if (enclave->is_init) {
+ if (vsize > PAGE_SIZE)
+ return -EINVAL;
+
+ paddr = __pa(epm->ptr) + (vma->vm_pgoff << PAGE_SHIFT);
+ remap_pfn_range(vma, vma->vm_start, paddr >> PAGE_SHIFT, vsize, vma->vm_page_prot);
+ } else {
+ psize = utm->size;
+ if (vsize > psize)
+ return -EINVAL;
+
+ remap_pfn_range(vma, vma->vm_start, __pa(utm->ptr) >> PAGE_SHIFT, vsize,
+ vma->vm_page_prot);
+ }
+
+ return 0;
+}
+
+static int __init keystone_init(void)
+{
+ int ret;
+
+ ret = misc_register(&keystone_dev);
+ if (ret < 0)
+ return ret;
+
+ keystone_dev.this_device->coherent_dma_mask = DMA_BIT_MASK(32);
+ return 0;
+}
+
+device_initcall(keystone_init);
diff --git a/arch/riscv/kernel/keystone/keystone.h b/arch/riscv/kernel/keystone/keystone.h
new file mode 100644
index 0000000..300b394
--- /dev/null
+++ b/arch/riscv/kernel/keystone/keystone.h
@@ -0,0 +1,73 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (c) 2018-2022 The Regents of the University of California (Regents).
+ * Copyright (c) 2023 Univrsity of Tampere.
+ *
+ * Authors:
+ * Dayeol Lee <dayeol@berkeley.edu>
+ * Evgeny Pobachienko <evgenyp@berkeley.edu>
+ * Jarkko Sakkinen <jarkko.sakkinen@tuni.fi>
+ */
+
+#ifndef RISCV_KEYSTONE_H
+#define RISCV_KEYSTONE_H
+
+#include <asm/sbi.h>
+#include <asm/csr.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/uaccess.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/miscdevice.h>
+#include <linux/idr.h>
+#include <linux/file.h>
+#include "riscv64.h"
+
+#undef pr_fmt
+#define pr_fmt(fmt) "keystone: " fmt
+
+typedef u64 vaddr_t;
+typedef u64 paddr_t;
+
+extern struct miscdevice keystone_dev;
+
+long keystone_ioctl(struct file *filep, unsigned int cmd, unsigned long arg);
+int keystone_release(struct inode *inode, struct file *file);
+int keystone_mmap(struct file *filp, struct vm_area_struct *vma);
+
+struct epm {
+ void *ptr;
+ size_t size;
+ unsigned long order;
+ phys_addr_t pa;
+};
+
+struct utm {
+ void *ptr;
+ size_t size;
+ unsigned long order;
+};
+
+struct enclave {
+ int eid;
+ int close_on_pexit;
+ struct utm *utm;
+ struct epm *epm;
+ bool is_init;
+ /* marks when ioctl is active with another thread: */
+ unsigned long busy;
+};
+
+struct enclave *keystone_enclave_create(unsigned long min_pages);
+void keystone_enclave_destroy(struct enclave *enclave);
+
+int keystone_alloc_eid(struct enclave *enclave);
+struct enclave *keystone_free_eid(unsigned int ueid);
+
+int epm_init(struct epm *epm, unsigned long requested_pages);
+int utm_init(struct utm *utm, unsigned long requested_pages);
+
+#endif /* RISCV_KEYSTONE_H */
diff --git a/arch/riscv/kernel/keystone/page.c b/arch/riscv/kernel/keystone/page.c
new file mode 100644
index 0000000..4c1fcf6
--- /dev/null
+++ b/arch/riscv/kernel/keystone/page.c
@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2018-2022 The Regents of the University of California (Regents).
+ * Copyright (c) 2023 Univrsity of Tampere.
+ *
+ * Authors:
+ * Dayeol Lee <dayeol@berkeley.edu>
+ * Evgeny Pobachienko <evgenyp@berkeley.edu>
+ * Jarkko Sakkinen <jarkko.sakkinen@tuni.fi>
+ */
+
+#include <linux/kernel.h>
+#include <linux/dma-mapping.h>
+#include "riscv64.h"
+#include "keystone.h"
+
+/*
+ * Initialize Enclave Private Memory (EPM).
+ */
+int epm_init(struct epm *epm, unsigned long requested_pages)
+{
+ unsigned long aligned_pages = __roundup_pow_of_two(requested_pages);
+ phys_addr_t __maybe_unused device_phys_addr = 0;
+ unsigned long order = ilog2(aligned_pages);
+ void *ptr = NULL;
+
+#ifdef CONFIG_CMA
+ ptr = dma_alloc_coherent(keystone_dev.this_device,
+ aligned_pages << PAGE_SHIFT,
+ &device_phys_addr,
+ GFP_KERNEL);
+#else
+ if (order < MAX_ORDER)
+ ptr = __get_free_pages(GFP_HIGHUSER, order);
+ else
+ return -EINVAL;
+#endif
+
+ if (!ptr)
+ return -ENOMEM;
+
+ /* Zero the payload: */
+ memset(ptr, 0, aligned_pages);
+
+ epm->pa = __pa(ptr);
+ epm->order = order;
+ epm->size = aligned_pages << PAGE_SHIFT;
+ epm->ptr = ptr;
+ return 0;
+}
+
+/*
+ * Initialize UnTrusted Memory (UTM).
+ */
+int utm_init(struct utm *utm, unsigned long requested_pages)
+{
+
+ unsigned long aligned_pages = __roundup_pow_of_two(requested_pages);
+ phys_addr_t __maybe_unused device_phys_addr = 0;
+ unsigned long order = ilog2(aligned_pages);
+
+ utm->ptr = (void *)__get_free_pages(GFP_HIGHUSER, order);
+ if (!utm->ptr)
+ return -ENOMEM;
+
+ utm->order = order;
+ utm->size = aligned_pages << PAGE_SHIFT;
+ return 0;
+}
diff --git a/arch/riscv/kernel/keystone/riscv64.h b/arch/riscv/kernel/keystone/riscv64.h
new file mode 100644
index 0000000..9bc59f4
--- /dev/null
+++ b/arch/riscv/kernel/keystone/riscv64.h
@@ -0,0 +1,80 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (c) 2018-2022 The Regents of the University of California (Regents).
+ * Copyright (c) 2023 Univrsity of Tampere.
+ *
+ * Authors:
+ * Dayeol Lee <dayeol@berkeley.edu>
+ * Evgeny Pobachienko <evgenyp@berkeley.edu>
+ * Jarkko Sakkinen <jarkko.sakkinen@tuni.fi>
+ */
+
+#ifndef RISCV64_H
+#define RISCV64_H
+
+#include <asm/page.h>
+#include <linux/types.h>
+
+#define PRV_U 0
+#define PRV_S 1
+#define PRV_H 2
+#define PRV_M 3
+
+#define SATP32_MODE 0x80000000
+#define SATP32_ASID 0x7FC00000
+#define SATP32_PPN 0x003FFFFF
+#define SATP64_MODE 0xF000000000000000
+#define SATP64_ASID 0x0FFFF00000000000
+#define SATP64_PPN 0x00000FFFFFFFFFFF
+
+#define SATP_MODE_OFF 0
+#define SATP_MODE_SV32 1
+#define SATP_MODE_SV39 8
+#define SATP_MODE_SV48 9
+#define SATP_MODE_SV57 10
+#define SATP_MODE_SV64 11
+
+/* page table entry (PTE) fields */
+#define PTE_V 0x001 /* Valid */
+#define PTE_R 0x002 /* Read */
+#define PTE_W 0x004 /* Write */
+#define PTE_X 0x008 /* Execute */
+#define PTE_U 0x010 /* User */
+#define PTE_G 0x020 /* Global */
+#define PTE_A 0x040 /* Accessed */
+#define PTE_D 0x080 /* Dirty */
+#define PTE_SOFT 0x300 /* Reserved for Software */
+
+#define PTE_PPN_SHIFT 10
+
+#define PTE_TABLE(PTE) (((PTE) & (PTE_V | PTE_R | PTE_W | PTE_X)) == PTE_V)
+
+#define MSTATUS_SD MSTATUS64_SD
+#define SSTATUS_SD SSTATUS64_SD
+#define RISCV_PGLEVEL_BITS 9
+
+#define RISCV_PGSHIFT 12
+#define RISCV_PGSIZE BIT(RISCV_PGSHIFT)
+
+#define MEGAPAGE_SIZE ((u64)(RISCV_PGSIZE << RISCV_PGLEVEL_BITS))
+#define SATP_MODE_CHOICE \
+ ((0 & (~SATP64_MODE)) | (SATP_MODE_SV39 * (SATP64_MODE & (~(SATP64_MODE - 1)))))
+
+#define GIGAPAGE_SIZE (MEGAPAGE_SIZE << RISCV_PGLEVEL_BITS)
+
+static inline void flush_tlb(void)
+{
+ asm volatile("sfence.vma");
+}
+
+static inline pte_t pte_create(unsigned long ppn, int type)
+{
+ return __pte((ppn << PTE_PPN_SHIFT) | PTE_V | type);
+}
+
+static inline pte_t ptd_create(unsigned long ppn)
+{
+ return pte_create(ppn, PTE_V);
+}
+
+#endif /* RISCV64_H */
diff --git a/arch/riscv/kernel/keystone/sbi.h b/arch/riscv/kernel/keystone/sbi.h
new file mode 100644
index 0000000..a6f2b2d
--- /dev/null
+++ b/arch/riscv/kernel/keystone/sbi.h
@@ -0,0 +1,47 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (c) 2018-2022 The Regents of the University of California (Regents).
+ * Copyright (c) 2023 Univrsity of Tampere.
+ *
+ * Dayeol Lee <dayeol@berkeley.edu>
+ * Evgeny Pobachienko <evgenyp@berkeley.edu>
+ * Jarkko Sakkinen <jarkko.sakkinen@tuni.fi>
+ */
+
+#ifndef RISCV_KEYSTONE_SBI_H
+#define RISCV_KEYSTONE_SBI_H
+
+#include <uapi/asm/keystone.h>
+#include <asm/sbi.h>
+
+#define KEYSTONE_SBI_EXT_ID 0x08424b45
+#define SBI_SM_CREATE_ENCLAVE 2001
+#define SBI_SM_DESTROY_ENCLAVE 2002
+#define SBI_SM_RUN_ENCLAVE 2003
+#define SBI_SM_RESUME_ENCLAVE 2005
+#define SBI_SM_CREATE_LIBRARY_ENCLAVE 2006
+#define SBI_SM_DESTROY_LIBRARY_ENCLAVE 2007
+
+struct keystone_sbi_pregion {
+ u64 paddr;
+ size_t size;
+};
+
+struct keystone_sbi_create {
+ /* memory regions */
+ struct keystone_sbi_pregion epm_region;
+ struct keystone_sbi_pregion utm_region;
+
+ /* physical addresses */
+ u64 runtime_paddr;
+ u64 user_paddr;
+ u64 free_paddr;
+
+ /* parameters */
+ struct runtime_params_t params;
+ char library_name[NAME_MAX];
+};
+
+#define sbi_sm_call(id, value) sbi_ecall(KEYSTONE_SBI_EXT_ID, (id), (value), 0, 0, 0, 0, 0)
+
+#endif /* RISCV_KEYSTONE_SBI_H */
