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

234

static·inline·void·_nocheck__trace_run_poll_handlers_begin(void·*·ctx,·int64_t·max_ns,·int64_t·timeout)

234

static·inline·void·_nocheck__trace_run_poll_handlers_begin(void·*·ctx,·int64_t·max_ns,·int64_t·timeout)

235

{

235

{

236

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

236

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

237

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

237

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

238

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

238

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

239

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

239

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

241

············qemu_log("%d@%zu.%06zu:run_poll_handlers_begin·"·"ctx·%p·max_ns·%"PRId64·"·timeout·%"PRId64·"\n",

241

············qemu_log("%d@%zu.%06zu:run_poll_handlers_begin·"·"ctx·%p·max_ns·%"PRId64·"·timeout·%"PRId64·"\n",

242

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

242

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

243

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

243

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

244

·····················,·ctx,·max_ns,·timeout);

244

·····················,·ctx,·max_ns,·timeout);

245

#line·247·"trace/trace-util.h"

245

#line·247·"trace/trace-util.h"

246

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

246

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

248

············qemu_log("run_poll_handlers_begin·"·"ctx·%p·max_ns·%"PRId64·"·timeout·%"PRId64·"\n",·ctx,·max_ns,·timeout);

248

············qemu_log("run_poll_handlers_begin·"·"ctx·%p·max_ns·%"PRId64·"·timeout·%"PRId64·"\n",·ctx,·max_ns,·timeout);

249

#line·251·"trace/trace-util.h"

249

#line·251·"trace/trace-util.h"

250

········}

250

········}

251

····}

251

····}

252

}

252

}

253

static·inline·void·trace_run_poll_handlers_begin(void·*·ctx,·int64_t·max_ns,·int64_t·timeout)

253

static·inline·void·trace_run_poll_handlers_begin(void·*·ctx,·int64_t·max_ns,·int64_t·timeout)

265

static·inline·void·_nocheck__trace_run_poll_handlers_end(void·*·ctx,·bool·progress,·int64_t·timeout)

265

static·inline·void·_nocheck__trace_run_poll_handlers_end(void·*·ctx,·bool·progress,·int64_t·timeout)

266

{

266

{

267

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

267

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

268

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

268

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

269

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

269

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

270

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

270

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

272

············qemu_log("%d@%zu.%06zu:run_poll_handlers_end·"·"ctx·%p·progress·%d·new·timeout·%"PRId64·"\n",

272

············qemu_log("%d@%zu.%06zu:run_poll_handlers_end·"·"ctx·%p·progress·%d·new·timeout·%"PRId64·"\n",

273

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

273

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

274

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

274

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

275

·····················,·ctx,·progress,·timeout);

275

·····················,·ctx,·progress,·timeout);

276

#line·278·"trace/trace-util.h"

276

#line·278·"trace/trace-util.h"

277

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

277

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

279

············qemu_log("run_poll_handlers_end·"·"ctx·%p·progress·%d·new·timeout·%"PRId64·"\n",·ctx,·progress,·timeout);

279

············qemu_log("run_poll_handlers_end·"·"ctx·%p·progress·%d·new·timeout·%"PRId64·"\n",·ctx,·progress,·timeout);

280

#line·282·"trace/trace-util.h"

280

#line·282·"trace/trace-util.h"

281

········}

281

········}

282

····}

282

····}

283

}

283

}

284

static·inline·void·trace_run_poll_handlers_end(void·*·ctx,·bool·progress,·int64_t·timeout)

284

static·inline·void·trace_run_poll_handlers_end(void·*·ctx,·bool·progress,·int64_t·timeout)

296

static·inline·void·_nocheck__trace_poll_shrink(void·*·ctx,·int64_t·old,·int64_t·new)

296

static·inline·void·_nocheck__trace_poll_shrink(void·*·ctx,·int64_t·old,·int64_t·new)

297

{

297

{

298

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

298

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

299

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

299

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

300

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

300

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

301

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

301

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

303

············qemu_log("%d@%zu.%06zu:poll_shrink·"·"ctx·%p·old·%"PRId64"·new·%"PRId64·"\n",

303

············qemu_log("%d@%zu.%06zu:poll_shrink·"·"ctx·%p·old·%"PRId64"·new·%"PRId64·"\n",

304

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

304

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

305

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

305

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

306

·····················,·ctx,·old,·new);

306

·····················,·ctx,·old,·new);

307

#line·309·"trace/trace-util.h"

307

#line·309·"trace/trace-util.h"

308

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

308

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

310

············qemu_log("poll_shrink·"·"ctx·%p·old·%"PRId64"·new·%"PRId64·"\n",·ctx,·old,·new);

310

············qemu_log("poll_shrink·"·"ctx·%p·old·%"PRId64"·new·%"PRId64·"\n",·ctx,·old,·new);

311

#line·313·"trace/trace-util.h"

311

#line·313·"trace/trace-util.h"

312

········}

312

········}

313

····}

313

····}

314

}

314

}

315

static·inline·void·trace_poll_shrink(void·*·ctx,·int64_t·old,·int64_t·new)

315

static·inline·void·trace_poll_shrink(void·*·ctx,·int64_t·old,·int64_t·new)

327

static·inline·void·_nocheck__trace_poll_grow(void·*·ctx,·int64_t·old,·int64_t·new)

327

static·inline·void·_nocheck__trace_poll_grow(void·*·ctx,·int64_t·old,·int64_t·new)

328

{

328

{

329

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

329

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

330

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

330

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

331

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

331

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

332

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

332

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

334

············qemu_log("%d@%zu.%06zu:poll_grow·"·"ctx·%p·old·%"PRId64"·new·%"PRId64·"\n",

334

············qemu_log("%d@%zu.%06zu:poll_grow·"·"ctx·%p·old·%"PRId64"·new·%"PRId64·"\n",

335

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

335

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

336

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

336

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

337

·····················,·ctx,·old,·new);

337

·····················,·ctx,·old,·new);

338

#line·340·"trace/trace-util.h"

338

#line·340·"trace/trace-util.h"

339

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

339

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

341

············qemu_log("poll_grow·"·"ctx·%p·old·%"PRId64"·new·%"PRId64·"\n",·ctx,·old,·new);

341

············qemu_log("poll_grow·"·"ctx·%p·old·%"PRId64"·new·%"PRId64·"\n",·ctx,·old,·new);

342

#line·344·"trace/trace-util.h"

342

#line·344·"trace/trace-util.h"

343

········}

343

········}

344

····}

344

····}

345

}

345

}

346

static·inline·void·trace_poll_grow(void·*·ctx,·int64_t·old,·int64_t·new)

346

static·inline·void·trace_poll_grow(void·*·ctx,·int64_t·old,·int64_t·new)

358

static·inline·void·_nocheck__trace_poll_add(void·*·ctx,·void·*·node,·int·fd,·unsigned·revents)

358

static·inline·void·_nocheck__trace_poll_add(void·*·ctx,·void·*·node,·int·fd,·unsigned·revents)

359

{

359

{

360

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

360

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

361

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

361

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

362

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

362

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

363

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

363

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

365

············qemu_log("%d@%zu.%06zu:poll_add·"·"ctx·%p·node·%p·fd·%d·revents·0x%x"·"\n",

365

············qemu_log("%d@%zu.%06zu:poll_add·"·"ctx·%p·node·%p·fd·%d·revents·0x%x"·"\n",

366

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

366

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

367

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

367

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

368

·····················,·ctx,·node,·fd,·revents);

368

·····················,·ctx,·node,·fd,·revents);

369

#line·371·"trace/trace-util.h"

369

#line·371·"trace/trace-util.h"

370

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

370

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

372

············qemu_log("poll_add·"·"ctx·%p·node·%p·fd·%d·revents·0x%x"·"\n",·ctx,·node,·fd,·revents);

372

············qemu_log("poll_add·"·"ctx·%p·node·%p·fd·%d·revents·0x%x"·"\n",·ctx,·node,·fd,·revents);

373

#line·375·"trace/trace-util.h"

373

#line·375·"trace/trace-util.h"

374

········}

374

········}

375

····}

375

····}

376

}

376

}

377

static·inline·void·trace_poll_add(void·*·ctx,·void·*·node,·int·fd,·unsigned·revents)

377

static·inline·void·trace_poll_add(void·*·ctx,·void·*·node,·int·fd,·unsigned·revents)

389

static·inline·void·_nocheck__trace_poll_remove(void·*·ctx,·void·*·node,·int·fd)

389

static·inline·void·_nocheck__trace_poll_remove(void·*·ctx,·void·*·node,·int·fd)

390

{

390

{

391

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

391

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

392

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

392

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

393

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

393

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

394

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

394

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

396

············qemu_log("%d@%zu.%06zu:poll_remove·"·"ctx·%p·node·%p·fd·%d"·"\n",

396

············qemu_log("%d@%zu.%06zu:poll_remove·"·"ctx·%p·node·%p·fd·%d"·"\n",

397

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

397

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

398

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

398

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

399

·····················,·ctx,·node,·fd);

399

·····················,·ctx,·node,·fd);

400

#line·402·"trace/trace-util.h"

400

#line·402·"trace/trace-util.h"

401

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

401

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

403

············qemu_log("poll_remove·"·"ctx·%p·node·%p·fd·%d"·"\n",·ctx,·node,·fd);

403

············qemu_log("poll_remove·"·"ctx·%p·node·%p·fd·%d"·"\n",·ctx,·node,·fd);

404

#line·406·"trace/trace-util.h"

404

#line·406·"trace/trace-util.h"

405

········}

405

········}

406

····}

406

····}

407

}

407

}

408

static·inline·void·trace_poll_remove(void·*·ctx,·void·*·node,·int·fd)

408

static·inline·void·trace_poll_remove(void·*·ctx,·void·*·node,·int·fd)

420

static·inline·void·_nocheck__trace_aio_co_schedule(void·*·ctx,·void·*·co)

420

static·inline·void·_nocheck__trace_aio_co_schedule(void·*·ctx,·void·*·co)

421

{

421

{

422

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

422

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

423

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

423

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

424

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

424

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

425

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

425

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

427

············qemu_log("%d@%zu.%06zu:aio_co_schedule·"·"ctx·%p·co·%p"·"\n",

427

············qemu_log("%d@%zu.%06zu:aio_co_schedule·"·"ctx·%p·co·%p"·"\n",

428

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

428

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

429

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

429

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

430

·····················,·ctx,·co);

430

·····················,·ctx,·co);

431

#line·433·"trace/trace-util.h"

431

#line·433·"trace/trace-util.h"

432

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

432

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

434

············qemu_log("aio_co_schedule·"·"ctx·%p·co·%p"·"\n",·ctx,·co);

434

············qemu_log("aio_co_schedule·"·"ctx·%p·co·%p"·"\n",·ctx,·co);

435

#line·437·"trace/trace-util.h"

435

#line·437·"trace/trace-util.h"

436

········}

436

········}

437

····}

437

····}

438

}

438

}

439

static·inline·void·trace_aio_co_schedule(void·*·ctx,·void·*·co)

439

static·inline·void·trace_aio_co_schedule(void·*·ctx,·void·*·co)

451

static·inline·void·_nocheck__trace_aio_co_schedule_bh_cb(void·*·ctx,·void·*·co)

451

static·inline·void·_nocheck__trace_aio_co_schedule_bh_cb(void·*·ctx,·void·*·co)

452

{

452

{

453

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

453

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

454

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

454

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

455

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

455

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

456

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

456

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

458

············qemu_log("%d@%zu.%06zu:aio_co_schedule_bh_cb·"·"ctx·%p·co·%p"·"\n",

458

············qemu_log("%d@%zu.%06zu:aio_co_schedule_bh_cb·"·"ctx·%p·co·%p"·"\n",

459

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

459

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

460

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

460

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

461

·····················,·ctx,·co);

461

·····················,·ctx,·co);

462

#line·464·"trace/trace-util.h"

462

#line·464·"trace/trace-util.h"

463

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

463

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

465

············qemu_log("aio_co_schedule_bh_cb·"·"ctx·%p·co·%p"·"\n",·ctx,·co);

465

············qemu_log("aio_co_schedule_bh_cb·"·"ctx·%p·co·%p"·"\n",·ctx,·co);

466

#line·468·"trace/trace-util.h"

466

#line·468·"trace/trace-util.h"

467

········}

467

········}

468

····}

468

····}

469

}

469

}

470

static·inline·void·trace_aio_co_schedule_bh_cb(void·*·ctx,·void·*·co)

470

static·inline·void·trace_aio_co_schedule_bh_cb(void·*·ctx,·void·*·co)

482

static·inline·void·_nocheck__trace_reentrant_aio(void·*·ctx,·const·char·*·name)

482

static·inline·void·_nocheck__trace_reentrant_aio(void·*·ctx,·const·char·*·name)

483

{

483

{

484

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

484

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

485

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

485

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

486

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

486

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

487

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

487

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

489

············qemu_log("%d@%zu.%06zu:reentrant_aio·"·"ctx·%p·name·%s"·"\n",

489

············qemu_log("%d@%zu.%06zu:reentrant_aio·"·"ctx·%p·name·%s"·"\n",

490

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

490

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

491

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

491

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

492

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

492

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

493

#line·495·"trace/trace-util.h"

493

#line·495·"trace/trace-util.h"

494

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

494

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

496

············qemu_log("reentrant_aio·"·"ctx·%p·name·%s"·"\n",·ctx,·name);

496

············qemu_log("reentrant_aio·"·"ctx·%p·name·%s"·"\n",·ctx,·name);

497

#line·499·"trace/trace-util.h"

497

#line·499·"trace/trace-util.h"

498

········}

498

········}

499

····}

499

····}

500

}

500

}

501

static·inline·void·trace_reentrant_aio(void·*·ctx,·const·char·*·name)

501

static·inline·void·trace_reentrant_aio(void·*·ctx,·const·char·*·name)

513

static·inline·void·_nocheck__trace_thread_pool_submit(void·*·pool,·void·*·req,·void·*·opaque)

513

static·inline·void·_nocheck__trace_thread_pool_submit(void·*·pool,·void·*·req,·void·*·opaque)

514

{

514

{

515

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

515

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

516

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

516

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

517

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

517

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

518

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

518

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

520

············qemu_log("%d@%zu.%06zu:thread_pool_submit·"·"pool·%p·req·%p·opaque·%p"·"\n",

520

············qemu_log("%d@%zu.%06zu:thread_pool_submit·"·"pool·%p·req·%p·opaque·%p"·"\n",

521

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

521

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

522

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

522

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

523

·····················,·pool,·req,·opaque);

523

·····················,·pool,·req,·opaque);

524

#line·526·"trace/trace-util.h"

524

#line·526·"trace/trace-util.h"

525

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

525

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

527

············qemu_log("thread_pool_submit·"·"pool·%p·req·%p·opaque·%p"·"\n",·pool,·req,·opaque);

527

············qemu_log("thread_pool_submit·"·"pool·%p·req·%p·opaque·%p"·"\n",·pool,·req,·opaque);

528

#line·530·"trace/trace-util.h"

528

#line·530·"trace/trace-util.h"

529

········}

529

········}

530

····}

530

····}

531

}

531

}

532

static·inline·void·trace_thread_pool_submit(void·*·pool,·void·*·req,·void·*·opaque)

532

static·inline·void·trace_thread_pool_submit(void·*·pool,·void·*·req,·void·*·opaque)

544

static·inline·void·_nocheck__trace_thread_pool_complete(void·*·pool,·void·*·req,·void·*·opaque,·int·ret)

544

static·inline·void·_nocheck__trace_thread_pool_complete(void·*·pool,·void·*·req,·void·*·opaque,·int·ret)

545

{

545

{

546

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

546

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

547

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

547

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

548

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

548

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

549

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

549

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

551

············qemu_log("%d@%zu.%06zu:thread_pool_complete·"·"pool·%p·req·%p·opaque·%p·ret·%d"·"\n",

551

············qemu_log("%d@%zu.%06zu:thread_pool_complete·"·"pool·%p·req·%p·opaque·%p·ret·%d"·"\n",

552

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

552

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

553

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

553

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

554

·····················,·pool,·req,·opaque,·ret);

554

·····················,·pool,·req,·opaque,·ret);

555

#line·557·"trace/trace-util.h"

555

#line·557·"trace/trace-util.h"

556

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

556

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

558

············qemu_log("thread_pool_complete·"·"pool·%p·req·%p·opaque·%p·ret·%d"·"\n",·pool,·req,·opaque,·ret);

558

············qemu_log("thread_pool_complete·"·"pool·%p·req·%p·opaque·%p·ret·%d"·"\n",·pool,·req,·opaque,·ret);

559

#line·561·"trace/trace-util.h"

559

#line·561·"trace/trace-util.h"

560

········}

560

········}

