Release 4.7 drivers/base/memory.c

Directory: drivers/base
/*
 * 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 <asm/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
Person Tokens Prop Commits CommitProp
nathan fontenot nathan fontenot 15 100.00% 1 100.00%
Total 15 100.00% 1 100.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
Person Tokens Prop Commits CommitProp
dave hansen dave hansen 18 94.74% 1 50.00%
alan stern alan stern 1 5.26% 1 50.00%
Total 19 100.00% 2 100.00%


EXPORT_SYMBOL(register_memory_notifier);



void unregister_memory_notifier(struct notifier_block *nb)
{
	blocking_notifier_chain_unregister(&memory_chain, nb);
}
Contributors
Person Tokens Prop Commits CommitProp
dave hansen dave hansen 17 94.44% 1 50.00%
alan stern alan stern 1 5.56% 1 50.00%
Total 18 100.00% 2 100.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
Person Tokens Prop Commits CommitProp
robert jennings robert jennings 19 100.00% 1 100.00%
Total 19 100.00% 1 100.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
Person Tokens Prop Commits CommitProp
robert jennings robert jennings 18 100.00% 1 100.00%
Total 18 100.00% 1 100.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
Person Tokens Prop Commits CommitProp
yasuaki ishimatsu yasuaki ishimatsu 25 96.15% 1 50.00%
gu zheng gu zheng 1 3.85% 1 50.00%
Total 26 100.00% 2 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
nathan fontenot nathan fontenot 12 100.00% 1 100.00%
Total 12 100.00% 1 100.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
Person Tokens Prop Commits CommitProp
nathan fontenot nathan fontenot 51 100.00% 1 100.00%
Total 51 100.00% 1 100.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
Person Tokens Prop Commits CommitProp
dave hansen dave hansen 28 53.85% 1 20.00%
nathan fontenot nathan fontenot 17 32.69% 1 20.00%
andi kleen andi kleen 4 7.69% 1 20.00%
kay sievers kay sievers 2 3.85% 1 20.00%
gu zheng gu zheng 1 1.92% 1 20.00%
Total 52 100.00% 5 100.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);

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

	return sprintf(buf, "%d\n", ret);
}

Contributors
Person Tokens Prop Commits CommitProp
badari pulavarty badari pulavarty 53 53.54% 1 14.29%
nathan fontenot nathan fontenot 26 26.26% 2 28.57%
russ anderson russ anderson 13 13.13% 1 14.29%
stephen rothwell stephen rothwell 4 4.04% 1 14.29%
kay sievers kay sievers 2 2.02% 1 14.29%
gu zheng gu zheng 1 1.01% 1 14.29%
Total 99 100.00% 7 100.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
Person Tokens Prop Commits CommitProp
dave hansen dave hansen 99 93.40% 1 25.00%
andi kleen andi kleen 4 3.77% 1 25.00%
kay sievers kay sievers 2 1.89% 1 25.00%
gu zheng gu zheng 1 0.94% 1 25.00%
Total 106 100.00% 4 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
dave hansen dave hansen 23 95.83% 1 50.00%
alan stern alan stern 1 4.17% 1 50.00%
Total 24 100.00% 2 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
robert jennings robert jennings 24 100.00% 1 100.00%
Total 24 100.00% 1 100.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
Person Tokens Prop Commits CommitProp
mel gorman mel gorman 61 54.46% 1 25.00%
dave hansen dave hansen 45 40.18% 1 25.00%
nathan fontenot nathan fontenot 3 2.68% 1 25.00%
greg kroah-hartman greg kroah-hartman 3 2.68% 1 25.00%
Total 112 100.00% 4 100.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;
	struct page *first_page;
	int ret;

	start_pfn = section_nr_to_pfn(phys_index);
	first_page = pfn_to_page(start_pfn);

	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
Person Tokens Prop Commits CommitProp
dave hansen dave hansen 48 39.02% 1 10.00%
mel gorman mel gorman 48 39.02% 1 10.00%
wen congyang wen congyang 6 4.88% 1 10.00%
lai jiangshan lai jiangshan 5 4.07% 1 10.00%
zhang zhen zhang zhen 4 3.25% 1 10.00%
sheng yong sheng yong 3 2.44% 1 10.00%
arjan van de ven arjan van de ven 3 2.44% 1 10.00%
nathan fontenot nathan fontenot 3 2.44% 1 10.00%
anton blanchard anton blanchard 2 1.63% 1 10.00%
harvey harrison harvey harrison 1 0.81% 1 10.00%
Total 123 100.00% 10 100.00%



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
Person Tokens Prop Commits CommitProp
dave hansen dave hansen 39 52.00% 1 11.11%
nathan fontenot nathan fontenot 20 26.67% 2 22.22%
rafael j. wysocki rafael j. wysocki 9 12.00% 2 22.22%
seth jennings seth jennings 3 4.00% 1 11.11%
lai jiangshan lai jiangshan 2 2.67% 1 11.11%
anton blanchard anton blanchard 1 1.33% 1 11.11%
michael holzheu michael holzheu 1 1.33% 1 11.11%
Total 75 100.00% 9 100.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
Person Tokens Prop Commits CommitProp
rafael j. wysocki rafael j. wysocki 40 54.79% 1 16.67%
seth jennings seth jennings 27 36.99% 1 16.67%
dave hansen dave hansen 3 4.11% 1 16.67%
tang chen tang chen 1 1.37% 1 16.67%
david rientjes david rientjes 1 1.37% 1 16.67%
gu zheng gu zheng 1 1.37% 1 16.67%
Total 73 100.00% 6 100.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
Person Tokens Prop Commits CommitProp
rafael j. wysocki rafael j. wysocki 36 65.45% 1 20.00%
seth jennings seth jennings 15 27.27% 2 40.00%
wen congyang wen congyang 3 5.45% 1 20.00%
gu zheng gu zheng 1 1.82% 1 20.00%
Total 55 100.00% 5 100.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)
		return ret;
	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
dave hansen dave hansen 48 25.00% 1 7.69%
seth jennings seth jennings 36 18.75% 1 7.69%
rafael j. wysocki rafael j. wysocki 28 14.58% 1 7.69%
lai jiangshan lai jiangshan 27 14.06% 1 7.69%
tang chen tang chen 12 6.25% 2 15.38%
yasuaki ishimatsu yasuaki ishimatsu 10 5.21% 1 7.69%
linus torvalds linus torvalds 7 3.65% 1 7.69%
michael holzheu michael holzheu 7 3.65% 1 7.69%
david rientjes david rientjes 7 3.65% 1 7.69%
gu zheng gu zheng 5 2.60% 1 7.69%
andi kleen andi kleen 3 1.56% 1 7.69%
kay sievers kay sievers 2 1.04% 1 7.69%
Total 192 100.00% 13 100.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
Person Tokens Prop Commits CommitProp
dave hansen dave hansen 35 83.33% 1 25.00%
andi kleen andi kleen 4 9.52% 1 25.00%
kay sievers kay sievers 2 4.76% 1 25.00%
gu zheng gu zheng 1 2.38% 1 25.00%
Total 42 100.00% 4 100.00%

#ifdef CONFIG_MEMORY_HOTREMOVE


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, end_pfn;
	unsigned long nr_pages = PAGES_PER_SECTION * sections_per_block;
	struct page *first_page;
	struct zone *zone;

	start_pfn = section_nr_to_pfn(mem->start_section_nr);
	end_pfn = start_pfn + nr_pages;
	first_page = pfn_to_page(start_pfn);

	/* The block contains more than one zone can not be offlined. */
	if (!test_pages_in_a_zone(start_pfn, end_pfn))
		return sprintf(buf, "none\n");

	zone = page_zone(first_page);

	if (zone_idx(zone) == ZONE_MOVABLE - 1) {
		/*The mem block is the last memoryblock of this zone.*/
		if (end_pfn == zone_end_pfn(zone))
			return sprintf(buf, "%s %s\n",
					zone->name, (zone + 1)->name);
	}

	if (zone_idx(zone) == ZONE_MOVABLE) {
		/*The mem block is the first memoryblock of ZONE_MOVABLE.*/
		if (start_pfn == zone->zone_start_pfn)
			return sprintf(buf, "%s %s\n",
					zone->name, (zone - 1)->name);
	}

	return sprintf(buf, "%s\n", zone->name);
}
Contributors
Person Tokens Prop Commits CommitProp
zhang zhen zhang zhen 197 100.00% 1 100.00%
Total 197 100.00% 1 100.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
Person Tokens Prop Commits CommitProp
dave hansen dave hansen 19 61.29% 1 16.67%
andi kleen andi kleen 4 12.90% 1 16.67%
kay sievers kay sievers 3 9.68% 1 16.67%
nathan fontenot nathan fontenot 2 6.45% 1 16.67%
fengguang wu fengguang wu 2 6.45% 1 16.67%
linus torvalds linus torvalds 1 3.23% 1 16.67%
Total 31 100.00% 6 100.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
Person Tokens Prop Commits CommitProp
vitaly kuznetsov vitaly kuznetsov 41 100.00% 1 100.00%
Total 41 100.00% 1 100.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
Person Tokens Prop Commits CommitProp
vitaly kuznetsov vitaly kuznetsov 59 100.00% 1 100.00%
Total 59 100.00% 1 100.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
Person Tokens Prop Commits CommitProp
dave hansen dave hansen 44 38.94% 1 10.00%
anton blanchard anton blanchard 26 23.01% 1 10.00%
zhang zhen zhang zhen 12 10.62% 1 10.00%
yasunori goto yasunori goto 10 8.85% 1 10.00%
nikanth karthikesan nikanth karthikesan 7 6.19% 1 10.00%
andi kleen andi kleen 4 3.54% 1 10.00%
john allen john allen 3 2.65% 1 10.00%
kay sievers kay sievers 3 2.65% 1 10.00%
fengguang wu fengguang wu 2 1.77% 1 10.00%
nathan fontenot nathan fontenot 2 1.77% 1 10.00%
Total 113 100.00% 10 100.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
Person Tokens Prop Commits CommitProp
andi kleen andi kleen 91 93.81% 2 40.00%
kay sievers kay sievers 3 3.09% 1 20.00%
fengguang wu fengguang wu 2 2.06% 1 20.00%
jingoo han jingoo han 1 1.03% 1 20.00%
Total 97 100.00% 5 100.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
Person Tokens Prop Commits CommitProp
andi kleen andi kleen 75 91.46% 2 33.33%
kay sievers kay sievers 3 3.66% 1 16.67%
fengguang wu fengguang wu 2 2.44% 1 16.67%
tony luck tony luck 1 1.22% 1 16.67%
jingoo han jingoo han 1 1.22% 1 16.67%
Total 82 100.00% 6 100.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
Person Tokens Prop Commits CommitProp
heiko carstens heiko carstens 13 100.00% 1 100.00%
Total 13 100.00% 1 100.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
Person Tokens Prop Commits CommitProp
nathan fontenot nathan fontenot 55 64.71% 2 50.00%
kay sievers kay sievers 29 34.12% 1 25.00%
gu zheng gu zheng 1 1.18% 1 25.00%
Total 85 100.00% 4 100.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
Person Tokens Prop Commits CommitProp
nathan fontenot nathan fontenot 20 100.00% 1 100.00%
Total 20 100.00% 1 100.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
Person Tokens Prop Commits CommitProp
nathan fontenot nathan fontenot 56 81.16% 1 33.33%
linus torvalds linus torvalds 12 17.39% 1 33.33%
seth jennings seth jennings 1 1.45% 1 33.33%
Total 69 100.00% 3 100.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
Person Tokens Prop Commits CommitProp
dave hansen dave hansen 62 48.06% 2 33.33%
nathan fontenot nathan fontenot 55 42.64% 3 50.00%
heiko carstens heiko carstens 12 9.30% 1 16.67%
Total 129 100.00% 6 100.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
Person Tokens Prop Commits CommitProp
seth jennings seth jennings 58 52.73% 2 28.57%
nathan fontenot nathan fontenot 31 28.18% 2 28.57%
yinghai lu yinghai lu 11 10.00% 1 14.29%
dave hansen dave hansen 7 6.36% 1 14.29%
heiko carstens heiko carstens 3 2.73% 1 14.29%
Total 110 100.00% 7 100.00%



