sparse.c 20.8 KB
Newer Older
1 2 3 4
/*
 * sparse memory mappings.
 */
#include <linux/mm.h>
5
#include <linux/slab.h>
6 7
#include <linux/mmzone.h>
#include <linux/bootmem.h>
8
#include <linux/compiler.h>
9
#include <linux/highmem.h>
10
#include <linux/export.h>
11
#include <linux/spinlock.h>
12
#include <linux/vmalloc.h>
13

14
#include "internal.h"
15
#include <asm/dma.h>
16 17
#include <asm/pgalloc.h>
#include <asm/pgtable.h>
18 19 20 21 22 23

/*
 * Permanent SPARSEMEM data:
 *
 * 1) mem_section	- memory sections, mem_map's for valid memory
 */
24
#ifdef CONFIG_SPARSEMEM_EXTREME
Bob Picco's avatar
Bob Picco committed
25
struct mem_section *mem_section[NR_SECTION_ROOTS]
26
	____cacheline_internodealigned_in_smp;
27 28
#else
struct mem_section mem_section[NR_SECTION_ROOTS][SECTIONS_PER_ROOT]
29
	____cacheline_internodealigned_in_smp;
30 31 32
#endif
EXPORT_SYMBOL(mem_section);

33 34 35 36 37 38 39 40 41 42 43 44
#ifdef NODE_NOT_IN_PAGE_FLAGS
/*
 * If we did not store the node number in the page then we have to
 * do a lookup in the section_to_node_table in order to find which
 * node the page belongs to.
 */
#if MAX_NUMNODES <= 256
static u8 section_to_node_table[NR_MEM_SECTIONS] __cacheline_aligned;
#else
static u16 section_to_node_table[NR_MEM_SECTIONS] __cacheline_aligned;
#endif

45
int page_to_nid(const struct page *page)
46 47 48 49
{
	return section_to_node_table[page_to_section(page)];
}
EXPORT_SYMBOL(page_to_nid);
50 51 52 53 54 55 56 57 58

static void set_section_nid(unsigned long section_nr, int nid)
{
	section_to_node_table[section_nr] = nid;
}
#else /* !NODE_NOT_IN_PAGE_FLAGS */
static inline void set_section_nid(unsigned long section_nr, int nid)
{
}
59 60
#endif

61
#ifdef CONFIG_SPARSEMEM_EXTREME
62
static struct mem_section noinline __init_refok *sparse_index_alloc(int nid)
63 64 65 66 67
{
	struct mem_section *section = NULL;
	unsigned long array_size = SECTIONS_PER_ROOT *
				   sizeof(struct mem_section);

68 69
	if (slab_is_available()) {
		if (node_state(nid, N_HIGH_MEMORY))
70
			section = kzalloc_node(array_size, GFP_KERNEL, nid);
71
		else
72 73
			section = kzalloc(array_size, GFP_KERNEL);
	} else {
74
		section = memblock_virt_alloc_node(array_size, nid);
75
	}
76 77

	return section;
78
}
Bob Picco's avatar
Bob Picco committed
79

80
static int __meminit sparse_index_init(unsigned long section_nr, int nid)
Bob Picco's avatar
Bob Picco committed
81
{
82 83
	unsigned long root = SECTION_NR_TO_ROOT(section_nr);
	struct mem_section *section;
Bob Picco's avatar
Bob Picco committed
84 85

	if (mem_section[root])
86
		return -EEXIST;
87

88
	section = sparse_index_alloc(nid);
89 90
	if (!section)
		return -ENOMEM;
91 92

	mem_section[root] = section;
93

94
	return 0;
95 96 97 98 99
}
#else /* !SPARSEMEM_EXTREME */
static inline int sparse_index_init(unsigned long section_nr, int nid)
{
	return 0;
Bob Picco's avatar
Bob Picco committed
100
}
101 102
#endif

