From nobody Tue Feb 10 04:16:16 2026 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) client-ip=208.118.235.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Authentication-Results: mx.zohomail.com; spf=pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org Return-Path: Received: from lists.gnu.org (lists.gnu.org [208.118.235.17]) by mx.zohomail.com with SMTPS id 149986521220874.32538114886586; Wed, 12 Jul 2017 06:13:32 -0700 (PDT) Received: from localhost ([::1]:52686 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1dVHSG-0002qx-Kk for importer@patchew.org; Wed, 12 Jul 2017 09:13:24 -0400 Received: from eggs.gnu.org ([2001:4830:134:3::10]:44856) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1dVHDL-0006WO-Lk for qemu-devel@nongnu.org; Wed, 12 Jul 2017 08:58:02 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1dVHDH-00010u-H3 for qemu-devel@nongnu.org; Wed, 12 Jul 2017 08:57:59 -0400 Received: from mx0a-001b2d01.pphosted.com ([148.163.156.1]:59372) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1dVHDH-0000zt-4B for qemu-devel@nongnu.org; Wed, 12 Jul 2017 08:57:55 -0400 Received: from pps.filterd (m0098396.ppops.net [127.0.0.1]) by mx0a-001b2d01.pphosted.com (8.16.0.21/8.16.0.21) with SMTP id v6CCs4Ex139484 for ; Wed, 12 Jul 2017 08:57:53 -0400 Received: from e06smtp10.uk.ibm.com (e06smtp10.uk.ibm.com [195.75.94.106]) by mx0a-001b2d01.pphosted.com with ESMTP id 2bncj51vyh-1 (version=TLSv1.2 cipher=AES256-SHA bits=256 verify=NOT) for ; Wed, 12 Jul 2017 08:57:53 -0400 Received: from localhost by e06smtp10.uk.ibm.com with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted for from ; Wed, 12 Jul 2017 13:57:51 +0100 Received: from b06cxnps4076.portsmouth.uk.ibm.com (9.149.109.198) by e06smtp10.uk.ibm.com (192.168.101.140) with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted; Wed, 12 Jul 2017 13:57:47 +0100 Received: from d06av22.portsmouth.uk.ibm.com (d06av22.portsmouth.uk.ibm.com [9.149.105.58]) by b06cxnps4076.portsmouth.uk.ibm.com (8.14.9/8.14.9/NCO v10.0) with ESMTP id v6CCvkeQ40894690; Wed, 12 Jul 2017 12:57:46 GMT Received: from d06av22.portsmouth.uk.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id 134204C044; Wed, 12 Jul 2017 13:55:31 +0100 (BST) Received: from d06av22.portsmouth.uk.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id EC1D44C040; Wed, 12 Jul 2017 13:55:30 +0100 (BST) Received: from tuxmaker.boeblingen.de.ibm.com (unknown [9.152.85.9]) by d06av22.portsmouth.uk.ibm.com (Postfix) with ESMTPS; Wed, 12 Jul 2017 13:55:30 +0100 (BST) Received: by tuxmaker.boeblingen.de.ibm.com (Postfix, from userid 25651) id 635D320F69D; Wed, 12 Jul 2017 14:57:46 +0200 (CEST) From: Christian Borntraeger To: qemu-devel Date: Wed, 12 Jul 2017 14:57:37 +0200 X-Mailer: git-send-email 2.7.4 In-Reply-To: <1499864265-144136-1-git-send-email-borntraeger@de.ibm.com> References: <1499864265-144136-1-git-send-email-borntraeger@de.ibm.com> X-TM-AS-GCONF: 00 x-cbid: 17071212-0040-0000-0000-000003C26EC3 X-IBM-AV-DETECTION: SAVI=unused REMOTE=unused XFE=unused x-cbparentid: 17071212-0041-0000-0000-000025BD97EA Message-Id: <1499864265-144136-4-git-send-email-borntraeger@de.ibm.com> X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10432:, , definitions=2017-07-12_03:, , signatures=0 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 spamscore=0 suspectscore=2 malwarescore=0 phishscore=0 adultscore=0 bulkscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.0.1-1706020000 definitions=main-1707120211 X-detected-operating-system: by eggs.gnu.org: GNU/Linux 3.x [generic] [fuzzy] X-Received-From: 148.163.156.1 Subject: [Qemu-devel] [PATCH 03/11] s390x/migration: Storage attributes device X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Christian Borntraeger , Claudio Imbrenda , Cornelia Huck , Alexander Graf , Richard Henderson Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail: RSF_0 Z_629925259 SPT_0 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" From: Claudio Imbrenda Storage attributes device, like we have for storage keys. Signed-off-by: Claudio Imbrenda Signed-off-by: Christian Borntraeger --- hw/s390x/Makefile.objs | 2 + hw/s390x/s390-stattrib-kvm.c | 178 +++++++++++++++++ hw/s390x/s390-stattrib.c | 348 ++++++++++++++++++++++++++++++= ++++ hw/s390x/s390-virtio-ccw.c | 10 +- include/hw/s390x/storage-attributes.h | 68 +++++++ 5 files changed, 605 insertions(+), 1 deletion(-) create mode 100644 hw/s390x/s390-stattrib-kvm.c create mode 100644 hw/s390x/s390-stattrib.c create mode 100644 include/hw/s390x/storage-attributes.h diff --git a/hw/s390x/Makefile.objs b/hw/s390x/Makefile.objs index a8e5575..b2aade2 100644 --- a/hw/s390x/Makefile.objs +++ b/hw/s390x/Makefile.objs @@ -13,5 +13,7 @@ obj-y +=3D css-bridge.o obj-y +=3D ccw-device.o obj-y +=3D s390-pci-bus.o s390-pci-inst.o obj-y +=3D s390-skeys.o +obj-y +=3D s390-stattrib.o obj-$(CONFIG_KVM) +=3D s390-skeys-kvm.o +obj-$(CONFIG_KVM) +=3D s390-stattrib-kvm.o obj-y +=3D s390-ccw.o diff --git a/hw/s390x/s390-stattrib-kvm.c b/hw/s390x/s390-stattrib-kvm.c new file mode 100644 index 0000000..2e7f144 --- /dev/null +++ b/hw/s390x/s390-stattrib-kvm.c @@ -0,0 +1,178 @@ +/* + * s390 storage attributes device -- KVM object + * + * Copyright 2016 IBM Corp. + * Author(s): Claudio Imbrenda + * + * 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 "qmp-commands.h" +#include "migration/qemu-file.h" +#include "hw/s390x/storage-attributes.h" +#include "qemu/error-report.h" +#include "sysemu/kvm.h" +#include "exec/ram_addr.h" +#include "cpu.h" + +static void kvm_s390_stattrib_instance_init(Object *obj) +{ + KVMS390StAttribState *sas =3D KVM_S390_STATTRIB(obj); + + sas->still_dirty =3D 0; +} + +static int kvm_s390_stattrib_read_helper(S390StAttribState *sa, + uint64_t *start_gfn, + uint32_t count, + uint8_t *values, + uint32_t flags) +{ + KVMS390StAttribState *sas =3D KVM_S390_STATTRIB(sa); + int r; + struct kvm_s390_cmma_log clog =3D { + .values =3D (uint64_t)values, + .start_gfn =3D *start_gfn, + .count =3D count, + .flags =3D flags, + }; + + r =3D kvm_vm_ioctl(kvm_state, KVM_S390_GET_CMMA_BITS, &clog); + if (r < 0) { + error_report("Error: %s", strerror(-r)); + return r; + } + + *start_gfn =3D clog.start_gfn; + sas->still_dirty =3D clog.remaining; + return clog.count; +} + +static int kvm_s390_stattrib_get_stattr(S390StAttribState *sa, + uint64_t *start_gfn, + uint32_t count, + uint8_t *values) +{ + return kvm_s390_stattrib_read_helper(sa, start_gfn, count, values, 0); +} + +static int kvm_s390_stattrib_peek_stattr(S390StAttribState *sa, + uint64_t start_gfn, + uint32_t count, + uint8_t *values) +{ + return kvm_s390_stattrib_read_helper(sa, &start_gfn, count, values, + KVM_S390_CMMA_PEEK); +} + +static int kvm_s390_stattrib_set_stattr(S390StAttribState *sa, + uint64_t start_gfn, + uint32_t count, + uint8_t *values) +{ + KVMS390StAttribState *sas =3D KVM_S390_STATTRIB(sa); + MachineState *machine =3D MACHINE(qdev_get_machine()); + unsigned long max =3D machine->maxram_size / TARGET_PAGE_SIZE; + + if (start_gfn + count > max) { + error_report("Error: invalid address."); + return -1; + } + if (!sas->incoming_buffer) { + sas->incoming_buffer =3D g_malloc0(max); + } + + memcpy(sas->incoming_buffer + start_gfn, values, count); + + return 0; +} + +static void kvm_s390_stattrib_synchronize(S390StAttribState *sa) +{ + KVMS390StAttribState *sas =3D KVM_S390_STATTRIB(sa); + MachineState *machine =3D MACHINE(qdev_get_machine()); + unsigned long max =3D machine->maxram_size / TARGET_PAGE_SIZE; + unsigned long cx, len =3D 1 << 19; + int r; + struct kvm_s390_cmma_log clog =3D { + .flags =3D 0, + .mask =3D ~0ULL, + }; + + if (sas->incoming_buffer) { + for (cx =3D 0; cx + len <=3D max; cx +=3D len) { + clog.start_gfn =3D cx; + clog.count =3D len; + clog.values =3D (uint64_t)(sas->incoming_buffer + cx * len); + r =3D kvm_vm_ioctl(kvm_state, KVM_S390_SET_CMMA_BITS, &clog); + if (r) { + return; + } + } + if (cx < max) { + clog.start_gfn =3D cx; + clog.count =3D max - cx; + clog.values =3D (uint64_t)(sas->incoming_buffer + cx * len); + r =3D kvm_vm_ioctl(kvm_state, KVM_S390_SET_CMMA_BITS, &clog); + } + g_free(sas->incoming_buffer); + sas->incoming_buffer =3D NULL; + } +} + +static int kvm_s390_stattrib_set_migrationmode(S390StAttribState *sa, bool= val) +{ + struct kvm_device_attr attr =3D { + .group =3D KVM_S390_VM_MIGRATION, + .attr =3D val, + .addr =3D 0, + }; + return kvm_vm_ioctl(kvm_state, KVM_SET_DEVICE_ATTR, &attr); +} + +static long long kvm_s390_stattrib_get_dirtycount(S390StAttribState *sa) +{ + KVMS390StAttribState *sas =3D KVM_S390_STATTRIB(sa); + uint8_t val[8]; + + kvm_s390_stattrib_peek_stattr(sa, 0, 1, val); + return sas->still_dirty; +} + +static int kvm_s390_stattrib_get_active(S390StAttribState *sa) +{ + return kvm_s390_cmma_active() && sa->migration_enabled; +} + +static void kvm_s390_stattrib_class_init(ObjectClass *oc, void *data) +{ + S390StAttribClass *sac =3D S390_STATTRIB_CLASS(oc); + + sac->get_stattr =3D kvm_s390_stattrib_get_stattr; + sac->peek_stattr =3D kvm_s390_stattrib_peek_stattr; + sac->set_stattr =3D kvm_s390_stattrib_set_stattr; + sac->set_migrationmode =3D kvm_s390_stattrib_set_migrationmode; + sac->get_dirtycount =3D kvm_s390_stattrib_get_dirtycount; + sac->synchronize =3D kvm_s390_stattrib_synchronize; + sac->get_active =3D kvm_s390_stattrib_get_active; +} + +static const TypeInfo kvm_s390_stattrib_info =3D { + .name =3D TYPE_KVM_S390_STATTRIB, + .parent =3D TYPE_S390_STATTRIB, + .instance_init =3D kvm_s390_stattrib_instance_init, + .instance_size =3D sizeof(KVMS390StAttribState), + .class_init =3D kvm_s390_stattrib_class_init, + .class_size =3D sizeof(S390StAttribClass), +}; + +static void kvm_s390_stattrib_register_types(void) +{ + type_register_static(&kvm_s390_stattrib_info); +} + +type_init(kvm_s390_stattrib_register_types) diff --git a/hw/s390x/s390-stattrib.c b/hw/s390x/s390-stattrib.c new file mode 100644 index 0000000..eb41fe9 --- /dev/null +++ b/hw/s390x/s390-stattrib.c @@ -0,0 +1,348 @@ +/* + * s390 storage attributes device + * + * Copyright 2016 IBM Corp. + * Author(s): Claudio Imbrenda + * + * 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 "migration/qemu-file.h" +#include "migration/register.h" +#include "hw/s390x/storage-attributes.h" +#include "qemu/error-report.h" +#include "sysemu/kvm.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 + +void s390_stattrib_init(void) +{ + Object *obj; + +#ifdef CONFIG_KVM + if (kvm_enabled() && + kvm_check_extension(kvm_state, KVM_CAP_S390_CMMA_MIGRATION)) { + obj =3D object_new(TYPE_KVM_S390_STATTRIB); + } else { + obj =3D object_new(TYPE_QEMU_S390_STATTRIB); + } +#else + obj =3D object_new(TYPE_QEMU_S390_STATTRIB); +#endif + + object_property_add_child(qdev_get_machine(), TYPE_S390_STATTRIB, + obj, NULL); + object_unref(obj); + + qdev_init_nofail(DEVICE(obj)); +} + +/* Migration support: */ + +static int cmma_load(QEMUFile *f, void *opaque, int version_id) +{ + S390StAttribState *sas =3D S390_STATTRIB(opaque); + S390StAttribClass *sac =3D S390_STATTRIB_GET_CLASS(sas); + uint64_t count, cur_gfn; + int flags, ret =3D 0; + ram_addr_t addr; + uint8_t *buf; + + while (!ret) { + addr =3D qemu_get_be64(f); + flags =3D addr & ~TARGET_PAGE_MASK; + addr &=3D TARGET_PAGE_MASK; + + switch (flags) { + case STATTR_FLAG_MORE: { + cur_gfn =3D addr / TARGET_PAGE_SIZE; + count =3D qemu_get_be64(f); + buf =3D g_try_malloc(count); + if (!buf) { + error_report("cmma_load could not allocate memory"); + ret =3D -ENOMEM; + break; + } + + qemu_get_buffer(f, buf, count); + ret =3D 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 =3D -EINVAL; + break; + } + case STATTR_FLAG_DONE: + /* This is after the last pre-copied value has been sent, noth= ing + * 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", fl= ags); + ret =3D -EINVAL; + } + } + + return ret; +} + +static int cmma_save_setup(QEMUFile *f, void *opaque) +{ + S390StAttribState *sas =3D S390_STATTRIB(opaque); + S390StAttribClass *sac =3D S390_STATTRIB_GET_CLASS(sas); + int res; + /* + * Signal that we want to start a migration, thus needing PGSTE dirty + * tracking. + */ + res =3D 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 =3D S390_STATTRIB(opaque); + S390StAttribClass *sac =3D S390_STATTRIB_GET_CLASS(sas); + long long res =3D sac->get_dirtycount(sas); + + if (res >=3D 0) { + *non_postcopiable_pending +=3D res; + } +} + +static int cmma_save(QEMUFile *f, void *opaque, int final) +{ + S390StAttribState *sas =3D S390_STATTRIB(opaque); + S390StAttribClass *sac =3D S390_STATTRIB_GET_CLASS(sas); + uint8_t *buf; + int r, cx, reallen =3D 0, ret =3D 0; + uint32_t buflen =3D 1 << 19; /* 512kB cover 2GB of guest memory */ + uint64_t start_gfn =3D sas->migration_cur_gfn; + + buf =3D 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) =3D=3D 0) { + reallen =3D sac->get_stattr(sas, &start_gfn, buflen, buf); + if (reallen < 0) { + g_free(buf); + return reallen; + } + + ret =3D 1; + if (0 =3D=3D reallen) { + break; + } + qemu_put_be64(f, (start_gfn << TARGET_PAGE_BITS) | STATTR_FLAG_MOR= E); + qemu_put_be64(f, reallen); + for (cx =3D 0; cx < reallen; cx++) { + qemu_put_byte(f, buf[cx]); + } + if (!sac->get_dirtycount(sas)) { + break; + } + } + + sas->migration_cur_gfn =3D start_gfn + reallen; + g_free(buf); + if (final) { + qemu_put_be64(f, STATTR_FLAG_DONE); + } + qemu_put_be64(f, STATTR_FLAG_EOS); + + r =3D 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 =3D S390_STATTRIB(opaque); + S390StAttribClass *sac =3D S390_STATTRIB_GET_CLASS(sas); + sac->set_migrationmode(sas, 0); +} + +static bool cmma_active(void *opaque) +{ + S390StAttribState *sas =3D S390_STATTRIB(opaque); + S390StAttribClass *sac =3D 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 star= t_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 *star= t_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 va= lue) +{ + 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 =3D S390_STATTRIB_CLASS(oc); + + sa_cl->synchronize =3D qemu_s390_synchronize_stub; + sa_cl->get_stattr =3D qemu_s390_get_stattr_stub; + sa_cl->set_stattr =3D qemu_s390_peek_stattr_stub; + sa_cl->peek_stattr =3D qemu_s390_peek_stattr_stub; + sa_cl->set_migrationmode =3D qemu_s390_set_migrationmode_stub; + sa_cl->get_dirtycount =3D qemu_s390_get_dirtycount_stub; + sa_cl->get_active =3D qemu_s390_get_active; +} + +static const TypeInfo qemu_s390_stattrib_info =3D { + .name =3D TYPE_QEMU_S390_STATTRIB, + .parent =3D TYPE_S390_STATTRIB, + .instance_init =3D qemu_s390_stattrib_instance_init, + .instance_size =3D sizeof(QEMUS390StAttribState), + .class_init =3D qemu_s390_stattrib_class_init, + .class_size =3D sizeof(S390StAttribClass), +}; + +/* Generic abstract object: */ + +static void s390_stattrib_realize(DeviceState *dev, Error **errp) +{ + bool ambiguous =3D 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 =3D DEVICE_CLASS(oc); + + dc->hotpluggable =3D false; + set_bit(DEVICE_CATEGORY_MISC, dc->categories); + dc->realize =3D s390_stattrib_realize; +} + +static inline bool s390_stattrib_get_migration_enabled(Object *obj, Error = **e) +{ + S390StAttribState *s =3D S390_STATTRIB(obj); + + return s->migration_enabled; +} + +static inline void s390_stattrib_set_migration_enabled(Object *obj, bool v= alue, + Error **errp) +{ + S390StAttribState *s =3D S390_STATTRIB(obj); + + s->migration_enabled =3D value; +} + +static void s390_stattrib_instance_init(Object *obj) +{ + S390StAttribState *sas =3D S390_STATTRIB(obj); + SaveVMHandlers *ops; + + /* ops will always be freed by qemu when unregistering */ + ops =3D g_new0(SaveVMHandlers, 1); + + ops->save_setup =3D cmma_save_setup; + ops->save_live_iterate =3D cmma_save_iterate; + ops->save_live_complete_precopy =3D cmma_save_complete; + ops->save_live_pending =3D cmma_save_pending; + ops->save_cleanup =3D cmma_save_cleanup; + ops->load_state =3D cmma_load; + ops->is_active =3D 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 =3D 0; +} + +static const TypeInfo s390_stattrib_info =3D { + .name =3D TYPE_S390_STATTRIB, + .parent =3D TYPE_DEVICE, + .instance_init =3D s390_stattrib_instance_init, + .instance_size =3D sizeof(S390StAttribState), + .class_init =3D s390_stattrib_class_init, + .class_size =3D sizeof(S390StAttribClass), + .abstract =3D 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) diff --git a/hw/s390x/s390-virtio-ccw.c b/hw/s390x/s390-virtio-ccw.c index 41ca666..0c8f758 100644 --- a/hw/s390x/s390-virtio-ccw.c +++ b/hw/s390x/s390-virtio-ccw.c @@ -24,6 +24,7 @@ #include "qemu/config-file.h" #include "s390-pci-bus.h" #include "hw/s390x/storage-keys.h" +#include "hw/s390x/storage-attributes.h" #include "hw/compat.h" #include "ipl.h" #include "hw/s390x/s390-virtio-ccw.h" @@ -103,6 +104,8 @@ void s390_memory_init(ram_addr_t mem_size) =20 /* Initialize storage key device */ s390_skeys_init(); + /* Initialize storage attributes device */ + s390_stattrib_init(); } =20 static SaveVMHandlers savevm_gtod =3D { @@ -406,7 +409,12 @@ static const TypeInfo ccw_machine_info =3D { type_init(ccw_machine_register_##suffix) =20 #define CCW_COMPAT_2_9 \ - HW_COMPAT_2_9 + HW_COMPAT_2_9 \ + {\ + .driver =3D TYPE_S390_STATTRIB,\ + .property =3D "migration-enabled",\ + .value =3D "off",\ + }, =20 #define CCW_COMPAT_2_8 \ HW_COMPAT_2_8 \ diff --git a/include/hw/s390x/storage-attributes.h b/include/hw/s390x/stora= ge-attributes.h new file mode 100644 index 0000000..161440b --- /dev/null +++ b/include/hw/s390x/storage-attributes.h @@ -0,0 +1,68 @@ +/* + * s390 storage attributes device + * + * Copyright 2016 IBM Corp. + * Author(s): Claudio Imbrenda + * + * 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. + */ + +#ifndef S390_STORAGE_ATTRIBUTES_H +#define S390_STORAGE_ATTRIBUTES_H + +#include + +#define TYPE_S390_STATTRIB "s390-storage_attributes" +#define TYPE_QEMU_S390_STATTRIB "s390-storage_attributes-qemu" +#define TYPE_KVM_S390_STATTRIB "s390-storage_attributes-kvm" + +#define S390_STATTRIB(obj) \ + OBJECT_CHECK(S390StAttribState, (obj), TYPE_S390_STATTRIB) + +typedef struct S390StAttribState { + DeviceState parent_obj; + uint64_t migration_cur_gfn; + bool migration_enabled; +} S390StAttribState; + +#define S390_STATTRIB_CLASS(klass) \ + OBJECT_CLASS_CHECK(S390StAttribClass, (klass), TYPE_S390_STATTRIB) +#define S390_STATTRIB_GET_CLASS(obj) \ + OBJECT_GET_CLASS(S390StAttribClass, (obj), TYPE_S390_STATTRIB) + +typedef struct S390StAttribClass { + DeviceClass parent_class; + /* Return value: < 0 on error, or new count */ + int (*get_stattr)(S390StAttribState *sa, uint64_t *start_gfn, + uint32_t count, uint8_t *values); + int (*peek_stattr)(S390StAttribState *sa, uint64_t start_gfn, + uint32_t count, uint8_t *values); + int (*set_stattr)(S390StAttribState *sa, uint64_t start_gfn, + uint32_t count, uint8_t *values); + void (*synchronize)(S390StAttribState *sa); + int (*set_migrationmode)(S390StAttribState *sa, bool value); + int (*get_active)(S390StAttribState *sa); + long long (*get_dirtycount)(S390StAttribState *sa); +} S390StAttribClass; + +#define QEMU_S390_STATTRIB(obj) \ + OBJECT_CHECK(QEMUS390StAttribState, (obj), TYPE_QEMU_S390_STATTRIB) + +typedef struct QEMUS390StAttribState { + S390StAttribState parent_obj; +} QEMUS390StAttribState; + +#define KVM_S390_STATTRIB(obj) \ + OBJECT_CHECK(KVMS390StAttribState, (obj), TYPE_KVM_S390_STATTRIB) + +typedef struct KVMS390StAttribState { + S390StAttribState parent_obj; + uint64_t still_dirty; + uint8_t *incoming_buffer; +} KVMS390StAttribState; + +void s390_stattrib_init(void); + +#endif /* S390_STORAGE_ATTRIBUTES_H */ --=20 2.7.4