/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

342

static·inline·void·_nocheck__trace_spapr_pci_msi(const·char·*·msg,·uint32_t·ca)

342

static·inline·void·_nocheck__trace_spapr_pci_msi(const·char·*·msg,·uint32_t·ca)

343

{

343

{

344

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

344

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

345

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

345

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

346

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

346

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

347

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

347

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

349

············qemu_log("%d@%zu.%06zu:spapr_pci_msi·"·"%s·(cfg=0x%x)"·"\n",

349

············qemu_log("%d@%zu.%06zu:spapr_pci_msi·"·"%s·(cfg=0x%x)"·"\n",

350

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

350

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

351

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

351

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

352

·····················,·msg,·ca);

352

·····················,·msg,·ca);

353

#line·355·"trace/trace-hw_ppc.h"

353

#line·355·"trace/trace-hw_ppc.h"

354

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

354

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

356

············qemu_log("spapr_pci_msi·"·"%s·(cfg=0x%x)"·"\n",·msg,·ca);

356

············qemu_log("spapr_pci_msi·"·"%s·(cfg=0x%x)"·"\n",·msg,·ca);

357

#line·359·"trace/trace-hw_ppc.h"

357

#line·359·"trace/trace-hw_ppc.h"

358

········}

358

········}

359

····}

359

····}

360

}

360

}

361

static·inline·void·trace_spapr_pci_msi(const·char·*·msg,·uint32_t·ca)

361

static·inline·void·trace_spapr_pci_msi(const·char·*·msg,·uint32_t·ca)

373

static·inline·void·_nocheck__trace_spapr_pci_msi_setup(const·char·*·name,·unsigned·vector,·uint64_t·addr)

373

static·inline·void·_nocheck__trace_spapr_pci_msi_setup(const·char·*·name,·unsigned·vector,·uint64_t·addr)

374

{

374

{

375

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

375

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

376

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

376

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

377

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

377

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

378

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

378

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

380

············qemu_log("%d@%zu.%06zu:spapr_pci_msi_setup·"·"dev\"%s\"·vector·%u,·addr=0x%"PRIx64·"\n",

380

············qemu_log("%d@%zu.%06zu:spapr_pci_msi_setup·"·"dev\"%s\"·vector·%u,·addr=0x%"PRIx64·"\n",

381

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

381

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

382

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

382

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

383

·····················,·name,·vector,·addr);

383

·····················,·name,·vector,·addr);

384

#line·386·"trace/trace-hw_ppc.h"

384

#line·386·"trace/trace-hw_ppc.h"

385

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

385

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

387

············qemu_log("spapr_pci_msi_setup·"·"dev\"%s\"·vector·%u,·addr=0x%"PRIx64·"\n",·name,·vector,·addr);

387

············qemu_log("spapr_pci_msi_setup·"·"dev\"%s\"·vector·%u,·addr=0x%"PRIx64·"\n",·name,·vector,·addr);

388

#line·390·"trace/trace-hw_ppc.h"

388

#line·390·"trace/trace-hw_ppc.h"

389

········}

389

········}

390

····}

390

····}

391

}

391

}

392

static·inline·void·trace_spapr_pci_msi_setup(const·char·*·name,·unsigned·vector,·uint64_t·addr)

392

static·inline·void·trace_spapr_pci_msi_setup(const·char·*·name,·unsigned·vector,·uint64_t·addr)

404

static·inline·void·_nocheck__trace_spapr_pci_rtas_ibm_change_msi(unsigned·cfg,·unsigned·func,·unsigned·req,·unsigned·first)

404

static·inline·void·_nocheck__trace_spapr_pci_rtas_ibm_change_msi(unsigned·cfg,·unsigned·func,·unsigned·req,·unsigned·first)

405

{

405

{

406

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

406

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

407

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

407

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

408

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

408

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

409

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

409

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

411

············qemu_log("%d@%zu.%06zu:spapr_pci_rtas_ibm_change_msi·"·"cfgaddr·0x%x·func·%u,·requested·%u,·first·irq·%u"·"\n",

411

············qemu_log("%d@%zu.%06zu:spapr_pci_rtas_ibm_change_msi·"·"cfgaddr·0x%x·func·%u,·requested·%u,·first·irq·%u"·"\n",

412

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

412

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

413

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

413

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

414

·····················,·cfg,·func,·req,·first);

414

·····················,·cfg,·func,·req,·first);

415

#line·417·"trace/trace-hw_ppc.h"

415

#line·417·"trace/trace-hw_ppc.h"

416

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

416

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

418

············qemu_log("spapr_pci_rtas_ibm_change_msi·"·"cfgaddr·0x%x·func·%u,·requested·%u,·first·irq·%u"·"\n",·cfg,·func,·req,·first);

418

············qemu_log("spapr_pci_rtas_ibm_change_msi·"·"cfgaddr·0x%x·func·%u,·requested·%u,·first·irq·%u"·"\n",·cfg,·func,·req,·first);

419

#line·421·"trace/trace-hw_ppc.h"

419

#line·421·"trace/trace-hw_ppc.h"

420

········}

420

········}

421

····}

421

····}

422

}

422

}

423

static·inline·void·trace_spapr_pci_rtas_ibm_change_msi(unsigned·cfg,·unsigned·func,·unsigned·req,·unsigned·first)

423

static·inline·void·trace_spapr_pci_rtas_ibm_change_msi(unsigned·cfg,·unsigned·func,·unsigned·req,·unsigned·first)

435

static·inline·void·_nocheck__trace_spapr_pci_rtas_ibm_query_interrupt_source_number(unsigned·ioa,·unsigned·intr)

435

static·inline·void·_nocheck__trace_spapr_pci_rtas_ibm_query_interrupt_source_number(unsigned·ioa,·unsigned·intr)

436

{

436

{

437

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

437

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

438

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

438

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

439

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

439

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

440

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

440

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

442

············qemu_log("%d@%zu.%06zu:spapr_pci_rtas_ibm_query_interrupt_source_number·"·"queries·for·#%u,·IRQ%u"·"\n",

442

············qemu_log("%d@%zu.%06zu:spapr_pci_rtas_ibm_query_interrupt_source_number·"·"queries·for·#%u,·IRQ%u"·"\n",

443

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

443

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

444

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

444

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

445

·····················,·ioa,·intr);

445

·····················,·ioa,·intr);

446

#line·448·"trace/trace-hw_ppc.h"

446

#line·448·"trace/trace-hw_ppc.h"

447

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

447

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

449

············qemu_log("spapr_pci_rtas_ibm_query_interrupt_source_number·"·"queries·for·#%u,·IRQ%u"·"\n",·ioa,·intr);

449

············qemu_log("spapr_pci_rtas_ibm_query_interrupt_source_number·"·"queries·for·#%u,·IRQ%u"·"\n",·ioa,·intr);

450

#line·452·"trace/trace-hw_ppc.h"

450

#line·452·"trace/trace-hw_ppc.h"

451

········}

451

········}

452

····}

452

····}

453

}

453

}

454

static·inline·void·trace_spapr_pci_rtas_ibm_query_interrupt_source_number(unsigned·ioa,·unsigned·intr)

454

static·inline·void·trace_spapr_pci_rtas_ibm_query_interrupt_source_number(unsigned·ioa,·unsigned·intr)

466

static·inline·void·_nocheck__trace_spapr_pci_msi_write(uint64_t·addr,·uint64_t·data,·uint32_t·dt_irq)

466

static·inline·void·_nocheck__trace_spapr_pci_msi_write(uint64_t·addr,·uint64_t·data,·uint32_t·dt_irq)

467

{

467

{

468

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

468

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

469

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

469

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

470

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

470

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

471

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

471

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

473

············qemu_log("%d@%zu.%06zu:spapr_pci_msi_write·"·"@0x%"PRIx64"<=0x%"PRIx64"·IRQ·%u"·"\n",

473

············qemu_log("%d@%zu.%06zu:spapr_pci_msi_write·"·"@0x%"PRIx64"<=0x%"PRIx64"·IRQ·%u"·"\n",

474

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

474

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

475

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

475

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

476

·····················,·addr,·data,·dt_irq);

476

·····················,·addr,·data,·dt_irq);

477

#line·479·"trace/trace-hw_ppc.h"

477

#line·479·"trace/trace-hw_ppc.h"

478

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

478

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

480

············qemu_log("spapr_pci_msi_write·"·"@0x%"PRIx64"<=0x%"PRIx64"·IRQ·%u"·"\n",·addr,·data,·dt_irq);

480

············qemu_log("spapr_pci_msi_write·"·"@0x%"PRIx64"<=0x%"PRIx64"·IRQ·%u"·"\n",·addr,·data,·dt_irq);

481

#line·483·"trace/trace-hw_ppc.h"

481

#line·483·"trace/trace-hw_ppc.h"

482

········}

482

········}

483

····}

483

····}

484

}

484

}

485

static·inline·void·trace_spapr_pci_msi_write(uint64_t·addr,·uint64_t·data,·uint32_t·dt_irq)

485

static·inline·void·trace_spapr_pci_msi_write(uint64_t·addr,·uint64_t·data,·uint32_t·dt_irq)

497

static·inline·void·_nocheck__trace_spapr_pci_lsi_set(const·char·*·busname,·int·pin,·uint32_t·irq)

497

static·inline·void·_nocheck__trace_spapr_pci_lsi_set(const·char·*·busname,·int·pin,·uint32_t·irq)

498

{

498

{

499

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

499

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

500

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

500

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

501

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

501

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

502

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

502

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

504

············qemu_log("%d@%zu.%06zu:spapr_pci_lsi_set·"·"%s·PIN%d·IRQ·%u"·"\n",

504

············qemu_log("%d@%zu.%06zu:spapr_pci_lsi_set·"·"%s·PIN%d·IRQ·%u"·"\n",

505

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

505

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

506

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

506

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

507

·····················,·busname,·pin,·irq);

507

·····················,·busname,·pin,·irq);

508

#line·510·"trace/trace-hw_ppc.h"

508

#line·510·"trace/trace-hw_ppc.h"

509

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

509

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

511

············qemu_log("spapr_pci_lsi_set·"·"%s·PIN%d·IRQ·%u"·"\n",·busname,·pin,·irq);

511

············qemu_log("spapr_pci_lsi_set·"·"%s·PIN%d·IRQ·%u"·"\n",·busname,·pin,·irq);

512

#line·514·"trace/trace-hw_ppc.h"

512

#line·514·"trace/trace-hw_ppc.h"

513

········}

513

········}

514

····}

514

····}

515

}

515

}

516

static·inline·void·trace_spapr_pci_lsi_set(const·char·*·busname,·int·pin,·uint32_t·irq)

516

static·inline·void·trace_spapr_pci_lsi_set(const·char·*·busname,·int·pin,·uint32_t·irq)

528

static·inline·void·_nocheck__trace_spapr_pci_msi_retry(unsigned·config_addr,·unsigned·req_num,·unsigned·max_irqs)

528

static·inline·void·_nocheck__trace_spapr_pci_msi_retry(unsigned·config_addr,·unsigned·req_num,·unsigned·max_irqs)

529

{

529

{

530

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

530

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

531

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

531

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

532

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

532

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

533

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

533

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

535

············qemu_log("%d@%zu.%06zu:spapr_pci_msi_retry·"·"Guest·device·at·0x%x·asked·%u,·have·only·%u"·"\n",

535

············qemu_log("%d@%zu.%06zu:spapr_pci_msi_retry·"·"Guest·device·at·0x%x·asked·%u,·have·only·%u"·"\n",

536

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

536

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

537

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

537

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

538

·····················,·config_addr,·req_num,·max_irqs);

538

·····················,·config_addr,·req_num,·max_irqs);

539

#line·541·"trace/trace-hw_ppc.h"

539

#line·541·"trace/trace-hw_ppc.h"

540

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

540

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

542

············qemu_log("spapr_pci_msi_retry·"·"Guest·device·at·0x%x·asked·%u,·have·only·%u"·"\n",·config_addr,·req_num,·max_irqs);

542

············qemu_log("spapr_pci_msi_retry·"·"Guest·device·at·0x%x·asked·%u,·have·only·%u"·"\n",·config_addr,·req_num,·max_irqs);

543

#line·545·"trace/trace-hw_ppc.h"

543

#line·545·"trace/trace-hw_ppc.h"

544

········}

544

········}

545

····}

545

····}

546

}

546

}

547

static·inline·void·trace_spapr_pci_msi_retry(unsigned·config_addr,·unsigned·req_num,·unsigned·max_irqs)

547

static·inline·void·trace_spapr_pci_msi_retry(unsigned·config_addr,·unsigned·req_num,·unsigned·max_irqs)

559

static·inline·void·_nocheck__trace_spapr_cas_continue(unsigned·long·n)

559

static·inline·void·_nocheck__trace_spapr_cas_continue(unsigned·long·n)

560

{

560

{

561

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

561

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

562

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

562

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

563

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

563

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

564

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

564

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

566

············qemu_log("%d@%zu.%06zu:spapr_cas_continue·"·"Copy·changes·to·the·guest:·%ld·bytes"·"\n",

566

············qemu_log("%d@%zu.%06zu:spapr_cas_continue·"·"Copy·changes·to·the·guest:·%ld·bytes"·"\n",

567

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

567

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

568

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

568

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

569

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

569

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

570

#line·572·"trace/trace-hw_ppc.h"

570

#line·572·"trace/trace-hw_ppc.h"

571

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

571

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

573

············qemu_log("spapr_cas_continue·"·"Copy·changes·to·the·guest:·%ld·bytes"·"\n",·n);

573

············qemu_log("spapr_cas_continue·"·"Copy·changes·to·the·guest:·%ld·bytes"·"\n",·n);

574

#line·576·"trace/trace-hw_ppc.h"

574

#line·576·"trace/trace-hw_ppc.h"

575

········}

575

········}

576

····}

576

····}

577

}

577

}

578

static·inline·void·trace_spapr_cas_continue(unsigned·long·n)

578

static·inline·void·trace_spapr_cas_continue(unsigned·long·n)

590

static·inline·void·_nocheck__trace_spapr_cas_pvr(uint32_t·cur_pvr,·bool·explicit_match,·uint32_t·new_pvr)

590

static·inline·void·_nocheck__trace_spapr_cas_pvr(uint32_t·cur_pvr,·bool·explicit_match,·uint32_t·new_pvr)

591

{

591

{

592

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

592

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

593

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

593

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

594

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

594

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

595

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

595

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

597

············qemu_log("%d@%zu.%06zu:spapr_cas_pvr·"·"current=0x%x,·explicit_match=%u,·new=0x%x"·"\n",

597

············qemu_log("%d@%zu.%06zu:spapr_cas_pvr·"·"current=0x%x,·explicit_match=%u,·new=0x%x"·"\n",

598

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

598

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

599

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

599

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

600

·····················,·cur_pvr,·explicit_match,·new_pvr);

600

·····················,·cur_pvr,·explicit_match,·new_pvr);

601

#line·603·"trace/trace-hw_ppc.h"

601

#line·603·"trace/trace-hw_ppc.h"

602

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

602

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

604

············qemu_log("spapr_cas_pvr·"·"current=0x%x,·explicit_match=%u,·new=0x%x"·"\n",·cur_pvr,·explicit_match,·new_pvr);

604

············qemu_log("spapr_cas_pvr·"·"current=0x%x,·explicit_match=%u,·new=0x%x"·"\n",·cur_pvr,·explicit_match,·new_pvr);

605

#line·607·"trace/trace-hw_ppc.h"

605

#line·607·"trace/trace-hw_ppc.h"

606

········}

606

········}

607

····}

607

····}

608

}

608

}

609

static·inline·void·trace_spapr_cas_pvr(uint32_t·cur_pvr,·bool·explicit_match,·uint32_t·new_pvr)

609

static·inline·void·trace_spapr_cas_pvr(uint32_t·cur_pvr,·bool·explicit_match,·uint32_t·new_pvr)

621

static·inline·void·_nocheck__trace_spapr_h_resize_hpt_prepare(uint64_t·flags,·uint64_t·shift)

621

static·inline·void·_nocheck__trace_spapr_h_resize_hpt_prepare(uint64_t·flags,·uint64_t·shift)

622

{

622

{

623

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

623

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

624

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

624

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

625

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

625

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

626

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

626

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

628

············qemu_log("%d@%zu.%06zu:spapr_h_resize_hpt_prepare·"·"flags=0x%"PRIx64",·shift=%"PRIu64·"\n",

628

············qemu_log("%d@%zu.%06zu:spapr_h_resize_hpt_prepare·"·"flags=0x%"PRIx64",·shift=%"PRIu64·"\n",

629

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

629

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

630

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

630

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

631

·····················,·flags,·shift);

631

·····················,·flags,·shift);

632

#line·634·"trace/trace-hw_ppc.h"

632

#line·634·"trace/trace-hw_ppc.h"

633

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

633

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

635

············qemu_log("spapr_h_resize_hpt_prepare·"·"flags=0x%"PRIx64",·shift=%"PRIu64·"\n",·flags,·shift);

635

············qemu_log("spapr_h_resize_hpt_prepare·"·"flags=0x%"PRIx64",·shift=%"PRIu64·"\n",·flags,·shift);

636

#line·638·"trace/trace-hw_ppc.h"

636

#line·638·"trace/trace-hw_ppc.h"

637

········}

637

········}

638

····}

638

····}

639

}

639

}

640

static·inline·void·trace_spapr_h_resize_hpt_prepare(uint64_t·flags,·uint64_t·shift)

640

static·inline·void·trace_spapr_h_resize_hpt_prepare(uint64_t·flags,·uint64_t·shift)

652

static·inline·void·_nocheck__trace_spapr_h_resize_hpt_commit(uint64_t·flags,·uint64_t·shift)

652

static·inline·void·_nocheck__trace_spapr_h_resize_hpt_commit(uint64_t·flags,·uint64_t·shift)

653

{

653

{

654

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

654

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

655

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

655

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

656

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

656

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

657

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

657

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

659

············qemu_log("%d@%zu.%06zu:spapr_h_resize_hpt_commit·"·"flags=0x%"PRIx64",·shift=%"PRIu64·"\n",

659

············qemu_log("%d@%zu.%06zu:spapr_h_resize_hpt_commit·"·"flags=0x%"PRIx64",·shift=%"PRIu64·"\n",

660

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

660

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

661

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

661

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

662

·····················,·flags,·shift);

662

·····················,·flags,·shift);

663

#line·665·"trace/trace-hw_ppc.h"

663

#line·665·"trace/trace-hw_ppc.h"

664

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

664

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

666

············qemu_log("spapr_h_resize_hpt_commit·"·"flags=0x%"PRIx64",·shift=%"PRIu64·"\n",·flags,·shift);

666

············qemu_log("spapr_h_resize_hpt_commit·"·"flags=0x%"PRIx64",·shift=%"PRIu64·"\n",·flags,·shift);

667

#line·669·"trace/trace-hw_ppc.h"

667

#line·669·"trace/trace-hw_ppc.h"

668

········}

668

········}

669

····}

669

····}

670

}

670

}

671

static·inline·void·trace_spapr_h_resize_hpt_commit(uint64_t·flags,·uint64_t·shift)

671

static·inline·void·trace_spapr_h_resize_hpt_commit(uint64_t·flags,·uint64_t·shift)

683

static·inline·void·_nocheck__trace_spapr_update_dt(unsigned·cb)

683

static·inline·void·_nocheck__trace_spapr_update_dt(unsigned·cb)

684

{

684

{

685

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

685

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

686

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

686

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

687

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

687

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

688

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

688

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

690

············qemu_log("%d@%zu.%06zu:spapr_update_dt·"·"New·blob·%u·bytes"·"\n",

690

············qemu_log("%d@%zu.%06zu:spapr_update_dt·"·"New·blob·%u·bytes"·"\n",

691

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

691

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

692

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

692

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

693

·····················,·cb);

693

·····················,·cb);

694

#line·696·"trace/trace-hw_ppc.h"

694

#line·696·"trace/trace-hw_ppc.h"

695

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

695

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

697

············qemu_log("spapr_update_dt·"·"New·blob·%u·bytes"·"\n",·cb);

697

············qemu_log("spapr_update_dt·"·"New·blob·%u·bytes"·"\n",·cb);

698

#line·700·"trace/trace-hw_ppc.h"

698

#line·700·"trace/trace-hw_ppc.h"

699

········}

699

········}

700

····}

700

····}

701

}

701

}

702

static·inline·void·trace_spapr_update_dt(unsigned·cb)

702

static·inline·void·trace_spapr_update_dt(unsigned·cb)

714

static·inline·void·_nocheck__trace_spapr_update_dt_failed_size(unsigned·cbold,·unsigned·cbnew,·unsigned·magic)

714

static·inline·void·_nocheck__trace_spapr_update_dt_failed_size(unsigned·cbold,·unsigned·cbnew,·unsigned·magic)

715

{

715

{

716

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

716

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

717

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

717

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

718

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

718

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

719

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

719

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

721

············qemu_log("%d@%zu.%06zu:spapr_update_dt_failed_size·"·"Old·blob·%u·bytes,·new·blob·%u·bytes,·magic·0x%x"·"\n",

721

············qemu_log("%d@%zu.%06zu:spapr_update_dt_failed_size·"·"Old·blob·%u·bytes,·new·blob·%u·bytes,·magic·0x%x"·"\n",

722

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

722

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

723

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

723

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

724

·····················,·cbold,·cbnew,·magic);

724

·····················,·cbold,·cbnew,·magic);

725

#line·727·"trace/trace-hw_ppc.h"

725

#line·727·"trace/trace-hw_ppc.h"

726

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

726

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

728

············qemu_log("spapr_update_dt_failed_size·"·"Old·blob·%u·bytes,·new·blob·%u·bytes,·magic·0x%x"·"\n",·cbold,·cbnew,·magic);

728

············qemu_log("spapr_update_dt_failed_size·"·"Old·blob·%u·bytes,·new·blob·%u·bytes,·magic·0x%x"·"\n",·cbold,·cbnew,·magic);

729

#line·731·"trace/trace-hw_ppc.h"

729

#line·731·"trace/trace-hw_ppc.h"

730

········}

730

········}

731

····}

731

····}

732

}

732

}

733

static·inline·void·trace_spapr_update_dt_failed_size(unsigned·cbold,·unsigned·cbnew,·unsigned·magic)

733

static·inline·void·trace_spapr_update_dt_failed_size(unsigned·cbold,·unsigned·cbnew,·unsigned·magic)

745

static·inline·void·_nocheck__trace_spapr_update_dt_failed_check(unsigned·cbold,·unsigned·cbnew,·unsigned·magic)

745

static·inline·void·_nocheck__trace_spapr_update_dt_failed_check(unsigned·cbold,·unsigned·cbnew,·unsigned·magic)

746

{

746

{

747

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

747

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

748

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

748

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

749

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

749

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

750

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

750

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

752

············qemu_log("%d@%zu.%06zu:spapr_update_dt_failed_check·"·"Old·blob·%u·bytes,·new·blob·%u·bytes,·magic·0x%x"·"\n",

752

············qemu_log("%d@%zu.%06zu:spapr_update_dt_failed_check·"·"Old·blob·%u·bytes,·new·blob·%u·bytes,·magic·0x%x"·"\n",

753

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

753

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

754

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

754

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

755

·····················,·cbold,·cbnew,·magic);

755

·····················,·cbold,·cbnew,·magic);

756

#line·758·"trace/trace-hw_ppc.h"

756

#line·758·"trace/trace-hw_ppc.h"

757

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

757

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

759

············qemu_log("spapr_update_dt_failed_check·"·"Old·blob·%u·bytes,·new·blob·%u·bytes,·magic·0x%x"·"\n",·cbold,·cbnew,·magic);

759

············qemu_log("spapr_update_dt_failed_check·"·"Old·blob·%u·bytes,·new·blob·%u·bytes,·magic·0x%x"·"\n",·cbold,·cbnew,·magic);

760

#line·762·"trace/trace-hw_ppc.h"

760

#line·762·"trace/trace-hw_ppc.h"

761

········}

761

········}

762

····}

762

····}

763

}

763

}

764

static·inline·void·trace_spapr_update_dt_failed_check(unsigned·cbold,·unsigned·cbnew,·unsigned·magic)

764

static·inline·void·trace_spapr_update_dt_failed_check(unsigned·cbold,·unsigned·cbnew,·unsigned·magic)

776

static·inline·void·_nocheck__trace_spapr_h_tpm_comm(const·char·*·device_path,·uint64_t·operation)

776

static·inline·void·_nocheck__trace_spapr_h_tpm_comm(const·char·*·device_path,·uint64_t·operation)

777

{

777

{

778

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

778

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

779

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

779

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

780

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

780

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

781

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

781

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

783

············qemu_log("%d@%zu.%06zu:spapr_h_tpm_comm·"·"tpm_device_path=%s·operation=0x%"PRIx64·"\n",

783

············qemu_log("%d@%zu.%06zu:spapr_h_tpm_comm·"·"tpm_device_path=%s·operation=0x%"PRIx64·"\n",

784

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

784

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

785

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

785

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

786

·····················,·device_path,·operation);

786

·····················,·device_path,·operation);

787

#line·789·"trace/trace-hw_ppc.h"

787

#line·789·"trace/trace-hw_ppc.h"

788

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

788

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

790

············qemu_log("spapr_h_tpm_comm·"·"tpm_device_path=%s·operation=0x%"PRIx64·"\n",·device_path,·operation);

790

············qemu_log("spapr_h_tpm_comm·"·"tpm_device_path=%s·operation=0x%"PRIx64·"\n",·device_path,·operation);

791

#line·793·"trace/trace-hw_ppc.h"

791

#line·793·"trace/trace-hw_ppc.h"

792

········}

792

········}

793

····}

793

····}

794

}

794

}

795

static·inline·void·trace_spapr_h_tpm_comm(const·char·*·device_path,·uint64_t·operation)

795

static·inline·void·trace_spapr_h_tpm_comm(const·char·*·device_path,·uint64_t·operation)

807

static·inline·void·_nocheck__trace_spapr_tpm_execute(uint64_t·data_in,·uint64_t·data_in_sz,·uint64_t·data_out,·uint64_t·data_out_sz)

807

static·inline·void·_nocheck__trace_spapr_tpm_execute(uint64_t·data_in,·uint64_t·data_in_sz,·uint64_t·data_out,·uint64_t·data_out_sz)

808

