date:20111007

[Qemu-devel] Training program for your software

2011-10-07 Thread OCS Partners


  
  







Dear Sir or Madam,
 
I noticed that your company provides Open
  Source software, but does not appear to have training for this
  software.  My organization,
  One Course Source, is a training development and instructional
  staffing company, specializing in Open Source technologies.
 
Having a solid training program is important
  for any software program to be successful.  Customers need to know that
  they can receive good training when they opt to switch to your
  software product.  
 
One Course Source provides the following
  services:
 

  Instructors:
Our instructors learn your product and can teach from your
existing course materials.
  Courseware
  design: If you need courses developed, our instructors are
also courseware developers.  We
can either develop course materials from scratch or edit your
existing materials.
  Sales:
We can include your classes as part of our sales efforts.  For a commission on sales
we including your classes as part of our sales and marketing
strategy.  

 
I would be interested in opening a dialog
  regarding providing these services to your organization.  If you aren't the correct
  person for this, can you please forward this to the person in your
  organization who is responsible for this sort of business
  relationship?
 
Sincerely,
 
Bob Smith
  One Course Source

[Qemu-devel] [Bug 722311] Re: Segmentation fault if started without -enable-kvm parameter

2011-10-07 Thread Bug Reporter

The problem reported above was the same up to and including qemu 0.15.0.
Meanwhile I found this on the LinuxFromScratch (LFS) bug tracker:

  "Glibc-2.14 causes segfaults in SDL",
http://wiki.linuxfromscratch.org/lfs/ticket/2920

After applying their patch to GLIBC, qemu finally works again on the
Pentium 4. As far as I am concerned, this bug report can now be closed.


** Bug watch added: Linux From Scratch Trac #2920
   http://wiki.linuxfromscratch.org/lfs/ticket/2920

-- 
You received this bug notification because you are a member of qemu-
devel-ml, which is subscribed to QEMU.
https://bugs.launchpad.net/bugs/722311

Title:
  Segmentation fault if started without -enable-kvm parameter

Status in QEMU:
  New

Bug description:
  I start qemu (Linux) from the same USB memory stick on several
  computers. Up to and including qemu 0.12.5, I could use or not use
  qemu's "-enable-kvm" command line parameter as appropriate for the
  hardware, and qemu would run. In contrast, qemu 0.13.0 and 0.14.0
  segfault if started without "-enable-kvm". I get a black window
  appearing for fractions of a second, disappearing immediately, and
  then the error message "Segmentation fault".

  Hardware: Pentium 4, and Core 2 Duo.
  Command line: either "qemu" or "qemu -enable-kvm" (after manually loading the 
kvm-intel module on the Core 2 Duo).
  Reproducible: always.

To manage notifications about this bug go to:
https://bugs.launchpad.net/qemu/+bug/722311/+subscriptions

Re: [Qemu-devel] QEMU + ARM11MPCore

2011-10-07 Thread Antti P Miettinen

"TusharK"  writes:
> Hello,
> I tried executing QEMU (realview-smp ARM11MPCore) with Linux kernel 2.6.39.3,
> but it failed. Kernel itself is not getting decompressed. I compiled the
> kernel with realview-smp_config and build was successful. Can you please let
> me know how can test QEMU + ARM11MPcore combination.

In 2009 at least the following kernel options seemed relevant:

CONFIG_MACH_REALVIEW_EB=y
CONFIG_REALVIEW_EB_ARM11MP=y
CONFIG_REALVIEW_EB_ARM11MP_REVB=y
# CONFIG_REALVIEW_HIGH_PHYS_OFFSET is not set

-- 
Antti P Miettinen
http://www.iki.fi/~ananaza/

Re: [Qemu-devel] In-kernel emulation

2011-10-07 Thread Xin Tong

I am kind of speculating here. I could be wrong


MMU. in the kernel you can manipulate the EPT reg which is normally used by
kvm ( introduced by intel vmx, or amd svm).

IO, specifically for network packets, they do not need to go to user space,
they can be handled to the virtual machine directly.


Thanks


Xin


On Fri, Oct 7, 2011 at 3:10 PM, 陳韋任  wrote:

> > guest isa is different from host isa in this case.
> >
> > Xin
> >
> > On Fri, Oct 7, 2011 at 12:33 PM, 陳韋任  wrote:
> >
> > > > I am wondering that whether there are any attempts (product-oriented
> or
> > > > research-based ) to push QEMU into the Linux kernel to speed up
> emulation.
> > > > If the emulation is running in the kernel, there are some resources
> it can
> > > > manipulate to speed up emulation in comparison to the when it is
> running as
> > > > a user process, i.e. MMU. Also, IO emulation may become faster,
> because 2
>
>   I would like to know how you can leverage linux kernel to speed up
> MMU/IO emulation if guest and host are different ISAs. :)
>
> > > > kernel enters and exits are incurred for a network packet if QEMU is
> running
> > > > as a user process. If QEMU is running in the kernel, only 1 kernel
> enter and
> > > > exit are needed.  Any suggestions or discussions are welcome.
> > >
> > >   You want to use QEMU to emulate guest ISA different from the host?
> > > If the ISA of guest and host is the same, then KVM is enough, I think.
>
>
> --
> Wei-Ren Chen (陳韋任)
> Computer Systems Lab, Institute of Information Science,
> Academia Sinica, Taiwan (R.O.C.)
> Tel:886-2-2788-3799 #1667
>

