gmane.comp.emulators.qemu

Android Goldfish on QEMU

Ira Ray Jenkins — 2012-05-25T22:13:25

I found a GSOC11 project that attempted to port the Android "Goldfish"
platform to mainline QEMU. Was this project successful, or is this
currently being worked on?

[PATCH 11/14] g364fb: g364fb_screen_dump(): add errorhandling

Luiz Capitulino — 2012-05-25T19:41:16

This is done by using qemu_fopen_err(), qemu_fputc_err() and handling
errors appropriately (eg. removing the screendump file if the operation
fails).

Note that the error is not passed up yet, as vga_hw_screen_dump() still
calls consoles[0]->hw_screen_dump() with errp=NULL.

The error will be propagated up when screendump is converted to the QAPI.
That will be done by a later commit.

Signed-off-by: Luiz Capitulino <lcapitulino< at >redhat.com>
---
 hw/g364fb.c | 48 ++++++++++++++++++++++++++++++++++++------------
 1 file changed, 36 insertions(+), 12 deletions(-)

diff --git a/hw/g364fb.c b/hw/g364fb.c
index 498154b..a18a414 100644
--- a/hw/g364fb.c
+++ b/hw/g364fb.c
< at >< at > -301,35 +301,59 < at >< at > static void g364fb_screen_dump(void *opaque, const char *filename, bool cswitch,
     qemu_flush_coalesced_mmio_buffer();
 
     if (s->depth != 8) {
-        error_report("g364: unknown guest depth %d", s->depth);
+        error_set(errp, QERR_INVALID_PARAMETER_VALUE, "depth", "8");
         return;
     }
 
-    f = fopen(fil

[PATCH 05/14] cutils: introduce qemu_fputc_err()

Luiz Capitulino — 2012-05-25T19:41:10

A fputc() wrapper that takes an Error argument.

Signed-off-by: Luiz Capitulino <lcapitulino< at >redhat.com>
---
 cutils.c      | 12 ++++++++++++
 qemu-common.h |  1 +
 2 files changed, 13 insertions(+)

diff --git a/cutils.c b/cutils.c
index f5b02b4..83edb43 100644
--- a/cutils.c
+++ b/cutils.c
< at >< at > -622,3 +622,15 < at >< at > int qemu_fprintf_err(Error **errp, FILE *stream, const char *format, ...)
 
     return ret;
 }
+
+int qemu_fputc_err(int c, FILE *stream, Error **errp)
+{
+    int ret;
+
+    ret = fputc(c, stream);
+    if (ret == EOF) {
+        set_write_err(errp, errno);
+    }
+
+    return ret;
+}
diff --git a/qemu-common.h b/qemu-common.h
index 58c5197..895bc2b 100644
--- a/qemu-common.h
+++ b/qemu-common.h
< at >< at > -211,6 +211,7 < at >< at > int qemu_sendv(int sockfd, struct iovec *iov, int len, int iov_offset);
 
 FILE *qemu_fopen_err(const char *path, const char *mode, Error **errp);
 int qemu_fprintf_err(Error **errp, FILE *stream, const char *format, ...);
+int qemu_fputc_err(int c, FILE *stream, Error **errp);
 
 /* E

[PATCH 08/14] console: vga_hw_screen_dump_ptr: take anError argument

Luiz Capitulino — 2012-05-25T19:41:13

The new argument is not used in this commit. Error handling will
be added to each device individually in later commits.

All devices that register a screen dump callback via
graphic_console_init() are updated.

This work is required by the future conversion of the screendump
command to the QAPI.

Signed-off-by: Luiz Capitulino <lcapitulino< at >redhat.com>
---
 console.c       |  2 +-
 console.h       |  4 +++-
 hw/blizzard.c   |  2 +-
 hw/g364fb.c     |  3 ++-
 hw/omap_lcdc.c  |  3 ++-
 hw/qxl.c        |  5 +++--
 hw/tcx.c        | 12 ++++++++----
 hw/vga.c        |  6 ++++--
 hw/vmware_vga.c |  5 +++--
 9 files changed, 27 insertions(+), 15 deletions(-)

diff --git a/console.c b/console.c
index 6a463f5..4669e62 100644
--- a/console.c
+++ b/console.c
< at >< at > -187,7 +187,7 < at >< at > void vga_hw_screen_dump(const char *filename)
         console_select(0);
     }
     if (consoles[0] && consoles[0]->hw_screen_dump) {
-        consoles[0]->hw_screen_dump(consoles[0]->hw, filename, cswitch);
+        consoles[0]->hw_screen_dump

[PATCH 14/14] qapi: convert screendump

Luiz Capitulino — 2012-05-25T19:41:19

Also activates error reporting from devices.

Signed-off-by: Luiz Capitulino <lcapitulino< at >redhat.com>
---
 console.c        |  7 ++++---
 console.h        |  1 -
 hmp-commands.hx  |  5 ++---
 hmp.c            |  9 +++++++++
 hmp.h            |  1 +
 monitor.c        |  6 ------
 qapi-schema.json | 24 ++++++++++++++++++++++++
 qmp-commands.hx  |  5 +----
 8 files changed, 41 insertions(+), 17 deletions(-)

diff --git a/console.c b/console.c
index 4669e62..2bbf104 100644
--- a/console.c
+++ b/console.c
< at >< at > -24,6 +24,7 < at >< at >
 #include "qemu-common.h"
 #include "console.h"
 #include "qemu-timer.h"
+#include "qmp-commands.h"
 
 //#define DEBUG_CONSOLE
 #define DEFAULT_BACKSCROLL 512
< at >< at > -173,7 +174,7 < at >< at > void vga_hw_invalidate(void)
         active_console->hw_invalidate(active_console->hw);
 }
 
-void vga_hw_screen_dump(const char *filename)
+void qmp_screendump(const char *filename, Error **errp)
 {
     TextConsole *previous_active_console;
     bool cswitch;
< at >< at > -187,9 +188,9 < at >< at > void vga_hw_screen_dump(const char *f

[PATCH 10/14] omap_lcdc: omap_ppm_save(): add errorhandling

Luiz Capitulino — 2012-05-25T19:41:15

This is done by using qemu_fopen_err(), qemu_fputc_err() and handling
errors appropriately (eg. removing the screendump file if the operation
fails).

Note that the error is not passed up yet, as vga_hw_screen_dump() still
calls consoles[0]->hw_screen_dump() with errp=NULL.

The error will be propagated up when screendump is converted to the QAPI.
That will be done by a later commit.

Signed-off-by: Luiz Capitulino <lcapitulino< at >redhat.com>
---
 hw/omap_lcdc.c | 53 +++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 39 insertions(+), 14 deletions(-)

diff --git a/hw/omap_lcdc.c b/hw/omap_lcdc.c
index 3d6328f..cf5a264 100644
--- a/hw/omap_lcdc.c
+++ b/hw/omap_lcdc.c
< at >< at > -224,18 +224,22 < at >< at > static void omap_update_display(void *opaque)
     omap_lcd->invalidate = 0;
 }
 
-static int omap_ppm_save(const char *filename, uint8_t *data,
-                    int w, int h, int linesize)
+static void omap_ppm_save(const char *filename, uint8_t *data,
+                    int w, int h, int linesize, Er

Re: [PATCH v2 1/1] virtio-rng: hardware random number generator device

Amit Shah — 2012-05-25T20:20:18

How?  With the chardev, it can only keep feeding data, and that data
will be consumed when chr_can_read() returns > 0.  And even then the
mgmt app has no idea how much data was asked for, and how much was
consumed.

Amit

[PATCH 04/14] cutils: introduce qemu_fprintf_err()

Luiz Capitulino — 2012-05-25T19:41:09

A fprintf() wrapper that takes an Error argument.

Signed-off-by: Luiz Capitulino <lcapitulino< at >redhat.com>
---
 cutils.c      | 31 +++++++++++++++++++++++++++++++
 qemu-common.h |  1 +
 2 files changed, 32 insertions(+)

diff --git a/cutils.c b/cutils.c
index bdee130..f5b02b4 100644
--- a/cutils.c
+++ b/cutils.c
< at >< at > -591,3 +591,34 < at >< at > FILE *qemu_fopen_err(const char *path, const char *mode, Error **errp)
 
     return fp;
 }
+
+static void set_write_err(Error **errp, int err_nr)
+{
+    switch (err_nr) {
+    case ENOSPC:
+        error_set(errp, QERR_NO_SPACE);
+        return;
+    case EFBIG:
+        error_set(errp, QERR_FILE_TOO_BIG);
+        return;
+    default:
+        error_set(errp, QERR_IO_ERROR);
+        return;
+    }
+}
+
+int qemu_fprintf_err(Error **errp, FILE *stream, const char *format, ...)
+{
+    va_list ap;
+    int ret;
+
+    va_start(ap, format);
+    ret = vfprintf(stream, format, ap);
+    va_end(ap);
+
+    if (ret < 0) {
+        set_write_err(errp, errno);
+    }
+
+    return

[PATCH 09/14] vga: ppm_save(): add error handling

Luiz Capitulino — 2012-05-25T19:41:14

This is done by using qemu_fopen_err(), qemu_fwrite_err() and handling
errors appropriately (eg. removing the screendump file if the operation
fails).

Adding error handling to ppm_save() has the net effect of automatically
adding error handling for all devices using ppm_save(), but note that
the error is not passed up yet, as vga_hw_screen_dump() still calls
consoles[0]->hw_screen_dump() with errp=NULL.

The error will be propagated up when screendump is converted to the QAPI.
That will be done by a later commit.

Signed-off-by: Luiz Capitulino <lcapitulino< at >redhat.com>
---
 hw/blizzard.c   |  2 +-
 hw/qxl.c        |  2 +-
 hw/vga.c        | 32 +++++++++++++++++++++-----------
 hw/vga_int.h    |  3 ++-
 hw/vmware_vga.c |  2 +-
 5 files changed, 26 insertions(+), 15 deletions(-)

diff --git a/hw/blizzard.c b/hw/blizzard.c
index a2b9053..d1c9d81 100644
--- a/hw/blizzard.c
+++ b/hw/blizzard.c
< at >< at > -939,7 +939,7 < at >< at > static void blizzard_screen_dump(void *opaque, const char *filename,
 
     blizzard_update_display(

[PATCH 13/14] tcx: tcx_screen_dump(): add errorhandling

Luiz Capitulino — 2012-05-25T19:41:18

This is done by using qemu_fopen_err(), qemu_fputc_err() and handling
errors appropriately (eg. removing the screendump file if the operation
fails).

Note that the error is not passed up yet, as vga_hw_screen_dump() still
calls consoles[0]->hw_screen_dump() with errp=NULL.

The error will be propagated up when screendump is converted to the QAPI.
That will be done by a later commit.

Signed-off-by: Luiz Capitulino <lcapitulino< at >redhat.com>
---
 hw/tcx.c | 34 +++++++++++++++++++++++++++-------
 1 file changed, 27 insertions(+), 7 deletions(-)

diff --git a/hw/tcx.c b/hw/tcx.c
index 4027363..7aa1abe 100644
--- a/hw/tcx.c
+++ b/hw/tcx.c
< at >< at > -584,24 +584,44 < at >< at > static void tcx_screen_dump(void *opaque, const char *filename, bool cswitch,
     uint8_t *d, *d1, v;
     int y, x;
 
-    f = fopen(filename, "wb");
-    if (!f)
+    f = qemu_fopen_err(filename, "wb", errp);
+    if (error_is_set(errp)) {
         return;
-    fprintf(f, "P6\n%d %d\n%d\n", s->width, s->height, 255);
+    }
+    qemu_fprintf_err(errp, f,

[PATCH 03/14] cutils: introduce qemu_fopen_err()

Luiz Capitulino — 2012-05-25T19:41:08

A fopen() wrapper that takes an Error argument.

Signed-off-by: Luiz Capitulino <lcapitulino< at >redhat.com>
---
 cutils.c      | 42 ++++++++++++++++++++++++++++++++++++++++++
 qemu-common.h |  3 +++
 2 files changed, 45 insertions(+)

diff --git a/cutils.c b/cutils.c
index af308cd..bdee130 100644
--- a/cutils.c
+++ b/cutils.c
< at >< at > -26,6 +26,7 < at >< at >
 #include <math.h>
 
 #include "qemu_socket.h"
+#include "error.h"
 
 void pstrcpy(char *buf, int buf_size, const char *str)
 {
< at >< at > -549,3 +550,44 < at >< at > int qemu_sendv(int sockfd, struct iovec *iov, int len, int iov_offset)
     return do_sendv_recvv(sockfd, iov, len, iov_offset, 1);
 }
 
+static void set_open_err(Error **errp, const char *path, int err_nr)
+{
+    switch (err_nr) {
+    case EACCES:
+        error_set(errp, QERR_INVALID_ACCESS);
+        return;
+    case EMFILE:
+        error_set(errp, QERR_TOO_MANY_FILES_PROC);
+        return;
+    case ENFILE:
+        error_set(errp, QERR_TOO_MANY_FILES_SYS);
+        return;
+    case ENAMETOOLONG:
+        error_set(

Re: [PATCH v2 1/1] virtio-rng: hardware random numbergenerator device

Anthony Liguori — 2012-05-25T20:00:53

I don't understand the point of this event.  Can't a management app just create 
a socket and then it can see all the requests the guest makes?

Regards,

Anthony Liguori

[PATCH 06/14] cutils: introduce qemu_fwrite_err()

Luiz Capitulino — 2012-05-25T19:41:11

A fwrite() wrapper that takes an Error argument.

Signed-off-by: Luiz Capitulino <lcapitulino< at >redhat.com>
---
 cutils.c      | 15 +++++++++++++++
 qemu-common.h |  2 ++
 2 files changed, 17 insertions(+)

diff --git a/cutils.c b/cutils.c
index 83edb43..63fdfc0 100644
--- a/cutils.c
+++ b/cutils.c
< at >< at > -634,3 +634,18 < at >< at > int qemu_fputc_err(int c, FILE *stream, Error **errp)
 
     return ret;
 }
+
+size_t qemu_fwrite_err(const void *ptr, size_t size, size_t nmemb,
+                       FILE *stream, Error **errp)
+{
+    size_t ret;
+
+    clearerr(stream);
+    ret = fwrite(ptr, size, nmemb, stream);
+
+    if (ferror(stream)) {
+        set_write_err(errp, errno);
+    }
+
+    return ret;
+}
diff --git a/qemu-common.h b/qemu-common.h
index 895bc2b..39377ff 100644
--- a/qemu-common.h
+++ b/qemu-common.h
< at >< at > -212,6 +212,8 < at >< at > int qemu_sendv(int sockfd, struct iovec *iov, int len, int iov_offset);
 FILE *qemu_fopen_err(const char *path, const char *mode, Error **errp);
 int qemu_fprintf_err(Error **errp, FILE *s

[PATCH 12/14] tcx: tcx24_screen_dump(): add errorhandling

Luiz Capitulino — 2012-05-25T19:41:17

This is done by using qemu_fopen_err(), qemu_fputc_err() and handling
errors appropriately (eg. removing the screendump file if the operation
fails).

Note that the error is not passed up yet, as vga_hw_screen_dump() still
calls consoles[0]->hw_screen_dump() with errp=NULL.

The error will be propagated up when screendump is converted to the QAPI.
That will be done by a later commit.

Signed-off-by: Luiz Capitulino <lcapitulino< at >redhat.com>
---
 hw/tcx.c | 50 ++++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 40 insertions(+), 10 deletions(-)

diff --git a/hw/tcx.c b/hw/tcx.c
index 74a7085..4027363 100644
--- a/hw/tcx.c
+++ b/hw/tcx.c
< at >< at > -613,10 +613,14 < at >< at > static void tcx24_screen_dump(void *opaque, const char *filename, bool cswitch,
     uint32_t *s24, *cptr, dval;
     int y, x;
 
-    f = fopen(filename, "wb");
-    if (!f)
+    f = qemu_fopen_err(filename, "wb", errp);
+    if (error_is_set(errp)) {
         return;
-    fprintf(f, "P6\n%d %d\n%d\n", s->width, s->height, 255);
+    }
+

[PATCH 07/14] omap_lcdc: rename ppm_save() toomap_ppm_save()

Luiz Capitulino — 2012-05-25T19:41:12

Avoids confusion with the global ppm_save() defined in hw/vga.c.

Signed-off-by: Luiz Capitulino <lcapitulino< at >redhat.com>
---
 hw/omap_lcdc.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/hw/omap_lcdc.c b/hw/omap_lcdc.c
index 4a08e9d..6d2e83a 100644
--- a/hw/omap_lcdc.c
+++ b/hw/omap_lcdc.c
< at >< at > -224,8 +224,8 < at >< at > static void omap_update_display(void *opaque)
     omap_lcd->invalidate = 0;
 }
 
-static int ppm_save(const char *filename, uint8_t *data,
-                int w, int h, int linesize)
+static int omap_ppm_save(const char *filename, uint8_t *data,
+                    int w, int h, int linesize)
 {
     FILE *f;
     uint8_t *d, *d1;
< at >< at > -270,9 +270,9 < at >< at > static void omap_screen_dump(void *opaque, const char *filename, bool cswitch)
 
     omap_update_display(opaque);
     if (omap_lcd && ds_get_data(omap_lcd->state))
-        ppm_save(filename, ds_get_data(omap_lcd->state),
-                omap_lcd->width, omap_lcd->height,
-                ds_get_linesize(omap_lcd->sta

[PATCH 02/14] qerror: add new errors

Luiz Capitulino — 2012-05-25T19:41:07

New errors for write() and open() failures. Will be used by the
next commits.

Signed-off-by: Luiz Capitulino <lcapitulino< at >redhat.com>
---
 qerror.c | 24 ++++++++++++++++++++++++
 qerror.h | 18 ++++++++++++++++++
 2 files changed, 42 insertions(+)

diff --git a/qerror.c b/qerror.c
index 2c97382..58e4570 100644
--- a/qerror.c
+++ b/qerror.c
< at >< at > -152,6 +152,14 < at >< at > static const QErrorStringTable qerror_table[] = {
         .desc      = "The feature '%(name)' is not enabled",
     },
     {
+        .error_fmt = QERR_FILE_TOO_BIG,
+        .desc      = "File exceeds maxium file size limit",
+    },
+    {
+        .error_fmt = QERR_INVALID_ACCESS,
+        .desc      = "The access is invalid",
+    },
+    {
         .error_fmt = QERR_INVALID_BLOCK_FORMAT,
         .desc      = "Invalid block format '%(name)'",
     },
< at >< at > -209,10 +217,18 < at >< at > static const QErrorStringTable qerror_table[] = {
         .desc      = "Parameter '%(name)' is missing",
     },
     {
+        .error_fmt = QERR_NAME_TOO_LONG,
+        .des

[PATCH qmp-next 00/14]: qapi: convert screendump

Luiz Capitulino — 2012-05-25T19:41:05

Converting the screendump command is simple and shouldn't take more than
or or two patches, the complicated part is to report all errors correctly.

I hope I didn't go too far there, but at least this series does the right
thing (or is very near to).

 console.c        |   7 ++--
 console.h        |   5 +--
 cutils.c         | 100 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 hmp-commands.hx  |   5 ++-
 hmp.c            |   9 +++++
 hmp.h            |   1 +
 hw/blizzard.c    |   4 +--
 hw/g364fb.c      |  51 ++++++++++++++++++++--------
 hw/omap_lcdc.c   |  60 +++++++++++++++++++++++----------
 hw/qxl.c         |   7 ++--
 hw/tcx.c         |  96 ++++++++++++++++++++++++++++++++++++++++------------
 hw/vga.c         |  38 +++++++++++++--------
 hw/vga_int.h     |   3 +-
 hw/vmware_vga.c  |   7 ++--
 monitor.c        |   6 ----
 qapi-schema.json |  24 +++++++++++++
 qemu-common.h    |   7 ++++
 qerror.c         |  28 ++++++++++++++--
 qerror.h         |  22 ++++++++++--
 qmp-commands.hx  |   5 +--

[PATCH 01/14] qerror: extend QERR_TOO_MANY_FILES

Luiz Capitulino — 2012-05-25T19:41:06

Specify it's too many open files in the system (ENFILE).

There's no compatibility problem because it's not used anywhere today.

Signed-off-by: Luiz Capitulino <lcapitulino< at >redhat.com>
---
 qerror.c | 4 ++--
 qerror.h | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/qerror.c b/qerror.c
index 5092fe7..2c97382 100644
--- a/qerror.c
+++ b/qerror.c
< at >< at > -279,8 +279,8 < at >< at > static const QErrorStringTable qerror_table[] = {
         .desc      = "Could not set password",
     },
     {
-        .error_fmt = QERR_TOO_MANY_FILES,
-        .desc      = "Too many open files",
+        .error_fmt = QERR_TOO_MANY_FILES_SYS,
+        .desc      = "Too many opened files in the system",
     },
     {
         .error_fmt = QERR_UNDEFINED_ERROR,
diff --git a/qerror.h b/qerror.h
index 4cbba48..9ddf09c 100644
--- a/qerror.h
+++ b/qerror.h
< at >< at > -230,8 +230,8 < at >< at > QError *qobject_to_qerror(const QObject *obj);
 #define QERR_SET_PASSWD_FAILED \
     "{ 'class': 'SetPasswdFailed', 'data': {} }"
 
-#define QERR_TOO

[PATCH v2 1/1] virtio-rng: hardware random numbergenerator device

Amit Shah — 2012-05-25T19:32:49

The Linux kernel already has a virtio-rng driver, this is the device
implementation.

When the guest asks for entropy from the virtio hwrng, it puts a buffer
in the vq.  We then put entropy into that buffer, and push it back to
the guest.

The chardev connected to this device is fed the data to be sent to the
guest.

Invocation is simple:

  $ qemu ... -device virtio-rng-pci,chardev=foo

In the guest, we see

  $ cat /sys/devices/virtual/misc/hw_random/rng_available
  virtio

  $ cat /sys/devices/virtual/misc/hw_random/rng_current
  virtio

  # cat /dev/hwrng

Simply feeding /dev/urandom from the host to the chardev is sufficient:

  $ qemu ... -chardev socket,path=/tmp/foo,server,nowait,id=foo \
             -device virtio-rng,chardev=foo

  $ nc -U /tmp/foo < /dev/urandom

A QMP event is sent for interested apps to monitor activity and send the
appropriate number of bytes that get asked by the guest:

  {"timestamp": {"seconds": 1337966878, "microseconds": 517009}, \
   "event": "ENTROPY_NEEDED", "data": {

[PATCH v2 0/1] virtio-rng: hardware random numbergenerator

Amit Shah — 2012-05-25T19:32:48

Hello,

Here's the 2nd iteration of the virtio hwrng device.

This device just accepts data from the chardev and sends it up to the
guest.  There's no policy here on restricting the number of bytes we
send to the guest, as that can be done by management apps.

libvirt has a better picture of the host's entropy and multiple
guests, so it can better make decisions on when to supply entropy, and
how much.  Of course, Linux has a low watermark, via

  /proc/sys/kernel/random/entropy_avail

and it will stop giving out entropy once that watermark is reached
(currently 64).

/dev/urandom doesn't use all the bits at once, so using that device to
feed in entropy to the guest is safer and faster (without compromising
on the quality of randomness).

libvirt can also use daemons like egd to feed in entropy.

v2:
 * Remove hard-wiring to /dev/urandom
 * Use chardev for input
 * Add a QMP event for notifying listeners about entropy needed and
   the bytes asked for by the guest.
 * Add s390 code

Please review, and apply

Re: [PATCH 04/10] qom: add get_id

malc — 2012-05-25T17:39:34


Even better is to not use gcc extensions like this one.


Given that it's forbidden in this context - yeah.

[..snip..]