103 104
/*
 * Although written for the SPARSEMEM_EXTREME case, this happens
105
 * to also work for the flat array case because
106 107 108 109 110 111 112
 * NR_SECTION_ROOTS==NR_MEM_SECTIONS.
 */
int __section_nr(struct mem_section* ms)
{
	unsigned long root_nr;
	struct mem_section* root;

113 114
	for (root_nr = 0; root_nr < NR_SECTION_ROOTS; root_nr++) {
		root = __nr_to_section(root_nr * SECTIONS_PER_ROOT);
115 116 117 118 119 120 121
		if (!root)
			continue;

		if ((ms >= root) && (ms < (root + SECTIONS_PER_ROOT)))
		     break;
	}

122 123
	VM_BUG_ON(root_nr == NR_SECTION_ROOTS);

124 125 126
	return (root_nr * SECTIONS_PER_ROOT) + (ms - root);
}

127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
/*
 * During early boot, before section_mem_map is used for an actual
 * mem_map, we use section_mem_map to store the section's NUMA
 * node.  This keeps us from having to use another data structure.  The
 * node information is cleared just before we store the real mem_map.
 */
static inline unsigned long sparse_encode_early_nid(int nid)
{
	return (nid << SECTION_NID_SHIFT);
}

static inline int sparse_early_nid(struct mem_section *section)
{
	return (section->section_mem_map >> SECTION_NID_SHIFT);
}

143 144 145
/* Validate the physical addressing limitations of the model */
void __meminit mminit_validate_memmodel_limits(unsigned long *start_pfn,
						unsigned long *end_pfn)
146
{
147
	unsigned long max_sparsemem_pfn = 1UL << (MAX_PHYSMEM_BITS-PAGE_SHIFT);
148

149 150 151 152
	/*
	 * Sanity checks - do not allow an architecture to pass
	 * in larger pfns than the maximum scope of sparsemem:
	 */
153 154 155 156 157 158 159
	if (*start_pfn > max_sparsemem_pfn) {
		mminit_dprintk(MMINIT_WARNING, "pfnvalidation",
			"Start of range %lu -> %lu exceeds SPARSEMEM max %lu\n",
			*start_pfn, *end_pfn, max_sparsemem_pfn);
		WARN_ON_ONCE(1);
		*start_pfn = max_sparsemem_pfn;
		*end_pfn = max_sparsemem_pfn;
160
	} else if (*end_pfn > max_sparsemem_pfn) {
161 162 163 164 165 166 167 168 169 170 171 172
		mminit_dprintk(MMINIT_WARNING, "pfnvalidation",
			"End of range %lu -> %lu exceeds SPARSEMEM max %lu\n",
			*start_pfn, *end_pfn, max_sparsemem_pfn);
		WARN_ON_ONCE(1);
		*end_pfn = max_sparsemem_pfn;
	}
}

/* Record a memory area against a node. */
void __init memory_present(int nid, unsigned long start, unsigned long end)
{
	unsigned long pfn;
173

174
	start &= PAGE_SECTION_MASK;
175
	mminit_validate_memmodel_limits(&start, &end);
176 177
	for (pfn = start; pfn < end; pfn += PAGES_PER_SECTION) {
		unsigned long section = pfn_to_section_nr(pfn);
Bob Picco's avatar
Bob Picco committed
178 179 180
		struct mem_section *ms;

		sparse_index_init(section, nid);
181
		set_section_nid(section, nid);
Bob Picco's avatar
Bob Picco committed
182 183 184

		ms = __nr_to_section(section);
		if (!ms->section_mem_map)
185 186
			ms->section_mem_map = sparse_encode_early_nid(nid) |
							SECTION_MARKED_PRESENT;
187 188 189 190 191 192 193 194 195 196 197 198 199
	}
}

/*
 * Only used by the i386 NUMA architecures, but relatively
 * generic code.
 */