static bool is_zone_device_section(struct mem_section *ms)
{
	struct page *page;

	page = sparse_decode_mem_map(ms->section_mem_map, __section_nr(ms));
	return is_zone_device_page(page);
}

Contributors
Person Tokens Prop Commits CommitProp
dan williams dan williams 36 100.00% 1 100.00%
Total 36 100.00% 1 100.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;

	if (is_zone_device_section(section))
		return 0;

	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
Person Tokens Prop Commits CommitProp
nathan fontenot nathan fontenot 69 57.50% 2 18.18%
seth jennings seth jennings 16 13.33% 3 27.27%
gary hade gary hade 12 10.00% 1 9.09%
dan williams dan williams 10 8.33% 1 9.09%
yinghai lu yinghai lu 6 5.00% 1 9.09%
dave hansen dave hansen 4 3.33% 1 9.09%
david rientjes david rientjes 2 1.67% 1 9.09%
kay sievers kay sievers 1 0.83% 1 9.09%
Total 120 100.00% 11 100.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
Person Tokens Prop Commits CommitProp
david rientjes david rientjes 39 97.50% 1 50.00%
seth jennings seth jennings 1 2.50% 1 50.00%
Total 40 100.00% 2 100.00%



static int remove_memory_section(unsigned long node_id,
			       struct mem_section *section, int phys_device)
{
	struct memory_block *mem;

