[Qemu-devel] [PATCH v2 0/5] s390: Support for Hotplug of Standby Memory

[Qemu-devel] [PATCH v2 0/5] s390: Support for Hotplug of Standby Memory

[Matthew Rosato]

This patchset adds support in s390 for a pool of standby memory,
which can be set online/offline by the guest (ie, via chmem).
New options, maxmem and slots, are added to the QEMU command line
memory parameter to specify the total amount of memory available 
to the guest as well as the number of memory slots available.
As part of this work, additional results are provided for the 
Read SCP Information SCLP, and new implentation is added for the 
Read Storage Element Information, Attach Storage Element, 
Assign Storage and Unassign Storage SCLPs, which enables the s390 
guest to manipulate the standby memory pool.

This patchset is based on work originally done by Jeng-Fang (Nick)
Wang.

This patchset has been built to apply on the s390-next tree at:

git://github.com/borntraeger/qemu.git s390-next

Changes for v2:
 * Removed the patch that introduced the standby-mem operand and 
   instead included Igor Mammedov's patches that add the mem-opts 
   'maxmem' and 'slots', with a slight modification due to the removal 
   of qemu_opts_create_nofail.
 * Patch 3 was inserted to add a new qom object that encapsulate variables 
   used by s390 memory hotplug.  Patches 4 and 5 adjusted to use this 
   object.
 * Added additional code comments and other minor changes per Alexander 
   Graf's comments

Igor Mammedov (2):
  vl: convert -m to QemuOpts
  vl.c: extend -m option to support options for memory hotplug

Matthew Rosato (3):
  sclp-s390: Add device to manage s390 memory hotplug
  virtio-ccw: Include standby memory when calculating storage increment
  sclp-s390: Add memory hotplug SCLPs

 hw/s390x/s390-virtio-ccw.c |   42 +++++--
 hw/s390x/sclp.c            |  276 ++++++++++++++++++++++++++++++++++++++++++--
 include/hw/s390x/sclp.h    |   19 +++
 qemu-options.hx            |   10 +-
 target-s390x/cpu.h         |   18 +++
 target-s390x/kvm.c         |    5 +
 vl.c                       |   98 ++++++++++++++--
 7 files changed, 440 insertions(+), 28 deletions(-)

-- 
1.7.9.5

[Qemu-devel] [PATCH v2 1/5] vl: convert -m to QemuOpts

[Matthew Rosato]

From: Igor Mammedov <imammedo@redhat.com>

Adds option to -m
 "mem" - startup memory amount

For compatibility with legacy CLI if suffix-less number is passed,
it assumes amount in Mb.

Otherwise user is free to use suffixed number using suffixes b,k/K,M,G

Signed-off-by: Igor Mammedov <imammedo@redhat.com>
---
 qemu-options.hx |    7 +++++--
 vl.c            |   53 ++++++++++++++++++++++++++++++++++++++++++-----------
 2 files changed, 47 insertions(+), 13 deletions(-)

diff --git a/qemu-options.hx b/qemu-options.hx
index 56e5fdf..4d7ef52 100644
--- a/qemu-options.hx
+++ b/qemu-options.hx
@@ -210,8 +210,11 @@ use is discouraged as it may be removed from future versions.
 ETEXI
 
 DEF("m", HAS_ARG, QEMU_OPTION_m,
-    "-m megs         set virtual RAM size to megs MB [default="
-    stringify(DEFAULT_RAM_SIZE) "]\n", QEMU_ARCH_ALL)
+    "-m [mem=]megs\n"
+    "                configure guest RAM\n"
+    "                mem: initial amount of guest memory (default: "
+    stringify(DEFAULT_RAM_SIZE) "Mb)\n",
+    QEMU_ARCH_ALL)
 STEXI
 @item -m @var{megs}
 @findex -m
diff --git a/vl.c b/vl.c
index 383be1b..a3e43d6 100644
--- a/vl.c
+++ b/vl.c
@@ -532,6 +532,20 @@ static QemuOptsList qemu_msg_opts = {
     },
 };
 
+static QemuOptsList qemu_mem_opts = {
+    .name = "memory-opts",
+    .implied_opt_name = "mem",
+    .head = QTAILQ_HEAD_INITIALIZER(qemu_mem_opts.head),
+    .merge_lists = true,
+    .desc = {
+        {
+            .name = "mem",
+            .type = QEMU_OPT_SIZE,
+        },
+        { /* end of list */ }
+    },
+};
+
 /**
  * Get machine options
  *
@@ -2877,6 +2891,7 @@ int main(int argc, char **argv, char **envp)
     };
     const char *trace_events = NULL;
     const char *trace_file = NULL;
+    const ram_addr_t default_ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
 
     atexit(qemu_run_exit_notifiers);
     error_set_progname(argv[0]);
@@ -2915,6 +2930,8 @@ int main(int argc, char **argv, char **envp)
     qemu_add_opts(&qemu_tpmdev_opts);
     qemu_add_opts(&qemu_realtime_opts);
     qemu_add_opts(&qemu_msg_opts);
+    qemu_add_opts(&qemu_mem_opts);
+    qemu_opts_create(&qemu_mem_opts, NULL, 0, &error_abort);
 
     runstate_init();
 
@@ -2930,7 +2947,7 @@ int main(int argc, char **argv, char **envp)
     module_call_init(MODULE_INIT_MACHINE);
     machine = find_default_machine();
     cpu_model = NULL;
-    ram_size = 0;
+    ram_size = default_ram_size;
     snapshot = 0;
     cyls = heads = secs = 0;
     translation = BIOS_ATA_TRANSLATION_AUTO;
@@ -3207,16 +3224,32 @@ int main(int argc, char **argv, char **envp)
                 exit(0);
                 break;
             case QEMU_OPTION_m: {
-                int64_t value;
                 uint64_t sz;
-                char *end;
+                const char *mem_str;
 
-                value = strtosz(optarg, &end);
-                if (value < 0 || *end) {
-                    fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
+                opts = qemu_opts_parse(qemu_find_opts("memory-opts"),
+                                       optarg, 1);
+
+                mem_str = qemu_opt_get(opts, "mem");
+                if (!mem_str) {
+                    fprintf(stderr, "qemu: invalid -m option, missing "
+                            " 'mem' option\n");
                     exit(1);
                 }
-                sz = QEMU_ALIGN_UP((uint64_t)value, 8192);
+
+                sz = qemu_opt_get_size(opts, "mem", ram_size);
+
+                /* Fix up legacy suffix-less format */
+                if (g_ascii_isdigit(mem_str[strlen(mem_str) - 1])) {
+                    sz <<= 20;
+                }
+
+                /* backward compatibility behaviour for case "-m 0" */
+                if (sz == 0) {
+                    sz = default_ram_size;
+                }
+
+                sz = QEMU_ALIGN_UP(sz, 8192);
                 ram_size = sz;
                 if (ram_size != sz) {
                     fprintf(stderr, "qemu: ram size too large\n");
@@ -4065,10 +4098,8 @@ int main(int argc, char **argv, char **envp)
         exit(1);
     }
 
