/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-20250219-aucltpnr/packages/diff-html reproducibleA reproducibleB

219

static·inline·void·_nocheck__trace_fdc_ioport_read(uint8_t·reg,·uint8_t·value)

219

static·inline·void·_nocheck__trace_fdc_ioport_read(uint8_t·reg,·uint8_t·value)

220

{

220

{

221

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

221

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

222

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

222

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

223

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

223

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

224

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

224

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

226

············qemu_log("%d@%zu.%06zu:fdc_ioport_read·"·"read·reg·0x%02x·val·0x%02x"·"\n",

226

············qemu_log("%d@%zu.%06zu:fdc_ioport_read·"·"read·reg·0x%02x·val·0x%02x"·"\n",

227

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

227

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

228

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

228

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

229

·····················,·reg,·value);

229

·····················,·reg,·value);

230

#line·232·"trace/trace-hw_block.h"

230

#line·232·"trace/trace-hw_block.h"

231

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

231

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

233

············qemu_log("fdc_ioport_read·"·"read·reg·0x%02x·val·0x%02x"·"\n",·reg,·value);

233

············qemu_log("fdc_ioport_read·"·"read·reg·0x%02x·val·0x%02x"·"\n",·reg,·value);

234

#line·236·"trace/trace-hw_block.h"

234

#line·236·"trace/trace-hw_block.h"

235

········}

235

········}

236

····}

236

····}

237

}

237

}

238

static·inline·void·trace_fdc_ioport_read(uint8_t·reg,·uint8_t·value)

238

static·inline·void·trace_fdc_ioport_read(uint8_t·reg,·uint8_t·value)

250

static·inline·void·_nocheck__trace_fdc_ioport_write(uint8_t·reg,·uint8_t·value)

250

static·inline·void·_nocheck__trace_fdc_ioport_write(uint8_t·reg,·uint8_t·value)

251

{

251

{

252

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

252

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

253

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

253

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

254

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

254

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

255

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

255

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

257

············qemu_log("%d@%zu.%06zu:fdc_ioport_write·"·"write·reg·0x%02x·val·0x%02x"·"\n",

257

············qemu_log("%d@%zu.%06zu:fdc_ioport_write·"·"write·reg·0x%02x·val·0x%02x"·"\n",

258

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

258

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

259

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

259

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

260

·····················,·reg,·value);

260

·····················,·reg,·value);

261

#line·263·"trace/trace-hw_block.h"

261

#line·263·"trace/trace-hw_block.h"

262

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

262

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

264

············qemu_log("fdc_ioport_write·"·"write·reg·0x%02x·val·0x%02x"·"\n",·reg,·value);

264

············qemu_log("fdc_ioport_write·"·"write·reg·0x%02x·val·0x%02x"·"\n",·reg,·value);

265

#line·267·"trace/trace-hw_block.h"

265

#line·267·"trace/trace-hw_block.h"

266

········}

266

········}

267

····}

267

····}

268

}

268

}

269

static·inline·void·trace_fdc_ioport_write(uint8_t·reg,·uint8_t·value)

269

static·inline·void·trace_fdc_ioport_write(uint8_t·reg,·uint8_t·value)

281

static·inline·void·_nocheck__trace_fdctrl_tc_pulse(int·level)

281

static·inline·void·_nocheck__trace_fdctrl_tc_pulse(int·level)

282

{

282

{

283

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

283

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

284

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

284

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

285

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

285

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

286

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

286

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

288

············qemu_log("%d@%zu.%06zu:fdctrl_tc_pulse·"·"TC·pulse:·%u"·"\n",

288

············qemu_log("%d@%zu.%06zu:fdctrl_tc_pulse·"·"TC·pulse:·%u"·"\n",

289

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

289

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

290

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

290

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

291

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

291

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

292

#line·294·"trace/trace-hw_block.h"

292

#line·294·"trace/trace-hw_block.h"

293

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

293

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

295

············qemu_log("fdctrl_tc_pulse·"·"TC·pulse:·%u"·"\n",·level);

295

············qemu_log("fdctrl_tc_pulse·"·"TC·pulse:·%u"·"\n",·level);

296

#line·298·"trace/trace-hw_block.h"

296

#line·298·"trace/trace-hw_block.h"

297

········}

297

········}

298

····}

298

····}

299

}

299

}

300

static·inline·void·trace_fdctrl_tc_pulse(int·level)

300

static·inline·void·trace_fdctrl_tc_pulse(int·level)

312

static·inline·void·_nocheck__trace_pflash_chip_erase_invalid(const·char·*·name,·uint64_t·offset)

312

static·inline·void·_nocheck__trace_pflash_chip_erase_invalid(const·char·*·name,·uint64_t·offset)

313

{

313

{

314

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

314

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

315

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

315

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

316

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

316

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

317

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

317

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

319

············qemu_log("%d@%zu.%06zu:pflash_chip_erase_invalid·"·"%s:·chip·erase:·invalid·address·0x%"·PRIx64·"\n",

319

············qemu_log("%d@%zu.%06zu:pflash_chip_erase_invalid·"·"%s:·chip·erase:·invalid·address·0x%"·PRIx64·"\n",

320

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

320

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

321

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

321

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

322

·····················,·name,·offset);

322

·····················,·name,·offset);

323

#line·325·"trace/trace-hw_block.h"

323

#line·325·"trace/trace-hw_block.h"

324

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

324

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

326

············qemu_log("pflash_chip_erase_invalid·"·"%s:·chip·erase:·invalid·address·0x%"·PRIx64·"\n",·name,·offset);

326

············qemu_log("pflash_chip_erase_invalid·"·"%s:·chip·erase:·invalid·address·0x%"·PRIx64·"\n",·name,·offset);

327

#line·329·"trace/trace-hw_block.h"

327

#line·329·"trace/trace-hw_block.h"

328

········}

328

········}

329

····}

329

····}

330

}

330

}

331

static·inline·void·trace_pflash_chip_erase_invalid(const·char·*·name,·uint64_t·offset)

331

static·inline·void·trace_pflash_chip_erase_invalid(const·char·*·name,·uint64_t·offset)

343

static·inline·void·_nocheck__trace_pflash_chip_erase_start(const·char·*·name)

343

static·inline·void·_nocheck__trace_pflash_chip_erase_start(const·char·*·name)

344

{

344

{

345

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

345

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

346

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

346

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

347

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

347

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

348

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

348

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

350

············qemu_log("%d@%zu.%06zu:pflash_chip_erase_start·"·"%s:·start·chip·erase"·"\n",

350

············qemu_log("%d@%zu.%06zu:pflash_chip_erase_start·"·"%s:·start·chip·erase"·"\n",

351

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

351

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

352

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

352

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

353

·····················,·name);

353

·····················,·name);

354

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

354

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

355

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

355

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

357

············qemu_log("pflash_chip_erase_start·"·"%s:·start·chip·erase"·"\n",·name);

357

············qemu_log("pflash_chip_erase_start·"·"%s:·start·chip·erase"·"\n",·name);

358

#line·360·"trace/trace-hw_block.h"

358

#line·360·"trace/trace-hw_block.h"

359

········}

359

········}

360

····}

360

····}

361

}

361

}

362

static·inline·void·trace_pflash_chip_erase_start(const·char·*·name)

362

static·inline·void·trace_pflash_chip_erase_start(const·char·*·name)

374

static·inline·void·_nocheck__trace_pflash_data_read(const·char·*·name,·uint64_t·offset,·unsigned·size,·uint32_t·value)

374

static·inline·void·_nocheck__trace_pflash_data_read(const·char·*·name,·uint64_t·offset,·unsigned·size,·uint32_t·value)

375

{

375

{

376

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

376

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

377

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

377

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

378

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

378

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

379

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

379

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

381

············qemu_log("%d@%zu.%06zu:pflash_data_read·"·"%s:·data·offset:0x%04"PRIx64"·size:%u·value:0x%04x"·"\n",

381

············qemu_log("%d@%zu.%06zu:pflash_data_read·"·"%s:·data·offset:0x%04"PRIx64"·size:%u·value:0x%04x"·"\n",

382

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

382

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

383

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

383

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

384

·····················,·name,·offset,·size,·value);

384

·····················,·name,·offset,·size,·value);

385

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

385

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

386

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

386

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

388

············qemu_log("pflash_data_read·"·"%s:·data·offset:0x%04"PRIx64"·size:%u·value:0x%04x"·"\n",·name,·offset,·size,·value);

388

············qemu_log("pflash_data_read·"·"%s:·data·offset:0x%04"PRIx64"·size:%u·value:0x%04x"·"\n",·name,·offset,·size,·value);

389

#line·391·"trace/trace-hw_block.h"

389

#line·391·"trace/trace-hw_block.h"

390

········}

390

········}

391

····}

391

····}

392

}

392

}

393

static·inline·void·trace_pflash_data_read(const·char·*·name,·uint64_t·offset,·unsigned·size,·uint32_t·value)

393

static·inline·void·trace_pflash_data_read(const·char·*·name,·uint64_t·offset,·unsigned·size,·uint32_t·value)

405

static·inline·void·_nocheck__trace_pflash_data_write(const·char·*·name,·uint64_t·offset,·unsigned·size,·uint32_t·value,·uint64_t·counter)

405

static·inline·void·_nocheck__trace_pflash_data_write(const·char·*·name,·uint64_t·offset,·unsigned·size,·uint32_t·value,·uint64_t·counter)

406

{

406

{

407

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

407

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

408

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

408

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

409

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

409

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

410

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

410

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

412

············qemu_log("%d@%zu.%06zu:pflash_data_write·"·"%s:·data·offset:0x%04"PRIx64"·size:%u·value:0x%04x·counter:0x%016"PRIx64·"\n",

412

············qemu_log("%d@%zu.%06zu:pflash_data_write·"·"%s:·data·offset:0x%04"PRIx64"·size:%u·value:0x%04x·counter:0x%016"PRIx64·"\n",

413

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

413

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

414

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

414

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

415

·····················,·name,·offset,·size,·value,·counter);

415

·····················,·name,·offset,·size,·value,·counter);

416

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

416

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

417

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

417

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

419

············qemu_log("pflash_data_write·"·"%s:·data·offset:0x%04"PRIx64"·size:%u·value:0x%04x·counter:0x%016"PRIx64·"\n",·name,·offset,·size,·value,·counter);

419

············qemu_log("pflash_data_write·"·"%s:·data·offset:0x%04"PRIx64"·size:%u·value:0x%04x·counter:0x%016"PRIx64·"\n",·name,·offset,·size,·value,·counter);

420

#line·422·"trace/trace-hw_block.h"

420

#line·422·"trace/trace-hw_block.h"

421

········}

421

········}

422

····}

422

····}

423

}

423

}

424

static·inline·void·trace_pflash_data_write(const·char·*·name,·uint64_t·offset,·unsigned·size,·uint32_t·value,·uint64_t·counter)

424

static·inline·void·trace_pflash_data_write(const·char·*·name,·uint64_t·offset,·unsigned·size,·uint32_t·value,·uint64_t·counter)

436

static·inline·void·_nocheck__trace_pflash_device_id(const·char·*·name,·uint16_t·id)

436

static·inline·void·_nocheck__trace_pflash_device_id(const·char·*·name,·uint16_t·id)

437

{

437

{

438

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

438

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

439

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

439

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

440

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

440

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

441

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

441

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

443

············qemu_log("%d@%zu.%06zu:pflash_device_id·"·"%s:·read·device·ID:·0x%04x"·"\n",

443

············qemu_log("%d@%zu.%06zu:pflash_device_id·"·"%s:·read·device·ID:·0x%04x"·"\n",

444

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

444

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

445

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

445

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

446

·····················,·name,·id);

446

·····················,·name,·id);

447

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

447

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

448

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

448

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

450

············qemu_log("pflash_device_id·"·"%s:·read·device·ID:·0x%04x"·"\n",·name,·id);

450

············qemu_log("pflash_device_id·"·"%s:·read·device·ID:·0x%04x"·"\n",·name,·id);

451

#line·453·"trace/trace-hw_block.h"

451

#line·453·"trace/trace-hw_block.h"

452

········}

452

········}

453

····}

453

····}

454

}

454

}

455

static·inline·void·trace_pflash_device_id(const·char·*·name,·uint16_t·id)

455

static·inline·void·trace_pflash_device_id(const·char·*·name,·uint16_t·id)

467

static·inline·void·_nocheck__trace_pflash_device_info(const·char·*·name,·uint64_t·offset)

467

static·inline·void·_nocheck__trace_pflash_device_info(const·char·*·name,·uint64_t·offset)

468

{

468

{

469

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

469

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

470

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

470

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

471

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

471

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

472

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

472

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

474

············qemu_log("%d@%zu.%06zu:pflash_device_info·"·"%s:·read·device·information·offset:0x%04"·PRIx64·"\n",

474

············qemu_log("%d@%zu.%06zu:pflash_device_info·"·"%s:·read·device·information·offset:0x%04"·PRIx64·"\n",

475

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

475

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

476

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

476

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

477

·····················,·name,·offset);

477

·····················,·name,·offset);

478

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

478

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

479

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

479

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

481

············qemu_log("pflash_device_info·"·"%s:·read·device·information·offset:0x%04"·PRIx64·"\n",·name,·offset);

481

············qemu_log("pflash_device_info·"·"%s:·read·device·information·offset:0x%04"·PRIx64·"\n",·name,·offset);

482

#line·484·"trace/trace-hw_block.h"

482

#line·484·"trace/trace-hw_block.h"

483

········}

483

········}

484

····}

484

····}

485

}

485

}

486

static·inline·void·trace_pflash_device_info(const·char·*·name,·uint64_t·offset)

486

static·inline·void·trace_pflash_device_info(const·char·*·name,·uint64_t·offset)

498

static·inline·void·_nocheck__trace_pflash_erase_complete(const·char·*·name)

498

static·inline·void·_nocheck__trace_pflash_erase_complete(const·char·*·name)

499

{

499

{

500

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

500

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

501

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

501

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

502

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

502

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

503

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

503

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

505

············qemu_log("%d@%zu.%06zu:pflash_erase_complete·"·"%s:·sector·erase·complete"·"\n",

505

············qemu_log("%d@%zu.%06zu:pflash_erase_complete·"·"%s:·sector·erase·complete"·"\n",

506

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

506

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

507

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

507

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

508

·····················,·name);

508

·····················,·name);

509

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

509

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

510

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

510

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

512

············qemu_log("pflash_erase_complete·"·"%s:·sector·erase·complete"·"\n",·name);

512

············qemu_log("pflash_erase_complete·"·"%s:·sector·erase·complete"·"\n",·name);

513

#line·515·"trace/trace-hw_block.h"

513

#line·515·"trace/trace-hw_block.h"

514

········}

514

········}

