drivers/base/memory.c: drop the mem_sysfs_mutex

The mem_sysfs_mutex isn't really helpful.  Also, it's not really clear
what the mutex protects at all.

The device lists of the memory subsystem are protected separately.  We
don't need that mutex when looking up.  creating, or removing
independent devices.  find_memory_block_by_id() will perform locking on
its own and grab a reference of the returned device.

At the time memory_dev_init() is called, we cannot have concurrent
hot(un)plug operations yet - we're still fairly early during boot.  We
don't need any locking.

The creation/removal of memory block devices should be protected on a
higher level - especially using the device hotplug lock to avoid
documented issues (see Documentation/core-api/memory-hotplug.rst) - or
if that is reworked, using similar locking.

Protecting in the context of these functions only doesn't really make
sense.  Especially, if we would have a situation where the same memory
blocks are created/deleted at the same time, there is something horribly
going wrong (imagining adding/removing a DIMM at the same time from two
call paths) - after the functions succeeded something else in the
callers would blow up (e.g., create_memory_block_devices() succeeded but
there are no memory block devices anymore).

All relevant call paths (except when adding memory early during boot via
ACPI, which is now documented) hold the device hotplug lock when adding
memory, and when removing memory.  Let's document that instead.

Add a simple safety net to create_memory_block_devices() in case we
would actually remove memory blocks while adding them, so we'll never
dereference a NULL pointer.  Simplify memory_dev_init() now that the
lock is gone.

Link: http://lkml.kernel.org/r/20190925082621.4927-1-david@redhat.com
Signed-off-by: David Hildenbrand <david@redhat.com>
Reviewed-by: Andrew Morton <akpm@linux-foundation.org>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: "Rafael J. Wysocki" <rafael@kernel.org>
Cc: Michal Hocko <mhocko@kernel.org>
Cc: Oscar Salvador <osalvador@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/drivers/base/memory.c b/drivers/base/memory.c
index d65ecde..799b431 100644 (file)
--- a/drivers/base/memory.c
+++ b/drivers/base/memory.c
@@ -19,15 +19,12 @@
 #include <linux/memory.h>
 #include <linux/memory_hotplug.h>
 #include <linux/mm.h>
-#include <linux/mutex.h>
 #include <linux/stat.h>
 #include <linux/slab.h>
 
 #include <linux/atomic.h>
 #include <linux/uaccess.h>
 
-static DEFINE_MUTEX(mem_sysfs_mutex);
-
 #define MEMORY_CLASS_NAME      "memory"
 
 #define to_memory_block(dev) container_of(dev, struct memory_block, dev)
@@ -700,6 +697,8 @@ static void unregister_memory(struct memory_block *memory)
  * Create memory block devices for the given memory area. Start and size
  * have to be aligned to memory block granularity. Memory block devices
  * will be initialized as offline.
+ *
+ * Called under device_hotplug_lock.
  */
 int create_memory_block_devices(unsigned long start, unsigned long size)
 {
@@ -713,7 +712,6 @@ int create_memory_block_devices(unsigned long start, unsigned long size)
                         !IS_ALIGNED(size, memory_block_size_bytes())))
                return -EINVAL;
 
-       mutex_lock(&mem_sysfs_mutex);
        for (block_id = start_block_id; block_id != end_block_id; block_id++) {
                ret = init_memory_block(&mem, block_id, MEM_OFFLINE);
                if (ret)
@@ -725,11 +723,12 @@ int create_memory_block_devices(unsigned long start, unsigned long size)
                for (block_id = start_block_id; block_id != end_block_id;
                     block_id++) {
                        mem = find_memory_block_by_id(block_id);
+                       if (WARN_ON_ONCE(!mem))
+                               continue;
                        mem->section_count = 0;
                        unregister_memory(mem);
                }
        }
-       mutex_unlock(&mem_sysfs_mutex);
        return ret;
 }
 
@@ -737,6 +736,8 @@ int create_memory_block_devices(unsigned long start, unsigned long size)
  * Remove memory block devices for the given memory area. Start and size
  * have to be aligned to memory block granularity. Memory block devices
  * have to be offline.
+ *
+ * Called under device_hotplug_lock.
  */
 void remove_memory_block_devices(unsigned long start, unsigned long size)
 {
@@ -749,7 +750,6 @@ void remove_memory_block_devices(unsigned long start, unsigned long size)
                         !IS_ALIGNED(size, memory_block_size_bytes())))
                return;
 
-       mutex_lock(&mem_sysfs_mutex);
        for (block_id = start_block_id; block_id != end_block_id; block_id++) {
                mem = find_memory_block_by_id(block_id);
                if (WARN_ON_ONCE(!mem))
@@ -758,7 +758,6 @@ void remove_memory_block_devices(unsigned long start, unsigned long size)
                unregister_memory_block_under_nodes(mem);
                unregister_memory(mem);
        }
-       mutex_unlock(&mem_sysfs_mutex);
 }
 
 /* return true if the memory block is offlined, otherwise, return false */
@@ -792,12 +791,13 @@ static const struct attribute_group *memory_root_attr_groups[] = {
 };
 
 /*
- * Initialize the sysfs support for memory devices...
+ * Initialize the sysfs support for memory devices. At the time this function
+ * is called, we cannot have concurrent creation/deletion of memory block
+ * devices, the device_hotplug_lock is not needed.
  */
 void __init memory_dev_init(void)
 {
        int ret;
-       int err;
        unsigned long block_sz, nr;
 
        /* Validate the configured memory block size */
@@ -808,24 +808,19 @@ void __init memory_dev_init(void)
 
        ret = subsys_system_register(&memory_subsys, memory_root_attr_groups);
        if (ret)
-               goto out;
+               panic("%s() failed to register subsystem: %d\n", __func__, ret);
 
        /*
         * Create entries for memory sections that were found
         * during boot and have been initialized
         */
-       mutex_lock(&mem_sysfs_mutex);
        for (nr = 0; nr <= __highest_present_section_nr;
             nr += sections_per_block) {
-               err = add_memory_block(nr);
-               if (!ret)
-                       ret = err;
+               ret = add_memory_block(nr);
+               if (ret)
+                       panic("%s() failed to add memory block: %d\n", __func__,
+                             ret);
        }
-       mutex_unlock(&mem_sysfs_mutex);
-
-out:
-       if (ret)
-               panic("%s() failed: %d\n", __func__, ret);
 }
 
 /**