memory.c 22 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
2
/*
3
 * Memory subsystem support
4 5 6 7 8 9 10 11 12 13 14 15 16
 *
 * Written by Matt Tolentino <matthew.e.tolentino@intel.com>
 *            Dave Hansen <haveblue@us.ibm.com>
 *
 * This file provides the necessary infrastructure to represent
 * a SPARSEMEM-memory-model system's physical memory in /sysfs.
 * All arch-independent code that assumes MEMORY_HOTPLUG requires
 * SPARSEMEM should be contained here, or in mm/memory_hotplug.c.
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/topology.h>
17
#include <linux/capability.h>
18 19 20 21
#include <linux/device.h>
#include <linux/memory.h>
#include <linux/memory_hotplug.h>
#include <linux/mm.h>
22
#include <linux/stat.h>
23
#include <linux/slab.h>
24

Arun Sharma's avatar
Arun Sharma committed
25
#include <linux/atomic.h>
26
#include <linux/uaccess.h>
27 28

#define MEMORY_CLASS_NAME	"memory"
29

30 31
#define to_memory_block(dev) container_of(dev, struct memory_block, dev)

32 33
static int sections_per_block;

34
static inline unsigned long base_memory_block_id(unsigned long section_nr)
35 36 37
{
	return section_nr / sections_per_block;
}
38

39
static inline unsigned long pfn_to_block_id(unsigned long pfn)
40 41 42 43
{
	return base_memory_block_id(pfn_to_section_nr(pfn));
}

44 45 46 47 48
static inline unsigned long phys_to_block_id(unsigned long phys)
{
	return pfn_to_block_id(PFN_DOWN(phys));
}

49 50 51
static int memory_subsys_online(struct device *dev);
static int memory_subsys_offline(struct device *dev);

52
static struct bus_type memory_subsys = {
53
	.name = MEMORY_CLASS_NAME,
54
	.dev_name = MEMORY_CLASS_NAME,
55 56
	.online = memory_subsys_online,
	.offline = memory_subsys_offline,
57 58
};

59
static BLOCKING_NOTIFIER_HEAD(memory_chain);
60

61
int register_memory_notifier(struct notifier_block *nb)
62
{
63
	return blocking_notifier_chain_register(&memory_chain, nb);
64
}
65
EXPORT_SYMBOL(register_memory_notifier);
66

67
void unregister_memory_notifier(struct notifier_block *nb)
68
{
69
	blocking_notifier_chain_unregister(&memory_chain, nb);
70
}
71
EXPORT_SYMBOL(unregister_memory_notifier);
72

73 74
static void memory_block_release(struct device *dev)
{
75
	struct memory_block *mem = to_memory_block(dev);
76 77 78 79

	kfree(mem);
}

80 81 82 83
unsigned long __weak memory_block_size_bytes(void)
{
	return MIN_MEMORY_BLOCK_SIZE;
}
84
EXPORT_SYMBOL_GPL(memory_block_size_bytes);
85

86
/*
87
 * Show the first physical section index (number) of this memory block.
88
 */
89 90
static ssize_t phys_index_show(struct device *dev,
			       struct device_attribute *attr, char *buf)
91
{
92
	struct memory_block *mem = to_memory_block(dev);
93 94 95 96 97 98
	unsigned long phys_index;

	phys_index = mem->start_section_nr / sections_per_block;
	return sprintf(buf, "%08lx\n", phys_index);
}

99
/*
100 101 102 103
 * Show whether the memory block is likely to be offlineable (or is already
 * offline). Once offline, the memory block could be removed. The return
 * value does, however, not indicate that there is a way to remove the
 * memory block.
104
 */
105 106
static ssize_t removable_show(struct device *dev, struct device_attribute *attr,
			      char *buf)
107
{
108
	struct memory_block *mem = to_memory_block(dev);
109 110
	unsigned long pfn;
	int ret = 1, i;
111

112 113 114
	if (mem->state != MEM_ONLINE)
		goto out;

115
	for (i = 0; i < sections_per_block; i++) {
116 117
		if (!present_section_nr(mem->start_section_nr + i))
			continue;
118
		pfn = section_nr_to_pfn(mem->start_section_nr + i);
119 120 121
		ret &= is_mem_section_removable(pfn, PAGES_PER_SECTION);
	}

122
out:
123 124 125
	return sprintf(buf, "%d\n", ret);
}

