From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received-SPF: Pass (sender SPF authorized) identity=helo; client-ip=104.47.41.74; helo=nam03-dm3-obe.outbound.protection.outlook.com; envelope-from=brijesh.singh@amd.com; receiver=edk2-devel@lists.01.org Received: from NAM03-DM3-obe.outbound.protection.outlook.com (mail-dm3nam03on0074.outbound.protection.outlook.com [104.47.41.74]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-SHA384 (256/256 bits)) (No client certificate requested) by ml01.01.org (Postfix) with ESMTPS id 3077621F833DA for ; Thu, 4 Jan 2018 09:01:23 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=amdcloud.onmicrosoft.com; s=selector1-amd-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version; bh=pZRnwR7yMFc1nqq4H8VVftwv77Y7Ix0ejjpg5bFGLZQ=; b=U9WCA1e89fk5DdXd+OGi2uaJlXx9eCQKcNQFXErJGJckVodKJgS7aS14B/YGr2aqTA3fHOSfsMvsF7s+NTll8vZy3P5qgNmF7ZuHIZYcPvLXJ+Z4mqaQGyXVSiDMc+2qKgO6GQjSLCUw/E408n3muiuNJLiX21Gp+JoGOG3U/w4= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=brijesh.singh@amd.com; Received: from wsp141597wss.amd.com (165.204.78.1) by CY1PR12MB0151.namprd12.prod.outlook.com (10.161.173.21) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384_P256) id 15.20.386.5; Thu, 4 Jan 2018 17:06:24 +0000 From: Brijesh Singh To: edk2-devel@lists.01.org Cc: Tom Lendacky , Brijesh Singh , Jian J Wang , Jiewen Yao , Jordan Justen , Laszlo Ersek Date: Thu, 4 Jan 2018 11:06:02 -0600 Message-Id: <20180104170602.6617-1-brijesh.singh@amd.com> X-Mailer: git-send-email 2.9.5 MIME-Version: 1.0 X-Originating-IP: [165.204.78.1] X-ClientProxiedBy: BN6PR14CA0035.namprd14.prod.outlook.com (10.171.172.149) To CY1PR12MB0151.namprd12.prod.outlook.com (10.161.173.21) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-HT: Tenant X-MS-Office365-Filtering-Correlation-Id: 69b63ade-0601-4fa7-97af-08d553957ca3 X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(48565401081)(4534020)(4602075)(4627115)(201703031133081)(201702281549075)(5600026)(4604075)(2017052603307)(7153060); SRVR:CY1PR12MB0151; X-Microsoft-Exchange-Diagnostics: 1; CY1PR12MB0151; 3:ndK5plglTLaid6ve3h9PuFqdKn+vaiXiCwN2+C0r6B8QAQn46fDBIc0AdkfttM6tvKJDlIBv7LhYApNUsABI6fUSCXdPMB4NYJIjujectUO2ITTNkxqlJtRgVLiHR+6wjunP5Sm6HPras8GBSke/45LC+jNGJe8Ez9aINvL9J3bAggmYYyqud03uhJkRvOIzCvQ5RyaahwYjDyXM7fwzvpDecHfDpa6vAOt0YACuTyfOwhXkk9dhQdOzHfTojeGU; 25:j8omvYkP3Jdv4Ov+sjYrNJvT+UfKV6x6TBHlBb0LcvQ1nFeY79QackRq8E2wfXawRUpwePz4utx7s0USBB1DgBcS81i9w0Yx8xqLQL8SYlzb8uJdFhqZRsB+wsYkjVbjLlQ8U1tf7RanAMZ6Odhza/l26pPgbXfUJBCjzCxTxgwxWz07LJCT7K4ct5sLYmFJTGjMQ23dkrbeQcvPEMlpfzopOqZ5VHXBHutlqQ1gN3ibUEBLYh8XNvXh0fgVkfqCs+j9UZXikm04kEcPp69LgDW63PyuEIkFMAHHPvpaFT4zJ32jMdS6Z+x6Mm3l3Wwq14FHAciHNgzYnzbzWzb+9A==; 31:1ElxvC94Rdz6XQfdZJyFV3GhZRLaF75zDM7jWvIEYzaFzLlYmze2d/ZXpu4Gl7+ZdH/7ETCoWTAG2ROkgMdj0/7Xjzj5U2zqjHeC14mnrmJI1oYGpIDumawck5z+WoVL2TlT3rwCOpAs2tYCsuemXWrQoNAK7TFNZbWUDOvAubfblhqA17NsI19WOZMPbjSLArwq6rwIE6Bi1oAtq4tW0YzK1VOQJhEmd+b1sWiut6g= X-MS-TrafficTypeDiagnostic: CY1PR12MB0151: X-Microsoft-Exchange-Diagnostics: 1; CY1PR12MB0151; 20:VODF+vCHz8z3nRMmgKVA+hd8QCNUSsEyUIli7UxXia+fbM9FfzJvjcoTzjt+bcg1Wx+xYCu+sMbwQNQHUa76lGhKzYs4UMGXhiq5q22mjXFQm5cq9VqC0gFZK10suMb/fPmX6mMHrvkOgvg8/xtUqNEb3/Q7sTNA2+/7OzytSCJbHP1XYV4/LSPd0syuxdjSrM2JSMcTbtPvqrJlivfXHp7XCs1qef2seLEBXqBhjjGyaCa7oZngdqdvFvik79w491F9qwO8Nn2hruRd7y4EN42pZg+BGZLdx/PVXsN5k8oHT9QHdsTTcjGRqupVP1nhyJjN9digsyD2bNnPhbCEP1Il5bipPzfvPPS3WQatibgGCYUn0LsqTfgo69Yg/bVUcziS3ypigB5k/xP45cyFtU1tmmPb9eIkzd4SAbSHe6YY5bcmFz2lORE+T3dcQkwqO8z8WGbbY2IWzivwIgnuGLF/3/VCAnIr2getnB9hTZICemGHD/r8mhpGtsvldhjc; 4:inMSGmUxUTQEfMqOhblUHl32rpf95AUxdkcVoI4DcG2jjv3Kdw6aT3/MBt47JGKIf1hnJr8Jp+56SG2tOvG/NmV8vHU1OJLwig91GU1PgjbYJUbYHgKy+Njp3BJiWHkkylY7NqLsFxl5jS9SUH53Om/hkhGNqrbSZuULyicpzlbXvAeRbuEWUftqWOUYK514e/pYqem7MeL+Auo+XtP7uQCZhsuk6Ng37Csknn8SFTJ9HaQww4wU4N3AY4jWAKTciUVJV4mbpTx1HlmRBpSvM7Mn8bDJs72+lEHSgnZN+DbCJlSv/NltEsgh7L5QpXZVXzebdwgi0aR1T4syocL/hw== X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(767451399110)(228905959029699); X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(6040470)(2401047)(5005006)(8121501046)(10201501046)(3002001)(3231023)(944501075)(93006095)(93001095)(6055026)(6041268)(20161123564045)(20161123558120)(20161123560045)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123562045)(6072148)(201708071742011); SRVR:CY1PR12MB0151; BCL:0; PCL:0; RULEID:(100000803101)(100110400095); SRVR:CY1PR12MB0151; X-Forefront-PRVS: 054231DC40 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(39380400002)(39860400002)(376002)(396003)(346002)(366004)(189003)(199004)(106356001)(6116002)(81156014)(105586002)(6916009)(48376002)(8676002)(1076002)(6666003)(50466002)(86362001)(3846002)(16526018)(25786009)(478600001)(4326008)(16586007)(54906003)(305945005)(316002)(97736004)(36756003)(7736002)(52116002)(53936002)(2361001)(8936002)(50226002)(5660300001)(81166006)(51416003)(6486002)(68736007)(53416004)(7696005)(2351001)(2906002)(47776003)(59450400001)(386003)(66066001)(213903007)(19627235001); DIR:OUT; SFP:1101; SCL:1; SRVR:CY1PR12MB0151; H:wsp141597wss.amd.com; FPR:; SPF:None; PTR:InfoNoRecords; MX:1; A:1; LANG:en; Received-SPF: None (protection.outlook.com: amd.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; CY1PR12MB0151; 23:l2j2PEL28W+cJO/SLBJSWE1bgdRMVptFuwe3+z3m7?= =?us-ascii?Q?c9nWYuGz7SH8LeOCAHf+pg4qOeLNH9OuL+UGN/fpNmiWtXW7GbfkCEk0xjtA?= =?us-ascii?Q?XlnWOiFnwXo3SYODTyZG/eQbPIkN1ysRg8Z2vkfYaeIqqvc6Xdp1P+Y7txWa?= =?us-ascii?Q?AcOZg9Eppk9nlUDzbcdh/VBBPs6EYFuPg20FWkhBE9fEt/+Mbg9XM8A1+giQ?= =?us-ascii?Q?4L8KHiaXBenqazO9opnGYuV/M9SadmTCR2HutJKLl45QvWf9bHJpGVcd5j6e?= =?us-ascii?Q?2TGLpVYpYftuY5UNGmXEQILscT51texZ6flBQqjNKW5nTqUBANCqntU5UVyg?= =?us-ascii?Q?tpWyITyYo5jpeSQb5b4YfLoDAuW9xe3UTNUnJBok1F6calEbBKQXi49a7txM?= =?us-ascii?Q?iaG8WDGW/Gi/VabSDfKg3uurRCxDtWkFFHE4ui9OU/gTGd4HDkrddsjG9Krd?= =?us-ascii?Q?wLPM1ucfGoSNM11cvM14O01sBhR3FE2zWwbI1CFiUMSjn3tV3y0yigBUhZl9?= =?us-ascii?Q?AbCUJW+ugKZc9io25nS4MOu11B1OQFvNrLjezDYRETNUc7HCKTumdAAC+1mL?= =?us-ascii?Q?aoCkdXmiB2umuegFeu02FQUGnXVhOTjMe4ciJ5cch/+ayCH3aST6sTQ5gEH6?= =?us-ascii?Q?qxbiGOfdbbPAFErpBPqS0avG6kmgZw3PBjm5BfyIAr0kTy/3NYPotFj2HroW?= =?us-ascii?Q?zBffRiJdNb83CTOE7nIKlAd/uv30zbUZDgdpN5MRubY0SWTu7cVMINhO8l+L?= =?us-ascii?Q?h1gzZD433gB0YhLSnYquMDivva9TdivQIHGJmCR98DZ3HKqiSL3kcbGxlDGL?= =?us-ascii?Q?kKS6IJfbM1zk6RcjEILlogZtlJHBkPrCMCrSkiIHwaFrDc12JLmDR2RpvY9w?= =?us-ascii?Q?DSmcPZS8JUWtFS8KJ+kMbcyNyjQOd1oUekR5IWj2eSVqYAT4AcIez3dLwxTm?= =?us-ascii?Q?z1qiKTXeySU8+e3I3ChkR0PdJZCgKlnPu11c0cvS0+Nxha7lzs3f1zjE9DOL?= =?us-ascii?Q?RI4ft2aiQ330/D87WteAenAvc5UUhEMuzvW4quEtg7LxhYwDZV9l2+yU1vR8?= =?us-ascii?Q?y0xHrtcYs/Mx+yaWb47Qs0GGmB0NHl4P4w7zYuyZiqCWK2NI2fGhXUeo//6q?= =?us-ascii?Q?4CdFmpfxWFWUmCo5maM6UPIUvhxaInu3gQ5kTdNc8LjLfekMuH12DkIlvgXC?= =?us-ascii?Q?bTlKEIBLuNT6UE=3D?= X-Microsoft-Exchange-Diagnostics: 1; CY1PR12MB0151; 6:V9s23GPXRMhQTIedPeD2okSdZzqxbB3SCFcFbFNn5N/5j6PR1MEXP2jkeKYa8SPO1hQbqeMFxKY1LqrfBcHCysacMVV715FLtozbtS0/0dZywcVfm/4GMV7uN1h/oQ+vDGXsFM9QGz+4rO+ErVIKQcFkH7UvDjWgmX9ewK/4oG7jAdCjrWkFL6IskvR4ICAISSbTOFQrPDqJHgqfRz95+3RiY8g6/LpjTD4R2uyWYlSS/xepZB26LMT2qBVgtNZrF9JkF/fvWjpGh8o+gCShhI/uEyV03Mk1TEgoPB0eIsIf6iqYxih5cZa6Upe5JMZKRYLPotWMJ08lRoCG0yozrpjUBlf/qvugtOWTssNav2w=; 5:fIf2hjSbt4rRCbxq4o44EaPLFkzMAckSpFLeKX0dx8T+Tu+dePJu9p1vMOH2JgHzaZ79bC7ZFvfO64VDBRCg8OLMNAaKNn/781dxi2+0dNm7klMQ6McdKx0jyuEqS0GozJA8I8DunVDi29GgPDEhPNcqy/IteFq2PbKfb6jbxX8=; 24:1YpJDTVLdZGUqVt0ECLYhD10XmmTHG7rsTcRIUzoGYo2y8n8Egl55NGu/aAO0EIrJrjpUoy/wxijNFwQHD9Y9QqiNKJHovvwXfFFHPaF/gc=; 7:dqlIfs4AsELybfTBmdHjxFypXnOfr8gDQpsbs5rlmsDqP89qj0FJVZl+m4bgTUtfMhv+Oigjyc9mjS1tGKOqasZVgthcGht7Xb6gCUP3ngzdD/EY2ty8HeyxIgXQL4u9ZdOyjmi8q/qyjyZyrF+yVNnDVMo+EyXs/2TNJnoja2OGUVevJginmb1Ekea+U3VOeiex6dGleu+T4simsyEWY8XNj+3BYd+/ewdH/kzvFzuiDuEKYnnT8k0F4nB8aMrQ SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; CY1PR12MB0151; 20:JLy/vBWqJk0J2Fj2BapbuMvgF1eHsBqcA/IDRygnaK3FCzY1X3OiulTyOHZPYH1BsZzSkjOfeignSdj1aWq8038qfTq1/k1hgSr0YNXMSHBbFTfgTHV9ZWNvC3q6U5vPPtIOB2b996DxJwshg3ikghNANrQyaqh9ONlfDfKQis8HvaWMpRdUkp/SEefKVNYtMayRO27FCbDq4e829CkaICoqihHGbSUPA8qK8EhwGVeWmlu7Zyn1f7rUQIk70ai5 X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 04 Jan 2018 17:06:24.0684 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 69b63ade-0601-4fa7-97af-08d553957ca3 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 3dd8961f-e488-4e60-8e11-a82d994e183d X-MS-Exchange-Transport-CrossTenantHeadersStamped: CY1PR12MB0151 Subject: [PATCH] OvmfPkg/BaseMemEncryptSevLib: Enable protection for newly added page table X-BeenThere: edk2-devel@lists.01.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: EDK II Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 04 Jan 2018 17:01:23 -0000 Content-Type: text/plain Commit 2ac1730bf2a5 (MdeModulePkg/DxeIpl: Mark page table as read-only) sets the memory pages used for page table as read-only after paging is setup and sets CR0.WP to protect CPU modifying the read-only pages. The commit causes #PF when MemEncryptSevClearPageEncMask() or MemEncryptSevSetPageEncMask() tries to change the page-table attributes. This patch takes the similar approach as Commit 147fd35c3e38 (UefiCpuPkg/CpuDxe: Enable protection for newly added page table). When page table protection is enabled, we disable it temporarily before changing the page table attributes. This patch makes use of the same approach as Commit 2ac1730bf2a5 (MdeModulePkg/DxeIpl: Mark page table as read-only)) for allocating page table memory from reserved memory pool, which helps to reduce a potential "split" operation. Cc: Jian J Wang Cc: Jiewen Yao Cc: Jordan Justen Cc: Laszlo Ersek Signed-off-by: Brijesh Singh --- OvmfPkg/Library/BaseMemEncryptSevLib/X64/VirtualMemory.h | 28 ++ OvmfPkg/Library/BaseMemEncryptSevLib/X64/VirtualMemory.c | 378 +++++++++++++++++++- 2 files changed, 399 insertions(+), 7 deletions(-) diff --git a/OvmfPkg/Library/BaseMemEncryptSevLib/X64/VirtualMemory.h b/OvmfPkg/Library/BaseMemEncryptSevLib/X64/VirtualMemory.h index 70cd2187a326..e7b5634b45c1 100644 --- a/OvmfPkg/Library/BaseMemEncryptSevLib/X64/VirtualMemory.h +++ b/OvmfPkg/Library/BaseMemEncryptSevLib/X64/VirtualMemory.h @@ -128,6 +128,20 @@ typedef union { #define IA32_PG_P BIT0 #define IA32_PG_RW BIT1 +#define IA32_PG_PS BIT7 + +#define PAGING_PAE_INDEX_MASK 0x1FF + +#define PAGING_4K_ADDRESS_MASK_64 0x000FFFFFFFFFF000ull +#define PAGING_2M_ADDRESS_MASK_64 0x000FFFFFFFE00000ull +#define PAGING_1G_ADDRESS_MASK_64 0x000FFFFFC0000000ull + +#define PAGING_L1_ADDRESS_SHIFT 12 +#define PAGING_L2_ADDRESS_SHIFT 21 +#define PAGING_L3_ADDRESS_SHIFT 30 +#define PAGING_L4_ADDRESS_SHIFT 39 + +#define PAGING_PML4E_NUMBER 4 #define PAGETABLE_ENTRY_MASK ((1UL << 9) - 1) #define PML4_OFFSET(x) ( (x >> 39) & PAGETABLE_ENTRY_MASK) @@ -136,6 +150,20 @@ typedef union { #define PTE_OFFSET(x) ( (x >> 12) & PAGETABLE_ENTRY_MASK) #define PAGING_1G_ADDRESS_MASK_64 0x000FFFFFC0000000ull +#define PAGE_TABLE_POOL_ALIGNMENT BASE_2MB +#define PAGE_TABLE_POOL_UNIT_SIZE SIZE_2MB +#define PAGE_TABLE_POOL_UNIT_PAGES EFI_SIZE_TO_PAGES (PAGE_TABLE_POOL_UNIT_SIZE) +#define PAGE_TABLE_POOL_ALIGN_MASK \ + (~(EFI_PHYSICAL_ADDRESS)(PAGE_TABLE_POOL_ALIGNMENT - 1)) + +typedef struct { + VOID *NextPool; + UINTN Offset; + UINTN FreePages; +} PAGE_TABLE_POOL; + + + /** This function clears memory encryption bit for the memory region specified by PhysicalAddress and length from the current page table context. diff --git a/OvmfPkg/Library/BaseMemEncryptSevLib/X64/VirtualMemory.c b/OvmfPkg/Library/BaseMemEncryptSevLib/X64/VirtualMemory.c index e1e705c34626..4185874c99b8 100644 --- a/OvmfPkg/Library/BaseMemEncryptSevLib/X64/VirtualMemory.c +++ b/OvmfPkg/Library/BaseMemEncryptSevLib/X64/VirtualMemory.c @@ -25,6 +25,7 @@ Code is derived from MdeModulePkg/Core/DxeIplPeim/X64/VirtualMemory.c STATIC BOOLEAN mAddressEncMaskChecked = FALSE; STATIC UINT64 mAddressEncMask; +STATIC PAGE_TABLE_POOL *mPageTablePool = NULL; typedef enum { SetCBit, @@ -63,6 +64,123 @@ GetMemEncryptionAddressMask ( } /** + Initialize a buffer pool for page table use only. + + To reduce the potential split operation on page table, the pages reserved for + page table should be allocated in the times of PAGE_TABLE_POOL_UNIT_PAGES and + at the boundary of PAGE_TABLE_POOL_ALIGNMENT. So the page pool is always + initialized with number of pages greater than or equal to the given PoolPages. + + Once the pages in the pool are used up, this method should be called again to + reserve at least another PAGE_TABLE_POOL_UNIT_PAGES. Usually this won't happen + often in practice. + + @param[in] PoolPages The least page number of the pool to be created. + + @retval TRUE The pool is initialized successfully. + @retval FALSE The memory is out of resource. +**/ +STATIC +BOOLEAN +InitializePageTablePool ( + IN UINTN PoolPages + ) +{ + VOID *Buffer; + + // + // Always reserve at least PAGE_TABLE_POOL_UNIT_PAGES, including one page for + // header. + // + PoolPages += 1; // Add one page for header. + PoolPages = ((PoolPages - 1) / PAGE_TABLE_POOL_UNIT_PAGES + 1) * + PAGE_TABLE_POOL_UNIT_PAGES; + Buffer = AllocateAlignedPages (PoolPages, PAGE_TABLE_POOL_ALIGNMENT); + if (Buffer == NULL) { + DEBUG ((DEBUG_ERROR, "ERROR: Out of aligned pages\r\n")); + return FALSE; + } + + // + // Link all pools into a list for easier track later. + // + if (mPageTablePool == NULL) { + mPageTablePool = Buffer; + mPageTablePool->NextPool = mPageTablePool; + } else { + ((PAGE_TABLE_POOL *)Buffer)->NextPool = mPageTablePool->NextPool; + mPageTablePool->NextPool = Buffer; + mPageTablePool = Buffer; + } + + // + // Reserve one page for pool header. + // + mPageTablePool->FreePages = PoolPages - 1; + mPageTablePool->Offset = EFI_PAGES_TO_SIZE (1); + + return TRUE; +} + +/** + This API provides a way to allocate memory for page table. + + This API can be called more than once to allocate memory for page tables. + + Allocates the number of 4KB pages and returns a pointer to the allocated + buffer. The buffer returned is aligned on a 4KB boundary. + + If Pages is 0, then NULL is returned. + If there is not enough memory remaining to satisfy the request, then NULL is + returned. + + @param Pages The number of 4 KB pages to allocate. + + @return A pointer to the allocated buffer or NULL if allocation fails. + +**/ +STATIC +VOID * +EFIAPI +AllocatePageTableMemory ( + IN UINTN Pages + ) +{ + VOID *Buffer; + + if (Pages == 0) { + return NULL; + } + + // + // Renew the pool if necessary. + // + if (mPageTablePool == NULL || + Pages > mPageTablePool->FreePages) { + if (!InitializePageTablePool (Pages)) { + return NULL; + } + } + + Buffer = (UINT8 *)mPageTablePool + mPageTablePool->Offset; + + mPageTablePool->Offset += EFI_PAGES_TO_SIZE (Pages); + mPageTablePool->FreePages -= Pages; + + DEBUG (( + DEBUG_VERBOSE, + "%a:%a: Buffer=0x%Lx Pages=%ld\n", + gEfiCallerBaseName, + __FUNCTION__, + Buffer, + Pages + )); + + return Buffer; +} + + +/** Split 2M page to 4K. @param[in] PhysicalAddress Start physical address the 2M page covered. @@ -85,7 +203,7 @@ Split2MPageTo4K ( PAGE_TABLE_4K_ENTRY *PageTableEntry, *PageTableEntry1; UINT64 AddressEncMask; - PageTableEntry = AllocatePages(1); + PageTableEntry = AllocatePageTableMemory(1); PageTableEntry1 = PageTableEntry; @@ -117,6 +235,179 @@ Split2MPageTo4K ( } /** + Set one page of page table pool memory to be read-only. + + @param[in] PageTableBase Base address of page table (CR3). + @param[in] Address Start address of a page to be set as read-only. + @param[in] Level4Paging Level 4 paging flag. + +**/ +STATIC +VOID +SetPageTablePoolReadOnly ( + IN UINTN PageTableBase, + IN EFI_PHYSICAL_ADDRESS Address, + IN BOOLEAN Level4Paging + ) +{ + UINTN Index; + UINTN EntryIndex; + UINT64 AddressEncMask; + EFI_PHYSICAL_ADDRESS PhysicalAddress; + UINT64 *PageTable; + UINT64 *NewPageTable; + UINT64 PageAttr; + UINT64 LevelSize[5]; + UINT64 LevelMask[5]; + UINTN LevelShift[5]; + UINTN Level; + UINT64 PoolUnitSize; + + ASSERT (PageTableBase != 0); + + // + // Since the page table is always from page table pool, which is always + // located at the boundary of PcdPageTablePoolAlignment, we just need to + // set the whole pool unit to be read-only. + // + Address = Address & PAGE_TABLE_POOL_ALIGN_MASK; + + LevelShift[1] = PAGING_L1_ADDRESS_SHIFT; + LevelShift[2] = PAGING_L2_ADDRESS_SHIFT; + LevelShift[3] = PAGING_L3_ADDRESS_SHIFT; + LevelShift[4] = PAGING_L4_ADDRESS_SHIFT; + + LevelMask[1] = PAGING_4K_ADDRESS_MASK_64; + LevelMask[2] = PAGING_2M_ADDRESS_MASK_64; + LevelMask[3] = PAGING_1G_ADDRESS_MASK_64; + LevelMask[4] = PAGING_1G_ADDRESS_MASK_64; + + LevelSize[1] = SIZE_4KB; + LevelSize[2] = SIZE_2MB; + LevelSize[3] = SIZE_1GB; + LevelSize[4] = SIZE_512GB; + + AddressEncMask = GetMemEncryptionAddressMask() & + PAGING_1G_ADDRESS_MASK_64; + PageTable = (UINT64 *)(UINTN)PageTableBase; + PoolUnitSize = PAGE_TABLE_POOL_UNIT_SIZE; + + for (Level = (Level4Paging) ? 4 : 3; Level > 0; --Level) { + Index = ((UINTN)RShiftU64 (Address, LevelShift[Level])); + Index &= PAGING_PAE_INDEX_MASK; + + PageAttr = PageTable[Index]; + if ((PageAttr & IA32_PG_PS) == 0) { + // + // Go to next level of table. + // + PageTable = (UINT64 *)(UINTN)(PageAttr & ~AddressEncMask & + PAGING_4K_ADDRESS_MASK_64); + continue; + } + + if (PoolUnitSize >= LevelSize[Level]) { + // + // Clear R/W bit if current page granularity is not larger than pool unit + // size. + // + if ((PageAttr & IA32_PG_RW) != 0) { + while (PoolUnitSize > 0) { + // + // PAGE_TABLE_POOL_UNIT_SIZE and PAGE_TABLE_POOL_ALIGNMENT are fit in + // one page (2MB). Then we don't need to update attributes for pages + // crossing page directory. ASSERT below is for that purpose. + // + ASSERT (Index < EFI_PAGE_SIZE/sizeof (UINT64)); + + PageTable[Index] &= ~(UINT64)IA32_PG_RW; + PoolUnitSize -= LevelSize[Level]; + + ++Index; + } + } + + break; + + } else { + // + // The smaller granularity of page must be needed. + // + ASSERT (Level > 1); + + NewPageTable = AllocatePageTableMemory (1); + ASSERT (NewPageTable != NULL); + + PhysicalAddress = PageAttr & LevelMask[Level]; + for (EntryIndex = 0; + EntryIndex < EFI_PAGE_SIZE/sizeof (UINT64); + ++EntryIndex) { + NewPageTable[EntryIndex] = PhysicalAddress | AddressEncMask | + IA32_PG_P | IA32_PG_RW; + if (Level > 2) { + NewPageTable[EntryIndex] |= IA32_PG_PS; + } + PhysicalAddress += LevelSize[Level - 1]; + } + + PageTable[Index] = (UINT64)(UINTN)NewPageTable | AddressEncMask | + IA32_PG_P | IA32_PG_RW; + PageTable = NewPageTable; + } + } +} + +/** + Prevent the memory pages used for page table from been overwritten. + + @param[in] PageTableBase Base address of page table (CR3). + @param[in] Level4Paging Level 4 paging flag. + +**/ +STATIC +VOID +EnablePageTableProtection ( + IN UINTN PageTableBase, + IN BOOLEAN Level4Paging + ) +{ + PAGE_TABLE_POOL *HeadPool; + PAGE_TABLE_POOL *Pool; + UINT64 PoolSize; + EFI_PHYSICAL_ADDRESS Address; + + if (mPageTablePool == NULL) { + return; + } + + // + // SetPageTablePoolReadOnly might update mPageTablePool. It's safer to + // remember original one in advance. + // + HeadPool = mPageTablePool; + Pool = HeadPool; + do { + Address = (EFI_PHYSICAL_ADDRESS)(UINTN)Pool; + PoolSize = Pool->Offset + EFI_PAGES_TO_SIZE (Pool->FreePages); + + // + // The size of one pool must be multiple of PAGE_TABLE_POOL_UNIT_SIZE, which + // is one of page size of the processor (2MB by default). Let's apply the + // protection to them one by one. + // + while (PoolSize > 0) { + SetPageTablePoolReadOnly(PageTableBase, Address, Level4Paging); + Address += PAGE_TABLE_POOL_UNIT_SIZE; + PoolSize -= PAGE_TABLE_POOL_UNIT_SIZE; + } + + Pool = Pool->NextPool; + } while (Pool != HeadPool); + +} + + +/** Split 1G page to 2M. @param[in] PhysicalAddress Start physical address the 1G page covered. @@ -139,7 +430,7 @@ Split1GPageTo2M ( PAGE_TABLE_ENTRY *PageDirectoryEntry; UINT64 AddressEncMask; - PageDirectoryEntry = AllocatePages(1); + PageDirectoryEntry = AllocatePageTableMemory(1); AddressEncMask = GetMemEncryptionAddressMask (); ASSERT (PageDirectoryEntry != NULL); @@ -195,6 +486,47 @@ SetOrClearCBit( } /** + Check the WP status in CR0 register. This bit is used to lock or unlock write + access to pages marked as read-only. + + @retval TRUE Write protection is enabled. + @retval FALSE Write protection is disabled. +**/ +STATIC +BOOLEAN +IsReadOnlyPageWriteProtected ( + VOID + ) +{ + return ((AsmReadCr0 () & BIT16) != 0); +} + + +/** + Disable Write Protect on pages marked as read-only. +**/ +STATIC +VOID +DisableReadOnlyPageWriteProtect ( + VOID + ) +{ + AsmWriteCr0 (AsmReadCr0() & ~BIT16); +} + +/** + Enable Write Protect on pages marked as read-only. +**/ +VOID +EnableReadOnlyPageWriteProtect ( + VOID + ) +{ + AsmWriteCr0 (AsmReadCr0() | BIT16); +} + + +/** This function either sets or clears memory encryption bit for the memory region specified by PhysicalAddress and length from the current page table context. @@ -238,6 +570,8 @@ SetMemoryEncDec ( PAGE_TABLE_4K_ENTRY *PageTableEntry; UINT64 PgTableMask; UINT64 AddressEncMask; + BOOLEAN IsWpEnabled; + RETURN_STATUS Status; DEBUG (( DEBUG_VERBOSE, @@ -274,6 +608,16 @@ SetMemoryEncDec ( WriteBackInvalidateDataCacheRange((VOID*) (UINTN)PhysicalAddress, Length); } + // + // Make sure that the page table is changeable. + // + IsWpEnabled = IsReadOnlyPageWriteProtected (); + if (IsWpEnabled) { + DisableReadOnlyPageWriteProtect (); + } + + Status = EFI_SUCCESS; + while (Length) { // @@ -293,7 +637,8 @@ SetMemoryEncDec ( __FUNCTION__, PhysicalAddress )); - return RETURN_NO_MAPPING; + Status = RETURN_NO_MAPPING; + goto Done; } PageDirectory1GEntry = (VOID*) ((PageMapLevel4Entry->Bits.PageTableBaseAddress<<12) & ~PgTableMask); @@ -306,7 +651,8 @@ SetMemoryEncDec ( __FUNCTION__, PhysicalAddress )); - return RETURN_NO_MAPPING; + Status = RETURN_NO_MAPPING; + goto Done; } // @@ -357,7 +703,8 @@ SetMemoryEncDec ( __FUNCTION__, PhysicalAddress )); - return RETURN_NO_MAPPING; + Status = RETURN_NO_MAPPING; + goto Done; } // // If the MustBe1 bit is not a 1, it's not a 2MB entry @@ -397,7 +744,8 @@ SetMemoryEncDec ( __FUNCTION__, PhysicalAddress )); - return RETURN_NO_MAPPING; + Status = RETURN_NO_MAPPING; + goto Done; } SetOrClearCBit (&PageTableEntry->Uint64, Mode); PhysicalAddress += EFI_PAGE_SIZE; @@ -407,11 +755,27 @@ SetMemoryEncDec ( } // + // Protect the page table by marking the memory used for page table to be + // read-only. + // + if (IsWpEnabled) { + EnablePageTableProtection ((UINTN)PageMapLevel4Entry, TRUE); + } + + // // Flush TLB // CpuFlushTlb(); - return RETURN_SUCCESS; +Done: + // + // Restore page table write protection, if any. + // + if (IsWpEnabled) { + EnableReadOnlyPageWriteProtect (); + } + + return Status; } /** -- 2.9.5