unsigned long __init node_memmap_size_bytes(int nid, unsigned long start_pfn,
						     unsigned long end_pfn)
{
	unsigned long pfn;
	unsigned long nr_pages = 0;

200
	mminit_validate_memmodel_limits(&start_pfn, &end_pfn);
201 202 203 204
	for (pfn = start_pfn; pfn < end_pfn; pfn += PAGES_PER_SECTION) {
		if (nid != early_pfn_to_nid(pfn))
			continue;

205
		if (pfn_present(pfn))
206 207 208 209 210 211
			nr_pages += PAGES_PER_SECTION;
	}

	return nr_pages * sizeof(struct page);
}

212 213 214 215 216 217 218 219 220 221 222
/*
 * Subtle, we encode the real pfn into the mem_map such that
 * the identity pfn - section_mem_map will return the actual
 * physical page frame number.
 */
static unsigned long sparse_encode_mem_map(struct page *mem_map, unsigned long pnum)
{
	return (unsigned long)(mem_map - (section_nr_to_pfn(pnum)));
}

/*
223
 * Decode mem_map from the coded memmap
224 225 226
 */
struct page *sparse_decode_mem_map(unsigned long coded_mem_map, unsigned long pnum)
{
227 228
	/* mask off the extra low bits of information */
	coded_mem_map &= SECTION_MAP_MASK;
229 230 231
	return ((struct page *)coded_mem_map) + section_nr_to_pfn(pnum);
}

232
static int __meminit sparse_init_one_section(struct mem_section *ms,
233 234
		unsigned long pnum, struct page *mem_map,
		unsigned long *pageblock_bitmap)
235
{
236
	if (!present_section(ms))
237 238
		return -EINVAL;

239
	ms->section_mem_map &= ~SECTION_MAP_MASK;
240 241
	ms->section_mem_map |= sparse_encode_mem_map(mem_map, pnum) |
							SECTION_HAS_MEM_MAP;
242
 	ms->pageblock_flags = pageblock_bitmap;
243 244 245 246

	return 1;
}

247
unsigned long usemap_size(void)
248 249 250 251 252 253 254 255 256 257 258 259 260 261
{
	unsigned long size_bytes;
	size_bytes = roundup(SECTION_BLOCKFLAGS_BITS, 8) / 8;
	size_bytes = roundup(size_bytes, sizeof(unsigned long));
	return size_bytes;
}

#ifdef CONFIG_MEMORY_HOTPLUG
static unsigned long *__kmalloc_section_usemap(void)
{
	return kmalloc(usemap_size(), GFP_KERNEL);
}
#endif /* CONFIG_MEMORY_HOTPLUG */

262 263
#ifdef CONFIG_MEMORY_HOTREMOVE
static unsigned long * __init
264
sparse_early_usemaps_alloc_pgdat_section(struct pglist_data *pgdat,
265
					 unsigned long size)
266
{
267 268 269
	unsigned long goal, limit;
	unsigned long *p;
	int nid;
270 271 272
	/*
	 * A page may contain usemaps for other sections preventing the
	 * page being freed and making a section unremovable while
Li Zhong's avatar
Li Zhong committed
273
	 * other sections referencing the usemap remain active. Similarly,
274 275 276 277 278 279
	 * a pgdat can prevent a section being removed. If section A
	 * contains a pgdat and section B contains the usemap, both
	 * sections become inter-dependent. This allocates usemaps
	 * from the same section as the pgdat where possible to avoid
	 * this problem.
	 */
280
	goal = __pa(pgdat) & (PAGE_SECTION_MASK << PAGE_SHIFT);
281 282 283
	limit = goal + (1UL << PA_SECTION_SHIFT);
	nid = early_pfn_to_nid(goal >> PAGE_SHIFT);
again:
284 285 286
	p = memblock_virt_alloc_try_nid_nopanic(size,
						SMP_CACHE_BYTES, goal, limit,
						nid);
287 288 289 290 291
	if (!p && limit) {
		limit = 0;
		goto again;
	}
	return p;
292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315
}

