/srv/pokybuild/yocto-worker/reproducible/build/build-st/tmp/work/x86_64-linux/diffoscope-native/208-r0/recipe-sysroot-native/usr/bin/diffoscope.real --no-default-limits --max-report-size 262144000 --exclude-directory-metadata yes --html-dir /srv/autobuilder/valkyrie.yocto.io/pub/repro-fail/oe-reproducible-20250308-s52sakkc/packages/diff-html reproducibleA reproducibleB

615

static·inline·void·_nocheck__trace_pic_update_irq(bool·master,·uint8_t·imr,·uint8_t·irr,·uint8_t·padd)

615

static·inline·void·_nocheck__trace_pic_update_irq(bool·master,·uint8_t·imr,·uint8_t·irr,·uint8_t·padd)

616

{

616

{

617

····if·(trace_event_get_state(TRACE_PIC_UPDATE_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

617

····if·(trace_event_get_state(TRACE_PIC_UPDATE_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

618

········if·(message_with_timestamp)·{

618

········if·(message_with_timestamp)·{

619

············struct·timeval·_now;

619

············struct·timeval·_now;

620

············gettimeofday(&_now,·NULL);

620

············gettimeofday(&_now,·NULL);

622

············qemu_log("%d@%zu.%06zu:pic_update_irq·"·"master·%d·imr·%"PRIu8"·irr·%"PRIu8"·padd·%"PRIu8·"\n",

622

············qemu_log("%d@%zu.%06zu:pic_update_irq·"·"master·%d·imr·%"PRIu8"·irr·%"PRIu8"·padd·%"PRIu8·"\n",

623

·····················qemu_get_thread_id(),

623

·····················qemu_get_thread_id(),

624

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

624

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

625

·····················,·master,·imr,·irr,·padd);

625

·····················,·master,·imr,·irr,·padd);

626

#line·628·"trace/trace-hw_intc.h"

626

#line·628·"trace/trace-hw_intc.h"

627

········}·else·{

627

········}·else·{

629

············qemu_log("pic_update_irq·"·"master·%d·imr·%"PRIu8"·irr·%"PRIu8"·padd·%"PRIu8·"\n",·master,·imr,·irr,·padd);

629

············qemu_log("pic_update_irq·"·"master·%d·imr·%"PRIu8"·irr·%"PRIu8"·padd·%"PRIu8·"\n",·master,·imr,·irr,·padd);

630

#line·632·"trace/trace-hw_intc.h"

630

#line·632·"trace/trace-hw_intc.h"

631

········}

631

········}

632

····}

632

····}

633

}

633

}

634

static·inline·void·trace_pic_update_irq(bool·master,·uint8_t·imr,·uint8_t·irr,·uint8_t·padd)

634

static·inline·void·trace_pic_update_irq(bool·master,·uint8_t·imr,·uint8_t·irr,·uint8_t·padd)

646

static·inline·void·_nocheck__trace_pic_set_irq(bool·master,·int·irq,·int·level)

646

static·inline·void·_nocheck__trace_pic_set_irq(bool·master,·int·irq,·int·level)

647

{

647

{

648

····if·(trace_event_get_state(TRACE_PIC_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

648

····if·(trace_event_get_state(TRACE_PIC_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

649

········if·(message_with_timestamp)·{

649

········if·(message_with_timestamp)·{

650

············struct·timeval·_now;

650

············struct·timeval·_now;

651

············gettimeofday(&_now,·NULL);

651

············gettimeofday(&_now,·NULL);

653

············qemu_log("%d@%zu.%06zu:pic_set_irq·"·"master·%d·irq·%d·level·%d"·"\n",

653

············qemu_log("%d@%zu.%06zu:pic_set_irq·"·"master·%d·irq·%d·level·%d"·"\n",

654

·····················qemu_get_thread_id(),

654

·····················qemu_get_thread_id(),

655

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

655

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

656

·····················,·master,·irq,·level);

656

·····················,·master,·irq,·level);

657

#line·659·"trace/trace-hw_intc.h"

657

#line·659·"trace/trace-hw_intc.h"

658

········}·else·{

658

········}·else·{

660

············qemu_log("pic_set_irq·"·"master·%d·irq·%d·level·%d"·"\n",·master,·irq,·level);

660

············qemu_log("pic_set_irq·"·"master·%d·irq·%d·level·%d"·"\n",·master,·irq,·level);

661

#line·663·"trace/trace-hw_intc.h"

661

#line·663·"trace/trace-hw_intc.h"

662

········}

662

········}

663

····}

663

····}

664

}

664

}

665

static·inline·void·trace_pic_set_irq(bool·master,·int·irq,·int·level)

665

static·inline·void·trace_pic_set_irq(bool·master,·int·irq,·int·level)

677

static·inline·void·_nocheck__trace_pic_interrupt(int·irq,·int·intno)

677

static·inline·void·_nocheck__trace_pic_interrupt(int·irq,·int·intno)

678

{

678

{

679

····if·(trace_event_get_state(TRACE_PIC_INTERRUPT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

679

····if·(trace_event_get_state(TRACE_PIC_INTERRUPT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

680

········if·(message_with_timestamp)·{

680

········if·(message_with_timestamp)·{

681

············struct·timeval·_now;

681

············struct·timeval·_now;

682

············gettimeofday(&_now,·NULL);

682

············gettimeofday(&_now,·NULL);

684

············qemu_log("%d@%zu.%06zu:pic_interrupt·"·"irq·%d·intno·%d"·"\n",

684

············qemu_log("%d@%zu.%06zu:pic_interrupt·"·"irq·%d·intno·%d"·"\n",

685

·····················qemu_get_thread_id(),

685

·····················qemu_get_thread_id(),

686

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

686

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

687

·····················,·irq,·intno);

687

·····················,·irq,·intno);

688

#line·690·"trace/trace-hw_intc.h"

688

#line·690·"trace/trace-hw_intc.h"

689

········}·else·{

689

········}·else·{

691

············qemu_log("pic_interrupt·"·"irq·%d·intno·%d"·"\n",·irq,·intno);

691

············qemu_log("pic_interrupt·"·"irq·%d·intno·%d"·"\n",·irq,·intno);

692

#line·694·"trace/trace-hw_intc.h"

692

#line·694·"trace/trace-hw_intc.h"

693

········}

693

········}

694

····}

694

····}

695

}

695

}

696

static·inline·void·trace_pic_interrupt(int·irq,·int·intno)

696

static·inline·void·trace_pic_interrupt(int·irq,·int·intno)

708

static·inline·void·_nocheck__trace_pic_ioport_write(bool·master,·uint64_t·addr,·uint64_t·val)

708

static·inline·void·_nocheck__trace_pic_ioport_write(bool·master,·uint64_t·addr,·uint64_t·val)

709

{

709

{

710

····if·(trace_event_get_state(TRACE_PIC_IOPORT_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

710

····if·(trace_event_get_state(TRACE_PIC_IOPORT_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

711

········if·(message_with_timestamp)·{

711

········if·(message_with_timestamp)·{

712

············struct·timeval·_now;

712

············struct·timeval·_now;

713

············gettimeofday(&_now,·NULL);

713

············gettimeofday(&_now,·NULL);

715

············qemu_log("%d@%zu.%06zu:pic_ioport_write·"·"master·%d·addr·0x%"PRIx64"·val·0x%"PRIx64·"\n",

715

············qemu_log("%d@%zu.%06zu:pic_ioport_write·"·"master·%d·addr·0x%"PRIx64"·val·0x%"PRIx64·"\n",

716

·····················qemu_get_thread_id(),

716

·····················qemu_get_thread_id(),

717

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

717

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

718

·····················,·master,·addr,·val);

718

·····················,·master,·addr,·val);

719

#line·721·"trace/trace-hw_intc.h"

719

#line·721·"trace/trace-hw_intc.h"

720

········}·else·{

720

········}·else·{

722

············qemu_log("pic_ioport_write·"·"master·%d·addr·0x%"PRIx64"·val·0x%"PRIx64·"\n",·master,·addr,·val);

722

············qemu_log("pic_ioport_write·"·"master·%d·addr·0x%"PRIx64"·val·0x%"PRIx64·"\n",·master,·addr,·val);

723

#line·725·"trace/trace-hw_intc.h"

723

#line·725·"trace/trace-hw_intc.h"

724

········}

724

········}

725

····}

725

····}

726

}

726

}

727

static·inline·void·trace_pic_ioport_write(bool·master,·uint64_t·addr,·uint64_t·val)

727

static·inline·void·trace_pic_ioport_write(bool·master,·uint64_t·addr,·uint64_t·val)

739

static·inline·void·_nocheck__trace_pic_ioport_read(bool·master,·uint64_t·addr,·int·val)

739

static·inline·void·_nocheck__trace_pic_ioport_read(bool·master,·uint64_t·addr,·int·val)

740

{

740

{

741

····if·(trace_event_get_state(TRACE_PIC_IOPORT_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

741

····if·(trace_event_get_state(TRACE_PIC_IOPORT_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

742

········if·(message_with_timestamp)·{

742

········if·(message_with_timestamp)·{

743

············struct·timeval·_now;

743

············struct·timeval·_now;

744

············gettimeofday(&_now,·NULL);

744

············gettimeofday(&_now,·NULL);

746

············qemu_log("%d@%zu.%06zu:pic_ioport_read·"·"master·%d·addr·0x%"PRIx64"·val·0x%x"·"\n",

746

············qemu_log("%d@%zu.%06zu:pic_ioport_read·"·"master·%d·addr·0x%"PRIx64"·val·0x%x"·"\n",

747

·····················qemu_get_thread_id(),

747

·····················qemu_get_thread_id(),

748

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

748

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

749

·····················,·master,·addr,·val);

749

·····················,·master,·addr,·val);

750

#line·752·"trace/trace-hw_intc.h"

750

#line·752·"trace/trace-hw_intc.h"

751

········}·else·{

751

········}·else·{

753

············qemu_log("pic_ioport_read·"·"master·%d·addr·0x%"PRIx64"·val·0x%x"·"\n",·master,·addr,·val);

753

············qemu_log("pic_ioport_read·"·"master·%d·addr·0x%"PRIx64"·val·0x%x"·"\n",·master,·addr,·val);

754

#line·756·"trace/trace-hw_intc.h"

754

#line·756·"trace/trace-hw_intc.h"

755

········}

755

········}

756

····}

756

····}

757

}

757

}

758

static·inline·void·trace_pic_ioport_read(bool·master,·uint64_t·addr,·int·val)

758

static·inline·void·trace_pic_ioport_read(bool·master,·uint64_t·addr,·int·val)

770

static·inline·void·_nocheck__trace_cpu_set_apic_base(uint64_t·val)

770

static·inline·void·_nocheck__trace_cpu_set_apic_base(uint64_t·val)

771

{

771

{

772

····if·(trace_event_get_state(TRACE_CPU_SET_APIC_BASE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

772

····if·(trace_event_get_state(TRACE_CPU_SET_APIC_BASE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

773

········if·(message_with_timestamp)·{

773

········if·(message_with_timestamp)·{

774

············struct·timeval·_now;

774

············struct·timeval·_now;

775

············gettimeofday(&_now,·NULL);

775

············gettimeofday(&_now,·NULL);

777

············qemu_log("%d@%zu.%06zu:cpu_set_apic_base·"·"0x%016"PRIx64·"\n",

777

············qemu_log("%d@%zu.%06zu:cpu_set_apic_base·"·"0x%016"PRIx64·"\n",

778

·····················qemu_get_thread_id(),

778

·····················qemu_get_thread_id(),

779

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

779

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

780

·····················,·val);

780

·····················,·val);

781

#line·783·"trace/trace-hw_intc.h"

781

#line·783·"trace/trace-hw_intc.h"

782

········}·else·{

782

········}·else·{

784

············qemu_log("cpu_set_apic_base·"·"0x%016"PRIx64·"\n",·val);

784

············qemu_log("cpu_set_apic_base·"·"0x%016"PRIx64·"\n",·val);

785

#line·787·"trace/trace-hw_intc.h"

785

#line·787·"trace/trace-hw_intc.h"

786

········}

786

········}

787

····}

787

····}

788

}

788

}

789

static·inline·void·trace_cpu_set_apic_base(uint64_t·val)

789

static·inline·void·trace_cpu_set_apic_base(uint64_t·val)

801

static·inline·void·_nocheck__trace_cpu_get_apic_base(uint64_t·val)

801

static·inline·void·_nocheck__trace_cpu_get_apic_base(uint64_t·val)

802

{

802

{

803

····if·(trace_event_get_state(TRACE_CPU_GET_APIC_BASE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

803

····if·(trace_event_get_state(TRACE_CPU_GET_APIC_BASE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

804

········if·(message_with_timestamp)·{

804

········if·(message_with_timestamp)·{

805

············struct·timeval·_now;

805

············struct·timeval·_now;

806

············gettimeofday(&_now,·NULL);

806

············gettimeofday(&_now,·NULL);

808

············qemu_log("%d@%zu.%06zu:cpu_get_apic_base·"·"0x%016"PRIx64·"\n",

808

············qemu_log("%d@%zu.%06zu:cpu_get_apic_base·"·"0x%016"PRIx64·"\n",

809

·····················qemu_get_thread_id(),

809

·····················qemu_get_thread_id(),

810

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

810

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

811

·····················,·val);

811

·····················,·val);

812

#line·814·"trace/trace-hw_intc.h"

812

#line·814·"trace/trace-hw_intc.h"

813

········}·else·{

813

········}·else·{

815

············qemu_log("cpu_get_apic_base·"·"0x%016"PRIx64·"\n",·val);

815

············qemu_log("cpu_get_apic_base·"·"0x%016"PRIx64·"\n",·val);

816

#line·818·"trace/trace-hw_intc.h"

816

#line·818·"trace/trace-hw_intc.h"

817

········}

817

········}

818

····}

818

····}

819

}

819

}

820

static·inline·void·trace_cpu_get_apic_base(uint64_t·val)

820

static·inline·void·trace_cpu_get_apic_base(uint64_t·val)

832

static·inline·void·_nocheck__trace_apic_report_irq_delivered(int·apic_irq_delivered)

832

static·inline·void·_nocheck__trace_apic_report_irq_delivered(int·apic_irq_delivered)

833

{

833

{

834

····if·(trace_event_get_state(TRACE_APIC_REPORT_IRQ_DELIVERED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

834

····if·(trace_event_get_state(TRACE_APIC_REPORT_IRQ_DELIVERED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

835

········if·(message_with_timestamp)·{

835

········if·(message_with_timestamp)·{

836

············struct·timeval·_now;

836

············struct·timeval·_now;

837

············gettimeofday(&_now,·NULL);

837

············gettimeofday(&_now,·NULL);

839

············qemu_log("%d@%zu.%06zu:apic_report_irq_delivered·"·"coalescing·%d"·"\n",

839

············qemu_log("%d@%zu.%06zu:apic_report_irq_delivered·"·"coalescing·%d"·"\n",

840

·····················qemu_get_thread_id(),

840

·····················qemu_get_thread_id(),

841

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

841

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

842

·····················,·apic_irq_delivered);

842

·····················,·apic_irq_delivered);

843

#line·845·"trace/trace-hw_intc.h"

843

#line·845·"trace/trace-hw_intc.h"

844

········}·else·{

844

········}·else·{

846

············qemu_log("apic_report_irq_delivered·"·"coalescing·%d"·"\n",·apic_irq_delivered);

846

············qemu_log("apic_report_irq_delivered·"·"coalescing·%d"·"\n",·apic_irq_delivered);

847

#line·849·"trace/trace-hw_intc.h"

847

#line·849·"trace/trace-hw_intc.h"

848

········}

848

········}

849

····}

849

····}

850

}

850

}

851

static·inline·void·trace_apic_report_irq_delivered(int·apic_irq_delivered)

851

static·inline·void·trace_apic_report_irq_delivered(int·apic_irq_delivered)

863

static·inline·void·_nocheck__trace_apic_reset_irq_delivered(int·apic_irq_delivered)

863

static·inline·void·_nocheck__trace_apic_reset_irq_delivered(int·apic_irq_delivered)

864

{

864

{

865

····if·(trace_event_get_state(TRACE_APIC_RESET_IRQ_DELIVERED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

865

····if·(trace_event_get_state(TRACE_APIC_RESET_IRQ_DELIVERED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

866

········if·(message_with_timestamp)·{

866

········if·(message_with_timestamp)·{

867

············struct·timeval·_now;

867

············struct·timeval·_now;

868

············gettimeofday(&_now,·NULL);

868

············gettimeofday(&_now,·NULL);

870

············qemu_log("%d@%zu.%06zu:apic_reset_irq_delivered·"·"old·coalescing·%d"·"\n",

870

············qemu_log("%d@%zu.%06zu:apic_reset_irq_delivered·"·"old·coalescing·%d"·"\n",

871

·····················qemu_get_thread_id(),

871

·····················qemu_get_thread_id(),

872

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

872

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

873

·····················,·apic_irq_delivered);

873

·····················,·apic_irq_delivered);

874

#line·876·"trace/trace-hw_intc.h"

874

#line·876·"trace/trace-hw_intc.h"

875

········}·else·{

875

········}·else·{

877

············qemu_log("apic_reset_irq_delivered·"·"old·coalescing·%d"·"\n",·apic_irq_delivered);

877

············qemu_log("apic_reset_irq_delivered·"·"old·coalescing·%d"·"\n",·apic_irq_delivered);

878

#line·880·"trace/trace-hw_intc.h"

878

#line·880·"trace/trace-hw_intc.h"

879

········}

879

········}

880

····}

880

····}

881

}

881

}

882

static·inline·void·trace_apic_reset_irq_delivered(int·apic_irq_delivered)

882

static·inline·void·trace_apic_reset_irq_delivered(int·apic_irq_delivered)

894

static·inline·void·_nocheck__trace_apic_get_irq_delivered(int·apic_irq_delivered)

894

static·inline·void·_nocheck__trace_apic_get_irq_delivered(int·apic_irq_delivered)

895

{

895

{

896

····if·(trace_event_get_state(TRACE_APIC_GET_IRQ_DELIVERED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

896

····if·(trace_event_get_state(TRACE_APIC_GET_IRQ_DELIVERED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

897

········if·(message_with_timestamp)·{

897

········if·(message_with_timestamp)·{

898

············struct·timeval·_now;

898

············struct·timeval·_now;

899

············gettimeofday(&_now,·NULL);

899

············gettimeofday(&_now,·NULL);

901

············qemu_log("%d@%zu.%06zu:apic_get_irq_delivered·"·"returning·coalescing·%d"·"\n",

901

············qemu_log("%d@%zu.%06zu:apic_get_irq_delivered·"·"returning·coalescing·%d"·"\n",

902

·····················qemu_get_thread_id(),

902

·····················qemu_get_thread_id(),

903

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

903

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

904

·····················,·apic_irq_delivered);

904

·····················,·apic_irq_delivered);

905

#line·907·"trace/trace-hw_intc.h"

905

#line·907·"trace/trace-hw_intc.h"

906

········}·else·{

906

········}·else·{

908

············qemu_log("apic_get_irq_delivered·"·"returning·coalescing·%d"·"\n",·apic_irq_delivered);

908

············qemu_log("apic_get_irq_delivered·"·"returning·coalescing·%d"·"\n",·apic_irq_delivered);

909

#line·911·"trace/trace-hw_intc.h"

909

#line·911·"trace/trace-hw_intc.h"

910

········}

910

········}

911

····}

911

····}

912

}

912

}

913

static·inline·void·trace_apic_get_irq_delivered(int·apic_irq_delivered)

913

static·inline·void·trace_apic_get_irq_delivered(int·apic_irq_delivered)

925

static·inline·void·_nocheck__trace_apic_local_deliver(int·vector,·uint32_t·lvt)

925

static·inline·void·_nocheck__trace_apic_local_deliver(int·vector,·uint32_t·lvt)

926

{

926

{

927

····if·(trace_event_get_state(TRACE_APIC_LOCAL_DELIVER)·&&·qemu_loglevel_mask(LOG_TRACE))·{

927

····if·(trace_event_get_state(TRACE_APIC_LOCAL_DELIVER)·&&·qemu_loglevel_mask(LOG_TRACE))·{

928

········if·(message_with_timestamp)·{

928

········if·(message_with_timestamp)·{

929

············struct·timeval·_now;

929

············struct·timeval·_now;

930

············gettimeofday(&_now,·NULL);

930

············gettimeofday(&_now,·NULL);

932

············qemu_log("%d@%zu.%06zu:apic_local_deliver·"·"vector·%d·delivery·mode·%d"·"\n",

932

············qemu_log("%d@%zu.%06zu:apic_local_deliver·"·"vector·%d·delivery·mode·%d"·"\n",

933

·····················qemu_get_thread_id(),

933

·····················qemu_get_thread_id(),

934

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

934

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

935

·····················,·vector,·lvt);

935

·····················,·vector,·lvt);

936

#line·938·"trace/trace-hw_intc.h"

936

#line·938·"trace/trace-hw_intc.h"

937

········}·else·{

937

········}·else·{

939

············qemu_log("apic_local_deliver·"·"vector·%d·delivery·mode·%d"·"\n",·vector,·lvt);

939

············qemu_log("apic_local_deliver·"·"vector·%d·delivery·mode·%d"·"\n",·vector,·lvt);

940

#line·942·"trace/trace-hw_intc.h"

940

#line·942·"trace/trace-hw_intc.h"

941

········}

941

········}

942

····}

942

····}

943

}

943

}

944

static·inline·void·trace_apic_local_deliver(int·vector,·uint32_t·lvt)

944

static·inline·void·trace_apic_local_deliver(int·vector,·uint32_t·lvt)

956

static·inline·void·_nocheck__trace_apic_deliver_irq(uint8_t·dest,·uint8_t·dest_mode,·uint8_t·delivery_mode,·uint8_t·vector_num,·uint8_t·trigger_mode)

956

static·inline·void·_nocheck__trace_apic_deliver_irq(uint8_t·dest,·uint8_t·dest_mode,·uint8_t·delivery_mode,·uint8_t·vector_num,·uint8_t·trigger_mode)

957

{

957

{

958

····if·(trace_event_get_state(TRACE_APIC_DELIVER_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

958

····if·(trace_event_get_state(TRACE_APIC_DELIVER_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

959

········if·(message_with_timestamp)·{

959

········if·(message_with_timestamp)·{

960

············struct·timeval·_now;

960

············struct·timeval·_now;

961

············gettimeofday(&_now,·NULL);

961

············gettimeofday(&_now,·NULL);

963

············qemu_log("%d@%zu.%06zu:apic_deliver_irq·"·"dest·%d·dest_mode·%d·delivery_mode·%d·vector·%d·trigger_mode·%d"·"\n",

963

············qemu_log("%d@%zu.%06zu:apic_deliver_irq·"·"dest·%d·dest_mode·%d·delivery_mode·%d·vector·%d·trigger_mode·%d"·"\n",

964

·····················qemu_get_thread_id(),

964

·····················qemu_get_thread_id(),

965

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

965

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

966

·····················,·dest,·dest_mode,·delivery_mode,·vector_num,·trigger_mode);

966

·····················,·dest,·dest_mode,·delivery_mode,·vector_num,·trigger_mode);

967

#line·969·"trace/trace-hw_intc.h"

967

#line·969·"trace/trace-hw_intc.h"

968

········}·else·{

968

········}·else·{

970

············qemu_log("apic_deliver_irq·"·"dest·%d·dest_mode·%d·delivery_mode·%d·vector·%d·trigger_mode·%d"·"\n",·dest,·dest_mode,·delivery_mode,·vector_num,·trigger_mode);

970

············qemu_log("apic_deliver_irq·"·"dest·%d·dest_mode·%d·delivery_mode·%d·vector·%d·trigger_mode·%d"·"\n",·dest,·dest_mode,·delivery_mode,·vector_num,·trigger_mode);

971

#line·973·"trace/trace-hw_intc.h"

971

#line·973·"trace/trace-hw_intc.h"

972

········}

972

········}

973

····}

973

····}

974

}

974

}

975

static·inline·void·trace_apic_deliver_irq(uint8_t·dest,·uint8_t·dest_mode,·uint8_t·delivery_mode,·uint8_t·vector_num,·uint8_t·trigger_mode)

975

static·inline·void·trace_apic_deliver_irq(uint8_t·dest,·uint8_t·dest_mode,·uint8_t·delivery_mode,·uint8_t·vector_num,·uint8_t·trigger_mode)

987

static·inline·void·_nocheck__trace_apic_mem_readl(uint64_t·addr,·uint32_t·val)

987

static·inline·void·_nocheck__trace_apic_mem_readl(uint64_t·addr,·uint32_t·val)

988

{

988

{

989

····if·(trace_event_get_state(TRACE_APIC_MEM_READL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

989

····if·(trace_event_get_state(TRACE_APIC_MEM_READL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

990

········if·(message_with_timestamp)·{

990

········if·(message_with_timestamp)·{

991

············struct·timeval·_now;

991

············struct·timeval·_now;

992

············gettimeofday(&_now,·NULL);

992

············gettimeofday(&_now,·NULL);

994

············qemu_log("%d@%zu.%06zu:apic_mem_readl·"·"0x%"PRIx64"·=·0x%08x"·"\n",

994

············qemu_log("%d@%zu.%06zu:apic_mem_readl·"·"0x%"PRIx64"·=·0x%08x"·"\n",

995

·····················qemu_get_thread_id(),

995

·····················qemu_get_thread_id(),

996

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

996

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

997

·····················,·addr,·val);

997

·····················,·addr,·val);

998

#line·1000·"trace/trace-hw_intc.h"

998

#line·1000·"trace/trace-hw_intc.h"

999

········}·else·{

999

········}·else·{

1001

············qemu_log("apic_mem_readl·"·"0x%"PRIx64"·=·0x%08x"·"\n",·addr,·val);

1001

············qemu_log("apic_mem_readl·"·"0x%"PRIx64"·=·0x%08x"·"\n",·addr,·val);

1002

#line·1004·"trace/trace-hw_intc.h"

1002

#line·1004·"trace/trace-hw_intc.h"

1003

········}

1003

········}

1004

····}

1004

····}

1005

}

1005

}

1006

static·inline·void·trace_apic_mem_readl(uint64_t·addr,·uint32_t·val)

1006

static·inline·void·trace_apic_mem_readl(uint64_t·addr,·uint32_t·val)

1018

static·inline·void·_nocheck__trace_apic_mem_writel(uint64_t·addr,·uint32_t·val)

1018

static·inline·void·_nocheck__trace_apic_mem_writel(uint64_t·addr,·uint32_t·val)

1019

{

1019

{

1020

····if·(trace_event_get_state(TRACE_APIC_MEM_WRITEL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1020

····if·(trace_event_get_state(TRACE_APIC_MEM_WRITEL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1021

········if·(message_with_timestamp)·{

1021

········if·(message_with_timestamp)·{

1022

············struct·timeval·_now;

1022

············struct·timeval·_now;

1023

············gettimeofday(&_now,·NULL);

1023

············gettimeofday(&_now,·NULL);

1025

············qemu_log("%d@%zu.%06zu:apic_mem_writel·"·"0x%"PRIx64"·=·0x%08x"·"\n",

1025

············qemu_log("%d@%zu.%06zu:apic_mem_writel·"·"0x%"PRIx64"·=·0x%08x"·"\n",

1026

·····················qemu_get_thread_id(),

1026

·····················qemu_get_thread_id(),

1027

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1027

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1028

·····················,·addr,·val);

1028

·····················,·addr,·val);

1029

#line·1031·"trace/trace-hw_intc.h"

1029

#line·1031·"trace/trace-hw_intc.h"

1030

········}·else·{

1030

········}·else·{

1032

············qemu_log("apic_mem_writel·"·"0x%"PRIx64"·=·0x%08x"·"\n",·addr,·val);

1032

············qemu_log("apic_mem_writel·"·"0x%"PRIx64"·=·0x%08x"·"\n",·addr,·val);

1033

#line·1035·"trace/trace-hw_intc.h"

1033

#line·1035·"trace/trace-hw_intc.h"

1034

········}

1034

········}

1035

····}

1035

····}

1036

}

1036

}

1037

static·inline·void·trace_apic_mem_writel(uint64_t·addr,·uint32_t·val)

1037

static·inline·void·trace_apic_mem_writel(uint64_t·addr,·uint32_t·val)

1049

static·inline·void·_nocheck__trace_ioapic_set_remote_irr(int·n)

1049

static·inline·void·_nocheck__trace_ioapic_set_remote_irr(int·n)

1050

{

1050

{

1051

····if·(trace_event_get_state(TRACE_IOAPIC_SET_REMOTE_IRR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1051

····if·(trace_event_get_state(TRACE_IOAPIC_SET_REMOTE_IRR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1052

········if·(message_with_timestamp)·{

1052

········if·(message_with_timestamp)·{

1053

············struct·timeval·_now;

1053

············struct·timeval·_now;

1054

············gettimeofday(&_now,·NULL);

1054

············gettimeofday(&_now,·NULL);

1056

············qemu_log("%d@%zu.%06zu:ioapic_set_remote_irr·"·"set·remote·irr·for·pin·%d"·"\n",

1056

············qemu_log("%d@%zu.%06zu:ioapic_set_remote_irr·"·"set·remote·irr·for·pin·%d"·"\n",

1057

·····················qemu_get_thread_id(),

1057

·····················qemu_get_thread_id(),

1058

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1058

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1059

·····················,·n);

1059

·····················,·n);

1060

#line·1062·"trace/trace-hw_intc.h"

1060

#line·1062·"trace/trace-hw_intc.h"

1061

········}·else·{

1061

········}·else·{

1063

············qemu_log("ioapic_set_remote_irr·"·"set·remote·irr·for·pin·%d"·"\n",·n);

1063

············qemu_log("ioapic_set_remote_irr·"·"set·remote·irr·for·pin·%d"·"\n",·n);

1064

#line·1066·"trace/trace-hw_intc.h"

1064

#line·1066·"trace/trace-hw_intc.h"

1065

········}

1065

········}

1066

····}

1066

····}

1067

}

1067

}

1068

static·inline·void·trace_ioapic_set_remote_irr(int·n)

1068

static·inline·void·trace_ioapic_set_remote_irr(int·n)

1080

static·inline·void·_nocheck__trace_ioapic_clear_remote_irr(int·n,·int·vector)

1080

static·inline·void·_nocheck__trace_ioapic_clear_remote_irr(int·n,·int·vector)

1081

{

1081

{

1082

····if·(trace_event_get_state(TRACE_IOAPIC_CLEAR_REMOTE_IRR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1082

····if·(trace_event_get_state(TRACE_IOAPIC_CLEAR_REMOTE_IRR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1083

········if·(message_with_timestamp)·{

1083

········if·(message_with_timestamp)·{

1084

············struct·timeval·_now;

1084

············struct·timeval·_now;

1085

············gettimeofday(&_now,·NULL);

1085

············gettimeofday(&_now,·NULL);

1087

············qemu_log("%d@%zu.%06zu:ioapic_clear_remote_irr·"·"clear·remote·irr·for·pin·%d·vector·%d"·"\n",

1087

············qemu_log("%d@%zu.%06zu:ioapic_clear_remote_irr·"·"clear·remote·irr·for·pin·%d·vector·%d"·"\n",

1088

·····················qemu_get_thread_id(),

1088

·····················qemu_get_thread_id(),

1089

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1089

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1090

·····················,·n,·vector);

1090

·····················,·n,·vector);

1091

#line·1093·"trace/trace-hw_intc.h"

1091

#line·1093·"trace/trace-hw_intc.h"

1092

········}·else·{

1092

········}·else·{

1094

············qemu_log("ioapic_clear_remote_irr·"·"clear·remote·irr·for·pin·%d·vector·%d"·"\n",·n,·vector);

1094

············qemu_log("ioapic_clear_remote_irr·"·"clear·remote·irr·for·pin·%d·vector·%d"·"\n",·n,·vector);

1095

#line·1097·"trace/trace-hw_intc.h"

1095

#line·1097·"trace/trace-hw_intc.h"

1096

········}

1096

········}

1097

····}

1097

····}

1098

}

1098

}

1099

static·inline·void·trace_ioapic_clear_remote_irr(int·n,·int·vector)

1099

static·inline·void·trace_ioapic_clear_remote_irr(int·n,·int·vector)

1111

static·inline·void·_nocheck__trace_ioapic_eoi_broadcast(int·vector)

1111

static·inline·void·_nocheck__trace_ioapic_eoi_broadcast(int·vector)

1112

{

1112

{

1113

····if·(trace_event_get_state(TRACE_IOAPIC_EOI_BROADCAST)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1113

····if·(trace_event_get_state(TRACE_IOAPIC_EOI_BROADCAST)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1114

········if·(message_with_timestamp)·{

1114

········if·(message_with_timestamp)·{

1115

············struct·timeval·_now;

1115

············struct·timeval·_now;

1116

············gettimeofday(&_now,·NULL);

1116

············gettimeofday(&_now,·NULL);

1118

············qemu_log("%d@%zu.%06zu:ioapic_eoi_broadcast·"·"EOI·broadcast·for·vector·%d"·"\n",

1118

············qemu_log("%d@%zu.%06zu:ioapic_eoi_broadcast·"·"EOI·broadcast·for·vector·%d"·"\n",

1119

·····················qemu_get_thread_id(),

1119

·····················qemu_get_thread_id(),

1120

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1120

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1121

·····················,·vector);

1121

·····················,·vector);

1122

#line·1124·"trace/trace-hw_intc.h"

1122

#line·1124·"trace/trace-hw_intc.h"

1123

········}·else·{

1123

········}·else·{

1125

············qemu_log("ioapic_eoi_broadcast·"·"EOI·broadcast·for·vector·%d"·"\n",·vector);

1125

············qemu_log("ioapic_eoi_broadcast·"·"EOI·broadcast·for·vector·%d"·"\n",·vector);

1126

#line·1128·"trace/trace-hw_intc.h"

1126

#line·1128·"trace/trace-hw_intc.h"

1127

········}

1127

········}

1128

····}

1128

····}

1129

}

1129

}

1130

static·inline·void·trace_ioapic_eoi_broadcast(int·vector)

1130

static·inline·void·trace_ioapic_eoi_broadcast(int·vector)

1142

static·inline·void·_nocheck__trace_ioapic_eoi_delayed_reassert(int·vector)

1142

static·inline·void·_nocheck__trace_ioapic_eoi_delayed_reassert(int·vector)

1143

{

1143

{

1144

····if·(trace_event_get_state(TRACE_IOAPIC_EOI_DELAYED_REASSERT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1144

····if·(trace_event_get_state(TRACE_IOAPIC_EOI_DELAYED_REASSERT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1145

········if·(message_with_timestamp)·{

1145

········if·(message_with_timestamp)·{

1146

············struct·timeval·_now;

1146

············struct·timeval·_now;

1147

············gettimeofday(&_now,·NULL);

1147

············gettimeofday(&_now,·NULL);

1149

············qemu_log("%d@%zu.%06zu:ioapic_eoi_delayed_reassert·"·"delayed·reassert·on·EOI·broadcast·for·vector·%d"·"\n",

1149

············qemu_log("%d@%zu.%06zu:ioapic_eoi_delayed_reassert·"·"delayed·reassert·on·EOI·broadcast·for·vector·%d"·"\n",

1150

·····················qemu_get_thread_id(),

1150

·····················qemu_get_thread_id(),

1151

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1151

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1152

·····················,·vector);

1152

·····················,·vector);

1153

#line·1155·"trace/trace-hw_intc.h"

1153

#line·1155·"trace/trace-hw_intc.h"

1154

········}·else·{

1154

········}·else·{

1156

············qemu_log("ioapic_eoi_delayed_reassert·"·"delayed·reassert·on·EOI·broadcast·for·vector·%d"·"\n",·vector);

1156

············qemu_log("ioapic_eoi_delayed_reassert·"·"delayed·reassert·on·EOI·broadcast·for·vector·%d"·"\n",·vector);

1157

#line·1159·"trace/trace-hw_intc.h"

1157

#line·1159·"trace/trace-hw_intc.h"

1158

········}

1158

········}

1159

····}

1159

····}

1160

}

1160

}

1161

static·inline·void·trace_ioapic_eoi_delayed_reassert(int·vector)

1161

static·inline·void·trace_ioapic_eoi_delayed_reassert(int·vector)

1173

static·inline·void·_nocheck__trace_ioapic_mem_read(uint8_t·addr,·uint8_t·regsel,·uint8_t·size,·uint32_t·val)

1173

static·inline·void·_nocheck__trace_ioapic_mem_read(uint8_t·addr,·uint8_t·regsel,·uint8_t·size,·uint32_t·val)

1174

{

1174

{

1175

····if·(trace_event_get_state(TRACE_IOAPIC_MEM_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1175

····if·(trace_event_get_state(TRACE_IOAPIC_MEM_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1176

········if·(message_with_timestamp)·{

1176

········if·(message_with_timestamp)·{

1177

············struct·timeval·_now;

1177

············struct·timeval·_now;

1178

············gettimeofday(&_now,·NULL);

1178

············gettimeofday(&_now,·NULL);

1180

············qemu_log("%d@%zu.%06zu:ioapic_mem_read·"·"ioapic·mem·read·addr·0x%"PRIx8"·regsel:·0x%"PRIx8"·size·0x%"PRIx8"·retval·0x%"PRIx32·"\n",

1180

············qemu_log("%d@%zu.%06zu:ioapic_mem_read·"·"ioapic·mem·read·addr·0x%"PRIx8"·regsel:·0x%"PRIx8"·size·0x%"PRIx8"·retval·0x%"PRIx32·"\n",

1181

·····················qemu_get_thread_id(),

1181

·····················qemu_get_thread_id(),

1182

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1182

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1183

·····················,·addr,·regsel,·size,·val);

1183

·····················,·addr,·regsel,·size,·val);

1184

#line·1186·"trace/trace-hw_intc.h"

1184

#line·1186·"trace/trace-hw_intc.h"

1185

········}·else·{

1185

········}·else·{

1187

············qemu_log("ioapic_mem_read·"·"ioapic·mem·read·addr·0x%"PRIx8"·regsel:·0x%"PRIx8"·size·0x%"PRIx8"·retval·0x%"PRIx32·"\n",·addr,·regsel,·size,·val);

1187

············qemu_log("ioapic_mem_read·"·"ioapic·mem·read·addr·0x%"PRIx8"·regsel:·0x%"PRIx8"·size·0x%"PRIx8"·retval·0x%"PRIx32·"\n",·addr,·regsel,·size,·val);

1188

#line·1190·"trace/trace-hw_intc.h"

1188

#line·1190·"trace/trace-hw_intc.h"

1189

········}

1189

········}

1190

····}

1190

····}

1191

}

1191

}

1192

static·inline·void·trace_ioapic_mem_read(uint8_t·addr,·uint8_t·regsel,·uint8_t·size,·uint32_t·val)

1192

static·inline·void·trace_ioapic_mem_read(uint8_t·addr,·uint8_t·regsel,·uint8_t·size,·uint32_t·val)

1204

static·inline·void·_nocheck__trace_ioapic_mem_write(uint8_t·addr,·uint8_t·regsel,·uint8_t·size,·uint32_t·val)

1204

static·inline·void·_nocheck__trace_ioapic_mem_write(uint8_t·addr,·uint8_t·regsel,·uint8_t·size,·uint32_t·val)

1205

{

1205

{

1206

····if·(trace_event_get_state(TRACE_IOAPIC_MEM_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1206

····if·(trace_event_get_state(TRACE_IOAPIC_MEM_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1207

········if·(message_with_timestamp)·{

1207

········if·(message_with_timestamp)·{

1208

············struct·timeval·_now;

1208

············struct·timeval·_now;

1209

············gettimeofday(&_now,·NULL);

1209

············gettimeofday(&_now,·NULL);

1211

············qemu_log("%d@%zu.%06zu:ioapic_mem_write·"·"ioapic·mem·write·addr·0x%"PRIx8"·regsel:·0x%"PRIx8"·size·0x%"PRIx8"·val·0x%"PRIx32·"\n",

1211

············qemu_log("%d@%zu.%06zu:ioapic_mem_write·"·"ioapic·mem·write·addr·0x%"PRIx8"·regsel:·0x%"PRIx8"·size·0x%"PRIx8"·val·0x%"PRIx32·"\n",

1212

·····················qemu_get_thread_id(),

1212

·····················qemu_get_thread_id(),

1213

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1213

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1214

·····················,·addr,·regsel,·size,·val);

1214

·····················,·addr,·regsel,·size,·val);

1215

#line·1217·"trace/trace-hw_intc.h"

1215

#line·1217·"trace/trace-hw_intc.h"

1216

········}·else·{

1216

········}·else·{

1218

············qemu_log("ioapic_mem_write·"·"ioapic·mem·write·addr·0x%"PRIx8"·regsel:·0x%"PRIx8"·size·0x%"PRIx8"·val·0x%"PRIx32·"\n",·addr,·regsel,·size,·val);

1218

············qemu_log("ioapic_mem_write·"·"ioapic·mem·write·addr·0x%"PRIx8"·regsel:·0x%"PRIx8"·size·0x%"PRIx8"·val·0x%"PRIx32·"\n",·addr,·regsel,·size,·val);

1219

#line·1221·"trace/trace-hw_intc.h"

1219

#line·1221·"trace/trace-hw_intc.h"

1220

········}

1220

········}

1221

····}

1221

····}

1222

}

1222

}

1223

static·inline·void·trace_ioapic_mem_write(uint8_t·addr,·uint8_t·regsel,·uint8_t·size,·uint32_t·val)

1223

static·inline·void·trace_ioapic_mem_write(uint8_t·addr,·uint8_t·regsel,·uint8_t·size,·uint32_t·val)

1235

static·inline·void·_nocheck__trace_ioapic_set_irq(int·vector,·int·level)

1235

static·inline·void·_nocheck__trace_ioapic_set_irq(int·vector,·int·level)

1236

{

1236

{

1237

····if·(trace_event_get_state(TRACE_IOAPIC_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1237

····if·(trace_event_get_state(TRACE_IOAPIC_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1238

········if·(message_with_timestamp)·{

1238

········if·(message_with_timestamp)·{

1239

············struct·timeval·_now;

1239

············struct·timeval·_now;

1240

············gettimeofday(&_now,·NULL);

1240

············gettimeofday(&_now,·NULL);

1242

············qemu_log("%d@%zu.%06zu:ioapic_set_irq·"·"vector:·%d·level:·%d"·"\n",

1242

············qemu_log("%d@%zu.%06zu:ioapic_set_irq·"·"vector:·%d·level:·%d"·"\n",

1243

·····················qemu_get_thread_id(),

1243

·····················qemu_get_thread_id(),

1244

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1244

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1245

·····················,·vector,·level);

1245

·····················,·vector,·level);

1246

#line·1248·"trace/trace-hw_intc.h"

1246

#line·1248·"trace/trace-hw_intc.h"

1247

········}·else·{

1247

········}·else·{

1249

············qemu_log("ioapic_set_irq·"·"vector:·%d·level:·%d"·"\n",·vector,·level);

1249

············qemu_log("ioapic_set_irq·"·"vector:·%d·level:·%d"·"\n",·vector,·level);

1250

#line·1252·"trace/trace-hw_intc.h"

1250

#line·1252·"trace/trace-hw_intc.h"

1251

········}

1251

········}

1252

····}

1252

····}

1253

}

1253

}

1254

static·inline·void·trace_ioapic_set_irq(int·vector,·int·level)

1254

static·inline·void·trace_ioapic_set_irq(int·vector,·int·level)

1266

static·inline·void·_nocheck__trace_slavio_intctl_mem_readl(uint32_t·cpu,·uint64_t·addr,·uint32_t·ret)

1266

static·inline·void·_nocheck__trace_slavio_intctl_mem_readl(uint32_t·cpu,·uint64_t·addr,·uint32_t·ret)

1267

{

1267

{

1268

····if·(trace_event_get_state(TRACE_SLAVIO_INTCTL_MEM_READL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1268

····if·(trace_event_get_state(TRACE_SLAVIO_INTCTL_MEM_READL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1269

········if·(message_with_timestamp)·{

1269

········if·(message_with_timestamp)·{

1270

············struct·timeval·_now;

1270

············struct·timeval·_now;

1271

············gettimeofday(&_now,·NULL);

1271

············gettimeofday(&_now,·NULL);

1273

············qemu_log("%d@%zu.%06zu:slavio_intctl_mem_readl·"·"read·cpu·%d·reg·0x%"PRIx64"·=·0x%x"·"\n",

1273

············qemu_log("%d@%zu.%06zu:slavio_intctl_mem_readl·"·"read·cpu·%d·reg·0x%"PRIx64"·=·0x%x"·"\n",

1274

·····················qemu_get_thread_id(),

1274

·····················qemu_get_thread_id(),

1275

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1275

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1276

·····················,·cpu,·addr,·ret);

1276

·····················,·cpu,·addr,·ret);

1277

#line·1279·"trace/trace-hw_intc.h"

1277

#line·1279·"trace/trace-hw_intc.h"

1278

········}·else·{

1278

········}·else·{

1280

············qemu_log("slavio_intctl_mem_readl·"·"read·cpu·%d·reg·0x%"PRIx64"·=·0x%x"·"\n",·cpu,·addr,·ret);

1280

············qemu_log("slavio_intctl_mem_readl·"·"read·cpu·%d·reg·0x%"PRIx64"·=·0x%x"·"\n",·cpu,·addr,·ret);

1281

#line·1283·"trace/trace-hw_intc.h"

1281

#line·1283·"trace/trace-hw_intc.h"

1282

········}

1282

········}

1283

····}

1283

····}

1284

}

1284

}

1285

static·inline·void·trace_slavio_intctl_mem_readl(uint32_t·cpu,·uint64_t·addr,·uint32_t·ret)

1285

static·inline·void·trace_slavio_intctl_mem_readl(uint32_t·cpu,·uint64_t·addr,·uint32_t·ret)

1297

static·inline·void·_nocheck__trace_slavio_intctl_mem_writel(uint32_t·cpu,·uint64_t·addr,·uint32_t·val)

1297

static·inline·void·_nocheck__trace_slavio_intctl_mem_writel(uint32_t·cpu,·uint64_t·addr,·uint32_t·val)

1298

{

1298

{

1299

····if·(trace_event_get_state(TRACE_SLAVIO_INTCTL_MEM_WRITEL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1299

····if·(trace_event_get_state(TRACE_SLAVIO_INTCTL_MEM_WRITEL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1300

········if·(message_with_timestamp)·{

1300

········if·(message_with_timestamp)·{

1301

············struct·timeval·_now;

1301

············struct·timeval·_now;

1302

············gettimeofday(&_now,·NULL);

1302

············gettimeofday(&_now,·NULL);

1304

············qemu_log("%d@%zu.%06zu:slavio_intctl_mem_writel·"·"write·cpu·%d·reg·0x%"PRIx64"·=·0x%x"·"\n",

1304

············qemu_log("%d@%zu.%06zu:slavio_intctl_mem_writel·"·"write·cpu·%d·reg·0x%"PRIx64"·=·0x%x"·"\n",

1305

·····················qemu_get_thread_id(),

1305

·····················qemu_get_thread_id(),

1306

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1306

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1307

·····················,·cpu,·addr,·val);

1307

·····················,·cpu,·addr,·val);

1308

#line·1310·"trace/trace-hw_intc.h"

1308

#line·1310·"trace/trace-hw_intc.h"

1309

········}·else·{

1309

········}·else·{

1311

············qemu_log("slavio_intctl_mem_writel·"·"write·cpu·%d·reg·0x%"PRIx64"·=·0x%x"·"\n",·cpu,·addr,·val);

1311

············qemu_log("slavio_intctl_mem_writel·"·"write·cpu·%d·reg·0x%"PRIx64"·=·0x%x"·"\n",·cpu,·addr,·val);

1312

#line·1314·"trace/trace-hw_intc.h"

1312

#line·1314·"trace/trace-hw_intc.h"

1313

········}

1313

········}

1314

····}

1314

····}

1315

}

1315

}

1316

static·inline·void·trace_slavio_intctl_mem_writel(uint32_t·cpu,·uint64_t·addr,·uint32_t·val)

1316

static·inline·void·trace_slavio_intctl_mem_writel(uint32_t·cpu,·uint64_t·addr,·uint32_t·val)

1328

static·inline·void·_nocheck__trace_slavio_intctl_mem_writel_clear(uint32_t·cpu,·uint32_t·val,·uint32_t·intreg_pending)

1328

static·inline·void·_nocheck__trace_slavio_intctl_mem_writel_clear(uint32_t·cpu,·uint32_t·val,·uint32_t·intreg_pending)

1329

{

1329

{

1330

····if·(trace_event_get_state(TRACE_SLAVIO_INTCTL_MEM_WRITEL_CLEAR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1330

····if·(trace_event_get_state(TRACE_SLAVIO_INTCTL_MEM_WRITEL_CLEAR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1331

········if·(message_with_timestamp)·{

1331

········if·(message_with_timestamp)·{

1332

············struct·timeval·_now;

1332

············struct·timeval·_now;

1333

············gettimeofday(&_now,·NULL);

1333

············gettimeofday(&_now,·NULL);

1335

············qemu_log("%d@%zu.%06zu:slavio_intctl_mem_writel_clear·"·"Cleared·cpu·%d·irq·mask·0x%x,·curmask·0x%x"·"\n",

1335

············qemu_log("%d@%zu.%06zu:slavio_intctl_mem_writel_clear·"·"Cleared·cpu·%d·irq·mask·0x%x,·curmask·0x%x"·"\n",

1336

·····················qemu_get_thread_id(),

1336

·····················qemu_get_thread_id(),

1337

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1337

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1338

·····················,·cpu,·val,·intreg_pending);

1338

·····················,·cpu,·val,·intreg_pending);

1339

#line·1341·"trace/trace-hw_intc.h"

1339

#line·1341·"trace/trace-hw_intc.h"

1340

········}·else·{

1340

········}·else·{

1342

············qemu_log("slavio_intctl_mem_writel_clear·"·"Cleared·cpu·%d·irq·mask·0x%x,·curmask·0x%x"·"\n",·cpu,·val,·intreg_pending);

1342

············qemu_log("slavio_intctl_mem_writel_clear·"·"Cleared·cpu·%d·irq·mask·0x%x,·curmask·0x%x"·"\n",·cpu,·val,·intreg_pending);

1343

#line·1345·"trace/trace-hw_intc.h"

1343

#line·1345·"trace/trace-hw_intc.h"

1344

········}

1344

········}

1345

····}

1345

····}

1346

}

1346

}

1347

static·inline·void·trace_slavio_intctl_mem_writel_clear(uint32_t·cpu,·uint32_t·val,·uint32_t·intreg_pending)

1347

static·inline·void·trace_slavio_intctl_mem_writel_clear(uint32_t·cpu,·uint32_t·val,·uint32_t·intreg_pending)

1359

static·inline·void·_nocheck__trace_slavio_intctl_mem_writel_set(uint32_t·cpu,·uint32_t·val,·uint32_t·intreg_pending)

1359

static·inline·void·_nocheck__trace_slavio_intctl_mem_writel_set(uint32_t·cpu,·uint32_t·val,·uint32_t·intreg_pending)

1360

{

1360

{

1361

····if·(trace_event_get_state(TRACE_SLAVIO_INTCTL_MEM_WRITEL_SET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1361

····if·(trace_event_get_state(TRACE_SLAVIO_INTCTL_MEM_WRITEL_SET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1362

········if·(message_with_timestamp)·{

1362

········if·(message_with_timestamp)·{

1363

············struct·timeval·_now;

1363

············struct·timeval·_now;

1364

············gettimeofday(&_now,·NULL);

1364

············gettimeofday(&_now,·NULL);

1366

············qemu_log("%d@%zu.%06zu:slavio_intctl_mem_writel_set·"·"Set·cpu·%d·irq·mask·0x%x,·curmask·0x%x"·"\n",

1366

············qemu_log("%d@%zu.%06zu:slavio_intctl_mem_writel_set·"·"Set·cpu·%d·irq·mask·0x%x,·curmask·0x%x"·"\n",

1367

·····················qemu_get_thread_id(),

1367

·····················qemu_get_thread_id(),

1368

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1368

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1369

·····················,·cpu,·val,·intreg_pending);

1369

·····················,·cpu,·val,·intreg_pending);

1370

#line·1372·"trace/trace-hw_intc.h"

1370

#line·1372·"trace/trace-hw_intc.h"

1371

········}·else·{

1371

········}·else·{

1373

············qemu_log("slavio_intctl_mem_writel_set·"·"Set·cpu·%d·irq·mask·0x%x,·curmask·0x%x"·"\n",·cpu,·val,·intreg_pending);

1373

············qemu_log("slavio_intctl_mem_writel_set·"·"Set·cpu·%d·irq·mask·0x%x,·curmask·0x%x"·"\n",·cpu,·val,·intreg_pending);

1374

#line·1376·"trace/trace-hw_intc.h"

1374

#line·1376·"trace/trace-hw_intc.h"

1375

········}

1375

········}

1376

····}

1376

····}

1377

}

1377

}

1378

static·inline·void·trace_slavio_intctl_mem_writel_set(uint32_t·cpu,·uint32_t·val,·uint32_t·intreg_pending)

1378

static·inline·void·trace_slavio_intctl_mem_writel_set(uint32_t·cpu,·uint32_t·val,·uint32_t·intreg_pending)

1390

static·inline·void·_nocheck__trace_slavio_intctlm_mem_readl(uint64_t·addr,·uint32_t·ret)

1390

static·inline·void·_nocheck__trace_slavio_intctlm_mem_readl(uint64_t·addr,·uint32_t·ret)

1391

{

1391

{

1392

····if·(trace_event_get_state(TRACE_SLAVIO_INTCTLM_MEM_READL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1392

····if·(trace_event_get_state(TRACE_SLAVIO_INTCTLM_MEM_READL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1393

········if·(message_with_timestamp)·{

1393

········if·(message_with_timestamp)·{

1394

············struct·timeval·_now;

1394

············struct·timeval·_now;

1395

············gettimeofday(&_now,·NULL);

1395

············gettimeofday(&_now,·NULL);

1397

············qemu_log("%d@%zu.%06zu:slavio_intctlm_mem_readl·"·"read·system·reg·0x%"PRIx64"·=·0x%x"·"\n",

1397

············qemu_log("%d@%zu.%06zu:slavio_intctlm_mem_readl·"·"read·system·reg·0x%"PRIx64"·=·0x%x"·"\n",

1398

·····················qemu_get_thread_id(),

1398

·····················qemu_get_thread_id(),

1399

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1399

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1400

·····················,·addr,·ret);

1400

·····················,·addr,·ret);

1401

#line·1403·"trace/trace-hw_intc.h"

1401

#line·1403·"trace/trace-hw_intc.h"

1402

········}·else·{

1402

········}·else·{

1404

············qemu_log("slavio_intctlm_mem_readl·"·"read·system·reg·0x%"PRIx64"·=·0x%x"·"\n",·addr,·ret);

1404

············qemu_log("slavio_intctlm_mem_readl·"·"read·system·reg·0x%"PRIx64"·=·0x%x"·"\n",·addr,·ret);

1405

#line·1407·"trace/trace-hw_intc.h"

1405

#line·1407·"trace/trace-hw_intc.h"

1406

········}

1406

········}

1407

····}

1407

····}

1408

}

1408

}

1409

static·inline·void·trace_slavio_intctlm_mem_readl(uint64_t·addr,·uint32_t·ret)

1409

static·inline·void·trace_slavio_intctlm_mem_readl(uint64_t·addr,·uint32_t·ret)

1421

static·inline·void·_nocheck__trace_slavio_intctlm_mem_writel(uint64_t·addr,·uint32_t·val)

1421

static·inline·void·_nocheck__trace_slavio_intctlm_mem_writel(uint64_t·addr,·uint32_t·val)

1422

{

1422

{

1423

····if·(trace_event_get_state(TRACE_SLAVIO_INTCTLM_MEM_WRITEL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1423

····if·(trace_event_get_state(TRACE_SLAVIO_INTCTLM_MEM_WRITEL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1424

········if·(message_with_timestamp)·{

1424

········if·(message_with_timestamp)·{

1425

············struct·timeval·_now;

1425

············struct·timeval·_now;

1426

············gettimeofday(&_now,·NULL);

1426

············gettimeofday(&_now,·NULL);

1428

············qemu_log("%d@%zu.%06zu:slavio_intctlm_mem_writel·"·"write·system·reg·0x%"PRIx64"·=·0x%x"·"\n",

1428

············qemu_log("%d@%zu.%06zu:slavio_intctlm_mem_writel·"·"write·system·reg·0x%"PRIx64"·=·0x%x"·"\n",

1429

·····················qemu_get_thread_id(),

1429

·····················qemu_get_thread_id(),

1430

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1430

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1431

·····················,·addr,·val);

1431

·····················,·addr,·val);

1432

#line·1434·"trace/trace-hw_intc.h"

1432

#line·1434·"trace/trace-hw_intc.h"

1433

········}·else·{

1433

········}·else·{

1435

············qemu_log("slavio_intctlm_mem_writel·"·"write·system·reg·0x%"PRIx64"·=·0x%x"·"\n",·addr,·val);

1435

············qemu_log("slavio_intctlm_mem_writel·"·"write·system·reg·0x%"PRIx64"·=·0x%x"·"\n",·addr,·val);

1436

#line·1438·"trace/trace-hw_intc.h"

1436

#line·1438·"trace/trace-hw_intc.h"

1437

········}

1437

········}

1438

····}

1438

····}

1439

}

1439

}

1440

static·inline·void·trace_slavio_intctlm_mem_writel(uint64_t·addr,·uint32_t·val)

1440

static·inline·void·trace_slavio_intctlm_mem_writel(uint64_t·addr,·uint32_t·val)

1452

static·inline·void·_nocheck__trace_slavio_intctlm_mem_writel_enable(uint32_t·val,·uint32_t·intregm_disabled)

1452

static·inline·void·_nocheck__trace_slavio_intctlm_mem_writel_enable(uint32_t·val,·uint32_t·intregm_disabled)

1453

{

1453

{

1454

····if·(trace_event_get_state(TRACE_SLAVIO_INTCTLM_MEM_WRITEL_ENABLE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1454

····if·(trace_event_get_state(TRACE_SLAVIO_INTCTLM_MEM_WRITEL_ENABLE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1455

········if·(message_with_timestamp)·{

1455

········if·(message_with_timestamp)·{

1456

············struct·timeval·_now;

1456

············struct·timeval·_now;

1457

············gettimeofday(&_now,·NULL);

1457

············gettimeofday(&_now,·NULL);

1459

············qemu_log("%d@%zu.%06zu:slavio_intctlm_mem_writel_enable·"·"Enabled·master·irq·mask·0x%x,·curmask·0x%x"·"\n",

1459

············qemu_log("%d@%zu.%06zu:slavio_intctlm_mem_writel_enable·"·"Enabled·master·irq·mask·0x%x,·curmask·0x%x"·"\n",

1460

·····················qemu_get_thread_id(),

1460

·····················qemu_get_thread_id(),

1461

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1461

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1462

·····················,·val,·intregm_disabled);

1462

·····················,·val,·intregm_disabled);

1463

#line·1465·"trace/trace-hw_intc.h"

1463

#line·1465·"trace/trace-hw_intc.h"

1464

········}·else·{

1464

········}·else·{

1466

············qemu_log("slavio_intctlm_mem_writel_enable·"·"Enabled·master·irq·mask·0x%x,·curmask·0x%x"·"\n",·val,·intregm_disabled);

1466

············qemu_log("slavio_intctlm_mem_writel_enable·"·"Enabled·master·irq·mask·0x%x,·curmask·0x%x"·"\n",·val,·intregm_disabled);

1467

#line·1469·"trace/trace-hw_intc.h"

1467

#line·1469·"trace/trace-hw_intc.h"

1468

········}

1468

········}

1469

····}

1469

····}

1470

}

1470

}

1471

static·inline·void·trace_slavio_intctlm_mem_writel_enable(uint32_t·val,·uint32_t·intregm_disabled)

1471

static·inline·void·trace_slavio_intctlm_mem_writel_enable(uint32_t·val,·uint32_t·intregm_disabled)

1483

static·inline·void·_nocheck__trace_slavio_intctlm_mem_writel_disable(uint32_t·val,·uint32_t·intregm_disabled)

1483

static·inline·void·_nocheck__trace_slavio_intctlm_mem_writel_disable(uint32_t·val,·uint32_t·intregm_disabled)

1484

{

1484

{

1485

····if·(trace_event_get_state(TRACE_SLAVIO_INTCTLM_MEM_WRITEL_DISABLE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1485

····if·(trace_event_get_state(TRACE_SLAVIO_INTCTLM_MEM_WRITEL_DISABLE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1486

········if·(message_with_timestamp)·{

1486

········if·(message_with_timestamp)·{

1487

············struct·timeval·_now;

1487

············struct·timeval·_now;

1488

············gettimeofday(&_now,·NULL);

1488

············gettimeofday(&_now,·NULL);

1490

············qemu_log("%d@%zu.%06zu:slavio_intctlm_mem_writel_disable·"·"Disabled·master·irq·mask·0x%x,·curmask·0x%x"·"\n",

1490

············qemu_log("%d@%zu.%06zu:slavio_intctlm_mem_writel_disable·"·"Disabled·master·irq·mask·0x%x,·curmask·0x%x"·"\n",

1491

·····················qemu_get_thread_id(),

1491

·····················qemu_get_thread_id(),

1492

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1492

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1493

·····················,·val,·intregm_disabled);

1493

·····················,·val,·intregm_disabled);

1494

#line·1496·"trace/trace-hw_intc.h"

1494

#line·1496·"trace/trace-hw_intc.h"

1495

········}·else·{

1495

········}·else·{

1497

············qemu_log("slavio_intctlm_mem_writel_disable·"·"Disabled·master·irq·mask·0x%x,·curmask·0x%x"·"\n",·val,·intregm_disabled);

1497

············qemu_log("slavio_intctlm_mem_writel_disable·"·"Disabled·master·irq·mask·0x%x,·curmask·0x%x"·"\n",·val,·intregm_disabled);

1498

#line·1500·"trace/trace-hw_intc.h"

1498

#line·1500·"trace/trace-hw_intc.h"

1499

········}

1499

········}

1500

····}

1500

····}

1501

}

1501

}

1502

static·inline·void·trace_slavio_intctlm_mem_writel_disable(uint32_t·val,·uint32_t·intregm_disabled)

1502

static·inline·void·trace_slavio_intctlm_mem_writel_disable(uint32_t·val,·uint32_t·intregm_disabled)

1514

static·inline·void·_nocheck__trace_slavio_intctlm_mem_writel_target(uint32_t·cpu)

1514

static·inline·void·_nocheck__trace_slavio_intctlm_mem_writel_target(uint32_t·cpu)

1515

{

1515

{

1516

····if·(trace_event_get_state(TRACE_SLAVIO_INTCTLM_MEM_WRITEL_TARGET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1516

····if·(trace_event_get_state(TRACE_SLAVIO_INTCTLM_MEM_WRITEL_TARGET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1517

········if·(message_with_timestamp)·{

1517

········if·(message_with_timestamp)·{

1518

············struct·timeval·_now;

1518

············struct·timeval·_now;

1519

············gettimeofday(&_now,·NULL);

1519

············gettimeofday(&_now,·NULL);

1521

············qemu_log("%d@%zu.%06zu:slavio_intctlm_mem_writel_target·"·"Set·master·irq·cpu·%d"·"\n",

1521

············qemu_log("%d@%zu.%06zu:slavio_intctlm_mem_writel_target·"·"Set·master·irq·cpu·%d"·"\n",

1522

·····················qemu_get_thread_id(),

1522

·····················qemu_get_thread_id(),

1523

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1523

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1524

·····················,·cpu);

1524

·····················,·cpu);

1525

#line·1527·"trace/trace-hw_intc.h"

1525

#line·1527·"trace/trace-hw_intc.h"

1526

········}·else·{

1526

········}·else·{

1528

············qemu_log("slavio_intctlm_mem_writel_target·"·"Set·master·irq·cpu·%d"·"\n",·cpu);

1528

············qemu_log("slavio_intctlm_mem_writel_target·"·"Set·master·irq·cpu·%d"·"\n",·cpu);

1529

#line·1531·"trace/trace-hw_intc.h"

1529

#line·1531·"trace/trace-hw_intc.h"

1530

········}

1530

········}

1531

····}

1531

····}

1532

}

1532

}

1533

static·inline·void·trace_slavio_intctlm_mem_writel_target(uint32_t·cpu)

1533

static·inline·void·trace_slavio_intctlm_mem_writel_target(uint32_t·cpu)

1545

static·inline·void·_nocheck__trace_slavio_check_interrupts(uint32_t·pending,·uint32_t·intregm_disabled)

1545

static·inline·void·_nocheck__trace_slavio_check_interrupts(uint32_t·pending,·uint32_t·intregm_disabled)

1546

{

1546

{

1547

····if·(trace_event_get_state(TRACE_SLAVIO_CHECK_INTERRUPTS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1547

····if·(trace_event_get_state(TRACE_SLAVIO_CHECK_INTERRUPTS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1548

········if·(message_with_timestamp)·{

1548

········if·(message_with_timestamp)·{

1549

············struct·timeval·_now;

1549

············struct·timeval·_now;

1550

············gettimeofday(&_now,·NULL);

1550

············gettimeofday(&_now,·NULL);

1552

············qemu_log("%d@%zu.%06zu:slavio_check_interrupts·"·"pending·0x%x·disabled·0x%x"·"\n",

1552

············qemu_log("%d@%zu.%06zu:slavio_check_interrupts·"·"pending·0x%x·disabled·0x%x"·"\n",

1553

·····················qemu_get_thread_id(),

1553

·····················qemu_get_thread_id(),

1554

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1554

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1555

·····················,·pending,·intregm_disabled);

1555

·····················,·pending,·intregm_disabled);

1556

#line·1558·"trace/trace-hw_intc.h"

1556

#line·1558·"trace/trace-hw_intc.h"

1557

········}·else·{

1557

········}·else·{

1559

············qemu_log("slavio_check_interrupts·"·"pending·0x%x·disabled·0x%x"·"\n",·pending,·intregm_disabled);

1559

············qemu_log("slavio_check_interrupts·"·"pending·0x%x·disabled·0x%x"·"\n",·pending,·intregm_disabled);

1560

#line·1562·"trace/trace-hw_intc.h"

1560

#line·1562·"trace/trace-hw_intc.h"

1561

········}

1561

········}

1562

····}

1562

····}

1563

}

1563

}

1564

static·inline·void·trace_slavio_check_interrupts(uint32_t·pending,·uint32_t·intregm_disabled)

1564

static·inline·void·trace_slavio_check_interrupts(uint32_t·pending,·uint32_t·intregm_disabled)

1576

static·inline·void·_nocheck__trace_slavio_set_irq(uint32_t·target_cpu,·int·irq,·uint32_t·pil,·int·level)

1576

static·inline·void·_nocheck__trace_slavio_set_irq(uint32_t·target_cpu,·int·irq,·uint32_t·pil,·int·level)

1577

{

1577

{

1578

····if·(trace_event_get_state(TRACE_SLAVIO_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1578

····if·(trace_event_get_state(TRACE_SLAVIO_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1579

········if·(message_with_timestamp)·{

1579

········if·(message_with_timestamp)·{

1580

············struct·timeval·_now;

1580

············struct·timeval·_now;

1581

············gettimeofday(&_now,·NULL);

1581

············gettimeofday(&_now,·NULL);

1583

············qemu_log("%d@%zu.%06zu:slavio_set_irq·"·"Set·cpu·%d·irq·%d·->·pil·%d·level·%d"·"\n",

1583

············qemu_log("%d@%zu.%06zu:slavio_set_irq·"·"Set·cpu·%d·irq·%d·->·pil·%d·level·%d"·"\n",

1584

·····················qemu_get_thread_id(),

1584

·····················qemu_get_thread_id(),

1585

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1585

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1586

·····················,·target_cpu,·irq,·pil,·level);

1586

·····················,·target_cpu,·irq,·pil,·level);

1587

#line·1589·"trace/trace-hw_intc.h"

1587

#line·1589·"trace/trace-hw_intc.h"

1588

········}·else·{

1588

········}·else·{

1590

············qemu_log("slavio_set_irq·"·"Set·cpu·%d·irq·%d·->·pil·%d·level·%d"·"\n",·target_cpu,·irq,·pil,·level);

1590

············qemu_log("slavio_set_irq·"·"Set·cpu·%d·irq·%d·->·pil·%d·level·%d"·"\n",·target_cpu,·irq,·pil,·level);

1591

#line·1593·"trace/trace-hw_intc.h"

1591

#line·1593·"trace/trace-hw_intc.h"

1592

········}

1592

········}

1593

····}

1593

····}

1594

}

1594

}

1595

static·inline·void·trace_slavio_set_irq(uint32_t·target_cpu,·int·irq,·uint32_t·pil,·int·level)

1595

static·inline·void·trace_slavio_set_irq(uint32_t·target_cpu,·int·irq,·uint32_t·pil,·int·level)

1607

static·inline·void·_nocheck__trace_slavio_set_timer_irq_cpu(int·cpu,·int·level)

1607

static·inline·void·_nocheck__trace_slavio_set_timer_irq_cpu(int·cpu,·int·level)

1608

{

1608

{

1609

····if·(trace_event_get_state(TRACE_SLAVIO_SET_TIMER_IRQ_CPU)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1609

····if·(trace_event_get_state(TRACE_SLAVIO_SET_TIMER_IRQ_CPU)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1610

········if·(message_with_timestamp)·{

1610

········if·(message_with_timestamp)·{

1611

············struct·timeval·_now;

1611

············struct·timeval·_now;

1612

············gettimeofday(&_now,·NULL);

1612

············gettimeofday(&_now,·NULL);

1614

············qemu_log("%d@%zu.%06zu:slavio_set_timer_irq_cpu·"·"Set·cpu·%d·local·timer·level·%d"·"\n",

1614

············qemu_log("%d@%zu.%06zu:slavio_set_timer_irq_cpu·"·"Set·cpu·%d·local·timer·level·%d"·"\n",

1615

·····················qemu_get_thread_id(),

1615

·····················qemu_get_thread_id(),

1616

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1616

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1617

·····················,·cpu,·level);

1617

·····················,·cpu,·level);

1618

#line·1620·"trace/trace-hw_intc.h"

1618

#line·1620·"trace/trace-hw_intc.h"

1619

········}·else·{

1619

········}·else·{

1621

············qemu_log("slavio_set_timer_irq_cpu·"·"Set·cpu·%d·local·timer·level·%d"·"\n",·cpu,·level);

1621

············qemu_log("slavio_set_timer_irq_cpu·"·"Set·cpu·%d·local·timer·level·%d"·"\n",·cpu,·level);

1622

#line·1624·"trace/trace-hw_intc.h"

1622

#line·1624·"trace/trace-hw_intc.h"

1623

········}

1623

········}

1624

····}

1624

····}

1625

}

1625

}

1626

static·inline·void·trace_slavio_set_timer_irq_cpu(int·cpu,·int·level)

1626

static·inline·void·trace_slavio_set_timer_irq_cpu(int·cpu,·int·level)

1638

static·inline·void·_nocheck__trace_grlib_irqmp_check_irqs(uint32_t·pend,·uint32_t·force,·uint32_t·mask,·uint32_t·lvl1,·uint32_t·lvl2)

1638

static·inline·void·_nocheck__trace_grlib_irqmp_check_irqs(uint32_t·pend,·uint32_t·force,·uint32_t·mask,·uint32_t·lvl1,·uint32_t·lvl2)

1639

{

1639

{

1640

····if·(trace_event_get_state(TRACE_GRLIB_IRQMP_CHECK_IRQS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1640

····if·(trace_event_get_state(TRACE_GRLIB_IRQMP_CHECK_IRQS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1641

········if·(message_with_timestamp)·{

1641

········if·(message_with_timestamp)·{

1642

············struct·timeval·_now;

1642

············struct·timeval·_now;

1643

············gettimeofday(&_now,·NULL);

1643

············gettimeofday(&_now,·NULL);

1645

············qemu_log("%d@%zu.%06zu:grlib_irqmp_check_irqs·"·"pend:0x%04x·force:0x%04x·mask:0x%04x·lvl1:0x%04x·lvl0:0x%04x"·"\n",

1645

············qemu_log("%d@%zu.%06zu:grlib_irqmp_check_irqs·"·"pend:0x%04x·force:0x%04x·mask:0x%04x·lvl1:0x%04x·lvl0:0x%04x"·"\n",

1646

·····················qemu_get_thread_id(),

1646

·····················qemu_get_thread_id(),

1647

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1647

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1648

·····················,·pend,·force,·mask,·lvl1,·lvl2);

1648

·····················,·pend,·force,·mask,·lvl1,·lvl2);

1649

#line·1651·"trace/trace-hw_intc.h"

1649

#line·1651·"trace/trace-hw_intc.h"

1650

········}·else·{

1650

········}·else·{

1652

············qemu_log("grlib_irqmp_check_irqs·"·"pend:0x%04x·force:0x%04x·mask:0x%04x·lvl1:0x%04x·lvl0:0x%04x"·"\n",·pend,·force,·mask,·lvl1,·lvl2);

1652

············qemu_log("grlib_irqmp_check_irqs·"·"pend:0x%04x·force:0x%04x·mask:0x%04x·lvl1:0x%04x·lvl0:0x%04x"·"\n",·pend,·force,·mask,·lvl1,·lvl2);

1653

#line·1655·"trace/trace-hw_intc.h"

1653

#line·1655·"trace/trace-hw_intc.h"

1654

········}

1654

········}

1655

····}

1655

····}

1656

}

1656

}

1657

static·inline·void·trace_grlib_irqmp_check_irqs(uint32_t·pend,·uint32_t·force,·uint32_t·mask,·uint32_t·lvl1,·uint32_t·lvl2)

1657

static·inline·void·trace_grlib_irqmp_check_irqs(uint32_t·pend,·uint32_t·force,·uint32_t·mask,·uint32_t·lvl1,·uint32_t·lvl2)

1669

static·inline·void·_nocheck__trace_grlib_irqmp_ack(int·intno)

1669

static·inline·void·_nocheck__trace_grlib_irqmp_ack(int·intno)

1670

{

1670

{

1671

····if·(trace_event_get_state(TRACE_GRLIB_IRQMP_ACK)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1671

····if·(trace_event_get_state(TRACE_GRLIB_IRQMP_ACK)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1672

········if·(message_with_timestamp)·{

1672

········if·(message_with_timestamp)·{

1673

············struct·timeval·_now;

1673

············struct·timeval·_now;

1674

············gettimeofday(&_now,·NULL);

1674

············gettimeofday(&_now,·NULL);

1676

············qemu_log("%d@%zu.%06zu:grlib_irqmp_ack·"·"interrupt:%d"·"\n",

1676

············qemu_log("%d@%zu.%06zu:grlib_irqmp_ack·"·"interrupt:%d"·"\n",

1677

·····················qemu_get_thread_id(),

1677

·····················qemu_get_thread_id(),

1678

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1678

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1679

·····················,·intno);

1679

·····················,·intno);

1680

#line·1682·"trace/trace-hw_intc.h"

1680

#line·1682·"trace/trace-hw_intc.h"

1681

········}·else·{

1681

········}·else·{

1683

············qemu_log("grlib_irqmp_ack·"·"interrupt:%d"·"\n",·intno);

1683

············qemu_log("grlib_irqmp_ack·"·"interrupt:%d"·"\n",·intno);

1684

#line·1686·"trace/trace-hw_intc.h"

1684

#line·1686·"trace/trace-hw_intc.h"

1685

········}

1685

········}

1686

····}

1686

····}

1687

}

1687

}

1688

static·inline·void·trace_grlib_irqmp_ack(int·intno)

1688

static·inline·void·trace_grlib_irqmp_ack(int·intno)

1700

static·inline·void·_nocheck__trace_grlib_irqmp_set_irq(int·irq)

1700

static·inline·void·_nocheck__trace_grlib_irqmp_set_irq(int·irq)

1701

{

1701

{

1702

····if·(trace_event_get_state(TRACE_GRLIB_IRQMP_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1702

····if·(trace_event_get_state(TRACE_GRLIB_IRQMP_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1703

········if·(message_with_timestamp)·{

1703

········if·(message_with_timestamp)·{

1704

············struct·timeval·_now;

1704

············struct·timeval·_now;

1705

············gettimeofday(&_now,·NULL);

1705

············gettimeofday(&_now,·NULL);

1707

············qemu_log("%d@%zu.%06zu:grlib_irqmp_set_irq·"·"Raise·CPU·IRQ·%d"·"\n",

1707

············qemu_log("%d@%zu.%06zu:grlib_irqmp_set_irq·"·"Raise·CPU·IRQ·%d"·"\n",

1708

·····················qemu_get_thread_id(),

1708

·····················qemu_get_thread_id(),

1709

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1709

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1710

·····················,·irq);

1710

·····················,·irq);

1711

#line·1713·"trace/trace-hw_intc.h"

1711

#line·1713·"trace/trace-hw_intc.h"

1712

········}·else·{

1712

········}·else·{

1714

············qemu_log("grlib_irqmp_set_irq·"·"Raise·CPU·IRQ·%d"·"\n",·irq);

1714

············qemu_log("grlib_irqmp_set_irq·"·"Raise·CPU·IRQ·%d"·"\n",·irq);

1715

#line·1717·"trace/trace-hw_intc.h"

1715

#line·1717·"trace/trace-hw_intc.h"

1716

········}

1716

········}

1717

····}

1717

····}

1718

}

1718

}

1719

static·inline·void·trace_grlib_irqmp_set_irq(int·irq)

1719

static·inline·void·trace_grlib_irqmp_set_irq(int·irq)

1731

static·inline·void·_nocheck__trace_grlib_irqmp_readl_unknown(uint64_t·addr)

1731

static·inline·void·_nocheck__trace_grlib_irqmp_readl_unknown(uint64_t·addr)

1732

{

1732

{

1733

····if·(trace_event_get_state(TRACE_GRLIB_IRQMP_READL_UNKNOWN)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1733

····if·(trace_event_get_state(TRACE_GRLIB_IRQMP_READL_UNKNOWN)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1734

········if·(message_with_timestamp)·{

1734

········if·(message_with_timestamp)·{

1735

············struct·timeval·_now;

1735

············struct·timeval·_now;

1736

············gettimeofday(&_now,·NULL);

1736

············gettimeofday(&_now,·NULL);

1738

············qemu_log("%d@%zu.%06zu:grlib_irqmp_readl_unknown·"·"addr·0x%"PRIx64·"\n",

1738

············qemu_log("%d@%zu.%06zu:grlib_irqmp_readl_unknown·"·"addr·0x%"PRIx64·"\n",

1739

·····················qemu_get_thread_id(),

1739

·····················qemu_get_thread_id(),

1740

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1740

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1741

·····················,·addr);

1741

·····················,·addr);

1742

#line·1744·"trace/trace-hw_intc.h"

1742

#line·1744·"trace/trace-hw_intc.h"

1743

········}·else·{

1743

········}·else·{

1745

············qemu_log("grlib_irqmp_readl_unknown·"·"addr·0x%"PRIx64·"\n",·addr);

1745

············qemu_log("grlib_irqmp_readl_unknown·"·"addr·0x%"PRIx64·"\n",·addr);

1746

#line·1748·"trace/trace-hw_intc.h"

1746

#line·1748·"trace/trace-hw_intc.h"

1747

········}

1747

········}

1748

····}

1748

····}

1749

}

1749

}

1750

static·inline·void·trace_grlib_irqmp_readl_unknown(uint64_t·addr)

1750

static·inline·void·trace_grlib_irqmp_readl_unknown(uint64_t·addr)

1762

static·inline·void·_nocheck__trace_grlib_irqmp_writel_unknown(uint64_t·addr,·uint32_t·value)

1762

static·inline·void·_nocheck__trace_grlib_irqmp_writel_unknown(uint64_t·addr,·uint32_t·value)

1763

{

1763

{

1764

····if·(trace_event_get_state(TRACE_GRLIB_IRQMP_WRITEL_UNKNOWN)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1764

····if·(trace_event_get_state(TRACE_GRLIB_IRQMP_WRITEL_UNKNOWN)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1765

········if·(message_with_timestamp)·{

1765

········if·(message_with_timestamp)·{

1766

············struct·timeval·_now;

1766

············struct·timeval·_now;

1767

············gettimeofday(&_now,·NULL);

1767

············gettimeofday(&_now,·NULL);

1769

············qemu_log("%d@%zu.%06zu:grlib_irqmp_writel_unknown·"·"addr·0x%"PRIx64"·value·0x%x"·"\n",

1769

············qemu_log("%d@%zu.%06zu:grlib_irqmp_writel_unknown·"·"addr·0x%"PRIx64"·value·0x%x"·"\n",

1770

·····················qemu_get_thread_id(),

1770

·····················qemu_get_thread_id(),

1771

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1771

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1772

·····················,·addr,·value);

1772

·····················,·addr,·value);

1773

#line·1775·"trace/trace-hw_intc.h"

1773

#line·1775·"trace/trace-hw_intc.h"

1774

········}·else·{

1774

········}·else·{

1776

············qemu_log("grlib_irqmp_writel_unknown·"·"addr·0x%"PRIx64"·value·0x%x"·"\n",·addr,·value);

1776

············qemu_log("grlib_irqmp_writel_unknown·"·"addr·0x%"PRIx64"·value·0x%x"·"\n",·addr,·value);

1777

#line·1779·"trace/trace-hw_intc.h"

1777

#line·1779·"trace/trace-hw_intc.h"

1778

········}

1778

········}

1779

····}

1779

····}

1780

}

1780

}

1781

static·inline·void·trace_grlib_irqmp_writel_unknown(uint64_t·addr,·uint32_t·value)

1781

static·inline·void·trace_grlib_irqmp_writel_unknown(uint64_t·addr,·uint32_t·value)

1793

static·inline·void·_nocheck__trace_xics_icp_check_ipi(int·server,·uint8_t·mfrr)

1793

static·inline·void·_nocheck__trace_xics_icp_check_ipi(int·server,·uint8_t·mfrr)

1794

{

1794

{

1795

····if·(trace_event_get_state(TRACE_XICS_ICP_CHECK_IPI)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1795

····if·(trace_event_get_state(TRACE_XICS_ICP_CHECK_IPI)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1796

········if·(message_with_timestamp)·{

1796

········if·(message_with_timestamp)·{

1797

············struct·timeval·_now;

1797

············struct·timeval·_now;

1798

············gettimeofday(&_now,·NULL);

1798

············gettimeofday(&_now,·NULL);

1800

············qemu_log("%d@%zu.%06zu:xics_icp_check_ipi·"·"CPU·%d·can·take·IPI·mfrr=0x%x"·"\n",

1800

············qemu_log("%d@%zu.%06zu:xics_icp_check_ipi·"·"CPU·%d·can·take·IPI·mfrr=0x%x"·"\n",

1801

·····················qemu_get_thread_id(),

1801

·····················qemu_get_thread_id(),

1802

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1802

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1803

·····················,·server,·mfrr);

1803

·····················,·server,·mfrr);

1804

#line·1806·"trace/trace-hw_intc.h"

1804

#line·1806·"trace/trace-hw_intc.h"

1805

········}·else·{

1805

········}·else·{

1807

············qemu_log("xics_icp_check_ipi·"·"CPU·%d·can·take·IPI·mfrr=0x%x"·"\n",·server,·mfrr);

1807

············qemu_log("xics_icp_check_ipi·"·"CPU·%d·can·take·IPI·mfrr=0x%x"·"\n",·server,·mfrr);

1808

#line·1810·"trace/trace-hw_intc.h"

1808

#line·1810·"trace/trace-hw_intc.h"

1809

········}

1809

········}

1810

····}

1810

····}

1811

}

1811

}

1812

static·inline·void·trace_xics_icp_check_ipi(int·server,·uint8_t·mfrr)

1812

static·inline·void·trace_xics_icp_check_ipi(int·server,·uint8_t·mfrr)

1824

static·inline·void·_nocheck__trace_xics_icp_accept(uint32_t·old_xirr,·uint32_t·new_xirr)

1824

static·inline·void·_nocheck__trace_xics_icp_accept(uint32_t·old_xirr,·uint32_t·new_xirr)

1825

{

1825

{

1826

····if·(trace_event_get_state(TRACE_XICS_ICP_ACCEPT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1826

····if·(trace_event_get_state(TRACE_XICS_ICP_ACCEPT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1827

········if·(message_with_timestamp)·{

1827

········if·(message_with_timestamp)·{

1828

············struct·timeval·_now;

1828

············struct·timeval·_now;

1829

············gettimeofday(&_now,·NULL);

1829

············gettimeofday(&_now,·NULL);

1831

············qemu_log("%d@%zu.%06zu:xics_icp_accept·"·"icp_accept:·XIRR·0x%"PRIx32"->0x%"PRIx32·"\n",

1831

············qemu_log("%d@%zu.%06zu:xics_icp_accept·"·"icp_accept:·XIRR·0x%"PRIx32"->0x%"PRIx32·"\n",

1832

·····················qemu_get_thread_id(),

1832

·····················qemu_get_thread_id(),

1833

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1833

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1834

·····················,·old_xirr,·new_xirr);

1834

·····················,·old_xirr,·new_xirr);

1835

#line·1837·"trace/trace-hw_intc.h"

1835

#line·1837·"trace/trace-hw_intc.h"

1836

········}·else·{

1836

········}·else·{

1838

············qemu_log("xics_icp_accept·"·"icp_accept:·XIRR·0x%"PRIx32"->0x%"PRIx32·"\n",·old_xirr,·new_xirr);

1838

············qemu_log("xics_icp_accept·"·"icp_accept:·XIRR·0x%"PRIx32"->0x%"PRIx32·"\n",·old_xirr,·new_xirr);

1839

#line·1841·"trace/trace-hw_intc.h"

1839

#line·1841·"trace/trace-hw_intc.h"

1840

········}

1840

········}

1841

····}

1841

····}

1842

}

1842

}

1843

static·inline·void·trace_xics_icp_accept(uint32_t·old_xirr,·uint32_t·new_xirr)

1843

static·inline·void·trace_xics_icp_accept(uint32_t·old_xirr,·uint32_t·new_xirr)

1855

static·inline·void·_nocheck__trace_xics_icp_eoi(int·server,·uint32_t·xirr,·uint32_t·new_xirr)

1855

static·inline·void·_nocheck__trace_xics_icp_eoi(int·server,·uint32_t·xirr,·uint32_t·new_xirr)

1856

{

1856

{

1857

····if·(trace_event_get_state(TRACE_XICS_ICP_EOI)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1857

····if·(trace_event_get_state(TRACE_XICS_ICP_EOI)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1858

········if·(message_with_timestamp)·{

1858

········if·(message_with_timestamp)·{

1859

············struct·timeval·_now;

1859

············struct·timeval·_now;

1860

············gettimeofday(&_now,·NULL);

1860

············gettimeofday(&_now,·NULL);

1862

············qemu_log("%d@%zu.%06zu:xics_icp_eoi·"·"icp_eoi:·server·%d·given·XIRR·0x%"PRIx32"·new·XIRR·0x%"PRIx32·"\n",

1862

············qemu_log("%d@%zu.%06zu:xics_icp_eoi·"·"icp_eoi:·server·%d·given·XIRR·0x%"PRIx32"·new·XIRR·0x%"PRIx32·"\n",

1863

·····················qemu_get_thread_id(),

1863

·····················qemu_get_thread_id(),

1864

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1864

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1865

·····················,·server,·xirr,·new_xirr);

1865

·····················,·server,·xirr,·new_xirr);

1866

#line·1868·"trace/trace-hw_intc.h"

1866

#line·1868·"trace/trace-hw_intc.h"

1867

········}·else·{

1867

········}·else·{

1869

············qemu_log("xics_icp_eoi·"·"icp_eoi:·server·%d·given·XIRR·0x%"PRIx32"·new·XIRR·0x%"PRIx32·"\n",·server,·xirr,·new_xirr);

1869

············qemu_log("xics_icp_eoi·"·"icp_eoi:·server·%d·given·XIRR·0x%"PRIx32"·new·XIRR·0x%"PRIx32·"\n",·server,·xirr,·new_xirr);

1870

#line·1872·"trace/trace-hw_intc.h"

1870

#line·1872·"trace/trace-hw_intc.h"

1871

········}

1871

········}

1872

····}

1872

····}

1873

}

1873

}

1874

static·inline·void·trace_xics_icp_eoi(int·server,·uint32_t·xirr,·uint32_t·new_xirr)

1874

static·inline·void·trace_xics_icp_eoi(int·server,·uint32_t·xirr,·uint32_t·new_xirr)

1886

static·inline·void·_nocheck__trace_xics_icp_irq(int·server,·int·nr,·uint8_t·priority)

1886

static·inline·void·_nocheck__trace_xics_icp_irq(int·server,·int·nr,·uint8_t·priority)

1887

{

1887

{

1888

····if·(trace_event_get_state(TRACE_XICS_ICP_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1888

····if·(trace_event_get_state(TRACE_XICS_ICP_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1889

········if·(message_with_timestamp)·{

1889

········if·(message_with_timestamp)·{

1890

············struct·timeval·_now;

1890

············struct·timeval·_now;

1891

············gettimeofday(&_now,·NULL);

1891

············gettimeofday(&_now,·NULL);

1893

············qemu_log("%d@%zu.%06zu:xics_icp_irq·"·"cpu·%d·trying·to·deliver·irq·0x%"PRIx32"·priority·0x%x"·"\n",

1893

············qemu_log("%d@%zu.%06zu:xics_icp_irq·"·"cpu·%d·trying·to·deliver·irq·0x%"PRIx32"·priority·0x%x"·"\n",

1894

·····················qemu_get_thread_id(),

1894

·····················qemu_get_thread_id(),

1895

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1895

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1896

·····················,·server,·nr,·priority);

1896

·····················,·server,·nr,·priority);

1897

#line·1899·"trace/trace-hw_intc.h"

1897

#line·1899·"trace/trace-hw_intc.h"

1898

········}·else·{

1898

········}·else·{

1900

············qemu_log("xics_icp_irq·"·"cpu·%d·trying·to·deliver·irq·0x%"PRIx32"·priority·0x%x"·"\n",·server,·nr,·priority);

1900

············qemu_log("xics_icp_irq·"·"cpu·%d·trying·to·deliver·irq·0x%"PRIx32"·priority·0x%x"·"\n",·server,·nr,·priority);

1901

#line·1903·"trace/trace-hw_intc.h"

1901

#line·1903·"trace/trace-hw_intc.h"

1902

········}

1902

········}

1903

····}

1903

····}

1904

}

1904

}

1905

static·inline·void·trace_xics_icp_irq(int·server,·int·nr,·uint8_t·priority)

1905

static·inline·void·trace_xics_icp_irq(int·server,·int·nr,·uint8_t·priority)

1917

static·inline·void·_nocheck__trace_xics_icp_raise(uint32_t·xirr,·uint8_t·pending_priority)

1917

static·inline·void·_nocheck__trace_xics_icp_raise(uint32_t·xirr,·uint8_t·pending_priority)

1918

{

1918

{

1919

····if·(trace_event_get_state(TRACE_XICS_ICP_RAISE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1919

····if·(trace_event_get_state(TRACE_XICS_ICP_RAISE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1920

········if·(message_with_timestamp)·{

1920

········if·(message_with_timestamp)·{

1921

············struct·timeval·_now;

1921

············struct·timeval·_now;

1922

············gettimeofday(&_now,·NULL);

1922

············gettimeofday(&_now,·NULL);

1924

············qemu_log("%d@%zu.%06zu:xics_icp_raise·"·"raising·IRQ·new·XIRR=0x%x·new·pending·priority=0x%x"·"\n",

1924

············qemu_log("%d@%zu.%06zu:xics_icp_raise·"·"raising·IRQ·new·XIRR=0x%x·new·pending·priority=0x%x"·"\n",

1925

·····················qemu_get_thread_id(),

1925

·····················qemu_get_thread_id(),

1926

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1926

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1927

·····················,·xirr,·pending_priority);

1927

·····················,·xirr,·pending_priority);

1928

#line·1930·"trace/trace-hw_intc.h"

1928

#line·1930·"trace/trace-hw_intc.h"

1929

········}·else·{

1929

········}·else·{

1931

············qemu_log("xics_icp_raise·"·"raising·IRQ·new·XIRR=0x%x·new·pending·priority=0x%x"·"\n",·xirr,·pending_priority);

1931

············qemu_log("xics_icp_raise·"·"raising·IRQ·new·XIRR=0x%x·new·pending·priority=0x%x"·"\n",·xirr,·pending_priority);

1932

#line·1934·"trace/trace-hw_intc.h"

1932

#line·1934·"trace/trace-hw_intc.h"

1933

········}

1933

········}

1934

····}

1934

····}

1935

}

1935

}

1936

static·inline·void·trace_xics_icp_raise(uint32_t·xirr,·uint8_t·pending_priority)

1936

static·inline·void·trace_xics_icp_raise(uint32_t·xirr,·uint8_t·pending_priority)

1948

static·inline·void·_nocheck__trace_xics_ics_set_irq_msi(int·srcno,·int·nr)

1948

static·inline·void·_nocheck__trace_xics_ics_set_irq_msi(int·srcno,·int·nr)

1949

{

1949

{

1950

····if·(trace_event_get_state(TRACE_XICS_ICS_SET_IRQ_MSI)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1950

····if·(trace_event_get_state(TRACE_XICS_ICS_SET_IRQ_MSI)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1951

········if·(message_with_timestamp)·{

1951

········if·(message_with_timestamp)·{

1952

············struct·timeval·_now;

1952

············struct·timeval·_now;

1953

············gettimeofday(&_now,·NULL);

1953

············gettimeofday(&_now,·NULL);

1955

············qemu_log("%d@%zu.%06zu:xics_ics_set_irq_msi·"·"set_irq_msi:·srcno·%d·[irq·0x%x]"·"\n",

1955

············qemu_log("%d@%zu.%06zu:xics_ics_set_irq_msi·"·"set_irq_msi:·srcno·%d·[irq·0x%x]"·"\n",

1956

·····················qemu_get_thread_id(),

1956

·····················qemu_get_thread_id(),

1957

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1957

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1958

·····················,·srcno,·nr);

1958

·····················,·srcno,·nr);

1959

#line·1961·"trace/trace-hw_intc.h"

1959

#line·1961·"trace/trace-hw_intc.h"

1960

········}·else·{

1960

········}·else·{

1962

············qemu_log("xics_ics_set_irq_msi·"·"set_irq_msi:·srcno·%d·[irq·0x%x]"·"\n",·srcno,·nr);

1962

············qemu_log("xics_ics_set_irq_msi·"·"set_irq_msi:·srcno·%d·[irq·0x%x]"·"\n",·srcno,·nr);

1963

#line·1965·"trace/trace-hw_intc.h"

1963

#line·1965·"trace/trace-hw_intc.h"

1964

········}

1964

········}

1965

····}

1965

····}

1966

}

1966

}

1967

static·inline·void·trace_xics_ics_set_irq_msi(int·srcno,·int·nr)

1967

static·inline·void·trace_xics_ics_set_irq_msi(int·srcno,·int·nr)

1979

static·inline·void·_nocheck__trace_xics_masked_pending(void)

1979

static·inline·void·_nocheck__trace_xics_masked_pending(void)

1980

{

1980

{

1981

····if·(trace_event_get_state(TRACE_XICS_MASKED_PENDING)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1981

····if·(trace_event_get_state(TRACE_XICS_MASKED_PENDING)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1982

········if·(message_with_timestamp)·{

1982

········if·(message_with_timestamp)·{

1983

············struct·timeval·_now;

1983

············struct·timeval·_now;

1984

············gettimeofday(&_now,·NULL);

1984

············gettimeofday(&_now,·NULL);

1986

············qemu_log("%d@%zu.%06zu:xics_masked_pending·"·"set_irq_msi:·masked·pending"·"\n",

1986

············qemu_log("%d@%zu.%06zu:xics_masked_pending·"·"set_irq_msi:·masked·pending"·"\n",

1987

·····················qemu_get_thread_id(),

1987

·····················qemu_get_thread_id(),

1988

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1988

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1989

·····················);

1989

·····················);

1990

#line·1992·"trace/trace-hw_intc.h"

1990

#line·1992·"trace/trace-hw_intc.h"

1991

········}·else·{

1991

········}·else·{

1993

············qemu_log("xics_masked_pending·"·"set_irq_msi:·masked·pending"·"\n");

1993

············qemu_log("xics_masked_pending·"·"set_irq_msi:·masked·pending"·"\n");

1994

#line·1996·"trace/trace-hw_intc.h"

1994

#line·1996·"trace/trace-hw_intc.h"

1995

········}

1995

········}

1996

····}

1996

····}

1997

}

1997

}

1998

static·inline·void·trace_xics_masked_pending(void)

1998

static·inline·void·trace_xics_masked_pending(void)

2010

static·inline·void·_nocheck__trace_xics_ics_set_irq_lsi(int·srcno,·int·nr)

2010

static·inline·void·_nocheck__trace_xics_ics_set_irq_lsi(int·srcno,·int·nr)

2011

{

2011

{

2012

····if·(trace_event_get_state(TRACE_XICS_ICS_SET_IRQ_LSI)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2012

····if·(trace_event_get_state(TRACE_XICS_ICS_SET_IRQ_LSI)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2013

········if·(message_with_timestamp)·{

2013

········if·(message_with_timestamp)·{

2014

············struct·timeval·_now;

2014

············struct·timeval·_now;

2015

············gettimeofday(&_now,·NULL);

2015

············gettimeofday(&_now,·NULL);

2017

············qemu_log("%d@%zu.%06zu:xics_ics_set_irq_lsi·"·"set_irq_lsi:·srcno·%d·[irq·0x%x]"·"\n",

2017

············qemu_log("%d@%zu.%06zu:xics_ics_set_irq_lsi·"·"set_irq_lsi:·srcno·%d·[irq·0x%x]"·"\n",

2018

·····················qemu_get_thread_id(),

2018

·····················qemu_get_thread_id(),

2019

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2019

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2020

·····················,·srcno,·nr);

2020

·····················,·srcno,·nr);

2021

#line·2023·"trace/trace-hw_intc.h"

2021

#line·2023·"trace/trace-hw_intc.h"

2022

········}·else·{

2022

········}·else·{

2024

············qemu_log("xics_ics_set_irq_lsi·"·"set_irq_lsi:·srcno·%d·[irq·0x%x]"·"\n",·srcno,·nr);

2024

············qemu_log("xics_ics_set_irq_lsi·"·"set_irq_lsi:·srcno·%d·[irq·0x%x]"·"\n",·srcno,·nr);

2025

#line·2027·"trace/trace-hw_intc.h"

2025

#line·2027·"trace/trace-hw_intc.h"

2026

········}

2026

········}

2027

····}

2027

····}

2028

}

2028

}

2029

static·inline·void·trace_xics_ics_set_irq_lsi(int·srcno,·int·nr)

2029

static·inline·void·trace_xics_ics_set_irq_lsi(int·srcno,·int·nr)

2041

static·inline·void·_nocheck__trace_xics_ics_write_xive(int·nr,·int·srcno,·int·server,·uint8_t·priority)

2041

static·inline·void·_nocheck__trace_xics_ics_write_xive(int·nr,·int·srcno,·int·server,·uint8_t·priority)

2042

{

2042

{

2043

····if·(trace_event_get_state(TRACE_XICS_ICS_WRITE_XIVE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2043

····if·(trace_event_get_state(TRACE_XICS_ICS_WRITE_XIVE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2044

········if·(message_with_timestamp)·{

2044

········if·(message_with_timestamp)·{

2045

············struct·timeval·_now;

2045

············struct·timeval·_now;

2046

············gettimeofday(&_now,·NULL);

2046

············gettimeofday(&_now,·NULL);

2048

············qemu_log("%d@%zu.%06zu:xics_ics_write_xive·"·"ics_write_xive:·irq·0x%x·[src·%d]·server·0x%x·prio·0x%x"·"\n",

2048

············qemu_log("%d@%zu.%06zu:xics_ics_write_xive·"·"ics_write_xive:·irq·0x%x·[src·%d]·server·0x%x·prio·0x%x"·"\n",

2049

·····················qemu_get_thread_id(),

2049

·····················qemu_get_thread_id(),

2050

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2050

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2051

·····················,·nr,·srcno,·server,·priority);

2051

·····················,·nr,·srcno,·server,·priority);

2052

#line·2054·"trace/trace-hw_intc.h"

2052

#line·2054·"trace/trace-hw_intc.h"

2053

········}·else·{

2053

········}·else·{

2055

············qemu_log("xics_ics_write_xive·"·"ics_write_xive:·irq·0x%x·[src·%d]·server·0x%x·prio·0x%x"·"\n",·nr,·srcno,·server,·priority);

2055

············qemu_log("xics_ics_write_xive·"·"ics_write_xive:·irq·0x%x·[src·%d]·server·0x%x·prio·0x%x"·"\n",·nr,·srcno,·server,·priority);

2056

#line·2058·"trace/trace-hw_intc.h"

2056

#line·2058·"trace/trace-hw_intc.h"

2057

········}

2057

········}

2058

····}

2058

····}

2059

}

2059

}

2060

static·inline·void·trace_xics_ics_write_xive(int·nr,·int·srcno,·int·server,·uint8_t·priority)

2060

static·inline·void·trace_xics_ics_write_xive(int·nr,·int·srcno,·int·server,·uint8_t·priority)

2072

static·inline·void·_nocheck__trace_xics_ics_reject(int·nr,·int·srcno)

2072

static·inline·void·_nocheck__trace_xics_ics_reject(int·nr,·int·srcno)

2073

{

2073

{

2074

····if·(trace_event_get_state(TRACE_XICS_ICS_REJECT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2074

····if·(trace_event_get_state(TRACE_XICS_ICS_REJECT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2075

········if·(message_with_timestamp)·{

2075

········if·(message_with_timestamp)·{

2076

············struct·timeval·_now;

2076

············struct·timeval·_now;

2077

············gettimeofday(&_now,·NULL);

2077

············gettimeofday(&_now,·NULL);

2079

············qemu_log("%d@%zu.%06zu:xics_ics_reject·"·"reject·irq·0x%x·[src·%d]"·"\n",

2079

············qemu_log("%d@%zu.%06zu:xics_ics_reject·"·"reject·irq·0x%x·[src·%d]"·"\n",

2080

·····················qemu_get_thread_id(),

2080

·····················qemu_get_thread_id(),

2081

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2081

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2082

·····················,·nr,·srcno);

2082

·····················,·nr,·srcno);

2083

#line·2085·"trace/trace-hw_intc.h"

2083

#line·2085·"trace/trace-hw_intc.h"

2084

········}·else·{

2084

········}·else·{

2086

············qemu_log("xics_ics_reject·"·"reject·irq·0x%x·[src·%d]"·"\n",·nr,·srcno);

2086

············qemu_log("xics_ics_reject·"·"reject·irq·0x%x·[src·%d]"·"\n",·nr,·srcno);

2087

#line·2089·"trace/trace-hw_intc.h"

2087

#line·2089·"trace/trace-hw_intc.h"

2088

········}

2088

········}

2089

····}

2089

····}

2090

}

2090

}

2091

static·inline·void·trace_xics_ics_reject(int·nr,·int·srcno)

2091

static·inline·void·trace_xics_ics_reject(int·nr,·int·srcno)

2103

static·inline·void·_nocheck__trace_xics_ics_eoi(int·nr)

2103

static·inline·void·_nocheck__trace_xics_ics_eoi(int·nr)

2104

{

2104

{

2105

····if·(trace_event_get_state(TRACE_XICS_ICS_EOI)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2105

····if·(trace_event_get_state(TRACE_XICS_ICS_EOI)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2106

········if·(message_with_timestamp)·{

2106

········if·(message_with_timestamp)·{

2107

············struct·timeval·_now;

2107

············struct·timeval·_now;

2108

············gettimeofday(&_now,·NULL);

2108

············gettimeofday(&_now,·NULL);

2110

············qemu_log("%d@%zu.%06zu:xics_ics_eoi·"·"ics_eoi:·irq·0x%x"·"\n",

2110

············qemu_log("%d@%zu.%06zu:xics_ics_eoi·"·"ics_eoi:·irq·0x%x"·"\n",

2111

·····················qemu_get_thread_id(),

2111

·····················qemu_get_thread_id(),

2112

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2112

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2113

·····················,·nr);

2113

·····················,·nr);

2114

#line·2116·"trace/trace-hw_intc.h"

2114

#line·2116·"trace/trace-hw_intc.h"

2115

········}·else·{

2115

········}·else·{

2117

············qemu_log("xics_ics_eoi·"·"ics_eoi:·irq·0x%x"·"\n",·nr);

2117

············qemu_log("xics_ics_eoi·"·"ics_eoi:·irq·0x%x"·"\n",·nr);

2118

#line·2120·"trace/trace-hw_intc.h"

2118

#line·2120·"trace/trace-hw_intc.h"

2119

········}

2119

········}

2120

····}

2120

····}

2121

}

2121

}

2122

static·inline·void·trace_xics_ics_eoi(int·nr)

2122

static·inline·void·trace_xics_ics_eoi(int·nr)

2134

static·inline·void·_nocheck__trace_flic_create_device(int·err)

2134

static·inline·void·_nocheck__trace_flic_create_device(int·err)

2135

{

2135

{

2136

····if·(trace_event_get_state(TRACE_FLIC_CREATE_DEVICE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2136

····if·(trace_event_get_state(TRACE_FLIC_CREATE_DEVICE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2137

········if·(message_with_timestamp)·{

2137

········if·(message_with_timestamp)·{

2138

············struct·timeval·_now;

2138

············struct·timeval·_now;

2139

············gettimeofday(&_now,·NULL);

2139

············gettimeofday(&_now,·NULL);

2141

············qemu_log("%d@%zu.%06zu:flic_create_device·"·"flic:·create·device·failed·%d"·"\n",

2141

············qemu_log("%d@%zu.%06zu:flic_create_device·"·"flic:·create·device·failed·%d"·"\n",

2142

·····················qemu_get_thread_id(),

2142

·····················qemu_get_thread_id(),

2143

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2143

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2144

·····················,·err);

2144

·····················,·err);

2145

#line·2147·"trace/trace-hw_intc.h"

2145

#line·2147·"trace/trace-hw_intc.h"

2146

········}·else·{

2146

········}·else·{

2148

············qemu_log("flic_create_device·"·"flic:·create·device·failed·%d"·"\n",·err);

2148

············qemu_log("flic_create_device·"·"flic:·create·device·failed·%d"·"\n",·err);

2149

#line·2151·"trace/trace-hw_intc.h"

2149

#line·2151·"trace/trace-hw_intc.h"

2150

········}

2150

········}

2151

····}

2151

····}

2152

}

2152

}

2153

static·inline·void·trace_flic_create_device(int·err)

2153

static·inline·void·trace_flic_create_device(int·err)

2165

static·inline·void·_nocheck__trace_flic_reset_failed(int·err)

2165

static·inline·void·_nocheck__trace_flic_reset_failed(int·err)

2166

{

2166

{

2167

····if·(trace_event_get_state(TRACE_FLIC_RESET_FAILED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2167

····if·(trace_event_get_state(TRACE_FLIC_RESET_FAILED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2168

········if·(message_with_timestamp)·{

2168

········if·(message_with_timestamp)·{

2169

············struct·timeval·_now;

2169

············struct·timeval·_now;

2170

············gettimeofday(&_now,·NULL);

2170

············gettimeofday(&_now,·NULL);

2172

············qemu_log("%d@%zu.%06zu:flic_reset_failed·"·"flic:·reset·failed·%d"·"\n",

2172

············qemu_log("%d@%zu.%06zu:flic_reset_failed·"·"flic:·reset·failed·%d"·"\n",

2173

·····················qemu_get_thread_id(),

2173

·····················qemu_get_thread_id(),

2174

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2174

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2175

·····················,·err);

2175

·····················,·err);

2176

#line·2178·"trace/trace-hw_intc.h"

2176

#line·2178·"trace/trace-hw_intc.h"

2177

········}·else·{

2177

········}·else·{

2179

············qemu_log("flic_reset_failed·"·"flic:·reset·failed·%d"·"\n",·err);

2179

············qemu_log("flic_reset_failed·"·"flic:·reset·failed·%d"·"\n",·err);

2180

#line·2182·"trace/trace-hw_intc.h"

2180

#line·2182·"trace/trace-hw_intc.h"

2181

········}

2181

········}

2182

····}

2182

····}

2183

}

2183

}

2184

static·inline·void·trace_flic_reset_failed(int·err)

2184

static·inline·void·trace_flic_reset_failed(int·err)

2196

static·inline·void·_nocheck__trace_qemu_s390_airq_suppressed(uint8_t·type,·uint8_t·isc)

2196

static·inline·void·_nocheck__trace_qemu_s390_airq_suppressed(uint8_t·type,·uint8_t·isc)

2197

{

2197

{

2198

····if·(trace_event_get_state(TRACE_QEMU_S390_AIRQ_SUPPRESSED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2198

····if·(trace_event_get_state(TRACE_QEMU_S390_AIRQ_SUPPRESSED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2199

········if·(message_with_timestamp)·{

2199

········if·(message_with_timestamp)·{

2200

············struct·timeval·_now;

2200

············struct·timeval·_now;

2201

············gettimeofday(&_now,·NULL);

2201

············gettimeofday(&_now,·NULL);

2203

············qemu_log("%d@%zu.%06zu:qemu_s390_airq_suppressed·"·"flic:·adapter·I/O·interrupt·suppressed·(type·0x%x·isc·0x%x)"·"\n",

2203

············qemu_log("%d@%zu.%06zu:qemu_s390_airq_suppressed·"·"flic:·adapter·I/O·interrupt·suppressed·(type·0x%x·isc·0x%x)"·"\n",

2204

·····················qemu_get_thread_id(),

2204

·····················qemu_get_thread_id(),

2205

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2205

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2206

·····················,·type,·isc);

2206

·····················,·type,·isc);

2207

#line·2209·"trace/trace-hw_intc.h"

2207

#line·2209·"trace/trace-hw_intc.h"

2208

········}·else·{

2208

········}·else·{

2210

············qemu_log("qemu_s390_airq_suppressed·"·"flic:·adapter·I/O·interrupt·suppressed·(type·0x%x·isc·0x%x)"·"\n",·type,·isc);

2210

············qemu_log("qemu_s390_airq_suppressed·"·"flic:·adapter·I/O·interrupt·suppressed·(type·0x%x·isc·0x%x)"·"\n",·type,·isc);

2211

#line·2213·"trace/trace-hw_intc.h"

2211

#line·2213·"trace/trace-hw_intc.h"

2212

········}

2212

········}

2213

····}

2213

····}

2214

}

2214

}

2215

static·inline·void·trace_qemu_s390_airq_suppressed(uint8_t·type,·uint8_t·isc)

2215

static·inline·void·trace_qemu_s390_airq_suppressed(uint8_t·type,·uint8_t·isc)

2227

static·inline·void·_nocheck__trace_qemu_s390_suppress_airq(uint8_t·isc,·const·char·*·from,·const·char·*·to)

2227

static·inline·void·_nocheck__trace_qemu_s390_suppress_airq(uint8_t·isc,·const·char·*·from,·const·char·*·to)

2228

{

2228

{

2229

····if·(trace_event_get_state(TRACE_QEMU_S390_SUPPRESS_AIRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2229

····if·(trace_event_get_state(TRACE_QEMU_S390_SUPPRESS_AIRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2230

········if·(message_with_timestamp)·{

2230

········if·(message_with_timestamp)·{

2231

············struct·timeval·_now;

2231

············struct·timeval·_now;

2232

············gettimeofday(&_now,·NULL);

2232

············gettimeofday(&_now,·NULL);

2234

············qemu_log("%d@%zu.%06zu:qemu_s390_suppress_airq·"·"flic:·for·isc·0x%x,·suppress·airq·by·modifying·ais·mode·from·%s·to·%s"·"\n",

2234

············qemu_log("%d@%zu.%06zu:qemu_s390_suppress_airq·"·"flic:·for·isc·0x%x,·suppress·airq·by·modifying·ais·mode·from·%s·to·%s"·"\n",

2235

·····················qemu_get_thread_id(),

2235

·····················qemu_get_thread_id(),

2236

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2236

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2237

·····················,·isc,·from,·to);

2237

·····················,·isc,·from,·to);

2238

#line·2240·"trace/trace-hw_intc.h"

2238

#line·2240·"trace/trace-hw_intc.h"

2239

········}·else·{

2239

········}·else·{

2241

············qemu_log("qemu_s390_suppress_airq·"·"flic:·for·isc·0x%x,·suppress·airq·by·modifying·ais·mode·from·%s·to·%s"·"\n",·isc,·from,·to);

2241

············qemu_log("qemu_s390_suppress_airq·"·"flic:·for·isc·0x%x,·suppress·airq·by·modifying·ais·mode·from·%s·to·%s"·"\n",·isc,·from,·to);

2242

#line·2244·"trace/trace-hw_intc.h"

2242

#line·2244·"trace/trace-hw_intc.h"

2243

········}

2243

········}

2244

····}

2244

····}

2245

}

2245

}

2246

static·inline·void·trace_qemu_s390_suppress_airq(uint8_t·isc,·const·char·*·from,·const·char·*·to)

2246

static·inline·void·trace_qemu_s390_suppress_airq(uint8_t·isc,·const·char·*·from,·const·char·*·to)

2258

static·inline·void·_nocheck__trace_aspeed_vic_set_irq(int·irq,·int·level)

2258

static·inline·void·_nocheck__trace_aspeed_vic_set_irq(int·irq,·int·level)

2259

{

2259

{

2260

····if·(trace_event_get_state(TRACE_ASPEED_VIC_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2260

····if·(trace_event_get_state(TRACE_ASPEED_VIC_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2261

········if·(message_with_timestamp)·{

2261

········if·(message_with_timestamp)·{

2262

············struct·timeval·_now;

2262

············struct·timeval·_now;

2263

············gettimeofday(&_now,·NULL);

2263

············gettimeofday(&_now,·NULL);

2265

············qemu_log("%d@%zu.%06zu:aspeed_vic_set_irq·"·"Enabling·IRQ·%d:·%d"·"\n",

2265

············qemu_log("%d@%zu.%06zu:aspeed_vic_set_irq·"·"Enabling·IRQ·%d:·%d"·"\n",

2266

·····················qemu_get_thread_id(),

2266

·····················qemu_get_thread_id(),

2267

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2267

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2268

·····················,·irq,·level);

2268

·····················,·irq,·level);

2269

#line·2271·"trace/trace-hw_intc.h"

2269

#line·2271·"trace/trace-hw_intc.h"

2270

········}·else·{

2270

········}·else·{

2272

············qemu_log("aspeed_vic_set_irq·"·"Enabling·IRQ·%d:·%d"·"\n",·irq,·level);

2272

············qemu_log("aspeed_vic_set_irq·"·"Enabling·IRQ·%d:·%d"·"\n",·irq,·level);

2273

#line·2275·"trace/trace-hw_intc.h"

2273

#line·2275·"trace/trace-hw_intc.h"

2274

········}

2274

········}

2275

····}

2275

····}

2276

}

2276

}

2277

static·inline·void·trace_aspeed_vic_set_irq(int·irq,·int·level)

2277

static·inline·void·trace_aspeed_vic_set_irq(int·irq,·int·level)

2289

static·inline·void·_nocheck__trace_aspeed_vic_update_fiq(int·flags)

2289

static·inline·void·_nocheck__trace_aspeed_vic_update_fiq(int·flags)

2290

{

2290

{

2291

····if·(trace_event_get_state(TRACE_ASPEED_VIC_UPDATE_FIQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2291

····if·(trace_event_get_state(TRACE_ASPEED_VIC_UPDATE_FIQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2292

········if·(message_with_timestamp)·{

2292

········if·(message_with_timestamp)·{

2293

············struct·timeval·_now;

2293

············struct·timeval·_now;

2294

············gettimeofday(&_now,·NULL);

2294

············gettimeofday(&_now,·NULL);

2296

············qemu_log("%d@%zu.%06zu:aspeed_vic_update_fiq·"·"Raising·FIQ:·%d"·"\n",

2296

············qemu_log("%d@%zu.%06zu:aspeed_vic_update_fiq·"·"Raising·FIQ:·%d"·"\n",

2297

·····················qemu_get_thread_id(),

2297

·····················qemu_get_thread_id(),

2298

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2298

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2299

·····················,·flags);

2299

·····················,·flags);

2300

#line·2302·"trace/trace-hw_intc.h"

2300

#line·2302·"trace/trace-hw_intc.h"

2301

········}·else·{

2301

········}·else·{

2303

············qemu_log("aspeed_vic_update_fiq·"·"Raising·FIQ:·%d"·"\n",·flags);

2303

············qemu_log("aspeed_vic_update_fiq·"·"Raising·FIQ:·%d"·"\n",·flags);

2304

#line·2306·"trace/trace-hw_intc.h"

2304

#line·2306·"trace/trace-hw_intc.h"

2305

········}

2305

········}

2306

····}

2306

····}

2307

}

2307

}

2308

static·inline·void·trace_aspeed_vic_update_fiq(int·flags)

2308

static·inline·void·trace_aspeed_vic_update_fiq(int·flags)

2320

static·inline·void·_nocheck__trace_aspeed_vic_update_irq(int·flags)

2320

static·inline·void·_nocheck__trace_aspeed_vic_update_irq(int·flags)

2321

{

2321

{

2322

····if·(trace_event_get_state(TRACE_ASPEED_VIC_UPDATE_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2322

····if·(trace_event_get_state(TRACE_ASPEED_VIC_UPDATE_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2323

········if·(message_with_timestamp)·{

2323

········if·(message_with_timestamp)·{

2324

············struct·timeval·_now;

2324

············struct·timeval·_now;

2325

············gettimeofday(&_now,·NULL);

2325

············gettimeofday(&_now,·NULL);

2327

············qemu_log("%d@%zu.%06zu:aspeed_vic_update_irq·"·"Raising·IRQ:·%d"·"\n",

2327

············qemu_log("%d@%zu.%06zu:aspeed_vic_update_irq·"·"Raising·IRQ:·%d"·"\n",

2328

·····················qemu_get_thread_id(),

2328

·····················qemu_get_thread_id(),

2329

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2329

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2330

·····················,·flags);

2330

·····················,·flags);

2331

#line·2333·"trace/trace-hw_intc.h"

2331

#line·2333·"trace/trace-hw_intc.h"

2332

········}·else·{

2332

········}·else·{

2334

············qemu_log("aspeed_vic_update_irq·"·"Raising·IRQ:·%d"·"\n",·flags);

2334

············qemu_log("aspeed_vic_update_irq·"·"Raising·IRQ:·%d"·"\n",·flags);

2335

#line·2337·"trace/trace-hw_intc.h"

2335

#line·2337·"trace/trace-hw_intc.h"

2336

········}

2336

········}

2337

····}

2337

····}

2338

}

2338

}

2339

static·inline·void·trace_aspeed_vic_update_irq(int·flags)

2339

static·inline·void·trace_aspeed_vic_update_irq(int·flags)

2351

static·inline·void·_nocheck__trace_aspeed_vic_read(uint64_t·offset,·unsigned·size,·uint32_t·value)

2351

static·inline·void·_nocheck__trace_aspeed_vic_read(uint64_t·offset,·unsigned·size,·uint32_t·value)

2352

{

2352

{

2353

····if·(trace_event_get_state(TRACE_ASPEED_VIC_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2353

····if·(trace_event_get_state(TRACE_ASPEED_VIC_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2354

········if·(message_with_timestamp)·{

2354

········if·(message_with_timestamp)·{

2355

············struct·timeval·_now;

2355

············struct·timeval·_now;

2356

············gettimeofday(&_now,·NULL);

2356

············gettimeofday(&_now,·NULL);

2358

············qemu_log("%d@%zu.%06zu:aspeed_vic_read·"·"From·0x%"·PRIx64·"·of·size·%u:·0x%"·PRIx32·"\n",

2358

············qemu_log("%d@%zu.%06zu:aspeed_vic_read·"·"From·0x%"·PRIx64·"·of·size·%u:·0x%"·PRIx32·"\n",

2359

·····················qemu_get_thread_id(),

2359

·····················qemu_get_thread_id(),

2360

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2360

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2361

·····················,·offset,·size,·value);

2361

·····················,·offset,·size,·value);

2362

#line·2364·"trace/trace-hw_intc.h"

2362

#line·2364·"trace/trace-hw_intc.h"

2363

········}·else·{

2363

········}·else·{

2365

············qemu_log("aspeed_vic_read·"·"From·0x%"·PRIx64·"·of·size·%u:·0x%"·PRIx32·"\n",·offset,·size,·value);

2365

············qemu_log("aspeed_vic_read·"·"From·0x%"·PRIx64·"·of·size·%u:·0x%"·PRIx32·"\n",·offset,·size,·value);

2366

#line·2368·"trace/trace-hw_intc.h"

2366

#line·2368·"trace/trace-hw_intc.h"

2367

········}

2367

········}

2368

····}

2368

····}

2369

}

2369

}

2370

static·inline·void·trace_aspeed_vic_read(uint64_t·offset,·unsigned·size,·uint32_t·value)

2370

static·inline·void·trace_aspeed_vic_read(uint64_t·offset,·unsigned·size,·uint32_t·value)

2382

static·inline·void·_nocheck__trace_aspeed_vic_write(uint64_t·offset,·unsigned·size,·uint32_t·data)

2382

static·inline·void·_nocheck__trace_aspeed_vic_write(uint64_t·offset,·unsigned·size,·uint32_t·data)

2383

{

2383

{

2384

····if·(trace_event_get_state(TRACE_ASPEED_VIC_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2384

····if·(trace_event_get_state(TRACE_ASPEED_VIC_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2385

········if·(message_with_timestamp)·{

2385

········if·(message_with_timestamp)·{

2386

············struct·timeval·_now;

2386

············struct·timeval·_now;

2387

············gettimeofday(&_now,·NULL);

2387

············gettimeofday(&_now,·NULL);

2389

············qemu_log("%d@%zu.%06zu:aspeed_vic_write·"·"To·0x%"·PRIx64·"·of·size·%u:·0x%"·PRIx32·"\n",

2389

············qemu_log("%d@%zu.%06zu:aspeed_vic_write·"·"To·0x%"·PRIx64·"·of·size·%u:·0x%"·PRIx32·"\n",

2390

·····················qemu_get_thread_id(),

2390

·····················qemu_get_thread_id(),

2391

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2391

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2392

·····················,·offset,·size,·data);

2392

·····················,·offset,·size,·data);

2393

#line·2395·"trace/trace-hw_intc.h"

2393

#line·2395·"trace/trace-hw_intc.h"

2394

········}·else·{

2394

········}·else·{

2396

············qemu_log("aspeed_vic_write·"·"To·0x%"·PRIx64·"·of·size·%u:·0x%"·PRIx32·"\n",·offset,·size,·data);

2396

············qemu_log("aspeed_vic_write·"·"To·0x%"·PRIx64·"·of·size·%u:·0x%"·PRIx32·"\n",·offset,·size,·data);

2397

#line·2399·"trace/trace-hw_intc.h"

2397

#line·2399·"trace/trace-hw_intc.h"

2398

········}

2398

········}

2399

····}

2399

····}

2400

}

2400

}

2401

static·inline·void·trace_aspeed_vic_write(uint64_t·offset,·unsigned·size,·uint32_t·data)

2401

static·inline·void·trace_aspeed_vic_write(uint64_t·offset,·unsigned·size,·uint32_t·data)

2413

static·inline·void·_nocheck__trace_gic_enable_irq(int·irq)

2413

static·inline·void·_nocheck__trace_gic_enable_irq(int·irq)

2414

{

2414

{

2415

····if·(trace_event_get_state(TRACE_GIC_ENABLE_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2415

····if·(trace_event_get_state(TRACE_GIC_ENABLE_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2416

········if·(message_with_timestamp)·{

2416

········if·(message_with_timestamp)·{

2417

············struct·timeval·_now;

2417

············struct·timeval·_now;

2418

············gettimeofday(&_now,·NULL);

2418

············gettimeofday(&_now,·NULL);

2420

············qemu_log("%d@%zu.%06zu:gic_enable_irq·"·"irq·%d·enabled"·"\n",

2420

············qemu_log("%d@%zu.%06zu:gic_enable_irq·"·"irq·%d·enabled"·"\n",

2421

·····················qemu_get_thread_id(),

2421

·····················qemu_get_thread_id(),

2422

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2422

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2423

·····················,·irq);

2423

·····················,·irq);

2424

#line·2426·"trace/trace-hw_intc.h"

2424

#line·2426·"trace/trace-hw_intc.h"

2425

········}·else·{

2425

········}·else·{

2427

············qemu_log("gic_enable_irq·"·"irq·%d·enabled"·"\n",·irq);

2427

············qemu_log("gic_enable_irq·"·"irq·%d·enabled"·"\n",·irq);

2428

#line·2430·"trace/trace-hw_intc.h"

2428

#line·2430·"trace/trace-hw_intc.h"

2429

········}

2429

········}

2430

····}

2430

····}

2431

}

2431

}

2432

static·inline·void·trace_gic_enable_irq(int·irq)

2432

static·inline·void·trace_gic_enable_irq(int·irq)

2444

static·inline·void·_nocheck__trace_gic_disable_irq(int·irq)

2444

static·inline·void·_nocheck__trace_gic_disable_irq(int·irq)

2445

{

2445

{

2446

····if·(trace_event_get_state(TRACE_GIC_DISABLE_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2446

····if·(trace_event_get_state(TRACE_GIC_DISABLE_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2447

········if·(message_with_timestamp)·{

2447

········if·(message_with_timestamp)·{

2448

············struct·timeval·_now;

2448

············struct·timeval·_now;

2449

············gettimeofday(&_now,·NULL);

2449

············gettimeofday(&_now,·NULL);

2451

············qemu_log("%d@%zu.%06zu:gic_disable_irq·"·"irq·%d·disabled"·"\n",

2451

············qemu_log("%d@%zu.%06zu:gic_disable_irq·"·"irq·%d·disabled"·"\n",

2452

·····················qemu_get_thread_id(),

2452

·····················qemu_get_thread_id(),

2453

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2453

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2454

·····················,·irq);

2454

·····················,·irq);

2455

#line·2457·"trace/trace-hw_intc.h"

2455

#line·2457·"trace/trace-hw_intc.h"

2456

········}·else·{

2456

········}·else·{

2458

············qemu_log("gic_disable_irq·"·"irq·%d·disabled"·"\n",·irq);

2458

············qemu_log("gic_disable_irq·"·"irq·%d·disabled"·"\n",·irq);

2459

#line·2461·"trace/trace-hw_intc.h"

2459

#line·2461·"trace/trace-hw_intc.h"

2460

········}

2460

········}

2461

····}

2461

····}

2462

}

2462

}

2463

static·inline·void·trace_gic_disable_irq(int·irq)

2463

static·inline·void·trace_gic_disable_irq(int·irq)

2475

static·inline·void·_nocheck__trace_gic_set_irq(int·irq,·int·level,·int·cpumask,·int·target)

2475

static·inline·void·_nocheck__trace_gic_set_irq(int·irq,·int·level,·int·cpumask,·int·target)

2476

{

2476

{

2477

····if·(trace_event_get_state(TRACE_GIC_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2477

····if·(trace_event_get_state(TRACE_GIC_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2478

········if·(message_with_timestamp)·{

2478

········if·(message_with_timestamp)·{

2479

············struct·timeval·_now;

2479

············struct·timeval·_now;

2480

············gettimeofday(&_now,·NULL);

2480

············gettimeofday(&_now,·NULL);

2482

············qemu_log("%d@%zu.%06zu:gic_set_irq·"·"irq·%d·level·%d·cpumask·0x%x·target·0x%x"·"\n",

2482

············qemu_log("%d@%zu.%06zu:gic_set_irq·"·"irq·%d·level·%d·cpumask·0x%x·target·0x%x"·"\n",

2483

·····················qemu_get_thread_id(),

2483

·····················qemu_get_thread_id(),

2484

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2484

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2485

·····················,·irq,·level,·cpumask,·target);

2485

·····················,·irq,·level,·cpumask,·target);

2486

#line·2488·"trace/trace-hw_intc.h"

2486

#line·2488·"trace/trace-hw_intc.h"

2487

········}·else·{

2487

········}·else·{

2489

············qemu_log("gic_set_irq·"·"irq·%d·level·%d·cpumask·0x%x·target·0x%x"·"\n",·irq,·level,·cpumask,·target);

2489

············qemu_log("gic_set_irq·"·"irq·%d·level·%d·cpumask·0x%x·target·0x%x"·"\n",·irq,·level,·cpumask,·target);

2490

#line·2492·"trace/trace-hw_intc.h"

2490

#line·2492·"trace/trace-hw_intc.h"

2491

········}

2491

········}

2492

····}

2492

····}

2493

}

2493

}

2494

static·inline·void·trace_gic_set_irq(int·irq,·int·level,·int·cpumask,·int·target)

2494

static·inline·void·trace_gic_set_irq(int·irq,·int·level,·int·cpumask,·int·target)

2506

static·inline·void·_nocheck__trace_gic_update_bestirq(const·char·*·s,·int·cpu,·int·irq,·int·prio,·int·priority_mask,·int·running_priority)

2506

static·inline·void·_nocheck__trace_gic_update_bestirq(const·char·*·s,·int·cpu,·int·irq,·int·prio,·int·priority_mask,·int·running_priority)

2507

{

2507

{

2508

····if·(trace_event_get_state(TRACE_GIC_UPDATE_BESTIRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2508

····if·(trace_event_get_state(TRACE_GIC_UPDATE_BESTIRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2509

········if·(message_with_timestamp)·{

2509

········if·(message_with_timestamp)·{

2510

············struct·timeval·_now;

2510

············struct·timeval·_now;

2511

············gettimeofday(&_now,·NULL);

2511

············gettimeofday(&_now,·NULL);

2513

············qemu_log("%d@%zu.%06zu:gic_update_bestirq·"·"%s·%d·irq·%d·priority·%d·cpu·priority·mask·%d·cpu·running·priority·%d"·"\n",

2513

············qemu_log("%d@%zu.%06zu:gic_update_bestirq·"·"%s·%d·irq·%d·priority·%d·cpu·priority·mask·%d·cpu·running·priority·%d"·"\n",

2514

·····················qemu_get_thread_id(),

2514

·····················qemu_get_thread_id(),

2515

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2515

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2516

·····················,·s,·cpu,·irq,·prio,·priority_mask,·running_priority);

2516

·····················,·s,·cpu,·irq,·prio,·priority_mask,·running_priority);

2517

#line·2519·"trace/trace-hw_intc.h"

2517

#line·2519·"trace/trace-hw_intc.h"

2518

········}·else·{

2518

········}·else·{

2520

············qemu_log("gic_update_bestirq·"·"%s·%d·irq·%d·priority·%d·cpu·priority·mask·%d·cpu·running·priority·%d"·"\n",·s,·cpu,·irq,·prio,·priority_mask,·running_priority);

2520

············qemu_log("gic_update_bestirq·"·"%s·%d·irq·%d·priority·%d·cpu·priority·mask·%d·cpu·running·priority·%d"·"\n",·s,·cpu,·irq,·prio,·priority_mask,·running_priority);

2521

#line·2523·"trace/trace-hw_intc.h"

2521

#line·2523·"trace/trace-hw_intc.h"

2522

········}

2522

········}

2523

····}

2523

····}

2524

}

2524

}

2525

static·inline·void·trace_gic_update_bestirq(const·char·*·s,·int·cpu,·int·irq,·int·prio,·int·priority_mask,·int·running_priority)

2525

static·inline·void·trace_gic_update_bestirq(const·char·*·s,·int·cpu,·int·irq,·int·prio,·int·priority_mask,·int·running_priority)

2537

static·inline·void·_nocheck__trace_gic_update_set_irq(int·cpu,·const·char·*·name,·int·level)

2537

static·inline·void·_nocheck__trace_gic_update_set_irq(int·cpu,·const·char·*·name,·int·level)

2538

{

2538

{

2539

····if·(trace_event_get_state(TRACE_GIC_UPDATE_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2539

····if·(trace_event_get_state(TRACE_GIC_UPDATE_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2540

········if·(message_with_timestamp)·{

2540

········if·(message_with_timestamp)·{

2541

············struct·timeval·_now;

2541

············struct·timeval·_now;

2542

············gettimeofday(&_now,·NULL);

2542

············gettimeofday(&_now,·NULL);

2544

············qemu_log("%d@%zu.%06zu:gic_update_set_irq·"·"cpu[%d]:·%s·=·%d"·"\n",

2544

············qemu_log("%d@%zu.%06zu:gic_update_set_irq·"·"cpu[%d]:·%s·=·%d"·"\n",

2545

·····················qemu_get_thread_id(),

2545

·····················qemu_get_thread_id(),

2546

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2546

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2547

·····················,·cpu,·name,·level);

2547

·····················,·cpu,·name,·level);

2548

#line·2550·"trace/trace-hw_intc.h"

2548

#line·2550·"trace/trace-hw_intc.h"

2549

········}·else·{

2549

········}·else·{

2551

············qemu_log("gic_update_set_irq·"·"cpu[%d]:·%s·=·%d"·"\n",·cpu,·name,·level);

2551

············qemu_log("gic_update_set_irq·"·"cpu[%d]:·%s·=·%d"·"\n",·cpu,·name,·level);

2552

#line·2554·"trace/trace-hw_intc.h"

2552

#line·2554·"trace/trace-hw_intc.h"

2553

········}

2553

········}

2554

····}

2554

····}

2555

}

2555

}

2556

static·inline·void·trace_gic_update_set_irq(int·cpu,·const·char·*·name,·int·level)

2556

static·inline·void·trace_gic_update_set_irq(int·cpu,·const·char·*·name,·int·level)

2568

static·inline·void·_nocheck__trace_gic_acknowledge_irq(const·char·*·s,·int·cpu,·int·irq)

2568

static·inline·void·_nocheck__trace_gic_acknowledge_irq(const·char·*·s,·int·cpu,·int·irq)

2569

{

2569

{

2570

····if·(trace_event_get_state(TRACE_GIC_ACKNOWLEDGE_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2570

····if·(trace_event_get_state(TRACE_GIC_ACKNOWLEDGE_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2571

········if·(message_with_timestamp)·{

2571

········if·(message_with_timestamp)·{

2572

············struct·timeval·_now;

2572

············struct·timeval·_now;

2573

············gettimeofday(&_now,·NULL);

2573

············gettimeofday(&_now,·NULL);

2575

············qemu_log("%d@%zu.%06zu:gic_acknowledge_irq·"·"%s·%d·acknowledged·irq·%d"·"\n",

2575

············qemu_log("%d@%zu.%06zu:gic_acknowledge_irq·"·"%s·%d·acknowledged·irq·%d"·"\n",

2576

·····················qemu_get_thread_id(),

2576

·····················qemu_get_thread_id(),

2577

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2577

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2578

·····················,·s,·cpu,·irq);

2578

·····················,·s,·cpu,·irq);

2579

#line·2581·"trace/trace-hw_intc.h"

2579

#line·2581·"trace/trace-hw_intc.h"

2580

········}·else·{

2580

········}·else·{

2582

············qemu_log("gic_acknowledge_irq·"·"%s·%d·acknowledged·irq·%d"·"\n",·s,·cpu,·irq);

2582

············qemu_log("gic_acknowledge_irq·"·"%s·%d·acknowledged·irq·%d"·"\n",·s,·cpu,·irq);

2583

#line·2585·"trace/trace-hw_intc.h"

2583

#line·2585·"trace/trace-hw_intc.h"

2584

········}

2584

········}

2585

····}

2585

····}

2586

}

2586

}

2587

static·inline·void·trace_gic_acknowledge_irq(const·char·*·s,·int·cpu,·int·irq)

2587

static·inline·void·trace_gic_acknowledge_irq(const·char·*·s,·int·cpu,·int·irq)

2599

static·inline·void·_nocheck__trace_gic_cpu_write(const·char·*·s,·int·cpu,·int·addr,·uint32_t·val)

2599

static·inline·void·_nocheck__trace_gic_cpu_write(const·char·*·s,·int·cpu,·int·addr,·uint32_t·val)

2600

{

2600

{

2601

····if·(trace_event_get_state(TRACE_GIC_CPU_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2601

····if·(trace_event_get_state(TRACE_GIC_CPU_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2602

········if·(message_with_timestamp)·{

2602

········if·(message_with_timestamp)·{

2603

············struct·timeval·_now;

2603

············struct·timeval·_now;

2604

············gettimeofday(&_now,·NULL);

2604

············gettimeofday(&_now,·NULL);

2606

············qemu_log("%d@%zu.%06zu:gic_cpu_write·"·"%s·%d·iface·write·at·0x%08x·0x%08"·PRIx32·"\n",

2606

············qemu_log("%d@%zu.%06zu:gic_cpu_write·"·"%s·%d·iface·write·at·0x%08x·0x%08"·PRIx32·"\n",

2607

·····················qemu_get_thread_id(),

2607

·····················qemu_get_thread_id(),

2608

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2608

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2609

·····················,·s,·cpu,·addr,·val);

2609

·····················,·s,·cpu,·addr,·val);

2610

#line·2612·"trace/trace-hw_intc.h"

2610

#line·2612·"trace/trace-hw_intc.h"

2611

········}·else·{

2611

········}·else·{

2613

············qemu_log("gic_cpu_write·"·"%s·%d·iface·write·at·0x%08x·0x%08"·PRIx32·"\n",·s,·cpu,·addr,·val);

2613

············qemu_log("gic_cpu_write·"·"%s·%d·iface·write·at·0x%08x·0x%08"·PRIx32·"\n",·s,·cpu,·addr,·val);

2614

#line·2616·"trace/trace-hw_intc.h"

2614

#line·2616·"trace/trace-hw_intc.h"

2615

········}

2615

········}

2616

····}

2616

····}

2617

}

2617

}

2618

static·inline·void·trace_gic_cpu_write(const·char·*·s,·int·cpu,·int·addr,·uint32_t·val)

2618

static·inline·void·trace_gic_cpu_write(const·char·*·s,·int·cpu,·int·addr,·uint32_t·val)

2630

static·inline·void·_nocheck__trace_gic_cpu_read(const·char·*·s,·int·cpu,·int·addr,·uint32_t·val)

2630

static·inline·void·_nocheck__trace_gic_cpu_read(const·char·*·s,·int·cpu,·int·addr,·uint32_t·val)

2631

{

2631

{

2632

····if·(trace_event_get_state(TRACE_GIC_CPU_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2632

····if·(trace_event_get_state(TRACE_GIC_CPU_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2633

········if·(message_with_timestamp)·{

2633

········if·(message_with_timestamp)·{

2634

············struct·timeval·_now;

2634

············struct·timeval·_now;

2635

············gettimeofday(&_now,·NULL);

2635

············gettimeofday(&_now,·NULL);

2637

············qemu_log("%d@%zu.%06zu:gic_cpu_read·"·"%s·%d·iface·read·at·0x%08x:·0x%08"·PRIx32·"\n",

2637

············qemu_log("%d@%zu.%06zu:gic_cpu_read·"·"%s·%d·iface·read·at·0x%08x:·0x%08"·PRIx32·"\n",

2638

·····················qemu_get_thread_id(),

2638

·····················qemu_get_thread_id(),

2639

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2639

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2640

·····················,·s,·cpu,·addr,·val);

2640

·····················,·s,·cpu,·addr,·val);

2641

#line·2643·"trace/trace-hw_intc.h"

2641

#line·2643·"trace/trace-hw_intc.h"

2642

········}·else·{

2642

········}·else·{

2644

············qemu_log("gic_cpu_read·"·"%s·%d·iface·read·at·0x%08x:·0x%08"·PRIx32·"\n",·s,·cpu,·addr,·val);

2644

············qemu_log("gic_cpu_read·"·"%s·%d·iface·read·at·0x%08x:·0x%08"·PRIx32·"\n",·s,·cpu,·addr,·val);

2645

#line·2647·"trace/trace-hw_intc.h"

2645

#line·2647·"trace/trace-hw_intc.h"

2646

········}

2646

········}

2647

····}

2647

····}

2648

}

2648

}

2649

static·inline·void·trace_gic_cpu_read(const·char·*·s,·int·cpu,·int·addr,·uint32_t·val)

2649

static·inline·void·trace_gic_cpu_read(const·char·*·s,·int·cpu,·int·addr,·uint32_t·val)

2661

static·inline·void·_nocheck__trace_gic_hyp_read(int·addr,·uint32_t·val)

2661

static·inline·void·_nocheck__trace_gic_hyp_read(int·addr,·uint32_t·val)

2662

{

2662

{

2663

····if·(trace_event_get_state(TRACE_GIC_HYP_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2663

····if·(trace_event_get_state(TRACE_GIC_HYP_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2664

········if·(message_with_timestamp)·{

2664

········if·(message_with_timestamp)·{

2665

············struct·timeval·_now;

2665

············struct·timeval·_now;

2666

············gettimeofday(&_now,·NULL);

2666

············gettimeofday(&_now,·NULL);

2668

············qemu_log("%d@%zu.%06zu:gic_hyp_read·"·"hyp·read·at·0x%08x:·0x%08"·PRIx32·"\n",

2668

············qemu_log("%d@%zu.%06zu:gic_hyp_read·"·"hyp·read·at·0x%08x:·0x%08"·PRIx32·"\n",

2669

·····················qemu_get_thread_id(),

2669

·····················qemu_get_thread_id(),

2670

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2670

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2671

·····················,·addr,·val);

2671

·····················,·addr,·val);

2672

#line·2674·"trace/trace-hw_intc.h"

2672

#line·2674·"trace/trace-hw_intc.h"

2673

········}·else·{

2673

········}·else·{

2675

············qemu_log("gic_hyp_read·"·"hyp·read·at·0x%08x:·0x%08"·PRIx32·"\n",·addr,·val);

2675

············qemu_log("gic_hyp_read·"·"hyp·read·at·0x%08x:·0x%08"·PRIx32·"\n",·addr,·val);

2676

#line·2678·"trace/trace-hw_intc.h"

2676

#line·2678·"trace/trace-hw_intc.h"

2677

········}

2677

········}

2678

····}

2678

····}

2679

}

2679

}

2680

static·inline·void·trace_gic_hyp_read(int·addr,·uint32_t·val)

2680

static·inline·void·trace_gic_hyp_read(int·addr,·uint32_t·val)

2692

static·inline·void·_nocheck__trace_gic_hyp_write(int·addr,·uint32_t·val)

2692

static·inline·void·_nocheck__trace_gic_hyp_write(int·addr,·uint32_t·val)

2693

{

2693

{

2694

····if·(trace_event_get_state(TRACE_GIC_HYP_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2694

····if·(trace_event_get_state(TRACE_GIC_HYP_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2695

········if·(message_with_timestamp)·{

2695

········if·(message_with_timestamp)·{

2696

············struct·timeval·_now;

2696

············struct·timeval·_now;

2697

············gettimeofday(&_now,·NULL);

2697

············gettimeofday(&_now,·NULL);

2699

············qemu_log("%d@%zu.%06zu:gic_hyp_write·"·"hyp·write·at·0x%08x:·0x%08"·PRIx32·"\n",

2699

············qemu_log("%d@%zu.%06zu:gic_hyp_write·"·"hyp·write·at·0x%08x:·0x%08"·PRIx32·"\n",

2700

·····················qemu_get_thread_id(),

2700

·····················qemu_get_thread_id(),

2701

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2701

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2702

·····················,·addr,·val);

2702

·····················,·addr,·val);

2703

#line·2705·"trace/trace-hw_intc.h"

2703

#line·2705·"trace/trace-hw_intc.h"

2704

········}·else·{

2704

········}·else·{

2706

············qemu_log("gic_hyp_write·"·"hyp·write·at·0x%08x:·0x%08"·PRIx32·"\n",·addr,·val);

2706

············qemu_log("gic_hyp_write·"·"hyp·write·at·0x%08x:·0x%08"·PRIx32·"\n",·addr,·val);

2707

#line·2709·"trace/trace-hw_intc.h"

2707

#line·2709·"trace/trace-hw_intc.h"

2708

········}

2708

········}

2709

····}

2709

····}

2710

}

2710

}

2711

static·inline·void·trace_gic_hyp_write(int·addr,·uint32_t·val)

2711

static·inline·void·trace_gic_hyp_write(int·addr,·uint32_t·val)

2723

static·inline·void·_nocheck__trace_gic_dist_read(int·addr,·unsigned·int·size,·uint32_t·val)

2723

static·inline·void·_nocheck__trace_gic_dist_read(int·addr,·unsigned·int·size,·uint32_t·val)

2724

{

2724

{

2725

····if·(trace_event_get_state(TRACE_GIC_DIST_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2725

····if·(trace_event_get_state(TRACE_GIC_DIST_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2726

········if·(message_with_timestamp)·{

2726

········if·(message_with_timestamp)·{

2727

············struct·timeval·_now;

2727

············struct·timeval·_now;

2728

············gettimeofday(&_now,·NULL);

2728

············gettimeofday(&_now,·NULL);

2730

············qemu_log("%d@%zu.%06zu:gic_dist_read·"·"dist·read·at·0x%08x·size·%u:·0x%08"·PRIx32·"\n",

2730

············qemu_log("%d@%zu.%06zu:gic_dist_read·"·"dist·read·at·0x%08x·size·%u:·0x%08"·PRIx32·"\n",

2731

·····················qemu_get_thread_id(),

2731

·····················qemu_get_thread_id(),

2732

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2732

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2733

·····················,·addr,·size,·val);

2733

·····················,·addr,·size,·val);

2734

#line·2736·"trace/trace-hw_intc.h"

2734

#line·2736·"trace/trace-hw_intc.h"

2735

········}·else·{

2735

········}·else·{

2737

············qemu_log("gic_dist_read·"·"dist·read·at·0x%08x·size·%u:·0x%08"·PRIx32·"\n",·addr,·size,·val);

2737

············qemu_log("gic_dist_read·"·"dist·read·at·0x%08x·size·%u:·0x%08"·PRIx32·"\n",·addr,·size,·val);

2738

#line·2740·"trace/trace-hw_intc.h"

2738

#line·2740·"trace/trace-hw_intc.h"

2739

········}

2739

········}

2740

····}

2740

····}

2741

}

2741

}

2742

static·inline·void·trace_gic_dist_read(int·addr,·unsigned·int·size,·uint32_t·val)

2742

static·inline·void·trace_gic_dist_read(int·addr,·unsigned·int·size,·uint32_t·val)

2754

static·inline·void·_nocheck__trace_gic_dist_write(int·addr,·unsigned·int·size,·uint32_t·val)

2754

static·inline·void·_nocheck__trace_gic_dist_write(int·addr,·unsigned·int·size,·uint32_t·val)

2755

{

2755

{

2756

····if·(trace_event_get_state(TRACE_GIC_DIST_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2756

····if·(trace_event_get_state(TRACE_GIC_DIST_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2757

········if·(message_with_timestamp)·{

2757

········if·(message_with_timestamp)·{

2758

············struct·timeval·_now;

2758

············struct·timeval·_now;

2759

············gettimeofday(&_now,·NULL);

2759

············gettimeofday(&_now,·NULL);

2761

············qemu_log("%d@%zu.%06zu:gic_dist_write·"·"dist·write·at·0x%08x·size·%u:·0x%08"·PRIx32·"\n",

2761

············qemu_log("%d@%zu.%06zu:gic_dist_write·"·"dist·write·at·0x%08x·size·%u:·0x%08"·PRIx32·"\n",

2762

·····················qemu_get_thread_id(),

2762

·····················qemu_get_thread_id(),

2763

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2763

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2764

·····················,·addr,·size,·val);

2764

·····················,·addr,·size,·val);

2765

#line·2767·"trace/trace-hw_intc.h"

2765

#line·2767·"trace/trace-hw_intc.h"

2766

········}·else·{

2766

········}·else·{

2768

············qemu_log("gic_dist_write·"·"dist·write·at·0x%08x·size·%u:·0x%08"·PRIx32·"\n",·addr,·size,·val);

2768

············qemu_log("gic_dist_write·"·"dist·write·at·0x%08x·size·%u:·0x%08"·PRIx32·"\n",·addr,·size,·val);

2769

#line·2771·"trace/trace-hw_intc.h"

2769

#line·2771·"trace/trace-hw_intc.h"

2770

········}

2770

········}

2771

····}

2771

····}

2772

}

2772

}

2773

static·inline·void·trace_gic_dist_write(int·addr,·unsigned·int·size,·uint32_t·val)

2773

static·inline·void·trace_gic_dist_write(int·addr,·unsigned·int·size,·uint32_t·val)

2785

static·inline·void·_nocheck__trace_gic_lr_entry(int·cpu,·int·entry,·uint32_t·val)

2785

static·inline·void·_nocheck__trace_gic_lr_entry(int·cpu,·int·entry,·uint32_t·val)

2786

{

2786

{

2787

····if·(trace_event_get_state(TRACE_GIC_LR_ENTRY)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2787

····if·(trace_event_get_state(TRACE_GIC_LR_ENTRY)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2788

········if·(message_with_timestamp)·{

2788

········if·(message_with_timestamp)·{

2789

············struct·timeval·_now;

2789

············struct·timeval·_now;

2790

············gettimeofday(&_now,·NULL);

2790

············gettimeofday(&_now,·NULL);

2792

············qemu_log("%d@%zu.%06zu:gic_lr_entry·"·"cpu·%d:·new·lr·entry·%d:·0x%08"·PRIx32·"\n",

2792

············qemu_log("%d@%zu.%06zu:gic_lr_entry·"·"cpu·%d:·new·lr·entry·%d:·0x%08"·PRIx32·"\n",

2793

·····················qemu_get_thread_id(),

2793

·····················qemu_get_thread_id(),

2794

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2794

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2795

·····················,·cpu,·entry,·val);

2795

·····················,·cpu,·entry,·val);

2796

#line·2798·"trace/trace-hw_intc.h"

2796

#line·2798·"trace/trace-hw_intc.h"

2797

········}·else·{

2797

········}·else·{

2799

············qemu_log("gic_lr_entry·"·"cpu·%d:·new·lr·entry·%d:·0x%08"·PRIx32·"\n",·cpu,·entry,·val);

2799

············qemu_log("gic_lr_entry·"·"cpu·%d:·new·lr·entry·%d:·0x%08"·PRIx32·"\n",·cpu,·entry,·val);

2800

#line·2802·"trace/trace-hw_intc.h"

2800

#line·2802·"trace/trace-hw_intc.h"

2801

········}

2801

········}

2802

····}

2802

····}

2803

}

2803

}

2804

static·inline·void·trace_gic_lr_entry(int·cpu,·int·entry,·uint32_t·val)

2804

static·inline·void·trace_gic_lr_entry(int·cpu,·int·entry,·uint32_t·val)

2816

static·inline·void·_nocheck__trace_gic_update_maintenance_irq(int·cpu,·int·val)

2816

static·inline·void·_nocheck__trace_gic_update_maintenance_irq(int·cpu,·int·val)

2817

{

2817

{

2818

····if·(trace_event_get_state(TRACE_GIC_UPDATE_MAINTENANCE_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2818

····if·(trace_event_get_state(TRACE_GIC_UPDATE_MAINTENANCE_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2819

········if·(message_with_timestamp)·{

2819

········if·(message_with_timestamp)·{

2820

············struct·timeval·_now;

2820

············struct·timeval·_now;

2821

············gettimeofday(&_now,·NULL);

2821

············gettimeofday(&_now,·NULL);

2823

············qemu_log("%d@%zu.%06zu:gic_update_maintenance_irq·"·"cpu·%d:·maintenance·=·%d"·"\n",

2823

············qemu_log("%d@%zu.%06zu:gic_update_maintenance_irq·"·"cpu·%d:·maintenance·=·%d"·"\n",

2824

·····················qemu_get_thread_id(),

2824

·····················qemu_get_thread_id(),

2825

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2825

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2826

·····················,·cpu,·val);

2826

·····················,·cpu,·val);

2827

#line·2829·"trace/trace-hw_intc.h"

2827

#line·2829·"trace/trace-hw_intc.h"

2828

········}·else·{

2828

········}·else·{

2830

············qemu_log("gic_update_maintenance_irq·"·"cpu·%d:·maintenance·=·%d"·"\n",·cpu,·val);

2830

············qemu_log("gic_update_maintenance_irq·"·"cpu·%d:·maintenance·=·%d"·"\n",·cpu,·val);

2831

#line·2833·"trace/trace-hw_intc.h"

2831

#line·2833·"trace/trace-hw_intc.h"

2832

········}

2832

········}

2833

····}

2833

····}

2834

}

2834

}

2835

static·inline·void·trace_gic_update_maintenance_irq(int·cpu,·int·val)

2835

static·inline·void·trace_gic_update_maintenance_irq(int·cpu,·int·val)

2847

static·inline·void·_nocheck__trace_gicv3_icc_pmr_read(uint32_t·cpu,·uint64_t·val)

2847

static·inline·void·_nocheck__trace_gicv3_icc_pmr_read(uint32_t·cpu,·uint64_t·val)

2848

{

2848

{

2849

····if·(trace_event_get_state(TRACE_GICV3_ICC_PMR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2849

····if·(trace_event_get_state(TRACE_GICV3_ICC_PMR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2850

········if·(message_with_timestamp)·{

2850

········if·(message_with_timestamp)·{

2851

············struct·timeval·_now;

2851

············struct·timeval·_now;

2852

············gettimeofday(&_now,·NULL);

2852

············gettimeofday(&_now,·NULL);

2854

············qemu_log("%d@%zu.%06zu:gicv3_icc_pmr_read·"·"GICv3·ICC_PMR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

2854

············qemu_log("%d@%zu.%06zu:gicv3_icc_pmr_read·"·"GICv3·ICC_PMR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

2855

·····················qemu_get_thread_id(),

2855

·····················qemu_get_thread_id(),

2856

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2856

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2857

·····················,·cpu,·val);

2857

·····················,·cpu,·val);

2858

#line·2860·"trace/trace-hw_intc.h"

2858

#line·2860·"trace/trace-hw_intc.h"

2859

········}·else·{

2859

········}·else·{

2861

············qemu_log("gicv3_icc_pmr_read·"·"GICv3·ICC_PMR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

2861

············qemu_log("gicv3_icc_pmr_read·"·"GICv3·ICC_PMR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

2862

#line·2864·"trace/trace-hw_intc.h"

2862

#line·2864·"trace/trace-hw_intc.h"

2863

········}

2863

········}

2864

····}

2864

····}

2865

}

2865

}

2866

static·inline·void·trace_gicv3_icc_pmr_read(uint32_t·cpu,·uint64_t·val)

2866

static·inline·void·trace_gicv3_icc_pmr_read(uint32_t·cpu,·uint64_t·val)

2878

static·inline·void·_nocheck__trace_gicv3_icc_pmr_write(uint32_t·cpu,·uint64_t·val)

2878

static·inline·void·_nocheck__trace_gicv3_icc_pmr_write(uint32_t·cpu,·uint64_t·val)

2879

{

2879

{

2880

····if·(trace_event_get_state(TRACE_GICV3_ICC_PMR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2880

····if·(trace_event_get_state(TRACE_GICV3_ICC_PMR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2881

········if·(message_with_timestamp)·{

2881

········if·(message_with_timestamp)·{

2882

············struct·timeval·_now;

2882

············struct·timeval·_now;

2883

············gettimeofday(&_now,·NULL);

2883

············gettimeofday(&_now,·NULL);

2885

············qemu_log("%d@%zu.%06zu:gicv3_icc_pmr_write·"·"GICv3·ICC_PMR·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

2885

············qemu_log("%d@%zu.%06zu:gicv3_icc_pmr_write·"·"GICv3·ICC_PMR·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

2886

·····················qemu_get_thread_id(),

2886

·····················qemu_get_thread_id(),

2887

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2887

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2888

·····················,·cpu,·val);

2888

·····················,·cpu,·val);

2889

#line·2891·"trace/trace-hw_intc.h"

2889

#line·2891·"trace/trace-hw_intc.h"

2890

········}·else·{

2890

········}·else·{

2892

············qemu_log("gicv3_icc_pmr_write·"·"GICv3·ICC_PMR·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

2892

············qemu_log("gicv3_icc_pmr_write·"·"GICv3·ICC_PMR·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

2893

#line·2895·"trace/trace-hw_intc.h"

2893

#line·2895·"trace/trace-hw_intc.h"

2894

········}

2894

········}

2895

····}

2895

····}

2896

}

2896

}

2897

static·inline·void·trace_gicv3_icc_pmr_write(uint32_t·cpu,·uint64_t·val)

2897

static·inline·void·trace_gicv3_icc_pmr_write(uint32_t·cpu,·uint64_t·val)

2909

static·inline·void·_nocheck__trace_gicv3_icc_bpr_read(int·grp,·uint32_t·cpu,·uint64_t·val)

2909

static·inline·void·_nocheck__trace_gicv3_icc_bpr_read(int·grp,·uint32_t·cpu,·uint64_t·val)

2910

{

2910

{

2911

····if·(trace_event_get_state(TRACE_GICV3_ICC_BPR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2911

····if·(trace_event_get_state(TRACE_GICV3_ICC_BPR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2912

········if·(message_with_timestamp)·{

2912

········if·(message_with_timestamp)·{

2913

············struct·timeval·_now;

2913

············struct·timeval·_now;

2914

············gettimeofday(&_now,·NULL);

2914

············gettimeofday(&_now,·NULL);

2916

············qemu_log("%d@%zu.%06zu:gicv3_icc_bpr_read·"·"GICv3·ICC_BPR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

2916

············qemu_log("%d@%zu.%06zu:gicv3_icc_bpr_read·"·"GICv3·ICC_BPR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

2917

·····················qemu_get_thread_id(),

2917

·····················qemu_get_thread_id(),

2918

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2918

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2919

·····················,·grp,·cpu,·val);

2919

·····················,·grp,·cpu,·val);

2920

#line·2922·"trace/trace-hw_intc.h"

2920

#line·2922·"trace/trace-hw_intc.h"

2921

········}·else·{

2921

········}·else·{

2923

············qemu_log("gicv3_icc_bpr_read·"·"GICv3·ICC_BPR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·cpu,·val);

2923

············qemu_log("gicv3_icc_bpr_read·"·"GICv3·ICC_BPR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·cpu,·val);

2924

#line·2926·"trace/trace-hw_intc.h"

2924

#line·2926·"trace/trace-hw_intc.h"

2925

········}

2925

········}

2926

····}

2926

····}

2927

}

2927

}

2928

static·inline·void·trace_gicv3_icc_bpr_read(int·grp,·uint32_t·cpu,·uint64_t·val)

2928

static·inline·void·trace_gicv3_icc_bpr_read(int·grp,·uint32_t·cpu,·uint64_t·val)

2940

static·inline·void·_nocheck__trace_gicv3_icc_bpr_write(int·grp,·uint32_t·cpu,·uint64_t·val)

2940

static·inline·void·_nocheck__trace_gicv3_icc_bpr_write(int·grp,·uint32_t·cpu,·uint64_t·val)

2941

{

2941

{

2942

····if·(trace_event_get_state(TRACE_GICV3_ICC_BPR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2942

····if·(trace_event_get_state(TRACE_GICV3_ICC_BPR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2943

········if·(message_with_timestamp)·{

2943

········if·(message_with_timestamp)·{

2944

············struct·timeval·_now;

2944

············struct·timeval·_now;

2945

············gettimeofday(&_now,·NULL);

2945

············gettimeofday(&_now,·NULL);

2947

············qemu_log("%d@%zu.%06zu:gicv3_icc_bpr_write·"·"GICv3·ICC_BPR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

2947

············qemu_log("%d@%zu.%06zu:gicv3_icc_bpr_write·"·"GICv3·ICC_BPR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

2948

·····················qemu_get_thread_id(),

2948

·····················qemu_get_thread_id(),

2949

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2949

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2950

·····················,·grp,·cpu,·val);

2950

·····················,·grp,·cpu,·val);

2951

#line·2953·"trace/trace-hw_intc.h"

2951

#line·2953·"trace/trace-hw_intc.h"

2952

········}·else·{

2952

········}·else·{

2954

············qemu_log("gicv3_icc_bpr_write·"·"GICv3·ICC_BPR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·cpu,·val);

2954

············qemu_log("gicv3_icc_bpr_write·"·"GICv3·ICC_BPR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·cpu,·val);

2955

#line·2957·"trace/trace-hw_intc.h"

2955

#line·2957·"trace/trace-hw_intc.h"

2956

········}

2956

········}

2957

····}

2957

····}

2958

}

2958

}

2959

static·inline·void·trace_gicv3_icc_bpr_write(int·grp,·uint32_t·cpu,·uint64_t·val)

2959

static·inline·void·trace_gicv3_icc_bpr_write(int·grp,·uint32_t·cpu,·uint64_t·val)

2971

static·inline·void·_nocheck__trace_gicv3_icc_ap_read(int·grp,·int·regno,·uint32_t·cpu,·uint64_t·val)

2971

static·inline·void·_nocheck__trace_gicv3_icc_ap_read(int·grp,·int·regno,·uint32_t·cpu,·uint64_t·val)

2972

{

2972

{

2973

····if·(trace_event_get_state(TRACE_GICV3_ICC_AP_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2973

····if·(trace_event_get_state(TRACE_GICV3_ICC_AP_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2974

········if·(message_with_timestamp)·{

2974

········if·(message_with_timestamp)·{

2975

············struct·timeval·_now;

2975

············struct·timeval·_now;

2976

············gettimeofday(&_now,·NULL);

2976

············gettimeofday(&_now,·NULL);

2978

············qemu_log("%d@%zu.%06zu:gicv3_icc_ap_read·"·"GICv3·ICC_AP%dR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

2978

············qemu_log("%d@%zu.%06zu:gicv3_icc_ap_read·"·"GICv3·ICC_AP%dR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

2979

·····················qemu_get_thread_id(),

2979

·····················qemu_get_thread_id(),

2980

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2980

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2981

·····················,·grp,·regno,·cpu,·val);

2981

·····················,·grp,·regno,·cpu,·val);

2982

#line·2984·"trace/trace-hw_intc.h"

2982

#line·2984·"trace/trace-hw_intc.h"

2983

········}·else·{

2983

········}·else·{

2985

············qemu_log("gicv3_icc_ap_read·"·"GICv3·ICC_AP%dR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·regno,·cpu,·val);

2985

············qemu_log("gicv3_icc_ap_read·"·"GICv3·ICC_AP%dR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·regno,·cpu,·val);

2986

#line·2988·"trace/trace-hw_intc.h"

2986

#line·2988·"trace/trace-hw_intc.h"

2987

········}

2987

········}

2988

····}

2988

····}

2989

}

2989

}

2990

static·inline·void·trace_gicv3_icc_ap_read(int·grp,·int·regno,·uint32_t·cpu,·uint64_t·val)

2990

static·inline·void·trace_gicv3_icc_ap_read(int·grp,·int·regno,·uint32_t·cpu,·uint64_t·val)

3002

static·inline·void·_nocheck__trace_gicv3_icc_ap_write(int·grp,·int·regno,·uint32_t·cpu,·uint64_t·val)

3002

static·inline·void·_nocheck__trace_gicv3_icc_ap_write(int·grp,·int·regno,·uint32_t·cpu,·uint64_t·val)

3003

{

3003

{

3004

····if·(trace_event_get_state(TRACE_GICV3_ICC_AP_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3004

····if·(trace_event_get_state(TRACE_GICV3_ICC_AP_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3005

········if·(message_with_timestamp)·{

3005

········if·(message_with_timestamp)·{

3006

············struct·timeval·_now;

3006

············struct·timeval·_now;

3007

············gettimeofday(&_now,·NULL);

3007

············gettimeofday(&_now,·NULL);

3009

············qemu_log("%d@%zu.%06zu:gicv3_icc_ap_write·"·"GICv3·ICC_AP%dR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

3009

············qemu_log("%d@%zu.%06zu:gicv3_icc_ap_write·"·"GICv3·ICC_AP%dR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

3010

·····················qemu_get_thread_id(),

3010

·····················qemu_get_thread_id(),

3011

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3011

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3012

·····················,·grp,·regno,·cpu,·val);

3012

·····················,·grp,·regno,·cpu,·val);

3013

#line·3015·"trace/trace-hw_intc.h"

3013

#line·3015·"trace/trace-hw_intc.h"

3014

········}·else·{

3014

········}·else·{

3016

············qemu_log("gicv3_icc_ap_write·"·"GICv3·ICC_AP%dR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·regno,·cpu,·val);

3016

············qemu_log("gicv3_icc_ap_write·"·"GICv3·ICC_AP%dR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·regno,·cpu,·val);

3017

#line·3019·"trace/trace-hw_intc.h"

3017

#line·3019·"trace/trace-hw_intc.h"

3018

········}

3018

········}

3019

····}

3019

····}

3020

}

3020

}

3021

static·inline·void·trace_gicv3_icc_ap_write(int·grp,·int·regno,·uint32_t·cpu,·uint64_t·val)

3021

static·inline·void·trace_gicv3_icc_ap_write(int·grp,·int·regno,·uint32_t·cpu,·uint64_t·val)

3033

static·inline·void·_nocheck__trace_gicv3_icc_igrpen_read(int·grp,·uint32_t·cpu,·uint64_t·val)

3033

static·inline·void·_nocheck__trace_gicv3_icc_igrpen_read(int·grp,·uint32_t·cpu,·uint64_t·val)

3034

{

3034

{

3035

····if·(trace_event_get_state(TRACE_GICV3_ICC_IGRPEN_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3035

····if·(trace_event_get_state(TRACE_GICV3_ICC_IGRPEN_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3036

········if·(message_with_timestamp)·{

3036

········if·(message_with_timestamp)·{

3037

············struct·timeval·_now;

3037

············struct·timeval·_now;

3038

············gettimeofday(&_now,·NULL);

3038

············gettimeofday(&_now,·NULL);

3040

············qemu_log("%d@%zu.%06zu:gicv3_icc_igrpen_read·"·"GICv3·ICC_IGRPEN%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3040

············qemu_log("%d@%zu.%06zu:gicv3_icc_igrpen_read·"·"GICv3·ICC_IGRPEN%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3041

·····················qemu_get_thread_id(),

3041

·····················qemu_get_thread_id(),

3042

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3042

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3043

·····················,·grp,·cpu,·val);

3043

·····················,·grp,·cpu,·val);

3044

#line·3046·"trace/trace-hw_intc.h"

3044

#line·3046·"trace/trace-hw_intc.h"

3045

········}·else·{

3045

········}·else·{

3047

············qemu_log("gicv3_icc_igrpen_read·"·"GICv3·ICC_IGRPEN%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·cpu,·val);

3047

············qemu_log("gicv3_icc_igrpen_read·"·"GICv3·ICC_IGRPEN%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·cpu,·val);

3048

#line·3050·"trace/trace-hw_intc.h"

3048

#line·3050·"trace/trace-hw_intc.h"

3049

········}

3049

········}

3050

····}

3050

····}

3051

}

3051

}

3052

static·inline·void·trace_gicv3_icc_igrpen_read(int·grp,·uint32_t·cpu,·uint64_t·val)

3052

static·inline·void·trace_gicv3_icc_igrpen_read(int·grp,·uint32_t·cpu,·uint64_t·val)

3064

static·inline·void·_nocheck__trace_gicv3_icc_igrpen_write(int·grp,·uint32_t·cpu,·uint64_t·val)

3064

static·inline·void·_nocheck__trace_gicv3_icc_igrpen_write(int·grp,·uint32_t·cpu,·uint64_t·val)

3065

{

3065

{

3066

····if·(trace_event_get_state(TRACE_GICV3_ICC_IGRPEN_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3066

····if·(trace_event_get_state(TRACE_GICV3_ICC_IGRPEN_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3067

········if·(message_with_timestamp)·{

3067

········if·(message_with_timestamp)·{

3068

············struct·timeval·_now;

3068

············struct·timeval·_now;

3069

············gettimeofday(&_now,·NULL);

3069

············gettimeofday(&_now,·NULL);

3071

············qemu_log("%d@%zu.%06zu:gicv3_icc_igrpen_write·"·"GICv3·ICC_IGRPEN%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

3071

············qemu_log("%d@%zu.%06zu:gicv3_icc_igrpen_write·"·"GICv3·ICC_IGRPEN%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

3072

·····················qemu_get_thread_id(),

3072

·····················qemu_get_thread_id(),

3073

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3073

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3074

·····················,·grp,·cpu,·val);

3074

·····················,·grp,·cpu,·val);

3075

#line·3077·"trace/trace-hw_intc.h"

3075

#line·3077·"trace/trace-hw_intc.h"

3076

········}·else·{

3076

········}·else·{

3078

············qemu_log("gicv3_icc_igrpen_write·"·"GICv3·ICC_IGRPEN%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·cpu,·val);

3078

············qemu_log("gicv3_icc_igrpen_write·"·"GICv3·ICC_IGRPEN%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·cpu,·val);

3079

#line·3081·"trace/trace-hw_intc.h"

3079

#line·3081·"trace/trace-hw_intc.h"

3080

········}

3080

········}

3081

····}

3081

····}

3082

}

3082

}

3083

static·inline·void·trace_gicv3_icc_igrpen_write(int·grp,·uint32_t·cpu,·uint64_t·val)

3083

static·inline·void·trace_gicv3_icc_igrpen_write(int·grp,·uint32_t·cpu,·uint64_t·val)

3095

static·inline·void·_nocheck__trace_gicv3_icc_igrpen1_el3_read(uint32_t·cpu,·uint64_t·val)

3095

static·inline·void·_nocheck__trace_gicv3_icc_igrpen1_el3_read(uint32_t·cpu,·uint64_t·val)

3096

{

3096

{

3097

····if·(trace_event_get_state(TRACE_GICV3_ICC_IGRPEN1_EL3_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3097

····if·(trace_event_get_state(TRACE_GICV3_ICC_IGRPEN1_EL3_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3098

········if·(message_with_timestamp)·{

3098

········if·(message_with_timestamp)·{

3099

············struct·timeval·_now;

3099

············struct·timeval·_now;

3100

············gettimeofday(&_now,·NULL);

3100

············gettimeofday(&_now,·NULL);

3102

············qemu_log("%d@%zu.%06zu:gicv3_icc_igrpen1_el3_read·"·"GICv3·ICC_IGRPEN1_EL3·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3102

············qemu_log("%d@%zu.%06zu:gicv3_icc_igrpen1_el3_read·"·"GICv3·ICC_IGRPEN1_EL3·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3103

·····················qemu_get_thread_id(),

3103

·····················qemu_get_thread_id(),

3104

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3104

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3105

·····················,·cpu,·val);

3105

·····················,·cpu,·val);

3106

#line·3108·"trace/trace-hw_intc.h"

3106

#line·3108·"trace/trace-hw_intc.h"

3107

········}·else·{

3107

········}·else·{

3109

············qemu_log("gicv3_icc_igrpen1_el3_read·"·"GICv3·ICC_IGRPEN1_EL3·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3109

············qemu_log("gicv3_icc_igrpen1_el3_read·"·"GICv3·ICC_IGRPEN1_EL3·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3110

#line·3112·"trace/trace-hw_intc.h"

3110

#line·3112·"trace/trace-hw_intc.h"

3111

········}

3111

········}

3112

····}

3112

····}

3113

}

3113

}

3114

static·inline·void·trace_gicv3_icc_igrpen1_el3_read(uint32_t·cpu,·uint64_t·val)

3114

static·inline·void·trace_gicv3_icc_igrpen1_el3_read(uint32_t·cpu,·uint64_t·val)

3126

static·inline·void·_nocheck__trace_gicv3_icc_igrpen1_el3_write(uint32_t·cpu,·uint64_t·val)

3126

static·inline·void·_nocheck__trace_gicv3_icc_igrpen1_el3_write(uint32_t·cpu,·uint64_t·val)

3127

{

3127

{

3128

····if·(trace_event_get_state(TRACE_GICV3_ICC_IGRPEN1_EL3_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3128

····if·(trace_event_get_state(TRACE_GICV3_ICC_IGRPEN1_EL3_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3129

········if·(message_with_timestamp)·{

3129

········if·(message_with_timestamp)·{

3130

············struct·timeval·_now;

3130

············struct·timeval·_now;

3131

············gettimeofday(&_now,·NULL);

3131

············gettimeofday(&_now,·NULL);

3133

············qemu_log("%d@%zu.%06zu:gicv3_icc_igrpen1_el3_write·"·"GICv3·ICC_IGRPEN1_EL3·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

3133

············qemu_log("%d@%zu.%06zu:gicv3_icc_igrpen1_el3_write·"·"GICv3·ICC_IGRPEN1_EL3·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

3134

·····················qemu_get_thread_id(),

3134

·····················qemu_get_thread_id(),

3135

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3135

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3136

·····················,·cpu,·val);

3136

·····················,·cpu,·val);

3137

#line·3139·"trace/trace-hw_intc.h"

3137

#line·3139·"trace/trace-hw_intc.h"

3138

········}·else·{

3138

········}·else·{

3140

············qemu_log("gicv3_icc_igrpen1_el3_write·"·"GICv3·ICC_IGRPEN1_EL3·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3140

············qemu_log("gicv3_icc_igrpen1_el3_write·"·"GICv3·ICC_IGRPEN1_EL3·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3141

#line·3143·"trace/trace-hw_intc.h"

3141

#line·3143·"trace/trace-hw_intc.h"

3142

········}

3142

········}

3143

····}

3143

····}

3144

}

3144

}

3145

static·inline·void·trace_gicv3_icc_igrpen1_el3_write(uint32_t·cpu,·uint64_t·val)

3145

static·inline·void·trace_gicv3_icc_igrpen1_el3_write(uint32_t·cpu,·uint64_t·val)

3157

static·inline·void·_nocheck__trace_gicv3_icc_ctlr_read(uint32_t·cpu,·uint64_t·val)

3157

static·inline·void·_nocheck__trace_gicv3_icc_ctlr_read(uint32_t·cpu,·uint64_t·val)

3158

{

3158

{

3159

····if·(trace_event_get_state(TRACE_GICV3_ICC_CTLR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3159

····if·(trace_event_get_state(TRACE_GICV3_ICC_CTLR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3160

········if·(message_with_timestamp)·{

3160

········if·(message_with_timestamp)·{

3161

············struct·timeval·_now;

3161

············struct·timeval·_now;

3162

············gettimeofday(&_now,·NULL);

3162

············gettimeofday(&_now,·NULL);

3164

············qemu_log("%d@%zu.%06zu:gicv3_icc_ctlr_read·"·"GICv3·ICC_CTLR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3164

············qemu_log("%d@%zu.%06zu:gicv3_icc_ctlr_read·"·"GICv3·ICC_CTLR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3165

·····················qemu_get_thread_id(),

3165

·····················qemu_get_thread_id(),

3166

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3166

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3167

·····················,·cpu,·val);

3167

·····················,·cpu,·val);

3168

#line·3170·"trace/trace-hw_intc.h"

3168

#line·3170·"trace/trace-hw_intc.h"

3169

········}·else·{

3169

········}·else·{

3171

············qemu_log("gicv3_icc_ctlr_read·"·"GICv3·ICC_CTLR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3171

············qemu_log("gicv3_icc_ctlr_read·"·"GICv3·ICC_CTLR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3172

#line·3174·"trace/trace-hw_intc.h"

3172

#line·3174·"trace/trace-hw_intc.h"

3173

········}

3173

········}

3174

····}

3174

····}

3175

}

3175

}

3176

static·inline·void·trace_gicv3_icc_ctlr_read(uint32_t·cpu,·uint64_t·val)

3176

static·inline·void·trace_gicv3_icc_ctlr_read(uint32_t·cpu,·uint64_t·val)

3188

static·inline·void·_nocheck__trace_gicv3_icc_ctlr_write(uint32_t·cpu,·uint64_t·val)

3188

static·inline·void·_nocheck__trace_gicv3_icc_ctlr_write(uint32_t·cpu,·uint64_t·val)

3189

{

3189

{

3190

····if·(trace_event_get_state(TRACE_GICV3_ICC_CTLR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3190

····if·(trace_event_get_state(TRACE_GICV3_ICC_CTLR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3191

········if·(message_with_timestamp)·{

3191

········if·(message_with_timestamp)·{

3192

············struct·timeval·_now;

3192

············struct·timeval·_now;

3193

············gettimeofday(&_now,·NULL);

3193

············gettimeofday(&_now,·NULL);

3195

············qemu_log("%d@%zu.%06zu:gicv3_icc_ctlr_write·"·"GICv3·ICC_CTLR·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

3195

············qemu_log("%d@%zu.%06zu:gicv3_icc_ctlr_write·"·"GICv3·ICC_CTLR·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

3196

·····················qemu_get_thread_id(),

3196

·····················qemu_get_thread_id(),

3197

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3197

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3198

·····················,·cpu,·val);

3198

·····················,·cpu,·val);

3199

#line·3201·"trace/trace-hw_intc.h"

3199

#line·3201·"trace/trace-hw_intc.h"

3200

········}·else·{

3200

········}·else·{

3202

············qemu_log("gicv3_icc_ctlr_write·"·"GICv3·ICC_CTLR·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3202

············qemu_log("gicv3_icc_ctlr_write·"·"GICv3·ICC_CTLR·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3203

#line·3205·"trace/trace-hw_intc.h"

3203

#line·3205·"trace/trace-hw_intc.h"

3204

········}

3204

········}

3205

····}

3205

····}

3206

}

3206

}

3207

static·inline·void·trace_gicv3_icc_ctlr_write(uint32_t·cpu,·uint64_t·val)

3207

static·inline·void·trace_gicv3_icc_ctlr_write(uint32_t·cpu,·uint64_t·val)

3219

static·inline·void·_nocheck__trace_gicv3_icc_ctlr_el3_read(uint32_t·cpu,·uint64_t·val)

3219

static·inline·void·_nocheck__trace_gicv3_icc_ctlr_el3_read(uint32_t·cpu,·uint64_t·val)

3220

{

3220

{

3221

····if·(trace_event_get_state(TRACE_GICV3_ICC_CTLR_EL3_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3221

····if·(trace_event_get_state(TRACE_GICV3_ICC_CTLR_EL3_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3222

········if·(message_with_timestamp)·{

3222

········if·(message_with_timestamp)·{

3223

············struct·timeval·_now;

3223

············struct·timeval·_now;

3224

············gettimeofday(&_now,·NULL);

3224

············gettimeofday(&_now,·NULL);

3226

············qemu_log("%d@%zu.%06zu:gicv3_icc_ctlr_el3_read·"·"GICv3·ICC_CTLR_EL3·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3226

············qemu_log("%d@%zu.%06zu:gicv3_icc_ctlr_el3_read·"·"GICv3·ICC_CTLR_EL3·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3227

·····················qemu_get_thread_id(),

3227

·····················qemu_get_thread_id(),

3228

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3228

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3229

·····················,·cpu,·val);

3229

·····················,·cpu,·val);

3230

#line·3232·"trace/trace-hw_intc.h"

3230

#line·3232·"trace/trace-hw_intc.h"

3231

········}·else·{

3231

········}·else·{

3233

············qemu_log("gicv3_icc_ctlr_el3_read·"·"GICv3·ICC_CTLR_EL3·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3233

············qemu_log("gicv3_icc_ctlr_el3_read·"·"GICv3·ICC_CTLR_EL3·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3234

#line·3236·"trace/trace-hw_intc.h"

3234

#line·3236·"trace/trace-hw_intc.h"

3235

········}

3235

········}

3236

····}

3236

····}

3237

}

3237

}

3238

static·inline·void·trace_gicv3_icc_ctlr_el3_read(uint32_t·cpu,·uint64_t·val)

3238

static·inline·void·trace_gicv3_icc_ctlr_el3_read(uint32_t·cpu,·uint64_t·val)

3250

static·inline·void·_nocheck__trace_gicv3_icc_ctlr_el3_write(uint32_t·cpu,·uint64_t·val)

3250

static·inline·void·_nocheck__trace_gicv3_icc_ctlr_el3_write(uint32_t·cpu,·uint64_t·val)

3251

{

3251

{

3252

····if·(trace_event_get_state(TRACE_GICV3_ICC_CTLR_EL3_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3252

····if·(trace_event_get_state(TRACE_GICV3_ICC_CTLR_EL3_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3253

········if·(message_with_timestamp)·{

3253

········if·(message_with_timestamp)·{

3254

············struct·timeval·_now;

3254

············struct·timeval·_now;

3255

············gettimeofday(&_now,·NULL);

3255

············gettimeofday(&_now,·NULL);

3257

············qemu_log("%d@%zu.%06zu:gicv3_icc_ctlr_el3_write·"·"GICv3·ICC_CTLR_EL3·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

3257

············qemu_log("%d@%zu.%06zu:gicv3_icc_ctlr_el3_write·"·"GICv3·ICC_CTLR_EL3·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

3258

·····················qemu_get_thread_id(),

3258

·····················qemu_get_thread_id(),

3259

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3259

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3260

·····················,·cpu,·val);

3260

·····················,·cpu,·val);

3261

#line·3263·"trace/trace-hw_intc.h"

3261

#line·3263·"trace/trace-hw_intc.h"

3262

········}·else·{

3262

········}·else·{

3264

············qemu_log("gicv3_icc_ctlr_el3_write·"·"GICv3·ICC_CTLR_EL3·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3264

············qemu_log("gicv3_icc_ctlr_el3_write·"·"GICv3·ICC_CTLR_EL3·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3265

#line·3267·"trace/trace-hw_intc.h"

3265

#line·3267·"trace/trace-hw_intc.h"

3266

········}

3266

········}

3267

····}

3267

····}

3268

}

3268

}

3269

static·inline·void·trace_gicv3_icc_ctlr_el3_write(uint32_t·cpu,·uint64_t·val)

3269

static·inline·void·trace_gicv3_icc_ctlr_el3_write(uint32_t·cpu,·uint64_t·val)

3281

static·inline·void·_nocheck__trace_gicv3_cpuif_update(uint32_t·cpuid,·int·irq,·int·grp,·int·prio)

3281

static·inline·void·_nocheck__trace_gicv3_cpuif_update(uint32_t·cpuid,·int·irq,·int·grp,·int·prio)

3282

{

3282

{

3283

····if·(trace_event_get_state(TRACE_GICV3_CPUIF_UPDATE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3283

····if·(trace_event_get_state(TRACE_GICV3_CPUIF_UPDATE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3284

········if·(message_with_timestamp)·{

3284

········if·(message_with_timestamp)·{

3285

············struct·timeval·_now;

3285

············struct·timeval·_now;

3286

············gettimeofday(&_now,·NULL);

3286

············gettimeofday(&_now,·NULL);

3288

············qemu_log("%d@%zu.%06zu:gicv3_cpuif_update·"·"GICv3·CPU·i/f·0x%x·HPPI·update:·irq·%d·group·%d·prio·%d"·"\n",

3288

············qemu_log("%d@%zu.%06zu:gicv3_cpuif_update·"·"GICv3·CPU·i/f·0x%x·HPPI·update:·irq·%d·group·%d·prio·%d"·"\n",

3289

·····················qemu_get_thread_id(),

3289

·····················qemu_get_thread_id(),

3290

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3290

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3291

·····················,·cpuid,·irq,·grp,·prio);

3291

·····················,·cpuid,·irq,·grp,·prio);

3292

#line·3294·"trace/trace-hw_intc.h"

3292

#line·3294·"trace/trace-hw_intc.h"

3293

········}·else·{

3293

········}·else·{

3295

············qemu_log("gicv3_cpuif_update·"·"GICv3·CPU·i/f·0x%x·HPPI·update:·irq·%d·group·%d·prio·%d"·"\n",·cpuid,·irq,·grp,·prio);

3295

············qemu_log("gicv3_cpuif_update·"·"GICv3·CPU·i/f·0x%x·HPPI·update:·irq·%d·group·%d·prio·%d"·"\n",·cpuid,·irq,·grp,·prio);

3296

#line·3298·"trace/trace-hw_intc.h"

3296

#line·3298·"trace/trace-hw_intc.h"

3297

········}

3297

········}

3298

····}

3298

····}

3299

}

3299

}

3300

static·inline·void·trace_gicv3_cpuif_update(uint32_t·cpuid,·int·irq,·int·grp,·int·prio)

3300

static·inline·void·trace_gicv3_cpuif_update(uint32_t·cpuid,·int·irq,·int·grp,·int·prio)

3312

static·inline·void·_nocheck__trace_gicv3_cpuif_set_irqs(uint32_t·cpuid,·int·fiqlevel,·int·irqlevel)

3312

static·inline·void·_nocheck__trace_gicv3_cpuif_set_irqs(uint32_t·cpuid,·int·fiqlevel,·int·irqlevel)

3313

{

3313

{

3314

····if·(trace_event_get_state(TRACE_GICV3_CPUIF_SET_IRQS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3314

····if·(trace_event_get_state(TRACE_GICV3_CPUIF_SET_IRQS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3315

········if·(message_with_timestamp)·{

3315

········if·(message_with_timestamp)·{

3316

············struct·timeval·_now;

3316

············struct·timeval·_now;

3317

············gettimeofday(&_now,·NULL);

3317

············gettimeofday(&_now,·NULL);

3319

············qemu_log("%d@%zu.%06zu:gicv3_cpuif_set_irqs·"·"GICv3·CPU·i/f·0x%x·HPPI·update:·setting·FIQ·%d·IRQ·%d"·"\n",

3319

············qemu_log("%d@%zu.%06zu:gicv3_cpuif_set_irqs·"·"GICv3·CPU·i/f·0x%x·HPPI·update:·setting·FIQ·%d·IRQ·%d"·"\n",

3320

·····················qemu_get_thread_id(),

3320

·····················qemu_get_thread_id(),

3321

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3321

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3322

·····················,·cpuid,·fiqlevel,·irqlevel);

3322

·····················,·cpuid,·fiqlevel,·irqlevel);

3323

#line·3325·"trace/trace-hw_intc.h"

3323

#line·3325·"trace/trace-hw_intc.h"

3324

········}·else·{

3324

········}·else·{

3326

············qemu_log("gicv3_cpuif_set_irqs·"·"GICv3·CPU·i/f·0x%x·HPPI·update:·setting·FIQ·%d·IRQ·%d"·"\n",·cpuid,·fiqlevel,·irqlevel);

3326

············qemu_log("gicv3_cpuif_set_irqs·"·"GICv3·CPU·i/f·0x%x·HPPI·update:·setting·FIQ·%d·IRQ·%d"·"\n",·cpuid,·fiqlevel,·irqlevel);

3327

#line·3329·"trace/trace-hw_intc.h"

3327

#line·3329·"trace/trace-hw_intc.h"

3328

········}

3328

········}

3329

····}

3329

····}

3330

}

3330

}

3331

static·inline·void·trace_gicv3_cpuif_set_irqs(uint32_t·cpuid,·int·fiqlevel,·int·irqlevel)

3331

static·inline·void·trace_gicv3_cpuif_set_irqs(uint32_t·cpuid,·int·fiqlevel,·int·irqlevel)

3343

static·inline·void·_nocheck__trace_gicv3_icc_generate_sgi(uint32_t·cpuid,·int·irq,·int·irm,·uint32_t·aff,·uint32_t·targetlist)

3343

static·inline·void·_nocheck__trace_gicv3_icc_generate_sgi(uint32_t·cpuid,·int·irq,·int·irm,·uint32_t·aff,·uint32_t·targetlist)

3344

{

3344

{

3345

····if·(trace_event_get_state(TRACE_GICV3_ICC_GENERATE_SGI)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3345

····if·(trace_event_get_state(TRACE_GICV3_ICC_GENERATE_SGI)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3346

········if·(message_with_timestamp)·{

3346

········if·(message_with_timestamp)·{

3347

············struct·timeval·_now;

3347

············struct·timeval·_now;

3348

············gettimeofday(&_now,·NULL);

3348

············gettimeofday(&_now,·NULL);

3350

············qemu_log("%d@%zu.%06zu:gicv3_icc_generate_sgi·"·"GICv3·CPU·i/f·0x%x·generating·SGI·%d·IRM·%d·target·affinity·0x%xxx·targetlist·0x%x"·"\n",

3350

············qemu_log("%d@%zu.%06zu:gicv3_icc_generate_sgi·"·"GICv3·CPU·i/f·0x%x·generating·SGI·%d·IRM·%d·target·affinity·0x%xxx·targetlist·0x%x"·"\n",

3351

·····················qemu_get_thread_id(),

3351

·····················qemu_get_thread_id(),

3352

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3352

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3353

·····················,·cpuid,·irq,·irm,·aff,·targetlist);

3353

·····················,·cpuid,·irq,·irm,·aff,·targetlist);

3354

#line·3356·"trace/trace-hw_intc.h"

3354

#line·3356·"trace/trace-hw_intc.h"

3355

········}·else·{

3355

········}·else·{

3357

············qemu_log("gicv3_icc_generate_sgi·"·"GICv3·CPU·i/f·0x%x·generating·SGI·%d·IRM·%d·target·affinity·0x%xxx·targetlist·0x%x"·"\n",·cpuid,·irq,·irm,·aff,·targetlist);

3357

············qemu_log("gicv3_icc_generate_sgi·"·"GICv3·CPU·i/f·0x%x·generating·SGI·%d·IRM·%d·target·affinity·0x%xxx·targetlist·0x%x"·"\n",·cpuid,·irq,·irm,·aff,·targetlist);

3358

#line·3360·"trace/trace-hw_intc.h"

3358

#line·3360·"trace/trace-hw_intc.h"

3359

········}

3359

········}

3360

····}

3360

····}

3361

}

3361

}

3362

static·inline·void·trace_gicv3_icc_generate_sgi(uint32_t·cpuid,·int·irq,·int·irm,·uint32_t·aff,·uint32_t·targetlist)

3362

static·inline·void·trace_gicv3_icc_generate_sgi(uint32_t·cpuid,·int·irq,·int·irm,·uint32_t·aff,·uint32_t·targetlist)

3374

static·inline·void·_nocheck__trace_gicv3_icc_iar0_read(uint32_t·cpu,·uint64_t·val)

3374

static·inline·void·_nocheck__trace_gicv3_icc_iar0_read(uint32_t·cpu,·uint64_t·val)

3375

{

3375

{

3376

····if·(trace_event_get_state(TRACE_GICV3_ICC_IAR0_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3376

····if·(trace_event_get_state(TRACE_GICV3_ICC_IAR0_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3377

········if·(message_with_timestamp)·{

3377

········if·(message_with_timestamp)·{

3378

············struct·timeval·_now;

3378

············struct·timeval·_now;

3379

············gettimeofday(&_now,·NULL);

3379

············gettimeofday(&_now,·NULL);

3381

············qemu_log("%d@%zu.%06zu:gicv3_icc_iar0_read·"·"GICv3·ICC_IAR0·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3381

············qemu_log("%d@%zu.%06zu:gicv3_icc_iar0_read·"·"GICv3·ICC_IAR0·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3382

·····················qemu_get_thread_id(),

3382

·····················qemu_get_thread_id(),

3383

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3383

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3384

·····················,·cpu,·val);

3384

·····················,·cpu,·val);

3385

#line·3387·"trace/trace-hw_intc.h"

3385

#line·3387·"trace/trace-hw_intc.h"

3386

········}·else·{

3386

········}·else·{

3388

············qemu_log("gicv3_icc_iar0_read·"·"GICv3·ICC_IAR0·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3388

············qemu_log("gicv3_icc_iar0_read·"·"GICv3·ICC_IAR0·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3389

#line·3391·"trace/trace-hw_intc.h"

3389

#line·3391·"trace/trace-hw_intc.h"

3390

········}

3390

········}

3391

····}

3391

····}

3392

}

3392

}

3393

static·inline·void·trace_gicv3_icc_iar0_read(uint32_t·cpu,·uint64_t·val)

3393

static·inline·void·trace_gicv3_icc_iar0_read(uint32_t·cpu,·uint64_t·val)

3405

static·inline·void·_nocheck__trace_gicv3_icc_iar1_read(uint32_t·cpu,·uint64_t·val)

3405

static·inline·void·_nocheck__trace_gicv3_icc_iar1_read(uint32_t·cpu,·uint64_t·val)

3406

{

3406

{

3407

····if·(trace_event_get_state(TRACE_GICV3_ICC_IAR1_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3407

····if·(trace_event_get_state(TRACE_GICV3_ICC_IAR1_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3408

········if·(message_with_timestamp)·{

3408

········if·(message_with_timestamp)·{

3409

············struct·timeval·_now;

3409

············struct·timeval·_now;

3410

············gettimeofday(&_now,·NULL);

3410

············gettimeofday(&_now,·NULL);

3412

············qemu_log("%d@%zu.%06zu:gicv3_icc_iar1_read·"·"GICv3·ICC_IAR1·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3412

············qemu_log("%d@%zu.%06zu:gicv3_icc_iar1_read·"·"GICv3·ICC_IAR1·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3413

·····················qemu_get_thread_id(),

3413

·····················qemu_get_thread_id(),

3414

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3414

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3415

·····················,·cpu,·val);

3415

·····················,·cpu,·val);

3416

#line·3418·"trace/trace-hw_intc.h"

3416

#line·3418·"trace/trace-hw_intc.h"

3417

········}·else·{

3417

········}·else·{

3419

············qemu_log("gicv3_icc_iar1_read·"·"GICv3·ICC_IAR1·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3419

············qemu_log("gicv3_icc_iar1_read·"·"GICv3·ICC_IAR1·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3420

#line·3422·"trace/trace-hw_intc.h"

3420

#line·3422·"trace/trace-hw_intc.h"

3421

········}

3421

········}

3422

····}

3422

····}

3423

}

3423

}

3424

static·inline·void·trace_gicv3_icc_iar1_read(uint32_t·cpu,·uint64_t·val)

3424

static·inline·void·trace_gicv3_icc_iar1_read(uint32_t·cpu,·uint64_t·val)

3436

static·inline·void·_nocheck__trace_gicv3_icc_eoir_write(int·grp,·uint32_t·cpu,·uint64_t·val)

3436

static·inline·void·_nocheck__trace_gicv3_icc_eoir_write(int·grp,·uint32_t·cpu,·uint64_t·val)

3437

{

3437

{

3438

····if·(trace_event_get_state(TRACE_GICV3_ICC_EOIR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3438

····if·(trace_event_get_state(TRACE_GICV3_ICC_EOIR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3439

········if·(message_with_timestamp)·{

3439

········if·(message_with_timestamp)·{

3440

············struct·timeval·_now;

3440

············struct·timeval·_now;

3441

············gettimeofday(&_now,·NULL);

3441

············gettimeofday(&_now,·NULL);

3443

············qemu_log("%d@%zu.%06zu:gicv3_icc_eoir_write·"·"GICv3·ICC_EOIR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

3443

············qemu_log("%d@%zu.%06zu:gicv3_icc_eoir_write·"·"GICv3·ICC_EOIR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

3444

·····················qemu_get_thread_id(),

3444

·····················qemu_get_thread_id(),

3445

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3445

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3446

·····················,·grp,·cpu,·val);

3446

·····················,·grp,·cpu,·val);

3447

#line·3449·"trace/trace-hw_intc.h"

3447

#line·3449·"trace/trace-hw_intc.h"

3448

········}·else·{

3448

········}·else·{

3450

············qemu_log("gicv3_icc_eoir_write·"·"GICv3·ICC_EOIR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·cpu,·val);

3450

············qemu_log("gicv3_icc_eoir_write·"·"GICv3·ICC_EOIR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·cpu,·val);

3451

#line·3453·"trace/trace-hw_intc.h"

3451

#line·3453·"trace/trace-hw_intc.h"

3452

········}

3452

········}

3453

····}

3453

····}

3454

}

3454

}

3455

static·inline·void·trace_gicv3_icc_eoir_write(int·grp,·uint32_t·cpu,·uint64_t·val)

3455

static·inline·void·trace_gicv3_icc_eoir_write(int·grp,·uint32_t·cpu,·uint64_t·val)

3467

static·inline·void·_nocheck__trace_gicv3_icc_hppir0_read(uint32_t·cpu,·uint64_t·val)

3467

static·inline·void·_nocheck__trace_gicv3_icc_hppir0_read(uint32_t·cpu,·uint64_t·val)

3468

{

3468

{

3469

····if·(trace_event_get_state(TRACE_GICV3_ICC_HPPIR0_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3469

····if·(trace_event_get_state(TRACE_GICV3_ICC_HPPIR0_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3470

········if·(message_with_timestamp)·{

3470

········if·(message_with_timestamp)·{

3471

············struct·timeval·_now;

3471

············struct·timeval·_now;

3472

············gettimeofday(&_now,·NULL);

3472

············gettimeofday(&_now,·NULL);

3474

············qemu_log("%d@%zu.%06zu:gicv3_icc_hppir0_read·"·"GICv3·ICC_HPPIR0·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3474

············qemu_log("%d@%zu.%06zu:gicv3_icc_hppir0_read·"·"GICv3·ICC_HPPIR0·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3475

·····················qemu_get_thread_id(),

3475

·····················qemu_get_thread_id(),

3476

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3476

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3477

·····················,·cpu,·val);

3477

·····················,·cpu,·val);

3478

#line·3480·"trace/trace-hw_intc.h"

3478

#line·3480·"trace/trace-hw_intc.h"

3479

········}·else·{

3479

········}·else·{

3481

············qemu_log("gicv3_icc_hppir0_read·"·"GICv3·ICC_HPPIR0·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3481

············qemu_log("gicv3_icc_hppir0_read·"·"GICv3·ICC_HPPIR0·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3482

#line·3484·"trace/trace-hw_intc.h"

3482

#line·3484·"trace/trace-hw_intc.h"

3483

········}

3483

········}

3484

····}

3484

····}

3485

}

3485

}

3486

static·inline·void·trace_gicv3_icc_hppir0_read(uint32_t·cpu,·uint64_t·val)

3486

static·inline·void·trace_gicv3_icc_hppir0_read(uint32_t·cpu,·uint64_t·val)

3498

static·inline·void·_nocheck__trace_gicv3_icc_hppir1_read(uint32_t·cpu,·uint64_t·val)

3498

static·inline·void·_nocheck__trace_gicv3_icc_hppir1_read(uint32_t·cpu,·uint64_t·val)

3499

{

3499

{

3500

····if·(trace_event_get_state(TRACE_GICV3_ICC_HPPIR1_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3500

····if·(trace_event_get_state(TRACE_GICV3_ICC_HPPIR1_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3501

········if·(message_with_timestamp)·{

3501

········if·(message_with_timestamp)·{

3502

············struct·timeval·_now;

3502

············struct·timeval·_now;

3503

············gettimeofday(&_now,·NULL);

3503

············gettimeofday(&_now,·NULL);

3505

············qemu_log("%d@%zu.%06zu:gicv3_icc_hppir1_read·"·"GICv3·ICC_HPPIR1·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3505

············qemu_log("%d@%zu.%06zu:gicv3_icc_hppir1_read·"·"GICv3·ICC_HPPIR1·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3506

·····················qemu_get_thread_id(),

3506

·····················qemu_get_thread_id(),

3507

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3507

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3508

·····················,·cpu,·val);

3508

·····················,·cpu,·val);

3509

#line·3511·"trace/trace-hw_intc.h"

3509

#line·3511·"trace/trace-hw_intc.h"

3510

········}·else·{

3510

········}·else·{

3512

············qemu_log("gicv3_icc_hppir1_read·"·"GICv3·ICC_HPPIR1·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3512

············qemu_log("gicv3_icc_hppir1_read·"·"GICv3·ICC_HPPIR1·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3513

#line·3515·"trace/trace-hw_intc.h"

3513

#line·3515·"trace/trace-hw_intc.h"

3514

········}

3514

········}

3515

····}

3515

····}

3516

}

3516

}

3517

static·inline·void·trace_gicv3_icc_hppir1_read(uint32_t·cpu,·uint64_t·val)

3517

static·inline·void·trace_gicv3_icc_hppir1_read(uint32_t·cpu,·uint64_t·val)

3529

static·inline·void·_nocheck__trace_gicv3_icc_dir_write(uint32_t·cpu,·uint64_t·val)

3529

static·inline·void·_nocheck__trace_gicv3_icc_dir_write(uint32_t·cpu,·uint64_t·val)

3530

{

3530

{

3531

····if·(trace_event_get_state(TRACE_GICV3_ICC_DIR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3531

····if·(trace_event_get_state(TRACE_GICV3_ICC_DIR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3532

········if·(message_with_timestamp)·{

3532

········if·(message_with_timestamp)·{

3533

············struct·timeval·_now;

3533

············struct·timeval·_now;

3534

············gettimeofday(&_now,·NULL);

3534

············gettimeofday(&_now,·NULL);

3536

············qemu_log("%d@%zu.%06zu:gicv3_icc_dir_write·"·"GICv3·ICC_DIR·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

3536

············qemu_log("%d@%zu.%06zu:gicv3_icc_dir_write·"·"GICv3·ICC_DIR·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

3537

·····················qemu_get_thread_id(),

3537

·····················qemu_get_thread_id(),

3538

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3538

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3539

·····················,·cpu,·val);

3539

·····················,·cpu,·val);

3540

#line·3542·"trace/trace-hw_intc.h"

3540

#line·3542·"trace/trace-hw_intc.h"

3541

········}·else·{

3541

········}·else·{

3543

············qemu_log("gicv3_icc_dir_write·"·"GICv3·ICC_DIR·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3543

············qemu_log("gicv3_icc_dir_write·"·"GICv3·ICC_DIR·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3544

#line·3546·"trace/trace-hw_intc.h"

3544

#line·3546·"trace/trace-hw_intc.h"

3545

········}

3545

········}

3546

····}

3546

····}

3547

}

3547

}

3548

static·inline·void·trace_gicv3_icc_dir_write(uint32_t·cpu,·uint64_t·val)

3548

static·inline·void·trace_gicv3_icc_dir_write(uint32_t·cpu,·uint64_t·val)

3560

static·inline·void·_nocheck__trace_gicv3_icc_rpr_read(uint32_t·cpu,·uint64_t·val)

3560

static·inline·void·_nocheck__trace_gicv3_icc_rpr_read(uint32_t·cpu,·uint64_t·val)

3561

{

3561

{

3562

····if·(trace_event_get_state(TRACE_GICV3_ICC_RPR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3562

····if·(trace_event_get_state(TRACE_GICV3_ICC_RPR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3563

········if·(message_with_timestamp)·{

3563

········if·(message_with_timestamp)·{

3564

············struct·timeval·_now;

3564

············struct·timeval·_now;

3565

············gettimeofday(&_now,·NULL);

3565

············gettimeofday(&_now,·NULL);

3567

············qemu_log("%d@%zu.%06zu:gicv3_icc_rpr_read·"·"GICv3·ICC_RPR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3567

············qemu_log("%d@%zu.%06zu:gicv3_icc_rpr_read·"·"GICv3·ICC_RPR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3568

·····················qemu_get_thread_id(),

3568

·····················qemu_get_thread_id(),

3569

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3569

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3570

·····················,·cpu,·val);

3570

·····················,·cpu,·val);

3571

#line·3573·"trace/trace-hw_intc.h"

3571

#line·3573·"trace/trace-hw_intc.h"

3572

········}·else·{

3572

········}·else·{

3574

············qemu_log("gicv3_icc_rpr_read·"·"GICv3·ICC_RPR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3574

············qemu_log("gicv3_icc_rpr_read·"·"GICv3·ICC_RPR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3575

#line·3577·"trace/trace-hw_intc.h"

3575

#line·3577·"trace/trace-hw_intc.h"

3576

········}

3576

········}

3577

····}

3577

····}

3578

}

3578

}

3579

static·inline·void·trace_gicv3_icc_rpr_read(uint32_t·cpu,·uint64_t·val)

3579

static·inline·void·trace_gicv3_icc_rpr_read(uint32_t·cpu,·uint64_t·val)

3591

static·inline·void·_nocheck__trace_gicv3_ich_ap_read(int·grp,·int·regno,·uint32_t·cpu,·uint64_t·val)

3591

static·inline·void·_nocheck__trace_gicv3_ich_ap_read(int·grp,·int·regno,·uint32_t·cpu,·uint64_t·val)

3592

{

3592

{

3593

····if·(trace_event_get_state(TRACE_GICV3_ICH_AP_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3593

····if·(trace_event_get_state(TRACE_GICV3_ICH_AP_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3594

········if·(message_with_timestamp)·{

3594

········if·(message_with_timestamp)·{

3595

············struct·timeval·_now;

3595

············struct·timeval·_now;

3596

············gettimeofday(&_now,·NULL);

3596

············gettimeofday(&_now,·NULL);

3598

············qemu_log("%d@%zu.%06zu:gicv3_ich_ap_read·"·"GICv3·ICH_AP%dR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3598

············qemu_log("%d@%zu.%06zu:gicv3_ich_ap_read·"·"GICv3·ICH_AP%dR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3599

·····················qemu_get_thread_id(),

3599

·····················qemu_get_thread_id(),

3600

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3600

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3601

·····················,·grp,·regno,·cpu,·val);

3601

·····················,·grp,·regno,·cpu,·val);

3602

#line·3604·"trace/trace-hw_intc.h"

3602

#line·3604·"trace/trace-hw_intc.h"

3603

········}·else·{

3603

········}·else·{

3605

············qemu_log("gicv3_ich_ap_read·"·"GICv3·ICH_AP%dR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·regno,·cpu,·val);

3605

············qemu_log("gicv3_ich_ap_read·"·"GICv3·ICH_AP%dR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·regno,·cpu,·val);

3606

#line·3608·"trace/trace-hw_intc.h"

3606

#line·3608·"trace/trace-hw_intc.h"

3607

········}

3607

········}

3608

····}

3608

····}

3609

}

3609

}

3610

static·inline·void·trace_gicv3_ich_ap_read(int·grp,·int·regno,·uint32_t·cpu,·uint64_t·val)

3610

static·inline·void·trace_gicv3_ich_ap_read(int·grp,·int·regno,·uint32_t·cpu,·uint64_t·val)

3622

static·inline·void·_nocheck__trace_gicv3_ich_ap_write(int·grp,·int·regno,·uint32_t·cpu,·uint64_t·val)

3622

static·inline·void·_nocheck__trace_gicv3_ich_ap_write(int·grp,·int·regno,·uint32_t·cpu,·uint64_t·val)

3623

{

3623

{

3624

····if·(trace_event_get_state(TRACE_GICV3_ICH_AP_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3624

····if·(trace_event_get_state(TRACE_GICV3_ICH_AP_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3625

········if·(message_with_timestamp)·{

3625

········if·(message_with_timestamp)·{

3626

············struct·timeval·_now;

3626

············struct·timeval·_now;

3627

············gettimeofday(&_now,·NULL);

3627

············gettimeofday(&_now,·NULL);

3629

············qemu_log("%d@%zu.%06zu:gicv3_ich_ap_write·"·"GICv3·ICH_AP%dR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

3629

············qemu_log("%d@%zu.%06zu:gicv3_ich_ap_write·"·"GICv3·ICH_AP%dR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

3630

·····················qemu_get_thread_id(),

3630

·····················qemu_get_thread_id(),

3631

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3631

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3632

·····················,·grp,·regno,·cpu,·val);

3632

·····················,·grp,·regno,·cpu,·val);

3633

#line·3635·"trace/trace-hw_intc.h"

3633

#line·3635·"trace/trace-hw_intc.h"

3634

········}·else·{

3634

········}·else·{

3636

············qemu_log("gicv3_ich_ap_write·"·"GICv3·ICH_AP%dR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·regno,·cpu,·val);

3636

············qemu_log("gicv3_ich_ap_write·"·"GICv3·ICH_AP%dR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·regno,·cpu,·val);

3637

#line·3639·"trace/trace-hw_intc.h"

3637

#line·3639·"trace/trace-hw_intc.h"

3638

········}

3638

········}

3639

····}

3639

····}

3640

}

3640

}

3641

static·inline·void·trace_gicv3_ich_ap_write(int·grp,·int·regno,·uint32_t·cpu,·uint64_t·val)

3641

static·inline·void·trace_gicv3_ich_ap_write(int·grp,·int·regno,·uint32_t·cpu,·uint64_t·val)

3653

static·inline·void·_nocheck__trace_gicv3_ich_hcr_read(uint32_t·cpu,·uint64_t·val)

3653

static·inline·void·_nocheck__trace_gicv3_ich_hcr_read(uint32_t·cpu,·uint64_t·val)

3654

{

3654

{

3655

····if·(trace_event_get_state(TRACE_GICV3_ICH_HCR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3655

····if·(trace_event_get_state(TRACE_GICV3_ICH_HCR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3656

········if·(message_with_timestamp)·{

3656

········if·(message_with_timestamp)·{

3657

············struct·timeval·_now;

3657

············struct·timeval·_now;

3658

············gettimeofday(&_now,·NULL);

3658

············gettimeofday(&_now,·NULL);

3660

············qemu_log("%d@%zu.%06zu:gicv3_ich_hcr_read·"·"GICv3·ICH_HCR_EL2·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3660

············qemu_log("%d@%zu.%06zu:gicv3_ich_hcr_read·"·"GICv3·ICH_HCR_EL2·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3661

·····················qemu_get_thread_id(),

3661

·····················qemu_get_thread_id(),

3662

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3662

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3663

·····················,·cpu,·val);

3663

·····················,·cpu,·val);

3664

#line·3666·"trace/trace-hw_intc.h"

3664

#line·3666·"trace/trace-hw_intc.h"

3665

········}·else·{

3665

········}·else·{

3667

············qemu_log("gicv3_ich_hcr_read·"·"GICv3·ICH_HCR_EL2·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3667

············qemu_log("gicv3_ich_hcr_read·"·"GICv3·ICH_HCR_EL2·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3668

#line·3670·"trace/trace-hw_intc.h"

3668

#line·3670·"trace/trace-hw_intc.h"

3669

········}

3669

········}

3670

····}

3670

····}

3671

}

3671

}

3672

static·inline·void·trace_gicv3_ich_hcr_read(uint32_t·cpu,·uint64_t·val)

3672

static·inline·void·trace_gicv3_ich_hcr_read(uint32_t·cpu,·uint64_t·val)

3684

static·inline·void·_nocheck__trace_gicv3_ich_hcr_write(uint32_t·cpu,·uint64_t·val)

3684

static·inline·void·_nocheck__trace_gicv3_ich_hcr_write(uint32_t·cpu,·uint64_t·val)

3685

{

3685

{

3686

····if·(trace_event_get_state(TRACE_GICV3_ICH_HCR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3686

····if·(trace_event_get_state(TRACE_GICV3_ICH_HCR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3687

········if·(message_with_timestamp)·{

3687

········if·(message_with_timestamp)·{

3688

············struct·timeval·_now;

3688

············struct·timeval·_now;

3689

············gettimeofday(&_now,·NULL);

3689

············gettimeofday(&_now,·NULL);

3691

············qemu_log("%d@%zu.%06zu:gicv3_ich_hcr_write·"·"GICv3·ICH_HCR_EL2·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

3691

············qemu_log("%d@%zu.%06zu:gicv3_ich_hcr_write·"·"GICv3·ICH_HCR_EL2·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

3692

·····················qemu_get_thread_id(),

3692

·····················qemu_get_thread_id(),

3693

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3693

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3694

·····················,·cpu,·val);

3694

·····················,·cpu,·val);

3695

#line·3697·"trace/trace-hw_intc.h"

3695

#line·3697·"trace/trace-hw_intc.h"

3696

········}·else·{

3696

········}·else·{

3698

············qemu_log("gicv3_ich_hcr_write·"·"GICv3·ICH_HCR_EL2·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3698

············qemu_log("gicv3_ich_hcr_write·"·"GICv3·ICH_HCR_EL2·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3699

#line·3701·"trace/trace-hw_intc.h"

3699

#line·3701·"trace/trace-hw_intc.h"

3700

········}

3700

········}

3701

····}

3701

····}

3702

}

3702

}

3703

static·inline·void·trace_gicv3_ich_hcr_write(uint32_t·cpu,·uint64_t·val)

3703

static·inline·void·trace_gicv3_ich_hcr_write(uint32_t·cpu,·uint64_t·val)

3715

static·inline·void·_nocheck__trace_gicv3_ich_vmcr_read(uint32_t·cpu,·uint64_t·val)

3715

static·inline·void·_nocheck__trace_gicv3_ich_vmcr_read(uint32_t·cpu,·uint64_t·val)

3716

{

3716

{

3717

····if·(trace_event_get_state(TRACE_GICV3_ICH_VMCR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3717

····if·(trace_event_get_state(TRACE_GICV3_ICH_VMCR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3718

········if·(message_with_timestamp)·{

3718

········if·(message_with_timestamp)·{

3719

············struct·timeval·_now;

3719

············struct·timeval·_now;

3720

············gettimeofday(&_now,·NULL);

3720

············gettimeofday(&_now,·NULL);

3722

············qemu_log("%d@%zu.%06zu:gicv3_ich_vmcr_read·"·"GICv3·ICH_VMCR_EL2·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3722

············qemu_log("%d@%zu.%06zu:gicv3_ich_vmcr_read·"·"GICv3·ICH_VMCR_EL2·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3723

·····················qemu_get_thread_id(),

3723

·····················qemu_get_thread_id(),

3724

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3724

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3725

·····················,·cpu,·val);

3725

·····················,·cpu,·val);

3726

#line·3728·"trace/trace-hw_intc.h"

3726

#line·3728·"trace/trace-hw_intc.h"

3727

········}·else·{

3727

········}·else·{

3729

············qemu_log("gicv3_ich_vmcr_read·"·"GICv3·ICH_VMCR_EL2·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3729

············qemu_log("gicv3_ich_vmcr_read·"·"GICv3·ICH_VMCR_EL2·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3730

#line·3732·"trace/trace-hw_intc.h"

3730

#line·3732·"trace/trace-hw_intc.h"

3731

········}

3731

········}

3732

····}

3732

····}

3733

}

3733

}

3734

static·inline·void·trace_gicv3_ich_vmcr_read(uint32_t·cpu,·uint64_t·val)

3734

static·inline·void·trace_gicv3_ich_vmcr_read(uint32_t·cpu,·uint64_t·val)

3746

static·inline·void·_nocheck__trace_gicv3_ich_vmcr_write(uint32_t·cpu,·uint64_t·val)

3746

static·inline·void·_nocheck__trace_gicv3_ich_vmcr_write(uint32_t·cpu,·uint64_t·val)

3747

{

3747

{

3748

····if·(trace_event_get_state(TRACE_GICV3_ICH_VMCR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3748

····if·(trace_event_get_state(TRACE_GICV3_ICH_VMCR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3749

········if·(message_with_timestamp)·{

3749

········if·(message_with_timestamp)·{

3750

············struct·timeval·_now;

3750

············struct·timeval·_now;

3751

············gettimeofday(&_now,·NULL);

3751

············gettimeofday(&_now,·NULL);

3753

············qemu_log("%d@%zu.%06zu:gicv3_ich_vmcr_write·"·"GICv3·ICH_VMCR_EL2·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

3753

············qemu_log("%d@%zu.%06zu:gicv3_ich_vmcr_write·"·"GICv3·ICH_VMCR_EL2·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

3754

·····················qemu_get_thread_id(),

3754

·····················qemu_get_thread_id(),

3755

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3755

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3756

·····················,·cpu,·val);

3756

·····················,·cpu,·val);

3757

#line·3759·"trace/trace-hw_intc.h"

3757

#line·3759·"trace/trace-hw_intc.h"

3758

········}·else·{

3758

········}·else·{

3760

············qemu_log("gicv3_ich_vmcr_write·"·"GICv3·ICH_VMCR_EL2·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3760

············qemu_log("gicv3_ich_vmcr_write·"·"GICv3·ICH_VMCR_EL2·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3761

#line·3763·"trace/trace-hw_intc.h"

3761

#line·3763·"trace/trace-hw_intc.h"

3762

········}

3762

········}

3763

····}

3763

····}

3764

}

3764

}

3765

static·inline·void·trace_gicv3_ich_vmcr_write(uint32_t·cpu,·uint64_t·val)

3765

static·inline·void·trace_gicv3_ich_vmcr_write(uint32_t·cpu,·uint64_t·val)

3777

static·inline·void·_nocheck__trace_gicv3_ich_lr_read(int·regno,·uint32_t·cpu,·uint64_t·val)

3777

static·inline·void·_nocheck__trace_gicv3_ich_lr_read(int·regno,·uint32_t·cpu,·uint64_t·val)

3778

{

3778

{

3779

····if·(trace_event_get_state(TRACE_GICV3_ICH_LR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3779

····if·(trace_event_get_state(TRACE_GICV3_ICH_LR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3780

········if·(message_with_timestamp)·{

3780

········if·(message_with_timestamp)·{

3781

············struct·timeval·_now;

3781

············struct·timeval·_now;

3782

············gettimeofday(&_now,·NULL);

3782

············gettimeofday(&_now,·NULL);

3784

············qemu_log("%d@%zu.%06zu:gicv3_ich_lr_read·"·"GICv3·ICH_LR%d_EL2·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3784

············qemu_log("%d@%zu.%06zu:gicv3_ich_lr_read·"·"GICv3·ICH_LR%d_EL2·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3785

·····················qemu_get_thread_id(),

3785

·····················qemu_get_thread_id(),

3786

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3786

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3787

·····················,·regno,·cpu,·val);

3787

·····················,·regno,·cpu,·val);

3788

#line·3790·"trace/trace-hw_intc.h"

3788

#line·3790·"trace/trace-hw_intc.h"

3789

········}·else·{

3789

········}·else·{

3791

············qemu_log("gicv3_ich_lr_read·"·"GICv3·ICH_LR%d_EL2·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·regno,·cpu,·val);

3791

············qemu_log("gicv3_ich_lr_read·"·"GICv3·ICH_LR%d_EL2·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·regno,·cpu,·val);

3792

#line·3794·"trace/trace-hw_intc.h"

3792

#line·3794·"trace/trace-hw_intc.h"

3793

········}

3793

········}

3794

····}

3794

····}

3795

}

3795

}

3796

static·inline·void·trace_gicv3_ich_lr_read(int·regno,·uint32_t·cpu,·uint64_t·val)

3796

static·inline·void·trace_gicv3_ich_lr_read(int·regno,·uint32_t·cpu,·uint64_t·val)

3808

static·inline·void·_nocheck__trace_gicv3_ich_lr32_read(int·regno,·uint32_t·cpu,·uint32_t·val)

3808

static·inline·void·_nocheck__trace_gicv3_ich_lr32_read(int·regno,·uint32_t·cpu,·uint32_t·val)

3809

{

3809

{

3810

····if·(trace_event_get_state(TRACE_GICV3_ICH_LR32_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3810

····if·(trace_event_get_state(TRACE_GICV3_ICH_LR32_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3811

········if·(message_with_timestamp)·{

3811

········if·(message_with_timestamp)·{

3812

············struct·timeval·_now;

3812

············struct·timeval·_now;

3813

············gettimeofday(&_now,·NULL);

3813

············gettimeofday(&_now,·NULL);

3815

············qemu_log("%d@%zu.%06zu:gicv3_ich_lr32_read·"·"GICv3·ICH_LR%d·read·cpu·0x%x·value·0x%"·PRIx32·"\n",

3815

············qemu_log("%d@%zu.%06zu:gicv3_ich_lr32_read·"·"GICv3·ICH_LR%d·read·cpu·0x%x·value·0x%"·PRIx32·"\n",

3816

·····················qemu_get_thread_id(),

3816

·····················qemu_get_thread_id(),

3817

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3817

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3818

·····················,·regno,·cpu,·val);

3818

·····················,·regno,·cpu,·val);

3819

#line·3821·"trace/trace-hw_intc.h"

3819

#line·3821·"trace/trace-hw_intc.h"

3820

········}·else·{

3820

········}·else·{

3822

············qemu_log("gicv3_ich_lr32_read·"·"GICv3·ICH_LR%d·read·cpu·0x%x·value·0x%"·PRIx32·"\n",·regno,·cpu,·val);

3822

············qemu_log("gicv3_ich_lr32_read·"·"GICv3·ICH_LR%d·read·cpu·0x%x·value·0x%"·PRIx32·"\n",·regno,·cpu,·val);

3823

#line·3825·"trace/trace-hw_intc.h"

3823

#line·3825·"trace/trace-hw_intc.h"

3824

········}

3824

········}

3825

····}

3825

····}

3826

}

3826

}

3827

static·inline·void·trace_gicv3_ich_lr32_read(int·regno,·uint32_t·cpu,·uint32_t·val)

3827

static·inline·void·trace_gicv3_ich_lr32_read(int·regno,·uint32_t·cpu,·uint32_t·val)

3839

static·inline·void·_nocheck__trace_gicv3_ich_lrc_read(int·regno,·uint32_t·cpu,·uint32_t·val)

3839

static·inline·void·_nocheck__trace_gicv3_ich_lrc_read(int·regno,·uint32_t·cpu,·uint32_t·val)

3840

{

3840

{

3841

····if·(trace_event_get_state(TRACE_GICV3_ICH_LRC_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3841

····if·(trace_event_get_state(TRACE_GICV3_ICH_LRC_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3842

········if·(message_with_timestamp)·{

3842

········if·(message_with_timestamp)·{

3843

············struct·timeval·_now;

3843

············struct·timeval·_now;

3844

············gettimeofday(&_now,·NULL);

3844

············gettimeofday(&_now,·NULL);

3846

············qemu_log("%d@%zu.%06zu:gicv3_ich_lrc_read·"·"GICv3·ICH_LRC%d·read·cpu·0x%x·value·0x%"·PRIx32·"\n",

3846

············qemu_log("%d@%zu.%06zu:gicv3_ich_lrc_read·"·"GICv3·ICH_LRC%d·read·cpu·0x%x·value·0x%"·PRIx32·"\n",

3847

·····················qemu_get_thread_id(),

3847

·····················qemu_get_thread_id(),

3848

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3848

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3849

·····················,·regno,·cpu,·val);

3849

·····················,·regno,·cpu,·val);

3850

#line·3852·"trace/trace-hw_intc.h"

3850

#line·3852·"trace/trace-hw_intc.h"

3851

········}·else·{

3851

········}·else·{

3853

············qemu_log("gicv3_ich_lrc_read·"·"GICv3·ICH_LRC%d·read·cpu·0x%x·value·0x%"·PRIx32·"\n",·regno,·cpu,·val);

3853

············qemu_log("gicv3_ich_lrc_read·"·"GICv3·ICH_LRC%d·read·cpu·0x%x·value·0x%"·PRIx32·"\n",·regno,·cpu,·val);

3854

#line·3856·"trace/trace-hw_intc.h"

3854

#line·3856·"trace/trace-hw_intc.h"

3855

········}

3855

········}

3856

····}

3856

····}

3857

}

3857

}

3858

static·inline·void·trace_gicv3_ich_lrc_read(int·regno,·uint32_t·cpu,·uint32_t·val)

3858

static·inline·void·trace_gicv3_ich_lrc_read(int·regno,·uint32_t·cpu,·uint32_t·val)

3870

static·inline·void·_nocheck__trace_gicv3_ich_lr_write(int·regno,·uint32_t·cpu,·uint64_t·val)

3870

static·inline·void·_nocheck__trace_gicv3_ich_lr_write(int·regno,·uint32_t·cpu,·uint64_t·val)

3871

{

3871

{

3872

····if·(trace_event_get_state(TRACE_GICV3_ICH_LR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3872

····if·(trace_event_get_state(TRACE_GICV3_ICH_LR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3873

········if·(message_with_timestamp)·{

3873

········if·(message_with_timestamp)·{

3874

············struct·timeval·_now;

3874

············struct·timeval·_now;

3875

············gettimeofday(&_now,·NULL);

3875

············gettimeofday(&_now,·NULL);

3877

············qemu_log("%d@%zu.%06zu:gicv3_ich_lr_write·"·"GICv3·ICH_LR%d_EL2·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

3877

············qemu_log("%d@%zu.%06zu:gicv3_ich_lr_write·"·"GICv3·ICH_LR%d_EL2·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

3878

·····················qemu_get_thread_id(),

3878

·····················qemu_get_thread_id(),

3879

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3879

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3880

·····················,·regno,·cpu,·val);

3880

·····················,·regno,·cpu,·val);

3881

#line·3883·"trace/trace-hw_intc.h"

3881

#line·3883·"trace/trace-hw_intc.h"

3882

········}·else·{

3882

········}·else·{

3884

············qemu_log("gicv3_ich_lr_write·"·"GICv3·ICH_LR%d_EL2·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·regno,·cpu,·val);

3884

············qemu_log("gicv3_ich_lr_write·"·"GICv3·ICH_LR%d_EL2·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·regno,·cpu,·val);

3885

#line·3887·"trace/trace-hw_intc.h"

3885

#line·3887·"trace/trace-hw_intc.h"

3886

········}

3886

········}

3887

····}

3887

····}

3888

}

3888

}

3889

static·inline·void·trace_gicv3_ich_lr_write(int·regno,·uint32_t·cpu,·uint64_t·val)

3889

static·inline·void·trace_gicv3_ich_lr_write(int·regno,·uint32_t·cpu,·uint64_t·val)

3901

static·inline·void·_nocheck__trace_gicv3_ich_lr32_write(int·regno,·uint32_t·cpu,·uint32_t·val)

3901

static·inline·void·_nocheck__trace_gicv3_ich_lr32_write(int·regno,·uint32_t·cpu,·uint32_t·val)

3902

{

3902

{

3903

····if·(trace_event_get_state(TRACE_GICV3_ICH_LR32_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3903

····if·(trace_event_get_state(TRACE_GICV3_ICH_LR32_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3904

········if·(message_with_timestamp)·{

3904

········if·(message_with_timestamp)·{

3905

············struct·timeval·_now;

3905

············struct·timeval·_now;

3906

············gettimeofday(&_now,·NULL);

3906

············gettimeofday(&_now,·NULL);

3908

············qemu_log("%d@%zu.%06zu:gicv3_ich_lr32_write·"·"GICv3·ICH_LR%d·write·cpu·0x%x·value·0x%"·PRIx32·"\n",

3908

············qemu_log("%d@%zu.%06zu:gicv3_ich_lr32_write·"·"GICv3·ICH_LR%d·write·cpu·0x%x·value·0x%"·PRIx32·"\n",

3909

·····················qemu_get_thread_id(),

3909

·····················qemu_get_thread_id(),

3910

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3910

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3911

·····················,·regno,·cpu,·val);

3911

·····················,·regno,·cpu,·val);

3912

#line·3914·"trace/trace-hw_intc.h"

3912

#line·3914·"trace/trace-hw_intc.h"

3913

········}·else·{

3913

········}·else·{

3915

············qemu_log("gicv3_ich_lr32_write·"·"GICv3·ICH_LR%d·write·cpu·0x%x·value·0x%"·PRIx32·"\n",·regno,·cpu,·val);

3915

············qemu_log("gicv3_ich_lr32_write·"·"GICv3·ICH_LR%d·write·cpu·0x%x·value·0x%"·PRIx32·"\n",·regno,·cpu,·val);

3916

#line·3918·"trace/trace-hw_intc.h"

3916

#line·3918·"trace/trace-hw_intc.h"

3917

········}

3917

········}

3918

····}

3918

····}

3919

}

3919

}

3920

static·inline·void·trace_gicv3_ich_lr32_write(int·regno,·uint32_t·cpu,·uint32_t·val)

3920

static·inline·void·trace_gicv3_ich_lr32_write(int·regno,·uint32_t·cpu,·uint32_t·val)

3932

static·inline·void·_nocheck__trace_gicv3_ich_lrc_write(int·regno,·uint32_t·cpu,·uint32_t·val)

3932

static·inline·void·_nocheck__trace_gicv3_ich_lrc_write(int·regno,·uint32_t·cpu,·uint32_t·val)

3933

{

3933

{

3934

····if·(trace_event_get_state(TRACE_GICV3_ICH_LRC_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3934

····if·(trace_event_get_state(TRACE_GICV3_ICH_LRC_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3935

········if·(message_with_timestamp)·{

3935

········if·(message_with_timestamp)·{

3936

············struct·timeval·_now;

3936

············struct·timeval·_now;

3937

············gettimeofday(&_now,·NULL);

3937

············gettimeofday(&_now,·NULL);

3939

············qemu_log("%d@%zu.%06zu:gicv3_ich_lrc_write·"·"GICv3·ICH_LRC%d·write·cpu·0x%x·value·0x%"·PRIx32·"\n",

3939

············qemu_log("%d@%zu.%06zu:gicv3_ich_lrc_write·"·"GICv3·ICH_LRC%d·write·cpu·0x%x·value·0x%"·PRIx32·"\n",

3940

·····················qemu_get_thread_id(),

3940

·····················qemu_get_thread_id(),

3941

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3941

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3942

·····················,·regno,·cpu,·val);

3942

·····················,·regno,·cpu,·val);

3943

#line·3945·"trace/trace-hw_intc.h"

3943

#line·3945·"trace/trace-hw_intc.h"

3944

········}·else·{

3944

········}·else·{

3946

············qemu_log("gicv3_ich_lrc_write·"·"GICv3·ICH_LRC%d·write·cpu·0x%x·value·0x%"·PRIx32·"\n",·regno,·cpu,·val);

3946

············qemu_log("gicv3_ich_lrc_write·"·"GICv3·ICH_LRC%d·write·cpu·0x%x·value·0x%"·PRIx32·"\n",·regno,·cpu,·val);

3947

#line·3949·"trace/trace-hw_intc.h"

3947

#line·3949·"trace/trace-hw_intc.h"

3948

········}

3948

········}

3949

····}

3949

····}

3950

}

3950

}

3951

static·inline·void·trace_gicv3_ich_lrc_write(int·regno,·uint32_t·cpu,·uint32_t·val)

3951

static·inline·void·trace_gicv3_ich_lrc_write(int·regno,·uint32_t·cpu,·uint32_t·val)

3963

static·inline·void·_nocheck__trace_gicv3_ich_vtr_read(uint32_t·cpu,·uint64_t·val)

3963

static·inline·void·_nocheck__trace_gicv3_ich_vtr_read(uint32_t·cpu,·uint64_t·val)

3964

{

3964

{

3965

····if·(trace_event_get_state(TRACE_GICV3_ICH_VTR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3965

····if·(trace_event_get_state(TRACE_GICV3_ICH_VTR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3966

········if·(message_with_timestamp)·{

3966

········if·(message_with_timestamp)·{

3967

············struct·timeval·_now;

3967

············struct·timeval·_now;

3968

············gettimeofday(&_now,·NULL);

3968

············gettimeofday(&_now,·NULL);

3970

············qemu_log("%d@%zu.%06zu:gicv3_ich_vtr_read·"·"GICv3·ICH_VTR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3970

············qemu_log("%d@%zu.%06zu:gicv3_ich_vtr_read·"·"GICv3·ICH_VTR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

3971

·····················qemu_get_thread_id(),

3971

·····················qemu_get_thread_id(),

3972

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3972

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3973

·····················,·cpu,·val);

3973

·····················,·cpu,·val);

3974

#line·3976·"trace/trace-hw_intc.h"

3974

#line·3976·"trace/trace-hw_intc.h"

3975

········}·else·{

3975

········}·else·{

3977

············qemu_log("gicv3_ich_vtr_read·"·"GICv3·ICH_VTR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3977

············qemu_log("gicv3_ich_vtr_read·"·"GICv3·ICH_VTR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

3978

#line·3980·"trace/trace-hw_intc.h"

3978

#line·3980·"trace/trace-hw_intc.h"

3979

········}

3979

········}

3980

····}

3980

····}

3981

}

3981

}

3982

static·inline·void·trace_gicv3_ich_vtr_read(uint32_t·cpu,·uint64_t·val)

3982

static·inline·void·trace_gicv3_ich_vtr_read(uint32_t·cpu,·uint64_t·val)

3994

static·inline·void·_nocheck__trace_gicv3_ich_misr_read(uint32_t·cpu,·uint64_t·val)

3994

static·inline·void·_nocheck__trace_gicv3_ich_misr_read(uint32_t·cpu,·uint64_t·val)

3995

{

3995

{

3996

····if·(trace_event_get_state(TRACE_GICV3_ICH_MISR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3996

····if·(trace_event_get_state(TRACE_GICV3_ICH_MISR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3997

········if·(message_with_timestamp)·{

3997

········if·(message_with_timestamp)·{

3998

············struct·timeval·_now;

3998

············struct·timeval·_now;

3999

············gettimeofday(&_now,·NULL);

3999

············gettimeofday(&_now,·NULL);

4001

············qemu_log("%d@%zu.%06zu:gicv3_ich_misr_read·"·"GICv3·ICH_MISR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

4001

············qemu_log("%d@%zu.%06zu:gicv3_ich_misr_read·"·"GICv3·ICH_MISR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

4002

·····················qemu_get_thread_id(),

4002

·····················qemu_get_thread_id(),

4003

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4003

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4004

·····················,·cpu,·val);

4004

·····················,·cpu,·val);

4005

#line·4007·"trace/trace-hw_intc.h"

4005

#line·4007·"trace/trace-hw_intc.h"

4006

········}·else·{

4006

········}·else·{

4008

············qemu_log("gicv3_ich_misr_read·"·"GICv3·ICH_MISR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

4008

············qemu_log("gicv3_ich_misr_read·"·"GICv3·ICH_MISR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

4009

#line·4011·"trace/trace-hw_intc.h"

4009

#line·4011·"trace/trace-hw_intc.h"

4010

········}

4010

········}

4011

····}

4011

····}

4012

}

4012

}

4013

static·inline·void·trace_gicv3_ich_misr_read(uint32_t·cpu,·uint64_t·val)

4013

static·inline·void·trace_gicv3_ich_misr_read(uint32_t·cpu,·uint64_t·val)

4025

static·inline·void·_nocheck__trace_gicv3_ich_eisr_read(uint32_t·cpu,·uint64_t·val)

4025

static·inline·void·_nocheck__trace_gicv3_ich_eisr_read(uint32_t·cpu,·uint64_t·val)

4026

{

4026

{

4027

····if·(trace_event_get_state(TRACE_GICV3_ICH_EISR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4027

····if·(trace_event_get_state(TRACE_GICV3_ICH_EISR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4028

········if·(message_with_timestamp)·{

4028

········if·(message_with_timestamp)·{

4029

············struct·timeval·_now;

4029

············struct·timeval·_now;

4030

············gettimeofday(&_now,·NULL);

4030

············gettimeofday(&_now,·NULL);

4032

············qemu_log("%d@%zu.%06zu:gicv3_ich_eisr_read·"·"GICv3·ICH_EISR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

4032

············qemu_log("%d@%zu.%06zu:gicv3_ich_eisr_read·"·"GICv3·ICH_EISR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

4033

·····················qemu_get_thread_id(),

4033

·····················qemu_get_thread_id(),

4034

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4034

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4035

·····················,·cpu,·val);

4035

·····················,·cpu,·val);

4036

#line·4038·"trace/trace-hw_intc.h"

4036

#line·4038·"trace/trace-hw_intc.h"

4037

········}·else·{

4037

········}·else·{

4039

············qemu_log("gicv3_ich_eisr_read·"·"GICv3·ICH_EISR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

4039

············qemu_log("gicv3_ich_eisr_read·"·"GICv3·ICH_EISR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

4040

#line·4042·"trace/trace-hw_intc.h"

4040

#line·4042·"trace/trace-hw_intc.h"

4041

········}

4041

········}

4042

····}

4042

····}

4043

}

4043

}

4044

static·inline·void·trace_gicv3_ich_eisr_read(uint32_t·cpu,·uint64_t·val)

4044

static·inline·void·trace_gicv3_ich_eisr_read(uint32_t·cpu,·uint64_t·val)

4056

static·inline·void·_nocheck__trace_gicv3_ich_elrsr_read(uint32_t·cpu,·uint64_t·val)

4056

static·inline·void·_nocheck__trace_gicv3_ich_elrsr_read(uint32_t·cpu,·uint64_t·val)

4057

{

4057

{

4058

····if·(trace_event_get_state(TRACE_GICV3_ICH_ELRSR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4058

····if·(trace_event_get_state(TRACE_GICV3_ICH_ELRSR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4059

········if·(message_with_timestamp)·{

4059

········if·(message_with_timestamp)·{

4060

············struct·timeval·_now;

4060

············struct·timeval·_now;

4061

············gettimeofday(&_now,·NULL);

4061

············gettimeofday(&_now,·NULL);

4063

············qemu_log("%d@%zu.%06zu:gicv3_ich_elrsr_read·"·"GICv3·ICH_ELRSR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

4063

············qemu_log("%d@%zu.%06zu:gicv3_ich_elrsr_read·"·"GICv3·ICH_ELRSR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

4064

·····················qemu_get_thread_id(),

4064

·····················qemu_get_thread_id(),

4065

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4065

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4066

·····················,·cpu,·val);

4066

·····················,·cpu,·val);

4067

#line·4069·"trace/trace-hw_intc.h"

4067

#line·4069·"trace/trace-hw_intc.h"

4068

········}·else·{

4068

········}·else·{

4070

············qemu_log("gicv3_ich_elrsr_read·"·"GICv3·ICH_ELRSR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

4070

············qemu_log("gicv3_ich_elrsr_read·"·"GICv3·ICH_ELRSR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

4071

#line·4073·"trace/trace-hw_intc.h"

4071

#line·4073·"trace/trace-hw_intc.h"

4072

········}

4072

········}

4073

····}

4073

····}

4074

}

4074

}

4075

static·inline·void·trace_gicv3_ich_elrsr_read(uint32_t·cpu,·uint64_t·val)

4075

static·inline·void·trace_gicv3_ich_elrsr_read(uint32_t·cpu,·uint64_t·val)

4087

static·inline·void·_nocheck__trace_gicv3_icv_ap_read(int·grp,·int·regno,·uint32_t·cpu,·uint64_t·val)

4087

static·inline·void·_nocheck__trace_gicv3_icv_ap_read(int·grp,·int·regno,·uint32_t·cpu,·uint64_t·val)

4088

{

4088

{

4089

····if·(trace_event_get_state(TRACE_GICV3_ICV_AP_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4089

····if·(trace_event_get_state(TRACE_GICV3_ICV_AP_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4090

········if·(message_with_timestamp)·{

4090

········if·(message_with_timestamp)·{

4091

············struct·timeval·_now;

4091

············struct·timeval·_now;

4092

············gettimeofday(&_now,·NULL);

4092

············gettimeofday(&_now,·NULL);

4094

············qemu_log("%d@%zu.%06zu:gicv3_icv_ap_read·"·"GICv3·ICV_AP%dR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

4094

············qemu_log("%d@%zu.%06zu:gicv3_icv_ap_read·"·"GICv3·ICV_AP%dR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

4095

·····················qemu_get_thread_id(),

4095

·····················qemu_get_thread_id(),

4096

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4096

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4097

·····················,·grp,·regno,·cpu,·val);

4097

·····················,·grp,·regno,·cpu,·val);

4098

#line·4100·"trace/trace-hw_intc.h"

4098

#line·4100·"trace/trace-hw_intc.h"

4099

········}·else·{

4099

········}·else·{

4101

············qemu_log("gicv3_icv_ap_read·"·"GICv3·ICV_AP%dR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·regno,·cpu,·val);

4101

············qemu_log("gicv3_icv_ap_read·"·"GICv3·ICV_AP%dR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·regno,·cpu,·val);

4102

#line·4104·"trace/trace-hw_intc.h"

4102

#line·4104·"trace/trace-hw_intc.h"

4103

········}

4103

········}

4104

····}

4104

····}

4105

}

4105

}

4106

static·inline·void·trace_gicv3_icv_ap_read(int·grp,·int·regno,·uint32_t·cpu,·uint64_t·val)

4106

static·inline·void·trace_gicv3_icv_ap_read(int·grp,·int·regno,·uint32_t·cpu,·uint64_t·val)

4118

static·inline·void·_nocheck__trace_gicv3_icv_ap_write(int·grp,·int·regno,·uint32_t·cpu,·uint64_t·val)

4118

static·inline·void·_nocheck__trace_gicv3_icv_ap_write(int·grp,·int·regno,·uint32_t·cpu,·uint64_t·val)

4119

{

4119

{

4120

····if·(trace_event_get_state(TRACE_GICV3_ICV_AP_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4120

····if·(trace_event_get_state(TRACE_GICV3_ICV_AP_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4121

········if·(message_with_timestamp)·{

4121

········if·(message_with_timestamp)·{

4122

············struct·timeval·_now;

4122

············struct·timeval·_now;

4123

············gettimeofday(&_now,·NULL);

4123

············gettimeofday(&_now,·NULL);

4125

············qemu_log("%d@%zu.%06zu:gicv3_icv_ap_write·"·"GICv3·ICV_AP%dR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

4125

············qemu_log("%d@%zu.%06zu:gicv3_icv_ap_write·"·"GICv3·ICV_AP%dR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

4126

·····················qemu_get_thread_id(),

4126

·····················qemu_get_thread_id(),

4127

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4127

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4128

·····················,·grp,·regno,·cpu,·val);

4128

·····················,·grp,·regno,·cpu,·val);

4129

#line·4131·"trace/trace-hw_intc.h"

4129

#line·4131·"trace/trace-hw_intc.h"

4130

········}·else·{

4130

········}·else·{

4132

············qemu_log("gicv3_icv_ap_write·"·"GICv3·ICV_AP%dR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·regno,·cpu,·val);

4132

············qemu_log("gicv3_icv_ap_write·"·"GICv3·ICV_AP%dR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·regno,·cpu,·val);

4133

#line·4135·"trace/trace-hw_intc.h"

4133

#line·4135·"trace/trace-hw_intc.h"

4134

········}

4134

········}

4135

····}

4135

····}

4136

}

4136

}

4137

static·inline·void·trace_gicv3_icv_ap_write(int·grp,·int·regno,·uint32_t·cpu,·uint64_t·val)

4137

static·inline·void·trace_gicv3_icv_ap_write(int·grp,·int·regno,·uint32_t·cpu,·uint64_t·val)

4149

static·inline·void·_nocheck__trace_gicv3_icv_bpr_read(int·grp,·uint32_t·cpu,·uint64_t·val)

4149

static·inline·void·_nocheck__trace_gicv3_icv_bpr_read(int·grp,·uint32_t·cpu,·uint64_t·val)

4150

{

4150

{

4151

····if·(trace_event_get_state(TRACE_GICV3_ICV_BPR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4151

····if·(trace_event_get_state(TRACE_GICV3_ICV_BPR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4152

········if·(message_with_timestamp)·{

4152

········if·(message_with_timestamp)·{

4153

············struct·timeval·_now;

4153

············struct·timeval·_now;

4154

············gettimeofday(&_now,·NULL);

4154

············gettimeofday(&_now,·NULL);

4156

············qemu_log("%d@%zu.%06zu:gicv3_icv_bpr_read·"·"GICv3·ICV_BPR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

4156

············qemu_log("%d@%zu.%06zu:gicv3_icv_bpr_read·"·"GICv3·ICV_BPR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

4157

·····················qemu_get_thread_id(),

4157

·····················qemu_get_thread_id(),

4158

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4158

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4159

·····················,·grp,·cpu,·val);

4159

·····················,·grp,·cpu,·val);

4160

#line·4162·"trace/trace-hw_intc.h"

4160

#line·4162·"trace/trace-hw_intc.h"

4161

········}·else·{

4161

········}·else·{

4163

············qemu_log("gicv3_icv_bpr_read·"·"GICv3·ICV_BPR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·cpu,·val);

4163

············qemu_log("gicv3_icv_bpr_read·"·"GICv3·ICV_BPR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·cpu,·val);

4164

#line·4166·"trace/trace-hw_intc.h"

4164

#line·4166·"trace/trace-hw_intc.h"

4165

········}

4165

········}

4166

····}

4166

····}

4167

}

4167

}

4168

static·inline·void·trace_gicv3_icv_bpr_read(int·grp,·uint32_t·cpu,·uint64_t·val)

4168

static·inline·void·trace_gicv3_icv_bpr_read(int·grp,·uint32_t·cpu,·uint64_t·val)

4180

static·inline·void·_nocheck__trace_gicv3_icv_bpr_write(int·grp,·uint32_t·cpu,·uint64_t·val)

4180

static·inline·void·_nocheck__trace_gicv3_icv_bpr_write(int·grp,·uint32_t·cpu,·uint64_t·val)

4181

{

4181

{

4182

····if·(trace_event_get_state(TRACE_GICV3_ICV_BPR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4182

····if·(trace_event_get_state(TRACE_GICV3_ICV_BPR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4183

········if·(message_with_timestamp)·{

4183

········if·(message_with_timestamp)·{

4184

············struct·timeval·_now;

4184

············struct·timeval·_now;

4185

············gettimeofday(&_now,·NULL);

4185

············gettimeofday(&_now,·NULL);

4187

············qemu_log("%d@%zu.%06zu:gicv3_icv_bpr_write·"·"GICv3·ICV_BPR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

4187

············qemu_log("%d@%zu.%06zu:gicv3_icv_bpr_write·"·"GICv3·ICV_BPR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

4188

·····················qemu_get_thread_id(),

4188

·····················qemu_get_thread_id(),

4189

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4189

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4190

·····················,·grp,·cpu,·val);

4190

·····················,·grp,·cpu,·val);

4191

#line·4193·"trace/trace-hw_intc.h"

4191

#line·4193·"trace/trace-hw_intc.h"

4192

········}·else·{

4192

········}·else·{

4194

············qemu_log("gicv3_icv_bpr_write·"·"GICv3·ICV_BPR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·cpu,·val);

4194

············qemu_log("gicv3_icv_bpr_write·"·"GICv3·ICV_BPR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·cpu,·val);

4195

#line·4197·"trace/trace-hw_intc.h"

4195

#line·4197·"trace/trace-hw_intc.h"

4196

········}

4196

········}

4197

····}

4197

····}

4198

}

4198

}

4199

static·inline·void·trace_gicv3_icv_bpr_write(int·grp,·uint32_t·cpu,·uint64_t·val)

4199

static·inline·void·trace_gicv3_icv_bpr_write(int·grp,·uint32_t·cpu,·uint64_t·val)

4211

static·inline·void·_nocheck__trace_gicv3_icv_pmr_read(uint32_t·cpu,·uint64_t·val)

4211

static·inline·void·_nocheck__trace_gicv3_icv_pmr_read(uint32_t·cpu,·uint64_t·val)

4212

{

4212

{

4213

····if·(trace_event_get_state(TRACE_GICV3_ICV_PMR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4213

····if·(trace_event_get_state(TRACE_GICV3_ICV_PMR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4214

········if·(message_with_timestamp)·{

4214

········if·(message_with_timestamp)·{

4215

············struct·timeval·_now;

4215

············struct·timeval·_now;

4216

············gettimeofday(&_now,·NULL);

4216

············gettimeofday(&_now,·NULL);

4218

············qemu_log("%d@%zu.%06zu:gicv3_icv_pmr_read·"·"GICv3·ICV_PMR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

4218

············qemu_log("%d@%zu.%06zu:gicv3_icv_pmr_read·"·"GICv3·ICV_PMR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

4219

·····················qemu_get_thread_id(),

4219

·····················qemu_get_thread_id(),

4220

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4220

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4221

·····················,·cpu,·val);

4221

·····················,·cpu,·val);

4222

#line·4224·"trace/trace-hw_intc.h"

4222

#line·4224·"trace/trace-hw_intc.h"

4223

········}·else·{

4223

········}·else·{

4225

············qemu_log("gicv3_icv_pmr_read·"·"GICv3·ICV_PMR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

4225

············qemu_log("gicv3_icv_pmr_read·"·"GICv3·ICV_PMR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

4226

#line·4228·"trace/trace-hw_intc.h"

4226

#line·4228·"trace/trace-hw_intc.h"

4227

········}

4227

········}

4228

····}

4228

····}

4229

}

4229

}

4230

static·inline·void·trace_gicv3_icv_pmr_read(uint32_t·cpu,·uint64_t·val)

4230

static·inline·void·trace_gicv3_icv_pmr_read(uint32_t·cpu,·uint64_t·val)

4242

static·inline·void·_nocheck__trace_gicv3_icv_pmr_write(uint32_t·cpu,·uint64_t·val)

4242

static·inline·void·_nocheck__trace_gicv3_icv_pmr_write(uint32_t·cpu,·uint64_t·val)

4243

{

4243

{

4244

····if·(trace_event_get_state(TRACE_GICV3_ICV_PMR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4244

····if·(trace_event_get_state(TRACE_GICV3_ICV_PMR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4245

········if·(message_with_timestamp)·{

4245

········if·(message_with_timestamp)·{

4246

············struct·timeval·_now;

4246

············struct·timeval·_now;

4247

············gettimeofday(&_now,·NULL);

4247

············gettimeofday(&_now,·NULL);

4249

············qemu_log("%d@%zu.%06zu:gicv3_icv_pmr_write·"·"GICv3·ICV_PMR·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

4249

············qemu_log("%d@%zu.%06zu:gicv3_icv_pmr_write·"·"GICv3·ICV_PMR·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

4250

·····················qemu_get_thread_id(),

4250

·····················qemu_get_thread_id(),

4251

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4251

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4252

·····················,·cpu,·val);

4252

·····················,·cpu,·val);

4253

#line·4255·"trace/trace-hw_intc.h"

4253

#line·4255·"trace/trace-hw_intc.h"

4254

········}·else·{

4254

········}·else·{

4256

············qemu_log("gicv3_icv_pmr_write·"·"GICv3·ICV_PMR·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

4256

············qemu_log("gicv3_icv_pmr_write·"·"GICv3·ICV_PMR·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

4257

#line·4259·"trace/trace-hw_intc.h"

4257

#line·4259·"trace/trace-hw_intc.h"

4258

········}

4258

········}

4259

····}

4259

····}

4260

}

4260

}

4261

static·inline·void·trace_gicv3_icv_pmr_write(uint32_t·cpu,·uint64_t·val)

4261

static·inline·void·trace_gicv3_icv_pmr_write(uint32_t·cpu,·uint64_t·val)

4273

static·inline·void·_nocheck__trace_gicv3_icv_igrpen_read(int·grp,·uint32_t·cpu,·uint64_t·val)

4273

static·inline·void·_nocheck__trace_gicv3_icv_igrpen_read(int·grp,·uint32_t·cpu,·uint64_t·val)

4274

{

4274

{

4275

····if·(trace_event_get_state(TRACE_GICV3_ICV_IGRPEN_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4275

····if·(trace_event_get_state(TRACE_GICV3_ICV_IGRPEN_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4276

········if·(message_with_timestamp)·{

4276

········if·(message_with_timestamp)·{

4277

············struct·timeval·_now;

4277

············struct·timeval·_now;

4278

············gettimeofday(&_now,·NULL);

4278

············gettimeofday(&_now,·NULL);

4280

············qemu_log("%d@%zu.%06zu:gicv3_icv_igrpen_read·"·"GICv3·ICV_IGRPEN%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

4280

············qemu_log("%d@%zu.%06zu:gicv3_icv_igrpen_read·"·"GICv3·ICV_IGRPEN%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

4281

·····················qemu_get_thread_id(),

4281

·····················qemu_get_thread_id(),

4282

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4282

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4283

·····················,·grp,·cpu,·val);

4283

·····················,·grp,·cpu,·val);

4284

#line·4286·"trace/trace-hw_intc.h"

4284

#line·4286·"trace/trace-hw_intc.h"

4285

········}·else·{

4285

········}·else·{

4287

············qemu_log("gicv3_icv_igrpen_read·"·"GICv3·ICV_IGRPEN%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·cpu,·val);

4287

············qemu_log("gicv3_icv_igrpen_read·"·"GICv3·ICV_IGRPEN%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·cpu,·val);

4288

#line·4290·"trace/trace-hw_intc.h"

4288

#line·4290·"trace/trace-hw_intc.h"

4289

········}

4289

········}

4290

····}

4290

····}

4291

}

4291

}

4292

static·inline·void·trace_gicv3_icv_igrpen_read(int·grp,·uint32_t·cpu,·uint64_t·val)

4292

static·inline·void·trace_gicv3_icv_igrpen_read(int·grp,·uint32_t·cpu,·uint64_t·val)

4304

static·inline·void·_nocheck__trace_gicv3_icv_igrpen_write(int·grp,·uint32_t·cpu,·uint64_t·val)

4304

static·inline·void·_nocheck__trace_gicv3_icv_igrpen_write(int·grp,·uint32_t·cpu,·uint64_t·val)

4305

{

4305

{

4306

····if·(trace_event_get_state(TRACE_GICV3_ICV_IGRPEN_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4306

····if·(trace_event_get_state(TRACE_GICV3_ICV_IGRPEN_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4307

········if·(message_with_timestamp)·{

4307

········if·(message_with_timestamp)·{

4308

············struct·timeval·_now;

4308

············struct·timeval·_now;

4309

············gettimeofday(&_now,·NULL);

4309

············gettimeofday(&_now,·NULL);

4311

············qemu_log("%d@%zu.%06zu:gicv3_icv_igrpen_write·"·"GICv3·ICV_IGRPEN%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

4311

············qemu_log("%d@%zu.%06zu:gicv3_icv_igrpen_write·"·"GICv3·ICV_IGRPEN%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

4312

·····················qemu_get_thread_id(),

4312

·····················qemu_get_thread_id(),

4313

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4313

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4314

·····················,·grp,·cpu,·val);

4314

·····················,·grp,·cpu,·val);

4315

#line·4317·"trace/trace-hw_intc.h"

4315

#line·4317·"trace/trace-hw_intc.h"

4316

········}·else·{

4316

········}·else·{

4318

············qemu_log("gicv3_icv_igrpen_write·"·"GICv3·ICV_IGRPEN%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·cpu,·val);

4318

············qemu_log("gicv3_icv_igrpen_write·"·"GICv3·ICV_IGRPEN%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·cpu,·val);

4319

#line·4321·"trace/trace-hw_intc.h"

4319

#line·4321·"trace/trace-hw_intc.h"

4320

········}

4320

········}

4321

····}

4321

····}

4322

}

4322

}

4323

static·inline·void·trace_gicv3_icv_igrpen_write(int·grp,·uint32_t·cpu,·uint64_t·val)

4323

static·inline·void·trace_gicv3_icv_igrpen_write(int·grp,·uint32_t·cpu,·uint64_t·val)

4335

static·inline·void·_nocheck__trace_gicv3_icv_ctlr_read(uint32_t·cpu,·uint64_t·val)

4335

static·inline·void·_nocheck__trace_gicv3_icv_ctlr_read(uint32_t·cpu,·uint64_t·val)

4336

{

4336

{

4337

····if·(trace_event_get_state(TRACE_GICV3_ICV_CTLR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4337

····if·(trace_event_get_state(TRACE_GICV3_ICV_CTLR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4338

········if·(message_with_timestamp)·{

4338

········if·(message_with_timestamp)·{

4339

············struct·timeval·_now;

4339

············struct·timeval·_now;

4340

············gettimeofday(&_now,·NULL);

4340

············gettimeofday(&_now,·NULL);

4342

············qemu_log("%d@%zu.%06zu:gicv3_icv_ctlr_read·"·"GICv3·ICV_CTLR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

4342

············qemu_log("%d@%zu.%06zu:gicv3_icv_ctlr_read·"·"GICv3·ICV_CTLR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

4343

·····················qemu_get_thread_id(),

4343

·····················qemu_get_thread_id(),

4344

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4344

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4345

·····················,·cpu,·val);

4345

·····················,·cpu,·val);

4346

#line·4348·"trace/trace-hw_intc.h"

4346

#line·4348·"trace/trace-hw_intc.h"

4347

········}·else·{

4347

········}·else·{

4349

············qemu_log("gicv3_icv_ctlr_read·"·"GICv3·ICV_CTLR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

4349

············qemu_log("gicv3_icv_ctlr_read·"·"GICv3·ICV_CTLR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

4350

#line·4352·"trace/trace-hw_intc.h"

4350

#line·4352·"trace/trace-hw_intc.h"

4351

········}

4351

········}

4352

····}

4352

····}

4353

}

4353

}

4354

static·inline·void·trace_gicv3_icv_ctlr_read(uint32_t·cpu,·uint64_t·val)

4354

static·inline·void·trace_gicv3_icv_ctlr_read(uint32_t·cpu,·uint64_t·val)

4366

static·inline·void·_nocheck__trace_gicv3_icv_ctlr_write(uint32_t·cpu,·uint64_t·val)

4366

static·inline·void·_nocheck__trace_gicv3_icv_ctlr_write(uint32_t·cpu,·uint64_t·val)

4367

{

4367

{

4368

····if·(trace_event_get_state(TRACE_GICV3_ICV_CTLR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4368

····if·(trace_event_get_state(TRACE_GICV3_ICV_CTLR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4369

········if·(message_with_timestamp)·{

4369

········if·(message_with_timestamp)·{

4370

············struct·timeval·_now;

4370

············struct·timeval·_now;

4371

············gettimeofday(&_now,·NULL);

4371

············gettimeofday(&_now,·NULL);

4373

············qemu_log("%d@%zu.%06zu:gicv3_icv_ctlr_write·"·"GICv3·ICV_CTLR·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

4373

············qemu_log("%d@%zu.%06zu:gicv3_icv_ctlr_write·"·"GICv3·ICV_CTLR·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

4374

·····················qemu_get_thread_id(),

4374

·····················qemu_get_thread_id(),

4375

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4375

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4376

·····················,·cpu,·val);

4376

·····················,·cpu,·val);

4377

#line·4379·"trace/trace-hw_intc.h"

4377

#line·4379·"trace/trace-hw_intc.h"

4378

········}·else·{

4378

········}·else·{

4380

············qemu_log("gicv3_icv_ctlr_write·"·"GICv3·ICV_CTLR·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

4380

············qemu_log("gicv3_icv_ctlr_write·"·"GICv3·ICV_CTLR·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

4381

#line·4383·"trace/trace-hw_intc.h"

4381

#line·4383·"trace/trace-hw_intc.h"

4382

········}

4382

········}

4383

····}

4383

····}

4384

}

4384

}

4385

static·inline·void·trace_gicv3_icv_ctlr_write(uint32_t·cpu,·uint64_t·val)

4385

static·inline·void·trace_gicv3_icv_ctlr_write(uint32_t·cpu,·uint64_t·val)

4397

static·inline·void·_nocheck__trace_gicv3_icv_rpr_read(uint32_t·cpu,·uint64_t·val)

4397

static·inline·void·_nocheck__trace_gicv3_icv_rpr_read(uint32_t·cpu,·uint64_t·val)

4398

{

4398

{

4399

····if·(trace_event_get_state(TRACE_GICV3_ICV_RPR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4399

····if·(trace_event_get_state(TRACE_GICV3_ICV_RPR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4400

········if·(message_with_timestamp)·{

4400

········if·(message_with_timestamp)·{

4401

············struct·timeval·_now;

4401

············struct·timeval·_now;

4402

············gettimeofday(&_now,·NULL);

4402

············gettimeofday(&_now,·NULL);

4404

············qemu_log("%d@%zu.%06zu:gicv3_icv_rpr_read·"·"GICv3·ICV_RPR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

4404

············qemu_log("%d@%zu.%06zu:gicv3_icv_rpr_read·"·"GICv3·ICV_RPR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

4405

·····················qemu_get_thread_id(),

4405

·····················qemu_get_thread_id(),

4406

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4406

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4407

·····················,·cpu,·val);

4407

·····················,·cpu,·val);

4408

#line·4410·"trace/trace-hw_intc.h"

4408

#line·4410·"trace/trace-hw_intc.h"

4409

········}·else·{

4409

········}·else·{

4411

············qemu_log("gicv3_icv_rpr_read·"·"GICv3·ICV_RPR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

4411

············qemu_log("gicv3_icv_rpr_read·"·"GICv3·ICV_RPR·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

4412

#line·4414·"trace/trace-hw_intc.h"

4412

#line·4414·"trace/trace-hw_intc.h"

4413

········}

4413

········}

4414

····}

4414

····}

4415

}

4415

}

4416

static·inline·void·trace_gicv3_icv_rpr_read(uint32_t·cpu,·uint64_t·val)

4416

static·inline·void·trace_gicv3_icv_rpr_read(uint32_t·cpu,·uint64_t·val)

4428

static·inline·void·_nocheck__trace_gicv3_icv_hppir_read(int·grp,·uint32_t·cpu,·uint64_t·val)

4428

static·inline·void·_nocheck__trace_gicv3_icv_hppir_read(int·grp,·uint32_t·cpu,·uint64_t·val)

4429

{

4429

{

4430

····if·(trace_event_get_state(TRACE_GICV3_ICV_HPPIR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4430

····if·(trace_event_get_state(TRACE_GICV3_ICV_HPPIR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4431

········if·(message_with_timestamp)·{

4431

········if·(message_with_timestamp)·{

4432

············struct·timeval·_now;

4432

············struct·timeval·_now;

4433

············gettimeofday(&_now,·NULL);

4433

············gettimeofday(&_now,·NULL);

4435

············qemu_log("%d@%zu.%06zu:gicv3_icv_hppir_read·"·"GICv3·ICV_HPPIR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

4435

············qemu_log("%d@%zu.%06zu:gicv3_icv_hppir_read·"·"GICv3·ICV_HPPIR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

4436

·····················qemu_get_thread_id(),

4436

·····················qemu_get_thread_id(),

4437

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4437

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4438

·····················,·grp,·cpu,·val);

4438

·····················,·grp,·cpu,·val);

4439

#line·4441·"trace/trace-hw_intc.h"

4439

#line·4441·"trace/trace-hw_intc.h"

4440

········}·else·{

4440

········}·else·{

4442

············qemu_log("gicv3_icv_hppir_read·"·"GICv3·ICV_HPPIR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·cpu,·val);

4442

············qemu_log("gicv3_icv_hppir_read·"·"GICv3·ICV_HPPIR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·cpu,·val);

4443

#line·4445·"trace/trace-hw_intc.h"

4443

#line·4445·"trace/trace-hw_intc.h"

4444

········}

4444

········}

4445

····}

4445

····}

4446

}

4446

}

4447

static·inline·void·trace_gicv3_icv_hppir_read(int·grp,·uint32_t·cpu,·uint64_t·val)

4447

static·inline·void·trace_gicv3_icv_hppir_read(int·grp,·uint32_t·cpu,·uint64_t·val)

4459

static·inline·void·_nocheck__trace_gicv3_icv_dir_write(uint32_t·cpu,·uint64_t·val)

4459

static·inline·void·_nocheck__trace_gicv3_icv_dir_write(uint32_t·cpu,·uint64_t·val)

4460

{

4460

{

4461

····if·(trace_event_get_state(TRACE_GICV3_ICV_DIR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4461

····if·(trace_event_get_state(TRACE_GICV3_ICV_DIR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4462

········if·(message_with_timestamp)·{

4462

········if·(message_with_timestamp)·{

4463

············struct·timeval·_now;

4463

············struct·timeval·_now;

4464

············gettimeofday(&_now,·NULL);

4464

············gettimeofday(&_now,·NULL);

4466

············qemu_log("%d@%zu.%06zu:gicv3_icv_dir_write·"·"GICv3·ICV_DIR·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

4466

············qemu_log("%d@%zu.%06zu:gicv3_icv_dir_write·"·"GICv3·ICV_DIR·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

4467

·····················qemu_get_thread_id(),

4467

·····················qemu_get_thread_id(),

4468

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4468

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4469

·····················,·cpu,·val);

4469

·····················,·cpu,·val);

4470

#line·4472·"trace/trace-hw_intc.h"

4470

#line·4472·"trace/trace-hw_intc.h"

4471

········}·else·{

4471

········}·else·{

4473

············qemu_log("gicv3_icv_dir_write·"·"GICv3·ICV_DIR·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

4473

············qemu_log("gicv3_icv_dir_write·"·"GICv3·ICV_DIR·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·cpu,·val);

4474

#line·4476·"trace/trace-hw_intc.h"

4474

#line·4476·"trace/trace-hw_intc.h"

4475

········}

4475

········}

4476

····}

4476

····}

4477

}

4477

}

4478

static·inline·void·trace_gicv3_icv_dir_write(uint32_t·cpu,·uint64_t·val)

4478

static·inline·void·trace_gicv3_icv_dir_write(uint32_t·cpu,·uint64_t·val)

4490

static·inline·void·_nocheck__trace_gicv3_icv_iar_read(int·grp,·uint32_t·cpu,·uint64_t·val)

4490

static·inline·void·_nocheck__trace_gicv3_icv_iar_read(int·grp,·uint32_t·cpu,·uint64_t·val)

4491

{

4491

{

4492

····if·(trace_event_get_state(TRACE_GICV3_ICV_IAR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4492

····if·(trace_event_get_state(TRACE_GICV3_ICV_IAR_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4493

········if·(message_with_timestamp)·{

4493

········if·(message_with_timestamp)·{

4494

············struct·timeval·_now;

4494

············struct·timeval·_now;

4495

············gettimeofday(&_now,·NULL);

4495

············gettimeofday(&_now,·NULL);

4497

············qemu_log("%d@%zu.%06zu:gicv3_icv_iar_read·"·"GICv3·ICV_IAR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

4497

············qemu_log("%d@%zu.%06zu:gicv3_icv_iar_read·"·"GICv3·ICV_IAR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",

4498

·····················qemu_get_thread_id(),

4498

·····················qemu_get_thread_id(),

4499

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4499

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4500

·····················,·grp,·cpu,·val);

4500

·····················,·grp,·cpu,·val);

4501

#line·4503·"trace/trace-hw_intc.h"

4501

#line·4503·"trace/trace-hw_intc.h"

4502

········}·else·{

4502

········}·else·{

4504

············qemu_log("gicv3_icv_iar_read·"·"GICv3·ICV_IAR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·cpu,·val);

4504

············qemu_log("gicv3_icv_iar_read·"·"GICv3·ICV_IAR%d·read·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·cpu,·val);

4505

#line·4507·"trace/trace-hw_intc.h"

4505

#line·4507·"trace/trace-hw_intc.h"

4506

········}

4506

········}

4507

····}

4507

····}

4508

}

4508

}

4509

static·inline·void·trace_gicv3_icv_iar_read(int·grp,·uint32_t·cpu,·uint64_t·val)

4509

static·inline·void·trace_gicv3_icv_iar_read(int·grp,·uint32_t·cpu,·uint64_t·val)

4521

static·inline·void·_nocheck__trace_gicv3_icv_eoir_write(int·grp,·uint32_t·cpu,·uint64_t·val)

4521

static·inline·void·_nocheck__trace_gicv3_icv_eoir_write(int·grp,·uint32_t·cpu,·uint64_t·val)

4522

{

4522

{

4523

····if·(trace_event_get_state(TRACE_GICV3_ICV_EOIR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4523

····if·(trace_event_get_state(TRACE_GICV3_ICV_EOIR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4524

········if·(message_with_timestamp)·{

4524

········if·(message_with_timestamp)·{

4525

············struct·timeval·_now;

4525

············struct·timeval·_now;

4526

············gettimeofday(&_now,·NULL);

4526

············gettimeofday(&_now,·NULL);

4528

············qemu_log("%d@%zu.%06zu:gicv3_icv_eoir_write·"·"GICv3·ICV_EOIR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

4528

············qemu_log("%d@%zu.%06zu:gicv3_icv_eoir_write·"·"GICv3·ICV_EOIR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",

4529

·····················qemu_get_thread_id(),

4529

·····················qemu_get_thread_id(),

4530

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4530

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4531

·····················,·grp,·cpu,·val);

4531

·····················,·grp,·cpu,·val);

4532

#line·4534·"trace/trace-hw_intc.h"

4532

#line·4534·"trace/trace-hw_intc.h"

4533

········}·else·{

4533

········}·else·{

4535

············qemu_log("gicv3_icv_eoir_write·"·"GICv3·ICV_EOIR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·cpu,·val);

4535

············qemu_log("gicv3_icv_eoir_write·"·"GICv3·ICV_EOIR%d·write·cpu·0x%x·value·0x%"·PRIx64·"\n",·grp,·cpu,·val);

4536

#line·4538·"trace/trace-hw_intc.h"

4536

#line·4538·"trace/trace-hw_intc.h"

4537

········}

4537

········}

4538

····}

4538

····}

4539

}

4539

}

4540

static·inline·void·trace_gicv3_icv_eoir_write(int·grp,·uint32_t·cpu,·uint64_t·val)

4540

static·inline·void·trace_gicv3_icv_eoir_write(int·grp,·uint32_t·cpu,·uint64_t·val)

4552

static·inline·void·_nocheck__trace_gicv3_cpuif_virt_update(uint32_t·cpuid,·int·idx)

4552

static·inline·void·_nocheck__trace_gicv3_cpuif_virt_update(uint32_t·cpuid,·int·idx)

4553

{

4553

{

4554

····if·(trace_event_get_state(TRACE_GICV3_CPUIF_VIRT_UPDATE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4554

····if·(trace_event_get_state(TRACE_GICV3_CPUIF_VIRT_UPDATE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4555

········if·(message_with_timestamp)·{

4555

········if·(message_with_timestamp)·{

4556

············struct·timeval·_now;

4556

············struct·timeval·_now;

4557

············gettimeofday(&_now,·NULL);

4557

············gettimeofday(&_now,·NULL);

4559

············qemu_log("%d@%zu.%06zu:gicv3_cpuif_virt_update·"·"GICv3·CPU·i/f·0x%x·virt·HPPI·update·LR·index·%d"·"\n",

4559

············qemu_log("%d@%zu.%06zu:gicv3_cpuif_virt_update·"·"GICv3·CPU·i/f·0x%x·virt·HPPI·update·LR·index·%d"·"\n",

4560

·····················qemu_get_thread_id(),

4560

·····················qemu_get_thread_id(),

4561

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4561

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4562

·····················,·cpuid,·idx);

4562

·····················,·cpuid,·idx);

4563

#line·4565·"trace/trace-hw_intc.h"

4563

#line·4565·"trace/trace-hw_intc.h"

4564

········}·else·{

4564

········}·else·{

4566

············qemu_log("gicv3_cpuif_virt_update·"·"GICv3·CPU·i/f·0x%x·virt·HPPI·update·LR·index·%d"·"\n",·cpuid,·idx);

4566

············qemu_log("gicv3_cpuif_virt_update·"·"GICv3·CPU·i/f·0x%x·virt·HPPI·update·LR·index·%d"·"\n",·cpuid,·idx);

4567

#line·4569·"trace/trace-hw_intc.h"

4567

#line·4569·"trace/trace-hw_intc.h"

4568

········}

4568

········}

4569

····}

4569

····}

4570

}

4570

}

4571

static·inline·void·trace_gicv3_cpuif_virt_update(uint32_t·cpuid,·int·idx)

4571

static·inline·void·trace_gicv3_cpuif_virt_update(uint32_t·cpuid,·int·idx)

4583

static·inline·void·_nocheck__trace_gicv3_cpuif_virt_set_irqs(uint32_t·cpuid,·int·fiqlevel,·int·irqlevel,·int·maintlevel)

4583

static·inline·void·_nocheck__trace_gicv3_cpuif_virt_set_irqs(uint32_t·cpuid,·int·fiqlevel,·int·irqlevel,·int·maintlevel)

4584

{

4584

{

4585

····if·(trace_event_get_state(TRACE_GICV3_CPUIF_VIRT_SET_IRQS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4585

····if·(trace_event_get_state(TRACE_GICV3_CPUIF_VIRT_SET_IRQS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4586

········if·(message_with_timestamp)·{

4586

········if·(message_with_timestamp)·{

4587

············struct·timeval·_now;

4587

············struct·timeval·_now;

4588

············gettimeofday(&_now,·NULL);

4588

············gettimeofday(&_now,·NULL);

4590

············qemu_log("%d@%zu.%06zu:gicv3_cpuif_virt_set_irqs·"·"GICv3·CPU·i/f·0x%x·virt·HPPI·update:·setting·FIQ·%d·IRQ·%d·maintenance-irq·%d"·"\n",

4590

············qemu_log("%d@%zu.%06zu:gicv3_cpuif_virt_set_irqs·"·"GICv3·CPU·i/f·0x%x·virt·HPPI·update:·setting·FIQ·%d·IRQ·%d·maintenance-irq·%d"·"\n",

4591

·····················qemu_get_thread_id(),

4591

·····················qemu_get_thread_id(),

4592

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4592

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4593

·····················,·cpuid,·fiqlevel,·irqlevel,·maintlevel);

4593

·····················,·cpuid,·fiqlevel,·irqlevel,·maintlevel);

4594

#line·4596·"trace/trace-hw_intc.h"

4594

#line·4596·"trace/trace-hw_intc.h"

4595

········}·else·{

4595

········}·else·{

4597

············qemu_log("gicv3_cpuif_virt_set_irqs·"·"GICv3·CPU·i/f·0x%x·virt·HPPI·update:·setting·FIQ·%d·IRQ·%d·maintenance-irq·%d"·"\n",·cpuid,·fiqlevel,·irqlevel,·maintlevel);

4597

············qemu_log("gicv3_cpuif_virt_set_irqs·"·"GICv3·CPU·i/f·0x%x·virt·HPPI·update:·setting·FIQ·%d·IRQ·%d·maintenance-irq·%d"·"\n",·cpuid,·fiqlevel,·irqlevel,·maintlevel);

4598

#line·4600·"trace/trace-hw_intc.h"

4598

#line·4600·"trace/trace-hw_intc.h"

4599

········}

4599

········}

4600

····}

4600

····}

4601

}

4601

}

4602

static·inline·void·trace_gicv3_cpuif_virt_set_irqs(uint32_t·cpuid,·int·fiqlevel,·int·irqlevel,·int·maintlevel)

4602

static·inline·void·trace_gicv3_cpuif_virt_set_irqs(uint32_t·cpuid,·int·fiqlevel,·int·irqlevel,·int·maintlevel)

4614

static·inline·void·_nocheck__trace_gicv3_dist_read(uint64_t·offset,·uint64_t·data,·unsigned·size,·bool·secure)

4614

static·inline·void·_nocheck__trace_gicv3_dist_read(uint64_t·offset,·uint64_t·data,·unsigned·size,·bool·secure)

4615

{

4615

{

4616

····if·(trace_event_get_state(TRACE_GICV3_DIST_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4616

····if·(trace_event_get_state(TRACE_GICV3_DIST_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4617

········if·(message_with_timestamp)·{

4617

········if·(message_with_timestamp)·{

4618

············struct·timeval·_now;

4618

············struct·timeval·_now;

4619

············gettimeofday(&_now,·NULL);

4619

············gettimeofday(&_now,·NULL);

4621

············qemu_log("%d@%zu.%06zu:gicv3_dist_read·"·"GICv3·distributor·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u·secure·%d"·"\n",

4621

············qemu_log("%d@%zu.%06zu:gicv3_dist_read·"·"GICv3·distributor·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u·secure·%d"·"\n",

4622

·····················qemu_get_thread_id(),

4622

·····················qemu_get_thread_id(),

4623

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4623

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4624

·····················,·offset,·data,·size,·secure);

4624

·····················,·offset,·data,·size,·secure);

4625

#line·4627·"trace/trace-hw_intc.h"

4625

#line·4627·"trace/trace-hw_intc.h"

4626

········}·else·{

4626

········}·else·{

4628

············qemu_log("gicv3_dist_read·"·"GICv3·distributor·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u·secure·%d"·"\n",·offset,·data,·size,·secure);

4628

············qemu_log("gicv3_dist_read·"·"GICv3·distributor·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u·secure·%d"·"\n",·offset,·data,·size,·secure);

4629

#line·4631·"trace/trace-hw_intc.h"

4629

#line·4631·"trace/trace-hw_intc.h"

4630

········}

4630

········}

4631

····}

4631

····}

4632

}

4632

}

4633

static·inline·void·trace_gicv3_dist_read(uint64_t·offset,·uint64_t·data,·unsigned·size,·bool·secure)

4633

static·inline·void·trace_gicv3_dist_read(uint64_t·offset,·uint64_t·data,·unsigned·size,·bool·secure)

4645

static·inline·void·_nocheck__trace_gicv3_dist_badread(uint64_t·offset,·unsigned·size,·bool·secure)

4645

static·inline·void·_nocheck__trace_gicv3_dist_badread(uint64_t·offset,·unsigned·size,·bool·secure)

4646

{

4646

{

4647

····if·(trace_event_get_state(TRACE_GICV3_DIST_BADREAD)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4647

····if·(trace_event_get_state(TRACE_GICV3_DIST_BADREAD)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4648

········if·(message_with_timestamp)·{

4648

········if·(message_with_timestamp)·{

4649

············struct·timeval·_now;

4649

············struct·timeval·_now;

4650

············gettimeofday(&_now,·NULL);

4650

············gettimeofday(&_now,·NULL);

4652

············qemu_log("%d@%zu.%06zu:gicv3_dist_badread·"·"GICv3·distributor·read:·offset·0x%"·PRIx64·"·size·%u·secure·%d:·error"·"\n",

4652

············qemu_log("%d@%zu.%06zu:gicv3_dist_badread·"·"GICv3·distributor·read:·offset·0x%"·PRIx64·"·size·%u·secure·%d:·error"·"\n",

4653

·····················qemu_get_thread_id(),

4653

·····················qemu_get_thread_id(),

4654

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4654

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4655

·····················,·offset,·size,·secure);

4655

·····················,·offset,·size,·secure);

4656

#line·4658·"trace/trace-hw_intc.h"

4656

#line·4658·"trace/trace-hw_intc.h"

4657

········}·else·{

4657

········}·else·{

4659

············qemu_log("gicv3_dist_badread·"·"GICv3·distributor·read:·offset·0x%"·PRIx64·"·size·%u·secure·%d:·error"·"\n",·offset,·size,·secure);

4659

············qemu_log("gicv3_dist_badread·"·"GICv3·distributor·read:·offset·0x%"·PRIx64·"·size·%u·secure·%d:·error"·"\n",·offset,·size,·secure);

4660

#line·4662·"trace/trace-hw_intc.h"

4660

#line·4662·"trace/trace-hw_intc.h"

4661

········}

4661

········}

4662

····}

4662

····}

4663

}

4663

}

4664

static·inline·void·trace_gicv3_dist_badread(uint64_t·offset,·unsigned·size,·bool·secure)

4664

static·inline·void·trace_gicv3_dist_badread(uint64_t·offset,·unsigned·size,·bool·secure)

4676

static·inline·void·_nocheck__trace_gicv3_dist_write(uint64_t·offset,·uint64_t·data,·unsigned·size,·bool·secure)

4676

static·inline·void·_nocheck__trace_gicv3_dist_write(uint64_t·offset,·uint64_t·data,·unsigned·size,·bool·secure)

4677

{

4677

{

4678

····if·(trace_event_get_state(TRACE_GICV3_DIST_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4678

····if·(trace_event_get_state(TRACE_GICV3_DIST_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4679

········if·(message_with_timestamp)·{

4679

········if·(message_with_timestamp)·{

4680

············struct·timeval·_now;

4680

············struct·timeval·_now;

4681

············gettimeofday(&_now,·NULL);

4681

············gettimeofday(&_now,·NULL);

4683

············qemu_log("%d@%zu.%06zu:gicv3_dist_write·"·"GICv3·distributor·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u·secure·%d"·"\n",

4683

············qemu_log("%d@%zu.%06zu:gicv3_dist_write·"·"GICv3·distributor·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u·secure·%d"·"\n",

4684

·····················qemu_get_thread_id(),

4684

·····················qemu_get_thread_id(),

4685

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4685

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4686

·····················,·offset,·data,·size,·secure);

4686

·····················,·offset,·data,·size,·secure);

4687

#line·4689·"trace/trace-hw_intc.h"

4687

#line·4689·"trace/trace-hw_intc.h"

4688

········}·else·{

4688

········}·else·{

4690

············qemu_log("gicv3_dist_write·"·"GICv3·distributor·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u·secure·%d"·"\n",·offset,·data,·size,·secure);

4690

············qemu_log("gicv3_dist_write·"·"GICv3·distributor·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u·secure·%d"·"\n",·offset,·data,·size,·secure);

4691

#line·4693·"trace/trace-hw_intc.h"

4691

#line·4693·"trace/trace-hw_intc.h"

4692

········}

4692

········}

4693

····}

4693

····}

4694

}

4694

}

4695

static·inline·void·trace_gicv3_dist_write(uint64_t·offset,·uint64_t·data,·unsigned·size,·bool·secure)

4695

static·inline·void·trace_gicv3_dist_write(uint64_t·offset,·uint64_t·data,·unsigned·size,·bool·secure)

4707

static·inline·void·_nocheck__trace_gicv3_dist_badwrite(uint64_t·offset,·uint64_t·data,·unsigned·size,·bool·secure)

4707

static·inline·void·_nocheck__trace_gicv3_dist_badwrite(uint64_t·offset,·uint64_t·data,·unsigned·size,·bool·secure)

4708

{

4708

{

4709

····if·(trace_event_get_state(TRACE_GICV3_DIST_BADWRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4709

····if·(trace_event_get_state(TRACE_GICV3_DIST_BADWRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4710

········if·(message_with_timestamp)·{

4710

········if·(message_with_timestamp)·{

4711

············struct·timeval·_now;

4711

············struct·timeval·_now;

4712

············gettimeofday(&_now,·NULL);

4712

············gettimeofday(&_now,·NULL);

4714

············qemu_log("%d@%zu.%06zu:gicv3_dist_badwrite·"·"GICv3·distributor·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u·secure·%d:·error"·"\n",

4714

············qemu_log("%d@%zu.%06zu:gicv3_dist_badwrite·"·"GICv3·distributor·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u·secure·%d:·error"·"\n",

4715

·····················qemu_get_thread_id(),

4715

·····················qemu_get_thread_id(),

4716

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4716

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4717

·····················,·offset,·data,·size,·secure);

4717

·····················,·offset,·data,·size,·secure);

4718

#line·4720·"trace/trace-hw_intc.h"

4718

#line·4720·"trace/trace-hw_intc.h"

4719

········}·else·{

4719

········}·else·{

4721

············qemu_log("gicv3_dist_badwrite·"·"GICv3·distributor·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u·secure·%d:·error"·"\n",·offset,·data,·size,·secure);

4721

············qemu_log("gicv3_dist_badwrite·"·"GICv3·distributor·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u·secure·%d:·error"·"\n",·offset,·data,·size,·secure);

4722

#line·4724·"trace/trace-hw_intc.h"

4722

#line·4724·"trace/trace-hw_intc.h"

4723

········}

4723

········}

4724

····}

4724

····}

4725

}

4725

}

4726

static·inline·void·trace_gicv3_dist_badwrite(uint64_t·offset,·uint64_t·data,·unsigned·size,·bool·secure)

4726

static·inline·void·trace_gicv3_dist_badwrite(uint64_t·offset,·uint64_t·data,·unsigned·size,·bool·secure)

4738

static·inline·void·_nocheck__trace_gicv3_dist_set_irq(int·irq,·int·level)

4738

static·inline·void·_nocheck__trace_gicv3_dist_set_irq(int·irq,·int·level)

4739

{

4739

{

4740

····if·(trace_event_get_state(TRACE_GICV3_DIST_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4740

····if·(trace_event_get_state(TRACE_GICV3_DIST_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4741

········if·(message_with_timestamp)·{

4741

········if·(message_with_timestamp)·{

4742

············struct·timeval·_now;

4742

············struct·timeval·_now;

4743

············gettimeofday(&_now,·NULL);

4743

············gettimeofday(&_now,·NULL);

4745

············qemu_log("%d@%zu.%06zu:gicv3_dist_set_irq·"·"GICv3·distributor·interrupt·%d·level·changed·to·%d"·"\n",

4745

············qemu_log("%d@%zu.%06zu:gicv3_dist_set_irq·"·"GICv3·distributor·interrupt·%d·level·changed·to·%d"·"\n",

4746

·····················qemu_get_thread_id(),

4746

·····················qemu_get_thread_id(),

4747

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4747

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4748

·····················,·irq,·level);

4748

·····················,·irq,·level);

4749

#line·4751·"trace/trace-hw_intc.h"

4749

#line·4751·"trace/trace-hw_intc.h"

4750

········}·else·{

4750

········}·else·{

4752

············qemu_log("gicv3_dist_set_irq·"·"GICv3·distributor·interrupt·%d·level·changed·to·%d"·"\n",·irq,·level);

4752

············qemu_log("gicv3_dist_set_irq·"·"GICv3·distributor·interrupt·%d·level·changed·to·%d"·"\n",·irq,·level);

4753

#line·4755·"trace/trace-hw_intc.h"

4753

#line·4755·"trace/trace-hw_intc.h"

4754

········}

4754

········}

4755

····}

4755

····}

4756

}

4756

}

4757

static·inline·void·trace_gicv3_dist_set_irq(int·irq,·int·level)

4757

static·inline·void·trace_gicv3_dist_set_irq(int·irq,·int·level)

4769

static·inline·void·_nocheck__trace_gicv3_redist_read(uint32_t·cpu,·uint64_t·offset,·uint64_t·data,·unsigned·size,·bool·secure)

4769

static·inline·void·_nocheck__trace_gicv3_redist_read(uint32_t·cpu,·uint64_t·offset,·uint64_t·data,·unsigned·size,·bool·secure)

4770

{

4770

{

4771

····if·(trace_event_get_state(TRACE_GICV3_REDIST_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4771

····if·(trace_event_get_state(TRACE_GICV3_REDIST_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4772

········if·(message_with_timestamp)·{

4772

········if·(message_with_timestamp)·{

4773

············struct·timeval·_now;

4773

············struct·timeval·_now;

4774

············gettimeofday(&_now,·NULL);

4774

············gettimeofday(&_now,·NULL);

4776

············qemu_log("%d@%zu.%06zu:gicv3_redist_read·"·"GICv3·redistributor·0x%x·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u·secure·%d"·"\n",

4776

············qemu_log("%d@%zu.%06zu:gicv3_redist_read·"·"GICv3·redistributor·0x%x·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u·secure·%d"·"\n",

4777

·····················qemu_get_thread_id(),

4777

·····················qemu_get_thread_id(),

4778

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4778

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4779

·····················,·cpu,·offset,·data,·size,·secure);

4779

·····················,·cpu,·offset,·data,·size,·secure);

4780

#line·4782·"trace/trace-hw_intc.h"

4780

#line·4782·"trace/trace-hw_intc.h"

4781

········}·else·{

4781

········}·else·{

4783

············qemu_log("gicv3_redist_read·"·"GICv3·redistributor·0x%x·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u·secure·%d"·"\n",·cpu,·offset,·data,·size,·secure);

4783

············qemu_log("gicv3_redist_read·"·"GICv3·redistributor·0x%x·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u·secure·%d"·"\n",·cpu,·offset,·data,·size,·secure);

4784

#line·4786·"trace/trace-hw_intc.h"

4784

#line·4786·"trace/trace-hw_intc.h"

4785

········}

4785

········}

4786

····}

4786

····}

4787

}

4787

}

4788

static·inline·void·trace_gicv3_redist_read(uint32_t·cpu,·uint64_t·offset,·uint64_t·data,·unsigned·size,·bool·secure)

4788

static·inline·void·trace_gicv3_redist_read(uint32_t·cpu,·uint64_t·offset,·uint64_t·data,·unsigned·size,·bool·secure)

4800

static·inline·void·_nocheck__trace_gicv3_redist_badread(uint32_t·cpu,·uint64_t·offset,·unsigned·size,·bool·secure)

4800

static·inline·void·_nocheck__trace_gicv3_redist_badread(uint32_t·cpu,·uint64_t·offset,·unsigned·size,·bool·secure)

4801

{

4801

{

4802

····if·(trace_event_get_state(TRACE_GICV3_REDIST_BADREAD)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4802

····if·(trace_event_get_state(TRACE_GICV3_REDIST_BADREAD)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4803

········if·(message_with_timestamp)·{

4803

········if·(message_with_timestamp)·{

4804

············struct·timeval·_now;

4804

············struct·timeval·_now;

4805

············gettimeofday(&_now,·NULL);

4805

············gettimeofday(&_now,·NULL);

4807

············qemu_log("%d@%zu.%06zu:gicv3_redist_badread·"·"GICv3·redistributor·0x%x·read:·offset·0x%"·PRIx64·"·size·%u·secure·%d:·error"·"\n",

4807

············qemu_log("%d@%zu.%06zu:gicv3_redist_badread·"·"GICv3·redistributor·0x%x·read:·offset·0x%"·PRIx64·"·size·%u·secure·%d:·error"·"\n",

4808

·····················qemu_get_thread_id(),

4808

·····················qemu_get_thread_id(),

4809

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4809

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4810

·····················,·cpu,·offset,·size,·secure);

4810

·····················,·cpu,·offset,·size,·secure);

4811

#line·4813·"trace/trace-hw_intc.h"

4811

#line·4813·"trace/trace-hw_intc.h"

4812

········}·else·{

4812

········}·else·{

4814

············qemu_log("gicv3_redist_badread·"·"GICv3·redistributor·0x%x·read:·offset·0x%"·PRIx64·"·size·%u·secure·%d:·error"·"\n",·cpu,·offset,·size,·secure);

4814

············qemu_log("gicv3_redist_badread·"·"GICv3·redistributor·0x%x·read:·offset·0x%"·PRIx64·"·size·%u·secure·%d:·error"·"\n",·cpu,·offset,·size,·secure);

4815

#line·4817·"trace/trace-hw_intc.h"

4815

#line·4817·"trace/trace-hw_intc.h"

4816

········}

4816

········}

4817

····}

4817

····}

4818

}

4818

}

4819

static·inline·void·trace_gicv3_redist_badread(uint32_t·cpu,·uint64_t·offset,·unsigned·size,·bool·secure)

4819

static·inline·void·trace_gicv3_redist_badread(uint32_t·cpu,·uint64_t·offset,·unsigned·size,·bool·secure)

4831

static·inline·void·_nocheck__trace_gicv3_redist_write(uint32_t·cpu,·uint64_t·offset,·uint64_t·data,·unsigned·size,·bool·secure)

4831

static·inline·void·_nocheck__trace_gicv3_redist_write(uint32_t·cpu,·uint64_t·offset,·uint64_t·data,·unsigned·size,·bool·secure)

4832

{

4832

{

4833

····if·(trace_event_get_state(TRACE_GICV3_REDIST_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4833

····if·(trace_event_get_state(TRACE_GICV3_REDIST_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4834

········if·(message_with_timestamp)·{

4834

········if·(message_with_timestamp)·{

4835

············struct·timeval·_now;

4835

············struct·timeval·_now;

4836

············gettimeofday(&_now,·NULL);

4836

············gettimeofday(&_now,·NULL);

4838

············qemu_log("%d@%zu.%06zu:gicv3_redist_write·"·"GICv3·redistributor·0x%x·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u·secure·%d"·"\n",

4838

············qemu_log("%d@%zu.%06zu:gicv3_redist_write·"·"GICv3·redistributor·0x%x·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u·secure·%d"·"\n",

4839

·····················qemu_get_thread_id(),

4839

·····················qemu_get_thread_id(),

4840

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4840

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4841

·····················,·cpu,·offset,·data,·size,·secure);

4841

·····················,·cpu,·offset,·data,·size,·secure);

4842

#line·4844·"trace/trace-hw_intc.h"

4842

#line·4844·"trace/trace-hw_intc.h"

4843

········}·else·{

4843

········}·else·{

4845

············qemu_log("gicv3_redist_write·"·"GICv3·redistributor·0x%x·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u·secure·%d"·"\n",·cpu,·offset,·data,·size,·secure);

4845

············qemu_log("gicv3_redist_write·"·"GICv3·redistributor·0x%x·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u·secure·%d"·"\n",·cpu,·offset,·data,·size,·secure);

4846

#line·4848·"trace/trace-hw_intc.h"

4846

#line·4848·"trace/trace-hw_intc.h"

4847

········}

4847

········}

4848

····}

4848

····}

4849

}

4849

}

4850

static·inline·void·trace_gicv3_redist_write(uint32_t·cpu,·uint64_t·offset,·uint64_t·data,·unsigned·size,·bool·secure)

4850

static·inline·void·trace_gicv3_redist_write(uint32_t·cpu,·uint64_t·offset,·uint64_t·data,·unsigned·size,·bool·secure)

4862

static·inline·void·_nocheck__trace_gicv3_redist_badwrite(uint32_t·cpu,·uint64_t·offset,·uint64_t·data,·unsigned·size,·bool·secure)

4862

static·inline·void·_nocheck__trace_gicv3_redist_badwrite(uint32_t·cpu,·uint64_t·offset,·uint64_t·data,·unsigned·size,·bool·secure)

4863

{

4863

{

4864

····if·(trace_event_get_state(TRACE_GICV3_REDIST_BADWRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4864

····if·(trace_event_get_state(TRACE_GICV3_REDIST_BADWRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4865

········if·(message_with_timestamp)·{

4865

········if·(message_with_timestamp)·{

4866

············struct·timeval·_now;

4866

············struct·timeval·_now;

4867

············gettimeofday(&_now,·NULL);

4867

············gettimeofday(&_now,·NULL);

4869

············qemu_log("%d@%zu.%06zu:gicv3_redist_badwrite·"·"GICv3·redistributor·0x%x·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u·secure·%d:·error"·"\n",

4869

············qemu_log("%d@%zu.%06zu:gicv3_redist_badwrite·"·"GICv3·redistributor·0x%x·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u·secure·%d:·error"·"\n",

4870

·····················qemu_get_thread_id(),

4870

·····················qemu_get_thread_id(),

4871

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4871

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4872

·····················,·cpu,·offset,·data,·size,·secure);

4872

·····················,·cpu,·offset,·data,·size,·secure);

4873

#line·4875·"trace/trace-hw_intc.h"

4873

#line·4875·"trace/trace-hw_intc.h"

4874

········}·else·{

4874

········}·else·{

4876

············qemu_log("gicv3_redist_badwrite·"·"GICv3·redistributor·0x%x·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u·secure·%d:·error"·"\n",·cpu,·offset,·data,·size,·secure);

4876

············qemu_log("gicv3_redist_badwrite·"·"GICv3·redistributor·0x%x·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u·secure·%d:·error"·"\n",·cpu,·offset,·data,·size,·secure);

4877

#line·4879·"trace/trace-hw_intc.h"

4877

#line·4879·"trace/trace-hw_intc.h"

4878

········}

4878

········}

4879

····}

4879

····}

4880

}

4880

}

4881

static·inline·void·trace_gicv3_redist_badwrite(uint32_t·cpu,·uint64_t·offset,·uint64_t·data,·unsigned·size,·bool·secure)

4881

static·inline·void·trace_gicv3_redist_badwrite(uint32_t·cpu,·uint64_t·offset,·uint64_t·data,·unsigned·size,·bool·secure)

4893

static·inline·void·_nocheck__trace_gicv3_redist_set_irq(uint32_t·cpu,·int·irq,·int·level)

4893

static·inline·void·_nocheck__trace_gicv3_redist_set_irq(uint32_t·cpu,·int·irq,·int·level)

4894

{

4894

{

4895

····if·(trace_event_get_state(TRACE_GICV3_REDIST_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4895

····if·(trace_event_get_state(TRACE_GICV3_REDIST_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4896

········if·(message_with_timestamp)·{

4896

········if·(message_with_timestamp)·{

4897

············struct·timeval·_now;

4897

············struct·timeval·_now;

4898

············gettimeofday(&_now,·NULL);

4898

············gettimeofday(&_now,·NULL);

4900

············qemu_log("%d@%zu.%06zu:gicv3_redist_set_irq·"·"GICv3·redistributor·0x%x·interrupt·%d·level·changed·to·%d"·"\n",

4900

············qemu_log("%d@%zu.%06zu:gicv3_redist_set_irq·"·"GICv3·redistributor·0x%x·interrupt·%d·level·changed·to·%d"·"\n",

4901

·····················qemu_get_thread_id(),

4901

·····················qemu_get_thread_id(),

4902

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4902

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4903

·····················,·cpu,·irq,·level);

4903

·····················,·cpu,·irq,·level);

4904

#line·4906·"trace/trace-hw_intc.h"

4904

#line·4906·"trace/trace-hw_intc.h"

4905

········}·else·{

4905

········}·else·{

4907

············qemu_log("gicv3_redist_set_irq·"·"GICv3·redistributor·0x%x·interrupt·%d·level·changed·to·%d"·"\n",·cpu,·irq,·level);

4907

············qemu_log("gicv3_redist_set_irq·"·"GICv3·redistributor·0x%x·interrupt·%d·level·changed·to·%d"·"\n",·cpu,·irq,·level);

4908

#line·4910·"trace/trace-hw_intc.h"

4908

#line·4910·"trace/trace-hw_intc.h"

4909

········}

4909

········}

4910

····}

4910

····}

4911

}

4911

}

4912

static·inline·void·trace_gicv3_redist_set_irq(uint32_t·cpu,·int·irq,·int·level)

4912

static·inline·void·trace_gicv3_redist_set_irq(uint32_t·cpu,·int·irq,·int·level)

4924

static·inline·void·_nocheck__trace_gicv3_redist_send_sgi(uint32_t·cpu,·int·irq)

4924

static·inline·void·_nocheck__trace_gicv3_redist_send_sgi(uint32_t·cpu,·int·irq)

4925

{

4925

{

4926

····if·(trace_event_get_state(TRACE_GICV3_REDIST_SEND_SGI)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4926

····if·(trace_event_get_state(TRACE_GICV3_REDIST_SEND_SGI)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4927

········if·(message_with_timestamp)·{

4927

········if·(message_with_timestamp)·{

4928

············struct·timeval·_now;

4928

············struct·timeval·_now;

4929

············gettimeofday(&_now,·NULL);

4929

············gettimeofday(&_now,·NULL);

4931

············qemu_log("%d@%zu.%06zu:gicv3_redist_send_sgi·"·"GICv3·redistributor·0x%x·pending·SGI·%d"·"\n",

4931

············qemu_log("%d@%zu.%06zu:gicv3_redist_send_sgi·"·"GICv3·redistributor·0x%x·pending·SGI·%d"·"\n",

4932

·····················qemu_get_thread_id(),

4932

·····················qemu_get_thread_id(),

4933

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4933

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4934

·····················,·cpu,·irq);

4934

·····················,·cpu,·irq);

4935

#line·4937·"trace/trace-hw_intc.h"

4935

#line·4937·"trace/trace-hw_intc.h"

4936

········}·else·{

4936

········}·else·{

4938

············qemu_log("gicv3_redist_send_sgi·"·"GICv3·redistributor·0x%x·pending·SGI·%d"·"\n",·cpu,·irq);

4938

············qemu_log("gicv3_redist_send_sgi·"·"GICv3·redistributor·0x%x·pending·SGI·%d"·"\n",·cpu,·irq);

4939

#line·4941·"trace/trace-hw_intc.h"

4939

#line·4941·"trace/trace-hw_intc.h"

4940

········}

4940

········}

4941

····}

4941

····}

4942

}

4942

}

4943

static·inline·void·trace_gicv3_redist_send_sgi(uint32_t·cpu,·int·irq)

4943

static·inline·void·trace_gicv3_redist_send_sgi(uint32_t·cpu,·int·irq)

4955

static·inline·void·_nocheck__trace_nvic_recompute_state(int·vectpending,·int·vectpending_prio,·int·exception_prio)

4955

static·inline·void·_nocheck__trace_nvic_recompute_state(int·vectpending,·int·vectpending_prio,·int·exception_prio)

4956

{

4956

{

4957

····if·(trace_event_get_state(TRACE_NVIC_RECOMPUTE_STATE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4957

····if·(trace_event_get_state(TRACE_NVIC_RECOMPUTE_STATE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4958

········if·(message_with_timestamp)·{

4958

········if·(message_with_timestamp)·{

4959

············struct·timeval·_now;

4959

············struct·timeval·_now;

4960

············gettimeofday(&_now,·NULL);

4960

············gettimeofday(&_now,·NULL);

4962

············qemu_log("%d@%zu.%06zu:nvic_recompute_state·"·"NVIC·state·recomputed:·vectpending·%d·vectpending_prio·%d·exception_prio·%d"·"\n",

4962

············qemu_log("%d@%zu.%06zu:nvic_recompute_state·"·"NVIC·state·recomputed:·vectpending·%d·vectpending_prio·%d·exception_prio·%d"·"\n",

4963

·····················qemu_get_thread_id(),

4963

·····················qemu_get_thread_id(),

4964

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4964

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4965

·····················,·vectpending,·vectpending_prio,·exception_prio);

4965

·····················,·vectpending,·vectpending_prio,·exception_prio);

4966

#line·4968·"trace/trace-hw_intc.h"

4966

#line·4968·"trace/trace-hw_intc.h"

4967

········}·else·{

4967

········}·else·{

4969

············qemu_log("nvic_recompute_state·"·"NVIC·state·recomputed:·vectpending·%d·vectpending_prio·%d·exception_prio·%d"·"\n",·vectpending,·vectpending_prio,·exception_prio);

4969

············qemu_log("nvic_recompute_state·"·"NVIC·state·recomputed:·vectpending·%d·vectpending_prio·%d·exception_prio·%d"·"\n",·vectpending,·vectpending_prio,·exception_prio);

4970

#line·4972·"trace/trace-hw_intc.h"

4970

#line·4972·"trace/trace-hw_intc.h"

4971

········}

4971

········}

4972

····}

4972

····}

4973

}

4973

}

4974

static·inline·void·trace_nvic_recompute_state(int·vectpending,·int·vectpending_prio,·int·exception_prio)

4974

static·inline·void·trace_nvic_recompute_state(int·vectpending,·int·vectpending_prio,·int·exception_prio)

4986

static·inline·void·_nocheck__trace_nvic_recompute_state_secure(int·vectpending,·bool·vectpending_is_s_banked,·int·vectpending_prio,·int·exception_prio)

4986

static·inline·void·_nocheck__trace_nvic_recompute_state_secure(int·vectpending,·bool·vectpending_is_s_banked,·int·vectpending_prio,·int·exception_prio)

4987

{

4987

{

4988

····if·(trace_event_get_state(TRACE_NVIC_RECOMPUTE_STATE_SECURE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4988

····if·(trace_event_get_state(TRACE_NVIC_RECOMPUTE_STATE_SECURE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

4989

········if·(message_with_timestamp)·{

4989

········if·(message_with_timestamp)·{

4990

············struct·timeval·_now;

4990

············struct·timeval·_now;

4991

············gettimeofday(&_now,·NULL);

4991

············gettimeofday(&_now,·NULL);

4993

············qemu_log("%d@%zu.%06zu:nvic_recompute_state_secure·"·"NVIC·state·recomputed:·vectpending·%d·is_s_banked·%d·vectpending_prio·%d·exception_prio·%d"·"\n",

4993

············qemu_log("%d@%zu.%06zu:nvic_recompute_state_secure·"·"NVIC·state·recomputed:·vectpending·%d·is_s_banked·%d·vectpending_prio·%d·exception_prio·%d"·"\n",

4994

·····················qemu_get_thread_id(),

4994

·····················qemu_get_thread_id(),

4995

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4995

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

4996

·····················,·vectpending,·vectpending_is_s_banked,·vectpending_prio,·exception_prio);

4996

·····················,·vectpending,·vectpending_is_s_banked,·vectpending_prio,·exception_prio);

4997

#line·4999·"trace/trace-hw_intc.h"

4997

#line·4999·"trace/trace-hw_intc.h"

4998

········}·else·{

4998

········}·else·{

5000

············qemu_log("nvic_recompute_state_secure·"·"NVIC·state·recomputed:·vectpending·%d·is_s_banked·%d·vectpending_prio·%d·exception_prio·%d"·"\n",·vectpending,·vectpending_is_s_banked,·vectpending_prio,·exception_prio);

5000

············qemu_log("nvic_recompute_state_secure·"·"NVIC·state·recomputed:·vectpending·%d·is_s_banked·%d·vectpending_prio·%d·exception_prio·%d"·"\n",·vectpending,·vectpending_is_s_banked,·vectpending_prio,·exception_prio);

5001

#line·5003·"trace/trace-hw_intc.h"

5001

#line·5003·"trace/trace-hw_intc.h"

5002

········}

5002

········}

5003

····}

5003

····}

5004

}

5004

}

5005

static·inline·void·trace_nvic_recompute_state_secure(int·vectpending,·bool·vectpending_is_s_banked,·int·vectpending_prio,·int·exception_prio)

5005

static·inline·void·trace_nvic_recompute_state_secure(int·vectpending,·bool·vectpending_is_s_banked,·int·vectpending_prio,·int·exception_prio)

5017

static·inline·void·_nocheck__trace_nvic_set_prio(int·irq,·bool·secure,·uint8_t·prio)

5017

static·inline·void·_nocheck__trace_nvic_set_prio(int·irq,·bool·secure,·uint8_t·prio)

5018

{

5018

{

5019

····if·(trace_event_get_state(TRACE_NVIC_SET_PRIO)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5019

····if·(trace_event_get_state(TRACE_NVIC_SET_PRIO)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5020

········if·(message_with_timestamp)·{

5020

········if·(message_with_timestamp)·{

5021

············struct·timeval·_now;

5021

············struct·timeval·_now;

5022

············gettimeofday(&_now,·NULL);

5022

············gettimeofday(&_now,·NULL);

5024

············qemu_log("%d@%zu.%06zu:nvic_set_prio·"·"NVIC·set·irq·%d·secure-bank·%d·priority·%d"·"\n",

5024

············qemu_log("%d@%zu.%06zu:nvic_set_prio·"·"NVIC·set·irq·%d·secure-bank·%d·priority·%d"·"\n",

5025

·····················qemu_get_thread_id(),

5025

·····················qemu_get_thread_id(),

5026

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5026

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5027

·····················,·irq,·secure,·prio);

5027

·····················,·irq,·secure,·prio);

5028

#line·5030·"trace/trace-hw_intc.h"

5028

#line·5030·"trace/trace-hw_intc.h"

5029

········}·else·{

5029

········}·else·{

5031

············qemu_log("nvic_set_prio·"·"NVIC·set·irq·%d·secure-bank·%d·priority·%d"·"\n",·irq,·secure,·prio);

5031

············qemu_log("nvic_set_prio·"·"NVIC·set·irq·%d·secure-bank·%d·priority·%d"·"\n",·irq,·secure,·prio);

5032

#line·5034·"trace/trace-hw_intc.h"

5032

#line·5034·"trace/trace-hw_intc.h"

5033

········}

5033

········}

5034

····}

5034

····}

5035

}

5035

}

5036

static·inline·void·trace_nvic_set_prio(int·irq,·bool·secure,·uint8_t·prio)

5036

static·inline·void·trace_nvic_set_prio(int·irq,·bool·secure,·uint8_t·prio)

5048

static·inline·void·_nocheck__trace_nvic_irq_update(int·vectpending,·int·pendprio,·int·exception_prio,·int·level)

5048

static·inline·void·_nocheck__trace_nvic_irq_update(int·vectpending,·int·pendprio,·int·exception_prio,·int·level)

5049

{

5049

{

5050

····if·(trace_event_get_state(TRACE_NVIC_IRQ_UPDATE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5050

····if·(trace_event_get_state(TRACE_NVIC_IRQ_UPDATE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5051

········if·(message_with_timestamp)·{

5051

········if·(message_with_timestamp)·{

5052

············struct·timeval·_now;

5052

············struct·timeval·_now;

5053

············gettimeofday(&_now,·NULL);

5053

············gettimeofday(&_now,·NULL);

5055

············qemu_log("%d@%zu.%06zu:nvic_irq_update·"·"NVIC·vectpending·%d·pending·prio·%d·exception_prio·%d:·setting·irq·line·to·%d"·"\n",

5055

············qemu_log("%d@%zu.%06zu:nvic_irq_update·"·"NVIC·vectpending·%d·pending·prio·%d·exception_prio·%d:·setting·irq·line·to·%d"·"\n",

5056

·····················qemu_get_thread_id(),

5056

·····················qemu_get_thread_id(),

5057

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5057

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5058

·····················,·vectpending,·pendprio,·exception_prio,·level);

5058

·····················,·vectpending,·pendprio,·exception_prio,·level);

5059

#line·5061·"trace/trace-hw_intc.h"

5059

#line·5061·"trace/trace-hw_intc.h"

5060

········}·else·{

5060

········}·else·{

5062

············qemu_log("nvic_irq_update·"·"NVIC·vectpending·%d·pending·prio·%d·exception_prio·%d:·setting·irq·line·to·%d"·"\n",·vectpending,·pendprio,·exception_prio,·level);

5062

············qemu_log("nvic_irq_update·"·"NVIC·vectpending·%d·pending·prio·%d·exception_prio·%d:·setting·irq·line·to·%d"·"\n",·vectpending,·pendprio,·exception_prio,·level);

5063

#line·5065·"trace/trace-hw_intc.h"

5063

#line·5065·"trace/trace-hw_intc.h"

5064

········}

5064

········}

5065

····}

5065

····}

5066

}

5066

}

5067

static·inline·void·trace_nvic_irq_update(int·vectpending,·int·pendprio,·int·exception_prio,·int·level)

5067

static·inline·void·trace_nvic_irq_update(int·vectpending,·int·pendprio,·int·exception_prio,·int·level)

5079

static·inline·void·_nocheck__trace_nvic_escalate_prio(int·irq,·int·irqprio,·int·runprio)

5079

static·inline·void·_nocheck__trace_nvic_escalate_prio(int·irq,·int·irqprio,·int·runprio)

5080

{

5080

{

5081

····if·(trace_event_get_state(TRACE_NVIC_ESCALATE_PRIO)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5081

····if·(trace_event_get_state(TRACE_NVIC_ESCALATE_PRIO)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5082

········if·(message_with_timestamp)·{

5082

········if·(message_with_timestamp)·{

5083

············struct·timeval·_now;

5083

············struct·timeval·_now;

5084

············gettimeofday(&_now,·NULL);

5084

············gettimeofday(&_now,·NULL);

5086

············qemu_log("%d@%zu.%06zu:nvic_escalate_prio·"·"NVIC·escalating·irq·%d·to·HardFault:·insufficient·priority·%d·>=·%d"·"\n",

5086

············qemu_log("%d@%zu.%06zu:nvic_escalate_prio·"·"NVIC·escalating·irq·%d·to·HardFault:·insufficient·priority·%d·>=·%d"·"\n",

5087

·····················qemu_get_thread_id(),

5087

·····················qemu_get_thread_id(),

5088

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5088

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5089

·····················,·irq,·irqprio,·runprio);

5089

·····················,·irq,·irqprio,·runprio);

5090

#line·5092·"trace/trace-hw_intc.h"

5090

#line·5092·"trace/trace-hw_intc.h"

5091

········}·else·{

5091

········}·else·{

5093

············qemu_log("nvic_escalate_prio·"·"NVIC·escalating·irq·%d·to·HardFault:·insufficient·priority·%d·>=·%d"·"\n",·irq,·irqprio,·runprio);

5093

············qemu_log("nvic_escalate_prio·"·"NVIC·escalating·irq·%d·to·HardFault:·insufficient·priority·%d·>=·%d"·"\n",·irq,·irqprio,·runprio);

5094

#line·5096·"trace/trace-hw_intc.h"

5094

#line·5096·"trace/trace-hw_intc.h"

5095

········}

5095

········}

5096

····}

5096

····}

5097

}

5097

}

5098

static·inline·void·trace_nvic_escalate_prio(int·irq,·int·irqprio,·int·runprio)

5098

static·inline·void·trace_nvic_escalate_prio(int·irq,·int·irqprio,·int·runprio)

5110

static·inline·void·_nocheck__trace_nvic_escalate_disabled(int·irq)

5110

static·inline·void·_nocheck__trace_nvic_escalate_disabled(int·irq)

5111

{

5111

{

5112

····if·(trace_event_get_state(TRACE_NVIC_ESCALATE_DISABLED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5112

····if·(trace_event_get_state(TRACE_NVIC_ESCALATE_DISABLED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5113

········if·(message_with_timestamp)·{

5113

········if·(message_with_timestamp)·{

5114

············struct·timeval·_now;

5114

············struct·timeval·_now;

5115

············gettimeofday(&_now,·NULL);

5115

············gettimeofday(&_now,·NULL);

5117

············qemu_log("%d@%zu.%06zu:nvic_escalate_disabled·"·"NVIC·escalating·irq·%d·to·HardFault:·disabled"·"\n",

5117

············qemu_log("%d@%zu.%06zu:nvic_escalate_disabled·"·"NVIC·escalating·irq·%d·to·HardFault:·disabled"·"\n",

5118

·····················qemu_get_thread_id(),

5118

·····················qemu_get_thread_id(),

5119

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5119

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5120

·····················,·irq);

5120

·····················,·irq);

5121

#line·5123·"trace/trace-hw_intc.h"

5121

#line·5123·"trace/trace-hw_intc.h"

5122

········}·else·{

5122

········}·else·{

5124

············qemu_log("nvic_escalate_disabled·"·"NVIC·escalating·irq·%d·to·HardFault:·disabled"·"\n",·irq);

5124

············qemu_log("nvic_escalate_disabled·"·"NVIC·escalating·irq·%d·to·HardFault:·disabled"·"\n",·irq);

5125

#line·5127·"trace/trace-hw_intc.h"

5125

#line·5127·"trace/trace-hw_intc.h"

5126

········}

5126

········}

5127

····}

5127

····}

5128

}

5128

}

5129

static·inline·void·trace_nvic_escalate_disabled(int·irq)

5129

static·inline·void·trace_nvic_escalate_disabled(int·irq)

5141

static·inline·void·_nocheck__trace_nvic_set_pending(int·irq,·bool·secure,·bool·targets_secure,·bool·derived,·int·en,·int·prio)

5141

static·inline·void·_nocheck__trace_nvic_set_pending(int·irq,·bool·secure,·bool·targets_secure,·bool·derived,·int·en,·int·prio)

5142

{

5142

{

5143

····if·(trace_event_get_state(TRACE_NVIC_SET_PENDING)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5143

····if·(trace_event_get_state(TRACE_NVIC_SET_PENDING)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5144

········if·(message_with_timestamp)·{

5144

········if·(message_with_timestamp)·{

5145

············struct·timeval·_now;

5145

············struct·timeval·_now;

5146

············gettimeofday(&_now,·NULL);

5146

············gettimeofday(&_now,·NULL);

5148

············qemu_log("%d@%zu.%06zu:nvic_set_pending·"·"NVIC·set·pending·irq·%d·secure-bank·%d·targets_secure·%d·derived·%d·(enabled:·%d·priority·%d)"·"\n",

5148

············qemu_log("%d@%zu.%06zu:nvic_set_pending·"·"NVIC·set·pending·irq·%d·secure-bank·%d·targets_secure·%d·derived·%d·(enabled:·%d·priority·%d)"·"\n",

5149

·····················qemu_get_thread_id(),

5149

·····················qemu_get_thread_id(),

5150

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5150

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5151

·····················,·irq,·secure,·targets_secure,·derived,·en,·prio);

5151

·····················,·irq,·secure,·targets_secure,·derived,·en,·prio);

5152

#line·5154·"trace/trace-hw_intc.h"

5152

#line·5154·"trace/trace-hw_intc.h"

5153

········}·else·{

5153

········}·else·{

5155

············qemu_log("nvic_set_pending·"·"NVIC·set·pending·irq·%d·secure-bank·%d·targets_secure·%d·derived·%d·(enabled:·%d·priority·%d)"·"\n",·irq,·secure,·targets_secure,·derived,·en,·prio);

5155

············qemu_log("nvic_set_pending·"·"NVIC·set·pending·irq·%d·secure-bank·%d·targets_secure·%d·derived·%d·(enabled:·%d·priority·%d)"·"\n",·irq,·secure,·targets_secure,·derived,·en,·prio);

5156

#line·5158·"trace/trace-hw_intc.h"

5156

#line·5158·"trace/trace-hw_intc.h"

5157

········}

5157

········}

5158

····}

5158

····}

5159

}

5159

}

5160

static·inline·void·trace_nvic_set_pending(int·irq,·bool·secure,·bool·targets_secure,·bool·derived,·int·en,·int·prio)

5160

static·inline·void·trace_nvic_set_pending(int·irq,·bool·secure,·bool·targets_secure,·bool·derived,·int·en,·int·prio)

5172

static·inline·void·_nocheck__trace_nvic_clear_pending(int·irq,·bool·secure,·int·en,·int·prio)

5172

static·inline·void·_nocheck__trace_nvic_clear_pending(int·irq,·bool·secure,·int·en,·int·prio)

5173

{

5173

{

5174

····if·(trace_event_get_state(TRACE_NVIC_CLEAR_PENDING)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5174

····if·(trace_event_get_state(TRACE_NVIC_CLEAR_PENDING)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5175

········if·(message_with_timestamp)·{

5175

········if·(message_with_timestamp)·{

5176

············struct·timeval·_now;

5176

············struct·timeval·_now;

5177

············gettimeofday(&_now,·NULL);

5177

············gettimeofday(&_now,·NULL);

5179

············qemu_log("%d@%zu.%06zu:nvic_clear_pending·"·"NVIC·clear·pending·irq·%d·secure-bank·%d·(enabled:·%d·priority·%d)"·"\n",

5179

············qemu_log("%d@%zu.%06zu:nvic_clear_pending·"·"NVIC·clear·pending·irq·%d·secure-bank·%d·(enabled:·%d·priority·%d)"·"\n",

5180

·····················qemu_get_thread_id(),

5180

·····················qemu_get_thread_id(),

5181

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5181

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5182

·····················,·irq,·secure,·en,·prio);

5182

·····················,·irq,·secure,·en,·prio);

5183

#line·5185·"trace/trace-hw_intc.h"

5183

#line·5185·"trace/trace-hw_intc.h"

5184

········}·else·{

5184

········}·else·{

5186

············qemu_log("nvic_clear_pending·"·"NVIC·clear·pending·irq·%d·secure-bank·%d·(enabled:·%d·priority·%d)"·"\n",·irq,·secure,·en,·prio);

5186

············qemu_log("nvic_clear_pending·"·"NVIC·clear·pending·irq·%d·secure-bank·%d·(enabled:·%d·priority·%d)"·"\n",·irq,·secure,·en,·prio);

5187

#line·5189·"trace/trace-hw_intc.h"

5187

#line·5189·"trace/trace-hw_intc.h"

5188

········}

5188

········}

5189

····}

5189

····}

5190

}

5190

}

5191

static·inline·void·trace_nvic_clear_pending(int·irq,·bool·secure,·int·en,·int·prio)

5191

static·inline·void·trace_nvic_clear_pending(int·irq,·bool·secure,·int·en,·int·prio)

5203

static·inline·void·_nocheck__trace_nvic_acknowledge_irq(int·irq,·int·prio)

5203

static·inline·void·_nocheck__trace_nvic_acknowledge_irq(int·irq,·int·prio)

5204

{

5204

{

5205

····if·(trace_event_get_state(TRACE_NVIC_ACKNOWLEDGE_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5205

····if·(trace_event_get_state(TRACE_NVIC_ACKNOWLEDGE_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5206

········if·(message_with_timestamp)·{

5206

········if·(message_with_timestamp)·{

5207

············struct·timeval·_now;

5207

············struct·timeval·_now;

5208

············gettimeofday(&_now,·NULL);

5208

············gettimeofday(&_now,·NULL);

5210

············qemu_log("%d@%zu.%06zu:nvic_acknowledge_irq·"·"NVIC·acknowledge·IRQ:·%d·now·active·(prio·%d)"·"\n",

5210

············qemu_log("%d@%zu.%06zu:nvic_acknowledge_irq·"·"NVIC·acknowledge·IRQ:·%d·now·active·(prio·%d)"·"\n",

5211

·····················qemu_get_thread_id(),

5211

·····················qemu_get_thread_id(),

5212

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5212

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5213

·····················,·irq,·prio);

5213

·····················,·irq,·prio);

5214

#line·5216·"trace/trace-hw_intc.h"

5214

#line·5216·"trace/trace-hw_intc.h"

5215

········}·else·{

5215

········}·else·{

5217

············qemu_log("nvic_acknowledge_irq·"·"NVIC·acknowledge·IRQ:·%d·now·active·(prio·%d)"·"\n",·irq,·prio);

5217

············qemu_log("nvic_acknowledge_irq·"·"NVIC·acknowledge·IRQ:·%d·now·active·(prio·%d)"·"\n",·irq,·prio);

5218

#line·5220·"trace/trace-hw_intc.h"

5218

#line·5220·"trace/trace-hw_intc.h"

5219

········}

5219

········}

5220

····}

5220

····}

5221

}

5221

}

5222

static·inline·void·trace_nvic_acknowledge_irq(int·irq,·int·prio)

5222

static·inline·void·trace_nvic_acknowledge_irq(int·irq,·int·prio)

5234

static·inline·void·_nocheck__trace_nvic_get_pending_irq_info(int·irq,·bool·secure)

5234

static·inline·void·_nocheck__trace_nvic_get_pending_irq_info(int·irq,·bool·secure)

5235

{

5235

{

5236

····if·(trace_event_get_state(TRACE_NVIC_GET_PENDING_IRQ_INFO)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5236

····if·(trace_event_get_state(TRACE_NVIC_GET_PENDING_IRQ_INFO)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5237

········if·(message_with_timestamp)·{

5237

········if·(message_with_timestamp)·{

5238

············struct·timeval·_now;

5238

············struct·timeval·_now;

5239

············gettimeofday(&_now,·NULL);

5239

············gettimeofday(&_now,·NULL);

5241

············qemu_log("%d@%zu.%06zu:nvic_get_pending_irq_info·"·"NVIC·next·IRQ·%d:·targets_secure:·%d"·"\n",

5241

············qemu_log("%d@%zu.%06zu:nvic_get_pending_irq_info·"·"NVIC·next·IRQ·%d:·targets_secure:·%d"·"\n",

5242

·····················qemu_get_thread_id(),

5242

·····················qemu_get_thread_id(),

5243

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5243

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5244

·····················,·irq,·secure);

5244

·····················,·irq,·secure);

5245

#line·5247·"trace/trace-hw_intc.h"

5245

#line·5247·"trace/trace-hw_intc.h"

5246

········}·else·{

5246

········}·else·{

5248

············qemu_log("nvic_get_pending_irq_info·"·"NVIC·next·IRQ·%d:·targets_secure:·%d"·"\n",·irq,·secure);

5248

············qemu_log("nvic_get_pending_irq_info·"·"NVIC·next·IRQ·%d:·targets_secure:·%d"·"\n",·irq,·secure);

5249

#line·5251·"trace/trace-hw_intc.h"

5249

#line·5251·"trace/trace-hw_intc.h"

5250

········}

5250

········}

5251

····}

5251

····}

5252

}

5252

}

5253

static·inline·void·trace_nvic_get_pending_irq_info(int·irq,·bool·secure)

5253

static·inline·void·trace_nvic_get_pending_irq_info(int·irq,·bool·secure)

5265

static·inline·void·_nocheck__trace_nvic_complete_irq(int·irq,·bool·secure)

5265

static·inline·void·_nocheck__trace_nvic_complete_irq(int·irq,·bool·secure)

5266

{

5266

{

5267

····if·(trace_event_get_state(TRACE_NVIC_COMPLETE_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5267

····if·(trace_event_get_state(TRACE_NVIC_COMPLETE_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5268

········if·(message_with_timestamp)·{

5268

········if·(message_with_timestamp)·{

5269

············struct·timeval·_now;

5269

············struct·timeval·_now;

5270

············gettimeofday(&_now,·NULL);

5270

············gettimeofday(&_now,·NULL);

5272

············qemu_log("%d@%zu.%06zu:nvic_complete_irq·"·"NVIC·complete·IRQ·%d·(secure·%d)"·"\n",

5272

············qemu_log("%d@%zu.%06zu:nvic_complete_irq·"·"NVIC·complete·IRQ·%d·(secure·%d)"·"\n",

5273

·····················qemu_get_thread_id(),

5273

·····················qemu_get_thread_id(),

5274

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5274

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5275

·····················,·irq,·secure);

5275

·····················,·irq,·secure);

5276

#line·5278·"trace/trace-hw_intc.h"

5276

#line·5278·"trace/trace-hw_intc.h"

5277

········}·else·{

5277

········}·else·{

5279

············qemu_log("nvic_complete_irq·"·"NVIC·complete·IRQ·%d·(secure·%d)"·"\n",·irq,·secure);

5279

············qemu_log("nvic_complete_irq·"·"NVIC·complete·IRQ·%d·(secure·%d)"·"\n",·irq,·secure);

5280

#line·5282·"trace/trace-hw_intc.h"

5280

#line·5282·"trace/trace-hw_intc.h"

5281

········}

5281

········}

5282

····}

5282

····}

5283

}

5283

}

5284

static·inline·void·trace_nvic_complete_irq(int·irq,·bool·secure)

5284

static·inline·void·trace_nvic_complete_irq(int·irq,·bool·secure)

5296

static·inline·void·_nocheck__trace_nvic_set_irq_level(int·irq,·int·level)

5296

static·inline·void·_nocheck__trace_nvic_set_irq_level(int·irq,·int·level)

5297

{

5297

{

5298

····if·(trace_event_get_state(TRACE_NVIC_SET_IRQ_LEVEL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5298

····if·(trace_event_get_state(TRACE_NVIC_SET_IRQ_LEVEL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5299

········if·(message_with_timestamp)·{

5299

········if·(message_with_timestamp)·{

5300

············struct·timeval·_now;

5300

············struct·timeval·_now;

5301

············gettimeofday(&_now,·NULL);

5301

············gettimeofday(&_now,·NULL);

5303

············qemu_log("%d@%zu.%06zu:nvic_set_irq_level·"·"NVIC·external·irq·%d·level·set·to·%d"·"\n",

5303

············qemu_log("%d@%zu.%06zu:nvic_set_irq_level·"·"NVIC·external·irq·%d·level·set·to·%d"·"\n",

5304

·····················qemu_get_thread_id(),

5304

·····················qemu_get_thread_id(),

5305

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5305

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5306

·····················,·irq,·level);

5306

·····················,·irq,·level);

5307

#line·5309·"trace/trace-hw_intc.h"

5307

#line·5309·"trace/trace-hw_intc.h"

5308

········}·else·{

5308

········}·else·{

5310

············qemu_log("nvic_set_irq_level·"·"NVIC·external·irq·%d·level·set·to·%d"·"\n",·irq,·level);

5310

············qemu_log("nvic_set_irq_level·"·"NVIC·external·irq·%d·level·set·to·%d"·"\n",·irq,·level);

5311

#line·5313·"trace/trace-hw_intc.h"

5311

#line·5313·"trace/trace-hw_intc.h"

5312

········}

5312

········}

5313

····}

5313

····}

5314

}

5314

}

5315

static·inline·void·trace_nvic_set_irq_level(int·irq,·int·level)

5315

static·inline·void·trace_nvic_set_irq_level(int·irq,·int·level)

5327

static·inline·void·_nocheck__trace_nvic_set_nmi_level(int·level)

5327

static·inline·void·_nocheck__trace_nvic_set_nmi_level(int·level)

5328

{

5328

{

5329

····if·(trace_event_get_state(TRACE_NVIC_SET_NMI_LEVEL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5329

····if·(trace_event_get_state(TRACE_NVIC_SET_NMI_LEVEL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5330

········if·(message_with_timestamp)·{

5330

········if·(message_with_timestamp)·{

5331

············struct·timeval·_now;

5331

············struct·timeval·_now;

5332

············gettimeofday(&_now,·NULL);

5332

············gettimeofday(&_now,·NULL);

5334

············qemu_log("%d@%zu.%06zu:nvic_set_nmi_level·"·"NVIC·external·NMI·level·set·to·%d"·"\n",

5334

············qemu_log("%d@%zu.%06zu:nvic_set_nmi_level·"·"NVIC·external·NMI·level·set·to·%d"·"\n",

5335

·····················qemu_get_thread_id(),

5335

·····················qemu_get_thread_id(),

5336

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5336

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5337

·····················,·level);

5337

·····················,·level);

5338

#line·5340·"trace/trace-hw_intc.h"

5338

#line·5340·"trace/trace-hw_intc.h"

5339

········}·else·{

5339

········}·else·{

5341

············qemu_log("nvic_set_nmi_level·"·"NVIC·external·NMI·level·set·to·%d"·"\n",·level);

5341

············qemu_log("nvic_set_nmi_level·"·"NVIC·external·NMI·level·set·to·%d"·"\n",·level);

5342

#line·5344·"trace/trace-hw_intc.h"

5342

#line·5344·"trace/trace-hw_intc.h"

5343

········}

5343

········}

5344

····}

5344

····}

5345

}

5345

}

5346

static·inline·void·trace_nvic_set_nmi_level(int·level)

5346

static·inline·void·trace_nvic_set_nmi_level(int·level)

5358

static·inline·void·_nocheck__trace_nvic_sysreg_read(uint64_t·addr,·uint32_t·value,·unsigned·size)

5358

static·inline·void·_nocheck__trace_nvic_sysreg_read(uint64_t·addr,·uint32_t·value,·unsigned·size)

5359

{

5359

{

5360

····if·(trace_event_get_state(TRACE_NVIC_SYSREG_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5360

····if·(trace_event_get_state(TRACE_NVIC_SYSREG_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5361

········if·(message_with_timestamp)·{

5361

········if·(message_with_timestamp)·{

5362

············struct·timeval·_now;

5362

············struct·timeval·_now;

5363

············gettimeofday(&_now,·NULL);

5363

············gettimeofday(&_now,·NULL);

5365

············qemu_log("%d@%zu.%06zu:nvic_sysreg_read·"·"NVIC·sysreg·read·addr·0x%"·PRIx64·"·data·0x%"·PRIx32·"·size·%u"·"\n",

5365

············qemu_log("%d@%zu.%06zu:nvic_sysreg_read·"·"NVIC·sysreg·read·addr·0x%"·PRIx64·"·data·0x%"·PRIx32·"·size·%u"·"\n",

5366

·····················qemu_get_thread_id(),

5366

·····················qemu_get_thread_id(),

5367

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5367

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5368

·····················,·addr,·value,·size);

5368

·····················,·addr,·value,·size);

5369

#line·5371·"trace/trace-hw_intc.h"

5369

#line·5371·"trace/trace-hw_intc.h"

5370

········}·else·{

5370

········}·else·{

5372

············qemu_log("nvic_sysreg_read·"·"NVIC·sysreg·read·addr·0x%"·PRIx64·"·data·0x%"·PRIx32·"·size·%u"·"\n",·addr,·value,·size);

5372

············qemu_log("nvic_sysreg_read·"·"NVIC·sysreg·read·addr·0x%"·PRIx64·"·data·0x%"·PRIx32·"·size·%u"·"\n",·addr,·value,·size);

5373

#line·5375·"trace/trace-hw_intc.h"

5373

#line·5375·"trace/trace-hw_intc.h"

5374

········}

5374

········}

5375

····}

5375

····}

5376

}

5376

}

5377

static·inline·void·trace_nvic_sysreg_read(uint64_t·addr,·uint32_t·value,·unsigned·size)

5377

static·inline·void·trace_nvic_sysreg_read(uint64_t·addr,·uint32_t·value,·unsigned·size)

5389

static·inline·void·_nocheck__trace_nvic_sysreg_write(uint64_t·addr,·uint32_t·value,·unsigned·size)

5389

static·inline·void·_nocheck__trace_nvic_sysreg_write(uint64_t·addr,·uint32_t·value,·unsigned·size)

5390

{

5390

{

5391

····if·(trace_event_get_state(TRACE_NVIC_SYSREG_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5391

····if·(trace_event_get_state(TRACE_NVIC_SYSREG_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5392

········if·(message_with_timestamp)·{

5392

········if·(message_with_timestamp)·{

5393

············struct·timeval·_now;

5393

············struct·timeval·_now;

5394

············gettimeofday(&_now,·NULL);

5394

············gettimeofday(&_now,·NULL);

5396

············qemu_log("%d@%zu.%06zu:nvic_sysreg_write·"·"NVIC·sysreg·write·addr·0x%"·PRIx64·"·data·0x%"·PRIx32·"·size·%u"·"\n",

5396

············qemu_log("%d@%zu.%06zu:nvic_sysreg_write·"·"NVIC·sysreg·write·addr·0x%"·PRIx64·"·data·0x%"·PRIx32·"·size·%u"·"\n",

5397

·····················qemu_get_thread_id(),

5397

·····················qemu_get_thread_id(),

5398

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5398

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5399

·····················,·addr,·value,·size);

5399

·····················,·addr,·value,·size);

5400

#line·5402·"trace/trace-hw_intc.h"

5400

#line·5402·"trace/trace-hw_intc.h"

5401

········}·else·{

5401

········}·else·{

5403

············qemu_log("nvic_sysreg_write·"·"NVIC·sysreg·write·addr·0x%"·PRIx64·"·data·0x%"·PRIx32·"·size·%u"·"\n",·addr,·value,·size);

5403

············qemu_log("nvic_sysreg_write·"·"NVIC·sysreg·write·addr·0x%"·PRIx64·"·data·0x%"·PRIx32·"·size·%u"·"\n",·addr,·value,·size);

5404

#line·5406·"trace/trace-hw_intc.h"

5404

#line·5406·"trace/trace-hw_intc.h"

5405

········}

5405

········}

5406

····}

5406

····}

5407

}

5407

}

5408

static·inline·void·trace_nvic_sysreg_write(uint64_t·addr,·uint32_t·value,·unsigned·size)

5408

static·inline·void·trace_nvic_sysreg_write(uint64_t·addr,·uint32_t·value,·unsigned·size)

5420

static·inline·void·_nocheck__trace_heathrow_write(uint64_t·addr,·unsigned·int·n,·uint64_t·value)

5420

static·inline·void·_nocheck__trace_heathrow_write(uint64_t·addr,·unsigned·int·n,·uint64_t·value)

5421

{

5421

{

5422

····if·(trace_event_get_state(TRACE_HEATHROW_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5422

····if·(trace_event_get_state(TRACE_HEATHROW_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5423

········if·(message_with_timestamp)·{

5423

········if·(message_with_timestamp)·{

5424

············struct·timeval·_now;

5424

············struct·timeval·_now;

5425

············gettimeofday(&_now,·NULL);

5425

············gettimeofday(&_now,·NULL);

5427

············qemu_log("%d@%zu.%06zu:heathrow_write·"·"0x%"PRIx64"·%u:·0x%"PRIx64·"\n",

5427

············qemu_log("%d@%zu.%06zu:heathrow_write·"·"0x%"PRIx64"·%u:·0x%"PRIx64·"\n",

5428

·····················qemu_get_thread_id(),

5428

·····················qemu_get_thread_id(),

5429

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5429

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5430

·····················,·addr,·n,·value);

5430

·····················,·addr,·n,·value);

5431

#line·5433·"trace/trace-hw_intc.h"

5431

#line·5433·"trace/trace-hw_intc.h"

5432

········}·else·{

5432

········}·else·{

5434

············qemu_log("heathrow_write·"·"0x%"PRIx64"·%u:·0x%"PRIx64·"\n",·addr,·n,·value);

5434

············qemu_log("heathrow_write·"·"0x%"PRIx64"·%u:·0x%"PRIx64·"\n",·addr,·n,·value);

5435

#line·5437·"trace/trace-hw_intc.h"

5435

#line·5437·"trace/trace-hw_intc.h"

5436

········}

5436

········}

5437

····}

5437

····}

5438

}

5438

}

5439

static·inline·void·trace_heathrow_write(uint64_t·addr,·unsigned·int·n,·uint64_t·value)

5439

static·inline·void·trace_heathrow_write(uint64_t·addr,·unsigned·int·n,·uint64_t·value)

5451

static·inline·void·_nocheck__trace_heathrow_read(uint64_t·addr,·unsigned·int·n,·uint64_t·value)

5451

static·inline·void·_nocheck__trace_heathrow_read(uint64_t·addr,·unsigned·int·n,·uint64_t·value)

5452

{

5452

{

5453

····if·(trace_event_get_state(TRACE_HEATHROW_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5453

····if·(trace_event_get_state(TRACE_HEATHROW_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5454

········if·(message_with_timestamp)·{

5454

········if·(message_with_timestamp)·{

5455

············struct·timeval·_now;

5455

············struct·timeval·_now;

5456

············gettimeofday(&_now,·NULL);

5456

············gettimeofday(&_now,·NULL);

5458

············qemu_log("%d@%zu.%06zu:heathrow_read·"·"0x%"PRIx64"·%u:·0x%"PRIx64·"\n",

5458

············qemu_log("%d@%zu.%06zu:heathrow_read·"·"0x%"PRIx64"·%u:·0x%"PRIx64·"\n",

5459

·····················qemu_get_thread_id(),

5459

·····················qemu_get_thread_id(),

5460

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5460

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5461

·····················,·addr,·n,·value);

5461

·····················,·addr,·n,·value);

5462

#line·5464·"trace/trace-hw_intc.h"

5462

#line·5464·"trace/trace-hw_intc.h"

5463

········}·else·{

5463

········}·else·{

5465

············qemu_log("heathrow_read·"·"0x%"PRIx64"·%u:·0x%"PRIx64·"\n",·addr,·n,·value);

5465

············qemu_log("heathrow_read·"·"0x%"PRIx64"·%u:·0x%"PRIx64·"\n",·addr,·n,·value);

5466

#line·5468·"trace/trace-hw_intc.h"

5466

#line·5468·"trace/trace-hw_intc.h"

5467

········}

5467

········}

5468

····}

5468

····}

5469

}

5469

}

5470

static·inline·void·trace_heathrow_read(uint64_t·addr,·unsigned·int·n,·uint64_t·value)

5470

static·inline·void·trace_heathrow_read(uint64_t·addr,·unsigned·int·n,·uint64_t·value)

5482

static·inline·void·_nocheck__trace_heathrow_set_irq(int·num,·int·level)

5482

static·inline·void·_nocheck__trace_heathrow_set_irq(int·num,·int·level)

5483

{

5483

{

5484

····if·(trace_event_get_state(TRACE_HEATHROW_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5484

····if·(trace_event_get_state(TRACE_HEATHROW_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5485

········if·(message_with_timestamp)·{

5485

········if·(message_with_timestamp)·{

5486

············struct·timeval·_now;

5486

············struct·timeval·_now;

5487

············gettimeofday(&_now,·NULL);

5487

············gettimeofday(&_now,·NULL);

5489

············qemu_log("%d@%zu.%06zu:heathrow_set_irq·"·"set_irq:·num=0x%02x·level=%d"·"\n",

5489

············qemu_log("%d@%zu.%06zu:heathrow_set_irq·"·"set_irq:·num=0x%02x·level=%d"·"\n",

5490

·····················qemu_get_thread_id(),

5490

·····················qemu_get_thread_id(),

5491

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5491

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5492

·····················,·num,·level);

5492

·····················,·num,·level);

5493

#line·5495·"trace/trace-hw_intc.h"

5493

#line·5495·"trace/trace-hw_intc.h"

5494

········}·else·{

5494

········}·else·{

5496

············qemu_log("heathrow_set_irq·"·"set_irq:·num=0x%02x·level=%d"·"\n",·num,·level);

5496

············qemu_log("heathrow_set_irq·"·"set_irq:·num=0x%02x·level=%d"·"\n",·num,·level);

5497

#line·5499·"trace/trace-hw_intc.h"

5497

#line·5499·"trace/trace-hw_intc.h"

5498

········}

5498

········}

5499

····}

5499

····}

5500

}

5500

}

5501

static·inline·void·trace_heathrow_set_irq(int·num,·int·level)

5501

static·inline·void·trace_heathrow_set_irq(int·num,·int·level)

5513

static·inline·void·_nocheck__trace_bcm2835_ic_set_gpu_irq(int·irq,·int·level)

5513

static·inline·void·_nocheck__trace_bcm2835_ic_set_gpu_irq(int·irq,·int·level)

5514

{

5514

{

5515

····if·(trace_event_get_state(TRACE_BCM2835_IC_SET_GPU_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5515

····if·(trace_event_get_state(TRACE_BCM2835_IC_SET_GPU_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5516

········if·(message_with_timestamp)·{

5516

········if·(message_with_timestamp)·{

5517

············struct·timeval·_now;

5517

············struct·timeval·_now;

5518

············gettimeofday(&_now,·NULL);

5518

············gettimeofday(&_now,·NULL);

5520

············qemu_log("%d@%zu.%06zu:bcm2835_ic_set_gpu_irq·"·"GPU·irq·#%d·level·%d"·"\n",

5520

············qemu_log("%d@%zu.%06zu:bcm2835_ic_set_gpu_irq·"·"GPU·irq·#%d·level·%d"·"\n",

5521

·····················qemu_get_thread_id(),

5521

·····················qemu_get_thread_id(),

5522

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5522

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5523

·····················,·irq,·level);

5523

·····················,·irq,·level);

5524

#line·5526·"trace/trace-hw_intc.h"

5524

#line·5526·"trace/trace-hw_intc.h"

5525

········}·else·{

5525

········}·else·{

5527

············qemu_log("bcm2835_ic_set_gpu_irq·"·"GPU·irq·#%d·level·%d"·"\n",·irq,·level);

5527

············qemu_log("bcm2835_ic_set_gpu_irq·"·"GPU·irq·#%d·level·%d"·"\n",·irq,·level);

5528

#line·5530·"trace/trace-hw_intc.h"

5528

#line·5530·"trace/trace-hw_intc.h"

5529

········}

5529

········}

5530

····}

5530

····}

5531

}

5531

}

5532

static·inline·void·trace_bcm2835_ic_set_gpu_irq(int·irq,·int·level)

5532

static·inline·void·trace_bcm2835_ic_set_gpu_irq(int·irq,·int·level)

5544

static·inline·void·_nocheck__trace_bcm2835_ic_set_cpu_irq(int·irq,·int·level)

5544

static·inline·void·_nocheck__trace_bcm2835_ic_set_cpu_irq(int·irq,·int·level)

5545

{

5545

{

5546

····if·(trace_event_get_state(TRACE_BCM2835_IC_SET_CPU_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5546

····if·(trace_event_get_state(TRACE_BCM2835_IC_SET_CPU_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5547

········if·(message_with_timestamp)·{

5547

········if·(message_with_timestamp)·{

5548

············struct·timeval·_now;

5548

············struct·timeval·_now;

5549

············gettimeofday(&_now,·NULL);

5549

············gettimeofday(&_now,·NULL);

5551

············qemu_log("%d@%zu.%06zu:bcm2835_ic_set_cpu_irq·"·"CPU·irq·#%d·level·%d"·"\n",

5551

············qemu_log("%d@%zu.%06zu:bcm2835_ic_set_cpu_irq·"·"CPU·irq·#%d·level·%d"·"\n",

5552

·····················qemu_get_thread_id(),

5552

·····················qemu_get_thread_id(),

5553

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5553

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5554

·····················,·irq,·level);

5554

·····················,·irq,·level);

5555

#line·5557·"trace/trace-hw_intc.h"

5555

#line·5557·"trace/trace-hw_intc.h"

5556

········}·else·{

5556

········}·else·{

5558

············qemu_log("bcm2835_ic_set_cpu_irq·"·"CPU·irq·#%d·level·%d"·"\n",·irq,·level);

5558

············qemu_log("bcm2835_ic_set_cpu_irq·"·"CPU·irq·#%d·level·%d"·"\n",·irq,·level);

5559

#line·5561·"trace/trace-hw_intc.h"

5559

#line·5561·"trace/trace-hw_intc.h"

5560

········}

5560

········}

5561

····}

5561

····}

5562

}

5562

}

5563

static·inline·void·trace_bcm2835_ic_set_cpu_irq(int·irq,·int·level)

5563

static·inline·void·trace_bcm2835_ic_set_cpu_irq(int·irq,·int·level)

5575

static·inline·void·_nocheck__trace_spapr_xive_claim_irq(uint32_t·lisn,·bool·lsi)

5575

static·inline·void·_nocheck__trace_spapr_xive_claim_irq(uint32_t·lisn,·bool·lsi)

5576

{

5576

{

5577

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_CLAIM_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5577

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_CLAIM_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5578

········if·(message_with_timestamp)·{

5578

········if·(message_with_timestamp)·{

5579

············struct·timeval·_now;

5579

············struct·timeval·_now;

5580

············gettimeofday(&_now,·NULL);

5580

············gettimeofday(&_now,·NULL);

5582

············qemu_log("%d@%zu.%06zu:spapr_xive_claim_irq·"·"lisn=0x%x·lsi=%d"·"\n",

5582

············qemu_log("%d@%zu.%06zu:spapr_xive_claim_irq·"·"lisn=0x%x·lsi=%d"·"\n",

5583

·····················qemu_get_thread_id(),

5583

·····················qemu_get_thread_id(),

5584

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5584

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5585

·····················,·lisn,·lsi);

5585

·····················,·lisn,·lsi);

5586

#line·5588·"trace/trace-hw_intc.h"

5586

#line·5588·"trace/trace-hw_intc.h"

5587

········}·else·{

5587

········}·else·{

5589

············qemu_log("spapr_xive_claim_irq·"·"lisn=0x%x·lsi=%d"·"\n",·lisn,·lsi);

5589

············qemu_log("spapr_xive_claim_irq·"·"lisn=0x%x·lsi=%d"·"\n",·lisn,·lsi);

5590

#line·5592·"trace/trace-hw_intc.h"

5590

#line·5592·"trace/trace-hw_intc.h"

5591

········}

5591

········}

5592

····}

5592

····}

5593

}

5593

}

5594

static·inline·void·trace_spapr_xive_claim_irq(uint32_t·lisn,·bool·lsi)

5594

static·inline·void·trace_spapr_xive_claim_irq(uint32_t·lisn,·bool·lsi)

5606

static·inline·void·_nocheck__trace_spapr_xive_free_irq(uint32_t·lisn)

5606

static·inline·void·_nocheck__trace_spapr_xive_free_irq(uint32_t·lisn)

5607

{

5607

{

5608

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_FREE_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5608

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_FREE_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5609

········if·(message_with_timestamp)·{

5609

········if·(message_with_timestamp)·{

5610

············struct·timeval·_now;

5610

············struct·timeval·_now;

5611

············gettimeofday(&_now,·NULL);

5611

············gettimeofday(&_now,·NULL);

5613

············qemu_log("%d@%zu.%06zu:spapr_xive_free_irq·"·"lisn=0x%x"·"\n",

5613

············qemu_log("%d@%zu.%06zu:spapr_xive_free_irq·"·"lisn=0x%x"·"\n",

5614

·····················qemu_get_thread_id(),

5614

·····················qemu_get_thread_id(),

5615

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5615

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5616

·····················,·lisn);

5616

·····················,·lisn);

5617

#line·5619·"trace/trace-hw_intc.h"

5617

#line·5619·"trace/trace-hw_intc.h"

5618

········}·else·{

5618

········}·else·{

5620

············qemu_log("spapr_xive_free_irq·"·"lisn=0x%x"·"\n",·lisn);

5620

············qemu_log("spapr_xive_free_irq·"·"lisn=0x%x"·"\n",·lisn);

5621

#line·5623·"trace/trace-hw_intc.h"

5621

#line·5623·"trace/trace-hw_intc.h"

5622

········}

5622

········}

5623

····}

5623

····}

5624

}

5624

}

5625

static·inline·void·trace_spapr_xive_free_irq(uint32_t·lisn)

5625

static·inline·void·trace_spapr_xive_free_irq(uint32_t·lisn)

5637

static·inline·void·_nocheck__trace_spapr_xive_set_irq(uint32_t·lisn,·uint32_t·val)

5637

static·inline·void·_nocheck__trace_spapr_xive_set_irq(uint32_t·lisn,·uint32_t·val)

5638

{

5638

{

5639

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5639

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5640

········if·(message_with_timestamp)·{

5640

········if·(message_with_timestamp)·{

5641

············struct·timeval·_now;

5641

············struct·timeval·_now;

5642

············gettimeofday(&_now,·NULL);

5642

············gettimeofday(&_now,·NULL);

5644

············qemu_log("%d@%zu.%06zu:spapr_xive_set_irq·"·"lisn=0x%x·val=%d"·"\n",

5644

············qemu_log("%d@%zu.%06zu:spapr_xive_set_irq·"·"lisn=0x%x·val=%d"·"\n",

5645

·····················qemu_get_thread_id(),

5645

·····················qemu_get_thread_id(),

5646

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5646

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5647

·····················,·lisn,·val);

5647

·····················,·lisn,·val);

5648

#line·5650·"trace/trace-hw_intc.h"

5648

#line·5650·"trace/trace-hw_intc.h"

5649

········}·else·{

5649

········}·else·{

5651

············qemu_log("spapr_xive_set_irq·"·"lisn=0x%x·val=%d"·"\n",·lisn,·val);

5651

············qemu_log("spapr_xive_set_irq·"·"lisn=0x%x·val=%d"·"\n",·lisn,·val);

5652

#line·5654·"trace/trace-hw_intc.h"

5652

#line·5654·"trace/trace-hw_intc.h"

5653

········}

5653

········}

5654

····}

5654

····}

5655

}

5655

}

5656

static·inline·void·trace_spapr_xive_set_irq(uint32_t·lisn,·uint32_t·val)

5656

static·inline·void·trace_spapr_xive_set_irq(uint32_t·lisn,·uint32_t·val)

5668

static·inline·void·_nocheck__trace_spapr_xive_get_source_info(uint64_t·flags,·uint64_t·lisn)

5668

static·inline·void·_nocheck__trace_spapr_xive_get_source_info(uint64_t·flags,·uint64_t·lisn)

5669

{

5669

{

5670

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_GET_SOURCE_INFO)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5670

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_GET_SOURCE_INFO)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5671

········if·(message_with_timestamp)·{

5671

········if·(message_with_timestamp)·{

5672

············struct·timeval·_now;

5672

············struct·timeval·_now;

5673

············gettimeofday(&_now,·NULL);

5673

············gettimeofday(&_now,·NULL);

5675

············qemu_log("%d@%zu.%06zu:spapr_xive_get_source_info·"·"flags=0x%"PRIx64"·lisn=0x%"PRIx64·"\n",

5675

············qemu_log("%d@%zu.%06zu:spapr_xive_get_source_info·"·"flags=0x%"PRIx64"·lisn=0x%"PRIx64·"\n",

5676

·····················qemu_get_thread_id(),

5676

·····················qemu_get_thread_id(),

5677

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5677

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5678

·····················,·flags,·lisn);

5678

·····················,·flags,·lisn);

5679

#line·5681·"trace/trace-hw_intc.h"

5679

#line·5681·"trace/trace-hw_intc.h"

5680

········}·else·{

5680

········}·else·{

5682

············qemu_log("spapr_xive_get_source_info·"·"flags=0x%"PRIx64"·lisn=0x%"PRIx64·"\n",·flags,·lisn);

5682

············qemu_log("spapr_xive_get_source_info·"·"flags=0x%"PRIx64"·lisn=0x%"PRIx64·"\n",·flags,·lisn);

5683

#line·5685·"trace/trace-hw_intc.h"

5683

#line·5685·"trace/trace-hw_intc.h"

5684

········}

5684

········}

5685

····}

5685

····}

5686

}

5686

}

5687

static·inline·void·trace_spapr_xive_get_source_info(uint64_t·flags,·uint64_t·lisn)

5687

static·inline·void·trace_spapr_xive_get_source_info(uint64_t·flags,·uint64_t·lisn)

5699

static·inline·void·_nocheck__trace_spapr_xive_set_source_config(uint64_t·flags,·uint64_t·lisn,·uint64_t·target,·uint64_t·priority,·uint64_t·eisn)

5699

static·inline·void·_nocheck__trace_spapr_xive_set_source_config(uint64_t·flags,·uint64_t·lisn,·uint64_t·target,·uint64_t·priority,·uint64_t·eisn)

5700

{

5700

{

5701

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_SET_SOURCE_CONFIG)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5701

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_SET_SOURCE_CONFIG)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5702

········if·(message_with_timestamp)·{

5702

········if·(message_with_timestamp)·{

5703

············struct·timeval·_now;

5703

············struct·timeval·_now;

5704

············gettimeofday(&_now,·NULL);

5704

············gettimeofday(&_now,·NULL);

5706

············qemu_log("%d@%zu.%06zu:spapr_xive_set_source_config·"·"flags=0x%"PRIx64"·lisn=0x%"PRIx64"·target=0x%"PRIx64"·priority=0x%"PRIx64"·eisn=0x%"PRIx64·"\n",

5706

············qemu_log("%d@%zu.%06zu:spapr_xive_set_source_config·"·"flags=0x%"PRIx64"·lisn=0x%"PRIx64"·target=0x%"PRIx64"·priority=0x%"PRIx64"·eisn=0x%"PRIx64·"\n",

5707

·····················qemu_get_thread_id(),

5707

·····················qemu_get_thread_id(),

5708

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5708

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5709

·····················,·flags,·lisn,·target,·priority,·eisn);

5709

·····················,·flags,·lisn,·target,·priority,·eisn);

5710

#line·5712·"trace/trace-hw_intc.h"

5710

#line·5712·"trace/trace-hw_intc.h"

5711

········}·else·{

5711

········}·else·{

5713

············qemu_log("spapr_xive_set_source_config·"·"flags=0x%"PRIx64"·lisn=0x%"PRIx64"·target=0x%"PRIx64"·priority=0x%"PRIx64"·eisn=0x%"PRIx64·"\n",·flags,·lisn,·target,·priority,·eisn);

5713

············qemu_log("spapr_xive_set_source_config·"·"flags=0x%"PRIx64"·lisn=0x%"PRIx64"·target=0x%"PRIx64"·priority=0x%"PRIx64"·eisn=0x%"PRIx64·"\n",·flags,·lisn,·target,·priority,·eisn);

5714

#line·5716·"trace/trace-hw_intc.h"

5714

#line·5716·"trace/trace-hw_intc.h"

5715

········}

5715

········}

5716

····}

5716

····}

5717

}

5717

}

5718

static·inline·void·trace_spapr_xive_set_source_config(uint64_t·flags,·uint64_t·lisn,·uint64_t·target,·uint64_t·priority,·uint64_t·eisn)

5718

static·inline·void·trace_spapr_xive_set_source_config(uint64_t·flags,·uint64_t·lisn,·uint64_t·target,·uint64_t·priority,·uint64_t·eisn)

5730

static·inline·void·_nocheck__trace_spapr_xive_get_source_config(uint64_t·flags,·uint64_t·lisn)

5730

static·inline·void·_nocheck__trace_spapr_xive_get_source_config(uint64_t·flags,·uint64_t·lisn)

5731

{

5731

{

5732

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_GET_SOURCE_CONFIG)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5732

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_GET_SOURCE_CONFIG)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5733

········if·(message_with_timestamp)·{

5733

········if·(message_with_timestamp)·{

5734

············struct·timeval·_now;

5734

············struct·timeval·_now;

5735

············gettimeofday(&_now,·NULL);

5735

············gettimeofday(&_now,·NULL);

5737

············qemu_log("%d@%zu.%06zu:spapr_xive_get_source_config·"·"flags=0x%"PRIx64"·lisn=0x%"PRIx64·"\n",

5737

············qemu_log("%d@%zu.%06zu:spapr_xive_get_source_config·"·"flags=0x%"PRIx64"·lisn=0x%"PRIx64·"\n",

5738

·····················qemu_get_thread_id(),

5738

·····················qemu_get_thread_id(),

5739

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5739

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5740

·····················,·flags,·lisn);

5740

·····················,·flags,·lisn);

5741

#line·5743·"trace/trace-hw_intc.h"

5741

#line·5743·"trace/trace-hw_intc.h"

5742

········}·else·{

5742

········}·else·{

5744

············qemu_log("spapr_xive_get_source_config·"·"flags=0x%"PRIx64"·lisn=0x%"PRIx64·"\n",·flags,·lisn);

5744

············qemu_log("spapr_xive_get_source_config·"·"flags=0x%"PRIx64"·lisn=0x%"PRIx64·"\n",·flags,·lisn);

5745

#line·5747·"trace/trace-hw_intc.h"

5745

#line·5747·"trace/trace-hw_intc.h"

5746

········}

5746

········}

5747

····}

5747

····}

5748

}

5748

}

5749

static·inline·void·trace_spapr_xive_get_source_config(uint64_t·flags,·uint64_t·lisn)

5749

static·inline·void·trace_spapr_xive_get_source_config(uint64_t·flags,·uint64_t·lisn)

5761

static·inline·void·_nocheck__trace_spapr_xive_get_queue_info(uint64_t·flags,·uint64_t·target,·uint64_t·priority)

5761

static·inline·void·_nocheck__trace_spapr_xive_get_queue_info(uint64_t·flags,·uint64_t·target,·uint64_t·priority)

5762

{

5762

{

5763

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_GET_QUEUE_INFO)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5763

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_GET_QUEUE_INFO)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5764

········if·(message_with_timestamp)·{

5764

········if·(message_with_timestamp)·{

5765

············struct·timeval·_now;

5765

············struct·timeval·_now;

5766

············gettimeofday(&_now,·NULL);

5766

············gettimeofday(&_now,·NULL);

5768

············qemu_log("%d@%zu.%06zu:spapr_xive_get_queue_info·"·"flags=0x%"PRIx64"·target=0x%"PRIx64"·priority=0x%"PRIx64·"\n",

5768

············qemu_log("%d@%zu.%06zu:spapr_xive_get_queue_info·"·"flags=0x%"PRIx64"·target=0x%"PRIx64"·priority=0x%"PRIx64·"\n",

5769

·····················qemu_get_thread_id(),

5769

·····················qemu_get_thread_id(),

5770

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5770

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5771

·····················,·flags,·target,·priority);

5771

·····················,·flags,·target,·priority);

5772

#line·5774·"trace/trace-hw_intc.h"

5772

#line·5774·"trace/trace-hw_intc.h"

5773

········}·else·{

5773

········}·else·{

5775

············qemu_log("spapr_xive_get_queue_info·"·"flags=0x%"PRIx64"·target=0x%"PRIx64"·priority=0x%"PRIx64·"\n",·flags,·target,·priority);

5775

············qemu_log("spapr_xive_get_queue_info·"·"flags=0x%"PRIx64"·target=0x%"PRIx64"·priority=0x%"PRIx64·"\n",·flags,·target,·priority);

5776

#line·5778·"trace/trace-hw_intc.h"

5776

#line·5778·"trace/trace-hw_intc.h"

5777

········}

5777

········}

5778

····}

5778

····}

5779

}

5779

}

5780

static·inline·void·trace_spapr_xive_get_queue_info(uint64_t·flags,·uint64_t·target,·uint64_t·priority)

5780

static·inline·void·trace_spapr_xive_get_queue_info(uint64_t·flags,·uint64_t·target,·uint64_t·priority)

5792

static·inline·void·_nocheck__trace_spapr_xive_set_queue_config(uint64_t·flags,·uint64_t·target,·uint64_t·priority,·uint64_t·qpage,·uint64_t·qsize)

5792

static·inline·void·_nocheck__trace_spapr_xive_set_queue_config(uint64_t·flags,·uint64_t·target,·uint64_t·priority,·uint64_t·qpage,·uint64_t·qsize)

5793

{

5793

{

5794

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_SET_QUEUE_CONFIG)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5794

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_SET_QUEUE_CONFIG)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5795

········if·(message_with_timestamp)·{

5795

········if·(message_with_timestamp)·{

5796

············struct·timeval·_now;

5796

············struct·timeval·_now;

5797

············gettimeofday(&_now,·NULL);

5797

············gettimeofday(&_now,·NULL);

5799

············qemu_log("%d@%zu.%06zu:spapr_xive_set_queue_config·"·"flags=0x%"PRIx64"·target=0x%"PRIx64"·priority=0x%"PRIx64"·qpage=0x%"PRIx64"·qsize=0x%"PRIx64·"\n",

5799

············qemu_log("%d@%zu.%06zu:spapr_xive_set_queue_config·"·"flags=0x%"PRIx64"·target=0x%"PRIx64"·priority=0x%"PRIx64"·qpage=0x%"PRIx64"·qsize=0x%"PRIx64·"\n",

5800

·····················qemu_get_thread_id(),

5800

·····················qemu_get_thread_id(),

5801

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5801

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5802

·····················,·flags,·target,·priority,·qpage,·qsize);

5802

·····················,·flags,·target,·priority,·qpage,·qsize);

5803

#line·5805·"trace/trace-hw_intc.h"

5803

#line·5805·"trace/trace-hw_intc.h"

5804

········}·else·{

5804

········}·else·{

5806

············qemu_log("spapr_xive_set_queue_config·"·"flags=0x%"PRIx64"·target=0x%"PRIx64"·priority=0x%"PRIx64"·qpage=0x%"PRIx64"·qsize=0x%"PRIx64·"\n",·flags,·target,·priority,·qpage,·qsize);

5806

············qemu_log("spapr_xive_set_queue_config·"·"flags=0x%"PRIx64"·target=0x%"PRIx64"·priority=0x%"PRIx64"·qpage=0x%"PRIx64"·qsize=0x%"PRIx64·"\n",·flags,·target,·priority,·qpage,·qsize);

5807

#line·5809·"trace/trace-hw_intc.h"

5807

#line·5809·"trace/trace-hw_intc.h"

5808

········}

5808

········}

5809

····}

5809

····}

5810

}

5810

}

5811

static·inline·void·trace_spapr_xive_set_queue_config(uint64_t·flags,·uint64_t·target,·uint64_t·priority,·uint64_t·qpage,·uint64_t·qsize)

5811

static·inline·void·trace_spapr_xive_set_queue_config(uint64_t·flags,·uint64_t·target,·uint64_t·priority,·uint64_t·qpage,·uint64_t·qsize)

5823

static·inline·void·_nocheck__trace_spapr_xive_get_queue_config(uint64_t·flags,·uint64_t·target,·uint64_t·priority)

5823

static·inline·void·_nocheck__trace_spapr_xive_get_queue_config(uint64_t·flags,·uint64_t·target,·uint64_t·priority)

5824

{

5824

{

5825

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_GET_QUEUE_CONFIG)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5825

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_GET_QUEUE_CONFIG)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5826

········if·(message_with_timestamp)·{

5826

········if·(message_with_timestamp)·{

5827

············struct·timeval·_now;

5827

············struct·timeval·_now;

5828

············gettimeofday(&_now,·NULL);

5828

············gettimeofday(&_now,·NULL);

5830

············qemu_log("%d@%zu.%06zu:spapr_xive_get_queue_config·"·"flags=0x%"PRIx64"·target=0x%"PRIx64"·priority=0x%"PRIx64·"\n",

5830

············qemu_log("%d@%zu.%06zu:spapr_xive_get_queue_config·"·"flags=0x%"PRIx64"·target=0x%"PRIx64"·priority=0x%"PRIx64·"\n",

5831

·····················qemu_get_thread_id(),

5831

·····················qemu_get_thread_id(),

5832

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5832

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5833

·····················,·flags,·target,·priority);

5833

·····················,·flags,·target,·priority);

5834

#line·5836·"trace/trace-hw_intc.h"

5834

#line·5836·"trace/trace-hw_intc.h"

5835

········}·else·{

5835

········}·else·{

5837

············qemu_log("spapr_xive_get_queue_config·"·"flags=0x%"PRIx64"·target=0x%"PRIx64"·priority=0x%"PRIx64·"\n",·flags,·target,·priority);

5837

············qemu_log("spapr_xive_get_queue_config·"·"flags=0x%"PRIx64"·target=0x%"PRIx64"·priority=0x%"PRIx64·"\n",·flags,·target,·priority);

5838

#line·5840·"trace/trace-hw_intc.h"

5838

#line·5840·"trace/trace-hw_intc.h"

5839

········}

5839

········}

5840

····}

5840

····}

5841

}

5841

}

5842

static·inline·void·trace_spapr_xive_get_queue_config(uint64_t·flags,·uint64_t·target,·uint64_t·priority)

5842

static·inline·void·trace_spapr_xive_get_queue_config(uint64_t·flags,·uint64_t·target,·uint64_t·priority)

5854

static·inline·void·_nocheck__trace_spapr_xive_set_os_reporting_line(uint64_t·flags)

5854

static·inline·void·_nocheck__trace_spapr_xive_set_os_reporting_line(uint64_t·flags)

5855

{

5855

{

5856

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_SET_OS_REPORTING_LINE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5856

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_SET_OS_REPORTING_LINE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5857

········if·(message_with_timestamp)·{

5857

········if·(message_with_timestamp)·{

5858

············struct·timeval·_now;

5858

············struct·timeval·_now;

5859

············gettimeofday(&_now,·NULL);

5859

············gettimeofday(&_now,·NULL);

5861

············qemu_log("%d@%zu.%06zu:spapr_xive_set_os_reporting_line·"·"flags=0x%"PRIx64·"\n",

5861

············qemu_log("%d@%zu.%06zu:spapr_xive_set_os_reporting_line·"·"flags=0x%"PRIx64·"\n",

5862

·····················qemu_get_thread_id(),

5862

·····················qemu_get_thread_id(),

5863

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5863

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5864

·····················,·flags);

5864

·····················,·flags);

5865

#line·5867·"trace/trace-hw_intc.h"

5865

#line·5867·"trace/trace-hw_intc.h"

5866

········}·else·{

5866

········}·else·{

5868

············qemu_log("spapr_xive_set_os_reporting_line·"·"flags=0x%"PRIx64·"\n",·flags);

5868

············qemu_log("spapr_xive_set_os_reporting_line·"·"flags=0x%"PRIx64·"\n",·flags);

5869

#line·5871·"trace/trace-hw_intc.h"

5869

#line·5871·"trace/trace-hw_intc.h"

5870

········}

5870

········}

5871

····}

5871

····}

5872

}

5872

}

5873

static·inline·void·trace_spapr_xive_set_os_reporting_line(uint64_t·flags)

5873

static·inline·void·trace_spapr_xive_set_os_reporting_line(uint64_t·flags)

5885

static·inline·void·_nocheck__trace_spapr_xive_get_os_reporting_line(uint64_t·flags)

5885

static·inline·void·_nocheck__trace_spapr_xive_get_os_reporting_line(uint64_t·flags)

5886

{

5886

{

5887

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_GET_OS_REPORTING_LINE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5887

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_GET_OS_REPORTING_LINE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5888

········if·(message_with_timestamp)·{

5888

········if·(message_with_timestamp)·{

5889

············struct·timeval·_now;

5889

············struct·timeval·_now;

5890

············gettimeofday(&_now,·NULL);

5890

············gettimeofday(&_now,·NULL);

5892

············qemu_log("%d@%zu.%06zu:spapr_xive_get_os_reporting_line·"·"flags=0x%"PRIx64·"\n",

5892

············qemu_log("%d@%zu.%06zu:spapr_xive_get_os_reporting_line·"·"flags=0x%"PRIx64·"\n",

5893

·····················qemu_get_thread_id(),

5893

·····················qemu_get_thread_id(),

5894

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5894

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5895

·····················,·flags);

5895

·····················,·flags);

5896

#line·5898·"trace/trace-hw_intc.h"

5896

#line·5898·"trace/trace-hw_intc.h"

5897

········}·else·{

5897

········}·else·{

5899

············qemu_log("spapr_xive_get_os_reporting_line·"·"flags=0x%"PRIx64·"\n",·flags);

5899

············qemu_log("spapr_xive_get_os_reporting_line·"·"flags=0x%"PRIx64·"\n",·flags);

5900

#line·5902·"trace/trace-hw_intc.h"

5900

#line·5902·"trace/trace-hw_intc.h"

5901

········}

5901

········}

5902

····}

5902

····}

5903

}

5903

}

5904

static·inline·void·trace_spapr_xive_get_os_reporting_line(uint64_t·flags)

5904

static·inline·void·trace_spapr_xive_get_os_reporting_line(uint64_t·flags)

5916

static·inline·void·_nocheck__trace_spapr_xive_esb(uint64_t·flags,·uint64_t·lisn,·uint64_t·offset,·uint64_t·data)

5916

static·inline·void·_nocheck__trace_spapr_xive_esb(uint64_t·flags,·uint64_t·lisn,·uint64_t·offset,·uint64_t·data)

5917

{

5917

{

5918

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_ESB)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5918

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_ESB)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5919

········if·(message_with_timestamp)·{

5919

········if·(message_with_timestamp)·{

5920

············struct·timeval·_now;

5920

············struct·timeval·_now;

5921

············gettimeofday(&_now,·NULL);

5921

············gettimeofday(&_now,·NULL);

5923

············qemu_log("%d@%zu.%06zu:spapr_xive_esb·"·"flags=0x%"PRIx64"·lisn=0x%"PRIx64"·offset=0x%"PRIx64"·data=0x%"PRIx64·"\n",

5923

············qemu_log("%d@%zu.%06zu:spapr_xive_esb·"·"flags=0x%"PRIx64"·lisn=0x%"PRIx64"·offset=0x%"PRIx64"·data=0x%"PRIx64·"\n",

5924

·····················qemu_get_thread_id(),

5924

·····················qemu_get_thread_id(),

5925

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5925

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5926

·····················,·flags,·lisn,·offset,·data);

5926

·····················,·flags,·lisn,·offset,·data);

5927

#line·5929·"trace/trace-hw_intc.h"

5927

#line·5929·"trace/trace-hw_intc.h"

5928

········}·else·{

5928

········}·else·{

5930

············qemu_log("spapr_xive_esb·"·"flags=0x%"PRIx64"·lisn=0x%"PRIx64"·offset=0x%"PRIx64"·data=0x%"PRIx64·"\n",·flags,·lisn,·offset,·data);

5930

············qemu_log("spapr_xive_esb·"·"flags=0x%"PRIx64"·lisn=0x%"PRIx64"·offset=0x%"PRIx64"·data=0x%"PRIx64·"\n",·flags,·lisn,·offset,·data);

5931

#line·5933·"trace/trace-hw_intc.h"

5931

#line·5933·"trace/trace-hw_intc.h"

5932

········}

5932

········}

5933

····}

5933

····}

5934

}

5934

}

5935

static·inline·void·trace_spapr_xive_esb(uint64_t·flags,·uint64_t·lisn,·uint64_t·offset,·uint64_t·data)

5935

static·inline·void·trace_spapr_xive_esb(uint64_t·flags,·uint64_t·lisn,·uint64_t·offset,·uint64_t·data)

5947

static·inline·void·_nocheck__trace_spapr_xive_sync(uint64_t·flags,·uint64_t·lisn)

5947

static·inline·void·_nocheck__trace_spapr_xive_sync(uint64_t·flags,·uint64_t·lisn)

5948

{

5948

{

5949

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_SYNC)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5949

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_SYNC)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5950

········if·(message_with_timestamp)·{

5950

········if·(message_with_timestamp)·{

5951

············struct·timeval·_now;

5951

············struct·timeval·_now;

5952

············gettimeofday(&_now,·NULL);

5952

············gettimeofday(&_now,·NULL);

5954

············qemu_log("%d@%zu.%06zu:spapr_xive_sync·"·"flags=0x%"PRIx64"·lisn=0x%"PRIx64·"\n",

5954

············qemu_log("%d@%zu.%06zu:spapr_xive_sync·"·"flags=0x%"PRIx64"·lisn=0x%"PRIx64·"\n",

5955

·····················qemu_get_thread_id(),

5955

·····················qemu_get_thread_id(),

5956

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5956

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5957

·····················,·flags,·lisn);

5957

·····················,·flags,·lisn);

5958

#line·5960·"trace/trace-hw_intc.h"

5958

#line·5960·"trace/trace-hw_intc.h"

5959

········}·else·{

5959

········}·else·{

5961

············qemu_log("spapr_xive_sync·"·"flags=0x%"PRIx64"·lisn=0x%"PRIx64·"\n",·flags,·lisn);

5961

············qemu_log("spapr_xive_sync·"·"flags=0x%"PRIx64"·lisn=0x%"PRIx64·"\n",·flags,·lisn);

5962

#line·5964·"trace/trace-hw_intc.h"

5962

#line·5964·"trace/trace-hw_intc.h"

5963

········}

5963

········}

5964

····}

5964

····}

5965

}

5965

}

5966

static·inline·void·trace_spapr_xive_sync(uint64_t·flags,·uint64_t·lisn)

5966

static·inline·void·trace_spapr_xive_sync(uint64_t·flags,·uint64_t·lisn)

5978

static·inline·void·_nocheck__trace_spapr_xive_reset(uint64_t·flags)

5978

static·inline·void·_nocheck__trace_spapr_xive_reset(uint64_t·flags)

5979

{

5979

{

5980

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5980

····if·(trace_event_get_state(TRACE_SPAPR_XIVE_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

5981

········if·(message_with_timestamp)·{

5981

········if·(message_with_timestamp)·{

5982

············struct·timeval·_now;

5982

············struct·timeval·_now;

5983

············gettimeofday(&_now,·NULL);

5983

············gettimeofday(&_now,·NULL);

5985

············qemu_log("%d@%zu.%06zu:spapr_xive_reset·"·"flags=0x%"PRIx64·"\n",

5985

············qemu_log("%d@%zu.%06zu:spapr_xive_reset·"·"flags=0x%"PRIx64·"\n",

5986

·····················qemu_get_thread_id(),

5986

·····················qemu_get_thread_id(),

5987

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5987

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

5988

·····················,·flags);

5988

·····················,·flags);

5989

#line·5991·"trace/trace-hw_intc.h"

5989

#line·5991·"trace/trace-hw_intc.h"

5990

········}·else·{

5990

········}·else·{

5992

············qemu_log("spapr_xive_reset·"·"flags=0x%"PRIx64·"\n",·flags);

5992

············qemu_log("spapr_xive_reset·"·"flags=0x%"PRIx64·"\n",·flags);

5993

#line·5995·"trace/trace-hw_intc.h"

5993

#line·5995·"trace/trace-hw_intc.h"

5994

········}

5994

········}

5995

····}

5995

····}

5996

}

5996

}

5997

static·inline·void·trace_spapr_xive_reset(uint64_t·flags)

5997

static·inline·void·trace_spapr_xive_reset(uint64_t·flags)

6009

static·inline·void·_nocheck__trace_kvm_xive_cpu_connect(uint32_t·id)

6009

static·inline·void·_nocheck__trace_kvm_xive_cpu_connect(uint32_t·id)

6010

{

6010

{

6011

····if·(trace_event_get_state(TRACE_KVM_XIVE_CPU_CONNECT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6011

····if·(trace_event_get_state(TRACE_KVM_XIVE_CPU_CONNECT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6012

········if·(message_with_timestamp)·{

6012

········if·(message_with_timestamp)·{

6013

············struct·timeval·_now;

6013

············struct·timeval·_now;

6014

············gettimeofday(&_now,·NULL);

6014

············gettimeofday(&_now,·NULL);

6016

············qemu_log("%d@%zu.%06zu:kvm_xive_cpu_connect·"·"connect·CPU%d·to·KVM·device"·"\n",

6016

············qemu_log("%d@%zu.%06zu:kvm_xive_cpu_connect·"·"connect·CPU%d·to·KVM·device"·"\n",

6017

·····················qemu_get_thread_id(),

6017

·····················qemu_get_thread_id(),

6018

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6018

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6019

·····················,·id);

6019

·····················,·id);

6020

#line·6022·"trace/trace-hw_intc.h"

6020

#line·6022·"trace/trace-hw_intc.h"

6021

········}·else·{

6021

········}·else·{

6023

············qemu_log("kvm_xive_cpu_connect·"·"connect·CPU%d·to·KVM·device"·"\n",·id);

6023

············qemu_log("kvm_xive_cpu_connect·"·"connect·CPU%d·to·KVM·device"·"\n",·id);

6024

#line·6026·"trace/trace-hw_intc.h"

6024

#line·6026·"trace/trace-hw_intc.h"

6025

········}

6025

········}

6026

····}

6026

····}

6027

}

6027

}

6028

static·inline·void·trace_kvm_xive_cpu_connect(uint32_t·id)

6028

static·inline·void·trace_kvm_xive_cpu_connect(uint32_t·id)

6040

static·inline·void·_nocheck__trace_kvm_xive_source_reset(uint32_t·srcno)

6040

static·inline·void·_nocheck__trace_kvm_xive_source_reset(uint32_t·srcno)

6041

{

6041

{

6042

····if·(trace_event_get_state(TRACE_KVM_XIVE_SOURCE_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6042

····if·(trace_event_get_state(TRACE_KVM_XIVE_SOURCE_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6043

········if·(message_with_timestamp)·{

6043

········if·(message_with_timestamp)·{

6044

············struct·timeval·_now;

6044

············struct·timeval·_now;

6045

············gettimeofday(&_now,·NULL);

6045

············gettimeofday(&_now,·NULL);

6047

············qemu_log("%d@%zu.%06zu:kvm_xive_source_reset·"·"IRQ·0x%x"·"\n",

6047

············qemu_log("%d@%zu.%06zu:kvm_xive_source_reset·"·"IRQ·0x%x"·"\n",

6048

·····················qemu_get_thread_id(),

6048

·····················qemu_get_thread_id(),

6049

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6049

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6050

·····················,·srcno);

6050

·····················,·srcno);

6051

#line·6053·"trace/trace-hw_intc.h"

6051

#line·6053·"trace/trace-hw_intc.h"

6052

········}·else·{

6052

········}·else·{

6054

············qemu_log("kvm_xive_source_reset·"·"IRQ·0x%x"·"\n",·srcno);

6054

············qemu_log("kvm_xive_source_reset·"·"IRQ·0x%x"·"\n",·srcno);

6055

#line·6057·"trace/trace-hw_intc.h"

6055

#line·6057·"trace/trace-hw_intc.h"

6056

········}

6056

········}

6057

····}

6057

····}

6058

}

6058

}

6059

static·inline·void·trace_kvm_xive_source_reset(uint32_t·srcno)

6059

static·inline·void·trace_kvm_xive_source_reset(uint32_t·srcno)

6071

static·inline·void·_nocheck__trace_xive_tctx_accept(uint32_t·index,·uint8_t·ring,·uint8_t·ipb,·uint8_t·pipr,·uint8_t·cppr,·uint8_t·nsr)

6071

static·inline·void·_nocheck__trace_xive_tctx_accept(uint32_t·index,·uint8_t·ring,·uint8_t·ipb,·uint8_t·pipr,·uint8_t·cppr,·uint8_t·nsr)

6072

{

6072

{

6073

····if·(trace_event_get_state(TRACE_XIVE_TCTX_ACCEPT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6073

····if·(trace_event_get_state(TRACE_XIVE_TCTX_ACCEPT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6074

········if·(message_with_timestamp)·{

6074

········if·(message_with_timestamp)·{

6075

············struct·timeval·_now;

6075

············struct·timeval·_now;

6076

············gettimeofday(&_now,·NULL);

6076

············gettimeofday(&_now,·NULL);

6078

············qemu_log("%d@%zu.%06zu:xive_tctx_accept·"·"target=%d·ring=0x%x·IBP=0x%02x·PIPR=0x%02x·CPPR=0x%02x·NSR=0x%02x·ACK"·"\n",

6078

············qemu_log("%d@%zu.%06zu:xive_tctx_accept·"·"target=%d·ring=0x%x·IBP=0x%02x·PIPR=0x%02x·CPPR=0x%02x·NSR=0x%02x·ACK"·"\n",

6079

·····················qemu_get_thread_id(),

6079

·····················qemu_get_thread_id(),

6080

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6080

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6081

·····················,·index,·ring,·ipb,·pipr,·cppr,·nsr);

6081

·····················,·index,·ring,·ipb,·pipr,·cppr,·nsr);

6082

#line·6084·"trace/trace-hw_intc.h"

6082

#line·6084·"trace/trace-hw_intc.h"

6083

········}·else·{

6083

········}·else·{

6085

············qemu_log("xive_tctx_accept·"·"target=%d·ring=0x%x·IBP=0x%02x·PIPR=0x%02x·CPPR=0x%02x·NSR=0x%02x·ACK"·"\n",·index,·ring,·ipb,·pipr,·cppr,·nsr);

6085

············qemu_log("xive_tctx_accept·"·"target=%d·ring=0x%x·IBP=0x%02x·PIPR=0x%02x·CPPR=0x%02x·NSR=0x%02x·ACK"·"\n",·index,·ring,·ipb,·pipr,·cppr,·nsr);

6086

#line·6088·"trace/trace-hw_intc.h"

6086

#line·6088·"trace/trace-hw_intc.h"

6087

········}

6087

········}

6088

····}

6088

····}

6089

}

6089

}

6090

static·inline·void·trace_xive_tctx_accept(uint32_t·index,·uint8_t·ring,·uint8_t·ipb,·uint8_t·pipr,·uint8_t·cppr,·uint8_t·nsr)

6090

static·inline·void·trace_xive_tctx_accept(uint32_t·index,·uint8_t·ring,·uint8_t·ipb,·uint8_t·pipr,·uint8_t·cppr,·uint8_t·nsr)

6102

static·inline·void·_nocheck__trace_xive_tctx_notify(uint32_t·index,·uint8_t·ring,·uint8_t·ipb,·uint8_t·pipr,·uint8_t·cppr,·uint8_t·nsr)

6102

static·inline·void·_nocheck__trace_xive_tctx_notify(uint32_t·index,·uint8_t·ring,·uint8_t·ipb,·uint8_t·pipr,·uint8_t·cppr,·uint8_t·nsr)

6103

{

6103

{

6104

····if·(trace_event_get_state(TRACE_XIVE_TCTX_NOTIFY)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6104

····if·(trace_event_get_state(TRACE_XIVE_TCTX_NOTIFY)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6105

········if·(message_with_timestamp)·{

6105

········if·(message_with_timestamp)·{

6106

············struct·timeval·_now;

6106

············struct·timeval·_now;

6107

············gettimeofday(&_now,·NULL);

6107

············gettimeofday(&_now,·NULL);

6109

············qemu_log("%d@%zu.%06zu:xive_tctx_notify·"·"target=%d·ring=0x%x·IBP=0x%02x·PIPR=0x%02x·CPPR=0x%02x·NSR=0x%02x·raise·!"·"\n",

6109

············qemu_log("%d@%zu.%06zu:xive_tctx_notify·"·"target=%d·ring=0x%x·IBP=0x%02x·PIPR=0x%02x·CPPR=0x%02x·NSR=0x%02x·raise·!"·"\n",

6110

·····················qemu_get_thread_id(),

6110

·····················qemu_get_thread_id(),

6111

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6111

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6112

·····················,·index,·ring,·ipb,·pipr,·cppr,·nsr);

6112

·····················,·index,·ring,·ipb,·pipr,·cppr,·nsr);

6113

#line·6115·"trace/trace-hw_intc.h"

6113

#line·6115·"trace/trace-hw_intc.h"

6114

········}·else·{

6114

········}·else·{

6116

············qemu_log("xive_tctx_notify·"·"target=%d·ring=0x%x·IBP=0x%02x·PIPR=0x%02x·CPPR=0x%02x·NSR=0x%02x·raise·!"·"\n",·index,·ring,·ipb,·pipr,·cppr,·nsr);

6116

············qemu_log("xive_tctx_notify·"·"target=%d·ring=0x%x·IBP=0x%02x·PIPR=0x%02x·CPPR=0x%02x·NSR=0x%02x·raise·!"·"\n",·index,·ring,·ipb,·pipr,·cppr,·nsr);

6117

#line·6119·"trace/trace-hw_intc.h"

6117

#line·6119·"trace/trace-hw_intc.h"

6118

········}

6118

········}

6119

····}

6119

····}

6120

}

6120

}

6121

static·inline·void·trace_xive_tctx_notify(uint32_t·index,·uint8_t·ring,·uint8_t·ipb,·uint8_t·pipr,·uint8_t·cppr,·uint8_t·nsr)

6121

static·inline·void·trace_xive_tctx_notify(uint32_t·index,·uint8_t·ring,·uint8_t·ipb,·uint8_t·pipr,·uint8_t·cppr,·uint8_t·nsr)

6133

static·inline·void·_nocheck__trace_xive_tctx_set_cppr(uint32_t·index,·uint8_t·ring,·uint8_t·ipb,·uint8_t·pipr,·uint8_t·cppr,·uint8_t·nsr)

6133

static·inline·void·_nocheck__trace_xive_tctx_set_cppr(uint32_t·index,·uint8_t·ring,·uint8_t·ipb,·uint8_t·pipr,·uint8_t·cppr,·uint8_t·nsr)

6134

{

6134

{

6135

····if·(trace_event_get_state(TRACE_XIVE_TCTX_SET_CPPR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6135

····if·(trace_event_get_state(TRACE_XIVE_TCTX_SET_CPPR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6136

········if·(message_with_timestamp)·{

6136

········if·(message_with_timestamp)·{

6137

············struct·timeval·_now;

6137

············struct·timeval·_now;

6138

············gettimeofday(&_now,·NULL);

6138

············gettimeofday(&_now,·NULL);

6140

············qemu_log("%d@%zu.%06zu:xive_tctx_set_cppr·"·"target=%d·ring=0x%x·IBP=0x%02x·PIPR=0x%02x·new·CPPR=0x%02x·NSR=0x%02x"·"\n",

6140

············qemu_log("%d@%zu.%06zu:xive_tctx_set_cppr·"·"target=%d·ring=0x%x·IBP=0x%02x·PIPR=0x%02x·new·CPPR=0x%02x·NSR=0x%02x"·"\n",

6141

·····················qemu_get_thread_id(),

6141

·····················qemu_get_thread_id(),

6142

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6142

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6143

·····················,·index,·ring,·ipb,·pipr,·cppr,·nsr);

6143

·····················,·index,·ring,·ipb,·pipr,·cppr,·nsr);

6144

#line·6146·"trace/trace-hw_intc.h"

6144

#line·6146·"trace/trace-hw_intc.h"

6145

········}·else·{

6145

········}·else·{

6147

············qemu_log("xive_tctx_set_cppr·"·"target=%d·ring=0x%x·IBP=0x%02x·PIPR=0x%02x·new·CPPR=0x%02x·NSR=0x%02x"·"\n",·index,·ring,·ipb,·pipr,·cppr,·nsr);

6147

············qemu_log("xive_tctx_set_cppr·"·"target=%d·ring=0x%x·IBP=0x%02x·PIPR=0x%02x·new·CPPR=0x%02x·NSR=0x%02x"·"\n",·index,·ring,·ipb,·pipr,·cppr,·nsr);

6148

#line·6150·"trace/trace-hw_intc.h"

6148

#line·6150·"trace/trace-hw_intc.h"

6149

········}

6149

········}

6150

····}

6150

····}

6151

}

6151

}

6152

static·inline·void·trace_xive_tctx_set_cppr(uint32_t·index,·uint8_t·ring,·uint8_t·ipb,·uint8_t·pipr,·uint8_t·cppr,·uint8_t·nsr)

6152

static·inline·void·trace_xive_tctx_set_cppr(uint32_t·index,·uint8_t·ring,·uint8_t·ipb,·uint8_t·pipr,·uint8_t·cppr,·uint8_t·nsr)

6164

static·inline·void·_nocheck__trace_xive_source_esb_read(uint64_t·addr,·uint32_t·srcno,·uint64_t·value)

6164

static·inline·void·_nocheck__trace_xive_source_esb_read(uint64_t·addr,·uint32_t·srcno,·uint64_t·value)

6165

{

6165

{

6166

····if·(trace_event_get_state(TRACE_XIVE_SOURCE_ESB_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6166

····if·(trace_event_get_state(TRACE_XIVE_SOURCE_ESB_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6167

········if·(message_with_timestamp)·{

6167

········if·(message_with_timestamp)·{

6168

············struct·timeval·_now;

6168

············struct·timeval·_now;

6169

············gettimeofday(&_now,·NULL);

6169

············gettimeofday(&_now,·NULL);

6171

············qemu_log("%d@%zu.%06zu:xive_source_esb_read·"·"@0x%"PRIx64"·IRQ·0x%x·val=0x%"PRIx64·"\n",

6171

············qemu_log("%d@%zu.%06zu:xive_source_esb_read·"·"@0x%"PRIx64"·IRQ·0x%x·val=0x%"PRIx64·"\n",

6172

·····················qemu_get_thread_id(),

6172

·····················qemu_get_thread_id(),

6173

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6173

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6174

·····················,·addr,·srcno,·value);

6174

·····················,·addr,·srcno,·value);

6175

#line·6177·"trace/trace-hw_intc.h"

6175

#line·6177·"trace/trace-hw_intc.h"

6176

········}·else·{

6176

········}·else·{

6178

············qemu_log("xive_source_esb_read·"·"@0x%"PRIx64"·IRQ·0x%x·val=0x%"PRIx64·"\n",·addr,·srcno,·value);

6178

············qemu_log("xive_source_esb_read·"·"@0x%"PRIx64"·IRQ·0x%x·val=0x%"PRIx64·"\n",·addr,·srcno,·value);

6179

#line·6181·"trace/trace-hw_intc.h"

6179

#line·6181·"trace/trace-hw_intc.h"

6180

········}

6180

········}

6181

····}

6181

····}

6182

}

6182

}

6183

static·inline·void·trace_xive_source_esb_read(uint64_t·addr,·uint32_t·srcno,·uint64_t·value)

6183

static·inline·void·trace_xive_source_esb_read(uint64_t·addr,·uint32_t·srcno,·uint64_t·value)

6195

static·inline·void·_nocheck__trace_xive_source_esb_write(uint64_t·addr,·uint32_t·srcno,·uint64_t·value)

6195

static·inline·void·_nocheck__trace_xive_source_esb_write(uint64_t·addr,·uint32_t·srcno,·uint64_t·value)

6196

{

6196

{

6197

····if·(trace_event_get_state(TRACE_XIVE_SOURCE_ESB_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6197

····if·(trace_event_get_state(TRACE_XIVE_SOURCE_ESB_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6198

········if·(message_with_timestamp)·{

6198

········if·(message_with_timestamp)·{

6199

············struct·timeval·_now;

6199

············struct·timeval·_now;

6200

············gettimeofday(&_now,·NULL);

6200

············gettimeofday(&_now,·NULL);

6202

············qemu_log("%d@%zu.%06zu:xive_source_esb_write·"·"@0x%"PRIx64"·IRQ·0x%x·val=0x%"PRIx64·"\n",

6202

············qemu_log("%d@%zu.%06zu:xive_source_esb_write·"·"@0x%"PRIx64"·IRQ·0x%x·val=0x%"PRIx64·"\n",

6203

·····················qemu_get_thread_id(),

6203

·····················qemu_get_thread_id(),

6204

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6204

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6205

·····················,·addr,·srcno,·value);

6205

·····················,·addr,·srcno,·value);

6206

#line·6208·"trace/trace-hw_intc.h"

6206

#line·6208·"trace/trace-hw_intc.h"

6207

········}·else·{

6207

········}·else·{

6209

············qemu_log("xive_source_esb_write·"·"@0x%"PRIx64"·IRQ·0x%x·val=0x%"PRIx64·"\n",·addr,·srcno,·value);

6209

············qemu_log("xive_source_esb_write·"·"@0x%"PRIx64"·IRQ·0x%x·val=0x%"PRIx64·"\n",·addr,·srcno,·value);

6210

#line·6212·"trace/trace-hw_intc.h"

6210

#line·6212·"trace/trace-hw_intc.h"

6211

········}

6211

········}

6212

····}

6212

····}

6213

}

6213

}

6214

static·inline·void·trace_xive_source_esb_write(uint64_t·addr,·uint32_t·srcno,·uint64_t·value)

6214

static·inline·void·trace_xive_source_esb_write(uint64_t·addr,·uint32_t·srcno,·uint64_t·value)

6226

static·inline·void·_nocheck__trace_xive_router_end_notify(uint8_t·end_blk,·uint32_t·end_idx,·uint32_t·end_data)

6226

static·inline·void·_nocheck__trace_xive_router_end_notify(uint8_t·end_blk,·uint32_t·end_idx,·uint32_t·end_data)

6227

{

6227

{

6228

····if·(trace_event_get_state(TRACE_XIVE_ROUTER_END_NOTIFY)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6228

····if·(trace_event_get_state(TRACE_XIVE_ROUTER_END_NOTIFY)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6229

········if·(message_with_timestamp)·{

6229

········if·(message_with_timestamp)·{

6230

············struct·timeval·_now;

6230

············struct·timeval·_now;

6231

············gettimeofday(&_now,·NULL);

6231

············gettimeofday(&_now,·NULL);

6233

············qemu_log("%d@%zu.%06zu:xive_router_end_notify·"·"END·0x%02x/0x%04x·->·enqueue·0x%08x"·"\n",

6233

············qemu_log("%d@%zu.%06zu:xive_router_end_notify·"·"END·0x%02x/0x%04x·->·enqueue·0x%08x"·"\n",

6234

·····················qemu_get_thread_id(),

6234

·····················qemu_get_thread_id(),

6235

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6235

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6236

·····················,·end_blk,·end_idx,·end_data);

6236

·····················,·end_blk,·end_idx,·end_data);

6237

#line·6239·"trace/trace-hw_intc.h"

6237

#line·6239·"trace/trace-hw_intc.h"

6238

········}·else·{

6238

········}·else·{

6240

············qemu_log("xive_router_end_notify·"·"END·0x%02x/0x%04x·->·enqueue·0x%08x"·"\n",·end_blk,·end_idx,·end_data);

6240

············qemu_log("xive_router_end_notify·"·"END·0x%02x/0x%04x·->·enqueue·0x%08x"·"\n",·end_blk,·end_idx,·end_data);

6241

#line·6243·"trace/trace-hw_intc.h"

6241

#line·6243·"trace/trace-hw_intc.h"

6242

········}

6242

········}

6243

····}

6243

····}

6244

}

6244

}

6245

static·inline·void·trace_xive_router_end_notify(uint8_t·end_blk,·uint32_t·end_idx,·uint32_t·end_data)

6245

static·inline·void·trace_xive_router_end_notify(uint8_t·end_blk,·uint32_t·end_idx,·uint32_t·end_data)

6257

static·inline·void·_nocheck__trace_xive_router_end_escalate(uint8_t·end_blk,·uint32_t·end_idx,·uint8_t·esc_blk,·uint32_t·esc_idx,·uint32_t·end_data)

6257

static·inline·void·_nocheck__trace_xive_router_end_escalate(uint8_t·end_blk,·uint32_t·end_idx,·uint8_t·esc_blk,·uint32_t·esc_idx,·uint32_t·end_data)

6258

{

6258

{

6259

····if·(trace_event_get_state(TRACE_XIVE_ROUTER_END_ESCALATE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6259

····if·(trace_event_get_state(TRACE_XIVE_ROUTER_END_ESCALATE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6260

········if·(message_with_timestamp)·{

6260

········if·(message_with_timestamp)·{

6261

············struct·timeval·_now;

6261

············struct·timeval·_now;

6262

············gettimeofday(&_now,·NULL);

6262

············gettimeofday(&_now,·NULL);

6264

············qemu_log("%d@%zu.%06zu:xive_router_end_escalate·"·"END·0x%02x/0x%04x·->·escalate·END·0x%02x/0x%04x·data·0x%08x"·"\n",

6264

············qemu_log("%d@%zu.%06zu:xive_router_end_escalate·"·"END·0x%02x/0x%04x·->·escalate·END·0x%02x/0x%04x·data·0x%08x"·"\n",

6265

·····················qemu_get_thread_id(),

6265

·····················qemu_get_thread_id(),

6266

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6266

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6267

·····················,·end_blk,·end_idx,·esc_blk,·esc_idx,·end_data);

6267

·····················,·end_blk,·end_idx,·esc_blk,·esc_idx,·end_data);

6268

#line·6270·"trace/trace-hw_intc.h"

6268

#line·6270·"trace/trace-hw_intc.h"

6269

········}·else·{

6269

········}·else·{

6271

············qemu_log("xive_router_end_escalate·"·"END·0x%02x/0x%04x·->·escalate·END·0x%02x/0x%04x·data·0x%08x"·"\n",·end_blk,·end_idx,·esc_blk,·esc_idx,·end_data);

6271

············qemu_log("xive_router_end_escalate·"·"END·0x%02x/0x%04x·->·escalate·END·0x%02x/0x%04x·data·0x%08x"·"\n",·end_blk,·end_idx,·esc_blk,·esc_idx,·end_data);

6272

#line·6274·"trace/trace-hw_intc.h"

6272

#line·6274·"trace/trace-hw_intc.h"

6273

········}

6273

········}

6274

····}

6274

····}

6275

}

6275

}

6276

static·inline·void·trace_xive_router_end_escalate(uint8_t·end_blk,·uint32_t·end_idx,·uint8_t·esc_blk,·uint32_t·esc_idx,·uint32_t·end_data)

6276

static·inline·void·trace_xive_router_end_escalate(uint8_t·end_blk,·uint32_t·end_idx,·uint8_t·esc_blk,·uint32_t·esc_idx,·uint32_t·end_data)

6288

static·inline·void·_nocheck__trace_xive_tctx_tm_write(uint64_t·offset,·unsigned·int·size,·uint64_t·value)

6288

static·inline·void·_nocheck__trace_xive_tctx_tm_write(uint64_t·offset,·unsigned·int·size,·uint64_t·value)

6289

{

6289

{

6290

····if·(trace_event_get_state(TRACE_XIVE_TCTX_TM_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6290

····if·(trace_event_get_state(TRACE_XIVE_TCTX_TM_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6291

········if·(message_with_timestamp)·{

6291

········if·(message_with_timestamp)·{

6292

············struct·timeval·_now;

6292

············struct·timeval·_now;

6293

············gettimeofday(&_now,·NULL);

6293

············gettimeofday(&_now,·NULL);

6295

············qemu_log("%d@%zu.%06zu:xive_tctx_tm_write·"·"@0x%"PRIx64"·sz=%d·val=0x%"·PRIx64·"\n",

6295

············qemu_log("%d@%zu.%06zu:xive_tctx_tm_write·"·"@0x%"PRIx64"·sz=%d·val=0x%"·PRIx64·"\n",

6296

·····················qemu_get_thread_id(),

6296

·····················qemu_get_thread_id(),

6297

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6297

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6298

·····················,·offset,·size,·value);

6298

·····················,·offset,·size,·value);

6299

#line·6301·"trace/trace-hw_intc.h"

6299

#line·6301·"trace/trace-hw_intc.h"

6300

········}·else·{

6300

········}·else·{

6302

············qemu_log("xive_tctx_tm_write·"·"@0x%"PRIx64"·sz=%d·val=0x%"·PRIx64·"\n",·offset,·size,·value);

6302

············qemu_log("xive_tctx_tm_write·"·"@0x%"PRIx64"·sz=%d·val=0x%"·PRIx64·"\n",·offset,·size,·value);

6303

#line·6305·"trace/trace-hw_intc.h"

6303

#line·6305·"trace/trace-hw_intc.h"

6304

········}

6304

········}

6305

····}

6305

····}

6306

}

6306

}

6307

static·inline·void·trace_xive_tctx_tm_write(uint64_t·offset,·unsigned·int·size,·uint64_t·value)

6307

static·inline·void·trace_xive_tctx_tm_write(uint64_t·offset,·unsigned·int·size,·uint64_t·value)

6319

static·inline·void·_nocheck__trace_xive_tctx_tm_read(uint64_t·offset,·unsigned·int·size,·uint64_t·value)

6319

static·inline·void·_nocheck__trace_xive_tctx_tm_read(uint64_t·offset,·unsigned·int·size,·uint64_t·value)

6320

{

6320

{

6321

····if·(trace_event_get_state(TRACE_XIVE_TCTX_TM_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6321

····if·(trace_event_get_state(TRACE_XIVE_TCTX_TM_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6322

········if·(message_with_timestamp)·{

6322

········if·(message_with_timestamp)·{

6323

············struct·timeval·_now;

6323

············struct·timeval·_now;

6324

············gettimeofday(&_now,·NULL);

6324

············gettimeofday(&_now,·NULL);

6326

············qemu_log("%d@%zu.%06zu:xive_tctx_tm_read·"·"@0x%"PRIx64"·sz=%d·val=0x%"·PRIx64·"\n",

6326

············qemu_log("%d@%zu.%06zu:xive_tctx_tm_read·"·"@0x%"PRIx64"·sz=%d·val=0x%"·PRIx64·"\n",

6327

·····················qemu_get_thread_id(),

6327

·····················qemu_get_thread_id(),

6328

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6328

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6329

·····················,·offset,·size,·value);

6329

·····················,·offset,·size,·value);

6330

#line·6332·"trace/trace-hw_intc.h"

6330

#line·6332·"trace/trace-hw_intc.h"

6331

········}·else·{

6331

········}·else·{

6333

············qemu_log("xive_tctx_tm_read·"·"@0x%"PRIx64"·sz=%d·val=0x%"·PRIx64·"\n",·offset,·size,·value);

6333

············qemu_log("xive_tctx_tm_read·"·"@0x%"PRIx64"·sz=%d·val=0x%"·PRIx64·"\n",·offset,·size,·value);

6334

#line·6336·"trace/trace-hw_intc.h"

6334

#line·6336·"trace/trace-hw_intc.h"

6335

········}

6335

········}

6336

····}

6336

····}

6337

}

6337

}

6338

static·inline·void·trace_xive_tctx_tm_read(uint64_t·offset,·unsigned·int·size,·uint64_t·value)

6338

static·inline·void·trace_xive_tctx_tm_read(uint64_t·offset,·unsigned·int·size,·uint64_t·value)

6350

static·inline·void·_nocheck__trace_xive_presenter_notify(uint8_t·nvt_blk,·uint32_t·nvt_idx,·uint8_t·ring)

6350

static·inline·void·_nocheck__trace_xive_presenter_notify(uint8_t·nvt_blk,·uint32_t·nvt_idx,·uint8_t·ring)

6351

{

6351

{

6352

····if·(trace_event_get_state(TRACE_XIVE_PRESENTER_NOTIFY)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6352

····if·(trace_event_get_state(TRACE_XIVE_PRESENTER_NOTIFY)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6353

········if·(message_with_timestamp)·{

6353

········if·(message_with_timestamp)·{

6354

············struct·timeval·_now;

6354

············struct·timeval·_now;

6355

············gettimeofday(&_now,·NULL);

6355

············gettimeofday(&_now,·NULL);

6357

············qemu_log("%d@%zu.%06zu:xive_presenter_notify·"·"found·NVT·0x%x/0x%x·ring=0x%x"·"\n",

6357

············qemu_log("%d@%zu.%06zu:xive_presenter_notify·"·"found·NVT·0x%x/0x%x·ring=0x%x"·"\n",

6358

·····················qemu_get_thread_id(),

6358

·····················qemu_get_thread_id(),

6359

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6359

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6360

·····················,·nvt_blk,·nvt_idx,·ring);

6360

·····················,·nvt_blk,·nvt_idx,·ring);

6361

#line·6363·"trace/trace-hw_intc.h"

6361

#line·6363·"trace/trace-hw_intc.h"

6362

········}·else·{

6362

········}·else·{

6364

············qemu_log("xive_presenter_notify·"·"found·NVT·0x%x/0x%x·ring=0x%x"·"\n",·nvt_blk,·nvt_idx,·ring);

6364

············qemu_log("xive_presenter_notify·"·"found·NVT·0x%x/0x%x·ring=0x%x"·"\n",·nvt_blk,·nvt_idx,·ring);

6365

#line·6367·"trace/trace-hw_intc.h"

6365

#line·6367·"trace/trace-hw_intc.h"

6366

········}

6366

········}

6367

····}

6367

····}

6368

}

6368

}

6369

static·inline·void·trace_xive_presenter_notify(uint8_t·nvt_blk,·uint32_t·nvt_idx,·uint8_t·ring)

6369

static·inline·void·trace_xive_presenter_notify(uint8_t·nvt_blk,·uint32_t·nvt_idx,·uint8_t·ring)

6381

static·inline·void·_nocheck__trace_xive_end_source_read(uint8_t·end_blk,·uint32_t·end_idx,·uint64_t·addr)

6381

static·inline·void·_nocheck__trace_xive_end_source_read(uint8_t·end_blk,·uint32_t·end_idx,·uint64_t·addr)

6382

{

6382

{

6383

····if·(trace_event_get_state(TRACE_XIVE_END_SOURCE_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6383

····if·(trace_event_get_state(TRACE_XIVE_END_SOURCE_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6384

········if·(message_with_timestamp)·{

6384

········if·(message_with_timestamp)·{

6385

············struct·timeval·_now;

6385

············struct·timeval·_now;

6386

············gettimeofday(&_now,·NULL);

6386

············gettimeofday(&_now,·NULL);

6388

············qemu_log("%d@%zu.%06zu:xive_end_source_read·"·"END·0x%x/0x%x·@0x%"PRIx64·"\n",

6388

············qemu_log("%d@%zu.%06zu:xive_end_source_read·"·"END·0x%x/0x%x·@0x%"PRIx64·"\n",

6389

·····················qemu_get_thread_id(),

6389

·····················qemu_get_thread_id(),

6390

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6390

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6391

·····················,·end_blk,·end_idx,·addr);

6391

·····················,·end_blk,·end_idx,·addr);

6392

#line·6394·"trace/trace-hw_intc.h"

6392

#line·6394·"trace/trace-hw_intc.h"

6393

········}·else·{

6393

········}·else·{

6395

············qemu_log("xive_end_source_read·"·"END·0x%x/0x%x·@0x%"PRIx64·"\n",·end_blk,·end_idx,·addr);

6395

············qemu_log("xive_end_source_read·"·"END·0x%x/0x%x·@0x%"PRIx64·"\n",·end_blk,·end_idx,·addr);

6396

#line·6398·"trace/trace-hw_intc.h"

6396

#line·6398·"trace/trace-hw_intc.h"

6397

········}

6397

········}

6398

····}

6398

····}

6399

}

6399

}

6400

static·inline·void·trace_xive_end_source_read(uint8_t·end_blk,·uint32_t·end_idx,·uint64_t·addr)

6400

static·inline·void·trace_xive_end_source_read(uint8_t·end_blk,·uint32_t·end_idx,·uint64_t·addr)

6412

static·inline·void·_nocheck__trace_pnv_xive_ic_hw_trigger(uint64_t·addr,·uint64_t·val)

6412

static·inline·void·_nocheck__trace_pnv_xive_ic_hw_trigger(uint64_t·addr,·uint64_t·val)

6413

{

6413

{

6414

····if·(trace_event_get_state(TRACE_PNV_XIVE_IC_HW_TRIGGER)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6414

····if·(trace_event_get_state(TRACE_PNV_XIVE_IC_HW_TRIGGER)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6415

········if·(message_with_timestamp)·{

6415

········if·(message_with_timestamp)·{

6416

············struct·timeval·_now;

6416

············struct·timeval·_now;

6417

············gettimeofday(&_now,·NULL);

6417

············gettimeofday(&_now,·NULL);

6419

············qemu_log("%d@%zu.%06zu:pnv_xive_ic_hw_trigger·"·"@0x%"PRIx64"·val=0x%"PRIx64·"\n",

6419

············qemu_log("%d@%zu.%06zu:pnv_xive_ic_hw_trigger·"·"@0x%"PRIx64"·val=0x%"PRIx64·"\n",

6420

·····················qemu_get_thread_id(),

6420

·····················qemu_get_thread_id(),

6421

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6421

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6422

·····················,·addr,·val);

6422

·····················,·addr,·val);

6423

#line·6425·"trace/trace-hw_intc.h"

6423

#line·6425·"trace/trace-hw_intc.h"

6424

········}·else·{

6424

········}·else·{

6426

············qemu_log("pnv_xive_ic_hw_trigger·"·"@0x%"PRIx64"·val=0x%"PRIx64·"\n",·addr,·val);

6426

············qemu_log("pnv_xive_ic_hw_trigger·"·"@0x%"PRIx64"·val=0x%"PRIx64·"\n",·addr,·val);

6427

#line·6429·"trace/trace-hw_intc.h"

6427

#line·6429·"trace/trace-hw_intc.h"

6428

········}

6428

········}

6429

····}

6429

····}

6430

}

6430

}

6431

static·inline·void·trace_pnv_xive_ic_hw_trigger(uint64_t·addr,·uint64_t·val)

6431

static·inline·void·trace_pnv_xive_ic_hw_trigger(uint64_t·addr,·uint64_t·val)

6443

static·inline·void·_nocheck__trace_goldfish_irq_request(void·*·dev,·int·idx,·int·irq,·int·level)

6443

static·inline·void·_nocheck__trace_goldfish_irq_request(void·*·dev,·int·idx,·int·irq,·int·level)

6444

{

6444

{

6445

····if·(trace_event_get_state(TRACE_GOLDFISH_IRQ_REQUEST)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6445

····if·(trace_event_get_state(TRACE_GOLDFISH_IRQ_REQUEST)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6446

········if·(message_with_timestamp)·{

6446

········if·(message_with_timestamp)·{

6447

············struct·timeval·_now;

6447

············struct·timeval·_now;

6448

············gettimeofday(&_now,·NULL);

6448

············gettimeofday(&_now,·NULL);

6450

············qemu_log("%d@%zu.%06zu:goldfish_irq_request·"·"pic:·%p·goldfish-irq.%d·irq:·%d·level:·%d"·"\n",

6450

············qemu_log("%d@%zu.%06zu:goldfish_irq_request·"·"pic:·%p·goldfish-irq.%d·irq:·%d·level:·%d"·"\n",

6451

·····················qemu_get_thread_id(),

6451

·····················qemu_get_thread_id(),

6452

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6452

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6453

·····················,·dev,·idx,·irq,·level);

6453

·····················,·dev,·idx,·irq,·level);

6454

#line·6456·"trace/trace-hw_intc.h"

6454

#line·6456·"trace/trace-hw_intc.h"

6455

········}·else·{

6455

········}·else·{

6457

············qemu_log("goldfish_irq_request·"·"pic:·%p·goldfish-irq.%d·irq:·%d·level:·%d"·"\n",·dev,·idx,·irq,·level);

6457

············qemu_log("goldfish_irq_request·"·"pic:·%p·goldfish-irq.%d·irq:·%d·level:·%d"·"\n",·dev,·idx,·irq,·level);

6458

#line·6460·"trace/trace-hw_intc.h"

6458

#line·6460·"trace/trace-hw_intc.h"

6459

········}

6459

········}

6460

····}

6460

····}

6461

}

6461

}

6462

static·inline·void·trace_goldfish_irq_request(void·*·dev,·int·idx,·int·irq,·int·level)

6462

static·inline·void·trace_goldfish_irq_request(void·*·dev,·int·idx,·int·irq,·int·level)

6474

static·inline·void·_nocheck__trace_goldfish_pic_read(void·*·dev,·int·idx,·unsigned·int·addr,·unsigned·int·size,·uint64_t·value)

6474

static·inline·void·_nocheck__trace_goldfish_pic_read(void·*·dev,·int·idx,·unsigned·int·addr,·unsigned·int·size,·uint64_t·value)

6475

{

6475

{

6476

····if·(trace_event_get_state(TRACE_GOLDFISH_PIC_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6476

····if·(trace_event_get_state(TRACE_GOLDFISH_PIC_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6477

········if·(message_with_timestamp)·{

6477

········if·(message_with_timestamp)·{

6478

············struct·timeval·_now;

6478

············struct·timeval·_now;

6479

············gettimeofday(&_now,·NULL);

6479

············gettimeofday(&_now,·NULL);

6481

············qemu_log("%d@%zu.%06zu:goldfish_pic_read·"·"pic:·%p·goldfish-irq.%d·reg:·0x%02x·size:·%d·value:·0x%"PRIx64·"\n",

6481

············qemu_log("%d@%zu.%06zu:goldfish_pic_read·"·"pic:·%p·goldfish-irq.%d·reg:·0x%02x·size:·%d·value:·0x%"PRIx64·"\n",

6482

·····················qemu_get_thread_id(),

6482

·····················qemu_get_thread_id(),

6483

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6483

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6484

·····················,·dev,·idx,·addr,·size,·value);

6484

·····················,·dev,·idx,·addr,·size,·value);

6485

#line·6487·"trace/trace-hw_intc.h"

6485

#line·6487·"trace/trace-hw_intc.h"

6486

········}·else·{

6486

········}·else·{

6488

············qemu_log("goldfish_pic_read·"·"pic:·%p·goldfish-irq.%d·reg:·0x%02x·size:·%d·value:·0x%"PRIx64·"\n",·dev,·idx,·addr,·size,·value);

6488

············qemu_log("goldfish_pic_read·"·"pic:·%p·goldfish-irq.%d·reg:·0x%02x·size:·%d·value:·0x%"PRIx64·"\n",·dev,·idx,·addr,·size,·value);

6489

#line·6491·"trace/trace-hw_intc.h"

6489

#line·6491·"trace/trace-hw_intc.h"

6490

········}

6490

········}

6491

····}

6491

····}

6492

}

6492

}

6493

static·inline·void·trace_goldfish_pic_read(void·*·dev,·int·idx,·unsigned·int·addr,·unsigned·int·size,·uint64_t·value)

6493

static·inline·void·trace_goldfish_pic_read(void·*·dev,·int·idx,·unsigned·int·addr,·unsigned·int·size,·uint64_t·value)

6505

static·inline·void·_nocheck__trace_goldfish_pic_write(void·*·dev,·int·idx,·unsigned·int·addr,·unsigned·int·size,·uint64_t·value)

6505

static·inline·void·_nocheck__trace_goldfish_pic_write(void·*·dev,·int·idx,·unsigned·int·addr,·unsigned·int·size,·uint64_t·value)

6506

{

6506

{

6507

····if·(trace_event_get_state(TRACE_GOLDFISH_PIC_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6507

····if·(trace_event_get_state(TRACE_GOLDFISH_PIC_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6508

········if·(message_with_timestamp)·{

6508

········if·(message_with_timestamp)·{

6509

············struct·timeval·_now;

6509

············struct·timeval·_now;

6510

············gettimeofday(&_now,·NULL);

6510

············gettimeofday(&_now,·NULL);

6512

············qemu_log("%d@%zu.%06zu:goldfish_pic_write·"·"pic:·%p·goldfish-irq.%d·reg:·0x%02x·size:·%d·value:·0x%"PRIx64·"\n",

6512

············qemu_log("%d@%zu.%06zu:goldfish_pic_write·"·"pic:·%p·goldfish-irq.%d·reg:·0x%02x·size:·%d·value:·0x%"PRIx64·"\n",

6513

·····················qemu_get_thread_id(),

6513

·····················qemu_get_thread_id(),

6514

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6514

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6515

·····················,·dev,·idx,·addr,·size,·value);

6515

·····················,·dev,·idx,·addr,·size,·value);

6516

#line·6518·"trace/trace-hw_intc.h"

6516

#line·6518·"trace/trace-hw_intc.h"

6517

········}·else·{

6517

········}·else·{

6519

············qemu_log("goldfish_pic_write·"·"pic:·%p·goldfish-irq.%d·reg:·0x%02x·size:·%d·value:·0x%"PRIx64·"\n",·dev,·idx,·addr,·size,·value);

6519

············qemu_log("goldfish_pic_write·"·"pic:·%p·goldfish-irq.%d·reg:·0x%02x·size:·%d·value:·0x%"PRIx64·"\n",·dev,·idx,·addr,·size,·value);

6520

#line·6522·"trace/trace-hw_intc.h"

6520

#line·6522·"trace/trace-hw_intc.h"

6521

········}

6521

········}

6522

····}

6522

····}

6523

}

6523

}

6524

static·inline·void·trace_goldfish_pic_write(void·*·dev,·int·idx,·unsigned·int·addr,·unsigned·int·size,·uint64_t·value)

6524

static·inline·void·trace_goldfish_pic_write(void·*·dev,·int·idx,·unsigned·int·addr,·unsigned·int·size,·uint64_t·value)

6536

static·inline·void·_nocheck__trace_goldfish_pic_reset(void·*·dev,·int·idx)

6536

static·inline·void·_nocheck__trace_goldfish_pic_reset(void·*·dev,·int·idx)

6537

{

6537

{

6538

····if·(trace_event_get_state(TRACE_GOLDFISH_PIC_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6538

····if·(trace_event_get_state(TRACE_GOLDFISH_PIC_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6539

········if·(message_with_timestamp)·{

6539

········if·(message_with_timestamp)·{

6540

············struct·timeval·_now;

6540

············struct·timeval·_now;

6541

············gettimeofday(&_now,·NULL);

6541

············gettimeofday(&_now,·NULL);

6543

············qemu_log("%d@%zu.%06zu:goldfish_pic_reset·"·"pic:·%p·goldfish-irq.%d"·"\n",

6543

············qemu_log("%d@%zu.%06zu:goldfish_pic_reset·"·"pic:·%p·goldfish-irq.%d"·"\n",

6544

·····················qemu_get_thread_id(),

6544

·····················qemu_get_thread_id(),

6545

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6545

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6546

·····················,·dev,·idx);

6546

·····················,·dev,·idx);

6547

#line·6549·"trace/trace-hw_intc.h"

6547

#line·6549·"trace/trace-hw_intc.h"

6548

········}·else·{

6548

········}·else·{

6550

············qemu_log("goldfish_pic_reset·"·"pic:·%p·goldfish-irq.%d"·"\n",·dev,·idx);

6550

············qemu_log("goldfish_pic_reset·"·"pic:·%p·goldfish-irq.%d"·"\n",·dev,·idx);

6551

#line·6553·"trace/trace-hw_intc.h"

6551

#line·6553·"trace/trace-hw_intc.h"

6552

········}

6552

········}

6553

····}

6553

····}

6554

}

6554

}

6555

static·inline·void·trace_goldfish_pic_reset(void·*·dev,·int·idx)

6555

static·inline·void·trace_goldfish_pic_reset(void·*·dev,·int·idx)

6567

static·inline·void·_nocheck__trace_goldfish_pic_realize(void·*·dev,·int·idx)

6567

static·inline·void·_nocheck__trace_goldfish_pic_realize(void·*·dev,·int·idx)

6568

{

6568

{

6569

····if·(trace_event_get_state(TRACE_GOLDFISH_PIC_REALIZE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6569

····if·(trace_event_get_state(TRACE_GOLDFISH_PIC_REALIZE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6570

········if·(message_with_timestamp)·{

6570

········if·(message_with_timestamp)·{

6571

············struct·timeval·_now;

6571

············struct·timeval·_now;

6572

············gettimeofday(&_now,·NULL);

6572

············gettimeofday(&_now,·NULL);

6574

············qemu_log("%d@%zu.%06zu:goldfish_pic_realize·"·"pic:·%p·goldfish-irq.%d"·"\n",

6574

············qemu_log("%d@%zu.%06zu:goldfish_pic_realize·"·"pic:·%p·goldfish-irq.%d"·"\n",

6575

·····················qemu_get_thread_id(),

6575

·····················qemu_get_thread_id(),

6576

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6576

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6577

·····················,·dev,·idx);

6577

·····················,·dev,·idx);

6578

#line·6580·"trace/trace-hw_intc.h"

6578

#line·6580·"trace/trace-hw_intc.h"

6579

········}·else·{

6579

········}·else·{

6581

············qemu_log("goldfish_pic_realize·"·"pic:·%p·goldfish-irq.%d"·"\n",·dev,·idx);

6581

············qemu_log("goldfish_pic_realize·"·"pic:·%p·goldfish-irq.%d"·"\n",·dev,·idx);

6582

#line·6584·"trace/trace-hw_intc.h"

6582

#line·6584·"trace/trace-hw_intc.h"

6583

········}

6583

········}

6584

····}

6584

····}

6585

}

6585

}

6586

static·inline·void·trace_goldfish_pic_realize(void·*·dev,·int·idx)

6586

static·inline·void·trace_goldfish_pic_realize(void·*·dev,·int·idx)

6598

static·inline·void·_nocheck__trace_goldfish_pic_instance_init(void·*·dev)

6598

static·inline·void·_nocheck__trace_goldfish_pic_instance_init(void·*·dev)

6599

{

6599

{

6600

····if·(trace_event_get_state(TRACE_GOLDFISH_PIC_INSTANCE_INIT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6600

····if·(trace_event_get_state(TRACE_GOLDFISH_PIC_INSTANCE_INIT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6601

········if·(message_with_timestamp)·{

6601

········if·(message_with_timestamp)·{

6602

············struct·timeval·_now;

6602

············struct·timeval·_now;

6603

············gettimeofday(&_now,·NULL);

6603

············gettimeofday(&_now,·NULL);

6605

············qemu_log("%d@%zu.%06zu:goldfish_pic_instance_init·"·"pic:·%p·goldfish-irq"·"\n",

6605

············qemu_log("%d@%zu.%06zu:goldfish_pic_instance_init·"·"pic:·%p·goldfish-irq"·"\n",

6606

·····················qemu_get_thread_id(),

6606

·····················qemu_get_thread_id(),

6607

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6607

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6608

·····················,·dev);

6608

·····················,·dev);

6609

#line·6611·"trace/trace-hw_intc.h"

6609

#line·6611·"trace/trace-hw_intc.h"

6610

········}·else·{

6610

········}·else·{

6612

············qemu_log("goldfish_pic_instance_init·"·"pic:·%p·goldfish-irq"·"\n",·dev);

6612

············qemu_log("goldfish_pic_instance_init·"·"pic:·%p·goldfish-irq"·"\n",·dev);

6613

#line·6615·"trace/trace-hw_intc.h"

6613

#line·6615·"trace/trace-hw_intc.h"

6614

········}

6614

········}

6615

····}

6615

····}

6616

}

6616

}

6617

static·inline·void·trace_goldfish_pic_instance_init(void·*·dev)

6617

static·inline·void·trace_goldfish_pic_instance_init(void·*·dev)

6629

static·inline·void·_nocheck__trace_sh_intc_sources(int·p,·int·a,·int·c,·int·m,·unsigned·short·v,·const·char·*·s1,·const·char·*·s2,·const·char·*·s3)

6629

static·inline·void·_nocheck__trace_sh_intc_sources(int·p,·int·a,·int·c,·int·m,·unsigned·short·v,·const·char·*·s1,·const·char·*·s2,·const·char·*·s3)

6630

{

6630

{

6631

····if·(trace_event_get_state(TRACE_SH_INTC_SOURCES)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6631

····if·(trace_event_get_state(TRACE_SH_INTC_SOURCES)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6632

········if·(message_with_timestamp)·{

6632

········if·(message_with_timestamp)·{

6633

············struct·timeval·_now;

6633

············struct·timeval·_now;

6634

············gettimeofday(&_now,·NULL);

6634

············gettimeofday(&_now,·NULL);

6636

············qemu_log("%d@%zu.%06zu:sh_intc_sources·"·"(%d/%d/%d/%d)·interrupt·source·0x%x·%s%s%s"·"\n",

6636

············qemu_log("%d@%zu.%06zu:sh_intc_sources·"·"(%d/%d/%d/%d)·interrupt·source·0x%x·%s%s%s"·"\n",

6637

·····················qemu_get_thread_id(),

6637

·····················qemu_get_thread_id(),

6638

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6638

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6639

·····················,·p,·a,·c,·m,·v,·s1,·s2,·s3);

6639

·····················,·p,·a,·c,·m,·v,·s1,·s2,·s3);

6640

#line·6642·"trace/trace-hw_intc.h"

6640

#line·6642·"trace/trace-hw_intc.h"

6641

········}·else·{

6641

········}·else·{

6643

············qemu_log("sh_intc_sources·"·"(%d/%d/%d/%d)·interrupt·source·0x%x·%s%s%s"·"\n",·p,·a,·c,·m,·v,·s1,·s2,·s3);

6643

············qemu_log("sh_intc_sources·"·"(%d/%d/%d/%d)·interrupt·source·0x%x·%s%s%s"·"\n",·p,·a,·c,·m,·v,·s1,·s2,·s3);

6644

#line·6646·"trace/trace-hw_intc.h"

6644

#line·6646·"trace/trace-hw_intc.h"

6645

········}

6645

········}

6646

····}

6646

····}

6647

}

6647

}

6648

static·inline·void·trace_sh_intc_sources(int·p,·int·a,·int·c,·int·m,·unsigned·short·v,·const·char·*·s1,·const·char·*·s2,·const·char·*·s3)

6648

static·inline·void·trace_sh_intc_sources(int·p,·int·a,·int·c,·int·m,·unsigned·short·v,·const·char·*·s1,·const·char·*·s2,·const·char·*·s3)

6660

static·inline·void·_nocheck__trace_sh_intc_pending(int·p,·unsigned·short·v)

6660

static·inline·void·_nocheck__trace_sh_intc_pending(int·p,·unsigned·short·v)

6661

{

6661

{

6662

····if·(trace_event_get_state(TRACE_SH_INTC_PENDING)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6662

····if·(trace_event_get_state(TRACE_SH_INTC_PENDING)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6663

········if·(message_with_timestamp)·{

6663

········if·(message_with_timestamp)·{

6664

············struct·timeval·_now;

6664

············struct·timeval·_now;

6665

············gettimeofday(&_now,·NULL);

6665

············gettimeofday(&_now,·NULL);

6667

············qemu_log("%d@%zu.%06zu:sh_intc_pending·"·"(%d)·returning·interrupt·source·0x%x"·"\n",

6667

············qemu_log("%d@%zu.%06zu:sh_intc_pending·"·"(%d)·returning·interrupt·source·0x%x"·"\n",

6668

·····················qemu_get_thread_id(),

6668

·····················qemu_get_thread_id(),

6669

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6669

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6670

·····················,·p,·v);

6670

·····················,·p,·v);

6671

#line·6673·"trace/trace-hw_intc.h"

6671

#line·6673·"trace/trace-hw_intc.h"

6672

········}·else·{

6672

········}·else·{

6674

············qemu_log("sh_intc_pending·"·"(%d)·returning·interrupt·source·0x%x"·"\n",·p,·v);

6674

············qemu_log("sh_intc_pending·"·"(%d)·returning·interrupt·source·0x%x"·"\n",·p,·v);

6675

#line·6677·"trace/trace-hw_intc.h"

6675

#line·6677·"trace/trace-hw_intc.h"

6676

········}

6676

········}

6677

····}

6677

····}

6678

}

6678

}

6679

static·inline·void·trace_sh_intc_pending(int·p,·unsigned·short·v)

6679

static·inline·void·trace_sh_intc_pending(int·p,·unsigned·short·v)

6691

static·inline·void·_nocheck__trace_sh_intc_register(const·char·*·s,·int·id,·unsigned·short·v,·int·c,·int·m)

6691

static·inline·void·_nocheck__trace_sh_intc_register(const·char·*·s,·int·id,·unsigned·short·v,·int·c,·int·m)

6692

{

6692

{

6693

····if·(trace_event_get_state(TRACE_SH_INTC_REGISTER)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6693

····if·(trace_event_get_state(TRACE_SH_INTC_REGISTER)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6694

········if·(message_with_timestamp)·{

6694

········if·(message_with_timestamp)·{

6695

············struct·timeval·_now;

6695

············struct·timeval·_now;

6696

············gettimeofday(&_now,·NULL);

6696

············gettimeofday(&_now,·NULL);

6698

············qemu_log("%d@%zu.%06zu:sh_intc_register·"·"%s·%u·->·0x%04x·(%d/%d)"·"\n",

6698

············qemu_log("%d@%zu.%06zu:sh_intc_register·"·"%s·%u·->·0x%04x·(%d/%d)"·"\n",

6699

·····················qemu_get_thread_id(),

6699

·····················qemu_get_thread_id(),

6700

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6700

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6701

·····················,·s,·id,·v,·c,·m);

6701

·····················,·s,·id,·v,·c,·m);

6702

#line·6704·"trace/trace-hw_intc.h"

6702

#line·6704·"trace/trace-hw_intc.h"

6703

········}·else·{

6703

········}·else·{

6705

············qemu_log("sh_intc_register·"·"%s·%u·->·0x%04x·(%d/%d)"·"\n",·s,·id,·v,·c,·m);

6705

············qemu_log("sh_intc_register·"·"%s·%u·->·0x%04x·(%d/%d)"·"\n",·s,·id,·v,·c,·m);

6706

#line·6708·"trace/trace-hw_intc.h"

6706

#line·6708·"trace/trace-hw_intc.h"

6707

········}

6707

········}

6708

····}

6708

····}

6709

}

6709

}

6710

static·inline·void·trace_sh_intc_register(const·char·*·s,·int·id,·unsigned·short·v,·int·c,·int·m)

6710

static·inline·void·trace_sh_intc_register(const·char·*·s,·int·id,·unsigned·short·v,·int·c,·int·m)

6722

static·inline·void·_nocheck__trace_sh_intc_read(unsigned·size,·uint64_t·offset,·unsigned·long·val)

6722

static·inline·void·_nocheck__trace_sh_intc_read(unsigned·size,·uint64_t·offset,·unsigned·long·val)

6723

{

6723

{

6724

····if·(trace_event_get_state(TRACE_SH_INTC_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6724

····if·(trace_event_get_state(TRACE_SH_INTC_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6725

········if·(message_with_timestamp)·{

6725

········if·(message_with_timestamp)·{

6726

············struct·timeval·_now;

6726

············struct·timeval·_now;

6727

············gettimeofday(&_now,·NULL);

6727

············gettimeofday(&_now,·NULL);

6729

············qemu_log("%d@%zu.%06zu:sh_intc_read·"·"size·%u·0x%"·PRIx64·"·->·0x%lx"·"\n",

6729

············qemu_log("%d@%zu.%06zu:sh_intc_read·"·"size·%u·0x%"·PRIx64·"·->·0x%lx"·"\n",

6730

·····················qemu_get_thread_id(),

6730

·····················qemu_get_thread_id(),

6731

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6731

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6732

·····················,·size,·offset,·val);

6732

·····················,·size,·offset,·val);

6733

#line·6735·"trace/trace-hw_intc.h"

6733

#line·6735·"trace/trace-hw_intc.h"

6734

········}·else·{

6734

········}·else·{

6736

············qemu_log("sh_intc_read·"·"size·%u·0x%"·PRIx64·"·->·0x%lx"·"\n",·size,·offset,·val);

6736

············qemu_log("sh_intc_read·"·"size·%u·0x%"·PRIx64·"·->·0x%lx"·"\n",·size,·offset,·val);

6737

#line·6739·"trace/trace-hw_intc.h"

6737

#line·6739·"trace/trace-hw_intc.h"

6738

········}

6738

········}

6739

····}

6739

····}

6740

}

6740

}

6741

static·inline·void·trace_sh_intc_read(unsigned·size,·uint64_t·offset,·unsigned·long·val)

6741

static·inline·void·trace_sh_intc_read(unsigned·size,·uint64_t·offset,·unsigned·long·val)

6753

static·inline·void·_nocheck__trace_sh_intc_write(unsigned·size,·uint64_t·offset,·unsigned·long·val)

6753

static·inline·void·_nocheck__trace_sh_intc_write(unsigned·size,·uint64_t·offset,·unsigned·long·val)

6754

{

6754

{

6755

····if·(trace_event_get_state(TRACE_SH_INTC_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6755

····if·(trace_event_get_state(TRACE_SH_INTC_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6756

········if·(message_with_timestamp)·{

6756

········if·(message_with_timestamp)·{

6757

············struct·timeval·_now;

6757

············struct·timeval·_now;

6758

············gettimeofday(&_now,·NULL);

6758

············gettimeofday(&_now,·NULL);

6760

············qemu_log("%d@%zu.%06zu:sh_intc_write·"·"size·%u·0x%"·PRIx64·"·<-·0x%lx"·"\n",

6760

············qemu_log("%d@%zu.%06zu:sh_intc_write·"·"size·%u·0x%"·PRIx64·"·<-·0x%lx"·"\n",

6761

·····················qemu_get_thread_id(),

6761

·····················qemu_get_thread_id(),

6762

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6762

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6763

·····················,·size,·offset,·val);

6763

·····················,·size,·offset,·val);

6764

#line·6766·"trace/trace-hw_intc.h"

6764

#line·6766·"trace/trace-hw_intc.h"

6765

········}·else·{

6765

········}·else·{

6767

············qemu_log("sh_intc_write·"·"size·%u·0x%"·PRIx64·"·<-·0x%lx"·"\n",·size,·offset,·val);

6767

············qemu_log("sh_intc_write·"·"size·%u·0x%"·PRIx64·"·<-·0x%lx"·"\n",·size,·offset,·val);

6768

#line·6770·"trace/trace-hw_intc.h"

6768

#line·6770·"trace/trace-hw_intc.h"

6769

········}

6769

········}

6770

····}

6770

····}

6771

}

6771

}

6772

static·inline·void·trace_sh_intc_write(unsigned·size,·uint64_t·offset,·unsigned·long·val)

6772

static·inline·void·trace_sh_intc_write(unsigned·size,·uint64_t·offset,·unsigned·long·val)

6784

static·inline·void·_nocheck__trace_sh_intc_set(int·id,·int·enable)

6784

static·inline·void·_nocheck__trace_sh_intc_set(int·id,·int·enable)

6785

{

6785

{

6786

····if·(trace_event_get_state(TRACE_SH_INTC_SET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6786

····if·(trace_event_get_state(TRACE_SH_INTC_SET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

6787

········if·(message_with_timestamp)·{

6787

········if·(message_with_timestamp)·{

6788

············struct·timeval·_now;

6788

············struct·timeval·_now;

6789

············gettimeofday(&_now,·NULL);

6789

············gettimeofday(&_now,·NULL);

6791

············qemu_log("%d@%zu.%06zu:sh_intc_set·"·"setting·interrupt·group·%d·to·%d"·"\n",

6791

············qemu_log("%d@%zu.%06zu:sh_intc_set·"·"setting·interrupt·group·%d·to·%d"·"\n",

6792

·····················qemu_get_thread_id(),

6792

·····················qemu_get_thread_id(),

6793

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6793

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

6794

·····················,·id,·enable);

6794

·····················,·id,·enable);

6795

#line·6797·"trace/trace-hw_intc.h"

6795

#line·6797·"trace/trace-hw_intc.h"

6796

········}·else·{

6796

········}·else·{

6798

············qemu_log("sh_intc_set·"·"setting·interrupt·group·%d·to·%d"·"\n",·id,·enable);

6798

············qemu_log("sh_intc_set·"·"setting·interrupt·group·%d·to·%d"·"\n",·id,·enable);

6799

#line·6801·"trace/trace-hw_intc.h"

6799

#line·6801·"trace/trace-hw_intc.h"

6800

········}

6800

········}

6801

····}

6801

····}

6802

}

6802

}

6803

static·inline·void·trace_sh_intc_set(int·id,·int·enable)

6803

static·inline·void·trace_sh_intc_set(int·id,·int·enable)