Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 1 | /****************************************************************************** |
| 2 | * Xen selfballoon driver (and optional frontswap self-shrinking driver) |
| 3 | * |
| 4 | * Copyright (c) 2009-2011, Dan Magenheimer, Oracle Corp. |
| 5 | * |
| 6 | * This code complements the cleancache and frontswap patchsets to optimize |
| 7 | * support for Xen Transcendent Memory ("tmem"). The policy it implements |
| 8 | * is rudimentary and will likely improve over time, but it does work well |
| 9 | * enough today. |
| 10 | * |
| 11 | * Two functionalities are implemented here which both use "control theory" |
| 12 | * (feedback) to optimize memory utilization. In a virtualized environment |
| 13 | * such as Xen, RAM is often a scarce resource and we would like to ensure |
| 14 | * that each of a possibly large number of virtual machines is using RAM |
| 15 | * efficiently, i.e. using as little as possible when under light load |
| 16 | * and obtaining as much as possible when memory demands are high. |
| 17 | * Since RAM needs vary highly dynamically and sometimes dramatically, |
| 18 | * "hysteresis" is used, that is, memory target is determined not just |
| 19 | * on current data but also on past data stored in the system. |
| 20 | * |
| 21 | * "Selfballooning" creates memory pressure by managing the Xen balloon |
| 22 | * driver to decrease and increase available kernel memory, driven |
| 23 | * largely by the target value of "Committed_AS" (see /proc/meminfo). |
| 24 | * Since Committed_AS does not account for clean mapped pages (i.e. pages |
| 25 | * in RAM that are identical to pages on disk), selfballooning has the |
| 26 | * affect of pushing less frequently used clean pagecache pages out of |
| 27 | * kernel RAM and, presumably using cleancache, into Xen tmem where |
| 28 | * Xen can more efficiently optimize RAM utilization for such pages. |
| 29 | * |
| 30 | * When kernel memory demand unexpectedly increases faster than Xen, via |
| 31 | * the selfballoon driver, is able to (or chooses to) provide usable RAM, |
| 32 | * the kernel may invoke swapping. In most cases, frontswap is able |
| 33 | * to absorb this swapping into Xen tmem. However, due to the fact |
| 34 | * that the kernel swap subsystem assumes swapping occurs to a disk, |
| 35 | * swapped pages may sit on the disk for a very long time; even if |
| 36 | * the kernel knows the page will never be used again. This is because |
| 37 | * the disk space costs very little and can be overwritten when |
| 38 | * necessary. When such stale pages are in frontswap, however, they |
| 39 | * are taking up valuable real estate. "Frontswap selfshrinking" works |
| 40 | * to resolve this: When frontswap activity is otherwise stable |
| 41 | * and the guest kernel is not under memory pressure, the "frontswap |
| 42 | * selfshrinking" accounts for this by providing pressure to remove some |
| 43 | * pages from frontswap and return them to kernel memory. |
| 44 | * |
| 45 | * For both "selfballooning" and "frontswap-selfshrinking", a worker |
| 46 | * thread is used and sysfs tunables are provided to adjust the frequency |
| 47 | * and rate of adjustments to achieve the goal, as well as to disable one |
| 48 | * or both functions independently. |
| 49 | * |
| 50 | * While some argue that this functionality can and should be implemented |
| 51 | * in userspace, it has been observed that bad things happen (e.g. OOMs). |
| 52 | * |
| 53 | * System configuration note: Selfballooning should not be enabled on |
| 54 | * systems without a sufficiently large swap device configured; for best |
| 55 | * results, it is recommended that total swap be increased by the size |
| 56 | * of the guest memory. Also, while technically not required to be |
| 57 | * configured, it is highly recommended that frontswap also be configured |
| 58 | * and enabled when selfballooning is running. So, selfballooning |
| 59 | * is disabled by default if frontswap is not configured and can only |
| 60 | * be enabled with the "selfballooning" kernel boot option; similarly |
| 61 | * selfballooning is enabled by default if frontswap is configured and |
| 62 | * can be disabled with the "noselfballooning" kernel boot option. Finally, |
| 63 | * when frontswap is configured, frontswap-selfshrinking can be disabled |
| 64 | * with the "noselfshrink" kernel boot option. |
| 65 | * |
| 66 | * Selfballooning is disallowed in domain0 and force-disabled. |
| 67 | * |
| 68 | */ |
| 69 | |
| 70 | #include <linux/kernel.h> |
Dan Magenheimer | 38a1ed4 | 2011-09-27 08:47:58 -0600 | [diff] [blame] | 71 | #include <linux/bootmem.h> |
| 72 | #include <linux/swap.h> |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 73 | #include <linux/mm.h> |
| 74 | #include <linux/mman.h> |
Randy Dunlap | 4fec0e0 | 2011-08-15 21:41:43 -0700 | [diff] [blame] | 75 | #include <linux/module.h> |
Konrad Rzeszutek Wilk | 0642d2e | 2011-07-22 14:01:16 -0400 | [diff] [blame] | 76 | #include <linux/workqueue.h> |
Greg Kroah-Hartman | cb0c05c | 2011-12-15 11:07:02 -0800 | [diff] [blame] | 77 | #include <linux/device.h> |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 78 | #include <xen/balloon.h> |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 79 | #include <xen/tmem.h> |
Konrad Rzeszutek Wilk | 0642d2e | 2011-07-22 14:01:16 -0400 | [diff] [blame] | 80 | #include <xen/xen.h> |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 81 | |
| 82 | /* Enable/disable with sysfs. */ |
| 83 | static int xen_selfballooning_enabled __read_mostly; |
| 84 | |
| 85 | /* |
| 86 | * Controls rate at which memory target (this iteration) approaches |
| 87 | * ultimate goal when memory need is increasing (up-hysteresis) or |
| 88 | * decreasing (down-hysteresis). Higher values of hysteresis cause |
| 89 | * slower increases/decreases. The default values for the various |
| 90 | * parameters were deemed reasonable by experimentation, may be |
| 91 | * workload-dependent, and can all be adjusted via sysfs. |
| 92 | */ |
| 93 | static unsigned int selfballoon_downhysteresis __read_mostly = 8; |
| 94 | static unsigned int selfballoon_uphysteresis __read_mostly = 1; |
| 95 | |
| 96 | /* In HZ, controls frequency of worker invocation. */ |
| 97 | static unsigned int selfballoon_interval __read_mostly = 5; |
| 98 | |
Dan Magenheimer | 38a1ed4 | 2011-09-27 08:47:58 -0600 | [diff] [blame] | 99 | /* |
| 100 | * Minimum usable RAM in MB for selfballooning target for balloon. |
| 101 | * If non-zero, it is added to totalreserve_pages and self-ballooning |
| 102 | * will not balloon below the sum. If zero, a piecewise linear function |
| 103 | * is calculated as a minimum and added to totalreserve_pages. Note that |
| 104 | * setting this value indiscriminately may cause OOMs and crashes. |
| 105 | */ |
| 106 | static unsigned int selfballoon_min_usable_mb; |
| 107 | |
Jana Saout | d79d595 | 2012-05-15 12:34:46 +0200 | [diff] [blame] | 108 | /* |
| 109 | * Amount of RAM in MB to add to the target number of pages. |
| 110 | * Can be used to reserve some more room for caches and the like. |
| 111 | */ |
| 112 | static unsigned int selfballoon_reserved_mb; |
| 113 | |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 114 | static void selfballoon_process(struct work_struct *work); |
| 115 | static DECLARE_DELAYED_WORK(selfballoon_worker, selfballoon_process); |
| 116 | |
| 117 | #ifdef CONFIG_FRONTSWAP |
| 118 | #include <linux/frontswap.h> |
| 119 | |
| 120 | /* Enable/disable with sysfs. */ |
| 121 | static bool frontswap_selfshrinking __read_mostly; |
| 122 | |
| 123 | /* Enable/disable with kernel boot option. */ |
| 124 | static bool use_frontswap_selfshrink __initdata = true; |
| 125 | |
| 126 | /* |
| 127 | * The default values for the following parameters were deemed reasonable |
| 128 | * by experimentation, may be workload-dependent, and can all be |
| 129 | * adjusted via sysfs. |
| 130 | */ |
| 131 | |
| 132 | /* Control rate for frontswap shrinking. Higher hysteresis is slower. */ |
| 133 | static unsigned int frontswap_hysteresis __read_mostly = 20; |
| 134 | |
| 135 | /* |
| 136 | * Number of selfballoon worker invocations to wait before observing that |
| 137 | * frontswap selfshrinking should commence. Note that selfshrinking does |
| 138 | * not use a separate worker thread. |
| 139 | */ |
| 140 | static unsigned int frontswap_inertia __read_mostly = 3; |
| 141 | |
| 142 | /* Countdown to next invocation of frontswap_shrink() */ |
| 143 | static unsigned long frontswap_inertia_counter; |
| 144 | |
| 145 | /* |
| 146 | * Invoked by the selfballoon worker thread, uses current number of pages |
| 147 | * in frontswap (frontswap_curr_pages()), previous status, and control |
| 148 | * values (hysteresis and inertia) to determine if frontswap should be |
| 149 | * shrunk and what the new frontswap size should be. Note that |
| 150 | * frontswap_shrink is essentially a partial swapoff that immediately |
| 151 | * transfers pages from the "swap device" (frontswap) back into kernel |
| 152 | * RAM; despite the name, frontswap "shrinking" is very different from |
| 153 | * the "shrinker" interface used by the kernel MM subsystem to reclaim |
| 154 | * memory. |
| 155 | */ |
| 156 | static void frontswap_selfshrink(void) |
| 157 | { |
| 158 | static unsigned long cur_frontswap_pages; |
| 159 | static unsigned long last_frontswap_pages; |
| 160 | static unsigned long tgt_frontswap_pages; |
| 161 | |
| 162 | last_frontswap_pages = cur_frontswap_pages; |
| 163 | cur_frontswap_pages = frontswap_curr_pages(); |
| 164 | if (!cur_frontswap_pages || |
| 165 | (cur_frontswap_pages > last_frontswap_pages)) { |
| 166 | frontswap_inertia_counter = frontswap_inertia; |
| 167 | return; |
| 168 | } |
| 169 | if (frontswap_inertia_counter && --frontswap_inertia_counter) |
| 170 | return; |
| 171 | if (cur_frontswap_pages <= frontswap_hysteresis) |
| 172 | tgt_frontswap_pages = 0; |
| 173 | else |
| 174 | tgt_frontswap_pages = cur_frontswap_pages - |
| 175 | (cur_frontswap_pages / frontswap_hysteresis); |
| 176 | frontswap_shrink(tgt_frontswap_pages); |
| 177 | } |
| 178 | |
| 179 | static int __init xen_nofrontswap_selfshrink_setup(char *s) |
| 180 | { |
| 181 | use_frontswap_selfshrink = false; |
| 182 | return 1; |
| 183 | } |
| 184 | |
| 185 | __setup("noselfshrink", xen_nofrontswap_selfshrink_setup); |
| 186 | |
| 187 | /* Disable with kernel boot option. */ |
| 188 | static bool use_selfballooning __initdata = true; |
| 189 | |
| 190 | static int __init xen_noselfballooning_setup(char *s) |
| 191 | { |
| 192 | use_selfballooning = false; |
| 193 | return 1; |
| 194 | } |
| 195 | |
| 196 | __setup("noselfballooning", xen_noselfballooning_setup); |
| 197 | #else /* !CONFIG_FRONTSWAP */ |
| 198 | /* Enable with kernel boot option. */ |
| 199 | static bool use_selfballooning __initdata = false; |
| 200 | |
| 201 | static int __init xen_selfballooning_setup(char *s) |
| 202 | { |
| 203 | use_selfballooning = true; |
| 204 | return 1; |
| 205 | } |
| 206 | |
| 207 | __setup("selfballooning", xen_selfballooning_setup); |
| 208 | #endif /* CONFIG_FRONTSWAP */ |
| 209 | |
Dan Magenheimer | 38a1ed4 | 2011-09-27 08:47:58 -0600 | [diff] [blame] | 210 | #define MB2PAGES(mb) ((mb) << (20 - PAGE_SHIFT)) |
| 211 | |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 212 | /* |
| 213 | * Use current balloon size, the goal (vm_committed_as), and hysteresis |
| 214 | * parameters to set a new target balloon size |
| 215 | */ |
| 216 | static void selfballoon_process(struct work_struct *work) |
| 217 | { |
Dan Magenheimer | 38a1ed4 | 2011-09-27 08:47:58 -0600 | [diff] [blame] | 218 | unsigned long cur_pages, goal_pages, tgt_pages, floor_pages; |
| 219 | unsigned long useful_pages; |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 220 | bool reset_timer = false; |
| 221 | |
| 222 | if (xen_selfballooning_enabled) { |
Dan Magenheimer | 38a1ed4 | 2011-09-27 08:47:58 -0600 | [diff] [blame] | 223 | cur_pages = totalram_pages; |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 224 | tgt_pages = cur_pages; /* default is no change */ |
| 225 | goal_pages = percpu_counter_read_positive(&vm_committed_as) + |
Jana Saout | d79d595 | 2012-05-15 12:34:46 +0200 | [diff] [blame] | 226 | totalreserve_pages + |
| 227 | MB2PAGES(selfballoon_reserved_mb); |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 228 | #ifdef CONFIG_FRONTSWAP |
| 229 | /* allow space for frontswap pages to be repatriated */ |
| 230 | if (frontswap_selfshrinking && frontswap_enabled) |
| 231 | goal_pages += frontswap_curr_pages(); |
| 232 | #endif |
| 233 | if (cur_pages > goal_pages) |
| 234 | tgt_pages = cur_pages - |
| 235 | ((cur_pages - goal_pages) / |
| 236 | selfballoon_downhysteresis); |
| 237 | else if (cur_pages < goal_pages) |
| 238 | tgt_pages = cur_pages + |
| 239 | ((goal_pages - cur_pages) / |
| 240 | selfballoon_uphysteresis); |
| 241 | /* else if cur_pages == goal_pages, no change */ |
Dan Magenheimer | 38a1ed4 | 2011-09-27 08:47:58 -0600 | [diff] [blame] | 242 | useful_pages = max_pfn - totalreserve_pages; |
| 243 | if (selfballoon_min_usable_mb != 0) |
| 244 | floor_pages = totalreserve_pages + |
| 245 | MB2PAGES(selfballoon_min_usable_mb); |
| 246 | /* piecewise linear function ending in ~3% slope */ |
| 247 | else if (useful_pages < MB2PAGES(16)) |
| 248 | floor_pages = max_pfn; /* not worth ballooning */ |
| 249 | else if (useful_pages < MB2PAGES(64)) |
| 250 | floor_pages = totalreserve_pages + MB2PAGES(16) + |
| 251 | ((useful_pages - MB2PAGES(16)) >> 1); |
| 252 | else if (useful_pages < MB2PAGES(512)) |
| 253 | floor_pages = totalreserve_pages + MB2PAGES(40) + |
| 254 | ((useful_pages - MB2PAGES(40)) >> 3); |
| 255 | else /* useful_pages >= MB2PAGES(512) */ |
| 256 | floor_pages = totalreserve_pages + MB2PAGES(99) + |
| 257 | ((useful_pages - MB2PAGES(99)) >> 5); |
| 258 | if (tgt_pages < floor_pages) |
| 259 | tgt_pages = floor_pages; |
| 260 | balloon_set_new_target(tgt_pages + |
| 261 | balloon_stats.current_pages - totalram_pages); |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 262 | reset_timer = true; |
| 263 | } |
| 264 | #ifdef CONFIG_FRONTSWAP |
| 265 | if (frontswap_selfshrinking && frontswap_enabled) { |
| 266 | frontswap_selfshrink(); |
| 267 | reset_timer = true; |
| 268 | } |
| 269 | #endif |
| 270 | if (reset_timer) |
| 271 | schedule_delayed_work(&selfballoon_worker, |
| 272 | selfballoon_interval * HZ); |
| 273 | } |
| 274 | |
| 275 | #ifdef CONFIG_SYSFS |
| 276 | |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 277 | #include <linux/capability.h> |
| 278 | |
| 279 | #define SELFBALLOON_SHOW(name, format, args...) \ |
Kay Sievers | 0706802 | 2011-12-14 15:32:50 -0800 | [diff] [blame] | 280 | static ssize_t show_##name(struct device *dev, \ |
| 281 | struct device_attribute *attr, \ |
| 282 | char *buf) \ |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 283 | { \ |
| 284 | return sprintf(buf, format, ##args); \ |
| 285 | } |
| 286 | |
| 287 | SELFBALLOON_SHOW(selfballooning, "%d\n", xen_selfballooning_enabled); |
| 288 | |
Kay Sievers | 0706802 | 2011-12-14 15:32:50 -0800 | [diff] [blame] | 289 | static ssize_t store_selfballooning(struct device *dev, |
| 290 | struct device_attribute *attr, |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 291 | const char *buf, |
| 292 | size_t count) |
| 293 | { |
| 294 | bool was_enabled = xen_selfballooning_enabled; |
| 295 | unsigned long tmp; |
| 296 | int err; |
| 297 | |
| 298 | if (!capable(CAP_SYS_ADMIN)) |
| 299 | return -EPERM; |
| 300 | |
| 301 | err = strict_strtoul(buf, 10, &tmp); |
| 302 | if (err || ((tmp != 0) && (tmp != 1))) |
| 303 | return -EINVAL; |
| 304 | |
| 305 | xen_selfballooning_enabled = !!tmp; |
| 306 | if (!was_enabled && xen_selfballooning_enabled) |
| 307 | schedule_delayed_work(&selfballoon_worker, |
| 308 | selfballoon_interval * HZ); |
| 309 | |
| 310 | return count; |
| 311 | } |
| 312 | |
Kay Sievers | 0706802 | 2011-12-14 15:32:50 -0800 | [diff] [blame] | 313 | static DEVICE_ATTR(selfballooning, S_IRUGO | S_IWUSR, |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 314 | show_selfballooning, store_selfballooning); |
| 315 | |
| 316 | SELFBALLOON_SHOW(selfballoon_interval, "%d\n", selfballoon_interval); |
| 317 | |
Kay Sievers | 0706802 | 2011-12-14 15:32:50 -0800 | [diff] [blame] | 318 | static ssize_t store_selfballoon_interval(struct device *dev, |
| 319 | struct device_attribute *attr, |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 320 | const char *buf, |
| 321 | size_t count) |
| 322 | { |
| 323 | unsigned long val; |
| 324 | int err; |
| 325 | |
| 326 | if (!capable(CAP_SYS_ADMIN)) |
| 327 | return -EPERM; |
| 328 | err = strict_strtoul(buf, 10, &val); |
| 329 | if (err || val == 0) |
| 330 | return -EINVAL; |
| 331 | selfballoon_interval = val; |
| 332 | return count; |
| 333 | } |
| 334 | |
Kay Sievers | 0706802 | 2011-12-14 15:32:50 -0800 | [diff] [blame] | 335 | static DEVICE_ATTR(selfballoon_interval, S_IRUGO | S_IWUSR, |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 336 | show_selfballoon_interval, store_selfballoon_interval); |
| 337 | |
| 338 | SELFBALLOON_SHOW(selfballoon_downhys, "%d\n", selfballoon_downhysteresis); |
| 339 | |
Kay Sievers | 0706802 | 2011-12-14 15:32:50 -0800 | [diff] [blame] | 340 | static ssize_t store_selfballoon_downhys(struct device *dev, |
| 341 | struct device_attribute *attr, |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 342 | const char *buf, |
| 343 | size_t count) |
| 344 | { |
| 345 | unsigned long val; |
| 346 | int err; |
| 347 | |
| 348 | if (!capable(CAP_SYS_ADMIN)) |
| 349 | return -EPERM; |
| 350 | err = strict_strtoul(buf, 10, &val); |
| 351 | if (err || val == 0) |
| 352 | return -EINVAL; |
| 353 | selfballoon_downhysteresis = val; |
| 354 | return count; |
| 355 | } |
| 356 | |
Kay Sievers | 0706802 | 2011-12-14 15:32:50 -0800 | [diff] [blame] | 357 | static DEVICE_ATTR(selfballoon_downhysteresis, S_IRUGO | S_IWUSR, |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 358 | show_selfballoon_downhys, store_selfballoon_downhys); |
| 359 | |
| 360 | |
| 361 | SELFBALLOON_SHOW(selfballoon_uphys, "%d\n", selfballoon_uphysteresis); |
| 362 | |
Kay Sievers | 0706802 | 2011-12-14 15:32:50 -0800 | [diff] [blame] | 363 | static ssize_t store_selfballoon_uphys(struct device *dev, |
| 364 | struct device_attribute *attr, |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 365 | const char *buf, |
| 366 | size_t count) |
| 367 | { |
| 368 | unsigned long val; |
| 369 | int err; |
| 370 | |
| 371 | if (!capable(CAP_SYS_ADMIN)) |
| 372 | return -EPERM; |
| 373 | err = strict_strtoul(buf, 10, &val); |
| 374 | if (err || val == 0) |
| 375 | return -EINVAL; |
| 376 | selfballoon_uphysteresis = val; |
| 377 | return count; |
| 378 | } |
| 379 | |
Kay Sievers | 0706802 | 2011-12-14 15:32:50 -0800 | [diff] [blame] | 380 | static DEVICE_ATTR(selfballoon_uphysteresis, S_IRUGO | S_IWUSR, |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 381 | show_selfballoon_uphys, store_selfballoon_uphys); |
| 382 | |
Dan Magenheimer | 38a1ed4 | 2011-09-27 08:47:58 -0600 | [diff] [blame] | 383 | SELFBALLOON_SHOW(selfballoon_min_usable_mb, "%d\n", |
| 384 | selfballoon_min_usable_mb); |
| 385 | |
Kay Sievers | 0706802 | 2011-12-14 15:32:50 -0800 | [diff] [blame] | 386 | static ssize_t store_selfballoon_min_usable_mb(struct device *dev, |
| 387 | struct device_attribute *attr, |
Dan Magenheimer | 38a1ed4 | 2011-09-27 08:47:58 -0600 | [diff] [blame] | 388 | const char *buf, |
| 389 | size_t count) |
| 390 | { |
| 391 | unsigned long val; |
| 392 | int err; |
| 393 | |
| 394 | if (!capable(CAP_SYS_ADMIN)) |
| 395 | return -EPERM; |
| 396 | err = strict_strtoul(buf, 10, &val); |
| 397 | if (err || val == 0) |
| 398 | return -EINVAL; |
| 399 | selfballoon_min_usable_mb = val; |
| 400 | return count; |
| 401 | } |
| 402 | |
Kay Sievers | 0706802 | 2011-12-14 15:32:50 -0800 | [diff] [blame] | 403 | static DEVICE_ATTR(selfballoon_min_usable_mb, S_IRUGO | S_IWUSR, |
Dan Magenheimer | 38a1ed4 | 2011-09-27 08:47:58 -0600 | [diff] [blame] | 404 | show_selfballoon_min_usable_mb, |
| 405 | store_selfballoon_min_usable_mb); |
| 406 | |
Jana Saout | d79d595 | 2012-05-15 12:34:46 +0200 | [diff] [blame] | 407 | SELFBALLOON_SHOW(selfballoon_reserved_mb, "%d\n", |
| 408 | selfballoon_reserved_mb); |
| 409 | |
| 410 | static ssize_t store_selfballoon_reserved_mb(struct device *dev, |
| 411 | struct device_attribute *attr, |
| 412 | const char *buf, |
| 413 | size_t count) |
| 414 | { |
| 415 | unsigned long val; |
| 416 | int err; |
| 417 | |
| 418 | if (!capable(CAP_SYS_ADMIN)) |
| 419 | return -EPERM; |
| 420 | err = strict_strtoul(buf, 10, &val); |
| 421 | if (err || val == 0) |
| 422 | return -EINVAL; |
| 423 | selfballoon_reserved_mb = val; |
| 424 | return count; |
| 425 | } |
| 426 | |
| 427 | static DEVICE_ATTR(selfballoon_reserved_mb, S_IRUGO | S_IWUSR, |
| 428 | show_selfballoon_reserved_mb, |
| 429 | store_selfballoon_reserved_mb); |
| 430 | |
Dan Magenheimer | 38a1ed4 | 2011-09-27 08:47:58 -0600 | [diff] [blame] | 431 | |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 432 | #ifdef CONFIG_FRONTSWAP |
| 433 | SELFBALLOON_SHOW(frontswap_selfshrinking, "%d\n", frontswap_selfshrinking); |
| 434 | |
Kay Sievers | 0706802 | 2011-12-14 15:32:50 -0800 | [diff] [blame] | 435 | static ssize_t store_frontswap_selfshrinking(struct device *dev, |
| 436 | struct device_attribute *attr, |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 437 | const char *buf, |
| 438 | size_t count) |
| 439 | { |
| 440 | bool was_enabled = frontswap_selfshrinking; |
| 441 | unsigned long tmp; |
| 442 | int err; |
| 443 | |
| 444 | if (!capable(CAP_SYS_ADMIN)) |
| 445 | return -EPERM; |
| 446 | err = strict_strtoul(buf, 10, &tmp); |
| 447 | if (err || ((tmp != 0) && (tmp != 1))) |
| 448 | return -EINVAL; |
| 449 | frontswap_selfshrinking = !!tmp; |
| 450 | if (!was_enabled && !xen_selfballooning_enabled && |
| 451 | frontswap_selfshrinking) |
| 452 | schedule_delayed_work(&selfballoon_worker, |
| 453 | selfballoon_interval * HZ); |
| 454 | |
| 455 | return count; |
| 456 | } |
| 457 | |
Kay Sievers | 0706802 | 2011-12-14 15:32:50 -0800 | [diff] [blame] | 458 | static DEVICE_ATTR(frontswap_selfshrinking, S_IRUGO | S_IWUSR, |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 459 | show_frontswap_selfshrinking, store_frontswap_selfshrinking); |
| 460 | |
| 461 | SELFBALLOON_SHOW(frontswap_inertia, "%d\n", frontswap_inertia); |
| 462 | |
Kay Sievers | 0706802 | 2011-12-14 15:32:50 -0800 | [diff] [blame] | 463 | static ssize_t store_frontswap_inertia(struct device *dev, |
| 464 | struct device_attribute *attr, |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 465 | const char *buf, |
| 466 | size_t count) |
| 467 | { |
| 468 | unsigned long val; |
| 469 | int err; |
| 470 | |
| 471 | if (!capable(CAP_SYS_ADMIN)) |
| 472 | return -EPERM; |
| 473 | err = strict_strtoul(buf, 10, &val); |
| 474 | if (err || val == 0) |
| 475 | return -EINVAL; |
| 476 | frontswap_inertia = val; |
| 477 | frontswap_inertia_counter = val; |
| 478 | return count; |
| 479 | } |
| 480 | |
Kay Sievers | 0706802 | 2011-12-14 15:32:50 -0800 | [diff] [blame] | 481 | static DEVICE_ATTR(frontswap_inertia, S_IRUGO | S_IWUSR, |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 482 | show_frontswap_inertia, store_frontswap_inertia); |
| 483 | |
| 484 | SELFBALLOON_SHOW(frontswap_hysteresis, "%d\n", frontswap_hysteresis); |
| 485 | |
Kay Sievers | 0706802 | 2011-12-14 15:32:50 -0800 | [diff] [blame] | 486 | static ssize_t store_frontswap_hysteresis(struct device *dev, |
| 487 | struct device_attribute *attr, |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 488 | const char *buf, |
| 489 | size_t count) |
| 490 | { |
| 491 | unsigned long val; |
| 492 | int err; |
| 493 | |
| 494 | if (!capable(CAP_SYS_ADMIN)) |
| 495 | return -EPERM; |
| 496 | err = strict_strtoul(buf, 10, &val); |
| 497 | if (err || val == 0) |
| 498 | return -EINVAL; |
| 499 | frontswap_hysteresis = val; |
| 500 | return count; |
| 501 | } |
| 502 | |
Kay Sievers | 0706802 | 2011-12-14 15:32:50 -0800 | [diff] [blame] | 503 | static DEVICE_ATTR(frontswap_hysteresis, S_IRUGO | S_IWUSR, |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 504 | show_frontswap_hysteresis, store_frontswap_hysteresis); |
| 505 | |
| 506 | #endif /* CONFIG_FRONTSWAP */ |
| 507 | |
| 508 | static struct attribute *selfballoon_attrs[] = { |
Kay Sievers | 0706802 | 2011-12-14 15:32:50 -0800 | [diff] [blame] | 509 | &dev_attr_selfballooning.attr, |
| 510 | &dev_attr_selfballoon_interval.attr, |
| 511 | &dev_attr_selfballoon_downhysteresis.attr, |
| 512 | &dev_attr_selfballoon_uphysteresis.attr, |
| 513 | &dev_attr_selfballoon_min_usable_mb.attr, |
Jana Saout | d79d595 | 2012-05-15 12:34:46 +0200 | [diff] [blame] | 514 | &dev_attr_selfballoon_reserved_mb.attr, |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 515 | #ifdef CONFIG_FRONTSWAP |
Kay Sievers | 0706802 | 2011-12-14 15:32:50 -0800 | [diff] [blame] | 516 | &dev_attr_frontswap_selfshrinking.attr, |
| 517 | &dev_attr_frontswap_hysteresis.attr, |
| 518 | &dev_attr_frontswap_inertia.attr, |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 519 | #endif |
| 520 | NULL |
| 521 | }; |
| 522 | |
Jan Beulich | ead1d01 | 2012-03-14 12:34:19 -0400 | [diff] [blame] | 523 | static const struct attribute_group selfballoon_group = { |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 524 | .name = "selfballoon", |
| 525 | .attrs = selfballoon_attrs |
| 526 | }; |
| 527 | #endif |
| 528 | |
Kay Sievers | 0706802 | 2011-12-14 15:32:50 -0800 | [diff] [blame] | 529 | int register_xen_selfballooning(struct device *dev) |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 530 | { |
| 531 | int error = -1; |
| 532 | |
| 533 | #ifdef CONFIG_SYSFS |
Kay Sievers | 0706802 | 2011-12-14 15:32:50 -0800 | [diff] [blame] | 534 | error = sysfs_create_group(&dev->kobj, &selfballoon_group); |
Dan Magenheimer | a50777c | 2011-07-08 12:26:21 -0600 | [diff] [blame] | 535 | #endif |
| 536 | return error; |
| 537 | } |
| 538 | EXPORT_SYMBOL(register_xen_selfballooning); |
| 539 | |
| 540 | static int __init xen_selfballoon_init(void) |
| 541 | { |
| 542 | bool enable = false; |
| 543 | |
| 544 | if (!xen_domain()) |
| 545 | return -ENODEV; |
| 546 | |
| 547 | if (xen_initial_domain()) { |
| 548 | pr_info("xen/balloon: Xen selfballooning driver " |
| 549 | "disabled for domain0.\n"); |
| 550 | return -ENODEV; |
| 551 | } |
| 552 | |
| 553 | xen_selfballooning_enabled = tmem_enabled && use_selfballooning; |
| 554 | if (xen_selfballooning_enabled) { |
| 555 | pr_info("xen/balloon: Initializing Xen " |
| 556 | "selfballooning driver.\n"); |
| 557 | enable = true; |
| 558 | } |
| 559 | #ifdef CONFIG_FRONTSWAP |
| 560 | frontswap_selfshrinking = tmem_enabled && use_frontswap_selfshrink; |
| 561 | if (frontswap_selfshrinking) { |
| 562 | pr_info("xen/balloon: Initializing frontswap " |
| 563 | "selfshrinking driver.\n"); |
| 564 | enable = true; |
| 565 | } |
| 566 | #endif |
| 567 | if (!enable) |
| 568 | return -ENODEV; |
| 569 | |
| 570 | schedule_delayed_work(&selfballoon_worker, selfballoon_interval * HZ); |
| 571 | |
| 572 | return 0; |
| 573 | } |
| 574 | |
| 575 | subsys_initcall(xen_selfballoon_init); |
| 576 | |
| 577 | MODULE_LICENSE("GPL"); |