As of April 7th this functionality has been enabled in Linus's kernel

tree[1] and so I am submitting the QEMU pieces for inclusion.

[1]: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b0c504f154718904ae49349147e3b7e6ae91ffdc

Alexander Duyck (5):

linux-headers: Update to allow renaming of free_page_report_cmd_id

linux-headers: update to contain virito-balloon free page reporting

virtio-balloon: Replace free page hinting references to 'report' with 'hint'

hw/virtio/virtio-balloon.c | 151 +++++++++++++++++------

include/hw/virtio/virtio-balloon.h | 23 ++--

include/standard-headers/linux/virtio_balloon.h | 12 ++

3 files changed, 136 insertions(+), 50 deletions(-)

Sync to the latest upstream changes for free page hinting. To be

replaced by a full linux header sync.

include/standard-headers/linux/virtio_balloon.h | 11 +++++++++--

1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/include/standard-headers/linux/virtio_balloon.h b/include/standard-headers/linux/virtio_balloon.h

--- a/include/standard-headers/linux/virtio_balloon.h

+++ b/include/standard-headers/linux/virtio_balloon.h

@@ -XXX,XX +XXX,XX @@ struct virtio_balloon_config {

    uint32_t num_pages;

    /* Number of pages we've actually got in balloon. */

    uint32_t actual;

-    /* Free page report command id, readonly by guest */

-    uint32_t free_page_report_cmd_id;

+    /*

+     * Free page hint command id, readonly by guest.

+     * Was previously name free_page_report_cmd_id so we

+     * need to carry that name for legacy support.

+     */

+    union {

+        uint32_t free_page_hint_cmd_id;

+        uint32_t free_page_report_cmd_id;    /* deprecated */

+    };

    /* Stores PAGE_POISON if page poisoning is in use */

    uint32_t poison_val;

};

From: Alexander Duyck <alexander.h.duyck@linux.intel.com>

In an upcoming patch a feature named Free Page Reporting is about to be

added. In order to avoid any confusion we should drop the use of the word

'report' when referring to Free Page Hinting. So what this patch does is go

through and replace all instances of 'report' with 'hint" when we are

referring to free page hinting.

Signed-off-by: Alexander Duyck <alexander.h.duyck@linux.intel.com>

---

hw/virtio/virtio-balloon.c | 74 ++++++++++++++++++------------------

include/hw/virtio/virtio-balloon.h | 20 +++++-----

2 files changed, 47 insertions(+), 47 deletions(-)

diff --git a/hw/virtio/virtio-balloon.c b/hw/virtio/virtio-balloon.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/virtio/virtio-balloon.c

+++ b/hw/virtio/virtio-balloon.c

@@ -XXX,XX +XXX,XX @@ static bool get_free_page_hints(VirtIOBalloon *dev)

ret = false;

goto out;

}

- if (id == dev->free_page_report_cmd_id) {

- dev->free_page_report_status = FREE_PAGE_REPORT_S_START;

+ if (id == dev->free_page_hint_cmd_id) {

+ dev->free_page_hint_status = FREE_PAGE_HINT_S_START;

} else {

/*

* Stop the optimization only when it has started. This

* avoids a stale stop sign for the previous command.

*/

- if (dev->free_page_report_status == FREE_PAGE_REPORT_S_START) {

- dev->free_page_report_status = FREE_PAGE_REPORT_S_STOP;

+ if (dev->free_page_hint_status == FREE_PAGE_HINT_S_START) {

+ dev->free_page_hint_status = FREE_PAGE_HINT_S_STOP;

}

}

}

if (elem->in_num) {

- if (dev->free_page_report_status == FREE_PAGE_REPORT_S_START) {

+ if (dev->free_page_hint_status == FREE_PAGE_HINT_S_START) {

qemu_guest_free_page_hint(elem->in_sg[0].iov_base,

elem->in_sg[0].iov_len);

}

@@ -XXX,XX +XXX,XX @@ static void virtio_ballloon_get_free_page_hints(void *opaque)

qemu_mutex_unlock(&dev->free_page_lock);

virtio_notify(vdev, vq);

/*

- * Start to poll the vq once the reporting started. Otherwise, continue

+ * Start to poll the vq once the hinting started. Otherwise, continue

* only when there are entries on the vq, which need to be given back.

*/

} while (continue_to_get_hints ||

- dev->free_page_report_status == FREE_PAGE_REPORT_S_START);

+ dev->free_page_hint_status == FREE_PAGE_HINT_S_START);

virtio_queue_set_notification(vq, 1);

}

