← Back to branch summary

~ressu/+junk/xen-ubuntu

« back to all changes in this revision

Viewing changes to xen/arch/x86/oprofile/op_model_p4.c

  • Committer: sami at haahtinen
  • Date: 2011-05-23 19:11:45 UTC
  • mfrom: (3.1.3 xen)
  • Revision ID: sami@haahtinen.name-20110523191145-55rhsn3endndbbge
* Upload new version to ppa, base off the 4.1.0 package in debian
* Re-enable hvmloader:
  - Use packaged ipxe.
* Workaround incompatibility with xenstored of Xen 4.0.
* New upstream release.
* New upstream release candidate.
* Build documentation using pdflatex.
* Use python 2.6. (closes: #596545)
* Fix lintian override.
* Install new tools: xl, xenpaging.
* Enable blktap2.
  - Use own md5 implementation.
  - Fix includes.
  - Fix linking of blktap2 binaries.
  - Remove optimization setting.
* Temporarily disable hvmloader, wants to download ipxe.
* Remove xenstored pid check from xl.

Show diffs side-by-side

added added

removed removed

Lines of Context:
xen/arch/x86/oprofile/op_model_p4.c
347
347
};
348
348
 
349
349
 
350
 
#define MISC_PMC_ENABLED_P(x) ((x) & 1 << 7)
 
350
#define MISC_PMC_ENABLED_P(x) ((x) & 1ULL << 7)
351
351
 
352
 
#define ESCR_RESERVED_BITS 0x80000003
 
352
#define ESCR_RESERVED_BITS 0x80000003ULL
353
353
#define ESCR_CLEAR(escr) ((escr) &= ESCR_RESERVED_BITS)
354
 
#define ESCR_SET_USR_0(escr, usr) ((escr) |= (((usr) & 1) << 2))
355
 
#define ESCR_SET_OS_0(escr, os) ((escr) |= (((os) & 1) << 3))
356
 
#define ESCR_SET_USR_1(escr, usr) ((escr) |= (((usr) & 1)))
357
 
#define ESCR_SET_OS_1(escr, os) ((escr) |= (((os) & 1) << 1))
358
 
#define ESCR_SET_EVENT_SELECT(escr, sel) ((escr) |= (((sel) & 0x3f) << 25))
359
 
#define ESCR_SET_EVENT_MASK(escr, mask) ((escr) |= (((mask) & 0xffff) << 9))
360
 
#define ESCR_READ(escr,high,ev,i) do {rdmsr(ev->bindings[(i)].escr_address, (escr), (high));} while (0)
361
 
#define ESCR_WRITE(escr,high,ev,i) do {wrmsr(ev->bindings[(i)].escr_address, (escr), (high));} while (0)
 
354
#define ESCR_SET_USR_0(escr, usr) ((escr) |= (((usr) & 1ULL) << 2))
 
355
#define ESCR_SET_OS_0(escr, os) ((escr) |= (((os) & 1ULL) << 3))
 
356
#define ESCR_SET_USR_1(escr, usr) ((escr) |= (((usr) & 1ULL)))
 
357
#define ESCR_SET_OS_1(escr, os) ((escr) |= (((os) & 1ULL) << 1))
 
358
#define ESCR_SET_EVENT_SELECT(escr, sel) ((escr) |= (((sel) & 0x3fULL) << 25))
 
359
#define ESCR_SET_EVENT_MASK(escr, mask) ((escr) |= (((mask) & 0xffffULL) << 9))
 
360
#define ESCR_READ(escr,ev,i) do {rdmsrl(ev->bindings[(i)].escr_address, (escr));} while (0)
 
361
#define ESCR_WRITE(escr,ev,i) do {wrmsrl(ev->bindings[(i)].escr_address, (escr));} while (0)
362
362
 
363
 
#define CCCR_RESERVED_BITS 0x38030FFF
 
363
#define CCCR_RESERVED_BITS 0x38030FFFULL
364
364
#define CCCR_CLEAR(cccr) ((cccr) &= CCCR_RESERVED_BITS)
365
 
#define CCCR_SET_REQUIRED_BITS(cccr) ((cccr) |= 0x00030000)
366
 
#define CCCR_SET_ESCR_SELECT(cccr, sel) ((cccr) |= (((sel) & 0x07) << 13))
367
 
#define CCCR_SET_PMI_OVF_0(cccr) ((cccr) |= (1<<26))
368
 
