fe4b24f05f6ad0459c060489524289f352adfaec
[muen/linux.git] / drivers / base / memory.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Memory subsystem support
4  *
5  * Written by Matt Tolentino <matthew.e.tolentino@intel.com>
6  *            Dave Hansen <haveblue@us.ibm.com>
7  *
8  * This file provides the necessary infrastructure to represent
9  * a SPARSEMEM-memory-model system's physical memory in /sysfs.
10  * All arch-independent code that assumes MEMORY_HOTPLUG requires
11  * SPARSEMEM should be contained here, or in mm/memory_hotplug.c.
12  */
13
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/topology.h>
17 #include <linux/capability.h>
18 #include <linux/device.h>
19 #include <linux/memory.h>
20 #include <linux/memory_hotplug.h>
21 #include <linux/mm.h>
22 #include <linux/mutex.h>
23 #include <linux/stat.h>
24 #include <linux/slab.h>
25
26 #include <linux/atomic.h>
27 #include <linux/uaccess.h>
28
29 static DEFINE_MUTEX(mem_sysfs_mutex);
30
31 #define MEMORY_CLASS_NAME       "memory"
32
33 #define to_memory_block(dev) container_of(dev, struct memory_block, dev)
34
35 static int sections_per_block;
36
37 static inline int base_memory_block_id(int section_nr)
38 {
39         return section_nr / sections_per_block;
40 }
41
42 static int memory_subsys_online(struct device *dev);
43 static int memory_subsys_offline(struct device *dev);
44
45 static struct bus_type memory_subsys = {
46         .name = MEMORY_CLASS_NAME,
47         .dev_name = MEMORY_CLASS_NAME,
48         .online = memory_subsys_online,
49         .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 static ATOMIC_NOTIFIER_HEAD(memory_isolate_chain);
67
68 int register_memory_isolate_notifier(struct notifier_block *nb)
69 {
70         return atomic_notifier_chain_register(&memory_isolate_chain, nb);
71 }
72 EXPORT_SYMBOL(register_memory_isolate_notifier);
73
74 void unregister_memory_isolate_notifier(struct notifier_block *nb)
75 {
76         atomic_notifier_chain_unregister(&memory_isolate_chain, nb);
77 }
78 EXPORT_SYMBOL(unregister_memory_isolate_notifier);
79
80 static void memory_block_release(struct device *dev)
81 {
82         struct memory_block *mem = to_memory_block(dev);
83
84         kfree(mem);
85 }
86
87 unsigned long __weak memory_block_size_bytes(void)
88 {
89         return MIN_MEMORY_BLOCK_SIZE;
90 }
91
92 static unsigned long get_memory_block_size(void)
93 {
94         unsigned long block_sz;
95
96         block_sz = memory_block_size_bytes();
97
98         /* Validate blk_sz is a power of 2 and not less than section size */
99         if ((block_sz & (block_sz - 1)) || (block_sz < MIN_MEMORY_BLOCK_SIZE)) {
100                 WARN_ON(1);
101                 block_sz = MIN_MEMORY_BLOCK_SIZE;
102         }
103
104         return block_sz;
105 }
106
107 /*
108  * use this as the physical section index that this memsection
109  * uses.
110  */
111
112 static ssize_t show_mem_start_phys_index(struct device *dev,
113                         struct device_attribute *attr, char *buf)
114 {
115         struct memory_block *mem = to_memory_block(dev);
116         unsigned long phys_index;
117
118         phys_index = mem->start_section_nr / sections_per_block;
119         return sprintf(buf, "%08lx\n", phys_index);
120 }
121
122 /*
123  * Show whether the section of memory is likely to be hot-removable
124  */
125 static ssize_t show_mem_removable(struct device *dev,
126                         struct device_attribute *attr, char *buf)
127 {
128         unsigned long i, pfn;
129         int ret = 1;
130         struct memory_block *mem = to_memory_block(dev);
131
132         if (mem->state != MEM_ONLINE)
133                 goto out;
134
135         for (i = 0; i < sections_per_block; i++) {
136                 if (!present_section_nr(mem->start_section_nr + i))
137                         continue;
138                 pfn = section_nr_to_pfn(mem->start_section_nr + i);
139                 ret &= is_mem_section_removable(pfn, PAGES_PER_SECTION);
140         }
141
142 out:
143         return sprintf(buf, "%d\n", ret);
144 }
145
146 /*
147  * online, offline, going offline, etc.
148  */
149 static ssize_t show_mem_state(struct device *dev,
150                         struct device_attribute *attr, char *buf)
151 {
152         struct memory_block *mem = to_memory_block(dev);
153         ssize_t len = 0;
154
155         /*
156          * We can probably put these states in a nice little array
157          * so that they're not open-coded
158          */
159         switch (mem->state) {
160         case MEM_ONLINE:
161                 len = sprintf(buf, "online\n");
162                 break;
163         case MEM_OFFLINE:
164                 len = sprintf(buf, "offline\n");
165                 break;
166         case MEM_GOING_OFFLINE:
167                 len = sprintf(buf, "going-offline\n");
168                 break;
169         default:
170                 len = sprintf(buf, "ERROR-UNKNOWN-%ld\n",
171                                 mem->state);
172                 WARN_ON(1);
173                 break;
174         }
175
176         return len;
177 }
178
179 int memory_notify(unsigned long val, void *v)
180 {
181         return blocking_notifier_call_chain(&memory_chain, val, v);
182 }
183
184 int memory_isolate_notify(unsigned long val, void *v)
185 {
186         return atomic_notifier_call_chain(&memory_isolate_chain, val, v);
187 }
188
189 /*
190  * The probe routines leave the pages reserved, just as the bootmem code does.
191  * Make sure they're still that way.
192  */
193 static bool pages_correctly_reserved(unsigned long start_pfn)
194 {
195         int i, j;
196         struct page *page;
197         unsigned long pfn = start_pfn;
198
199         /*
200          * memmap between sections is not contiguous except with
201          * SPARSEMEM_VMEMMAP. We lookup the page once per section
202          * and assume memmap is contiguous within each section
203          */
204         for (i = 0; i < sections_per_block; i++, pfn += PAGES_PER_SECTION) {
205                 if (WARN_ON_ONCE(!pfn_valid(pfn)))
206                         return false;
207                 page = pfn_to_page(pfn);
208
209                 for (j = 0; j < PAGES_PER_SECTION; j++) {
210                         if (PageReserved(page + j))
211                                 continue;
212
213                         printk(KERN_WARNING "section number %ld page number %d "
214                                 "not reserved, was it already online?\n",
215                                 pfn_to_section_nr(pfn), j);
216
217                         return false;
218                 }
219         }
220
221         return true;
222 }
223
224 /*
225  * MEMORY_HOTPLUG depends on SPARSEMEM in mm/Kconfig, so it is
226  * 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         int ret;
235
236         start_pfn = section_nr_to_pfn(phys_index);
237
238         switch (action) {
239         case MEM_ONLINE:
240                 if (!pages_correctly_reserved(start_pfn))
241                         return -EBUSY;
242
243                 ret = online_pages(start_pfn, nr_pages, online_type);
244                 break;
245         case MEM_OFFLINE:
246                 ret = offline_pages(start_pfn, nr_pages);
247                 break;
248         default:
249                 WARN(1, KERN_WARNING "%s(%ld, %ld) unknown action: "
250                      "%ld\n", __func__, phys_index, action, action);
251                 ret = -EINVAL;
252         }
253
254         return ret;
255 }
256
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         if (mem->state != from_state_req)
263                 return -EINVAL;
264
265         if (to_state == MEM_OFFLINE)
266                 mem->state = MEM_GOING_OFFLINE;
267
268         ret = memory_block_action(mem->start_section_nr, to_state,
269                                 mem->online_type);
270
271         mem->state = ret ? from_state_req : to_state;
272
273         return ret;
274 }
275
276 /* The device lock serializes operations on memory_subsys_[online|offline] */
277 static int memory_subsys_online(struct device *dev)
278 {
279         struct memory_block *mem = to_memory_block(dev);
280         int ret;
281
282         if (mem->state == MEM_ONLINE)
283                 return 0;
284
285         /*
286          * If we are called from store_mem_state(), online_type will be
287          * set >= 0 Otherwise we were called from the device online
288          * attribute and need to set the online_type.
289          */
290         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         /* clear online_type */
297         mem->online_type = -1;
298
299         return ret;
300 }
301
302 static int memory_subsys_offline(struct device *dev)
303 {
304         struct memory_block *mem = to_memory_block(dev);
305
306         if (mem->state == MEM_OFFLINE)
307                 return 0;
308
309         /* Can't offline block with non-present sections */
310         if (mem->section_count != sections_per_block)
311                 return -EINVAL;
312
313         return memory_block_change_state(mem, MEM_OFFLINE, MEM_ONLINE);
314 }
315
316 static ssize_t
317 store_mem_state(struct device *dev,
318                 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         ret = lock_device_hotplug_sysfs();
324         if (ret)
325                 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         else {
336                 ret = -EINVAL;
337                 goto err;
338         }
339
340         /*
341          * Memory hotplug needs to hold mem_hotplug_begin() for probe to find
342          * the correct memory block to online before doing device_online(dev),
343          * which will take dev->mutex.  Take the lock early to prevent an
344          * inversion, memory_subsys_online() callbacks will be implemented by
345          * assuming it's already protected.
346          */
347         mem_hotplug_begin();
348
349         switch (online_type) {
350         case MMOP_ONLINE_KERNEL:
351         case MMOP_ONLINE_MOVABLE:
352         case MMOP_ONLINE_KEEP:
353                 mem->online_type = online_type;
354                 ret = device_online(&mem->dev);
355                 break;
356         case MMOP_OFFLINE:
357                 ret = device_offline(&mem->dev);
358                 break;
359         default:
360                 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         if (ret)
370                 return -EINVAL;
371
372         return count;
373 }
374
375 /*
376  * phys_device is a bad name for this.  What I really want
377  * is a way to differentiate between memory ranges that
378  * are part of physical devices that constitute
379  * a complete removable unit or fru.
380  * i.e. do these ranges belong to the same physical device,
381  * s.t. if I offline all of these sections I can then
382  * remove the physical device?
383  */
384 static ssize_t show_phys_device(struct device *dev,
385                                 struct device_attribute *attr, char *buf)
386 {
387         struct memory_block *mem = to_memory_block(dev);
388         return sprintf(buf, "%d\n", mem->phys_device);
389 }
390
391 #ifdef CONFIG_MEMORY_HOTREMOVE
392 static void print_allowed_zone(char *buf, int nid, unsigned long start_pfn,
393                 unsigned long nr_pages, int online_type,
394                 struct zone *default_zone)
395 {
396         struct zone *zone;
397
398         zone = zone_for_pfn_range(online_type, nid, start_pfn, nr_pages);
399         if (zone != default_zone) {
400                 strcat(buf, " ");
401                 strcat(buf, zone->name);
402         }
403 }
404
405 static ssize_t show_valid_zones(struct device *dev,
406                                 struct device_attribute *attr, char *buf)
407 {
408         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          * The block contains more than one zone can not be offlined.
417          * This can happen e.g. for ZONE_DMA and ZONE_DMA32
418          */
419         if (!test_pages_in_a_zone(start_pfn, start_pfn + nr_pages, &valid_start_pfn, &valid_end_pfn))
420                 return sprintf(buf, "none\n");
421
422         start_pfn = valid_start_pfn;
423         nr_pages = valid_end_pfn - start_pfn;
424
425         /*
426          * Check the existing zone. Make sure that we do that only on the
427          * online nodes otherwise the page_zone is not reliable
428          */
429         if (mem->state == MEM_ONLINE) {
430                 strcat(buf, page_zone(pfn_to_page(start_pfn))->name);
431                 goto out;
432         }
433
434         nid = pfn_to_nid(start_pfn);
435         default_zone = zone_for_pfn_range(MMOP_ONLINE_KEEP, nid, start_pfn, nr_pages);
436         strcat(buf, default_zone->name);
437
438         print_allowed_zone(buf, nid, start_pfn, nr_pages, MMOP_ONLINE_KERNEL,
439                         default_zone);
440         print_allowed_zone(buf, nid, start_pfn, nr_pages, MMOP_ONLINE_MOVABLE,
441                         default_zone);
442 out:
443         strcat(buf, "\n");
444
445         return strlen(buf);
446 }
447 static DEVICE_ATTR(valid_zones, 0444, show_valid_zones, NULL);
448 #endif
449
450 static DEVICE_ATTR(phys_index, 0444, show_mem_start_phys_index, NULL);
451 static DEVICE_ATTR(state, 0644, show_mem_state, store_mem_state);
452 static DEVICE_ATTR(phys_device, 0444, show_phys_device, NULL);
453 static DEVICE_ATTR(removable, 0444, show_mem_removable, NULL);
454
455 /*
456  * Block size attribute stuff
457  */
458 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  * Memory auto online policy.
469  */
470
471 static ssize_t
472 show_auto_online_blocks(struct device *dev, struct device_attribute *attr,
473                         char *buf)
474 {
475         if (memhp_auto_online)
476                 return sprintf(buf, "online\n");
477         else
478                 return sprintf(buf, "offline\n");
479 }
480
481 static ssize_t
482 store_auto_online_blocks(struct device *dev, struct device_attribute *attr,
483                          const char *buf, size_t count)
484 {
485         if (sysfs_streq(buf, "online"))
486                 memhp_auto_online = true;
487         else if (sysfs_streq(buf, "offline"))
488                 memhp_auto_online = false;
489         else
490                 return -EINVAL;
491
492         return count;
493 }
494
495 static DEVICE_ATTR(auto_online_blocks, 0644, show_auto_online_blocks,
496                    store_auto_online_blocks);
497
498 /*
499  * Some architectures will have custom drivers to do this, and
500  * will not need to do it from userspace.  The fake hot-add code
501  * as well as ppc64 will do all of their discovery in userspace
502  * and will require this interface.
503  */
504 #ifdef CONFIG_ARCH_MEMORY_PROBE
505 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         ret = kstrtoull(buf, 0, &phys_addr);
514         if (ret)
515                 return ret;
516
517         if (phys_addr & ((pages_per_block << PAGE_SHIFT) - 1))
518                 return -EINVAL;
519
520         nid = memory_add_physaddr_to_nid(phys_addr);
521         ret = add_memory(nid, phys_addr,
522                          MIN_MEMORY_BLOCK_SIZE * sections_per_block);
523
524         if (ret)
525                 goto out;
526
527         ret = count;
528 out:
529         return ret;
530 }
531
532 static DEVICE_ATTR(probe, S_IWUSR, NULL, memory_probe_store);
533 #endif
534
535 #ifdef CONFIG_MEMORY_FAILURE
536 /*
537  * Support for offlining pages of memory
538  */
539
540 /* Soft offline a page */
541 static ssize_t
542 store_soft_offline_page(struct device *dev,
543                         struct device_attribute *attr,
544                         const char *buf, size_t count)
545 {
546         int ret;
547         u64 pfn;
548         if (!capable(CAP_SYS_ADMIN))
549                 return -EPERM;
550         if (kstrtoull(buf, 0, &pfn) < 0)
551                 return -EINVAL;
552         pfn >>= PAGE_SHIFT;
553         if (!pfn_valid(pfn))
554                 return -ENXIO;
555         ret = soft_offline_page(pfn_to_page(pfn), 0);
556         return ret == 0 ? count : ret;
557 }
558
559 /* Forcibly offline a page, including killing processes. */
560 static ssize_t
561 store_hard_offline_page(struct device *dev,
562                         struct device_attribute *attr,
563                         const char *buf, size_t count)
564 {
565         int ret;
566         u64 pfn;
567         if (!capable(CAP_SYS_ADMIN))
568                 return -EPERM;
569         if (kstrtoull(buf, 0, &pfn) < 0)
570                 return -EINVAL;
571         pfn >>= PAGE_SHIFT;
572         ret = memory_failure(pfn, 0);
573         return ret ? ret : count;
574 }
575
576 static DEVICE_ATTR(soft_offline_page, S_IWUSR, NULL, store_soft_offline_page);
577 static DEVICE_ATTR(hard_offline_page, S_IWUSR, NULL, store_hard_offline_page);
578 #endif
579
580 /*
581  * Note that phys_device is optional.  It is here to allow for
582  * differentiation between which *physical* devices each
583  * section belongs to...
584  */
585 int __weak arch_get_memory_phys_device(unsigned long start_pfn)
586 {
587         return 0;
588 }
589
590 /*
591  * A reference for the returned object is held and the reference for the
592  * hinted object is released.
593  */
594 struct memory_block *find_memory_block_hinted(struct mem_section *section,
595                                               struct memory_block *hint)
596 {
597         int block_id = base_memory_block_id(__section_nr(section));
598         struct device *hintdev = hint ? &hint->dev : NULL;
599         struct device *dev;
600
601         dev = subsys_find_device_by_id(&memory_subsys, block_id, hintdev);
602         if (hint)
603                 put_device(&hint->dev);
604         if (!dev)
605                 return NULL;
606         return to_memory_block(dev);
607 }
608
609 /*
610  * For now, we have a linear search to go find the appropriate
611  * memory_block corresponding to a particular phys_index. If
612  * this gets to be a real problem, we can always use a radix
613  * tree or something here.
614  *
615  * This could be made generic for all device subsystems.
616  */
617 struct memory_block *find_memory_block(struct mem_section *section)
618 {
619         return find_memory_block_hinted(section, NULL);
620 }
621
622 static struct attribute *memory_memblk_attrs[] = {
623         &dev_attr_phys_index.attr,
624         &dev_attr_state.attr,
625         &dev_attr_phys_device.attr,
626         &dev_attr_removable.attr,
627 #ifdef CONFIG_MEMORY_HOTREMOVE
628         &dev_attr_valid_zones.attr,
629 #endif
630         NULL
631 };
632
633 static struct attribute_group memory_memblk_attr_group = {
634         .attrs = memory_memblk_attrs,
635 };
636
637 static const struct attribute_group *memory_memblk_attr_groups[] = {
638         &memory_memblk_attr_group,
639         NULL,
640 };
641
642 /*
643  * register_memory - Setup a sysfs device for a memory block
644  */
645 static
646 int register_memory(struct memory_block *memory)
647 {
648         memory->dev.bus = &memory_subsys;
649         memory->dev.id = memory->start_section_nr / sections_per_block;
650         memory->dev.release = memory_block_release;
651         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 static int init_memory_block(struct memory_block **memory,
658                              struct mem_section *section, unsigned long state)
659 {
660         struct memory_block *mem;
661         unsigned long start_pfn;
662         int scn_nr;
663         int ret = 0;
664
665         mem = kzalloc(sizeof(*mem), GFP_KERNEL);
666         if (!mem)
667                 return -ENOMEM;
668
669         scn_nr = __section_nr(section);
670         mem->start_section_nr =
671                         base_memory_block_id(scn_nr) * sections_per_block;
672         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         mem->phys_device = arch_get_memory_phys_device(start_pfn);
676
677         ret = register_memory(mem);
678
679         *memory = mem;
680         return ret;
681 }
682
683 static int add_memory_block(int base_section_nr)
684 {
685         struct memory_block *mem;
686         int i, ret, section_count = 0, section_nr;
687
688         for (i = base_section_nr;
689              (i < base_section_nr + sections_per_block) && i < NR_MEM_SECTIONS;
690              i++) {
691                 if (!present_section_nr(i))
692                         continue;
693                 if (section_count == 0)
694                         section_nr = i;
695                 section_count++;
696         }
697
698         if (section_count == 0)
699                 return 0;
700         ret = init_memory_block(&mem, __nr_to_section(section_nr), MEM_ONLINE);
701         if (ret)
702                 return ret;
703         mem->section_count = section_count;
704         return 0;
705 }
706
707 /*
708  * need an interface for the VM to add new memory regions,
709  * but without onlining it.
710  */
711 int register_new_memory(int nid, struct mem_section *section)
712 {
713         int ret = 0;
714         struct memory_block *mem;
715
716         mutex_lock(&mem_sysfs_mutex);
717
718         mem = find_memory_block(section);
719         if (mem) {
720                 mem->section_count++;
721                 put_device(&mem->dev);
722         } else {
723                 ret = init_memory_block(&mem, section, MEM_OFFLINE);
724                 if (ret)
725                         goto out;
726                 mem->section_count++;
727         }
728
729         if (mem->section_count == sections_per_block)
730                 ret = register_mem_sect_under_node(mem, nid);
731 out:
732         mutex_unlock(&mem_sysfs_mutex);
733         return ret;
734 }
735
736 #ifdef CONFIG_MEMORY_HOTREMOVE
737 static void
738 unregister_memory(struct memory_block *memory)
739 {
740         BUG_ON(memory->dev.bus != &memory_subsys);
741
742         /* drop the ref. we got in remove_memory_block() */
743         put_device(&memory->dev);
744         device_unregister(&memory->dev);
745 }
746
747 static int remove_memory_section(unsigned long node_id,
748                                struct mem_section *section, int phys_device)
749 {
750         struct memory_block *mem;
751
752         mutex_lock(&mem_sysfs_mutex);
753
754         /*
755          * Some users of the memory hotplug do not want/need memblock to
756          * track all sections. Skip over those.
757          */
758         mem = find_memory_block(section);
759         if (!mem)
760                 goto out_unlock;
761
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         return 0;
773 }
774
775 int unregister_memory_section(struct mem_section *section)
776 {
777         if (!present_section(section))
778                 return -EINVAL;
779
780         return remove_memory_section(0, section, 0);
781 }
782 #endif /* CONFIG_MEMORY_HOTREMOVE */
783
784 /* return true if the memory block is offlined, otherwise, return false */
785 bool is_memblock_offlined(struct memory_block *mem)
786 {
787         return mem->state == MEM_OFFLINE;
788 }
789
790 static struct attribute *memory_root_attrs[] = {
791 #ifdef CONFIG_ARCH_MEMORY_PROBE
792         &dev_attr_probe.attr,
793 #endif
794
795 #ifdef CONFIG_MEMORY_FAILURE
796         &dev_attr_soft_offline_page.attr,
797         &dev_attr_hard_offline_page.attr,
798 #endif
799
800         &dev_attr_block_size_bytes.attr,
801         &dev_attr_auto_online_blocks.attr,
802         NULL
803 };
804
805 static struct attribute_group memory_root_attr_group = {
806         .attrs = memory_root_attrs,
807 };
808
809 static const struct attribute_group *memory_root_attr_groups[] = {
810         &memory_root_attr_group,
811         NULL,
812 };
813
814 /*
815  * Initialize the sysfs support for memory devices...
816  */
817 int __init memory_dev_init(void)
818 {
819         unsigned int i;
820         int ret;
821         int err;
822         unsigned long block_sz;
823
824         ret = subsys_system_register(&memory_subsys, memory_root_attr_groups);
825         if (ret)
826                 goto out;
827
828         block_sz = get_memory_block_size();
829         sections_per_block = block_sz / MIN_MEMORY_BLOCK_SIZE;
830
831         /*
832          * Create entries for memory sections that were found
833          * during boot and have been initialized
834          */
835         mutex_lock(&mem_sysfs_mutex);
836         for (i = 0; i < NR_MEM_SECTIONS; i += sections_per_block) {
837                 /* Don't iterate over sections we know are !present: */
838                 if (i > __highest_present_section_nr)
839                         break;
840
841                 err = add_memory_block(i);
842                 if (!ret)
843                         ret = err;
844         }
845         mutex_unlock(&mem_sysfs_mutex);
846
847 out:
848         if (ret)
849                 printk(KERN_ERR "%s() failed: %d\n", __func__, ret);
850         return ret;
851 }