1aa04b4ccSPaul Mackerras /* 2aa04b4ccSPaul Mackerras * Copyright 2011 Paul Mackerras, IBM Corp. <paulus@au1.ibm.com> 3aa04b4ccSPaul Mackerras * 4aa04b4ccSPaul Mackerras * This program is free software; you can redistribute it and/or modify 5aa04b4ccSPaul Mackerras * it under the terms of the GNU General Public License, version 2, as 6aa04b4ccSPaul Mackerras * published by the Free Software Foundation. 7aa04b4ccSPaul Mackerras */ 8aa04b4ccSPaul Mackerras 9aa04b4ccSPaul Mackerras #include <linux/kvm_host.h> 10aa04b4ccSPaul Mackerras #include <linux/preempt.h> 1166b15db6SPaul Gortmaker #include <linux/export.h> 12aa04b4ccSPaul Mackerras #include <linux/sched.h> 13aa04b4ccSPaul Mackerras #include <linux/spinlock.h> 14aa04b4ccSPaul Mackerras #include <linux/bootmem.h> 15aa04b4ccSPaul Mackerras #include <linux/init.h> 16fa61a4e3SAneesh Kumar K.V #include <linux/memblock.h> 17fa61a4e3SAneesh Kumar K.V #include <linux/sizes.h> 18aa04b4ccSPaul Mackerras 19aa04b4ccSPaul Mackerras #include <asm/cputable.h> 20aa04b4ccSPaul Mackerras #include <asm/kvm_ppc.h> 21aa04b4ccSPaul Mackerras #include <asm/kvm_book3s.h> 22aa04b4ccSPaul Mackerras 23fa61a4e3SAneesh Kumar K.V #include "book3s_hv_cma.h" 24fa61a4e3SAneesh Kumar K.V 25b4e70611SAlexander Graf #define KVM_LINEAR_RMA 0 26d2a1b483SAlexander Graf #define KVM_LINEAR_HPT 1 27b4e70611SAlexander Graf 28b4e70611SAlexander Graf static void __init kvm_linear_init_one(ulong size, int count, int type); 29b4e70611SAlexander Graf static struct kvmppc_linear_info *kvm_alloc_linear(int type); 30b4e70611SAlexander Graf static void kvm_release_linear(struct kvmppc_linear_info *ri); 31fa61a4e3SAneesh Kumar K.V /* 32fa61a4e3SAneesh Kumar K.V * Hash page table alignment on newer cpus(CPU_FTR_ARCH_206) 33fa61a4e3SAneesh Kumar K.V * should be power of 2. 34fa61a4e3SAneesh Kumar K.V */ 35fa61a4e3SAneesh Kumar K.V #define HPT_ALIGN_PAGES ((1 << 18) >> PAGE_SHIFT) /* 256k */ 36fa61a4e3SAneesh Kumar K.V /* 37fa61a4e3SAneesh Kumar K.V * By default we reserve 5% of memory for hash pagetable allocation. 38fa61a4e3SAneesh Kumar K.V */ 39fa61a4e3SAneesh Kumar K.V static unsigned long kvm_cma_resv_ratio = 5; 4032fad281SPaul Mackerras 41b4e70611SAlexander Graf /*************** RMA *************/ 42b4e70611SAlexander Graf 43aa04b4ccSPaul Mackerras /* 44aa04b4ccSPaul Mackerras * This maintains a list of RMAs (real mode areas) for KVM guests to use. 45aa04b4ccSPaul Mackerras * Each RMA has to be physically contiguous and of a size that the 46aa04b4ccSPaul Mackerras * hardware supports. PPC970 and POWER7 support 64MB, 128MB and 256MB, 47aa04b4ccSPaul Mackerras * and other larger sizes. Since we are unlikely to be allocate that 48aa04b4ccSPaul Mackerras * much physically contiguous memory after the system is up and running, 49aa04b4ccSPaul Mackerras * we preallocate a set of RMAs in early boot for KVM to use. 50aa04b4ccSPaul Mackerras */ 51aa04b4ccSPaul Mackerras static unsigned long kvm_rma_size = 64 << 20; /* 64MB */ 52aa04b4ccSPaul Mackerras static unsigned long kvm_rma_count; 53aa04b4ccSPaul Mackerras 54aa04b4ccSPaul Mackerras /* Work out RMLS (real mode limit selector) field value for a given RMA size. 559e368f29SPaul Mackerras Assumes POWER7 or PPC970. */ 56aa04b4ccSPaul Mackerras static inline int lpcr_rmls(unsigned long rma_size) 57aa04b4ccSPaul Mackerras { 58aa04b4ccSPaul Mackerras switch (rma_size) { 59aa04b4ccSPaul Mackerras case 32ul << 20: /* 32 MB */ 609e368f29SPaul Mackerras if (cpu_has_feature(CPU_FTR_ARCH_206)) 619e368f29SPaul Mackerras return 8; /* only supported on POWER7 */ 629e368f29SPaul Mackerras return -1; 63aa04b4ccSPaul Mackerras case 64ul << 20: /* 64 MB */ 64aa04b4ccSPaul Mackerras return 3; 65aa04b4ccSPaul Mackerras case 128ul << 20: /* 128 MB */ 66aa04b4ccSPaul Mackerras return 7; 67aa04b4ccSPaul Mackerras case 256ul << 20: /* 256 MB */ 68aa04b4ccSPaul Mackerras return 4; 69aa04b4ccSPaul Mackerras case 1ul << 30: /* 1 GB */ 70aa04b4ccSPaul Mackerras return 2; 71aa04b4ccSPaul Mackerras case 16ul << 30: /* 16 GB */ 72aa04b4ccSPaul Mackerras return 1; 73aa04b4ccSPaul Mackerras case 256ul << 30: /* 256 GB */ 74aa04b4ccSPaul Mackerras return 0; 75aa04b4ccSPaul Mackerras default: 76aa04b4ccSPaul Mackerras return -1; 77aa04b4ccSPaul Mackerras } 78aa04b4ccSPaul Mackerras } 79aa04b4ccSPaul Mackerras 80b4e70611SAlexander Graf static int __init early_parse_rma_size(char *p) 81b4e70611SAlexander Graf { 82b4e70611SAlexander Graf if (!p) 83b4e70611SAlexander Graf return 1; 84b4e70611SAlexander Graf 85b4e70611SAlexander Graf kvm_rma_size = memparse(p, &p); 86b4e70611SAlexander Graf 87b4e70611SAlexander Graf return 0; 88b4e70611SAlexander Graf } 89b4e70611SAlexander Graf early_param("kvm_rma_size", early_parse_rma_size); 90b4e70611SAlexander Graf 91b4e70611SAlexander Graf static int __init early_parse_rma_count(char *p) 92b4e70611SAlexander Graf { 93b4e70611SAlexander Graf if (!p) 94b4e70611SAlexander Graf return 1; 95b4e70611SAlexander Graf 96b4e70611SAlexander Graf kvm_rma_count = simple_strtoul(p, NULL, 0); 97b4e70611SAlexander Graf 98b4e70611SAlexander Graf return 0; 99b4e70611SAlexander Graf } 100b4e70611SAlexander Graf early_param("kvm_rma_count", early_parse_rma_count); 101b4e70611SAlexander Graf 102b4e70611SAlexander Graf struct kvmppc_linear_info *kvm_alloc_rma(void) 103b4e70611SAlexander Graf { 104b4e70611SAlexander Graf return kvm_alloc_linear(KVM_LINEAR_RMA); 105b4e70611SAlexander Graf } 106b4e70611SAlexander Graf EXPORT_SYMBOL_GPL(kvm_alloc_rma); 107b4e70611SAlexander Graf 108b4e70611SAlexander Graf void kvm_release_rma(struct kvmppc_linear_info *ri) 109b4e70611SAlexander Graf { 110b4e70611SAlexander Graf kvm_release_linear(ri); 111b4e70611SAlexander Graf } 112b4e70611SAlexander Graf EXPORT_SYMBOL_GPL(kvm_release_rma); 113b4e70611SAlexander Graf 114fa61a4e3SAneesh Kumar K.V static int __init early_parse_kvm_cma_resv(char *p) 115d2a1b483SAlexander Graf { 116fa61a4e3SAneesh Kumar K.V pr_debug("%s(%s)\n", __func__, p); 117d2a1b483SAlexander Graf if (!p) 118fa61a4e3SAneesh Kumar K.V return -EINVAL; 119fa61a4e3SAneesh Kumar K.V return kstrtoul(p, 0, &kvm_cma_resv_ratio); 120d2a1b483SAlexander Graf } 121fa61a4e3SAneesh Kumar K.V early_param("kvm_cma_resv_ratio", early_parse_kvm_cma_resv); 122d2a1b483SAlexander Graf 123fa61a4e3SAneesh Kumar K.V struct page *kvm_alloc_hpt(unsigned long nr_pages) 124d2a1b483SAlexander Graf { 125fa61a4e3SAneesh Kumar K.V unsigned long align_pages = HPT_ALIGN_PAGES; 126fa61a4e3SAneesh Kumar K.V 127fa61a4e3SAneesh Kumar K.V /* Old CPUs require HPT aligned on a multiple of its size */ 128fa61a4e3SAneesh Kumar K.V if (!cpu_has_feature(CPU_FTR_ARCH_206)) 129fa61a4e3SAneesh Kumar K.V align_pages = nr_pages; 130fa61a4e3SAneesh Kumar K.V return kvm_alloc_cma(nr_pages, align_pages); 131d2a1b483SAlexander Graf } 132d2a1b483SAlexander Graf EXPORT_SYMBOL_GPL(kvm_alloc_hpt); 133d2a1b483SAlexander Graf 134fa61a4e3SAneesh Kumar K.V void kvm_release_hpt(struct page *page, unsigned long nr_pages) 135d2a1b483SAlexander Graf { 136fa61a4e3SAneesh Kumar K.V kvm_release_cma(page, nr_pages); 137d2a1b483SAlexander Graf } 138d2a1b483SAlexander Graf EXPORT_SYMBOL_GPL(kvm_release_hpt); 139d2a1b483SAlexander Graf 140b4e70611SAlexander Graf /*************** generic *************/ 141b4e70611SAlexander Graf 142b4e70611SAlexander Graf static LIST_HEAD(free_linears); 143b4e70611SAlexander Graf static DEFINE_SPINLOCK(linear_lock); 144b4e70611SAlexander Graf 145b4e70611SAlexander Graf static void __init kvm_linear_init_one(ulong size, int count, int type) 146aa04b4ccSPaul Mackerras { 147aa04b4ccSPaul Mackerras unsigned long i; 148aa04b4ccSPaul Mackerras unsigned long j, npages; 149b4e70611SAlexander Graf void *linear; 150aa04b4ccSPaul Mackerras struct page *pg; 151b4e70611SAlexander Graf const char *typestr; 152b4e70611SAlexander Graf struct kvmppc_linear_info *linear_info; 153aa04b4ccSPaul Mackerras 154b4e70611SAlexander Graf if (!count) 155b4e70611SAlexander Graf return; 156b4e70611SAlexander Graf 157d2a1b483SAlexander Graf typestr = (type == KVM_LINEAR_RMA) ? "RMA" : "HPT"; 158b4e70611SAlexander Graf 159b4e70611SAlexander Graf npages = size >> PAGE_SHIFT; 160b4e70611SAlexander Graf linear_info = alloc_bootmem(count * sizeof(struct kvmppc_linear_info)); 161b4e70611SAlexander Graf for (i = 0; i < count; ++i) { 162b4e70611SAlexander Graf linear = alloc_bootmem_align(size, size); 1631340f3e8SPaul Mackerras pr_debug("Allocated KVM %s at %p (%ld MB)\n", typestr, linear, 164b4e70611SAlexander Graf size >> 20); 165b4e70611SAlexander Graf linear_info[i].base_virt = linear; 166b4e70611SAlexander Graf linear_info[i].base_pfn = __pa(linear) >> PAGE_SHIFT; 167b4e70611SAlexander Graf linear_info[i].npages = npages; 168b4e70611SAlexander Graf linear_info[i].type = type; 169b4e70611SAlexander Graf list_add_tail(&linear_info[i].list, &free_linears); 170b4e70611SAlexander Graf atomic_set(&linear_info[i].use_count, 0); 171b4e70611SAlexander Graf 172b4e70611SAlexander Graf pg = pfn_to_page(linear_info[i].base_pfn); 173b4e70611SAlexander Graf for (j = 0; j < npages; ++j) { 174b4e70611SAlexander Graf atomic_inc(&pg->_count); 175b4e70611SAlexander Graf ++pg; 176b4e70611SAlexander Graf } 177b4e70611SAlexander Graf } 178b4e70611SAlexander Graf } 179b4e70611SAlexander Graf 180b4e70611SAlexander Graf static struct kvmppc_linear_info *kvm_alloc_linear(int type) 181b4e70611SAlexander Graf { 182b4e51229SPaul Mackerras struct kvmppc_linear_info *ri, *ret; 183b4e70611SAlexander Graf 184b4e51229SPaul Mackerras ret = NULL; 185b4e70611SAlexander Graf spin_lock(&linear_lock); 186b4e70611SAlexander Graf list_for_each_entry(ri, &free_linears, list) { 187b4e70611SAlexander Graf if (ri->type != type) 188b4e70611SAlexander Graf continue; 189b4e70611SAlexander Graf 190b4e70611SAlexander Graf list_del(&ri->list); 191b4e70611SAlexander Graf atomic_inc(&ri->use_count); 192b4e51229SPaul Mackerras memset(ri->base_virt, 0, ri->npages << PAGE_SHIFT); 193b4e51229SPaul Mackerras ret = ri; 194b4e70611SAlexander Graf break; 195b4e70611SAlexander Graf } 196b4e70611SAlexander Graf spin_unlock(&linear_lock); 197b4e51229SPaul Mackerras return ret; 198b4e70611SAlexander Graf } 199b4e70611SAlexander Graf 200b4e70611SAlexander Graf static void kvm_release_linear(struct kvmppc_linear_info *ri) 201b4e70611SAlexander Graf { 202b4e70611SAlexander Graf if (atomic_dec_and_test(&ri->use_count)) { 203b4e70611SAlexander Graf spin_lock(&linear_lock); 204b4e70611SAlexander Graf list_add_tail(&ri->list, &free_linears); 205b4e70611SAlexander Graf spin_unlock(&linear_lock); 206b4e70611SAlexander Graf 207b4e70611SAlexander Graf } 208b4e70611SAlexander Graf } 209b4e70611SAlexander Graf 210b4e70611SAlexander Graf /* 211b4e70611SAlexander Graf * Called at boot time while the bootmem allocator is active, 212b4e70611SAlexander Graf * to allocate contiguous physical memory for the hash page 213b4e70611SAlexander Graf * tables for guests. 214b4e70611SAlexander Graf */ 215b4e70611SAlexander Graf void __init kvm_linear_init(void) 216b4e70611SAlexander Graf { 217b4e70611SAlexander Graf /* RMA */ 2189e368f29SPaul Mackerras /* Only do this on PPC970 in HV mode */ 2199e368f29SPaul Mackerras if (!cpu_has_feature(CPU_FTR_HVMODE) || 2209e368f29SPaul Mackerras !cpu_has_feature(CPU_FTR_ARCH_201)) 221aa04b4ccSPaul Mackerras return; 222aa04b4ccSPaul Mackerras 223aa04b4ccSPaul Mackerras if (!kvm_rma_size || !kvm_rma_count) 224aa04b4ccSPaul Mackerras return; 225aa04b4ccSPaul Mackerras 226aa04b4ccSPaul Mackerras /* Check that the requested size is one supported in hardware */ 227aa04b4ccSPaul Mackerras if (lpcr_rmls(kvm_rma_size) < 0) { 228aa04b4ccSPaul Mackerras pr_err("RMA size of 0x%lx not supported\n", kvm_rma_size); 229aa04b4ccSPaul Mackerras return; 230aa04b4ccSPaul Mackerras } 231aa04b4ccSPaul Mackerras 232b4e70611SAlexander Graf kvm_linear_init_one(kvm_rma_size, kvm_rma_count, KVM_LINEAR_RMA); 233aa04b4ccSPaul Mackerras } 234fa61a4e3SAneesh Kumar K.V 235fa61a4e3SAneesh Kumar K.V /** 236fa61a4e3SAneesh Kumar K.V * kvm_cma_reserve() - reserve area for kvm hash pagetable 237fa61a4e3SAneesh Kumar K.V * 238fa61a4e3SAneesh Kumar K.V * This function reserves memory from early allocator. It should be 239fa61a4e3SAneesh Kumar K.V * called by arch specific code once the early allocator (memblock or bootmem) 240fa61a4e3SAneesh Kumar K.V * has been activated and all other subsystems have already allocated/reserved 241fa61a4e3SAneesh Kumar K.V * memory. 242fa61a4e3SAneesh Kumar K.V */ 243fa61a4e3SAneesh Kumar K.V void __init kvm_cma_reserve(void) 244fa61a4e3SAneesh Kumar K.V { 245fa61a4e3SAneesh Kumar K.V unsigned long align_size; 246fa61a4e3SAneesh Kumar K.V struct memblock_region *reg; 247fa61a4e3SAneesh Kumar K.V phys_addr_t selected_size = 0; 248fa61a4e3SAneesh Kumar K.V /* 249fa61a4e3SAneesh Kumar K.V * We cannot use memblock_phys_mem_size() here, because 250fa61a4e3SAneesh Kumar K.V * memblock_analyze() has not been called yet. 251fa61a4e3SAneesh Kumar K.V */ 252fa61a4e3SAneesh Kumar K.V for_each_memblock(memory, reg) 253fa61a4e3SAneesh Kumar K.V selected_size += memblock_region_memory_end_pfn(reg) - 254fa61a4e3SAneesh Kumar K.V memblock_region_memory_base_pfn(reg); 255fa61a4e3SAneesh Kumar K.V 256fa61a4e3SAneesh Kumar K.V selected_size = (selected_size * kvm_cma_resv_ratio / 100) << PAGE_SHIFT; 257fa61a4e3SAneesh Kumar K.V if (selected_size) { 258fa61a4e3SAneesh Kumar K.V pr_debug("%s: reserving %ld MiB for global area\n", __func__, 259fa61a4e3SAneesh Kumar K.V (unsigned long)selected_size / SZ_1M); 260fa61a4e3SAneesh Kumar K.V /* 261fa61a4e3SAneesh Kumar K.V * Old CPUs require HPT aligned on a multiple of its size. So for them 262fa61a4e3SAneesh Kumar K.V * make the alignment as max size we could request. 263fa61a4e3SAneesh Kumar K.V */ 264fa61a4e3SAneesh Kumar K.V if (!cpu_has_feature(CPU_FTR_ARCH_206)) 265fa61a4e3SAneesh Kumar K.V align_size = __rounddown_pow_of_two(selected_size); 266fa61a4e3SAneesh Kumar K.V else 267fa61a4e3SAneesh Kumar K.V align_size = HPT_ALIGN_PAGES << PAGE_SHIFT; 268fa61a4e3SAneesh Kumar K.V kvm_cma_declare_contiguous(selected_size, align_size); 269fa61a4e3SAneesh Kumar K.V } 270fa61a4e3SAneesh Kumar K.V } 271