1 /* 2 * arch/s390/mm/vmem.c 3 * 4 * Copyright IBM Corp. 2006 5 * Author(s): Heiko Carstens <heiko.carstens@de.ibm.com> 6 */ 7 8 #include <linux/bootmem.h> 9 #include <linux/pfn.h> 10 #include <linux/mm.h> 11 #include <linux/module.h> 12 #include <linux/list.h> 13 #include <linux/hugetlb.h> 14 #include <asm/pgalloc.h> 15 #include <asm/pgtable.h> 16 #include <asm/setup.h> 17 #include <asm/tlbflush.h> 18 #include <asm/sections.h> 19 20 static DEFINE_MUTEX(vmem_mutex); 21 22 struct memory_segment { 23 struct list_head list; 24 unsigned long start; 25 unsigned long size; 26 }; 27 28 static LIST_HEAD(mem_segs); 29 30 static void __ref *vmem_alloc_pages(unsigned int order) 31 { 32 if (slab_is_available()) 33 return (void *)__get_free_pages(GFP_KERNEL, order); 34 return alloc_bootmem_pages((1 << order) * PAGE_SIZE); 35 } 36 37 static inline pud_t *vmem_pud_alloc(void) 38 { 39 pud_t *pud = NULL; 40 41 #ifdef CONFIG_64BIT 42 pud = vmem_alloc_pages(2); 43 if (!pud) 44 return NULL; 45 clear_table((unsigned long *) pud, _REGION3_ENTRY_EMPTY, PAGE_SIZE * 4); 46 #endif 47 return pud; 48 } 49 50 static inline pmd_t *vmem_pmd_alloc(void) 51 { 52 pmd_t *pmd = NULL; 53 54 #ifdef CONFIG_64BIT 55 pmd = vmem_alloc_pages(2); 56 if (!pmd) 57 return NULL; 58 clear_table((unsigned long *) pmd, _SEGMENT_ENTRY_EMPTY, PAGE_SIZE * 4); 59 #endif 60 return pmd; 61 } 62 63 static pte_t __ref *vmem_pte_alloc(void) 64 { 65 pte_t *pte; 66 67 if (slab_is_available()) 68 pte = (pte_t *) page_table_alloc(&init_mm); 69 else 70 pte = alloc_bootmem(PTRS_PER_PTE * sizeof(pte_t)); 71 if (!pte) 72 return NULL; 73 clear_table((unsigned long *) pte, _PAGE_TYPE_EMPTY, 74 PTRS_PER_PTE * sizeof(pte_t)); 75 return pte; 76 } 77 78 /* 79 * Add a physical memory range to the 1:1 mapping. 80 */ 81 static int vmem_add_mem(unsigned long start, unsigned long size, int ro) 82 { 83 unsigned long address; 84 pgd_t *pg_dir; 85 pud_t *pu_dir; 86 pmd_t *pm_dir; 87 pte_t *pt_dir; 88 pte_t pte; 89 int ret = -ENOMEM; 90 91 for (address = start; address < start + size; address += PAGE_SIZE) { 92 pg_dir = pgd_offset_k(address); 93 if (pgd_none(*pg_dir)) { 94 pu_dir = vmem_pud_alloc(); 95 if (!pu_dir) 96 goto out; 97 pgd_populate_kernel(&init_mm, pg_dir, pu_dir); 98 } 99 100 pu_dir = pud_offset(pg_dir, address); 101 if (pud_none(*pu_dir)) { 102 pm_dir = vmem_pmd_alloc(); 103 if (!pm_dir) 104 goto out; 105 pud_populate_kernel(&init_mm, pu_dir, pm_dir); 106 } 107 108 pte = mk_pte_phys(address, __pgprot(ro ? _PAGE_RO : 0)); 109 pm_dir = pmd_offset(pu_dir, address); 110 111 #ifdef __s390x__ 112 if (MACHINE_HAS_HPAGE && !(address & ~HPAGE_MASK) && 113 (address + HPAGE_SIZE <= start + size) && 114 (address >= HPAGE_SIZE)) { 115 pte_val(pte) |= _SEGMENT_ENTRY_LARGE; 116 pmd_val(*pm_dir) = pte_val(pte); 117 address += HPAGE_SIZE - PAGE_SIZE; 118 continue; 119 } 120 #endif 121 if (pmd_none(*pm_dir)) { 122 pt_dir = vmem_pte_alloc(); 123 if (!pt_dir) 124 goto out; 125 pmd_populate_kernel(&init_mm, pm_dir, pt_dir); 126 } 127 128 pt_dir = pte_offset_kernel(pm_dir, address); 129 *pt_dir = pte; 130 } 131 ret = 0; 132 out: 133 flush_tlb_kernel_range(start, start + size); 134 return ret; 135 } 136 137 /* 138 * Remove a physical memory range from the 1:1 mapping. 139 * Currently only invalidates page table entries. 140 */ 141 static void vmem_remove_range(unsigned long start, unsigned long size) 142 { 143 unsigned long address; 144 pgd_t *pg_dir; 145 pud_t *pu_dir; 146 pmd_t *pm_dir; 147 pte_t *pt_dir; 148 pte_t pte; 149 150 pte_val(pte) = _PAGE_TYPE_EMPTY; 151 for (address = start; address < start + size; address += PAGE_SIZE) { 152 pg_dir = pgd_offset_k(address); 153 pu_dir = pud_offset(pg_dir, address); 154 if (pud_none(*pu_dir)) 155 continue; 156 pm_dir = pmd_offset(pu_dir, address); 157 if (pmd_none(*pm_dir)) 158 continue; 159 160 if (pmd_huge(*pm_dir)) { 161 pmd_clear_kernel(pm_dir); 162 address += HPAGE_SIZE - PAGE_SIZE; 163 continue; 164 } 165 166 pt_dir = pte_offset_kernel(pm_dir, address); 167 *pt_dir = pte; 168 } 169 flush_tlb_kernel_range(start, start + size); 170 } 171 172 /* 173 * Add a backed mem_map array to the virtual mem_map array. 174 */ 175 int __meminit vmemmap_populate(struct page *start, unsigned long nr, int node) 176 { 177 unsigned long address, start_addr, end_addr; 178 pgd_t *pg_dir; 179 pud_t *pu_dir; 180 pmd_t *pm_dir; 181 pte_t *pt_dir; 182 pte_t pte; 183 int ret = -ENOMEM; 184 185 start_addr = (unsigned long) start; 186 end_addr = (unsigned long) (start + nr); 187 188 for (address = start_addr; address < end_addr; address += PAGE_SIZE) { 189 pg_dir = pgd_offset_k(address); 190 if (pgd_none(*pg_dir)) { 191 pu_dir = vmem_pud_alloc(); 192 if (!pu_dir) 193 goto out; 194 pgd_populate_kernel(&init_mm, pg_dir, pu_dir); 195 } 196 197 pu_dir = pud_offset(pg_dir, address); 198 if (pud_none(*pu_dir)) { 199 pm_dir = vmem_pmd_alloc(); 200 if (!pm_dir) 201 goto out; 202 pud_populate_kernel(&init_mm, pu_dir, pm_dir); 203 } 204 205 pm_dir = pmd_offset(pu_dir, address); 206 if (pmd_none(*pm_dir)) { 207 pt_dir = vmem_pte_alloc(); 208 if (!pt_dir) 209 goto out; 210 pmd_populate_kernel(&init_mm, pm_dir, pt_dir); 211 } 212 213 pt_dir = pte_offset_kernel(pm_dir, address); 214 if (pte_none(*pt_dir)) { 215 unsigned long new_page; 216 217 new_page =__pa(vmem_alloc_pages(0)); 218 if (!new_page) 219 goto out; 220 pte = pfn_pte(new_page >> PAGE_SHIFT, PAGE_KERNEL); 221 *pt_dir = pte; 222 } 223 } 224 memset(start, 0, nr * sizeof(struct page)); 225 ret = 0; 226 out: 227 flush_tlb_kernel_range(start_addr, end_addr); 228 return ret; 229 } 230 231 /* 232 * Add memory segment to the segment list if it doesn't overlap with 233 * an already present segment. 234 */ 235 static int insert_memory_segment(struct memory_segment *seg) 236 { 237 struct memory_segment *tmp; 238 239 if (seg->start + seg->size > VMEM_MAX_PHYS || 240 seg->start + seg->size < seg->start) 241 return -ERANGE; 242 243 list_for_each_entry(tmp, &mem_segs, list) { 244 if (seg->start >= tmp->start + tmp->size) 245 continue; 246 if (seg->start + seg->size <= tmp->start) 247 continue; 248 return -ENOSPC; 249 } 250 list_add(&seg->list, &mem_segs); 251 return 0; 252 } 253 254 /* 255 * Remove memory segment from the segment list. 256 */ 257 static void remove_memory_segment(struct memory_segment *seg) 258 { 259 list_del(&seg->list); 260 } 261 262 static void __remove_shared_memory(struct memory_segment *seg) 263 { 264 remove_memory_segment(seg); 265 vmem_remove_range(seg->start, seg->size); 266 } 267 268 int vmem_remove_mapping(unsigned long start, unsigned long size) 269 { 270 struct memory_segment *seg; 271 int ret; 272 273 mutex_lock(&vmem_mutex); 274 275 ret = -ENOENT; 276 list_for_each_entry(seg, &mem_segs, list) { 277 if (seg->start == start && seg->size == size) 278 break; 279 } 280 281 if (seg->start != start || seg->size != size) 282 goto out; 283 284 ret = 0; 285 __remove_shared_memory(seg); 286 kfree(seg); 287 out: 288 mutex_unlock(&vmem_mutex); 289 return ret; 290 } 291 292 int vmem_add_mapping(unsigned long start, unsigned long size) 293 { 294 struct memory_segment *seg; 295 int ret; 296 297 mutex_lock(&vmem_mutex); 298 ret = -ENOMEM; 299 seg = kzalloc(sizeof(*seg), GFP_KERNEL); 300 if (!seg) 301 goto out; 302 seg->start = start; 303 seg->size = size; 304 305 ret = insert_memory_segment(seg); 306 if (ret) 307 goto out_free; 308 309 ret = vmem_add_mem(start, size, 0); 310 if (ret) 311 goto out_remove; 312 goto out; 313 314 out_remove: 315 __remove_shared_memory(seg); 316 out_free: 317 kfree(seg); 318 out: 319 mutex_unlock(&vmem_mutex); 320 return ret; 321 } 322 323 /* 324 * map whole physical memory to virtual memory (identity mapping) 325 * we reserve enough space in the vmalloc area for vmemmap to hotplug 326 * additional memory segments. 327 */ 328 void __init vmem_map_init(void) 329 { 330 unsigned long ro_start, ro_end; 331 unsigned long start, end; 332 int i; 333 334 INIT_LIST_HEAD(&init_mm.context.crst_list); 335 INIT_LIST_HEAD(&init_mm.context.pgtable_list); 336 init_mm.context.noexec = 0; 337 ro_start = ((unsigned long)&_stext) & PAGE_MASK; 338 ro_end = PFN_ALIGN((unsigned long)&_eshared); 339 for (i = 0; i < MEMORY_CHUNKS && memory_chunk[i].size > 0; i++) { 340 start = memory_chunk[i].addr; 341 end = memory_chunk[i].addr + memory_chunk[i].size; 342 if (start >= ro_end || end <= ro_start) 343 vmem_add_mem(start, end - start, 0); 344 else if (start >= ro_start && end <= ro_end) 345 vmem_add_mem(start, end - start, 1); 346 else if (start >= ro_start) { 347 vmem_add_mem(start, ro_end - start, 1); 348 vmem_add_mem(ro_end, end - ro_end, 0); 349 } else if (end < ro_end) { 350 vmem_add_mem(start, ro_start - start, 0); 351 vmem_add_mem(ro_start, end - ro_start, 1); 352 } else { 353 vmem_add_mem(start, ro_start - start, 0); 354 vmem_add_mem(ro_start, ro_end - ro_start, 1); 355 vmem_add_mem(ro_end, end - ro_end, 0); 356 } 357 } 358 } 359 360 /* 361 * Convert memory chunk array to a memory segment list so there is a single 362 * list that contains both r/w memory and shared memory segments. 363 */ 364 static int __init vmem_convert_memory_chunk(void) 365 { 366 struct memory_segment *seg; 367 int i; 368 369 mutex_lock(&vmem_mutex); 370 for (i = 0; i < MEMORY_CHUNKS; i++) { 371 if (!memory_chunk[i].size) 372 continue; 373 seg = kzalloc(sizeof(*seg), GFP_KERNEL); 374 if (!seg) 375 panic("Out of memory...\n"); 376 seg->start = memory_chunk[i].addr; 377 seg->size = memory_chunk[i].size; 378 insert_memory_segment(seg); 379 } 380 mutex_unlock(&vmem_mutex); 381 return 0; 382 } 383 384 core_initcall(vmem_convert_memory_chunk); 385