]>
Commit | Line | Data |
---|---|---|
0efe406c JH |
1 | /* |
2 | * s390 storage key device | |
3 | * | |
4 | * Copyright 2015 IBM Corp. | |
5 | * Author(s): Jason J. Herne <jjherne@linux.vnet.ibm.com> | |
6 | * | |
7 | * This work is licensed under the terms of the GNU GPL, version 2 or (at | |
8 | * your option) any later version. See the COPYING file in the top-level | |
9 | * directory. | |
10 | */ | |
11 | ||
9615495a | 12 | #include "qemu/osdep.h" |
0efe406c | 13 | #include "hw/boards.h" |
7ee0c3e3 | 14 | #include "qmp-commands.h" |
186208fa | 15 | #include "migration/qemu-file.h" |
0efe406c JH |
16 | #include "hw/s390x/storage-keys.h" |
17 | #include "qemu/error-report.h" | |
18 | ||
7ee0c3e3 | 19 | #define S390_SKEYS_BUFFER_SIZE 131072 /* Room for 128k storage keys */ |
186208fa JH |
20 | #define S390_SKEYS_SAVE_FLAG_EOS 0x01 |
21 | #define S390_SKEYS_SAVE_FLAG_SKEYS 0x02 | |
22 | #define S390_SKEYS_SAVE_FLAG_ERROR 0x04 | |
7ee0c3e3 | 23 | |
0efe406c JH |
24 | S390SKeysState *s390_get_skeys_device(void) |
25 | { | |
26 | S390SKeysState *ss; | |
27 | ||
28 | ss = S390_SKEYS(object_resolve_path_type("", TYPE_S390_SKEYS, NULL)); | |
29 | assert(ss); | |
30 | return ss; | |
31 | } | |
32 | ||
33 | void s390_skeys_init(void) | |
34 | { | |
35 | Object *obj; | |
36 | ||
37 | if (kvm_enabled()) { | |
38 | obj = object_new(TYPE_KVM_S390_SKEYS); | |
39 | } else { | |
40 | obj = object_new(TYPE_QEMU_S390_SKEYS); | |
41 | } | |
42 | object_property_add_child(qdev_get_machine(), TYPE_S390_SKEYS, | |
43 | obj, NULL); | |
44 | object_unref(obj); | |
45 | ||
46 | qdev_init_nofail(DEVICE(obj)); | |
47 | } | |
48 | ||
7ee0c3e3 JH |
49 | static void write_keys(QEMUFile *f, uint8_t *keys, uint64_t startgfn, |
50 | uint64_t count, Error **errp) | |
51 | { | |
52 | uint64_t curpage = startgfn; | |
53 | uint64_t maxpage = curpage + count - 1; | |
54 | const char *fmt = "page=%03" PRIx64 ": key(%d) => ACC=%X, FP=%d, REF=%d," | |
55 | " ch=%d, reserved=%d\n"; | |
56 | char buf[128]; | |
57 | int len; | |
58 | ||
59 | for (; curpage <= maxpage; curpage++) { | |
60 | uint8_t acc = (*keys & 0xF0) >> 4; | |
61 | int fp = (*keys & 0x08); | |
62 | int ref = (*keys & 0x04); | |
63 | int ch = (*keys & 0x02); | |
64 | int res = (*keys & 0x01); | |
65 | ||
66 | len = snprintf(buf, sizeof(buf), fmt, curpage, | |
67 | *keys, acc, fp, ref, ch, res); | |
68 | assert(len < sizeof(buf)); | |
69 | qemu_put_buffer(f, (uint8_t *)buf, len); | |
70 | keys++; | |
71 | } | |
72 | } | |
73 | ||
a08f0081 JH |
74 | void hmp_info_skeys(Monitor *mon, const QDict *qdict) |
75 | { | |
76 | S390SKeysState *ss = s390_get_skeys_device(); | |
77 | S390SKeysClass *skeyclass = S390_SKEYS_GET_CLASS(ss); | |
78 | uint64_t addr = qdict_get_int(qdict, "addr"); | |
79 | uint8_t key; | |
80 | int r; | |
81 | ||
82 | /* Quick check to see if guest is using storage keys*/ | |
83 | if (!skeyclass->skeys_enabled(ss)) { | |
84 | monitor_printf(mon, "Error: This guest is not using storage keys\n"); | |
85 | return; | |
86 | } | |
87 | ||
88 | r = skeyclass->get_skeys(ss, addr / TARGET_PAGE_SIZE, 1, &key); | |
89 | if (r < 0) { | |
90 | monitor_printf(mon, "Error: %s\n", strerror(-r)); | |
91 | return; | |
92 | } | |
93 | ||
94 | monitor_printf(mon, " key: 0x%X\n", key); | |
95 | } | |
96 | ||
a4538a5c JH |
97 | void hmp_dump_skeys(Monitor *mon, const QDict *qdict) |
98 | { | |
99 | const char *filename = qdict_get_str(qdict, "filename"); | |
100 | Error *err = NULL; | |
101 | ||
102 | qmp_dump_skeys(filename, &err); | |
103 | if (err) { | |
193227f9 | 104 | error_report_err(err); |
a4538a5c JH |
105 | } |
106 | } | |
107 | ||
7ee0c3e3 JH |
108 | void qmp_dump_skeys(const char *filename, Error **errp) |
109 | { | |
110 | S390SKeysState *ss = s390_get_skeys_device(); | |
111 | S390SKeysClass *skeyclass = S390_SKEYS_GET_CLASS(ss); | |
112 | const uint64_t total_count = ram_size / TARGET_PAGE_SIZE; | |
113 | uint64_t handled_count = 0, cur_count; | |
114 | Error *lerr = NULL; | |
115 | vaddr cur_gfn = 0; | |
116 | uint8_t *buf; | |
117 | int ret; | |
118 | QEMUFile *f; | |
119 | ||
120 | /* Quick check to see if guest is using storage keys*/ | |
121 | if (!skeyclass->skeys_enabled(ss)) { | |
122 | error_setg(errp, "This guest is not using storage keys - " | |
123 | "nothing to dump"); | |
124 | return; | |
125 | } | |
126 | ||
127 | f = qemu_fopen(filename, "wb"); | |
128 | if (!f) { | |
129 | error_setg_file_open(errp, errno, filename); | |
130 | return; | |
131 | } | |
132 | ||
133 | buf = g_try_malloc(S390_SKEYS_BUFFER_SIZE); | |
134 | if (!buf) { | |
135 | error_setg(errp, "Could not allocate memory"); | |
136 | goto out; | |
137 | } | |
138 | ||
139 | /* we'll only dump initial memory for now */ | |
140 | while (handled_count < total_count) { | |
141 | /* Calculate how many keys to ask for & handle overflow case */ | |
142 | cur_count = MIN(total_count - handled_count, S390_SKEYS_BUFFER_SIZE); | |
143 | ||
144 | ret = skeyclass->get_skeys(ss, cur_gfn, cur_count, buf); | |
145 | if (ret < 0) { | |
146 | error_setg(errp, "get_keys error %d", ret); | |
147 | goto out_free; | |
148 | } | |
149 | ||
150 | /* write keys to stream */ | |
151 | write_keys(f, buf, cur_gfn, cur_count, &lerr); | |
152 | if (lerr) { | |
153 | goto out_free; | |
154 | } | |
155 | ||
156 | cur_gfn += cur_count; | |
157 | handled_count += cur_count; | |
158 | } | |
159 | ||
160 | out_free: | |
161 | error_propagate(errp, lerr); | |
162 | g_free(buf); | |
163 | out: | |
164 | qemu_fclose(f); | |
165 | } | |
166 | ||
0efe406c JH |
167 | static void qemu_s390_skeys_init(Object *obj) |
168 | { | |
169 | QEMUS390SKeysState *skeys = QEMU_S390_SKEYS(obj); | |
170 | MachineState *machine = MACHINE(qdev_get_machine()); | |
171 | ||
172 | skeys->key_count = machine->maxram_size / TARGET_PAGE_SIZE; | |
173 | skeys->keydata = g_malloc0(skeys->key_count); | |
174 | } | |
175 | ||
176 | static int qemu_s390_skeys_enabled(S390SKeysState *ss) | |
177 | { | |
178 | return 1; | |
179 | } | |
180 | ||
181 | /* | |
182 | * TODO: for memory hotplug support qemu_s390_skeys_set and qemu_s390_skeys_get | |
183 | * will have to make sure that the given gfn belongs to a memory region and not | |
184 | * a memory hole. | |
185 | */ | |
186 | static int qemu_s390_skeys_set(S390SKeysState *ss, uint64_t start_gfn, | |
187 | uint64_t count, uint8_t *keys) | |
188 | { | |
189 | QEMUS390SKeysState *skeydev = QEMU_S390_SKEYS(ss); | |
190 | int i; | |
191 | ||
192 | /* Check for uint64 overflow and access beyond end of key data */ | |
193 | if (start_gfn + count > skeydev->key_count || start_gfn + count < count) { | |
194 | error_report("Error: Setting storage keys for page beyond the end " | |
9af9e0fe MA |
195 | "of memory: gfn=%" PRIx64 " count=%" PRId64, |
196 | start_gfn, count); | |
0efe406c JH |
197 | return -EINVAL; |
198 | } | |
199 | ||
200 | for (i = 0; i < count; i++) { | |
201 | skeydev->keydata[start_gfn + i] = keys[i]; | |
202 | } | |
203 | return 0; | |
204 | } | |
205 | ||
206 | static int qemu_s390_skeys_get(S390SKeysState *ss, uint64_t start_gfn, | |
207 | uint64_t count, uint8_t *keys) | |
208 | { | |
209 | QEMUS390SKeysState *skeydev = QEMU_S390_SKEYS(ss); | |
210 | int i; | |
211 | ||
212 | /* Check for uint64 overflow and access beyond end of key data */ | |
213 | if (start_gfn + count > skeydev->key_count || start_gfn + count < count) { | |
214 | error_report("Error: Getting storage keys for page beyond the end " | |
9af9e0fe MA |
215 | "of memory: gfn=%" PRIx64 " count=%" PRId64, |
216 | start_gfn, count); | |
0efe406c JH |
217 | return -EINVAL; |
218 | } | |
219 | ||
220 | for (i = 0; i < count; i++) { | |
221 | keys[i] = skeydev->keydata[start_gfn + i]; | |
222 | } | |
223 | return 0; | |
224 | } | |
225 | ||
226 | static void qemu_s390_skeys_class_init(ObjectClass *oc, void *data) | |
227 | { | |
228 | S390SKeysClass *skeyclass = S390_SKEYS_CLASS(oc); | |
229 | ||
230 | skeyclass->skeys_enabled = qemu_s390_skeys_enabled; | |
231 | skeyclass->get_skeys = qemu_s390_skeys_get; | |
232 | skeyclass->set_skeys = qemu_s390_skeys_set; | |
233 | } | |
234 | ||
235 | static const TypeInfo qemu_s390_skeys_info = { | |
236 | .name = TYPE_QEMU_S390_SKEYS, | |
237 | .parent = TYPE_S390_SKEYS, | |
238 | .instance_init = qemu_s390_skeys_init, | |
239 | .instance_size = sizeof(QEMUS390SKeysState), | |
240 | .class_init = qemu_s390_skeys_class_init, | |
2f2b0c66 | 241 | .class_size = sizeof(S390SKeysClass), |
0efe406c JH |
242 | }; |
243 | ||
186208fa JH |
244 | static void s390_storage_keys_save(QEMUFile *f, void *opaque) |
245 | { | |
246 | S390SKeysState *ss = S390_SKEYS(opaque); | |
247 | S390SKeysClass *skeyclass = S390_SKEYS_GET_CLASS(ss); | |
248 | uint64_t pages_left = ram_size / TARGET_PAGE_SIZE; | |
249 | uint64_t read_count, eos = S390_SKEYS_SAVE_FLAG_EOS; | |
250 | vaddr cur_gfn = 0; | |
251 | int error = 0; | |
252 | uint8_t *buf; | |
253 | ||
254 | if (!skeyclass->skeys_enabled(ss)) { | |
255 | goto end_stream; | |
256 | } | |
257 | ||
258 | buf = g_try_malloc(S390_SKEYS_BUFFER_SIZE); | |
259 | if (!buf) { | |
9af9e0fe | 260 | error_report("storage key save could not allocate memory"); |
186208fa JH |
261 | goto end_stream; |
262 | } | |
263 | ||
264 | /* We only support initial memory. Standby memory is not handled yet. */ | |
265 | qemu_put_be64(f, (cur_gfn * TARGET_PAGE_SIZE) | S390_SKEYS_SAVE_FLAG_SKEYS); | |
266 | qemu_put_be64(f, pages_left); | |
267 | ||
268 | while (pages_left) { | |
269 | read_count = MIN(pages_left, S390_SKEYS_BUFFER_SIZE); | |
270 | ||
271 | if (!error) { | |
272 | error = skeyclass->get_skeys(ss, cur_gfn, read_count, buf); | |
273 | if (error) { | |
274 | /* | |
275 | * If error: we want to fill the stream with valid data instead | |
276 | * of stopping early so we pad the stream with 0x00 values and | |
277 | * use S390_SKEYS_SAVE_FLAG_ERROR to indicate failure to the | |
278 | * reading side. | |
279 | */ | |
9af9e0fe | 280 | error_report("S390_GET_KEYS error %d", error); |
186208fa JH |
281 | memset(buf, 0, S390_SKEYS_BUFFER_SIZE); |
282 | eos = S390_SKEYS_SAVE_FLAG_ERROR; | |
283 | } | |
284 | } | |
285 | ||
286 | qemu_put_buffer(f, buf, read_count); | |
287 | cur_gfn += read_count; | |
288 | pages_left -= read_count; | |
289 | } | |
290 | ||
291 | g_free(buf); | |
292 | end_stream: | |
293 | qemu_put_be64(f, eos); | |
294 | } | |
295 | ||
296 | static int s390_storage_keys_load(QEMUFile *f, void *opaque, int version_id) | |
297 | { | |
298 | S390SKeysState *ss = S390_SKEYS(opaque); | |
299 | S390SKeysClass *skeyclass = S390_SKEYS_GET_CLASS(ss); | |
300 | int ret = 0; | |
301 | ||
302 | while (!ret) { | |
303 | ram_addr_t addr; | |
304 | int flags; | |
305 | ||
306 | addr = qemu_get_be64(f); | |
307 | flags = addr & ~TARGET_PAGE_MASK; | |
308 | addr &= TARGET_PAGE_MASK; | |
309 | ||
310 | switch (flags) { | |
311 | case S390_SKEYS_SAVE_FLAG_SKEYS: { | |
312 | const uint64_t total_count = qemu_get_be64(f); | |
313 | uint64_t handled_count = 0, cur_count; | |
314 | uint64_t cur_gfn = addr / TARGET_PAGE_SIZE; | |
315 | uint8_t *buf = g_try_malloc(S390_SKEYS_BUFFER_SIZE); | |
316 | ||
317 | if (!buf) { | |
9af9e0fe | 318 | error_report("storage key load could not allocate memory"); |
186208fa JH |
319 | ret = -ENOMEM; |
320 | break; | |
321 | } | |
322 | ||
323 | while (handled_count < total_count) { | |
324 | cur_count = MIN(total_count - handled_count, | |
325 | S390_SKEYS_BUFFER_SIZE); | |
326 | qemu_get_buffer(f, buf, cur_count); | |
327 | ||
328 | ret = skeyclass->set_skeys(ss, cur_gfn, cur_count, buf); | |
329 | if (ret < 0) { | |
9af9e0fe | 330 | error_report("S390_SET_KEYS error %d", ret); |
186208fa JH |
331 | break; |
332 | } | |
333 | handled_count += cur_count; | |
334 | cur_gfn += cur_count; | |
335 | } | |
336 | g_free(buf); | |
337 | break; | |
338 | } | |
339 | case S390_SKEYS_SAVE_FLAG_ERROR: { | |
340 | error_report("Storage key data is incomplete"); | |
341 | ret = -EINVAL; | |
342 | break; | |
343 | } | |
344 | case S390_SKEYS_SAVE_FLAG_EOS: | |
345 | /* normal exit */ | |
346 | return 0; | |
347 | default: | |
348 | error_report("Unexpected storage key flag data: %#x", flags); | |
349 | ret = -EINVAL; | |
350 | } | |
351 | } | |
352 | ||
353 | return ret; | |
354 | } | |
355 | ||
9ef40173 JH |
356 | static inline bool s390_skeys_get_migration_enabled(Object *obj, Error **errp) |
357 | { | |
358 | S390SKeysState *ss = S390_SKEYS(obj); | |
359 | ||
360 | return ss->migration_enabled; | |
361 | } | |
362 | ||
363 | static inline void s390_skeys_set_migration_enabled(Object *obj, bool value, | |
364 | Error **errp) | |
186208fa JH |
365 | { |
366 | S390SKeysState *ss = S390_SKEYS(obj); | |
367 | ||
9ef40173 JH |
368 | /* Prevent double registration of savevm handler */ |
369 | if (ss->migration_enabled == value) { | |
370 | return; | |
371 | } | |
372 | ||
373 | ss->migration_enabled = value; | |
374 | ||
375 | if (ss->migration_enabled) { | |
376 | register_savevm(NULL, TYPE_S390_SKEYS, 0, 1, s390_storage_keys_save, | |
377 | s390_storage_keys_load, ss); | |
378 | } else { | |
379 | unregister_savevm(DEVICE(ss), TYPE_S390_SKEYS, ss); | |
380 | } | |
381 | } | |
382 | ||
383 | static void s390_skeys_instance_init(Object *obj) | |
384 | { | |
385 | object_property_add_bool(obj, "migration-enabled", | |
386 | s390_skeys_get_migration_enabled, | |
387 | s390_skeys_set_migration_enabled, NULL); | |
388 | object_property_set_bool(obj, true, "migration-enabled", NULL); | |
186208fa JH |
389 | } |
390 | ||
0efe406c JH |
391 | static void s390_skeys_class_init(ObjectClass *oc, void *data) |
392 | { | |
393 | DeviceClass *dc = DEVICE_CLASS(oc); | |
394 | ||
395 | dc->hotpluggable = false; | |
396 | set_bit(DEVICE_CATEGORY_MISC, dc->categories); | |
397 | } | |
398 | ||
399 | static const TypeInfo s390_skeys_info = { | |
400 | .name = TYPE_S390_SKEYS, | |
401 | .parent = TYPE_DEVICE, | |
186208fa | 402 | .instance_init = s390_skeys_instance_init, |
0efe406c JH |
403 | .instance_size = sizeof(S390SKeysState), |
404 | .class_init = s390_skeys_class_init, | |
405 | .class_size = sizeof(S390SKeysClass), | |
406 | .abstract = true, | |
407 | }; | |
408 | ||
409 | static void qemu_s390_skeys_register_types(void) | |
410 | { | |
411 | type_register_static(&s390_skeys_info); | |
412 | type_register_static(&qemu_s390_skeys_info); | |
413 | } | |
414 | ||
415 | type_init(qemu_s390_skeys_register_types) |