-    /* init the memory */
-    if (ram_size == 0) {
-        ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
-    }
+    /* store value for the future use */
+    qemu_opt_set_number(opts, "mem", ram_size);
 
     if (qemu_opts_foreach(qemu_find_opts("device"), device_help_func, NULL, 0)
         != 0) {
-- 
1.7.9.5

[Qemu-devel] [PATCH v2 2/5] vl.c: extend -m option to support options for memory hotplug

[Matthew Rosato]

From: Igor Mammedov <imammedo@redhat.com>

Add following parameters:
  "slots" - total number of hotplug memory slots
  "maxmem" - maximum possible memory

"slots" and "maxmem" should go in pair and "maxmem" should be greater
than "mem" for memory hotplug to be enabled.

Signed-off-by: Igor Mammedov <imammedo@redhat.com>
---
 qemu-options.hx |    7 +++++--
 vl.c            |   45 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 50 insertions(+), 2 deletions(-)

diff --git a/qemu-options.hx b/qemu-options.hx
index 4d7ef52..ff60504 100644
--- a/qemu-options.hx
+++ b/qemu-options.hx
@@ -210,10 +210,13 @@ use is discouraged as it may be removed from future versions.
 ETEXI
 
 DEF("m", HAS_ARG, QEMU_OPTION_m,
-    "-m [mem=]megs\n"
+    "-m [mem=]megs[,slots=n,maxmem=size]\n"
     "                configure guest RAM\n"
     "                mem: initial amount of guest memory (default: "
-    stringify(DEFAULT_RAM_SIZE) "Mb)\n",
+    stringify(DEFAULT_RAM_SIZE) "Mb)\n"
+    "                slots=number of hotplug slots (default: none)\n"
+    "                maxmem=maximum amount of guest memory (default: none)\n"
+    "                slots and maxmem must be used together\n",
     QEMU_ARCH_ALL)
 STEXI
 @item -m @var{megs}
diff --git a/vl.c b/vl.c
index a3e43d6..d8ff51f 100644
--- a/vl.c
+++ b/vl.c
@@ -542,6 +542,14 @@ static QemuOptsList qemu_mem_opts = {
             .name = "mem",
             .type = QEMU_OPT_SIZE,
         },
+        {
+            .name = "slots",
+            .type = QEMU_OPT_NUMBER,
+        },
+        {
+            .name = "maxmem",
+            .type = QEMU_OPT_SIZE,
+        },
         { /* end of list */ }
     },
 };
@@ -3226,6 +3234,7 @@ int main(int argc, char **argv, char **envp)
             case QEMU_OPTION_m: {
                 uint64_t sz;
                 const char *mem_str;
+                const char *maxmem_str, *slots_str;
 
                 opts = qemu_opts_parse(qemu_find_opts("memory-opts"),
                                        optarg, 1);
@@ -3255,6 +3264,42 @@ int main(int argc, char **argv, char **envp)
                     fprintf(stderr, "qemu: ram size too large\n");
                     exit(1);
                 }
+
+                maxmem_str = qemu_opt_get(opts, "maxmem");
+                slots_str = qemu_opt_get(opts, "slots");
+                if (maxmem_str && slots_str) {
+                    uint64_t slots;
+
+                    sz = qemu_opt_get_size(opts, "maxmem", 0);
+                    if (sz < ram_size) {
+                        fprintf(stderr, "qemu: invalid -m option value: maxmem "
+                                "(%" PRIu64 ") <= initial memory (%"
+                                PRIu64 ")\n", sz, ram_size);
+                        exit(1);
+                    }
+
+                    slots = qemu_opt_get_number(opts, "slots", 0);
+                    if ((sz > ram_size) && !slots) {
+                        fprintf(stderr, "qemu: invalid -m option value: maxmem "
+                                "(%" PRIu64 ") more than initial memory (%"
+                                PRIu64 ") but no hotplug slots where "
+                                "specified\n", sz, ram_size);
+                        exit(1);
+                    }
+
+                    if ((sz <= ram_size) && slots) {
+                        fprintf(stderr, "qemu: invalid -m option value:  %"
+                                PRIu64 " hotplug slots where specified but "
+                                "maxmem (%" PRIu64 ") <= initial memory (%"
+                                PRIu64 ")\n", slots, sz, ram_size);
+                        exit(1);
+                    }
+                } else if ((!maxmem_str && slots_str) ||
+                           (maxmem_str && !slots_str)) {
+                    fprintf(stderr, "qemu: invalid -m option value: missing "
+                            "'%s' option\n", slots_str ? "maxmem" : "slots");
+                    exit(1);
+                }
                 break;
             }
 #ifdef CONFIG_TPM
-- 
1.7.9.5

[Qemu-devel] [PATCH v2 3/5] sclp-s390: Add device to manage s390 memory hotplug

[Matthew Rosato]

Add sclpMemoryHotplugDev to contain associated data structures, etc.

Signed-off-by: Matthew Rosato <mjrosato@linux.vnet.ibm.com>
---
 hw/s390x/sclp.c         |   32 ++++++++++++++++++++++++++++++++
 include/hw/s390x/sclp.h |   19 +++++++++++++++++++
 2 files changed, 51 insertions(+)

diff --git a/hw/s390x/sclp.c b/hw/s390x/sclp.c
index d8ddf35..338dbdf 100644
--- a/hw/s390x/sclp.c
+++ b/hw/s390x/sclp.c
@@ -183,3 +183,35 @@ void s390_sclp_init(void)
                               OBJECT(dev), NULL);
     qdev_init_nofail(dev);
 }
+
+sclpMemoryHotplugDev *get_sclp_memory_hotplug_dev(void)
+{
+    DeviceState *dev;
+    ObjectProperty *op = object_property_find(qdev_get_machine(),
+                                              TYPE_SCLP_MEMORY_HOTPLUG_DEV,
+                                              NULL);
+    if (!op) {
+        dev = qdev_create(NULL, TYPE_SCLP_MEMORY_HOTPLUG_DEV);
+        object_property_add_child(qdev_get_machine(),
+                                  TYPE_SCLP_MEMORY_HOTPLUG_DEV,
+                                  OBJECT(dev), NULL);
+        qdev_init_nofail(dev);
+        op = object_property_find(qdev_get_machine(),
+                                  TYPE_SCLP_MEMORY_HOTPLUG_DEV,
+                                  NULL);
+    }
+
+    return op->opaque;
+}
+
+static TypeInfo sclp_memory_hotplug_dev_info = {
+    .name = TYPE_SCLP_MEMORY_HOTPLUG_DEV,
+    .parent = TYPE_DEVICE,
+    .instance_size = sizeof(sclpMemoryHotplugDev),
+};
+
+static void register_types(void)
+{
+    type_register_static(&sclp_memory_hotplug_dev_info);
+}
+type_init(register_types);
diff --git a/include/hw/s390x/sclp.h b/include/hw/s390x/sclp.h
index 7ef1622..bbcc181 100644
--- a/include/hw/s390x/sclp.h
+++ b/include/hw/s390x/sclp.h
@@ -156,6 +156,24 @@ typedef struct SCCB {
     char data[SCCB_DATA_LEN];
  } QEMU_PACKED SCCB;
 
