dax: Assign RAM regions to memory-hotplug by default

The default mode for device-dax instances is backwards for RAM-regions
as evidenced by the fact that it tends to catch end users by surprise.
"Where is my memory?". Recall that platforms are increasingly shipping
with performance-differentiated memory pools beyond typical DRAM and
NUMA effects. This includes HBM (high-bandwidth-memory) and CXL (dynamic
interleave, varied media types, and future fabric attached
possibilities).

For this reason the EFI_MEMORY_SP (EFI Special Purpose Memory => Linux
'Soft Reserved') attribute is expected to be applied to all memory-pools
that are not the general purpose pool. This designation gives an
Operating System a chance to defer usage of a memory pool until later in
the boot process where its performance properties can be interrogated
and administrator policy can be applied.

'Soft Reserved' memory can be anything from too limited and precious to
be part of the general purpose pool (HBM), too slow to host hot kernel
data structures (some PMEM media), or anything in between. However, in
the absence of an explicit policy, the memory should at least be made
usable by default. The current device-dax default hides all
non-general-purpose memory behind a device interface.

The expectation is that the distribution of users that want the memory
online by default vs device-dedicated-access by default follows the
Pareto principle. A small number of enlightened users may want to do
userspace memory management through a device, but general users just
want the kernel to make the memory available with an option to get more
advanced later.

Arrange for all device-dax instances not backed by PMEM to default to
attaching to the dax_kmem driver. From there the baseline memory hotplug
policy (CONFIG_MEMORY_HOTPLUG_DEFAULT_ONLINE / memhp_default_state=)
gates whether the memory comes online or stays offline. Where, if it
stays offline, it can be reliably converted back to device-mode where it
can be partitioned, or fronted by a userspace allocator.

So, if someone wants device-dax instances for their 'Soft Reserved'
memory:

1/ Build a kernel with CONFIG_MEMORY_HOTPLUG_DEFAULT_ONLINE=n or boot
   with memhp_default_state=offline, or roll the dice and hope that the
   kernel has not pinned a page in that memory before step 2.

2/ Write a udev rule to convert the target dax device(s) from
   'system-ram' mode to 'devdax' mode:

   daxctl reconfigure-device $dax -m devdax -f

Cc: Michal Hocko <mhocko@suse.com>
Cc: David Hildenbrand <david@redhat.com>
Cc: Dave Hansen <dave.hansen@linux.intel.com>
Reviewed-by: Gregory Price <gregory.price@memverge.com>
Tested-by: Fan Ni <fan.ni@samsung.com>
Reviewed-by: Dave Jiang <dave.jiang@intel.com>
Link: https://lore.kernel.org/r/167602003336.1924368.6809503401422267885.stgit@dwillia2-xfh.jf.intel.com
Signed-off-by: Dan Williams <dan.j.williams@intel.com>

diff --git a/drivers/dax/Kconfig b/drivers/dax/Kconfig
index d13c889c2a6464804b40e0aa7b8abac5a1700894..1163eb62e5f69e3be7205950e475f98fe12a6c43 100644 (file)
--- a/drivers/dax/Kconfig
+++ b/drivers/dax/Kconfig
@@ -50,7 +50,7 @@ config DEV_DAX_HMEM_DEVICES
        def_bool y
 
 config DEV_DAX_KMEM
-       tristate "KMEM DAX: volatile-use of persistent memory"
+       tristate "KMEM DAX: map dax-devices as System-RAM"
        default DEV_DAX
        depends on DEV_DAX
        depends on MEMORY_HOTPLUG # for add_memory() and friends

diff --git a/drivers/dax/bus.c b/drivers/dax/bus.c
index 1dad813ee4a6907b2370ea2e6e861b3cbd9b6a85..012d576004e9f610a4744986730ec5671cc9c501 100644 (file)
--- a/drivers/dax/bus.c
+++ b/drivers/dax/bus.c
@@ -56,6 +56,25 @@ static int dax_match_id(struct dax_device_driver *dax_drv, struct device *dev)
        return match;
 }
 
+static int dax_match_type(struct dax_device_driver *dax_drv, struct device *dev)
+{
+       enum dax_driver_type type = DAXDRV_DEVICE_TYPE;
+       struct dev_dax *dev_dax = to_dev_dax(dev);
+
+       if (dev_dax->region->res.flags & IORESOURCE_DAX_KMEM)
+               type = DAXDRV_KMEM_TYPE;
+
+       if (dax_drv->type == type)
+               return 1;
+
+       /* default to device mode if dax_kmem is disabled */
+       if (dax_drv->type == DAXDRV_DEVICE_TYPE &&
+           !IS_ENABLED(CONFIG_DEV_DAX_KMEM))
+               return 1;
+
+       return 0;
+}
+
 enum id_action {
        ID_REMOVE,
        ID_ADD,
@@ -216,14 +235,9 @@ static int dax_bus_match(struct device *dev, struct device_driver *drv)
 {
        struct dax_device_driver *dax_drv = to_dax_drv(drv);
 
-       /*
-        * All but the 'device-dax' driver, which has 'match_always'
-        * set, requires an exact id match.
-        */
-       if (dax_drv->match_always)
+       if (dax_match_id(dax_drv, dev))
                return 1;
-
-       return dax_match_id(dax_drv, dev);
+       return dax_match_type(dax_drv, dev);
 }
 
 /*
@@ -1413,13 +1427,10 @@ struct dev_dax *devm_create_dev_dax(struct dev_dax_data *data)
 }
 EXPORT_SYMBOL_GPL(devm_create_dev_dax);
 
-static int match_always_count;
-
 int __dax_driver_register(struct dax_device_driver *dax_drv,
                struct module *module, const char *mod_name)
 {
        struct device_driver *drv = &dax_drv->drv;
-       int rc = 0;
 
        /*
         * dax_bus_probe() calls dax_drv->probe() unconditionally.
@@ -1434,26 +1445,7 @@ int __dax_driver_register(struct dax_device_driver *dax_drv,
        drv->mod_name = mod_name;
        drv->bus = &dax_bus_type;
 
-       /* there can only be one default driver */
-       mutex_lock(&dax_bus_lock);
-       match_always_count += dax_drv->match_always;
-       if (match_always_count > 1) {
-               match_always_count--;
-               WARN_ON(1);
-               rc = -EINVAL;
-       }
-       mutex_unlock(&dax_bus_lock);
-       if (rc)
-               return rc;
-
-       rc = driver_register(drv);
-       if (rc && dax_drv->match_always) {
-               mutex_lock(&dax_bus_lock);
-               match_always_count -= dax_drv->match_always;
-               mutex_unlock(&dax_bus_lock);
-       }
-
-       return rc;
+       return driver_register(drv);
 }
 EXPORT_SYMBOL_GPL(__dax_driver_register);
 
