/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

339

static·inline·void·_nocheck__trace_x86_iommu_iec_notify(bool·global,·uint32_t·index,·uint32_t·mask)

339

static·inline·void·_nocheck__trace_x86_iommu_iec_notify(bool·global,·uint32_t·index,·uint32_t·mask)

340

{

340

{

341

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

341

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

342

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

342

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

343

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

343

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

344

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

344

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

346

············qemu_log("%d@%zu.%06zu:x86_iommu_iec_notify·"·"Notify·IEC·invalidation:·global=%d·index=%"·PRIu32·"·mask=%"·PRIu32·"\n",

346

············qemu_log("%d@%zu.%06zu:x86_iommu_iec_notify·"·"Notify·IEC·invalidation:·global=%d·index=%"·PRIu32·"·mask=%"·PRIu32·"\n",

347

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

347

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

348

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

348

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

349

·····················,·global,·index,·mask);

349

·····················,·global,·index,·mask);

350

#line·352·"trace/trace-hw_i386.h"

350

#line·352·"trace/trace-hw_i386.h"

351

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

351

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

353

············qemu_log("x86_iommu_iec_notify·"·"Notify·IEC·invalidation:·global=%d·index=%"·PRIu32·"·mask=%"·PRIu32·"\n",·global,·index,·mask);

353

············qemu_log("x86_iommu_iec_notify·"·"Notify·IEC·invalidation:·global=%d·index=%"·PRIu32·"·mask=%"·PRIu32·"\n",·global,·index,·mask);

354

#line·356·"trace/trace-hw_i386.h"

354

#line·356·"trace/trace-hw_i386.h"

355

········}

355

········}

356

····}

356

····}

357

}

357

}

358

static·inline·void·trace_x86_iommu_iec_notify(bool·global,·uint32_t·index,·uint32_t·mask)

358

static·inline·void·trace_x86_iommu_iec_notify(bool·global,·uint32_t·index,·uint32_t·mask)

370

static·inline·void·_nocheck__trace_vtd_inv_desc(const·char·*·type,·uint64_t·hi,·uint64_t·lo)

370

static·inline·void·_nocheck__trace_vtd_inv_desc(const·char·*·type,·uint64_t·hi,·uint64_t·lo)

371

{

371

{

372

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

372

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

373

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

373

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

374

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

374

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

375

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

375

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

377

············qemu_log("%d@%zu.%06zu:vtd_inv_desc·"·"invalidate·desc·type·%s·high·0x%"PRIx64"·low·0x%"PRIx64·"\n",

377

············qemu_log("%d@%zu.%06zu:vtd_inv_desc·"·"invalidate·desc·type·%s·high·0x%"PRIx64"·low·0x%"PRIx64·"\n",

378

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

378

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

379

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

379

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

380

·····················,·type,·hi,·lo);

380

·····················,·type,·hi,·lo);

381

#line·383·"trace/trace-hw_i386.h"

381

#line·383·"trace/trace-hw_i386.h"

382

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

382

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

384

············qemu_log("vtd_inv_desc·"·"invalidate·desc·type·%s·high·0x%"PRIx64"·low·0x%"PRIx64·"\n",·type,·hi,·lo);

384

············qemu_log("vtd_inv_desc·"·"invalidate·desc·type·%s·high·0x%"PRIx64"·low·0x%"PRIx64·"\n",·type,·hi,·lo);

385

#line·387·"trace/trace-hw_i386.h"

385

#line·387·"trace/trace-hw_i386.h"

386

········}

386

········}

387

····}

387

····}

388

}

388

}

389

static·inline·void·trace_vtd_inv_desc(const·char·*·type,·uint64_t·hi,·uint64_t·lo)

389

static·inline·void·trace_vtd_inv_desc(const·char·*·type,·uint64_t·hi,·uint64_t·lo)

401

static·inline·void·_nocheck__trace_vtd_inv_desc_cc_domain(uint16_t·domain)

401

static·inline·void·_nocheck__trace_vtd_inv_desc_cc_domain(uint16_t·domain)

402

{

402

{

403

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

403

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

404

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

404

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

405

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

405

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

406

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

406

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

408

············qemu_log("%d@%zu.%06zu:vtd_inv_desc_cc_domain·"·"context·invalidate·domain·0x%"PRIx16·"\n",

408

············qemu_log("%d@%zu.%06zu:vtd_inv_desc_cc_domain·"·"context·invalidate·domain·0x%"PRIx16·"\n",

409

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

409

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

410

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

410

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

411

·····················,·domain);

411

·····················,·domain);

412

#line·414·"trace/trace-hw_i386.h"

412

#line·414·"trace/trace-hw_i386.h"

413

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

413

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

415

············qemu_log("vtd_inv_desc_cc_domain·"·"context·invalidate·domain·0x%"PRIx16·"\n",·domain);

415

············qemu_log("vtd_inv_desc_cc_domain·"·"context·invalidate·domain·0x%"PRIx16·"\n",·domain);

416

#line·418·"trace/trace-hw_i386.h"

416

#line·418·"trace/trace-hw_i386.h"

417

········}

417

········}

418

····}

418

····}

419

}

419

}

420

static·inline·void·trace_vtd_inv_desc_cc_domain(uint16_t·domain)

420

static·inline·void·trace_vtd_inv_desc_cc_domain(uint16_t·domain)

432

static·inline·void·_nocheck__trace_vtd_inv_desc_cc_global(void)

432

static·inline·void·_nocheck__trace_vtd_inv_desc_cc_global(void)

433

{

433

{

434

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

434

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

435

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

435

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

436

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

436

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

437

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

437

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

439

············qemu_log("%d@%zu.%06zu:vtd_inv_desc_cc_global·"·"context·invalidate·globally"·"\n",

439

············qemu_log("%d@%zu.%06zu:vtd_inv_desc_cc_global·"·"context·invalidate·globally"·"\n",

440

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

440

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

441

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

441

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

442

·····················);

442

·····················);

443

#line·445·"trace/trace-hw_i386.h"

443

#line·445·"trace/trace-hw_i386.h"

444

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

444

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

446

············qemu_log("vtd_inv_desc_cc_global·"·"context·invalidate·globally"·"\n");

446

············qemu_log("vtd_inv_desc_cc_global·"·"context·invalidate·globally"·"\n");

447

#line·449·"trace/trace-hw_i386.h"

447

#line·449·"trace/trace-hw_i386.h"

448

········}

448

········}

449

····}

449

····}

450

}

450

}

451

static·inline·void·trace_vtd_inv_desc_cc_global(void)

451

static·inline·void·trace_vtd_inv_desc_cc_global(void)

463

static·inline·void·_nocheck__trace_vtd_inv_desc_cc_device(uint8_t·bus,·uint8_t·dev,·uint8_t·fn)

463

static·inline·void·_nocheck__trace_vtd_inv_desc_cc_device(uint8_t·bus,·uint8_t·dev,·uint8_t·fn)

464

{

464

{

465

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

465

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

466

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

466

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

467

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

467

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

468

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

468

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

470

············qemu_log("%d@%zu.%06zu:vtd_inv_desc_cc_device·"·"context·invalidate·device·%02"PRIx8":%02"PRIx8".%02"PRIx8·"\n",

470

············qemu_log("%d@%zu.%06zu:vtd_inv_desc_cc_device·"·"context·invalidate·device·%02"PRIx8":%02"PRIx8".%02"PRIx8·"\n",

471

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

471

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

472

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

472

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

473

·····················,·bus,·dev,·fn);

473

·····················,·bus,·dev,·fn);

474

#line·476·"trace/trace-hw_i386.h"

474

#line·476·"trace/trace-hw_i386.h"

475

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

475

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

477

············qemu_log("vtd_inv_desc_cc_device·"·"context·invalidate·device·%02"PRIx8":%02"PRIx8".%02"PRIx8·"\n",·bus,·dev,·fn);

477

············qemu_log("vtd_inv_desc_cc_device·"·"context·invalidate·device·%02"PRIx8":%02"PRIx8".%02"PRIx8·"\n",·bus,·dev,·fn);

478

#line·480·"trace/trace-hw_i386.h"

478

#line·480·"trace/trace-hw_i386.h"

479

········}

479

········}

480

····}

480

····}

481

}

481

}

482

static·inline·void·trace_vtd_inv_desc_cc_device(uint8_t·bus,·uint8_t·dev,·uint8_t·fn)

482

static·inline·void·trace_vtd_inv_desc_cc_device(uint8_t·bus,·uint8_t·dev,·uint8_t·fn)

494

static·inline·void·_nocheck__trace_vtd_inv_desc_cc_devices(uint16_t·sid,·uint16_t·fmask)

494

static·inline·void·_nocheck__trace_vtd_inv_desc_cc_devices(uint16_t·sid,·uint16_t·fmask)

495

{

495

{

496

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

496

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

497

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

497

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

498

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

498

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

499

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

499

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

501

············qemu_log("%d@%zu.%06zu:vtd_inv_desc_cc_devices·"·"context·invalidate·devices·sid·0x%"PRIx16"·fmask·0x%"PRIx16·"\n",

501

············qemu_log("%d@%zu.%06zu:vtd_inv_desc_cc_devices·"·"context·invalidate·devices·sid·0x%"PRIx16"·fmask·0x%"PRIx16·"\n",

502

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

502

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

503

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

503

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

504

·····················,·sid,·fmask);

504

·····················,·sid,·fmask);

505

#line·507·"trace/trace-hw_i386.h"

505

#line·507·"trace/trace-hw_i386.h"

506

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

506

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

508

············qemu_log("vtd_inv_desc_cc_devices·"·"context·invalidate·devices·sid·0x%"PRIx16"·fmask·0x%"PRIx16·"\n",·sid,·fmask);

508

············qemu_log("vtd_inv_desc_cc_devices·"·"context·invalidate·devices·sid·0x%"PRIx16"·fmask·0x%"PRIx16·"\n",·sid,·fmask);

509

#line·511·"trace/trace-hw_i386.h"

509

#line·511·"trace/trace-hw_i386.h"

510

········}

510

········}

511

····}

511

····}

512

}

512

}

513

static·inline·void·trace_vtd_inv_desc_cc_devices(uint16_t·sid,·uint16_t·fmask)

513

static·inline·void·trace_vtd_inv_desc_cc_devices(uint16_t·sid,·uint16_t·fmask)

525

static·inline·void·_nocheck__trace_vtd_inv_desc_iotlb_global(void)

525

static·inline·void·_nocheck__trace_vtd_inv_desc_iotlb_global(void)

526

{

526

{

527

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

527

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

528

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

528

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

529

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

529

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

530

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

530

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

532

············qemu_log("%d@%zu.%06zu:vtd_inv_desc_iotlb_global·"·"iotlb·invalidate·global"·"\n",

532

············qemu_log("%d@%zu.%06zu:vtd_inv_desc_iotlb_global·"·"iotlb·invalidate·global"·"\n",

533

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

533

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

534

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

534

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

535

·····················);

535

·····················);

536

#line·538·"trace/trace-hw_i386.h"

536

#line·538·"trace/trace-hw_i386.h"

537

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

537

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

539

············qemu_log("vtd_inv_desc_iotlb_global·"·"iotlb·invalidate·global"·"\n");

539

············qemu_log("vtd_inv_desc_iotlb_global·"·"iotlb·invalidate·global"·"\n");

540

#line·542·"trace/trace-hw_i386.h"

540

#line·542·"trace/trace-hw_i386.h"

541

········}

541

········}

542

····}

542

····}

543

}

543

}

544

static·inline·void·trace_vtd_inv_desc_iotlb_global(void)

544

static·inline·void·trace_vtd_inv_desc_iotlb_global(void)

556

static·inline·void·_nocheck__trace_vtd_inv_desc_iotlb_domain(uint16_t·domain)

556

static·inline·void·_nocheck__trace_vtd_inv_desc_iotlb_domain(uint16_t·domain)

557

{

557

{

558

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

558

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

559

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

559

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

560

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

560

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

561

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

561

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

563

············qemu_log("%d@%zu.%06zu:vtd_inv_desc_iotlb_domain·"·"iotlb·invalidate·whole·domain·0x%"PRIx16·"\n",

563

············qemu_log("%d@%zu.%06zu:vtd_inv_desc_iotlb_domain·"·"iotlb·invalidate·whole·domain·0x%"PRIx16·"\n",

564

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

564

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

565

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

565

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

566

·····················,·domain);

566

·····················,·domain);

567

#line·569·"trace/trace-hw_i386.h"

567

#line·569·"trace/trace-hw_i386.h"

568

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

568

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

570

············qemu_log("vtd_inv_desc_iotlb_domain·"·"iotlb·invalidate·whole·domain·0x%"PRIx16·"\n",·domain);

570

············qemu_log("vtd_inv_desc_iotlb_domain·"·"iotlb·invalidate·whole·domain·0x%"PRIx16·"\n",·domain);

571

#line·573·"trace/trace-hw_i386.h"

571

#line·573·"trace/trace-hw_i386.h"

572

········}

572

········}

573

····}

573

····}

574

}

574

}

575

static·inline·void·trace_vtd_inv_desc_iotlb_domain(uint16_t·domain)

575

static·inline·void·trace_vtd_inv_desc_iotlb_domain(uint16_t·domain)

587

static·inline·void·_nocheck__trace_vtd_inv_desc_iotlb_pages(uint16_t·domain,·uint64_t·addr,·uint8_t·mask)

587

static·inline·void·_nocheck__trace_vtd_inv_desc_iotlb_pages(uint16_t·domain,·uint64_t·addr,·uint8_t·mask)

588

{

588

{

589

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

589

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

590

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

590

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

591

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

591

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

592

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

592

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

594

············qemu_log("%d@%zu.%06zu:vtd_inv_desc_iotlb_pages·"·"iotlb·invalidate·domain·0x%"PRIx16"·addr·0x%"PRIx64"·mask·0x%"PRIx8·"\n",

594

············qemu_log("%d@%zu.%06zu:vtd_inv_desc_iotlb_pages·"·"iotlb·invalidate·domain·0x%"PRIx16"·addr·0x%"PRIx64"·mask·0x%"PRIx8·"\n",

595

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

595

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

596

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

596

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

597

·····················,·domain,·addr,·mask);

597

·····················,·domain,·addr,·mask);

598

#line·600·"trace/trace-hw_i386.h"

598

#line·600·"trace/trace-hw_i386.h"

599

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

599

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

601

············qemu_log("vtd_inv_desc_iotlb_pages·"·"iotlb·invalidate·domain·0x%"PRIx16"·addr·0x%"PRIx64"·mask·0x%"PRIx8·"\n",·domain,·addr,·mask);

601

············qemu_log("vtd_inv_desc_iotlb_pages·"·"iotlb·invalidate·domain·0x%"PRIx16"·addr·0x%"PRIx64"·mask·0x%"PRIx8·"\n",·domain,·addr,·mask);

602

#line·604·"trace/trace-hw_i386.h"

602

#line·604·"trace/trace-hw_i386.h"

603

········}

603

········}

604

····}

604

····}

605

}

605

}

606

static·inline·void·trace_vtd_inv_desc_iotlb_pages(uint16_t·domain,·uint64_t·addr,·uint8_t·mask)

606

static·inline·void·trace_vtd_inv_desc_iotlb_pages(uint16_t·domain,·uint64_t·addr,·uint8_t·mask)

618

static·inline·void·_nocheck__trace_vtd_inv_desc_wait_sw(uint64_t·addr,·uint32_t·data)

618

static·inline·void·_nocheck__trace_vtd_inv_desc_wait_sw(uint64_t·addr,·uint32_t·data)

619

{

619

{

620

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

620

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

621

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

621

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

622

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

622

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

623

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

623

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

625

············qemu_log("%d@%zu.%06zu:vtd_inv_desc_wait_sw·"·"wait·invalidate·status·write·addr·0x%"PRIx64"·data·0x%"PRIx32·"\n",

625

············qemu_log("%d@%zu.%06zu:vtd_inv_desc_wait_sw·"·"wait·invalidate·status·write·addr·0x%"PRIx64"·data·0x%"PRIx32·"\n",

626

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

626

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

627

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

627

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

628

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

628

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

629

#line·631·"trace/trace-hw_i386.h"

629

#line·631·"trace/trace-hw_i386.h"

630

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

630

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

632

············qemu_log("vtd_inv_desc_wait_sw·"·"wait·invalidate·status·write·addr·0x%"PRIx64"·data·0x%"PRIx32·"\n",·addr,·data);

632

············qemu_log("vtd_inv_desc_wait_sw·"·"wait·invalidate·status·write·addr·0x%"PRIx64"·data·0x%"PRIx32·"\n",·addr,·data);

633

#line·635·"trace/trace-hw_i386.h"

633

#line·635·"trace/trace-hw_i386.h"

634

········}

634

········}

635

····}

635

····}

636

}

636

}

637

static·inline·void·trace_vtd_inv_desc_wait_sw(uint64_t·addr,·uint32_t·data)

637

static·inline·void·trace_vtd_inv_desc_wait_sw(uint64_t·addr,·uint32_t·data)

649

static·inline·void·_nocheck__trace_vtd_inv_desc_wait_irq(const·char·*·msg)

649

static·inline·void·_nocheck__trace_vtd_inv_desc_wait_irq(const·char·*·msg)

650

{

650

{

651

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

651

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

652

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

652

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

653

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

653

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

654

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

654

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

656

············qemu_log("%d@%zu.%06zu:vtd_inv_desc_wait_irq·"·"%s"·"\n",

656

············qemu_log("%d@%zu.%06zu:vtd_inv_desc_wait_irq·"·"%s"·"\n",

657

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

657

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

658

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

658

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

659

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

659

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

660

#line·662·"trace/trace-hw_i386.h"

660

#line·662·"trace/trace-hw_i386.h"

661

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

661

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

663

············qemu_log("vtd_inv_desc_wait_irq·"·"%s"·"\n",·msg);

663

············qemu_log("vtd_inv_desc_wait_irq·"·"%s"·"\n",·msg);

664

#line·666·"trace/trace-hw_i386.h"

664

#line·666·"trace/trace-hw_i386.h"

665

········}

665

········}

666

····}

666

····}

667

}

667

}

668

static·inline·void·trace_vtd_inv_desc_wait_irq(const·char·*·msg)

668

static·inline·void·trace_vtd_inv_desc_wait_irq(const·char·*·msg)

680

static·inline·void·_nocheck__trace_vtd_inv_desc_wait_write_fail(uint64_t·hi,·uint64_t·lo)

680

static·inline·void·_nocheck__trace_vtd_inv_desc_wait_write_fail(uint64_t·hi,·uint64_t·lo)

681

{

681

{

682

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

682

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

683

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

683

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

684

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

684

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

685

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

685

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

687

············qemu_log("%d@%zu.%06zu:vtd_inv_desc_wait_write_fail·"·"write·fail·for·wait·desc·hi·0x%"PRIx64"·lo·0x%"PRIx64·"\n",

687

············qemu_log("%d@%zu.%06zu:vtd_inv_desc_wait_write_fail·"·"write·fail·for·wait·desc·hi·0x%"PRIx64"·lo·0x%"PRIx64·"\n",

688

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

688

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

689

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

689

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

690

·····················,·hi,·lo);

690

·····················,·hi,·lo);

691

#line·693·"trace/trace-hw_i386.h"

691

#line·693·"trace/trace-hw_i386.h"

692

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

692

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

694

············qemu_log("vtd_inv_desc_wait_write_fail·"·"write·fail·for·wait·desc·hi·0x%"PRIx64"·lo·0x%"PRIx64·"\n",·hi,·lo);

694

············qemu_log("vtd_inv_desc_wait_write_fail·"·"write·fail·for·wait·desc·hi·0x%"PRIx64"·lo·0x%"PRIx64·"\n",·hi,·lo);

695

#line·697·"trace/trace-hw_i386.h"

695

#line·697·"trace/trace-hw_i386.h"

696

········}

696

········}

697

····}

697

····}

698

}

698

}

699

static·inline·void·trace_vtd_inv_desc_wait_write_fail(uint64_t·hi,·uint64_t·lo)

699

static·inline·void·trace_vtd_inv_desc_wait_write_fail(uint64_t·hi,·uint64_t·lo)

711

static·inline·void·_nocheck__trace_vtd_inv_desc_iec(uint32_t·granularity,·uint32_t·index,·uint32_t·mask)

711

static·inline·void·_nocheck__trace_vtd_inv_desc_iec(uint32_t·granularity,·uint32_t·index,·uint32_t·mask)

712

{

712

{

713

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

713

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

714

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

714

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

715

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

715

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

716

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

716

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

718

············qemu_log("%d@%zu.%06zu:vtd_inv_desc_iec·"·"granularity·0x%"PRIx32"·index·0x%"PRIx32"·mask·0x%"PRIx32·"\n",

718

············qemu_log("%d@%zu.%06zu:vtd_inv_desc_iec·"·"granularity·0x%"PRIx32"·index·0x%"PRIx32"·mask·0x%"PRIx32·"\n",

719

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

719

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

720

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

720

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

721

·····················,·granularity,·index,·mask);

721

·····················,·granularity,·index,·mask);

722

#line·724·"trace/trace-hw_i386.h"

722

#line·724·"trace/trace-hw_i386.h"

723

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

723

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

725

············qemu_log("vtd_inv_desc_iec·"·"granularity·0x%"PRIx32"·index·0x%"PRIx32"·mask·0x%"PRIx32·"\n",·granularity,·index,·mask);

725

············qemu_log("vtd_inv_desc_iec·"·"granularity·0x%"PRIx32"·index·0x%"PRIx32"·mask·0x%"PRIx32·"\n",·granularity,·index,·mask);

726

#line·728·"trace/trace-hw_i386.h"

726

#line·728·"trace/trace-hw_i386.h"

727

········}

727

········}

728

····}

728

····}

729

}

729

}

730

static·inline·void·trace_vtd_inv_desc_iec(uint32_t·granularity,·uint32_t·index,·uint32_t·mask)

730

static·inline·void·trace_vtd_inv_desc_iec(uint32_t·granularity,·uint32_t·index,·uint32_t·mask)

742

static·inline·void·_nocheck__trace_vtd_inv_qi_enable(bool·enable)

742

static·inline·void·_nocheck__trace_vtd_inv_qi_enable(bool·enable)

743

{

743

{

744

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

744

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

745

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

745

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

746

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

746

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

747

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

747

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

749

············qemu_log("%d@%zu.%06zu:vtd_inv_qi_enable·"·"enabled·%d"·"\n",

749

············qemu_log("%d@%zu.%06zu:vtd_inv_qi_enable·"·"enabled·%d"·"\n",

750

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

750

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

751

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

751

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

752

·····················,·enable);

752

·····················,·enable);

753

#line·755·"trace/trace-hw_i386.h"

753

#line·755·"trace/trace-hw_i386.h"

754

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

754

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

756

············qemu_log("vtd_inv_qi_enable·"·"enabled·%d"·"\n",·enable);

756

············qemu_log("vtd_inv_qi_enable·"·"enabled·%d"·"\n",·enable);

757

#line·759·"trace/trace-hw_i386.h"

757

#line·759·"trace/trace-hw_i386.h"

758

········}

758

········}

759

····}

759

····}

760

}

760

}

761

static·inline·void·trace_vtd_inv_qi_enable(bool·enable)

761

static·inline·void·trace_vtd_inv_qi_enable(bool·enable)

773

static·inline·void·_nocheck__trace_vtd_inv_qi_setup(uint64_t·addr,·int·size)

773

static·inline·void·_nocheck__trace_vtd_inv_qi_setup(uint64_t·addr,·int·size)

774

{

774

{

775

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

775

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

776

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

776

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

777

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

777

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

778

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

778

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

780

············qemu_log("%d@%zu.%06zu:vtd_inv_qi_setup·"·"addr·0x%"PRIx64"·size·%d"·"\n",

780

············qemu_log("%d@%zu.%06zu:vtd_inv_qi_setup·"·"addr·0x%"PRIx64"·size·%d"·"\n",

781

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

781

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

782

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

782

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

783

·····················,·addr,·size);

783

·····················,·addr,·size);

784

#line·786·"trace/trace-hw_i386.h"

784

#line·786·"trace/trace-hw_i386.h"

785

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

785

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

787

············qemu_log("vtd_inv_qi_setup·"·"addr·0x%"PRIx64"·size·%d"·"\n",·addr,·size);

787

············qemu_log("vtd_inv_qi_setup·"·"addr·0x%"PRIx64"·size·%d"·"\n",·addr,·size);

788

#line·790·"trace/trace-hw_i386.h"

788

#line·790·"trace/trace-hw_i386.h"

789

········}

789

········}

790

····}

790

····}

791

}

791

}

792

static·inline·void·trace_vtd_inv_qi_setup(uint64_t·addr,·int·size)

792

static·inline·void·trace_vtd_inv_qi_setup(uint64_t·addr,·int·size)

804

static·inline·void·_nocheck__trace_vtd_inv_qi_head(uint16_t·head)

804

static·inline·void·_nocheck__trace_vtd_inv_qi_head(uint16_t·head)

805

{

805

{

806

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

806

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

807

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

807

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

808

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

808

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

809

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

809

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

811

············qemu_log("%d@%zu.%06zu:vtd_inv_qi_head·"·"read·head·%d"·"\n",

811

············qemu_log("%d@%zu.%06zu:vtd_inv_qi_head·"·"read·head·%d"·"\n",

812

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

812

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

813

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

813

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

814

·····················,·head);

814

·····················,·head);

815

#line·817·"trace/trace-hw_i386.h"

815

#line·817·"trace/trace-hw_i386.h"

816

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

816

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

818

············qemu_log("vtd_inv_qi_head·"·"read·head·%d"·"\n",·head);

818

············qemu_log("vtd_inv_qi_head·"·"read·head·%d"·"\n",·head);

819

#line·821·"trace/trace-hw_i386.h"

819

#line·821·"trace/trace-hw_i386.h"

820

········}

820

········}

821

····}

821

····}

822

}

822

}

823

static·inline·void·trace_vtd_inv_qi_head(uint16_t·head)

823

static·inline·void·trace_vtd_inv_qi_head(uint16_t·head)

835

static·inline·void·_nocheck__trace_vtd_inv_qi_tail(uint16_t·head)

835

static·inline·void·_nocheck__trace_vtd_inv_qi_tail(uint16_t·head)

