| 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: <1588812129-8596-5-git-send-email-anthony.yznaga@oracle.com>
Date: Wed, 6 May 2020 17:41:30 -0700
From: Anthony Yznaga <anthony.yznaga@...cle.com>
To: linux-mm@...ck.org, linux-kernel@...r.kernel.org
Cc: willy@...radead.org, corbet@....net, tglx@...utronix.de,
mingo@...hat.com, bp@...en8.de, x86@...nel.org, hpa@...or.com,
dave.hansen@...ux.intel.com, luto@...nel.org, peterz@...radead.org,
rppt@...ux.ibm.com, akpm@...ux-foundation.org, hughd@...gle.com,
ebiederm@...ssion.com, masahiroy@...nel.org, ardb@...nel.org,
ndesaulniers@...gle.com, dima@...ovin.in, daniel.kiper@...cle.com,
nivedita@...m.mit.edu, rafael.j.wysocki@...el.com,
dan.j.williams@...el.com, zhenzhong.duan@...cle.com,
jroedel@...e.de, bhe@...hat.com, guro@...com,
Thomas.Lendacky@....com, andriy.shevchenko@...ux.intel.com,
keescook@...omium.org, hannes@...xchg.org, minchan@...nel.org,
mhocko@...nel.org, ying.huang@...el.com,
yang.shi@...ux.alibaba.com, gustavo@...eddedor.com,
ziqian.lzq@...fin.com, vdavydov.dev@...il.com,
jason.zeng@...el.com, kevin.tian@...el.com, zhiyuan.lv@...el.com,
lei.l.li@...el.com, paul.c.lai@...el.com, ashok.raj@...el.com,
linux-fsdevel@...r.kernel.org, linux-doc@...r.kernel.org,
kexec@...ts.infradead.org
Subject: [RFC 04/43] mm: PKRAM: implement page stream operations
Using the pkram_save_page() function, one can populate PKRAM objects with
memory pages which can later be loaded using the pkram_load_page()
function. Saving a memory page to PKRAM is accomplished by recording
its pfn and incrementing its refcount so that it will not be freed after
the last user puts it.
Originally-by: Vladimir Davydov <vdavydov.dev@...il.com>
Signed-off-by: Anthony Yznaga <anthony.yznaga@...cle.com>
---
include/linux/pkram.h | 5 ++
mm/pkram.c | 219 +++++++++++++++++++++++++++++++++++++++++++++++++-
2 files changed, 221 insertions(+), 3 deletions(-)
diff --git a/include/linux/pkram.h b/include/linux/pkram.h
index fabde2cd8203..f338d1c2aeb6 100644
--- a/include/linux/pkram.h
+++ b/include/linux/pkram.h
@@ -12,6 +12,11 @@ struct pkram_stream {
gfp_t gfp_mask;
struct pkram_node *node;
struct pkram_obj *obj;
+
+ struct pkram_link *link; /* current link */
+ unsigned int entry_idx; /* next entry in link */
+
+ unsigned long next_index;
};
#define PKRAM_NAME_MAX 256 /* including nul */
diff --git a/mm/pkram.c b/mm/pkram.c
index 4934ffd8b019..ab3053ca3539 100644
--- a/mm/pkram.c
+++ b/mm/pkram.c
@@ -1,6 +1,7 @@
// SPDX-License-Identifier: GPL-2.0
#include <linux/err.h>
#include <linux/gfp.h>
+#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/mm.h>
@@ -10,8 +11,38 @@
#include <linux/string.h>
#include <linux/types.h>
+#include "internal.h"
+
+
+/*
+ * Represents a reference to a data page saved to PKRAM.
+ */
+typedef __u64 pkram_entry_t;
+
+#define PKRAM_ENTRY_FLAGS_SHIFT 0x5
+#define PKRAM_ENTRY_FLAGS_MASK 0x7f
+
+/*
+ * Keeps references to data pages saved to PKRAM.
+ * The structure occupies a memory page.
+ */
+struct pkram_link {
+ __u64 link_pfn; /* points to the next link of the object */
+ __u64 index; /* mapping index of first pkram_entry_t */
+
+ /*
+ * the array occupies the rest of the link page; if the link is not
+ * full, the rest of the array must be filled with zeros
+ */
+ pkram_entry_t entry[0];
+};
+
+#define PKRAM_LINK_ENTRIES_MAX \
+ ((PAGE_SIZE-sizeof(struct pkram_link))/sizeof(pkram_entry_t))
+
struct pkram_obj {
- __u64 obj_pfn; /* points to the next object in the list */
+ __u64 link_pfn; /* points to the first link of the object */
+ __u64 obj_pfn; /* points to the next object in the list */
};
/*
@@ -19,6 +50,10 @@ struct pkram_obj {
* independently of each other. The nodes are identified by unique name
* strings.
*
+ * References to data pages saved to a preserved memory node are kept in a
+ * singly-linked list of PKRAM link structures (see above), the node has a
+ * pointer to the head of.
+ *
* The structure occupies a memory page.
*/
struct pkram_node {
@@ -68,6 +103,37 @@ static struct pkram_node *pkram_find_node(const char *name)
return NULL;
}
+static void pkram_truncate_link(struct pkram_link *link)
+{
+ struct page *page;
+ pkram_entry_t p;
+ int i;
+
+ for (i = 0; i < PKRAM_LINK_ENTRIES_MAX; i++) {
+ p = link->entry[i];
+ if (!p)
+ continue;
+ page = pfn_to_page(PHYS_PFN(p));
+ put_page(page);
+ }
+}
+
+static void pkram_truncate_obj(struct pkram_obj *obj)
+{
+ unsigned long link_pfn;
+ struct pkram_link *link;
+
+ link_pfn = obj->link_pfn;
+ while (link_pfn) {
+ link = pfn_to_kaddr(link_pfn);
+ pkram_truncate_link(link);
+ link_pfn = link->link_pfn;
+ pkram_free_page(link);
+ cond_resched();
+ }
+ obj->link_pfn = 0;
+}
+
static void pkram_truncate_node(struct pkram_node *node)
{
unsigned long obj_pfn;
@@ -76,6 +142,7 @@ static void pkram_truncate_node(struct pkram_node *node)
obj_pfn = node->obj_pfn;
while (obj_pfn) {
obj = pfn_to_kaddr(obj_pfn);
+ pkram_truncate_obj(obj);
obj_pfn = obj->obj_pfn;
pkram_free_page(obj);
cond_resched();
@@ -83,6 +150,26 @@ static void pkram_truncate_node(struct pkram_node *node)
node->obj_pfn = 0;
}
+static void pkram_add_link(struct pkram_link *link, struct pkram_obj *obj)
+{
+ link->link_pfn = obj->link_pfn;
+ obj->link_pfn = page_to_pfn(virt_to_page(link));
+}
+
+static struct pkram_link *pkram_remove_link(struct pkram_obj *obj)
+{
+ struct pkram_link *current_link;
+
+ if (!obj->link_pfn)
+ return NULL;
+
+ current_link = pfn_to_kaddr(obj->link_pfn);
+ obj->link_pfn = current_link->link_pfn;
+ current_link->link_pfn = 0;
+
+ return current_link;
+}
+
static void pkram_stream_init(struct pkram_stream *ps,
struct pkram_node *node, gfp_t gfp_mask)
{
@@ -94,6 +181,9 @@ static void pkram_stream_init(struct pkram_stream *ps,
static void pkram_stream_init_obj(struct pkram_stream *ps, struct pkram_obj *obj)
{
ps->obj = obj;
+ ps->link = NULL;
+ ps->entry_idx = 0;
+ ps->next_index = 0;
}
/**
@@ -295,9 +385,28 @@ void pkram_finish_load_obj(struct pkram_stream *ps)
{
struct pkram_node *node = ps->node;
struct pkram_obj *obj = ps->obj;
+ struct pkram_link *link = ps->link;
BUG_ON((node->flags & PKRAM_ACCMODE_MASK) != PKRAM_LOAD);
+ /*
+ * If link is not null, then loading stopped within a pkram_link
+ * unexpectedly.
+ */
+ if (link) {
+ unsigned long link_pfn;
+
+ link_pfn = page_to_pfn(virt_to_page(link));
+ while (link_pfn) {
+ link = pfn_to_kaddr(link_pfn);
+ pkram_truncate_link(link);
+ link_pfn = link->link_pfn;
+ pkram_free_page(link);
+ cond_resched();
+ }
+ }
+
+ pkram_truncate_obj(obj);
pkram_free_page(obj);
}
@@ -316,6 +425,44 @@ void pkram_finish_load(struct pkram_stream *ps)
pkram_free_page(node);
}
+/*
+ * Insert page to PKRAM node allocating a new PKRAM link if necessary.
+ */
+static int __pkram_save_page(struct pkram_stream *ps,
+ struct page *page, short flags, unsigned long index)
+{
+ struct pkram_link *link = ps->link;
+ struct pkram_obj *obj = ps->obj;
+ pkram_entry_t p;
+
+ if (!link || ps->entry_idx >= PKRAM_LINK_ENTRIES_MAX ||
+ index != ps->next_index) {
+ struct page *link_page;
+
+ link_page = pkram_alloc_page((ps->gfp_mask & GFP_RECLAIM_MASK) |
+ __GFP_ZERO);
+ if (!link_page)
+ return -ENOMEM;
+
+ ps->link = link = page_address(link_page);
+ pkram_add_link(link, obj);
+
+ ps->entry_idx = 0;
+
+ ps->next_index = link->index = index;
+ }
+
+ ps->next_index++;
+
+ get_page(page);
+ p = page_to_phys(page);
+ p |= ((flags & PKRAM_ENTRY_FLAGS_MASK) << PKRAM_ENTRY_FLAGS_SHIFT);
+ link->entry[ps->entry_idx] = p;
+ ps->entry_idx++;
+
+ return 0;
+}
+
/**
* Save page @page to the preserved memory node and object associated with
* stream @ps. The stream must have been initialized with pkram_prepare_save()
@@ -324,10 +471,72 @@ void pkram_finish_load(struct pkram_stream *ps)
* @flags specifies supplemental page state to be preserved.
*
* Returns 0 on success, -errno on failure.
+ *
+ * Error values:
+ * %ENOMEM: insufficient amount of memory available
+ *
+ * Saving a page to preserved memory is simply incrementing its refcount so
+ * that it will not get freed after the last user puts it. That means it is
+ * safe to use the page as usual after it has been saved.
*/
int pkram_save_page(struct pkram_stream *ps, struct page *page, short flags)
{
- return -ENOSYS;
+ struct pkram_node *node = ps->node;
+
+ BUG_ON((node->flags & PKRAM_ACCMODE_MASK) != PKRAM_SAVE);
+
+ BUG_ON(PageCompound(page));
+
+ return __pkram_save_page(ps, page, flags, page->index);
+}
+
+/*
+ * Extract the next page from preserved memory freeing a PKRAM link if it
+ * becomes empty.
+ */
+static struct page *__pkram_load_page(struct pkram_stream *ps, unsigned long *index, short *flags)
+{
+ struct pkram_link *link = ps->link;
+ struct page *page;
+ pkram_entry_t p;
+ short flgs;
+
+ if (!link) {
+ link = pkram_remove_link(ps->obj);
+ if (!link)
+ return NULL;
+
+ ps->link = link;
+ ps->entry_idx = 0;
+ ps->next_index = link->index;
+ }
+
+ BUG_ON(ps->entry_idx >= PKRAM_LINK_ENTRIES_MAX);
+
+ p = link->entry[ps->entry_idx];
+ BUG_ON(!p);
+
+ flgs = (p >> PKRAM_ENTRY_FLAGS_SHIFT) & PKRAM_ENTRY_FLAGS_MASK;
+ page = pfn_to_page(PHYS_PFN(p));
+
+ if (flags)
+ *flags = flgs;
+ if (index)
+ *index = ps->next_index;
+
+ ps->next_index++;
+
+ /* clear to avoid double free (see pkram_truncate_link()) */
+ link->entry[ps->entry_idx] = 0;
+
+ ps->entry_idx++;
+ if (ps->entry_idx >= PKRAM_LINK_ENTRIES_MAX ||
+ !link->entry[ps->entry_idx]) {
+ ps->link = NULL;
+ pkram_free_page(link);
+ }
+
+ return page;
}
/**
@@ -346,7 +555,11 @@ int pkram_save_page(struct pkram_stream *ps, struct page *page, short flags)
*/
struct page *pkram_load_page(struct pkram_stream *ps, unsigned long *index, short *flags)
{
- return NULL;
+ struct pkram_node *node = ps->node;
+
+ BUG_ON((node->flags & PKRAM_ACCMODE_MASK) != PKRAM_LOAD);
+
+ return __pkram_load_page(ps, index, flags);
}
/**
--
2.13.3
Powered by blists - more mailing lists