561

····}

561

····}

562

}

562

}

563

static·inline·void·trace_thread_pool_complete(void·*·pool,·void·*·req,·void·*·opaque,·int·ret)

563

static·inline·void·trace_thread_pool_complete(void·*·pool,·void·*·req,·void·*·opaque,·int·ret)

575

static·inline·void·_nocheck__trace_thread_pool_cancel(void·*·req,·void·*·opaque)

575

static·inline·void·_nocheck__trace_thread_pool_cancel(void·*·req,·void·*·opaque)

576

{

576

{

577

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

577

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

578

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

578

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

579

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

579

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

580

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

580

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

582

············qemu_log("%d@%zu.%06zu:thread_pool_cancel·"·"req·%p·opaque·%p"·"\n",

582

············qemu_log("%d@%zu.%06zu:thread_pool_cancel·"·"req·%p·opaque·%p"·"\n",

583

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

583

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

584

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

584

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

585

·····················,·req,·opaque);

585

·····················,·req,·opaque);

586

#line·588·"trace/trace-util.h"

586

#line·588·"trace/trace-util.h"

587

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

587

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

589

············qemu_log("thread_pool_cancel·"·"req·%p·opaque·%p"·"\n",·req,·opaque);

589

············qemu_log("thread_pool_cancel·"·"req·%p·opaque·%p"·"\n",·req,·opaque);

590

#line·592·"trace/trace-util.h"

590

#line·592·"trace/trace-util.h"

591

········}

591

········}

592

····}

592

····}

593

}

593

}

594

static·inline·void·trace_thread_pool_cancel(void·*·req,·void·*·opaque)

594

static·inline·void·trace_thread_pool_cancel(void·*·req,·void·*·opaque)

606

static·inline·void·_nocheck__trace_buffer_resize(const·char·*·buf,·size_t·olen,·size_t·len)

606

static·inline·void·_nocheck__trace_buffer_resize(const·char·*·buf,·size_t·olen,·size_t·len)

607

{

607

{

608

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

608

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

609

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

609

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

610

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

610

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

611

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

611

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

613

············qemu_log("%d@%zu.%06zu:buffer_resize·"·"%s:·old·%zd,·new·%zd"·"\n",

613

············qemu_log("%d@%zu.%06zu:buffer_resize·"·"%s:·old·%zd,·new·%zd"·"\n",

614

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

614

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

615

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

615

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

616

·····················,·buf,·olen,·len);

616

·····················,·buf,·olen,·len);

617

#line·619·"trace/trace-util.h"

617

#line·619·"trace/trace-util.h"

618

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

618

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

620

············qemu_log("buffer_resize·"·"%s:·old·%zd,·new·%zd"·"\n",·buf,·olen,·len);

620

············qemu_log("buffer_resize·"·"%s:·old·%zd,·new·%zd"·"\n",·buf,·olen,·len);

621

#line·623·"trace/trace-util.h"

621

#line·623·"trace/trace-util.h"

622

········}

622

········}

623

····}

623

····}

624

}

624

}

625

static·inline·void·trace_buffer_resize(const·char·*·buf,·size_t·olen,·size_t·len)

625

static·inline·void·trace_buffer_resize(const·char·*·buf,·size_t·olen,·size_t·len)

637

static·inline·void·_nocheck__trace_buffer_move_empty(const·char·*·buf,·size_t·len,·const·char·*·from)

637

static·inline·void·_nocheck__trace_buffer_move_empty(const·char·*·buf,·size_t·len,·const·char·*·from)

638

{

638

{

639

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

639

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

640

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

640

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

641

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

641

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

642

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

642

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

644

············qemu_log("%d@%zu.%06zu:buffer_move_empty·"·"%s:·%zd·bytes·from·%s"·"\n",

644

············qemu_log("%d@%zu.%06zu:buffer_move_empty·"·"%s:·%zd·bytes·from·%s"·"\n",

645

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

645

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

646

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

646

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

647

·····················,·buf,·len,·from);

647

·····················,·buf,·len,·from);

648

#line·650·"trace/trace-util.h"

648

#line·650·"trace/trace-util.h"

649

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

649

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

651

············qemu_log("buffer_move_empty·"·"%s:·%zd·bytes·from·%s"·"\n",·buf,·len,·from);

651

············qemu_log("buffer_move_empty·"·"%s:·%zd·bytes·from·%s"·"\n",·buf,·len,·from);

652

#line·654·"trace/trace-util.h"

652

#line·654·"trace/trace-util.h"

653

········}

653

········}

654

····}

654

····}

655

}

655

}

656

static·inline·void·trace_buffer_move_empty(const·char·*·buf,·size_t·len,·const·char·*·from)

656

static·inline·void·trace_buffer_move_empty(const·char·*·buf,·size_t·len,·const·char·*·from)

668

static·inline·void·_nocheck__trace_buffer_move(const·char·*·buf,·size_t·len,·const·char·*·from)

668

static·inline·void·_nocheck__trace_buffer_move(const·char·*·buf,·size_t·len,·const·char·*·from)

669

{

669

{

670

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

670

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

671

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

671

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

672

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

672

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

673

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

673

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

675

············qemu_log("%d@%zu.%06zu:buffer_move·"·"%s:·%zd·bytes·from·%s"·"\n",

675

············qemu_log("%d@%zu.%06zu:buffer_move·"·"%s:·%zd·bytes·from·%s"·"\n",

676

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

676

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

677

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

677

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

678

·····················,·buf,·len,·from);

678

·····················,·buf,·len,·from);

679

#line·681·"trace/trace-util.h"

679

#line·681·"trace/trace-util.h"

680

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

680

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

682

············qemu_log("buffer_move·"·"%s:·%zd·bytes·from·%s"·"\n",·buf,·len,·from);

682

············qemu_log("buffer_move·"·"%s:·%zd·bytes·from·%s"·"\n",·buf,·len,·from);

683

#line·685·"trace/trace-util.h"

683

#line·685·"trace/trace-util.h"

684

········}

684

········}

685

····}

685

····}

686

}

686

}

687

static·inline·void·trace_buffer_move(const·char·*·buf,·size_t·len,·const·char·*·from)

687

static·inline·void·trace_buffer_move(const·char·*·buf,·size_t·len,·const·char·*·from)

699

static·inline·void·_nocheck__trace_buffer_free(const·char·*·buf,·size_t·len)

699

static·inline·void·_nocheck__trace_buffer_free(const·char·*·buf,·size_t·len)

700

{

700

{

701

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

701

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

702

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

702

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

703

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

703

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

704

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

704

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

706

············qemu_log("%d@%zu.%06zu:buffer_free·"·"%s:·capacity·%zd"·"\n",

706

············qemu_log("%d@%zu.%06zu:buffer_free·"·"%s:·capacity·%zd"·"\n",

707

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

707

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

708

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

708

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

709

·····················,·buf,·len);

709

·····················,·buf,·len);

710

#line·712·"trace/trace-util.h"

710

#line·712·"trace/trace-util.h"

711

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

711

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

713

············qemu_log("buffer_free·"·"%s:·capacity·%zd"·"\n",·buf,·len);

713

············qemu_log("buffer_free·"·"%s:·capacity·%zd"·"\n",·buf,·len);

714

#line·716·"trace/trace-util.h"

714

#line·716·"trace/trace-util.h"

715

········}

715

········}

716

····}

716

····}

717

}

717

}

718

static·inline·void·trace_buffer_free(const·char·*·buf,·size_t·len)

718

static·inline·void·trace_buffer_free(const·char·*·buf,·size_t·len)

730

static·inline·void·_nocheck__trace_qemu_file_monitor_add_watch(void·*·mon,·const·char·*·dirpath,·const·char·*·filename,·void·*·cb,·void·*·opaque,·int64_t·id)

730

static·inline·void·_nocheck__trace_qemu_file_monitor_add_watch(void·*·mon,·const·char·*·dirpath,·const·char·*·filename,·void·*·cb,·void·*·opaque,·int64_t·id)

731

{

731

{

732

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

732

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

733

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

733

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

734

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

734

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

735

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

735

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

737

············qemu_log("%d@%zu.%06zu:qemu_file_monitor_add_watch·"·"File·monitor·%p·add·watch·dir='%s'·file='%s'·cb=%p·opaque=%p·id=%"·PRId64·"\n",

737

············qemu_log("%d@%zu.%06zu:qemu_file_monitor_add_watch·"·"File·monitor·%p·add·watch·dir='%s'·file='%s'·cb=%p·opaque=%p·id=%"·PRId64·"\n",

738

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

738

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

739

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

739

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

740

·····················,·mon,·dirpath,·filename,·cb,·opaque,·id);

740

·····················,·mon,·dirpath,·filename,·cb,·opaque,·id);

741

#line·743·"trace/trace-util.h"

741

#line·743·"trace/trace-util.h"

742

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

742

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

744

············qemu_log("qemu_file_monitor_add_watch·"·"File·monitor·%p·add·watch·dir='%s'·file='%s'·cb=%p·opaque=%p·id=%"·PRId64·"\n",·mon,·dirpath,·filename,·cb,·opaque,·id);

744

············qemu_log("qemu_file_monitor_add_watch·"·"File·monitor·%p·add·watch·dir='%s'·file='%s'·cb=%p·opaque=%p·id=%"·PRId64·"\n",·mon,·dirpath,·filename,·cb,·opaque,·id);

745

#line·747·"trace/trace-util.h"

745

#line·747·"trace/trace-util.h"

746

········}

746

········}

747

····}

747

····}

748

}

748

}

749

static·inline·void·trace_qemu_file_monitor_add_watch(void·*·mon,·const·char·*·dirpath,·const·char·*·filename,·void·*·cb,·void·*·opaque,·int64_t·id)

749

static·inline·void·trace_qemu_file_monitor_add_watch(void·*·mon,·const·char·*·dirpath,·const·char·*·filename,·void·*·cb,·void·*·opaque,·int64_t·id)

761

static·inline·void·_nocheck__trace_qemu_file_monitor_remove_watch(void·*·mon,·const·char·*·dirpath,·int64_t·id)

761

static·inline·void·_nocheck__trace_qemu_file_monitor_remove_watch(void·*·mon,·const·char·*·dirpath,·int64_t·id)

762

{

762

{

763

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

763

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

764

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

764

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

765

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

765

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

766

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

766

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

768

············qemu_log("%d@%zu.%06zu:qemu_file_monitor_remove_watch·"·"File·monitor·%p·remove·watch·dir='%s'·id=%"·PRId64·"\n",

768

············qemu_log("%d@%zu.%06zu:qemu_file_monitor_remove_watch·"·"File·monitor·%p·remove·watch·dir='%s'·id=%"·PRId64·"\n",

769

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

769

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

770

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

770

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

771

·····················,·mon,·dirpath,·id);

771

·····················,·mon,·dirpath,·id);

772

#line·774·"trace/trace-util.h"

772

#line·774·"trace/trace-util.h"

773

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

773

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

775

············qemu_log("qemu_file_monitor_remove_watch·"·"File·monitor·%p·remove·watch·dir='%s'·id=%"·PRId64·"\n",·mon,·dirpath,·id);

775

············qemu_log("qemu_file_monitor_remove_watch·"·"File·monitor·%p·remove·watch·dir='%s'·id=%"·PRId64·"\n",·mon,·dirpath,·id);

776

#line·778·"trace/trace-util.h"

776

#line·778·"trace/trace-util.h"

777

········}

777

········}

778

····}

778

····}

779

}

779

}

780

static·inline·void·trace_qemu_file_monitor_remove_watch(void·*·mon,·const·char·*·dirpath,·int64_t·id)

780

static·inline·void·trace_qemu_file_monitor_remove_watch(void·*·mon,·const·char·*·dirpath,·int64_t·id)

792

static·inline·void·_nocheck__trace_qemu_file_monitor_new(void·*·mon,·int·fd)

792

static·inline·void·_nocheck__trace_qemu_file_monitor_new(void·*·mon,·int·fd)

793

{

793

{

794

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

794

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

795

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

795

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

796

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

796

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

797

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

797

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

799

············qemu_log("%d@%zu.%06zu:qemu_file_monitor_new·"·"File·monitor·%p·created·fd=%d"·"\n",

799

············qemu_log("%d@%zu.%06zu:qemu_file_monitor_new·"·"File·monitor·%p·created·fd=%d"·"\n",

800

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

800

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

801

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

801

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

802

·····················,·mon,·fd);

802

·····················,·mon,·fd);

803

#line·805·"trace/trace-util.h"

803

#line·805·"trace/trace-util.h"

804

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

804

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

806

············qemu_log("qemu_file_monitor_new·"·"File·monitor·%p·created·fd=%d"·"\n",·mon,·fd);

806

············qemu_log("qemu_file_monitor_new·"·"File·monitor·%p·created·fd=%d"·"\n",·mon,·fd);

807

#line·809·"trace/trace-util.h"

807

#line·809·"trace/trace-util.h"

808

········}

808

········}

809

····}

809

····}

810

}

810

}

811

static·inline·void·trace_qemu_file_monitor_new(void·*·mon,·int·fd)

811

static·inline·void·trace_qemu_file_monitor_new(void·*·mon,·int·fd)

823

static·inline·void·_nocheck__trace_qemu_file_monitor_enable_watch(void·*·mon,·const·char·*·dirpath,·int·id)

823

static·inline·void·_nocheck__trace_qemu_file_monitor_enable_watch(void·*·mon,·const·char·*·dirpath,·int·id)

824

{

824

{

825

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

825

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

826

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

826

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

827

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

827

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

828

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

828

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

830

············qemu_log("%d@%zu.%06zu:qemu_file_monitor_enable_watch·"·"File·monitor·%p·enable·watch·dir='%s'·id=%u"·"\n",

830

············qemu_log("%d@%zu.%06zu:qemu_file_monitor_enable_watch·"·"File·monitor·%p·enable·watch·dir='%s'·id=%u"·"\n",

831

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

831

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

832

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

832

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

833

·····················,·mon,·dirpath,·id);

833

·····················,·mon,·dirpath,·id);

834

#line·836·"trace/trace-util.h"

834

#line·836·"trace/trace-util.h"

835

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

835

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

837

············qemu_log("qemu_file_monitor_enable_watch·"·"File·monitor·%p·enable·watch·dir='%s'·id=%u"·"\n",·mon,·dirpath,·id);

837

············qemu_log("qemu_file_monitor_enable_watch·"·"File·monitor·%p·enable·watch·dir='%s'·id=%u"·"\n",·mon,·dirpath,·id);

838

#line·840·"trace/trace-util.h"

838

#line·840·"trace/trace-util.h"

839

········}

839

········}

840

····}

840

····}

841

}

841

}

842

static·inline·void·trace_qemu_file_monitor_enable_watch(void·*·mon,·const·char·*·dirpath,·int·id)

842

static·inline·void·trace_qemu_file_monitor_enable_watch(void·*·mon,·const·char·*·dirpath,·int·id)

854

static·inline·void·_nocheck__trace_qemu_file_monitor_disable_watch(void·*·mon,·const·char·*·dirpath,·int·id)

854

static·inline·void·_nocheck__trace_qemu_file_monitor_disable_watch(void·*·mon,·const·char·*·dirpath,·int·id)

855

{

855

{

856

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

856

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

857

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

857

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

858

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

858

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

859

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

859

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

861

············qemu_log("%d@%zu.%06zu:qemu_file_monitor_disable_watch·"·"File·monitor·%p·disable·watch·dir='%s'·id=%u"·"\n",

861

············qemu_log("%d@%zu.%06zu:qemu_file_monitor_disable_watch·"·"File·monitor·%p·disable·watch·dir='%s'·id=%u"·"\n",

862

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

862

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

863

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

863

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

864

·····················,·mon,·dirpath,·id);

864

·····················,·mon,·dirpath,·id);

865

#line·867·"trace/trace-util.h"

865

#line·867·"trace/trace-util.h"

866

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

866

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

868

············qemu_log("qemu_file_monitor_disable_watch·"·"File·monitor·%p·disable·watch·dir='%s'·id=%u"·"\n",·mon,·dirpath,·id);

868

············qemu_log("qemu_file_monitor_disable_watch·"·"File·monitor·%p·disable·watch·dir='%s'·id=%u"·"\n",·mon,·dirpath,·id);

869

#line·871·"trace/trace-util.h"

869

#line·871·"trace/trace-util.h"

870

········}

870

········}