{

808

{

809

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

809

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

810

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

810

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

811

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

811

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

812

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

812

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

814

············qemu_log("%d@%zu.%06zu:spapr_tpm_execute·"·"data_in=0x%"PRIx64",·data_in_sz=%"PRIu64",·data_out=0x%"PRIx64",·data_out_sz=%"PRIu64·"\n",

814

············qemu_log("%d@%zu.%06zu:spapr_tpm_execute·"·"data_in=0x%"PRIx64",·data_in_sz=%"PRIu64",·data_out=0x%"PRIx64",·data_out_sz=%"PRIu64·"\n",

815

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

815

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

816

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

816

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

817

·····················,·data_in,·data_in_sz,·data_out,·data_out_sz);

817

·····················,·data_in,·data_in_sz,·data_out,·data_out_sz);

818

#line·820·"trace/trace-hw_ppc.h"

818

#line·820·"trace/trace-hw_ppc.h"

819

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

819

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

821

············qemu_log("spapr_tpm_execute·"·"data_in=0x%"PRIx64",·data_in_sz=%"PRIu64",·data_out=0x%"PRIx64",·data_out_sz=%"PRIu64·"\n",·data_in,·data_in_sz,·data_out,·data_out_sz);

821

············qemu_log("spapr_tpm_execute·"·"data_in=0x%"PRIx64",·data_in_sz=%"PRIu64",·data_out=0x%"PRIx64",·data_out_sz=%"PRIu64·"\n",·data_in,·data_in_sz,·data_out,·data_out_sz);

822

#line·824·"trace/trace-hw_ppc.h"

822

#line·824·"trace/trace-hw_ppc.h"

823

········}

823

········}

824

····}

824

····}

825

}

825

}

826

static·inline·void·trace_spapr_tpm_execute(uint64_t·data_in,·uint64_t·data_in_sz,·uint64_t·data_out,·uint64_t·data_out_sz)

826

static·inline·void·trace_spapr_tpm_execute(uint64_t·data_in,·uint64_t·data_in_sz,·uint64_t·data_out,·uint64_t·data_out_sz)

838

static·inline·void·_nocheck__trace_spapr_iommu_put(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce,·uint64_t·ret)

838

static·inline·void·_nocheck__trace_spapr_iommu_put(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce,·uint64_t·ret)

839

{

839

{

840

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

840

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

841

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

841

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

842

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

842

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

843

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

843

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

845

············qemu_log("%d@%zu.%06zu:spapr_iommu_put·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·tce=0x%"PRIx64"·ret=%"PRId64·"\n",

845

············qemu_log("%d@%zu.%06zu:spapr_iommu_put·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·tce=0x%"PRIx64"·ret=%"PRId64·"\n",

846

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

846

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

847

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

847

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

848

·····················,·liobn,·ioba,·tce,·ret);

848

·····················,·liobn,·ioba,·tce,·ret);

849

#line·851·"trace/trace-hw_ppc.h"

849

#line·851·"trace/trace-hw_ppc.h"

850

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

850

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

852

············qemu_log("spapr_iommu_put·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·tce=0x%"PRIx64"·ret=%"PRId64·"\n",·liobn,·ioba,·tce,·ret);

852

············qemu_log("spapr_iommu_put·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·tce=0x%"PRIx64"·ret=%"PRId64·"\n",·liobn,·ioba,·tce,·ret);

853

#line·855·"trace/trace-hw_ppc.h"

853

#line·855·"trace/trace-hw_ppc.h"

854

········}

854

········}

855

····}

855

····}

856

}

856

}

857

static·inline·void·trace_spapr_iommu_put(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce,·uint64_t·ret)

857

static·inline·void·trace_spapr_iommu_put(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce,·uint64_t·ret)

869

static·inline·void·_nocheck__trace_spapr_iommu_get(uint64_t·liobn,·uint64_t·ioba,·uint64_t·ret,·uint64_t·tce)

869

static·inline·void·_nocheck__trace_spapr_iommu_get(uint64_t·liobn,·uint64_t·ioba,·uint64_t·ret,·uint64_t·tce)

870

{

870

{

871

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

871

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

872

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

872

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

873

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

873

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

874

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

874

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

876

············qemu_log("%d@%zu.%06zu:spapr_iommu_get·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·ret=%"PRId64"·tce=0x%"PRIx64·"\n",

876

············qemu_log("%d@%zu.%06zu:spapr_iommu_get·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·ret=%"PRId64"·tce=0x%"PRIx64·"\n",

877

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

877

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

878

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

878

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

879

·····················,·liobn,·ioba,·ret,·tce);

879

·····················,·liobn,·ioba,·ret,·tce);

880

#line·882·"trace/trace-hw_ppc.h"

880

#line·882·"trace/trace-hw_ppc.h"

881

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

881

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

883

············qemu_log("spapr_iommu_get·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·ret=%"PRId64"·tce=0x%"PRIx64·"\n",·liobn,·ioba,·ret,·tce);

883

············qemu_log("spapr_iommu_get·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·ret=%"PRId64"·tce=0x%"PRIx64·"\n",·liobn,·ioba,·ret,·tce);

884

#line·886·"trace/trace-hw_ppc.h"

884

#line·886·"trace/trace-hw_ppc.h"

885

········}

885

········}

886

····}

886

····}

887

}

887

}

888

static·inline·void·trace_spapr_iommu_get(uint64_t·liobn,·uint64_t·ioba,·uint64_t·ret,·uint64_t·tce)

888

static·inline·void·trace_spapr_iommu_get(uint64_t·liobn,·uint64_t·ioba,·uint64_t·ret,·uint64_t·tce)

900

static·inline·void·_nocheck__trace_spapr_iommu_indirect(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce,·uint64_t·iobaN,·uint64_t·tceN,·uint64_t·ret)

900

static·inline·void·_nocheck__trace_spapr_iommu_indirect(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce,·uint64_t·iobaN,·uint64_t·tceN,·uint64_t·ret)

901

{

901

{

902

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

902

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

903

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

903

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

904

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

904

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

905

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

905

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

907

············qemu_log("%d@%zu.%06zu:spapr_iommu_indirect·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·tcelist=0x%"PRIx64"·iobaN=0x%"PRIx64"·tceN=0x%"PRIx64"·ret=%"PRId64·"\n",

907

············qemu_log("%d@%zu.%06zu:spapr_iommu_indirect·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·tcelist=0x%"PRIx64"·iobaN=0x%"PRIx64"·tceN=0x%"PRIx64"·ret=%"PRId64·"\n",

908

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

908

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

909

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

909

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

910

·····················,·liobn,·ioba,·tce,·iobaN,·tceN,·ret);

910

·····················,·liobn,·ioba,·tce,·iobaN,·tceN,·ret);

911

#line·913·"trace/trace-hw_ppc.h"

911

#line·913·"trace/trace-hw_ppc.h"

912

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

912

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

914

············qemu_log("spapr_iommu_indirect·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·tcelist=0x%"PRIx64"·iobaN=0x%"PRIx64"·tceN=0x%"PRIx64"·ret=%"PRId64·"\n",·liobn,·ioba,·tce,·iobaN,·tceN,·ret);

914

············qemu_log("spapr_iommu_indirect·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·tcelist=0x%"PRIx64"·iobaN=0x%"PRIx64"·tceN=0x%"PRIx64"·ret=%"PRId64·"\n",·liobn,·ioba,·tce,·iobaN,·tceN,·ret);

915

#line·917·"trace/trace-hw_ppc.h"

915

#line·917·"trace/trace-hw_ppc.h"

916

········}

916

········}

917

····}

917

····}

918

}

918

}

919

static·inline·void·trace_spapr_iommu_indirect(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce,·uint64_t·iobaN,·uint64_t·tceN,·uint64_t·ret)

919

static·inline·void·trace_spapr_iommu_indirect(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce,·uint64_t·iobaN,·uint64_t·tceN,·uint64_t·ret)

931

static·inline·void·_nocheck__trace_spapr_iommu_stuff(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce_value,·uint64_t·npages,·uint64_t·ret)

931

static·inline·void·_nocheck__trace_spapr_iommu_stuff(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce_value,·uint64_t·npages,·uint64_t·ret)

932

{

932

{

933

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

933

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

934

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

934

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

935

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

935

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

936

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

936

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

938

············qemu_log("%d@%zu.%06zu:spapr_iommu_stuff·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·tcevalue=0x%"PRIx64"·npages=%"PRId64"·ret=%"PRId64·"\n",

938

············qemu_log("%d@%zu.%06zu:spapr_iommu_stuff·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·tcevalue=0x%"PRIx64"·npages=%"PRId64"·ret=%"PRId64·"\n",

939

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

939

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

940

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

940

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

941

·····················,·liobn,·ioba,·tce_value,·npages,·ret);

941

·····················,·liobn,·ioba,·tce_value,·npages,·ret);

942

#line·944·"trace/trace-hw_ppc.h"

942

#line·944·"trace/trace-hw_ppc.h"

943

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

943

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

945

············qemu_log("spapr_iommu_stuff·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·tcevalue=0x%"PRIx64"·npages=%"PRId64"·ret=%"PRId64·"\n",·liobn,·ioba,·tce_value,·npages,·ret);

945

············qemu_log("spapr_iommu_stuff·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·tcevalue=0x%"PRIx64"·npages=%"PRId64"·ret=%"PRId64·"\n",·liobn,·ioba,·tce_value,·npages,·ret);

946

#line·948·"trace/trace-hw_ppc.h"

946

#line·948·"trace/trace-hw_ppc.h"

947

········}

947

········}

948

····}

948

····}

949

}

949

}

950

static·inline·void·trace_spapr_iommu_stuff(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce_value,·uint64_t·npages,·uint64_t·ret)

950

static·inline·void·trace_spapr_iommu_stuff(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce_value,·uint64_t·npages,·uint64_t·ret)

962

static·inline·void·_nocheck__trace_spapr_iommu_pci_put(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce,·uint64_t·ret)

962

static·inline·void·_nocheck__trace_spapr_iommu_pci_put(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce,·uint64_t·ret)

963

{

963

{

964

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

964

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

965

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

965

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

966

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

966

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

967

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

967

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

969

············qemu_log("%d@%zu.%06zu:spapr_iommu_pci_put·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·tce=0x%"PRIx64"·ret=%"PRId64·"\n",

969

············qemu_log("%d@%zu.%06zu:spapr_iommu_pci_put·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·tce=0x%"PRIx64"·ret=%"PRId64·"\n",

970

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

970

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

971

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

971

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

972

·····················,·liobn,·ioba,·tce,·ret);

972

·····················,·liobn,·ioba,·tce,·ret);

973

#line·975·"trace/trace-hw_ppc.h"

973

#line·975·"trace/trace-hw_ppc.h"

974

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

974

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

976

············qemu_log("spapr_iommu_pci_put·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·tce=0x%"PRIx64"·ret=%"PRId64·"\n",·liobn,·ioba,·tce,·ret);

976

············qemu_log("spapr_iommu_pci_put·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·tce=0x%"PRIx64"·ret=%"PRId64·"\n",·liobn,·ioba,·tce,·ret);

977

#line·979·"trace/trace-hw_ppc.h"

977

#line·979·"trace/trace-hw_ppc.h"

978

········}

978

········}

979

····}

979

····}

980

}

980

}

981

static·inline·void·trace_spapr_iommu_pci_put(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce,·uint64_t·ret)

981

static·inline·void·trace_spapr_iommu_pci_put(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce,·uint64_t·ret)

993

static·inline·void·_nocheck__trace_spapr_iommu_pci_get(uint64_t·liobn,·uint64_t·ioba,·uint64_t·ret,·uint64_t·tce)

993

static·inline·void·_nocheck__trace_spapr_iommu_pci_get(uint64_t·liobn,·uint64_t·ioba,·uint64_t·ret,·uint64_t·tce)

994

{

994

{

995

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

995

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

996

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

996

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

997

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

997

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

998

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

998

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

1000

············qemu_log("%d@%zu.%06zu:spapr_iommu_pci_get·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·ret=%"PRId64"·tce=0x%"PRIx64·"\n",

1000

············qemu_log("%d@%zu.%06zu:spapr_iommu_pci_get·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·ret=%"PRId64"·tce=0x%"PRIx64·"\n",

1001

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

1001

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

1002

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

1002

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

1003

·····················,·liobn,·ioba,·ret,·tce);

1003

·····················,·liobn,·ioba,·ret,·tce);

1004

#line·1006·"trace/trace-hw_ppc.h"

1004

#line·1006·"trace/trace-hw_ppc.h"

1005

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

1005

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

1007

············qemu_log("spapr_iommu_pci_get·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·ret=%"PRId64"·tce=0x%"PRIx64·"\n",·liobn,·ioba,·ret,·tce);

1007

············qemu_log("spapr_iommu_pci_get·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·ret=%"PRId64"·tce=0x%"PRIx64·"\n",·liobn,·ioba,·ret,·tce);

1008

#line·1010·"trace/trace-hw_ppc.h"

1008

#line·1010·"trace/trace-hw_ppc.h"

1009

········}

1009

········}

1010

····}

1010

····}

1011

}

1011

}

1012

static·inline·void·trace_spapr_iommu_pci_get(uint64_t·liobn,·uint64_t·ioba,·uint64_t·ret,·uint64_t·tce)

1012

static·inline·void·trace_spapr_iommu_pci_get(uint64_t·liobn,·uint64_t·ioba,·uint64_t·ret,·uint64_t·tce)

1024

static·inline·void·_nocheck__trace_spapr_iommu_pci_indirect(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce,·uint64_t·iobaN,·uint64_t·tceN,·uint64_t·ret)

1024

static·inline·void·_nocheck__trace_spapr_iommu_pci_indirect(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce,·uint64_t·iobaN,·uint64_t·tceN,·uint64_t·ret)

1025

{

1025

{

1026

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

1026

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

1027

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

1027

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

1028

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

1028

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

1029

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

1029

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

1031

············qemu_log("%d@%zu.%06zu:spapr_iommu_pci_indirect·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·tcelist=0x%"PRIx64"·iobaN=0x%"PRIx64"·tceN=0x%"PRIx64"·ret=%"PRId64·"\n",

1031

············qemu_log("%d@%zu.%06zu:spapr_iommu_pci_indirect·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·tcelist=0x%"PRIx64"·iobaN=0x%"PRIx64"·tceN=0x%"PRIx64"·ret=%"PRId64·"\n",

1032

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

1032

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

1033

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

1033

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

1034

·····················,·liobn,·ioba,·tce,·iobaN,·tceN,·ret);

1034

·····················,·liobn,·ioba,·tce,·iobaN,·tceN,·ret);

1035

#line·1037·"trace/trace-hw_ppc.h"

1035

#line·1037·"trace/trace-hw_ppc.h"

1036

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

1036

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

1038

············qemu_log("spapr_iommu_pci_indirect·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·tcelist=0x%"PRIx64"·iobaN=0x%"PRIx64"·tceN=0x%"PRIx64"·ret=%"PRId64·"\n",·liobn,·ioba,·tce,·iobaN,·tceN,·ret);

1038

············qemu_log("spapr_iommu_pci_indirect·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·tcelist=0x%"PRIx64"·iobaN=0x%"PRIx64"·tceN=0x%"PRIx64"·ret=%"PRId64·"\n",·liobn,·ioba,·tce,·iobaN,·tceN,·ret);

1039

#line·1041·"trace/trace-hw_ppc.h"

1039

#line·1041·"trace/trace-hw_ppc.h"

1040

········}

1040

········}

1041

····}

1041

····}

1042

}

1042

}

1043

static·inline·void·trace_spapr_iommu_pci_indirect(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce,·uint64_t·iobaN,·uint64_t·tceN,·uint64_t·ret)

1043

static·inline·void·trace_spapr_iommu_pci_indirect(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce,·uint64_t·iobaN,·uint64_t·tceN,·uint64_t·ret)

1055

static·inline·void·_nocheck__trace_spapr_iommu_pci_stuff(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce_value,·uint64_t·npages,·uint64_t·ret)

1055

static·inline·void·_nocheck__trace_spapr_iommu_pci_stuff(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce_value,·uint64_t·npages,·uint64_t·ret)

1056

{

1056

{

1057

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

1057

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

1058

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

1058

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

1059

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

1059

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

1060

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

1060

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

1062

············qemu_log("%d@%zu.%06zu:spapr_iommu_pci_stuff·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·tcevalue=0x%"PRIx64"·npages=%"PRId64"·ret=%"PRId64·"\n",

1062

············qemu_log("%d@%zu.%06zu:spapr_iommu_pci_stuff·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·tcevalue=0x%"PRIx64"·npages=%"PRId64"·ret=%"PRId64·"\n",

1063

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

1063

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

1064

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

1064

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

1065

·····················,·liobn,·ioba,·tce_value,·npages,·ret);

1065

·····················,·liobn,·ioba,·tce_value,·npages,·ret);

1066

#line·1068·"trace/trace-hw_ppc.h"

1066

#line·1068·"trace/trace-hw_ppc.h"

1067

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

1067

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

1069

············qemu_log("spapr_iommu_pci_stuff·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·tcevalue=0x%"PRIx64"·npages=%"PRId64"·ret=%"PRId64·"\n",·liobn,·ioba,·tce_value,·npages,·ret);

1069

············qemu_log("spapr_iommu_pci_stuff·"·"liobn=0x%"PRIx64"·ioba=0x%"PRIx64"·tcevalue=0x%"PRIx64"·npages=%"PRId64"·ret=%"PRId64·"\n",·liobn,·ioba,·tce_value,·npages,·ret);

1070

#line·1072·"trace/trace-hw_ppc.h"

1070

#line·1072·"trace/trace-hw_ppc.h"

1071

········}

1071

········}

1072

····}

1072

····}

1073

}

1073

}

1074

static·inline·void·trace_spapr_iommu_pci_stuff(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce_value,·uint64_t·npages,·uint64_t·ret)

1074

static·inline·void·trace_spapr_iommu_pci_stuff(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce_value,·uint64_t·npages,·uint64_t·ret)

1086

static·inline·void·_nocheck__trace_spapr_iommu_xlate(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce,·unsigned·perm,·unsigned·pgsize)

1086

static·inline·void·_nocheck__trace_spapr_iommu_xlate(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce,·unsigned·perm,·unsigned·pgsize)

1087

{

1087

{

1088

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

1088

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

1089

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

1089

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

1090

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

1090

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

1091

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

1091

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

1093

············qemu_log("%d@%zu.%06zu:spapr_iommu_xlate·"·"liobn=0x%"PRIx64"·0x%"PRIx64"·->·0x%"PRIx64"·perm=%u·mask=0x%x"·"\n",

1093

············qemu_log("%d@%zu.%06zu:spapr_iommu_xlate·"·"liobn=0x%"PRIx64"·0x%"PRIx64"·->·0x%"PRIx64"·perm=%u·mask=0x%x"·"\n",

1094

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

1094

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

1095

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

1095

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

1096

·····················,·liobn,·ioba,·tce,·perm,·pgsize);

1096

·····················,·liobn,·ioba,·tce,·perm,·pgsize);

1097

#line·1099·"trace/trace-hw_ppc.h"

1097

#line·1099·"trace/trace-hw_ppc.h"

1098

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

1098

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

1100

············qemu_log("spapr_iommu_xlate·"·"liobn=0x%"PRIx64"·0x%"PRIx64"·->·0x%"PRIx64"·perm=%u·mask=0x%x"·"\n",·liobn,·ioba,·tce,·perm,·pgsize);

1100

············qemu_log("spapr_iommu_xlate·"·"liobn=0x%"PRIx64"·0x%"PRIx64"·->·0x%"PRIx64"·perm=%u·mask=0x%x"·"\n",·liobn,·ioba,·tce,·perm,·pgsize);

1101

#line·1103·"trace/trace-hw_ppc.h"

1101

#line·1103·"trace/trace-hw_ppc.h"

1102

········}

1102

········}

1103

····}

1103

····}

1104

}

1104

}

1105

static·inline·void·trace_spapr_iommu_xlate(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce,·unsigned·perm,·unsigned·pgsize)

1105

static·inline·void·trace_spapr_iommu_xlate(uint64_t·liobn,·uint64_t·ioba,·uint64_t·tce,·unsigned·perm,·unsigned·pgsize)

1117

static·inline·void·_nocheck__trace_spapr_iommu_new_table(uint64_t·liobn,·void·*·table,·int·fd)

1117

static·inline·void·_nocheck__trace_spapr_iommu_new_table(uint64_t·liobn,·void·*·table,·int·fd)

1118

{

1118

{

1119

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

1119

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

1120

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

1120

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

1121

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

1121

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

1122

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

1122

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

1124

············qemu_log("%d@%zu.%06zu:spapr_iommu_new_table·"·"liobn=0x%"PRIx64"·table=%p·fd=%d"·"\n",

1124

············qemu_log("%d@%zu.%06zu:spapr_iommu_new_table·"·"liobn=0x%"PRIx64"·table=%p·fd=%d"·"\n",

1125

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

1125

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

1126

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

1126

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

1127

·····················,·liobn,·table,·fd);

1127

·····················,·liobn,·table,·fd);

1128

#line·1130·"trace/trace-hw_ppc.h"

1128

#line·1130·"trace/trace-hw_ppc.h"

1129

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

1129

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

1131

············qemu_log("spapr_iommu_new_table·"·"liobn=0x%"PRIx64"·table=%p·fd=%d"·"\n",·liobn,·table,·fd);

1131

············qemu_log("spapr_iommu_new_table·"·"liobn=0x%"PRIx64"·table=%p·fd=%d"·"\n",·liobn,·table,·fd);

1132

#line·1134·"trace/trace-hw_ppc.h"

1132

#line·1134·"trace/trace-hw_ppc.h"

1133

········}

1133

········}

1134

····}

1134

····}

1135

}

1135

}

1136

static·inline·void·trace_spapr_iommu_new_table(uint64_t·liobn,·void·*·table,·int·fd)

1136

static·inline·void·trace_spapr_iommu_new_table(uint64_t·liobn,·void·*·table,·int·fd)

1148

static·inline·void·_nocheck__trace_spapr_iommu_pre_save(uint64_t·liobn,·uint32_t·nb,·uint64_t·offs,·uint32_t·ps)

1148

static·inline·void·_nocheck__trace_spapr_iommu_pre_save(uint64_t·liobn,·uint32_t·nb,·uint64_t·offs,·uint32_t·ps)

1149

{

1149

{

1150

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

1150

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

1151

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

1151

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

1152

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

1152

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

1153

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

1153

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

1155

············qemu_log("%d@%zu.%06zu:spapr_iommu_pre_save·"·"liobn=%"PRIx64"·%"PRIx32"·bus_offset=0x%"PRIx64"·ps=%"PRIu32·"\n",

1155

············qemu_log("%d@%zu.%06zu:spapr_iommu_pre_save·"·"liobn=%"PRIx64"·%"PRIx32"·bus_offset=0x%"PRIx64"·ps=%"PRIu32·"\n",

1156

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

1156

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

1157

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

1157

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

1158

·····················,·liobn,·nb,·offs,·ps);

1158

·····················,·liobn,·nb,·offs,·ps);

1159

#line·1161·"trace/trace-hw_ppc.h"

1159

#line·1161·"trace/trace-hw_ppc.h"

1160

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

1160

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

1162

············qemu_log("spapr_iommu_pre_save·"·"liobn=%"PRIx64"·%"PRIx32"·bus_offset=0x%"PRIx64"·ps=%"PRIu32·"\n",·liobn,·nb,·offs,·ps);

1162

············qemu_log("spapr_iommu_pre_save·"·"liobn=%"PRIx64"·%"PRIx32"·bus_offset=0x%"PRIx64"·ps=%"PRIu32·"\n",·liobn,·nb,·offs,·ps);

1163

#line·1165·"trace/trace-hw_ppc.h"

1163

#line·1165·"trace/trace-hw_ppc.h"

1164

········}

1164

········}

1165

····}

1165

····}

1166

}

1166

}

1167

static·inline·void·trace_spapr_iommu_pre_save(uint64_t·liobn,·uint32_t·nb,·uint64_t·offs,·uint32_t·ps)

1167

static·inline·void·trace_spapr_iommu_pre_save(uint64_t·liobn,·uint32_t·nb,·uint64_t·offs,·uint32_t·ps)

1179

static·inline·void·_nocheck__trace_spapr_iommu_post_load(uint64_t·liobn,·uint32_t·pre_nb,·uint32_t·post_nb,·uint64_t·offs,·uint32_t·ps)

1179

static·inline·void·_nocheck__trace_spapr_iommu_post_load(uint64_t·liobn,·uint32_t·pre_nb,·uint32_t·post_nb,·uint64_t·offs,·uint32_t·ps)

1180

{

1180

{

1181

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

1181

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

1182

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

1182

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

1183

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

1183

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

1184

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

1184

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

1186

············qemu_log("%d@%zu.%06zu:spapr_iommu_post_load·"·"liobn=%"PRIx64"·%"PRIx32"·=>·0x%"PRIx32"·bus_offset=0x%"PRIx64"·ps=%"PRIu32·"\n",

1186

············qemu_log("%d@%zu.%06zu:spapr_iommu_post_load·"·"liobn=%"PRIx64"·%"PRIx32"·=>·0x%"PRIx32"·bus_offset=0x%"PRIx64"·ps=%"PRIu32·"\n",

1187

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

1187

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

1188

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

1188

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

1189

·····················,·liobn,·pre_nb,·post_nb,·offs,·ps);

1189

·····················,·liobn,·pre_nb,·post_nb,·offs,·ps);

1190

#line·1192·"trace/trace-hw_ppc.h"

1190

#line·1192·"trace/trace-hw_ppc.h"

1191

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

1191

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

1193

············qemu_log("spapr_iommu_post_load·"·"liobn=%"PRIx64"·%"PRIx32"·=>·0x%"PRIx32"·bus_offset=0x%"PRIx64"·ps=%"PRIu32·"\n",·liobn,·pre_nb,·post_nb,·offs,·ps);

1193

············qemu_log("spapr_iommu_post_load·"·"liobn=%"PRIx64"·%"PRIx32"·=>·0x%"PRIx32"·bus_offset=0x%"PRIx64"·ps=%"PRIu32·"\n",·liobn,·pre_nb,·post_nb,·offs,·ps);

1194

#line·1196·"trace/trace-hw_ppc.h"

1194

#line·1196·"trace/trace-hw_ppc.h"

1195

········}

1195

········}

1196

····}

1196

····}

1197

}

1197

}

1198

static·inline·void·trace_spapr_iommu_post_load(uint64_t·liobn,·uint32_t·pre_nb,·uint32_t·post_nb,·uint64_t·offs,·uint32_t·ps)

1198

static·inline·void·trace_spapr_iommu_post_load(uint64_t·liobn,·uint32_t·pre_nb,·uint32_t·post_nb,·uint64_t·offs,·uint32_t·ps)

1210

static·inline·void·_nocheck__trace_spapr_iommu_ddw_query(uint64_t·buid,·uint32_t·cfgaddr,·unsigned·wa,·uint64_t·win_size,·uint32_t·pgmask)

1210

static·inline·void·_nocheck__trace_spapr_iommu_ddw_query(uint64_t·buid,·uint32_t·cfgaddr,·unsigned·wa,·uint64_t·win_size,·uint32_t·pgmask)

