hw/s390x/s390-skeys.c - third_party/qemu - Git at Google

 /*
  * s390 storage key device
  *
  * Copyright 2015 IBM Corp.
  * Author(s): Jason J. Herne <jjherne@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 "qemu/units.h"
 #include "hw/boards.h"
 #include "hw/s390x/storage-keys.h"
 #include "qapi/error.h"
 #include "qapi/qapi-commands-misc-target.h"
 #include "qapi/qmp/qdict.h"
 #include "qemu/error-report.h"
 #include "sysemu/memory_mapping.h"
 #include "exec/address-spaces.h"
 #include "sysemu/kvm.h"
 #include "migration/qemu-file-types.h"
 #include "migration/register.h"

 #define S390_SKEYS_BUFFER_SIZE (128 * KiB)  /* Room for 128k storage keys */
 #define S390_SKEYS_SAVE_FLAG_EOS 0x01
 #define S390_SKEYS_SAVE_FLAG_SKEYS 0x02
 #define S390_SKEYS_SAVE_FLAG_ERROR 0x04

 S390SKeysState *s390_get_skeys_device(void)
 {
     S390SKeysState *ss;

     ss = S390_SKEYS(object_resolve_path_type("", TYPE_S390_SKEYS, NULL));
     assert(ss);
     return ss;
 }

 void s390_skeys_init(void)
 {
     Object *obj;

     if (kvm_enabled()) {
         obj = object_new(TYPE_KVM_S390_SKEYS);
     } else {
         obj = object_new(TYPE_QEMU_S390_SKEYS);
     }
     object_property_add_child(qdev_get_machine(), TYPE_S390_SKEYS,
                               obj);
     object_unref(obj);

     qdev_realize(DEVICE(obj), NULL, &error_fatal);
 }

 static void write_keys(FILE *f, uint8_t *keys, uint64_t startgfn,
                        uint64_t count, Error **errp)
 {
     uint64_t curpage = startgfn;
     uint64_t maxpage = curpage + count - 1;

     for (; curpage <= maxpage; curpage++) {
         uint8_t acc = (*keys & 0xF0) >> 4;
         int fp =  (*keys & 0x08);
         int ref = (*keys & 0x04);
         int ch = (*keys & 0x02);
         int res = (*keys & 0x01);

         fprintf(f, "page=%03" PRIx64 ": key(%d) => ACC=%X, FP=%d, REF=%d,"
                 " ch=%d, reserved=%d\n",
                 curpage, *keys, acc, fp, ref, ch, res);
         keys++;
     }
 }

 void hmp_info_skeys(Monitor *mon, const QDict *qdict)
 {
     S390SKeysState *ss = s390_get_skeys_device();
     S390SKeysClass *skeyclass = S390_SKEYS_GET_CLASS(ss);
     uint64_t addr = qdict_get_int(qdict, "addr");
     uint8_t key;
     int r;

     /* Quick check to see if guest is using storage keys*/
     if (!skeyclass->skeys_are_enabled(ss)) {
         monitor_printf(mon, "Error: This guest is not using storage keys\n");
         return;
     }

     if (!address_space_access_valid(&address_space_memory,
                                     addr & TARGET_PAGE_MASK, TARGET_PAGE_SIZE,
                                     false, MEMTXATTRS_UNSPECIFIED)) {
         monitor_printf(mon, "Error: The given address is not valid\n");
         return;
     }

     r = skeyclass->get_skeys(ss, addr / TARGET_PAGE_SIZE, 1, &key);
     if (r < 0) {
         monitor_printf(mon, "Error: %s\n", strerror(-r));
         return;
     }

     monitor_printf(mon, "  key: 0x%X\n", key);
 }

 void hmp_dump_skeys(Monitor *mon, const QDict *qdict)
 {
     const char *filename = qdict_get_str(qdict, "filename");
     Error *err = NULL;

     qmp_dump_skeys(filename, &err);
     if (err) {
         error_report_err(err);
     }
 }

 void qmp_dump_skeys(const char *filename, Error **errp)
 {
     S390SKeysState *ss = s390_get_skeys_device();
     S390SKeysClass *skeyclass = S390_SKEYS_GET_CLASS(ss);
     GuestPhysBlockList guest_phys_blocks;
     GuestPhysBlock *block;
     uint64_t pages, gfn;
     Error *lerr = NULL;
     uint8_t *buf;
     int ret;
     int fd;
     FILE *f;

     /* Quick check to see if guest is using storage keys*/
     if (!skeyclass->skeys_are_enabled(ss)) {
         error_setg(errp, "This guest is not using storage keys - "
                          "nothing to dump");
         return;
     }

     fd = qemu_open_old(filename, O_WRONLY | O_CREAT | O_TRUNC, 0600);
     if (fd < 0) {
         error_setg_file_open(errp, errno, filename);
         return;
     }
     f = fdopen(fd, "wb");
     if (!f) {
         close(fd);
         error_setg_file_open(errp, errno, filename);
         return;
     }

     buf = g_try_malloc(S390_SKEYS_BUFFER_SIZE);
     if (!buf) {
         error_setg(errp, "Could not allocate memory");
         goto out;
     }

     assert(qemu_mutex_iothread_locked());
     guest_phys_blocks_init(&guest_phys_blocks);
     guest_phys_blocks_append(&guest_phys_blocks);

     QTAILQ_FOREACH(block, &guest_phys_blocks.head, next) {
         assert(QEMU_IS_ALIGNED(block->target_start, TARGET_PAGE_SIZE));
         assert(QEMU_IS_ALIGNED(block->target_end, TARGET_PAGE_SIZE));

         gfn = block->target_start / TARGET_PAGE_SIZE;
         pages = (block->target_end - block->target_start) / TARGET_PAGE_SIZE;

         while (pages) {
             const uint64_t cur_pages = MIN(pages, S390_SKEYS_BUFFER_SIZE);

             ret = skeyclass->get_skeys(ss, gfn, cur_pages, buf);
             if (ret < 0) {
                 error_setg_errno(errp, -ret, "get_keys error");
                 goto out_free;
             }

             /* write keys to stream */
             write_keys(f, buf, gfn, cur_pages, &lerr);
             if (lerr) {
                 goto out_free;
             }

             gfn += cur_pages;
             pages -= cur_pages;
         }
     }

 out_free:
     guest_phys_blocks_free(&guest_phys_blocks);
     error_propagate(errp, lerr);
     g_free(buf);
 out:
     fclose(f);
 }

 static bool qemu_s390_skeys_are_enabled(S390SKeysState *ss)
 {
     QEMUS390SKeysState *skeys = QEMU_S390_SKEYS(ss);

     /* Lockless check is sufficient. */
     return !!skeys->keydata;
 }

 static bool qemu_s390_enable_skeys(S390SKeysState *ss)
 {
     QEMUS390SKeysState *skeys = QEMU_S390_SKEYS(ss);
     static gsize initialized;

     if (likely(skeys->keydata)) {
         return true;
     }

     /*
      * TODO: Modern Linux doesn't use storage keys unless running KVM guests
      *       that use storage keys. Therefore, we keep it simple for now.
      *
      * 1) We should initialize to "referenced+changed" for an initial
      *    over-indication. Let's avoid touching megabytes of data for now and
      *    assume that any sane user will issue a storage key instruction before
      *    actually relying on this data.
      * 2) Relying on ram_size and allocating a big array is ugly. We should
      *    allocate and manage storage key data per RAMBlock or optimally using
      *    some sparse data structure.
      * 3) We only ever have a single S390SKeysState, so relying on
      *    g_once_init_enter() is good enough.
      */
     if (g_once_init_enter(&initialized)) {
         MachineState *machine = MACHINE(qdev_get_machine());

         skeys->key_count = machine->ram_size / TARGET_PAGE_SIZE;
         skeys->keydata = g_malloc0(skeys->key_count);
         g_once_init_leave(&initialized, 1);
     }
     return false;
 }

 static int qemu_s390_skeys_set(S390SKeysState *ss, uint64_t start_gfn,
                               uint64_t count, uint8_t *keys)
 {
     QEMUS390SKeysState *skeydev = QEMU_S390_SKEYS(ss);
     int i;

     /* Check for uint64 overflow and access beyond end of key data */
     if (unlikely(!skeydev->keydata || start_gfn + count > skeydev->key_count ||
                   start_gfn + count < count)) {
         error_report("Error: Setting storage keys for pages with unallocated "
                      "storage key memory: gfn=%" PRIx64 " count=%" PRId64,
                      start_gfn, count);
         return -EINVAL;
     }

     for (i = 0; i < count; i++) {
         skeydev->keydata[start_gfn + i] = keys[i];
     }
     return 0;
 }

 static int qemu_s390_skeys_get(S390SKeysState *ss, uint64_t start_gfn,
                                uint64_t count, uint8_t *keys)
 {
     QEMUS390SKeysState *skeydev = QEMU_S390_SKEYS(ss);
     int i;

     /* Check for uint64 overflow and access beyond end of key data */
     if (unlikely(!skeydev->keydata || start_gfn + count > skeydev->key_count ||
                   start_gfn + count < count)) {
         error_report("Error: Getting storage keys for pages with unallocated "
                      "storage key memory: gfn=%" PRIx64 " count=%" PRId64,
                      start_gfn, count);
         return -EINVAL;
     }

     for (i = 0; i < count; i++) {
         keys[i] = skeydev->keydata[start_gfn + i];
     }
     return 0;
 }

 static void qemu_s390_skeys_class_init(ObjectClass *oc, void *data)
 {
     S390SKeysClass *skeyclass = S390_SKEYS_CLASS(oc);
     DeviceClass *dc = DEVICE_CLASS(oc);

     skeyclass->skeys_are_enabled = qemu_s390_skeys_are_enabled;
     skeyclass->enable_skeys = qemu_s390_enable_skeys;
     skeyclass->get_skeys = qemu_s390_skeys_get;
     skeyclass->set_skeys = qemu_s390_skeys_set;

     /* Reason: Internal device (only one skeys device for the whole memory) */
     dc->user_creatable = false;
 }

 static const TypeInfo qemu_s390_skeys_info = {
     .name          = TYPE_QEMU_S390_SKEYS,
     .parent        = TYPE_S390_SKEYS,
     .instance_size = sizeof(QEMUS390SKeysState),
     .class_init    = qemu_s390_skeys_class_init,
     .class_size    = sizeof(S390SKeysClass),
 };

 static void s390_storage_keys_save(QEMUFile *f, void *opaque)
 {
     S390SKeysState *ss = S390_SKEYS(opaque);
     S390SKeysClass *skeyclass = S390_SKEYS_GET_CLASS(ss);
     GuestPhysBlockList guest_phys_blocks;
     GuestPhysBlock *block;
     uint64_t pages, gfn;
     int error = 0;
     uint8_t *buf;

     if (!skeyclass->skeys_are_enabled(ss)) {
         goto end_stream;
     }

     buf = g_try_malloc(S390_SKEYS_BUFFER_SIZE);
     if (!buf) {
         error_report("storage key save could not allocate memory");
         goto end_stream;
     }

     guest_phys_blocks_init(&guest_phys_blocks);
     guest_phys_blocks_append(&guest_phys_blocks);

     /* Send each contiguous physical memory range separately. */
     QTAILQ_FOREACH(block, &guest_phys_blocks.head, next) {
         assert(QEMU_IS_ALIGNED(block->target_start, TARGET_PAGE_SIZE));
         assert(QEMU_IS_ALIGNED(block->target_end, TARGET_PAGE_SIZE));

         gfn = block->target_start / TARGET_PAGE_SIZE;
         pages = (block->target_end - block->target_start) / TARGET_PAGE_SIZE;
         qemu_put_be64(f, block->target_start | S390_SKEYS_SAVE_FLAG_SKEYS);
         qemu_put_be64(f, pages);

         while (pages) {
             const uint64_t cur_pages = MIN(pages, S390_SKEYS_BUFFER_SIZE);

             if (!error) {
                 error = skeyclass->get_skeys(ss, gfn, cur_pages, buf);
                 if (error) {
                     /*
                      * Create a valid stream with all 0x00 and indicate
                      * S390_SKEYS_SAVE_FLAG_ERROR to the destination.
                      */
                     error_report("S390_GET_KEYS error %d", error);
                     memset(buf, 0, S390_SKEYS_BUFFER_SIZE);
                 }
             }

             qemu_put_buffer(f, buf, cur_pages);
             gfn += cur_pages;
             pages -= cur_pages;
         }

         if (error) {
             break;
         }
     }

     guest_phys_blocks_free(&guest_phys_blocks);
     g_free(buf);
 end_stream:
     if (error) {
         qemu_put_be64(f, S390_SKEYS_SAVE_FLAG_ERROR);
     } else {
         qemu_put_be64(f, S390_SKEYS_SAVE_FLAG_EOS);
     }
 }

 static int s390_storage_keys_load(QEMUFile *f, void *opaque, int version_id)
 {
     S390SKeysState *ss = S390_SKEYS(opaque);
     S390SKeysClass *skeyclass = S390_SKEYS_GET_CLASS(ss);
     int ret = 0;

     /*
      * Make sure to lazy-enable if required to be done explicitly. No need to
      * flush any TLB as the VM is not running yet.
      */
     if (skeyclass->enable_skeys) {
         skeyclass->enable_skeys(ss);
     }

     while (!ret) {
         ram_addr_t addr;
         int flags;

         addr = qemu_get_be64(f);
         flags = addr & ~TARGET_PAGE_MASK;
         addr &= TARGET_PAGE_MASK;

         switch (flags) {
         case S390_SKEYS_SAVE_FLAG_SKEYS: {
             const uint64_t total_count = qemu_get_be64(f);
             uint64_t handled_count = 0, cur_count;
             uint64_t cur_gfn = addr / TARGET_PAGE_SIZE;
             uint8_t *buf = g_try_malloc(S390_SKEYS_BUFFER_SIZE);

             if (!buf) {
                 error_report("storage key load could not allocate memory");
                 ret = -ENOMEM;
                 break;
             }

             while (handled_count < total_count) {
                 cur_count = MIN(total_count - handled_count,
                                 S390_SKEYS_BUFFER_SIZE);
                 qemu_get_buffer(f, buf, cur_count);

                 ret = skeyclass->set_skeys(ss, cur_gfn, cur_count, buf);
                 if (ret < 0) {
                     error_report("S390_SET_KEYS error %d", ret);
                     break;
                 }
                 handled_count += cur_count;
                 cur_gfn += cur_count;
             }
             g_free(buf);
             break;
         }
         case S390_SKEYS_SAVE_FLAG_ERROR: {
             error_report("Storage key data is incomplete");
             ret = -EINVAL;
             break;
         }
         case S390_SKEYS_SAVE_FLAG_EOS:
             /* normal exit */
             return 0;
         default:
             error_report("Unexpected storage key flag data: %#x", flags);
             ret = -EINVAL;
         }
     }

     return ret;
 }

 static inline bool s390_skeys_get_migration_enabled(Object *obj, Error **errp)
 {
     S390SKeysState *ss = S390_SKEYS(obj);

     return ss->migration_enabled;
 }

 static SaveVMHandlers savevm_s390_storage_keys = {
     .save_state = s390_storage_keys_save,
     .load_state = s390_storage_keys_load,
 };

 static inline void s390_skeys_set_migration_enabled(Object *obj, bool value,
                                             Error **errp)
 {
     S390SKeysState *ss = S390_SKEYS(obj);

     /* Prevent double registration of savevm handler */
     if (ss->migration_enabled == value) {
         return;
     }

     ss->migration_enabled = value;

     if (ss->migration_enabled) {
         register_savevm_live(TYPE_S390_SKEYS, 0, 1,
                              &savevm_s390_storage_keys, ss);
     } else {
         unregister_savevm(VMSTATE_IF(ss), TYPE_S390_SKEYS, ss);
     }
 }

 static void s390_skeys_instance_init(Object *obj)
 {
     object_property_add_bool(obj, "migration-enabled",
                              s390_skeys_get_migration_enabled,
                              s390_skeys_set_migration_enabled);
     object_property_set_bool(obj, "migration-enabled", true, NULL);
 }

 static void s390_skeys_class_init(ObjectClass *oc, void *data)
 {
     DeviceClass *dc = DEVICE_CLASS(oc);

     dc->hotpluggable = false;
     set_bit(DEVICE_CATEGORY_MISC, dc->categories);
 }

 static const TypeInfo s390_skeys_info = {
     .name          = TYPE_S390_SKEYS,
     .parent        = TYPE_DEVICE,
     .instance_init = s390_skeys_instance_init,
     .instance_size = sizeof(S390SKeysState),
     .class_init    = s390_skeys_class_init,
     .class_size    = sizeof(S390SKeysClass),
     .abstract = true,
 };

 static void qemu_s390_skeys_register_types(void)
 {
     type_register_static(&s390_skeys_info);
     type_register_static(&qemu_s390_skeys_info);
 }

 type_init(qemu_s390_skeys_register_types)
	/*
	* s390 storage key device
	*
	* Copyright 2015 IBM Corp.
	* Author(s): Jason J. Herne <jjherne@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 "qemu/units.h"
	#include "hw/boards.h"
	#include "hw/s390x/storage-keys.h"
	#include "qapi/error.h"
	#include "qapi/qapi-commands-misc-target.h"
	#include "qapi/qmp/qdict.h"
	#include "qemu/error-report.h"
	#include "sysemu/memory_mapping.h"
	#include "exec/address-spaces.h"
	#include "sysemu/kvm.h"
	#include "migration/qemu-file-types.h"
	#include "migration/register.h"

	#define S390_SKEYS_BUFFER_SIZE (128 * KiB) /* Room for 128k storage keys */
	#define S390_SKEYS_SAVE_FLAG_EOS 0x01
	#define S390_SKEYS_SAVE_FLAG_SKEYS 0x02
	#define S390_SKEYS_SAVE_FLAG_ERROR 0x04

	S390SKeysState *s390_get_skeys_device(void)
	{
	S390SKeysState *ss;

	ss = S390_SKEYS(object_resolve_path_type("", TYPE_S390_SKEYS, NULL));
	assert(ss);
	return ss;
	}

	void s390_skeys_init(void)
	{
	Object *obj;

	if (kvm_enabled()) {
	obj = object_new(TYPE_KVM_S390_SKEYS);
	} else {
	obj = object_new(TYPE_QEMU_S390_SKEYS);
	}
	object_property_add_child(qdev_get_machine(), TYPE_S390_SKEYS,
	obj);
	object_unref(obj);

	qdev_realize(DEVICE(obj), NULL, &error_fatal);
	}

	static void write_keys(FILE f, uint8_t keys, uint64_t startgfn,
	uint64_t count, Error **errp)
	{
	uint64_t curpage = startgfn;
	uint64_t maxpage = curpage + count - 1;

	for (; curpage <= maxpage; curpage++) {
	uint8_t acc = (*keys & 0xF0) >> 4;
	int fp = (*keys & 0x08);
	int ref = (*keys & 0x04);
	int ch = (*keys & 0x02);
	int res = (*keys & 0x01);

	fprintf(f, "page=%03" PRIx64 ": key(%d) => ACC=%X, FP=%d, REF=%d,"
	" ch=%d, reserved=%d\n",
	curpage, *keys, acc, fp, ref, ch, res);
	keys++;
	}
	}

	void hmp_info_skeys(Monitor mon, const QDict qdict)
	{
	S390SKeysState *ss = s390_get_skeys_device();
	S390SKeysClass *skeyclass = S390_SKEYS_GET_CLASS(ss);
	uint64_t addr = qdict_get_int(qdict, "addr");
	uint8_t key;
	int r;

	/* Quick check to see if guest is using storage keys*/
	if (!skeyclass->skeys_are_enabled(ss)) {
	monitor_printf(mon, "Error: This guest is not using storage keys\n");
	return;
	}

	if (!address_space_access_valid(&address_space_memory,
	addr & TARGET_PAGE_MASK, TARGET_PAGE_SIZE,
	false, MEMTXATTRS_UNSPECIFIED)) {
	monitor_printf(mon, "Error: The given address is not valid\n");
	return;
	}

	r = skeyclass->get_skeys(ss, addr / TARGET_PAGE_SIZE, 1, &key);
	if (r < 0) {
	monitor_printf(mon, "Error: %s\n", strerror(-r));
	return;
	}

	monitor_printf(mon, " key: 0x%X\n", key);
	}

	void hmp_dump_skeys(Monitor mon, const QDict qdict)
	{
	const char *filename = qdict_get_str(qdict, "filename");
	Error *err = NULL;

	qmp_dump_skeys(filename, &err);
	if (err) {
	error_report_err(err);
	}
	}

	void qmp_dump_skeys(const char filename, Error *errp)
	{
	S390SKeysState *ss = s390_get_skeys_device();
	S390SKeysClass *skeyclass = S390_SKEYS_GET_CLASS(ss);
	GuestPhysBlockList guest_phys_blocks;
	GuestPhysBlock *block;
	uint64_t pages, gfn;
	Error *lerr = NULL;
	uint8_t *buf;
	int ret;
	int fd;
	FILE *f;

	/* Quick check to see if guest is using storage keys*/
	if (!skeyclass->skeys_are_enabled(ss)) {
	error_setg(errp, "This guest is not using storage keys - "
	"nothing to dump");
	return;
	}

	fd = qemu_open_old(filename, O_WRONLY \| O_CREAT \| O_TRUNC, 0600);
	if (fd < 0) {
	error_setg_file_open(errp, errno, filename);
	return;
	}
	f = fdopen(fd, "wb");
	if (!f) {
	close(fd);
	error_setg_file_open(errp, errno, filename);
	return;
	}

	buf = g_try_malloc(S390_SKEYS_BUFFER_SIZE);
	if (!buf) {
	error_setg(errp, "Could not allocate memory");
	goto out;
	}

	assert(qemu_mutex_iothread_locked());
	guest_phys_blocks_init(&guest_phys_blocks);
	guest_phys_blocks_append(&guest_phys_blocks);

	QTAILQ_FOREACH(block, &guest_phys_blocks.head, next) {
	assert(QEMU_IS_ALIGNED(block->target_start, TARGET_PAGE_SIZE));
	assert(QEMU_IS_ALIGNED(block->target_end, TARGET_PAGE_SIZE));

	gfn = block->target_start / TARGET_PAGE_SIZE;
	pages = (block->target_end - block->target_start) / TARGET_PAGE_SIZE;

	while (pages) {
	const uint64_t cur_pages = MIN(pages, S390_SKEYS_BUFFER_SIZE);

	ret = skeyclass->get_skeys(ss, gfn, cur_pages, buf);
	if (ret < 0) {
	error_setg_errno(errp, -ret, "get_keys error");
	goto out_free;
	}

	/* write keys to stream */
	write_keys(f, buf, gfn, cur_pages, &lerr);
	if (lerr) {
	goto out_free;
	}

	gfn += cur_pages;
	pages -= cur_pages;
	}
	}

	out_free:
	guest_phys_blocks_free(&guest_phys_blocks);
	error_propagate(errp, lerr);
	g_free(buf);
	out:
	fclose(f);
	}

	static bool qemu_s390_skeys_are_enabled(S390SKeysState *ss)
	{
	QEMUS390SKeysState *skeys = QEMU_S390_SKEYS(ss);

	/* Lockless check is sufficient. */
	return !!skeys->keydata;
	}

	static bool qemu_s390_enable_skeys(S390SKeysState *ss)
	{
	QEMUS390SKeysState *skeys = QEMU_S390_SKEYS(ss);
	static gsize initialized;

	if (likely(skeys->keydata)) {
	return true;
	}

	/*
	* TODO: Modern Linux doesn't use storage keys unless running KVM guests
	* that use storage keys. Therefore, we keep it simple for now.
	*
	* 1) We should initialize to "referenced+changed" for an initial
	* over-indication. Let's avoid touching megabytes of data for now and
	* assume that any sane user will issue a storage key instruction before
	* actually relying on this data.
	* 2) Relying on ram_size and allocating a big array is ugly. We should
	* allocate and manage storage key data per RAMBlock or optimally using
	* some sparse data structure.
	* 3) We only ever have a single S390SKeysState, so relying on
	* g_once_init_enter() is good enough.
	*/
	if (g_once_init_enter(&initialized)) {
	MachineState *machine = MACHINE(qdev_get_machine());

	skeys->key_count = machine->ram_size / TARGET_PAGE_SIZE;
	skeys->keydata = g_malloc0(skeys->key_count);
	g_once_init_leave(&initialized, 1);
	}
	return false;
	}

	static int qemu_s390_skeys_set(S390SKeysState *ss, uint64_t start_gfn,
	uint64_t count, uint8_t *keys)
	{
	QEMUS390SKeysState *skeydev = QEMU_S390_SKEYS(ss);
	int i;

	/* Check for uint64 overflow and access beyond end of key data */
	if (unlikely(!skeydev->keydata \|\| start_gfn + count > skeydev->key_count \|\|
	start_gfn + count < count)) {
	error_report("Error: Setting storage keys for pages with unallocated "
	"storage key memory: gfn=%" PRIx64 " count=%" PRId64,
	start_gfn, count);
	return -EINVAL;
	}

	for (i = 0; i < count; i++) {
	skeydev->keydata[start_gfn + i] = keys[i];
	}
	return 0;
	}

	static int qemu_s390_skeys_get(S390SKeysState *ss, uint64_t start_gfn,
	uint64_t count, uint8_t *keys)
	{
	QEMUS390SKeysState *skeydev = QEMU_S390_SKEYS(ss);
	int i;

	/* Check for uint64 overflow and access beyond end of key data */
	if (unlikely(!skeydev->keydata \|\| start_gfn + count > skeydev->key_count \|\|
	start_gfn + count < count)) {
	error_report("Error: Getting storage keys for pages with unallocated "
	"storage key memory: gfn=%" PRIx64 " count=%" PRId64,
	start_gfn, count);
	return -EINVAL;
	}

	for (i = 0; i < count; i++) {
	keys[i] = skeydev->keydata[start_gfn + i];
	}
	return 0;
	}

	static void qemu_s390_skeys_class_init(ObjectClass oc, void data)
	{
	S390SKeysClass *skeyclass = S390_SKEYS_CLASS(oc);
	DeviceClass *dc = DEVICE_CLASS(oc);

	skeyclass->skeys_are_enabled = qemu_s390_skeys_are_enabled;
	skeyclass->enable_skeys = qemu_s390_enable_skeys;
	skeyclass->get_skeys = qemu_s390_skeys_get;
	skeyclass->set_skeys = qemu_s390_skeys_set;

	/* Reason: Internal device (only one skeys device for the whole memory) */
	dc->user_creatable = false;
	}

	static const TypeInfo qemu_s390_skeys_info = {
	.name = TYPE_QEMU_S390_SKEYS,
	.parent = TYPE_S390_SKEYS,
	.instance_size = sizeof(QEMUS390SKeysState),
	.class_init = qemu_s390_skeys_class_init,
	.class_size = sizeof(S390SKeysClass),
	};

	static void s390_storage_keys_save(QEMUFile f, void opaque)
	{
	S390SKeysState *ss = S390_SKEYS(opaque);
	S390SKeysClass *skeyclass = S390_SKEYS_GET_CLASS(ss);
	GuestPhysBlockList guest_phys_blocks;
	GuestPhysBlock *block;
	uint64_t pages, gfn;
	int error = 0;
	uint8_t *buf;

	if (!skeyclass->skeys_are_enabled(ss)) {
	goto end_stream;
	}

	buf = g_try_malloc(S390_SKEYS_BUFFER_SIZE);
	if (!buf) {
	error_report("storage key save could not allocate memory");
	goto end_stream;
	}

	guest_phys_blocks_init(&guest_phys_blocks);
	guest_phys_blocks_append(&guest_phys_blocks);

	/* Send each contiguous physical memory range separately. */
	QTAILQ_FOREACH(block, &guest_phys_blocks.head, next) {
	assert(QEMU_IS_ALIGNED(block->target_start, TARGET_PAGE_SIZE));
	assert(QEMU_IS_ALIGNED(block->target_end, TARGET_PAGE_SIZE));

	gfn = block->target_start / TARGET_PAGE_SIZE;
	pages = (block->target_end - block->target_start) / TARGET_PAGE_SIZE;
	qemu_put_be64(f, block->target_start \| S390_SKEYS_SAVE_FLAG_SKEYS);
	qemu_put_be64(f, pages);

	while (pages) {
	const uint64_t cur_pages = MIN(pages, S390_SKEYS_BUFFER_SIZE);

	if (!error) {
	error = skeyclass->get_skeys(ss, gfn, cur_pages, buf);
	if (error) {
	/*
	* Create a valid stream with all 0x00 and indicate
	* S390_SKEYS_SAVE_FLAG_ERROR to the destination.
	*/
	error_report("S390_GET_KEYS error %d", error);
	memset(buf, 0, S390_SKEYS_BUFFER_SIZE);
	}
	}

	qemu_put_buffer(f, buf, cur_pages);
	gfn += cur_pages;
	pages -= cur_pages;
	}

	if (error) {
	break;
	}
	}

	guest_phys_blocks_free(&guest_phys_blocks);
	g_free(buf);
	end_stream:
	if (error) {
	qemu_put_be64(f, S390_SKEYS_SAVE_FLAG_ERROR);
	} else {
	qemu_put_be64(f, S390_SKEYS_SAVE_FLAG_EOS);
	}
	}

	static int s390_storage_keys_load(QEMUFile f, void opaque, int version_id)
	{
	S390SKeysState *ss = S390_SKEYS(opaque);
	S390SKeysClass *skeyclass = S390_SKEYS_GET_CLASS(ss);
	int ret = 0;

	/*
	* Make sure to lazy-enable if required to be done explicitly. No need to
	* flush any TLB as the VM is not running yet.
	*/
	if (skeyclass->enable_skeys) {
	skeyclass->enable_skeys(ss);
	}

	while (!ret) {
	ram_addr_t addr;
	int flags;

	addr = qemu_get_be64(f);
	flags = addr & ~TARGET_PAGE_MASK;
	addr &= TARGET_PAGE_MASK;

	switch (flags) {
	case S390_SKEYS_SAVE_FLAG_SKEYS: {
	const uint64_t total_count = qemu_get_be64(f);
	uint64_t handled_count = 0, cur_count;
	uint64_t cur_gfn = addr / TARGET_PAGE_SIZE;
	uint8_t *buf = g_try_malloc(S390_SKEYS_BUFFER_SIZE);

	if (!buf) {
	error_report("storage key load could not allocate memory");
	ret = -ENOMEM;
	break;
	}

	while (handled_count < total_count) {
	cur_count = MIN(total_count - handled_count,
	S390_SKEYS_BUFFER_SIZE);
	qemu_get_buffer(f, buf, cur_count);

	ret = skeyclass->set_skeys(ss, cur_gfn, cur_count, buf);
	if (ret < 0) {
	error_report("S390_SET_KEYS error %d", ret);
	break;
	}
	handled_count += cur_count;
	cur_gfn += cur_count;
	}
	g_free(buf);
	break;
	}
	case S390_SKEYS_SAVE_FLAG_ERROR: {
	error_report("Storage key data is incomplete");
	ret = -EINVAL;
	break;
	}
	case S390_SKEYS_SAVE_FLAG_EOS:
	/* normal exit */
	return 0;
	default:
	error_report("Unexpected storage key flag data: %#x", flags);
	ret = -EINVAL;
	}
	}

	return ret;
	}

	static inline bool s390_skeys_get_migration_enabled(Object obj, Error *errp)
	{
	S390SKeysState *ss = S390_SKEYS(obj);

	return ss->migration_enabled;
	}

	static SaveVMHandlers savevm_s390_storage_keys = {
	.save_state = s390_storage_keys_save,
	.load_state = s390_storage_keys_load,
	};

	static inline void s390_skeys_set_migration_enabled(Object *obj, bool value,
	Error **errp)
	{
	S390SKeysState *ss = S390_SKEYS(obj);

	/* Prevent double registration of savevm handler */
	if (ss->migration_enabled == value) {
	return;
	}

	ss->migration_enabled = value;

	if (ss->migration_enabled) {
	register_savevm_live(TYPE_S390_SKEYS, 0, 1,
	&savevm_s390_storage_keys, ss);
	} else {
	unregister_savevm(VMSTATE_IF(ss), TYPE_S390_SKEYS, ss);
	}
	}

	static void s390_skeys_instance_init(Object *obj)
	{
	object_property_add_bool(obj, "migration-enabled",
	s390_skeys_get_migration_enabled,
	s390_skeys_set_migration_enabled);
	object_property_set_bool(obj, "migration-enabled", true, NULL);
	}

	static void s390_skeys_class_init(ObjectClass oc, void data)
	{
	DeviceClass *dc = DEVICE_CLASS(oc);

	dc->hotpluggable = false;
	set_bit(DEVICE_CATEGORY_MISC, dc->categories);
	}

	static const TypeInfo s390_skeys_info = {
	.name = TYPE_S390_SKEYS,
	.parent = TYPE_DEVICE,
	.instance_init = s390_skeys_instance_init,
	.instance_size = sizeof(S390SKeysState),
	.class_init = s390_skeys_class_init,
	.class_size = sizeof(S390SKeysClass),
	.abstract = true,
	};

	static void qemu_s390_skeys_register_types(void)
	{
	type_register_static(&s390_skeys_info);
	type_register_static(&qemu_s390_skeys_info);
	}

	type_init(qemu_s390_skeys_register_types)