qemu

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

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);
52
    object_unref(obj);
53

54
    qdev_realize(DEVICE(obj), NULL, &error_fatal);
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
    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

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

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

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

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

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

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, false, NULL);
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
                                            Error **errp)
301
{
302
    return 0;
303
}
304

305
static int qemu_s390_get_active(S390StAttribState *sa)
306
{
307
    return sa->migration_enabled;
308
}
309

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

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

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

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

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