+typedef struct sclpMemoryHotplugDev sclpMemoryHotplugDev;
+
+#define TYPE_SCLP_MEMORY_HOTPLUG_DEV "sclp-memory-hotplug-dev"
+#define SCLP_MEMORY_HOTPLUG_DEV(obj) \
+  OBJECT_CHECK(sclpMemoryHotplugDev, (obj), TYPE_SCLP_MEMORY_HOTPLUG_DEV)
+
+struct sclpMemoryHotplugDev {
+    DeviceState parent;
+    ram_addr_t standby_mem_size;
+    ram_addr_t padded_ram_size;
+    ram_addr_t pad_size;
+    ram_addr_t standby_subregion_size;
+    ram_addr_t rzm;
+    int shift;
+    char *standby_state_map;
+};
+
+
 static inline int sccb_data_len(SCCB *sccb)
 {
     return be16_to_cpu(sccb->h.length) - sizeof(sccb->h);
@@ -163,6 +181,7 @@ static inline int sccb_data_len(SCCB *sccb)
 
 
 void s390_sclp_init(void);
+sclpMemoryHotplugDev *get_sclp_memory_hotplug_dev(void);
 void sclp_service_interrupt(uint32_t sccb);
 void raise_irq_cpu_hotplug(void);
 
-- 
1.7.9.5

[Qemu-devel] [PATCH v2 4/5] virtio-ccw: Include standby memory when calculating storage increment

[Matthew Rosato]

When determining the memory increment size, use the maxmem size if
it was specified.

Signed-off-by: Matthew Rosato <mjrosato@linux.vnet.ibm.com>
---
 hw/s390x/s390-virtio-ccw.c |   42 ++++++++++++++++++++++++++++++++++--------
 target-s390x/cpu.h         |    3 +++
 2 files changed, 37 insertions(+), 8 deletions(-)

diff --git a/hw/s390x/s390-virtio-ccw.c b/hw/s390x/s390-virtio-ccw.c
index 0d4f6ae..4877d57 100644
--- a/hw/s390x/s390-virtio-ccw.c
+++ b/hw/s390x/s390-virtio-ccw.c
@@ -17,6 +17,7 @@
 #include "ioinst.h"
 #include "css.h"
 #include "virtio-ccw.h"
+#include "qemu/config-file.h"
 
 void io_subsystem_reset(void)
 {
@@ -84,17 +85,31 @@ static void ccw_init(QEMUMachineInitArgs *args)
     ram_addr_t my_ram_size = args->ram_size;
     MemoryRegion *sysmem = get_system_memory();
     MemoryRegion *ram = g_new(MemoryRegion, 1);
-    int shift = 0;
+    sclpMemoryHotplugDev *mhd = get_sclp_memory_hotplug_dev();
     uint8_t *storage_keys;
     int ret;
     VirtualCssBus *css_bus;
-
-    /* s390x ram size detection needs a 16bit multiplier + an increment. So
-       guests > 64GB can be specified in 2MB steps etc. */
-    while ((my_ram_size >> (20 + shift)) > 65535) {
-        shift++;
+    QemuOpts *opts = qemu_opts_find(qemu_find_opts("memory-opts"), NULL);
+    ram_addr_t pad_size = 0;
+    ram_addr_t maxmem = qemu_opt_get_size(opts, "maxmem", 0);
+    ram_addr_t standby_mem_size = maxmem - my_ram_size;
+
+    /* The storage increment size is a multiple of 1M and is a power of 2.
+     * The number of storage increments must be 1020 or fewer.
+     * The variable 'mhd->shift' retains the increment size, in the
+     * form of increment_size = (2^shift) MBytes */
+    while ((my_ram_size >> (20 + mhd->shift)) > 1020) {
+        mhd->shift++;
+    }
+    while ((mhd->standby_mem_size >> (20 + mhd->shift)) > 1020) {
+        mhd->shift++;
     }
-    my_ram_size = my_ram_size >> (20 + shift) << (20 + shift);
+
+    /* The core and standby memory areas need to be aligned with
+     * the increment size */
+    standby_mem_size = standby_mem_size >> (20 + mhd->shift)
+                                        << (20 + mhd->shift);
+    my_ram_size = my_ram_size >> (20 + mhd->shift) << (20 + mhd->shift);
 
     /* let's propagate the changed ram size into the global variable. */
     ram_size = my_ram_size;
@@ -109,11 +124,22 @@ static void ccw_init(QEMUMachineInitArgs *args)
     /* register hypercalls */
     virtio_ccw_register_hcalls();
 
-    /* allocate RAM */
+    /* allocate RAM for core */
     memory_region_init_ram(ram, NULL, "s390.ram", my_ram_size);
     vmstate_register_ram_global(ram);
     memory_region_add_subregion(sysmem, 0, ram);
 
+    /* If the size of ram is not on a MEM_SECTION_SIZE boundary,
+       calculate the pad size necessary to force this boundary. */
+    if (standby_mem_size) {
+        if (my_ram_size % MEM_SECTION_SIZE) {
+            pad_size = MEM_SECTION_SIZE - my_ram_size % MEM_SECTION_SIZE;
+        }
+        my_ram_size += standby_mem_size + pad_size;
+        mhd->pad_size = pad_size;
+        mhd->standby_mem_size = standby_mem_size;
+    }
+
     /* allocate storage keys */
     storage_keys = g_malloc0(my_ram_size / TARGET_PAGE_SIZE);
 
diff --git a/target-s390x/cpu.h b/target-s390x/cpu.h
index 9673838..8d25fef 100644
--- a/target-s390x/cpu.h
+++ b/target-s390x/cpu.h
@@ -380,6 +380,9 @@ unsigned s390_del_running_cpu(S390CPU *cpu);
 /* service interrupts are floating therefore we must not pass an cpustate */
 void s390_sclp_extint(uint32_t parm);
 
+/* from s390-virtio-ccw */
+#define MEM_SECTION_SIZE             0x10000000UL
+
 /* from s390-virtio-bus */
 extern const hwaddr virtio_size;
 
-- 
1.7.9.5

[Qemu-devel] [PATCH v2 5/5] sclp-s390: Add memory hotplug SCLPs

[Matthew Rosato]

Add memory information to read SCP info and add handlers for
Read Storage Element Information, Attach Storage Element,
Assign Storage and Unassign Storage.

Signed-off-by: Matthew Rosato <mjrosato@linux.vnet.ibm.com>
---
 hw/s390x/sclp.c    |  244 ++++++++++++++++++++++++++++++++++++++++++++++++++--
 target-s390x/cpu.h |   15 ++++
 target-s390x/kvm.c |    5 ++
 3 files changed, 257 insertions(+), 7 deletions(-)

diff --git a/hw/s390x/sclp.c b/hw/s390x/sclp.c
index 338dbdf..ea6cf60 100644
--- a/hw/s390x/sclp.c
+++ b/hw/s390x/sclp.c
@@ -16,7 +16,8 @@
 #include "sysemu/kvm.h"
 #include "exec/memory.h"
 #include "sysemu/sysemu.h"
-
+#include "exec/address-spaces.h"
+#include "qemu/config-file.h"
 #include "hw/s390x/sclp.h"
 #include "hw/s390x/event-facility.h"
 
@@ -33,10 +34,18 @@ static inline SCLPEventFacility *get_event_facility(void)
 static void read_SCP_info(SCCB *sccb)
 {
     ReadInfo *read_info = (ReadInfo *) sccb;
+    sclpMemoryHotplugDev *mhd = get_sclp_memory_hotplug_dev();
     CPUState *cpu;
-    int shift = 0;
     int cpu_count = 0;
     int i = 0;
+    int rnsize, rnmax;
+    QemuOpts *opts = qemu_opts_find(qemu_find_opts("memory-opts"), NULL);
+    int slots = qemu_opt_get_number(opts, "slots", 0);
+    int max_avail_slots = s390_get_memslot_count(kvm_state);
+
+    if (slots > max_avail_slots) {
+        slots = max_avail_slots;
+    }
 
     CPU_FOREACH(cpu) {
         cpu_count++;
@@ -52,16 +61,221 @@ static void read_SCP_info(SCCB *sccb)
         read_info->entries[i].type = 0;
     }
 
-    read_info->facilities = cpu_to_be64(SCLP_HAS_CPU_INFO);
+    /*
+     * The storage increment size is a multiple of 1M and is a power of 2.
+     * The number of storage increments must be 1020 or fewer.
+     */
+    while ((ram_size >> (20 + mhd->shift)) > 1020) {
+        mhd->shift++;
+    }
+    while ((mhd->standby_mem_size >> (20 + mhd->shift)) > 1020) {
+        mhd->shift++;
+    }
+
+    mhd->standby_subregion_size = MEM_SECTION_SIZE;
+    /* Deduct the memory slot already used for core */
+    if (slots > 0) {
+        while ((mhd->standby_subregion_size * (slots - 1)
+                < mhd->standby_mem_size)) {
+            mhd->standby_subregion_size = mhd->standby_subregion_size << 1;
+        }
+    }
+    /*
+     * Initialize mapping of guest standby memory sections indicating which
+     * are and are not online. Assume all standby memory begins offline.
+     */
+    if (mhd->standby_state_map == 0) {
+        if (mhd->standby_mem_size % mhd->standby_subregion_size) {
+            mhd->standby_state_map = g_malloc0((mhd->standby_mem_size /
+                                           mhd->standby_subregion_size + 1) *
+                                          (mhd->standby_subregion_size /
+                                           MEM_SECTION_SIZE));
+        } else {
+            mhd->standby_state_map = g_malloc0(mhd->standby_mem_size /
+                                               MEM_SECTION_SIZE);
+        }
+    }
+
+    mhd->padded_ram_size = ram_size + mhd->pad_size;
+    mhd->rzm = 1 << (20 + mhd->shift);
+    rnsize = 1 << mhd->shift;
+    if (rnsize <= 128) {
+        read_info->rnsize = rnsize;
+    } else {
+        read_info->rnsize = 0;
+        read_info->rnsize2 = cpu_to_be32(rnsize);
+    }
 
-    while ((ram_size >> (20 + shift)) > 65535) {
-        shift++;
+    rnmax = ((ram_size + mhd->standby_mem_size + mhd->pad_size)
+             >> (20 + mhd->shift));
+    if (rnmax < 0x10000) {
+        read_info->rnmax = cpu_to_be16(rnmax);
+    } else {
+        read_info->rnmax = cpu_to_be16(0);
+        read_info->rnmax2 = cpu_to_be64(rnmax);
     }
-    read_info->rnmax = cpu_to_be16(ram_size >> (20 + shift));
-    read_info->rnsize = 1 << shift;
+
+    read_info->facilities = cpu_to_be64(SCLP_HAS_CPU_INFO |
+                                        SCLP_FC_ASSIGN_ATTACH_READ_STOR);
+
     sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_READ_COMPLETION);
 }
 
+static void read_storage_element0_info(SCCB *sccb)
+{
+    int i, assigned;
+    int subincrement_id = SCLP_STARTING_SUBINCREMENT_ID;
+    ReadStorageElementInfo *storage_info = (ReadStorageElementInfo *) sccb;
+    sclpMemoryHotplugDev *mhd = get_sclp_memory_hotplug_dev();
+
+    if ((ram_size >> (20 + mhd->shift)) >= 0x10000) {
+        sccb->h.response_code = cpu_to_be16(SCLP_RC_SCCB_BOUNDARY_VIOLATION);
+        return;
+    }
+
+    /* Return information regarding core memory */
+    storage_info->max_id = cpu_to_be16(mhd->standby_mem_size ? 1 : 0);
+    assigned = ram_size >> (20 + mhd->shift);
+    storage_info->assigned = cpu_to_be16(assigned);
+
+    for (i = 0; i < assigned; i++) {
+        storage_info->entries[i] = cpu_to_be32(subincrement_id);
+        subincrement_id += SCLP_INCREMENT_UNIT;
+    }
+    sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_READ_COMPLETION);
+}
+
+static void read_storage_element1_info(SCCB *sccb)
+{
+    ReadStorageElementInfo *storage_info = (ReadStorageElementInfo *) sccb;
+    sclpMemoryHotplugDev *mhd = get_sclp_memory_hotplug_dev();
+
+    if ((mhd->standby_mem_size >> (20 + mhd->shift)) >= 0x10000) {
+        sccb->h.response_code = cpu_to_be16(SCLP_RC_SCCB_BOUNDARY_VIOLATION);
+        return;
+    }
+
+    /* Return information regarding standby memory */
+    storage_info->max_id = cpu_to_be16(mhd->standby_mem_size ? 1 : 0);
+    storage_info->assigned = cpu_to_be16(mhd->standby_mem_size >>
+                                         (20 + mhd->shift));
+    storage_info->standby = cpu_to_be16(mhd->standby_mem_size >>
+                                        (20 + mhd->shift));
+    sccb->h.response_code = cpu_to_be16(SCLP_RC_STANDBY_READ_COMPLETION);
+}
+
+static void attach_storage_element(SCCB *sccb, uint16_t element)
+{
+    int i, assigned, subincrement_id;
+    AttachStorageElement *attach_info = (AttachStorageElement *) sccb;
+    sclpMemoryHotplugDev *mhd = get_sclp_memory_hotplug_dev();
+
+    if (element != 1) {
+        sccb->h.response_code = cpu_to_be16(SCLP_RC_INVALID_SCLP_COMMAND);
+        return;
+    }
+
+    assigned = mhd->standby_mem_size >> (20 + mhd->shift);
+    attach_info->assigned = cpu_to_be16(assigned);
+    subincrement_id = ((ram_size >> (20 + mhd->shift)) << 16)
+                      + SCLP_STARTING_SUBINCREMENT_ID;
+    for (i = 0; i < assigned; i++) {
+        attach_info->entries[i] = cpu_to_be32(subincrement_id);
+        subincrement_id += SCLP_INCREMENT_UNIT;
+    }
+    sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_COMPLETION);
+}
+
+static void assign_storage(SCCB *sccb)
+{
+    MemoryRegion *mr = NULL;
+    int this_subregion_size;
+    AssignStorage *assign_info = (AssignStorage *) sccb;
+    sclpMemoryHotplugDev *mhd = get_sclp_memory_hotplug_dev();
+    ram_addr_t assign_addr = (assign_info->rn - 1) * mhd->rzm;
+    MemoryRegion *sysmem = get_system_memory();
+
+    if ((assign_addr % MEM_SECTION_SIZE == 0) &&
+        (assign_addr >= mhd->padded_ram_size)) {
+        /* Re-use existing memory region if found */
+        mr = memory_region_find(sysmem, assign_addr, 1).mr;
+        if (!mr) {
+
+            MemoryRegion *standby_ram = g_new(MemoryRegion, 1);
+
+            /* offset to align to standby_subregion_size for allocation */
+            ram_addr_t offset = assign_addr -
+                                (assign_addr - mhd->padded_ram_size)
+                                % mhd->standby_subregion_size;
+
+            /* strlen("standby.ram") + 4 (Max of KVM_MEMORY_SLOTS) +  NULL */
+            char id[16];
+            snprintf(id, 16, "standby.ram%d",
+                     (int)((offset - mhd->padded_ram_size) /
+                     mhd->standby_subregion_size) + 1);
+
+            /* Allocate a subregion of the calculated standby_subregion_size */
+            if (offset + mhd->standby_subregion_size >
+                mhd->padded_ram_size + mhd->standby_mem_size) {
+                this_subregion_size = mhd->padded_ram_size +
+                  mhd->standby_mem_size - offset;
+            } else {
+                this_subregion_size = mhd->standby_subregion_size;
+            }
+
+            memory_region_init_ram(standby_ram, NULL, id, this_subregion_size);
+            vmstate_register_ram_global(standby_ram);
+            memory_region_add_subregion(sysmem, offset, standby_ram);
+        }
+        /* The specified subregion is no longer in standby */
+        mhd->standby_state_map[(assign_addr - mhd->padded_ram_size)
+                               / MEM_SECTION_SIZE] = 1;
+    }
+    sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_COMPLETION);
+}
+
+static void unassign_storage(SCCB *sccb)
+{
+    MemoryRegion *mr = NULL;
+    AssignStorage *assign_info = (AssignStorage *) sccb;
+    sclpMemoryHotplugDev *mhd = get_sclp_memory_hotplug_dev();
+    ram_addr_t unassign_addr = (assign_info->rn - 1) * mhd->rzm;
+    MemoryRegion *sysmem = get_system_memory();
+
+    /* if the addr is a multiple of 256 MB */
+    if ((unassign_addr % MEM_SECTION_SIZE == 0) &&
+        (unassign_addr >= mhd->padded_ram_size)) {
+        mhd->standby_state_map[(unassign_addr -
+                           mhd->padded_ram_size) / MEM_SECTION_SIZE] = 0;
+
+        /* find the specified memory region and destroy it */
+        mr = memory_region_find(sysmem, unassign_addr, 1).mr;
+        if (mr) {
+            int i;
+            int is_removable = 1;
+            ram_addr_t map_offset = (unassign_addr - mhd->padded_ram_size -
+                                     (unassign_addr - mhd->padded_ram_size)
+                                     % mhd->standby_subregion_size);
+            /* Mark all affected subregions as 'standby' once again */
+            for (i = 0;
+                 i < (mhd->standby_subregion_size / MEM_SECTION_SIZE);
+                 i++) {
+
+                if (mhd->standby_state_map[i + map_offset / MEM_SECTION_SIZE]) {
+                    is_removable = 0;
+                    break;
+                }
+            }
+            if (is_removable) {
+                memory_region_del_subregion(sysmem, mr);
+                memory_region_destroy(mr);
+                g_free(mr);
+            }
+        }
+    }
+    sccb->h.response_code = cpu_to_be16(SCLP_RC_NORMAL_COMPLETION);
+}
+
 /* Provide information about the CPU */
 static void sclp_read_cpu_info(SCCB *sccb)
 {
@@ -103,6 +317,22 @@ static void sclp_execute(SCCB *sccb, uint32_t code)
     case SCLP_CMDW_READ_CPU_INFO:
         sclp_read_cpu_info(sccb);
         break;
+    case SCLP_READ_STORAGE_ELEMENT_INFO:
+        if (code & 0xff00) {
+            read_storage_element1_info(sccb);
+        } else {
+            read_storage_element0_info(sccb);
+        }
+        break;
+    case SCLP_ATTACH_STORAGE_ELEMENT:
+        attach_storage_element(sccb, (code & 0xff00) >> 8);
+        break;
+    case SCLP_ASSIGN_STORAGE:
+        assign_storage(sccb);
+        break;
+    case SCLP_UNASSIGN_STORAGE:
+        unassign_storage(sccb);
+        break;
     default:
         efc->command_handler(ef, sccb, code);
         break;
diff --git a/target-s390x/cpu.h b/target-s390x/cpu.h
index 8d25fef..47aa46a 100644
--- a/target-s390x/cpu.h
+++ b/target-s390x/cpu.h
@@ -382,6 +382,7 @@ void s390_sclp_extint(uint32_t parm);
 
 /* from s390-virtio-ccw */
 #define MEM_SECTION_SIZE             0x10000000UL
+#define MAX_AVAIL_SLOTS              32
 
 /* from s390-virtio-bus */
 extern const hwaddr virtio_size;
@@ -1074,6 +1075,7 @@ void kvm_s390_enable_css_support(S390CPU *cpu);
 int kvm_s390_assign_subch_ioeventfd(EventNotifier *notifier, uint32_t sch,
                                     int vq, bool assign);
 int kvm_s390_cpu_restart(S390CPU *cpu);
+int kvm_s390_get_memslot_count(KVMState *s);
 #else
 static inline void kvm_s390_io_interrupt(S390CPU *cpu,
                                         uint16_t subchannel_id,
@@ -1098,6 +1100,10 @@ static inline int kvm_s390_cpu_restart(S390CPU *cpu)
 {
     return -ENOSYS;
 }
+static inline int kvm_s390_get_memslot_count(KVMState *s)
+{
+  return MAX_AVAIL_SLOTS;
+}
 #endif
 
 static inline int s390_cpu_restart(S390CPU *cpu)
@@ -1108,6 +1114,15 @@ static inline int s390_cpu_restart(S390CPU *cpu)
     return -ENOSYS;
 }
 
+static inline int s390_get_memslot_count(KVMState *s)
+{
+    if (kvm_enabled()) {
+        return kvm_s390_get_memslot_count(s);
+    } else {
+        return MAX_AVAIL_SLOTS;
+    }
+}
+
 static inline void s390_io_interrupt(S390CPU *cpu,
                                      uint16_t subchannel_id,
                                      uint16_t subchannel_nr,
diff --git a/target-s390x/kvm.c b/target-s390x/kvm.c
index 20c711f..4a8aa7b 100644
--- a/target-s390x/kvm.c
+++ b/target-s390x/kvm.c
@@ -917,3 +917,8 @@ int kvm_s390_assign_subch_ioeventfd(EventNotifier *notifier, uint32_t sch,
     }
     return kvm_vm_ioctl(kvm_state, KVM_IOEVENTFD, &kick);
 }
+
+int kvm_s390_get_memslot_count(KVMState *s)
+{
+    return kvm_check_extension(s, KVM_CAP_NR_MEMSLOTS);
+}
-- 
1.7.9.5

Re: [Qemu-devel] [PATCH v2 0/5] s390: Support for Hotplug of Standby Memory

[Christian Borntraeger]

On 24/02/14 22:30, Matthew Rosato wrote:
> This patchset adds support in s390 for a pool of standby memory,
> which can be set online/offline by the guest (ie, via chmem).
> New options, maxmem and slots, are added to the QEMU command line
> memory parameter to specify the total amount of memory available 
> to the guest as well as the number of memory slots available.
> As part of this work, additional results are provided for the 
> Read SCP Information SCLP, and new implentation is added for the 
> Read Storage Element Information, Attach Storage Element, 
> Assign Storage and Unassign Storage SCLPs, which enables the s390 
> guest to manipulate the standby memory pool.

Looks like Paolo will apply Igors latest patches to the numa branch,
I will defer patches 3-5 until Igors patches hit qemu master.

Christian

> 
> This patchset is based on work originally done by Jeng-Fang (Nick)
> Wang.
> 
> This patchset has been built to apply on the s390-next tree at:
> 
> git://github.com/borntraeger/qemu.git s390-next
> 
> Changes for v2:
>  * Removed the patch that introduced the standby-mem operand and 
>    instead included Igor Mammedov's patches that add the mem-opts 
>    'maxmem' and 'slots', with a slight modification due to the removal 
>    of qemu_opts_create_nofail.
>  * Patch 3 was inserted to add a new qom object that encapsulate variables 
>    used by s390 memory hotplug.  Patches 4 and 5 adjusted to use this 
>    object.
>  * Added additional code comments and other minor changes per Alexander 
>    Graf's comments
> 
> Igor Mammedov (2):
>   vl: convert -m to QemuOpts
>   vl.c: extend -m option to support options for memory hotplug
> 
> Matthew Rosato (3):
>   sclp-s390: Add device to manage s390 memory hotplug
>   virtio-ccw: Include standby memory when calculating storage increment
>   sclp-s390: Add memory hotplug SCLPs
> 
>  hw/s390x/s390-virtio-ccw.c |   42 +++++--
>  hw/s390x/sclp.c            |  276 ++++++++++++++++++++++++++++++++++++++++++--
>  include/hw/s390x/sclp.h    |   19 +++
>  qemu-options.hx            |   10 +-
>  target-s390x/cpu.h         |   18 +++
>  target-s390x/kvm.c         |    5 +
>  vl.c                       |   98 ++++++++++++++--
>  7 files changed, 440 insertions(+), 28 deletions(-)
> 

Re: [Qemu-devel] [PATCH v2 0/5] s390: Support for Hotplug of Standby Memory

[Paolo Bonzini]

Il 26/02/2014 15:42, Christian Borntraeger ha scritto:
> On 24/02/14 22:30, Matthew Rosato wrote:
>> This patchset adds support in s390 for a pool of standby memory,
>> which can be set online/offline by the guest (ie, via chmem).
>> New options, maxmem and slots, are added to the QEMU command line
>> memory parameter to specify the total amount of memory available
>> to the guest as well as the number of memory slots available.
>> As part of this work, additional results are provided for the
>> Read SCP Information SCLP, and new implentation is added for the
>> Read Storage Element Information, Attach Storage Element,
>> Assign Storage and Unassign Storage SCLPs, which enables the s390
>> guest to manipulate the standby memory pool.
>
> Looks like Paolo will apply Igors latest patches to the numa branch,
> I will defer patches 3-5 until Igors patches hit qemu master.

What are the dependencies of these series?  I can include it in my queue if:

(a) you give me your Acked-by

(b) Igor reviews it and tells me if this is the right version of his 
patch "extend -m option to support options for memory hotplug"

Paolo

> Christian
>
>>
>> This patchset is based on work originally done by Jeng-Fang (Nick)
>> Wang.
>>
>> This patchset has been built to apply on the s390-next tree at:
>>
>> git://github.com/borntraeger/qemu.git s390-next
>>
>> Changes for v2:
>>  * Removed the patch that introduced the standby-mem operand and
>>    instead included Igor Mammedov's patches that add the mem-opts
>>    'maxmem' and 'slots', with a slight modification due to the removal
>>    of qemu_opts_create_nofail.
>>  * Patch 3 was inserted to add a new qom object that encapsulate variables
>>    used by s390 memory hotplug.  Patches 4 and 5 adjusted to use this
>>    object.
>>  * Added additional code comments and other minor changes per Alexander
>>    Graf's comments
>>
>> Igor Mammedov (2):
>>   vl: convert -m to QemuOpts
>>   vl.c: extend -m option to support options for memory hotplug
>>
>> Matthew Rosato (3):
>>   sclp-s390: Add device to manage s390 memory hotplug
>>   virtio-ccw: Include standby memory when calculating storage increment
>>   sclp-s390: Add memory hotplug SCLPs
>>
>>  hw/s390x/s390-virtio-ccw.c |   42 +++++--
>>  hw/s390x/sclp.c            |  276 ++++++++++++++++++++++++++++++++++++++++++--
>>  include/hw/s390x/sclp.h    |   19 +++
>>  qemu-options.hx            |   10 +-
>>  target-s390x/cpu.h         |   18 +++
>>  target-s390x/kvm.c         |    5 +
>>  vl.c                       |   98 ++++++++++++++--
>>  7 files changed, 440 insertions(+), 28 deletions(-)
>>
>

Re: [Qemu-devel] [PATCH v2 0/5] s390: Support for Hotplug of Standby Memory

[Christian Borntraeger]

On 26/02/14 15:45, Paolo Bonzini wrote:
> Il 26/02/2014 15:42, Christian Borntraeger ha scritto:
>> On 24/02/14 22:30, Matthew Rosato wrote:
>>> This patchset adds support in s390 for a pool of standby memory,
>>> which can be set online/offline by the guest (ie, via chmem).
>>> New options, maxmem and slots, are added to the QEMU command line
>>> memory parameter to specify the total amount of memory available
>>> to the guest as well as the number of memory slots available.
>>> As part of this work, additional results are provided for the
>>> Read SCP Information SCLP, and new implentation is added for the
>>> Read Storage Element Information, Attach Storage Element,
>>> Assign Storage and Unassign Storage SCLPs, which enables the s390
>>> guest to manipulate the standby memory pool.
>>
>> Looks like Paolo will apply Igors latest patches to the numa branch,
>> I will defer patches 3-5 until Igors patches hit qemu master.
> 
> What are the dependencies of these series?  I can include it in my queue if:

The last version of the "memory hotplug" platches (its actually concept called
standby memory that the guest can request to be enabled from the hypervisor)
gained feedback from you to use Igors patch set instead of cooking up a new parameter
(http://lists.gnu.org/archive/html/qemu-devel/2013-12/msg03081.html)

Seems that the latest version
(https://lists.gnu.org/archive/html/qemu-devel/2014-02/msg02321.html)
does not match the patch in this series.

I have not fully reviewed patches 3-5 yet, so lets just defer memory hotplug
on s390 until Igors patch hit master.

Christian

> 
> (a) you give me your Acked-by
> 
> (b) Igor reviews it and tells me if this is the right version of his patch "extend -m option to support options for memory hotplug"
> 
> Paolo
> 
>> Christian
>>
>>>
>>> This patchset is based on work originally done by Jeng-Fang (Nick)
>>> Wang.
>>>
>>> This patchset has been built to apply on the s390-next tree at:
>>>
>>> git://github.com/borntraeger/qemu.git s390-next
>>>
>>> Changes for v2:
>>>  * Removed the patch that introduced the standby-mem operand and
>>>    instead included Igor Mammedov's patches that add the mem-opts
>>>    'maxmem' and 'slots', with a slight modification due to the removal
>>>    of qemu_opts_create_nofail.
>>>  * Patch 3 was inserted to add a new qom object that encapsulate variables
>>>    used by s390 memory hotplug.  Patches 4 and 5 adjusted to use this
>>>    object.
>>>  * Added additional code comments and other minor changes per Alexander
>>>    Graf's comments
>>>
>>> Igor Mammedov (2):
>>>   vl: convert -m to QemuOpts
>>>   vl.c: extend -m option to support options for memory hotplug
>>>
>>> Matthew Rosato (3):
>>>   sclp-s390: Add device to manage s390 memory hotplug
>>>   virtio-ccw: Include standby memory when calculating storage increment
>>>   sclp-s390: Add memory hotplug SCLPs
>>>
>>>  hw/s390x/s390-virtio-ccw.c |   42 +++++--
>>>  hw/s390x/sclp.c            |  276 ++++++++++++++++++++++++++++++++++++++++++--
>>>  include/hw/s390x/sclp.h    |   19 +++
>>>  qemu-options.hx            |   10 +-
>>>  target-s390x/cpu.h         |   18 +++
>>>  target-s390x/kvm.c         |    5 +
>>>  vl.c                       |   98 ++++++++++++++--
>>>  7 files changed, 440 insertions(+), 28 deletions(-)
>>>
>>
> 

Re: [Qemu-devel] [PATCH v2 2/5] vl.c: extend -m option to support options for memory hotplug

[Igor Mammedov]

On Mon, 24 Feb 2014 16:30:50 -0500
Matthew Rosato <mjrosato@linux.vnet.ibm.com> wrote:

> From: Igor Mammedov <imammedo@redhat.com>
> 
> Add following parameters:
>   "slots" - total number of hotplug memory slots
>   "maxmem" - maximum possible memory
> 
> "slots" and "maxmem" should go in pair and "maxmem" should be greater
> than "mem" for memory hotplug to be enabled.
it's outdated version which does not apply,
I'll push a new one to memory-hotplug-v8 tree soon, so it could be picked up from there.

> Signed-off-by: Igor Mammedov <imammedo@redhat.com>
> ---
>  qemu-options.hx |    7 +++++--
>  vl.c            |   45 +++++++++++++++++++++++++++++++++++++++++++++
>  2 files changed, 50 insertions(+), 2 deletions(-)
> 
> diff --git a/qemu-options.hx b/qemu-options.hx
> index 4d7ef52..ff60504 100644
> --- a/qemu-options.hx
> +++ b/qemu-options.hx
> @@ -210,10 +210,13 @@ use is discouraged as it may be removed from future versions.
>  ETEXI
>  
>  DEF("m", HAS_ARG, QEMU_OPTION_m,
> -    "-m [mem=]megs\n"
> +    "-m [mem=]megs[,slots=n,maxmem=size]\n"
>      "                configure guest RAM\n"
>      "                mem: initial amount of guest memory (default: "
> -    stringify(DEFAULT_RAM_SIZE) "Mb)\n",
> +    stringify(DEFAULT_RAM_SIZE) "Mb)\n"
> +    "                slots=number of hotplug slots (default: none)\n"
> +    "                maxmem=maximum amount of guest memory (default: none)\n"
> +    "                slots and maxmem must be used together\n",
>      QEMU_ARCH_ALL)
>  STEXI
>  @item -m @var{megs}
> diff --git a/vl.c b/vl.c
> index a3e43d6..d8ff51f 100644
> --- a/vl.c
> +++ b/vl.c
> @@ -542,6 +542,14 @@ static QemuOptsList qemu_mem_opts = {
>              .name = "mem",
>              .type = QEMU_OPT_SIZE,
>          },
> +        {
> +            .name = "slots",
> +            .type = QEMU_OPT_NUMBER,
> +        },
> +        {
> +            .name = "maxmem",
> +            .type = QEMU_OPT_SIZE,
> +        },
>          { /* end of list */ }
>      },
>  };
> @@ -3226,6 +3234,7 @@ int main(int argc, char **argv, char **envp)
>              case QEMU_OPTION_m: {
>                  uint64_t sz;
>                  const char *mem_str;
> +                const char *maxmem_str, *slots_str;
>  
>                  opts = qemu_opts_parse(qemu_find_opts("memory-opts"),
>                                         optarg, 1);
> @@ -3255,6 +3264,42 @@ int main(int argc, char **argv, char **envp)
>                      fprintf(stderr, "qemu: ram size too large\n");
>                      exit(1);
>                  }
> +
> +                maxmem_str = qemu_opt_get(opts, "maxmem");
> +                slots_str = qemu_opt_get(opts, "slots");
> +                if (maxmem_str && slots_str) {
> +                    uint64_t slots;
> +
> +                    sz = qemu_opt_get_size(opts, "maxmem", 0);
> +                    if (sz < ram_size) {
> +                        fprintf(stderr, "qemu: invalid -m option value: maxmem "
> +                                "(%" PRIu64 ") <= initial memory (%"
> +                                PRIu64 ")\n", sz, ram_size);
> +                        exit(1);
> +                    }
> +
> +                    slots = qemu_opt_get_number(opts, "slots", 0);
> +                    if ((sz > ram_size) && !slots) {
> +                        fprintf(stderr, "qemu: invalid -m option value: maxmem "
> +                                "(%" PRIu64 ") more than initial memory (%"
> +                                PRIu64 ") but no hotplug slots where "
> +                                "specified\n", sz, ram_size);
> +                        exit(1);
> +                    }
> +
> +                    if ((sz <= ram_size) && slots) {
> +                        fprintf(stderr, "qemu: invalid -m option value:  %"
> +                                PRIu64 " hotplug slots where specified but "
> +                                "maxmem (%" PRIu64 ") <= initial memory (%"
> +                                PRIu64 ")\n", slots, sz, ram_size);
> +                        exit(1);
> +                    }
> +                } else if ((!maxmem_str && slots_str) ||
> +                           (maxmem_str && !slots_str)) {
> +                    fprintf(stderr, "qemu: invalid -m option value: missing "
> +                            "'%s' option\n", slots_str ? "maxmem" : "slots");
> +                    exit(1);
> +                }
>                  break;
>              }
>  #ifdef CONFIG_TPM