@@ -XXX,XX +XXX,XX @@ static void virtio_balloon_free_page_start(VirtIOBalloon *s)

return;

}

- if (s->free_page_report_cmd_id == UINT_MAX) {

- s->free_page_report_cmd_id =

- VIRTIO_BALLOON_FREE_PAGE_REPORT_CMD_ID_MIN;

+ if (s->free_page_hint_cmd_id == UINT_MAX) {

+ s->free_page_hint_cmd_id =

+ VIRTIO_BALLOON_FREE_PAGE_HINT_CMD_ID_MIN;

} else {

- s->free_page_report_cmd_id++;

+ s->free_page_hint_cmd_id++;

}

- s->free_page_report_status = FREE_PAGE_REPORT_S_REQUESTED;

+ s->free_page_hint_status = FREE_PAGE_HINT_S_REQUESTED;

virtio_notify_config(vdev);

}

@@ -XXX,XX +XXX,XX @@ static void virtio_balloon_free_page_stop(VirtIOBalloon *s)

{

VirtIODevice *vdev = VIRTIO_DEVICE(s);

- if (s->free_page_report_status != FREE_PAGE_REPORT_S_STOP) {

+ if (s->free_page_hint_status != FREE_PAGE_HINT_S_STOP) {

/*

* The lock also guarantees us that the

* virtio_ballloon_get_free_page_hints exits after the

- * free_page_report_status is set to S_STOP.

+ * free_page_hint_status is set to S_STOP.

*/

qemu_mutex_lock(&s->free_page_lock);

/*

* The guest hasn't done the reporting, so host sends a notification

* to the guest to actively stop the reporting.

*/

- s->free_page_report_status = FREE_PAGE_REPORT_S_STOP;

+ s->free_page_hint_status = FREE_PAGE_HINT_S_STOP;

qemu_mutex_unlock(&s->free_page_lock);

virtio_notify_config(vdev);

}

@@ -XXX,XX +XXX,XX @@ static void virtio_balloon_free_page_done(VirtIOBalloon *s)

{

VirtIODevice *vdev = VIRTIO_DEVICE(s);

- s->free_page_report_status = FREE_PAGE_REPORT_S_DONE;

+ s->free_page_hint_status = FREE_PAGE_HINT_S_DONE;

virtio_notify_config(vdev);

}

static int

-virtio_balloon_free_page_report_notify(NotifierWithReturn *n, void *data)

+virtio_balloon_free_page_hint_notify(NotifierWithReturn *n, void *data)

{

VirtIOBalloon *dev = container_of(n, VirtIOBalloon,

- free_page_report_notify);

+ free_page_hint_notify);

VirtIODevice *vdev = VIRTIO_DEVICE(dev);

PrecopyNotifyData *pnd = data;

@@ -XXX,XX +XXX,XX @@ static size_t virtio_balloon_config_size(VirtIOBalloon *s)

if (virtio_has_feature(features, VIRTIO_BALLOON_F_FREE_PAGE_HINT)) {

return offsetof(struct virtio_balloon_config, poison_val);

}

- return offsetof(struct virtio_balloon_config, free_page_report_cmd_id);

+ return offsetof(struct virtio_balloon_config, free_page_hint_cmd_id);

}

static void virtio_balloon_get_config(VirtIODevice *vdev, uint8_t *config_data)

@@ -XXX,XX +XXX,XX @@ static void virtio_balloon_get_config(VirtIODevice *vdev, uint8_t *config_data)

config.num_pages = cpu_to_le32(dev->num_pages);

config.actual = cpu_to_le32(dev->actual);

- if (dev->free_page_report_status == FREE_PAGE_REPORT_S_REQUESTED) {

- config.free_page_report_cmd_id =

- cpu_to_le32(dev->free_page_report_cmd_id);

- } else if (dev->free_page_report_status == FREE_PAGE_REPORT_S_STOP) {

- config.free_page_report_cmd_id =

+ if (dev->free_page_hint_status == FREE_PAGE_HINT_S_REQUESTED) {

+ config.free_page_hint_cmd_id =

+ cpu_to_le32(dev->free_page_hint_cmd_id);

+ } else if (dev->free_page_hint_status == FREE_PAGE_HINT_S_STOP) {

+ config.free_page_hint_cmd_id =

cpu_to_le32(VIRTIO_BALLOON_CMD_ID_STOP);

- } else if (dev->free_page_report_status == FREE_PAGE_REPORT_S_DONE) {

- config.free_page_report_cmd_id =

+ } else if (dev->free_page_hint_status == FREE_PAGE_HINT_S_DONE) {

+ config.free_page_hint_cmd_id =

cpu_to_le32(VIRTIO_BALLOON_CMD_ID_DONE);

}

@@ -XXX,XX +XXX,XX @@ static int virtio_balloon_post_load_device(void *opaque, int version_id)

return 0;

}

-static const VMStateDescription vmstate_virtio_balloon_free_page_report = {

+static const VMStateDescription vmstate_virtio_balloon_free_page_hint = {

.name = "virtio-balloon-device/free-page-report",

.version_id = 1,

.minimum_version_id = 1,

.needed = virtio_balloon_free_page_support,

.fields = (VMStateField[]) {

- VMSTATE_UINT32(free_page_report_cmd_id, VirtIOBalloon),

- VMSTATE_UINT32(free_page_report_status, VirtIOBalloon),

+ VMSTATE_UINT32(free_page_hint_cmd_id, VirtIOBalloon),

+ VMSTATE_UINT32(free_page_hint_status, VirtIOBalloon),

VMSTATE_END_OF_LIST()

}

};

@@ -XXX,XX +XXX,XX @@ static const VMStateDescription vmstate_virtio_balloon_device = {

VMSTATE_END_OF_LIST()

},

.subsections = (const VMStateDescription * []) {

- &vmstate_virtio_balloon_free_page_report,

+ &vmstate_virtio_balloon_free_page_hint,

NULL

}

};

@@ -XXX,XX +XXX,XX @@ static void virtio_balloon_device_realize(DeviceState *dev, Error **errp)

VIRTIO_BALLOON_F_FREE_PAGE_HINT)) {

s->free_page_vq = virtio_add_queue(vdev, VIRTQUEUE_MAX_SIZE,

virtio_balloon_handle_free_page_vq);

- s->free_page_report_status = FREE_PAGE_REPORT_S_STOP;

- s->free_page_report_cmd_id =

- VIRTIO_BALLOON_FREE_PAGE_REPORT_CMD_ID_MIN;

- s->free_page_report_notify.notify =

- virtio_balloon_free_page_report_notify;

- precopy_add_notifier(&s->free_page_report_notify);

+ s->free_page_hint_status = FREE_PAGE_HINT_S_STOP;

+ s->free_page_hint_cmd_id =

+ VIRTIO_BALLOON_FREE_PAGE_HINT_CMD_ID_MIN;

+ s->free_page_hint_notify.notify =

+ virtio_balloon_free_page_hint_notify;

+ precopy_add_notifier(&s->free_page_hint_notify);

if (s->iothread) {

object_ref(OBJECT(s->iothread));

s->free_page_bh = aio_bh_new(iothread_get_aio_context(s->iothread),

@@ -XXX,XX +XXX,XX @@ static void virtio_balloon_device_unrealize(DeviceState *dev, Error **errp)

if (virtio_balloon_free_page_support(s)) {

qemu_bh_delete(s->free_page_bh);

virtio_balloon_free_page_stop(s);

- precopy_remove_notifier(&s->free_page_report_notify);

+ precopy_remove_notifier(&s->free_page_hint_notify);

}

balloon_stats_destroy_timer(s);

qemu_remove_balloon_handler(s);

diff --git a/include/hw/virtio/virtio-balloon.h b/include/hw/virtio/virtio-balloon.h

index XXXXXXX..XXXXXXX 100644

--- a/include/hw/virtio/virtio-balloon.h

+++ b/include/hw/virtio/virtio-balloon.h

@@ -XXX,XX +XXX,XX @@

#define VIRTIO_BALLOON(obj) \

OBJECT_CHECK(VirtIOBalloon, (obj), TYPE_VIRTIO_BALLOON)

-#define VIRTIO_BALLOON_FREE_PAGE_REPORT_CMD_ID_MIN 0x80000000

+#define VIRTIO_BALLOON_FREE_PAGE_HINT_CMD_ID_MIN 0x80000000

typedef struct virtio_balloon_stat VirtIOBalloonStat;

@@ -XXX,XX +XXX,XX @@ typedef struct virtio_balloon_stat_modern {

uint64_t val;

} VirtIOBalloonStatModern;

-enum virtio_balloon_free_page_report_status {

- FREE_PAGE_REPORT_S_STOP = 0,

- FREE_PAGE_REPORT_S_REQUESTED = 1,

- FREE_PAGE_REPORT_S_START = 2,

- FREE_PAGE_REPORT_S_DONE = 3,

+enum virtio_balloon_free_page_hint_status {

+ FREE_PAGE_HINT_S_STOP = 0,

+ FREE_PAGE_HINT_S_REQUESTED = 1,

+ FREE_PAGE_HINT_S_START = 2,

+ FREE_PAGE_HINT_S_DONE = 3,

};

typedef struct VirtIOBalloon {

VirtIODevice parent_obj;

VirtQueue *ivq, *dvq, *svq, *free_page_vq;

- uint32_t free_page_report_status;

+ uint32_t free_page_hint_status;

uint32_t num_pages;

uint32_t actual;

- uint32_t free_page_report_cmd_id;

+ uint32_t free_page_hint_cmd_id;

uint64_t stats[VIRTIO_BALLOON_S_NR];

VirtQueueElement *stats_vq_elem;

size_t stats_vq_offset;

@@ -XXX,XX +XXX,XX @@ typedef struct VirtIOBalloon {

QEMUBH *free_page_bh;

/*

* Lock to synchronize threads to access the free page reporting related

- * fields (e.g. free_page_report_status).

+ * fields (e.g. free_page_hint_status).

*/

QemuMutex free_page_lock;

QemuCond free_page_cond;

@@ -XXX,XX +XXX,XX @@ typedef struct VirtIOBalloon {

* stopped.

*/

bool block_iothread;

- NotifierWithReturn free_page_report_notify;

+ NotifierWithReturn free_page_hint_notify;

int64_t stats_last_update;

int64_t stats_poll_interval;

uint32_t host_features;

we want to actually get data on if the guest will be poisoning pages.

Add a value for tracking the poison value being used if page poisoning is

enabled. With this we can determine if we will need to skip page reporting

when it is enabled in the future.

hw/virtio/virtio-balloon.c | 7 +++++++

2 files changed, 8 insertions(+)

if (dev->free_page_hint_status == FREE_PAGE_HINT_S_REQUESTED) {

config.free_page_hint_cmd_id =

+ dev->poison_val = 0;

+ if (virtio_vdev_has_feature(vdev, VIRTIO_BALLOON_F_PAGE_POISON)) {

+ dev->poison_val = le32_to_cpu(config.poison_val);

+ }

hw/virtio/virtio-balloon.c | 70 ++++++++++++++++++++++++++++++++++++

2 files changed, 71 insertions(+), 1 deletion(-)

+ /*

+ * For now we will simply ignore unaligned memory regions, or

+ * regions that overrun the end of the RAMBlock.

+ */

+ if (!QEMU_IS_ALIGNED(ram_offset | size, qemu_ram_pagesize(rb)) ||

+ (ram_offset + size) > qemu_ram_get_used_length(rb)) {

@@ -XXX,XX +XXX,XX @@ static void virtio_balloon_device_realize(DeviceState *dev, Error **errp)

VirtIOBalloon *s = VIRTIO_BALLOON(dev);

int ret;

+ /*

+ * Page reporting is dependant on page poison to make sure we can

+ * report a page without changing the state of the internal data.

+ * We need to set the flag before we call virtio_init as it will

+ * affect the config size of the vdev.

+ */

+ if (virtio_has_feature(s->host_features, VIRTIO_BALLOON_F_REPORTING)) {

+ s->host_features |= 1 << VIRTIO_BALLOON_F_PAGE_POISON;

+ }

+

virtio_init(vdev, "virtio-balloon", VIRTIO_ID_BALLOON,

virtio_balloon_config_size(s));

VIRTIO_BALLOON_F_DEFLATE_ON_OOM, false),

DEFINE_PROP_BIT("free-page-hint", VirtIOBalloon, host_features,

VIRTIO_BALLOON_F_FREE_PAGE_HINT, false),

/* QEMU 4.0 accidentally changed the config size even when free-page-hint

* is disabled, resulting in QEMU 3.1 migration incompatibility. This

* property retains this quirk for QEMU 4.1 machine types.

@@ -XXX,XX +XXX,XX @@ enum virtio_balloon_free_page_hint_status {

uint32_t free_page_hint_status;