515

····}

515

····}

516

}

516

}

517

static·inline·void·trace_pflash_erase_complete(const·char·*·name)

517

static·inline·void·trace_pflash_erase_complete(const·char·*·name)

529

static·inline·void·_nocheck__trace_pflash_erase_timeout(const·char·*·name,·int·count)

529

static·inline·void·_nocheck__trace_pflash_erase_timeout(const·char·*·name,·int·count)

530

{

530

{

531

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

531

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

532

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

532

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

533

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

533

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

534

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

534

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

536

············qemu_log("%d@%zu.%06zu:pflash_erase_timeout·"·"%s:·erase·timeout·fired;·erasing·%d·sectors"·"\n",

536

············qemu_log("%d@%zu.%06zu:pflash_erase_timeout·"·"%s:·erase·timeout·fired;·erasing·%d·sectors"·"\n",

537

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

537

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

538

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

538

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

539

·····················,·name,·count);

539

·····················,·name,·count);

540

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

540

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

541

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

541

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

543

············qemu_log("pflash_erase_timeout·"·"%s:·erase·timeout·fired;·erasing·%d·sectors"·"\n",·name,·count);

543

············qemu_log("pflash_erase_timeout·"·"%s:·erase·timeout·fired;·erasing·%d·sectors"·"\n",·name,·count);

544

#line·546·"trace/trace-hw_block.h"

544

#line·546·"trace/trace-hw_block.h"

545

········}

545

········}

546

····}

546

····}

547

}

547

}

548

static·inline·void·trace_pflash_erase_timeout(const·char·*·name,·int·count)

548

static·inline·void·trace_pflash_erase_timeout(const·char·*·name,·int·count)

560

static·inline·void·_nocheck__trace_pflash_io_read(const·char·*·name,·uint64_t·offset,·unsigned·int·size,·uint32_t·value,·uint8_t·cmd,·uint8_t·wcycle)

560

static·inline·void·_nocheck__trace_pflash_io_read(const·char·*·name,·uint64_t·offset,·unsigned·int·size,·uint32_t·value,·uint8_t·cmd,·uint8_t·wcycle)

561

{

561

{

562

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

562

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

563

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

563

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

564

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

564

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

565

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

565

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

567

············qemu_log("%d@%zu.%06zu:pflash_io_read·"·"%s:·offset:0x%04"·PRIx64·"·size:%u·value:0x%04x·cmd:0x%02x·wcycle:%u"·"\n",

567

············qemu_log("%d@%zu.%06zu:pflash_io_read·"·"%s:·offset:0x%04"·PRIx64·"·size:%u·value:0x%04x·cmd:0x%02x·wcycle:%u"·"\n",

568

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

568

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

569

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

569

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

570

·····················,·name,·offset,·size,·value,·cmd,·wcycle);

570

·····················,·name,·offset,·size,·value,·cmd,·wcycle);

571

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

571

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

572

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

572

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

574

············qemu_log("pflash_io_read·"·"%s:·offset:0x%04"·PRIx64·"·size:%u·value:0x%04x·cmd:0x%02x·wcycle:%u"·"\n",·name,·offset,·size,·value,·cmd,·wcycle);

574

············qemu_log("pflash_io_read·"·"%s:·offset:0x%04"·PRIx64·"·size:%u·value:0x%04x·cmd:0x%02x·wcycle:%u"·"\n",·name,·offset,·size,·value,·cmd,·wcycle);

575

#line·577·"trace/trace-hw_block.h"

575

#line·577·"trace/trace-hw_block.h"

576

········}

576

········}

577

····}

577

····}

578

}

578

}

579

static·inline·void·trace_pflash_io_read(const·char·*·name,·uint64_t·offset,·unsigned·int·size,·uint32_t·value,·uint8_t·cmd,·uint8_t·wcycle)

579

static·inline·void·trace_pflash_io_read(const·char·*·name,·uint64_t·offset,·unsigned·int·size,·uint32_t·value,·uint8_t·cmd,·uint8_t·wcycle)

591

static·inline·void·_nocheck__trace_pflash_io_write(const·char·*·name,·uint64_t·offset,·unsigned·int·size,·uint32_t·value,·uint8_t·wcycle)

591

static·inline·void·_nocheck__trace_pflash_io_write(const·char·*·name,·uint64_t·offset,·unsigned·int·size,·uint32_t·value,·uint8_t·wcycle)

592

{

592

{

593

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

593

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

594

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

594

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

595

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

595

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

596

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

596

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

598

············qemu_log("%d@%zu.%06zu:pflash_io_write·"·"%s:·offset:0x%04"PRIx64"·size:%u·value:0x%04x·wcycle:%u"·"\n",

598

············qemu_log("%d@%zu.%06zu:pflash_io_write·"·"%s:·offset:0x%04"PRIx64"·size:%u·value:0x%04x·wcycle:%u"·"\n",

599

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

599

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

600

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

600

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

601

·····················,·name,·offset,·size,·value,·wcycle);

601

·····················,·name,·offset,·size,·value,·wcycle);

602

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

602

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

603

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

603

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

605

············qemu_log("pflash_io_write·"·"%s:·offset:0x%04"PRIx64"·size:%u·value:0x%04x·wcycle:%u"·"\n",·name,·offset,·size,·value,·wcycle);

605

············qemu_log("pflash_io_write·"·"%s:·offset:0x%04"PRIx64"·size:%u·value:0x%04x·wcycle:%u"·"\n",·name,·offset,·size,·value,·wcycle);

606

#line·608·"trace/trace-hw_block.h"

606

#line·608·"trace/trace-hw_block.h"

607

········}

607

········}

608

····}

608

····}

609

}

609

}

610

static·inline·void·trace_pflash_io_write(const·char·*·name,·uint64_t·offset,·unsigned·int·size,·uint32_t·value,·uint8_t·wcycle)

610

static·inline·void·trace_pflash_io_write(const·char·*·name,·uint64_t·offset,·unsigned·int·size,·uint32_t·value,·uint8_t·wcycle)

622

static·inline·void·_nocheck__trace_pflash_manufacturer_id(const·char·*·name,·uint16_t·id)

622

static·inline·void·_nocheck__trace_pflash_manufacturer_id(const·char·*·name,·uint16_t·id)

623

{

623

{

624

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

624

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

625

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

625

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

626

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

626

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

627

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

627

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

629

············qemu_log("%d@%zu.%06zu:pflash_manufacturer_id·"·"%s:·read·manufacturer·ID:·0x%04x"·"\n",

629

············qemu_log("%d@%zu.%06zu:pflash_manufacturer_id·"·"%s:·read·manufacturer·ID:·0x%04x"·"\n",

630

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

630

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

631

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

631

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

632

·····················,·name,·id);

632

·····················,·name,·id);

633

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

633

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

634

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

634

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

636

············qemu_log("pflash_manufacturer_id·"·"%s:·read·manufacturer·ID:·0x%04x"·"\n",·name,·id);

636

············qemu_log("pflash_manufacturer_id·"·"%s:·read·manufacturer·ID:·0x%04x"·"\n",·name,·id);

637

#line·639·"trace/trace-hw_block.h"

637

#line·639·"trace/trace-hw_block.h"

638

········}

638

········}

639

····}

639

····}

640

}

640

}

641

static·inline·void·trace_pflash_manufacturer_id(const·char·*·name,·uint16_t·id)

641

static·inline·void·trace_pflash_manufacturer_id(const·char·*·name,·uint16_t·id)

653

static·inline·void·_nocheck__trace_pflash_mode_read_array(const·char·*·name)

653

static·inline·void·_nocheck__trace_pflash_mode_read_array(const·char·*·name)

654

{

654

{

655

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

655

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

656

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

656

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

657

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

657

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

658

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

658

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

660

············qemu_log("%d@%zu.%06zu:pflash_mode_read_array·"·"%s:·read·array·mode"·"\n",

660

············qemu_log("%d@%zu.%06zu:pflash_mode_read_array·"·"%s:·read·array·mode"·"\n",

661

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

661

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

662

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

662

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

663

·····················,·name);

663

·····················,·name);

664

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

664

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

665

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

665

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

667

············qemu_log("pflash_mode_read_array·"·"%s:·read·array·mode"·"\n",·name);

667

············qemu_log("pflash_mode_read_array·"·"%s:·read·array·mode"·"\n",·name);

668

#line·670·"trace/trace-hw_block.h"

668

#line·670·"trace/trace-hw_block.h"

669

········}

669

········}

670

····}

670

····}

671

}

671

}

672

static·inline·void·trace_pflash_mode_read_array(const·char·*·name)

672

static·inline·void·trace_pflash_mode_read_array(const·char·*·name)

684

static·inline·void·_nocheck__trace_pflash_postload_cb(const·char·*·name)

684

static·inline·void·_nocheck__trace_pflash_postload_cb(const·char·*·name)

685

{

685

{

686

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

686

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

687

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

687

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

688

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

688

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

689

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

689

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

691

············qemu_log("%d@%zu.%06zu:pflash_postload_cb·"·"%s:·updating·bdrv"·"\n",

691

············qemu_log("%d@%zu.%06zu:pflash_postload_cb·"·"%s:·updating·bdrv"·"\n",

692

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

692

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

693

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

693

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

694

·····················,·name);

694

·····················,·name);

695

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

695

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

696

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

696

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

698

············qemu_log("pflash_postload_cb·"·"%s:·updating·bdrv"·"\n",·name);

698

············qemu_log("pflash_postload_cb·"·"%s:·updating·bdrv"·"\n",·name);

699

#line·701·"trace/trace-hw_block.h"

699

#line·701·"trace/trace-hw_block.h"

700

········}

700

········}

701

····}

701

····}

702

}

702

}

703

static·inline·void·trace_pflash_postload_cb(const·char·*·name)

703

static·inline·void·trace_pflash_postload_cb(const·char·*·name)

715

static·inline·void·_nocheck__trace_pflash_read_done(const·char·*·name,·uint64_t·offset,·uint64_t·ret)

715

static·inline·void·_nocheck__trace_pflash_read_done(const·char·*·name,·uint64_t·offset,·uint64_t·ret)

716

{

716

{

717

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

717

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

718

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

718

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

719

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

719

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

720

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

720

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

722

············qemu_log("%d@%zu.%06zu:pflash_read_done·"·"%s:·ID:0x%"·PRIx64·"·ret:0x%"·PRIx64·"\n",

722

············qemu_log("%d@%zu.%06zu:pflash_read_done·"·"%s:·ID:0x%"·PRIx64·"·ret:0x%"·PRIx64·"\n",

723

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

723

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

724

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

724

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

725

·····················,·name,·offset,·ret);

725

·····················,·name,·offset,·ret);

726

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

726

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

727

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

727

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

729

············qemu_log("pflash_read_done·"·"%s:·ID:0x%"·PRIx64·"·ret:0x%"·PRIx64·"\n",·name,·offset,·ret);

729

············qemu_log("pflash_read_done·"·"%s:·ID:0x%"·PRIx64·"·ret:0x%"·PRIx64·"\n",·name,·offset,·ret);

730

#line·732·"trace/trace-hw_block.h"

730

#line·732·"trace/trace-hw_block.h"

731

········}

731

········}

732

····}

732

····}

733

}

733

}

734

static·inline·void·trace_pflash_read_done(const·char·*·name,·uint64_t·offset,·uint64_t·ret)

734

static·inline·void·trace_pflash_read_done(const·char·*·name,·uint64_t·offset,·uint64_t·ret)

746

static·inline·void·_nocheck__trace_pflash_read_status(const·char·*·name,·uint32_t·ret)

746

static·inline·void·_nocheck__trace_pflash_read_status(const·char·*·name,·uint32_t·ret)

747

{

747

{

748

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

748

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

749

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

749

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

750

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

750

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

751

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

751

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

753

············qemu_log("%d@%zu.%06zu:pflash_read_status·"·"%s:·status:0x%x"·"\n",

753

············qemu_log("%d@%zu.%06zu:pflash_read_status·"·"%s:·status:0x%x"·"\n",

754

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

754

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

755

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

755

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

756

·····················,·name,·ret);

756

·····················,·name,·ret);

757

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

757

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

758

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

758

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

760

············qemu_log("pflash_read_status·"·"%s:·status:0x%x"·"\n",·name,·ret);

760

············qemu_log("pflash_read_status·"·"%s:·status:0x%x"·"\n",·name,·ret);

761

#line·763·"trace/trace-hw_block.h"

761

#line·763·"trace/trace-hw_block.h"

762

········}

762

········}

763

····}

763

····}

764

}

764

}

765

static·inline·void·trace_pflash_read_status(const·char·*·name,·uint32_t·ret)

765

static·inline·void·trace_pflash_read_status(const·char·*·name,·uint32_t·ret)

777

static·inline·void·_nocheck__trace_pflash_read_unknown_state(const·char·*·name,·uint8_t·cmd)

777

static·inline·void·_nocheck__trace_pflash_read_unknown_state(const·char·*·name,·uint8_t·cmd)

778

{

778

{

779

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

779

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

780

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

780

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

781

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

781

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

782

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

782

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

784

············qemu_log("%d@%zu.%06zu:pflash_read_unknown_state·"·"%s:·unknown·command·state:0x%x"·"\n",

784

············qemu_log("%d@%zu.%06zu:pflash_read_unknown_state·"·"%s:·unknown·command·state:0x%x"·"\n",

785

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

785

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

786

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

786

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

787

·····················,·name,·cmd);

787

·····················,·name,·cmd);

788

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

788

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

789

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

789

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

791

············qemu_log("pflash_read_unknown_state·"·"%s:·unknown·command·state:0x%x"·"\n",·name,·cmd);

791

············qemu_log("pflash_read_unknown_state·"·"%s:·unknown·command·state:0x%x"·"\n",·name,·cmd);

792

#line·794·"trace/trace-hw_block.h"

792

#line·794·"trace/trace-hw_block.h"

793

········}

793

········}

794

····}

794

····}

795

}

795

}

796

static·inline·void·trace_pflash_read_unknown_state(const·char·*·name,·uint8_t·cmd)

796

static·inline·void·trace_pflash_read_unknown_state(const·char·*·name,·uint8_t·cmd)

808

static·inline·void·_nocheck__trace_pflash_reset(const·char·*·name)