871

····}

871

····}

872

}

872

}

873

static·inline·void·trace_qemu_file_monitor_disable_watch(void·*·mon,·const·char·*·dirpath,·int·id)

873

static·inline·void·trace_qemu_file_monitor_disable_watch(void·*·mon,·const·char·*·dirpath,·int·id)

885

static·inline·void·_nocheck__trace_qemu_file_monitor_event(void·*·mon,·const·char·*·dirpath,·const·char·*·filename,·int·mask,·unsigned·int·id)

885

static·inline·void·_nocheck__trace_qemu_file_monitor_event(void·*·mon,·const·char·*·dirpath,·const·char·*·filename,·int·mask,·unsigned·int·id)

886

{

886

{

887

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

887

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

888

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

888

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

889

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

889

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

890

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

890

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

892

············qemu_log("%d@%zu.%06zu:qemu_file_monitor_event·"·"File·monitor·%p·event·dir='%s'·file='%s'·mask=0x%x·id=%u"·"\n",

892

············qemu_log("%d@%zu.%06zu:qemu_file_monitor_event·"·"File·monitor·%p·event·dir='%s'·file='%s'·mask=0x%x·id=%u"·"\n",

893

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

893

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

894

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

894

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

895

·····················,·mon,·dirpath,·filename,·mask,·id);

895

·····················,·mon,·dirpath,·filename,·mask,·id);

896

#line·898·"trace/trace-util.h"

896

#line·898·"trace/trace-util.h"

897

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

897

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

899

············qemu_log("qemu_file_monitor_event·"·"File·monitor·%p·event·dir='%s'·file='%s'·mask=0x%x·id=%u"·"\n",·mon,·dirpath,·filename,·mask,·id);

899

············qemu_log("qemu_file_monitor_event·"·"File·monitor·%p·event·dir='%s'·file='%s'·mask=0x%x·id=%u"·"\n",·mon,·dirpath,·filename,·mask,·id);

900

#line·902·"trace/trace-util.h"

900

#line·902·"trace/trace-util.h"

901

········}

901

········}

902

····}

902

····}

903

}

903

}

904

static·inline·void·trace_qemu_file_monitor_event(void·*·mon,·const·char·*·dirpath,·const·char·*·filename,·int·mask,·unsigned·int·id)

904

static·inline·void·trace_qemu_file_monitor_event(void·*·mon,·const·char·*·dirpath,·const·char·*·filename,·int·mask,·unsigned·int·id)

916

static·inline·void·_nocheck__trace_qemu_file_monitor_dispatch(void·*·mon,·const·char·*·dirpath,·const·char·*·filename,·int·ev,·void·*·cb,·void·*·opaque,·int64_t·id)

916

static·inline·void·_nocheck__trace_qemu_file_monitor_dispatch(void·*·mon,·const·char·*·dirpath,·const·char·*·filename,·int·ev,·void·*·cb,·void·*·opaque,·int64_t·id)

917

{

917

{

918

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

918

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

919

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

919

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

920

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

920

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

921

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

921

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

923

············qemu_log("%d@%zu.%06zu:qemu_file_monitor_dispatch·"·"File·monitor·%p·dispatch·dir='%s'·file='%s'·ev=%d·cb=%p·opaque=%p·id=%"·PRId64·"\n",

923

············qemu_log("%d@%zu.%06zu:qemu_file_monitor_dispatch·"·"File·monitor·%p·dispatch·dir='%s'·file='%s'·ev=%d·cb=%p·opaque=%p·id=%"·PRId64·"\n",

924

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

924

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

925

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

925

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

926

·····················,·mon,·dirpath,·filename,·ev,·cb,·opaque,·id);

926

·····················,·mon,·dirpath,·filename,·ev,·cb,·opaque,·id);

927

#line·929·"trace/trace-util.h"

927

#line·929·"trace/trace-util.h"

928

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

928

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

930

············qemu_log("qemu_file_monitor_dispatch·"·"File·monitor·%p·dispatch·dir='%s'·file='%s'·ev=%d·cb=%p·opaque=%p·id=%"·PRId64·"\n",·mon,·dirpath,·filename,·ev,·cb,·opaque,·id);

930

············qemu_log("qemu_file_monitor_dispatch·"·"File·monitor·%p·dispatch·dir='%s'·file='%s'·ev=%d·cb=%p·opaque=%p·id=%"·PRId64·"\n",·mon,·dirpath,·filename,·ev,·cb,·opaque,·id);

931

#line·933·"trace/trace-util.h"

931

#line·933·"trace/trace-util.h"

932

········}

932

········}

933

····}

933

····}

934

}

934

}

935

static·inline·void·trace_qemu_file_monitor_dispatch(void·*·mon,·const·char·*·dirpath,·const·char·*·filename,·int·ev,·void·*·cb,·void·*·opaque,·int64_t·id)

935

static·inline·void·trace_qemu_file_monitor_dispatch(void·*·mon,·const·char·*·dirpath,·const·char·*·filename,·int·ev,·void·*·cb,·void·*·opaque,·int64_t·id)

947

static·inline·void·_nocheck__trace_qemu_aio_coroutine_enter(void·*·ctx,·void·*·from,·void·*·to,·void·*·opaque)

947

static·inline·void·_nocheck__trace_qemu_aio_coroutine_enter(void·*·ctx,·void·*·from,·void·*·to,·void·*·opaque)

948

{

948

{

949

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

949

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

950

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

950

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

951

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

951

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

952

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

952

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

954

············qemu_log("%d@%zu.%06zu:qemu_aio_coroutine_enter·"·"ctx·%p·from·%p·to·%p·opaque·%p"·"\n",

954

············qemu_log("%d@%zu.%06zu:qemu_aio_coroutine_enter·"·"ctx·%p·from·%p·to·%p·opaque·%p"·"\n",

955

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

955

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

956

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

956

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

957

·····················,·ctx,·from,·to,·opaque);

957

·····················,·ctx,·from,·to,·opaque);

958

#line·960·"trace/trace-util.h"

958

#line·960·"trace/trace-util.h"

959

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

959

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

961

············qemu_log("qemu_aio_coroutine_enter·"·"ctx·%p·from·%p·to·%p·opaque·%p"·"\n",·ctx,·from,·to,·opaque);

961

············qemu_log("qemu_aio_coroutine_enter·"·"ctx·%p·from·%p·to·%p·opaque·%p"·"\n",·ctx,·from,·to,·opaque);

962

#line·964·"trace/trace-util.h"

962

#line·964·"trace/trace-util.h"

963

········}

963

········}

964

····}

964

····}

965

}

965

}

966

static·inline·void·trace_qemu_aio_coroutine_enter(void·*·ctx,·void·*·from,·void·*·to,·void·*·opaque)

966

static·inline·void·trace_qemu_aio_coroutine_enter(void·*·ctx,·void·*·from,·void·*·to,·void·*·opaque)

978

static·inline·void·_nocheck__trace_qemu_coroutine_yield(void·*·from,·void·*·to)

978

static·inline·void·_nocheck__trace_qemu_coroutine_yield(void·*·from,·void·*·to)

979

{

979

{

980

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

980

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

981

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

981

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

982

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

982

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

983

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

983

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

985

············qemu_log("%d@%zu.%06zu:qemu_coroutine_yield·"·"from·%p·to·%p"·"\n",

985

············qemu_log("%d@%zu.%06zu:qemu_coroutine_yield·"·"from·%p·to·%p"·"\n",

986

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

986

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

987

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

987

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

988

·····················,·from,·to);

988

·····················,·from,·to);

989

#line·991·"trace/trace-util.h"

989

#line·991·"trace/trace-util.h"

990

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

990

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

992

············qemu_log("qemu_coroutine_yield·"·"from·%p·to·%p"·"\n",·from,·to);

992

············qemu_log("qemu_coroutine_yield·"·"from·%p·to·%p"·"\n",·from,·to);

993

#line·995·"trace/trace-util.h"

993

#line·995·"trace/trace-util.h"

994

········}

994

········}

995

····}

995

····}

996

}

996

}

997

static·inline·void·trace_qemu_coroutine_yield(void·*·from,·void·*·to)

997

static·inline·void·trace_qemu_coroutine_yield(void·*·from,·void·*·to)

1009

static·inline·void·_nocheck__trace_qemu_coroutine_terminate(void·*·co)

1009

static·inline·void·_nocheck__trace_qemu_coroutine_terminate(void·*·co)

1010

{

1010

{

1011

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

1011

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

1012

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

1012

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

1013

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

1013

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

1014

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

1014

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

1016

············qemu_log("%d@%zu.%06zu:qemu_coroutine_terminate·"·"self·%p"·"\n",

1016

············qemu_log("%d@%zu.%06zu:qemu_coroutine_terminate·"·"self·%p"·"\n",

1017

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

1017

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

1018

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

1018

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

1019

·····················,·co);

1019

·····················,·co);

1020

#line·1022·"trace/trace-util.h"

1020

#line·1022·"trace/trace-util.h"

1021

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

1021

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

1023

············qemu_log("qemu_coroutine_terminate·"·"self·%p"·"\n",·co);

1023

············qemu_log("qemu_coroutine_terminate·"·"self·%p"·"\n",·co);

1024

#line·1026·"trace/trace-util.h"

1024

#line·1026·"trace/trace-util.h"

1025

········}

1025

········}

1026

····}

1026

····}

1027

}

1027

}

1028

static·inline·void·trace_qemu_coroutine_terminate(void·*·co)

1028

static·inline·void·trace_qemu_coroutine_terminate(void·*·co)

1040

static·inline·void·_nocheck__trace_qemu_co_mutex_lock_uncontended(void·*·mutex,·void·*·self)

1040

static·inline·void·_nocheck__trace_qemu_co_mutex_lock_uncontended(void·*·mutex,·void·*·self)

1041

{

1041

{

1042

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

1042

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

1043

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

1043

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

1044

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

1044

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

1045

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

1045

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

1047

············qemu_log("%d@%zu.%06zu:qemu_co_mutex_lock_uncontended·"·"mutex·%p·self·%p"·"\n",

1047

············qemu_log("%d@%zu.%06zu:qemu_co_mutex_lock_uncontended·"·"mutex·%p·self·%p"·"\n",

1048

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

1048

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

1049

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

1049

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

1050

·····················,·mutex,·self);

1050

·····················,·mutex,·self);

1051

#line·1053·"trace/trace-util.h"

1051

#line·1053·"trace/trace-util.h"

1052

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

1052

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

1054

············qemu_log("qemu_co_mutex_lock_uncontended·"·"mutex·%p·self·%p"·"\n",·mutex,·self);

1054

············qemu_log("qemu_co_mutex_lock_uncontended·"·"mutex·%p·self·%p"·"\n",·mutex,·self);

1055

#line·1057·"trace/trace-util.h"

1055

#line·1057·"trace/trace-util.h"

1056

········}

1056

········}

1057

····}

1057

····}

1058

}

1058

}

1059

static·inline·void·trace_qemu_co_mutex_lock_uncontended(void·*·mutex,·void·*·self)

1059

static·inline·void·trace_qemu_co_mutex_lock_uncontended(void·*·mutex,·void·*·self)

1071

static·inline·void·_nocheck__trace_qemu_co_mutex_lock_entry(void·*·mutex,·void·*·self)

1071

static·inline·void·_nocheck__trace_qemu_co_mutex_lock_entry(void·*·mutex,·void·*·self)

1072

{

1072

{

1073

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

1073

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

1074

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

1074

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

1075

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

1075

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

1076

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

1076

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

1078

············qemu_log("%d@%zu.%06zu:qemu_co_mutex_lock_entry·"·"mutex·%p·self·%p"·"\n",

1078

············qemu_log("%d@%zu.%06zu:qemu_co_mutex_lock_entry·"·"mutex·%p·self·%p"·"\n",

1079

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

1079

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

1080

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

1080

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

1081

·····················,·mutex,·self);

1081

·····················,·mutex,·self);

1082

#line·1084·"trace/trace-util.h"

1082

#line·1084·"trace/trace-util.h"

1083

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

1083

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

1085

············qemu_log("qemu_co_mutex_lock_entry·"·"mutex·%p·self·%p"·"\n",·mutex,·self);

1085

············qemu_log("qemu_co_mutex_lock_entry·"·"mutex·%p·self·%p"·"\n",·mutex,·self);

1086

#line·1088·"trace/trace-util.h"

1086

#line·1088·"trace/trace-util.h"

1087

········}

1087

········}

1088

····}

1088

····}

1089

}

1089

}

1090

static·inline·void·trace_qemu_co_mutex_lock_entry(void·*·mutex,·void·*·self)

1090

static·inline·void·trace_qemu_co_mutex_lock_entry(void·*·mutex,·void·*·self)

1102

static·inline·void·_nocheck__trace_qemu_co_mutex_lock_return(void·*·mutex,·void·*·self)

1102

static·inline·void·_nocheck__trace_qemu_co_mutex_lock_return(void·*·mutex,·void·*·self)

1103

{

1103

{

1104

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

1104

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

1105

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

1105

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

1106

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

1106

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

1107

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

1107

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

1109

············qemu_log("%d@%zu.%06zu:qemu_co_mutex_lock_return·"·"mutex·%p·self·%p"·"\n",

1109

············qemu_log("%d@%zu.%06zu:qemu_co_mutex_lock_return·"·"mutex·%p·self·%p"·"\n",

1110

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

1110

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

1111

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

1111

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

1112

·····················,·mutex,·self);

1112

·····················,·mutex,·self);

1113

#line·1115·"trace/trace-util.h"

1113

#line·1115·"trace/trace-util.h"

1114

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

1114

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

1116

············qemu_log("qemu_co_mutex_lock_return·"·"mutex·%p·self·%p"·"\n",·mutex,·self);

1116

············qemu_log("qemu_co_mutex_lock_return·"·"mutex·%p·self·%p"·"\n",·mutex,·self);

1117

#line·1119·"trace/trace-util.h"

1117

#line·1119·"trace/trace-util.h"

1118

········}

1118

········}

1119

····}

1119

····}

1120

}

1120

}

1121

static·inline·void·trace_qemu_co_mutex_lock_return(void·*·mutex,·void·*·self)

1121

static·inline·void·trace_qemu_co_mutex_lock_return(void·*·mutex,·void·*·self)

1133

static·inline·void·_nocheck__trace_qemu_co_mutex_unlock_entry(void·*·mutex,·void·*·self)

1133

static·inline·void·_nocheck__trace_qemu_co_mutex_unlock_entry(void·*·mutex,·void·*·self)

1134

{

1134

{

1135

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

1135

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

1136

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

1136

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

1137

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

1137

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

1138

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

1138

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

1140

············qemu_log("%d@%zu.%06zu:qemu_co_mutex_unlock_entry·"·"mutex·%p·self·%p"·"\n",

1140

············qemu_log("%d@%zu.%06zu:qemu_co_mutex_unlock_entry·"·"mutex·%p·self·%p"·"\n",

1141

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

1141

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

1142

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

1142

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

1143

·····················,·mutex,·self);

1143

·····················,·mutex,·self);

1144

#line·1146·"trace/trace-util.h"

1144

#line·1146·"trace/trace-util.h"

1145

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

1145

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

1147

············qemu_log("qemu_co_mutex_unlock_entry·"·"mutex·%p·self·%p"·"\n",·mutex,·self);

1147

············qemu_log("qemu_co_mutex_unlock_entry·"·"mutex·%p·self·%p"·"\n",·mutex,·self);

1148

#line·1150·"trace/trace-util.h"

1148

#line·1150·"trace/trace-util.h"

1149

········}

1149

········}

1150

····}

1150

····}

1151

}

1151

}

1152

static·inline·void·trace_qemu_co_mutex_unlock_entry(void·*·mutex,·void·*·self)

1152

static·inline·void·trace_qemu_co_mutex_unlock_entry(void·*·mutex,·void·*·self)

1164

static·inline·void·_nocheck__trace_qemu_co_mutex_unlock_return(void·*·mutex,·void·*·self)

1164

static·inline·void·_nocheck__trace_qemu_co_mutex_unlock_return(void·*·mutex,·void·*·self)

