/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

306

static·inline·void·_nocheck__trace_ide_ioport_read(uint32_t·addr,·const·char·*·reg,·uint32_t·val,·void·*·bus,·void·*·s)

306

static·inline·void·_nocheck__trace_ide_ioport_read(uint32_t·addr,·const·char·*·reg,·uint32_t·val,·void·*·bus,·void·*·s)

307

{

307

{

308

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

308

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

309

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

309

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

310

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

310

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

311

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

311

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

313

············qemu_log("%d@%zu.%06zu:ide_ioport_read·"·"IDE·PIO·rd·@·0x%"PRIx32"·(%s);·val·0x%02"PRIx32";·bus·%p·IDEState·%p"·"\n",

313

············qemu_log("%d@%zu.%06zu:ide_ioport_read·"·"IDE·PIO·rd·@·0x%"PRIx32"·(%s);·val·0x%02"PRIx32";·bus·%p·IDEState·%p"·"\n",

314

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

314

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

315

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

315

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

316

·····················,·addr,·reg,·val,·bus,·s);

316

·····················,·addr,·reg,·val,·bus,·s);

317

#line·319·"trace/trace-hw_ide.h"

317

#line·319·"trace/trace-hw_ide.h"

318

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

318

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

320

············qemu_log("ide_ioport_read·"·"IDE·PIO·rd·@·0x%"PRIx32"·(%s);·val·0x%02"PRIx32";·bus·%p·IDEState·%p"·"\n",·addr,·reg,·val,·bus,·s);

320

············qemu_log("ide_ioport_read·"·"IDE·PIO·rd·@·0x%"PRIx32"·(%s);·val·0x%02"PRIx32";·bus·%p·IDEState·%p"·"\n",·addr,·reg,·val,·bus,·s);

321

#line·323·"trace/trace-hw_ide.h"

321

#line·323·"trace/trace-hw_ide.h"

322

········}

322

········}

323

····}

323

····}

324

}

324

}

325

static·inline·void·trace_ide_ioport_read(uint32_t·addr,·const·char·*·reg,·uint32_t·val,·void·*·bus,·void·*·s)

325

static·inline·void·trace_ide_ioport_read(uint32_t·addr,·const·char·*·reg,·uint32_t·val,·void·*·bus,·void·*·s)

337

static·inline·void·_nocheck__trace_ide_ioport_write(uint32_t·addr,·const·char·*·reg,·uint32_t·val,·void·*·bus,·void·*·s)

337

static·inline·void·_nocheck__trace_ide_ioport_write(uint32_t·addr,·const·char·*·reg,·uint32_t·val,·void·*·bus,·void·*·s)

338

{

338

{

339

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

339

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

340

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

340

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

341

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

341

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

342

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

342

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

344

············qemu_log("%d@%zu.%06zu:ide_ioport_write·"·"IDE·PIO·wr·@·0x%"PRIx32"·(%s);·val·0x%02"PRIx32";·bus·%p·IDEState·%p"·"\n",

344

············qemu_log("%d@%zu.%06zu:ide_ioport_write·"·"IDE·PIO·wr·@·0x%"PRIx32"·(%s);·val·0x%02"PRIx32";·bus·%p·IDEState·%p"·"\n",

345

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

345

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

346

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

346

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

347

·····················,·addr,·reg,·val,·bus,·s);

347

·····················,·addr,·reg,·val,·bus,·s);

348

#line·350·"trace/trace-hw_ide.h"

348

#line·350·"trace/trace-hw_ide.h"

349

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

349

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

351

············qemu_log("ide_ioport_write·"·"IDE·PIO·wr·@·0x%"PRIx32"·(%s);·val·0x%02"PRIx32";·bus·%p·IDEState·%p"·"\n",·addr,·reg,·val,·bus,·s);

351

············qemu_log("ide_ioport_write·"·"IDE·PIO·wr·@·0x%"PRIx32"·(%s);·val·0x%02"PRIx32";·bus·%p·IDEState·%p"·"\n",·addr,·reg,·val,·bus,·s);

352

#line·354·"trace/trace-hw_ide.h"

352

#line·354·"trace/trace-hw_ide.h"

353

········}

353

········}

354

····}

354

····}

355

}

355

}

356

static·inline·void·trace_ide_ioport_write(uint32_t·addr,·const·char·*·reg,·uint32_t·val,·void·*·bus,·void·*·s)

356

static·inline·void·trace_ide_ioport_write(uint32_t·addr,·const·char·*·reg,·uint32_t·val,·void·*·bus,·void·*·s)

368

static·inline·void·_nocheck__trace_ide_status_read(uint32_t·addr,·uint32_t·val,·void·*·bus,·void·*·s)

368

static·inline·void·_nocheck__trace_ide_status_read(uint32_t·addr,·uint32_t·val,·void·*·bus,·void·*·s)

369

{

369

{

370

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

370

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

371

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

371

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

372

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

372

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

373

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

373

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

375

············qemu_log("%d@%zu.%06zu:ide_status_read·"·"IDE·PIO·rd·@·0x%"PRIx32"·(Alt·Status);·val·0x%02"PRIx32";·bus·%p;·IDEState·%p"·"\n",

375

············qemu_log("%d@%zu.%06zu:ide_status_read·"·"IDE·PIO·rd·@·0x%"PRIx32"·(Alt·Status);·val·0x%02"PRIx32";·bus·%p;·IDEState·%p"·"\n",

376

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

376

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

377

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

377

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

378

·····················,·addr,·val,·bus,·s);

378

·····················,·addr,·val,·bus,·s);

379

#line·381·"trace/trace-hw_ide.h"

379

#line·381·"trace/trace-hw_ide.h"

380

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

380

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

382

············qemu_log("ide_status_read·"·"IDE·PIO·rd·@·0x%"PRIx32"·(Alt·Status);·val·0x%02"PRIx32";·bus·%p;·IDEState·%p"·"\n",·addr,·val,·bus,·s);

382

············qemu_log("ide_status_read·"·"IDE·PIO·rd·@·0x%"PRIx32"·(Alt·Status);·val·0x%02"PRIx32";·bus·%p;·IDEState·%p"·"\n",·addr,·val,·bus,·s);

383

#line·385·"trace/trace-hw_ide.h"

383

#line·385·"trace/trace-hw_ide.h"

384

········}

384

········}

385

····}

385

····}

386

}

386

}

387

static·inline·void·trace_ide_status_read(uint32_t·addr,·uint32_t·val,·void·*·bus,·void·*·s)

387

static·inline·void·trace_ide_status_read(uint32_t·addr,·uint32_t·val,·void·*·bus,·void·*·s)

399

static·inline·void·_nocheck__trace_ide_ctrl_write(uint32_t·addr,·uint32_t·val,·void·*·bus)

399

static·inline·void·_nocheck__trace_ide_ctrl_write(uint32_t·addr,·uint32_t·val,·void·*·bus)

400

{

400

{

401

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

401

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

402

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

402

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

403

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

403

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

404

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

404

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

406

············qemu_log("%d@%zu.%06zu:ide_ctrl_write·"·"IDE·PIO·wr·@·0x%"PRIx32"·(Device·Control);·val·0x%02"PRIx32";·bus·%p"·"\n",

406

············qemu_log("%d@%zu.%06zu:ide_ctrl_write·"·"IDE·PIO·wr·@·0x%"PRIx32"·(Device·Control);·val·0x%02"PRIx32";·bus·%p"·"\n",

407

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

407

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

408

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

408

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

409

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

409

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

410

#line·412·"trace/trace-hw_ide.h"

410

#line·412·"trace/trace-hw_ide.h"

411

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

411

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

413

············qemu_log("ide_ctrl_write·"·"IDE·PIO·wr·@·0x%"PRIx32"·(Device·Control);·val·0x%02"PRIx32";·bus·%p"·"\n",·addr,·val,·bus);

413

············qemu_log("ide_ctrl_write·"·"IDE·PIO·wr·@·0x%"PRIx32"·(Device·Control);·val·0x%02"PRIx32";·bus·%p"·"\n",·addr,·val,·bus);

414

#line·416·"trace/trace-hw_ide.h"

414

#line·416·"trace/trace-hw_ide.h"

415

········}

415

········}

416

····}

416

····}

417

}

417

}

418

static·inline·void·trace_ide_ctrl_write(uint32_t·addr,·uint32_t·val,·void·*·bus)

418

static·inline·void·trace_ide_ctrl_write(uint32_t·addr,·uint32_t·val,·void·*·bus)

430

static·inline·void·_nocheck__trace_ide_data_readw(uint32_t·addr,·uint32_t·val,·void·*·bus,·void·*·s)

430

static·inline·void·_nocheck__trace_ide_data_readw(uint32_t·addr,·uint32_t·val,·void·*·bus,·void·*·s)

431

{

431

{

432

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

432

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

433

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

433

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

434

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

434

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

435

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

435

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

437

············qemu_log("%d@%zu.%06zu:ide_data_readw·"·"IDE·PIO·rd·@·0x%"PRIx32"·(Data:·Word);·val·0x%04"PRIx32";·bus·%p;·IDEState·%p"·"\n",

437

············qemu_log("%d@%zu.%06zu:ide_data_readw·"·"IDE·PIO·rd·@·0x%"PRIx32"·(Data:·Word);·val·0x%04"PRIx32";·bus·%p;·IDEState·%p"·"\n",

438

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

438

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

439

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

439

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

440

·····················,·addr,·val,·bus,·s);

440

·····················,·addr,·val,·bus,·s);

441

#line·443·"trace/trace-hw_ide.h"

441

#line·443·"trace/trace-hw_ide.h"

442

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

442

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

444

············qemu_log("ide_data_readw·"·"IDE·PIO·rd·@·0x%"PRIx32"·(Data:·Word);·val·0x%04"PRIx32";·bus·%p;·IDEState·%p"·"\n",·addr,·val,·bus,·s);

444

············qemu_log("ide_data_readw·"·"IDE·PIO·rd·@·0x%"PRIx32"·(Data:·Word);·val·0x%04"PRIx32";·bus·%p;·IDEState·%p"·"\n",·addr,·val,·bus,·s);

445

#line·447·"trace/trace-hw_ide.h"

445

#line·447·"trace/trace-hw_ide.h"

446

········}

446

········}

447

····}

447

····}

448

}

448

}

449

static·inline·void·trace_ide_data_readw(uint32_t·addr,·uint32_t·val,·void·*·bus,·void·*·s)

449

static·inline·void·trace_ide_data_readw(uint32_t·addr,·uint32_t·val,·void·*·bus,·void·*·s)

461

static·inline·void·_nocheck__trace_ide_data_writew(uint32_t·addr,·uint32_t·val,·void·*·bus,·void·*·s)

461

static·inline·void·_nocheck__trace_ide_data_writew(uint32_t·addr,·uint32_t·val,·void·*·bus,·void·*·s)

462

{

462

{

463

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

463

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

464

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

464

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

465

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

465

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

466

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

466

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

468

············qemu_log("%d@%zu.%06zu:ide_data_writew·"·"IDE·PIO·wr·@·0x%"PRIx32"·(Data:·Word);·val·0x%04"PRIx32";·bus·%p;·IDEState·%p"·"\n",

468

············qemu_log("%d@%zu.%06zu:ide_data_writew·"·"IDE·PIO·wr·@·0x%"PRIx32"·(Data:·Word);·val·0x%04"PRIx32";·bus·%p;·IDEState·%p"·"\n",

469

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

469

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

470

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

470

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

471

·····················,·addr,·val,·bus,·s);

471

·····················,·addr,·val,·bus,·s);

472

#line·474·"trace/trace-hw_ide.h"

472

#line·474·"trace/trace-hw_ide.h"

473

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

473

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

475

············qemu_log("ide_data_writew·"·"IDE·PIO·wr·@·0x%"PRIx32"·(Data:·Word);·val·0x%04"PRIx32";·bus·%p;·IDEState·%p"·"\n",·addr,·val,·bus,·s);

475

············qemu_log("ide_data_writew·"·"IDE·PIO·wr·@·0x%"PRIx32"·(Data:·Word);·val·0x%04"PRIx32";·bus·%p;·IDEState·%p"·"\n",·addr,·val,·bus,·s);

476

#line·478·"trace/trace-hw_ide.h"

476

#line·478·"trace/trace-hw_ide.h"

477

········}

477

········}

478

····}

478

····}

479

}

479

}

480

static·inline·void·trace_ide_data_writew(uint32_t·addr,·uint32_t·val,·void·*·bus,·void·*·s)

480

static·inline·void·trace_ide_data_writew(uint32_t·addr,·uint32_t·val,·void·*·bus,·void·*·s)

492

static·inline·void·_nocheck__trace_ide_data_readl(uint32_t·addr,·uint32_t·val,·void·*·bus,·void·*·s)

492

static·inline·void·_nocheck__trace_ide_data_readl(uint32_t·addr,·uint32_t·val,·void·*·bus,·void·*·s)

493

{

493

{

494

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

494

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

495

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

495

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

496

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

496

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

497

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

497

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

499

············qemu_log("%d@%zu.%06zu:ide_data_readl·"·"IDE·PIO·rd·@·0x%"PRIx32"·(Data:·Long);·val·0x%08"PRIx32";·bus·%p;·IDEState·%p"·"\n",

499

············qemu_log("%d@%zu.%06zu:ide_data_readl·"·"IDE·PIO·rd·@·0x%"PRIx32"·(Data:·Long);·val·0x%08"PRIx32";·bus·%p;·IDEState·%p"·"\n",

500

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

500

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

501

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

501

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

502

·····················,·addr,·val,·bus,·s);

502

·····················,·addr,·val,·bus,·s);

503

#line·505·"trace/trace-hw_ide.h"

503

#line·505·"trace/trace-hw_ide.h"

504

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

504

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

506

············qemu_log("ide_data_readl·"·"IDE·PIO·rd·@·0x%"PRIx32"·(Data:·Long);·val·0x%08"PRIx32";·bus·%p;·IDEState·%p"·"\n",·addr,·val,·bus,·s);

506

············qemu_log("ide_data_readl·"·"IDE·PIO·rd·@·0x%"PRIx32"·(Data:·Long);·val·0x%08"PRIx32";·bus·%p;·IDEState·%p"·"\n",·addr,·val,·bus,·s);

507

#line·509·"trace/trace-hw_ide.h"

507

#line·509·"trace/trace-hw_ide.h"

508

········}

508

········}

509

····}

509

····}

510

}

510

}

511

static·inline·void·trace_ide_data_readl(uint32_t·addr,·uint32_t·val,·void·*·bus,·void·*·s)

511

static·inline·void·trace_ide_data_readl(uint32_t·addr,·uint32_t·val,·void·*·bus,·void·*·s)

523

static·inline·void·_nocheck__trace_ide_data_writel(uint32_t·addr,·uint32_t·val,·void·*·bus,·void·*·s)

523

static·inline·void·_nocheck__trace_ide_data_writel(uint32_t·addr,·uint32_t·val,·void·*·bus,·void·*·s)

524

{

524

{

525

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

525

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

526

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

526

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

527

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

527

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

528

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

528

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

530

············qemu_log("%d@%zu.%06zu:ide_data_writel·"·"IDE·PIO·wr·@·0x%"PRIx32"·(Data:·Long);·val·0x%08"PRIx32";·bus·%p;·IDEState·%p"·"\n",

530

············qemu_log("%d@%zu.%06zu:ide_data_writel·"·"IDE·PIO·wr·@·0x%"PRIx32"·(Data:·Long);·val·0x%08"PRIx32";·bus·%p;·IDEState·%p"·"\n",

531

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

531

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

532

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

532

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

533

·····················,·addr,·val,·bus,·s);

533

·····················,·addr,·val,·bus,·s);

534

#line·536·"trace/trace-hw_ide.h"

534

#line·536·"trace/trace-hw_ide.h"

535

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

535

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

537

············qemu_log("ide_data_writel·"·"IDE·PIO·wr·@·0x%"PRIx32"·(Data:·Long);·val·0x%08"PRIx32";·bus·%p;·IDEState·%p"·"\n",·addr,·val,·bus,·s);

537

············qemu_log("ide_data_writel·"·"IDE·PIO·wr·@·0x%"PRIx32"·(Data:·Long);·val·0x%08"PRIx32";·bus·%p;·IDEState·%p"·"\n",·addr,·val,·bus,·s);

538

#line·540·"trace/trace-hw_ide.h"

538

#line·540·"trace/trace-hw_ide.h"

539

········}

539

········}

540

····}

540

····}

541

}

541

}

542

static·inline·void·trace_ide_data_writel(uint32_t·addr,·uint32_t·val,·void·*·bus,·void·*·s)

542

static·inline·void·trace_ide_data_writel(uint32_t·addr,·uint32_t·val,·void·*·bus,·void·*·s)

554

static·inline·void·_nocheck__trace_ide_exec_cmd(void·*·bus,·void·*·state,·uint32_t·cmd)

554

static·inline·void·_nocheck__trace_ide_exec_cmd(void·*·bus,·void·*·state,·uint32_t·cmd)

555

{

555

{

556

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

556

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

557

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

557

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

558

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

558

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

559

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

559

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

561

············qemu_log("%d@%zu.%06zu:ide_exec_cmd·"·"IDE·exec·cmd:·bus·%p;·state·%p;·cmd·0x%02x"·"\n",

561

············qemu_log("%d@%zu.%06zu:ide_exec_cmd·"·"IDE·exec·cmd:·bus·%p;·state·%p;·cmd·0x%02x"·"\n",

562

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

562

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

563

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

563

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

564

·····················,·bus,·state,·cmd);

564

·····················,·bus,·state,·cmd);

565

#line·567·"trace/trace-hw_ide.h"

565

#line·567·"trace/trace-hw_ide.h"

566

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

566

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

568

············qemu_log("ide_exec_cmd·"·"IDE·exec·cmd:·bus·%p;·state·%p;·cmd·0x%02x"·"\n",·bus,·state,·cmd);

568

············qemu_log("ide_exec_cmd·"·"IDE·exec·cmd:·bus·%p;·state·%p;·cmd·0x%02x"·"\n",·bus,·state,·cmd);

569

#line·571·"trace/trace-hw_ide.h"

569

#line·571·"trace/trace-hw_ide.h"

570

········}

570

········}

571

····}

571

····}

572

}

572

}

573

static·inline·void·trace_ide_exec_cmd(void·*·bus,·void·*·state,·uint32_t·cmd)

573

static·inline·void·trace_ide_exec_cmd(void·*·bus,·void·*·state,·uint32_t·cmd)

585

static·inline·void·_nocheck__trace_ide_cancel_dma_sync_buffered(void·*·fn,·void·*·req)

585

static·inline·void·_nocheck__trace_ide_cancel_dma_sync_buffered(void·*·fn,·void·*·req)

586

{

586

{

587

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

587

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

588

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

588

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

589

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

589

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

590

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

590

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

592

············qemu_log("%d@%zu.%06zu:ide_cancel_dma_sync_buffered·"·"invoking·cb·%p·of·buffered·request·%p·with·-ECANCELED"·"\n",

592

············qemu_log("%d@%zu.%06zu:ide_cancel_dma_sync_buffered·"·"invoking·cb·%p·of·buffered·request·%p·with·-ECANCELED"·"\n",

593

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

593

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

594

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

594

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

595

·····················,·fn,·req);

595

·····················,·fn,·req);

596

#line·598·"trace/trace-hw_ide.h"

596

#line·598·"trace/trace-hw_ide.h"

597

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

597

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

599

············qemu_log("ide_cancel_dma_sync_buffered·"·"invoking·cb·%p·of·buffered·request·%p·with·-ECANCELED"·"\n",·fn,·req);

599

············qemu_log("ide_cancel_dma_sync_buffered·"·"invoking·cb·%p·of·buffered·request·%p·with·-ECANCELED"·"\n",·fn,·req);

600

#line·602·"trace/trace-hw_ide.h"

600

#line·602·"trace/trace-hw_ide.h"

601

········}

601

········}

602

····}

602

····}

603

}

603

}

604

static·inline·void·trace_ide_cancel_dma_sync_buffered(void·*·fn,·void·*·req)

604

static·inline·void·trace_ide_cancel_dma_sync_buffered(void·*·fn,·void·*·req)

616

static·inline·void·_nocheck__trace_ide_cancel_dma_sync_remaining(void)

616

static·inline·void·_nocheck__trace_ide_cancel_dma_sync_remaining(void)

617

{

617

{

618

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

618

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

619

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

619

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

620

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

620

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

621

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

621

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

623

············qemu_log("%d@%zu.%06zu:ide_cancel_dma_sync_remaining·"·"draining·all·remaining·requests"·"\n",

623

············qemu_log("%d@%zu.%06zu:ide_cancel_dma_sync_remaining·"·"draining·all·remaining·requests"·"\n",

624

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

624

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

625

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

625

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

626

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

626

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

627

#line·629·"trace/trace-hw_ide.h"

627

#line·629·"trace/trace-hw_ide.h"

628

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

628

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

630

············qemu_log("ide_cancel_dma_sync_remaining·"·"draining·all·remaining·requests"·"\n");

630

············qemu_log("ide_cancel_dma_sync_remaining·"·"draining·all·remaining·requests"·"\n");

631

#line·633·"trace/trace-hw_ide.h"

631

#line·633·"trace/trace-hw_ide.h"

632

········}

632

········}

633

····}

633

····}

634

}

634

}

635

static·inline·void·trace_ide_cancel_dma_sync_remaining(void)

635

static·inline·void·trace_ide_cancel_dma_sync_remaining(void)

647

static·inline·void·_nocheck__trace_ide_sector_read(int64_t·sector_num,·int·nsectors)

647

static·inline·void·_nocheck__trace_ide_sector_read(int64_t·sector_num,·int·nsectors)

648

{

648

{

649

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

649

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

650

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

650

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

651

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

651

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

652

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

652

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

654

············qemu_log("%d@%zu.%06zu:ide_sector_read·"·"sector=%"PRId64"·nsectors=%d"·"\n",

654

············qemu_log("%d@%zu.%06zu:ide_sector_read·"·"sector=%"PRId64"·nsectors=%d"·"\n",

655

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

655

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

656

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

656

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

657

·····················,·sector_num,·nsectors);

657

·····················,·sector_num,·nsectors);

658

#line·660·"trace/trace-hw_ide.h"

658

#line·660·"trace/trace-hw_ide.h"

659

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

659

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

661

············qemu_log("ide_sector_read·"·"sector=%"PRId64"·nsectors=%d"·"\n",·sector_num,·nsectors);

661

············qemu_log("ide_sector_read·"·"sector=%"PRId64"·nsectors=%d"·"\n",·sector_num,·nsectors);

662

#line·664·"trace/trace-hw_ide.h"

662

#line·664·"trace/trace-hw_ide.h"

663

········}

663

········}

664

····}

664

····}

665

}

665

}

666

static·inline·void·trace_ide_sector_read(int64_t·sector_num,·int·nsectors)

666

static·inline·void·trace_ide_sector_read(int64_t·sector_num,·int·nsectors)

678

static·inline·void·_nocheck__trace_ide_sector_write(int64_t·sector_num,·int·nsectors)

678

static·inline·void·_nocheck__trace_ide_sector_write(int64_t·sector_num,·int·nsectors)

679

{

679

{

680

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

680

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

681

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

681

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

682

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

682

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

683

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

683

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

685

············qemu_log("%d@%zu.%06zu:ide_sector_write·"·"sector=%"PRId64"·nsectors=%d"·"\n",

685

············qemu_log("%d@%zu.%06zu:ide_sector_write·"·"sector=%"PRId64"·nsectors=%d"·"\n",

686

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

686

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

687

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

687

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

688

·····················,·sector_num,·nsectors);

688

·····················,·sector_num,·nsectors);

689

#line·691·"trace/trace-hw_ide.h"

689

#line·691·"trace/trace-hw_ide.h"

690

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

690

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

692

············qemu_log("ide_sector_write·"·"sector=%"PRId64"·nsectors=%d"·"\n",·sector_num,·nsectors);

692

············qemu_log("ide_sector_write·"·"sector=%"PRId64"·nsectors=%d"·"\n",·sector_num,·nsectors);

693

#line·695·"trace/trace-hw_ide.h"

693

#line·695·"trace/trace-hw_ide.h"

694

········}

694

········}

