This patch series is separated from the previous "Virtio-balloon
Enhancement" series. The new feature, VIRTIO_BALLOON_F_FREE_PAGE_VQ,
implemented by this series enables the virtio-balloon driver to report
hints of guest free pages to the host. It can be used to accelerate live
migration of VMs. Here is an introduction of this usage:
Live migration needs to transfer the VM's memory from the source machine
to the destination round by round. For the 1st round, all the VM's memory
is transferred. From the 2nd round, only the pieces of memory that were
written by the guest (after the 1st round) are transferred. One method
that is popularly used by the hypervisor to track which part of memory is
written is to write-protect all the guest memory.
The second feature enables the optimization of the 1st round memory
transfer - the hypervisor can skip the transfer of guest free pages in the
1st round. It is not concerned that the memory pages are used after they
are given to the hypervisor as a hint of the free pages, because they will
be tracked by the hypervisor and transferred in the next round if they are
used and written.
ChangeLog:
v21-v22:
- add_one_sg: some code and comment re-arrangement
- send_cmd_id: handle a cornercase
For precious ChangeLog, please reference
https://lwn.net/Articles/743660/
Wei Wang (3):
mm: support reporting free page blocks
virtio-balloon: VIRTIO_BALLOON_F_FREE_PAGE_VQ
virtio-balloon: don't report free pages when page poisoning is enabled
drivers/virtio/virtio_balloon.c | 250 +++++++++++++++++++++++++++++++-----
include/linux/mm.h | 6 +
include/uapi/linux/virtio_balloon.h | 6 +
mm/page_alloc.c | 91 +++++++++++++
4 files changed, 321 insertions(+), 32 deletions(-)
--
2.7.4
This patch adds support to walk through the free page blocks in the
system and report them via a callback function. Some page blocks may
leave the free list after zone->lock is released, so it is the caller's
responsibility to either detect or prevent the use of such pages.
One use example of this patch is to accelerate live migration by skipping
the transfer of free pages reported from the guest. A popular method used
by the hypervisor to track which part of memory is written during live
migration is to write-protect all the guest memory. So, those pages that
are reported as free pages but are written after the report function
returns will be captured by the hypervisor, and they will be added to the
next round of memory transfer.
Signed-off-by: Wei Wang <[email protected]>
Signed-off-by: Liang Li <[email protected]>
Cc: Michal Hocko <[email protected]>
Cc: Michael S. Tsirkin <[email protected]>
Acked-by: Michal Hocko <[email protected]>
---
include/linux/mm.h | 6 ++++
mm/page_alloc.c | 91 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 97 insertions(+)
diff --git a/include/linux/mm.h b/include/linux/mm.h
index ea818ff..b3077dd 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -1938,6 +1938,12 @@ extern void free_area_init_node(int nid, unsigned long * zones_size,
unsigned long zone_start_pfn, unsigned long *zholes_size);
extern void free_initmem(void);
+extern void walk_free_mem_block(void *opaque,
+ int min_order,
+ bool (*report_pfn_range)(void *opaque,
+ unsigned long pfn,
+ unsigned long num));
+
/*
* Free reserved pages within range [PAGE_ALIGN(start), end & PAGE_MASK)
* into the buddy system. The freed pages will be poisoned with pattern
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 76c9688..705de22 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -4899,6 +4899,97 @@ void show_free_areas(unsigned int filter, nodemask_t *nodemask)
show_swap_cache_info();
}
+/*
+ * Walk through a free page list and report the found pfn range via the
+ * callback.
+ *
+ * Return false if the callback requests to stop reporting. Otherwise,
+ * return true.
+ */
+static bool walk_free_page_list(void *opaque,
+ struct zone *zone,
+ int order,
+ enum migratetype mt,
+ bool (*report_pfn_range)(void *,
+ unsigned long,
+ unsigned long))
+{
+ struct page *page;
+ struct list_head *list;
+ unsigned long pfn, flags;
+ bool ret;
+
+ spin_lock_irqsave(&zone->lock, flags);
+ list = &zone->free_area[order].free_list[mt];
+ list_for_each_entry(page, list, lru) {
+ pfn = page_to_pfn(page);
+ ret = report_pfn_range(opaque, pfn, 1 << order);
+ if (!ret)
+ break;
+ }
+ spin_unlock_irqrestore(&zone->lock, flags);
+
+ return ret;
+}
+
+/**
+ * walk_free_mem_block - Walk through the free page blocks in the system
+ * @opaque: the context passed from the caller
+ * @min_order: the minimum order of free lists to check
+ * @report_pfn_range: the callback to report the pfn range of the free pages
+ *
+ * If the callback returns false, stop iterating the list of free page blocks.
+ * Otherwise, continue to report.
+ *
+ * Please note that there are no locking guarantees for the callback and
+ * that the reported pfn range might be freed or disappear after the
+ * callback returns so the caller has to be very careful how it is used.
+ *
+ * The callback itself must not sleep or perform any operations which would
+ * require any memory allocations directly (not even GFP_NOWAIT/GFP_ATOMIC)
+ * or via any lock dependency. It is generally advisable to implement
+ * the callback as simple as possible and defer any heavy lifting to a
+ * different context.
+ *
+ * There is no guarantee that each free range will be reported only once
+ * during one walk_free_mem_block invocation.
+ *
+ * pfn_to_page on the given range is strongly discouraged and if there is
+ * an absolute need for that make sure to contact MM people to discuss
+ * potential problems.
+ *
+ * The function itself might sleep so it cannot be called from atomic
+ * contexts.
+ *
+ * In general low orders tend to be very volatile and so it makes more
+ * sense to query larger ones first for various optimizations which like
+ * ballooning etc... This will reduce the overhead as well.
+ */
+void walk_free_mem_block(void *opaque,
+ int min_order,
+ bool (*report_pfn_range)(void *opaque,
+ unsigned long pfn,
+ unsigned long num))
+{
+ struct zone *zone;
+ int order;
+ enum migratetype mt;
+ bool ret;
+
+ for_each_populated_zone(zone) {
+ for (order = MAX_ORDER - 1; order >= min_order; order--) {
+ for (mt = 0; mt < MIGRATE_TYPES; mt++) {
+ ret = walk_free_page_list(opaque, zone,
+ order, mt,
+ report_pfn_range);
+ if (!ret)
+ return;
+ }
+ }
+ }
+}
+EXPORT_SYMBOL_GPL(walk_free_mem_block);
+
static void zoneref_set_zone(struct zone *zone, struct zoneref *zoneref)
{
zoneref->zone = zone;
--
2.7.4
Negotiation of the VIRTIO_BALLOON_F_FREE_PAGE_VQ feature indicates the
support of reporting hints of guest free pages to host via virtio-balloon.
Host requests the guest to report free pages by sending a new cmd
id to the guest via the free_page_report_cmd_id configuration register.
When the guest starts to report, the first element added to the free page
vq is the cmd id given by host. When the guest finishes the reporting
of all the free pages, VIRTIO_BALLOON_FREE_PAGE_REPORT_STOP_ID is added
to the vq to tell host that the reporting is done. Host may also requests
the guest to stop the reporting in advance by sending the stop cmd id to
the guest via the configuration register.
Signed-off-by: Wei Wang <[email protected]>
Signed-off-by: Liang Li <[email protected]>
Cc: Michael S. Tsirkin <[email protected]>
Cc: Michal Hocko <[email protected]>
---
drivers/virtio/virtio_balloon.c | 242 +++++++++++++++++++++++++++++++-----
include/uapi/linux/virtio_balloon.h | 4 +
2 files changed, 214 insertions(+), 32 deletions(-)
diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c
index a1fb52c..b9561a5 100644
--- a/drivers/virtio/virtio_balloon.c
+++ b/drivers/virtio/virtio_balloon.c
@@ -53,7 +53,12 @@ static struct vfsmount *balloon_mnt;
struct virtio_balloon {
struct virtio_device *vdev;
- struct virtqueue *inflate_vq, *deflate_vq, *stats_vq;
+ struct virtqueue *inflate_vq, *deflate_vq, *stats_vq, *free_page_vq;
+
+ /* Balloon's own wq for cpu-intensive work items */
+ struct workqueue_struct *balloon_wq;
+ /* The free page reporting work item submitted to the balloon wq */
+ struct work_struct report_free_page_work;
/* The balloon servicing is delegated to a freezable workqueue. */
struct work_struct update_balloon_stats_work;
@@ -63,6 +68,13 @@ struct virtio_balloon {
spinlock_t stop_update_lock;
bool stop_update;
+ /* Start to report free pages */
+ bool report_free_page;
+ /* Stores the cmd id given by host to start the free page reporting */
+ uint32_t start_cmd_id;
+ /* Stores STOP_ID as a sign to tell host that the reporting is done */
+ uint32_t stop_cmd_id;
+
/* Waiting for host to ack the pages we released. */
wait_queue_head_t acked;
@@ -281,6 +293,71 @@ static unsigned int update_balloon_stats(struct virtio_balloon *vb)
return idx;
}
+static void add_one_sg(struct virtqueue *vq, unsigned long pfn, uint32_t len)
+{
+ struct scatterlist sg;
+ unsigned int unused;
+ int err;
+
+ sg_init_table(&sg, 1);
+ sg_set_page(&sg, pfn_to_page(pfn), len, 0);
+
+ /* Detach all the used buffers from the vq */
+ while (virtqueue_get_buf(vq, &unused))
+ ;
+
+ /*
+ * Since this is an optimization feature, losing a couple of free
+ * pages to report isn't important. We simply resturn without adding
+ * the page if the vq is full. We are adding one entry each time,
+ * which essentially results in no memory allocation, so the
+ * GFP_KERNEL flag below can be ignored.
+ */
+ if (vq->num_free) {
+ err = virtqueue_add_inbuf(vq, &sg, 1, vq, GFP_KERNEL);
+ /*
+ * This is expected to never fail, because there is always an
+ * entry available on the vq.
+ */
+ BUG_ON(err);
+ }
+}
+
+static void batch_free_page_sg(struct virtqueue *vq,
+ unsigned long pfn,
+ uint32_t len)
+{
+ add_one_sg(vq, pfn, len);
+
+ /* Batch till the vq is full */
+ if (!vq->num_free)
+ virtqueue_kick(vq);
+}
+
+static void send_cmd_id(struct virtqueue *vq, void *addr)
+{
+ struct scatterlist sg;
+ unsigned int unused;
+ int err;
+
+ sg_init_one(&sg, addr, sizeof(uint32_t));
+
+ /*
+ * This handles the cornercase that the vq happens to be full when
+ * adding a cmd id. Rarely happen in practice.
+ */
+ while (!vq->num_free)
+ virtqueue_get_buf(vq, &unused);
+
+ err = virtqueue_add_outbuf(vq, &sg, 1, vq, GFP_KERNEL);
+ /*
+ * This is expected to never fail, because there is always an
+ * entry available on the vq.
+ */
+ BUG_ON(err);
+ virtqueue_kick(vq);
+}
+
/*
* While most virtqueues communicate guest-initiated requests to the hypervisor,
* the stats queue operates in reverse. The driver initializes the virtqueue
@@ -316,17 +393,6 @@ static void stats_handle_request(struct virtio_balloon *vb)
virtqueue_kick(vq);
}
-static void virtballoon_changed(struct virtio_device *vdev)
-{
- struct virtio_balloon *vb = vdev->priv;
- unsigned long flags;
-
- spin_lock_irqsave(&vb->stop_update_lock, flags);
- if (!vb->stop_update)
- queue_work(system_freezable_wq, &vb->update_balloon_size_work);
- spin_unlock_irqrestore(&vb->stop_update_lock, flags);
-}
-
static inline s64 towards_target(struct virtio_balloon *vb)
{
s64 target;
@@ -343,6 +409,36 @@ static inline s64 towards_target(struct virtio_balloon *vb)
return target - vb->num_pages;
}
+static void virtballoon_changed(struct virtio_device *vdev)
+{
+ struct virtio_balloon *vb = vdev->priv;
+ unsigned long flags;
+ __u32 cmd_id;
+ s64 diff = towards_target(vb);
+
+ if (diff) {
+ spin_lock_irqsave(&vb->stop_update_lock, flags);
+ if (!vb->stop_update)
+ queue_work(system_freezable_wq,
+ &vb->update_balloon_size_work);
+ spin_unlock_irqrestore(&vb->stop_update_lock, flags);
+ }
+
+ virtio_cread(vb->vdev, struct virtio_balloon_config,
+ free_page_report_cmd_id, &cmd_id);
+ if (cmd_id == VIRTIO_BALLOON_FREE_PAGE_REPORT_STOP_ID) {
+ WRITE_ONCE(vb->report_free_page, false);
+ } else if (cmd_id != vb->start_cmd_id) {
+ /*
+ * Host requests to start the reporting by sending a new cmd
+ * id.
+ */
+ WRITE_ONCE(vb->report_free_page, true);
+ vb->start_cmd_id = cmd_id;
+ queue_work(vb->balloon_wq, &vb->report_free_page_work);
+ }
+}
+
static void update_balloon_size(struct virtio_balloon *vb)
{
u32 actual = vb->num_pages;
@@ -417,40 +513,113 @@ static void update_balloon_size_func(struct work_struct *work)
static int init_vqs(struct virtio_balloon *vb)
{
- struct virtqueue *vqs[3];
- vq_callback_t *callbacks[] = { balloon_ack, balloon_ack, stats_request };
- static const char * const names[] = { "inflate", "deflate", "stats" };
- int err, nvqs;
+ struct virtqueue **vqs;
+ vq_callback_t **callbacks;
+ const char **names;
+ struct scatterlist sg;
+ int i, nvqs, err = -ENOMEM;
+
+ /* Inflateq and deflateq are used unconditionally */
+ nvqs = 2;
+ if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ))
+ nvqs++;
+ if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ))
+ nvqs++;
+
+ /* Allocate space for find_vqs parameters */
+ vqs = kcalloc(nvqs, sizeof(*vqs), GFP_KERNEL);
+ if (!vqs)
+ goto err_vq;
+ callbacks = kmalloc_array(nvqs, sizeof(*callbacks), GFP_KERNEL);
+ if (!callbacks)
+ goto err_callback;
+ names = kmalloc_array(nvqs, sizeof(*names), GFP_KERNEL);
+ if (!names)
+ goto err_names;
+
+ callbacks[0] = balloon_ack;
+ names[0] = "inflate";
+ callbacks[1] = balloon_ack;
+ names[1] = "deflate";
+
+ i = 2;
+ if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ)) {
+ callbacks[i] = stats_request;
+ names[i] = "stats";
+ i++;
+ }
- /*
- * We expect two virtqueues: inflate and deflate, and
- * optionally stat.
- */
- nvqs = virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ) ? 3 : 2;
- err = virtio_find_vqs(vb->vdev, nvqs, vqs, callbacks, names, NULL);
+ if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ)) {
+ callbacks[i] = NULL;
+ names[i] = "free_page_vq";
+ }
+
+ err = vb->vdev->config->find_vqs(vb->vdev, nvqs, vqs, callbacks, names,
+ NULL, NULL);
if (err)
- return err;
+ goto err_find;
vb->inflate_vq = vqs[0];
vb->deflate_vq = vqs[1];
+ i = 2;
if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ)) {
- struct scatterlist sg;
- unsigned int num_stats;
- vb->stats_vq = vqs[2];
-
+ vb->stats_vq = vqs[i++];
/*
* Prime this virtqueue with one buffer so the hypervisor can
* use it to signal us later (it can't be broken yet!).
*/
- num_stats = update_balloon_stats(vb);
-
- sg_init_one(&sg, vb->stats, sizeof(vb->stats[0]) * num_stats);
+ sg_init_one(&sg, vb->stats, sizeof(vb->stats));
if (virtqueue_add_outbuf(vb->stats_vq, &sg, 1, vb, GFP_KERNEL)
- < 0)
- BUG();
+ < 0) {
+ dev_warn(&vb->vdev->dev, "%s: add stat_vq failed\n",
+ __func__);
+ goto err_find;
+ }
virtqueue_kick(vb->stats_vq);
}
+
+ if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ))
+ vb->free_page_vq = vqs[i];
+
+ kfree(names);
+ kfree(callbacks);
+ kfree(vqs);
return 0;
+
+err_find:
+ kfree(names);
+err_names:
+ kfree(callbacks);
+err_callback:
+ kfree(vqs);
+err_vq:
+ return err;
+}
+
+static bool virtio_balloon_send_free_pages(void *opaque, unsigned long pfn,
+ unsigned long nr_pages)
+{
+ struct virtio_balloon *vb = (struct virtio_balloon *)opaque;
+ uint32_t len = nr_pages << PAGE_SHIFT;
+
+ if (!READ_ONCE(vb->report_free_page))
+ return false;
+
+ batch_free_page_sg(vb->free_page_vq, pfn, len);
+
+ return true;
+}
+
+static void report_free_page_func(struct work_struct *work)
+{
+ struct virtio_balloon *vb;
+
+ vb = container_of(work, struct virtio_balloon, report_free_page_work);
+ /* Start by sending the obtained cmd id to the host with an outbuf */
+ send_cmd_id(vb->free_page_vq, &vb->start_cmd_id);
+ walk_free_mem_block(vb, 0, &virtio_balloon_send_free_pages);
+ /* End by sending the stop id to the host with an outbuf */
+ send_cmd_id(vb->free_page_vq, &vb->stop_cmd_id);
}
#ifdef CONFIG_BALLOON_COMPACTION
@@ -566,6 +735,13 @@ static int virtballoon_probe(struct virtio_device *vdev)
if (err)
goto out_free_vb;
+ if (virtio_has_feature(vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ)) {
+ vb->balloon_wq = alloc_workqueue("balloon-wq",
+ WQ_FREEZABLE | WQ_CPU_INTENSIVE, 0);
+ INIT_WORK(&vb->report_free_page_work, report_free_page_func);
+ vb->stop_cmd_id = VIRTIO_BALLOON_FREE_PAGE_REPORT_STOP_ID;
+ }
+
vb->nb.notifier_call = virtballoon_oom_notify;
vb->nb.priority = VIRTBALLOON_OOM_NOTIFY_PRIORITY;
err = register_oom_notifier(&vb->nb);
@@ -630,6 +806,7 @@ static void virtballoon_remove(struct virtio_device *vdev)
spin_unlock_irq(&vb->stop_update_lock);
cancel_work_sync(&vb->update_balloon_size_work);
cancel_work_sync(&vb->update_balloon_stats_work);
+ cancel_work_sync(&vb->report_free_page_work);
remove_common(vb);
#ifdef CONFIG_BALLOON_COMPACTION
@@ -682,6 +859,7 @@ static unsigned int features[] = {
VIRTIO_BALLOON_F_MUST_TELL_HOST,
VIRTIO_BALLOON_F_STATS_VQ,
VIRTIO_BALLOON_F_DEFLATE_ON_OOM,
+ VIRTIO_BALLOON_F_FREE_PAGE_VQ,
};
static struct virtio_driver virtio_balloon_driver = {
diff --git a/include/uapi/linux/virtio_balloon.h b/include/uapi/linux/virtio_balloon.h
index 343d7dd..55e2456 100644
--- a/include/uapi/linux/virtio_balloon.h
+++ b/include/uapi/linux/virtio_balloon.h
@@ -34,15 +34,19 @@
#define VIRTIO_BALLOON_F_MUST_TELL_HOST 0 /* Tell before reclaiming pages */
#define VIRTIO_BALLOON_F_STATS_VQ 1 /* Memory Stats virtqueue */
#define VIRTIO_BALLOON_F_DEFLATE_ON_OOM 2 /* Deflate balloon on OOM */
+#define VIRTIO_BALLOON_F_FREE_PAGE_VQ 3 /* VQ to report free pages */
/* Size of a PFN in the balloon interface. */
#define VIRTIO_BALLOON_PFN_SHIFT 12
+#define VIRTIO_BALLOON_FREE_PAGE_REPORT_STOP_ID 0
struct virtio_balloon_config {
/* Number of pages host wants Guest to give up. */
__u32 num_pages;
/* Number of pages we've actually got in balloon. */
__u32 actual;
+ /* Free page report command id, readonly by guest */
+ __u32 free_page_report_cmd_id;
};
#define VIRTIO_BALLOON_S_SWAP_IN 0 /* Amount of memory swapped in */
--
2.7.4
The guest free pages should not be discarded by the live migration thread
when page poisoning is enabled with PAGE_POISONING_NO_SANITY=n, because
skipping the transfer of such poisoned free pages will trigger false
positive when new pages are allocated and checked on the destination.
This patch adds a config field, poison_val. Guest writes to the config
field to tell the host about the poisoning value. The value will be 0 in
the following cases:
1) PAGE_POISONING_NO_SANITY is enabled;
2) page poisoning is disabled; or
3) PAGE_POISONING_ZERO is enabled.
Signed-off-by: Wei Wang <[email protected]>
Suggested-by: Michael S. Tsirkin <[email protected]>
Cc: Michal Hocko <[email protected]>
---
drivers/virtio/virtio_balloon.c | 8 ++++++++
include/uapi/linux/virtio_balloon.h | 2 ++
2 files changed, 10 insertions(+)
diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c
index b9561a5..5a42235 100644
--- a/drivers/virtio/virtio_balloon.c
+++ b/drivers/virtio/virtio_balloon.c
@@ -706,6 +706,7 @@ static struct file_system_type balloon_fs = {
static int virtballoon_probe(struct virtio_device *vdev)
{
struct virtio_balloon *vb;
+ __u32 poison_val;
int err;
if (!vdev->config->get) {
@@ -740,6 +741,13 @@ static int virtballoon_probe(struct virtio_device *vdev)
WQ_FREEZABLE | WQ_CPU_INTENSIVE, 0);
INIT_WORK(&vb->report_free_page_work, report_free_page_func);
vb->stop_cmd_id = VIRTIO_BALLOON_FREE_PAGE_REPORT_STOP_ID;
+ if (IS_ENABLED(CONFIG_PAGE_POISONING_NO_SANITY) ||
+ !page_poisoning_enabled())
+ poison_val = 0;
+ else
+ poison_val = PAGE_POISON;
+ virtio_cwrite(vb->vdev, struct virtio_balloon_config,
+ poison_val, &poison_val);
}
vb->nb.notifier_call = virtballoon_oom_notify;
diff --git a/include/uapi/linux/virtio_balloon.h b/include/uapi/linux/virtio_balloon.h
index 55e2456..5861876 100644
--- a/include/uapi/linux/virtio_balloon.h
+++ b/include/uapi/linux/virtio_balloon.h
@@ -47,6 +47,8 @@ struct virtio_balloon_config {
__u32 actual;
/* Free page report command id, readonly by guest */
__u32 free_page_report_cmd_id;
+ /* Stores PAGE_POISON if page poisoning with sanity check is in use */
+ __u32 poison_val;
};
#define VIRTIO_BALLOON_S_SWAP_IN 0 /* Amount of memory swapped in */
--
2.7.4
>
> Negotiation of the VIRTIO_BALLOON_F_FREE_PAGE_VQ feature indicates the
> support of reporting hints of guest free pages to host via virtio-balloon.
>
> Host requests the guest to report free pages by sending a new cmd
> id to the guest via the free_page_report_cmd_id configuration register.
>
> When the guest starts to report, the first element added to the free page
> vq is the cmd id given by host. When the guest finishes the reporting
> of all the free pages, VIRTIO_BALLOON_FREE_PAGE_REPORT_STOP_ID is added
> to the vq to tell host that the reporting is done. Host may also requests
> the guest to stop the reporting in advance by sending the stop cmd id to
> the guest via the configuration register.
>
> Signed-off-by: Wei Wang <[email protected]>
> Signed-off-by: Liang Li <[email protected]>
> Cc: Michael S. Tsirkin <[email protected]>
> Cc: Michal Hocko <[email protected]>
> ---
> drivers/virtio/virtio_balloon.c | 242
> +++++++++++++++++++++++++++++++-----
> include/uapi/linux/virtio_balloon.h | 4 +
> 2 files changed, 214 insertions(+), 32 deletions(-)
>
> diff --git a/drivers/virtio/virtio_balloon.c
> b/drivers/virtio/virtio_balloon.c
> index a1fb52c..b9561a5 100644
> --- a/drivers/virtio/virtio_balloon.c
> +++ b/drivers/virtio/virtio_balloon.c
> @@ -53,7 +53,12 @@ static struct vfsmount *balloon_mnt;
>
> struct virtio_balloon {
> struct virtio_device *vdev;
> - struct virtqueue *inflate_vq, *deflate_vq, *stats_vq;
> + struct virtqueue *inflate_vq, *deflate_vq, *stats_vq, *free_page_vq;
> +
> + /* Balloon's own wq for cpu-intensive work items */
> + struct workqueue_struct *balloon_wq;
> + /* The free page reporting work item submitted to the balloon wq */
> + struct work_struct report_free_page_work;
>
> /* The balloon servicing is delegated to a freezable workqueue. */
> struct work_struct update_balloon_stats_work;
> @@ -63,6 +68,13 @@ struct virtio_balloon {
> spinlock_t stop_update_lock;
> bool stop_update;
>
> + /* Start to report free pages */
> + bool report_free_page;
> + /* Stores the cmd id given by host to start the free page reporting */
> + uint32_t start_cmd_id;
> + /* Stores STOP_ID as a sign to tell host that the reporting is done */
> + uint32_t stop_cmd_id;
> +
> /* Waiting for host to ack the pages we released. */
> wait_queue_head_t acked;
>
> @@ -281,6 +293,71 @@ static unsigned int update_balloon_stats(struct
> virtio_balloon *vb)
> return idx;
> }
>
> +static void add_one_sg(struct virtqueue *vq, unsigned long pfn, uint32_t
> len)
> +{
> + struct scatterlist sg;
> + unsigned int unused;
> + int err;
> +
> + sg_init_table(&sg, 1);
> + sg_set_page(&sg, pfn_to_page(pfn), len, 0);
> +
> + /* Detach all the used buffers from the vq */
> + while (virtqueue_get_buf(vq, &unused))
> + ;
> +
> + /*
> + * Since this is an optimization feature, losing a couple of free
> + * pages to report isn't important. We simply resturn without adding
> + * the page if the vq is full. We are adding one entry each time,
> + * which essentially results in no memory allocation, so the
> + * GFP_KERNEL flag below can be ignored.
> + */
> + if (vq->num_free) {
> + err = virtqueue_add_inbuf(vq, &sg, 1, vq, GFP_KERNEL);
> + /*
> + * This is expected to never fail, because there is always an
> + * entry available on the vq.
> + */
> + BUG_ON(err);
> + }
> +}
> +
> +static void batch_free_page_sg(struct virtqueue *vq,
> + unsigned long pfn,
> + uint32_t len)
> +{
> + add_one_sg(vq, pfn, len);
> +
> + /* Batch till the vq is full */
> + if (!vq->num_free)
> + virtqueue_kick(vq);
> +}
> +
> +static void send_cmd_id(struct virtqueue *vq, void *addr)
> +{
> + struct scatterlist sg;
> + unsigned int unused;
> + int err;
> +
> + sg_init_one(&sg, addr, sizeof(uint32_t));
> +
> + /*
> + * This handles the cornercase that the vq happens to be full when
> + * adding a cmd id. Rarely happen in practice.
> + */
> + while (!vq->num_free)
> + virtqueue_get_buf(vq, &unused);
> +
> + err = virtqueue_add_outbuf(vq, &sg, 1, vq, GFP_KERNEL);
> + /*
> + * This is expected to never fail, because there is always an
> + * entry available on the vq.
> + */
> + BUG_ON(err);
> + virtqueue_kick(vq);
> +}
> +
> /*
> * While most virtqueues communicate guest-initiated requests to the
> hypervisor,
> * the stats queue operates in reverse. The driver initializes the
> virtqueue
> @@ -316,17 +393,6 @@ static void stats_handle_request(struct virtio_balloon
> *vb)
> virtqueue_kick(vq);
> }
>
> -static void virtballoon_changed(struct virtio_device *vdev)
> -{
> - struct virtio_balloon *vb = vdev->priv;
> - unsigned long flags;
> -
> - spin_lock_irqsave(&vb->stop_update_lock, flags);
> - if (!vb->stop_update)
> - queue_work(system_freezable_wq, &vb->update_balloon_size_work);
> - spin_unlock_irqrestore(&vb->stop_update_lock, flags);
> -}
> -
> static inline s64 towards_target(struct virtio_balloon *vb)
> {
> s64 target;
> @@ -343,6 +409,36 @@ static inline s64 towards_target(struct virtio_balloon
> *vb)
> return target - vb->num_pages;
> }
>
> +static void virtballoon_changed(struct virtio_device *vdev)
> +{
> + struct virtio_balloon *vb = vdev->priv;
> + unsigned long flags;
> + __u32 cmd_id;
> + s64 diff = towards_target(vb);
> +
> + if (diff) {
> + spin_lock_irqsave(&vb->stop_update_lock, flags);
> + if (!vb->stop_update)
> + queue_work(system_freezable_wq,
> + &vb->update_balloon_size_work);
> + spin_unlock_irqrestore(&vb->stop_update_lock, flags);
> + }
> +
> + virtio_cread(vb->vdev, struct virtio_balloon_config,
> + free_page_report_cmd_id, &cmd_id);
> + if (cmd_id == VIRTIO_BALLOON_FREE_PAGE_REPORT_STOP_ID) {
> + WRITE_ONCE(vb->report_free_page, false);
> + } else if (cmd_id != vb->start_cmd_id) {
> + /*
> + * Host requests to start the reporting by sending a new cmd
> + * id.
> + */
> + WRITE_ONCE(vb->report_free_page, true);
> + vb->start_cmd_id = cmd_id;
> + queue_work(vb->balloon_wq, &vb->report_free_page_work);
> + }
> +}
> +
> static void update_balloon_size(struct virtio_balloon *vb)
> {
> u32 actual = vb->num_pages;
> @@ -417,40 +513,113 @@ static void update_balloon_size_func(struct
> work_struct *work)
>
> static int init_vqs(struct virtio_balloon *vb)
> {
> - struct virtqueue *vqs[3];
> - vq_callback_t *callbacks[] = { balloon_ack, balloon_ack, stats_request };
> - static const char * const names[] = { "inflate", "deflate", "stats" };
> - int err, nvqs;
> + struct virtqueue **vqs;
> + vq_callback_t **callbacks;
> + const char **names;
> + struct scatterlist sg;
> + int i, nvqs, err = -ENOMEM;
> +
> + /* Inflateq and deflateq are used unconditionally */
> + nvqs = 2;
> + if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ))
> + nvqs++;
> + if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ))
> + nvqs++;
> +
> + /* Allocate space for find_vqs parameters */
> + vqs = kcalloc(nvqs, sizeof(*vqs), GFP_KERNEL);
> + if (!vqs)
> + goto err_vq;
> + callbacks = kmalloc_array(nvqs, sizeof(*callbacks), GFP_KERNEL);
> + if (!callbacks)
> + goto err_callback;
> + names = kmalloc_array(nvqs, sizeof(*names), GFP_KERNEL);
> + if (!names)
> + goto err_names;
> +
> + callbacks[0] = balloon_ack;
> + names[0] = "inflate";
> + callbacks[1] = balloon_ack;
> + names[1] = "deflate";
> +
> + i = 2;
> + if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ)) {
> + callbacks[i] = stats_request;
> + names[i] = "stats";
> + i++;
> + }
>
> - /*
> - * We expect two virtqueues: inflate and deflate, and
> - * optionally stat.
> - */
> - nvqs = virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ) ? 3 : 2;
> - err = virtio_find_vqs(vb->vdev, nvqs, vqs, callbacks, names, NULL);
> + if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ)) {
> + callbacks[i] = NULL;
> + names[i] = "free_page_vq";
> + }
> +
> + err = vb->vdev->config->find_vqs(vb->vdev, nvqs, vqs, callbacks, names,
> + NULL, NULL);
> if (err)
> - return err;
> + goto err_find;
>
> vb->inflate_vq = vqs[0];
> vb->deflate_vq = vqs[1];
> + i = 2;
> if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ)) {
> - struct scatterlist sg;
> - unsigned int num_stats;
> - vb->stats_vq = vqs[2];
> -
> + vb->stats_vq = vqs[i++];
> /*
> * Prime this virtqueue with one buffer so the hypervisor can
> * use it to signal us later (it can't be broken yet!).
> */
> - num_stats = update_balloon_stats(vb);
> -
> - sg_init_one(&sg, vb->stats, sizeof(vb->stats[0]) * num_stats);
> + sg_init_one(&sg, vb->stats, sizeof(vb->stats));
> if (virtqueue_add_outbuf(vb->stats_vq, &sg, 1, vb, GFP_KERNEL)
> - < 0)
> - BUG();
> + < 0) {
> + dev_warn(&vb->vdev->dev, "%s: add stat_vq failed\n",
> + __func__);
> + goto err_find;
> + }
> virtqueue_kick(vb->stats_vq);
> }
> +
> + if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ))
> + vb->free_page_vq = vqs[i];
> +
> + kfree(names);
> + kfree(callbacks);
> + kfree(vqs);
> return 0;
We can assign err=0 and remove above duplicate code?
> +
> +err_find:
> + kfree(names);
> +err_names:
> + kfree(callbacks);
> +err_callback:
> + kfree(vqs);
> +err_vq:
> + return err;
> +}
> +
> +static bool virtio_balloon_send_free_pages(void *opaque, unsigned long pfn,
> + unsigned long nr_pages)
> +{
> + struct virtio_balloon *vb = (struct virtio_balloon *)opaque;
> + uint32_t len = nr_pages << PAGE_SHIFT;
> +
> + if (!READ_ONCE(vb->report_free_page))
> + return false;
> +
> + batch_free_page_sg(vb->free_page_vq, pfn, len);
> +
> + return true;
> +}
> +
> +static void report_free_page_func(struct work_struct *work)
> +{
> + struct virtio_balloon *vb;
> +
> + vb = container_of(work, struct virtio_balloon, report_free_page_work);
> + /* Start by sending the obtained cmd id to the host with an outbuf */
> + send_cmd_id(vb->free_page_vq, &vb->start_cmd_id);
> + walk_free_mem_block(vb, 0, &virtio_balloon_send_free_pages);
> + /* End by sending the stop id to the host with an outbuf */
> + send_cmd_id(vb->free_page_vq, &vb->stop_cmd_id);
> }
>
> #ifdef CONFIG_BALLOON_COMPACTION
> @@ -566,6 +735,13 @@ static int virtballoon_probe(struct virtio_device *vdev)
> if (err)
> goto out_free_vb;
>
> + if (virtio_has_feature(vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ)) {
> + vb->balloon_wq = alloc_workqueue("balloon-wq",
> + WQ_FREEZABLE | WQ_CPU_INTENSIVE, 0);
> + INIT_WORK(&vb->report_free_page_work, report_free_page_func);
> + vb->stop_cmd_id = VIRTIO_BALLOON_FREE_PAGE_REPORT_STOP_ID;
> + }
> +
> vb->nb.notifier_call = virtballoon_oom_notify;
> vb->nb.priority = VIRTBALLOON_OOM_NOTIFY_PRIORITY;
> err = register_oom_notifier(&vb->nb);
> @@ -630,6 +806,7 @@ static void virtballoon_remove(struct virtio_device
> *vdev)
> spin_unlock_irq(&vb->stop_update_lock);
> cancel_work_sync(&vb->update_balloon_size_work);
> cancel_work_sync(&vb->update_balloon_stats_work);
> + cancel_work_sync(&vb->report_free_page_work);
>
> remove_common(vb);
> #ifdef CONFIG_BALLOON_COMPACTION
> @@ -682,6 +859,7 @@ static unsigned int features[] = {
> VIRTIO_BALLOON_F_MUST_TELL_HOST,
> VIRTIO_BALLOON_F_STATS_VQ,
> VIRTIO_BALLOON_F_DEFLATE_ON_OOM,
> + VIRTIO_BALLOON_F_FREE_PAGE_VQ,
> };
>
> static struct virtio_driver virtio_balloon_driver = {
> diff --git a/include/uapi/linux/virtio_balloon.h
> b/include/uapi/linux/virtio_balloon.h
> index 343d7dd..55e2456 100644
> --- a/include/uapi/linux/virtio_balloon.h
> +++ b/include/uapi/linux/virtio_balloon.h
> @@ -34,15 +34,19 @@
> #define VIRTIO_BALLOON_F_MUST_TELL_HOST 0 /* Tell before reclaiming pages */
> #define VIRTIO_BALLOON_F_STATS_VQ 1 /* Memory Stats virtqueue */
> #define VIRTIO_BALLOON_F_DEFLATE_ON_OOM 2 /* Deflate balloon on OOM */
> +#define VIRTIO_BALLOON_F_FREE_PAGE_VQ 3 /* VQ to report free pages */
>
> /* Size of a PFN in the balloon interface. */
> #define VIRTIO_BALLOON_PFN_SHIFT 12
>
> +#define VIRTIO_BALLOON_FREE_PAGE_REPORT_STOP_ID 0
> struct virtio_balloon_config {
> /* Number of pages host wants Guest to give up. */
> __u32 num_pages;
> /* Number of pages we've actually got in balloon. */
> __u32 actual;
> + /* Free page report command id, readonly by guest */
> + __u32 free_page_report_cmd_id;
> };
>
> #define VIRTIO_BALLOON_S_SWAP_IN 0 /* Amount of memory swapped in */
> --
> 2.7.4
>
>
On 01/17/2018 04:21 PM, Pankaj Gupta wrote:
>> Negotiation of the VIRTIO_BALLOON_F_FREE_PAGE_VQ feature indicates the
>> support of reporting hints of guest free pages to host via virtio-balloon.
>>
>> Host requests the guest to report free pages by sending a new cmd
>> id to the guest via the free_page_report_cmd_id configuration register.
>>
>> When the guest starts to report, the first element added to the free page
>> vq is the cmd id given by host. When the guest finishes the reporting
>> of all the free pages, VIRTIO_BALLOON_FREE_PAGE_REPORT_STOP_ID is added
>> to the vq to tell host that the reporting is done. Host may also requests
>> the guest to stop the reporting in advance by sending the stop cmd id to
>> the guest via the configuration register.
>>
>> Signed-off-by: Wei Wang <[email protected]>
>> Signed-off-by: Liang Li <[email protected]>
>> Cc: Michael S. Tsirkin <[email protected]>
>> Cc: Michal Hocko <[email protected]>
>> ---
>> drivers/virtio/virtio_balloon.c | 242
>> +++++++++++++++++++++++++++++++-----
>> include/uapi/linux/virtio_balloon.h | 4 +
>> 2 files changed, 214 insertions(+), 32 deletions(-)
>>
>> diff --git a/drivers/virtio/virtio_balloon.c
>> b/drivers/virtio/virtio_balloon.c
>> index a1fb52c..b9561a5 100644
>> --- a/drivers/virtio/virtio_balloon.c
>> +++ b/drivers/virtio/virtio_balloon.c
>> @@ -53,7 +53,12 @@ static struct vfsmount *balloon_mnt;
>>
>> struct virtio_balloon {
>> struct virtio_device *vdev;
>> - struct virtqueue *inflate_vq, *deflate_vq, *stats_vq;
>> + struct virtqueue *inflate_vq, *deflate_vq, *stats_vq, *free_page_vq;
>> +
>> + /* Balloon's own wq for cpu-intensive work items */
>> + struct workqueue_struct *balloon_wq;
>> + /* The free page reporting work item submitted to the balloon wq */
>> + struct work_struct report_free_page_work;
>>
>> /* The balloon servicing is delegated to a freezable workqueue. */
>> struct work_struct update_balloon_stats_work;
>> @@ -63,6 +68,13 @@ struct virtio_balloon {
>> spinlock_t stop_update_lock;
>> bool stop_update;
>>
>> + /* Start to report free pages */
>> + bool report_free_page;
>> + /* Stores the cmd id given by host to start the free page reporting */
>> + uint32_t start_cmd_id;
>> + /* Stores STOP_ID as a sign to tell host that the reporting is done */
>> + uint32_t stop_cmd_id;
>> +
>> /* Waiting for host to ack the pages we released. */
>> wait_queue_head_t acked;
>>
>> @@ -281,6 +293,71 @@ static unsigned int update_balloon_stats(struct
>> virtio_balloon *vb)
>> return idx;
>> }
>>
>> +static void add_one_sg(struct virtqueue *vq, unsigned long pfn, uint32_t
>> len)
>> +{
>> + struct scatterlist sg;
>> + unsigned int unused;
>> + int err;
>> +
>> + sg_init_table(&sg, 1);
>> + sg_set_page(&sg, pfn_to_page(pfn), len, 0);
>> +
>> + /* Detach all the used buffers from the vq */
>> + while (virtqueue_get_buf(vq, &unused))
>> + ;
>> +
>> + /*
>> + * Since this is an optimization feature, losing a couple of free
>> + * pages to report isn't important. We simply resturn without adding
>> + * the page if the vq is full. We are adding one entry each time,
>> + * which essentially results in no memory allocation, so the
>> + * GFP_KERNEL flag below can be ignored.
>> + */
>> + if (vq->num_free) {
>> + err = virtqueue_add_inbuf(vq, &sg, 1, vq, GFP_KERNEL);
>> + /*
>> + * This is expected to never fail, because there is always an
>> + * entry available on the vq.
>> + */
>> + BUG_ON(err);
>> + }
>> +}
>> +
>> +static void batch_free_page_sg(struct virtqueue *vq,
>> + unsigned long pfn,
>> + uint32_t len)
>> +{
>> + add_one_sg(vq, pfn, len);
>> +
>> + /* Batch till the vq is full */
>> + if (!vq->num_free)
>> + virtqueue_kick(vq);
>> +}
>> +
>> +static void send_cmd_id(struct virtqueue *vq, void *addr)
>> +{
>> + struct scatterlist sg;
>> + unsigned int unused;
>> + int err;
>> +
>> + sg_init_one(&sg, addr, sizeof(uint32_t));
>> +
>> + /*
>> + * This handles the cornercase that the vq happens to be full when
>> + * adding a cmd id. Rarely happen in practice.
>> + */
>> + while (!vq->num_free)
>> + virtqueue_get_buf(vq, &unused);
>> +
>> + err = virtqueue_add_outbuf(vq, &sg, 1, vq, GFP_KERNEL);
>> + /*
>> + * This is expected to never fail, because there is always an
>> + * entry available on the vq.
>> + */
>> + BUG_ON(err);
>> + virtqueue_kick(vq);
>> +}
>> +
>> /*
>> * While most virtqueues communicate guest-initiated requests to the
>> hypervisor,
>> * the stats queue operates in reverse. The driver initializes the
>> virtqueue
>> @@ -316,17 +393,6 @@ static void stats_handle_request(struct virtio_balloon
>> *vb)
>> virtqueue_kick(vq);
>> }
>>
>> -static void virtballoon_changed(struct virtio_device *vdev)
>> -{
>> - struct virtio_balloon *vb = vdev->priv;
>> - unsigned long flags;
>> -
>> - spin_lock_irqsave(&vb->stop_update_lock, flags);
>> - if (!vb->stop_update)
>> - queue_work(system_freezable_wq, &vb->update_balloon_size_work);
>> - spin_unlock_irqrestore(&vb->stop_update_lock, flags);
>> -}
>> -
>> static inline s64 towards_target(struct virtio_balloon *vb)
>> {
>> s64 target;
>> @@ -343,6 +409,36 @@ static inline s64 towards_target(struct virtio_balloon
>> *vb)
>> return target - vb->num_pages;
>> }
>>
>> +static void virtballoon_changed(struct virtio_device *vdev)
>> +{
>> + struct virtio_balloon *vb = vdev->priv;
>> + unsigned long flags;
>> + __u32 cmd_id;
>> + s64 diff = towards_target(vb);
>> +
>> + if (diff) {
>> + spin_lock_irqsave(&vb->stop_update_lock, flags);
>> + if (!vb->stop_update)
>> + queue_work(system_freezable_wq,
>> + &vb->update_balloon_size_work);
>> + spin_unlock_irqrestore(&vb->stop_update_lock, flags);
>> + }
>> +
>> + virtio_cread(vb->vdev, struct virtio_balloon_config,
>> + free_page_report_cmd_id, &cmd_id);
>> + if (cmd_id == VIRTIO_BALLOON_FREE_PAGE_REPORT_STOP_ID) {
>> + WRITE_ONCE(vb->report_free_page, false);
>> + } else if (cmd_id != vb->start_cmd_id) {
>> + /*
>> + * Host requests to start the reporting by sending a new cmd
>> + * id.
>> + */
>> + WRITE_ONCE(vb->report_free_page, true);
>> + vb->start_cmd_id = cmd_id;
>> + queue_work(vb->balloon_wq, &vb->report_free_page_work);
>> + }
>> +}
>> +
>> static void update_balloon_size(struct virtio_balloon *vb)
>> {
>> u32 actual = vb->num_pages;
>> @@ -417,40 +513,113 @@ static void update_balloon_size_func(struct
>> work_struct *work)
>>
>> static int init_vqs(struct virtio_balloon *vb)
>> {
>> - struct virtqueue *vqs[3];
>> - vq_callback_t *callbacks[] = { balloon_ack, balloon_ack, stats_request };
>> - static const char * const names[] = { "inflate", "deflate", "stats" };
>> - int err, nvqs;
>> + struct virtqueue **vqs;
>> + vq_callback_t **callbacks;
>> + const char **names;
>> + struct scatterlist sg;
>> + int i, nvqs, err = -ENOMEM;
>> +
>> + /* Inflateq and deflateq are used unconditionally */
>> + nvqs = 2;
>> + if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ))
>> + nvqs++;
>> + if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ))
>> + nvqs++;
>> +
>> + /* Allocate space for find_vqs parameters */
>> + vqs = kcalloc(nvqs, sizeof(*vqs), GFP_KERNEL);
>> + if (!vqs)
>> + goto err_vq;
>> + callbacks = kmalloc_array(nvqs, sizeof(*callbacks), GFP_KERNEL);
>> + if (!callbacks)
>> + goto err_callback;
>> + names = kmalloc_array(nvqs, sizeof(*names), GFP_KERNEL);
>> + if (!names)
>> + goto err_names;
>> +
>> + callbacks[0] = balloon_ack;
>> + names[0] = "inflate";
>> + callbacks[1] = balloon_ack;
>> + names[1] = "deflate";
>> +
>> + i = 2;
>> + if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ)) {
>> + callbacks[i] = stats_request;
>> + names[i] = "stats";
>> + i++;
>> + }
>>
>> - /*
>> - * We expect two virtqueues: inflate and deflate, and
>> - * optionally stat.
>> - */
>> - nvqs = virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ) ? 3 : 2;
>> - err = virtio_find_vqs(vb->vdev, nvqs, vqs, callbacks, names, NULL);
>> + if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ)) {
>> + callbacks[i] = NULL;
>> + names[i] = "free_page_vq";
>> + }
>> +
>> + err = vb->vdev->config->find_vqs(vb->vdev, nvqs, vqs, callbacks, names,
>> + NULL, NULL);
>> if (err)
>> - return err;
>> + goto err_find;
>>
>> vb->inflate_vq = vqs[0];
>> vb->deflate_vq = vqs[1];
>> + i = 2;
>> if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ)) {
>> - struct scatterlist sg;
>> - unsigned int num_stats;
>> - vb->stats_vq = vqs[2];
>> -
>> + vb->stats_vq = vqs[i++];
>> /*
>> * Prime this virtqueue with one buffer so the hypervisor can
>> * use it to signal us later (it can't be broken yet!).
>> */
>> - num_stats = update_balloon_stats(vb);
>> -
>> - sg_init_one(&sg, vb->stats, sizeof(vb->stats[0]) * num_stats);
>> + sg_init_one(&sg, vb->stats, sizeof(vb->stats));
>> if (virtqueue_add_outbuf(vb->stats_vq, &sg, 1, vb, GFP_KERNEL)
>> - < 0)
>> - BUG();
>> + < 0) {
>> + dev_warn(&vb->vdev->dev, "%s: add stat_vq failed\n",
>> + __func__);
>> + goto err_find;
>> + }
>> virtqueue_kick(vb->stats_vq);
>> }
>> +
>> + if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ))
>> + vb->free_page_vq = vqs[i];
>> +
>> + kfree(names);
>> + kfree(callbacks);
>> + kfree(vqs);
>> return 0;
>
> We can assign err=0 and remove above duplicate code?
>
Where do you want to assign err=0? Could you show it using code?
Best,
Wei
> On 01/17/2018 04:21 PM, Pankaj Gupta wrote:
> >> Negotiation of the VIRTIO_BALLOON_F_FREE_PAGE_VQ feature indicates the
> >> support of reporting hints of guest free pages to host via virtio-balloon.
> >>
> >> Host requests the guest to report free pages by sending a new cmd
> >> id to the guest via the free_page_report_cmd_id configuration register.
> >>
> >> When the guest starts to report, the first element added to the free page
> >> vq is the cmd id given by host. When the guest finishes the reporting
> >> of all the free pages, VIRTIO_BALLOON_FREE_PAGE_REPORT_STOP_ID is added
> >> to the vq to tell host that the reporting is done. Host may also requests
> >> the guest to stop the reporting in advance by sending the stop cmd id to
> >> the guest via the configuration register.
> >>
> >> Signed-off-by: Wei Wang <[email protected]>
> >> Signed-off-by: Liang Li <[email protected]>
> >> Cc: Michael S. Tsirkin <[email protected]>
> >> Cc: Michal Hocko <[email protected]>
> >> ---
> >> drivers/virtio/virtio_balloon.c | 242
> >> +++++++++++++++++++++++++++++++-----
> >> include/uapi/linux/virtio_balloon.h | 4 +
> >> 2 files changed, 214 insertions(+), 32 deletions(-)
> >>
> >> diff --git a/drivers/virtio/virtio_balloon.c
> >> b/drivers/virtio/virtio_balloon.c
> >> index a1fb52c..b9561a5 100644
> >> --- a/drivers/virtio/virtio_balloon.c
> >> +++ b/drivers/virtio/virtio_balloon.c
> >> @@ -53,7 +53,12 @@ static struct vfsmount *balloon_mnt;
> >>
> >> struct virtio_balloon {
> >> struct virtio_device *vdev;
> >> - struct virtqueue *inflate_vq, *deflate_vq, *stats_vq;
> >> + struct virtqueue *inflate_vq, *deflate_vq, *stats_vq, *free_page_vq;
> >> +
> >> + /* Balloon's own wq for cpu-intensive work items */
> >> + struct workqueue_struct *balloon_wq;
> >> + /* The free page reporting work item submitted to the balloon wq */
> >> + struct work_struct report_free_page_work;
> >>
> >> /* The balloon servicing is delegated to a freezable workqueue. */
> >> struct work_struct update_balloon_stats_work;
> >> @@ -63,6 +68,13 @@ struct virtio_balloon {
> >> spinlock_t stop_update_lock;
> >> bool stop_update;
> >>
> >> + /* Start to report free pages */
> >> + bool report_free_page;
> >> + /* Stores the cmd id given by host to start the free page reporting */
> >> + uint32_t start_cmd_id;
> >> + /* Stores STOP_ID as a sign to tell host that the reporting is done */
> >> + uint32_t stop_cmd_id;
> >> +
> >> /* Waiting for host to ack the pages we released. */
> >> wait_queue_head_t acked;
> >>
> >> @@ -281,6 +293,71 @@ static unsigned int update_balloon_stats(struct
> >> virtio_balloon *vb)
> >> return idx;
> >> }
> >>
> >> +static void add_one_sg(struct virtqueue *vq, unsigned long pfn, uint32_t
> >> len)
> >> +{
> >> + struct scatterlist sg;
> >> + unsigned int unused;
> >> + int err;
> >> +
> >> + sg_init_table(&sg, 1);
> >> + sg_set_page(&sg, pfn_to_page(pfn), len, 0);
> >> +
> >> + /* Detach all the used buffers from the vq */
> >> + while (virtqueue_get_buf(vq, &unused))
> >> + ;
> >> +
> >> + /*
> >> + * Since this is an optimization feature, losing a couple of free
> >> + * pages to report isn't important. We simply resturn without adding
> >> + * the page if the vq is full. We are adding one entry each time,
> >> + * which essentially results in no memory allocation, so the
> >> + * GFP_KERNEL flag below can be ignored.
> >> + */
> >> + if (vq->num_free) {
> >> + err = virtqueue_add_inbuf(vq, &sg, 1, vq, GFP_KERNEL);
> >> + /*
> >> + * This is expected to never fail, because there is always an
> >> + * entry available on the vq.
> >> + */
> >> + BUG_ON(err);
> >> + }
> >> +}
> >> +
> >> +static void batch_free_page_sg(struct virtqueue *vq,
> >> + unsigned long pfn,
> >> + uint32_t len)
> >> +{
> >> + add_one_sg(vq, pfn, len);
> >> +
> >> + /* Batch till the vq is full */
> >> + if (!vq->num_free)
> >> + virtqueue_kick(vq);
> >> +}
> >> +
> >> +static void send_cmd_id(struct virtqueue *vq, void *addr)
> >> +{
> >> + struct scatterlist sg;
> >> + unsigned int unused;
> >> + int err;
> >> +
> >> + sg_init_one(&sg, addr, sizeof(uint32_t));
> >> +
> >> + /*
> >> + * This handles the cornercase that the vq happens to be full when
> >> + * adding a cmd id. Rarely happen in practice.
> >> + */
> >> + while (!vq->num_free)
> >> + virtqueue_get_buf(vq, &unused);
> >> +
> >> + err = virtqueue_add_outbuf(vq, &sg, 1, vq, GFP_KERNEL);
> >> + /*
> >> + * This is expected to never fail, because there is always an
> >> + * entry available on the vq.
> >> + */
> >> + BUG_ON(err);
> >> + virtqueue_kick(vq);
> >> +}
> >> +
> >> /*
> >> * While most virtqueues communicate guest-initiated requests to the
> >> hypervisor,
> >> * the stats queue operates in reverse. The driver initializes the
> >> virtqueue
> >> @@ -316,17 +393,6 @@ static void stats_handle_request(struct
> >> virtio_balloon
> >> *vb)
> >> virtqueue_kick(vq);
> >> }
> >>
> >> -static void virtballoon_changed(struct virtio_device *vdev)
> >> -{
> >> - struct virtio_balloon *vb = vdev->priv;
> >> - unsigned long flags;
> >> -
> >> - spin_lock_irqsave(&vb->stop_update_lock, flags);
> >> - if (!vb->stop_update)
> >> - queue_work(system_freezable_wq, &vb->update_balloon_size_work);
> >> - spin_unlock_irqrestore(&vb->stop_update_lock, flags);
> >> -}
> >> -
> >> static inline s64 towards_target(struct virtio_balloon *vb)
> >> {
> >> s64 target;
> >> @@ -343,6 +409,36 @@ static inline s64 towards_target(struct
> >> virtio_balloon
> >> *vb)
> >> return target - vb->num_pages;
> >> }
> >>
> >> +static void virtballoon_changed(struct virtio_device *vdev)
> >> +{
> >> + struct virtio_balloon *vb = vdev->priv;
> >> + unsigned long flags;
> >> + __u32 cmd_id;
> >> + s64 diff = towards_target(vb);
> >> +
> >> + if (diff) {
> >> + spin_lock_irqsave(&vb->stop_update_lock, flags);
> >> + if (!vb->stop_update)
> >> + queue_work(system_freezable_wq,
> >> + &vb->update_balloon_size_work);
> >> + spin_unlock_irqrestore(&vb->stop_update_lock, flags);
> >> + }
> >> +
> >> + virtio_cread(vb->vdev, struct virtio_balloon_config,
> >> + free_page_report_cmd_id, &cmd_id);
> >> + if (cmd_id == VIRTIO_BALLOON_FREE_PAGE_REPORT_STOP_ID) {
> >> + WRITE_ONCE(vb->report_free_page, false);
> >> + } else if (cmd_id != vb->start_cmd_id) {
> >> + /*
> >> + * Host requests to start the reporting by sending a new cmd
> >> + * id.
> >> + */
> >> + WRITE_ONCE(vb->report_free_page, true);
> >> + vb->start_cmd_id = cmd_id;
> >> + queue_work(vb->balloon_wq, &vb->report_free_page_work);
> >> + }
> >> +}
> >> +
> >> static void update_balloon_size(struct virtio_balloon *vb)
> >> {
> >> u32 actual = vb->num_pages;
> >> @@ -417,40 +513,113 @@ static void update_balloon_size_func(struct
> >> work_struct *work)
> >>
> >> static int init_vqs(struct virtio_balloon *vb)
> >> {
> >> - struct virtqueue *vqs[3];
> >> - vq_callback_t *callbacks[] = { balloon_ack, balloon_ack, stats_request
> >> };
> >> - static const char * const names[] = { "inflate", "deflate", "stats" };
> >> - int err, nvqs;
> >> + struct virtqueue **vqs;
> >> + vq_callback_t **callbacks;
> >> + const char **names;
> >> + struct scatterlist sg;
> >> + int i, nvqs, err = -ENOMEM;
> >> +
> >> + /* Inflateq and deflateq are used unconditionally */
> >> + nvqs = 2;
> >> + if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ))
> >> + nvqs++;
> >> + if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ))
> >> + nvqs++;
> >> +
> >> + /* Allocate space for find_vqs parameters */
> >> + vqs = kcalloc(nvqs, sizeof(*vqs), GFP_KERNEL);
> >> + if (!vqs)
> >> + goto err_vq;
> >> + callbacks = kmalloc_array(nvqs, sizeof(*callbacks), GFP_KERNEL);
> >> + if (!callbacks)
> >> + goto err_callback;
> >> + names = kmalloc_array(nvqs, sizeof(*names), GFP_KERNEL);
> >> + if (!names)
> >> + goto err_names;
> >> +
> >> + callbacks[0] = balloon_ack;
> >> + names[0] = "inflate";
> >> + callbacks[1] = balloon_ack;
> >> + names[1] = "deflate";
> >> +
> >> + i = 2;
> >> + if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ)) {
> >> + callbacks[i] = stats_request;
> >> + names[i] = "stats";
> >> + i++;
> >> + }
> >>
> >> - /*
> >> - * We expect two virtqueues: inflate and deflate, and
> >> - * optionally stat.
> >> - */
> >> - nvqs = virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ) ? 3 : 2;
> >> - err = virtio_find_vqs(vb->vdev, nvqs, vqs, callbacks, names, NULL);
> >> + if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ)) {
> >> + callbacks[i] = NULL;
> >> + names[i] = "free_page_vq";
> >> + }
> >> +
> >> + err = vb->vdev->config->find_vqs(vb->vdev, nvqs, vqs, callbacks, names,
> >> + NULL, NULL);
> >> if (err)
> >> - return err;
> >> + goto err_find;
> >>
> >> vb->inflate_vq = vqs[0];
> >> vb->deflate_vq = vqs[1];
> >> + i = 2;
> >> if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ)) {
> >> - struct scatterlist sg;
> >> - unsigned int num_stats;
> >> - vb->stats_vq = vqs[2];
> >> -
> >> + vb->stats_vq = vqs[i++];
> >> /*
> >> * Prime this virtqueue with one buffer so the hypervisor can
> >> * use it to signal us later (it can't be broken yet!).
> >> */
> >> - num_stats = update_balloon_stats(vb);
> >> -
> >> - sg_init_one(&sg, vb->stats, sizeof(vb->stats[0]) * num_stats);
> >> + sg_init_one(&sg, vb->stats, sizeof(vb->stats));
> >> if (virtqueue_add_outbuf(vb->stats_vq, &sg, 1, vb, GFP_KERNEL)
> >> - < 0)
> >> - BUG();
> >> + < 0) {
> >> + dev_warn(&vb->vdev->dev, "%s: add stat_vq failed\n",
> >> + __func__);
> >> + goto err_find;
> >> + }
> >> virtqueue_kick(vb->stats_vq);
> >> }
> >> +
> >> + if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ))
> >> + vb->free_page_vq = vqs[i];
> >> +
> >> + kfree(names);
> >> + kfree(callbacks);
> >> + kfree(vqs);
> >> return 0;
> >
> > We can assign err=0 and remove above duplicate code?
> >
>
> Where do you want to assign err=0? Could you show it using code?
o.k you have initialize "err = -ENOMEM;"
Remove these four lines.
- kfree(names);
- kfree(callbacks);
- kfree(vqs);
- return 0;
+ err = 0; // if executed without any error
Below code is already there, so for error, err is already 'ENOMEM'
and a jump to any label.
+
+err_find:
+ kfree(names);
+err_names:
+ kfree(callbacks);
+err_callback:
+ kfree(vqs);
> +err_vq:
> + return err;
> +}
Thanks,
Pankaj
>
>
> Best,
> Wei
>
>
>
On 01/17/2018 05:27 PM, Pankaj Gupta wrote:
>> On 01/17/2018 04:21 PM, Pankaj Gupta wrote:
>>
> o.k you have initialize "err = -ENOMEM;"
>
> Remove these four lines.
>
> - kfree(names);
> - kfree(callbacks);
> - kfree(vqs);
> - return 0;
>
> + err = 0; // if executed without any error
>
OK, thanks. "error = 0" is not needed actually.
Best,
Wei
On Wed, Jan 17, 2018 at 01:10:11PM +0800, Wei Wang wrote:
> Negotiation of the VIRTIO_BALLOON_F_FREE_PAGE_VQ feature indicates the
> support of reporting hints of guest free pages to host via virtio-balloon.
>
> Host requests the guest to report free pages by sending a new cmd
> id to the guest via the free_page_report_cmd_id configuration register.
>
> When the guest starts to report, the first element added to the free page
> vq is the cmd id given by host. When the guest finishes the reporting
> of all the free pages, VIRTIO_BALLOON_FREE_PAGE_REPORT_STOP_ID is added
> to the vq to tell host that the reporting is done. Host may also requests
> the guest to stop the reporting in advance by sending the stop cmd id to
> the guest via the configuration register.
>
> Signed-off-by: Wei Wang <[email protected]>
> Signed-off-by: Liang Li <[email protected]>
> Cc: Michael S. Tsirkin <[email protected]>
> Cc: Michal Hocko <[email protected]>
> ---
> drivers/virtio/virtio_balloon.c | 242 +++++++++++++++++++++++++++++++-----
> include/uapi/linux/virtio_balloon.h | 4 +
> 2 files changed, 214 insertions(+), 32 deletions(-)
>
> diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c
> index a1fb52c..b9561a5 100644
> --- a/drivers/virtio/virtio_balloon.c
> +++ b/drivers/virtio/virtio_balloon.c
> @@ -53,7 +53,12 @@ static struct vfsmount *balloon_mnt;
>
> struct virtio_balloon {
> struct virtio_device *vdev;
> - struct virtqueue *inflate_vq, *deflate_vq, *stats_vq;
> + struct virtqueue *inflate_vq, *deflate_vq, *stats_vq, *free_page_vq;
> +
> + /* Balloon's own wq for cpu-intensive work items */
> + struct workqueue_struct *balloon_wq;
> + /* The free page reporting work item submitted to the balloon wq */
> + struct work_struct report_free_page_work;
>
> /* The balloon servicing is delegated to a freezable workqueue. */
> struct work_struct update_balloon_stats_work;
> @@ -63,6 +68,13 @@ struct virtio_balloon {
> spinlock_t stop_update_lock;
> bool stop_update;
>
> + /* Start to report free pages */
> + bool report_free_page;
> + /* Stores the cmd id given by host to start the free page reporting */
> + uint32_t start_cmd_id;
> + /* Stores STOP_ID as a sign to tell host that the reporting is done */
> + uint32_t stop_cmd_id;
> +
> /* Waiting for host to ack the pages we released. */
> wait_queue_head_t acked;
>
> @@ -281,6 +293,71 @@ static unsigned int update_balloon_stats(struct virtio_balloon *vb)
> return idx;
> }
>
> +static void add_one_sg(struct virtqueue *vq, unsigned long pfn, uint32_t len)
> +{
> + struct scatterlist sg;
> + unsigned int unused;
> + int err;
> +
> + sg_init_table(&sg, 1);
> + sg_set_page(&sg, pfn_to_page(pfn), len, 0);
> +
> + /* Detach all the used buffers from the vq */
> + while (virtqueue_get_buf(vq, &unused))
> + ;
> +
> + /*
> + * Since this is an optimization feature, losing a couple of free
> + * pages to report isn't important.
> We simply resturn
return
> without adding
> + * the page if the vq is full. We are adding one entry each time,
> + * which essentially results in no memory allocation, so the
> + * GFP_KERNEL flag below can be ignored.
> + */
> + if (vq->num_free) {
> + err = virtqueue_add_inbuf(vq, &sg, 1, vq, GFP_KERNEL);
Should we kick here? At least when ring is close to
being full. Kick at half way full?
Otherwise it's unlikely ring will
ever be cleaned until we finish the scan.
> + /*
> + * This is expected to never fail, because there is always an
> + * entry available on the vq.
> + */
> + BUG_ON(err);
> + }
> +}
> +
> +static void batch_free_page_sg(struct virtqueue *vq,
> + unsigned long pfn,
> + uint32_t len)
Not sure what does batch refer to here.
I'd just open-code this.
> +{
> + add_one_sg(vq, pfn, len);
> +
> + /* Batch till the vq is full */
> + if (!vq->num_free)
> + virtqueue_kick(vq);
> +}
> +
> +static void send_cmd_id(struct virtqueue *vq, void *addr)
Why void *? Should be a specific type.
then you can use sizeof *addr as size.
> +{
> + struct scatterlist sg;
> + unsigned int unused;
> + int err;
> +
> + sg_init_one(&sg, addr, sizeof(uint32_t));
This passes a guest-endian value to host. This is a problem:
should always pass LE values.
> +
> + /*
> + * This handles the cornercase that the vq happens to be full when
> + * adding a cmd id. Rarely happen in practice.
> + */
> + while (!vq->num_free)
> + virtqueue_get_buf(vq, &unused);
I dislike this busy-waiting. It's a hint after all -
why not just retry later - hopefully after getting an
interrupt?
Alternatively, stop adding more entries when we have a single
ring entry left, making sure we have space for the command.
> +
> + err = virtqueue_add_outbuf(vq, &sg, 1, vq, GFP_KERNEL);
> + /*
> + * This is expected to never fail, because there is always an
> + * entry available on the vq.
> + */
> + BUG_ON(err);
> + virtqueue_kick(vq);
> +}
> +
> /*
> * While most virtqueues communicate guest-initiated requests to the hypervisor,
> * the stats queue operates in reverse. The driver initializes the virtqueue
> @@ -316,17 +393,6 @@ static void stats_handle_request(struct virtio_balloon *vb)
> virtqueue_kick(vq);
> }
>
> -static void virtballoon_changed(struct virtio_device *vdev)
> -{
> - struct virtio_balloon *vb = vdev->priv;
> - unsigned long flags;
> -
> - spin_lock_irqsave(&vb->stop_update_lock, flags);
> - if (!vb->stop_update)
> - queue_work(system_freezable_wq, &vb->update_balloon_size_work);
> - spin_unlock_irqrestore(&vb->stop_update_lock, flags);
> -}
> -
> static inline s64 towards_target(struct virtio_balloon *vb)
> {
> s64 target;
> @@ -343,6 +409,36 @@ static inline s64 towards_target(struct virtio_balloon *vb)
> return target - vb->num_pages;
> }
>
> +static void virtballoon_changed(struct virtio_device *vdev)
> +{
> + struct virtio_balloon *vb = vdev->priv;
> + unsigned long flags;
> + __u32 cmd_id;
> + s64 diff = towards_target(vb);
> +
> + if (diff) {
> + spin_lock_irqsave(&vb->stop_update_lock, flags);
> + if (!vb->stop_update)
Why do you ignore stop_update for freeze?
This means new wq entries can be added during remove
causing use after free issues.
> + queue_work(system_freezable_wq,
> + &vb->update_balloon_size_work);
> + spin_unlock_irqrestore(&vb->stop_update_lock, flags);
> + }
> +
> + virtio_cread(vb->vdev, struct virtio_balloon_config,
> + free_page_report_cmd_id, &cmd_id);
You want virtio_cread_feature, don't access the new field
if the feature has not been negotiated.
> + if (cmd_id == VIRTIO_BALLOON_FREE_PAGE_REPORT_STOP_ID) {
> + WRITE_ONCE(vb->report_free_page, false);
> + } else if (cmd_id != vb->start_cmd_id) {
> + /*
> + * Host requests to start the reporting by sending a new cmd
> + * id.
> + */
> + WRITE_ONCE(vb->report_free_page, true);
I don't know why we bother with WRITE_ONCE here. The point of
report_free_page being used lockless is that that it's not a big deal if
it's wrong occasionally, right?
> + vb->start_cmd_id = cmd_id;
> + queue_work(vb->balloon_wq, &vb->report_free_page_work);
It seems that if a command was already queued (with a different id),
this will result in new command id being sent to host twice, which will
likely confuse the host.
> + }
> +}
> +
> static void update_balloon_size(struct virtio_balloon *vb)
> {
> u32 actual = vb->num_pages;
> @@ -417,40 +513,113 @@ static void update_balloon_size_func(struct work_struct *work)
>
> static int init_vqs(struct virtio_balloon *vb)
> {
> - struct virtqueue *vqs[3];
> - vq_callback_t *callbacks[] = { balloon_ack, balloon_ack, stats_request };
> - static const char * const names[] = { "inflate", "deflate", "stats" };
> - int err, nvqs;
> + struct virtqueue **vqs;
> + vq_callback_t **callbacks;
> + const char **names;
> + struct scatterlist sg;
> + int i, nvqs, err = -ENOMEM;
> +
> + /* Inflateq and deflateq are used unconditionally */
> + nvqs = 2;
> + if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ))
> + nvqs++;
> + if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ))
> + nvqs++;
> +
> + /* Allocate space for find_vqs parameters */
> + vqs = kcalloc(nvqs, sizeof(*vqs), GFP_KERNEL);
> + if (!vqs)
> + goto err_vq;
> + callbacks = kmalloc_array(nvqs, sizeof(*callbacks), GFP_KERNEL);
> + if (!callbacks)
> + goto err_callback;
> + names = kmalloc_array(nvqs, sizeof(*names), GFP_KERNEL);
> + if (!names)
> + goto err_names;
Why not just keep these 3 arrays on stack? they aren't large.
> +
> + callbacks[0] = balloon_ack;
> + names[0] = "inflate";
> + callbacks[1] = balloon_ack;
> + names[1] = "deflate";
> +
> + i = 2;
> + if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ)) {
> + callbacks[i] = stats_request;
> + names[i] = "stats";
> + i++;
> + }
>
> - /*
> - * We expect two virtqueues: inflate and deflate, and
> - * optionally stat.
> - */
> - nvqs = virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ) ? 3 : 2;
> - err = virtio_find_vqs(vb->vdev, nvqs, vqs, callbacks, names, NULL);
> + if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ)) {
> + callbacks[i] = NULL;
> + names[i] = "free_page_vq";
> + }
> +
> + err = vb->vdev->config->find_vqs(vb->vdev, nvqs, vqs, callbacks, names,
> + NULL, NULL);
> if (err)
> - return err;
> + goto err_find;
>
> vb->inflate_vq = vqs[0];
> vb->deflate_vq = vqs[1];
> + i = 2;
> if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ)) {
> - struct scatterlist sg;
> - unsigned int num_stats;
> - vb->stats_vq = vqs[2];
> -
> + vb->stats_vq = vqs[i++];
> /*
> * Prime this virtqueue with one buffer so the hypervisor can
> * use it to signal us later (it can't be broken yet!).
> */
> - num_stats = update_balloon_stats(vb);
> -
> - sg_init_one(&sg, vb->stats, sizeof(vb->stats[0]) * num_stats);
> + sg_init_one(&sg, vb->stats, sizeof(vb->stats));
> if (virtqueue_add_outbuf(vb->stats_vq, &sg, 1, vb, GFP_KERNEL)
> - < 0)
> - BUG();
> + < 0) {
> + dev_warn(&vb->vdev->dev, "%s: add stat_vq failed\n",
> + __func__);
> + goto err_find;
> + }
> virtqueue_kick(vb->stats_vq);
> }
> +
> + if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ))
> + vb->free_page_vq = vqs[i];
> +
> + kfree(names);
> + kfree(callbacks);
> + kfree(vqs);
> return 0;
> +
> +err_find:
> + kfree(names);
> +err_names:
> + kfree(callbacks);
> +err_callback:
> + kfree(vqs);
> +err_vq:
> + return err;
> +}
> +
> +static bool virtio_balloon_send_free_pages(void *opaque, unsigned long pfn,
> + unsigned long nr_pages)
> +{
> + struct virtio_balloon *vb = (struct virtio_balloon *)opaque;
> + uint32_t len = nr_pages << PAGE_SHIFT;
> +
> + if (!READ_ONCE(vb->report_free_page))
> + return false;
> +
> + batch_free_page_sg(vb->free_page_vq, pfn, len);
> +
> + return true;
> +}
> +
> +static void report_free_page_func(struct work_struct *work)
> +{
> + struct virtio_balloon *vb;
> +
> + vb = container_of(work, struct virtio_balloon, report_free_page_work);
> + /* Start by sending the obtained cmd id to the host with an outbuf */
> + send_cmd_id(vb->free_page_vq, &vb->start_cmd_id);
> + walk_free_mem_block(vb, 0, &virtio_balloon_send_free_pages);
> + /* End by sending the stop id to the host with an outbuf */
> + send_cmd_id(vb->free_page_vq, &vb->stop_cmd_id);
> }
>
> #ifdef CONFIG_BALLOON_COMPACTION
> @@ -566,6 +735,13 @@ static int virtballoon_probe(struct virtio_device *vdev)
> if (err)
> goto out_free_vb;
>
> + if (virtio_has_feature(vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ)) {
> + vb->balloon_wq = alloc_workqueue("balloon-wq",
> + WQ_FREEZABLE | WQ_CPU_INTENSIVE, 0);
No destroy_workqueue in sight, will likely leak a wq in remove.
> + INIT_WORK(&vb->report_free_page_work, report_free_page_func);
> + vb->stop_cmd_id = VIRTIO_BALLOON_FREE_PAGE_REPORT_STOP_ID;
> + }
> +
> vb->nb.notifier_call = virtballoon_oom_notify;
> vb->nb.priority = VIRTBALLOON_OOM_NOTIFY_PRIORITY;
> err = register_oom_notifier(&vb->nb);
> @@ -630,6 +806,7 @@ static void virtballoon_remove(struct virtio_device *vdev)
> spin_unlock_irq(&vb->stop_update_lock);
> cancel_work_sync(&vb->update_balloon_size_work);
> cancel_work_sync(&vb->update_balloon_stats_work);
> + cancel_work_sync(&vb->report_free_page_work);
>
> remove_common(vb);
> #ifdef CONFIG_BALLOON_COMPACTION
> @@ -682,6 +859,7 @@ static unsigned int features[] = {
> VIRTIO_BALLOON_F_MUST_TELL_HOST,
> VIRTIO_BALLOON_F_STATS_VQ,
> VIRTIO_BALLOON_F_DEFLATE_ON_OOM,
> + VIRTIO_BALLOON_F_FREE_PAGE_VQ,
> };
>
> static struct virtio_driver virtio_balloon_driver = {
> diff --git a/include/uapi/linux/virtio_balloon.h b/include/uapi/linux/virtio_balloon.h
> index 343d7dd..55e2456 100644
> --- a/include/uapi/linux/virtio_balloon.h
> +++ b/include/uapi/linux/virtio_balloon.h
> @@ -34,15 +34,19 @@
> #define VIRTIO_BALLOON_F_MUST_TELL_HOST 0 /* Tell before reclaiming pages */
> #define VIRTIO_BALLOON_F_STATS_VQ 1 /* Memory Stats virtqueue */
> #define VIRTIO_BALLOON_F_DEFLATE_ON_OOM 2 /* Deflate balloon on OOM */
> +#define VIRTIO_BALLOON_F_FREE_PAGE_VQ 3 /* VQ to report free pages */
>
> /* Size of a PFN in the balloon interface. */
> #define VIRTIO_BALLOON_PFN_SHIFT 12
>
> +#define VIRTIO_BALLOON_FREE_PAGE_REPORT_STOP_ID 0
> struct virtio_balloon_config {
> /* Number of pages host wants Guest to give up. */
> __u32 num_pages;
> /* Number of pages we've actually got in balloon. */
> __u32 actual;
> + /* Free page report command id, readonly by guest */
> + __u32 free_page_report_cmd_id;
> };
>
> #define VIRTIO_BALLOON_S_SWAP_IN 0 /* Amount of memory swapped in */
> --
> 2.7.4
On 2018/01/18 1:44, Michael S. Tsirkin wrote:
>> +static void add_one_sg(struct virtqueue *vq, unsigned long pfn, uint32_t len)
>> +{
>> + struct scatterlist sg;
>> + unsigned int unused;
>> + int err;
>> +
>> + sg_init_table(&sg, 1);
>> + sg_set_page(&sg, pfn_to_page(pfn), len, 0);
>> +
>> + /* Detach all the used buffers from the vq */
>> + while (virtqueue_get_buf(vq, &unused))
>> + ;
>> +
>> + /*
>> + * Since this is an optimization feature, losing a couple of free
>> + * pages to report isn't important.
>> We simply resturn
>
> return
>
>> without adding
>> + * the page if the vq is full. We are adding one entry each time,
>> + * which essentially results in no memory allocation, so the
>> + * GFP_KERNEL flag below can be ignored.
>> + */
>> + if (vq->num_free) {
>> + err = virtqueue_add_inbuf(vq, &sg, 1, vq, GFP_KERNEL);
>
> Should we kick here? At least when ring is close to
> being full. Kick at half way full?
> Otherwise it's unlikely ring will
> ever be cleaned until we finish the scan.
Since this add_one_sg() is called between spin_lock_irqsave(&zone->lock, flags)
and spin_unlock_irqrestore(&zone->lock, flags), it is not permitted to sleep.
And walk_free_mem_block() is not ready to handle resume.
By the way, specifying GFP_KERNEL here is confusing even though it is never used.
walk_free_mem_block() says:
* The callback itself must not sleep or perform any operations which would
* require any memory allocations directly (not even GFP_NOWAIT/GFP_ATOMIC)
* or via any lock dependency.
>
>> + /*
>> + * This is expected to never fail, because there is always an
>> + * entry available on the vq.
>> + */
>> + BUG_ON(err);
>> + }
>> +}
On Thu, Jan 18, 2018 at 10:30:18PM +0900, Tetsuo Handa wrote:
> On 2018/01/18 1:44, Michael S. Tsirkin wrote:
> >> +static void add_one_sg(struct virtqueue *vq, unsigned long pfn, uint32_t len)
> >> +{
> >> + struct scatterlist sg;
> >> + unsigned int unused;
> >> + int err;
> >> +
> >> + sg_init_table(&sg, 1);
> >> + sg_set_page(&sg, pfn_to_page(pfn), len, 0);
> >> +
> >> + /* Detach all the used buffers from the vq */
> >> + while (virtqueue_get_buf(vq, &unused))
> >> + ;
> >> +
> >> + /*
> >> + * Since this is an optimization feature, losing a couple of free
> >> + * pages to report isn't important.
> >> We simply resturn
> >
> > return
> >
> >> without adding
> >> + * the page if the vq is full. We are adding one entry each time,
> >> + * which essentially results in no memory allocation, so the
> >> + * GFP_KERNEL flag below can be ignored.
> >> + */
> >> + if (vq->num_free) {
> >> + err = virtqueue_add_inbuf(vq, &sg, 1, vq, GFP_KERNEL);
> >
> > Should we kick here? At least when ring is close to
> > being full. Kick at half way full?
> > Otherwise it's unlikely ring will
> > ever be cleaned until we finish the scan.
>
> Since this add_one_sg() is called between spin_lock_irqsave(&zone->lock, flags)
> and spin_unlock_irqrestore(&zone->lock, flags), it is not permitted to sleep.
kick takes a while sometimes but it doesn't sleep.
> And walk_free_mem_block() is not ready to handle resume.
>
> By the way, specifying GFP_KERNEL here is confusing even though it is never used.
> walk_free_mem_block() says:
>
> * The callback itself must not sleep or perform any operations which would
> * require any memory allocations directly (not even GFP_NOWAIT/GFP_ATOMIC)
> * or via any lock dependency.
Yea, GFP_ATOMIC would do just as well. But I think any allocation
on this path would be problematic.
How about a flag to make all allocations fail?
E.g.
#define GFP_FORBIDDEN (___GFP_DMA | ___GFP_HIGHMEM)
Still this is not a blocker, we can worry about this later.
> >
> >> + /*
> >> + * This is expected to never fail, because there is always an
> >> + * entry available on the vq.
> >> + */
> >> + BUG_ON(err);
> >> + }
> >> +}
Michael S. Tsirkin wrote:
> On Thu, Jan 18, 2018 at 10:30:18PM +0900, Tetsuo Handa wrote:
> > On 2018/01/18 1:44, Michael S. Tsirkin wrote:
> > >> +static void add_one_sg(struct virtqueue *vq, unsigned long pfn, uint32_t len)
> > >> +{
> > >> + struct scatterlist sg;
> > >> + unsigned int unused;
> > >> + int err;
> > >> +
> > >> + sg_init_table(&sg, 1);
> > >> + sg_set_page(&sg, pfn_to_page(pfn), len, 0);
> > >> +
> > >> + /* Detach all the used buffers from the vq */
> > >> + while (virtqueue_get_buf(vq, &unused))
> > >> + ;
> > >> +
> > >> + /*
> > >> + * Since this is an optimization feature, losing a couple of free
> > >> + * pages to report isn't important.
> > >> We simply resturn
> > >
> > > return
> > >
> > >> without adding
> > >> + * the page if the vq is full. We are adding one entry each time,
> > >> + * which essentially results in no memory allocation, so the
> > >> + * GFP_KERNEL flag below can be ignored.
> > >> + */
> > >> + if (vq->num_free) {
> > >> + err = virtqueue_add_inbuf(vq, &sg, 1, vq, GFP_KERNEL);
> > >
> > > Should we kick here? At least when ring is close to
> > > being full. Kick at half way full?
> > > Otherwise it's unlikely ring will
> > > ever be cleaned until we finish the scan.
> >
> > Since this add_one_sg() is called between spin_lock_irqsave(&zone->lock, flags)
> > and spin_unlock_irqrestore(&zone->lock, flags), it is not permitted to sleep.
>
> kick takes a while sometimes but it doesn't sleep.
I don't know about virtio. But the purpose of kicking here is to wait for pending data
to be flushed in order to increase vq->num_free, isn't it? Then, doesn't waiting for
pending data to be flushed involve sleeping? If yes, we can wait for completion of kick
but we can't wait for completion of flush. Is pending data flushed without sleep?
>
> > And walk_free_mem_block() is not ready to handle resume.
> >
> > By the way, specifying GFP_KERNEL here is confusing even though it is never used.
> > walk_free_mem_block() says:
> >
> > * The callback itself must not sleep or perform any operations which would
> > * require any memory allocations directly (not even GFP_NOWAIT/GFP_ATOMIC)
> > * or via any lock dependency.
>
> Yea, GFP_ATOMIC would do just as well. But I think any allocation
> on this path would be problematic.
>
> How about a flag to make all allocations fail?
>
> E.g.
>
> #define GFP_FORBIDDEN (___GFP_DMA | ___GFP_HIGHMEM)
>
> Still this is not a blocker, we can worry about this later.
>
>
> > >
> > >> + /*
> > >> + * This is expected to never fail, because there is always an
> > >> + * entry available on the vq.
> > >> + */
> > >> + BUG_ON(err);
> > >> + }
> > >> +}
>
On Fri, Jan 19, 2018 at 06:11:31AM +0900, Tetsuo Handa wrote:
> Michael S. Tsirkin wrote:
> > On Thu, Jan 18, 2018 at 10:30:18PM +0900, Tetsuo Handa wrote:
> > > On 2018/01/18 1:44, Michael S. Tsirkin wrote:
> > > >> +static void add_one_sg(struct virtqueue *vq, unsigned long pfn, uint32_t len)
> > > >> +{
> > > >> + struct scatterlist sg;
> > > >> + unsigned int unused;
> > > >> + int err;
> > > >> +
> > > >> + sg_init_table(&sg, 1);
> > > >> + sg_set_page(&sg, pfn_to_page(pfn), len, 0);
> > > >> +
> > > >> + /* Detach all the used buffers from the vq */
> > > >> + while (virtqueue_get_buf(vq, &unused))
> > > >> + ;
> > > >> +
> > > >> + /*
> > > >> + * Since this is an optimization feature, losing a couple of free
> > > >> + * pages to report isn't important.
> > > >> We simply resturn
> > > >
> > > > return
> > > >
> > > >> without adding
> > > >> + * the page if the vq is full. We are adding one entry each time,
> > > >> + * which essentially results in no memory allocation, so the
> > > >> + * GFP_KERNEL flag below can be ignored.
> > > >> + */
> > > >> + if (vq->num_free) {
> > > >> + err = virtqueue_add_inbuf(vq, &sg, 1, vq, GFP_KERNEL);
> > > >
> > > > Should we kick here? At least when ring is close to
> > > > being full. Kick at half way full?
> > > > Otherwise it's unlikely ring will
> > > > ever be cleaned until we finish the scan.
> > >
> > > Since this add_one_sg() is called between spin_lock_irqsave(&zone->lock, flags)
> > > and spin_unlock_irqrestore(&zone->lock, flags), it is not permitted to sleep.
> >
> > kick takes a while sometimes but it doesn't sleep.
>
> I don't know about virtio. But the purpose of kicking here is to wait for pending data
> to be flushed in order to increase vq->num_free, isn't it?
It isn't. It's to wake up device out of sleep to make it start
processing the pending data. If device isn't asleep, it's a nop.
> Then, doesn't waiting for
> pending data to be flushed involve sleeping? If yes, we can wait for completion of kick
> but we can't wait for completion of flush. Is pending data flushed without sleep?
>
> >
> > > And walk_free_mem_block() is not ready to handle resume.
> > >
> > > By the way, specifying GFP_KERNEL here is confusing even though it is never used.
> > > walk_free_mem_block() says:
> > >
> > > * The callback itself must not sleep or perform any operations which would
> > > * require any memory allocations directly (not even GFP_NOWAIT/GFP_ATOMIC)
> > > * or via any lock dependency.
> >
> > Yea, GFP_ATOMIC would do just as well. But I think any allocation
> > on this path would be problematic.
> >
> > How about a flag to make all allocations fail?
> >
> > E.g.
> >
> > #define GFP_FORBIDDEN (___GFP_DMA | ___GFP_HIGHMEM)
> >
> > Still this is not a blocker, we can worry about this later.
> >
> >
> > > >
> > > >> + /*
> > > >> + * This is expected to never fail, because there is always an
> > > >> + * entry available on the vq.
> > > >> + */
> > > >> + BUG_ON(err);
> > > >> + }
> > > >> +}
> >
On Wed, Jan 17, 2018 at 01:10:12PM +0800, Wei Wang wrote:
> The guest free pages should not be discarded by the live migration thread
> when page poisoning is enabled with PAGE_POISONING_NO_SANITY=n, because
> skipping the transfer of such poisoned free pages will trigger false
> positive when new pages are allocated and checked on the destination.
> This patch adds a config field, poison_val. Guest writes to the config
> field to tell the host about the poisoning value. The value will be 0 in
> the following cases:
> 1) PAGE_POISONING_NO_SANITY is enabled;
> 2) page poisoning is disabled; or
> 3) PAGE_POISONING_ZERO is enabled.
>
> Signed-off-by: Wei Wang <[email protected]>
> Suggested-by: Michael S. Tsirkin <[email protected]>
> Cc: Michal Hocko <[email protected]>
Pls squash with the previous patch. It's not nice to break a
config, then fix it up later.
> ---
> drivers/virtio/virtio_balloon.c | 8 ++++++++
> include/uapi/linux/virtio_balloon.h | 2 ++
> 2 files changed, 10 insertions(+)
>
> diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c
> index b9561a5..5a42235 100644
> --- a/drivers/virtio/virtio_balloon.c
> +++ b/drivers/virtio/virtio_balloon.c
> @@ -706,6 +706,7 @@ static struct file_system_type balloon_fs = {
> static int virtballoon_probe(struct virtio_device *vdev)
> {
> struct virtio_balloon *vb;
> + __u32 poison_val;
> int err;
>
> if (!vdev->config->get) {
> @@ -740,6 +741,13 @@ static int virtballoon_probe(struct virtio_device *vdev)
> WQ_FREEZABLE | WQ_CPU_INTENSIVE, 0);
> INIT_WORK(&vb->report_free_page_work, report_free_page_func);
> vb->stop_cmd_id = VIRTIO_BALLOON_FREE_PAGE_REPORT_STOP_ID;
> + if (IS_ENABLED(CONFIG_PAGE_POISONING_NO_SANITY) ||
> + !page_poisoning_enabled())
> + poison_val = 0;
> + else
> + poison_val = PAGE_POISON;
> + virtio_cwrite(vb->vdev, struct virtio_balloon_config,
> + poison_val, &poison_val);
> }
>
> vb->nb.notifier_call = virtballoon_oom_notify;
> diff --git a/include/uapi/linux/virtio_balloon.h b/include/uapi/linux/virtio_balloon.h
> index 55e2456..5861876 100644
> --- a/include/uapi/linux/virtio_balloon.h
> +++ b/include/uapi/linux/virtio_balloon.h
> @@ -47,6 +47,8 @@ struct virtio_balloon_config {
> __u32 actual;
> /* Free page report command id, readonly by guest */
> __u32 free_page_report_cmd_id;
> + /* Stores PAGE_POISON if page poisoning with sanity check is in use */
> + __u32 poison_val;
> };
>
> #define VIRTIO_BALLOON_S_SWAP_IN 0 /* Amount of memory swapped in */
> --
> 2.7.4
On 01/18/2018 12:44 AM, Michael S. Tsirkin wrote:
> On Wed, Jan 17, 2018 at 01:10:11PM +0800, Wei Wang wrote:
>
>
>> +{
>> + struct scatterlist sg;
>> + unsigned int unused;
>> + int err;
>> +
>> + sg_init_one(&sg, addr, sizeof(uint32_t));
> This passes a guest-endian value to host. This is a problem:
> should always pass LE values.
I think the endianness is handled when virtqueue_add_outbuf():
desc[i].addr = cpu_to_virtio64(_vq->vdev, addr);
right?
>
>> +
>> + /*
>> + * This handles the cornercase that the vq happens to be full when
>> + * adding a cmd id. Rarely happen in practice.
>> + */
>> + while (!vq->num_free)
>> + virtqueue_get_buf(vq, &unused);
> I dislike this busy-waiting. It's a hint after all -
> why not just retry later - hopefully after getting an
> interrupt?
>
> Alternatively, stop adding more entries when we have a single
> ring entry left, making sure we have space for the command.
I think the second one looks good. Thanks.
>> + queue_work(system_freezable_wq,
>> + &vb->update_balloon_size_work);
>> + spin_unlock_irqrestore(&vb->stop_update_lock, flags);
>> + }
>> +
>> + virtio_cread(vb->vdev, struct virtio_balloon_config,
>> + free_page_report_cmd_id, &cmd_id);
> You want virtio_cread_feature, don't access the new field
> if the feature has not been negotiated.
Right. We probably need to put all the following cmd id related things
under the feature check,
How about
if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ)) {
virtio_cread(..);
if (cmd_id == VIRTIO_BALLOON_FREE_PAGE_REPORT_STOP_ID) {
....
}
>
>
>> + if (cmd_id == VIRTIO_BALLOON_FREE_PAGE_REPORT_STOP_ID) {
>> + WRITE_ONCE(vb->report_free_page, false);
>> + } else if (cmd_id != vb->start_cmd_id) {
>> + /*
>> + * Host requests to start the reporting by sending a new cmd
>> + * id.
>> + */
>> + WRITE_ONCE(vb->report_free_page, true);
> I don't know why we bother with WRITE_ONCE here. The point of
> report_free_page being used lockless is that that it's not a big deal if
> it's wrong occasionally, right?
Actually the main reason is that "vb->report_free_page" is a value
shared by two threads:
Written by the config_change here, and read by the worker thread that
reports the free pages.
Alternatively, we could let the two sides access to the shared variable
with "volatile" pointers.
>
>
>
>> + vb->start_cmd_id = cmd_id;
>> + queue_work(vb->balloon_wq, &vb->report_free_page_work);
> It seems that if a command was already queued (with a different id),
> this will result in new command id being sent to host twice, which will
> likely confuse the host.
I think that case won't happen, because
- the host sends a cmd id to the guest via the config, while the guest
acks back the received cmd id via the virtqueue;
- the guest ack back a cmd id only when a new cmd id is received from
the host, that is the above check:
if (cmd_id != vb->start_cmd_id) { --> the driver only queues the
reporting work only when a new cmd id is received
/*
* Host requests to start the reporting by
sending a
* new cmd id.
*/
WRITE_ONCE(vb->report_free_page, true);
vb->start_cmd_id = cmd_id;
queue_work(vb->balloon_wq,
&vb->report_free_page_work);
}
So the same cmd id wouldn't queue the reporting work twice.
>
>
>
>> + }
>> +}
>> +
>> static void update_balloon_size(struct virtio_balloon *vb)
>> {
>> u32 actual = vb->num_pages;
>> @@ -417,40 +513,113 @@ static void update_balloon_size_func(struct work_struct *work)
>>
>> static int init_vqs(struct virtio_balloon *vb)
>> {
>> - struct virtqueue *vqs[3];
>> - vq_callback_t *callbacks[] = { balloon_ack, balloon_ack, stats_request };
>> - static const char * const names[] = { "inflate", "deflate", "stats" };
>> - int err, nvqs;
>> + struct virtqueue **vqs;
>> + vq_callback_t **callbacks;
>> + const char **names;
>> + struct scatterlist sg;
>> + int i, nvqs, err = -ENOMEM;
>> +
>> + /* Inflateq and deflateq are used unconditionally */
>> + nvqs = 2;
>> + if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ))
>> + nvqs++;
>> + if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ))
>> + nvqs++;
>> +
>> + /* Allocate space for find_vqs parameters */
>> + vqs = kcalloc(nvqs, sizeof(*vqs), GFP_KERNEL);
>> + if (!vqs)
>> + goto err_vq;
>> + callbacks = kmalloc_array(nvqs, sizeof(*callbacks), GFP_KERNEL);
>> + if (!callbacks)
>> + goto err_callback;
>> + names = kmalloc_array(nvqs, sizeof(*names), GFP_KERNEL);
>> + if (!names)
>> + goto err_names;
> Why not just keep these 3 arrays on stack? they aren't large.
Sounds good. Here is the new implementation:
static int init_vqs(struct virtio_balloon *vb)
{
struct virtqueue *vqs[4];
vq_callback_t *callbacks[4];
const char *names[4];
struct scatterlist sg;
int ret;
/*
* Inflateq and deflateq are used unconditionally. stats_vq and
* free_page_vq uses names[2] and names[3], respectively. The
names[]
* will be NULL if the related feature is not enabled, which will
* cause no allocation for the corresponding virtqueue in find_vqs.
*/
callbacks[0] = balloon_ack;
names[0] = "inflate";
callbacks[1] = balloon_ack;
names[1] = "deflate";
names[2] = NULL;
names[3] = NULL;
if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ)) {
names[2] = "stats";
callbacks[2] = stats_request;
}
if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ)) {
names[3] = "free_page_vq";
callbacks[3] = NULL;
}
ret = vb->vdev->config->find_vqs(vb->vdev, 4, vqs, callbacks,
names,
NULL, NULL);
if (ret)
return ret;
vb->inflate_vq = vqs[0];
vb->deflate_vq = vqs[1];
if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ)) {
vb->stats_vq = vqs[2];
/*
* Prime this virtqueue with one buffer so the
hypervisor can
* use it to signal us later (it can't be broken yet!).
*/
sg_init_one(&sg, vb->stats, sizeof(vb->stats));
ret = virtqueue_add_outbuf(vb->stats_vq, &sg, 1, vb,
GFP_KERNEL);
if (ret) {
dev_warn(&vb->vdev->dev, "%s: add stat_vq
failed\n",
__func__);
return ret;
}
virtqueue_kick(vb->stats_vq);
}
if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ))
vb->free_page_vq = vqs[3];
return 0;
}
Btw, the QEMU side doesn't have an option to disable STATS_VQ currently,
we may need to add that later.
Best,
Wei
On 01/18/2018 12:44 AM, Michael S. Tsirkin wrote:
> On Wed, Jan 17, 2018 at 01:10:11PM +0800, Wei Wang wrote:
>>
>> +static void virtballoon_changed(struct virtio_device *vdev)
>> +{
>> + struct virtio_balloon *vb = vdev->priv;
>> + unsigned long flags;
>> + __u32 cmd_id;
>> + s64 diff = towards_target(vb);
>> +
>> + if (diff) {
>> + spin_lock_irqsave(&vb->stop_update_lock, flags);
>> + if (!vb->stop_update)
> Why do you ignore stop_update for freeze?
> This means new wq entries can be added during remove
> causing use after free issues.
I think stop_update isn't needed, because the lock has already been
handled internally by the APIs. Similar examples like
mem_cgroup_css_free() in "mm/memcontrol.c", there is no such locks used
for cancel_work_sync(&memcg->high_work).
Best,
Wei
On Fri, Jan 19, 2018 at 11:44:21AM +0800, Wei Wang wrote:
> On 01/18/2018 12:44 AM, Michael S. Tsirkin wrote:
> > On Wed, Jan 17, 2018 at 01:10:11PM +0800, Wei Wang wrote:
> >
>
> >
> > > +{
> > > + struct scatterlist sg;
> > > + unsigned int unused;
> > > + int err;
> > > +
> > > + sg_init_one(&sg, addr, sizeof(uint32_t));
> > This passes a guest-endian value to host. This is a problem:
> > should always pass LE values.
>
> I think the endianness is handled when virtqueue_add_outbuf():
>
> desc[i].addr = cpu_to_virtio64(_vq->vdev, addr);
>
> right?
No - that handles the address, not the value you pass in.
> >
> > > +
> > > + /*
> > > + * This handles the cornercase that the vq happens to be full when
> > > + * adding a cmd id. Rarely happen in practice.
> > > + */
> > > + while (!vq->num_free)
> > > + virtqueue_get_buf(vq, &unused);
> > I dislike this busy-waiting. It's a hint after all -
> > why not just retry later - hopefully after getting an
> > interrupt?
> >
> > Alternatively, stop adding more entries when we have a single
> > ring entry left, making sure we have space for the command.
>
> I think the second one looks good. Thanks.
>
> > > + queue_work(system_freezable_wq,
> > > + &vb->update_balloon_size_work);
> > > + spin_unlock_irqrestore(&vb->stop_update_lock, flags);
> > > + }
> > > +
> > > + virtio_cread(vb->vdev, struct virtio_balloon_config,
> > > + free_page_report_cmd_id, &cmd_id);
> > You want virtio_cread_feature, don't access the new field
> > if the feature has not been negotiated.
>
> Right. We probably need to put all the following cmd id related things under
> the feature check,
>
> How about
>
> if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ)) {
> virtio_cread(..);
> if (cmd_id == VIRTIO_BALLOON_FREE_PAGE_REPORT_STOP_ID) {
> ....
> }
>
that's ok too.
> >
> >
> > > + if (cmd_id == VIRTIO_BALLOON_FREE_PAGE_REPORT_STOP_ID) {
> > > + WRITE_ONCE(vb->report_free_page, false);
> > > + } else if (cmd_id != vb->start_cmd_id) {
> > > + /*
> > > + * Host requests to start the reporting by sending a new cmd
> > > + * id.
> > > + */
> > > + WRITE_ONCE(vb->report_free_page, true);
> > I don't know why we bother with WRITE_ONCE here. The point of
> > report_free_page being used lockless is that that it's not a big deal if
> > it's wrong occasionally, right?
>
> Actually the main reason is that "vb->report_free_page" is a value shared by
> two threads:
> Written by the config_change here, and read by the worker thread that
> reports the free pages.
Right but what's wrong if it's read or written twice and not once?
> Alternatively, we could let the two sides access to the shared variable with
> "volatile" pointers.
>
>
> >
> >
> >
> > > + vb->start_cmd_id = cmd_id;
> > > + queue_work(vb->balloon_wq, &vb->report_free_page_work);
> > It seems that if a command was already queued (with a different id),
> > this will result in new command id being sent to host twice, which will
> > likely confuse the host.
>
> I think that case won't happen, because
> - the host sends a cmd id to the guest via the config, while the guest acks
> back the received cmd id via the virtqueue;
> - the guest ack back a cmd id only when a new cmd id is received from the
> host, that is the above check:
>
> if (cmd_id != vb->start_cmd_id) { --> the driver only queues the
> reporting work only when a new cmd id is received
> /*
> * Host requests to start the reporting by sending a
> * new cmd id.
> */
> WRITE_ONCE(vb->report_free_page, true);
> vb->start_cmd_id = cmd_id;
> queue_work(vb->balloon_wq,
> &vb->report_free_page_work);
> }
>
> So the same cmd id wouldn't queue the reporting work twice.
>
Like this:
vb->start_cmd_id = cmd_id;
queue_work(vb->balloon_wq, &vb->report_free_page_work);
command id changes
vb->start_cmd_id = cmd_id;
work executes
queue_work(vb->balloon_wq, &vb->report_free_page_work);
work executes again
> >
> >
> >
> > > + }
> > > +}
> > > +
> > > static void update_balloon_size(struct virtio_balloon *vb)
> > > {
> > > u32 actual = vb->num_pages;
> > > @@ -417,40 +513,113 @@ static void update_balloon_size_func(struct work_struct *work)
> > > static int init_vqs(struct virtio_balloon *vb)
> > > {
> > > - struct virtqueue *vqs[3];
> > > - vq_callback_t *callbacks[] = { balloon_ack, balloon_ack, stats_request };
> > > - static const char * const names[] = { "inflate", "deflate", "stats" };
> > > - int err, nvqs;
> > > + struct virtqueue **vqs;
> > > + vq_callback_t **callbacks;
> > > + const char **names;
> > > + struct scatterlist sg;
> > > + int i, nvqs, err = -ENOMEM;
> > > +
> > > + /* Inflateq and deflateq are used unconditionally */
> > > + nvqs = 2;
> > > + if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ))
> > > + nvqs++;
> > > + if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ))
> > > + nvqs++;
> > > +
> > > + /* Allocate space for find_vqs parameters */
> > > + vqs = kcalloc(nvqs, sizeof(*vqs), GFP_KERNEL);
> > > + if (!vqs)
> > > + goto err_vq;
> > > + callbacks = kmalloc_array(nvqs, sizeof(*callbacks), GFP_KERNEL);
> > > + if (!callbacks)
> > > + goto err_callback;
> > > + names = kmalloc_array(nvqs, sizeof(*names), GFP_KERNEL);
> > > + if (!names)
> > > + goto err_names;
> > Why not just keep these 3 arrays on stack? they aren't large.
>
> Sounds good. Here is the new implementation:
>
> static int init_vqs(struct virtio_balloon *vb)
> {
> struct virtqueue *vqs[4];
> vq_callback_t *callbacks[4];
> const char *names[4];
> struct scatterlist sg;
> int ret;
>
>
> /*
> * Inflateq and deflateq are used unconditionally. stats_vq and
> * free_page_vq uses names[2] and names[3], respectively. The
> names[]
> * will be NULL if the related feature is not enabled, which will
> * cause no allocation for the corresponding virtqueue in find_vqs.
> */
> callbacks[0] = balloon_ack;
> names[0] = "inflate";
> callbacks[1] = balloon_ack;
> names[1] = "deflate";
> names[2] = NULL;
> names[3] = NULL;
>
> if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ)) {
> names[2] = "stats";
> callbacks[2] = stats_request;
> }
> if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ)) {
> names[3] = "free_page_vq";
> callbacks[3] = NULL;
> }
>
> ret = vb->vdev->config->find_vqs(vb->vdev, 4, vqs, callbacks, names,
> NULL, NULL);
> if (ret)
> return ret;
>
> vb->inflate_vq = vqs[0];
> vb->deflate_vq = vqs[1];
>
> if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ)) {
> vb->stats_vq = vqs[2];
> /*
> * Prime this virtqueue with one buffer so the hypervisor
> can
> * use it to signal us later (it can't be broken yet!).
> */
> sg_init_one(&sg, vb->stats, sizeof(vb->stats));
> ret = virtqueue_add_outbuf(vb->stats_vq, &sg, 1, vb,
> GFP_KERNEL);
> if (ret) {
> dev_warn(&vb->vdev->dev, "%s: add stat_vq failed\n",
> __func__);
> return ret;
> }
> virtqueue_kick(vb->stats_vq);
> }
>
> if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_VQ))
> vb->free_page_vq = vqs[3];
>
> return 0;
> }
>
>
> Btw, the QEMU side doesn't have an option to disable STATS_VQ currently, we
> may need to add that later.
>
> Best,
> Wei
why not
Michael S. Tsirkin wrote:
> > > > >> + * the page if the vq is full. We are adding one entry each time,
> > > > >> + * which essentially results in no memory allocation, so the
> > > > >> + * GFP_KERNEL flag below can be ignored.
> > > > >> + */
> > > > >> + if (vq->num_free) {
> > > > >> + err = virtqueue_add_inbuf(vq, &sg, 1, vq, GFP_KERNEL);
> > > > >
> > > > > Should we kick here? At least when ring is close to
> > > > > being full. Kick at half way full?
> > > > > Otherwise it's unlikely ring will
> > > > > ever be cleaned until we finish the scan.
> > > >
> > > > Since this add_one_sg() is called between spin_lock_irqsave(&zone->lock, flags)
> > > > and spin_unlock_irqrestore(&zone->lock, flags), it is not permitted to sleep.
> > >
> > > kick takes a while sometimes but it doesn't sleep.
> >
> > I don't know about virtio. But the purpose of kicking here is to wait for pending data
> > to be flushed in order to increase vq->num_free, isn't it?
>
> It isn't. It's to wake up device out of sleep to make it start
> processing the pending data. If device isn't asleep, it's a nop.
We need to wait until vq->num_free > 0 if vq->num_free == 0 if we want to allow
virtqueue_add_inbuf() to succeed. When will vq->num_free++ be called?
You said virtqueue_kick() is a no-op if the device is not asleep.
Then, there will be no guarantee that we can make vq->num_free > 0
by calling virtqueue_kick(). Are you saying that
virtqueue_kick(vq);
while (!vq->num_free)
virtqueue_get_buf(vq, &unused);
err = virtqueue_add_inbuf(vq, &sg, 1, vq, GFP_KERNEL);
BUG_ON(err);
sequence from IRQ disabled atomic context is safe? If no, what is
the point with calling virtqueue_kick() when ring is close to being
(half way) full? We can't guarantee that all data is sent to QEMU after all.
Also, why does the cmd id matter? If VIRTIO_BALLOON_F_FREE_PAGE_VQ does not
guarantee the atomicity, I don't see the point of communicating the cmd id
between the QEMU and the guest kernel. Just an EOF marker should be enough.
I do want to see changes for the QEMU side in order to review changes for
the guest kernel side.
On 01/19/2018 08:39 PM, Michael S. Tsirkin wrote:
> On Fri, Jan 19, 2018 at 11:44:21AM +0800, Wei Wang wrote:
>> On 01/18/2018 12:44 AM, Michael S. Tsirkin wrote:
>>> On Wed, Jan 17, 2018 at 01:10:11PM +0800, Wei Wang wrote:
>>>
>>>> + vb->start_cmd_id = cmd_id;
>>>> + queue_work(vb->balloon_wq, &vb->report_free_page_work);
>>> It seems that if a command was already queued (with a different id),
>>> this will result in new command id being sent to host twice, which will
>>> likely confuse the host.
>> I think that case won't happen, because
>> - the host sends a cmd id to the guest via the config, while the guest acks
>> back the received cmd id via the virtqueue;
>> - the guest ack back a cmd id only when a new cmd id is received from the
>> host, that is the above check:
>>
>> if (cmd_id != vb->start_cmd_id) { --> the driver only queues the
>> reporting work only when a new cmd id is received
>> /*
>> * Host requests to start the reporting by sending a
>> * new cmd id.
>> */
>> WRITE_ONCE(vb->report_free_page, true);
>> vb->start_cmd_id = cmd_id;
>> queue_work(vb->balloon_wq,
>> &vb->report_free_page_work);
>> }
>>
>> So the same cmd id wouldn't queue the reporting work twice.
>>
> Like this:
>
> vb->start_cmd_id = cmd_id;
> queue_work(vb->balloon_wq, &vb->report_free_page_work);
>
> command id changes
>
> vb->start_cmd_id = cmd_id;
>
> work executes
>
> queue_work(vb->balloon_wq, &vb->report_free_page_work);
>
> work executes again
>
If we think about the whole working flow, I think this case couldn't happen:
1) device send cmd_id=1 to driver;
2) driver receives cmd_id=1 in the config and acks cmd_id=1 to the
device via the vq;
3) device revives cmd_id=1;
4) device wants to stop the reporting by sending cmd_id=STOP;
5) driver receives cmd_id=STOP from the config, and acks cmd_id=STOP to
the device via the vq;
6) device sends cmd_id=2 to driver;
...
cmd_id=2 won't come after cmd_id=1, there will be a STOP cmd in between
them (STOP won't queue the work).
How about defining the correct device behavior in the spec:
The device Should NOT send a second cmd id to the driver until a STOP
cmd ack for the previous cmd id has been received from the guest.
Best,
Wei
On 01/22/2018 07:25 PM, Wei Wang wrote:
> On 01/19/2018 08:39 PM, Michael S. Tsirkin wrote:
>> On Fri, Jan 19, 2018 at 11:44:21AM +0800, Wei Wang wrote:
>>> On 01/18/2018 12:44 AM, Michael S. Tsirkin wrote:
>>>> On Wed, Jan 17, 2018 at 01:10:11PM +0800, Wei Wang wrote:
>>>>
>>>>> + vb->start_cmd_id = cmd_id;
>>>>> + queue_work(vb->balloon_wq, &vb->report_free_page_work);
>>>> It seems that if a command was already queued (with a different id),
>>>> this will result in new command id being sent to host twice, which
>>>> will
>>>> likely confuse the host.
>>> I think that case won't happen, because
>>> - the host sends a cmd id to the guest via the config, while the
>>> guest acks
>>> back the received cmd id via the virtqueue;
>>> - the guest ack back a cmd id only when a new cmd id is received
>>> from the
>>> host, that is the above check:
>>>
>>> if (cmd_id != vb->start_cmd_id) { --> the driver only queues the
>>> reporting work only when a new cmd id is received
>>> /*
>>> * Host requests to start the reporting by
>>> sending a
>>> * new cmd id.
>>> */
>>> WRITE_ONCE(vb->report_free_page, true);
>>> vb->start_cmd_id = cmd_id;
>>> queue_work(vb->balloon_wq,
>>> &vb->report_free_page_work);
>>> }
>>>
>>> So the same cmd id wouldn't queue the reporting work twice.
>>>
>> Like this:
>>
>> vb->start_cmd_id = cmd_id;
>> queue_work(vb->balloon_wq, &vb->report_free_page_work);
>>
>> command id changes
>>
>> vb->start_cmd_id = cmd_id;
>>
>> work executes
>>
>> queue_work(vb->balloon_wq, &vb->report_free_page_work);
>>
>> work executes again
>>
>
> If we think about the whole working flow, I think this case couldn't
> happen:
>
> 1) device send cmd_id=1 to driver;
> 2) driver receives cmd_id=1 in the config and acks cmd_id=1 to the
> device via the vq;
> 3) device revives cmd_id=1;
> 4) device wants to stop the reporting by sending cmd_id=STOP;
> 5) driver receives cmd_id=STOP from the config, and acks cmd_id=STOP
> to the device via the vq;
> 6) device sends cmd_id=2 to driver;
> ...
>
> cmd_id=2 won't come after cmd_id=1, there will be a STOP cmd in
> between them (STOP won't queue the work).
>
> How about defining the correct device behavior in the spec:
> The device Should NOT send a second cmd id to the driver until a STOP
> cmd ack for the previous cmd id has been received from the guest.
Thanks for the comments, and I adopted most of them in the new posted
v23 patches. The above discussion is the one that I haven't included. If
you could still see issues in the above analysis, please let me know.
Thanks.
Best,
Wei
On Mon, Jan 22, 2018 at 07:25:45PM +0800, Wei Wang wrote:
> On 01/19/2018 08:39 PM, Michael S. Tsirkin wrote:
> > On Fri, Jan 19, 2018 at 11:44:21AM +0800, Wei Wang wrote:
> > > On 01/18/2018 12:44 AM, Michael S. Tsirkin wrote:
> > > > On Wed, Jan 17, 2018 at 01:10:11PM +0800, Wei Wang wrote:
> > > >
> > > > > + vb->start_cmd_id = cmd_id;
> > > > > + queue_work(vb->balloon_wq, &vb->report_free_page_work);
> > > > It seems that if a command was already queued (with a different id),
> > > > this will result in new command id being sent to host twice, which will
> > > > likely confuse the host.
> > > I think that case won't happen, because
> > > - the host sends a cmd id to the guest via the config, while the guest acks
> > > back the received cmd id via the virtqueue;
> > > - the guest ack back a cmd id only when a new cmd id is received from the
> > > host, that is the above check:
> > >
> > > if (cmd_id != vb->start_cmd_id) { --> the driver only queues the
> > > reporting work only when a new cmd id is received
> > > /*
> > > * Host requests to start the reporting by sending a
> > > * new cmd id.
> > > */
> > > WRITE_ONCE(vb->report_free_page, true);
> > > vb->start_cmd_id = cmd_id;
> > > queue_work(vb->balloon_wq,
> > > &vb->report_free_page_work);
> > > }
> > >
> > > So the same cmd id wouldn't queue the reporting work twice.
> > >
> > Like this:
> >
> > vb->start_cmd_id = cmd_id;
> > queue_work(vb->balloon_wq, &vb->report_free_page_work);
> >
> > command id changes
> >
> > vb->start_cmd_id = cmd_id;
> >
> > work executes
> >
> > queue_work(vb->balloon_wq, &vb->report_free_page_work);
> >
> > work executes again
> >
>
> If we think about the whole working flow, I think this case couldn't happen:
>
> 1) device send cmd_id=1 to driver;
> 2) driver receives cmd_id=1 in the config and acks cmd_id=1 to the device
> via the vq;
> 3) device revives cmd_id=1;
> 4) device wants to stop the reporting by sending cmd_id=STOP;
> 5) driver receives cmd_id=STOP from the config, and acks cmd_id=STOP to the
> device via the vq;
> 6) device sends cmd_id=2 to driver;
> ...
>
> cmd_id=2 won't come after cmd_id=1, there will be a STOP cmd in between them
> (STOP won't queue the work).
>
> How about defining the correct device behavior in the spec:
> The device Should NOT send a second cmd id to the driver until a STOP cmd
> ack for the previous cmd id has been received from the guest.
>
>
> Best,
> Wei
I think we should just fix races in the driver rather than introduce
random restrictions in the device.
If device wants to start a new sequence, it should be able to
do just that without a complicated back and forth with several
roundtrips through the driver.
--
MST
On Wed, Jan 24, 2018 at 11:18:40AM +0800, Wei Wang wrote:
> On 01/22/2018 07:25 PM, Wei Wang wrote:
> > On 01/19/2018 08:39 PM, Michael S. Tsirkin wrote:
> > > On Fri, Jan 19, 2018 at 11:44:21AM +0800, Wei Wang wrote:
> > > > On 01/18/2018 12:44 AM, Michael S. Tsirkin wrote:
> > > > > On Wed, Jan 17, 2018 at 01:10:11PM +0800, Wei Wang wrote:
> > > > >
> > > > > > + vb->start_cmd_id = cmd_id;
> > > > > > + queue_work(vb->balloon_wq, &vb->report_free_page_work);
> > > > > It seems that if a command was already queued (with a different id),
> > > > > this will result in new command id being sent to host twice,
> > > > > which will
> > > > > likely confuse the host.
> > > > I think that case won't happen, because
> > > > - the host sends a cmd id to the guest via the config, while the
> > > > guest acks
> > > > back the received cmd id via the virtqueue;
> > > > - the guest ack back a cmd id only when a new cmd id is received
> > > > from the
> > > > host, that is the above check:
> > > >
> > > > if (cmd_id != vb->start_cmd_id) { --> the driver only queues the
> > > > reporting work only when a new cmd id is received
> > > > /*
> > > > * Host requests to start the reporting
> > > > by sending a
> > > > * new cmd id.
> > > > */
> > > > WRITE_ONCE(vb->report_free_page, true);
> > > > vb->start_cmd_id = cmd_id;
> > > > queue_work(vb->balloon_wq,
> > > > &vb->report_free_page_work);
> > > > }
> > > >
> > > > So the same cmd id wouldn't queue the reporting work twice.
> > > >
> > > Like this:
> > >
> > > vb->start_cmd_id = cmd_id;
> > > queue_work(vb->balloon_wq, &vb->report_free_page_work);
> > >
> > > command id changes
> > >
> > > vb->start_cmd_id = cmd_id;
> > >
> > > work executes
> > >
> > > queue_work(vb->balloon_wq, &vb->report_free_page_work);
> > >
> > > work executes again
> > >
> >
> > If we think about the whole working flow, I think this case couldn't
> > happen:
> >
> > 1) device send cmd_id=1 to driver;
> > 2) driver receives cmd_id=1 in the config and acks cmd_id=1 to the
> > device via the vq;
> > 3) device revives cmd_id=1;
> > 4) device wants to stop the reporting by sending cmd_id=STOP;
> > 5) driver receives cmd_id=STOP from the config, and acks cmd_id=STOP to
> > the device via the vq;
> > 6) device sends cmd_id=2 to driver;
> > ...
> >
> > cmd_id=2 won't come after cmd_id=1, there will be a STOP cmd in between
> > them (STOP won't queue the work).
> >
> > How about defining the correct device behavior in the spec:
> > The device Should NOT send a second cmd id to the driver until a STOP
> > cmd ack for the previous cmd id has been received from the guest.
>
>
> Thanks for the comments, and I adopted most of them in the new posted v23
> patches. The above discussion is the one that I haven't included. If you
> could still see issues in the above analysis, please let me know. Thanks.
>
> Best,
> Wei
>
>
>
Yes, I think you should just fix the race in the driver.
--
MST
On 01/24/2018 12:29 PM, Michael S. Tsirkin wrote:
> On Mon, Jan 22, 2018 at 07:25:45PM +0800, Wei Wang wrote:
>> On 01/19/2018 08:39 PM, Michael S. Tsirkin wrote:
>>> On Fri, Jan 19, 2018 at 11:44:21AM +0800, Wei Wang wrote:
>>>> On 01/18/2018 12:44 AM, Michael S. Tsirkin wrote:
>>>>> On Wed, Jan 17, 2018 at 01:10:11PM +0800, Wei Wang wrote:
>>>>>
>>>>>> + vb->start_cmd_id = cmd_id;
>>>>>> + queue_work(vb->balloon_wq, &vb->report_free_page_work);
>>>>> It seems that if a command was already queued (with a different id),
>>>>> this will result in new command id being sent to host twice, which will
>>>>> likely confuse the host.
>>>> I think that case won't happen, because
>>>> - the host sends a cmd id to the guest via the config, while the guest acks
>>>> back the received cmd id via the virtqueue;
>>>> - the guest ack back a cmd id only when a new cmd id is received from the
>>>> host, that is the above check:
>>>>
>>>> if (cmd_id != vb->start_cmd_id) { --> the driver only queues the
>>>> reporting work only when a new cmd id is received
>>>> /*
>>>> * Host requests to start the reporting by sending a
>>>> * new cmd id.
>>>> */
>>>> WRITE_ONCE(vb->report_free_page, true);
>>>> vb->start_cmd_id = cmd_id;
>>>> queue_work(vb->balloon_wq,
>>>> &vb->report_free_page_work);
>>>> }
>>>>
>>>> So the same cmd id wouldn't queue the reporting work twice.
>>>>
>>> Like this:
>>>
>>> vb->start_cmd_id = cmd_id;
>>> queue_work(vb->balloon_wq, &vb->report_free_page_work);
>>>
>>> command id changes
>>>
>>> vb->start_cmd_id = cmd_id;
>>>
>>> work executes
>>>
>>> queue_work(vb->balloon_wq, &vb->report_free_page_work);
>>>
>>> work executes again
>>>
>> If we think about the whole working flow, I think this case couldn't happen:
>>
>> 1) device send cmd_id=1 to driver;
>> 2) driver receives cmd_id=1 in the config and acks cmd_id=1 to the device
>> via the vq;
>> 3) device revives cmd_id=1;
>> 4) device wants to stop the reporting by sending cmd_id=STOP;
>> 5) driver receives cmd_id=STOP from the config, and acks cmd_id=STOP to the
>> device via the vq;
>> 6) device sends cmd_id=2 to driver;
>> ...
>>
>> cmd_id=2 won't come after cmd_id=1, there will be a STOP cmd in between them
>> (STOP won't queue the work).
>>
>> How about defining the correct device behavior in the spec:
>> The device Should NOT send a second cmd id to the driver until a STOP cmd
>> ack for the previous cmd id has been received from the guest.
>>
>>
>> Best,
>> Wei
> I think we should just fix races in the driver rather than introduce
> random restrictions in the device.
>
> If device wants to start a new sequence, it should be able to
> do just that without a complicated back and forth with several
> roundtrips through the driver.
>
OK, I've fixed it in the new version, v24. Please have a check there.
Thanks.
(Other changes based on the comments on v23 have also been included)
Best,
Wei