[Qemu-devel] [PATCH] ui/vnc: Fix use of free() instead of g_free()

2011-10-07 Thread Stefan Weil

Please note that mechlist still uses malloc / strdup / free.

Signed-off-by: Stefan Weil 
---
 ui/vnc-auth-sasl.c   |8 
 ui/vnc-enc-hextile.c |4 ++--
 ui/vnc-tls.c |2 +-
 ui/vnc.c |8 
 4 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/ui/vnc-auth-sasl.c b/ui/vnc-auth-sasl.c
index e96095a..23b1bf5 100644
--- a/ui/vnc-auth-sasl.c
+++ b/ui/vnc-auth-sasl.c
@@ -34,7 +34,7 @@ void vnc_sasl_client_cleanup(VncState *vs)
 vs->sasl.runSSF = vs->sasl.waitWriteSSF = vs->sasl.wantSSF = 0;
 vs->sasl.encodedLength = vs->sasl.encodedOffset = 0;
 vs->sasl.encoded = NULL;
-free(vs->sasl.username);
+g_free(vs->sasl.username);
 free(vs->sasl.mechlist);
 vs->sasl.username = vs->sasl.mechlist = NULL;
 sasl_dispose(&vs->sasl.conn);
@@ -506,7 +506,7 @@ void start_auth_sasl(VncState *vs)
 goto authabort;
 
 if (!(remoteAddr = vnc_socket_remote_addr("%s;%s", vs->csock))) {
-free(localAddr);
+g_free(localAddr);
 goto authabort;
 }
 
@@ -518,8 +518,8 @@ void start_auth_sasl(VncState *vs)
   NULL, /* Callbacks, not needed */
   SASL_SUCCESS_DATA,
   &vs->sasl.conn);
-free(localAddr);
-free(remoteAddr);
+g_free(localAddr);
+g_free(remoteAddr);
 localAddr = remoteAddr = NULL;
 
 if (err != SASL_OK) {
diff --git a/ui/vnc-enc-hextile.c b/ui/vnc-enc-hextile.c
index d2905c8..c860dbb 100644
--- a/ui/vnc-enc-hextile.c
+++ b/ui/vnc-enc-hextile.c
@@ -80,8 +80,8 @@ int vnc_hextile_send_framebuffer_update(VncState *vs, int x,
   last_bg, last_fg, &has_bg, &has_fg);
 }
 }
-free(last_fg);
-free(last_bg);
+g_free(last_fg);
+g_free(last_bg);
 
 return 1;
 }
diff --git a/ui/vnc-tls.c b/ui/vnc-tls.c
index ffbd172..3aaa939 100644
--- a/ui/vnc-tls.c
+++ b/ui/vnc-tls.c
@@ -413,7 +413,7 @@ void vnc_tls_client_cleanup(struct VncState *vs)
 vs->tls.session = NULL;
 }
 vs->tls.wiremode = VNC_WIREMODE_CLEAR;
-free(vs->tls.dname);
+g_free(vs->tls.dname);
 }
 
 
diff --git a/ui/vnc.c b/ui/vnc.c
index fc3a612..3107918 100644
--- a/ui/vnc.c
+++ b/ui/vnc.c
@@ -2880,7 +2880,7 @@ int vnc_display_open(DisplayState *ds, const char 
*display)
 if ((saslErr = sasl_server_init(NULL, "qemu")) != SASL_OK) {
 fprintf(stderr, "Failed to initialize SASL auth %s",
 sasl_errstring(saslErr, NULL, NULL));
-free(vs->display);
+g_free(vs->display);
 vs->display = NULL;
 return -1;
 }
@@ -2894,7 +2894,7 @@ int vnc_display_open(DisplayState *ds, const char 
*display)
 else
 vs->lsock = inet_connect(display, SOCK_STREAM);
 if (-1 == vs->lsock) {
-free(vs->display);
+g_free(vs->display);
 vs->display = NULL;
 return -1;
 } else {
@@ -2915,10 +2915,10 @@ int vnc_display_open(DisplayState *ds, const char 
*display)
 vs->lsock = inet_listen(display, dpy, 256, SOCK_STREAM, 5900);
 }
 if (-1 == vs->lsock) {
-free(dpy);
+g_free(dpy);
 return -1;
 } else {
-free(vs->display);
+g_free(vs->display);
 vs->display = dpy;
 }
 }
-- 
1.7.2.5

Re: [Qemu-devel] In-kernel emulation

2011-10-07 Thread 陳韋任

> guest isa is different from host isa in this case.
> 
> Xin
> 
> On Fri, Oct 7, 2011 at 12:33 PM, 陳韋任  wrote:
> 
> > > I am wondering that whether there are any attempts (product-oriented or
> > > research-based ) to push QEMU into the Linux kernel to speed up emulation.
> > > If the emulation is running in the kernel, there are some resources it can
> > > manipulate to speed up emulation in comparison to the when it is running 
> > > as
> > > a user process, i.e. MMU. Also, IO emulation may become faster, because 2

  I would like to know how you can leverage linux kernel to speed up
MMU/IO emulation if guest and host are different ISAs. :)

> > > kernel enters and exits are incurred for a network packet if QEMU is 
> > > running
> > > as a user process. If QEMU is running in the kernel, only 1 kernel enter 
> > > and
> > > exit are needed.  Any suggestions or discussions are welcome.
> >
> >   You want to use QEMU to emulate guest ISA different from the host?
> > If the ISA of guest and host is the same, then KVM is enough, I think.