126 127 128
/*
 * online, offline, going offline, etc.
 */
129 130
static ssize_t state_show(struct device *dev, struct device_attribute *attr,
			  char *buf)
131
{
132
	struct memory_block *mem = to_memory_block(dev);
133 134 135 136 137 138 139
	ssize_t len = 0;

	/*
	 * We can probably put these states in a nice little array
	 * so that they're not open-coded
	 */
	switch (mem->state) {
140 141 142 143 144 145 146 147 148 149 150 151 152 153
	case MEM_ONLINE:
		len = sprintf(buf, "online\n");
		break;
	case MEM_OFFLINE:
		len = sprintf(buf, "offline\n");
		break;
	case MEM_GOING_OFFLINE:
		len = sprintf(buf, "going-offline\n");
		break;
	default:
		len = sprintf(buf, "ERROR-UNKNOWN-%ld\n",
				mem->state);
		WARN_ON(1);
		break;
154 155 156 157 158
	}

	return len;
}

159
int memory_notify(unsigned long val, void *v)
160
{
161
	return blocking_notifier_call_chain(&memory_chain, val, v);
162 163
}

164
/*
165 166 167
 * The probe routines leave the pages uninitialized, just as the bootmem code
 * does. Make sure we do not access them, but instead use only information from
 * within sections.
168
 */
169
static bool pages_correctly_probed(unsigned long start_pfn)
170
{
171 172
	unsigned long section_nr = pfn_to_section_nr(start_pfn);
	unsigned long section_nr_end = section_nr + sections_per_block;
173 174 175 176 177 178 179
	unsigned long pfn = start_pfn;

	/*
	 * memmap between sections is not contiguous except with
	 * SPARSEMEM_VMEMMAP. We lookup the page once per section
	 * and assume memmap is contiguous within each section
	 */
180
	for (; section_nr < section_nr_end; section_nr++) {
181 182 183
		if (WARN_ON_ONCE(!pfn_valid(pfn)))
			return false;

184
		if (!present_section_nr(section_nr)) {
185
			pr_warn("section %ld pfn[%lx, %lx) not present\n",
186 187 188
				section_nr, pfn, pfn + PAGES_PER_SECTION);
			return false;
		} else if (!valid_section_nr(section_nr)) {
189
			pr_warn("section %ld pfn[%lx, %lx) no valid memmap\n",
190 191 192
				section_nr, pfn, pfn + PAGES_PER_SECTION);
			return false;
		} else if (online_section_nr(section_nr)) {
193
			pr_warn("section %ld pfn[%lx, %lx) is already online\n",
194
				section_nr, pfn, pfn + PAGES_PER_SECTION);
195 196
			return false;
		}
197
		pfn += PAGES_PER_SECTION;
198 199 200 201 202
	}

	return true;
}

203 204 205 206 207
/*
 * MEMORY_HOTPLUG depends on SPARSEMEM in mm/Kconfig, so it is
 * OK to have direct references to sparsemem variables in here.
 */
static int
208 209
memory_block_action(unsigned long start_section_nr, unsigned long action,
		    int online_type)
210
{
211
	unsigned long start_pfn;
212
	unsigned long nr_pages = PAGES_PER_SECTION * sections_per_block;
213 214
	int ret;

215
	start_pfn = section_nr_to_pfn(start_section_nr);
216

217
	switch (action) {
218
	case MEM_ONLINE:
219
		if (!pages_correctly_probed(start_pfn))
220 221 222 223 224 225 226 227 228
			return -EBUSY;

		ret = online_pages(start_pfn, nr_pages, online_type);
		break;
	case MEM_OFFLINE:
		ret = offline_pages(start_pfn, nr_pages);
		break;
	default:
		WARN(1, KERN_WARNING "%s(%ld, %ld) unknown action: "
229
		     "%ld\n", __func__, start_section_nr, action, action);
230
		ret = -EINVAL;
231 232 233 234 235
	}

	return ret;
}

236
static int memory_block_change_state(struct memory_block *mem,
237
		unsigned long to_state, unsigned long from_state_req)
238
{
239
	int ret = 0;
240

241 242
	if (mem->state != from_state_req)
		return -EINVAL;
243

244 245 246
	if (to_state == MEM_OFFLINE)
		mem->state = MEM_GOING_OFFLINE;

247 248 249
	ret = memory_block_action(mem->start_section_nr, to_state,
				mem->online_type);

250
	mem->state = ret ? from_state_req : to_state;
251

252 253
	return ret;
}
254

