qemu-e2k/hw/s390x/s390-stattrib.c

409 lines
11 KiB
C
Raw Normal View History

/*
* s390 storage attributes device
*
* Copyright 2016 IBM Corp.
* Author(s): Claudio Imbrenda <imbrenda@linux.vnet.ibm.com>
*
* This work is licensed under the terms of the GNU GPL, version 2 or (at
* your option) any later version. See the COPYING file in the top-level
* directory.
*/
#include "qemu/osdep.h"
#include "hw/boards.h"
#include "cpu.h"
#include "qmp-commands.h"
#include "migration/qemu-file.h"
#include "migration/register.h"
#include "hw/s390x/storage-attributes.h"
#include "qemu/error-report.h"
#include "exec/ram_addr.h"
#include "qapi/error.h"
#define CMMA_BLOCK_SIZE (1 << 10)
#define STATTR_FLAG_EOS 0x01ULL
#define STATTR_FLAG_MORE 0x02ULL
#define STATTR_FLAG_ERROR 0x04ULL
#define STATTR_FLAG_DONE 0x08ULL
static S390StAttribState *s390_get_stattrib_device(void)
{
S390StAttribState *sas;
sas = S390_STATTRIB(object_resolve_path_type("", TYPE_S390_STATTRIB, NULL));
assert(sas);
return sas;
}
void s390_stattrib_init(void)
{
Object *obj;
obj = kvm_s390_stattrib_create();
if (!obj) {
obj = object_new(TYPE_QEMU_S390_STATTRIB);
}
object_property_add_child(qdev_get_machine(), TYPE_S390_STATTRIB,
obj, NULL);
object_unref(obj);
qdev_init_nofail(DEVICE(obj));
}
/* Console commands: */
void hmp_migrationmode(Monitor *mon, const QDict *qdict)
{
S390StAttribState *sas = s390_get_stattrib_device();
S390StAttribClass *sac = S390_STATTRIB_GET_CLASS(sas);
uint64_t what = qdict_get_int(qdict, "mode");
int r;
r = sac->set_migrationmode(sas, what);
if (r < 0) {
monitor_printf(mon, "Error: %s", strerror(-r));
}
}
void hmp_info_cmma(Monitor *mon, const QDict *qdict)
{
S390StAttribState *sas = s390_get_stattrib_device();
S390StAttribClass *sac = S390_STATTRIB_GET_CLASS(sas);
uint64_t addr = qdict_get_int(qdict, "addr");
uint64_t buflen = qdict_get_try_int(qdict, "count", 8);
uint8_t *vals;
int cx, len;
vals = g_try_malloc(buflen);
if (!vals) {
monitor_printf(mon, "Error: %s\n", strerror(errno));
return;
}
len = sac->peek_stattr(sas, addr / TARGET_PAGE_SIZE, buflen, vals);
if (len < 0) {
monitor_printf(mon, "Error: %s", strerror(-len));
goto out;
}
monitor_printf(mon, " CMMA attributes, "
"pages %" PRIu64 "+%d (0x%" PRIx64 "):\n",
addr / TARGET_PAGE_SIZE, len, addr & ~TARGET_PAGE_MASK);
for (cx = 0; cx < len; cx++) {
if (cx % 8 == 7) {
monitor_printf(mon, "%02x\n", vals[cx]);
} else {
monitor_printf(mon, "%02x", vals[cx]);
}
}
monitor_printf(mon, "\n");
out:
g_free(vals);
}
/* Migration support: */
static int cmma_load(QEMUFile *f, void *opaque, int version_id)
{
S390StAttribState *sas = S390_STATTRIB(opaque);
S390StAttribClass *sac = S390_STATTRIB_GET_CLASS(sas);
uint64_t count, cur_gfn;
int flags, ret = 0;
ram_addr_t addr;
uint8_t *buf;
while (!ret) {
addr = qemu_get_be64(f);
flags = addr & ~TARGET_PAGE_MASK;
addr &= TARGET_PAGE_MASK;
switch (flags) {
case STATTR_FLAG_MORE: {
cur_gfn = addr / TARGET_PAGE_SIZE;
count = qemu_get_be64(f);
buf = g_try_malloc(count);
if (!buf) {
error_report("cmma_load could not allocate memory");
ret = -ENOMEM;
break;
}
qemu_get_buffer(f, buf, count);
ret = sac->set_stattr(sas, cur_gfn, count, buf);
if (ret < 0) {
error_report("Error %d while setting storage attributes", ret);
}
g_free(buf);
break;
}
case STATTR_FLAG_ERROR: {
error_report("Storage attributes data is incomplete");
ret = -EINVAL;
break;
}
case STATTR_FLAG_DONE:
/* This is after the last pre-copied value has been sent, nothing
* more will be sent after this. Pre-copy has finished, and we
* are done flushing all the remaining values. Now the target
* system is about to take over. We synchronize the buffer to
* apply the actual correct values where needed.
*/
sac->synchronize(sas);
break;
case STATTR_FLAG_EOS:
/* Normal exit */
return 0;
default:
error_report("Unexpected storage attribute flag data: %#x", flags);
ret = -EINVAL;
}
}
return ret;
}
static int cmma_save_setup(QEMUFile *f, void *opaque)
{
S390StAttribState *sas = S390_STATTRIB(opaque);
S390StAttribClass *sac = S390_STATTRIB_GET_CLASS(sas);
int res;
/*
* Signal that we want to start a migration, thus needing PGSTE dirty
* tracking.
*/
res = sac->set_migrationmode(sas, 1);
if (res) {
return res;
}
qemu_put_be64(f, STATTR_FLAG_EOS);
return 0;
}
static void cmma_save_pending(QEMUFile *f, void *opaque, uint64_t max_size,
uint64_t *non_postcopiable_pending,
uint64_t *postcopiable_pending)
{
S390StAttribState *sas = S390_STATTRIB(opaque);
S390StAttribClass *sac = S390_STATTRIB_GET_CLASS(sas);
long long res = sac->get_dirtycount(sas);
if (res >= 0) {
*non_postcopiable_pending += res;
}
}
static int cmma_save(QEMUFile *f, void *opaque, int final)
{
S390StAttribState *sas = S390_STATTRIB(opaque);
S390StAttribClass *sac = S390_STATTRIB_GET_CLASS(sas);
uint8_t *buf;
int r, cx, reallen = 0, ret = 0;
uint32_t buflen = 1 << 19; /* 512kB cover 2GB of guest memory */
uint64_t start_gfn = sas->migration_cur_gfn;
buf = g_try_malloc(buflen);
if (!buf) {
error_report("Could not allocate memory to save storage attributes");
return -ENOMEM;
}
while (final ? 1 : qemu_file_rate_limit(f) == 0) {
reallen = sac->get_stattr(sas, &start_gfn, buflen, buf);
if (reallen < 0) {
g_free(buf);
return reallen;
}
ret = 1;
if (!reallen) {
break;
}
qemu_put_be64(f, (start_gfn << TARGET_PAGE_BITS) | STATTR_FLAG_MORE);
qemu_put_be64(f, reallen);
for (cx = 0; cx < reallen; cx++) {
qemu_put_byte(f, buf[cx]);
}
if (!sac->get_dirtycount(sas)) {
break;
}
}
sas->migration_cur_gfn = start_gfn + reallen;
g_free(buf);
if (final) {
qemu_put_be64(f, STATTR_FLAG_DONE);
}
qemu_put_be64(f, STATTR_FLAG_EOS);
r = qemu_file_get_error(f);
if (r < 0) {
return r;
}
return ret;
}
static int cmma_save_iterate(QEMUFile *f, void *opaque)
{
return cmma_save(f, opaque, 0);
}
static int cmma_save_complete(QEMUFile *f, void *opaque)
{
return cmma_save(f, opaque, 1);
}
static void cmma_save_cleanup(void *opaque)
{
S390StAttribState *sas = S390_STATTRIB(opaque);
S390StAttribClass *sac = S390_STATTRIB_GET_CLASS(sas);
sac->set_migrationmode(sas, 0);
}
static bool cmma_active(void *opaque)
{
S390StAttribState *sas = S390_STATTRIB(opaque);
S390StAttribClass *sac = S390_STATTRIB_GET_CLASS(sas);
return sac->get_active(sas);
}
/* QEMU object: */
static void qemu_s390_stattrib_instance_init(Object *obj)
{
}
static int qemu_s390_peek_stattr_stub(S390StAttribState *sa, uint64_t start_gfn,
uint32_t count, uint8_t *values)
{
return 0;
}
static void qemu_s390_synchronize_stub(S390StAttribState *sa)
{
}
static int qemu_s390_get_stattr_stub(S390StAttribState *sa, uint64_t *start_gfn,
uint32_t count, uint8_t *values)
{
return 0;
}
static long long qemu_s390_get_dirtycount_stub(S390StAttribState *sa)
{
return 0;
}
static int qemu_s390_set_migrationmode_stub(S390StAttribState *sa, bool value)
{
return 0;
}
static int qemu_s390_get_active(S390StAttribState *sa)
{
return sa->migration_enabled;
}
static void qemu_s390_stattrib_class_init(ObjectClass *oc, void *data)
{
S390StAttribClass *sa_cl = S390_STATTRIB_CLASS(oc);
DeviceClass *dc = DEVICE_CLASS(oc);
sa_cl->synchronize = qemu_s390_synchronize_stub;
sa_cl->get_stattr = qemu_s390_get_stattr_stub;
sa_cl->set_stattr = qemu_s390_peek_stattr_stub;
sa_cl->peek_stattr = qemu_s390_peek_stattr_stub;
sa_cl->set_migrationmode = qemu_s390_set_migrationmode_stub;
sa_cl->get_dirtycount = qemu_s390_get_dirtycount_stub;
sa_cl->get_active = qemu_s390_get_active;
/* Reason: Can only be instantiated one time (internally) */
dc->user_creatable = false;
}
static const TypeInfo qemu_s390_stattrib_info = {
.name = TYPE_QEMU_S390_STATTRIB,
.parent = TYPE_S390_STATTRIB,
.instance_init = qemu_s390_stattrib_instance_init,
.instance_size = sizeof(QEMUS390StAttribState),
.class_init = qemu_s390_stattrib_class_init,
.class_size = sizeof(S390StAttribClass),
};
/* Generic abstract object: */
static void s390_stattrib_realize(DeviceState *dev, Error **errp)
{
bool ambiguous = false;
object_resolve_path_type("", TYPE_S390_STATTRIB, &ambiguous);
if (ambiguous) {
error_setg(errp, "storage_attributes device already exists");
}
}
static void s390_stattrib_class_init(ObjectClass *oc, void *data)
{
DeviceClass *dc = DEVICE_CLASS(oc);
dc->hotpluggable = false;
set_bit(DEVICE_CATEGORY_MISC, dc->categories);
dc->realize = s390_stattrib_realize;
}
static inline bool s390_stattrib_get_migration_enabled(Object *obj, Error **e)
{
S390StAttribState *s = S390_STATTRIB(obj);
return s->migration_enabled;
}
static inline void s390_stattrib_set_migration_enabled(Object *obj, bool value,
Error **errp)
{
S390StAttribState *s = S390_STATTRIB(obj);
s->migration_enabled = value;
}
static void s390_stattrib_instance_init(Object *obj)
{
S390StAttribState *sas = S390_STATTRIB(obj);
SaveVMHandlers *ops;
/* ops will always be freed by qemu when unregistering */
ops = g_new0(SaveVMHandlers, 1);
ops->save_setup = cmma_save_setup;
ops->save_live_iterate = cmma_save_iterate;
ops->save_live_complete_precopy = cmma_save_complete;
ops->save_live_pending = cmma_save_pending;
ops->save_cleanup = cmma_save_cleanup;
ops->load_state = cmma_load;
ops->is_active = cmma_active;
register_savevm_live(NULL, TYPE_S390_STATTRIB, 0, 0, ops, sas);
object_property_add_bool(obj, "migration-enabled",
s390_stattrib_get_migration_enabled,
s390_stattrib_set_migration_enabled, NULL);
object_property_set_bool(obj, true, "migration-enabled", NULL);
sas->migration_cur_gfn = 0;
}
static const TypeInfo s390_stattrib_info = {
.name = TYPE_S390_STATTRIB,
.parent = TYPE_DEVICE,
.instance_init = s390_stattrib_instance_init,
.instance_size = sizeof(S390StAttribState),
.class_init = s390_stattrib_class_init,
.class_size = sizeof(S390StAttribClass),
.abstract = true,
};
static void s390_stattrib_register_types(void)
{
type_register_static(&s390_stattrib_info);
type_register_static(&qemu_s390_stattrib_info);
}
type_init(s390_stattrib_register_types)