cregit-Linux how code gets into the kernel

Release 4.14 drivers/base/memory.c

Directory: drivers/base
// SPDX-License-Identifier: GPL-2.0
/*
 * Memory subsystem support
 *
 * 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>
#include <linux/capability.h>
#include <linux/device.h>
#include <linux/memory.h>
#include <linux/memory_hotplug.h>
#include <linux/mm.h>
#include <linux/mutex.h>
#include <linux/stat.h>
#include <linux/slab.h>

#include <linux/atomic.h>
#include <linux/uaccess.h>

static DEFINE_MUTEX(mem_sysfs_mutex);


#define MEMORY_CLASS_NAME	"memory"


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


static int sections_per_block;


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

Contributors

PersonTokensPropCommitsCommitProp
Nathan Fontenot15100.00%1100.00%
Total15100.00%1100.00%

static int memory_subsys_online(struct device *dev); static int memory_subsys_offline(struct device *dev); static struct bus_type memory_subsys = { .name = MEMORY_CLASS_NAME, .dev_name = MEMORY_CLASS_NAME, .online = memory_subsys_online, .offline = memory_subsys_offline, }; static BLOCKING_NOTIFIER_HEAD(memory_chain);
int register_memory_notifier(struct notifier_block *nb) { return blocking_notifier_chain_register(&memory_chain, nb); }

Contributors

PersonTokensPropCommitsCommitProp
Dave Hansen1894.74%150.00%
Alan Stern15.26%150.00%
Total19100.00%2100.00%

EXPORT_SYMBOL(register_memory_notifier);
void unregister_memory_notifier(struct notifier_block *nb) { blocking_notifier_chain_unregister(&memory_chain, nb); }

Contributors

PersonTokensPropCommitsCommitProp
Dave Hansen1794.44%150.00%
Alan Stern15.56%150.00%
Total18100.00%2100.00%

EXPORT_SYMBOL(unregister_memory_notifier); 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); }

Contributors

PersonTokensPropCommitsCommitProp
Robert Jennings19100.00%1100.00%
Total19100.00%1100.00%

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

Contributors

PersonTokensPropCommitsCommitProp
Robert Jennings18100.00%1100.00%
Total18100.00%1100.00%

EXPORT_SYMBOL(unregister_memory_isolate_notifier);
static void memory_block_release(struct device *dev) { struct memory_block *mem = to_memory_block(dev); kfree(mem); }

Contributors

PersonTokensPropCommitsCommitProp
Yasuaki Ishimatsu2596.15%150.00%
Gu Zheng13.85%150.00%
Total26100.00%2100.00%


unsigned long __weak memory_block_size_bytes(void) { return MIN_MEMORY_BLOCK_SIZE; }

Contributors

PersonTokensPropCommitsCommitProp
Nathan Fontenot12100.00%1100.00%
Total12100.00%1100.00%


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; }

Contributors

PersonTokensPropCommitsCommitProp
Nathan Fontenot51100.00%1100.00%
Total51100.00%1100.00%

/* * use this as the physical section index that this memsection * uses. */
static ssize_t show_mem_start_phys_index(struct device *dev, struct device_attribute *attr, char *buf) { struct memory_block *mem = to_memory_block(dev); unsigned long phys_index; phys_index = mem->start_section_nr / sections_per_block; return sprintf(buf, "%08lx\n", phys_index); }

Contributors

PersonTokensPropCommitsCommitProp
Dave Hansen2853.85%120.00%
Nathan Fontenot1732.69%120.00%
Andi Kleen47.69%120.00%
Kay Sievers23.85%120.00%
Gu Zheng11.92%120.00%
Total52100.00%5100.00%

/* * Show whether the section of memory is likely to be hot-removable */
static ssize_t show_mem_removable(struct device *dev, struct device_attribute *attr, char *buf) { unsigned long i, pfn; int ret = 1; struct memory_block *mem = to_memory_block(dev); if (mem->state != MEM_ONLINE) goto out; for (i = 0; i < sections_per_block; i++) { if (!present_section_nr(mem->start_section_nr + i)) continue; pfn = section_nr_to_pfn(mem->start_section_nr + i); ret &= is_mem_section_removable(pfn, PAGES_PER_SECTION); } out: return sprintf(buf, "%d\n", ret); }