#define CCCR_SET_PMI_OVF_1(cccr) ((cccr) |= (1<<27))
369
 
#define CCCR_SET_ENABLE(cccr) ((cccr) |= (1<<12))
370
 
#define CCCR_SET_DISABLE(cccr) ((cccr) &= ~(1<<12))
371
 
#define CCCR_READ(low, high, i) do {rdmsr(p4_counters[(i)].cccr_address, (low), (high));} while (0)
372
 
#define CCCR_WRITE(low, high, i) do {wrmsr(p4_counters[(i)].cccr_address, (low), (high));} while (0)
373
 
#define CCCR_OVF_P(cccr) ((cccr) & (1U<<31))
374
 
#define CCCR_CLEAR_OVF(cccr) ((cccr) &= (~(1U<<31)))
 
365
#define CCCR_SET_REQUIRED_BITS(cccr) ((cccr) |= 0x00030000ULL)
 
366
#define CCCR_SET_ESCR_SELECT(cccr, sel) ((cccr) |= (((sel) & 0x07ULL) << 13))
 
367
#define CCCR_SET_PMI_OVF_0(cccr) ((cccr) |= (1ULL<<26))
 
368
#define CCCR_SET_PMI_OVF_1(cccr) ((cccr) |= (1ULL<<27))
 
369
#define CCCR_SET_ENABLE(cccr) ((cccr) |= (1ULL<<12))
 
370
#define CCCR_SET_DISABLE(cccr) ((cccr) &= ~(1ULL<<12))
 
371
#define CCCR_READ(msr_content, i) do {rdmsrl(p4_counters[(i)].cccr_address, (msr_content));} while (0)
 
372
#define CCCR_WRITE(msr_content, i) do {wrmsrl(p4_counters[(i)].cccr_address, (msr_content));} while (0)
 
373
#define CCCR_OVF_P(cccr) ((cccr) & (1ULL<<31))
 
374
#define CCCR_CLEAR_OVF(cccr) ((cccr) &= (~(1ULL<<31)))
375
375
 
376
 
#define CTR_READ(l,h,i) do {rdmsr(p4_counters[(i)].counter_address, (l), (h));} while (0)
377
 
#define CTR_WRITE(l,i) do {wrmsr(p4_counters[(i)].counter_address, -(u32)(l), -1);} while (0)
378
 
#define CTR_OVERFLOW_P(ctr) (!((ctr) & 0x80000000))
 
376
#define CTR_READ(msr_content,i) do {rdmsrl(p4_counters[(i)].counter_address, (msr_content));} while (0)
 
377
#define CTR_WRITE(msr_content,i) do {wrmsrl(p4_counters[(i)].counter_address, -(msr_content));} while (0)
 
378
#define CTR_OVERFLOW_P(ctr) (!((ctr) & 0x80000000ULL))
379
379
 
380
380
 
381
381
/* this assigns a "stagger" to the current CPU, which is used throughout
481
481
{
482
482
        int i;
483
483
        int const maxbind = 2;
484
 
        unsigned int cccr = 0;
485
 
        unsigned int escr = 0;
486
 
        unsigned int high = 0;
 
484
        uint64_t cccr = 0;
 
485
        uint64_t escr = 0;
487
486
        unsigned int counter_bit;
488
487
        const struct p4_event_binding *ev = NULL;
489
488
        unsigned int stag;
507
506
                if (ev->bindings[i].virt_counter & counter_bit) {
508
507
 
509
508
                        /* modify ESCR */
510
 
                        ESCR_READ(escr, high, ev, i);
 
509
                        ESCR_READ(escr, ev, i);
511
510
                        ESCR_CLEAR(escr);
512
511
                        if (stag == 0) {
513
512
                                ESCR_SET_USR_0(escr, counter_config[ctr].user);
518
517
                        }
519
518
                        ESCR_SET_EVENT_SELECT(escr, ev->event_select);
520
519
                        ESCR_SET_EVENT_MASK(escr, counter_config[ctr].unit_mask);                       
521
 
                        ESCR_WRITE(escr, high, ev, i);
 
520
                        ESCR_WRITE(escr, ev, i);
522
521
                       
523
522
                        /* modify CCCR */
524
 
                        CCCR_READ(cccr, high, VIRT_CTR(stag, ctr));
 
523
                        CCCR_READ(cccr, VIRT_CTR(stag, ctr));
525
524
                        CCCR_CLEAR(cccr);
526
525
                        CCCR_SET_REQUIRED_BITS(cccr);