static void __init check_usemap_section_nr(int nid, unsigned long *usemap)
{
	unsigned long usemap_snr, pgdat_snr;
	static unsigned long old_usemap_snr = NR_MEM_SECTIONS;
	static unsigned long old_pgdat_snr = NR_MEM_SECTIONS;
	struct pglist_data *pgdat = NODE_DATA(nid);
	int usemap_nid;

	usemap_snr = pfn_to_section_nr(__pa(usemap) >> PAGE_SHIFT);
	pgdat_snr = pfn_to_section_nr(__pa(pgdat) >> PAGE_SHIFT);
	if (usemap_snr == pgdat_snr)
		return;

	if (old_usemap_snr == usemap_snr && old_pgdat_snr == pgdat_snr)
		/* skip redundant message */
		return;

	old_usemap_snr = usemap_snr;
	old_pgdat_snr = pgdat_snr;

	usemap_nid = sparse_early_nid(__nr_to_section(usemap_snr));
	if (usemap_nid != nid) {
316 317
		pr_info("node %d must be removed before remove section %ld\n",
			nid, usemap_snr);
318 319 320 321 322 323 324 325
		return;
	}
	/*
	 * There is a circular dependency.
	 * Some platforms allow un-removable section because they will just
	 * gather other removable sections for dynamic partitioning.
	 * Just notify un-removable section's number here.
	 */
326 327
	pr_info("Section %ld and %ld (node %d) have a circular dependency on usemap and pgdat allocations\n",
		usemap_snr, pgdat_snr, nid);
328 329 330
}
#else
static unsigned long * __init
331
sparse_early_usemaps_alloc_pgdat_section(struct pglist_data *pgdat,
332
					 unsigned long size)
333
{
334
	return memblock_virt_alloc_node_nopanic(size, pgdat->node_id);
335 336 337 338 339 340 341
}

static void __init check_usemap_section_nr(int nid, unsigned long *usemap)
{
}
#endif /* CONFIG_MEMORY_HOTREMOVE */

342
static void __init sparse_early_usemaps_alloc_node(void *data,
343 344 345
				 unsigned long pnum_begin,
				 unsigned long pnum_end,
				 unsigned long usemap_count, int nodeid)
346
{
347 348
	void *usemap;
	unsigned long pnum;
349
	unsigned long **usemap_map = (unsigned long **)data;
350
	int size = usemap_size();
351

352
	usemap = sparse_early_usemaps_alloc_pgdat_section(NODE_DATA(nodeid),
353
							  size * usemap_count);
354
	if (!usemap) {
355
		pr_warn("%s: allocation failed\n", __func__);
356
		return;
357 358
	}

359 360 361 362 363 364
	for (pnum = pnum_begin; pnum < pnum_end; pnum++) {
		if (!present_section_nr(pnum))
			continue;
		usemap_map[pnum] = usemap;
		usemap += size;
		check_usemap_section_nr(nodeid, usemap_map[pnum]);
365
	}
366 367
}