255
/* The device lock serializes operations on memory_subsys_[online|offline] */
256 257
static int memory_subsys_online(struct device *dev)
{
258
	struct memory_block *mem = to_memory_block(dev);
259
	int ret;
260

261 262
	if (mem->state == MEM_ONLINE)
		return 0;
263

264
	/*
265
	 * If we are called from state_store(), online_type will be
266 267 268 269
	 * set >= 0 Otherwise we were called from the device online
	 * attribute and need to set the online_type.
	 */
	if (mem->online_type < 0)
270
		mem->online_type = MMOP_ONLINE_KEEP;
271

272
	ret = memory_block_change_state(mem, MEM_ONLINE, MEM_OFFLINE);
273

274 275
	/* clear online_type */
	mem->online_type = -1;
276 277 278 279 280

	return ret;
}

static int memory_subsys_offline(struct device *dev)
281
{
282
	struct memory_block *mem = to_memory_block(dev);
283

284 285
	if (mem->state == MEM_OFFLINE)
		return 0;
286

287 288 289 290
	/* Can't offline block with non-present sections */
	if (mem->section_count != sections_per_block)
		return -EINVAL;

291
	return memory_block_change_state(mem, MEM_OFFLINE, MEM_ONLINE);
292
}
293

294 295
static ssize_t state_store(struct device *dev, struct device_attribute *attr,
			   const char *buf, size_t count)
296
{
297
	struct memory_block *mem = to_memory_block(dev);
298
	int ret, online_type;
299

300 301 302
	ret = lock_device_hotplug_sysfs();
	if (ret)
		return ret;
303

304
	if (sysfs_streq(buf, "online_kernel"))
305
		online_type = MMOP_ONLINE_KERNEL;
306
	else if (sysfs_streq(buf, "online_movable"))
307
		online_type = MMOP_ONLINE_MOVABLE;
308
	else if (sysfs_streq(buf, "online"))
309
		online_type = MMOP_ONLINE_KEEP;
310
	else if (sysfs_streq(buf, "offline"))
311
		online_type = MMOP_OFFLINE;
312 313 314 315
	else {
		ret = -EINVAL;
		goto err;
	}
316 317

	switch (online_type) {
318 319 320
	case MMOP_ONLINE_KERNEL:
	case MMOP_ONLINE_MOVABLE:
	case MMOP_ONLINE_KEEP:
321
		/* mem->online_type is protected by device_hotplug_lock */
322 323 324
		mem->online_type = online_type;
		ret = device_online(&mem->dev);
		break;
325
	case MMOP_OFFLINE:
326 327 328 329
		ret = device_offline(&mem->dev);
		break;
	default:
		ret = -EINVAL; /* should never happen */
330 331
	}

332
err:
333
	unlock_device_hotplug();
334

335
	if (ret < 0)
336
		return ret;
337 338 339
	if (ret)
		return -EINVAL;

340 341 342 343 344 345 346 347 348 349 350 351
	return count;
}

/*
 * phys_device is a bad name for this.  What I really want
 * is a way to differentiate between memory ranges that
 * are part of physical devices that constitute
 * a complete removable unit or fru.
 * i.e. do these ranges belong to the same physical device,
 * s.t. if I offline all of these sections I can then
 * remove the physical device?
 */
352
static ssize_t phys_device_show(struct device *dev,
353
				struct device_attribute *attr, char *buf)
354
{
355
	struct memory_block *mem = to_memory_block(dev);
356 357 358
	return sprintf(buf, "%d\n", mem->phys_device);
}

359
#ifdef CONFIG_MEMORY_HOTREMOVE
360 361 362 363 364 365 366 367 368 369 370 371 372
static void print_allowed_zone(char *buf, int nid, unsigned long start_pfn,
		unsigned long nr_pages, int online_type,
		struct zone *default_zone)
{
	struct zone *zone;

	zone = zone_for_pfn_range(online_type, nid, start_pfn, nr_pages);
	if (zone != default_zone) {
		strcat(buf, " ");
		strcat(buf, zone->name);
	}
}

