mirror of
https://github.com/torvalds/linux.git
synced 2024-12-26 21:02:19 +00:00
9f960da72b
It is now allowed to use persistent memory like a regular RAM, but currently there is no way to remove this memory until machine is rebooted. This work expands the functionality to also allows hotremoving previously hotplugged persistent memory, and recover the device for use for other purposes. To hotremove persistent memory, the management software must first offline all memory blocks of dax region, and than unbind it from device-dax/kmem driver. So, operations should look like this: echo offline > /sys/devices/system/memory/memoryN/state ... echo dax0.0 > /sys/bus/dax/drivers/kmem/unbind Note: if unbind is done without offlining memory beforehand, it won't be possible to do dax0.0 hotremove, and dax's memory is going to be part of System RAM until reboot. Link: http://lkml.kernel.org/r/20190517215438.6487-4-pasha.tatashin@soleen.com Signed-off-by: Pavel Tatashin <pasha.tatashin@soleen.com> Reviewed-by: David Hildenbrand <david@redhat.com> Cc: James Morris <jmorris@namei.org> Cc: Sasha Levin <sashal@kernel.org> Cc: Michal Hocko <mhocko@suse.com> Cc: Dave Hansen <dave.hansen@linux.intel.com> Cc: Dan Williams <dan.j.williams@intel.com> Cc: Keith Busch <keith.busch@intel.com> Cc: Vishal Verma <vishal.l.verma@intel.com> Cc: Dave Jiang <dave.jiang@intel.com> Cc: Ross Zwisler <zwisler@kernel.org> Cc: Tom Lendacky <thomas.lendacky@amd.com> Cc: Huang Ying <ying.huang@intel.com> Cc: Fengguang Wu <fengguang.wu@intel.com> Cc: Borislav Petkov <bp@suse.de> Cc: Bjorn Helgaas <bhelgaas@google.com> Cc: Yaowei Bai <baiyaowei@cmss.chinamobile.com> Cc: Takashi Iwai <tiwai@suse.de> Cc: Jérôme Glisse <jglisse@redhat.com> Cc: Dave Hansen <dave.hansen@intel.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
145 lines
3.9 KiB
C
145 lines
3.9 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;
|
|
}
|
|
dev_dax->dax_kmem_res = new_res;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_MEMORY_HOTREMOVE
|
|
static int dev_dax_kmem_remove(struct device *dev)
|
|
{
|
|
struct dev_dax *dev_dax = to_dev_dax(dev);
|
|
struct resource *res = dev_dax->dax_kmem_res;
|
|
resource_size_t kmem_start = res->start;
|
|
resource_size_t kmem_size = resource_size(res);
|
|
int rc;
|
|
|
|
/*
|
|
* We have one shot for removing memory, if some memory blocks were not
|
|
* offline prior to calling this function remove_memory() will fail, and
|
|
* there is no way to hotremove this memory until reboot because device
|
|
* unbind will succeed even if we return failure.
|
|
*/
|
|
rc = remove_memory(dev_dax->target_node, kmem_start, kmem_size);
|
|
if (rc) {
|
|
dev_err(dev,
|
|
"DAX region %pR cannot be hotremoved until the next reboot\n",
|
|
res);
|
|
return rc;
|
|
}
|
|
|
|
/* Release and free dax resources */
|
|
release_resource(res);
|
|
kfree(res);
|
|
dev_dax->dax_kmem_res = NULL;
|
|
|
|
return 0;
|
|
}
|
|
#else
|
|
static int dev_dax_kmem_remove(struct device *dev)
|
|
{
|
|
/*
|
|
* Without hotremove 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;
|
|
}
|
|
#endif /* CONFIG_MEMORY_HOTREMOVE */
|
|
|
|
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);
|