695

····}

695

····}

696

}

696

}

697

static·inline·void·trace_ide_sector_write(int64_t·sector_num,·int·nsectors)

697

static·inline·void·trace_ide_sector_write(int64_t·sector_num,·int·nsectors)

709

static·inline·void·_nocheck__trace_ide_reset(void·*·s)

709

static·inline·void·_nocheck__trace_ide_reset(void·*·s)

710

{

710

{

711

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

711

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

712

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

712

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

713

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

713

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

714

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

714

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

716

············qemu_log("%d@%zu.%06zu:ide_reset·"·"IDEstate·%p"·"\n",

716

············qemu_log("%d@%zu.%06zu:ide_reset·"·"IDEstate·%p"·"\n",

717

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

717

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

718

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

718

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

719

·····················,·s);

719

·····················,·s);

720

#line·722·"trace/trace-hw_ide.h"

720

#line·722·"trace/trace-hw_ide.h"

721

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

721

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

723

············qemu_log("ide_reset·"·"IDEstate·%p"·"\n",·s);

723

············qemu_log("ide_reset·"·"IDEstate·%p"·"\n",·s);

724

#line·726·"trace/trace-hw_ide.h"

724

#line·726·"trace/trace-hw_ide.h"

725

········}

725

········}

726

····}

726

····}

727

}

727

}

728

static·inline·void·trace_ide_reset(void·*·s)

728

static·inline·void·trace_ide_reset(void·*·s)

740

static·inline·void·_nocheck__trace_ide_bus_reset_aio(void)

740

static·inline·void·_nocheck__trace_ide_bus_reset_aio(void)

741

{

741

{

742

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

742

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

743

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

743

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

744

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

744

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

745

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

745

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

747

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

747

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

748

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

748

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

749

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

749

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

750

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

750

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

751

#line·753·"trace/trace-hw_ide.h"

751

#line·753·"trace/trace-hw_ide.h"

752

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

752

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

754

············qemu_log("ide_bus_reset_aio·"·"aio_cancel"·"\n");

754

············qemu_log("ide_bus_reset_aio·"·"aio_cancel"·"\n");

755

#line·757·"trace/trace-hw_ide.h"

755

#line·757·"trace/trace-hw_ide.h"

756

········}

756

········}

757

····}

757

····}

758

}

758

}

759

static·inline·void·trace_ide_bus_reset_aio(void)

759

static·inline·void·trace_ide_bus_reset_aio(void)

771

static·inline·void·_nocheck__trace_ide_dma_cb(void·*·s,·int64_t·sector_num,·int·n,·const·char·*·dma)

771

static·inline·void·_nocheck__trace_ide_dma_cb(void·*·s,·int64_t·sector_num,·int·n,·const·char·*·dma)

772

{

772

{

773

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

773

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

774

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

774

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

775

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

775

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

776

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

776

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

778

············qemu_log("%d@%zu.%06zu:ide_dma_cb·"·"IDEState·%p;·sector_num=%"PRId64"·n=%d·cmd=%s"·"\n",

778

············qemu_log("%d@%zu.%06zu:ide_dma_cb·"·"IDEState·%p;·sector_num=%"PRId64"·n=%d·cmd=%s"·"\n",

779

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

779

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

780

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

780

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

781

·····················,·s,·sector_num,·n,·dma);

781

·····················,·s,·sector_num,·n,·dma);

782

#line·784·"trace/trace-hw_ide.h"

782

#line·784·"trace/trace-hw_ide.h"

783

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

783

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

785

············qemu_log("ide_dma_cb·"·"IDEState·%p;·sector_num=%"PRId64"·n=%d·cmd=%s"·"\n",·s,·sector_num,·n,·dma);

785

············qemu_log("ide_dma_cb·"·"IDEState·%p;·sector_num=%"PRId64"·n=%d·cmd=%s"·"\n",·s,·sector_num,·n,·dma);

786

#line·788·"trace/trace-hw_ide.h"

786

#line·788·"trace/trace-hw_ide.h"

787

········}

787

········}

788

····}

788

····}

789

}

789

}

790

static·inline·void·trace_ide_dma_cb(void·*·s,·int64_t·sector_num,·int·n,·const·char·*·dma)

790

static·inline·void·trace_ide_dma_cb(void·*·s,·int64_t·sector_num,·int·n,·const·char·*·dma)

802

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

802

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

803

{

803

{

804

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

804

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

805

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

805

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

806

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

806

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

807

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

807

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

809

············qemu_log("%d@%zu.%06zu:bmdma_read_cmd646·"·"bmdma:·readb·0x%"PRIx64"·:·0x%02x"·"\n",

809

············qemu_log("%d@%zu.%06zu:bmdma_read_cmd646·"·"bmdma:·readb·0x%"PRIx64"·:·0x%02x"·"\n",

810

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

810

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

811

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

811

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

812

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

812

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

813

#line·815·"trace/trace-hw_ide.h"

813

#line·815·"trace/trace-hw_ide.h"

814

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

814

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

816

············qemu_log("bmdma_read_cmd646·"·"bmdma:·readb·0x%"PRIx64"·:·0x%02x"·"\n",·addr,·val);

816

············qemu_log("bmdma_read_cmd646·"·"bmdma:·readb·0x%"PRIx64"·:·0x%02x"·"\n",·addr,·val);

817

#line·819·"trace/trace-hw_ide.h"

817

#line·819·"trace/trace-hw_ide.h"

818

········}

818

········}

819

····}

819

····}

820

}

820

}

821

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

821

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

833

static·inline·void·_nocheck__trace_bmdma_write_cmd646(uint64_t·addr,·uint64_t·val)

833

static·inline·void·_nocheck__trace_bmdma_write_cmd646(uint64_t·addr,·uint64_t·val)

834

{

834

{

835

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

835

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

836

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

836

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

837

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

837

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

838

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

838

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

840

············qemu_log("%d@%zu.%06zu:bmdma_write_cmd646·"·"bmdma:·writeb·0x%"PRIx64"·:·0x%02"PRIx64·"\n",

840

············qemu_log("%d@%zu.%06zu:bmdma_write_cmd646·"·"bmdma:·writeb·0x%"PRIx64"·:·0x%02"PRIx64·"\n",

841

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

841

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

842

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

842

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

843

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

843

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

844

#line·846·"trace/trace-hw_ide.h"

844

#line·846·"trace/trace-hw_ide.h"

845

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

845

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

847

············qemu_log("bmdma_write_cmd646·"·"bmdma:·writeb·0x%"PRIx64"·:·0x%02"PRIx64·"\n",·addr,·val);

847

············qemu_log("bmdma_write_cmd646·"·"bmdma:·writeb·0x%"PRIx64"·:·0x%02"PRIx64·"\n",·addr,·val);

848

#line·850·"trace/trace-hw_ide.h"

848

#line·850·"trace/trace-hw_ide.h"

849

········}

849

········}

850

····}

850

····}

851

}

851

}

852

static·inline·void·trace_bmdma_write_cmd646(uint64_t·addr,·uint64_t·val)

852

static·inline·void·trace_bmdma_write_cmd646(uint64_t·addr,·uint64_t·val)

864

static·inline·void·_nocheck__trace_bmdma_reset(void)

864

static·inline·void·_nocheck__trace_bmdma_reset(void)

865

{

865

{

866

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

866

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

867

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

867

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

868

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

868

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

869

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

869

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

871

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

871

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

872

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

872

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

873

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

873

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

874

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

874

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

875

#line·877·"trace/trace-hw_ide.h"

875

#line·877·"trace/trace-hw_ide.h"

876

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

876

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

878

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

878

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

879

#line·881·"trace/trace-hw_ide.h"

879

#line·881·"trace/trace-hw_ide.h"

880

········}

880

········}

881

····}

881

····}

882

}

882

}

883

static·inline·void·trace_bmdma_reset(void)

883

static·inline·void·trace_bmdma_reset(void)

895

static·inline·void·_nocheck__trace_bmdma_cmd_writeb(uint32_t·val)

895

static·inline·void·_nocheck__trace_bmdma_cmd_writeb(uint32_t·val)

896

{

896

{

897

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

897

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

898

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

898

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

899

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

899

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

900

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

900

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

902

············qemu_log("%d@%zu.%06zu:bmdma_cmd_writeb·"·"val:·0x%08x"·"\n",

902

············qemu_log("%d@%zu.%06zu:bmdma_cmd_writeb·"·"val:·0x%08x"·"\n",

903

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

903

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

904

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

904

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

905

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

905

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

906

#line·908·"trace/trace-hw_ide.h"

906

#line·908·"trace/trace-hw_ide.h"

907

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

907

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

909

············qemu_log("bmdma_cmd_writeb·"·"val:·0x%08x"·"\n",·val);

909

············qemu_log("bmdma_cmd_writeb·"·"val:·0x%08x"·"\n",·val);

910

#line·912·"trace/trace-hw_ide.h"

910

#line·912·"trace/trace-hw_ide.h"

911

········}

911

········}

912

····}

912

····}

913

}

913

}

914

static·inline·void·trace_bmdma_cmd_writeb(uint32_t·val)

914

static·inline·void·trace_bmdma_cmd_writeb(uint32_t·val)

926

static·inline·void·_nocheck__trace_bmdma_addr_read(uint64_t·data)

926

static·inline·void·_nocheck__trace_bmdma_addr_read(uint64_t·data)

927

{

927

{

928

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

928

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

929

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

929

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

930

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

930

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

931

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

931

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

933

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

933

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

934

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

934

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

935

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

935

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

936

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

936

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

937

#line·939·"trace/trace-hw_ide.h"

937

#line·939·"trace/trace-hw_ide.h"

938

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

938

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

940

············qemu_log("bmdma_addr_read·"·"data:·0x%016"PRIx64·"\n",·data);

940

············qemu_log("bmdma_addr_read·"·"data:·0x%016"PRIx64·"\n",·data);

941

#line·943·"trace/trace-hw_ide.h"

941

#line·943·"trace/trace-hw_ide.h"

942

········}

942

········}

943

····}

943

····}

944

}

944

}

945

static·inline·void·trace_bmdma_addr_read(uint64_t·data)

945

static·inline·void·trace_bmdma_addr_read(uint64_t·data)

957

static·inline·void·_nocheck__trace_bmdma_addr_write(uint64_t·data)

957

static·inline·void·_nocheck__trace_bmdma_addr_write(uint64_t·data)

958

{

958

{

959

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

959

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

960

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

960

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

961

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

961

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

962

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

962

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

964

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

964

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

965

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

965

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

966

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

966

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

967

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

967

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

968

#line·970·"trace/trace-hw_ide.h"

968

#line·970·"trace/trace-hw_ide.h"

969

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

969

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

971

············qemu_log("bmdma_addr_write·"·"data:·0x%016"PRIx64·"\n",·data);

971

············qemu_log("bmdma_addr_write·"·"data:·0x%016"PRIx64·"\n",·data);

972

#line·974·"trace/trace-hw_ide.h"

972

#line·974·"trace/trace-hw_ide.h"

973

········}

973

········}

974

····}

974

····}

975

}

975

}

976

static·inline·void·trace_bmdma_addr_write(uint64_t·data)

976

static·inline·void·trace_bmdma_addr_write(uint64_t·data)

988

static·inline·void·_nocheck__trace_bmdma_read(uint64_t·addr,·uint8_t·val)

988

static·inline·void·_nocheck__trace_bmdma_read(uint64_t·addr,·uint8_t·val)

989

{

989

{

990

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

990

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

991

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

991

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

992

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

992

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

993

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

993

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

995

············qemu_log("%d@%zu.%06zu:bmdma_read·"·"bmdma:·readb·0x%"PRIx64"·:·0x%02x"·"\n",

995

············qemu_log("%d@%zu.%06zu:bmdma_read·"·"bmdma:·readb·0x%"PRIx64"·:·0x%02x"·"\n",

996

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

996

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

997

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

997

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

998

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

998

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

999

#line·1001·"trace/trace-hw_ide.h"

999

#line·1001·"trace/trace-hw_ide.h"

1000

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

1000

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

1002

············qemu_log("bmdma_read·"·"bmdma:·readb·0x%"PRIx64"·:·0x%02x"·"\n",·addr,·val);

1002

············qemu_log("bmdma_read·"·"bmdma:·readb·0x%"PRIx64"·:·0x%02x"·"\n",·addr,·val);

1003

#line·1005·"trace/trace-hw_ide.h"

1003

#line·1005·"trace/trace-hw_ide.h"

1004

········}

1004

········}

1005

····}

1005

····}

1006

}

1006

}

1007

static·inline·void·trace_bmdma_read(uint64_t·addr,·uint8_t·val)

1007

static·inline·void·trace_bmdma_read(uint64_t·addr,·uint8_t·val)

1019

static·inline·void·_nocheck__trace_bmdma_write(uint64_t·addr,·uint64_t·val)

1019

static·inline·void·_nocheck__trace_bmdma_write(uint64_t·addr,·uint64_t·val)

1020

{

1020

{

1021

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

1021

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

1022

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

1022

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

1023

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

1023

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

1024

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

1024

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

1026

············qemu_log("%d@%zu.%06zu:bmdma_write·"·"bmdma:·writeb·0x%"PRIx64"·:·0x%02"PRIx64·"\n",

1026

············qemu_log("%d@%zu.%06zu:bmdma_write·"·"bmdma:·writeb·0x%"PRIx64"·:·0x%02"PRIx64·"\n",

1027

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

1027

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

1028

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

1028

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

1029

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

1029

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

1030

#line·1032·"trace/trace-hw_ide.h"

1030

#line·1032·"trace/trace-hw_ide.h"

1031

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

1031

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

1033

············qemu_log("bmdma_write·"·"bmdma:·writeb·0x%"PRIx64"·:·0x%02"PRIx64·"\n",·addr,·val);

1033

············qemu_log("bmdma_write·"·"bmdma:·writeb·0x%"PRIx64"·:·0x%02"PRIx64·"\n",·addr,·val);

1034

#line·1036·"trace/trace-hw_ide.h"

1034

#line·1036·"trace/trace-hw_ide.h"

1035

········}

1035

········}

1036

····}

1036

····}

1037

}

1037

}

1038

static·inline·void·trace_bmdma_write(uint64_t·addr,·uint64_t·val)

1038

static·inline·void·trace_bmdma_write(uint64_t·addr,·uint64_t·val)

1050

static·inline·void·_nocheck__trace_sii3112_read(int·size,·uint64_t·addr,·uint64_t·val)

1050

static·inline·void·_nocheck__trace_sii3112_read(int·size,·uint64_t·addr,·uint64_t·val)

1051

{

1051

{

1052

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

1052

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

1053

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

1053

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

1054

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

1054

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

1055

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

1055

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

1057

············qemu_log("%d@%zu.%06zu:sii3112_read·"·"bmdma:·read·(size·%d)·0x%"PRIx64"·:·0x%02"PRIx64·"\n",

1057

············qemu_log("%d@%zu.%06zu:sii3112_read·"·"bmdma:·read·(size·%d)·0x%"PRIx64"·:·0x%02"PRIx64·"\n",

1058

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

1058

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

1059

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

1059

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

1060

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

1060

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

1061

#line·1063·"trace/trace-hw_ide.h"

1061

#line·1063·"trace/trace-hw_ide.h"

1062

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

1062

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

1064

············qemu_log("sii3112_read·"·"bmdma:·read·(size·%d)·0x%"PRIx64"·:·0x%02"PRIx64·"\n",·size,·addr,·val);

1064

············qemu_log("sii3112_read·"·"bmdma:·read·(size·%d)·0x%"PRIx64"·:·0x%02"PRIx64·"\n",·size,·addr,·val);

1065

#line·1067·"trace/trace-hw_ide.h"

1065

#line·1067·"trace/trace-hw_ide.h"

1066

········}

1066

········}

1067

····}

1067

····}

1068

}

1068

}

1069

static·inline·void·trace_sii3112_read(int·size,·uint64_t·addr,·uint64_t·val)

1069

static·inline·void·trace_sii3112_read(int·size,·uint64_t·addr,·uint64_t·val)

1081

static·inline·void·_nocheck__trace_sii3112_write(int·size,·uint64_t·addr,·uint64_t·val)

1081

static·inline·void·_nocheck__trace_sii3112_write(int·size,·uint64_t·addr,·uint64_t·val)

1082

{

1082

{

1083

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

1083

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

1084

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

1084

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

1085

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

1085

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

1086

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

1086

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

1088

············qemu_log("%d@%zu.%06zu:sii3112_write·"·"bmdma:·write·(size·%d)·0x%"PRIx64"·:·0x%02"PRIx64·"\n",

1088

············qemu_log("%d@%zu.%06zu:sii3112_write·"·"bmdma:·write·(size·%d)·0x%"PRIx64"·:·0x%02"PRIx64·"\n",

1089

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

1089

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

1090

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

1090

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

1091

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

1091

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

1092

#line·1094·"trace/trace-hw_ide.h"

1092

#line·1094·"trace/trace-hw_ide.h"

1093

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

1093

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

1095

············qemu_log("sii3112_write·"·"bmdma:·write·(size·%d)·0x%"PRIx64"·:·0x%02"PRIx64·"\n",·size,·addr,·val);

1095

············qemu_log("sii3112_write·"·"bmdma:·write·(size·%d)·0x%"PRIx64"·:·0x%02"PRIx64·"\n",·size,·addr,·val);

1096

#line·1098·"trace/trace-hw_ide.h"

1096

#line·1098·"trace/trace-hw_ide.h"

1097

········}

1097

········}

1098

····}

1098

····}

1099

}

1099

}

1100

static·inline·void·trace_sii3112_write(int·size,·uint64_t·addr,·uint64_t·val)

1100

static·inline·void·trace_sii3112_write(int·size,·uint64_t·addr,·uint64_t·val)

1112

static·inline·void·_nocheck__trace_sii3112_set_irq(int·channel,·int·level)

1112

static·inline·void·_nocheck__trace_sii3112_set_irq(int·channel,·int·level)

1113

{

1113

{

1114

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

1114

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

1115

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

1115

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

1116

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

1116

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

1117

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

1117

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

1119

············qemu_log("%d@%zu.%06zu:sii3112_set_irq·"·"channel·%d·level·%d"·"\n",

1119

············qemu_log("%d@%zu.%06zu:sii3112_set_irq·"·"channel·%d·level·%d"·"\n",

1120

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

1120

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

1121

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

1121

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

1122

·····················,·channel,·level);

1122

·····················,·channel,·level);

1123

#line·1125·"trace/trace-hw_ide.h"

1123

#line·1125·"trace/trace-hw_ide.h"

1124

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

1124

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

1126

············qemu_log("sii3112_set_irq·"·"channel·%d·level·%d"·"\n",·channel,·level);

1126

············qemu_log("sii3112_set_irq·"·"channel·%d·level·%d"·"\n",·channel,·level);

1127

#line·1129·"trace/trace-hw_ide.h"

1127

#line·1129·"trace/trace-hw_ide.h"

1128

········}

1128

········}

1129

····}

1129

····}

1130

}

1130

}

1131

static·inline·void·trace_sii3112_set_irq(int·channel,·int·level)

1131

static·inline·void·trace_sii3112_set_irq(int·channel,·int·level)

1143

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

1143

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

1144

{

1144

{

1145

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

1145

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

1146

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

1146

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

1147

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

1147

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

1148

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

1148

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

1150

············qemu_log("%d@%zu.%06zu:bmdma_read_via·"·"bmdma:·readb·0x%"PRIx64"·:·0x%02x"·"\n",

1150

············qemu_log("%d@%zu.%06zu:bmdma_read_via·"·"bmdma:·readb·0x%"PRIx64"·:·0x%02x"·"\n",

1151

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

1151

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

1152

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

1152

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

1153

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

1153

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

1154

#line·1156·"trace/trace-hw_ide.h"

1154

#line·1156·"trace/trace-hw_ide.h"

1155

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

1155

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

1157

············qemu_log("bmdma_read_via·"·"bmdma:·readb·0x%"PRIx64"·:·0x%02x"·"\n",·addr,·val);

1157

············qemu_log("bmdma_read_via·"·"bmdma:·readb·0x%"PRIx64"·:·0x%02x"·"\n",·addr,·val);

1158

#line·1160·"trace/trace-hw_ide.h"

1158

#line·1160·"trace/trace-hw_ide.h"

1159

········}

1159

········}

1160

····}

1160

····}

1161

}

1161

}

1162

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

1162

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

1174

static·inline·void·_nocheck__trace_bmdma_write_via(uint64_t·addr,·uint64_t·val)

1174

static·inline·void·_nocheck__trace_bmdma_write_via(uint64_t·addr,·uint64_t·val)

1175

{

1175

{

1176

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

1176

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

1177

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

1177

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

1178

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

1178

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

1179

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

1179

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

1181

············qemu_log("%d@%zu.%06zu:bmdma_write_via·"·"bmdma:·writeb·0x%"PRIx64"·:·0x%02"PRIx64·"\n",

1181

············qemu_log("%d@%zu.%06zu:bmdma_write_via·"·"bmdma:·writeb·0x%"PRIx64"·:·0x%02"PRIx64·"\n",

1182

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

1182

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

1183

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

1183

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

1184

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

1184

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

1185

#line·1187·"trace/trace-hw_ide.h"

1185

#line·1187·"trace/trace-hw_ide.h"

1186

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

1186

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

1188

············qemu_log("bmdma_write_via·"·"bmdma:·writeb·0x%"PRIx64"·:·0x%02"PRIx64·"\n",·addr,·val);

1188

············qemu_log("bmdma_write_via·"·"bmdma:·writeb·0x%"PRIx64"·:·0x%02"PRIx64·"\n",·addr,·val);

1189

#line·1191·"trace/trace-hw_ide.h"

1189

#line·1191·"trace/trace-hw_ide.h"

1190

········}

1190

········}

1191

····}

1191

····}

1192

}

1192

}

1193

static·inline·void·trace_bmdma_write_via(uint64_t·addr,·uint64_t·val)

1193

static·inline·void·trace_bmdma_write_via(uint64_t·addr,·uint64_t·val)

1205

static·inline·void·_nocheck__trace_cd_read_sector_sync(int·lba)

1205

static·inline·void·_nocheck__trace_cd_read_sector_sync(int·lba)

1206

{

1206

{

1207

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

1207

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

1208

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

1208

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

1209

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

1209

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

1210

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

1210

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

1212

············qemu_log("%d@%zu.%06zu:cd_read_sector_sync·"·"lba=%d"·"\n",

1212

············qemu_log("%d@%zu.%06zu:cd_read_sector_sync·"·"lba=%d"·"\n",

1213

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

1213

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

1214

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

1214

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

1215

·····················,·lba);

1215

·····················,·lba);

1216

#line·1218·"trace/trace-hw_ide.h"

1216

#line·1218·"trace/trace-hw_ide.h"

1217

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

1217

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

1219

············qemu_log("cd_read_sector_sync·"·"lba=%d"·"\n",·lba);

1219

············qemu_log("cd_read_sector_sync·"·"lba=%d"·"\n",·lba);

1220

#line·1222·"trace/trace-hw_ide.h"

1220

#line·1222·"trace/trace-hw_ide.h"

1221

········}

1221

········}

1222

····}

1222

····}

1223

}

1223

}

1224

static·inline·void·trace_cd_read_sector_sync(int·lba)

1224

static·inline·void·trace_cd_read_sector_sync(int·lba)

1236

static·inline·void·_nocheck__trace_cd_read_sector_cb(int·lba,·int·ret)

1236

static·inline·void·_nocheck__trace_cd_read_sector_cb(int·lba,·int·ret)

1237

{

1237

{

1238

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

1238

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

1239

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

1239

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

1240

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

1240

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

1241

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

1241

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

1243

············qemu_log("%d@%zu.%06zu:cd_read_sector_cb·"·"lba=%d·ret=%d"·"\n",

1243

············qemu_log("%d@%zu.%06zu:cd_read_sector_cb·"·"lba=%d·ret=%d"·"\n",

1244

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

1244

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

1245

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

1245

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

1246

·····················,·lba,·ret);

1246

·····················,·lba,·ret);

1247

#line·1249·"trace/trace-hw_ide.h"

1247

#line·1249·"trace/trace-hw_ide.h"

1248

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

1248

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

1250

············qemu_log("cd_read_sector_cb·"·"lba=%d·ret=%d"·"\n",·lba,·ret);

1250

············qemu_log("cd_read_sector_cb·"·"lba=%d·ret=%d"·"\n",·lba,·ret);

1251

#line·1253·"trace/trace-hw_ide.h"

1251

#line·1253·"trace/trace-hw_ide.h"

1252

········}

1252

········}

