SAFE public projects git trees. - safe/jmp/linux-2.6/blob - mm/sparse.c

   1 /*
   2  * sparse memory mappings.
   3  */
   4 #include <linux/config.h>
   5 #include <linux/mm.h>
   6 #include <linux/mmzone.h>
   7 #include <linux/bootmem.h>
   8 #include <linux/highmem.h>
   9 #include <linux/module.h>
  10 #include <linux/spinlock.h>
  11 #include <linux/vmalloc.h>
  12 #include <asm/dma.h>
  13
  14 /*
  15  * Permanent SPARSEMEM data:
  16  *
  17  * 1) mem_section       - memory sections, mem_map's for valid memory
  18  */
  19 #ifdef CONFIG_SPARSEMEM_EXTREME
  20 struct mem_section *mem_section[NR_SECTION_ROOTS]
  21         ____cacheline_internodealigned_in_smp;
  22 #else
  23 struct mem_section mem_section[NR_SECTION_ROOTS][SECTIONS_PER_ROOT]
  24         ____cacheline_internodealigned_in_smp;
  25 #endif
  26 EXPORT_SYMBOL(mem_section);
  27
  28 #ifdef CONFIG_SPARSEMEM_EXTREME
  29 static struct mem_section *sparse_index_alloc(int nid)
  30 {
  31         struct mem_section *section = NULL;
  32         unsigned long array_size = SECTIONS_PER_ROOT *
  33                                    sizeof(struct mem_section);
  34
  35         if (slab_is_available())
  36                 section = kmalloc_node(array_size, GFP_KERNEL, nid);
  37         else
  38                 section = alloc_bootmem_node(NODE_DATA(nid), array_size);
  39
  40         if (section)
  41                 memset(section, 0, array_size);
  42
  43         return section;
  44 }
  45
  46 static int sparse_index_init(unsigned long section_nr, int nid)
  47 {
  48         static spinlock_t index_init_lock = SPIN_LOCK_UNLOCKED;
  49         unsigned long root = SECTION_NR_TO_ROOT(section_nr);
  50         struct mem_section *section;
  51         int ret = 0;
  52
  53         if (mem_section[root])
  54                 return -EEXIST;
  55
  56         section = sparse_index_alloc(nid);
  57         /*
  58          * This lock keeps two different sections from
  59          * reallocating for the same index
  60          */
  61         spin_lock(&index_init_lock);
  62
  63         if (mem_section[root]) {
  64                 ret = -EEXIST;
  65                 goto out;
  66         }
  67
  68         mem_section[root] = section;
  69 out:
  70         spin_unlock(&index_init_lock);
  71         return ret;
  72 }
  73 #else /* !SPARSEMEM_EXTREME */
  74 static inline int sparse_index_init(unsigned long section_nr, int nid)
  75 {
  76         return 0;
  77 }
  78 #endif
  79
  80 /*
  81  * Although written for the SPARSEMEM_EXTREME case, this happens
  82  * to also work for the flat array case becase
  83  * NR_SECTION_ROOTS==NR_MEM_SECTIONS.
  84  */
  85 int __section_nr(struct mem_section* ms)
  86 {
  87         unsigned long root_nr;
  88         struct mem_section* root;
  89
  90         for (root_nr = 0; root_nr < NR_SECTION_ROOTS; root_nr++) {
  91                 root = __nr_to_section(root_nr * SECTIONS_PER_ROOT);
  92                 if (!root)
  93                         continue;
  94
  95                 if ((ms >= root) && (ms < (root + SECTIONS_PER_ROOT)))
  96                      break;
  97         }
  98
  99         return (root_nr * SECTIONS_PER_ROOT) + (ms - root);
 100 }
 101
 102 /*
 103  * During early boot, before section_mem_map is used for an actual
 104  * mem_map, we use section_mem_map to store the section's NUMA
 105  * node.  This keeps us from having to use another data structure.  The
 106  * node information is cleared just before we store the real mem_map.
 107  */
 108 static inline unsigned long sparse_encode_early_nid(int nid)
 109 {
 110         return (nid << SECTION_NID_SHIFT);
 111 }
 112
 113 static inline int sparse_early_nid(struct mem_section *section)
 114 {
 115         return (section->section_mem_map >> SECTION_NID_SHIFT);
 116 }
 117
 118 /* Record a memory area against a node. */
 119 void memory_present(int nid, unsigned long start, unsigned long end)
 120 {
 121         unsigned long pfn;
 122
 123         start &= PAGE_SECTION_MASK;
 124         for (pfn = start; pfn < end; pfn += PAGES_PER_SECTION) {
 125                 unsigned long section = pfn_to_section_nr(pfn);
 126                 struct mem_section *ms;
 127
 128                 sparse_index_init(section, nid);
 129
 130                 ms = __nr_to_section(section);
 131                 if (!ms->section_mem_map)
 132                         ms->section_mem_map = sparse_encode_early_nid(nid) |
 133                                                         SECTION_MARKED_PRESENT;
 134         }
 135 }
 136
 137 /*
 138  * Only used by the i386 NUMA architecures, but relatively
 139  * generic code.
 140  */
 141 unsigned long __init node_memmap_size_bytes(int nid, unsigned long start_pfn,
 142                                                      unsigned long end_pfn)
 143 {
 144         unsigned long pfn;
 145         unsigned long nr_pages = 0;
 146
 147         for (pfn = start_pfn; pfn < end_pfn; pfn += PAGES_PER_SECTION) {
 148                 if (nid != early_pfn_to_nid(pfn))
 149                         continue;
 150
 151                 if (pfn_valid(pfn))
 152                         nr_pages += PAGES_PER_SECTION;
 153         }
 154
 155         return nr_pages * sizeof(struct page);
 156 }
 157
 158 /*
 159  * Subtle, we encode the real pfn into the mem_map such that
 160  * the identity pfn - section_mem_map will return the actual
 161  * physical page frame number.
 162  */
 163 static unsigned long sparse_encode_mem_map(struct page *mem_map, unsigned long pnum)
 164 {
 165         return (unsigned long)(mem_map - (section_nr_to_pfn(pnum)));
 166 }
 167
 168 /*
 169  * We need this if we ever free the mem_maps.  While not implemented yet,
 170  * this function is included for parity with its sibling.
 171  */
 172 static __attribute((unused))
 173 struct page *sparse_decode_mem_map(unsigned long coded_mem_map, unsigned long pnum)
 174 {
 175         return ((struct page *)coded_mem_map) + section_nr_to_pfn(pnum);
 176 }
 177
 178 static int sparse_init_one_section(struct mem_section *ms,
 179                 unsigned long pnum, struct page *mem_map)
 180 {
 181         if (!valid_section(ms))
 182                 return -EINVAL;
 183
 184         ms->section_mem_map &= ~SECTION_MAP_MASK;
 185         ms->section_mem_map |= sparse_encode_mem_map(mem_map, pnum);
 186
 187         return 1;
 188 }
 189
 190 static struct page *sparse_early_mem_map_alloc(unsigned long pnum)
 191 {
 192         struct page *map;
 193         struct mem_section *ms = __nr_to_section(pnum);
 194         int nid = sparse_early_nid(ms);
 195
 196         map = alloc_remap(nid, sizeof(struct page) * PAGES_PER_SECTION);
 197         if (map)
 198                 return map;
 199
 200         map = alloc_bootmem_node(NODE_DATA(nid),
 201                         sizeof(struct page) * PAGES_PER_SECTION);
 202         if (map)
 203                 return map;
 204
 205         printk(KERN_WARNING "%s: allocation failed\n", __FUNCTION__);
 206         ms->section_mem_map = 0;
 207         return NULL;
 208 }
 209
 210 static struct page *__kmalloc_section_memmap(unsigned long nr_pages)
 211 {
 212         struct page *page, *ret;
 213         unsigned long memmap_size = sizeof(struct page) * nr_pages;
 214
 215         page = alloc_pages(GFP_KERNEL, get_order(memmap_size));
 216         if (page)
 217                 goto got_map_page;
 218
 219         ret = vmalloc(memmap_size);
 220         if (ret)
 221                 goto got_map_ptr;
 222
 223         return NULL;
 224 got_map_page:
 225         ret = (struct page *)pfn_to_kaddr(page_to_pfn(page));
 226 got_map_ptr:
 227         memset(ret, 0, memmap_size);
 228
 229         return ret;
 230 }
 231
 232 static int vaddr_in_vmalloc_area(void *addr)
 233 {
 234         if (addr >= (void *)VMALLOC_START &&
 235             addr < (void *)VMALLOC_END)
 236                 return 1;
 237         return 0;
 238 }
 239
 240 static void __kfree_section_memmap(struct page *memmap, unsigned long nr_pages)
 241 {
 242         if (vaddr_in_vmalloc_area(memmap))
 243                 vfree(memmap);
 244         else
 245                 free_pages((unsigned long)memmap,
 246                            get_order(sizeof(struct page) * nr_pages));
 247 }
 248
 249 /*
 250  * Allocate the accumulated non-linear sections, allocate a mem_map
 251  * for each and record the physical to section mapping.
 252  */
 253 void sparse_init(void)
 254 {
 255         unsigned long pnum;
 256         struct page *map;
 257
 258         for (pnum = 0; pnum < NR_MEM_SECTIONS; pnum++) {
 259                 if (!valid_section_nr(pnum))
 260                         continue;
 261
 262                 map = sparse_early_mem_map_alloc(pnum);
 263                 if (!map)
 264                         continue;
 265                 sparse_init_one_section(__nr_to_section(pnum), pnum, map);
 266         }
 267 }
 268
 269 /*
 270  * returns the number of sections whose mem_maps were properly
 271  * set.  If this is <=0, then that means that the passed-in
 272  * map was not consumed and must be freed.
 273  */
 274 int sparse_add_one_section(struct zone *zone, unsigned long start_pfn,
 275                            int nr_pages)
 276 {
 277         unsigned long section_nr = pfn_to_section_nr(start_pfn);
 278         struct pglist_data *pgdat = zone->zone_pgdat;
 279         struct mem_section *ms;
 280         struct page *memmap;
 281         unsigned long flags;
 282         int ret;
 283
 284         /*
 285          * no locking for this, because it does its own
 286          * plus, it does a kmalloc
 287          */
 288         sparse_index_init(section_nr, pgdat->node_id);
 289         memmap = __kmalloc_section_memmap(nr_pages);
 290
 291         pgdat_resize_lock(pgdat, &flags);
 292
 293         ms = __pfn_to_section(start_pfn);
 294         if (ms->section_mem_map & SECTION_MARKED_PRESENT) {
 295                 ret = -EEXIST;
 296                 goto out;
 297         }
 298         ms->section_mem_map |= SECTION_MARKED_PRESENT;
 299
 300         ret = sparse_init_one_section(ms, section_nr, memmap);
 301
 302 out:
 303         pgdat_resize_unlock(pgdat, &flags);
 304         if (ret <= 0)
 305                 __kfree_section_memmap(memmap, nr_pages);
 306         return ret;
 307 }