Contributors

PersonTokensPropCommitsCommitProp
Badari Pulavarty5347.32%112.50%
Nathan Fontenot2623.21%225.00%
Russ Anderson1311.61%112.50%
Michal Hocko1311.61%112.50%
Stephen Rothwell43.57%112.50%
Kay Sievers21.79%112.50%
Gu Zheng10.89%112.50%
Total112100.00%8100.00%

/* * online, offline, going offline, etc. */
static ssize_t show_mem_state(struct device *dev, struct device_attribute *attr, char *buf) { struct memory_block *mem = to_memory_block(dev); 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) { 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; } return len; }

Contributors

PersonTokensPropCommitsCommitProp
Dave Hansen9993.40%125.00%
Andi Kleen43.77%125.00%
Kay Sievers21.89%125.00%
Gu Zheng10.94%125.00%
Total106100.00%4100.00%


int memory_notify(unsigned long val, void *v) { return blocking_notifier_call_chain(&memory_chain, val, v); }

Contributors

PersonTokensPropCommitsCommitProp
Dave Hansen2395.83%150.00%
Alan Stern14.17%150.00%
Total24100.00%2100.00%


int memory_isolate_notify(unsigned long val, void *v) { return atomic_notifier_call_chain(&memory_isolate_chain, val, v); }

Contributors

PersonTokensPropCommitsCommitProp
Robert Jennings24100.00%1100.00%
Total24100.00%1100.00%

/* * The probe routines leave the pages reserved, just as the bootmem code does. * Make sure they're still that way. */
static bool pages_correctly_reserved(unsigned long start_pfn) { 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; }

Contributors

PersonTokensPropCommitsCommitProp
Mel Gorman6154.46%125.00%
Dave Hansen4540.18%125.00%
Nathan Fontenot32.68%125.00%
Greg Kroah-Hartman32.68%125.00%
Total112100.00%4100.00%