1253

····}

1253

····}

1254

}

1254

}

1255

static·inline·void·trace_cd_read_sector_cb(int·lba,·int·ret)

1255

static·inline·void·trace_cd_read_sector_cb(int·lba,·int·ret)

1267

static·inline·void·_nocheck__trace_cd_read_sector(int·lba)

1267

static·inline·void·_nocheck__trace_cd_read_sector(int·lba)

1268

{

1268

{

1269

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

1269

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

1270

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

1270

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

1271

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

1271

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

1272

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

1272

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

1274

············qemu_log("%d@%zu.%06zu:cd_read_sector·"·"lba=%d"·"\n",

1274

············qemu_log("%d@%zu.%06zu:cd_read_sector·"·"lba=%d"·"\n",

1275

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

1275

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

1276

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

1276

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

1277

·····················,·lba);

1277

·····················,·lba);

1278

#line·1280·"trace/trace-hw_ide.h"

1278

#line·1280·"trace/trace-hw_ide.h"

1279

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

1279

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

1281

············qemu_log("cd_read_sector·"·"lba=%d"·"\n",·lba);

1281

············qemu_log("cd_read_sector·"·"lba=%d"·"\n",·lba);

1282

#line·1284·"trace/trace-hw_ide.h"

1282

#line·1284·"trace/trace-hw_ide.h"

1283

········}

1283

········}

1284

····}

1284

····}

1285

}

1285

}

1286

static·inline·void·trace_cd_read_sector(int·lba)

1286

static·inline·void·trace_cd_read_sector(int·lba)

1298

static·inline·void·_nocheck__trace_ide_atapi_cmd_error(void·*·s,·int·sense_key,·int·asc)

1298

static·inline·void·_nocheck__trace_ide_atapi_cmd_error(void·*·s,·int·sense_key,·int·asc)

1299

{

1299

{

1300

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

1300

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

1301

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

1301

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

1302

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

1302

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

1303

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

1303

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

1305

············qemu_log("%d@%zu.%06zu:ide_atapi_cmd_error·"·"IDEState:·%p;·sense=0x%x·asc=0x%x"·"\n",

1305

············qemu_log("%d@%zu.%06zu:ide_atapi_cmd_error·"·"IDEState:·%p;·sense=0x%x·asc=0x%x"·"\n",

1306

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

1306

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

1307

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

1307

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

1308

·····················,·s,·sense_key,·asc);

1308

·····················,·s,·sense_key,·asc);

1309

#line·1311·"trace/trace-hw_ide.h"

1309

#line·1311·"trace/trace-hw_ide.h"

1310

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

1310

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

1312

············qemu_log("ide_atapi_cmd_error·"·"IDEState:·%p;·sense=0x%x·asc=0x%x"·"\n",·s,·sense_key,·asc);

1312

············qemu_log("ide_atapi_cmd_error·"·"IDEState:·%p;·sense=0x%x·asc=0x%x"·"\n",·s,·sense_key,·asc);

1313

#line·1315·"trace/trace-hw_ide.h"

1313

#line·1315·"trace/trace-hw_ide.h"

1314

········}

1314

········}

1315

····}

1315

····}

1316

}

1316

}

1317

static·inline·void·trace_ide_atapi_cmd_error(void·*·s,·int·sense_key,·int·asc)

1317

static·inline·void·trace_ide_atapi_cmd_error(void·*·s,·int·sense_key,·int·asc)

1329

static·inline·void·_nocheck__trace_ide_atapi_cmd_reply_end(void·*·s,·int·tx_size,·int·elem_tx_size,·int32_t·index)

1329

static·inline·void·_nocheck__trace_ide_atapi_cmd_reply_end(void·*·s,·int·tx_size,·int·elem_tx_size,·int32_t·index)

1330

{

1330

{

1331

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

1331

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

1332

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

1332

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

1333

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

1333

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

1334

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

1334

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

1336

············qemu_log("%d@%zu.%06zu:ide_atapi_cmd_reply_end·"·"IDEState·%p;·reply:·tx_size=%d·elem_tx_size=%d·index=%"PRId32·"\n",

1336

············qemu_log("%d@%zu.%06zu:ide_atapi_cmd_reply_end·"·"IDEState·%p;·reply:·tx_size=%d·elem_tx_size=%d·index=%"PRId32·"\n",

1337

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

1337

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

1338

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

1338

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

1339

·····················,·s,·tx_size,·elem_tx_size,·index);

1339

·····················,·s,·tx_size,·elem_tx_size,·index);

1340

#line·1342·"trace/trace-hw_ide.h"

1340

#line·1342·"trace/trace-hw_ide.h"

1341

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

1341

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

1343

············qemu_log("ide_atapi_cmd_reply_end·"·"IDEState·%p;·reply:·tx_size=%d·elem_tx_size=%d·index=%"PRId32·"\n",·s,·tx_size,·elem_tx_size,·index);

1343

············qemu_log("ide_atapi_cmd_reply_end·"·"IDEState·%p;·reply:·tx_size=%d·elem_tx_size=%d·index=%"PRId32·"\n",·s,·tx_size,·elem_tx_size,·index);

1344

#line·1346·"trace/trace-hw_ide.h"

1344

#line·1346·"trace/trace-hw_ide.h"

1345

········}

1345

········}

1346

····}

1346

····}

1347

}

1347

}

1348

static·inline·void·trace_ide_atapi_cmd_reply_end(void·*·s,·int·tx_size,·int·elem_tx_size,·int32_t·index)

1348

static·inline·void·trace_ide_atapi_cmd_reply_end(void·*·s,·int·tx_size,·int·elem_tx_size,·int32_t·index)

1360

static·inline·void·_nocheck__trace_ide_atapi_cmd_reply_end_eot(void·*·s,·int·status)

1360

static·inline·void·_nocheck__trace_ide_atapi_cmd_reply_end_eot(void·*·s,·int·status)

1361

{

1361

{

1362

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

1362

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

1363

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

1363

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

1364

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

1364

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

1365

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

1365

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

1367

············qemu_log("%d@%zu.%06zu:ide_atapi_cmd_reply_end_eot·"·"IDEState:·%p;·end·of·transfer,·status=0x%x"·"\n",

1367

············qemu_log("%d@%zu.%06zu:ide_atapi_cmd_reply_end_eot·"·"IDEState:·%p;·end·of·transfer,·status=0x%x"·"\n",

1368

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

1368

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

1369

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

1369

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

1370

·····················,·s,·status);

1370

·····················,·s,·status);

1371

#line·1373·"trace/trace-hw_ide.h"

1371

#line·1373·"trace/trace-hw_ide.h"

1372

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

1372

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

1374

············qemu_log("ide_atapi_cmd_reply_end_eot·"·"IDEState:·%p;·end·of·transfer,·status=0x%x"·"\n",·s,·status);

1374

············qemu_log("ide_atapi_cmd_reply_end_eot·"·"IDEState:·%p;·end·of·transfer,·status=0x%x"·"\n",·s,·status);

1375

#line·1377·"trace/trace-hw_ide.h"

1375

#line·1377·"trace/trace-hw_ide.h"

1376

········}

1376

········}

1377

····}

1377

····}

1378

}

1378

}

1379

static·inline·void·trace_ide_atapi_cmd_reply_end_eot(void·*·s,·int·status)

1379

static·inline·void·trace_ide_atapi_cmd_reply_end_eot(void·*·s,·int·status)

1391

static·inline·void·_nocheck__trace_ide_atapi_cmd_reply_end_bcl(void·*·s,·int·bcl)

1391

static·inline·void·_nocheck__trace_ide_atapi_cmd_reply_end_bcl(void·*·s,·int·bcl)

1392

{

1392

{

1393

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

1393

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

1394

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

1394

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

1395

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

1395

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

1396

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

1396

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

1398

············qemu_log("%d@%zu.%06zu:ide_atapi_cmd_reply_end_bcl·"·"IDEState:·%p;·byte_count_limit=%d"·"\n",

1398

············qemu_log("%d@%zu.%06zu:ide_atapi_cmd_reply_end_bcl·"·"IDEState:·%p;·byte_count_limit=%d"·"\n",

1399

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

1399

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

1400

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

1400

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

1401

·····················,·s,·bcl);

1401

·····················,·s,·bcl);

1402

#line·1404·"trace/trace-hw_ide.h"

1402

#line·1404·"trace/trace-hw_ide.h"

1403

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

1403

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

1405

············qemu_log("ide_atapi_cmd_reply_end_bcl·"·"IDEState:·%p;·byte_count_limit=%d"·"\n",·s,·bcl);

1405

············qemu_log("ide_atapi_cmd_reply_end_bcl·"·"IDEState:·%p;·byte_count_limit=%d"·"\n",·s,·bcl);

1406

#line·1408·"trace/trace-hw_ide.h"

1406

#line·1408·"trace/trace-hw_ide.h"

1407

········}

1407

········}

1408

····}

1408

····}

1409

}

1409

}

1410

static·inline·void·trace_ide_atapi_cmd_reply_end_bcl(void·*·s,·int·bcl)

1410

static·inline·void·trace_ide_atapi_cmd_reply_end_bcl(void·*·s,·int·bcl)

1422

static·inline·void·_nocheck__trace_ide_atapi_cmd_reply_end_new(void·*·s,·int·status)

1422

static·inline·void·_nocheck__trace_ide_atapi_cmd_reply_end_new(void·*·s,·int·status)

1423

{

1423

{

1424

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

1424

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

1425

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

1425

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

1426

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

1426

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

1427

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

1427

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

1429

············qemu_log("%d@%zu.%06zu:ide_atapi_cmd_reply_end_new·"·"IDEState:·%p;·new·transfer·started,·status=0x%x"·"\n",

1429

············qemu_log("%d@%zu.%06zu:ide_atapi_cmd_reply_end_new·"·"IDEState:·%p;·new·transfer·started,·status=0x%x"·"\n",

1430

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

1430

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

1431

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

1431

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

1432

·····················,·s,·status);

1432

·····················,·s,·status);

1433

#line·1435·"trace/trace-hw_ide.h"

1433

#line·1435·"trace/trace-hw_ide.h"

1434

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

1434

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

1436

············qemu_log("ide_atapi_cmd_reply_end_new·"·"IDEState:·%p;·new·transfer·started,·status=0x%x"·"\n",·s,·status);

1436

············qemu_log("ide_atapi_cmd_reply_end_new·"·"IDEState:·%p;·new·transfer·started,·status=0x%x"·"\n",·s,·status);

1437

#line·1439·"trace/trace-hw_ide.h"

1437

#line·1439·"trace/trace-hw_ide.h"

1438

········}

1438

········}

1439

····}

1439

····}

1440

}

1440

}

1441

static·inline·void·trace_ide_atapi_cmd_reply_end_new(void·*·s,·int·status)

1441

static·inline·void·trace_ide_atapi_cmd_reply_end_new(void·*·s,·int·status)

1453

static·inline·void·_nocheck__trace_ide_atapi_cmd_check_status(void·*·s)

1453

static·inline·void·_nocheck__trace_ide_atapi_cmd_check_status(void·*·s)

1454

{

1454

{

1455

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

1455

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

1456

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

1456

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

1457

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

1457

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

1458

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

1458

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

1460

············qemu_log("%d@%zu.%06zu:ide_atapi_cmd_check_status·"·"IDEState:·%p"·"\n",

1460

············qemu_log("%d@%zu.%06zu:ide_atapi_cmd_check_status·"·"IDEState:·%p"·"\n",

1461

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

1461

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

1462

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

1462

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

1463

·····················,·s);

1463

·····················,·s);

1464

#line·1466·"trace/trace-hw_ide.h"

1464

#line·1466·"trace/trace-hw_ide.h"

1465

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

1465

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

1467

············qemu_log("ide_atapi_cmd_check_status·"·"IDEState:·%p"·"\n",·s);

1467

············qemu_log("ide_atapi_cmd_check_status·"·"IDEState:·%p"·"\n",·s);

1468

#line·1470·"trace/trace-hw_ide.h"

1468

#line·1470·"trace/trace-hw_ide.h"

1469

········}

1469

········}

1470

····}

1470

····}

1471

}

1471

}

1472

static·inline·void·trace_ide_atapi_cmd_check_status(void·*·s)

1472

static·inline·void·trace_ide_atapi_cmd_check_status(void·*·s)

1484

static·inline·void·_nocheck__trace_ide_atapi_cmd_read(void·*·s,·const·char·*·method,·int·lba,·int·nb_sectors)

1484

static·inline·void·_nocheck__trace_ide_atapi_cmd_read(void·*·s,·const·char·*·method,·int·lba,·int·nb_sectors)

1485

{

1485

{

1486

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

1486

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

1487

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

1487

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

1488

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

1488

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

1489

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

1489

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

1491

············qemu_log("%d@%zu.%06zu:ide_atapi_cmd_read·"·"IDEState:·%p;·read·%s:·LBA=%d·nb_sectors=%d"·"\n",

1491

············qemu_log("%d@%zu.%06zu:ide_atapi_cmd_read·"·"IDEState:·%p;·read·%s:·LBA=%d·nb_sectors=%d"·"\n",

1492

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

1492

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

1493

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

1493

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

1494

·····················,·s,·method,·lba,·nb_sectors);

1494

·····················,·s,·method,·lba,·nb_sectors);

1495

#line·1497·"trace/trace-hw_ide.h"

1495

#line·1497·"trace/trace-hw_ide.h"

1496

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

1496

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

1498

············qemu_log("ide_atapi_cmd_read·"·"IDEState:·%p;·read·%s:·LBA=%d·nb_sectors=%d"·"\n",·s,·method,·lba,·nb_sectors);

1498

············qemu_log("ide_atapi_cmd_read·"·"IDEState:·%p;·read·%s:·LBA=%d·nb_sectors=%d"·"\n",·s,·method,·lba,·nb_sectors);

1499

#line·1501·"trace/trace-hw_ide.h"

1499

#line·1501·"trace/trace-hw_ide.h"

1500

········}

1500

········}

1501

····}

1501

····}

1502

}

1502

}

1503

static·inline·void·trace_ide_atapi_cmd_read(void·*·s,·const·char·*·method,·int·lba,·int·nb_sectors)

1503

static·inline·void·trace_ide_atapi_cmd_read(void·*·s,·const·char·*·method,·int·lba,·int·nb_sectors)

1515

static·inline·void·_nocheck__trace_ide_atapi_cmd(void·*·s,·uint8_t·cmd)

1515

static·inline·void·_nocheck__trace_ide_atapi_cmd(void·*·s,·uint8_t·cmd)

1516

{

1516

{

1517

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

1517

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

1518

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

1518

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

1519

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

1519

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

1520

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

1520

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

1522

············qemu_log("%d@%zu.%06zu:ide_atapi_cmd·"·"IDEState:·%p;·cmd:·0x%02x"·"\n",

1522

············qemu_log("%d@%zu.%06zu:ide_atapi_cmd·"·"IDEState:·%p;·cmd:·0x%02x"·"\n",

1523

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

1523

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

1524

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

1524

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

1525

·····················,·s,·cmd);

1525

·····················,·s,·cmd);

1526

#line·1528·"trace/trace-hw_ide.h"

1526

#line·1528·"trace/trace-hw_ide.h"

1527

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

1527

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

1529

············qemu_log("ide_atapi_cmd·"·"IDEState:·%p;·cmd:·0x%02x"·"\n",·s,·cmd);

1529

············qemu_log("ide_atapi_cmd·"·"IDEState:·%p;·cmd:·0x%02x"·"\n",·s,·cmd);

1530

#line·1532·"trace/trace-hw_ide.h"

1530

#line·1532·"trace/trace-hw_ide.h"

1531

········}

1531

········}

1532

····}

1532

····}

1533

}

1533

}

1534

static·inline·void·trace_ide_atapi_cmd(void·*·s,·uint8_t·cmd)

1534

static·inline·void·trace_ide_atapi_cmd(void·*·s,·uint8_t·cmd)

1546

static·inline·void·_nocheck__trace_ide_atapi_cmd_read_dma_cb_aio(void·*·s,·int·lba,·int·n)

1546

static·inline·void·_nocheck__trace_ide_atapi_cmd_read_dma_cb_aio(void·*·s,·int·lba,·int·n)

1547

{

1547

{

1548

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

1548

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

1549

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

1549

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

1550

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

1550

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

1551

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

1551

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

1553

············qemu_log("%d@%zu.%06zu:ide_atapi_cmd_read_dma_cb_aio·"·"IDEState:·%p;·aio·read:·lba=%d·n=%d"·"\n",

1553

············qemu_log("%d@%zu.%06zu:ide_atapi_cmd_read_dma_cb_aio·"·"IDEState:·%p;·aio·read:·lba=%d·n=%d"·"\n",

1554

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

1554

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

1555

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

1555

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

1556

·····················,·s,·lba,·n);

1556

·····················,·s,·lba,·n);

1557

#line·1559·"trace/trace-hw_ide.h"

1557

#line·1559·"trace/trace-hw_ide.h"

1558

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

1558

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

1560

············qemu_log("ide_atapi_cmd_read_dma_cb_aio·"·"IDEState:·%p;·aio·read:·lba=%d·n=%d"·"\n",·s,·lba,·n);

1560

············qemu_log("ide_atapi_cmd_read_dma_cb_aio·"·"IDEState:·%p;·aio·read:·lba=%d·n=%d"·"\n",·s,·lba,·n);

1561

#line·1563·"trace/trace-hw_ide.h"

1561

#line·1563·"trace/trace-hw_ide.h"

1562

········}

1562

········}

1563

····}

1563

····}

1564

}

1564

}

1565

static·inline·void·trace_ide_atapi_cmd_read_dma_cb_aio(void·*·s,·int·lba,·int·n)

1565

static·inline·void·trace_ide_atapi_cmd_read_dma_cb_aio(void·*·s,·int·lba,·int·n)

1577

static·inline·void·_nocheck__trace_ide_atapi_cmd_packet(void·*·s,·uint16_t·limit,·const·char·*·packet)

1577

static·inline·void·_nocheck__trace_ide_atapi_cmd_packet(void·*·s,·uint16_t·limit,·const·char·*·packet)

1578

{

1578

{

1579

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

1579

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

1580

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

1580

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

1581

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

1581

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

1582

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

1582

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

1584

············qemu_log("%d@%zu.%06zu:ide_atapi_cmd_packet·"·"IDEState:·%p;·limit=0x%x·packet:·%s"·"\n",

1584

············qemu_log("%d@%zu.%06zu:ide_atapi_cmd_packet·"·"IDEState:·%p;·limit=0x%x·packet:·%s"·"\n",

1585

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

1585

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

1586

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

1586

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

1587

·····················,·s,·limit,·packet);

1587

·····················,·s,·limit,·packet);

1588

#line·1590·"trace/trace-hw_ide.h"

1588

#line·1590·"trace/trace-hw_ide.h"

1589

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

1589

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

1591

············qemu_log("ide_atapi_cmd_packet·"·"IDEState:·%p;·limit=0x%x·packet:·%s"·"\n",·s,·limit,·packet);

1591

············qemu_log("ide_atapi_cmd_packet·"·"IDEState:·%p;·limit=0x%x·packet:·%s"·"\n",·s,·limit,·packet);

1592

#line·1594·"trace/trace-hw_ide.h"

1592

#line·1594·"trace/trace-hw_ide.h"

1593

········}

1593

········}

1594

····}

1594

····}

1595

}

1595

}

1596

static·inline·void·trace_ide_atapi_cmd_packet(void·*·s,·uint16_t·limit,·const·char·*·packet)

1596

static·inline·void·trace_ide_atapi_cmd_packet(void·*·s,·uint16_t·limit,·const·char·*·packet)

1608

static·inline·void·_nocheck__trace_ahci_port_read(void·*·s,·int·port,·const·char·*·reg,·int·offset,·uint32_t·ret)

1608

static·inline·void·_nocheck__trace_ahci_port_read(void·*·s,·int·port,·const·char·*·reg,·int·offset,·uint32_t·ret)

1609

{

1609

{

1610

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

1610

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

1611

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

1611

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

1612

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

1612

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

1613

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

1613

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

1615

············qemu_log("%d@%zu.%06zu:ahci_port_read·"·"ahci(%p)[%d]:·port·read·[reg:%s]·@·0x%x:·0x%08x"·"\n",

1615

············qemu_log("%d@%zu.%06zu:ahci_port_read·"·"ahci(%p)[%d]:·port·read·[reg:%s]·@·0x%x:·0x%08x"·"\n",

1616

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

1616

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

1617

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

1617

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

1618

·····················,·s,·port,·reg,·offset,·ret);

1618

·····················,·s,·port,·reg,·offset,·ret);

1619

#line·1621·"trace/trace-hw_ide.h"

1619

#line·1621·"trace/trace-hw_ide.h"

1620

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

1620

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

1622

············qemu_log("ahci_port_read·"·"ahci(%p)[%d]:·port·read·[reg:%s]·@·0x%x:·0x%08x"·"\n",·s,·port,·reg,·offset,·ret);

1622

············qemu_log("ahci_port_read·"·"ahci(%p)[%d]:·port·read·[reg:%s]·@·0x%x:·0x%08x"·"\n",·s,·port,·reg,·offset,·ret);

1623

#line·1625·"trace/trace-hw_ide.h"

1623

#line·1625·"trace/trace-hw_ide.h"

1624

········}

1624

········}

1625

····}

1625

····}

1626

}

1626

}

1627

static·inline·void·trace_ahci_port_read(void·*·s,·int·port,·const·char·*·reg,·int·offset,·uint32_t·ret)

1627

static·inline·void·trace_ahci_port_read(void·*·s,·int·port,·const·char·*·reg,·int·offset,·uint32_t·ret)

1639

static·inline·void·_nocheck__trace_ahci_port_read_default(void·*·s,·int·port,·const·char·*·reg,·int·offset)

1639

static·inline·void·_nocheck__trace_ahci_port_read_default(void·*·s,·int·port,·const·char·*·reg,·int·offset)

1640

{

1640

{

1641

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

1641

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

1642

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

1642

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

1643

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

1643

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

1644

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

1644

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

1646

············qemu_log("%d@%zu.%06zu:ahci_port_read_default·"·"ahci(%p)[%d]:·unimplemented·port·read·[reg:%s]·@·0x%x"·"\n",

1646

············qemu_log("%d@%zu.%06zu:ahci_port_read_default·"·"ahci(%p)[%d]:·unimplemented·port·read·[reg:%s]·@·0x%x"·"\n",

1647

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

1647

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

1648

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

1648

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

1649

·····················,·s,·port,·reg,·offset);

1649

·····················,·s,·port,·reg,·offset);

1650

#line·1652·"trace/trace-hw_ide.h"

1650

#line·1652·"trace/trace-hw_ide.h"

1651

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

1651

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

1653

············qemu_log("ahci_port_read_default·"·"ahci(%p)[%d]:·unimplemented·port·read·[reg:%s]·@·0x%x"·"\n",·s,·port,·reg,·offset);

1653

············qemu_log("ahci_port_read_default·"·"ahci(%p)[%d]:·unimplemented·port·read·[reg:%s]·@·0x%x"·"\n",·s,·port,·reg,·offset);

1654

#line·1656·"trace/trace-hw_ide.h"

1654

#line·1656·"trace/trace-hw_ide.h"

1655

········}

1655

········}

1656

····}

1656

····}

1657

}

1657

}

1658

static·inline·void·trace_ahci_port_read_default(void·*·s,·int·port,·const·char·*·reg,·int·offset)

1658

static·inline·void·trace_ahci_port_read_default(void·*·s,·int·port,·const·char·*·reg,·int·offset)

1670

static·inline·void·_nocheck__trace_ahci_irq_raise(void·*·s)

1670

static·inline·void·_nocheck__trace_ahci_irq_raise(void·*·s)

1671