836

{

836

{

837

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

837

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

838

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

838

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

839

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

839

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

840

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

840

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

842

············qemu_log("%d@%zu.%06zu:vtd_inv_qi_tail·"·"write·tail·%d"·"\n",

842

············qemu_log("%d@%zu.%06zu:vtd_inv_qi_tail·"·"write·tail·%d"·"\n",

843

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

843

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

844

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

844

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

845

·····················,·head);

845

·····················,·head);

846

#line·848·"trace/trace-hw_i386.h"

846

#line·848·"trace/trace-hw_i386.h"

847

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

847

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

849

············qemu_log("vtd_inv_qi_tail·"·"write·tail·%d"·"\n",·head);

849

············qemu_log("vtd_inv_qi_tail·"·"write·tail·%d"·"\n",·head);

850

#line·852·"trace/trace-hw_i386.h"

850

#line·852·"trace/trace-hw_i386.h"

851

········}

851

········}

852

····}

852

····}

853

}

853

}

854

static·inline·void·trace_vtd_inv_qi_tail(uint16_t·head)

854

static·inline·void·trace_vtd_inv_qi_tail(uint16_t·head)

866

static·inline·void·_nocheck__trace_vtd_inv_qi_fetch(void)

866

static·inline·void·_nocheck__trace_vtd_inv_qi_fetch(void)

867

{

867

{

868

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

868

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

869

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

869

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

870

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

870

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

871

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

871

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

873

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

873

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

874

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

874

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

875

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

875

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

876

·····················);

876

·····················);

877

#line·879·"trace/trace-hw_i386.h"

877

#line·879·"trace/trace-hw_i386.h"

878

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

878

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

880

············qemu_log("vtd_inv_qi_fetch·"·""·"\n");

880

············qemu_log("vtd_inv_qi_fetch·"·""·"\n");

881

#line·883·"trace/trace-hw_i386.h"

881

#line·883·"trace/trace-hw_i386.h"

882

········}

882

········}

883

····}

883

····}

884

}

884

}

885

static·inline·void·trace_vtd_inv_qi_fetch(void)

885

static·inline·void·trace_vtd_inv_qi_fetch(void)

897

static·inline·void·_nocheck__trace_vtd_context_cache_reset(void)

897

static·inline·void·_nocheck__trace_vtd_context_cache_reset(void)

898

{

898

{

899

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

899

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

900

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

900

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

901

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

901

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

902

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

902

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

904

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

904

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

905

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

905

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

906

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

906

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

907

·····················);

907

·····················);

908

#line·910·"trace/trace-hw_i386.h"

908

#line·910·"trace/trace-hw_i386.h"

909

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

909

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

911

············qemu_log("vtd_context_cache_reset·"·""·"\n");

911

············qemu_log("vtd_context_cache_reset·"·""·"\n");

912

#line·914·"trace/trace-hw_i386.h"

912

#line·914·"trace/trace-hw_i386.h"

913

········}

913

········}

914

····}

914

····}

915

}

915

}

916

static·inline·void·trace_vtd_context_cache_reset(void)

916

static·inline·void·trace_vtd_context_cache_reset(void)

928

static·inline·void·_nocheck__trace_vtd_re_not_present(uint8_t·bus)

928

static·inline·void·_nocheck__trace_vtd_re_not_present(uint8_t·bus)

929

{

929

{

930

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

930

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

931

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

931

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

932

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

932

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

933

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

933

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

935

············qemu_log("%d@%zu.%06zu:vtd_re_not_present·"·"Root·entry·bus·%"PRIu8"·not·present"·"\n",

935

············qemu_log("%d@%zu.%06zu:vtd_re_not_present·"·"Root·entry·bus·%"PRIu8"·not·present"·"\n",

936

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

936

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

937

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

937

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

938

·····················,·bus);

938

·····················,·bus);

939

#line·941·"trace/trace-hw_i386.h"

939

#line·941·"trace/trace-hw_i386.h"

940

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

940

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

942

············qemu_log("vtd_re_not_present·"·"Root·entry·bus·%"PRIu8"·not·present"·"\n",·bus);

942

············qemu_log("vtd_re_not_present·"·"Root·entry·bus·%"PRIu8"·not·present"·"\n",·bus);

943

#line·945·"trace/trace-hw_i386.h"

943

#line·945·"trace/trace-hw_i386.h"

944

········}

944

········}

945

····}

945

····}

946

}

946

}

947

static·inline·void·trace_vtd_re_not_present(uint8_t·bus)

947

static·inline·void·trace_vtd_re_not_present(uint8_t·bus)

959

static·inline·void·_nocheck__trace_vtd_ce_not_present(uint8_t·bus,·uint8_t·devfn)

959

static·inline·void·_nocheck__trace_vtd_ce_not_present(uint8_t·bus,·uint8_t·devfn)

960

{

960

{

961

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

961

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

962

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

962

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

963

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

963

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

964

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

964

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

966

············qemu_log("%d@%zu.%06zu:vtd_ce_not_present·"·"Context·entry·bus·%"PRIu8"·devfn·%"PRIu8"·not·present"·"\n",

966

············qemu_log("%d@%zu.%06zu:vtd_ce_not_present·"·"Context·entry·bus·%"PRIu8"·devfn·%"PRIu8"·not·present"·"\n",

967

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

967

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

968

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

968

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

969

·····················,·bus,·devfn);

969

·····················,·bus,·devfn);

970

#line·972·"trace/trace-hw_i386.h"

970

#line·972·"trace/trace-hw_i386.h"

971

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

971

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

973

············qemu_log("vtd_ce_not_present·"·"Context·entry·bus·%"PRIu8"·devfn·%"PRIu8"·not·present"·"\n",·bus,·devfn);

973

············qemu_log("vtd_ce_not_present·"·"Context·entry·bus·%"PRIu8"·devfn·%"PRIu8"·not·present"·"\n",·bus,·devfn);

974

#line·976·"trace/trace-hw_i386.h"

974

#line·976·"trace/trace-hw_i386.h"

975

········}

975

········}

976

····}

976

····}

977

}

977

}

978

static·inline·void·trace_vtd_ce_not_present(uint8_t·bus,·uint8_t·devfn)

978

static·inline·void·trace_vtd_ce_not_present(uint8_t·bus,·uint8_t·devfn)

990

static·inline·void·_nocheck__trace_vtd_iotlb_page_hit(uint16_t·sid,·uint64_t·addr,·uint64_t·slpte,·uint16_t·domain)

990

static·inline·void·_nocheck__trace_vtd_iotlb_page_hit(uint16_t·sid,·uint64_t·addr,·uint64_t·slpte,·uint16_t·domain)

991

{

991

{

992

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

992

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

993

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

993

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

994

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

994

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

995

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

995

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

997

············qemu_log("%d@%zu.%06zu:vtd_iotlb_page_hit·"·"IOTLB·page·hit·sid·0x%"PRIx16"·iova·0x%"PRIx64"·slpte·0x%"PRIx64"·domain·0x%"PRIx16·"\n",

997

············qemu_log("%d@%zu.%06zu:vtd_iotlb_page_hit·"·"IOTLB·page·hit·sid·0x%"PRIx16"·iova·0x%"PRIx64"·slpte·0x%"PRIx64"·domain·0x%"PRIx16·"\n",

998

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

998

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

999

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

999

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

1000

·····················,·sid,·addr,·slpte,·domain);

1000

·····················,·sid,·addr,·slpte,·domain);

1001

#line·1003·"trace/trace-hw_i386.h"

1001

#line·1003·"trace/trace-hw_i386.h"

1002

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

1002

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

1004

············qemu_log("vtd_iotlb_page_hit·"·"IOTLB·page·hit·sid·0x%"PRIx16"·iova·0x%"PRIx64"·slpte·0x%"PRIx64"·domain·0x%"PRIx16·"\n",·sid,·addr,·slpte,·domain);

1004

············qemu_log("vtd_iotlb_page_hit·"·"IOTLB·page·hit·sid·0x%"PRIx16"·iova·0x%"PRIx64"·slpte·0x%"PRIx64"·domain·0x%"PRIx16·"\n",·sid,·addr,·slpte,·domain);

1005

#line·1007·"trace/trace-hw_i386.h"

1005

#line·1007·"trace/trace-hw_i386.h"

1006

········}

1006

········}

1007

····}

1007

····}

1008

}

1008

}

1009

static·inline·void·trace_vtd_iotlb_page_hit(uint16_t·sid,·uint64_t·addr,·uint64_t·slpte,·uint16_t·domain)

1009

static·inline·void·trace_vtd_iotlb_page_hit(uint16_t·sid,·uint64_t·addr,·uint64_t·slpte,·uint16_t·domain)

1021

static·inline·void·_nocheck__trace_vtd_iotlb_page_update(uint16_t·sid,·uint64_t·addr,·uint64_t·slpte,·uint16_t·domain)

1021

static·inline·void·_nocheck__trace_vtd_iotlb_page_update(uint16_t·sid,·uint64_t·addr,·uint64_t·slpte,·uint16_t·domain)

1022

{

1022

{

1023

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

1023

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

1024

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

1024

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

1025

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

1025

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

1026

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

1026

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

1028

············qemu_log("%d@%zu.%06zu:vtd_iotlb_page_update·"·"IOTLB·page·update·sid·0x%"PRIx16"·iova·0x%"PRIx64"·slpte·0x%"PRIx64"·domain·0x%"PRIx16·"\n",

1028

············qemu_log("%d@%zu.%06zu:vtd_iotlb_page_update·"·"IOTLB·page·update·sid·0x%"PRIx16"·iova·0x%"PRIx64"·slpte·0x%"PRIx64"·domain·0x%"PRIx16·"\n",

1029

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

1029

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

1030

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

1030

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

1031

·····················,·sid,·addr,·slpte,·domain);

1031

·····················,·sid,·addr,·slpte,·domain);

1032

#line·1034·"trace/trace-hw_i386.h"

1032

#line·1034·"trace/trace-hw_i386.h"

1033

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

1033

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

1035

············qemu_log("vtd_iotlb_page_update·"·"IOTLB·page·update·sid·0x%"PRIx16"·iova·0x%"PRIx64"·slpte·0x%"PRIx64"·domain·0x%"PRIx16·"\n",·sid,·addr,·slpte,·domain);

1035

············qemu_log("vtd_iotlb_page_update·"·"IOTLB·page·update·sid·0x%"PRIx16"·iova·0x%"PRIx64"·slpte·0x%"PRIx64"·domain·0x%"PRIx16·"\n",·sid,·addr,·slpte,·domain);

1036

#line·1038·"trace/trace-hw_i386.h"

1036

#line·1038·"trace/trace-hw_i386.h"

1037

········}

1037

········}

1038

····}

1038

····}

1039

}

1039

}

1040

static·inline·void·trace_vtd_iotlb_page_update(uint16_t·sid,·uint64_t·addr,·uint64_t·slpte,·uint16_t·domain)

1040

static·inline·void·trace_vtd_iotlb_page_update(uint16_t·sid,·uint64_t·addr,·uint64_t·slpte,·uint16_t·domain)

1052

static·inline·void·_nocheck__trace_vtd_iotlb_cc_hit(uint8_t·bus,·uint8_t·devfn,·uint64_t·high,·uint64_t·low,·uint32_t·gen)

1052

static·inline·void·_nocheck__trace_vtd_iotlb_cc_hit(uint8_t·bus,·uint8_t·devfn,·uint64_t·high,·uint64_t·low,·uint32_t·gen)

1053

{

1053

{

1054

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

1054

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

1055

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

1055

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

1056

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

1056

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

1057

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

1057

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

1059

············qemu_log("%d@%zu.%06zu:vtd_iotlb_cc_hit·"·"IOTLB·context·hit·bus·0x%"PRIx8"·devfn·0x%"PRIx8"·high·0x%"PRIx64"·low·0x%"PRIx64"·gen·%"PRIu32·"\n",

1059

············qemu_log("%d@%zu.%06zu:vtd_iotlb_cc_hit·"·"IOTLB·context·hit·bus·0x%"PRIx8"·devfn·0x%"PRIx8"·high·0x%"PRIx64"·low·0x%"PRIx64"·gen·%"PRIu32·"\n",

1060

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

1060

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

1061

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

1061

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

1062

·····················,·bus,·devfn,·high,·low,·gen);

1062

·····················,·bus,·devfn,·high,·low,·gen);

1063

#line·1065·"trace/trace-hw_i386.h"

1063

#line·1065·"trace/trace-hw_i386.h"

1064

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

1064

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

1066

············qemu_log("vtd_iotlb_cc_hit·"·"IOTLB·context·hit·bus·0x%"PRIx8"·devfn·0x%"PRIx8"·high·0x%"PRIx64"·low·0x%"PRIx64"·gen·%"PRIu32·"\n",·bus,·devfn,·high,·low,·gen);

1066

············qemu_log("vtd_iotlb_cc_hit·"·"IOTLB·context·hit·bus·0x%"PRIx8"·devfn·0x%"PRIx8"·high·0x%"PRIx64"·low·0x%"PRIx64"·gen·%"PRIu32·"\n",·bus,·devfn,·high,·low,·gen);

1067

#line·1069·"trace/trace-hw_i386.h"

1067

#line·1069·"trace/trace-hw_i386.h"

1068

········}

1068

········}

1069

····}

1069

····}

1070

}

1070

}

1071

static·inline·void·trace_vtd_iotlb_cc_hit(uint8_t·bus,·uint8_t·devfn,·uint64_t·high,·uint64_t·low,·uint32_t·gen)

1071

static·inline·void·trace_vtd_iotlb_cc_hit(uint8_t·bus,·uint8_t·devfn,·uint64_t·high,·uint64_t·low,·uint32_t·gen)

1083

static·inline·void·_nocheck__trace_vtd_iotlb_cc_update(uint8_t·bus,·uint8_t·devfn,·uint64_t·high,·uint64_t·low,·uint32_t·gen1,·uint32_t·gen2)

1083

static·inline·void·_nocheck__trace_vtd_iotlb_cc_update(uint8_t·bus,·uint8_t·devfn,·uint64_t·high,·uint64_t·low,·uint32_t·gen1,·uint32_t·gen2)

1084

{

1084

{

1085

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

1085

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

1086

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

1086

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

1087

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

1087

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

1088

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

1088

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

1090

············qemu_log("%d@%zu.%06zu:vtd_iotlb_cc_update·"·"IOTLB·context·update·bus·0x%"PRIx8"·devfn·0x%"PRIx8"·high·0x%"PRIx64"·low·0x%"PRIx64"·gen·%"PRIu32"·->·gen·%"PRIu32·"\n",

1090

············qemu_log("%d@%zu.%06zu:vtd_iotlb_cc_update·"·"IOTLB·context·update·bus·0x%"PRIx8"·devfn·0x%"PRIx8"·high·0x%"PRIx64"·low·0x%"PRIx64"·gen·%"PRIu32"·->·gen·%"PRIu32·"\n",

1091

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

1091

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

1092

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

1092

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

1093

·····················,·bus,·devfn,·high,·low,·gen1,·gen2);

1093

·····················,·bus,·devfn,·high,·low,·gen1,·gen2);

1094

#line·1096·"trace/trace-hw_i386.h"

1094

#line·1096·"trace/trace-hw_i386.h"

1095

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

1095

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

1097

············qemu_log("vtd_iotlb_cc_update·"·"IOTLB·context·update·bus·0x%"PRIx8"·devfn·0x%"PRIx8"·high·0x%"PRIx64"·low·0x%"PRIx64"·gen·%"PRIu32"·->·gen·%"PRIu32·"\n",·bus,·devfn,·high,·low,·gen1,·gen2);

1097

············qemu_log("vtd_iotlb_cc_update·"·"IOTLB·context·update·bus·0x%"PRIx8"·devfn·0x%"PRIx8"·high·0x%"PRIx64"·low·0x%"PRIx64"·gen·%"PRIu32"·->·gen·%"PRIu32·"\n",·bus,·devfn,·high,·low,·gen1,·gen2);

1098

#line·1100·"trace/trace-hw_i386.h"

1098

#line·1100·"trace/trace-hw_i386.h"

1099

········}

1099

········}

1100

····}

1100

····}

1101

}

1101

}

1102

static·inline·void·trace_vtd_iotlb_cc_update(uint8_t·bus,·uint8_t·devfn,·uint64_t·high,·uint64_t·low,·uint32_t·gen1,·uint32_t·gen2)

1102

static·inline·void·trace_vtd_iotlb_cc_update(uint8_t·bus,·uint8_t·devfn,·uint64_t·high,·uint64_t·low,·uint32_t·gen1,·uint32_t·gen2)

1114

static·inline·void·_nocheck__trace_vtd_iotlb_reset(const·char·*·reason)

1114

static·inline·void·_nocheck__trace_vtd_iotlb_reset(const·char·*·reason)

1115

{

1115

{

1116

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

1116

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

1117

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

1117

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

1118

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

1118

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

1119

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

1119

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

1121

············qemu_log("%d@%zu.%06zu:vtd_iotlb_reset·"·"IOTLB·reset·(reason:·%s)"·"\n",

1121

············qemu_log("%d@%zu.%06zu:vtd_iotlb_reset·"·"IOTLB·reset·(reason:·%s)"·"\n",

1122

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

1122

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

1123

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

1123

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

1124

·····················,·reason);

1124

·····················,·reason);

1125

#line·1127·"trace/trace-hw_i386.h"

1125

#line·1127·"trace/trace-hw_i386.h"

1126

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

1126

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

1128

············qemu_log("vtd_iotlb_reset·"·"IOTLB·reset·(reason:·%s)"·"\n",·reason);

1128

············qemu_log("vtd_iotlb_reset·"·"IOTLB·reset·(reason:·%s)"·"\n",·reason);

1129

#line·1131·"trace/trace-hw_i386.h"

1129

#line·1131·"trace/trace-hw_i386.h"

1130

········}

1130

········}

1131

····}

1131

····}

1132

}

1132

}

1133

static·inline·void·trace_vtd_iotlb_reset(const·char·*·reason)

1133

static·inline·void·trace_vtd_iotlb_reset(const·char·*·reason)

1145

static·inline·void·_nocheck__trace_vtd_fault_disabled(void)

1145

static·inline·void·_nocheck__trace_vtd_fault_disabled(void)

1146

{

1146

{

1147

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

1147

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

1148

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

1148

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

1149

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

1149

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

1150

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

1150

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

1152

············qemu_log("%d@%zu.%06zu:vtd_fault_disabled·"·"Fault·processing·disabled·for·context·entry"·"\n",

1152

············qemu_log("%d@%zu.%06zu:vtd_fault_disabled·"·"Fault·processing·disabled·for·context·entry"·"\n",

1153

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

1153

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

1154

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

1154

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

1155

·····················);

1155

·····················);

1156

#line·1158·"trace/trace-hw_i386.h"

1156

#line·1158·"trace/trace-hw_i386.h"

1157

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

1157

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

1159

············qemu_log("vtd_fault_disabled·"·"Fault·processing·disabled·for·context·entry"·"\n");

1159

············qemu_log("vtd_fault_disabled·"·"Fault·processing·disabled·for·context·entry"·"\n");

1160

#line·1162·"trace/trace-hw_i386.h"

1160

#line·1162·"trace/trace-hw_i386.h"

1161

········}

1161

········}

1162

····}

1162

····}

1163

}

1163

}

1164

static·inline·void·trace_vtd_fault_disabled(void)

1164

static·inline·void·trace_vtd_fault_disabled(void)

1176

static·inline·void·_nocheck__trace_vtd_replay_ce_valid(const·char·*·mode,·uint8_t·bus,·uint8_t·dev,·uint8_t·fn,·uint16_t·domain,·uint64_t·hi,·uint64_t·lo)

1176

static·inline·void·_nocheck__trace_vtd_replay_ce_valid(const·char·*·mode,·uint8_t·bus,·uint8_t·dev,·uint8_t·fn,·uint16_t·domain,·uint64_t·hi,·uint64_t·lo)

1177

{

1177

{

1178

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

1178

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

1179

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

1179

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

1180

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

1180

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

1181

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

1181

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

1183

············qemu_log("%d@%zu.%06zu:vtd_replay_ce_valid·"·"%s:·replay·valid·context·device·%02"PRIx8":%02"PRIx8".%02"PRIx8"·domain·0x%"PRIx16"·hi·0x%"PRIx64"·lo·0x%"PRIx64·"\n",

1183

············qemu_log("%d@%zu.%06zu:vtd_replay_ce_valid·"·"%s:·replay·valid·context·device·%02"PRIx8":%02"PRIx8".%02"PRIx8"·domain·0x%"PRIx16"·hi·0x%"PRIx64"·lo·0x%"PRIx64·"\n",

1184

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

1184

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

1185

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

1185

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

1186

·····················,·mode,·bus,·dev,·fn,·domain,·hi,·lo);

1186

·····················,·mode,·bus,·dev,·fn,·domain,·hi,·lo);

1187

#line·1189·"trace/trace-hw_i386.h"

1187

#line·1189·"trace/trace-hw_i386.h"

1188

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

1188

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

1190

············qemu_log("vtd_replay_ce_valid·"·"%s:·replay·valid·context·device·%02"PRIx8":%02"PRIx8".%02"PRIx8"·domain·0x%"PRIx16"·hi·0x%"PRIx64"·lo·0x%"PRIx64·"\n",·mode,·bus,·dev,·fn,·domain,·hi,·lo);

1190

············qemu_log("vtd_replay_ce_valid·"·"%s:·replay·valid·context·device·%02"PRIx8":%02"PRIx8".%02"PRIx8"·domain·0x%"PRIx16"·hi·0x%"PRIx64"·lo·0x%"PRIx64·"\n",·mode,·bus,·dev,·fn,·domain,·hi,·lo);

1191

#line·1193·"trace/trace-hw_i386.h"

1191

#line·1193·"trace/trace-hw_i386.h"

1192

········}

1192

········}

1193

····}

1193

····}

1194

}

1194

}

1195

static·inline·void·trace_vtd_replay_ce_valid(const·char·*·mode,·uint8_t·bus,·uint8_t·dev,·uint8_t·fn,·uint16_t·domain,·uint64_t·hi,·uint64_t·lo)

1195

static·inline·void·trace_vtd_replay_ce_valid(const·char·*·mode,·uint8_t·bus,·uint8_t·dev,·uint8_t·fn,·uint16_t·domain,·uint64_t·hi,·uint64_t·lo)

1207

static·inline·void·_nocheck__trace_vtd_replay_ce_invalid(uint8_t·bus,·uint8_t·dev,·uint8_t·fn)

1207

static·inline·void·_nocheck__trace_vtd_replay_ce_invalid(uint8_t·bus,·uint8_t·dev,·uint8_t·fn)

1208

{

1208

{

1209

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

1209

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

1210

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

1210

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

1211

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

1211

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

1212

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

1212

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

1214

············qemu_log("%d@%zu.%06zu:vtd_replay_ce_invalid·"·"replay·invalid·context·device·%02"PRIx8":%02"PRIx8".%02"PRIx8·"\n",

1214

············qemu_log("%d@%zu.%06zu:vtd_replay_ce_invalid·"·"replay·invalid·context·device·%02"PRIx8":%02"PRIx8".%02"PRIx8·"\n",

1215

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

1215

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

1216

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

1216

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

1217

·····················,·bus,·dev,·fn);

1217

·····················,·bus,·dev,·fn);

1218

#line·1220·"trace/trace-hw_i386.h"

1218

#line·1220·"trace/trace-hw_i386.h"

1219

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

1219

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

1221

············qemu_log("vtd_replay_ce_invalid·"·"replay·invalid·context·device·%02"PRIx8":%02"PRIx8".%02"PRIx8·"\n",·bus,·dev,·fn);

1221

············qemu_log("vtd_replay_ce_invalid·"·"replay·invalid·context·device·%02"PRIx8":%02"PRIx8".%02"PRIx8·"\n",·bus,·dev,·fn);

1222

#line·1224·"trace/trace-hw_i386.h"

1222

#line·1224·"trace/trace-hw_i386.h"

1223

········}

1223

········}

1224

····}

1224

····}

1225

}

1225

}

1226

static·inline·void·trace_vtd_replay_ce_invalid(uint8_t·bus,·uint8_t·dev,·uint8_t·fn)

1226

static·inline·void·trace_vtd_replay_ce_invalid(uint8_t·bus,·uint8_t·dev,·uint8_t·fn)

1238

static·inline·void·_nocheck__trace_vtd_page_walk_level(uint64_t·addr,·uint32_t·level,·uint64_t·start,·uint64_t·end)

1238

static·inline·void·_nocheck__trace_vtd_page_walk_level(uint64_t·addr,·uint32_t·level,·uint64_t·start,·uint64_t·end)

1239

{

1239

{

1240

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

1240

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

1241

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

1241

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

1242

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

1242

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

1243

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

1243

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

1245

············qemu_log("%d@%zu.%06zu:vtd_page_walk_level·"·"walk·(base=0x%"PRIx64",·level=%"PRIu32")·iova·range·0x%"PRIx64"·-·0x%"PRIx64·"\n",

1245

············qemu_log("%d@%zu.%06zu:vtd_page_walk_level·"·"walk·(base=0x%"PRIx64",·level=%"PRIu32")·iova·range·0x%"PRIx64"·-·0x%"PRIx64·"\n",

1246

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

1246

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

1247

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

1247

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

1248

·····················,·addr,·level,·start,·end);

1248

·····················,·addr,·level,·start,·end);

1249

#line·1251·"trace/trace-hw_i386.h"

1249

#line·1251·"trace/trace-hw_i386.h"

1250

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

1250

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

1252

············qemu_log("vtd_page_walk_level·"·"walk·(base=0x%"PRIx64",·level=%"PRIu32")·iova·range·0x%"PRIx64"·-·0x%"PRIx64·"\n",·addr,·level,·start,·end);

1252

············qemu_log("vtd_page_walk_level·"·"walk·(base=0x%"PRIx64",·level=%"PRIu32")·iova·range·0x%"PRIx64"·-·0x%"PRIx64·"\n",·addr,·level,·start,·end);

1253

#line·1255·"trace/trace-hw_i386.h"

1253

#line·1255·"trace/trace-hw_i386.h"

1254

········}

1254

········}

1255

····}

1255

····}

1256

}

1256

}

1257

