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 53 static struct xenbus_watch target_watch = 54 { 55 .node = "memory/target" 56 }; 57 58 /* React to a change in the target key */ 59 static void watch_target(struct xenbus_watch *watch, 60 const char **vec, unsigned int len) 61 { 62 unsigned long long new_target; 63 int err; 64 65 err = xenbus_scanf(XBT_NIL, "memory", "target", "%llu", &new_target); 66 if (err != 1) { 67 /* This is ok (for domain0 at least) - so just return */ 68 return; 69 } 70 71 /* The given memory/target value is in KiB, so it needs converting to 72 * pages. PAGE_SHIFT converts bytes to pages, hence PAGE_SHIFT - 10. 73 */ 74 balloon_set_new_target(new_target >> (PAGE_SHIFT - 10)); 75 } 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 90 static struct notifier_block xenstore_notifier; 91 92 static int __init balloon_init(void) 93 { 94 if (!xen_domain()) 95 return -ENODEV; 96 97 pr_info("xen-balloon: Initialising balloon driver.\n"); 98 99 register_balloon(&balloon_sysdev); 100 101 register_xen_selfballooning(&balloon_sysdev); 102 103 target_watch.callback = watch_target; 104 xenstore_notifier.notifier_call = balloon_init_watcher; 105 106 register_xenstore_notifier(&xenstore_notifier); 107 108 return 0; 109 } 110 subsys_initcall(balloon_init); 111 112 static void balloon_exit(void) 113 { 114 /* XXX - release balloon here */ 115 return; 116 } 117 118 module_exit(balloon_exit); 119 120 #define BALLOON_SHOW(name, format, args...) \ 121 static ssize_t show_##name(struct sys_device *dev, \ 122 struct sysdev_attribute *attr, \ 123 char *buf) \ 124 { \ 125 return sprintf(buf, format, ##args); \ 126 } \ 127 static SYSDEV_ATTR(name, S_IRUGO, show_##name, NULL) 128 129 BALLOON_SHOW(current_kb, "%lu\n", PAGES2KB(balloon_stats.current_pages)); 130 BALLOON_SHOW(low_kb, "%lu\n", PAGES2KB(balloon_stats.balloon_low)); 131 BALLOON_SHOW(high_kb, "%lu\n", PAGES2KB(balloon_stats.balloon_high)); 132 133 static SYSDEV_ULONG_ATTR(schedule_delay, 0444, balloon_stats.schedule_delay); 134 static SYSDEV_ULONG_ATTR(max_schedule_delay, 0644, balloon_stats.max_schedule_delay); 135 static SYSDEV_ULONG_ATTR(retry_count, 0444, balloon_stats.retry_count); 136 static SYSDEV_ULONG_ATTR(max_retry_count, 0644, balloon_stats.max_retry_count); 137 138 static ssize_t show_target_kb(struct sys_device *dev, struct sysdev_attribute *attr, 139 char *buf) 140 { 141 return sprintf(buf, "%lu\n", PAGES2KB(balloon_stats.target_pages)); 142 } 143 144 static ssize_t store_target_kb(struct sys_device *dev, 145 struct sysdev_attribute *attr, 146 const char *buf, 147 size_t count) 148 { 149 char *endchar; 150 unsigned long long target_bytes; 151 152 if (!capable(CAP_SYS_ADMIN)) 153 return -EPERM; 154 155 target_bytes = simple_strtoull(buf, &endchar, 0) * 1024; 156 157 balloon_set_new_target(target_bytes >> PAGE_SHIFT); 158 159 return count; 160 } 161 162 static SYSDEV_ATTR(target_kb, S_IRUGO | S_IWUSR, 163 show_target_kb, store_target_kb); 164 165 166 static ssize_t show_target(struct sys_device *dev, struct sysdev_attribute *attr, 167 char *buf) 168 { 169 return sprintf(buf, "%llu\n", 170 (unsigned long long)balloon_stats.target_pages 171 << PAGE_SHIFT); 172 } 173 174 static ssize_t store_target(struct sys_device *dev, 175 struct sysdev_attribute *attr, 176 const char *buf, 177 size_t count) 178 { 179 char *endchar; 180 unsigned long long target_bytes; 181 182 if (!capable(CAP_SYS_ADMIN)) 183 return -EPERM; 184 185 target_bytes = memparse(buf, &endchar); 186 187 balloon_set_new_target(target_bytes >> PAGE_SHIFT); 188 189 return count; 190 } 191 192 static SYSDEV_ATTR(target, S_IRUGO | S_IWUSR, 193 show_target, store_target); 194 195 196 static struct sysdev_attribute *balloon_attrs[] = { 197 &attr_target_kb, 198 &attr_target, 199 &attr_schedule_delay.attr, 200 &attr_max_schedule_delay.attr, 201 &attr_retry_count.attr, 202 &attr_max_retry_count.attr 203 }; 204 205 static struct attribute *balloon_info_attrs[] = { 206 &attr_current_kb.attr, 207 &attr_low_kb.attr, 208 &attr_high_kb.attr, 209 NULL 210 }; 211 212 static struct attribute_group balloon_info_group = { 213 .name = "info", 214 .attrs = balloon_info_attrs 215 }; 216 217 static struct sysdev_class balloon_sysdev_class = { 218 .name = BALLOON_CLASS_NAME 219 }; 220 221 static int register_balloon(struct sys_device *sysdev) 222 { 223 int i, error; 224 225 error = sysdev_class_register(&balloon_sysdev_class); 226 if (error) 227 return error; 228 229 sysdev->id = 0; 230 sysdev->cls = &balloon_sysdev_class; 231 232 error = sysdev_register(sysdev); 233 if (error) { 234 sysdev_class_unregister(&balloon_sysdev_class); 235 return error; 236 } 237 238 for (i = 0; i < ARRAY_SIZE(balloon_attrs); i++) { 239 error = sysdev_create_file(sysdev, balloon_attrs[i]); 240 if (error) 241 goto fail; 242 } 243 244 error = sysfs_create_group(&sysdev->kobj, &balloon_info_group); 245 if (error) 246 goto fail; 247 248 return 0; 249 250 fail: 251 while (--i >= 0) 252 sysdev_remove_file(sysdev, balloon_attrs[i]); 253 sysdev_unregister(sysdev); 254 sysdev_class_unregister(&balloon_sysdev_class); 255 return error; 256 } 257 258 MODULE_LICENSE("GPL"); 259