{

1671

{

1672

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

1672

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

1673

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

1673

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

1674

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

1674

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

1675

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

1675

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

1677

············qemu_log("%d@%zu.%06zu:ahci_irq_raise·"·"ahci(%p):·raise·irq"·"\n",

1677

············qemu_log("%d@%zu.%06zu:ahci_irq_raise·"·"ahci(%p):·raise·irq"·"\n",

1678

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

1678

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

1679

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

1679

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

1680

·····················,·s);

1680

·····················,·s);

1681

#line·1683·"trace/trace-hw_ide.h"

1681

#line·1683·"trace/trace-hw_ide.h"

1682

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

1682

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

1684

············qemu_log("ahci_irq_raise·"·"ahci(%p):·raise·irq"·"\n",·s);

1684

············qemu_log("ahci_irq_raise·"·"ahci(%p):·raise·irq"·"\n",·s);

1685

#line·1687·"trace/trace-hw_ide.h"

1685

#line·1687·"trace/trace-hw_ide.h"

1686

········}

1686

········}

1687

····}

1687

····}

1688

}

1688

}

1689

static·inline·void·trace_ahci_irq_raise(void·*·s)

1689

static·inline·void·trace_ahci_irq_raise(void·*·s)

1701

static·inline·void·_nocheck__trace_ahci_irq_lower(void·*·s)

1701

static·inline·void·_nocheck__trace_ahci_irq_lower(void·*·s)

1702

{

1702

{

1703

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

1703

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

1704

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

1704

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

1705

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

1705

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

1706

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

1706

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

1708

············qemu_log("%d@%zu.%06zu:ahci_irq_lower·"·"ahci(%p):·lower·irq"·"\n",

1708

············qemu_log("%d@%zu.%06zu:ahci_irq_lower·"·"ahci(%p):·lower·irq"·"\n",

1709

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

1709

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

1710

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

1710

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

1711

·····················,·s);

1711

·····················,·s);

1712

#line·1714·"trace/trace-hw_ide.h"

1712

#line·1714·"trace/trace-hw_ide.h"

1713

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

1713

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

1715

············qemu_log("ahci_irq_lower·"·"ahci(%p):·lower·irq"·"\n",·s);

1715

············qemu_log("ahci_irq_lower·"·"ahci(%p):·lower·irq"·"\n",·s);

1716

#line·1718·"trace/trace-hw_ide.h"

1716

#line·1718·"trace/trace-hw_ide.h"

1717

········}

1717

········}

1718

····}

1718

····}

1719

}

1719

}

1720

static·inline·void·trace_ahci_irq_lower(void·*·s)

1720

static·inline·void·trace_ahci_irq_lower(void·*·s)

1732

static·inline·void·_nocheck__trace_ahci_check_irq(void·*·s,·uint32_t·old,·uint32_t·new)

1732

static·inline·void·_nocheck__trace_ahci_check_irq(void·*·s,·uint32_t·old,·uint32_t·new)

1733

{

1733

{

1734

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

1734

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

1735

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

1735

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

1736

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

1736

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

1737

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

1737

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

1739

············qemu_log("%d@%zu.%06zu:ahci_check_irq·"·"ahci(%p):·check·irq·0x%08x·-->·0x%08x"·"\n",

1739

············qemu_log("%d@%zu.%06zu:ahci_check_irq·"·"ahci(%p):·check·irq·0x%08x·-->·0x%08x"·"\n",

1740

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

1740

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

1741

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

1741

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

1742

·····················,·s,·old,·new);

1742

·····················,·s,·old,·new);

1743

#line·1745·"trace/trace-hw_ide.h"

1743

#line·1745·"trace/trace-hw_ide.h"

1744

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

1744

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

1746

············qemu_log("ahci_check_irq·"·"ahci(%p):·check·irq·0x%08x·-->·0x%08x"·"\n",·s,·old,·new);

1746

············qemu_log("ahci_check_irq·"·"ahci(%p):·check·irq·0x%08x·-->·0x%08x"·"\n",·s,·old,·new);

1747

#line·1749·"trace/trace-hw_ide.h"

1747

#line·1749·"trace/trace-hw_ide.h"

1748

········}

1748

········}

1749

····}

1749

····}

1750

}

1750

}

1751

static·inline·void·trace_ahci_check_irq(void·*·s,·uint32_t·old,·uint32_t·new)

1751

static·inline·void·trace_ahci_check_irq(void·*·s,·uint32_t·old,·uint32_t·new)

1763

static·inline·void·_nocheck__trace_ahci_trigger_irq(void·*·s,·int·port,·const·char·*·name,·uint32_t·val,·uint32_t·old,·uint32_t·new,·uint32_t·effective)

1763

static·inline·void·_nocheck__trace_ahci_trigger_irq(void·*·s,·int·port,·const·char·*·name,·uint32_t·val,·uint32_t·old,·uint32_t·new,·uint32_t·effective)

1764

{

1764

{

1765

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

1765

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

1766

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

1766

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

1767

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

1767

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

1768

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

1768

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

1770

············qemu_log("%d@%zu.%06zu:ahci_trigger_irq·"·"ahci(%p)[%d]:·trigger·irq·+%s·(0x%08x);·irqstat:·0x%08x·-->·0x%08x;·effective:·0x%08x"·"\n",

1770

············qemu_log("%d@%zu.%06zu:ahci_trigger_irq·"·"ahci(%p)[%d]:·trigger·irq·+%s·(0x%08x);·irqstat:·0x%08x·-->·0x%08x;·effective:·0x%08x"·"\n",

1771

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

1771

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

1772

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

1772

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

1773

·····················,·s,·port,·name,·val,·old,·new,·effective);

1773

·····················,·s,·port,·name,·val,·old,·new,·effective);

1774

#line·1776·"trace/trace-hw_ide.h"

1774

#line·1776·"trace/trace-hw_ide.h"

1775

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

1775

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

1777

············qemu_log("ahci_trigger_irq·"·"ahci(%p)[%d]:·trigger·irq·+%s·(0x%08x);·irqstat:·0x%08x·-->·0x%08x;·effective:·0x%08x"·"\n",·s,·port,·name,·val,·old,·new,·effective);

1777

············qemu_log("ahci_trigger_irq·"·"ahci(%p)[%d]:·trigger·irq·+%s·(0x%08x);·irqstat:·0x%08x·-->·0x%08x;·effective:·0x%08x"·"\n",·s,·port,·name,·val,·old,·new,·effective);

1778

#line·1780·"trace/trace-hw_ide.h"

1778

#line·1780·"trace/trace-hw_ide.h"

1779

········}

1779

········}

1780

····}

1780

····}

1781

}

1781

}

1782

static·inline·void·trace_ahci_trigger_irq(void·*·s,·int·port,·const·char·*·name,·uint32_t·val,·uint32_t·old,·uint32_t·new,·uint32_t·effective)

1782

static·inline·void·trace_ahci_trigger_irq(void·*·s,·int·port,·const·char·*·name,·uint32_t·val,·uint32_t·old,·uint32_t·new,·uint32_t·effective)

1794

static·inline·void·_nocheck__trace_ahci_port_write(void·*·s,·int·port,·const·char·*·reg,·int·offset,·uint32_t·val)

1794

static·inline·void·_nocheck__trace_ahci_port_write(void·*·s,·int·port,·const·char·*·reg,·int·offset,·uint32_t·val)

1795

{

1795

{

1796

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

1796

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

1797

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

1797

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

1798

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

1798

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

1799

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

1799

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

1801

············qemu_log("%d@%zu.%06zu:ahci_port_write·"·"ahci(%p)[%d]:·port·write·[reg:%s]·@·0x%x:·0x%08x"·"\n",

1801

············qemu_log("%d@%zu.%06zu:ahci_port_write·"·"ahci(%p)[%d]:·port·write·[reg:%s]·@·0x%x:·0x%08x"·"\n",

1802

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

1802

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

1803

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

1803

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

1804

·····················,·s,·port,·reg,·offset,·val);

1804

·····················,·s,·port,·reg,·offset,·val);

1805

#line·1807·"trace/trace-hw_ide.h"

1805

#line·1807·"trace/trace-hw_ide.h"

1806

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

1806

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

1808

············qemu_log("ahci_port_write·"·"ahci(%p)[%d]:·port·write·[reg:%s]·@·0x%x:·0x%08x"·"\n",·s,·port,·reg,·offset,·val);

1808

············qemu_log("ahci_port_write·"·"ahci(%p)[%d]:·port·write·[reg:%s]·@·0x%x:·0x%08x"·"\n",·s,·port,·reg,·offset,·val);

1809

#line·1811·"trace/trace-hw_ide.h"

1809

#line·1811·"trace/trace-hw_ide.h"

1810

········}

1810

········}

1811

····}

1811

····}

1812

}

1812

}

1813

static·inline·void·trace_ahci_port_write(void·*·s,·int·port,·const·char·*·reg,·int·offset,·uint32_t·val)

1813

static·inline·void·trace_ahci_port_write(void·*·s,·int·port,·const·char·*·reg,·int·offset,·uint32_t·val)

1825

static·inline·void·_nocheck__trace_ahci_port_write_unimpl(void·*·s,·int·port,·const·char·*·reg,·int·offset,·uint32_t·val)

1825

static·inline·void·_nocheck__trace_ahci_port_write_unimpl(void·*·s,·int·port,·const·char·*·reg,·int·offset,·uint32_t·val)

1826

{

1826

{

1827

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

1827

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

1828

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

1828

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

1829

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

1829

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

1830

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

1830

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

1832

············qemu_log("%d@%zu.%06zu:ahci_port_write_unimpl·"·"ahci(%p)[%d]:·unimplemented·port·write·[reg:%s]·@·0x%x:·0x%08x"·"\n",

1832

············qemu_log("%d@%zu.%06zu:ahci_port_write_unimpl·"·"ahci(%p)[%d]:·unimplemented·port·write·[reg:%s]·@·0x%x:·0x%08x"·"\n",

1833

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

1833

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

1834

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

1834

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

1835

·····················,·s,·port,·reg,·offset,·val);

1835

·····················,·s,·port,·reg,·offset,·val);

1836

#line·1838·"trace/trace-hw_ide.h"

1836

#line·1838·"trace/trace-hw_ide.h"

1837

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

1837

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

1839

············qemu_log("ahci_port_write_unimpl·"·"ahci(%p)[%d]:·unimplemented·port·write·[reg:%s]·@·0x%x:·0x%08x"·"\n",·s,·port,·reg,·offset,·val);

1839

············qemu_log("ahci_port_write_unimpl·"·"ahci(%p)[%d]:·unimplemented·port·write·[reg:%s]·@·0x%x:·0x%08x"·"\n",·s,·port,·reg,·offset,·val);

1840

#line·1842·"trace/trace-hw_ide.h"

1840

#line·1842·"trace/trace-hw_ide.h"

1841

········}

1841

········}

1842

····}

1842

····}

1843

}

1843

}

1844

static·inline·void·trace_ahci_port_write_unimpl(void·*·s,·int·port,·const·char·*·reg,·int·offset,·uint32_t·val)

1844

static·inline·void·trace_ahci_port_write_unimpl(void·*·s,·int·port,·const·char·*·reg,·int·offset,·uint32_t·val)

1856

static·inline·void·_nocheck__trace_ahci_mem_read_32(void·*·s,·uint64_t·addr,·uint32_t·val)

1856

static·inline·void·_nocheck__trace_ahci_mem_read_32(void·*·s,·uint64_t·addr,·uint32_t·val)

1857

{

1857

{

1858

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

1858

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

1859

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

1859

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

1860

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

1860

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

1861

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

1861

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

1863

············qemu_log("%d@%zu.%06zu:ahci_mem_read_32·"·"ahci(%p):·mem·read·@·0x%"PRIx64":·0x%08x"·"\n",

1863

············qemu_log("%d@%zu.%06zu:ahci_mem_read_32·"·"ahci(%p):·mem·read·@·0x%"PRIx64":·0x%08x"·"\n",

1864

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

1864

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

1865

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

1865

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

1866

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

1866

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

1867

#line·1869·"trace/trace-hw_ide.h"

1867

#line·1869·"trace/trace-hw_ide.h"

1868

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

1868

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

1870

············qemu_log("ahci_mem_read_32·"·"ahci(%p):·mem·read·@·0x%"PRIx64":·0x%08x"·"\n",·s,·addr,·val);

1870

············qemu_log("ahci_mem_read_32·"·"ahci(%p):·mem·read·@·0x%"PRIx64":·0x%08x"·"\n",·s,·addr,·val);

1871

#line·1873·"trace/trace-hw_ide.h"

1871

#line·1873·"trace/trace-hw_ide.h"

1872

········}

1872

········}

1873

····}

1873

····}

1874

}

1874

}

1875

static·inline·void·trace_ahci_mem_read_32(void·*·s,·uint64_t·addr,·uint32_t·val)

1875

static·inline·void·trace_ahci_mem_read_32(void·*·s,·uint64_t·addr,·uint32_t·val)

1887

static·inline·void·_nocheck__trace_ahci_mem_read_32_default(void·*·s,·uint64_t·addr,·uint32_t·val)

1887

static·inline·void·_nocheck__trace_ahci_mem_read_32_default(void·*·s,·uint64_t·addr,·uint32_t·val)

1888

{

1888

{

1889

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

1889

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

1890

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

1890

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

1891

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

1891

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

1892

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

1892

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

1894

············qemu_log("%d@%zu.%06zu:ahci_mem_read_32_default·"·"ahci(%p):·mem·read·@·0x%"PRIx64":·0x%08x"·"\n",

1894

············qemu_log("%d@%zu.%06zu:ahci_mem_read_32_default·"·"ahci(%p):·mem·read·@·0x%"PRIx64":·0x%08x"·"\n",

1895

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

1895

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

1896

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

1896

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

1897

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

1897

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

1898

#line·1900·"trace/trace-hw_ide.h"

1898

#line·1900·"trace/trace-hw_ide.h"

1899

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

1899

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

1901

············qemu_log("ahci_mem_read_32_default·"·"ahci(%p):·mem·read·@·0x%"PRIx64":·0x%08x"·"\n",·s,·addr,·val);

1901

············qemu_log("ahci_mem_read_32_default·"·"ahci(%p):·mem·read·@·0x%"PRIx64":·0x%08x"·"\n",·s,·addr,·val);

1902

#line·1904·"trace/trace-hw_ide.h"

1902

#line·1904·"trace/trace-hw_ide.h"

1903

········}

1903

········}

1904

····}

1904

····}

1905

}

1905

}

1906

static·inline·void·trace_ahci_mem_read_32_default(void·*·s,·uint64_t·addr,·uint32_t·val)

1906

static·inline·void·trace_ahci_mem_read_32_default(void·*·s,·uint64_t·addr,·uint32_t·val)

1918

static·inline·void·_nocheck__trace_ahci_mem_read_32_host(void·*·s,·const·char·*·reg,·uint64_t·addr,·uint32_t·val)

1918

static·inline·void·_nocheck__trace_ahci_mem_read_32_host(void·*·s,·const·char·*·reg,·uint64_t·addr,·uint32_t·val)

1919

{

1919

{

1920

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

1920

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

1921

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

1921

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

1922

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

1922

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

1923

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

1923

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

1925

············qemu_log("%d@%zu.%06zu:ahci_mem_read_32_host·"·"ahci(%p):·mem·read·[reg:%s]·@·0x%"PRIx64":·0x%08x"·"\n",

1925

············qemu_log("%d@%zu.%06zu:ahci_mem_read_32_host·"·"ahci(%p):·mem·read·[reg:%s]·@·0x%"PRIx64":·0x%08x"·"\n",

1926

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

1926

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

1927

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

1927

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

1928

·····················,·s,·reg,·addr,·val);

1928

·····················,·s,·reg,·addr,·val);

1929

#line·1931·"trace/trace-hw_ide.h"

1929

#line·1931·"trace/trace-hw_ide.h"

1930

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

1930

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

1932

············qemu_log("ahci_mem_read_32_host·"·"ahci(%p):·mem·read·[reg:%s]·@·0x%"PRIx64":·0x%08x"·"\n",·s,·reg,·addr,·val);

1932

············qemu_log("ahci_mem_read_32_host·"·"ahci(%p):·mem·read·[reg:%s]·@·0x%"PRIx64":·0x%08x"·"\n",·s,·reg,·addr,·val);

1933

#line·1935·"trace/trace-hw_ide.h"

1933

#line·1935·"trace/trace-hw_ide.h"

1934

········}

1934

········}

1935

····}

1935

····}

1936

}

1936

}

1937

static·inline·void·trace_ahci_mem_read_32_host(void·*·s,·const·char·*·reg,·uint64_t·addr,·uint32_t·val)

1937

static·inline·void·trace_ahci_mem_read_32_host(void·*·s,·const·char·*·reg,·uint64_t·addr,·uint32_t·val)

1949

static·inline·void·_nocheck__trace_ahci_mem_read_32_host_default(void·*·s,·const·char·*·reg,·uint64_t·addr)

1949

static·inline·void·_nocheck__trace_ahci_mem_read_32_host_default(void·*·s,·const·char·*·reg,·uint64_t·addr)

1950

{

1950

{

1951

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

1951

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

1952

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

1952

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

1953

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

1953

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

1954

············gettimeofday(&_now,·NULL);

1954

············gettimeofday(&_now,·NULL);

1956

············qemu_log("%d@%zu.%06zu:ahci_mem_read_32_host_default·"·"ahci(%p):·unimplemented·mem·read·[reg:%s]·@·0x%"PRIx64·"\n",

1956

············qemu_log("%d@%zu.%06zu:ahci_mem_read_32_host_default·"·"ahci(%p):·unimplemented·mem·read·[reg:%s]·@·0x%"PRIx64·"\n",

1957

·····················qemu_get_thread_id(),

1957

·····················qemu_get_thread_id(),

1958

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1958

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1959

·····················,·s,·reg,·addr);

1959

·····················,·s,·reg,·addr);

1960

#line·1962·"trace/trace-hw_ide.h"

1960

#line·1962·"trace/trace-hw_ide.h"

1961

········}·else·{

1961

········}·else·{

1963

············qemu_log("ahci_mem_read_32_host_default·"·"ahci(%p):·unimplemented·mem·read·[reg:%s]·@·0x%"PRIx64·"\n",·s,·reg,·addr);

1963

············qemu_log("ahci_mem_read_32_host_default·"·"ahci(%p):·unimplemented·mem·read·[reg:%s]·@·0x%"PRIx64·"\n",·s,·reg,·addr);

1964

#line·1966·"trace/trace-hw_ide.h"

1964

#line·1966·"trace/trace-hw_ide.h"

1965

········}

1965

········}

1966

····}

1966

····}

1967

}

1967

}

1968

static·inline·void·trace_ahci_mem_read_32_host_default(void·*·s,·const·char·*·reg,·uint64_t·addr)

1968

static·inline·void·trace_ahci_mem_read_32_host_default(void·*·s,·const·char·*·reg,·uint64_t·addr)

1980

static·inline·void·_nocheck__trace_ahci_mem_read(void·*·s,·unsigned·size,·uint64_t·addr,·uint64_t·val)

1980

static·inline·void·_nocheck__trace_ahci_mem_read(void·*·s,·unsigned·size,·uint64_t·addr,·uint64_t·val)

1981