368
#ifndef CONFIG_SPARSEMEM_VMEMMAP
369
struct page __init *sparse_mem_map_populate(unsigned long pnum, int nid)
370 371
{
	struct page *map;
372
	unsigned long size;
373 374 375 376 377

	map = alloc_remap(nid, sizeof(struct page) * PAGES_PER_SECTION);
	if (map)
		return map;

378
	size = PAGE_ALIGN(sizeof(struct page) * PAGES_PER_SECTION);
379 380 381
	map = memblock_virt_alloc_try_nid(size,
					  PAGE_SIZE, __pa(MAX_DMA_ADDRESS),
					  BOOTMEM_ALLOC_ACCESSIBLE, nid);
382 383
	return map;
}
384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404
void __init sparse_mem_maps_populate_node(struct page **map_map,
					  unsigned long pnum_begin,
					  unsigned long pnum_end,
					  unsigned long map_count, int nodeid)
{
	void *map;
	unsigned long pnum;
	unsigned long size = sizeof(struct page) * PAGES_PER_SECTION;

	map = alloc_remap(nodeid, size * map_count);
	if (map) {
		for (pnum = pnum_begin; pnum < pnum_end; pnum++) {
			if (!present_section_nr(pnum))
				continue;
			map_map[pnum] = map;
			map += size;
		}
		return;
	}

	size = PAGE_ALIGN(size);
405 406 407
	map = memblock_virt_alloc_try_nid(size * map_count,
					  PAGE_SIZE, __pa(MAX_DMA_ADDRESS),
					  BOOTMEM_ALLOC_ACCESSIBLE, nodeid);
408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427
	if (map) {
		for (pnum = pnum_begin; pnum < pnum_end; pnum++) {
			if (!present_section_nr(pnum))
				continue;
			map_map[pnum] = map;
			map += size;
		}
		return;
	}

	/* fallback */
	for (pnum = pnum_begin; pnum < pnum_end; pnum++) {
		struct mem_section *ms;

		if (!present_section_nr(pnum))
			continue;
		map_map[pnum] = sparse_mem_map_populate(pnum, nodeid);
		if (map_map[pnum])
			continue;
		ms = __nr_to_section(pnum);
428
		pr_err("%s: sparsemem memory map backing failed some memory will not be available\n",
Joe Perches's avatar
Joe Perches committed
429
		       __func__);
430 431 432
		ms->section_mem_map = 0;
	}
}
433 434
#endif /* !CONFIG_SPARSEMEM_VMEMMAP */

435
#ifdef CONFIG_SPARSEMEM_ALLOC_MEM_MAP_TOGETHER
436
static void __init sparse_early_mem_maps_alloc_node(void *data,
437 438 439 440
				 unsigned long pnum_begin,
				 unsigned long pnum_end,
				 unsigned long map_count, int nodeid)
{
441
	struct page **map_map = (struct page **)data;
442 443 444
	sparse_mem_maps_populate_node(map_map, pnum_begin, pnum_end,
					 map_count, nodeid);
}
445
#else
446
static struct page __init *sparse_early_mem_map_alloc(unsigned long pnum)
447 448 449 450 451
{
	struct page *map;
	struct mem_section *ms = __nr_to_section(pnum);
	int nid = sparse_early_nid(ms);

452
	map = sparse_mem_map_populate(pnum, nid);
453 454 455
	if (map)
		return map;

456
	pr_err("%s: sparsemem memory map backing failed some memory will not be available\n",
Joe Perches's avatar
Joe Perches committed
457
	       __func__);
Bob Picco's avatar
Bob Picco committed
458
	ms->section_mem_map = 0;
459 460
	return NULL;
}
461
#endif
462

463
void __weak __meminit vmemmap_populate_print_last(void)
464 465
{
}
466

467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
/**
 *  alloc_usemap_and_memmap - memory alloction for pageblock flags and vmemmap
 *  @map: usemap_map for pageblock flags or mmap_map for vmemmap
 */
static void __init alloc_usemap_and_memmap(void (*alloc_func)
					(void *, unsigned long, unsigned long,
					unsigned long, int), void *data)
{
	unsigned long pnum;
	unsigned long map_count;
	int nodeid_begin = 0;
	unsigned long pnum_begin = 0;

	for (pnum = 0; pnum < NR_MEM_SECTIONS; pnum++) {
		struct mem_section *ms;

		if (!present_section_nr(pnum))
			continue;
		ms = __nr_to_section(pnum);
		nodeid_begin = sparse_early_nid(ms);
		pnum_begin = pnum;
		break;
	}
	map_count = 1;
	for (pnum = pnum_begin + 1; pnum < NR_MEM_SECTIONS; pnum++) {
		struct mem_section *ms;
		int nodeid;

		if (!present_section_nr(pnum))
			continue;
		ms = __nr_to_section(pnum);
		nodeid = sparse_early_nid(ms);
		if (nodeid == nodeid_begin) {
			map_count++;
			continue;
		}
		/* ok, we need to take cake of from pnum_begin to pnum - 1*/
		alloc_func(data, pnum_begin, pnum,
						map_count, nodeid_begin);
		/* new start, update count etc*/
		nodeid_begin = nodeid;
		pnum_begin = pnum;
		map_count = 1;
	}
	/* ok, last chunk */
	alloc_func(data, pnum_begin, NR_MEM_SECTIONS,
						map_count, nodeid_begin);
}