373
static ssize_t valid_zones_show(struct device *dev,
374 375 376
				struct device_attribute *attr, char *buf)
{
	struct memory_block *mem = to_memory_block(dev);
377
	unsigned long start_pfn = section_nr_to_pfn(mem->start_section_nr);
378
	unsigned long nr_pages = PAGES_PER_SECTION * sections_per_block;
379
	unsigned long valid_start_pfn, valid_end_pfn;
380
	struct zone *default_zone;
381
	int nid;
382

383 384 385 386 387
	/*
	 * Check the existing zone. Make sure that we do that only on the
	 * online nodes otherwise the page_zone is not reliable
	 */
	if (mem->state == MEM_ONLINE) {
388 389 390 391 392 393 394 395
		/*
		 * The block contains more than one zone can not be offlined.
		 * This can happen e.g. for ZONE_DMA and ZONE_DMA32
		 */
		if (!test_pages_in_a_zone(start_pfn, start_pfn + nr_pages,
					  &valid_start_pfn, &valid_end_pfn))
			return sprintf(buf, "none\n");
		start_pfn = valid_start_pfn;
396 397
		strcat(buf, page_zone(pfn_to_page(start_pfn))->name);
		goto out;
398 399
	}

400
	nid = mem->nid;
401 402
	default_zone = zone_for_pfn_range(MMOP_ONLINE_KEEP, nid, start_pfn, nr_pages);
	strcat(buf, default_zone->name);
403

404 405 406 407
	print_allowed_zone(buf, nid, start_pfn, nr_pages, MMOP_ONLINE_KERNEL,
			default_zone);
	print_allowed_zone(buf, nid, start_pfn, nr_pages, MMOP_ONLINE_MOVABLE,
			default_zone);
408
out:
409 410 411
	strcat(buf, "\n");

	return strlen(buf);
412
}
413
static DEVICE_ATTR_RO(valid_zones);
414 415
#endif

416 417 418 419
static DEVICE_ATTR_RO(phys_index);
static DEVICE_ATTR_RW(state);
static DEVICE_ATTR_RO(phys_device);
static DEVICE_ATTR_RO(removable);
420 421

/*
422
 * Show the memory block size (shared by all memory blocks).
423
 */
424 425
static ssize_t block_size_bytes_show(struct device *dev,
				     struct device_attribute *attr, char *buf)
426
{
427
	return sprintf(buf, "%lx\n", memory_block_size_bytes());
428 429
}

430
static DEVICE_ATTR_RO(block_size_bytes);
431

432 433 434 435
/*
 * Memory auto online policy.
 */

436 437
static ssize_t auto_online_blocks_show(struct device *dev,
				       struct device_attribute *attr, char *buf)
438 439 440 441 442 443 444
{
	if (memhp_auto_online)
		return sprintf(buf, "online\n");
	else
		return sprintf(buf, "offline\n");
}

445 446 447
static ssize_t auto_online_blocks_store(struct device *dev,
					struct device_attribute *attr,
					const char *buf, size_t count)
448 449 450 451 452 453 454 455 456 457 458
{
	if (sysfs_streq(buf, "online"))
		memhp_auto_online = true;
	else if (sysfs_streq(buf, "offline"))
		memhp_auto_online = false;
	else
		return -EINVAL;

	return count;
}

459
static DEVICE_ATTR_RW(auto_online_blocks);
460

461 462 463 464 465 466 467
/*
 * Some architectures will have custom drivers to do this, and
 * will not need to do it from userspace.  The fake hot-add code
 * as well as ppc64 will do all of their discovery in userspace
 * and will require this interface.
 */
#ifdef CONFIG_ARCH_MEMORY_PROBE
468 469
static ssize_t probe_store(struct device *dev, struct device_attribute *attr,
			   const char *buf, size_t count)
470 471
{
	u64 phys_addr;
472
	int nid, ret;
473
	unsigned long pages_per_block = PAGES_PER_SECTION * sections_per_block;
474

475 476 477
	ret = kstrtoull(buf, 0, &phys_addr);
	if (ret)
		return ret;
478

479 480 481
	if (phys_addr & ((pages_per_block << PAGE_SHIFT) - 1))
		return -EINVAL;

482 483
	ret = lock_device_hotplug_sysfs();
	if (ret)
484
		return ret;
485

486
	nid = memory_add_physaddr_to_nid(phys_addr);
487 488
	ret = __add_memory(nid, phys_addr,
			   MIN_MEMORY_BLOCK_SIZE * sections_per_block);
489

490 491
	if (ret)
		goto out;
492

493 494
	ret = count;
out:
495
	unlock_device_hotplug();
496
	return ret;
497 498
}

