[Qemu-devel] qemu / KVM modification to yield to external component (how to make it ignore the time the external component is running)

[Lloret, Luis]

BTW, we are using Fedora 18 and OpenSUSE 12.2 as guest OS. Any ideas?

 

Thanks,

Luis

 

 

Hi, qemu experts,

 

We are using qemu with KVM for some experiments that involve qemu yielding to

an external process periodically. By yielding, what I mean is that qemu will

stop executing for some time while the external process does its job and

reports back to qemu. The external process is a remote HW model. The handshake

happens with normal TCP sockets, and the platform that this is running on has

the constraint that qemu and the external model cannot execute concurrently. So

they need to work in a kind of ping-pong mode. That is why we need this

synchronization mechanism.

 

The yield is done inside a normal qemu timer callback. And this is the relevant

code for what I am talking about.

// Install the timer

sim_sync_timer = qemu_new_timer_ns (vm_clock, sim_sync_callback, NULL);

 

-----

 

// This is the callback definition. It just calls the sync function and

reprograms the periodic timer

static void sim_sync_callback (void *p){

  qemutbx_send_sync (qemu_get_clock_ns (vm_clock));

  qemu_mod_timer (sim_sync_timer, qemu_get_clock_ns (vm_clock) +

syncTimerExpiredTime );

}

 

------

 

// This is the function where we yield to the external program

int qemu_send_sync (unsigned long long vmtime)

{

    struct qemu_message msg;

    memset(&msg,0,sizeof(struct qemutbx_message));

    //vm_stop_sync();

    msg.mtype   = QEMU_MESSAGE_SYNC;

    msg.mAck    = QEMU_MESSAGE_SYNC_DONE;

    msg.vm_time = vmtime;

 

// send the sync message to the external program. We will wait here until the

external program replies back

    qemu_send_msg_and_wait_ack(&msg); // This is just blocking TCP send and

receive

    //vm_start();

    return 0;

}

 

 

What we want is that this time where the external process is executing and qemu

is waiting, was completely transparent to the software, drivers, etc, running

inside qemu. And we do not care if clocks and time inside qemu deviate from

real wall clock time. What we want is that this external execution time is not

seen by qemu and the guest in general. So, for example if qemu runs for 2

seconds of virtual time, then yields to the external process that takes 3

seconds to process, what we expect is that when qemu resumes it does at virtual

time 2, without trying to synchronize at all with the real time on the host.

Like if the 3 seconds of real time hadn't existed.

 

So far, I have been trying with linux clocksources (to change from the default

kvm-clock), vm_stop and vm_start (so that the yield to external happens inside

a vm_stop / vm_start block), but nothing seems to work as I expect.

 

For example, some driver code seems to time out, because it is probably seeing

the time that this external process is running (and qemu isn't) as time that

has elapsed from its point of view.

 

Perhaps this would be easier without KVM (I don't know), but KVM is a must

too...

 

Can someone give some pointers as to what we should do to achieve this? Any

idea would be greatly appreciated.

 

Thanks in advance,

Luis