xref: /openbmc/qemu/hw/s390x/s390-stattrib.c (revision 520e210c)
1 /*
2  * s390 storage attributes device
3  *
4  * Copyright 2016 IBM Corp.
5  * Author(s): Claudio Imbrenda <imbrenda@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 
12 #include "qemu/osdep.h"
13 #include "qemu/units.h"
14 #include "hw/boards.h"
15 #include "cpu.h"
16 #include "migration/qemu-file.h"
17 #include "migration/register.h"
18 #include "hw/s390x/storage-attributes.h"
19 #include "qemu/error-report.h"
20 #include "exec/ram_addr.h"
21 #include "qapi/error.h"
22 #include "qapi/qmp/qdict.h"
23 
24 /* 512KiB cover 2GB of guest memory */
25 #define CMMA_BLOCK_SIZE  (512 * KiB)
26 
27 #define STATTR_FLAG_EOS     0x01ULL
28 #define STATTR_FLAG_MORE    0x02ULL
29 #define STATTR_FLAG_ERROR   0x04ULL
30 #define STATTR_FLAG_DONE    0x08ULL
31 
32 static S390StAttribState *s390_get_stattrib_device(void)
33 {
34     S390StAttribState *sas;
35 
36     sas = S390_STATTRIB(object_resolve_path_type("", TYPE_S390_STATTRIB, NULL));
37     assert(sas);
38     return sas;
39 }
40 
41 void s390_stattrib_init(void)
42 {
43     Object *obj;
44 
45     obj = kvm_s390_stattrib_create();
46     if (!obj) {
47         obj = object_new(TYPE_QEMU_S390_STATTRIB);
48     }
49 
50     object_property_add_child(qdev_get_machine(), TYPE_S390_STATTRIB,
51                               obj, NULL);
52     object_unref(obj);
53 
54     qdev_init_nofail(DEVICE(obj));
55 }
56 
57 /* Console commands: */
58 
59 void hmp_migrationmode(Monitor *mon, const QDict *qdict)
60 {
61     S390StAttribState *sas = s390_get_stattrib_device();
62     S390StAttribClass *sac = S390_STATTRIB_GET_CLASS(sas);
63     uint64_t what = qdict_get_int(qdict, "mode");
64     int r;
65 
66     r = sac->set_migrationmode(sas, what);
67     if (r < 0) {
68         monitor_printf(mon, "Error: %s", strerror(-r));
69     }
70 }
71 
72 void hmp_info_cmma(Monitor *mon, const QDict *qdict)
73 {
74     S390StAttribState *sas = s390_get_stattrib_device();
75     S390StAttribClass *sac = S390_STATTRIB_GET_CLASS(sas);
76     uint64_t addr = qdict_get_int(qdict, "addr");
77     uint64_t buflen = qdict_get_try_int(qdict, "count", 8);
78     uint8_t *vals;
79     int cx, len;
80 
81     vals = g_try_malloc(buflen);
82     if (!vals) {
83         monitor_printf(mon, "Error: %s\n", strerror(errno));
84         return;
85     }
86 
87     len = sac->peek_stattr(sas, addr / TARGET_PAGE_SIZE, buflen, vals);
88     if (len < 0) {
89         monitor_printf(mon, "Error: %s", strerror(-len));
90         goto out;
91     }
92 
93     monitor_printf(mon, "  CMMA attributes, "
94                    "pages %" PRIu64 "+%d (0x%" PRIx64 "):\n",
95                    addr / TARGET_PAGE_SIZE, len, addr & ~TARGET_PAGE_MASK);
96     for (cx = 0; cx < len; cx++) {
97         if (cx % 8 == 7) {
98             monitor_printf(mon, "%02x\n", vals[cx]);
99         } else {
100             monitor_printf(mon, "%02x", vals[cx]);
101         }
102     }
103     monitor_printf(mon, "\n");
104 
105 out:
106     g_free(vals);
107 }
108 
109 /* Migration support: */
110 
111 static int cmma_load(QEMUFile *f, void *opaque, int version_id)
112 {
113     S390StAttribState *sas = S390_STATTRIB(opaque);
114     S390StAttribClass *sac = S390_STATTRIB_GET_CLASS(sas);
115     uint64_t count, cur_gfn;
116     int flags, ret = 0;
117     ram_addr_t addr;
118     uint8_t *buf;
119 
120     while (!ret) {
121         addr = qemu_get_be64(f);
122         flags = addr & ~TARGET_PAGE_MASK;
123         addr &= TARGET_PAGE_MASK;
124 
125         switch (flags) {
126         case STATTR_FLAG_MORE: {
127             cur_gfn = addr / TARGET_PAGE_SIZE;
128             count = qemu_get_be64(f);
129             buf = g_try_malloc(count);
130             if (!buf) {
131                 error_report("cmma_load could not allocate memory");
132                 ret = -ENOMEM;
133                 break;
134             }
135 
136             qemu_get_buffer(f, buf, count);
137             ret = sac->set_stattr(sas, cur_gfn, count, buf);
138             if (ret < 0) {
139                 error_report("Error %d while setting storage attributes", ret);
140             }
141             g_free(buf);
142             break;
143         }
144         case STATTR_FLAG_ERROR: {
145             error_report("Storage attributes data is incomplete");
146             ret = -EINVAL;
147             break;
148         }
149         case STATTR_FLAG_DONE:
150             /* This is after the last pre-copied value has been sent, nothing
151              * more will be sent after this. Pre-copy has finished, and we
152              * are done flushing all the remaining values. Now the target
153              * system is about to take over. We synchronize the buffer to
154              * apply the actual correct values where needed.
155              */
156              sac->synchronize(sas);
157             break;
158         case STATTR_FLAG_EOS:
159             /* Normal exit */
160             return 0;
161         default:
162             error_report("Unexpected storage attribute flag data: %#x", flags);
163             ret = -EINVAL;
164         }
165     }
166 
167     return ret;
168 }
169 
170 static int cmma_save_setup(QEMUFile *f, void *opaque)
171 {
172     S390StAttribState *sas = S390_STATTRIB(opaque);
173     S390StAttribClass *sac = S390_STATTRIB_GET_CLASS(sas);
174     int res;
175     /*
176      * Signal that we want to start a migration, thus needing PGSTE dirty
177      * tracking.
178      */
179     res = sac->set_migrationmode(sas, 1);
180     if (res) {
181         return res;
182     }
183     qemu_put_be64(f, STATTR_FLAG_EOS);
184     return 0;
185 }
186 
187 static void cmma_save_pending(QEMUFile *f, void *opaque, uint64_t max_size,
188                               uint64_t *res_precopy_only,
189                               uint64_t *res_compatible,
190                               uint64_t *res_postcopy_only)
191 {
192     S390StAttribState *sas = S390_STATTRIB(opaque);
193     S390StAttribClass *sac = S390_STATTRIB_GET_CLASS(sas);
194     long long res = sac->get_dirtycount(sas);
195 
196     if (res >= 0) {
197         *res_precopy_only += res;
198     }
199 }
200 
201 static int cmma_save(QEMUFile *f, void *opaque, int final)
202 {
203     S390StAttribState *sas = S390_STATTRIB(opaque);
204     S390StAttribClass *sac = S390_STATTRIB_GET_CLASS(sas);
205     uint8_t *buf;
206     int r, cx, reallen = 0, ret = 0;
207     uint32_t buflen = CMMA_BLOCK_SIZE;
208     uint64_t start_gfn = sas->migration_cur_gfn;
209 
210     buf = g_try_malloc(buflen);
211     if (!buf) {
212         error_report("Could not allocate memory to save storage attributes");
213         return -ENOMEM;
214     }
215 
216     while (final ? 1 : qemu_file_rate_limit(f) == 0) {
217         reallen = sac->get_stattr(sas, &start_gfn, buflen, buf);
218         if (reallen < 0) {
219             g_free(buf);
220             return reallen;
221         }
222 
223         ret = 1;
224         if (!reallen) {
225             break;
226         }
227         qemu_put_be64(f, (start_gfn << TARGET_PAGE_BITS) | STATTR_FLAG_MORE);
228         qemu_put_be64(f, reallen);
229         for (cx = 0; cx < reallen; cx++) {
230             qemu_put_byte(f, buf[cx]);
231         }
232         if (!sac->get_dirtycount(sas)) {
233             break;
234         }
235     }
236 
237     sas->migration_cur_gfn = start_gfn + reallen;
238     g_free(buf);
239     if (final) {
240         qemu_put_be64(f, STATTR_FLAG_DONE);
241     }
242     qemu_put_be64(f, STATTR_FLAG_EOS);
243 
244     r = qemu_file_get_error(f);
245     if (r < 0) {
246         return r;
247     }
248 
249     return ret;
250 }
251 
252 static int cmma_save_iterate(QEMUFile *f, void *opaque)
253 {
254     return cmma_save(f, opaque, 0);
255 }
256 
257 static int cmma_save_complete(QEMUFile *f, void *opaque)
258 {
259     return cmma_save(f, opaque, 1);
260 }
261 
262 static void cmma_save_cleanup(void *opaque)
263 {
264     S390StAttribState *sas = S390_STATTRIB(opaque);
265     S390StAttribClass *sac = S390_STATTRIB_GET_CLASS(sas);
266     sac->set_migrationmode(sas, 0);
267 }
268 
269 static bool cmma_active(void *opaque)
270 {
271     S390StAttribState *sas = S390_STATTRIB(opaque);
272     S390StAttribClass *sac = S390_STATTRIB_GET_CLASS(sas);
273     return sac->get_active(sas);
274 }
275 
276 /* QEMU object: */
277 
278 static void qemu_s390_stattrib_instance_init(Object *obj)
279 {
280 }
281 
282 static int qemu_s390_peek_stattr_stub(S390StAttribState *sa, uint64_t start_gfn,
283                                      uint32_t count, uint8_t *values)
284 {
285     return 0;
286 }
287 static void qemu_s390_synchronize_stub(S390StAttribState *sa)
288 {
289 }
290 static int qemu_s390_get_stattr_stub(S390StAttribState *sa, uint64_t *start_gfn,
291                                      uint32_t count, uint8_t *values)
292 {
293     return 0;
294 }
295 static long long qemu_s390_get_dirtycount_stub(S390StAttribState *sa)
296 {
297     return 0;
298 }
299 static int qemu_s390_set_migrationmode_stub(S390StAttribState *sa, bool value)
300 {
301     return 0;
302 }
303 
304 static int qemu_s390_get_active(S390StAttribState *sa)
305 {
306     return sa->migration_enabled;
307 }
308 
309 static void qemu_s390_stattrib_class_init(ObjectClass *oc, void *data)
310 {
311     S390StAttribClass *sa_cl = S390_STATTRIB_CLASS(oc);
312     DeviceClass *dc = DEVICE_CLASS(oc);
313 
314     sa_cl->synchronize = qemu_s390_synchronize_stub;
315     sa_cl->get_stattr = qemu_s390_get_stattr_stub;
316     sa_cl->set_stattr = qemu_s390_peek_stattr_stub;
317     sa_cl->peek_stattr = qemu_s390_peek_stattr_stub;
318     sa_cl->set_migrationmode = qemu_s390_set_migrationmode_stub;
319     sa_cl->get_dirtycount = qemu_s390_get_dirtycount_stub;
320     sa_cl->get_active = qemu_s390_get_active;
321 
322     /* Reason: Can only be instantiated one time (internally) */
323     dc->user_creatable = false;
324 }
325 
326 static const TypeInfo qemu_s390_stattrib_info = {
327     .name          = TYPE_QEMU_S390_STATTRIB,
328     .parent        = TYPE_S390_STATTRIB,
329     .instance_init = qemu_s390_stattrib_instance_init,
330     .instance_size = sizeof(QEMUS390StAttribState),
331     .class_init    = qemu_s390_stattrib_class_init,
332     .class_size    = sizeof(S390StAttribClass),
333 };
334 
335 /* Generic abstract object: */
336 
337 static void s390_stattrib_realize(DeviceState *dev, Error **errp)
338 {
339     bool ambiguous = false;
340 
341     object_resolve_path_type("", TYPE_S390_STATTRIB, &ambiguous);
342     if (ambiguous) {
343         error_setg(errp, "storage_attributes device already exists");
344     }
345 }
346 
347 static void s390_stattrib_class_init(ObjectClass *oc, void *data)
348 {
349     DeviceClass *dc = DEVICE_CLASS(oc);
350 
351     dc->hotpluggable = false;
352     set_bit(DEVICE_CATEGORY_MISC, dc->categories);
353     dc->realize = s390_stattrib_realize;
354 }
355 
356 static inline bool s390_stattrib_get_migration_enabled(Object *obj, Error **e)
357 {
358     S390StAttribState *s = S390_STATTRIB(obj);
359 
360     return s->migration_enabled;
361 }
362 
363 static inline void s390_stattrib_set_migration_enabled(Object *obj, bool value,
364                                             Error **errp)
365 {
366     S390StAttribState *s = S390_STATTRIB(obj);
367 
368     s->migration_enabled = value;
369 }
370 
371 static SaveVMHandlers savevm_s390_stattrib_handlers = {
372     .save_setup = cmma_save_setup,
373     .save_live_iterate = cmma_save_iterate,
374     .save_live_complete_precopy = cmma_save_complete,
375     .save_live_pending = cmma_save_pending,
376     .save_cleanup = cmma_save_cleanup,
377     .load_state = cmma_load,
378     .is_active = cmma_active,
379 };
380 
381 static void s390_stattrib_instance_init(Object *obj)
382 {
383     S390StAttribState *sas = S390_STATTRIB(obj);
384 
385     register_savevm_live(NULL, TYPE_S390_STATTRIB, 0, 0,
386                          &savevm_s390_stattrib_handlers, sas);
387 
388     object_property_add_bool(obj, "migration-enabled",
389                              s390_stattrib_get_migration_enabled,
390                              s390_stattrib_set_migration_enabled, NULL);
391     object_property_set_bool(obj, true, "migration-enabled", NULL);
392     sas->migration_cur_gfn = 0;
393 }
394 
395 static const TypeInfo s390_stattrib_info = {
396     .name          = TYPE_S390_STATTRIB,
397     .parent        = TYPE_DEVICE,
398     .instance_init = s390_stattrib_instance_init,
399     .instance_size = sizeof(S390StAttribState),
400     .class_init    = s390_stattrib_class_init,
401     .class_size    = sizeof(S390StAttribClass),
402     .abstract      = true,
403 };
404 
405 static void s390_stattrib_register_types(void)
406 {
407     type_register_static(&s390_stattrib_info);
408     type_register_static(&qemu_s390_stattrib_info);
409 }
410 
411 type_init(s390_stattrib_register_types)
412