1 /* 2 * SGX common code 3 * 4 * Copyright (C) 2021 Intel Corporation 5 * 6 * Authors: 7 * Yang Zhong<yang.zhong@intel.com> 8 * Sean Christopherson <sean.j.christopherson@intel.com> 9 * 10 * This work is licensed under the terms of the GNU GPL, version 2 or later. 11 * See the COPYING file in the top-level directory. 12 */ 13 #include "qemu/osdep.h" 14 #include "hw/i386/pc.h" 15 #include "hw/i386/sgx-epc.h" 16 #include "hw/mem/memory-device.h" 17 #include "monitor/qdev.h" 18 #include "monitor/monitor.h" 19 #include "monitor/hmp-target.h" 20 #include "qapi/error.h" 21 #include "qapi/qapi-commands-misc-target.h" 22 #include "exec/address-spaces.h" 23 #include "sysemu/hw_accel.h" 24 #include "sysemu/reset.h" 25 #include <sys/ioctl.h> 26 #include "hw/acpi/aml-build.h" 27 28 #define SGX_MAX_EPC_SECTIONS 8 29 #define SGX_CPUID_EPC_INVALID 0x0 30 31 /* A valid EPC section. */ 32 #define SGX_CPUID_EPC_SECTION 0x1 33 #define SGX_CPUID_EPC_MASK 0xF 34 35 #define SGX_MAGIC 0xA4 36 #define SGX_IOC_VEPC_REMOVE_ALL _IO(SGX_MAGIC, 0x04) 37 38 #define RETRY_NUM 2 39 40 static int sgx_epc_device_list(Object *obj, void *opaque) 41 { 42 GSList **list = opaque; 43 44 if (object_dynamic_cast(obj, TYPE_SGX_EPC)) { 45 *list = g_slist_append(*list, DEVICE(obj)); 46 } 47 48 object_child_foreach(obj, sgx_epc_device_list, opaque); 49 return 0; 50 } 51 52 static GSList *sgx_epc_get_device_list(void) 53 { 54 GSList *list = NULL; 55 56 object_child_foreach(qdev_get_machine(), sgx_epc_device_list, &list); 57 return list; 58 } 59 60 void sgx_epc_build_srat(GArray *table_data) 61 { 62 GSList *device_list = sgx_epc_get_device_list(); 63 64 for (; device_list; device_list = device_list->next) { 65 DeviceState *dev = device_list->data; 66 Object *obj = OBJECT(dev); 67 uint64_t addr, size; 68 int node; 69 70 node = object_property_get_uint(obj, SGX_EPC_NUMA_NODE_PROP, 71 &error_abort); 72 addr = object_property_get_uint(obj, SGX_EPC_ADDR_PROP, &error_abort); 73 size = object_property_get_uint(obj, SGX_EPC_SIZE_PROP, &error_abort); 74 75 build_srat_memory(table_data, addr, size, node, MEM_AFFINITY_ENABLED); 76 } 77 g_slist_free(device_list); 78 } 79 80 static uint64_t sgx_calc_section_metric(uint64_t low, uint64_t high) 81 { 82 return (low & MAKE_64BIT_MASK(12, 20)) + 83 ((high & MAKE_64BIT_MASK(0, 20)) << 32); 84 } 85 86 static SGXEPCSectionList *sgx_calc_host_epc_sections(uint64_t *size) 87 { 88 SGXEPCSectionList *head = NULL, **tail = &head; 89 SGXEPCSection *section; 90 uint32_t i, type; 91 uint32_t eax, ebx, ecx, edx; 92 uint32_t j = 0; 93 94 for (i = 0; i < SGX_MAX_EPC_SECTIONS; i++) { 95 host_cpuid(0x12, i + 2, &eax, &ebx, &ecx, &edx); 96 97 type = eax & SGX_CPUID_EPC_MASK; 98 if (type == SGX_CPUID_EPC_INVALID) { 99 break; 100 } 101 102 if (type != SGX_CPUID_EPC_SECTION) { 103 break; 104 } 105 106 section = g_new0(SGXEPCSection, 1); 107 section->node = j++; 108 section->size = sgx_calc_section_metric(ecx, edx); 109 *size += section->size; 110 QAPI_LIST_APPEND(tail, section); 111 } 112 113 return head; 114 } 115 116 static void sgx_epc_reset(void *opaque) 117 { 118 PCMachineState *pcms = PC_MACHINE(qdev_get_machine()); 119 HostMemoryBackend *hostmem; 120 SGXEPCDevice *epc; 121 int failures; 122 int fd, i, j, r; 123 static bool warned = false; 124 125 /* 126 * The second pass is needed to remove SECS pages that could not 127 * be removed during the first. 128 */ 129 for (i = 0; i < RETRY_NUM; i++) { 130 failures = 0; 131 for (j = 0; j < pcms->sgx_epc.nr_sections; j++) { 132 epc = pcms->sgx_epc.sections[j]; 133 hostmem = MEMORY_BACKEND(epc->hostmem); 134 fd = memory_region_get_fd(host_memory_backend_get_memory(hostmem)); 135 136 r = ioctl(fd, SGX_IOC_VEPC_REMOVE_ALL); 137 if (r == -ENOTTY && !warned) { 138 warned = true; 139 warn_report("kernel does not support SGX_IOC_VEPC_REMOVE_ALL"); 140 warn_report("SGX might operate incorrectly in the guest after reset"); 141 break; 142 } else if (r > 0) { 143 /* SECS pages remain */ 144 failures++; 145 if (i == 1) { 146 error_report("cannot reset vEPC section %d", j); 147 } 148 } 149 } 150 if (!failures) { 151 break; 152 } 153 } 154 } 155 156 SGXInfo *qmp_query_sgx_capabilities(Error **errp) 157 { 158 SGXInfo *info = NULL; 159 uint32_t eax, ebx, ecx, edx; 160 uint64_t size = 0; 161 162 int fd = qemu_open_old("/dev/sgx_vepc", O_RDWR); 163 if (fd < 0) { 164 error_setg(errp, "SGX is not enabled in KVM"); 165 return NULL; 166 } 167 168 info = g_new0(SGXInfo, 1); 169 host_cpuid(0x7, 0, &eax, &ebx, &ecx, &edx); 170 171 info->sgx = ebx & (1U << 2) ? true : false; 172 info->flc = ecx & (1U << 30) ? true : false; 173 174 host_cpuid(0x12, 0, &eax, &ebx, &ecx, &edx); 175 info->sgx1 = eax & (1U << 0) ? true : false; 176 info->sgx2 = eax & (1U << 1) ? true : false; 177 178 info->sections = sgx_calc_host_epc_sections(&size); 179 info->section_size = size; 180 181 close(fd); 182 183 return info; 184 } 185 186 static SGXEPCSectionList *sgx_get_epc_sections_list(void) 187 { 188 GSList *device_list = sgx_epc_get_device_list(); 189 SGXEPCSectionList *head = NULL, **tail = &head; 190 SGXEPCSection *section; 191 192 for (; device_list; device_list = device_list->next) { 193 DeviceState *dev = device_list->data; 194 Object *obj = OBJECT(dev); 195 196 section = g_new0(SGXEPCSection, 1); 197 section->node = object_property_get_uint(obj, SGX_EPC_NUMA_NODE_PROP, 198 &error_abort); 199 section->size = object_property_get_uint(obj, SGX_EPC_SIZE_PROP, 200 &error_abort); 201 QAPI_LIST_APPEND(tail, section); 202 } 203 g_slist_free(device_list); 204 205 return head; 206 } 207 208 SGXInfo *qmp_query_sgx(Error **errp) 209 { 210 SGXInfo *info = NULL; 211 X86MachineState *x86ms; 212 PCMachineState *pcms = 213 (PCMachineState *)object_dynamic_cast(qdev_get_machine(), 214 TYPE_PC_MACHINE); 215 if (!pcms) { 216 error_setg(errp, "SGX is only supported on PC machines"); 217 return NULL; 218 } 219 220 x86ms = X86_MACHINE(pcms); 221 if (!x86ms->sgx_epc_list) { 222 error_setg(errp, "No EPC regions defined, SGX not available"); 223 return NULL; 224 } 225 226 SGXEPCState *sgx_epc = &pcms->sgx_epc; 227 info = g_new0(SGXInfo, 1); 228 229 info->sgx = true; 230 info->sgx1 = true; 231 info->sgx2 = true; 232 info->flc = true; 233 info->section_size = sgx_epc->size; 234 info->sections = sgx_get_epc_sections_list(); 235 236 return info; 237 } 238 239 void hmp_info_sgx(Monitor *mon, const QDict *qdict) 240 { 241 Error *err = NULL; 242 SGXEPCSectionList *section_list, *section; 243 g_autoptr(SGXInfo) info = qmp_query_sgx(&err); 244 245 if (err) { 246 error_report_err(err); 247 return; 248 } 249 monitor_printf(mon, "SGX support: %s\n", 250 info->sgx ? "enabled" : "disabled"); 251 monitor_printf(mon, "SGX1 support: %s\n", 252 info->sgx1 ? "enabled" : "disabled"); 253 monitor_printf(mon, "SGX2 support: %s\n", 254 info->sgx2 ? "enabled" : "disabled"); 255 monitor_printf(mon, "FLC support: %s\n", 256 info->flc ? "enabled" : "disabled"); 257 monitor_printf(mon, "size: %" PRIu64 "\n", 258 info->section_size); 259 260 section_list = info->sections; 261 for (section = section_list; section; section = section->next) { 262 monitor_printf(mon, "NUMA node #%" PRId64 ": ", 263 section->value->node); 264 monitor_printf(mon, "size=%" PRIu64 "\n", 265 section->value->size); 266 } 267 } 268 269 bool sgx_epc_get_section(int section_nr, uint64_t *addr, uint64_t *size) 270 { 271 PCMachineState *pcms = PC_MACHINE(qdev_get_machine()); 272 SGXEPCDevice *epc; 273 274 if (pcms->sgx_epc.size == 0 || pcms->sgx_epc.nr_sections <= section_nr) { 275 return true; 276 } 277 278 epc = pcms->sgx_epc.sections[section_nr]; 279 280 *addr = epc->addr; 281 *size = memory_device_get_region_size(MEMORY_DEVICE(epc), &error_fatal); 282 283 return false; 284 } 285 286 void pc_machine_init_sgx_epc(PCMachineState *pcms) 287 { 288 SGXEPCState *sgx_epc = &pcms->sgx_epc; 289 X86MachineState *x86ms = X86_MACHINE(pcms); 290 SgxEPCList *list = NULL; 291 Object *obj; 292 293 memset(sgx_epc, 0, sizeof(SGXEPCState)); 294 if (!x86ms->sgx_epc_list) { 295 return; 296 } 297 298 sgx_epc->base = 0x100000000ULL + x86ms->above_4g_mem_size; 299 300 memory_region_init(&sgx_epc->mr, OBJECT(pcms), "sgx-epc", UINT64_MAX); 301 memory_region_add_subregion(get_system_memory(), sgx_epc->base, 302 &sgx_epc->mr); 303 304 for (list = x86ms->sgx_epc_list; list; list = list->next) { 305 obj = object_new("sgx-epc"); 306 307 /* set the memdev link with memory backend */ 308 object_property_parse(obj, SGX_EPC_MEMDEV_PROP, list->value->memdev, 309 &error_fatal); 310 /* set the numa node property for sgx epc object */ 311 object_property_set_uint(obj, SGX_EPC_NUMA_NODE_PROP, list->value->node, 312 &error_fatal); 313 object_property_set_bool(obj, "realized", true, &error_fatal); 314 object_unref(obj); 315 } 316 317 if ((sgx_epc->base + sgx_epc->size) < sgx_epc->base) { 318 error_report("Size of all 'sgx-epc' =0x%"PRIx64" causes EPC to wrap", 319 sgx_epc->size); 320 exit(EXIT_FAILURE); 321 } 322 323 memory_region_set_size(&sgx_epc->mr, sgx_epc->size); 324 325 /* register the reset callback for sgx epc */ 326 qemu_register_reset(sgx_epc_reset, NULL); 327 } 328