mirror of
https://github.com/torvalds/linux.git
synced 2024-11-22 20:22:09 +00:00
31e4ca92a7
Patch series ""Hotremove" persistent memory", v6.
Recently, adding a persistent memory to be used like a regular RAM was
added to Linux. This work extends this functionality to also allow hot
removing persistent memory.
We (Microsoft) have an important use case for this functionality.
The requirement is for physical machines with small amount of RAM (~8G)
to be able to reboot in a very short period of time (<1s). Yet, there
is a userland state that is expensive to recreate (~2G).
The solution is to boot machines with 2G preserved for persistent
memory.
Copy the state, and hotadd the persistent memory so machine still has
all 8G available for runtime. Before reboot, offline and hotremove
device-dax 2G, copy the memory that is needed to be preserved to pmem0
device, and reboot.
The series of operations look like this:
1. After boot restore /dev/pmem0 to ramdisk to be consumed by apps.
and free ramdisk.
2. Convert raw pmem0 to devdax
ndctl create-namespace --mode devdax --map mem -e namespace0.0 -f
3. Hotadd to System RAM
echo dax0.0 > /sys/bus/dax/drivers/device_dax/unbind
echo dax0.0 > /sys/bus/dax/drivers/kmem/new_id
echo online_movable > /sys/devices/system/memoryXXX/state
4. Before reboot hotremove device-dax memory from System RAM
echo offline > /sys/devices/system/memoryXXX/state
echo dax0.0 > /sys/bus/dax/drivers/kmem/unbind
5. Create raw pmem0 device
ndctl create-namespace --mode raw -e namespace0.0 -f
6. Copy the state that was stored by apps to ramdisk to pmem device
7. Do kexec reboot or reboot through firmware if firmware does not
zero memory in pmem0 region (These machines have only regular
volatile memory). So to have pmem0 device either memmap kernel
parameter is used, or devices nodes in dtb are specified.
This patch (of 3):
When add_memory() fails, the resource and the memory should be freed.
Link: http://lkml.kernel.org/r/20190517215438.6487-2-pasha.tatashin@soleen.com
Fixes: c221c0b030 ("device-dax: "Hotplug" persistent memory for use like normal RAM")
Signed-off-by: Pavel Tatashin <pasha.tatashin@soleen.com>
Reviewed-by: Dave Hansen <dave.hansen@intel.com>
Cc: Bjorn Helgaas <bhelgaas@google.com>
Cc: Borislav Petkov <bp@suse.de>
Cc: Dan Williams <dan.j.williams@intel.com>
Cc: Dave Hansen <dave.hansen@linux.intel.com>
Cc: Dave Jiang <dave.jiang@intel.com>
Cc: David Hildenbrand <david@redhat.com>
Cc: Fengguang Wu <fengguang.wu@intel.com>
Cc: Huang Ying <ying.huang@intel.com>
Cc: James Morris <jmorris@namei.org>
Cc: Jérôme Glisse <jglisse@redhat.com>
Cc: Keith Busch <keith.busch@intel.com>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Ross Zwisler <zwisler@kernel.org>
Cc: Sasha Levin <sashal@kernel.org>
Cc: Takashi Iwai <tiwai@suse.de>
Cc: Tom Lendacky <thomas.lendacky@amd.com>
Cc: Vishal Verma <vishal.l.verma@intel.com>
Cc: Yaowei Bai <baiyaowei@cmss.chinamobile.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
112 lines
3.0 KiB
C
112 lines
3.0 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/* Copyright(c) 2016-2019 Intel Corporation. All rights reserved. */
|
|
#include <linux/memremap.h>
|
|
#include <linux/pagemap.h>
|
|
#include <linux/memory.h>
|
|
#include <linux/module.h>
|
|
#include <linux/device.h>
|
|
#include <linux/pfn_t.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/dax.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/mman.h>
|
|
#include "dax-private.h"
|
|
#include "bus.h"
|
|
|
|
int dev_dax_kmem_probe(struct device *dev)
|
|
{
|
|
struct dev_dax *dev_dax = to_dev_dax(dev);
|
|
struct resource *res = &dev_dax->region->res;
|
|
resource_size_t kmem_start;
|
|
resource_size_t kmem_size;
|
|
resource_size_t kmem_end;
|
|
struct resource *new_res;
|
|
int numa_node;
|
|
int rc;
|
|
|
|
/*
|
|
* Ensure good NUMA information for the persistent memory.
|
|
* Without this check, there is a risk that slow memory
|
|
* could be mixed in a node with faster memory, causing
|
|
* unavoidable performance issues.
|
|
*/
|
|
numa_node = dev_dax->target_node;
|
|
if (numa_node < 0) {
|
|
dev_warn(dev, "rejecting DAX region %pR with invalid node: %d\n",
|
|
res, numa_node);
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* Hotplug starting at the beginning of the next block: */
|
|
kmem_start = ALIGN(res->start, memory_block_size_bytes());
|
|
|
|
kmem_size = resource_size(res);
|
|
/* Adjust the size down to compensate for moving up kmem_start: */
|
|
kmem_size -= kmem_start - res->start;
|
|
/* Align the size down to cover only complete blocks: */
|
|
kmem_size &= ~(memory_block_size_bytes() - 1);
|
|
kmem_end = kmem_start + kmem_size;
|
|
|
|
/* Region is permanently reserved. Hot-remove not yet implemented. */
|
|
new_res = request_mem_region(kmem_start, kmem_size, dev_name(dev));
|
|
if (!new_res) {
|
|
dev_warn(dev, "could not reserve region [%pa-%pa]\n",
|
|
&kmem_start, &kmem_end);
|
|
return -EBUSY;
|
|
}
|
|
|
|
/*
|
|
* Set flags appropriate for System RAM. Leave ..._BUSY clear
|
|
* so that add_memory() can add a child resource. Do not
|
|
* inherit flags from the parent since it may set new flags
|
|
* unknown to us that will break add_memory() below.
|
|
*/
|
|
new_res->flags = IORESOURCE_SYSTEM_RAM;
|
|
new_res->name = dev_name(dev);
|
|
|
|
rc = add_memory(numa_node, new_res->start, resource_size(new_res));
|
|
if (rc) {
|
|
release_resource(new_res);
|
|
kfree(new_res);
|
|
return rc;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int dev_dax_kmem_remove(struct device *dev)
|
|
{
|
|
/*
|
|
* Purposely leak the request_mem_region() for the device-dax
|
|
* range and return '0' to ->remove() attempts. The removal of
|
|
* the device from the driver always succeeds, but the region
|
|
* is permanently pinned as reserved by the unreleased
|
|
* request_mem_region().
|
|
*/
|
|
return 0;
|
|
}
|
|
|
|
static struct dax_device_driver device_dax_kmem_driver = {
|
|
.drv = {
|
|
.probe = dev_dax_kmem_probe,
|
|
.remove = dev_dax_kmem_remove,
|
|
},
|
|
};
|
|
|
|
static int __init dax_kmem_init(void)
|
|
{
|
|
return dax_driver_register(&device_dax_kmem_driver);
|
|
}
|
|
|
|
static void __exit dax_kmem_exit(void)
|
|
{
|
|
dax_driver_unregister(&device_dax_kmem_driver);
|
|
}
|
|
|
|
MODULE_AUTHOR("Intel Corporation");
|
|
MODULE_LICENSE("GPL v2");
|
|
module_init(dax_kmem_init);
|
|
module_exit(dax_kmem_exit);
|
|
MODULE_ALIAS_DAX_DEVICE(0);
|