-- 
Wei-Ren Chen (陳韋任)
Computer Systems Lab, Institute of Information Science,
Academia Sinica, Taiwan (R.O.C.)
Tel:886-2-2788-3799 #1667

Re: [Qemu-devel] [PATCH] tcg: Introduce TCGReg for all TCG hosts (fixes build for s390 hosts)

2011-10-07 Thread Stefan Weil


Am 07.10.2011 20:13, schrieb Richard Henderson:

On 10/07/2011 11:00 AM, Stefan Weil wrote:
+#define TCGReg int /* TODO: Remove this line when tcg-target.c uses 
TCGReg. */


Nack. This is too ugly to live.

How hard can it be to simply change the prototype in each
of the backend files instead? Yes, full conversion to
TCGReg is desirable, but this is not C++ -- integers and
enums are interchangable without casts.

r~


The goal of my patch is to get code which compiles again
on all hosts with minimum risk and which is a base for further
improvements.

I cannot run build tests for all possible hosts, and even
changing 4 prototypes for each host is a risk when it is not
tested. Yes, you can review the changes, some developers can
try builds, but that takes a lot of time.

As soon as my patch is applied, it is possible to add
more TCGReg usage to tcg.c, s390/tcg-target.c and all
other TCG targets in independent patches.

I'm just preparing patches for tcg.c and i386/tcg-target.*.

But let me repeat: these new patches need a good review
which will take some time. The bug fix should be applied soon.
Maybe you can change your mind and send an ack.

- Stefan

Re: [Qemu-devel] [PATCH] tcg: Introduce TCGReg for all TCG hosts (fixes build for s390 hosts)

2011-10-07 Thread Richard Henderson

On 10/07/2011 11:00 AM, Stefan Weil wrote:
> +#define TCGReg int /* TODO: Remove this line when tcg-target.c uses TCGReg. 
> */

Nack.  This is too ugly to live.

How hard can it be to simply change the prototype in each
of the backend files instead?  Yes, full conversion to
TCGReg is desirable, but this is not C++ -- integers and
enums are interchangable without casts.

r~

[Qemu-devel] [PATCH] tcg: Introduce TCGReg for all TCG hosts (fixes build for s390 hosts)

2011-10-07 Thread Stefan Weil

s390 already uses TCGReg - this patch defines TCGReg
for all other TCG targets.

The targets still don't use TCGReg, therefore a temporary define
maps 'TCGReg' to 'int' for all unfinished targets.

This define allows usage of TCGReg in tcg.c thus fixing some forward
declarations which had broken compilation on s390 hosts since commit
c0ad3001bf12292b137b05e1c4643f31c6b0a727.

Signed-off-by: Stefan Weil 
---
 tcg/arm/tcg-target.h   |6 --
 tcg/hppa/tcg-target.h  |6 --
 tcg/i386/tcg-target.h  |6 --
 tcg/ia64/tcg-target.h  |7 +--
 tcg/mips/tcg-target.h  |6 --
 tcg/ppc/tcg-target.h   |6 --
 tcg/ppc64/tcg-target.h |6 --
 tcg/sparc/tcg-target.h |6 --
 tcg/tcg.c  |8 
 9 files changed, 37 insertions(+), 20 deletions(-)

diff --git a/tcg/arm/tcg-target.h b/tcg/arm/tcg-target.h
index 33afd97..047b6d0 100644
--- a/tcg/arm/tcg-target.h
+++ b/tcg/arm/tcg-target.h
@@ -27,7 +27,7 @@
 #undef TCG_TARGET_WORDS_BIGENDIAN
 #undef TCG_TARGET_STACK_GROWSUP
 
