memory.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784
  1. /*
  2. * Memory subsystem support
  3. *
  4. * Written by Matt Tolentino <matthew.e.tolentino@intel.com>
  5. * Dave Hansen <haveblue@us.ibm.com>
  6. *
  7. * This file provides the necessary infrastructure to represent
  8. * a SPARSEMEM-memory-model system's physical memory in /sysfs.
  9. * All arch-independent code that assumes MEMORY_HOTPLUG requires
  10. * SPARSEMEM should be contained here, or in mm/memory_hotplug.c.
  11. */
  12. #include <linux/module.h>
  13. #include <linux/init.h>
  14. #include <linux/topology.h>
  15. #include <linux/capability.h>
  16. #include <linux/device.h>
  17. #include <linux/memory.h>
  18. #include <linux/memory_hotplug.h>
  19. #include <linux/mm.h>
  20. #include <linux/mutex.h>
  21. #include <linux/stat.h>
  22. #include <linux/slab.h>
  23. #include <linux/atomic.h>
  24. #include <asm/uaccess.h>
  25. static DEFINE_MUTEX(mem_sysfs_mutex);
  26. #define MEMORY_CLASS_NAME "memory"
  27. #define to_memory_block(dev) container_of(dev, struct memory_block, dev)
  28. static int sections_per_block;
  29. static inline int base_memory_block_id(int section_nr)
  30. {
  31. return section_nr / sections_per_block;
  32. }
  33. static int memory_subsys_online(struct device *dev);
  34. static int memory_subsys_offline(struct device *dev);
  35. static struct bus_type memory_subsys = {
  36. .name = MEMORY_CLASS_NAME,
  37. .dev_name = MEMORY_CLASS_NAME,
  38. .online = memory_subsys_online,
  39. .offline = memory_subsys_offline,
  40. };
  41. static BLOCKING_NOTIFIER_HEAD(memory_chain);
  42. int register_memory_notifier(struct notifier_block *nb)
  43. {
  44. return blocking_notifier_chain_register(&memory_chain, nb);
  45. }
  46. EXPORT_SYMBOL(register_memory_notifier);
  47. void unregister_memory_notifier(struct notifier_block *nb)
  48. {
  49. blocking_notifier_chain_unregister(&memory_chain, nb);
  50. }
  51. EXPORT_SYMBOL(unregister_memory_notifier);
  52. static ATOMIC_NOTIFIER_HEAD(memory_isolate_chain);
  53. int register_memory_isolate_notifier(struct notifier_block *nb)
  54. {
  55. return atomic_notifier_chain_register(&memory_isolate_chain, nb);
  56. }
  57. EXPORT_SYMBOL(register_memory_isolate_notifier);
  58. void unregister_memory_isolate_notifier(struct notifier_block *nb)
  59. {
  60. atomic_notifier_chain_unregister(&memory_isolate_chain, nb);
  61. }
  62. EXPORT_SYMBOL(unregister_memory_isolate_notifier);
  63. static void memory_block_release(struct device *dev)
  64. {
  65. struct memory_block *mem = to_memory_block(dev);
  66. kfree(mem);
  67. }
  68. unsigned long __weak memory_block_size_bytes(void)
  69. {
  70. return MIN_MEMORY_BLOCK_SIZE;
  71. }
  72. static unsigned long get_memory_block_size(void)
  73. {
  74. unsigned long block_sz;
  75. block_sz = memory_block_size_bytes();
  76. /* Validate blk_sz is a power of 2 and not less than section size */
  77. if ((block_sz & (block_sz - 1)) || (block_sz < MIN_MEMORY_BLOCK_SIZE)) {
  78. WARN_ON(1);
  79. block_sz = MIN_MEMORY_BLOCK_SIZE;
  80. }
  81. return block_sz;
  82. }
  83. /*
  84. * use this as the physical section index that this memsection
  85. * uses.
  86. */
  87. static ssize_t show_mem_start_phys_index(struct device *dev,
  88. struct device_attribute *attr, char *buf)
  89. {
  90. struct memory_block *mem = to_memory_block(dev);
  91. unsigned long phys_index;
  92. phys_index = mem->start_section_nr / sections_per_block;
  93. return sprintf(buf, "%08lx\n", phys_index);
  94. }
  95. /*
  96. * Show whether the section of memory is likely to be hot-removable
  97. */
  98. static ssize_t show_mem_removable(struct device *dev,
  99. struct device_attribute *attr, char *buf)
  100. {
  101. unsigned long i, pfn;
  102. int ret = 1;
  103. struct memory_block *mem = to_memory_block(dev);
  104. for (i = 0; i < sections_per_block; i++) {
  105. if (!present_section_nr(mem->start_section_nr + i))
  106. continue;
  107. pfn = section_nr_to_pfn(mem->start_section_nr + i);
  108. ret &= is_mem_section_removable(pfn, PAGES_PER_SECTION);
  109. }
  110. return sprintf(buf, "%d\n", ret);
  111. }
  112. /*
  113. * online, offline, going offline, etc.
  114. */
  115. static ssize_t show_mem_state(struct device *dev,
  116. struct device_attribute *attr, char *buf)
  117. {
  118. struct memory_block *mem = to_memory_block(dev);
  119. ssize_t len = 0;
  120. /*
  121. * We can probably put these states in a nice little array
  122. * so that they're not open-coded
  123. */
  124. switch (mem->state) {
  125. case MEM_ONLINE:
  126. len = sprintf(buf, "online\n");
  127. break;
  128. case MEM_OFFLINE:
  129. len = sprintf(buf, "offline\n");
  130. break;
  131. case MEM_GOING_OFFLINE:
  132. len = sprintf(buf, "going-offline\n");
  133. break;
  134. default:
  135. len = sprintf(buf, "ERROR-UNKNOWN-%ld\n",
  136. mem->state);
  137. WARN_ON(1);
  138. break;
  139. }
  140. return len;
  141. }
  142. int memory_notify(unsigned long val, void *v)
  143. {
  144. return blocking_notifier_call_chain(&memory_chain, val, v);
  145. }
  146. int memory_isolate_notify(unsigned long val, void *v)
  147. {
  148. return atomic_notifier_call_chain(&memory_isolate_chain, val, v);
  149. }
  150. /*
  151. * The probe routines leave the pages reserved, just as the bootmem code does.
  152. * Make sure they're still that way.
  153. */
  154. static bool pages_correctly_reserved(unsigned long start_pfn)
  155. {
  156. int i, j;
  157. struct page *page;
  158. unsigned long pfn = start_pfn;
  159. /*
  160. * memmap between sections is not contiguous except with
  161. * SPARSEMEM_VMEMMAP. We lookup the page once per section
  162. * and assume memmap is contiguous within each section
  163. */
  164. for (i = 0; i < sections_per_block; i++, pfn += PAGES_PER_SECTION) {
  165. if (WARN_ON_ONCE(!pfn_valid(pfn)))
  166. return false;
  167. page = pfn_to_page(pfn);
  168. for (j = 0; j < PAGES_PER_SECTION; j++) {
  169. if (PageReserved(page + j))
  170. continue;
  171. printk(KERN_WARNING "section number %ld page number %d "
  172. "not reserved, was it already online?\n",
  173. pfn_to_section_nr(pfn), j);
  174. return false;
  175. }
  176. }
  177. return true;
  178. }
  179. /*
  180. * MEMORY_HOTPLUG depends on SPARSEMEM in mm/Kconfig, so it is
  181. * OK to have direct references to sparsemem variables in here.
  182. * Must already be protected by mem_hotplug_begin().
  183. */
  184. static int
  185. memory_block_action(unsigned long phys_index, unsigned long action, int online_type)
  186. {
  187. unsigned long start_pfn;
  188. unsigned long nr_pages = PAGES_PER_SECTION * sections_per_block;
  189. struct page *first_page;
  190. int ret;
  191. start_pfn = section_nr_to_pfn(phys_index);
  192. first_page = pfn_to_page(start_pfn);
  193. switch (action) {
  194. case MEM_ONLINE:
  195. if (!pages_correctly_reserved(start_pfn))
  196. return -EBUSY;
  197. ret = online_pages(start_pfn, nr_pages, online_type);
  198. break;
  199. case MEM_OFFLINE:
  200. ret = offline_pages(start_pfn, nr_pages);
  201. break;
  202. default:
  203. WARN(1, KERN_WARNING "%s(%ld, %ld) unknown action: "
  204. "%ld\n", __func__, phys_index, action, action);
  205. ret = -EINVAL;
  206. }
  207. return ret;
  208. }
  209. static int memory_block_change_state(struct memory_block *mem,
  210. unsigned long to_state, unsigned long from_state_req)
  211. {
  212. int ret = 0;
  213. if (mem->state != from_state_req)
  214. return -EINVAL;
  215. if (to_state == MEM_OFFLINE)
  216. mem->state = MEM_GOING_OFFLINE;
  217. ret = memory_block_action(mem->start_section_nr, to_state,
  218. mem->online_type);
  219. mem->state = ret ? from_state_req : to_state;
  220. return ret;
  221. }
  222. /* The device lock serializes operations on memory_subsys_[online|offline] */
  223. static int memory_subsys_online(struct device *dev)
  224. {
  225. struct memory_block *mem = to_memory_block(dev);
  226. int ret;
  227. if (mem->state == MEM_ONLINE)
  228. return 0;
  229. /*
  230. * If we are called from store_mem_state(), online_type will be
  231. * set >= 0 Otherwise we were called from the device online
  232. * attribute and need to set the online_type.
  233. */
  234. if (mem->online_type < 0)
  235. mem->online_type = MMOP_ONLINE_KEEP;
  236. /* Already under protection of mem_hotplug_begin() */
  237. ret = memory_block_change_state(mem, MEM_ONLINE, MEM_OFFLINE);
  238. /* clear online_type */
  239. mem->online_type = -1;
  240. return ret;
  241. }
  242. static int memory_subsys_offline(struct device *dev)
  243. {
  244. struct memory_block *mem = to_memory_block(dev);
  245. if (mem->state == MEM_OFFLINE)
  246. return 0;
  247. /* Can't offline block with non-present sections */
  248. if (mem->section_count != sections_per_block)
  249. return -EINVAL;
  250. return memory_block_change_state(mem, MEM_OFFLINE, MEM_ONLINE);
  251. }
  252. static ssize_t
  253. store_mem_state(struct device *dev,
  254. struct device_attribute *attr, const char *buf, size_t count)
  255. {
  256. struct memory_block *mem = to_memory_block(dev);
  257. int ret, online_type;
  258. ret = lock_device_hotplug_sysfs();
  259. if (ret)
  260. return ret;
  261. if (sysfs_streq(buf, "online_kernel"))
  262. online_type = MMOP_ONLINE_KERNEL;
  263. else if (sysfs_streq(buf, "online_movable"))
  264. online_type = MMOP_ONLINE_MOVABLE;
  265. else if (sysfs_streq(buf, "online"))
  266. online_type = MMOP_ONLINE_KEEP;
  267. else if (sysfs_streq(buf, "offline"))
  268. online_type = MMOP_OFFLINE;
  269. else {
  270. ret = -EINVAL;
  271. goto err;
  272. }
  273. /*
  274. * Memory hotplug needs to hold mem_hotplug_begin() for probe to find
  275. * the correct memory block to online before doing device_online(dev),
  276. * which will take dev->mutex. Take the lock early to prevent an
  277. * inversion, memory_subsys_online() callbacks will be implemented by
  278. * assuming it's already protected.
  279. */
  280. mem_hotplug_begin();
  281. switch (online_type) {
  282. case MMOP_ONLINE_KERNEL:
  283. case MMOP_ONLINE_MOVABLE:
  284. case MMOP_ONLINE_KEEP:
  285. mem->online_type = online_type;
  286. ret = device_online(&mem->dev);
  287. break;
  288. case MMOP_OFFLINE:
  289. ret = device_offline(&mem->dev);
  290. break;
  291. default:
  292. ret = -EINVAL; /* should never happen */
  293. }
  294. mem_hotplug_done();
  295. err:
  296. unlock_device_hotplug();
  297. if (ret)
  298. return ret;
  299. return count;
  300. }
  301. /*
  302. * phys_device is a bad name for this. What I really want
  303. * is a way to differentiate between memory ranges that
  304. * are part of physical devices that constitute
  305. * a complete removable unit or fru.
  306. * i.e. do these ranges belong to the same physical device,
  307. * s.t. if I offline all of these sections I can then
  308. * remove the physical device?
  309. */
  310. static ssize_t show_phys_device(struct device *dev,
  311. struct device_attribute *attr, char *buf)
  312. {
  313. struct memory_block *mem = to_memory_block(dev);
  314. return sprintf(buf, "%d\n", mem->phys_device);
  315. }
  316. #ifdef CONFIG_MEMORY_HOTREMOVE
  317. static ssize_t show_valid_zones(struct device *dev,
  318. struct device_attribute *attr, char *buf)
  319. {
  320. struct memory_block *mem = to_memory_block(dev);
  321. unsigned long start_pfn, end_pfn;
  322. unsigned long valid_start, valid_end;
  323. unsigned long nr_pages = PAGES_PER_SECTION * sections_per_block;
  324. struct zone *zone;
  325. start_pfn = section_nr_to_pfn(mem->start_section_nr);
  326. end_pfn = start_pfn + nr_pages;
  327. /* The block contains more than one zone can not be offlined. */
  328. if (!test_pages_in_a_zone(start_pfn, end_pfn, &valid_start, &valid_end))
  329. return sprintf(buf, "none\n");
  330. zone = page_zone(pfn_to_page(valid_start));
  331. if (zone_idx(zone) == ZONE_MOVABLE - 1) {
  332. /*The mem block is the last memoryblock of this zone.*/
  333. if (valid_end == zone_end_pfn(zone))
  334. return sprintf(buf, "%s %s\n",
  335. zone->name, (zone + 1)->name);
  336. }
  337. if (zone_idx(zone) == ZONE_MOVABLE) {
  338. /*The mem block is the first memoryblock of ZONE_MOVABLE.*/
  339. if (valid_start == zone->zone_start_pfn)
  340. return sprintf(buf, "%s %s\n",
  341. zone->name, (zone - 1)->name);
  342. }
  343. return sprintf(buf, "%s\n", zone->name);
  344. }
  345. static DEVICE_ATTR(valid_zones, 0444, show_valid_zones, NULL);
  346. #endif
  347. static DEVICE_ATTR(phys_index, 0444, show_mem_start_phys_index, NULL);
  348. static DEVICE_ATTR(state, 0644, show_mem_state, store_mem_state);
  349. static DEVICE_ATTR(phys_device, 0444, show_phys_device, NULL);
  350. static DEVICE_ATTR(removable, 0444, show_mem_removable, NULL);
  351. /*
  352. * Block size attribute stuff
  353. */
  354. static ssize_t
  355. print_block_size(struct device *dev, struct device_attribute *attr,
  356. char *buf)
  357. {
  358. return sprintf(buf, "%lx\n", get_memory_block_size());
  359. }
  360. static DEVICE_ATTR(block_size_bytes, 0444, print_block_size, NULL);
  361. /*
  362. * Some architectures will have custom drivers to do this, and
  363. * will not need to do it from userspace. The fake hot-add code
  364. * as well as ppc64 will do all of their discovery in userspace
  365. * and will require this interface.
  366. */
  367. #ifdef CONFIG_ARCH_MEMORY_PROBE
  368. static ssize_t
  369. memory_probe_store(struct device *dev, struct device_attribute *attr,
  370. const char *buf, size_t count)
  371. {
  372. u64 phys_addr;
  373. int nid;
  374. int i, ret;
  375. unsigned long pages_per_block = PAGES_PER_SECTION * sections_per_block;
  376. ret = kstrtoull(buf, 0, &phys_addr);
  377. if (ret)
  378. return ret;
  379. if (phys_addr & ((pages_per_block << PAGE_SHIFT) - 1))
  380. return -EINVAL;
  381. for (i = 0; i < sections_per_block; i++) {
  382. nid = memory_add_physaddr_to_nid(phys_addr);
  383. ret = add_memory(nid, phys_addr,
  384. PAGES_PER_SECTION << PAGE_SHIFT);
  385. if (ret)
  386. goto out;
  387. phys_addr += MIN_MEMORY_BLOCK_SIZE;
  388. }
  389. ret = count;
  390. out:
  391. return ret;
  392. }
  393. static DEVICE_ATTR(probe, S_IWUSR, NULL, memory_probe_store);
  394. #endif
  395. #ifdef CONFIG_MEMORY_FAILURE
  396. /*
  397. * Support for offlining pages of memory
  398. */
  399. /* Soft offline a page */
  400. static ssize_t
  401. store_soft_offline_page(struct device *dev,
  402. struct device_attribute *attr,
  403. const char *buf, size_t count)
  404. {
  405. int ret;
  406. u64 pfn;
  407. if (!capable(CAP_SYS_ADMIN))
  408. return -EPERM;
  409. if (kstrtoull(buf, 0, &pfn) < 0)
  410. return -EINVAL;
  411. pfn >>= PAGE_SHIFT;
  412. if (!pfn_valid(pfn))
  413. return -ENXIO;
  414. ret = soft_offline_page(pfn_to_page(pfn), 0);
  415. return ret == 0 ? count : ret;
  416. }
  417. /* Forcibly offline a page, including killing processes. */
  418. static ssize_t
  419. store_hard_offline_page(struct device *dev,
  420. struct device_attribute *attr,
  421. const char *buf, size_t count)
  422. {
  423. int ret;
  424. u64 pfn;
  425. if (!capable(CAP_SYS_ADMIN))
  426. return -EPERM;
  427. if (kstrtoull(buf, 0, &pfn) < 0)
  428. return -EINVAL;
  429. pfn >>= PAGE_SHIFT;
  430. ret = memory_failure(pfn, 0, 0);
  431. return ret ? ret : count;
  432. }
  433. static DEVICE_ATTR(soft_offline_page, S_IWUSR, NULL, store_soft_offline_page);
  434. static DEVICE_ATTR(hard_offline_page, S_IWUSR, NULL, store_hard_offline_page);
  435. #endif
  436. /*
  437. * Note that phys_device is optional. It is here to allow for
  438. * differentiation between which *physical* devices each
  439. * section belongs to...
  440. */
  441. int __weak arch_get_memory_phys_device(unsigned long start_pfn)
  442. {
  443. return 0;
  444. }
  445. /*
  446. * A reference for the returned object is held and the reference for the
  447. * hinted object is released.
  448. */
  449. struct memory_block *find_memory_block_hinted(struct mem_section *section,
  450. struct memory_block *hint)
  451. {
  452. int block_id = base_memory_block_id(__section_nr(section));
  453. struct device *hintdev = hint ? &hint->dev : NULL;
  454. struct device *dev;
  455. dev = subsys_find_device_by_id(&memory_subsys, block_id, hintdev);
  456. if (hint)
  457. put_device(&hint->dev);
  458. if (!dev)
  459. return NULL;
  460. return to_memory_block(dev);
  461. }
  462. /*
  463. * For now, we have a linear search to go find the appropriate
  464. * memory_block corresponding to a particular phys_index. If
  465. * this gets to be a real problem, we can always use a radix
  466. * tree or something here.
  467. *
  468. * This could be made generic for all device subsystems.
  469. */
  470. struct memory_block *find_memory_block(struct mem_section *section)
  471. {
  472. return find_memory_block_hinted(section, NULL);
  473. }
  474. static struct attribute *memory_memblk_attrs[] = {
  475. &dev_attr_phys_index.attr,
  476. &dev_attr_state.attr,
  477. &dev_attr_phys_device.attr,
  478. &dev_attr_removable.attr,
  479. #ifdef CONFIG_MEMORY_HOTREMOVE
  480. &dev_attr_valid_zones.attr,
  481. #endif
  482. NULL
  483. };
  484. static struct attribute_group memory_memblk_attr_group = {
  485. .attrs = memory_memblk_attrs,
  486. };
  487. static const struct attribute_group *memory_memblk_attr_groups[] = {
  488. &memory_memblk_attr_group,
  489. NULL,
  490. };
  491. /*
  492. * register_memory - Setup a sysfs device for a memory block
  493. */
  494. static
  495. int register_memory(struct memory_block *memory)
  496. {
  497. memory->dev.bus = &memory_subsys;
  498. memory->dev.id = memory->start_section_nr / sections_per_block;
  499. memory->dev.release = memory_block_release;
  500. memory->dev.groups = memory_memblk_attr_groups;
  501. memory->dev.offline = memory->state == MEM_OFFLINE;
  502. return device_register(&memory->dev);
  503. }
  504. static int init_memory_block(struct memory_block **memory,
  505. struct mem_section *section, unsigned long state)
  506. {
  507. struct memory_block *mem;
  508. unsigned long start_pfn;
  509. int scn_nr;
  510. int ret = 0;
  511. mem = kzalloc(sizeof(*mem), GFP_KERNEL);
  512. if (!mem)
  513. return -ENOMEM;
  514. scn_nr = __section_nr(section);
  515. mem->start_section_nr =
  516. base_memory_block_id(scn_nr) * sections_per_block;
  517. mem->end_section_nr = mem->start_section_nr + sections_per_block - 1;
  518. mem->state = state;
  519. mem->section_count++;
  520. start_pfn = section_nr_to_pfn(mem->start_section_nr);
  521. mem->phys_device = arch_get_memory_phys_device(start_pfn);
  522. ret = register_memory(mem);
  523. *memory = mem;
  524. return ret;
  525. }
  526. static int add_memory_block(int base_section_nr)
  527. {
  528. struct memory_block *mem;
  529. int i, ret, section_count = 0, section_nr;
  530. for (i = base_section_nr;
  531. (i < base_section_nr + sections_per_block) && i < NR_MEM_SECTIONS;
  532. i++) {
  533. if (!present_section_nr(i))
  534. continue;
  535. if (section_count == 0)
  536. section_nr = i;
  537. section_count++;
  538. }
  539. if (section_count == 0)
  540. return 0;
  541. ret = init_memory_block(&mem, __nr_to_section(section_nr), MEM_ONLINE);
  542. if (ret)
  543. return ret;
  544. mem->section_count = section_count;
  545. return 0;
  546. }
  547. /*
  548. * need an interface for the VM to add new memory regions,
  549. * but without onlining it.
  550. */
  551. int register_new_memory(int nid, struct mem_section *section)
  552. {
  553. int ret = 0;
  554. struct memory_block *mem;
  555. mutex_lock(&mem_sysfs_mutex);
  556. mem = find_memory_block(section);
  557. if (mem) {
  558. mem->section_count++;
  559. put_device(&mem->dev);
  560. } else {
  561. ret = init_memory_block(&mem, section, MEM_OFFLINE);
  562. if (ret)
  563. goto out;
  564. }
  565. if (mem->section_count == sections_per_block)
  566. ret = register_mem_sect_under_node(mem, nid);
  567. out:
  568. mutex_unlock(&mem_sysfs_mutex);
  569. return ret;
  570. }
  571. #ifdef CONFIG_MEMORY_HOTREMOVE
  572. static void
  573. unregister_memory(struct memory_block *memory)
  574. {
  575. BUG_ON(memory->dev.bus != &memory_subsys);
  576. /* drop the ref. we got in remove_memory_block() */
  577. put_device(&memory->dev);
  578. device_unregister(&memory->dev);
  579. }
  580. static int remove_memory_block(unsigned long node_id,
  581. struct mem_section *section, int phys_device)
  582. {
  583. struct memory_block *mem;
  584. mutex_lock(&mem_sysfs_mutex);
  585. mem = find_memory_block(section);
  586. unregister_mem_sect_under_nodes(mem, __section_nr(section));
  587. mem->section_count--;
  588. if (mem->section_count == 0)
  589. unregister_memory(mem);
  590. else
  591. put_device(&mem->dev);
  592. mutex_unlock(&mem_sysfs_mutex);
  593. return 0;
  594. }
  595. int unregister_memory_section(struct mem_section *section)
  596. {
  597. if (!present_section(section))
  598. return -EINVAL;
  599. return remove_memory_block(0, section, 0);
  600. }
  601. #endif /* CONFIG_MEMORY_HOTREMOVE */
  602. /* return true if the memory block is offlined, otherwise, return false */
  603. bool is_memblock_offlined(struct memory_block *mem)
  604. {
  605. return mem->state == MEM_OFFLINE;
  606. }
  607. static struct attribute *memory_root_attrs[] = {
  608. #ifdef CONFIG_ARCH_MEMORY_PROBE
  609. &dev_attr_probe.attr,
  610. #endif
  611. #ifdef CONFIG_MEMORY_FAILURE
  612. &dev_attr_soft_offline_page.attr,
  613. &dev_attr_hard_offline_page.attr,
  614. #endif
  615. &dev_attr_block_size_bytes.attr,
  616. NULL
  617. };
  618. static struct attribute_group memory_root_attr_group = {
  619. .attrs = memory_root_attrs,
  620. };
  621. static const struct attribute_group *memory_root_attr_groups[] = {
  622. &memory_root_attr_group,
  623. NULL,
  624. };
  625. /*
  626. * Initialize the sysfs support for memory devices...
  627. */
  628. int __init memory_dev_init(void)
  629. {
  630. unsigned int i;
  631. int ret;
  632. int err;
  633. unsigned long block_sz;
  634. ret = subsys_system_register(&memory_subsys, memory_root_attr_groups);
  635. if (ret)
  636. goto out;
  637. block_sz = get_memory_block_size();
  638. sections_per_block = block_sz / MIN_MEMORY_BLOCK_SIZE;
  639. /*
  640. * Create entries for memory sections that were found
  641. * during boot and have been initialized
  642. */
  643. mutex_lock(&mem_sysfs_mutex);
  644. for (i = 0; i < NR_MEM_SECTIONS; i += sections_per_block) {
  645. err = add_memory_block(i);
  646. if (!ret)
  647. ret = err;
  648. }
  649. mutex_unlock(&mem_sysfs_mutex);
  650. out:
  651. if (ret)
  652. printk(KERN_ERR "%s() failed: %d\n", __func__, ret);
  653. return ret;
  654. }