499
static DEVICE_ATTR_WO(probe);
500 501
#endif

502 503 504 505 506 507
#ifdef CONFIG_MEMORY_FAILURE
/*
 * Support for offlining pages of memory
 */

/* Soft offline a page */
508 509 510
static ssize_t soft_offline_page_store(struct device *dev,
				       struct device_attribute *attr,
				       const char *buf, size_t count)
511 512 513 514 515
{
	int ret;
	u64 pfn;
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;
516
	if (kstrtoull(buf, 0, &pfn) < 0)
517 518
		return -EINVAL;
	pfn >>= PAGE_SHIFT;
519
	ret = soft_offline_page(pfn, 0);
520 521 522 523
	return ret == 0 ? count : ret;
}

/* Forcibly offline a page, including killing processes. */
524 525 526
static ssize_t hard_offline_page_store(struct device *dev,
				       struct device_attribute *attr,
				       const char *buf, size_t count)
527 528 529 530 531
{
	int ret;
	u64 pfn;
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;
532
	if (kstrtoull(buf, 0, &pfn) < 0)
533 534
		return -EINVAL;
	pfn >>= PAGE_SHIFT;
535
	ret = memory_failure(pfn, 0);
536 537 538
	return ret ? ret : count;
}

539 540
static DEVICE_ATTR_WO(soft_offline_page);
static DEVICE_ATTR_WO(hard_offline_page);
541 542
#endif

543 544 545 546 547
/*
 * Note that phys_device is optional.  It is here to allow for
 * differentiation between which *physical* devices each
 * section belongs to...
 */
548 549 550 551
int __weak arch_get_memory_phys_device(unsigned long start_pfn)
{
	return 0;
}
552

553 554
/* A reference for the returned memory block device is acquired. */
static struct memory_block *find_memory_block_by_id(unsigned long block_id)
555
{
556
	struct device *dev;
557

558 559
	dev = subsys_find_device_by_id(&memory_subsys, block_id, NULL);
	return dev ? to_memory_block(dev) : NULL;
560 561
}

562 563 564 565 566 567
/*
 * For now, we have a linear search to go find the appropriate
 * memory_block corresponding to a particular phys_index. If
 * this gets to be a real problem, we can always use a radix
 * tree or something here.
 *
568
 * This could be made generic for all device subsystems.
569 570 571
 */
struct memory_block *find_memory_block(struct mem_section *section)
{
572 573 574
	unsigned long block_id = base_memory_block_id(__section_nr(section));

	return find_memory_block_by_id(block_id);
575 576
}

577 578 579 580 581
static struct attribute *memory_memblk_attrs[] = {
	&dev_attr_phys_index.attr,
	&dev_attr_state.attr,
	&dev_attr_phys_device.attr,
	&dev_attr_removable.attr,
582 583 584
#ifdef CONFIG_MEMORY_HOTREMOVE
	&dev_attr_valid_zones.attr,
#endif
585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602
	NULL
};

static struct attribute_group memory_memblk_attr_group = {
	.attrs = memory_memblk_attrs,
};

static const struct attribute_group *memory_memblk_attr_groups[] = {
	&memory_memblk_attr_group,
	NULL,
};

/*
 * register_memory - Setup a sysfs device for a memory block
 */
static
int register_memory(struct memory_block *memory)
{
603 604
	int ret;

605 606 607 608
	memory->dev.bus = &memory_subsys;
	memory->dev.id = memory->start_section_nr / sections_per_block;
	memory->dev.release = memory_block_release;
	memory->dev.groups = memory_memblk_attr_groups;
609
	memory->dev.offline = memory->state == MEM_OFFLINE;
610

611 612 613 614 615
	ret = device_register(&memory->dev);
	if (ret)
		put_device(&memory->dev);

	return ret;
616 617
}

618 619
static int init_memory_block(struct memory_block **memory,
			     unsigned long block_id, unsigned long state)