1211

{

1211

{

1212

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

1212

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

1213

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

1213

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

1214

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

1214

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

1215

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

1215

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

1217

············qemu_log("%d@%zu.%06zu:spapr_iommu_ddw_query·"·"buid=0x%"PRIx64"·addr=0x%"PRIx32",·%u·windows·available,·max·window·size=0x%"PRIx64",·mask=0x%"PRIx32·"\n",

1217

············qemu_log("%d@%zu.%06zu:spapr_iommu_ddw_query·"·"buid=0x%"PRIx64"·addr=0x%"PRIx32",·%u·windows·available,·max·window·size=0x%"PRIx64",·mask=0x%"PRIx32·"\n",

1218

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

1218

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

1219

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

1219

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

1220

·····················,·buid,·cfgaddr,·wa,·win_size,·pgmask);

1220

·····················,·buid,·cfgaddr,·wa,·win_size,·pgmask);

1221

#line·1223·"trace/trace-hw_ppc.h"

1221

#line·1223·"trace/trace-hw_ppc.h"

1222

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

1222

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

1224

············qemu_log("spapr_iommu_ddw_query·"·"buid=0x%"PRIx64"·addr=0x%"PRIx32",·%u·windows·available,·max·window·size=0x%"PRIx64",·mask=0x%"PRIx32·"\n",·buid,·cfgaddr,·wa,·win_size,·pgmask);

1224

············qemu_log("spapr_iommu_ddw_query·"·"buid=0x%"PRIx64"·addr=0x%"PRIx32",·%u·windows·available,·max·window·size=0x%"PRIx64",·mask=0x%"PRIx32·"\n",·buid,·cfgaddr,·wa,·win_size,·pgmask);

1225

#line·1227·"trace/trace-hw_ppc.h"

1225

#line·1227·"trace/trace-hw_ppc.h"

1226

········}

1226

········}

1227

····}

1227

····}

1228

}

1228

}

1229

static·inline·void·trace_spapr_iommu_ddw_query(uint64_t·buid,·uint32_t·cfgaddr,·unsigned·wa,·uint64_t·win_size,·uint32_t·pgmask)

1229

static·inline·void·trace_spapr_iommu_ddw_query(uint64_t·buid,·uint32_t·cfgaddr,·unsigned·wa,·uint64_t·win_size,·uint32_t·pgmask)

1241

static·inline·void·_nocheck__trace_spapr_iommu_ddw_create(uint64_t·buid,·uint32_t·cfgaddr,·uint64_t·pg_size,·uint64_t·req_size,·uint64_t·start,·uint32_t·liobn)

1241

static·inline·void·_nocheck__trace_spapr_iommu_ddw_create(uint64_t·buid,·uint32_t·cfgaddr,·uint64_t·pg_size,·uint64_t·req_size,·uint64_t·start,·uint32_t·liobn)

1242

{

1242

{

1243

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

1243

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

1244

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

1244

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

1245

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

1245

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

1246

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

1246

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

1248

············qemu_log("%d@%zu.%06zu:spapr_iommu_ddw_create·"·"buid=0x%"PRIx64"·addr=0x%"PRIx32",·page·size=0x%"PRIx64",·requested=0x%"PRIx64",·start·addr=0x%"PRIx64",·liobn=0x%"PRIx32·"\n",

1248

············qemu_log("%d@%zu.%06zu:spapr_iommu_ddw_create·"·"buid=0x%"PRIx64"·addr=0x%"PRIx32",·page·size=0x%"PRIx64",·requested=0x%"PRIx64",·start·addr=0x%"PRIx64",·liobn=0x%"PRIx32·"\n",

1249

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

1249

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

1250

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

1250

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

1251

·····················,·buid,·cfgaddr,·pg_size,·req_size,·start,·liobn);

1251

·····················,·buid,·cfgaddr,·pg_size,·req_size,·start,·liobn);

1252

#line·1254·"trace/trace-hw_ppc.h"

1252

#line·1254·"trace/trace-hw_ppc.h"

1253

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

1253

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

1255

············qemu_log("spapr_iommu_ddw_create·"·"buid=0x%"PRIx64"·addr=0x%"PRIx32",·page·size=0x%"PRIx64",·requested=0x%"PRIx64",·start·addr=0x%"PRIx64",·liobn=0x%"PRIx32·"\n",·buid,·cfgaddr,·pg_size,·req_size,·start,·liobn);

1255

············qemu_log("spapr_iommu_ddw_create·"·"buid=0x%"PRIx64"·addr=0x%"PRIx32",·page·size=0x%"PRIx64",·requested=0x%"PRIx64",·start·addr=0x%"PRIx64",·liobn=0x%"PRIx32·"\n",·buid,·cfgaddr,·pg_size,·req_size,·start,·liobn);

1256

#line·1258·"trace/trace-hw_ppc.h"

1256

#line·1258·"trace/trace-hw_ppc.h"

1257

········}

1257

········}

1258

····}

1258

····}

1259

}

1259

}

1260

static·inline·void·trace_spapr_iommu_ddw_create(uint64_t·buid,·uint32_t·cfgaddr,·uint64_t·pg_size,·uint64_t·req_size,·uint64_t·start,·uint32_t·liobn)

1260

static·inline·void·trace_spapr_iommu_ddw_create(uint64_t·buid,·uint32_t·cfgaddr,·uint64_t·pg_size,·uint64_t·req_size,·uint64_t·start,·uint32_t·liobn)

1272

static·inline·void·_nocheck__trace_spapr_iommu_ddw_remove(uint32_t·liobn)

1272

static·inline·void·_nocheck__trace_spapr_iommu_ddw_remove(uint32_t·liobn)

1273

{

1273

{

1274

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

1274

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

1275

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

1275

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

1276

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

1276

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

1277

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

1277

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

1279

············qemu_log("%d@%zu.%06zu:spapr_iommu_ddw_remove·"·"liobn=0x%"PRIx32·"\n",

1279

············qemu_log("%d@%zu.%06zu:spapr_iommu_ddw_remove·"·"liobn=0x%"PRIx32·"\n",

1280

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

1280

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

1281

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

1281

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

1282

·····················,·liobn);

1282

·····················,·liobn);

1283

#line·1285·"trace/trace-hw_ppc.h"

1283

#line·1285·"trace/trace-hw_ppc.h"

1284

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

1284

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

1286

············qemu_log("spapr_iommu_ddw_remove·"·"liobn=0x%"PRIx32·"\n",·liobn);

1286

············qemu_log("spapr_iommu_ddw_remove·"·"liobn=0x%"PRIx32·"\n",·liobn);

1287

#line·1289·"trace/trace-hw_ppc.h"

1287

#line·1289·"trace/trace-hw_ppc.h"

1288

········}

1288

········}

1289

····}

1289

····}

1290

}

1290

}

1291

static·inline·void·trace_spapr_iommu_ddw_remove(uint32_t·liobn)

1291

static·inline·void·trace_spapr_iommu_ddw_remove(uint32_t·liobn)

1303

static·inline·void·_nocheck__trace_spapr_iommu_ddw_reset(uint64_t·buid,·uint32_t·cfgaddr)

1303

static·inline·void·_nocheck__trace_spapr_iommu_ddw_reset(uint64_t·buid,·uint32_t·cfgaddr)

1304

{

1304

{

1305

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

1305

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

1306

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

1306

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

1307

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

1307

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

1308

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

1308

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

1310

············qemu_log("%d@%zu.%06zu:spapr_iommu_ddw_reset·"·"buid=0x%"PRIx64"·addr=0x%"PRIx32·"\n",

1310

············qemu_log("%d@%zu.%06zu:spapr_iommu_ddw_reset·"·"buid=0x%"PRIx64"·addr=0x%"PRIx32·"\n",

1311

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

1311

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

1312

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

1312

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

1313

·····················,·buid,·cfgaddr);

1313

·····················,·buid,·cfgaddr);

1314

#line·1316·"trace/trace-hw_ppc.h"

1314

#line·1316·"trace/trace-hw_ppc.h"

1315

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

1315

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

1317

············qemu_log("spapr_iommu_ddw_reset·"·"buid=0x%"PRIx64"·addr=0x%"PRIx32·"\n",·buid,·cfgaddr);

1317

············qemu_log("spapr_iommu_ddw_reset·"·"buid=0x%"PRIx64"·addr=0x%"PRIx32·"\n",·buid,·cfgaddr);

1318

#line·1320·"trace/trace-hw_ppc.h"

1318

#line·1320·"trace/trace-hw_ppc.h"

1319

········}

1319

········}

1320

····}

1320

····}

1321

}

1321

}

1322

static·inline·void·trace_spapr_iommu_ddw_reset(uint64_t·buid,·uint32_t·cfgaddr)

1322

static·inline·void·trace_spapr_iommu_ddw_reset(uint64_t·buid,·uint32_t·cfgaddr)

1334

static·inline·void·_nocheck__trace_spapr_drc_set_isolation_state(uint32_t·index,·int·state)

1334

static·inline·void·_nocheck__trace_spapr_drc_set_isolation_state(uint32_t·index,·int·state)

1335

{

1335

{

1336

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

1336

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

1337

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

1337

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

1338

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

1338

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

1339

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

1339

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

1341

············qemu_log("%d@%zu.%06zu:spapr_drc_set_isolation_state·"·"drc:·0x%"PRIx32",·state:·0x%"PRIx32·"\n",

1341

············qemu_log("%d@%zu.%06zu:spapr_drc_set_isolation_state·"·"drc:·0x%"PRIx32",·state:·0x%"PRIx32·"\n",

1342

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

1342

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

1343

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

1343

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

1344

·····················,·index,·state);

1344

·····················,·index,·state);

1345

#line·1347·"trace/trace-hw_ppc.h"

1345

#line·1347·"trace/trace-hw_ppc.h"

1346

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

1346

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

1348

············qemu_log("spapr_drc_set_isolation_state·"·"drc:·0x%"PRIx32",·state:·0x%"PRIx32·"\n",·index,·state);

1348

············qemu_log("spapr_drc_set_isolation_state·"·"drc:·0x%"PRIx32",·state:·0x%"PRIx32·"\n",·index,·state);

1349

#line·1351·"trace/trace-hw_ppc.h"

1349

#line·1351·"trace/trace-hw_ppc.h"

1350

········}

1350

········}

1351

····}

1351

····}

1352

}

1352

}

1353

static·inline·void·trace_spapr_drc_set_isolation_state(uint32_t·index,·int·state)

1353

static·inline·void·trace_spapr_drc_set_isolation_state(uint32_t·index,·int·state)

1365

static·inline·void·_nocheck__trace_spapr_drc_set_isolation_state_finalizing(uint32_t·index)

1365

static·inline·void·_nocheck__trace_spapr_drc_set_isolation_state_finalizing(uint32_t·index)

1366

{

1366

{

1367

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

1367

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

1368

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

1368

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

1369

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

1369

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

1370

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

1370

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

1372

············qemu_log("%d@%zu.%06zu:spapr_drc_set_isolation_state_finalizing·"·"drc:·0x%"PRIx32·"\n",

1372

············qemu_log("%d@%zu.%06zu:spapr_drc_set_isolation_state_finalizing·"·"drc:·0x%"PRIx32·"\n",

1373

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

1373

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

1374

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

1374

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

1375

·····················,·index);

1375

·····················,·index);

1376

#line·1378·"trace/trace-hw_ppc.h"

1376

#line·1378·"trace/trace-hw_ppc.h"

1377

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

1377

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

1379

············qemu_log("spapr_drc_set_isolation_state_finalizing·"·"drc:·0x%"PRIx32·"\n",·index);

1379

············qemu_log("spapr_drc_set_isolation_state_finalizing·"·"drc:·0x%"PRIx32·"\n",·index);

1380

#line·1382·"trace/trace-hw_ppc.h"

1380

#line·1382·"trace/trace-hw_ppc.h"

1381

········}

1381

········}

1382

····}

1382

····}

1383

}

1383

}

1384

static·inline·void·trace_spapr_drc_set_isolation_state_finalizing(uint32_t·index)

1384

static·inline·void·trace_spapr_drc_set_isolation_state_finalizing(uint32_t·index)

1396

static·inline·void·_nocheck__trace_spapr_drc_set_dr_indicator(uint32_t·index,·int·state)

1396

static·inline·void·_nocheck__trace_spapr_drc_set_dr_indicator(uint32_t·index,·int·state)

1397

{

1397

{

1398

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

1398

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

1399

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

1399

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

1400

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

1400

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

1401

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

1401

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

1403

············qemu_log("%d@%zu.%06zu:spapr_drc_set_dr_indicator·"·"drc:·0x%"PRIx32",·state:·0x%x"·"\n",

1403

············qemu_log("%d@%zu.%06zu:spapr_drc_set_dr_indicator·"·"drc:·0x%"PRIx32",·state:·0x%x"·"\n",

1404

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

1404

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

1405

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

1405

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

1406

·····················,·index,·state);

1406

·····················,·index,·state);

1407

#line·1409·"trace/trace-hw_ppc.h"

1407

#line·1409·"trace/trace-hw_ppc.h"

1408

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

1408

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

1410

············qemu_log("spapr_drc_set_dr_indicator·"·"drc:·0x%"PRIx32",·state:·0x%x"·"\n",·index,·state);

1410

············qemu_log("spapr_drc_set_dr_indicator·"·"drc:·0x%"PRIx32",·state:·0x%x"·"\n",·index,·state);

1411

#line·1413·"trace/trace-hw_ppc.h"

1411

#line·1413·"trace/trace-hw_ppc.h"

1412

········}

1412

········}

1413

····}

1413

····}

1414

}

1414

}

1415

static·inline·void·trace_spapr_drc_set_dr_indicator(uint32_t·index,·int·state)

1415

static·inline·void·trace_spapr_drc_set_dr_indicator(uint32_t·index,·int·state)

1427

static·inline·void·_nocheck__trace_spapr_drc_set_allocation_state(uint32_t·index,·int·state)

1427

static·inline·void·_nocheck__trace_spapr_drc_set_allocation_state(uint32_t·index,·int·state)

1428

{

1428

{

1429

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

1429

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

1430

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

1430

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

1431

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

1431

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

1432

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

1432

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

1434

············qemu_log("%d@%zu.%06zu:spapr_drc_set_allocation_state·"·"drc:·0x%"PRIx32",·state:·0x%x"·"\n",

1434

············qemu_log("%d@%zu.%06zu:spapr_drc_set_allocation_state·"·"drc:·0x%"PRIx32",·state:·0x%x"·"\n",

1435

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

1435

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

1436

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

1436

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

1437

·····················,·index,·state);

1437

·····················,·index,·state);

1438

#line·1440·"trace/trace-hw_ppc.h"

1438

#line·1440·"trace/trace-hw_ppc.h"

1439

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

1439

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

1441

············qemu_log("spapr_drc_set_allocation_state·"·"drc:·0x%"PRIx32",·state:·0x%x"·"\n",·index,·state);

1441

············qemu_log("spapr_drc_set_allocation_state·"·"drc:·0x%"PRIx32",·state:·0x%x"·"\n",·index,·state);

1442

#line·1444·"trace/trace-hw_ppc.h"

1442

#line·1444·"trace/trace-hw_ppc.h"

1443

········}

1443

········}

1444

····}

1444

····}

1445

}

1445

}

1446

static·inline·void·trace_spapr_drc_set_allocation_state(uint32_t·index,·int·state)

1446

static·inline·void·trace_spapr_drc_set_allocation_state(uint32_t·index,·int·state)

1458

static·inline·void·_nocheck__trace_spapr_drc_set_allocation_state_finalizing(uint32_t·index)

1458

static·inline·void·_nocheck__trace_spapr_drc_set_allocation_state_finalizing(uint32_t·index)

1459

{

1459

{

1460

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

1460

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

1461

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

1461

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

1462

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

1462

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

1463

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

1463

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

1465

············qemu_log("%d@%zu.%06zu:spapr_drc_set_allocation_state_finalizing·"·"drc:·0x%"PRIx32·"\n",

1465

············qemu_log("%d@%zu.%06zu:spapr_drc_set_allocation_state_finalizing·"·"drc:·0x%"PRIx32·"\n",

1466

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

1466

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

1467

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

1467

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

1468

·····················,·index);

1468

·····················,·index);

1469

#line·1471·"trace/trace-hw_ppc.h"

1469

#line·1471·"trace/trace-hw_ppc.h"

1470

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

1470

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

1472

············qemu_log("spapr_drc_set_allocation_state_finalizing·"·"drc:·0x%"PRIx32·"\n",·index);

1472

············qemu_log("spapr_drc_set_allocation_state_finalizing·"·"drc:·0x%"PRIx32·"\n",·index);

1473

#line·1475·"trace/trace-hw_ppc.h"

1473

#line·1475·"trace/trace-hw_ppc.h"

1474

········}

1474

········}

1475

····}

1475

····}

1476

}

1476

}

1477

static·inline·void·trace_spapr_drc_set_allocation_state_finalizing(uint32_t·index)

1477

static·inline·void·trace_spapr_drc_set_allocation_state_finalizing(uint32_t·index)

1489

static·inline·void·_nocheck__trace_spapr_drc_set_configured(uint32_t·index)

1489

static·inline·void·_nocheck__trace_spapr_drc_set_configured(uint32_t·index)

1490

{

1490

{

1491

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

1491

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

1492

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

1492

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

1493

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

1493

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

1494

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

1494

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

1496

············qemu_log("%d@%zu.%06zu:spapr_drc_set_configured·"·"drc:·0x%"PRIx32·"\n",

1496

············qemu_log("%d@%zu.%06zu:spapr_drc_set_configured·"·"drc:·0x%"PRIx32·"\n",

1497

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

1497

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

1498

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

1498

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

1499

·····················,·index);

1499

·····················,·index);

1500

#line·1502·"trace/trace-hw_ppc.h"

1500

#line·1502·"trace/trace-hw_ppc.h"

1501

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

1501

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

1503

············qemu_log("spapr_drc_set_configured·"·"drc:·0x%"PRIx32·"\n",·index);

1503

············qemu_log("spapr_drc_set_configured·"·"drc:·0x%"PRIx32·"\n",·index);

1504

#line·1506·"trace/trace-hw_ppc.h"

1504

#line·1506·"trace/trace-hw_ppc.h"

1505

········}

1505

········}

1506

····}

1506

····}

1507

}

1507

}

1508

static·inline·void·trace_spapr_drc_set_configured(uint32_t·index)

1508

static·inline·void·trace_spapr_drc_set_configured(uint32_t·index)

1520

static·inline·void·_nocheck__trace_spapr_drc_attach(uint32_t·index)

1520

static·inline·void·_nocheck__trace_spapr_drc_attach(uint32_t·index)

1521

{

1521

{

1522

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

1522

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

1523

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

1523

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

1524

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

1524

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

1525

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

1525

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

1527

············qemu_log("%d@%zu.%06zu:spapr_drc_attach·"·"drc:·0x%"PRIx32·"\n",

1527

············qemu_log("%d@%zu.%06zu:spapr_drc_attach·"·"drc:·0x%"PRIx32·"\n",

1528

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

1528

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

1529

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

1529

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

1530

·····················,·index);

1530

·····················,·index);

1531

#line·1533·"trace/trace-hw_ppc.h"

1531

#line·1533·"trace/trace-hw_ppc.h"

1532

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

1532

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

1534

············qemu_log("spapr_drc_attach·"·"drc:·0x%"PRIx32·"\n",·index);

1534

············qemu_log("spapr_drc_attach·"·"drc:·0x%"PRIx32·"\n",·index);

1535

#line·1537·"trace/trace-hw_ppc.h"

1535

#line·1537·"trace/trace-hw_ppc.h"

1536

········}

1536

········}

1537

····}

1537

····}

1538

}

1538

}

1539

static·inline·void·trace_spapr_drc_attach(uint32_t·index)

1539

static·inline·void·trace_spapr_drc_attach(uint32_t·index)

1551

static·inline·void·_nocheck__trace_spapr_drc_unplug_request(uint32_t·index)

1551

static·inline·void·_nocheck__trace_spapr_drc_unplug_request(uint32_t·index)

1552

{

1552

{

1553

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

1553

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

1554

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

1554

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

1555

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

1555

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

1556

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

1556

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

1558

············qemu_log("%d@%zu.%06zu:spapr_drc_unplug_request·"·"drc:·0x%"PRIx32·"\n",

1558

············qemu_log("%d@%zu.%06zu:spapr_drc_unplug_request·"·"drc:·0x%"PRIx32·"\n",

1559

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

1559

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

1560

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

1560

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

1561

·····················,·index);

1561

·····················,·index);

1562

#line·1564·"trace/trace-hw_ppc.h"

1562

#line·1564·"trace/trace-hw_ppc.h"

1563

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

1563

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

1565

············qemu_log("spapr_drc_unplug_request·"·"drc:·0x%"PRIx32·"\n",·index);

1565

············qemu_log("spapr_drc_unplug_request·"·"drc:·0x%"PRIx32·"\n",·index);

1566

#line·1568·"trace/trace-hw_ppc.h"

1566

#line·1568·"trace/trace-hw_ppc.h"

1567

········}

1567

········}

1568

····}

1568

····}

1569

}

1569

}

1570

static·inline·void·trace_spapr_drc_unplug_request(uint32_t·index)

1570

static·inline·void·trace_spapr_drc_unplug_request(uint32_t·index)

1582

static·inline·void·_nocheck__trace_spapr_drc_awaiting_quiesce(uint32_t·index)

1582

static·inline·void·_nocheck__trace_spapr_drc_awaiting_quiesce(uint32_t·index)

1583

{

1583

{

1584

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

1584

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

1585

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

1585

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

1586

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

1586

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

1587

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

1587

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

1589

············qemu_log("%d@%zu.%06zu:spapr_drc_awaiting_quiesce·"·"drc:·0x%"PRIx32·"\n",

1589

············qemu_log("%d@%zu.%06zu:spapr_drc_awaiting_quiesce·"·"drc:·0x%"PRIx32·"\n",

1590

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

1590

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

1591

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

1591

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

1592

·····················,·index);

1592

·····················,·index);

1593

#line·1595·"trace/trace-hw_ppc.h"

1593

#line·1595·"trace/trace-hw_ppc.h"

1594

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

1594

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

1596

············qemu_log("spapr_drc_awaiting_quiesce·"·"drc:·0x%"PRIx32·"\n",·index);

1596

············qemu_log("spapr_drc_awaiting_quiesce·"·"drc:·0x%"PRIx32·"\n",·index);

1597

#line·1599·"trace/trace-hw_ppc.h"

1597

#line·1599·"trace/trace-hw_ppc.h"

1598

········}

1598

········}

1599

····}

1599

····}

1600

}

1600

}

1601

static·inline·void·trace_spapr_drc_awaiting_quiesce(uint32_t·index)

1601

static·inline·void·trace_spapr_drc_awaiting_quiesce(uint32_t·index)

1613

static·inline·void·_nocheck__trace_spapr_drc_reset(uint32_t·index)

1613

static·inline·void·_nocheck__trace_spapr_drc_reset(uint32_t·index)

1614

{

1614

{

1615

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

1615

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

1616

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

1616

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

1617

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

1617

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

1618

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

1618

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

1620

············qemu_log("%d@%zu.%06zu:spapr_drc_reset·"·"drc:·0x%"PRIx32·"\n",

1620

············qemu_log("%d@%zu.%06zu:spapr_drc_reset·"·"drc:·0x%"PRIx32·"\n",

1621

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

1621

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

1622

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

1622

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

1623

·····················,·index);

1623

·····················,·index);

1624

#line·1626·"trace/trace-hw_ppc.h"

1624

#line·1626·"trace/trace-hw_ppc.h"

1625

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

1625

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

1627

············qemu_log("spapr_drc_reset·"·"drc:·0x%"PRIx32·"\n",·index);

1627

············qemu_log("spapr_drc_reset·"·"drc:·0x%"PRIx32·"\n",·index);

1628

#line·1630·"trace/trace-hw_ppc.h"

1628

#line·1630·"trace/trace-hw_ppc.h"

1629

········}

1629

········}

1630

····}

1630

····}

1631

}

1631

}

1632

static·inline·void·trace_spapr_drc_reset(uint32_t·index)

1632

static·inline·void·trace_spapr_drc_reset(uint32_t·index)

1644

static·inline·void·_nocheck__trace_spapr_drc_realize(uint32_t·index)

1644

static·inline·void·_nocheck__trace_spapr_drc_realize(uint32_t·index)

1645

{

1645

{

1646

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

1646

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

1647

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

1647

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

1648

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

1648

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

1649

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

1649

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

1651

············qemu_log("%d@%zu.%06zu:spapr_drc_realize·"·"drc:·0x%"PRIx32·"\n",

1651

············qemu_log("%d@%zu.%06zu:spapr_drc_realize·"·"drc:·0x%"PRIx32·"\n",

1652

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

1652

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

1653

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

1653

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

1654

·····················,·index);

1654

·····················,·index);

1655

#line·1657·"trace/trace-hw_ppc.h"

1655

#line·1657·"trace/trace-hw_ppc.h"

1656

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

1656

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

1658

············qemu_log("spapr_drc_realize·"·"drc:·0x%"PRIx32·"\n",·index);

1658

············qemu_log("spapr_drc_realize·"·"drc:·0x%"PRIx32·"\n",·index);

1659

#line·1661·"trace/trace-hw_ppc.h"

1659

#line·1661·"trace/trace-hw_ppc.h"

1660

········}

1660

········}

1661

····}

1661

····}

1662

}

1662

}

1663

static·inline·void·trace_spapr_drc_realize(uint32_t·index)

1663

static·inline·void·trace_spapr_drc_realize(uint32_t·index)

1675

static·inline·void·_nocheck__trace_spapr_drc_realize_child(uint32_t·index,·const·char·*·childname)

1675

static·inline·void·_nocheck__trace_spapr_drc_realize_child(uint32_t·index,·const·char·*·childname)

1676

{

1676

{

1677

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

1677

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

1678

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

1678

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

1679

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

1679

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

1680

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

1680

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

1682

············qemu_log("%d@%zu.%06zu:spapr_drc_realize_child·"·"drc:·0x%"PRIx32",·child·name:·%s"·"\n",

1682

············qemu_log("%d@%zu.%06zu:spapr_drc_realize_child·"·"drc:·0x%"PRIx32",·child·name:·%s"·"\n",

1683

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

1683

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

1684

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

1684

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

1685

·····················,·index,·childname);

1685

·····················,·index,·childname);

1686

#line·1688·"trace/trace-hw_ppc.h"

1686

#line·1688·"trace/trace-hw_ppc.h"

1687

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

1687

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

1689

············qemu_log("spapr_drc_realize_child·"·"drc:·0x%"PRIx32",·child·name:·%s"·"\n",·index,·childname);

1689

············qemu_log("spapr_drc_realize_child·"·"drc:·0x%"PRIx32",·child·name:·%s"·"\n",·index,·childname);

1690

#line·1692·"trace/trace-hw_ppc.h"

1690

#line·1692·"trace/trace-hw_ppc.h"

1691

········}

1691

········}

