]>
Commit | Line | Data |
---|---|---|
803eb047 DDG |
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 | ||
283c0972 JP |
33 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
34 | ||
803eb047 | 35 | #include <linux/kernel.h> |
106eaa8e PG |
36 | #include <linux/errno.h> |
37 | #include <linux/mm_types.h> | |
38 | #include <linux/init.h> | |
803eb047 | 39 | #include <linux/capability.h> |
1d988ed4 | 40 | #include <linux/memory_hotplug.h> |
803eb047 DDG |
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> | |
197ecb38 | 48 | #include <xen/mem-reservation.h> |
803eb047 DDG |
49 | |
50 | #define PAGES2KB(_p) ((_p)<<(PAGE_SHIFT-10)) | |
51 | ||
52 | #define BALLOON_CLASS_NAME "xen_memory" | |
53 | ||
1d988ed4 JG |
54 | #ifdef CONFIG_MEMORY_HOTPLUG |
55 | u64 xen_saved_max_mem_size = 0; | |
56 | #endif | |
57 | ||
07068021 | 58 | static struct device balloon_dev; |
803eb047 | 59 | |
07068021 | 60 | static int register_balloon(struct device *dev); |
803eb047 | 61 | |
803eb047 DDG |
62 | /* React to a change in the target key */ |
63 | static void watch_target(struct xenbus_watch *watch, | |
5584ea25 | 64 | const char *path, const char *token) |
803eb047 | 65 | { |
5266b8e4 | 66 | unsigned long long new_target, static_max; |
803eb047 | 67 | int err; |
96edd61d JG |
68 | static bool watch_fired; |
69 | static long target_diff; | |
803eb047 | 70 | |
1d988ed4 JG |
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 | ||
803eb047 DDG |
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 | */ | |
96edd61d | 86 | new_target >>= PAGE_SHIFT - 10; |
5266b8e4 JG |
87 | |
88 | if (!watch_fired) { | |
89 | watch_fired = true; | |
3aa6c19d BO |
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)) | |
5266b8e4 | 95 | static_max >>= PAGE_SHIFT - 10; |
3aa6c19d BO |
96 | else |
97 | static_max = new_target; | |
98 | ||
3596924a | 99 | target_diff = (xen_pv_domain() || xen_initial_domain()) ? 0 |
5266b8e4 | 100 | : static_max - balloon_stats.target_pages; |
96edd61d JG |
101 | } |
102 | ||
5266b8e4 | 103 | balloon_set_new_target(new_target - target_diff); |
803eb047 | 104 | } |
6b71c52e OH |
105 | static struct xenbus_watch target_watch = { |
106 | .node = "memory/target", | |
107 | .callback = watch_target, | |
108 | }; | |
109 | ||
803eb047 DDG |
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) | |
283c0972 | 119 | pr_err("Failed to set balloon watcher\n"); |
803eb047 DDG |
120 | |
121 | return NOTIFY_DONE; | |
122 | } | |
123 | ||
6b71c52e OH |
124 | static struct notifier_block xenstore_notifier = { |
125 | .notifier_call = balloon_init_watcher, | |
126 | }; | |
803eb047 | 127 | |
96edd61d | 128 | void xen_balloon_init(void) |
803eb047 | 129 | { |
07068021 | 130 | register_balloon(&balloon_dev); |
803eb047 | 131 | |
803eb047 | 132 | register_xenstore_notifier(&xenstore_notifier); |
803eb047 | 133 | } |
96edd61d | 134 | EXPORT_SYMBOL_GPL(xen_balloon_init); |
803eb047 | 135 | |
803eb047 | 136 | #define BALLOON_SHOW(name, format, args...) \ |
07068021 KS |
137 | static ssize_t show_##name(struct device *dev, \ |
138 | struct device_attribute *attr, \ | |
803eb047 DDG |
139 | char *buf) \ |
140 | { \ | |
141 | return sprintf(buf, format, ##args); \ | |
142 | } \ | |
07068021 | 143 | static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL) |
803eb047 DDG |
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 | ||
07068021 KS |
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); | |
197ecb38 | 153 | static DEVICE_BOOL_ATTR(scrub_pages, 0644, xen_scrub_pages); |
803eb047 | 154 | |
07068021 | 155 | static ssize_t show_target_kb(struct device *dev, struct device_attribute *attr, |
803eb047 DDG |
156 | char *buf) |
157 | { | |
158 | return sprintf(buf, "%lu\n", PAGES2KB(balloon_stats.target_pages)); | |
159 | } | |
160 | ||
07068021 KS |
161 | static ssize_t store_target_kb(struct device *dev, |
162 | struct device_attribute *attr, | |
803eb047 DDG |
163 | const char *buf, |
164 | size_t count) | |
165 | { | |
166 | char *endchar; | |
167 | unsigned long long target_bytes; | |
168 | ||
169 | if (!capable(CAP_SYS_ADMIN)) | |
170 | return -EPERM; | |
171 | ||
172 | target_bytes = simple_strtoull(buf, &endchar, 0) * 1024; | |
173 | ||
174 | balloon_set_new_target(target_bytes >> PAGE_SHIFT); | |
175 | ||
176 | return count; | |
177 | } | |
178 | ||
07068021 | 179 | static DEVICE_ATTR(target_kb, S_IRUGO | S_IWUSR, |
803eb047 DDG |
180 | show_target_kb, store_target_kb); |
181 | ||
182 | ||
07068021 | 183 | static ssize_t show_target(struct device *dev, struct device_attribute *attr, |
803eb047 DDG |
184 | char *buf) |
185 | { | |
186 | return sprintf(buf, "%llu\n", | |
187 | (unsigned long long)balloon_stats.target_pages | |
188 | << PAGE_SHIFT); | |
189 | } | |
190 | ||
07068021 KS |
191 | static ssize_t store_target(struct device *dev, |
192 | struct device_attribute *attr, | |
803eb047 DDG |
193 | const char *buf, |
194 | size_t count) | |
195 | { | |
196 | char *endchar; | |
197 | unsigned long long target_bytes; | |
198 | ||
199 | if (!capable(CAP_SYS_ADMIN)) | |
200 | return -EPERM; | |
201 | ||
202 | target_bytes = memparse(buf, &endchar); | |
203 | ||
204 | balloon_set_new_target(target_bytes >> PAGE_SHIFT); | |
205 | ||
206 | return count; | |
207 | } | |
208 | ||
07068021 | 209 | static DEVICE_ATTR(target, S_IRUGO | S_IWUSR, |
803eb047 DDG |
210 | show_target, store_target); |
211 | ||
212 | ||
b6a473a7 TI |
213 | static struct attribute *balloon_attrs[] = { |
214 | &dev_attr_target_kb.attr, | |
215 | &dev_attr_target.attr, | |
216 | &dev_attr_schedule_delay.attr.attr, | |
217 | &dev_attr_max_schedule_delay.attr.attr, | |
218 | &dev_attr_retry_count.attr.attr, | |
219 | &dev_attr_max_retry_count.attr.attr, | |
197ecb38 | 220 | &dev_attr_scrub_pages.attr.attr, |
b6a473a7 TI |
221 | NULL |
222 | }; | |
223 | ||
224 | static const struct attribute_group balloon_group = { | |
225 | .attrs = balloon_attrs | |
803eb047 DDG |
226 | }; |
227 | ||
228 | static struct attribute *balloon_info_attrs[] = { | |
07068021 KS |
229 | &dev_attr_current_kb.attr, |
230 | &dev_attr_low_kb.attr, | |
231 | &dev_attr_high_kb.attr, | |
803eb047 DDG |
232 | NULL |
233 | }; | |
234 | ||
ead1d014 | 235 | static const struct attribute_group balloon_info_group = { |
803eb047 DDG |
236 | .name = "info", |
237 | .attrs = balloon_info_attrs | |
238 | }; | |
239 | ||
b6a473a7 TI |
240 | static const struct attribute_group *balloon_groups[] = { |
241 | &balloon_group, | |
242 | &balloon_info_group, | |
243 | NULL | |
244 | }; | |
245 | ||
07068021 KS |
246 | static struct bus_type balloon_subsys = { |
247 | .name = BALLOON_CLASS_NAME, | |
248 | .dev_name = BALLOON_CLASS_NAME, | |
803eb047 DDG |
249 | }; |
250 | ||
07068021 | 251 | static int register_balloon(struct device *dev) |
803eb047 | 252 | { |
b6a473a7 | 253 | int error; |
803eb047 | 254 | |
8ea11f7f | 255 | error = subsys_system_register(&balloon_subsys, NULL); |
803eb047 DDG |
256 | if (error) |
257 | return error; | |
258 | ||
07068021 KS |
259 | dev->id = 0; |
260 | dev->bus = &balloon_subsys; | |
b6a473a7 | 261 | dev->groups = balloon_groups; |
803eb047 | 262 | |
07068021 | 263 | error = device_register(dev); |
803eb047 | 264 | if (error) { |
07068021 | 265 | bus_unregister(&balloon_subsys); |
803eb047 DDG |
266 | return error; |
267 | } | |
268 | ||
803eb047 | 269 | return 0; |
803eb047 | 270 | } |