Re: [Qemu-devel] [PATCH v2 0/5] s390: Support for Hotplug of Standby Memory

[Matthew Rosato]

On 02/24/2014 04:30 PM, Matthew Rosato wrote:
> This patchset adds support in s390 for a pool of standby memory,
> which can be set online/offline by the guest (ie, via chmem).
> New options, maxmem and slots, are added to the QEMU command line
> memory parameter to specify the total amount of memory available 
> to the guest as well as the number of memory slots available.
> As part of this work, additional results are provided for the 
> Read SCP Information SCLP, and new implentation is added for the 
> Read Storage Element Information, Attach Storage Element, 
> Assign Storage and Unassign Storage SCLPs, which enables the s390 
> guest to manipulate the standby memory pool.
> 
> This patchset is based on work originally done by Jeng-Fang (Nick)
> Wang.
> 
> This patchset has been built to apply on the s390-next tree at:
> 
> git://github.com/borntraeger/qemu.git s390-next
> 
> Changes for v2:
>  * Removed the patch that introduced the standby-mem operand and 
>    instead included Igor Mammedov's patches that add the mem-opts 
>    'maxmem' and 'slots', with a slight modification due to the removal 
>    of qemu_opts_create_nofail.
>  * Patch 3 was inserted to add a new qom object that encapsulate variables 
>    used by s390 memory hotplug.  Patches 4 and 5 adjusted to use this 
>    object.
>  * Added additional code comments and other minor changes per Alexander 
>    Graf's comments
> 
> Igor Mammedov (2):
>   vl: convert -m to QemuOpts
>   vl.c: extend -m option to support options for memory hotplug
> 
> Matthew Rosato (3):
>   sclp-s390: Add device to manage s390 memory hotplug
>   virtio-ccw: Include standby memory when calculating storage increment
>   sclp-s390: Add memory hotplug SCLPs
> 
>  hw/s390x/s390-virtio-ccw.c |   42 +++++--
>  hw/s390x/sclp.c            |  276 ++++++++++++++++++++++++++++++++++++++++++--
>  include/hw/s390x/sclp.h    |   19 +++
>  qemu-options.hx            |   10 +-
>  target-s390x/cpu.h         |   18 +++
>  target-s390x/kvm.c         |    5 +
>  vl.c                       |   98 ++++++++++++++--
>  7 files changed, 440 insertions(+), 28 deletions(-)
> 

