xref: /freebsd/sys/dev/xen/balloon/balloon.c (revision 4e4e43dc9e1afc863670a031cc5cc75eb5e668d6)
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 
52 static 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 
57 struct mtx balloon_mutex;
58 
59 /* We increase/decrease in batches which fit in a page */
60 static xen_pfn_t frame_list[PAGE_SIZE / sizeof(xen_pfn_t)];
61 
62 struct 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 
78 static struct balloon_stats balloon_stats;
79 #define bs balloon_stats
80 
81 SYSCTL_DECL(_dev_xen);
82 static SYSCTL_NODE(_dev_xen, OID_AUTO, balloon,
83     CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
84     "Balloon");
85 SYSCTL_ULONG(_dev_xen_balloon, OID_AUTO, current, CTLFLAG_RD,
86     &bs.current_pages, 0, "Current allocation");
87 SYSCTL_ULONG(_dev_xen_balloon, OID_AUTO, target, CTLFLAG_RD,
88     &bs.target_pages, 0, "Target allocation");
89 SYSCTL_ULONG(_dev_xen_balloon, OID_AUTO, driver_pages, CTLFLAG_RD,
90     &bs.driver_pages, 0, "Driver pages");
91 SYSCTL_ULONG(_dev_xen_balloon, OID_AUTO, hard_limit, CTLFLAG_RD,
92     &bs.hard_limit, 0, "Xen hard limit");
93 SYSCTL_ULONG(_dev_xen_balloon, OID_AUTO, low_mem, CTLFLAG_RD,
94     &bs.balloon_low, 0, "Low-mem balloon");
95 SYSCTL_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. */
99 static TAILQ_HEAD(,vm_page) ballooned_pages;
100 
101 /* Main work function, always executed in process context. */
102 static 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 
109 static unsigned long
110 current_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 
118 static unsigned long
119 minimum_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 
151 static int
152 increase_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 
212 static int
213 decrease_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  */
272 static void
273 balloon_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. */
304 static void
305 set_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 
313 static 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 */
320 static void
321 watch_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  */
348 static void
349 xenballoon_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  */
365 static int
366 xenballoon_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  */
381 static int
382 xenballoon_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  -----------------------*/
408 static 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 
417 DEFINE_CLASS_0(xenballoon, xenballoon_driver, xenballoon_methods, 0);
418 devclass_t xenballoon_devclass;
419 
420 DRIVER_MODULE(xenballoon, xenstore, xenballoon_driver, xenballoon_devclass,
421     NULL, NULL);
422