xen-project/xen
1
0 Fork 0
mirror of https://github.com/xen-project/xen.git synced 2026-10-28 02:01:24 +01:00
Code Issues Activity

xen: remove tmem from hypervisor

Browse Source 
This patch removes all tmem related code and CONFIG_TMEM from the
hypervisor. Also remove tmem hypercalls from the default XSM policy.

It is written as if tmem is disabled and tmem freeable pages is 0.

We will need to keep public/tmem.h around forever to avoid breaking
guests.  Remove the hypervisor only part and put guest visible part
under a xen version check. Take the chance to remove trailing
whitespaces.

Signed-off-by: Wei Liu <wei.liu2@citrix.com>
Acked-by: Jan Beulich <jbeulich@suse.com>
Acked-by: Daniel De Graaf <dgdegra@tycho.nsa.gov>
Acked-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
Acked-by: Ian Jackson <ian.jackson@eu.citrix.com>
This commit is contained in:
Wei Liu committed 2019-05-13 11:28:27 +01:00
1 parent c588c002cc
commit c492e19fdd
36 files changed
+11 -3910
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

MAINTAINERS
-8
View File
@@ -402,14 +402,6 @@ F: */configure
F: */*.ac
F: tools/
TRANSCENDENT MEMORY (TMEM)
M: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
W: https://oss.oracle.com/projects/tmem
S: Supported
F: xen/common/tmem*
F: xen/include/xen/tmem*
F: docs/misc/tmem*
UNMODIFIED LINUX PV DRIVERS
M: Jan Beulich <jbeulich@suse.com>
S: Obsolete
tools/flask/policy/modules/dom0.te
+2 -2
View File
@@ -10,8 +10,8 @@ allow dom0_t xen_t:xen {
settime tbufcontrol readconsole clearconsole perfcontrol mtrr_add
mtrr_del mtrr_read microcode physinfo quirk writeconsole readapic
writeapic privprofile nonprivprofile kexec firmware sleep frequency
getidle debug getcpuinfo heap pm_op mca_op lockprof cpupool_op tmem_op
tmem_control getscheduler setscheduler
getidle debug getcpuinfo heap pm_op mca_op lockprof cpupool_op
getscheduler setscheduler
};
allow dom0_t xen_t:xen2 {
resource_op psr_cmt_op psr_alloc pmu_ctrl get_symbol
tools/flask/policy/modules/guest_features.te
-3
View File
@@ -1,6 +1,3 @@
# Allow all domains to use (unprivileged parts of) the tmem hypercall
allow domain_type xen_t:xen tmem_op;
# Allow all domains to use PMU (but not to change its settings --- that's what
# pmu_ctrl is for)
allow domain_type xen_t:xen2 pmu_use;
xen/arch/arm/configs/tiny64.conf
-1
View File
@@ -11,7 +11,6 @@ CONFIG_ARM=y
#
# Common Features
#
# CONFIG_TMEM is not set
CONFIG_SCHED_CREDIT=y
# CONFIG_SCHED_CREDIT2 is not set
# CONFIG_SCHED_RTDS is not set
xen/arch/x86/configs/pvshim_defconfig
-1
View File
@@ -11,7 +11,6 @@ CONFIG_NR_CPUS=32
# CONFIG_HVM_FEP is not set
# CONFIG_TBOOT is not set
# CONFIG_KEXEC is not set
# CONFIG_TMEM is not set
# CONFIG_XENOPROF is not set
# CONFIG_XSM is not set
# CONFIG_SCHED_CREDIT2 is not set
xen/arch/x86/guest/hypercall_page.S
-1
View File
@@ -58,7 +58,6 @@ DECLARE_HYPERCALL(hvm_op)
DECLARE_HYPERCALL(sysctl)
DECLARE_HYPERCALL(domctl)
DECLARE_HYPERCALL(kexec_op)
DECLARE_HYPERCALL(tmem_op)
DECLARE_HYPERCALL(argo_op)
DECLARE_HYPERCALL(xenpmu_op)
xen/arch/x86/hvm/hypercall.c
-3
View File
@@ -135,9 +135,6 @@ static const hypercall_table_t hvm_hypercall_table[] = {
HYPERCALL(hvm_op),
HYPERCALL(sysctl),
HYPERCALL(domctl),
#ifdef CONFIG_TMEM
HYPERCALL(tmem_op),
#endif
#ifdef CONFIG_ARGO
COMPAT_CALL(argo_op),
#endif
xen/arch/x86/hypercall.c
-1
View File
@@ -65,7 +65,6 @@ const hypercall_args_t hypercall_args_table[NR_hypercalls] =
ARGS(sysctl, 1),
ARGS(domctl, 1),
ARGS(kexec_op, 2),
ARGS(tmem_op, 1),
#ifdef CONFIG_ARGO
ARGS(argo_op, 5),
#endif
xen/arch/x86/pv/hypercall.c
-3
View File
@@ -76,9 +76,6 @@ const hypercall_table_t pv_hypercall_table[] = {
#ifdef CONFIG_KEXEC
COMPAT_CALL(kexec_op),
#endif
#ifdef CONFIG_TMEM
HYPERCALL(tmem_op),
#endif
#ifdef CONFIG_ARGO
COMPAT_CALL(argo_op),
#endif
xen/arch/x86/setup.c
-8
View File
@@ -25,7 +25,6 @@
#include <xen/dmi.h>
#include <xen/pfn.h>
#include <xen/nodemask.h>
#include <xen/tmem_xen.h>
#include <xen/virtual_region.h>
#include <xen/watchdog.h>
#include <public/version.h>
@@ -1496,13 +1495,6 @@ void __init noreturn __start_xen(unsigned long mbi_p)
s = pfn_to_paddr(limit + 1);
init_domheap_pages(s, e);
}
if ( tmem_enabled() )
{
printk(XENLOG_WARNING
"TMEM physical RAM limit exceeded, disabling TMEM\n");
tmem_disable();
}
}
else
end_boot_allocator();
xen/common/Kconfig
-15
View File
@@ -88,21 +88,6 @@ config KEXEC
If unsure, say Y.
config TMEM
bool "Transcendent Memory Support (deprecated)" if EXPERT = "y"
---help---
Transcendent memory allows PV-aware guests to collaborate on memory
usage. Guests can 'swap' their memory to the hypervisor or have an
collective pool of memory shared across guests. The end result is
less memory usage by guests allowing higher guest density.
You also have to enable it on the Xen commandline by using tmem=1.
WARNING: This option (and its underlying code) is going to go away
in a future Xen version.
If unsure, say N.
config XENOPROF
def_bool y
prompt "Xen Oprofile Support" if EXPERT = "y"
xen/common/Makefile
+1 -8
View File
@@ -22,7 +22,6 @@ obj-$(CONFIG_KEXEC) += kimage.o
obj-y += lib.o
obj-$(CONFIG_NEEDS_LIST_SORT) += list_sort.o
obj-$(CONFIG_LIVEPATCH) += livepatch.o livepatch_elf.o
obj-$(CONFIG_TMEM) += lzo.o
obj-$(CONFIG_MEM_ACCESS) += mem_access.o
obj-y += memory.o
obj-y += monitor.o
@@ -67,16 +66,10 @@ obj-bin-y += warning.init.o
obj-$(CONFIG_XENOPROF) += xenoprof.o
obj-y += xmalloc_tlsf.o
lzo-y := lzo
lzo-$(CONFIG_TMEM) :=
obj-bin-$(CONFIG_X86) += $(foreach n,decompress bunzip2 unxz unlzma $(lzo-y) unlzo unlz4 earlycpio,$(n).init.o)
obj-bin-$(CONFIG_X86) += $(foreach n,decompress bunzip2 unxz unlzma lzo unlzo unlz4 earlycpio,$(n).init.o)
obj-$(CONFIG_COMPAT) += $(addprefix compat/,domain.o kernel.o memory.o multicall.o xlat.o)
tmem-y := tmem.o tmem_xen.o tmem_control.o
tmem-$(CONFIG_COMPAT) += compat/tmem_xen.o
obj-$(CONFIG_TMEM) += $(tmem-y)
extra-y := symbols-dummy.o
subdir-$(CONFIG_COVERAGE) += coverage
xen/common/compat/tmem_xen.c
-23
View File
@@ -1,23 +0,0 @@
/******************************************************************************
* tmem_xen.c
*
*/
#include <xen/lib.h>
#include <xen/sched.h>
#include <xen/domain.h>
#include <xen/guest_access.h>
#include <xen/hypercall.h>
#include <compat/tmem.h>
CHECK_tmem_oid;
/*
* Local variables:
* mode: C
* c-file-style: "BSD"
* c-basic-offset: 4
* tab-width: 4
* indent-tabs-mode: nil
* End:
*/
xen/common/domain.c
-3
View File
@@ -41,7 +41,6 @@
#include <public/vcpu.h>
#include <xsm/xsm.h>
#include <xen/trace.h>
#include <xen/tmem.h>
#include <asm/setup.h>
#ifdef CONFIG_X86
@@ -725,10 +724,8 @@ int domain_kill(struct domain *d)
argo_destroy(d);
evtchn_destroy(d);
gnttab_release_mappings(d);
tmem_destroy(d->tmem_client);
vnuma_destroy(d->vnuma);
domain_set_outstanding_pages(d, 0);
d->tmem_client = NULL;
/* fallthrough */
case DOMDYING_dying:
rc = domain_relinquish_resources(d);
xen/common/lzo.c
-262
View File
@@ -105,269 +105,7 @@
#define get_unaligned_le16(_p) (*(u16 *)(_p))
#define get_unaligned_le32(_p) (*(u32 *)(_p))
#ifdef CONFIG_TMEM
static noinline size_t
lzo1x_1_do_compress(const unsigned char *in, size_t in_len,
unsigned char *out, size_t *out_len,
size_t ti, void *wrkmem)
{
const unsigned char *ip;
unsigned char *op;
const unsigned char * const in_end = in + in_len;
const unsigned char * const ip_end = in + in_len - 20;
const unsigned char *ii;
lzo_dict_t * const dict = (lzo_dict_t *) wrkmem;
op = out;
ip = in;
ii = ip;
ip += ti < 4 ? 4 - ti : 0;
for (;;) {
const unsigned char *m_pos;
size_t t, m_len, m_off;
u32 dv;
literal:
ip += 1 + ((ip - ii) >> 5);
next:
if (unlikely(ip >= ip_end))
break;
dv = get_unaligned_le32(ip);
t = ((dv * 0x1824429d) >> (32 - D_BITS)) & D_MASK;
m_pos = in + dict[t];
dict[t] = (lzo_dict_t) (ip - in);
if (unlikely(dv != get_unaligned_le32(m_pos)))
goto literal;
ii -= ti;
ti = 0;
t = ip - ii;
if (t != 0) {
if (t <= 3) {
op[-2] |= t;
COPY4(op, ii);
op += t;
} else if (t <= 16) {
*op++ = (t - 3);
COPY8(op, ii);
COPY8(op + 8, ii + 8);
op += t;
} else {
if (t <= 18) {
*op++ = (t - 3);
} else {
size_t tt = t - 18;
*op++ = 0;
while (unlikely(tt > 255)) {
tt -= 255;
*op++ = 0;
}
*op++ = tt;
}
do {
COPY8(op, ii);
COPY8(op + 8, ii + 8);
op += 16;
ii += 16;
t -= 16;
} while (t >= 16);
if (t > 0) do {
*op++ = *ii++;
} while (--t > 0);
}
}
m_len = 4;
{
#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && defined(LZO_USE_CTZ64)
u64 v;
v = get_unaligned((const u64 *) (ip + m_len)) ^
get_unaligned((const u64 *) (m_pos + m_len));
if (unlikely(v == 0)) {
do {
m_len += 8;
v = get_unaligned((const u64 *) (ip + m_len)) ^
get_unaligned((const u64 *) (m_pos + m_len));
if (unlikely(ip + m_len >= ip_end))
goto m_len_done;
} while (v == 0);
}
# if defined(__LITTLE_ENDIAN)
m_len += (unsigned) __builtin_ctzll(v) / 8;
# elif defined(__BIG_ENDIAN)
m_len += (unsigned) __builtin_clzll(v) / 8;
# else
# error "missing endian definition"
# endif
#elif defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && defined(LZO_USE_CTZ32)
u32 v;
v = get_unaligned((const u32 *) (ip + m_len)) ^
get_unaligned((const u32 *) (m_pos + m_len));
if (unlikely(v == 0)) {
do {
m_len += 4;
v = get_unaligned((const u32 *) (ip + m_len)) ^
get_unaligned((const u32 *) (m_pos + m_len));
if (v != 0)
break;
m_len += 4;
v = get_unaligned((const u32 *) (ip + m_len)) ^
get_unaligned((const u32 *) (m_pos + m_len));
if (unlikely(ip + m_len >= ip_end))
goto m_len_done;
} while (v == 0);
}
# if defined(__LITTLE_ENDIAN)
m_len += (unsigned) __builtin_ctz(v) / 8;
# elif defined(__BIG_ENDIAN)
m_len += (unsigned) __builtin_clz(v) / 8;
# else
# error "missing endian definition"
# endif
#else
if (unlikely(ip[m_len] == m_pos[m_len])) {
do {
m_len += 1;
if (ip[m_len] != m_pos[m_len])
break;
m_len += 1;
if (ip[m_len] != m_pos[m_len])
break;
m_len += 1;
if (ip[m_len] != m_pos[m_len])
break;
m_len += 1;
if (ip[m_len] != m_pos[m_len])
break;
m_len += 1;
if (ip[m_len] != m_pos[m_len])
break;
m_len += 1;
if (ip[m_len] != m_pos[m_len])
break;
m_len += 1;
if (ip[m_len] != m_pos[m_len])
break;
m_len += 1;
if (unlikely(ip + m_len >= ip_end))
goto m_len_done;
} while (ip[m_len] == m_pos[m_len]);
}
#endif
}
m_len_done:
m_off = ip - m_pos;
ip += m_len;
ii = ip;
if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) {
m_off -= 1;
*op++ = (((m_len - 1) << 5) | ((m_off & 7) << 2));
*op++ = (m_off >> 3);
} else if (m_off <= M3_MAX_OFFSET) {
m_off -= 1;
if (m_len <= M3_MAX_LEN)
*op++ = (M3_MARKER | (m_len - 2));
else {
m_len -= M3_MAX_LEN;
*op++ = M3_MARKER | 0;
while (unlikely(m_len > 255)) {
m_len -= 255;
*op++ = 0;
}
*op++ = (m_len);
}
*op++ = (m_off << 2);
*op++ = (m_off >> 6);
} else {
m_off -= 0x4000;
if (m_len <= M4_MAX_LEN)
*op++ = (M4_MARKER | ((m_off >> 11) & 8)
| (m_len - 2));
else {
m_len -= M4_MAX_LEN;
*op++ = (M4_MARKER | ((m_off >> 11) & 8));
while (unlikely(m_len > 255)) {
m_len -= 255;
*op++ = 0;
}
*op++ = (m_len);
}
*op++ = (m_off << 2);
*op++ = (m_off >> 6);
}
goto next;
}
*out_len = op - out;
return in_end - (ii - ti);
}
int lzo1x_1_compress(const unsigned char *in, size_t in_len,
unsigned char *out, size_t *out_len,
void *wrkmem)
{
const unsigned char *ip = in;
unsigned char *op = out;
size_t l = in_len;
size_t t = 0;
while (l > 20) {
size_t ll = l <= (M4_MAX_OFFSET + 1) ? l : (M4_MAX_OFFSET + 1);
uintptr_t ll_end = (uintptr_t) ip + ll;
if ((ll_end + ((t + ll) >> 5)) <= ll_end)
break;
BUILD_BUG_ON(D_SIZE * sizeof(lzo_dict_t) > LZO1X_1_MEM_COMPRESS);
memset(wrkmem, 0, D_SIZE * sizeof(lzo_dict_t));
t = lzo1x_1_do_compress(ip, ll, op, out_len, t, wrkmem);
ip += ll;
op += *out_len;
l -= ll;
}
t += l;
if (t > 0) {
const unsigned char *ii = in + in_len - t;
if (op == out && t <= 238) {
*op++ = (17 + t);
} else if (t <= 3) {
op[-2] |= t;
} else if (t <= 18) {
*op++ = (t - 3);
} else {
size_t tt = t - 18;
*op++ = 0;
while (tt > 255) {
tt -= 255;
*op++ = 0;
}
*op++ = tt;
}
if (t >= 16) do {
COPY8(op, ii);
COPY8(op + 8, ii + 8);
op += 16;
ii += 16;
t -= 16;
} while (t >= 16);
if (t > 0) do {
*op++ = *ii++;
} while (--t > 0);
}
*op++ = M4_MARKER | 1;
*op++ = 0;
*op++ = 0;
*out_len = op - out;
return LZO_E_OK;
}
# define INIT
#else /* CONFIG_TMEM */
#include "decompress.h"
#endif /* CONFIG_TMEM */
/*
* LZO1X Decompressor from LZO
xen/common/memory.c
+1 -3
View File
@@ -7,6 +7,7 @@
* Copyright (c) 2003-2005, K A Fraser
*/
#include <xen/domain_page.h>
#include <xen/types.h>
#include <xen/lib.h>
#include <xen/mm.h>
@@ -18,8 +19,6 @@
#include <xen/guest_access.h>
#include <xen/hypercall.h>
#include <xen/errno.h>
#include <xen/tmem.h>
#include <xen/tmem_xen.h>
#include <xen/numa.h>
#include <xen/mem_access.h>
#include <xen/trace.h>
@@ -250,7 +249,6 @@ static void populate_physmap(struct memop_args *a)
if ( unlikely(!page) )
{
if ( !tmem_enabled() || a->extent_order )
gdprintk(XENLOG_INFO,
"Could not allocate order=%u extent: id=%d memflags=%#x (%u of %u)\n",
a->extent_order, d->domain_id, a->memflags,
xen/common/page_alloc.c
+2 -46
View File
@@ -135,8 +135,6 @@
#include <xen/numa.h>
#include <xen/nodemask.h>
#include <xen/event.h>
#include <xen/tmem.h>
#include <xen/tmem_xen.h>
#include <public/sysctl.h>
#include <public/sched.h>
#include <asm/page.h>
@@ -455,10 +453,6 @@ static unsigned long node_need_scrub[MAX_NUMNODES];
static unsigned long *avail[MAX_NUMNODES];
static long total_avail_pages;
/* TMEM: Reserve a fraction of memory for mid-size (0<order<9) allocations.*/
static long midsize_alloc_zone_pages;
#define MIDSIZE_ALLOC_FRAC 128
static DEFINE_SPINLOCK(heap_lock);
static long outstanding_claims; /* total outstanding claims by all domains */
@@ -534,16 +528,6 @@ int domain_set_outstanding_pages(struct domain *d, unsigned long pages)
/* how much memory is available? */
avail_pages = total_avail_pages;
/* Note: The usage of claim means that allocation from a guest *might*
* have to come from freeable memory. Using free memory is always better, if
* it is available, than using freeable memory.
*
* But that is OK as once the claim has been made, it still can take minutes
* before the claim is fully satisfied. Tmem can make use of the unclaimed
* pages during this time (to store ephemeral/freeable pages only,
* not persistent pages).
*/
avail_pages += tmem_freeable_pages();
avail_pages -= outstanding_claims;
/*
@@ -715,8 +699,7 @@ static void __init setup_low_mem_virq(void)
static void check_low_mem_virq(void)
{
unsigned long avail_pages = total_avail_pages +
tmem_freeable_pages() - outstanding_claims;
unsigned long avail_pages = total_avail_pages - outstanding_claims;
if ( unlikely(avail_pages <= low_mem_virq_th) )
{
@@ -943,8 +926,7 @@ static struct page_info *alloc_heap_pages(
* Claimed memory is considered unavailable unless the request
* is made by a domain with sufficient unclaimed pages.
*/
if ( (outstanding_claims + request >
total_avail_pages + tmem_freeable_pages()) &&
if ( (outstanding_claims + request > total_avail_pages) &&
((memflags & MEMF_no_refcount) ||
!d || d->outstanding_pages < request) )
{
@@ -952,22 +934,6 @@ static struct page_info *alloc_heap_pages(
return NULL;
}
/*
* TMEM: When available memory is scarce due to tmem absorbing it, allow
* only mid-size allocations to avoid worst of fragmentation issues.
* Others try tmem pools then fail. This is a workaround until all
* post-dom0-creation-multi-page allocations can be eliminated.
*/
if ( ((order == 0) || (order >= 9)) &&
(total_avail_pages <= midsize_alloc_zone_pages) &&
tmem_freeable_pages() )
{
/* Try to free memory from tmem. */
pg = tmem_relinquish_pages(order, memflags);
spin_unlock(&heap_lock);
return pg;
}
pg = get_free_buddy(zone_lo, zone_hi, order, memflags, d);
/* Try getting a dirty buddy if we couldn't get a clean one. */
if ( !pg && !(memflags & MEMF_no_scrub) )
@@ -1456,10 +1422,6 @@ static void free_heap_pages(
else
pg->u.free.first_dirty = INVALID_DIRTY_IDX;
if ( tmem_enabled() )
midsize_alloc_zone_pages = max(
midsize_alloc_zone_pages, total_avail_pages / MIDSIZE_ALLOC_FRAC);
/* Merge chunks as far as possible. */
while ( order < MAX_ORDER )
{
@@ -1846,11 +1808,6 @@ static unsigned long avail_heap_pages(
return free_pages;
}
unsigned long total_free_pages(void)
{
return total_avail_pages - midsize_alloc_zone_pages;
}
void __init end_boot_allocator(void)
{
unsigned int i;
@@ -2277,7 +2234,6 @@ int assign_pages(
{
if ( unlikely((d->tot_pages + (1 << order)) > d->max_pages) )
{
if ( !tmem_enabled() || order != 0 || d->tot_pages != d->max_pages )
gprintk(XENLOG_INFO, "Over-allocation for domain %u: "
"%u > %u\n", d->domain_id,
d->tot_pages + (1 << order), d->max_pages);
xen/common/sysctl.c
-5
View File
@@ -13,7 +13,6 @@
#include <xen/domain.h>
#include <xen/event.h>
#include <xen/domain_page.h>
#include <xen/tmem.h>
#include <xen/trace.h>
#include <xen/console.h>
#include <xen/iocap.h>
@@ -456,10 +455,6 @@ long do_sysctl(XEN_GUEST_HANDLE_PARAM(xen_sysctl_t) u_sysctl)
}
#endif
case XEN_SYSCTL_tmem_op:
ret = tmem_control(&op->u.tmem_op);
break;
case XEN_SYSCTL_livepatch_op:
ret = livepatch_op(&op->u.livepatch);
if ( ret != -ENOSYS && ret != -EOPNOTSUPP )
xen/common/tmem.c
-2095
View File
File diff suppressed because it is too large. Load diff
xen/common/tmem_control.c
-560
View File
@@ -1,560 +0,0 @@
/*
* Copyright (c) 2016 Oracle and/or its affiliates. All rights reserved.
*
*/
#include <xen/init.h>
#include <xen/list.h>
#include <xen/radix-tree.h>
#include <xen/rbtree.h>
#include <xen/rwlock.h>
#include <xen/tmem_control.h>
#include <xen/tmem.h>
#include <xen/tmem_xen.h>
#include <public/sysctl.h>
/************ TMEM CONTROL OPERATIONS ************************************/
/* Freeze/thaw all pools belonging to client cli_id (all domains if -1). */
static int tmemc_freeze_pools(domid_t cli_id, int arg)
{
struct client *client;
bool freeze = arg == XEN_SYSCTL_TMEM_OP_FREEZE;
bool destroy = arg == XEN_SYSCTL_TMEM_OP_DESTROY;
char *s;
s = destroy ? "destroyed" : ( freeze ? "frozen" : "thawed" );
if ( cli_id == TMEM_CLI_ID_NULL )
{
list_for_each_entry(client,&tmem_global.client_list,client_list)
client->info.flags.u.frozen = freeze;
tmem_client_info("tmem: all pools %s for all %ss\n", s, tmem_client_str);
}
else
{
if ( (client = tmem_client_from_cli_id(cli_id)) == NULL)
return -1;
client->info.flags.u.frozen = freeze;
tmem_client_info("tmem: all pools %s for %s=%d\n",
s, tmem_cli_id_str, cli_id);
}
return 0;
}
static unsigned long tmem_flush_npages(unsigned long n)
{
unsigned long avail_pages = 0;
while ( (avail_pages = tmem_page_list_pages) < n )
{
if ( !tmem_evict() )
break;
}
if ( avail_pages )
{
spin_lock(&tmem_page_list_lock);
while ( !page_list_empty(&tmem_page_list) )
{
struct page_info *pg = page_list_remove_head(&tmem_page_list);
scrub_one_page(pg);
tmem_page_list_pages--;
free_domheap_page(pg);
}
ASSERT(tmem_page_list_pages == 0);
INIT_PAGE_LIST_HEAD(&tmem_page_list);
spin_unlock(&tmem_page_list_lock);
}
return avail_pages;
}
static int tmemc_flush_mem(domid_t cli_id, uint32_t kb)
{
uint32_t npages, flushed_pages, flushed_kb;
if ( cli_id != TMEM_CLI_ID_NULL )
{
tmem_client_warn("tmem: %s-specific flush not supported yet, use --all\n",
tmem_client_str);
return -1;
}
/* Convert kb to pages, rounding up if necessary. */
npages = (kb + ((1 << (PAGE_SHIFT-10))-1)) >> (PAGE_SHIFT-10);
flushed_pages = tmem_flush_npages(npages);
flushed_kb = flushed_pages << (PAGE_SHIFT-10);
return flushed_kb;
}
/*
* These tmemc_list* routines output lots of stats in a format that is
* intended to be program-parseable, not human-readable. Further, by
* tying each group of stats to a line format indicator (e.g. G= for
* global stats) and each individual stat to a two-letter specifier
* (e.g. Ec:nnnnn in the G= line says there are nnnnn pages in the
* global ephemeral pool), it should allow the stats reported to be
* forward and backwards compatible as tmem evolves.
*/
#define BSIZE 1024
static int tmemc_list_client(struct client *c, tmem_cli_va_param_t buf,
int off, uint32_t len, bool use_long)
{
char info[BSIZE];
int i, n = 0, sum = 0;
struct tmem_pool *p;
bool s;
n = scnprintf(info,BSIZE,"C=CI:%d,ww:%d,co:%d,fr:%d,"
"Tc:%"PRIu64",Ge:%ld,Pp:%ld,Gp:%ld%c",
c->cli_id, c->info.weight, c->info.flags.u.compress, c->info.flags.u.frozen,
c->total_cycles, c->succ_eph_gets, c->succ_pers_puts, c->succ_pers_gets,
use_long ? ',' : '\n');
if (use_long)
n += scnprintf(info+n,BSIZE-n,
"Ec:%ld,Em:%ld,cp:%ld,cb:%"PRId64",cn:%ld,cm:%ld\n",
c->eph_count, c->eph_count_max,
c->compressed_pages, c->compressed_sum_size,
c->compress_poor, c->compress_nomem);
if ( !copy_to_guest_offset(buf, off + sum, info, n + 1) )
sum += n;
for ( i = 0; i < MAX_POOLS_PER_DOMAIN; i++ )
{
if ( (p = c->pools[i]) == NULL )
continue;
s = is_shared(p);
n = scnprintf(info,BSIZE,"P=CI:%d,PI:%d,"
"PT:%c%c,U0:%"PRIx64",U1:%"PRIx64"%c",
c->cli_id, p->pool_id,
is_persistent(p) ? 'P' : 'E', s ? 'S' : 'P',
(uint64_t)(s ? p->uuid[0] : 0),
(uint64_t)(s ? p->uuid[1] : 0LL),
use_long ? ',' : '\n');
if (use_long)
n += scnprintf(info+n,BSIZE-n,
"Pc:%d,Pm:%d,Oc:%ld,Om:%ld,Nc:%lu,Nm:%lu,"
"ps:%lu,pt:%lu,pd:%lu,pr:%lu,px:%lu,gs:%lu,gt:%lu,"
"fs:%lu,ft:%lu,os:%lu,ot:%lu\n",
_atomic_read(p->pgp_count), p->pgp_count_max,
p->obj_count, p->obj_count_max,
p->objnode_count, p->objnode_count_max,
p->good_puts, p->puts,p->dup_puts_flushed, p->dup_puts_replaced,
p->no_mem_puts,
p->found_gets, p->gets,
p->flushs_found, p->flushs, p->flush_objs_found, p->flush_objs);
if ( sum + n >= len )
return sum;
if ( !copy_to_guest_offset(buf, off + sum, info, n + 1) )
sum += n;
}
return sum;
}
static int tmemc_list_shared(tmem_cli_va_param_t buf, int off, uint32_t len,
bool use_long)
{
char info[BSIZE];
int i, n = 0, sum = 0;
struct tmem_pool *p;
struct share_list *sl;
for ( i = 0; i < MAX_GLOBAL_SHARED_POOLS; i++ )
{
if ( (p = tmem_global.shared_pools[i]) == NULL )
continue;
n = scnprintf(info+n,BSIZE-n,"S=SI:%d,PT:%c%c,U0:%"PRIx64",U1:%"PRIx64,
i, is_persistent(p) ? 'P' : 'E',
is_shared(p) ? 'S' : 'P',
p->uuid[0], p->uuid[1]);
list_for_each_entry(sl,&p->share_list, share_list)
n += scnprintf(info+n,BSIZE-n,",SC:%d",sl->client->cli_id);
n += scnprintf(info+n,BSIZE-n,"%c", use_long ? ',' : '\n');
if (use_long)
n += scnprintf(info+n,BSIZE-n,
"Pc:%d,Pm:%d,Oc:%ld,Om:%ld,Nc:%lu,Nm:%lu,"
"ps:%lu,pt:%lu,pd:%lu,pr:%lu,px:%lu,gs:%lu,gt:%lu,"
"fs:%lu,ft:%lu,os:%lu,ot:%lu\n",
_atomic_read(p->pgp_count), p->pgp_count_max,
p->obj_count, p->obj_count_max,
p->objnode_count, p->objnode_count_max,
p->good_puts, p->puts,p->dup_puts_flushed, p->dup_puts_replaced,
p->no_mem_puts,
p->found_gets, p->gets,
p->flushs_found, p->flushs, p->flush_objs_found, p->flush_objs);
if ( sum + n >= len )
return sum;
if ( !copy_to_guest_offset(buf, off + sum, info, n + 1) )
sum += n;
}
return sum;
}
static int tmemc_list_global_perf(tmem_cli_va_param_t buf, int off,
uint32_t len, bool use_long)
{
char info[BSIZE];
int n = 0, sum = 0;
n = scnprintf(info+n,BSIZE-n,"T=");
n--; /* Overwrite trailing comma. */
n += scnprintf(info+n,BSIZE-n,"\n");
if ( sum + n >= len )
return sum;
if ( !copy_to_guest_offset(buf, off + sum, info, n + 1) )
sum += n;
return sum;
}
static int tmemc_list_global(tmem_cli_va_param_t buf, int off, uint32_t len,
bool use_long)
{
char info[BSIZE];
int n = 0, sum = off;
n += scnprintf(info,BSIZE,"G="
"Tt:%lu,Te:%lu,Cf:%lu,Af:%lu,Pf:%lu,Ta:%lu,"
"Lm:%lu,Et:%lu,Ea:%lu,Rt:%lu,Ra:%lu,Rx:%lu,Fp:%lu%c",
tmem_stats.total_tmem_ops, tmem_stats.errored_tmem_ops, tmem_stats.failed_copies,
tmem_stats.alloc_failed, tmem_stats.alloc_page_failed, tmem_page_list_pages,
tmem_stats.low_on_memory, tmem_stats.evicted_pgs,
tmem_stats.evict_attempts, tmem_stats.relinq_pgs, tmem_stats.relinq_attempts,
tmem_stats.max_evicts_per_relinq,
tmem_stats.total_flush_pool, use_long ? ',' : '\n');
if (use_long)
n += scnprintf(info+n,BSIZE-n,
"Ec:%ld,Em:%ld,Oc:%d,Om:%d,Nc:%d,Nm:%d,Pc:%d,Pm:%d,"
"Fc:%d,Fm:%d,Sc:%d,Sm:%d,Ep:%lu,Gd:%lu,Zt:%lu,Gz:%lu\n",
tmem_global.eph_count, tmem_stats.global_eph_count_max,
_atomic_read(tmem_stats.global_obj_count), tmem_stats.global_obj_count_max,
_atomic_read(tmem_stats.global_rtree_node_count), tmem_stats.global_rtree_node_count_max,
_atomic_read(tmem_stats.global_pgp_count), tmem_stats.global_pgp_count_max,
_atomic_read(tmem_stats.global_page_count), tmem_stats.global_page_count_max,
_atomic_read(tmem_stats.global_pcd_count), tmem_stats.global_pcd_count_max,
tmem_stats.tot_good_eph_puts,tmem_stats.deduped_puts,tmem_stats.pcd_tot_tze_size,
tmem_stats.pcd_tot_csize);
if ( sum + n >= len )
return sum;
if ( !copy_to_guest_offset(buf, off + sum, info, n + 1) )
sum += n;
return sum;
}
static int tmemc_list(domid_t cli_id, tmem_cli_va_param_t buf, uint32_t len,
bool use_long)
{
struct client *client;
int off = 0;
if ( cli_id == TMEM_CLI_ID_NULL ) {
off = tmemc_list_global(buf,0,len,use_long);
off += tmemc_list_shared(buf,off,len-off,use_long);
list_for_each_entry(client,&tmem_global.client_list,client_list)
off += tmemc_list_client(client, buf, off, len-off, use_long);
off += tmemc_list_global_perf(buf,off,len-off,use_long);
}
else if ( (client = tmem_client_from_cli_id(cli_id)) == NULL)
return -1;
else
off = tmemc_list_client(client, buf, 0, len, use_long);
return 0;
}
static int __tmemc_set_client_info(struct client *client,
XEN_GUEST_HANDLE(xen_tmem_client_t) buf)
{
domid_t cli_id;
uint32_t old_weight;
xen_tmem_client_t info = { };
ASSERT(client);
if ( copy_from_guest(&info, buf, 1) )
return -EFAULT;
if ( info.version != TMEM_SPEC_VERSION )
return -EOPNOTSUPP;
if ( info.maxpools > MAX_POOLS_PER_DOMAIN )
return -ERANGE;
/* Ignore info.nr_pools. */
cli_id = client->cli_id;
if ( info.weight != client->info.weight )
{
old_weight = client->info.weight;
client->info.weight = info.weight;
tmem_client_info("tmem: weight set to %d for %s=%d\n",
info.weight, tmem_cli_id_str, cli_id);
atomic_sub(old_weight,&tmem_global.client_weight_total);
atomic_add(client->info.weight,&tmem_global.client_weight_total);
}
if ( info.flags.u.compress != client->info.flags.u.compress )
{
client->info.flags.u.compress = info.flags.u.compress;
tmem_client_info("tmem: compression %s for %s=%d\n",
info.flags.u.compress ? "enabled" : "disabled",
tmem_cli_id_str,cli_id);
}
return 0;
}
static int tmemc_set_client_info(domid_t cli_id,
XEN_GUEST_HANDLE(xen_tmem_client_t) info)
{
struct client *client;
int ret = -ENOENT;
if ( cli_id == TMEM_CLI_ID_NULL )
{
list_for_each_entry(client,&tmem_global.client_list,client_list)
{
ret = __tmemc_set_client_info(client, info);
if (ret)
break;
}
}
else
{
client = tmem_client_from_cli_id(cli_id);
if ( client )
ret = __tmemc_set_client_info(client, info);
}
return ret;
}
static int tmemc_get_client_info(int cli_id,
XEN_GUEST_HANDLE(xen_tmem_client_t) info)
{
struct client *client = tmem_client_from_cli_id(cli_id);
if ( client )
{
if ( copy_to_guest(info, &client->info, 1) )
return -EFAULT;
}
else
{
static const xen_tmem_client_t generic = {
.version = TMEM_SPEC_VERSION,
.maxpools = MAX_POOLS_PER_DOMAIN
};
if ( copy_to_guest(info, &generic, 1) )
return -EFAULT;
}
return 0;
}
static int tmemc_get_pool(int cli_id,
XEN_GUEST_HANDLE(xen_tmem_pool_info_t) pools,
uint32_t len)
{
struct client *client = tmem_client_from_cli_id(cli_id);
unsigned int i, idx;
int rc = 0;
unsigned int nr = len / sizeof(xen_tmem_pool_info_t);
if ( len % sizeof(xen_tmem_pool_info_t) )
return -EINVAL;
if ( nr > MAX_POOLS_PER_DOMAIN )
return -E2BIG;
if ( !guest_handle_okay(pools, nr) )
return -EINVAL;
if ( !client )
return -EINVAL;
for ( idx = 0, i = 0; i < MAX_POOLS_PER_DOMAIN; i++ )
{
struct tmem_pool *pool = client->pools[i];
xen_tmem_pool_info_t out;
if ( pool == NULL )
continue;
out.flags.raw = (pool->persistent ? TMEM_POOL_PERSIST : 0) |
(pool->shared ? TMEM_POOL_SHARED : 0) |
(POOL_PAGESHIFT << TMEM_POOL_PAGESIZE_SHIFT) |
(TMEM_SPEC_VERSION << TMEM_POOL_VERSION_SHIFT);
out.n_pages = _atomic_read(pool->pgp_count);
out.uuid[0] = pool->uuid[0];
out.uuid[1] = pool->uuid[1];
out.id = i;
/* N.B. 'idx' != 'i'. */
if ( __copy_to_guest_offset(pools, idx, &out, 1) )
{
rc = -EFAULT;
break;
}
idx++;
/* Don't try to put more than what was requested. */
if ( idx >= nr )
break;
}
/* And how many we have processed. */
return rc ? : idx;
}
static int tmemc_set_pools(int cli_id,
XEN_GUEST_HANDLE(xen_tmem_pool_info_t) pools,
uint32_t len)
{
unsigned int i;
int rc = 0;
unsigned int nr = len / sizeof(xen_tmem_pool_info_t);
struct client *client = tmem_client_from_cli_id(cli_id);
if ( len % sizeof(xen_tmem_pool_info_t) )
return -EINVAL;
if ( nr > MAX_POOLS_PER_DOMAIN )
return -E2BIG;
if ( !guest_handle_okay(pools, nr) )
return -EINVAL;
if ( !client )
{
client = client_create(cli_id);
if ( !client )
return -ENOMEM;
}
for ( i = 0; i < nr; i++ )
{
xen_tmem_pool_info_t pool;
if ( __copy_from_guest_offset(&pool, pools, i, 1 ) )
return -EFAULT;
if ( pool.n_pages )
return -EINVAL;
rc = do_tmem_new_pool(cli_id, pool.id, pool.flags.raw,
pool.uuid[0], pool.uuid[1]);
if ( rc < 0 )
break;
pool.id = rc;
if ( __copy_to_guest_offset(pools, i, &pool, 1) )
return -EFAULT;
}
/* And how many we have processed. */
return rc ? : i;
}
static int tmemc_auth_pools(int cli_id,
XEN_GUEST_HANDLE(xen_tmem_pool_info_t) pools,
uint32_t len)
{
unsigned int i;
int rc = 0;
unsigned int nr = len / sizeof(xen_tmem_pool_info_t);
struct client *client = tmem_client_from_cli_id(cli_id);
if ( len % sizeof(xen_tmem_pool_info_t) )
return -EINVAL;
if ( nr > MAX_POOLS_PER_DOMAIN )
return -E2BIG;
if ( !guest_handle_okay(pools, nr) )
return -EINVAL;
if ( !client )
{
client = client_create(cli_id);
if ( !client )
return -ENOMEM;
}
for ( i = 0; i < nr; i++ )
{
xen_tmem_pool_info_t pool;
if ( __copy_from_guest_offset(&pool, pools, i, 1 ) )
return -EFAULT;
if ( pool.n_pages )
return -EINVAL;
rc = tmemc_shared_pool_auth(cli_id, pool.uuid[0], pool.uuid[1],
pool.flags.u.auth);
if ( rc < 0 )
break;
}
/* And how many we have processed. */
return rc ? : i;
}
int tmem_control(struct xen_sysctl_tmem_op *op)
{
int ret;
uint32_t cmd = op->cmd;
if ( op->pad != 0 )
return -EINVAL;
write_lock(&tmem_rwlock);
switch (cmd)
{
case XEN_SYSCTL_TMEM_OP_THAW:
case XEN_SYSCTL_TMEM_OP_FREEZE:
case XEN_SYSCTL_TMEM_OP_DESTROY:
ret = tmemc_freeze_pools(op->cli_id, cmd);
break;
case XEN_SYSCTL_TMEM_OP_FLUSH:
ret = tmemc_flush_mem(op->cli_id, op->arg);
break;
case XEN_SYSCTL_TMEM_OP_LIST:
ret = tmemc_list(op->cli_id,
guest_handle_cast(op->u.buf, char), op->len, op->arg);
break;
case XEN_SYSCTL_TMEM_OP_SET_CLIENT_INFO:
ret = tmemc_set_client_info(op->cli_id, op->u.client);
break;
case XEN_SYSCTL_TMEM_OP_QUERY_FREEABLE_MB:
ret = tmem_freeable_pages() >> (20 - PAGE_SHIFT);
break;
case XEN_SYSCTL_TMEM_OP_GET_CLIENT_INFO:
ret = tmemc_get_client_info(op->cli_id, op->u.client);
break;
case XEN_SYSCTL_TMEM_OP_GET_POOLS:
ret = tmemc_get_pool(op->cli_id, op->u.pool, op->len);
break;
case XEN_SYSCTL_TMEM_OP_SET_POOLS: /* TMEM_RESTORE_NEW */
ret = tmemc_set_pools(op->cli_id, op->u.pool, op->len);
break;
case XEN_SYSCTL_TMEM_OP_SET_AUTH: /* TMEM_AUTH */
ret = tmemc_auth_pools(op->cli_id, op->u.pool, op->len);
break;
default:
ret = do_tmem_control(op);
break;
}
write_unlock(&tmem_rwlock);
return ret;
}
/*
* Local variables:
* mode: C
* c-file-style: "BSD"
* c-basic-offset: 4
* tab-width: 4
* indent-tabs-mode: nil
* End:
*/
xen/common/tmem_xen.c
-277
View File
@@ -1,277 +0,0 @@
/******************************************************************************
* tmem-xen.c
*
* Xen-specific Transcendent memory
*
* Copyright (c) 2009, Dan Magenheimer, Oracle Corp.
*/
#include <xen/tmem.h>
#include <xen/tmem_xen.h>
#include <xen/lzo.h> /* compression code */
#include <xen/paging.h>
#include <xen/domain_page.h>
#include <xen/cpu.h>
#include <xen/init.h>
bool __read_mostly opt_tmem;
boolean_param("tmem", opt_tmem);
bool __read_mostly opt_tmem_compress;
boolean_param("tmem_compress", opt_tmem_compress);
atomic_t freeable_page_count = ATOMIC_INIT(0);
/* these are a concurrency bottleneck, could be percpu and dynamically
* allocated iff opt_tmem_compress */
#define LZO_WORKMEM_BYTES LZO1X_1_MEM_COMPRESS
#define LZO_DSTMEM_PAGES 2
static DEFINE_PER_CPU_READ_MOSTLY(unsigned char *, workmem);
static DEFINE_PER_CPU_READ_MOSTLY(unsigned char *, dstmem);
static DEFINE_PER_CPU_READ_MOSTLY(void *, scratch_page);
#if defined(CONFIG_ARM)
static inline void *cli_get_page(xen_pfn_t cmfn, mfn_t *pcli_mfn,
struct page_info **pcli_pfp, bool cli_write)
{
ASSERT_UNREACHABLE();
return NULL;
}
static inline void cli_put_page(void *cli_va, struct page_info *cli_pfp,
mfn_t cli_mfn, bool mark_dirty)
{
ASSERT_UNREACHABLE();
}
#else
#include <asm/p2m.h>
static inline void *cli_get_page(xen_pfn_t cmfn, mfn_t *pcli_mfn,
struct page_info **pcli_pfp, bool cli_write)
{
p2m_type_t t;
struct page_info *page;
page = get_page_from_gfn(current->domain, cmfn, &t, P2M_ALLOC);
if ( !page || t != p2m_ram_rw )
{
if ( page )
put_page(page);
return NULL;
}
if ( cli_write && !get_page_type(page, PGT_writable_page) )
{
put_page(page);
return NULL;
}
*pcli_mfn = page_to_mfn(page);
*pcli_pfp = page;
return map_domain_page(*pcli_mfn);
}
static inline void cli_put_page(void *cli_va, struct page_info *cli_pfp,
mfn_t cli_mfn, bool mark_dirty)
{
if ( mark_dirty )
{
put_page_and_type(cli_pfp);
paging_mark_dirty(current->domain, cli_mfn);
}
else
put_page(cli_pfp);
unmap_domain_page(cli_va);
}
#endif
int tmem_copy_from_client(struct page_info *pfp,
xen_pfn_t cmfn, tmem_cli_va_param_t clibuf)
{
mfn_t tmem_mfn, cli_mfn = INVALID_MFN;
char *tmem_va, *cli_va = NULL;
struct page_info *cli_pfp = NULL;
int rc = 1;
ASSERT(pfp != NULL);
tmem_mfn = page_to_mfn(pfp);
tmem_va = map_domain_page(tmem_mfn);
if ( guest_handle_is_null(clibuf) )
{
cli_va = cli_get_page(cmfn, &cli_mfn, &cli_pfp, 0);
if ( cli_va == NULL )
{
unmap_domain_page(tmem_va);
return -EFAULT;
}
}
smp_mb();
if ( cli_va )
{
memcpy(tmem_va, cli_va, PAGE_SIZE);
cli_put_page(cli_va, cli_pfp, cli_mfn, 0);
}
else
rc = -EINVAL;
unmap_domain_page(tmem_va);
return rc;
}
int tmem_compress_from_client(xen_pfn_t cmfn,
void **out_va, size_t *out_len, tmem_cli_va_param_t clibuf)
{
int ret = 0;
unsigned char *dmem = this_cpu(dstmem);
unsigned char *wmem = this_cpu(workmem);
char *scratch = this_cpu(scratch_page);
struct page_info *cli_pfp = NULL;
mfn_t cli_mfn = INVALID_MFN;
void *cli_va = NULL;
if ( dmem == NULL || wmem == NULL )
return 0; /* no buffer, so can't compress */
if ( guest_handle_is_null(clibuf) )
{
cli_va = cli_get_page(cmfn, &cli_mfn, &cli_pfp, 0);
if ( cli_va == NULL )
return -EFAULT;
}
else if ( !scratch )
return 0;
else if ( copy_from_guest(scratch, clibuf, PAGE_SIZE) )
return -EFAULT;
smp_mb();
ret = lzo1x_1_compress(cli_va ?: scratch, PAGE_SIZE, dmem, out_len, wmem);
ASSERT(ret == LZO_E_OK);
*out_va = dmem;
if ( cli_va )
cli_put_page(cli_va, cli_pfp, cli_mfn, 0);
return 1;
}
int tmem_copy_to_client(xen_pfn_t cmfn, struct page_info *pfp,
tmem_cli_va_param_t clibuf)
{
mfn_t tmem_mfn, cli_mfn = INVALID_MFN;
char *tmem_va, *cli_va = NULL;
struct page_info *cli_pfp = NULL;
int rc = 1;
ASSERT(pfp != NULL);
if ( guest_handle_is_null(clibuf) )
{
cli_va = cli_get_page(cmfn, &cli_mfn, &cli_pfp, 1);
if ( cli_va == NULL )
return -EFAULT;
}
tmem_mfn = page_to_mfn(pfp);
tmem_va = map_domain_page(tmem_mfn);
if ( cli_va )
{
memcpy(cli_va, tmem_va, PAGE_SIZE);
cli_put_page(cli_va, cli_pfp, cli_mfn, 1);
}
else
rc = -EINVAL;
unmap_domain_page(tmem_va);
smp_mb();
return rc;
}
int tmem_decompress_to_client(xen_pfn_t cmfn, void *tmem_va,
size_t size, tmem_cli_va_param_t clibuf)
{
mfn_t cli_mfn = INVALID_MFN;
struct page_info *cli_pfp = NULL;
void *cli_va = NULL;
char *scratch = this_cpu(scratch_page);
size_t out_len = PAGE_SIZE;
int ret;
if ( guest_handle_is_null(clibuf) )
{
cli_va = cli_get_page(cmfn, &cli_mfn, &cli_pfp, 1);
if ( cli_va == NULL )
return -EFAULT;
}
else if ( !scratch )
return 0;
ret = lzo1x_decompress_safe(tmem_va, size, cli_va ?: scratch, &out_len);
ASSERT(ret == LZO_E_OK);
ASSERT(out_len == PAGE_SIZE);
if ( cli_va )
cli_put_page(cli_va, cli_pfp, cli_mfn, 1);
else if ( copy_to_guest(clibuf, scratch, PAGE_SIZE) )
return -EFAULT;
smp_mb();
return 1;
}
/****************** XEN-SPECIFIC HOST INITIALIZATION ********************/
static int dstmem_order, workmem_order;
static int cpu_callback(
struct notifier_block *nfb, unsigned long action, void *hcpu)
{
unsigned int cpu = (unsigned long)hcpu;
switch ( action )
{
case CPU_UP_PREPARE: {
if ( per_cpu(dstmem, cpu) == NULL )
per_cpu(dstmem, cpu) = alloc_xenheap_pages(dstmem_order, 0);
if ( per_cpu(workmem, cpu) == NULL )
per_cpu(workmem, cpu) = alloc_xenheap_pages(workmem_order, 0);
if ( per_cpu(scratch_page, cpu) == NULL )
per_cpu(scratch_page, cpu) = alloc_xenheap_page();
break;
}
case CPU_DEAD:
case CPU_UP_CANCELED: {
if ( per_cpu(dstmem, cpu) != NULL )
{
free_xenheap_pages(per_cpu(dstmem, cpu), dstmem_order);
per_cpu(dstmem, cpu) = NULL;
}
if ( per_cpu(workmem, cpu) != NULL )
{
free_xenheap_pages(per_cpu(workmem, cpu), workmem_order);
per_cpu(workmem, cpu) = NULL;
}
if ( per_cpu(scratch_page, cpu) != NULL )
{
free_xenheap_page(per_cpu(scratch_page, cpu));
per_cpu(scratch_page, cpu) = NULL;
}
break;
}
default:
break;
}
return NOTIFY_DONE;
}
static struct notifier_block cpu_nfb = {
.notifier_call = cpu_callback
};
int __init tmem_init(void)
{
unsigned int cpu;
dstmem_order = get_order_from_pages(LZO_DSTMEM_PAGES);
workmem_order = get_order_from_bytes(LZO1X_1_MEM_COMPRESS);
for_each_online_cpu ( cpu )
{
void *hcpu = (void *)(long)cpu;
cpu_callback(&cpu_nfb, CPU_UP_PREPARE, hcpu);
}
register_cpu_notifier(&cpu_nfb);
return 1;
}
xen/include/Makefile
-1
View File
@@ -17,7 +17,6 @@ headers-y := \
compat/physdev.h \
compat/platform.h \
compat/sched.h \
compat/tmem.h \
compat/trace.h \
compat/vcpu.h \
compat/version.h \
xen/include/public/sysctl.h
+1 -107
View File
@@ -34,7 +34,6 @@
#include "xen.h"
#include "domctl.h"
#include "physdev.h"
#include "tmem.h"
#define XEN_SYSCTL_INTERFACE_VERSION 0x00000012
@@ -751,110 +750,6 @@ struct xen_sysctl_psr_alloc {
} u;
};
#define XEN_SYSCTL_TMEM_OP_ALL_CLIENTS 0xFFFFU
#define XEN_SYSCTL_TMEM_OP_THAW 0
#define XEN_SYSCTL_TMEM_OP_FREEZE 1
#define XEN_SYSCTL_TMEM_OP_FLUSH 2
#define XEN_SYSCTL_TMEM_OP_DESTROY 3
#define XEN_SYSCTL_TMEM_OP_LIST 4
#define XEN_SYSCTL_TMEM_OP_GET_CLIENT_INFO 5
#define XEN_SYSCTL_TMEM_OP_SET_CLIENT_INFO 6
#define XEN_SYSCTL_TMEM_OP_GET_POOLS 7
#define XEN_SYSCTL_TMEM_OP_QUERY_FREEABLE_MB 8
#define XEN_SYSCTL_TMEM_OP_SET_POOLS 9
#define XEN_SYSCTL_TMEM_OP_SAVE_BEGIN 10
#define XEN_SYSCTL_TMEM_OP_SET_AUTH 11
#define XEN_SYSCTL_TMEM_OP_SAVE_GET_NEXT_PAGE 19
#define XEN_SYSCTL_TMEM_OP_SAVE_GET_NEXT_INV 20
#define XEN_SYSCTL_TMEM_OP_SAVE_END 21
#define XEN_SYSCTL_TMEM_OP_RESTORE_BEGIN 30
#define XEN_SYSCTL_TMEM_OP_RESTORE_PUT_PAGE 32
#define XEN_SYSCTL_TMEM_OP_RESTORE_FLUSH_PAGE 33
/*
* XEN_SYSCTL_TMEM_OP_SAVE_GET_NEXT_[PAGE|INV] override the 'buf' in
* xen_sysctl_tmem_op with this structure - sometimes with an extra
* page tackled on.
*/
struct tmem_handle {
uint32_t pool_id;
uint32_t index;
xen_tmem_oid_t oid;
};
/*
* XEN_SYSCTL_TMEM_OP_[GET,SAVE]_CLIENT uses the 'client' in
* xen_tmem_op with this structure, which is mostly used during migration.
*/
struct xen_tmem_client {
uint32_t version; /* If mismatched we will get XEN_EOPNOTSUPP. */
uint32_t maxpools; /* If greater than what hypervisor supports, will get
XEN_ERANGE. */
uint32_t nr_pools; /* Current amount of pools. Ignored on SET*/
union { /* See TMEM_CLIENT_[COMPRESS,FROZEN] */
uint32_t raw;
struct {
uint8_t frozen:1,
compress:1,
migrating:1;
} u;
} flags;
uint32_t weight;
};
typedef struct xen_tmem_client xen_tmem_client_t;
DEFINE_XEN_GUEST_HANDLE(xen_tmem_client_t);
/*
* XEN_SYSCTL_TMEM_OP_[GET|SET]_POOLS or XEN_SYSCTL_TMEM_OP_SET_AUTH
* uses the 'pool' array in * xen_sysctl_tmem_op with this structure.
* The XEN_SYSCTL_TMEM_OP_GET_POOLS hypercall will
* return the number of entries in 'pool' or a negative value
* if an error was encountered.
* The XEN_SYSCTL_TMEM_OP_SET_[AUTH|POOLS] will return the number of
* entries in 'pool' processed or a negative value if an error
* was encountered.
*/
struct xen_tmem_pool_info {
union {
uint32_t raw;
struct {
uint32_t persist:1, /* See TMEM_POOL_PERSIST. */
shared:1, /* See TMEM_POOL_SHARED. */
auth:1, /* See TMEM_POOL_AUTH. */
rsv1:1,
pagebits:8, /* TMEM_POOL_PAGESIZE_[SHIFT,MASK]. */
rsv2:12,
version:8; /* TMEM_POOL_VERSION_[SHIFT,MASK]. */
} u;
} flags;
uint32_t id; /* Less than tmem_client.maxpools. */
uint64_t n_pages; /* Zero on XEN_SYSCTL_TMEM_OP_SET_[AUTH|POOLS]. */
uint64_aligned_t uuid[2];
};
typedef struct xen_tmem_pool_info xen_tmem_pool_info_t;
DEFINE_XEN_GUEST_HANDLE(xen_tmem_pool_info_t);
struct xen_sysctl_tmem_op {
uint32_t cmd; /* IN: XEN_SYSCTL_TMEM_OP_* . */
int32_t pool_id; /* IN: 0 by default unless _SAVE_*, RESTORE_* .*/
uint32_t cli_id; /* IN: client id, 0 for XEN_SYSCTL_TMEM_QUERY_FREEABLE_MB
for all others can be the domain id or
XEN_SYSCTL_TMEM_OP_ALL_CLIENTS for all. */
uint32_t len; /* IN: length of 'buf'. If not applicable to use 0. */
uint32_t arg; /* IN: If not applicable to command use 0. */
uint32_t pad; /* Padding so structure is the same under 32 and 64. */
xen_tmem_oid_t oid; /* IN: If not applicable to command use 0s. */
union {
XEN_GUEST_HANDLE_64(char) buf; /* IN/OUT: Buffer to save/restore */
XEN_GUEST_HANDLE_64(xen_tmem_client_t) client; /* IN/OUT for */
/* XEN_SYSCTL_TMEM_OP_[GET,SAVE]_CLIENT. */
XEN_GUEST_HANDLE_64(xen_tmem_pool_info_t) pool; /* OUT for */
/* XEN_SYSCTL_TMEM_OP_GET_POOLS. Must have 'len' */
/* of them. */
} u;
};
/*
* XEN_SYSCTL_get_cpu_levelling_caps (x86 specific)
*
@@ -1143,7 +1038,7 @@ struct xen_sysctl {
#define XEN_SYSCTL_psr_cmt_op 21
#define XEN_SYSCTL_pcitopoinfo 22
#define XEN_SYSCTL_psr_alloc 23
#define XEN_SYSCTL_tmem_op 24
/* #define XEN_SYSCTL_tmem_op 24 */
#define XEN_SYSCTL_get_cpu_levelling_caps 25
#define XEN_SYSCTL_get_cpu_featureset 26
#define XEN_SYSCTL_livepatch_op 27
@@ -1173,7 +1068,6 @@ struct xen_sysctl {
struct xen_sysctl_coverage_op coverage_op;
struct xen_sysctl_psr_cmt_op psr_cmt_op;
struct xen_sysctl_psr_alloc psr_alloc;
struct xen_sysctl_tmem_op tmem_op;
struct xen_sysctl_cpu_levelling_caps cpu_levelling_caps;
struct xen_sysctl_cpu_featureset cpu_featureset;
struct xen_sysctl_livepatch_op livepatch;
xen/include/public/tmem.h
+4 -6
View File
@@ -29,15 +29,11 @@
#include "xen.h"
#if __XEN_INTERFACE_VERSION__ < 0x00041300
/* version of ABI */
#define TMEM_SPEC_VERSION 1
/* Commands to HYPERVISOR_tmem_op() */
#ifdef __XEN__
#define TMEM_CONTROL 0 /* Now called XEN_SYSCTL_tmem_op */
#else
#undef TMEM_CONTROL
#endif
#define TMEM_NEW_POOL 1
#define TMEM_DESTROY_POOL 2
#define TMEM_PUT_PAGE 4
@@ -111,6 +107,8 @@ typedef struct tmem_op tmem_op_t;
DEFINE_XEN_GUEST_HANDLE(tmem_op_t);
#endif
#endif /* __XEN_INTERFACE_VERSION__ < 0x00041200 */
#endif /* __XEN_PUBLIC_TMEM_H__ */
/*
xen/include/xen/hypercall.h
-7
View File
@@ -12,7 +12,6 @@
#include <public/sysctl.h>
#include <public/platform.h>
#include <public/event_channel.h>
#include <public/tmem.h>
#include <public/version.h>
#include <public/pmu.h>
#include <public/hvm/dm_op.h>
@@ -130,12 +129,6 @@ extern long
do_xsm_op(
XEN_GUEST_HANDLE_PARAM(xsm_op_t) u_xsm_op);
#ifdef CONFIG_TMEM
extern long
do_tmem_op(
XEN_GUEST_HANDLE_PARAM(tmem_op_t) uops);
#endif
#ifdef CONFIG_ARGO
extern long do_argo_op(
unsigned int cmd,
xen/include/xen/mm.h
-3
View File
@@ -209,7 +209,6 @@ unsigned long avail_node_heap_pages(unsigned int);
unsigned int online_page(unsigned long mfn, uint32_t *status);
int offline_page(unsigned long mfn, int broken, uint32_t *status);
int query_page_offline(unsigned long mfn, uint32_t *status);
unsigned long total_free_pages(void);
void heap_init_late(void);
@@ -249,8 +248,6 @@ struct npfec {
#define MEMF_no_refcount (1U<<_MEMF_no_refcount)
#define _MEMF_populate_on_demand 1
#define MEMF_populate_on_demand (1U<<_MEMF_populate_on_demand)
#define _MEMF_tmem 2
#define MEMF_tmem (1U<<_MEMF_tmem)
#define _MEMF_no_dma 3
#define MEMF_no_dma (1U<<_MEMF_no_dma)
#define _MEMF_exact_node 4
xen/include/xen/sched.h
-3
View File
@@ -454,9 +454,6 @@ struct domain
*/
spinlock_t hypercall_deadlock_mutex;
/* transcendent memory, auto-allocated on first tmem op by each domain */
struct client *tmem_client;
struct lock_profile_qhead profile_head;
/* Various vm_events */
xen/include/xen/tmem.h
-45
View File
@@ -1,45 +0,0 @@
/******************************************************************************
* tmem.h
*
* Transcendent memory
*
* Copyright (c) 2008, Dan Magenheimer, Oracle Corp.
*/
#ifndef __XEN_TMEM_H__
#define __XEN_TMEM_H__
struct xen_sysctl_tmem_op;
#ifdef CONFIG_TMEM
extern int tmem_control(struct xen_sysctl_tmem_op *op);
extern void tmem_destroy(void *);
extern void *tmem_relinquish_pages(unsigned int, unsigned int);
extern unsigned long tmem_freeable_pages(void);
#else
static inline int
tmem_control(struct xen_sysctl_tmem_op *op)
{
return -ENOSYS;
}
static inline void
tmem_destroy(void *p)
{
return;
}
static inline void *
tmem_relinquish_pages(unsigned int x, unsigned int y)
{
return NULL;
}
static inline unsigned long
tmem_freeable_pages(void)
{
return 0;
}
#endif /* CONFIG_TMEM */
#endif /* __XEN_TMEM_H__ */
xen/include/xen/tmem_control.h
-39
View File
@@ -1,39 +0,0 @@
/*
* Copyright (c) 2016 Oracle and/or its affiliates. All rights reserved.
*
*/
#ifndef __XEN_TMEM_CONTROL_H__
#define __XEN_TMEM_CONTROL_H__
#ifdef CONFIG_TMEM
#include <public/sysctl.h>
/* Variables and functions that tmem_control.c needs from tmem.c */
extern struct tmem_statistics tmem_stats;
extern struct tmem_global tmem_global;
extern rwlock_t tmem_rwlock;
int tmem_evict(void);
int do_tmem_control(struct xen_sysctl_tmem_op *op);
struct client *client_create(domid_t cli_id);
int do_tmem_new_pool(domid_t this_cli_id, uint32_t d_poolid, uint32_t flags,
uint64_t uuid_lo, uint64_t uuid_hi);
int tmemc_shared_pool_auth(domid_t cli_id, uint64_t uuid_lo,
uint64_t uuid_hi, bool auth);
#endif /* CONFIG_TMEM */
#endif /* __XEN_TMEM_CONTROL_H__ */
/*
* Local variables:
* mode: C
* c-file-style: "BSD"
* c-basic-offset: 4
* tab-width: 4
* indent-tabs-mode: nil
* End:
*/
xen/include/xen/tmem_xen.h
-343
View File
@@ -1,343 +0,0 @@
/******************************************************************************
* tmem_xen.h
*
* Xen-specific Transcendent memory
*
* Copyright (c) 2009, Dan Magenheimer, Oracle Corp.
*/
#ifndef __XEN_TMEM_XEN_H__
#define __XEN_TMEM_XEN_H__
#include <xen/mm.h> /* heap alloc/free */
#include <xen/pfn.h>
#include <xen/xmalloc.h> /* xmalloc/xfree */
#include <xen/sched.h> /* struct domain */
#include <xen/guest_access.h> /* copy_from_guest */
#include <xen/hash.h> /* hash_long */
#include <xen/domain_page.h> /* __map_domain_page */
#include <xen/rbtree.h> /* struct rb_root */
#include <xsm/xsm.h> /* xsm_tmem_control */
#include <public/tmem.h>
#ifdef CONFIG_COMPAT
#include <compat/tmem.h>
#endif
typedef uint32_t pagesize_t; /* like size_t, must handle largest PAGE_SIZE */
#define IS_PAGE_ALIGNED(addr) IS_ALIGNED((unsigned long)(addr), PAGE_SIZE)
#define IS_VALID_PAGE(_pi) mfn_valid(page_to_mfn(_pi))
extern struct page_list_head tmem_page_list;
extern spinlock_t tmem_page_list_lock;
extern unsigned long tmem_page_list_pages;
extern atomic_t freeable_page_count;
extern int tmem_init(void);
#define tmem_hash hash_long
extern bool opt_tmem_compress;
static inline bool tmem_compression_enabled(void)
{
return opt_tmem_compress;
}
#ifdef CONFIG_TMEM
extern bool opt_tmem;
static inline bool tmem_enabled(void)
{
return opt_tmem;
}
static inline void tmem_disable(void)
{
opt_tmem = false;
}
#else
static inline bool tmem_enabled(void)
{
return false;
}
static inline void tmem_disable(void)
{
}
#endif /* CONFIG_TMEM */
/*
* Memory free page list management
*/
static inline struct page_info *tmem_page_list_get(void)
{
struct page_info *pi;
spin_lock(&tmem_page_list_lock);
if ( (pi = page_list_remove_head(&tmem_page_list)) != NULL )
tmem_page_list_pages--;
spin_unlock(&tmem_page_list_lock);
ASSERT((pi == NULL) || IS_VALID_PAGE(pi));
return pi;
}
static inline void tmem_page_list_put(struct page_info *pi)
{
ASSERT(IS_VALID_PAGE(pi));
spin_lock(&tmem_page_list_lock);
page_list_add(pi, &tmem_page_list);
tmem_page_list_pages++;
spin_unlock(&tmem_page_list_lock);
}
/*
* Memory allocation for persistent data
*/
static inline struct page_info *__tmem_alloc_page_thispool(struct domain *d)
{
struct page_info *pi;
/* note that this tot_pages check is not protected by d->page_alloc_lock,
* so may race and periodically fail in donate_page or alloc_domheap_pages
* That's OK... neither is a problem, though chatty if log_lvl is set */
if ( d->tot_pages >= d->max_pages )
return NULL;
if ( tmem_page_list_pages )
{
if ( (pi = tmem_page_list_get()) != NULL )
{
if ( donate_page(d,pi,0) == 0 )
goto out;
else
tmem_page_list_put(pi);
}
}
pi = alloc_domheap_pages(d,0,MEMF_tmem);
out:
ASSERT((pi == NULL) || IS_VALID_PAGE(pi));
return pi;
}
static inline void __tmem_free_page_thispool(struct page_info *pi)
{
struct domain *d = page_get_owner(pi);
ASSERT(IS_VALID_PAGE(pi));
if ( (d == NULL) || steal_page(d,pi,0) == 0 )
tmem_page_list_put(pi);
else
{
scrub_one_page(pi);
ASSERT((pi->count_info & ~(PGC_allocated | 1)) == 0);
free_domheap_pages(pi,0);
}
}
/*
* Memory allocation for ephemeral (non-persistent) data
*/
static inline struct page_info *__tmem_alloc_page(void)
{
struct page_info *pi = tmem_page_list_get();
if ( pi == NULL)
pi = alloc_domheap_pages(0,0,MEMF_tmem);
if ( pi )
atomic_inc(&freeable_page_count);
ASSERT((pi == NULL) || IS_VALID_PAGE(pi));
return pi;
}
static inline void __tmem_free_page(struct page_info *pi)
{
ASSERT(IS_VALID_PAGE(pi));
tmem_page_list_put(pi);
atomic_dec(&freeable_page_count);
}
/* "Client" (==domain) abstraction */
static inline struct client *tmem_client_from_cli_id(domid_t cli_id)
{
struct client *c;
struct domain *d = rcu_lock_domain_by_id(cli_id);
if (d == NULL)
return NULL;
c = d->tmem_client;
rcu_unlock_domain(d);
return c;
}
/* these typedefs are in the public/tmem.h interface
typedef XEN_GUEST_HANDLE(void) cli_mfn_t;
typedef XEN_GUEST_HANDLE(char) cli_va_t;
*/
typedef XEN_GUEST_HANDLE_PARAM(tmem_op_t) tmem_cli_op_t;
typedef XEN_GUEST_HANDLE_PARAM(char) tmem_cli_va_param_t;
static inline int tmem_get_tmemop_from_client(tmem_op_t *op, tmem_cli_op_t uops)
{
#ifdef CONFIG_COMPAT
if ( is_hvm_vcpu(current) ? hvm_guest_x86_mode(current) != 8
: is_pv_32bit_vcpu(current) )
{
int rc;
enum XLAT_tmem_op_u u;
tmem_op_compat_t cop;
rc = copy_from_guest(&cop, guest_handle_cast(uops, void), 1);
if ( rc )
return rc;
switch ( cop.cmd )
{
case TMEM_NEW_POOL: u = XLAT_tmem_op_u_creat; break;
default: u = XLAT_tmem_op_u_gen ; break;
}
XLAT_tmem_op(op, &cop);
return 0;
}
#endif
return copy_from_guest(op, uops, 1);
}
#define tmem_cli_buf_null guest_handle_from_ptr(NULL, char)
#define TMEM_CLI_ID_NULL ((domid_t)((domid_t)-1L))
#define tmem_cli_id_str "domid"
#define tmem_client_str "domain"
int tmem_decompress_to_client(xen_pfn_t, void *, size_t,
tmem_cli_va_param_t);
int tmem_compress_from_client(xen_pfn_t, void **, size_t *,
tmem_cli_va_param_t);
int tmem_copy_from_client(struct page_info *, xen_pfn_t, tmem_cli_va_param_t);
int tmem_copy_to_client(xen_pfn_t, struct page_info *, tmem_cli_va_param_t);
#define tmem_client_err(fmt, args...) printk(XENLOG_G_ERR fmt, ##args)
#define tmem_client_warn(fmt, args...) printk(XENLOG_G_WARNING fmt, ##args)
#define tmem_client_info(fmt, args...) printk(XENLOG_G_INFO fmt, ##args)
/* Global statistics (none need to be locked). */
struct tmem_statistics {
unsigned long total_tmem_ops;
unsigned long errored_tmem_ops;
unsigned long total_flush_pool;
unsigned long alloc_failed;
unsigned long alloc_page_failed;
unsigned long evicted_pgs;
unsigned long evict_attempts;
unsigned long relinq_pgs;
unsigned long relinq_attempts;
unsigned long max_evicts_per_relinq;
unsigned long low_on_memory;
unsigned long deduped_puts;
unsigned long tot_good_eph_puts;
int global_obj_count_max;
int global_pgp_count_max;
int global_pcd_count_max;
int global_page_count_max;
int global_rtree_node_count_max;
long global_eph_count_max;
unsigned long failed_copies;
unsigned long pcd_tot_tze_size;
unsigned long pcd_tot_csize;
/* Global counters (should use long_atomic_t access). */
atomic_t global_obj_count;
atomic_t global_pgp_count;
atomic_t global_pcd_count;
atomic_t global_page_count;
atomic_t global_rtree_node_count;
};
#define atomic_inc_and_max(_c) do { \
atomic_inc(&tmem_stats._c); \
if ( _atomic_read(tmem_stats._c) > tmem_stats._c##_max ) \
tmem_stats._c##_max = _atomic_read(tmem_stats._c); \
} while (0)
#define atomic_dec_and_assert(_c) do { \
atomic_dec(&tmem_stats._c); \
ASSERT(_atomic_read(tmem_stats._c) >= 0); \
} while (0)
#define MAX_GLOBAL_SHARED_POOLS 16
struct tmem_global {
struct list_head ephemeral_page_list; /* All pages in ephemeral pools. */
struct list_head client_list;
struct tmem_pool *shared_pools[MAX_GLOBAL_SHARED_POOLS];
bool shared_auth;
long eph_count; /* Atomicity depends on eph_lists_spinlock. */
atomic_t client_weight_total;
};
#define MAX_POOLS_PER_DOMAIN 16
struct tmem_pool;
struct tmem_page_descriptor;
struct tmem_page_content_descriptor;
struct client {
struct list_head client_list;
struct tmem_pool *pools[MAX_POOLS_PER_DOMAIN];
struct domain *domain;
struct xmem_pool *persistent_pool;
struct list_head ephemeral_page_list;
long eph_count, eph_count_max;
domid_t cli_id;
xen_tmem_client_t info;
/* For save/restore/migration. */
bool was_frozen;
struct list_head persistent_invalidated_list;
struct tmem_page_descriptor *cur_pgp;
/* Statistics collection. */
unsigned long compress_poor, compress_nomem;
unsigned long compressed_pages;
uint64_t compressed_sum_size;
uint64_t total_cycles;
unsigned long succ_pers_puts, succ_eph_gets, succ_pers_gets;
/* Shared pool authentication. */
uint64_t shared_auth_uuid[MAX_GLOBAL_SHARED_POOLS][2];
};
#define POOL_PAGESHIFT (PAGE_SHIFT - 12)
#define OBJ_HASH_BUCKETS 256 /* Must be power of two. */
#define OBJ_HASH_BUCKETS_MASK (OBJ_HASH_BUCKETS-1)
#define is_persistent(_p) (_p->persistent)
#define is_shared(_p) (_p->shared)
struct tmem_pool {
bool shared;
bool persistent;
bool is_dying;
struct client *client;
uint64_t uuid[2]; /* 0 for private, non-zero for shared. */
uint32_t pool_id;
rwlock_t pool_rwlock;
struct rb_root obj_rb_root[OBJ_HASH_BUCKETS]; /* Protected by pool_rwlock. */
struct list_head share_list; /* Valid if shared. */
int shared_count; /* Valid if shared. */
/* For save/restore/migration. */
struct list_head persistent_page_list;
struct tmem_page_descriptor *cur_pgp;
/* Statistics collection. */
atomic_t pgp_count;
int pgp_count_max;
long obj_count; /* Atomicity depends on pool_rwlock held for write. */
long obj_count_max;
unsigned long objnode_count, objnode_count_max;
uint64_t sum_life_cycles;
uint64_t sum_evicted_cycles;
unsigned long puts, good_puts, no_mem_puts;
unsigned long dup_puts_flushed, dup_puts_replaced;
unsigned long gets, found_gets;
unsigned long flushs, flushs_found;
unsigned long flush_objs, flush_objs_found;
};
struct share_list {
struct list_head share_list;
struct client *client;
};
#endif /* __XEN_TMEM_XEN_H__ */
xen/include/xlat.lst
-2
View File
@@ -135,8 +135,6 @@
? sched_pin_override sched.h
? sched_remote_shutdown sched.h
? sched_shutdown sched.h
? tmem_oid tmem.h
! tmem_op tmem.h
? t_buf trace.h
? vcpu_get_physid vcpu.h
? vcpu_register_vcpu_info vcpu.h
xen/include/xsm/dummy.h
-6
View File
@@ -433,12 +433,6 @@ static XSM_INLINE int xsm_page_offline(XSM_DEFAULT_ARG uint32_t cmd)
return xsm_default_action(action, current->domain, NULL);
}
static XSM_INLINE int xsm_tmem_op(XSM_DEFAULT_VOID)
{
XSM_ASSERT_ACTION(XSM_HOOK);
return xsm_default_action(action, current->domain, NULL);
}
static XSM_INLINE long xsm_do_xsm_op(XEN_GUEST_HANDLE_PARAM(xsm_op_t) op)
{
return -ENOSYS;
xen/include/xsm/xsm.h
-6
View File
@@ -127,7 +127,6 @@ struct xsm_operations {
int (*resource_setup_misc) (void);
int (*page_offline)(uint32_t cmd);
int (*tmem_op)(void);
long (*do_xsm_op) (XEN_GUEST_HANDLE_PARAM(xsm_op_t) op);
#ifdef CONFIG_COMPAT
@@ -537,11 +536,6 @@ static inline int xsm_page_offline(xsm_default_t def, uint32_t cmd)
return xsm_ops->page_offline(cmd);
}
static inline int xsm_tmem_op(xsm_default_t def)
{
return xsm_ops->tmem_op();
}
static inline long xsm_do_xsm_op (XEN_GUEST_HANDLE_PARAM(xsm_op_t) op)
{
return xsm_ops->do_xsm_op(op);
xen/xsm/dummy.c
-1
View File
@@ -103,7 +103,6 @@ void __init xsm_fixup_ops (struct xsm_operations *ops)
set_to_dummy_if_null(ops, resource_setup_misc);
set_to_dummy_if_null(ops, page_offline);
set_to_dummy_if_null(ops, tmem_op);
set_to_dummy_if_null(ops, hvm_param);
set_to_dummy_if_null(ops, hvm_control);
set_to_dummy_if_null(ops, hvm_param_nested);
xen/xsm/flask/hooks.c
-9
View File
@@ -810,9 +810,6 @@ static int flask_sysctl(int cmd)
return avc_current_has_perm(SECINITSID_XEN, SECCLASS_XEN2,
XEN2__PSR_ALLOC, NULL);
case XEN_SYSCTL_tmem_op:
return domain_has_xen(current->domain, XEN__TMEM_CONTROL);
case XEN_SYSCTL_get_cpu_levelling_caps:
return avc_current_has_perm(SECINITSID_XEN, SECCLASS_XEN2,
XEN2__GET_CPU_LEVELLING_CAPS, NULL);
@@ -1178,11 +1175,6 @@ static inline int flask_page_offline(uint32_t cmd)
}
}
static inline int flask_tmem_op(void)
{
return domain_has_xen(current->domain, XEN__TMEM_OP);
}
static int flask_add_to_physmap(struct domain *d1, struct domain *d2)
{
return domain_has_perm(d1, d2, SECCLASS_MMU, MMU__PHYSMAP);
@@ -1818,7 +1810,6 @@ static struct xsm_operations flask_ops = {
.resource_setup_misc = flask_resource_setup_misc,
.page_offline = flask_page_offline,
.tmem_op = flask_tmem_op,
.hvm_param = flask_hvm_param,
.hvm_control = flask_hvm_param,
.hvm_param_nested = flask_hvm_param_nested,
xen/xsm/flask/policy/access_vectors
-4
View File
@@ -67,10 +67,6 @@ class xen
lockprof
# XEN_SYSCTL_cpupool_op
cpupool_op
# tmem hypercall (any access)
tmem_op
# XEN_SYSCTL_tmem_op command of tmem (part of sysctl)
tmem_control
# XEN_SYSCTL_scheduler_op with XEN_DOMCTL_SCHEDOP_getinfo, XEN_SYSCTL_sched_id, XEN_DOMCTL_SCHEDOP_getvcpuinfo
getscheduler
# XEN_SYSCTL_scheduler_op with XEN_DOMCTL_SCHEDOP_putinfo, XEN_DOMCTL_SCHEDOP_putvcpuinfo
Reference in new issue
xen-project/xen
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.

The note is not visible to the blocked user.