| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <1440625157.31365.21.camel@intel.com>
Date: Wed, 26 Aug 2015 21:39:18 +0000
From: "Williams, Dan J" <dan.j.williams@...el.com>
To: "hch@....de" <hch@....de>
CC: "linux-kernel@...r.kernel.org" <linux-kernel@...r.kernel.org>,
"mingo@...nel.org" <mingo@...nel.org>,
"linux-mm@...ck.org" <linux-mm@...ck.org>,
"hpa@...or.com" <hpa@...or.com>,
"linux-nvdimm@...ts.01.org" <linux-nvdimm@...ts.01.org>,
"ross.zwisler@...ux.intel.com" <ross.zwisler@...ux.intel.com>,
"boaz@...xistor.com" <boaz@...xistor.com>,
"david@...morbit.com" <david@...morbit.com>
Subject: Re: [PATCH v2 9/9] devm_memremap_pages: protect against pmem device
unbind
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.
8<----
Subject: devm_memremap_pages: protect against pmem device unbind
From: Dan Williams <dan.j.williams@...el.com>
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@....de>
Signed-off-by: Dan Williams <dan.j.williams@...el.com>
---
include/linux/io.h | 30 ++++++++++++++++
kernel/memremap.c | 96 +++++++++++++++++++++++++++++++++++++++++++++++++++-
2 files changed, 125 insertions(+), 1 deletion(-)
diff --git a/include/linux/io.h b/include/linux/io.h
index de64c1e53612..9e696b114c6d 100644
--- a/include/linux/io.h
+++ b/include/linux/io.h
@@ -90,8 +90,25 @@ 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>
+
+struct memremap_map {
+ struct percpu_ref percpu_ref;
+};
+
void *devm_memremap_pages(struct device *dev, struct resource *res);
+struct memremap_map * __must_check get_memremap_map(resource_size_t addr);
+static inline void ref_memremap_map(struct memremap_map *memremap_map)
+{
+ percpu_ref_get(&memremap_map->percpu_ref);
+}
+
+static inline void put_memremap_map(struct memremap_map *memremap_map)
+{
+ percpu_ref_put(&memremap_map->percpu_ref);
+}
#else
+struct memremap_map;
static inline void *devm_memremap_pages(struct device *dev, struct resource *res)
{
/*
@@ -102,6 +119,19 @@ 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 memremap_map *get_memremap_map(resource_size_t addr)
+{
+ return NULL;
+}
+
+static inline void ref_memremap_map(struct memremap_map *memremap_map)
+{
+}
+
+static inline void put_memremap_map(struct memremap_map *memremap_map)
+{
+}
#endif
/*
diff --git a/kernel/memremap.c b/kernel/memremap.c
index 72b0c66628b6..5b9f04789b96 100644
--- a/kernel/memremap.c
+++ b/kernel/memremap.c
@@ -11,7 +11,11 @@
* General Public License for more details.
*/
#include <linux/device.h>
+#include <linux/ioport.h>
#include <linux/types.h>
+#include <linux/sched.h>
+#include <linux/wait.h>
+#include <linux/list.h>
#include <linux/io.h>
#include <linux/mm.h>
#include <linux/memory_hotplug.h>
@@ -138,14 +142,74 @@ void devm_memunmap(struct device *dev, void *addr)
EXPORT_SYMBOL(devm_memunmap);
#ifdef CONFIG_ZONE_DEVICE
+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,
+};
+
struct page_map {
struct resource res;
+ struct list_head list;
+ unsigned long flags;
+ struct memremap_map map;
+ struct device *dev;
};
+static struct page_map *to_page_map(struct percpu_ref *ref)
+{
+ return container_of(ref, struct page_map, 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->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 +219,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 +236,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->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 +253,32 @@ 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 memremap_map * __must_check get_memremap_map(resource_size_t addr)
+{
+ struct memremap_map *ret = NULL;
+ struct page_map *page_map;
+
+ 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->map.percpu_ref))
+ ret = &page_map->map;
+ break;
+ }
+ }
+ rcu_read_unlock();
+
+ return ret;
+}
+EXPORT_SYMBOL_GPL(get_memremap_map);
#endif /* CONFIG_ZONE_DEVICE */
Powered by blists - more mailing lists