620
{
621
	struct memory_block *mem;
622 623 624
	unsigned long start_pfn;
	int ret = 0;

625
	mem = find_memory_block_by_id(block_id);
626 627 628 629
	if (mem) {
		put_device(&mem->dev);
		return -EEXIST;
	}
630
	mem = kzalloc(sizeof(*mem), GFP_KERNEL);
631 632 633
	if (!mem)
		return -ENOMEM;

634
	mem->start_section_nr = block_id * sections_per_block;
635
	mem->state = state;
636
	start_pfn = section_nr_to_pfn(mem->start_section_nr);
637
	mem->phys_device = arch_get_memory_phys_device(start_pfn);
638
	mem->nid = NUMA_NO_NODE;
639

640 641 642 643 644 645
	ret = register_memory(mem);

	*memory = mem;
	return ret;
}

646
static int add_memory_block(unsigned long base_section_nr)
647
{
648
	int ret, section_count = 0;
649
	struct memory_block *mem;
650
	unsigned long nr;
651

652 653 654
	for (nr = base_section_nr; nr < base_section_nr + sections_per_block;
	     nr++)
		if (present_section_nr(nr))
655
			section_count++;
656

657 658
	if (section_count == 0)
		return 0;
659 660
	ret = init_memory_block(&mem, base_memory_block_id(base_section_nr),
				MEM_ONLINE);
661 662 663 664
	if (ret)
		return ret;
	mem->section_count = section_count;
	return 0;
665 666
}

667 668 669 670 671 672 673 674 675 676
static void unregister_memory(struct memory_block *memory)
{
	if (WARN_ON_ONCE(memory->dev.bus != &memory_subsys))
		return;

	/* drop the ref. we got via find_memory_block() */
	put_device(&memory->dev);
	device_unregister(&memory->dev);
}

677
/*
678 679 680
 * Create memory block devices for the given memory area. Start and size
 * have to be aligned to memory block granularity. Memory block devices
 * will be initialized as offline.
681 682
 *
 * Called under device_hotplug_lock.
683
 */
684
int create_memory_block_devices(unsigned long start, unsigned long size)
685
{
686 687
	const unsigned long start_block_id = pfn_to_block_id(PFN_DOWN(start));
	unsigned long end_block_id = pfn_to_block_id(PFN_DOWN(start + size));
688
	struct memory_block *mem;
689 690
	unsigned long block_id;
	int ret = 0;
691

692 693 694
	if (WARN_ON_ONCE(!IS_ALIGNED(start, memory_block_size_bytes()) ||
			 !IS_ALIGNED(size, memory_block_size_bytes())))
		return -EINVAL;
695

696
	for (block_id = start_block_id; block_id != end_block_id; block_id++) {
697
		ret = init_memory_block(&mem, block_id, MEM_OFFLINE);
698
		if (ret)
699 700 701 702 703 704 705
			break;
		mem->section_count = sections_per_block;
	}
	if (ret) {
		end_block_id = block_id;
		for (block_id = start_block_id; block_id != end_block_id;
		     block_id++) {
706
			mem = find_memory_block_by_id(block_id);
707 708
			if (WARN_ON_ONCE(!mem))
				continue;
709 710 711
			mem->section_count = 0;
			unregister_memory(mem);
		}
712
	}
713
	return ret;
714 715
}

716 717 718 719
/*
 * Remove memory block devices for the given memory area. Start and size
 * have to be aligned to memory block granularity. Memory block devices
 * have to be offline.
720 721
 *
 * Called under device_hotplug_lock.
722 723
 */
void remove_memory_block_devices(unsigned long start, unsigned long size)
724
{
725 726
	const unsigned long start_block_id = pfn_to_block_id(PFN_DOWN(start));
	const unsigned long end_block_id = pfn_to_block_id(PFN_DOWN(start + size));
727
	struct memory_block *mem;
728
	unsigned long block_id;
729

730 731
	if (WARN_ON_ONCE(!IS_ALIGNED(start, memory_block_size_bytes()) ||
			 !IS_ALIGNED(size, memory_block_size_bytes())))
732 733
		return;

734
	for (block_id = start_block_id; block_id != end_block_id; block_id++) {
735
		mem = find_memory_block_by_id(block_id);
736 737 738 739
		if (WARN_ON_ONCE(!mem))
			continue;
		mem->section_count = 0;
		unregister_memory_block_under_nodes(mem);
740
		unregister_memory(mem);
741
	}
742 743
}

744 745 746 747 748 749
/* return true if the memory block is offlined, otherwise, return false */
bool is_memblock_offlined(struct memory_block *mem)
{
	return mem->state == MEM_OFFLINE;
}

