memory.c 20.2 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/mutex.h>
23
#include <linux/stat.h>
24
#include <linux/slab.h>
25

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

29
30
static DEFINE_MUTEX(mem_sysfs_mutex);

31
#define MEMORY_CLASS_NAME	"memory"
32

33
34
#define to_memory_block(dev) container_of(dev, struct memory_block, dev)

35
36
37
38
39
40
static int sections_per_block;

static inline int base_memory_block_id(int section_nr)
{
	return section_nr / sections_per_block;
}
41

42
43
44
static int memory_subsys_online(struct device *dev);
static int memory_subsys_offline(struct device *dev);

45
static struct bus_type memory_subsys = {
46
	.name = MEMORY_CLASS_NAME,
47
	.dev_name = MEMORY_CLASS_NAME,
48
49
	.online = memory_subsys_online,
	.offline = memory_subsys_offline,
50
51
};

52
static BLOCKING_NOTIFIER_HEAD(memory_chain);
53

54
int register_memory_notifier(struct notifier_block *nb)
55
{
56
	return blocking_notifier_chain_register(&memory_chain, nb);
57
}
58
EXPORT_SYMBOL(register_memory_notifier);
59

60
void unregister_memory_notifier(struct notifier_block *nb)
61
{
62
	blocking_notifier_chain_unregister(&memory_chain, nb);
63
}
64
EXPORT_SYMBOL(unregister_memory_notifier);
65

66
67
68
69
70
71
72
73
74
75
76
77
78
79
static ATOMIC_NOTIFIER_HEAD(memory_isolate_chain);

int register_memory_isolate_notifier(struct notifier_block *nb)
{
	return atomic_notifier_chain_register(&memory_isolate_chain, nb);
}
EXPORT_SYMBOL(register_memory_isolate_notifier);

void unregister_memory_isolate_notifier(struct notifier_block *nb)
{
	atomic_notifier_chain_unregister(&memory_isolate_chain, nb);
}
EXPORT_SYMBOL(unregister_memory_isolate_notifier);

80
81
static void memory_block_release(struct device *dev)
{
82
	struct memory_block *mem = to_memory_block(dev);
83
84
85
86

	kfree(mem);
}

87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
unsigned long __weak memory_block_size_bytes(void)
{
	return MIN_MEMORY_BLOCK_SIZE;
}

static unsigned long get_memory_block_size(void)
{
	unsigned long block_sz;

	block_sz = memory_block_size_bytes();

	/* Validate blk_sz is a power of 2 and not less than section size */
	if ((block_sz & (block_sz - 1)) || (block_sz < MIN_MEMORY_BLOCK_SIZE)) {
		WARN_ON(1);
		block_sz = MIN_MEMORY_BLOCK_SIZE;
	}

	return block_sz;
}

107
108
109
110
111
/*
 * use this as the physical section index that this memsection
 * uses.
 */

112
113
static ssize_t show_mem_start_phys_index(struct device *dev,
			struct device_attribute *attr, char *buf)
114
{
115
	struct memory_block *mem = to_memory_block(dev);
116
117
118
119
120
121
	unsigned long phys_index;

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

122
123
124
/*
 * Show whether the section of memory is likely to be hot-removable
 */
125
126
static ssize_t show_mem_removable(struct device *dev,
			struct device_attribute *attr, char *buf)
127
{
128
129
	unsigned long i, pfn;
	int ret = 1;
130
	struct memory_block *mem = to_memory_block(dev);
131

132
133
134
	if (mem->state != MEM_ONLINE)
		goto out;

135
	for (i = 0; i < sections_per_block; i++) {
136
137
		if (!present_section_nr(mem->start_section_nr + i))
			continue;
138
		pfn = section_nr_to_pfn(mem->start_section_nr + i);
139
140
141
		ret &= is_mem_section_removable(pfn, PAGES_PER_SECTION);
	}

142
out:
143
144
145
	return sprintf(buf, "%d\n", ret);
}

146
147
148
/*
 * online, offline, going offline, etc.
 */
149
150
static ssize_t show_mem_state(struct device *dev,
			struct device_attribute *attr, char *buf)
151
{
152
	struct memory_block *mem = to_memory_block(dev);
153
154
155
156
157
158
159
	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) {
160
161
162
163
164
165
166
167
168
169
170
171
172
173
	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;
174
175
176
177
178
	}

	return len;
}

