xref: /openbmc/qemu/hw/s390x/s390-stattrib.c (revision 9a72bea6)
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 "migration/qemu-file.h"
15 #include "migration/register.h"
16 #include "hw/qdev-properties.h"
17 #include "hw/s390x/storage-attributes.h"
18 #include "qemu/error-report.h"
19 #include "exec/ram_addr.h"
20 #include "qapi/error.h"
21 #include "qapi/qmp/qdict.h"
22 #include "cpu.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 
s390_get_stattrib_device(void)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 
s390_stattrib_init(void)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);
52     object_unref(obj);
53 
54     qdev_realize(DEVICE(obj), NULL, &error_fatal);
55 }
56 
57 /* Console commands: */
58 
hmp_migrationmode(Monitor * mon,const QDict * qdict)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     Error *local_err = NULL;
65     int r;
66 
67     r = sac->set_migrationmode(sas, what, &local_err);
68     if (r < 0) {
69         monitor_printf(mon, "Error: %s", error_get_pretty(local_err));
70         error_free(local_err);
71     }
72 }
73 
hmp_info_cmma(Monitor * mon,const QDict * qdict)74 void hmp_info_cmma(Monitor *mon, const QDict *qdict)
75 {
76     S390StAttribState *sas = s390_get_stattrib_device();
77     S390StAttribClass *sac = S390_STATTRIB_GET_CLASS(sas);
78     uint64_t addr = qdict_get_int(qdict, "addr");
79     uint64_t buflen = qdict_get_try_int(qdict, "count", 8);
80     uint8_t *vals;
81     int cx, len;
82 
83     vals = g_try_malloc(buflen);
84     if (!vals) {
85         monitor_printf(mon, "Error: %s\n", strerror(errno));
86         return;
87     }
88 
89     len = sac->peek_stattr(sas, addr / TARGET_PAGE_SIZE, buflen, vals);
90     if (len < 0) {
91         monitor_printf(mon, "Error: %s", strerror(-len));
92         goto out;
93     }
94 
95     monitor_printf(mon, "  CMMA attributes, "
96                    "pages %" PRIu64 "+%d (0x%" PRIx64 "):\n",
97                    addr / TARGET_PAGE_SIZE, len, addr & ~TARGET_PAGE_MASK);
98     for (cx = 0; cx < len; cx++) {
99         if (cx % 8 == 7) {
100             monitor_printf(mon, "%02x\n", vals[cx]);
101         } else {
102             monitor_printf(mon, "%02x", vals[cx]);
103         }
104     }
105     monitor_printf(mon, "\n");
106 
107 out:
108     g_free(vals);
109 }
110 
111 /* Migration support: */
112 
cmma_load(QEMUFile * f,void * opaque,int version_id)113 static int cmma_load(QEMUFile *f, void *opaque, int version_id)
114 {
115     S390StAttribState *sas = S390_STATTRIB(opaque);
116     S390StAttribClass *sac = S390_STATTRIB_GET_CLASS(sas);
117     uint64_t count, cur_gfn;
118     int flags, ret = 0;
119     ram_addr_t addr;
120     uint8_t *buf;
121 
122     while (!ret) {
123         addr = qemu_get_be64(f);
124         flags = addr & ~TARGET_PAGE_MASK;
125         addr &= TARGET_PAGE_MASK;
126 
127         switch (flags) {
128         case STATTR_FLAG_MORE: {
129             cur_gfn = addr / TARGET_PAGE_SIZE;
130             count = qemu_get_be64(f);
131             buf = g_try_malloc(count);
132             if (!buf) {
133                 error_report("cmma_load could not allocate memory");
134                 ret = -ENOMEM;
135                 break;
136             }
137 
138             qemu_get_buffer(f, buf, count);
139             ret = sac->set_stattr(sas, cur_gfn, count, buf);
140             if (ret < 0) {
141                 error_report("Error %d while setting storage attributes", ret);
142             }
143             g_free(buf);
144             break;
145         }
146         case STATTR_FLAG_ERROR: {
147             error_report("Storage attributes data is incomplete");
148             ret = -EINVAL;
149             break;
150         }
151         case STATTR_FLAG_DONE:
152             /* This is after the last pre-copied value has been sent, nothing
153              * more will be sent after this. Pre-copy has finished, and we
154              * are done flushing all the remaining values. Now the target
155              * system is about to take over. We synchronize the buffer to
156              * apply the actual correct values where needed.
157              */
158              sac->synchronize(sas);
159             break;
160         case STATTR_FLAG_EOS:
161             /* Normal exit */
162             return 0;
163         default:
164             error_report("Unexpected storage attribute flag data: %#x", flags);
165             ret = -EINVAL;
166         }
167     }
168 
169     return ret;
170 }
171 
cmma_save_setup(QEMUFile * f,void * opaque,Error ** errp)172 static int cmma_save_setup(QEMUFile *f, void *opaque, Error **errp)
173 {
174     S390StAttribState *sas = S390_STATTRIB(opaque);
175     S390StAttribClass *sac = S390_STATTRIB_GET_CLASS(sas);
176     int res;
177     /*
178      * Signal that we want to start a migration, thus needing PGSTE dirty
179      * tracking.
180      */
181     res = sac->set_migrationmode(sas, true, errp);
182     if (res) {
183         return res;
184     }
185     qemu_put_be64(f, STATTR_FLAG_EOS);
186     return 0;
187 }
188 
cmma_state_pending(void * opaque,uint64_t * must_precopy,uint64_t * can_postcopy)189 static void cmma_state_pending(void *opaque, uint64_t *must_precopy,
190                                uint64_t *can_postcopy)
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         *must_precopy += res;
198     }
199 }
200 
cmma_save(QEMUFile * f,void * opaque,int final)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 : migration_rate_exceeded(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 
cmma_save_iterate(QEMUFile * f,void * opaque)252 static int cmma_save_iterate(QEMUFile *f, void *opaque)
253 {
254     return cmma_save(f, opaque, 0);
255 }
256 
cmma_save_complete(QEMUFile * f,void * opaque)257 static int cmma_save_complete(QEMUFile *f, void *opaque)
258 {
259     return cmma_save(f, opaque, 1);
260 }
261 
cmma_save_cleanup(void * opaque)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, false, NULL);
267 }
268 
cmma_active(void * opaque)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 
qemu_s390_stattrib_instance_init(Object * obj)278 static void qemu_s390_stattrib_instance_init(Object *obj)
279 {
280 }
281 
qemu_s390_peek_stattr_stub(S390StAttribState * sa,uint64_t start_gfn,uint32_t count,uint8_t * values)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 }
qemu_s390_synchronize_stub(S390StAttribState * sa)287 static void qemu_s390_synchronize_stub(S390StAttribState *sa)
288 {
289 }
qemu_s390_get_stattr_stub(S390StAttribState * sa,uint64_t * start_gfn,uint32_t count,uint8_t * values)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 }
qemu_s390_get_dirtycount_stub(S390StAttribState * sa)295 static long long qemu_s390_get_dirtycount_stub(S390StAttribState *sa)
296 {
297     return 0;
298 }
qemu_s390_set_migrationmode_stub(S390StAttribState * sa,bool value,Error ** errp)299 static int qemu_s390_set_migrationmode_stub(S390StAttribState *sa, bool value,
300                                             Error **errp)
301 {
302     return 0;
303 }
304 
qemu_s390_get_active(S390StAttribState * sa)305 static int qemu_s390_get_active(S390StAttribState *sa)
306 {
307     return sa->migration_enabled;
308 }
309 
qemu_s390_stattrib_class_init(ObjectClass * oc,void * data)310 static void qemu_s390_stattrib_class_init(ObjectClass *oc, void *data)
311 {
312     S390StAttribClass *sa_cl = S390_STATTRIB_CLASS(oc);
313     DeviceClass *dc = DEVICE_CLASS(oc);
314 
315     sa_cl->synchronize = qemu_s390_synchronize_stub;
316     sa_cl->get_stattr = qemu_s390_get_stattr_stub;
317     sa_cl->set_stattr = qemu_s390_peek_stattr_stub;
318     sa_cl->peek_stattr = qemu_s390_peek_stattr_stub;
319     sa_cl->set_migrationmode = qemu_s390_set_migrationmode_stub;
320     sa_cl->get_dirtycount = qemu_s390_get_dirtycount_stub;
321     sa_cl->get_active = qemu_s390_get_active;
322 
323     /* Reason: Can only be instantiated one time (internally) */
324     dc->user_creatable = false;
325 }
326 
327 static const TypeInfo qemu_s390_stattrib_info = {
328     .name          = TYPE_QEMU_S390_STATTRIB,
329     .parent        = TYPE_S390_STATTRIB,
330     .instance_init = qemu_s390_stattrib_instance_init,
331     .instance_size = sizeof(QEMUS390StAttribState),
332     .class_init    = qemu_s390_stattrib_class_init,
333     .class_size    = sizeof(S390StAttribClass),
334 };
335 
336 /* Generic abstract object: */
337 
338 static SaveVMHandlers savevm_s390_stattrib_handlers = {
339     .save_setup = cmma_save_setup,
340     .save_live_iterate = cmma_save_iterate,
341     .save_live_complete_precopy = cmma_save_complete,
342     .state_pending_exact = cmma_state_pending,
343     .state_pending_estimate = cmma_state_pending,
344     .save_cleanup = cmma_save_cleanup,
345     .load_state = cmma_load,
346     .is_active = cmma_active,
347 };
348 
s390_stattrib_realize(DeviceState * dev,Error ** errp)349 static void s390_stattrib_realize(DeviceState *dev, Error **errp)
350 {
351     bool ambiguous = false;
352 
353     object_resolve_path_type("", TYPE_S390_STATTRIB, &ambiguous);
354     if (ambiguous) {
355         error_setg(errp, "storage_attributes device already exists");
356         return;
357     }
358 
359     register_savevm_live(TYPE_S390_STATTRIB, 0, 0,
360                          &savevm_s390_stattrib_handlers, dev);
361 }
362 
363 static Property s390_stattrib_props[] = {
364     DEFINE_PROP_BOOL("migration-enabled", S390StAttribState, migration_enabled, true),
365     DEFINE_PROP_END_OF_LIST(),
366 };
367 
s390_stattrib_class_init(ObjectClass * oc,void * data)368 static void s390_stattrib_class_init(ObjectClass *oc, void *data)
369 {
370     DeviceClass *dc = DEVICE_CLASS(oc);
371 
372     dc->hotpluggable = false;
373     set_bit(DEVICE_CATEGORY_MISC, dc->categories);
374     dc->realize = s390_stattrib_realize;
375     device_class_set_props(dc, s390_stattrib_props);
376 }
377 
s390_stattrib_instance_init(Object * obj)378 static void s390_stattrib_instance_init(Object *obj)
379 {
380     S390StAttribState *sas = S390_STATTRIB(obj);
381 
382     sas->migration_cur_gfn = 0;
383 }
384 
385 static const TypeInfo s390_stattrib_info = {
386     .name          = TYPE_S390_STATTRIB,
387     .parent        = TYPE_DEVICE,
388     .instance_init = s390_stattrib_instance_init,
389     .instance_size = sizeof(S390StAttribState),
390     .class_init    = s390_stattrib_class_init,
391     .class_size    = sizeof(S390StAttribClass),
392     .abstract      = true,
393 };
394 
s390_stattrib_register_types(void)395 static void s390_stattrib_register_types(void)
396 {
397     type_register_static(&s390_stattrib_info);
398     type_register_static(&qemu_s390_stattrib_info);
399 }
400 
401 type_init(s390_stattrib_register_types)
402