1 /******************************************************************************
4 * Xen balloon driver - enables returning/claiming memory to/from Xen.
6 * Copyright (c) 2003, B Dragovic
7 * Copyright (c) 2003-2004, M Williamson, K Fraser
8 * Copyright (c) 2005 Dan M. Smith, IBM Corporation
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License version 2
12 * as published by the Free Software Foundation; or, when distributed
13 * separately from the Linux kernel or incorporated into other
14 * software packages, subject to the following license:
16 * Permission is hereby granted, free of charge, to any person obtaining a copy
17 * of this source file (the "Software"), to deal in the Software without
18 * restriction, including without limitation the rights to use, copy, modify,
19 * merge, publish, distribute, sublicense, and/or sell copies of the Software,
20 * and to permit persons to whom the Software is furnished to do so, subject to
21 * the following conditions:
23 * The above copyright notice and this permission notice shall be included in
24 * all copies or substantial portions of the Software.
26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
27 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
28 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
29 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
30 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
31 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
35 #include <linux/kernel.h>
36 #include <linux/module.h>
37 #include <linux/sched.h>
38 #include <linux/errno.h>
40 #include <linux/bootmem.h>
41 #include <linux/pagemap.h>
42 #include <linux/highmem.h>
43 #include <linux/mutex.h>
44 #include <linux/list.h>
45 #include <linux/sysdev.h>
48 #include <asm/pgalloc.h>
49 #include <asm/pgtable.h>
50 #include <asm/uaccess.h>
53 #include <asm/xen/hypervisor.h>
54 #include <asm/xen/hypercall.h>
55 #include <xen/interface/xen.h>
56 #include <xen/interface/memory.h>
57 #include <xen/xenbus.h>
58 #include <xen/features.h>
61 #define PAGES2KB(_p) ((_p)<<(PAGE_SHIFT-10))
63 #define BALLOON_CLASS_NAME "xen_memory"
65 struct balloon_stats
{
66 /* We aim for 'current allocation' == 'target allocation'. */
67 unsigned long current_pages
;
68 unsigned long target_pages
;
69 /* We may hit the hard limit in Xen. If we do then we remember it. */
70 unsigned long hard_limit
;
72 * Drivers may alter the memory reservation independently, but they
73 * must inform the balloon driver so we avoid hitting the hard limit.
75 unsigned long driver_pages
;
76 /* Number of pages in high- and low-memory balloons. */
77 unsigned long balloon_low
;
78 unsigned long balloon_high
;
81 static DEFINE_MUTEX(balloon_mutex
);
83 static struct sys_device balloon_sysdev
;
85 static int register_balloon(struct sys_device
*sysdev
);
88 * Protects atomic reservation decrease/increase against concurrent increases.
89 * Also protects non-atomic updates of current_pages and driver_pages, and
92 static DEFINE_SPINLOCK(balloon_lock
);
94 static struct balloon_stats balloon_stats
;
96 /* We increase/decrease in batches which fit in a page */
97 static unsigned long frame_list
[PAGE_SIZE
/ sizeof(unsigned long)];
99 /* VM /proc information for memory */
100 extern unsigned long totalram_pages
;
102 #ifdef CONFIG_HIGHMEM
103 extern unsigned long totalhigh_pages
;
104 #define inc_totalhigh_pages() (totalhigh_pages++)
105 #define dec_totalhigh_pages() (totalhigh_pages--)
107 #define inc_totalhigh_pages() do {} while(0)
108 #define dec_totalhigh_pages() do {} while(0)
111 /* List of ballooned pages, threaded through the mem_map array. */
112 static LIST_HEAD(ballooned_pages
);
114 /* Main work function, always executed in process context. */
115 static void balloon_process(struct work_struct
*work
);
116 static DECLARE_WORK(balloon_worker
, balloon_process
);
117 static struct timer_list balloon_timer
;
119 /* When ballooning out (allocating memory to return to Xen) we don't really
120 want the kernel to try too hard since that can trigger the oom killer. */
121 #define GFP_BALLOON \
122 (GFP_HIGHUSER | __GFP_NOWARN | __GFP_NORETRY | __GFP_NOMEMALLOC)
124 static void scrub_page(struct page
*page
)
126 #ifdef CONFIG_XEN_SCRUB_PAGES
127 clear_highpage(page
);
131 /* balloon_append: add the given page to the balloon. */
132 static void balloon_append(struct page
*page
)
134 /* Lowmem is re-populated first, so highmem pages go at list tail. */
135 if (PageHighMem(page
)) {
136 list_add_tail(&page
->lru
, &ballooned_pages
);
137 balloon_stats
.balloon_high
++;
138 dec_totalhigh_pages();
140 list_add(&page
->lru
, &ballooned_pages
);
141 balloon_stats
.balloon_low
++;
145 /* balloon_retrieve: rescue a page from the balloon, if it is not empty. */
146 static struct page
*balloon_retrieve(void)
150 if (list_empty(&ballooned_pages
))
153 page
= list_entry(ballooned_pages
.next
, struct page
, lru
);
154 list_del(&page
->lru
);
156 if (PageHighMem(page
)) {
157 balloon_stats
.balloon_high
--;
158 inc_totalhigh_pages();
161 balloon_stats
.balloon_low
--;
166 static struct page
*balloon_first_page(void)
168 if (list_empty(&ballooned_pages
))
170 return list_entry(ballooned_pages
.next
, struct page
, lru
);
173 static struct page
*balloon_next_page(struct page
*page
)
175 struct list_head
*next
= page
->lru
.next
;
176 if (next
== &ballooned_pages
)
178 return list_entry(next
, struct page
, lru
);
181 static void balloon_alarm(unsigned long unused
)
183 schedule_work(&balloon_worker
);
186 static unsigned long current_target(void)
188 unsigned long target
= min(balloon_stats
.target_pages
, balloon_stats
.hard_limit
);
191 balloon_stats
.current_pages
+
192 balloon_stats
.balloon_low
+
193 balloon_stats
.balloon_high
);
198 static int increase_reservation(unsigned long nr_pages
)
200 unsigned long pfn
, i
, flags
;
203 struct xen_memory_reservation reservation
= {
209 if (nr_pages
> ARRAY_SIZE(frame_list
))
210 nr_pages
= ARRAY_SIZE(frame_list
);
212 spin_lock_irqsave(&balloon_lock
, flags
);
214 page
= balloon_first_page();
215 for (i
= 0; i
< nr_pages
; i
++) {
216 BUG_ON(page
== NULL
);
217 frame_list
[i
] = page_to_pfn(page
);;
218 page
= balloon_next_page(page
);
221 set_xen_guest_handle(reservation
.extent_start
, frame_list
);
222 reservation
.nr_extents
= nr_pages
;
223 rc
= HYPERVISOR_memory_op(XENMEM_populate_physmap
, &reservation
);
228 /* We hit the Xen hard limit: reprobe. */
229 reservation
.nr_extents
= rc
;
230 ret
= HYPERVISOR_memory_op(XENMEM_decrease_reservation
,
235 balloon_stats
.hard_limit
= (balloon_stats
.current_pages
+ rc
-
236 balloon_stats
.driver_pages
);
240 for (i
= 0; i
< nr_pages
; i
++) {
241 page
= balloon_retrieve();
242 BUG_ON(page
== NULL
);
244 pfn
= page_to_pfn(page
);
245 BUG_ON(!xen_feature(XENFEAT_auto_translated_physmap
) &&
246 phys_to_machine_mapping_valid(pfn
));
248 set_phys_to_machine(pfn
, frame_list
[i
]);
250 /* Link back into the page tables if not highmem. */
251 if (pfn
< max_low_pfn
) {
253 ret
= HYPERVISOR_update_va_mapping(
254 (unsigned long)__va(pfn
<< PAGE_SHIFT
),
255 mfn_pte(frame_list
[i
], PAGE_KERNEL
),
260 /* Relinquish the page back to the allocator. */
261 ClearPageReserved(page
);
262 init_page_count(page
);
266 balloon_stats
.current_pages
+= nr_pages
;
267 totalram_pages
= balloon_stats
.current_pages
;
270 spin_unlock_irqrestore(&balloon_lock
, flags
);
275 static int decrease_reservation(unsigned long nr_pages
)
277 unsigned long pfn
, i
, flags
;
281 struct xen_memory_reservation reservation
= {
287 if (nr_pages
> ARRAY_SIZE(frame_list
))
288 nr_pages
= ARRAY_SIZE(frame_list
);
290 for (i
= 0; i
< nr_pages
; i
++) {
291 if ((page
= alloc_page(GFP_BALLOON
)) == NULL
) {
297 pfn
= page_to_pfn(page
);
298 frame_list
[i
] = pfn_to_mfn(pfn
);
303 /* Ensure that ballooned highmem pages don't have kmaps. */
307 spin_lock_irqsave(&balloon_lock
, flags
);
309 /* No more mappings: invalidate P2M and add to balloon. */
310 for (i
= 0; i
< nr_pages
; i
++) {
311 pfn
= mfn_to_pfn(frame_list
[i
]);
312 set_phys_to_machine(pfn
, INVALID_P2M_ENTRY
);
313 balloon_append(pfn_to_page(pfn
));
316 set_xen_guest_handle(reservation
.extent_start
, frame_list
);
317 reservation
.nr_extents
= nr_pages
;
318 ret
= HYPERVISOR_memory_op(XENMEM_decrease_reservation
, &reservation
);
319 BUG_ON(ret
!= nr_pages
);
321 balloon_stats
.current_pages
-= nr_pages
;
322 totalram_pages
= balloon_stats
.current_pages
;
324 spin_unlock_irqrestore(&balloon_lock
, flags
);
330 * We avoid multiple worker processes conflicting via the balloon mutex.
331 * We may of course race updates of the target counts (which are protected
332 * by the balloon lock), or with changes to the Xen hard limit, but we will
333 * recover from these in time.
335 static void balloon_process(struct work_struct
*work
)
340 mutex_lock(&balloon_mutex
);
343 credit
= current_target() - balloon_stats
.current_pages
;
345 need_sleep
= (increase_reservation(credit
) != 0);
347 need_sleep
= (decrease_reservation(-credit
) != 0);
349 #ifndef CONFIG_PREEMPT
353 } while ((credit
!= 0) && !need_sleep
);
355 /* Schedule more work if there is some still to be done. */
356 if (current_target() != balloon_stats
.current_pages
)
357 mod_timer(&balloon_timer
, jiffies
+ HZ
);
359 mutex_unlock(&balloon_mutex
);
362 /* Resets the Xen limit, sets new target, and kicks off processing. */
363 static void balloon_set_new_target(unsigned long target
)
365 /* No need for lock. Not read-modify-write updates. */
366 balloon_stats
.hard_limit
= ~0UL;
367 balloon_stats
.target_pages
= target
;
368 schedule_work(&balloon_worker
);
371 static struct xenbus_watch target_watch
=
373 .node
= "memory/target"
376 /* React to a change in the target key */
377 static void watch_target(struct xenbus_watch
*watch
,
378 const char **vec
, unsigned int len
)
380 unsigned long long new_target
;
383 err
= xenbus_scanf(XBT_NIL
, "memory", "target", "%llu", &new_target
);
385 /* This is ok (for domain0 at least) - so just return */
389 /* The given memory/target value is in KiB, so it needs converting to
390 * pages. PAGE_SHIFT converts bytes to pages, hence PAGE_SHIFT - 10.
392 balloon_set_new_target(new_target
>> (PAGE_SHIFT
- 10));
395 static int balloon_init_watcher(struct notifier_block
*notifier
,
401 err
= register_xenbus_watch(&target_watch
);
403 printk(KERN_ERR
"Failed to set balloon watcher\n");
408 static struct notifier_block xenstore_notifier
;
410 static int __init
balloon_init(void)
415 if (!xen_pv_domain())
418 pr_info("xen_balloon: Initialising balloon driver.\n");
420 balloon_stats
.current_pages
= min(xen_start_info
->nr_pages
, max_pfn
);
421 totalram_pages
= balloon_stats
.current_pages
;
422 balloon_stats
.target_pages
= balloon_stats
.current_pages
;
423 balloon_stats
.balloon_low
= 0;
424 balloon_stats
.balloon_high
= 0;
425 balloon_stats
.driver_pages
= 0UL;
426 balloon_stats
.hard_limit
= ~0UL;
428 init_timer(&balloon_timer
);
429 balloon_timer
.data
= 0;
430 balloon_timer
.function
= balloon_alarm
;
432 register_balloon(&balloon_sysdev
);
434 /* Initialise the balloon with excess memory space. */
435 for (pfn
= xen_start_info
->nr_pages
; pfn
< max_pfn
; pfn
++) {
436 page
= pfn_to_page(pfn
);
437 if (!PageReserved(page
))
438 balloon_append(page
);
441 target_watch
.callback
= watch_target
;
442 xenstore_notifier
.notifier_call
= balloon_init_watcher
;
444 register_xenstore_notifier(&xenstore_notifier
);
449 subsys_initcall(balloon_init
);
451 static void balloon_exit(void)
453 /* XXX - release balloon here */
457 module_exit(balloon_exit
);
459 #define BALLOON_SHOW(name, format, args...) \
460 static ssize_t show_##name(struct sys_device *dev, \
461 struct sysdev_attribute *attr, \
464 return sprintf(buf, format, ##args); \
466 static SYSDEV_ATTR(name, S_IRUGO, show_##name, NULL)
468 BALLOON_SHOW(current_kb
, "%lu\n", PAGES2KB(balloon_stats
.current_pages
));
469 BALLOON_SHOW(low_kb
, "%lu\n", PAGES2KB(balloon_stats
.balloon_low
));
470 BALLOON_SHOW(high_kb
, "%lu\n", PAGES2KB(balloon_stats
.balloon_high
));
471 BALLOON_SHOW(hard_limit_kb
,
472 (balloon_stats
.hard_limit
!=~0UL) ? "%lu\n" : "???\n",
473 (balloon_stats
.hard_limit
!=~0UL) ? PAGES2KB(balloon_stats
.hard_limit
) : 0);
474 BALLOON_SHOW(driver_kb
, "%lu\n", PAGES2KB(balloon_stats
.driver_pages
));
476 static ssize_t
show_target_kb(struct sys_device
*dev
, struct sysdev_attribute
*attr
,
479 return sprintf(buf
, "%lu\n", PAGES2KB(balloon_stats
.target_pages
));
482 static ssize_t
store_target_kb(struct sys_device
*dev
,
483 struct sysdev_attribute
*attr
,
488 unsigned long long target_bytes
;
490 if (!capable(CAP_SYS_ADMIN
))
493 target_bytes
= memparse(buf
, &endchar
);
495 balloon_set_new_target(target_bytes
>> PAGE_SHIFT
);
500 static SYSDEV_ATTR(target_kb
, S_IRUGO
| S_IWUSR
,
501 show_target_kb
, store_target_kb
);
503 static struct sysdev_attribute
*balloon_attrs
[] = {
507 static struct attribute
*balloon_info_attrs
[] = {
508 &attr_current_kb
.attr
,
511 &attr_hard_limit_kb
.attr
,
512 &attr_driver_kb
.attr
,
516 static struct attribute_group balloon_info_group
= {
518 .attrs
= balloon_info_attrs
,
521 static struct sysdev_class balloon_sysdev_class
= {
522 .name
= BALLOON_CLASS_NAME
,
525 static int register_balloon(struct sys_device
*sysdev
)
529 error
= sysdev_class_register(&balloon_sysdev_class
);
534 sysdev
->cls
= &balloon_sysdev_class
;
536 error
= sysdev_register(sysdev
);
538 sysdev_class_unregister(&balloon_sysdev_class
);
542 for (i
= 0; i
< ARRAY_SIZE(balloon_attrs
); i
++) {
543 error
= sysdev_create_file(sysdev
, balloon_attrs
[i
]);
548 error
= sysfs_create_group(&sysdev
->kobj
, &balloon_info_group
);
556 sysdev_remove_file(sysdev
, balloon_attrs
[i
]);
557 sysdev_unregister(sysdev
);
558 sysdev_class_unregister(&balloon_sysdev_class
);
562 MODULE_LICENSE("GPL");