516 517 518 519 520 521 522 523
/*
 * Allocate the accumulated non-linear sections, allocate a mem_map
 * for each and record the physical to section mapping.
 */
void __init sparse_init(void)
{
	unsigned long pnum;
	struct page *map;
524
	unsigned long *usemap;
525
	unsigned long **usemap_map;
526 527 528 529 530
	int size;
#ifdef CONFIG_SPARSEMEM_ALLOC_MEM_MAP_TOGETHER
	int size2;
	struct page **map_map;
#endif
531

532 533 534
	/* see include/linux/mmzone.h 'struct mem_section' definition */
	BUILD_BUG_ON(!is_power_of_2(sizeof(struct mem_section)));

535 536 537
	/* Setup pageblock_order for HUGETLB_PAGE_SIZE_VARIABLE */
	set_pageblock_order();

538 539 540 541 542 543
	/*
	 * map is using big page (aka 2M in x86 64 bit)
	 * usemap is less one page (aka 24 bytes)
	 * so alloc 2M (with 2M align) and 24 bytes in turn will
	 * make next 2M slip to one more 2M later.
	 * then in big system, the memory will have a lot of holes...
544
	 * here try to allocate 2M pages continuously.
545 546 547 548 549
	 *
	 * powerpc need to call sparse_init_one_section right after each
	 * sparse_early_mem_map_alloc, so allocate usemap_map at first.
	 */
	size = sizeof(unsigned long *) * NR_MEM_SECTIONS;
550
	usemap_map = memblock_virt_alloc(size, 0);
551 552
	if (!usemap_map)
		panic("can not allocate usemap_map\n");
553 554
	alloc_usemap_and_memmap(sparse_early_usemaps_alloc_node,
							(void *)usemap_map);
555

556 557
#ifdef CONFIG_SPARSEMEM_ALLOC_MEM_MAP_TOGETHER
	size2 = sizeof(struct page *) * NR_MEM_SECTIONS;
558
	map_map = memblock_virt_alloc(size2, 0);
559 560
	if (!map_map)
		panic("can not allocate map_map\n");
561 562
	alloc_usemap_and_memmap(sparse_early_mem_maps_alloc_node,
							(void *)map_map);
563 564
#endif

565 566
	for (pnum = 0; pnum < NR_MEM_SECTIONS; pnum++) {
		if (!present_section_nr(pnum))
567
			continue;
568

569
		usemap = usemap_map[pnum];
570 571 572
		if (!usemap)
			continue;

573 574 575
#ifdef CONFIG_SPARSEMEM_ALLOC_MEM_MAP_TOGETHER
		map = map_map[pnum];
#else
576
		map = sparse_early_mem_map_alloc(pnum);
577
#endif
578 579 580
		if (!map)
			continue;

581 582
		sparse_init_one_section(__nr_to_section(pnum), pnum, map,
								usemap);
583
	}
584

585 586
	vmemmap_populate_print_last();

587
#ifdef CONFIG_SPARSEMEM_ALLOC_MEM_MAP_TOGETHER
588
	memblock_free_early(__pa(map_map), size2);
589
#endif
590
	memblock_free_early(__pa(usemap_map), size);
591 592 593
}

