[PATCH RFCv1 2/5] kernel/resource: merge_child_mem_resources() to merge memory resources after adding succeeded

[David Hildenbrand <david@xxxxxxxxxx>]

Some add_memory*() users add memory in small, contiguous memory blocks.
Examples include virtio-mem, hyper-v balloon, and the XEN balloon.

This can quickly result in a lot of memory resources, whereby the actual
resource boundaries are not of interest (e.g., it might be relevant for
DIMMs, exposed via /proc/iomem to user space). We really want to merge
added resources in this scenario where possible.

Let's provide an interface to trigger merging of applicable child
resources. It will be, for example, used by virtio-mem to trigger
merging of memory resources it added (via add_memory_driver()
managed) to its resource container.

Note: We really want to merge after the whole operation succeeded, not
directly when adding a resource to the resource tree (it would break
add_memory_resource() and require splitting resources again when the
operation failed - e.g., due to -ENOMEM).

Cc: Andrew Morton <akpm@xxxxxxxxxxxxxxxxxxxx>
Cc: Michal Hocko <mhocko@xxxxxxxx>
Cc: Dan Williams <dan.j.williams@xxxxxxxxx>
Cc: Jason Gunthorpe <jgg@xxxxxxxx>
Cc: Kees Cook <keescook@xxxxxxxxxxxx>
Cc: Ard Biesheuvel <ardb@xxxxxxxxxx>
Cc: Thomas Gleixner <tglx@xxxxxxxxxxxxx>
Cc: "K. Y. Srinivasan" <kys@xxxxxxxxxxxxx>
Cc: Haiyang Zhang <haiyangz@xxxxxxxxxxxxx>
Cc: Stephen Hemminger <sthemmin@xxxxxxxxxxxxx>
Cc: Wei Liu <wei.liu@xxxxxxxxxx>
Cc: Boris Ostrovsky <boris.ostrovsky@xxxxxxxxxx>
Cc: Juergen Gross <jgross@xxxxxxxx>
Cc: Stefano Stabellini <sstabellini@xxxxxxxxxx>
Cc: Roger Pau Monné <roger.pau@xxxxxxxxxx>
Cc: Julien Grall <julien@xxxxxxx>
Signed-off-by: David Hildenbrand <david@xxxxxxxxxx>
---
 include/linux/ioport.h |  3 +++
 kernel/resource.c      | 56 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 59 insertions(+)

diff --git a/include/linux/ioport.h b/include/linux/ioport.h
index 52a91f5fa1a36..743b87fe2205b 100644
--- a/include/linux/ioport.h
+++ b/include/linux/ioport.h
@@ -251,6 +251,9 @@ extern void __release_region(struct resource *, 
resource_size_t,
 extern void release_mem_region_adjustable(struct resource *, resource_size_t,
                                          resource_size_t);
 #endif
+#ifdef CONFIG_MEMORY_HOTPLUG
+extern void merge_child_mem_resources(struct resource *res, const char *name);
+#endif
 
 /* Wrappers for managed devices */
 struct device;
diff --git a/kernel/resource.c b/kernel/resource.c
index 249c6b54014de..01ecc5b7956f5 100644
--- a/kernel/resource.c
+++ b/kernel/resource.c
@@ -1360,6 +1360,62 @@ void release_mem_region_adjustable(struct resource 
*parent,
 }
 #endif /* CONFIG_MEMORY_HOTREMOVE */
 
+#ifdef CONFIG_MEMORY_HOTPLUG
+static bool mem_resources_mergeable(struct resource *r1, struct resource *r2)
+{
+       return r1->end + 1 == r2->start &&
+              r1->name == r2->name &&
+              r1->flags == r2->flags &&
+              (r1->flags & IORESOURCE_MEM) &&
+              r1->desc == r2->desc &&
+              !r1->child && !r2->child;
+}
+
+/*
+ * merge_child_mem_resources - try to merge contiguous child IORESOURCE_MEM
+ *                             resources with the given name that match all
+ *                             other properties
+ * @parent: parent resource descriptor
+ * @name: name of the child resources to consider for merging
+ *
+ * This interface is intended for memory hotplug, whereby lots of consecutive
+ * memory resources are added (e.g., via add_memory*()) by a driver, and the
+ * actual resource boundaries are not of interest (e.g., it might be
+ * relevant for DIMMs). Only immediate child resources are considered. All
+ * applicable child resources must be immutable during the request.
+ *
+ * Note:
+ * - The caller has to make sure that no pointers to resources that might
+ *   get merged are held anymore. Callers should only trigger merging of child
+ *   resources when they are the only one adding such resources to the parent.
+ *   E.g., if two mechanisms could add "System RAM" immediately below the
+ *   same parent, this function is not safe to use.
+ * - release_mem_region_adjustable() will split on demand on memory hotunplug
+ */
+void merge_child_mem_resources(struct resource *parent, const char *name)
+{
+       struct resource *cur, *next;
+
+       write_lock(&resource_lock);
+
+       cur = parent->child;
+       while (cur && cur->sibling) {
+               next = cur->sibling;
+               if (!strcmp(cur->name, name) &&
+                   mem_resources_mergeable(cur, next)) {
+                       cur->end = next->end;
+                       cur->sibling = next->sibling;
+                       free_resource(next);
+                       next = cur->sibling;
+               }
+               cur = next;
+       }
+
+       write_unlock(&resource_lock);
+}
+EXPORT_SYMBOL(merge_child_mem_resources);
+#endif /* CONFIG_MEMORY_HOTPLUG */
+
 /*
  * Managed region resource
  */
-- 
2.26.2