static·inline·void·trace_vtd_page_walk_level(uint64_t·addr,·uint32_t·level,·uint64_t·start,·uint64_t·end)

1257

static·inline·void·trace_vtd_page_walk_level(uint64_t·addr,·uint32_t·level,·uint64_t·start,·uint64_t·end)

1269

static·inline·void·_nocheck__trace_vtd_page_walk_one(uint16_t·domain,·uint64_t·iova,·uint64_t·gpa,·uint64_t·mask,·int·perm)

1269

static·inline·void·_nocheck__trace_vtd_page_walk_one(uint16_t·domain,·uint64_t·iova,·uint64_t·gpa,·uint64_t·mask,·int·perm)

1270

{

1270

{

1271

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

1271

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

1272

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

1272

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

1273

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

1273

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

1274

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

1274

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

1276

············qemu_log("%d@%zu.%06zu:vtd_page_walk_one·"·"domain·0x%"PRIu16"·iova·0x%"PRIx64"·->·gpa·0x%"PRIx64"·mask·0x%"PRIx64"·perm·%d"·"\n",

1276

············qemu_log("%d@%zu.%06zu:vtd_page_walk_one·"·"domain·0x%"PRIu16"·iova·0x%"PRIx64"·->·gpa·0x%"PRIx64"·mask·0x%"PRIx64"·perm·%d"·"\n",

1277

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

1277

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

1278

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

1278

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

1279

·····················,·domain,·iova,·gpa,·mask,·perm);

1279

·····················,·domain,·iova,·gpa,·mask,·perm);

1280

#line·1282·"trace/trace-hw_i386.h"

1280

#line·1282·"trace/trace-hw_i386.h"

1281

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

1281

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

1283

············qemu_log("vtd_page_walk_one·"·"domain·0x%"PRIu16"·iova·0x%"PRIx64"·->·gpa·0x%"PRIx64"·mask·0x%"PRIx64"·perm·%d"·"\n",·domain,·iova,·gpa,·mask,·perm);

1283

············qemu_log("vtd_page_walk_one·"·"domain·0x%"PRIu16"·iova·0x%"PRIx64"·->·gpa·0x%"PRIx64"·mask·0x%"PRIx64"·perm·%d"·"\n",·domain,·iova,·gpa,·mask,·perm);

1284

#line·1286·"trace/trace-hw_i386.h"

1284

#line·1286·"trace/trace-hw_i386.h"

1285

········}

1285

········}

1286

····}

1286

····}

1287

}

1287

}

1288

static·inline·void·trace_vtd_page_walk_one(uint16_t·domain,·uint64_t·iova,·uint64_t·gpa,·uint64_t·mask,·int·perm)

1288

static·inline·void·trace_vtd_page_walk_one(uint16_t·domain,·uint64_t·iova,·uint64_t·gpa,·uint64_t·mask,·int·perm)

1300

static·inline·void·_nocheck__trace_vtd_page_walk_one_skip_map(uint64_t·iova,·uint64_t·mask,·uint64_t·translated)

1300

static·inline·void·_nocheck__trace_vtd_page_walk_one_skip_map(uint64_t·iova,·uint64_t·mask,·uint64_t·translated)

1301

{

1301

{

1302

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

1302

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

1303

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

1303

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

1304

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

1304

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

1305

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

1305

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

1307

············qemu_log("%d@%zu.%06zu:vtd_page_walk_one_skip_map·"·"iova·0x%"PRIx64"·mask·0x%"PRIx64"·translated·0x%"PRIx64·"\n",

1307

············qemu_log("%d@%zu.%06zu:vtd_page_walk_one_skip_map·"·"iova·0x%"PRIx64"·mask·0x%"PRIx64"·translated·0x%"PRIx64·"\n",

1308

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

1308

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

1309

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

1309

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

1310

·····················,·iova,·mask,·translated);

1310

·····················,·iova,·mask,·translated);

1311

#line·1313·"trace/trace-hw_i386.h"

1311

#line·1313·"trace/trace-hw_i386.h"

1312

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

1312

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

1314

············qemu_log("vtd_page_walk_one_skip_map·"·"iova·0x%"PRIx64"·mask·0x%"PRIx64"·translated·0x%"PRIx64·"\n",·iova,·mask,·translated);

1314

············qemu_log("vtd_page_walk_one_skip_map·"·"iova·0x%"PRIx64"·mask·0x%"PRIx64"·translated·0x%"PRIx64·"\n",·iova,·mask,·translated);

1315

#line·1317·"trace/trace-hw_i386.h"

1315

#line·1317·"trace/trace-hw_i386.h"

1316

········}

1316

········}

1317

····}

1317

····}

1318

}

1318

}

1319

static·inline·void·trace_vtd_page_walk_one_skip_map(uint64_t·iova,·uint64_t·mask,·uint64_t·translated)

1319

static·inline·void·trace_vtd_page_walk_one_skip_map(uint64_t·iova,·uint64_t·mask,·uint64_t·translated)

1331

static·inline·void·_nocheck__trace_vtd_page_walk_one_skip_unmap(uint64_t·iova,·uint64_t·mask)

1331

static·inline·void·_nocheck__trace_vtd_page_walk_one_skip_unmap(uint64_t·iova,·uint64_t·mask)

1332

{

1332

{

1333

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

1333

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

1334

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

1334

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

1335

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

1335

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

1336

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

1336

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

1338

············qemu_log("%d@%zu.%06zu:vtd_page_walk_one_skip_unmap·"·"iova·0x%"PRIx64"·mask·0x%"PRIx64·"\n",

1338

············qemu_log("%d@%zu.%06zu:vtd_page_walk_one_skip_unmap·"·"iova·0x%"PRIx64"·mask·0x%"PRIx64·"\n",

1339

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

1339

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

1340

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

1340

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

1341

·····················,·iova,·mask);

1341

·····················,·iova,·mask);

1342

#line·1344·"trace/trace-hw_i386.h"

1342

#line·1344·"trace/trace-hw_i386.h"

1343

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

1343

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

1345

············qemu_log("vtd_page_walk_one_skip_unmap·"·"iova·0x%"PRIx64"·mask·0x%"PRIx64·"\n",·iova,·mask);

1345

············qemu_log("vtd_page_walk_one_skip_unmap·"·"iova·0x%"PRIx64"·mask·0x%"PRIx64·"\n",·iova,·mask);

1346

#line·1348·"trace/trace-hw_i386.h"

1346

#line·1348·"trace/trace-hw_i386.h"

1347

········}

1347

········}

1348

····}

1348

····}

1349

}

1349

}

1350

static·inline·void·trace_vtd_page_walk_one_skip_unmap(uint64_t·iova,·uint64_t·mask)

1350

static·inline·void·trace_vtd_page_walk_one_skip_unmap(uint64_t·iova,·uint64_t·mask)

1362

static·inline·void·_nocheck__trace_vtd_page_walk_skip_read(uint64_t·iova,·uint64_t·next)

1362

static·inline·void·_nocheck__trace_vtd_page_walk_skip_read(uint64_t·iova,·uint64_t·next)

1363

{

1363

{

1364

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

1364

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

1365

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

1365

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

1366

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

1366

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

1367

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

1367

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

1369

············qemu_log("%d@%zu.%06zu:vtd_page_walk_skip_read·"·"Page·walk·skip·iova·0x%"PRIx64"·-·0x%"PRIx64"·due·to·unable·to·read"·"\n",

1369

············qemu_log("%d@%zu.%06zu:vtd_page_walk_skip_read·"·"Page·walk·skip·iova·0x%"PRIx64"·-·0x%"PRIx64"·due·to·unable·to·read"·"\n",

1370

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

1370

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

1371

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

1371

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

1372

·····················,·iova,·next);

1372

·····················,·iova,·next);

1373

#line·1375·"trace/trace-hw_i386.h"

1373

#line·1375·"trace/trace-hw_i386.h"

1374

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

1374

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

1376

············qemu_log("vtd_page_walk_skip_read·"·"Page·walk·skip·iova·0x%"PRIx64"·-·0x%"PRIx64"·due·to·unable·to·read"·"\n",·iova,·next);

1376

············qemu_log("vtd_page_walk_skip_read·"·"Page·walk·skip·iova·0x%"PRIx64"·-·0x%"PRIx64"·due·to·unable·to·read"·"\n",·iova,·next);

1377

#line·1379·"trace/trace-hw_i386.h"

1377

#line·1379·"trace/trace-hw_i386.h"

1378

········}

1378

········}

1379

····}

1379

····}

1380

}

1380

}

1381

static·inline·void·trace_vtd_page_walk_skip_read(uint64_t·iova,·uint64_t·next)

1381

static·inline·void·trace_vtd_page_walk_skip_read(uint64_t·iova,·uint64_t·next)

1393

static·inline·void·_nocheck__trace_vtd_page_walk_skip_reserve(uint64_t·iova,·uint64_t·next)

1393

static·inline·void·_nocheck__trace_vtd_page_walk_skip_reserve(uint64_t·iova,·uint64_t·next)

1394

{

1394

{

1395

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

1395

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

1396

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

1396

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

1397

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

1397

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

1398

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

1398

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

1400

············qemu_log("%d@%zu.%06zu:vtd_page_walk_skip_reserve·"·"Page·walk·skip·iova·0x%"PRIx64"·-·0x%"PRIx64"·due·to·rsrv·set"·"\n",

1400

············qemu_log("%d@%zu.%06zu:vtd_page_walk_skip_reserve·"·"Page·walk·skip·iova·0x%"PRIx64"·-·0x%"PRIx64"·due·to·rsrv·set"·"\n",

1401

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

1401

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

1402

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

1402

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

1403

·····················,·iova,·next);

1403

·····················,·iova,·next);

1404

#line·1406·"trace/trace-hw_i386.h"

1404

#line·1406·"trace/trace-hw_i386.h"

1405

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

1405

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

1407

············qemu_log("vtd_page_walk_skip_reserve·"·"Page·walk·skip·iova·0x%"PRIx64"·-·0x%"PRIx64"·due·to·rsrv·set"·"\n",·iova,·next);

1407

············qemu_log("vtd_page_walk_skip_reserve·"·"Page·walk·skip·iova·0x%"PRIx64"·-·0x%"PRIx64"·due·to·rsrv·set"·"\n",·iova,·next);

1408

#line·1410·"trace/trace-hw_i386.h"

1408

#line·1410·"trace/trace-hw_i386.h"

1409

········}

1409

········}

1410

····}

1410

····}

1411

}

1411

}

1412

static·inline·void·trace_vtd_page_walk_skip_reserve(uint64_t·iova,·uint64_t·next)

1412

static·inline·void·trace_vtd_page_walk_skip_reserve(uint64_t·iova,·uint64_t·next)

1424

static·inline·void·_nocheck__trace_vtd_switch_address_space(uint8_t·bus,·uint8_t·slot,·uint8_t·fn,·bool·on)

1424

static·inline·void·_nocheck__trace_vtd_switch_address_space(uint8_t·bus,·uint8_t·slot,·uint8_t·fn,·bool·on)

1425

{

1425

{

1426

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

1426

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

1427

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

1427

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

1428

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

1428

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

1429

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

1429

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

1431

············qemu_log("%d@%zu.%06zu:vtd_switch_address_space·"·"Device·%02x:%02x.%x·switching·address·space·(iommu·enabled=%d)"·"\n",

1431

············qemu_log("%d@%zu.%06zu:vtd_switch_address_space·"·"Device·%02x:%02x.%x·switching·address·space·(iommu·enabled=%d)"·"\n",

1432

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

1432

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

1433

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

1433

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

1434

·····················,·bus,·slot,·fn,·on);

1434

·····················,·bus,·slot,·fn,·on);

1435

#line·1437·"trace/trace-hw_i386.h"

1435

#line·1437·"trace/trace-hw_i386.h"

1436

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

1436

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

1438

············qemu_log("vtd_switch_address_space·"·"Device·%02x:%02x.%x·switching·address·space·(iommu·enabled=%d)"·"\n",·bus,·slot,·fn,·on);

1438

············qemu_log("vtd_switch_address_space·"·"Device·%02x:%02x.%x·switching·address·space·(iommu·enabled=%d)"·"\n",·bus,·slot,·fn,·on);

1439

#line·1441·"trace/trace-hw_i386.h"

1439

#line·1441·"trace/trace-hw_i386.h"

1440

········}

1440

········}

1441

····}

1441

····}

1442

}

1442

}

1443

static·inline·void·trace_vtd_switch_address_space(uint8_t·bus,·uint8_t·slot,·uint8_t·fn,·bool·on)

1443

static·inline·void·trace_vtd_switch_address_space(uint8_t·bus,·uint8_t·slot,·uint8_t·fn,·bool·on)

1455

static·inline·void·_nocheck__trace_vtd_as_unmap_whole(uint8_t·bus,·uint8_t·slot,·uint8_t·fn,·uint64_t·iova,·uint64_t·size)

1455

static·inline·void·_nocheck__trace_vtd_as_unmap_whole(uint8_t·bus,·uint8_t·slot,·uint8_t·fn,·uint64_t·iova,·uint64_t·size)

1456

{

1456

{

1457

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

1457

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

1458

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

1458

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

1459

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

1459

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

1460

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

1460

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

1462

············qemu_log("%d@%zu.%06zu:vtd_as_unmap_whole·"·"Device·%02x:%02x.%x·start·0x%"PRIx64"·size·0x%"PRIx64·"\n",

1462

············qemu_log("%d@%zu.%06zu:vtd_as_unmap_whole·"·"Device·%02x:%02x.%x·start·0x%"PRIx64"·size·0x%"PRIx64·"\n",

1463

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

1463

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

1464

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

1464

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

1465

·····················,·bus,·slot,·fn,·iova,·size);

1465

·····················,·bus,·slot,·fn,·iova,·size);

1466

#line·1468·"trace/trace-hw_i386.h"

1466

#line·1468·"trace/trace-hw_i386.h"

1467

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

1467

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

1469

············qemu_log("vtd_as_unmap_whole·"·"Device·%02x:%02x.%x·start·0x%"PRIx64"·size·0x%"PRIx64·"\n",·bus,·slot,·fn,·iova,·size);

1469

············qemu_log("vtd_as_unmap_whole·"·"Device·%02x:%02x.%x·start·0x%"PRIx64"·size·0x%"PRIx64·"\n",·bus,·slot,·fn,·iova,·size);

1470

#line·1472·"trace/trace-hw_i386.h"

1470

#line·1472·"trace/trace-hw_i386.h"

1471

········}

1471

········}

1472

····}

1472

····}

1473

}

1473

}

1474

static·inline·void·trace_vtd_as_unmap_whole(uint8_t·bus,·uint8_t·slot,·uint8_t·fn,·uint64_t·iova,·uint64_t·size)

1474

static·inline·void·trace_vtd_as_unmap_whole(uint8_t·bus,·uint8_t·slot,·uint8_t·fn,·uint64_t·iova,·uint64_t·size)

1486

static·inline·void·_nocheck__trace_vtd_translate_pt(uint16_t·sid,·uint64_t·addr)

1486

static·inline·void·_nocheck__trace_vtd_translate_pt(uint16_t·sid,·uint64_t·addr)

1487

{

1487

{

1488

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

1488

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

1489

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

1489

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

1490

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

1490

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

1491

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

1491

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

1493

············qemu_log("%d@%zu.%06zu:vtd_translate_pt·"·"source·id·0x%"PRIu16",·iova·0x%"PRIx64·"\n",

1493

············qemu_log("%d@%zu.%06zu:vtd_translate_pt·"·"source·id·0x%"PRIu16",·iova·0x%"PRIx64·"\n",

1494

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

1494

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

1495

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

1495

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

1496

·····················,·sid,·addr);

1496

·····················,·sid,·addr);

1497

#line·1499·"trace/trace-hw_i386.h"

1497

#line·1499·"trace/trace-hw_i386.h"

1498

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

1498

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

1500

············qemu_log("vtd_translate_pt·"·"source·id·0x%"PRIu16",·iova·0x%"PRIx64·"\n",·sid,·addr);

1500

············qemu_log("vtd_translate_pt·"·"source·id·0x%"PRIu16",·iova·0x%"PRIx64·"\n",·sid,·addr);

1501

#line·1503·"trace/trace-hw_i386.h"

1501

#line·1503·"trace/trace-hw_i386.h"

1502

········}

1502

········}

1503

····}

1503

····}

1504

}

1504

}

1505

static·inline·void·trace_vtd_translate_pt(uint16_t·sid,·uint64_t·addr)

1505

static·inline·void·trace_vtd_translate_pt(uint16_t·sid,·uint64_t·addr)

1517

static·inline·void·_nocheck__trace_vtd_pt_enable_fast_path(uint16_t·sid,·bool·success)

1517

static·inline·void·_nocheck__trace_vtd_pt_enable_fast_path(uint16_t·sid,·bool·success)

1518

{

1518

{

1519

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

1519

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

1520

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

1520

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

1521

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

1521

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

1522

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

1522

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

1524

············qemu_log("%d@%zu.%06zu:vtd_pt_enable_fast_path·"·"sid·0x%"PRIu16"·%d"·"\n",

1524

············qemu_log("%d@%zu.%06zu:vtd_pt_enable_fast_path·"·"sid·0x%"PRIu16"·%d"·"\n",

1525

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

1525

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

1526

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

1526

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

1527

·····················,·sid,·success);

1527

·····················,·sid,·success);

1528

#line·1530·"trace/trace-hw_i386.h"

1528

#line·1530·"trace/trace-hw_i386.h"

1529

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

1529

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

1531

············qemu_log("vtd_pt_enable_fast_path·"·"sid·0x%"PRIu16"·%d"·"\n",·sid,·success);

1531

············qemu_log("vtd_pt_enable_fast_path·"·"sid·0x%"PRIu16"·%d"·"\n",·sid,·success);

1532

#line·1534·"trace/trace-hw_i386.h"

1532

#line·1534·"trace/trace-hw_i386.h"

1533

········}

1533

········}

1534

····}

1534

····}

1535

}

1535

}

1536

static·inline·void·trace_vtd_pt_enable_fast_path(uint16_t·sid,·bool·success)

1536

static·inline·void·trace_vtd_pt_enable_fast_path(uint16_t·sid,·bool·success)

1548

static·inline·void·_nocheck__trace_vtd_irq_generate(uint64_t·addr,·uint64_t·data)

1548

static·inline·void·_nocheck__trace_vtd_irq_generate(uint64_t·addr,·uint64_t·data)

1549

{

1549

{

1550

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

1550

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

1551

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

1551

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

1552

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

1552

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

1553

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

1553

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

1555

············qemu_log("%d@%zu.%06zu:vtd_irq_generate·"·"addr·0x%"PRIx64"·data·0x%"PRIx64·"\n",

1555

············qemu_log("%d@%zu.%06zu:vtd_irq_generate·"·"addr·0x%"PRIx64"·data·0x%"PRIx64·"\n",

1556

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

1556

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

1557

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

1557

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

1558

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

1558

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

1559

#line·1561·"trace/trace-hw_i386.h"

1559

#line·1561·"trace/trace-hw_i386.h"

1560

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

1560

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

1562

············qemu_log("vtd_irq_generate·"·"addr·0x%"PRIx64"·data·0x%"PRIx64·"\n",·addr,·data);

1562

············qemu_log("vtd_irq_generate·"·"addr·0x%"PRIx64"·data·0x%"PRIx64·"\n",·addr,·data);

1563

#line·1565·"trace/trace-hw_i386.h"

1563

#line·1565·"trace/trace-hw_i386.h"

1564

········}

1564

········}

1565

····}

1565

····}

1566

}

1566

}

1567

static·inline·void·trace_vtd_irq_generate(uint64_t·addr,·uint64_t·data)

1567

static·inline·void·trace_vtd_irq_generate(uint64_t·addr,·uint64_t·data)

1579

static·inline·void·_nocheck__trace_vtd_reg_read(uint64_t·addr,·uint64_t·size)

1579

static·inline·void·_nocheck__trace_vtd_reg_read(uint64_t·addr,·uint64_t·size)

1580

{

1580

{

1581

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

1581

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

1582

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

1582

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

1583

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

1583

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

1584

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

1584

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

1586

············qemu_log("%d@%zu.%06zu:vtd_reg_read·"·"addr·0x%"PRIx64"·size·0x%"PRIx64·"\n",

1586

············qemu_log("%d@%zu.%06zu:vtd_reg_read·"·"addr·0x%"PRIx64"·size·0x%"PRIx64·"\n",

1587

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

1587

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

1588

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

1588

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

1589

·····················,·addr,·size);

1589

·····················,·addr,·size);

1590

#line·1592·"trace/trace-hw_i386.h"

1590

#line·1592·"trace/trace-hw_i386.h"

1591

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

1591

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

1593

············qemu_log("vtd_reg_read·"·"addr·0x%"PRIx64"·size·0x%"PRIx64·"\n",·addr,·size);

1593

············qemu_log("vtd_reg_read·"·"addr·0x%"PRIx64"·size·0x%"PRIx64·"\n",·addr,·size);

1594

#line·1596·"trace/trace-hw_i386.h"

1594

#line·1596·"trace/trace-hw_i386.h"

1595

········}

1595

········}

1596

····}

1596

····}

1597

}

1597

}

1598

static·inline·void·trace_vtd_reg_read(uint64_t·addr,·uint64_t·size)

1598

static·inline·void·trace_vtd_reg_read(uint64_t·addr,·uint64_t·size)

1610

static·inline·void·_nocheck__trace_vtd_reg_write(uint64_t·addr,·uint64_t·size,·uint64_t·val)

1610

static·inline·void·_nocheck__trace_vtd_reg_write(uint64_t·addr,·uint64_t·size,·uint64_t·val)

1611

{

1611

{

1612

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

1612

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

1613

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

1613

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

1614

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

1614

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

1615

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

1615

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

1617

············qemu_log("%d@%zu.%06zu:vtd_reg_write·"·"addr·0x%"PRIx64"·size·0x%"PRIx64"·value·0x%"PRIx64·"\n",

1617

············qemu_log("%d@%zu.%06zu:vtd_reg_write·"·"addr·0x%"PRIx64"·size·0x%"PRIx64"·value·0x%"PRIx64·"\n",

1618

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

1618

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

1619

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

1619

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

1620

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

1620

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

1621

#line·1623·"trace/trace-hw_i386.h"

1621

#line·1623·"trace/trace-hw_i386.h"

1622

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

1622

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

1624

············qemu_log("vtd_reg_write·"·"addr·0x%"PRIx64"·size·0x%"PRIx64"·value·0x%"PRIx64·"\n",·addr,·size,·val);

1624

············qemu_log("vtd_reg_write·"·"addr·0x%"PRIx64"·size·0x%"PRIx64"·value·0x%"PRIx64·"\n",·addr,·size,·val);

1625

#line·1627·"trace/trace-hw_i386.h"

1625

#line·1627·"trace/trace-hw_i386.h"

1626

········}

1626

········}

1627

····}

1627

····}

1628

}

1628

}

1629

static·inline·void·trace_vtd_reg_write(uint64_t·addr,·uint64_t·size,·uint64_t·val)

1629

static·inline·void·trace_vtd_reg_write(uint64_t·addr,·uint64_t·size,·uint64_t·val)

1641

static·inline·void·_nocheck__trace_vtd_reg_dmar_root(uint64_t·addr,·bool·scalable)

1641

static·inline·void·_nocheck__trace_vtd_reg_dmar_root(uint64_t·addr,·bool·scalable)

1642

{

1642

{

1643

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

1643

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

1644

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

1644

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

1645

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

1645

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

1646

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

1646

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

1648

············qemu_log("%d@%zu.%06zu:vtd_reg_dmar_root·"·"addr·0x%"PRIx64"·scalable·%d"·"\n",

1648

············qemu_log("%d@%zu.%06zu:vtd_reg_dmar_root·"·"addr·0x%"PRIx64"·scalable·%d"·"\n",

1649

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

1649

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

1650

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

1650

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

1651

·····················,·addr,·scalable);

1651

·····················,·addr,·scalable);

1652

#line·1654·"trace/trace-hw_i386.h"

1652

#line·1654·"trace/trace-hw_i386.h"

1653

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

1653

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

1655

············qemu_log("vtd_reg_dmar_root·"·"addr·0x%"PRIx64"·scalable·%d"·"\n",·addr,·scalable);

1655

············qemu_log("vtd_reg_dmar_root·"·"addr·0x%"PRIx64"·scalable·%d"·"\n",·addr,·scalable);

1656

#line·1658·"trace/trace-hw_i386.h"

1656

#line·1658·"trace/trace-hw_i386.h"

1657

········}

1657

········}

1658

····}

1658

····}

1659

}

1659

}

1660

static·inline·void·trace_vtd_reg_dmar_root(uint64_t·addr,·bool·scalable)

1660

static·inline·void·trace_vtd_reg_dmar_root(uint64_t·addr,·bool·scalable)

1672

static·inline·void·_nocheck__trace_vtd_reg_ir_root(uint64_t·addr,·uint32_t·size)

1672

static·inline·void·_nocheck__trace_vtd_reg_ir_root(uint64_t·addr,·uint32_t·size)

1673

{

1673

{

1674

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

1674

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

1675

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

1675

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

1676

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

1676

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

1677

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

1677

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

1679

············qemu_log("%d@%zu.%06zu:vtd_reg_ir_root·"·"addr·0x%"PRIx64"·size·0x%"PRIx32·"\n",

1679

············qemu_log("%d@%zu.%06zu:vtd_reg_ir_root·"·"addr·0x%"PRIx64"·size·0x%"PRIx32·"\n",

1680

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

1680

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

1681

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

1681

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

1682

·····················,·addr,·size);

1682

·····················,·addr,·size);

1683

#line·1685·"trace/trace-hw_i386.h"

1683

#line·1685·"trace/trace-hw_i386.h"

1684

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

1684

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

1686

············qemu_log("vtd_reg_ir_root·"·"addr·0x%"PRIx64"·size·0x%"PRIx32·"\n",·addr,·size);

1686

············qemu_log("vtd_reg_ir_root·"·"addr·0x%"PRIx64"·size·0x%"PRIx32·"\n",·addr,·size);

1687

#line·1689·"trace/trace-hw_i386.h"

1687

#line·1689·"trace/trace-hw_i386.h"

1688

········}

1688

········}

1689

····}

1689

····}

1690

}

1690

}

