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 __init_refok *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 ret = 0; 225 out: 226 flush_tlb_kernel_range(start_addr, end_addr); 227 return ret; 228 } 229 230 /* 231 * Add memory segment to the segment list if it doesn't overlap with 232 * an already present segment. 233 */ 234 static int insert_memory_segment(struct memory_segment *seg) 235 { 236 struct memory_segment *tmp; 237 238 if (seg->start + seg->size >= VMEM_MAX_PHYS || 239 seg->start + seg->size < seg->start) 240 return -ERANGE; 241 242 list_for_each_entry(tmp, &mem_segs, list) { 243 if (seg->start >= tmp->start + tmp->size) 244 continue; 245 if (seg->start + seg->size <= tmp->start) 246 continue; 247 return -ENOSPC; 248 } 249 list_add(&seg->list, &mem_segs); 250 return 0; 251 } 252 253 /* 254 * Remove memory segment from the segment list. 255 */ 256 static void remove_memory_segment(struct memory_segment *seg) 257 { 258 list_del(&seg->list); 259 } 260 261 static void __remove_shared_memory(struct memory_segment *seg) 262 { 263 remove_memory_segment(seg); 264 vmem_remove_range(seg->start, seg->size); 265 } 266 267 int vmem_remove_mapping(unsigned long start, unsigned long size) 268 { 269 struct memory_segment *seg; 270 int ret; 271 272 mutex_lock(&vmem_mutex); 273 274 ret = -ENOENT; 275 list_for_each_entry(seg, &mem_segs, list) { 276 if (seg->start == start && seg->size == size) 277 break; 278 } 279 280 if (seg->start != start || seg->size != size) 281 goto out; 282 283 ret = 0; 284 __remove_shared_memory(seg); 285 kfree(seg); 286 out: 287 mutex_unlock(&vmem_mutex); 288 return ret; 289 } 290 291 int vmem_add_mapping(unsigned long start, unsigned long size) 292 { 293 struct memory_segment *seg; 294 int ret; 295 296 mutex_lock(&vmem_mutex); 297 ret = -ENOMEM; 298 seg = kzalloc(sizeof(*seg), GFP_KERNEL); 299 if (!seg) 300 goto out; 301 seg->start = start; 302 seg->size = size; 303 304 ret = insert_memory_segment(seg); 305 if (ret) 306 goto out_free; 307 308 ret = vmem_add_mem(start, size, 0); 309 if (ret) 310 goto out_remove; 311 goto out; 312 313 out_remove: 314 __remove_shared_memory(seg); 315 out_free: 316 kfree(seg); 317 out: 318 mutex_unlock(&vmem_mutex); 319 return ret; 320 } 321 322 /* 323 * map whole physical memory to virtual memory (identity mapping) 324 * we reserve enough space in the vmalloc area for vmemmap to hotplug 325 * additional memory segments. 326 */ 327 void __init vmem_map_init(void) 328 { 329 unsigned long ro_start, ro_end; 330 unsigned long start, end; 331 int i; 332 333 INIT_LIST_HEAD(&init_mm.context.crst_list); 334 INIT_LIST_HEAD(&init_mm.context.pgtable_list); 335 init_mm.context.noexec = 0; 336 ro_start = ((unsigned long)&_stext) & PAGE_MASK; 337 ro_end = PFN_ALIGN((unsigned long)&_eshared); 338 for (i = 0; i < MEMORY_CHUNKS && memory_chunk[i].size > 0; i++) { 339 start = memory_chunk[i].addr; 340 end = memory_chunk[i].addr + memory_chunk[i].size; 341 if (start >= ro_end || end <= ro_start) 342 vmem_add_mem(start, end - start, 0); 343 else if (start >= ro_start && end <= ro_end) 344 vmem_add_mem(start, end - start, 1); 345 else if (start >= ro_start) { 346 vmem_add_mem(start, ro_end - start, 1); 347 vmem_add_mem(ro_end, end - ro_end, 0); 348 } else if (end < ro_end) { 349 vmem_add_mem(start, ro_start - start, 0); 350 vmem_add_mem(ro_start, end - ro_start, 1); 351 } else { 352 vmem_add_mem(start, ro_start - start, 0); 353 vmem_add_mem(ro_start, ro_end - ro_start, 1); 354 vmem_add_mem(ro_end, end - ro_end, 0); 355 } 356 } 357 } 358 359 /* 360 * Convert memory chunk array to a memory segment list so there is a single 361 * list that contains both r/w memory and shared memory segments. 362 */ 363 static int __init vmem_convert_memory_chunk(void) 364 { 365 struct memory_segment *seg; 366 int i; 367 368 mutex_lock(&vmem_mutex); 369 for (i = 0; i < MEMORY_CHUNKS; i++) { 370 if (!memory_chunk[i].size) 371 continue; 372 seg = kzalloc(sizeof(*seg), GFP_KERNEL); 373 if (!seg) 374 panic("Out of memory...\n"); 375 seg->start = memory_chunk[i].addr; 376 seg->size = memory_chunk[i].size; 377 insert_memory_segment(seg); 378 } 379 mutex_unlock(&vmem_mutex); 380 return 0; 381 } 382 383 core_initcall(vmem_convert_memory_chunk); 384