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