179
int memory_notify(unsigned long val, void *v)
180
{
181
	return blocking_notifier_call_chain(&memory_chain, val, v);
182
183
}

184
185
186
187
188
int memory_isolate_notify(unsigned long val, void *v)
{
	return atomic_notifier_call_chain(&memory_isolate_chain, val, v);
}

189
190
191
192
/*
 * The probe routines leave the pages reserved, just as the bootmem code does.
 * Make sure they're still that way.
 */
193
static bool pages_correctly_reserved(unsigned long start_pfn)
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
{
	int i, j;
	struct page *page;
	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
	 */
	for (i = 0; i < sections_per_block; i++, pfn += PAGES_PER_SECTION) {
		if (WARN_ON_ONCE(!pfn_valid(pfn)))
			return false;
		page = pfn_to_page(pfn);

		for (j = 0; j < PAGES_PER_SECTION; j++) {
			if (PageReserved(page + j))
				continue;

			printk(KERN_WARNING "section number %ld page number %d "
				"not reserved, was it already online?\n",
				pfn_to_section_nr(pfn), j);

			return false;
		}
	}

	return true;
}

224
225
226
/*
 * MEMORY_HOTPLUG depends on SPARSEMEM in mm/Kconfig, so it is
 * OK to have direct references to sparsemem variables in here.
227
 * Must already be protected by mem_hotplug_begin().
228
229
 */
static int
230
memory_block_action(unsigned long phys_index, unsigned long action, int online_type)
231
{
232
	unsigned long start_pfn;
233
	unsigned long nr_pages = PAGES_PER_SECTION * sections_per_block;
234
235
	int ret;

236
	start_pfn = section_nr_to_pfn(phys_index);
237

238
	switch (action) {
239
240
241
242
243
244
245
246
247
248
249
250
251
	case MEM_ONLINE:
		if (!pages_correctly_reserved(start_pfn))
			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: "
		     "%ld\n", __func__, phys_index, action, action);
		ret = -EINVAL;
252
253
254
255
256
	}

	return ret;
}

257
static int memory_block_change_state(struct memory_block *mem,
258
		unsigned long to_state, unsigned long from_state_req)
259
{
260
	int ret = 0;
261

262
263
	if (mem->state != from_state_req)
		return -EINVAL;
264

265
266
267
	if (to_state == MEM_OFFLINE)
		mem->state = MEM_GOING_OFFLINE;

268
269
270
	ret = memory_block_action(mem->start_section_nr, to_state,
				mem->online_type);

271
	mem->state = ret ? from_state_req : to_state;
272

273
274
	return ret;
}
275

276
/* The device lock serializes operations on memory_subsys_[online|offline] */
277
278
static int memory_subsys_online(struct device *dev)
{
279
	struct memory_block *mem = to_memory_block(dev);
280
	int ret;
281

282
283
	if (mem->state == MEM_ONLINE)
		return 0;
284

285
286
287
288
289
290
	/*
	 * If we are called from store_mem_state(), online_type will be
	 * set >= 0 Otherwise we were called from the device online
	 * attribute and need to set the online_type.
	 */
	if (mem->online_type < 0)
291
		mem->online_type = MMOP_ONLINE_KEEP;
292

293
	/* Already under protection of mem_hotplug_begin() */
294
	ret = memory_block_change_state(mem, MEM_ONLINE, MEM_OFFLINE);
295

296
297
	/* clear online_type */
	mem->online_type = -1;
298
299
300
301
302

	return ret;
}