808

static·inline·void·_nocheck__trace_pflash_reset(const·char·*·name)

809

{

809

{

810

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

810

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

811

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

811

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

812

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

812

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

813

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

813

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

815

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

815

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

816

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

816

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

817

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

817

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

818

·····················,·name);

818

·····················,·name);

819

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

819

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

820

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

820

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

822

············qemu_log("pflash_reset·"·"%s:·reset"·"\n",·name);

822

············qemu_log("pflash_reset·"·"%s:·reset"·"\n",·name);

823

#line·825·"trace/trace-hw_block.h"

823

#line·825·"trace/trace-hw_block.h"

824

········}

824

········}

825

····}

825

····}

826

}

826

}

827

static·inline·void·trace_pflash_reset(const·char·*·name)

827

static·inline·void·trace_pflash_reset(const·char·*·name)

839

static·inline·void·_nocheck__trace_pflash_sector_erase_start(const·char·*·name,·int·width1,·uint64_t·start,·int·width2,·uint64_t·end)

839

static·inline·void·_nocheck__trace_pflash_sector_erase_start(const·char·*·name,·int·width1,·uint64_t·start,·int·width2,·uint64_t·end)

840

{

840

{

841

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

841

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

842

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

842

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

843

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

843

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

844

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

844

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

846

············qemu_log("%d@%zu.%06zu:pflash_sector_erase_start·"·"%s:·start·sector·erase·at:·0x%0*"·PRIx64·"-0x%0*"·PRIx64·"\n",

846

············qemu_log("%d@%zu.%06zu:pflash_sector_erase_start·"·"%s:·start·sector·erase·at:·0x%0*"·PRIx64·"-0x%0*"·PRIx64·"\n",

847

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

847

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

848

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

848

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

849

·····················,·name,·width1,·start,·width2,·end);

849

·····················,·name,·width1,·start,·width2,·end);

850

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

850

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

851

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

851

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

853

············qemu_log("pflash_sector_erase_start·"·"%s:·start·sector·erase·at:·0x%0*"·PRIx64·"-0x%0*"·PRIx64·"\n",·name,·width1,·start,·width2,·end);

853

············qemu_log("pflash_sector_erase_start·"·"%s:·start·sector·erase·at:·0x%0*"·PRIx64·"-0x%0*"·PRIx64·"\n",·name,·width1,·start,·width2,·end);

854

#line·856·"trace/trace-hw_block.h"

854

#line·856·"trace/trace-hw_block.h"

855

········}

855

········}

856

····}

856

····}

857

}

857

}

858

static·inline·void·trace_pflash_sector_erase_start(const·char·*·name,·int·width1,·uint64_t·start,·int·width2,·uint64_t·end)

858

static·inline·void·trace_pflash_sector_erase_start(const·char·*·name,·int·width1,·uint64_t·start,·int·width2,·uint64_t·end)

870

static·inline·void·_nocheck__trace_pflash_timer_expired(const·char·*·name,·uint8_t·cmd)

870

static·inline·void·_nocheck__trace_pflash_timer_expired(const·char·*·name,·uint8_t·cmd)

871

{

871

{

872

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

872

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

873

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

873

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

874

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

874

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

875

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

875

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

877

············qemu_log("%d@%zu.%06zu:pflash_timer_expired·"·"%s:·command·0x%02x·done"·"\n",

877

············qemu_log("%d@%zu.%06zu:pflash_timer_expired·"·"%s:·command·0x%02x·done"·"\n",

878

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

878

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

879

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

879

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

880

·····················,·name,·cmd);

880

·····················,·name,·cmd);

881

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

881

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

882

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

882

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

884

············qemu_log("pflash_timer_expired·"·"%s:·command·0x%02x·done"·"\n",·name,·cmd);

884

············qemu_log("pflash_timer_expired·"·"%s:·command·0x%02x·done"·"\n",·name,·cmd);

885

#line·887·"trace/trace-hw_block.h"

885

#line·887·"trace/trace-hw_block.h"

886

········}

886

········}

887

····}

887

····}

888

}

888

}

889

static·inline·void·trace_pflash_timer_expired(const·char·*·name,·uint8_t·cmd)

889

static·inline·void·trace_pflash_timer_expired(const·char·*·name,·uint8_t·cmd)

901

static·inline·void·_nocheck__trace_pflash_unlock0_failed(const·char·*·name,·uint64_t·offset,·uint8_t·cmd,·uint16_t·addr0)

901

static·inline·void·_nocheck__trace_pflash_unlock0_failed(const·char·*·name,·uint64_t·offset,·uint8_t·cmd,·uint16_t·addr0)

902

{

902

{

903

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

903

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

904

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

904

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

905

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

905

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

906

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

906

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

908

············qemu_log("%d@%zu.%06zu:pflash_unlock0_failed·"·"%s:·unlock0·failed·0x%"·PRIx64·"·0x%02x·0x%04x"·"\n",

908

············qemu_log("%d@%zu.%06zu:pflash_unlock0_failed·"·"%s:·unlock0·failed·0x%"·PRIx64·"·0x%02x·0x%04x"·"\n",

909

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

909

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

910

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

910

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

911

·····················,·name,·offset,·cmd,·addr0);

911

·····················,·name,·offset,·cmd,·addr0);

912

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

912

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

913

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

913

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

915

············qemu_log("pflash_unlock0_failed·"·"%s:·unlock0·failed·0x%"·PRIx64·"·0x%02x·0x%04x"·"\n",·name,·offset,·cmd,·addr0);

915

············qemu_log("pflash_unlock0_failed·"·"%s:·unlock0·failed·0x%"·PRIx64·"·0x%02x·0x%04x"·"\n",·name,·offset,·cmd,·addr0);

916

#line·918·"trace/trace-hw_block.h"

916

#line·918·"trace/trace-hw_block.h"

917

········}

917

········}

918

····}

918

····}

919

}

919

}

920

static·inline·void·trace_pflash_unlock0_failed(const·char·*·name,·uint64_t·offset,·uint8_t·cmd,·uint16_t·addr0)

920

static·inline·void·trace_pflash_unlock0_failed(const·char·*·name,·uint64_t·offset,·uint8_t·cmd,·uint16_t·addr0)

932

static·inline·void·_nocheck__trace_pflash_unlock1_failed(const·char·*·name,·uint64_t·offset,·uint8_t·cmd)

932

static·inline·void·_nocheck__trace_pflash_unlock1_failed(const·char·*·name,·uint64_t·offset,·uint8_t·cmd)

933

{

933

{

934

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

934

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

935

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

935

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

936

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

936

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

937

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

937

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

939

············qemu_log("%d@%zu.%06zu:pflash_unlock1_failed·"·"%s:·unlock0·failed·0x%"·PRIx64·"·0x%02x"·"\n",

939

············qemu_log("%d@%zu.%06zu:pflash_unlock1_failed·"·"%s:·unlock0·failed·0x%"·PRIx64·"·0x%02x"·"\n",

940

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

940

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

941

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

941

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

942

·····················,·name,·offset,·cmd);

942

·····················,·name,·offset,·cmd);

943

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

943

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

944

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

944

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

946

············qemu_log("pflash_unlock1_failed·"·"%s:·unlock0·failed·0x%"·PRIx64·"·0x%02x"·"\n",·name,·offset,·cmd);

946

············qemu_log("pflash_unlock1_failed·"·"%s:·unlock0·failed·0x%"·PRIx64·"·0x%02x"·"\n",·name,·offset,·cmd);

947

#line·949·"trace/trace-hw_block.h"

947

#line·949·"trace/trace-hw_block.h"

948

········}

948

········}

949

····}

949

····}

950

}

950

}

951

static·inline·void·trace_pflash_unlock1_failed(const·char·*·name,·uint64_t·offset,·uint8_t·cmd)

951

static·inline·void·trace_pflash_unlock1_failed(const·char·*·name,·uint64_t·offset,·uint8_t·cmd)

963

static·inline·void·_nocheck__trace_pflash_unsupported_device_configuration(const·char·*·name,·uint8_t·width,·uint8_t·max)

963

static·inline·void·_nocheck__trace_pflash_unsupported_device_configuration(const·char·*·name,·uint8_t·width,·uint8_t·max)

964

{

964

{

965

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

965

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

966

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

966

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

967

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

967

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

968

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

968

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

970

············qemu_log("%d@%zu.%06zu:pflash_unsupported_device_configuration·"·"%s:·unsupported·device·configuration:·device_width:%d·max_device_width:%d"·"\n",

970

············qemu_log("%d@%zu.%06zu:pflash_unsupported_device_configuration·"·"%s:·unsupported·device·configuration:·device_width:%d·max_device_width:%d"·"\n",

971

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

971

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

972

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

972

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

973

·····················,·name,·width,·max);

973

·····················,·name,·width,·max);

974

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

974

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

975

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

975

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

977

············qemu_log("pflash_unsupported_device_configuration·"·"%s:·unsupported·device·configuration:·device_width:%d·max_device_width:%d"·"\n",·name,·width,·max);

977

············qemu_log("pflash_unsupported_device_configuration·"·"%s:·unsupported·device·configuration:·device_width:%d·max_device_width:%d"·"\n",·name,·width,·max);

978

#line·980·"trace/trace-hw_block.h"

978

#line·980·"trace/trace-hw_block.h"

979

········}

979

········}

980

····}

980

····}

981

}

981

}

982

static·inline·void·trace_pflash_unsupported_device_configuration(const·char·*·name,·uint8_t·width,·uint8_t·max)

982

static·inline·void·trace_pflash_unsupported_device_configuration(const·char·*·name,·uint8_t·width,·uint8_t·max)

994

static·inline·void·_nocheck__trace_pflash_write(const·char·*·name,·const·char·*·str)

994

static·inline·void·_nocheck__trace_pflash_write(const·char·*·name,·const·char·*·str)

995

{

995

{

996

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

996

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

997

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

997

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

998

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

998

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

999

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

999

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

1001

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

1001

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

1002

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

1002

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

1003

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

1003

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

1004

·····················,·name,·str);

1004

·····················,·name,·str);

1005

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

1005

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

1006

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

1006

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

1008

············qemu_log("pflash_write·"·"%s:·%s"·"\n",·name,·str);

1008

············qemu_log("pflash_write·"·"%s:·%s"·"\n",·name,·str);

1009

#line·1011·"trace/trace-hw_block.h"

1009

#line·1011·"trace/trace-hw_block.h"

1010

········}

1010

········}

1011

····}

1011

····}

1012

}

1012

}

1013

static·inline·void·trace_pflash_write(const·char·*·name,·const·char·*·str)

1013

static·inline·void·trace_pflash_write(const·char·*·name,·const·char·*·str)

1025

static·inline·void·_nocheck__trace_pflash_write_block(const·char·*·name,·uint32_t·value)

1025

static·inline·void·_nocheck__trace_pflash_write_block(const·char·*·name,·uint32_t·value)

1026

{

1026

{

1027

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

1027

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

1028

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

1028

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

1029

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

1029

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

1030

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

1030

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

1032

············qemu_log("%d@%zu.%06zu:pflash_write_block·"·"%s:·block·write:·bytes:0x%x"·"\n",

1032

············qemu_log("%d@%zu.%06zu:pflash_write_block·"·"%s:·block·write:·bytes:0x%x"·"\n",

1033

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

1033

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

1034

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

1034

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

1035

·····················,·name,·value);

1035

·····················,·name,·value);

1036

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

1036

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

1037

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

1037

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

1039

············qemu_log("pflash_write_block·"·"%s:·block·write:·bytes:0x%x"·"\n",·name,·value);

1039

············qemu_log("pflash_write_block·"·"%s:·block·write:·bytes:0x%x"·"\n",·name,·value);

1040

#line·1042·"trace/trace-hw_block.h"

1040

#line·1042·"trace/trace-hw_block.h"

1041

········}

1041

········}

1042

····}

1042

····}

1043

}

1043

}

1044

static·inline·void·trace_pflash_write_block(const·char·*·name,·uint32_t·value)

1044

static·inline·void·trace_pflash_write_block(const·char·*·name,·uint32_t·value)

1056

static·inline·void·_nocheck__trace_pflash_write_block_erase(const·char·*·name,·uint64_t·offset,·uint64_t·len)

1056

static·inline·void·_nocheck__trace_pflash_write_block_erase(const·char·*·name,·uint64_t·offset,·uint64_t·len)

1057

{

1057

{

1058

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

1058

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

1059

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

1059

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

1060

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

1060

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

1061

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

1061

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

1063

············qemu_log("%d@%zu.%06zu:pflash_write_block_erase·"·"%s:·block·erase·offset:0x%"·PRIx64·"·bytes:0x%"·PRIx64·"\n",

1063

············qemu_log("%d@%zu.%06zu:pflash_write_block_erase·"·"%s:·block·erase·offset:0x%"·PRIx64·"·bytes:0x%"·PRIx64·"\n",

1064

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

1064

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

1065

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

1065

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

1066

·····················,·name,·offset,·len);

1066

·····················,·name,·offset,·len);

1067

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

1067

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

1068

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

1068

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

1070

············qemu_log("pflash_write_block_erase·"·"%s:·block·erase·offset:0x%"·PRIx64·"·bytes:0x%"·PRIx64·"\n",·name,·offset,·len);

1070

············qemu_log("pflash_write_block_erase·"·"%s:·block·erase·offset:0x%"·PRIx64·"·bytes:0x%"·PRIx64·"\n",·name,·offset,·len);

1071

#line·1073·"trace/trace-hw_block.h"

1071

#line·1073·"trace/trace-hw_block.h"

1072

········}

1072

········}

1073

····}

1073

····}

1074

}

1074

}

1075

static·inline·void·trace_pflash_write_block_erase(const·char·*·name,·uint64_t·offset,·uint64_t·len)

1075

static·inline·void·trace_pflash_write_block_erase(const·char·*·name,·uint64_t·offset,·uint64_t·len)

1087

static·inline·void·_nocheck__trace_pflash_write_failed(const·char·*·name,·uint64_t·offset,·uint8_t·cmd)

1087

static·inline·void·_nocheck__trace_pflash_write_failed(const·char·*·name,·uint64_t·offset,·uint8_t·cmd)

1088