-enum {
+typedef enum {
 TCG_REG_R0 = 0,
 TCG_REG_R1,
 TCG_REG_R2,
@@ -44,7 +44,9 @@ enum {
 TCG_REG_R13,
 TCG_REG_R14,
 TCG_REG_PC,
-};
+} TCGReg;
+
+#define TCGReg int /* TODO: Remove this line when tcg-target.c uses TCGReg. */
 
 #define TCG_TARGET_NB_REGS 16
 
diff --git a/tcg/hppa/tcg-target.h b/tcg/hppa/tcg-target.h
index ec9a7bf..8c220ae 100644
--- a/tcg/hppa/tcg-target.h
+++ b/tcg/hppa/tcg-target.h
@@ -32,7 +32,7 @@
 
 #define TCG_TARGET_NB_REGS 32
 
-enum {
+typedef enum {
 TCG_REG_R0 = 0,
 TCG_REG_R1,
 TCG_REG_RP,
@@ -65,7 +65,9 @@ enum {
 TCG_REG_RET1,
 TCG_REG_SP,
 TCG_REG_R31,
-};
+} TCGReg;
+
+#define TCGReg int /* TODO: Remove this line when tcg-target.c uses TCGReg. */
 
 #define TCG_CT_CONST_00x0100
 #define TCG_CT_CONST_S5   0x0200
diff --git a/tcg/i386/tcg-target.h b/tcg/i386/tcg-target.h
index b9c9d4e..0466216 100644
--- a/tcg/i386/tcg-target.h
+++ b/tcg/i386/tcg-target.h
@@ -36,7 +36,7 @@
 # define TCG_TARGET_NB_REGS 8
 #endif
 
-enum {
+typedef enum {
 TCG_REG_EAX = 0,
 TCG_REG_ECX,
 TCG_REG_EDX,
@@ -64,7 +64,9 @@ enum {
 TCG_REG_RBP = TCG_REG_EBP,
 TCG_REG_RSI = TCG_REG_ESI,
 TCG_REG_RDI = TCG_REG_EDI,
-};
+} TCGReg;
+
+#define TCGReg int /* TODO: Remove this line when tcg-target.c uses TCGReg. */
 
 #define TCG_CT_CONST_S32 0x100
 #define TCG_CT_CONST_U32 0x200
diff --git a/tcg/ia64/tcg-target.h b/tcg/ia64/tcg-target.h
index 578cf29..fc83559 100644
--- a/tcg/ia64/tcg-target.h
+++ b/tcg/ia64/tcg-target.h
@@ -26,7 +26,8 @@
 
 /* We only map the first 64 registers */
 #define TCG_TARGET_NB_REGS 64
-enum {
+
+typedef enum {
 TCG_REG_R0 = 0,
 TCG_REG_R1,
 TCG_REG_R2,
@@ -91,7 +92,9 @@ enum {
 TCG_REG_R61,
 TCG_REG_R62,
 TCG_REG_R63,
-};
+} TCGReg;
+
+#define TCGReg int /* TODO: Remove this line when tcg-target.c uses TCGReg. */
 
 #define TCG_CT_CONST_ZERO 0x100
 #define TCG_CT_CONST_S22 0x200
diff --git a/tcg/mips/tcg-target.h b/tcg/mips/tcg-target.h
index e2a2571..1b01206 100644
--- a/tcg/mips/tcg-target.h
+++ b/tcg/mips/tcg-target.h
@@ -31,7 +31,7 @@
 
 #define TCG_TARGET_NB_REGS 32
 
-enum {
+typedef enum {
 TCG_REG_ZERO = 0,
 TCG_REG_AT,
 TCG_REG_V0,
@@ -64,7 +64,9 @@ enum {
 TCG_REG_SP,
 TCG_REG_FP,
 TCG_REG_RA,
-};
+} TCGReg;
+
+#define TCGReg int /* TODO: Remove this line when tcg-target.c uses TCGReg. */
 
 #define TCG_CT_CONST_ZERO 0x100
 #define TCG_CT_CONST_U16  0x200
diff --git a/tcg/ppc/tcg-target.h b/tcg/ppc/tcg-target.h
index 5c2d612..d737809 100644
--- a/tcg/ppc/tcg-target.h
+++ b/tcg/ppc/tcg-target.h
@@ -26,7 +26,7 @@
 #define TCG_TARGET_WORDS_BIGENDIAN
 #define TCG_TARGET_NB_REGS 32
 
-enum {
+typedef enum {
 TCG_REG_R0 = 0,
 TCG_REG_R1,
 TCG_REG_R2,
@@ -59,7 +59,9 @@ enum {
 TCG_REG_R29,
 TCG_REG_R30,
 TCG_REG_R31
-};
+} TCGReg;
+
+#define TCGReg int /* TODO: Remove this line when tcg-target.c uses TCGReg. */
 
 /* used for function call generation */
 #define TCG_REG_CALL_STACK TCG_REG_R1
diff --git a/tcg/ppc64/tcg-target.h b/tcg/ppc64/tcg-target.h
index 8d1fb73..a37259e 100644
--- a/tcg/ppc64/tcg-target.h
+++ b/tcg/ppc64/tcg-target.h
@@ -26,7 +26,7 @@
 #define TCG_TARGET_WORDS_BIGENDIAN
 #define TCG_TARGET_NB_REGS 32
 
-enum {
+typedef enum {
 TCG_REG_R0 = 0,
 TCG_REG_R1,
 TCG_REG_R2,
@@ -59,7 +59,9 @@ enum {
 TCG_REG_R29,
 TCG_REG_R30,
 TCG_REG_R31
-};
+} TCGReg;
+
+#define TCGReg int /* TODO: Remove this line when tcg-target.c uses TCGReg. */
 
 /* used for function call generation */
 #define TCG_REG_CALL_STACK TCG_REG_R1
diff --git a/tcg/sparc/tcg-target.h b/tcg/sparc/tcg-target.h
index 1464ef4..527b32f 100644
--- a/tcg/sparc/tcg-target.h
+++ b/tcg/sparc/tcg-target.h
@@ -27,7 +27,7 @@
 
 #define TCG_TARGET_NB_REGS 32
 
-enum {
+typedef enum {
 TCG_REG_G0 = 0,
 TCG_REG_G1,
 TCG_REG_G2,
@@ -60,7 +60,9 @@ enum {
 TCG_REG_I5,
 TCG_REG_I6,
 TCG_REG_I7,
-};

Re: [Qemu-devel] [PATCH] Make cpu_single_env thread local (Linux only for now)

2011-10-07 Thread David Gilbert

On 5 October 2011 10:21, Paolo Bonzini  wrote:

> If interested people can test the patches more and submit them more
> formally, I'd be very glad.  I wrote it for RCU, but of course that one is
> not really going to be 1.0 material (even for 9p).

Hmm this got a bit more complex than the original patch; still it covers a lot
more bases.

Should this also replace the THREAD that's defined in
linux-user/qemu.h and bsd-user/qemu.h (that is __thread if built with
NPTL)?
It seems to only be there for 'thread_env' which is also a CPUState*
(hmm - what state does that contain that cpu_single_env doesn't?)

Dave

Re: [Qemu-devel] In-kernel emulation

2011-10-07 Thread 陳韋任

> I am wondering that whether there are any attempts (product-oriented or
> research-based ) to push QEMU into the Linux kernel to speed up emulation.
> If the emulation is running in the kernel, there are some resources it can
> manipulate to speed up emulation in comparison to the when it is running as
> a user process, i.e. MMU. Also, IO emulation may become faster, because 2
> kernel enters and exits are incurred for a network packet if QEMU is running
> as a user process. If QEMU is running in the kernel, only 1 kernel enter and
> exit are needed.  Any suggestions or discussions are welcome.

  You want to use QEMU to emulate guest ISA different from the host?
If the ISA of guest and host is the same, then KVM is enough, I think.

Regards,
chenwj

-- 
Wei-Ren Chen (陳韋任)
Computer Systems Lab, Institute of Information Science,
Academia Sinica, Taiwan (R.O.C.)
Tel:886-2-2788-3799 #1667

Re: [Qemu-devel] [PATCH v3] Add AACI audio playback support to the ARM Versatile/PB platform

2011-10-07 Thread Peter Maydell

On 29 September 2011 18:31, Mathieu Sonet  wrote:
> This driver emulates the ARM AACI interface (PL041) connected to a LM4549
> codec.
> It enables audio playback for the Versatile/PB platform.
>
> Limitations:
> - Supports only a playback on one channel (Versatile/Vexpress)
> - Supports only a TX FIFO in compact-mode.

Actually you seem to have implemented a weird hybrid of compact
and non-compact modes.

Non-compact mode: FIFOs are 20 bits wide; a word write from the
CPU writes to bits [19:0] of the FIFO slot; each 'slot' of data
to the LM4549 reads 20 bits from the FIFO.
Compact mode: FIFOs are 40 bits wide (and half as deep); a word
write from the CPU writes to bits [31:0] of the FIFO slot; each
'slot' of data to the LM4549 reads 16 bits from the FIFO (bits
[15:0] then [31:16], and you have to read two slots (ie the
2 channels of stereo).

You've implemented a single 32 bit depth FIFO which one CPU
write writes to and which always passes one 32 bit word to the
LM4549. There are two issues here:
 (1) the LM4549 can take up to 18 bits of data per slot,
which your current lm4549_write_sample() API doesn't allow.
Passing two 32 bit words here would fix that. [My point here
is that we shouldn't hardwire the missing non-compact mode
support into the API between the two components.]
 (2) when the Linux driver dynamically identifies the size
of the FIFO it does it in non-compact mode, so it will return
a value half as big as is actually right for the compact-mode
behaviour you've implemented.

(Also your FIFO is twice as deep as it should be if we're
only implementing compact mode.)

> Playback tested successfully with speaker-test/aplay/mpg123.

I find that on vexpress mpg123 playback works but can be quite stuttery.
madplay (integer only) is somewhat better, so I suspect that qemu is
spending ages emulating Neon/VFP in mpg123...

Further (minor) comments below.

> +    regfile[LM4549_PCM_Front_DAC_Rate]  = 0xBB80;
> +    regfile[LM4549_PCM_ADC_Rate]        = 0xBB80;
> +    regfile[LM4549_Vendor_ID1]          = 0x4e53;
> +    regfile[LM4549_Vendor_ID2]          = 0x4331;

Can we be consistent about upper or lower case for the hex?

> +#define MAX_FIFO_DEPTH                 (1024)
> +#define VERSATILEPB_DEFAULT_FIFO_DEPTH (256)  /* AN115B - Table 1.1 */

pl041.c shouldn't know anything about VersatilePB. The default
fifo depth should be 8 (same as the hardware PL041).

> +static uint8_t pl041_compute_periphid3(pl041_state *s)
> +{
> +    uint8_t id3 = (1 | ((s->fifo_depth >> 4) << 3));
> +    return id3;
> +}

This isn't right.

[5:3] FIFO depth (non-compact mode)
b000  8
b001  16
b010  32
b011  64
b100  128
b101  256
b110  512
b111  1024

...which isn't what your function calculates.
(Linux determines FIFO depth programmatically by stuffing words
into the FIFO until the status register says it's full, which is
why it doesn't complain.)

NB that some of the board TRMs have what seem to be incorrect
labelling on the tables of depth vs ID register bits.

> +    /* Update the irq state */
> +    qemu_set_irq(s->irq, ((s->regs.isr1 & s->regs.ie1) > 0) ? 1 : 0);
> +    DBG_L2("Set interrupt sr1 = 0x%08x isr1 = 0x%08x masked = 0x%08x\n",
> +           s->regs.sr1, s->regs.isr1, s->regs.isr1 & mask);
> +}

This debug printf won't compile if enabled -- you forgot
to update it when you changed the main code to remove the
'mask' variable.

> +static int pl041_post_load(void *opaque, int version_id)
> +{
> +    pl041_state *s = opaque;
> +    lm4549_post_load(&s->codec);
> +    return 0;
> +}

Is it not possible to just register lm4549_post_load()
as the post_load function for lm4549_state, rather than
having a pl041 post_load hook which only passes it through?

(Something in your mailsending path is wrapping long lines, by the way.)

-- PMM

[Qemu-devel] [PATCH 0/3] block: zero write detection

2011-10-07 Thread Stefan Hajnoczi

Image streaming copies data from the backing file into the image file. It is
important to represent zero regions from the backing file efficiently during
streaming, otherwise the image file grows to the full virtual disk size and
loses sparseness.

There are two ways to implement zero write detection, they are subtly different:

1. Allow image formats to provide efficient representations for zero regions.
QED does this with "zero clusters" and it has been discussed for qcow2v3.

2. During streaming, check for zeroes and skip writing to the image file when
zeroes are detected.

However, there are some disadvantages to #2 because it leaves unallocated holes
in the image file. If image streaming is aborted before it completes then it
will be necessary to reread all unallocated clusters from the backing file upon
resuming image streaming. Potentionally worse is that a backing file over a
slow remote connection will have the zero regions fetched again and again if
the guest accesses them. #1 avoids these problems because the image file
contains information on which regions are zeroes and do not need to be
refetched.

This patch series implements #1 with the existing QED zero cluster feature. In
the future we can add qcow2v3 zero clusters too. We can also implement #2
directly in the image streaming code as a fallback when the BlockDriver does
not support zero detection #1 itself. That way we get the best possible zero
write detection, depending on the image format.

Here is a qemu-iotest to verify that zero write detection is working:
http://repo.or.cz/w/qemu-iotests/stefanha.git/commitdiff/226949695eef51bdcdea3e6ce3d7e5a863427f37

Stefan Hajnoczi (3):
block: add zero write detection interface
qed: add zero write detection support
qemu-io: add zero write detection option

--
1.7.6.3

[Qemu-devel] [PATCH 2/3] qed: add zero write detection support

2011-10-07 Thread Stefan Hajnoczi

The QED image format is able to efficiently represent clusters
containing zeroes with a magic offset value.  This patch implements zero
write detection for allocating writes so that image streaming can copy
over zero clusters from a backing file without expanding the image file
unnecessarily.

This is based code by Anthony Liguori .

Signed-off-by: Stefan Hajnoczi 
---
 block/qed.c |   81 +--
 1 files changed, 73 insertions(+), 8 deletions(-)

diff --git a/block/qed.c b/block/qed.c
index e87dc4d..ec3113b 100644
--- a/block/qed.c
+++ b/block/qed.c
@@ -947,9 +947,8 @@ static void qed_aio_write_l1_update(void *opaque, int ret)
 /**
  * Update L2 table with new cluster offsets and write them out
  */
-static void qed_aio_write_l2_update(void *opaque, int ret)
+static void qed_aio_write_l2_update(QEDAIOCB *acb, int ret, uint64_t offset)
 {
-QEDAIOCB *acb = opaque;
 BDRVQEDState *s = acb_to_s(acb);
 bool need_alloc = acb->find_cluster_ret == QED_CLUSTER_L1;
 int index;
@@ -965,7 +964,7 @@ static void qed_aio_write_l2_update(void *opaque, int ret)
 
 index = qed_l2_index(s, acb->cur_pos);
 qed_update_l2_table(s, acb->request.l2_table->table, index, 
acb->cur_nclusters,
- acb->cur_cluster);
+ offset);
 
 if (need_alloc) {
 /* Write out the whole new L2 table */
@@ -982,6 +981,51 @@ err:
 qed_aio_complete(acb, ret);
 }
 
+static void qed_aio_write_l2_update_cb(void *opaque, int ret)
+{
+QEDAIOCB *acb = opaque;
+qed_aio_write_l2_update(acb, ret, acb->cur_cluster);
+}
+
+/**
+ * Determine if we have a zero write to a block of clusters
+ *
+ * We validate that the write is aligned to a cluster boundary, and that it's
+ * a multiple of cluster size with all zeros.
+ */
+static bool qed_is_zero_write(QEDAIOCB *acb)
+{
+BDRVQEDState *s = acb_to_s(acb);
+int i;
+
+if (!qed_offset_is_cluster_aligned(s, acb->cur_pos)) {
+return false;
+}
+
+if (!qed_offset_is_cluster_aligned(s, acb->cur_qiov.size)) {
+return false;
+}
+
+for (i = 0; i < acb->cur_qiov.niov; i++) {
+struct iovec *iov = &acb->cur_qiov.iov[i];
+uint64_t *v;
+int j;
+
+if ((iov->iov_len & 0x07)) {
+return false;
+}
+
+v = iov->iov_base;
+for (j = 0; j < iov->iov_len; j += sizeof(v[0])) {
+if (v[j >> 3]) {
+return false;
+}
+}
+}
+
+return true;
+}
+
 /**
  * Flush new data clusters before updating the L2 table
  *
@@ -996,7 +1040,7 @@ static void qed_aio_write_flush_before_l2_update(void 
*opaque, int ret)
 QEDAIOCB *acb = opaque;
 BDRVQEDState *s = acb_to_s(acb);
 
-if (!bdrv_aio_flush(s->bs->file, qed_aio_write_l2_update, opaque)) {
+if (!bdrv_aio_flush(s->bs->file, qed_aio_write_l2_update_cb, opaque)) {
 qed_aio_complete(acb, -EIO);
 }
 }
@@ -1026,7 +1070,7 @@ static void qed_aio_write_main(void *opaque, int ret)
 if (s->bs->backing_hd) {
 next_fn = qed_aio_write_flush_before_l2_update;
 } else {
-next_fn = qed_aio_write_l2_update;
+next_fn = qed_aio_write_l2_update_cb;
 }
 }
 
@@ -1092,6 +1136,18 @@ static bool qed_should_set_need_check(BDRVQEDState *s)
 return !(s->header.features & QED_F_NEED_CHECK);
 }
 
+static void qed_aio_write_zero_cluster(void *opaque, int ret)
+{
+QEDAIOCB *acb = opaque;
+
+if (ret) {
+qed_aio_complete(acb, ret);
+return;
+}
+
+qed_aio_write_l2_update(acb, 0, 1);
+}
+
 /**
  * Write new data cluster
  *
@@ -1103,6 +1159,7 @@ static bool qed_should_set_need_check(BDRVQEDState *s)
 static void qed_aio_write_alloc(QEDAIOCB *acb, size_t len)
 {
 BDRVQEDState *s = acb_to_s(acb);
+BlockDriverCompletionFunc *cb;
 
 /* Cancel timer when the first allocating request comes in */
 if (QSIMPLEQ_EMPTY(&s->allocating_write_reqs)) {
@@ -1120,14 +1177,21 @@ static void qed_aio_write_alloc(QEDAIOCB *acb, size_t 
len)
 
 acb->cur_nclusters = qed_bytes_to_clusters(s,
 qed_offset_into_cluster(s, acb->cur_pos) + len);
-acb->cur_cluster = qed_alloc_clusters(s, acb->cur_nclusters);
 qemu_iovec_copy(&acb->cur_qiov, acb->qiov, acb->qiov_offset, len);
 
+/* Zero write detection */
+if (s->bs->use_zero_detection && qed_is_zero_write(acb)) {
+cb = qed_aio_write_zero_cluster;
+} else {
+cb = qed_aio_write_prefill;
+acb->cur_cluster = qed_alloc_clusters(s, acb->cur_nclusters);
+}
+
 if (qed_should_set_need_check(s)) {
 s->header.features |= QED_F_NEED_CHECK;
-qed_write_header(s, qed_aio_write_prefill, acb);
+qed_write_header(s, cb, acb);
 } else {
-qed_aio_write_prefill(acb, 0);
+cb(acb, 0);
 }
 }
 
@@ -1474,6 +1538,7 @@ static BlockDriver bdrv_qed = {
 .format_name  = "qed",

[Qemu-devel] [PATCH 1/3] block: add zero write detection interface

2011-10-07 Thread Stefan Hajnoczi

Some image formats can represent zero regions efficiently even when a
backing file is present.  In order to use this feature they need to
detect zero writes and handle them specially.

Since zero write detection consumes CPU cycles it is disabled by default
and must be explicitly enabled.  This patch adds an interface to do so.

Currently no block drivers actually support zero write detection yet.
This is addressed in follow-up patches.

Signed-off-by: Stefan Hajnoczi 
---
 block.c |   16 
 block.h |2 ++
 block_int.h |   13 +
 3 files changed, 31 insertions(+), 0 deletions(-)

diff --git a/block.c b/block.c
index e3fe97f..5cf53d6 100644
--- a/block.c
+++ b/block.c
@@ -481,6 +481,7 @@ static int bdrv_open_common(BlockDriverState *bs, const 
char *filename,
 bs->valid_key = 0;
 bs->open_flags = flags;
 bs->buffer_alignment = 512;
+bs->use_zero_detection = false;
 
 pstrcpy(bs->filename, sizeof(bs->filename), filename);
 
@@ -3344,3 +3345,18 @@ out:
 
 return ret;
 }
+
+int bdrv_set_zero_detection(BlockDriverState *bs, bool enable)
+{
+BlockDriver *drv = bs->drv;
+
+if (!drv) {
+return -ENOMEDIUM;
+}
+if (!drv->has_zero_detection) {
+return -ENOTSUP;
+}
+
+bs->use_zero_detection = enable;
+return 0;
+}
diff --git a/block.h b/block.h
index 16bfa0a..283dc27 100644
--- a/block.h
+++ b/block.h
@@ -273,6 +273,8 @@ int bdrv_img_create(const char *filename, const char *fmt,
 void bdrv_set_buffer_alignment(BlockDriverState *bs, int align);
 void *qemu_blockalign(BlockDriverState *bs, size_t size);
 
+int bdrv_set_zero_detection(BlockDriverState *bs, bool enable);
+
 #define BDRV_SECTORS_PER_DIRTY_CHUNK 2048
 
 void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable);
diff --git a/block_int.h b/block_int.h
index 8c3b863..3e8d768 100644
--- a/block_int.h
+++ b/block_int.h
@@ -146,6 +146,16 @@ struct BlockDriver {
  */
 int (*bdrv_has_zero_init)(BlockDriverState *bs);
 
+/*
+ * True if zero write detection is supported, false otherwise.
+ *
+ * Block drivers that declare support for zero detection should check
+ * BlockDriverState.use_zero_detection for each write request to decide
+ * whether or not to perform detection.  Since zero detection consumes CPU
+ * cycles it is disabled by default.
+ */
+bool has_zero_detection;
+
 QLIST_ENTRY(BlockDriver) list;
 };
 
@@ -195,6 +205,9 @@ struct BlockDriverState {
 /* do we need to tell the quest if we have a volatile write cache? */
 int enable_write_cache;
 
+/* is zero write detection enabled? */
+bool use_zero_detection;
+
 /* NOTE: the following infos are only hints for real hardware
drivers. They are not used by the block driver */
 int cyls, heads, secs, translation;
-- 
1.7.6.3

[Qemu-devel] [PATCH 3/3] qemu-io: add zero write detection option

2011-10-07 Thread Stefan Hajnoczi

Add a -z option to qemu-io and the 'open' command to enable zero write
detection.  This is used by the qemu-iotests 029 test case and allows
scripts to exercise zero write detection.

Signed-off-by: Stefan Hajnoczi 
---
 qemu-io.c |   35 ---
 1 files changed, 28 insertions(+), 7 deletions(-)

diff --git a/qemu-io.c b/qemu-io.c
index e91af37..94beaf6 100644
--- a/qemu-io.c
+++ b/qemu-io.c
@@ -1593,7 +1593,7 @@ static const cmdinfo_t close_cmd = {
 .oneline= "close the current open file",
 };
 
-static int openfile(char *name, int flags, int growable)
+static int openfile(char *name, int flags, int growable, int detect_zeroes)
 {
 if (bs) {
 fprintf(stderr, "file open already, try 'help close'\n");
@@ -1615,6 +1615,16 @@ static int openfile(char *name, int flags, int growable)
 }
 }
 
+if (detect_zeroes) {
+if (bdrv_set_zero_detection(bs, true) < 0) {
+fprintf(stderr, "%s: format does not support zero detection\n",
+progname);
+bdrv_delete(bs);
+bs = NULL;
+return 1;
+}
+}
+
 return 0;
 }
 
@@ -1632,6 +1642,7 @@ static void open_help(void)
 " -s, -- use snapshot file\n"
 " -n, -- disable host cache\n"
 " -g, -- allow file to grow (only applies to protocols)"
+" -z  -- use zero write detection (supported formats only)\n"
 "\n");
 }
 
@@ -1644,7 +1655,7 @@ static const cmdinfo_t open_cmd = {
 .argmin = 1,
 .argmax = -1,
 .flags  = CMD_NOFILE_OK,
-.args   = "[-Crsn] [path]",
+.args   = "[-Crsnz] [path]",
 .oneline= "open the file specified by path",
 .help   = open_help,
 };
@@ -1654,9 +1665,10 @@ static int open_f(int argc, char **argv)
 int flags = 0;
 int readonly = 0;
 int growable = 0;
+int detect_zeroes = 0;
 int c;
 
-while ((c = getopt(argc, argv, "snrg")) != EOF) {
+while ((c = getopt(argc, argv, "snrgz")) != EOF) {
 switch (c) {
 case 's':
 flags |= BDRV_O_SNAPSHOT;
@@ -1670,6 +1682,9 @@ static int open_f(int argc, char **argv)
 case 'g':
 growable = 1;
 break;
+case 'z':
+detect_zeroes = 1;
+break;
 default:
 return command_usage(&open_cmd);
 }
@@ -1683,7 +1698,7 @@ static int open_f(int argc, char **argv)
 return command_usage(&open_cmd);
 }
 
-return openfile(argv[optind], flags, growable);
+return openfile(argv[optind], flags, growable, detect_zeroes);
 }
 
 static int init_args_command(int index)
@@ -1710,7 +1725,7 @@ static int init_check_command(const cmdinfo_t *ct)
 static void usage(const char *name)
 {
 printf(
-"Usage: %s [-h] [-V] [-rsnm] [-c cmd] ... [file]\n"
+"Usage: %s [-h] [-V] [-rsnmkz] [-c cmd] ... [file]\n"
 "QEMU Disk exerciser\n"
 "\n"
 "  -c, --cmdcommand to execute\n"
@@ -1720,6 +1735,7 @@ static void usage(const char *name)
 "  -g, --growable   allow file to grow (only applies to protocols)\n"
 "  -m, --misalign   misalign allocations for O_DIRECT\n"
 "  -k, --native-aio use kernel AIO implementation (on Linux only)\n"
+"  -z, --detect-zeroes  use zero write detection (supported formats only)\n"
 "  -h, --help   display this help and exit\n"
 "  -V, --versionoutput version information and exit\n"
 "\n",
@@ -1731,7 +1747,8 @@ int main(int argc, char **argv)
 {
 int readonly = 0;
 int growable = 0;
-const char *sopt = "hVc:rsnmgk";
+int detect_zeroes = 0;
+const char *sopt = "hVc:rsnmgkz";
 const struct option lopt[] = {
 { "help", 0, NULL, 'h' },
 { "version", 0, NULL, 'V' },
@@ -1743,6 +1760,7 @@ int main(int argc, char **argv)
 { "misalign", 0, NULL, 'm' },
 { "growable", 0, NULL, 'g' },
 { "native-aio", 0, NULL, 'k' },
+{ "detect-zeroes", 0, NULL, 'z' },
 { NULL, 0, NULL, 0 }
 };
 int c;
@@ -1774,6 +1792,9 @@ int main(int argc, char **argv)
 case 'k':
 flags |= BDRV_O_NATIVE_AIO;
 break;
+case 'z':
+detect_zeroes = 1;
+break;
 case 'V':
 printf("%s version %s\n", progname, VERSION);
 exit(0);
@@ -1823,7 +1844,7 @@ int main(int argc, char **argv)
 }
 
 if ((argc - optind) == 1) {
-openfile(argv[optind], flags, growable);
+openfile(argv[optind], flags, growable, detect_zeroes);
 }
 command_loop();
 
-- 
1.7.6.3

83 matches

Mail list logo