Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > linux.kernel > #1213483 > unrolled thread

[PATCH v2 9/9] devm_memremap_pages: protect against pmem device unbind

Started byDan Williams <dan.j.williams@intel.com>
First post2015-08-26 03:40 +0200
Last post2015-08-27 09:40 +0200
Articles 4 — 4 participants

Back to article view | Back to linux.kernel

This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by below is the oldest one visible, not the original post.

Contents

  [PATCH v2 9/9] devm_memremap_pages: protect against pmem device  unbind Dan Williams <dan.j.williams@intel.com> - 2015-08-26 03:40 +0200
    Re: [PATCH v2 9/9] devm_memremap_pages: protect against pmem  device unbind Christoph Hellwig <hch@lst.de> - 2015-08-26 14:50 +0200
      Re: [PATCH v2 9/9] devm_memremap_pages: protect against pmem device  unbind "Williams, Dan J" <dan.j.williams@intel.com> - 2015-08-26 23:40 +0200
        Re: [PATCH v2 9/9] devm_memremap_pages: protect against pmem  device unbind "hch@lst.de" <hch@lst.de> - 2015-08-27 09:40 +0200

#1213483 — [PATCH v2 9/9] devm_memremap_pages: protect against pmem device unbind

FromDan Williams <dan.j.williams@intel.com>
Date2015-08-26 03:40 +0200
Subject[PATCH v2 9/9] devm_memremap_pages: protect against pmem device unbind
Message-ID<q1xR1-7IF-19@gated-at.bofh.it>
Given that:

1/ device ->remove() can not be failed

2/ a pmem device may be unbound at any time

3/ we do not know what other parts of the kernel are actively using a
   'struct page' from devm_memremap_pages()

...provide a facility for active usages of device memory to block pmem
device unbind.  With a percpu_ref it should be feasible to take a
reference on a per-I/O or other high frequency basis.

Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
---
 include/linux/io.h |   37 ++++++++++++++++++++++
 kernel/memremap.c  |   89 ++++++++++++++++++++++++++++++++++++++++++++++++++--
 2 files changed, 123 insertions(+), 3 deletions(-)

diff --git a/include/linux/io.h b/include/linux/io.h
index de64c1e53612..e20cc04f42b7 100644
--- a/include/linux/io.h
+++ b/include/linux/io.h
@@ -90,8 +90,31 @@ void devm_memunmap(struct device *dev, void *addr);
 void *__devm_memremap_pages(struct device *dev, struct resource *res);
 
 #ifdef CONFIG_ZONE_DEVICE
+#include <linux/percpu-refcount.h>
+#include <linux/ioport.h>
+#include <linux/list.h>
+
+struct page_map {
+	struct resource res;
+	struct list_head list;
+	unsigned long flags;
+	struct percpu_ref percpu_ref;
+	struct device *dev;
+};
+
 void *devm_memremap_pages(struct device *dev, struct resource *res);
+struct page_map * __must_check get_page_map(resource_size_t addr);
+static inline void ref_page_map(struct page_map *page_map)
+{
+	percpu_ref_get(&page_map->percpu_ref);
+}
+
+static inline void put_page_map(struct page_map *page_map)
+{
+	percpu_ref_put(&page_map->percpu_ref);
+}
 #else
