Lines Matching +full:memory +full:- +full:to +full:- +full:memory
1 // SPDX-License-Identifier: GPL-2.0
3 * Memory subsystem support
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
19 #include <linux/memory.h>
29 #define MEMORY_CLASS_NAME "memory"
46 return -EINVAL; in mhp_online_type_from_str()
79 * Memory blocks are cached in a local radix tree to avoid
86 * Memory groups, indexed by memory group id (mgid).
109 WARN_ON(mem->altmap); in memory_block_release()
119 /* Show the memory block ID, relative to the memory block size */
125 return sysfs_emit(buf, "%08lx\n", memory_block_id(mem->start_section_nr)); in phys_index_show()
130 * with CONFIG_MEMORY_HOTREMOVE - bad heuristic.
149 * so that they're not open-coded in state_show()
151 switch (mem->state) { in state_show()
159 output = "going-offline"; in state_show()
163 return sysfs_emit(buf, "ERROR-UNKNOWN-%ld\n", mem->state); in state_show()
188 unsigned long start_pfn = section_nr_to_pfn(mem->start_section_nr); in memory_block_online()
195 return -EHWPOISON; in memory_block_online()
197 zone = zone_for_pfn_range(mem->online_type, mem->nid, mem->group, in memory_block_online()
202 * they describe (they remain until the memory is unplugged), doing in memory_block_online()
203 * their initialization and accounting at memory onlining/offlining in memory_block_online()
204 * stage helps to keep accounting easier to follow - e.g vmemmaps in memory_block_online()
205 * belong to the same zone as the memory they backed. in memory_block_online()
207 if (mem->altmap) in memory_block_online()
208 nr_vmemmap_pages = mem->altmap->free; in memory_block_online()
218 nr_pages - nr_vmemmap_pages, zone, mem->group); in memory_block_online()
230 adjust_present_page_count(pfn_to_page(start_pfn), mem->group, in memory_block_online()
233 mem->zone = zone; in memory_block_online()
244 unsigned long start_pfn = section_nr_to_pfn(mem->start_section_nr); in memory_block_offline()
249 if (!mem->zone) in memory_block_offline()
250 return -EINVAL; in memory_block_offline()
256 if (mem->altmap) in memory_block_offline()
257 nr_vmemmap_pages = mem->altmap->free; in memory_block_offline()
261 adjust_present_page_count(pfn_to_page(start_pfn), mem->group, in memory_block_offline()
262 -nr_vmemmap_pages); in memory_block_offline()
265 nr_pages - nr_vmemmap_pages, mem->zone, mem->group); in memory_block_offline()
270 mem->group, nr_vmemmap_pages); in memory_block_offline()
277 mem->zone = NULL; in memory_block_offline()
285 * OK to have direct references to sparsemem variables in here.
301 "%ld\n", __func__, mem->start_section_nr, action, action); in memory_block_action()
302 ret = -EINVAL; in memory_block_action()
313 if (mem->state != from_state_req) in memory_block_change_state()
314 return -EINVAL; in memory_block_change_state()
317 mem->state = MEM_GOING_OFFLINE; in memory_block_change_state()
320 mem->state = ret ? from_state_req : to_state; in memory_block_change_state()
331 if (mem->state == MEM_ONLINE) in memory_subsys_online()
336 * we want to default to MMOP_ONLINE. in memory_subsys_online()
338 if (mem->online_type == MMOP_OFFLINE) in memory_subsys_online()
339 mem->online_type = MMOP_ONLINE; in memory_subsys_online()
342 mem->online_type = MMOP_OFFLINE; in memory_subsys_online()
351 if (mem->state == MEM_OFFLINE) in memory_subsys_offline()
365 return -EINVAL; in state_store()
375 /* mem->online_type is protected by device_hotplug_lock */ in state_store()
376 mem->online_type = online_type; in state_store()
377 ret = device_online(&mem->dev); in state_store()
380 ret = device_offline(&mem->dev); in state_store()
383 ret = -EINVAL; /* should never happen */ in state_store()
391 return -EINVAL; in state_store()
398 * covered by a memory block, allowing for identifying which memory blocks
399 * comprise a storage increment. Since a memory block spans complete
407 unsigned long start_pfn = section_nr_to_pfn(mem->start_section_nr); in phys_device_show()
425 return sysfs_emit_at(buf, len, " %s", zone->name); in print_allowed_zone()
432 unsigned long start_pfn = section_nr_to_pfn(mem->start_section_nr); in valid_zones_show()
434 struct memory_group *group = mem->group; in valid_zones_show()
436 int nid = mem->nid; in valid_zones_show()
443 if (mem->state == MEM_ONLINE) { in valid_zones_show()
445 * If !mem->zone, the memory block spans multiple zones and in valid_zones_show()
448 default_zone = mem->zone; in valid_zones_show()
451 len += sysfs_emit_at(buf, len, "%s", default_zone->name); in valid_zones_show()
458 len += sysfs_emit_at(buf, len, "%s", default_zone->name); in valid_zones_show()
476 * Show the memory block size (shared by all memory blocks).
487 * Memory auto online policy.
504 return -EINVAL; in auto_online_blocks_store()
523 * Some architectures will have custom drivers to do this, and
524 * will not need to do it from userspace. The fake hot-add code
540 if (phys_addr & ((pages_per_block << PAGE_SHIFT) - 1)) in probe_store()
541 return -EINVAL; in probe_store()
566 * Support for offlining pages of memory
577 return -EPERM; in soft_offline_page_store()
579 return -EINVAL; in soft_offline_page_store()
593 return -EPERM; in hard_offline_page_store()
595 return -EINVAL; in hard_offline_page_store()
598 if (ret == -EOPNOTSUPP) in hard_offline_page_store()
614 * A reference for the returned memory block device is acquired.
624 get_device(&mem->dev); in find_memory_block_by_id()
658 static int __add_memory_block(struct memory_block *memory) in __add_memory_block() argument
662 memory->dev.bus = &memory_subsys; in __add_memory_block()
663 memory->dev.id = memory->start_section_nr / sections_per_block; in __add_memory_block()
664 memory->dev.release = memory_block_release; in __add_memory_block()
665 memory->dev.groups = memory_memblk_attr_groups; in __add_memory_block()
666 memory->dev.offline = memory->state == MEM_OFFLINE; in __add_memory_block()
668 ret = device_register(&memory->dev); in __add_memory_block()
670 put_device(&memory->dev); in __add_memory_block()
673 ret = xa_err(xa_store(&memory_blocks, memory->dev.id, memory, in __add_memory_block()
676 device_unregister(&memory->dev); in __add_memory_block()
684 const unsigned long start_pfn = section_nr_to_pfn(mem->start_section_nr); in early_node_zone_for_memory_block()
691 * This logic only works for early memory, when the applicable zones in early_node_zone_for_memory_block()
692 * already span the memory block. We don't expect overlapping zones on in early_node_zone_for_memory_block()
693 * a single node for early memory. So if we're told that some PFNs in early_node_zone_for_memory_block()
694 * of a node fall into this memory block, we can assume that all node in early_node_zone_for_memory_block()
695 * zones that intersect with the memory block are actually applicable. in early_node_zone_for_memory_block()
696 * No need to look at the memmap. in early_node_zone_for_memory_block()
699 zone = pgdat->node_zones + i; in early_node_zone_for_memory_block()
717 * memory_block_add_nid() - Indicate that system RAM falling into this memory
718 * block device (partially) belongs to the given node.
719 * @mem: The memory block device.
721 * @context: The memory initialization context.
723 * Indicate that system RAM falling into this memory block (partially) belongs
724 * to the given node. If the context indicates ("early") that we are adding the
726 * set/adjust mem->zone based on the zone ranges of the given node.
731 if (context == MEMINIT_EARLY && mem->nid != nid) { in memory_block_add_nid()
733 * For early memory we have to determine the zone when setting in memory_block_add_nid()
735 * memory block by indicate via zone == NULL that we're not in memory_block_add_nid()
738 * setting the node id a second time to a different node, in memory_block_add_nid()
741 if (mem->nid == NUMA_NO_NODE) in memory_block_add_nid()
742 mem->zone = early_node_zone_for_memory_block(mem, nid); in memory_block_add_nid()
744 mem->zone = NULL; in memory_block_add_nid()
748 * If this memory block spans multiple nodes, we only indicate in memory_block_add_nid()
750 * to hotplugged memory), zone == NULL will prohibit memory offlining in memory_block_add_nid()
753 mem->nid = nid; in memory_block_add_nid()
766 put_device(&mem->dev); in add_memory_block()
767 return -EEXIST; in add_memory_block()
771 return -ENOMEM; in add_memory_block()
773 mem->start_section_nr = block_id * sections_per_block; in add_memory_block()
774 mem->state = state; in add_memory_block()
775 mem->nid = NUMA_NO_NODE; in add_memory_block()
776 mem->altmap = altmap; in add_memory_block()
777 INIT_LIST_HEAD(&mem->group_next); in add_memory_block()
782 * MEM_ONLINE at this point implies early memory. With NUMA, in add_memory_block()
784 * memory_block_add_nid(). Memory hotplug updated the zone in add_memory_block()
785 * manually when memory onlining/offlining succeeds. in add_memory_block()
787 mem->zone = early_node_zone_for_memory_block(mem, NUMA_NO_NODE); in add_memory_block()
795 mem->group = group; in add_memory_block()
796 list_add(&mem->group_next, &group->memory_blocks); in add_memory_block()
825 static void remove_memory_block(struct memory_block *memory) in remove_memory_block() argument
827 if (WARN_ON_ONCE(memory->dev.bus != &memory_subsys)) in remove_memory_block()
830 WARN_ON(xa_erase(&memory_blocks, memory->dev.id) == NULL); in remove_memory_block()
832 if (memory->group) { in remove_memory_block()
833 list_del(&memory->group_next); in remove_memory_block()
834 memory->group = NULL; in remove_memory_block()
838 put_device(&memory->dev); in remove_memory_block()
839 device_unregister(&memory->dev); in remove_memory_block()
843 * Create memory block devices for the given memory area. Start and size
844 * have to be aligned to memory block granularity. Memory block devices
861 return -EINVAL; in create_memory_block_devices()
882 * Remove memory block devices for the given memory area. Start and size
883 * have to be aligned to memory block granularity. Memory block devices
884 * have to be offline.
903 num_poisoned_pages_sub(-1UL, memblk_nr_poison(mem)); in remove_memory_block_devices()
937 * Initialize the sysfs support for memory devices. At the time this function
938 * is called, we cannot have concurrent creation/deletion of memory block
946 /* Validate the configured memory block size */ in memory_dev_init()
949 panic("Memory block size not suitable: 0x%lx\n", block_sz); in memory_dev_init()
954 panic("%s() failed to register subsystem: %d\n", __func__, ret); in memory_dev_init()
957 * Create entries for memory sections that were found in memory_dev_init()
964 panic("%s() failed to add memory block: %d\n", __func__, in memory_dev_init()
970 * walk_memory_blocks - walk through all present memory blocks overlapped
973 * @start: start address of the memory range
974 * @size: size of the memory range
975 * @arg: argument passed to func
976 * @func: callback for each memory section walked
978 * This function walks through all present memory blocks overlapped by the
979 * range [start, start + size), calling func on each memory block.
990 const unsigned long end_block_id = phys_to_block_id(start + size - 1); in walk_memory_blocks()
1004 put_device(&mem->dev); in walk_memory_blocks()
1021 return cb_data->func(mem, cb_data->arg); in for_each_memory_block_cb()
1025 * for_each_memory_block - walk through all present memory blocks
1027 * @arg: argument passed to func
1028 * @func: callback for each memory block walked
1030 * This function walks through all present memory blocks, calling func on
1031 * each memory block.
1048 * This is an internal helper to unify allocation and initialization of
1049 * memory groups. Note that the passed memory group will be copied to a
1050 * dynamically allocated memory group. After this call, the passed
1051 * memory group should no longer be used.
1060 return -EINVAL; in memory_group_register()
1064 return -ENOMEM; in memory_group_register()
1066 INIT_LIST_HEAD(&new_group->memory_blocks); in memory_group_register()
1080 * memory_group_register_static() - Register a static memory group.
1082 * @max_pages: The maximum number of pages we'll have in this static memory
1085 * Register a new static memory group and return the memory group id.
1086 * All memory in the group belongs to a single unit, such as a DIMM. All
1087 * memory belonging to a static memory group is added in one go to be removed
1088 * in one go -- it's static.
1090 * Returns an error if out of memory, if the node id is invalid, if no new
1091 * memory groups can be registered, or if max_pages is invalid (0). Otherwise,
1092 * returns the new memory group id.
1104 return -EINVAL; in memory_group_register_static()
1110 * memory_group_register_dynamic() - Register a dynamic memory group.
1112 * @unit_pages: Unit in pages in which is memory added/removed in this dynamic
1113 * memory group.
1115 * Register a new dynamic memory group and return the memory group id.
1116 * Memory within a dynamic memory group is added/removed dynamically
1119 * Returns an error if out of memory, if the node id is invalid, if no new
1120 * memory groups can be registered, or if unit_pages is invalid (0, not a
1121 * power of two, smaller than a single memory block). Otherwise, returns the
1122 * new memory group id.
1136 return -EINVAL; in memory_group_register_dynamic()
1142 * memory_group_unregister() - Unregister a memory group.
1143 * @mgid: the memory group id
1145 * Unregister a memory group. If any memory block still belongs to this
1146 * memory group, unregistering will fail.
1148 * Returns -EINVAL if the memory group id is invalid, returns -EBUSY if some
1149 * memory blocks still belong to this memory group and returns 0 if
1157 return -EINVAL; in memory_group_unregister()
1161 return -EINVAL; in memory_group_unregister()
1162 if (!list_empty(&group->memory_blocks)) in memory_group_unregister()
1163 return -EBUSY; in memory_group_unregister()
1171 * This is an internal helper only to be used in core memory hotplug code to
1172 * lookup a memory group. We don't care about locking, as we don't expect a
1173 * memory group to get unregistered while adding memory to it -- because
1174 * the group and the memory is managed by the same driver.
1182 * This is an internal helper only to be used in core memory hotplug code to
1183 * walk all dynamic memory groups excluding a given memory group, either
1184 * belonging to a specific node, or belonging to any node.
1198 if (nid != NUMA_NO_NODE && group->nid != nid) in walk_dynamic_memory_groups()
1215 atomic_long_inc(&mem->nr_hwpoison); in memblk_nr_poison_inc()
1224 atomic_long_sub(i, &mem->nr_hwpoison); in memblk_nr_poison_sub()
1229 return atomic_long_read(&mem->nr_hwpoison); in memblk_nr_poison()