Re: generate random numbers

["michele.paolino" <michele.paolino@studio.unibo.it>]

[-- Attachment #1.1: Type: text/plain, Size: 1509 bytes --]

Following George's advices I have rewrited my scheduler. But now serial
console's log report me a bug in a function of timer.c

(XEN) ****************************************
(XEN) Panic on CPU 0:
(XEN) Xen BUG at timer.c:184
(XEN) ****************************************

This is caused by cpumask_raise_softirq() in my wake() function. What can I
do?

Michele

On Thu, Feb 25, 2010 at 10:25 PM, George Dunlap <george.dunlap@eu.citrix.com
> wrote:

> The problem is that you're choosing a random vcpu to run, without
> considering whether it *wants* to run or not.  In this case, you're running
> a vcpu before it's even been completely set up yet (write_cr3 is failing
> because the guest *has* no cr3 ready yet).
>
> The normal way schedulers deal with this is to keep one list of all vcpus
> (or all domains), and another list with "runnable" vcpus.  You can keep
> track of which vcpus are runnable with the vcpu_wake() callback and by using
> vcpu_runnable() in schedule().
>
> At very least, your loop in schedule should check vcpu_runnable() before
> selecting it.
>
> -George
>
>
> michele.paolino wrote:
>
>> Here's my random scheduler. It works until I start a virtual machine
>> (error file attached is the serial console's log).
>> In xen call trace there isn't any of my functions.
>> To generate random numbers I'm using the hash (MD5) of NOW() function.
>> I would also Know why at boot time there are two calls at vcpu_init
>> function for vcpu with id = 0 ??
>>
>> Thanks
>> Michele
>>
>
>

[-- Attachment #1.2: Type: text/html, Size: 2105 bytes --]

[-- Attachment #2: log --]
[-- Type: application/octet-stream, Size: 7850 bytes --]

 __  __            _____ _  _    ____  
 \ \/ /___ _ __   |___ /| || |  |___ \ 
  \  // _ \ '_ \    |_ \| || |_   __) |
  /  \  __/ | | |  ___) |__   _| / __/ 
 /_/\_\___|_| |_| |____(_) |_|(_)_____|
                                       
(XEN) Xen version 3.4.2 (root@) (gcc version 4.2.4 (Ubuntu 4.2.4-1ubuntu4)) Fri Feb 26 18:04:47 CET 2010
(XEN) Latest ChangeSet: unavailable
(XEN) Command line: dom0_mem=262144 loglvl=all guest_loglvl=all com1=115200,8n1 console=com1 sched=random
(XEN) Video information:
(XEN)  VGA is text mode 80x25, font 8x16
(XEN) Disc information:
(XEN)  Found 1 MBR signatures
(XEN)  Found 1 EDD information structures
(XEN) Xen-e820 RAM map:
(XEN)  0000000000000000 - 000000000009f000 (usable)
(XEN)  000000000009f000 - 00000000000a0000 (reserved)
(XEN)  00000000000e8000 - 0000000000100000 (reserved)
(XEN)  0000000000100000 - 000000003fff0000 (usable)
(XEN)  000000003fff0000 - 0000000040000000 (ACPI data)
(XEN)  00000000fffbc000 - 0000000100000000 (reserved)
(XEN) System RAM: 1023MB (1048124kB)
(XEN) ACPI: RSDP 000FBDB0, 0014 (r0 QEMU  )
(XEN) ACPI: RSDT 3FFF0000, 0034 (r1 QEMU   QEMURSDT        1 QEMU        1)
(XEN) ACPI: FACP 3FFF01B4, 0074 (r1 QEMU   QEMUFACP        1 QEMU        1)
(XEN) ACPI: DSDT 3FFF0280, 1DD4 (r1   BXPC   BXDSDT        1 INTL 20090521)
(XEN) ACPI: FACS 3FFF0240, 0040
(XEN) ACPI: SSDT 3FFF2054, 09E3 (r1   BXPC   BXSSDT        1 INTL 20090521)
(XEN) ACPI: APIC 3FFF2A38, 00EA (r1 QEMU   QEMUAPIC        1 QEMU        1)
(XEN) ACPI: HPET 3FFF2B90, 0038 (r1 QEMU   QEMUHPET        1 QEMU        1)
(XEN) NUMA turned off
(XEN) Faking a node at 0000000000000000-000000003fff0000
(XEN) Xen heap: 9MB (9808kB)
(XEN) Domain heap initialised
(XEN) found SMP MP-table at 000fbc90
(XEN) DMI 2.4 present.
(XEN) Using APIC driver default
(XEN) ACPI: PM-Timer IO Port: 0xb008
(XEN) ACPI: ACPI SLEEP INFO: pm1x_cnt[b004,0], pm1x_evt[b000,0]
(XEN) ACPI:                  wakeup_vec[3fff024c], vec_size[20]
(XEN) ACPI: Local APIC address 0xfee00000
(XEN) ACPI: LAPIC (acpi_id[0x00] lapic_id[0x00] enabled)
(XEN) Processor #0 6:2 APIC version 20
(XEN) ACPI: LAPIC (acpi_id[0x01] lapic_id[0x01] disabled)
(XEN) ACPI: LAPIC (acpi_id[0x02] lapic_id[0x02] disabled)
(XEN) ACPI: LAPIC (acpi_id[0x03] lapic_id[0x03] disabled)
(XEN) ACPI: LAPIC (acpi_id[0x04] lapic_id[0x04] disabled)
(XEN) ACPI: LAPIC (acpi_id[0x05] lapic_id[0x05] disabled)
(XEN) ACPI: LAPIC (acpi_id[0x06] lapic_id[0x06] disabled)
(XEN) ACPI: LAPIC (acpi_id[0x07] lapic_id[0x07] disabled)
(XEN) ACPI: LAPIC (acpi_id[0x08] lapic_id[0x08] disabled)
(XEN) ACPI: LAPIC (acpi_id[0x09] lapic_id[0x09] disabled)
(XEN) ACPI: LAPIC (acpi_id[0x0a] lapic_id[0x0a] disabled)
(XEN) ACPI: LAPIC (acpi_id[0x0b] lapic_id[0x0b] disabled)
(XEN) ACPI: LAPIC (acpi_id[0x0c] lapic_id[0x0c] disabled)
(XEN) ACPI: LAPIC (acpi_id[0x0d] lapic_id[0x0d] disabled)
(XEN) ACPI: LAPIC (acpi_id[0x0e] lapic_id[0x0e] disabled)
(XEN) ACPI: LAPIC (acpi_id[0x0f] lapic_id[0x0f] disabled)
(XEN) ACPI: IOAPIC (id[0x01] address[0xfec00000] gsi_base[0])
(XEN) IOAPIC[0]: apic_id 1, version 17, address 0xfec00000, GSI 0-23
(XEN) ACPI: INT_SRC_OVR (bus 0 bus_irq 0 global_irq 2 dfl dfl)
(XEN) ACPI: INT_SRC_OVR (bus 0 bus_irq 5 global_irq 5 high level)
(XEN) ACPI: INT_SRC_OVR (bus 0 bus_irq 9 global_irq 9 high level)
(XEN) ACPI: INT_SRC_OVR (bus 0 bus_irq 10 global_irq 10 high level)
(XEN) ACPI: INT_SRC_OVR (bus 0 bus_irq 11 global_irq 11 high level)
(XEN) ACPI: IRQ0 used by override.
(XEN) ACPI: IRQ2 used by override.
(XEN) ACPI: IRQ5 used by override.
(XEN) ACPI: IRQ9 used by override.
(XEN) ACPI: IRQ10 used by override.
(XEN) ACPI: IRQ11 used by override.
(XEN) Enabling APIC mode:  Flat.  Using 1 I/O APICs
(XEN) ACPI: HPET id: 0x8086a201 base: 0xfed00000
(XEN) Using ACPI (MADT) for SMP configuration information
(XEN) Using scheduler: my Random Scheduler (random)
(XEN) 
(XEN) 
(XEN) add VCPU 0
(XEN) 
(XEN) Initializing CPU#0
(XEN) Detected 2533.340 MHz processor.
(XEN) CPU: L1 I cache: 32K, L1 D cache: 32K
(XEN) CPU: L2 cache: 2048K
(XEN) Intel machine check reporting enabled on CPU#0.
(XEN) CMCI: CPU0 has no CMCI support
(XEN) CPU0: Intel QEMU Virtual CPU version 0.11.0 stepping 03
(XEN) Total of 1 processors activated.
(XEN) ENABLING IO-APIC IRQs
(XEN)  -> Using new ACK method
(XEN) ..TIMER: vector=0xF0 apic1=0 pin1=2 apic2=-1 pin2=-1
(XEN) BAD HPET revision id.
(XEN) Platform timer is 3.579MHz ACPI PM Timer
(XEN) Brought up 1 CPUs
(XEN) I/O virtualisation disabled
(XEN) CPUIDLE: disabled due to no HPET. Force enable with 'cpuidle'.
(XEN) ACPI sleep modes: S3
(XEN) mcheck_poll: Machine check polling timer started.
(XEN) 
(XEN) 
(XEN) add VCPU 0
(XEN) 
(XEN) *** LOADING DOMAIN 0 ***
(XEN)  Xen  kernel: 32-bit, PAE, lsb
(XEN)  Dom0 kernel: 32-bit, PAE, lsb, paddr 0xc0100000 -> 0xc048d33c
(XEN) PHYSICAL MEMORY ARRANGEMENT:
(XEN)  Dom0 alloc.:   000000003c000000->000000003e000000 (57344 pages to be allocated)
(XEN) VIRTUAL MEMORY ARRANGEMENT:
(XEN)  Loaded kernel: c0100000->c048d33c
(XEN)  Init. ramdisk: c048e000->c12ec200
(XEN)  Phys-Mach map: c12ed000->c132d000
(XEN)  Start info:    c132d000->c132d47c
(XEN)  Page tables:   c132e000->c133d000
(XEN)  Boot stack:    c133d000->c133e000
(XEN)  TOTAL:         c0000000->c1400000
(XEN)  ENTRY ADDRESS: c0100000
(XEN) Dom0 has maximum 1 VCPUs
(XEN) Scrubbing Free RAM: .......done.
(XEN) Xen trace buffers: disabled
(XEN) Std. Loglevel: All
(XEN) Guest Loglevel: All
(XEN) *** Serial input -> DOM0 (type 'CTRL-a' three times to switch input to Xen)
(XEN) 
(XEN) 
(XEN) WAKE UP!!!!!!!!!!!!
(XEN) 
(XEN) 
(XEN) I'm setting the mask for the current vcpu
(XEN) 
(XEN) 
(XEN) Init Random Number Generator
(XEN) Inizializzo il random con la parola ff227e48
(XEN) 
(XEN) Updating Random Generator
(XEN) Freed 116kB init memory.
(XEN) Xen BUG at timer.c:184
(XEN) ----[ Xen-3.4.2  x86_32p  debug=n  Not tainted ]----
(XEN) CPU:    0
(XEN) EIP:    e008:[<ff1198c5>] remove_entry+0x15/0x80
(XEN) EFLAGS: 00010006   CONTEXT: hypervisor
(XEN) eax: ff204100   ebx: ffbfc2d4   ecx: 00000000   edx: 0000001a
(XEN) esi: 00000260   edi: 00000011   ebp: ff204100   esp: ff227eb8
(XEN) cr0: 8005003b   cr4: 000006f0   cr3: 00100120   cr2: 00000000
(XEN) ds: e010   es: e010   fs: e010   gs: e010   ss: e010   cs: e008
(XEN) Xen stack trace from esp=ff227eb8:
(XEN)    ff27c410 0000001a 00000260 ff119e69 ff204100 ff204100 00000000 ff204100
(XEN)    ff204100 00000000 00000292 72c15df2 00000000 ffbfc2b0 ffbfa000 ff11610f
(XEN)    ffbfc2d4 00000260 00000011 ff204100 ff204100 ff204100 72c09aa2 00000000
(XEN)    ffbfc2b0 72c0866b 00000000 ff116be3 ffbfc2b0 73591ceb 00000000 ff138db2
(XEN)    ff24e214 00000000 00000000 ff204090 00989680 00000000 00000000 ff1d6b40
(XEN)    ff204080 00000001 0000e008 00000282 ff1d6b40 0000000a ff1ca378 ffbfc2b0
(XEN)    00989680 00000000 ff239ff9 00000000 ff227fb4 ff2044b0 00000000 ff117bf5
(XEN)    00000000 ff227fb4 ff227fb4 ff1369b3 ffbfa000 ff08bf30 00000000 00000000
(XEN)    00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
(XEN)    00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
(XEN)    00000000 ffbfa000
(XEN) Xen call trace:
(XEN)    [<ff1198c5>] remove_entry+0x15/0x80
(XEN)    [<ff119e69>] set_timer+0x129/0x190
(XEN)    [<ff11610f>] vcpu_periodic_timer_work+0x6f/0xb0
(XEN)    [<ff116be3>] schedule+0x1a3/0x410
(XEN)    [<ff138db2>] common_interrupt+0x52/0x60
(XEN)    [<ff117bf5>] do_softirq+0x35/0x70
(XEN)    [<ff1369b3>] idle_loop+0x43/0x90
(XEN)    
(XEN) 
(XEN) ****************************************
(XEN) Panic on CPU 0:
(XEN) Xen BUG at timer.c:184
(XEN) ****************************************
(XEN) 
(XEN) Reboot in five seconds...

[-- Attachment #3: sched_random.c --]
[-- Type: text/x-csrc, Size: 4939 bytes --]

#include <xen/lib.h>
#include <xen/sched.h>
#include <xen/time.h>
#include <xen/sched-if.h>
#include <xen/softirq.h>
#include <xen/errno.h>
#include <xen/list.h>
#include <xen/timer.h>
#include <xen/randmd5.h>

int tot_vcpu=0;
MD5_CTX mdContext;

#define RAND_PCPU(_c)     ((struct random_pcpu *)per_cpu(schedule_data, _c).sched_priv)
#define RAND_VCPU(_vcpu)  ((struct random_vcpu *) (_vcpu)->sched_priv)
#define RUNQ(_cpu)        (&(RAND_PCPU(_cpu)->runq))

struct random_pcpu {
    struct list_head runq;
};

struct random_vcpu{
    struct list_head active_vcpu_elem; //all
    struct list_head runq_elem; //runnable
    struct vcpu *vcpu;
};

static int random_pcpu_init(int cpu);
static inline void __runq_insert(unsigned int cpu, struct random_vcpu *svc);

static int random_vcpu_init(struct vcpu *vc){
    struct random_vcpu *svc;

    svc = xmalloc(struct random_vcpu);
    if ( svc == NULL )
        return -1;
    memset(svc, 0, sizeof(*svc));
  
    INIT_LIST_HEAD(&svc->active_vcpu_elem);
    INIT_LIST_HEAD(&svc->runq_elem);

    svc->vcpu = vc;
    vc->sched_priv = svc;

  /* Allocate per-PCPU info */
    if ( unlikely(!RAND_PCPU(vc->processor)) )
    {
        if ( random_pcpu_init(vc->processor) != 0 )
            return -1;
    }

    //check CSCHED_VCPU_CHECK

    tot_vcpu++; 
    printk("\nadd VCPU %d\n", vc->vcpu_id);
    return 0;
}

static int random_pcpu_init(int cpu)
{
    struct random_pcpu *spc;
    /* Allocate per-PCPU info */
    spc = xmalloc(struct random_pcpu);
    if ( spc == NULL )
        return -1;
    memset(spc, 0, sizeof(*spc));
    INIT_LIST_HEAD(&spc->runq);
    per_cpu(schedule_data, cpu).sched_priv = spc;
    return 0;
}


static void random_vcpu_destroy(struct vcpu *v)
{
    printk("\n\nDESTROYING VCPU %d\n\n",v->vcpu_id);
    /*
    struct csched_vcpu * const svc = CSCHED_VCPU(vc);
    struct csched_dom * const sdom = svc->sdom;
    unsigned long flags;

    CSCHED_STAT_CRANK(vcpu_destroy);

    BUG_ON( sdom == NULL );
    BUG_ON( !list_empty(&svc->runq_elem) );

    spin_lock_irqsave(&csched_priv.lock, flags);

    if ( !list_empty(&svc->active_vcpu_elem) )
        __csched_vcpu_acct_stop_locked(svc);

    spin_unlock_irqrestore(&csched_priv.lock, flags);

    xfree(svc);*/
}


struct task_slice random_schedule(s_time_t now){
    const unsigned int cpu = smp_processor_id();
    struct list_head *runq = RUNQ(cpu);
    struct random_vcpu * const scurr = RAND_VCPU(current);
    struct random_vcpu *snext;
    struct task_slice ret;
    int next_vcpu=0;

    next_vcpu = (MD5Final (&mdContext))  % tot_vcpu;

    /*
     * Select next runnable local VCPU (ie top of local runq)
     */
    if ( vcpu_runnable(current) )
        __runq_insert(cpu, scurr);
  //  else
  //      BUG_ON( is_idle_vcpu(current) || list_empty(runq) );


    while (next_vcpu==0){
        next_vcpu--;
        runq=runq->next;
    }
    snext = list_entry(runq->next, struct random_vcpu, runq_elem);

    ret.time = MILLISECS(10);
    ret.task = snext->vcpu;

    return ret;
}


static void __random_init(void){
    unsigned char digest[16];
    int i;
    long unsigned int mask= 0xFF;
    long unsigned int string_now = NOW();
    MD5Init (&mdContext);
    printk("\n\nInit Random Number Generator\n");
    for (i=0;i<8;i++){
        digest[i]=(char) ((string_now & mask) >> 8*i);
        mask <<=8;
    }
    printk("Inizializzo il random con la parola %x", (unsigned int) digest);
    MD5Update (&mdContext, (unsigned char*)digest, sizeof(s_time_t));
    printk("\n\nUpdating Random Generator\n");

}

static void random_vcpu_wake( struct vcpu *vc){
    struct random_vcpu * const svc = RAND_VCPU(vc);
    const unsigned int cpu = vc->processor;
    cpumask_t mask;

    cpus_clear(mask);
    /* Put the VCPU on the runq and tickle CPUs */
    __runq_insert(cpu, svc);  //inserisce in coda la vcpu
    //    __runq_tickle(cpu, svc);  // raise softirq   

    printk("\n\nWAKE UP!!!!!!!!!!!!\n\n");
    if ( unlikely(!list_empty(&svc->runq_elem)) )
    {
        return;
    }

    if ( !is_idle_vcpu(vc) && likely(vcpu_runnable(vc)) ) 
    {
        cpu_set(cpu, mask);
        printk("\nI'm setting the mask for the current vcpu\n");
    }
    if ( !cpus_empty(mask) )
        cpumask_raise_softirq(mask, SCHEDULE_SOFTIRQ);    


    //cpu_raise_softirq(cpu,SCHEDULE_SOFTIRQ);
    __random_init();
    return;
}


static inline void __runq_insert(unsigned int cpu, struct random_vcpu *svc)
{
    const struct list_head * const runq = RUNQ(cpu);
    struct list_head *iter;

    list_for_each( iter, runq )
    {	
        list_add_tail(&svc->runq_elem, iter);
    }
    return; 
}

struct scheduler sched_rand_def = {
    .name           = "my Random Scheduler",
    .opt_name       = "random",
    .sched_id       = 17,
    .init_vcpu      = random_vcpu_init,
    .wake           = random_vcpu_wake,
    .destroy_vcpu   = random_vcpu_destroy,
    .do_schedule    = random_schedule,

};




[-- Attachment #4: Type: text/plain, Size: 138 bytes --]

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xensource.com
http://lists.xensource.com/xen-devel