1165

{

1165

{

1166

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

1166

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

1167

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

1167

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

1168

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

1168

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

1169

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

1169

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

1171

············qemu_log("%d@%zu.%06zu:qemu_co_mutex_unlock_return·"·"mutex·%p·self·%p"·"\n",

1171

············qemu_log("%d@%zu.%06zu:qemu_co_mutex_unlock_return·"·"mutex·%p·self·%p"·"\n",

1172

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

1172

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

1173

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

1173

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

1174

·····················,·mutex,·self);

1174

·····················,·mutex,·self);

1175

#line·1177·"trace/trace-util.h"

1175

#line·1177·"trace/trace-util.h"

1176

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

1176

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

1178

············qemu_log("qemu_co_mutex_unlock_return·"·"mutex·%p·self·%p"·"\n",·mutex,·self);

1178

············qemu_log("qemu_co_mutex_unlock_return·"·"mutex·%p·self·%p"·"\n",·mutex,·self);

1179

#line·1181·"trace/trace-util.h"

1179

#line·1181·"trace/trace-util.h"

1180

········}

1180

········}

1181

····}

1181

····}

1182

}

1182

}

1183

static·inline·void·trace_qemu_co_mutex_unlock_return(void·*·mutex,·void·*·self)

1183

static·inline·void·trace_qemu_co_mutex_unlock_return(void·*·mutex,·void·*·self)

1195

static·inline·void·_nocheck__trace_qemu_memalign(size_t·alignment,·size_t·size,·void·*·ptr)

1195

static·inline·void·_nocheck__trace_qemu_memalign(size_t·alignment,·size_t·size,·void·*·ptr)

1196

{

1196

{

1197

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

1197

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

1198

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

1198

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

1199

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

1199

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

1200

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

1200

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

1202

············qemu_log("%d@%zu.%06zu:qemu_memalign·"·"alignment·%zu·size·%zu·ptr·%p"·"\n",

1202

············qemu_log("%d@%zu.%06zu:qemu_memalign·"·"alignment·%zu·size·%zu·ptr·%p"·"\n",

1203

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

1203

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

1204

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

1204

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

1205

·····················,·alignment,·size,·ptr);

1205

·····················,·alignment,·size,·ptr);

1206

#line·1208·"trace/trace-util.h"

1206

#line·1208·"trace/trace-util.h"

1207

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

1207

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

1209

············qemu_log("qemu_memalign·"·"alignment·%zu·size·%zu·ptr·%p"·"\n",·alignment,·size,·ptr);

1209

············qemu_log("qemu_memalign·"·"alignment·%zu·size·%zu·ptr·%p"·"\n",·alignment,·size,·ptr);

1210

#line·1212·"trace/trace-util.h"

1210

#line·1212·"trace/trace-util.h"

1211

········}

1211

········}

1212

····}

1212

····}

1213

}

1213

}

1214

static·inline·void·trace_qemu_memalign(size_t·alignment,·size_t·size,·void·*·ptr)

1214

static·inline·void·trace_qemu_memalign(size_t·alignment,·size_t·size,·void·*·ptr)

1226

static·inline·void·_nocheck__trace_qemu_anon_ram_alloc(size_t·size,·void·*·ptr)

1226

static·inline·void·_nocheck__trace_qemu_anon_ram_alloc(size_t·size,·void·*·ptr)

1227

{

1227

{

1228

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

1228

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

1229

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

1229

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

1230

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

1230

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

1231

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

1231

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

1233

············qemu_log("%d@%zu.%06zu:qemu_anon_ram_alloc·"·"size·%zu·ptr·%p"·"\n",

1233

············qemu_log("%d@%zu.%06zu:qemu_anon_ram_alloc·"·"size·%zu·ptr·%p"·"\n",

1234

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

1234

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

1235

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

1235

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

1236

·····················,·size,·ptr);

1236

·····················,·size,·ptr);

1237

#line·1239·"trace/trace-util.h"

1237

#line·1239·"trace/trace-util.h"

1238

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

1238

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

1240

············qemu_log("qemu_anon_ram_alloc·"·"size·%zu·ptr·%p"·"\n",·size,·ptr);

1240

············qemu_log("qemu_anon_ram_alloc·"·"size·%zu·ptr·%p"·"\n",·size,·ptr);

1241

#line·1243·"trace/trace-util.h"

1241

#line·1243·"trace/trace-util.h"

1242

········}

1242

········}

1243

····}

1243

····}

1244

}

1244

}

1245

static·inline·void·trace_qemu_anon_ram_alloc(size_t·size,·void·*·ptr)

1245

static·inline·void·trace_qemu_anon_ram_alloc(size_t·size,·void·*·ptr)

1257

static·inline·void·_nocheck__trace_qemu_vfree(void·*·ptr)

1257

static·inline·void·_nocheck__trace_qemu_vfree(void·*·ptr)

1258

{

1258

{

1259

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

1259

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

1260

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

1260

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

1261

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

1261

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

1262

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

1262

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

1264

············qemu_log("%d@%zu.%06zu:qemu_vfree·"·"ptr·%p"·"\n",

1264

············qemu_log("%d@%zu.%06zu:qemu_vfree·"·"ptr·%p"·"\n",

1265

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

1265

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

1266

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

1266

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

1267

·····················,·ptr);

1267

·····················,·ptr);

1268

#line·1270·"trace/trace-util.h"

1268

#line·1270·"trace/trace-util.h"

1269

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

1269

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

1271

············qemu_log("qemu_vfree·"·"ptr·%p"·"\n",·ptr);

1271

············qemu_log("qemu_vfree·"·"ptr·%p"·"\n",·ptr);

1272

#line·1274·"trace/trace-util.h"

1272

#line·1274·"trace/trace-util.h"

1273

········}

1273

········}

1274

····}

1274

····}

1275

}

1275

}

1276

static·inline·void·trace_qemu_vfree(void·*·ptr)

1276

static·inline·void·trace_qemu_vfree(void·*·ptr)

1288

static·inline·void·_nocheck__trace_qemu_anon_ram_free(void·*·ptr,·size_t·size)

1288

static·inline·void·_nocheck__trace_qemu_anon_ram_free(void·*·ptr,·size_t·size)

1289

{

1289

{

1290

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

1290

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

1291

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

1291

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

1292

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

1292

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

1293

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

1293

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

1295

············qemu_log("%d@%zu.%06zu:qemu_anon_ram_free·"·"ptr·%p·size·%zu"·"\n",

1295

············qemu_log("%d@%zu.%06zu:qemu_anon_ram_free·"·"ptr·%p·size·%zu"·"\n",

1296

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

1296

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

1297

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

1297

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

1298

·····················,·ptr,·size);

1298

·····················,·ptr,·size);

1299

#line·1301·"trace/trace-util.h"

1299

#line·1301·"trace/trace-util.h"

1300

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

1300

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

1302

············qemu_log("qemu_anon_ram_free·"·"ptr·%p·size·%zu"·"\n",·ptr,·size);

1302

············qemu_log("qemu_anon_ram_free·"·"ptr·%p·size·%zu"·"\n",·ptr,·size);

1303

#line·1305·"trace/trace-util.h"

1303

#line·1305·"trace/trace-util.h"

1304

········}

1304

········}

1305

····}

1305

····}

1306

}

1306

}

1307

static·inline·void·trace_qemu_anon_ram_free(void·*·ptr,·size_t·size)

1307

static·inline·void·trace_qemu_anon_ram_free(void·*·ptr,·size_t·size)

1319

static·inline·void·_nocheck__trace_hbitmap_iter_skip_words(const·void·*·hb,·void·*·hbi,·uint64_t·pos,·unsigned·long·cur)

1319

static·inline·void·_nocheck__trace_hbitmap_iter_skip_words(const·void·*·hb,·void·*·hbi,·uint64_t·pos,·unsigned·long·cur)

1320

{

1320

{

1321

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

1321

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

1322

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

1322

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

1323

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

1323

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

1324

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

1324

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

1326

············qemu_log("%d@%zu.%06zu:hbitmap_iter_skip_words·"·"hb·%p·hbi·%p·pos·%"PRId64"·cur·0x%lx"·"\n",

1326

············qemu_log("%d@%zu.%06zu:hbitmap_iter_skip_words·"·"hb·%p·hbi·%p·pos·%"PRId64"·cur·0x%lx"·"\n",

1327

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

1327

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

1328

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

1328

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

1329

·····················,·hb,·hbi,·pos,·cur);

1329

·····················,·hb,·hbi,·pos,·cur);

1330

#line·1332·"trace/trace-util.h"

1330

#line·1332·"trace/trace-util.h"

1331

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

1331

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

1333

············qemu_log("hbitmap_iter_skip_words·"·"hb·%p·hbi·%p·pos·%"PRId64"·cur·0x%lx"·"\n",·hb,·hbi,·pos,·cur);

1333

············qemu_log("hbitmap_iter_skip_words·"·"hb·%p·hbi·%p·pos·%"PRId64"·cur·0x%lx"·"\n",·hb,·hbi,·pos,·cur);

1334

#line·1336·"trace/trace-util.h"

1334

#line·1336·"trace/trace-util.h"

1335

········}

1335

········}

1336

····}

1336

····}

1337

}

1337

}

1338

static·inline·void·trace_hbitmap_iter_skip_words(const·void·*·hb,·void·*·hbi,·uint64_t·pos,·unsigned·long·cur)

1338

static·inline·void·trace_hbitmap_iter_skip_words(const·void·*·hb,·void·*·hbi,·uint64_t·pos,·unsigned·long·cur)

1350

static·inline·void·_nocheck__trace_hbitmap_reset(void·*·hb,·uint64_t·start,·uint64_t·count,·uint64_t·sbit,·uint64_t·ebit)

1350

static·inline·void·_nocheck__trace_hbitmap_reset(void·*·hb,·uint64_t·start,·uint64_t·count,·uint64_t·sbit,·uint64_t·ebit)

1351

{

1351

{

1352

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

1352

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

1353

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

1353

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

1354

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

1354

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

1355

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

1355

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

1357

············qemu_log("%d@%zu.%06zu:hbitmap_reset·"·"hb·%p·items·%"PRIu64",%"PRIu64"·bits·%"PRIu64"..%"PRIu64·"\n",

1357

············qemu_log("%d@%zu.%06zu:hbitmap_reset·"·"hb·%p·items·%"PRIu64",%"PRIu64"·bits·%"PRIu64"..%"PRIu64·"\n",

1358

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

1358

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

1359

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

1359

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

1360

·····················,·hb,·start,·count,·sbit,·ebit);

1360

·····················,·hb,·start,·count,·sbit,·ebit);

1361

#line·1363·"trace/trace-util.h"

1361

#line·1363·"trace/trace-util.h"

1362

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

1362

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

1364

············qemu_log("hbitmap_reset·"·"hb·%p·items·%"PRIu64",%"PRIu64"·bits·%"PRIu64"..%"PRIu64·"\n",·hb,·start,·count,·sbit,·ebit);

1364

············qemu_log("hbitmap_reset·"·"hb·%p·items·%"PRIu64",%"PRIu64"·bits·%"PRIu64"..%"PRIu64·"\n",·hb,·start,·count,·sbit,·ebit);

1365

#line·1367·"trace/trace-util.h"

1365

#line·1367·"trace/trace-util.h"

1366

········}

1366

········}

1367

····}

1367

····}

1368

}

1368

}

1369

static·inline·void·trace_hbitmap_reset(void·*·hb,·uint64_t·start,·uint64_t·count,·uint64_t·sbit,·uint64_t·ebit)

1369

static·inline·void·trace_hbitmap_reset(void·*·hb,·uint64_t·start,·uint64_t·count,·uint64_t·sbit,·uint64_t·ebit)

1381

static·inline·void·_nocheck__trace_hbitmap_set(void·*·hb,·uint64_t·start,·uint64_t·count,·uint64_t·sbit,·uint64_t·ebit)

1381

static·inline·void·_nocheck__trace_hbitmap_set(void·*·hb,·uint64_t·start,·uint64_t·count,·uint64_t·sbit,·uint64_t·ebit)

1382

{

1382

{

1383

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

1383

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

1384

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

1384

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

1385

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

1385

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

1386

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

1386

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

1388

············qemu_log("%d@%zu.%06zu:hbitmap_set·"·"hb·%p·items·%"PRIu64",%"PRIu64"·bits·%"PRIu64"..%"PRIu64·"\n",

1388

············qemu_log("%d@%zu.%06zu:hbitmap_set·"·"hb·%p·items·%"PRIu64",%"PRIu64"·bits·%"PRIu64"..%"PRIu64·"\n",

1389

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

1389

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

1390

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

1390

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

1391

·····················,·hb,·start,·count,·sbit,·ebit);

1391

·····················,·hb,·start,·count,·sbit,·ebit);

1392

#line·1394·"trace/trace-util.h"

1392

#line·1394·"trace/trace-util.h"

1393

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

1393

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

1395

············qemu_log("hbitmap_set·"·"hb·%p·items·%"PRIu64",%"PRIu64"·bits·%"PRIu64"..%"PRIu64·"\n",·hb,·start,·count,·sbit,·ebit);

1395

············qemu_log("hbitmap_set·"·"hb·%p·items·%"PRIu64",%"PRIu64"·bits·%"PRIu64"..%"PRIu64·"\n",·hb,·start,·count,·sbit,·ebit);

1396

#line·1398·"trace/trace-util.h"

1396

#line·1398·"trace/trace-util.h"

1397

········}

1397

········}

1398

····}

1398

····}

1399

}

1399

}

1400

static·inline·void·trace_hbitmap_set(void·*·hb,·uint64_t·start,·uint64_t·count,·uint64_t·sbit,·uint64_t·ebit)

1400

static·inline·void·trace_hbitmap_set(void·*·hb,·uint64_t·start,·uint64_t·count,·uint64_t·sbit,·uint64_t·ebit)

1412

static·inline·void·_nocheck__trace_lockcnt_fast_path_attempt(const·void·*·lockcnt,·int·expected,·int·new)

1412

static·inline·void·_nocheck__trace_lockcnt_fast_path_attempt(const·void·*·lockcnt,·int·expected,·int·new)

1413

{

1413

{

1414

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

1414

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

1415

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

1415

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

1416

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

1416

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

1417

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

1417

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

1419

············qemu_log("%d@%zu.%06zu:lockcnt_fast_path_attempt·"·"lockcnt·%p·fast·path·%d->%d"·"\n",

1419

············qemu_log("%d@%zu.%06zu:lockcnt_fast_path_attempt·"·"lockcnt·%p·fast·path·%d->%d"·"\n",

1420

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

1420

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

1421

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

1421

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

1422

·····················,·lockcnt,·expected,·new);

1422

·····················,·lockcnt,·expected,·new);

1423

#line·1425·"trace/trace-util.h"

1423

#line·1425·"trace/trace-util.h"

1424

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

1424

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

1426

············qemu_log("lockcnt_fast_path_attempt·"·"lockcnt·%p·fast·path·%d->%d"·"\n",·lockcnt,·expected,·new);

1426

············qemu_log("lockcnt_fast_path_attempt·"·"lockcnt·%p·fast·path·%d->%d"·"\n",·lockcnt,·expected,·new);

1427

#line·1429·"trace/trace-util.h"

1427

#line·1429·"trace/trace-util.h"

1428

········}

1428

········}

1429

····}

1429

····}

1430

}

1430

}

1431

static·inline·void·trace_lockcnt_fast_path_attempt(const·void·*·lockcnt,·int·expected,·int·new)

1431

static·inline·void·trace_lockcnt_fast_path_attempt(const·void·*·lockcnt,·int·expected,·int·new)

1443

static·inline·void·_nocheck__trace_lockcnt_fast_path_success(const·void·*·lockcnt,·int·expected,·int·new)

1443

static·inline·void·_nocheck__trace_lockcnt_fast_path_success(const·void·*·lockcnt,·int·expected,·int·new)

1444

