Daniel De Graaf | 803eb04 | 2011-03-14 11:29:37 -0400 | [diff] [blame] | 1 | /****************************************************************************** |
| 2 | * Xen balloon driver - enables returning/claiming memory to/from Xen. |
| 3 | * |
| 4 | * Copyright (c) 2003, B Dragovic |
| 5 | * Copyright (c) 2003-2004, M Williamson, K Fraser |
| 6 | * Copyright (c) 2005 Dan M. Smith, IBM Corporation |
| 7 | * |
| 8 | * This program is free software; you can redistribute it and/or |
| 9 | * modify it under the terms of the GNU General Public License version 2 |
| 10 | * as published by the Free Software Foundation; or, when distributed |
| 11 | * separately from the Linux kernel or incorporated into other |
| 12 | * software packages, subject to the following license: |
| 13 | * |
| 14 | * Permission is hereby granted, free of charge, to any person obtaining a copy |
| 15 | * of this source file (the "Software"), to deal in the Software without |
| 16 | * restriction, including without limitation the rights to use, copy, modify, |
| 17 | * merge, publish, distribute, sublicense, and/or sell copies of the Software, |
| 18 | * and to permit persons to whom the Software is furnished to do so, subject to |
| 19 | * the following conditions: |
| 20 | * |
| 21 | * The above copyright notice and this permission notice shall be included in |
| 22 | * all copies or substantial portions of the Software. |
| 23 | * |
| 24 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 25 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 26 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| 27 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 28 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| 29 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| 30 | * IN THE SOFTWARE. |
| 31 | */ |
| 32 | |
| 33 | #include <linux/kernel.h> |
| 34 | #include <linux/module.h> |
| 35 | #include <linux/sysdev.h> |
| 36 | #include <linux/capability.h> |
| 37 | |
| 38 | #include <xen/xen.h> |
| 39 | #include <xen/interface/xen.h> |
| 40 | #include <xen/balloon.h> |
| 41 | #include <xen/xenbus.h> |
| 42 | #include <xen/features.h> |
| 43 | #include <xen/page.h> |
| 44 | |
| 45 | #define PAGES2KB(_p) ((_p)<<(PAGE_SHIFT-10)) |
| 46 | |
| 47 | #define BALLOON_CLASS_NAME "xen_memory" |
| 48 | |
| 49 | static struct sys_device balloon_sysdev; |
| 50 | |
| 51 | static int register_balloon(struct sys_device *sysdev); |
| 52 | |
Daniel De Graaf | 803eb04 | 2011-03-14 11:29:37 -0400 | [diff] [blame] | 53 | /* React to a change in the target key */ |
| 54 | static void watch_target(struct xenbus_watch *watch, |
| 55 | const char **vec, unsigned int len) |
| 56 | { |
| 57 | unsigned long long new_target; |
| 58 | int err; |
| 59 | |
| 60 | err = xenbus_scanf(XBT_NIL, "memory", "target", "%llu", &new_target); |
| 61 | if (err != 1) { |
| 62 | /* This is ok (for domain0 at least) - so just return */ |
| 63 | return; |
| 64 | } |
| 65 | |
| 66 | /* The given memory/target value is in KiB, so it needs converting to |
| 67 | * pages. PAGE_SHIFT converts bytes to pages, hence PAGE_SHIFT - 10. |
| 68 | */ |
| 69 | balloon_set_new_target(new_target >> (PAGE_SHIFT - 10)); |
| 70 | } |
Olaf Hering | 6b71c52 | 2011-07-28 15:23:03 +0200 | [diff] [blame^] | 71 | static struct xenbus_watch target_watch = { |
| 72 | .node = "memory/target", |
| 73 | .callback = watch_target, |
| 74 | }; |
| 75 | |
Daniel De Graaf | 803eb04 | 2011-03-14 11:29:37 -0400 | [diff] [blame] | 76 | |
| 77 | static int balloon_init_watcher(struct notifier_block *notifier, |
| 78 | unsigned long event, |
| 79 | void *data) |
| 80 | { |
| 81 | int err; |
| 82 | |
| 83 | err = register_xenbus_watch(&target_watch); |
| 84 | if (err) |
| 85 | printk(KERN_ERR "Failed to set balloon watcher\n"); |
| 86 | |
| 87 | return NOTIFY_DONE; |
| 88 | } |
| 89 | |
Olaf Hering | 6b71c52 | 2011-07-28 15:23:03 +0200 | [diff] [blame^] | 90 | static struct notifier_block xenstore_notifier = { |
| 91 | .notifier_call = balloon_init_watcher, |
| 92 | }; |
Daniel De Graaf | 803eb04 | 2011-03-14 11:29:37 -0400 | [diff] [blame] | 93 | |
| 94 | static int __init balloon_init(void) |
| 95 | { |
| 96 | if (!xen_domain()) |
| 97 | return -ENODEV; |
| 98 | |
| 99 | pr_info("xen-balloon: Initialising balloon driver.\n"); |
| 100 | |
| 101 | register_balloon(&balloon_sysdev); |
| 102 | |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 103 | register_xen_selfballooning(&balloon_sysdev); |
| 104 | |
Daniel De Graaf | 803eb04 | 2011-03-14 11:29:37 -0400 | [diff] [blame] | 105 | register_xenstore_notifier(&xenstore_notifier); |
| 106 | |
| 107 | return 0; |
| 108 | } |
| 109 | subsys_initcall(balloon_init); |
| 110 | |
| 111 | static void balloon_exit(void) |
| 112 | { |
| 113 | /* XXX - release balloon here */ |
| 114 | return; |
| 115 | } |
| 116 | |
| 117 | module_exit(balloon_exit); |
| 118 | |
| 119 | #define BALLOON_SHOW(name, format, args...) \ |
| 120 | static ssize_t show_##name(struct sys_device *dev, \ |
| 121 | struct sysdev_attribute *attr, \ |
| 122 | char *buf) \ |
| 123 | { \ |
| 124 | return sprintf(buf, format, ##args); \ |
| 125 | } \ |
| 126 | static SYSDEV_ATTR(name, S_IRUGO, show_##name, NULL) |
| 127 | |
| 128 | BALLOON_SHOW(current_kb, "%lu\n", PAGES2KB(balloon_stats.current_pages)); |
| 129 | BALLOON_SHOW(low_kb, "%lu\n", PAGES2KB(balloon_stats.balloon_low)); |
| 130 | BALLOON_SHOW(high_kb, "%lu\n", PAGES2KB(balloon_stats.balloon_high)); |
| 131 | |
| 132 | static SYSDEV_ULONG_ATTR(schedule_delay, 0444, balloon_stats.schedule_delay); |
| 133 | static SYSDEV_ULONG_ATTR(max_schedule_delay, 0644, balloon_stats.max_schedule_delay); |
| 134 | static SYSDEV_ULONG_ATTR(retry_count, 0444, balloon_stats.retry_count); |
| 135 | static SYSDEV_ULONG_ATTR(max_retry_count, 0644, balloon_stats.max_retry_count); |
| 136 | |
| 137 | static ssize_t show_target_kb(struct sys_device *dev, struct sysdev_attribute *attr, |
| 138 | char *buf) |
| 139 | { |
| 140 | return sprintf(buf, "%lu\n", PAGES2KB(balloon_stats.target_pages)); |
| 141 | } |
| 142 | |
| 143 | static ssize_t store_target_kb(struct sys_device *dev, |
| 144 | struct sysdev_attribute *attr, |
| 145 | const char *buf, |
| 146 | size_t count) |
| 147 | { |
| 148 | char *endchar; |
| 149 | unsigned long long target_bytes; |
| 150 | |
| 151 | if (!capable(CAP_SYS_ADMIN)) |
| 152 | return -EPERM; |
| 153 | |
| 154 | target_bytes = simple_strtoull(buf, &endchar, 0) * 1024; |
| 155 | |
| 156 | balloon_set_new_target(target_bytes >> PAGE_SHIFT); |
| 157 | |
| 158 | return count; |
| 159 | } |
| 160 | |
| 161 | static SYSDEV_ATTR(target_kb, S_IRUGO | S_IWUSR, |
| 162 | show_target_kb, store_target_kb); |
| 163 | |
| 164 | |
| 165 | static ssize_t show_target(struct sys_device *dev, struct sysdev_attribute *attr, |
| 166 | char *buf) |
| 167 | { |
| 168 | return sprintf(buf, "%llu\n", |
| 169 | (unsigned long long)balloon_stats.target_pages |
| 170 | << PAGE_SHIFT); |
| 171 | } |
| 172 | |
| 173 | static ssize_t store_target(struct sys_device *dev, |
| 174 | struct sysdev_attribute *attr, |
| 175 | const char *buf, |
| 176 | size_t count) |
| 177 | { |
| 178 | char *endchar; |
| 179 | unsigned long long target_bytes; |
| 180 | |
| 181 | if (!capable(CAP_SYS_ADMIN)) |
| 182 | return -EPERM; |
| 183 | |
| 184 | target_bytes = memparse(buf, &endchar); |
| 185 | |
| 186 | balloon_set_new_target(target_bytes >> PAGE_SHIFT); |
| 187 | |
| 188 | return count; |
| 189 | } |
| 190 | |
| 191 | static SYSDEV_ATTR(target, S_IRUGO | S_IWUSR, |
| 192 | show_target, store_target); |
| 193 | |
| 194 | |
| 195 | static struct sysdev_attribute *balloon_attrs[] = { |
| 196 | &attr_target_kb, |
| 197 | &attr_target, |
| 198 | &attr_schedule_delay.attr, |
| 199 | &attr_max_schedule_delay.attr, |
| 200 | &attr_retry_count.attr, |
| 201 | &attr_max_retry_count.attr |
| 202 | }; |
| 203 | |
| 204 | static struct attribute *balloon_info_attrs[] = { |
| 205 | &attr_current_kb.attr, |
| 206 | &attr_low_kb.attr, |
| 207 | &attr_high_kb.attr, |
| 208 | NULL |
| 209 | }; |
| 210 | |
| 211 | static struct attribute_group balloon_info_group = { |
| 212 | .name = "info", |
| 213 | .attrs = balloon_info_attrs |
| 214 | }; |
| 215 | |
| 216 | static struct sysdev_class balloon_sysdev_class = { |
| 217 | .name = BALLOON_CLASS_NAME |
| 218 | }; |
| 219 | |
| 220 | static int register_balloon(struct sys_device *sysdev) |
| 221 | { |
| 222 | int i, error; |
| 223 | |
| 224 | error = sysdev_class_register(&balloon_sysdev_class); |
| 225 | if (error) |
| 226 | return error; |
| 227 | |
| 228 | sysdev->id = 0; |
| 229 | sysdev->cls = &balloon_sysdev_class; |
| 230 | |
| 231 | error = sysdev_register(sysdev); |
| 232 | if (error) { |
| 233 | sysdev_class_unregister(&balloon_sysdev_class); |
| 234 | return error; |
| 235 | } |
| 236 | |
| 237 | for (i = 0; i < ARRAY_SIZE(balloon_attrs); i++) { |
| 238 | error = sysdev_create_file(sysdev, balloon_attrs[i]); |
| 239 | if (error) |
| 240 | goto fail; |
| 241 | } |
| 242 | |
| 243 | error = sysfs_create_group(&sysdev->kobj, &balloon_info_group); |
| 244 | if (error) |
| 245 | goto fail; |
| 246 | |
| 247 | return 0; |
| 248 | |
| 249 | fail: |
| 250 | while (--i >= 0) |
| 251 | sysdev_remove_file(sysdev, balloon_attrs[i]); |
| 252 | sysdev_unregister(sysdev); |
| 253 | sysdev_class_unregister(&balloon_sysdev_class); |
| 254 | return error; |
| 255 | } |
| 256 | |
| 257 | MODULE_LICENSE("GPL"); |