Ping.  Patches 3-5 in particular could still use a review.

Re: [Qemu-devel] [PATCH v2 0/5] s390: Support for Hotplug of Standby Memory

[Matthew Rosato]

On 03/10/2014 10:39 AM, Matthew Rosato wrote:
> On 02/24/2014 04:30 PM, Matthew Rosato wrote:
>> This patchset adds support in s390 for a pool of standby memory,
>> which can be set online/offline by the guest (ie, via chmem).
>> New options, maxmem and slots, are added to the QEMU command line
>> memory parameter to specify the total amount of memory available 
>> to the guest as well as the number of memory slots available.
>> As part of this work, additional results are provided for the 
>> Read SCP Information SCLP, and new implentation is added for the 
>> Read Storage Element Information, Attach Storage Element, 
>> Assign Storage and Unassign Storage SCLPs, which enables the s390 
>> guest to manipulate the standby memory pool.
>>
>> This patchset is based on work originally done by Jeng-Fang (Nick)
>> Wang.
>>
>> This patchset has been built to apply on the s390-next tree at:
>>
>> git://github.com/borntraeger/qemu.git s390-next
>>
>> Changes for v2:
>>  * Removed the patch that introduced the standby-mem operand and 
>>    instead included Igor Mammedov's patches that add the mem-opts 
>>    'maxmem' and 'slots', with a slight modification due to the removal 
>>    of qemu_opts_create_nofail.
>>  * Patch 3 was inserted to add a new qom object that encapsulate variables 
>>    used by s390 memory hotplug.  Patches 4 and 5 adjusted to use this 
>>    object.
>>  * Added additional code comments and other minor changes per Alexander 
>>    Graf's comments
>>
>> Igor Mammedov (2):
>>   vl: convert -m to QemuOpts
>>   vl.c: extend -m option to support options for memory hotplug
>>
>> Matthew Rosato (3):
>>   sclp-s390: Add device to manage s390 memory hotplug
>>   virtio-ccw: Include standby memory when calculating storage increment
>>   sclp-s390: Add memory hotplug SCLPs
>>
>>  hw/s390x/s390-virtio-ccw.c |   42 +++++--
>>  hw/s390x/sclp.c            |  276 ++++++++++++++++++++++++++++++++++++++++++--
>>  include/hw/s390x/sclp.h    |   19 +++
>>  qemu-options.hx            |   10 +-
>>  target-s390x/cpu.h         |   18 +++
>>  target-s390x/kvm.c         |    5 +
>>  vl.c                       |   98 ++++++++++++++--
>>  7 files changed, 440 insertions(+), 28 deletions(-)
>>
> 
> Ping.  Patches 3-5 in particular could still use a review.
> 
Ping.