527
526
                        CCCR_SET_ESCR_SELECT(cccr, ev->escr_select);
530
529
                        } else {
531
530
                                CCCR_SET_PMI_OVF_1(cccr);
532
531
                        }
533
 
                        CCCR_WRITE(cccr, high, VIRT_CTR(stag, ctr));
 
532
                        CCCR_WRITE(cccr, VIRT_CTR(stag, ctr));
534
533
                        return;
535
534
                }
536
535
        }
544
543
static void p4_setup_ctrs(struct op_msrs const * const msrs)
545
544
{
546
545
        unsigned int i;
547
 
        unsigned int low, high;
 
546
        uint64_t msr_content;
548
547
        unsigned int addr;
549
548
        unsigned int stag;
550
549
 
551
550
        stag = get_stagger();
552
551
 
553
 
        rdmsr(MSR_IA32_MISC_ENABLE, low, high);
554
 
        if (! MISC_PMC_ENABLED_P(low)) {
 
552
        rdmsrl(MSR_IA32_MISC_ENABLE, msr_content);
 
553
        if (! MISC_PMC_ENABLED_P(msr_content)) {
555
554
                printk(KERN_ERR "oprofile: P4 PMC not available\n");
556
555
                return;
557
556
        }
558
557
 
559
558
        /* clear the cccrs we will use */
560
559
        for (i = 0 ; i < num_counters ; i++) {
561
 
                rdmsr(p4_counters[VIRT_CTR(stag, i)].cccr_address, low, high);
562
 
                CCCR_CLEAR(low);
563
 
                CCCR_SET_REQUIRED_BITS(low);
564
 
                wrmsr(p4_counters[VIRT_CTR(stag, i)].cccr_address, low, high);
 
560
                rdmsrl(p4_counters[VIRT_CTR(stag, i)].cccr_address, msr_content);
 
561
                CCCR_CLEAR(msr_content);
 
562
                CCCR_SET_REQUIRED_BITS(msr_content);
 
563
                wrmsrl(p4_counters[VIRT_CTR(stag, i)].cccr_address, msr_content);
565
564
        }
566
565
 
567
566
        /* clear cccrs outside our concern */
568
567
        for (i = stag ; i < NUM_UNUSED_CCCRS ; i += addr_increment()) {
569
 
                rdmsr(p4_unused_cccr[i], low, high);
570
 
                CCCR_CLEAR(low);
571
 
                CCCR_SET_REQUIRED_BITS(low);
572
 
                wrmsr(p4_unused_cccr[i], low, high);
 
568
                rdmsrl(p4_unused_cccr[i], msr_content);
 
569
                CCCR_CLEAR(msr_content);
 
570
                CCCR_SET_REQUIRED_BITS(msr_content);
 
571
                wrmsrl(p4_unused_cccr[i], msr_content);
573
572
        }
574
573
 
575
574
        /* clear all escrs (including those outside our concern) */
576
575
        for (addr = MSR_P4_BSU_ESCR0 + stag;
577
576
             addr <  MSR_P4_IQ_ESCR0; addr += addr_increment()) {
578
 
                wrmsr(addr, 0, 0);
 
577
                wrmsrl(addr, 0x0ULL);
579
578
        }
580
579
 
581
580
        /* On older models clear also MSR_P4_IQ_ESCR0/1 */
582
581
        if (boot_cpu_data.x86_model < 0x3) {
583
 
                wrmsr(MSR_P4_IQ_ESCR0, 0, 0);
584
 
                wrmsr(MSR_P4_IQ_ESCR1, 0, 0);
 
582
                wrmsrl(MSR_P4_IQ_ESCR0, 0x0ULL);
 
583
                wrmsrl(MSR_P4_IQ_ESCR1, 0x0ULL);
585
584
        }
586
585
 
587
586
        for (addr = MSR_P4_RAT_ESCR0 + stag;
588
587
             addr <= MSR_P4_SSU_ESCR0; ++i, addr += addr_increment()) {
589
 
                wrmsr(addr, 0, 0);
 
588
                wrmsrl(addr, 0x0ULL);
590
589
        }
591
590
        
592
591
        for (addr = MSR_P4_MS_ESCR0 + stag;
593
592
             addr <= MSR_P4_TC_ESCR1; addr += addr_increment()){ 
594
 
                wrmsr(addr, 0, 0);
 
593
                wrmsrl(addr, 0x0ULL);
595
594
        }
596
595
        
597
596
        for (addr = MSR_P4_IX_ESCR0 + stag;
598
597
             addr <= MSR_P4_CRU_ESCR3; addr += addr_increment()){ 
599
 
                wrmsr(addr, 0, 0);
 
598
                wrmsrl(addr, 0x0ULL);
600
599
        }
601
600
 
602
601
        if (num_counters == NUM_COUNTERS_NON_HT) {              
603
 
                wrmsr(MSR_P4_CRU_ESCR4, 0, 0);
604
 
                wrmsr(MSR_P4_CRU_ESCR5, 0, 0);
 
602
                wrmsrl(MSR_P4_CRU_ESCR4, 0x0ULL);
 
603
                wrmsrl(MSR_P4_CRU_ESCR5, 0x0ULL);
605
604
        } else if (stag == 0) {
606
 
                wrmsr(MSR_P4_CRU_ESCR4, 0, 0);
 
605
                wrmsrl(MSR_P4_CRU_ESCR4, 0x0ULL);
607
606
        } else {
608
 
                wrmsr(MSR_P4_CRU_ESCR5, 0, 0);
 
607
                wrmsrl(MSR_P4_CRU_ESCR5, 0x0ULL);
609
608
        }               
610
609
        
611
610
        /* setup all counters */
624
623
                         struct op_msrs const * const msrs,
625
624
                         struct cpu_user_regs * const regs)
626
625
{
627
 
        unsigned long ctr, low, high, stag, real;
 
626
        unsigned long ctr, stag, real;
 
627
        uint64_t msr_content;
628
628
        int i;
629
629
        int ovf = 0;
630
630
        unsigned long eip = regs->eip;
656
656
                
657
657
                real = VIRT_CTR(stag, i);
658
658
 
659
 
                CCCR_READ(low, high, real);
660
 
                CTR_READ(ctr, high, real);
661
 
                if (CCCR_OVF_P(low) || CTR_OVERFLOW_P(ctr)) {
 
659
                CCCR_READ(msr_content, real);
 
660
                CTR_READ(ctr, real);
 
661
                if (CCCR_OVF_P(msr_content) || CTR_OVERFLOW_P(ctr)) {
662
662
                        xenoprof_log_event(current, regs, eip, mode, i);
663
663
                        CTR_WRITE(reset_value[i], real);
664
 
                        CCCR_CLEAR_OVF(low);
665
 
                        CCCR_WRITE(low, high, real);
 
664
                        CCCR_CLEAR_OVF(msr_content);
 
665
                        CCCR_WRITE(msr_content, real);
666
666
                        CTR_WRITE(reset_value[i], real);
667
667
                        ovf = 1;
668
668
                }
677
677
 
678
678
static void p4_start(struct op_msrs const * const msrs)
679
679
{
680
 
        unsigned int low, high, stag;
 
680
        unsigned int stag;
 
681
        uint64_t msr_content;
681
682
        int i;
682
683
 
683
684
        stag = get_stagger();
685
686
        for (i = 0; i < num_counters; ++i) {
686
687
                if (!reset_value[i])
687
688
                        continue;
688
 
                CCCR_READ(low, high, VIRT_CTR(stag, i));
689
 
                CCCR_SET_ENABLE(low);
690
 
                CCCR_WRITE(low, high, VIRT_CTR(stag, i));
 
689
                CCCR_READ(msr_content, VIRT_CTR(stag, i));
 
690
                CCCR_SET_ENABLE(msr_content);
 
691
                CCCR_WRITE(msr_content, VIRT_CTR(stag, i));
691
692
        }
692
693
}
693
694
 
694
695
 
695
696
static void p4_stop(struct op_msrs const * const msrs)
696
697
{
697
 
        unsigned int low, high, stag;
 
698
        unsigned int stag;
 
699
        uint64_t msr_content;
698
700
        int i;
699
701
 
700
702
        stag = get_stagger();
701
703
 
702
704
        for (i = 0; i < num_counters; ++i) {
703
 
                CCCR_READ(low, high, VIRT_CTR(stag, i));
704
 
                CCCR_SET_DISABLE(low);
705
 
                CCCR_WRITE(low, high, VIRT_CTR(stag, i));
 
705
                CCCR_READ(msr_content, VIRT_CTR(stag, i));
 
706
                CCCR_SET_DISABLE(msr_content);
 
707
                CCCR_WRITE(msr_content, VIRT_CTR(stag, i));
706
708
        }
707
709
}
708
710