1692

····}

1692

····}

1693

}

1693

}

1694

static·inline·void·trace_spapr_drc_realize_child(uint32_t·index,·const·char·*·childname)

1694

static·inline·void·trace_spapr_drc_realize_child(uint32_t·index,·const·char·*·childname)

1706

static·inline·void·_nocheck__trace_spapr_drc_realize_complete(uint32_t·index)

1706

static·inline·void·_nocheck__trace_spapr_drc_realize_complete(uint32_t·index)

1707

{

1707

{

1708

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

1708

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

1709

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

1709

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

1710

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

1710

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

1711

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

1711

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

1713

············qemu_log("%d@%zu.%06zu:spapr_drc_realize_complete·"·"drc:·0x%"PRIx32·"\n",

1713

············qemu_log("%d@%zu.%06zu:spapr_drc_realize_complete·"·"drc:·0x%"PRIx32·"\n",

1714

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

1714

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

1715

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

1715

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

1716

·····················,·index);

1716

·····················,·index);

1717

#line·1719·"trace/trace-hw_ppc.h"

1717

#line·1719·"trace/trace-hw_ppc.h"

1718

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

1718

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

1720

············qemu_log("spapr_drc_realize_complete·"·"drc:·0x%"PRIx32·"\n",·index);

1720

············qemu_log("spapr_drc_realize_complete·"·"drc:·0x%"PRIx32·"\n",·index);

1721

#line·1723·"trace/trace-hw_ppc.h"

1721

#line·1723·"trace/trace-hw_ppc.h"

1722

········}

1722

········}

1723

····}

1723

····}

1724

}

1724

}

1725

static·inline·void·trace_spapr_drc_realize_complete(uint32_t·index)

1725

static·inline·void·trace_spapr_drc_realize_complete(uint32_t·index)

1737

static·inline·void·_nocheck__trace_spapr_drc_unrealize(uint32_t·index)

1737

static·inline·void·_nocheck__trace_spapr_drc_unrealize(uint32_t·index)

1738

{

1738

{

1739

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

1739

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

1740

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

1740

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

1741

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

1741

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

1742

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

1742

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

1744

············qemu_log("%d@%zu.%06zu:spapr_drc_unrealize·"·"drc:·0x%"PRIx32·"\n",

1744

············qemu_log("%d@%zu.%06zu:spapr_drc_unrealize·"·"drc:·0x%"PRIx32·"\n",

1745

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

1745

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

1746

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

1746

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

1747

·····················,·index);

1747

·····················,·index);

1748

#line·1750·"trace/trace-hw_ppc.h"

1748

#line·1750·"trace/trace-hw_ppc.h"

1749

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

1749

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

1751

············qemu_log("spapr_drc_unrealize·"·"drc:·0x%"PRIx32·"\n",·index);

1751

············qemu_log("spapr_drc_unrealize·"·"drc:·0x%"PRIx32·"\n",·index);

1752

#line·1754·"trace/trace-hw_ppc.h"

1752

#line·1754·"trace/trace-hw_ppc.h"

1753

········}

1753

········}

1754

····}

1754

····}

1755

}

1755

}

1756

static·inline·void·trace_spapr_drc_unrealize(uint32_t·index)

1756

static·inline·void·trace_spapr_drc_unrealize(uint32_t·index)

1768

static·inline·void·_nocheck__trace_spapr_ovec_parse_vector(int·vector,·int·byte,·uint16_t·vec_len,·uint8_t·entry)

1768

static·inline·void·_nocheck__trace_spapr_ovec_parse_vector(int·vector,·int·byte,·uint16_t·vec_len,·uint8_t·entry)

1769

{

1769

{

1770

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

1770

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

1771

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

1771

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

1772

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

1772

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

1773

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

1773

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

1775

············qemu_log("%d@%zu.%06zu:spapr_ovec_parse_vector·"·"read·guest·vector·%2d,·byte·%3d·/·%3d:·0x%.2x"·"\n",

1775

············qemu_log("%d@%zu.%06zu:spapr_ovec_parse_vector·"·"read·guest·vector·%2d,·byte·%3d·/·%3d:·0x%.2x"·"\n",

1776

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

1776

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

1777

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

1777

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

1778

·····················,·vector,·byte,·vec_len,·entry);

1778

·····················,·vector,·byte,·vec_len,·entry);

1779

#line·1781·"trace/trace-hw_ppc.h"

1779

#line·1781·"trace/trace-hw_ppc.h"

1780

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

1780

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

1782

············qemu_log("spapr_ovec_parse_vector·"·"read·guest·vector·%2d,·byte·%3d·/·%3d:·0x%.2x"·"\n",·vector,·byte,·vec_len,·entry);

1782

············qemu_log("spapr_ovec_parse_vector·"·"read·guest·vector·%2d,·byte·%3d·/·%3d:·0x%.2x"·"\n",·vector,·byte,·vec_len,·entry);

1783

#line·1785·"trace/trace-hw_ppc.h"

1783

#line·1785·"trace/trace-hw_ppc.h"

1784

········}

1784

········}

1785

····}

1785

····}

1786

}

1786

}

1787

static·inline·void·trace_spapr_ovec_parse_vector(int·vector,·int·byte,·uint16_t·vec_len,·uint8_t·entry)

1787

static·inline·void·trace_spapr_ovec_parse_vector(int·vector,·int·byte,·uint16_t·vec_len,·uint8_t·entry)

1799

static·inline·void·_nocheck__trace_spapr_ovec_populate_dt(int·byte,·uint16_t·vec_len,·uint8_t·entry)

1799

static·inline·void·_nocheck__trace_spapr_ovec_populate_dt(int·byte,·uint16_t·vec_len,·uint8_t·entry)

1800

{

1800

{

1801

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

1801

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

1802

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

1802

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

1803

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

1803

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

1804

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

1804

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

1806

············qemu_log("%d@%zu.%06zu:spapr_ovec_populate_dt·"·"encoding·guest·vector·byte·%3d·/·%3d:·0x%.2x"·"\n",

1806

············qemu_log("%d@%zu.%06zu:spapr_ovec_populate_dt·"·"encoding·guest·vector·byte·%3d·/·%3d:·0x%.2x"·"\n",

1807

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

1807

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

1808

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

1808

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

1809

·····················,·byte,·vec_len,·entry);

1809

·····················,·byte,·vec_len,·entry);

1810

#line·1812·"trace/trace-hw_ppc.h"

1810

#line·1812·"trace/trace-hw_ppc.h"

1811

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

1811

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

1813

············qemu_log("spapr_ovec_populate_dt·"·"encoding·guest·vector·byte·%3d·/·%3d:·0x%.2x"·"\n",·byte,·vec_len,·entry);

1813

············qemu_log("spapr_ovec_populate_dt·"·"encoding·guest·vector·byte·%3d·/·%3d:·0x%.2x"·"\n",·byte,·vec_len,·entry);

1814

#line·1816·"trace/trace-hw_ppc.h"

1814

#line·1816·"trace/trace-hw_ppc.h"

1815

········}

1815

········}

1816

····}

1816

····}

1817

}

1817

}

1818

static·inline·void·trace_spapr_ovec_populate_dt(int·byte,·uint16_t·vec_len,·uint8_t·entry)

1818

static·inline·void·trace_spapr_ovec_populate_dt(int·byte,·uint16_t·vec_len,·uint8_t·entry)

1830

static·inline·void·_nocheck__trace_spapr_rtas_get_sensor_state_not_supported(uint32_t·index,·uint32_t·type)

1830

static·inline·void·_nocheck__trace_spapr_rtas_get_sensor_state_not_supported(uint32_t·index,·uint32_t·type)

1831

{

1831

{

1832

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

1832

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

1833

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

1833

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

1834

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

1834

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

1835

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

1835

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

1837

············qemu_log("%d@%zu.%06zu:spapr_rtas_get_sensor_state_not_supported·"·"sensor·index:·0x%"PRIx32",·type:·%"PRIu32·"\n",

1837

············qemu_log("%d@%zu.%06zu:spapr_rtas_get_sensor_state_not_supported·"·"sensor·index:·0x%"PRIx32",·type:·%"PRIu32·"\n",

1838

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

1838

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

1839

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

1839

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

1840

·····················,·index,·type);

1840

·····················,·index,·type);

1841

#line·1843·"trace/trace-hw_ppc.h"

1841

#line·1843·"trace/trace-hw_ppc.h"

1842

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

1842

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

1844

············qemu_log("spapr_rtas_get_sensor_state_not_supported·"·"sensor·index:·0x%"PRIx32",·type:·%"PRIu32·"\n",·index,·type);

1844

············qemu_log("spapr_rtas_get_sensor_state_not_supported·"·"sensor·index:·0x%"PRIx32",·type:·%"PRIu32·"\n",·index,·type);

1845

#line·1847·"trace/trace-hw_ppc.h"

1845

#line·1847·"trace/trace-hw_ppc.h"

1846

········}

1846

········}

1847

····}

1847

····}

1848

}

1848

}

1849

static·inline·void·trace_spapr_rtas_get_sensor_state_not_supported(uint32_t·index,·uint32_t·type)

1849

static·inline·void·trace_spapr_rtas_get_sensor_state_not_supported(uint32_t·index,·uint32_t·type)

1861

static·inline·void·_nocheck__trace_spapr_rtas_get_sensor_state_invalid(uint32_t·index)

1861

static·inline·void·_nocheck__trace_spapr_rtas_get_sensor_state_invalid(uint32_t·index)

1862

{

1862

{

1863

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

1863

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

1864

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

1864

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

1865

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

1865

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

1866

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

1866

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

1868

············qemu_log("%d@%zu.%06zu:spapr_rtas_get_sensor_state_invalid·"·"sensor·index:·0x%"PRIx32·"\n",

1868

············qemu_log("%d@%zu.%06zu:spapr_rtas_get_sensor_state_invalid·"·"sensor·index:·0x%"PRIx32·"\n",

1869

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

1869

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

1870

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

1870

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

1871

·····················,·index);

1871

·····················,·index);

1872

#line·1874·"trace/trace-hw_ppc.h"

1872

#line·1874·"trace/trace-hw_ppc.h"

1873

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

1873

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

1875

············qemu_log("spapr_rtas_get_sensor_state_invalid·"·"sensor·index:·0x%"PRIx32·"\n",·index);

1875

············qemu_log("spapr_rtas_get_sensor_state_invalid·"·"sensor·index:·0x%"PRIx32·"\n",·index);

1876

#line·1878·"trace/trace-hw_ppc.h"

1876

#line·1878·"trace/trace-hw_ppc.h"

1877

········}

1877

········}

1878

····}

1878

····}

1879

}

1879

}

1880

static·inline·void·trace_spapr_rtas_get_sensor_state_invalid(uint32_t·index)

1880

static·inline·void·trace_spapr_rtas_get_sensor_state_invalid(uint32_t·index)

1892

static·inline·void·_nocheck__trace_spapr_rtas_ibm_configure_connector_invalid(uint32_t·index)

1892

static·inline·void·_nocheck__trace_spapr_rtas_ibm_configure_connector_invalid(uint32_t·index)

1893

{

1893

{

1894

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

1894

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

1895

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

1895

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

1896

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

1896

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

1897

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

1897

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

1899

············qemu_log("%d@%zu.%06zu:spapr_rtas_ibm_configure_connector_invalid·"·"DRC·index:·0x%"PRIx32·"\n",

1899

············qemu_log("%d@%zu.%06zu:spapr_rtas_ibm_configure_connector_invalid·"·"DRC·index:·0x%"PRIx32·"\n",

1900

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

1900

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

1901

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

1901

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

1902

·····················,·index);

1902

·····················,·index);

1903

#line·1905·"trace/trace-hw_ppc.h"

1903

#line·1905·"trace/trace-hw_ppc.h"

1904

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

1904

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

1906

············qemu_log("spapr_rtas_ibm_configure_connector_invalid·"·"DRC·index:·0x%"PRIx32·"\n",·index);

1906

············qemu_log("spapr_rtas_ibm_configure_connector_invalid·"·"DRC·index:·0x%"PRIx32·"\n",·index);

1907

#line·1909·"trace/trace-hw_ppc.h"

1907

#line·1909·"trace/trace-hw_ppc.h"

1908

········}

1908

········}

1909

····}

1909

····}

1910

}

1910

}

1911

static·inline·void·trace_spapr_rtas_ibm_configure_connector_invalid(uint32_t·index)

1911

static·inline·void·trace_spapr_rtas_ibm_configure_connector_invalid(uint32_t·index)

1923

static·inline·void·_nocheck__trace_spapr_vio_h_reg_crq(uint64_t·reg,·uint64_t·queue_addr,·uint64_t·queue_len)

1923

static·inline·void·_nocheck__trace_spapr_vio_h_reg_crq(uint64_t·reg,·uint64_t·queue_addr,·uint64_t·queue_len)

1924

{

1924

{

1925

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

1925

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

1926

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

1926

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

1927

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

1927

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

1928

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

1928

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

1930

············qemu_log("%d@%zu.%06zu:spapr_vio_h_reg_crq·"·"CRQ·for·dev·0x%"·PRIx64·"·registered·at·0x%"·PRIx64·"/0x%"·PRIx64·"\n",

1930

············qemu_log("%d@%zu.%06zu:spapr_vio_h_reg_crq·"·"CRQ·for·dev·0x%"·PRIx64·"·registered·at·0x%"·PRIx64·"/0x%"·PRIx64·"\n",

1931

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

1931

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

1932

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

1932

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

1933

·····················,·reg,·queue_addr,·queue_len);

1933

·····················,·reg,·queue_addr,·queue_len);

1934

#line·1936·"trace/trace-hw_ppc.h"

1934

#line·1936·"trace/trace-hw_ppc.h"

1935

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

1935

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

1937

············qemu_log("spapr_vio_h_reg_crq·"·"CRQ·for·dev·0x%"·PRIx64·"·registered·at·0x%"·PRIx64·"/0x%"·PRIx64·"\n",·reg,·queue_addr,·queue_len);

1937

············qemu_log("spapr_vio_h_reg_crq·"·"CRQ·for·dev·0x%"·PRIx64·"·registered·at·0x%"·PRIx64·"/0x%"·PRIx64·"\n",·reg,·queue_addr,·queue_len);

1938

#line·1940·"trace/trace-hw_ppc.h"

1938

#line·1940·"trace/trace-hw_ppc.h"

1939

········}

1939

········}

1940

····}

1940

····}

1941

}

1941

}

1942

static·inline·void·trace_spapr_vio_h_reg_crq(uint64_t·reg,·uint64_t·queue_addr,·uint64_t·queue_len)

1942

static·inline·void·trace_spapr_vio_h_reg_crq(uint64_t·reg,·uint64_t·queue_addr,·uint64_t·queue_len)

1954

static·inline·void·_nocheck__trace_spapr_vio_free_crq(uint32_t·reg)

1954

static·inline·void·_nocheck__trace_spapr_vio_free_crq(uint32_t·reg)

1955

{

1955

{

1956

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

1956

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

1957

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

1957

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

1958

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

1958

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

1959

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

1959

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

1961

············qemu_log("%d@%zu.%06zu:spapr_vio_free_crq·"·"CRQ·for·dev·0x%"·PRIx32·"·freed"·"\n",

1961

············qemu_log("%d@%zu.%06zu:spapr_vio_free_crq·"·"CRQ·for·dev·0x%"·PRIx32·"·freed"·"\n",

1962

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

1962

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

1963

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

1963

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

1964

·····················,·reg);

1964

·····················,·reg);

1965

#line·1967·"trace/trace-hw_ppc.h"

1965

#line·1967·"trace/trace-hw_ppc.h"

1966

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

1966

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

1968

············qemu_log("spapr_vio_free_crq·"·"CRQ·for·dev·0x%"·PRIx32·"·freed"·"\n",·reg);

1968

············qemu_log("spapr_vio_free_crq·"·"CRQ·for·dev·0x%"·PRIx32·"·freed"·"\n",·reg);

1969

#line·1971·"trace/trace-hw_ppc.h"

1969

#line·1971·"trace/trace-hw_ppc.h"

1970

········}

1970

········}

1971

····}

1971

····}

1972

}

1972

}

1973

static·inline·void·trace_spapr_vio_free_crq(uint32_t·reg)

1973

static·inline·void·trace_spapr_vio_free_crq(uint32_t·reg)

1985

static·inline·void·_nocheck__trace_vof_error_str_truncated(const·char·*·s,·int·len)

1985

static·inline·void·_nocheck__trace_vof_error_str_truncated(const·char·*·s,·int·len)

1986

{

1986

{

1987

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

1987

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

1988

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

1988

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

1989

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

1989

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

1990

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

1990

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

1992

············qemu_log("%d@%zu.%06zu:vof_error_str_truncated·"·"%s·truncated·to·%d"·"\n",

1992

············qemu_log("%d@%zu.%06zu:vof_error_str_truncated·"·"%s·truncated·to·%d"·"\n",

1993

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

1993

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

1994

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

1994

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

1995

·····················,·s,·len);

1995

·····················,·s,·len);

1996

#line·1998·"trace/trace-hw_ppc.h"

1996

#line·1998·"trace/trace-hw_ppc.h"

1997

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

1997

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

1999

············qemu_log("vof_error_str_truncated·"·"%s·truncated·to·%d"·"\n",·s,·len);

1999

············qemu_log("vof_error_str_truncated·"·"%s·truncated·to·%d"·"\n",·s,·len);

2000

#line·2002·"trace/trace-hw_ppc.h"

2000

#line·2002·"trace/trace-hw_ppc.h"

2001

········}

2001

········}

2002

····}

2002

····}

2003

}

2003

}

2004

static·inline·void·trace_vof_error_str_truncated(const·char·*·s,·int·len)

2004

static·inline·void·trace_vof_error_str_truncated(const·char·*·s,·int·len)

2016

static·inline·void·_nocheck__trace_vof_error_param(const·char·*·method,·int·nargscheck,·int·nretcheck,·int·nargs,·int·nret)

2016

static·inline·void·_nocheck__trace_vof_error_param(const·char·*·method,·int·nargscheck,·int·nretcheck,·int·nargs,·int·nret)

2017

{

2017

{

2018

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

2018

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

2019

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

2019

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

2020

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

2020

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

2021

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

2021

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

2023

············qemu_log("%d@%zu.%06zu:vof_error_param·"·"%s·takes/returns·%d/%d,·not·%d/%d"·"\n",

2023

············qemu_log("%d@%zu.%06zu:vof_error_param·"·"%s·takes/returns·%d/%d,·not·%d/%d"·"\n",

2024

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

2024

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

2025

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

2025

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

2026

·····················,·method,·nargscheck,·nretcheck,·nargs,·nret);

2026

·····················,·method,·nargscheck,·nretcheck,·nargs,·nret);

2027

#line·2029·"trace/trace-hw_ppc.h"

2027

#line·2029·"trace/trace-hw_ppc.h"

2028

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

2028

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

2030

············qemu_log("vof_error_param·"·"%s·takes/returns·%d/%d,·not·%d/%d"·"\n",·method,·nargscheck,·nretcheck,·nargs,·nret);

2030

············qemu_log("vof_error_param·"·"%s·takes/returns·%d/%d,·not·%d/%d"·"\n",·method,·nargscheck,·nretcheck,·nargs,·nret);

2031

#line·2033·"trace/trace-hw_ppc.h"

2031

#line·2033·"trace/trace-hw_ppc.h"

2032

········}

2032

········}

2033

····}

2033

····}

2034

}

2034

}

2035

static·inline·void·trace_vof_error_param(const·char·*·method,·int·nargscheck,·int·nretcheck,·int·nargs,·int·nret)

2035

static·inline·void·trace_vof_error_param(const·char·*·method,·int·nargscheck,·int·nretcheck,·int·nargs,·int·nret)

2047

static·inline·void·_nocheck__trace_vof_error_unknown_service(const·char·*·service,·int·nargs,·int·nret)

2047

static·inline·void·_nocheck__trace_vof_error_unknown_service(const·char·*·service,·int·nargs,·int·nret)

2048

{

2048

{

2049

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

2049

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

2050

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

2050

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

2051

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

2051

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

2052

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

2052

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

2054

············qemu_log("%d@%zu.%06zu:vof_error_unknown_service·"·"\"%s\"·args=%d·rets=%d"·"\n",

2054

············qemu_log("%d@%zu.%06zu:vof_error_unknown_service·"·"\"%s\"·args=%d·rets=%d"·"\n",

2055

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

2055

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

2056

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

2056

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

2057

·····················,·service,·nargs,·nret);

2057

·····················,·service,·nargs,·nret);

2058

#line·2060·"trace/trace-hw_ppc.h"

2058

#line·2060·"trace/trace-hw_ppc.h"

2059

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

2059

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

2061

············qemu_log("vof_error_unknown_service·"·"\"%s\"·args=%d·rets=%d"·"\n",·service,·nargs,·nret);

2061

············qemu_log("vof_error_unknown_service·"·"\"%s\"·args=%d·rets=%d"·"\n",·service,·nargs,·nret);

2062

#line·2064·"trace/trace-hw_ppc.h"

2062

#line·2064·"trace/trace-hw_ppc.h"

2063

········}

2063

········}

2064

····}

2064

····}

2065

}

2065

}

2066

static·inline·void·trace_vof_error_unknown_service(const·char·*·service,·int·nargs,·int·nret)

2066

static·inline·void·trace_vof_error_unknown_service(const·char·*·service,·int·nargs,·int·nret)

2078

static·inline·void·_nocheck__trace_vof_error_unknown_method(const·char·*·method)

2078

static·inline·void·_nocheck__trace_vof_error_unknown_method(const·char·*·method)

2079

{

2079

{

2080

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

2080

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

2081

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

2081

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

2082

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

2082

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

2083

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

2083

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

2085

············qemu_log("%d@%zu.%06zu:vof_error_unknown_method·"·"\"%s\""·"\n",

2085

············qemu_log("%d@%zu.%06zu:vof_error_unknown_method·"·"\"%s\""·"\n",

2086

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

2086

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

2087

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

2087

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

2088

·····················,·method);

2088

·····················,·method);

2089

#line·2091·"trace/trace-hw_ppc.h"

2089

#line·2091·"trace/trace-hw_ppc.h"

2090

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

2090

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

2092

············qemu_log("vof_error_unknown_method·"·"\"%s\""·"\n",·method);

2092

············qemu_log("vof_error_unknown_method·"·"\"%s\""·"\n",·method);

2093

#line·2095·"trace/trace-hw_ppc.h"

2093

#line·2095·"trace/trace-hw_ppc.h"

2094

········}

2094

········}

2095

····}

2095

····}

2096

}

2096

}

2097

static·inline·void·trace_vof_error_unknown_method(const·char·*·method)

2097

static·inline·void·trace_vof_error_unknown_method(const·char·*·method)

2109

static·inline·void·_nocheck__trace_vof_error_unknown_ihandle_close(uint32_t·ih)

2109

static·inline·void·_nocheck__trace_vof_error_unknown_ihandle_close(uint32_t·ih)

2110

