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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 34 35 #include <linux/kernel.h> 36 #include <linux/errno.h> 37 #include <linux/mm_types.h> 38 #include <linux/init.h> 39 #include <linux/capability.h> 40 #include <linux/memory_hotplug.h> 41 42 #include <xen/xen.h> 43 #include <xen/interface/xen.h> 44 #include <xen/balloon.h> 45 #include <xen/xenbus.h> 46 #include <xen/features.h> 47 #include <xen/page.h> 48 #include <xen/mem-reservation.h> 49 50 #define PAGES2KB(_p) ((_p)<<(PAGE_SHIFT-10)) 51 52 #define BALLOON_CLASS_NAME "xen_memory" 53 54 #ifdef CONFIG_MEMORY_HOTPLUG 55 u64 xen_saved_max_mem_size = 0; 56 #endif 57 58 static struct device balloon_dev; 59 60 static int register_balloon(struct device *dev); 61 62 /* React to a change in the target key */ 63 static void watch_target(struct xenbus_watch *watch, 64 const char *path, const char *token) 65 { 66 unsigned long long new_target, static_max; 67 int err; 68 static bool watch_fired; 69 static long target_diff; 70 71 #ifdef CONFIG_MEMORY_HOTPLUG 72 /* The balloon driver will take care of adding memory now. */ 73 if (xen_saved_max_mem_size) 74 max_mem_size = xen_saved_max_mem_size; 75 #endif 76 77 err = xenbus_scanf(XBT_NIL, "memory", "target", "%llu", &new_target); 78 if (err != 1) { 79 /* This is ok (for domain0 at least) - so just return */ 80 return; 81 } 82 83 /* The given memory/target value is in KiB, so it needs converting to 84 * pages. PAGE_SHIFT converts bytes to pages, hence PAGE_SHIFT - 10. 85 */ 86 new_target >>= PAGE_SHIFT - 10; 87 88 if (!watch_fired) { 89 watch_fired = true; 90 91 if ((xenbus_scanf(XBT_NIL, "memory", "static-max", 92 "%llu", &static_max) == 1) || 93 (xenbus_scanf(XBT_NIL, "memory", "memory_static_max", 94 "%llu", &static_max) == 1)) 95 static_max >>= PAGE_SHIFT - 10; 96 else 97 static_max = balloon_stats.current_pages; 98 99 target_diff = (xen_pv_domain() || xen_initial_domain()) ? 0 100 : static_max - balloon_stats.target_pages; 101 } 102 103 balloon_set_new_target(new_target - target_diff); 104 } 105 static struct xenbus_watch target_watch = { 106 .node = "memory/target", 107 .callback = watch_target, 108 }; 109 110 111 static int balloon_init_watcher(struct notifier_block *notifier, 112 unsigned long event, 113 void *data) 114 { 115 int err; 116 117 err = register_xenbus_watch(&target_watch); 118 if (err) 119 pr_err("Failed to set balloon watcher\n"); 120 121 return NOTIFY_DONE; 122 } 123 124 static struct notifier_block xenstore_notifier = { 125 .notifier_call = balloon_init_watcher, 126 }; 127 128 void xen_balloon_init(void) 129 { 130 register_balloon(&balloon_dev); 131 132 register_xenstore_notifier(&xenstore_notifier); 133 } 134 EXPORT_SYMBOL_GPL(xen_balloon_init); 135 136 #define BALLOON_SHOW(name, format, args...) \ 137 static ssize_t name##_show(struct device *dev, \ 138 struct device_attribute *attr, \ 139 char *buf) \ 140 { \ 141 return sprintf(buf, format, ##args); \ 142 } \ 143 static DEVICE_ATTR_RO(name) 144 145 BALLOON_SHOW(current_kb, "%lu\n", PAGES2KB(balloon_stats.current_pages)); 146 BALLOON_SHOW(low_kb, "%lu\n", PAGES2KB(balloon_stats.balloon_low)); 147 BALLOON_SHOW(high_kb, "%lu\n", PAGES2KB(balloon_stats.balloon_high)); 148 149 static DEVICE_ULONG_ATTR(schedule_delay, 0444, balloon_stats.schedule_delay); 150 static DEVICE_ULONG_ATTR(max_schedule_delay, 0644, balloon_stats.max_schedule_delay); 151 static DEVICE_ULONG_ATTR(retry_count, 0444, balloon_stats.retry_count); 152 static DEVICE_ULONG_ATTR(max_retry_count, 0644, balloon_stats.max_retry_count); 153 static DEVICE_BOOL_ATTR(scrub_pages, 0644, xen_scrub_pages); 154 155 static ssize_t target_kb_show(struct device *dev, struct device_attribute *attr, 156 char *buf) 157 { 158 return sprintf(buf, "%lu\n", PAGES2KB(balloon_stats.target_pages)); 159 } 160 161 static ssize_t target_kb_store(struct device *dev, 162 struct device_attribute *attr, 163 const char *buf, size_t count) 164 { 165 char *endchar; 166 unsigned long long target_bytes; 167 168 if (!capable(CAP_SYS_ADMIN)) 169 return -EPERM; 170 171 target_bytes = simple_strtoull(buf, &endchar, 0) * 1024; 172 173 balloon_set_new_target(target_bytes >> PAGE_SHIFT); 174 175 return count; 176 } 177 178 static DEVICE_ATTR_RW(target_kb); 179 180 static ssize_t target_show(struct device *dev, struct device_attribute *attr, 181 char *buf) 182 { 183 return sprintf(buf, "%llu\n", 184 (unsigned long long)balloon_stats.target_pages 185 << PAGE_SHIFT); 186 } 187 188 static ssize_t target_store(struct device *dev, 189 struct device_attribute *attr, 190 const char *buf, size_t count) 191 { 192 char *endchar; 193 unsigned long long target_bytes; 194 195 if (!capable(CAP_SYS_ADMIN)) 196 return -EPERM; 197 198 target_bytes = memparse(buf, &endchar); 199 200 balloon_set_new_target(target_bytes >> PAGE_SHIFT); 201 202 return count; 203 } 204 205 static DEVICE_ATTR_RW(target); 206 207 static struct attribute *balloon_attrs[] = { 208 &dev_attr_target_kb.attr, 209 &dev_attr_target.attr, 210 &dev_attr_schedule_delay.attr.attr, 211 &dev_attr_max_schedule_delay.attr.attr, 212 &dev_attr_retry_count.attr.attr, 213 &dev_attr_max_retry_count.attr.attr, 214 &dev_attr_scrub_pages.attr.attr, 215 NULL 216 }; 217 218 static const struct attribute_group balloon_group = { 219 .attrs = balloon_attrs 220 }; 221 222 static struct attribute *balloon_info_attrs[] = { 223 &dev_attr_current_kb.attr, 224 &dev_attr_low_kb.attr, 225 &dev_attr_high_kb.attr, 226 NULL 227 }; 228 229 static const struct attribute_group balloon_info_group = { 230 .name = "info", 231 .attrs = balloon_info_attrs 232 }; 233 234 static const struct attribute_group *balloon_groups[] = { 235 &balloon_group, 236 &balloon_info_group, 237 NULL 238 }; 239 240 static struct bus_type balloon_subsys = { 241 .name = BALLOON_CLASS_NAME, 242 .dev_name = BALLOON_CLASS_NAME, 243 }; 244 245 static int register_balloon(struct device *dev) 246 { 247 int error; 248 249 error = subsys_system_register(&balloon_subsys, NULL); 250 if (error) 251 return error; 252 253 dev->id = 0; 254 dev->bus = &balloon_subsys; 255 dev->groups = balloon_groups; 256 257 error = device_register(dev); 258 if (error) { 259 bus_unregister(&balloon_subsys); 260 return error; 261 } 262 263 return 0; 264 } 265