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