+struct page_map;
 static inline void *devm_memremap_pages(struct device *dev, struct resource *res)
 {
 	/*
@@ -102,6 +125,20 @@ static inline void *devm_memremap_pages(struct device *dev, struct resource *res
 	WARN_ON_ONCE(1);
 	return ERR_PTR(-ENXIO);
 }
+
+static inline __must_check struct page_map *get_page_map(resource_size_t addr)
+{
+	return NULL;
+}
+
+static inline void ref_page_map(struct page_map *page_map)
+{
+	return false;
+}
+
+static inline void put_page_map(struct page_map *page_map)
+{
+}
 #endif
 
 /*
diff --git a/kernel/memremap.c b/kernel/memremap.c
index 72b0c66628b6..65a6c9396062 100644
--- a/kernel/memremap.c
+++ b/kernel/memremap.c
@@ -12,6 +12,8 @@
  */
 #include <linux/device.h>
 #include <linux/types.h>
+#include <linux/sched.h>
+#include <linux/wait.h>
 #include <linux/io.h>
 #include <linux/mm.h>
 #include <linux/memory_hotplug.h>
@@ -138,14 +140,66 @@ void devm_memunmap(struct device *dev, void *addr)
 EXPORT_SYMBOL(devm_memunmap);
 
 #ifdef CONFIG_ZONE_DEVICE
-struct page_map {
-	struct resource res;
+static DEFINE_MUTEX(page_map_lock);
+static DECLARE_WAIT_QUEUE_HEAD(page_map_wait);
+static LIST_HEAD(page_maps);
+
+enum {
+	PAGE_MAP_LIVE,
+	PAGE_MAP_CONFIRM,
 };
 
+static struct page_map *to_page_map(struct percpu_ref *ref)
+{
+	return container_of(ref, struct page_map, percpu_ref);
+}
+
+static void page_map_release(struct percpu_ref *ref)
+{
+	struct page_map *page_map = to_page_map(ref);
+
+	/* signal page_map is idle (no more refs) */
+	clear_bit(PAGE_MAP_LIVE, &page_map->flags);
+	wake_up_all(&page_map_wait);
+}
+
+static void page_map_confirm(struct percpu_ref *ref)
+{
+	struct page_map *page_map = to_page_map(ref);
+
+	/* signal page_map is confirmed dead (slow path ref mode) */
+	set_bit(PAGE_MAP_CONFIRM, &page_map->flags);
+	wake_up_all(&page_map_wait);
+}
+
+static void page_map_destroy(struct page_map *page_map)
+{
+	long tmo;
+
+	/* flush new lookups */
+	mutex_lock(&page_map_lock);
+	list_del_rcu(&page_map->list);
+	mutex_unlock(&page_map_lock);
+	synchronize_rcu();
+
+	percpu_ref_kill_and_confirm(&page_map->percpu_ref, page_map_confirm);
+	do {
+		tmo = wait_event_interruptible_timeout(page_map_wait,
+			!test_bit(PAGE_MAP_LIVE, &page_map->flags)
+			&& test_bit(PAGE_MAP_CONFIRM, &page_map->flags), 5*HZ);
+		if (tmo <= 0)
+			dev_dbg(page_map->dev,
+					"page map active, continuing to wait...\n");
+	} while (tmo <= 0);
+}
+
 static void devm_memremap_pages_release(struct device *dev, void *res)
 {
 	struct page_map *page_map = res;
 
+	if (test_bit(PAGE_MAP_LIVE, &page_map->flags))
+		page_map_destroy(page_map);
+
 	/* pages are dead and unused, undo the arch mapping */
 	arch_remove_memory(page_map->res.start, resource_size(&page_map->res));
 }
@@ -155,7 +209,7 @@ void *devm_memremap_pages(struct device *dev, struct resource *res)
 	int is_ram = region_intersects(res->start, resource_size(res),
 			"System RAM");
 	struct page_map *page_map;
-	int error, nid;
+	int error, nid, rc;
 
 	if (is_ram == REGION_MIXED) {
 		WARN_ONCE(1, "%s attempted on mixed region %pr\n",
@@ -172,6 +226,12 @@ void *devm_memremap_pages(struct device *dev, struct resource *res)
 		return ERR_PTR(-ENOMEM);
 
 	memcpy(&page_map->res, res, sizeof(*res));
+	INIT_LIST_HEAD(&page_map->list);
+	page_map->dev = dev;
+	rc = percpu_ref_init(&page_map->percpu_ref, page_map_release, 0,
+				GFP_KERNEL);
+	if (rc)
+		return ERR_PTR(rc);
 
 	nid = dev_to_node(dev);
 	if (nid < 0)
@@ -183,8 +243,31 @@ void *devm_memremap_pages(struct device *dev, struct resource *res)
 		return ERR_PTR(error);
 	}
 
+	set_bit(PAGE_MAP_LIVE, &page_map->flags);
+	mutex_lock(&page_map_lock);
+	list_add_rcu(&page_map->list, &page_maps);
+	mutex_unlock(&page_map_lock);
+
 	devres_add(dev, page_map);
 	return __va(res->start);
 }
 EXPORT_SYMBOL(devm_memremap_pages);
+
+struct page_map * __must_check get_page_map(resource_size_t addr)
+{
+	struct page_map *page_map, *ret = NULL;
+
+	rcu_read_lock();
+	list_for_each_entry_rcu(page_map, &page_maps, list) {
+		if (addr >= page_map->res.start && addr <= page_map->res.end) {
+			if (percpu_ref_tryget(&page_map->percpu_ref))
+				ret = page_map;
+			break;
+		}
+	}
+	rcu_read_unlock();
+
+	return ret;
+}
+EXPORT_SYMBOL_GPL(get_page_map);
 #endif /* CONFIG_ZONE_DEVICE */

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [next] | [standalone]

#1213821 — Re: [PATCH v2 9/9] devm_memremap_pages: protect against pmem device unbind

FromChristoph Hellwig <hch@lst.de>
Date2015-08-26 14:50 +0200
SubjectRe: [PATCH v2 9/9] devm_memremap_pages: protect against pmem device unbind
Message-ID<q1Ijo-602-19@gated-at.bofh.it>
In reply to#1213483
On Tue, Aug 25, 2015 at 09:28:13PM -0400, Dan Williams wrote:
> Given that:
> 
> 1/ device ->remove() can not be failed
> 
> 2/ a pmem device may be unbound at any time
> 
> 3/ we do not know what other parts of the kernel are actively using a
>    'struct page' from devm_memremap_pages()
> 
> ...provide a facility for active usages of device memory to block pmem
> device unbind.  With a percpu_ref it should be feasible to take a
> reference on a per-I/O or other high frequency basis.

Without a caller of get_page_map this is just adding dead code.  I'd
suggest to group it in a series with that caller.

Also if the page_map gets exposed in a header the name is a bit too generic.
memremap_map maybe?
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1214204

From"Williams, Dan J" <dan.j.williams@intel.com>
Date2015-08-26 23:40 +0200
Message-ID<q1QAi-12Y-9@gated-at.bofh.it>
In reply to#1213821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--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1214369 — Re: [PATCH v2 9/9] devm_memremap_pages: protect against pmem device unbind

From"hch@lst.de" <hch@lst.de>
Date2015-08-27 09:40 +0200
SubjectRe: [PATCH v2 9/9] devm_memremap_pages: protect against pmem device unbind
Message-ID<q1ZWW-6e9-13@gated-at.bofh.it>
In reply to#1214204
On Wed, Aug 26, 2015 at 09:39:18PM +0000, Williams, Dan J wrote:
> On Wed, 2015-08-26 at 14:46 +0200, Christoph Hellwig wrote:
> > On Tue, Aug 25, 2015 at 09:28:13PM -0400, Dan Williams wrote:
> > > Given that:
> > > 
> > > 1/ device ->remove() can not be failed
> > > 
> > > 2/ a pmem device may be unbound at any time
> > > 
> > > 3/ we do not know what other parts of the kernel are actively using a
> > >    'struct page' from devm_memremap_pages()
> > > 
> > > ...provide a facility for active usages of device memory to block pmem
> > > device unbind.  With a percpu_ref it should be feasible to take a
> > > reference on a per-I/O or other high frequency basis.
> > 
> > Without a caller of get_page_map this is just adding dead code.  I'd
> > suggest to group it in a series with that caller.
> > 
> 
> Agreed, we can drop this until the first user arrives.
> 
> > Also if the page_map gets exposed in a header the name is a bit too generic.
> > memremap_map maybe?
> 
> Done, and in the patch below I hide the internal implementation details
> of page_map in kernel/memremap.c and only expose the percpu_ref in the
> public memremap_map.

Yes, that looks good once we're getting the users for it.
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [standalone]

Back to top | Article view | linux.kernel

csiph-web