balloon.c revision 843e19887f64dde75055cf8842fc4db2171eff45
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2007 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <sys/balloon_impl.h>
#include <sys/hypervisor.h>
#include <vm/seg_kmem.h>
#include <sys/sysmacros.h>
#include <sys/machsystm.h>
/*
* This file implements a balloon thread, which controls a domain's memory
* reservation, or the amount of memory a domain is currently allocated.
* The hypervisor provides the current memory reservation through xenbus,
* so we register a watch on this. We will then be signalled when the
* reservation changes. If it goes up, we map the new mfn's to our pfn's
* (allocating page_t's if necessary), and release them into the system.
* If the reservation goes down, we grab pages and release them back to
* the hypervisor, saving the page_t's for later use.
*/
/*
* Various structures needed by the balloon thread
*/
static bln_stats_t bln_stats;
static kthread_t *bln_thread;
static kcondvar_t bln_cv;
static struct xenbus_watch bln_watch;
static mfn_t new_high_mfn;
/*
* For holding spare page_t structures - keep a singly-linked list.
* The list may hold both valid (pagenum < mfn_count) and invalid
* (pagenum >= mfn_count) page_t's. Valid page_t's should be inserted
* at the front, and invalid page_t's at the back. Removal should
* always be from the front. This is a singly-linked list using
* p_next, so p_prev is always NULL.
*/
int balloon_zero_memory = 1;
static caddr_t balloon_kva;
static kmutex_t balloon_kva_mutex;
/*
* reassign_pfn() calls update_contig_pfnlist(), which can cause a large
* slowdown when calling multiple times. If we're reassigning less than the
* quota defined here, we just accept the slowdown. If the count is greater
* than the quota, we tell the contig alloc code to stop its accounting until
* we're done. Setting the quota to less than 2 is not supported.
*
* Note that we define our own wrapper around the external
* clear_and_lock_contig_pfnlist(), but we just use the version of
* unlock_contig_pfnlist() in vm_machdep.c.
*/
extern void clear_and_lock_contig_pfnlist(void);
extern void unlock_contig_pfnlist(void);
/*
* Lock the pfnlist if necessary (see above), and return whether we locked it.
*/
static int
balloon_lock_contig_pfnlist(int count) {
if (count > bln_contig_list_quota) {
return (1);
} else {
return (0);
}
}
/*
* The page represented by pp is being given back to the hypervisor.
* Add the page_t structure to our spare list.
*/
static void
{
/*
* We need to keep the page exclusively locked
* to prevent swrand from grabbing it.
*/
if (bln_spare_list_front == NULL) {
/*
* The pfn is invalid, so add at the end of list. Since these
* adds should *only* be done by balloon_init_new_pages(), and
* that does adds in order, the following ASSERT should
* never trigger.
*/
} else {
/* Add at beginning of list */
}
}
/*
* Return a page_t structure from our spare list, or NULL if none are available.
*/
static page_t *
balloon_page_sub(void)
{
if (bln_spare_list_front == NULL) {
return (NULL);
}
return (NULL);
}
if (bln_spare_list_front == NULL)
return (pp);
}
/*
* NOTE: We currently do not support growing beyond the boot memory size,
* so the following function will not be called. It is left in here with
* the hope that someday this restriction can be lifted, and this code can
* be used.
*/
/*
* This structure is placed at the start of every block of new pages
*/
typedef struct {
/*
* To make the math below slightly less confusing, we calculate the first
* two parts here. page_t's are handled separately, so they are not included.
*/
/*
* We want to add memory, but have no spare page_t structures. Use some of
* our new memory for the page_t structures.
*
* Somewhat similar to kphysm_add_memory_dynamic(), but simpler.
*/
static int
{
/* Calculate the number of pages we're going to add */
/*
* The following calculates the number of "meta" pages -- the pages
* that will be required to hold page_t structures for all new pages.
* Proof of this calculation is left up to the reader.
*/
/*
* Given the number of page_t structures we need, is there also
* room in our meta pages for a memseg and memlist struct?
* If not, we'll need one more meta page.
*/
metapgs++;
/*
* metapgs is calculated from totalpgs, which may be much larger than
* count. If we don't have enough pages, all of the pages in this
* batch will be made meta pages, and a future trip through
* balloon_inc_reservation() will add the rest of the meta pages.
*/
/*
* Figure out the number of page_t structures that can fit in metapgs
*
* This will cause us to initialize more page_t structures than we
* need - these may be used in future memory increases.
*/
/*
* We only increment mfn_count by count, not num_pages, to keep the
* space of all valid pfns contiguous. This means we create page_t
* structures with invalid pagenums -- we deal with this situation
* in balloon_page_sub.
*/
/*
* Get a VA for the pages that will hold page_t and other structures.
* The memseg and memlist structures will go at the beginning, with
* the page_t structures following.
*/
/* LINTED: improper alignment */
/*
* Set the mfn to pfn mapping for the meta pages.
*/
for (i = 0; i < metapgs; i++) {
}
if (locked)
/*
* For our meta pages, map them in and zero the page.
* This will be the first time touching the new pages.
*/
/*
* Initialize the page array for the new pages.
*/
for (i = 0; i < metapgs; i++) {
page_iolock_init(&page_array[i]);
}
/*
* For the rest of the pages, initialize the page_t struct and
* add them to the free list
*/
page_iolock_init(&page_array[i]);
balloon_page_add(&page_array[i]);
}
/*
* Remember where I said that we don't call this function? The missing
* code right here is why. We need to set up kpm mappings for any new
* pages coming in. However, if someone starts up a domain with small
* memory, then greatly increases it, we could get in some horrible
* deadlock situations as we steal page tables for kpm use, and
* userland applications take them right back before we can use them
* to set up our new memory. Once a way around that is found, and a
* few other changes are made, we'll be able to enable this code.
*/
/*
* Update kernel structures, part 1: memsegs list
*/
memsegs_lock(1);
;
memsegs_unlock(1);
/*
* Update kernel structures, part 2: mem_node array
*/
/*
* Update kernel structures, part 3: phys_install array
* (*sigh* how many of these things do we need?)
*/
&phys_install);
return (metapgs);
}
/* How many ulong_t's can we fit on a page? */
/*
* These are too large to declare on the stack, so we make them static instead
*/
/*
* This function is called when our reservation is increasing. Make a
* hypervisor call to get our new pages, then integrate them into the system.
*/
static spgcnt_t
{
int meta_pg_start, meta_pg_end;
long rv;
rv = 0;
meta_pg_start = meta_pg_end = 0;
if (credit > FRAME_ARRAY_SIZE)
if (rv < 0) {
return (0);
}
for (i = 0; i < rv; i++) {
if (mfn_frames[i] > new_high_mfn)
new_high_mfn = mfn_frames[i];
pp = balloon_page_sub();
/*
* We pass the index into the current mfn array,
* then move the counter past the mfns we used
*/
meta_pg_start = i;
i += cnt;
meta_pg_end = i;
if (i < rv) {
pp = balloon_page_sub();
} else {
}
}
break;
}
if (new_list_back == NULL) {
} else {
new_list_back = pp;
}
}
cnt = i;
}
}
if (locked)
while (new_list_front != NULL) {
pp = new_list_front;
}
/*
* We couldn't get page structures.
*
* This shouldn't happen, but causes no real harm if it does.
* On debug kernels, we'll flag it. On all kernels, we'll
* give back the pages we couldn't assign.
*/
#ifdef DEBUG
#endif /* DEBUG */
rv = i;
}
return (rv);
}
/*
* This function is called when we want to decrease the memory reservation
* of our domain. Allocate the memory and make a hypervisor call to give
* it back.
*/
static spgcnt_t
{
int i, locked;
long rv;
if (debit > FRAME_ARRAY_SIZE) {
}
/*
* Don't bother if there isn't a safe amount of kmem left.
*/
if (kmem_avail() < balloon_minkmem) {
kmem_reap();
if (kmem_avail() < balloon_minkmem)
return (0);
}
return (0);
}
for (i = 0; i < debit; i++) {
new_high_mfn = 0;
/*
* Call kmem_reap(), then try once more,
* but only if there is a safe amount of
* kmem left.
*/
kmem_reap();
if (kmem_avail() < balloon_minkmem ||
debit = i;
break;
}
}
}
if (debit == 0) {
return (0);
}
/*
* Remove all mappings for the pfns from the system
*/
for (i = 0; i < debit; i++) {
}
if (locked)
if (rv < 0) {
rv = 0;
panic("Unexpected return value (%ld) from decrease reservation "
"hypervisor call", rv);
}
return (rv);
}
/*
* node is changed. When it is fired, we will read a new reservation
* target for our domain and signal the worker thread to make the change.
*
* If the reservation is larger than we can handle, we issue a warning. dom0
* does this automatically every boot, so we skip the first warning on dom0.
*/
/*ARGSUSED*/
static void
{
int rv;
static uchar_t warning_cnt = 0;
if (rv != 0) {
return;
}
/* new_target is in kB - change this to pages */
/*
* Unfortunately, dom0 may give us a target that is larger than
* our max limit. Re-check the limit, and, if the new target is
* too large, adjust it downwards.
*/
"larger than original memory size (0x%lx pages). "
"Ballooning beyond original memory size is not "
"allowed.",
}
warning_cnt = 1;
} else {
}
}
/*
* bln_wait_sec can be used to throttle the hv calls, but by default it's
* turned off. If a balloon attempt fails, the wait time is forced on, and
* then is exponentially increased as further attempts fail.
*/
uint_t bln_wait_sec = 0;
/*
* This is the main balloon thread. Wait on the cv. When woken, if our
* reservation has changed, call the appropriate function to adjust the
* reservation.
*/
static void
balloon_worker_thread(void)
{
for (;;) {
rv = 0;
/*
* We weren't able to fully complete the request
* last time through, so try again.
*/
} else {
}
if (bln_stats.bln_new_target <
/* reservation shrunk */
} else if (bln_stats.bln_new_target >
/* reservation grew */
}
}
if (rv == 0) {
if (bln_wait == 0) {
bln_wait = 1;
} else {
bln_wait <<= bln_wait_shift;
}
} else {
}
}
}
/*
* Called after balloon_init(), which is below. The xenbus thread is up
* and running, so we can register our watch and create the balloon thread.
*/
static void
{
if (state != XENSTORE_UP)
return;
if (register_xenbus_watch(&bln_watch)) {
"thread will be disabled");
return;
}
if (bln_thread == NULL)
}
/*
* Basic initialization of the balloon thread. Set all of our variables,
* and register a callback for later when we can register a xenbus watch.
*/
void
{
/* init balloon zero logic */
}
/*
* These functions are called from the network drivers when they gain a page
* or give one away. We simply update our count. Note that the counter
* tracks the number of pages we give away, so we need to subtract any
* amount passed to balloon_drv_added.
*/
void
{
}
void
{
}
/*
* balloon_alloc_pages()
* Allocate page_cnt mfns. mfns storage provided by the caller. Returns
* the number of pages allocated, which could be less than page_cnt, or
* a negative number if an error occurred.
*/
long
{
long rv;
/*LINTED: constant in conditional context*/
if (rv > 0)
return (rv);
}
/*
* balloon_free_pages()
* free page_cnt pages, using any combination of mfns, pfns, and kva as long
* as they refer to the same mapping. We need to zero the pages before
* giving them back to the hypervisor. kva space is not free'd up in case
* the caller wants to re-use it.
*/
long
{
uint_t i;
long e;
#if DEBUG
/* make sure kva is page aligned and maps to first pfn */
}
}
#endif
/* if we have a kva, we can clean all pages with just one bzero */
}
/*
* All the current callers only pass 1 page when using kva or
* pfns, and use mfns when passing multiple pages. If that
* assumption is changed, the following code will need some
* work. The following ASSERT() guarantees we're respecting
* the io locking quota.
*/
/* go through all the pages */
for (i = 0; i < page_cnt; i++) {
/* get the next pfn */
} else {
}
/*
* if we didn't already zero this page, do it now. we
* need to do this *before* we give back the MFN
*/
}
/*
* unmap the pfn. We don't free up the kva vmem space
* so the caller can re-use it. The page must be
* unmapped before it is given back to the hypervisor.
*/
}
/* grab the mfn before the pfn is marked as invalid */
/* mark the pfn as invalid */
/*
* if we weren't given an array of MFNs, we need to
* free them up one at a time. Otherwise, we'll wait
* until later and do it in one hypercall
*/
/*LINTED: constant in conditional context*/
e = HYPERVISOR_memory_op(
if (e != 1) {
"give a page back to the "
"hypervisor.\n");
}
}
}
/*
* if all we were given was an array of MFN's, we only need to zero out
* each page. The MFNs will be free'd up below.
*/
} else if (balloon_zero_memory) {
for (i = 0; i < page_cnt; i++) {
}
}
/*
* if we were passed in MFNs, we haven't free'd them up yet. We can
* do it with one call.
*/
/*LINTED: constant in conditional context*/
if (e != page_cnt) {
"to the hypervisor.\n");
}
}
return (page_cnt);
}
/*
* balloon_replace_pages()
* Try to replace nextexts blocks of 2^order pages. addr_bits specifies
* how many bits of address the pages must be within (i.e. 16 would mean
* that the pages cannot have an address > 64k). The constrints are on
* what the hypervisor gives us -- we are free to give any pages in
* exchange. The array pp is the pages we are giving away. The caller
* provides storage space for mfns, which hold the new physical pages.
*/
long
{
long fallback_cnt;
long cnt;
long e;
int locked;
/*
* we shouldn't be allocating constrained pages on a guest. It doesn't
* make any sense. They won't be constrained after a migration.
*/
/* Give back the current pages to the hypervisor */
for (i = 0; i < page_cnt; i++) {
if (cnt != 1) {
"to the hypervisor.\n");
}
}
/*
* try to allocate the new pages using addr_bits and order. If we can't
* get all of the pages, try to get the remaining pages with no
* constraints and, if that was successful, return the number of
* constrained pages we did allocate.
*/
/*LINTED: constant in conditional context*/
/* assign the new MFNs to the current PFNs */
for (i = 0; i < cnt; i++) {
for (j = 0; j < extlen; j++) {
mfns[i] + j);
}
}
if (locked)
if (cnt < 0) {
cnt = 0;
}
/*
* We couldn't get enough memory to satisfy our requirements.
* The above loop will assign the parts of the request that
* were successful (this part may be 0). We need to fill
* in the rest. The bzero below clears out extent_order and
* address_bits, so we'll take anything from the hypervisor
* to replace the pages we gave away.
*/
/*LINTED: constant in conditional context*/
if (e != fallback_cnt) {
"failed increase_reservation.\n");
}
for (i = 0; i < fallback_cnt; i++) {
/*
* We already used pp[0...(cnt * extlen)] before,
* so start at the next entry in the pp array.
*/
}
if (locked)
}
/*
* balloon_free_pages increments our counter. Decrement it here.
*/
/*
* return the number of extents we were able to replace. If we got
* this far, we know all the pp's are valid.
*/
return (cnt);
}
/*
* balloon_zero_page()
* zero out the page.
*/
static void
{
/* balloon_init() should have been called first */
/* map the pfn into kva, zero the page, then unmap the pfn */
}
/*
* Called from the driver - return the requested stat.
*/
balloon_values(int cmd)
{
switch (cmd) {
case BLN_IOCTL_CURRENT:
case BLN_IOCTL_TARGET:
case BLN_IOCTL_LOW:
case BLN_IOCTL_HIGH:
case BLN_IOCTL_LIMIT:
default:
}
/*NOTREACHED*/
}