750 751 752 753 754 755 756 757 758 759 760
static struct attribute *memory_root_attrs[] = {
#ifdef CONFIG_ARCH_MEMORY_PROBE
	&dev_attr_probe.attr,
#endif

#ifdef CONFIG_MEMORY_FAILURE
	&dev_attr_soft_offline_page.attr,
	&dev_attr_hard_offline_page.attr,
#endif

	&dev_attr_block_size_bytes.attr,
761
	&dev_attr_auto_online_blocks.attr,
762 763 764 765 766 767 768 769 770 771 772 773
	NULL
};

static struct attribute_group memory_root_attr_group = {
	.attrs = memory_root_attrs,
};

static const struct attribute_group *memory_root_attr_groups[] = {
	&memory_root_attr_group,
	NULL,
};

774
/*
775 776 777
 * Initialize the sysfs support for memory devices. At the time this function
 * is called, we cannot have concurrent creation/deletion of memory block
 * devices, the device_hotplug_lock is not needed.
778
 */
779
void __init memory_dev_init(void)
780 781
{
	int ret;
782
	unsigned long block_sz, nr;
783

784 785 786 787 788 789
	/* Validate the configured memory block size */
	block_sz = memory_block_size_bytes();
	if (!is_power_of_2(block_sz) || block_sz < MIN_MEMORY_BLOCK_SIZE)
		panic("Memory block size not suitable: 0x%lx\n", block_sz);
	sections_per_block = block_sz / MIN_MEMORY_BLOCK_SIZE;

790
	ret = subsys_system_register(&memory_subsys, memory_root_attr_groups);
791
	if (ret)
792
		panic("%s() failed to register subsystem: %d\n", __func__, ret);
793 794 795 796 797

	/*
	 * Create entries for memory sections that were found
	 * during boot and have been initialized
	 */
798 799
	for (nr = 0; nr <= __highest_present_section_nr;
	     nr += sections_per_block) {
800 801 802 803
		ret = add_memory_block(nr);
		if (ret)
			panic("%s() failed to add memory block: %d\n", __func__,
			      ret);
804 805
	}
}
806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830

/**
 * walk_memory_blocks - walk through all present memory blocks overlapped
 *			by the range [start, start + size)
 *
 * @start: start address of the memory range
 * @size: size of the memory range
 * @arg: argument passed to func
 * @func: callback for each memory section walked
 *
 * This function walks through all present memory blocks overlapped by the
 * range [start, start + size), calling func on each memory block.
 *
 * In case func() returns an error, walking is aborted and the error is
 * returned.
 */
int walk_memory_blocks(unsigned long start, unsigned long size,
		       void *arg, walk_memory_blocks_func_t func)
{
	const unsigned long start_block_id = phys_to_block_id(start);
	const unsigned long end_block_id = phys_to_block_id(start + size - 1);
	struct memory_block *mem;
	unsigned long block_id;
	int ret = 0;

831 832 833
	if (!size)
		return 0;

834
	for (block_id = start_block_id; block_id <= end_block_id; block_id++) {
835
		mem = find_memory_block_by_id(block_id);
836 837 838 839 840 841 842 843 844 845
		if (!mem)
			continue;

		ret = func(mem, arg);
		put_device(&mem->dev);
		if (ret)
			break;
	}
	return ret;
}
846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881

struct for_each_memory_block_cb_data {
	walk_memory_blocks_func_t func;
	void *arg;
};

static int for_each_memory_block_cb(struct device *dev, void *data)
{
	struct memory_block *mem = to_memory_block(dev);
	struct for_each_memory_block_cb_data *cb_data = data;

	return cb_data->func(mem, cb_data->arg);
}

/**
 * for_each_memory_block - walk through all present memory blocks
 *
 * @arg: argument passed to func
 * @func: callback for each memory block walked
 *
 * This function walks through all present memory blocks, calling func on
 * each memory block.
 *
 * In case func() returns an error, walking is aborted and the error is
 * returned.
 */
int for_each_memory_block(void *arg, walk_memory_blocks_func_t func)
{
	struct for_each_memory_block_cb_data cb_data = {
		.func = func,
		.arg = arg,
	};

	return bus_for_each_dev(&memory_subsys, NULL, &cb_data,
				for_each_memory_block_cb);
}