1/******************************************************************************
2 * balloon.c
3 *
4 * Xen balloon driver - enables returning/claiming memory to/from Xen.
5 *
6 * Copyright (c) 2003, B Dragovic
7 * Copyright (c) 2003-2004, M Williamson, K Fraser
8 * Copyright (c) 2005 Dan M. Smith, IBM Corporation
9 *
10 * This file may be distributed separately from the Linux kernel, or
11 * incorporated into other software packages, subject to the following license:
12 *
13 * Permission is hereby granted, free of charge, to any person obtaining a copy
14 * of this source file (the "Software"), to deal in the Software without
15 * restriction, including without limitation the rights to use, copy, modify,
16 * merge, publish, distribute, sublicense, and/or sell copies of the Software,
17 * and to permit persons to whom the Software is furnished to do so, subject to
18 * the following conditions:
19 *
20 * The above copyright notice and this permission notice shall be included in
21 * all copies or substantial portions of the Software.
22 *
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
24 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
25 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
26 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
27 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
28 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
29 * IN THE SOFTWARE.
30 */
31
32#include <sys/cdefs.h>
33__FBSDID("$FreeBSD$");
34
35#include <sys/param.h>
36#include <sys/lock.h>
37#include <sys/kernel.h>
38#include <sys/kthread.h>
39#include <sys/malloc.h>
40#include <sys/mutex.h>
41#include <sys/sysctl.h>
42#include <sys/module.h>
43
44#include <vm/vm.h>
45#include <vm/vm_page.h>
46
47#include <xen/xen-os.h>
48#include <xen/hypervisor.h>
49#include <xen/features.h>
50#include <xen/xenstore/xenstorevar.h>
51
52static MALLOC_DEFINE(M_BALLOON, "Balloon", "Xen Balloon Driver");
53
54/* Convert from KB (as fetched from xenstore) to number of PAGES */
55#define KB_TO_PAGE_SHIFT	(PAGE_SHIFT - 10)
56
57struct mtx balloon_mutex;
58
59/* We increase/decrease in batches which fit in a page */
60static xen_pfn_t frame_list[PAGE_SIZE / sizeof(xen_pfn_t)];
61
62struct balloon_stats {
63	/* We aim for 'current allocation' == 'target allocation'. */
64	unsigned long current_pages;
65	unsigned long target_pages;
66	/* We may hit the hard limit in Xen. If we do then we remember it. */
67	unsigned long hard_limit;
68	/*
69	 * Drivers may alter the memory reservation independently, but they
70	 * must inform the balloon driver so we avoid hitting the hard limit.
71	 */
72	unsigned long driver_pages;
73	/* Number of pages in high- and low-memory balloons. */
74	unsigned long balloon_low;
75	unsigned long balloon_high;
76};
77
78static struct balloon_stats balloon_stats;
79#define bs balloon_stats
80
81SYSCTL_DECL(_dev_xen);
82static SYSCTL_NODE(_dev_xen, OID_AUTO, balloon,
83    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
84    "Balloon");
85SYSCTL_ULONG(_dev_xen_balloon, OID_AUTO, current, CTLFLAG_RD,
86    &bs.current_pages, 0, "Current allocation");
87SYSCTL_ULONG(_dev_xen_balloon, OID_AUTO, target, CTLFLAG_RD,
88    &bs.target_pages, 0, "Target allocation");
89SYSCTL_ULONG(_dev_xen_balloon, OID_AUTO, driver_pages, CTLFLAG_RD,
90    &bs.driver_pages, 0, "Driver pages");
91SYSCTL_ULONG(_dev_xen_balloon, OID_AUTO, hard_limit, CTLFLAG_RD,
92    &bs.hard_limit, 0, "Xen hard limit");
93SYSCTL_ULONG(_dev_xen_balloon, OID_AUTO, low_mem, CTLFLAG_RD,
94    &bs.balloon_low, 0, "Low-mem balloon");
95SYSCTL_ULONG(_dev_xen_balloon, OID_AUTO, high_mem, CTLFLAG_RD,
96    &bs.balloon_high, 0, "High-mem balloon");
97
98/* List of ballooned pages, threaded through the mem_map array. */
99static TAILQ_HEAD(,vm_page) ballooned_pages;
100
101/* Main work function, always executed in process context. */
102static void balloon_process(void *unused);
103
104#define IPRINTK(fmt, args...) \
105	printk(KERN_INFO "xen_mem: " fmt, ##args)
106#define WPRINTK(fmt, args...) \
107	printk(KERN_WARNING "xen_mem: " fmt, ##args)
108
109static unsigned long
110current_target(void)
111{
112	unsigned long target = min(bs.target_pages, bs.hard_limit);
113	if (target > (bs.current_pages + bs.balloon_low + bs.balloon_high))
114		target = bs.current_pages + bs.balloon_low + bs.balloon_high;
115	return (target);
116}
117
118static unsigned long
119minimum_target(void)
120{
121	unsigned long min_pages, curr_pages = current_target();
122
123#define MB2PAGES(mb) ((mb) << (20 - PAGE_SHIFT))
124	/*
125	 * Simple continuous piecewiese linear function:
126	 *  max MiB -> min MiB	gradient
127	 *       0	   0
128	 *      16	  16
129	 *      32	  24
130	 *     128	  72	(1/2)
131	 *     512 	 168	(1/4)
132	 *    2048	 360	(1/8)
133	 *    8192	 552	(1/32)
134	 *   32768	1320
135	 *  131072	4392
136	 */
137	if (realmem < MB2PAGES(128))
138		min_pages = MB2PAGES(8) + (realmem >> 1);
139	else if (realmem < MB2PAGES(512))
140		min_pages = MB2PAGES(40) + (realmem >> 2);
141	else if (realmem < MB2PAGES(2048))
142		min_pages = MB2PAGES(104) + (realmem >> 3);
143	else
144		min_pages = MB2PAGES(296) + (realmem >> 5);
145#undef MB2PAGES
146
147	/* Don't enforce growth */
148	return (min(min_pages, curr_pages));
149}
150
151static int
152increase_reservation(unsigned long nr_pages)
153{
154	unsigned long  i;
155	vm_page_t      page;
156	long           rc;
157	struct xen_memory_reservation reservation = {
158		.address_bits = 0,
159		.extent_order = 0,
160		.domid        = DOMID_SELF
161	};
162
163	mtx_assert(&balloon_mutex, MA_OWNED);
164
165	if (nr_pages > nitems(frame_list))
166		nr_pages = nitems(frame_list);
167
168	for (page = TAILQ_FIRST(&ballooned_pages), i = 0;
169	    i < nr_pages; i++, page = TAILQ_NEXT(page, plinks.q)) {
170		KASSERT(page != NULL, ("ballooned_pages list corrupt"));
171		frame_list[i] = (VM_PAGE_TO_PHYS(page) >> PAGE_SHIFT);
172	}
173
174	set_xen_guest_handle(reservation.extent_start, frame_list);
175	reservation.nr_extents   = nr_pages;
176	rc = HYPERVISOR_memory_op(
177		XENMEM_populate_physmap, &reservation);
178	if (rc < nr_pages) {
179		if (rc > 0) {
180			int ret;
181
182			/* We hit the Xen hard limit: reprobe. */
183			reservation.nr_extents = rc;
184			ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation,
185					&reservation);
186			KASSERT(ret == rc, ("HYPERVISOR_memory_op failed"));
187		}
188		if (rc >= 0)
189			bs.hard_limit = (bs.current_pages + rc -
190					 bs.driver_pages);
191		goto out;
192	}
193
194	for (i = 0; i < nr_pages; i++) {
195		page = TAILQ_FIRST(&ballooned_pages);
196		KASSERT(page != NULL, ("Unable to get ballooned page"));
197		TAILQ_REMOVE(&ballooned_pages, page, plinks.q);
198		bs.balloon_low--;
199
200		KASSERT(xen_feature(XENFEAT_auto_translated_physmap),
201		    ("auto translated physmap but mapping is valid"));
202
203		vm_page_free(page);
204	}
205
206	bs.current_pages += nr_pages;
207
208 out:
209	return (0);
210}
211
212static int
213decrease_reservation(unsigned long nr_pages)
214{
215	unsigned long  i;
216	vm_page_t      page;
217	int            need_sleep = 0;
218	int ret;
219	struct xen_memory_reservation reservation = {
220		.address_bits = 0,
221		.extent_order = 0,
222		.domid        = DOMID_SELF
223	};
224
225	mtx_assert(&balloon_mutex, MA_OWNED);
226
227	if (nr_pages > nitems(frame_list))
228		nr_pages = nitems(frame_list);
229
230	for (i = 0; i < nr_pages; i++) {
231		if ((page = vm_page_alloc(NULL, 0,
232			    VM_ALLOC_NORMAL | VM_ALLOC_NOOBJ |
233			    VM_ALLOC_ZERO)) == NULL) {
234			nr_pages = i;
235			need_sleep = 1;
236			break;
237		}
238
239		if ((page->flags & PG_ZERO) == 0) {
240			/*
241			 * Zero the page, or else we might be leaking
242			 * important data to other domains on the same
243			 * host. Xen doesn't scrub ballooned out memory
244			 * pages, the guest is in charge of making
245			 * sure that no information is leaked.
246			 */
247			pmap_zero_page(page);
248		}
249
250		frame_list[i] = (VM_PAGE_TO_PHYS(page) >> PAGE_SHIFT);
251
252		TAILQ_INSERT_HEAD(&ballooned_pages, page, plinks.q);
253		bs.balloon_low++;
254	}
255
256	set_xen_guest_handle(reservation.extent_start, frame_list);
257	reservation.nr_extents   = nr_pages;
258	ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation, &reservation);
259	KASSERT(ret == nr_pages, ("HYPERVISOR_memory_op failed"));
260
261	bs.current_pages -= nr_pages;
262
263	return (need_sleep);
264}
265
266/*
267 * We avoid multiple worker processes conflicting via the balloon mutex.
268 * We may of course race updates of the target counts (which are protected
269 * by the balloon lock), or with changes to the Xen hard limit, but we will
270 * recover from these in time.
271 */
272static void
273balloon_process(void *unused)
274{
275	int need_sleep = 0;
276	long credit;
277
278	mtx_lock(&balloon_mutex);
279	for (;;) {
280		int sleep_time;
281
282		do {
283			credit = current_target() - bs.current_pages;
284			if (credit > 0)
285				need_sleep = (increase_reservation(credit) != 0);
286			if (credit < 0)
287				need_sleep = (decrease_reservation(-credit) != 0);
288
289		} while ((credit != 0) && !need_sleep);
290
291		/* Schedule more work if there is some still to be done. */
292		if (current_target() != bs.current_pages)
293			sleep_time = hz;
294		else
295			sleep_time = 0;
296
297		msleep(balloon_process, &balloon_mutex, 0, "balloon",
298		       sleep_time);
299	}
300	mtx_unlock(&balloon_mutex);
301}
302
303/* Resets the Xen limit, sets new target, and kicks off processing. */
304static void
305set_new_target(unsigned long target)
306{
307	/* No need for lock. Not read-modify-write updates. */
308	bs.hard_limit   = ~0UL;
309	bs.target_pages = max(target, minimum_target());
310	wakeup(balloon_process);
311}
312
313static struct xs_watch target_watch =
314{
315	.node = "memory/target",
316	.max_pending = 1,
317};
318
319/* React to a change in the target key */
320static void
321watch_target(struct xs_watch *watch,
322	     const char **vec, unsigned int len)
323{
324	unsigned long long new_target;
325	int err;
326
327	err = xs_scanf(XST_NIL, "memory", "target", NULL,
328	    "%llu", &new_target);
329	if (err) {
330		/* This is ok (for domain0 at least) - so just return */
331		return;
332	}
333
334	/*
335	 * The given memory/target value is in KiB, so it needs converting to
336	 * pages.  PAGE_SHIFT converts bytes to pages, hence PAGE_SHIFT - 10.
337	 */
338	set_new_target(new_target >> KB_TO_PAGE_SHIFT);
339}
340
341/*------------------ Private Device Attachment Functions  --------------------*/
342/**
343 * \brief Identify instances of this device type in the system.
344 *
345 * \param driver  The driver performing this identify action.
346 * \param parent  The NewBus parent device for any devices this method adds.
347 */
348static void
349xenballoon_identify(driver_t *driver __unused, device_t parent)
350{
351	/*
352	 * A single device instance for our driver is always present
353	 * in a system operating under Xen.
354	 */
355	BUS_ADD_CHILD(parent, 0, driver->name, 0);
356}
357
358/**
359 * \brief Probe for the existence of the Xen Balloon device
360 *
361 * \param dev  NewBus device_t for this Xen control instance.
362 *
363 * \return  Always returns 0 indicating success.
364 */
365static int
366xenballoon_probe(device_t dev)
367{
368
369	device_set_desc(dev, "Xen Balloon Device");
370	return (0);
371}
372
373/**
374 * \brief Attach the Xen Balloon device.
375 *
376 * \param dev  NewBus device_t for this Xen control instance.
377 *
378 * \return  On success, 0. Otherwise an errno value indicating the
379 *          type of failure.
380 */
381static int
382xenballoon_attach(device_t dev)
383{
384	int err;
385
386	mtx_init(&balloon_mutex, "balloon_mutex", NULL, MTX_DEF);
387
388	bs.current_pages = realmem;
389	bs.target_pages  = bs.current_pages;
390	bs.balloon_low   = 0;
391	bs.balloon_high  = 0;
392	bs.driver_pages  = 0UL;
393	bs.hard_limit    = ~0UL;
394
395	kproc_create(balloon_process, NULL, NULL, 0, 0, "balloon");
396
397	target_watch.callback = watch_target;
398
399	err = xs_register_watch(&target_watch);
400	if (err)
401		device_printf(dev,
402		    "xenballon: failed to set balloon watcher\n");
403
404	return (err);
405}
406
407/*-------------------- Private Device Attachment Data  -----------------------*/
408static device_method_t xenballoon_methods[] = {
409	/* Device interface */
410	DEVMETHOD(device_identify,	xenballoon_identify),
411	DEVMETHOD(device_probe,         xenballoon_probe),
412	DEVMETHOD(device_attach,        xenballoon_attach),
413
414	DEVMETHOD_END
415};
416
417DEFINE_CLASS_0(xenballoon, xenballoon_driver, xenballoon_methods, 0);
418devclass_t xenballoon_devclass;
419
420DRIVER_MODULE(xenballoon, xenstore, xenballoon_driver, xenballoon_devclass,
421    NULL, NULL);
422