#ifdef CONFIG_MEMORY_HOTPLUG
594
#ifdef CONFIG_SPARSEMEM_VMEMMAP
595
static inline struct page *kmalloc_section_memmap(unsigned long pnum, int nid)
596 597 598 599
{
	/* This will make the necessary allocations eventually. */
	return sparse_mem_map_populate(pnum, nid);
}
600
static void __kfree_section_memmap(struct page *memmap)
601
{
602
	unsigned long start = (unsigned long)memmap;
603
	unsigned long end = (unsigned long)(memmap + PAGES_PER_SECTION);
604 605

	vmemmap_free(start, end);
606
}
607
#ifdef CONFIG_MEMORY_HOTREMOVE
608
static void free_map_bootmem(struct page *memmap)
609
{
610
	unsigned long start = (unsigned long)memmap;
611
	unsigned long end = (unsigned long)(memmap + PAGES_PER_SECTION);
612 613

	vmemmap_free(start, end);
614
}
615
#endif /* CONFIG_MEMORY_HOTREMOVE */
616
#else
617
static struct page *__kmalloc_section_memmap(void)
618 619
{
	struct page *page, *ret;
620
	unsigned long memmap_size = sizeof(struct page) * PAGES_PER_SECTION;
621

622
	page = alloc_pages(GFP_KERNEL|__GFP_NOWARN, get_order(memmap_size));
623 624 625 626 627 628 629 630 631 632 633 634 635 636 637
	if (page)
		goto got_map_page;

	ret = vmalloc(memmap_size);
	if (ret)
		goto got_map_ptr;

	return NULL;
got_map_page:
	ret = (struct page *)pfn_to_kaddr(page_to_pfn(page));
got_map_ptr:

	return ret;
}

638
static inline struct page *kmalloc_section_memmap(unsigned long pnum, int nid)
639
{
640
	return __kmalloc_section_memmap();
641 642
}

643
static void __kfree_section_memmap(struct page *memmap)
644
{
645
	if (is_vmalloc_addr(memmap))
646 647 648
		vfree(memmap);
	else
		free_pages((unsigned long)memmap,
649
			   get_order(sizeof(struct page) * PAGES_PER_SECTION));
650
}
651

652
#ifdef CONFIG_MEMORY_HOTREMOVE
653
static void free_map_bootmem(struct page *memmap)
654 655
{
	unsigned long maps_section_nr, removing_section_nr, i;
656
	unsigned long magic, nr_pages;
657
	struct page *page = virt_to_page(memmap);
658

659 660 661
	nr_pages = PAGE_ALIGN(PAGES_PER_SECTION * sizeof(struct page))
		>> PAGE_SHIFT;

662
	for (i = 0; i < nr_pages; i++, page++) {
Andrea Arcangeli's avatar
Andrea Arcangeli committed
663
		magic = (unsigned long) page->lru.next;
664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681

		BUG_ON(magic == NODE_INFO);

		maps_section_nr = pfn_to_section_nr(page_to_pfn(page));
		removing_section_nr = page->private;

		/*
		 * When this function is called, the removing section is
		 * logical offlined state. This means all pages are isolated
		 * from page allocator. If removing section's memmap is placed
		 * on the same section, it must not be freed.
		 * If it is freed, page allocator may allocate it which will
		 * be removed physically soon.
		 */
		if (maps_section_nr != removing_section_nr)
			put_page_bootmem(page);
	}
}
682
#endif /* CONFIG_MEMORY_HOTREMOVE */
683
#endif /* CONFIG_SPARSEMEM_VMEMMAP */
684

685 686 687 688 689
/*
 * returns the number of sections whose mem_maps were properly
 * set.  If this is <=0, then that means that the passed-in
 * map was not consumed and must be freed.
 */
