1 /* 2 * Copyright (C) 2016 Linaro Ltd; <ard.biesheuvel@linaro.org> 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License version 2 as 6 * published by the Free Software Foundation. 7 * 8 */ 9 10 #include <linux/efi.h> 11 #include <asm/efi.h> 12 13 #include "efistub.h" 14 15 struct efi_rng_protocol { 16 efi_status_t (*get_info)(struct efi_rng_protocol *, 17 unsigned long *, efi_guid_t *); 18 efi_status_t (*get_rng)(struct efi_rng_protocol *, 19 efi_guid_t *, unsigned long, u8 *out); 20 }; 21 22 efi_status_t efi_get_random_bytes(efi_system_table_t *sys_table_arg, 23 unsigned long size, u8 *out) 24 { 25 efi_guid_t rng_proto = EFI_RNG_PROTOCOL_GUID; 26 efi_status_t status; 27 struct efi_rng_protocol *rng; 28 29 status = efi_call_early(locate_protocol, &rng_proto, NULL, 30 (void **)&rng); 31 if (status != EFI_SUCCESS) 32 return status; 33 34 return rng->get_rng(rng, NULL, size, out); 35 } 36 37 /* 38 * Return the number of slots covered by this entry, i.e., the number of 39 * addresses it covers that are suitably aligned and supply enough room 40 * for the allocation. 41 */ 42 static unsigned long get_entry_num_slots(efi_memory_desc_t *md, 43 unsigned long size, 44 unsigned long align) 45 { 46 u64 start, end; 47 48 if (md->type != EFI_CONVENTIONAL_MEMORY) 49 return 0; 50 51 start = round_up(md->phys_addr, align); 52 end = round_down(md->phys_addr + md->num_pages * EFI_PAGE_SIZE - size, 53 align); 54 55 if (start > end) 56 return 0; 57 58 return (end - start + 1) / align; 59 } 60 61 /* 62 * The UEFI memory descriptors have a virtual address field that is only used 63 * when installing the virtual mapping using SetVirtualAddressMap(). Since it 64 * is unused here, we can reuse it to keep track of each descriptor's slot 65 * count. 66 */ 67 #define MD_NUM_SLOTS(md) ((md)->virt_addr) 68 69 efi_status_t efi_random_alloc(efi_system_table_t *sys_table_arg, 70 unsigned long size, 71 unsigned long align, 72 unsigned long *addr, 73 unsigned long random_seed) 74 { 75 unsigned long map_size, desc_size, total_slots = 0, target_slot; 76 efi_status_t status; 77 efi_memory_desc_t *memory_map; 78 int map_offset; 79 80 status = efi_get_memory_map(sys_table_arg, &memory_map, &map_size, 81 &desc_size, NULL, NULL); 82 if (status != EFI_SUCCESS) 83 return status; 84 85 if (align < EFI_ALLOC_ALIGN) 86 align = EFI_ALLOC_ALIGN; 87 88 /* count the suitable slots in each memory map entry */ 89 for (map_offset = 0; map_offset < map_size; map_offset += desc_size) { 90 efi_memory_desc_t *md = (void *)memory_map + map_offset; 91 unsigned long slots; 92 93 slots = get_entry_num_slots(md, size, align); 94 MD_NUM_SLOTS(md) = slots; 95 total_slots += slots; 96 } 97 98 /* find a random number between 0 and total_slots */ 99 target_slot = (total_slots * (u16)random_seed) >> 16; 100 101 /* 102 * target_slot is now a value in the range [0, total_slots), and so 103 * it corresponds with exactly one of the suitable slots we recorded 104 * when iterating over the memory map the first time around. 105 * 106 * So iterate over the memory map again, subtracting the number of 107 * slots of each entry at each iteration, until we have found the entry 108 * that covers our chosen slot. Use the residual value of target_slot 109 * to calculate the randomly chosen address, and allocate it directly 110 * using EFI_ALLOCATE_ADDRESS. 111 */ 112 for (map_offset = 0; map_offset < map_size; map_offset += desc_size) { 113 efi_memory_desc_t *md = (void *)memory_map + map_offset; 114 efi_physical_addr_t target; 115 unsigned long pages; 116 117 if (target_slot >= MD_NUM_SLOTS(md)) { 118 target_slot -= MD_NUM_SLOTS(md); 119 continue; 120 } 121 122 target = round_up(md->phys_addr, align) + target_slot * align; 123 pages = round_up(size, EFI_PAGE_SIZE) / EFI_PAGE_SIZE; 124 125 status = efi_call_early(allocate_pages, EFI_ALLOCATE_ADDRESS, 126 EFI_LOADER_DATA, pages, &target); 127 if (status == EFI_SUCCESS) 128 *addr = target; 129 break; 130 } 131 132 efi_call_early(free_pool, memory_map); 133 134 return status; 135 } 136