{

1088

{

1089

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

1089

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

1090

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

1090

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

1091

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

1091

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

1092

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

1092

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

1094

············qemu_log("%d@%zu.%06zu:pflash_write_failed·"·"%s:·command·failed·0x%"·PRIx64·"·0x%02x"·"\n",

1094

············qemu_log("%d@%zu.%06zu:pflash_write_failed·"·"%s:·command·failed·0x%"·PRIx64·"·0x%02x"·"\n",

1095

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

1095

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

1096

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

1096

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

1097

·····················,·name,·offset,·cmd);

1097

·····················,·name,·offset,·cmd);

1098

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

1098

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

1099

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

1099

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

1101

············qemu_log("pflash_write_failed·"·"%s:·command·failed·0x%"·PRIx64·"·0x%02x"·"\n",·name,·offset,·cmd);

1101

············qemu_log("pflash_write_failed·"·"%s:·command·failed·0x%"·PRIx64·"·0x%02x"·"\n",·name,·offset,·cmd);

1102

#line·1104·"trace/trace-hw_block.h"

1102

#line·1104·"trace/trace-hw_block.h"

1103

········}

1103

········}

1104

····}

1104

····}

1105

}

1105

}

1106

static·inline·void·trace_pflash_write_failed(const·char·*·name,·uint64_t·offset,·uint8_t·cmd)

1106

static·inline·void·trace_pflash_write_failed(const·char·*·name,·uint64_t·offset,·uint8_t·cmd)

1118

static·inline·void·_nocheck__trace_pflash_write_invalid(const·char·*·name,·uint8_t·cmd)

1118

static·inline·void·_nocheck__trace_pflash_write_invalid(const·char·*·name,·uint8_t·cmd)

1119

{

1119

{

1120

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

1120

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

1121

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

1121

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

1122

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

1122

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

1123

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

1123

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

1125

············qemu_log("%d@%zu.%06zu:pflash_write_invalid·"·"%s:·invalid·write·for·command·0x%02x"·"\n",

1125

············qemu_log("%d@%zu.%06zu:pflash_write_invalid·"·"%s:·invalid·write·for·command·0x%02x"·"\n",

1126

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

1126

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

1127

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

1127

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

1128

·····················,·name,·cmd);

1128

·····················,·name,·cmd);

1129

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

1129

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

1130

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

1130

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

1132

············qemu_log("pflash_write_invalid·"·"%s:·invalid·write·for·command·0x%02x"·"\n",·name,·cmd);

1132

············qemu_log("pflash_write_invalid·"·"%s:·invalid·write·for·command·0x%02x"·"\n",·name,·cmd);

1133

#line·1135·"trace/trace-hw_block.h"

1133

#line·1135·"trace/trace-hw_block.h"

1134

········}

1134

········}

1135

····}

1135

····}

1136

}

1136

}

1137

static·inline·void·trace_pflash_write_invalid(const·char·*·name,·uint8_t·cmd)

1137

static·inline·void·trace_pflash_write_invalid(const·char·*·name,·uint8_t·cmd)

1149

static·inline·void·_nocheck__trace_pflash_write_invalid_command(const·char·*·name,·uint8_t·cmd)

1149

static·inline·void·_nocheck__trace_pflash_write_invalid_command(const·char·*·name,·uint8_t·cmd)

1150

{

1150

{

1151

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

1151

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

1152

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

1152

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

1153

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

1153

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

1154

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

1154

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

1156

············qemu_log("%d@%zu.%06zu:pflash_write_invalid_command·"·"%s:·invalid·command·0x%02x·(wc·5)"·"\n",

1156

············qemu_log("%d@%zu.%06zu:pflash_write_invalid_command·"·"%s:·invalid·command·0x%02x·(wc·5)"·"\n",

1157

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

1157

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

1158

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

1158

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

1159

·····················,·name,·cmd);

1159

·····················,·name,·cmd);

1160

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

1160

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

1161

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

1161

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

1163

············qemu_log("pflash_write_invalid_command·"·"%s:·invalid·command·0x%02x·(wc·5)"·"\n",·name,·cmd);

1163

············qemu_log("pflash_write_invalid_command·"·"%s:·invalid·command·0x%02x·(wc·5)"·"\n",·name,·cmd);

1164

#line·1166·"trace/trace-hw_block.h"

1164

#line·1166·"trace/trace-hw_block.h"

1165

········}

1165

········}

1166

····}

1166

····}

1167

}

1167

}

1168

static·inline·void·trace_pflash_write_invalid_command(const·char·*·name,·uint8_t·cmd)

1168

static·inline·void·trace_pflash_write_invalid_command(const·char·*·name,·uint8_t·cmd)

1180

static·inline·void·_nocheck__trace_pflash_write_invalid_state(const·char·*·name,·uint8_t·cmd,·int·wc)

1180

static·inline·void·_nocheck__trace_pflash_write_invalid_state(const·char·*·name,·uint8_t·cmd,·int·wc)

1181

{

1181

{

1182

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

1182

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

1183

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

1183

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

1184

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

1184

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

1185

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

1185

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

1187

············qemu_log("%d@%zu.%06zu:pflash_write_invalid_state·"·"%s:·invalid·command·state·0x%02x·(wc·%d)"·"\n",

1187

············qemu_log("%d@%zu.%06zu:pflash_write_invalid_state·"·"%s:·invalid·command·state·0x%02x·(wc·%d)"·"\n",

1188

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

1188

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

1189

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

1189

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

1190

·····················,·name,·cmd,·wc);

1190

·····················,·name,·cmd,·wc);

1191

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

1191

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

1192

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

1192

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

1194

············qemu_log("pflash_write_invalid_state·"·"%s:·invalid·command·state·0x%02x·(wc·%d)"·"\n",·name,·cmd,·wc);

1194

············qemu_log("pflash_write_invalid_state·"·"%s:·invalid·command·state·0x%02x·(wc·%d)"·"\n",·name,·cmd,·wc);

1195

#line·1197·"trace/trace-hw_block.h"

1195

#line·1197·"trace/trace-hw_block.h"

1196

········}

1196

········}

1197

····}

1197

····}

1198

}

1198

}

1199

static·inline·void·trace_pflash_write_invalid_state(const·char·*·name,·uint8_t·cmd,·int·wc)

1199

static·inline·void·trace_pflash_write_invalid_state(const·char·*·name,·uint8_t·cmd,·int·wc)

1211

static·inline·void·_nocheck__trace_pflash_write_start(const·char·*·name,·uint8_t·cmd)

1211

static·inline·void·_nocheck__trace_pflash_write_start(const·char·*·name,·uint8_t·cmd)

1212

{

1212

{

1213

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

1213

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

1214

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

1214

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

1215

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

1215

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

1216

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

1216

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

1218

············qemu_log("%d@%zu.%06zu:pflash_write_start·"·"%s:·starting·command·0x%02x"·"\n",

1218

············qemu_log("%d@%zu.%06zu:pflash_write_start·"·"%s:·starting·command·0x%02x"·"\n",

1219

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

1219

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

1220

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

1220

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

1221

·····················,·name,·cmd);

1221

·····················,·name,·cmd);

1222

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

1222

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

1223

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

1223

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

1225

············qemu_log("pflash_write_start·"·"%s:·starting·command·0x%02x"·"\n",·name,·cmd);

1225

············qemu_log("pflash_write_start·"·"%s:·starting·command·0x%02x"·"\n",·name,·cmd);

1226

#line·1228·"trace/trace-hw_block.h"

1226

#line·1228·"trace/trace-hw_block.h"

1227

········}

1227

········}

1228

····}

1228

····}

1229

}

1229

}

1230

static·inline·void·trace_pflash_write_start(const·char·*·name,·uint8_t·cmd)

1230

static·inline·void·trace_pflash_write_start(const·char·*·name,·uint8_t·cmd)

1242

static·inline·void·_nocheck__trace_pflash_write_unknown(const·char·*·name,·uint8_t·cmd)

1242

static·inline·void·_nocheck__trace_pflash_write_unknown(const·char·*·name,·uint8_t·cmd)

1243

{

1243

{

1244

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

1244

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

1245

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

1245

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

1246

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

1246

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

1247

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

1247

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

1249

············qemu_log("%d@%zu.%06zu:pflash_write_unknown·"·"%s:·unknown·command·0x%02x"·"\n",

1249

············qemu_log("%d@%zu.%06zu:pflash_write_unknown·"·"%s:·unknown·command·0x%02x"·"\n",

1250

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

1250

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

1251

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

1251

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

1252

·····················,·name,·cmd);

1252

·····················,·name,·cmd);

1253

#line·1255·"trace/trace-hw_block.h"

1253

#line·1255·"trace/trace-hw_block.h"

1254

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

1254

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

1256

············qemu_log("pflash_write_unknown·"·"%s:·unknown·command·0x%02x"·"\n",·name,·cmd);

1256

············qemu_log("pflash_write_unknown·"·"%s:·unknown·command·0x%02x"·"\n",·name,·cmd);

1257

#line·1259·"trace/trace-hw_block.h"

1257

#line·1259·"trace/trace-hw_block.h"

1258

········}

1258

········}

1259

····}

1259

····}

1260

}

1260

}

1261

static·inline·void·trace_pflash_write_unknown(const·char·*·name,·uint8_t·cmd)

1261

static·inline·void·trace_pflash_write_unknown(const·char·*·name,·uint8_t·cmd)

1273

static·inline·void·_nocheck__trace_virtio_blk_req_complete(void·*·vdev,·void·*·req,·int·status)

1273

static·inline·void·_nocheck__trace_virtio_blk_req_complete(void·*·vdev,·void·*·req,·int·status)

1274

{

1274

{

1275

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

1275

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

1276

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

1276

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

1277

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

1277

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

1278

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

1278

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

1280

············qemu_log("%d@%zu.%06zu:virtio_blk_req_complete·"·"vdev·%p·req·%p·status·%d"·"\n",

1280

············qemu_log("%d@%zu.%06zu:virtio_blk_req_complete·"·"vdev·%p·req·%p·status·%d"·"\n",

1281

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

1281

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

1282

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

1282

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

1283

·····················,·vdev,·req,·status);

1283

·····················,·vdev,·req,·status);

1284

#line·1286·"trace/trace-hw_block.h"

1284

#line·1286·"trace/trace-hw_block.h"

1285

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

1285

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

1287

············qemu_log("virtio_blk_req_complete·"·"vdev·%p·req·%p·status·%d"·"\n",·vdev,·req,·status);

1287

············qemu_log("virtio_blk_req_complete·"·"vdev·%p·req·%p·status·%d"·"\n",·vdev,·req,·status);

1288

#line·1290·"trace/trace-hw_block.h"

1288

#line·1290·"trace/trace-hw_block.h"

1289

········}

1289

········}

1290

····}

1290

····}

1291

}

1291

}

1292

static·inline·void·trace_virtio_blk_req_complete(void·*·vdev,·void·*·req,·int·status)

1292

static·inline·void·trace_virtio_blk_req_complete(void·*·vdev,·void·*·req,·int·status)

1304

static·inline·void·_nocheck__trace_virtio_blk_rw_complete(void·*·vdev,·void·*·req,·int·ret)

1304

static·inline·void·_nocheck__trace_virtio_blk_rw_complete(void·*·vdev,·void·*·req,·int·ret)

1305

{

1305

{

1306

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

1306

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

1307

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

1307

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

1308

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

1308

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

1309

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

1309

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

1311

············qemu_log("%d@%zu.%06zu:virtio_blk_rw_complete·"·"vdev·%p·req·%p·ret·%d"·"\n",

1311

············qemu_log("%d@%zu.%06zu:virtio_blk_rw_complete·"·"vdev·%p·req·%p·ret·%d"·"\n",

1312

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

1312

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

1313

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

1313

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

1314

·····················,·vdev,·req,·ret);

1314

·····················,·vdev,·req,·ret);

1315

#line·1317·"trace/trace-hw_block.h"

1315

#line·1317·"trace/trace-hw_block.h"

1316

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

1316

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

1318

············qemu_log("virtio_blk_rw_complete·"·"vdev·%p·req·%p·ret·%d"·"\n",·vdev,·req,·ret);

1318

············qemu_log("virtio_blk_rw_complete·"·"vdev·%p·req·%p·ret·%d"·"\n",·vdev,·req,·ret);

1319

#line·1321·"trace/trace-hw_block.h"

1319

#line·1321·"trace/trace-hw_block.h"

1320

········}

1320

········}

1321

····}

1321

····}

1322

}

1322

}

1323

static·inline·void·trace_virtio_blk_rw_complete(void·*·vdev,·void·*·req,·int·ret)

1323

static·inline·void·trace_virtio_blk_rw_complete(void·*·vdev,·void·*·req,·int·ret)

1335

static·inline·void·_nocheck__trace_virtio_blk_handle_write(void·*·vdev,·void·*·req,·uint64_t·sector,·size_t·nsectors)

1335

static·inline·void·_nocheck__trace_virtio_blk_handle_write(void·*·vdev,·void·*·req,·uint64_t·sector,·size_t·nsectors)

1336

{

1336

{

1337

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

1337

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

1338

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

1338

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

1339

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

1339

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

1340

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

1340

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

1342

············qemu_log("%d@%zu.%06zu:virtio_blk_handle_write·"·"vdev·%p·req·%p·sector·%"PRIu64"·nsectors·%zu"·"\n",

1342

············qemu_log("%d@%zu.%06zu:virtio_blk_handle_write·"·"vdev·%p·req·%p·sector·%"PRIu64"·nsectors·%zu"·"\n",

1343

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

1343

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

1344

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

1344

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

1345

·····················,·vdev,·req,·sector,·nsectors);

1345

·····················,·vdev,·req,·sector,·nsectors);

1346

#line·1348·"trace/trace-hw_block.h"

1346

#line·1348·"trace/trace-hw_block.h"

1347

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

1347

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

1349

············qemu_log("virtio_blk_handle_write·"·"vdev·%p·req·%p·sector·%"PRIu64"·nsectors·%zu"·"\n",·vdev,·req,·sector,·nsectors);

1349

············qemu_log("virtio_blk_handle_write·"·"vdev·%p·req·%p·sector·%"PRIu64"·nsectors·%zu"·"\n",·vdev,·req,·sector,·nsectors);

1350

#line·1352·"trace/trace-hw_block.h"

1350

#line·1352·"trace/trace-hw_block.h"

1351

········}

1351

········}

1352

····}

1352

····}

1353

}

1353

}

1354

static·inline·void·trace_virtio_blk_handle_write(void·*·vdev,·void·*·req,·uint64_t·sector,·size_t·nsectors)

1354

static·inline·void·trace_virtio_blk_handle_write(void·*·vdev,·void·*·req,·uint64_t·sector,·size_t·nsectors)

1366