{

1444

{

1445

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

1445

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

1446

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

1446

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

1447

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

1447

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

1448

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

1448

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

1450

············qemu_log("%d@%zu.%06zu:lockcnt_fast_path_success·"·"lockcnt·%p·fast·path·%d->%d·succeeded"·"\n",

1450

············qemu_log("%d@%zu.%06zu:lockcnt_fast_path_success·"·"lockcnt·%p·fast·path·%d->%d·succeeded"·"\n",

1451

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

1451

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

1452

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

1452

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

1453

·····················,·lockcnt,·expected,·new);

1453

·····················,·lockcnt,·expected,·new);

1454

#line·1456·"trace/trace-util.h"

1454

#line·1456·"trace/trace-util.h"

1455

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

1455

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

1457

············qemu_log("lockcnt_fast_path_success·"·"lockcnt·%p·fast·path·%d->%d·succeeded"·"\n",·lockcnt,·expected,·new);

1457

············qemu_log("lockcnt_fast_path_success·"·"lockcnt·%p·fast·path·%d->%d·succeeded"·"\n",·lockcnt,·expected,·new);

1458

#line·1460·"trace/trace-util.h"

1458

#line·1460·"trace/trace-util.h"

1459

········}

1459

········}

1460

····}

1460

····}

1461

}

1461

}

1462

static·inline·void·trace_lockcnt_fast_path_success(const·void·*·lockcnt,·int·expected,·int·new)

1462

static·inline·void·trace_lockcnt_fast_path_success(const·void·*·lockcnt,·int·expected,·int·new)

1474

static·inline·void·_nocheck__trace_lockcnt_unlock_attempt(const·void·*·lockcnt,·int·expected,·int·new)

1474

static·inline·void·_nocheck__trace_lockcnt_unlock_attempt(const·void·*·lockcnt,·int·expected,·int·new)

1475

{

1475

{

1476

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

1476

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

1477

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

1477

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

1478

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

1478

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

1479

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

1479

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

1481

············qemu_log("%d@%zu.%06zu:lockcnt_unlock_attempt·"·"lockcnt·%p·unlock·%d->%d"·"\n",

1481

············qemu_log("%d@%zu.%06zu:lockcnt_unlock_attempt·"·"lockcnt·%p·unlock·%d->%d"·"\n",

1482

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

1482

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

1483

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

1483

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

1484

·····················,·lockcnt,·expected,·new);

1484

·····················,·lockcnt,·expected,·new);

1485

#line·1487·"trace/trace-util.h"

1485

#line·1487·"trace/trace-util.h"

1486

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

1486

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

1488

············qemu_log("lockcnt_unlock_attempt·"·"lockcnt·%p·unlock·%d->%d"·"\n",·lockcnt,·expected,·new);

1488

············qemu_log("lockcnt_unlock_attempt·"·"lockcnt·%p·unlock·%d->%d"·"\n",·lockcnt,·expected,·new);

1489

#line·1491·"trace/trace-util.h"

1489

#line·1491·"trace/trace-util.h"

1490

········}

1490

········}

1491

····}

1491

····}

1492

}

1492

}

1493

static·inline·void·trace_lockcnt_unlock_attempt(const·void·*·lockcnt,·int·expected,·int·new)

1493

static·inline·void·trace_lockcnt_unlock_attempt(const·void·*·lockcnt,·int·expected,·int·new)

1505

static·inline·void·_nocheck__trace_lockcnt_unlock_success(const·void·*·lockcnt,·int·expected,·int·new)

1505

static·inline·void·_nocheck__trace_lockcnt_unlock_success(const·void·*·lockcnt,·int·expected,·int·new)

1506

{

1506

{

1507

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

1507

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

1508

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

1508

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

1509

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

1509

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

1510

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

1510

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

1512

············qemu_log("%d@%zu.%06zu:lockcnt_unlock_success·"·"lockcnt·%p·unlock·%d->%d·succeeded"·"\n",

1512

············qemu_log("%d@%zu.%06zu:lockcnt_unlock_success·"·"lockcnt·%p·unlock·%d->%d·succeeded"·"\n",

1513

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

1513

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

1514

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

1514

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

1515

·····················,·lockcnt,·expected,·new);

1515

·····················,·lockcnt,·expected,·new);

1516

#line·1518·"trace/trace-util.h"

1516

#line·1518·"trace/trace-util.h"

1517

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

1517

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

1519

············qemu_log("lockcnt_unlock_success·"·"lockcnt·%p·unlock·%d->%d·succeeded"·"\n",·lockcnt,·expected,·new);

1519

············qemu_log("lockcnt_unlock_success·"·"lockcnt·%p·unlock·%d->%d·succeeded"·"\n",·lockcnt,·expected,·new);

1520

#line·1522·"trace/trace-util.h"

1520

#line·1522·"trace/trace-util.h"

1521

········}

1521

········}

1522

····}

1522

····}

1523

}

1523

}

1524

static·inline·void·trace_lockcnt_unlock_success(const·void·*·lockcnt,·int·expected,·int·new)

1524

static·inline·void·trace_lockcnt_unlock_success(const·void·*·lockcnt,·int·expected,·int·new)

1536

static·inline·void·_nocheck__trace_lockcnt_futex_wait_prepare(const·void·*·lockcnt,·int·expected,·int·new)

1536

static·inline·void·_nocheck__trace_lockcnt_futex_wait_prepare(const·void·*·lockcnt,·int·expected,·int·new)

1537

{

1537

{

1538

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

1538

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

1539

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

1539

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

1540

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

1540

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

1541

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

1541

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

1543

············qemu_log("%d@%zu.%06zu:lockcnt_futex_wait_prepare·"·"lockcnt·%p·preparing·slow·path·%d->%d"·"\n",

1543

············qemu_log("%d@%zu.%06zu:lockcnt_futex_wait_prepare·"·"lockcnt·%p·preparing·slow·path·%d->%d"·"\n",

1544

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

1544

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

1545

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

1545

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

1546

·····················,·lockcnt,·expected,·new);

1546

·····················,·lockcnt,·expected,·new);

1547

#line·1549·"trace/trace-util.h"

1547

#line·1549·"trace/trace-util.h"

1548

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

1548

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

1550

············qemu_log("lockcnt_futex_wait_prepare·"·"lockcnt·%p·preparing·slow·path·%d->%d"·"\n",·lockcnt,·expected,·new);

1550

············qemu_log("lockcnt_futex_wait_prepare·"·"lockcnt·%p·preparing·slow·path·%d->%d"·"\n",·lockcnt,·expected,·new);

1551

#line·1553·"trace/trace-util.h"

1551

#line·1553·"trace/trace-util.h"

1552

········}

1552

········}

1553

····}

1553

····}

1554

}

1554

}

1555

static·inline·void·trace_lockcnt_futex_wait_prepare(const·void·*·lockcnt,·int·expected,·int·new)

1555

static·inline·void·trace_lockcnt_futex_wait_prepare(const·void·*·lockcnt,·int·expected,·int·new)

1567

static·inline·void·_nocheck__trace_lockcnt_futex_wait(const·void·*·lockcnt,·int·val)

1567

static·inline·void·_nocheck__trace_lockcnt_futex_wait(const·void·*·lockcnt,·int·val)

1568

{

1568

{

1569

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

1569

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

1570

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

1570

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

1571

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

1571

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

1572

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

1572

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

1574

············qemu_log("%d@%zu.%06zu:lockcnt_futex_wait·"·"lockcnt·%p·waiting·on·%d"·"\n",

1574

············qemu_log("%d@%zu.%06zu:lockcnt_futex_wait·"·"lockcnt·%p·waiting·on·%d"·"\n",

1575

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

1575

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

1576

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

1576

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

1577

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

1577

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

1578

#line·1580·"trace/trace-util.h"

1578

#line·1580·"trace/trace-util.h"

1579

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

1579

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

1581

············qemu_log("lockcnt_futex_wait·"·"lockcnt·%p·waiting·on·%d"·"\n",·lockcnt,·val);

1581

············qemu_log("lockcnt_futex_wait·"·"lockcnt·%p·waiting·on·%d"·"\n",·lockcnt,·val);

1582

#line·1584·"trace/trace-util.h"

1582

#line·1584·"trace/trace-util.h"

1583

········}

1583

········}

1584

····}

1584

····}

1585

}

1585

}

1586

static·inline·void·trace_lockcnt_futex_wait(const·void·*·lockcnt,·int·val)

1586

static·inline·void·trace_lockcnt_futex_wait(const·void·*·lockcnt,·int·val)

1598

static·inline·void·_nocheck__trace_lockcnt_futex_wait_resume(const·void·*·lockcnt,·int·new)

1598

static·inline·void·_nocheck__trace_lockcnt_futex_wait_resume(const·void·*·lockcnt,·int·new)

1599

{

1599

{

1600

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

1600

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

1601

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

1601

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

1602

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

1602

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

1603

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

1603

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

1605

············qemu_log("%d@%zu.%06zu:lockcnt_futex_wait_resume·"·"lockcnt·%p·after·wait:·%d"·"\n",

1605

············qemu_log("%d@%zu.%06zu:lockcnt_futex_wait_resume·"·"lockcnt·%p·after·wait:·%d"·"\n",

1606

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

1606

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

1607

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

1607

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

1608

·····················,·lockcnt,·new);

1608

·····················,·lockcnt,·new);

1609

#line·1611·"trace/trace-util.h"

1609

#line·1611·"trace/trace-util.h"

1610

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

1610

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

1612

············qemu_log("lockcnt_futex_wait_resume·"·"lockcnt·%p·after·wait:·%d"·"\n",·lockcnt,·new);

1612

············qemu_log("lockcnt_futex_wait_resume·"·"lockcnt·%p·after·wait:·%d"·"\n",·lockcnt,·new);

1613

#line·1615·"trace/trace-util.h"

1613

#line·1615·"trace/trace-util.h"

1614

········}

1614

········}

1615

····}

1615

····}

1616

}

1616

}

1617

static·inline·void·trace_lockcnt_futex_wait_resume(const·void·*·lockcnt,·int·new)

1617

static·inline·void·trace_lockcnt_futex_wait_resume(const·void·*·lockcnt,·int·new)

1629

static·inline·void·_nocheck__trace_lockcnt_futex_wake(const·void·*·lockcnt)

1629

static·inline·void·_nocheck__trace_lockcnt_futex_wake(const·void·*·lockcnt)

1630

{

1630

{

1631

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

1631

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

1632

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

1632

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

1633

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

1633

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

1634

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

1634

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

1636

············qemu_log("%d@%zu.%06zu:lockcnt_futex_wake·"·"lockcnt·%p·waking·up·one·waiter"·"\n",

1636

············qemu_log("%d@%zu.%06zu:lockcnt_futex_wake·"·"lockcnt·%p·waking·up·one·waiter"·"\n",

1637

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

1637

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

1638

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

1638

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

1639

·····················,·lockcnt);

1639

·····················,·lockcnt);

1640

#line·1642·"trace/trace-util.h"

1640

#line·1642·"trace/trace-util.h"

1641

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

1641

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

1643

············qemu_log("lockcnt_futex_wake·"·"lockcnt·%p·waking·up·one·waiter"·"\n",·lockcnt);

1643

············qemu_log("lockcnt_futex_wake·"·"lockcnt·%p·waking·up·one·waiter"·"\n",·lockcnt);

1644

#line·1646·"trace/trace-util.h"

1644

#line·1646·"trace/trace-util.h"

1645

········}

1645

········}

1646

····}

1646

····}

1647

}

1647

}

1648

static·inline·void·trace_lockcnt_futex_wake(const·void·*·lockcnt)

1648

static·inline·void·trace_lockcnt_futex_wake(const·void·*·lockcnt)

1660

static·inline·void·_nocheck__trace_socket_listen(int·num)

1660

static·inline·void·_nocheck__trace_socket_listen(int·num)

1661

{

1661

{

1662

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

1662

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

1663

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

1663

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

1664

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

1664

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

1665

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

1665

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

1667

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

1667

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

1668

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

1668

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

1669

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

1669

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

1670

·····················,·num);

1670

·····················,·num);

1671

#line·1673·"trace/trace-util.h"

1671

#line·1673·"trace/trace-util.h"

1672

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

1672

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

1674

············qemu_log("socket_listen·"·"backlog:·%d"·"\n",·num);

1674

············qemu_log("socket_listen·"·"backlog:·%d"·"\n",·num);

1675

#line·1677·"trace/trace-util.h"

1675

#line·1677·"trace/trace-util.h"

1676

········}

1676

········}

1677

····}

1677

····}

1678

}

1678

}

1679

static·inline·void·trace_socket_listen(int·num)

1679

static·inline·void·trace_socket_listen(int·num)

1691

static·inline·void·_nocheck__trace_qemu_mutex_lock(void·*·mutex,·const·char·*·file,·const·int·line)

1691

static·inline·void·_nocheck__trace_qemu_mutex_lock(void·*·mutex,·const·char·*·file,·const·int·line)

1692

{

1692

{

1693

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

1693

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

1694

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

1694

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

1695

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

1695

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

1696

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

1696

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

1698

············qemu_log("%d@%zu.%06zu:qemu_mutex_lock·"·"waiting·on·mutex·%p·(%s:%d)"·"\n",

1698

············qemu_log("%d@%zu.%06zu:qemu_mutex_lock·"·"waiting·on·mutex·%p·(%s:%d)"·"\n",

1699

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

1699

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

1700

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

1700

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

1701

·····················,·mutex,·file,·line);

1701

·····················,·mutex,·file,·line);

1702

#line·1704·"trace/trace-util.h"

1702

#line·1704·"trace/trace-util.h"

1703

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

1703

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

1705

············qemu_log("qemu_mutex_lock·"·"waiting·on·mutex·%p·(%s:%d)"·"\n",·mutex,·file,·line);

1705

············qemu_log("qemu_mutex_lock·"·"waiting·on·mutex·%p·(%s:%d)"·"\n",·mutex,·file,·line);

1706

#line·1708·"trace/trace-util.h"

1706

#line·1708·"trace/trace-util.h"

1707

········}

1707

········}

1708

····}

1708

····}

1709

}

1709

}

1710

static·inline·void·trace_qemu_mutex_lock(void·*·mutex,·const·char·*·file,·const·int·line)

1710

static·inline·void·trace_qemu_mutex_lock(void·*·mutex,·const·char·*·file,·const·int·line)

1722

static·inline·void·_nocheck__trace_qemu_mutex_locked(void·*·mutex,·const·char·*·file,·const·int·line)

1722

static·inline·void·_nocheck__trace_qemu_mutex_locked(void·*·mutex,·const·char·*·file,·const·int·line)

1723

{

1723

{

1724

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

1724

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

1725

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

1725

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

1726

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

1726

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

1727

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

1727

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

1729

············qemu_log("%d@%zu.%06zu:qemu_mutex_locked·"·"taken·mutex·%p·(%s:%d)"·"\n",

1729

············qemu_log("%d@%zu.%06zu:qemu_mutex_locked·"·"taken·mutex·%p·(%s:%d)"·"\n",

1730

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

1730

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

1731

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

1731

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

1732

·····················,·mutex,·file,·line);

1732

·····················,·mutex,·file,·line);

1733

#line·1735·"trace/trace-util.h"

1733

#line·1735·"trace/trace-util.h"

1734

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

1734

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

1736

············qemu_log("qemu_mutex_locked·"·"taken·mutex·%p·(%s:%d)"·"\n",·mutex,·file,·line);

1736

············qemu_log("qemu_mutex_locked·"·"taken·mutex·%p·(%s:%d)"·"\n",·mutex,·file,·line);

1737

#line·1739·"trace/trace-util.h"

1737

#line·1739·"trace/trace-util.h"

1738

········}

1738

········}

1739

····}

1739

····}

1740

}

1740

}

1741

static·inline·void·trace_qemu_mutex_locked(void·*·mutex,·const·char·*·file,·const·int·line)

1741

static·inline·void·trace_qemu_mutex_locked(void·*·mutex,·const·char·*·file,·const·int·line)

1753

static·inline·void·_nocheck__trace_qemu_mutex_unlock(void·*·mutex,·const·char·*·file,·const·int·line)

1753

static·inline·void·_nocheck__trace_qemu_mutex_unlock(void·*·mutex,·const·char·*·file,·const·int·line)

1754