1691

static·inline·void·trace_vtd_reg_ir_root(uint64_t·addr,·uint32_t·size)

1691

static·inline·void·trace_vtd_reg_ir_root(uint64_t·addr,·uint32_t·size)

1703

static·inline·void·_nocheck__trace_vtd_reg_write_gcmd(uint32_t·status,·uint32_t·val)

1703

static·inline·void·_nocheck__trace_vtd_reg_write_gcmd(uint32_t·status,·uint32_t·val)

1704

{

1704

{

1705

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

1705

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

1706

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

1706

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

1707

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

1707

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

1708

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

1708

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

1710

············qemu_log("%d@%zu.%06zu:vtd_reg_write_gcmd·"·"status·0x%"PRIx32"·value·0x%"PRIx32·"\n",

1710

············qemu_log("%d@%zu.%06zu:vtd_reg_write_gcmd·"·"status·0x%"PRIx32"·value·0x%"PRIx32·"\n",

1711

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

1711

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

1712

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

1712

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

1713

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

1713

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

1714

#line·1716·"trace/trace-hw_i386.h"

1714

#line·1716·"trace/trace-hw_i386.h"

1715

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

1715

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

1717

············qemu_log("vtd_reg_write_gcmd·"·"status·0x%"PRIx32"·value·0x%"PRIx32·"\n",·status,·val);

1717

············qemu_log("vtd_reg_write_gcmd·"·"status·0x%"PRIx32"·value·0x%"PRIx32·"\n",·status,·val);

1718

#line·1720·"trace/trace-hw_i386.h"

1718

#line·1720·"trace/trace-hw_i386.h"

1719

········}

1719

········}

1720

····}

1720

····}

1721

}

1721

}

1722

static·inline·void·trace_vtd_reg_write_gcmd(uint32_t·status,·uint32_t·val)

1722

static·inline·void·trace_vtd_reg_write_gcmd(uint32_t·status,·uint32_t·val)

1734

static·inline·void·_nocheck__trace_vtd_reg_write_fectl(uint32_t·value)

1734

static·inline·void·_nocheck__trace_vtd_reg_write_fectl(uint32_t·value)

1735

{

1735

{

1736

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

1736

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

1737

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

1737

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

1738

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

1738

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

1739

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

1739

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

1741

············qemu_log("%d@%zu.%06zu:vtd_reg_write_fectl·"·"value·0x%"PRIx32·"\n",

1741

············qemu_log("%d@%zu.%06zu:vtd_reg_write_fectl·"·"value·0x%"PRIx32·"\n",

1742

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

1742

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

1743

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

1743

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

1744

·····················,·value);

1744

·····················,·value);

1745

#line·1747·"trace/trace-hw_i386.h"

1745

#line·1747·"trace/trace-hw_i386.h"

1746

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

1746

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

1748

············qemu_log("vtd_reg_write_fectl·"·"value·0x%"PRIx32·"\n",·value);

1748

············qemu_log("vtd_reg_write_fectl·"·"value·0x%"PRIx32·"\n",·value);

1749

#line·1751·"trace/trace-hw_i386.h"

1749

#line·1751·"trace/trace-hw_i386.h"

1750

········}

1750

········}

1751

····}

1751

····}

1752

}

1752

}

1753

static·inline·void·trace_vtd_reg_write_fectl(uint32_t·value)

1753

static·inline·void·trace_vtd_reg_write_fectl(uint32_t·value)

1765

static·inline·void·_nocheck__trace_vtd_reg_write_iectl(uint32_t·value)

1765

static·inline·void·_nocheck__trace_vtd_reg_write_iectl(uint32_t·value)

1766

{

1766

{

1767

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

1767

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

1768

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

1768

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

1769

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

1769

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

1770

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

1770

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

1772

············qemu_log("%d@%zu.%06zu:vtd_reg_write_iectl·"·"value·0x%"PRIx32·"\n",

1772

············qemu_log("%d@%zu.%06zu:vtd_reg_write_iectl·"·"value·0x%"PRIx32·"\n",

1773

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

1773

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

1774

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

1774

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

1775

·····················,·value);

1775

·····················,·value);

1776

#line·1778·"trace/trace-hw_i386.h"

1776

#line·1778·"trace/trace-hw_i386.h"

1777

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

1777

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

1779

············qemu_log("vtd_reg_write_iectl·"·"value·0x%"PRIx32·"\n",·value);

1779

············qemu_log("vtd_reg_write_iectl·"·"value·0x%"PRIx32·"\n",·value);

1780

#line·1782·"trace/trace-hw_i386.h"

1780

#line·1782·"trace/trace-hw_i386.h"

1781

········}

1781

········}

1782

····}

1782

····}

1783

}

1783

}

1784

static·inline·void·trace_vtd_reg_write_iectl(uint32_t·value)

1784

static·inline·void·trace_vtd_reg_write_iectl(uint32_t·value)

1796

static·inline·void·_nocheck__trace_vtd_reg_ics_clear_ip(void)

1796

static·inline·void·_nocheck__trace_vtd_reg_ics_clear_ip(void)

1797

{

1797

{

1798

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

1798

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

1799

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

1799

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

1800

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

1800

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

1801

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

1801

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

1803

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

1803

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

1804

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

1804

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

1805

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

1805

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

1806

·····················);

1806

·····················);

1807

#line·1809·"trace/trace-hw_i386.h"

1807

#line·1809·"trace/trace-hw_i386.h"

1808

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

1808

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

1810

············qemu_log("vtd_reg_ics_clear_ip·"·""·"\n");

1810

············qemu_log("vtd_reg_ics_clear_ip·"·""·"\n");

1811

#line·1813·"trace/trace-hw_i386.h"

1811

#line·1813·"trace/trace-hw_i386.h"

1812

········}

1812

········}

1813

····}

1813

····}

1814

}

1814

}

1815

static·inline·void·trace_vtd_reg_ics_clear_ip(void)

1815

static·inline·void·trace_vtd_reg_ics_clear_ip(void)

1827

static·inline·void·_nocheck__trace_vtd_dmar_translate(uint8_t·bus,·uint8_t·slot,·uint8_t·func,·uint64_t·iova,·uint64_t·gpa,·uint64_t·mask)

1827

static·inline·void·_nocheck__trace_vtd_dmar_translate(uint8_t·bus,·uint8_t·slot,·uint8_t·func,·uint64_t·iova,·uint64_t·gpa,·uint64_t·mask)

1828

{

1828

{

1829

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

1829

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

1830

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

1830

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

1831

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

1831

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

1832

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

1832

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

1834

············qemu_log("%d@%zu.%06zu:vtd_dmar_translate·"·"dev·%02x:%02x.%02x·iova·0x%"PRIx64"·->·gpa·0x%"PRIx64"·mask·0x%"PRIx64·"\n",

1834

············qemu_log("%d@%zu.%06zu:vtd_dmar_translate·"·"dev·%02x:%02x.%02x·iova·0x%"PRIx64"·->·gpa·0x%"PRIx64"·mask·0x%"PRIx64·"\n",

1835

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

1835

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

1836

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

1836

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

1837

·····················,·bus,·slot,·func,·iova,·gpa,·mask);

1837

·····················,·bus,·slot,·func,·iova,·gpa,·mask);

1838

#line·1840·"trace/trace-hw_i386.h"

1838

#line·1840·"trace/trace-hw_i386.h"

1839

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

1839

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

1841

············qemu_log("vtd_dmar_translate·"·"dev·%02x:%02x.%02x·iova·0x%"PRIx64"·->·gpa·0x%"PRIx64"·mask·0x%"PRIx64·"\n",·bus,·slot,·func,·iova,·gpa,·mask);

1841

············qemu_log("vtd_dmar_translate·"·"dev·%02x:%02x.%02x·iova·0x%"PRIx64"·->·gpa·0x%"PRIx64"·mask·0x%"PRIx64·"\n",·bus,·slot,·func,·iova,·gpa,·mask);

1842

#line·1844·"trace/trace-hw_i386.h"

1842

#line·1844·"trace/trace-hw_i386.h"

1843

········}

1843

········}

1844

····}

1844

····}

1845

}

1845

}

1846

static·inline·void·trace_vtd_dmar_translate(uint8_t·bus,·uint8_t·slot,·uint8_t·func,·uint64_t·iova,·uint64_t·gpa,·uint64_t·mask)

1846

static·inline·void·trace_vtd_dmar_translate(uint8_t·bus,·uint8_t·slot,·uint8_t·func,·uint64_t·iova,·uint64_t·gpa,·uint64_t·mask)

1858

static·inline·void·_nocheck__trace_vtd_dmar_enable(bool·en)

1858

static·inline·void·_nocheck__trace_vtd_dmar_enable(bool·en)

1859

{

1859

{

1860

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

1860

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

1861

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

1861

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

1862

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

1862

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

1863

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

1863

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

1865

············qemu_log("%d@%zu.%06zu:vtd_dmar_enable·"·"enable·%d"·"\n",

1865

············qemu_log("%d@%zu.%06zu:vtd_dmar_enable·"·"enable·%d"·"\n",

1866

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

1866

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

1867

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

1867

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

1868

·····················,·en);

1868

·····················,·en);

1869

#line·1871·"trace/trace-hw_i386.h"

1869

#line·1871·"trace/trace-hw_i386.h"

1870

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

1870

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

1872

············qemu_log("vtd_dmar_enable·"·"enable·%d"·"\n",·en);

1872

············qemu_log("vtd_dmar_enable·"·"enable·%d"·"\n",·en);

1873

#line·1875·"trace/trace-hw_i386.h"

1873

#line·1875·"trace/trace-hw_i386.h"

1874

········}

1874

········}

1875

····}

1875

····}

1876

}

1876

}

1877

static·inline·void·trace_vtd_dmar_enable(bool·en)

1877

static·inline·void·trace_vtd_dmar_enable(bool·en)

1889

static·inline·void·_nocheck__trace_vtd_dmar_fault(uint16_t·sid,·int·fault,·uint64_t·addr,·bool·is_write)

1889

static·inline·void·_nocheck__trace_vtd_dmar_fault(uint16_t·sid,·int·fault,·uint64_t·addr,·bool·is_write)

1890

{

1890

{

1891

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

1891

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

1892

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

1892

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

1893

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

1893

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

1894

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

1894

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

1896

············qemu_log("%d@%zu.%06zu:vtd_dmar_fault·"·"sid·0x%"PRIx16"·fault·%d·addr·0x%"PRIx64"·write·%d"·"\n",

1896

············qemu_log("%d@%zu.%06zu:vtd_dmar_fault·"·"sid·0x%"PRIx16"·fault·%d·addr·0x%"PRIx64"·write·%d"·"\n",

1897

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

1897

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

1898

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

1898

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

1899

·····················,·sid,·fault,·addr,·is_write);

1899

·····················,·sid,·fault,·addr,·is_write);

1900

#line·1902·"trace/trace-hw_i386.h"

1900

#line·1902·"trace/trace-hw_i386.h"

1901

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

1901

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

1903

············qemu_log("vtd_dmar_fault·"·"sid·0x%"PRIx16"·fault·%d·addr·0x%"PRIx64"·write·%d"·"\n",·sid,·fault,·addr,·is_write);

1903

············qemu_log("vtd_dmar_fault·"·"sid·0x%"PRIx16"·fault·%d·addr·0x%"PRIx64"·write·%d"·"\n",·sid,·fault,·addr,·is_write);

1904

#line·1906·"trace/trace-hw_i386.h"

1904

#line·1906·"trace/trace-hw_i386.h"

1905

········}

1905

········}

1906

····}

1906

····}

1907

}

1907

}

1908

static·inline·void·trace_vtd_dmar_fault(uint16_t·sid,·int·fault,·uint64_t·addr,·bool·is_write)

1908

static·inline·void·trace_vtd_dmar_fault(uint16_t·sid,·int·fault,·uint64_t·addr,·bool·is_write)

1920

static·inline·void·_nocheck__trace_vtd_ir_enable(bool·en)

1920

static·inline·void·_nocheck__trace_vtd_ir_enable(bool·en)

1921

{

1921

{

1922

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

1922

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

1923

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

1923

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

1924

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

1924

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

1925

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

1925

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

1927

············qemu_log("%d@%zu.%06zu:vtd_ir_enable·"·"enable·%d"·"\n",

1927

············qemu_log("%d@%zu.%06zu:vtd_ir_enable·"·"enable·%d"·"\n",

1928

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

1928

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

1929

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

1929

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

1930

·····················,·en);

1930

·····················,·en);

1931

#line·1933·"trace/trace-hw_i386.h"

1931

#line·1933·"trace/trace-hw_i386.h"

1932

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

1932

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

1934

············qemu_log("vtd_ir_enable·"·"enable·%d"·"\n",·en);

1934

············qemu_log("vtd_ir_enable·"·"enable·%d"·"\n",·en);

1935

#line·1937·"trace/trace-hw_i386.h"

1935

#line·1937·"trace/trace-hw_i386.h"

1936

········}

1936

········}

1937

····}

1937

····}

1938

}

1938

}

1939

static·inline·void·trace_vtd_ir_enable(bool·en)

1939

static·inline·void·trace_vtd_ir_enable(bool·en)

1951

static·inline·void·_nocheck__trace_vtd_ir_irte_get(int·index,·uint64_t·lo,·uint64_t·hi)

1951

static·inline·void·_nocheck__trace_vtd_ir_irte_get(int·index,·uint64_t·lo,·uint64_t·hi)

1952

{

1952

{

1953

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

1953

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

1954

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

1954

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

1955

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

1955

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

1956

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

1956

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

1958

············qemu_log("%d@%zu.%06zu:vtd_ir_irte_get·"·"index·%d·low·0x%"PRIx64"·high·0x%"PRIx64·"\n",

1958

············qemu_log("%d@%zu.%06zu:vtd_ir_irte_get·"·"index·%d·low·0x%"PRIx64"·high·0x%"PRIx64·"\n",

1959

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

1959

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

1960

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

1960

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

1961

·····················,·index,·lo,·hi);

1961

·····················,·index,·lo,·hi);

1962

#line·1964·"trace/trace-hw_i386.h"

1962

#line·1964·"trace/trace-hw_i386.h"

1963

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

1963

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

1965

············qemu_log("vtd_ir_irte_get·"·"index·%d·low·0x%"PRIx64"·high·0x%"PRIx64·"\n",·index,·lo,·hi);

1965

············qemu_log("vtd_ir_irte_get·"·"index·%d·low·0x%"PRIx64"·high·0x%"PRIx64·"\n",·index,·lo,·hi);

1966

#line·1968·"trace/trace-hw_i386.h"

1966

#line·1968·"trace/trace-hw_i386.h"

1967

········}

1967

········}

1968

····}

1968

····}

1969

}

1969

}

1970

static·inline·void·trace_vtd_ir_irte_get(int·index,·uint64_t·lo,·uint64_t·hi)

1970

static·inline·void·trace_vtd_ir_irte_get(int·index,·uint64_t·lo,·uint64_t·hi)

1982

static·inline·void·_nocheck__trace_vtd_ir_remap(int·index,·int·tri,·int·vec,·int·deliver,·uint32_t·dest,·int·dest_mode)

1982

static·inline·void·_nocheck__trace_vtd_ir_remap(int·index,·int·tri,·int·vec,·int·deliver,·uint32_t·dest,·int·dest_mode)

1983

{

1983

{

1984

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

1984

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

1985

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

1985

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

1986

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

1986

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

1987

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

1987

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

1989

············qemu_log("%d@%zu.%06zu:vtd_ir_remap·"·"index·%d·trigger·%d·vector·%d·deliver·%d·dest·0x%"PRIx32"·mode·%d"·"\n",

1989

············qemu_log("%d@%zu.%06zu:vtd_ir_remap·"·"index·%d·trigger·%d·vector·%d·deliver·%d·dest·0x%"PRIx32"·mode·%d"·"\n",

1990

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

1990

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

1991

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

1991

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

1992

·····················,·index,·tri,·vec,·deliver,·dest,·dest_mode);

1992

·····················,·index,·tri,·vec,·deliver,·dest,·dest_mode);

1993

#line·1995·"trace/trace-hw_i386.h"

1993

#line·1995·"trace/trace-hw_i386.h"

1994

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

1994

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

1996

············qemu_log("vtd_ir_remap·"·"index·%d·trigger·%d·vector·%d·deliver·%d·dest·0x%"PRIx32"·mode·%d"·"\n",·index,·tri,·vec,·deliver,·dest,·dest_mode);

1996

············qemu_log("vtd_ir_remap·"·"index·%d·trigger·%d·vector·%d·deliver·%d·dest·0x%"PRIx32"·mode·%d"·"\n",·index,·tri,·vec,·deliver,·dest,·dest_mode);

1997

#line·1999·"trace/trace-hw_i386.h"

1997

#line·1999·"trace/trace-hw_i386.h"

1998

········}

1998

········}

1999

····}

1999

····}

2000

}

2000

}

2001

static·inline·void·trace_vtd_ir_remap(int·index,·int·tri,·int·vec,·int·deliver,·uint32_t·dest,·int·dest_mode)

2001

static·inline·void·trace_vtd_ir_remap(int·index,·int·tri,·int·vec,·int·deliver,·uint32_t·dest,·int·dest_mode)

2013

static·inline·void·_nocheck__trace_vtd_ir_remap_type(const·char·*·type)

2013

static·inline·void·_nocheck__trace_vtd_ir_remap_type(const·char·*·type)

2014

{

2014

{

2015

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

2015

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

2016

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

2016

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

2017

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

2017

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

2018

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

2018

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

2020

············qemu_log("%d@%zu.%06zu:vtd_ir_remap_type·"·"%s"·"\n",

2020

············qemu_log("%d@%zu.%06zu:vtd_ir_remap_type·"·"%s"·"\n",

2021

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

2021

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

2022

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

2022

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

2023

·····················,·type);

2023

·····················,·type);

2024

#line·2026·"trace/trace-hw_i386.h"

2024

#line·2026·"trace/trace-hw_i386.h"

2025

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

2025

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

2027

············qemu_log("vtd_ir_remap_type·"·"%s"·"\n",·type);

2027

············qemu_log("vtd_ir_remap_type·"·"%s"·"\n",·type);

2028

#line·2030·"trace/trace-hw_i386.h"

2028

#line·2030·"trace/trace-hw_i386.h"

2029

········}

2029

········}

2030

····}

2030

····}

2031

}

2031

}

2032

static·inline·void·trace_vtd_ir_remap_type(const·char·*·type)

2032

static·inline·void·trace_vtd_ir_remap_type(const·char·*·type)

2044

static·inline·void·_nocheck__trace_vtd_ir_remap_msi(uint64_t·addr,·uint64_t·data,·uint64_t·addr2,·uint64_t·data2)

2044

static·inline·void·_nocheck__trace_vtd_ir_remap_msi(uint64_t·addr,·uint64_t·data,·uint64_t·addr2,·uint64_t·data2)

2045

{

2045

{

2046

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

2046

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

2047

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

2047

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

2048

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

2048

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

2049

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

2049

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

2051

············qemu_log("%d@%zu.%06zu:vtd_ir_remap_msi·"·"(addr·0x%"PRIx64",·data·0x%"PRIx64")·->·(addr·0x%"PRIx64",·data·0x%"PRIx64")"·"\n",

2051

············qemu_log("%d@%zu.%06zu:vtd_ir_remap_msi·"·"(addr·0x%"PRIx64",·data·0x%"PRIx64")·->·(addr·0x%"PRIx64",·data·0x%"PRIx64")"·"\n",

2052

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

2052

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

2053

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

2053

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

2054

·····················,·addr,·data,·addr2,·data2);

2054

·····················,·addr,·data,·addr2,·data2);

2055

#line·2057·"trace/trace-hw_i386.h"

2055

#line·2057·"trace/trace-hw_i386.h"

2056

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

2056

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

2058

············qemu_log("vtd_ir_remap_msi·"·"(addr·0x%"PRIx64",·data·0x%"PRIx64")·->·(addr·0x%"PRIx64",·data·0x%"PRIx64")"·"\n",·addr,·data,·addr2,·data2);

2058

············qemu_log("vtd_ir_remap_msi·"·"(addr·0x%"PRIx64",·data·0x%"PRIx64")·->·(addr·0x%"PRIx64",·data·0x%"PRIx64")"·"\n",·addr,·data,·addr2,·data2);

2059

#line·2061·"trace/trace-hw_i386.h"

2059

#line·2061·"trace/trace-hw_i386.h"

2060

········}

2060

········}

2061

····}

2061

····}

2062

}

2062

}

2063

static·inline·void·trace_vtd_ir_remap_msi(uint64_t·addr,·uint64_t·data,·uint64_t·addr2,·uint64_t·data2)

2063

static·inline·void·trace_vtd_ir_remap_msi(uint64_t·addr,·uint64_t·data,·uint64_t·addr2,·uint64_t·data2)

2075

static·inline·void·_nocheck__trace_vtd_ir_remap_msi_req(uint64_t·addr,·uint64_t·data)

2075

static·inline·void·_nocheck__trace_vtd_ir_remap_msi_req(uint64_t·addr,·uint64_t·data)

2076