static·inline·void·_nocheck__trace_virtio_blk_handle_read(void·*·vdev,·void·*·req,·uint64_t·sector,·size_t·nsectors)

1366

static·inline·void·_nocheck__trace_virtio_blk_handle_read(void·*·vdev,·void·*·req,·uint64_t·sector,·size_t·nsectors)

1367

{

1367

{

1368

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

1368

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

1369

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

1369

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

1370

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

1370

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

1371

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

1371

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

1373

············qemu_log("%d@%zu.%06zu:virtio_blk_handle_read·"·"vdev·%p·req·%p·sector·%"PRIu64"·nsectors·%zu"·"\n",

1373

············qemu_log("%d@%zu.%06zu:virtio_blk_handle_read·"·"vdev·%p·req·%p·sector·%"PRIu64"·nsectors·%zu"·"\n",

1374

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

1374

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

1375

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

1375

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

1376

·····················,·vdev,·req,·sector,·nsectors);

1376

·····················,·vdev,·req,·sector,·nsectors);

1377

#line·1379·"trace/trace-hw_block.h"

1377

#line·1379·"trace/trace-hw_block.h"

1378

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

1378

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

1380

············qemu_log("virtio_blk_handle_read·"·"vdev·%p·req·%p·sector·%"PRIu64"·nsectors·%zu"·"\n",·vdev,·req,·sector,·nsectors);

1380

············qemu_log("virtio_blk_handle_read·"·"vdev·%p·req·%p·sector·%"PRIu64"·nsectors·%zu"·"\n",·vdev,·req,·sector,·nsectors);

1381

#line·1383·"trace/trace-hw_block.h"

1381

#line·1383·"trace/trace-hw_block.h"

1382

········}

1382

········}

1383

····}

1383

····}

1384

}

1384

}

1385

static·inline·void·trace_virtio_blk_handle_read(void·*·vdev,·void·*·req,·uint64_t·sector,·size_t·nsectors)

1385

static·inline·void·trace_virtio_blk_handle_read(void·*·vdev,·void·*·req,·uint64_t·sector,·size_t·nsectors)

1397

static·inline·void·_nocheck__trace_virtio_blk_submit_multireq(void·*·vdev,·void·*·mrb,·int·start,·int·num_reqs,·uint64_t·offset,·size_t·size,·bool·is_write)

1397

static·inline·void·_nocheck__trace_virtio_blk_submit_multireq(void·*·vdev,·void·*·mrb,·int·start,·int·num_reqs,·uint64_t·offset,·size_t·size,·bool·is_write)

1398

{

1398

{

1399

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

1399

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

1400

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

1400

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

1401

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

1401

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

1402

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

1402

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

1404

············qemu_log("%d@%zu.%06zu:virtio_blk_submit_multireq·"·"vdev·%p·mrb·%p·start·%d·num_reqs·%d·offset·%"PRIu64"·size·%zu·is_write·%d"·"\n",

1404

············qemu_log("%d@%zu.%06zu:virtio_blk_submit_multireq·"·"vdev·%p·mrb·%p·start·%d·num_reqs·%d·offset·%"PRIu64"·size·%zu·is_write·%d"·"\n",

1405

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

1405

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

1406

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

1406

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

1407

·····················,·vdev,·mrb,·start,·num_reqs,·offset,·size,·is_write);

1407

·····················,·vdev,·mrb,·start,·num_reqs,·offset,·size,·is_write);

1408

#line·1410·"trace/trace-hw_block.h"

1408

#line·1410·"trace/trace-hw_block.h"

1409

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

1409

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

1411

············qemu_log("virtio_blk_submit_multireq·"·"vdev·%p·mrb·%p·start·%d·num_reqs·%d·offset·%"PRIu64"·size·%zu·is_write·%d"·"\n",·vdev,·mrb,·start,·num_reqs,·offset,·size,·is_write);

1411

············qemu_log("virtio_blk_submit_multireq·"·"vdev·%p·mrb·%p·start·%d·num_reqs·%d·offset·%"PRIu64"·size·%zu·is_write·%d"·"\n",·vdev,·mrb,·start,·num_reqs,·offset,·size,·is_write);

1412

#line·1414·"trace/trace-hw_block.h"

1412

#line·1414·"trace/trace-hw_block.h"

1413

········}

1413

········}

1414

····}

1414

····}

1415

}

1415

}

1416

static·inline·void·trace_virtio_blk_submit_multireq(void·*·vdev,·void·*·mrb,·int·start,·int·num_reqs,·uint64_t·offset,·size_t·size,·bool·is_write)

1416

static·inline·void·trace_virtio_blk_submit_multireq(void·*·vdev,·void·*·mrb,·int·start,·int·num_reqs,·uint64_t·offset,·size_t·size,·bool·is_write)

1428

static·inline·void·_nocheck__trace_hd_geometry_lchs_guess(void·*·blk,·int·cyls,·int·heads,·int·secs)

1428

static·inline·void·_nocheck__trace_hd_geometry_lchs_guess(void·*·blk,·int·cyls,·int·heads,·int·secs)

1429

{

1429

{

1430

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

1430

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

1431

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

1431

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

1432

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

1432

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

1433

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

1433

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

1435

············qemu_log("%d@%zu.%06zu:hd_geometry_lchs_guess·"·"blk·%p·LCHS·%d·%d·%d"·"\n",

1435

············qemu_log("%d@%zu.%06zu:hd_geometry_lchs_guess·"·"blk·%p·LCHS·%d·%d·%d"·"\n",

1436

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

1436

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

1437

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

1437

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

1438

·····················,·blk,·cyls,·heads,·secs);

1438

·····················,·blk,·cyls,·heads,·secs);

1439

#line·1441·"trace/trace-hw_block.h"

1439

#line·1441·"trace/trace-hw_block.h"

1440

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

1440

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

1442

············qemu_log("hd_geometry_lchs_guess·"·"blk·%p·LCHS·%d·%d·%d"·"\n",·blk,·cyls,·heads,·secs);

1442

············qemu_log("hd_geometry_lchs_guess·"·"blk·%p·LCHS·%d·%d·%d"·"\n",·blk,·cyls,·heads,·secs);

1443

#line·1445·"trace/trace-hw_block.h"

1443

#line·1445·"trace/trace-hw_block.h"

1444

········}

1444

········}

1445

····}

1445

····}

1446

}

1446

}

1447

static·inline·void·trace_hd_geometry_lchs_guess(void·*·blk,·int·cyls,·int·heads,·int·secs)

1447

static·inline·void·trace_hd_geometry_lchs_guess(void·*·blk,·int·cyls,·int·heads,·int·secs)

1459

static·inline·void·_nocheck__trace_hd_geometry_guess(void·*·blk,·uint32_t·cyls,·uint32_t·heads,·uint32_t·secs,·int·trans)

1459

static·inline·void·_nocheck__trace_hd_geometry_guess(void·*·blk,·uint32_t·cyls,·uint32_t·heads,·uint32_t·secs,·int·trans)

1460

{

1460

{

1461

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

1461

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

1462

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

1462

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

1463

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

1463

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

1464

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

1464

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

1466

············qemu_log("%d@%zu.%06zu:hd_geometry_guess·"·"blk·%p·CHS·%u·%u·%u·trans·%d"·"\n",

1466

············qemu_log("%d@%zu.%06zu:hd_geometry_guess·"·"blk·%p·CHS·%u·%u·%u·trans·%d"·"\n",

1467

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

1467

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

1468

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

1468

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

1469

·····················,·blk,·cyls,·heads,·secs,·trans);

1469

·····················,·blk,·cyls,·heads,·secs,·trans);

1470

#line·1472·"trace/trace-hw_block.h"

1470

#line·1472·"trace/trace-hw_block.h"

1471

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

1471

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

1473

············qemu_log("hd_geometry_guess·"·"blk·%p·CHS·%u·%u·%u·trans·%d"·"\n",·blk,·cyls,·heads,·secs,·trans);

1473

············qemu_log("hd_geometry_guess·"·"blk·%p·CHS·%u·%u·%u·trans·%d"·"\n",·blk,·cyls,·heads,·secs,·trans);

1474

#line·1476·"trace/trace-hw_block.h"

1474

#line·1476·"trace/trace-hw_block.h"

1475

········}

1475

········}

1476

····}

1476

····}

1477

}

1477

}

1478

static·inline·void·trace_hd_geometry_guess(void·*·blk,·uint32_t·cyls,·uint32_t·heads,·uint32_t·secs,·int·trans)

1478

static·inline·void·trace_hd_geometry_guess(void·*·blk,·uint32_t·cyls,·uint32_t·heads,·uint32_t·secs,·int·trans)

1490

static·inline·void·_nocheck__trace_xen_block_realize(const·char·*·type,·uint32_t·disk,·uint32_t·partition)

1490

static·inline·void·_nocheck__trace_xen_block_realize(const·char·*·type,·uint32_t·disk,·uint32_t·partition)

1491

{

1491

{

1492

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

1492

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

1493

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

1493

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

1494

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

1494

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

1495

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

1495

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

1497

············qemu_log("%d@%zu.%06zu:xen_block_realize·"·"%s·d%up%u"·"\n",

1497

············qemu_log("%d@%zu.%06zu:xen_block_realize·"·"%s·d%up%u"·"\n",

1498

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

1498

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

1499

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

1499

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

1500

·····················,·type,·disk,·partition);

1500

·····················,·type,·disk,·partition);

1501

#line·1503·"trace/trace-hw_block.h"

1501

#line·1503·"trace/trace-hw_block.h"

1502

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

1502

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

1504

············qemu_log("xen_block_realize·"·"%s·d%up%u"·"\n",·type,·disk,·partition);

1504

············qemu_log("xen_block_realize·"·"%s·d%up%u"·"\n",·type,·disk,·partition);

1505

#line·1507·"trace/trace-hw_block.h"

1505

#line·1507·"trace/trace-hw_block.h"

1506

········}

1506

········}

1507

····}

1507

····}

1508

}

1508

}

1509

static·inline·void·trace_xen_block_realize(const·char·*·type,·uint32_t·disk,·uint32_t·partition)

1509

static·inline·void·trace_xen_block_realize(const·char·*·type,·uint32_t·disk,·uint32_t·partition)

1521

static·inline·void·_nocheck__trace_xen_block_connect(const·char·*·type,·uint32_t·disk,·uint32_t·partition)

1521

static·inline·void·_nocheck__trace_xen_block_connect(const·char·*·type,·uint32_t·disk,·uint32_t·partition)

1522

{

1522

{

1523

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

1523

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

1524

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

1524

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

1525

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

1525

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

1526

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

1526

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

1528

············qemu_log("%d@%zu.%06zu:xen_block_connect·"·"%s·d%up%u"·"\n",

1528

············qemu_log("%d@%zu.%06zu:xen_block_connect·"·"%s·d%up%u"·"\n",

1529

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

1529

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

1530

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

1530

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

1531

·····················,·type,·disk,·partition);

1531

·····················,·type,·disk,·partition);

1532

#line·1534·"trace/trace-hw_block.h"

1532

#line·1534·"trace/trace-hw_block.h"

1533

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

1533

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

1535

············qemu_log("xen_block_connect·"·"%s·d%up%u"·"\n",·type,·disk,·partition);

1535

············qemu_log("xen_block_connect·"·"%s·d%up%u"·"\n",·type,·disk,·partition);

1536

#line·1538·"trace/trace-hw_block.h"

1536

#line·1538·"trace/trace-hw_block.h"

1537

········}

1537

········}

1538

····}

1538

····}

1539

}

1539

}

1540

static·inline·void·trace_xen_block_connect(const·char·*·type,·uint32_t·disk,·uint32_t·partition)

1540

static·inline·void·trace_xen_block_connect(const·char·*·type,·uint32_t·disk,·uint32_t·partition)

1552

static·inline·void·_nocheck__trace_xen_block_disconnect(const·char·*·type,·uint32_t·disk,·uint32_t·partition)

1552

static·inline·void·_nocheck__trace_xen_block_disconnect(const·char·*·type,·uint32_t·disk,·uint32_t·partition)

1553

{

1553

{

1554

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

1554

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

1555

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

1555

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

1556

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

1556

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

1557

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

1557

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

1559

············qemu_log("%d@%zu.%06zu:xen_block_disconnect·"·"%s·d%up%u"·"\n",

1559

············qemu_log("%d@%zu.%06zu:xen_block_disconnect·"·"%s·d%up%u"·"\n",

1560

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

1560

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

1561

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

1561

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

1562

·····················,·type,·disk,·partition);

1562

·····················,·type,·disk,·partition);

1563

#line·1565·"trace/trace-hw_block.h"

1563

#line·1565·"trace/trace-hw_block.h"

1564

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

1564

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

1566

············qemu_log("xen_block_disconnect·"·"%s·d%up%u"·"\n",·type,·disk,·partition);

1566

············qemu_log("xen_block_disconnect·"·"%s·d%up%u"·"\n",·type,·disk,·partition);

1567

#line·1569·"trace/trace-hw_block.h"

1567

#line·1569·"trace/trace-hw_block.h"

1568

········}

1568

········}

1569

····}

1569

····}

1570

}

1570

}

1571

static·inline·void·trace_xen_block_disconnect(const·char·*·type,·uint32_t·disk,·uint32_t·partition)

1571

static·inline·void·trace_xen_block_disconnect(const·char·*·type,·uint32_t·disk,·uint32_t·partition)

1583

static·inline·void·_nocheck__trace_xen_block_unrealize(const·char·*·type,·uint32_t·disk,·uint32_t·partition)

1583

static·inline·void·_nocheck__trace_xen_block_unrealize(const·char·*·type,·uint32_t·disk,·uint32_t·partition)

1584

{

1584

{

1585

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

1585

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

1586

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

1586

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

1587

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

1587

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

1588

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

1588

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

1590

············qemu_log("%d@%zu.%06zu:xen_block_unrealize·"·"%s·d%up%u"·"\n",

1590

············qemu_log("%d@%zu.%06zu:xen_block_unrealize·"·"%s·d%up%u"·"\n",

1591

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

1591

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

1592

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

1592

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

1593

·····················,·type,·disk,·partition);

1593

·····················,·type,·disk,·partition);

1594

#line·1596·"trace/trace-hw_block.h"

1594

#line·1596·"trace/trace-hw_block.h"

1595

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

1595

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

1597

············qemu_log("xen_block_unrealize·"·"%s·d%up%u"·"\n",·type,·disk,·partition);

1597

············qemu_log("xen_block_unrealize·"·"%s·d%up%u"·"\n",·type,·disk,·partition);

1598

#line·1600·"trace/trace-hw_block.h"

1598

#line·1600·"trace/trace-hw_block.h"

1599

········}

1599

········}