/* * MEMORY_HOTPLUG depends on SPARSEMEM in mm/Kconfig, so it is * OK to have direct references to sparsemem variables in here. * Must already be protected by mem_hotplug_begin(). */
static int memory_block_action(unsigned long phys_index, unsigned long action, int online_type) { unsigned long start_pfn; unsigned long nr_pages = PAGES_PER_SECTION * sections_per_block; int ret; start_pfn = section_nr_to_pfn(phys_index); switch (action) { 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; } return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Dave Hansen4843.24%110.00%
Mel Gorman4338.74%110.00%
Lai Jiangshan54.50%110.00%
Sheng Yong32.70%110.00%
Arjan van de Ven32.70%110.00%
Nathan Fontenot32.70%110.00%
Anton Blanchard21.80%110.00%
Wen Congyang21.80%110.00%
Zhang Zhen10.90%110.00%
Harvey Harrison10.90%110.00%
Total111100.00%10100.00%


static int memory_block_change_state(struct memory_block *mem, unsigned long to_state, unsigned long from_state_req) { int ret = 0; if (mem->state != from_state_req) return -EINVAL; if (to_state == MEM_OFFLINE) mem->state = MEM_GOING_OFFLINE; ret = memory_block_action(mem->start_section_nr, to_state, mem->online_type); mem->state = ret ? from_state_req : to_state; return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Dave Hansen3951.32%110.00%
Nathan Fontenot2127.63%330.00%
Rafael J. Wysocki911.84%220.00%
Seth Jennings33.95%110.00%
Lai Jiangshan22.63%110.00%
Michael Holzheu11.32%110.00%
Anton Blanchard11.32%110.00%
Total76100.00%10100.00%

/* The device lock serializes operations on memory_subsys_[online|offline] */
static int memory_subsys_online(struct device *dev) { struct memory_block *mem = to_memory_block(dev); int ret; if (mem->state == MEM_ONLINE) return 0; /* * 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) mem->online_type = MMOP_ONLINE_KEEP; /* Already under protection of mem_hotplug_begin() */ ret = memory_block_change_state(mem, MEM_ONLINE, MEM_OFFLINE); /* clear online_type */ mem->online_type = -1; return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Rafael J. Wysocki4054.79%116.67%
Seth Jennings2736.99%116.67%
Dave Hansen34.11%116.67%
Gu Zheng11.37%116.67%
David Rientjes11.37%116.67%
Tang Chen11.37%116.67%
Total73100.00%6100.00%


static int memory_subsys_offline(struct device *dev) { struct memory_block *mem = to_memory_block(dev); if (mem->state == MEM_OFFLINE) return 0; /* Can't offline block with non-present sections */ if (mem->section_count != sections_per_block) return -EINVAL; return memory_block_change_state(mem, MEM_OFFLINE, MEM_ONLINE); }

Contributors

PersonTokensPropCommitsCommitProp
Rafael J. Wysocki3665.45%120.00%
Seth Jennings1527.27%240.00%
Wen Congyang35.45%120.00%
Gu Zheng11.82%120.00%
Total55100.00%5100.00%


static ssize_t store_mem_state(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct memory_block *mem = to_memory_block(dev); int ret, online_type; ret = lock_device_hotplug_sysfs(); if (ret) return ret; if (sysfs_streq(buf, "online_kernel")) online_type = MMOP_ONLINE_KERNEL; else if (sysfs_streq(buf, "online_movable")) online_type = MMOP_ONLINE_MOVABLE; else if (sysfs_streq(buf, "online")) online_type = MMOP_ONLINE_KEEP; else if (sysfs_streq(buf, "offline")) online_type = MMOP_OFFLINE; else { ret = -EINVAL; goto err; } /* * 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(); switch (online_type) { case MMOP_ONLINE_KERNEL: case MMOP_ONLINE_MOVABLE: case MMOP_ONLINE_KEEP: mem->online_type = online_type; ret = device_online(&mem->dev); break; case MMOP_OFFLINE: ret = device_offline(&mem->dev); break; default: ret = -EINVAL; /* should never happen */ } mem_hotplug_done(); err: unlock_device_hotplug(); if (ret < 0) return ret; if (ret) return -EINVAL; return count; }

Contributors

PersonTokensPropCommitsCommitProp
Dave Hansen4823.76%16.67%
Seth Jennings3517.33%16.67%
Rafael J. Wysocki2914.36%16.67%
Lai Jiangshan2813.86%16.67%
Tang Chen125.94%213.33%
Yasuaki Ishimatsu104.95%16.67%
Reza Arbab104.95%16.67%
David Rientjes73.47%16.67%
Linus Torvalds73.47%16.67%
Gu Zheng52.48%16.67%
Michael Holzheu52.48%16.67%
Andi Kleen31.49%16.67%
Kay Sievers20.99%16.67%
Wen Congyang10.50%16.67%
Total202100.00%15100.00%

/* * 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? */
static ssize_t show_phys_device(struct device *dev, struct device_attribute *attr, char *buf) { struct memory_block *mem = to_memory_block(dev); return sprintf(buf, "%d\n", mem->phys_device); }

Contributors

PersonTokensPropCommitsCommitProp
Dave Hansen3583.33%125.00%
Andi Kleen49.52%125.00%
Kay Sievers24.76%125.00%
Gu Zheng12.38%125.00%
Total42100.00%4100.00%

#ifdef CONFIG_MEMORY_HOTREMOVE
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); } }

Contributors

PersonTokensPropCommitsCommitProp
Michal Hocko71100.00%1100.00%
Total71100.00%1100.00%