{

2076

{

2077

····if·(trace_event_get_state(TRACE_VTD_IR_REMAP_MSI_REQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2077

····if·(trace_event_get_state(TRACE_VTD_IR_REMAP_MSI_REQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2078

········if·(message_with_timestamp)·{

2078

········if·(message_with_timestamp)·{

2079

············struct·timeval·_now;

2079

············struct·timeval·_now;

2080

············gettimeofday(&_now,·NULL);

2080

············gettimeofday(&_now,·NULL);

2082

············qemu_log("%d@%zu.%06zu:vtd_ir_remap_msi_req·"·"addr·0x%"PRIx64"·data·0x%"PRIx64·"\n",

2082

············qemu_log("%d@%zu.%06zu:vtd_ir_remap_msi_req·"·"addr·0x%"PRIx64"·data·0x%"PRIx64·"\n",

2083

·····················qemu_get_thread_id(),

2083

·····················qemu_get_thread_id(),

2084

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2084

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2085

·····················,·addr,·data);

2085

·····················,·addr,·data);

2086

#line·2088·"trace/trace-hw_i386.h"

2086

#line·2088·"trace/trace-hw_i386.h"

2087

········}·else·{

2087

········}·else·{

2089

············qemu_log("vtd_ir_remap_msi_req·"·"addr·0x%"PRIx64"·data·0x%"PRIx64·"\n",·addr,·data);

2089

············qemu_log("vtd_ir_remap_msi_req·"·"addr·0x%"PRIx64"·data·0x%"PRIx64·"\n",·addr,·data);

2090

#line·2092·"trace/trace-hw_i386.h"

2090

#line·2092·"trace/trace-hw_i386.h"

2091

········}

2091

········}

2092

····}

2092

····}

2093

}

2093

}

2094

static·inline·void·trace_vtd_ir_remap_msi_req(uint64_t·addr,·uint64_t·data)

2094

static·inline·void·trace_vtd_ir_remap_msi_req(uint64_t·addr,·uint64_t·data)

2106

static·inline·void·_nocheck__trace_vtd_fsts_ppf(bool·set)

2106

static·inline·void·_nocheck__trace_vtd_fsts_ppf(bool·set)

2107

{

2107

{

2108

····if·(trace_event_get_state(TRACE_VTD_FSTS_PPF)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2108

····if·(trace_event_get_state(TRACE_VTD_FSTS_PPF)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2109

········if·(message_with_timestamp)·{

2109

········if·(message_with_timestamp)·{

2110

············struct·timeval·_now;

2110

············struct·timeval·_now;

2111

············gettimeofday(&_now,·NULL);

2111

············gettimeofday(&_now,·NULL);

2113

············qemu_log("%d@%zu.%06zu:vtd_fsts_ppf·"·"FSTS·PPF·bit·set·to·%d"·"\n",

2113

············qemu_log("%d@%zu.%06zu:vtd_fsts_ppf·"·"FSTS·PPF·bit·set·to·%d"·"\n",

2114

·····················qemu_get_thread_id(),

2114

·····················qemu_get_thread_id(),

2115

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2115

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2116

·····················,·set);

2116

·····················,·set);

2117

#line·2119·"trace/trace-hw_i386.h"

2117

#line·2119·"trace/trace-hw_i386.h"

2118

········}·else·{

2118

········}·else·{

2120

············qemu_log("vtd_fsts_ppf·"·"FSTS·PPF·bit·set·to·%d"·"\n",·set);

2120

············qemu_log("vtd_fsts_ppf·"·"FSTS·PPF·bit·set·to·%d"·"\n",·set);

2121

#line·2123·"trace/trace-hw_i386.h"

2121

#line·2123·"trace/trace-hw_i386.h"

2122

········}

2122

········}

2123

····}

2123

····}

2124

}

2124

}

2125

static·inline·void·trace_vtd_fsts_ppf(bool·set)

2125

static·inline·void·trace_vtd_fsts_ppf(bool·set)

2137

static·inline·void·_nocheck__trace_vtd_fsts_clear_ip(void)

2137

static·inline·void·_nocheck__trace_vtd_fsts_clear_ip(void)

2138

{

2138

{

2139

····if·(trace_event_get_state(TRACE_VTD_FSTS_CLEAR_IP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2139

····if·(trace_event_get_state(TRACE_VTD_FSTS_CLEAR_IP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2140

········if·(message_with_timestamp)·{

2140

········if·(message_with_timestamp)·{

2141

············struct·timeval·_now;

2141

············struct·timeval·_now;

2142

············gettimeofday(&_now,·NULL);

2142

············gettimeofday(&_now,·NULL);

2144

············qemu_log("%d@%zu.%06zu:vtd_fsts_clear_ip·"·""·"\n",

2144

············qemu_log("%d@%zu.%06zu:vtd_fsts_clear_ip·"·""·"\n",

2145

·····················qemu_get_thread_id(),

2145

·····················qemu_get_thread_id(),

2146

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2146

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2147

·····················);

2147

·····················);

2148

#line·2150·"trace/trace-hw_i386.h"

2148

#line·2150·"trace/trace-hw_i386.h"

2149

········}·else·{

2149

········}·else·{

2151

············qemu_log("vtd_fsts_clear_ip·"·""·"\n");

2151

············qemu_log("vtd_fsts_clear_ip·"·""·"\n");

2152

#line·2154·"trace/trace-hw_i386.h"

2152

#line·2154·"trace/trace-hw_i386.h"

2153

········}

2153

········}

2154

····}

2154

····}

2155

}

2155

}

2156

static·inline·void·trace_vtd_fsts_clear_ip(void)

2156

static·inline·void·trace_vtd_fsts_clear_ip(void)

2168

static·inline·void·_nocheck__trace_vtd_frr_new(int·index,·uint64_t·hi,·uint64_t·lo)

2168

static·inline·void·_nocheck__trace_vtd_frr_new(int·index,·uint64_t·hi,·uint64_t·lo)

2169

{

2169

{

2170

····if·(trace_event_get_state(TRACE_VTD_FRR_NEW)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2170

····if·(trace_event_get_state(TRACE_VTD_FRR_NEW)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2171

········if·(message_with_timestamp)·{

2171

········if·(message_with_timestamp)·{

2172

············struct·timeval·_now;

2172

············struct·timeval·_now;

2173

············gettimeofday(&_now,·NULL);

2173

············gettimeofday(&_now,·NULL);

2175

············qemu_log("%d@%zu.%06zu:vtd_frr_new·"·"index·%d·high·0x%"PRIx64"·low·0x%"PRIx64·"\n",

2175

············qemu_log("%d@%zu.%06zu:vtd_frr_new·"·"index·%d·high·0x%"PRIx64"·low·0x%"PRIx64·"\n",

2176

·····················qemu_get_thread_id(),

2176

·····················qemu_get_thread_id(),

2177

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2177

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2178

·····················,·index,·hi,·lo);

2178

·····················,·index,·hi,·lo);

2179

#line·2181·"trace/trace-hw_i386.h"

2179

#line·2181·"trace/trace-hw_i386.h"

2180

········}·else·{

2180

········}·else·{

2182

············qemu_log("vtd_frr_new·"·"index·%d·high·0x%"PRIx64"·low·0x%"PRIx64·"\n",·index,·hi,·lo);

2182

············qemu_log("vtd_frr_new·"·"index·%d·high·0x%"PRIx64"·low·0x%"PRIx64·"\n",·index,·hi,·lo);

2183

#line·2185·"trace/trace-hw_i386.h"

2183

#line·2185·"trace/trace-hw_i386.h"

2184

········}

2184

········}

2185

····}

2185

····}

2186

}

2186

}

2187

static·inline·void·trace_vtd_frr_new(int·index,·uint64_t·hi,·uint64_t·lo)

2187

static·inline·void·trace_vtd_frr_new(int·index,·uint64_t·hi,·uint64_t·lo)

2199

static·inline·void·_nocheck__trace_vtd_warn_invalid_qi_tail(uint16_t·tail)

2199

static·inline·void·_nocheck__trace_vtd_warn_invalid_qi_tail(uint16_t·tail)

2200

{

2200

{

2201

····if·(trace_event_get_state(TRACE_VTD_WARN_INVALID_QI_TAIL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2201

····if·(trace_event_get_state(TRACE_VTD_WARN_INVALID_QI_TAIL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2202

········if·(message_with_timestamp)·{

2202

········if·(message_with_timestamp)·{

2203

············struct·timeval·_now;

2203

············struct·timeval·_now;

2204

············gettimeofday(&_now,·NULL);

2204

············gettimeofday(&_now,·NULL);

2206

············qemu_log("%d@%zu.%06zu:vtd_warn_invalid_qi_tail·"·"tail·0x%"PRIx16·"\n",

2206

············qemu_log("%d@%zu.%06zu:vtd_warn_invalid_qi_tail·"·"tail·0x%"PRIx16·"\n",

2207

·····················qemu_get_thread_id(),

2207

·····················qemu_get_thread_id(),

2208

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2208

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2209

·····················,·tail);

2209

·····················,·tail);

2210

#line·2212·"trace/trace-hw_i386.h"

2210

#line·2212·"trace/trace-hw_i386.h"

2211

········}·else·{

2211

········}·else·{

2213

············qemu_log("vtd_warn_invalid_qi_tail·"·"tail·0x%"PRIx16·"\n",·tail);

2213

············qemu_log("vtd_warn_invalid_qi_tail·"·"tail·0x%"PRIx16·"\n",·tail);

2214

#line·2216·"trace/trace-hw_i386.h"

2214

#line·2216·"trace/trace-hw_i386.h"

2215

········}

2215

········}

2216

····}

2216

····}

2217

}

2217

}

2218

static·inline·void·trace_vtd_warn_invalid_qi_tail(uint16_t·tail)

2218

static·inline·void·trace_vtd_warn_invalid_qi_tail(uint16_t·tail)

2230

static·inline·void·_nocheck__trace_vtd_warn_ir_vector(uint16_t·sid,·int·index,·int·vec,·int·target)

2230

static·inline·void·_nocheck__trace_vtd_warn_ir_vector(uint16_t·sid,·int·index,·int·vec,·int·target)

2231

{

2231

{

2232

····if·(trace_event_get_state(TRACE_VTD_WARN_IR_VECTOR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2232

····if·(trace_event_get_state(TRACE_VTD_WARN_IR_VECTOR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2233

········if·(message_with_timestamp)·{

2233

········if·(message_with_timestamp)·{

2234

············struct·timeval·_now;

2234

············struct·timeval·_now;

2235

············gettimeofday(&_now,·NULL);

2235

············gettimeofday(&_now,·NULL);

2237

············qemu_log("%d@%zu.%06zu:vtd_warn_ir_vector·"·"sid·0x%"PRIx16"·index·%d·vec·%d·(should·be:·%d)"·"\n",

2237

············qemu_log("%d@%zu.%06zu:vtd_warn_ir_vector·"·"sid·0x%"PRIx16"·index·%d·vec·%d·(should·be:·%d)"·"\n",

2238

·····················qemu_get_thread_id(),

2238

·····················qemu_get_thread_id(),

2239

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2239

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2240

·····················,·sid,·index,·vec,·target);

2240

·····················,·sid,·index,·vec,·target);

2241

#line·2243·"trace/trace-hw_i386.h"

2241

#line·2243·"trace/trace-hw_i386.h"

2242

········}·else·{

2242

········}·else·{

2244

············qemu_log("vtd_warn_ir_vector·"·"sid·0x%"PRIx16"·index·%d·vec·%d·(should·be:·%d)"·"\n",·sid,·index,·vec,·target);

2244

············qemu_log("vtd_warn_ir_vector·"·"sid·0x%"PRIx16"·index·%d·vec·%d·(should·be:·%d)"·"\n",·sid,·index,·vec,·target);

2245

#line·2247·"trace/trace-hw_i386.h"

2245

#line·2247·"trace/trace-hw_i386.h"

2246

········}

2246

········}

2247

····}

2247

····}

2248

}

2248

}

2249

static·inline·void·trace_vtd_warn_ir_vector(uint16_t·sid,·int·index,·int·vec,·int·target)

2249

static·inline·void·trace_vtd_warn_ir_vector(uint16_t·sid,·int·index,·int·vec,·int·target)

2261

static·inline·void·_nocheck__trace_vtd_warn_ir_trigger(uint16_t·sid,·int·index,·int·trig,·int·target)

2261

static·inline·void·_nocheck__trace_vtd_warn_ir_trigger(uint16_t·sid,·int·index,·int·trig,·int·target)

2262

{

2262

{

2263

····if·(trace_event_get_state(TRACE_VTD_WARN_IR_TRIGGER)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2263

····if·(trace_event_get_state(TRACE_VTD_WARN_IR_TRIGGER)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2264

········if·(message_with_timestamp)·{

2264

········if·(message_with_timestamp)·{

2265

············struct·timeval·_now;

2265

············struct·timeval·_now;

2266

············gettimeofday(&_now,·NULL);

2266

············gettimeofday(&_now,·NULL);

2268

············qemu_log("%d@%zu.%06zu:vtd_warn_ir_trigger·"·"sid·0x%"PRIx16"·index·%d·trigger·%d·(should·be:·%d)"·"\n",

2268

············qemu_log("%d@%zu.%06zu:vtd_warn_ir_trigger·"·"sid·0x%"PRIx16"·index·%d·trigger·%d·(should·be:·%d)"·"\n",

2269

·····················qemu_get_thread_id(),

2269

·····················qemu_get_thread_id(),

2270

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2270

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2271

·····················,·sid,·index,·trig,·target);

2271

·····················,·sid,·index,·trig,·target);

2272

#line·2274·"trace/trace-hw_i386.h"

2272

#line·2274·"trace/trace-hw_i386.h"

2273

········}·else·{

2273

········}·else·{

2275

············qemu_log("vtd_warn_ir_trigger·"·"sid·0x%"PRIx16"·index·%d·trigger·%d·(should·be:·%d)"·"\n",·sid,·index,·trig,·target);

2275

············qemu_log("vtd_warn_ir_trigger·"·"sid·0x%"PRIx16"·index·%d·trigger·%d·(should·be:·%d)"·"\n",·sid,·index,·trig,·target);

2276

#line·2278·"trace/trace-hw_i386.h"

2276

#line·2278·"trace/trace-hw_i386.h"

2277

········}

2277

········}

2278

····}

2278

····}

2279

}

2279

}

2280

static·inline·void·trace_vtd_warn_ir_trigger(uint16_t·sid,·int·index,·int·trig,·int·target)

2280

static·inline·void·trace_vtd_warn_ir_trigger(uint16_t·sid,·int·index,·int·trig,·int·target)

2292

static·inline·void·_nocheck__trace_amdvi_evntlog_fail(uint64_t·addr,·uint32_t·head)

2292

static·inline·void·_nocheck__trace_amdvi_evntlog_fail(uint64_t·addr,·uint32_t·head)

2293

{

2293

{

2294

····if·(trace_event_get_state(TRACE_AMDVI_EVNTLOG_FAIL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2294

····if·(trace_event_get_state(TRACE_AMDVI_EVNTLOG_FAIL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2295

········if·(message_with_timestamp)·{

2295

········if·(message_with_timestamp)·{

2296

············struct·timeval·_now;

2296

············struct·timeval·_now;

2297

············gettimeofday(&_now,·NULL);

2297

············gettimeofday(&_now,·NULL);

2299

············qemu_log("%d@%zu.%06zu:amdvi_evntlog_fail·"·"error:·fail·to·write·at·addr·0x%"PRIx64"·+··offset·0x%"PRIx32·"\n",

2299

············qemu_log("%d@%zu.%06zu:amdvi_evntlog_fail·"·"error:·fail·to·write·at·addr·0x%"PRIx64"·+··offset·0x%"PRIx32·"\n",

2300

·····················qemu_get_thread_id(),

2300

·····················qemu_get_thread_id(),

2301

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2301

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2302

·····················,·addr,·head);

2302

·····················,·addr,·head);

2303

#line·2305·"trace/trace-hw_i386.h"

2303

#line·2305·"trace/trace-hw_i386.h"

2304

········}·else·{

2304

········}·else·{

2306

············qemu_log("amdvi_evntlog_fail·"·"error:·fail·to·write·at·addr·0x%"PRIx64"·+··offset·0x%"PRIx32·"\n",·addr,·head);

2306

············qemu_log("amdvi_evntlog_fail·"·"error:·fail·to·write·at·addr·0x%"PRIx64"·+··offset·0x%"PRIx32·"\n",·addr,·head);

2307

#line·2309·"trace/trace-hw_i386.h"

2307

#line·2309·"trace/trace-hw_i386.h"

2308

········}

2308

········}

2309

····}

2309

····}

2310

}

2310

}

2311

static·inline·void·trace_amdvi_evntlog_fail(uint64_t·addr,·uint32_t·head)

2311

static·inline·void·trace_amdvi_evntlog_fail(uint64_t·addr,·uint32_t·head)

2323

static·inline·void·_nocheck__trace_amdvi_cache_update(uint16_t·domid,·uint8_t·bus,·uint8_t·slot,·uint8_t·func,·uint64_t·gpa,·uint64_t·txaddr)

2323

static·inline·void·_nocheck__trace_amdvi_cache_update(uint16_t·domid,·uint8_t·bus,·uint8_t·slot,·uint8_t·func,·uint64_t·gpa,·uint64_t·txaddr)

2324

{

2324

{

2325

····if·(trace_event_get_state(TRACE_AMDVI_CACHE_UPDATE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2325

····if·(trace_event_get_state(TRACE_AMDVI_CACHE_UPDATE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2326

········if·(message_with_timestamp)·{

2326

········if·(message_with_timestamp)·{

2327

············struct·timeval·_now;

2327

············struct·timeval·_now;

2328

············gettimeofday(&_now,·NULL);

2328

············gettimeofday(&_now,·NULL);

2330

············qemu_log("%d@%zu.%06zu:amdvi_cache_update·"·"·update·iotlb·domid·0x%"PRIx16"·devid:·%02x:%02x.%x·gpa·0x%"PRIx64"·hpa·0x%"PRIx64·"\n",

2330

············qemu_log("%d@%zu.%06zu:amdvi_cache_update·"·"·update·iotlb·domid·0x%"PRIx16"·devid:·%02x:%02x.%x·gpa·0x%"PRIx64"·hpa·0x%"PRIx64·"\n",

2331

·····················qemu_get_thread_id(),

2331

·····················qemu_get_thread_id(),

2332

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2332

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2333

·····················,·domid,·bus,·slot,·func,·gpa,·txaddr);

2333

·····················,·domid,·bus,·slot,·func,·gpa,·txaddr);

2334

#line·2336·"trace/trace-hw_i386.h"

2334

#line·2336·"trace/trace-hw_i386.h"

2335

········}·else·{

2335

········}·else·{

2337

············qemu_log("amdvi_cache_update·"·"·update·iotlb·domid·0x%"PRIx16"·devid:·%02x:%02x.%x·gpa·0x%"PRIx64"·hpa·0x%"PRIx64·"\n",·domid,·bus,·slot,·func,·gpa,·txaddr);

2337

············qemu_log("amdvi_cache_update·"·"·update·iotlb·domid·0x%"PRIx16"·devid:·%02x:%02x.%x·gpa·0x%"PRIx64"·hpa·0x%"PRIx64·"\n",·domid,·bus,·slot,·func,·gpa,·txaddr);

2338

#line·2340·"trace/trace-hw_i386.h"

2338

#line·2340·"trace/trace-hw_i386.h"

2339

········}

2339

········}

2340

····}

2340

····}

2341

}

2341

}

2342

static·inline·void·trace_amdvi_cache_update(uint16_t·domid,·uint8_t·bus,·uint8_t·slot,·uint8_t·func,·uint64_t·gpa,·uint64_t·txaddr)

2342

static·inline·void·trace_amdvi_cache_update(uint16_t·domid,·uint8_t·bus,·uint8_t·slot,·uint8_t·func,·uint64_t·gpa,·uint64_t·txaddr)

2354

static·inline·void·_nocheck__trace_amdvi_completion_wait_fail(uint64_t·addr)

2354

static·inline·void·_nocheck__trace_amdvi_completion_wait_fail(uint64_t·addr)

2355

{

2355

{

2356

····if·(trace_event_get_state(TRACE_AMDVI_COMPLETION_WAIT_FAIL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2356

····if·(trace_event_get_state(TRACE_AMDVI_COMPLETION_WAIT_FAIL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2357

········if·(message_with_timestamp)·{

2357

········if·(message_with_timestamp)·{

2358

············struct·timeval·_now;

2358

············struct·timeval·_now;

2359

············gettimeofday(&_now,·NULL);

2359

············gettimeofday(&_now,·NULL);

2361

············qemu_log("%d@%zu.%06zu:amdvi_completion_wait_fail·"·"error:·fail·to·write·at·address·0x%"PRIx64·"\n",

2361

············qemu_log("%d@%zu.%06zu:amdvi_completion_wait_fail·"·"error:·fail·to·write·at·address·0x%"PRIx64·"\n",

2362

·····················qemu_get_thread_id(),

2362

·····················qemu_get_thread_id(),

2363

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2363

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2364

·····················,·addr);

2364

·····················,·addr);

2365

#line·2367·"trace/trace-hw_i386.h"

2365

#line·2367·"trace/trace-hw_i386.h"

2366

········}·else·{

2366

········}·else·{

2368

············qemu_log("amdvi_completion_wait_fail·"·"error:·fail·to·write·at·address·0x%"PRIx64·"\n",·addr);

2368

············qemu_log("amdvi_completion_wait_fail·"·"error:·fail·to·write·at·address·0x%"PRIx64·"\n",·addr);

2369

#line·2371·"trace/trace-hw_i386.h"

2369

#line·2371·"trace/trace-hw_i386.h"

2370

········}

2370

········}

2371

····}

2371

····}

2372

}

2372

}

2373

static·inline·void·trace_amdvi_completion_wait_fail(uint64_t·addr)

2373

static·inline·void·trace_amdvi_completion_wait_fail(uint64_t·addr)

2385

static·inline·void·_nocheck__trace_amdvi_mmio_write(const·char·*·reg,·uint64_t·addr,·unsigned·size,·uint64_t·val,·uint64_t·offset)

2385

static·inline·void·_nocheck__trace_amdvi_mmio_write(const·char·*·reg,·uint64_t·addr,·unsigned·size,·uint64_t·val,·uint64_t·offset)

2386

{

2386

{

2387

····if·(trace_event_get_state(TRACE_AMDVI_MMIO_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2387

····if·(trace_event_get_state(TRACE_AMDVI_MMIO_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2388

········if·(message_with_timestamp)·{

2388

········if·(message_with_timestamp)·{

2389

············struct·timeval·_now;

2389

············struct·timeval·_now;

2390

············gettimeofday(&_now,·NULL);

2390

············gettimeofday(&_now,·NULL);

2392

············qemu_log("%d@%zu.%06zu:amdvi_mmio_write·"·"%s·write·addr·0x%"PRIx64",·size·%u,·val·0x%"PRIx64",·offset·0x%"PRIx64·"\n",

2392

············qemu_log("%d@%zu.%06zu:amdvi_mmio_write·"·"%s·write·addr·0x%"PRIx64",·size·%u,·val·0x%"PRIx64",·offset·0x%"PRIx64·"\n",

2393

·····················qemu_get_thread_id(),

2393

·····················qemu_get_thread_id(),

2394

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2394

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2395

·····················,·reg,·addr,·size,·val,·offset);

2395

·····················,·reg,·addr,·size,·val,·offset);

2396

#line·2398·"trace/trace-hw_i386.h"

2396

#line·2398·"trace/trace-hw_i386.h"

2397

········}·else·{

2397

········}·else·{

2399

············qemu_log("amdvi_mmio_write·"·"%s·write·addr·0x%"PRIx64",·size·%u,·val·0x%"PRIx64",·offset·0x%"PRIx64·"\n",·reg,·addr,·size,·val,·offset);

2399

············qemu_log("amdvi_mmio_write·"·"%s·write·addr·0x%"PRIx64",·size·%u,·val·0x%"PRIx64",·offset·0x%"PRIx64·"\n",·reg,·addr,·size,·val,·offset);

2400

#line·2402·"trace/trace-hw_i386.h"

2400

#line·2402·"trace/trace-hw_i386.h"

2401

········}

2401

········}

2402

····}

2402

····}

2403

}

2403

}

2404

static·inline·void·trace_amdvi_mmio_write(const·char·*·reg,·uint64_t·addr,·unsigned·size,·uint64_t·val,·uint64_t·offset)

2404

static·inline·void·trace_amdvi_mmio_write(const·char·*·reg,·uint64_t·addr,·unsigned·size,·uint64_t·val,·uint64_t·offset)

2416

static·inline·void·_nocheck__trace_amdvi_mmio_read(const·char·*·reg,·uint64_t·addr,·unsigned·size,·uint64_t·offset)

2416

static·inline·void·_nocheck__trace_amdvi_mmio_read(const·char·*·reg,·uint64_t·addr,·unsigned·size,·uint64_t·offset)

2417

{

2417

{

2418

····if·(trace_event_get_state(TRACE_AMDVI_MMIO_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2418

····if·(trace_event_get_state(TRACE_AMDVI_MMIO_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2419

········if·(message_with_timestamp)·{

2419

········if·(message_with_timestamp)·{

2420

············struct·timeval·_now;

2420

············struct·timeval·_now;

2421

············gettimeofday(&_now,·NULL);

2421

············gettimeofday(&_now,·NULL);

2423

············qemu_log("%d@%zu.%06zu:amdvi_mmio_read·"·"%s·read·addr·0x%"PRIx64",·size·%u·offset·0x%"PRIx64·"\n",

2423

············qemu_log("%d@%zu.%06zu:amdvi_mmio_read·"·"%s·read·addr·0x%"PRIx64",·size·%u·offset·0x%"PRIx64·"\n",

2424

·····················qemu_get_thread_id(),

2424

·····················qemu_get_thread_id(),

2425

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2425

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2426

·····················,·reg,·addr,·size,·offset);

2426

·····················,·reg,·addr,·size,·offset);

2427

#line·2429·"trace/trace-hw_i386.h"

2427

#line·2429·"trace/trace-hw_i386.h"

2428

········}·else·{

2428

········}·else·{

2430

············qemu_log("amdvi_mmio_read·"·"%s·read·addr·0x%"PRIx64",·size·%u·offset·0x%"PRIx64·"\n",·reg,·addr,·size,·offset);

2430

············qemu_log("amdvi_mmio_read·"·"%s·read·addr·0x%"PRIx64",·size·%u·offset·0x%"PRIx64·"\n",·reg,·addr,·size,·offset);

2431

#line·2433·"trace/trace-hw_i386.h"

2431

#line·2433·"trace/trace-hw_i386.h"

2432

········}

2432

········}

2433

····}

2433

····}

2434

}

2434

}

2435

static·inline·void·trace_amdvi_mmio_read(const·char·*·reg,·uint64_t·addr,·unsigned·size,·uint64_t·offset)

2435

static·inline·void·trace_amdvi_mmio_read(const·char·*·reg,·uint64_t·addr,·unsigned·size,·uint64_t·offset)

2447

static·inline·void·_nocheck__trace_amdvi_mmio_read_invalid(int·max,·uint64_t·addr,·unsigned·size)

2447

static·inline·void·_nocheck__trace_amdvi_mmio_read_invalid(int·max,·uint64_t·addr,·unsigned·size)

2448

{

2448

{

2449

····if·(trace_event_get_state(TRACE_AMDVI_MMIO_READ_INVALID)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2449

····if·(trace_event_get_state(TRACE_AMDVI_MMIO_READ_INVALID)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2450

········if·(message_with_timestamp)·{

2450

········if·(message_with_timestamp)·{

2451

············struct·timeval·_now;

2451

············struct·timeval·_now;

2452

············gettimeofday(&_now,·NULL);

2452

············gettimeofday(&_now,·NULL);

2454

············qemu_log("%d@%zu.%06zu:amdvi_mmio_read_invalid·"·"error:·addr·outside·region·(max·0x%x):·read·addr·0x%"·PRIx64·",·size·%u"·"\n",

2454

············qemu_log("%d@%zu.%06zu:amdvi_mmio_read_invalid·"·"error:·addr·outside·region·(max·0x%x):·read·addr·0x%"·PRIx64·",·size·%u"·"\n",

2455

·····················qemu_get_thread_id(),

2455

·····················qemu_get_thread_id(),

2456

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2456

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2457

·····················,·max,·addr,·size);

2457

·····················,·max,·addr,·size);

2458

#line·2460·"trace/trace-hw_i386.h"

2458

#line·2460·"trace/trace-hw_i386.h"

2459

········}·else·{

2459

········}·else·{

2461

············qemu_log("amdvi_mmio_read_invalid·"·"error:·addr·outside·region·(max·0x%x):·read·addr·0x%"·PRIx64·",·size·%u"·"\n",·max,·addr,·size);

2461

············qemu_log("amdvi_mmio_read_invalid·"·"error:·addr·outside·region·(max·0x%x):·read·addr·0x%"·PRIx64·",·size·%u"·"\n",·max,·addr,·size);

2462

#line·2464·"trace/trace-hw_i386.h"

2462

#line·2464·"trace/trace-hw_i386.h"

2463

········}

2463

········}

2464

····}

2464

····}

2465

}

2465

}

2466

static·inline·void·trace_amdvi_mmio_read_invalid(int·max,·uint64_t·addr,·unsigned·size)

2466

static·inline·void·trace_amdvi_mmio_read_invalid(int·max,·uint64_t·addr,·unsigned·size)

2478

static·inline·void·_nocheck__trace_amdvi_command_error(uint64_t·status)

2478

static·inline·void·_nocheck__trace_amdvi_command_error(uint64_t·status)

2479

{

2479

{

2480

····if·(trace_event_get_state(TRACE_AMDVI_COMMAND_ERROR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2480

····if·(trace_event_get_state(TRACE_AMDVI_COMMAND_ERROR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2481

········if·(message_with_timestamp)·{

2481

········if·(message_with_timestamp)·{

2482

············struct·timeval·_now;

2482

············struct·timeval·_now;

2483

············gettimeofday(&_now,·NULL);

2483

············gettimeofday(&_now,·NULL);

2485

············qemu_log("%d@%zu.%06zu:amdvi_command_error·"·"error:·Executing·commands·with·command·buffer·disabled·0x%"PRIx64·"\n",

2485

············qemu_log("%d@%zu.%06zu:amdvi_command_error·"·"error:·Executing·commands·with·command·buffer·disabled·0x%"PRIx64·"\n",

2486

·····················qemu_get_thread_id(),

2486

·····················qemu_get_thread_id(),

2487

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2487

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2488

·····················,·status);

2488

·····················,·status);

2489

#line·2491·"trace/trace-hw_i386.h"

2489

#line·2491·"trace/trace-hw_i386.h"

2490

········}·else·{

2490

········}·else·{

2492

············qemu_log("amdvi_command_error·"·"error:·Executing·commands·with·command·buffer·disabled·0x%"PRIx64·"\n",·status);

2492

············qemu_log("amdvi_command_error·"·"error:·Executing·commands·with·command·buffer·disabled·0x%"PRIx64·"\n",·status);

2493

#line·2495·"trace/trace-hw_i386.h"

2493

#line·2495·"trace/trace-hw_i386.h"

2494

········}

2494

········}

2495

····}

2495

····}

2496

}

2496

}

2497

static·inline·void·trace_amdvi_command_error(uint64_t·status)

2497

static·inline·void·trace_amdvi_command_error(uint64_t·status)

2509

static·inline·void·_nocheck__trace_amdvi_command_read_fail(uint64_t·addr,·uint32_t·head)

2509

static·inline·void·_nocheck__trace_amdvi_command_read_fail(uint64_t·addr,·uint32_t·head)

2510

{

2510

{

2511

····if·(trace_event_get_state(TRACE_AMDVI_COMMAND_READ_FAIL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2511

····if·(trace_event_get_state(TRACE_AMDVI_COMMAND_READ_FAIL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2512

········if·(message_with_timestamp)·{

2512

········if·(message_with_timestamp)·{

2513

············struct·timeval·_now;

2513

············struct·timeval·_now;

2514

············gettimeofday(&_now,·NULL);

2514

············gettimeofday(&_now,·NULL);

2516

············qemu_log("%d@%zu.%06zu:amdvi_command_read_fail·"·"error:·fail·to·access·memory·at·0x%"PRIx64"·+·0x%"PRIx32·"\n",

2516

············qemu_log("%d@%zu.%06zu:amdvi_command_read_fail·"·"error:·fail·to·access·memory·at·0x%"PRIx64"·+·0x%"PRIx32·"\n",

2517

·····················qemu_get_thread_id(),

2517

·····················qemu_get_thread_id(),

2518

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2518

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2519

·····················,·addr,·head);

2519

·····················,·addr,·head);

2520

#line·2522·"trace/trace-hw_i386.h"

2520

#line·2522·"trace/trace-hw_i386.h"

2521

········}·else·{

2521

········}·else·{

2523

············qemu_log("amdvi_command_read_fail·"·"error:·fail·to·access·memory·at·0x%"PRIx64"·+·0x%"PRIx32·"\n",·addr,·head);

2523

············qemu_log("amdvi_command_read_fail·"·"error:·fail·to·access·memory·at·0x%"PRIx64"·+·0x%"PRIx32·"\n",·addr,·head);

2524

#line·2526·"trace/trace-hw_i386.h"

2524

#line·2526·"trace/trace-hw_i386.h"

2525

········}

2525

········}

2526

····}

2526

····}

2527

}

2527

}

2528

static·inline·void·trace_amdvi_command_read_fail(uint64_t·addr,·uint32_t·head)

2528

static·inline·void·trace_amdvi_command_read_fail(uint64_t·addr,·uint32_t·head)

2540

static·inline·void·_nocheck__trace_amdvi_command_exec(uint32_t·head,·uint32_t·tail,·uint64_t·buf)

2540

static·inline·void·_nocheck__trace_amdvi_command_exec(uint32_t·head,·uint32_t·tail,·uint64_t·buf)

2541

{

2541

{

2542

····if·(trace_event_get_state(TRACE_AMDVI_COMMAND_EXEC)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2542

····if·(trace_event_get_state(TRACE_AMDVI_COMMAND_EXEC)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2543

········if·(message_with_timestamp)·{

2543

········if·(message_with_timestamp)·{

2544

············struct·timeval·_now;

2544

············struct·timeval·_now;

2545

············gettimeofday(&_now,·NULL);

2545

············gettimeofday(&_now,·NULL);

2547

············qemu_log("%d@%zu.%06zu:amdvi_command_exec·"·"command·buffer·head·at·0x%"PRIx32"·command·buffer·tail·at·0x%"PRIx32"·command·buffer·base·at·0x%"PRIx64·"\n",

2547

············qemu_log("%d@%zu.%06zu:amdvi_command_exec·"·"command·buffer·head·at·0x%"PRIx32"·command·buffer·tail·at·0x%"PRIx32"·command·buffer·base·at·0x%"PRIx64·"\n",

2548

·····················qemu_get_thread_id(),

2548

·····················qemu_get_thread_id(),

2549

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2549

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2550

·····················,·head,·tail,·buf);

2550

·····················,·head,·tail,·buf);

2551

#line·2553·"trace/trace-hw_i386.h"

2551

#line·2553·"trace/trace-hw_i386.h"

2552

········}·else·{

2552

········}·else·{

2554

············qemu_log("amdvi_command_exec·"·"command·buffer·head·at·0x%"PRIx32"·command·buffer·tail·at·0x%"PRIx32"·command·buffer·base·at·0x%"PRIx64·"\n",·head,·tail,·buf);

2554

············qemu_log("amdvi_command_exec·"·"command·buffer·head·at·0x%"PRIx32"·command·buffer·tail·at·0x%"PRIx32"·command·buffer·base·at·0x%"PRIx64·"\n",·head,·tail,·buf);

2555

#line·2557·"trace/trace-hw_i386.h"

2555

#line·2557·"trace/trace-hw_i386.h"

2556

········}

2556

········}

2557

····}

2557

····}

2558

}

2558

}

2559

static·inline·void·trace_amdvi_command_exec(uint32_t·head,·uint32_t·tail,·uint64_t·buf)

2559

static·inline·void·trace_amdvi_command_exec(uint32_t·head,·uint32_t·tail,·uint64_t·buf)

2571

static·inline·void·_nocheck__trace_amdvi_unhandled_command(uint8_t·type)

2571

static·inline·void·_nocheck__trace_amdvi_unhandled_command(uint8_t·type)

2572

{

2572

{

2573

····if·(trace_event_get_state(TRACE_AMDVI_UNHANDLED_COMMAND)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2573

····if·(trace_event_get_state(TRACE_AMDVI_UNHANDLED_COMMAND)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2574

········if·(message_with_timestamp)·{

2574

········if·(message_with_timestamp)·{

2575

············struct·timeval·_now;

2575

············struct·timeval·_now;

2576

············gettimeofday(&_now,·NULL);

2576

············gettimeofday(&_now,·NULL);

2578

············qemu_log("%d@%zu.%06zu:amdvi_unhandled_command·"·"unhandled·command·0x%"PRIx8·"\n",

2578

············qemu_log("%d@%zu.%06zu:amdvi_unhandled_command·"·"unhandled·command·0x%"PRIx8·"\n",

2579

·····················qemu_get_thread_id(),

2579

·····················qemu_get_thread_id(),

2580

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2580

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2581

·····················,·type);

2581

·····················,·type);

2582

#line·2584·"trace/trace-hw_i386.h"

2582

#line·2584·"trace/trace-hw_i386.h"

2583

········}·else·{

2583

········}·else·{

2585

············qemu_log("amdvi_unhandled_command·"·"unhandled·command·0x%"PRIx8·"\n",·type);

2585

············qemu_log("amdvi_unhandled_command·"·"unhandled·command·0x%"PRIx8·"\n",·type);

2586

#line·2588·"trace/trace-hw_i386.h"

2586

#line·2588·"trace/trace-hw_i386.h"

2587

········}

2587

········}

2588

····}

2588

····}

2589

}

2589

}

2590

static·inline·void·trace_amdvi_unhandled_command(uint8_t·type)

2590

static·inline·void·trace_amdvi_unhandled_command(uint8_t·type)

2602

static·inline·void·_nocheck__trace_amdvi_intr_inval(void)

2602

static·inline·void·_nocheck__trace_amdvi_intr_inval(void)

2603

{

2603

{

2604

····if·(trace_event_get_state(TRACE_AMDVI_INTR_INVAL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2604

····if·(trace_event_get_state(TRACE_AMDVI_INTR_INVAL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2605

········if·(message_with_timestamp)·{

2605

········if·(message_with_timestamp)·{

2606

············struct·timeval·_now;

2606

············struct·timeval·_now;

2607

············gettimeofday(&_now,·NULL);

2607

············gettimeofday(&_now,·NULL);

2609

············qemu_log("%d@%zu.%06zu:amdvi_intr_inval·"·"Interrupt·table·invalidated"·"\n",

2609

············qemu_log("%d@%zu.%06zu:amdvi_intr_inval·"·"Interrupt·table·invalidated"·"\n",

2610

·····················qemu_get_thread_id(),

2610

·····················qemu_get_thread_id(),

2611

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2611

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2612

·····················);

2612

·····················);

2613

#line·2615·"trace/trace-hw_i386.h"

2613

#line·2615·"trace/trace-hw_i386.h"

2614

········}·else·{

2614

········}·else·{

2616

············qemu_log("amdvi_intr_inval·"·"Interrupt·table·invalidated"·"\n");

2616

············qemu_log("amdvi_intr_inval·"·"Interrupt·table·invalidated"·"\n");

2617

#line·2619·"trace/trace-hw_i386.h"

2617

#line·2619·"trace/trace-hw_i386.h"

2618

········}

2618

········}

2619

····}

2619

····}

2620

}

2620

}

2621

static·inline·void·trace_amdvi_intr_inval(void)

2621

static·inline·void·trace_amdvi_intr_inval(void)

2633

static·inline·void·_nocheck__trace_amdvi_iotlb_inval(void)

2633

static·inline·void·_nocheck__trace_amdvi_iotlb_inval(void)

2634

{

2634

{

2635

····if·(trace_event_get_state(TRACE_AMDVI_IOTLB_INVAL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2635

····if·(trace_event_get_state(TRACE_AMDVI_IOTLB_INVAL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2636

········if·(message_with_timestamp)·{

2636

········if·(message_with_timestamp)·{

2637

············struct·timeval·_now;

2637

············struct·timeval·_now;

2638

············gettimeofday(&_now,·NULL);

2638

············gettimeofday(&_now,·NULL);

2640

············qemu_log("%d@%zu.%06zu:amdvi_iotlb_inval·"·"IOTLB·pages·invalidated"·"\n",

2640

············qemu_log("%d@%zu.%06zu:amdvi_iotlb_inval·"·"IOTLB·pages·invalidated"·"\n",

2641

·····················qemu_get_thread_id(),

2641

·····················qemu_get_thread_id(),

2642

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2642

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2643

·····················);

2643

·····················);

2644

#line·2646·"trace/trace-hw_i386.h"

2644

#line·2646·"trace/trace-hw_i386.h"

2645

········}·else·{

2645

········}·else·{

2647

············qemu_log("amdvi_iotlb_inval·"·"IOTLB·pages·invalidated"·"\n");

2647

············qemu_log("amdvi_iotlb_inval·"·"IOTLB·pages·invalidated"·"\n");

2648

#line·2650·"trace/trace-hw_i386.h"

2648

#line·2650·"trace/trace-hw_i386.h"

2649

········}

2649

········}

2650

····}

2650

····}

2651

}

2651

}

2652

static·inline·void·trace_amdvi_iotlb_inval(void)

2652

static·inline·void·trace_amdvi_iotlb_inval(void)

2664

static·inline·void·_nocheck__trace_amdvi_prefetch_pages(void)

2664

static·inline·void·_nocheck__trace_amdvi_prefetch_pages(void)

2665

{

2665

{

2666

····if·(trace_event_get_state(TRACE_AMDVI_PREFETCH_PAGES)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2666

····if·(trace_event_get_state(TRACE_AMDVI_PREFETCH_PAGES)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2667

········if·(message_with_timestamp)·{

2667

········if·(message_with_timestamp)·{

2668

············struct·timeval·_now;

2668

············struct·timeval·_now;

2669

············gettimeofday(&_now,·NULL);

2669

············gettimeofday(&_now,·NULL);

2671

············qemu_log("%d@%zu.%06zu:amdvi_prefetch_pages·"·"Pre-fetch·of·AMD-Vi·pages·requested"·"\n",

2671

············qemu_log("%d@%zu.%06zu:amdvi_prefetch_pages·"·"Pre-fetch·of·AMD-Vi·pages·requested"·"\n",

2672

·····················qemu_get_thread_id(),

2672

·····················qemu_get_thread_id(),

2673

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2673

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2674

·····················);

2674

·····················);

2675

#line·2677·"trace/trace-hw_i386.h"

2675

#line·2677·"trace/trace-hw_i386.h"

2676

········}·else·{

2676

········}·else·{

2678

············qemu_log("amdvi_prefetch_pages·"·"Pre-fetch·of·AMD-Vi·pages·requested"·"\n");

2678

············qemu_log("amdvi_prefetch_pages·"·"Pre-fetch·of·AMD-Vi·pages·requested"·"\n");

2679

#line·2681·"trace/trace-hw_i386.h"

2679

#line·2681·"trace/trace-hw_i386.h"

2680

········}

2680

········}

2681

····}

2681

····}

2682

}

2682

}

2683

static·inline·void·trace_amdvi_prefetch_pages(void)

2683

static·inline·void·trace_amdvi_prefetch_pages(void)

2695

static·inline·void·_nocheck__trace_amdvi_pages_inval(uint16_t·domid)

2695

static·inline·void·_nocheck__trace_amdvi_pages_inval(uint16_t·domid)

2696

{

2696

{

2697

····if·(trace_event_get_state(TRACE_AMDVI_PAGES_INVAL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2697

····if·(trace_event_get_state(TRACE_AMDVI_PAGES_INVAL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2698

········if·(message_with_timestamp)·{

2698

········if·(message_with_timestamp)·{

2699

············struct·timeval·_now;

2699

············struct·timeval·_now;

2700

············gettimeofday(&_now,·NULL);

2700

············gettimeofday(&_now,·NULL);

2702

············qemu_log("%d@%zu.%06zu:amdvi_pages_inval·"·"AMD-Vi·pages·for·domain·0x%"PRIx16·"·invalidated"·"\n",

2702

············qemu_log("%d@%zu.%06zu:amdvi_pages_inval·"·"AMD-Vi·pages·for·domain·0x%"PRIx16·"·invalidated"·"\n",

2703

·····················qemu_get_thread_id(),

2703

·····················qemu_get_thread_id(),

2704

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2704

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2705

·····················,·domid);

2705

·····················,·domid);

2706

#line·2708·"trace/trace-hw_i386.h"

2706

#line·2708·"trace/trace-hw_i386.h"

2707

········}·else·{

2707

········}·else·{

2709

············qemu_log("amdvi_pages_inval·"·"AMD-Vi·pages·for·domain·0x%"PRIx16·"·invalidated"·"\n",·domid);

2709

············qemu_log("amdvi_pages_inval·"·"AMD-Vi·pages·for·domain·0x%"PRIx16·"·invalidated"·"\n",·domid);

2710

#line·2712·"trace/trace-hw_i386.h"

2710

#line·2712·"trace/trace-hw_i386.h"

2711

········}

2711

········}

2712

····}

2712

····}

2713

}

2713

}

2714

static·inline·void·trace_amdvi_pages_inval(uint16_t·domid)

2714

static·inline·void·trace_amdvi_pages_inval(uint16_t·domid)

2726

static·inline·void·_nocheck__trace_amdvi_all_inval(void)

2726

static·inline·void·_nocheck__trace_amdvi_all_inval(void)

2727

{

2727

{

2728

····if·(trace_event_get_state(TRACE_AMDVI_ALL_INVAL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2728

····if·(trace_event_get_state(TRACE_AMDVI_ALL_INVAL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2729

········if·(message_with_timestamp)·{

2729

········if·(message_with_timestamp)·{

2730

············struct·timeval·_now;

2730

············struct·timeval·_now;

2731

············gettimeofday(&_now,·NULL);

2731

············gettimeofday(&_now,·NULL);

2733

············qemu_log("%d@%zu.%06zu:amdvi_all_inval·"·"Invalidation·of·all·AMD-Vi·cache·requested·"·"\n",

2733

············qemu_log("%d@%zu.%06zu:amdvi_all_inval·"·"Invalidation·of·all·AMD-Vi·cache·requested·"·"\n",

2734

·····················qemu_get_thread_id(),

2734

·····················qemu_get_thread_id(),

2735

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2735

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2736

·····················);

2736

·····················);

2737

#line·2739·"trace/trace-hw_i386.h"

2737

#line·2739·"trace/trace-hw_i386.h"

2738

········}·else·{

2738

········}·else·{

2740

············qemu_log("amdvi_all_inval·"·"Invalidation·of·all·AMD-Vi·cache·requested·"·"\n");

2740

············qemu_log("amdvi_all_inval·"·"Invalidation·of·all·AMD-Vi·cache·requested·"·"\n");

2741

#line·2743·"trace/trace-hw_i386.h"

2741

#line·2743·"trace/trace-hw_i386.h"

2742

········}

2742

········}

2743

····}

2743

····}

2744

}

2744

}

2745

static·inline·void·trace_amdvi_all_inval(void)

2745

static·inline·void·trace_amdvi_all_inval(void)

2757

static·inline·void·_nocheck__trace_amdvi_ppr_exec(void)

2757

static·inline·void·_nocheck__trace_amdvi_ppr_exec(void)

2758

{

2758

{

2759

····if·(trace_event_get_state(TRACE_AMDVI_PPR_EXEC)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2759

····if·(trace_event_get_state(TRACE_AMDVI_PPR_EXEC)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2760

········if·(message_with_timestamp)·{

2760

········if·(message_with_timestamp)·{

2761

············struct·timeval·_now;

2761

············struct·timeval·_now;

2762

············gettimeofday(&_now,·NULL);

2762

············gettimeofday(&_now,·NULL);

2764

············qemu_log("%d@%zu.%06zu:amdvi_ppr_exec·"·"Execution·of·PPR·queue·requested·"·"\n",

2764

············qemu_log("%d@%zu.%06zu:amdvi_ppr_exec·"·"Execution·of·PPR·queue·requested·"·"\n",

2765

·····················qemu_get_thread_id(),

2765

·····················qemu_get_thread_id(),

2766

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2766

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2767

·····················);

2767

·····················);

2768

#line·2770·"trace/trace-hw_i386.h"

2768

#line·2770·"trace/trace-hw_i386.h"

2769

········}·else·{

2769

········}·else·{

2771

············qemu_log("amdvi_ppr_exec·"·"Execution·of·PPR·queue·requested·"·"\n");

2771

············qemu_log("amdvi_ppr_exec·"·"Execution·of·PPR·queue·requested·"·"\n");

2772

#line·2774·"trace/trace-hw_i386.h"

2772

#line·2774·"trace/trace-hw_i386.h"

2773

········}

2773

········}

2774

····}

2774

····}

2775

}

2775

}

2776

static·inline·void·trace_amdvi_ppr_exec(void)

2776

static·inline·void·trace_amdvi_ppr_exec(void)

2788

static·inline·void·_nocheck__trace_amdvi_devtab_inval(uint8_t·bus,·uint8_t·slot,·uint8_t·func)

2788

static·inline·void·_nocheck__trace_amdvi_devtab_inval(uint8_t·bus,·uint8_t·slot,·uint8_t·func)

2789

{

2789

{

2790

····if·(trace_event_get_state(TRACE_AMDVI_DEVTAB_INVAL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2790

····if·(trace_event_get_state(TRACE_AMDVI_DEVTAB_INVAL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2791

········if·(message_with_timestamp)·{

2791

········if·(message_with_timestamp)·{

2792

············struct·timeval·_now;

2792

············struct·timeval·_now;

2793

············gettimeofday(&_now,·NULL);

2793

············gettimeofday(&_now,·NULL);

2795

············qemu_log("%d@%zu.%06zu:amdvi_devtab_inval·"·"device·table·entry·for·devid:·%02x:%02x.%x·invalidated"·"\n",

2795

············qemu_log("%d@%zu.%06zu:amdvi_devtab_inval·"·"device·table·entry·for·devid:·%02x:%02x.%x·invalidated"·"\n",

2796

·····················qemu_get_thread_id(),

2796

·····················qemu_get_thread_id(),

2797

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2797

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2798

·····················,·bus,·slot,·func);

2798

·····················,·bus,·slot,·func);

2799

#line·2801·"trace/trace-hw_i386.h"

2799

#line·2801·"trace/trace-hw_i386.h"

2800

········}·else·{

2800

········}·else·{

2802

············qemu_log("amdvi_devtab_inval·"·"device·table·entry·for·devid:·%02x:%02x.%x·invalidated"·"\n",·bus,·slot,·func);

2802

············qemu_log("amdvi_devtab_inval·"·"device·table·entry·for·devid:·%02x:%02x.%x·invalidated"·"\n",·bus,·slot,·func);

2803

#line·2805·"trace/trace-hw_i386.h"

2803

#line·2805·"trace/trace-hw_i386.h"

2804

········}

2804

········}

2805

····}

2805

····}

2806

}

2806

}

2807

static·inline·void·trace_amdvi_devtab_inval(uint8_t·bus,·uint8_t·slot,·uint8_t·func)

2807

static·inline·void·trace_amdvi_devtab_inval(uint8_t·bus,·uint8_t·slot,·uint8_t·func)

2819

static·inline·void·_nocheck__trace_amdvi_completion_wait(uint64_t·addr,·uint64_t·data)

2819

static·inline·void·_nocheck__trace_amdvi_completion_wait(uint64_t·addr,·uint64_t·data)

2820

{

2820

{

2821

····if·(trace_event_get_state(TRACE_AMDVI_COMPLETION_WAIT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2821

····if·(trace_event_get_state(TRACE_AMDVI_COMPLETION_WAIT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2822

········if·(message_with_timestamp)·{

2822

········if·(message_with_timestamp)·{

2823

············struct·timeval·_now;

2823

············struct·timeval·_now;

2824

············gettimeofday(&_now,·NULL);

2824

············gettimeofday(&_now,·NULL);

2826

············qemu_log("%d@%zu.%06zu:amdvi_completion_wait·"·"completion·wait·requested·with·store·address·0x%"PRIx64"·and·store·data·0x%"PRIx64·"\n",

2826

············qemu_log("%d@%zu.%06zu:amdvi_completion_wait·"·"completion·wait·requested·with·store·address·0x%"PRIx64"·and·store·data·0x%"PRIx64·"\n",

2827

·····················qemu_get_thread_id(),

2827

·····················qemu_get_thread_id(),

2828

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2828

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2829

·····················,·addr,·data);

2829

·····················,·addr,·data);

2830

#line·2832·"trace/trace-hw_i386.h"

2830

#line·2832·"trace/trace-hw_i386.h"

2831

········}·else·{

2831

········}·else·{

2833

············qemu_log("amdvi_completion_wait·"·"completion·wait·requested·with·store·address·0x%"PRIx64"·and·store·data·0x%"PRIx64·"\n",·addr,·data);

2833

············qemu_log("amdvi_completion_wait·"·"completion·wait·requested·with·store·address·0x%"PRIx64"·and·store·data·0x%"PRIx64·"\n",·addr,·data);

2834

#line·2836·"trace/trace-hw_i386.h"

2834

#line·2836·"trace/trace-hw_i386.h"

2835

········}

2835

········}

2836

····}

2836

····}

2837

}

2837

}

2838

static·inline·void·trace_amdvi_completion_wait(uint64_t·addr,·uint64_t·data)

2838

static·inline·void·trace_amdvi_completion_wait(uint64_t·addr,·uint64_t·data)

2850

static·inline·void·_nocheck__trace_amdvi_control_status(uint64_t·val)

2850

static·inline·void·_nocheck__trace_amdvi_control_status(uint64_t·val)

2851

{

2851

{

2852

····if·(trace_event_get_state(TRACE_AMDVI_CONTROL_STATUS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2852

····if·(trace_event_get_state(TRACE_AMDVI_CONTROL_STATUS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2853

········if·(message_with_timestamp)·{

2853

········if·(message_with_timestamp)·{

2854

············struct·timeval·_now;

2854

············struct·timeval·_now;

2855

············gettimeofday(&_now,·NULL);

2855

············gettimeofday(&_now,·NULL);

2857

············qemu_log("%d@%zu.%06zu:amdvi_control_status·"·"MMIO_STATUS·state·0x%"PRIx64·"\n",

2857

············qemu_log("%d@%zu.%06zu:amdvi_control_status·"·"MMIO_STATUS·state·0x%"PRIx64·"\n",

2858

·····················qemu_get_thread_id(),

2858

·····················qemu_get_thread_id(),

2859

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2859

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2860

·····················,·val);

2860

·····················,·val);

2861

#line·2863·"trace/trace-hw_i386.h"

2861

#line·2863·"trace/trace-hw_i386.h"

2862

········}·else·{

2862

········}·else·{

2864

············qemu_log("amdvi_control_status·"·"MMIO_STATUS·state·0x%"PRIx64·"\n",·val);

2864

············qemu_log("amdvi_control_status·"·"MMIO_STATUS·state·0x%"PRIx64·"\n",·val);

2865

#line·2867·"trace/trace-hw_i386.h"

2865

#line·2867·"trace/trace-hw_i386.h"

2866

········}

2866

········}

2867

····}

2867

····}

2868

}

2868

}

2869

static·inline·void·trace_amdvi_control_status(uint64_t·val)

2869

static·inline·void·trace_amdvi_control_status(uint64_t·val)

2881

static·inline·void·_nocheck__trace_amdvi_iotlb_reset(void)

2881

static·inline·void·_nocheck__trace_amdvi_iotlb_reset(void)

2882

{

2882

{

2883

····if·(trace_event_get_state(TRACE_AMDVI_IOTLB_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2883

····if·(trace_event_get_state(TRACE_AMDVI_IOTLB_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2884

········if·(message_with_timestamp)·{

2884

········if·(message_with_timestamp)·{

2885

············struct·timeval·_now;

2885

············struct·timeval·_now;

2886

············gettimeofday(&_now,·NULL);

2886

············gettimeofday(&_now,·NULL);

2888

············qemu_log("%d@%zu.%06zu:amdvi_iotlb_reset·"·"IOTLB·exceed·size·limit·-·reset·"·"\n",

2888

············qemu_log("%d@%zu.%06zu:amdvi_iotlb_reset·"·"IOTLB·exceed·size·limit·-·reset·"·"\n",

2889

·····················qemu_get_thread_id(),

2889

·····················qemu_get_thread_id(),

2890

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2890

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2891

·····················);

2891

·····················);

2892

#line·2894·"trace/trace-hw_i386.h"

2892

#line·2894·"trace/trace-hw_i386.h"

2893

········}·else·{

2893

········}·else·{

2895

············qemu_log("amdvi_iotlb_reset·"·"IOTLB·exceed·size·limit·-·reset·"·"\n");

2895

············qemu_log("amdvi_iotlb_reset·"·"IOTLB·exceed·size·limit·-·reset·"·"\n");

2896

#line·2898·"trace/trace-hw_i386.h"

2896

#line·2898·"trace/trace-hw_i386.h"

2897

········}

2897

········}

2898

····}

2898

····}

2899

}

2899

}

2900

static·inline·void·trace_amdvi_iotlb_reset(void)

2900

static·inline·void·trace_amdvi_iotlb_reset(void)

2912

static·inline·void·_nocheck__trace_amdvi_dte_get_fail(uint64_t·addr,·uint32_t·offset)

2912

static·inline·void·_nocheck__trace_amdvi_dte_get_fail(uint64_t·addr,·uint32_t·offset)

2913

{

2913

{

2914

····if·(trace_event_get_state(TRACE_AMDVI_DTE_GET_FAIL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2914

····if·(trace_event_get_state(TRACE_AMDVI_DTE_GET_FAIL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2915

········if·(message_with_timestamp)·{

2915

········if·(message_with_timestamp)·{

2916

············struct·timeval·_now;

2916

············struct·timeval·_now;

2917

············gettimeofday(&_now,·NULL);

2917

············gettimeofday(&_now,·NULL);

2919

············qemu_log("%d@%zu.%06zu:amdvi_dte_get_fail·"·"error:·failed·to·access·Device·Entry·devtab·0x%"PRIx64"·offset·0x%"PRIx32·"\n",

2919

············qemu_log("%d@%zu.%06zu:amdvi_dte_get_fail·"·"error:·failed·to·access·Device·Entry·devtab·0x%"PRIx64"·offset·0x%"PRIx32·"\n",

2920

·····················qemu_get_thread_id(),

2920

·····················qemu_get_thread_id(),

2921

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2921

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2922

·····················,·addr,·offset);

2922

·····················,·addr,·offset);

2923

#line·2925·"trace/trace-hw_i386.h"

2923

#line·2925·"trace/trace-hw_i386.h"

2924

········}·else·{

2924

········}·else·{

2926

············qemu_log("amdvi_dte_get_fail·"·"error:·failed·to·access·Device·Entry·devtab·0x%"PRIx64"·offset·0x%"PRIx32·"\n",·addr,·offset);

2926

············qemu_log("amdvi_dte_get_fail·"·"error:·failed·to·access·Device·Entry·devtab·0x%"PRIx64"·offset·0x%"PRIx32·"\n",·addr,·offset);

2927

#line·2929·"trace/trace-hw_i386.h"

2927

#line·2929·"trace/trace-hw_i386.h"

2928

········}

2928

········}

2929

····}

2929

····}

2930

}

2930

}

2931

static·inline·void·trace_amdvi_dte_get_fail(uint64_t·addr,·uint32_t·offset)

2931

static·inline·void·trace_amdvi_dte_get_fail(uint64_t·addr,·uint32_t·offset)

2943

static·inline·void·_nocheck__trace_amdvi_invalid_dte(uint64_t·addr)

2943

static·inline·void·_nocheck__trace_amdvi_invalid_dte(uint64_t·addr)

2944

{

2944

{

2945

····if·(trace_event_get_state(TRACE_AMDVI_INVALID_DTE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2945

····if·(trace_event_get_state(TRACE_AMDVI_INVALID_DTE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2946

········if·(message_with_timestamp)·{

2946

········if·(message_with_timestamp)·{

2947

············struct·timeval·_now;

2947

············struct·timeval·_now;

2948

············gettimeofday(&_now,·NULL);

2948

············gettimeofday(&_now,·NULL);

2950

············qemu_log("%d@%zu.%06zu:amdvi_invalid_dte·"·"PTE·entry·at·0x%"PRIx64"·is·invalid·"·"\n",

2950

············qemu_log("%d@%zu.%06zu:amdvi_invalid_dte·"·"PTE·entry·at·0x%"PRIx64"·is·invalid·"·"\n",

2951

·····················qemu_get_thread_id(),

2951

·····················qemu_get_thread_id(),

2952

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2952

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2953

·····················,·addr);

2953

·····················,·addr);

2954

#line·2956·"trace/trace-hw_i386.h"

2954

#line·2956·"trace/trace-hw_i386.h"

2955

········}·else·{

2955

········}·else·{

2957

············qemu_log("amdvi_invalid_dte·"·"PTE·entry·at·0x%"PRIx64"·is·invalid·"·"\n",·addr);

2957

············qemu_log("amdvi_invalid_dte·"·"PTE·entry·at·0x%"PRIx64"·is·invalid·"·"\n",·addr);

2958

#line·2960·"trace/trace-hw_i386.h"

2958

#line·2960·"trace/trace-hw_i386.h"

2959

········}

2959

········}

2960

····}

2960

····}

2961

}

2961

}

2962

static·inline·void·trace_amdvi_invalid_dte(uint64_t·addr)

2962

static·inline·void·trace_amdvi_invalid_dte(uint64_t·addr)

2974

static·inline·void·_nocheck__trace_amdvi_get_pte_hwerror(uint64_t·addr)

2974

static·inline·void·_nocheck__trace_amdvi_get_pte_hwerror(uint64_t·addr)

2975

{

2975

{

2976

····if·(trace_event_get_state(TRACE_AMDVI_GET_PTE_HWERROR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2976

····if·(trace_event_get_state(TRACE_AMDVI_GET_PTE_HWERROR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2977

········if·(message_with_timestamp)·{

2977

········if·(message_with_timestamp)·{

2978

············struct·timeval·_now;

2978

············struct·timeval·_now;

2979

············gettimeofday(&_now,·NULL);

2979

············gettimeofday(&_now,·NULL);

2981

············qemu_log("%d@%zu.%06zu:amdvi_get_pte_hwerror·"·"hardware·error·eccessing·PTE·at·addr·0x%"PRIx64·"\n",

2981

············qemu_log("%d@%zu.%06zu:amdvi_get_pte_hwerror·"·"hardware·error·eccessing·PTE·at·addr·0x%"PRIx64·"\n",

2982

·····················qemu_get_thread_id(),

2982

·····················qemu_get_thread_id(),

2983

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2983

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2984

·····················,·addr);

2984

·····················,·addr);

2985

#line·2987·"trace/trace-hw_i386.h"

2985

#line·2987·"trace/trace-hw_i386.h"

2986

········}·else·{

2986

········}·else·{

2988

············qemu_log("amdvi_get_pte_hwerror·"·"hardware·error·eccessing·PTE·at·addr·0x%"PRIx64·"\n",·addr);

2988

············qemu_log("amdvi_get_pte_hwerror·"·"hardware·error·eccessing·PTE·at·addr·0x%"PRIx64·"\n",·addr);

2989

#line·2991·"trace/trace-hw_i386.h"

2989

#line·2991·"trace/trace-hw_i386.h"

2990

········}

2990

········}

2991

····}

2991

····}

2992

}

2992

}

2993

static·inline·void·trace_amdvi_get_pte_hwerror(uint64_t·addr)

2993

static·inline·void·trace_amdvi_get_pte_hwerror(uint64_t·addr)

3005

static·inline·void·_nocheck__trace_amdvi_mode_invalid(uint8_t·level,·uint64_t·addr)

3005

static·inline·void·_nocheck__trace_amdvi_mode_invalid(uint8_t·level,·uint64_t·addr)

3006

{

3006

{

3007

····if·(trace_event_get_state(TRACE_AMDVI_MODE_INVALID)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3007

····if·(trace_event_get_state(TRACE_AMDVI_MODE_INVALID)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3008

········if·(message_with_timestamp)·{

3008

········if·(message_with_timestamp)·{

3009

············struct·timeval·_now;

3009

············struct·timeval·_now;

3010

············gettimeofday(&_now,·NULL);

3010

············gettimeofday(&_now,·NULL);

3012

············qemu_log("%d@%zu.%06zu:amdvi_mode_invalid·"·"error:·translation·level·0x%"PRIx8"·translating·addr·0x%"PRIx64·"\n",

3012

············qemu_log("%d@%zu.%06zu:amdvi_mode_invalid·"·"error:·translation·level·0x%"PRIx8"·translating·addr·0x%"PRIx64·"\n",

3013

·····················qemu_get_thread_id(),

3013

·····················qemu_get_thread_id(),

3014

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3014

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3015

·····················,·level,·addr);

3015

·····················,·level,·addr);

3016

#line·3018·"trace/trace-hw_i386.h"

3016

#line·3018·"trace/trace-hw_i386.h"

3017

········}·else·{

3017

········}·else·{

3019

············qemu_log("amdvi_mode_invalid·"·"error:·translation·level·0x%"PRIx8"·translating·addr·0x%"PRIx64·"\n",·level,·addr);

3019

············qemu_log("amdvi_mode_invalid·"·"error:·translation·level·0x%"PRIx8"·translating·addr·0x%"PRIx64·"\n",·level,·addr);

3020

#line·3022·"trace/trace-hw_i386.h"

3020

#line·3022·"trace/trace-hw_i386.h"

3021

········}

3021

········}

3022

····}

3022

····}

3023

}

3023

}

3024

static·inline·void·trace_amdvi_mode_invalid(uint8_t·level,·uint64_t·addr)

3024

static·inline·void·trace_amdvi_mode_invalid(uint8_t·level,·uint64_t·addr)

3036

static·inline·void·_nocheck__trace_amdvi_page_fault(uint64_t·addr)

3036

static·inline·void·_nocheck__trace_amdvi_page_fault(uint64_t·addr)

3037

{

3037

{

3038

····if·(trace_event_get_state(TRACE_AMDVI_PAGE_FAULT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3038

····if·(trace_event_get_state(TRACE_AMDVI_PAGE_FAULT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3039

········if·(message_with_timestamp)·{

3039

········if·(message_with_timestamp)·{

3040

············struct·timeval·_now;

3040

············struct·timeval·_now;

3041

············gettimeofday(&_now,·NULL);

3041

············gettimeofday(&_now,·NULL);

3043

············qemu_log("%d@%zu.%06zu:amdvi_page_fault·"·"error:·page·fault·accessing·guest·physical·address·0x%"PRIx64·"\n",

3043

············qemu_log("%d@%zu.%06zu:amdvi_page_fault·"·"error:·page·fault·accessing·guest·physical·address·0x%"PRIx64·"\n",

3044

·····················qemu_get_thread_id(),

3044

·····················qemu_get_thread_id(),

3045

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3045

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3046

·····················,·addr);

3046

·····················,·addr);

3047

#line·3049·"trace/trace-hw_i386.h"

3047

#line·3049·"trace/trace-hw_i386.h"

3048

········}·else·{

3048

········}·else·{

3050

············qemu_log("amdvi_page_fault·"·"error:·page·fault·accessing·guest·physical·address·0x%"PRIx64·"\n",·addr);

3050

············qemu_log("amdvi_page_fault·"·"error:·page·fault·accessing·guest·physical·address·0x%"PRIx64·"\n",·addr);

3051

#line·3053·"trace/trace-hw_i386.h"

3051

#line·3053·"trace/trace-hw_i386.h"

3052

········}

3052

········}

3053

····}

3053

····}

3054

}

3054

}

3055

static·inline·void·trace_amdvi_page_fault(uint64_t·addr)

3055

static·inline·void·trace_amdvi_page_fault(uint64_t·addr)

3067

static·inline·void·_nocheck__trace_amdvi_iotlb_hit(uint8_t·bus,·uint8_t·slot,·uint8_t·func,·uint64_t·addr,·uint64_t·txaddr)

3067

static·inline·void·_nocheck__trace_amdvi_iotlb_hit(uint8_t·bus,·uint8_t·slot,·uint8_t·func,·uint64_t·addr,·uint64_t·txaddr)

3068

{

3068

{

3069

····if·(trace_event_get_state(TRACE_AMDVI_IOTLB_HIT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3069

····if·(trace_event_get_state(TRACE_AMDVI_IOTLB_HIT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3070

········if·(message_with_timestamp)·{

3070

········if·(message_with_timestamp)·{

3071

············struct·timeval·_now;

3071

············struct·timeval·_now;

3072

············gettimeofday(&_now,·NULL);

3072

············gettimeofday(&_now,·NULL);

3074

············qemu_log("%d@%zu.%06zu:amdvi_iotlb_hit·"·"hit·iotlb·devid·%02x:%02x.%x·gpa·0x%"PRIx64"·hpa·0x%"PRIx64·"\n",

3074

············qemu_log("%d@%zu.%06zu:amdvi_iotlb_hit·"·"hit·iotlb·devid·%02x:%02x.%x·gpa·0x%"PRIx64"·hpa·0x%"PRIx64·"\n",

3075

·····················qemu_get_thread_id(),

3075

·····················qemu_get_thread_id(),

3076

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3076

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3077

·····················,·bus,·slot,·func,·addr,·txaddr);

3077

·····················,·bus,·slot,·func,·addr,·txaddr);

3078

#line·3080·"trace/trace-hw_i386.h"

3078

#line·3080·"trace/trace-hw_i386.h"

3079

········}·else·{

3079

········}·else·{

3081

············qemu_log("amdvi_iotlb_hit·"·"hit·iotlb·devid·%02x:%02x.%x·gpa·0x%"PRIx64"·hpa·0x%"PRIx64·"\n",·bus,·slot,·func,·addr,·txaddr);

3081

············qemu_log("amdvi_iotlb_hit·"·"hit·iotlb·devid·%02x:%02x.%x·gpa·0x%"PRIx64"·hpa·0x%"PRIx64·"\n",·bus,·slot,·func,·addr,·txaddr);

3082

#line·3084·"trace/trace-hw_i386.h"

3082

#line·3084·"trace/trace-hw_i386.h"

3083

········}

3083

········}

3084

····}

3084

····}

3085

}

3085

}

3086

static·inline·void·trace_amdvi_iotlb_hit(uint8_t·bus,·uint8_t·slot,·uint8_t·func,·uint64_t·addr,·uint64_t·txaddr)

3086

static·inline·void·trace_amdvi_iotlb_hit(uint8_t·bus,·uint8_t·slot,·uint8_t·func,·uint64_t·addr,·uint64_t·txaddr)

3098

static·inline·void·_nocheck__trace_amdvi_translation_result(uint8_t·bus,·uint8_t·slot,·uint8_t·func,·uint64_t·addr,·uint64_t·txaddr)

3098

static·inline·void·_nocheck__trace_amdvi_translation_result(uint8_t·bus,·uint8_t·slot,·uint8_t·func,·uint64_t·addr,·uint64_t·txaddr)

3099

{

3099

{

3100

····if·(trace_event_get_state(TRACE_AMDVI_TRANSLATION_RESULT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3100

····if·(trace_event_get_state(TRACE_AMDVI_TRANSLATION_RESULT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3101

········if·(message_with_timestamp)·{

3101

········if·(message_with_timestamp)·{

3102

············struct·timeval·_now;

3102

············struct·timeval·_now;

3103

············gettimeofday(&_now,·NULL);

3103

············gettimeofday(&_now,·NULL);

3105

············qemu_log("%d@%zu.%06zu:amdvi_translation_result·"·"devid:·%02x:%02x.%x·gpa·0x%"PRIx64"·hpa·0x%"PRIx64·"\n",

3105

············qemu_log("%d@%zu.%06zu:amdvi_translation_result·"·"devid:·%02x:%02x.%x·gpa·0x%"PRIx64"·hpa·0x%"PRIx64·"\n",

3106

·····················qemu_get_thread_id(),

3106

·····················qemu_get_thread_id(),

3107

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3107

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3108

·····················,·bus,·slot,·func,·addr,·txaddr);

3108

·····················,·bus,·slot,·func,·addr,·txaddr);

3109

#line·3111·"trace/trace-hw_i386.h"

3109

#line·3111·"trace/trace-hw_i386.h"

3110

········}·else·{

3110

········}·else·{

3112

············qemu_log("amdvi_translation_result·"·"devid:·%02x:%02x.%x·gpa·0x%"PRIx64"·hpa·0x%"PRIx64·"\n",·bus,·slot,·func,·addr,·txaddr);

3112

············qemu_log("amdvi_translation_result·"·"devid:·%02x:%02x.%x·gpa·0x%"PRIx64"·hpa·0x%"PRIx64·"\n",·bus,·slot,·func,·addr,·txaddr);

3113

#line·3115·"trace/trace-hw_i386.h"

3113

#line·3115·"trace/trace-hw_i386.h"

3114

········}

3114

········}

3115

····}

3115

····}

3116

}

3116

}

3117

static·inline·void·trace_amdvi_translation_result(uint8_t·bus,·uint8_t·slot,·uint8_t·func,·uint64_t·addr,·uint64_t·txaddr)

3117

static·inline·void·trace_amdvi_translation_result(uint8_t·bus,·uint8_t·slot,·uint8_t·func,·uint64_t·addr,·uint64_t·txaddr)

3129

static·inline·void·_nocheck__trace_amdvi_mem_ir_write_req(uint64_t·addr,·uint64_t·val,·uint32_t·size)

3129

static·inline·void·_nocheck__trace_amdvi_mem_ir_write_req(uint64_t·addr,·uint64_t·val,·uint32_t·size)

3130

{

3130

{

3131

····if·(trace_event_get_state(TRACE_AMDVI_MEM_IR_WRITE_REQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3131

····if·(trace_event_get_state(TRACE_AMDVI_MEM_IR_WRITE_REQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3132

········if·(message_with_timestamp)·{

3132

········if·(message_with_timestamp)·{

3133

············struct·timeval·_now;

3133

············struct·timeval·_now;

3134

············gettimeofday(&_now,·NULL);

3134

············gettimeofday(&_now,·NULL);

3136

············qemu_log("%d@%zu.%06zu:amdvi_mem_ir_write_req·"·"addr·0x%"PRIx64"·data·0x%"PRIx64"·size·0x%"PRIx32·"\n",

3136

············qemu_log("%d@%zu.%06zu:amdvi_mem_ir_write_req·"·"addr·0x%"PRIx64"·data·0x%"PRIx64"·size·0x%"PRIx32·"\n",

3137

·····················qemu_get_thread_id(),

3137

·····················qemu_get_thread_id(),

3138

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3138

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3139

·····················,·addr,·val,·size);

3139

·····················,·addr,·val,·size);

3140

#line·3142·"trace/trace-hw_i386.h"

3140

#line·3142·"trace/trace-hw_i386.h"

3141

········}·else·{

3141

········}·else·{

3143

············qemu_log("amdvi_mem_ir_write_req·"·"addr·0x%"PRIx64"·data·0x%"PRIx64"·size·0x%"PRIx32·"\n",·addr,·val,·size);

3143

············qemu_log("amdvi_mem_ir_write_req·"·"addr·0x%"PRIx64"·data·0x%"PRIx64"·size·0x%"PRIx32·"\n",·addr,·val,·size);

3144

#line·3146·"trace/trace-hw_i386.h"

3144

#line·3146·"trace/trace-hw_i386.h"

3145

········}

3145

········}

3146

····}

3146

····}

3147

}

3147

}

3148

static·inline·void·trace_amdvi_mem_ir_write_req(uint64_t·addr,·uint64_t·val,·uint32_t·size)

3148

static·inline·void·trace_amdvi_mem_ir_write_req(uint64_t·addr,·uint64_t·val,·uint32_t·size)

3160

static·inline·void·_nocheck__trace_amdvi_mem_ir_write(uint64_t·addr,·uint64_t·val)

3160

static·inline·void·_nocheck__trace_amdvi_mem_ir_write(uint64_t·addr,·uint64_t·val)

3161

{

3161

{

3162

····if·(trace_event_get_state(TRACE_AMDVI_MEM_IR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3162

····if·(trace_event_get_state(TRACE_AMDVI_MEM_IR_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3163

········if·(message_with_timestamp)·{

3163

········if·(message_with_timestamp)·{

3164

············struct·timeval·_now;

3164

············struct·timeval·_now;

3165

············gettimeofday(&_now,·NULL);

3165

············gettimeofday(&_now,·NULL);

3167

············qemu_log("%d@%zu.%06zu:amdvi_mem_ir_write·"·"addr·0x%"PRIx64"·data·0x%"PRIx64·"\n",

3167

············qemu_log("%d@%zu.%06zu:amdvi_mem_ir_write·"·"addr·0x%"PRIx64"·data·0x%"PRIx64·"\n",

3168

·····················qemu_get_thread_id(),

3168

·····················qemu_get_thread_id(),

3169

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3169

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3170

·····················,·addr,·val);

3170

·····················,·addr,·val);

3171

#line·3173·"trace/trace-hw_i386.h"

3171

#line·3173·"trace/trace-hw_i386.h"

3172

········}·else·{

3172

········}·else·{

3174

············qemu_log("amdvi_mem_ir_write·"·"addr·0x%"PRIx64"·data·0x%"PRIx64·"\n",·addr,·val);

3174

············qemu_log("amdvi_mem_ir_write·"·"addr·0x%"PRIx64"·data·0x%"PRIx64·"\n",·addr,·val);

3175

#line·3177·"trace/trace-hw_i386.h"

3175

#line·3177·"trace/trace-hw_i386.h"

3176

········}

3176

········}

3177

····}

3177

····}

3178

}

3178

}

3179

static·inline·void·trace_amdvi_mem_ir_write(uint64_t·addr,·uint64_t·val)

3179

static·inline·void·trace_amdvi_mem_ir_write(uint64_t·addr,·uint64_t·val)

3191

static·inline·void·_nocheck__trace_amdvi_ir_remap_msi_req(uint64_t·addr,·uint64_t·data,·uint8_t·devid)

3191

static·inline·void·_nocheck__trace_amdvi_ir_remap_msi_req(uint64_t·addr,·uint64_t·data,·uint8_t·devid)

3192

{

3192

{

3193

····if·(trace_event_get_state(TRACE_AMDVI_IR_REMAP_MSI_REQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3193

····if·(trace_event_get_state(TRACE_AMDVI_IR_REMAP_MSI_REQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3194

········if·(message_with_timestamp)·{

3194

········if·(message_with_timestamp)·{

3195

············struct·timeval·_now;

3195

············struct·timeval·_now;

3196

············gettimeofday(&_now,·NULL);

3196

············gettimeofday(&_now,·NULL);

3198

············qemu_log("%d@%zu.%06zu:amdvi_ir_remap_msi_req·"·"addr·0x%"PRIx64"·data·0x%"PRIx64"·devid·0x%"PRIx8·"\n",

3198

············qemu_log("%d@%zu.%06zu:amdvi_ir_remap_msi_req·"·"addr·0x%"PRIx64"·data·0x%"PRIx64"·devid·0x%"PRIx8·"\n",

3199

·····················qemu_get_thread_id(),

3199

·····················qemu_get_thread_id(),

3200

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3200

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3201

·····················,·addr,·data,·devid);

3201

·····················,·addr,·data,·devid);

3202

#line·3204·"trace/trace-hw_i386.h"

3202

#line·3204·"trace/trace-hw_i386.h"

3203

········}·else·{

3203

········}·else·{

3205

············qemu_log("amdvi_ir_remap_msi_req·"·"addr·0x%"PRIx64"·data·0x%"PRIx64"·devid·0x%"PRIx8·"\n",·addr,·data,·devid);

3205

············qemu_log("amdvi_ir_remap_msi_req·"·"addr·0x%"PRIx64"·data·0x%"PRIx64"·devid·0x%"PRIx8·"\n",·addr,·data,·devid);

3206

#line·3208·"trace/trace-hw_i386.h"

3206

#line·3208·"trace/trace-hw_i386.h"

3207

········}

3207

········}

3208

····}

3208

····}

3209

}

3209

}

3210

static·inline·void·trace_amdvi_ir_remap_msi_req(uint64_t·addr,·uint64_t·data,·uint8_t·devid)

3210

static·inline·void·trace_amdvi_ir_remap_msi_req(uint64_t·addr,·uint64_t·data,·uint8_t·devid)

3222

static·inline·void·_nocheck__trace_amdvi_ir_remap_msi(uint64_t·addr,·uint64_t·data,·uint64_t·addr2,·uint64_t·data2)

3222

static·inline·void·_nocheck__trace_amdvi_ir_remap_msi(uint64_t·addr,·uint64_t·data,·uint64_t·addr2,·uint64_t·data2)

3223

{

3223

{

3224

····if·(trace_event_get_state(TRACE_AMDVI_IR_REMAP_MSI)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3224

····if·(trace_event_get_state(TRACE_AMDVI_IR_REMAP_MSI)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3225

········if·(message_with_timestamp)·{

3225

········if·(message_with_timestamp)·{

3226

············struct·timeval·_now;

3226

············struct·timeval·_now;

3227

············gettimeofday(&_now,·NULL);

3227

············gettimeofday(&_now,·NULL);

3229

············qemu_log("%d@%zu.%06zu:amdvi_ir_remap_msi·"·"(addr·0x%"PRIx64",·data·0x%"PRIx64")·->·(addr·0x%"PRIx64",·data·0x%"PRIx64")"·"\n",

3229

············qemu_log("%d@%zu.%06zu:amdvi_ir_remap_msi·"·"(addr·0x%"PRIx64",·data·0x%"PRIx64")·->·(addr·0x%"PRIx64",·data·0x%"PRIx64")"·"\n",

3230

·····················qemu_get_thread_id(),

3230

·····················qemu_get_thread_id(),

3231

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3231

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3232

·····················,·addr,·data,·addr2,·data2);

3232

·····················,·addr,·data,·addr2,·data2);

3233

#line·3235·"trace/trace-hw_i386.h"

3233

#line·3235·"trace/trace-hw_i386.h"

3234

········}·else·{

3234

········}·else·{

3236

············qemu_log("amdvi_ir_remap_msi·"·"(addr·0x%"PRIx64",·data·0x%"PRIx64")·->·(addr·0x%"PRIx64",·data·0x%"PRIx64")"·"\n",·addr,·data,·addr2,·data2);

3236

············qemu_log("amdvi_ir_remap_msi·"·"(addr·0x%"PRIx64",·data·0x%"PRIx64")·->·(addr·0x%"PRIx64",·data·0x%"PRIx64")"·"\n",·addr,·data,·addr2,·data2);

3237

#line·3239·"trace/trace-hw_i386.h"

3237

#line·3239·"trace/trace-hw_i386.h"

3238

········}

3238

········}

3239

····}

3239

····}

3240

}

3240

}

3241

static·inline·void·trace_amdvi_ir_remap_msi(uint64_t·addr,·uint64_t·data,·uint64_t·addr2,·uint64_t·data2)

3241

static·inline·void·trace_amdvi_ir_remap_msi(uint64_t·addr,·uint64_t·data,·uint64_t·addr2,·uint64_t·data2)

3253

static·inline·void·_nocheck__trace_amdvi_err(const·char·*·str)

3253

static·inline·void·_nocheck__trace_amdvi_err(const·char·*·str)

3254

{

3254

{

3255

····if·(trace_event_get_state(TRACE_AMDVI_ERR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3255

····if·(trace_event_get_state(TRACE_AMDVI_ERR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3256

········if·(message_with_timestamp)·{

3256

········if·(message_with_timestamp)·{

3257

············struct·timeval·_now;

3257

············struct·timeval·_now;

3258

············gettimeofday(&_now,·NULL);

3258

············gettimeofday(&_now,·NULL);

3260

············qemu_log("%d@%zu.%06zu:amdvi_err·"·"%s"·"\n",

3260

············qemu_log("%d@%zu.%06zu:amdvi_err·"·"%s"·"\n",

3261

·····················qemu_get_thread_id(),

3261

·····················qemu_get_thread_id(),

3262

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3262

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3263

·····················,·str);

3263

·····················,·str);

3264

#line·3266·"trace/trace-hw_i386.h"

3264

#line·3266·"trace/trace-hw_i386.h"

3265

········}·else·{

3265

········}·else·{

3267

············qemu_log("amdvi_err·"·"%s"·"\n",·str);

3267

············qemu_log("amdvi_err·"·"%s"·"\n",·str);

3268

#line·3270·"trace/trace-hw_i386.h"

3268

#line·3270·"trace/trace-hw_i386.h"

3269

········}

3269

········}

3270

····}

3270

····}

3271

}

3271

}

3272

static·inline·void·trace_amdvi_err(const·char·*·str)

3272

static·inline·void·trace_amdvi_err(const·char·*·str)

3284

static·inline·void·_nocheck__trace_amdvi_ir_irte(uint64_t·addr,·uint64_t·data)

3284

static·inline·void·_nocheck__trace_amdvi_ir_irte(uint64_t·addr,·uint64_t·data)

3285

{

3285

{

3286

····if·(trace_event_get_state(TRACE_AMDVI_IR_IRTE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3286

····if·(trace_event_get_state(TRACE_AMDVI_IR_IRTE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3287

········if·(message_with_timestamp)·{

3287

········if·(message_with_timestamp)·{

3288

············struct·timeval·_now;

3288

············struct·timeval·_now;

3289

············gettimeofday(&_now,·NULL);

3289

············gettimeofday(&_now,·NULL);

3291

············qemu_log("%d@%zu.%06zu:amdvi_ir_irte·"·"addr·0x%"PRIx64"·offset·0x%"PRIx64·"\n",

3291

············qemu_log("%d@%zu.%06zu:amdvi_ir_irte·"·"addr·0x%"PRIx64"·offset·0x%"PRIx64·"\n",

3292

·····················qemu_get_thread_id(),

3292

·····················qemu_get_thread_id(),

3293

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3293

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3294

·····················,·addr,·data);

3294

·····················,·addr,·data);

3295

#line·3297·"trace/trace-hw_i386.h"

3295

#line·3297·"trace/trace-hw_i386.h"

3296

········}·else·{

3296

········}·else·{

3298

············qemu_log("amdvi_ir_irte·"·"addr·0x%"PRIx64"·offset·0x%"PRIx64·"\n",·addr,·data);

3298

············qemu_log("amdvi_ir_irte·"·"addr·0x%"PRIx64"·offset·0x%"PRIx64·"\n",·addr,·data);

3299

#line·3301·"trace/trace-hw_i386.h"

3299

#line·3301·"trace/trace-hw_i386.h"

3300

········}

3300

········}

3301

····}

3301

····}

3302

}

3302

}

3303

static·inline·void·trace_amdvi_ir_irte(uint64_t·addr,·uint64_t·data)

3303

static·inline·void·trace_amdvi_ir_irte(uint64_t·addr,·uint64_t·data)

3315

static·inline·void·_nocheck__trace_amdvi_ir_irte_val(uint32_t·data)

3315

static·inline·void·_nocheck__trace_amdvi_ir_irte_val(uint32_t·data)

3316

{

3316

{

3317

····if·(trace_event_get_state(TRACE_AMDVI_IR_IRTE_VAL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3317

····if·(trace_event_get_state(TRACE_AMDVI_IR_IRTE_VAL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3318

········if·(message_with_timestamp)·{

3318

········if·(message_with_timestamp)·{

3319

············struct·timeval·_now;

3319

············struct·timeval·_now;

3320

············gettimeofday(&_now,·NULL);

3320

············gettimeofday(&_now,·NULL);

3322

············qemu_log("%d@%zu.%06zu:amdvi_ir_irte_val·"·"data·0x%"PRIx32·"\n",

3322

············qemu_log("%d@%zu.%06zu:amdvi_ir_irte_val·"·"data·0x%"PRIx32·"\n",

3323

·····················qemu_get_thread_id(),

3323

·····················qemu_get_thread_id(),

3324

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3324

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3325

·····················,·data);

3325

·····················,·data);

3326

#line·3328·"trace/trace-hw_i386.h"

3326

#line·3328·"trace/trace-hw_i386.h"

3327

········}·else·{

3327

········}·else·{

3329

············qemu_log("amdvi_ir_irte_val·"·"data·0x%"PRIx32·"\n",·data);

3329

············qemu_log("amdvi_ir_irte_val·"·"data·0x%"PRIx32·"\n",·data);

3330

#line·3332·"trace/trace-hw_i386.h"

3330

#line·3332·"trace/trace-hw_i386.h"

3331

········}

3331

········}

3332

····}

3332

····}

3333

}

3333

}

3334

static·inline·void·trace_amdvi_ir_irte_val(uint32_t·data)

3334

static·inline·void·trace_amdvi_ir_irte_val(uint32_t·data)

3346

static·inline·void·_nocheck__trace_amdvi_ir_err(const·char·*·str)

3346

static·inline·void·_nocheck__trace_amdvi_ir_err(const·char·*·str)

3347

{

3347

{

3348

····if·(trace_event_get_state(TRACE_AMDVI_IR_ERR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3348

····if·(trace_event_get_state(TRACE_AMDVI_IR_ERR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3349

········if·(message_with_timestamp)·{

3349

········if·(message_with_timestamp)·{

3350

············struct·timeval·_now;

3350

············struct·timeval·_now;

3351

············gettimeofday(&_now,·NULL);

3351

············gettimeofday(&_now,·NULL);

3353

············qemu_log("%d@%zu.%06zu:amdvi_ir_err·"·"%s"·"\n",

3353

············qemu_log("%d@%zu.%06zu:amdvi_ir_err·"·"%s"·"\n",

3354

·····················qemu_get_thread_id(),

3354

·····················qemu_get_thread_id(),

3355

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3355

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3356

·····················,·str);

3356

·····················,·str);

3357

#line·3359·"trace/trace-hw_i386.h"

3357

#line·3359·"trace/trace-hw_i386.h"

3358

········}·else·{

3358

········}·else·{

3360

············qemu_log("amdvi_ir_err·"·"%s"·"\n",·str);

3360

············qemu_log("amdvi_ir_err·"·"%s"·"\n",·str);

3361

#line·3363·"trace/trace-hw_i386.h"

3361

#line·3363·"trace/trace-hw_i386.h"

3362

········}

3362

········}

3363

····}

3363

····}

3364

}

3364

}

3365

static·inline·void·trace_amdvi_ir_err(const·char·*·str)

3365

static·inline·void·trace_amdvi_ir_err(const·char·*·str)

3377

static·inline·void·_nocheck__trace_amdvi_ir_intctl(uint8_t·val)

3377

static·inline·void·_nocheck__trace_amdvi_ir_intctl(uint8_t·val)

3378

{

3378

{

3379

····if·(trace_event_get_state(TRACE_AMDVI_IR_INTCTL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3379

····if·(trace_event_get_state(TRACE_AMDVI_IR_INTCTL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3380

········if·(message_with_timestamp)·{

3380

········if·(message_with_timestamp)·{

3381

············struct·timeval·_now;

3381

············struct·timeval·_now;

3382

············gettimeofday(&_now,·NULL);

3382

············gettimeofday(&_now,·NULL);

3384

············qemu_log("%d@%zu.%06zu:amdvi_ir_intctl·"·"int_ctl·0x%"PRIx8·"\n",

3384

············qemu_log("%d@%zu.%06zu:amdvi_ir_intctl·"·"int_ctl·0x%"PRIx8·"\n",

3385

·····················qemu_get_thread_id(),

3385

·····················qemu_get_thread_id(),

3386

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3386

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3387

·····················,·val);

3387

·····················,·val);

3388

#line·3390·"trace/trace-hw_i386.h"

3388

#line·3390·"trace/trace-hw_i386.h"

3389

········}·else·{

3389

········}·else·{

3391

············qemu_log("amdvi_ir_intctl·"·"int_ctl·0x%"PRIx8·"\n",·val);

3391

············qemu_log("amdvi_ir_intctl·"·"int_ctl·0x%"PRIx8·"\n",·val);

3392

#line·3394·"trace/trace-hw_i386.h"

3392

#line·3394·"trace/trace-hw_i386.h"

3393

········}

3393

········}

3394

····}

3394

····}

3395

}

3395

}

3396

static·inline·void·trace_amdvi_ir_intctl(uint8_t·val)

3396

static·inline·void·trace_amdvi_ir_intctl(uint8_t·val)

3408

static·inline·void·_nocheck__trace_amdvi_ir_target_abort(const·char·*·str)

3408

static·inline·void·_nocheck__trace_amdvi_ir_target_abort(const·char·*·str)

3409

{

3409

{

3410

····if·(trace_event_get_state(TRACE_AMDVI_IR_TARGET_ABORT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3410

····if·(trace_event_get_state(TRACE_AMDVI_IR_TARGET_ABORT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3411

········if·(message_with_timestamp)·{

3411

········if·(message_with_timestamp)·{

3412

············struct·timeval·_now;

3412

············struct·timeval·_now;

3413

············gettimeofday(&_now,·NULL);

3413

············gettimeofday(&_now,·NULL);

3415

············qemu_log("%d@%zu.%06zu:amdvi_ir_target_abort·"·"%s"·"\n",

3415

············qemu_log("%d@%zu.%06zu:amdvi_ir_target_abort·"·"%s"·"\n",

3416

·····················qemu_get_thread_id(),

3416

·····················qemu_get_thread_id(),

3417

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3417

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3418

·····················,·str);

3418

·····················,·str);

3419

#line·3421·"trace/trace-hw_i386.h"

3419

#line·3421·"trace/trace-hw_i386.h"

3420

········}·else·{

3420

········}·else·{

3422

············qemu_log("amdvi_ir_target_abort·"·"%s"·"\n",·str);

3422

············qemu_log("amdvi_ir_target_abort·"·"%s"·"\n",·str);

3423

#line·3425·"trace/trace-hw_i386.h"

3423

#line·3425·"trace/trace-hw_i386.h"

3424

········}

3424

········}

3425

····}

3425

····}

3426

}

3426

}

3427

static·inline·void·trace_amdvi_ir_target_abort(const·char·*·str)

3427

static·inline·void·trace_amdvi_ir_target_abort(const·char·*·str)

3439

static·inline·void·_nocheck__trace_amdvi_ir_delivery_mode(const·char·*·str)

3439

static·inline·void·_nocheck__trace_amdvi_ir_delivery_mode(const·char·*·str)

3440

{

3440

{

3441

····if·(trace_event_get_state(TRACE_AMDVI_IR_DELIVERY_MODE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3441

····if·(trace_event_get_state(TRACE_AMDVI_IR_DELIVERY_MODE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3442

········if·(message_with_timestamp)·{

3442

········if·(message_with_timestamp)·{

3443

············struct·timeval·_now;

3443

············struct·timeval·_now;

3444

············gettimeofday(&_now,·NULL);

3444

············gettimeofday(&_now,·NULL);

3446

············qemu_log("%d@%zu.%06zu:amdvi_ir_delivery_mode·"·"%s"·"\n",

3446

············qemu_log("%d@%zu.%06zu:amdvi_ir_delivery_mode·"·"%s"·"\n",

3447

·····················qemu_get_thread_id(),

3447

·····················qemu_get_thread_id(),

3448

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3448

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3449

·····················,·str);

3449

·····················,·str);

3450

#line·3452·"trace/trace-hw_i386.h"

3450

#line·3452·"trace/trace-hw_i386.h"

3451

········}·else·{

3451

········}·else·{

3453

············qemu_log("amdvi_ir_delivery_mode·"·"%s"·"\n",·str);

3453

············qemu_log("amdvi_ir_delivery_mode·"·"%s"·"\n",·str);

3454

#line·3456·"trace/trace-hw_i386.h"

3454

#line·3456·"trace/trace-hw_i386.h"

3455

········}

3455

········}

3456

····}

3456

····}

3457

}

3457

}

3458

static·inline·void·trace_amdvi_ir_delivery_mode(const·char·*·str)

3458

static·inline·void·trace_amdvi_ir_delivery_mode(const·char·*·str)

3470

static·inline·void·_nocheck__trace_amdvi_ir_irte_ga_val(uint64_t·hi,·uint64_t·lo)

3470

static·inline·void·_nocheck__trace_amdvi_ir_irte_ga_val(uint64_t·hi,·uint64_t·lo)

3471

{

3471

{

3472

····if·(trace_event_get_state(TRACE_AMDVI_IR_IRTE_GA_VAL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3472

····if·(trace_event_get_state(TRACE_AMDVI_IR_IRTE_GA_VAL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3473

········if·(message_with_timestamp)·{

3473

········if·(message_with_timestamp)·{

3474

············struct·timeval·_now;

3474

············struct·timeval·_now;

3475

············gettimeofday(&_now,·NULL);

3475

············gettimeofday(&_now,·NULL);

3477

············qemu_log("%d@%zu.%06zu:amdvi_ir_irte_ga_val·"·"hi·0x%"PRIx64"·lo·0x%"PRIx64·"\n",

3477

············qemu_log("%d@%zu.%06zu:amdvi_ir_irte_ga_val·"·"hi·0x%"PRIx64"·lo·0x%"PRIx64·"\n",

3478

·····················qemu_get_thread_id(),

3478

·····················qemu_get_thread_id(),

3479

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3479

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3480

·····················,·hi,·lo);

3480

·····················,·hi,·lo);

3481

#line·3483·"trace/trace-hw_i386.h"

3481

#line·3483·"trace/trace-hw_i386.h"

3482

········}·else·{

3482

········}·else·{

3484

············qemu_log("amdvi_ir_irte_ga_val·"·"hi·0x%"PRIx64"·lo·0x%"PRIx64·"\n",·hi,·lo);

3484

············qemu_log("amdvi_ir_irte_ga_val·"·"hi·0x%"PRIx64"·lo·0x%"PRIx64·"\n",·hi,·lo);

3485

#line·3487·"trace/trace-hw_i386.h"

3485

#line·3487·"trace/trace-hw_i386.h"

3486

········}

3486

········}

3487

····}

3487

····}

3488

}

3488

}

3489

static·inline·void·trace_amdvi_ir_irte_ga_val(uint64_t·hi,·uint64_t·lo)

3489

static·inline·void·trace_amdvi_ir_irte_ga_val(uint64_t·hi,·uint64_t·lo)

3501

static·inline·void·_nocheck__trace_vmport_register(unsigned·char·command,·void·*·func,·void·*·opaque)

3501

static·inline·void·_nocheck__trace_vmport_register(unsigned·char·command,·void·*·func,·void·*·opaque)

3502

{

3502

{

3503

····if·(trace_event_get_state(TRACE_VMPORT_REGISTER)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3503

····if·(trace_event_get_state(TRACE_VMPORT_REGISTER)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3504

········if·(message_with_timestamp)·{

3504

········if·(message_with_timestamp)·{

3505

············struct·timeval·_now;

3505

············struct·timeval·_now;

3506

············gettimeofday(&_now,·NULL);

3506

············gettimeofday(&_now,·NULL);

3508

············qemu_log("%d@%zu.%06zu:vmport_register·"·"command:·0x%02x·func:·%p·opaque:·%p"·"\n",

3508

············qemu_log("%d@%zu.%06zu:vmport_register·"·"command:·0x%02x·func:·%p·opaque:·%p"·"\n",

3509

·····················qemu_get_thread_id(),

3509

·····················qemu_get_thread_id(),

3510

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3510

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3511

·····················,·command,·func,·opaque);

3511

·····················,·command,·func,·opaque);

3512

#line·3514·"trace/trace-hw_i386.h"

3512

#line·3514·"trace/trace-hw_i386.h"

3513

········}·else·{

3513

········}·else·{

3515

············qemu_log("vmport_register·"·"command:·0x%02x·func:·%p·opaque:·%p"·"\n",·command,·func,·opaque);

3515

············qemu_log("vmport_register·"·"command:·0x%02x·func:·%p·opaque:·%p"·"\n",·command,·func,·opaque);

3516

#line·3518·"trace/trace-hw_i386.h"

3516

#line·3518·"trace/trace-hw_i386.h"

3517

········}

3517

········}

3518

····}

3518

····}

3519

}

3519

}

3520

static·inline·void·trace_vmport_register(unsigned·char·command,·void·*·func,·void·*·opaque)

3520

static·inline·void·trace_vmport_register(unsigned·char·command,·void·*·func,·void·*·opaque)

3532

static·inline·void·_nocheck__trace_vmport_command(unsigned·char·command)

3532

static·inline·void·_nocheck__trace_vmport_command(unsigned·char·command)

3533

{

3533

{

3534

····if·(trace_event_get_state(TRACE_VMPORT_COMMAND)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3534

····if·(trace_event_get_state(TRACE_VMPORT_COMMAND)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3535

········if·(message_with_timestamp)·{

3535

········if·(message_with_timestamp)·{

3536

············struct·timeval·_now;

3536

············struct·timeval·_now;

3537

············gettimeofday(&_now,·NULL);

3537

············gettimeofday(&_now,·NULL);

3539

············qemu_log("%d@%zu.%06zu:vmport_command·"·"command:·0x%02x"·"\n",

3539

············qemu_log("%d@%zu.%06zu:vmport_command·"·"command:·0x%02x"·"\n",

3540

·····················qemu_get_thread_id(),

3540

·····················qemu_get_thread_id(),

3541

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3541

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3542

·····················,·command);

3542

·····················,·command);

3543

#line·3545·"trace/trace-hw_i386.h"

3543

#line·3545·"trace/trace-hw_i386.h"

3544

········}·else·{

3544

········}·else·{

3546

············qemu_log("vmport_command·"·"command:·0x%02x"·"\n",·command);

3546

············qemu_log("vmport_command·"·"command:·0x%02x"·"\n",·command);

3547

#line·3549·"trace/trace-hw_i386.h"

3547

#line·3549·"trace/trace-hw_i386.h"

3548

········}

3548

········}

3549

····}

3549

····}

3550

}

3550

}

3551

static·inline·void·trace_vmport_command(unsigned·char·command)

3551

static·inline·void·trace_vmport_command(unsigned·char·command)

3563

static·inline·void·_nocheck__trace_x86_gsi_interrupt(int·irqn,·int·level)

3563

static·inline·void·_nocheck__trace_x86_gsi_interrupt(int·irqn,·int·level)

3564

{

3564

{

3565

····if·(trace_event_get_state(TRACE_X86_GSI_INTERRUPT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3565

····if·(trace_event_get_state(TRACE_X86_GSI_INTERRUPT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3566

········if·(message_with_timestamp)·{

3566

········if·(message_with_timestamp)·{

3567

············struct·timeval·_now;

3567

············struct·timeval·_now;

3568

············gettimeofday(&_now,·NULL);

3568

············gettimeofday(&_now,·NULL);

3570

············qemu_log("%d@%zu.%06zu:x86_gsi_interrupt·"·"GSI·interrupt·#%d·level:%d"·"\n",

3570

············qemu_log("%d@%zu.%06zu:x86_gsi_interrupt·"·"GSI·interrupt·#%d·level:%d"·"\n",

3571

·····················qemu_get_thread_id(),

3571

·····················qemu_get_thread_id(),

3572

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3572

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3573

·····················,·irqn,·level);

3573

·····················,·irqn,·level);

3574

#line·3576·"trace/trace-hw_i386.h"

3574

#line·3576·"trace/trace-hw_i386.h"

3575

········}·else·{

3575

········}·else·{

3577

············qemu_log("x86_gsi_interrupt·"·"GSI·interrupt·#%d·level:%d"·"\n",·irqn,·level);

3577

············qemu_log("x86_gsi_interrupt·"·"GSI·interrupt·#%d·level:%d"·"\n",·irqn,·level);

3578

#line·3580·"trace/trace-hw_i386.h"

3578

#line·3580·"trace/trace-hw_i386.h"

3579

········}

3579

········}

3580

····}

3580

····}

3581

}

3581

}

3582

static·inline·void·trace_x86_gsi_interrupt(int·irqn,·int·level)

3582

static·inline·void·trace_x86_gsi_interrupt(int·irqn,·int·level)

3594

static·inline·void·_nocheck__trace_x86_pic_interrupt(int·irqn,·int·level)

3594

static·inline·void·_nocheck__trace_x86_pic_interrupt(int·irqn,·int·level)

3595

{

3595

{

3596

····if·(trace_event_get_state(TRACE_X86_PIC_INTERRUPT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3596

····if·(trace_event_get_state(TRACE_X86_PIC_INTERRUPT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3597

········if·(message_with_timestamp)·{

3597

········if·(message_with_timestamp)·{

3598

············struct·timeval·_now;

3598

············struct·timeval·_now;

3599

············gettimeofday(&_now,·NULL);

3599

············gettimeofday(&_now,·NULL);

3601

············qemu_log("%d@%zu.%06zu:x86_pic_interrupt·"·"PIC·interrupt·#%d·level:%d"·"\n",

3601

············qemu_log("%d@%zu.%06zu:x86_pic_interrupt·"·"PIC·interrupt·#%d·level:%d"·"\n",

3602

·····················qemu_get_thread_id(),

3602

·····················qemu_get_thread_id(),

3603

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3603

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3604

·····················,·irqn,·level);

3604

·····················,·irqn,·level);

3605

#line·3607·"trace/trace-hw_i386.h"

3605

#line·3607·"trace/trace-hw_i386.h"

3606

········}·else·{

3606

········}·else·{

3608

············qemu_log("x86_pic_interrupt·"·"PIC·interrupt·#%d·level:%d"·"\n",·irqn,·level);

3608

············qemu_log("x86_pic_interrupt·"·"PIC·interrupt·#%d·level:%d"·"\n",·irqn,·level);

3609

#line·3611·"trace/trace-hw_i386.h"

3609

#line·3611·"trace/trace-hw_i386.h"

3610

········}

3610

········}

3611

····}

3611

····}

3612

}

3612

}

3613

static·inline·void·trace_x86_pic_interrupt(int·irqn,·int·level)

3613

static·inline·void·trace_x86_pic_interrupt(int·irqn,·int·level)

3625

static·inline·void·_nocheck__trace_port92_read(uint8_t·val)

3625

static·inline·void·_nocheck__trace_port92_read(uint8_t·val)

3626

{

3626

{

3627

····if·(trace_event_get_state(TRACE_PORT92_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3627

····if·(trace_event_get_state(TRACE_PORT92_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3628

········if·(message_with_timestamp)·{

3628

········if·(message_with_timestamp)·{

3629

············struct·timeval·_now;

3629

············struct·timeval·_now;

3630

············gettimeofday(&_now,·NULL);

3630

············gettimeofday(&_now,·NULL);

3632

············qemu_log("%d@%zu.%06zu:port92_read·"·"port92:·read·0x%02x"·"\n",

3632

············qemu_log("%d@%zu.%06zu:port92_read·"·"port92:·read·0x%02x"·"\n",

3633

·····················qemu_get_thread_id(),

3633

·····················qemu_get_thread_id(),

3634

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3634

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3635

·····················,·val);

3635

·····················,·val);

3636

#line·3638·"trace/trace-hw_i386.h"

3636

#line·3638·"trace/trace-hw_i386.h"

3637

········}·else·{

3637

········}·else·{

3639

············qemu_log("port92_read·"·"port92:·read·0x%02x"·"\n",·val);

3639

············qemu_log("port92_read·"·"port92:·read·0x%02x"·"\n",·val);

3640

#line·3642·"trace/trace-hw_i386.h"

3640

#line·3642·"trace/trace-hw_i386.h"

3641

········}

3641

········}

3642

····}

3642

····}

3643

}

3643

}

3644

static·inline·void·trace_port92_read(uint8_t·val)

3644

static·inline·void·trace_port92_read(uint8_t·val)

3656

static·inline·void·_nocheck__trace_port92_write(uint8_t·val)

3656

static·inline·void·_nocheck__trace_port92_write(uint8_t·val)

3657

{

3657

{

3658

····if·(trace_event_get_state(TRACE_PORT92_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3658

····if·(trace_event_get_state(TRACE_PORT92_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3659

········if·(message_with_timestamp)·{

3659

········if·(message_with_timestamp)·{

3660

············struct·timeval·_now;

3660

············struct·timeval·_now;

3661

············gettimeofday(&_now,·NULL);

3661

············gettimeofday(&_now,·NULL);

3663

············qemu_log("%d@%zu.%06zu:port92_write·"·"port92:·write·0x%02x"·"\n",

3663

············qemu_log("%d@%zu.%06zu:port92_write·"·"port92:·write·0x%02x"·"\n",

3664

·····················qemu_get_thread_id(),

3664

·····················qemu_get_thread_id(),

3665

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3665

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3666

·····················,·val);

3666

·····················,·val);

3667

#line·3669·"trace/trace-hw_i386.h"

3667

#line·3669·"trace/trace-hw_i386.h"

3668

········}·else·{

3668

········}·else·{

3670

············qemu_log("port92_write·"·"port92:·write·0x%02x"·"\n",·val);

3670

············qemu_log("port92_write·"·"port92:·write·0x%02x"·"\n",·val);

3671

#line·3673·"trace/trace-hw_i386.h"

3671

#line·3673·"trace/trace-hw_i386.h"

3672

········}

3672

········}

3673

····}

3673

····}

3674

}

3674

}

3675

static·inline·void·trace_port92_write(uint8_t·val)

3675

static·inline·void·trace_port92_write(uint8_t·val)