1600

····}

1600

····}

1601

}

1601

}

1602

static·inline·void·trace_xen_block_unrealize(const·char·*·type,·uint32_t·disk,·uint32_t·partition)

1602

static·inline·void·trace_xen_block_unrealize(const·char·*·type,·uint32_t·disk,·uint32_t·partition)

1614

static·inline·void·_nocheck__trace_xen_block_size(const·char·*·type,·uint32_t·disk,·uint32_t·partition,·int64_t·sectors)

1614

static·inline·void·_nocheck__trace_xen_block_size(const·char·*·type,·uint32_t·disk,·uint32_t·partition,·int64_t·sectors)

1615

{

1615

{

1616

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

1616

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

1617

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

1617

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

1618

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

1618

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

1619

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

1619

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

1621

············qemu_log("%d@%zu.%06zu:xen_block_size·"·"%s·d%up%u·%"PRIi64·"\n",

1621

············qemu_log("%d@%zu.%06zu:xen_block_size·"·"%s·d%up%u·%"PRIi64·"\n",

1622

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

1622

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

1623

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

1623

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

1624

·····················,·type,·disk,·partition,·sectors);

1624

·····················,·type,·disk,·partition,·sectors);

1625

#line·1627·"trace/trace-hw_block.h"

1625

#line·1627·"trace/trace-hw_block.h"

1626

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

1626

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

1628

············qemu_log("xen_block_size·"·"%s·d%up%u·%"PRIi64·"\n",·type,·disk,·partition,·sectors);

1628

············qemu_log("xen_block_size·"·"%s·d%up%u·%"PRIi64·"\n",·type,·disk,·partition,·sectors);

1629

#line·1631·"trace/trace-hw_block.h"

1629

#line·1631·"trace/trace-hw_block.h"

1630

········}

1630

········}

1631

····}

1631

····}

1632

}

1632

}

1633

static·inline·void·trace_xen_block_size(const·char·*·type,·uint32_t·disk,·uint32_t·partition,·int64_t·sectors)

1633

static·inline·void·trace_xen_block_size(const·char·*·type,·uint32_t·disk,·uint32_t·partition,·int64_t·sectors)

1645

static·inline·void·_nocheck__trace_xen_disk_realize(void)

1645

static·inline·void·_nocheck__trace_xen_disk_realize(void)

1646

{

1646

{

1647

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

1647

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

1648

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

1648

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

1649

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

1649

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

1650

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

1650

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

1652

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

1652

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

1653

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

1653

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

1654

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

1654

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

1655

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

1655

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

1656

#line·1658·"trace/trace-hw_block.h"

1656

#line·1658·"trace/trace-hw_block.h"

1657

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

1657

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

1659

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

1659

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

1660

#line·1662·"trace/trace-hw_block.h"

1660

#line·1662·"trace/trace-hw_block.h"

1661

········}

1661

········}

1662

····}

1662

····}

1663

}

1663

}

1664

static·inline·void·trace_xen_disk_realize(void)

1664

static·inline·void·trace_xen_disk_realize(void)

1676

static·inline·void·_nocheck__trace_xen_disk_unrealize(void)

1676

static·inline·void·_nocheck__trace_xen_disk_unrealize(void)

1677

{

1677

{

1678

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

1678

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

1679

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

1679

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

1680

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

1680

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

1681

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

1681

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

1683

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

1683

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

1684

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

1684

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

1685

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

1685

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

1686

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

1686

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

1687

#line·1689·"trace/trace-hw_block.h"

1687

#line·1689·"trace/trace-hw_block.h"

1688

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

1688

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

1690

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

1690

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

1691

#line·1693·"trace/trace-hw_block.h"

1691

#line·1693·"trace/trace-hw_block.h"

1692

········}

1692

········}

1693

····}

1693

····}

1694

}

1694

}

1695

static·inline·void·trace_xen_disk_unrealize(void)

1695

static·inline·void·trace_xen_disk_unrealize(void)

1707

static·inline·void·_nocheck__trace_xen_cdrom_realize(void)

1707

static·inline·void·_nocheck__trace_xen_cdrom_realize(void)

1708

{

1708

{

1709

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

1709

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

1710

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

1710

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

1711

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

1711

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

1712

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

1712

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

1714

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

1714

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

1715

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

1715

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

1716

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

1716

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

1717

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

1717

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

1718

#line·1720·"trace/trace-hw_block.h"

1718

#line·1720·"trace/trace-hw_block.h"

1719

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

1719

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

1721

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

1721

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

1722

#line·1724·"trace/trace-hw_block.h"

1722

#line·1724·"trace/trace-hw_block.h"

1723

········}

1723

········}

1724

····}

1724

····}

1725

}

1725

}

1726

static·inline·void·trace_xen_cdrom_realize(void)

1726

static·inline·void·trace_xen_cdrom_realize(void)

1738

static·inline·void·_nocheck__trace_xen_cdrom_unrealize(void)

1738

static·inline·void·_nocheck__trace_xen_cdrom_unrealize(void)

1739

{

1739

{

1740

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

1740

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

1741

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

1741

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

1742

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

1742

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

1743

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

1743

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

1745

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

1745

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

1746

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

1746

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

1747

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

1747

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

1748

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

1748

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

1749

#line·1751·"trace/trace-hw_block.h"

1749

#line·1751·"trace/trace-hw_block.h"

1750

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

1750

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

1752

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

1752

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

1753

#line·1755·"trace/trace-hw_block.h"

1753

#line·1755·"trace/trace-hw_block.h"

1754

········}

1754

········}

1755

····}

1755

····}

1756

}

1756

}

1757

static·inline·void·trace_xen_cdrom_unrealize(void)

1757

static·inline·void·trace_xen_cdrom_unrealize(void)

1769

static·inline·void·_nocheck__trace_xen_block_blockdev_add(char·*·str)

1769

static·inline·void·_nocheck__trace_xen_block_blockdev_add(char·*·str)

1770

{

1770

{

1771

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

1771

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

1772

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

1772

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

1773

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

1773

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

1774

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

1774

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

1776

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

1776

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

1777

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

1777

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

1778

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1778

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1779

·····················,·str);

1779

·····················,·str);

1780

#line·1782·"trace/trace-hw_block.h"

1780

#line·1782·"trace/trace-hw_block.h"

1781

········}·else·{

1781

········}·else·{

1783

············qemu_log("xen_block_blockdev_add·"·"%s"·"\n",·str);

1783

············qemu_log("xen_block_blockdev_add·"·"%s"·"\n",·str);

1784

#line·1786·"trace/trace-hw_block.h"

1784

#line·1786·"trace/trace-hw_block.h"

1785

········}

1785

········}

1786

····}

1786

····}

1787

}

1787

}

1788

static·inline·void·trace_xen_block_blockdev_add(char·*·str)

1788

static·inline·void·trace_xen_block_blockdev_add(char·*·str)

1800

static·inline·void·_nocheck__trace_xen_block_blockdev_del(const·char·*·node_name)

1800

static·inline·void·_nocheck__trace_xen_block_blockdev_del(const·char·*·node_name)

1801

