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, dir: "memory" , node: "target" , fmt: "%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(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(dev: &balloon_dev); |
131 | |
132 | register_xenstore_notifier(nb: &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, fmt: "%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: 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, fmt: "%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(ptr: buf, retptr: &endchar); |
199 | |
200 | balloon_set_new_target(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(subsys: &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(bus: &balloon_subsys); |
260 | return error; |
261 | } |
262 | |
263 | return 0; |
264 | } |
265 | |