{

1981

{

1982

····if·(trace_event_get_state(TRACE_AHCI_MEM_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1982

····if·(trace_event_get_state(TRACE_AHCI_MEM_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1983

········if·(message_with_timestamp)·{

1983

········if·(message_with_timestamp)·{

1984

············struct·timeval·_now;

1984

············struct·timeval·_now;

1985

············gettimeofday(&_now,·NULL);

1985

············gettimeofday(&_now,·NULL);

1987

············qemu_log("%d@%zu.%06zu:ahci_mem_read·"·"ahci(%p):·read%u·@·0x%"PRIx64":·0x%016"PRIx64·"\n",

1987

············qemu_log("%d@%zu.%06zu:ahci_mem_read·"·"ahci(%p):·read%u·@·0x%"PRIx64":·0x%016"PRIx64·"\n",

1988

·····················qemu_get_thread_id(),

1988

·····················qemu_get_thread_id(),

1989

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1989

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1990

·····················,·s,·size,·addr,·val);

1990

·····················,·s,·size,·addr,·val);

1991

#line·1993·"trace/trace-hw_ide.h"

1991

#line·1993·"trace/trace-hw_ide.h"

1992

········}·else·{

1992

········}·else·{

1994

············qemu_log("ahci_mem_read·"·"ahci(%p):·read%u·@·0x%"PRIx64":·0x%016"PRIx64·"\n",·s,·size,·addr,·val);

1994

············qemu_log("ahci_mem_read·"·"ahci(%p):·read%u·@·0x%"PRIx64":·0x%016"PRIx64·"\n",·s,·size,·addr,·val);

1995

#line·1997·"trace/trace-hw_ide.h"

1995

#line·1997·"trace/trace-hw_ide.h"

1996

········}

1996

········}

1997

····}

1997

····}

1998

}

1998

}

1999

static·inline·void·trace_ahci_mem_read(void·*·s,·unsigned·size,·uint64_t·addr,·uint64_t·val)

1999

static·inline·void·trace_ahci_mem_read(void·*·s,·unsigned·size,·uint64_t·addr,·uint64_t·val)

2011

static·inline·void·_nocheck__trace_ahci_mem_write(void·*·s,·unsigned·size,·uint64_t·addr,·uint64_t·val)

2011

static·inline·void·_nocheck__trace_ahci_mem_write(void·*·s,·unsigned·size,·uint64_t·addr,·uint64_t·val)

2012

{

2012

{

2013

····if·(trace_event_get_state(TRACE_AHCI_MEM_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2013

····if·(trace_event_get_state(TRACE_AHCI_MEM_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2014

········if·(message_with_timestamp)·{

2014

········if·(message_with_timestamp)·{

2015

············struct·timeval·_now;

2015

············struct·timeval·_now;

2016

············gettimeofday(&_now,·NULL);

2016

············gettimeofday(&_now,·NULL);

2018

············qemu_log("%d@%zu.%06zu:ahci_mem_write·"·"ahci(%p):·write%u·@·0x%"PRIx64":·0x%016"PRIx64·"\n",

2018

············qemu_log("%d@%zu.%06zu:ahci_mem_write·"·"ahci(%p):·write%u·@·0x%"PRIx64":·0x%016"PRIx64·"\n",

2019

·····················qemu_get_thread_id(),

2019

·····················qemu_get_thread_id(),

2020

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2020

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2021

·····················,·s,·size,·addr,·val);

2021

·····················,·s,·size,·addr,·val);

2022

#line·2024·"trace/trace-hw_ide.h"

2022

#line·2024·"trace/trace-hw_ide.h"

2023

········}·else·{

2023

········}·else·{

2025

············qemu_log("ahci_mem_write·"·"ahci(%p):·write%u·@·0x%"PRIx64":·0x%016"PRIx64·"\n",·s,·size,·addr,·val);

2025

············qemu_log("ahci_mem_write·"·"ahci(%p):·write%u·@·0x%"PRIx64":·0x%016"PRIx64·"\n",·s,·size,·addr,·val);

2026

#line·2028·"trace/trace-hw_ide.h"

2026

#line·2028·"trace/trace-hw_ide.h"

2027

········}

2027

········}

2028

····}

2028

····}

2029

}

2029

}

2030

static·inline·void·trace_ahci_mem_write(void·*·s,·unsigned·size,·uint64_t·addr,·uint64_t·val)

2030

static·inline·void·trace_ahci_mem_write(void·*·s,·unsigned·size,·uint64_t·addr,·uint64_t·val)

2042

static·inline·void·_nocheck__trace_ahci_mem_write_host_unimpl(void·*·s,·unsigned·size,·const·char·*·reg,·uint64_t·addr)

2042

static·inline·void·_nocheck__trace_ahci_mem_write_host_unimpl(void·*·s,·unsigned·size,·const·char·*·reg,·uint64_t·addr)

2043

{

2043

{

2044

····if·(trace_event_get_state(TRACE_AHCI_MEM_WRITE_HOST_UNIMPL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2044

····if·(trace_event_get_state(TRACE_AHCI_MEM_WRITE_HOST_UNIMPL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2045

········if·(message_with_timestamp)·{

2045

········if·(message_with_timestamp)·{

2046

············struct·timeval·_now;

2046

············struct·timeval·_now;

2047

············gettimeofday(&_now,·NULL);

2047

············gettimeofday(&_now,·NULL);

2049

············qemu_log("%d@%zu.%06zu:ahci_mem_write_host_unimpl·"·"ahci(%p)·unimplemented·write%u·[reg:%s]·@·0x%"PRIx64·"\n",

2049

············qemu_log("%d@%zu.%06zu:ahci_mem_write_host_unimpl·"·"ahci(%p)·unimplemented·write%u·[reg:%s]·@·0x%"PRIx64·"\n",

2050

·····················qemu_get_thread_id(),

2050

·····················qemu_get_thread_id(),

2051

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2051

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2052

·····················,·s,·size,·reg,·addr);

2052

·····················,·s,·size,·reg,·addr);

2053

#line·2055·"trace/trace-hw_ide.h"

2053

#line·2055·"trace/trace-hw_ide.h"

2054

········}·else·{

2054

········}·else·{

2056

············qemu_log("ahci_mem_write_host_unimpl·"·"ahci(%p)·unimplemented·write%u·[reg:%s]·@·0x%"PRIx64·"\n",·s,·size,·reg,·addr);

2056

············qemu_log("ahci_mem_write_host_unimpl·"·"ahci(%p)·unimplemented·write%u·[reg:%s]·@·0x%"PRIx64·"\n",·s,·size,·reg,·addr);

2057

#line·2059·"trace/trace-hw_ide.h"

2057

#line·2059·"trace/trace-hw_ide.h"

2058

········}

2058

········}

2059

····}

2059

····}

2060

}

2060

}

2061

static·inline·void·trace_ahci_mem_write_host_unimpl(void·*·s,·unsigned·size,·const·char·*·reg,·uint64_t·addr)

2061

static·inline·void·trace_ahci_mem_write_host_unimpl(void·*·s,·unsigned·size,·const·char·*·reg,·uint64_t·addr)

2073

static·inline·void·_nocheck__trace_ahci_mem_write_host(void·*·s,·unsigned·size,·const·char·*·reg,·uint64_t·addr,·uint64_t·val)

2073

static·inline·void·_nocheck__trace_ahci_mem_write_host(void·*·s,·unsigned·size,·const·char·*·reg,·uint64_t·addr,·uint64_t·val)

2074

{

2074

{

2075

····if·(trace_event_get_state(TRACE_AHCI_MEM_WRITE_HOST)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2075

····if·(trace_event_get_state(TRACE_AHCI_MEM_WRITE_HOST)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2076

········if·(message_with_timestamp)·{

2076

········if·(message_with_timestamp)·{

2077

············struct·timeval·_now;

2077

············struct·timeval·_now;

2078

············gettimeofday(&_now,·NULL);

2078

············gettimeofday(&_now,·NULL);

2080

············qemu_log("%d@%zu.%06zu:ahci_mem_write_host·"·"ahci(%p)·write%u·[reg:%s]·@·0x%"PRIx64":·0x%016"PRIx64·"\n",

2080

············qemu_log("%d@%zu.%06zu:ahci_mem_write_host·"·"ahci(%p)·write%u·[reg:%s]·@·0x%"PRIx64":·0x%016"PRIx64·"\n",

2081

·····················qemu_get_thread_id(),

2081

·····················qemu_get_thread_id(),

2082

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2082

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2083

·····················,·s,·size,·reg,·addr,·val);

2083

·····················,·s,·size,·reg,·addr,·val);

2084

#line·2086·"trace/trace-hw_ide.h"

2084

#line·2086·"trace/trace-hw_ide.h"

2085

········}·else·{

2085

········}·else·{

2087

············qemu_log("ahci_mem_write_host·"·"ahci(%p)·write%u·[reg:%s]·@·0x%"PRIx64":·0x%016"PRIx64·"\n",·s,·size,·reg,·addr,·val);

2087

············qemu_log("ahci_mem_write_host·"·"ahci(%p)·write%u·[reg:%s]·@·0x%"PRIx64":·0x%016"PRIx64·"\n",·s,·size,·reg,·addr,·val);

2088

#line·2090·"trace/trace-hw_ide.h"

2088

#line·2090·"trace/trace-hw_ide.h"

2089

········}

2089

········}

2090

····}

2090

····}

2091

}

2091

}

2092

static·inline·void·trace_ahci_mem_write_host(void·*·s,·unsigned·size,·const·char·*·reg,·uint64_t·addr,·uint64_t·val)

2092

static·inline·void·trace_ahci_mem_write_host(void·*·s,·unsigned·size,·const·char·*·reg,·uint64_t·addr,·uint64_t·val)

2104

static·inline·void·_nocheck__trace_ahci_mem_write_unimpl(void·*·s,·unsigned·size,·uint64_t·addr,·uint64_t·val)

2104

static·inline·void·_nocheck__trace_ahci_mem_write_unimpl(void·*·s,·unsigned·size,·uint64_t·addr,·uint64_t·val)

2105

{

2105

{

2106

····if·(trace_event_get_state(TRACE_AHCI_MEM_WRITE_UNIMPL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2106

····if·(trace_event_get_state(TRACE_AHCI_MEM_WRITE_UNIMPL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2107

········if·(message_with_timestamp)·{

2107

········if·(message_with_timestamp)·{

2108

············struct·timeval·_now;

2108

············struct·timeval·_now;

2109

············gettimeofday(&_now,·NULL);

2109

············gettimeofday(&_now,·NULL);

2111

············qemu_log("%d@%zu.%06zu:ahci_mem_write_unimpl·"·"ahci(%p):·write%u·to·unknown·register·0x%"PRIx64":·0x%016"PRIx64·"\n",

2111

············qemu_log("%d@%zu.%06zu:ahci_mem_write_unimpl·"·"ahci(%p):·write%u·to·unknown·register·0x%"PRIx64":·0x%016"PRIx64·"\n",

2112

·····················qemu_get_thread_id(),

2112

·····················qemu_get_thread_id(),

2113

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2113

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2114

·····················,·s,·size,·addr,·val);

2114

·····················,·s,·size,·addr,·val);

2115

#line·2117·"trace/trace-hw_ide.h"

2115

#line·2117·"trace/trace-hw_ide.h"

2116

········}·else·{

2116

········}·else·{

2118

············qemu_log("ahci_mem_write_unimpl·"·"ahci(%p):·write%u·to·unknown·register·0x%"PRIx64":·0x%016"PRIx64·"\n",·s,·size,·addr,·val);

2118

············qemu_log("ahci_mem_write_unimpl·"·"ahci(%p):·write%u·to·unknown·register·0x%"PRIx64":·0x%016"PRIx64·"\n",·s,·size,·addr,·val);

2119

#line·2121·"trace/trace-hw_ide.h"

2119

#line·2121·"trace/trace-hw_ide.h"

2120

········}

2120

········}

2121

····}

2121

····}

2122

}

2122

}

2123

static·inline·void·trace_ahci_mem_write_unimpl(void·*·s,·unsigned·size,·uint64_t·addr,·uint64_t·val)

2123

static·inline·void·trace_ahci_mem_write_unimpl(void·*·s,·unsigned·size,·uint64_t·addr,·uint64_t·val)

2135

static·inline·void·_nocheck__trace_ahci_set_signature(void·*·s,·int·port,·uint8_t·nsector,·uint8_t·sector,·uint8_t·lcyl,·uint8_t·hcyl,·uint32_t·sig)

2135

static·inline·void·_nocheck__trace_ahci_set_signature(void·*·s,·int·port,·uint8_t·nsector,·uint8_t·sector,·uint8_t·lcyl,·uint8_t·hcyl,·uint32_t·sig)

2136

{

2136

{

2137

····if·(trace_event_get_state(TRACE_AHCI_SET_SIGNATURE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2137

····if·(trace_event_get_state(TRACE_AHCI_SET_SIGNATURE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2138

········if·(message_with_timestamp)·{

2138

········if·(message_with_timestamp)·{

2139

············struct·timeval·_now;

2139

············struct·timeval·_now;

2140

············gettimeofday(&_now,·NULL);

2140

············gettimeofday(&_now,·NULL);

2142

············qemu_log("%d@%zu.%06zu:ahci_set_signature·"·"ahci(%p)[%d]:·set·signature·sector:0x%02x·nsector:0x%02x·lcyl:0x%02x·hcyl:0x%02x·(cumulatively:·0x%08x)"·"\n",

2142

············qemu_log("%d@%zu.%06zu:ahci_set_signature·"·"ahci(%p)[%d]:·set·signature·sector:0x%02x·nsector:0x%02x·lcyl:0x%02x·hcyl:0x%02x·(cumulatively:·0x%08x)"·"\n",

2143

·····················qemu_get_thread_id(),

2143

·····················qemu_get_thread_id(),

2144

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2144

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2145

·····················,·s,·port,·nsector,·sector,·lcyl,·hcyl,·sig);

2145

·····················,·s,·port,·nsector,·sector,·lcyl,·hcyl,·sig);

2146

#line·2148·"trace/trace-hw_ide.h"

2146

#line·2148·"trace/trace-hw_ide.h"

2147

········}·else·{

2147

········}·else·{

2149

············qemu_log("ahci_set_signature·"·"ahci(%p)[%d]:·set·signature·sector:0x%02x·nsector:0x%02x·lcyl:0x%02x·hcyl:0x%02x·(cumulatively:·0x%08x)"·"\n",·s,·port,·nsector,·sector,·lcyl,·hcyl,·sig);

2149

············qemu_log("ahci_set_signature·"·"ahci(%p)[%d]:·set·signature·sector:0x%02x·nsector:0x%02x·lcyl:0x%02x·hcyl:0x%02x·(cumulatively:·0x%08x)"·"\n",·s,·port,·nsector,·sector,·lcyl,·hcyl,·sig);

2150

#line·2152·"trace/trace-hw_ide.h"

2150

#line·2152·"trace/trace-hw_ide.h"

2151

········}

2151

········}

2152

····}

2152

····}

2153

}

2153

}

2154

static·inline·void·trace_ahci_set_signature(void·*·s,·int·port,·uint8_t·nsector,·uint8_t·sector,·uint8_t·lcyl,·uint8_t·hcyl,·uint32_t·sig)

2154

static·inline·void·trace_ahci_set_signature(void·*·s,·int·port,·uint8_t·nsector,·uint8_t·sector,·uint8_t·lcyl,·uint8_t·hcyl,·uint32_t·sig)

2166

static·inline·void·_nocheck__trace_ahci_reset_port(void·*·s,·int·port)

2166

static·inline·void·_nocheck__trace_ahci_reset_port(void·*·s,·int·port)

2167

{

2167

{

2168

····if·(trace_event_get_state(TRACE_AHCI_RESET_PORT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2168

····if·(trace_event_get_state(TRACE_AHCI_RESET_PORT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2169

········if·(message_with_timestamp)·{

2169

········if·(message_with_timestamp)·{

2170

············struct·timeval·_now;

2170

············struct·timeval·_now;

2171

············gettimeofday(&_now,·NULL);

2171

············gettimeofday(&_now,·NULL);

2173

············qemu_log("%d@%zu.%06zu:ahci_reset_port·"·"ahci(%p)[%d]:·reset·port"·"\n",

2173

············qemu_log("%d@%zu.%06zu:ahci_reset_port·"·"ahci(%p)[%d]:·reset·port"·"\n",

2174

·····················qemu_get_thread_id(),

2174

·····················qemu_get_thread_id(),

2175

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2175

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2176

·····················,·s,·port);

2176

·····················,·s,·port);

2177

#line·2179·"trace/trace-hw_ide.h"

2177

#line·2179·"trace/trace-hw_ide.h"

2178

········}·else·{

2178

········}·else·{

2180

············qemu_log("ahci_reset_port·"·"ahci(%p)[%d]:·reset·port"·"\n",·s,·port);

2180

············qemu_log("ahci_reset_port·"·"ahci(%p)[%d]:·reset·port"·"\n",·s,·port);

2181

#line·2183·"trace/trace-hw_ide.h"

2181

#line·2183·"trace/trace-hw_ide.h"

2182

········}

2182

········}

2183

····}

2183

····}

2184

}

2184

}

2185

static·inline·void·trace_ahci_reset_port(void·*·s,·int·port)

2185

static·inline·void·trace_ahci_reset_port(void·*·s,·int·port)

2197

static·inline·void·_nocheck__trace_ahci_unmap_fis_address_null(void·*·s,·int·port)

2197

static·inline·void·_nocheck__trace_ahci_unmap_fis_address_null(void·*·s,·int·port)

2198

{

2198

{

2199

····if·(trace_event_get_state(TRACE_AHCI_UNMAP_FIS_ADDRESS_NULL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2199

····if·(trace_event_get_state(TRACE_AHCI_UNMAP_FIS_ADDRESS_NULL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2200

········if·(message_with_timestamp)·{

2200

········if·(message_with_timestamp)·{

2201

············struct·timeval·_now;

2201

············struct·timeval·_now;

2202

············gettimeofday(&_now,·NULL);

2202

············gettimeofday(&_now,·NULL);

2204

············qemu_log("%d@%zu.%06zu:ahci_unmap_fis_address_null·"·"ahci(%p)[%d]:·Attempt·to·unmap·NULL·FIS·address"·"\n",

2204

············qemu_log("%d@%zu.%06zu:ahci_unmap_fis_address_null·"·"ahci(%p)[%d]:·Attempt·to·unmap·NULL·FIS·address"·"\n",

2205

·····················qemu_get_thread_id(),

2205

·····················qemu_get_thread_id(),

2206

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2206

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2207

·····················,·s,·port);

2207

·····················,·s,·port);

2208

#line·2210·"trace/trace-hw_ide.h"

2208

#line·2210·"trace/trace-hw_ide.h"

2209

········}·else·{

2209

········}·else·{

2211

············qemu_log("ahci_unmap_fis_address_null·"·"ahci(%p)[%d]:·Attempt·to·unmap·NULL·FIS·address"·"\n",·s,·port);

2211

············qemu_log("ahci_unmap_fis_address_null·"·"ahci(%p)[%d]:·Attempt·to·unmap·NULL·FIS·address"·"\n",·s,·port);

2212

#line·2214·"trace/trace-hw_ide.h"

2212

#line·2214·"trace/trace-hw_ide.h"

2213

········}

2213

········}

2214

····}

2214

····}

2215

}

2215

}

2216

static·inline·void·trace_ahci_unmap_fis_address_null(void·*·s,·int·port)

2216

static·inline·void·trace_ahci_unmap_fis_address_null(void·*·s,·int·port)

2228

static·inline·void·_nocheck__trace_ahci_unmap_clb_address_null(void·*·s,·int·port)

2228

static·inline·void·_nocheck__trace_ahci_unmap_clb_address_null(void·*·s,·int·port)

2229

{

2229

{

2230

····if·(trace_event_get_state(TRACE_AHCI_UNMAP_CLB_ADDRESS_NULL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2230

····if·(trace_event_get_state(TRACE_AHCI_UNMAP_CLB_ADDRESS_NULL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2231

········if·(message_with_timestamp)·{

2231

········if·(message_with_timestamp)·{

2232

············struct·timeval·_now;

2232

············struct·timeval·_now;

2233

············gettimeofday(&_now,·NULL);

2233

············gettimeofday(&_now,·NULL);

2235

············qemu_log("%d@%zu.%06zu:ahci_unmap_clb_address_null·"·"ahci(%p)[%d]:·Attempt·to·unmap·NULL·CLB·address"·"\n",

2235

············qemu_log("%d@%zu.%06zu:ahci_unmap_clb_address_null·"·"ahci(%p)[%d]:·Attempt·to·unmap·NULL·CLB·address"·"\n",

2236

·····················qemu_get_thread_id(),

2236

·····················qemu_get_thread_id(),

2237

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2237

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2238

·····················,·s,·port);

2238

·····················,·s,·port);

2239

#line·2241·"trace/trace-hw_ide.h"

2239

#line·2241·"trace/trace-hw_ide.h"

2240

········}·else·{

2240

········}·else·{

2242

············qemu_log("ahci_unmap_clb_address_null·"·"ahci(%p)[%d]:·Attempt·to·unmap·NULL·CLB·address"·"\n",·s,·port);

2242

············qemu_log("ahci_unmap_clb_address_null·"·"ahci(%p)[%d]:·Attempt·to·unmap·NULL·CLB·address"·"\n",·s,·port);

2243

#line·2245·"trace/trace-hw_ide.h"

2243

#line·2245·"trace/trace-hw_ide.h"

2244

········}

2244

········}

2245

····}

2245

····}

2246

}

2246

}

2247

static·inline·void·trace_ahci_unmap_clb_address_null(void·*·s,·int·port)

2247

static·inline·void·trace_ahci_unmap_clb_address_null(void·*·s,·int·port)

2259

static·inline·void·_nocheck__trace_ahci_populate_sglist(void·*·s,·int·port)

2259

static·inline·void·_nocheck__trace_ahci_populate_sglist(void·*·s,·int·port)

2260

{

2260

{

2261

····if·(trace_event_get_state(TRACE_AHCI_POPULATE_SGLIST)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2261

····if·(trace_event_get_state(TRACE_AHCI_POPULATE_SGLIST)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2262

········if·(message_with_timestamp)·{

2262

········if·(message_with_timestamp)·{

2263

············struct·timeval·_now;

2263

············struct·timeval·_now;

2264

············gettimeofday(&_now,·NULL);

2264

············gettimeofday(&_now,·NULL);

2266

············qemu_log("%d@%zu.%06zu:ahci_populate_sglist·"·"ahci(%p)[%d]"·"\n",

2266

············qemu_log("%d@%zu.%06zu:ahci_populate_sglist·"·"ahci(%p)[%d]"·"\n",

2267

·····················qemu_get_thread_id(),

2267

·····················qemu_get_thread_id(),

2268

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2268

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2269

·····················,·s,·port);

2269

·····················,·s,·port);

2270

#line·2272·"trace/trace-hw_ide.h"

2270

#line·2272·"trace/trace-hw_ide.h"

2271

········}·else·{

2271

········}·else·{

2273

············qemu_log("ahci_populate_sglist·"·"ahci(%p)[%d]"·"\n",·s,·port);

2273

············qemu_log("ahci_populate_sglist·"·"ahci(%p)[%d]"·"\n",·s,·port);

2274

#line·2276·"trace/trace-hw_ide.h"

2274

#line·2276·"trace/trace-hw_ide.h"

2275

········}

2275

········}

2276

····}

2276

····}

2277

}

2277

}

2278

static·inline·void·trace_ahci_populate_sglist(void·*·s,·int·port)

2278

static·inline·void·trace_ahci_populate_sglist(void·*·s,·int·port)

2290

static·inline·void·_nocheck__trace_ahci_populate_sglist_no_prdtl(void·*·s,·int·port,·uint16_t·opts)

2290

static·inline·void·_nocheck__trace_ahci_populate_sglist_no_prdtl(void·*·s,·int·port,·uint16_t·opts)

2291

{

2291

{

2292

····if·(trace_event_get_state(TRACE_AHCI_POPULATE_SGLIST_NO_PRDTL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2292

····if·(trace_event_get_state(TRACE_AHCI_POPULATE_SGLIST_NO_PRDTL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2293

········if·(message_with_timestamp)·{

2293

········if·(message_with_timestamp)·{

2294

············struct·timeval·_now;

2294

············struct·timeval·_now;

2295

············gettimeofday(&_now,·NULL);

2295

············gettimeofday(&_now,·NULL);

2297

············qemu_log("%d@%zu.%06zu:ahci_populate_sglist_no_prdtl·"·"ahci(%p)[%d]:·no·sg·list·given·by·guest:·0x%04x"·"\n",

2297

············qemu_log("%d@%zu.%06zu:ahci_populate_sglist_no_prdtl·"·"ahci(%p)[%d]:·no·sg·list·given·by·guest:·0x%04x"·"\n",

2298

·····················qemu_get_thread_id(),

2298

·····················qemu_get_thread_id(),

2299

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2299

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2300

·····················,·s,·port,·opts);

2300

·····················,·s,·port,·opts);

2301

#line·2303·"trace/trace-hw_ide.h"

2301

#line·2303·"trace/trace-hw_ide.h"

2302

········}·else·{

2302

········}·else·{

2304

············qemu_log("ahci_populate_sglist_no_prdtl·"·"ahci(%p)[%d]:·no·sg·list·given·by·guest:·0x%04x"·"\n",·s,·port,·opts);

2304

············qemu_log("ahci_populate_sglist_no_prdtl·"·"ahci(%p)[%d]:·no·sg·list·given·by·guest:·0x%04x"·"\n",·s,·port,·opts);

2305

#line·2307·"trace/trace-hw_ide.h"

2305

#line·2307·"trace/trace-hw_ide.h"

2306

········}

2306

········}

2307

····}

2307

····}

2308

}

2308

}

2309

static·inline·void·trace_ahci_populate_sglist_no_prdtl(void·*·s,·int·port,·uint16_t·opts)

2309

static·inline·void·trace_ahci_populate_sglist_no_prdtl(void·*·s,·int·port,·uint16_t·opts)

2321

static·inline·void·_nocheck__trace_ahci_populate_sglist_no_map(void·*·s,·int·port)

2321

static·inline·void·_nocheck__trace_ahci_populate_sglist_no_map(void·*·s,·int·port)

2322

{

2322

{

2323

····if·(trace_event_get_state(TRACE_AHCI_POPULATE_SGLIST_NO_MAP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2323

····if·(trace_event_get_state(TRACE_AHCI_POPULATE_SGLIST_NO_MAP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2324

········if·(message_with_timestamp)·{

2324

········if·(message_with_timestamp)·{

2325

············struct·timeval·_now;

2325

············struct·timeval·_now;

2326

············gettimeofday(&_now,·NULL);

2326

············gettimeofday(&_now,·NULL);

2328

············qemu_log("%d@%zu.%06zu:ahci_populate_sglist_no_map·"·"ahci(%p)[%d]:·DMA·mapping·failed"·"\n",

2328

············qemu_log("%d@%zu.%06zu:ahci_populate_sglist_no_map·"·"ahci(%p)[%d]:·DMA·mapping·failed"·"\n",

2329

·····················qemu_get_thread_id(),

2329

·····················qemu_get_thread_id(),

2330

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2330

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2331

·····················,·s,·port);

2331

·····················,·s,·port);

2332

#line·2334·"trace/trace-hw_ide.h"

2332

#line·2334·"trace/trace-hw_ide.h"

2333

········}·else·{

2333

········}·else·{

2335

············qemu_log("ahci_populate_sglist_no_map·"·"ahci(%p)[%d]:·DMA·mapping·failed"·"\n",·s,·port);

2335

············qemu_log("ahci_populate_sglist_no_map·"·"ahci(%p)[%d]:·DMA·mapping·failed"·"\n",·s,·port);

2336

#line·2338·"trace/trace-hw_ide.h"

2336

#line·2338·"trace/trace-hw_ide.h"

2337

········}

2337

········}

2338

····}

2338

····}

2339

}

2339

}

2340

static·inline·void·trace_ahci_populate_sglist_no_map(void·*·s,·int·port)

2340

static·inline·void·trace_ahci_populate_sglist_no_map(void·*·s,·int·port)

2352

static·inline·void·_nocheck__trace_ahci_populate_sglist_short_map(void·*·s,·int·port)

2352

static·inline·void·_nocheck__trace_ahci_populate_sglist_short_map(void·*·s,·int·port)

2353

{

2353

{

2354

····if·(trace_event_get_state(TRACE_AHCI_POPULATE_SGLIST_SHORT_MAP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2354

····if·(trace_event_get_state(TRACE_AHCI_POPULATE_SGLIST_SHORT_MAP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2355

········if·(message_with_timestamp)·{

2355

········if·(message_with_timestamp)·{

2356

············struct·timeval·_now;

2356

············struct·timeval·_now;

2357

············gettimeofday(&_now,·NULL);

2357

············gettimeofday(&_now,·NULL);

2359

············qemu_log("%d@%zu.%06zu:ahci_populate_sglist_short_map·"·"ahci(%p)[%d]:·mapped·less·than·expected"·"\n",

2359

············qemu_log("%d@%zu.%06zu:ahci_populate_sglist_short_map·"·"ahci(%p)[%d]:·mapped·less·than·expected"·"\n",

2360

·····················qemu_get_thread_id(),

2360

·····················qemu_get_thread_id(),

2361

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2361

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2362

·····················,·s,·port);

2362

·····················,·s,·port);

2363

#line·2365·"trace/trace-hw_ide.h"

2363

#line·2365·"trace/trace-hw_ide.h"

2364

········}·else·{

2364

········}·else·{

2366

············qemu_log("ahci_populate_sglist_short_map·"·"ahci(%p)[%d]:·mapped·less·than·expected"·"\n",·s,·port);

2366

············qemu_log("ahci_populate_sglist_short_map·"·"ahci(%p)[%d]:·mapped·less·than·expected"·"\n",·s,·port);

2367

#line·2369·"trace/trace-hw_ide.h"

2367

#line·2369·"trace/trace-hw_ide.h"

2368

········}

2368

········}

2369

····}

2369

····}

2370

}

2370

}

2371

static·inline·void·trace_ahci_populate_sglist_short_map(void·*·s,·int·port)

2371

static·inline·void·trace_ahci_populate_sglist_short_map(void·*·s,·int·port)

2383

static·inline·void·_nocheck__trace_ahci_populate_sglist_bad_offset(void·*·s,·int·port,·int·off_idx,·int64_t·off_pos)

2383

static·inline·void·_nocheck__trace_ahci_populate_sglist_bad_offset(void·*·s,·int·port,·int·off_idx,·int64_t·off_pos)

2384

{

2384

{

2385

····if·(trace_event_get_state(TRACE_AHCI_POPULATE_SGLIST_BAD_OFFSET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2385

····if·(trace_event_get_state(TRACE_AHCI_POPULATE_SGLIST_BAD_OFFSET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2386

········if·(message_with_timestamp)·{

2386

········if·(message_with_timestamp)·{

2387

············struct·timeval·_now;

2387

············struct·timeval·_now;

2388

············gettimeofday(&_now,·NULL);

2388

············gettimeofday(&_now,·NULL);

2390

············qemu_log("%d@%zu.%06zu:ahci_populate_sglist_bad_offset·"·"ahci(%p)[%d]:·Incorrect·offset!·off_idx:·%d,·off_pos:·%"PRId64·"\n",

2390

············qemu_log("%d@%zu.%06zu:ahci_populate_sglist_bad_offset·"·"ahci(%p)[%d]:·Incorrect·offset!·off_idx:·%d,·off_pos:·%"PRId64·"\n",

2391

·····················qemu_get_thread_id(),

2391

·····················qemu_get_thread_id(),

2392

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2392

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2393

·····················,·s,·port,·off_idx,·off_pos);

2393

·····················,·s,·port,·off_idx,·off_pos);

2394

#line·2396·"trace/trace-hw_ide.h"

2394

#line·2396·"trace/trace-hw_ide.h"

2395

········}·else·{

2395

········}·else·{

2397

············qemu_log("ahci_populate_sglist_bad_offset·"·"ahci(%p)[%d]:·Incorrect·offset!·off_idx:·%d,·off_pos:·%"PRId64·"\n",·s,·port,·off_idx,·off_pos);

2397

············qemu_log("ahci_populate_sglist_bad_offset·"·"ahci(%p)[%d]:·Incorrect·offset!·off_idx:·%d,·off_pos:·%"PRId64·"\n",·s,·port,·off_idx,·off_pos);

2398

#line·2400·"trace/trace-hw_ide.h"

2398

#line·2400·"trace/trace-hw_ide.h"

2399

········}

2399

········}

2400

····}

2400

····}

2401

}

2401

}

2402

static·inline·void·trace_ahci_populate_sglist_bad_offset(void·*·s,·int·port,·int·off_idx,·int64_t·off_pos)

2402

static·inline·void·trace_ahci_populate_sglist_bad_offset(void·*·s,·int·port,·int·off_idx,·int64_t·off_pos)

2414

static·inline·void·_nocheck__trace_ncq_finish(void·*·s,·int·port,·uint8_t·tag)

2414

static·inline·void·_nocheck__trace_ncq_finish(void·*·s,·int·port,·uint8_t·tag)

2415

{

2415

{

2416

····if·(trace_event_get_state(TRACE_NCQ_FINISH)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2416

····if·(trace_event_get_state(TRACE_NCQ_FINISH)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2417

········if·(message_with_timestamp)·{

2417

········if·(message_with_timestamp)·{

2418

············struct·timeval·_now;

2418

············struct·timeval·_now;

2419

············gettimeofday(&_now,·NULL);

2419

············gettimeofday(&_now,·NULL);

2421

············qemu_log("%d@%zu.%06zu:ncq_finish·"·"ahci(%p)[%d][tag:%d]:·NCQ·transfer·finished"·"\n",

2421

············qemu_log("%d@%zu.%06zu:ncq_finish·"·"ahci(%p)[%d][tag:%d]:·NCQ·transfer·finished"·"\n",

2422

·····················qemu_get_thread_id(),

2422

·····················qemu_get_thread_id(),

2423

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2423

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2424

·····················,·s,·port,·tag);

2424

·····················,·s,·port,·tag);

2425

#line·2427·"trace/trace-hw_ide.h"

2425

#line·2427·"trace/trace-hw_ide.h"

2426

········}·else·{

2426

········}·else·{

2428

············qemu_log("ncq_finish·"·"ahci(%p)[%d][tag:%d]:·NCQ·transfer·finished"·"\n",·s,·port,·tag);

2428

············qemu_log("ncq_finish·"·"ahci(%p)[%d][tag:%d]:·NCQ·transfer·finished"·"\n",·s,·port,·tag);

2429

#line·2431·"trace/trace-hw_ide.h"

2429

#line·2431·"trace/trace-hw_ide.h"

2430

········}

2430

········}

2431

····}

2431

····}

2432

}

2432

}

2433

static·inline·void·trace_ncq_finish(void·*·s,·int·port,·uint8_t·tag)

2433

static·inline·void·trace_ncq_finish(void·*·s,·int·port,·uint8_t·tag)

2445

static·inline·void·_nocheck__trace_execute_ncq_command_read(void·*·s,·int·port,·uint8_t·tag,·int·count,·int64_t·lba)

2445

static·inline·void·_nocheck__trace_execute_ncq_command_read(void·*·s,·int·port,·uint8_t·tag,·int·count,·int64_t·lba)

2446

{

2446

{

2447

····if·(trace_event_get_state(TRACE_EXECUTE_NCQ_COMMAND_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2447

····if·(trace_event_get_state(TRACE_EXECUTE_NCQ_COMMAND_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2448

········if·(message_with_timestamp)·{

2448

········if·(message_with_timestamp)·{

2449

············struct·timeval·_now;

2449

············struct·timeval·_now;

2450

············gettimeofday(&_now,·NULL);

2450

············gettimeofday(&_now,·NULL);

2452

············qemu_log("%d@%zu.%06zu:execute_ncq_command_read·"·"ahci(%p)[%d][tag:%d]:·NCQ·reading·%d·sectors·from·LBA·%"PRId64·"\n",

2452

············qemu_log("%d@%zu.%06zu:execute_ncq_command_read·"·"ahci(%p)[%d][tag:%d]:·NCQ·reading·%d·sectors·from·LBA·%"PRId64·"\n",

2453

·····················qemu_get_thread_id(),

2453

·····················qemu_get_thread_id(),

2454

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2454

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2455

·····················,·s,·port,·tag,·count,·lba);

2455

·····················,·s,·port,·tag,·count,·lba);

2456

#line·2458·"trace/trace-hw_ide.h"

2456

#line·2458·"trace/trace-hw_ide.h"

2457

········}·else·{

2457

········}·else·{

2459

············qemu_log("execute_ncq_command_read·"·"ahci(%p)[%d][tag:%d]:·NCQ·reading·%d·sectors·from·LBA·%"PRId64·"\n",·s,·port,·tag,·count,·lba);

2459

············qemu_log("execute_ncq_command_read·"·"ahci(%p)[%d][tag:%d]:·NCQ·reading·%d·sectors·from·LBA·%"PRId64·"\n",·s,·port,·tag,·count,·lba);

2460

#line·2462·"trace/trace-hw_ide.h"

2460

#line·2462·"trace/trace-hw_ide.h"

2461

········}

2461

········}

2462

····}

2462

····}

2463

}

2463

}

2464

static·inline·void·trace_execute_ncq_command_read(void·*·s,·int·port,·uint8_t·tag,·int·count,·int64_t·lba)

2464

static·inline·void·trace_execute_ncq_command_read(void·*·s,·int·port,·uint8_t·tag,·int·count,·int64_t·lba)

2476

static·inline·void·_nocheck__trace_execute_ncq_command_unsup(void·*·s,·int·port,·uint8_t·tag,·uint8_t·cmd)

2476

static·inline·void·_nocheck__trace_execute_ncq_command_unsup(void·*·s,·int·port,·uint8_t·tag,·uint8_t·cmd)

2477

{

2477

{

2478

····if·(trace_event_get_state(TRACE_EXECUTE_NCQ_COMMAND_UNSUP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2478

····if·(trace_event_get_state(TRACE_EXECUTE_NCQ_COMMAND_UNSUP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2479

········if·(message_with_timestamp)·{

2479

········if·(message_with_timestamp)·{

2480

············struct·timeval·_now;

2480

············struct·timeval·_now;

2481

············gettimeofday(&_now,·NULL);

2481

············gettimeofday(&_now,·NULL);

2483

············qemu_log("%d@%zu.%06zu:execute_ncq_command_unsup·"·"ahci(%p)[%d][tag:%d]:·error:·unsupported·NCQ·command·(0x%02x)·received"·"\n",

2483

············qemu_log("%d@%zu.%06zu:execute_ncq_command_unsup·"·"ahci(%p)[%d][tag:%d]:·error:·unsupported·NCQ·command·(0x%02x)·received"·"\n",

2484

·····················qemu_get_thread_id(),

2484

·····················qemu_get_thread_id(),

2485

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2485

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2486

·····················,·s,·port,·tag,·cmd);

2486

·····················,·s,·port,·tag,·cmd);

2487

#line·2489·"trace/trace-hw_ide.h"

2487

#line·2489·"trace/trace-hw_ide.h"

2488

········}·else·{

2488

········}·else·{

2490

············qemu_log("execute_ncq_command_unsup·"·"ahci(%p)[%d][tag:%d]:·error:·unsupported·NCQ·command·(0x%02x)·received"·"\n",·s,·port,·tag,·cmd);

2490

············qemu_log("execute_ncq_command_unsup·"·"ahci(%p)[%d][tag:%d]:·error:·unsupported·NCQ·command·(0x%02x)·received"·"\n",·s,·port,·tag,·cmd);

2491

#line·2493·"trace/trace-hw_ide.h"

2491

#line·2493·"trace/trace-hw_ide.h"

2492

········}

2492

········}

2493

····}

2493

····}

2494

}

2494

}

2495

static·inline·void·trace_execute_ncq_command_unsup(void·*·s,·int·port,·uint8_t·tag,·uint8_t·cmd)

2495

static·inline·void·trace_execute_ncq_command_unsup(void·*·s,·int·port,·uint8_t·tag,·uint8_t·cmd)

2507

static·inline·void·_nocheck__trace_process_ncq_command_mismatch(void·*·s,·int·port,·uint8_t·tag,·uint8_t·slot)

2507

static·inline·void·_nocheck__trace_process_ncq_command_mismatch(void·*·s,·int·port,·uint8_t·tag,·uint8_t·slot)

2508

{

2508

{

2509

····if·(trace_event_get_state(TRACE_PROCESS_NCQ_COMMAND_MISMATCH)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2509

····if·(trace_event_get_state(TRACE_PROCESS_NCQ_COMMAND_MISMATCH)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2510

········if·(message_with_timestamp)·{

2510

········if·(message_with_timestamp)·{

2511

············struct·timeval·_now;

2511

············struct·timeval·_now;

2512

············gettimeofday(&_now,·NULL);

2512

············gettimeofday(&_now,·NULL);

2514

············qemu_log("%d@%zu.%06zu:process_ncq_command_mismatch·"·"ahci(%p)[%d][tag:%d]:·Warning:·NCQ·slot·(%d)·did·not·match·the·given·tag"·"\n",

2514

············qemu_log("%d@%zu.%06zu:process_ncq_command_mismatch·"·"ahci(%p)[%d][tag:%d]:·Warning:·NCQ·slot·(%d)·did·not·match·the·given·tag"·"\n",

2515

·····················qemu_get_thread_id(),

2515

·····················qemu_get_thread_id(),

2516

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2516

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2517

·····················,·s,·port,·tag,·slot);

2517

·····················,·s,·port,·tag,·slot);

2518

#line·2520·"trace/trace-hw_ide.h"

2518

#line·2520·"trace/trace-hw_ide.h"

2519

········}·else·{

2519

········}·else·{

2521

············qemu_log("process_ncq_command_mismatch·"·"ahci(%p)[%d][tag:%d]:·Warning:·NCQ·slot·(%d)·did·not·match·the·given·tag"·"\n",·s,·port,·tag,·slot);

2521

············qemu_log("process_ncq_command_mismatch·"·"ahci(%p)[%d][tag:%d]:·Warning:·NCQ·slot·(%d)·did·not·match·the·given·tag"·"\n",·s,·port,·tag,·slot);

2522

#line·2524·"trace/trace-hw_ide.h"

2522

#line·2524·"trace/trace-hw_ide.h"

2523

········}

2523

········}

2524

····}

2524

····}

2525

}

2525

}

2526

static·inline·void·trace_process_ncq_command_mismatch(void·*·s,·int·port,·uint8_t·tag,·uint8_t·slot)

2526

static·inline·void·trace_process_ncq_command_mismatch(void·*·s,·int·port,·uint8_t·tag,·uint8_t·slot)

2538

static·inline·void·_nocheck__trace_process_ncq_command_aux(void·*·s,·int·port,·uint8_t·tag)

2538

static·inline·void·_nocheck__trace_process_ncq_command_aux(void·*·s,·int·port,·uint8_t·tag)

2539

{

2539

{

2540

····if·(trace_event_get_state(TRACE_PROCESS_NCQ_COMMAND_AUX)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2540

····if·(trace_event_get_state(TRACE_PROCESS_NCQ_COMMAND_AUX)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2541

········if·(message_with_timestamp)·{

2541

········if·(message_with_timestamp)·{

2542

············struct·timeval·_now;

2542

············struct·timeval·_now;

2543

············gettimeofday(&_now,·NULL);

2543

············gettimeofday(&_now,·NULL);

2545

············qemu_log("%d@%zu.%06zu:process_ncq_command_aux·"·"ahci(%p)[%d][tag:%d]:·Warn:·Attempt·to·use·NCQ·auxiliary·fields"·"\n",

2545

············qemu_log("%d@%zu.%06zu:process_ncq_command_aux·"·"ahci(%p)[%d][tag:%d]:·Warn:·Attempt·to·use·NCQ·auxiliary·fields"·"\n",

2546

·····················qemu_get_thread_id(),

2546

·····················qemu_get_thread_id(),

2547

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2547

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2548

·····················,·s,·port,·tag);

2548

·····················,·s,·port,·tag);

2549

#line·2551·"trace/trace-hw_ide.h"

2549

#line·2551·"trace/trace-hw_ide.h"

2550

········}·else·{

2550

········}·else·{

2552

············qemu_log("process_ncq_command_aux·"·"ahci(%p)[%d][tag:%d]:·Warn:·Attempt·to·use·NCQ·auxiliary·fields"·"\n",·s,·port,·tag);

2552

············qemu_log("process_ncq_command_aux·"·"ahci(%p)[%d][tag:%d]:·Warn:·Attempt·to·use·NCQ·auxiliary·fields"·"\n",·s,·port,·tag);

2553

#line·2555·"trace/trace-hw_ide.h"

2553

#line·2555·"trace/trace-hw_ide.h"

2554

········}

2554

········}

2555

····}

2555

····}

2556

}

2556

}

2557

static·inline·void·trace_process_ncq_command_aux(void·*·s,·int·port,·uint8_t·tag)

2557

static·inline·void·trace_process_ncq_command_aux(void·*·s,·int·port,·uint8_t·tag)

2569

static·inline·void·_nocheck__trace_process_ncq_command_prioicc(void·*·s,·int·port,·uint8_t·tag)

2569

static·inline·void·_nocheck__trace_process_ncq_command_prioicc(void·*·s,·int·port,·uint8_t·tag)

2570

{

2570

{

2571

····if·(trace_event_get_state(TRACE_PROCESS_NCQ_COMMAND_PRIOICC)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2571

····if·(trace_event_get_state(TRACE_PROCESS_NCQ_COMMAND_PRIOICC)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2572

········if·(message_with_timestamp)·{

2572

········if·(message_with_timestamp)·{

2573

············struct·timeval·_now;

2573

············struct·timeval·_now;

2574

············gettimeofday(&_now,·NULL);

2574

············gettimeofday(&_now,·NULL);

2576

············qemu_log("%d@%zu.%06zu:process_ncq_command_prioicc·"·"ahci(%p)[%d][tag:%d]:·Warn:·Unsupported·attempt·to·use·PRIO/ICC·fields"·"\n",

2576

············qemu_log("%d@%zu.%06zu:process_ncq_command_prioicc·"·"ahci(%p)[%d][tag:%d]:·Warn:·Unsupported·attempt·to·use·PRIO/ICC·fields"·"\n",

2577

·····················qemu_get_thread_id(),

2577

·····················qemu_get_thread_id(),

2578

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2578

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2579

·····················,·s,·port,·tag);

2579

·····················,·s,·port,·tag);

2580

#line·2582·"trace/trace-hw_ide.h"

2580

#line·2582·"trace/trace-hw_ide.h"

2581

········}·else·{

2581

········}·else·{

2583

············qemu_log("process_ncq_command_prioicc·"·"ahci(%p)[%d][tag:%d]:·Warn:·Unsupported·attempt·to·use·PRIO/ICC·fields"·"\n",·s,·port,·tag);

2583

············qemu_log("process_ncq_command_prioicc·"·"ahci(%p)[%d][tag:%d]:·Warn:·Unsupported·attempt·to·use·PRIO/ICC·fields"·"\n",·s,·port,·tag);

2584

#line·2586·"trace/trace-hw_ide.h"

2584

#line·2586·"trace/trace-hw_ide.h"

2585

········}

2585

········}

2586

····}

2586

····}

2587

}

2587

}

2588

static·inline·void·trace_process_ncq_command_prioicc(void·*·s,·int·port,·uint8_t·tag)

2588

static·inline·void·trace_process_ncq_command_prioicc(void·*·s,·int·port,·uint8_t·tag)

2600

static·inline·void·_nocheck__trace_process_ncq_command_fua(void·*·s,·int·port,·uint8_t·tag)

2600

static·inline·void·_nocheck__trace_process_ncq_command_fua(void·*·s,·int·port,·uint8_t·tag)

2601

{

2601

{

2602

····if·(trace_event_get_state(TRACE_PROCESS_NCQ_COMMAND_FUA)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2602

····if·(trace_event_get_state(TRACE_PROCESS_NCQ_COMMAND_FUA)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2603

········if·(message_with_timestamp)·{

2603

········if·(message_with_timestamp)·{

2604

············struct·timeval·_now;

2604

············struct·timeval·_now;

2605

············gettimeofday(&_now,·NULL);

2605

············gettimeofday(&_now,·NULL);

2607

············qemu_log("%d@%zu.%06zu:process_ncq_command_fua·"·"ahci(%p)[%d][tag:%d]:·Warn:·Unsupported·attempt·to·use·Force·Unit·Access"·"\n",

2607

············qemu_log("%d@%zu.%06zu:process_ncq_command_fua·"·"ahci(%p)[%d][tag:%d]:·Warn:·Unsupported·attempt·to·use·Force·Unit·Access"·"\n",

2608

·····················qemu_get_thread_id(),

2608

·····················qemu_get_thread_id(),

2609

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2609

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2610

·····················,·s,·port,·tag);

2610

·····················,·s,·port,·tag);

2611

#line·2613·"trace/trace-hw_ide.h"

2611

#line·2613·"trace/trace-hw_ide.h"

2612

········}·else·{

2612

········}·else·{

2614

············qemu_log("process_ncq_command_fua·"·"ahci(%p)[%d][tag:%d]:·Warn:·Unsupported·attempt·to·use·Force·Unit·Access"·"\n",·s,·port,·tag);

2614

············qemu_log("process_ncq_command_fua·"·"ahci(%p)[%d][tag:%d]:·Warn:·Unsupported·attempt·to·use·Force·Unit·Access"·"\n",·s,·port,·tag);

2615

#line·2617·"trace/trace-hw_ide.h"

2615

#line·2617·"trace/trace-hw_ide.h"

2616

········}

2616

········}

2617

····}

2617

····}

2618

}

2618

}

2619

static·inline·void·trace_process_ncq_command_fua(void·*·s,·int·port,·uint8_t·tag)

2619

static·inline·void·trace_process_ncq_command_fua(void·*·s,·int·port,·uint8_t·tag)

2631

static·inline·void·_nocheck__trace_process_ncq_command_rarc(void·*·s,·int·port,·uint8_t·tag)

2631

static·inline·void·_nocheck__trace_process_ncq_command_rarc(void·*·s,·int·port,·uint8_t·tag)

2632

{

2632

{

2633

····if·(trace_event_get_state(TRACE_PROCESS_NCQ_COMMAND_RARC)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2633

····if·(trace_event_get_state(TRACE_PROCESS_NCQ_COMMAND_RARC)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2634

········if·(message_with_timestamp)·{

2634

········if·(message_with_timestamp)·{

2635

············struct·timeval·_now;

2635

············struct·timeval·_now;

2636

············gettimeofday(&_now,·NULL);

2636

············gettimeofday(&_now,·NULL);

2638

············qemu_log("%d@%zu.%06zu:process_ncq_command_rarc·"·"ahci(%p)[%d][tag:%d]:·Warn:·Unsupported·attempt·to·use·Rebuild·Assist"·"\n",

2638

············qemu_log("%d@%zu.%06zu:process_ncq_command_rarc·"·"ahci(%p)[%d][tag:%d]:·Warn:·Unsupported·attempt·to·use·Rebuild·Assist"·"\n",

2639

·····················qemu_get_thread_id(),

2639

·····················qemu_get_thread_id(),

2640

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2640

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2641

·····················,·s,·port,·tag);

2641

·····················,·s,·port,·tag);

2642

#line·2644·"trace/trace-hw_ide.h"

2642

#line·2644·"trace/trace-hw_ide.h"

2643

········}·else·{

2643

········}·else·{

2645

············qemu_log("process_ncq_command_rarc·"·"ahci(%p)[%d][tag:%d]:·Warn:·Unsupported·attempt·to·use·Rebuild·Assist"·"\n",·s,·port,·tag);

2645

············qemu_log("process_ncq_command_rarc·"·"ahci(%p)[%d][tag:%d]:·Warn:·Unsupported·attempt·to·use·Rebuild·Assist"·"\n",·s,·port,·tag);

2646

#line·2648·"trace/trace-hw_ide.h"

2646

#line·2648·"trace/trace-hw_ide.h"

2647

········}

2647

········}

2648

····}

2648

····}

2649

}

2649

}

2650

static·inline·void·trace_process_ncq_command_rarc(void·*·s,·int·port,·uint8_t·tag)

2650

static·inline·void·trace_process_ncq_command_rarc(void·*·s,·int·port,·uint8_t·tag)

2662

static·inline·void·_nocheck__trace_process_ncq_command_large(void·*·s,·int·port,·uint8_t·tag,·size_t·prdtl,·size_t·size)

2662

static·inline·void·_nocheck__trace_process_ncq_command_large(void·*·s,·int·port,·uint8_t·tag,·size_t·prdtl,·size_t·size)

2663

{

2663

{

2664

····if·(trace_event_get_state(TRACE_PROCESS_NCQ_COMMAND_LARGE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2664

····if·(trace_event_get_state(TRACE_PROCESS_NCQ_COMMAND_LARGE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2665

········if·(message_with_timestamp)·{

2665

········if·(message_with_timestamp)·{

2666

············struct·timeval·_now;

2666

············struct·timeval·_now;

2667

············gettimeofday(&_now,·NULL);

2667

············gettimeofday(&_now,·NULL);

2669

············qemu_log("%d@%zu.%06zu:process_ncq_command_large·"·"ahci(%p)[%d][tag:%d]:·Warn:·PRDTL·(0x%zx)·does·not·match·requested·size·(0x%zx)"·"\n",

2669

············qemu_log("%d@%zu.%06zu:process_ncq_command_large·"·"ahci(%p)[%d][tag:%d]:·Warn:·PRDTL·(0x%zx)·does·not·match·requested·size·(0x%zx)"·"\n",

2670

·····················qemu_get_thread_id(),

2670

·····················qemu_get_thread_id(),

2671

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2671

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2672

·····················,·s,·port,·tag,·prdtl,·size);

2672

·····················,·s,·port,·tag,·prdtl,·size);

2673

#line·2675·"trace/trace-hw_ide.h"

2673

#line·2675·"trace/trace-hw_ide.h"

2674

········}·else·{

2674

········}·else·{

2676

············qemu_log("process_ncq_command_large·"·"ahci(%p)[%d][tag:%d]:·Warn:·PRDTL·(0x%zx)·does·not·match·requested·size·(0x%zx)"·"\n",·s,·port,·tag,·prdtl,·size);

2676

············qemu_log("process_ncq_command_large·"·"ahci(%p)[%d][tag:%d]:·Warn:·PRDTL·(0x%zx)·does·not·match·requested·size·(0x%zx)"·"\n",·s,·port,·tag,·prdtl,·size);

2677

#line·2679·"trace/trace-hw_ide.h"

2677

#line·2679·"trace/trace-hw_ide.h"

2678

········}

2678

········}

2679

····}

2679

····}

2680

}

2680

}

2681

static·inline·void·trace_process_ncq_command_large(void·*·s,·int·port,·uint8_t·tag,·size_t·prdtl,·size_t·size)

2681

static·inline·void·trace_process_ncq_command_large(void·*·s,·int·port,·uint8_t·tag,·size_t·prdtl,·size_t·size)

2693

static·inline·void·_nocheck__trace_process_ncq_command(void·*·s,·int·port,·uint8_t·tag,·uint8_t·cmd,·uint64_t·lba,·uint64_t·end)

2693

static·inline·void·_nocheck__trace_process_ncq_command(void·*·s,·int·port,·uint8_t·tag,·uint8_t·cmd,·uint64_t·lba,·uint64_t·end)

2694

{

2694

{

2695

····if·(trace_event_get_state(TRACE_PROCESS_NCQ_COMMAND)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2695

····if·(trace_event_get_state(TRACE_PROCESS_NCQ_COMMAND)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2696

········if·(message_with_timestamp)·{

2696

········if·(message_with_timestamp)·{

2697

············struct·timeval·_now;

2697

············struct·timeval·_now;

2698

············gettimeofday(&_now,·NULL);

2698

············gettimeofday(&_now,·NULL);

2700

············qemu_log("%d@%zu.%06zu:process_ncq_command·"·"ahci(%p)[%d][tag:%d]:·NCQ·op·0x%02x·on·sectors·[%"PRId64",%"PRId64"]"·"\n",

2700

············qemu_log("%d@%zu.%06zu:process_ncq_command·"·"ahci(%p)[%d][tag:%d]:·NCQ·op·0x%02x·on·sectors·[%"PRId64",%"PRId64"]"·"\n",

2701

·····················qemu_get_thread_id(),

2701

·····················qemu_get_thread_id(),

2702

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2702

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2703

·····················,·s,·port,·tag,·cmd,·lba,·end);

2703

·····················,·s,·port,·tag,·cmd,·lba,·end);

2704

#line·2706·"trace/trace-hw_ide.h"

2704

#line·2706·"trace/trace-hw_ide.h"

2705

········}·else·{

2705

········}·else·{

2707

············qemu_log("process_ncq_command·"·"ahci(%p)[%d][tag:%d]:·NCQ·op·0x%02x·on·sectors·[%"PRId64",%"PRId64"]"·"\n",·s,·port,·tag,·cmd,·lba,·end);

2707

············qemu_log("process_ncq_command·"·"ahci(%p)[%d][tag:%d]:·NCQ·op·0x%02x·on·sectors·[%"PRId64",%"PRId64"]"·"\n",·s,·port,·tag,·cmd,·lba,·end);

2708

#line·2710·"trace/trace-hw_ide.h"

2708

#line·2710·"trace/trace-hw_ide.h"

2709

········}

2709

········}

2710

····}

2710

····}

2711

}

2711

}

2712

static·inline·void·trace_process_ncq_command(void·*·s,·int·port,·uint8_t·tag,·uint8_t·cmd,·uint64_t·lba,·uint64_t·end)

2712

static·inline·void·trace_process_ncq_command(void·*·s,·int·port,·uint8_t·tag,·uint8_t·cmd,·uint64_t·lba,·uint64_t·end)

2724

static·inline·void·_nocheck__trace_handle_reg_h2d_fis_pmp(void·*·s,·int·port,·char·b0,·char·b1,·char·b2)

2724

static·inline·void·_nocheck__trace_handle_reg_h2d_fis_pmp(void·*·s,·int·port,·char·b0,·char·b1,·char·b2)

2725

{

2725

{

2726

····if·(trace_event_get_state(TRACE_HANDLE_REG_H2D_FIS_PMP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2726

····if·(trace_event_get_state(TRACE_HANDLE_REG_H2D_FIS_PMP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2727

········if·(message_with_timestamp)·{

2727

········if·(message_with_timestamp)·{

2728

············struct·timeval·_now;

2728

············struct·timeval·_now;

2729

············gettimeofday(&_now,·NULL);

2729

············gettimeofday(&_now,·NULL);

2731

············qemu_log("%d@%zu.%06zu:handle_reg_h2d_fis_pmp·"·"ahci(%p)[%d]:·Port·Multiplier·not·supported,·FIS:·0x%02x-%02x-%02x"·"\n",

2731

············qemu_log("%d@%zu.%06zu:handle_reg_h2d_fis_pmp·"·"ahci(%p)[%d]:·Port·Multiplier·not·supported,·FIS:·0x%02x-%02x-%02x"·"\n",

2732

·····················qemu_get_thread_id(),

2732

·····················qemu_get_thread_id(),

2733

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2733

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2734

·····················,·s,·port,·b0,·b1,·b2);

2734

·····················,·s,·port,·b0,·b1,·b2);

2735

#line·2737·"trace/trace-hw_ide.h"

2735

#line·2737·"trace/trace-hw_ide.h"

2736

········}·else·{

2736

········}·else·{

2738

············qemu_log("handle_reg_h2d_fis_pmp·"·"ahci(%p)[%d]:·Port·Multiplier·not·supported,·FIS:·0x%02x-%02x-%02x"·"\n",·s,·port,·b0,·b1,·b2);

2738

············qemu_log("handle_reg_h2d_fis_pmp·"·"ahci(%p)[%d]:·Port·Multiplier·not·supported,·FIS:·0x%02x-%02x-%02x"·"\n",·s,·port,·b0,·b1,·b2);

2739

#line·2741·"trace/trace-hw_ide.h"

2739

#line·2741·"trace/trace-hw_ide.h"

2740

········}

2740

········}

2741

····}

2741

····}

2742

}

2742

}

2743

static·inline·void·trace_handle_reg_h2d_fis_pmp(void·*·s,·int·port,·char·b0,·char·b1,·char·b2)

2743

static·inline·void·trace_handle_reg_h2d_fis_pmp(void·*·s,·int·port,·char·b0,·char·b1,·char·b2)

2755

static·inline·void·_nocheck__trace_handle_reg_h2d_fis_res(void·*·s,·int·port,·char·b0,·char·b1,·char·b2)

2755

static·inline·void·_nocheck__trace_handle_reg_h2d_fis_res(void·*·s,·int·port,·char·b0,·char·b1,·char·b2)

2756

{

2756

{

2757

····if·(trace_event_get_state(TRACE_HANDLE_REG_H2D_FIS_RES)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2757

····if·(trace_event_get_state(TRACE_HANDLE_REG_H2D_FIS_RES)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2758

········if·(message_with_timestamp)·{

2758

········if·(message_with_timestamp)·{

2759

············struct·timeval·_now;

2759

············struct·timeval·_now;

2760

············gettimeofday(&_now,·NULL);

2760

············gettimeofday(&_now,·NULL);

2762

············qemu_log("%d@%zu.%06zu:handle_reg_h2d_fis_res·"·"ahci(%p)[%d]:·Reserved·flags·set·in·H2D·Register·FIS,·FIS:·0x%02x-%02x-%02x"·"\n",

2762

············qemu_log("%d@%zu.%06zu:handle_reg_h2d_fis_res·"·"ahci(%p)[%d]:·Reserved·flags·set·in·H2D·Register·FIS,·FIS:·0x%02x-%02x-%02x"·"\n",

2763

·····················qemu_get_thread_id(),

2763

·····················qemu_get_thread_id(),

2764

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2764

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2765

·····················,·s,·port,·b0,·b1,·b2);

2765

·····················,·s,·port,·b0,·b1,·b2);

2766

#line·2768·"trace/trace-hw_ide.h"

2766

#line·2768·"trace/trace-hw_ide.h"

2767

········}·else·{

2767

········}·else·{

2769

············qemu_log("handle_reg_h2d_fis_res·"·"ahci(%p)[%d]:·Reserved·flags·set·in·H2D·Register·FIS,·FIS:·0x%02x-%02x-%02x"·"\n",·s,·port,·b0,·b1,·b2);

2769

············qemu_log("handle_reg_h2d_fis_res·"·"ahci(%p)[%d]:·Reserved·flags·set·in·H2D·Register·FIS,·FIS:·0x%02x-%02x-%02x"·"\n",·s,·port,·b0,·b1,·b2);

2770

#line·2772·"trace/trace-hw_ide.h"

2770

#line·2772·"trace/trace-hw_ide.h"

2771

········}

2771

········}

2772

····}

2772

····}

2773

}

2773

}

2774

static·inline·void·trace_handle_reg_h2d_fis_res(void·*·s,·int·port,·char·b0,·char·b1,·char·b2)

2774

static·inline·void·trace_handle_reg_h2d_fis_res(void·*·s,·int·port,·char·b0,·char·b1,·char·b2)

2786

static·inline·void·_nocheck__trace_handle_cmd_busy(void·*·s,·int·port)

2786

static·inline·void·_nocheck__trace_handle_cmd_busy(void·*·s,·int·port)

2787

{

2787

{

2788

····if·(trace_event_get_state(TRACE_HANDLE_CMD_BUSY)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2788

····if·(trace_event_get_state(TRACE_HANDLE_CMD_BUSY)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2789

········if·(message_with_timestamp)·{

2789

········if·(message_with_timestamp)·{

2790

············struct·timeval·_now;

2790

············struct·timeval·_now;

2791

············gettimeofday(&_now,·NULL);

2791

············gettimeofday(&_now,·NULL);

2793

············qemu_log("%d@%zu.%06zu:handle_cmd_busy·"·"ahci(%p)[%d]:·engine·busy"·"\n",

2793

············qemu_log("%d@%zu.%06zu:handle_cmd_busy·"·"ahci(%p)[%d]:·engine·busy"·"\n",

2794

·····················qemu_get_thread_id(),

2794

·····················qemu_get_thread_id(),

2795

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2795

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2796

·····················,·s,·port);

2796

·····················,·s,·port);

2797

#line·2799·"trace/trace-hw_ide.h"

2797

#line·2799·"trace/trace-hw_ide.h"

2798

········}·else·{

2798

········}·else·{

2800

············qemu_log("handle_cmd_busy·"·"ahci(%p)[%d]:·engine·busy"·"\n",·s,·port);

2800

············qemu_log("handle_cmd_busy·"·"ahci(%p)[%d]:·engine·busy"·"\n",·s,·port);

2801

#line·2803·"trace/trace-hw_ide.h"

2801

#line·2803·"trace/trace-hw_ide.h"

2802

········}

2802

········}

2803

····}

2803

····}

2804

}

2804

}

2805

static·inline·void·trace_handle_cmd_busy(void·*·s,·int·port)

2805

static·inline·void·trace_handle_cmd_busy(void·*·s,·int·port)

2817

static·inline·void·_nocheck__trace_handle_cmd_nolist(void·*·s,·int·port)

2817

static·inline·void·_nocheck__trace_handle_cmd_nolist(void·*·s,·int·port)

2818

{

2818

{

2819

····if·(trace_event_get_state(TRACE_HANDLE_CMD_NOLIST)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2819

····if·(trace_event_get_state(TRACE_HANDLE_CMD_NOLIST)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2820

········if·(message_with_timestamp)·{

2820

········if·(message_with_timestamp)·{

2821

············struct·timeval·_now;

2821

············struct·timeval·_now;

2822

············gettimeofday(&_now,·NULL);

2822

············gettimeofday(&_now,·NULL);

2824

············qemu_log("%d@%zu.%06zu:handle_cmd_nolist·"·"ahci(%p)[%d]:·handle_cmd·called·without·s->dev[port].lst"·"\n",

2824

············qemu_log("%d@%zu.%06zu:handle_cmd_nolist·"·"ahci(%p)[%d]:·handle_cmd·called·without·s->dev[port].lst"·"\n",

2825

·····················qemu_get_thread_id(),

2825

·····················qemu_get_thread_id(),

2826

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2826

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2827

·····················,·s,·port);

2827

·····················,·s,·port);

2828

#line·2830·"trace/trace-hw_ide.h"

2828

#line·2830·"trace/trace-hw_ide.h"

2829

········}·else·{

2829

········}·else·{

2831

············qemu_log("handle_cmd_nolist·"·"ahci(%p)[%d]:·handle_cmd·called·without·s->dev[port].lst"·"\n",·s,·port);

2831

············qemu_log("handle_cmd_nolist·"·"ahci(%p)[%d]:·handle_cmd·called·without·s->dev[port].lst"·"\n",·s,·port);

2832

#line·2834·"trace/trace-hw_ide.h"

2832

#line·2834·"trace/trace-hw_ide.h"

2833

········}

2833

········}

2834

····}

2834

····}

2835

}

2835

}

2836

static·inline·void·trace_handle_cmd_nolist(void·*·s,·int·port)

2836

static·inline·void·trace_handle_cmd_nolist(void·*·s,·int·port)

2848

static·inline·void·_nocheck__trace_handle_cmd_badport(void·*·s,·int·port)

2848

static·inline·void·_nocheck__trace_handle_cmd_badport(void·*·s,·int·port)

2849

{

2849

{

2850

····if·(trace_event_get_state(TRACE_HANDLE_CMD_BADPORT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2850

····if·(trace_event_get_state(TRACE_HANDLE_CMD_BADPORT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2851

········if·(message_with_timestamp)·{

2851

········if·(message_with_timestamp)·{

2852

············struct·timeval·_now;

2852

············struct·timeval·_now;

2853

············gettimeofday(&_now,·NULL);

2853

············gettimeofday(&_now,·NULL);

2855

············qemu_log("%d@%zu.%06zu:handle_cmd_badport·"·"ahci(%p)[%d]:·guest·accessed·unused·port"·"\n",

2855

············qemu_log("%d@%zu.%06zu:handle_cmd_badport·"·"ahci(%p)[%d]:·guest·accessed·unused·port"·"\n",

2856

·····················qemu_get_thread_id(),

2856

·····················qemu_get_thread_id(),

2857

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2857

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2858

·····················,·s,·port);

2858

·····················,·s,·port);

2859

#line·2861·"trace/trace-hw_ide.h"

2859

#line·2861·"trace/trace-hw_ide.h"

2860

········}·else·{

2860

········}·else·{

2862

············qemu_log("handle_cmd_badport·"·"ahci(%p)[%d]:·guest·accessed·unused·port"·"\n",·s,·port);

2862

············qemu_log("handle_cmd_badport·"·"ahci(%p)[%d]:·guest·accessed·unused·port"·"\n",·s,·port);

2863

#line·2865·"trace/trace-hw_ide.h"

2863

#line·2865·"trace/trace-hw_ide.h"

2864

········}

2864

········}

2865

····}

2865

····}

2866

}

2866

}

2867

static·inline·void·trace_handle_cmd_badport(void·*·s,·int·port)

2867

static·inline·void·trace_handle_cmd_badport(void·*·s,·int·port)

2879

static·inline·void·_nocheck__trace_handle_cmd_badfis(void·*·s,·int·port)

2879

static·inline·void·_nocheck__trace_handle_cmd_badfis(void·*·s,·int·port)

2880

{

2880

{

2881

····if·(trace_event_get_state(TRACE_HANDLE_CMD_BADFIS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2881

····if·(trace_event_get_state(TRACE_HANDLE_CMD_BADFIS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2882

········if·(message_with_timestamp)·{

2882

········if·(message_with_timestamp)·{

2883

············struct·timeval·_now;

2883

············struct·timeval·_now;

2884

············gettimeofday(&_now,·NULL);

2884

············gettimeofday(&_now,·NULL);

2886

············qemu_log("%d@%zu.%06zu:handle_cmd_badfis·"·"ahci(%p)[%d]:·guest·provided·an·invalid·cmd·FIS"·"\n",

2886

············qemu_log("%d@%zu.%06zu:handle_cmd_badfis·"·"ahci(%p)[%d]:·guest·provided·an·invalid·cmd·FIS"·"\n",

2887

·····················qemu_get_thread_id(),

2887

·····················qemu_get_thread_id(),

2888

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2888

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2889

·····················,·s,·port);

2889

·····················,·s,·port);

2890

#line·2892·"trace/trace-hw_ide.h"

2890

#line·2892·"trace/trace-hw_ide.h"

2891

········}·else·{

2891

········}·else·{

2893

············qemu_log("handle_cmd_badfis·"·"ahci(%p)[%d]:·guest·provided·an·invalid·cmd·FIS"·"\n",·s,·port);

2893

············qemu_log("handle_cmd_badfis·"·"ahci(%p)[%d]:·guest·provided·an·invalid·cmd·FIS"·"\n",·s,·port);

2894

#line·2896·"trace/trace-hw_ide.h"

2894

#line·2896·"trace/trace-hw_ide.h"

2895

········}

2895

········}

2896

····}

2896

····}

2897

}

2897

}

2898

static·inline·void·trace_handle_cmd_badfis(void·*·s,·int·port)

2898

static·inline·void·trace_handle_cmd_badfis(void·*·s,·int·port)

2910

static·inline·void·_nocheck__trace_handle_cmd_badmap(void·*·s,·int·port,·uint64_t·len)

2910

static·inline·void·_nocheck__trace_handle_cmd_badmap(void·*·s,·int·port,·uint64_t·len)

2911

{

2911

{

2912

····if·(trace_event_get_state(TRACE_HANDLE_CMD_BADMAP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2912

····if·(trace_event_get_state(TRACE_HANDLE_CMD_BADMAP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2913

········if·(message_with_timestamp)·{

2913

········if·(message_with_timestamp)·{

2914

············struct·timeval·_now;

2914

············struct·timeval·_now;

2915

············gettimeofday(&_now,·NULL);

2915

············gettimeofday(&_now,·NULL);

2917

············qemu_log("%d@%zu.%06zu:handle_cmd_badmap·"·"ahci(%p)[%d]:·dma_memory_map·failed,·0x%02"PRIx64"·!=·0x80"·"\n",

2917

············qemu_log("%d@%zu.%06zu:handle_cmd_badmap·"·"ahci(%p)[%d]:·dma_memory_map·failed,·0x%02"PRIx64"·!=·0x80"·"\n",

2918

·····················qemu_get_thread_id(),

2918

·····················qemu_get_thread_id(),

2919

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2919

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2920

·····················,·s,·port,·len);

2920

·····················,·s,·port,·len);

2921

#line·2923·"trace/trace-hw_ide.h"

2921

#line·2923·"trace/trace-hw_ide.h"

2922

········}·else·{

2922

········}·else·{

2924

············qemu_log("handle_cmd_badmap·"·"ahci(%p)[%d]:·dma_memory_map·failed,·0x%02"PRIx64"·!=·0x80"·"\n",·s,·port,·len);

2924

············qemu_log("handle_cmd_badmap·"·"ahci(%p)[%d]:·dma_memory_map·failed,·0x%02"PRIx64"·!=·0x80"·"\n",·s,·port,·len);

2925

#line·2927·"trace/trace-hw_ide.h"

2925

#line·2927·"trace/trace-hw_ide.h"

2926

········}

2926

········}

2927

····}

2927

····}

2928

}

2928

}

2929

static·inline·void·trace_handle_cmd_badmap(void·*·s,·int·port,·uint64_t·len)

2929

static·inline·void·trace_handle_cmd_badmap(void·*·s,·int·port,·uint64_t·len)

2941

static·inline·void·_nocheck__trace_handle_cmd_unhandled_fis(void·*·s,·int·port,·uint8_t·b0,·uint8_t·b1,·uint8_t·b2)

2941

static·inline·void·_nocheck__trace_handle_cmd_unhandled_fis(void·*·s,·int·port,·uint8_t·b0,·uint8_t·b1,·uint8_t·b2)

2942

{

2942

{

2943

····if·(trace_event_get_state(TRACE_HANDLE_CMD_UNHANDLED_FIS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2943

····if·(trace_event_get_state(TRACE_HANDLE_CMD_UNHANDLED_FIS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2944

········if·(message_with_timestamp)·{

2944

········if·(message_with_timestamp)·{

2945

············struct·timeval·_now;

2945

············struct·timeval·_now;

2946

············gettimeofday(&_now,·NULL);

2946

············gettimeofday(&_now,·NULL);

2948

············qemu_log("%d@%zu.%06zu:handle_cmd_unhandled_fis·"·"ahci(%p)[%d]:·unhandled·FIS·type.·cmd_fis:·0x%02x-%02x-%02x"·"\n",

2948

············qemu_log("%d@%zu.%06zu:handle_cmd_unhandled_fis·"·"ahci(%p)[%d]:·unhandled·FIS·type.·cmd_fis:·0x%02x-%02x-%02x"·"\n",

2949

·····················qemu_get_thread_id(),

2949

·····················qemu_get_thread_id(),

2950

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2950

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2951

·····················,·s,·port,·b0,·b1,·b2);

2951

·····················,·s,·port,·b0,·b1,·b2);

2952

#line·2954·"trace/trace-hw_ide.h"

2952

#line·2954·"trace/trace-hw_ide.h"

2953

········}·else·{

2953

········}·else·{

2955

············qemu_log("handle_cmd_unhandled_fis·"·"ahci(%p)[%d]:·unhandled·FIS·type.·cmd_fis:·0x%02x-%02x-%02x"·"\n",·s,·port,·b0,·b1,·b2);

2955

············qemu_log("handle_cmd_unhandled_fis·"·"ahci(%p)[%d]:·unhandled·FIS·type.·cmd_fis:·0x%02x-%02x-%02x"·"\n",·s,·port,·b0,·b1,·b2);

2956

#line·2958·"trace/trace-hw_ide.h"

2956

#line·2958·"trace/trace-hw_ide.h"

2957

········}

2957

········}

2958

····}

2958

····}

2959

}

2959

}

2960

static·inline·void·trace_handle_cmd_unhandled_fis(void·*·s,·int·port,·uint8_t·b0,·uint8_t·b1,·uint8_t·b2)

2960

static·inline·void·trace_handle_cmd_unhandled_fis(void·*·s,·int·port,·uint8_t·b0,·uint8_t·b1,·uint8_t·b2)

2972

static·inline·void·_nocheck__trace_ahci_pio_transfer(void·*·s,·int·port,·const·char·*·rw,·uint32_t·size,·const·char·*·tgt,·const·char·*·sgl)

2972

static·inline·void·_nocheck__trace_ahci_pio_transfer(void·*·s,·int·port,·const·char·*·rw,·uint32_t·size,·const·char·*·tgt,·const·char·*·sgl)

2973

{

2973

{

2974

····if·(trace_event_get_state(TRACE_AHCI_PIO_TRANSFER)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2974

····if·(trace_event_get_state(TRACE_AHCI_PIO_TRANSFER)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2975

········if·(message_with_timestamp)·{

2975

········if·(message_with_timestamp)·{

2976

············struct·timeval·_now;

2976

············struct·timeval·_now;

2977

············gettimeofday(&_now,·NULL);

2977

············gettimeofday(&_now,·NULL);

2979

············qemu_log("%d@%zu.%06zu:ahci_pio_transfer·"·"ahci(%p)[%d]:·%sing·%d·bytes·on·%s·w/%s·sglist"·"\n",

2979

············qemu_log("%d@%zu.%06zu:ahci_pio_transfer·"·"ahci(%p)[%d]:·%sing·%d·bytes·on·%s·w/%s·sglist"·"\n",

2980

·····················qemu_get_thread_id(),

2980

·····················qemu_get_thread_id(),

2981

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2981

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2982

·····················,·s,·port,·rw,·size,·tgt,·sgl);

2982

·····················,·s,·port,·rw,·size,·tgt,·sgl);

2983

#line·2985·"trace/trace-hw_ide.h"

2983

#line·2985·"trace/trace-hw_ide.h"

2984

········}·else·{

2984

········}·else·{

2986

············qemu_log("ahci_pio_transfer·"·"ahci(%p)[%d]:·%sing·%d·bytes·on·%s·w/%s·sglist"·"\n",·s,·port,·rw,·size,·tgt,·sgl);

2986

············qemu_log("ahci_pio_transfer·"·"ahci(%p)[%d]:·%sing·%d·bytes·on·%s·w/%s·sglist"·"\n",·s,·port,·rw,·size,·tgt,·sgl);

2987

#line·2989·"trace/trace-hw_ide.h"

2987

#line·2989·"trace/trace-hw_ide.h"

2988

········}

2988

········}

2989

····}

2989

····}

2990

}

2990

}

2991

static·inline·void·trace_ahci_pio_transfer(void·*·s,·int·port,·const·char·*·rw,·uint32_t·size,·const·char·*·tgt,·const·char·*·sgl)

2991

static·inline·void·trace_ahci_pio_transfer(void·*·s,·int·port,·const·char·*·rw,·uint32_t·size,·const·char·*·tgt,·const·char·*·sgl)

3003

static·inline·void·_nocheck__trace_ahci_start_dma(void·*·s,·int·port)

3003

static·inline·void·_nocheck__trace_ahci_start_dma(void·*·s,·int·port)

3004

{

3004

{

3005

····if·(trace_event_get_state(TRACE_AHCI_START_DMA)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3005

····if·(trace_event_get_state(TRACE_AHCI_START_DMA)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3006

········if·(message_with_timestamp)·{

3006

········if·(message_with_timestamp)·{

3007

············struct·timeval·_now;

3007

············struct·timeval·_now;

3008

············gettimeofday(&_now,·NULL);

3008

············gettimeofday(&_now,·NULL);

3010

············qemu_log("%d@%zu.%06zu:ahci_start_dma·"·"ahci(%p)[%d]:·start·dma"·"\n",

3010

············qemu_log("%d@%zu.%06zu:ahci_start_dma·"·"ahci(%p)[%d]:·start·dma"·"\n",

3011

·····················qemu_get_thread_id(),

3011

·····················qemu_get_thread_id(),

3012

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3012

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3013

·····················,·s,·port);

3013

·····················,·s,·port);

3014

#line·3016·"trace/trace-hw_ide.h"

3014

#line·3016·"trace/trace-hw_ide.h"

3015

········}·else·{

3015

········}·else·{

3017

············qemu_log("ahci_start_dma·"·"ahci(%p)[%d]:·start·dma"·"\n",·s,·port);

3017

············qemu_log("ahci_start_dma·"·"ahci(%p)[%d]:·start·dma"·"\n",·s,·port);

3018

#line·3020·"trace/trace-hw_ide.h"

3018

#line·3020·"trace/trace-hw_ide.h"

3019

········}

3019

········}

3020

····}

3020

····}

3021

}

3021

}

3022

static·inline·void·trace_ahci_start_dma(void·*·s,·int·port)

3022

static·inline·void·trace_ahci_start_dma(void·*·s,·int·port)

3034

static·inline·void·_nocheck__trace_ahci_dma_prepare_buf(void·*·s,·int·port,·int32_t·io_buffer_size,·int32_t·limit)

3034

static·inline·void·_nocheck__trace_ahci_dma_prepare_buf(void·*·s,·int·port,·int32_t·io_buffer_size,·int32_t·limit)

3035

{

3035

{

3036

····if·(trace_event_get_state(TRACE_AHCI_DMA_PREPARE_BUF)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3036

····if·(trace_event_get_state(TRACE_AHCI_DMA_PREPARE_BUF)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3037

········if·(message_with_timestamp)·{

3037

········if·(message_with_timestamp)·{

3038

············struct·timeval·_now;

3038

············struct·timeval·_now;

3039

············gettimeofday(&_now,·NULL);

3039

············gettimeofday(&_now,·NULL);

3041

············qemu_log("%d@%zu.%06zu:ahci_dma_prepare_buf·"·"ahci(%p)[%d]:·prepare·buf·limit=%"PRId32"·prepared=%"PRId32·"\n",

3041

············qemu_log("%d@%zu.%06zu:ahci_dma_prepare_buf·"·"ahci(%p)[%d]:·prepare·buf·limit=%"PRId32"·prepared=%"PRId32·"\n",

3042

·····················qemu_get_thread_id(),

3042

·····················qemu_get_thread_id(),

3043

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3043

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3044

·····················,·s,·port,·io_buffer_size,·limit);

3044

·····················,·s,·port,·io_buffer_size,·limit);

3045

#line·3047·"trace/trace-hw_ide.h"

3045

#line·3047·"trace/trace-hw_ide.h"

3046

········}·else·{

3046

········}·else·{

3048

············qemu_log("ahci_dma_prepare_buf·"·"ahci(%p)[%d]:·prepare·buf·limit=%"PRId32"·prepared=%"PRId32·"\n",·s,·port,·io_buffer_size,·limit);

3048

············qemu_log("ahci_dma_prepare_buf·"·"ahci(%p)[%d]:·prepare·buf·limit=%"PRId32"·prepared=%"PRId32·"\n",·s,·port,·io_buffer_size,·limit);

3049

#line·3051·"trace/trace-hw_ide.h"

3049

#line·3051·"trace/trace-hw_ide.h"

3050

········}

3050

········}

3051

····}

3051

····}

3052

}

3052

}

3053

static·inline·void·trace_ahci_dma_prepare_buf(void·*·s,·int·port,·int32_t·io_buffer_size,·int32_t·limit)

3053

static·inline·void·trace_ahci_dma_prepare_buf(void·*·s,·int·port,·int32_t·io_buffer_size,·int32_t·limit)

3065

static·inline·void·_nocheck__trace_ahci_dma_prepare_buf_fail(void·*·s,·int·port)

3065

static·inline·void·_nocheck__trace_ahci_dma_prepare_buf_fail(void·*·s,·int·port)

3066

{

3066

{

3067

····if·(trace_event_get_state(TRACE_AHCI_DMA_PREPARE_BUF_FAIL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3067

····if·(trace_event_get_state(TRACE_AHCI_DMA_PREPARE_BUF_FAIL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3068

········if·(message_with_timestamp)·{

3068

········if·(message_with_timestamp)·{

3069

············struct·timeval·_now;

3069

············struct·timeval·_now;

3070

············gettimeofday(&_now,·NULL);

3070

············gettimeofday(&_now,·NULL);

3072

············qemu_log("%d@%zu.%06zu:ahci_dma_prepare_buf_fail·"·"ahci(%p)[%d]:·sglist·population·failed"·"\n",

3072

············qemu_log("%d@%zu.%06zu:ahci_dma_prepare_buf_fail·"·"ahci(%p)[%d]:·sglist·population·failed"·"\n",

3073

·····················qemu_get_thread_id(),

3073

·····················qemu_get_thread_id(),

3074

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3074

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3075

·····················,·s,·port);

3075

·····················,·s,·port);

3076

#line·3078·"trace/trace-hw_ide.h"

3076

#line·3078·"trace/trace-hw_ide.h"

3077

········}·else·{

3077

········}·else·{

3079

············qemu_log("ahci_dma_prepare_buf_fail·"·"ahci(%p)[%d]:·sglist·population·failed"·"\n",·s,·port);

3079

············qemu_log("ahci_dma_prepare_buf_fail·"·"ahci(%p)[%d]:·sglist·population·failed"·"\n",·s,·port);

3080

#line·3082·"trace/trace-hw_ide.h"

3080

#line·3082·"trace/trace-hw_ide.h"

3081

········}

3081

········}

3082

····}

3082

····}

3083

}

3083

}

3084

static·inline·void·trace_ahci_dma_prepare_buf_fail(void·*·s,·int·port)

3084

static·inline·void·trace_ahci_dma_prepare_buf_fail(void·*·s,·int·port)

3096

static·inline·void·_nocheck__trace_ahci_dma_rw_buf(void·*·s,·int·port,·int·l)

3096

static·inline·void·_nocheck__trace_ahci_dma_rw_buf(void·*·s,·int·port,·int·l)

3097

{

3097

{

3098

····if·(trace_event_get_state(TRACE_AHCI_DMA_RW_BUF)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3098

····if·(trace_event_get_state(TRACE_AHCI_DMA_RW_BUF)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3099

········if·(message_with_timestamp)·{

3099

········if·(message_with_timestamp)·{

3100

············struct·timeval·_now;

3100

············struct·timeval·_now;

3101

············gettimeofday(&_now,·NULL);

3101

············gettimeofday(&_now,·NULL);

3103

············qemu_log("%d@%zu.%06zu:ahci_dma_rw_buf·"·"ahci(%p)[%d]·len=0x%x"·"\n",

3103

············qemu_log("%d@%zu.%06zu:ahci_dma_rw_buf·"·"ahci(%p)[%d]·len=0x%x"·"\n",

3104

·····················qemu_get_thread_id(),

3104

·····················qemu_get_thread_id(),

3105

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3105

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3106

·····················,·s,·port,·l);

3106

·····················,·s,·port,·l);

3107

#line·3109·"trace/trace-hw_ide.h"

3107

#line·3109·"trace/trace-hw_ide.h"

3108

········}·else·{

3108

········}·else·{

3110

············qemu_log("ahci_dma_rw_buf·"·"ahci(%p)[%d]·len=0x%x"·"\n",·s,·port,·l);

3110

············qemu_log("ahci_dma_rw_buf·"·"ahci(%p)[%d]·len=0x%x"·"\n",·s,·port,·l);

3111

#line·3113·"trace/trace-hw_ide.h"

3111

#line·3113·"trace/trace-hw_ide.h"

3112

········}

3112

········}

3113

····}

3113

····}

3114

}

3114

}

3115

static·inline·void·trace_ahci_dma_rw_buf(void·*·s,·int·port,·int·l)

3115

static·inline·void·trace_ahci_dma_rw_buf(void·*·s,·int·port,·int·l)

3127

static·inline·void·_nocheck__trace_ahci_cmd_done(void·*·s,·int·port)

3127

static·inline·void·_nocheck__trace_ahci_cmd_done(void·*·s,·int·port)

3128

{

3128

{

3129

····if·(trace_event_get_state(TRACE_AHCI_CMD_DONE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3129

····if·(trace_event_get_state(TRACE_AHCI_CMD_DONE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3130

········if·(message_with_timestamp)·{

3130

········if·(message_with_timestamp)·{

3131

············struct·timeval·_now;

3131

············struct·timeval·_now;

3132

············gettimeofday(&_now,·NULL);

3132

············gettimeofday(&_now,·NULL);

3134

············qemu_log("%d@%zu.%06zu:ahci_cmd_done·"·"ahci(%p)[%d]:·cmd·done"·"\n",

3134

············qemu_log("%d@%zu.%06zu:ahci_cmd_done·"·"ahci(%p)[%d]:·cmd·done"·"\n",

3135

·····················qemu_get_thread_id(),

3135

·····················qemu_get_thread_id(),

3136

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3136

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3137

·····················,·s,·port);

3137

·····················,·s,·port);

3138

#line·3140·"trace/trace-hw_ide.h"

3138

#line·3140·"trace/trace-hw_ide.h"

3139

········}·else·{

3139

········}·else·{

3141

············qemu_log("ahci_cmd_done·"·"ahci(%p)[%d]:·cmd·done"·"\n",·s,·port);

3141

············qemu_log("ahci_cmd_done·"·"ahci(%p)[%d]:·cmd·done"·"\n",·s,·port);

3142

#line·3144·"trace/trace-hw_ide.h"

3142

#line·3144·"trace/trace-hw_ide.h"

3143

········}

3143

········}

3144

····}

3144

····}

3145

}

3145

}

3146

static·inline·void·trace_ahci_cmd_done(void·*·s,·int·port)

3146

static·inline·void·trace_ahci_cmd_done(void·*·s,·int·port)

3158

static·inline·void·_nocheck__trace_ahci_reset(void·*·s)

3158

static·inline·void·_nocheck__trace_ahci_reset(void·*·s)

3159

{

3159

{

3160

····if·(trace_event_get_state(TRACE_AHCI_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3160

····if·(trace_event_get_state(TRACE_AHCI_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3161

········if·(message_with_timestamp)·{

3161

········if·(message_with_timestamp)·{

3162

············struct·timeval·_now;

3162

············struct·timeval·_now;

3163

············gettimeofday(&_now,·NULL);

3163

············gettimeofday(&_now,·NULL);

3165

············qemu_log("%d@%zu.%06zu:ahci_reset·"·"ahci(%p):·HBA·reset"·"\n",

3165

············qemu_log("%d@%zu.%06zu:ahci_reset·"·"ahci(%p):·HBA·reset"·"\n",

3166

·····················qemu_get_thread_id(),

3166

·····················qemu_get_thread_id(),

3167

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3167

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3168

·····················,·s);

3168

·····················,·s);

3169

#line·3171·"trace/trace-hw_ide.h"

3169

#line·3171·"trace/trace-hw_ide.h"

3170

········}·else·{

3170

········}·else·{

3172

············qemu_log("ahci_reset·"·"ahci(%p):·HBA·reset"·"\n",·s);

3172

············qemu_log("ahci_reset·"·"ahci(%p):·HBA·reset"·"\n",·s);

3173

#line·3175·"trace/trace-hw_ide.h"

3173

#line·3175·"trace/trace-hw_ide.h"

3174

········}

3174

········}

3175

····}

3175

····}

3176

}

3176

}

3177

static·inline·void·trace_ahci_reset(void·*·s)

3177

static·inline·void·trace_ahci_reset(void·*·s)

3189

static·inline·void·_nocheck__trace_handle_reg_h2d_fis_dump(void·*·s,·int·port,·const·char·*·fis)

3189

static·inline·void·_nocheck__trace_handle_reg_h2d_fis_dump(void·*·s,·int·port,·const·char·*·fis)

3190

{

3190

{

3191

····if·(trace_event_get_state(TRACE_HANDLE_REG_H2D_FIS_DUMP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3191

····if·(trace_event_get_state(TRACE_HANDLE_REG_H2D_FIS_DUMP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3192

········if·(message_with_timestamp)·{

3192

········if·(message_with_timestamp)·{

3193

············struct·timeval·_now;

3193

············struct·timeval·_now;

3194

············gettimeofday(&_now,·NULL);

3194

············gettimeofday(&_now,·NULL);

3196

············qemu_log("%d@%zu.%06zu:handle_reg_h2d_fis_dump·"·"ahci(%p)[%d]:·%s"·"\n",

3196

············qemu_log("%d@%zu.%06zu:handle_reg_h2d_fis_dump·"·"ahci(%p)[%d]:·%s"·"\n",

3197

·····················qemu_get_thread_id(),

3197

·····················qemu_get_thread_id(),

3198

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3198

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3199

·····················,·s,·port,·fis);

3199

·····················,·s,·port,·fis);

3200

#line·3202·"trace/trace-hw_ide.h"

3200

#line·3202·"trace/trace-hw_ide.h"

3201

········}·else·{

3201

········}·else·{

3203

············qemu_log("handle_reg_h2d_fis_dump·"·"ahci(%p)[%d]:·%s"·"\n",·s,·port,·fis);

3203

············qemu_log("handle_reg_h2d_fis_dump·"·"ahci(%p)[%d]:·%s"·"\n",·s,·port,·fis);

3204

#line·3206·"trace/trace-hw_ide.h"

3204

#line·3206·"trace/trace-hw_ide.h"

3205

········}

3205

········}

3206

····}

3206

····}

3207

}

3207

}

3208

static·inline·void·trace_handle_reg_h2d_fis_dump(void·*·s,·int·port,·const·char·*·fis)

3208

static·inline·void·trace_handle_reg_h2d_fis_dump(void·*·s,·int·port,·const·char·*·fis)

3220

static·inline·void·_nocheck__trace_handle_cmd_fis_dump(void·*·s,·int·port,·const·char·*·fis)

3220

static·inline·void·_nocheck__trace_handle_cmd_fis_dump(void·*·s,·int·port,·const·char·*·fis)

3221

{

3221

{

3222

····if·(trace_event_get_state(TRACE_HANDLE_CMD_FIS_DUMP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3222

····if·(trace_event_get_state(TRACE_HANDLE_CMD_FIS_DUMP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3223

········if·(message_with_timestamp)·{

3223

········if·(message_with_timestamp)·{

3224

············struct·timeval·_now;

3224

············struct·timeval·_now;

3225

············gettimeofday(&_now,·NULL);

3225

············gettimeofday(&_now,·NULL);

3227

············qemu_log("%d@%zu.%06zu:handle_cmd_fis_dump·"·"ahci(%p)[%d]:·%s"·"\n",

3227

············qemu_log("%d@%zu.%06zu:handle_cmd_fis_dump·"·"ahci(%p)[%d]:·%s"·"\n",

3228

·····················qemu_get_thread_id(),

3228

·····················qemu_get_thread_id(),

3229

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3229

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3230

·····················,·s,·port,·fis);

3230

·····················,·s,·port,·fis);

3231

#line·3233·"trace/trace-hw_ide.h"

3231

#line·3233·"trace/trace-hw_ide.h"

3232

········}·else·{

3232

········}·else·{

3234

············qemu_log("handle_cmd_fis_dump·"·"ahci(%p)[%d]:·%s"·"\n",·s,·port,·fis);

3234

············qemu_log("handle_cmd_fis_dump·"·"ahci(%p)[%d]:·%s"·"\n",·s,·port,·fis);

3235

#line·3237·"trace/trace-hw_ide.h"

3235

#line·3237·"trace/trace-hw_ide.h"

3236

········}

3236

········}

3237

····}

3237

····}

3238

}

3238

}

3239

static·inline·void·trace_handle_cmd_fis_dump(void·*·s,·int·port,·const·char·*·fis)

3239

static·inline·void·trace_handle_cmd_fis_dump(void·*·s,·int·port,·const·char·*·fis)

3251

static·inline·void·_nocheck__trace_allwinner_ahci_mem_read(void·*·s,·void·*·a,·uint64_t·addr,·uint64_t·val,·unsigned·size)

3251

static·inline·void·_nocheck__trace_allwinner_ahci_mem_read(void·*·s,·void·*·a,·uint64_t·addr,·uint64_t·val,·unsigned·size)

3252

{

3252

{

3253

····if·(trace_event_get_state(TRACE_ALLWINNER_AHCI_MEM_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3253

····if·(trace_event_get_state(TRACE_ALLWINNER_AHCI_MEM_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3254

········if·(message_with_timestamp)·{

3254

········if·(message_with_timestamp)·{

3255

············struct·timeval·_now;

3255

············struct·timeval·_now;

3256

············gettimeofday(&_now,·NULL);

3256

············gettimeofday(&_now,·NULL);

3258

············qemu_log("%d@%zu.%06zu:allwinner_ahci_mem_read·"·"ahci(%p):·read·a=%p·addr=0x%"PRIx64"·val=0x%"PRIx64",·size=%d"·"\n",

3258

············qemu_log("%d@%zu.%06zu:allwinner_ahci_mem_read·"·"ahci(%p):·read·a=%p·addr=0x%"PRIx64"·val=0x%"PRIx64",·size=%d"·"\n",

3259

·····················qemu_get_thread_id(),

3259

·····················qemu_get_thread_id(),

3260

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3260

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3261

·····················,·s,·a,·addr,·val,·size);

3261

·····················,·s,·a,·addr,·val,·size);

3262

#line·3264·"trace/trace-hw_ide.h"

3262

#line·3264·"trace/trace-hw_ide.h"

3263

········}·else·{

3263

········}·else·{

3265

············qemu_log("allwinner_ahci_mem_read·"·"ahci(%p):·read·a=%p·addr=0x%"PRIx64"·val=0x%"PRIx64",·size=%d"·"\n",·s,·a,·addr,·val,·size);

3265

············qemu_log("allwinner_ahci_mem_read·"·"ahci(%p):·read·a=%p·addr=0x%"PRIx64"·val=0x%"PRIx64",·size=%d"·"\n",·s,·a,·addr,·val,·size);

3266

#line·3268·"trace/trace-hw_ide.h"

3266

#line·3268·"trace/trace-hw_ide.h"

3267

········}

3267

········}

3268

····}

3268

····}

3269

}

3269

}

3270

static·inline·void·trace_allwinner_ahci_mem_read(void·*·s,·void·*·a,·uint64_t·addr,·uint64_t·val,·unsigned·size)

3270

static·inline·void·trace_allwinner_ahci_mem_read(void·*·s,·void·*·a,·uint64_t·addr,·uint64_t·val,·unsigned·size)

3282

static·inline·void·_nocheck__trace_allwinner_ahci_mem_write(void·*·s,·void·*·a,·uint64_t·addr,·uint64_t·val,·unsigned·size)

3282

static·inline·void·_nocheck__trace_allwinner_ahci_mem_write(void·*·s,·void·*·a,·uint64_t·addr,·uint64_t·val,·unsigned·size)

3283

{

3283

{

3284

····if·(trace_event_get_state(TRACE_ALLWINNER_AHCI_MEM_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3284

····if·(trace_event_get_state(TRACE_ALLWINNER_AHCI_MEM_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

3285

········if·(message_with_timestamp)·{

3285

········if·(message_with_timestamp)·{

3286

············struct·timeval·_now;

3286

············struct·timeval·_now;

3287

············gettimeofday(&_now,·NULL);

3287

············gettimeofday(&_now,·NULL);

3289

············qemu_log("%d@%zu.%06zu:allwinner_ahci_mem_write·"·"ahci(%p):·write·a=%p·addr=0x%"PRIx64"·val=0x%"PRIx64",·size=%d"·"\n",

3289

············qemu_log("%d@%zu.%06zu:allwinner_ahci_mem_write·"·"ahci(%p):·write·a=%p·addr=0x%"PRIx64"·val=0x%"PRIx64",·size=%d"·"\n",

3290

·····················qemu_get_thread_id(),

3290

·····················qemu_get_thread_id(),

3291

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3291

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

3292

·····················,·s,·a,·addr,·val,·size);

3292

·····················,·s,·a,·addr,·val,·size);

3293

#line·3295·"trace/trace-hw_ide.h"

3293

#line·3295·"trace/trace-hw_ide.h"

3294

········}·else·{

3294

········}·else·{

3296

············qemu_log("allwinner_ahci_mem_write·"·"ahci(%p):·write·a=%p·addr=0x%"PRIx64"·val=0x%"PRIx64",·size=%d"·"\n",·s,·a,·addr,·val,·size);

3296

············qemu_log("allwinner_ahci_mem_write·"·"ahci(%p):·write·a=%p·addr=0x%"PRIx64"·val=0x%"PRIx64",·size=%d"·"\n",·s,·a,·addr,·val,·size);

3297

#line·3299·"trace/trace-hw_ide.h"

3297

#line·3299·"trace/trace-hw_ide.h"

3298

········}

3298

········}

3299

····}

3299

····}

3300

}

3300

}

3301

static·inline·void·trace_allwinner_ahci_mem_write(void·*·s,·void·*·a,·uint64_t·addr,·uint64_t·val,·unsigned·size)

3301

static·inline·void·trace_allwinner_ahci_mem_write(void·*·s,·void·*·a,·uint64_t·addr,·uint64_t·val,·unsigned·size)