690
int __meminit sparse_add_one_section(struct zone *zone, unsigned long start_pfn)
691
{
692 693 694 695
	unsigned long section_nr = pfn_to_section_nr(start_pfn);
	struct pglist_data *pgdat = zone->zone_pgdat;
	struct mem_section *ms;
	struct page *memmap;
696
	unsigned long *usemap;
697 698
	unsigned long flags;
	int ret;
699

700 701 702 703
	/*
	 * no locking for this, because it does its own
	 * plus, it does a kmalloc
	 */
704 705 706
	ret = sparse_index_init(section_nr, pgdat->node_id);
	if (ret < 0 && ret != -EEXIST)
		return ret;
707
	memmap = kmalloc_section_memmap(section_nr, pgdat->node_id);
708 709
	if (!memmap)
		return -ENOMEM;
710
	usemap = __kmalloc_section_usemap();
711
	if (!usemap) {
712
		__kfree_section_memmap(memmap);
713 714
		return -ENOMEM;
	}
715 716

	pgdat_resize_lock(pgdat, &flags);
717

718 719 720 721 722
	ms = __pfn_to_section(start_pfn);
	if (ms->section_mem_map & SECTION_MARKED_PRESENT) {
		ret = -EEXIST;
		goto out;
	}
723

724
	memset(memmap, 0, sizeof(struct page) * PAGES_PER_SECTION);
725

726 727
	ms->section_mem_map |= SECTION_MARKED_PRESENT;

728
	ret = sparse_init_one_section(ms, section_nr, memmap, usemap);
729 730 731

out:
	pgdat_resize_unlock(pgdat, &flags);
732 733
	if (ret <= 0) {
		kfree(usemap);
734
		__kfree_section_memmap(memmap);
735
	}
736
	return ret;
737
}
738

739
#ifdef CONFIG_MEMORY_HOTREMOVE
740 741 742 743 744 745 746 747
#ifdef CONFIG_MEMORY_FAILURE
static void clear_hwpoisoned_pages(struct page *memmap, int nr_pages)
{
	int i;

	if (!memmap)
		return;

748
	for (i = 0; i < nr_pages; i++) {
749
		if (PageHWPoison(&memmap[i])) {
750
			atomic_long_sub(1, &num_poisoned_pages);
751 752 753 754 755 756 757 758 759 760
			ClearPageHWPoison(&memmap[i]);
		}
	}
}
#else
static inline void clear_hwpoisoned_pages(struct page *memmap, int nr_pages)
{
}
#endif

761 762 763 764 765 766 767 768 769 770 771 772 773 774
static void free_section_usemap(struct page *memmap, unsigned long *usemap)
{
	struct page *usemap_page;

	if (!usemap)
		return;

	usemap_page = virt_to_page(usemap);
	/*
	 * Check to see if allocation came from hot-plug-add
	 */
	if (PageSlab(usemap_page) || PageCompound(usemap_page)) {
		kfree(usemap);
		if (memmap)
775
			__kfree_section_memmap(memmap);
776 777 778 779 780 781 782 783
		return;
	}

	/*
	 * The usemap came from bootmem. This is packed with other usemaps
	 * on the section which has pgdat at boot time. Just keep it as is now.
	 */

784 785
	if (memmap)
		free_map_bootmem(memmap);
786 787
}

788 789
void sparse_remove_one_section(struct zone *zone, struct mem_section *ms,
		unsigned long map_offset)
790 791
{
	struct page *memmap = NULL;
792 793
	unsigned long *usemap = NULL, flags;
	struct pglist_data *pgdat = zone->zone_pgdat;
794

795
	pgdat_resize_lock(pgdat, &flags);
796 797 798 799 800 801 802
	if (ms->section_mem_map) {
		usemap = ms->pageblock_flags;
		memmap = sparse_decode_mem_map(ms->section_mem_map,
						__section_nr(ms));
		ms->section_mem_map = 0;
		ms->pageblock_flags = NULL;
	}
803
	pgdat_resize_unlock(pgdat, &flags);
804

805 806
	clear_hwpoisoned_pages(memmap + map_offset,
			PAGES_PER_SECTION - map_offset);
807 808
	free_section_usemap(memmap, usemap);
}
809 810
#endif /* CONFIG_MEMORY_HOTREMOVE */
#endif /* CONFIG_MEMORY_HOTPLUG */