mm/hmm: add new helper to hotplug CDM memory region

Unlike unaddressable memory, coherent device memory has a real resource
associated with it on the system (as CPU can address it).  Add a new
helper to hotplug such memory within the HMM framework.

Link: http://lkml.kernel.org/r/20170817000548.32038-20-jglisse@redhat.com
Signed-off-by: Jérôme Glisse <jglisse@redhat.com>
Reviewed-by: Balbir Singh <bsingharora@gmail.com>
Cc: Aneesh Kumar <aneesh.kumar@linux.vnet.ibm.com>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Dan Williams <dan.j.williams@intel.com>
Cc: David Nellans <dnellans@nvidia.com>
Cc: Evgeny Baskakov <ebaskakov@nvidia.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: John Hubbard <jhubbard@nvidia.com>
Cc: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Cc: Mark Hairgrove <mhairgrove@nvidia.com>
Cc: Michal Hocko <mhocko@kernel.org>
Cc: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: Ross Zwisler <ross.zwisler@linux.intel.com>
Cc: Sherry Cheung <SCheung@nvidia.com>
Cc: Subhash Gutti <sgutti@nvidia.com>
Cc: Vladimir Davydov <vdavydov.dev@gmail.com>
Cc: Bob Liu <liubo95@huawei.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/include/linux/hmm.h b/include/linux/hmm.h
index 6d3b0b4fed4ee004dc87ce2e7e931df50d333a7e..8385e75356cafeee5252eda7994ab906564c878e 100644 (file)
--- a/include/linux/hmm.h
+++ b/include/linux/hmm.h
@@ -443,6 +443,9 @@ struct hmm_devmem {
 struct hmm_devmem *hmm_devmem_add(const struct hmm_devmem_ops *ops,
                                  struct device *device,
                                  unsigned long size);
+struct hmm_devmem *hmm_devmem_add_resource(const struct hmm_devmem_ops *ops,
+                                          struct device *device,
+                                          struct resource *res);
 void hmm_devmem_remove(struct hmm_devmem *devmem);
 
 /*

diff --git a/mm/hmm.c b/mm/hmm.c
index b31d56662202c7c2dbda0d934e7a9cb0edcf30d3..bdb49b836bf22d6de63b5cb8dd89d96b32862e44 100644 (file)
--- a/mm/hmm.c
+++ b/mm/hmm.c
@@ -839,7 +839,11 @@ static void hmm_devmem_release(struct device *dev, void *data)
        zone = page_zone(page);
 
        mem_hotplug_begin();
-       __remove_pages(zone, start_pfn, npages);
+       if (resource->desc == IORES_DESC_DEVICE_PRIVATE_MEMORY)
+               __remove_pages(zone, start_pfn, npages);
+       else
+               arch_remove_memory(start_pfn << PAGE_SHIFT,
+                                  npages << PAGE_SHIFT);
        mem_hotplug_done();
 
        hmm_devmem_radix_release(resource);
@@ -875,7 +879,11 @@ static int hmm_devmem_pages_create(struct hmm_devmem *devmem)
        if (is_ram == REGION_INTERSECTS)
                return -ENXIO;
 
-       devmem->pagemap.type = MEMORY_DEVICE_PRIVATE;
+       if (devmem->resource->desc == IORES_DESC_DEVICE_PUBLIC_MEMORY)
+               devmem->pagemap.type = MEMORY_DEVICE_PUBLIC;
+       else
+               devmem->pagemap.type = MEMORY_DEVICE_PRIVATE;
+
        devmem->pagemap.res = devmem->resource;
        devmem->pagemap.page_fault = hmm_devmem_fault;
        devmem->pagemap.page_free = hmm_devmem_free;
@@ -920,9 +928,15 @@ static int hmm_devmem_pages_create(struct hmm_devmem *devmem)
         * over the device memory is un-accessible thus we do not want to
         * create a linear mapping for the memory like arch_add_memory()
         * would do.
+        *
+        * For device public memory, which is accesible by the CPU, we do
+        * want the linear mapping and thus use arch_add_memory().
         */
-       ret = add_pages(nid, align_start >> PAGE_SHIFT,
-                       align_size >> PAGE_SHIFT, false);
+       if (devmem->pagemap.type == MEMORY_DEVICE_PUBLIC)
+               ret = arch_add_memory(nid, align_start, align_size, false);
+       else
+               ret = add_pages(nid, align_start >> PAGE_SHIFT,
+                               align_size >> PAGE_SHIFT, false);
        if (ret) {
                mem_hotplug_done();
                goto error_add_memory;
@@ -1069,6 +1083,67 @@ error_percpu_ref:
 }
 EXPORT_SYMBOL(hmm_devmem_add);
 
+struct hmm_devmem *hmm_devmem_add_resource(const struct hmm_devmem_ops *ops,
+                                          struct device *device,
+                                          struct resource *res)
+{
+       struct hmm_devmem *devmem;
+       int ret;
+
+       if (res->desc != IORES_DESC_DEVICE_PUBLIC_MEMORY)
+               return ERR_PTR(-EINVAL);
+
+       static_branch_enable(&device_private_key);
+
+       devmem = devres_alloc_node(&hmm_devmem_release, sizeof(*devmem),
+                                  GFP_KERNEL, dev_to_node(device));
+       if (!devmem)
+               return ERR_PTR(-ENOMEM);
+
+       init_completion(&devmem->completion);
+       devmem->pfn_first = -1UL;
+       devmem->pfn_last = -1UL;
+       devmem->resource = res;
+       devmem->device = device;
+       devmem->ops = ops;
+
+       ret = percpu_ref_init(&devmem->ref, &hmm_devmem_ref_release,
+                             0, GFP_KERNEL);
+       if (ret)
+               goto error_percpu_ref;
+
+       ret = devm_add_action(device, hmm_devmem_ref_exit, &devmem->ref);
+       if (ret)
+               goto error_devm_add_action;
+
+
+       devmem->pfn_first = devmem->resource->start >> PAGE_SHIFT;
+       devmem->pfn_last = devmem->pfn_first +
+                          (resource_size(devmem->resource) >> PAGE_SHIFT);
+
+       ret = hmm_devmem_pages_create(devmem);
+       if (ret)
+               goto error_devm_add_action;
+
+       devres_add(device, devmem);
+
+       ret = devm_add_action(device, hmm_devmem_ref_kill, &devmem->ref);
+       if (ret) {
+               hmm_devmem_remove(devmem);
+               return ERR_PTR(ret);
+       }
+
+       return devmem;
+
+error_devm_add_action:
+       hmm_devmem_ref_kill(&devmem->ref);
+       hmm_devmem_ref_exit(&devmem->ref);
+error_percpu_ref:
+       devres_free(devmem);
+       return ERR_PTR(ret);
+}
+EXPORT_SYMBOL(hmm_devmem_add_resource);
+
 /*
  * hmm_devmem_remove() - remove device memory (kill and free ZONE_DEVICE)
  *
@@ -1082,6 +1157,7 @@ void hmm_devmem_remove(struct hmm_devmem *devmem)
 {
        resource_size_t start, size;
        struct device *device;
+       bool cdm = false;
 
        if (!devmem)
                return;
@@ -1090,11 +1166,13 @@ void hmm_devmem_remove(struct hmm_devmem *devmem)
        start = devmem->resource->start;
        size = resource_size(devmem->resource);
 
+       cdm = devmem->resource->desc == IORES_DESC_DEVICE_PUBLIC_MEMORY;
        hmm_devmem_ref_kill(&devmem->ref);
        hmm_devmem_ref_exit(&devmem->ref);
        hmm_devmem_pages_remove(devmem);
 
-       devm_release_mem_region(device, start, size);
+       if (!cdm)
+               devm_release_mem_region(device, start, size);
 }
 EXPORT_SYMBOL(hmm_devmem_remove);