static int memory_subsys_offline(struct device *dev)
303
{
304
	struct memory_block *mem = to_memory_block(dev);
305

306
307
	if (mem->state == MEM_OFFLINE)
		return 0;
308

309
310
311
312
	/* Can't offline block with non-present sections */
	if (mem->section_count != sections_per_block)
		return -EINVAL;

313
	return memory_block_change_state(mem, MEM_OFFLINE, MEM_ONLINE);
314
}
315

316
static ssize_t
317
318
store_mem_state(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
319
{
320
	struct memory_block *mem = to_memory_block(dev);
321
	int ret, online_type;
322

323
324
325
	ret = lock_device_hotplug_sysfs();
	if (ret)
		return ret;
326

327
	if (sysfs_streq(buf, "online_kernel"))
328
		online_type = MMOP_ONLINE_KERNEL;
329
	else if (sysfs_streq(buf, "online_movable"))
330
		online_type = MMOP_ONLINE_MOVABLE;
331
	else if (sysfs_streq(buf, "online"))
332
		online_type = MMOP_ONLINE_KEEP;
333
	else if (sysfs_streq(buf, "offline"))
334
		online_type = MMOP_OFFLINE;
335
336
337
338
	else {
		ret = -EINVAL;
		goto err;
	}
339

340
341
342
343
344
345
346
347
348
	/*
	 * Memory hotplug needs to hold mem_hotplug_begin() for probe to find
	 * the correct memory block to online before doing device_online(dev),
	 * which will take dev->mutex.  Take the lock early to prevent an
	 * inversion, memory_subsys_online() callbacks will be implemented by
	 * assuming it's already protected.
	 */
	mem_hotplug_begin();

349
	switch (online_type) {
350
351
352
	case MMOP_ONLINE_KERNEL:
	case MMOP_ONLINE_MOVABLE:
	case MMOP_ONLINE_KEEP:
353
354
355
		mem->online_type = online_type;
		ret = device_online(&mem->dev);
		break;
356
	case MMOP_OFFLINE:
357
358
359
360
		ret = device_offline(&mem->dev);
		break;
	default:
		ret = -EINVAL; /* should never happen */
361
362
	}

363
	mem_hotplug_done();
364
err:
365
	unlock_device_hotplug();
366

367
	if (ret < 0)
368
		return ret;
369
370
371
	if (ret)
		return -EINVAL;

372
373
374
375
376
377
378
379
380
381
382
383
	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?
 */
384
385
static ssize_t show_phys_device(struct device *dev,
				struct device_attribute *attr, char *buf)
386
{
387
	struct memory_block *mem = to_memory_block(dev);
388
389
390
	return sprintf(buf, "%d\n", mem->phys_device);
}

391
#ifdef CONFIG_MEMORY_HOTREMOVE
392
393
394
395
396
397
398
399
400
401
402
403
404
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);
	}
}

