openssl - Mirror of https://github.com/openssl/openssl

Age	Commit message (Expand)	Author
2011-02-08	OCSP stapling fix (OpenSSL 0.9.8r/1.0.0d)	Bodo Möller
2008-05-27	year 2008	Bodo Möller
2007-02-17	Reorganize the data used for SSL ciphersuite pattern matching.	Bodo Möller
2006-06-14	Thread-safety fixes	Bodo Möller
2005-04-25	update	Bodo Möller
2003-02-24	year 2003	Bodo Möller
2002-03-15	fix ssl3_pending	Bodo Möller
2001-01-24	new year	Ulf Möller
2000-01-27	Increase the year by one.	Ulf Möller
1999-03-06	Cleaned up the LICENSE document: The official contact for any license	Ralf S. Engelschall
1999-02-26	Use consistent and existing addresses	Ralf S. Engelschall
1998-12-23	Switch to OpenSSL name	Ralf S. Engelschall
1998-12-22	* empty log message *	Ralf S. Engelschall
1998-12-22	Various cleanups and fixed by Marc and Ralf to start the OpenTLS project	Ralf S. Engelschall

// SPDX-License-Identifier: GPL-2.0-only /* * AMD Memory Encryption Support * * Copyright (C) 2016 Advanced Micro Devices, Inc. * * Author: Tom Lendacky <thomas.lendacky@amd.com> */ #define DISABLE_BRANCH_PROFILING /* * Since we're dealing with identity mappings, physical and virtual * addresses are the same, so override these defines which are ultimately * used by the headers in misc.h. */ #define __pa(x) ((unsigned long)(x)) #define __va(x) ((void *)((unsigned long)(x))) /* * Special hack: we have to be careful, because no indirections are * allowed here, and paravirt_ops is a kind of one. As it will only run in * baremetal anyway, we just keep it from happening. (This list needs to * be extended when new paravirt and debugging variants are added.) */ #undef CONFIG_PARAVIRT #undef CONFIG_PARAVIRT_XXL #undef CONFIG_PARAVIRT_SPINLOCKS #include <linux/kernel.h> #include <linux/mm.h> #include <linux/mem_encrypt.h> #include <asm/setup.h> #include <asm/sections.h> #include <asm/cmdline.h> #include "mm_internal.h" #define PGD_FLAGS _KERNPG_TABLE_NOENC #define P4D_FLAGS _KERNPG_TABLE_NOENC #define PUD_FLAGS _KERNPG_TABLE_NOENC #define PMD_FLAGS _KERNPG_TABLE_NOENC #define PMD_FLAGS_LARGE (__PAGE_KERNEL_LARGE_EXEC & ~_PAGE_GLOBAL) #define PMD_FLAGS_DEC PMD_FLAGS_LARGE #define PMD_FLAGS_DEC_WP ((PMD_FLAGS_DEC & ~_PAGE_CACHE_MASK) | \ (_PAGE_PAT | _PAGE_PWT)) #define PMD_FLAGS_ENC (PMD_FLAGS_LARGE | _PAGE_ENC) #define PTE_FLAGS (__PAGE_KERNEL_EXEC & ~_PAGE_GLOBAL) #define PTE_FLAGS_DEC PTE_FLAGS #define PTE_FLAGS_DEC_WP ((PTE_FLAGS_DEC & ~_PAGE_CACHE_MASK) | \ (_PAGE_PAT | _PAGE_PWT)) #define PTE_FLAGS_ENC (PTE_FLAGS | _PAGE_ENC) struct sme_populate_pgd_data { void *pgtable_area; pgd_t *pgd; pmdval_t pmd_flags; pteval_t pte_flags; unsigned long paddr; unsigned long vaddr; unsigned long vaddr_end; }; /* * This work area lives in the .init.scratch section, which lives outside of * the kernel proper. It is sized to hold the intermediate copy buffer and * more than enough pagetable pages. * * By using this section, the kernel can be encrypted in place and it * avoids any possibility of boot parameters or initramfs images being * placed such that the in-place encryption logic overwrites them. This * section is 2MB aligned to allow for simple pagetable setup using only * PMD entries (see vmlinux.lds.S). */ static char sme_workarea[2 * PMD_PAGE_SIZE] __section(.init.scratch); static char sme_cmdline_arg[] __initdata = "mem_encrypt"; static char sme_cmdline_on[] __initdata = "on"; static char sme_cmdline_off[] __initdata = "off"; static void __init sme_clear_pgd(struct sme_populate_pgd_data *ppd) { unsigned long pgd_start, pgd_end, pgd_size; pgd_t *pgd_p; pgd_start = ppd->vaddr & PGDIR_MASK; pgd_end = ppd->vaddr_end & PGDIR_MASK; pgd_size = (((pgd_end - pgd_start) / PGDIR_SIZE) + 1) * sizeof(pgd_t); pgd_p = ppd->pgd + pgd_index(ppd->vaddr); memset(pgd_p, 0, pgd_size); } static pud_t __init *sme_prepare_pgd(struct sme_populate_pgd_data *ppd) { pgd_t *pgd; p4d_t *p4d; pud_t *pud; pmd_t *pmd; pgd = ppd->pgd + pgd_index(ppd->vaddr); if (pgd_none(*pgd)) { p4d = ppd->pgtable_area; memset(p4d, 0, sizeof(*p4d) * PTRS_PER_P4D); ppd->pgtable_area += sizeof(*p4d) * PTRS_PER_P4D; set_pgd(pgd, __pgd(PGD_FLAGS | __pa(p4d))); } p4d = p4d_offset(pgd, ppd->vaddr); if (p4d_none(*p4d)) { pud = ppd->pgtable_area; memset(pud, 0, sizeof(*pud) * PTRS_PER_PUD); ppd->pgtable_area += sizeof(*pud) * PTRS_PER_PUD; set_p4d(p4d, __p4d(P4D_FLAGS | __pa(pud))); } pud = pud_offset(p4d, ppd->vaddr); if (pud_none(*pud)) { pmd = ppd->pgtable_area; memset(pmd, 0, sizeof(*pmd) * PTRS_PER_PMD); ppd->pgtable_area += sizeof(*pmd) * PTRS_PER_PMD; set_pud(pud, __pud(PUD_FLAGS | __pa(pmd))); } if (pud_large(*pud)) return NULL; return pud; } static void __init sme_populate_pgd_large(struct sme_populate_pgd_data *ppd) { pud_t *pud; pmd_t *pmd; pud = sme_prepare_pgd(ppd); if (!pud) return; pmd = pmd_offset(pud, ppd->vaddr); if (pmd_large(*pmd)) return; set_pmd(pmd, __pmd(ppd->paddr | ppd->pmd_flags)); } static void __init sme_populate_pgd(struct sme_populate_pgd_data *ppd) { pud_t *pud; pmd_t *pmd; pte_t *pte; pud = sme_prepare_pgd(ppd); if (!pud) return; pmd = pmd_offset(pud, ppd->vaddr); if (pmd_none(*pmd)) { pte = ppd->pgtable_area; memset(pte, 0, sizeof(*pte) * PTRS_PER_PTE); ppd->pgtable_area += sizeof(*pte) * PTRS_PER_PTE; set_pmd(pmd, __pmd(PMD_FLAGS | __pa(pte))); } if (pmd_large(*pmd)) return; pte = pte_offset_map(pmd, ppd->vaddr); if (pte_none(*pte)) set_pte(pte, __pte(ppd->paddr | ppd->pte_flags)); } static void __init __sme_map_range_pmd(struct sme_populate_pgd_data *ppd) { while (ppd->vaddr < ppd->vaddr_end) { sme_populate_pgd_large(ppd); ppd->vaddr += PMD_PAGE_SIZE; ppd->paddr += PMD_PAGE_SIZE; } } static void __init __sme_map_range_pte(struct sme_populate_pgd_data *ppd) { while (ppd->vaddr < ppd->vaddr_end) { sme_populate_pgd(ppd); ppd->vaddr += PAGE_SIZE; ppd->paddr += PAGE_SIZE; } } static void __init __sme_map_range(struct sme_populate_pgd_data *ppd, pmdval_t pmd_flags, pteval_t pte_flags) { unsigned long vaddr_end; ppd->pmd_flags = pmd_flags; ppd->pte_flags = pte_flags; /* Save original end value since we modify the struct value */ vaddr_end = ppd->vaddr_end; /* If start is not 2MB aligned, create PTE entries */ ppd->vaddr_end = ALIGN(ppd->vaddr, PMD_PAGE_SIZE); __sme_map_range_pte(ppd); /* Create PMD entries */ ppd->vaddr_end = vaddr_end & PMD_PAGE_MASK; __sme_map_range_pmd(ppd); /* If end is not 2MB aligned, create PTE entries */ ppd->vaddr_end = vaddr_end; __sme_map_range_pte(ppd); } static void __init sme_map_range_encrypted(struct sme_populate_pgd_data *ppd) { __sme_map_range(ppd, PMD_FLAGS_ENC, PTE_FLAGS_ENC); } static void __init sme_map_range_decrypted(struct sme_populate_pgd_data *ppd) { __sme_map_range(ppd, PMD_FLAGS_DEC, PTE_FLAGS_DEC); } static void __init sme_map_range_decrypted_wp(struct sme_populate_pgd_data *ppd) { __sme_map_range(ppd, PMD_FLAGS_DEC_WP, PTE_FLAGS_DEC_WP); } static unsigned long __init sme_pgtable_calc(unsigned long len) { unsigned long entries = 0, tables = 0; /* * Perform a relatively simplistic calculation of the pagetable * entries that are needed. Those mappings will be covered mostly * by 2MB PMD entries so we can conservatively calculate the required * number of P4D, PUD and PMD structures needed to perform the * mappings. For mappings that are not 2MB aligned, PTE mappings * would be needed for the start and end portion of the address range * that fall outside of the 2MB alignment. This results in, at most, * two extra pages to hold PTE entries for each range that is mapped. * Incrementing the count for each covers the case where the addresses * cross entries. */ /* PGDIR_SIZE is equal to P4D_SIZE on 4-level machine. */ if (PTRS_PER_P4D<