memory hotplug: make kmem_cache_node for SLUB on memory online avoid panic (b9049e23) · Commits · 戴 / test

include/linux/memory.h

+4 −0

Original line number	Diff line number	Diff line
		@@ -83,10 +83,14 @@ extern int memory_notify(unsigned long val, void *v);

		#endif /* CONFIG_MEMORY_HOTPLUG_SPARSE */

		#ifdef CONFIG_MEMORY_HOTPLUG
		#define hotplug_memory_notifier(fn, pri) { \
		static struct notifier_block fn##_mem_nb = \
		{ .notifier_call = fn, .priority = pri }; \
		register_memory_notifier(&fn##_mem_nb); \
		}
		#else
		#define hotplug_memory_notifier(fn, pri) do { } while (0)
		#endif

		#endif /* _LINUX_MEMORY_H_ */

mm/slub.c

+118 −0

Original line number	Diff line number	Diff line
		@@ -20,6 +20,7 @@
		#include <linux/mempolicy.h>
		#include <linux/ctype.h>
		#include <linux/kallsyms.h>
		#include <linux/memory.h>

		/*
		* Lock order:
		@@ -2694,6 +2695,121 @@ int kmem_cache_shrink(struct kmem_cache *s)
		}
		EXPORT_SYMBOL(kmem_cache_shrink);

		#if defined(CONFIG_NUMA) && defined(CONFIG_MEMORY_HOTPLUG)
		static int slab_mem_going_offline_callback(void *arg)
		{
		struct kmem_cache *s;

		down_read(&slub_lock);
		list_for_each_entry(s, &slab_caches, list)
		kmem_cache_shrink(s);
		up_read(&slub_lock);

		return 0;
		}

		static void slab_mem_offline_callback(void *arg)
		{
		struct kmem_cache_node *n;
		struct kmem_cache *s;
		struct memory_notify *marg = arg;
		int offline_node;

		offline_node = marg->status_change_nid;

		/*
		* If the node still has available memory. we need kmem_cache_node
		* for it yet.
		*/
		if (offline_node < 0)
		return;

		down_read(&slub_lock);
		list_for_each_entry(s, &slab_caches, list) {
		n = get_node(s, offline_node);
		if (n) {
		/*
		* if n->nr_slabs > 0, slabs still exist on the node
		* that is going down. We were unable to free them,
		* and offline_pages() function shoudn't call this
		* callback. So, we must fail.
		*/
		BUG_ON(atomic_read(&n->nr_slabs));

		s->node[offline_node] = NULL;
		kmem_cache_free(kmalloc_caches, n);
		}
		}
		up_read(&slub_lock);
		}

		static int slab_mem_going_online_callback(void *arg)
		{
		struct kmem_cache_node *n;
		struct kmem_cache *s;
		struct memory_notify *marg = arg;
		int nid = marg->status_change_nid;
		int ret = 0;

		/*
		* If the node's memory is already available, then kmem_cache_node is
		* already created. Nothing to do.
		*/
		if (nid < 0)
		return 0;

		/*
		* We are bringing a node online. No memory is availabe yet. We must
		* allocate a kmem_cache_node structure in order to bring the node
		* online.
		*/
		down_read(&slub_lock);
		list_for_each_entry(s, &slab_caches, list) {
		/*
		* XXX: kmem_cache_alloc_node will fallback to other nodes
		* since memory is not yet available from the node that
		* is brought up.
		*/
		n = kmem_cache_alloc(kmalloc_caches, GFP_KERNEL);
		if (!n) {
		ret = -ENOMEM;
		goto out;
		}
		init_kmem_cache_node(n);
		s->node[nid] = n;
		}
		out:
		up_read(&slub_lock);
		return ret;
		}

		static int slab_memory_callback(struct notifier_block *self,
		unsigned long action, void *arg)
		{
		int ret = 0;

		switch (action) {
		case MEM_GOING_ONLINE:
		ret = slab_mem_going_online_callback(arg);
		break;
		case MEM_GOING_OFFLINE:
		ret = slab_mem_going_offline_callback(arg);
		break;
		case MEM_OFFLINE:
		case MEM_CANCEL_ONLINE:
		slab_mem_offline_callback(arg);
		break;
		case MEM_ONLINE:
		case MEM_CANCEL_OFFLINE:
		break;
		}

		ret = notifier_from_errno(ret);
		return ret;
		}

		#endif /* CONFIG_MEMORY_HOTPLUG */

		/********************************************************************
		* Basic setup of slabs
		*******************************************************************/
		@@ -2715,6 +2831,8 @@ void __init kmem_cache_init(void)
		sizeof(struct kmem_cache_node), GFP_KERNEL);
		kmalloc_caches[0].refcount = -1;
		caches++;

		hotplug_memory_notifier(slab_memory_callback, 1);
		#endif

		/* Able to allocate the per node structures */

Admin message