405
406
407
408
static ssize_t show_valid_zones(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	struct memory_block *mem = to_memory_block(dev);
409
	unsigned long start_pfn = section_nr_to_pfn(mem->start_section_nr);
410
	unsigned long nr_pages = PAGES_PER_SECTION * sections_per_block;
411
	unsigned long valid_start_pfn, valid_end_pfn;
412
	struct zone *default_zone;
413
	int nid;
414

415
416
417
418
419
	/*
	 * 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))
420
421
		return sprintf(buf, "none\n");

422
423
	start_pfn = valid_start_pfn;
	nr_pages = valid_end_pfn - start_pfn;
424

425
426
427
428
429
430
431
	/*
	 * 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) {
		strcat(buf, page_zone(pfn_to_page(start_pfn))->name);
		goto out;
432
433
	}

434
	nid = pfn_to_nid(start_pfn);
435
436
	default_zone = zone_for_pfn_range(MMOP_ONLINE_KEEP, nid, start_pfn, nr_pages);
	strcat(buf, default_zone->name);
437

438
439
440
441
	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);
442
out:
443
444
445
	strcat(buf, "\n");

	return strlen(buf);
446
447
448
449
}
static DEVICE_ATTR(valid_zones, 0444, show_valid_zones, NULL);
#endif

450
451
452
453
static DEVICE_ATTR(phys_index, 0444, show_mem_start_phys_index, NULL);
static DEVICE_ATTR(state, 0644, show_mem_state, store_mem_state);
static DEVICE_ATTR(phys_device, 0444, show_phys_device, NULL);
static DEVICE_ATTR(removable, 0444, show_mem_removable, NULL);
454
455
456
457
458

/*
 * Block size attribute stuff
 */
static ssize_t
459
print_block_size(struct device *dev, struct device_attribute *attr,
460
		 char *buf)
461
{
462
	return sprintf(buf, "%lx\n", get_memory_block_size());
463
464
}

465
static DEVICE_ATTR(block_size_bytes, 0444, print_block_size, NULL);
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
/*
 * Memory auto online policy.
 */

static ssize_t
show_auto_online_blocks(struct device *dev, struct device_attribute *attr,
			char *buf)
{
	if (memhp_auto_online)
		return sprintf(buf, "online\n");
	else
		return sprintf(buf, "offline\n");
}

static ssize_t
store_auto_online_blocks(struct device *dev, struct device_attribute *attr,
			 const char *buf, size_t count)
{
	if (sysfs_streq(buf, "online"))
		memhp_auto_online = true;
	else if (sysfs_streq(buf, "offline"))
		memhp_auto_online = false;
	else
		return -EINVAL;

	return count;
}

static DEVICE_ATTR(auto_online_blocks, 0644, show_auto_online_blocks,
		   store_auto_online_blocks);

498
499
500
501
502
503
504
505
/*
 * 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
static ssize_t
506
memory_probe_store(struct device *dev, struct device_attribute *attr,
507
		   const char *buf, size_t count)
508
509
{
	u64 phys_addr;
510
	int nid, ret;
511
	unsigned long pages_per_block = PAGES_PER_SECTION * sections_per_block;
512

513
514
515
	ret = kstrtoull(buf, 0, &phys_addr);
	if (ret)
		return ret;
516

517
518
519
	if (phys_addr & ((pages_per_block << PAGE_SHIFT) - 1))
		return -EINVAL;

520
521
522
	nid = memory_add_physaddr_to_nid(phys_addr);
	ret = add_memory(nid, phys_addr,
			 MIN_MEMORY_BLOCK_SIZE * sections_per_block);
523

524
525
	if (ret)
		goto out;
526

527
528
529
	ret = count;
out:
	return ret;
530
531
}

532
static DEVICE_ATTR(probe, S_IWUSR, NULL, memory_probe_store);
533
534
#endif

535
536
537
538
539
540
541
#ifdef CONFIG_MEMORY_FAILURE
/*
 * Support for offlining pages of memory
 */

/* Soft offline a page */
static ssize_t
542
543
store_soft_offline_page(struct device *dev,
			struct device_attribute *attr,
544
			const char *buf, size_t count)
545
546
547
548
549
{
	int ret;
	u64 pfn;
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;
550
	if (kstrtoull(buf, 0, &pfn) < 0)
551
552
553
554
555
556
557
558
559
560
		return -EINVAL;
	pfn >>= PAGE_SHIFT;
	if (!pfn_valid(pfn))
		return -ENXIO;
	ret = soft_offline_page(pfn_to_page(pfn), 0);
	return ret == 0 ? count : ret;
}

/* Forcibly offline a page, including killing processes. */
static ssize_t
561
562
store_hard_offline_page(struct device *dev,
			struct device_attribute *attr,
563
			const char *buf, size_t count)
564
565
566
567
568
{
	int ret;
	u64 pfn;
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;
569
	if (kstrtoull(buf, 0, &pfn) < 0)
570
571
		return -EINVAL;
	pfn >>= PAGE_SHIFT;
572
	ret = memory_failure(pfn, 0);
573
574
575
	return ret ? ret : count;
}

576
577
static DEVICE_ATTR(soft_offline_page, S_IWUSR, NULL, store_soft_offline_page);
static DEVICE_ATTR(hard_offline_page, S_IWUSR, NULL, store_hard_offline_page);
578
579
#endif

580
581
582
583
584
/*
 * Note that phys_device is optional.  It is here to allow for
 * differentiation between which *physical* devices each
 * section belongs to...
 */
585
586
587
588
int __weak arch_get_memory_phys_device(unsigned long start_pfn)
{
	return 0;
}
589

590
591
592
593
/*
 * A reference for the returned object is held and the reference for the
 * hinted object is released.
 */
594
595
struct memory_block *find_memory_block_hinted(struct mem_section *section,
					      struct memory_block *hint)
596
{
597
	int block_id = base_memory_block_id(__section_nr(section));
598
599
	struct device *hintdev = hint ? &hint->dev : NULL;
	struct device *dev;
600

601
602
603
604
	dev = subsys_find_device_by_id(&memory_subsys, block_id, hintdev);
	if (hint)
		put_device(&hint->dev);
	if (!dev)
605
		return NULL;
606
	return to_memory_block(dev);
607
608
}

609
610
611
612
613
614
/*
 * 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.
 *
615
 * This could be made generic for all device subsystems.
616
617
618
619
620
621
 */
struct memory_block *find_memory_block(struct mem_section *section)
{
	return find_memory_block_hinted(section, NULL);
}

622
623
624
625
626
static struct attribute *memory_memblk_attrs[] = {
	&dev_attr_phys_index.attr,
	&dev_attr_state.attr,
	&dev_attr_phys_device.attr,
	&dev_attr_removable.attr,
627
628
629
#ifdef CONFIG_MEMORY_HOTREMOVE
	&dev_attr_valid_zones.attr,
#endif
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
	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)
{
	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;
652
	memory->dev.offline = memory->state == MEM_OFFLINE;
653

654
	return device_register(&memory->dev);
655
656
}

657
658
static int init_memory_block(struct memory_block **memory,
			     struct mem_section *section, unsigned long state)
659
{
660
	struct memory_block *mem;
661
	unsigned long start_pfn;
662
	int scn_nr;
663
664
	int ret = 0;

665
	mem = kzalloc(sizeof(*mem), GFP_KERNEL);
666
667
668
	if (!mem)
		return -ENOMEM;

669
	scn_nr = __section_nr(section);
670
671
672
	mem->start_section_nr =
			base_memory_block_id(scn_nr) * sections_per_block;
	mem->end_section_nr = mem->start_section_nr + sections_per_block - 1;
673
	mem->state = state;
674
	start_pfn = section_nr_to_pfn(mem->start_section_nr);
675
676
	mem->phys_device = arch_get_memory_phys_device(start_pfn);

677
678
679
680
681
682
	ret = register_memory(mem);

	*memory = mem;
	return ret;
}

683
static int add_memory_block(int base_section_nr)
684
{
685
686
	struct memory_block *mem;
	int i, ret, section_count = 0, section_nr;
687

688
689
690
691
692
693
694
695
	for (i = base_section_nr;
	     (i < base_section_nr + sections_per_block) && i < NR_MEM_SECTIONS;
	     i++) {
		if (!present_section_nr(i))
			continue;
		if (section_count == 0)
			section_nr = i;
		section_count++;
696
697
	}

698
699
700
701
702
703
704
	if (section_count == 0)
		return 0;
	ret = init_memory_block(&mem, __nr_to_section(section_nr), MEM_ONLINE);
	if (ret)
		return ret;
	mem->section_count = section_count;
	return 0;
705
706
}

707
708
709
710
711
712
/*
 * need an interface for the VM to add new memory regions,
 * but without onlining it.
 */
int register_new_memory(int nid, struct mem_section *section)
{
713
714
	int ret = 0;
	struct memory_block *mem;
715
716
717

	mutex_lock(&mem_sysfs_mutex);

718
719
720
721
722
723
724
725
	mem = find_memory_block(section);
	if (mem) {
		mem->section_count++;
		put_device(&mem->dev);
	} else {
		ret = init_memory_block(&mem, section, MEM_OFFLINE);
		if (ret)
			goto out;
726
		mem->section_count++;
727
728
729
730
731
732
	}

	if (mem->section_count == sections_per_block)
		ret = register_mem_sect_under_node(mem, nid);
out:
	mutex_unlock(&mem_sysfs_mutex);
733
	return ret;
734
735
736
737
738
739
740
741
742
}

#ifdef CONFIG_MEMORY_HOTREMOVE
static void
unregister_memory(struct memory_block *memory)
{
	BUG_ON(memory->dev.bus != &memory_subsys);

	/* drop the ref. we got in remove_memory_block() */
743
	put_device(&memory->dev);
744
745
746
	device_unregister(&memory->dev);
}

747
static int remove_memory_section(unsigned long node_id,
748
			       struct mem_section *section, int phys_device)
749
750
751
{
	struct memory_block *mem;

752
	mutex_lock(&mem_sysfs_mutex);
753
754
755
756
757

	/*
	 * Some users of the memory hotplug do not want/need memblock to
	 * track all sections. Skip over those.
	 */
758
	mem = find_memory_block(section);
759
760
761
	if (!mem)
		goto out_unlock;

762
	unregister_mem_sect_under_nodes(mem, __section_nr(section));
763
764

	mem->section_count--;
765
	if (mem->section_count == 0)
766
		unregister_memory(mem);
767
	else
768
		put_device(&mem->dev);
769

770
out_unlock:
771
	mutex_unlock(&mem_sysfs_mutex);
772
773
774
775
776
	return 0;
}

int unregister_memory_section(struct mem_section *section)
{
777
	if (!present_section(section))
778
779
		return -EINVAL;

780
	return remove_memory_section(0, section, 0);
781
}
782
#endif /* CONFIG_MEMORY_HOTREMOVE */
783

784
785
786
787
788
789
/* return true if the memory block is offlined, otherwise, return false */
bool is_memblock_offlined(struct memory_block *mem)
{
	return mem->state == MEM_OFFLINE;
}

790
791
792
793
794
795
796
797
798
799
800
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,
801
	&dev_attr_auto_online_blocks.attr,
802
803
804
805
806
807
808
809
810
811
812
813
	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,
};

814
815
816
817
818
819
820
/*
 * Initialize the sysfs support for memory devices...
 */
int __init memory_dev_init(void)
{
	unsigned int i;
	int ret;
821
	int err;
822
	unsigned long block_sz;
823

824
	ret = subsys_system_register(&memory_subsys, memory_root_attr_groups);
825
826
	if (ret)
		goto out;
827

828
829
830
	block_sz = get_memory_block_size();
	sections_per_block = block_sz / MIN_MEMORY_BLOCK_SIZE;

831
832
833
834
	/*
	 * Create entries for memory sections that were found
	 * during boot and have been initialized
	 */
835
	mutex_lock(&mem_sysfs_mutex);
836
	for (i = 0; i < NR_MEM_SECTIONS; i += sections_per_block) {
837
838
839
840
		/* Don't iterate over sections we know are !present: */
		if (i > __highest_present_section_nr)
			break;

841
		err = add_memory_block(i);
842
843
		if (!ret)
			ret = err;
844
	}
845
	mutex_unlock(&mem_sysfs_mutex);
846

847
848
out:
	if (ret)
849
		printk(KERN_ERR "%s() failed: %d\n", __func__, ret);
850
851
	return ret;
}