{

1754

{

1755

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

1755

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

1756

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

1756

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

1757

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

1757

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

1758

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

1758

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

1760

············qemu_log("%d@%zu.%06zu:qemu_mutex_unlock·"·"released·mutex·%p·(%s:%d)"·"\n",

1760

············qemu_log("%d@%zu.%06zu:qemu_mutex_unlock·"·"released·mutex·%p·(%s:%d)"·"\n",

1761

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

1761

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

1762

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

1762

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

1763

·····················,·mutex,·file,·line);

1763

·····················,·mutex,·file,·line);

1764

#line·1766·"trace/trace-util.h"

1764

#line·1766·"trace/trace-util.h"

1765

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

1765

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

1767

············qemu_log("qemu_mutex_unlock·"·"released·mutex·%p·(%s:%d)"·"\n",·mutex,·file,·line);

1767

············qemu_log("qemu_mutex_unlock·"·"released·mutex·%p·(%s:%d)"·"\n",·mutex,·file,·line);

1768

#line·1770·"trace/trace-util.h"

1768

#line·1770·"trace/trace-util.h"

1769

········}

1769

········}

1770

····}

1770

····}

1771

}

1771

}

1772

static·inline·void·trace_qemu_mutex_unlock(void·*·mutex,·const·char·*·file,·const·int·line)

1772

static·inline·void·trace_qemu_mutex_unlock(void·*·mutex,·const·char·*·file,·const·int·line)

1784

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

1784

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

1785

{

1785

{

1786

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

1786

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

1787

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

1787

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

1788

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

1788

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

1789

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

1789

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

1791

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

1791

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

1792

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

1792

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

1793

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

1793

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

1794

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

1794

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

1795

#line·1797·"trace/trace-util.h"

1795

#line·1797·"trace/trace-util.h"

1796

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

1796

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

1798

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

1798

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

1799

#line·1801·"trace/trace-util.h"

1799

#line·1801·"trace/trace-util.h"

1800

········}

1800

········}

1801

····}

1801

····}

1802

}

1802

}

1803

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

1803

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

1815

static·inline·void·_nocheck__trace_qemu_vfio_ram_block_added(void·*·s,·void·*·p,·size_t·size)

1815

static·inline·void·_nocheck__trace_qemu_vfio_ram_block_added(void·*·s,·void·*·p,·size_t·size)

1816

{

1816

{

1817

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

1817

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

1818

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

1818

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

1819

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

1819

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

1820

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

1820

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

1822

············qemu_log("%d@%zu.%06zu:qemu_vfio_ram_block_added·"·"s·%p·host·%p·size·0x%zx"·"\n",

1822

············qemu_log("%d@%zu.%06zu:qemu_vfio_ram_block_added·"·"s·%p·host·%p·size·0x%zx"·"\n",

1823

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

1823

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

1824

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

1824

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

1825

·····················,·s,·p,·size);

1825

·····················,·s,·p,·size);

1826

#line·1828·"trace/trace-util.h"

1826

#line·1828·"trace/trace-util.h"

1827

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

1827

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

1829

············qemu_log("qemu_vfio_ram_block_added·"·"s·%p·host·%p·size·0x%zx"·"\n",·s,·p,·size);

1829

············qemu_log("qemu_vfio_ram_block_added·"·"s·%p·host·%p·size·0x%zx"·"\n",·s,·p,·size);

1830

#line·1832·"trace/trace-util.h"

1830

#line·1832·"trace/trace-util.h"

1831

········}

1831

········}

1832

····}

1832

····}

1833

}

1833

}

1834

static·inline·void·trace_qemu_vfio_ram_block_added(void·*·s,·void·*·p,·size_t·size)

1834

static·inline·void·trace_qemu_vfio_ram_block_added(void·*·s,·void·*·p,·size_t·size)

1846

static·inline·void·_nocheck__trace_qemu_vfio_ram_block_removed(void·*·s,·void·*·p,·size_t·size)

1846

static·inline·void·_nocheck__trace_qemu_vfio_ram_block_removed(void·*·s,·void·*·p,·size_t·size)

1847

{

1847

{

1848

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

1848

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

1849

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

1849

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

1850

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

1850

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

1851

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

1851

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

1853

············qemu_log("%d@%zu.%06zu:qemu_vfio_ram_block_removed·"·"s·%p·host·%p·size·0x%zx"·"\n",

1853

············qemu_log("%d@%zu.%06zu:qemu_vfio_ram_block_removed·"·"s·%p·host·%p·size·0x%zx"·"\n",

1854

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

1854

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

1855

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

1855

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

1856

·····················,·s,·p,·size);

1856

·····················,·s,·p,·size);

1857

#line·1859·"trace/trace-util.h"

1857

#line·1859·"trace/trace-util.h"

1858

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

1858

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

1860

············qemu_log("qemu_vfio_ram_block_removed·"·"s·%p·host·%p·size·0x%zx"·"\n",·s,·p,·size);

1860

············qemu_log("qemu_vfio_ram_block_removed·"·"s·%p·host·%p·size·0x%zx"·"\n",·s,·p,·size);

1861

#line·1863·"trace/trace-util.h"

1861

#line·1863·"trace/trace-util.h"

1862

········}

1862

········}

1863

····}

1863

····}

1864

}

1864

}

1865

static·inline·void·trace_qemu_vfio_ram_block_removed(void·*·s,·void·*·p,·size_t·size)

1865

static·inline·void·trace_qemu_vfio_ram_block_removed(void·*·s,·void·*·p,·size_t·size)

1877

static·inline·void·_nocheck__trace_qemu_vfio_dump_mapping(void·*·host,·uint64_t·iova,·size_t·size)

1877

static·inline·void·_nocheck__trace_qemu_vfio_dump_mapping(void·*·host,·uint64_t·iova,·size_t·size)

1878

{

1878

{

1879

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

1879

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

1880

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

1880

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

1881

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

1881

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

1882

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

1882

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

1884

············qemu_log("%d@%zu.%06zu:qemu_vfio_dump_mapping·"·"vfio·mapping·%p·to·iova·0x%08"·PRIx64·"·size·0x%zx"·"\n",

1884

············qemu_log("%d@%zu.%06zu:qemu_vfio_dump_mapping·"·"vfio·mapping·%p·to·iova·0x%08"·PRIx64·"·size·0x%zx"·"\n",

1885

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

1885

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

1886

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

1886

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

1887

·····················,·host,·iova,·size);

1887

·····················,·host,·iova,·size);

1888

#line·1890·"trace/trace-util.h"

1888

#line·1890·"trace/trace-util.h"

1889

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

1889

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

1891

············qemu_log("qemu_vfio_dump_mapping·"·"vfio·mapping·%p·to·iova·0x%08"·PRIx64·"·size·0x%zx"·"\n",·host,·iova,·size);

1891

············qemu_log("qemu_vfio_dump_mapping·"·"vfio·mapping·%p·to·iova·0x%08"·PRIx64·"·size·0x%zx"·"\n",·host,·iova,·size);

1892

#line·1894·"trace/trace-util.h"

1892

#line·1894·"trace/trace-util.h"

1893

········}

1893

········}

1894

····}

1894

····}

1895

}

1895

}

1896

static·inline·void·trace_qemu_vfio_dump_mapping(void·*·host,·uint64_t·iova,·size_t·size)

1896

static·inline·void·trace_qemu_vfio_dump_mapping(void·*·host,·uint64_t·iova,·size_t·size)

1908

static·inline·void·_nocheck__trace_qemu_vfio_find_mapping(void·*·s,·void·*·p)

1908

static·inline·void·_nocheck__trace_qemu_vfio_find_mapping(void·*·s,·void·*·p)

1909

{

1909

{

1910

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

1910

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

1911

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

1911

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

1912

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

1912

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

1913

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

1913

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

1915

············qemu_log("%d@%zu.%06zu:qemu_vfio_find_mapping·"·"s·%p·host·%p"·"\n",

1915

············qemu_log("%d@%zu.%06zu:qemu_vfio_find_mapping·"·"s·%p·host·%p"·"\n",

1916

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

1916

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

1917

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

1917

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

1918

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

1918

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

1919

#line·1921·"trace/trace-util.h"

1919

#line·1921·"trace/trace-util.h"

1920

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

1920

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

1922

············qemu_log("qemu_vfio_find_mapping·"·"s·%p·host·%p"·"\n",·s,·p);

1922

············qemu_log("qemu_vfio_find_mapping·"·"s·%p·host·%p"·"\n",·s,·p);

1923

#line·1925·"trace/trace-util.h"

1923

#line·1925·"trace/trace-util.h"

1924

········}

1924

········}

1925

····}

1925

····}

1926

}

1926

}

1927

static·inline·void·trace_qemu_vfio_find_mapping(void·*·s,·void·*·p)

1927

static·inline·void·trace_qemu_vfio_find_mapping(void·*·s,·void·*·p)

1939

static·inline·void·_nocheck__trace_qemu_vfio_new_mapping(void·*·s,·void·*·host,·size_t·size,·int·index,·uint64_t·iova)

1939

static·inline·void·_nocheck__trace_qemu_vfio_new_mapping(void·*·s,·void·*·host,·size_t·size,·int·index,·uint64_t·iova)

1940

{

1940

{

1941

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

1941

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

1942

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

1942

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

1943

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

1943

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

1944

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

1944

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

1946

············qemu_log("%d@%zu.%06zu:qemu_vfio_new_mapping·"·"s·%p·host·%p·size·0x%zx·index·%d·iova·0x%"PRIx64·"\n",

1946

············qemu_log("%d@%zu.%06zu:qemu_vfio_new_mapping·"·"s·%p·host·%p·size·0x%zx·index·%d·iova·0x%"PRIx64·"\n",

1947

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

1947

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

1948

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

1948

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1949

·····················,·s,·host,·size,·index,·iova);

1949

·····················,·s,·host,·size,·index,·iova);

1950

#line·1952·"trace/trace-util.h"

1950

#line·1952·"trace/trace-util.h"

1951

········}·else·{

1951

········}·else·{

1953

············qemu_log("qemu_vfio_new_mapping·"·"s·%p·host·%p·size·0x%zx·index·%d·iova·0x%"PRIx64·"\n",·s,·host,·size,·index,·iova);

1953

············qemu_log("qemu_vfio_new_mapping·"·"s·%p·host·%p·size·0x%zx·index·%d·iova·0x%"PRIx64·"\n",·s,·host,·size,·index,·iova);

1954

#line·1956·"trace/trace-util.h"

1954

#line·1956·"trace/trace-util.h"

1955

········}

1955

········}

1956

····}

1956

····}

1957

}

1957

}

1958

static·inline·void·trace_qemu_vfio_new_mapping(void·*·s,·void·*·host,·size_t·size,·int·index,·uint64_t·iova)

1958

static·inline·void·trace_qemu_vfio_new_mapping(void·*·s,·void·*·host,·size_t·size,·int·index,·uint64_t·iova)

1970

static·inline·void·_nocheck__trace_qemu_vfio_do_mapping(void·*·s,·void·*·host,·uint64_t·iova,·size_t·size)

1970

static·inline·void·_nocheck__trace_qemu_vfio_do_mapping(void·*·s,·void·*·host,·uint64_t·iova,·size_t·size)

1971

{

1971

{

1972

····if·(trace_event_get_state(TRACE_QEMU_VFIO_DO_MAPPING)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1972

····if·(trace_event_get_state(TRACE_QEMU_VFIO_DO_MAPPING)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1973

········if·(message_with_timestamp)·{

1973

········if·(message_with_timestamp)·{

1974

············struct·timeval·_now;

1974

············struct·timeval·_now;

1975

············gettimeofday(&_now,·NULL);

1975

············gettimeofday(&_now,·NULL);

1977

············qemu_log("%d@%zu.%06zu:qemu_vfio_do_mapping·"·"s·%p·host·%p·<->·iova·0x%"PRIx64·"·size·0x%zx"·"\n",

1977

············qemu_log("%d@%zu.%06zu:qemu_vfio_do_mapping·"·"s·%p·host·%p·<->·iova·0x%"PRIx64·"·size·0x%zx"·"\n",

1978

·····················qemu_get_thread_id(),

1978

·····················qemu_get_thread_id(),

1979

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1979

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1980

·····················,·s,·host,·iova,·size);

1980

·····················,·s,·host,·iova,·size);

1981

#line·1983·"trace/trace-util.h"

1981

#line·1983·"trace/trace-util.h"

1982

········}·else·{

1982

········}·else·{

1984

············qemu_log("qemu_vfio_do_mapping·"·"s·%p·host·%p·<->·iova·0x%"PRIx64·"·size·0x%zx"·"\n",·s,·host,·iova,·size);

1984

············qemu_log("qemu_vfio_do_mapping·"·"s·%p·host·%p·<->·iova·0x%"PRIx64·"·size·0x%zx"·"\n",·s,·host,·iova,·size);

1985

#line·1987·"trace/trace-util.h"

1985

#line·1987·"trace/trace-util.h"

1986

········}

1986

········}

1987

····}

1987

····}

1988

}

1988

}

1989

static·inline·void·trace_qemu_vfio_do_mapping(void·*·s,·void·*·host,·uint64_t·iova,·size_t·size)

1989

static·inline·void·trace_qemu_vfio_do_mapping(void·*·s,·void·*·host,·uint64_t·iova,·size_t·size)

2001

static·inline·void·_nocheck__trace_qemu_vfio_dma_map(void·*·s,·void·*·host,·size_t·size,·bool·temporary,·uint64_t·*·iova)

2001

static·inline·void·_nocheck__trace_qemu_vfio_dma_map(void·*·s,·void·*·host,·size_t·size,·bool·temporary,·uint64_t·*·iova)

2002