{

1801

{

1802

····if·(trace_event_get_state(TRACE_XEN_BLOCK_BLOCKDEV_DEL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1802

····if·(trace_event_get_state(TRACE_XEN_BLOCK_BLOCKDEV_DEL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1803

········if·(message_with_timestamp)·{

1803

········if·(message_with_timestamp)·{

1804

············struct·timeval·_now;

1804

············struct·timeval·_now;

1805

············gettimeofday(&_now,·NULL);

1805

············gettimeofday(&_now,·NULL);

1807

············qemu_log("%d@%zu.%06zu:xen_block_blockdev_del·"·"%s"·"\n",

1807

············qemu_log("%d@%zu.%06zu:xen_block_blockdev_del·"·"%s"·"\n",

1808

·····················qemu_get_thread_id(),

1808

·····················qemu_get_thread_id(),

1809

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1809

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1810

·····················,·node_name);

1810

·····················,·node_name);

1811

#line·1813·"trace/trace-hw_block.h"

1811

#line·1813·"trace/trace-hw_block.h"

1812

········}·else·{

1812

········}·else·{

1814

············qemu_log("xen_block_blockdev_del·"·"%s"·"\n",·node_name);

1814

············qemu_log("xen_block_blockdev_del·"·"%s"·"\n",·node_name);

1815

#line·1817·"trace/trace-hw_block.h"

1815

#line·1817·"trace/trace-hw_block.h"

1816

········}

1816

········}

1817

····}

1817

····}

1818

}

1818

}

1819

static·inline·void·trace_xen_block_blockdev_del(const·char·*·node_name)

1819

static·inline·void·trace_xen_block_blockdev_del(const·char·*·node_name)

1831

static·inline·void·_nocheck__trace_xen_block_device_create(unsigned·int·number)

1831

static·inline·void·_nocheck__trace_xen_block_device_create(unsigned·int·number)

1832

{

1832

{

1833

····if·(trace_event_get_state(TRACE_XEN_BLOCK_DEVICE_CREATE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1833

····if·(trace_event_get_state(TRACE_XEN_BLOCK_DEVICE_CREATE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1834

········if·(message_with_timestamp)·{

1834

········if·(message_with_timestamp)·{

1835

············struct·timeval·_now;

1835

············struct·timeval·_now;

1836

············gettimeofday(&_now,·NULL);

1836

············gettimeofday(&_now,·NULL);

1838

············qemu_log("%d@%zu.%06zu:xen_block_device_create·"·"%u"·"\n",

1838

············qemu_log("%d@%zu.%06zu:xen_block_device_create·"·"%u"·"\n",

1839

·····················qemu_get_thread_id(),

1839

·····················qemu_get_thread_id(),

1840

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1840

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1841

·····················,·number);

1841

·····················,·number);

1842

#line·1844·"trace/trace-hw_block.h"

1842

#line·1844·"trace/trace-hw_block.h"

1843

········}·else·{

1843

········}·else·{

1845

············qemu_log("xen_block_device_create·"·"%u"·"\n",·number);

1845

············qemu_log("xen_block_device_create·"·"%u"·"\n",·number);

1846

#line·1848·"trace/trace-hw_block.h"

1846

#line·1848·"trace/trace-hw_block.h"

1847

········}

1847

········}

1848

····}

1848

····}

1849

}

1849

}

1850

static·inline·void·trace_xen_block_device_create(unsigned·int·number)

1850

static·inline·void·trace_xen_block_device_create(unsigned·int·number)

1862

static·inline·void·_nocheck__trace_xen_block_device_destroy(unsigned·int·number)

1862

static·inline·void·_nocheck__trace_xen_block_device_destroy(unsigned·int·number)

1863

{

1863

{

1864

····if·(trace_event_get_state(TRACE_XEN_BLOCK_DEVICE_DESTROY)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1864

····if·(trace_event_get_state(TRACE_XEN_BLOCK_DEVICE_DESTROY)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1865

········if·(message_with_timestamp)·{

1865

········if·(message_with_timestamp)·{

1866

············struct·timeval·_now;

1866

············struct·timeval·_now;

1867

············gettimeofday(&_now,·NULL);

1867

············gettimeofday(&_now,·NULL);

1869

············qemu_log("%d@%zu.%06zu:xen_block_device_destroy·"·"%u"·"\n",

1869

············qemu_log("%d@%zu.%06zu:xen_block_device_destroy·"·"%u"·"\n",

1870

·····················qemu_get_thread_id(),

1870

·····················qemu_get_thread_id(),

1871

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1871

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1872

·····················,·number);

1872

·····················,·number);

1873

#line·1875·"trace/trace-hw_block.h"

1873

#line·1875·"trace/trace-hw_block.h"

1874

········}·else·{

1874

········}·else·{

1876

············qemu_log("xen_block_device_destroy·"·"%u"·"\n",·number);

1876

············qemu_log("xen_block_device_destroy·"·"%u"·"\n",·number);

1877

#line·1879·"trace/trace-hw_block.h"

1877

#line·1879·"trace/trace-hw_block.h"

1878

········}

1878

········}

1879

····}

1879

····}

1880

}

1880

}

1881

static·inline·void·trace_xen_block_device_destroy(unsigned·int·number)

1881

static·inline·void·trace_xen_block_device_destroy(unsigned·int·number)

1893

static·inline·void·_nocheck__trace_m25p80_flash_erase(void·*·s,·int·offset,·uint32_t·len)

1893

static·inline·void·_nocheck__trace_m25p80_flash_erase(void·*·s,·int·offset,·uint32_t·len)

1894

{

1894

{

1895

····if·(trace_event_get_state(TRACE_M25P80_FLASH_ERASE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1895

····if·(trace_event_get_state(TRACE_M25P80_FLASH_ERASE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1896

········if·(message_with_timestamp)·{

1896

········if·(message_with_timestamp)·{

1897

············struct·timeval·_now;

1897

············struct·timeval·_now;

1898

············gettimeofday(&_now,·NULL);

1898

············gettimeofday(&_now,·NULL);

1900

············qemu_log("%d@%zu.%06zu:m25p80_flash_erase·"·"[%p]·offset·=·0x%"PRIx32",·len·=·%u"·"\n",

1900

············qemu_log("%d@%zu.%06zu:m25p80_flash_erase·"·"[%p]·offset·=·0x%"PRIx32",·len·=·%u"·"\n",

1901

·····················qemu_get_thread_id(),

1901

·····················qemu_get_thread_id(),

1902

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1902

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1903

·····················,·s,·offset,·len);

1903

·····················,·s,·offset,·len);

1904

#line·1906·"trace/trace-hw_block.h"

1904

#line·1906·"trace/trace-hw_block.h"

1905

········}·else·{

1905

········}·else·{

1907

············qemu_log("m25p80_flash_erase·"·"[%p]·offset·=·0x%"PRIx32",·len·=·%u"·"\n",·s,·offset,·len);

1907

············qemu_log("m25p80_flash_erase·"·"[%p]·offset·=·0x%"PRIx32",·len·=·%u"·"\n",·s,·offset,·len);

1908

#line·1910·"trace/trace-hw_block.h"

1908

#line·1910·"trace/trace-hw_block.h"

1909

········}

1909

········}

1910

····}

1910

····}

1911

}

1911

}

1912

static·inline·void·trace_m25p80_flash_erase(void·*·s,·int·offset,·uint32_t·len)

1912

static·inline·void·trace_m25p80_flash_erase(void·*·s,·int·offset,·uint32_t·len)

1924

static·inline·void·_nocheck__trace_m25p80_programming_zero_to_one(void·*·s,·uint32_t·addr,·uint8_t·prev,·uint8_t·data)

1924

static·inline·void·_nocheck__trace_m25p80_programming_zero_to_one(void·*·s,·uint32_t·addr,·uint8_t·prev,·uint8_t·data)

1925

{

1925

{

1926

····if·(trace_event_get_state(TRACE_M25P80_PROGRAMMING_ZERO_TO_ONE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1926

····if·(trace_event_get_state(TRACE_M25P80_PROGRAMMING_ZERO_TO_ONE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1927

········if·(message_with_timestamp)·{

1927

········if·(message_with_timestamp)·{

1928

············struct·timeval·_now;

1928

············struct·timeval·_now;

1929

············gettimeofday(&_now,·NULL);

1929

············gettimeofday(&_now,·NULL);

1931

············qemu_log("%d@%zu.%06zu:m25p80_programming_zero_to_one·"·"[%p]·programming·zero·to·one!·addr=0x%"PRIx32"··0x%"PRIx8"·->·0x%"PRIx8·"\n",

1931

············qemu_log("%d@%zu.%06zu:m25p80_programming_zero_to_one·"·"[%p]·programming·zero·to·one!·addr=0x%"PRIx32"··0x%"PRIx8"·->·0x%"PRIx8·"\n",

1932

·····················qemu_get_thread_id(),

1932

·····················qemu_get_thread_id(),

1933

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1933

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1934

·····················,·s,·addr,·prev,·data);

1934

·····················,·s,·addr,·prev,·data);

1935

#line·1937·"trace/trace-hw_block.h"

1935

#line·1937·"trace/trace-hw_block.h"

1936

········}·else·{

1936

········}·else·{

1938

············qemu_log("m25p80_programming_zero_to_one·"·"[%p]·programming·zero·to·one!·addr=0x%"PRIx32"··0x%"PRIx8"·->·0x%"PRIx8·"\n",·s,·addr,·prev,·data);

1938

············qemu_log("m25p80_programming_zero_to_one·"·"[%p]·programming·zero·to·one!·addr=0x%"PRIx32"··0x%"PRIx8"·->·0x%"PRIx8·"\n",·s,·addr,·prev,·data);

1939

#line·1941·"trace/trace-hw_block.h"

1939

#line·1941·"trace/trace-hw_block.h"

1940

········}

1940

········}

1941

····}

1941

····}

1942

}

1942

}

1943

static·inline·void·trace_m25p80_programming_zero_to_one(void·*·s,·uint32_t·addr,·uint8_t·prev,·uint8_t·data)

1943

static·inline·void·trace_m25p80_programming_zero_to_one(void·*·s,·uint32_t·addr,·uint8_t·prev,·uint8_t·data)

1955

static·inline·void·_nocheck__trace_m25p80_reset_done(void·*·s)

1955

static·inline·void·_nocheck__trace_m25p80_reset_done(void·*·s)

1956

{

1956

{

1957

····if·(trace_event_get_state(TRACE_M25P80_RESET_DONE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1957

····if·(trace_event_get_state(TRACE_M25P80_RESET_DONE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1958

········if·(message_with_timestamp)·{

1958

········if·(message_with_timestamp)·{

1959

············struct·timeval·_now;

1959

············struct·timeval·_now;

1960

············gettimeofday(&_now,·NULL);

1960

············gettimeofday(&_now,·NULL);

1962

············qemu_log("%d@%zu.%06zu:m25p80_reset_done·"·"[%p]·Reset·done."·"\n",

1962

············qemu_log("%d@%zu.%06zu:m25p80_reset_done·"·"[%p]·Reset·done."·"\n",

1963

·····················qemu_get_thread_id(),

1963

·····················qemu_get_thread_id(),

1964

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1964

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1965

·····················,·s);

1965

·····················,·s);

1966

#line·1968·"trace/trace-hw_block.h"

1966

#line·1968·"trace/trace-hw_block.h"

1967

········}·else·{

1967

········}·else·{

1969

············qemu_log("m25p80_reset_done·"·"[%p]·Reset·done."·"\n",·s);

1969

············qemu_log("m25p80_reset_done·"·"[%p]·Reset·done."·"\n",·s);

1970

#line·1972·"trace/trace-hw_block.h"

1970

#line·1972·"trace/trace-hw_block.h"

1971

········}

1971

········}

1972

····}

1972

····}

1973

}

1973

}

1974

static·inline·void·trace_m25p80_reset_done(void·*·s)

1974

static·inline·void·trace_m25p80_reset_done(void·*·s)

1986

static·inline·void·_nocheck__trace_m25p80_command_decoded(void·*·s,·uint32_t·cmd)

1986

static·inline·void·_nocheck__trace_m25p80_command_decoded(void·*·s,·uint32_t·cmd)

1987

{

1987

{

1988

····if·(trace_event_get_state(TRACE_M25P80_COMMAND_DECODED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1988

····if·(trace_event_get_state(TRACE_M25P80_COMMAND_DECODED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1989

········if·(message_with_timestamp)·{

1989

········if·(message_with_timestamp)·{

1990

············struct·timeval·_now;

1990

············struct·timeval·_now;

1991

············gettimeofday(&_now,·NULL);

1991

············gettimeofday(&_now,·NULL);

1993

············qemu_log("%d@%zu.%06zu:m25p80_command_decoded·"·"[%p]·new·command:0x%"PRIx32·"\n",

1993

············qemu_log("%d@%zu.%06zu:m25p80_command_decoded·"·"[%p]·new·command:0x%"PRIx32·"\n",

1994

·····················qemu_get_thread_id(),

1994

·····················qemu_get_thread_id(),

1995

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1995

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1996

·····················,·s,·cmd);

1996

·····················,·s,·cmd);

1997

#line·1999·"trace/trace-hw_block.h"

1997

#line·1999·"trace/trace-hw_block.h"

1998

········}·else·{

1998

········}·else·{

2000

············qemu_log("m25p80_command_decoded·"·"[%p]·new·command:0x%"PRIx32·"\n",·s,·cmd);

2000

············qemu_log("m25p80_command_decoded·"·"[%p]·new·command:0x%"PRIx32·"\n",·s,·cmd);

2001

#line·2003·"trace/trace-hw_block.h"

2001

#line·2003·"trace/trace-hw_block.h"

2002

········}

2002

········}

2003

····}

2003

····}

2004

}

2004

}

2005

static·inline·void·trace_m25p80_command_decoded(void·*·s,·uint32_t·cmd)

2005

static·inline·void·trace_m25p80_command_decoded(void·*·s,·uint32_t·cmd)

2017

static·inline·void·_nocheck__trace_m25p80_complete_collecting(void·*·s,·uint32_t·cmd,·int·n,·uint8_t·ear,·uint32_t·cur_addr)

2017

static·inline·void·_nocheck__trace_m25p80_complete_collecting(void·*·s,·uint32_t·cmd,·int·n,·uint8_t·ear,·uint32_t·cur_addr)

2018

{

2018

{

2019

····if·(trace_event_get_state(TRACE_M25P80_COMPLETE_COLLECTING)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2019

····if·(trace_event_get_state(TRACE_M25P80_COMPLETE_COLLECTING)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2020

········if·(message_with_timestamp)·{

2020

········if·(message_with_timestamp)·{

2021

············struct·timeval·_now;

2021

············struct·timeval·_now;

2022

············gettimeofday(&_now,·NULL);

2022

············gettimeofday(&_now,·NULL);

2024

············qemu_log("%d@%zu.%06zu:m25p80_complete_collecting·"·"[%p]·decode·cmd:·0x%"PRIx32"·len·%d·ear·0x%"PRIx8"·addr·0x%"PRIx32·"\n",

2024

············qemu_log("%d@%zu.%06zu:m25p80_complete_collecting·"·"[%p]·decode·cmd:·0x%"PRIx32"·len·%d·ear·0x%"PRIx8"·addr·0x%"PRIx32·"\n",

2025

·····················qemu_get_thread_id(),

2025

·····················qemu_get_thread_id(),

2026

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2026

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2027

·····················,·s,·cmd,·n,·ear,·cur_addr);

2027

·····················,·s,·cmd,·n,·ear,·cur_addr);

2028

#line·2030·"trace/trace-hw_block.h"

2028

#line·2030·"trace/trace-hw_block.h"

2029

········}·else·{

2029

········}·else·{

2031

············qemu_log("m25p80_complete_collecting·"·"[%p]·decode·cmd:·0x%"PRIx32"·len·%d·ear·0x%"PRIx8"·addr·0x%"PRIx32·"\n",·s,·cmd,·n,·ear,·cur_addr);

2031

············qemu_log("m25p80_complete_collecting·"·"[%p]·decode·cmd:·0x%"PRIx32"·len·%d·ear·0x%"PRIx8"·addr·0x%"PRIx32·"\n",·s,·cmd,·n,·ear,·cur_addr);

2032

#line·2034·"trace/trace-hw_block.h"

2032

#line·2034·"trace/trace-hw_block.h"

2033

········}

2033

········}

2034

····}

2034

····}

2035

}

2035

}

2036

static·inline·void·trace_m25p80_complete_collecting(void·*·s,·uint32_t·cmd,·int·n,·uint8_t·ear,·uint32_t·cur_addr)

2036

static·inline·void·trace_m25p80_complete_collecting(void·*·s,·uint32_t·cmd,·int·n,·uint8_t·ear,·uint32_t·cur_addr)

2048

static·inline·void·_nocheck__trace_m25p80_populated_jedec(void·*·s)

2048

static·inline·void·_nocheck__trace_m25p80_populated_jedec(void·*·s)

2049

{

2049

{

2050

····if·(trace_event_get_state(TRACE_M25P80_POPULATED_JEDEC)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2050

····if·(trace_event_get_state(TRACE_M25P80_POPULATED_JEDEC)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2051

········if·(message_with_timestamp)·{

2051

········if·(message_with_timestamp)·{

2052

············struct·timeval·_now;

2052

············struct·timeval·_now;

2053

············gettimeofday(&_now,·NULL);

2053

············gettimeofday(&_now,·NULL);

2055

············qemu_log("%d@%zu.%06zu:m25p80_populated_jedec·"·"[%p]·populated·jedec·code"·"\n",

2055

············qemu_log("%d@%zu.%06zu:m25p80_populated_jedec·"·"[%p]·populated·jedec·code"·"\n",

2056

·····················qemu_get_thread_id(),

2056

·····················qemu_get_thread_id(),

2057

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2057

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2058

·····················,·s);

2058

·····················,·s);

2059

#line·2061·"trace/trace-hw_block.h"

2059

#line·2061·"trace/trace-hw_block.h"

2060

········}·else·{

2060

········}·else·{

2062

············qemu_log("m25p80_populated_jedec·"·"[%p]·populated·jedec·code"·"\n",·s);

2062

············qemu_log("m25p80_populated_jedec·"·"[%p]·populated·jedec·code"·"\n",·s);

2063

#line·2065·"trace/trace-hw_block.h"

2063

#line·2065·"trace/trace-hw_block.h"

2064

········}

2064

········}

2065

····}

2065

····}

2066

}

2066

}

2067

static·inline·void·trace_m25p80_populated_jedec(void·*·s)

2067

static·inline·void·trace_m25p80_populated_jedec(void·*·s)

2079

static·inline·void·_nocheck__trace_m25p80_chip_erase(void·*·s)

2079

static·inline·void·_nocheck__trace_m25p80_chip_erase(void·*·s)

2080

{

2080

{

2081

····if·(trace_event_get_state(TRACE_M25P80_CHIP_ERASE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2081

····if·(trace_event_get_state(TRACE_M25P80_CHIP_ERASE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2082

········if·(message_with_timestamp)·{

2082

········if·(message_with_timestamp)·{

2083

············struct·timeval·_now;

2083

············struct·timeval·_now;

2084

············gettimeofday(&_now,·NULL);

2084

············gettimeofday(&_now,·NULL);

2086

············qemu_log("%d@%zu.%06zu:m25p80_chip_erase·"·"[%p]·chip·erase"·"\n",

2086

············qemu_log("%d@%zu.%06zu:m25p80_chip_erase·"·"[%p]·chip·erase"·"\n",

2087

·····················qemu_get_thread_id(),

2087

·····················qemu_get_thread_id(),

2088

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2088

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2089

·····················,·s);

2089

·····················,·s);

2090

#line·2092·"trace/trace-hw_block.h"

2090

#line·2092·"trace/trace-hw_block.h"

2091

········}·else·{

2091

········}·else·{

2093

············qemu_log("m25p80_chip_erase·"·"[%p]·chip·erase"·"\n",·s);

2093

············qemu_log("m25p80_chip_erase·"·"[%p]·chip·erase"·"\n",·s);

2094

#line·2096·"trace/trace-hw_block.h"

2094

#line·2096·"trace/trace-hw_block.h"

2095

········}

2095

········}

2096

····}

2096

····}

2097

}

2097

}

2098

static·inline·void·trace_m25p80_chip_erase(void·*·s)

2098

static·inline·void·trace_m25p80_chip_erase(void·*·s)

2110

static·inline·void·_nocheck__trace_m25p80_select(void·*·s,·const·char·*·what)

2110

static·inline·void·_nocheck__trace_m25p80_select(void·*·s,·const·char·*·what)

2111

{

2111

{

2112

····if·(trace_event_get_state(TRACE_M25P80_SELECT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2112

····if·(trace_event_get_state(TRACE_M25P80_SELECT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2113

········if·(message_with_timestamp)·{

2113

········if·(message_with_timestamp)·{

2114

············struct·timeval·_now;

2114

············struct·timeval·_now;

2115

············gettimeofday(&_now,·NULL);

2115

············gettimeofday(&_now,·NULL);

2117

············qemu_log("%d@%zu.%06zu:m25p80_select·"·"[%p]·%sselect"·"\n",

2117

············qemu_log("%d@%zu.%06zu:m25p80_select·"·"[%p]·%sselect"·"\n",

2118

·····················qemu_get_thread_id(),

2118

·····················qemu_get_thread_id(),

2119

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2119

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2120

·····················,·s,·what);

2120

·····················,·s,·what);

2121

#line·2123·"trace/trace-hw_block.h"

2121

#line·2123·"trace/trace-hw_block.h"

2122

········}·else·{

2122

········}·else·{

2124

············qemu_log("m25p80_select·"·"[%p]·%sselect"·"\n",·s,·what);

2124

············qemu_log("m25p80_select·"·"[%p]·%sselect"·"\n",·s,·what);

2125

#line·2127·"trace/trace-hw_block.h"

2125

#line·2127·"trace/trace-hw_block.h"

2126

········}

2126

········}

2127

····}

2127

····}

2128

}

2128

}

2129

static·inline·void·trace_m25p80_select(void·*·s,·const·char·*·what)

2129

static·inline·void·trace_m25p80_select(void·*·s,·const·char·*·what)

2141

static·inline·void·_nocheck__trace_m25p80_page_program(void·*·s,·uint32_t·addr,·uint8_t·tx)

2141

static·inline·void·_nocheck__trace_m25p80_page_program(void·*·s,·uint32_t·addr,·uint8_t·tx)

2142

{

2142

{

2143

····if·(trace_event_get_state(TRACE_M25P80_PAGE_PROGRAM)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2143

····if·(trace_event_get_state(TRACE_M25P80_PAGE_PROGRAM)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2144

········if·(message_with_timestamp)·{

2144

········if·(message_with_timestamp)·{

2145

············struct·timeval·_now;

2145

············struct·timeval·_now;

2146

············gettimeofday(&_now,·NULL);

2146

············gettimeofday(&_now,·NULL);

2148

············qemu_log("%d@%zu.%06zu:m25p80_page_program·"·"[%p]·page·program·cur_addr=0x%"PRIx32"·data=0x%"PRIx8·"\n",

2148

············qemu_log("%d@%zu.%06zu:m25p80_page_program·"·"[%p]·page·program·cur_addr=0x%"PRIx32"·data=0x%"PRIx8·"\n",

2149

·····················qemu_get_thread_id(),

2149

·····················qemu_get_thread_id(),

2150

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2150

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2151

·····················,·s,·addr,·tx);

2151

·····················,·s,·addr,·tx);

2152

#line·2154·"trace/trace-hw_block.h"

2152

#line·2154·"trace/trace-hw_block.h"

2153

········}·else·{

2153

········}·else·{

2155

············qemu_log("m25p80_page_program·"·"[%p]·page·program·cur_addr=0x%"PRIx32"·data=0x%"PRIx8·"\n",·s,·addr,·tx);

2155

············qemu_log("m25p80_page_program·"·"[%p]·page·program·cur_addr=0x%"PRIx32"·data=0x%"PRIx8·"\n",·s,·addr,·tx);

2156

#line·2158·"trace/trace-hw_block.h"

2156

#line·2158·"trace/trace-hw_block.h"

2157

········}

2157

········}

2158

····}

2158

····}

2159

}

2159

}

2160

static·inline·void·trace_m25p80_page_program(void·*·s,·uint32_t·addr,·uint8_t·tx)

2160

static·inline·void·trace_m25p80_page_program(void·*·s,·uint32_t·addr,·uint8_t·tx)

2172

static·inline·void·_nocheck__trace_m25p80_transfer(void·*·s,·uint8_t·state,·uint32_t·len,·uint8_t·needed,·uint32_t·pos,·uint32_t·cur_addr,·uint8_t·t)

2172

static·inline·void·_nocheck__trace_m25p80_transfer(void·*·s,·uint8_t·state,·uint32_t·len,·uint8_t·needed,·uint32_t·pos,·uint32_t·cur_addr,·uint8_t·t)

2173

{

2173

{

2174

····if·(trace_event_get_state(TRACE_M25P80_TRANSFER)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2174

····if·(trace_event_get_state(TRACE_M25P80_TRANSFER)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2175

········if·(message_with_timestamp)·{

2175

········if·(message_with_timestamp)·{

2176

············struct·timeval·_now;

2176

············struct·timeval·_now;

2177

············gettimeofday(&_now,·NULL);

2177

············gettimeofday(&_now,·NULL);

2179

············qemu_log("%d@%zu.%06zu:m25p80_transfer·"·"[%p]·Transfer·state·0x%"PRIx8"·len·0x%"PRIx32"·needed·0x%"PRIx8"·pos·0x%"PRIx32"·addr·0x%"PRIx32"·tx·0x%"PRIx8·"\n",

2179

············qemu_log("%d@%zu.%06zu:m25p80_transfer·"·"[%p]·Transfer·state·0x%"PRIx8"·len·0x%"PRIx32"·needed·0x%"PRIx8"·pos·0x%"PRIx32"·addr·0x%"PRIx32"·tx·0x%"PRIx8·"\n",

2180

·····················qemu_get_thread_id(),

2180

·····················qemu_get_thread_id(),

2181

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2181

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2182

·····················,·s,·state,·len,·needed,·pos,·cur_addr,·t);

2182

·····················,·s,·state,·len,·needed,·pos,·cur_addr,·t);

2183

#line·2185·"trace/trace-hw_block.h"

2183

#line·2185·"trace/trace-hw_block.h"

2184

········}·else·{

2184

········}·else·{

2186

············qemu_log("m25p80_transfer·"·"[%p]·Transfer·state·0x%"PRIx8"·len·0x%"PRIx32"·needed·0x%"PRIx8"·pos·0x%"PRIx32"·addr·0x%"PRIx32"·tx·0x%"PRIx8·"\n",·s,·state,·len,·needed,·pos,·cur_addr,·t);

2186

············qemu_log("m25p80_transfer·"·"[%p]·Transfer·state·0x%"PRIx8"·len·0x%"PRIx32"·needed·0x%"PRIx8"·pos·0x%"PRIx32"·addr·0x%"PRIx32"·tx·0x%"PRIx8·"\n",·s,·state,·len,·needed,·pos,·cur_addr,·t);

2187

#line·2189·"trace/trace-hw_block.h"

2187

#line·2189·"trace/trace-hw_block.h"

2188

········}

2188

········}

2189

····}

2189

····}

2190

}

2190

}

2191

static·inline·void·trace_m25p80_transfer(void·*·s,·uint8_t·state,·uint32_t·len,·uint8_t·needed,·uint32_t·pos,·uint32_t·cur_addr,·uint8_t·t)

2191

static·inline·void·trace_m25p80_transfer(void·*·s,·uint8_t·state,·uint32_t·len,·uint8_t·needed,·uint32_t·pos,·uint32_t·cur_addr,·uint8_t·t)

2203

static·inline·void·_nocheck__trace_m25p80_read_byte(void·*·s,·uint32_t·addr,·uint8_t·v)

2203

static·inline·void·_nocheck__trace_m25p80_read_byte(void·*·s,·uint32_t·addr,·uint8_t·v)

2204

{

2204

{

2205

····if·(trace_event_get_state(TRACE_M25P80_READ_BYTE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2205

····if·(trace_event_get_state(TRACE_M25P80_READ_BYTE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2206

········if·(message_with_timestamp)·{

2206

········if·(message_with_timestamp)·{

2207

············struct·timeval·_now;

2207

············struct·timeval·_now;

2208

············gettimeofday(&_now,·NULL);

2208

············gettimeofday(&_now,·NULL);

2210

············qemu_log("%d@%zu.%06zu:m25p80_read_byte·"·"[%p]·Read·byte·0x%"PRIx32"=0x%"PRIx8·"\n",

2210

············qemu_log("%d@%zu.%06zu:m25p80_read_byte·"·"[%p]·Read·byte·0x%"PRIx32"=0x%"PRIx8·"\n",

2211

·····················qemu_get_thread_id(),

2211

·····················qemu_get_thread_id(),

2212

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2212

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2213

·····················,·s,·addr,·v);

2213

·····················,·s,·addr,·v);

2214

#line·2216·"trace/trace-hw_block.h"

2214

#line·2216·"trace/trace-hw_block.h"

2215

········}·else·{

2215

········}·else·{

2217

············qemu_log("m25p80_read_byte·"·"[%p]·Read·byte·0x%"PRIx32"=0x%"PRIx8·"\n",·s,·addr,·v);

2217

············qemu_log("m25p80_read_byte·"·"[%p]·Read·byte·0x%"PRIx32"=0x%"PRIx8·"\n",·s,·addr,·v);

2218

#line·2220·"trace/trace-hw_block.h"

2218

#line·2220·"trace/trace-hw_block.h"

2219

········}

2219

········}

2220

····}

2220

····}

2221

}

2221

}

2222

static·inline·void·trace_m25p80_read_byte(void·*·s,·uint32_t·addr,·uint8_t·v)

2222

static·inline·void·trace_m25p80_read_byte(void·*·s,·uint32_t·addr,·uint8_t·v)

2234

static·inline·void·_nocheck__trace_m25p80_read_data(void·*·s,·uint32_t·pos,·uint8_t·v)

2234

static·inline·void·_nocheck__trace_m25p80_read_data(void·*·s,·uint32_t·pos,·uint8_t·v)

2235

{

2235

{

2236

····if·(trace_event_get_state(TRACE_M25P80_READ_DATA)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2236

····if·(trace_event_get_state(TRACE_M25P80_READ_DATA)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2237

········if·(message_with_timestamp)·{

2237

········if·(message_with_timestamp)·{

2238

············struct·timeval·_now;

2238

············struct·timeval·_now;

2239

············gettimeofday(&_now,·NULL);

2239

············gettimeofday(&_now,·NULL);

2241

············qemu_log("%d@%zu.%06zu:m25p80_read_data·"·"[%p]·Read·data·0x%"PRIx32"=0x%"PRIx8·"\n",

2241

············qemu_log("%d@%zu.%06zu:m25p80_read_data·"·"[%p]·Read·data·0x%"PRIx32"=0x%"PRIx8·"\n",

2242

·····················qemu_get_thread_id(),

2242

·····················qemu_get_thread_id(),

2243

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2243

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2244

·····················,·s,·pos,·v);

2244

·····················,·s,·pos,·v);

2245

#line·2247·"trace/trace-hw_block.h"

2245

#line·2247·"trace/trace-hw_block.h"

2246

········}·else·{

2246

········}·else·{

2248

············qemu_log("m25p80_read_data·"·"[%p]·Read·data·0x%"PRIx32"=0x%"PRIx8·"\n",·s,·pos,·v);

2248

············qemu_log("m25p80_read_data·"·"[%p]·Read·data·0x%"PRIx32"=0x%"PRIx8·"\n",·s,·pos,·v);

2249

#line·2251·"trace/trace-hw_block.h"

2249

#line·2251·"trace/trace-hw_block.h"

2250

········}

2250

········}

2251

····}

2251

····}

2252

}

2252

}

2253

static·inline·void·trace_m25p80_read_data(void·*·s,·uint32_t·pos,·uint8_t·v)

2253

static·inline·void·trace_m25p80_read_data(void·*·s,·uint32_t·pos,·uint8_t·v)

2265

static·inline·void·_nocheck__trace_m25p80_binding(void·*·s)

2265

static·inline·void·_nocheck__trace_m25p80_binding(void·*·s)

2266

{

2266

{

2267

····if·(trace_event_get_state(TRACE_M25P80_BINDING)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2267

····if·(trace_event_get_state(TRACE_M25P80_BINDING)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2268

········if·(message_with_timestamp)·{

2268

········if·(message_with_timestamp)·{

2269

············struct·timeval·_now;

2269

············struct·timeval·_now;

2270

············gettimeofday(&_now,·NULL);

2270

············gettimeofday(&_now,·NULL);

2272

············qemu_log("%d@%zu.%06zu:m25p80_binding·"·"[%p]·Binding·to·IF_MTD·drive"·"\n",

2272

············qemu_log("%d@%zu.%06zu:m25p80_binding·"·"[%p]·Binding·to·IF_MTD·drive"·"\n",

2273

·····················qemu_get_thread_id(),

2273

·····················qemu_get_thread_id(),

2274

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2274

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2275

·····················,·s);

2275

·····················,·s);

2276

#line·2278·"trace/trace-hw_block.h"

2276

#line·2278·"trace/trace-hw_block.h"

2277

········}·else·{

2277

········}·else·{

2279

············qemu_log("m25p80_binding·"·"[%p]·Binding·to·IF_MTD·drive"·"\n",·s);

2279

············qemu_log("m25p80_binding·"·"[%p]·Binding·to·IF_MTD·drive"·"\n",·s);

2280

#line·2282·"trace/trace-hw_block.h"

2280

#line·2282·"trace/trace-hw_block.h"

2281

········}

2281

········}

2282

····}

2282

····}

2283

}

2283

}

2284

static·inline·void·trace_m25p80_binding(void·*·s)

2284

static·inline·void·trace_m25p80_binding(void·*·s)

2296

static·inline·void·_nocheck__trace_m25p80_binding_no_bdrv(void·*·s)

2296

static·inline·void·_nocheck__trace_m25p80_binding_no_bdrv(void·*·s)

2297

{

2297

{

2298

····if·(trace_event_get_state(TRACE_M25P80_BINDING_NO_BDRV)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2298

····if·(trace_event_get_state(TRACE_M25P80_BINDING_NO_BDRV)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2299

········if·(message_with_timestamp)·{

2299

········if·(message_with_timestamp)·{

2300

············struct·timeval·_now;

2300

············struct·timeval·_now;

2301

············gettimeofday(&_now,·NULL);

2301

············gettimeofday(&_now,·NULL);

2303

············qemu_log("%d@%zu.%06zu:m25p80_binding_no_bdrv·"·"[%p]·No·BDRV·-·binding·to·RAM"·"\n",

2303

············qemu_log("%d@%zu.%06zu:m25p80_binding_no_bdrv·"·"[%p]·No·BDRV·-·binding·to·RAM"·"\n",

2304

·····················qemu_get_thread_id(),

2304

·····················qemu_get_thread_id(),

2305

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2305

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2306

·····················,·s);

2306

·····················,·s);

2307

#line·2309·"trace/trace-hw_block.h"

2307

#line·2309·"trace/trace-hw_block.h"

2308

········}·else·{

2308

········}·else·{

2310

············qemu_log("m25p80_binding_no_bdrv·"·"[%p]·No·BDRV·-·binding·to·RAM"·"\n",·s);

2310

············qemu_log("m25p80_binding_no_bdrv·"·"[%p]·No·BDRV·-·binding·to·RAM"·"\n",·s);

2311

#line·2313·"trace/trace-hw_block.h"

2311

#line·2313·"trace/trace-hw_block.h"

2312

········}

2312

········}

2313

····}

2313

····}

2314

}

2314

}

2315

static·inline·void·trace_m25p80_binding_no_bdrv(void·*·s)

2315

static·inline·void·trace_m25p80_binding_no_bdrv(void·*·s)