	if (is_zone_device_section(section))
		return 0;

	mutex_lock(&mem_sysfs_mutex);
	mem = find_memory_block(section);
	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);

	mutex_unlock(&mem_sysfs_mutex);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
nathan fontenot nathan fontenot 44 47.83% 4 40.00%
dave hansen dave hansen 34 36.96% 1 10.00%
dan williams dan williams 10 10.87% 1 10.00%
seth jennings seth jennings 2 2.17% 2 20.00%
david rientjes david rientjes 1 1.09% 1 10.00%
kay sievers kay sievers 1 1.09% 1 10.00%
Total 92 100.00% 10 100.00%



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

	return remove_memory_section(0, section, 0);
}
Contributors
Person Tokens Prop Commits CommitProp
dave hansen dave hansen 30 93.75% 1 33.33%
andy whitcroft andy whitcroft 1 3.12% 1 33.33%
seth jennings seth jennings 1 3.12% 1 33.33%
Total 32 100.00% 3 100.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
Person Tokens Prop Commits CommitProp
yasuaki ishimatsu yasuaki ishimatsu 17 100.00% 1 100.00%
Total 17 100.00% 1 100.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) {
		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
Person Tokens Prop Commits CommitProp
dave hansen dave hansen 43 37.72% 1 12.50%
andrew morton andrew morton 36 31.58% 1 12.50%
nathan fontenot nathan fontenot 16 14.04% 2 25.00%
seth jennings seth jennings 15 13.16% 2 25.00%
kay sievers kay sievers 3 2.63% 1 12.50%
harvey harrison harvey harrison 1 0.88% 1 12.50%
Total 114 100.00% 8 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
dave hansen dave hansen 748 24.18% 2 2.60%
nathan fontenot nathan fontenot 641 20.72% 7 9.09%
zhang zhen zhang zhen 240 7.76% 3 3.90%
andi kleen andi kleen 217 7.01% 4 5.19%
seth jennings seth jennings 176 5.69% 10 12.99%
rafael j. wysocki rafael j. wysocki 143 4.62% 2 2.60%
vitaly kuznetsov vitaly kuznetsov 118 3.81% 1 1.30%
mel gorman mel gorman 110 3.56% 1 1.30%
robert jennings robert jennings 77 2.49% 1 1.30%
kay sievers kay sievers 74 2.39% 2 2.60%
badari pulavarty badari pulavarty 65 2.10% 1 1.30%
david rientjes david rientjes 58 1.87% 2 2.60%
dan williams dan williams 56 1.81% 1 1.30%
yasuaki ishimatsu yasuaki ishimatsu 53 1.71% 3 3.90%
andrew morton andrew morton 36 1.16% 1 1.30%
lai jiangshan lai jiangshan 34 1.10% 1 1.30%
anton blanchard anton blanchard 29 0.94% 2 2.60%
heiko carstens heiko carstens 28 0.90% 1 1.30%
linus torvalds linus torvalds 20 0.65% 3 3.90%
gu zheng gu zheng 20 0.65% 1 1.30%
yinghai lu yinghai lu 17 0.55% 1 1.30%
tang chen tang chen 13 0.42% 2 2.60%
russ anderson russ anderson 13 0.42% 1 1.30%
gary hade gary hade 12 0.39% 1 1.30%
hannes hering hannes hering 10 0.32% 1 1.30%
yasunori goto yasunori goto 10 0.32% 1 1.30%
wen congyang wen congyang 9 0.29% 2 2.60%
michael holzheu michael holzheu 8 0.26% 1 1.30%
fengguang wu fengguang wu 8 0.26% 1 1.30%
alan stern alan stern 7 0.23% 1 1.30%
nikanth karthikesan nikanth karthikesan 7 0.23% 1 1.30%
stephen rothwell stephen rothwell 4 0.13% 1 1.30%
li shaohua li shaohua 4 0.13% 1 1.30%
arjan van de ven arjan van de ven 3 0.10% 1 1.30%
greg kroah-hartman greg kroah-hartman 3 0.10% 1 1.30%
john allen john allen 3 0.10% 1 1.30%
tejun heo tejun heo 3 0.10% 1 1.30%
daniel walker daniel walker 3 0.10% 1 1.30%
sheng yong sheng yong 3 0.10% 1 1.30%
felipe balbi felipe balbi 2 0.06% 1 1.30%
randy dunlap randy dunlap 2 0.06% 1 1.30%
jingoo han jingoo han 2 0.06% 1 1.30%
harvey harrison harvey harrison 2 0.06% 1 1.30%
andy whitcroft andy whitcroft 1 0.03% 1 1.30%
arun sharma arun sharma 1 0.03% 1 1.30%
tony luck tony luck 1 0.03% 1 1.30%
Total 3094 100.00% 77 100.00%
  Directory: drivers/base

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
nathan fontenot	nathan fontenot	15	100.00%	1	100.00%
	Total	15	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 drivers/base/memory.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