static ssize_t show_valid_zones(struct device *dev, struct device_attribute *attr, char *buf) { struct memory_block *mem = to_memory_block(dev); unsigned long start_pfn = section_nr_to_pfn(mem->start_section_nr); unsigned long nr_pages = PAGES_PER_SECTION * sections_per_block; unsigned long valid_start_pfn, valid_end_pfn; struct zone *default_zone; int nid; /* * The block contains more than one zone can not be offlined. * This can happen e.g. for ZONE_DMA and ZONE_DMA32 */ if (!test_pages_in_a_zone(start_pfn, start_pfn + nr_pages, &valid_start_pfn, &valid_end_pfn)) return sprintf(buf, "none\n"); start_pfn = valid_start_pfn; nr_pages = valid_end_pfn - start_pfn; /* * 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; } nid = pfn_to_nid(start_pfn); default_zone = zone_for_pfn_range(MMOP_ONLINE_KEEP, nid, start_pfn, nr_pages); strcat(buf, default_zone->name); 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); out: strcat(buf, "\n"); return strlen(buf); }

Contributors

PersonTokensPropCommitsCommitProp
Michal Hocko8742.86%233.33%
Zhang Zhen7838.42%116.67%
Reza Arbab2713.30%116.67%
Toshi Kani104.93%116.67%
Yasuaki Ishimatsu10.49%116.67%
Total203100.00%6100.00%

static DEVICE_ATTR(valid_zones, 0444, show_valid_zones, NULL); #endif 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); /* * Block size attribute stuff */
static ssize_t print_block_size(struct device *dev, struct device_attribute *attr, char *buf) { return sprintf(buf, "%lx\n", get_memory_block_size()); }

Contributors

PersonTokensPropCommitsCommitProp
Dave Hansen1961.29%116.67%
Andi Kleen412.90%116.67%
Kay Sievers39.68%116.67%
Nathan Fontenot26.45%116.67%
Fengguang Wu26.45%116.67%
Linus Torvalds13.23%116.67%
Total31100.00%6100.00%

static DEVICE_ATTR(block_size_bytes, 0444, print_block_size, NULL); /* * 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"); }

Contributors

PersonTokensPropCommitsCommitProp
Vitaly Kuznetsov41100.00%1100.00%
Total41100.00%1100.00%


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; }

Contributors

PersonTokensPropCommitsCommitProp
Vitaly Kuznetsov59100.00%1100.00%
Total59100.00%1100.00%

static DEVICE_ATTR(auto_online_blocks, 0644, show_auto_online_blocks, store_auto_online_blocks); /* * 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 memory_probe_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { u64 phys_addr; int nid, ret; unsigned long pages_per_block = PAGES_PER_SECTION * sections_per_block; ret = kstrtoull(buf, 0, &phys_addr); if (ret) return ret; if (phys_addr & ((pages_per_block << PAGE_SHIFT) - 1)) return -EINVAL; nid = memory_add_physaddr_to_nid(phys_addr); ret = add_memory(nid, phys_addr, MIN_MEMORY_BLOCK_SIZE * sections_per_block); if (ret) goto out; ret = count; out: return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Dave Hansen4438.94%110.00%
Anton Blanchard2623.01%110.00%
Zhang Zhen1210.62%110.00%
Yasunori Goto108.85%110.00%
Nikanth Karthikesan76.19%110.00%
Andi Kleen43.54%110.00%
Kay Sievers32.65%110.00%
John Allen32.65%110.00%
Fengguang Wu21.77%110.00%
Nathan Fontenot21.77%110.00%
Total113100.00%10100.00%

static DEVICE_ATTR(probe, S_IWUSR, NULL, memory_probe_store); #endif #ifdef CONFIG_MEMORY_FAILURE /* * Support for offlining pages of memory */ /* Soft offline a page */
static ssize_t store_soft_offline_page(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int ret; u64 pfn; if (!capable(CAP_SYS_ADMIN)) return -EPERM; if (kstrtoull(buf, 0, &pfn) < 0) 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; }

Contributors

PersonTokensPropCommitsCommitProp
Andi Kleen9193.81%240.00%
Kay Sievers33.09%120.00%
Fengguang Wu22.06%120.00%
Jingoo Han11.03%120.00%
Total97100.00%5100.00%

/* Forcibly offline a page, including killing processes. */
static ssize_t store_hard_offline_page(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int ret; u64 pfn; if (!capable(CAP_SYS_ADMIN)) return -EPERM; if (kstrtoull(buf, 0, &pfn) < 0) return -EINVAL; pfn >>= PAGE_SHIFT; ret = memory_failure(pfn, 0, 0); return ret ? ret : count; }

Contributors

PersonTokensPropCommitsCommitProp
Andi Kleen7591.46%233.33%
Kay Sievers33.66%116.67%
Fengguang Wu22.44%116.67%
Tony Luck11.22%116.67%
Jingoo Han11.22%116.67%
Total82100.00%6100.00%

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); #endif /* * Note that phys_device is optional. It is here to allow for * differentiation between which *physical* devices each * section belongs to... */
int __weak arch_get_memory_phys_device(unsigned long start_pfn) { return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Heiko Carstens13100.00%1100.00%
Total13100.00%1100.00%

/* * A reference for the returned object is held and the reference for the * hinted object is released. */
struct memory_block *find_memory_block_hinted(struct mem_section *section, struct memory_block *hint) { int block_id = base_memory_block_id(__section_nr(section)); struct device *hintdev = hint ? &hint->dev : NULL; struct device *dev; dev = subsys_find_device_by_id(&memory_subsys, block_id, hintdev); if (hint) put_device(&hint->dev); if (!dev) return NULL; return to_memory_block(dev); }

Contributors

PersonTokensPropCommitsCommitProp
Nathan Fontenot5564.71%250.00%
Kay Sievers2934.12%125.00%
Gu Zheng11.18%125.00%
Total85100.00%4100.00%

/* * 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. * * This could be made generic for all device subsystems. */
struct memory_block *find_memory_block(struct mem_section *section) { return find_memory_block_hinted(section, NULL); }

Contributors

PersonTokensPropCommitsCommitProp
Nathan Fontenot20100.00%1100.00%
Total20100.00%1100.00%

static struct attribute *memory_memblk_attrs[] = { &dev_attr_phys_index.attr, &dev_attr_state.attr, &dev_attr_phys_device.attr, &dev_attr_removable.attr, #ifdef CONFIG_MEMORY_HOTREMOVE &dev_attr_valid_zones.attr, #endif 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; memory->dev.offline = memory->state == MEM_OFFLINE; return device_register(&memory->dev); }

Contributors

PersonTokensPropCommitsCommitProp
Nathan Fontenot5681.16%133.33%
Linus Torvalds1217.39%133.33%
Seth Jennings11.45%133.33%
Total69100.00%3100.00%


static int init_memory_block(struct memory_block **memory, struct mem_section *section, unsigned long state) { struct memory_block *mem; unsigned long start_pfn; int scn_nr; int ret = 0; mem = kzalloc(sizeof(*mem), GFP_KERNEL); if (!mem) return -ENOMEM; scn_nr = __section_nr(section); 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; mem->state = state; start_pfn = section_nr_to_pfn(mem->start_section_nr); mem->phys_device = arch_get_memory_phys_device(start_pfn); ret = register_memory(mem); *memory = mem; return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Nathan Fontenot7356.59%457.14%
Dave Hansen4434.11%228.57%
Heiko Carstens129.30%114.29%
Total129100.00%7100.00%


static int add_memory_block(int base_section_nr) { struct memory_block *mem; int i, ret, section_count = 0, section_nr; 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++; } 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; }

Contributors

PersonTokensPropCommitsCommitProp
Seth Jennings5852.73%228.57%
Nathan Fontenot3128.18%228.57%
Yinghai Lu1110.00%114.29%
Dave Hansen76.36%114.29%
Heiko Carstens32.73%114.29%
Total110100.00%7100.00%

/* * 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) { int ret = 0; struct memory_block *mem; mutex_lock(&mem_sysfs_mutex); 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; mem->section_count++; } if (mem->section_count == sections_per_block) ret = register_mem_sect_under_node(mem, nid); out: mutex_unlock(&mem_sysfs_mutex); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Nathan Fontenot6962.73%220.00%
Seth Jennings1614.55%330.00%
Gary Hade1210.91%110.00%
Yinghai Lu65.45%110.00%
Dave Hansen43.64%110.00%
David Rientjes21.82%110.00%
Kay Sievers10.91%110.00%
Total110100.00%10100.00%

#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() */ put_device(&memory->dev); device_unregister(&memory->dev); }

Contributors

PersonTokensPropCommitsCommitProp
David Rientjes3997.50%150.00%
Seth Jennings12.50%150.00%
Total40100.00%2100.00%


static int remove_memory_section(unsigned long node_id, struct mem_section *section, int phys_device) { struct memory_block *mem; mutex_lock(&mem_sysfs_mutex); /* * Some users of the memory hotplug do not want/need memblock to * track all sections. Skip over those. */ mem = find_memory_block(section); if (!mem) goto out_unlock; unregister_mem_sect_under_nodes(mem, __section_nr(section)); mem->section_count--; if (mem->section_count == 0) unregister_memory(mem); else put_device(&mem->dev); out_unlock: mutex_unlock(&mem_sysfs_mutex); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Nathan Fontenot4447.31%440.00%
Dave Hansen3436.56%110.00%
Michal Hocko1111.83%110.00%
Seth Jennings22.15%220.00%
David Rientjes11.08%110.00%
Kay Sievers11.08%110.00%
Total93100.00%10100.00%


int unregister_memory_section(struct mem_section *section) { if (!present_section(section)) return -EINVAL; return remove_memory_section(0, section, 0); }

Contributors

PersonTokensPropCommitsCommitProp
Dave Hansen3093.75%133.33%
Seth Jennings13.12%133.33%
Andy Whitcroft13.12%133.33%
Total32100.00%3100.00%

#endif /* CONFIG_MEMORY_HOTREMOVE */ /* return true if the memory block is offlined, otherwise, return false */
bool is_memblock_offlined(struct memory_block *mem) { return mem->state == MEM_OFFLINE; }

Contributors

PersonTokensPropCommitsCommitProp
Yasuaki Ishimatsu17100.00%1100.00%
Total17100.00%1100.00%

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, &dev_attr_auto_online_blocks.attr, 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, }; /* * Initialize the sysfs support for memory devices... */
int __init memory_dev_init(void) { unsigned int i; int ret; int err; unsigned long block_sz; ret = subsys_system_register(&memory_subsys, memory_root_attr_groups); if (ret) goto out; block_sz = get_memory_block_size(); sections_per_block = block_sz / MIN_MEMORY_BLOCK_SIZE; /* * Create entries for memory sections that were found * during boot and have been initialized */ mutex_lock(&mem_sysfs_mutex); for (i = 0; i < NR_MEM_SECTIONS; i += sections_per_block) { /* Don't iterate over sections we know are !present: */ if (i > __highest_present_section_nr) break; err = add_memory_block(i); if (!ret) ret = err; } mutex_unlock(&mem_sysfs_mutex); out: if (ret) printk(KERN_ERR "%s() failed: %d\n", __func__, ret); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Dave Hansen5141.80%222.22%
Andrew Morton3629.51%111.11%
Nathan Fontenot1613.11%222.22%
Seth Jennings1512.30%222.22%
Kay Sievers32.46%111.11%
Harvey Harrison10.82%111.11%
Total122100.00%9100.00%


Overall Contributors

PersonTokensPropCommitsCommitProp
Dave Hansen74223.58%33.41%
Nathan Fontenot65520.81%89.09%
Andi Kleen2176.90%44.55%
Michal Hocko1825.78%44.55%
Seth Jennings1755.56%1011.36%
Rafael J. Wysocki1444.58%22.27%
Vitaly Kuznetsov1183.75%11.14%
Zhang Zhen1183.75%33.41%
Mel Gorman1053.34%11.14%
Robert Jennings772.45%11.14%
Kay Sievers742.35%22.27%
Badari Pulavarty652.07%11.14%
David Rientjes581.84%22.27%
Yasuaki Ishimatsu541.72%44.55%
Reza Arbab371.18%22.27%
Andrew Morton361.14%11.14%
Lai Jiangshan351.11%11.14%
Anton Blanchard290.92%22.27%
Heiko Carstens280.89%11.14%
Linus Torvalds210.67%44.55%
Gu Zheng200.64%11.14%
Yinghai Lu170.54%11.14%
Russ Anderson130.41%11.14%
Tang Chen130.41%22.27%
Gary Hade120.38%11.14%
Hannes Hering100.32%11.14%
Yasunori Goto100.32%11.14%
Toshi Kani100.32%11.14%
Fengguang Wu80.25%11.14%
Nikanth Karthikesan70.22%11.14%
Alan Stern70.22%11.14%
Wen Congyang60.19%22.27%
Michael Holzheu60.19%11.14%
David Shaohua Li40.13%11.14%
Greg Kroah-Hartman40.13%22.27%
Stephen Rothwell40.13%11.14%
Tejun Heo30.10%11.14%
Arjan van de Ven30.10%11.14%
John Allen30.10%11.14%
Daniel Walker30.10%11.14%
Sheng Yong30.10%11.14%
Randy Dunlap20.06%11.14%
Felipe Balbi20.06%11.14%
Harvey Harrison20.06%11.14%
Jingoo Han20.06%11.14%
Andy Whitcroft10.03%11.14%
Tony Luck10.03%11.14%
Arun Sharma10.03%11.14%
Total3147100.00%88100.00%
Directory: drivers/base
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.