{

2110

{

2111

····if·(trace_event_get_state(TRACE_VOF_ERROR_UNKNOWN_IHANDLE_CLOSE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2111

····if·(trace_event_get_state(TRACE_VOF_ERROR_UNKNOWN_IHANDLE_CLOSE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2112

········if·(message_with_timestamp)·{

2112

········if·(message_with_timestamp)·{

2113

············struct·timeval·_now;

2113

············struct·timeval·_now;

2114

············gettimeofday(&_now,·NULL);

2114

············gettimeofday(&_now,·NULL);

2116

············qemu_log("%d@%zu.%06zu:vof_error_unknown_ihandle_close·"·"ih=0x%x"·"\n",

2116

············qemu_log("%d@%zu.%06zu:vof_error_unknown_ihandle_close·"·"ih=0x%x"·"\n",

2117

·····················qemu_get_thread_id(),

2117

·····················qemu_get_thread_id(),

2118

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2118

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2119

·····················,·ih);

2119

·····················,·ih);

2120

#line·2122·"trace/trace-hw_ppc.h"

2120

#line·2122·"trace/trace-hw_ppc.h"

2121

········}·else·{

2121

········}·else·{

2123

············qemu_log("vof_error_unknown_ihandle_close·"·"ih=0x%x"·"\n",·ih);

2123

············qemu_log("vof_error_unknown_ihandle_close·"·"ih=0x%x"·"\n",·ih);

2124

#line·2126·"trace/trace-hw_ppc.h"

2124

#line·2126·"trace/trace-hw_ppc.h"

2125

········}

2125

········}

2126

····}

2126

····}

2127

}

2127

}

2128

static·inline·void·trace_vof_error_unknown_ihandle_close(uint32_t·ih)

2128

static·inline·void·trace_vof_error_unknown_ihandle_close(uint32_t·ih)

2140

static·inline·void·_nocheck__trace_vof_error_unknown_path(const·char·*·path)

2140

static·inline·void·_nocheck__trace_vof_error_unknown_path(const·char·*·path)

2141

{

2141

{

2142

····if·(trace_event_get_state(TRACE_VOF_ERROR_UNKNOWN_PATH)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2142

····if·(trace_event_get_state(TRACE_VOF_ERROR_UNKNOWN_PATH)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2143

········if·(message_with_timestamp)·{

2143

········if·(message_with_timestamp)·{

2144

············struct·timeval·_now;

2144

············struct·timeval·_now;

2145

············gettimeofday(&_now,·NULL);

2145

············gettimeofday(&_now,·NULL);

2147

············qemu_log("%d@%zu.%06zu:vof_error_unknown_path·"·"\"%s\""·"\n",

2147

············qemu_log("%d@%zu.%06zu:vof_error_unknown_path·"·"\"%s\""·"\n",

2148

·····················qemu_get_thread_id(),

2148

·····················qemu_get_thread_id(),

2149

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2149

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2150

·····················,·path);

2150

·····················,·path);

2151

#line·2153·"trace/trace-hw_ppc.h"

2151

#line·2153·"trace/trace-hw_ppc.h"

2152

········}·else·{

2152

········}·else·{

2154

············qemu_log("vof_error_unknown_path·"·"\"%s\""·"\n",·path);

2154

············qemu_log("vof_error_unknown_path·"·"\"%s\""·"\n",·path);

2155

#line·2157·"trace/trace-hw_ppc.h"

2155

#line·2157·"trace/trace-hw_ppc.h"

2156

········}

2156

········}

2157

····}

2157

····}

2158

}

2158

}

2159

static·inline·void·trace_vof_error_unknown_path(const·char·*·path)

2159

static·inline·void·trace_vof_error_unknown_path(const·char·*·path)

2171

static·inline·void·_nocheck__trace_vof_error_write(uint32_t·ih)

2171

static·inline·void·_nocheck__trace_vof_error_write(uint32_t·ih)

2172

{

2172

{

2173

····if·(trace_event_get_state(TRACE_VOF_ERROR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2173

····if·(trace_event_get_state(TRACE_VOF_ERROR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2174

········if·(message_with_timestamp)·{

2174

········if·(message_with_timestamp)·{

2175

············struct·timeval·_now;

2175

············struct·timeval·_now;

2176

············gettimeofday(&_now,·NULL);

2176

············gettimeofday(&_now,·NULL);

2178

············qemu_log("%d@%zu.%06zu:vof_error_write·"·"ih=0x%x"·"\n",

2178

············qemu_log("%d@%zu.%06zu:vof_error_write·"·"ih=0x%x"·"\n",

2179

·····················qemu_get_thread_id(),

2179

·····················qemu_get_thread_id(),

2180

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2180

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2181

·····················,·ih);

2181

·····················,·ih);

2182

#line·2184·"trace/trace-hw_ppc.h"

2182

#line·2184·"trace/trace-hw_ppc.h"

2183

········}·else·{

2183

········}·else·{

2185

············qemu_log("vof_error_write·"·"ih=0x%x"·"\n",·ih);

2185

············qemu_log("vof_error_write·"·"ih=0x%x"·"\n",·ih);

2186

#line·2188·"trace/trace-hw_ppc.h"

2186

#line·2188·"trace/trace-hw_ppc.h"

2187

········}

2187

········}

2188

····}

2188

····}

2189

}

2189

}

2190

static·inline·void·trace_vof_error_write(uint32_t·ih)

2190

static·inline·void·trace_vof_error_write(uint32_t·ih)

2202

static·inline·void·_nocheck__trace_vof_finddevice(const·char·*·path,·uint32_t·ph)

2202

static·inline·void·_nocheck__trace_vof_finddevice(const·char·*·path,·uint32_t·ph)

2203

{

2203

{

2204

····if·(trace_event_get_state(TRACE_VOF_FINDDEVICE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2204

····if·(trace_event_get_state(TRACE_VOF_FINDDEVICE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2205

········if·(message_with_timestamp)·{

2205

········if·(message_with_timestamp)·{

2206

············struct·timeval·_now;

2206

············struct·timeval·_now;

2207

············gettimeofday(&_now,·NULL);

2207

············gettimeofday(&_now,·NULL);

2209

············qemu_log("%d@%zu.%06zu:vof_finddevice·"·"\"%s\"·=>·ph=0x%x"·"\n",

2209

············qemu_log("%d@%zu.%06zu:vof_finddevice·"·"\"%s\"·=>·ph=0x%x"·"\n",

2210

·····················qemu_get_thread_id(),

2210

·····················qemu_get_thread_id(),

2211

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2211

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2212

·····················,·path,·ph);

2212

·····················,·path,·ph);

2213

#line·2215·"trace/trace-hw_ppc.h"

2213

#line·2215·"trace/trace-hw_ppc.h"

2214

········}·else·{

2214

········}·else·{

2216

············qemu_log("vof_finddevice·"·"\"%s\"·=>·ph=0x%x"·"\n",·path,·ph);

2216

············qemu_log("vof_finddevice·"·"\"%s\"·=>·ph=0x%x"·"\n",·path,·ph);

2217

#line·2219·"trace/trace-hw_ppc.h"

2217

#line·2219·"trace/trace-hw_ppc.h"

2218

········}

2218

········}

2219

····}

2219

····}

2220

}

2220

}

2221

static·inline·void·trace_vof_finddevice(const·char·*·path,·uint32_t·ph)

2221

static·inline·void·trace_vof_finddevice(const·char·*·path,·uint32_t·ph)

2233

static·inline·void·_nocheck__trace_vof_claim(uint32_t·virt,·uint32_t·size,·uint32_t·align,·uint32_t·ret)

2233

static·inline·void·_nocheck__trace_vof_claim(uint32_t·virt,·uint32_t·size,·uint32_t·align,·uint32_t·ret)

2234

{

2234

{

2235

····if·(trace_event_get_state(TRACE_VOF_CLAIM)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2235

····if·(trace_event_get_state(TRACE_VOF_CLAIM)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2236

········if·(message_with_timestamp)·{

2236

········if·(message_with_timestamp)·{

2237

············struct·timeval·_now;

2237

············struct·timeval·_now;

2238

············gettimeofday(&_now,·NULL);

2238

············gettimeofday(&_now,·NULL);

2240

············qemu_log("%d@%zu.%06zu:vof_claim·"·"virt=0x%x·size=0x%x·align=0x%x·=>·0x%x"·"\n",

2240

············qemu_log("%d@%zu.%06zu:vof_claim·"·"virt=0x%x·size=0x%x·align=0x%x·=>·0x%x"·"\n",

2241

·····················qemu_get_thread_id(),

2241

·····················qemu_get_thread_id(),

2242

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2242

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2243

·····················,·virt,·size,·align,·ret);

2243

·····················,·virt,·size,·align,·ret);

2244

#line·2246·"trace/trace-hw_ppc.h"

2244

#line·2246·"trace/trace-hw_ppc.h"

2245

········}·else·{

2245

········}·else·{

2247

············qemu_log("vof_claim·"·"virt=0x%x·size=0x%x·align=0x%x·=>·0x%x"·"\n",·virt,·size,·align,·ret);

2247

············qemu_log("vof_claim·"·"virt=0x%x·size=0x%x·align=0x%x·=>·0x%x"·"\n",·virt,·size,·align,·ret);

2248

#line·2250·"trace/trace-hw_ppc.h"

2248

#line·2250·"trace/trace-hw_ppc.h"

2249

········}

2249

········}

2250

····}

2250

····}

2251

}

2251

}

2252

static·inline·void·trace_vof_claim(uint32_t·virt,·uint32_t·size,·uint32_t·align,·uint32_t·ret)

2252

static·inline·void·trace_vof_claim(uint32_t·virt,·uint32_t·size,·uint32_t·align,·uint32_t·ret)

2264

static·inline·void·_nocheck__trace_vof_release(uint32_t·virt,·uint32_t·size,·uint32_t·ret)

2264

static·inline·void·_nocheck__trace_vof_release(uint32_t·virt,·uint32_t·size,·uint32_t·ret)

2265

{

2265

{

2266

····if·(trace_event_get_state(TRACE_VOF_RELEASE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2266

····if·(trace_event_get_state(TRACE_VOF_RELEASE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2267

········if·(message_with_timestamp)·{

2267

········if·(message_with_timestamp)·{

2268

············struct·timeval·_now;

2268

············struct·timeval·_now;

2269

············gettimeofday(&_now,·NULL);

2269

············gettimeofday(&_now,·NULL);

2271

············qemu_log("%d@%zu.%06zu:vof_release·"·"virt=0x%x·size=0x%x·=>·0x%x"·"\n",

2271

············qemu_log("%d@%zu.%06zu:vof_release·"·"virt=0x%x·size=0x%x·=>·0x%x"·"\n",

2272

·····················qemu_get_thread_id(),

2272

·····················qemu_get_thread_id(),

2273

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2273

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2274

·····················,·virt,·size,·ret);

2274

·····················,·virt,·size,·ret);

2275

#line·2277·"trace/trace-hw_ppc.h"

2275

#line·2277·"trace/trace-hw_ppc.h"

2276

········}·else·{

2276

········}·else·{

2278

············qemu_log("vof_release·"·"virt=0x%x·size=0x%x·=>·0x%x"·"\n",·virt,·size,·ret);

2278

············qemu_log("vof_release·"·"virt=0x%x·size=0x%x·=>·0x%x"·"\n",·virt,·size,·ret);

2279

#line·2281·"trace/trace-hw_ppc.h"

2279

#line·2281·"trace/trace-hw_ppc.h"

2280

········}

2280

········}

2281

····}

2281

····}

2282

}

2282

}

2283

static·inline·void·trace_vof_release(uint32_t·virt,·uint32_t·size,·uint32_t·ret)

2283

static·inline·void·trace_vof_release(uint32_t·virt,·uint32_t·size,·uint32_t·ret)

2295

static·inline·void·_nocheck__trace_vof_method(uint32_t·ihandle,·const·char·*·method,·uint32_t·param,·uint32_t·ret,·uint32_t·ret2)

2295

static·inline·void·_nocheck__trace_vof_method(uint32_t·ihandle,·const·char·*·method,·uint32_t·param,·uint32_t·ret,·uint32_t·ret2)

2296

{

2296

{

2297

····if·(trace_event_get_state(TRACE_VOF_METHOD)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2297

····if·(trace_event_get_state(TRACE_VOF_METHOD)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2298

········if·(message_with_timestamp)·{

2298

········if·(message_with_timestamp)·{

2299

············struct·timeval·_now;

2299

············struct·timeval·_now;

2300

············gettimeofday(&_now,·NULL);

2300

············gettimeofday(&_now,·NULL);

2302

············qemu_log("%d@%zu.%06zu:vof_method·"·"ih=0x%x·\"%s\"(0x%x)·=>·0x%x·0x%x"·"\n",

2302

············qemu_log("%d@%zu.%06zu:vof_method·"·"ih=0x%x·\"%s\"(0x%x)·=>·0x%x·0x%x"·"\n",

2303

·····················qemu_get_thread_id(),

2303

·····················qemu_get_thread_id(),

2304

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2304

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2305

·····················,·ihandle,·method,·param,·ret,·ret2);

2305

·····················,·ihandle,·method,·param,·ret,·ret2);

2306

#line·2308·"trace/trace-hw_ppc.h"

2306

#line·2308·"trace/trace-hw_ppc.h"

2307

········}·else·{

2307

········}·else·{

2309

············qemu_log("vof_method·"·"ih=0x%x·\"%s\"(0x%x)·=>·0x%x·0x%x"·"\n",·ihandle,·method,·param,·ret,·ret2);

2309

············qemu_log("vof_method·"·"ih=0x%x·\"%s\"(0x%x)·=>·0x%x·0x%x"·"\n",·ihandle,·method,·param,·ret,·ret2);

2310

#line·2312·"trace/trace-hw_ppc.h"

2310

#line·2312·"trace/trace-hw_ppc.h"

2311

········}

2311

········}

2312

····}

2312

····}

2313

}

2313

}

2314

static·inline·void·trace_vof_method(uint32_t·ihandle,·const·char·*·method,·uint32_t·param,·uint32_t·ret,·uint32_t·ret2)

2314

static·inline·void·trace_vof_method(uint32_t·ihandle,·const·char·*·method,·uint32_t·param,·uint32_t·ret,·uint32_t·ret2)

2326

static·inline·void·_nocheck__trace_vof_getprop(uint32_t·ph,·const·char·*·prop,·uint32_t·ret,·const·char·*·val)

2326

static·inline·void·_nocheck__trace_vof_getprop(uint32_t·ph,·const·char·*·prop,·uint32_t·ret,·const·char·*·val)

2327

{

2327

{

2328

····if·(trace_event_get_state(TRACE_VOF_GETPROP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2328

····if·(trace_event_get_state(TRACE_VOF_GETPROP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2329

········if·(message_with_timestamp)·{

2329

········if·(message_with_timestamp)·{

2330

············struct·timeval·_now;

2330

············struct·timeval·_now;

2331

············gettimeofday(&_now,·NULL);

2331

············gettimeofday(&_now,·NULL);

2333

············qemu_log("%d@%zu.%06zu:vof_getprop·"·"ph=0x%x·\"%s\"·=>·len=%d·[%s]"·"\n",

2333

············qemu_log("%d@%zu.%06zu:vof_getprop·"·"ph=0x%x·\"%s\"·=>·len=%d·[%s]"·"\n",

2334

·····················qemu_get_thread_id(),

2334

·····················qemu_get_thread_id(),

2335

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2335

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2336

·····················,·ph,·prop,·ret,·val);

2336

·····················,·ph,·prop,·ret,·val);

2337

#line·2339·"trace/trace-hw_ppc.h"

2337

#line·2339·"trace/trace-hw_ppc.h"

2338

········}·else·{

2338

········}·else·{

2340

············qemu_log("vof_getprop·"·"ph=0x%x·\"%s\"·=>·len=%d·[%s]"·"\n",·ph,·prop,·ret,·val);

2340

············qemu_log("vof_getprop·"·"ph=0x%x·\"%s\"·=>·len=%d·[%s]"·"\n",·ph,·prop,·ret,·val);

2341

#line·2343·"trace/trace-hw_ppc.h"

2341

#line·2343·"trace/trace-hw_ppc.h"

2342

········}

2342

········}

2343

····}

2343

····}

2344

}

2344

}

2345

static·inline·void·trace_vof_getprop(uint32_t·ph,·const·char·*·prop,·uint32_t·ret,·const·char·*·val)

2345

static·inline·void·trace_vof_getprop(uint32_t·ph,·const·char·*·prop,·uint32_t·ret,·const·char·*·val)

2357

static·inline·void·_nocheck__trace_vof_getproplen(uint32_t·ph,·const·char·*·prop,·uint32_t·ret)

2357

static·inline·void·_nocheck__trace_vof_getproplen(uint32_t·ph,·const·char·*·prop,·uint32_t·ret)

2358

{

2358

{

2359

····if·(trace_event_get_state(TRACE_VOF_GETPROPLEN)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2359

····if·(trace_event_get_state(TRACE_VOF_GETPROPLEN)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2360

········if·(message_with_timestamp)·{

2360

········if·(message_with_timestamp)·{

2361

············struct·timeval·_now;

2361

············struct·timeval·_now;

2362

············gettimeofday(&_now,·NULL);

2362

············gettimeofday(&_now,·NULL);

2364

············qemu_log("%d@%zu.%06zu:vof_getproplen·"·"ph=0x%x·\"%s\"·=>·len=%d"·"\n",

2364

············qemu_log("%d@%zu.%06zu:vof_getproplen·"·"ph=0x%x·\"%s\"·=>·len=%d"·"\n",

2365

·····················qemu_get_thread_id(),

2365

·····················qemu_get_thread_id(),

2366

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2366

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2367

·····················,·ph,·prop,·ret);

2367

·····················,·ph,·prop,·ret);

2368

#line·2370·"trace/trace-hw_ppc.h"

2368

#line·2370·"trace/trace-hw_ppc.h"

2369

········}·else·{

2369

········}·else·{

2371

············qemu_log("vof_getproplen·"·"ph=0x%x·\"%s\"·=>·len=%d"·"\n",·ph,·prop,·ret);

2371

············qemu_log("vof_getproplen·"·"ph=0x%x·\"%s\"·=>·len=%d"·"\n",·ph,·prop,·ret);

2372

#line·2374·"trace/trace-hw_ppc.h"

2372

#line·2374·"trace/trace-hw_ppc.h"

2373

········}

2373

········}

2374

····}

2374

····}

2375

}

2375

}

2376

static·inline·void·trace_vof_getproplen(uint32_t·ph,·const·char·*·prop,·uint32_t·ret)

2376

static·inline·void·trace_vof_getproplen(uint32_t·ph,·const·char·*·prop,·uint32_t·ret)

2388

static·inline·void·_nocheck__trace_vof_setprop(uint32_t·ph,·const·char·*·prop,·const·char·*·val,·uint32_t·vallen,·uint32_t·ret)

2388

static·inline·void·_nocheck__trace_vof_setprop(uint32_t·ph,·const·char·*·prop,·const·char·*·val,·uint32_t·vallen,·uint32_t·ret)

2389

{

2389

{

2390

····if·(trace_event_get_state(TRACE_VOF_SETPROP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2390

····if·(trace_event_get_state(TRACE_VOF_SETPROP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2391

········if·(message_with_timestamp)·{

2391

········if·(message_with_timestamp)·{

2392

············struct·timeval·_now;

2392

············struct·timeval·_now;

2393

············gettimeofday(&_now,·NULL);

2393

············gettimeofday(&_now,·NULL);

2395

············qemu_log("%d@%zu.%06zu:vof_setprop·"·"ph=0x%x·\"%s\"·[%s]·len=%d·=>·ret=%d"·"\n",

2395

············qemu_log("%d@%zu.%06zu:vof_setprop·"·"ph=0x%x·\"%s\"·[%s]·len=%d·=>·ret=%d"·"\n",

2396

·····················qemu_get_thread_id(),

2396

·····················qemu_get_thread_id(),

2397

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2397

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2398

·····················,·ph,·prop,·val,·vallen,·ret);

2398

·····················,·ph,·prop,·val,·vallen,·ret);

2399

#line·2401·"trace/trace-hw_ppc.h"

2399

#line·2401·"trace/trace-hw_ppc.h"

2400

········}·else·{

2400

········}·else·{

2402

············qemu_log("vof_setprop·"·"ph=0x%x·\"%s\"·[%s]·len=%d·=>·ret=%d"·"\n",·ph,·prop,·val,·vallen,·ret);

2402

············qemu_log("vof_setprop·"·"ph=0x%x·\"%s\"·[%s]·len=%d·=>·ret=%d"·"\n",·ph,·prop,·val,·vallen,·ret);

2403

#line·2405·"trace/trace-hw_ppc.h"

2403

#line·2405·"trace/trace-hw_ppc.h"

2404

········}

2404

········}

2405

····}

2405

····}

2406

}

2406

}

2407

static·inline·void·trace_vof_setprop(uint32_t·ph,·const·char·*·prop,·const·char·*·val,·uint32_t·vallen,·uint32_t·ret)

2407

static·inline·void·trace_vof_setprop(uint32_t·ph,·const·char·*·prop,·const·char·*·val,·uint32_t·vallen,·uint32_t·ret)

2419

static·inline·void·_nocheck__trace_vof_open(const·char·*·path,·uint32_t·ph,·uint32_t·ih)

2419

static·inline·void·_nocheck__trace_vof_open(const·char·*·path,·uint32_t·ph,·uint32_t·ih)

2420

{

2420

{

2421

····if·(trace_event_get_state(TRACE_VOF_OPEN)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2421

····if·(trace_event_get_state(TRACE_VOF_OPEN)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2422

········if·(message_with_timestamp)·{

2422

········if·(message_with_timestamp)·{

2423

············struct·timeval·_now;

2423

············struct·timeval·_now;

2424

············gettimeofday(&_now,·NULL);

2424

············gettimeofday(&_now,·NULL);

2426

············qemu_log("%d@%zu.%06zu:vof_open·"·"%s·ph=0x%x·=>·ih=0x%x"·"\n",

2426

············qemu_log("%d@%zu.%06zu:vof_open·"·"%s·ph=0x%x·=>·ih=0x%x"·"\n",

2427

·····················qemu_get_thread_id(),

2427

·····················qemu_get_thread_id(),

2428

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2428

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2429

·····················,·path,·ph,·ih);

2429

·····················,·path,·ph,·ih);

2430

#line·2432·"trace/trace-hw_ppc.h"

2430

#line·2432·"trace/trace-hw_ppc.h"

2431

········}·else·{

2431

········}·else·{

2433

············qemu_log("vof_open·"·"%s·ph=0x%x·=>·ih=0x%x"·"\n",·path,·ph,·ih);

2433

············qemu_log("vof_open·"·"%s·ph=0x%x·=>·ih=0x%x"·"\n",·path,·ph,·ih);

2434

#line·2436·"trace/trace-hw_ppc.h"

2434

#line·2436·"trace/trace-hw_ppc.h"

2435

········}

2435

········}

2436

····}

2436

····}

2437

}

2437

}

2438

static·inline·void·trace_vof_open(const·char·*·path,·uint32_t·ph,·uint32_t·ih)

2438

static·inline·void·trace_vof_open(const·char·*·path,·uint32_t·ph,·uint32_t·ih)

2450

static·inline·void·_nocheck__trace_vof_interpret(const·char·*·cmd,·uint32_t·param1,·uint32_t·param2,·uint32_t·ret,·uint32_t·ret2)

2450

static·inline·void·_nocheck__trace_vof_interpret(const·char·*·cmd,·uint32_t·param1,·uint32_t·param2,·uint32_t·ret,·uint32_t·ret2)

2451

{

2451

{

2452

····if·(trace_event_get_state(TRACE_VOF_INTERPRET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2452

····if·(trace_event_get_state(TRACE_VOF_INTERPRET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2453

········if·(message_with_timestamp)·{

2453

········if·(message_with_timestamp)·{

2454

············struct·timeval·_now;

2454

············struct·timeval·_now;

2455

············gettimeofday(&_now,·NULL);

2455

············gettimeofday(&_now,·NULL);

2457

············qemu_log("%d@%zu.%06zu:vof_interpret·"·"[%s]·0x%x·0x%x·=>·0x%x·0x%x"·"\n",

2457

············qemu_log("%d@%zu.%06zu:vof_interpret·"·"[%s]·0x%x·0x%x·=>·0x%x·0x%x"·"\n",

2458

·····················qemu_get_thread_id(),

2458

·····················qemu_get_thread_id(),

2459

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2459

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2460

·····················,·cmd,·param1,·param2,·ret,·ret2);

2460

·····················,·cmd,·param1,·param2,·ret,·ret2);

2461

#line·2463·"trace/trace-hw_ppc.h"

2461

#line·2463·"trace/trace-hw_ppc.h"

2462

········}·else·{

2462

········}·else·{

2464

············qemu_log("vof_interpret·"·"[%s]·0x%x·0x%x·=>·0x%x·0x%x"·"\n",·cmd,·param1,·param2,·ret,·ret2);

2464

············qemu_log("vof_interpret·"·"[%s]·0x%x·0x%x·=>·0x%x·0x%x"·"\n",·cmd,·param1,·param2,·ret,·ret2);

2465

#line·2467·"trace/trace-hw_ppc.h"

2465

#line·2467·"trace/trace-hw_ppc.h"

2466

········}

2466

········}

2467

····}

2467

····}

2468

}

2468

}

2469

static·inline·void·trace_vof_interpret(const·char·*·cmd,·uint32_t·param1,·uint32_t·param2,·uint32_t·ret,·uint32_t·ret2)

2469

static·inline·void·trace_vof_interpret(const·char·*·cmd,·uint32_t·param1,·uint32_t·param2,·uint32_t·ret,·uint32_t·ret2)

2481

static·inline·void·_nocheck__trace_vof_package_to_path(uint32_t·ph,·const·char·*·tmp,·int·ret)

2481

static·inline·void·_nocheck__trace_vof_package_to_path(uint32_t·ph,·const·char·*·tmp,·int·ret)

2482

{

2482

{

2483

····if·(trace_event_get_state(TRACE_VOF_PACKAGE_TO_PATH)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2483

····if·(trace_event_get_state(TRACE_VOF_PACKAGE_TO_PATH)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2484

········if·(message_with_timestamp)·{

2484

········if·(message_with_timestamp)·{

2485

············struct·timeval·_now;

2485

············struct·timeval·_now;

2486

············gettimeofday(&_now,·NULL);

2486

············gettimeofday(&_now,·NULL);

2488

············qemu_log("%d@%zu.%06zu:vof_package_to_path·"·"ph=0x%x·=>·%s·len=%d"·"\n",

2488

············qemu_log("%d@%zu.%06zu:vof_package_to_path·"·"ph=0x%x·=>·%s·len=%d"·"\n",

2489

·····················qemu_get_thread_id(),

2489

·····················qemu_get_thread_id(),

2490

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2490

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2491

·····················,·ph,·tmp,·ret);

2491

·····················,·ph,·tmp,·ret);

2492

#line·2494·"trace/trace-hw_ppc.h"

2492

#line·2494·"trace/trace-hw_ppc.h"

2493

········}·else·{

2493

········}·else·{

2495

············qemu_log("vof_package_to_path·"·"ph=0x%x·=>·%s·len=%d"·"\n",·ph,·tmp,·ret);

2495

············qemu_log("vof_package_to_path·"·"ph=0x%x·=>·%s·len=%d"·"\n",·ph,·tmp,·ret);

2496

#line·2498·"trace/trace-hw_ppc.h"

2496

#line·2498·"trace/trace-hw_ppc.h"

2497

········}

2497

········}

2498

····}

2498

····}

2499

}

2499

}

2500

static·inline·void·trace_vof_package_to_path(uint32_t·ph,·const·char·*·tmp,·int·ret)

2500

static·inline·void·trace_vof_package_to_path(uint32_t·ph,·const·char·*·tmp,·int·ret)

2512

static·inline·void·_nocheck__trace_vof_instance_to_path(uint32_t·ih,·uint32_t·ph,·const·char·*·tmp,·int·ret)

2512

static·inline·void·_nocheck__trace_vof_instance_to_path(uint32_t·ih,·uint32_t·ph,·const·char·*·tmp,·int·ret)

2513

{

2513

{

2514

····if·(trace_event_get_state(TRACE_VOF_INSTANCE_TO_PATH)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2514

····if·(trace_event_get_state(TRACE_VOF_INSTANCE_TO_PATH)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2515

········if·(message_with_timestamp)·{

2515

········if·(message_with_timestamp)·{

2516

············struct·timeval·_now;

2516

············struct·timeval·_now;

2517

············gettimeofday(&_now,·NULL);

2517

············gettimeofday(&_now,·NULL);

2519

············qemu_log("%d@%zu.%06zu:vof_instance_to_path·"·"ih=0x%x·ph=0x%x·=>·%s·len=%d"·"\n",

2519

············qemu_log("%d@%zu.%06zu:vof_instance_to_path·"·"ih=0x%x·ph=0x%x·=>·%s·len=%d"·"\n",

2520

·····················qemu_get_thread_id(),

2520

·····················qemu_get_thread_id(),

2521

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2521

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2522

·····················,·ih,·ph,·tmp,·ret);

2522

·····················,·ih,·ph,·tmp,·ret);

2523

#line·2525·"trace/trace-hw_ppc.h"

2523

#line·2525·"trace/trace-hw_ppc.h"

2524

········}·else·{

2524

········}·else·{

2526

············qemu_log("vof_instance_to_path·"·"ih=0x%x·ph=0x%x·=>·%s·len=%d"·"\n",·ih,·ph,·tmp,·ret);

2526

············qemu_log("vof_instance_to_path·"·"ih=0x%x·ph=0x%x·=>·%s·len=%d"·"\n",·ih,·ph,·tmp,·ret);

2527

#line·2529·"trace/trace-hw_ppc.h"

2527

#line·2529·"trace/trace-hw_ppc.h"

2528

········}

2528

········}

2529

····}

2529

····}

2530

}

2530

}

2531

static·inline·void·trace_vof_instance_to_path(uint32_t·ih,·uint32_t·ph,·const·char·*·tmp,·int·ret)

2531

static·inline·void·trace_vof_instance_to_path(uint32_t·ih,·uint32_t·ph,·const·char·*·tmp,·int·ret)

2543

static·inline·void·_nocheck__trace_vof_instance_to_package(uint32_t·ih,·uint32_t·ph)

2543

static·inline·void·_nocheck__trace_vof_instance_to_package(uint32_t·ih,·uint32_t·ph)

2544

{

2544

{

2545

····if·(trace_event_get_state(TRACE_VOF_INSTANCE_TO_PACKAGE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2545

····if·(trace_event_get_state(TRACE_VOF_INSTANCE_TO_PACKAGE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2546

········if·(message_with_timestamp)·{

2546

········if·(message_with_timestamp)·{

2547

············struct·timeval·_now;

2547

············struct·timeval·_now;

2548

············gettimeofday(&_now,·NULL);

2548

············gettimeofday(&_now,·NULL);

2550

············qemu_log("%d@%zu.%06zu:vof_instance_to_package·"·"ih=0x%x·=>·ph=0x%x"·"\n",

2550

············qemu_log("%d@%zu.%06zu:vof_instance_to_package·"·"ih=0x%x·=>·ph=0x%x"·"\n",

2551

·····················qemu_get_thread_id(),

2551

·····················qemu_get_thread_id(),

2552

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2552

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2553

·····················,·ih,·ph);

2553

·····················,·ih,·ph);

2554

#line·2556·"trace/trace-hw_ppc.h"

2554

#line·2556·"trace/trace-hw_ppc.h"

2555

········}·else·{

2555

········}·else·{

2557

············qemu_log("vof_instance_to_package·"·"ih=0x%x·=>·ph=0x%x"·"\n",·ih,·ph);

2557

············qemu_log("vof_instance_to_package·"·"ih=0x%x·=>·ph=0x%x"·"\n",·ih,·ph);

2558

#line·2560·"trace/trace-hw_ppc.h"

2558

#line·2560·"trace/trace-hw_ppc.h"

2559

········}

2559

········}

2560

····}

2560

····}

2561

}

2561

}

2562

static·inline·void·trace_vof_instance_to_package(uint32_t·ih,·uint32_t·ph)

2562

static·inline·void·trace_vof_instance_to_package(uint32_t·ih,·uint32_t·ph)

2574

static·inline·void·_nocheck__trace_vof_write(uint32_t·ih,·unsigned·cb,·const·char·*·msg)

2574

static·inline·void·_nocheck__trace_vof_write(uint32_t·ih,·unsigned·cb,·const·char·*·msg)

2575

{

2575

{

2576

····if·(trace_event_get_state(TRACE_VOF_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2576

····if·(trace_event_get_state(TRACE_VOF_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2577

········if·(message_with_timestamp)·{

2577

········if·(message_with_timestamp)·{

2578

············struct·timeval·_now;

2578

············struct·timeval·_now;

2579

············gettimeofday(&_now,·NULL);

2579

············gettimeofday(&_now,·NULL);

2581

············qemu_log("%d@%zu.%06zu:vof_write·"·"ih=0x%x·[%u]·\"%s\""·"\n",

2581

············qemu_log("%d@%zu.%06zu:vof_write·"·"ih=0x%x·[%u]·\"%s\""·"\n",

2582

·····················qemu_get_thread_id(),

2582

·····················qemu_get_thread_id(),

2583

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2583

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2584

·····················,·ih,·cb,·msg);

2584

·····················,·ih,·cb,·msg);

2585

#line·2587·"trace/trace-hw_ppc.h"

2585

#line·2587·"trace/trace-hw_ppc.h"

2586

········}·else·{

2586

········}·else·{

2588

············qemu_log("vof_write·"·"ih=0x%x·[%u]·\"%s\""·"\n",·ih,·cb,·msg);

2588

············qemu_log("vof_write·"·"ih=0x%x·[%u]·\"%s\""·"\n",·ih,·cb,·msg);

2589

#line·2591·"trace/trace-hw_ppc.h"

2589

#line·2591·"trace/trace-hw_ppc.h"

2590

········}

2590

········}

2591

····}

2591

····}

2592

}

2592

}

2593

static·inline·void·trace_vof_write(uint32_t·ih,·unsigned·cb,·const·char·*·msg)

2593

static·inline·void·trace_vof_write(uint32_t·ih,·unsigned·cb,·const·char·*·msg)

2605

static·inline·void·_nocheck__trace_vof_avail(uint64_t·start,·uint64_t·end,·uint64_t·size)

2605

static·inline·void·_nocheck__trace_vof_avail(uint64_t·start,·uint64_t·end,·uint64_t·size)

2606

{

2606

{

2607

····if·(trace_event_get_state(TRACE_VOF_AVAIL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2607

····if·(trace_event_get_state(TRACE_VOF_AVAIL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2608

········if·(message_with_timestamp)·{

2608

········if·(message_with_timestamp)·{

2609

············struct·timeval·_now;

2609

············struct·timeval·_now;

2610

············gettimeofday(&_now,·NULL);

2610

············gettimeofday(&_now,·NULL);

2612

············qemu_log("%d@%zu.%06zu:vof_avail·"·"0x%"PRIx64"..0x%"PRIx64"·size=0x%"PRIx64·"\n",

2612

············qemu_log("%d@%zu.%06zu:vof_avail·"·"0x%"PRIx64"..0x%"PRIx64"·size=0x%"PRIx64·"\n",

2613

·····················qemu_get_thread_id(),

2613

·····················qemu_get_thread_id(),

2614

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2614

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2615

·····················,·start,·end,·size);

2615

·····················,·start,·end,·size);

2616

#line·2618·"trace/trace-hw_ppc.h"

2616

#line·2618·"trace/trace-hw_ppc.h"

2617

········}·else·{

2617

········}·else·{

2619

············qemu_log("vof_avail·"·"0x%"PRIx64"..0x%"PRIx64"·size=0x%"PRIx64·"\n",·start,·end,·size);

2619

············qemu_log("vof_avail·"·"0x%"PRIx64"..0x%"PRIx64"·size=0x%"PRIx64·"\n",·start,·end,·size);

2620

#line·2622·"trace/trace-hw_ppc.h"

2620

#line·2622·"trace/trace-hw_ppc.h"

2621

········}

2621

········}

2622

····}

2622

····}

2623

}

2623

}

2624

static·inline·void·trace_vof_avail(uint64_t·start,·uint64_t·end,·uint64_t·size)

2624

static·inline·void·trace_vof_avail(uint64_t·start,·uint64_t·end,·uint64_t·size)

2636

static·inline·void·_nocheck__trace_vof_claimed(uint64_t·start,·uint64_t·end,·uint64_t·size)

2636

static·inline·void·_nocheck__trace_vof_claimed(uint64_t·start,·uint64_t·end,·uint64_t·size)

2637

{

2637

{

2638

····if·(trace_event_get_state(TRACE_VOF_CLAIMED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2638

····if·(trace_event_get_state(TRACE_VOF_CLAIMED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2639

········if·(message_with_timestamp)·{

2639

········if·(message_with_timestamp)·{

2640

············struct·timeval·_now;

2640

············struct·timeval·_now;

2641

············gettimeofday(&_now,·NULL);

2641

············gettimeofday(&_now,·NULL);

2643

············qemu_log("%d@%zu.%06zu:vof_claimed·"·"0x%"PRIx64"..0x%"PRIx64"·size=0x%"PRIx64·"\n",

2643

············qemu_log("%d@%zu.%06zu:vof_claimed·"·"0x%"PRIx64"..0x%"PRIx64"·size=0x%"PRIx64·"\n",

2644

·····················qemu_get_thread_id(),

2644

·····················qemu_get_thread_id(),

2645

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2645

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2646

·····················,·start,·end,·size);

2646

·····················,·start,·end,·size);

2647

#line·2649·"trace/trace-hw_ppc.h"

2647

#line·2649·"trace/trace-hw_ppc.h"

2648

········}·else·{

2648

········}·else·{

2650

············qemu_log("vof_claimed·"·"0x%"PRIx64"..0x%"PRIx64"·size=0x%"PRIx64·"\n",·start,·end,·size);

2650

············qemu_log("vof_claimed·"·"0x%"PRIx64"..0x%"PRIx64"·size=0x%"PRIx64·"\n",·start,·end,·size);

2651

#line·2653·"trace/trace-hw_ppc.h"

2651

#line·2653·"trace/trace-hw_ppc.h"

2652

········}

2652

········}

2653

····}

2653

····}

2654

}

2654

}

2655

static·inline·void·trace_vof_claimed(uint64_t·start,·uint64_t·end,·uint64_t·size)

2655

static·inline·void·trace_vof_claimed(uint64_t·start,·uint64_t·end,·uint64_t·size)

2667

static·inline·void·_nocheck__trace_ppc_tb_adjust(uint64_t·offs1,·uint64_t·offs2,·int64_t·diff,·int64_t·seconds)

2667

static·inline·void·_nocheck__trace_ppc_tb_adjust(uint64_t·offs1,·uint64_t·offs2,·int64_t·diff,·int64_t·seconds)

2668

{

2668

{

2669

····if·(trace_event_get_state(TRACE_PPC_TB_ADJUST)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2669

····if·(trace_event_get_state(TRACE_PPC_TB_ADJUST)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2670

········if·(message_with_timestamp)·{

2670

········if·(message_with_timestamp)·{

2671

············struct·timeval·_now;

2671

············struct·timeval·_now;

2672

············gettimeofday(&_now,·NULL);

2672

············gettimeofday(&_now,·NULL);

2674

············qemu_log("%d@%zu.%06zu:ppc_tb_adjust·"·"adjusted·from·0x%"PRIx64"·to·0x%"PRIx64",·diff·%"PRId64"·(%"PRId64"s)"·"\n",

2674

············qemu_log("%d@%zu.%06zu:ppc_tb_adjust·"·"adjusted·from·0x%"PRIx64"·to·0x%"PRIx64",·diff·%"PRId64"·(%"PRId64"s)"·"\n",

2675

·····················qemu_get_thread_id(),

2675

·····················qemu_get_thread_id(),

2676

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2676

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2677

·····················,·offs1,·offs2,·diff,·seconds);

2677

·····················,·offs1,·offs2,·diff,·seconds);

2678

#line·2680·"trace/trace-hw_ppc.h"

2678

#line·2680·"trace/trace-hw_ppc.h"

2679

········}·else·{

2679

········}·else·{

2681

············qemu_log("ppc_tb_adjust·"·"adjusted·from·0x%"PRIx64"·to·0x%"PRIx64",·diff·%"PRId64"·(%"PRId64"s)"·"\n",·offs1,·offs2,·diff,·seconds);

2681

············qemu_log("ppc_tb_adjust·"·"adjusted·from·0x%"PRIx64"·to·0x%"PRIx64",·diff·%"PRId64"·(%"PRId64"s)"·"\n",·offs1,·offs2,·diff,·seconds);

2682

#line·2684·"trace/trace-hw_ppc.h"

2682

#line·2684·"trace/trace-hw_ppc.h"

2683

········}

2683

········}

2684

····}

2684

····}

2685

}

2685

}

2686

static·inline·void·trace_ppc_tb_adjust(uint64_t·offs1,·uint64_t·offs2,·int64_t·diff,·int64_t·seconds)

2686

static·inline·void·trace_ppc_tb_adjust(uint64_t·offs1,·uint64_t·offs2,·int64_t·diff,·int64_t·seconds)

2698

static·inline·void·_nocheck__trace_ppc_tb_load(uint64_t·tb)

2698

static·inline·void·_nocheck__trace_ppc_tb_load(uint64_t·tb)

2699

{

2699

{

2700

····if·(trace_event_get_state(TRACE_PPC_TB_LOAD)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2700

····if·(trace_event_get_state(TRACE_PPC_TB_LOAD)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2701

········if·(message_with_timestamp)·{

2701

········if·(message_with_timestamp)·{

2702

············struct·timeval·_now;

2702

············struct·timeval·_now;

2703

············gettimeofday(&_now,·NULL);

2703

············gettimeofday(&_now,·NULL);

2705

············qemu_log("%d@%zu.%06zu:ppc_tb_load·"·"tb·0x%016"·PRIx64·"\n",

2705

············qemu_log("%d@%zu.%06zu:ppc_tb_load·"·"tb·0x%016"·PRIx64·"\n",

2706

·····················qemu_get_thread_id(),

2706

·····················qemu_get_thread_id(),

2707

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2707

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2708

·····················,·tb);

2708

·····················,·tb);

2709

#line·2711·"trace/trace-hw_ppc.h"

2709

#line·2711·"trace/trace-hw_ppc.h"

2710

········}·else·{

2710

········}·else·{

2712

············qemu_log("ppc_tb_load·"·"tb·0x%016"·PRIx64·"\n",·tb);

2712

············qemu_log("ppc_tb_load·"·"tb·0x%016"·PRIx64·"\n",·tb);

2713

#line·2715·"trace/trace-hw_ppc.h"

2713

#line·2715·"trace/trace-hw_ppc.h"

2714

········}

2714

········}

2715

····}

2715

····}

2716

}

2716

}

2717

static·inline·void·trace_ppc_tb_load(uint64_t·tb)

2717

static·inline·void·trace_ppc_tb_load(uint64_t·tb)

2729

static·inline·void·_nocheck__trace_ppc_tb_store(uint64_t·tb,·uint64_t·offset)

2729

static·inline·void·_nocheck__trace_ppc_tb_store(uint64_t·tb,·uint64_t·offset)

2730

{

2730

{

2731

····if·(trace_event_get_state(TRACE_PPC_TB_STORE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2731

····if·(trace_event_get_state(TRACE_PPC_TB_STORE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2732

········if·(message_with_timestamp)·{

2732

········if·(message_with_timestamp)·{

2733

············struct·timeval·_now;

2733

············struct·timeval·_now;

2734

············gettimeofday(&_now,·NULL);

2734

············gettimeofday(&_now,·NULL);

2736

············qemu_log("%d@%zu.%06zu:ppc_tb_store·"·"tb·0x%016"·PRIx64·"·offset·0x%08"·PRIx64·"\n",

2736

············qemu_log("%d@%zu.%06zu:ppc_tb_store·"·"tb·0x%016"·PRIx64·"·offset·0x%08"·PRIx64·"\n",

2737

·····················qemu_get_thread_id(),

2737

·····················qemu_get_thread_id(),

2738

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2738

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2739

·····················,·tb,·offset);

2739

·····················,·tb,·offset);

2740

#line·2742·"trace/trace-hw_ppc.h"

2740

#line·2742·"trace/trace-hw_ppc.h"

2741

········}·else·{

2741

········}·else·{

2743

············qemu_log("ppc_tb_store·"·"tb·0x%016"·PRIx64·"·offset·0x%08"·PRIx64·"\n",·tb,·offset);

2743

············qemu_log("ppc_tb_store·"·"tb·0x%016"·PRIx64·"·offset·0x%08"·PRIx64·"\n",·tb,·offset);

2744

#line·2746·"trace/trace-hw_ppc.h"

2744

#line·2746·"trace/trace-hw_ppc.h"

2745

········}

2745

········}

2746

····}

2746

····}

2747

}

2747

}

2748

static·inline·void·trace_ppc_tb_store(uint64_t·tb,·uint64_t·offset)

2748

static·inline·void·trace_ppc_tb_store(uint64_t·tb,·uint64_t·offset)

2760

static·inline·void·_nocheck__trace_ppc_decr_load(uint64_t·tb)

2760

static·inline·void·_nocheck__trace_ppc_decr_load(uint64_t·tb)

2761

{

2761

{

2762

····if·(trace_event_get_state(TRACE_PPC_DECR_LOAD)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2762

····if·(trace_event_get_state(TRACE_PPC_DECR_LOAD)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2763

········if·(message_with_timestamp)·{

2763

········if·(message_with_timestamp)·{

2764

············struct·timeval·_now;

2764

············struct·timeval·_now;

2765

············gettimeofday(&_now,·NULL);

2765

············gettimeofday(&_now,·NULL);

2767

············qemu_log("%d@%zu.%06zu:ppc_decr_load·"·"decr·0x%016"·PRIx64·"\n",

2767

············qemu_log("%d@%zu.%06zu:ppc_decr_load·"·"decr·0x%016"·PRIx64·"\n",

2768

·····················qemu_get_thread_id(),

2768

·····················qemu_get_thread_id(),

2769

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2769

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2770

·····················,·tb);

2770

·····················,·tb);

2771

#line·2773·"trace/trace-hw_ppc.h"

2771

#line·2773·"trace/trace-hw_ppc.h"

2772

········}·else·{

2772

········}·else·{

2774

············qemu_log("ppc_decr_load·"·"decr·0x%016"·PRIx64·"\n",·tb);

2774

············qemu_log("ppc_decr_load·"·"decr·0x%016"·PRIx64·"\n",·tb);

2775

#line·2777·"trace/trace-hw_ppc.h"

2775

#line·2777·"trace/trace-hw_ppc.h"

2776

········}

2776

········}

2777

····}

2777

····}

2778

}

2778

}

2779

static·inline·void·trace_ppc_decr_load(uint64_t·tb)

2779

static·inline·void·trace_ppc_decr_load(uint64_t·tb)

2791

static·inline·void·_nocheck__trace_ppc_decr_excp(const·char·*·action)

2791

static·inline·void·_nocheck__trace_ppc_decr_excp(const·char·*·action)

2792

{

2792

{

2793

····if·(trace_event_get_state(TRACE_PPC_DECR_EXCP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2793

····if·(trace_event_get_state(TRACE_PPC_DECR_EXCP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2794

········if·(message_with_timestamp)·{

2794

········if·(message_with_timestamp)·{

2795

············struct·timeval·_now;

2795

············struct·timeval·_now;

2796

············gettimeofday(&_now,·NULL);

2796

············gettimeofday(&_now,·NULL);

2798

············qemu_log("%d@%zu.%06zu:ppc_decr_excp·"·"%s·decrementer"·"\n",

2798

············qemu_log("%d@%zu.%06zu:ppc_decr_excp·"·"%s·decrementer"·"\n",

2799

·····················qemu_get_thread_id(),

2799

·····················qemu_get_thread_id(),

2800

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2800

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2801

·····················,·action);

2801

·····················,·action);

2802

#line·2804·"trace/trace-hw_ppc.h"

2802

#line·2804·"trace/trace-hw_ppc.h"

2803

········}·else·{

2803

········}·else·{

2805

············qemu_log("ppc_decr_excp·"·"%s·decrementer"·"\n",·action);

2805

············qemu_log("ppc_decr_excp·"·"%s·decrementer"·"\n",·action);

2806

#line·2808·"trace/trace-hw_ppc.h"

2806

#line·2808·"trace/trace-hw_ppc.h"

2807

········}

2807

········}

2808

····}

2808

····}

2809

}

2809

}

2810

static·inline·void·trace_ppc_decr_excp(const·char·*·action)

2810

static·inline·void·trace_ppc_decr_excp(const·char·*·action)

2822

static·inline·void·_nocheck__trace_ppc_decr_store(uint32_t·nr_bits,·uint64_t·decr,·uint64_t·value)

2822

static·inline·void·_nocheck__trace_ppc_decr_store(uint32_t·nr_bits,·uint64_t·decr,·uint64_t·value)

2823

{

2823

{

2824

····if·(trace_event_get_state(TRACE_PPC_DECR_STORE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2824

····if·(trace_event_get_state(TRACE_PPC_DECR_STORE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2825

········if·(message_with_timestamp)·{

2825

········if·(message_with_timestamp)·{

2826

············struct·timeval·_now;

2826

············struct·timeval·_now;

2827

············gettimeofday(&_now,·NULL);

2827

············gettimeofday(&_now,·NULL);

2829

············qemu_log("%d@%zu.%06zu:ppc_decr_store·"·"%d-bit·0x%016"·PRIx64·"·=>·0x%016"·PRIx64·"\n",

2829

············qemu_log("%d@%zu.%06zu:ppc_decr_store·"·"%d-bit·0x%016"·PRIx64·"·=>·0x%016"·PRIx64·"\n",

2830

·····················qemu_get_thread_id(),

2830

·····················qemu_get_thread_id(),

2831

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2831

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2832

·····················,·nr_bits,·decr,·value);

2832

·····················,·nr_bits,·decr,·value);

2833

#line·2835·"trace/trace-hw_ppc.h"

2833

#line·2835·"trace/trace-hw_ppc.h"

2834

········}·else·{

2834

········}·else·{

2836

············qemu_log("ppc_decr_store·"·"%d-bit·0x%016"·PRIx64·"·=>·0x%016"·PRIx64·"\n",·nr_bits,·decr,·value);

2836

············qemu_log("ppc_decr_store·"·"%d-bit·0x%016"·PRIx64·"·=>·0x%016"·PRIx64·"\n",·nr_bits,·decr,·value);

2837

#line·2839·"trace/trace-hw_ppc.h"

2837

#line·2839·"trace/trace-hw_ppc.h"

2838

········}

2838

········}

2839

····}

2839

····}

2840

}

2840

}

2841

static·inline·void·trace_ppc_decr_store(uint32_t·nr_bits,·uint64_t·decr,·uint64_t·value)

2841

static·inline·void·trace_ppc_decr_store(uint32_t·nr_bits,·uint64_t·decr,·uint64_t·value)

2853

static·inline·void·_nocheck__trace_ppc4xx_fit(uint32_t·ir,·uint64_t·tcr,·uint64_t·tsr)

2853

static·inline·void·_nocheck__trace_ppc4xx_fit(uint32_t·ir,·uint64_t·tcr,·uint64_t·tsr)

2854

{

2854

{

2855

····if·(trace_event_get_state(TRACE_PPC4XX_FIT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2855

····if·(trace_event_get_state(TRACE_PPC4XX_FIT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2856

········if·(message_with_timestamp)·{

2856

········if·(message_with_timestamp)·{

2857

············struct·timeval·_now;

2857

············struct·timeval·_now;

2858

············gettimeofday(&_now,·NULL);

2858

············gettimeofday(&_now,·NULL);

2860

············qemu_log("%d@%zu.%06zu:ppc4xx_fit·"·"ir·%d·TCR·0x%"·PRIx64·"·TSR·0x%"·PRIx64·"\n",

2860

············qemu_log("%d@%zu.%06zu:ppc4xx_fit·"·"ir·%d·TCR·0x%"·PRIx64·"·TSR·0x%"·PRIx64·"\n",

2861

·····················qemu_get_thread_id(),

2861

·····················qemu_get_thread_id(),

2862

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2862

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2863

·····················,·ir,·tcr,·tsr);

2863

·····················,·ir,·tcr,·tsr);

2864

#line·2866·"trace/trace-hw_ppc.h"

2864

#line·2866·"trace/trace-hw_ppc.h"

2865

········}·else·{

2865

········}·else·{

2867

············qemu_log("ppc4xx_fit·"·"ir·%d·TCR·0x%"·PRIx64·"·TSR·0x%"·PRIx64·"\n",·ir,·tcr,·tsr);

2867

············qemu_log("ppc4xx_fit·"·"ir·%d·TCR·0x%"·PRIx64·"·TSR·0x%"·PRIx64·"\n",·ir,·tcr,·tsr);

2868

#line·2870·"trace/trace-hw_ppc.h"

2868

#line·2870·"trace/trace-hw_ppc.h"

2869

········}

2869

········}

2870

····}

2870

····}

2871

}

2871

}

2872

static·inline·void·trace_ppc4xx_fit(uint32_t·ir,·uint64_t·tcr,·uint64_t·tsr)

2872

static·inline·void·trace_ppc4xx_fit(uint32_t·ir,·uint64_t·tcr,·uint64_t·tsr)

2884

static·inline·void·_nocheck__trace_ppc4xx_pit_stop(void)

2884

static·inline·void·_nocheck__trace_ppc4xx_pit_stop(void)

2885

{

2885

{

2886

····if·(trace_event_get_state(TRACE_PPC4XX_PIT_STOP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2886

····if·(trace_event_get_state(TRACE_PPC4XX_PIT_STOP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2887

········if·(message_with_timestamp)·{

2887

········if·(message_with_timestamp)·{

2888

············struct·timeval·_now;

2888

············struct·timeval·_now;

2889

············gettimeofday(&_now,·NULL);

2889

············gettimeofday(&_now,·NULL);

2891

············qemu_log("%d@%zu.%06zu:ppc4xx_pit_stop·"·""·"\n",

2891

············qemu_log("%d@%zu.%06zu:ppc4xx_pit_stop·"·""·"\n",

2892

·····················qemu_get_thread_id(),

2892

·····················qemu_get_thread_id(),

2893

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2893

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2894

·····················);

2894

·····················);

2895

#line·2897·"trace/trace-hw_ppc.h"

2895

#line·2897·"trace/trace-hw_ppc.h"

2896

········}·else·{

2896

········}·else·{

2898

············qemu_log("ppc4xx_pit_stop·"·""·"\n");

2898

············qemu_log("ppc4xx_pit_stop·"·""·"\n");

2899

#line·2901·"trace/trace-hw_ppc.h"

2899

#line·2901·"trace/trace-hw_ppc.h"

2900

········}

2900

········}

2901

····}

2901

····}

2902

}

2902

}

2903

static·inline·void·trace_ppc4xx_pit_stop(void)

2903

static·inline·void·trace_ppc4xx_pit_stop(void)

2915

static·inline·void·_nocheck__trace_ppc4xx_pit_start(uint64_t·reload)

2915

static·inline·void·_nocheck__trace_ppc4xx_pit_start(uint64_t·reload)

2916

{

2916

{

2917

····if·(trace_event_get_state(TRACE_PPC4XX_PIT_START)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2917

····if·(trace_event_get_state(TRACE_PPC4XX_PIT_START)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2918

········if·(message_with_timestamp)·{

2918

········if·(message_with_timestamp)·{

2919

············struct·timeval·_now;

2919

············struct·timeval·_now;

2920

············gettimeofday(&_now,·NULL);

2920

············gettimeofday(&_now,·NULL);

2922

············qemu_log("%d@%zu.%06zu:ppc4xx_pit_start·"·"PIT·0x%016"·PRIx64·"\n",

2922

············qemu_log("%d@%zu.%06zu:ppc4xx_pit_start·"·"PIT·0x%016"·PRIx64·"\n",

2923

·····················qemu_get_thread_id(),

2923

·····················qemu_get_thread_id(),

2924

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2924

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2925

·····················,·reload);

2925

·····················,·reload);

2926

#line·2928·"trace/trace-hw_ppc.h"

2926

#line·2928·"trace/trace-hw_ppc.h"

2927

········}·else·{

2927

········}·else·{

2929

············qemu_log("ppc4xx_pit_start·"·"PIT·0x%016"·PRIx64·"\n",·reload);

2929

············qemu_log("ppc4xx_pit_start·"·"PIT·0x%016"·PRIx64·"\n",·reload);

2930

#line·2932·"trace/trace-hw_ppc.h"

2930

#line·2932·"trace/trace-hw_ppc.h"

2931

········}

2931

········}

2932

····}

2932

····}

2933

}

2933

}

2934

static·inline·void·trace_ppc4xx_pit_start(uint64_t·reload)

2934

static·inline·void·trace_ppc4xx_pit_start(uint64_t·reload)

2946

static·inline·void·_nocheck__trace_ppc4xx_pit(uint32_t·ar,·uint32_t·ir,·uint64_t·tcr,·uint64_t·tsr,·uint64_t·reload)

2946

static·inline·void·_nocheck__trace_ppc4xx_pit(uint32_t·ar,·uint32_t·ir,·uint64_t·tcr,·uint64_t·tsr,·uint64_t·reload)

2947

{

2947

{

2948

····if·(trace_event_get_state(TRACE_PPC4XX_PIT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2948

····if·(trace_event_get_state(TRACE_PPC4XX_PIT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2949

········if·(message_with_timestamp)·{

2949

········if·(message_with_timestamp)·{

2950

············struct·timeval·_now;

2950

············struct·timeval·_now;

2951

············gettimeofday(&_now,·NULL);

2951

············gettimeofday(&_now,·NULL);

2953

············qemu_log("%d@%zu.%06zu:ppc4xx_pit·"·"ar·%d·ir·%d·TCR·0x%"·PRIx64·"·TSR·0x%"·PRIx64·"·PIT·0x%016"·PRIx64·"\n",

2953

············qemu_log("%d@%zu.%06zu:ppc4xx_pit·"·"ar·%d·ir·%d·TCR·0x%"·PRIx64·"·TSR·0x%"·PRIx64·"·PIT·0x%016"·PRIx64·"\n",

2954

·····················qemu_get_thread_id(),

2954

·····················qemu_get_thread_id(),

2955

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2955

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2956

·····················,·ar,·ir,·tcr,·tsr,·reload);

2956

·····················,·ar,·ir,·tcr,·tsr,·reload);

2957

#line·2959·"trace/trace-hw_ppc.h"

2957

#line·2959·"trace/trace-hw_ppc.h"

2958

········}·else·{

2958

········}·else·{

2960

············qemu_log("ppc4xx_pit·"·"ar·%d·ir·%d·TCR·0x%"·PRIx64·"·TSR·0x%"·PRIx64·"·PIT·0x%016"·PRIx64·"\n",·ar,·ir,·tcr,·tsr,·reload);

2960

············qemu_log("ppc4xx_pit·"·"ar·%d·ir·%d·TCR·0x%"·PRIx64·"·TSR·0x%"·PRIx64·"·PIT·0x%016"·PRIx64·"\n",·ar,·ir,·tcr,·tsr,·reload);

2961

#line·2963·"trace/trace-hw_ppc.h"

2961

#line·2963·"trace/trace-hw_ppc.h"

2962

········}

2962

········}

2963

····}

2963

····}

2964

}

2964

}

2965

static·inline·void·trace_ppc4xx_pit(uint32_t·ar,·uint32_t·ir,·uint64_t·tcr,·uint64_t·tsr,·uint64_t·reload)

2965

static·inline·void·trace_ppc4xx_pit(uint32_t·ar,·uint32_t·ir,·uint64_t·tcr,·uint64_t·tsr,·uint64_t·reload)

2977

static·inline·void·_nocheck__trace_ppc4xx_wdt(uint64_t·tcr,·uint64_t·tsr)

2977

static·inline·void·_nocheck__trace_ppc4xx_wdt(uint64_t·tcr,·uint64_t·tsr)

2978

{

2978

{

2979

····if·(trace_event_get_state(TRACE_PPC4XX_WDT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2979

····if·(trace_event_get_state(TRACE_PPC4XX_WDT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2980

········if·(message_with_timestamp)·{

2980

········if·(message_with_timestamp)·{

2981

············struct·timeval·_now;

2981

············struct·timeval·_now;

2982

············gettimeofday(&_now,·NULL);

2982

············gettimeofday(&_now,·NULL);

2984

············qemu_log("%d@%zu.%06zu:ppc4xx_wdt·"·"TCR·0x%"·PRIx64·"·TSR·0x%"·PRIx64·"\n",

2984

············qemu_log("%d@%zu.%06zu:ppc4xx_wdt·"·"TCR·0x%"·PRIx64·"·TSR·0x%"·PRIx64·"\n",

2985

·····················qemu_get_thread_id(),

2985

·····················qemu_get_thread_id(),

2986

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2986

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2987

·····················,·tcr,·tsr);

2987

·····················,·tcr,·tsr);

2988

#line·2990·"trace/trace-hw_ppc.h"

2988

#line·2990·"trace/trace-hw_ppc.h"

2989

········}·else·{

2989

········}·else·{

2991

············qemu_log("ppc4xx_wdt·"·"TCR·0x%"·PRIx64·"·TSR·0x%"·PRIx64·"\n",·tcr,·tsr);

2991

············qemu_log("ppc4xx_wdt·"·"TCR·0x%"·PRIx64·"·TSR·0x%"·PRIx64·"\n",·tcr,·tsr);

2992

#line·2994·"trace/trace-hw_ppc.h"

2992

#line·2994·"trace/trace-hw_ppc.h"

2993

········}

2993

········}

2994

····}

2994

····}

2995

}

2995

}

2996

static·inline·void·trace_ppc4xx_wdt(uint64_t·tcr,·uint64_t·tsr)

2996

static·inline·void·trace_ppc4xx_wdt(uint64_t·tcr,·uint64_t·tsr)

3008

static·inline·void·_nocheck__trace_ppc40x_store_pit(uint64_t·value)

3008

static·inline·void·_nocheck__trace_ppc40x_store_pit(uint64_t·value)

3009

{

3009

{

3010

····if·(trace_event_get_state(TRACE_PPC40X_STORE_PIT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3010

····if·(trace_event_get_state(TRACE_PPC40X_STORE_PIT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3011

········if·(message_with_timestamp)·{

3011

········if·(message_with_timestamp)·{

3012

············struct·timeval·_now;

3012

············struct·timeval·_now;

3013

············gettimeofday(&_now,·NULL);

3013

············gettimeofday(&_now,·NULL);

3015

············qemu_log("%d@%zu.%06zu:ppc40x_store_pit·"·"val·0x%"·PRIx64·"\n",

3015

············qemu_log("%d@%zu.%06zu:ppc40x_store_pit·"·"val·0x%"·PRIx64·"\n",

3016

·····················qemu_get_thread_id(),

3016

·····················qemu_get_thread_id(),

3017

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3017

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3018

·····················,·value);

3018

·····················,·value);

3019

#line·3021·"trace/trace-hw_ppc.h"

3019

#line·3021·"trace/trace-hw_ppc.h"

3020

········}·else·{

3020

········}·else·{

3022

············qemu_log("ppc40x_store_pit·"·"val·0x%"·PRIx64·"\n",·value);

3022

············qemu_log("ppc40x_store_pit·"·"val·0x%"·PRIx64·"\n",·value);

3023

#line·3025·"trace/trace-hw_ppc.h"

3023

#line·3025·"trace/trace-hw_ppc.h"

3024

········}

3024

········}

3025

····}

3025

····}

3026

}

3026

}

3027

static·inline·void·trace_ppc40x_store_pit(uint64_t·value)

3027

static·inline·void·trace_ppc40x_store_pit(uint64_t·value)

3039

static·inline·void·_nocheck__trace_ppc40x_set_tb_clk(uint32_t·value)

3039

static·inline·void·_nocheck__trace_ppc40x_set_tb_clk(uint32_t·value)

3040

{

3040

{

3041

····if·(trace_event_get_state(TRACE_PPC40X_SET_TB_CLK)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3041

····if·(trace_event_get_state(TRACE_PPC40X_SET_TB_CLK)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3042

········if·(message_with_timestamp)·{

3042

········if·(message_with_timestamp)·{

3043

············struct·timeval·_now;

3043

············struct·timeval·_now;

3044

············gettimeofday(&_now,·NULL);

3044

············gettimeofday(&_now,·NULL);

3046

············qemu_log("%d@%zu.%06zu:ppc40x_set_tb_clk·"·"new·frequency·%"·PRIu32·"\n",

3046

············qemu_log("%d@%zu.%06zu:ppc40x_set_tb_clk·"·"new·frequency·%"·PRIu32·"\n",

3047

·····················qemu_get_thread_id(),

3047

·····················qemu_get_thread_id(),

3048

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3048

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3049

·····················,·value);

3049

·····················,·value);

3050

#line·3052·"trace/trace-hw_ppc.h"

3050

#line·3052·"trace/trace-hw_ppc.h"

3051

········}·else·{

3051

········}·else·{

3053

············qemu_log("ppc40x_set_tb_clk·"·"new·frequency·%"·PRIu32·"\n",·value);

3053

············qemu_log("ppc40x_set_tb_clk·"·"new·frequency·%"·PRIu32·"\n",·value);

3054

#line·3056·"trace/trace-hw_ppc.h"

3054

#line·3056·"trace/trace-hw_ppc.h"

3055

········}

3055

········}

3056

····}

3056

····}

3057

}

3057

}

3058

static·inline·void·trace_ppc40x_set_tb_clk(uint32_t·value)

3058

static·inline·void·trace_ppc40x_set_tb_clk(uint32_t·value)

3070

static·inline·void·_nocheck__trace_ppc40x_timers_init(uint32_t·value)

3070

static·inline·void·_nocheck__trace_ppc40x_timers_init(uint32_t·value)

3071

{

3071

{

3072

····if·(trace_event_get_state(TRACE_PPC40X_TIMERS_INIT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3072

····if·(trace_event_get_state(TRACE_PPC40X_TIMERS_INIT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3073

········if·(message_with_timestamp)·{

3073

········if·(message_with_timestamp)·{

3074

············struct·timeval·_now;

3074

············struct·timeval·_now;

3075

············gettimeofday(&_now,·NULL);

3075

············gettimeofday(&_now,·NULL);

3077

············qemu_log("%d@%zu.%06zu:ppc40x_timers_init·"·"frequency·%"·PRIu32·"\n",

3077

············qemu_log("%d@%zu.%06zu:ppc40x_timers_init·"·"frequency·%"·PRIu32·"\n",

3078

·····················qemu_get_thread_id(),

3078

·····················qemu_get_thread_id(),

3079

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3079

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3080

·····················,·value);

3080

·····················,·value);

3081

#line·3083·"trace/trace-hw_ppc.h"

3081

#line·3083·"trace/trace-hw_ppc.h"

3082

········}·else·{

3082

········}·else·{

3084

············qemu_log("ppc40x_timers_init·"·"frequency·%"·PRIu32·"\n",·value);

3084

············qemu_log("ppc40x_timers_init·"·"frequency·%"·PRIu32·"\n",·value);

3085

#line·3087·"trace/trace-hw_ppc.h"

3085

#line·3087·"trace/trace-hw_ppc.h"

3086

········}

3086

········}

3087

····}

3087

····}

3088

}

3088

}

3089

static·inline·void·trace_ppc40x_timers_init(uint32_t·value)

3089

static·inline·void·trace_ppc40x_timers_init(uint32_t·value)

3101

static·inline·void·_nocheck__trace_ppc_irq_set(void·*·env,·uint32_t·pin,·uint32_t·level)

3101

static·inline·void·_nocheck__trace_ppc_irq_set(void·*·env,·uint32_t·pin,·uint32_t·level)

3102

{

3102

{

3103

····if·(trace_event_get_state(TRACE_PPC_IRQ_SET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3103

····if·(trace_event_get_state(TRACE_PPC_IRQ_SET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3104

········if·(message_with_timestamp)·{

3104

········if·(message_with_timestamp)·{

3105

············struct·timeval·_now;

3105

············struct·timeval·_now;

3106

············gettimeofday(&_now,·NULL);

3106

············gettimeofday(&_now,·NULL);

3108

············qemu_log("%d@%zu.%06zu:ppc_irq_set·"·"env·[%p]·pin·%d·level·%d"·"\n",

3108

············qemu_log("%d@%zu.%06zu:ppc_irq_set·"·"env·[%p]·pin·%d·level·%d"·"\n",

3109

·····················qemu_get_thread_id(),

3109

·····················qemu_get_thread_id(),

3110

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3110

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3111

·····················,·env,·pin,·level);

3111

·····················,·env,·pin,·level);

3112

#line·3114·"trace/trace-hw_ppc.h"

3112

#line·3114·"trace/trace-hw_ppc.h"

3113

········}·else·{

3113

········}·else·{

3115

············qemu_log("ppc_irq_set·"·"env·[%p]·pin·%d·level·%d"·"\n",·env,·pin,·level);

3115

············qemu_log("ppc_irq_set·"·"env·[%p]·pin·%d·level·%d"·"\n",·env,·pin,·level);

3116

#line·3118·"trace/trace-hw_ppc.h"

3116

#line·3118·"trace/trace-hw_ppc.h"

3117

········}

3117

········}

3118

····}

3118

····}

3119

}

3119

}

3120

static·inline·void·trace_ppc_irq_set(void·*·env,·uint32_t·pin,·uint32_t·level)

3120

static·inline·void·trace_ppc_irq_set(void·*·env,·uint32_t·pin,·uint32_t·level)

3132

static·inline·void·_nocheck__trace_ppc_irq_set_exit(void·*·env,·uint32_t·n_IRQ,·uint32_t·level,·uint32_t·pending,·uint32_t·request)

3132

static·inline·void·_nocheck__trace_ppc_irq_set_exit(void·*·env,·uint32_t·n_IRQ,·uint32_t·level,·uint32_t·pending,·uint32_t·request)

3133

{

3133

{

3134

····if·(trace_event_get_state(TRACE_PPC_IRQ_SET_EXIT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3134

····if·(trace_event_get_state(TRACE_PPC_IRQ_SET_EXIT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3135

········if·(message_with_timestamp)·{

3135

········if·(message_with_timestamp)·{

3136

············struct·timeval·_now;

3136

············struct·timeval·_now;

3137

············gettimeofday(&_now,·NULL);

3137

············gettimeofday(&_now,·NULL);

3139

············qemu_log("%d@%zu.%06zu:ppc_irq_set_exit·"·"env·[%p]·n_IRQ·%d·level·%d·=>·pending·0x%08"·PRIx32·"·req·0x%08"·PRIx32·"\n",

3139

············qemu_log("%d@%zu.%06zu:ppc_irq_set_exit·"·"env·[%p]·n_IRQ·%d·level·%d·=>·pending·0x%08"·PRIx32·"·req·0x%08"·PRIx32·"\n",

3140

·····················qemu_get_thread_id(),

3140

·····················qemu_get_thread_id(),

3141

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3141

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3142

·····················,·env,·n_IRQ,·level,·pending,·request);

3142

·····················,·env,·n_IRQ,·level,·pending,·request);

3143

#line·3145·"trace/trace-hw_ppc.h"

3143

#line·3145·"trace/trace-hw_ppc.h"

3144

········}·else·{

3144

········}·else·{

3146

············qemu_log("ppc_irq_set_exit·"·"env·[%p]·n_IRQ·%d·level·%d·=>·pending·0x%08"·PRIx32·"·req·0x%08"·PRIx32·"\n",·env,·n_IRQ,·level,·pending,·request);

3146

············qemu_log("ppc_irq_set_exit·"·"env·[%p]·n_IRQ·%d·level·%d·=>·pending·0x%08"·PRIx32·"·req·0x%08"·PRIx32·"\n",·env,·n_IRQ,·level,·pending,·request);

3147

#line·3149·"trace/trace-hw_ppc.h"

3147

#line·3149·"trace/trace-hw_ppc.h"

3148

········}

3148

········}

3149

····}

3149

····}

3150

}

3150

}

3151

static·inline·void·trace_ppc_irq_set_exit(void·*·env,·uint32_t·n_IRQ,·uint32_t·level,·uint32_t·pending,·uint32_t·request)

3151

static·inline·void·trace_ppc_irq_set_exit(void·*·env,·uint32_t·n_IRQ,·uint32_t·level,·uint32_t·pending,·uint32_t·request)

3163

static·inline·void·_nocheck__trace_ppc_irq_set_state(const·char·*·name,·uint32_t·level)

3163

static·inline·void·_nocheck__trace_ppc_irq_set_state(const·char·*·name,·uint32_t·level)

3164

{

3164

{

3165

····if·(trace_event_get_state(TRACE_PPC_IRQ_SET_STATE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3165

····if·(trace_event_get_state(TRACE_PPC_IRQ_SET_STATE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3166

········if·(message_with_timestamp)·{

3166

········if·(message_with_timestamp)·{

3167

············struct·timeval·_now;

3167

············struct·timeval·_now;

3168

············gettimeofday(&_now,·NULL);

3168

············gettimeofday(&_now,·NULL);

3170

············qemu_log("%d@%zu.%06zu:ppc_irq_set_state·"·"\"%s\"·level·%d"·"\n",

3170

············qemu_log("%d@%zu.%06zu:ppc_irq_set_state·"·"\"%s\"·level·%d"·"\n",

3171

·····················qemu_get_thread_id(),

3171

·····················qemu_get_thread_id(),

3172

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3172

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3173

·····················,·name,·level);

3173

·····················,·name,·level);

3174

#line·3176·"trace/trace-hw_ppc.h"

3174

#line·3176·"trace/trace-hw_ppc.h"

3175

········}·else·{

3175

········}·else·{

3177

············qemu_log("ppc_irq_set_state·"·"\"%s\"·level·%d"·"\n",·name,·level);

3177

············qemu_log("ppc_irq_set_state·"·"\"%s\"·level·%d"·"\n",·name,·level);

3178

#line·3180·"trace/trace-hw_ppc.h"

3178

#line·3180·"trace/trace-hw_ppc.h"

3179

········}

3179

········}

3180

····}

3180

····}

3181

}

3181

}

3182

static·inline·void·trace_ppc_irq_set_state(const·char·*·name,·uint32_t·level)

3182

static·inline·void·trace_ppc_irq_set_state(const·char·*·name,·uint32_t·level)

3194

static·inline·void·_nocheck__trace_ppc_irq_reset(const·char·*·name)

3194

static·inline·void·_nocheck__trace_ppc_irq_reset(const·char·*·name)

3195

{

3195

{

3196

····if·(trace_event_get_state(TRACE_PPC_IRQ_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3196

····if·(trace_event_get_state(TRACE_PPC_IRQ_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3197

········if·(message_with_timestamp)·{

3197

········if·(message_with_timestamp)·{

3198

············struct·timeval·_now;

3198

············struct·timeval·_now;

3199

············gettimeofday(&_now,·NULL);

3199

············gettimeofday(&_now,·NULL);

3201

············qemu_log("%d@%zu.%06zu:ppc_irq_reset·"·"%s"·"\n",

3201

············qemu_log("%d@%zu.%06zu:ppc_irq_reset·"·"%s"·"\n",

3202

·····················qemu_get_thread_id(),

3202

·····················qemu_get_thread_id(),

3203

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3203

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3204

·····················,·name);

3204

·····················,·name);

3205

#line·3207·"trace/trace-hw_ppc.h"

3205

#line·3207·"trace/trace-hw_ppc.h"

3206

········}·else·{

3206

········}·else·{

3208

············qemu_log("ppc_irq_reset·"·"%s"·"\n",·name);

3208

············qemu_log("ppc_irq_reset·"·"%s"·"\n",·name);

3209

#line·3211·"trace/trace-hw_ppc.h"

3209

#line·3211·"trace/trace-hw_ppc.h"

3210

········}

3210

········}

3211

····}

3211

····}

3212

}

3212

}

3213

static·inline·void·trace_ppc_irq_reset(const·char·*·name)

3213

static·inline·void·trace_ppc_irq_reset(const·char·*·name)

3225

static·inline·void·_nocheck__trace_ppc_irq_cpu(const·char·*·action)

3225

static·inline·void·_nocheck__trace_ppc_irq_cpu(const·char·*·action)

3226

{

3226

{

3227

····if·(trace_event_get_state(TRACE_PPC_IRQ_CPU)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3227

····if·(trace_event_get_state(TRACE_PPC_IRQ_CPU)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3228

········if·(message_with_timestamp)·{

3228

········if·(message_with_timestamp)·{

3229

············struct·timeval·_now;

3229

············struct·timeval·_now;

3230

············gettimeofday(&_now,·NULL);

3230

············gettimeofday(&_now,·NULL);

3232

············qemu_log("%d@%zu.%06zu:ppc_irq_cpu·"·"%s"·"\n",

3232

············qemu_log("%d@%zu.%06zu:ppc_irq_cpu·"·"%s"·"\n",

3233

·····················qemu_get_thread_id(),

3233

·····················qemu_get_thread_id(),

3234

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3234

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3235

·····················,·action);

3235

·····················,·action);

3236

#line·3238·"trace/trace-hw_ppc.h"

3236

#line·3238·"trace/trace-hw_ppc.h"

3237

········}·else·{

3237

········}·else·{

3239

············qemu_log("ppc_irq_cpu·"·"%s"·"\n",·action);

3239

············qemu_log("ppc_irq_cpu·"·"%s"·"\n",·action);

3240

#line·3242·"trace/trace-hw_ppc.h"

3240

#line·3242·"trace/trace-hw_ppc.h"

3241

········}

3241

········}

3242

····}

3242

····}

3243

}

3243

}

3244

static·inline·void·trace_ppc_irq_cpu(const·char·*·action)

3244

static·inline·void·trace_ppc_irq_cpu(const·char·*·action)

3256

static·inline·void·_nocheck__trace_prep_systemio_read(uint32_t·addr,·uint32_t·val)

3256

static·inline·void·_nocheck__trace_prep_systemio_read(uint32_t·addr,·uint32_t·val)

3257

{

3257

{

3258

····if·(trace_event_get_state(TRACE_PREP_SYSTEMIO_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3258

····if·(trace_event_get_state(TRACE_PREP_SYSTEMIO_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3259

········if·(message_with_timestamp)·{

3259

········if·(message_with_timestamp)·{

3260

············struct·timeval·_now;

3260

············struct·timeval·_now;

3261

············gettimeofday(&_now,·NULL);

3261

············gettimeofday(&_now,·NULL);

3263

············qemu_log("%d@%zu.%06zu:prep_systemio_read·"·"read·addr=0x%x·val=0x%x"·"\n",

3263

············qemu_log("%d@%zu.%06zu:prep_systemio_read·"·"read·addr=0x%x·val=0x%x"·"\n",

3264

·····················qemu_get_thread_id(),

3264

·····················qemu_get_thread_id(),

3265

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3265

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3266

·····················,·addr,·val);

3266

·····················,·addr,·val);

3267

#line·3269·"trace/trace-hw_ppc.h"

3267

#line·3269·"trace/trace-hw_ppc.h"

3268

········}·else·{

3268

········}·else·{

3270

············qemu_log("prep_systemio_read·"·"read·addr=0x%x·val=0x%x"·"\n",·addr,·val);

3270

············qemu_log("prep_systemio_read·"·"read·addr=0x%x·val=0x%x"·"\n",·addr,·val);

3271

#line·3273·"trace/trace-hw_ppc.h"

3271

#line·3273·"trace/trace-hw_ppc.h"

3272

········}

3272

········}

3273

····}

3273

····}

3274

}

3274

}

3275

static·inline·void·trace_prep_systemio_read(uint32_t·addr,·uint32_t·val)

3275

static·inline·void·trace_prep_systemio_read(uint32_t·addr,·uint32_t·val)

3287

static·inline·void·_nocheck__trace_prep_systemio_write(uint32_t·addr,·uint32_t·val)

3287

static·inline·void·_nocheck__trace_prep_systemio_write(uint32_t·addr,·uint32_t·val)

3288

{

3288

{

3289

····if·(trace_event_get_state(TRACE_PREP_SYSTEMIO_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3289

····if·(trace_event_get_state(TRACE_PREP_SYSTEMIO_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3290

········if·(message_with_timestamp)·{

3290

········if·(message_with_timestamp)·{

3291

············struct·timeval·_now;

3291

············struct·timeval·_now;

3292

············gettimeofday(&_now,·NULL);

3292

············gettimeofday(&_now,·NULL);

3294

············qemu_log("%d@%zu.%06zu:prep_systemio_write·"·"write·addr=0x%x·val=0x%x"·"\n",

3294

············qemu_log("%d@%zu.%06zu:prep_systemio_write·"·"write·addr=0x%x·val=0x%x"·"\n",

3295

·····················qemu_get_thread_id(),

3295

·····················qemu_get_thread_id(),

3296

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3296

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3297

·····················,·addr,·val);

3297

·····················,·addr,·val);

3298

#line·3300·"trace/trace-hw_ppc.h"

3298

#line·3300·"trace/trace-hw_ppc.h"

3299

········}·else·{

3299

········}·else·{

3301

············qemu_log("prep_systemio_write·"·"write·addr=0x%x·val=0x%x"·"\n",·addr,·val);

3301

············qemu_log("prep_systemio_write·"·"write·addr=0x%x·val=0x%x"·"\n",·addr,·val);

3302

#line·3304·"trace/trace-hw_ppc.h"

3302

#line·3304·"trace/trace-hw_ppc.h"

3303

········}

3303

········}

3304

····}

3304

····}

3305

}

3305

}

3306

static·inline·void·trace_prep_systemio_write(uint32_t·addr,·uint32_t·val)

3306

static·inline·void·trace_prep_systemio_write(uint32_t·addr,·uint32_t·val)

3318

static·inline·void·_nocheck__trace_rs6000mc_id_read(uint32_t·addr,·uint32_t·val)

3318

static·inline·void·_nocheck__trace_rs6000mc_id_read(uint32_t·addr,·uint32_t·val)

3319

{

3319

{

3320

····if·(trace_event_get_state(TRACE_RS6000MC_ID_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3320

····if·(trace_event_get_state(TRACE_RS6000MC_ID_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3321

········if·(message_with_timestamp)·{

3321

········if·(message_with_timestamp)·{

3322

············struct·timeval·_now;

3322

············struct·timeval·_now;

3323

············gettimeofday(&_now,·NULL);

3323

············gettimeofday(&_now,·NULL);

3325

············qemu_log("%d@%zu.%06zu:rs6000mc_id_read·"·"read·addr=0x%x·val=0x%x"·"\n",

3325

············qemu_log("%d@%zu.%06zu:rs6000mc_id_read·"·"read·addr=0x%x·val=0x%x"·"\n",

3326

·····················qemu_get_thread_id(),

3326

·····················qemu_get_thread_id(),

3327

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3327

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3328

·····················,·addr,·val);

3328

·····················,·addr,·val);

3329

#line·3331·"trace/trace-hw_ppc.h"

3329

#line·3331·"trace/trace-hw_ppc.h"

3330

········}·else·{

3330

········}·else·{

3332

············qemu_log("rs6000mc_id_read·"·"read·addr=0x%x·val=0x%x"·"\n",·addr,·val);

3332

············qemu_log("rs6000mc_id_read·"·"read·addr=0x%x·val=0x%x"·"\n",·addr,·val);

3333

#line·3335·"trace/trace-hw_ppc.h"

3333

#line·3335·"trace/trace-hw_ppc.h"

3334

········}

3334

········}

3335

····}

3335

····}

3336

}

3336

}

3337

static·inline·void·trace_rs6000mc_id_read(uint32_t·addr,·uint32_t·val)

3337

static·inline·void·trace_rs6000mc_id_read(uint32_t·addr,·uint32_t·val)

3349

static·inline·void·_nocheck__trace_rs6000mc_presence_read(uint32_t·addr,·uint32_t·val)

3349

static·inline·void·_nocheck__trace_rs6000mc_presence_read(uint32_t·addr,·uint32_t·val)

3350

{

3350

{

3351

····if·(trace_event_get_state(TRACE_RS6000MC_PRESENCE_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3351

····if·(trace_event_get_state(TRACE_RS6000MC_PRESENCE_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3352

········if·(message_with_timestamp)·{

3352

········if·(message_with_timestamp)·{

3353

············struct·timeval·_now;

3353

············struct·timeval·_now;

3354

············gettimeofday(&_now,·NULL);

3354

············gettimeofday(&_now,·NULL);

3356

············qemu_log("%d@%zu.%06zu:rs6000mc_presence_read·"·"read·addr=0x%x·val=0x%x"·"\n",

3356

············qemu_log("%d@%zu.%06zu:rs6000mc_presence_read·"·"read·addr=0x%x·val=0x%x"·"\n",

3357

·····················qemu_get_thread_id(),

3357

·····················qemu_get_thread_id(),

3358

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3358

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3359

·····················,·addr,·val);

3359

·····················,·addr,·val);

3360

#line·3362·"trace/trace-hw_ppc.h"

3360

#line·3362·"trace/trace-hw_ppc.h"

3361

········}·else·{

3361

········}·else·{

3363

············qemu_log("rs6000mc_presence_read·"·"read·addr=0x%x·val=0x%x"·"\n",·addr,·val);

3363

············qemu_log("rs6000mc_presence_read·"·"read·addr=0x%x·val=0x%x"·"\n",·addr,·val);

3364

#line·3366·"trace/trace-hw_ppc.h"

3364

#line·3366·"trace/trace-hw_ppc.h"

3365

········}

3365

········}

3366

····}

3366

····}

3367

}

3367

}

3368

static·inline·void·trace_rs6000mc_presence_read(uint32_t·addr,·uint32_t·val)

3368

static·inline·void·trace_rs6000mc_presence_read(uint32_t·addr,·uint32_t·val)

3380

static·inline·void·_nocheck__trace_rs6000mc_size_read(uint32_t·addr,·uint32_t·val)

3380

static·inline·void·_nocheck__trace_rs6000mc_size_read(uint32_t·addr,·uint32_t·val)

3381

{

3381

{

3382

····if·(trace_event_get_state(TRACE_RS6000MC_SIZE_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3382

····if·(trace_event_get_state(TRACE_RS6000MC_SIZE_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3383

········if·(message_with_timestamp)·{

3383

········if·(message_with_timestamp)·{

3384

············struct·timeval·_now;

3384

············struct·timeval·_now;

3385

············gettimeofday(&_now,·NULL);

3385

············gettimeofday(&_now,·NULL);

3387

············qemu_log("%d@%zu.%06zu:rs6000mc_size_read·"·"read·addr=0x%x·val=0x%x"·"\n",

3387

············qemu_log("%d@%zu.%06zu:rs6000mc_size_read·"·"read·addr=0x%x·val=0x%x"·"\n",

3388

·····················qemu_get_thread_id(),

3388

·····················qemu_get_thread_id(),

3389

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3389

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3390

·····················,·addr,·val);

3390

·····················,·addr,·val);

3391

#line·3393·"trace/trace-hw_ppc.h"

3391

#line·3393·"trace/trace-hw_ppc.h"

3392

········}·else·{

3392

········}·else·{

3394

············qemu_log("rs6000mc_size_read·"·"read·addr=0x%x·val=0x%x"·"\n",·addr,·val);

3394

············qemu_log("rs6000mc_size_read·"·"read·addr=0x%x·val=0x%x"·"\n",·addr,·val);

3395

#line·3397·"trace/trace-hw_ppc.h"

3395

#line·3397·"trace/trace-hw_ppc.h"

3396

········}

3396

········}

3397

····}

3397

····}

3398

}

3398

}

3399

static·inline·void·trace_rs6000mc_size_read(uint32_t·addr,·uint32_t·val)

3399

static·inline·void·trace_rs6000mc_size_read(uint32_t·addr,·uint32_t·val)

3411

static·inline·void·_nocheck__trace_rs6000mc_size_write(uint32_t·addr,·uint32_t·val)

3411

static·inline·void·_nocheck__trace_rs6000mc_size_write(uint32_t·addr,·uint32_t·val)

3412

{

3412

{

3413

····if·(trace_event_get_state(TRACE_RS6000MC_SIZE_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3413

····if·(trace_event_get_state(TRACE_RS6000MC_SIZE_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3414

········if·(message_with_timestamp)·{

3414

········if·(message_with_timestamp)·{

3415

············struct·timeval·_now;

3415

············struct·timeval·_now;

3416

············gettimeofday(&_now,·NULL);

3416

············gettimeofday(&_now,·NULL);

3418

············qemu_log("%d@%zu.%06zu:rs6000mc_size_write·"·"write·addr=0x%x·val=0x%x"·"\n",

3418

············qemu_log("%d@%zu.%06zu:rs6000mc_size_write·"·"write·addr=0x%x·val=0x%x"·"\n",

3419

·····················qemu_get_thread_id(),

3419

·····················qemu_get_thread_id(),

3420

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3420

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3421

·····················,·addr,·val);

3421

·····················,·addr,·val);

3422

#line·3424·"trace/trace-hw_ppc.h"

3422

#line·3424·"trace/trace-hw_ppc.h"

3423

········}·else·{

3423

········}·else·{

3425

············qemu_log("rs6000mc_size_write·"·"write·addr=0x%x·val=0x%x"·"\n",·addr,·val);

3425

············qemu_log("rs6000mc_size_write·"·"write·addr=0x%x·val=0x%x"·"\n",·addr,·val);

3426

#line·3428·"trace/trace-hw_ppc.h"

3426

#line·3428·"trace/trace-hw_ppc.h"

3427

········}

3427

········}

3428

····}

3428

····}

3429

}

3429

}

3430

static·inline·void·trace_rs6000mc_size_write(uint32_t·addr,·uint32_t·val)

3430

static·inline·void·trace_rs6000mc_size_write(uint32_t·addr,·uint32_t·val)

3442

static·inline·void·_nocheck__trace_rs6000mc_parity_read(uint32_t·addr,·uint32_t·val)

3442

static·inline·void·_nocheck__trace_rs6000mc_parity_read(uint32_t·addr,·uint32_t·val)

3443

{

3443

{

3444

····if·(trace_event_get_state(TRACE_RS6000MC_PARITY_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3444

····if·(trace_event_get_state(TRACE_RS6000MC_PARITY_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3445

········if·(message_with_timestamp)·{

3445

········if·(message_with_timestamp)·{

3446

············struct·timeval·_now;

3446

············struct·timeval·_now;

3447

············gettimeofday(&_now,·NULL);

3447

············gettimeofday(&_now,·NULL);

3449

············qemu_log("%d@%zu.%06zu:rs6000mc_parity_read·"·"read·addr=0x%x·val=0x%x"·"\n",

3449

············qemu_log("%d@%zu.%06zu:rs6000mc_parity_read·"·"read·addr=0x%x·val=0x%x"·"\n",

3450

·····················qemu_get_thread_id(),

3450

·····················qemu_get_thread_id(),

3451

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3451

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3452

·····················,·addr,·val);

3452

·····················,·addr,·val);

3453

#line·3455·"trace/trace-hw_ppc.h"

3453

#line·3455·"trace/trace-hw_ppc.h"

3454

········}·else·{

3454

········}·else·{

3456

············qemu_log("rs6000mc_parity_read·"·"read·addr=0x%x·val=0x%x"·"\n",·addr,·val);

3456

············qemu_log("rs6000mc_parity_read·"·"read·addr=0x%x·val=0x%x"·"\n",·addr,·val);

3457

#line·3459·"trace/trace-hw_ppc.h"

3457

#line·3459·"trace/trace-hw_ppc.h"

3458

········}

3458

········}

3459

····}

3459

····}

3460

}

3460

}

3461

static·inline·void·trace_rs6000mc_parity_read(uint32_t·addr,·uint32_t·val)

3461

static·inline·void·trace_rs6000mc_parity_read(uint32_t·addr,·uint32_t·val)

3473

static·inline·void·_nocheck__trace_ppc4xx_pci_map_irq(int32_t·devfn,·int·irq_num,·int·slot)

3473

static·inline·void·_nocheck__trace_ppc4xx_pci_map_irq(int32_t·devfn,·int·irq_num,·int·slot)

3474

{

3474

{

3475

····if·(trace_event_get_state(TRACE_PPC4XX_PCI_MAP_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3475

····if·(trace_event_get_state(TRACE_PPC4XX_PCI_MAP_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3476

········if·(message_with_timestamp)·{

3476

········if·(message_with_timestamp)·{

3477

············struct·timeval·_now;

3477

············struct·timeval·_now;

3478

············gettimeofday(&_now,·NULL);

3478

············gettimeofday(&_now,·NULL);

3480

············qemu_log("%d@%zu.%06zu:ppc4xx_pci_map_irq·"·"devfn·0x%x·irq·%d·->·%d"·"\n",

3480

············qemu_log("%d@%zu.%06zu:ppc4xx_pci_map_irq·"·"devfn·0x%x·irq·%d·->·%d"·"\n",

3481

·····················qemu_get_thread_id(),

3481

·····················qemu_get_thread_id(),

3482

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3482

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3483

·····················,·devfn,·irq_num,·slot);

3483

·····················,·devfn,·irq_num,·slot);

3484

#line·3486·"trace/trace-hw_ppc.h"

3484

#line·3486·"trace/trace-hw_ppc.h"

3485

········}·else·{

3485

········}·else·{

3487

············qemu_log("ppc4xx_pci_map_irq·"·"devfn·0x%x·irq·%d·->·%d"·"\n",·devfn,·irq_num,·slot);

3487

············qemu_log("ppc4xx_pci_map_irq·"·"devfn·0x%x·irq·%d·->·%d"·"\n",·devfn,·irq_num,·slot);

3488

#line·3490·"trace/trace-hw_ppc.h"

3488

#line·3490·"trace/trace-hw_ppc.h"

3489

········}

3489

········}

3490

····}

3490

····}

3491

}

3491

}

3492

static·inline·void·trace_ppc4xx_pci_map_irq(int32_t·devfn,·int·irq_num,·int·slot)

3492

static·inline·void·trace_ppc4xx_pci_map_irq(int32_t·devfn,·int·irq_num,·int·slot)

3504

static·inline·void·_nocheck__trace_ppc4xx_pci_set_irq(int·irq_num)

3504

static·inline·void·_nocheck__trace_ppc4xx_pci_set_irq(int·irq_num)

3505

{

3505

{

3506

····if·(trace_event_get_state(TRACE_PPC4XX_PCI_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3506

····if·(trace_event_get_state(TRACE_PPC4XX_PCI_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3507

········if·(message_with_timestamp)·{

3507

········if·(message_with_timestamp)·{

3508

············struct·timeval·_now;

3508

············struct·timeval·_now;

3509

············gettimeofday(&_now,·NULL);

3509

············gettimeofday(&_now,·NULL);

3511

············qemu_log("%d@%zu.%06zu:ppc4xx_pci_set_irq·"·"PCI·irq·%d"·"\n",

3511

············qemu_log("%d@%zu.%06zu:ppc4xx_pci_set_irq·"·"PCI·irq·%d"·"\n",

3512

·····················qemu_get_thread_id(),

3512

·····················qemu_get_thread_id(),

3513

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3513

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3514

·····················,·irq_num);

3514

·····················,·irq_num);

3515

#line·3517·"trace/trace-hw_ppc.h"

3515

#line·3517·"trace/trace-hw_ppc.h"

3516

········}·else·{

3516

········}·else·{

3518

············qemu_log("ppc4xx_pci_set_irq·"·"PCI·irq·%d"·"\n",·irq_num);

3518

············qemu_log("ppc4xx_pci_set_irq·"·"PCI·irq·%d"·"\n",·irq_num);

3519

#line·3521·"trace/trace-hw_ppc.h"

3519

#line·3521·"trace/trace-hw_ppc.h"

3520

········}

3520

········}

3521

····}

3521

····}

3522

}

3522

}

3523

static·inline·void·trace_ppc4xx_pci_set_irq(int·irq_num)

3523

static·inline·void·trace_ppc4xx_pci_set_irq(int·irq_num)

3535

static·inline·void·_nocheck__trace_ppc440_pcix_map_irq(int32_t·devfn,·int·irq_num,·int·slot)

3535

static·inline·void·_nocheck__trace_ppc440_pcix_map_irq(int32_t·devfn,·int·irq_num,·int·slot)

3536

{

3536

{

3537

····if·(trace_event_get_state(TRACE_PPC440_PCIX_MAP_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3537

····if·(trace_event_get_state(TRACE_PPC440_PCIX_MAP_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3538

········if·(message_with_timestamp)·{

3538

········if·(message_with_timestamp)·{

3539

············struct·timeval·_now;

3539

············struct·timeval·_now;

3540

············gettimeofday(&_now,·NULL);

3540

············gettimeofday(&_now,·NULL);

3542

············qemu_log("%d@%zu.%06zu:ppc440_pcix_map_irq·"·"devfn·0x%x·irq·%d·->·%d"·"\n",

3542

············qemu_log("%d@%zu.%06zu:ppc440_pcix_map_irq·"·"devfn·0x%x·irq·%d·->·%d"·"\n",

3543

·····················qemu_get_thread_id(),

3543

·····················qemu_get_thread_id(),

3544

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3544

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3545

·····················,·devfn,·irq_num,·slot);

3545

·····················,·devfn,·irq_num,·slot);

3546

#line·3548·"trace/trace-hw_ppc.h"

3546

#line·3548·"trace/trace-hw_ppc.h"

3547

········}·else·{

3547

········}·else·{

3549

············qemu_log("ppc440_pcix_map_irq·"·"devfn·0x%x·irq·%d·->·%d"·"\n",·devfn,·irq_num,·slot);

3549

············qemu_log("ppc440_pcix_map_irq·"·"devfn·0x%x·irq·%d·->·%d"·"\n",·devfn,·irq_num,·slot);

3550

#line·3552·"trace/trace-hw_ppc.h"

3550

#line·3552·"trace/trace-hw_ppc.h"

3551

········}

3551

········}

3552

····}

3552

····}

3553

}

3553

}

3554

static·inline·void·trace_ppc440_pcix_map_irq(int32_t·devfn,·int·irq_num,·int·slot)

3554

static·inline·void·trace_ppc440_pcix_map_irq(int32_t·devfn,·int·irq_num,·int·slot)

3566

static·inline·void·_nocheck__trace_ppc440_pcix_set_irq(int·irq_num)

3566

static·inline·void·_nocheck__trace_ppc440_pcix_set_irq(int·irq_num)

3567

{

3567

{

3568

····if·(trace_event_get_state(TRACE_PPC440_PCIX_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3568

····if·(trace_event_get_state(TRACE_PPC440_PCIX_SET_IRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3569

········if·(message_with_timestamp)·{

3569

········if·(message_with_timestamp)·{

3570

············struct·timeval·_now;

3570

············struct·timeval·_now;

3571

············gettimeofday(&_now,·NULL);

3571

············gettimeofday(&_now,·NULL);

3573

············qemu_log("%d@%zu.%06zu:ppc440_pcix_set_irq·"·"PCI·irq·%d"·"\n",

3573

············qemu_log("%d@%zu.%06zu:ppc440_pcix_set_irq·"·"PCI·irq·%d"·"\n",

3574

·····················qemu_get_thread_id(),

3574

·····················qemu_get_thread_id(),

3575

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3575

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3576

·····················,·irq_num);

3576

·····················,·irq_num);

3577

#line·3579·"trace/trace-hw_ppc.h"

3577

#line·3579·"trace/trace-hw_ppc.h"

3578

········}·else·{

3578

········}·else·{

3580

············qemu_log("ppc440_pcix_set_irq·"·"PCI·irq·%d"·"\n",·irq_num);

3580

············qemu_log("ppc440_pcix_set_irq·"·"PCI·irq·%d"·"\n",·irq_num);

3581

#line·3583·"trace/trace-hw_ppc.h"

3581

#line·3583·"trace/trace-hw_ppc.h"

3582

········}

3582

········}

3583

····}

3583

····}

3584

}

3584

}

3585

static·inline·void·trace_ppc440_pcix_set_irq(int·irq_num)

3585

static·inline·void·trace_ppc440_pcix_set_irq(int·irq_num)

3597

static·inline·void·_nocheck__trace_ppc440_pcix_update_pim(int·idx,·uint64_t·size,·uint64_t·la)

3597

static·inline·void·_nocheck__trace_ppc440_pcix_update_pim(int·idx,·uint64_t·size,·uint64_t·la)

3598

{

3598

{

3599

····if·(trace_event_get_state(TRACE_PPC440_PCIX_UPDATE_PIM)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3599

····if·(trace_event_get_state(TRACE_PPC440_PCIX_UPDATE_PIM)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3600

········if·(message_with_timestamp)·{

3600

········if·(message_with_timestamp)·{

3601

············struct·timeval·_now;

3601

············struct·timeval·_now;

3602

············gettimeofday(&_now,·NULL);

3602

············gettimeofday(&_now,·NULL);

3604

············qemu_log("%d@%zu.%06zu:ppc440_pcix_update_pim·"·"Added·window·%d·of·size=0x%"·PRIx64·"·to·CPU=0x%"·PRIx64·"\n",

3604

············qemu_log("%d@%zu.%06zu:ppc440_pcix_update_pim·"·"Added·window·%d·of·size=0x%"·PRIx64·"·to·CPU=0x%"·PRIx64·"\n",

3605

·····················qemu_get_thread_id(),

3605

·····················qemu_get_thread_id(),

3606

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3606

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3607

·····················,·idx,·size,·la);

3607

·····················,·idx,·size,·la);

3608

#line·3610·"trace/trace-hw_ppc.h"

3608

#line·3610·"trace/trace-hw_ppc.h"

3609

········}·else·{

3609

········}·else·{

3611

············qemu_log("ppc440_pcix_update_pim·"·"Added·window·%d·of·size=0x%"·PRIx64·"·to·CPU=0x%"·PRIx64·"\n",·idx,·size,·la);

3611

············qemu_log("ppc440_pcix_update_pim·"·"Added·window·%d·of·size=0x%"·PRIx64·"·to·CPU=0x%"·PRIx64·"\n",·idx,·size,·la);

3612

#line·3614·"trace/trace-hw_ppc.h"

3612

#line·3614·"trace/trace-hw_ppc.h"

3613

········}

3613

········}

3614

····}

3614

····}

3615

}

3615

}

3616

static·inline·void·trace_ppc440_pcix_update_pim(int·idx,·uint64_t·size,·uint64_t·la)

3616

static·inline·void·trace_ppc440_pcix_update_pim(int·idx,·uint64_t·size,·uint64_t·la)

3628

static·inline·void·_nocheck__trace_ppc440_pcix_update_pom(int·idx,·uint32_t·size,·uint64_t·la,·uint64_t·pcia)

3628

static·inline·void·_nocheck__trace_ppc440_pcix_update_pom(int·idx,·uint32_t·size,·uint64_t·la,·uint64_t·pcia)

3629

{

3629

{

3630

····if·(trace_event_get_state(TRACE_PPC440_PCIX_UPDATE_POM)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3630

····if·(trace_event_get_state(TRACE_PPC440_PCIX_UPDATE_POM)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3631

········if·(message_with_timestamp)·{

3631

········if·(message_with_timestamp)·{

3632

············struct·timeval·_now;

3632

············struct·timeval·_now;

3633

············gettimeofday(&_now,·NULL);

3633

············gettimeofday(&_now,·NULL);

3635

············qemu_log("%d@%zu.%06zu:ppc440_pcix_update_pom·"·"Added·window·%d·of·size=0x%x·from·CPU=0x%"·PRIx64·"·to·PCI=0x%"·PRIx64·"\n",

3635

············qemu_log("%d@%zu.%06zu:ppc440_pcix_update_pom·"·"Added·window·%d·of·size=0x%x·from·CPU=0x%"·PRIx64·"·to·PCI=0x%"·PRIx64·"\n",

3636

·····················qemu_get_thread_id(),

3636

·····················qemu_get_thread_id(),

3637

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3637

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3638

·····················,·idx,·size,·la,·pcia);

3638

·····················,·idx,·size,·la,·pcia);

3639

#line·3641·"trace/trace-hw_ppc.h"

3639

#line·3641·"trace/trace-hw_ppc.h"

3640

········}·else·{

3640

········}·else·{

3642

············qemu_log("ppc440_pcix_update_pom·"·"Added·window·%d·of·size=0x%x·from·CPU=0x%"·PRIx64·"·to·PCI=0x%"·PRIx64·"\n",·idx,·size,·la,·pcia);

3642

············qemu_log("ppc440_pcix_update_pom·"·"Added·window·%d·of·size=0x%x·from·CPU=0x%"·PRIx64·"·to·PCI=0x%"·PRIx64·"\n",·idx,·size,·la,·pcia);

3643

#line·3645·"trace/trace-hw_ppc.h"

3643

#line·3645·"trace/trace-hw_ppc.h"

3644

········}

3644

········}

3645

····}

3645

····}

3646

}

3646

}

3647

static·inline·void·trace_ppc440_pcix_update_pom(int·idx,·uint32_t·size,·uint64_t·la,·uint64_t·pcia)

3647

static·inline·void·trace_ppc440_pcix_update_pom(int·idx,·uint32_t·size,·uint64_t·la,·uint64_t·pcia)

3659

static·inline·void·_nocheck__trace_ppc440_pcix_reg_read(uint64_t·addr,·uint32_t·val)

3659

static·inline·void·_nocheck__trace_ppc440_pcix_reg_read(uint64_t·addr,·uint32_t·val)

3660

{

3660

{

3661

····if·(trace_event_get_state(TRACE_PPC440_PCIX_REG_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3661

····if·(trace_event_get_state(TRACE_PPC440_PCIX_REG_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3662

········if·(message_with_timestamp)·{

3662

········if·(message_with_timestamp)·{

3663

············struct·timeval·_now;

3663

············struct·timeval·_now;

3664

············gettimeofday(&_now,·NULL);

3664

············gettimeofday(&_now,·NULL);

3666

············qemu_log("%d@%zu.%06zu:ppc440_pcix_reg_read·"·"addr·0x%"·PRIx64·"·=·0x%"·PRIx32·"\n",

3666

············qemu_log("%d@%zu.%06zu:ppc440_pcix_reg_read·"·"addr·0x%"·PRIx64·"·=·0x%"·PRIx32·"\n",

3667

·····················qemu_get_thread_id(),

3667

·····················qemu_get_thread_id(),

3668

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3668

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3669

·····················,·addr,·val);

3669

·····················,·addr,·val);

3670

#line·3672·"trace/trace-hw_ppc.h"

3670

#line·3672·"trace/trace-hw_ppc.h"

3671

········}·else·{

3671

········}·else·{

3673

············qemu_log("ppc440_pcix_reg_read·"·"addr·0x%"·PRIx64·"·=·0x%"·PRIx32·"\n",·addr,·val);

3673

············qemu_log("ppc440_pcix_reg_read·"·"addr·0x%"·PRIx64·"·=·0x%"·PRIx32·"\n",·addr,·val);

3674

#line·3676·"trace/trace-hw_ppc.h"

3674

#line·3676·"trace/trace-hw_ppc.h"

3675

········}

3675

········}

3676

····}

3676

····}

3677

}

3677

}

3678

static·inline·void·trace_ppc440_pcix_reg_read(uint64_t·addr,·uint32_t·val)

3678

static·inline·void·trace_ppc440_pcix_reg_read(uint64_t·addr,·uint32_t·val)

3690

static·inline·void·_nocheck__trace_ppc440_pcix_reg_write(uint64_t·addr,·uint32_t·val,·uint32_t·size)

3690

static·inline·void·_nocheck__trace_ppc440_pcix_reg_write(uint64_t·addr,·uint32_t·val,·uint32_t·size)

3691

{

3691

{

3692

····if·(trace_event_get_state(TRACE_PPC440_PCIX_REG_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3692

····if·(trace_event_get_state(TRACE_PPC440_PCIX_REG_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3693

········if·(message_with_timestamp)·{

3693

········if·(message_with_timestamp)·{

3694

············struct·timeval·_now;

3694

············struct·timeval·_now;

3695

············gettimeofday(&_now,·NULL);

3695

············gettimeofday(&_now,·NULL);

3697

············qemu_log("%d@%zu.%06zu:ppc440_pcix_reg_write·"·"addr·0x%"·PRIx64·"·=·0x%"·PRIx32·"·size·0x%"·PRIx32·"\n",

3697

············qemu_log("%d@%zu.%06zu:ppc440_pcix_reg_write·"·"addr·0x%"·PRIx64·"·=·0x%"·PRIx32·"·size·0x%"·PRIx32·"\n",

3698

·····················qemu_get_thread_id(),

3698

·····················qemu_get_thread_id(),

3699

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3699

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3700

·····················,·addr,·val,·size);

3700

·····················,·addr,·val,·size);

3701

#line·3703·"trace/trace-hw_ppc.h"

3701

#line·3703·"trace/trace-hw_ppc.h"

3702

········}·else·{

3702

········}·else·{

3704

············qemu_log("ppc440_pcix_reg_write·"·"addr·0x%"·PRIx64·"·=·0x%"·PRIx32·"·size·0x%"·PRIx32·"\n",·addr,·val,·size);

3704

············qemu_log("ppc440_pcix_reg_write·"·"addr·0x%"·PRIx64·"·=·0x%"·PRIx32·"·size·0x%"·PRIx32·"\n",·addr,·val,·size);

3705

#line·3707·"trace/trace-hw_ppc.h"

3705

#line·3707·"trace/trace-hw_ppc.h"

3706

········}

3706

········}

3707

····}

3707

····}

3708

}

3708

}

3709

static·inline·void·trace_ppc440_pcix_reg_write(uint64_t·addr,·uint32_t·val,·uint32_t·size)

3709

static·inline·void·trace_ppc440_pcix_reg_write(uint64_t·addr,·uint32_t·val,·uint32_t·size)