@@ -1463,7 +1455,6 @@ void dax_driver_unregister(struct dax_device_driver *dax_drv)
        struct dax_id *dax_id, *_id;
 
        mutex_lock(&dax_bus_lock);
-       match_always_count -= dax_drv->match_always;
        list_for_each_entry_safe(dax_id, _id, &dax_drv->ids, list) {
                list_del(&dax_id->list);
                kfree(dax_id);

diff --git a/drivers/dax/bus.h b/drivers/dax/bus.h
index fbb940293d6d84384b6fa37eb412790249b4ecf7..8cd79ab34292c7267f10f9bb7e44194aec108d6c 100644 (file)
--- a/drivers/dax/bus.h
+++ b/drivers/dax/bus.h
@@ -11,7 +11,10 @@ struct dax_device;
 struct dax_region;
 void dax_region_put(struct dax_region *dax_region);
 
-#define IORESOURCE_DAX_STATIC (1UL << 0)
+/* dax bus specific ioresource flags */
+#define IORESOURCE_DAX_STATIC BIT(0)
+#define IORESOURCE_DAX_KMEM BIT(1)
+
 struct dax_region *alloc_dax_region(struct device *parent, int region_id,
                struct range *range, int target_node, unsigned int align,
                unsigned long flags);
@@ -25,10 +28,15 @@ struct dev_dax_data {
 
 struct dev_dax *devm_create_dev_dax(struct dev_dax_data *data);
 
+enum dax_driver_type {
+       DAXDRV_KMEM_TYPE,
+       DAXDRV_DEVICE_TYPE,
+};
+
 struct dax_device_driver {
        struct device_driver drv;
        struct list_head ids;
-       int match_always;
+       enum dax_driver_type type;
        int (*probe)(struct dev_dax *dev);
        void (*remove)(struct dev_dax *dev);
 };

diff --git a/drivers/dax/device.c b/drivers/dax/device.c
index 5494d745ced58ad9fc12bfa2e8fc0ab71ad3548c..ecdff79e31f2acb2cf2cdfe2330264090722e91e 100644 (file)
--- a/drivers/dax/device.c
+++ b/drivers/dax/device.c
@@ -475,8 +475,7 @@ EXPORT_SYMBOL_GPL(dev_dax_probe);
 
 static struct dax_device_driver device_dax_driver = {
        .probe = dev_dax_probe,
-       /* all probe actions are unwound by devm, so .remove isn't necessary */
-       .match_always = 1,
+       .type = DAXDRV_DEVICE_TYPE,
 };
 
 static int __init dax_init(void)

diff --git a/drivers/dax/hmem/hmem.c b/drivers/dax/hmem/hmem.c
index e7bdff3132fa3699610b76f28fc5c394b3dbee19..5ec08f9f8a57afab92a68ad028647c0614a39327 100644 (file)
--- a/drivers/dax/hmem/hmem.c
+++ b/drivers/dax/hmem/hmem.c
@@ -11,15 +11,25 @@ module_param_named(region_idle, region_idle, bool, 0644);
 
 static int dax_hmem_probe(struct platform_device *pdev)
 {
+       unsigned long flags = IORESOURCE_DAX_KMEM;
        struct device *dev = &pdev->dev;
        struct dax_region *dax_region;
        struct memregion_info *mri;
        struct dev_dax_data data;
        struct dev_dax *dev_dax;
 
+       /*
+        * @region_idle == true indicates that an administrative agent
+        * wants to manipulate the range partitioning before the devices
+        * are created, so do not send them to the dax_kmem driver by
+        * default.
+        */
+       if (region_idle)
+               flags = 0;
+
        mri = dev->platform_data;
        dax_region = alloc_dax_region(dev, pdev->id, &mri->range,
-                                     mri->target_node, PMD_SIZE, 0);
+                                     mri->target_node, PMD_SIZE, flags);
        if (!dax_region)
                return -ENOMEM;
 

diff --git a/drivers/dax/kmem.c b/drivers/dax/kmem.c
index 4852a2dbdb278e7f9f2e2e7d2e9752a73e0b148d..918d01d3fbaa2af6c00620dbef739778ee70aa9f 100644 (file)
--- a/drivers/dax/kmem.c
+++ b/drivers/dax/kmem.c
@@ -239,6 +239,7 @@ static void dev_dax_kmem_remove(struct dev_dax *dev_dax)
 static struct dax_device_driver device_dax_kmem_driver = {
        .probe = dev_dax_kmem_probe,
        .remove = dev_dax_kmem_remove,
+       .type = DAXDRV_KMEM_TYPE,
 };
 
 static int __init dax_kmem_init(void)