git.oblomov.eu Git - linux-2.6/blob - arch/s390/mm/vmem.c

   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 <asm/pgalloc.h>
  14 #include <asm/pgtable.h>
  15 #include <asm/setup.h>
  16 #include <asm/tlbflush.h>
  17
  18 unsigned long vmalloc_end;
  19 EXPORT_SYMBOL(vmalloc_end);
  20
  21 static struct page *vmem_map;
  22 static DEFINE_MUTEX(vmem_mutex);
  23
  24 struct memory_segment {
  25         struct list_head list;
  26         unsigned long start;
  27         unsigned long size;
  28 };
  29
  30 static LIST_HEAD(mem_segs);
  31
  32 void memmap_init(unsigned long size, int nid, unsigned long zone,
  33                  unsigned long start_pfn)
  34 {
  35         struct page *start, *end;
  36         struct page *map_start, *map_end;
  37         int i;
  38
  39         start = pfn_to_page(start_pfn);
  40         end = start + size;
  41
  42         for (i = 0; i < MEMORY_CHUNKS && memory_chunk[i].size > 0; i++) {
  43                 unsigned long cstart, cend;
  44
  45                 cstart = PFN_DOWN(memory_chunk[i].addr);
  46                 cend = cstart + PFN_DOWN(memory_chunk[i].size);
  47
  48                 map_start = mem_map + cstart;
  49                 map_end = mem_map + cend;
  50
  51                 if (map_start < start)
  52                         map_start = start;
  53                 if (map_end > end)
  54                         map_end = end;
  55
  56                 map_start -= ((unsigned long) map_start & (PAGE_SIZE - 1))
  57                         / sizeof(struct page);
  58                 map_end += ((PFN_ALIGN((unsigned long) map_end)
  59                              - (unsigned long) map_end)
  60                             / sizeof(struct page));
  61
  62                 if (map_start < map_end)
  63                         memmap_init_zone((unsigned long)(map_end - map_start),
  64                                          nid, zone, page_to_pfn(map_start));
  65         }
  66 }
  67
  68 static inline void *vmem_alloc_pages(unsigned int order)
  69 {
  70         if (slab_is_available())
  71                 return (void *)__get_free_pages(GFP_KERNEL, order);
  72         return alloc_bootmem_pages((1 << order) * PAGE_SIZE);
  73 }
  74
  75 static inline pmd_t *vmem_pmd_alloc(void)
  76 {
  77         pmd_t *pmd;
  78         int i;
  79
  80         pmd = vmem_alloc_pages(PMD_ALLOC_ORDER);
  81         if (!pmd)
  82                 return NULL;
  83         for (i = 0; i < PTRS_PER_PMD; i++)
  84                 pmd_clear(pmd + i);
  85         return pmd;
  86 }
  87
  88 static inline pte_t *vmem_pte_alloc(void)
  89 {
  90         pte_t *pte;
  91         pte_t empty_pte;
  92         int i;
  93
  94         pte = vmem_alloc_pages(PTE_ALLOC_ORDER);
  95         if (!pte)
  96                 return NULL;
  97         pte_val(empty_pte) = _PAGE_TYPE_EMPTY;
  98         for (i = 0; i < PTRS_PER_PTE; i++)
  99                 set_pte(pte + i, empty_pte);
 100         return pte;
 101 }
 102
 103 /*
 104  * Add a physical memory range to the 1:1 mapping.
 105  */
 106 static int vmem_add_range(unsigned long start, unsigned long size)
 107 {
 108         unsigned long address;
 109         pgd_t *pg_dir;
 110         pmd_t *pm_dir;
 111         pte_t *pt_dir;
 112         pte_t  pte;
 113         int ret = -ENOMEM;
 114
 115         for (address = start; address < start + size; address += PAGE_SIZE) {
 116                 pg_dir = pgd_offset_k(address);
 117                 if (pgd_none(*pg_dir)) {
 118                         pm_dir = vmem_pmd_alloc();
 119                         if (!pm_dir)
 120                                 goto out;
 121                         pgd_populate(&init_mm, pg_dir, pm_dir);
 122                 }
 123
 124                 pm_dir = pmd_offset(pg_dir, address);
 125                 if (pmd_none(*pm_dir)) {
 126                         pt_dir = vmem_pte_alloc();
 127                         if (!pt_dir)
 128                                 goto out;
 129                         pmd_populate_kernel(&init_mm, pm_dir, pt_dir);
 130                 }
 131
 132                 pt_dir = pte_offset_kernel(pm_dir, address);
 133                 pte = pfn_pte(address >> PAGE_SHIFT, PAGE_KERNEL);
 134                 set_pte(pt_dir, pte);
 135         }
 136         ret = 0;
 137 out:
 138         flush_tlb_kernel_range(start, start + size);
 139         return ret;
 140 }
 141
 142 /*
 143  * Remove a physical memory range from the 1:1 mapping.
 144  * Currently only invalidates page table entries.
 145  */
 146 static void vmem_remove_range(unsigned long start, unsigned long size)
 147 {
 148         unsigned long address;
 149         pgd_t *pg_dir;
 150         pmd_t *pm_dir;
 151         pte_t *pt_dir;
 152         pte_t  pte;
 153
 154         pte_val(pte) = _PAGE_TYPE_EMPTY;
 155         for (address = start; address < start + size; address += PAGE_SIZE) {
 156                 pg_dir = pgd_offset_k(address);
 157                 if (pgd_none(*pg_dir))
 158                         continue;
 159                 pm_dir = pmd_offset(pg_dir, address);
 160                 if (pmd_none(*pm_dir))
 161                         continue;
 162                 pt_dir = pte_offset_kernel(pm_dir, address);
 163                 set_pte(pt_dir, pte);
 164         }
 165         flush_tlb_kernel_range(start, start + size);
 166 }
 167
 168 /*
 169  * Add a backed mem_map array to the virtual mem_map array.
 170  */
 171 static int vmem_add_mem_map(unsigned long start, unsigned long size)
 172 {
 173         unsigned long address, start_addr, end_addr;
 174         struct page *map_start, *map_end;
 175         pgd_t *pg_dir;
 176         pmd_t *pm_dir;
 177         pte_t *pt_dir;
 178         pte_t  pte;
 179         int ret = -ENOMEM;
 180
 181         map_start = vmem_map + PFN_DOWN(start);
 182         map_end = vmem_map + PFN_DOWN(start + size);
 183
 184         start_addr = (unsigned long) map_start & PAGE_MASK;
 185         end_addr = PFN_ALIGN((unsigned long) map_end);
 186
 187         for (address = start_addr; address < end_addr; address += PAGE_SIZE) {
 188                 pg_dir = pgd_offset_k(address);
 189                 if (pgd_none(*pg_dir)) {
 190                         pm_dir = vmem_pmd_alloc();
 191                         if (!pm_dir)
 192                                 goto out;
 193                         pgd_populate(&init_mm, pg_dir, pm_dir);
 194                 }
 195
 196                 pm_dir = pmd_offset(pg_dir, address);
 197                 if (pmd_none(*pm_dir)) {
 198                         pt_dir = vmem_pte_alloc();
 199                         if (!pt_dir)
 200                                 goto out;
 201                         pmd_populate_kernel(&init_mm, pm_dir, pt_dir);
 202                 }
 203
 204                 pt_dir = pte_offset_kernel(pm_dir, address);
 205                 if (pte_none(*pt_dir)) {
 206                         unsigned long new_page;
 207
 208                         new_page =__pa(vmem_alloc_pages(0));
 209                         if (!new_page)
 210                                 goto out;
 211                         pte = pfn_pte(new_page >> PAGE_SHIFT, PAGE_KERNEL);
 212                         set_pte(pt_dir, pte);
 213                 }
 214         }
 215         ret = 0;
 216 out:
 217         flush_tlb_kernel_range(start_addr, end_addr);
 218         return ret;
 219 }
 220
 221 static int vmem_add_mem(unsigned long start, unsigned long size)
 222 {
 223         int ret;
 224
 225         ret = vmem_add_range(start, size);
 226         if (ret)
 227                 return ret;
 228         return vmem_add_mem_map(start, size);
 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 (PFN_DOWN(seg->start + seg->size) > max_pfn ||
 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 remove_shared_memory(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 add_shared_memory(unsigned long start, unsigned long size)
 293 {
 294         struct memory_segment *seg;
 295         struct page *page;
 296         unsigned long pfn, num_pfn, end_pfn;
 297         int ret;
 298
 299         mutex_lock(&vmem_mutex);
 300         ret = -ENOMEM;
 301         seg = kzalloc(sizeof(*seg), GFP_KERNEL);
 302         if (!seg)
 303                 goto out;
 304         seg->start = start;
 305         seg->size = size;
 306
 307         ret = insert_memory_segment(seg);
 308         if (ret)
 309                 goto out_free;
 310
 311         ret = vmem_add_mem(start, size);
 312         if (ret)
 313                 goto out_remove;
 314
 315         pfn = PFN_DOWN(start);
 316         num_pfn = PFN_DOWN(size);
 317         end_pfn = pfn + num_pfn;
 318
 319         page = pfn_to_page(pfn);
 320         memset(page, 0, num_pfn * sizeof(struct page));
 321
 322         for (; pfn < end_pfn; pfn++) {
 323                 page = pfn_to_page(pfn);
 324                 init_page_count(page);
 325                 reset_page_mapcount(page);
 326                 SetPageReserved(page);
 327                 INIT_LIST_HEAD(&page->lru);
 328         }
 329         goto out;
 330
 331 out_remove:
 332         __remove_shared_memory(seg);
 333 out_free:
 334         kfree(seg);
 335 out:
 336         mutex_unlock(&vmem_mutex);
 337         return ret;
 338 }
 339
 340 /*
 341  * map whole physical memory to virtual memory (identity mapping)
 342  */
 343 void __init vmem_map_init(void)
 344 {
 345         unsigned long map_size;
 346         int i;
 347
 348         map_size = ALIGN(max_low_pfn, MAX_ORDER_NR_PAGES) * sizeof(struct page);
 349         vmalloc_end = PFN_ALIGN(VMALLOC_END_INIT) - PFN_ALIGN(map_size);
 350         vmem_map = (struct page *) vmalloc_end;
 351         NODE_DATA(0)->node_mem_map = vmem_map;
 352
 353         for (i = 0; i < MEMORY_CHUNKS && memory_chunk[i].size > 0; i++)
 354                 vmem_add_mem(memory_chunk[i].addr, memory_chunk[i].size);
 355 }
 356
 357 /*
 358  * Convert memory chunk array to a memory segment list so there is a single
 359  * list that contains both r/w memory and shared memory segments.
 360  */
 361 static int __init vmem_convert_memory_chunk(void)
 362 {
 363         struct memory_segment *seg;
 364         int i;
 365
 366         mutex_lock(&vmem_mutex);
 367         for (i = 0; i < MEMORY_CHUNKS && memory_chunk[i].size > 0; i++) {
 368                 if (!memory_chunk[i].size)
 369                         continue;
 370                 seg = kzalloc(sizeof(*seg), GFP_KERNEL);
 371                 if (!seg)
 372                         panic("Out of memory...\n");
 373                 seg->start = memory_chunk[i].addr;
 374                 seg->size = memory_chunk[i].size;
 375                 insert_memory_segment(seg);
 376         }
 377         mutex_unlock(&vmem_mutex);
 378         return 0;
 379 }
 380
 381 core_initcall(vmem_convert_memory_chunk);