{

2002

{

2003

····if·(trace_event_get_state(TRACE_QEMU_VFIO_DMA_MAP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2003

····if·(trace_event_get_state(TRACE_QEMU_VFIO_DMA_MAP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2004

········if·(message_with_timestamp)·{

2004

········if·(message_with_timestamp)·{

2005

············struct·timeval·_now;

2005

············struct·timeval·_now;

2006

············gettimeofday(&_now,·NULL);

2006

············gettimeofday(&_now,·NULL);

2008

············qemu_log("%d@%zu.%06zu:qemu_vfio_dma_map·"·"s·%p·host·%p·size·0x%zx·temporary·%d·&iova·%p"·"\n",

2008

············qemu_log("%d@%zu.%06zu:qemu_vfio_dma_map·"·"s·%p·host·%p·size·0x%zx·temporary·%d·&iova·%p"·"\n",

2009

·····················qemu_get_thread_id(),

2009

·····················qemu_get_thread_id(),

2010

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2010

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2011

·····················,·s,·host,·size,·temporary,·iova);

2011

·····················,·s,·host,·size,·temporary,·iova);

2012

#line·2014·"trace/trace-util.h"

2012

#line·2014·"trace/trace-util.h"

2013

········}·else·{

2013

········}·else·{

2015

············qemu_log("qemu_vfio_dma_map·"·"s·%p·host·%p·size·0x%zx·temporary·%d·&iova·%p"·"\n",·s,·host,·size,·temporary,·iova);

2015

············qemu_log("qemu_vfio_dma_map·"·"s·%p·host·%p·size·0x%zx·temporary·%d·&iova·%p"·"\n",·s,·host,·size,·temporary,·iova);

2016

#line·2018·"trace/trace-util.h"

2016

#line·2018·"trace/trace-util.h"

2017

········}

2017

········}

2018

····}

2018

····}

2019

}

2019

}

2020

static·inline·void·trace_qemu_vfio_dma_map(void·*·s,·void·*·host,·size_t·size,·bool·temporary,·uint64_t·*·iova)

2020

static·inline·void·trace_qemu_vfio_dma_map(void·*·s,·void·*·host,·size_t·size,·bool·temporary,·uint64_t·*·iova)

2032

static·inline·void·_nocheck__trace_qemu_vfio_dma_mapped(void·*·s,·void·*·host,·uint64_t·iova,·size_t·size)

2032

static·inline·void·_nocheck__trace_qemu_vfio_dma_mapped(void·*·s,·void·*·host,·uint64_t·iova,·size_t·size)

2033

{

2033

{

2034

····if·(trace_event_get_state(TRACE_QEMU_VFIO_DMA_MAPPED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2034

····if·(trace_event_get_state(TRACE_QEMU_VFIO_DMA_MAPPED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2035

········if·(message_with_timestamp)·{

2035

········if·(message_with_timestamp)·{

2036

············struct·timeval·_now;

2036

············struct·timeval·_now;

2037

············gettimeofday(&_now,·NULL);

2037

············gettimeofday(&_now,·NULL);

2039

············qemu_log("%d@%zu.%06zu:qemu_vfio_dma_mapped·"·"s·%p·host·%p·<->·iova·0x%"PRIx64"·size·0x%zx"·"\n",

2039

············qemu_log("%d@%zu.%06zu:qemu_vfio_dma_mapped·"·"s·%p·host·%p·<->·iova·0x%"PRIx64"·size·0x%zx"·"\n",

2040

·····················qemu_get_thread_id(),

2040

·····················qemu_get_thread_id(),

2041

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2041

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2042

·····················,·s,·host,·iova,·size);

2042

·····················,·s,·host,·iova,·size);

2043

#line·2045·"trace/trace-util.h"

2043

#line·2045·"trace/trace-util.h"

2044

········}·else·{

2044

········}·else·{

2046

············qemu_log("qemu_vfio_dma_mapped·"·"s·%p·host·%p·<->·iova·0x%"PRIx64"·size·0x%zx"·"\n",·s,·host,·iova,·size);

2046

············qemu_log("qemu_vfio_dma_mapped·"·"s·%p·host·%p·<->·iova·0x%"PRIx64"·size·0x%zx"·"\n",·s,·host,·iova,·size);

2047

#line·2049·"trace/trace-util.h"

2047

#line·2049·"trace/trace-util.h"

2048

········}

2048

········}

2049

····}

2049

····}

2050

}

2050

}

2051

static·inline·void·trace_qemu_vfio_dma_mapped(void·*·s,·void·*·host,·uint64_t·iova,·size_t·size)

2051

static·inline·void·trace_qemu_vfio_dma_mapped(void·*·s,·void·*·host,·uint64_t·iova,·size_t·size)

2063

static·inline·void·_nocheck__trace_qemu_vfio_dma_unmap(void·*·s,·void·*·host)

2063

static·inline·void·_nocheck__trace_qemu_vfio_dma_unmap(void·*·s,·void·*·host)

2064

{

2064

{

2065

····if·(trace_event_get_state(TRACE_QEMU_VFIO_DMA_UNMAP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2065

····if·(trace_event_get_state(TRACE_QEMU_VFIO_DMA_UNMAP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2066

········if·(message_with_timestamp)·{

2066

········if·(message_with_timestamp)·{

2067

············struct·timeval·_now;

2067

············struct·timeval·_now;

2068

············gettimeofday(&_now,·NULL);

2068

············gettimeofday(&_now,·NULL);

2070

············qemu_log("%d@%zu.%06zu:qemu_vfio_dma_unmap·"·"s·%p·host·%p"·"\n",

2070

············qemu_log("%d@%zu.%06zu:qemu_vfio_dma_unmap·"·"s·%p·host·%p"·"\n",

2071

·····················qemu_get_thread_id(),

2071

·····················qemu_get_thread_id(),

2072

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2072

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2073

·····················,·s,·host);

2073

·····················,·s,·host);

2074

#line·2076·"trace/trace-util.h"

2074

#line·2076·"trace/trace-util.h"

2075

········}·else·{

2075

········}·else·{

2077

············qemu_log("qemu_vfio_dma_unmap·"·"s·%p·host·%p"·"\n",·s,·host);

2077

············qemu_log("qemu_vfio_dma_unmap·"·"s·%p·host·%p"·"\n",·s,·host);

2078

#line·2080·"trace/trace-util.h"

2078

#line·2080·"trace/trace-util.h"

2079

········}

2079

········}

2080

····}

2080

····}

2081

}

2081

}

2082

static·inline·void·trace_qemu_vfio_dma_unmap(void·*·s,·void·*·host)

2082

static·inline·void·trace_qemu_vfio_dma_unmap(void·*·s,·void·*·host)

2094

static·inline·void·_nocheck__trace_qemu_vfio_pci_read_config(void·*·buf,·int·ofs,·int·size,·uint64_t·region_ofs,·uint64_t·region_size)

2094

static·inline·void·_nocheck__trace_qemu_vfio_pci_read_config(void·*·buf,·int·ofs,·int·size,·uint64_t·region_ofs,·uint64_t·region_size)

2095

{

2095

{

2096

····if·(trace_event_get_state(TRACE_QEMU_VFIO_PCI_READ_CONFIG)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2096

····if·(trace_event_get_state(TRACE_QEMU_VFIO_PCI_READ_CONFIG)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2097

········if·(message_with_timestamp)·{

2097

········if·(message_with_timestamp)·{

2098

············struct·timeval·_now;

2098

············struct·timeval·_now;

2099

············gettimeofday(&_now,·NULL);

2099

············gettimeofday(&_now,·NULL);

2101

············qemu_log("%d@%zu.%06zu:qemu_vfio_pci_read_config·"·"read·cfg·ptr·%p·ofs·0x%x·size·0x%x·(region·addr·0x%"PRIx64"·size·0x%"PRIx64")"·"\n",

2101

············qemu_log("%d@%zu.%06zu:qemu_vfio_pci_read_config·"·"read·cfg·ptr·%p·ofs·0x%x·size·0x%x·(region·addr·0x%"PRIx64"·size·0x%"PRIx64")"·"\n",

2102

·····················qemu_get_thread_id(),

2102

·····················qemu_get_thread_id(),

2103

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2103

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2104

·····················,·buf,·ofs,·size,·region_ofs,·region_size);

2104

·····················,·buf,·ofs,·size,·region_ofs,·region_size);

2105

#line·2107·"trace/trace-util.h"

2105

#line·2107·"trace/trace-util.h"

2106

········}·else·{

2106

········}·else·{

2108

············qemu_log("qemu_vfio_pci_read_config·"·"read·cfg·ptr·%p·ofs·0x%x·size·0x%x·(region·addr·0x%"PRIx64"·size·0x%"PRIx64")"·"\n",·buf,·ofs,·size,·region_ofs,·region_size);

2108

············qemu_log("qemu_vfio_pci_read_config·"·"read·cfg·ptr·%p·ofs·0x%x·size·0x%x·(region·addr·0x%"PRIx64"·size·0x%"PRIx64")"·"\n",·buf,·ofs,·size,·region_ofs,·region_size);

2109

#line·2111·"trace/trace-util.h"

2109

#line·2111·"trace/trace-util.h"

2110

········}

2110

········}

2111

····}

2111

····}

2112

}

2112

}

2113

static·inline·void·trace_qemu_vfio_pci_read_config(void·*·buf,·int·ofs,·int·size,·uint64_t·region_ofs,·uint64_t·region_size)

2113

static·inline·void·trace_qemu_vfio_pci_read_config(void·*·buf,·int·ofs,·int·size,·uint64_t·region_ofs,·uint64_t·region_size)

2125

static·inline·void·_nocheck__trace_qemu_vfio_pci_write_config(void·*·buf,·int·ofs,·int·size,·uint64_t·region_ofs,·uint64_t·region_size)

2125

static·inline·void·_nocheck__trace_qemu_vfio_pci_write_config(void·*·buf,·int·ofs,·int·size,·uint64_t·region_ofs,·uint64_t·region_size)

2126

{

2126

{

2127

····if·(trace_event_get_state(TRACE_QEMU_VFIO_PCI_WRITE_CONFIG)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2127

····if·(trace_event_get_state(TRACE_QEMU_VFIO_PCI_WRITE_CONFIG)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2128

········if·(message_with_timestamp)·{

2128

········if·(message_with_timestamp)·{

2129

············struct·timeval·_now;

2129

············struct·timeval·_now;

2130

············gettimeofday(&_now,·NULL);

2130

············gettimeofday(&_now,·NULL);

2132

············qemu_log("%d@%zu.%06zu:qemu_vfio_pci_write_config·"·"write·cfg·ptr·%p·ofs·0x%x·size·0x%x·(region·addr·0x%"PRIx64"·size·0x%"PRIx64")"·"\n",

2132

············qemu_log("%d@%zu.%06zu:qemu_vfio_pci_write_config·"·"write·cfg·ptr·%p·ofs·0x%x·size·0x%x·(region·addr·0x%"PRIx64"·size·0x%"PRIx64")"·"\n",

2133

·····················qemu_get_thread_id(),

2133

·····················qemu_get_thread_id(),

2134

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2134

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2135

·····················,·buf,·ofs,·size,·region_ofs,·region_size);

2135

·····················,·buf,·ofs,·size,·region_ofs,·region_size);

2136

#line·2138·"trace/trace-util.h"

2136

#line·2138·"trace/trace-util.h"

2137

········}·else·{

2137

········}·else·{

2139

············qemu_log("qemu_vfio_pci_write_config·"·"write·cfg·ptr·%p·ofs·0x%x·size·0x%x·(region·addr·0x%"PRIx64"·size·0x%"PRIx64")"·"\n",·buf,·ofs,·size,·region_ofs,·region_size);

2139

············qemu_log("qemu_vfio_pci_write_config·"·"write·cfg·ptr·%p·ofs·0x%x·size·0x%x·(region·addr·0x%"PRIx64"·size·0x%"PRIx64")"·"\n",·buf,·ofs,·size,·region_ofs,·region_size);

2140

#line·2142·"trace/trace-util.h"

2140

#line·2142·"trace/trace-util.h"

2141

········}

2141

········}

2142

····}

2142

····}

2143

}

2143

}

2144

static·inline·void·trace_qemu_vfio_pci_write_config(void·*·buf,·int·ofs,·int·size,·uint64_t·region_ofs,·uint64_t·region_size)

2144

static·inline·void·trace_qemu_vfio_pci_write_config(void·*·buf,·int·ofs,·int·size,·uint64_t·region_ofs,·uint64_t·region_size)

2156

static·inline·void·_nocheck__trace_qemu_vfio_region_info(const·char·*·desc,·uint64_t·region_ofs,·uint64_t·region_size,·uint32_t·cap_offset)

2156

static·inline·void·_nocheck__trace_qemu_vfio_region_info(const·char·*·desc,·uint64_t·region_ofs,·uint64_t·region_size,·uint32_t·cap_offset)

2157

{

2157

{

2158

····if·(trace_event_get_state(TRACE_QEMU_VFIO_REGION_INFO)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2158

····if·(trace_event_get_state(TRACE_QEMU_VFIO_REGION_INFO)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2159

········if·(message_with_timestamp)·{

2159

········if·(message_with_timestamp)·{

2160

············struct·timeval·_now;

2160

············struct·timeval·_now;

2161

············gettimeofday(&_now,·NULL);

2161

············gettimeofday(&_now,·NULL);

2163

············qemu_log("%d@%zu.%06zu:qemu_vfio_region_info·"·"region·'%s'·addr·0x%"PRIx64"·size·0x%"PRIx64"·cap_ofs·0x%"PRIx32·"\n",

2163

············qemu_log("%d@%zu.%06zu:qemu_vfio_region_info·"·"region·'%s'·addr·0x%"PRIx64"·size·0x%"PRIx64"·cap_ofs·0x%"PRIx32·"\n",

2164

·····················qemu_get_thread_id(),

2164

·····················qemu_get_thread_id(),

2165

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2165

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2166

·····················,·desc,·region_ofs,·region_size,·cap_offset);

2166

·····················,·desc,·region_ofs,·region_size,·cap_offset);

2167

#line·2169·"trace/trace-util.h"

2167

#line·2169·"trace/trace-util.h"

2168

········}·else·{

2168

········}·else·{

2170

············qemu_log("qemu_vfio_region_info·"·"region·'%s'·addr·0x%"PRIx64"·size·0x%"PRIx64"·cap_ofs·0x%"PRIx32·"\n",·desc,·region_ofs,·region_size,·cap_offset);

2170

············qemu_log("qemu_vfio_region_info·"·"region·'%s'·addr·0x%"PRIx64"·size·0x%"PRIx64"·cap_ofs·0x%"PRIx32·"\n",·desc,·region_ofs,·region_size,·cap_offset);

2171

#line·2173·"trace/trace-util.h"

2171

#line·2173·"trace/trace-util.h"

2172

········}

2172

········}

2173

····}

2173

····}

2174

}

2174

}

2175

static·inline·void·trace_qemu_vfio_region_info(const·char·*·desc,·uint64_t·region_ofs,·uint64_t·region_size,·uint32_t·cap_offset)

2175

static·inline·void·trace_qemu_vfio_region_info(const·char·*·desc,·uint64_t·region_ofs,·uint64_t·region_size,·uint32_t·cap_offset)

2187

static·inline·void·_nocheck__trace_qemu_vfio_pci_map_bar(int·index,·uint64_t·region_ofs,·uint64_t·region_size,·int·ofs,·void·*·host)

2187

static·inline·void·_nocheck__trace_qemu_vfio_pci_map_bar(int·index,·uint64_t·region_ofs,·uint64_t·region_size,·int·ofs,·void·*·host)

2188

{

2188

{

2189

····if·(trace_event_get_state(TRACE_QEMU_VFIO_PCI_MAP_BAR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2189

····if·(trace_event_get_state(TRACE_QEMU_VFIO_PCI_MAP_BAR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2190

········if·(message_with_timestamp)·{

2190

········if·(message_with_timestamp)·{

2191

············struct·timeval·_now;

2191

············struct·timeval·_now;

2192

············gettimeofday(&_now,·NULL);

2192

············gettimeofday(&_now,·NULL);

2194

············qemu_log("%d@%zu.%06zu:qemu_vfio_pci_map_bar·"·"map·region·bar#%d·addr·0x%"PRIx64"·size·0x%"PRIx64"·ofs·0x%x·host·%p"·"\n",

2194

············qemu_log("%d@%zu.%06zu:qemu_vfio_pci_map_bar·"·"map·region·bar#%d·addr·0x%"PRIx64"·size·0x%"PRIx64"·ofs·0x%x·host·%p"·"\n",

2195

·····················qemu_get_thread_id(),

2195

·····················qemu_get_thread_id(),

2196

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2196

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2197

·····················,·index,·region_ofs,·region_size,·ofs,·host);

2197

·····················,·index,·region_ofs,·region_size,·ofs,·host);

2198

#line·2200·"trace/trace-util.h"

2198

#line·2200·"trace/trace-util.h"

2199

········}·else·{

2199

········}·else·{

2201

············qemu_log("qemu_vfio_pci_map_bar·"·"map·region·bar#%d·addr·0x%"PRIx64"·size·0x%"PRIx64"·ofs·0x%x·host·%p"·"\n",·index,·region_ofs,·region_size,·ofs,·host);

2201

············qemu_log("qemu_vfio_pci_map_bar·"·"map·region·bar#%d·addr·0x%"PRIx64"·size·0x%"PRIx64"·ofs·0x%x·host·%p"·"\n",·index,·region_ofs,·region_size,·ofs,·host);

2202

#line·2204·"trace/trace-util.h"

2202

#line·2204·"trace/trace-util.h"

2203

········}

2203

········}

2204

····}

2204

····}

2205

}

2205

}

2206

static·inline·void·trace_qemu_vfio_pci_map_bar(int·index,·uint64_t·region_ofs,·uint64_t·region_size,·int·ofs,·void·*·host)

2206

static·inline·void·trace_qemu_vfio_pci_map_bar(int·index,·uint64_t·region_ofs,·uint64_t·region_size,·int·ofs,·void·*·host)

2218

static·inline·void·_nocheck__trace_uffd_query_features_nosys(int·err)

2218

static·inline·void·_nocheck__trace_uffd_query_features_nosys(int·err)

2219

{

2219

{

2220

····if·(trace_event_get_state(TRACE_UFFD_QUERY_FEATURES_NOSYS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2220

····if·(trace_event_get_state(TRACE_UFFD_QUERY_FEATURES_NOSYS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2221

········if·(message_with_timestamp)·{

2221

········if·(message_with_timestamp)·{

2222

············struct·timeval·_now;

2222

············struct·timeval·_now;

2223

············gettimeofday(&_now,·NULL);

2223

············gettimeofday(&_now,·NULL);

2225

············qemu_log("%d@%zu.%06zu:uffd_query_features_nosys·"·"errno:·%i"·"\n",

2225

············qemu_log("%d@%zu.%06zu:uffd_query_features_nosys·"·"errno:·%i"·"\n",

2226

·····················qemu_get_thread_id(),

2226

·····················qemu_get_thread_id(),

2227

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2227

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2228

·····················,·err);

2228

·····················,·err);

2229

#line·2231·"trace/trace-util.h"

2229

#line·2231·"trace/trace-util.h"

2230

········}·else·{

2230

········}·else·{

2232

············qemu_log("uffd_query_features_nosys·"·"errno:·%i"·"\n",·err);

2232

············qemu_log("uffd_query_features_nosys·"·"errno:·%i"·"\n",·err);

2233

#line·2235·"trace/trace-util.h"

2233

#line·2235·"trace/trace-util.h"

2234

········}

2234

········}

2235

····}

2235

····}

2236

}

2236

}

2237

static·inline·void·trace_uffd_query_features_nosys(int·err)

2237

static·inline·void·trace_uffd_query_features_nosys(int·err)

2249

static·inline·void·_nocheck__trace_uffd_query_features_api_failed(int·err)

2249

static·inline·void·_nocheck__trace_uffd_query_features_api_failed(int·err)

2250

{

2250

{

2251

····if·(trace_event_get_state(TRACE_UFFD_QUERY_FEATURES_API_FAILED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2251

····if·(trace_event_get_state(TRACE_UFFD_QUERY_FEATURES_API_FAILED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2252

········if·(message_with_timestamp)·{

2252

········if·(message_with_timestamp)·{

2253

············struct·timeval·_now;

2253

············struct·timeval·_now;

2254

············gettimeofday(&_now,·NULL);

2254

············gettimeofday(&_now,·NULL);

2256

············qemu_log("%d@%zu.%06zu:uffd_query_features_api_failed·"·"errno:·%i"·"\n",

2256

············qemu_log("%d@%zu.%06zu:uffd_query_features_api_failed·"·"errno:·%i"·"\n",

2257

·····················qemu_get_thread_id(),

2257

·····················qemu_get_thread_id(),

2258

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2258

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2259

·····················,·err);

2259

·····················,·err);

2260

#line·2262·"trace/trace-util.h"

2260

#line·2262·"trace/trace-util.h"

2261

········}·else·{

2261

········}·else·{

2263

············qemu_log("uffd_query_features_api_failed·"·"errno:·%i"·"\n",·err);

2263

············qemu_log("uffd_query_features_api_failed·"·"errno:·%i"·"\n",·err);

2264

#line·2266·"trace/trace-util.h"

2264

#line·2266·"trace/trace-util.h"

2265

········}

2265

········}

2266

····}

2266

····}

2267

}

2267

}

2268

static·inline·void·trace_uffd_query_features_api_failed(int·err)

2268

static·inline·void·trace_uffd_query_features_api_failed(int·err)

2280

static·inline·void·_nocheck__trace_uffd_create_fd_nosys(int·err)

2280

static·inline·void·_nocheck__trace_uffd_create_fd_nosys(int·err)

2281

{

2281

{

2282

····if·(trace_event_get_state(TRACE_UFFD_CREATE_FD_NOSYS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2282

····if·(trace_event_get_state(TRACE_UFFD_CREATE_FD_NOSYS)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2283

········if·(message_with_timestamp)·{

2283

········if·(message_with_timestamp)·{

2284

············struct·timeval·_now;

2284

············struct·timeval·_now;

2285

············gettimeofday(&_now,·NULL);

2285

············gettimeofday(&_now,·NULL);

2287

············qemu_log("%d@%zu.%06zu:uffd_create_fd_nosys·"·"errno:·%i"·"\n",

2287

············qemu_log("%d@%zu.%06zu:uffd_create_fd_nosys·"·"errno:·%i"·"\n",

2288

·····················qemu_get_thread_id(),

2288

·····················qemu_get_thread_id(),

2289

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2289

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2290

·····················,·err);

2290

·····················,·err);

2291

#line·2293·"trace/trace-util.h"

2291

#line·2293·"trace/trace-util.h"

2292

········}·else·{

2292

········}·else·{

2294

············qemu_log("uffd_create_fd_nosys·"·"errno:·%i"·"\n",·err);

2294

············qemu_log("uffd_create_fd_nosys·"·"errno:·%i"·"\n",·err);

2295

#line·2297·"trace/trace-util.h"

2295

#line·2297·"trace/trace-util.h"

2296

········}

2296

········}

2297

····}

2297

····}

2298

}

2298

}

2299

static·inline·void·trace_uffd_create_fd_nosys(int·err)

2299

static·inline·void·trace_uffd_create_fd_nosys(int·err)

2311

static·inline·void·_nocheck__trace_uffd_create_fd_api_failed(int·err)

2311

static·inline·void·_nocheck__trace_uffd_create_fd_api_failed(int·err)

2312

{

2312

{

2313

····if·(trace_event_get_state(TRACE_UFFD_CREATE_FD_API_FAILED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2313

····if·(trace_event_get_state(TRACE_UFFD_CREATE_FD_API_FAILED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2314

········if·(message_with_timestamp)·{

2314

········if·(message_with_timestamp)·{

2315

············struct·timeval·_now;

2315

············struct·timeval·_now;

2316

············gettimeofday(&_now,·NULL);

2316

············gettimeofday(&_now,·NULL);

2318

············qemu_log("%d@%zu.%06zu:uffd_create_fd_api_failed·"·"errno:·%i"·"\n",

2318

············qemu_log("%d@%zu.%06zu:uffd_create_fd_api_failed·"·"errno:·%i"·"\n",

2319

·····················qemu_get_thread_id(),

2319

·····················qemu_get_thread_id(),

2320

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2320

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2321

·····················,·err);

2321

·····················,·err);

2322

#line·2324·"trace/trace-util.h"

2322

#line·2324·"trace/trace-util.h"

2323

········}·else·{

2323

········}·else·{

2325

············qemu_log("uffd_create_fd_api_failed·"·"errno:·%i"·"\n",·err);

2325

············qemu_log("uffd_create_fd_api_failed·"·"errno:·%i"·"\n",·err);

2326

#line·2328·"trace/trace-util.h"

2326

#line·2328·"trace/trace-util.h"

2327

········}

2327

········}

2328

····}

2328

····}

2329

}

2329

}

2330

static·inline·void·trace_uffd_create_fd_api_failed(int·err)

2330

static·inline·void·trace_uffd_create_fd_api_failed(int·err)

2342

static·inline·void·_nocheck__trace_uffd_create_fd_api_noioctl(uint64_t·ioctl_req,·uint64_t·ioctl_supp)

2342

static·inline·void·_nocheck__trace_uffd_create_fd_api_noioctl(uint64_t·ioctl_req,·uint64_t·ioctl_supp)

2343

{

2343

{

2344

····if·(trace_event_get_state(TRACE_UFFD_CREATE_FD_API_NOIOCTL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2344

····if·(trace_event_get_state(TRACE_UFFD_CREATE_FD_API_NOIOCTL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2345

········if·(message_with_timestamp)·{

2345

········if·(message_with_timestamp)·{

2346

············struct·timeval·_now;

2346

············struct·timeval·_now;

2347

············gettimeofday(&_now,·NULL);

2347

············gettimeofday(&_now,·NULL);

2349

············qemu_log("%d@%zu.%06zu:uffd_create_fd_api_noioctl·"·"ioctl_req:·0x%"·PRIx64·"ioctl_supp:·0x%"·PRIx64·"\n",

2349

············qemu_log("%d@%zu.%06zu:uffd_create_fd_api_noioctl·"·"ioctl_req:·0x%"·PRIx64·"ioctl_supp:·0x%"·PRIx64·"\n",

2350

·····················qemu_get_thread_id(),

2350

·····················qemu_get_thread_id(),

2351

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2351

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2352

·····················,·ioctl_req,·ioctl_supp);

2352

·····················,·ioctl_req,·ioctl_supp);

2353

#line·2355·"trace/trace-util.h"

2353

#line·2355·"trace/trace-util.h"

2354

········}·else·{

2354

········}·else·{

2356

············qemu_log("uffd_create_fd_api_noioctl·"·"ioctl_req:·0x%"·PRIx64·"ioctl_supp:·0x%"·PRIx64·"\n",·ioctl_req,·ioctl_supp);

2356

············qemu_log("uffd_create_fd_api_noioctl·"·"ioctl_req:·0x%"·PRIx64·"ioctl_supp:·0x%"·PRIx64·"\n",·ioctl_req,·ioctl_supp);

2357

#line·2359·"trace/trace-util.h"

2357

#line·2359·"trace/trace-util.h"

2358

········}

2358

········}

2359

····}

2359

····}

2360

}

2360

}

2361

static·inline·void·trace_uffd_create_fd_api_noioctl(uint64_t·ioctl_req,·uint64_t·ioctl_supp)

2361

static·inline·void·trace_uffd_create_fd_api_noioctl(uint64_t·ioctl_req,·uint64_t·ioctl_supp)

2373

static·inline·void·_nocheck__trace_uffd_register_memory_failed(void·*·addr,·uint64_t·length,·uint64_t·mode,·int·err)

2373

static·inline·void·_nocheck__trace_uffd_register_memory_failed(void·*·addr,·uint64_t·length,·uint64_t·mode,·int·err)

2374

{

2374

{

2375

····if·(trace_event_get_state(TRACE_UFFD_REGISTER_MEMORY_FAILED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2375

····if·(trace_event_get_state(TRACE_UFFD_REGISTER_MEMORY_FAILED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2376

········if·(message_with_timestamp)·{

2376

········if·(message_with_timestamp)·{

2377

············struct·timeval·_now;

2377

············struct·timeval·_now;

2378

············gettimeofday(&_now,·NULL);

2378

············gettimeofday(&_now,·NULL);

2380

············qemu_log("%d@%zu.%06zu:uffd_register_memory_failed·"·"addr:·%p·length:·%"·PRIu64·"·mode:·0x%"·PRIx64·"·errno:·%i"·"\n",

2380

············qemu_log("%d@%zu.%06zu:uffd_register_memory_failed·"·"addr:·%p·length:·%"·PRIu64·"·mode:·0x%"·PRIx64·"·errno:·%i"·"\n",

2381

·····················qemu_get_thread_id(),

2381

·····················qemu_get_thread_id(),

2382

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2382

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2383

·····················,·addr,·length,·mode,·err);

2383

·····················,·addr,·length,·mode,·err);

2384

#line·2386·"trace/trace-util.h"

2384

#line·2386·"trace/trace-util.h"

2385

········}·else·{

2385

········}·else·{

2387

············qemu_log("uffd_register_memory_failed·"·"addr:·%p·length:·%"·PRIu64·"·mode:·0x%"·PRIx64·"·errno:·%i"·"\n",·addr,·length,·mode,·err);

2387

············qemu_log("uffd_register_memory_failed·"·"addr:·%p·length:·%"·PRIu64·"·mode:·0x%"·PRIx64·"·errno:·%i"·"\n",·addr,·length,·mode,·err);

2388

#line·2390·"trace/trace-util.h"

2388

#line·2390·"trace/trace-util.h"

2389

········}

2389

········}

2390

····}

2390

····}

2391

}

2391

}

2392

static·inline·void·trace_uffd_register_memory_failed(void·*·addr,·uint64_t·length,·uint64_t·mode,·int·err)

2392

static·inline·void·trace_uffd_register_memory_failed(void·*·addr,·uint64_t·length,·uint64_t·mode,·int·err)

2404

static·inline·void·_nocheck__trace_uffd_unregister_memory_failed(void·*·addr,·uint64_t·length,·int·err)

2404

static·inline·void·_nocheck__trace_uffd_unregister_memory_failed(void·*·addr,·uint64_t·length,·int·err)

2405

{

2405

{

2406

····if·(trace_event_get_state(TRACE_UFFD_UNREGISTER_MEMORY_FAILED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2406

····if·(trace_event_get_state(TRACE_UFFD_UNREGISTER_MEMORY_FAILED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2407

········if·(message_with_timestamp)·{

2407

········if·(message_with_timestamp)·{

2408

············struct·timeval·_now;

2408

············struct·timeval·_now;

2409

············gettimeofday(&_now,·NULL);

2409

············gettimeofday(&_now,·NULL);

2411

············qemu_log("%d@%zu.%06zu:uffd_unregister_memory_failed·"·"addr:·%p·length:·%"·PRIu64·"·errno:·%i"·"\n",

2411

············qemu_log("%d@%zu.%06zu:uffd_unregister_memory_failed·"·"addr:·%p·length:·%"·PRIu64·"·errno:·%i"·"\n",

2412

·····················qemu_get_thread_id(),

2412

·····················qemu_get_thread_id(),

2413

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2413

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2414

·····················,·addr,·length,·err);

2414

·····················,·addr,·length,·err);

2415

#line·2417·"trace/trace-util.h"

2415

#line·2417·"trace/trace-util.h"

2416

········}·else·{

2416

········}·else·{

2418

············qemu_log("uffd_unregister_memory_failed·"·"addr:·%p·length:·%"·PRIu64·"·errno:·%i"·"\n",·addr,·length,·err);

2418

············qemu_log("uffd_unregister_memory_failed·"·"addr:·%p·length:·%"·PRIu64·"·errno:·%i"·"\n",·addr,·length,·err);

2419

#line·2421·"trace/trace-util.h"

2419

#line·2421·"trace/trace-util.h"

2420

········}

2420

········}

2421

····}

2421

····}

2422

}

2422

}

2423

static·inline·void·trace_uffd_unregister_memory_failed(void·*·addr,·uint64_t·length,·int·err)

2423

static·inline·void·trace_uffd_unregister_memory_failed(void·*·addr,·uint64_t·length,·int·err)

2435

static·inline·void·_nocheck__trace_module_load_module(const·char·*·name)

2435

static·inline·void·_nocheck__trace_module_load_module(const·char·*·name)

2436

{

2436

{

2437

····if·(trace_event_get_state(TRACE_MODULE_LOAD_MODULE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2437

····if·(trace_event_get_state(TRACE_MODULE_LOAD_MODULE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2438

········if·(message_with_timestamp)·{

2438

········if·(message_with_timestamp)·{

2439

············struct·timeval·_now;

2439

············struct·timeval·_now;

2440

············gettimeofday(&_now,·NULL);

2440

············gettimeofday(&_now,·NULL);

2442

············qemu_log("%d@%zu.%06zu:module_load_module·"·"file·%s"·"\n",

2442

············qemu_log("%d@%zu.%06zu:module_load_module·"·"file·%s"·"\n",

2443

·····················qemu_get_thread_id(),

2443

·····················qemu_get_thread_id(),

2444

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2444

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2445

·····················,·name);

2445

·····················,·name);

2446

#line·2448·"trace/trace-util.h"

2446

#line·2448·"trace/trace-util.h"

2447

········}·else·{

2447

········}·else·{

2449

············qemu_log("module_load_module·"·"file·%s"·"\n",·name);

2449

············qemu_log("module_load_module·"·"file·%s"·"\n",·name);

2450

#line·2452·"trace/trace-util.h"

2450

#line·2452·"trace/trace-util.h"

2451

········}

2451

········}

2452

····}

2452

····}

2453

}

2453

}

2454

static·inline·void·trace_module_load_module(const·char·*·name)

2454

static·inline·void·trace_module_load_module(const·char·*·name)

2466

static·inline·void·_nocheck__trace_module_lookup_object_type(const·char·*·name)

2466

static·inline·void·_nocheck__trace_module_lookup_object_type(const·char·*·name)

2467

{

2467

{

2468

····if·(trace_event_get_state(TRACE_MODULE_LOOKUP_OBJECT_TYPE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2468

····if·(trace_event_get_state(TRACE_MODULE_LOOKUP_OBJECT_TYPE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2469

········if·(message_with_timestamp)·{

2469

········if·(message_with_timestamp)·{

2470

············struct·timeval·_now;

2470

············struct·timeval·_now;

2471

············gettimeofday(&_now,·NULL);

2471

············gettimeofday(&_now,·NULL);

2473

············qemu_log("%d@%zu.%06zu:module_lookup_object_type·"·"name·%s"·"\n",

2473

············qemu_log("%d@%zu.%06zu:module_lookup_object_type·"·"name·%s"·"\n",

2474

·····················qemu_get_thread_id(),

2474

·····················qemu_get_thread_id(),

2475

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2475

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2476

·····················,·name);

2476

·····················,·name);

2477

#line·2479·"trace/trace-util.h"

2477

#line·2479·"trace/trace-util.h"

2478

········}·else·{

2478

········}·else·{

2480

············qemu_log("module_lookup_object_type·"·"name·%s"·"\n",·name);

2480

············qemu_log("module_lookup_object_type·"·"name·%s"·"\n",·name);

2481

#line·2483·"trace/trace-util.h"

2481

#line·2483·"trace/trace-util.h"

2482

········}

2482

········}

2483

····}

2483

····}

2484

}

2484

}

2485

static·inline·void·trace_module_lookup_object_type(const·char·*·name)

2485

static·inline·void·trace_module_lookup_object_type(const·char·*·name)